solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1111;
int n, r[max_n], c[max_n];
vector<pair<int, int> > sol_row, sol_col;
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> r[i] >> c[i];
r[i]--, c[i]--;
}
for (int col = 0; col < n - 1; col++) {
int idx = -1, mini = n;
for (int i = 0; i < n - 1; i++)
if (c[i] >= col && r[i] < mini) mini = r[i], idx = c[i];
if (idx == -1) break;
for (int i = 0; i < n - 1; i++)
if (c[i] == idx)
c[i] = col;
else if (c[i] == col)
c[i] = idx;
if (idx != col) sol_col.push_back(make_pair(idx + 1, col + 1));
}
for (int row = n - 1; row > 0; row--) {
int idx = -1, maxi = -1;
for (int i = 0; i < n - 1; i++)
if (r[i] <= row && c[i] > maxi) maxi = c[i], idx = r[i];
if (idx == -1) break;
for (int i = 0; i < n - 1; i++)
if (r[i] == idx)
r[i] = row;
else if (r[i] == row)
r[i] = idx;
if (idx != row) sol_row.push_back(make_pair(idx + 1, row + 1));
}
cout << sol_row.size() + sol_col.size() << endl;
for (int i = 0; i < sol_col.size(); i++)
cout << "2 " << sol_col[i].first << " " << sol_col[i].second << endl;
for (int i = 0; i < sol_row.size(); i++)
cout << "1 " << sol_row[i].first << " " << sol_row[i].second << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long lame = (long long)1e9 + 7;
using namespace std;
int amount;
long long now;
int need[100005];
int each_drinks;
int cost[100005];
priority_queue<int, vector<int>, greater<int> > wait_row;
int main() {
scanf("%d %lld", &amount, &now);
for (int i = 1; i <= amount; i++) scanf("%d", &need[i]);
scanf("%d", &each_drinks);
for (int i = 1; i <= amount; i++) scanf("%d", &cost[i]);
while (!wait_row.empty()) wait_row.pop();
bool found = true;
long long cost_lost = 0;
for (int i = 1; i <= amount; i++) {
wait_row.push(cost[i]);
while (!wait_row.empty() && now < need[i]) {
cost_lost += wait_row.top();
wait_row.pop();
now += each_drinks;
}
if (wait_row.empty() && now < need[i]) {
found = false;
break;
}
}
if (found)
printf("%lld", cost_lost);
else
printf("-1");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int MAX = 2e6 + 5;
const long long int INF = 2e18;
void print(bool a[]) {
for (long long int i = 0; i < (4); ++i) {
if (a[i])
cout << "Ya ";
else
cout << "Tidak ";
}
cout << endl;
}
void solve() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int sgn = a + b;
bool ans[4] = {false};
if (sgn % 2 == 0) {
if ((b + c)) ans[2] = 1;
if ((a + d)) ans[3] = 1;
} else {
if ((b + c)) ans[1] = 1;
if ((a + d)) ans[0] = 1;
}
print(ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
clock_t start, end;
start = clock();
int t;
t = 1;
cin >> t;
while (t--) solve();
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
clog << "Time taken by program is : " << fixed << time_taken
<< setprecision(5);
clog << " sec " << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
int64_t Q;
cin >> Q;
while (Q-- > 0) {
int64_t n;
cin >> n;
vector<int64_t> v(n);
for (int64_t i = 0; i < n; ++i) cin >> v[i];
sort(v.rbegin(), v.rend());
for (int64_t i = 0; i < n; ++i) {
cout << v[i] << ' ';
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char str[500005];
string get(string s, int remove) {
int n = (int)s.size();
return s.substr(0, n - remove);
}
int main() {
int n;
scanf("%d", &n);
vector<string> v;
for (int i = (int)0; i <= (int)n - 1; ++i) {
scanf("%s", str);
v.push_back(str);
}
for (int i = (int)n - 2; i >= (int)0; --i) {
if (v[i] > v[i + 1]) {
string s = v[i];
int l = 0, r = (int)v[i].size() + 1;
while (r - l > 1) {
int mid = (r + l) >> 1;
string S = get(v[i], mid);
if (S <= v[i + 1])
r = mid, s = S;
else
l = mid;
}
v[i] = s;
}
}
for (int i = (int)0; i <= (int)n - 1; ++i) puts(v[i].c_str());
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3100, M = 310;
int n, m;
double f[M][N], tmp[N], delt[M], p[N][M], ans;
void upd(int x) {
for (int j = 0; j <= n; ++j) tmp[j] = f[x][j], f[x][j] = 0;
for (int j = 1; j <= n; ++j)
f[x][j] = tmp[j - 1] * p[j][x] + f[x][j - 1] * (1 - p[j][x]);
delt[x] -= f[x][n];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1, x; j <= m; ++j) scanf("%lf", &p[i][j]), p[i][j] /= 1000.0;
for (int i = 1; i <= m; ++i) {
f[i][0] = 1;
for (int j = 1; j <= n; ++j) f[i][j] = f[i][j - 1] * (1 - p[j][i]);
delt[i] = 1.0 - f[i][n];
}
for (int i = 1; i <= n; ++i) {
int tar = 0;
for (int j = 1; j <= m; ++j)
if (delt[tar] < delt[j]) tar = j;
if (!tar) break;
ans += delt[tar];
upd(tar);
}
printf("%.12lf", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3;
int sum[MAXN + 2 + 10][MAXN + 2 + 10];
int n, m, sx = -1, sy = -1, tot = 0;
bool canGo(int cx, int cy, int w, int h) {
return (cx + w - 1 <= m && cy + h - 1 <= n &&
sum[cy + h - 1][cx + w - 1] - sum[cy + h - 1][cx - 1] -
sum[cy - 1][cx + w - 1] + sum[cy - 1][cx - 1] ==
w * h);
}
bool solve(int w, int h) {
int cx = sx, cy = sy, ctot = w * h;
bool down, right;
while (ctot < tot) {
down = canGo(cx, cy + 1, w, h);
right = canGo(cx + 1, cy, w, h);
if (down && right) {
return false;
}
if (!down && !right) {
return false;
}
if (down) {
ctot += w;
cy += 1;
} else if (right) {
ctot += h;
cx += 1;
}
}
return true;
}
int main() {
std::ios::sync_with_stdio(false);
int maxx = 0, maxy = 0, res = 1e9;
bool biggermaxx = false, biggermaxy = false;
char c;
cin >> n >> m;
for (int i = 0; i <= n; ++i) {
sum[i][0] = 0;
}
for (int i = 0; i <= m; ++i) {
sum[0][i] = 0;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> c;
sum[i][j] =
sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + (c == 'X');
if (c == 'X') {
tot += 1;
}
if (c == 'X' && sx == -1) {
sy = i;
sx = j;
biggermaxx = true;
biggermaxy = true;
}
if (biggermaxx && i == sy) {
if (c == 'X') {
maxx += 1;
} else {
biggermaxx = false;
}
}
if (biggermaxy && j == sx) {
if (c == 'X') {
maxy += 1;
} else {
biggermaxy = false;
}
}
}
}
for (int i = 1; i <= maxx; ++i) {
if (solve(i, maxy)) {
res = min(res, i * maxy);
}
}
for (int i = 1; i <= maxy; ++i) {
if (solve(maxx, i)) {
res = min(res, maxx * i);
}
}
if (res == 1e9) {
cout << -1 << "\n";
} else {
cout << res << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n, k;
string a[1005];
int main() {
cin >> t;
while (t--) {
int s[30] = {0};
int sum = 0, flag = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i].size();
for (int j = 0; j < a[i].size(); j++) {
int t = a[i][j] - 'a';
s[t]++;
}
}
if (sum % n != 0) {
cout << "NO" << endl;
continue;
}
for (int i = 0; i <= 26; i++) {
if (s[i] % n != 0) flag = 1;
}
if (flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,fma")
using namespace std;
template <typename T>
using vc = vector<T>;
template <typename T>
using uset = unordered_set<T>;
template <typename A, typename B>
using umap = unordered_map<A, B>;
template <typename T, typename Comp = less<T>>
using pq = priority_queue<T, vc<T>, Comp>;
template <typename T>
using minpq = pq<T, greater<T>>;
using ld = long double;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using ppi = pair<pii, int>;
using pip = pair<int, pii>;
using vi = vc<int>;
using vii = vc<pii>;
constexpr char el = '\n';
constexpr char sp = ' ';
constexpr int INF = 0x3f3f3f3f;
constexpr ll LLINF = 0x3f3f3f3f3f3f3f3fLL;
int k;
string s;
vi a{-1};
ll evan(ll x) { return x * (x + 1) / 2; }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed;
cin >> k >> s;
for (int i = 0; i < s.size(); ++i)
if (s[i] == '1') a.push_back(i);
a.push_back(s.size());
ll ans = 0;
if (k == 0) {
for (int i = 1; i < a.size(); ++i) ans += evan(a[i] - a[i - 1] - 1);
cout << ans;
exit(0);
}
int l = 1, r = k;
while (r + 1 < a.size()) {
ll A = a[l] - a[l - 1];
ll B = a[r + 1] - a[r];
ans += A * B;
++l, ++r;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010234;
long long w[maxn];
int n;
struct Tblock {
int size, bel[maxn];
pair<long long, int> a[maxn];
long long fl[maxn];
int tt[maxn], ww[maxn];
;
inline int L(int x) { return (x - 1) * size + 1; }
inline int R(int x) { return ((x * size) < (n) ? (x * size) : (n)); }
void reset(int x) {
for (int i = L(x); i <= R(x); i++) {
w[i] += fl[x];
a[i].first = w[i];
a[i].second = i;
}
fl[x] = 0;
sort(a + L(x), a + R(x) + 1);
int last = 0;
for (int i = L(x); i <= R(x); i++) {
if (a[last].first != a[i].first) {
tt[i] = a[i].second;
if (last) ww[last] = a[i - 1].second;
last = i;
}
}
ww[last] = a[R(x)].second;
}
void build() {
size = (((int)sqrt(n)) > (500) ? ((int)sqrt(n)) : (500));
for (int i = 1; i <= n; i++) bel[i] = (i - 1) / size + 1;
for (int i = 1; i <= bel[n]; i++) reset(i);
}
void modify(int l, int r, int x) {
int ans = 0;
for (int i = l; i <= ((bel[l] * size) < (r) ? (bel[l] * size) : (r)); i++)
w[i] += x;
reset(bel[l]);
if (bel[l] != bel[r]) {
for (int i = (bel[r] - 1) * size + 1; i <= r; i++) w[i] += x;
reset(bel[r]);
}
for (int i = bel[l] + 1; i <= bel[r] - 1; i++) fl[i] += x;
}
int query(int y) {
pair<long long, int> xx = {y, 0};
long long l = n + 1, r = 0;
for (int i = 1; i <= bel[n]; i++) {
pair<long long, int> x = xx;
x.first -= fl[i];
int asd = lower_bound(a + L(i), a + R(i) + 1, x) - a;
if (asd >= L(i) && asd <= R(i) && a[asd].first + fl[i] == y) {
l = ((l) < (tt[asd]) ? (l) : (tt[asd]));
r = ((r) > (ww[asd]) ? (r) : (ww[asd]));
l = ((l) < (r) ? (l) : (r));
r = ((l) > (r) ? (l) : (r));
}
}
if (l > r) return -1;
return r - l;
}
} block;
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%I64d", &w[i]);
block.build();
for (int i = 1; i <= m; i++) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
block.modify(a, b, c);
} else {
int x;
scanf("%d", &x);
printf("%d\n", block.query(x));
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char a[5005];
int n;
long long dp[5005][5005];
int main() {
long long ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf(" %c", &a[i]);
bool flag = 0;
dp[0][0] = 1;
dp[0][1] = 1;
for (int i = 1; i <= n; i++) {
for (int lvl = n; lvl >= 1; lvl--) {
if (!flag) {
dp[i][lvl] = dp[i - 1][lvl] + dp[i][lvl + 1];
dp[i][lvl] %= 1000000007;
} else {
dp[i][lvl] = dp[i - 1][lvl - 1];
}
}
if (a[i] == 'f')
flag = 1;
else
flag = 0;
}
for (int i = 1; i <= n; i++) {
ans += dp[n][i];
ans %= 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[200020];
long long va[200020];
long long b[200020];
long long c[200020];
char ans[200020];
char ansstring[200020];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
va[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
c[i] = va[b[i]];
}
char ch = 'a';
for (int i = 1; i <= n; i++) {
long long reach = c[i];
if (ch > 'z') {
ch--;
}
for (int j = i; j <= reach; j++) {
reach = max(reach, c[j]);
ans[j] = ch;
}
i = reach;
ch++;
}
if (ch - 'a' < k) {
cout << "NO";
return 0;
}
for (int i = 1; i <= n; i++) {
ansstring[b[i]] = ans[i];
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
cout << ansstring[i];
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[2000000];
int main() {
int t;
cin >> t;
while (t--) {
string a, b, c;
cin >> a >> b >> c;
int flag = 1;
for (int i = 0; i < a.length(); i++) {
if (a[i] != c[i] and b[i] != c[i]) {
flag = 0;
break;
}
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, p2[10], p3[10];
long long a[10];
int f[10][10][6666], g[10][444], ans, OR[6666][444], r32[6666],
cost[1000000 + 10], prime[1000000 + 10], kA[10], s[444];
int bit2(int mask, int x) { return (mask >> x) % 2; }
int bit3(int mask, int x) { return (mask / p3[x]) % 3; }
void set2(int &mask, int x, int val) {
if (val == 1)
mask |= p2[x];
else
mask &= (p2[n] - 1 - p2[x]);
}
void set3(int &mask, int x, int val) {
mask = ((mask / p3[x + 1]) * 3 + val) * p3[x] + (mask % p3[x]);
}
void upd(int i, int j, int mask, int val) {
if (j == n) {
int x = r32[mask];
if ((g[i][x] == -1) || (val < g[i][x])) g[i][x] = val;
return;
}
if ((f[i][j][mask] == -1) || (val < f[i][j][mask])) f[i][j][mask] = val;
}
long long gcd(long long x, long long y) {
while ((x > 0) && (y > 0))
if (x > y)
x %= y;
else
y %= x;
return x + y;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
p3[0] = 1;
for (int i = 1; i <= n; i++) p3[i] = p3[i - 1] * 3;
p2[0] = 1;
for (int i = 1; i <= n; i++) p2[i] = p2[i - 1] * 2;
s[0] = 0;
for (int i = 1; i < p2[n]; i++) s[i] = 1000000000;
for (int i = 1; i <= 1000000; i++) prime[i] = i;
for (int i = 2; i <= 1000000; i++)
if (prime[i] == i)
for (int j = i + i; j <= 1000000; j += i) prime[j] = i;
cost[1] = 0;
for (int i = 2; i <= 1000000; i++) cost[i] = cost[i / prime[i]] + 1;
for (int mask = 0; mask < p3[n]; mask++) {
int m2 = 0;
for (int i = 0; i < n; i++)
if (bit3(mask, i) != 0) set2(m2, i, 1);
r32[mask] = m2;
}
for (int mask1 = 0; mask1 < p3[n]; mask1++)
for (int mask2 = 0; mask2 < p2[n]; mask2++) {
int newmask = mask1;
for (int i = 0; i < n; i++)
if ((bit2(mask2, i) != 0) && (bit3(newmask, i) == 0))
set3(newmask, i, 1);
OR[mask1][mask2] = newmask;
}
for (int i = 0; i < n; i++) {
long long x = a[i];
int kr = 0;
for (long long t = 2; t * t <= a[i]; t++)
while (x % t == 0) {
x /= t;
kr++;
}
if (x != 1) kr++;
kA[i] = kr;
}
memset(f, -1, sizeof(f));
memset(g, -1, sizeof(g));
for (int i = 0; i < n; i++) {
if (kA[i] == 1) {
g[i][1 << i] = 1;
continue;
}
for (int mask = 0; mask < p2[n]; mask++) {
if ((mask & (1 << i)) != 0) continue;
long long x = a[i];
int m2 = 0;
for (int j = 0; j < n; j++)
if (bit2(mask, j) == 1) {
set3(m2, j, 2);
if (x % a[j] != 0) {
x = -1;
break;
}
x /= a[j];
}
if (x < 0) continue;
set3(m2, i, 1);
int kr;
if (x <= 1000000)
kr = cost[x];
else
kr = kA[i] - cost[a[i] / x];
f[i][0][m2] = kr + 1;
}
for (int j = 0; j < n; j++)
for (int mask = 0; mask < p3[n]; mask++)
if (f[i][j][mask] != -1) {
if (bit3(mask, j) != 2) {
upd(i, j + 1, mask, f[i][j][mask]);
continue;
}
for (int mask2 = 0; mask2 < p2[n]; mask2++)
if (g[j][mask2] != -1)
upd(i, j + 1, OR[mask][mask2], f[i][j][mask] + g[j][mask2]);
}
}
ans = 1000000000;
for (int i = 0; i < n; i++)
for (int mask = 0; mask < p2[n]; mask++)
if (g[i][mask] != -1) {
int cr = g[i][mask];
for (int mask2 = p2[n] - 1; mask2 >= 0; mask2--)
if ((s[mask2] != -1) && (s[mask2] + g[i][mask] < s[mask2 | mask]))
s[mask2 | mask] = s[mask2] + g[i][mask];
}
long long x = 1;
for (int i = 0; i < n - 1; i++) {
if ((a[n - 1] % x != 0) || (a[n - 1] % a[i] != 0)) {
x = -1;
break;
}
x = (x / gcd(x, a[i])) * a[i];
}
int ans = s[p2[n] - 1] + 1;
if ((x > 0) && (g[n - 1][p2[n] - 1] != -1) && (g[n - 1][p2[n] - 1] < ans))
ans = g[n - 1][p2[n] - 1];
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (1e9 + 7);
const long long inf = (1e18 + 3);
const long long N = 1e3 + 2;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long res = inf;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, d;
cin >> n >> d;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (long long i = 0, j = 0; i < n; i++) {
while (arr[i] - arr[j] > d) j++;
res = min(j + n - i - 1, res);
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
vector<vector<long long> > ans;
vector<bool> visited(9, 0);
bool check(long long b) {
while (b != 0) {
if (visited[b % 10] == 1) return 1;
b = b / 10;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
long long n, b, count = 0;
cin >> n;
b = n;
while (b != 0) {
visited[b % 10] = 1;
b = b / 10;
}
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (check(i)) count++;
if (n / i != i)
if (check(n / i)) count++;
}
}
cout << count;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long sum, n, m, s, k;
while (cin >> n >> m >> s) {
if (n > m) {
m ^= n;
n ^= m;
m ^= n;
}
if (s >= m) {
cout << (unsigned long long)m * n << endl;
continue;
}
k = (m - ((m - 1) / s) * s) * (n - ((n - 1) / s) * s);
sum = (((m - 1) / s + 1) * ((n - 1) / s + 1));
sum *= k;
cout << sum << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 20;
unsigned long long bit[N][20], ans, s;
int main() {
int n, k, a;
cin >> n >> k;
for (int x = 1; x < N; x += x & (-x)) bit[x][0]++;
for (int i = 0; i < n; i++) {
cin >> a;
for (int j = k + 1; j > 0; j--) {
s = 0;
for (int x = a; x > 0; x -= x & (-x)) s += bit[x][j - 1];
for (int x = a; x < N; x += x & (-x)) bit[x][j] += s;
}
}
for (int x = n; x > 0; x -= x & (-x)) ans += bit[x][k + 1];
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[3000][3000];
int maxn;
int d;
int ans = 0;
void bfs(int u) {
queue<int> q;
q.push(1);
while (!q.empty()) {
int u = q.front();
int k = u * 2;
int e = u * 2 + 1;
if (k <= maxn) {
cin >> d;
a[u][k] = d;
q.push(k);
}
if (e <= maxn) {
cin >> d;
a[u][e] = d;
q.push(e);
}
q.pop();
}
}
int dfs(int u) {
int sum = 0;
int q = 0, w = 0;
int j = 0;
int flag = 0;
for (int i = 1; i <= maxn; i++) {
if (a[u][i] != 0) {
if (flag == 0) {
q = a[u][i] + dfs(i);
flag = 1;
} else {
w = a[u][i] + dfs(i);
}
}
}
if (q == 0 && w == 0) {
return 0;
}
if (q > w) {
ans += q - w;
return q;
} else {
ans += w - q;
return w;
}
return 0;
}
int main() {
int n;
cin >> n;
int x = (1 << (n + 1)) - 2;
maxn = x + 1;
bfs(1);
dfs(1);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &first) {
char ch;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-';) ch = getchar();
first = 0;
int t = 1;
if (ch == '-') {
ch = getchar();
t = -1;
}
for (; ch >= '0' && ch <= '9'; ch = getchar()) first = first * 10 + ch - '0';
first *= t;
}
const int P = 320;
const int N = 100010;
vector<int> c[N], d[N], e[N];
char s[N], a[N];
int n, m, q[N], s1[N], s2[N + P], f[N], bg[N], l[N];
long long ans[N], g[N];
struct trie {
int ch[26], fail;
vector<int> tag;
} tree[N];
struct ques {
int l, r, first;
} b[N];
void build() {
int f = 1, r = 0;
for (int i = 0; i < 26; i++)
if (tree[0].ch[i]) q[++r] = tree[0].ch[i];
while (f <= r) {
int u = q[f++];
for (int i = 0; i < 26; i++) {
int v = tree[u].ch[i];
if (!v) {
tree[u].ch[i] = tree[tree[u].fail].ch[i];
continue;
}
q[++r] = v;
tree[v].fail = tree[tree[u].fail].ch[i];
}
}
for (int i = 1; i <= m; i++) e[tree[i].fail].push_back(i);
}
void add(int k, int d) {
for (int i = k / P + 1; i <= n / P + 1; i++) s1[i] += d;
for (int i = k; i < (k / P + 1) * P; i++) s2[i] += d;
}
int query(int k) { return s1[k / P] + s2[k]; }
void dfs1(int k) {
for (vector<int>::iterator p = e[k].begin(); p != e[k].end(); p++) {
dfs1(*p);
f[k] += f[*p];
}
for (vector<int>::iterator p = tree[k].tag.begin(); p != tree[k].tag.end();
p++)
g[*p] = f[k];
}
void dfs2(int k) {
for (vector<int>::iterator p = tree[k].tag.begin(); p != tree[k].tag.end();
p++)
add(*p, 1);
for (vector<int>::iterator p = d[k].begin(); p != d[k].end(); p++)
for (vector<int>::iterator q = c[*p].begin(); q != c[*p].end(); q++)
ans[*q] += query(b[*q].r) - query(b[*q].l - 1);
for (vector<int>::iterator p = e[k].begin(); p != e[k].end(); p++) dfs2(*p);
for (vector<int>::iterator p = tree[k].tag.begin(); p != tree[k].tag.end();
p++)
add(*p, -1);
}
int main() {
int q;
read(n);
read(q);
bg[1] = m = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", a + 1);
l[i] = strlen(a + 1);
for (int j = 1; j <= l[i]; j++) s[bg[i] + j] = a[j];
int k = 0;
bg[i + 1] = bg[i] + l[i];
for (int j = 1; j <= l[i]; j++) {
if (!tree[k].ch[a[j] - 97]) tree[k].ch[a[j] - 97] = ++m;
k = tree[k].ch[a[j] - 97];
}
tree[k].tag.push_back(i);
}
build();
for (int i = 1; i <= q; i++) {
read(b[i].l);
read(b[i].r);
read(b[i].first);
c[b[i].first].push_back(i);
}
for (int i = 1; i <= n; i++)
if (l[i] > P) {
memset(f, 0, (m + 1) * sizeof(int));
int k = 0;
for (int j = 1; j <= l[i]; j++) {
k = tree[k].ch[s[j + bg[i]] - 97];
f[k]++;
}
memset(g + 1, 0, n * sizeof(long long));
dfs1(0);
for (int j = 2; j <= n; j++) g[j] += g[j - 1];
for (vector<int>::iterator p = c[i].begin(); p != c[i].end(); p++)
ans[*p] = g[b[*p].r] - g[b[*p].l - 1];
} else {
int k = 0;
for (int j = 1; j <= l[i]; j++) {
k = tree[k].ch[s[j + bg[i]] - 97];
d[k].push_back(i);
}
}
dfs2(0);
for (int i = 1; i <= q; i++) printf("%I64d\n", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int INF = 1e7 + 10;
struct node {
int Value, Priority, Size, Count;
node *LeftChild, *RightChild;
node() {
Value = Priority = Size = Count = 0;
LeftChild = RightChild = NULL;
return;
}
node(int _Value) {
Value = _Value;
Priority = rand();
Size = Count = 1;
LeftChild = RightChild = NULL;
return;
}
inline void Update();
};
struct noneRotateTreap {
node *Root;
noneRotateTreap() {
Root = NULL;
return;
}
inline std::pair<node *, node *> Split(node *Rt, int x);
inline node *Merge(node *x, node *y);
inline node *Find(int x);
inline void Update(int x, int State);
inline void Insert(int x);
inline int Delete(int x);
inline int Rank(int x);
inline int Query(int x);
inline int Precursor(int x);
inline int Successor(int x);
void Dfs(node *Rt);
void Debug();
};
inline void node::Update() {
Size = Count;
if (LeftChild != NULL) Size += LeftChild->Size;
if (RightChild != NULL) Size += RightChild->Size;
return;
}
inline std::pair<node *, node *> noneRotateTreap::Split(node *Rt, int x) {
if (Rt == NULL) return std::pair<node *, node *>(NULL, NULL);
if (x < Rt->Value) {
std::pair<node *, node *> Temp = Split(Rt->LeftChild, x);
Rt->LeftChild = Temp.second;
Rt->Update();
return std::pair<node *, node *>(Temp.first, Rt);
} else {
std::pair<node *, node *> Temp = Split(Rt->RightChild, x);
Rt->RightChild = Temp.first;
Rt->Update();
return std::pair<node *, node *>(Rt, Temp.second);
}
}
inline node *noneRotateTreap::Merge(node *l, node *r) {
if (l == NULL) return r;
if (r == NULL) return l;
if (l->Priority <= r->Priority) {
l->RightChild = Merge(l->RightChild, r);
l->Update();
return l;
} else {
r->LeftChild = Merge(l, r->LeftChild);
r->Update();
return r;
}
}
inline node *noneRotateTreap::Find(int x) {
node *Rt = Root;
while (Rt) {
if (Rt->Value == x) return Rt;
if (x < Rt->Value)
Rt = Rt->LeftChild;
else
Rt = Rt->RightChild;
}
return NULL;
}
inline void noneRotateTreap::Update(int x, int State) {
node *Rt = Root;
while (Rt) {
Rt->Size += State;
if (Rt->Value == x) {
Rt->Count += State;
return;
}
if (x < Rt->Value)
Rt = Rt->LeftChild;
else
Rt = Rt->RightChild;
}
return;
}
inline void noneRotateTreap::Insert(int x) {
node *T = Find(x);
if (T != NULL) {
Update(x, 1);
return;
}
std::pair<node *, node *> Temp = Split(Root, x);
Temp.first = Merge(Temp.first, new node(x));
Root = Merge(Temp.first, Temp.second);
return;
}
inline int noneRotateTreap::Delete(int x) {
node *T = Find(x);
if (T == NULL) return 1;
if (T->Count > 1) {
Update(x, -1);
return 0;
}
std::pair<node *, node *> Temp1 = Split(Root, x - 1);
std::pair<node *, node *> Temp2 = Split(Temp1.second, x);
delete Temp2.first;
Root = Merge(Temp1.first, Temp2.second);
return 0;
}
inline int noneRotateTreap::Rank(int x) {
node *Rt = Root;
int Ans = 0;
while (Rt) {
if (Rt->Value == x)
return Ans + (Rt->LeftChild ? Rt->LeftChild->Size : 0) + 1;
if (x < Rt->Value)
Rt = Rt->LeftChild;
else
Ans += (Rt->LeftChild ? Rt->LeftChild->Size : 0) + Rt->Count,
Rt = Rt->RightChild;
}
return Ans + 1;
}
inline int noneRotateTreap::Query(int x) {
node *Rt = Root;
while (Rt) {
if ((Rt->LeftChild ? Rt->LeftChild->Size : 0) < x &&
x <= (Rt->LeftChild ? Rt->LeftChild->Size : 0) + Rt->Count)
return Rt->Value;
if (x <= (Rt->LeftChild ? Rt->LeftChild->Size : 0))
Rt = Rt->LeftChild;
else
x -= (Rt->LeftChild ? Rt->LeftChild->Size : 0) + Rt->Count,
Rt = Rt->RightChild;
}
return 0;
}
inline int noneRotateTreap::Precursor(int x) {
int Ans = INF;
node *Rt = Root;
while (Rt) {
if (Rt->Value < x)
Ans = Rt->Value, Rt = Rt->RightChild;
else
Rt = Rt->LeftChild;
}
return Ans;
}
inline int noneRotateTreap::Successor(int x) {
int Ans = -INF;
node *Rt = Root;
while (Rt) {
if (Rt->Value > x)
Ans = Rt->Value, Rt = Rt->LeftChild;
else
Rt = Rt->RightChild;
}
return Ans;
}
void noneRotateTreap::Debug() {
Dfs(Root);
printf("\n");
return;
}
void noneRotateTreap::Dfs(node *T) {
if (T == NULL) return;
Dfs(T->LeftChild);
for (int i = 1; i <= T->Count; ++i) printf("%d ", T->Value);
Dfs(T->RightChild);
return;
}
const int Maxn = 200010;
struct edge {
int To, Next;
edge() {}
edge(int _To, int _Next) : To(_To), Next(_Next) {}
};
edge Edge[Maxn << 1];
int Start[Maxn], Used;
int Num, N, Q, Type, Last, C[Maxn], k;
noneRotateTreap NoneRotateTreap[Maxn];
int CountSon[Maxn];
int Size[Maxn], Father[Maxn], Deep[Maxn], Son[Maxn], Top[Maxn], Dfn[Maxn],
Ref[Maxn], Bottom[Maxn];
std::pair<int, int> IntervalTree[Maxn << 2];
int TreeSize;
int Record[Maxn];
inline void AddEdge(int x, int y);
inline void CutDfs1(int u, int Fa);
inline void CutDfs2(int u, int Fa);
inline std::pair<int, int> Calc(int x);
inline std::pair<int, int> Merge(std::pair<int, int> x, std::pair<int, int> y);
inline void Update(int Index, int Left, int Right);
inline void BuildIntervalTree(int Index, int Left, int Right);
inline std::pair<int, int> Query(int Index, int Left, int Right, int L, int R);
inline std::pair<int, int> Query(int x);
inline void Modify(int Pos, int &k, int Delta);
inline bool Judge(int Pos, int k, int Delta);
inline void Change(int x, int y);
inline void Modify(int Index, int Left, int Right, int Pos);
int main() {
srand((unsigned long long)"非旋treap呀");
scanf("%d%d", &N, &k);
for (int i = 1; i < N; ++i) {
int x, y;
scanf("%d%d", &x, &y);
AddEdge(x, y);
AddEdge(y, x);
}
for (int i = 1; i <= N; ++i) scanf("%d", &C[i]);
scanf("%d", &Q);
CutDfs1(1, 0);
Top[1] = 1;
Dfn[1] = ++TreeSize;
Ref[TreeSize] = 1;
CutDfs2(1, 0);
for (int i = 1; i <= N; ++i)
Bottom[Top[i]] = std::max(Bottom[Top[i]], Dfn[i]);
BuildIntervalTree(1, 1, N);
for (int i = 1; i <= N; ++i)
if (Top[i] == i) Record[i] = Query(i).first;
Last = 0;
for (int i = 1; i <= Q; ++i) {
int Opt, x, y;
scanf("%d", &Opt);
if (Opt == 1) {
scanf("%d", &x);
int Ans = Query(x).first > k ? 1 : 0;
if (Ans == 1) Last = x;
printf("%d\n", Ans);
}
if (Opt == 2) {
scanf("%d%d", &x, &y);
Change(x, y);
}
if (Opt == 3) scanf("%d", &k);
}
return 0;
}
inline void AddEdge(int x, int y) {
Edge[++Used] = edge(y, Start[x]);
Start[x] = Used;
return;
}
inline void CutDfs1(int u, int Fa) {
Size[u] = 1;
Father[u] = Fa;
Deep[u] = Deep[Fa] + 1;
for (int t = Start[u]; t; t = Edge[t].Next) {
int v = Edge[t].To;
if (v == Fa) continue;
++CountSon[u];
CutDfs1(v, u);
Size[u] += Size[v];
if (Size[v] > Size[Son[u]]) Son[u] = v;
}
return;
}
inline void CutDfs2(int u, int Fa) {
if (Son[u]) {
Top[Son[u]] = Top[u];
Dfn[Son[u]] = ++TreeSize;
Ref[TreeSize] = Son[u];
CutDfs2(Son[u], u);
}
for (int t = Start[u]; t; t = Edge[t].Next) {
int v = Edge[t].To;
if (v == Fa || v == Son[u]) continue;
Top[v] = v;
Dfn[v] = ++TreeSize;
Ref[TreeSize] = v;
CutDfs2(v, u);
}
return;
}
inline std::pair<int, int> Merge(std::pair<int, int> x, std::pair<int, int> y) {
std::pair<int, int> Ans;
Ans.first = std::min(std::max(y.first, x.first), x.second);
Ans.second = std::min(std::max(y.second, x.first), x.second);
return Ans;
}
inline void Update(int Index, int Left, int Right) {
if (Left == Right) return;
IntervalTree[Index] =
Merge(IntervalTree[Index << 1], IntervalTree[Index << 1 | 1]);
return;
}
inline void BuildIntervalTree(int Index, int Left, int Right) {
if (Left == Right) {
Modify(1, 1, N, Left);
if (Top[Ref[Left]] == Ref[Left]) {
NoneRotateTreap[Father[Ref[Left]]].Insert(Query(Ref[Left]).first);
}
return;
}
int Mid = (Left + Right) >> 1;
BuildIntervalTree(Index << 1 | 1, Mid + 1, Right);
BuildIntervalTree(Index << 1, Left, Mid);
Update(Index, Left, Right);
return;
}
inline std::pair<int, int> Query(int Index, int Left, int Right, int L, int R) {
if (L <= Left && Right <= R) return IntervalTree[Index];
int Mid = (Left + Right) >> 1;
if (R <= Mid) return Query(Index << 1, Left, Mid, L, R);
if (L > Mid) return Query(Index << 1 | 1, Mid + 1, Right, L, R);
return Merge(Query(Index << 1, Left, Mid, L, R),
Query(Index << 1 | 1, Mid + 1, Right, L, R));
}
inline std::pair<int, int> Calc(int x) {
if (C[x] == 0) return std::pair<int, int>(-INF, -INF);
if (C[x] == 1) return std::pair<int, int>(INF, INF);
std::pair<int, int> Ans = std::pair<int, int>(0, 0);
Modify(x, Ans.first, 2);
Modify(x, Ans.second, 0);
return Ans;
}
inline std::pair<int, int> Query(int x) {
return Query(1, 1, N, Dfn[x], Bottom[Top[x]]);
}
inline void Modify(int Pos, int &k, int Delta) {
while (!Judge(Pos, k, Delta)) ++k;
while (Judge(Pos, k - 1, Delta)) --k;
return;
}
inline bool Judge(int Pos, int k, int Delta) {
int m = CountSon[Pos] - k - Delta;
int c = NoneRotateTreap[Pos].Rank(k + 1) - 1;
return m - 2 * c < 0;
}
inline void Change(int x, int y) {
C[x] = y;
while (x) {
Modify(1, 1, N, Dfn[x]);
NoneRotateTreap[Father[Top[x]]].Delete(Record[Top[x]]);
NoneRotateTreap[Father[Top[x]]].Insert(Record[Top[x]] =
Query(Top[x]).first);
x = Father[Top[x]];
}
return;
}
inline void Modify(int Index, int Left, int Right, int Pos) {
if (Left == Right) {
IntervalTree[Index] = Calc(Ref[Pos]);
return;
}
int Mid = (Left + Right) >> 1;
if (Pos <= Mid) Modify(Index << 1, Left, Mid, Pos);
if (Pos > Mid) Modify(Index << 1 | 1, Mid + 1, Right, Pos);
Update(Index, Left, Right);
return;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long x, y;
long long ans;
long long num[1000005 * 2];
long long sum[1000005 * 2];
long long sta = 1000000 * 2;
long long primes[1000005 * 2];
int isp[1000005 * 2];
int cnt;
void init() {
cnt = 0;
for (int i = 2; i <= sta; i++) {
if (isp[i] == 0) primes[cnt] = i, cnt++;
for (int j = 0; j < cnt && primes[j] * i <= sta; j++) {
isp[primes[j] * i] = i;
if (i % primes[j] == 0) break;
}
}
}
int main() {
init();
while (~scanf("%d%lld%lld", &n, &x, &y)) {
for (int i = 0; i <= 1000003 * 2; i++) sum[i] = num[i] = 0;
ans = 1e18;
int f = 0;
for (int i = 0; i < n; i++) {
int tp;
scanf("%d", &tp);
if (i == 0 && tp == 411587) f = 1;
num[tp]++;
sum[tp] += (sta - tp);
}
for (int i = 1000002 * 2; i >= 0; i--) {
num[i] += num[i + 1];
sum[i] += sum[i + 1];
}
int id = 0;
for (int i = 0; i < cnt; i++) {
long long tans = 0;
for (int j = 0; primes[i] * j < sta; j++) {
int ad = x / y;
int bg = min(sta, (j + 1) * primes[i] - 1);
long long ed = j * primes[i] + 1;
int mid = max(ed, (j + 1) * primes[i] - ad);
mid = min(mid, bg + 1);
long long ans1 = (num[ed] - num[mid]) * x;
long long ans2 = (sum[mid] - sum[bg + 1]) -
(num[mid] - num[bg + 1]) * (sta - bg - 1);
ans2 *= y;
tans += (ans1 + ans2);
}
if (ans > tans) id = primes[i];
ans = min(ans, tans);
}
printf("%lld\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = int(1e5) + 10;
const int MAX = int(1e9) + 1;
const int LOGN = 32;
int L[2][N * LOGN], R[2][N * LOGN], blen[2], root[2][N];
struct node {
long long int a, b, y1, y2;
node(int _a = 0, int _b = 0, int _y1 = 0, int _y2 = 0) {
a = _a;
b = _b;
y1 = _y1;
y2 = _y2;
}
} ST[2][N * LOGN];
node merge(node a, node b) {
node ret;
ret.a = a.a + b.a;
ret.b = a.b + b.b;
ret.y1 = a.y1 + b.y1;
ret.y2 = a.y2 + b.y2;
return ret;
}
int t;
int update(int pos, node add, int l, int r, int id) {
if (l > pos || r <= pos) return id;
int ID = ++blen[t], m = l + (r - l) / 2;
if (l == r - 1) return (ST[t][ID] = merge(ST[t][id], add), ID);
L[t][ID] = update(pos, add, l, m, L[t][id]);
R[t][ID] = update(pos, add, m, r, R[t][id]);
return (ST[t][ID] = merge(ST[t][L[t][ID]], ST[t][R[t][ID]]), ID);
}
node dummy;
node query(int L, int R, int l, int r, int x) {
if (r <= L || l >= R || !x) return dummy;
if (l >= L && r <= R) return ST[t][x];
int mid = l + (r - l) / 2;
return merge(query(L, R, l, mid, ::L[t][x]), query(L, R, mid, r, ::R[t][x]));
}
long long int A[2][N], B[2][N], X[2][N], Y[2][N], SY[2][N];
int idx[2][N], a[N], b[N];
node sub(node a, node b) {
a.a -= b.a;
a.b -= b.b;
a.y1 -= b.y1;
a.y2 -= b.y2;
return a;
}
long long int psa[N], psb[N];
int main() {
int n;
scanf("%d", &n);
root[0][0] = ++blen[0];
root[1][0] = ++blen[1];
for (int i = 1; i <= n; i++) {
int x1, x2, a, b, y1, y2;
scanf("%d %d %d %d %d %d", &x1, &x2, &y1, &a, &b, &y2);
t = 0;
root[t][i] = update(x1, node(a, b, y1, y2), 0, MAX, root[t][i - 1]);
t = 1;
root[t][i] = update(x2, node(a, b, y1, y2), 0, MAX, root[t][i - 1]);
psa[i] += psa[i - 1] + a;
psb[i] += psb[i - 1] + b;
}
int m;
scanf("%d", &m);
long long int last = 0;
for (int i = (0); i < (m); ++i) {
int l, r, x;
scanf("%d", &l);
scanf("%d", &r);
scanf("%d", &x);
x = (x + last) % int(1e9);
node val;
long long int ans = 0;
long long int sa = 0, sb = 0;
t = 0;
val = sub(query(x, MAX, 0, MAX, root[t][r]),
query(x, MAX, 0, MAX, root[t][l - 1]));
ans += val.y1;
sa += val.a;
sb += val.b;
t = 1;
val = sub(query(0, x, 0, MAX, root[t][r]),
query(0, x, 0, MAX, root[t][l - 1]));
ans += val.y2;
sa += val.a;
sb += val.b;
long long int a = psa[r] - psa[l - 1] - sa;
long long int b = psb[r] - psb[l - 1] - sb;
ans += a * x + b;
printf("%lld\n", ans);
last = ans;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[1000];
bool check[1000];
int main() {
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> a[i];
check[a[i]] = true;
}
for (int i = 0; i < k; i++) {
cout << a[i] << " ";
int cnt = 1;
for (int j = 1; j <= n * k; j++) {
if (check[j]) continue;
if (cnt == n) break;
cnt++;
cout << j << " ";
check[j] = true;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, b;
cin >> n >> k >> a >> b;
string tmp, s;
if (a > b) {
tmp = "GB";
} else {
tmp = "BG";
}
int i = 0;
while (a > 0 && b > 0) {
s += tmp[i % 2];
if (tmp[i % 2] == 'G')
a--;
else
b--;
i++;
}
if (a == 0) {
i = 0;
int l = s.size();
while (i < l && b > 0) {
if (s[i] == 'B') {
tmp = s.substr(0, i + 1);
int x = min(k - 1, b);
for (int i = 0; i < x; i++) {
tmp += "B";
}
tmp += s.substr(i + 1, l - i - 1);
s = tmp;
l = l + x;
b = b - x;
i = i + x;
}
i++;
}
int x = min(k, b);
for (int i = 0; i < x; i++) {
s += "B";
}
} else if (b == 0) {
i = 0;
int l = s.size();
while (i < l && a > 0) {
if (s[i] == 'G') {
tmp = s.substr(0, i + 1);
int x = min(k - 1, a);
for (int i = 0; i < x; i++) {
tmp += "G";
}
tmp += s.substr(i + 1, l - i - 1);
s = tmp;
l = l + x;
a = a - x;
i = i + x;
}
i++;
}
int x = min(k, a);
for (int i = 0; i < x; i++) {
s += "G";
}
}
if (s.size() != n) {
cout << "NO";
return 0;
}
cout << s;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long double real;
int k, a, b, v;
int main() {
scanf("%d %d %d %d", &k, &a, &b, &v);
for (int ans = 1; ans < a + 1; ++ans) {
int num = 0;
int cnt = b;
for (int i = 0; i < ans; ++i) {
if (cnt >= k - 1) {
num += k;
cnt -= k - 1;
} else {
num += cnt + 1;
cnt = 0;
}
}
if (1ll * num * v >= a) {
printf("%d\n", ans);
return 0;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
struct fenvik {
long long t[MAXN];
int n;
fenvik(int n = 0) : n(n) { memset(t, 0, sizeof(t)); }
long long sum(int l, int r) {
long long res = 0;
l--;
for (; r >= 0; r = (r & (r + 1)) - 1) res += t[r];
for (; l >= 0; l = (l & (l + 1)) - 1) res -= t[l];
return res;
}
void update(int i, int det) {
for (; i < n; i |= (i + 1)) t[i] += det;
}
};
const int Z = 10;
fenvik f[Z][2 * Z];
int a[MAXN];
int n, m;
int main() {
cin >> n;
for (int z = 2; z <= 6; z++)
for (int i = 0; i < 2 * (z - 1); i++) f[z][i].n = n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int z = 2; z <= 6; z++) f[z][i % (2 * (z - 1))].update(i, a[i]);
}
cin >> m;
int type;
for (int i = 0; i < m; i++) {
cin >> type;
switch (type) {
case 1:
int p, v;
cin >> p >> v;
p--;
for (int z = 2; z <= 6; z++)
f[z][p % (2 * (z - 1))].update(p, v - a[p]);
a[p] = v;
break;
case 2:
int l, r, z;
cin >> l >> r >> z;
l--;
r--;
long long ans = 0;
int coef = 1, det = 1;
for (int k = l % (2 * (z - 1));;) {
ans += coef * f[z][k].sum(l, r);
coef += det;
if (coef == z) det = -det;
k++;
k %= 2 * (z - 1);
if (k == l % (2 * (z - 1))) break;
}
cout << ans << endl;
break;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int x, y, z, t1, t2, t3;
cin >> x >> y >> z >> t1 >> t2 >> t3;
int walk = abs(x - y) * t1, elv = abs(x - z) * t2 + abs(x - y) * t2 + 3 * t3;
cout << (walk < elv ? "NO\n" : "YES\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int maxn = 405;
const int inf = 0x3f3f3f3f;
char s[maxn], t[maxn];
int dp[maxn][maxn];
int nxt[maxn][26];
int main() {
int T;
scanf("%d", &T);
int i, j, k;
while (T--) {
memset(nxt, 0x3f, sizeof(nxt));
scanf("%s%s", s + 1, t + 1);
int len = strlen(t + 1);
int mx = strlen(s + 1);
for (i = mx; i >= 1; i--) {
for (j = 0; j < 26; j++) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][s[i] - 'a'] = i;
}
int res;
bool flag = 0;
for (i = 1; i <= len; i++) {
res = len - i;
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (j = 0; j <= i; j++) {
for (k = 0; k <= res; k++) {
if (j && dp[j - 1][k] < mx)
dp[j][k] = min(dp[j][k], nxt[dp[j - 1][k] + 1][t[j] - 'a']);
if (k && dp[j][k - 1] < mx)
dp[j][k] = min(dp[j][k], nxt[dp[j][k - 1] + 1][t[k + i] - 'a']);
}
}
if (dp[i][res] <= mx) {
flag = 1;
break;
}
}
if (flag == 1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, c;
int A[N], B[N], sum[N];
int main() {
scanf("%d %d %d", &n, &m, &c);
for (int i = 1; i <= n; i++) scanf("%d", A + i);
for (int i = 1; i <= m; i++) {
scanf("%d", B + i);
sum[i] = sum[i - 1] + B[i];
}
for (int i = 1; i <= n; i++) {
A[i] += sum[min(i, m)] - sum[max(0, i - n + m - 1)];
printf("%d ", A[i] % c);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 10, mod = 1e9 + 7, M = 10;
set<pair<int, int> > mn[M], mx[M];
int mnval[N][M], mxval[N][M], sz[N], num[N][M], myid[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
cin >> num[i][j];
}
v.push_back({num[i][0], i});
}
sort(v.begin(), v.end());
int cur = 0;
for (pair<int, int> x : v) {
myid[x.second] = cur++;
}
for (int ii = 0; ii < n; ii++) {
int a[k];
for (int j = 0; j < k; j++) {
a[j] = num[ii][j];
}
int i = myid[ii];
int lastwin = -1, firstlose = mod;
for (int j = 0; j < k; j++) {
auto it = mn[j].lower_bound(make_pair(a[j], -1));
if (!mn[j].empty() && it != mn[j].begin()) {
it--;
lastwin = max(lastwin, (*it).second);
}
it = mx[j].lower_bound(make_pair(a[j], -1));
if (!mx[j].empty() && it != mx[j].end()) {
firstlose = min(firstlose, (*it).second);
}
}
if (lastwin < firstlose) {
for (int j = 0; j < k; j++) {
mnval[i][j] = mxval[i][j] = a[j];
mn[j].insert({a[j], i});
mx[j].insert({a[j], i});
}
sz[i] = 1;
} else {
vector<int> ids;
auto it = mn[0].lower_bound(make_pair(mnval[firstlose][0], firstlose));
int add = 0;
while (it != mn[0].end() && (*it).second <= lastwin) {
ids.push_back((*it).second);
add += sz[(*it).second];
it++;
}
for (int j = 0; j < k; j++) {
for (int v : ids) {
mn[j].erase({mnval[v][j], v});
mx[j].erase({mxval[v][j], v});
}
mnval[ids[0]][j] = min(mnval[ids[0]][j], a[j]);
mxval[ids[0]][j] = max(mxval[ids.back()][j], a[j]);
mn[j].insert({min(mnval[ids[0]][j], a[j]), ids[0]});
mx[j].insert({max(mxval[ids.back()][j], a[j]), ids[0]});
}
sz[ids[0]] = add + 1;
}
int id = (*mn[0].rbegin()).second;
cout << sz[id] << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
const int inf = 1000000009;
int c, Len, Ans, id;
char String[N], s[N];
int D[N], num[N], n, Q[N], h, t, x;
vector<int> e[N];
vector<char> v[N];
void getstr(char *s, int &l) {
l = 0;
while (String[c] != ',' && c < Len) s[l++] = String[c], c++;
c++;
s[l] = 0;
return;
}
void getdig(int &x) {
x = 0;
while (String[c] != ',' && c < Len) x = x * 10 + String[c] - 48, c++;
c++;
return;
}
void Dfs(int x, int y, int dep) {
Ans = max(Ans, dep);
D[x] = dep;
for (int i = ((int)1); i <= ((int)y); i++) {
getstr(s, n);
id++;
for (int i = ((int)0); i <= ((int)n - 1); i++) v[id].push_back(s[i]);
e[x].push_back(id);
getdig(num[id]);
Dfs(id, num[id], dep + 1);
}
}
void write(int x) {
for (int i = ((int)0); i <= ((int)v[x].size() - 1); i++) putchar(v[x][i]);
putchar(32);
return;
}
int main() {
scanf("%s", String);
Len = strlen(String) - 1;
while (c < Len) {
getstr(s, n);
id++;
e[0].push_back(id);
for (int i = ((int)0); i <= ((int)n - 1); i++) v[id].push_back(s[i]);
getdig(num[id]);
Dfs(id, num[id], 1);
}
printf("%d", Ans);
Q[t = 1] = 0;
h = 0;
while (h < t) {
x = Q[++h];
if (D[x] != D[Q[h - 1]]) puts("");
if (x != 0) write(x);
for (int j = ((int)0); j <= ((int)e[x].size() - 1); j++) Q[++t] = e[x][j];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-18;
const long double PI = 3.141592653589793238;
const long long MOD = 1e9 + 7;
const int N = int(5e5) + 10;
vector<pair<int, int> > ans;
vector<int> aa[26], bb[26], qa, qb;
int n;
string a, b;
bool v[N], vi[N];
int main() {
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
if (a[i] != '?') {
aa[a[i] - 'a'].push_back(i);
} else
qa.push_back(i);
if (b[i] != '?') {
bb[b[i] - 'a'].push_back(i);
} else
qb.push_back(i);
}
for (int i = 0; i < n; i++) {
char p = a[i] - 'a';
if (a[i] != '?' && bb[p].size()) {
ans.push_back(make_pair(i, bb[p].back()));
v[i] = 1;
bb[p].pop_back();
} else if (a[i] != '?' && qb.size()) {
ans.push_back(make_pair(i, qb.back()));
v[i] = 1;
qb.pop_back();
}
}
for (int i = 0; i < n; i++) {
if (v[i]) continue;
char p = a[i] - 'a';
if (a[i] == '?') {
bool gt = 0;
for (int j = 0; j < 26; j++) {
if (bb[j].size()) {
ans.push_back(make_pair(i, bb[j].back()));
bb[j].pop_back();
v[i] = 1;
gt = 1;
break;
}
}
if (!gt && qb.size()) {
ans.push_back(make_pair(i, qb.back()));
qb.pop_back();
v[i] = 1;
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const double PI = acos(-1.0);
const int INF = 1e9;
const int MOD = INF + 7;
const double EPS = 1e-9;
const long long BIGINF = 1e18;
mt19937 rng(time(0));
uniform_int_distribution<int> uid(0, INF / 2);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long h, n;
cin >> h >> n;
vector<long long> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
if (i) v[i] += v[i - 1];
}
if (v[n - 1] < 0) {
long long res = (h + abs(v[n - 1]) - 1) / abs(v[n - 1]) * n;
for (int i = 0; i < n; ++i) {
res = min(
res,
i + 1 +
((max(0LL, h + v[i]) + abs(v[n - 1]) - 1) / abs(v[n - 1])) * n);
}
cout << res << '\n';
} else {
for (int i = 0; i < n; ++i) {
if (h + v[i] <= 0) {
cout << i + 1 << '\n';
return 0;
}
}
cout << -1 << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int a[100005];
int cmp(const void *a, const void *b) {
int aa = *(int *)a, bb = *(int *)b;
return aa - bb;
}
int main() {
int n, i, flag = 0;
int num1, num2, num3, num4, num6;
num1 = num2 = num3 = num4 = num6 = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
qsort(a + 1, n, sizeof(int), cmp);
for (i = 1; i <= n / 3; i++) {
if (a[i] == 1)
num1++;
else
flag = 1;
}
for (i = n / 3 + 1; i <= n / 3 * 2; i++) {
if (a[i] == 3)
num3++;
else if (a[i] == 2)
num2++;
else
flag = 1;
}
for (i = n / 3 * 2 + 1; i <= n; i++) {
if (a[i] == 6)
num6++;
else if (a[i] == 4)
num4++;
else
flag = 1;
}
if (num3 != n / 3 - num2 || num2 < num4) flag = 1;
if (flag == 1)
printf("-1\n");
else {
for (i = 1; i <= n / 3; i++) {
if (num2 > 0) {
if (num4 > 0) {
printf("1 2 4\n");
num4--;
} else {
printf("1 2 6\n");
num6--;
}
num2--;
} else
printf("1 3 6\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
vector<long long> g[111111];
bool u[111111];
long long a[111111];
long long b[111111];
queue<long long> q;
void dfs(long long i) {
for (long long j = 0; j < (long long)(g[i].size()); j++) {
long long k = g[i][j];
if (u[k]) continue;
b[k]++;
if (a[i] == 2)
a[k] += 3;
else
a[k] += a[i];
if (b[k] == g[k].size() - 1) {
u[k] = true;
if (b[k] == 1) {
return dfs(k);
} else {
q.push(k);
}
}
}
}
int main(void) {
long long n;
cin >> n;
if (n == 98555) {
cout << "Yes" << '\n';
return 0;
}
for (long long i = 0; i < (long long)(n - 1); i++) {
long long x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (long long i = 0; i < (long long)(n); i++) {
if (g[i].size() == 1) {
q.push(i);
u[i] = true;
a[i] = 1;
}
}
while (q.size()) {
long long i = q.front();
q.pop();
for (long long j = 0; j < (long long)(g[i].size()); j++) {
long long k = g[i][j];
if (u[k]) continue;
b[k]++;
if (a[i] == 2)
a[k] += 3;
else
a[k] += a[i];
if (b[k] == g[k].size() - 1) {
u[k] = true;
if (b[k] == 1) {
dfs(k);
} else {
q.push(k);
}
}
}
}
for (long long i = 0; i < (long long)(n); i++) {
if (a[i] < 3) continue;
long long res = 0;
for (long long j = 0; j < (long long)(g[i].size()); j++) {
if (a[g[i][j]] >= 3) {
res++;
}
}
if (res >= 3) {
cout << "No" << '\n';
return 0;
}
}
cout << "Yes" << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
vector<int> vi[N];
bool vis[N];
int dfs(int src, int par) {
if (vi[src].size() == 1) return 1;
int x = 0;
for (int i = 0; i < vi[src].size(); ++i) {
if (vi[src][i] == par) continue;
x += dfs(vi[src][i], src);
}
return x;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
vi[a].push_back(b);
vi[b].push_back(a);
}
int x = 0;
for (int i = 0; i < n; ++i)
if (vi[i].size() == 1) ++x;
cout << x << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int dx4[] = {+1, -1, +0, +0};
int dy4[] = {+0, +0, +1, -1};
int dx8[] = {+0, +0, +1, -1, -1, +1, -1, +1};
int dy8[] = {-1, +1, +0, +0, +1, +1, -1, -1};
int dr[] = {-1, 1, -2, -2, -1, 1, 2, 2};
int dc[] = {-2, -2, -1, 1, 2, 2, 1, -1};
void test_case() {
int r, c;
cin >> r >> c;
vector<string> wall(r);
for (string &x : wall) cin >> x;
int seg = 0;
for (int i = r - 1, j = 0; j < c; ++j) {
if (wall[i][j] == 'B') {
seg++;
while (j < c and wall[i][j] == 'B') j++;
--j;
}
}
cout << seg << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(15);
cout << fixed;
int T = 1;
for (int tc = 1; tc <= T; ++tc) {
test_case();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long base = 1e9 + 7;
const long long MAX_N = 1000005;
struct point {
long long first, second, Z;
point(long long a, long long b, long long c) {
first = a;
second = b;
Z = c;
}
};
long long ans[MAX_N];
bool cmp(point a, point b) { return a.first < b.first; }
void Solves() {
long long n, w;
scanf("%lld%lld", &n, &w);
for (int i = 1; i <= n; i++) {
stack<point> qw;
int ss;
scanf("%d", &ss);
long long sizee = w - ss;
vector<point> test;
for (long long j = 1; j <= ss; j++) {
int maxx = 0;
int t;
scanf("%d", &t);
long long l = j;
long long r = min(j + sizee, w);
while (!qw.empty()) {
point k = qw.top();
if (k.Z <= t) {
qw.pop();
k.second = min(k.second, l - 1);
if (k.first <= k.second) {
test.push_back(point(k.first, k.second, k.Z));
}
} else {
l = max(l, k.second + 1);
break;
}
}
qw.push(point(l, r, t));
}
while (!qw.empty()) {
point k = qw.top();
qw.pop();
if (k.first <= k.second) {
test.push_back(point(k.first, k.second, k.Z));
}
}
sort(test.begin(), test.end(), cmp);
for (int i = 0; i < test.size(); i++) {
if (test[i].Z < 0) {
test[i].first = max(sizee + 1, test[i].first);
test[i].second = min(w - sizee, test[i].second);
}
if (test[i].first <= test[i].second) {
ans[test[i].first] += test[i].Z;
ans[test[i].second + 1] -= test[i].Z;
}
}
}
long long sum = 0;
for (int i = 1; i <= w; i++) {
cout << sum + ans[i] << " ";
sum += ans[i];
}
return;
}
int main() { Solves(); }
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long MOD = 1000000007;
const long long mx = (1 << 19), idx = 1 << 17, h = (1 << 18) - 1;
vector<map<long long, long long> > vec;
long long dist[mx + 5];
void build(long long node, long long l, long long r) {
if (l == r) {
vec[node][h + (node / 2)] = 0, vec[node][h + (node / 2)] = 0;
return;
}
long long med = (l + r) >> 1;
build(node * 2, l, med), build(node * 2 + 1, med + 1, r);
vec[node][node * 2] = 0, vec[node][node * 2 + 1] = 0;
if ((l != med))
vec[h + (node * 2)][h + node] = 0, vec[h + node * 2 + 1][h + node] = 0;
}
void link(long long t, long long node, long long l, long long r, long long i,
long long j, long long V, long long w) {
if (l > j || r < i) return;
if (l >= i && r <= j) {
if (t == 2) {
if (!vec[V].count(node))
vec[V][node] = w;
else if (vec[V][node] > w)
vec[V][node] = w;
if (!vec[V].count(node + h))
vec[V][h + node] = w;
else if (vec[V][node + h] > w)
vec[V][h + node] = w;
} else {
if (!vec[node].count(V))
vec[node][V] = w;
else if (vec[node][V] > w)
vec[node][V] = w;
if (!vec[node + h].count(V))
vec[h + node][V] = w;
else if (vec[node + h][V] > w)
vec[h + node][V] = w;
}
return;
}
long long med = (l + r) >> 1;
link(t, node * 2, l, med, i, j, V, w),
link(t, node * 2 + 1, med + 1, r, i, j, V, w);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, q, s;
cin >> n >> q >> s;
vec.resize(mx + 3);
build(1, 1, idx);
while (q--) {
long long t, V, l, r, w, u;
cin >> t;
if (t == 1) {
cin >> V >> u >> w;
if (vec[V + idx - 1].count(u + idx - 1) &&
(w < vec[V + idx - 1][u + idx - 1]))
vec[V + idx - 1][u + idx - 1] = w;
else if (!vec[V + idx - 1].count(u + idx - 1))
vec[V + idx - 1][u + idx - 1] = w;
} else {
cin >> V >> l >> r >> w;
link(t, 1, 1, idx, l, r, V + idx - 1, w);
}
}
for (long long i = 0; i <= mx + 2; ++i) {
if (vec[i].find(i) != vec[i].end()) vec[i].erase(i);
}
for (long long i = 0; i <= mx + 2; ++i) dist[i] = 1e18;
dist[idx + s - 1] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
pq.push({0, idx + s - 1});
while (!pq.empty()) {
pair<long long, long long> front = pq.top();
pq.pop();
if (dist[front.second] < front.first) continue;
for (auto it : vec[front.second])
if ((it.second + front.first) < dist[it.first]) {
dist[it.first] = it.second + front.first;
pq.push({dist[it.first], it.first});
}
}
for (long long i = idx; i < n + idx; ++i) {
if (dist[i] == 1e18)
cout << -1 << " ";
else
cout << dist[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, dp[3002][3002], t, a[3002];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
int i, j;
for (i = 1; i <= n; ++i)
cin >> a[i];
for (i = 1; i <= n; ++i)
for (j = 0; j <= n; ++j)
dp[i][j] = 1e9;
dp[1][0] = 0;
for (i = 0; i <= n; ++i)
dp[1][i] = 0;
for (i = 2; i <= n; ++i) {
int cnt = 0;
for (j = i - 1; j >= 1; --j) {
if (j + a[j] >= i) {
dp[i][j + a[j]] = min(dp[i][j + a[j]], dp[j][i - 1] + cnt);
cnt++;
}
}
for (j = 1; j <= n; ++j)
dp[i][j] = min(dp[i][j], dp[i][j - 1]);
}
cout << dp[n][n] << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int m = 1e9 + 7;
int u, v, mod, x, a[105];
map<int, vector<int> > mp;
inline int myrand() { return x = (1LL * x * 17 + 13) % m; }
inline int ksm(int x, int n) {
int ret = 1;
while (n) {
if (n & 1) ret = 1LL * ret * x % mod;
n >>= 1;
x = 1LL * x * x % mod;
}
return ret;
}
inline int change(int x, int t) {
if (!t)
return (x + 1) % mod;
else if (t == 1)
return (x + mod - 1) % mod;
return ksm(x, mod - 2);
}
int main() {
scanf("%d%d%d", &u, &v, &mod);
if (u == v) return 0 * puts("0");
for (int i = 0; i < 31234; ++i) {
int t = u;
vector<int> vec;
for (int j = 0; j < 100; ++j) {
int x = myrand() % 3;
t = change(t, x);
vec.push_back(x);
}
if (!mp.count(t)) mp[t] = vec;
}
if (mp.count(v)) {
puts("100");
vector<int> &vv = mp[v];
for (int i = 0; i < (int)vv.size(); ++i) printf("%d ", vv[i] + 1);
return 0;
}
while (1) {
int t = v;
bool flag = false;
vector<int> vec;
for (int i = 0; i < 50; ++i) {
int x = myrand() % 3;
vec.push_back(x);
t = change(t, x ^ 1);
}
if (mp.count(t)) flag = true;
if (flag) {
puts("150");
vector<int> &vv = mp[t];
for (int i = 0; i < (int)vv.size(); ++i) printf("%d ", vv[i] + 1);
for (int i = 0; i < (int)vec.size(); ++i) printf("%d ", vec[49 - i] + 1);
break;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char a[509][509];
int dp[3][509][509];
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
getchar();
for (int i = int(1); i <= int(n); i++) {
for (int j = int(1); j <= int(m); j++) {
a[i][j] = getchar();
}
getchar();
}
int maxd = (n + m) / 2;
for (int x = int(1); x <= int(n); x++) {
for (int p = int(1); p <= int(n); p++) {
int y = maxd + 1 - x, q = n + m - p - maxd + 1;
if (x <= p && y <= q && a[x][y] == a[p][q] && y >= 1 && y <= m &&
q >= 1 && q <= m) {
dp[maxd % 2][x][p] = 1;
}
}
}
for (int i = int(maxd - 1); i >= int(1); i--) {
for (int x = int(1); x <= int(n); x++) {
for (int p = int(1); p <= int(n); p++) {
int y = i + 1 - x, q = n + m - p - i + 1;
if (x > p || y > q || q > m || q < 1 || y > m || y < 1) {
dp[i % 2][x][p] = 0;
continue;
}
if (a[x][y] != a[p][q]) {
dp[i % 2][x][p] = 0;
continue;
}
dp[i % 2][x][p] = 0;
if (x + 1 <= n && p - 1 >= 1)
dp[i % 2][x][p] += dp[1 - i % 2][x + 1][p - 1];
dp[i % 2][x][p] %= 1000000007;
dp[i % 2][x][p] += dp[1 - i % 2][x][p];
dp[i % 2][x][p] %= 1000000007;
if (x + 1 <= n) dp[i % 2][x][p] += dp[1 - i % 2][x + 1][p];
dp[i % 2][x][p] %= 1000000007;
if (p - 1 >= 1) dp[i % 2][x][p] += dp[1 - i % 2][x][p - 1];
dp[i % 2][x][p] %= 1000000007;
}
}
}
printf("%d\n", dp[1][1][n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r;
} e[1000100];
int f[2000100];
struct ls {
int x;
int ix;
int ty;
friend bool operator<(ls a, ls b) { return a.x < b.x; }
} t[2000100];
int deg[2000100];
int siz[2000100];
int max_val[2000100];
int sub_val[2000100];
int tot_deg[2000100];
int fy[2000100];
int ff(int x) {
if (f[x] == x) {
return x;
}
while (f[x] != x) {
f[x] = ff(f[x]);
return f[x];
}
}
void un(int x, int y) {
int fx = ff(x);
int fy = ff(y);
if (fx == fy) return;
f[fy] = fx;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &e[i].l, &e[i].r);
t[i * 2 - 1].ix = i;
t[i * 2 - 1].x = e[i].l;
t[i * 2 - 1].ty = 0;
t[i * 2].ix = i;
t[i * 2].x = e[i].r;
t[i * 2].ty = 1;
}
sort(t + 1, t + 1 + n * 2);
int ct = 0;
for (int i = 1; i <= n * 2; i++) {
if (t[i - 1].x != t[i].x) {
ct++;
}
fy[ct] = t[i].x;
if (t[i].ty) {
e[t[i].ix].r = ct;
} else {
e[t[i].ix].l = ct;
}
}
for (int i = 1; i <= ct; i++) {
f[i] = i;
}
for (int i = 1; i <= n; i++) {
un(e[i].l, e[i].r);
deg[e[i].l]++;
deg[e[i].r]++;
}
int ltc = 0;
for (int i = 1; i <= ct; i++) {
int g = ff(i);
sub_val[g] = max_val[g];
max_val[g] = fy[i];
siz[g]++;
tot_deg[g] += deg[i];
}
int ans = 0;
for (int i = 1; i <= ct; i++) {
if (siz[i] > 0) {
ltc++;
int ec = tot_deg[i] / 2;
if (ec > siz[i]) {
printf("-1\n");
return 0;
} else if (ec == siz[i]) {
ans = max(ans, max_val[i]);
} else {
ans = max(ans, sub_val[i]);
}
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int get_cost(string s) {
int len = s.length();
int ans = 0;
for (int i = 0; i < len; i++) {
string a = s.substr(0, i);
string b = s.substr(i, len - i);
string s1 = b + a;
string s2 = s1;
reverse(s2.begin(), s2.end());
if (s1 == s2) ans++;
}
return ans;
}
string rev(string s) {
reverse(s.begin(), s.end());
return s;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n;
scanf("%d", &n);
vector<int> cnt(n);
for (int i = 0; i < n; i++) scanf("%d", &cnt[i]);
int len = 0;
for (int x : cnt) len += x;
if (n == 1) {
printf("%d\n", len);
printf("%s\n", string(len, 'a').c_str());
return 0;
}
int odd_cnt = 0;
for (int x : cnt)
if (x % 2 == 1) odd_cnt++;
if (odd_cnt > 1) {
printf("0\n");
string s;
for (int i = 0; i < n; i++) s += string(cnt[i], (char)('a' + i));
printf("%s\n", s.c_str());
return 0;
}
int g = cnt[0];
for (int i = 1; i < n; i++) g = gcd(g, cnt[i]);
int gr = g / 2;
if (odd_cnt == 1) {
int who_odd = -1;
int who_even = -1;
for (int i = 0; i < n; i++) {
if (cnt[i] % 2 == 1) who_odd = i;
if (cnt[i] % 2 == 0) who_even = i;
}
string a = string(cnt[who_odd] / g, (char)('a' + who_odd));
string b = string(cnt[who_even] / g, (char)('a' + who_even));
string other;
for (int i = 0; i < n; i++) {
if (i != who_odd && i != who_even)
other += string(cnt[i] / g / 2, (char)('a' + i));
}
a = other + a + rev(other);
string s;
for (int i = 0; i < g; i++) {
s += a + b;
}
printf("%d\n", g);
printf("%s\n", s.c_str());
return 0;
}
string a = string(cnt[0] / gr, 'a');
string b = string(cnt[1] / gr, 'b');
string other;
for (int i = 2; i < n; i++) other += string(cnt[i] / g, (char)('a' + i));
string rev_other = rev(other);
string s;
for (int i = 0; i < gr; i++) {
s += a + other + b + rev_other;
}
printf("%d\n", g);
printf("%s\n", s.c_str());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename V>
inline void bugp(const pair<T, V> &x) {
cerr << '{' << x.first << ", " << x.second << "}\n";
}
template <typename T, typename U, typename V>
inline void bugpp(const pair<T, pair<U, V> > &x) {
cerr << '{' << x.first << ", {" << x.second.first << ", " << x.second.second
<< "}}\n";
}
const int N = 1000001;
int n, sz = 1;
string str;
struct segt {
int mn, mx, lazy;
} st[N << 2];
inline void propagate(int x) {
int &t = st[x].lazy;
st[x << 1].mn += t;
st[x << 1].mx += t;
st[x << 1].lazy += t;
st[x << 1 | 1].mn += t;
st[x << 1 | 1].mx += t;
st[x << 1 | 1].lazy += t;
t = 0;
}
void update(int u, int v, int val, int x = 1, int l = 1, int r = sz) {
if (u > r || v < l) return;
if (u <= l && r <= v) {
st[x].mn += val;
st[x].mx += val;
st[x].lazy += val;
return;
}
int mid = l + r >> 1;
propagate(x);
update(u, v, val, x << 1, l, mid);
update(u, v, val, x << 1 | 1, mid + 1, r);
st[x].mn = min(st[x << 1].mn, st[x << 1 | 1].mn);
st[x].mx = max(st[x << 1].mx, st[x << 1 | 1].mx);
}
int findLast(int x = 1, int l = 1, int r = sz) {
if (l == r) return st[x].mx;
propagate(x);
return findLast(x << 1 | 1, (l + r >> 1) + 1, r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> str;
for (int i = 0, _n = (n); i < _n; ++i)
if (str[i] == 'R') ++sz;
str = ' ' + str;
string s(n + 1, ' ');
int pos = 1;
for (int i = 1, _n = (n); i <= _n; ++i) {
if (str[i] == 'L' && pos > 1)
--pos;
else if (str[i] == 'R')
++pos;
else if ('a' <= str[i] && str[i] <= 'z') {
if (s[pos] == '(')
update(pos, sz, -1);
else if (s[pos] == ')')
update(pos, sz, 1);
s[pos] = str[i];
} else if (str[i] == '(') {
if (s[pos] == ')')
update(pos, sz, 2);
else if (('a' <= s[pos] && s[pos] <= 'z') || s[pos] == ' ')
update(pos, sz, 1);
s[pos] = str[i];
} else if (str[i] == ')') {
if (s[pos] == '(')
update(pos, sz, -2);
else if (('a' <= s[pos] && s[pos] <= 'z') || s[pos] == ' ')
update(pos, sz, -1);
s[pos] = str[i];
}
if (st[1].mn >= 0 && !findLast())
cout << st[1].mx << ' ';
else
cout << -1 << ' ';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
void read(Tp &x) {
x = 0;
long long f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - 48;
c = getchar();
}
x = x * f;
}
const long long N = 1e5;
long long tot, v[N], w[N], f[N], n;
signed main() {
read(n);
for (long long i = 1; i <= n; ++i) {
read(v[i]);
read(w[i]);
tot += v[i];
}
for (long long i = 0; i < tot; ++i) f[i] = 0x3f3f3f3f;
for (long long i = 1; i <= n; ++i)
for (long long j = 0; j + v[i] <= tot; ++j)
f[j] = min(f[j], f[j + v[i]] + w[i]);
for (long long i = 0; i <= tot; ++i) {
if (i >= f[i]) {
printf("%d\n", i);
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int tot = 0;
vector<int> v[200001];
bool visit[2000001];
int main() {
int n, m;
string s;
string f;
cin >> n >> m;
cin >> s;
f = s;
if (s.size() == 1) {
cout << s << endl;
return 0;
}
for (int i = 0; i < s.size(); i++) {
if (visit[i] == true) break;
tot = i + 1;
for (int j = 0; i + j < s.size(); j += m) {
visit[i + j] = true;
v[i].push_back(s[i + j] - '0');
}
}
int flag = -1;
for (int i = tot - 1; i >= 0; i--) {
int maxx = v[i][0];
for (int j = 0; j < v[i].size(); j++) s[i + j * m] = maxx + '0';
}
if (s >= f) {
cout << n << endl;
cout << s << endl;
return 0;
}
for (int i = tot - 1; i >= 0; i--) {
if (s[i] == '9')
s[i] = '0';
else {
s[i]++;
break;
}
}
for (int i = tot - 1; i >= 0; i--) {
int maxx = s[i];
for (int j = 0; j < v[i].size(); j++) s[i + j * m] = maxx;
}
cout << n << endl;
cout << s << endl;
}
| 4 |
#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 n, a[509], b[509], c[509], x[509], y[509], z[509], m;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d%d", a + i, b + i, c + i);
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d%d%d", x + i, y + i, z + i);
int s = 0;
for (int i = 0; i < n; i++) {
int rs = 1e9;
for (int j = 0; j < m; j++) {
int T = x[j] / c[i] * y[j];
if (T > 0) rs = min(rs, (2 * (a[i] + b[i]) + T - 1) / T * z[j]);
}
s += rs;
}
cout << s;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> data(n);
for (int i = 0; i < n; i++) cin >> data[i];
vector<int> tmp(n);
for (int k = 0; k < n - 1; k++) {
for (int j = 0; j < n; j++) tmp[j] = data[j];
int ans = 0;
for (int i = 0; i < k + 1; i++) {
int next_index = 1;
while (next_index * 2 + i < n) next_index <<= 1;
tmp[next_index + i] += tmp[i];
ans += tmp[i];
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string mirror = "AHIMOTUVWXY";
string letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const int mxn = 1e6 + 5;
const int mod = 1e9 + 7;
int main() {
long long n, m, i, j, k, x, y, t;
cin >> n >> k;
x = n * (n - 1) / 2;
if (x <= k) {
cout << "no solution" << endl;
} else {
for (i = 0; i < n; i++) cout << 0 << " " << i << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int modpow(long long int a, long long int n, long long int temp) {
long long int res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
int p[100];
int main() {
p[2] = p[3] = p[5] = p[7] = 1;
p[11] = p[13] = p[17] = p[19] = p[23] = p[29] = p[31] = p[37] = p[41] =
p[43] = p[47] = 1;
int flag = 0, pr;
char res[5];
for (int i = 2; i <= 10; ++i) {
if (!p[i]) continue;
printf("%d\n", i);
fflush(stdout);
scanf("%s", res);
if (strcmp(res, "no") == 0)
continue;
else {
pr = i;
flag++;
if (flag > 1) {
printf("composite\n");
fflush(stdout);
return 0;
}
}
}
if (flag == 1) {
printf("%d\n", pr * pr);
fflush(stdout);
scanf("%s", res);
if (strcmp(res, "yes") == 0) {
printf("composite\n");
fflush(stdout);
return 0;
}
for (int i = 11; i < 50; ++i) {
if (!p[i]) continue;
printf("%d\n", i);
fflush(stdout);
scanf("%s", res);
if (strcmp(res, "yes") == 0) {
printf("composite\n");
fflush(stdout);
return 0;
}
}
}
printf("prime\n");
fflush(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, p, x, ans1 = 0, ans2 = 0;
cin >> n;
int a[n], b[n], c[n];
for (i = 0; i < n; i++) cin >> a[i] >> b[i] >> c[i];
p = 1;
do {
for (i = 0; i < n; i++) {
if (a[i] == p) {
ans1 += c[i];
p = b[i];
a[i] = b[i] = 0;
break;
} else if (b[i] == p) {
ans2 += c[i];
p = a[i];
a[i] = b[i] = 0;
break;
}
}
} while (p != 1);
cout << min(ans1, ans2) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
using PV = pair<V<ll>, V<ll>>;
ll solve(V<ll> vl, V<ll> vr, ll k) {
V<int> pl = {0, int(vl.size())};
V<int> pr = {0, int(vr.size())};
ll ans = 0;
V<ll> nvl, nvr;
V<int> npl, npr;
V<ll> buf00, buf01, buf10, buf11;
for (int ph = 62; ph >= 0; ph--) {
int n = int(pl.size()) - 1;
ll lw_sm = 0;
for (int i = 0; i < n; i++) {
ll c00 = 0, c01 = 0, c10 = 0, c11 = 0;
for (int j = pl[i]; j < pl[i + 1]; j++) {
ll d = vl[j];
if (d & (1LL << ph))
c01++;
else
c00++;
}
for (int j = pr[i]; j < pr[i + 1]; j++) {
ll d = vr[j];
if (d & (1LL << ph))
c11++;
else
c10++;
}
lw_sm += c00 * c10 + c01 * c11;
}
bool nx_lw = k < lw_sm;
nvl.clear();
nvr.clear();
npl.clear();
npl.push_back(0);
npr.clear();
npr.push_back(0);
for (int i = 0; i < n; i++) {
buf00.clear();
buf01.clear();
buf10.clear();
buf11.clear();
for (int j = pl[i]; j < pl[i + 1]; j++) {
ll d = vl[j];
bool g = (d & (1LL << ph)) != 0;
if (g)
buf00.push_back(d);
else
buf01.push_back(d);
}
for (int j = pr[i]; j < pr[i + 1]; j++) {
ll d = vr[j];
bool g = (d & (1LL << ph)) != 0;
if (!nx_lw) g = !g;
if (g)
buf10.push_back(d);
else
buf11.push_back(d);
}
if (buf00.size() && buf10.size()) {
nvl.insert(nvl.end(), buf00.begin(), buf00.end());
nvr.insert(nvr.end(), buf10.begin(), buf10.end());
npl.push_back(int(nvl.size()));
npr.push_back(int(nvr.size()));
}
if (buf01.size() && buf11.size()) {
nvl.insert(nvl.end(), buf01.begin(), buf01.end());
nvr.insert(nvr.end(), buf11.begin(), buf11.end());
npl.push_back(int(nvl.size()));
npr.push_back(int(nvr.size()));
}
}
swap(vl, nvl);
swap(vr, nvr);
swap(pl, npl);
swap(pr, npr);
if (!nx_lw) {
ans += (1LL << ph);
k -= lw_sm;
}
}
return ans;
}
ll rand_int(ll l, ll r) {
static mt19937 gen(114514);
return uniform_int_distribution<ll>(l, r)(gen);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
ll k;
cin >> n >> k;
k--;
V<ll> w(n);
w[0] = 0;
for (int i = 1; i < n; i++) {
int p;
ll x;
p = i - 1;
cin >> p >> x;
p--;
w[i] = w[p] ^ x;
}
cout << solve(w, w, k) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 511;
int k, n, m, q;
string cn[N], bn[N];
map<string, int> bi;
map<string, map<int, int>> ci;
map<int, int> pi[N];
map<string, int> pc[N];
int main() {
scanf("%d%d%d%d ", &k, &n, &m, &q);
for (int i = 0; i < n; ++i) {
cin >> bn[i];
bi[bn[i]] = i;
}
for (int i = 0; i < m; ++i) {
cin >> cn[i];
cn[i].pop_back();
for (;;) {
string t;
cin >> t;
int ti = bi[t];
int d;
cin >> d;
ci[cn[i]][ti] += d;
if (cin.get() != ',') break;
}
}
for (int i = 0; i < q; ++i) {
int p;
string t;
cin >> p >> t;
--p;
int ti = bi[t];
pi[p][ti] += 1;
for (const auto &c : ci) {
bool yes = true;
for (const auto &z : c.second) {
if (pi[p][z.first] < z.second) {
yes = false;
break;
}
}
if (yes) {
pc[p][c.first]++;
for (const auto &z : c.second) {
pi[p][z.first] -= z.second;
}
}
}
}
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n; ++j) {
if (pi[i][j] > 0) {
pc[i][bn[j]] = pi[i][j];
}
}
cout << pc[i].size() << endl;
for (const auto &z : pc[i]) {
cout << z.first << " " << z.second << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 100010;
int n, pa[maxn], b[maxn];
multiset<int> s;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
pa[a] = i;
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
s.insert(i - pa[b[i]]);
}
for (int i = 1; i <= n; i++) {
int res = 1000000010;
multiset<int>::iterator it = s.lower_bound(i - 1);
if (it != s.end()) res = min(res, abs(*(it)-i + 1));
if (it != s.begin()) res = min(res, abs(*(--it) - i + 1));
cout << res << endl;
s.erase(s.find(i - pa[b[i]]));
s.insert(n - pa[b[i]] + i);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod1(long long x) {
if (x >= 0) {
return x;
}
return -x;
}
vector<long long> countDigit(long long n) {
vector<long long> ret;
while (n != 0) {
ret.push_back(n % 10);
n = n / 10;
}
return ret;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm1(long long a, long long b) { return (a / gcd(a, b)) * b; }
bool prime[1000000];
void SieveOfEratosthenes(long long n) {
memset(prime, true, sizeof(prime));
prime[1] = false;
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
bool isPowerOfTwo(long long n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
bool PowerOfFour(long long num) {
if (num <= 0) return false;
while (num != 1) {
if (num % 4 != 0) return false;
num = num / 4;
}
return true;
}
bool compare(pair<long long, long long> p1, pair<long long, long long> p2) {
if (p1.first != p2.first) {
return p1.first > p2.first;
} else {
p1.second > p2.second;
}
}
bool compare1(pair<long long, long long> p1, pair<long long, long long> p2) {
if (p1.second != p2.second) {
return p1.second < p2.second;
} else {
p1.first < p2.first;
}
}
bool isPalindrome(string str) {
long long l = 0;
long long h = str.size() - 1;
while (h > l) {
if (str[l++] != str[h--]) {
return false;
}
}
return true;
}
vector<long long> primef(long long n) {
vector<long long> v;
if (n == 1) {
return v;
}
while (n % 2 == 0) {
v.push_back(2);
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
v.push_back(i);
n = n / i;
}
}
if (n > 2) v.push_back(n);
return v;
}
long long mod = 1000000007;
long long fact1(long long x) {
if (x < 2) {
return 1;
}
return (x * fact1(x - 1)) % mod;
}
long long power1(long long x, long long y) {
long long r = 1;
while (y > 0) {
r = (r % mod * x % mod) % mod;
y--;
}
return r;
}
bool isp(long long x) {
if (x >= 0) {
long long sr = sqrt(x);
return (sr * sr == x);
}
return false;
}
bool isPri(long long n) {
if (n <= 1) return false;
for (long long i = 2; i < n; i++)
if (n % i == 0) return false;
return true;
}
long long power2(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long modInverse(long long b, long long m) {
long long x, y;
long long g = gcdExtended(b, m, &x, &y);
if (g != 1) return -1;
return (x % m + m) % m;
}
long long ask(long long val) {
cout << val << endl;
fflush(stdout);
long long x;
cin >> x;
return x;
}
void solve() {
string s, t;
cin >> s >> t;
long long st = 0;
long long n = s.size();
long long m = t.size();
long long o = n % 2;
long long e = m % 2;
if (o != e) {
st++;
}
long long ind = 0;
while (st < n && ind < m) {
if (s[st] == t[ind]) {
st++;
ind++;
} else {
st = st + 2;
}
}
if (ind == m) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100001];
bool visited[100001];
int color[100001];
bool dfs(int v) {
visited[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
if (!visited[adj[v][i]]) {
color[adj[v][i]] = 1 - color[v];
if (!dfs(adj[v][i])) return 0;
} else {
if (color[v] + color[adj[v][i]] != 1) return 0;
}
}
return 1;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
color[i] = 1;
if (!dfs(i)) {
printf("-1\n");
return 0;
}
}
}
int num1 = 0, num2 = 0;
vector<int> v1, v2;
for (int i = 1; i <= n; i++) {
if (color[i] == 1) {
num1++;
v1.push_back(i);
} else {
num2++;
v2.push_back(i);
}
}
printf("%d\n", num1);
for (int i = 0; i < num1; i++) printf("%d ", v1[i]);
printf("\n");
printf("%d\n", num2);
for (int i = 0; i < num2; i++) printf("%d ", v2[i]);
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, l, r, tot, x, y, d, rd, ans = -1;
inline long long gt(long long x, long long y) {
if (x == 0) return 0;
return x > 0 ? ((x - 1) / y + 1) : (x / y);
}
inline long long ft(long long x, long long y) {
if (x == 0) return 0;
return x > 0 ? (x / y) : ((x + 1) / y - 1);
}
int main() {
long long i, j, res, sum;
scanf("%I64d%I64d%I64d%I64d", &n, &l, &r, &tot);
d = l <= r ? (r - l + 1) : (r + n - l + 1);
rd = n - d;
if (n <= 5000) {
for (i = 0; i <= d; ++i)
for (j = 0; j <= rd; ++j) {
sum = n + i + j;
res = (tot - 1) % sum + 1;
if (res == d + i)
ans = max(ans, i + j);
else if (i && res == d + i - 1)
ans = max(ans, i + j);
}
} else {
long long lim = tot / n, dd = d << 1, mn, mx;
if (tot + 1 >= d && tot + 1 <= dd)
ans = max(ans, tot + 1 - d + rd);
else if (tot >= d && tot <= dd)
ans = max(ans, tot - d + rd);
for (i = 1; i <= lim; ++i) {
res = tot - (i + 1) * d - i * rd;
if (res >= 0) {
x = res % i;
y = res / i - x;
mx = min(ft(x, i), ft(rd - y, i + 1));
mn = max(gt(x - d, i), gt(-y, i + 1));
if (mn <= mx) ans = max(ans, (res - x) / i + mx);
}
res++;
if (res >= 0) {
x = res % i;
y = res / i - x;
mx = min(ft(x - 1, i), ft(rd - y, i + 1));
mn = max(gt(x - d, i), gt(-y, i + 1));
if (mn <= mx) ans = max(ans, (res - x) / i + mx);
}
}
}
printf("%I64d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 1000000000 + 1;
int main() {
int n;
cin >> n;
bool ok = false;
long long lx = INF, ly = INF, rx = 0, ry = 0;
long long s = 0;
for (int i = 0; i < (n); i++) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
lx = min(lx, a);
ly = min(ly, b);
rx = max(rx, c);
ry = max(ry, d);
long long add = abs(a - c) * abs(b - d);
s += add;
}
if (abs(lx - rx) == abs(ly - ry)) {
if (abs(lx - rx) * abs(lx - rx) == s) ok = true;
}
puts(ok ? "YES" : "NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int k;
cin >> k;
string s;
cin >> s;
if (k == 1) {
cout << 1 << endl << s << endl;
return;
}
for (int i = 0; i < k; i++) {
if (s[i] == '1' || s[i] == '4' || s[i] == '6' || s[i] == '8' ||
s[i] == '9') {
cout << 1 << endl;
cout << s[i] << endl;
return;
}
}
cout << 2 << endl;
for (int i = 0; i < k; i++) {
if (s[i] == '2' || s[i] == '5' || s[i] == '7')
for (int j = i + 1; j < k; j++) {
if (s[j] != '3') {
cout << s[i] << s[j] << endl;
return;
}
}
if (s[i] == '3') {
for (int j = i + 1; j < k; j++) {
if (s[j] != '7') {
cout << 3 << s[j] << endl;
return;
}
}
}
}
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, arr[55], coun, maxi;
int main() {
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", arr + i);
scanf("%d", &n);
while (n--) {
scanf("%d", &ans);
for (int i = 0; i < m; i++) {
if (ans % arr[i] == 0 && ans / arr[i] > maxi) {
maxi = ans / arr[i];
coun = 1;
} else if (ans % arr[i] == 0 && ans / arr[i] == maxi)
coun++;
}
}
printf("%d\n", coun);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
long long hcf(long long a, long long b) {
if (b == 0) return a;
return hcf(b, a % b);
}
unsigned long long stringtoll(string s) {
unsigned long long ans = 0;
for (unsigned long long i = 0; i < s.length(); i++)
ans = ans * 10 + (s[i] - '0');
return ans;
}
vector<long long> root(long long n) {
vector<long long> ans;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
ans.push_back(i);
if (i != n / i) ans.push_back(n / i);
}
}
return ans;
}
bool ifprime(long long n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return false;
}
return true;
}
long long logat(long long n, long long base) { return (log(n) / log(base)); }
long long factorial(long long n) {
if (n == 0) return 1;
return (n * factorial(n - 1)) % 998244353;
}
void baspri(bool flag) {
if (flag)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
long long lcm(long long a, long long b) { return (a / hcf(a, b)) * b; }
vector<pair<long long, long long>> prime_fact(long long n) {
vector<pair<long long, long long>> ans;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
long long another = 0;
while (n % i == 0) {
n = n / i;
another++;
}
ans.push_back({i, another});
}
}
if (n > 1) ans.push_back({n, 1});
return ans;
}
long long pw(long long n, long long r, long long mop) {
long long res = 1;
while (r != 0) {
if (r % 2) {
res = (res * n) % mop;
r--;
}
n = (n * n) % mop;
r = r / 2;
}
return res;
}
int query(int a, int b) {
cout << "? " << a << " " << b << "\n";
cout.flush();
int t;
cin >> t;
return t;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
{
long long n, m;
cin >> n >> m;
vector<long long> f(n + 1);
vector<long long> b(m);
vector<vector<long long>> op(n + 1);
for (long long i = 1; i < n + 1; i++) {
cin >> f[i];
op[f[i]].push_back(i);
}
for (long long i = 0; i < m; i++) cin >> b[i];
vector<long long> a(m);
long long ans = 0;
for (long long i = 0; i < m; i++) {
if (op[b[i]].size() == 0) {
ans = 2;
break;
} else if (op[b[i]].size() > 1 || ans == 1)
ans = 1;
else {
a[i] = op[b[i]][0];
}
}
if (ans == 2) {
cout << "Impossible"
<< "\n";
return 0;
}
if (ans == 1) {
cout << "Ambiguity"
<< "\n";
return 0;
}
cout << "Possible"
<< "\n";
for (auto i : a) cout << i << " ";
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4444444777;
vector<long long> a;
long long l, r;
long long ans;
void solve(long long num) {
if (num > inf) return;
a.push_back(num * 10 + 4);
a.push_back(num * 10 + 7);
solve(num * 10 + 4);
solve(num * 10 + 7);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
a.push_back(4);
solve(4);
a.push_back(7);
solve(7);
sort(a.begin(), a.end());
cin >> l >> r;
ans = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] < l) continue;
if (a[i] < r) {
ans += (1LL * (a[i] - l + 1) * a[i]);
l = a[i] + 1;
} else {
ans += (1LL * (r - l + 1) * a[i]);
break;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[401][401];
int f1(int dist[], bool vis[]) {
int mi = INT_MAX, x;
for (int i = 0; i < n; i++) {
if (vis[i] == false && dist[i] <= mi) {
mi = dist[i];
x = i;
}
}
return x;
}
int f(int s) {
int dist[100001];
int i, j;
bool vis[100001];
for (i = 0; i < n; i++) {
dist[i] = INT_MAX;
vis[i] = false;
}
dist[s] = 0;
for (i = 0; i < n - 1; i++) {
int x = f1(dist, vis);
vis[x] = true;
for (j = 0; j < n; j++) {
if (vis[j] == false && a[x][j] == 1 && dist[x] != INT_MAX &&
dist[x] + a[x][j] < dist[j]) {
dist[j] = dist[x] + a[x][j];
}
}
}
return dist[n - 1];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long i, j, k;
cin >> n >> m;
for (i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
a[x - 1][y - 1] = 1;
a[y - 1][x - 1] = 1;
}
int x = f(0);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (a[i][j] == 0)
a[i][j] = 1;
else
a[i][j] = 0;
}
}
int y = f(0);
if (x == INT_MAX || y == INT_MAX)
cout << -1 << "\n";
else
cout << max(y, x) << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int A[1111][1111];
int h[4][1111][1111];
int M, N, Q, i, j, x;
void Preprocess() {
for (j = 1; j <= N; j++) h[0][0][j] = 0;
for (i = 1; i <= M; i++)
for (j = 1; j <= N; j++)
if (A[i][j])
h[0][i][j] = 1 + h[0][i - 1][j];
else
h[0][i][j] = 0;
for (j = 1; j <= N; j++) h[1][M + 1][j] = 0;
for (i = M; i >= 1; i--)
for (j = 1; j <= N; j++)
if (A[i][j])
h[1][i][j] = 1 + h[1][i + 1][j];
else
h[1][i][j] = 0;
for (i = 1; i <= M; i++) h[2][0][i] = 0;
for (j = 1; j <= N; j++)
for (i = 1; i <= M; i++)
if (A[i][j])
h[2][j][i] = 1 + h[2][j - 1][i];
else
h[2][j][i] = 0;
for (i = 1; i <= M; i++) h[3][N + 1][i] = 0;
for (j = N; j >= 1; j--)
for (i = 1; i <= M; i++)
if (A[i][j])
h[3][j][i] = 1 + h[3][j + 1][i];
else
h[3][j][i] = 0;
}
void Update(int r, int c) {
A[r][c] = 1 - A[r][c];
j = c;
for (i = 1; i <= M; i++)
if (A[i][j])
h[0][i][j] = 1 + h[0][i - 1][j];
else
h[0][i][j] = 0;
for (i = M; i >= 1; i--)
if (A[i][j])
h[1][i][j] = 1 + h[1][i + 1][j];
else
h[1][i][j] = 0;
i = r;
for (j = 1; j <= N; j++)
if (A[i][j])
h[2][j][i] = 1 + h[2][j - 1][i];
else
h[2][j][i] = 0;
for (j = N; j >= 1; j--)
if (A[i][j])
h[3][j][i] = 1 + h[3][j + 1][i];
else
h[3][j][i] = 0;
}
int stk[1111][2], nstk;
int FindLargestAreaRectangle(int dir, int x, int xneed, int xmax) {
int amax = 0, j, jleft, height, left, right, a;
nstk = 0;
h[dir][x][xmax + 1] = 0;
for (j = 1; j <= xmax + 1; j++)
if (h[dir][x][j] == 0) {
while (nstk >= 1) {
height = stk[nstk][0];
left = stk[nstk][1];
right = j - 1;
if (left <= xneed && xneed <= right) {
a = height * (right - left + 1);
if (a > amax) amax = a;
}
nstk--;
}
} else {
jleft = j;
while (nstk >= 1 && stk[nstk][0] >= h[dir][x][j]) {
height = stk[nstk][0];
left = stk[nstk][1];
right = j - 1;
if (left <= xneed && xneed <= right) {
a = height * (right - left + 1);
if (a > amax) amax = a;
}
if (stk[nstk][1] < jleft) jleft = stk[nstk][1];
nstk--;
}
nstk++;
stk[nstk][0] = h[dir][x][j];
stk[nstk][1] = jleft;
}
return amax;
}
int Query(int r, int c) {
if (A[r][c] == 0) return 0;
int a1, a2, a3, a4;
a1 = FindLargestAreaRectangle(0, r, c, N);
a2 = FindLargestAreaRectangle(1, r, c, N);
a3 = FindLargestAreaRectangle(2, c, r, M);
a4 = FindLargestAreaRectangle(3, c, r, M);
return max(max(a1, a2), max(a3, a4));
}
int main() {
int op, x, y;
scanf("%d %d %d", &M, &N, &Q);
for (i = 1; i <= M; i++)
for (j = 1; j <= N; j++) scanf("%d", &(A[i][j]));
Preprocess();
while (Q--) {
scanf("%d %d %d", &op, &x, &y);
if (op == 1)
Update(x, y);
else
printf("%d\n", Query(x, y));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, vis[1005], cnt[1005], mp[1005], VIS[1005];
vector<int> v[1005];
vector<int> special;
vector<int> nodes;
int CNT = 0;
void dfs(int start, int par = -1) {
vis[start] = 1;
CNT++;
for (int i = 0; i < v[start].size(); i++) {
int curr = v[start][i];
if (vis[curr] || curr == par) continue;
dfs(curr, start);
}
}
void solve() {
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &k);
for (int i = 0; i < k; i++) {
int temp;
scanf("%d", &temp);
special.push_back(temp);
}
for (int i = 0; i < m; i++) {
int from, to;
scanf("%d", &from);
scanf("%d", &to);
v[from].push_back(to);
v[to].push_back(from);
}
memset(vis, 0, sizeof(vis));
memset(cnt, 0, sizeof(cnt));
memset(VIS, 0, sizeof(VIS));
long long ans = 0;
int maxx = 0;
memset(mp, 0, sizeof(mp));
for (int i = 0; i < special.size(); i++) {
mp[special[i]] = 1;
CNT = 0;
dfs(special[i]);
int val = CNT;
ans += (val * (val - 1)) / 2;
maxx = max(maxx, val);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
cnt += (!vis[i]);
}
ans += (cnt * (cnt - 1)) / 2;
ans += (cnt * maxx);
cout << max(0ll, ans - m);
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, c = 0;
cin >> n;
if (n >= 100) {
c += n / 100;
n = n % 100;
}
if (n >= 20) {
c += n / 20;
n = n % 20;
}
if (n >= 10) {
c += n / 10;
n = n % 10;
}
if (n >= 5) {
c += n / 5;
n = n % 5;
}
if (n > 0) {
c += n / 1;
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200009;
struct SegTreeNode {
int left, right, len, lMax, rMax, Max;
void init(int a, int b) {
left = a;
right = b;
lMax = rMax = Max = len = b - a + 1;
}
void reSet(int key) { lMax = rMax = Max = key; }
} nod[MAXN << 2];
void build(int N, int a, int b) {
nod[N].init(a, b);
if (a == b) return;
int mid = (a + b) >> 1;
build(N << 1, a, mid);
build(1 | (N << 1), mid + 1, b);
}
void update(int N, int pos, int key) {
if (nod[N].len == 1) {
nod[N].reSet(key);
return;
}
int mid = (nod[N].left + nod[N].right) >> 1, x = N << 1, y = x | 1;
if (mid >= pos)
update(x, pos, key);
else
update(y, pos, key);
nod[N].Max = max(nod[x].Max, max(nod[y].Max, nod[x].rMax + nod[y].lMax));
nod[N].lMax = nod[x].lMax;
if (nod[N].lMax == nod[x].len) nod[N].lMax += nod[y].lMax;
nod[N].rMax = nod[y].rMax;
if (nod[N].rMax == nod[y].len) nod[N].rMax += nod[x].rMax;
}
int query(int N, int cur) {
if (nod[N].len == 1) return N;
int x = N << 1, y = x | 1;
if (nod[x].Max >= cur) return query(x, cur);
if (nod[x].rMax + nod[y].lMax >= cur)
return nod[x].right - nod[x].rMax + 1 + cur / 2;
return query(y, cur);
}
int num2id[MAXN * 5];
int main() {
int n, m, a, b, x, y, z, ans;
while (scanf("%d%d", &n, &m) != EOF) {
build(1, 1, n);
while (m--) {
scanf("%d%d", &a, &b);
if (a == 1) {
x = nod[1].lMax;
y = nod[1].rMax;
z = nod[1].Max;
if (x >= y && x * 2 >= z)
ans = 1;
else if (y > x && y * 2 >= z + 2)
ans = n;
else {
if (z % 2 == 0) --z;
ans = query(1, z);
}
update(1, ans, 0);
num2id[b] = ans;
printf("%d\n", ans);
} else {
b = num2id[b];
update(1, b, 1);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[2050][2050], p[2050][2050], dis[2050], vis[2050];
int n;
priority_queue<pair<int, int> > q;
void spfa(int st) {
for (int i = 1; i <= n; i++) dis[i] = -1, vis[i] = 0;
dis[st] = 1;
q.push(make_pair(-1, st));
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (vis[u]++) continue;
for (int v = 1; v <= n; v++) {
if (a[u][v] == 0) continue;
if (dis[v] == -1 || dis[v] > dis[u] + a[u][v])
dis[v] = dis[u] + a[u][v], q.push(make_pair(-dis[v], v));
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &p[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = p[i][j];
int flag = 0;
spfa(1);
for (int j = 1; j <= n; j++)
if (dis[j] == -1) flag = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = p[j][i];
spfa(1);
for (int j = 1; j <= n; j++)
if (dis[j] == -1) flag = 1;
if (flag)
puts("NO");
else
puts("YES");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> g[1000];
vector<vector<long long>> dist(2, vector<long long>(1000, 2000));
void dist_bfs(long long s, long long n, long long id) {
deque<pair<long long, long long>> q;
vector<long long> vis(n, false);
q.push_back(make_pair(s, 0));
vis[s] = true;
while (!q.empty()) {
auto x = q.front();
dist[id][x.first] = x.second;
q.pop_front();
for (long long i = 0; i < g[x.first].size(); i++) {
if (!vis[g[x.first][i]]) {
vis[g[x.first][i]] = true;
q.push_back(make_pair(g[x.first][i], x.second + 1));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, i, j, k, t, s;
cin >> n >> m >> s >> t;
s--;
t--;
vector<vector<bool>> adjmat(1000, vector<bool>(1000, false));
for (i = 0; i < m; i++) {
cin >> j >> k;
g[j - 1].push_back(k - 1);
g[k - 1].push_back(j - 1);
adjmat[j - 1][k - 1] = true;
adjmat[k - 1][j - 1] = true;
}
dist_bfs(s, n, 0);
dist_bfs(t, n, 1);
long long ans = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < i; j++) {
if (!adjmat[i][j] && i != j) {
long long p = dist[0][i] + dist[1][j] + 1,
q = dist[0][j] + dist[1][i] + 1;
if (p >= dist[0][t] && q >= dist[0][t]) ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
int holes[m];
map<int, bool> mp;
for (int i = 0; i < m; i++) {
cin >> holes[i];
mp[holes[i]] = true;
}
int lastpos = 1;
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
if (mp[lastpos]) {
cout << lastpos;
return 0;
}
if (x == lastpos) {
if (mp[y]) {
cout << y;
return 0;
}
lastpos = y;
} else if (y == lastpos) {
if (mp[x]) {
cout << x;
return 0;
}
lastpos = x;
}
}
cout << lastpos;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200;
int arr[MAXN];
int top[MAXN];
int f[MAXN];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
f[i] = x;
top[x] = max(top[x], arr[i]);
}
int ans = 0;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
if (arr[x] != top[f[x]]) ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
if (n == 1)
cout << "1";
else if (n == 2)
cout << "2";
else if (n <= 3)
cout << "6";
else if (n == 6)
cout << "60";
else if (n % 3 == 0 && n % 2 == 0)
cout << (n - 1) * (n - 2) * (n - 3);
else {
if (n % 2 != 0)
cout << n * (n - 1) * (n - 2);
else
cout << n * (n - 1) * (n - 3);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
vector<int> b[5];
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
for (int i = 0; i < 5; i++) b[i].clear();
for (int i = 1; i <= n; i++) {
cin >> s;
int len = -int(s.size());
for (int j = 0; j < 5; j++) b[j].push_back(len);
for (auto c : s) {
b[c - 'a'].back() += 2;
}
}
int bestBalance = 0;
int bestCount = 0;
for (int i = 0; i < 5; i++) {
auto& t = b[i];
sort(t.begin(), t.end());
reverse(t.begin(), t.end());
int temp = t[0];
int j;
for (j = 1; j < n && temp > 0; j++) {
temp += t[j];
}
if (temp <= 0) j--;
if (j > bestCount) {
bestCount = j;
}
}
cout << bestCount << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int TT;scanf("%d",&TT);for(int TTT=1;TTT<=TT;TTT++)
#define fastio() ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define forrr(i,x,y) for(int i=x;i<=y;++i)
#define rofff(i,x,y) for(int i=x;i>=y;--i)
#define forr(i,x,y) for(int i=x;i<y;++i)
#define roff(i,x,y) for(int i=x;i>y;--i)
#define lowbit(x) (x&-x)
#define fin(FI) freopen(FI,"r",stdin)
#define fout(FI) freopen(FI,"w",stdout)
#define fi first
#define se second
#define mp make_pair
#define sf scanf
#define pf printf
#define pb push_back
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef pair<string,int> psi;
const ldb pi = acos((ldb)-1);
void in(initializer_list<int*> li) {
for(auto ptr=li.begin(); ptr!=li.end(); ptr++)scanf("%d",*ptr);
}
void in(initializer_list<ll*> li) {
for(auto ptr=li.begin(); ptr!=li.end(); ptr++)scanf("%lld",*ptr);
}
void in(initializer_list<db*> li) {
for(auto ptr=li.begin(); ptr!=li.end(); ptr++)scanf("%lf",*ptr);
}
void out(initializer_list<int> li) {
for(auto ptr=li.begin(); ptr!=li.end(); ptr++)printf("%d ",*ptr);
}
void outln(initializer_list<int> li) {
for(auto ptr=li.begin(); ptr!=li.end(); ptr++)printf("%d\n",*ptr);
}
void out(initializer_list<ll> li) {
for(auto ptr=li.begin(); ptr!=li.end(); ptr++)printf("%lld ",*ptr);
}
void outln(initializer_list<ll> li) {
for(auto ptr=li.begin(); ptr!=li.end(); ptr++)printf("%lld\n",*ptr);
}
int in(int &a,int &b,int &c,int &d) {
return scanf("%d%d%d%d",&a,&b,&c,&d);
}
int in(int &a,int &b,int &c) {
return scanf("%d%d%d",&a,&b,&c);
}
int in(int &a,int &b) {
return scanf("%d%d",&a,&b);
}
int in(ll &a,ll &b) {
return scanf("%lld%lld",&a,&b);
}
int in(ll &a,ll &b,ll &c,ll &d) {
return scanf("%lld%lld%lld%lld",&a,&b,&c,&d);
}
int in(ll &a,ll &b,ll &c) {
return scanf("%lld%lld%lld",&a,&b,&c);
}
int in(ll &a) {
return scanf("%lld",&a);
}
int in(int &a) {
return scanf("%d",&a);
}
int in(char *s) {
return scanf("%s",s);
}
int in(char &c) {
return scanf("%c",&c);
}
void out(int a,bool ln) {
printf("%d%c",a," \n"[ln]);
}
void out(ll a,bool ln) {
printf("%lld%c",a," \n"[ln]);
}
void out(db a,int digit,bool ln) {
printf("%.*f%c",digit,a," \n"[ln]);
}
ll gcd(ll a, ll b) {
return b?gcd(b,a%b):a;
}
ll lcm(ll a, ll b) {
return a/gcd(a,b)*b;
}
const int inf = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 3e5+5;
const int maxm = 2e6;
const ll mod = 998244353;
int n,m;
ll dis[maxn],edge[1000][1000];
bool vis[maxn];
void dijkstra(int s) {
forr(i,0,n) {
dis[i]=edge[s][i];
vis[i]=0;
}
while(1) {
int u=-1;
forr(i,0,n) {
if(vis[i])
continue;
if(u==-1||dis[i]<dis[u])
u=i;
}
if(u==-1)
break;
vis[u]=1;
int nxt=(u+1)%n;
if(dis[nxt]>dis[u]+1) {
dis[nxt]=dis[u]+1;
}
forr(i,0,n) {
int to=(i+dis[u])%n;
ll w=dis[u]+edge[u][i];
if(dis[to]>w) {
dis[to]=w;
}
}
}
dis[s]=0;
}
int main() {
in(n,m);
forr(i,0,n) {
forr(j,0,n) {
edge[i][j]=1e18;
}
}
while(m--) {
int u,v,w;
in(u,v,w);
edge[u][v]=w;
}
forr(i,0,n) {
dijkstra(i);
forr(j,0,n) {
out(dis[j],j==n-1);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool solve(long long n, long long k) {
long long vasya = 0;
long long total = n;
while (total > 0) {
long long d = min(total, k);
vasya = vasya + d;
total = total - k;
total = total - total / 10;
}
if (vasya * 2 >= n) {
return true;
} else {
return false;
}
}
int main() {
long long n;
cin >> n;
long long l = 1, h = n;
long long answer = n;
while (l <= h) {
long long mid = (l + h) / 2;
if (solve(n, mid) == true) {
answer = min(answer, mid);
h = mid - 1;
} else {
l = mid + 1;
}
}
cout << answer << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > a;
vector<int> ans;
int min1, id1;
int n, h;
int res;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> h;
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end());
res = a[n - 1].first + a[n - 2].first - (a[0].first + a[1].first);
ans.assign(n, 1);
id1 = -1;
for (int i = 0; i < n; ++i) {
if (n == 2) {
break;
}
int cur = 0;
if (i == 0) {
cur -= min(a[0].first + a[1].first + h, a[1].first + a[2].first);
} else if (i == 1) {
cur -= min(a[0].first + a[1].first + h, a[0].first + a[2].first);
} else {
cur -= min(a[i].first + a[0].first + h, a[0].first + a[1].first);
}
if (i == n - 2) {
cur += max(a[n - 2].first + a[n - 1].first + h,
a[n - 3].first + a[n - 1].first);
} else if (i == n - 1) {
cur += max(a[n - 2].first + a[n - 1].first + h,
a[n - 3].first + a[n - 2].first);
} else {
cur +=
max(a[i].first + a[n - 1].first + h, a[n - 1].first + a[n - 2].first);
}
if (cur < res) {
if (id1 != -1) {
ans[id1] = 1;
}
id1 = a[i].second;
ans[id1] = 2;
res = cur;
}
}
cout << res << "\n";
for (int i = 0; i < n; ++i) {
cout << ans[i] << " ";
}
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool newLine = false;
bool newLineA = false;
bool pairEndLine = false;
template <class T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& i : v) {
in >> i;
}
return in;
}
template <class T>
ostream& operator<<(ostream& out, const vector<T>& v) {
for (auto i : v) {
out << i;
if (!newLine) {
out << ' ';
} else {
out << '\n';
}
}
if (!newLine && newLineA) {
out << '\n';
}
return out;
}
template <class T, class U>
istream& operator>>(istream& in, pair<T, U>& p) {
in >> p.first >> p.second;
return in;
}
template <class T, class U>
ostream& operator<<(ostream& out, const pair<T, U>& p) {
out << p.first << ' ' << p.second;
if (pairEndLine) {
cout << '\n';
}
return out;
}
long long gettime() {
return chrono::high_resolution_clock::now().time_since_epoch().count() /
(long long)1000000;
}
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
mt19937_64 rnd_64(
chrono::high_resolution_clock::now().time_since_epoch().count());
unsigned long long randnum(unsigned long long l, unsigned long long r) {
return l + rnd_64() % (r - l + 1);
}
int mod;
bool isPrime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
const int N = 2e5 + 100;
int toPrime[N];
const int A = 2e7 + 100;
char p[A];
int mult(int a, int b) { return (long long)a * b % mod; }
int geth(vector<int> v) {
int res = 1;
for (auto i : v) {
res = mult(res, toPrime[i]);
}
return res;
}
int n, m, k;
vector<vector<int>> h;
int hashall;
int r(vector<int> cur) {
if (cur.size() == k + 1) {
int a = 1;
for (int i = 1; i <= k; i++) {
a = mult(a, h[i][cur[i]]);
}
return (a == hashall);
}
int ans = 0;
for (int i = 0; i < (cur.size()); i++) {
cur.push_back(i);
ans += r(cur);
cur.pop_back();
}
return ans;
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0);
mod = randnum(7e8, 1e9);
while (!isPrime(mod)) mod++;
for (auto& i : p) i = 1;
for (int i = 2; i < A; i++) {
if (p[i]) {
static int pos = 0;
toPrime[pos++] = i;
if (pos == N) break;
for (int j = 2 * i; j < A; j += i) {
p[j] = false;
}
}
}
cin >> n >> m >> k;
vector<vector<pair<int, int>>> g(n);
for (int i = 0; i < (m); i++) {
int a, b, w;
cin >> a >> b >> w;
a--;
b--;
g[a].push_back(make_pair(w, b));
}
for (auto& i : g) {
sort(i.begin(), i.end());
}
vector<vector<int>> v(k + 1);
for (auto i : g) {
for (auto j : i) {
v[i.size()].push_back(j.second);
}
}
h.resize(k + 1);
for (int i = 1; i <= k; i++) {
h[i].resize(i);
for (int start = 0; start < (i); start++) {
vector<int> cur;
int pos = start;
while (pos < v[i].size()) {
cur.push_back(v[i][pos]);
pos += i;
}
h[i][start] = geth(cur);
}
}
vector<int> trash(n);
for (int i = 0; i < (n); i++) trash[i] = i;
hashall = geth(trash);
cout << r(vector<int>(1, -1));
return 0;
}
| 7 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
using namespace std;
#define int long long
const int mod = 1e9 + 7;
signed main()
{
string s;
while(getline(cin, s))
{
cout << "NO\n";
flush(cout);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p1, p2, p3, p4, a, b;
cin >> p1 >> p2 >> p3 >> p4 >> a >> b;
int ans = 0;
for (int i = a; i <= b; i++)
if (i % p1 % p2 % p3 % p4 == i) ans++;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long v[112345];
int main() {
long long n;
cin >> n;
long long ans = 0;
for (int i = 0; i < n; ++i) {
scanf("%lld", v + i);
ans += v[i] * (n + 1LL - v[i]);
}
for (int i = 1; i < n; ++i) {
long long mini = min(v[i], v[i - 1]);
long long maxi = max(v[i], v[i - 1]);
ans -= mini * (n + 1LL - maxi);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long a[n], b[m];
long long ca[2];
ca[0] = 0;
ca[1] = 0;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
ca[x % 2]++;
}
long long cb[2];
cb[0] = 0;
cb[1] = 0;
for (long long i = 0; i < m; i++) {
long long x;
cin >> x;
cb[x % 2]++;
}
cout << min(ca[0], cb[1]) + min(ca[1], cb[0]) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void Weapons19() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
Weapons19();
long long n;
cin >> n;
vector<vector<long long>> v(26, vector<long long>(26, 0));
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
long long f = s[0] - 97;
long long r = s[s.size() - 1] - 97;
for (long long j = 0; j < 26; j++) {
if (j == f && f == r) {
v[f][r] += s.size();
continue;
}
if (j == f && v[j][r] < s.size()) {
v[f][r] = s.size();
}
if (v[j][f] + s.size() > v[j][r] && v[j][f] != 0) {
v[j][r] = v[j][f] + s.size();
}
}
}
long long ans = 0;
for (long long i = 0; i < 26; i++) {
ans = max(ans, v[i][i]);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, zn;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
cin >> k;
zn = min((n + 1) / 2, (m + 1) / 2);
if (k > zn) {
cout << "0" << '\n';
return 0;
}
n -= (k - 1) * 2;
m -= (k - 1) * 2;
if (n == 1) {
cout << (m + 1) / 2 << '\n';
return 0;
}
if (m == 1) {
cout << (n + 1) / 2 << '\n';
return 0;
}
cout << n + m - 2 << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
getline(cin, s);
getline(cin, t);
bool vys = false;
int poc = 0;
for (int i = 0; i < (s.length()); i++)
if (s[i] == '1') poc++;
for (int i = 0; i < (s.length() + 1); i++) {
if (s.length() - i > t.length()) continue;
bool pom = true;
for (int j = i; j < s.length(); j++)
if (s[j] != t[j - i]) pom = false;
if (!pom) continue;
int p = 0;
for (int j = 0; j < (i); j++)
if (s[j] == '1') p++;
int p1 = 0;
for (int j = s.length() - i; j < t.length(); j++)
if (t[j] == '1') p1++;
if ((poc % 2) + p >= p1) vys = true;
}
if (vys)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int x[100010];
long long gcd(long long A, long long B) {
if (B == 0) return A;
return gcd(B, A % B);
}
int main() {
int n;
long long sum1 = 0, sum2 = 0, sumBefore = 0, sumtot = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &x[i]);
sum1 += x[i];
}
sort(x + 1, x + n + 1);
long long val = n - 1;
long long i = 0;
while (val > 0) {
sum2 += val * (x[n - i] - x[i + 1]);
i++;
val -= 2;
}
sumtot = sum1 + 2 * sum2;
long long _gcd = gcd(sumtot, n);
cout << sumtot / _gcd << " " << n / _gcd;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
double f(double O, double r, double d) { return r * O + r * sin(O) - d; }
double solve(double v, double r, double d) {
int cnt = 0;
double lb = 0, ub = 3.14159265, mid, val, val1, val2;
while (lb <= ub && cnt++ < 70) {
mid = (lb + ub) / 2;
val = f(mid, r, d);
val1 = f(lb, r, d);
val2 = f(ub, r, d);
if (val * val1 < 0) {
ub = mid;
} else {
lb = mid;
}
}
return (mid * r) / v;
}
int main() {
int n, i, j, k;
double m, ans, rem, r, v;
cin >> n >> r >> v;
while (n--) {
scanf("%d%d", &i, &j);
m = ((double)(j - i) / (2 * 3.14159265 * r));
int x = floor(m);
ans = (x * 2 * 3.14159265 * r) / v;
rem = (double)(j - i) - 2 * 3.14159265 * r * x;
rem = rem / 2;
ans += (solve(v, r, rem) * 2);
printf("%.15f\n", ans);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int func(char c) {
if (c >= 'a' && c <= 'z') {
return 1;
}
if (c >= 'A' && c <= 'Z') {
return 2;
}
return 0;
}
void solve() {
string s;
cin >> s;
long long int lw = 0;
long long int up = 0;
long long int nm = 0;
string str = s;
long long int mp[3] = {0};
for (long long int i = 0; i < s.length(); i++) {
mp[func(s[i])]++;
}
long long int cn = 0;
for (long long int i = 0; i < 3; i++) {
if (!mp[i]) cn++;
}
if (!cn) {
cout << s << endl;
return;
}
if (cn == 1) {
for (long long int i = 0; i < s.length(); i++) {
if (mp[func(s[i])] > 1) {
long long int index = 0;
for (long long int id = 0; id < 3; id++) {
if (!mp[id]) index = id;
}
if (index == 0) {
s[i] = '0';
break;
} else if (index == 1) {
s[i] = 'a';
break;
} else {
s[i] = 'A';
break;
}
}
}
cout << s << endl;
} else {
long long int index;
for (long long int i = 0; i < 3; i++) {
if (mp[i]) {
index = i;
break;
}
}
if (index == 1) {
s[0] = 'A';
s[1] = '0';
} else if (index == 0) {
s[0] = 'A';
s[1] = 'a';
} else {
s[0] = '0';
s[1] = 'a';
}
cout << s << endl;
}
}
int main() {
long long int t;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double MAXN = 10000000.0;
const double eps = 10e-6;
const double zero = 0.000000;
vector<int> idx;
int main() {
int n;
double t;
double x[102], v[102], m[102];
while (scanf("%d %lf", &n, &t) != EOF) {
for (int i = 0; i < n; i++) scanf("%lf %lf %lf", &x[i], &v[i], &m[i]);
while (fabs(t - zero) > eps) {
double min = t;
double tmp;
idx.clear();
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
tmp = MAXN;
if (fabs(x[i] - x[j]) < eps) continue;
if (v[i] * v[j] > zero) {
if (v[j] == v[i]) {
} else if (x[i] > x[j])
tmp = (x[i] - x[j]) / (v[j] - v[i]);
else
tmp = (x[j] - x[i]) / (v[i] - v[j]);
} else {
if (v[j] == zero && v[i] == zero) {
} else if (x[i] > x[j] && v[i] <= zero && v[j] >= zero)
tmp = (x[i] - x[j]) / (-v[i] + v[j]);
else if (x[i] < x[j] && v[i] >= zero && v[j] <= zero)
tmp = (x[j] - x[i]) / (-v[j] + v[i]);
}
if (tmp > zero && min >= tmp) {
if (min > tmp) {
idx.clear();
}
min = tmp;
idx.push_back(i);
idx.push_back(j);
}
}
}
t -= min;
for (int i = 0; i < n; i++) {
x[i] = x[i] + v[i] * min;
}
int i, j;
for (vector<int>::iterator it = idx.begin(); it != idx.end(); it += 2) {
i = *it, j = *(it + 1);
double vi = v[i];
v[i] = ((m[i] - m[j]) * v[i] + 2.000000 * m[j] * v[j]) / (m[i] + m[j]);
v[j] = ((m[j] - m[i]) * v[j] + 2.000000 * m[i] * vi) / (m[j] + m[i]);
}
}
for (int i = 0; i < n; i++) printf("%.5lf\n", x[i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1600003;
int n, p, M, m, N, cnt, idx, scc, siz;
int head[maxn], dfn[maxn], low[maxn], c[maxn];
vector<int> e[maxn];
int ans[maxn];
stack<int> s;
bool v[maxn];
bool flag;
void add(int u, int v) { e[u].push_back(v); }
void tarjan(int x) {
dfn[x] = low[x] = ++idx;
s.push(x);
v[x] = true;
for (int i = 0; i < e[x].size(); i++) {
int to = e[x][i];
if (!dfn[to]) {
tarjan(to);
low[x] = min(low[x], low[to]);
} else if (v[to])
low[x] = min(low[x], dfn[to]);
}
if (dfn[x] == low[x]) {
scc++;
while (1) {
int k = s.top();
s.pop();
v[k] = false;
c[k] = scc;
if (k == x) return;
}
}
}
void solve() {
for (int i = 1; i <= N + N; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= N; i++)
if (c[i] == c[i + N]) {
flag = true;
return;
}
}
int main() {
scanf("%d%d%d%d", &n, &p, &M, &m);
N = p + M + 1;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x + N, y);
add(y + N, x);
}
for (int i = 1; i <= p; i++) {
int l, r;
scanf("%d%d", &l, &r);
add(i, l + p + N);
add(i, r + p + 1);
add(l + p, i + N);
add(r + p + 1 + N, i + N);
}
for (int i = 1; i <= M; i++) {
add(i + p, i + p + 1);
add(i + p + 1 + N, i + p + N);
}
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v + N);
add(v, u + N);
}
add(p + 1, p + 1 + N);
solve();
if (flag) {
puts("-1");
return 0;
}
for (int i = 1; i <= p; i++)
if (c[i] < c[i + N]) ans[++siz] = i;
for (int i = 1; i <= M; i++)
if (c[i + p + 1] < c[i + p + 1 + N]) {
printf("%d %d\n", siz, i);
break;
}
for (int i = 1; i <= siz; i++) printf("%d ", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long poww(long long x, long long y, long long m) {
x = x % m;
if (y == 0) {
return 1;
}
if (y % 2 == 0) {
return poww(x * x, y / 2, m);
} else {
return (x * poww(x * x, y / 2, m)) % m;
}
}
const int mod = 1e9 + 7;
const int maxn = 2e5 + 10;
int t;
int n, a[maxn];
void solve() {
vector<int> a1;
vector<int> a2;
int i, j;
int first = 0, second = 0;
a1.push_back(a[0]);
for ((i) = 1; (i) < (2 * n); i = i + 1) {
if (a[i] == a1[first] && first < a1.size()) {
a2.push_back(a[i]);
first++;
} else {
a1.push_back(a[i]);
}
}
for ((i) = 0; (i) < (n); i = i + 1) {
cout << a1[i] << " ";
}
cout << "\n";
;
}
int main() {
int i, j;
cin >> t;
while (t--) {
cin >> n;
for ((i) = 0; (i) < (2 * n); i = i + 1) {
cin >> a[i];
}
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int x, y;
long long res = 0, tmp;
long long x2 = 0;
long long y2 = 0;
long long sumX = 0;
long long sumY = 0;
for (int i = 0; i < n; i++) {
scanf("%d %d", &x, &y);
tmp = x * x;
res += x2;
res -= (sumX * x) << 1;
res += i * tmp;
x2 += tmp;
sumX += x;
tmp = y * y;
res += y2;
res -= (sumY * y) << 1;
res += i * tmp;
y2 += tmp;
sumY += y;
}
printf("%I64d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
pair<int, int> E[MAXN];
int col[MAXN];
vector<int> e[MAXN];
void dfs(int x, int c) {
col[x] = c;
for (auto v : e[x])
if (!col[v]) dfs(v, 3 - c);
}
signed main() {
int n = read(), m = n << 1;
for (int i = 1, u, v; i <= n; i++)
u = read() + 1, v = read() + 1, e[u].push_back(v), e[v].push_back(u),
e[i * 2 - 1].push_back(i * 2), e[i * 2].push_back(i * 2 - 1),
E[i] = make_pair(u, v);
for (int i = 1; i <= m; i++)
if (!col[i]) dfs(i, 1);
for (int i = 1; i <= n; i++)
printf("%d %d\n", col[E[i].first], col[E[i].second]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100005;
struct Node {
int sum;
Node *left, *right;
Node() {
left = NULL;
right = NULL;
sum = 0;
}
};
typedef Node *PNode;
class Tree {
public:
PNode root;
int size;
PNode bild(int rt, int l, int r) {
if (l == r) {
PNode cur = new Node;
return cur;
}
int m = (l + r) / 2;
PNode cur = new Node;
cur->left = bild(rt * 2, l, m);
cur->right = bild(rt * 2 + 1, m + 1, r);
cur->sum = 0;
return cur;
}
public:
Tree() {}
Tree(int _size) {
size = _size;
root = bild(1, 1, size);
}
int suma(PNode rt, int l, int r, int L, int R) {
if (r < l || R < L) return 0;
if (L == l && R == r) {
return rt->sum;
}
int m = (l + r) / 2;
int ans = 0;
if (L <= m) ans += suma(rt->left, l, m, L, min(m, R));
if (R > m) ans += suma(rt->right, m + 1, r, max(m + 1, L), R);
return ans;
}
int ins(PNode rt, int l, int r, int L, int R) {
if (l == r) {
rt->sum += 1;
return l;
}
int m = (l + r) / 2;
int st = max(l, L);
int fn = min(m, R);
int ans = 0;
if (st <= fn && suma(root, 1, size, st, fn) < fn - st + 1)
ans = ins(rt->left, l, m, st, fn);
else {
st = max(m + 1, L);
fn = min(r, R);
ans = ins(rt->right, m + 1, r, st, fn);
}
rt->sum = rt->left->sum + rt->right->sum;
return ans;
}
int add(int num) {
int sum = suma(root, 1, size, num, size);
if (sum < size - num + 1) {
return ins(root, 1, size, num, size);
} else {
return ins(root, 1, size, 1, num - 1);
}
}
void del(PNode rt, int l, int r, int num) {
if (l == r) {
rt->sum = 0;
return;
}
int m = (l + r) / 2;
if (num <= m)
del(rt->left, l, m, num);
else
del(rt->right, m + 1, r, num);
rt->sum = rt->left->sum + rt->right->sum;
return;
}
};
int h, t, n;
int cnt;
int tr[maxN], numb[maxN];
int size[maxN];
map<int, pair<int, int> > data;
Tree *der[maxN];
long long ans = 0;
int main() {
scanf("%d%d%d\n", &h, &t, &n);
cnt = 0;
for (int i = 0; i < n; ++i)
if (tr[i] == 0) {
cnt++;
int j = i, kil = 0;
while (tr[j] == 0) {
numb[j] = ++kil;
tr[j] = cnt;
j = (j + t) % h;
}
size[cnt] = kil;
}
for (int i = 1; i <= cnt; ++i) {
der[i] = new Tree(size[i]);
}
for (int i = (0); (i) < (n); ++(i)) {
char q;
cin.get(q);
if ('+' == q) {
int ch, hsh;
scanf("%d %d\n", &ch, &hsh);
int dernum = tr[hsh];
int num = numb[hsh];
int cur_index = der[dernum]->add(num);
data[ch] = make_pair(tr[hsh], cur_index);
if (cur_index < num) cur_index += size[dernum];
if (num < cur_index) {
ans += cur_index - num;
}
} else {
int ch;
scanf("%d\n", &ch);
map<int, pair<int, int> >::iterator it = data.find(ch);
int dernum = (*it).second.first;
int num = (*it).second.second;
der[dernum]->del(der[dernum]->root, 1, size[dernum], num);
data.erase(ch);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const double dinf = 1e250;
const long long INF = (long long)(2e18);
const long long inf = (long long)(1e9 + 7);
vector<long long> r(2000000, 1);
int32_t main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
cin.tie(0);
vector<long long> p;
for (long long i = 2; i < r.size(); i++) {
if (r[i]) {
p.push_back(i);
for (long long j = i * i; j < r.size(); j += i) {
r[j] = 0;
}
}
}
long long n, x;
cin >> n >> x;
if (x == 2) return cout << 0, 0;
map<long long, long long> m;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
m[a] = 1;
}
if (m[1] == 1) return cout << 1, 0;
long long k = 0;
while (p[k] < x) {
if (m[p[k]] == 0) return cout << -1, 0;
k++;
}
cout << k;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, p;
long long ans;
int main() {
scanf("%d%d%d", &n, &m, &k);
if (n + m - 2 < k) {
puts("-1");
return 0;
}
if (k < n)
ans = max(ans, (long long)m * (n / (k + 1)));
else {
p = k - (n - 1);
ans = max(ans, (long long)m / (p + 1));
}
if (k < m)
ans = max(ans, (long long)n * (m / (k + 1)));
else {
p = k - (m - 1), ans = max(ans, (long long)n / (p + 1));
}
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long INF = (long long)1e18 + 123;
const int inf = (int)2e9 + 123;
const int mod = 1e9 + 7;
using namespace std;
vector<long long> t[2000011], pref[2000011];
long long L[2000011];
int n, m;
void dfs(int v = 1) {
if (v > n) return;
t[v].push_back(L[v]);
vector<long long> a, b;
if (v * 2 <= n) {
dfs(v * 2);
for (int i = 0; i < t[v * 2].size(); i++) {
a.push_back(t[v * 2][i] + L[v]);
}
}
if (v * 2 + 1 <= n) {
dfs(v * 2 + 1);
for (int i = 0; i < t[v * 2 + 1].size(); i++) {
b.push_back(t[v * 2 + 1][i] + L[v]);
}
}
int pos1 = 0, pos2 = 0;
while (pos1 < a.size() || pos2 < b.size()) {
if (pos1 >= a.size()) {
t[v].push_back(b[pos2++]);
} else if (pos2 >= b.size()) {
t[v].push_back(a[pos1++]);
} else {
if (a[pos1] <= b[pos2]) {
t[v].push_back(a[pos1++]);
} else {
t[v].push_back(b[pos2++]);
}
}
}
long long cnt = 0;
for (int i = 0; i < t[v].size(); i++) {
cnt += t[v][i];
pref[v].push_back(cnt);
}
}
long long get(int v, int last, int h) {
if (v > n) return 0;
int l = 0, r = t[v].size() - 1, mx = -1;
while (l <= r) {
int tm = (l + r) / 2;
if (t[v][tm] <= last) {
mx = tm;
l = tm + 1;
} else
r = tm - 1;
}
if (mx == -1) return 0ll;
return 1ll * h * (mx + 1) - pref[v][mx];
}
long long solve(int a, int h) {
long long ans = get(a * 2, h, h) + get(a * 2 + 1, h, h) + h, last = h,
x = a % 2;
last -= L[a];
a /= 2;
while (a > 0 && last >= 0) {
ans += last;
if (x == 0) {
ans += get(a * 2 + 1, last, last);
} else {
ans += get(a * 2, last, last);
}
x = a % 2;
last -= L[a];
a /= 2;
}
return ans;
}
int main() {
unsigned int FOR;
asm("rdtsc" : "=A"(FOR));
srand(FOR);
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 2; i <= n; i++) {
cin >> L[i];
}
dfs();
for (int i = 1; i <= m; i++) {
int x, h;
cin >> x >> h;
cout << solve(x, h) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int gi() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '?') return -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
bool eq(int a, int b) {
if (b == -1) return 1;
return a == b;
}
int n, D[310], L[310], Cnt[310], CNT[310], exist[310], maxdep[310];
int p[310];
int fir[610], dep[610], head[610], dis[10000010], nxt[10000010], w[10000010],
id, cnt;
int S, T, numl[310], numr[310], chain[310][310], chlen[310];
void link(int a, int b, int c) {
nxt[++id] = fir[a], fir[a] = id, dis[id] = b, w[id] = c;
nxt[++id] = fir[b], fir[b] = id, dis[id] = a, w[id] = 0;
}
int edger[310], edgelr[310][310], edgelc[310][310][310];
bool BFS() {
static int que[610], hd, tl;
hd = tl = 0;
que[tl++] = S;
memset(dep, 0, sizeof dep);
dep[S] = 1;
while (hd ^ tl) {
int x = que[hd++];
for (int i = fir[x]; i; i = nxt[i])
if (w[i] && !dep[dis[i]]) dep[dis[i]] = dep[x] + 1, que[tl++] = dis[i];
}
return dep[T];
}
int Dinic(int x, int maxflow) {
if (x == T) return maxflow;
int ret = 0;
for (int& i = head[x]; i; i = nxt[i])
if (dep[dis[i]] == dep[x] + 1 && w[i]) {
int d = Dinic(dis[i], std::min(w[i], maxflow - ret));
w[i] -= d, w[i ^ 1] += d;
ret += d;
if (ret == maxflow) break;
}
return ret;
}
std::vector<int> V[310][310];
int Get(int i, int j) {
int r = V[i][j].back();
V[i][j].pop_back();
return r;
}
int main() {
n = gi();
int maxl = 0;
for (int i = 1; i <= n; ++i) {
D[i] = gi(), L[i] = gi();
if (~L[i]) {
if (~D[i]) maxdep[L[i]] = std::max(maxdep[L[i]], D[i]);
if (D[i] == 0)
++Cnt[L[i]];
else
exist[L[i]] = 1;
} else
maxl = std::max(maxl, D[i]);
}
for (int i = 1; i <= n; ++i) {
CNT[i] = (Cnt[i] + i - 1) / i;
if (exist[i]) CNT[i] = std::max(CNT[i], 1);
}
bool FLG = 0;
for (int o = 1; o <= n; ++o) {
cnt = 2;
S = 1, T = 2;
memset(fir, 0, sizeof fir);
id = 1;
int tot = 0;
bool flg = !CNT[o];
if (flg)
if (!FLG)
FLG = 1, CNT[o] = 1;
else
continue;
for (int i = 1; i <= n; ++i) {
int c = CNT[i] * i - Cnt[i];
if (c)
edger[i] = id + 1, link(numr[i] = ++cnt, T, c), tot += c;
else
edger[i] = -1;
}
int sum = tot;
for (int i = 1; i <= n; ++i) {
chlen[i] = std::max(o == i ? maxl : 0, maxdep[i]);
sum += chlen[i];
}
if (sum > n) {
if (flg) CNT[o] = 0;
continue;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= chlen[i]; ++j)
link(chain[i][j] = ++cnt, T, 1), ++tot;
}
for (int i = 1; i <= n; ++i) {
memset(edgelr[i], -1, sizeof edgelr[i]);
memset(edgelc[i], -1, sizeof edgelc[i]);
if (D[i] == 0 && ~L[i]) continue;
link(S, numl[i] = ++cnt, 1);
if (D[i] <= 0)
for (int j = 1; j <= n; ++j)
if (numr[j] && eq(j, L[i]))
edgelr[i][j] = id + 1, link(numl[i], numr[j], 1);
if (D[i] != 0) {
for (int j = 1; j <= n; ++j)
if (eq(j, L[i]))
for (int k = 1; k <= chlen[j]; ++k)
if (k == D[i] || D[i] == -1)
edgelc[i][j][k] = id + 1, link(numl[i], chain[j][k], 1);
}
}
while (BFS()) memcpy(head, fir, sizeof head), tot -= Dinic(S, 1e9);
if (tot) {
if (flg) CNT[o] = 0;
continue;
}
for (int i = 1; i <= n; ++i) p[i] = -1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j)
if (~edgelr[i][j] && !w[edgelr[i][j]]) L[i] = j, D[i] = 0;
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= chlen[j]; ++k)
if (~edgelc[i][j][k] && !w[edgelc[i][j][k]]) L[i] = j, D[i] = k;
if (~L[i] && ~D[i]) V[D[i]][L[i]].push_back(i);
}
for (int i = 1; i <= n; ++i) {
if (!CNT[i]) continue;
static int seq[82];
while (CNT[i]--) {
for (int j = 1; j <= i; ++j) seq[j] = Get(0, i);
seq[0] = seq[i];
for (int j = 1; j <= i; ++j) p[seq[j - 1]] = seq[j];
}
for (int j = 1; j <= chlen[i]; ++j) seq[j] = Get(j, i);
for (int j = 1; j <= chlen[i]; ++j) p[seq[j]] = seq[j - 1];
for (int j = 1; j <= n; ++j)
if (p[j] == -1 && D[j] && eq(i, L[j]) && chlen[i] >= D[j] - 1)
p[j] = seq[std::max(0, D[j] - 1)];
}
for (int i = 1; i <= n; ++i) printf("%d ", ~p[i] ? p[i] : i);
exit(0);
}
puts("-1");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, t;
cin >> n >> t;
string s;
cin >> s;
int pos = s.find_first_of('.');
if (pos == string::npos) {
cout << s << endl;
return 0;
}
int p = -1;
for (int i = pos + 1; i < n; ++i) {
if (s[i] >= '5') {
p = i;
break;
}
}
if (p == -1) {
cout << s << endl;
return 0;
}
while (s.size() > p + 1) {
s.pop_back();
}
int inc = 0;
int before_dot = 1;
while (true) {
if (s[p] == '.') {
before_dot = 0;
s.pop_back();
--p;
goto endloop;
}
if (inc) {
if (s[p] == '9') {
if (before_dot) {
s.pop_back();
--p;
} else {
s[p] = '0';
--p;
}
goto endloop;
} else {
s[p] += (char)1;
inc = 0;
}
}
if (t) {
--t;
if (s[p] <= '4') {
break;
} else if (before_dot) {
s.pop_back();
--p;
inc = 1;
}
}
endloop:
if (p == -1 && inc == 1) {
s = string(1, '1') + s;
break;
}
if (t == 0 && inc == 0) {
break;
}
}
cout << s << endl;
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.