solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
long long int csb(long long int x) {
if (x <= 0) return 0;
return (x % 2 == 0 ? 0 : 1) + csb(x / 2);
}
long long int tb(long long int n) {
long long int count = 0;
while (n) {
count++;
n >>= 1;
}
return count;
}
bool ip2(long long int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
{
long long int n, c = 0, f = 0, m = -1, e = -(long long int)1e9, o = 0,
p = 0, x = 0, y = 0, ans = 0, q = (long long int)1e9,
x1 = 0, y1, y3, x2, y2, k;
cin >> n >> m >> k;
for (long long int i = 0; i < k; i++) {
cin >> x >> y;
}
long long int a[k][2];
string s;
for (long long int i = 0; i < n - 1; i++) {
s.push_back('U');
}
for (long long int i = 0; i < m - 1; i++) {
s.push_back('L');
}
x = 1;
y = 1;
multiset<pair<long long int, long long int>> m1;
for (long long int i = 0; i < k; i++) {
cin >> p >> q;
m1.insert({p, q});
}
for (long long int i = 0; i < n; i++) {
if (f == 0) {
for (long long int j = 0; j < m - 1; j++) {
s.push_back('R');
}
f = 1;
} else {
for (long long int j = 0; j < m - 1; j++) {
s.push_back('L');
}
f = 0;
}
if (i == n - 1) break;
s.push_back('D');
}
cout << s.size() << "\n" << s << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int k, du[505], hav[505][505], A[505 * 505], B[505 * 505];
int main() {
int n, i, j, num = 0;
scanf("%d", &k);
if (k % 2 == 0) {
puts("NO");
return 0;
}
if (k == 1) {
puts("YES\n2 1\n1 2");
return 0;
}
n = k + 2;
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++) hav[i][j] = 1;
for (i = 1; i * 2 + 2 < n; i++) hav[2 * i - 1][2 * i] = 0;
hav[0][n - 1] = 0;
hav[0][n - 2] = 0;
hav[0][n] = 1;
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++) hav[i + n][j + n] = 1;
for (i = 1; i * 2 + 2 < n; i++) hav[2 * i - 1 + n][2 * i + n] = 0;
hav[n][n + n - 1] = 0;
hav[n][n + n - 2] = 0;
for (i = 0; i < 2 * n; i++)
for (j = i + 1; j < 2 * n; j++)
if (hav[i][j]) {
A[++num] = i;
B[num] = j;
}
puts("YES");
printf("%d %d\n", 2 * n, num);
for (i = 1; i <= num; i++) printf("%d %d\n", A[i] + 1, B[i] + 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
set<int> c;
int main() {
string s;
cin >> s;
int sz = s.size();
for (int i = s.size() - 1; i > 0; --i) {
if (s[i] == '0') {
sz--;
} else
break;
}
int k = sz - 1;
for (int i = 0; i < (sz + 1) / 2; ++i) {
if (s[i] == s[k]) {
c.insert(1);
} else
c.insert(0);
--k;
}
set<int>::iterator i = c.begin();
if (c.size() == 1 && (*i) == 1) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, d;
cin >> k >> d;
string ans;
ans += 48 + d;
if (d > 0) {
while (k >= 2) {
ans += '0';
k--;
}
cout << ans;
} else if (d == 0 && k == 1) {
cout << 0;
} else
cout << "No solution";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, arr[71][71], dp[71][71][71][36];
int mulMod(long long, long long);
int addMod(int, int);
void readArray(int *, int);
void printArray(int *, int);
int solve(int i, int j, int mod, int left) {
if (i == n - 1 && (!left || j == m)) return (mod == 0 ? 0 : -1e8);
if (j == m || !left) return dp[i][j][mod][left] = solve(i + 1, 0, mod, m / 2);
if (dp[i][j][mod][left] != -1) return dp[i][j][mod][left];
int ans = -1e8, MOD = arr[i][j] % k;
if (MOD < mod)
ans = max(ans, arr[i][j] + solve(i, j + 1, mod - MOD, left - 1));
else if (MOD > mod)
ans = max(ans, arr[i][j] + solve(i, j + 1, k - (MOD - mod), left - 1));
else
ans = max(ans, arr[i][j] + solve(i, j + 1, 0, left - 1));
ans = max(ans, solve(i, j + 1, mod, left));
return dp[i][j][mod][left] = ans;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
memset(dp, -1, sizeof(dp));
cout << max(0, solve(0, 0, 0, m / 2)) << endl;
return 0;
}
int mulMod(long long a, long long b) {
a *= b;
a %= 1000000007;
return (int)a;
}
int addMod(int a, int b) {
long long c = a + b;
if (c >= 1000000007) {
c -= 1000000007;
}
return (int)c;
}
void readArray(int *nums, int n) {
for (int i = 0; i < n; i++) cin >> nums[i];
}
void printArray(int *nums, int n) {
for (int i = 0; i < n; i++) cout << nums[i] << " ";
cout << endl;
}
| 13 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
template <typename A, typename B>
A min(A x, B y) {
if (x < y) return x;
return y;
}
template <typename A, typename B>
A max(A x, B y) {
if (x > y) return x;
return y;
}
template <typename D>
istream &operator>>(istream &in, vector<D> &arr) {
for (auto &(x) : (arr)) cin >> x;
return in;
}
template <typename D>
ostream &operator<<(ostream &in, vector<D> &arr) {
for (auto &x : arr) in << x << " ";
return in;
}
template <typename D, typename B>
ostream &operator<<(ostream &in, pair<D, B> &p) {
in << p.first << " " << p.second << " ";
return in;
}
template <typename D, typename B>
istream &operator>>(istream &in, pair<D, B> &p) {
in >> p.first >> p.second;
return in;
}
int modpow(long long, long long, int);
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long 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 << "]";
}
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 << "]";
}
void solve(int tc) {
int n;
cin >> n;
if (n % 2 == 0) {
cout << (n + 1) / 2 << " " << (n - 1) / 2 << " " << 1 << " "
<< "\n";
return;
}
n /= 2;
if (n % 2 == 0) {
cout << n - 1 << " " << n + 1 << " " << 1 << " "
<< "\n";
} else {
cout << n - 2 << " " << n + 2 << " " << 1 << " "
<< "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int k = 1, t = 1;
cin >> t;
while (t--) solve(k++);
return 0;
}
int modpow(long long a, long long b, int m = 1000000007) {
long long res = 1;
a %= m;
if (a == 0) return a;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a *= a;
a %= m;
b >>= 1;
}
return res;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)3e5 + 5;
const int inf = (int)1e9 + 7;
int n;
int a[N], sgn[N], now[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
sgn[i] = 1;
if (a[i] < 0) {
a[i] *= -1;
sgn[i] = -1;
}
}
int sum = 0;
for (int i = 1; i <= n; ++i) {
now[i] = (a[i] / 2) * sgn[i];
sum += now[i];
}
for (int i = 1; i <= n; ++i) {
if ((sum > 0 && sgn[i] == -1) || (sum < 0 && sgn[i] == 1)) {
sum -= now[i];
now[i] = ((a[i] + 1) / 2) * sgn[i];
sum += now[i];
}
}
assert(sum == 0);
for (int i = 1; i <= n; ++i) {
printf("%d\n", now[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long mod = 1e9 + 7;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T, A, B;
cin >> T;
for (int i = 0; i < T; ++i) {
cin >> A >> B;
cout << A + B << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int n, m, x, y, a, b;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
scanf("%d%d%d%d%d%d", &n, &m, &x, &y, &a, &b);
int c = gcd(a, b);
a /= c, b /= c;
int mr = n / a, mc = m / b;
if (mr > mc)
a *= mc, b *= mc;
else
a *= mr, b *= mr;
int midr = (a + 1) >> 1, midc = (b + 1) >> 1;
int lx = x - midr, ly = y - midc;
int ux = a + lx, uy = b + ly;
if (lx < 0) ux -= lx, lx = 0;
if (ly < 0) uy -= ly, ly = 0;
if (ux > n) lx -= ux - n, ux = n;
if (uy > m) ly -= uy - m, uy = m;
printf("%d %d %d %d\n", lx, ly, ux, uy);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1000 + 10;
int n, m, c[maxN][maxN];
long long k1, k2, k3, k4, k5;
int main() {
cin >> n >> m;
for (int I = 0; I < (n); I++)
for (int K = 0; K < (m); K++) scanf("%d", &c[I][K]);
for (int I = 0; I < (n); I++)
for (int K = 0; K < (m); K++) {
long long x = I * 4 + 2, y = K * 4 + 2;
k1 += c[I][K];
k2 += c[I][K];
k3 += 2 * x * c[I][K];
k4 += 2 * y * c[I][K];
k5 += c[I][K] * (x * x + y * y);
}
long long answer = 1ll << 60, xpos, ypos;
for (int I = 0; I < (n + 1); I++)
for (int K = 0; K < (m + 1); K++) {
long long x = I * 4, y = K * 4;
long long now = k1 * x * x + k2 * y * y - k3 * x - k4 * y + k5;
if (now < answer) {
answer = now;
xpos = I;
ypos = K;
}
}
cout << answer << endl;
cout << xpos << " " << ypos << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
static int N, M, K, D, T, dist[200003];
static vector<pair<int, int>> edge[200003], pre[200003];
static char output[200003];
static vector<string> answer;
inline void bfs(int S) {
queue<int> Q;
Q.push(S);
dist[S] = 1;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
D = max(D, dist[u]);
for (auto v : edge[u])
if (!dist[v.first]) {
dist[v.first] = dist[u] + 1;
Q.push(v.first);
}
}
}
inline void print_answer(void) {
printf("%d\n", T);
for (string s : answer) puts(s.c_str());
exit(0);
}
void dfs(int u) {
if (u == N + 1) {
answer.push_back(output);
if ((++T) == K) print_answer();
}
for (auto v : pre[u]) {
output[v.second] = '1';
dfs(u + 1);
output[v.second] = '0';
}
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 0, u, v; i < M; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(make_pair(v, i));
edge[v].push_back(make_pair(u, i));
output[i] = '0';
}
bfs(1);
for (int i = 2; i <= N; i++)
for (auto v : edge[i])
if (dist[v.first] + 1 == dist[i]) pre[i].push_back(v);
dfs(2);
print_answer();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
bool flag[3003] = {false};
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int temp;
cin >> temp;
flag[temp] = true;
}
for (int i = 1; i <= n + 1; ++i) {
if (!flag[i]) {
cout << i << "\n";
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int m, sum = 0;
scanf("%d", &m);
char arr[m][m];
for (int i = 0; i < m; i++) {
scanf("%s", arr[i]);
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == 'C') {
for (int k = j + 1; k < m; k++) {
if (arr[i][k] == 'C') {
sum++;
continue;
}
}
}
}
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == 'C') {
for (int k = i + 1; k < m; k++) {
if (arr[k][j] == 'C') {
sum++;
continue;
}
}
}
}
}
printf("%d", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int x, y;
int a[maxn];
int b[maxn];
int mp[maxn][maxn];
const int mv[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1},
{0, 1}, {1, -1}, {1, 0}, {1, 1}};
void move(int tx, int ty) {
int vx = tx == x ? 0 : (tx - x) / abs(tx - x);
int vy = ty == y ? 0 : (ty - y) / abs(ty - y);
if (vx == 0 && vy == 0) {
vx = 1, vy = 1;
}
if (vx + x < 1) vx = -vx;
if (vx + x > 999) vx = -vx;
if (vy + y < 1) vy = -vy;
if (vy + y > 999) vy = -vy;
if (mp[vx + x][vy + y]) {
for (int i = 0; i < 8; i++) {
int sx = mv[i][0];
int sy = mv[i][1];
if (mp[x + sx][y + sy] == 0) {
cout << x + sx << " " << y + sy << endl;
x += sx;
y += sy;
break;
}
}
} else {
cout << vx + x << " " << vy + y << endl;
x += vx;
y += vy;
}
}
bool judgemin(int a, int b, int c, int d) {
if (a <= b && a <= c && a <= d) {
return true;
}
return false;
}
void judge(int &tx, int &ty) {
int l1 = 0, l2 = 0, l3 = 0, l4 = 0;
for (int i = 1; i <= 999; i++) {
for (int j = 1; j <= 999; j++) {
if (mp[i][j]) {
if (i <= 500) {
if (j <= 500) ++l1;
if (j >= 500) {
++l2;
}
}
if (i >= 500) {
if (j <= 500) {
++l3;
}
if (j >= 500) {
++l4;
}
}
}
}
}
if (judgemin(l1, l2, l3, l4)) {
tx = 999, ty = 999;
} else if (judgemin(l2, l1, l3, l4)) {
tx = 999, ty = 1;
} else if (judgemin(l3, l1, l2, l4)) {
tx = 1, ty = 999;
} else {
tx = 1, ty = 1;
}
}
void solve() {
int k, xx, yy, tx = 500, ty = 500;
bool flag = false;
if (x == 500 && y == 500)
move(1, 1);
else
move(500, 500);
while (cin >> k >> xx >> yy) {
if (k == -1 && xx == -1 && yy == -1) {
break;
}
if (k == 0 && xx == 0 && yy == 0) {
break;
}
mp[a[k]][b[k]] = 0;
a[k] = xx, b[k] = yy;
mp[a[k]][b[k]] = 1;
if (x == 500 && y == 500) {
flag = true;
judge(tx, ty);
}
if (!flag) {
move(500, 500);
if (x == 500 && y == 500) {
flag = true;
judge(tx, ty);
}
} else {
move(tx, ty);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
memset(mp, 0, sizeof(mp));
cin >> x >> y;
for (int i = 1; i <= 666; i++) {
cin >> a[i] >> b[i];
mp[a[i]][b[i]] = 1;
}
solve();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ch = 0, nech = 0;
while (n--) {
long long a;
cin >> a;
a % 2 == 0 ? ch++ : nech++;
}
nech > ch ? cout << ch : cout << nech;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, j, ones, zeros, n;
cin >> t;
for (i = 0; i < t; i++) {
ones = 0;
zeros = 0;
cin >> n;
vector<int> high;
vector<int> low;
map<int, int> connect;
int p[n];
int q[n];
string s;
for (j = 0; j < n; j++) {
cin >> p[j];
}
cin >> s;
for (j = 0; j < n; j++) {
if (s[j] == '1') {
ones++;
high.push_back(p[j]);
} else {
zeros++;
low.push_back(p[j]);
}
}
sort(high.begin(), high.end());
sort(low.begin(), low.end());
for (j = zeros + 1; j <= n; j++) {
connect[high[j - zeros - 1]] = j;
}
for (j = 1; j <= zeros; j++) {
connect[low[j - 1]] = j;
}
for (j = 0; j < n; j++) {
q[j] = connect[p[j]];
}
for (j = 0; j < n; j++) {
cout << q[j] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
long double sol = 0;
for (int i = 1; i <= m; ++i) {
sol += i * powl(1.L * i / m, n);
sol -= i * powl(1.L * (i - 1) / m, n);
}
cout << sol << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vpi = vector<pii>;
using vpl = vector<pll>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> m;
vll vm(m);
for (auto &i : vm) cin >> i;
cin >> n;
vll vn(n);
for (auto &i : vn) cin >> i;
sort((vn).rbegin(), (vn).rend());
ll x = *min_element((vm).begin(), (vm).end());
ll ans = 0;
for (int i = 0, j = 1; i < n; i++, j++) {
if (j <= x)
ans += vn[i];
else {
j = 0;
i++;
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
char s1[maxn], s2[maxn];
int L[maxn], R[maxn], Last[maxn];
int main() {
scanf("%s%s", s1 + 1, s2 + 1);
int len1 = strlen(s1 + 1);
int len2 = strlen(s2 + 1);
memset(L, -1, sizeof(L));
memset(R, -1, sizeof(R));
memset(Last, -1, sizeof(Last));
int idx = 1;
for (int i = 1; i <= len1; i++) {
if (idx <= len1 && s1[i] == s2[idx]) Last[s1[i] - 'a'] = idx++;
L[i] = Last[s1[i] - 'a'];
}
memset(Last, -1, sizeof(Last));
idx = len2;
for (int i = len1; i >= 1; i--) {
if (idx > 0 && s1[i] == s2[idx]) Last[s1[i] - 'a'] = idx--;
R[i] = Last[s1[i] - 'a'];
}
bool ok = true;
for (int i = 1; i <= len1; i++) {
if (L[i] == -1 || R[i] == -1 || L[i] < R[i]) ok = false;
}
if (ok)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#define endl '\n'
using namespace std;
int l, r;
void read()
{
cin >> l >> r;
}
struct edge
{
int a, b, c;
edge() {}
edge(int _a, int _b, int _c)
{
a = _a;
b = _b;
c = _c;
}
};
vector <edge> edges;
void solve()
{
cout << "YES" << endl;
if (l == r)
{
cout << 2 << " " << 1 << endl;
cout << 1 << " " << 2 << " " << l << endl;
return;
}
int r1 = r - l + 1;
int idx = 2;
while ((1 << (idx - 2)) <= r1)
{
edges.push_back(edge(1, idx, 1));
for (int i = 2; i < idx; i++)
edges.push_back(edge(i, idx, 1 << (i-2)));
idx++;
}
idx--;
int curr_r = (1 << (idx - 2));
if (curr_r == r1)
{
if (l != 1)
{
edges.push_back(edge(idx, idx + 1, l-1));
cout << idx + 1 << " " << (int)edges.size() << endl;
for (auto i: edges)
cout << i.a << " " << i.b << " " << i.c << endl;
}
else
{
cout << idx << " " << (int)edges.size() << endl;
for (auto i: edges)
cout << i.a << " " << i.b << " " << i.c << endl;
}
return;
}
edges.push_back(edge(idx, idx + 1, 1));
edges.push_back(edge(1, idx + 1, 1));
curr_r++;
while (curr_r < r1)
{
int deg = 0;
while (curr_r + (1 << deg) <= r1)
deg++;
deg--;
edges.push_back(edge(deg + 2, idx + 1, curr_r));
curr_r += (1 << deg);
}
if (l == 1)
{
cout << idx + 1 << " " << (int)edges.size() << endl;
for (auto i: edges)
cout << i.a << " " << i.b << " " << i.c << endl;
return;
}
edges.push_back(edge(idx+1, idx+2, l-1));
cout << idx + 2 << " " << (int)edges.size() << endl;
for (auto i: edges)
cout << i.a << " " << i.b << " " << i.c << endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
read();
solve();
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int BUFFER_SIZE = 1 << 15;
char input_buffer[BUFFER_SIZE];
int input_pos = 0, input_len = 0;
char output_buffer[BUFFER_SIZE];
int output_pos = 0;
char number_buffer[100];
uint8_t lookup[100];
void _update_input_buffer() {
input_len = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
input_pos = 0;
if (input_len == 0) input_buffer[0] = EOF;
}
inline char next_char(bool advance = true) {
if (input_pos >= input_len) _update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
template <typename T>
inline void read_int(T &number) {
bool negative = false;
number = 0;
while (!isdigit(next_char(false)))
if (next_char() == '-') negative = true;
do {
number = 10 * number + (next_char() - '0');
} while (isdigit(next_char(false)));
if (negative) number = -number;
}
template <typename T, typename... Args>
inline void read_int(T &number, Args &...args) {
read_int(number);
read_int(args...);
}
void _flush_output() {
fwrite(output_buffer, sizeof(char), output_pos, stdout);
output_pos = 0;
}
inline void write_char(char c) {
if (output_pos == BUFFER_SIZE) _flush_output();
output_buffer[output_pos++] = c;
}
template <typename T>
inline void write_int(T number, char after = '\0') {
if (number < 0) {
write_char('-');
number = -number;
}
int length = 0;
while (number >= 10) {
uint8_t lookup_value = lookup[number % 100];
number /= 100;
number_buffer[length++] = (lookup_value & 15) + '0';
number_buffer[length++] = (lookup_value >> 4) + '0';
}
if (number != 0 || length == 0) write_char(number + '0');
for (int i = length - 1; i >= 0; i--) write_char(number_buffer[i]);
if (after) write_char(after);
}
void init() {
bool exit_success = atexit(_flush_output) == 0;
assert(exit_success);
for (int i = 0; i < 100; i++) lookup[i] = (i / 10 << 4) + i % 10;
}
} // namespace IO
const int sz = 18;
int f[1 << sz];
struct union_find {
vector<int> p;
union_find(int n) : p(n, -1) {}
int join(int u, int v) {
if ((u = root(u)) == (v = root(v))) return 0;
if (p[u] > p[v]) swap(u, v);
int r = (size(u) == 1 ? f[u] : 1) + (size(v) == 1 ? f[v] : 1) - 1;
p[u] += p[v];
p[v] = u;
return r;
}
int root(int u) { return p[u] < 0 ? u : p[u] = root(p[u]); }
int size(int u) { return -p[root(u)]; }
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
IO::init();
int n;
IO::read_int(n);
long long ans = 0;
for (int x; n--;) IO::read_int(x), ++f[x], ans -= x;
++f[0];
union_find uf(1 << sz);
for (int i = 1 << sz; --i >= 0;)
for (int j = i; 2 * j >= i; --j &= i)
if (f[i ^ j] && f[j]) {
ans += (long long)i * uf.join(i ^ j, j);
if (j == 0) break;
}
IO::write_int(ans, '\n');
return 0;
}
| 27 |
#include <iostream>
using namespace std;
int dp[35005],lst[35005],l[35005],qwq[35005];
struct stree
{
int now,l,r,add,mn;
}t[132000];
const int X=2e9;
inline void build(int now,int l,int r)
{
t[now].l=l,t[now].r=r,t[now].add=0;
if(l==r)
{
t[now].mn=X;
return ;
}
int mid=(l+r)/2;
build(now*2,l,mid),build(now*2+1,mid+1,r);
t[now].mn=min(t[now*2].mn,t[now*2+1].mn);
}
inline void give(int now,int k)
{
t[now].add+=k,t[now].mn+=k;
}
inline void pushdown(int now)
{
if(t[now].l!=t[now].r)
give(now*2,t[now].add),give(now*2+1,t[now].add),t[now].add=0;
}
inline void change(int now,int l,int r,int k)
{
pushdown(now);
if(t[now].l==l&&t[now].r==r)
{
give(now,k);
return ;
}
if(t[now*2].r>=r) change(now*2,l,r,k);
else if(t[now*2+1].l<=l) change(now*2+1,l,r,k);
else change(now*2,l,t[now*2].r,k),change(now*2+1,t[now*2+1].l,r,k);
t[now].mn=min(t[now*2].mn,t[now*2+1].mn);
}
inline int query()
{
return t[1].mn;
}
int main(int argc, char** argv) {
int n,k;
cin >> n >> k;
for(int i=1;i<=n;i++)
{
int x;
cin >> x;
l[i]=qwq[x];
qwq[x]=i;
}
for(int i=1;i<=n;i++)
lst[i]=lst[i-1]+(!!l[i])*(i-l[i]);
for(int i=2;i<=k;i++)
{
build(1,0,n);
change(1,0,0,-X);
for(int j=1;j<=n;j++)
{
if(l[j]) change(1,0,l[j]-1,j-l[j]);
dp[j]=query();
change(1,j,j,lst[j]-X);
}
swap(dp,lst);
}
cout << lst[n];
return 0;
}
| 17 |
#include <bits/stdc++.h>
int n, A, B, C, D;
unsigned int ans;
std::bitset<100000003> vis;
void solve(int p) {
unsigned int v = 1u * A * p * p * p + 1u * B * p * p + 1u * C * p + 1u * D;
for (long long i = p; i <= n; i = i * p) {
ans = ans + 1u * (n / i) * v;
}
}
int main() {
std::ios::sync_with_stdio(0);
std::cin >> n >> A >> B >> C >> D;
if (n >= 2) solve(2);
if (n >= 3) solve(3);
if (n >= 5) solve(5);
for (int i = 7; i <= n; ++i) {
if ((!(i & 1)) || i % 3 == 0 || i % 5 == 0) continue;
if (vis[i / 3]) continue;
solve(i);
for (int j = i + i; j <= n; j += i) {
if (((!(j & 1)) || j % 3 == 0 || j % 5 == 0)) continue;
vis[j / 3] = 1;
}
}
std::cout << ans << '\n';
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int a[int(1e5)];
int b[int(1e5)];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, l, r;
cin >> n >> r >> l;
if (((l - (n - 1)) * (l - (n - 1)) + n - 1) < r || n > l) puts("-1"), exit(0);
for (int i = 0; i < n - 1; i++) puts("1");
cout << l - (n - 1) << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct triple {
string name;
long long w, h;
triple() {}
triple(string n, long long ww, long long hh) { name = n, w = ww, h = hh; }
bool operator<(const triple &a) const { return name < a.name; }
};
int n, T;
string name[110];
map<string, long long> mp;
long long type[110], br[110];
long long sp[110];
long long deg[110], cnt[110];
long long mat[110][110];
long long w[110], h[110];
queue<long long> q;
triple arr[110];
bool hv[110];
int main() {
string s1, s2, s3, s4;
int a, b;
while (cin >> T) {
while (!q.empty()) q.pop();
n = 0;
memset(cnt, 0, sizeof cnt);
memset(mat, 0, sizeof mat);
memset(deg, 0, sizeof deg);
memset(br, 0, sizeof br);
memset(sp, 0, sizeof sp);
memset(w, 0, sizeof w);
memset(h, 0, sizeof h);
for (int i = 0; i < T; i++) {
cin >> s1;
if (s1[0] == 'W') {
cin >> s1;
for (int i = 0; i < s1.length(); i++)
if (s1[i] == '(' || s1[i] == ')' || s1[i] == ',') s1[i] = ' ';
istringstream sin(s1);
sin >> s2 >> a >> b;
if (mp.find(s2) == mp.end()) {
name[n] = s2;
mp[s2] = n++;
}
type[mp[s2]] = 0;
w[mp[s2]] = a;
h[mp[s2]] = b;
} else if (s1[0] == 'H') {
cin >> s2;
if (mp.find(s2) == mp.end()) {
name[n] = s2;
mp[s2] = n++;
}
type[mp[s2]] = 1;
} else if (s1[0] == 'V') {
cin >> s2;
if (mp.find(s2) == mp.end()) {
name[n] = s2;
mp[s2] = n++;
}
type[mp[s2]] = 2;
} else {
for (int i = 0; i < s1.length(); i++)
if (s1[i] == '(' || s1[i] == ')' || s1[i] == '.') s1[i] = ' ';
istringstream sin(s1);
sin >> s2 >> s3;
if (s3[0] == 'p') {
sin >> s4;
mat[mp[s2]][mp[s4]]++;
deg[mp[s2]]++;
cnt[mp[s2]]++;
} else {
sin >> a;
if (s3[4] == 'b')
br[mp[s2]] = a;
else
sp[mp[s2]] = a;
}
}
}
for (int i = 0; i < n; i++) {
if (deg[i] == 0) q.push(i);
}
while (!q.empty()) {
long long t = q.front();
q.pop();
if (type[t] != 0 && cnt[t] != 0) {
w[t] += 2 * br[t];
h[t] += 2 * br[t];
if (type[t] == 1)
w[t] += (cnt[t] - 1) * sp[t];
else
h[t] += (cnt[t] - 1) * sp[t];
}
for (int i = 0; i < n; i++) {
if (mat[i][t] > 0) {
int pt = i;
int tot = mat[i][t];
deg[pt] -= tot;
if (type[pt] == 1) {
w[pt] += tot * w[t];
h[pt] = max(h[pt], h[t]);
} else {
h[pt] += tot * h[t];
w[pt] = max(w[pt], w[t]);
}
if (deg[pt] == 0) q.push(pt);
}
}
}
for (int i = 0; i < n; i++) {
arr[i] = triple(name[i], w[i], h[i]);
}
sort(arr, arr + n);
for (int i = 0; i < n; i++)
cout << arr[i].name << ' ' << arr[i].w << ' ' << arr[i].h << endl;
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long a[5];
long long ans;
int main() {
cin >> a[1] >> a[2] >> a[3];
sort(a + 1, a + 1 + 3);
if (a[3] > 2 * a[1] + 2 * a[2]) a[3] = 2 * (a[1] + a[2]);
cout << (a[1] + a[2] + a[3]) / 3 << endl;
}
| 10 |
#include <bits/stdc++.h>
int arr[1005];
int main() {
int parity = 0;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int current;
scanf("%d", ¤t);
if (i == j) parity ^= current;
}
int m;
scanf("%d", &m);
while (m-- > 0) {
int x, y;
scanf("%d", &x);
if (x != 3) scanf("%d", &y);
if (x != 3) parity ^= 1;
if (x == 3) putchar(parity + '0');
}
putchar('\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[2100];
int main() {
int n, b, i, j;
while (scanf("%d%d", &n, &b) != EOF) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
int now, max = b;
for (i = 1; i <= n; i++)
for (j = i + 1; j <= n; j++)
if (a[j] > a[i]) {
now = b / a[i] * a[j] + b % a[i];
if (now > max) max = now;
}
printf("%d\n", max);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long fpow(long long a, long long b) {
long long r = 1;
for (a %= mod; b; b >>= 1) {
if (b & 1) r = r * a % mod;
a = a * a % mod;
}
return r;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
long long win[n][n];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) continue;
win[i][j] = a[i] * fpow(a[i] + a[j], mod - 2) % mod;
}
}
long long dp[1 << n], mul[1 << n][n], inner[1 << n][2];
for (int i = 1; i < 1 << n; ++i) {
mul[i][0] = mul[i][1] = 1;
for (int j = 0; j < n; ++j) {
if (i >> j & 1) mul[i][1] = mul[i][1] * a[j] % mod;
}
for (int j = 2; j < n; ++j) {
mul[i][j] = mul[i][j - 1] * mul[i][1] % mod;
}
inner[i][0] = 1;
for (int j = 0; j < n; ++j) {
if (i >> j & 1)
for (int k = j + 1; k < n; ++k) {
if (i >> k & 1) inner[i][0] = inner[i][0] * (a[j] + a[k]) % mod;
}
}
inner[i][1] = fpow(inner[i][0], mod - 2);
}
for (int i = 1; i < 1 << n; ++i) {
dp[i] = 1;
for (int j = (i - 1) & i; j; j = (j - 1) & i) {
dp[i] -= dp[j] * mul[j][__builtin_popcount(i ^ j)] % mod * inner[j][0] %
mod * inner[i ^ j][0] % mod * inner[i][1] % mod;
}
dp[i] %= mod;
}
long long ans = 0;
for (int i = 1; i < 1 << n; ++i) {
long long tmp = 1;
for (int j = 0; j < n; ++j) {
if (i >> j & 1)
for (int k = 0; k < n; ++k) {
if (!(i >> k & 1)) tmp = tmp * win[j][k] % mod;
}
}
ans += tmp * dp[i] % mod * __builtin_popcount(i) % mod;
}
ans %= mod;
if (ans < 0) ans += mod;
cout << ans << '\n';
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5200 + 15;
const int INF = 0x3f3f3f3f;
inline void rdInt(int &x) { scanf("%d", &x); }
inline void ptInt(int x) { printf("%d", x); }
inline void ptInts(int x, char c) { printf("%d%c", x, c); }
inline void rdStr(char *x) { scanf("%s", x); }
inline void ptStr(char *x) { printf("%s\n", x); }
inline void rdLL(long long &x) { scanf("%lld", &x); }
inline void ptLL(long long x) { printf("%lld", x); }
inline bool strEq(char *x, char *y) { return strcmp(x, y) == 0; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
bool a[MAXN][MAXN];
int stk[MAXN];
char s[MAXN][MAXN >> 1];
int n, m;
void seta(bool *Ary, bool _1, bool _2, bool _3, bool _4) {
Ary[0] = _1;
Ary[1] = _2;
Ary[2] = _3;
Ary[3] = _4;
}
void conv(bool *Ary, char c) {
switch (c) {
case '0':
seta(Ary, 0, 0, 0, 0);
break;
case '1':
seta(Ary, 0, 0, 0, 1);
break;
case '2':
seta(Ary, 0, 0, 1, 0);
break;
case '3':
seta(Ary, 0, 0, 1, 1);
break;
case '4':
seta(Ary, 0, 1, 0, 0);
break;
case '5':
seta(Ary, 0, 1, 0, 1);
break;
case '6':
seta(Ary, 0, 1, 1, 0);
break;
case '7':
seta(Ary, 0, 1, 1, 1);
break;
case '8':
seta(Ary, 1, 0, 0, 0);
break;
case '9':
seta(Ary, 1, 0, 0, 1);
break;
case 'A':
seta(Ary, 1, 0, 1, 0);
break;
case 'B':
seta(Ary, 1, 0, 1, 1);
break;
case 'C':
seta(Ary, 1, 1, 0, 0);
break;
case 'D':
seta(Ary, 1, 1, 0, 1);
break;
case 'E':
seta(Ary, 1, 1, 1, 0);
break;
case 'F':
seta(Ary, 1, 1, 1, 1);
break;
default:
ptStr("Oops.");
}
}
void calstk(int &res) {
int tmp = stk[1];
for (int i = (1); i <= (*stk); i++) tmp = gcd(tmp, stk[i]);
res = res ? gcd(res, tmp) : tmp;
}
int main() {
rdInt(n);
m = n >> 2;
for (int i = (0); i < (n); i++) rdStr(s[i]);
if (n == 1) {
return puts("1");
} else if (n == 2) {
if (s[0][0] == '3' && s[1][0] == '3') return puts("2");
if (s[0][0] == '0' && s[1][0] == '0') return puts("2");
return puts("1");
} else if (n == 3) {
if (s[0][0] == '8' && s[1][0] == '8' && s[2][0] == '8') return puts("3");
if (s[0][0] == '0' && s[1][0] == '0' && s[2][0] == '0') return puts("3");
return puts("1");
}
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
conv(a[i] + j * 4, s[i][j]);
}
int ans = 0;
for (int i = (0); i < (n); i++) {
int num = 0;
stk[0] = 0;
bool cur = a[i][0];
for (int j = (0); j <= (n); j++) {
if (cur == a[i][j] && j < n) {
num++;
} else {
cur ^= 1;
stk[++*stk] = num;
num = 1;
}
}
calstk(ans);
}
if (ans == 1) {
ptInt(1);
return 0;
}
for (int i = (0); i < (n); i++) {
int num = 0;
stk[0] = 0;
bool cur = a[0][i];
for (int j = (0); j <= (n); j++) {
if (cur == a[j][i] && j < n) {
num++;
} else {
cur ^= 1;
stk[++*stk] = num;
num = 1;
}
}
calstk(ans);
}
ptInt(ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int a[] = {4, 22, 27, 58, 85, 94, 121, 166, 202, 265, 274,
319, 346, 355, 378, 382, 391, 438, 454, 483, 517, 526,
535, 562, 576, 588, 627, 634, 636, 645, 648, 654, 663,
666, 690, 706, 728, 729, 762, 778, 825, 852, 861, 895,
913, 915, 922, 958, 985, 1086, 1111, 1165};
int x;
cin >> x;
cout << a[x - 1];
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MaxK = 20;
const int MaxN = 500000;
long long d[MaxN], dp[MaxN];
int k;
long long a, b;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
int main() {
scanf("%I64d%I64d%d", &a, &b, &k);
int n1 = 2;
for (int i = 3; i <= k; i++) n1 = lcm(n1, i);
long long n = n1;
dp[0] = 0LL;
for (int i = 1; i <= n; i++) {
dp[i] = 1 + dp[i - 1];
for (int j = 2; j <= k; j++)
if (dp[i] > 1 + dp[i - (i % j)]) dp[i] = 1 + dp[i - (i % j)];
}
d[b % n] = 0LL;
for (int i = (b % n) + 1; i <= n; i++) {
d[i] = 1 + d[i - 1];
for (int j = 2; j <= k; j++)
if (d[i] > 1 + d[i - (i % j)] && i - (i % j) >= (b % n))
d[i] = 1 + d[i - (i % j)];
}
if (a / n == b / n) {
printf("%I64d\n", d[a % n]);
return 0;
}
long long a1 = a / n;
long long b1 = b / n;
long long x = a1 - b1 - 1;
long long sol = x * (dp[n - 1] + 1);
sol += dp[a % n];
sol += d[n - 1];
printf("%I64d\n", sol + 1);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, l, r, ans, cntr, cntl;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l >> r;
cntl += l;
cntr += r;
}
if (cntl > n / 2)
ans += n - cntl;
else
ans += cntl;
if (cntr > n / 2)
ans += n - cntr;
else
ans += cntr;
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int maxn = 3e2;
const long long inf = 1e9 + 7;
vector<pair<int, int> > f, u, ho;
string s[100];
int used[10000];
int n;
bool check(int dx, int dy) {
for (int i = 0; i < f.size(); ++i) {
if (f[i].first + dx >= 0 && f[i].first + dx < n && f[i].second + dy >= 0 &&
f[i].second + dy < n) {
if (s[f[i].first + dx][f[i].second + dy] == '.') return false;
}
}
return true;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (s[i][j] == 'o') {
f.push_back(make_pair(i, j));
}
if (s[i][j] == 'x') {
u.push_back(make_pair(i, j));
}
}
}
for (int i = 0; i < u.size(); ++i) {
int s = ho.size();
for (int j = 0; j < f.size(); ++j) {
if (check(u[i].first - f[j].first, u[i].second - f[j].second)) {
ho.push_back(
make_pair(u[i].first - f[j].first, u[i].second - f[j].second));
break;
}
}
if (s == ho.size()) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
string ss[300];
for (int i = 0; i < 2 * n - 1; ++i) {
for (int j = 0; j < 2 * n - 1; ++j) {
ss[i] += ".";
}
}
ss[n - 1][n - 1] = 'o';
for (int i = 0; i < ho.size(); ++i) {
ss[n - 1 + ho[i].first][n - 1 + ho[i].second] = 'x';
}
for (int i = 0; i < 2 * n - 1; ++i) {
cout << ss[i] << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int X[3], Y[3];
map<string, int> dic_x, dic_y;
for (int i = 0; i < 3; i++) cin >> X[i] >> Y[i];
vector<string> ABC(3);
ABC[0] = "A";
dic_x["A"] = X[0];
dic_y["A"] = Y[0];
ABC[1] = "B";
dic_x["B"] = X[1];
dic_y["B"] = Y[1];
ABC[2] = "C";
dic_x["C"] = X[2];
dic_y["C"] = Y[2];
do {
int x[3], y[3];
for (int i = 0; i < 8; i++) {
int bit = i;
for (int j = 0; j < 3; j++) {
if (bit % 2) {
x[j] = dic_x[ABC[j]];
y[j] = dic_y[ABC[j]];
;
} else {
x[j] = dic_y[ABC[j]];
;
y[j] = dic_x[ABC[j]];
}
bit /= 2;
}
if (x[0] == y[0] + y[1] + y[2] && x[0] == x[1] && x[1] == x[2]) {
cout << x[0] << endl;
for (int c = 0; c < 3; c++) {
for (int i = 0; i < y[c]; i++) {
for (int j = 0; j < x[c]; j++) cout << ABC[c];
cout << endl;
}
}
return 0;
}
if (x[0] == y[0] + y[1] && x[0] == x[1] + x[2] && y[1] == y[2]) {
cout << x[0] << endl;
for (int i = 0; i < y[0]; i++) {
for (int j = 0; j < x[0]; j++) cout << ABC[0];
cout << endl;
}
for (int i = 0; i < y[1]; i++) {
for (int j = 0; j < x[1]; j++) cout << ABC[1];
for (int j = 0; j < x[2]; j++) cout << ABC[2];
cout << endl;
}
return 0;
}
}
} while (next_permutation(ABC.begin(), ABC.end()));
cout << -1 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
struct edge {
int u, v, w, id;
} c[maxn];
unordered_map<long long, int> mp;
int n, m, q, fa[maxn];
long long L[maxn], R[maxn];
int find_set(int x) { return fa[x] ? fa[x] = find_set(fa[x]) : x; }
bool cmp(edge a, edge b) { return a.w < b.w; }
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &c[i].u, &c[i].v, &c[i].w);
c[i].id = i;
}
sort(c + 1, c + m + 1, cmp);
int i, j, k;
for (i = 1; i <= m; i = j + 1) {
for (j = i; j < m && c[j + 1].w == c[i].w; j++)
;
for (k = i; k <= j; k++)
L[c[k].id] = 1LL * c[k].w * m + find_set(c[k].u),
R[c[k].id] = 1LL * c[k].w * m + find_set(c[k].v);
for (k = i; k <= j; k++)
if (find_set(c[k].u) != find_set(c[k].v))
fa[find_set(c[k].u)] = find_set(c[k].v);
}
memset(fa, 0, sizeof(fa));
scanf("%d", &q);
for (i = 1; i <= q; i++) {
int s;
scanf("%d", &s);
mp.clear();
bool flag = 1;
int x, clk = 0;
for (j = 1; j <= s; j++) {
scanf("%d", &x);
if (!mp[L[x]]) fa[mp[L[x]] = ++clk] = 0;
if (!mp[R[x]]) fa[mp[R[x]] = ++clk] = 0;
if (find_set(mp[L[x]]) == find_set(mp[R[x]]))
flag = 0;
else
fa[find_set(mp[L[x]])] = find_set(mp[R[x]]);
}
if (flag)
puts("YES");
else
puts("NO");
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, t, n, ar[1001], ans1, ans2, i, j, k;
int main() {
cin >> t;
while (t--) {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> ar[i];
a = 0;
b = 0;
i = 1;
j = n;
k = 0;
ans1 = 0;
ans2 = 0;
while (true) {
k++;
if (k % 2 == 1) {
ans1 = 0;
while (ans1 <= ans2) {
if (i > j) break;
ans1 += ar[i];
a += ar[i];
i++;
}
} else {
ans2 = 0;
while (ans2 <= ans1) {
if (i > j) break;
ans2 += ar[j];
b += ar[j];
j--;
}
}
if (i > j) break;
}
cout << k << " " << a << " " << b << endl;
}
}
| 5 |
#include <bits/stdc++.h>
void solution() {
long long n;
std::cin >> n;
std::cout << "0 1" << std::endl;
std::string s, t;
std::cin >> s;
long long l = 1, r = 1e9 - 1;
for (long long i = (2); i <= (n); ++i) {
long long mid = (l + r) >> 1;
std::cout << mid << " 1" << std::endl;
std::cin >> t;
if (s == t)
l = mid + 1;
else
r = mid - 1;
}
std::cout << l - 1 << " 0 " << r + 1 << " 2" << std::endl;
}
signed main() {
42;
std::ios::sync_with_stdio(false);
std::cout.tie(nullptr);
std::cin.tie(nullptr);
solution();
}
| 11 |
#include <bits/stdc++.h>
int main() {
int n, i, d = 0, a = 0;
scanf("%d", &n);
char w[n];
scanf("%s", &w);
for (i = 0; i < n; i++) {
if (w[i] == 'D') {
d++;
}
if (w[i] == 'A') {
a++;
}
}
if (d > a) {
printf("Danik");
}
if (d < a) {
printf("Anton");
}
if (d == a) {
printf("Friendship");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static const int maxn = 4e5 + 5;
static const long long int is_query = LLONG_MIN;
struct Line {
long long int m, b;
mutable function<const Line *()> succ;
bool operator<(const Line &rhs) const {
if (rhs.b != is_query) return m < rhs.m;
const Line *s = succ();
if (!s) return 0;
long long int x = rhs.m;
return (b - s->b) < ((s->m - m) * x);
}
};
struct CHT : public multiset<Line> {
bool bad(iterator y) {
auto z = next(y);
if (y == begin()) {
if (z == end()) return 0;
return y->m == z->m && y->b <= z->b;
}
auto x = prev(y);
if (z == end()) return y->m == x->m && y->b <= x->b;
return 1.0 * (x->b - y->b) * (z->m - y->m) >=
1.0 * (y->b - z->b) * (y->m - x->m);
}
void add(long long int m, long long int b) {
auto y = insert({m, b});
y->succ = [=] { return next(y) == end() ? 0 : &*next(y); };
if (bad(y)) {
erase(y);
return;
}
while (next(y) != end() && bad(next(y))) erase(next(y));
while (y != begin() && bad(prev(y))) erase(prev(y));
}
long long int query(long long int x) {
auto l = *lower_bound((Line){x, is_query});
return l.m * x + l.b;
}
};
vector<vector<pair<long long int, long long int> > > Tree(4 * maxn);
void update(int node, int a, int b, int i, int j,
pair<long long int, long long int> p) {
if (a > j or b < i) return;
if (a >= i and b <= j) return void(Tree[node].push_back(p));
int lchild = node * 2;
int rchild = lchild + 1;
int mid = (a + b) / 2;
update(lchild, a, mid, i, j, p);
update(rchild, mid + 1, b, i, j, p);
}
vector<CHT *> cht(30);
vector<long long int> qval(maxn);
vector<bool> valid(maxn);
vector<long long int> ans(maxn);
vector<bool> isquery(maxn);
void dfs(int node, int a, int b, int h) {
if (a > b) return;
cht[h] = new CHT();
for (pair<long long int, long long int> p : Tree[node])
(*cht[h]).add(p.first, p.second);
if (a == b) {
if (isquery[a] == 0) return;
long long int maxi = is_query;
for (int i = 0; i <= h; i++) {
if ((*cht[i]).size() == 0) continue;
long long int dp = (*cht[i]).query(qval[a]);
maxi = max(maxi, dp);
valid[a] = 1;
}
ans[a] = maxi;
} else {
int lchild = node * 2;
int rchild = lchild + 1;
int mid = (a + b) / 2;
dfs(lchild, a, mid, h + 1);
dfs(rchild, mid + 1, b, h + 1);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
map<pair<long long int, long long int>, int> in;
vector<pair<long long int, long long int> > all_queries(n + 1);
for (int i = 1; i <= n; i++) {
int type;
cin >> type;
if (type == 1) {
long long int a, b;
cin >> a >> b;
in[make_pair(a, b)] = i;
all_queries[i] = make_pair(a, b);
} else if (type == 2) {
int id;
cin >> id;
long long int a = all_queries[id].first;
long long int b = all_queries[id].second;
int l = in[make_pair(a, b)];
int r = i - 1;
update(1, 1, n, l, r, make_pair(a, b));
in.erase(make_pair(a, b));
} else {
long long int val;
cin >> val;
qval[i] = val;
isquery[i] = 1;
}
}
for (auto it : in) {
int l = it.second;
int r = n;
long long int a = it.first.first;
long long int b = it.first.second;
update(1, 1, n, l, r, make_pair(a, b));
}
dfs(1, 1, n, 0);
for (int i = 1; i <= n; i++) {
if (isquery[i] == 0) continue;
if (valid[i])
cout << ans[i] << '\n';
else
cout << "EMPTY SET" << '\n';
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int v[200200];
int s[7][200200];
int get(int t, int a, int b) {
int r = s[t][b];
if (a) r -= s[t][a - 1];
return r;
}
int main() {
int n;
scanf("%d", &n);
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
for (int i = 0; i < n; i++) scanf("%d", v + i);
sort(v, v + n);
if (v[n - 1] > a + b + c) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++) {
if (i)
for (int j = 0; j < 7; j++) s[j][i] += s[j][i - 1];
if (v[i] <= a) s[0][i]++;
if (a < v[i] && v[i] <= b) s[1][i]++;
if (b < v[i] && v[i] <= a + b) s[2][i]++;
if (v[i] > a + b) s[3][i]++;
if (v[i] - c <= a) s[4][i]++;
if (a < v[i] - c && v[i] - c <= b) s[5][i]++;
if (v[i] > a + b) s[6][i]++;
}
int ans0 = 0;
while (n >= 1 && v[n - 1] > b + c) {
n--;
ans0++;
}
int low = 0, up = n;
int pc = 0;
while (pc < n - 1 && v[pc + 1] <= c) pc++;
while (low != up) {
int mid = (low + up) / 2;
;
int ok = 0;
for (int i = 0; i <= mid; i++) {
;
int gr = mid - i;
int cc1, cc2, ct1, ct2, ct1b, ct2b;
ct1b = 1;
ct2b = 0;
cc2 = pc;
cc1 = pc - i + 1;
if (cc1 < 0) cc1 = 0;
if (v[0] > c) {
cc1 = 1;
cc2 = 0;
}
ct2 = n - 1;
ct1 = ct2 - gr + 1;
if (ct1 < 0) ct1 = 0;
if (ct1 <= cc2) {
int off = cc2 - ct1 + 1;
ct2b = cc1 - 1;
ct1b = ct2b - off + 1;
if (ct1b < 0) ct1b = 0;
if (ct2b < 0) {
ct1b = 1;
ct2b = 0;
}
ct1 = cc2 + 1;
}
if (v[n - 1] <= c) {
ct1b = 1;
ct2b = 0;
ct2 = cc1 - 1;
ct1 = ct2 - gr + 1;
if (ct1 < 0) ct1 = 0;
};
int AouB = get(0, 0, n - 1) - get(0, cc1, cc2) - get(0, ct1, ct2) -
get(0, ct1b, ct2b);
int AouB2 = get(4, ct1, ct2) + get(4, ct1b, ct2b);
int AeB = get(2, 0, n - 1) - get(2, cc1, cc2) - get(2, ct1, ct2) -
get(2, ct1b, ct2b);
int B = get(1, 0, n - 1) - get(1, cc1, cc2) - get(1, ct1, ct2) -
get(1, ct1b, ct2b);
int B2 = get(5, ct1, ct2) + get(5, ct1b, ct2b);
int falta = n - (cc2 - cc1 + 1);
int bad = get(6, 0, n - 1) - get(6, cc1, cc2) - get(6, ct1, ct2) -
get(6, ct1b, ct2b);
if (bad) continue;
;
int hb = mid, ha = mid;
hb -= B;
if (hb < 0) continue;
hb -= AeB;
ha -= AeB;
if (ha < 0 || hb < 0) continue;
hb -= B2;
int dec = min(ha, B2);
int pa = min(B2, min(ha, AouB));
ha -= dec;
AouB -= pa;
if (hb < 0) continue;
int p = min(min(ha, hb), min(AouB, AouB2));
ha -= p;
hb -= p;
AouB -= p;
AouB2 -= p;
if (ha == 0 || hb == 0) {
if (ha + hb >= AouB + AouB2) ok = 1;
} else if (AouB2 == 0) {
if (ha + hb >= AouB) ok = 1;
} else if (AouB == 0) {
if (max(ha, hb) >= AouB2) ok = 1;
}
}
if (ok)
up = mid;
else
low = mid + 1;
}
printf("%d\n", low + ans0);
}
| 16 |
#include <bits/stdc++.h>
const int M = 6e5 + 10;
const int mod = 1e9 + 7;
using namespace std;
inline long long read() {
long long e = 1, sum = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') e = -1;
c = getchar();
}
while (isdigit(c)) {
sum = sum * 10 + c - 48;
c = getchar();
}
return e * sum;
}
char c[M];
long long n, a[M];
long long l = 1, r = 1;
long long ans, flag;
long long x[M], y[M], z[M];
long long hx, hy, hz, Min = mod;
int main() {
long long i, j;
n = read();
scanf("%s", c + 1);
for (i = 1; i <= n; i++) {
a[i] = a[i - 1] + (c[i] == '(' ? 1 : -1);
if (a[i] < Min) {
Min = a[i];
}
}
if (a[n] != 0) {
printf("0\n1 1");
return 0;
}
for (i = 1; i <= n; i++) {
a[i + n] = a[i];
}
x[0] = y[0] = z[0] = 0;
for (i = 1; i <= n; i++) {
if (a[i] == Min) {
x[++hx] = i;
} else if (a[i] == Min + 1) {
y[++hy] = i;
} else if (a[i] == Min + 2) {
z[++hz] = i;
}
}
x[++hx] = n + x[1];
y[++hy] = n + y[1];
z[++hz] = n + z[1];
long long ans, res;
ans = res = hx - 1;
long long Max = 0;
for (i = 1; i <= hy; i++) {
long long sum = 0;
for (j = y[i - 1] + 1; j < y[i]; j++) {
if (a[j] < Min + 1) break;
if (a[j] == Min + 2) {
sum++;
}
}
if (sum > Max) {
l = (y[i - 1] + 1) % n;
r = y[i] % n;
if (l == 0) l = n;
if (r == 0) r = n;
Max = sum;
}
}
ans = max(ans, Max + res);
Max = 0;
for (i = 1; i <= hx; i++) {
long long sum = 0;
for (j = x[i - 1] + 1; j < x[i]; j++) {
if (a[j] == Min + 1) {
sum++;
}
}
if (sum > ans) {
l = (x[i - 1] + 1) % n;
r = x[i] % n;
if (l == 0) l = n;
if (r == 0) r = n;
ans = sum;
}
}
if (hx - 1 == 1) {
if (hy - 1 > ans) {
for (i = 1; i <= n; i++) {
if (a[i] == Min) {
l = i % n;
r = (i + 1) % n;
if (l == 0) l = n;
if (r == 0) r = n;
ans = hy - 1;
}
}
}
}
printf("%lld\n", ans);
printf("%lld %lld", l, r);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
string f = s;
long long sum = 0;
for (int i = 0; i < s.size(); i++) {
int y = (s[i] - 48) % 3;
sum += y;
s[i] = char(y + 48);
}
int h = sum % 3, id = -1;
if (h == 0) {
cout << f;
return 0;
}
for (int i = s.size(); i >= 0; i--) {
if (s[i] - 48 == h) {
id = i;
break;
}
}
if (id == -1) {
char t = '1';
if (h == t - 48) t = '2';
int n = s.size(), cnt1 = 0;
for (int q = 1; q <= 2; q++) {
int k = -1;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == t) {
k = i;
break;
}
}
if (k == -1) {
cnt1 = n;
break;
}
s.erase(k, 1);
f.erase(k, 1);
cnt1++;
}
if (cnt1 == n) {
cout << -1;
return 0;
}
int cnt = 0;
while (f[0] == '0') {
if (f[0] == '0' && f.size() == 1) break;
s.erase(0, 1);
f.erase(0, 1);
cnt++;
}
cout << f;
} else if (id == 0) {
int cnt = 1;
string d = s, p = f;
d.erase(id, 1);
p.erase(id, 1);
if (p.size() == 0) {
cout << -1;
return 0;
}
while (p[id] == '0') {
if (p[id] == '0' && p.size() == 1) break;
d.erase(id, 1);
p.erase(id, 1);
cnt++;
}
char t = '1';
if (t - 48 == h) {
t = '2';
}
if (cnt > 2) {
int cnt1 = 0;
int n = s.size();
for (int q = 1; q <= 2; q++) {
int k = -1;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == t) {
k = i;
break;
}
}
if (k == -1) {
cnt1 = n;
break;
}
s.erase(k, 1);
f.erase(k, 1);
if (f.size() == 0) {
cout << -1;
return 0;
}
cnt1++;
}
if (cnt1 > cnt) {
cout << p;
} else {
cout << f;
}
} else {
cout << p;
}
} else {
f.erase(id, 1);
if (f.size() == 0) {
cout << -1;
return 0;
}
cout << f;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct atom {
int num, w;
};
int operator<(atom k1, atom k2) { return k1.w < k2.w; }
set<atom> S;
int n, m, d, x[210000], p[210000], a[210000];
int compare(int k1, int k2) { return x[k1] < x[k2]; }
int main() {
scanf("%d%d%d", &d, &n, &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &x[i], &p[i]);
m++;
x[m] = d;
for (int i = 1; i <= m; i++) a[i] = i;
sort(a + 1, a + m + 1, compare);
S.insert((atom){n, 0});
long long ans = 0;
for (int i = 1; i <= m; i++) {
int dis = x[a[i]] - x[a[i - 1]];
if (n < dis) {
printf("-1\n");
return 0;
}
int ad = dis;
for (set<atom>::iterator k = S.begin(); dis;) {
int num = (*k).num;
if (num <= dis) {
ans += 1ll * (*k).w * num;
dis -= num;
set<atom>::iterator k1 = k;
k++;
S.erase(k1);
} else {
ans += 1ll * (*k).w * dis;
atom k2 = (atom){(*k).num - dis, (*k).w};
S.erase(k);
S.insert(k2);
break;
}
}
while (1) {
set<atom>::iterator k1 = S.lower_bound((atom){0, p[a[i]]});
if (k1 == S.end()) break;
ad += (*k1).num;
S.erase(k1);
}
if (ad) S.insert((atom){ad, p[a[i]]});
}
cout << ans << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int w[100005];
int wf[100005];
int main() {
ios::sync_with_stdio(0);
int n, cl, cr, ql, qr;
cin >> n >> cl >> cr >> ql >> qr;
wf[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i];
wf[i] = wf[i - 1] + w[i];
}
int tot = 0, cur, l, r;
int sum = wf[n];
int ret = 2e9 + 5;
for (int i = 0; i <= n; i++) {
cur = wf[i] * cl + (sum - wf[i]) * cr;
l = i;
r = n - l;
if (l > r)
cur += (l - r - 1) * ql;
else if (r > l)
cur += (r - l - 1) * qr;
ret = min(ret, cur);
}
cout << ret << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 262, hm = 52 * 52, maxt = 200;
const long long INF = 1000;
const long double EPS = 1E-9, EPS2 = 1E-8;
const long double M_PIS = 3.14159265358979323846264338327950288;
unsigned char color[hm];
string s[maxn];
pair<int, int> deltas[4];
pair<int, int> pix[hm][4][4];
int used[maxn][maxn], numb = 0, m, p, whose[maxn][maxn], was[hm][4][4];
pair<int, int> cmp(pair<int, int> a, pair<int, int> b, int dp, int cp) {
if (a.first == -1) return b;
if (b.first == -1) return a;
if (dp == 0 && ((a.first < b.first) ||
(a.first == b.first && ((a.second < b.second) != cp))))
return a;
if (dp == 1 && ((a.second > b.second) ||
(a.second == b.second && ((a.first < b.first) != cp))))
return a;
if (dp == 2 && ((a.first > b.first) ||
(a.first == b.first && ((a.second > b.second) != cp))))
return a;
if (dp == 3 && ((a.second < b.second) ||
(a.second == b.second && ((a.first > b.first) != cp))))
return a;
return b;
}
void dfs(int i, int j, unsigned char c) {
if (i < 0 || i >= m || j < 0 || j >= p || used[i][j] || s[i][j] != c) return;
used[i][j] = 1;
whose[i][j] = numb;
for (int k = 0; k < 4; ++k)
for (int l = 0; l < 2; ++l)
pix[numb][k][l] = cmp(make_pair(i, j), pix[numb][k][l], k, l);
dfs(i + 1, j, c);
dfs(i, j + 1, c);
dfs(i - 1, j, c);
dfs(i, j - 1, c);
}
pair<int, int> operator+(const pair<int, int>& a, const pair<int, int>& b) {
return make_pair(a.first + b.first, a.second + b.second);
}
void bfs(int id, int dp, int cp, int ost) {
if (was[id][dp][cp]) {
ost = (ost % (was[id][dp][cp] - ost));
}
was[id][dp][cp] = ost;
if (ost == 0) {
cout << color[id] << endl;
exit(0);
}
pair<int, int> px = pix[id][dp][cp] + deltas[dp];
if (px.first < 0 || px.first >= m || px.second < 0 || px.second >= p ||
s[px.first][px.second] == '0') {
if (cp == 0)
bfs(id, dp, 1, ost - 1);
else
bfs(id, (dp + 1) % 4, 0, ost - 1);
} else
bfs(whose[px.first][px.second], dp, cp, ost - 1);
}
int main() {
deltas[0] = make_pair(-1, 0);
deltas[1] = make_pair(0, 1);
deltas[2] = make_pair(1, 0);
deltas[3] = make_pair(0, -1);
int k, tmp, n;
cin >> m >> n;
for (int i = 0; i < m; ++i) cin >> s[i];
p = s[0].size();
for (int i = 0; i < m; ++i)
for (int j = 0; j < s[i].size(); ++j)
if (!used[i][j] && s[i][j] != '0') {
color[numb] = s[i][j];
for (int k = 0; k < 4; ++k)
for (int l = 0; l < 2; ++l) pix[numb][k][l] = make_pair(-1, 0);
dfs(i, j, s[i][j]);
++numb;
}
bfs(0, 1, 0, n);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct Team {
string name;
int points;
int zab;
int prop;
int playGames;
};
bool comp(Team a, Team b) {
bool res = true;
if (a.points > b.points)
return res;
else if (a.points == b.points) {
if ((a.zab - a.prop) > (b.zab - b.prop))
return res;
else if ((a.zab - a.prop) == (b.zab - b.prop)) {
if (a.zab > b.zab)
return res;
else if (a.zab == b.zab) {
if (b.name > a.name) return res;
}
}
}
return !res;
}
int main() {
string my_name("BERLAND");
vector<Team> tabl;
int n = 5;
for (int i = 0; i < n; ++i) {
string com1, com2;
int ball1, ball2;
cin >> com1 >> com2;
scanf("%d:%d", &ball1, &ball2);
int first = -1;
int sec = -1;
for (int j = 0; j < tabl.size(); ++j) {
if (tabl[j].name == com1) {
first = j;
} else if (tabl[j].name == com2)
sec = j;
}
int points1 = (ball1 >= ball2) ? ((ball1 == ball2) ? 1 : 3) : 0;
int points2 = (ball2 >= ball1) ? ((ball1 == ball2) ? 1 : 3) : 0;
if (first != -1) {
tabl[first].zab += ball1;
tabl[first].prop += ball2;
tabl[first].points += points1;
tabl[first].playGames += 1;
} else {
Team newTeam = {com1, points1, ball1, ball2, 1};
tabl.push_back(newTeam);
}
if (sec != -1) {
tabl[sec].zab += ball2;
tabl[sec].prop += ball1;
tabl[sec].points += points2;
tabl[sec].playGames += 1;
} else {
Team newTeam = {com2, points2, ball2, ball1, 1};
tabl.push_back(newTeam);
}
}
Team sopernik;
for (int i = 0; i < tabl.size(); ++i) {
if (tabl[i].playGames == 2 && tabl[i].name != my_name) {
sopernik = tabl[i];
break;
}
}
string sopernikName = sopernik.name;
int MAX_goal = 40;
int res1 = -1;
int res2 = -1;
for (int ball1 = 0; ball1 < MAX_goal; ++ball1)
for (int ball2 = 0; ball2 < ball1; ++ball2) {
vector<Team> tmp = tabl;
int myInd, hisInd;
for (int k = 0; k < tmp.size(); ++k) {
if (tmp[k].name == my_name)
myInd = k;
else if (tmp[k].name == sopernikName)
hisInd = k;
}
int points1 = (ball1 >= ball2) ? ((ball1 == ball2) ? 1 : 3) : 0;
int points2 = (ball2 >= ball1) ? ((ball1 == ball2) ? 1 : 3) : 0;
tmp[myInd].zab += ball1;
tmp[myInd].prop += ball2;
tmp[myInd].points += points1;
tmp[myInd].playGames += 1;
tmp[hisInd].zab += ball2;
tmp[hisInd].prop += ball1;
tmp[hisInd].points += points2;
tmp[hisInd].playGames += 1;
sort(tmp.begin(), tmp.end(), comp);
if (tmp[0].name == my_name || tmp[1].name == my_name) {
if (res1 == -1) {
res1 = ball1;
res2 = ball2;
}
if (ball1 - ball2 < res1 - res2) {
res1 = ball1;
res2 = ball2;
} else if (ball1 - ball2 == res1 - res2 && ball2 < res2) {
res1 = ball1;
res2 = ball2;
}
}
}
if (res1 != -1)
cout << res1 << ":" << res2;
else
cout << "IMPOSSIBLE";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long tavan(long long x, long long y) {
long long res = 1;
while (y) {
res *= (y % 2) ? x : 1;
res %= ((long long)1e9 + 7);
x *= x;
x %= ((long long)1e9 + 7);
y /= 2;
}
return res;
}
long long n, dp[((long long)210)][((long long)210)][((long long)210)],
f[((long long)210)][2];
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> s;
f[0][(s[0] == ')')] = 1;
for (int i = 1; i < s.size(); i++) {
f[i][(s[i] == ')')] = i + 1;
for (int j = i - 1; j >= 0; j--) {
bool flg = 1;
for (int k = 0; k < j; k++)
if (s[k] != s[i - j + k]) {
flg = 0;
break;
}
if (flg) {
f[i][(s[i] != ')')] = f[j][(s[i] != ')')];
break;
}
}
}
dp[0][0][0] = 1;
for (int i = 0; i < 2 * n; i++)
for (int j = 0; j <= min(n, (long long)i); j++)
for (int k = 0; k < s.size(); k++) {
dp[i + 1][j + 1][f[k][0]] += dp[i][j][k];
dp[i + 1][j + 1][f[k][0]] %= ((long long)1e9 + 7);
if (j) dp[i + 1][j - 1][f[k][1]] += dp[i][j][k];
dp[i + 1][j + 1][f[k][1]] %= ((long long)1e9 + 7);
}
long long ans = 0;
for (int i = 0; i < s.size(); i++)
ans += dp[2 * n][0][i], ans %= ((long long)1e9 + 7);
long long cat = 1;
for (int i = 1; i <= 2 * n; i++) cat *= i, cat %= ((long long)1e9 + 7);
for (int i = 1; i <= n; i++)
cat *= tavan(i, ((long long)1e9 + 7) - 2), cat %= ((long long)1e9 + 7),
cat *= tavan(i, ((long long)1e9 + 7) - 2), cat %= ((long long)1e9 + 7);
cat *= tavan(n + 1, ((long long)1e9 + 7) - 2);
cat %= ((long long)1e9 + 7);
cout << (cat - ans + ((long long)1e9 + 7)) % ((long long)1e9 + 7) << "\n";
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int ans[31];
void query(int l, int r, int ord, int len) {
if (l == r) {
cout << l << endl;
fflush(stdout);
return;
}
int res;
int m = (l + r) >> 1;
cout << m << endl;
fflush(stdout);
cin >> res;
if (res == 0) return;
if (ans[ord % len] == -1) res = -res;
if (res == -1)
query(l, m, ord + 1, len);
else
query(m + 1, r, ord + 1, len);
}
int main() {
int m, n;
while (cin >> m >> n) {
bool flag = true;
for (int i = 1; i <= n; i++) {
cout << 1 << endl;
fflush(stdout);
cin >> ans[i];
if (ans[i] == 0) {
flag = false;
break;
} else if (ans[i] == -2)
exit(0);
}
ans[0] = ans[n];
if (flag) query(1, m, n + 1, n);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long sum;
node() { sum = INT_MAX; }
};
class segte {
public:
long long n{};
vector<node> tree;
vector<long long> a;
node neutral;
void init(long long N) {
n = N;
tree.resize(4 * n + 1);
a.assign(n, INT_MAX);
}
void put(vector<long long> &val) { a = val; }
void merge(node &curr, node &left, node &right) {
curr.sum = min(left.sum, right.sum);
}
void single(node &curr, long long idx) { curr.sum = a[idx]; }
void build(long long index, long long ss, long long se) {
if (ss == se) {
single(tree[index], ss);
return;
}
long long mid = (ss + se) / 2;
build(2 * index, ss, mid);
build(2 * index + 1, mid + 1, se);
merge(tree[index], tree[2 * index], tree[2 * index + 1]);
}
void build() { build(1, 0, n - 1); }
node query(long long index, long long ss, long long se, long long qs,
long long qe) {
if (qs > se || qe < ss) return neutral;
if (qs <= ss && qe >= se) return tree[index];
long long mid = (ss + se) / 2;
node left = query(2 * index, ss, mid, qs, qe);
node right = query(2 * index + 1, mid + 1, se, qs, qe);
node mer;
merge(mer, left, right);
return mer;
}
node query(long long l, long long r) { return query(1, 0, n - 1, l, r); }
void update(long long index, long long idx, long long ss, long long se) {
if (idx < ss || idx > se) return;
if (ss == se) {
single(tree[index], ss);
return;
}
long long mid = (ss + se) / 2;
update(2 * index, idx, ss, mid);
update(2 * index + 1, idx, mid + 1, se);
merge(tree[index], tree[2 * index], tree[2 * index + 1]);
}
void update(long long idx) { update(1, idx, 0, n - 1); }
};
void solve() {
long long n;
cin >> n;
long long a[n + 1], b[n + 1], rb[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
memset(rb, -1, sizeof rb);
b[0] = 0;
rb[0] = 0;
for (long long i = 1; i <= n; i++) {
cin >> b[i];
b[i] += i;
rb[b[i]] = i;
}
segte s;
s.init(n + 5);
for (long long i = 1; i <= n; i++) {
s.a[i] = i - a[i];
s.update(i);
}
bool vis[n + 1];
long long val[n + 1];
memset(val, -1, sizeof val);
memset(vis, 0, sizeof vis);
vis[0] = true;
val[0] = 0;
vector<long long> check;
check.push_back(0);
while (!check.empty()) {
vector<long long> ncheck;
for (auto &c : check) {
if (s.query(c, n).sum > c) continue;
long long idx = c;
while (true) {
long long l = idx;
if (s.query(l, l).sum <= c) {
idx = l + 1;
long long nidx = rb[l];
if (nidx != -1 && !vis[nidx]) {
ncheck.push_back(nidx);
vis[nidx] = true;
}
val[l] = b[c];
s.a[l] = INT_MAX;
s.update(l);
} else {
long long r = n + 1;
while (l + 1 < r) {
long long m = (l + r) / 2;
if (s.query(l, m).sum <= c) {
r = m;
} else {
l = m;
}
}
if (r == n + 1) break;
idx = r;
long long nidx = rb[r];
if (nidx != -1 && !vis[nidx]) {
ncheck.push_back(nidx);
vis[nidx] = true;
}
val[r] = b[c];
s.a[r] = INT_MAX;
s.update(r);
}
}
}
check = ncheck;
}
if (val[n] == -1) {
cout << -1 << "\n";
} else {
vector<long long> ans;
while (n != 0) {
n = val[n];
ans.push_back(rb[n]);
}
cout << ans.size() << "\n";
for (auto &c : ans) {
cout << c << " ";
}
cout << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int A,B,k;
cin >> A >> B >> k;
vector<int> a(A),b(B);
vector<pair<int,int>> edges(k);
for(auto &[x, y] : edges) {
cin >> x;
}
for(auto &[x, y] : edges) {
cin >> y;
}
for(auto &[x,y]: edges) {
x--;
y--;
a[x]++;
b[y]++;
}
long long result = 0;
for(auto [x, y]: edges) {
result += k - a[x] - b[y] + 1;
}
cout << result / 2 << '\n';
}
int main(int argc, char** argv) {
int t;
cin >> t;
while(t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long s[500010], ss[500010];
map<long long, int> m;
vector<vector<int> > v;
int main() {
long long n, c = 1, cnt = 0;
cin >> n;
v.resize(n + 1);
for (int i = 1; i <= n; i++) scanf("%lld", &s[i]);
for (int i = n; i > 0; i--) {
ss[i] = s[i] + ss[i + 1];
if (!m[ss[i]]) m[ss[i]] = c++;
v[m[ss[i]]].push_back(i);
}
for (int i = 1; i <= n; i++) s[i] += s[i - 1];
for (int i = 1; i < c; i++) sort(v[i].begin(), v[i].end());
for (int i = 1; i <= n; i++) {
if (m[s[i]] && 3 * s[i] == s[n]) {
vector<int>::iterator idx =
lower_bound(v[m[s[i]]].begin(), v[m[s[i]]].end(), (i + 2));
cnt += v[m[s[i]]].size() - (idx - v[m[s[i]]].begin());
}
}
cout << cnt;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[26];
char s[100005];
bool compa(int a, int b) { return a > b; }
int main() {
long long res = 1;
bool z = false;
for (int i = 0; i < 26; i++) a[i] = 0;
cin >> s;
if (s[0] == '?')
res *= 9;
else if (s[0] == '0') {
res = 0;
cout << "0" << endl;
return 0;
} else if (s[0] >= '0' && s[0] <= '9')
;
else if (s[0] >= 'A' && s[0] <= 'J') {
a[s[0] - 'A']++;
z = true;
}
for (int i = 1; s[i] != '\0'; i++)
if (s[i] == '?')
res *= 10;
else if (s[i] >= 'A' && s[i] <= 'J')
a[s[i] - 'A']++;
sort(a, a + 20, compa);
int j = 10;
for (int i = 0; i <= 9 && a[i] != 0; i++) {
res *= j;
j--;
}
if (z) {
res /= 10;
res *= 9;
}
cout << res << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
template <class T>
void dbs(string str, T t) {
cout << str << " : " << t << endl;
}
template <class T, class... second>
void dbs(string str, T t, second... s) {
int idx = str.find(',');
cout << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class second, class T>
ostream& operator<<(ostream& os, const pair<second, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class second, class T>
ostream& operator<<(ostream& os, const map<second, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void prc(T a, T b) {
cout << "[";
for (T i = a; i != b; ++i) {
if (i != a) cout << ", ";
cout << *i;
}
cout << "]";
cout << endl;
}
vector<vector<int> > v;
int dfs(int node, vector<int>& visited, vector<int>& active) {
visited[node] = active[node] = 1;
int g = 0;
for (int i = 0; i < v[node].size(); i++) {
if (active[v[node][i]])
g++;
else if (!visited[v[node][i]])
g += dfs(v[node][i], visited, active);
}
active[node] = 0;
return g;
}
int main() {
int n, m;
cin >> n >> m;
v.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x - 1].push_back(y - 1);
}
for (int i = 0; i < n; i++) {
vector<int> visited(n, 0), active(n, 0);
int g = 0;
g += dfs(i, visited, active);
for (int j = 0; j < n; j++) {
if (!visited[j]) g += dfs(j, visited, active);
}
if (g <= 1) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int m = 2 * k + 1;
int l = n / m;
int rest = n % m;
if (!rest) {
rest = 2 * k;
} else {
l++;
}
cout << l << endl;
for (int i = rest / 2 + 1; i <= n; i = i + m) {
cout << i << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int dxx[] = {1, -1, 0, 0};
long long int dyy[] = {0, 0, -1, 1};
long long int modexpo(long long int x, long long int y) {
if (y == 0) return 1;
if (y % 2) {
long long int viky = modexpo(x, y / 2);
return (((x * viky) % 1000000007) * viky) % 1000000007;
} else {
long long int viky = modexpo(x, y / 2);
return (viky * viky) % 1000000007;
}
}
long long int presum[200011], sufsum[200011];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, i, j, l, r, q, k, kk, m, n, p;
cin >> n;
long long int ap[n + 11];
long long int sum = 0;
for (i = 0; i < n; i++) {
cin >> ap[i];
sum += ap[i];
}
presum[0] = ap[0];
for (i = 1; i < n; i++) {
presum[i] = presum[i - 1] + ap[i];
}
sufsum[0] = ap[n - 1];
k = 1;
for (i = n - 2; i >= 0; i--) {
sufsum[k] = sufsum[k - 1] + ap[i];
k++;
}
long long int ans = 0;
for (i = 0; i < n; i++) {
if (binary_search(sufsum, sufsum + k, presum[i]) &&
(2 * presum[i]) <= sum) {
ans = presum[i];
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N1 = 2e5 + 10;
int code() {
long long n, d;
string s;
cin >> n >> d >> s;
int cnt = 0;
long long i = 0;
while (i < n - 1) {
bool flag = 0;
for (long long j = min(i + d, n - 1); j > i; --j) {
if (s[j] == '1') {
++cnt, i = j;
flag = 1;
break;
}
}
if (flag == 0) {
cout << -1;
return 0;
}
}
cout << cnt;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tc = 1;
for (long long i = 0; i < (tc); ++i) code();
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double inf = 2000000000;
const int pr = 1993;
using namespace std;
long long res;
int n, m;
int a[100005];
bool w[100005];
vector<int> ord, g[100005];
bool cmp(int u, int v) { return a[u] > a[v]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ord.push_back(i);
}
for (int i = 1, v, u; i <= m; i++) {
cin >> v >> u;
g[v].push_back(u);
g[u].push_back(v);
}
sort(ord.begin(), ord.end(), cmp);
for (int j = 0; j < n; j++) {
int v = ord[j];
w[v] = true;
for (int i = 0; i < g[v].size(); i++)
if (!w[g[v][i]]) res += a[g[v][i]];
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n][n];
long long int i = 0;
long long int k = 0;
map<long long int, long long int> m;
for (i = 0; i < n; i++) {
long long int h = k;
for (long long int j = 0; j < n; j++) {
m[h]++;
a[i][j] = h;
h = h + 4;
}
while (m[k] != 0) {
k++;
}
}
for (i = 0; i < n; i++) {
long long int out = 0;
for (long long int j = 0; j < n; j++) {
cout << a[i][j] << " ";
out = out ^ a[j][i];
}
cout << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int root = 3;
const int maxn = 1 << 20;
int f[maxn];
inline int sub(const int& a, const int& b) {
return a < b ? a - b + mod : a - b;
}
inline int add(const int& a, const int& b) { return sub(a, mod - b); }
inline int mul(const int& a, const int& b) { return 1LL * a * b % mod; }
inline int fpow(int a, int n) {
if (n < 0) n = (2LL - mod) * n % (mod - 1);
int ret = 1;
while (n) {
if (n & 1) ret = mul(ret, a);
a = mul(a, a);
n >>= 1;
}
return ret;
}
inline void to_pow2(int& x) {
while (x ^ (x & -x)) x += (x & -x);
}
inline void bit_reverse(int f[], int size) {
for (int i = 1, j = size >> 1; i ^ size - 1; ++i) {
if (i < j) swap(f[i], f[j]);
int k = size >> 1;
while (j >= k) {
j -= k;
k >>= 1;
}
if (j < k) j += k;
}
}
inline void ntt(int f[], int size, int op = 1) {
bit_reverse(f, size);
for (int i = 2; i <= size; i <<= 1) {
int wn = fpow(root, op * (1 - mod) / i);
for (int j = 0; j ^ size; j += i) {
int w = 1;
for (int k = j; k ^ j + (i >> 1); ++k) {
int u = f[k];
int v = mul(w, f[k + (i >> 1)]);
f[k] = add(u, v);
f[k + (i >> 1)] = sub(u, v);
w = mul(w, wn);
}
}
}
if (!~op) {
int inv = fpow(size, -1);
for (int i = 0; i ^ size; ++i) f[i] = mul(f[i], inv);
}
}
int main() {
int n, k;
cin >> n >> k;
while (k--) {
int d;
cin >> d;
f[d] = 1;
}
int size = n * 5;
to_pow2(size);
ntt(f, size);
for (int i = 0; i ^ size; ++i) f[i] = fpow(f[i], n >> 1);
ntt(f, size, -1);
int res = 0;
for (int i = 0; i ^ size; ++i) res = add(res, mul(f[i], f[i]));
cout << res << endl;
}
| 16 |
#include <bits/stdc++.h>
int max(int x, int y) { return (x > y ? y : x); }
int geGcd(int a, int b) {
if (a == 0 || b == 0) return 0;
for (int i = max(a, b); i >= 1; i--)
if (a % i == 0 && b % i == 0) return i;
}
using namespace std;
int main() {
int a, b, n;
cin >> a >> b >> n;
int cnt = 0;
while (n > 0) {
if (geGcd(a, n)) {
n -= geGcd(a, n);
cnt++;
}
if (geGcd(b, n)) {
n -= geGcd(b, n);
cnt++;
}
}
if (cnt % 2 == 0)
cout << "1";
else
cout << "0";
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
void qread(int &x) {
int neg = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = 10 * x + c - '0', c = getchar();
x *= neg;
}
const int maxn = 200005;
const int mlog = 20;
int n, m, q, tot;
int a[maxn], dlt[maxn], ans[maxn];
class Event {
public:
int t, l, r, tp, id;
Event() {}
Event(int _t, int _l, int _r, int _tp, int _id)
: t(_t), l(_l), r(_r), tp(_tp), id(_id) {}
bool operator<(const Event &o) const { return t < o.t; }
} e[maxn];
namespace ST {
int mn[maxn][mlog], lg2[maxn];
void init(int *h) {
lg2[0] = 0;
for (int(i) = 1; (i) <= m; i++) {
lg2[i] = lg2[i - 1];
if (i == (1 << lg2[i] + 1)) lg2[i]++;
}
for (int(i) = 0; (i) < m; i++) mn[i][0] = h[i];
for (int(j) = 1; (j) <= mlog - 1; j++)
for (int(i) = 0; (i) < m; i++) {
if (i + (1 << j - 1) >= m)
mn[i][j] = 1e9;
else
mn[i][j] = min(mn[i][j - 1], mn[i + (1 << j - 1)][j - 1]);
}
}
int ask(int l, int r) {
r--;
if (l > r) return 1e9;
int len = lg2[r - l + 1];
return min(mn[l][len], mn[r - (1 << len) + 1][len]);
}
} // namespace ST
namespace BIT {
int t[maxn];
void init() {
for (int(i) = 1; (i) <= m; i++) t[i] = 0;
}
void add(int v) {
for (v++; v <= m; v += (v & -v)) t[v]++;
}
int sum(int v) {
int res = 0;
for (v++; v; v -= (v & -v)) res += t[v];
return res;
}
} // namespace BIT
namespace SA {
int sz;
int rk[maxn], sa[maxn], lcp[maxn], sum[maxn], tmp[maxn];
pair<int, int> cur[maxn];
map<int, int> num;
void rsort() {
int mx = 0;
for (int(i) = 0; (i) < m; i++)
sum[cur[i].second]++, mx = max(mx, cur[i].second);
for (int(i) = 1; (i) <= mx; i++) sum[i] += sum[i - 1];
for (int i = m - 1; i >= 0; i--) tmp[--sum[cur[i].second]] = i;
for (int(i) = 0; (i) < mx + 1; i++) sum[i] = 0;
mx = 0;
for (int(i) = 0; (i) < m; i++)
sum[cur[tmp[i]].first]++, mx = max(mx, cur[tmp[i]].first);
for (int(i) = 1; (i) <= mx; i++) sum[i] += sum[i - 1];
for (int i = m - 1; i >= 0; i--) sa[--sum[cur[tmp[i]].first]] = tmp[i];
for (int(i) = 0; (i) < mx + 1; i++) sum[i] = 0;
rk[sa[0]] = 0;
for (int(i) = 1; (i) <= m - 1; i++)
rk[sa[i]] = rk[sa[i - 1]] + (cur[sa[i]] == cur[sa[i - 1]] ? 0 : 1);
}
void work(int *a) {
for (int(i) = 0; (i) < m; i++) num[a[i]] = 0;
sz = 0;
for (map<int, int>::iterator it = num.begin(); it != num.end(); it++)
it->second = sz++;
for (int(i) = 0; (i) < m; i++)
a[i] = num[a[i]], cur[i] = make_pair(a[i], a[i]);
rsort();
for (int k = 1; k <= m; k <<= 1) {
for (int(i) = 0; (i) < m; i++)
cur[i] = make_pair(rk[i] + 1, i + k >= m ? 0 : rk[i + k] + 1);
rsort();
}
int h = 0;
for (int(i) = 0; (i) < m; i++) {
if (rk[i] == 0) continue;
int j = sa[rk[i] - 1];
if (h) h--;
while (i + h < m && j + h < m && a[i + h] == a[j + h]) h++;
lcp[rk[i] - 1] = h;
}
}
} // namespace SA
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < n; i++) scanf("%d", &a[i]);
m = 2 * n - 2;
for (int(i) = 0; (i) < n - 1; i++) {
dlt[i] = a[i + 1] - a[i];
dlt[i + n - 1] = -dlt[i];
}
SA::work(dlt);
ST::init(SA::lcp);
scanf("%d", &q);
for (int(i) = 0; (i) < q; i++) {
int ql, qr, cl, cr;
scanf("%d%d", &ql, &qr);
ql--;
qr--;
if (ql == qr) {
ans[i] = n - 1;
continue;
}
int l = -1, r = SA::rk[ql];
while (r - l > 1) {
int mid = (l + r) >> 1;
if (ST::ask(mid, SA::rk[ql]) >= qr - ql)
r = mid;
else
l = mid;
}
cl = r;
l = SA::rk[ql];
r = m;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (ST::ask(SA::rk[ql], mid) >= qr - ql)
l = mid;
else
r = mid;
}
cr = l;
e[tot++] = Event(cl - 1, ql, qr, -1, i);
e[tot++] = Event(cr, ql, qr, 1, i);
}
sort(e, e + tot);
int ptr = 0;
for (int(i) = 0; (i) < tot; i++) {
while (ptr < m && ptr <= e[i].t) {
if (SA::sa[ptr] >= n - 1) BIT::add(SA::sa[ptr] - (n - 1));
ptr++;
}
int ql = e[i].l, qr = e[i].r;
ans[e[i].id] += e[i].tp * BIT::sum(max(-1, ql - (qr - ql + 1)));
ans[e[i].id] += e[i].tp * (BIT::sum(n - 1) - BIT::sum(qr));
}
for (int(i) = 0; (i) < q; i++) printf("%d\n", ans[i]);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m, i, j, a, b, o = 0, e = 0, o1 = 0, e1 = 0, c, d;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a;
if (a % 2 == 1)
o++;
else
e++;
}
for (j = 0; j < m; j++) {
cin >> b;
if (b % 2 == 1)
o1++;
else
e1++;
}
c = min(o, e1);
d = min(o1, e);
cout << c + d;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, a[N];
vector<pair<vector<int>, int>> c;
int main() {
scanf("%d", &n);
vector<int> x(n - 1);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0, u; i < 32768; i++) {
u = __builtin_popcount((a[1] & 32767) ^ i);
for (int j = 2; j <= n; j++)
x[j - 2] = __builtin_popcount((a[j] & 32767) ^ i) - u;
c.emplace_back(x, i);
}
sort(c.begin(), c.end());
for (int i = 0, u; i < 32768; i++) {
u = __builtin_popcount((a[1] >> 15) ^ i);
for (int j = 2; j <= n; j++)
x[j - 2] = u - __builtin_popcount((a[j] >> 15) ^ i);
auto it = lower_bound(c.begin(), c.end(), make_pair(x, 0));
if (it != c.end() && (*it).first == x)
return printf("%d\n", (i << 15) | it->second), 0;
}
return puts("-1"), 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) {
if (b == 0) return a;
return (a % b == 0 ? b : GCD(b, a % b));
}
long long POW(long long base, long long exp) {
long long val;
val = 1;
while (exp > 0) {
if (exp % 2 == 1) {
val = (val * base) % 1000000007;
}
base = (base * base) % 1000000007;
exp = exp / 2;
}
return val;
}
queue<int> q[200005];
vector<int> ans;
int main() {
int n, num, i, idx, ask;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &num);
q[num].push(i + 1);
}
ask = 0;
while (1) {
if (!q[ask].empty()) {
idx = q[ask].front();
q[ask].pop();
ans.push_back(idx);
ask += 1;
} else {
if (ask < 3) {
break;
} else {
ask = ask - 3;
}
}
}
if (ans.size() == n) {
printf("Possible\n");
for (i = 0; i < n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
} else {
printf("Impossible\n");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long Inf = 1ll << 60ll;
namespace io {
char buf[(1 << 23)], *p1 = buf, *p2 = buf, c;
int f;
template <typename T>
T read() {
T x = 0;
f = 0;
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, (1 << 23), stdin), p1 == p2)
? EOF
: *p1++);
while (!isdigit(c))
(c == '-') && (f = 1),
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, (1 << 23), stdin),
p1 == p2)
? EOF
: *p1++);
while (isdigit(c))
x = x * 10 + (c & 15),
c = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, (1 << 23), stdin), p1 == p2)
? EOF
: *p1++);
return f ? -x : x;
}
} // namespace io
int r, s, p;
double dp[101][101][101], ansR, ansS, ansP;
int main() {
r = io::read<int>();
s = io::read<int>();
p = io::read<int>();
dp[r][s][p] = 1.0;
for (int R = r; ~R; --R) {
for (int S = s; ~S; --S) {
for (int P = p; ~P; --P) {
int tot = R * S + S * P + P * R;
if (R && S) dp[R][S - 1][P] += dp[R][S][P] * R * S / tot;
if (S && P) dp[R][S][P - 1] += dp[R][S][P] * S * P / tot;
if (P && R) dp[R - 1][S][P] += dp[R][S][P] * P * R / tot;
if (R && !S && !P) ansR += dp[R][S][P];
if (!R && S && !P) ansS += dp[R][S][P];
if (!R && !S && P) ansP += dp[R][S][P];
}
}
}
printf("%.12lf %.12lf %.12lf\n", ansR, ansS, ansP);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3e5 + 10;
struct Segment {
int l, r;
pair<long long, long long> num;
} tree[maxN * 30 + 1];
struct Node {
int x, op, a, b;
Node(int X = 0, int Y = 0, int Z = 0, int W = 0) {
x = X;
op = Y;
a = Z;
b = W;
}
} a[maxN + 1];
int n, m, cnt;
int tmp[maxN + 1], res, root[maxN + 1];
inline int read() {
int num = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
return num * f;
}
inline bool comp(Node a, Node b) { return a.x < b.x; }
inline pair<long long, long long> ADD(pair<long long, long long> a,
pair<long long, long long> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
inline void pushup(int node) {
tree[node].num = ADD(tree[tree[node].l].num, tree[tree[node].r].num);
}
inline int build(int l, int r) {
int node = ++cnt;
if (l == r) {
tree[node].num = make_pair(0, 0);
return node;
}
int mid = (l + r) >> 1;
tree[node].l = build(l, mid);
tree[node].r = build(mid + 1, r);
pushup(node);
return node;
}
inline int change(int pre, int l, int r, int x,
pair<long long, long long> num) {
int node = ++cnt;
if (l == r) {
tree[node].num = num;
return node;
}
int mid = (l + r) >> 1;
tree[node].l = tree[pre].l;
tree[node].r = tree[pre].r;
if (x <= mid)
tree[node].l = change(tree[pre].l, l, mid, x, num);
else
tree[node].r = change(tree[pre].r, mid + 1, r, x, num);
pushup(node);
return node;
}
inline pair<long long, long long> query(int node, int l, int r, int x, int y) {
if (!node) return make_pair(0, 0);
if (x <= l && r <= y) return tree[node].num;
int mid = (l + r) >> 1;
pair<long long, long long> ans = make_pair(0, 0);
if (x <= mid) ans = ADD(ans, query(tree[node].l, l, mid, x, y));
if (y > mid) ans = ADD(ans, query(tree[node].r, mid + 1, r, x, y));
return ans;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int l = read() + 1, r = read() + 1, ya = read(), ta = read(), tb = read(),
yb = read();
a[++res] = Node(0, i, 0, ya);
a[++res] = Node(l, i, ta, tb);
a[++res] = Node(r, i, 0, yb);
}
sort(a + 1, a + res + 1, comp);
root[0] = build(1, n);
for (int i = 1; i <= res; i++) {
tmp[i] = a[i].x;
root[i] = change(root[i - 1], 1, n, a[i].op, make_pair(a[i].a, a[i].b));
}
long long last = 0, mod = 1e9;
m = read();
while (m--) {
int l = read(), r = read(), x = (read() + last) % mod;
int t = upper_bound(tmp + 1, tmp + res + 1, x) - tmp - 1;
pair<long long, long long> ans = query(root[t], 1, n, l, r);
printf("%lld\n", last = 1ll * ans.first * x + ans.second);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
set<string> st;
int main(int argc, char *argv[]) {
int n;
string s;
int ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> s, mp[s]++, st.insert(s);
for (int i = 1; i <= n; i++) cin >> s, mp[s]--;
set<string>::iterator it;
for (it = st.begin(); it != st.end(); it++) {
if (mp[*it] > 0) ans += mp[*it];
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
map<char, int> freq;
string types = "ACGT";
for (int i = 0; i < n; i++) {
if (s[i] != '?') freq[s[i]]++;
}
for (int i = 0; i < n; i++)
if (s[i] == '?') {
int maxFreq = -1;
bool isEqual = true;
for (int j = 0; j < 4; j++) {
int curFreq = freq[types[j]];
if (maxFreq == -1 || maxFreq < curFreq) {
maxFreq = curFreq;
}
if (curFreq != maxFreq) {
isEqual = false;
}
}
if (isEqual) {
s[i] = 'A';
freq['A']++;
} else {
for (int j = 0; j < 4; j++) {
if (freq[types[j]] < maxFreq) {
s[i] = types[j];
freq[types[j]]++;
break;
}
}
}
}
map<char, int> newFreq;
for (int i = 0; i < n; i++) newFreq[s[i]]++;
int value = -1;
bool isValid = true;
for (int i = 0; i < 4; i++) {
int f = newFreq[types[i]];
if (value == -1) value = f;
if (f != value) {
isValid = false;
}
}
if (isValid)
cout << s << "\n";
else
cout << "==="
<< "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long q[10000010], ans[10000010];
int main() {
long long p, k;
scanf("%lld%lld", &p, &k);
q[0] = -p / k;
ans[0] = p % k;
int maxd = 0;
bool no_sol = false;
if (q[0] >= k || q[0] < 0) {
for (int d = 1; !no_sol; d++) {
maxd = d;
if (q[d - 1] < 0) {
q[d] = (k - 1 - q[d - 1]) / k;
} else {
q[d] = -q[d - 1] / k;
}
ans[d] = q[d - 1] + q[d] * k;
if (ans[d] >= k)
no_sol = true;
else if (q[d] < k && q[d] >= 0) {
break;
}
}
} else {
puts("1");
printf("%lld\n", ans[0]);
exit(0);
}
if (no_sol)
puts("-1");
else {
printf("%d\n", maxd + 2);
ans[maxd + 1] = q[maxd];
for (int i = 0; i <= maxd + 1; i++) printf("%lld ", ans[i]);
puts("");
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int moveX[4] = {0, 1, 0, -1};
int moveY[4] = {1, 0, -1, 0};
int r, c;
string board[1005];
int men;
int ans;
int vis[1005][1005];
queue<pair<int, int> > Q;
void solve(int x, int y) {
for (int i = int(0); i < int(r); i++)
for (int j = int(0); j < int(c); j++) vis[i][j] = 0;
Q.push(make_pair(x, y));
int actX, actY, nxtX, nxtY;
while (!Q.empty()) {
actX = Q.front().first;
actY = Q.front().second;
Q.pop();
for (int i = int(0); i < int(4); i++) {
nxtX = actX + moveX[i];
nxtY = actY + moveY[i];
if (nxtX >= 0 && nxtX < r && nxtY >= 0 && nxtY < c &&
board[nxtX][nxtY] != 'T' && (nxtX != x || nxtY != y) &&
!vis[nxtX][nxtY]) {
vis[nxtX][nxtY] = vis[actX][actY] + 1;
if (board[nxtX][nxtY] > '0' && board[nxtX][nxtY] <= '9' &&
vis[nxtX][nxtY] <= men) {
ans += board[nxtX][nxtY] - '0';
}
Q.push(make_pair(nxtX, nxtY));
}
}
}
}
int bfs(int x, int y) {
Q.push(make_pair(x, y));
int actX, actY, nxtX, nxtY;
while (!Q.empty()) {
actX = Q.front().first;
actY = Q.front().second;
Q.pop();
for (int i = int(0); i < int(4); i++) {
nxtX = actX + moveX[i];
nxtY = actY + moveY[i];
if (nxtX >= 0 && nxtX < r && nxtY >= 0 && nxtY < c &&
board[nxtX][nxtY] != 'T' && (nxtX != x || nxtY != y) &&
!vis[nxtX][nxtY]) {
vis[nxtX][nxtY] = vis[actX][actY] + 1;
if (board[nxtX][nxtY] == 'E') {
while (!Q.empty()) Q.pop();
return vis[nxtX][nxtY];
}
Q.push(make_pair(nxtX, nxtY));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> r >> c;
for (int i = int(0); i < int(r); i++) {
cin >> board[i];
}
pair<int, int> e;
for (int i = int(0); i < int(r); i++)
for (int j = int(0); j < int(c); j++) {
if (board[i][j] == 'S')
men = bfs(i, j);
else if (board[i][j] == 'E')
e = make_pair(i, j);
}
solve(e.first, e.second);
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (long long i = 0; i < 2e8; i++)
;
int n;
scanf("%d", &n);
int a[20];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 0; i < n; i++) printf("%d ", a[i]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n), lst(n + 1, -1), dist(n + 1, -1);
vector<int> ans(n + 1, INT_MAX);
for (int i = 0; i < n; i++) {
cin >> a[i];
if (lst[a[i]] == -1)
dist[a[i]] = i + 1;
else
dist[a[i]] = max(dist[a[i]], i - lst[a[i]]);
lst[a[i]] = i;
}
for (int i = 0; i < n; i++) {
dist[a[i]] = max(dist[a[i]], n - lst[a[i]]);
}
for (int i = 1; i <= n; i++) {
if (dist[i] == -1) {
continue;
} else
ans[dist[i]] = min(i, ans[dist[i]]);
}
int i = 1;
while (ans[i] == INT_MAX) {
cout << "-1"
<< " ";
i++;
}
while (i <= n) {
ans[i] = min(ans[i], ans[i - 1]);
cout << ans[i] << " ";
i++;
}
cout << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
int n;
int b[N], ans[N];
pair<int, int> a[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
b[n + 1] = b[1];
for (int i = 1; i <= n; i++) {
a[i] = make_pair(b[i] + b[i + 1], i - 1);
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) ans[a[i].second] = i - 1;
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
static const int mod = 1e9 + 7;
void cj() {
int tt;
cin >> tt;
for (int qq = 1; qq <= tt; ++qq) {
cout << "Case #" << qq << ": ";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, s;
cin >> n >> s;
int mx = -1;
int sum = 0;
for (int i = 0; i < n; ++i) {
int t;
cin >> t;
sum += t;
mx = max(mx, t);
}
sum -= mx;
if (s - sum >= 0) {
cout << "YES" << '\n';
;
} else {
cout << "NO" << '\n';
;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m, rb, cb, rd, cd, s, r, c, c1, r1;
cin >> t;
while (t) {
cin >> n >> m >> rb >> cb >> rd >> cd;
if (cd >= cb) {
c = cd - cb;
} else {
c = cb - cd;
c1 = 2 * (m - cb);
c = c + c1;
}
if (rd >= rb) {
r = rd - rb;
} else {
r = rb - rd;
r1 = 2 * (n - rb);
r = r + r1;
}
if (c < r)
cout << c;
else
cout << r;
cout << endl;
t--;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
typedef struct {
long long num;
int sub;
bool gaboleh0;
} store_num;
using namespace std;
int n;
long long res = 0;
store_num num[10] = {};
bool compare(store_num num1, store_num num2) { return num1.num > num2.num; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = (int)0; i < (int)n; i++) {
string temp;
cin >> temp;
int power10 = 1;
while (temp.size() > 0) {
int X = (int)temp[temp.size() - 1] - 'a';
num[X].num += power10;
temp.pop_back();
power10 *= 10;
if (temp.size() == 0) {
num[X].gaboleh0 = true;
}
}
}
sort(num, num + 10, compare);
bool zero_placed = false;
for (int i = (int)0; i < (int)10; i++) {
if (zero_placed) {
num[i].sub = i;
} else {
if (num[i].gaboleh0) {
num[i].sub = i + 1;
} else {
num[i].sub = 0;
zero_placed = true;
}
}
}
for (int i = (int)0; i < (int)10; i++) {
res += num[i].sub * num[i].num;
}
cout << res << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = int(3e5) + 99;
int n, m, k;
int arr[MAXN];
long long bst[MAXN];
long long psum[MAXN];
long long sum(int l, int r) {
l = max(l, 0);
return psum[r] - (l == 0 ? 0 : psum[l - 1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
psum[i] = arr[i] + (i == 0 ? 0 : psum[i - 1]);
}
long long res = 0;
for (int len = 1; len <= m && len <= n; ++len) {
res = max(res, sum(0, len - 1) - k);
}
for (int i = 0; i < n; ++i) {
if (i + 1 >= m) {
long long nbst = sum(i - m + 1, i) - k;
if (i - m >= 0) nbst += bst[i - m];
bst[i] = max(bst[i], +nbst);
}
for (int len = 0; len < m && i + len < n; ++len) {
res = max(res, bst[i] + sum(i + 1, i + len) - k * (len > 0));
}
}
cout << res << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t, i, a, b, c, sum;
cin >> t;
int d[t];
for (i = 0; i < t; i++) {
cin >> a >> b >> c;
sum = (a - b) * 2;
if (sum < 0) {
sum = -sum;
}
if (sum < 4 || max(a, max(b, c)) > sum) {
d[i] = -1;
} else {
if (c <= sum / 2) {
d[i] = c + sum / 2;
} else {
d[i] = c + sum / 2 - sum;
}
}
}
for (i = 0; i < t; i++) {
cout << d[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int s[maxn], g[maxn];
int l[maxn], r[maxn];
int ans[maxn];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i] >> g[i];
if (i == 0) {
l[i] = s[i];
r[i] = s[i] + g[i];
} else {
l[i] = max(l[i - 1] - 1, s[i]);
r[i] = min(r[i - 1] + 1, s[i] + g[i]);
}
if (l[i] > r[i]) {
cout << -1 << endl;
return 0;
}
}
ans[n - 1] = r[n - 1];
long long res = (long long)ans[n - 1] - s[n - 1];
for (int i = n - 2; i >= 0; i--) {
if (ans[i + 1] + 1 <= r[i]) {
ans[i] = ans[i + 1] + 1;
} else if (ans[i + 1] <= r[i]) {
ans[i] = ans[i + 1];
} else
ans[i] = ans[i + 1] - 1;
res += (long long)ans[i] - s[i];
}
cout << res << endl;
cout << ans[0];
for (int i = 1; i < n; i++) {
cout << " " << ans[i];
}
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> pwr;
int main() {
int t, n;
cin >> t;
while (t--) {
pwr.clear();
cin >> n;
int a, ans = 0;
for (int i = 0; i < n; i++) {
cin >> a;
int two_cnt = 0;
while (a % 2 == 0) {
two_cnt++;
a /= 2;
}
if (two_cnt > pwr[a]) {
ans -= pwr[a];
ans += two_cnt;
pwr[a] = two_cnt;
}
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool visited[150000];
vector<vector<int>> lst(150000);
long long nodes = 0;
long long edges = 0;
void dfs(int e) {
nodes++;
visited[e] = true;
for (int p = 0; p < lst[e].size(); p++) {
edges++;
if (!visited[lst[e][p]]) dfs(lst[e][p]);
}
}
void makefalse() {
for (int i = 0; i < 150000; i++) visited[i] = false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
;
lst.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
lst[x - 1].push_back(y - 1);
lst[y - 1].push_back(x - 1);
}
makefalse();
for (int i = 0; i < n; i++) {
if (!visited[i]) {
nodes = 0;
edges = 0;
dfs(i);
}
long long ans = (nodes * (nodes - 1));
if (ans != edges) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, n2, a = 0, b;
cin >> n;
n2 = n;
while (n2 > 0) {
n2 = n2 / 10;
a++;
}
b = pow(10, a);
if ((n % b > 0) && (a > 1))
cout << (b / 10) - (n % (b / 10));
else
cout << 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
long long GCD(long long a, long long b) { return (b == 0) ? a : GCD(b, a % b); }
inline long long LCM(long long a, long long b) { return a / GCD(a, b) * b; }
inline long long normalize(long long x, long long mod) {
x %= mod;
if (x < 0) x += mod;
return x;
}
struct GCD_type {
long long x, y, d;
};
GCD_type ex_GCD(long long a, long long b) {
if (b == 0) return {1, 0, a};
GCD_type pom = ex_GCD(b, a % b);
return {pom.y, pom.x - a / b * pom.y, pom.d};
}
int main() {
long long n, m, x, y, vx, vy;
cin >> n >> m >> x >> y >> vx >> vy;
long long a1, a2;
if (vx == 1) {
a1 = n - x;
} else {
a1 = x;
}
if (vy == 1) {
a2 = m - y;
} else {
a2 = y;
}
if (vx == 0) {
if (x == 0) {
if (vy == 1) {
cout << 0 << " " << m << endl;
} else {
cout << 0 << " " << 0 << endl;
}
} else if (x == n) {
if (vy == 1) {
cout << n << " " << m << endl;
} else {
cout << n << " " << 0 << endl;
}
} else {
cout << -1 << endl;
}
return 0;
}
if (vy == 0) {
if (y == 0) {
if (vx == 1) {
cout << n << " " << 0 << endl;
} else {
cout << 0 << " " << 0 << endl;
}
} else if (y == m) {
if (vx == 1) {
cout << n << " " << m << endl;
} else {
cout << 0 << " " << m << endl;
}
} else {
cout << -1 << endl;
}
return 0;
}
normalize(a1, n);
normalize(a2, m);
auto pom = ex_GCD(n, m);
int x1 = pom.x;
int d = pom.d;
if ((a1 - a2) % d != 0) {
cout << -1 << endl;
return 0;
}
long long t = normalize(a1 + x1 * (a2 - a1) / d % (m / d) * n, n * m / d);
long long lcm = LCM(n, m);
long long p = (t - a1) / n;
long long q = (t - a2) / m;
int anx, any;
if (p % 2 == 0) {
anx = n;
} else {
anx = 0;
}
if (vx == -1) {
anx = n - anx;
}
if (q % 2 == 0) {
any = m;
} else {
any = 0;
}
if (vy == -1) {
any = m - any;
}
cout << anx << " " << any << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
using namespace std;
template <typename T>
void uin(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
void uax(T &a, T b) {
if (b > a) a = b;
}
const long long maxn = 100 * 1000 + 228, INF = 1e16 + 228;
long long n, L, S;
long long w[maxn], p[maxn][20], h[maxn], sum[maxn], lb[maxn], rb[maxn],
sz[maxn], timer = 0;
vector<long long> g[maxn];
void zhfs(long long v) {
if (v == 1)
h[v] = 0;
else
h[v] = h[p[v][0]] + 1;
sum[v] = sum[p[v][0]] + w[v];
for (long long k = 1; k < 20; ++k) {
p[v][k] = p[p[v][k - 1]][k - 1];
}
lb[v] = ++timer;
sz[v] = 1;
for (long long to : g[v]) {
zhfs(to);
sz[v] += sz[to];
}
rb[v] = lb[v] + sz[v] - 1;
}
struct node {
long long mn;
long long mod;
long long l, r;
node() { mn = mod = l = r = 0; }
};
vector<node> d;
void build(long long l, long long r, long long v = 1) {
d[v].l = l;
d[v].r = r;
if (l == r) return;
long long m = (l + r) >> 1;
build(l, m, v << 1);
build(m + 1, r, v << 1 | 1);
}
void init(long long n) {
long long ss = 1;
while (ss < n) ss <<= 1;
ss <<= 1;
d.resize(ss + 3, node());
build(1, n);
}
long long gets(long long v) { return d[v].mn + d[v].mod; }
void push(long long v) {
if (d[v].mod) {
d[v << 1].mod += d[v].mod;
d[v << 1 | 1].mod += d[v].mod;
d[v].mod = 0;
d[v].mn = min(gets(v << 1), gets(v << 1 | 1));
}
}
void update(long long l, long long r, long long x, long long v = 1) {
if (l > r || d[v].l > r || d[v].r < l) return;
if (l <= d[v].l && d[v].r <= r) {
d[v].mod += x;
} else {
push(v);
update(l, r, x, v << 1);
update(l, r, x, v << 1 | 1);
d[v].mn = min(gets(v << 1), gets(v << 1 | 1));
}
}
void Set(long long pos, long long x, long long v = 1) {
if (d[v].l == d[v].r) {
d[v].mn = x;
d[v].mod = 0;
return;
}
long long m = (d[v].l + d[v].r) >> 1;
push(v);
if (pos <= m)
Set(pos, x, v << 1);
else
Set(pos, x, v << 1 | 1);
d[v].mn = min(gets(v << 1), gets(v << 1 | 1));
}
long long get(long long l, long long r, long long v = 1) {
if (l > r || d[v].l > r || d[v].r < l) return INF;
if (l <= d[v].l && d[v].r <= r) return gets(v);
push(v);
return min(get(l, r, v << 1), get(l, r, v << 1 | 1));
}
long long get_up(long long v) {
long long k = 19;
long long st = v;
while (k >= 0) {
if (h[st] - h[p[v][k]] + 1 <= L &&
sum[st] - sum[p[v][k]] + w[p[v][k]] <= S) {
v = p[v][k];
}
--k;
}
while (v != 1 && h[st] - h[p[v][0]] + 1 <= L &&
sum[st] - sum[p[v][0]] + w[p[v][0]] <= S)
v = p[v][0];
return v;
}
vector<long long> woops[maxn];
long long up[maxn];
void prepare() {
for (long long v = 1; v <= n; ++v) {
up[v] = get_up(v);
woops[up[v]].push_back(v);
}
}
long long dp[maxn], dp_sum[maxn];
void dfs(long long v) {
for (long long to : g[v]) {
dfs(to);
dp_sum[v] += dp[to];
}
dp[v] = min(dp_sum[v] + 1, 1 + get(lb[v], rb[v]) + dp_sum[v]);
update(lb[v], rb[v], dp_sum[v] - dp[v]);
for (long long u : woops[v]) {
Set(lb[u], INF);
}
}
void solve() {
cin >> n >> L >> S;
bool ok = 1;
for (long long i = 1; i <= n; ++i) {
cin >> w[i];
if (w[i] > S) ok = 0;
}
for (long long i = 2; i <= n; ++i) {
cin >> p[i][0];
g[p[i][0]].push_back(i);
}
if (!ok) {
cout << -1 << '\n';
return;
}
p[1][0] = 1;
zhfs(1);
prepare();
init(n);
dfs(1);
cout << dp[1] << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a;
cin >> a;
char b[a][a];
for (int i = 0; i < a; i++) {
for (int j = 0; j < a; j++) {
if (i % 2 == 0) {
if (j % 2 == 0) {
b[i][j] = 'W';
} else
b[i][j] = 'B';
} else {
if (j % 2 != 0) {
b[i][j] = 'W';
} else
b[i][j] = 'B';
}
}
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < a; j++) {
cout << b[i][j];
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename num_t>
inline void add_mod(num_t& a, const long long& b, const int& m) {
a = (a + b) % m;
if (a < 0) a += m;
}
template <typename num_t>
inline bool update_max(num_t& a, const num_t& b) {
return a < b ? a = b, true : false;
}
template <typename num_t>
inline bool update_min(num_t& a, const num_t& b) {
return a > b ? a = b, true : false;
}
template <typename num_t>
num_t gcd(num_t lhs, num_t rhs) {
return !lhs ? rhs : gcd(rhs % lhs, lhs);
}
template <typename num_t>
num_t pw(num_t n, num_t k, num_t mod) {
num_t res = 1;
for (; k > 0; k >>= 1) {
if (k & 1) res = 1ll * res * n % mod;
n = 1ll * n * n % mod;
}
return res;
}
const int inf = 1e9 + 7;
const int mod = 1e9 + 7;
const long long ll_inf = 9ll * inf * inf;
const int max_n = 1e5 + 7;
void solve() {
int test;
cin >> test;
while (test-- > 0) {
int n;
cin >> n;
vector<int> a(n);
for (auto& p : a) {
cin >> p;
--p;
}
vector<vector<int>> pos(n);
vector<int> index(n);
for (int i = 0; i < n; ++i) {
index[i] = (int)(pos[a[i]]).size();
pos[a[i]].push_back(i);
}
const int mx_base = 20;
vector<vector<int>> dp(n, vector<int>(mx_base, inf));
vector<int> temp_dp(n, inf);
auto calc_best = [&](int u, int v) -> int {
if (u > v) return -1;
if (u >= v) return 0;
temp_dp[u] = 0;
for (int j = u + 1; j <= v; ++j) {
int cur = a[j];
temp_dp[j] = temp_dp[j - 1] + 1;
if (index[j] == 0 || pos[cur][index[j] - 1] < u) {
temp_dp[j] = temp_dp[j - 1] + 1;
} else {
for (int t = index[j] - 1; t >= 0 && pos[cur][t] >= u; --t) {
int prev_j = pos[cur][t];
int prev_cal = prev_j == u ? 0 : temp_dp[prev_j - 1] + 1;
update_min(temp_dp[j], prev_cal + dp[j][t]);
}
}
}
return temp_dp[v];
};
for (int i = 0; i < n; ++i)
if (index[i] > 0) {
auto& cur_pos = pos[a[i]];
dp[i][index[i]] = 0;
for (int t = index[i] - 1; t >= 0; --t) {
int now = calc_best(cur_pos[t] + 1, cur_pos[index[i]] - 1);
update_min(dp[i][t], now + 1);
for (int k = t + 1; k < index[i]; ++k) {
update_min(dp[i][t], dp[i][k] + dp[cur_pos[k]][t]);
}
}
}
cout << calc_best(0, n - 1) << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
if (n < 11)
cout << "NO" << endl;
else {
int p = n;
for (int i = 0; i < n; i++) {
if (s[i] == '8') {
p = i;
break;
}
}
if ((n - p) >= 11)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 12e5 + 3;
int Te[MAXN], Lz[MAXN], N, M, A, B, C;
void up(int idx, int v) {
if (!Lz[idx] || v == -1) Te[idx] = max(v, 0), Lz[idx] = max(v, 0);
}
void shift(int idx) {
up(idx * 2, Lz[idx]);
up(idx * 2 + 1, Lz[idx]);
Lz[idx] = Te[idx] = 0;
}
void update(int idx, int l1, int r1, int l, int r, int v) {
if (l > r1 || r < l1) return;
if (l >= l1 && r <= r1) {
up(idx, v);
return;
}
int md = (l + r) / 2;
shift(idx);
update(idx * 2, l1, r1, l, md, v);
update(idx * 2 + 1, l1, r1, md + 1, r, v);
}
int query(int idx, int l1, int r1, int l, int r) {
if (l > r1 || r < l1) return -1;
if (l >= l1 && r <= r1) return Te[idx];
int md = (l + r) / 2;
shift(idx);
return max(query(idx * 2, l1, r1, l, md),
query(idx * 2 + 1, l1, r1, md + 1, r));
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
scanf("%d %d %d", &A, &B, &C);
update(1, A - 1, B - 1, 0, N - 1, C);
update(1, C - 1, C - 1, 0, N - 1, -1);
}
for (int i = 0; i < N; i++) printf("%d ", query(1, i, i, 0, N - 1));
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
int main() {
int t;
cin>>t;
while(t--){
int n,c=0;
cin>>n;
while(n--){
int x;
cin>>x;
if(x==1 or x==3)
c++;
}
cout<<c<<endl;
}
return 0;
}
| 0 |
#include "bits/stdc++.h"
#define ll long long
#define pb push_back
using namespace std;
const int mxN = 300001;
int arr[mxN]; // input array
int cnt[mxN]; // cnt[x] = number of occurrences of x in the array
bool ans[mxN]; // the final answer
int n;
void solve() {
int n;
cin >> n;
for (int i = 0; i <= n; ++i) {
cnt[i] = 0;
ans[i] = 0;
}
for (int i = 0; i < n; ++i) {
cin >> arr[i];
arr[i]--;
cnt[arr[i]]++;
}
int tp = -1;
while (cnt[tp + 1] == 1)
tp++;
ans[0] = tp == n - 1;
int l = 0;
int r = n - 1;
ans[n - 1] = cnt[0] > 0;
for (int i = n - 1; i > 0; --i) {
if (!ans[n - 1]) break;
ans[i] = true;
int nxt = n - i - 1;
if (--cnt[nxt] == 0 && (arr[l] == nxt || arr[r] == nxt) && cnt[nxt + 1]) {
if (arr[l] == nxt)l++;
if (arr[r] == nxt)r--;
continue;
}
break;
}
for (int i = 0; i < n; ++i)
cout << ans[i];
cout << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--)
solve();
}
| 10 |
#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 = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int power(int x, int y) {
int t = 1;
for (; y; y >>= 1, x = x * x % 1000000007)
if (y & 1) t = t * x % 1000000007;
return t;
}
struct edge {
int go, next;
} e[600005];
int tot, head[300005];
void insert(int u, int v) {
e[++tot].go = v;
e[tot].next = head[u];
head[u] = tot;
e[++tot].go = u;
e[tot].next = head[v];
head[v] = tot;
}
int n, m;
struct te {
int to, dis, w;
} a[300005];
int next2[300005], head2[300005];
long long s[300005], ans[300005];
int dep[300005];
long long query(int x) {
long long ret = 0;
while (x) {
ret += s[x];
x -= x & (-x);
}
return ret;
}
void add(int x, int y) {
for (; x <= n; x += x & (-x)) s[x] += y;
}
void dfs1(int x, int fa) {
for (int i = head[x], y = e[i].go; i; i = e[i].next, y = e[i].go)
if (y != fa) {
dep[y] = dep[x] + 1;
dfs1(y, x);
}
}
void dfs(int x, int fa) {
for (int i = head2[x]; i; i = next2[i]) {
add(min(n, dep[x] + a[i].dis), a[i].w);
}
ans[x] = query(n) - query(dep[x] - 1);
for (int i = head[x], y = e[i].go; i; i = e[i].next, y = e[i].go)
if (y != fa) {
dfs(y, x);
}
for (int i = head2[x]; i; i = next2[i])
add(min(n, dep[x] + a[i].dis), -a[i].w);
}
int main() {
n = read();
for (int i = 1; i <= (n - 1); i++) {
int x = read(), y = read();
insert(x, y);
}
m = read();
for (int i = 1; i <= (m); i++) {
a[i].to = read();
a[i].dis = read();
a[i].w = read();
next2[i] = head2[a[i].to];
head2[a[i].to] = i;
}
dep[1] = 1;
dfs1(1, 0);
dfs(1, 0);
for (int i = 1; i <= (n); i++) printf("%I64d ", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {}
signed main() {
long long int n1, n2, k1, k2;
cin >> n1 >> n2 >> k1 >> k2;
if (n1 > n2)
cout << "First" << endl;
else
cout << "Second" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int va, num;
bool operator<(const node &o) const {
if (va != o.va) return va < o.va;
return num > o.num;
}
} a[2005];
int b[2005], n;
bool mark[2005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].va);
a[i].va = abs(a[i].va);
a[i].num = i;
}
sort(&a[0], &a[n]);
for (int i = 0; i < n; i++) {
int numP = 0;
int numN = 0;
for (int j = a[i].num + 1; j < n; j++) {
if (mark[j] && b[j] < a[i].va) {
numP++;
}
}
for (int j = a[i].num - 1; j >= 0; j--) {
if (mark[j] && b[j] > -a[i].va) {
numN++;
}
}
mark[a[i].num] = 1;
if (numP <= numN) {
b[a[i].num] = a[i].va;
} else {
b[a[i].num] = -a[i].va;
}
}
int num = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (b[i] > b[j]) {
num++;
}
}
}
printf("%d\n", num);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, q, i, j;
cin >> n >> m >> q;
string a, b;
cin >> a >> b;
vector<long long> v(n + 1);
for (i = 0; i <= n - m; i++) {
string tmp = a.substr(i, m);
if (tmp == b) v[i + 1] = 1;
}
for (i = 1; i <= n; i++) v[i] += v[i - 1];
while (q--) {
long long l, r, tot = 0;
cin >> l >> r;
r = r - m + 1;
long long ans = 0;
if (r >= l) ans = v[r] - v[l - 1];
cout << ans << endl;
}
}
| 5 |
#include <iostream>
using namespace std;
bool cal(string &a, int k)
{
int n=a.length(),count=0;
for(int i=0; i<n; i++)
{
int val=a[i]-'A';
if((k&(1<<val)))
count++;
else
count--;
if(count<0)
return 0;
}
if(count==0)
return 1;
return 0;
}
int main() {
// your code goes here
int t;
cin>>t;
while(t--)
{
string s;
cin>>s;
int ans=0;
for(int i=0;i<8;i++)
{
ans|=cal(s,i);
}
if(ans==1)
cout<<"YES\n";
else
cout<<"NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[3005];
int main() {
memset(a, 0, sizeof a);
int n, l = 0, h = 0;
cin >> n;
for (int i = 2; i <= 3005; i++) {
if (a[i] == 0) {
for (int j = i; j * i <= n; j++) {
a[j * i] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
l = 0;
for (int j = 2; j <= i; j++) {
if (i % j == 0 && a[j] == 0) {
l++;
}
}
if (l == 2) {
h++;
}
}
cout << h;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d\n", &t);
while (t--) {
int n;
scanf("%d\n", &n);
int a[n];
for (int i = 0; i < n; ++i) {
scanf("%d", &(a[i]));
}
std::sort(a, a + n);
int steps = 0;
int sum = std::accumulate(a, a + n, 0);
int numOfZeros = std::count(a, a + n, 0);
if (numOfZeros != 0) {
steps += numOfZeros;
sum += numOfZeros;
}
if (sum == 0) {
steps += 1;
}
printf("%d\n", steps);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
using namespace ::std;
const long long maxn = 5e5 + 500;
const long long inf = 1e17 + 800;
long long tav2(long long a) { return a * a; }
struct CHT {
struct line {
long long m, b;
long double x;
long long val;
bool isQuery;
line(long long _m = 0, long long _b = 0)
: m(_m), b(_b), val(0), x(-inf), isQuery(false) {}
long long eval(long long x) const { return m * x + b; }
bool parallel(const line &l) const { return m == l.m; }
long double intersect(const line &l) const {
return parallel(l) ? inf : 1.0 * (l.b - b) / (m - l.m);
}
bool operator<(const line &l) const {
if (l.isQuery)
return x < l.val;
else
return m < l.m;
}
};
set<line> hull;
bool cPrev(set<line>::iterator it) { return it != hull.begin(); }
bool cNext(set<line>::iterator it) {
return it != hull.end() && next(it) != hull.end();
}
bool bad(const line &l1, const line &l2, const line &l3) {
return l1.intersect(l3) <= l1.intersect(l2);
}
bool bad(set<line>::iterator it) {
return cPrev(it) && cNext(it) && bad(*prev(it), *it, *next(it));
}
set<line>::iterator update(set<line>::iterator it) {
if (!cPrev(it)) return it;
long double x = it->intersect(*prev(it));
line tmp(*it);
tmp.x = x;
it = hull.erase(it);
return hull.insert(it, tmp);
}
void addLine(long long m, long long b) {
line l(m, b);
set<line>::iterator it = hull.lower_bound(l);
if (it != hull.end() && l.parallel(*it)) {
if (it->b < b)
it = hull.erase(it);
else
return;
}
it = hull.insert(it, l);
if (bad(it)) return (void)hull.erase(it);
while (cPrev(it) && bad(prev(it))) hull.erase(prev(it));
while (cNext(it) && bad(next(it))) hull.erase(next(it));
it = update(it);
if (cPrev(it)) update(prev(it));
if (cNext(it)) update(next(it));
}
long long findMaxAt(long long x) const {
if (hull.empty()) return -inf;
line q;
q.val = x, q.isQuery = 1;
set<line>::iterator it = --hull.lower_bound(q);
return it->eval(x);
}
};
long long findAns(vector<pair<long long, long long> > vec) {
long long res = inf;
CHT er;
for (long long i = 0; i < (long long)vec.size(); i++) {
pair<long long, long long> v = vec[i];
res = min(res, -er.findMaxAt(v.second) + v.first);
er.addLine(-2 * v.second, -v.first);
}
return res;
}
vector<long long> ger[maxn];
long long dp[maxn];
long long sz[maxn];
long long par[maxn];
void dfs(long long a, long long p = -1) {
par[a] = p;
sz[a] = 1;
for (auto v : ger[a]) {
if (v != p) {
dfs(v, a);
sz[a] += sz[v];
}
}
dp[a] = tav2(sz[a]);
for (auto v : ger[a]) {
if (v != p) {
dp[a] = min(dp[a], dp[v] + tav2(sz[a] - sz[v]));
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 1; i < n; i++) {
long long v, u;
cin >> v >> u;
v--;
u--;
ger[v].push_back(u);
ger[u].push_back(v);
}
dfs(0);
long long ans = inf;
for (long long i = 0; i < n; i++) {
vector<pair<long long, long long> > vec;
for (auto v : ger[i]) {
if (v != par[i]) {
vec.push_back(make_pair(dp[v] + tav2(sz[v]) - 2 * n * sz[v], sz[v]));
ans = min(ans, dp[v] + tav2(n - sz[v]));
}
}
long long res = findAns(vec) + tav2(n);
ans = min(ans, res);
}
cout << (n * (n - 1)) / 2 + (tav2(n) - ans) / 2;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int t;
int n, k;
int a[200010], b[200010], pos[200010];
int qwq[200010];
int lst[200010], nxt[200010];
inline void rmain() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", a + i), pos[a[i]] = i, qwq[i] = 0;
for (int i = 1; i <= k; i++) scanf("%d", b + i), qwq[b[i]] = 1;
for (int i = 0; i <= n; i++) nxt[i] = i + 1, lst[i + 1] = i, a[i] = qwq[a[i]];
int ans = 1;
for (int i = 1; i <= k; i++) {
int cur = pos[b[i]], qwq = 0;
if (lst[cur] != 0 && a[lst[cur]] == 0) qwq++;
if (nxt[cur] != n + 1 && a[nxt[cur]] == 0) qwq++;
ans = ans * qwq % mod;
nxt[lst[cur]] = nxt[cur];
lst[nxt[cur]] = lst[cur];
}
printf("%d\n", ans);
}
int main() {
scanf("%d", &t);
while (t--) rmain();
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.