solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long N = 10000;
const long long M = 101;
map<pair<long long, long long>, pair<long long, long long> > rng;
string s;
long long termina[N];
long long sig[N];
map<pair<pair<long long, long long>, pair<long long, long long> >, long long>
memo;
map<pair<pair<long long, long long>, pair<long long, long long> >, bool> used;
long long dp(long long pos, long long tipo, long long posi, long long nega) {
if (used[{{pos, tipo}, {posi, nega}}]) {
return memo[{{pos, tipo}, {posi, nega}}];
}
used[{{pos, tipo}, {posi, nega}}] = true;
long long ans;
if (tipo == 0) {
ans = LLONG_MIN;
} else {
ans = LLONG_MAX;
}
if (termina[pos] - pos == 4) {
if (posi > 0) {
ans = (s[pos + 1] - '0') + (s[pos + 3] - '0');
} else {
ans = (s[pos + 1] - '0') - (s[pos + 3] - '0');
}
} else {
if (s[pos + 1] == '(' && s[termina[pos + 1] + 2] == '(') {
long long cnt = sig[termina[pos + 1]] - sig[pos + 1];
for (long long i = 0; i <= cnt; i++) {
if (i <= posi && cnt - i <= nega) {
if (tipo == 0) {
if (i < posi) {
ans = max(ans, dp(pos + 1, 0, i, cnt - i) +
dp(termina[pos + 1] + 2, 0, posi - i - 1,
nega - (cnt - i)));
}
if (cnt - i < nega) {
ans = max(ans, dp(pos + 1, 0, i, cnt - i) -
dp(termina[pos + 1] + 2, 1, posi - i,
nega - (cnt - i) - 1));
}
} else {
if (i < posi) {
ans = min(ans, dp(pos + 1, 1, i, cnt - i) +
dp(termina[pos + 1] + 2, 1, posi - i - 1,
nega - (cnt - i)));
}
if (cnt - i < nega) {
ans = min(ans, dp(pos + 1, 1, i, cnt - i) -
dp(termina[pos + 1] + 2, 0, posi - i,
nega - (cnt - i) - 1));
}
}
}
}
} else if (s[pos + 1] == '(' && s[termina[pos + 1] + 2] != '(') {
if (tipo == 0) {
if (posi > 0) {
ans = max(ans, dp(pos + 1, 0, posi - 1, nega) +
(s[termina[pos + 1] + 2] - '0'));
}
if (nega > 0) {
ans = max(ans, dp(pos + 1, 0, posi, nega - 1) -
(s[termina[pos + 1] + 2] - '0'));
}
} else {
if (posi > 0) {
ans = min(ans, dp(pos + 1, 1, posi - 1, nega) +
(s[termina[pos + 1] + 2] - '0'));
}
if (nega > 0) {
ans = min(ans, dp(pos + 1, 1, posi, nega - 1) -
(s[termina[pos + 1] + 2] - '0'));
}
}
} else {
if (tipo == 0) {
if (posi > 0) {
ans = max(ans, (s[pos + 1] - '0') + dp(pos + 3, 0, posi - 1, nega));
}
if (nega > 0) {
ans = max(ans, (s[pos + 1] - '0') - dp(pos + 3, 1, posi, nega - 1));
}
} else {
if (posi > 0) {
ans = min(ans, (s[pos + 1] - '0') + dp(pos + 3, 1, posi - 1, nega));
}
if (nega > 0) {
ans = min(ans, (s[pos + 1] - '0') - dp(pos + 3, 0, posi, nega - 1));
}
}
}
}
memo[{{pos, tipo}, {posi, nega}}] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
cout << fixed;
long long a, b;
cin >> s;
cin >> a >> b;
if (s.size() == 1) {
cout << s << endl;
return 0;
}
deque<long long> q;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == '(' || s[i] == ')') {
if (q.empty()) {
q.push_back(i);
} else {
if (s[q.back()] == '(' && s[i] == ')') {
termina[q.back()] = i;
q.pop_back();
} else {
q.push_back(i);
}
}
} else if (s[i] == '?') {
sig[i]++;
}
sig[i + 1] = sig[i];
}
cout << dp(0, 0, a, b) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
vector<int> v;
while (t--) {
vector<int> v;
int n, m = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
v.push_back(c);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size() - 1; i++)
if (v[i] == v[i + 1]) {
cout << 0 << "\n";
m++;
break;
}
int mn = 1000;
if (m == 0) {
for (int i = 0; i < v.size() - 1; i++)
for (int j = i + 1; j < v.size(); j++) mn = min(mn, abs(v[i] - v[j]));
}
if (m == 0) cout << mn << "\n";
v.clear();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 14 + 1;
const int mod = 1e9 + 7;
int sum(int a, int b) {
int c = a + b;
if (c >= mod) c -= mod;
return c;
}
int mul(int a, int b) { return 1ll * a * b % mod; }
int bpow(int a, int b) {
int r = 1;
for (; b; b /= 2) {
if (b % 2) r = mul(r, a);
a = mul(a, a);
}
return r;
}
int dp[N][(1 << N)];
int a[N];
int win[N][N];
int wmask[N][(1 << N)];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (i != j) win[i][j] = mul(a[i], bpow(sum(a[i], a[j]), mod - 2));
}
for (int i = 0; i < n; i++) {
wmask[i][0] = 1;
for (int mask = 1; mask < (1 << n); mask++) {
int j = __builtin_ctz(mask);
wmask[i][mask] = mul(win[j][i], wmask[i][mask ^ (1 << j)]);
}
}
for (int mask = 1; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++)
if ((mask >> i) & 1) dp[i][mask] = 1;
for (int bmask = ((mask - 1) & mask); bmask; bmask = ((bmask - 1) & mask)) {
int prob = 1;
for (int i = 0; i < n; i++)
if ((bmask >> i) & 1) prob = mul(prob, wmask[i][bmask ^ mask]);
for (int i = 0; i < n; i++)
if ((bmask >> i) & 1)
dp[i][mask] = sum(dp[i][mask], mod - mul(prob, dp[i][bmask]));
}
}
int ans = 0;
for (int i = 0; i < n; i++) ans = sum(ans, dp[i][(1 << n) - 1]);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int f(int n, int k) {
if (n == k && n > 1) return 4 * n - 5;
return 4;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", f(n, i) * f(m, j));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r;
cin >> n >> r;
int arr[n];
int heaters = 0;
int freq[n];
int start = -1, end = -1;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
freq[i] = 0;
if (arr[i] == 1) heaters++;
}
for (int i = 0; i < n; ++i) {
if (arr[i] == 1) {
for (int j = i - r + 1; j <= i + r - 1; j++) {
if (j >= 0 && j < n) {
freq[j]++;
}
}
}
}
bool dead = false;
for (int i = 0; i < n; ++i) {
if (freq[i] == 0) {
dead = true;
break;
}
}
if (dead) {
cout << -1 << endl;
return 0;
}
int index = r;
int count = 0;
for (int i = 0; i < n; ++i) {
int j = min(i + r - 1, n - 1);
while (arr[j] != 1) {
j--;
}
count++;
i = j + r - 1;
}
cout << count << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
char buf[102];
cin.getline(buf, 102);
int x[3];
int y[3];
int p = 0;
for (int i = 0; i < n; ++i) {
cin.getline(buf, 102);
for (int j = 0; j < m; ++j) {
if (buf[j] == '*') {
x[p] = i + 1;
y[p++] = j + 1;
}
}
}
if (x[0] == x[1])
cout << x[2];
else
cout << x[0];
cout << ' ';
if (y[0] == y[1])
cout << y[2];
else if (y[0] == y[2])
cout << y[1];
else
cout << y[0];
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, l;
cin >> n >> l;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int rez = 2 * max(arr[0], l - arr[n - 1]);
for (int i = 1; i <= n - 1; i++) rez = max(rez, (arr[i] - arr[i - 1]));
cout << fixed << setprecision(15) << (float)rez / 2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s, k, a[2010], b[2010], nxt[2010], sum[2010], dp[2010][2010];
inline int read() {
int s = 0, w = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') w = -1;
for (; isdigit(c); c = getchar()) s = (s << 1) + (s << 3) + (c ^ 48);
return s * w;
}
bool check(int mid) {
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + (a[i] <= b[mid]);
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= s; ++i) {
for (int j = 1; j <= n; ++j) dp[i][j] = max(dp[i][j], dp[i - 1][j]);
for (int j = 1; j <= n; ++j)
if (nxt[j])
dp[i][nxt[j]] =
max(dp[i][nxt[j]], dp[i - 1][j - 1] + sum[nxt[j]] - sum[j - 1]);
for (int j = 1; j <= n; ++j) dp[i][j] = max(dp[i][j - 1], dp[i][j]);
}
return dp[s][n] >= k;
}
int main() {
n = read(), m = read(), s = read(), k = read();
for (int i = 1; i <= n; ++i) a[i] = read(), b[i] = a[i];
sort(b + 1, b + 1 + n);
for (int i = 1; i <= m; ++i) {
int l = read(), r = read();
for (int j = l; j <= r; ++j) nxt[j] = max(nxt[j], r);
}
int l = 1, r = n, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
ans = b[mid], r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
string s;
int m, f[200010];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> s >> m;
int n = int((s).size());
s = " " + s;
for (int i = (1); i <= (m); i++) {
int x;
cin >> x;
f[x]++;
}
for (int i = (1); i <= (n / 2); i++) f[i] += f[i - 1];
for (int i = (1); i <= (n / 2); i++) {
int h = f[i];
if (h % 2) swap(s[i], s[n - i + 1]);
}
for (int i = (1); i <= (n); i++) cout << s[i];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
int main() {
int t;
cin >> t;
for (int T = 0; T < t; T++) {
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
cout << i << " ";
}
cout << std::endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, max1 = 1e9;
cin >> n;
vector<pair<int, int> > v;
for (int i = 1; i <= n; i++)
if (n % i == 0 && i <= n / i)
v.push_back(make_pair(i, n / i));
else if (i > n / i)
break;
for (auto i : v)
if (abs(i.first - i.second) < max1)
a = i.first, b = i.second, max1 = abs(i.first - i.second);
cout << a << ' ' << b << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[75][75][2003];
int a[75];
string s;
struct node {
int cur, last, val;
node(int a, int b, int c) { cur = a, last = b, val = c; }
};
int S, n, k;
queue<node> q;
void bfs() {
q.push(node(S, 0, 0));
dp[S][0][0] = 0;
while (q.size() > 0) {
node u = q.front();
int i = u.cur, j = u.last, v = u.val;
q.pop();
if (v >= k) {
cout << dp[i][j][v];
return;
}
if (a[i] > a[j] && s[i - 1] != s[j - 1]) {
if (dp[i][i][v + a[i]] == -1) {
dp[i][i][v + a[i]] = dp[i][j][v];
q.push(node(i, i, v + a[i]));
}
}
if (i + 1 <= n && dp[i + 1][j][v] == -1) {
dp[i + 1][j][v] = dp[i][j][v] + 1;
q.push(node(i + 1, j, v));
}
if (i - 1 >= 1 && dp[i - 1][j][v] == -1) {
dp[i - 1][j][v] = dp[i][j][v] + 1;
q.push(node(i - 1, j, v));
}
}
cout << -1;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> S >> k;
int sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cin >> s;
bfs();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << 0;
return 0;
}
sort(a, a + n);
m = *max_element(a, a + n);
long long ans = 0, f = 0, cnt = 0;
for (long long i = 0; i < n - 1; i++) {
if (a[i] > f && f < m) {
ans += a[i] - 1;
f++;
} else if (f >= m) {
ans += a[i] - 1;
f++;
} else {
ans += a[i] - 1;
continue;
}
}
if (f >= a[n - 1])
ans += a[n - 1] - 1;
else
ans += f;
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5 + 50;
long long n, a[nmax], dem = 0;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (a[i] == a[1]) dem++;
if (a[i] == a[n]) dem++;
}
cout << max(n - dem, (long long)0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[105][105][105];
long long int opti[105][105][105];
long long int lps[105];
string s, s1, s2, ans;
long long int n, m, o;
long long int rec(long long int i, long long int j, long long int k) {
if (k >= o) return -1e16;
if (i >= n || j >= m) return 0;
if (dp[i][j][k] != -1) return dp[i][j][k];
long long int an = -1e16, x = 0;
if (s[i] == s1[j]) {
long long int y = k;
if (s2[k] != s[i]) {
y--;
y = max(y, 0ll);
y = lps[y];
while (y > 0) {
if (s2[y] == s[i]) {
y++;
break;
}
y = lps[y - 1];
}
if (y == 0 && s2[y] == s[i]) y++;
} else
y++;
x = rec(i + 1, j + 1, y) + 1;
if (x > an) {
opti[i][j][k] = 1;
an = x;
}
}
x = rec(i + 1, j, k);
if (x > an) {
opti[i][j][k] = 2;
an = x;
}
x = rec(i, j + 1, k);
if (x > an) {
opti[i][j][k] = 3;
an = x;
}
return dp[i][j][k] = an;
}
void computeLPSArray() {
int len = 0;
lps[0] = 0;
int i = 1;
while (i < o) {
if (s2[i] == s2[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
int main() {
for (int i = 0; i <= 104; i++)
for (int j = 0; j <= 104; j++)
for (int k = 0; k <= 104; k++) {
dp[i][j][k] = -1;
opti[i][j][k] = -1;
}
cin >> s >> s1 >> s2;
n = s.length();
m = s1.length();
o = s2.length();
computeLPSArray();
long long int an = rec(0, 0, 0);
if (an <= 0) return cout << "0" << '\n', 0;
long long int i = 0, j = 0, k = 0;
ans = "";
while (opti[i][j][k] != -1) {
if (opti[i][j][k] == 1) {
ans.push_back(s[i]);
long long int y = k;
if (s2[k] != s[i]) {
y--;
y = max(y, 0ll);
y = lps[y];
while (y > 0) {
if (s2[y] == s[i]) {
y++;
break;
}
y = lps[y - 1];
}
if (y == 0 && s2[y] == s[i]) y++;
} else
y++;
k = y;
i++, j++;
} else if (opti[i][j][k] == 2)
i++;
else
j++;
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int x, a, b, y, cnt, n;
int main() {
ios_base::sync_with_stdio(0);
;
cin >> n;
for (long long int i = 1; i <= n; i++) {
cin >> a >> b;
while (1) {
if (a <= 0 || b <= 0) break;
if (a < b) swap(a, b);
y = a - b;
if (y < b)
a -= b, cnt++;
else {
cnt += y / b;
y = (y / b) * b;
a -= y;
}
}
cout << cnt << endl;
x = 0;
y = 0;
cnt = 0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int>> adj;
vector<long long int> color;
long long int alp;
void DFS(int src, int p) {
if (p == 1) alp++;
color[src] = p;
for (auto x : adj[src]) {
if (color[x] == -1) {
DFS(x, 3 - p);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, i, a, b, ans;
cin >> n;
adj.resize(n + 1);
color.resize(n + 1, -1);
for (i = 1; i < n; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
alp = 0;
DFS(1, 1);
ans = (alp * (n - alp)) - (n - 1);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int a[maxn], b[maxn];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int height = 0;
for (int i = n; i > 0; i--) {
if (a[i] > height)
b[i] = 0;
else
b[i] = height + 1 - a[i];
height = max(height, a[i]);
}
for (int i = 1; i <= n; i++) cout << b[i] << ' ';
cout << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 5e3 + 10;
int sz[N];
vector<int> v[N];
int flag[N];
int dp[N];
int n;
void dfs(int x, int fa = 0) {
sz[x] = 0;
int sx = 0;
dp[0] = 1;
for (auto& y : v[x]) {
if (y == fa) continue;
dfs(y, x);
}
for (auto& y : v[x]) {
if (y == fa) continue;
int sy = sz[y];
for (int i = 1; i <= sy; i++) dp[sx + i] = 0;
sx += sy;
for (int i = sx; i >= sy; i--) {
dp[i] |= dp[i - sz[y]];
}
}
sz[x] = sx + 1;
for (int i = 0; i <= sx; i++) {
if (dp[i]) flag[i] = flag[i + (n - sz[x])] = 1;
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
v[x].emplace_back(y);
v[y].emplace_back(x);
}
dfs(1);
vector<int> ans;
for (int i = 1; i < n - 1; i++) {
if (flag[i]) ans.push_back(i);
}
printf("%d\n", ans.size());
for (auto& x : ans) printf("%d %d\n", x, n - x - 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3 * (1e5) + 5;
int n, m, Q;
int u, v;
vector<int> graph[MAXN];
int cyclesCount = 0;
int node2Cycle[MAXN];
vector<int> cycle[MAXN];
int parent[MAXN];
set<pair<int, int> > used;
bool usedNodes[MAXN];
int maxLeft[MAXN];
long long dp[MAXN];
long long prefix[MAXN];
void DFS(int x) {
usedNodes[x] = true;
for (int i = 0; i < graph[x].size(); i++) {
u = x;
v = graph[x][i];
if (used.count(make_pair(min(u, v), max(u, v))) == false) {
used.insert(make_pair(min(u, v), max(u, v)));
if (usedNodes[v] == false) {
parent[v] = u;
DFS(v);
} else {
while (u != v) {
node2Cycle[u] = cyclesCount;
cycle[cyclesCount].push_back(u);
u = parent[u];
}
node2Cycle[v] = cyclesCount;
cycle[cyclesCount].push_back(v);
cyclesCount++;
}
}
}
}
long long sum(long long x) {
if (x % 2 != 0) {
return sum(x - 1) + x;
}
return (x + 1) * (x / 2);
}
long long getSum(int l, int r) { return sum(r) - sum(l - 1); }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long L, R;
long long l, r, mid;
long long answer = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
DFS(i);
}
for (int i = 0; i < cyclesCount; i++) {
sort(cycle[i].begin(), cycle[i].end());
}
dp[1] = 1;
for (int i = 2; i <= n; i++) dp[i] = dp[i - 1] + i;
L = 1;
R = 1;
maxLeft[1] = 1;
for (R = 2; R <= n; R++) {
if (cyclesCount != 0) {
while (cycle[node2Cycle[R]][0] >= L &&
cycle[node2Cycle[R]][cycle[node2Cycle[R]].size() - 1] <= R) {
L++;
}
}
maxLeft[R] = L;
}
prefix[1] = 1;
for (int i = 2; i <= n; i++) prefix[i] = prefix[i - 1] + i - maxLeft[i] + 1;
cin >> Q;
for (int q = 0; q < Q; q++) {
cin >> L >> R;
answer = 0;
l = L;
r = R;
while (l + 1 < r) {
mid = (l + r) / 2;
if (maxLeft[mid] <= L)
l = mid;
else
r = mid - 1;
}
if (maxLeft[r] <= L) {
answer = getSum(L, r) - L * (r - L + 1) + (r - L + 1);
answer += prefix[R] - prefix[r];
} else if (maxLeft[l] <= L) {
answer = getSum(L, l) - L * (l - L + 1) + (l - L + 1);
answer += prefix[R] - prefix[l];
}
cout << answer << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
static void redirect(int argc, const char **argv) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
}
int main(int argc, const char **argv) {
redirect(argc, argv);
int N;
cin >> N;
set<string> init[2], trg[2];
int nex = 0;
for (int i = 0; i < N; i++) {
string s;
int ex;
cin >> s >> ex;
nex += ex;
init[!ex].insert(move(s));
}
for (int i = 0; i < nex; i++) trg[0].insert(to_string(i + 1));
for (int i = nex; i < N; i++) trg[1].insert(to_string(i + 1));
for (int i = 0; i < 2; i++) {
vector<string> shared;
for (const auto &s : init[i])
if (trg[i].count(s)) shared.push_back(s);
for (const auto &s : shared) {
init[i].erase(s);
trg[i].erase(s);
}
}
vector<pair<string, string>> ans;
if (!init[0].empty() && init[0] == trg[1] && init[1] == trg[0]) {
ans.emplace_back(*init[0].begin(), "tmp");
init[0].erase(*init[0].begin());
init[0].insert("tmp");
}
set<string> both[2], one[2];
for (int i = 0; i < 2; i++) {
set_intersection(begin(trg[i]), end(trg[i]), begin(init[!i]), end(init[!i]),
inserter(both[i], both[i].end()));
set_difference(begin(trg[i]), end(trg[i]), begin(init[!i]), end(init[!i]),
inserter(one[i], one[i].end()));
}
while (!init[0].empty() || !init[1].empty()) {
int side = one[0].empty() ? 1 : 0;
string t = *one[side].begin();
string s =
(both[!side].empty()) ? *init[side].begin() : *both[!side].begin();
ans.emplace_back(s, t);
both[!side].erase(s);
init[side].erase(s);
trg[side].erase(t);
one[side].erase(t);
if (trg[!side].count(s)) one[!side].insert(s);
}
cout << ((long long)(ans).size()) << '\n';
for (const auto &a : ans)
cout << "move " << a.first << ' ' << a.second << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 1)
cout << "-1" << endl;
else {
int a[100][100] = {0};
int b = 2;
int startx = 0, starty = 0, endx = n - 1, endy = n - 1;
for (int h = 0; h < n / 2; h++) {
for (int i = 0; i < n / 2; i++) {
int j;
for (j = starty; j <= endy; j++) a[startx][j] = b;
for (j = startx; j <= endx; j++) a[j][starty] = b;
for (j = endy; j >= starty; j--) a[endx][j] = b;
for (j = endx; j >= startx; j--) a[j][endy] = b;
startx++;
starty++;
endx--;
endy--;
b = 3 - b;
}
for (int i = 0; i < n; i++) {
for (int y = 0; y < n; y++)
if (a[i][y] == 2)
cout << "w";
else
cout << "b";
cout << endl;
}
cout << endl;
for (int i = 0; i < n; i++) {
for (int y = 0; y < n; y++)
if (a[i][y] == 2)
cout << "b";
else
cout << "w";
cout << endl;
}
cout << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
using pii = pair<int, int>;
using ppi = pair<int*, int>;
using pip = pair<int, pii>;
vector<int> adj[500100];
vector<int> vec[500100];
vector<ppi> roll;
int c[500100], root[500100], vst[500100], dst[500100];
int check_point;
int find_root(int u) {
if (root[u] == u) return u;
int r = find_root(root[u]);
roll.push_back({&root[u], root[u]});
roll.push_back({&dst[u], dst[u]});
dst[u] ^= dst[root[u]];
root[u] = r;
return r;
}
int merge(int u, int v) {
if (find_root(u) == find_root(v)) {
if (dst[u] == dst[v]) return 1;
return 0;
}
int d = (1 ^ dst[u] ^ dst[v]);
u = root[u], v = root[v];
roll.push_back({&root[v], root[v]});
roll.push_back({&dst[v], dst[v]});
root[v] = u;
dst[v] = d;
return 0;
}
void roll_back() {
while (roll.size() > check_point) {
auto p = roll.back();
*(p.first) = p.second;
roll.pop_back();
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
vec[c[i]].push_back(i);
}
for (int i = 1; i <= n; i++) root[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
if (c[u] == c[v]) {
int op = merge(u, v);
if (op) vst[c[u]] = 1;
} else {
adj[u].push_back(v);
adj[v].push_back(u);
}
}
int tot = 0;
for (int i = 1; i <= k; i++)
if (vst[i] == 0) tot++;
INT ans = 1LL * tot * (tot - 1) / 2;
int tt = 0;
check_point = roll.size();
for (int i = 1; i <= k; i++) {
if (vst[i]) continue;
vector<pip> edge;
vector<int> col, tmp;
for (int u : vec[i]) {
for (int v : adj[u]) {
if (vst[c[v]]) continue;
edge.push_back({c[v], {u, v}});
col.push_back(c[v]);
}
}
if (edge.empty()) continue;
sort(col.begin(), col.end());
sort(edge.begin(), edge.end());
col.resize(unique(col.begin(), col.end()) - col.begin());
tmp.resize(col.size(), 0);
int id = 0;
for (auto p : edge) {
if (p.first == col[id]) {
if (tmp[id]) continue;
int u = p.second.first, v = p.second.second;
int op = merge(u, v);
if (op) tmp[id] = 1;
} else {
roll_back();
id++;
int u = p.second.first, v = p.second.second;
int op = merge(u, v);
if (op) tmp[id] = 1;
}
}
roll_back();
for (int v : tmp)
if (v) tt++;
}
tt /= 2;
ans -= tt;
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char a[10], b[10];
char na[10], nb[10];
int main(void) {
scanf("%s %s", a, b);
int lena = strlen(a), lenb = strlen(b);
int mmax = 0;
for (int i = 0; i < max(lena, lenb); i++)
mmax = max(a[i] - '0', mmax), mmax = max(mmax, b[i] - '0');
mmax++;
for (int i = 0; i < lena; i++) na[i] = a[lena - i - 1] - '0';
for (int i = 0; i < lenb; i++) nb[i] = b[lenb - i - 1] - '0';
int ost = 0;
for (int i = 0; i < max(lena, lenb); i++) {
if (ost + na[i] + nb[i] >= mmax)
ost = 1;
else
ost = 0;
}
if (ost)
printf("%d", max(lena, lenb) + 1);
else
printf("%d", max(lena, lenb));
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
const double PI = acos(-1.0);
int n, m, ans[N], t[10];
vector<pair<int, int> > cl[N], ln[N], d[N * 2];
vector<pair<int, int> > sm[N * 2];
int main() {
cin >> n >> m;
for (int i = 1, x, y; i <= m; ++i) {
cin >> x >> y;
ln[x].push_back({y, i});
cl[y].push_back({x, i});
sm[x + y].push_back({x, i});
d[(n - x + 1) + (y - 1)].push_back({x, i});
}
for (int i = 1; i <= n; ++i) {
sort(ln[i].begin(), ln[i].end());
sort(cl[i].begin(), cl[i].end());
for (int j = 0; j < ln[i].size(); ++j) {
ans[ln[i][j].second] += (j - 1 >= 0) + (j + 1 < ln[i].size());
}
for (int j = 0; j < cl[i].size(); ++j) {
ans[cl[i][j].second] += (j - 1 >= 0) + (j + 1 < cl[i].size());
}
}
for (int i = 1; i <= n * 2; ++i) {
sort(sm[i].begin(), sm[i].end());
sort(d[i].begin(), d[i].end());
for (int j = 0; j < sm[i].size(); ++j) {
int x, y, z;
ans[sm[i][j].second] += (j - 1 >= 0) + (j + 1 < sm[i].size());
}
for (int j = 0; j < d[i].size(); ++j) {
ans[d[i][j].second] += (j - 1 >= 0) + (j + 1 < d[i].size());
}
}
for (int i = 1; i <= m; ++i) {
t[ans[i]]++;
}
for (int i = 0; i <= 8; ++i) {
cout << t[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double TriangleArea(pair<double, double> t1, pair<double, double> t2,
pair<double, double> t3) {
return (double)0.5 * abs(t1.first * t2.second + t2.first * t3.second +
t3.first * t1.second - t1.first * t3.second -
t3.first * t2.second - t2.first * t1.second);
}
bool IsInsideTriangle(pair<double, double> point, pair<double, double> t1,
pair<double, double> t2, pair<double, double> t3) {
return (abs(TriangleArea(point, t1, t2) + TriangleArea(point, t1, t3) +
TriangleArea(point, t3, t2) - TriangleArea(t1, t2, t3)) <= 1e-8);
}
bool PointEquals(pair<double, double> p1, pair<double, double> p2) {
return abs(p1.first - p2.first) <= 1e-8 && abs(p1.second - p2.second) <= 1e-8;
}
bool IsIntersecting(pair<pair<double, double>, pair<double, double> > segment1,
pair<pair<double, double>, pair<double, double> > segment2,
int* parallel = NULL,
pair<double, double>* intersection_point = NULL) {
int dummy_parallel;
pair<double, double> dummy_intersection_point;
if (parallel == NULL) parallel = &dummy_parallel;
if (intersection_point == NULL)
intersection_point = &dummy_intersection_point;
double xx1 = segment1.first.first;
double yy1 = segment1.first.second;
double xx2 = segment1.second.first;
double yy2 = segment1.second.second;
double xx3 = segment2.first.first;
double yy3 = segment2.first.second;
double xx4 = segment2.second.first;
double yy4 = segment2.second.second;
double ua, ub;
*parallel = 0;
if (fabs((yy4 - yy3) * (xx2 - xx1) - (xx4 - xx3) * (yy2 - yy1)) <= 1e-8) {
*parallel = 1;
if (PointEquals(segment1.first, segment2.first) ||
PointEquals(segment1.first, segment2.second)) {
*intersection_point = segment1.first;
return true;
} else if (PointEquals(segment1.second, segment2.first) ||
PointEquals(segment1.second, segment2.second)) {
*intersection_point = segment1.second;
return true;
}
return false;
}
ua = ((xx4 - xx3) * (yy1 - yy3) - (yy4 - yy3) * (xx1 - xx3)) /
((yy4 - yy3) * (xx2 - xx1) - (xx4 - xx3) * (yy2 - yy1));
ub = ((xx2 - xx1) * (yy1 - yy3) - (yy2 - yy1) * (xx1 - xx3)) /
((yy4 - yy3) * (xx2 - xx1) - (xx4 - xx3) * (yy2 - yy1));
double& xi = (*intersection_point).first;
double& yi = (*intersection_point).second;
xi = xx1 + ua * (xx2 - xx1);
yi = yy1 + ua * (yy2 - yy1);
return ((xi + 1e-8 >= fmin(xx1, xx2)) && (xi - 1e-8 <= fmax(xx1, xx2)) &&
(yi + 1e-8 >= fmin(yy1, yy2)) && (yi - 1e-8 <= fmax(yy1, yy2)) &&
(xi + 1e-8 >= fmin(xx3, xx4)) && (xi - 1e-8 <= fmax(xx3, xx4)) &&
(yi + 1e-8 >= fmin(yy3, yy4)) && (yi - 1e-8 <= fmax(yy3, yy4)));
}
bool PointLess(pair<double, double> p1, pair<double, double> p2) {
return p2.second + 1e-8 < p1.second ||
(fabs(p1.second - p2.second) <= 1e-8 && p1.first + 1e-8 < p2.first);
}
struct CmpPointLess {
bool operator()(pair<double, double> p1, pair<double, double> p2) {
return PointLess(p1, p2);
}
};
vector<pair<double, double> > triangles[150];
pair<double, double> MidPoint(pair<double, double> p1,
pair<double, double> p2) {
return make_pair(0.5 * (p1.first + p2.first), 0.5 * (p1.second + p2.second));
}
double SegmentLength(pair<pair<double, double>, pair<double, double> > seg) {
return sqrt((seg.first.first - seg.second.first) *
(seg.first.first - seg.second.first) +
(seg.first.second - seg.second.second) *
(seg.first.second - seg.second.second));
}
int main() {
int n;
cin >> n;
for (int(i) = 0; (i) < (n); ++(i)) {
for (int(j) = 0; (j) < (3); ++(j)) {
int x, y;
cin >> x >> y;
triangles[i].push_back(make_pair((double)x, (double)y));
}
}
double ret = 0.0;
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (3); ++(j)) {
vector<pair<double, double> > intersections;
pair<double, double> awal = triangles[i][j];
pair<double, double> akhir = triangles[i][(j + 1) % 3];
intersections.push_back(awal);
intersections.push_back(akhir);
for (int(k) = 0; (k) < (n); ++(k))
if (k != i)
for (int(l) = 0; (l) < (3); ++(l)) {
pair<double, double> p;
if (IsIntersecting(
make_pair(awal, akhir),
make_pair(triangles[k][l], triangles[k][(l + 1) % 3]), NULL,
&p)) {
intersections.push_back(p);
}
}
sort(intersections.begin(), intersections.end(), CmpPointLess());
for (int(k) = 0; (k) < (((int)intersections.size()) - 1); ++(k)) {
pair<double, double> p1 = intersections[k];
pair<double, double> p2 = intersections[k + 1];
if (PointEquals(p1, p2)) continue;
pair<double, double> mid = MidPoint(p1, p2);
int contained = 0;
for (int(l) = 0; (l) < (n); ++(l))
if (l != i) {
if (IsInsideTriangle(mid, triangles[l][0], triangles[l][1],
triangles[l][2])) {
contained = 1;
break;
}
}
if (!contained) ret += SegmentLength(make_pair(p1, p2));
}
}
printf("%.9lf\n", ret);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int inf = (1ll << 25) - 1;
const int maxn = (int)3e6 + 100;
const int mod = (int)1e9 + 7;
using namespace std;
struct node {
map<char, int> nxt;
int len;
int link;
int cnt;
int mx;
} second[maxn];
int N;
int last = 0;
void init() {
second[0].link = -1;
second[0].len = 0;
second[0].nxt.clear();
N = 1;
last = 0;
}
void add(char c) {
int v = N;
second[v].cnt = 1;
N++;
int p = last;
second[v].nxt.clear();
second[v].len = second[p].len + 1;
while (p != -1 && !second[p].nxt.count(c)) {
second[p].nxt[c] = v;
p = second[p].link;
}
if (p == -1) {
second[v].link = 0;
} else {
int q = second[p].nxt[c];
if (second[q].len == second[p].len + 1) {
second[v].link = q;
} else {
int cl = N++;
second[cl].len = second[p].len + 1;
second[cl].link = second[q].link;
second[cl].nxt = second[q].nxt;
while (p != -1 && second[p].nxt[c] == q) {
second[p].nxt[c] = cl;
p = second[p].link;
}
second[v].link = second[q].link = cl;
}
}
last = v;
}
int cmp(int i, int j) { return second[i].len > second[j].len; }
void calc() {
vector<int> p;
for (int i = 0; i < N; i++) p.push_back(i);
sort(p.begin(), p.end(), cmp);
for (int i = 0; i < p.size(); i++) {
if (second[p[i]].link != -1) {
second[second[p[i]].link].cnt += second[p[i]].cnt;
}
}
}
int u[maxn];
int T;
int get(string t) {
T++;
int v = 0;
int ans = 0;
int L = 0;
for (int i = 0; i < t.size(); i++) {
while (v && !second[v].nxt.count(t[i])) {
v = second[v].link;
L = second[v].len;
}
if (second[v].nxt.count(t[i])) {
v = second[v].nxt[t[i]];
L++;
}
}
if (L == t.size()) {
u[v] = T;
ans += second[v].cnt;
}
for (int i = 0; i < t.size(); i++) {
if (L == t.size()) {
L--;
if (second[second[v].link].len == L) {
v = second[v].link;
}
}
while (v && !second[v].nxt.count(t[i])) {
v = second[v].link;
L = second[v].len;
}
if (second[v].nxt.count(t[i])) {
v = second[v].nxt[t[i]];
L++;
}
if (L == t.size() && u[v] != T) {
ans += second[v].cnt;
u[v] = T;
}
}
return ans;
}
void solve() {
string t;
cin >> t;
init();
for (int i = 0; i < t.size(); i++) add(t[i]);
calc();
int x;
cin >> x;
for (int i = 0; i < x; i++) {
cin >> t;
cout << get(t) << "\n";
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> aodd, aeven, bodd, beven;
int main() {
long double timer = (long double)clock();
char str[100011];
scanf("\n%s", str + 1);
int len = strlen(str + 1);
for (int i = 1; i <= len; i++) {
if (str[i] == 'a') {
if (i & 1)
aodd.push_back(i);
else
aeven.push_back(i);
} else {
if (i & 1)
bodd.push_back(i);
else
beven.push_back(i);
}
}
long long odd = 0, even = 0;
for (int i = 1; i <= len; i++) {
if (i & 1) {
if (str[i] == 'a') {
int pos =
distance(aeven.begin(), upper_bound(aeven.begin(), aeven.end(), i));
even += (aeven.size() - pos);
pos = distance(aodd.begin(), upper_bound(aodd.begin(), aodd.end(), i));
odd += (aodd.size() - pos + 1);
} else {
int pos =
distance(beven.begin(), upper_bound(beven.begin(), beven.end(), i));
even += (beven.size() - pos);
pos = distance(bodd.begin(), upper_bound(bodd.begin(), bodd.end(), i));
odd += (bodd.size() - pos + 1);
}
} else {
if (str[i] == 'a') {
int pos =
distance(aeven.begin(), upper_bound(aeven.begin(), aeven.end(), i));
odd += (aeven.size() - pos + 1);
pos = distance(aodd.begin(), upper_bound(aodd.begin(), aodd.end(), i));
even += (aodd.size() - pos);
} else {
int pos =
distance(beven.begin(), upper_bound(beven.begin(), beven.end(), i));
odd += (beven.size() - pos + 1);
pos = distance(bodd.begin(), upper_bound(bodd.begin(), bodd.end(), i));
even += (bodd.size() - pos);
}
}
}
printf("%lld %lld\n", even, odd);
;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 6e5 + 10;
const int inf = 0x3f3f3f3f;
int d[maxn];
int lowbit(int x) { return x & (-x); }
void add(int pos, int x) {
for (int i = pos; i < maxn; i += lowbit(i)) d[i] += x;
}
int query(int pos) {
int ans = 0;
for (int i = pos; i; i -= lowbit(i)) ans += d[i];
return ans;
}
int pos[maxn];
int Max[maxn], Min[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int last = maxn - 1;
int n, m;
cin >> n >> m;
for (int i = (n); i >= (1); i--) {
pos[i] = last;
add(last, 1);
last--;
Max[i] = Min[i] = i;
}
while (m--) {
int x;
cin >> x;
Max[x] = max(Max[x], query(pos[x]));
add(pos[x], -1);
pos[x] = last--;
add(pos[x], 1);
Min[x] = 1;
}
for (int i = (1); i <= (n); i++) Max[i] = max(Max[i], query(pos[i]));
for (int i = (1); i <= (n); i++) cout << Min[i] << ' ' << Max[i] << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ar[200005];
int main() {
string s, t;
getline(cin, s);
getline(cin, t);
memset(ar, 0, sizeof ar);
map<char, int> mp;
for (int i = 0; i < t.size(); i++) mp[t[i]]++;
int yes = 0, no = 0;
for (int i = 0; i < s.size(); i++) {
if (mp[s[i]] != 0) {
mp[s[i]]--;
yes++;
ar[i] = 1;
}
}
for (int i = 0; i < s.size(); i++) {
if (mp[s[i]] == 0 && ar[i] == 0) {
char x;
if (s[i] >= 'A' && s[i] <= 'Z')
x = s[i] - 'A' + 'a';
else if (s[i] >= 'a' && s[i] <= 'z')
x = s[i] - 'a' + 'A';
if (mp[x] > 0) {
no++;
mp[x]--;
}
}
}
cout << yes << " " << no << "\n";
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
long long f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
const long long maxn = 100005;
long long n, d, b, sum[maxn], cnt, p1, p2;
signed main() {
read(n), read(d), read(b);
for (long long i = 1, x; i <= n; i++) {
read(x);
sum[i] = sum[i - 1] + x;
}
for (long long i = 1; i <= n / 2; i++) {
long long r = min(i + d * i, n), l = 1;
if (sum[r] - sum[l - 1] < b + cnt * b)
p1++;
else
cnt++;
}
cnt = 0;
for (long long i = n; i > n / 2; i--) {
long long r = n, l = max(1LL, i - d * (n - i + 1));
if (sum[r] - sum[l - 1] < b + cnt * b)
p2++;
else
cnt++;
}
printf("%lld\n", max(p1, p2));
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200005], f[200005];
int c[200005], d[200005 * 3], m, q, v[200005], w[200005 * 3];
long long e[200005], r1[200005], r2[200005], s[200005 * 3];
void circle(int u, int p, int l) {
if (v[u]) {
int i, j;
for (i = l - 1; d[i] != u; i--) c[d[i]] = 1;
for (j = i; j < l; j++) d[j - i] = d[j];
m = l - i;
c[u] = q = 1;
return;
}
v[u] = 1;
d[l] = u;
for (int i = 0; i < g[u].size(); i++) {
int j = g[u][i];
if (j != p) circle(j, u, l + 1);
if (q) break;
}
}
void dfs(int u, int fa) {
r1[u] = 0;
e[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int j = g[u][i], w = f[u][i];
if (j != fa && !c[j]) {
dfs(j, u);
r1[u] += r1[j] + w * e[j];
e[u] += e[j];
}
}
}
void count(int u, int p, long long s, long long t) {
r2[u] = s;
for (int i = 0; i < g[u].size(); i++) {
int j = g[u][i], w = f[u][i];
if (j != p && !c[j]) {
count(j, u, s + r1[u] - r1[j] + w * (t + e[u] - 2 * e[j]),
t + e[u] - e[j]);
}
}
}
int main() {
int i, j, k, n;
while (~scanf("%d", &n)) {
for (i = 1; i <= n; i++) g[i].clear(), f[i].clear();
for (i = 0; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
g[u].push_back(v), f[u].push_back(w);
g[v].push_back(u), f[v].push_back(w);
}
memset(v, 0, sizeof(v));
q = 0;
memset(c, 0, sizeof(c));
circle(1, 0, 0);
for (i = 0; i < m; i++) {
dfs(d[i], 0);
d[m + i] = d[m + m + i] = d[i];
for (j = 0; j < g[d[i]].size(); j++) {
int first = g[d[i]][j];
if (first == d[i + 1]) {
w[i] = f[d[i]][j];
break;
}
}
w[m + i] = w[m + m + i] = w[i];
s[i + 1] = s[i] + w[i];
}
for (i = m; i < 3 * m; i++) s[i + 1] = s[i] + w[i];
long long LR = 0, l = 0, r = 0;
int first = 1, second = m;
for (i = 1; i < m; i++) {
LR += (s[m] - s[i]) * e[d[i]] + r1[d[i]];
l += e[d[i]];
}
for (i = m; i < m + m; i++) {
while (first < i &&
(s[i] - s[first] > s[second + 1] - s[i] || second < i)) {
LR += (s[second + 1] - s[i] - s[i] + s[first]) * e[d[first]];
l -= e[d[first]];
r += e[d[second + 1]];
first++;
second++;
}
count(d[i], 0, LR, l + r);
l += e[d[i]];
LR += (l - r) * w[i] + r1[d[i]] - r1[d[i + 1]];
r -= e[d[i + 1]];
}
for (i = 1; i <= n; i++) {
printf("%I64d ", r1[i] + r2[i]);
}
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
template <class T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
using namespace std;
char ss[1 << 17], *A = ss, *B = ss;
inline char gc() {
return A == B && (B = (A = ss) + fread(ss, 1, 1 << 17, stdin), A == B) ? -1
: *A++;
}
template <class T>
inline void sd(T& x) {
char c;
T y = 1;
while (c = gc(), (c < 48 || 57 < c) && c != -1)
if (c == 45) y = -1;
x = c - 48;
while (c = gc(), 47 < c && c < 58) x = x * 10 + c - 48;
x *= y;
}
const int N = 3e5 + 5, M = N << 1;
typedef int arr[N];
struct Edge {
int nx, to;
} e[M];
int n, cntE, f[N][2];
arr fi, deg;
inline void add(int u, int v) { e[++cntE] = (Edge){fi[u], v}, fi[u] = cntE; }
inline void clear(int p) {
cntE = 0;
memset(fi, 0, p);
memset(deg, 0, p);
memset(f, 0, p << 1);
}
void dfs(int u, int p = 0) {
int m1 = 0, m2 = 0;
for (int i = fi[u], v = e[i].to; i; v = e[i = e[i].nx].to)
if (v ^ p) {
dfs(v, u);
cmax(f[u][0], f[v][0]);
cmax(f[u][1], f[v][1]);
if (f[v][1] > m2) f[v][1] > m1 ? m2 = m1, m1 = f[v][1] : m2 = f[v][1];
}
f[u][1] += deg[u] - 1;
cmax(f[u][0], deg[u] + 1 + m1 + m2);
}
inline int sol() {
sd(n);
clear((n + 2) << 2);
int u, v;
for (register int i = 2, I = n + 1; i < I; ++i) {
sd(u), sd(v);
add(u, v), add(v, u);
++deg[u], ++deg[v];
}
if (n == 2) return 2;
for (register int i = 1, I = n + 1; i < I; ++i)
if (deg[i] > 1) {
dfs(u = i);
break;
}
return f[u][0];
}
int main() {
int q;
sd(q);
while (q--) printf("%d\n", sol());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const int tmax = (int)1e3 + 100;
int mat[tmax][tmax];
int deg[tmax][tmax];
bool is_start[tmax][tmax];
bool visited[tmax][tmax];
void fill(int x, int y) {
if (visited[x][y]) return;
visited[x][y] = true;
for (int k = 0; k < 4; k++)
if (mat[x + dx[k]][y + dy[k]] == 1) fill(x + dx[k], y + dy[k]);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &mat[i][j]);
int tot = 0;
vector<pair<int, int> > starts;
int count_comp = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (!visited[i][j] && mat[i][j] == 1) {
count_comp++;
fill(i, j);
}
}
if (count_comp > 1) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mat[i][j] == 0) continue;
int x = i, y = j;
int cc = 0;
int hor = 0;
for (int k = 0; k < 4; k++)
if (mat[x + dx[k]][y + dy[k]] == 1) cc++, hor += k % 2;
tot += cc % 2;
if (cc == 2 && hor % 2 == 0) continue;
starts.push_back(make_pair(i, j));
is_start[i][j] = true;
}
}
if (tot > 2) {
printf("-1\n");
return 0;
}
int total_ans = 0;
for (int i = 0; i < starts.size(); i++) {
int x = starts[i].first;
int y = starts[i].second;
for (int k = 0; k < 4; k++) {
int cx = dx[k];
int cy = dy[k];
if (mat[x + cx][y + cy] == 0) continue;
int sz = 1;
int nx = x + cx;
int ny = y + cy;
while (mat[nx][ny] == 1) {
nx += cx;
ny += cy;
sz++;
}
total_ans = gcd(total_ans, sz - 1);
}
}
if (total_ans <= 1) {
printf("-1\n");
return 0;
}
for (int i = 2; i <= total_ans; i++)
if (total_ans % i == 0) printf("%d ", i);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
inline long long in() {
long long k = 0;
char ch = getchar();
bool p = 1;
while (ch < '-') ch = getchar();
if (ch == '-') p = 0, ch = getchar();
while (ch > '-') k = k * 10 + ch - '0', ch = getchar();
return p ? k : -k;
}
const int N = 1e6 + 5;
const long long inf = 1ll << 60;
long long dp[2][13][1 << 13], k;
int w[N], fz[N];
long long a[N], p[13], np[13], b[N], Cnt[1 << 13];
int c[13], nc[13], cnt, S, now = 1, id[N];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline void cmin(long long &x, long long y) {
if (x > y) x = y;
}
inline void calc(int w) {
for (int i = 1; i <= cnt; ++i)
for (int j = 0; j <= S; ++j) dp[now][i][j] = dp[now ^ 1][i][j];
static int fz[1 << 12];
for (int i = 1; i <= S; ++i) {
long long res = 1;
for (int j = 0; j < cnt; ++j)
if (i >> j & 1) res *= np[j + 1];
fz[i] = res <= k;
}
for (int i = 1; i <= S; ++i) {
if (!fz[i]) continue;
if (++Cnt[i] > cnt) continue;
cmin(dp[now][1][i], w);
for (int t = S ^ i, r = t;; t = (t - 1) & r) {
for (int j = 2; j <= cnt; ++j)
cmin(dp[now][j][t | i],
dp[now ^ 1][j - 1][t] / (j - 1) * j + 1ll * j * w);
if (!t) break;
}
}
}
inline bool cmp(const int &x, const int &y) {
return a[x] == a[y] ? w[x] < w[y] : a[x] < a[y];
}
inline bool cmp1(const int &x, const int &y) { return w[x] < w[y]; }
int main() {
int n = in();
long long g = 0;
k = in();
for (int i = 1; i <= n; ++i) a[i] = in(), g = gcd(g, a[i]);
for (int i = 1; i <= n; ++i) w[i] = in(), id[i] = i;
long long x = g;
if (g == 1) return puts("0"), 0;
for (long long i = 2; i * i <= x; ++i)
if (x % i == 0) {
p[++cnt] = i;
while (x % i == 0) x /= i, ++c[cnt];
}
if (x > 1) p[++cnt] = x, c[cnt] = 1;
for (int i = 1; i <= cnt; ++i) {
long long res = 1;
for (int j = 1; j <= c[j]; ++j) res *= p[j];
if (res > k) return puts("-1"), 0;
}
std::sort(id + 1, id + n + 1, cmp);
int m = n;
n = 0;
memcpy(b, a, sizeof a);
memcpy(fz, w, sizeof w);
for (int i = 1, ct = 0; i <= m; ++i)
if (b[id[i]] == b[id[i - 1]]) {
if (ct >= cnt) continue;
++ct;
a[++n] = b[id[i]], w[n] = fz[id[i]];
} else
ct = 1, a[++n] = b[id[i]], w[n] = fz[id[i]];
for (int i = 1; i <= n; ++i) id[i] = i;
std::sort(id + 1, id + n + 1, cmp1);
S = 1 << cnt;
--S;
for (int i = 1; i <= cnt; ++i)
for (int j = 0; j <= S; ++j) dp[now][i][j] = inf;
for (int i = 1; i <= n; ++i) {
long long x = a[id[i]];
now ^= 1;
for (int j = 1; j <= cnt; ++j) np[j] = 1;
for (int j = 1; j <= cnt; ++j)
while (x % p[j] == 0) ++nc[j], x /= p[j], np[j] *= p[j];
calc(w[id[i]]);
}
long long ans = inf;
for (int i = 1; i <= cnt; ++i) ans = std::min(ans, dp[now][i][S]);
printf("%lld\n", ans == inf ? -1ll : ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int mp[N][N];
int dp[N][N][30];
int n, m;
int dfs(int u, int v, int last) {
if (dp[u][v][last] != -1) return dp[u][v][last];
for (int i = 1; i <= n; ++i) {
if (mp[u][i] - 'a' >= last && dfs(v, i, mp[u][i] - 'a') == 0)
return dp[u][v][mp[u][i] - 'a'] = 1;
}
return dp[u][v][last] = 0;
}
int main() {
int a, b;
char c[5];
memset(dp, -1, sizeof(dp));
memset(mp, 0, sizeof(mp));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%s", &a, &b, c);
mp[a][b] = c[0];
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (dfs(i, j, 0))
putchar('A');
else
putchar('B');
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int n = s.size();
vector<int> a, b;
long long int c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
c1++;
else if (s[i] == 'B' && c1 > 0) {
c1--;
} else
c2++;
}
c2 = (c2 % 2 != 0);
cout << c1 + c2 << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int n,m,a[10],b[10],c[10][10],len,sum[10][1<<10],sk[10],ac[1<<10];
ll ans=1e9;
bool check(){
for(int i=0;i<len;++i){
int tp=ac[i];
for(int j=0;j<n;++j)if((sk[j]&i)==sk[j])tp+=a[j];
if(tp>0)return 0;
}return 1;
}
void dfs(int x,ll w){
if(w>=ans)return;
if(x>=n){
if(check())ans=w;
return;
}ll tp=w;
for(int i=x;i<n;++i)sk[i]=len-1,tp+=sum[i][sk[i]];
if(!check())return;
ans=min(ans,tp);
for(int i=0;i<len;++i){
sk[x]=i;
dfs(x+1,w+sum[x][i]);
}
}
int main(){
scanf("%d%d",&n,&m);
for(int i=0;i<n;++i)scanf("%d",&a[i]);
for(int i=0;i<m;++i)scanf("%d",&b[i]);
len=1<<m;
for(int i=0;i<len;++i)
for(int j=0;j<m;++j)if((1<<j)&i)ac[i]=(ac[i]-b[j]);
for(int i=0;i<n;++i)
for(int j=0;j<m;++j)scanf("%d",&c[i][j]);
for(int i=0;i<n;++i)
for(int j=0;j<len;++j)
for(int k=0;k<m;++k)if((1<<k)&j)sum[i][j]=(sum[i][j]+c[i][k]);
for(int i=0;i<n;++i)sk[i]=len-1;
if(!check()){
puts("-1");
return 0;
}
dfs(0,0);
printf("%lld\n",ans);
} | 12 |
#include <bits/stdc++.h>
int main(void) {
int h, m;
double hdeg, mdeg;
char ch[10];
while (gets(ch)) {
sscanf(ch, "%d:%d", &h, &m);
h %= 12;
mdeg = 6 * m;
hdeg = 30 * h + 0.5 * m;
if (30 * h + 0.5 * m == 360)
printf("0 0\n");
else
printf("%.6g %.6g\n", hdeg, mdeg);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const bool DEBUG = false;
const int MOD = 1000000007;
const int MX = 5000000;
const int LMX = 200000;
int N, M;
pair<pair<int, int>, int> videos[LMX];
pair<pair<int, int>, pair<int, long long> > channels[LMX];
long long ans = 0;
int idx1, idx2;
vector<int> coords;
void offer(long long value, int a, int b) {
if (value > ans) {
ans = value;
idx1 = a;
idx2 = b;
}
}
pair<int, int> bestSize[MX];
pair<int, int> lowestLeft[MX];
pair<long long, int> bestGain[MX];
inline int L(int x) { return x * 2 + 1; };
inline int R(int x) { return x * 2 + 2; };
inline int MID(int a, int b) { return (a + b) / 2; }
void build(int idx, int l, int r) {
if (l != r) {
build(L(idx), l, MID(l, r));
build(R(idx), MID(l, r) + 1, r);
}
bestSize[idx] = {0, -1};
lowestLeft[idx] = {((int)1e9 + 10), ((int)1e9 + 10)};
bestGain[idx] = {0, -1};
}
void put(int idx, int l, int r, pair<int, int> value, int identifier) {
int a = coords[l];
int b = coords[r];
int left = value.first;
int right = value.second;
if (right < a || right > b) return;
if (l == r) {
bestSize[idx] = max(bestSize[idx], {right - left, identifier});
lowestLeft[idx] = min(lowestLeft[idx], {left, identifier});
} else {
put(L(idx), l, MID(l, r), value, identifier);
put(R(idx), MID(l, r) + 1, r, value, identifier);
bestSize[idx] = max(bestSize[L(idx)], bestSize[R(idx)]);
lowestLeft[idx] = min(lowestLeft[L(idx)], lowestLeft[R(idx)]);
}
}
void put(int idx, int l, int r, pair<int, int> value, long long gain,
int identifier) {
int a = coords[l];
int b = coords[r];
int left = value.first;
int right = value.second;
if (right < a || right > b) return;
if (l == r) {
bestGain[idx] = max(bestGain[idx], {gain, identifier});
} else {
put(L(idx), l, MID(l, r), value, gain, identifier);
put(R(idx), MID(l, r) + 1, r, value, gain, identifier);
bestGain[idx] = max(bestGain[L(idx)], bestGain[R(idx)]);
}
}
pair<int, int> queryLeft(int idx, int l, int r, int queryL, int queryR) {
int a = coords[l];
int b = coords[r];
if (queryL <= a && queryR >= b)
return lowestLeft[idx];
else if (queryL > b || queryR < a)
return {((int)1e9 + 10), ((int)1e9 + 10)};
else {
return min(queryLeft(L(idx), l, MID(l, r), queryL, queryR),
queryLeft(R(idx), MID(l, r) + 1, r, queryL, queryR));
}
}
pair<int, int> querySize(int idx, int l, int r, int queryL, int queryR) {
int a = coords[l];
int b = coords[r];
if (queryL <= a && queryR >= b)
return bestSize[idx];
else if (queryL > b || queryR < a)
return {0, -1};
else {
return max(querySize(L(idx), l, MID(l, r), queryL, queryR),
querySize(R(idx), MID(l, r) + 1, r, queryL, queryR));
}
}
pair<long long, int> queryGain(int idx, int l, int r, int queryL, int queryR) {
int a = coords[l];
int b = coords[r];
if (queryL <= a && queryR >= b)
return bestGain[idx];
else if (queryL > b || queryR < a)
return {0, -1};
else {
return max(queryGain(L(idx), l, MID(l, r), queryL, queryR),
queryGain(R(idx), MID(l, r) + 1, r, queryL, queryR));
}
}
void solve(bool first = true) {
set<int> compress;
for (int i = (0); i < int(N); i++) {
compress.insert(videos[i].first.first);
compress.insert(videos[i].first.second);
}
for (int i = (0); i < int(M); i++) {
compress.insert(channels[i].first.first);
compress.insert(channels[i].first.second);
}
coords.clear();
for (auto& z : (compress)) coords.push_back(z);
int S = coords.size();
build(0, 0, S - 1);
sort(videos, videos + N);
sort(channels, channels + M);
int pos = N - 1;
for (int i = M - 1; i >= 0; i--) {
int left = channels[i].first.first;
int right = channels[i].first.second;
while (pos >= 0 && videos[pos].first.first >= left) {
put(0, 0, S - 1, videos[pos].first, videos[pos].second);
;
pos--;
}
auto v1 = queryLeft(0, 0, S - 1, right, ((int)1e9 + 10));
;
v1.first = right - v1.first;
auto v2 = querySize(0, 0, S - 1, -((int)1e9 + 10), right);
;
;
;
offer((long long)v1.first * channels[i].second.second, v1.second,
channels[i].second.first);
offer((long long)v2.first * channels[i].second.second, v2.second,
channels[i].second.first);
}
if (first) {
pos = M - 1;
for (int i = N - 1; i >= 0; i--) {
int left = videos[i].first.first;
int right = videos[i].first.second;
while (pos >= 0 && channels[pos].first.first >= left) {
put(0, 0, S - 1, channels[pos].first,
channels[pos].second.second *
(channels[pos].first.second - channels[pos].first.first),
channels[pos].second.first);
pos--;
}
auto v1 = queryGain(0, 0, S - 1, -((int)1e9 + 10), right);
offer(v1.first, videos[i].second, v1.second);
}
}
}
void neg(pair<int, int>& p) {
int a = p.first;
int b = p.second;
p.first = -b;
p.second = -a;
}
bool Read(int& x) {
char c, r = 0, n = 0;
x = 0;
for (;;) {
c = getchar();
if ((c < 0) && (!r)) return (0);
if ((c == '-') && (!r))
n = 1;
else if ((c >= '0') && (c <= '9'))
x = x * 10 + c - '0', r = 1;
else if (r)
break;
}
if (n) x = -x;
return (1);
}
int main() {
Read(N);
Read(M);
for (int i = (0); i < int(N); i++) {
Read(videos[i].first.first);
Read(videos[i].first.second);
videos[i].second = i + 1;
}
for (int i = (0); i < int(M); i++) {
Read(channels[i].first.first);
Read(channels[i].first.second);
scanf("%lld", &(channels[i].second.second));
channels[i].second.first = i + 1;
}
solve();
for (int i = (0); i < int(N); i++) neg(videos[i].first);
for (int i = (0); i < int(M); i++) neg(channels[i].first);
solve(false);
printf("%lld\n", ans);
if (ans > 0) printf("%d %d\n", idx1, idx2);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int t, m, i, j, k, sum = 0;
long long int n;
cin >> n;
vector<pair<long long int, long long int>> a(n);
vector<long long int> viz(2 * n + 5, 0);
for (i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
viz[a[i].first] = 1;
}
sort(a.begin(), a.end(), greater<pair<long long int, long long int>>());
vector<long long int> ans(2 * n + 1);
for (i = 0; i < n; i++) {
long long int flag = 0;
for (j = 2 * n; j > a[i].first; j--) {
if (!viz[j]) {
viz[j] = 1;
ans[2 * a[i].second] = a[i].first;
ans[2 * a[i].second + 1] = j;
flag = 1;
break;
}
}
if (!flag) {
cout << -1 << '\n';
return;
}
}
for (i = 1; i < 2 * n; i += 2) {
for (j = i + 2; j < 2 * n; j += 2) {
if (ans[i] > ans[j] && ans[j] > ans[i - 1] && ans[i] > ans[j - 1]) {
swap(ans[i], ans[j]);
}
}
}
for (i = 0; i < 2 * n; i++) {
cout << ans[i] << ' ';
}
cout << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int q;
cin >> q;
while (q--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const long long MAXN = 200010;
const long long INF = 1e9;
long long Q;
double ans;
long long sta[MAXN + 1], top;
long long root;
long long L;
namespace T {
struct data {
long long val, t, mn, sum, s, len, key, sumall;
} tr[MAXN * 3 + 1];
long long ch[MAXN + 1][2];
long long nod;
inline void NewNode(long long t, long long s, long long len) {
tr[++nod].mn = min(0LL, s * len);
tr[nod].s = s;
tr[nod].len = len;
tr[nod].sum = tr[nod].sumall = tr[nod].val = s * len;
tr[nod].t = t;
tr[nod].key = rand();
return;
}
inline void update(long long x) {
tr[x].sumall = tr[ch[x][0]].sumall + tr[x].val + tr[ch[x][1]].sumall;
tr[x].sum = tr[ch[x][0]].sumall + tr[x].val;
tr[x].mn = min(tr[ch[x][0]].mn, tr[x].sum + min(0LL, tr[ch[x][1]].mn));
return;
}
inline long long merge(long long x, long long y) {
if (!x || !y) return (x + y);
if (tr[x].key < tr[y].key) {
ch[x][1] = merge(ch[x][1], y), update(x);
return x;
} else {
ch[y][0] = merge(x, ch[y][0]), update(y);
return y;
}
}
inline pair<long long, long long> split(long long x, long long k) {
if (!x) return make_pair(0, 0);
if (k >= tr[x].t) {
pair<long long, long long> ret = split(ch[x][1], k);
ch[x][1] = ret.first;
update(x);
ret.first = x;
return ret;
} else {
pair<long long, long long> ret = split(ch[x][0], k);
ch[x][0] = ret.second;
update(x);
ret.second = x;
return ret;
}
}
inline void Findans(long long x, long long v) {
if (!v) {
ans = L - 1;
return;
}
if (!x) {
ans = -1;
return;
}
if (tr[x].mn + v > 0) {
ans = -1;
return;
}
if (ch[x][0] && tr[ch[x][0]].mn + v <= 0) {
Findans(ch[x][0], v);
return;
}
if (v + tr[x].sum <= 0) {
ans = (double)(v + tr[ch[x][0]].sumall) / (-tr[x].s) + tr[x].t - 1;
return;
}
if (ch[x][1] && tr[ch[x][1]].mn + v + tr[x].sum <= 0)
Findans(ch[x][1], v + tr[x].sum);
}
inline void print(long long x) {
if (!x) return;
cout << x << ":"
<< "ch[x][0]:" << ch[x][0] << " ch[x][1]:" << ch[x][1]
<< "\tt:" << tr[x].t << "\ts:" << tr[x].s << "\tlen:" << tr[x].len
<< "\tsumall:" << tr[x].sumall << "\tval:" << tr[x].val << endl;
print(ch[x][0]);
print(ch[x][1]);
}
} // namespace T
using namespace T;
int main() {
Q = read();
NewNode(0, 0, INF + 1);
NewNode(INF + 1, 0, INF);
root = merge(1, 2);
while (Q--) {
long long opr = read();
if (opr == 1) {
long long t = read(), s = read();
pair<long long, long long> A = split(root, t - 1);
long long x = A.first;
top = 0;
while (ch[x][1]) sta[++top] = x, x = ch[x][1];
sta[++top] = x;
long long d = sta[top];
long long len = tr[d].len - (t - tr[d].t);
NewNode(t, s, len);
if (d) {
tr[d].len -= len;
tr[d].sum = tr[d].sumall = tr[d].val = tr[d].s * (t - tr[d].t);
tr[d].mn = min(0LL, tr[d].s * (t - tr[d].t));
for (long long i = top; i >= 1; i--) update(sta[i]);
}
root = merge(A.first, merge(nod, A.second));
} else if (opr == 2) {
long long t = read();
pair<long long, long long> A = split(root, t - 1);
pair<long long, long long> B = split(A.second, t);
long long x = A.first, n = B.first, len = tr[n].len;
top = 0;
while (ch[x][1]) sta[++top] = x, x = ch[x][1];
sta[++top] = x;
long long d = sta[top];
if (d) {
tr[d].len += len;
tr[d].sum = tr[d].sumall = tr[d].val = tr[d].s * tr[d].len;
tr[d].mn = min(0LL, tr[d].s * tr[d].len);
for (long long i = top; i >= 1; i--) update(sta[i]);
}
root = merge(A.first, B.second);
} else {
long long l = read(), r = read(), v = read();
L = l;
ans = -1;
pair<long long, long long> A = split(root, l - 1);
pair<long long, long long> B = split(A.second, r);
long long n = B.first;
Findans(n, v);
if (ans >= 0) ans += 1;
if (ans > r || ans < l) {
puts("-1");
} else
printf("%.7lf\n", ans);
root = merge(A.first, merge(B.first, B.second));
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30);
const long long INFLL = (1ll << 60);
const long long MOD = (long long)(1e9 + 7);
void mul_mod(long long& a, long long b) {
a *= b;
a %= MOD;
}
void add_mod(long long& a, long long b) {
a = (a < MOD) ? a : (a - MOD);
b = (b < MOD) ? b : (b - MOD);
a += b;
a = (a < MOD) ? a : (a - MOD);
}
pair<int, long long> dp[3030][3030], sp[3030][3030];
long long w[3030], b[3030];
int ch[3030], m;
vector<int> g[3030];
void solve(int v, int p = -1) {
int i, j, k, u;
pair<int, long long> tmp;
for (i = (g[v].size() - 1); i >= 0; --i) {
if (g[v][i] == p) {
g[v].erase(g[v].begin() + i);
break;
}
}
for (i = (g[v].size() - 1); i >= 0; --i) {
u = g[v][i];
solve(u, v);
}
sp[g[v].size()][1] = pair<int, long long>(0, w[v] - b[v]);
ch[v] = 1;
for (i = (g[v].size() - 1); i >= 0; --i) {
u = g[v][i];
for (j = 1; j <= ch[v]; ++j) {
for (k = 1; k <= ch[u]; ++k) {
sp[i][j + k - 1] = pair<int, long long>(0, -INFLL);
sp[i][j + k] = pair<int, long long>(0, -INFLL);
}
}
for (j = 1; j <= ch[v]; ++j) {
for (k = 1; k <= ch[u]; ++k) {
tmp = pair<int, long long>(sp[i + 1][j].first + dp[u][k].first,
sp[i + 1][j].second + dp[u][k].second);
sp[i][j + k - 1] = max(sp[i][j + k - 1], tmp);
tmp = pair<int, long long>(sp[i + 1][j].first + dp[u][k].first +
((dp[u][k].second > 0ll) ? 1 : 0),
sp[i + 1][j].second);
sp[i][j + k] = max(sp[i][j + k], tmp);
}
}
ch[v] += ch[u];
}
for (j = 1; j <= ch[v]; ++j) {
dp[v][j] = sp[0][j];
}
}
int main(void) {
int t, n, i, j, u, v, ans;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
for (i = 0; i < n; ++i) {
scanf("%lld", &b[i]);
}
for (i = 0; i < n; ++i) {
scanf("%lld", &w[i]);
}
for (i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
solve(0);
ans = (dp[0][m].first + (dp[0][m].second > 0ll ? 1 : 0));
for (i = 0; i < n; ++i) {
g[i].clear();
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100000], f[100000], m;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
for (int i = 1; i < n; ++i) a[i] -= a[0];
a[0] = 0;
for (int i = 0; i < n - 1; ++i)
if (a[i + 1] - a[i] > 1) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n; ++i) f[a[i]]++;
m = a[n - 1];
if (m > 1)
for (int i = 1; i < m; ++i)
if (f[i] < 2) {
cout << "NO" << endl;
return 0;
}
for (int i = 1; i <= m; ++i) {
f[i] -= f[i - 1];
if (f[i] < 0) {
cout << "NO" << endl;
return 0;
}
}
if (f[m])
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
class BIT {
private:
vector<T> dat;
int n;
public:
BIT(int _n) : dat(_n + 1), n(_n) {}
T sum(int i) {
T s = 0;
while (i > 0) s += dat[i], i -= i & -i;
return s;
}
T sum(int l, int r) { return l > r ? 0 : sum(r) - sum(l - 1); }
void add(int i, T x) {
while (i <= n) dat[i] += x, i += i & -i;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<pair<int64_t, int64_t>> P(N);
for (auto &p : P) cin >> p.second;
for (auto &p : P) cin >> p.first;
sort(P.begin(), P.end());
vector<int> vs;
for (auto &p : P) vs.push_back(p.first);
P[0].first = 1;
for (int i = 1; i < N; ++i) {
P[i].first = P[i - 1].first + (vs[i - 1] != vs[i]);
}
for (auto &p : P) swap(p.first, p.second);
sort(P.begin(), P.end(), greater<pair<int, int>>());
int64_t ans = 0LL;
BIT<int64_t> bit(N), cnt(N);
for (auto &p : P) {
int x, v;
tie(x, v) = p;
ans += bit.sum(v, N) - x * cnt.sum(v, N);
bit.add(v, x);
cnt.add(v, 1);
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long abs(long long, long long);
void solve() {
string s;
cin >> s;
long long a[5][5];
long long n = s.length();
long long b[n][2];
for (long long i = 1; i < 5; i++) {
for (long long j = 1; j < 5; j++) a[i][j] = -1;
}
map<long long, long long> m;
for (long long i = 0; i < n; i++) {
if (s[i] == '0') {
m[0]++;
if (m[0] % 2 == 0) {
b[i][0] = 3;
b[i][1] = 1;
} else {
b[i][0] = 1;
b[i][1] = 1;
}
} else {
m[1]++;
if (m[1] % 4 == 1) {
b[i][0] = 1;
b[i][1] = 3;
} else if (m[1] % 4 == 2) {
b[i][0] = 2;
b[i][1] = 3;
} else if (m[1] % 4 == 3) {
b[i][0] = 3;
b[i][1] = 3;
} else if (m[1] % 4 == 0) {
b[i][0] = 4;
b[i][1] = 3;
}
}
}
for (long long i = 0; i < n; i++) {
cout << b[i][0] << " " << b[i][1] << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long TESTS = 1;
while (TESTS--) {
solve();
}
return 0;
}
long long abs(long long a, long long b) {
if (a > b)
return a - b;
else
return b - a;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int fa[400010], ch[400010][2], sz[400010], n, m, a[400010];
inline int Read() {
char c = getchar();
int num = 0;
while ('0' > c || c > '9') c = getchar();
while ('0' <= c && c <= '9') num = num * 10 + c - '0', c = getchar();
return (num);
}
inline void Up(int x) { sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + 1; }
inline bool Isrt(int x) { return (ch[fa[x]][0] != x && ch[fa[x]][1] != x); }
inline void Rot(int x) {
int f = fa[x], kid = (ch[f][1] == x);
if (!Isrt(f)) ch[fa[f]][(ch[fa[f]][1] == f)] = x;
ch[f][kid] = ch[x][!kid];
ch[x][!kid] = f;
if (ch[f][kid]) fa[ch[f][kid]] = f;
fa[x] = fa[f];
fa[f] = x;
Up(f);
Up(x);
}
inline void Splay(int x) {
while (!Isrt(x)) {
int f = fa[x], ff = fa[f];
if (Isrt(f)) {
Rot(x);
break;
}
if ((ch[ff][0] == f) == (ch[f][0] == x)) {
Rot(f);
Rot(x);
} else {
Rot(x);
Rot(x);
}
}
}
inline void Access(int x) {
int y = 0;
while (x) {
Splay(x);
ch[x][1] = y, Up(x);
y = x, x = fa[x];
}
}
inline void Link(int x, int y) {
Access(x);
Splay(x);
fa[x] = y;
}
inline void Cut(int x, int y) {
Access(x);
Splay(x);
fa[ch[x][0]] = 0;
ch[x][0] = 0;
Up(x);
}
inline void Ask(int x) {
Access(x);
Splay(x);
int l = x;
while (ch[l][0]) l = ch[l][0];
printf("%d %d\n", l, sz[ch[x][0]] + 1);
}
int main() {
n = Read();
m = Read();
for (int i = 1; i <= n; i++) {
a[i] = Read();
sz[i] = 1;
if (i + a[i] <= n) Link(i, i + a[i]);
}
for (int i = 1; i <= m; i++) {
int op = Read();
if (op == 0) {
int x = Read(), y = Read();
if (a[x] + x <= n) Cut(x, a[x] + x);
a[x] = y;
if (a[x] + x <= n) Link(x, a[x] + x);
} else {
int x = Read();
Ask(x);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void ECHO(string _s) {
cout << endl;
(void)_s;
}
template <typename T, typename... Args>
void ECHO(string _s, T x, Args... args) {
unsigned _i;
string _s2 = "";
for (_i = 0; _i < _s.length(); ++_i) {
if (_s[_i] == ',') break;
if (_s[_i] != ' ') _s2 += _s[_i];
}
if (_i == _s.length()) {
--_i;
}
cout << " (" << _s2 << "):" << x;
ECHO(_s.substr(_i + 1, _s.length() - _i - 1), args...);
}
template <typename T0, typename T1>
inline ostream& operator<<(ostream& os, pair<T0, T1>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline ostream& operator<<(ostream& os, vector<T>& v) {
for (unsigned i = 0; i < v.size(); ++i) {
cout << v[i] << "_";
}
cout << endl;
return os;
}
template <typename T>
inline T _min(T x1, T x2, T x3) {
return min(x1, min(x2, x3));
}
template <typename T>
inline T _min(T x1, T x2, T x3, T x4) {
return min(min(x1, x2), min(x2, x3));
}
inline long long _gcd(long long a, long long b) {
while (b) b %= a ^= b ^= a ^= b;
return a;
}
int main() {
ios::sync_with_stdio(false);
int t;
long long r, g, b, sum, low, car;
vector<long long> v;
cin >> t;
while (t--) {
cin >> r >> g >> b;
v.push_back(r);
v.push_back(g);
v.push_back(b);
sort(v.begin(), v.end());
sum = (r + b + g) / 2;
low = v[0] + v[1];
car = min(sum, low);
cout << car << "\n";
v.clear();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, mod = 1e9 + 7, ans;
long long sp(long long x, long long y) {
if (y == 0) return 1;
if (y % 2) return (sp(x, y - 1) * x) % mod;
long long f = sp(x, y / 2);
return (f * f) % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
if (n < m) swap(n, m);
if (m == 1 && n == 1) {
cout << 1;
return 0;
}
if (m == 1) {
if (k == -1) {
if (n % 2)
cout << 1;
else
cout << 0;
} else {
cout << 1;
}
return 0;
}
if (k == -1) {
if (n % 2 && m % 2) {
ans = sp(2, n - 1);
ans = sp(ans, m - 1);
}
if (n % 2 && m % 2 == 0) {
ans = 0;
}
if (n % 2 == 0 && m % 2) {
ans = 0;
}
if (n % 2 == 0 && m % 2 == 0) {
ans = sp(2, n - 1);
ans = sp(ans, m - 1);
}
} else {
ans = sp(2, n - 1);
ans = sp(ans, m - 1);
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a, b, as, bs, tmp(n + 1);
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
a = i;
b = n / i;
if (abs(a - b) < tmp) {
as = a;
bs = b;
tmp = abs(a - b);
}
}
}
cout << as << " " << bs << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int r;
cin >> r;
long long int a, b, c;
cin >> a >> b >> c;
if (a <= (b - c) && r > b)
cout << (r / a) << endl;
else {
long long int temp = r;
long long int count = 0;
if (temp > b) {
long long int t = (temp - b) / (b - c);
count += t;
temp -= t * (b - c);
}
if (temp >= b) {
count++;
temp -= b - c;
}
count += temp / a;
cout << max(count, r / a) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const long double eps = 1e-07;
const int dx[6] = {0, 0, 0, 0, 1, -1};
const int dy[6] = {0, 0, 1, -1, 0, 0};
const int dz[6] = {1, -1, 0, 0, 0, 0};
int k, n, m;
char a[15][15][15];
bool used[15][15][15];
int bfs(pair<pair<int, int>, int> start) {
queue<pair<pair<int, int>, int> > q;
q.push(start);
used[start.first.first][start.first.second][start.second] = true;
int res = 0;
while (!q.empty()) {
pair<pair<int, int>, int> cur = q.front();
q.pop();
++res;
for (int i = 0; i < 6; ++i) {
pair<pair<int, int>, int> tmp = cur;
tmp.first.first += dx[i];
tmp.first.second += dy[i];
tmp.second += dz[i];
if ((tmp.first.first < 0) || (tmp.first.first == k)) continue;
if ((tmp.first.second < 0) || (tmp.first.second == n)) continue;
if ((tmp.second < 0) || (tmp.second == m)) continue;
if (used[tmp.first.first][tmp.first.second][tmp.second]) continue;
used[tmp.first.first][tmp.first.second][tmp.second] = true;
q.push(tmp);
}
}
return res;
}
int main() {
cin >> k >> n >> m;
for (int i = 0; i < k; ++i)
for (int j = 0; j < n; ++j)
for (int z = 0; z < m; ++z) {
char c;
scanf(" %c ", &c);
if (c == '#') used[i][j][z] = true;
}
int x, y;
cin >> x >> y;
--x;
--y;
int ans = bfs(make_pair(make_pair(0, x), y));
cout << ans << endl;
return 0;
}
| 3 |
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,abm,mmx,tune=native")
#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<vector>
#include<set>
#include<utility>
#include<cstdlib>
#include<map>
#include<list>
#include<deque>
#define ll long long
#define ld long double
#define ull unsigned long long
#define endl '\n'
using namespace std;
ll gcd(ll i, ll j) {
if (j == 0)return i;
else return gcd(j, i % j);
}
ll lcm(ll i, ll j) {
return i * j / gcd(i, j);
}
ll max(ll i, ll j) {
return (i > j) ? i : j;
}
ll min(ll i, ll j) {
return (i < j) ? i : j;
}
ll numofdivs(ll n) {
ll ans = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
ans++;
else
ans += 2;
}
}
return ans;
}
bool prime(ll i) {
if (i < 2)
return false;
else {
for (int j = 2; j <= i / 2; j++) {
if (i % j == 0)
return false;
}
}
return true;
}
bool primewithexc(ll i, ll k) {
if (i < 2)
return false;
else {
for (ll j = 2; j <= i / 2; j++) {
if (j == k)
continue;
if (i % j == 0)
return false;
}
}
return true;
}
bool Tprime(ll i) {
if (sqrt(i) == (ll)sqrt(i))
if (numofdivs(i) == 3)
return true;
else
return false;
else
return false;
}
bool positive_negative(int n, int x)
{
if (n < 0 && x>0)
return true;
else if (n > 0 && x < 0)
return true;
else
return false;
}
void binary(vector<int>&v, int n) {
int i;
//cout << "Enter the number to convert: ";
//cin >> n;
for (i = 0; n > 0; i++)
{
v[i]= n % 2;
n = n / 2;
}
}
ll sumofdigs(ll n) {
ll sum = 0;
ll remainder = 0;
while (n > 0) {
remainder = n % 10;
sum += remainder;
n /= 10;
}
return sum;
}
int lcsnums(int x[], int y[], int n, int m)
{
int lcssuf[100 + 1][100 + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (i == 0 || j == 0)
lcssuf[i][j] = 0;
else if (x[i - 1] == y[j - 1])
lcssuf[i][j] = lcssuf[i - 1][j - 1] + 1;
else
lcssuf[i][j] = max(lcssuf[i - 1][j], lcssuf[i][j - 1]);
}
}
return lcssuf[n][m];
}
int lcs(string x, string y, int n, int m)
{
int lcssuf[100 + 1][100 + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (i == 0 || j == 0)
lcssuf[i][j] = 0;
else if (x[i - 1] == y[j - 1])
lcssuf[i][j] = lcssuf[i - 1][j - 1] + 1;
else
lcssuf[i][j] = max(lcssuf[i - 1][j], lcssuf[i][j - 1]);
}
}
return lcssuf[n][m];
}
int lcssub(string x, string y, int n, int m)
{
int lcssuf[100+1][100+1];
int answer = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (i == 0 || j == 0)
lcssuf[i][j] = 0;
else if (x[i - 1] == x[j - 1]) {
lcssuf[i][j] = lcssuf[i - 1][j - 1] + 1;
answer = max(answer, lcssuf[i][j]);
}
else
lcssuf[i][j] = 0;
}
}
return answer;
//return lcssuf[n][m];
}
string mul(string s, int k) {
string res = "";
while (k--) res += s;
return res;
};
int fact(int n) {
int sum = 1;
for (int i = 1; i <= n; i++)
sum *= i;
return sum;
}
void solve() {
string x = "NO";
string s;
for (ll i = 0; i <=18000; i++)
cout << x << endl;
}
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
//int t = 1;
//cin >> t;
//cout << min(1, 3);
//while (t--) {
solve();
//cout << ('s' - 'e');//9+13+12=34
//}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int **a, n, counter = 0, k;
cin >> n;
a = new int *[n];
for (int i = 0; i < n; i++) {
a[i] = new int[2];
cin >> a[i][0] >> a[i][1];
}
cin >> k;
for (int i = 0; i < n; i++) {
if (k <= a[i][1]) {
break;
} else {
counter++;
}
}
cout << n - counter;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, k, mask;
} e[105];
long long dp[2][1 << 20];
int cmp(const node &a, const node &b) { return a.k > b.k; }
int main() {
int i, j, n, m, b, c, x;
while (scanf("%d %d %d", &n, &m, &b) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%d %d %d", &e[i].x, &e[i].k, &c);
e[i].mask = 0;
for (j = 1; j <= c; j++) {
scanf("%d", &x);
e[i].mask |= 1 << x - 1;
}
sort(e + 1, e + n + 1, cmp);
}
for (j = 0; j < (1 << m); j++) dp[0][j] = 1LL << 62;
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j < (1 << m); j++) dp[i & 1][j] = dp[(i - 1) & 1][j];
for (j = 0; j < (1 << m); j++)
if (dp[(i - 1) & 1][j] != 1LL << 62) {
long long cost = dp[(i - 1) & 1][j] + e[i].x +
(j == 0 ? (long long)b * e[i].k : 0);
dp[i & 1][j | e[i].mask] = min(dp[i & 1][j | e[i].mask], cost);
}
}
long long ans = dp[n & 1][(1 << m) - 1];
if (ans == 1LL << 62)
printf("-1\n");
else
printf("%I64d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bitset<2000> b[2001];
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == '1') {
b[i].set(j);
}
}
}
for (int i = 0; i < n; i++) {
bitset<2000> cur;
cur.reset();
for (int j = 0; j < n; j++) {
if (i == j) continue;
cur |= b[j];
}
if (cur.count() == m) {
cout << "YES" << '\n';
return;
}
}
cout << "NO" << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> adj[n + 100];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int count1 = 0, count2 = 0, count3 = 0;
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1) count1++;
if (adj[i].size() == 2) count2++;
if (adj[i].size() == n - 1) count3++;
}
if (count2 == n)
cout << "ring topology";
else if (count1 == 2 && count2 == n - 2)
cout << "bus topology";
else if (count1 == n - 1 && count3 == 1)
cout << "star topology";
else
cout << "unknown topology ";
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long md = 1e9 + 7;
int cnt[(1ll << 12)][(1ll << 12)];
pair<pair<int, int>, bool> cnt1_w[4][6 * 6 * 6 * 6][(1ll << 4)];
int type[arr];
int a[arr];
int w, n, q;
pair<pair<int, int>, bool> get_kek(int p, int m, int mm) {
pair<pair<int, int>, bool> res = make_pair(make_pair(0, 0), 0);
for (int i = 0; i < p; i++) {
int cur_type = m % 6;
m /= 6;
if (cur_type == 0) {
if (mm & (1ll << i)) {
} else {
res.first.first ^= (1ll << i);
}
}
if (cur_type == 1) {
if (mm & (1ll << i)) {
res.second = 1;
} else {
}
}
if (cur_type == 2) {
if (mm & (1ll << i)) {
res.first.second ^= (1ll << i);
} else {
}
}
if (cur_type == 3) {
if (mm & (1ll << i)) {
res.first.second ^= (1ll << i);
} else {
res.second = 1;
}
}
if (cur_type == 4) {
if (mm & (1ll << i)) {
res.first.first ^= (1ll << i);
} else {
res.first.second ^= (1ll << i);
}
}
if (cur_type == 5) {
if (mm & (1ll << i)) {
} else {
res.first.second ^= (1ll << i);
}
}
}
return res;
}
int pw(int a, int n) {
int res = 1;
while (n--) {
res *= a;
}
return res;
}
void precalc() {
for (int p = 1; p <= 4; p++) {
for (int m = 0; m < pw(6, p); m++) {
for (int mm = 0; mm < (1ll << p); mm++) {
cnt1_w[p - 1][m][mm] = get_kek(p, m, mm);
}
}
}
}
inline bool podmask(int a, int b) { return ((a & b) == a); }
int cnt1[arr];
int main() {
precalc();
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> w >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 0; j < (1ll << w); j++) {
cnt[j][a[i] ^ j]++;
}
cnt1[a[i]]++;
}
for (int j = 0; j < (1ll << w); j++) {
for (int i = 0; i < w; i++) {
for (int k = 0; k < (1ll << w); k++) {
if (k & (1ll << i)) {
cnt[j][k] += cnt[j][k ^ (1ll << i)];
}
}
}
}
pair<pair<int, int>, bool> lolik;
pair<pair<int, int>, bool> lolik1;
pair<pair<int, int>, bool> lolik2;
pair<pair<int, int>, bool> lolik3;
if (w <= 8) {
for (int i = 0; i < q; i++) {
string s;
cin >> s;
int ans = 0;
for (int j = 0; j < w; j++) {
if (s[j] == 'A') {
type[j] = 0;
}
if (s[j] == 'O') {
type[j] = 1;
}
if (s[j] == 'X') {
type[j] = 2;
}
if (s[j] == 'a') {
type[j] = 0 + 3;
}
if (s[j] == 'o') {
type[j] = 1 + 3;
}
if (s[j] == 'x') {
type[j] = 2 + 3;
}
}
int mask_req = 0;
int mask_req_first_4 = 0;
int mask_req_after_4_before_8 = 0;
int mask_req_after_8_before_12 = 0;
if (w <= 4) {
for (int j = 0; j < w; j++) {
mask_req *= 6;
mask_req += type[j];
}
} else if (w <= 8) {
for (int j = w - 4; j < w; j++) {
mask_req_first_4 *= 6;
mask_req_first_4 += type[j];
}
for (int j = 0; j < w - 4; j++) {
mask_req_after_4_before_8 *= 6;
mask_req_after_4_before_8 += type[j];
}
} else {
for (int j = w - 4; j < w; j++) {
mask_req_first_4 *= 6;
mask_req_first_4 += type[j];
}
for (int j = w - 8; j < w - 4; j++) {
mask_req_after_4_before_8 *= 6;
mask_req_after_4_before_8 += type[j];
}
for (int j = 0; j < w - 8; j++) {
mask_req_after_8_before_12 *= 6;
mask_req_after_8_before_12 += type[j];
}
}
for (int j = 0; j < (1ll << w); j++) {
if (w <= 4) {
lolik = cnt1_w[w - 1][mask_req][j];
} else if (w <= 8) {
lolik1 = cnt1_w[4 - 1][mask_req_first_4][j & ((1ll << 4) - 1)];
lolik2 = cnt1_w[w - 4 - 1][mask_req_after_4_before_8][j >> 4];
lolik.first.first = lolik1.first.first + ((lolik2.first.first) << 4);
lolik.first.second =
lolik1.first.second + ((lolik2.first.second) << 4);
lolik.second = lolik1.second | lolik2.second;
} else {
lolik1 = cnt1_w[4 - 1][mask_req_first_4][j & ((1ll << 4) - 1)];
lolik2 = cnt1_w[4 - 1][mask_req_after_4_before_8]
[(j >> 4) & ((1ll << 4) - 1)];
lolik3 = cnt1_w[w - 8 - 1][mask_req_after_8_before_12][j >> 8];
lolik.first.first = lolik1.first.first + ((lolik2.first.first) << 4) +
((lolik3.first.first) << 8);
lolik.first.second = lolik1.first.second +
((lolik2.first.second) << 4) +
((lolik3.first.second) << 8);
lolik.second = lolik1.second | lolik2.second | lolik3.second;
}
if (!lolik.second) {
ans += (cnt[lolik.first.second][lolik.first.first] * cnt1[j]);
}
}
cout << ans << "\n";
}
} else {
map<string, int> answer;
for (int i = 0; i < q; i++) {
string s;
cin >> s;
int ans = 0;
for (int j = 0; j < w; j++) {
if (s[j] == 'A') {
type[j] = 0;
}
if (s[j] == 'O') {
type[j] = 1;
}
if (s[j] == 'X') {
type[j] = 2;
}
if (s[j] == 'a') {
type[j] = 0 + 3;
}
if (s[j] == 'o') {
type[j] = 1 + 3;
}
if (s[j] == 'x') {
type[j] = 2 + 3;
}
}
int mask_req_first_4 = 0;
int mask_req_after_4_before_8 = 0;
int mask_req_after_8_before_12 = 0;
for (int j = w - 4; j < w; j++) {
mask_req_first_4 *= 6;
mask_req_first_4 += type[j];
}
for (int j = w - 8; j < w - 4; j++) {
mask_req_after_4_before_8 *= 6;
mask_req_after_4_before_8 += type[j];
}
for (int j = 0; j < w - 8; j++) {
mask_req_after_8_before_12 *= 6;
mask_req_after_8_before_12 += type[j];
}
if (answer.count(s)) {
cout << answer[s] << "\n";
continue;
}
for (int j = 0; j < (1ll << w); j++) {
lolik1 = cnt1_w[4 - 1][mask_req_first_4][j & ((1ll << 4) - 1)];
lolik2 = cnt1_w[4 - 1][mask_req_after_4_before_8]
[(j >> 4) & ((1ll << 4) - 1)];
lolik3 = cnt1_w[w - 8 - 1][mask_req_after_8_before_12][j >> 8];
lolik.first.first = lolik1.first.first + ((lolik2.first.first) << 4) +
((lolik3.first.first) << 8);
lolik.first.second = lolik1.first.second +
((lolik2.first.second) << 4) +
((lolik3.first.second) << 8);
lolik.second = lolik1.second | lolik2.second | lolik3.second;
if (!lolik.second) {
ans += (cnt[lolik.first.second][lolik.first.first] * cnt1[j]);
}
}
answer[s] = ans;
cout << ans << "\n";
}
}
}
| 10 |
#include<bits/stdc++.h>
#include<unordered_map>
#include<unordered_set>
#include<iomanip>
using namespace std;
const int N = 1e6 + 10;
typedef long long ll;
int primes[N], cnt;
bool st[N];
void get_prime(int n)
{
for(int i = 2 ; i <= n ; i ++)
{
if(!st[i]) primes[cnt ++] = i;
int t = n / i;
for(int j = 0 ; primes[j] <= t ; j ++)
{
st[primes[j] * i] = true;
if(i % primes[j] == 0) break;
}
}
}
int main()
{
get_prime(N - 10);
int T;
cin >> T;
while(T --)
{
int d;
cin >> d;
ll res = 1;
int last = 1, sum = 0;
for(int i = 0 ; ; i ++)
{
if(primes[i] - last >= d)
res *= primes[i], last = primes[i], sum ++;
if(sum == 2) break;
}
cout << res << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 65;
int G[maxn][maxn][maxn], dp[maxn][maxn][maxn];
int main() {
int n, m, r;
while (scanf("%d%d%d", &n, &m, &r) != EOF) {
for (int k = 1; k <= m; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &G[k][i][j]);
}
}
}
for (int l = 1; l <= m; l++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
G[l][i][j] = min(G[l][i][j], G[l][i][k] + G[l][k][j]);
}
}
}
}
for (int k = 0; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[k][i][j] = inf;
}
}
}
for (int l = 1; l <= m; l++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[0][i][j] = min(dp[0][i][j], G[l][i][k] + G[l][k][j]);
}
}
}
}
for (int l = 1; l <= n; l++) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[l][i][j] = min(dp[l][i][j], dp[l - 1][i][k] + dp[0][k][j]);
}
}
}
}
while (r--) {
int s, e, k;
scanf("%d%d%d", &s, &e, &k);
int ans = inf;
k = min(k, n);
for (int i = 0; i <= k; i++) ans = min(ans, dp[i][s][e]);
printf("%d\n", ans);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, a[300050];
bool vis[300050];
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] < 0) p = i;
}
long long res = 0;
for (int k = n; k > 1; k >>= 1) {
if (p >= k) break;
int mp = -1;
for (int i = k; i <= n; i++)
if (!vis[i] && (mp < 0 || a[i] < a[mp])) mp = i;
res += a[mp];
vis[mp] = 1;
}
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC target("avx,tune=native")
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000009;
inline string getstr(string &s, int l, int r) {
string ret = "";
for (int i = l; i <= r; i++) ret.push_back(s[i]);
return ret;
}
int modpow(int x, int y, int md = mod) {
if (y == 0) return 1;
int ret = modpow(x, y >> 1, md);
ret = (long long)ret * ret % md;
if (y & 1) ret = (long long)ret * x % md;
return ret;
}
int n, h, orz;
int dp[2][33][33][33][33];
inline void add(int &x, int y) { x = (x + y >= mod ? x + y - mod : x + y); }
void upd1(int x) {
for (int b = 0; b <= 31; b++) {
for (int c = 0; c <= 31; c++) {
for (int d = 0; d <= 31; d++) {
if (b >= h && b <= 30) continue;
if (c >= h && c <= 30) continue;
if (d >= h && d <= 30) continue;
int &val1 = dp[x][0][b][c][d];
int &val2 = dp[x][32][b][c][d];
int nxt = x ^ 1, nxtb = min(b + 1, h), nxtc = min(c + 1, h),
nxtd = min(d + 1, h);
if (nxtb == h) nxtb = 31;
if (nxtc == h) nxtc = 31;
if (nxtd == h) nxtd = 31;
add(dp[nxt][0][nxtb][nxtc][nxtd], val1);
add(dp[nxt][1][b != 31 ? 0 : 32][nxtc][nxtd], val1);
add(dp[nxt][1][nxtb][c != 31 ? 0 : 32][nxtd], val1);
add(dp[nxt][1][nxtb][nxtc][d != 31 ? 0 : 32], val1);
add(dp[nxt][32][nxtb][nxtc][nxtd], val2);
add(dp[nxt][31][b != 31 ? 0 : 32][nxtc][nxtd], val2);
add(dp[nxt][31][nxtb][c != 31 ? 0 : 32][nxtd], val2);
add(dp[nxt][31][nxtb][nxtc][d != 31 ? 0 : 32], val2);
}
}
}
}
void upd2(int x) {
for (int b = 0; b <= 31; b++) {
for (int c = 0; c <= 31; c++) {
for (int d = 0; d <= 31; d++) {
if (b >= h && b <= 30) continue;
if (c >= h && c <= 30) continue;
if (d >= h && d <= 30) continue;
int &val1 = dp[x][b][0][c][d];
int &val2 = dp[x][b][32][c][d];
int nxt = x ^ 1, nxtb = min(b + 1, h), nxtc = min(c + 1, h),
nxtd = min(d + 1, h);
if (nxtb == h) nxtb = 31;
if (nxtc == h) nxtc = 31;
if (nxtd == h) nxtd = 31;
add(dp[nxt][nxtb][0][nxtc][nxtd], val1);
add(dp[nxt][b != 31 ? 0 : 32][1][nxtc][nxtd], val1);
add(dp[nxt][nxtb][1][c != 31 ? 0 : 32][nxtd], val1);
add(dp[nxt][nxtb][1][nxtc][d != 31 ? 0 : 32], val1);
add(dp[nxt][nxtb][32][nxtc][nxtd], val2);
add(dp[nxt][b != 31 ? 0 : 32][31][nxtc][nxtd], val2);
add(dp[nxt][nxtb][31][c != 31 ? 0 : 32][nxtd], val2);
add(dp[nxt][nxtb][31][nxtc][d != 31 ? 0 : 32], val2);
}
}
}
}
void upd3(int x) {
for (int b = 0; b <= 31; b++) {
for (int c = 0; c <= 31; c++) {
for (int d = 0; d <= 31; d++) {
if (b >= h && b <= 30) continue;
if (c >= h && c <= 30) continue;
if (d >= h && d <= 30) continue;
int &val1 = dp[x][b][c][0][d];
int &val2 = dp[x][b][c][32][d];
int nxt = x ^ 1, nxtb = min(b + 1, h), nxtc = min(c + 1, h),
nxtd = min(d + 1, h);
if (nxtb == h) nxtb = 31;
if (nxtc == h) nxtc = 31;
if (nxtd == h) nxtd = 31;
add(dp[nxt][nxtb][nxtc][0][nxtd], val1);
add(dp[nxt][b != 31 ? 0 : 32][nxtc][1][nxtd], val1);
add(dp[nxt][nxtb][c != 31 ? 0 : 32][1][nxtd], val1);
add(dp[nxt][nxtb][nxtc][1][d != 31 ? 0 : 32], val1);
add(dp[nxt][nxtb][nxtc][32][nxtd], val2);
add(dp[nxt][b != 31 ? 0 : 32][nxtc][31][nxtd], val2);
add(dp[nxt][nxtb][c != 31 ? 0 : 32][31][nxtd], val2);
add(dp[nxt][nxtb][nxtc][31][d != 31 ? 0 : 32], val2);
}
}
}
}
void upd4(int x) {
for (int b = 0; b <= 31; b++) {
for (int c = 0; c <= 31; c++) {
for (int d = 0; d <= 31; d++) {
if (b >= h && b <= 30) continue;
if (c >= h && c <= 30) continue;
if (d >= h && d <= 30) continue;
int &val1 = dp[x][b][c][d][0];
int &val2 = dp[x][b][c][d][32];
int nxt = x ^ 1, nxtb = min(b + 1, h), nxtc = min(c + 1, h),
nxtd = min(d + 1, h);
if (nxtb == h) nxtb = 31;
if (nxtc == h) nxtc = 31;
if (nxtd == h) nxtd = 31;
add(dp[nxt][nxtb][nxtc][nxtd][0], val1);
add(dp[nxt][b != 31 ? 0 : 32][nxtc][nxtd][1], val1);
add(dp[nxt][nxtb][c != 31 ? 0 : 32][nxtd][1], val1);
add(dp[nxt][nxtb][nxtc][d != 31 ? 0 : 32][1], val1);
add(dp[nxt][nxtb][nxtc][nxtd][32], val2);
add(dp[nxt][b != 31 ? 0 : 32][nxtc][nxtd][31], val2);
add(dp[nxt][nxtb][c != 31 ? 0 : 32][nxtd][31], val2);
add(dp[nxt][nxtb][nxtc][d != 31 ? 0 : 32][31], val2);
}
}
}
}
int main() {
cin >> n >> h;
int tmp = h == 1 ? 31 : 1;
dp[1][0][tmp][tmp][tmp] = 1;
dp[1][tmp][0][tmp][tmp] = 1;
dp[1][tmp][tmp][0][tmp] = 1;
dp[1][tmp][tmp][tmp][0] = 1;
for (int i = 1; i < n; i++) {
upd1(i & 1);
upd2(i & 1);
upd3(i & 1);
upd4(i & 1);
memset(dp[i & 1], 0, sizeof dp[i & 1]);
}
int ans = 0;
for (int i = 0; i < 33; i++)
for (int j = 0; j < 33; j++)
for (int k = 0; k < 33; k++)
for (int l = 0; l < 33; l++) {
if (i < h || j < h || k < h || l < h)
if (dp[n & 1][i][j][k][l]) add(ans, dp[n & 1][i][j][k][l]);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
int main() {
int n = read(), ans = 0;
static int a[500005];
for (int i = 1; i <= n; ++i) a[i] = read();
sort(a + 1, a + n + 1);
for (int i = 1, j = (n >> 1) + 1; i <= (n >> 1) && j <= n; ++i) {
for (; j < n && a[i] * 2 > a[j]; ++j)
;
if (a[i] * 2 <= a[j]) ++ans, ++j;
}
printf("%d\n", n - ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
const double e = exp(1.0);
const int INF = 0x7fffffff;
;
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
inline T Min(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T Max(T a, T b) {
return a > b ? a : b;
}
bool cmpbig(int a, int b) { return a > b; }
bool cmpsmall(int a, int b) { return a < b; }
using namespace std;
int heshu[1000010];
int heset[1000010];
int k;
void init() {
memset(heshu, 0, sizeof(heshu));
for (int i = 2; i * i <= 1e6; i++)
for (int j = i; j * i <= 1e6; j++) heshu[i * j] = 1;
k = 0;
for (int i = 4; i < 1e6; i++)
if (heshu[i]) heset[k++] = i;
}
bool check(int num) {
int l = 0, r = k - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (num > heset[mid])
l = mid + 1;
else if (num < heset[mid])
r = mid - 1;
else
return true;
}
return false;
}
int main() {
int n;
init();
while (cin >> n) {
for (int i = 4; i < n; i++) {
if (heshu[i] && check(n - i)) {
cout << i << " " << n - i << endl;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[n + 1], brr[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
brr[i] = arr[i];
}
sort(brr + 1, brr + n + 1);
long long sum[n + 1], sum2[n + 1];
memset(sum, 0, sizeof(sum));
memset(sum2, 0, sizeof(sum2));
sum[1] = arr[1];
sum2[1] = brr[1];
for (long long i = 2; i <= n; i++) {
sum[i] = arr[i] + sum[i - 1];
sum2[i] = brr[i] + sum2[i - 1];
}
long long q;
cin >> q;
while (q--) {
long long x, y, z;
cin >> x >> y >> z;
if (x == 1) cout << sum[z] - sum[y - 1] << "\n";
if (x == 2) cout << sum2[z] - sum2[y - 1] << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vector<long long> a;
long long n, v1, v2;
cin >> n;
for (long long i = 1; i <= n; i++) {
a.push_back(1);
while (a.size() > 1) {
v2 = a.back();
a.pop_back();
v1 = a.back();
a.pop_back();
if (v1 != v2) {
a.push_back(v1);
a.push_back(v2);
break;
}
a.push_back(v1 + 1);
}
}
for (long long i = 0; i < a.size(); i++) cout << a[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = 3.14159265359;
vector<long long> primes;
void GeneratingPrimes(int top) {
vector<bool> p(top + 1, 1);
p[0] = p[1] = 0;
for (int i = 2; i <= sqrt(top); i++) {
if (p[i]) {
for (int j = i * i; j <= top; j += i) {
p[j] = 0;
}
}
}
for (int i = 0; i < top + 1; i++)
if (p[i]) primes.push_back(i);
}
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
void EXTgcd(long long a, long long b, int& x0, int& y0) {
if (b == 0) {
x0 = 1, y0 = 0;
return;
}
EXTgcd(b, a % b, x0, y0);
long long x1 = y0;
long long y1 = x0 - (a / b) * y0;
x0 = x1;
y0 = y1;
}
long long power(long long n, long long p, long long mod) {
if (!p) return 1;
long long ans = 1;
while (p > 1) {
if (p & 1) ans = (ans * n) % mod;
n = (n * n) % mod;
p /= 2;
}
return (ans * n) % mod;
}
double dist(double a, double b, double x, double y) {
return sqrt(pow(a - x, 2) + pow(b - y, 2));
}
double dist3(double a, double b, double c, double x, double y, double z) {
return sqrt(pow(a - x, 2) + pow(b - y, 2) + pow(c - z, 2));
}
int xadd[9] = {1, -1, 0, 1, -1, 0, 1, -1, 0};
int yadd[9] = {1, -1, 0, -1, 0, 1, 0, 1, -1};
int xx[4] = {0, 1, 0, -1};
int yy[4] = {1, 0, -1, 0};
long long const N = 1e5 + 10;
long long const mod = 1e9 + 7;
long long const INF = 1e9;
int n, a[N];
bool chk(int mid) {
set<int> s, ns;
for (int i = 0; i < n; i++) s.insert(i), ns.insert(-i);
for (int i = 0; i < n; i++)
if (mid >= a[i]) {
int r = mid - a[i];
auto it = s.lower_bound(i);
while (it != s.end()) {
int z = *it;
if (z - i <= r) {
auto x = it++;
s.erase(x);
if (ns.count(-z)) ns.erase(-z);
} else
break;
}
it = ns.lower_bound(-i);
while (it != ns.end()) {
int z = *it;
if (i + z <= r) {
auto x = it++;
ns.erase(x);
if (s.count(-z)) s.erase(-z);
} else
break;
}
}
for (int x : s) {
x++;
if (x > mid && x <= n - mid) return 0;
}
return 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int lo = 1, hi = n, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (chk(mid)) {
hi = mid - 1;
} else {
lo = mid + 1;
}
}
cout << hi + 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, i, j, k, l, a[1000009], b[1000009], p[1000009], ans, cn, t,
x, y, z, mx, mn, s;
char c[1000009], d[1000009], ch;
int main() {
while (scanf("%I64d", &n) != EOF) {
x = y = 0;
for (i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
x |= a[i];
}
for (i = 0; i < n; i++) {
scanf("%I64d", &b[i]);
y |= b[i];
}
ans = x + y;
printf("%I64d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long xinyue, a, b, p, q, len;
long long calc(long long a, long long b, long long c, long long n) {
if (!a || !n) return (n + 1) * (b / c);
if (n < 0) return 0;
long long m = (a * n + b) / c;
if (a >= c || b >= c)
return calc(a % c, b % c, c, n) + (n * (n + 1) >> 1) * (a / c) +
(n + 1) * (b / c);
return m * n - calc(c, c - b - 1, a, m - 1);
}
long long gcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = gcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
int main() {
scanf("%lld", &xinyue);
while (xinyue--) {
scanf("%lld%lld%lld%lld", &a, &b, &p, &q);
long long l = 0, r = q, P = p << 1, Q = q << 1;
while (l < r) {
long long mid = l + r >> 1;
long long L = q - mid, R = q + mid + 1;
if (calc(P, Q - L, Q, b) + calc(P, Q - R, Q, a - 1) -
calc(P, Q - L, Q, a - 1) - calc(P, Q - R, Q, b) >
0)
r = mid;
else
l = mid + 1;
}
long long x, y, g = gcd(P, Q, x, y), ans = 1e9;
P /= g;
Q /= g;
if ((q - l) % g == 0) {
long long xx = (q - l) / g * x;
xx += (a - xx) / Q * Q;
while (xx >= a) xx -= Q;
while (xx < a) xx += Q;
ans = min(ans, xx);
}
if ((q + l) % g == 0) {
long long xx = (q + l) / g * x;
xx += (a - xx) / Q * Q;
while (xx >= a) xx -= Q;
while (xx < a) xx += Q;
ans = min(ans, xx);
}
printf("%lld\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
int n;
string s;
cin >> n >> s;
set<int> se[3];
for (int i = 0; i < n; i++) {
se[s[i] - '0'].insert(i);
}
while (se[0].size() > n / 3) {
int v = *se[0].rbegin();
se[0].erase(v);
if (se[2].size() < n / 3) {
se[2].insert(v);
} else {
se[1].insert(v);
}
}
while (se[1].size() > n / 3) {
if (se[0].size() < n / 3) {
se[0].insert(*se[1].begin());
se[1].erase(se[1].begin());
} else {
se[2].insert(*se[1].rbegin());
se[1].erase(*se[1].rbegin());
}
}
while (se[2].size() > n / 3) {
int v = *se[2].begin();
se[2].erase(v);
if (se[0].size() < n / 3) {
se[0].insert(v);
} else {
se[1].insert(v);
}
}
vector<char> a(n);
for (int i = 0; i < 3; i++) {
for (auto x : se[i]) {
a[x] = i + '0';
}
}
for (auto c : a) {
cout << c;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool RD(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1, ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void PT(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) PT(x / 10);
putchar(x % 10 + '0');
}
pair<int, int> a[3];
int b[3];
char val[3] = {'A', 'B', 'C'};
int main() {
b[0] = 0, b[1] = 1, b[2] = 2;
for (int i = 0; i < int(3); i++) {
RD(a[i].first), RD(a[i].second);
}
pair<int, int> c[3];
do {
for (int mask = 0; mask < (1 << 3); mask++) {
for (int i = 0; i < 3; i++)
if (mask & (1 << i))
c[i] = pair<int, int>(a[b[i]].second, a[b[i]].first);
else
c[i] = pair<int, int>(a[b[i]].first, a[b[i]].second);
if (c[0].first == c[1].first && c[1].first == c[2].first &&
c[0].second + c[1].second + c[2].second == c[0].first) {
printf("%d\n", c[0].first);
for (int x = 1; x <= int(c[0].first); x++) {
for (int y = 1; y <= int(c[0].second); y++) putchar(val[b[0]]);
for (int y = 1; y <= int(c[1].second); y++) putchar(val[b[1]]);
for (int y = 1; y <= int(c[2].second); y++) putchar(val[b[2]]);
puts("");
}
return 0;
}
if (c[0].first == c[1].first &&
c[0].second + c[1].second == c[2].second &&
c[2].second == c[0].first + c[2].first) {
printf("%d\n", c[2].second);
for (int x = 1; x <= int(c[0].first); x++) {
for (int y = 1; y <= int(c[0].second); y++) putchar(val[b[0]]);
for (int y = 1; y <= int(c[1].second); y++) putchar(val[b[1]]);
puts("");
}
for (int x = 1; x <= int(c[2].first); x++) {
for (int y = 1; y <= int(c[2].second); y++) putchar(val[b[2]]);
puts("");
}
puts("");
return 0;
}
}
} while (next_permutation(b, b + 3));
puts("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i, last, a[1010], ans[1010][1010];
bool used[1010];
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++)
if (a[i] != i) break;
if (i == n + 1) {
cout << n << '\n';
string s = "";
for (i = 1; i <= n; i++) s += '.';
for (i = 1; i <= n; i++) cout << s << '\n';
return 0;
}
i = n;
last = n;
used[i] = 1;
while (a[i] != n) {
if (a[i] > i)
ans[last][i] = ans[last][a[i]] = 1;
else
ans[last][i] = ans[last][a[i]] = 2;
last--;
used[i] = used[a[i]] = 1;
i = a[i];
}
for (int k = n, j = last + 1; k >= j; k--, j++) swap(ans[k], ans[j]);
for (i = 1; i <= n; i++)
if ((!used[i]) && (a[i] != i)) {
int j = a[i], cnt = 1;
used[i] = 1;
while (j != i) {
used[j] = 1;
cnt++;
j = a[j];
}
ans[last][i] = ans[last][a[i]] = ans[last][n] = 1;
ans[last - cnt + 1][a[a[i]]] = ans[last - cnt + 1][n] = 2;
int newlast = last - cnt;
j = a[a[i]];
cnt = 1;
while (j != i) {
if (a[j] > j)
ans[last - cnt][j] = ans[last - cnt][a[j]] = 1;
else
ans[last - cnt][j] = ans[last - cnt][a[j]] = 2;
j = a[j];
cnt++;
}
for (int k = last - 1, p = newlast + 2; k > p; k--, p++)
swap(ans[k], ans[p]);
last = newlast;
}
cout << n - 1 << '\n';
for (i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (ans[i][j] == 1)
cout << '/';
else if (ans[i][j] == 2)
cout << '\\';
else
cout << '.';
cout << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int N, Q;
set<pair<int, int> > g[100001];
int t0[100001], t1[100001], t2[100001];
int p[100001];
template <typename T>
class RMQ {
public:
std::vector<T> data;
std::vector<std::vector<int> > block;
std::vector<int> sblock;
std::vector<int> lookup;
int lg;
int min(int a, int b) { return data[b] < data[a] ? b : a; }
RMQ() {}
RMQ(std::vector<T> &t) {
data = t;
int N = data.size();
lg = (sizeof(N) << 3) - __builtin_clz(N);
block.assign((N + lg - 1) / lg, std::vector<int>(lg, 0));
for (int i = 0; i < N; i++) {
if (i % lg == 0) block[i / lg][0] = i;
block[i / lg][0] = min(i, block[i / lg][0]);
}
for (int j = 1; j < lg; j++)
for (int i = 0; i < block.size(); i++)
block[i][j] = min(
block[i][j - 1],
block[i + (i + (1 << (j - 1)) < block.size() ? (1 << (j - 1)) : 0)]
[j - 1]);
sblock.assign(N, 0);
std::vector<int> st;
for (int i = 0; i < block.size(); i++) {
st.clear();
for (int j = i * lg; j < N && j < i * lg + lg; j++) {
while (!st.empty() && data[j] < data[st.back()]) st.pop_back();
sblock[j] = 1 << (i * lg + lg - j - 1);
if (!st.empty()) sblock[j] |= sblock[st.back()];
st.push_back(j);
}
}
lookup.assign(1 << lg, 0);
for (int i = 1, ans = lg - 1, checker = 2; i < (1 << lg); ++i) {
if (checker <= i) {
ans--;
checker <<= 1;
}
lookup[i] = ans;
}
}
int q(int l, int r) {
if (r < l) swap(l, r);
int l1 = l / lg + 1;
int r1 = r / lg - 1;
int ans = l;
int t;
if (l1 <= r1) {
t = lg - lookup[r1 - l1 + 1] - 1;
ans = min(ans, min(block[l1][t], block[r1 - (1 << t) + 1][t]));
}
t = l1 * lg - 1 < r ? l1 * lg - 1 : r;
ans = min(ans, lookup[sblock[t] & (~(((1 << (l - (l1 * lg - lg))) - 1)
<< (l1 * lg - l)))] +
l1 * lg - lg);
t = r;
l = l > r1 * lg + lg ? l : r1 * lg + lg;
ans = min(ans, lookup[sblock[t] & (~(((1 << (l - (r1 * lg + lg))) - 1)
<< (r1 * lg + (lg << 1) - l)))] +
r1 * lg + lg);
return ans;
}
};
template <typename T>
class segment_tree {
public:
vector<T> data;
vector<T> tt;
int N;
int construct(int root, int cl, int cr) {
if (cl == cr) return tt[root] = cl;
int t1 = construct(root * 2, cl, (cl + cr) / 2);
int t2 = construct(root * 2 + 1, (cl + cr) / 2 + 1, cr);
return tt[root] = data[t2] < data[t1] ? t2 : t1;
}
int query(int root, int cl, int cr, int l, int r) {
if (cl > r || cr < l) return N;
if (l <= cl && cr <= r) return tt[root];
int t1 = query(root * 2, cl, (cl + cr) / 2, l, r);
int t2 = query(root * 2 + 1, (cl + cr) / 2 + 1, cr, l, r);
return data[t2] < data[t1] ? t2 : t1;
}
inline int q(int l, int r) {
if (r < l) swap(l, r);
return query(1, 0, N - 1, l, r);
}
segment_tree(){};
segment_tree(vector<T> a) {
N = a.size();
data = a;
data.push_back(INT_MAX);
tt.resize(4 * N);
construct(1, 0, N - 1);
}
};
class least_common_ancestor {
public:
int N;
vector<vector<int> > g;
vector<int> invf;
vector<int> f;
vector<int> ll;
RMQ<int> rmq;
void inorder(int s = 0, int d = 0) {
ll.push_back(d);
invf[ll.size() - 1] = s;
f[s] = ll.size() - 1;
for (int i = 0; i < g[s].size(); i++) {
inorder(g[s][i], d + 1);
ll.push_back(d);
invf[ll.size() - 1] = s;
}
}
least_common_ancestor(){};
least_common_ancestor(vector<vector<int> > t) {
g = t;
N = g.size();
f.resize(N);
invf.resize(2 * N - 1);
inorder();
rmq = RMQ<int>(ll);
ll.clear();
g.clear();
}
int q(int a, int b) { return invf[rmq.q(f[a], f[b])]; }
};
void fix(int s) {
for (pair<int, int> i : g[s]) {
g[i.first].erase(g[i.first].lower_bound(make_pair(s, 0)));
p[i.first] = s;
fix(i.first);
}
}
int add(int a, int b) {
int ret = a + b;
if (ret >= MOD) ret -= MOD;
return ret;
}
int mul(int a, int b) { return (a * 1ll * b) % MOD; }
int ddd[100001];
least_common_ancestor lca;
int dist(int a, int b) {
return add(add(ddd[a], ddd[b]), MOD - mul(2, ddd[1 + lca.q(a - 1, b - 1)]));
}
set<pair<int, int> > q[100001];
vector<int> ans;
void dfs1(int s, int d = 0) {
t0[s] = 1;
ddd[s] = d;
for (pair<int, int> i : g[s]) {
dfs1(i.first, add(d, i.second));
t0[s] = add(t0[s], t0[i.first]);
t1[s] = add(t1[s], mul(t0[i.first], i.second));
t1[s] = add(t1[s], t1[i.first]);
t2[s] = add(t2[s], t2[i.first]);
t2[s] = add(t2[s], mul(t1[i.first], mul(2, i.second)));
t2[s] = add(t2[s], mul(t0[i.first], mul(i.second, i.second)));
}
}
set<pair<int, pair<int, int> > > st[100001];
void dfs(int s) {
for (pair<int, int> i : g[s]) {
int pt0 = t0[i.first];
int pt1 = t1[i.first];
pt1 = add(pt1, mul(t0[i.first], i.second));
int pt2 = t2[i.first];
pt2 = add(pt2, mul(t1[i.first], mul(2, i.second)));
pt2 = add(pt2, mul(t0[i.first], mul(i.second, i.second)));
t0[s] = add(t0[s], MOD - pt0);
t1[s] = add(t1[s], MOD - pt1);
t2[s] = add(t2[s], MOD - pt2);
int ppt0 = t0[s];
int ppt1 = t1[s];
ppt1 = add(ppt1, mul(t0[s], i.second));
int ppt2 = t2[s];
ppt2 = add(ppt2, mul(t1[s], mul(2, i.second)));
ppt2 = add(ppt2, mul(t0[s], mul(i.second, i.second)));
t0[i.first] = add(t0[i.first], ppt0);
t1[i.first] = add(t1[i.first], ppt1);
t2[i.first] = add(t2[i.first], ppt2);
dfs(i.first);
t0[i.first] = add(t0[i.first], MOD - ppt0);
t1[i.first] = add(t1[i.first], MOD - ppt1);
t2[i.first] = add(t2[i.first], MOD - ppt2);
t0[s] = add(t0[s], pt0);
t1[s] = add(t1[s], pt1);
t2[s] = add(t2[s], pt2);
}
for (pair<int, int> i : g[s])
if (st[i.first].size() > st[s].size()) swap(st[i.first], st[s]);
for (pair<int, int> i : g[s]) {
st[s].insert(st[i.first].begin(), st[i.first].end());
st[i.first].clear();
}
for (set<pair<int, pair<int, int> > >::iterator it =
st[s].lower_bound(make_pair(s, make_pair(0, 0)));
it != st[s].end() && it->first == s; it++) {
if (s == 1) continue;
int ooo = dist(p[s], it->second.first);
ans[it->second.second] =
add(ans[it->second.second],
MOD - mul(2, add(t2[p[s]], add(mul(t1[p[s]], mul(2, ooo)),
mul(t0[p[s]], mul(ooo, ooo))))));
}
for (pair<int, int> i : q[s]) {
if (i.first == s || lca.q(s - 1, i.first - 1) + 1 != i.first) {
ans[i.second] = MOD - t2[s];
continue;
}
ans[i.second] = t2[s];
st[s].insert(make_pair(i.first, make_pair(s, i.second)));
}
}
vector<vector<int> > g1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
for (int i = 1, a, b, c; i < N; i++) {
cin >> a >> b >> c;
g[a].insert(make_pair(b, c));
g[b].insert(make_pair(a, c));
}
g1.resize(N + 1);
cin >> Q;
ans.resize(Q);
for (int i = 0, u, v; i < Q; i++) {
cin >> u >> v;
q[u].insert(make_pair(v, i));
}
fix(1);
for (int i = 1; i <= N; i++)
for (pair<int, int> j : g[i]) g1[i - 1].push_back(j.first - 1);
lca = least_common_ancestor(g1);
dfs1(1);
dfs(1);
for (int s = 1; s <= N; s++)
for (pair<int, int> i : q[s]) {
if (s != i.first && lca.q(s - 1, i.first - 1) + 1 == i.first) continue;
int ooo = dist(s, i.first);
ans[i.second] =
add(ans[i.second],
mul(2, add(t2[i.first], add(mul(t1[i.first], mul(2, ooo)),
mul(t0[i.first], mul(ooo, ooo))))));
}
for (int i : ans) cout << i << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100100], d[100100], cnt[100100], bad[100100];
vector<pair<long long, long long>> g[100100];
long long init(int v, int p) {
for (auto u : g[v]) {
if (u.first == p) continue;
d[u.first] = d[v] + u.second;
cnt[v] += init(u.first, v);
}
return cnt[v] += 1;
}
void dfs(int v, int p, long long dist, multiset<pair<long long, int>> &dst) {
if (dist - dst.begin()->first > a[v]) {
bad[v] = 1;
return;
}
for (auto u : g[v]) {
if (u.first == p) continue;
dst.insert(make_pair(dist, u.first));
dfs(u.first, v, dist + u.second, dst);
dst.erase(make_pair(dist, u.first));
}
}
long long res;
void calc(int v, int p) {
if (bad[v]) {
res += cnt[v];
return;
}
for (auto u : g[v]) {
if (u.first == p) continue;
calc(u.first, v);
}
}
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
for (int i = 1; i < n; i++) {
int p, c;
scanf("%d%d", &p, &c);
g[i + 1].push_back({p, c});
g[p].push_back({i + 1, c});
}
init(1, 0);
multiset<pair<long long, int>> dst;
dst.insert(make_pair(0, 1));
dfs(1, 0, 0, dst);
calc(1, 0);
printf("%I64d\n", res);
}
| 4 |
#include <bits/stdc++.h>
int main() {
char a[100000];
int n, x, i, L = 0, R = 0;
scanf("%d", &n);
scanf("%s", a);
printf("%d", n + 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline void quickread() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(10);
}
inline void print_vector(vector<int> &A) {
for (auto &&x : A) {
cout << x << " ";
}
cout << endl;
}
inline void print_array(const int A[], int n) {
for (int i = 0; i < n; ++i) {
if (i < n - 1) {
cout << A[i] << " ";
} else {
cout << A[i] << endl;
}
}
}
void chkmax(int &a, int b) { a = std::max(a, b); }
const int N = 1e6 + 5;
ll f[N][2];
int n, r1, r2, r3, d, a[N];
void upd(long long &a, long long b) { a = (a < b) ? a : b; }
inline void solve() {
cin >> n >> r1 >> r2 >> r3 >> d;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 2; i <= n; ++i) f[i][0] = f[i][1] = 1e18;
f[1][0] = 1ll * r1 * a[1] + r3;
f[1][1] = min(0ll + r2, 1ll * r1 * a[1] + r1);
for (int i = 1; i < n; ++i) {
upd(f[i + 1][0], f[i][0] + d + 1ll * r1 * a[i + 1] + r3);
upd(f[i + 1][1], f[i][0] + d + min(0ll + r2, 1ll * r1 * a[i + 1] + r1));
upd(f[i + 1][0], f[i][1] + d + 1ll * r1 * a[i + 1] + r3 + 2 * d + r1);
upd(f[i + 1][0], f[i][1] + d + 1ll * r1 * a[i + 1] + r1 + d + r1 + d + r1);
upd(f[i + 1][0], f[i][1] + d + r2 + d + r1 + d + r1);
upd(f[i + 1][1], f[i][1] + d + r2 + d + r1 + d);
upd(f[i + 1][1], f[i][1] + d + 1ll * r1 * a[i + 1] + r1 + d + r1 + d);
if (i == n - 1) {
upd(f[i + 1][0], f[i][1] + d + 1ll * r1 * a[i + 1] + r3 + d + r1);
}
}
cout << f[n][0] << endl;
}
int main() {
quickread();
int t = 1;
for (int _ = 0; _ < t; _++) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("Os")
#pragma GCC optimize("O2")
#pragma GCC optimize("O1")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("O3")
using namespace std;
int inf = 1e5 + 10;
long long mod = 1e9 + 7;
char nline = '\n', tab = '\t';
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
string s;
cin >> s;
if (s == "0") {
cout << "0";
return 0;
}
int iter = 1;
while (s.size() != 1) {
int mx = *max_element(s.begin(), s.end()) - 48;
string temp = to_string(stoi(s) - mx);
s = temp;
++iter;
}
cout << iter;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, n, m;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> m >> c;
if (m > c) {
a++;
}
if (m < c) {
b++;
}
if (m = c) {
a++;
b++;
}
}
if (a == b) {
cout << "Friendship is magic!^^" << endl;
return 0;
}
if (a < b) {
cout << "Chris" << endl;
return 0;
}
if (a > b) {
cout << "Mishka" << endl;
return 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int size = 200100, mod = 2012, inf = 0x3f3f3f3f;
const long long llmod = 4294967296ll, llinf = 0x3f3f3f3f3f3f3f3fll;
const double pi = acos(-1.0), eps = 1e-6;
int month[2][13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int nex[2][8] = {-1, 0, 1, 0, -1, 1, 1, -1, 0, 1, 0, -1, 1, 1, -1, -1};
template <class T>
inline void inc(T &a, T b) {
a = (a + b) % mod;
}
template <class T>
inline T modu(T a) {
return (a % mod + mod) % mod;
}
template <class T>
inline void crl(T *l, T *r, int step) {
T tmp = *l;
for (T *i = l; i < r; i += step) *i = *(i + step);
*(r - 1) = tmp;
}
template <class T>
inline void crr(T *l, T *r, int step) {
T tmp = *(r - 1);
for (T *i = r - 1; i > l; i -= step) *i = *(i - step);
*l = tmp;
}
bool inline dbeq(double a, double b) { return fabs(a - b) < eps; }
template <class T>
inline void cmin(T &a, T b) {
a = min(a, b);
}
template <class T>
inline void cmax(T &a, T b) {
a = max(a, b);
}
const int sonsize = 37;
struct node {
node *pa, *next[sonsize];
int len, loc, nxt, po, end;
int cnt, num, num2, sum, matchlen, nowmatchlen, app[sonsize];
char ch;
} * root, *last, e[size * 2], *b[size * 2];
int cnt, c[size * 2], endtime;
char s[size];
inline node *create(int len, int w) {
node *p = &e[cnt++];
p->loc = p->matchlen = p->len = len;
p->num = (len != 0);
p->num2 = (cnt == 1);
p->ch = w + 'a';
p->po = cnt - 1;
p->cnt = 1;
return p;
}
void init() {
for (int i = 0; i < cnt; i++) memset(e + i, 0, sizeof(e[i]));
memset(c, 0, sizeof(c));
cnt = endtime = 0;
last = root = create(0, -1);
}
void extend(int w, int j) {
node *p = last;
node *np = create(p->len + 1, w);
np->app[j] = 1;
while (p && !p->next[w]) p->next[w] = np, p = p->pa;
if (!p)
np->pa = root;
else {
node *q = p->next[w];
if (p->len + 1 == q->len)
np->pa = q;
else {
node *nq = &e[cnt++];
*nq = *q;
memset(nq->app, 0, sizeof(nq->app));
nq->cnt = 0;
nq->po = cnt - 1;
nq->len = p->len + 1;
np->pa = q->pa = nq;
while (p && p->next[w] == q) p->next[w] = nq, p = p->pa;
}
}
last = np;
}
void tp() {
for (int i = 0; i < cnt; i++) c[e[i].len]++;
for (int i = 1; i < cnt; i++) c[i] += c[i - 1];
for (int i = 0; i < cnt; i++) b[--c[e[i].len]] = &e[i];
}
void addnew(char s[], int j) {
for (int i = 0; s[i]; i++) extend(s[i] - 'a', j);
}
int main() {
int n, len, l[13], r[13];
while (scanf("%s", s) != EOF) {
init();
addnew(s, 0);
extend(26, 0);
scanf("%d", &n);
l[0] = 1, r[0] = strlen(s);
for (int j = 1; j < n + 1; j++) {
scanf("%s%d%d", s, &l[j], &r[j]);
addnew(s, j);
extend(26, j);
}
tp();
int ans = 0;
for (int i = cnt - 1; i >= 1; i--) {
node *p = b[i];
if (p->ch > 25 + 'a') continue;
bool flag = 1;
for (int j = 0; j < n + 1; j++) {
p->pa->app[j] += p->app[j];
flag = flag && (p->app[j] >= l[j] && p->app[j] <= r[j]);
}
if (flag) ans += p->len - p->pa->len;
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353;
void solve() {
long long int n, m;
cin >> n >> m;
for (long long int i = 1; i <= n / 2; i++) {
long long int r2 = n + 1 - i;
long long int c1 = 1, c2 = m;
while (c1 <= m) {
cout << i << " " << c1 << '\n';
cout << r2 << " " << c2 << '\n';
c1++, c2--;
}
}
if (n % 2) {
long long int r = (n + 1) / 2;
long long int c1 = 1, c2 = m;
while (c1 <= c2) {
cout << r << " " << c1 << '\n';
if (c1 != c2) {
cout << r << " " << c2 << '\n';
}
c1++, c2--;
}
}
}
int32_t main() {
long long int t = 1;
ios_base::sync_with_stdio(0);
cin.tie(0);
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
const int mod = 1e9 + 7;
int f[55][55][55][55], g[55][55], ifac[155], n, m;
int dfs(int n, int m, int ln, int lm);
int calc(int n, int m) {
if (n == 1) return m == 1;
if (g[n][m] != -1) return g[n][m];
g[n][m] = 0;
for (int x = 0; x <= n - 1; ++x) {
int y = n - 1 - x;
for (int l = m; l <= x + 1; ++l)
for (int r = m; r <= y + 1; ++r) {
if (std::min(l, r) != m) continue;
g[n][m] = (g[n][m] + (ll)dfs(x, l, x, l) * dfs(y, r, y, r) % mod) % mod;
}
}
return g[n][m];
}
int dfs(int n, int m, int ln, int lm) {
if (n == 0 && m == 1) return 1;
if (m < 1 || ln < 1) return 0;
if (f[n][m][ln][lm] != -1) return f[n][m][ln][lm];
int dn = ln, dm = lm - 1;
if (dm == 0) {
dn--;
dm = dn + 1;
}
f[n][m][ln][lm] = dfs(n, m, dn, dm);
int c = calc(ln, lm);
int s = 1, t = c;
for (int i = 1; i * ln <= n && i * lm <= m; ++i) {
s = (ll)s * t % mod;
t = (t + 1) % mod;
int way = (ll)s * ifac[i] % mod;
f[n][m][ln][lm] = (f[n][m][ln][lm] +
(ll)way * dfs(n - i * ln, m - lm * i, dn, dm) % mod) %
mod;
}
return f[n][m][ln][lm];
}
int main() {
std::memset(g, -1, sizeof(g));
std::memset(f, -1, sizeof(f));
scanf("%d%d", &n, &m);
ifac[0] = ifac[1] = 1;
for (int i = 2; i <= n + m; ++i)
ifac[i] = (ll)(mod - mod / i) * ifac[mod % i] % mod;
for (int i = 1; i <= n + m; ++i) ifac[i] = (ll)ifac[i - 1] * ifac[i] % mod;
printf("%d", dfs(n, m, n, m));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long lenX = x2 - x1 + 1;
long long lenY = y2 - y1 + 1;
long long ans =
(lenX + 1) / 2 * (lenY + 1) / 2 + (lenX - 1) / 2 * (lenY - 1) / 2;
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int x, y, z, n, m, k, med, a[21][21], cnt, u[21];
void dfs(int id, int v) {
if (id > n) return;
if (cnt >= k) return;
for (int i = 1; i <= n; i++) {
if (!u[i] && a[id][i] && v + a[id][i] <= med) {
cnt++;
u[i] = 1;
dfs(id + 1, v + a[id][i]);
u[i] = 0;
}
}
dfs(id + 1, v);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) scanf("%d%d%d", &x, &y, &z), a[x][y] = z;
int lo = 0, hi = n * 1000;
while (lo < hi) {
med = (lo + hi) / 2;
cnt = 1;
dfs(1, 0);
if (cnt >= k)
hi = med;
else
lo = med + 1;
}
printf("%d\n", lo);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int N;
cin >> N;
stack<bool> pilha;
for (int i = 0, a; i < N && cin >> a; i++) {
if (!pilha.empty() && (bool)(a % 2) == pilha.top())
pilha.pop();
else
pilha.push(a % 2);
}
cout << (pilha.size() <= 1 ? "YES" : "NO") << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void test_case() {
int a, b;
cin >> a >> b;
int k = 0;
map<int, long long> mp;
mp[0] = 1;
long long ans = (long long)a * (a + 1) / 2;
for (int i = 0; i < a; i++) {
int x;
cin >> x;
k ^= min(x, ((1 << b) - 1 - x));
mp[k]++;
}
for (auto x : mp) {
ans -= x.second / 2ll * (x.second / 2 - 1) / 2ll;
ans -= (x.second + 1) / 2ll * ((x.second + 1) / 2ll - 1) / 2ll;
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
test_case();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Line {
int l, r, col;
};
Line L[200005];
bool CMP_L(Line &x, Line &y) { return x.r < y.r; }
int n, tot, b[200005 << 1];
struct SEGTREE {
int L[200005 << 3], R[200005 << 3], tag[200005 << 3], Max[200005 << 3];
void Build(int k, int l, int r) {
L[k] = l, R[k] = r;
if (l == r) return;
int mid = l + r >> 1;
Build(k << 1, l, mid);
Build(k << 1 | 1, mid + 1, r);
}
void pushup(int k) { Max[k] = max(Max[k << 1], Max[k << 1 | 1]); }
void pushdown(int k) {
if (tag[k] != 0) {
tag[k << 1] += tag[k];
tag[k << 1 | 1] += tag[k];
Max[k << 1] += tag[k];
Max[k << 1 | 1] += tag[k];
tag[k] = 0;
}
}
void update(int k, int pos, int x) {
if (L[k] == R[k] && L[k] == pos) {
Max[k] = x;
return;
}
pushdown(k);
int mid = L[k] + R[k] >> 1;
if (pos <= mid)
update(k << 1, pos, x);
else
update(k << 1 | 1, pos, x);
pushup(k);
}
void Add(int k, int l, int r, int x) {
if (L[k] >= l && R[k] <= r) {
tag[k] += x, Max[k] += x;
return;
}
pushdown(k);
int mid = L[k] + R[k] >> 1;
if (l <= mid) Add(k << 1, l, r, x);
if (mid < r) Add(k << 1 | 1, l, r, x);
pushup(k);
}
int query(int k, int l, int r) {
if (L[k] >= l && R[k] <= r) return Max[k];
pushdown(k);
int mid = L[k] + R[k] >> 1, res = 0;
if (l <= mid) res = query(k << 1, l, r);
if (mid < r) res = max(res, query(k << 1 | 1, l, r));
return res;
}
};
SEGTREE B, W;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d %d %d", &L[i].l, &L[i].r, &L[i].col);
b[++tot] = L[i].l, b[++tot] = L[i].r;
}
sort(b + 1, b + tot + 1);
for (int i = 1; i <= n; ++i) {
L[i].l = lower_bound(b + 1, b + tot + 1, L[i].l) - b;
L[i].r = lower_bound(b + 1, b + tot + 1, L[i].r) - b;
}
sort(L + 1, L + n + 1, CMP_L);
B.Build(1, 0, tot), W.Build(1, 0, tot);
for (int l = 1, r = 0; l <= n; l = r + 1) {
int MAXB = 0, MAXW = 0;
while (r < n && L[r + 1].r == L[l].r) ++r;
for (int j = l; j <= r; ++j)
if (L[j].col == 2)
B.Add(1, 0, L[j].l - 1, 1);
else
W.Add(1, 0, L[j].l - 1, 1);
for (int j = l; j <= r; ++j)
if (L[j].col == 2)
MAXW = max(MAXW, B.query(1, 0, L[j].l - 1));
else
MAXB = max(MAXB, W.query(1, 0, L[j].l - 1));
W.update(1, L[l].r, MAXW);
B.update(1, L[l].r, MAXB);
}
printf("%d\n", max(W.query(1, 0, tot), B.query(1, 0, tot)));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> a;
inline bool read() {
if (!(cin >> n)) return false;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
return true;
}
inline void solve() {
int cnt = 0, pos = 0;
while (pos < n) {
cnt++;
int mx = pos;
while (pos < n && pos <= mx) {
mx = max(mx, a[pos]);
pos++;
}
}
cout << cnt << endl;
}
int main() {
if (read()) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
inline int maxi(int a, int b) {
if (a > b)
return a;
else
return b;
}
void problemE() {
int long long n = 10;
cin >> n;
if (n == 2) {
cout << 0;
return;
}
vector<unsigned int long long> a;
unsigned int long long sum = 0;
int long long minindex = -1;
int long long max = 0;
int long long maxindex = -1;
int long long i, j;
int long long tmp;
for (i = 0; i < n; i++) {
cin >> tmp;
a.push_back(tmp);
for (j = 1; j < a.size() - 1; ++j) {
int ankouc = min(a[j - 1], a[j + 1]);
if (a[j] <= ankouc) {
minindex = j;
sum += ankouc;
a.erase(a.begin() + minindex);
j -= 2;
if (j < 1) j = 0;
}
if (max < a[j]) {
max = a[j];
maxindex = j;
}
}
}
if (max < a[0]) {
max = a[0];
maxindex = 0;
}
if (max < a[a.size() - 1]) {
max = a[a.size() - 1];
maxindex = a.size() - 1;
}
for (i = maxindex + 2; i < a.size(); ++i) {
sum += a[i];
}
for (i = 0; i < maxindex - 1; ++i) {
sum += a[i];
}
if (maxindex - 1 >= 0 && maxindex + 1 < a.size()) {
if (a[maxindex - 1] < a[maxindex + 1])
sum += a[maxindex - 1];
else
sum += a[maxindex + 1];
}
cout << sum;
}
int main() {
problemE();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N;
int main(int argc, char *argv[]) {
cin >> N;
long long ans = 0;
for (int i = 0, _i = N; i < _i; ++i) {
long long x;
cin >> x;
ans += (long long)i * (x - 1);
ans += x;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int min(int x, int y) { return x < y ? x : y; }
int A[100005];
void run_case() {
int n, count_even, count_odd, i, ans, x;
scanf("%d", &n);
count_odd = 0, count_even = 0;
for (i = 0; i < n; i++) {
scanf("%d", &A[i]);
if (A[i] % 2 == 0)
count_even += 1;
else
count_odd += 1;
}
ans = 0;
ans += min(count_odd, count_even);
x = min(count_odd, count_even);
count_odd -= x;
count_even -= x;
ans += count_odd / 3;
printf("%d\n", ans);
}
int main() {
int T = 1;
while (T--) run_case();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int qpow(int b, int e, int m = 998244353) {
int a = 1;
for (; e; e >>= 1, b = (long long)b * b % m)
if (e & 1) a = (long long)a * b % m;
return a;
}
int n, m, k;
int a[200005], b[200005], x[200005], y[200005], ca[200005], cb[200005],
z[200005];
int d[200005], c;
int mnv[200005];
vector<int> g1[1000005], g2[1000005];
int mn[(1 << 19 | 7)], tg[(1 << 19 | 7)];
inline void P(int i, int x) {
mn[i] += x;
tg[i] += x;
}
inline void pd(int i) {
if (tg[i]) P((i << 1), tg[i]), P(((i << 1) | 1), tg[i]), tg[i] = 0;
}
void build(int i, int l, int r) {
if (l == r) {
mn[i] = mnv[l];
return;
}
build((i << 1), l, ((l + r) >> 1)),
build(((i << 1) | 1), ((l + r) >> 1) + 1, r);
mn[i] = min(mn[(i << 1)], mn[((i << 1) | 1)]);
}
void mdf(int i, int l, int r, int a, int b, int x) {
if (r < a || b < l) return;
if (a <= l && r <= b) return P(i, x);
pd(i), mdf((i << 1), l, ((l + r) >> 1), a, b, x),
mdf(((i << 1) | 1), ((l + r) >> 1) + 1, r, a, b, x);
mn[i] = min(mn[(i << 1)], mn[((i << 1) | 1)]);
}
int ans = 0x7fffffff;
int main() {
int tests = 1;
while (tests--) {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= (n); ++i)
scanf("%d%d", a + i, ca + i), g1[a[i]].push_back(i);
for (int i = 1; i <= (m); ++i) scanf("%d%d", b + i, cb + i), d[++c] = b[i];
sort(d + 1, d + c + 1), c = unique(d + 1, d + c + 1) - d - 1;
for (int i = 1; i <= (c); ++i) mnv[i] = 0x3f3f3f3f;
for (int i = 1; i <= (m); ++i)
b[i] = lower_bound(d + 1, d + c + 1, b[i]) - d,
mnv[b[i]] = min(mnv[b[i]], cb[i]);
build(1, 1, c);
for (int i = 1; i <= (k); ++i)
scanf("%d%d%d", x + i, y + i, z + i), g2[x[i]].push_back(i);
for (int v = 1; v <= (1000000); ++v) {
for (auto i : g1[v]) ans = min(ans, mn[1] + ca[i]);
for (auto i : g2[v]) {
int p = upper_bound(d + 1, d + c + 1, y[i]) - d;
if (p <= c) mdf(1, 1, c, p, c, -z[i]);
}
}
printf("%d\n", -ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e11;
const long long mod = 1e9 + 7;
const long long N = 301;
long long a[3], b[3], mn[N][N], loss[N][N];
set<pair<pair<long long, long long>, long long> > s;
int main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
for (long long i = 0; i < (n); ++i) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < N; i++)
for (int j = i; j < N; j++) mn[i][j] = inf;
if (n == 1) {
if (a[0] == 0)
cout << "BitAryo";
else
cout << "BitLGM";
return 0;
}
if (n == 2) {
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
long long cnt = 0;
for (int k = 0; k < i; k++) {
long long ix = k, jx = j;
if (ix > jx) swap(ix, jx);
cnt += loss[ix][jx];
}
for (int k = 0; k < j; k++) {
long long ix = i, jx = k;
if (ix > jx) swap(ix, jx);
cnt += loss[ix][jx];
}
for (int k = 0; k <= i; k++) cnt += loss[i - k][j - k];
if (cnt == 0) loss[i][j] = 1;
}
}
if (loss[a[0]][a[1]])
cout << "BitAryo";
else
cout << "BitLGM";
return 0;
}
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
for (int k = j; k < N; k++) {
long long t;
t = mn[i][j];
if (t < k) continue;
t = mn[i][k];
if (t < j) continue;
t = mn[j][k];
if (t < i) continue;
for (int l = 0; l <= i; l++)
if (s.find(make_pair(make_pair(i - l, j - l), k - l)) != s.end())
continue;
mn[i][j] = k;
mn[i][k] = j;
mn[j][k] = i;
s.insert(make_pair(make_pair(i, j), k));
}
}
}
if (s.find(make_pair(make_pair(a[0], a[1]), a[2])) != s.end())
cout << "BitAryo";
else
cout << "BitLGM";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 7e5 + 10;
vector<int> a[maxn];
vector<int> ans[5];
char s[maxn];
int vis[maxn];
int via[maxn];
int check(int u) {
int res = 0;
for (int i = ans[u].size() - 1; i >= 0; i--) {
res = res * 2 + ans[u][i];
}
return res;
}
void judge(int x, int id) {
while (x) {
if (x & 1)
a[id].push_back(1);
else
a[id].push_back(0);
x >>= 1;
}
}
int main() {
int n;
scanf("%d", &n);
int flag = 0;
int len = 0;
int mark = 10;
for (int i = 1; i <= n; i++) {
int num;
char ch;
cin >> ch >> num;
judge(num, i);
s[i] = ch;
int m = a[i].size();
len = max(len, m);
if (ch == '&') {
flag = 1;
mark = min(mark, m);
}
}
for (int i = 1; i <= n; i++) {
while (a[i].size() < len) a[i].push_back(0);
}
for (int i = 0; i < len; i++) {
int res = 0;
for (int k = 1; k <= n; k++) {
if (s[k] == '^')
res ^= a[k][i];
else if (s[k] == '|')
res |= a[k][i];
else
res &= a[k][i];
}
int rea = 1;
for (int k = 1; k <= n; k++) {
if (s[k] == '^')
rea ^= a[k][i];
else if (s[k] == '|')
rea |= a[k][i];
else
rea &= a[k][i];
}
if (res == 0 && rea == 0) {
ans[1].push_back(0);
ans[2].push_back(0);
ans[3].push_back(0);
}
if (res == 1 && rea == 1) {
ans[1].push_back(1);
ans[2].push_back(1);
ans[3].push_back(0);
}
if (res == 0 && rea == 1) {
ans[1].push_back(1);
ans[2].push_back(0);
ans[3].push_back(0);
}
if (res == 1 && rea == 0) {
ans[1].push_back(1);
ans[2].push_back(0);
ans[3].push_back(1);
}
}
while (ans[1].size() < mark) ans[1].push_back(1);
printf("3\n");
int num1 = check(1);
int num2 = check(2);
int num3 = check(3);
printf("& %d\n", num1);
printf("| %d\n", num2);
printf("^ %d\n", num3);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100020];
vector<string> lol;
int ar[34];
int u, v, vis[100020], flag = 0;
stack<int> mula;
void dfs(int src) {
vis[src] = 1;
for (int i = 0; i < G[src].size(); i++) {
int x = G[src][i];
if (vis[x] == 1) {
flag = 1;
return;
} else if (vis[x] == 0) {
dfs(x);
}
}
mula.push(src);
vis[src] = 2;
return;
}
int main() {
int test, j = test;
scanf("%d\n", &test);
j = test;
int leflag = 0;
while (test--) {
string str;
getline(cin, str);
lol.push_back(str);
}
for (int i = 0; i < j - 1; i++) {
string str1 = lol[i];
string str2 = lol[i + 1];
int cnt = 0;
for (int j = 0; j < min(str1.length(), str2.length()); j++) {
if (str1[j] == str2[j]) cnt++;
if (str1[j] != str2[j]) {
int p = str1[j] - 'a';
int q = str2[j] - 'a';
G[p].push_back(q);
break;
}
if (str1.length() > str2.length() && cnt == str2.length()) {
leflag = 1;
}
}
}
for (int i = 25; i >= 0; i--) {
if (!vis[i]) dfs(i);
if (flag == 1 || leflag == 1) {
printf("Impossible");
return 0;
}
}
while (!mula.empty()) {
printf("%c", (mula.top() + 'a'));
mula.pop();
}
puts("");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 3e5 + 10;
const int INF = 1e9;
int n, a[M], pos[M], ans;
struct state {
int r, l, now, add;
} st[M << 2];
void build(int l, int r, int cur) {
st[cur].l = l;
st[cur].r = r;
st[cur].now = st[cur].add = 0;
if (l == r) return;
int mid = l + (r - l) / 2;
build(l, mid, cur << 1);
build(mid + 1, r, cur << 1 | 1);
}
void pushup(int u) {
if (st[u].add) {
int a = u << 1, b = u << 1 | 1, s = st[u].add;
st[u].add = 0;
st[a].add += s;
st[a].now += s;
st[b].add += s;
st[b].now += s;
}
}
void maintain(int cur) {
st[cur].now = min(st[cur << 1].now, st[cur << 1 | 1].now);
}
void update(int k, int l, int r, int val) {
if (st[k].l > r || st[k].r < l) return;
if (st[k].l >= l && st[k].r <= r) {
st[k].now += val;
st[k].add += val;
return;
}
pushup(k);
update(k << 1, l, r, val);
update(k << 1 | 1, l, r, val);
st[k].now = min(st[k << 1].now, st[k << 1 | 1].now);
}
int main() {
scanf("%d", &n);
build(1, n, 1);
ans = n + 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = 1, tt; i <= n; i++) {
scanf("%d", &tt);
while (st[1].now >= 0) {
ans--;
update(1, 1, pos[ans], -1);
}
printf("%d ", ans);
update(1, 1, tt, 1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int tab[55][55];
int main() {
int t;
cin >> t;
set<int> x, y;
while (t--) {
x.clear();
y.clear();
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> tab[i][j];
if (tab[i][j]) {
x.insert(i);
y.insert(j);
}
}
int mn = min(n - x.size(), m - y.size());
if (mn % 2)
cout << "Ashish" << endl;
else
cout << "Vivek" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, c, d;
int *b = new int();
cin >> a >> *b >> c >> d;
delete b;
cout << (a && a == d || !c && a == d);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
string s;
int m;
long long ans = 0;
vector<pair<int, int> > g[2006];
int vis[2006], cnt, has[2006];
int dfs(int x, int now) {
vis[x] = now;
has[x] = 1;
bool ok = 1;
for (int i = 0; i < g[x].size(); i++) {
if (vis[g[x][i].first] != -1) {
if (vis[g[x][i].first] != now ^ (g[x][i].second)) return 0;
}
if (!has[g[x][i].first]) ok &= dfs(g[x][i].first, now ^ (g[x][i].second));
}
return ok;
}
int main() {
cin >> s;
m = s.size();
s = "0" + s;
for (int i = 1; i < m; i++) {
long long res = 1;
memset(vis, -1, sizeof(vis));
memset(has, 0, sizeof(has));
for (int j = 0; j < 2006; j++) g[j].clear();
for (int k = 1, j = m; k < j; k++, j--)
g[k].push_back(make_pair(j, 0)), g[j].push_back(make_pair(k, 0));
for (int k = 1, j = i; k < j; k++, j--)
g[k + m].push_back(make_pair(j + m, 0)),
g[j + m].push_back(make_pair(k + m, 0));
for (int j = m - i + 1, k = 1; j <= m; j++, k++) {
if (s[j] == '1')
g[j].push_back(make_pair(k + m, 1)),
g[k + m].push_back(make_pair(j, 1));
if (s[j] == '0')
g[j].push_back(make_pair(k + m, 0)),
g[k + m].push_back(make_pair(j, 0));
}
for (int j = 1; j <= m - i; j++)
if (s[j] != '?') vis[j] = s[j] - '0';
vis[1 + m] = 1;
if (!dfs(1 + m, 1)) res *= 0;
for (int j = 1; j <= m - i && res > 0; j++)
if (!has[j] && vis[j] != -1) {
if (!dfs(j, vis[j])) res *= 0;
}
for (int j = 1; j <= m + i && res > 0; j++)
if (!has[j]) {
if (!dfs(j, 0))
res = 0;
else
res = res * 2 % MOD;
}
ans = (ans + res) % MOD;
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, l;
cin >> n >> i >> j >> k >> l;
int man = (abs(k - i) + abs(l - j));
if (i == n && k == 0 || k == n && i == 0)
cout << min(man + 2 * min(n - j, n - l), man + 2 * min(j, l));
else if (j == n && l == 0 || l == n && j == 0)
cout << min(man + 2 * min(n - k, n - i), man + 2 * min(k, i));
else
cout << man;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1000;
vector<int> side[maxn];
int dfn[maxn], low[maxn], idx, f[maxn][23], stk[maxn], top, dep[maxn],
bel[maxn];
bool odd[maxn], in[maxn];
int mark[maxn];
vector<int> edge[maxn];
void tarjan(int u, int fa) {
bel[u] = bel[fa];
dfn[u] = low[u] = ++idx;
f[u][0] = fa;
stk[++top] = u;
dep[u] = dep[fa] + 1;
in[u] = 1;
for (int i = 0; i < side[u].size(); i++) {
int v = side[u][i];
if (v == fa) continue;
if (!dfn[v])
tarjan(v, u), low[u] = min(low[u], low[v]), edge[u].push_back(v),
edge[v].push_back(u);
else if (in[v])
low[u] = min(low[u], dfn[v]), odd[u] |= (abs(dep[u] - dep[v]) + 1) & 1;
}
if (low[u] == dfn[u]) {
int flag = 0;
for (int t = top; t >= 1 && stk[t] != u; t--)
if (odd[stk[t]]) {
flag = 1;
break;
}
while (stk[top] != u) {
if (flag) mark[stk[top]] |= flag;
in[stk[top]] = 0;
top--;
}
top--;
in[u] = 0;
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int j = 22; j >= 0; j--)
if (dep[f[u][j]] >= dep[v]) u = f[u][j];
if (u == v) return u;
for (int j = 22; j >= 0; j--)
if (f[u][j] != f[v][j]) u = f[u][j], v = f[v][j];
return f[u][0];
}
void dfs(int u, int fa) {
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == fa) continue;
mark[v] += mark[u];
dfs(v, u);
}
}
int dis(int u, int v, int lca) { return dep[u] + dep[v] - 2 * dep[lca]; }
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (1), iend = (m); i <= iend; i++) {
int u, v;
scanf("%d%d", &u, &v);
side[u].push_back(v);
side[v].push_back(u);
}
for (int i = (1), iend = (n); i <= iend; i++)
if (!dfn[i]) {
bel[0] = i;
top = 0;
tarjan(i, 0);
dfs(i, 0);
}
for (int i = (1), iend = (22); i <= iend; i++)
for (int j = (1), jend = (n); j <= jend; j++)
f[j][i] = f[f[j][i - 1]][i - 1];
int q;
scanf("%d", &q);
for (int i = (1), iend = (q); i <= iend; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (bel[u] != bel[v] || u == v) {
printf("No\n");
continue;
}
int l = lca(u, v);
if (dis(u, v, l) & 1) {
printf("Yes\n");
continue;
}
int ans = mark[u] - 2 * mark[l] + mark[v];
if (ans > 0) {
printf("Yes\n");
continue;
} else {
printf("No\n");
continue;
}
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.