solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int convert_to_age(string s) {
int age, i;
age = 0;
for (i = 0; i < s.size(); i++) age = 10 * age + (s[i] - '0');
return age;
}
bool is_alcoholic_drink(string drink, vector<string> alcoholicDrink) {
return find(alcoholicDrink.begin(), alcoholicDrink.end(), drink) !=
alcoholicDrink.end();
}
int n;
long long int total;
vector<string> alcoholicDrink = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE",
"GIN", "RUM", "SAKE", "TEQUILA",
"VODKA", "WHISKEY", "WINE"};
int main() {
scanf("%d\n", &n);
string input;
total = 0;
while (n--) {
cin >> input;
if (input[0] >= '0' && input[0] <= '9') {
if (convert_to_age(input) < 18) ++total;
} else if (is_alcoholic_drink(input, alcoholicDrink)) {
++total;
}
}
printf("%I64d\n", total);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s = "";
cin >> s;
bool pal = true;
for (int i = 0; i < s.size(); i++) {
if (s[i] != s[s.size() - i - 1]) pal = false;
}
if (pal == false)
cout << s.size();
else {
int index = -1;
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] != s[i + 1]) {
cout << s.size() - 1;
return 0;
}
}
cout << "0";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 504;
int a[1000004], n, m;
long long x[N], y[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%lld %lld", &x[i], &y[i]);
for (int i = 1; i <= m; i++)
for (int j = i + 1; j <= m; j++) {
if (y[i] == y[j]) continue;
long long f = (x[i] - x[j]) * (-y[i]), g = (y[i] - y[j]);
if (f % g != 0) continue;
long long d = f / g + x[i];
if (d < 1 || d > n) continue;
int s = 2;
for (int k = 1; k <= m; k++) {
if (k == i || k == j) continue;
if ((x[i] - x[j]) * (y[k] - y[i]) == (y[i] - y[j]) * (x[k] - x[i])) ++s;
}
a[d] = max(a[d], s);
}
int sum = 0;
for (int i = 1; i <= n; i++)
if (a[i])
sum += a[i];
else
sum++;
printf("%d\n", sum);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
long long mod;
vector<long long> fact(long long x) {
vector<long long> res;
for (long long d = 2; x > 1; ++d) {
if (d * d > x) d = x;
if (x % d == 0) {
res.push_back(d);
while (x % d == 0) x /= d;
}
}
return res;
}
pair<long long, long long> f(long long a, long long n) {
if (n < 1) return make_pair(0ll, 0ll);
vector<long long> p = fact(a);
int m = p.size();
long long res = 0;
long long res2 = 0;
for (int ms = 0; ms < (1 << m); ++ms) {
long long x = 1, z = 1;
for (int i = 0; i < m; ++i)
if (ms >> i & 1) x *= p[i], z = -z;
long long c = n / x;
res += (c * c + c) / 2 * x * z;
res2 += c * z;
}
return make_pair(res, res2);
}
int gcd(int x, int y) { return x ? gcd(y % x, x) : y; }
long long br(int n, int m, int L, int R) {
int ans = 0;
for (int ax = 0; ax <= n; ++ax)
for (int ay = 0; ay <= m; ++ay)
for (int bx = 0; bx <= n; ++bx)
for (int by = 0; by <= m; ++by)
if (ax != bx || ay != by) {
int d = (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
if (L * L <= d && d <= R * R &&
gcd(abs(ax - bx), abs(ay - by)) == 1)
++ans;
}
return ans / 2 % mod;
}
int main() {
long long n, m, L, R;
cin >> n >> m >> L >> R >> mod;
long long ans = L < 2 ? (m + 1) * n + (n + 1) * m : 0;
ans %= mod;
long long l = n, r = n;
for (long long a = 1; a <= m && a < R; ++a) {
while (l > 0 && (l - 1) * (l - 1) + a * a >= L * L) --l;
while (r * r + a * a > R * R) --r;
if (!(L * L <= l * l + a * a && l <= r && r * r + a * a <= R * R)) continue;
pair<long long, long long> pp1 = f(a, r);
pair<long long, long long> pp2 = f(a, l - 1);
long long sb = pp1.first - pp2.first;
long long bn = pp1.second - pp2.second;
sb = (sb + mod) % mod;
bn = (bn + mod) % mod;
long long res = -sb * (m - a + 1) + (n + 1) * (m - a + 1) * bn;
res = (res % mod + mod) % mod;
ans += res * 2;
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long p, n, m, L[1000005], layer[5005][5005], dp[2][5005], fact[5005],
coff[5005];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> p;
for (int i = 1; i <= n; i++) cin >> L[i];
layer[0][0] = 1;
for (int i = 1; i < 5005; i++)
for (int j = 1; j < 5005; j++) {
layer[i][j] = (layer[i - 1][j] * (j - 1)) % p;
if (j) layer[i][j] = (layer[i][j] + layer[i - 1][j - 1]) % p;
}
fact[0] = 1;
for (int i = 1; i < 5005; i++) fact[i] = (fact[i - 1] * i) % p;
coff[0] = 1;
for (int i = 1; i < 5005; i++) coff[i] = (coff[i - 1] * (m - i + 1)) % p;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
memset(dp[i & 1], 0, sizeof dp[i & 1]);
long long x = 0;
for (int j = 0; j <= L[i - 1]; j++) x = (x + dp[(i & 1) ^ 1][j]) % p;
for (int j = 1; j <= L[i]; j++) {
long long &ret = dp[i & 1][j];
ret = (layer[L[i]][j] * coff[j]) % p;
ret = (ret * x) % p;
long long t = (dp[(i & 1) ^ 1][j] * fact[j]) % p;
t = (t * layer[L[i]][j]) % p;
ret = (ret - t + p) % p;
}
}
long long res = 0;
for (int j = 0; j <= L[n]; j++) res = (res + dp[n & 1][j]) % p;
cout << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long bit[N] = {};
int idx[N] = {};
int n;
priority_queue<int> A;
priority_queue<int, vector<int>, greater<int>> B;
long long sum(int x) {
int ret = 0;
while (x) {
ret += bit[x];
x -= (x & -x);
}
return ret;
}
void add(int x, int val) {
while (x <= n) {
bit[x] += val;
x += (x & -x);
}
}
int main() {
cin >> n;
long long x;
for (int i = 1; i <= n; i++) {
cin >> x;
idx[x] = i;
}
long long now = 0, d = 0, t;
x = idx[1];
for (int i = 1; i <= n; i++) {
B.emplace(idx[i]);
A.emplace(B.top());
B.pop();
while (A.size() > ((i + 1) >> 1)) {
B.emplace(A.top());
A.pop();
}
while (A.size() < B.size()) {
A.emplace(B.top());
B.pop();
}
long long f = A.top(),
p = (long long)(i / 2) * (i / 2 + 1) - (i / 2) * ((i & 1) == 0),
t = (long long)A.size() - (f >= x);
now += abs(idx[i] - x) + (f - x) * (t + t - i);
x = f;
add(idx[i], 1);
d += i - sum(idx[i]);
cout << now - p + d << " \n"[i == n];
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N;
int coor[3010][2];
int dist[5000010][3];
int i, x, y, c;
bitset<3010> existed[3010];
int QSDist(const void *x, const void *y) {
int *A = (int *)x;
int *B = (int *)y;
if (A[0] > B[0]) return -1;
if (A[0] < B[0]) return 1;
return 0;
}
int ComputeDist(int V1, int V2) {
int dx = coor[V1][0] - coor[V2][0];
int dy = coor[V1][1] - coor[V2][1];
return dx * dx + dy * dy;
}
int Ans() {
for (i = 0; i < c; i++) {
int V1 = dist[i][1];
int V2 = dist[i][2];
if ((existed[V1] & existed[V2]) != 0) return dist[i][0];
existed[V1][V2] = 1;
existed[V2][V1] = 1;
}
return 0;
}
int main() {
scanf("%d", &N);
for (i = 0; i < N; i++)
for (x = 0; x < 2; x++) scanf("%d", &coor[i][x]);
c = 0;
for (i = 0; i < N; i++)
for (x = i + 1; x < N; x++) {
dist[c][0] = ComputeDist(i, x);
dist[c][1] = i;
dist[c][2] = x;
c++;
}
qsort(dist, c, sizeof(dist[0]), QSDist);
printf("%.7lf\n", sqrt((double)Ans()) * 0.5);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char str[1005];
int main() {
int n, p;
scanf("%d %d\n", &n, &p);
scanf("%s\n", str);
if (p < 3) {
if (n > 2) {
printf("NO\n");
return 0;
}
}
if (n == 1) {
if (str[0] - 'a' + 1 < p) {
printf("%c\n", str[0] + 1);
str[0] += 1;
} else {
printf("NO\n");
}
} else if (n == 2) {
bool ok = false;
int add = 1;
while (str[1] + add - 'a' + 1 <= p) {
if (str[1] + add != str[0]) {
printf("%c%c\n", str[0], str[1] + add);
str[1] += add;
ok = true;
break;
}
add++;
}
if (!ok) {
if (str[0] - 'a' + 1 < p) {
printf("%ca\n", str[0] + 1);
str[0] += 1;
ok = true;
}
}
if (!ok) {
printf("NO\n");
}
} else {
bool ok = false;
for (int i = n - 1; i > 1; i--) {
int add = 1;
while (str[i] + add - 'a' + 1 <= p) {
if (str[i] + add != str[i - 1] && str[i] + add != str[i - 2]) {
for (int k = 0; k < i; k++) {
printf("%c", str[k]);
}
printf("%c", str[i] + add);
str[i] += add;
for (int k = i + 1; k < n; k++) {
for (char print = 'a'; print <= 'a' + p - 1; print++) {
if (print != str[k - 1] && print != str[k - 2]) {
str[k] = print;
printf("%c", print);
break;
}
}
}
printf("\n");
ok = true;
break;
}
add++;
}
if (ok) break;
}
if (!ok) {
int add = 1;
while (str[1] + add - 'a' + 1 <= p) {
if (str[1] + add != str[0]) {
printf("%c%c", str[0], str[1] + add);
str[1] += add;
for (int k = 2; k < n; k++) {
for (char print = 'a'; print <= 'a' + p - 1; print++) {
if (print != str[k - 1] && print != str[k - 2]) {
printf("%c", print);
str[k] = print;
break;
}
}
}
printf("\n");
ok = true;
break;
}
add++;
}
if (!ok) {
if (str[0] - 'a' + 1 < p) {
printf("%c", str[0] + 1);
str[0] += 1;
for (int k = 1; k < n; k++) {
for (char print = 'a'; print <= 'a' + p - 1; print++) {
if (print != str[k - 1] && print != str[k - 2]) {
printf("%c", print);
str[k] = print;
break;
}
}
}
printf("\n");
ok = true;
}
}
}
if (!ok) printf("NO\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using cat = long long;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int N, K;
cin >> N >> K;
if (K == 1) {
cout << "3\n";
return 0;
}
K += 2;
vector<pair<int, int> > phi(N);
for (int i = 0; i < N; i++) phi[i] = {i + 1, i + 1};
vector<char> is_prime(N + 1, 1);
for (int i = 2; i <= N; i++)
if (is_prime[i]) {
for (int j = i; j <= N; j += i) {
phi[j - 1].first = phi[j - 1].first / i * (i - 1);
is_prime[j] = false;
}
}
sort(begin(phi), end(phi));
cat ans = 0;
for (int i = 0; i < K; i++) ans += phi[i].first;
cout << ans << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> b;
unordered_map<long long, long long> m;
int main() {
long long n;
cin >> n;
long long ma = 0;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
b.push_back(x);
m[i - b[i]] += b[i];
if (m[i - b[i]] > ma) ma = m[i - b[i]];
}
cout << ma << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int32_t n;
std::cin >> n;
std::deque<std::pair<int32_t, int32_t> > dq;
bool ok = true;
int32_t nxt = 1;
std::vector<int32_t> ans(n + 1);
for (int32_t i = 0; i < 2 * n; i++) {
char t;
std::cin >> t;
if (t == '-') {
int32_t x;
std::cin >> x;
if (!ok) {
continue;
}
if (dq.empty()) {
ok = false;
continue;
}
if (dq.front().second > x && dq.back().second > x) {
ok = false;
continue;
}
if (dq.front().second <= x) {
ans[dq.front().first] = x;
dq.pop_front();
if (!dq.empty()) {
dq.front().second = std::max(x + 1, dq.front().second);
dq.back().second = std::max(x + 1, dq.back().second);
}
} else {
ans[dq.back().first] = x;
dq.pop_back();
if (!dq.empty()) {
dq.front().second = std::max(x + 1, dq.front().second);
dq.back().second = std::max(x + 1, dq.back().second);
}
}
} else {
if (!ok) {
continue;
}
dq.push_back({nxt++, -1});
}
}
if (!ok) {
std::cout << "NO" << '\n';
} else {
std::cout << "YES" << '\n';
for (int32_t i = 1; i <= n; i++) {
std::cout << ans[i] << " ";
}
std::cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
bitset<maxn> ans, y;
vector<int> tree[maxn << 2];
void update(int l, int r, int rt, int x, int y, int w) {
if (x >= l && y <= r) {
tree[rt].push_back(w);
return;
}
if (x == y) return;
int mid = (x + y) >> 1;
update(l, r, rt << 1, x, mid, w);
update(l, r, (rt << 1) + 1, mid + 1, y, w);
}
void dfs(int rt, bitset<maxn> y, int len) {
bitset<maxn> z = y;
for (int i = tree[rt].size() - 1; i >= 0; i--) {
z |= (z << tree[rt][i]);
}
if (len == 1) {
ans |= z;
return;
}
dfs(rt << 1, z, len - (len >> 1));
dfs((rt << 1) + 1, z, len >> 1);
}
int main() {
int n, q;
while (~scanf("%d%d", &n, &q)) {
for (int i = 0; i <= (n << 2); i++) tree[i].clear();
ans = 0;
y = 0;
y[0] = 1;
int l, r, w;
for (int i = 0; i < q; i++) {
scanf("%d%d%d", &l, &r, &w);
update(l, r, 1, 1, n, w);
}
dfs(1, y, n);
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (ans[i]) cnt++;
}
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) {
if (ans[i]) {
printf("%d%c", i, --cnt == 0 ? '\n' : ' ');
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[4];
cin >> a[0] >> a[1] >> a[2] >> a[3];
int count = 0;
for (int i = 0; i < 4; i++) {
int j;
for (j = 0; j < i; j++) {
if (a[j] == a[i]) break;
}
if (i == j) count++;
}
cout << 4 - count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, t;
cin >> n >> t;
vector<int> s(n), d(n);
int ans = 1e+9;
for (int i = 0; i < n; ++i) {
cin >> s[i] >> d[i];
s[i] -= t;
if (s[i] < 0) {
s[i] %= d[i];
if (s[i] < 0) s[i] += d[i];
}
ans = min(ans, s[i]);
}
for (int i = 0; i < n; ++i) {
if (s[i] == ans) {
cout << i + 1 << endl;
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
while (cin >> s) {
if (s.size() % 2) {
cout << -1 << endl;
continue;
}
int x = 0, y = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'U')
x++;
else if (s[i] == 'D')
x--;
else if (s[i] == 'R')
y++;
else
y--;
}
cout << (abs(x) + abs(y)) / 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265358979323846;
const int inf = (int)1e9;
const long long int llinf = (long long int)1e18;
const int base = 10;
double eps = 1e-9;
bool pred(const pair<int, int>& i, const pair<int, int>& j) {
if (i.first == j.first) {
return i.second > j.second;
} else {
return i.first < j.first;
}
}
int main() {
int n;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end());
int now = a[0].second;
for (int i = 1; i < n; ++i) {
if (a[i].second >= now) {
now = a[i].second;
} else {
now = a[i].first;
}
}
cout << now;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> vec;
if (n == 1) {
cout << -1;
} else {
for (int i = 2; i <= n; i++) {
while (n % i == 0 && k > 1) {
vec.push_back(i);
n /= i;
k--;
}
if (k <= 1) break;
}
vec.push_back(n);
k--;
if (k == 0 && n > 1) {
for (int i = 0; i < vec.size(); i++) cout << vec[i] << " ";
} else
cout << -1;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, sol;
int l1[2002], c1[2002], l2[2002], c2[2002];
char s[2002][2002];
int main() {
cin >> n;
int i, j, l;
for (i = 1; i <= n; i++) cin >> s[i] + 1;
for (l = n; l >= 2; l--)
for (i = 1; i <= n - l + 1; i++) {
j = i + l - 1;
if ((s[i][j] + l1[i] + c1[j]) & 1) {
sol++;
l1[i]++;
c1[j]++;
}
if ((s[j][i] + l2[j] + c2[i]) & 1) {
sol++;
l2[j]++;
c2[i]++;
}
}
for (i = 1; i <= n; i++)
if ((s[i][i] + l1[i] + c1[i] + l2[i] + c2[i]) & 1) sol++;
cout << sol;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int da[62];
long long ans[62][32];
long long f[62];
int qe[62];
long long dfs(int s, int l, int ll, int up) {
if (!s) return 1;
if (!up && f[s] != -1) return f[s];
int stop = up ? da[s] : 1;
long long res = 0;
for (int i = 0; i <= stop; i++) {
if (s == ll && i == 0) continue;
int pos = ll - s;
qe[pos] = i;
if (pos < l)
res += dfs(s - 1, l, ll, up && i == stop);
else if (qe[pos % l] == i)
res += dfs(s - 1, l, ll, up && i == stop);
}
return up ? res : f[s] = res;
}
long long calc(long long x) {
memset(ans, 0, sizeof(ans));
int len = 0;
for (long long i = x; i; i /= 2) da[++len] = i % 2;
for (int i = 1; i <= len; i++)
for (int j = 1; j < i; j++)
if (i % j == 0) {
memset(f, -1, sizeof(f));
ans[i][j] = dfs(i, j, i, i == len);
}
for (int i = 1; i <= len; i++) {
for (int j = 1; j < i; j++)
if (i % j == 0) {
for (int k = 1; k < j; k++)
if (j % k == 0) ans[i][j] -= ans[i][k];
}
}
long long res = 0;
for (int i = 1; i <= len; i++)
for (int j = 1; j < i; j++)
if (i % j == 0) res += ans[i][j];
return res;
}
int main() {
long long a, b;
scanf("%I64d%I64d", &a, &b);
printf("%I64d\n", calc(b) - calc(a - 1));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int funk(char x) {
if (x == 'a') return 1;
if (x == 'b') return -1;
return 0;
}
char a[N][N];
int d[2 * N][(1 << 20) + 10];
int y[N][N];
struct abc {
int x, y, s;
};
abc w[N + N];
int main() {
int n, m, i, j;
cin >> n;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) cin >> a[i][j];
int t = 2;
d[n + n - 1][1] = funk(a[n][n]);
for (i = n; i >= 1; i--) {
w[n + i - 1].x = i;
w[n + i - 1].y = n;
w[n + i - 1].s = n - i + 1;
}
for (i = n; i >= 1; i--) {
w[i].x = 1;
w[i].y = i;
w[i].s = i;
}
int id = n + n - 2;
for (i = n - 1; i >= 1; i--) {
t = w[id].s;
m = (1 << t) - 1;
int x = w[id].x;
int y = w[id].y;
for (j = 1; j <= m; j++) {
char b = '0';
bool ok = 1;
for (int k = 0; k < t; k++) {
if (((1 << k) & j)) {
if (a[x + k][y - k] == b || b == '0') {
b = a[x + k][y - k];
} else {
ok = 0;
break;
}
}
}
if (ok) {
map<char, int> mp;
for (int k = 0; k < t; k++) {
if (((1 << k) & j)) {
int xx = x + k;
int yy = y - k;
yy++;
if (xx <= n && xx >= 1 && yy >= 1 && yy <= n) {
mp[a[xx][yy]] |= (1 << (xx - w[id + 1].x));
}
xx++;
yy--;
if (xx <= n && xx >= 1 && yy >= 1 && yy <= n) {
mp[a[xx][yy]] |= (1 << (xx - w[id + 1].x));
}
}
}
int ans;
if (id % 2 == 0) {
ans = -1e9;
for (map<char, int>::iterator k = mp.begin(); k != mp.end(); k++)
ans = max(ans, d[id + 1][(*k).second] + funk(b));
} else {
ans = 1e9;
for (map<char, int>::iterator k = mp.begin(); k != mp.end(); k++)
ans = min(ans, d[id + 1][(*k).second] + funk(b));
}
d[id][j] = ans;
}
}
id--;
}
for (i = n - 1; i >= 1; i--) {
t = w[id].s;
m = (1 << t) - 1;
int x = w[id].x;
int y = w[id].y;
for (j = 1; j <= m; j++) {
char b = '0';
bool ok = 1;
for (int k = 0; k < t; k++) {
if (((1 << k) & j)) {
if (a[x + k][y - k] == b || b == '0') {
b = a[x + k][y - k];
} else {
ok = 0;
break;
}
}
}
if (ok) {
map<char, int> mp;
for (int k = 0; k < t; k++) {
if (((1 << k) & j)) {
int xx = x + k;
int yy = y - k;
yy++;
if (xx <= n && xx >= 1 && yy >= 1 && yy <= n) {
mp[a[xx][yy]] |= (1 << (xx - w[id + 1].x));
}
xx++;
yy--;
if (xx <= n && xx >= 1 && yy >= 1 && yy <= n) {
mp[a[xx][yy]] |= (1 << (xx - w[id + 1].x));
}
}
}
int ans;
if (id % 2 == 0) {
ans = -1e9;
for (map<char, int>::iterator k = mp.begin(); k != mp.end(); k++)
ans = max(ans, d[id + 1][(*k).second] + funk(b));
} else {
ans = 1e9;
for (map<char, int>::iterator k = mp.begin(); k != mp.end(); k++)
ans = min(ans, d[id + 1][(*k).second] + funk(b));
}
d[id][j] = ans;
}
}
id--;
}
if (d[1][1] > 0) puts("FIRST");
if (d[1][1] == 0) puts("DRAW");
if (d[1][1] < 0) puts("SECOND");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 5;
long long n, k, a[N], res;
void solo() {
cin >> n;
for (int i = 1; i <= n; i++) cout << i + 1 << " ";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solo();
cout << endl;
}
cerr << "\n" << (double)clock() / CLOCKS_PER_SEC * 1000 << " ms";
}
| 0 |
#include <bits/stdc++.h>
int a[4 * 4];
int n, n2;
std::map<int, int> sums[4 + 1];
void gens(int p, int cnt, int sum, std::map<int, int>& s) {
if (cnt == 0) {
std::map<int, int>::iterator it = s.find(sum);
if (it == s.end())
s[sum] = 1;
else
++it->second;
return;
}
if (p >= n2) return;
gens(p + 1, cnt, sum, s);
gens(p + 1, cnt - 1, sum + a[p], s);
}
int m[4][4];
int hs[4], vs[4], ds1, ds2;
bool used[4 * 4];
int sum;
void doit(int i, int j, int v) {
hs[i] += v;
vs[j] += v;
if (i == j) ds1 += v;
if (i == n - j - 1) ds2 += v;
}
bool gen(int i, int j) {
if (i == n) return true;
int prev = -1;
for (int k = 0; k < n2; ++k)
if (!used[k] && prev != a[k]) {
prev = a[k];
int v = a[k];
m[i][j] = v;
doit(i, j, v);
if (i == n - 1 && vs[j] != sum) {
doit(i, j, -v);
continue;
}
if (j == n - 1 && hs[i] != sum) {
doit(i, j, -v);
continue;
}
if (i == n - 1 && j == 0 && ds2 != sum) {
doit(i, j, -v);
continue;
}
if (i == n - 1 && j == n - 1 && ds1 != sum) {
doit(i, j, -v);
continue;
}
if (hs[i] > sum || vs[j] > sum || ds1 > sum || ds2 > sum) {
doit(i, j, -v);
continue;
}
used[k] = true;
int i2 = i, j2 = j + 1;
if (j2 == n) {
++i2;
j2 = 0;
}
if (gen(i2, j2)) return true;
used[k] = false;
doit(i, j, -v);
}
return false;
}
int main() {
scanf("%d", &n);
n2 = n * n;
int min = 0;
for (int i = 0; i < n2; ++i) {
scanf("%d", &a[i]);
if (a[i] < min) min = a[i];
}
if (n == 1) {
printf("%d\n%d", a[0], a[0]);
return 0;
}
std::sort(&a[0], &a[n2]);
min = -min;
for (int i = 0; i < n2; ++i) a[i] += min;
for (int i = 1; i <= n; ++i) {
gens(0, i, 0, sums[i]);
}
bool res = false;
for (std::map<int, int>::const_iterator i = sums[n].begin();
i != sums[n].end(); ++i)
if (i->second >= n + n + 2) {
sum = i->first;
memset(hs, 0, sizeof(hs));
memset(vs, 0, sizeof(vs));
memset(used, 0, sizeof(used));
ds1 = 0;
ds2 = 0;
if (gen(0, 0)) {
res = true;
break;
}
}
if (!res) {
printf("sorry. i am failed");
return 0;
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) m[i][j] -= min;
int s = 0;
for (int i = 0; i < n; ++i) s += m[i][0];
printf("%d\n", s);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (j > 0) printf(" ");
printf("%d", m[i][j]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, d;
long long k, now;
int a[1005][1005];
void Dfs(int u, int i) {
if (a[u][i] == k) {
a[u][i] = 0;
a[u][i + 1]++;
Dfs(u, i + 1);
}
}
int main() {
n = read();
k = read();
d = read();
int t = n;
for (int i = 1; i <= d; i++) t = t / k + (int)(t % k > 0);
memset(a, 0, sizeof(a));
if (t == 1) {
for (int u = 2; u <= n; u++) {
for (int i = 1; i <= d; i++) a[u][i] = a[u - 1][i];
a[u][1] += 1;
Dfs(u, 1);
}
for (int i = 1; i <= d; i++) {
for (int j = 1; j <= n; j++) printf("%d ", a[j][i] + 1);
puts("");
}
} else
puts("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
int aa[750], pq[1 + 750], iq[750], cnt;
int i2(int i) {
return (i *= 2) > cnt ? 0
: i < cnt && (aa[pq[i + 1]] < aa[pq[i]]) ? i + 1
: i;
}
void pq_up(int u) {
int i, j;
for (i = iq[u]; (j = i / 2) && (aa[u] < aa[pq[j]]); i = j)
pq[iq[pq[j]] = i] = pq[j];
pq[iq[u] = i] = u;
}
void pq_dn(int u) {
int i, j;
for (i = iq[u]; (j = i2(i)) && (aa[pq[j]] < aa[u]); i = j)
pq[iq[pq[j]] = i] = pq[j];
pq[iq[u] = i] = u;
}
void pq_add(int u) {
iq[u] = ++cnt;
pq_up(u);
}
int pq_remove_first() {
int u = pq[1], v = pq[cnt--];
iq[v] = 1;
pq_dn(v);
return u;
}
int check(int n, int d, long long b) {
int i;
cnt = 0;
for (i = 0; i < n; i++) {
int a = aa[i];
pq_add(i);
b += a;
while (b < 0) {
if (d-- == 0) return 0;
b -= aa[pq_remove_first()];
}
}
return 1;
}
int main() {
static long long bb[750 + 1];
int n, m, i, d;
long long lower_, upper_, b;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%d", &aa[i]);
upper_ = 1e12;
for (d = 0; d < n; d++) {
lower_ = -1;
while (upper_ - lower_ > 1) {
b = (lower_ + upper_) / 2;
if (check(n, d, b))
upper_ = b;
else
lower_ = b;
}
bb[d] = upper_;
}
while (m--) {
int lower, upper;
scanf("%lld", &b);
lower = -1, upper = n;
while (upper - lower > 1) {
d = (lower + upper) / 2;
if (bb[d] <= b)
upper = d;
else
lower = d;
}
printf("%d\n", upper);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool win(string s, string t) {
if (s == "rock") return t == "scissors";
if (s == "scissors") return t == "paper";
return t == "rock";
}
int main() {
string f, s, t;
cin >> f;
cin >> s;
cin >> t;
if (win(f, s) && win(f, t))
cout << 'F' << endl;
else if (win(s, f) && win(s, t))
cout << 'M' << endl;
else if (win(t, f) && win(t, s))
cout << 'S' << endl;
else
cout << '?' << endl;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <typename T>
inline bool remin(T& c, const T& n) {
if (c > n) {
c = n;
return 1;
}
return 0;
}
template <typename T>
inline bool remax(T& c, const T& n) {
if (c < n) {
c = n;
return 1;
}
return 0;
}
int main() {
int n, i, a, sum = 0;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &a);
sum += a * i;
}
printf("%d\n", sum);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int gcd(int m, int n) {
int r;
while (n) {
r = m % n;
m = n;
n = r;
}
return m;
}
int a[1001];
int b[2005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
b[0] = a[0];
int k = 1;
for (int i = 1; i < n; i++) {
if (gcd(a[i], a[i - 1]) == 1) {
b[k++] = a[i];
} else {
for (int j = 2;; j++) {
if (gcd(j, a[i - 1]) == 1 && gcd(j, a[i]) == 1) {
b[k++] = j;
b[k++] = a[i];
break;
}
}
}
}
printf("%d\n", k - n);
for (int i = 0; i < k; i++) {
printf("%d ", b[i]);
}
printf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct A {
int val, id;
};
A a[112345];
A b[112345];
bool fs(A p, A q) { return p.val < q.val; }
int main() {
ios_base::sync_with_stdio(false);
int n, m, x, y;
cin >> n >> m >> x >> y;
for (int i = 1; i <= n; i++) {
cin >> a[i].val;
a[i].id = i;
}
for (int i = 1; i <= m; i++) {
cin >> b[i].val;
b[i].id = i;
}
sort(a + 1, a + 1 + n, fs);
sort(b + 1, b + 1 + m, fs);
int i = 1, j = 1;
vector<pair<int, int> > v;
while (i <= n && j <= m) {
if (b[j].val >= a[i].val - x && b[j].val <= a[i].val + y) {
v.push_back(make_pair(a[i].id, b[j].id));
i++, j++;
} else if (b[j].val < a[i].val - x)
j++;
else
i++;
}
cout << v.size() << "\n";
for (int i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct song {
double l, p;
bool operator<(const song &x) const {
return l * p * (1 - x.p) < x.l * x.p * (1 - p);
}
} s[50005];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int l, p;
scanf("%d %d", &l, &p);
s[i].l = (double)l, s[i].p = (double)p / 100.0;
}
sort(s, s + n);
double ans = 0.0, cump = 0.0;
for (int i = 0; i < n; i++) {
ans += s[i].l * (1 + s[i].p * cump);
cump += 1 - s[i].p;
}
printf("%.9f\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INFint = 2147483647;
const long long INF = 9223372036854775807ll;
const long long MOD = 1000000007ll;
const long double EPS = 1e-9;
vector<vector<int> > g;
vector<int> cl;
vector<int> p;
int be, en;
bool dfs(int v, int pr = -1) {
cl[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == pr) continue;
if (cl[to] == 0) {
p[to] = v;
if (dfs(to, v)) return 1;
} else if (cl[to] == 1) {
en = v;
be = to;
return 1;
}
}
cl[v] = 2;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
g.resize(n);
p.resize(n, -1);
cl.resize(n, 0);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (dfs(i)) break;
}
vector<int> c;
c.push_back(be);
for (int v = en; v != be; v = p[v]) c.push_back(v);
vector<int> dist(n, -1);
queue<int> q;
for (int i = 0; i < c.size(); i++) {
q.push(c[i]);
dist[c[i]] = 0;
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (dist[to] == -1) {
dist[to] = dist[v] + 1;
q.push(to);
}
}
}
for (int i = 0; i < n; i++) cout << dist[i] << ' ';
fprintf(stderr, "\nTIME = %lf\n", 1.0 * clock() / CLOCKS_PER_SEC);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30, N = 45005, M = 450005;
int head[N], ver[M], edge[M], Next[M], d[M], now[M];
int b[25];
int n, m, s, t, tot = 1;
int maxflow;
queue<int> q;
template <class T>
inline void read(T& x) {
x = 0;
char c = getchar();
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
x = f ? -x : x;
}
void add(int x, int y, int z) {
ver[++tot] = y, edge[tot] = z, Next[tot] = head[x], head[x] = tot;
ver[++tot] = x, edge[tot] = 0, Next[tot] = head[y], head[y] = tot;
}
bool bfs() {
memset(d, 0, sizeof(d));
while (q.size()) q.pop();
q.push(s);
d[s] = 1;
now[s] = head[s];
while (q.size()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = Next[i]) {
if (edge[i] && !d[ver[i]]) {
q.push(ver[i]);
now[ver[i]] = head[ver[i]];
d[ver[i]] = d[x] + 1;
if (ver[i] == t) return 1;
}
}
}
return 0;
}
int dicnic(int x, int flow) {
if (x == t) return flow;
int rest = flow, k, i;
for (i = now[x]; i && rest; i = Next[i])
if (edge[i] && d[ver[i]] == d[x] + 1) {
k = dicnic(ver[i], min(rest, edge[i]));
if (!k) d[ver[i]] = 0;
edge[i] -= k;
edge[i ^ 1] += k;
rest -= k;
}
now[x] = i;
return flow - rest;
}
void qin() {
tot = 1;
maxflow = 0;
memset(head, 0, sizeof(head));
memset(Next, 0, sizeof(Next));
memset(now, 0, sizeof(now));
}
int a[10005], v[10005];
int main() {
qin();
int g;
scanf("%d %d %d", &n, &m, &g);
s = n + m + 1;
t = n + m + 2;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 1; i <= n; i++) {
if (a[i])
add(i, t, v[i]);
else
add(s, i, v[i]);
}
int ans = 0;
for (int num = 1; num <= m; num++) {
int x, w, k, flag;
scanf("%d %d %d", &x, &w, &k);
ans += w;
if (x == 1) {
for (int i = 1; i <= k; i++) {
int date;
scanf("%d", &date);
add(date, n + num, inf);
}
scanf("%d", &flag);
if (flag)
add(n + num, t, w + g);
else
add(n + num, t, w);
} else {
for (int i = 1; i <= k; i++) {
int date;
scanf("%d", &date);
add(n + num, date, inf);
}
scanf("%d", &flag);
if (flag)
add(s, n + num, w + g);
else
add(s, n + num, w);
}
}
int flow = 0;
while (bfs())
while (flow = dicnic(s, inf)) maxflow += flow;
printf("%d", ans - maxflow);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
template <typename T>
void no(T s) {
cout << s;
exit(0);
}
void no() {
cout << "NO";
exit(0);
}
constexpr int maxn = 1 << 18;
vector<int> G[maxn];
int sz[maxn];
int n, m, rt1 = 0, rt2 = 0;
void DFS(int u, int fa = 0) {
sz[u] = 1;
for (int v : G[u])
if (v != fa) {
DFS(v, u);
sz[u] += sz[v];
if (sz[v] == m / 2) rt1 = u, rt2 = v;
}
}
void DFS3(int u, int fa = 0) {
sz[u] = 1;
for (int v : G[u])
if (v != fa) {
DFS3(v, u);
sz[u] += sz[v];
}
}
int ok, ans;
bool vis[maxn];
void DFS2(int u, int fa = 0, int id = 1) {
if (id <= m + 1 and id >= 1)
vis[id] = true;
else
ok = 0;
vector<int> son;
for (int v : G[u])
if (v != fa) son.push_back(v);
if (son.size() == 0U) return;
if (son.size() == 1U) {
if (ans) ok = 0;
ans = u;
if (id * 2 + 1 <= m + 1 and id * 2 + 1 >= 1)
vis[id * 2 + 1] = true;
else
ok = 0;
DFS2(son[0], u, id * 2);
} else if (son.size() == 2U) {
DFS2(son[0], u, id * 2);
DFS2(son[1], u, id * 2 + 1);
} else if (son.size() == 3U) {
if (ans) ok = 0;
ans = u;
sort(son.begin(), son.end(),
[&](const int &x, const int &y) { return sz[x] < sz[y]; });
if (id * 2 + 1 <= m + 1 and id * 2 + 1 >= 1)
vis[id * 2 + 1] = true;
else
ok = 0;
DFS2(son[2], u, id * 2);
DFS2(son[1], u, (id * 2 + 1) * 2);
DFS2(son[0], u, (id * 2 + 1) * 2 + 1);
} else
ok = 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(20);
cin >> n;
m = (1 << n) - 2;
for (int i = 1, u, v; i < m; i += 1) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
DFS(1);
if (not rt1) no(0);
vector<int> fk;
ok = 1;
ans = 0;
DFS3(rt1);
DFS2(rt1);
for (int i = 1; i <= m + 1; i += 1)
if (not vis[i]) ok = 0;
if (ok) fk.push_back(ans);
ok = 1;
ans = 0;
fill(vis, vis + maxn, false);
DFS3(rt2);
DFS2(rt2);
for (int i = 1; i <= m + 1; i += 1)
if (not vis[i]) ok = 0;
if (ok) fk.push_back(ans);
cout << fk.size() << "\n";
sort(fk.begin(), fk.end());
for (int x : fk) cout << x << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int a, b, c;
cin >> a >> b >> c;
if (a > b) swap(b, a);
if (b > c) swap(c, b);
if (a > b) swap(a, b);
if (a == 1)
cout << "YES\n";
else if (a == 2 && b == 2)
cout << "YES\n";
else if (a == 2 && b == 4 && c == 4)
cout << "YES\n";
else if (a == 3 && b == 3 && c == 3)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
if (n == 1 || n == 2)
cout << 0 << endl;
else {
int b, flag = 1;
vector<int> v;
v.push_back(1);
for (int i = 2; i <= n; i++) {
if (a[1] != a[i]) {
b = a[i] - a[1];
flag = 0;
break;
}
}
if (flag)
cout << 0;
else {
flag = 1;
int k, l;
if (b > 0) {
for (int i = 2; i <= n && flag; i++) {
if ((a[i] - a[i - 1]) < 0) {
flag = 0;
k = i;
l = i - 1;
}
}
if (flag)
cout << 0;
else
cout << 3 << endl << v[0] << " " << l << " " << k;
} else {
for (int i = 2; i <= n && flag; i++) {
if ((a[i] - a[i - 1]) > 0) {
flag = 0;
k = i;
l = i - 1;
}
}
if (flag)
cout << 0;
else
cout << 3 << endl << v[0] << " " << l << " " << k;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
vector<pair<int, int> > E, ans;
vector<pair<pair<int, int>, pair<int, int> > > ret, ret2;
int e[1010][1010], u, v, n;
void gao(int l, int r, vector<pair<pair<int, int>, pair<int, int> > > &res) {
if (l + 1 == r) return;
int md = (l + r) >> 1;
E.clear();
for (int i = l; i < md; i++)
for (int j = r + 1 - 1; j >= md + 1; j--)
if (e[i][j]) {
E.push_back(make_pair(i, j));
}
if (!((int)(E).size())) {
gao(l, md, res);
gao(md, r, res);
return;
}
int cu = E[0].first, cv = E[0].second;
for (int i = 0; i < ((int)(E).size()); i++) {
int nv = 0;
if (i == ((int)(E).size()) - 1)
nv = md;
else if (E[i].first == E[i + 1].first)
nv = E[i + 1].second;
else
nv = E[i + 1].first;
e[cu][cv] = e[cv][cu] = 0;
e[0][nv] = e[nv][0] = 1;
res.push_back(make_pair(make_pair(cu, cv), make_pair(0, nv)));
if (i != ((int)(E).size()) - 1) {
if (E[i].first == E[i + 1].first)
cv = E[i + 1].second;
else
cu = E[i + 1].first;
}
}
gao(l, md, res);
gao(md, r, res);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 3; i++) {
scanf("%d%d", &u, &v);
--u;
--v;
e[u][v] = 1;
e[v][u] = 1;
}
gao(1, n - 1, ret);
memset(e, 0, sizeof(e));
for (int i = 0; i < n - 3; i++) {
scanf("%d%d", &u, &v);
--u;
--v;
e[u][v] = 1;
e[v][u] = 1;
}
gao(1, n - 1, ret2);
for (auto p : ret) ans.push_back(p.first);
reverse((ret2).begin(), (ret2).end());
for (auto p : ret2) ans.push_back(p.second);
printf("%d\n", ((int)(ans).size()));
for (int i = 0; i < ((int)(ans).size()); i++)
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long val;
node(long long val = 0) { this->val = val; }
};
struct segtree {
long long n, a_l, a_r, a_val, a_x;
node def;
vector<node> tree;
vector<long long> a;
segtree(vector<long long> a) {
this->n = (long long)a.size();
this->a = a;
tree.resize(4 * n);
build();
}
void build() { build(0, 0, n); }
void build(long long v, long long l, long long r) {
if (r - l == 1) {
tree[v] = node(a[l]);
return;
}
long long m = (l + r) / 2;
build(v * 2 + 1, l, m);
build(v * 2 + 2, m, r);
tree[v] = merge(tree[v * 2 + 1], tree[v * 2 + 2]);
}
node merge(node left, node right) { return node(left.val + right.val); }
void update(long long x, long long val) {
a_x = x;
a_val = val;
upd(0, 0, n);
}
void upd(long long v, long long l, long long r) {
if (l > a_x || r <= a_x) {
return;
}
if (r - l == 1) {
tree[v] = merge(tree[v], node(a_val));
return;
}
long long m = (l + r) / 2;
upd(v * 2 + 1, l, m);
upd(v * 2 + 2, m, r);
tree[v] = merge(tree[v * 2 + 1], tree[v * 2 + 2]);
}
node get(long long l, long long r) {
a_r = r;
a_l = l;
return get(0, 0, n);
}
node get(long long v, long long l, long long r) {
if (l >= a_r || r <= a_l) {
return def;
}
if (l >= a_l && r <= a_r) {
node ans = tree[v];
return ans;
}
long long m = (l + r) / 2;
node left = get(v * 2 + 1, l, m);
node right = get(v * 2 + 2, m, r);
return merge(left, right);
}
};
signed main() {
long long n, h, m, k;
cin >> n >> h >> m >> k;
vector<long long> v;
map<long long, long long> mp;
vector<long long> hihi;
for (long long i = 0; i < n; ++i) {
long long hh, mm;
cin >> hh >> mm;
v.push_back(hh * m + mm);
++mp[mm % m];
hihi.push_back(mm % m);
}
sort(hihi.begin(), hihi.end());
hihi.resize(unique(hihi.begin(), hihi.end()) - hihi.begin());
map<long long, long long> comp;
for (auto i : hihi) {
comp[i] = upper_bound(hihi.begin(), hihi.end(), i) - hihi.begin() - 1;
}
vector<long long> base(comp.size());
segtree tree(base);
for (auto i : mp) {
tree.update(comp[i.first], i.second);
}
long long ans = 1e18;
long long ost_ans = 0;
for (long long i = 0; i < n; ++i) {
long long now_ans = 0;
long long ost = v[i] % m;
long long ost2 = (ost + k) % m;
if (ost2 > ost) {
long long lb = upper_bound(hihi.begin(), hihi.end(), ost) - hihi.begin();
long long rb = lower_bound(hihi.begin(), hihi.end(), ost2) - hihi.begin();
now_ans += tree.get(lb, rb).val;
} else {
long long lb = upper_bound(hihi.begin(), hihi.end(), ost) - hihi.begin();
long long rb = lower_bound(hihi.begin(), hihi.end(), ost2) - hihi.begin();
now_ans += tree.get(lb, tree.n).val;
now_ans += tree.get(0, rb).val;
}
ost += (m / 2);
ost %= m;
ost2 = (ost + k) % m;
if (ost2 > ost) {
long long lb = upper_bound(hihi.begin(), hihi.end(), ost) - hihi.begin();
long long rb = lower_bound(hihi.begin(), hihi.end(), ost2) - hihi.begin();
now_ans += tree.get(lb, rb).val;
} else {
long long lb = upper_bound(hihi.begin(), hihi.end(), ost) - hihi.begin();
long long rb = lower_bound(hihi.begin(), hihi.end(), ost2) - hihi.begin();
now_ans += tree.get(lb, tree.n).val;
now_ans += tree.get(0, rb).val;
}
if (now_ans < ans) {
ost_ans = ost;
}
ans = min(ans, now_ans);
now_ans = 0;
ost2 = v[i] % m;
ost = (ost2 - k + m) % m;
if (ost2 > ost) {
long long lb = upper_bound(hihi.begin(), hihi.end(), ost) - hihi.begin();
long long rb = lower_bound(hihi.begin(), hihi.end(), ost2) - hihi.begin();
now_ans += tree.get(lb, rb).val;
} else {
long long lb = upper_bound(hihi.begin(), hihi.end(), ost) - hihi.begin();
long long rb = lower_bound(hihi.begin(), hihi.end(), ost2) - hihi.begin();
now_ans += tree.get(lb, tree.n).val;
now_ans += tree.get(0, rb).val;
}
ost2 += (m / 2);
ost2 %= m;
ost = (ost2 - k + m) % m;
if (ost2 > ost) {
long long lb = upper_bound(hihi.begin(), hihi.end(), ost) - hihi.begin();
long long rb = lower_bound(hihi.begin(), hihi.end(), ost2) - hihi.begin();
now_ans += tree.get(lb, rb).val;
} else {
long long lb = upper_bound(hihi.begin(), hihi.end(), ost) - hihi.begin();
long long rb = lower_bound(hihi.begin(), hihi.end(), ost2) - hihi.begin();
now_ans += tree.get(lb, tree.n).val;
now_ans += tree.get(0, rb).val;
}
if (now_ans < ans) {
ost_ans = ost;
}
ans = min(ans, now_ans);
}
long long t = (ost_ans % (m / 2));
cout << ans << " " << (t + k) % (m / 2) << endl;
if (ans == 0) return 0;
long long ost1 = t;
long long ost2 = (ost1 + k) % m;
long long ost3 = (t + m / 2) % m;
long long ost4 = (ost3 + k) % m;
for (long long i = 0; i < n; ++i) {
long long ost = v[i] % m;
if (ost1 < ost2) {
if ((ost1 < ost) && (ost < ost2)) {
cout << i + 1 << " ";
continue;
}
} else {
if (ost > ost1 || ost < ost2) {
cout << i + 1 << " ";
continue;
}
}
if (ost3 < ost4) {
if ((ost3 < ost) && (ost < ost4)) {
cout << i + 1 << " ";
continue;
}
} else {
if (ost > ost3 || ost < ost4) {
cout << i + 1 << " ";
continue;
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[20];
char b[20];
scanf("%s", a);
int l;
bool f;
l = strlen(a) + 1;
for (int i = 0; i < l; i++) {
for (int j = 0; j < i; j++) b[j] = a[j];
b[i] = '*';
for (int j = i + 1; j < l; j++) b[j] = a[j - 1];
f = true;
for (int j = 0; j < l; j++) {
if (b[j] != '*' and b[l - j - 1] != '*' and b[j] != b[l - j - 1]) {
f = false;
break;
}
}
if (f) break;
}
if (!f)
printf("%s\n", "NA");
else {
for (int i = 0; i < l; i++)
if (b[i] == '*') {
if (b[l - i - 1] != '*')
printf("%c", b[l - i - 1]);
else
printf("a");
} else
printf("%c", b[i]);
printf("\n");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long modpow(long long x, long long n, long long m) {
if (n == 0) return 1 % m;
long long u = modpow(x, n / 2, m);
u = (u * u) % m;
if (n % 2 == 1) u = (u * x) % m;
return u;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
if (k % 3 != 0 || n < 3) {
n %= 3;
if (n == 0)
cout << "Bob\n";
else
cout << "Alice\n";
} else {
n %= k + 1;
if (n == k) {
cout << "Alice\n";
} else {
n %= 3;
if (n == 0)
cout << "Bob\n";
else
cout << "Alice\n";
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int isprime(long long N) {
if (N < 2 || (!(N & 1) && N != 2)) return 0;
for (int i = 3; i * i <= N; i += 2) {
if (!(N % i)) return 0;
}
return 1;
}
void solve() {
int W, H, w, h, x1, x2, y1, y2;
cin >> W >> H;
cin >> x1 >> y1 >> x2 >> y2;
cin >> w >> h;
int sum = INT_MAX;
if (W >= (x2 - x1 + w)) {
sum = min(sum, max(0, (w - x1)));
sum = min(sum, max(0, (w - (W - x2))));
}
if (H >= (y2 - y1 + h)) {
sum = min(sum, max(0, (h - y1)));
sum = min(sum, max(0, (h - (H - y2))));
}
if (sum == INT_MAX) {
cout << "-1" << endl;
return;
}
cout << fixed << setprecision(9) << sum << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int getint() {
unsigned int c;
int x = 0;
while (((c = getchar()) - '0') >= 10) {
if (c == '-') return -getint();
if (!~c) exit(0);
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while (((c = getchar()) - '0') < 10);
return x;
}
int n, nn, sum;
int as[20];
int c[10][10];
bool used[20];
int num[20], have[20], ns;
int perm[20][20][20];
void dfs(int row, int col, int rows, int cols, int dir, int cnt) {
int i, j, k;
if (cnt == nn) {
int tmp1 = 0, tmp2 = 0;
for (i = 0; i < n; i++) {
tmp1 += c[i][i];
tmp2 += c[i][n - 1 - i];
}
if (tmp1 != sum) return;
if (tmp2 != sum) return;
tmp1 = tmp2 = 0;
for (i = 0; i < n; i++) {
tmp1 += c[n - 1][i];
tmp2 += c[i][n - 1];
}
if (tmp1 != sum) return;
if (tmp2 != sum) return;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (j) putchar(' ');
printf("%d", c[i][j]);
}
puts("");
}
exit(0);
}
if (row == n or col == n) {
int tmp = 0;
if (dir == 0) {
for (i = 0; i < n; i++) tmp += c[row][i];
if (tmp != sum) return;
} else {
for (i = 0; i < n; i++) tmp += c[i][col];
if (tmp != sum) return;
}
if (dir == 0) {
dfs(rows + 1, cols, rows + 1, cols, 1, cnt);
} else {
dfs(rows, cols + 1, rows, cols + 1, 0, cnt);
}
}
for (i = 0; i < ns; i++) {
int d = perm[row][col][i];
if (have[d]) {
have[d]--;
c[row][col] = num[d];
if (dir == 0) dfs(row, col + 1, rows, cols, dir, cnt + 1);
if (dir == 1) dfs(row + 1, col, rows, cols, dir, cnt + 1);
have[d]++;
}
}
}
int main() {
int i, j, tcc, tc = 1 << 28;
for (tcc = 0; tcc < tc; tcc++) {
n = getint(), nn = n * n, sum = 0;
for (i = 0; i < nn; i++) as[i] = getint(), sum += as[i];
sum /= n;
for (i = 0; i < nn; i++) num[i] = as[i];
sort(num, num + nn);
ns = unique(num, num + nn) - num;
for (i = 0; i < ns; i++) {
for (j = 0; j < nn; j++)
if (num[i] == as[j]) have[i]++;
}
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
for (int k = 0; k < ns; k++) perm[i][j][k] = k;
random_shuffle(perm[i][j], perm[i][j] + ns);
}
printf("%d\n", sum);
dfs(0, 0, 0, 0, 0, 0);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
inline int read() {
int ret, cc, sign = 1;
while (!isdigit(cc = getchar())) sign = cc == '-' ? -1 : sign;
ret = cc - 48;
while (isdigit(cc = getchar())) ret = cc - 48 + ret * 10;
return ret * sign;
}
const int MOD = 998244353;
const int G = 3;
const int MAXN = 600010;
inline int add(int a, int b) { return (a += b) >= MOD ? a - MOD : a; }
inline int sub(int a, int b) { return (a -= b) < 0 ? a + MOD : a; }
inline int mul(int a, int b) { return 1ll * a * b % MOD; }
inline int qpow(int a, int p) {
int ret = 1;
for (p += (p < 0) * (MOD - 1); p; p >>= 1, a = mul(a, a))
if (p & 1) ret = mul(ret, a);
return ret;
}
inline std::vector<int> operator*(const std::vector<int>&,
const std::vector<int>&);
int fac[MAXN];
int inv[MAXN];
int main() {
int n = read(), K = read(), L = read();
n = n << 1 | 1, fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = mul(fac[i - 1], i);
inv[n] = qpow(fac[n], MOD - 2);
for (int i = n; i >= 1; --i) inv[i - 1] = mul(inv[i], i);
n >>= 1;
std::vector<int> A(n + 1), B(n + 1);
for (int i = 0; i <= n; ++i) {
A[i] = inv[i] * (i >= K);
B[i] = i & 1 ? MOD - inv[i] : inv[i];
}
A = A * B;
int ans = 0;
for (int i = K, pw = qpow(2, K); i <= n; ++i, pw = mul(pw, 2)) {
int cof = mul(pw, mul(fac[i], fac[i]));
cof = mul(cof, mul(inv[i << 1 | 1], inv[n - i]));
ans = add(ans, mul(cof, A[i]));
}
ans = mul(ans, fac[n]);
printf("%d\n", mul(ans, L));
}
int rev[MAXN];
int W[MAXN];
inline int getrev(int n) {
int len = 1, cnt = 0;
while (len < n) len <<= 1, ++cnt;
for (int i = 0; i < len; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (cnt - 1));
return len;
}
inline void NTT(std::vector<int>& a, int n, int opt) {
a.resize(n);
for (int i = 0; i < n; ++i)
if (i < rev[i]) std::swap(a[i], a[rev[i]]);
for (int i = (W[0] = 1); i < n; i <<= 1) {
int wn = qpow(G, opt * (MOD - 1) / (i << 1));
for (int k = i - 2; k >= 0; k -= 2) W[k + 1] = mul(W[k] = W[k >> 1], wn);
for (int j = 0, p = i << 1; j < n; j += p) {
for (int k = 0; k < i; ++k) {
int x = a[j + k], y = mul(W[k], a[j + k + i]);
a[j + k] = add(x, y), a[j + k + i] = sub(x, y);
}
}
}
if (opt == -1)
for (int i = 0, r = qpow(n, MOD - 2); i < n; ++i) a[i] = mul(a[i], r);
}
inline std::vector<int> operator*(const std::vector<int>& lhs,
const std::vector<int>& rhs) {
std::vector<int> A(lhs), B(rhs);
int len = A.size() + B.size() - 1;
int bln = getrev(len);
NTT(A, bln, 1), NTT(B, bln, 1);
for (int i = 0; i < bln; ++i) A[i] = mul(A[i], B[i]);
NTT(A, bln, -1), A.resize(len);
return A;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, p, k, rmx;
struct Node {
int a, b, id, rd;
} x[maxn], y[maxn];
bool cmp1(const Node &x, const Node &y) {
return x.b < y.b || x.b == y.b && x.a > y.a;
}
bool cmp2(const Node &x, const Node &y) {
return x.a > y.a || x.a == y.a && x.b > y.b;
}
int main() {
scanf("%d%d%d", &n, &p, &k);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x[i].a, &x[i].b);
x[i].id = i;
}
sort(x, x + n, cmp1);
for (int i = 0; i < n; ++i) {
x[i].rd = i;
y[i] = x[i];
}
sort(x + p - k, x + n, cmp2);
rmx = n - 1;
for (int i = p - k; i < p; ++i) {
printf("%d ", x[i].id + 1);
if (x[i].rd < rmx) rmx = x[i].rd;
}
for (int i = 1; i <= p - k; ++i)
printf("%d%c", y[rmx - i].id + 1, " \n"[i == p - k]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool DEB = 0;
void __start__() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
mt19937_64 rnd(time(0));
using ll = long long;
using vi = vector<int>;
using ld = long double;
using pii = pair<int, int>;
void test_case() {
string s, t;
cin >> s >> t;
if (s < t) {
cout << s << '\n';
return;
}
vector<pair<char, int>> r;
for (int i = 0; i < (int)s.size(); ++i) r.push_back({s[i], i});
sort(r.begin(), r.end());
char c = '?';
int pos = 0;
for (int i = 0; i < (int)s.size(); ++i) {
if (s[i] == r[i].first) continue;
c = r[i].first;
pos = i;
break;
}
for (int i = 0; i < (int)s.size(); ++i) {
swap(s[i], s[pos]);
if (s < t) {
cout << s << '\n';
return;
}
swap(s[i], s[pos]);
}
cout << "---\n";
}
signed main() {
__start__();
int Q;
cin >> Q;
while (Q--) test_case();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-5;
const long double PI = acos(-1);
const int INF = (int)1e9;
const long long INFF = (long long)1e18;
const int mod = (int)1e9 + 7;
const int MXN = (int)1e5 + 7;
char s1[MXN], s2[MXN];
int fail[MXN];
long long hh[MXN][27], bs[MXN][27], bs2[MXN][5];
long long val3[MXN][7], val4[MXN][7];
int MOD[5] = {1010102101, 1010101333, 999991921, mod, 1076767633};
mt19937 rng(0x5EED);
long long randint(long long lb = 0, long long ub = INF) {
return uniform_int_distribution<long long>(lb, ub)(rng);
}
int l1, l2;
vector<int> st;
void build() {
int l = strlen(s2 + 1);
fail[1] = 0;
int pos = 0;
for (int i = 2; i <= l; ++i) {
while (pos != 0 && s2[i] != s2[pos + 1]) pos = fail[pos];
if (s2[i] == s2[pos + 1]) pos++;
fail[i] = pos;
if (fail[i]) st.push_back(i - fail[i]);
}
sort(begin(st), end(st));
return;
}
bool check(int ll, int len) {
if (ll + len - 1 > l1) return 0;
for (int j = 0; j < 5; ++j) {
long long v1 = (val3[ll + len - 1][j] -
val3[ll - 1][j] * bs2[len][j] % MOD[j] + MOD[j]) %
MOD[j];
long long v2 = val4[len][j];
if (v1 != v2) return 0;
}
return 1;
}
int main(void) {
scanf("%s %s", s1 + 1, s2 + 1);
l1 = strlen(s1 + 1);
l2 = strlen(s2 + 1);
build();
for (int j = 0; j < 5; ++j) {
bs2[0][j] = 1;
bs2[1][j] = 26;
for (int i = 2; i < MXN; ++i) bs2[i][j] = bs2[i - 1][j] * 26 % MOD[j];
}
for (int j = 0; j < 5; ++j) {
for (int i = 0; i < 26; ++i) hh[i][j] = randint();
for (int i = 1; i < l1 + 1; ++i) {
val3[i][j] = (val3[i - 1][j] * 26 + hh[s1[i] - 'a'][j]) % MOD[j];
}
for (int i = 1; i < l2 + 1; ++i) {
val4[i][j] = (val4[i - 1][j] * 26 + hh[s2[i] - 'a'][j]) % MOD[j];
}
}
long long ans = l1 * 1ll * l2;
for (int i = 2; i < l1 + 1; ++i) {
int ll = 0, rr = (int)(st).size() - 1, ok = -1;
while (ll <= rr) {
int mid = (ll + rr) >> 1;
if (check(i, st[mid]))
ll = mid + 1, ok = mid;
else
rr = mid - 1;
}
ans -= (ok + 1);
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 20;
const long long MASK = (1 << 20);
long long adj[MAXN][MAXN];
long long dp[MASK][MAXN];
long long a[MAXN];
bool bit(long long x, long long a) {
for (long long i = MAXN; i >= 0; i--) {
if (x >= (1 << i)) {
x -= (1 << i);
if (i == a) {
return true;
}
}
}
return false;
}
long long bit_num(long long x) {
long long res = 0;
for (long long i = MAXN; i >= 0; i--) {
if (x >= (1 << i)) {
x -= (1 << i);
res++;
}
}
return res;
}
int main() {
long long n, m, k, res = 0;
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < k; i++) {
long long v, u, w;
cin >> v >> u >> w;
adj[v - 1][u - 1] = w;
}
for (long long i = 0; i < (1 << n); i++) {
for (long long j = 0; j < n; j++) {
if (!bit(i, j)) {
continue;
}
long long u = i - (1 << j);
if (u == 0) {
dp[i][j] = a[j];
}
for (long long w = n + 1; w >= 0; w--) {
if (u >= (1 << w)) {
u -= (1 << w);
dp[i][j] = max(dp[i][j], dp[i - (1 << j)][w] + adj[w][j] + a[j]);
}
}
if (bit_num(i) == m) {
res = max(res, dp[i][j]);
}
}
}
cout << res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, l, r, x, y, k;
cin >> l >> r >> x >> y >> k;
for (i = x; i <= y; i++) {
long long ans = (long long)i * k;
if (ans <= 10000000)
if (ans <= r && ans >= l) break;
}
if (i == y + 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int64_t mod = 1e9 + 7;
int64_t mod1 = 1e9 + 5;
int64_t power(int64_t a, int64_t b) {
if (b == 0)
return 1;
else if (b % 2 == 0)
return power((((a % mod) * (a % mod)) % mod), b / 2) % mod;
else
return ((a % mod) * (power((((a % mod) * (a % mod)) % mod), b / 2) % mod)) %
mod;
}
int co[21][21];
int dp[1ll << 20];
int n, m;
int fin(int mask) {
int &res = dp[mask];
if (res != -1) return res;
if (mask == 0) return 0;
res = 1e9;
for (int i = 0; i < m; ++i) {
if ((1ll << i) & mask) {
int cost = 0;
int temp = __builtin_popcount(mask);
for (int j = 0; j < m; ++j) {
if (j == i) continue;
if ((1ll << j) & mask) {
cost += co[i][j];
} else {
cost -= co[i][j];
}
}
res = min(res, fin(mask ^ (1ll << i)) + cost * temp);
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
memset(co, 0, sizeof(co));
memset(dp, -1, sizeof(dp));
cin >> n >> m;
string s;
cin >> s;
for (int i = 1; i < n; ++i) {
co[s[i - 1] - 'a'][s[i] - 'a']++;
co[s[i] - 'a'][s[i - 1] - 'a']++;
}
cout << fin((1ll << m) - 1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, d, h;
void panic() {
cout << -1 << endl;
exit(0);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> d >> h;
if (d > h * 2) {
panic();
}
if (d == h) {
if (n == h + 1) {
for (int i = 1; i < n; i++) {
cout << i << ' ' << i + 1 << '\n';
}
return 0;
} else if (h == 1) {
panic();
} else {
n -= 1;
long long mmax = 0;
for (int i = 1; i <= h; i++) {
cout << i << ' ' << i + 1 << '\n';
mmax = i + 1;
n--;
}
for (int i = 1; i <= d - h; i++) {
if (i == 1) {
cout << i << ' ' << h + i + 1 << '\n';
mmax = h + i + 1;
} else {
cout << h + i << ' ' << h + i + 1 << '\n';
mmax = h + i + 1;
}
n--;
}
while (n > 0) {
cout << 2 << ' ' << ++mmax << '\n';
n--;
}
return 0;
}
}
n -= 1;
long long mmax = 0;
for (int i = 1; i <= h; i++) {
cout << i << ' ' << i + 1 << '\n';
mmax = i + 1;
n--;
}
for (int i = 1; i <= d - h; i++) {
if (i == 1) {
cout << i << ' ' << h + i + 1 << '\n';
mmax = h + i + 1;
} else {
cout << h + i << ' ' << h + i + 1 << '\n';
mmax = h + i + 1;
}
n--;
}
while (n > 0) {
cout << 1 << ' ' << ++mmax << '\n';
n--;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a = "";
int n, k = 0;
cin >> n;
int arr[n], c = (n / 3);
bool check = true;
for (int x = 0; x < n; x++) cin >> arr[x];
sort(arr, arr + n);
for (int x = 0; x < n / 3; x++) {
if (arr[x] < arr[x + c] && arr[x + c] % arr[x] == 0 &&
arr[x + c * 2] > arr[x + c] && arr[x + c * 2] % arr[x + c] == 0) {
a += to_string(arr[x]) + " " + to_string(arr[x + (n / 3)]) + " " +
to_string(arr[x + ((n / 3) * 2)]) + "\n";
} else {
check = false;
break;
}
}
(check) ? cout << a << endl : cout << "-1" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int table[128][10010];
int minShifts[128][10010];
int main() {
int N, M;
cin >> N >> M;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 0; j < s.size(); j++) table[i][j] = (s[j] == '1' ? 1 : 0);
}
for (int i = 0; i < 128; i++)
for (int j = 0; j < 10010; j++) minShifts[i][j] = 1 << 20;
for (int i = 0; i < N; i++) {
bool ex = false;
int prevOc = -1;
for (int j = 0; j < 2 * M; j++) {
if (table[i][j % M] == 1) ex = true, prevOc = j % M;
if (prevOc != -1)
minShifts[i][j % M] =
min(minShifts[i][j % M],
min(abs(j % M - prevOc), abs(M - abs(j % M - prevOc))));
}
prevOc = -1;
for (int j = 2 * M - 1; j >= 0; j--) {
if (table[i][j % M] == 1) ex = true, prevOc = j % M;
if (prevOc != -1)
minShifts[i][j % M] =
min(minShifts[i][j % M],
min(abs(j % M - prevOc), abs(M - abs(j % M - prevOc))));
}
if (ex == false) {
cout << -1 << endl;
return 0;
}
}
int totalShifts = 1 << 20;
for (int i = 0; i < M; i++) {
int curr = 0;
for (int j = 0; j < N; j++) curr += minShifts[j][i];
totalShifts = min(totalShifts, curr);
}
if (totalShifts >= 1 << 20)
cout << -1 << endl;
else
cout << totalShifts << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int n, h;
double p;
long long int dizi[2004];
bool used[2004][2004][2][2];
double dp[2004][2004][2][2];
long double f(int x, int y, int a, int b) {
if (x > y) return 0;
if (used[x][y][a][b]) return dp[x][y][a][b];
used[x][y][a][b] = 1;
long long int sol = (a ? dizi[x - 1] + h : dizi[x - 1]);
long long int sag = (b == 0 ? dizi[y + 1] - h : dizi[y + 1]);
if (x == y) {
if (sol > dizi[x]) return dp[x][y][a][b] = min(dizi[x] + h, sag) - dizi[x];
if (sag < dizi[y]) return dp[x][y][a][b] = dizi[y] - max(sol, dizi[y] - h);
long double son1 = dizi[x] - max(sol, dizi[x] - h);
long double son2 = min(dizi[x] + h, sag) - dizi[x];
long double son3 = dizi[y] - max(sol, dizi[y] - h);
long double son4 = min(sag, dizi[y] + h) - dizi[y];
return dp[x][y][a][b] =
(son1 * p + son2 * (1 - p) + son3 * p + son4 * (1 - p)) / 2;
}
if (sol > dizi[x])
return dp[x][y][a][b] =
f(x + 1, y, 1, b) + min(dizi[x] + h, dizi[x + 1]) - dizi[x];
if (sag < dizi[y])
return dp[x][y][a][b] =
f(x, y - 1, a, 0) + dizi[y] - max(dizi[y - 1], dizi[y] - h);
long double son1 = f(x + 1, y, 0, b) + dizi[x] - max(sol, dizi[x] - h);
long double son2 =
f(x + 1, y, 1, b) + min(dizi[x] + h, dizi[x + 1]) - dizi[x];
long double son3 =
f(x, y - 1, a, 0) + dizi[y] - max(dizi[y - 1], dizi[y] - h);
long double son4 = f(x, y - 1, a, 1) + min(sag, dizi[y] + h) - dizi[y];
return dp[x][y][a][b] =
(son1 * p + son2 * (1 - p) + son3 * p + son4 * (1 - p)) / 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> h >> p;
dizi[0] = -1000000000000L;
dizi[n + 1] = 1000000000000L;
for (int i = 1; i <= n; i++) cin >> dizi[i];
sort(dizi + 1, dizi + n + 1);
cout.precision(100);
cout << f(1, n, 0, 1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, m, m2;
char c;
scanf("%d %c %d", &h, &c, &m);
scanf("%d", &m2);
m2 += m;
int h2 = (int)(m2 / 60);
h2 += h;
h2 %= 24;
m2 = m2 % 60;
if (h2 >= 0 && h2 <= 9) printf("0");
printf("%d:", h2);
if (m2 >= 0 && m2 <= 9) printf("0");
printf("%d\n", m2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int mod = 998244353;
const int maxn = 40 + 7;
int n, m;
int cnt = 0, inde = 0, ans = 0;
set<int> second[100007];
int some[maxn][maxn];
int none[maxn][maxn];
int all[maxn][maxn];
int ma[maxn][maxn];
map<string, int> ma1;
pair<int, int> deg[maxn];
void dfs(int d, int an, int sn, int nn) {
if (!sn && !nn) {
ans = max(ans, an);
return;
}
int pivot = some[d][1];
for (int j = 1; j <= an; ++j) all[d + 1][j] = all[d][j];
for (int i = 1; i <= sn; ++i) {
int v = some[d][i];
if (ma[pivot][v]) continue;
all[d + 1][an] = v;
int tsn = 0, tnn = 0;
for (int j = 1; j <= sn; ++j)
if (ma[v][some[d][j]]) some[d + 1][++tsn] = some[d][j];
for (int j = 1; j <= nn; ++j)
if (ma[v][none[d][j]]) none[d + 1][++tnn] = none[d][j];
dfs(d + 1, an + 1, tsn, tnn);
some[d][i] = 0, none[d][++nn] = v;
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (1); i <= (n); i++) {
int x;
scanf("%d", &x);
if (x == 1)
++cnt;
else {
string s;
cin >> s;
if (ma1.count(s) == 0) ma1[s] = ++inde;
second[cnt].insert(ma1[s]);
}
}
for (int i = (1); i <= (m); i++)
for (int j = (1); j <= (m); j++) ma[i][j] = 1;
for (int i = (1); i <= (cnt); i++)
for (auto x : second[i])
for (auto y : second[i]) {
ma[x][y] = 0;
}
for (int i = (1); i <= (m); i++)
for (int j = (1); j <= (m); j++) {
if (ma[i][j]) deg[i].first++;
deg[i].second = i;
}
sort(deg + 1, deg + 1 + m);
for (int i = m; i >= 1; i--) some[1][i] = deg[i].second;
dfs(1, 0, m, 0);
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class T2>
inline int chkmax(T &x, const T2 &y) {
return x < y ? x = y, 1 : 0;
}
template <class T, class T2>
inline int chkmin(T &x, const T2 &y) {
return x > y ? x = y, 1 : 0;
}
const int MAXN = (1 << 20);
const int mod = 998244353;
int n;
void read() { cin >> n; }
int dp[MAXN][2];
int lg[MAXN];
int rec(int n, int p) {
if (n == 0) return 1;
if (n == 1) return p == 1;
int &memo = dp[n][p];
if (memo != -1) return memo;
memo = 0;
int l = (1 << lg[n + 1]) / 2;
int r = l + n + 1 - (1 << lg[n + 1]);
if (r > (1 << lg[n + 1])) l += r - (1 << lg[n + 1]), r = (1 << lg[n + 1]);
for (int i = l; i <= r; i++)
if (i % 2 == p) {
memo += rec(i - 1, p ^ 1) * 1ll * rec(n - i, 0) % mod;
memo %= mod;
}
return memo;
}
void solve() {
int x = 1, par = 0;
while (x < n) {
if (par == 0 || par == 2) x++;
if (par == 1) x *= 2;
if (par == 3) x = x * 2 - 1;
par++;
par %= 4;
}
if (x == n)
cout << 1 << '\n';
else
cout << 0 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int periodifier(int a[], int len, int period) {
int count = 0;
for (int i = 0; i < period; i++) {
int c_1 = 0, c_2 = 0;
int p[len / period];
for (int j = 0; j < len / period; j++)
if (a[i + j * period] == 1)
c_1++;
else
c_2++;
if (c_1 == 0 || c_2 == 0)
;
else if (c_1 > c_2)
count += c_2;
else
count += c_1;
}
return count;
}
int main() {
int len, period;
cin >> len >> period;
int c[len];
for (int i = 0; i < len; i++) cin >> c[i];
cout << periodifier(c, len, period);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
const int MOD = 1e9 + 7;
const int lgN = 22;
const int N = 2e5 + 5;
array<int, 2> v[N];
int ans[N];
bool toleft(array<int, 2> a, array<int, 2> b, array<int, 2> c) {
long long int delx1 = b[0] - a[0], delx2 = c[0] - b[0];
long long int dely1 = b[1] - a[1], dely2 = c[1] - b[1];
return delx1 * dely2 - delx2 * dely1 > 0;
}
void solve() {
int n, i;
cin >> n;
for (i = 0; i < n; i++) cin >> v[i][0] >> v[i][1];
string s;
cin >> s;
for (i = 0; i < n; i++) ans[i] = i;
int j = 0;
for (i = 1; i < n; i++) {
if (v[i][1] < v[j][1]) {
j = i;
} else if (v[i][1] == v[j][1] && v[i][0] < v[j][0]) {
j = i;
}
}
swap(v[0], v[j]);
swap(ans[0], ans[j]);
for (i = 1; i < n - 1; i++) {
int mxj = i, mnj = i;
for (int k = i + 1; k < n; k++) {
if (toleft(v[i - 1], v[mnj], v[k])) {
mnj = k;
}
if (toleft(v[i - 1], v[k], v[mxj])) {
mxj = k;
}
}
if (s[i - 1] == 'R') {
swap(v[i], v[mnj]);
swap(ans[i], ans[mnj]);
} else {
swap(v[i], v[mxj]);
swap(ans[i], ans[mxj]);
}
}
for (i = 0; i < n; i++) cout << ans[i] + 1 << " \n"[i == n - 1];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (int tc = 1; tc <= t; ++tc) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1001];
int d[4];
int main() {
scanf("%d", &n);
a[0] = 0;
for (int i = 0; i < (int)(n); ++i) scanf("%d", a + i + 1);
for (int i = 1; i <= n; ++i) {
int pre = a[i - 1];
int x = a[i];
for (int i = 0; i < (int)(4); ++i) {
d[i] = x % 10;
x /= 10;
}
int best = 9999;
for (int i = 0; i < (int)(4); ++i) {
int rem = d[i];
for (int j = 0; j < (int)(10); ++j) {
d[i] = j;
int num = 0;
for (int k = 3; k >= 0; --k) {
num = 10 * num + d[k];
}
if (num >= pre && num >= 1000 && num <= 2011) {
best = min(best, num);
}
}
d[i] = rem;
}
if (best == 9999) {
printf("No solution\n");
return 0;
}
a[i] = best;
}
for (int i = 0; i < (int)(n); ++i) printf("%d\n", a[i + 1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
vector<pair<int, char> > D;
int x = 1;
for (int i = 1; i < a.size(); i++) {
if (a[i] != a[i - 1]) {
D.push_back({x, a[i - 1]});
x = 1;
} else {
x++;
}
}
D.push_back({x, a[a.size() - 1]});
for (int i = 0; i < D.size(); i++) {
if (i == 0) {
if (D[i].first > 2) {
D[i].first = 2;
}
} else {
if (D[i].first == 1) {
continue;
} else if (D[i].first > 2) {
D[i].first = 2;
}
if (D[i - 1].first < 2) {
continue;
} else {
D[i].first = 1;
}
}
}
for (int i = 0; i < D.size(); i++) {
for (int j = 0; j < D[i].first; j++) {
cout << D[i].second;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
double p = 1.0 * a / b;
double q = (1 - 1.0 * c / d) * (1 - 1.0 * a / b);
cout << p / (1 - q);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
bool check1;
check1 = false;
for (int i = 1; i < a.size(); i++) {
if (a[i] >= 'a' && a[i] <= 'z') check1 = true;
}
if (check1 == false) {
if (a[0] >= 'a' && a[0] <= 'z')
a[0] = toupper(a[0]);
else
a[0] = tolower(a[0]);
for (int i = 1; i < a.size(); i++) {
if (islower(a[i]))
a[i] = toupper(a[i]);
else
a[i] = tolower(a[i]);
}
}
cout << a << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, sec, count, assem;
long long b[100000], elem[100000], disassem[100000];
cin >> n >> k;
for (int i = 0; i < k; i++) {
count = 0;
sec = 0;
cin >> a;
for (int j = 0; j < a; j++) {
cin >> b[j];
}
if (b[0] == 1) {
for (int x = 0; x < a - 1; x++) {
if (b[x + 1] == b[x] + 1)
count++;
else
break;
}
}
disassem[i] = a - count - 1;
elem[i] = a - count;
}
int sum = 0, td = 0, te = 0;
for (int i = 0; i < k; i++) td = td + disassem[i];
for (int i = 0; i < k; i++) te = te + elem[i];
sum = td + te - 1;
cout << sum;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(double t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]" << endl;
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long power(long long x, unsigned 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 mod_inverse(long long a, long long p) { return power(a, p - 2, p); }
void swap(long long &x, long long &y) {
long long temp = x;
x = y;
y = temp;
}
vector<long long> sieve(long long n) {
long long *arr = new long long[n + 1]();
vector<long long> vect;
for (long long i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (long long j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mod_inverse(b, m), m) + m) % m;
}
long long modfact(long long n, long long p) {
if (p <= n) return 0;
long long res = (p - 1);
for (long long i = n + 1; i < p; i++) res = (res * mod_inverse(i, p)) % p;
return res;
}
long long fact(long long n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n), b(n);
map<long long, long long> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
m[b[i]] = i + 1;
}
for (long long i = 0; i < n; i++) {
a[i] = m[a[i]];
}
long long ans = 0;
for (long long i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
ans = n - i;
break;
}
}
cout << ans;
;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
auto start1 = high_resolution_clock::now();
solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int a[MAXN], b[MAXN];
int ans_1 = 0, ans_u = 0;
int _find(int x) {
if (x == a[x]) return x;
return a[x] = _find(a[x]);
}
void unite(int x, int y) {
x = _find(x);
y = _find(y);
if (x == y) return;
a[x] = y;
ans_u++;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
memset(a, -1, sizeof(a));
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int len = m / 4;
for (int j = 0; j < len; j++) {
int x;
if (s[j] >= 'A')
x = s[j] - 'A' + 10;
else
x = s[j] - '0';
for (int k = 0; k < 4; k++) {
b[j * 4 + 3 - k] = x & 1;
x >>= 1;
}
}
for (int k = 0; k < m; k++) b[k] ? a[k + m] = k + m : -1;
for (int k = 0; k < m; k++) {
if (b[k] == 1)
ans_1++;
else
continue;
if (~a[k]) unite(k, k + m);
if (k != 0 && b[k - 1]) unite(k + m - 1, k + m);
}
for (int k = 0; k < m; k++) a[k] = b[k] ? _find(k + m) - m : -1;
}
cout << ans_1 - ans_u << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long limit = 4294967296;
int MOD = 1000000007;
template <typename T>
void print(const T& x) {
cerr << x << ' ';
}
template <typename T1, typename... T2>
void print(const T1& first, const T2&... rest) {
print(first);
print(rest...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long q, n, k;
cin >> q;
while (q--) {
cin >> n >> k;
string s;
cin >> s;
int place = 0;
for (int i = 0; i < (int)s.size() && k > 0; i++) {
if (s[i] == '0') {
if (i - place <= k) {
swap(s[i], s[place]);
k -= i - place;
place++;
} else {
swap(s[i], s[i - k]);
k = 0;
}
}
}
cout << s << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n == 3) {
cout << "NO\n";
continue;
}
if ((n - 4) % 4 == 0)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[7010], b[7010];
bool mark[7010];
int32_t main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
}
for (long long i = 0; i < n; i++) {
long long cnt = 0;
for (long long j = 0; j < n; j++) {
if (a[i] == a[j]) cnt++;
}
if (cnt == 1) continue;
for (long long j = 0; j < n; j++) {
if ((a[j] | a[i]) == a[i]) {
mark[j] = true;
}
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (mark[i]) {
ans += b[i];
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void rd(T &x) {
x = 0;
int f = 1;
char c;
while (!isdigit(c = getchar()))
if (c == '-') f = -1;
do {
x = (x << 3) + (x << 1) + (c ^ 48);
} while (isdigit(c = getchar()));
x *= f;
}
const int N = 1e6 + 5, INF = 0x3f3f3f3f;
int q[N], n, k, x, dp[2][N], head, tail, l, r;
int main() {
rd(n), rd(k);
memset(dp[0], 0x3f, sizeof dp[0]);
dp[0][0] = 0;
while (k--) {
x ^= 1;
memcpy(dp[x], dp[x ^ 1], sizeof dp[x]);
rd(l), rd(r);
head = 1, tail = 0;
for (int i = 0; i <= min(n, r); i++) {
while (head <= tail && q[head] < i - r + l) head++;
while (head <= tail && dp[x ^ 1][q[tail]] >= dp[x ^ 1][i]) tail--;
q[++tail] = i;
dp[x][i] = min(dp[x][i], dp[x ^ 1][q[head]] + 2);
}
head = 1, tail = 0;
for (int i = r; i >= 0; i--) {
while (head <= tail && q[head] < l - i) head++;
while (head <= tail && dp[x ^ 1][q[tail]] >= dp[x ^ 1][r - i]) tail--;
q[++tail] = r - i;
dp[x][i] = min(dp[x][i], dp[x ^ 1][q[head]] + 1);
}
}
if (dp[x][n] >= INF)
printf("Hungry");
else
printf("Full\n%d", dp[x][n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int st[N], ed[N], cnt = 1;
int n, p, t[N], seg[4 * N], lazy[4 * N], q, v;
char tmp[10];
vector<int> g[N];
struct node {
int l, r;
int mid() { return l + r >> 1; }
int lazy, num;
} tree[N * 4];
void push_down(int rt) {
if (tree[rt].lazy) {
tree[rt].num = (tree[rt].r - tree[rt].l + 1) - tree[rt].num;
if (tree[rt].l != tree[rt].r) {
tree[rt << 1].lazy ^= 1;
tree[rt << 1 | 1].lazy ^= 1;
}
}
tree[rt].lazy = 0;
}
void push_up(int rt) {
tree[rt].num = tree[rt << 1].num + tree[rt << 1 | 1].num;
}
void update(int rt, int l, int r) {
push_down(rt);
if (tree[rt].l > r || tree[rt].r < l) return;
if (tree[rt].l >= l && tree[rt].r <= r) {
tree[rt].lazy = 1;
push_down(rt);
return;
}
update(rt << 1, l, r);
update(rt << 1 | 1, l, r);
push_up(rt);
}
int query(int rt, int l, int r) {
push_down(rt);
if (tree[rt].l == l && tree[rt].r == r) {
return tree[rt].num;
}
int mid = tree[rt].mid();
if (mid >= r)
return query(rt << 1, l, r);
else if (mid < l)
return query(rt << 1 | 1, l, r);
else
return query(rt << 1, l, mid) + query(rt << 1 | 1, mid + 1, r);
}
void build(int rt, int l, int r) {
tree[rt].l = l;
tree[rt].r = r;
tree[rt].num = tree[rt].lazy = 0;
if (l >= r) return;
int mid = tree[rt].mid();
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
}
void dfs(int u) {
st[u] = cnt++;
for (int i = 0; i < g[u].size(); ++i) {
dfs(g[u][i]);
}
ed[u] = cnt - 1;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", &p);
g[p].push_back(i);
}
dfs(1);
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &t[i]);
if (t[i]) update(1, st[i], st[i]);
}
for (int i = 1; i <= n; ++i) {
}
scanf("%d", &q);
while (q--) {
scanf("%s%d", tmp, &p);
if (tmp[0] == 'g') {
printf("%d\n", query(1, st[p], ed[p]));
} else {
update(1, st[p], ed[p]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, z, t3, t1, t2;
cin >> x >> y >> z >> t1 >> t2 >> t3;
t3 *= 3;
z = abs(z - x) + abs(x - y);
z *= t2;
z += t3;
t1 *= abs(x - y);
if (z > t1)
cout << "NO";
else
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
int k, t;
t = 0;
cin >> n >> d;
for (int i = 0; i < n; ++i) {
int c;
cin >> c;
t += c;
}
if ((t + (n - 1) * 10) > d) {
cout << "-1" << endl;
} else {
cout << (d - t) / 5 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const unsigned int maxl = 18, maxn = 1u << maxl;
constexpr unsigned long long mod = 998244353, primitiveRoot = 3;
class Number {
public:
inline friend Number operator+(const Number l, const Number r) {
return Number{(l.val + r.val) % mod};
}
inline void operator+=(const Number r) { val = (val + r.val) % mod; };
inline friend Number operator*(const Number l, const Number r) {
return Number{(l.val * r.val) % mod};
}
inline void operator*=(const Number r) { val = (val * r.val) % mod; };
inline friend Number operator-(const Number l, const Number r) {
return Number{l.val >= r.val ? l.val - r.val : l.val + mod - r.val};
}
inline void operator-=(const Number r) {
val = val >= r.val ? val - r.val : val + mod - r.val;
}
inline friend std::ostream& operator<<(std::ostream& os, const Number v) {
return os << v.val;
}
inline Number operator-() const { return Number{val ? mod - val : 0}; }
unsigned long long val;
};
Number unit[2][maxl + 10], fac[maxn + 10], ifac[maxn + 10], inv[maxn + 10];
unsigned int rev[maxn + 10];
Number quickPow(Number a, unsigned long long e) {
Number ret{1};
for (; e; e >>= 1) {
if (e & 0x01) ret *= a;
a *= a;
}
return ret;
}
inline Number inverse(const Number a) { return quickPow(a, mod - 2); }
static void initUnit(const unsigned int lgn) {
for (unsigned int i = 1; i <= lgn; ++i) {
unit[0][i] = quickPow(Number{primitiveRoot}, (mod - 1) >> i);
unit[1][i] = inverse(unit[0][i]);
}
}
static void initModularInv(const unsigned int n) {
inv[0].val = inv[1].val = 1;
for (unsigned int i = 2; i <= n; ++i)
inv[i].val = mod - (inv[mod % i] * Number{mod / i}).val;
}
static void initFactor(const unsigned int n) {
fac[0].val = ifac[0].val = 1;
for (unsigned int i = 1; i <= n; ++i) {
fac[i] = fac[i - 1] * Number{i};
ifac[i] = ifac[i - 1] * inv[i];
}
}
static void initRev(const unsigned int lgn) {
for (unsigned int i = 0; i < lgn; ++i) rev[1u << i] = 1u << (lgn - 1 - i);
const unsigned int n = 1u << lgn;
for (unsigned int i = 3; i < n; ++i) {
const unsigned int lb = i & -i;
rev[i] = rev[i ^ lb] | rev[lb];
}
}
unsigned int Log2(const unsigned int n) {
for (unsigned int i = 0;; ++i)
if (n <= (1u << i)) return i;
}
static unsigned int init(const unsigned int n) {
const unsigned int lgn = Log2(n + 1), v = 1u << (lgn + 1);
initRev(lgn + 1);
initUnit(lgn + 1);
initModularInv(v);
initFactor(v);
return lgn;
}
template <unsigned int inv>
void reverseCopy(Number dest[], const Number src[], const unsigned int n) {
const unsigned int cpy = n >> inv;
for (unsigned int i = 0; i < cpy; ++i) dest[rev[i]] = src[i];
for (unsigned int i = cpy; i < n; ++i) dest[rev[i]].val = 0;
}
template <bool typ, unsigned int inv>
void dft(const Number a[], Number dest[], const unsigned int lgn) {
const unsigned int n = 1u << lgn;
reverseCopy<inv>(dest, a, n);
for (unsigned int i = 1; i <= lgn; ++i) {
const unsigned int step = 1u << i, half = 1u << (i - 1);
const Number wm = unit[typ][i];
for (Number* blk = dest; blk < dest + n; blk += step) {
Number w{1};
for (Number *j = blk, *k = blk + half; j < blk + half; ++j, ++k) {
const Number u = *j, v = *k * w;
*j = u + v;
*k = u - v;
w *= wm;
}
}
}
if constexpr (typ) {
const Number iv = ::inv[n];
for (Number* i = dest; i < dest + n; ++i) *i *= iv;
}
}
template <unsigned int iva = 0, unsigned int ivb = 0>
void ntt(const Number a[], const Number b[], Number dest[],
const unsigned int lgn) {
static Number tmpa[maxn + 10], tmpb[maxn + 10];
dft<false, iva + 1>(a, tmpa, lgn + 1);
dft<false, ivb + 1>(b, tmpb, lgn + 1);
const unsigned int n = 1u << (lgn + 1);
for (unsigned int i = 0; i < n; ++i) tmpa[i] *= tmpb[i];
dft<true, 0>(tmpa, dest, lgn + 1);
}
template <bool inv>
void multiplyMatrix(const Number a[], const unsigned int n,
const unsigned int lgn, Number dest[]) {
static Number u[maxn + 10];
for (unsigned int i = 0; i <= n; ++i)
if constexpr (inv)
u[n - i] = fac[i] * a[i];
else
u[n - i].val = i & 0x01 ? mod - (fac[i] * a[i]).val : (fac[i] * a[i]).val;
ntt(u, ifac, dest, lgn);
std::reverse(dest, dest + n + 1);
if constexpr (inv) {
for (unsigned int i = 0; i <= n; ++i) dest[i] *= ifac[i];
} else {
for (unsigned int i = 0; i <= n; ++i)
dest[i] = i & 0x01 ? -(dest[i] * ifac[i]) : dest[i] * ifac[i];
}
}
void solve(const Number ini[], const unsigned int n, const unsigned long long m,
const unsigned int lgn, Number dest[]) {
static Number tmp[maxn + 10];
multiplyMatrix<true>(ini, n, lgn, tmp);
for (unsigned int i = 0; i <= n; ++i) tmp[i] *= quickPow(inv[i + 1], m);
multiplyMatrix<false>(tmp, n, lgn, dest);
}
int main() {
std::ios::sync_with_stdio(false);
unsigned int n;
unsigned long long m;
std::cin >> n >> m;
static Number ini[maxn + 10];
for (unsigned int i = 0; i <= n; ++i) std::cin >> ini[i].val;
solve(ini, n, m, init(n), ini);
std::copy(ini, ini + n + 1, std::ostream_iterator<Number>(std::cout, " "));
std::cout.put('\n');
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int ec;
int oc;
vector<vector<int> > ans;
stack<int> even;
stack<int> odd;
int makeEven() {
vector<int> temp;
if (!even.empty()) {
temp.push_back(even.top());
even.pop();
ans.push_back(temp);
return 1;
}
if (!odd.empty()) {
temp.push_back(odd.top());
odd.pop();
if (!odd.empty()) {
temp.push_back(odd.top());
odd.pop();
ans.push_back(temp);
} else {
return 0;
}
return 1;
}
return 0;
}
int makeOdd() {
vector<int> temp;
if (!odd.empty()) {
temp.push_back(odd.top());
odd.pop();
ans.push_back(temp);
return 1;
}
return 0;
}
int main() {
int n, k, p;
cin >> n >> k >> p;
ec = 0;
oc = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x % 2 == 0) {
even.push(x);
ec++;
} else {
odd.push(x);
oc++;
}
}
for (int i = 0; i < p; i++) {
if (!makeEven()) {
cout << "NO" << endl;
return 0;
}
}
for (int i = 0; i < k - p; i++) {
if (!makeOdd()) {
cout << "NO" << endl;
return 0;
}
}
int len = odd.size();
if (len % 2 != 0) {
cout << "NO" << endl;
return 0;
}
len = ans[0].size();
while (!even.empty()) {
ans[0].push_back(even.top());
even.pop();
}
while (!odd.empty()) {
ans[0].push_back(odd.top());
odd.pop();
}
len = ans.size();
cout << "YES" << endl;
for (int i = 0; i < k; i++) {
cout << ans[i].size() << " ";
int len = ans[i].size();
for (int j = 0; j < len; j++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {-1, 0, 0, 1};
int dy[4] = {0, -1, 1, 0};
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) return a.second < b.second;
return (a.first < b.first);
}
long long a[10000005];
void sieve() {
for (int i = 1; i < 10000005; i++) {
for (int j = i; j <= 10000005; j += i) {
a[j]++;
}
}
}
long long n, w, h;
bool g(long long x) { return (x / w) * (x / h) >= n; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long test;
cin >> test;
while (test) {
int n, x, y;
string s, w = "";
cin >> s >> x;
n = s.length();
for (int i = 0; i < n; i++) {
w += "1";
}
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
if (i + x < n) w[i + x] = '0';
if (i - x >= 0) w[i - x] = '0';
}
}
bool flag = true;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
if ((i + x >= n || w[i + x] == '0') && (i - x < 0 || w[i - x] == '0')) {
flag = false;
}
}
}
if (!flag)
cout << "-1" << endl;
else
cout << w << endl;
test--;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e6 + 9;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first < b.first) return true;
if (a.first == b.first && a.second < b.second)
return true;
else
return false;
}
vector<pair<long long, long long> > h;
long long m, a[200009], sptable[20][200009];
void build() {
for (int i = 0; i < m; i++) sptable[0][i] = h[i].second;
for (int i = 1; (1 << i) <= m; i++) {
for (int j = 0; j + (1 << i) <= m; j++) {
sptable[i][j] =
max(sptable[i - 1][j], sptable[i - 1][j + (1 << (i - 1))]);
}
}
}
long long query(int a, int b) {
if (a > b) swap(a, b);
int lg = __builtin_clz(1) - __builtin_clz(b - a + 1);
return max(sptable[lg][a], sptable[lg][b - (1 << lg) + 1]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
h.clear();
int monsters[n + 2];
int maxfm = -1;
for (int i = 0; i < n; i++) {
cin >> monsters[i];
maxfm = max(monsters[i], maxfm);
}
cin >> m;
int maxft = -1;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
h.push_back({a, b});
maxft = max(a, maxft);
}
if (maxft < maxfm) {
cout << -1 << '\n';
continue;
}
sort(h.begin(), h.end(), comp);
vector<int> h2;
for (int i = 0; i < m; i++) {
h2.push_back(h[i].first);
}
build();
int ans = 0;
int maxf = -1;
int contd = 0;
for (int i = 0; i < n; i++) {
contd++;
maxf = max(maxf, monsters[i]);
int pos = (upper_bound(h2.begin(), h2.end(), maxf - 1) - h2.begin());
if (pos < m && query(pos, m - 1) >= contd) {
} else {
ans++;
contd = 0;
maxf = -1;
i--;
}
}
if (contd > 0) ans++;
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char ch[110901];
vector<int> f[110901], ff[110901];
int col[110901];
long long Ans;
void ADD(int x, int y, int z) {
f[x].push_back(y);
ff[x].push_back(z);
f[y].push_back(x);
ff[y].push_back(z);
}
bool DFS(int x) {
int X, tp;
for (int i = 0; i < f[x].size(); i++) {
X = f[x][i];
tp = ff[x][i];
if (tp == 0) {
if (col[X] == -1) {
col[X] = col[x];
if (!DFS(X)) return false;
}
if (col[X] != col[x]) return false;
} else {
if (col[X] == -1) {
col[X] = col[x] ^ 1;
if (!DFS(X)) return false;
}
if (col[X] != (col[x] ^ 1)) return false;
}
}
return true;
}
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n / 2; i++) swap(ch[i], ch[n - i + 1]);
if (ch[1] == '1') return printf("0"), 0;
ch[1] = '0';
for (m = n - 1; m; m--) {
for (int i = 1; i <= n + m; i++) ff[i].clear(), f[i].clear(), col[i] = -1;
for (int i = 1; i <= n / 2; i++) ADD(i, n - i + 1, 0);
for (int i = 1; i <= m / 2; i++) ADD(n + i, n + m - i + 1, 0);
for (int i = 1; i <= m; i++) {
if (ch[i] == '?') continue;
ADD(i, i + n, ch[i] - '0');
}
bool flag = true;
for (int i = n; i > m; i--)
if (ch[i] != '?') {
if (col[i] == -1) {
col[i] = ch[i] - '0';
if (!DFS(i)) flag = false;
}
if (col[i] != ch[i] - '0') flag = false;
if (!flag) break;
}
if (!flag) continue;
long long Now = 1;
for (int i = 1; i <= n + m; i++)
if (col[i] == -1) {
col[i] = 1;
if (!DFS(i)) flag = false;
if (!flag) break;
Now = Now * 2 % 998244353;
}
if (!flag) continue;
Ans = (Ans + Now) % 998244353;
}
printf("%I64d\n", Ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long F[200005], G[200005], A[200005];
void init() {
F[0] = 1;
for (int i = 1; i < 200005; ++i) F[i] = i * F[i - 1], F[i] %= m;
G[0] = 1;
A[0] = 0;
for (int i = 1; i < 200005; ++i) {
int Cnt = 0, t = i;
while (t % 2 == 0) t /= 2, Cnt++;
G[i] = G[i - 1] * t, G[i] %= m;
A[i] = A[i - 1] + Cnt;
}
}
long long pow(long long numa, long long numb, long long numc) {
long long numx = 1, numy = numa;
while (numb > 0) {
if (numb & 1) numx = (numx * numy) % numc;
numy = (numy * numy) % numc;
numb >>= 1;
}
return numx;
}
int main() {
while (cin >> n) {
vector<int> v(n), w(n);
map<int, int> M;
for (int i = 0; i < n; ++i) scanf("%d", &v[i]), M[v[i]]++;
for (int i = 0; i < n; ++i) scanf("%d", &w[i]), M[w[i]]++;
int cnt = 0;
for (int i = 0; i < n; ++i)
if (v[i] == w[i]) cnt--;
cin >> m;
init();
long long ans = 1;
for (typeof M.begin() o = M.begin(); o != M.end(); o++) {
ans *= G[o->second], ans %= m;
cnt += A[o->second];
}
ans *= pow(2, cnt, m);
ans %= m;
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 302000, M = N * 3;
int fa[N], fx[N], fy[N], dx[N], dy[N];
int n, m, Q;
int dis[N], q[N];
int head[N], v[M], nxt[M], t = 1;
bool vis[N];
inline void add(int x, int y) {
nxt[++t] = head[x];
v[t] = y;
head[x] = t;
nxt[++t] = head[y];
v[t] = x;
head[y] = t;
}
int gf(int x) {
if (fa[x] != x) fa[x] = gf(fa[x]);
return fa[x];
}
void merge(int x, int y) {
x = gf(x);
y = gf(y);
if (x == y) return;
int a = dx[x], b = dy[x], c = dx[y], d = dy[y];
int tmp = max(a + b, c + d);
tmp = max(tmp, (a + b + 1) / 2 + 1 + (c + d + 1) / 2);
fa[y] = x;
if (tmp == a + b) {
dx[x] = a;
dy[x] = b;
} else if (tmp == c + d) {
dx[x] = c;
dy[x] = d;
} else {
dx[x] = tmp / 2;
dy[x] = tmp - tmp / 2;
}
}
void bfs(int st) {
int h, tail, s, i;
vis[st] = true;
dis[st] = 0;
q[h = tail = 1] = st;
while (h <= tail) {
s = q[h++];
for (i = head[s]; i; i = nxt[i])
if (!vis[v[i]]) {
vis[v[i]] = true;
dis[v[i]] = dis[s] + 1;
q[++tail] = v[i];
}
}
st = q[tail];
for (i = 1; i <= tail; i++) vis[q[i]] = false;
vis[st] = true;
dis[st] = 0;
q[h = tail = 1] = st;
while (h <= tail) {
s = q[h++];
for (i = head[s]; i; i = nxt[i])
if (!vis[v[i]]) {
vis[v[i]] = true;
dis[v[i]] = dis[s] + 1;
q[++tail] = v[i];
}
}
int tmp = dis[q[tail]];
for (i = 1; i <= tail; i++) fa[gf(q[i])] = gf(st);
dx[st] = tmp / 2;
dy[st] = tmp - tmp / 2;
}
int main() {
int i, x, y;
scanf("%d%d%d", &n, &m, &Q);
for (i = 1; i <= n; i++) fa[i] = i, dx[i] = dy[i] = 0;
while (m--) {
scanf("%d%d", &x, &y);
add(x, y);
}
for (i = 1; i <= n; i++)
if (!vis[i]) bfs(i);
int c;
while (Q--) {
scanf("%d", &c);
if (c == 1) {
scanf("%d", &x);
printf("%d\n", dx[gf(x)] + dy[gf(x)]);
} else {
scanf("%d%d", &x, &y);
merge(x, y);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long double eps = 1e-9;
const long double pi = acos(-1.0);
struct Rect {
int x1, y1, x2, y2;
};
int main() {
int n;
cin >> n;
vector<Rect> v(n);
for (int i = 0; i < n; i++) cin >> v[i].x1 >> v[i].y1 >> v[i].x2 >> v[i].y2;
if (n == 1) {
if (v[0].x2 == v[0].y2 - v[0].y1 + v[0].x1) {
cout << "YES" << endl;
return 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
int left = min(v[i].x1, v[j].x1);
int bottom = min(v[i].y1, v[j].y1);
int right = max(v[i].x2, v[j].x2);
int top = max(v[i].y2, v[j].y2);
if (right != top - bottom + left) continue;
int s_quad = (top - bottom) * (right - left);
int s_sum = 0;
for (int k = 0; k < n; k++) {
if (left <= v[k].x1 && right >= v[k].x2 && top >= v[k].y2 &&
bottom <= v[k].y1)
s_sum += (v[k].x2 - v[k].x1) * (v[k].y2 - v[k].y1);
}
if (s_quad == s_sum) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long MaxN = 10050;
struct Edge {
long long nxt, to, f, w;
} E[MaxN << 4];
template <class t>
inline void read(t &s) {
s = 0;
register long long f = 1;
register char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) s = (s << 3) + (s << 1) + (c ^ 48), c = getchar();
s *= f;
return;
}
template <class t, class... A>
inline void read(t &x, A &...a) {
read(x);
read(a...);
}
template <class t>
inline void write(t x) {
if (x < 0) putchar('-'), x = -x;
long long buf[21], top = 0;
while (x) buf[++top] = x % 10, x /= 10;
if (!top) buf[++top] = 0;
while (top) putchar(buf[top--] ^ '0');
return;
}
inline void setIn(std::string s) {
freopen(s.c_str(), "r", stdin);
return;
}
inline void setOut(std::string s) {
freopen(s.c_str(), "w", stdout);
return;
}
inline void setIO(std::string s = "") {
setIn(s + ".in");
setOut(s + ".out");
return;
}
template <class t>
inline bool checkmin(t &x, t y) {
if (x > y) {
x = y;
return 1;
}
return 0;
}
template <class t>
inline bool checkmax(t &x, t y) {
if (x < y) {
x = y;
return 1;
}
return 0;
}
inline long long lowbit(long long x) { return x & (-x); }
long long hd[MaxN], en = -1, n, m, S, T;
inline void adde(long long u, long long v, long long f, long long w) {
E[++en] = (Edge){hd[u], v, f, w}, hd[u] = en, std::swap(u, v), f = 0, w = -w,
E[++en] = (Edge){hd[u], v, f, w}, hd[u] = en;
}
long long dis[MaxN], preE[MaxN], vis[MaxN], flow[MaxN];
signed Q[1 << 23], h, t;
inline bool spfa() {
std::memset(dis, 0x3f, sizeof dis), std::memset(vis, 0, sizeof vis),
flow[S] = 1e18, dis[S] = 0, preE[T] = -1;
Q[h = t = 1] = S;
while (h <= t) {
register long long u = Q[h++];
vis[u] = 0;
for (register long long i = hd[u]; ~i; i = E[i].nxt) {
register long long v = E[i].to;
if (!E[i].f) continue;
if (checkmin(dis[v], dis[u] + E[i].w)) {
preE[v] = i, flow[v] = std::min(flow[u], E[i].f);
if (!vis[v]) vis[v] = 1, Q[++t] = v;
}
}
}
return ~preE[T];
}
inline long long mcmf() {
register long long mc = 0;
while (spfa()) {
mc += flow[T] * dis[T];
for (register long long i = T; i ^ S; i = E[preE[i] ^ 1].to)
E[preE[i]].f -= flow[T], E[preE[i] ^ 1].f += flow[T];
}
return mc;
}
long long a[85][85], Id[85][85];
signed main(void) {
std::memset(hd, -1, sizeof hd);
read(n, m), S = 0, T = MaxN - 1;
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= m; ++j)
read(a[i][j]), Id[i][j] = (i - 1) * m + j;
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= m; ++j)
if ((i + j) & 1) {
adde(S, Id[i][j], 1, 0);
if (i > 1) adde(Id[i][j], Id[i - 1][j], 1, a[i][j] != a[i - 1][j]);
if (j > 1) adde(Id[i][j], Id[i][j - 1], 1, a[i][j] != a[i][j - 1]);
if (i < n) adde(Id[i][j], Id[i + 1][j], 1, a[i][j] != a[i + 1][j]);
if (j < m) adde(Id[i][j], Id[i][j + 1], 1, a[i][j] != a[i][j + 1]);
} else
adde(Id[i][j], T, 1, 0);
write(mcmf()), std::puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x = 0, k = 0;
bool rounds[4000] = {false};
cin >> x >> k;
for (int i = 1; i <= k; ++i) {
int temp = 0;
cin >> temp;
if (temp == 1) {
cin >> temp >> temp;
rounds[temp] = rounds[temp - 1] = true;
} else {
cin >> temp;
rounds[temp] = true;
}
}
int min = 0;
int max = 0;
for (int i = 1; i < x; ++i) {
if (rounds[i] == false) {
if (i + 1 != x && rounds[i + 1] == false) {
++min;
max += 2;
rounds[i] = rounds[i + 1] = true;
} else {
++min;
++max;
rounds[i] = true;
}
}
}
cout << min << " " << max;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1001, inF = numeric_limits<long long>::max();
long long n, m, a, mini = inF, x, y, colps[N], rowps[N], colans[N], rowans[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a;
rowps[i] += a;
colps[j] += a;
}
for (int i = 0; i <= n; i++)
for (int j = 0; j < n; j++) {
long long dis = 4 * abs(i - j) + (j < i ? -2 : +2);
rowans[i] += rowps[j] * dis * dis;
}
for (int i = 0; i <= m; i++)
for (int j = 0; j < m; j++) {
long long dis = 4 * abs(i - j) + (j < i ? -2 : +2);
colans[i] += colps[j] * dis * dis;
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++)
if (rowans[i] + colans[j] < mini) {
mini = rowans[i] + colans[j];
x = i;
y = j;
}
cout << mini << '\n' << x << ' ' << y;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int exc[100020], req[100020];
void solve0() {
long long sufsum = 0;
long long answer = 0;
for (int i = n - 1; i >= 0; i--) {
sufsum += exc[i];
answer = max(answer, sufsum - req[i]);
}
cout << answer << '\n';
}
void solve1() {
long long answer = 0;
answer = max(answer, accumulate(exc, exc + n - 1, 0LL) -
*min_element(req, req + n - 1) +
max(0, exc[n - 1] - req[n - 1]));
answer = max(answer, accumulate(exc, exc + n, 0LL) -
*min_element(exc + 1, exc + n) - req[0]);
long long sufsum = 0;
for (int i = n - 1; i > 0; i--) {
sufsum += exc[i];
answer = max(answer, sufsum - req[i]);
}
sufsum += exc[0];
long long prefsum = 0;
int prefmin = req[0];
for (int i = 0; i < n - 1; i++) {
prefmin = min(prefmin, req[i]);
prefsum += exc[i];
sufsum -= exc[i];
answer = max(answer, prefsum - prefmin + sufsum - req[i + 1]);
}
cout << answer << '\n';
}
void solve2() {
cout << max(0LL, max(0LL + exc[n - 1] - req[n - 1],
accumulate(exc, exc + n, 0LL) -
*min_element(req, req + n - 1)))
<< '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> exc[i];
}
for (int i = 0; i < n; i++) {
cin >> req[i];
}
if (k == 0) {
solve0();
}
if (k == 1) {
solve1();
}
if (k >= 2) {
solve2();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ll n, x, h;
cin >> n;
if (n <= 2) {
cout << n;
return 0;
}
vector<pair<ll, ll>> v(n + 2);
for (int i = 1; i <= n; ++i) cin >> v[i].first >> v[i].second;
v[0] = make_pair(INT_MIN, 0);
v[n + 1] = make_pair(INT_MAX, 0);
sort(begin(v), end(v));
vector<ll> vl(n + 2), vr(n + 2);
for (int i = 1; i <= n; ++i) {
if (v[i].first - v[i].second > v[i - 1].first) {
vl[i] = vl[i - 1] + 1;
if (v[i].first - v[i].second > v[i - 1].first + v[i - 1].second)
vl[i] = max(vl[i], vr[i - 1] + 1);
else
vl[i] = max(vl[i], vr[i - 1]);
} else
vl[i] = max(vl[i - 1], vr[i - 1]);
if (v[i].first + v[i].second < v[i + 1].first)
vr[i] = max(vl[i - 1], vr[i - 1]) + 1;
else
vr[i] = max(vl[i - 1], vr[i - 1]);
}
cout << max(vl[n], vr[n]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::max;
std::map<int, int> map;
int n, Y, K, X, head[100001], nxt[200001], b[200001], power[100001],
powe[100001], k, mx[100001], size[100001], root, full, stk[100001], top,
inv[100001], v[100001];
long long ans1[100001], ans[100001];
bool vis[100001];
int mul(int a, int b) { return 1ll * a * b % Y; }
int qsm(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = mul(ans, a);
a = mul(a, a);
b >>= 1;
}
return ans;
}
void push(int s, int t) {
nxt[++k] = head[s];
head[s] = k;
b[k] = t;
}
void getroot(int x, int f) {
size[x] = 1, mx[x] = 0;
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f && !vis[b[i]])
getroot(b[i], x), size[x] += size[b[i]], mx[x] = max(mx[x], size[b[i]]);
mx[x] = max(mx[x], full - size[x]);
if (mx[x] < mx[root]) root = x;
}
void getans(int x, int f, int dis, int val) {
ans[x] += map[mul(inv[dis], (X + Y - val) % Y)];
size[x] = 1;
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f && !vis[b[i]])
getans(b[i], x, dis + 1, (mul(val, K) + v[b[i]]) % Y),
size[x] += size[b[i]];
}
void setans(int x, int f, int dis, int val) {
++map[val];
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f && !vis[b[i]])
setans(b[i], x, dis + 1, (val + mul(v[b[i]], powe[dis])) % Y);
}
void getans2(int x, int f, int dis, int val) {
ans1[x] += map[val];
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f && !vis[b[i]])
getans2(b[i], x, dis + 1, (val + mul(v[b[i]], powe[dis])) % Y);
}
void setans2(int x, int f, int dis, int val) {
++map[mul(X + Y - val, inv[dis])];
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f && !vis[b[i]])
setans2(b[i], x, dis + 1, (mul(val, K) + v[b[i]]) % Y);
}
void solve(int rt) {
vis[rt] = 1;
top = 0;
ans[rt] += v[rt] == X;
ans1[rt] += v[rt] == X;
for (int i = head[rt]; i; i = nxt[i])
if (!vis[b[i]]) stk[++top] = b[i];
map.clear();
for (int i = 1; i <= top; i++)
getans(stk[i], rt, 1, v[stk[i]]),
setans(stk[i], rt, 2, (v[rt] + mul(v[stk[i]], K)) % Y);
ans[rt] += map[X];
map.clear();
map[v[rt]] = 1;
for (int i = top; i; --i)
getans(stk[i], rt, 1, v[stk[i]]),
setans(stk[i], rt, 2, (v[rt] + mul(v[stk[i]], K)) % Y);
map.clear();
for (int i = 1; i <= top; i++)
getans2(stk[i], rt, 2, (v[rt] + mul(v[stk[i]], K)) % Y),
setans2(stk[i], rt, 1, v[stk[i]]);
ans1[rt] += map[v[rt]];
map.clear();
map[X] = 1;
for (int i = top; i; --i)
getans2(stk[i], rt, 2, (v[rt] + mul(v[stk[i]], K)) % Y),
setans2(stk[i], rt, 1, v[stk[i]]);
for (int i = head[rt]; i; i = nxt[i])
if (!vis[b[i]]) {
mx[root = 0] = full = size[b[i]];
getroot(b[i], rt);
solve(root);
}
}
int main() {
scanf("%d%d%d%d", &n, &Y, &K, &X);
powe[0] = 1;
for (int i = 1; i <= n; i++) powe[i] = mul(powe[i - 1], K);
inv[0] = 1;
inv[1] = qsm(K, Y - 2);
for (int i = 2; i <= n; i++) inv[i] = mul(inv[i - 1], inv[1]);
for (int i = 1; i <= n; i++) scanf("%d", v + i);
for (int i = 1, s, t; i < n; i++) {
scanf("%d%d", &s, &t);
push(s, t);
push(t, s);
}
mx[root = 0] = full = n;
getroot(1, 0);
solve(root);
long long tot = 0;
for (int i = 1; i <= n; i++) {
tot += 2ll * ans[i] * (n - ans[i]) + 2ll * ans1[i] * (n - ans1[i]) +
ans[i] * (n - ans1[i]) + ans1[i] * (n - ans[i]);
}
printf("%I64d", 1ll * n * n * n - (tot >> 1ll));
}
| 11 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
template <class T>
inline bool read(T &n) {
T x = 0, tmp = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
if (c == EOF) return false;
if (c == '-') c = getchar(), tmp = -1;
while (c >= '0' && c <= '9') x *= 10, x += (c - '0'), c = getchar();
n = x * tmp;
return true;
}
template <class T>
inline void write(T n) {
if (n < 0) {
putchar('-');
n = -n;
}
int len = 0, data[20];
while (n) {
data[len++] = n % 10;
n /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
}
const int MAXN = 100010;
long long inv[MAXN];
int n;
int main() {
read(n);
if (n == 1) {
puts("YES");
puts("1");
return 0;
} else if (n == 4) {
puts("YES");
printf("1\n3\n2\n4\n");
return 0;
}
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
puts("NO");
return 0;
}
}
puts("YES");
puts("1");
inv[1] = 1;
for (int i = 2; i < n; i++) {
inv[i] = (n - n / i) * inv[n % i] % n;
printf("%d\n", i * inv[i - 1] % n);
}
printf("%d\n", n);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long f[20], n;
int dfs(long long x, int w) {
if (!w) return 0;
int y = (x / f[w]) * w;
x %= f[w];
return y + min(dfs(x, w - 1), dfs(f[w] - x, w - 1) + w);
}
int main() {
cin >> n;
for (int i = 1; i <= 16; i++) {
f[i] = f[i - 1] * 10 + 1;
}
cout << dfs(n, 16);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int INF = 1e9;
struct node {
int mnx = INF, mxx = -INF, mny = INF, mxy = -INF, low = INF, top = -INF;
node() {}
node(pair<int, int> a)
: mnx(a.first),
mxx(a.first),
mny(a.second),
mxy(a.second),
low(a.second - a.first),
top(a.second - a.first) {}
node(int mnx, int mxx, int mny, int mxy, int low, int top)
: mnx(mnx), mxx(mxx), mny(mny), mxy(mxy), low(low), top(top) {}
};
node oper(node a, node b) {
node ans;
ans.mnx = min(a.mnx, b.mnx);
ans.mny = min(a.mny, b.mny);
ans.mxx = max(a.mxx, b.mxx);
ans.mxy = max(a.mxy, b.mxy);
ans.low = min(a.low, b.low);
ans.top = max(a.top, b.top);
return ans;
}
struct STree {
vector<node> t;
int n;
STree() {}
STree(int n) : n(n), t(2 * n + 5) {}
void upd(int p, node v) {
p += n;
for (t[p] = v; p > 1; p >>= 1) t[p >> 1] = oper(t[p], t[p ^ 1]);
}
node query(int l, int r) {
node res = node();
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = oper(res, t[l++]);
if (r & 1) res = oper(res, t[--r]);
}
return res;
}
};
STree st1, st2;
vector<pair<int, int> > v;
int n, top;
pair<int, int> lx = {1e9, -1e9}, ly = {1e9, -1e9};
pair<int, int> op(pair<int, int> a, int v) {
return {min(a.first, v), max(a.second, v)};
}
void fix(int id, multiset<int> &v1, STree &st) {
if (!int(v1.size()))
st.upd(id, node());
else {
int mn = *v1.begin(), mx = *v1.rbegin();
st.upd(id, node(mn, mx, id, id, id - mx, id - mn));
}
}
const int MAXN = 3e5 + 10;
multiset<int> l1[MAXN], r1[MAXN];
int f(int x, int y) {
node c1 = st1.query(0, y);
node c2 = st1.query(y, top);
node c3 = st2.query(y, top);
node c4 = st2.query(0, y);
int ans = 0;
if (c1.mnx != INF) {
int me = max(x - c1.mnx, y - c1.mny);
ans = max(ans, me);
}
if (c3.mnx != INF) {
int me = max(c3.mxx - x, c3.mxy - y);
ans = max(ans, me);
}
if (c2.mnx != INF) {
int me = c2.top - (y - x);
ans = max(ans, me);
}
if (c4.mnx != INF) {
int me = (y - x) - c4.low;
ans = max(ans, me);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
string s;
cin >> s;
int x = 0, y = 0;
for (auto c : s) x += c == 'B', y += c == 'N';
v.push_back({x, y});
lx = op(lx, x);
ly = op(ly, y);
r1[y].insert(x);
}
sort(v.begin(), v.end());
top = ly.second + 1;
st1 = STree(top);
st2 = STree(top);
for (int i = 0, ThxDem = top; i < ThxDem; ++i) fix(i, r1[i], st2);
pair<int, pair<int, int> > ans = {1e9, {-1, -1}};
int id = 0;
for (int x = lx.first, ThxDem = lx.second + 1; x < ThxDem; ++x) {
while (id < n && v[id].first <= x) {
int x = v[id].first, y = v[id].second;
r1[y].erase(r1[y].find(x));
l1[y].insert(x);
fix(y, l1[y], st1);
fix(y, r1[y], st2);
id++;
}
int l = ly.first - 1, r = ly.second + 1;
if (l == -1 && x == 0) l = 0;
while (r - l > 1) {
int m = (l + r) / 2;
if (f(x, m) > f(x, m + 1))
l = m;
else
r = m;
}
int bst = l + 1;
ans = min(ans, {f(x, bst), {x, bst}});
}
cout << ans.first << "\n";
cout << string(ans.second.first, 'B') + string(ans.second.second, 'N')
<< "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int q, x, a, i;
int main() {
cin >> q;
while (q--) {
cin >> x;
if (x < 4 || x == 5 || x == 7 || x == 11)
cout << -1 << endl;
else
cout << x / 4 - x % 2 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
int a[MAX], run[MAX], ans[MAX];
char s[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; ++i) {
if (s[i] == '0')
a[i] = 0;
else if (s[i] == '1')
a[i] = 1;
else
a[i] = -1;
}
vector<pair<int, int>> blocks;
int it1 = 0, it2 = 0;
while (it1 != n) {
while (it2 < n - 1 && a[it1] == a[it2 + 1]) ++it2;
blocks.emplace_back(it2 - it1 + 1, a[it1]);
++it2;
it1 = it2;
}
for (int i = 0; i < (int)blocks.size(); ++i) {
if (blocks[i].second != -1) continue;
if (i == 0)
blocks[i].second = blocks[i + 1].second;
else if (i == (int)blocks.size() - 1)
blocks[i].second = blocks[i - 1].second;
else if (blocks[i - 1].second == blocks[i + 1].second)
blocks[i].second = blocks[i - 1].second;
}
vector<pair<int, int>> compress;
it1 = 0;
it2 = 0;
while (it1 != (int)blocks.size()) {
int len = blocks[it1].first;
while (it2 < (int)blocks.size() - 1 &&
blocks[it1].second == blocks[it2 + 1].second)
it2++, len += blocks[it2].first;
compress.emplace_back(len, blocks[it1].second);
++it2;
it1 = it2;
}
for (auto block : compress) {
if (block.second == -1) continue;
for (int len = 1; len <= block.first; len++) ans[len] += block.first / len;
}
int max_size = -1, bef = -2;
int size = compress.size();
for (int i = 0; i < size; i++) {
int len = compress[i].first;
int type = compress[i].second;
if (bef != -1 && type != -1) {
max_size = len;
if (i != size - 1) max_size += compress[i + 1].first;
for (int l = 1; l <= max_size; l++) run[l] = len % l;
} else if (type == -1) {
for (int l = 1; l <= max_size; l++) {
if (run[l] + len >= l)
run[l] += len, ans[l] += run[l] / l, run[l] %= l;
else
run[l] = len;
}
int add = 0;
if (i != (int)size - 1) add += compress[i + 1].first;
if (i != (int)size - 2) add += compress[i + 2].first;
for (int l = max_size + 1; l <= len + add; ++l) run[l] = (len % l);
max_size = len + add;
} else {
for (int l = 1; l <= max_size; ++l) {
if (run[l] + (len % l) >= l)
run[l] += ((len % l) - l), ans[l]++;
else
run[l] += (len % l);
}
}
bef = type;
}
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int qa, qb, an = 0;
cin >> qa >> qb;
int n = qa + qb, sq = ceil(sqrt(n));
vector<int> bl;
for (int a = 1; n / a > sq; a++) {
if (bl.size() == 0 or bl.back() != n / a) bl.push_back(n / a);
}
for (int a = sq; a; a--) bl.push_back(a);
for (int a = 0; a < bl.size(); a++) {
int bq = bl[a];
if (qa / bq >= qa % bq and qb / bq >= qb % bq) {
int ra = qa / bq, la = qa / (bq + 1) + 1, rb = qb / bq,
lb = qb / (bq + 1) + 1;
if (qa % (bq + 1) == 0) la--;
if (qb % (bq + 1) == 0) lb--;
if (qa / ra and rb) {
int r = ra + rb, l = la + lb;
if (qa % (bq + 1) == 0 and qb % (bq + 1) == 0) l++;
an += (r - l + 1);
}
}
}
cout << an;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const long long MOD = 1e9 + 7;
using namespace std;
long long n_bits(long long n) {
long long x = __builtin_popcount(n);
return x;
}
char get(char x, char y) {
if ((x == 'S' and y == 'E') or (x == 'E' and y == 'S')) return 'T';
if ((x == 'S' and y == 'T') or (x == 'T' and y == 'S')) return 'E';
return 'S';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
map<string, long long> m;
long long n, k, count = 0;
cin >> n >> k;
string v[n];
for (int i = 0; i < (n); ++i) {
cin >> v[i];
}
for (int i = 0; i < (n); ++i) {
for (int j = i + 1; j < (n); ++j) {
string s = "";
for (int l = 0; l < (k); ++l) {
if (v[i][l] == v[j][l]) {
s += v[i][l];
} else {
s += get(v[i][l], v[j][l]);
}
}
count += m[s];
}
m[v[i]]++;
}
cout << count << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
const int mod = 1e9 + 7;
inline int read() {
char c = getchar();
int t = 0, f = 1;
while (!isdigit(c)) f = (c == '-') ? -1 : 1, c = getchar();
while (isdigit(c)) t = t * 10 + c - 48, c = getchar();
return t * f;
}
int cnt[N], cnt1[N], n;
void can(int len) {
int c = 0, d = n / len;
for (int i = 0; i < 256; i++) {
cnt1[i] = 0;
if (cnt[i] & 1) {
c++;
}
}
if (len & 1) {
if (c > d) return;
} else {
if (c != 0) return;
}
if (len == 1) {
cout << n << "\n";
for (int i = 0; i < 256; i++) {
for (int j = 0; j < cnt[i]; j++) {
putchar((char)i);
putchar(' ');
}
}
exit(0);
}
vector<string> v;
vector<char> b;
string r = "";
bool ok = 0;
for (int i = 0; i < 256; i++) {
for (int j = 0; j < cnt[i] / 2; j++) {
r += i;
cnt1[i] += 2;
if ((int)r.size() == len / 2) {
v.push_back(r);
r = "";
}
if ((int)v.size() == d) {
ok = 1;
break;
}
}
if (ok) break;
}
cout << d << "\n";
if (len & 1) {
for (int i = 255; i >= 0; i--) {
for (int j = 1; j <= cnt[i] - cnt1[i]; j++) {
b.push_back(char(i));
}
}
}
for (int i = 0; i < d; i++) {
if (len != 1) {
for (char f : v[i]) putchar(f);
}
if (len & 1) putchar(b[i]);
if (len != 1) {
for (int f = (int)v[i].size() - 1; f >= 0; f--) putchar(v[i][f]);
}
putchar(' ');
}
exit(0);
}
void solve() {
n = read();
for (int i = 1; i <= n; i++) cnt[getchar()]++;
for (int i = n; i >= 1; i--) {
if (n % i == 0) can(i);
}
}
int main() {
srand(time(0));
int t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
unsigned long long tt[6] = {4, 5, 6, 3, 2, 1};
void read() { cin >> s; }
void solve() {
unsigned long long ans = tt[s[s.size() - 1] - 'a'];
s.erase(s.end() - 1);
unsigned long long num = 0, pw = 1;
for (int i = s.size(); i >= 1; i--) {
num = num + (unsigned long long)(s[i - 1] - '0') * pw;
if (i > 1) pw *= 10;
}
unsigned long long timeServed = (num - 1) % 4 <= 1 ? num - 1 : num - 3;
unsigned long long passengers =
(num - 1) % 4 <= 1 ? (num - 1) / 2 * 6 : (num - 3) / 2 * 6;
if (((num - 1) % 4) % 2 == 1) passengers += (unsigned long long)6;
cout << ans + timeServed + passengers << endl;
}
int main() {
read();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--){
string s;
cin >> s;
stack<char> a, b;
int ans = 0;
for (auto c: s){
if (c == '(' || c == ')'){
if (c == '(')
a.push(c);
else {
if (!a.empty()){
ans++;
a.pop();
}
}
}
if (c == '[' || c == ']'){
if (c == '[')
b.push(c);
else {
if (!b.empty()){
ans++;
b.pop();
}
}
}
}
cout << ans << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
void itval(istream_iterator<string> it) {}
template <typename T, typename... Args>
void itval(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
itval(++it, args...);
}
const long long int MOD = 998244353;
template <typename T>
inline void print(T x) {
cout << x << "\n";
}
template <typename T>
inline void printvec(T x) {
for (auto a : x) cout << a << ' ';
cout << '\n';
}
struct custom {
bool operator()(
const pair<pair<long long int, long long int>, long long int> &p1,
const pair<pair<long long int, long long int>, long long int> &p2) const {
if (p1.second == p2.second) {
return p1.first.second < p2.first.second;
}
return p1.second < p2.second;
}
};
long long int get_pow(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
const long long int N = 1e5 + 5, inf = 4e18;
void solve() {
long long int n, q;
cin >> n >> q;
long long int d = 0, t = 0, st = 0, po = 0, pd = 1;
long long int x, p;
for (long long int i = (long long int)0; i < (long long int)(q); i++) {
cin >> p;
if (p == 2) {
d++;
if (po % 2 == 0) {
po = (po + 1) % n;
pd = (pd - 1 + n) % n;
} else {
pd = (pd + 1) % n;
po = (po - 1 + n) % n;
}
} else {
cin >> x;
po = (po + x + n) % n;
pd = (pd + x + n) % n;
}
}
vector<long long> ans(n, 0);
st = 1;
while (st <= n - 1) {
ans[po] = st;
po += 2;
po %= n;
st += 2;
}
st = 2;
while (st <= n) {
ans[pd] = st;
pd += 2;
pd %= n;
st += 2;
}
printvec(ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
clock_t z = clock();
for (long long int tes = (long long int)0; tes < (long long int)(test);
tes++) {
solve();
}
fprintf(stderr, "Total Time:%.4f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int t;
cin >> t;
while (t--) {
long long int a, b, x, y, count = 0, res;
cin >> a >> b;
x = a;
y = b;
while (x % 2 == 0) x = x / 2;
while (y % 2 == 0) y = y / 2;
if (x != y) {
cout << "-1"
<< "\n";
continue;
}
res = max(a, b) / min(a, b);
while (res >= 8) {
res = res / 8;
count++;
}
if (res > 1) count++;
cout << count << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1 << 20;
char s[SIZE];
bool solve() {
int N, K;
R(N, K);
R(s);
int cnt[2] = {};
for (int i = 0; i < (K); ++i) {
char c = '?';
for (int j = i; j < N; j += K) {
if (s[j] != '?') {
c = s[j];
break;
}
}
if (c != '?') {
for (int j = i; j < N; j += K) {
if (s[j] != '?' && s[j] != c) {
return false;
}
}
cnt[c - '0']++;
}
}
return cnt[0] <= K / 2 && cnt[1] <= K / 2;
}
int main() {
int ___T;
scanf("%d", &___T);
for (int cs = 1; cs <= ___T; cs++) {
puts(solve() ? "YES" : "NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::min;
using std::string;
using std::vector;
long long next(long long x) {
if (x == 0) return 0;
if (x % 10 <= 4) {
long long a = next(x / 10);
return a * 10 + 4;
}
if (x % 10 <= 7) {
long long a = next(x / 10);
if (a > x / 10)
return a * 10 + 4;
else
return a * 10 + 7;
}
return next((x + 10 - (x % 10)) / 10) * 10 + 4;
}
struct pair {
int x, y;
};
int main() {
int n, k;
cin >> n >> k;
long long x = 1;
int i = 1;
vector<int> fac;
fac.push_back(1);
while (x < k) {
++i;
x *= i;
fac.push_back(x);
}
if (i > n) {
cout << -1 << endl;
return 0;
}
int out = 0;
long long l = 4;
while (l <= n - i) {
++out;
l = next(l + 1);
}
vector<pair> data(i);
for (int j = 0; j < i; ++j) {
data[j].x = j + n - i + 1;
if (i == j + 1)
data[j].y = 1 + data[j].x;
else {
int q = k / fac[i - j - 2];
++q;
if (k % fac[i - j - 2] == 0) --q;
k = k - (q - 1) * fac[i - j - 2];
data[j].y = q + data[j].x;
}
}
vector<bool> use(i, false);
for (int j = 0; j < i; ++j) {
int num = data[j].y - data[j].x;
int qq = 0;
while ((num > 1) || (use[qq])) {
if (!use[qq]) --num;
++qq;
}
data[j].y = data[0].x + qq;
use[qq] = true;
if ((data[j].x == next(data[j].x)) && (data[j].y == next(data[j].y))) ++out;
}
cout << out << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 505050;
vector<int> adj[MAXV];
int n, m, q, t, lp, c[MAXV], tc[MAXV], d[MAXV];
void dfs(int v, int color, int path) {
c[v] = color;
bool hasNext = false;
for (int i = 0; i < (int)adj[v].size(); i++)
if (c[adj[v][i]] == 0) {
hasNext = true;
dfs(adj[v][i], color, path + 1);
}
if (!hasNext) {
if (path > lp) {
lp = path;
t = v;
}
}
}
void dfs2(int v, int path) {
tc[v] = 1;
bool hasNext = false;
for (int i = 0; i < (int)adj[v].size(); i++)
if (tc[adj[v][i]] == 0) {
hasNext = true;
dfs2(adj[v][i], path + 1);
}
if (!hasNext) {
if (path > lp) {
lp = path;
t = v;
}
}
}
int findFa(int x) {
if (c[x] == x) return x;
c[x] = findFa(c[x]);
return c[x];
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) adj[i].clear();
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);
}
memset(d, 0, sizeof(d));
memset(c, 0, sizeof(c));
memset(tc, 0, sizeof(tc));
for (int i = 1; i <= n; i++)
if (c[i] == 0) {
t = i;
lp = 0;
dfs(i, i, 0);
lp = 0;
dfs2(t, 0);
d[i] = lp;
}
int mark, x, y, u, v, nd, tnd;
for (int i = 0; i < q; i++) {
scanf("%d", &mark);
if (mark == 1) {
scanf("%d", &x);
printf("%d\n", d[findFa(x)]);
} else {
scanf("%d%d", &x, &y);
u = findFa(x);
v = findFa(y);
if (u == v) continue;
nd = max(d[u], d[v]);
tnd = (d[u] + 1) / 2 + (d[v] + 1) / 2 + 1;
nd = max(tnd, nd);
c[u] = v;
d[v] = nd;
}
}
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.