solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
while (cin >> n >> m >> q) {
vector<set<int>> lt(n), rb(n);
queue<pair<int, int>> que;
struct SegmentTree {
int n;
int init_val;
vector<int> tree;
function<int(int, int)> f;
SegmentTree(int n, int init_val, function<int(int, int)> f)
: n(n), init_val(init_val), tree(4 * n, init_val), f(f) {}
int get(int l, int r) { return get(l, r, 1, 0, n - 1); }
int get(int l, int r, int tv, int tl, int tr) {
if (l <= tl && tr <= r) return tree[tv];
if (tr < l || r < tl) return init_val;
int tm = (tl + tr) / 2;
return f(get(l, r, 2 * tv, tl, tm), get(l, r, 2 * tv + 1, tm + 1, tr));
}
void set(int idx, int val) { set(idx, val, 1, 0, n - 1); }
void set(int idx, int val, int tv, int tl, int tr) {
if (tl == tr) {
tree[tv] = val;
} else {
int tm = (tl + tr) / 2;
if (idx <= tm)
set(idx, val, 2 * tv, tl, tm);
else
set(idx, val, 2 * tv + 1, tm + 1, tr);
tree[tv] = f(tree[2 * tv], tree[2 * tv + 1]);
}
}
};
SegmentTree min_tree(n, m + 1, [](int a, int b) { return min(a, b); });
SegmentTree max_tree(n, -1, [](int a, int b) { return max(a, b); });
auto check = [&](int ii, int jj) {
int i = ii / 2;
int j = jj / 2;
if (ii % 2) {
if (!lt[i].count(j)) return true;
auto mi = min_tree.get(0, i);
return mi > j;
} else {
if (!rb[i].count(j)) return true;
auto ma = max_tree.get(i, n - 1);
return j > ma;
}
};
while (q--) {
int ii, jj;
cin >> ii >> jj;
--ii, --jj;
int i = ii / 2;
int j = jj / 2;
if (ii % 2) {
if (lt[i].count(j)) {
lt[i].erase(j);
int val = lt[i].empty() ? -1 : *lt[i].rbegin();
max_tree.set(i, val);
} else {
lt[i].insert(j);
max_tree.set(i, *lt[i].rbegin());
}
} else {
if (rb[i].count(j)) {
rb[i].erase(j);
int val = rb[i].empty() ? m + 1 : *rb[i].begin();
min_tree.set(i, val);
} else {
rb[i].insert(j);
min_tree.set(i, *rb[i].begin());
}
}
que.emplace(ii, jj);
while (!que.empty()) {
auto [ii, jj] = que.front();
if (!check(ii, jj)) {
break;
}
que.pop();
}
cout << (que.empty() ? "YES" : "NO") << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool check(long long int m, vector<long long int> v, int c) {
int a = 0;
for (int i = 0; i < n; i++) {
if (!c)
a++, c ^= 1;
else if (v[i] <= m)
a++, c ^= 1;
}
return a >= k;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
vector<long long int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
long long int l = 1, h = 1e9, m = 0;
while (l < h) {
m = (l + h) / 2;
if (check(m, v, 0) || check(m, v, 1))
h = m;
else
l = m + 1;
}
cout << l << "\n";
return 0;
}
| 4 |
#include <iostream>
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
const int MAX=8e4+9;
const long long mod=1e9+7;
using namespace std;
vector<int>adj[MAX];
ull fact[MAX];
ll dp[MAX][101];
ll pre[MAX][101];
int main(){
ll n, k;
cin>>n>>k;
vector<ll>v;
v.push_back(0);
for(int i=1;i*i<=n;i++){
v.push_back(i);
if(i*i<n)
v.push_back(n/i);
}
// cout<<1;
map<ll ,ll>mp;
sort(v.begin(), v.end());
for(int i=0;i<v.size();i++){
mp[v[i]]=i;
}
for(int i=1;i<v.size();i++)
dp[i][1]=1;
for(int i=1;i<v.size();i++)
pre[i][1]=v[i];
for(int i=2;i<=k;i++){
for(int j=1;j<v.size();j++){
int idx=mp[n/v[j]];
dp[j][i]=((v[j]-v[j-1])*pre[idx][i-1])%mod;
pre[j][i]=(pre[j-1][i]+dp[j][i])%mod;
}
}
cout<<pre[v.size()-1][k];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, cnt = 0, cal = 0, flag = 0, temp;
long long a[10005];
set<long long> st;
scanf("%I64d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
st.insert(a[i]);
}
if (st.size() == 1)
printf("YES\n");
else {
for (i = 1; i < n; i++) {
if (cal == 0) {
if (a[i] > a[i - 1]) cnt++;
}
if (a[i] == a[i - 1])
cal++;
else if (a[i] < a[i - 1])
break;
}
temp = cal + cnt;
for (j = temp; j < n - 1; j++) {
if (a[j] <= a[j + 1]) {
flag = 1;
printf("NO\n");
break;
}
}
if (flag == 0) printf("YES\n");
}
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int n;
int a,b,c;
cin >> n;
for(int i=0; i<n; i++){
cin >> a >> b >> c;
a*=a; b*=b; c*=c;
if(a == b+c || b == a+c || c == a+b)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main(int argc, char** argv) {
std::cin.tie(0);
std::ios_base::sync_with_stdio(0);
int n, k, c[111111], id[111111];
long long s = 0;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", c + i);
s += c[i];
}
for (int i = 0; i < k; i++) {
scanf("%d", id + i);
id[i]--;
}
long long S = 0;
bool prev = false;
for (int i = 0; i < n; i++) {
S += c[i] * c[(i + 1) % n];
if (std::binary_search(id, id + k, i)) {
int ii = (i + n - 1) % n, iii = (i + 1) % n;
if (!prev) {
if (i != n - 1) {
S += (s - (c[i] + c[ii] + c[iii])) * c[i];
} else if (id[0] == 0) {
S += (s - (c[i] + c[ii])) * c[i];
} else {
S += (s - (c[i] + c[ii] + c[iii])) * c[i];
}
} else {
if (i != n - 1) {
S += (s - (c[i] + c[iii])) * c[i];
} else if (id[0] == 0) {
S += (s - (c[i])) * c[i];
} else {
S += (s - (c[i] + c[iii])) * c[i];
}
}
s -= c[i];
prev = true;
} else {
prev = false;
}
}
printf("%I64d\n", S);
return 0;
}
| 2 |
#include <bits/stdc++.h>
void debug_print() {}
template <typename T, typename... Args>
void debug_print(T t, Args... args) {
std::cout << t << " ";
debug_print(args...);
}
int findMismatch(int array[25], int M) {
int count = 0;
for (int i = 0; i < M; ++i) {
;
;
if (array[i] != i) count++;
};
;
return count;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int matrix[25][25], copyMat[25][25];
int M, N;
std::cin >> N >> M;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
std::cin >> matrix[i][j];
matrix[i][j]--;
}
}
for (int i = 0; i < N; ++i) {
int val = findMismatch(matrix[i], M);
if (i == N - 1 && val <= 2) {
std::cout << "YES";
return 0;
};
;
if (val > 2) break;
}
for (int i = 0; i < M; ++i) {
for (int j = i + 1; j < M; ++j) {
for (int k = 0; k < N; ++k) {
std::swap(matrix[k][i], matrix[k][j]);
};
;
for (int l = 0; l < N; ++l) {
int val = findMismatch(matrix[l], M);
if (l == N - 1 && val <= 2) {
std::cout << "YES";
return 0;
};
;
if (val > 2) break;
}
for (int k = 0; k < N; ++k) {
std::swap(matrix[k][i], matrix[k][j]);
}
}
}
std::cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > add(2e6 + 10), del(2e6 + 10);
int color[300][300];
int temp[300][300];
vector<int> ans(2000000 + 10);
int dsu[90000];
int n, m, q;
bool INSIDE(int x, int y) { return (x >= 0 and x < n and y >= 0 and y < m); }
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int root(int x) { return x == dsu[x] ? x : dsu[x] = root(dsu[x]); }
int unite(int x, int y) {
int p = root(x), q = root(y);
if (p == q) {
return 0;
} else {
dsu[p] = q;
return 1;
}
}
void func(vector<pair<int, int> > arr, int coeff) {
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
temp[i][j] = 0;
}
}
for (long long int i = 0; i < n * m; i++) dsu[i] = i;
for (int i = 0; i < (int)arr.size(); i++) {
int cnt = 1;
temp[arr[i].first / m][arr[i].first % m] = 1;
for (long long int j = 0; j < 4; j++) {
int nx = arr[i].first / m + dx[j];
int ny = arr[i].first % m + dy[j];
if (INSIDE(nx, ny) and temp[nx][ny] == 1) {
cnt -= unite(arr[i].first, m * nx + ny);
}
}
ans[arr[i].second] += cnt * coeff;
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
int val = 0;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
color[i][j] = 0;
}
}
for (long long int i = 0; i < q; i++) {
int x, y, c;
scanf("%d%d%d", &x, &y, &c);
x--, y--;
val = max(val, c);
add[c].push_back(make_pair(m * x + y, i));
del[color[x][y]].push_back(make_pair(m * x + y, i));
color[x][y] = c;
}
for (long long int x = 0; x < n; x++) {
for (long long int y = 0; y < m; y++) {
del[color[x][y]].push_back(make_pair(m * x + y, q));
}
}
val++;
for (long long int i = 0; i < val; i++) reverse(del[i].begin(), del[i].end());
for (long long int i = 0; i < val; i++) {
func(add[i], +1);
}
for (long long int i = 0; i < val; i++) {
func(del[i], -1);
}
int cur = 1;
for (long long int i = 0; i < q; i++) {
cur += ans[i];
cout << cur << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, root;
vector<int> G[100002];
bool cmp(int a, int b) { return a > b; }
int a[100002];
long long dp[100002];
void dfs(int u, int fa) {
dp[u] = 1;
vector<long long> s;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == fa || a[v] == 0) continue;
a[v]--;
dfs(v, u);
if (dp[v]) s.push_back(dp[v]);
}
sort(s.begin(), s.end(), cmp);
for (int i = 0; a[u] && i < s.size(); i++) a[u]--, dp[u] += s[i] + 1;
for (int i = 0; a[u] && i < G[u].size(); i++) {
int v = G[u][i];
if (v == fa || a[v] == 0) continue;
dp[u] += 2LL * min(a[u], a[v]);
a[u] -= min(a[u], a[v]);
}
}
int main() {
int i, u, v;
while (~scanf("%d", &n)) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]), G[i].clear();
for (i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
scanf("%d", &root);
dfs(root, root);
cout << dp[root] - 1 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
/* {{{ */
#define CL(N) cout << N << endl
#define DCT(N) cout << "debug " << N << endl
#define REP(i, N) for (int i = 0; i < N; i++)
/* }}} */
int K[128], menu[128][4][4];
int check(int n, int m, int d1, int d2)
{
if (m > n) return (1);
if (menu[m][d1][d2]) return (menu[m][d1][d2]);
if (d1 == d2 && d1 == K[m] && d1) return (0);
if (K[m]){
menu[m][d1][d2] = check(n, m + 1, d2, K[m]) % 10000;
}
else {
for (int i = 1; i <= 3; i++){
if (d1 != d2 || d1 != i) menu[m][d1][d2] += check(n, m + 1, d2, i) % 10000;
}
}
return (menu[m][d1][d2]);
}
int main()
{
int n, k;
cin >> n >> k;
REP(i, k){
int a, b;
cin >> a >> b;
K[a] = b;
}
CL(check(n, 1, 0, 0) % 10000);
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int m, n;
char s0[N][12], s1[N][20];
char x[30], y[30];
int main() {
cin >> n >> m;
for (int i = 0; i < (n); i++) cin >> s0[i] >> s1[i];
for (int i = 0; i < (m); i++) {
cin >> x >> y;
printf("%s %s #", x, y);
for (int j = 0; j < (n); j++) {
bool flag = true;
for (int k = 0; s1[j][k]; k++)
if (s1[j][k] - y[k] != 0) flag = false;
if (flag) {
puts(s0[j]);
break;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int P[1 << 18], B[1 << 18], C[1 << 18], S[1 << 18];
long long R[1 << 18];
vector<pair<int, int> > E[1 << 18];
int gMark, gS;
int Parent(int a) {
if (P[a] == a) return a;
return P[a] = Parent(P[a]);
}
void dfs(int a, int p) {
B[a] = gMark;
int i;
for (i = 0; i < int((E[a]).size()); i++) {
int b = E[a][i].first;
if (b == p) continue;
dfs(b, a);
S[a] += S[b];
}
S[a] += C[a];
}
void dfs2(int a, int p) {
B[a] = gMark;
int i;
for (i = 0; i < int((E[a]).size()); i++) {
int b = E[a][i].first;
if (b == p) continue;
dfs2(b, a);
long long s = S[b];
R[E[a][i].second] = s * (gS - s);
}
}
int main() {
int n;
scanf("%d", &n);
int i, j;
vector<pair<pair<int, int>, pair<int, int> > > v;
for (i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
v.push_back(make_pair(pair<int, int>(c, i), pair<int, int>(a - 1, b - 1)));
}
sort((v).begin(), (v).end());
for (i = 0; i < n + n; i++) {
P[i] = i;
C[i] = 1;
S[i] = 0;
}
memset(B, 0, sizeof(B));
gMark = 0;
int prev = 0;
int cnt = n;
for (i = 1; i < n; i++)
if (i == n - 1 || v[i].first.first != v[i - 1].first.first) {
for (j = prev; j < i; j++) {
int a = Parent(v[j].second.first);
int b = Parent(v[j].second.second);
E[a].push_back(pair<int, int>(b, v[j].first.second));
E[b].push_back(pair<int, int>(a, v[j].first.second));
}
++gMark;
for (j = prev; j < i; j++) {
int a = Parent(v[j].second.first);
if (B[a] != gMark) dfs(a, -1);
}
++gMark;
for (j = prev; j < i; j++) {
int a = Parent(v[j].second.first);
if (B[a] != gMark) {
gS = S[a];
dfs2(a, -1);
}
}
for (j = prev; j < i; j++) {
int a = Parent(v[j].second.first);
int b = Parent(v[j].second.second);
P[a] = P[b] = cnt;
C[cnt] = C[a] + C[b];
++cnt;
}
prev = i;
}
long long res = 0;
for (i = 0; i < n - 1; i++) res = max(res, R[i]);
vector<int> ret;
for (i = 0; i < n - 1; i++)
if (R[i] == res) ret.push_back(i + 1);
printf("%I64d %d\n", res + res, int((ret).size()));
for (i = 0; i < int((ret).size()); i++)
printf("%d%c", ret[i], i == int((ret).size()) - 1 ? '\n' : ' ');
return 0;
};
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y, b, r;
scanf("%d%d%d", &y, &b, &r);
y++, r--;
printf("%d\n", min(y, min(b, r)) * 3);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const int MOD = 1e9 + 7;
const int N = 0;
int a, b;
int main() {
cin >> a >> b;
for (int i = 1; i <= a + 1; i++) printf("%d ", b + i);
for (int i = b; i >= 1; i--) printf("%d ", i);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using uint = unsigned int;
template <class T>
using V = vector<T>;
template <class T>
using VV = vector<vector<T>>;
template <class T, class U>
void chmax(T& x, U y) {
if (x < y) x = y;
}
template <class T, class U>
void chmin(T& x, U y) {
if (y < x) x = y;
}
template <class T>
void mkuni(V<T>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vc) {
o << "{";
for (const T& v : vc) o << v << ",";
o << "}";
return o;
}
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
namespace Normalize {
template <class E>
void dfs(vector<vector<E>>& G, vector<int>& ord, int v, int p = -1) {
ord.emplace_back(v);
int K = G[v].size();
for (int i = 0; i < int(K); i++) {
if (G[v][i].to == p) {
rotate(G[v].begin() + i, G[v].begin() + i + 1, G[v].end());
K--;
break;
}
}
for (int i = 0; i < int(K); i++) {
dfs(G, ord, G[v][i].to, v);
}
}
template <class E>
vector<int> normalize_and_gettopord(vector<vector<E>>& G, int r = 0) {
vector<int> ord;
dfs(G, ord, r);
return ord;
}
} // namespace Normalize
template <class N>
struct BidirectionalTreeDP {
vector<N> dp;
vector<N> up;
vector<N> rp;
vector<int> par;
template <class E>
BidirectionalTreeDP(vector<vector<E>>& G, int r = 0) {
int V = G.size();
dp.assign(V, N());
up.assign(V, N());
rp.assign(V, N());
par.assign(V, 0);
vector<int> ord = Normalize::normalize_and_gettopord<E>(G, r);
for (int t = 0; t < int(V); t++) {
int v = ord[t];
if (v == r)
par[v] = -1;
else
par[v] = G[v].back().to;
}
for (int t = V - 1; t >= 0; t--) {
int v = ord[t];
dp[v] = N();
int K = G[v].size() - (v != r);
for (int i = 0; i < int(K); i++) {
const E& e = G[v][i];
int u = e.to;
dp[v] = dp[v] + dp[u].append_edge(v, e);
}
dp[v].finalize(v);
}
for (int t = 0; t < int(V); t++) {
int v = ord[t];
int K = G[v].size() - (v != r);
vector<N> ls(K + 1), rs(K + 1);
for (int i = 0; i < int(K); i++) {
ls[i + 1] = ls[i] + dp[G[v][i].to].append_edge(v, G[v][i]);
rs[K - 1 - i] =
dp[G[v][K - 1 - i].to].append_edge(v, G[v][K - 1 - i]) + rs[K - i];
}
for (int i = 0; i < int(K); i++) {
const E& e = G[v][i];
int u = e.to;
up[u] = ls[i] + rs[i + 1];
if (v != r) up[u] = up[u] + up[v].append_edge(v, G[v].back());
up[u].finalize(v);
}
rp[v] = ls[K];
if (v != r) rp[v] = rp[v] + up[v].append_edge(v, G[v].back());
rp[v].finalize(v);
}
}
N get(int v, int p = -1) {
if (p == -1) return rp[v];
if (par[v] == p) return dp[v];
return up[p];
}
};
struct Node {
int f[2][2];
int sz;
Node() {
f[0][1] = f[1][0] = f[1][1] = 0;
f[0][0] = 1;
sz = 0;
}
template <class E>
Node append_edge(int p, const E& e) const {
Node n;
n.f[1][0] = f[0][0];
n.f[1][1] = f[0][1];
n.f[0][0] = f[1][0];
n.f[0][1] = f[1][1];
n.sz = sz;
return n;
}
friend Node operator+(const Node& l, const Node& r) {
Node z;
for (int i = 0; i < int(2); i++)
for (int j = 0; j < int(2); j++) z.f[i][j] = 0;
for (int i = 0; i < int(2); i++)
for (int j = 0; j < int(2); j++)
if (l.f[i][j]) {
for (int k = 0; k < int(2 - i); k++)
for (int m = 0; m < int(2 - j); m++)
if (r.f[k][m]) {
z.f[i + k][j + m] += l.f[i][j] * r.f[k][m];
}
}
z.sz = l.sz + r.sz;
return z;
}
void finalize(int r) {
if (f[0][0]) f[1][1]++;
sz++;
}
};
struct Edge {
int to;
};
int main() {
int N;
cin >> N;
VV<Edge> G(N);
for (int i = 0; i < int(N - 1); i++) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back({y});
G[y].push_back({x});
}
BidirectionalTreeDP<Node> dp(G);
ll ans = 0;
for (int i = 0; i < int(N); i++) {
for (auto e : G[i]) {
int j = e.to;
if (i < j) {
auto x = dp.get(i, j);
auto y = dp.get(j, i);
if (x.f[1][0] && y.f[1][0]) ans += 1LL * x.sz * y.sz;
ans += 1LL * x.f[1][1] * y.f[1][1];
}
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
int main() {
ios_base::sync_with_stdio(false);
long long int t;
cin >> t;
while (t--) {
long long int k;
cin >> n >> k;
if (k >= n) {
cout << k - n << '\n';
continue;
} else {
long long int flg = 0, l = 0, r = n;
if (n % 2 == k % 2)
cout << "0\n";
else
cout << "1\n";
continue;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, q, blk;
int a[1000010], org[1000010], frq[1000010];
int tot = 0;
namespace fastio {
int ptr, ye;
char temp[25], str[32333667], out[15333667];
void init() {
ptr = 0, ye = 0;
fread(str, 1, 32333667, stdin);
}
inline int number() {
int i, j, val = 0;
while (str[ptr] < 45 || str[ptr] > 57) ptr++;
while (str[ptr] > 47 && str[ptr] < 58) val = (val * 10) + (str[ptr++] - 48);
return val;
}
inline void convert(int x) {
int i, d = 0;
if (x < 0) x = -x, out[ye++] = 45;
for (;;) {
temp[++d] = (x % 10) + 48;
x /= 10;
if (!x) break;
}
for (i = d; i; i--) out[ye++] = temp[i];
out[ye++] = 10;
}
inline void print() { fwrite(out, 1, ye, stdout); }
} // namespace fastio
struct query {
int l, r, id, d;
inline query() {}
inline query(int a, int b, int c) {
id = c;
l = a, r = b, d = l / blk;
}
inline bool operator<(const query& other) const {
if (d != other.d) return (d < other.d);
return ((d & 1) ? (r > other.r) : (r < other.r));
}
} qq[1000010];
void add(int pos) {
frq[a[pos]]++;
if (frq[a[pos]] > 1) tot = tot ^ org[pos];
}
void rmv(int pos) {
frq[a[pos]]--;
if (frq[a[pos]] > 0) tot = tot ^ org[pos];
}
int main() {
fastio::init();
n = fastio::number();
blk = sqrt(n);
unordered_map<int, int> mp;
int cur = 1;
for (int i = 0; i < n; i++) {
a[i] = fastio::number();
org[i] = a[i];
}
for (int i = 0; i < n; i++) {
if (mp[a[i]] != 0) {
a[i] = mp[a[i]];
} else {
mp[a[i]] = cur;
a[i] = cur;
cur++;
}
}
q = fastio::number();
for (int i = 0; i < q; i++) {
int l, r;
l = fastio::number();
r = fastio::number();
l--;
r--;
qq[i] = query(l, r, i);
}
sort(qq, qq + q);
int curl = 0, curr = -1;
int ans[q];
for (int i = 0; i < q; i++) {
while (curl < qq[i].l) rmv(curl++);
while (curl > qq[i].l) add(--curl);
while (curr < qq[i].r) add(++curr);
while (curr > qq[i].r) rmv(curr--);
ans[qq[i].id] = tot;
}
for (int i = 0; i < q; i++) {
fastio::convert(ans[i]);
}
fastio::print();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
;
long long a[111000];
for (int i = 0; i < n; i++) cin >> a[i];
int m;
cin >> m;
;
long long h, w;
long long h0 = a[0];
for (int i = 0; i < m; i++) {
cin >> w >> h;
cout << max(h0, a[w - 1]) << endl;
h0 = max(h0, a[w - 1]) + h;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
} a, p[109];
int len;
char second[109];
void Read() {
scanf("%d %d", &a.x, &a.y);
scanf("%s", second);
len = strlen(second);
}
void Solve() {
if (a.x == 0 && a.y == 0) {
printf("Yes\n");
return;
}
int x = 0, y = 0;
for (int i = 0; i < len; i++) {
if (second[i] == 'R') x++;
if (second[i] == 'L') x--;
if (second[i] == 'D') y--;
if (second[i] == 'U') y++;
p[i + 1].x = x;
p[i + 1].y = y;
if (x == a.x && a.y == y) {
printf("Yes\n");
return;
}
}
x = p[len].x;
y = p[len].y;
if (x == 0 && y == 0) {
printf("No\n");
return;
}
p[0].x = 0;
p[0].y = 0;
for (int i = 0; i < len; i++) {
if (x != 0 && y != 0)
if ((a.x - p[i].x) % x == 0 && (a.y - p[i].y) % y == 0 &&
(a.x - p[i].x) / x == (a.y - p[i].y) / y && (a.y - p[i].y) / y > 0) {
printf("Yes\n");
return;
}
if (x == 0)
if (a.x - p[i].x == 0 && (a.y - p[i].y) % y == 0 &&
(a.y - p[i].y) / y > 0) {
printf("Yes\n");
return;
}
if (y == 0)
if (a.y - p[i].y == 0 && (a.x - p[i].x) % x == 0 &&
(a.x - p[i].x) / x > 0) {
printf("Yes\n");
return;
}
}
printf("No\n");
}
int main() {
Read();
Solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, k;
scanf("%lld", &n), scanf("%lld", &k);
long long ans = 0;
map<vector<pair<long long, long long>>, long long> cnt;
for (long long i = 0; i < n; i++) {
long long u;
scanf("%lld", &u);
vector<pair<long long, long long>> now, need;
for (long long d = 2; d * d <= u; d++)
if (u % d == 0) {
long long r = 0;
while (u % d == 0) u /= d, r++;
r %= k;
if (r > 0) {
now.push_back({d, r});
need.push_back({d, k - r});
}
}
if (u > 1) {
now.push_back({u, 1});
if (k > 1) need.push_back({u, k - 1});
}
ans += cnt[need];
cnt[now]++;
}
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int bignumlen = 5;
const int Blen = 8;
const long long base = 100000000;
struct bignum {
int len;
long long data[bignumlen];
long long &operator[](int x) { return (data[x]); }
const long long &operator[](int x) const { return (data[x]); }
bignum() {
memset(data, 0, sizeof(data));
len = 0;
}
void clear() {
for (int i = len; i >= 1; --i) data[i] = 0;
len = 0;
}
int check(const bignum &a, const bignum &b) {
if (a.len > b.len) return (0);
if (b.len > a.len) return (1);
for (int i = a.len; i >= 1; --i) {
if (a.data[i] < b.data[i]) return (1);
if (b.data[i] < a.data[i]) return (0);
}
return 2;
}
bool operator<(const bignum &b) { return (check(*this, b) == 1); }
bool operator>(const bignum &b) { return (check(*this, b) == 0); }
bool operator<=(const bignum &b) { return (check(*this, b) >= 1); }
bool operator>=(const bignum &b) { return (check(*this, b) % 2 == 0); }
bool operator!=(const bignum &b) { return (check(*this, b) != 2); }
bool operator==(const bignum &b) { return (check(*this, b) == 2); }
bignum operator=(const bignum &x) {
for (int i = x.len + 1; i <= len; ++i) data[i] = 0;
for (int i = 1; i <= x.len; ++i) data[i] = x.data[i];
len = x.len;
return *this;
}
bignum operator=(long long x) {
for (int i = len; i >= 0; --i) data[i] = 0;
len = 0;
while (x) {
data[++len] = x % base;
x /= base;
}
return *this;
}
bignum(long long x) {
memset(data, 0, sizeof(data));
len = 0;
(*this) = x;
}
bignum operator*(const bignum &b) {
int i, j;
bignum tmp;
for (i = 1; i <= len; ++i)
if (data[i] != 0)
for (j = 1; j <= b.len; ++j)
if (b.data[j] != 0) {
tmp.data[i + j - 1] += data[i] * b.data[j];
tmp.data[i + j] += tmp.data[i + j - 1] / base;
tmp.data[i + j - 1] %= base;
}
tmp.len = len + b.len - 1;
while (tmp.data[tmp.len + 1]) tmp.len++;
return tmp;
}
bignum operator*(long long x) {
int i;
bignum tmp;
for (i = 1; i <= len; ++i) tmp[i] = data[i] * x;
tmp.len = len;
for (i = 1; i <= len; ++i) {
tmp[i + 1] += tmp[i] / base, tmp[i] %= base;
if (tmp[i + 1] && i + 1 > tmp.len) tmp.len++;
}
return tmp;
}
bignum operator/(long long x) {
int i;
bignum tmp;
long long y = 0;
for (i = len; i >= 1; --i) {
y = y * base + data[i];
tmp[i] = y / x;
y %= x;
}
tmp.len = len;
while (tmp[tmp.len] == 0 && tmp.len > 1) tmp.len--;
return tmp;
}
bignum operator/(const bignum &b) {
if (b.len <= 1 && b[1] == 0) {
printf("error! 被0除!");
for (;;)
;
}
int i, l1 = (len - 1) * Blen, l2 = (b.len - 1) * Blen;
long long x = data[len], y = b[b.len];
while (x) x /= 10, l1++;
while (y) y /= 10, l2++;
bignum tmp, chu, B;
chu = *this;
B = b;
for (i = 1; i * Blen <= l1 - l2; ++i) B *= base;
for (i = 1; i <= (l1 - l2) % Blen; ++i) B *= 10;
for (i = l1 - l2; i >= 0; --i) {
x = 0;
while (chu >= B) chu -= B, x++;
tmp[i / Blen + 1] = tmp[i / Blen + 1] * 10 + x;
B /= 10;
}
tmp.len = (l1 - l2) / Blen + 1;
while (tmp.len >= 1 && !tmp[tmp.len]) tmp.len--;
return tmp;
}
bignum operator+(const bignum &b) {
bignum tmp;
int i, l = max(len, b.len);
for (i = 1; i <= l; ++i) tmp[i] = data[i] + b[i];
for (i = 1; i <= l; ++i) tmp[i + 1] += tmp[i] / base, tmp[i] %= base;
tmp.len = l;
if (tmp[tmp.len + 1]) tmp.len++;
return tmp;
}
bignum operator+(long long x) {
bignum tmp;
tmp = *this;
tmp[1] += x;
for (int i = 1; i <= len && tmp[i] >= base; ++i)
tmp[i + 1] += tmp[i] / base, tmp[i] %= base;
while (tmp[tmp.len + 1]) tmp.len++;
return tmp;
}
bignum operator-(const bignum &b) {
int i;
bignum tmp;
for (i = 1; i <= len; ++i) tmp.data[i] = data[i] - b.data[i];
for (i = 1; i <= len; ++i) {
if (tmp[i] < 0) tmp.data[i] += base, tmp.data[i + 1]--;
}
tmp.len = len;
while (tmp[tmp.len] == 0 && tmp.len > 1) tmp.len--;
return tmp;
}
bignum operator-(long long x) {
bignum tmp;
tmp = *this;
tmp[1] -= x;
for (int i = 1; i <= len && tmp[i] < 0; ++i) {
tmp[i + 1] += (tmp[i] + 1) / base - 1;
tmp[i] = (tmp[i] + 1) % base + base - 1;
}
while (!tmp[tmp.len] && tmp.len > 1) tmp.len--;
return tmp;
}
long long operator%(long long x) {
int i;
long long y = 0;
for (i = len; i >= 1; --i) y = (y * base + data[i]) % x;
return y;
}
bignum operator%(const bignum &b) {
if (b.len <= 1 && b[1] == 0) {
printf("error! 被0 mod!");
for (;;)
;
}
int i, l1 = (len - 1) * Blen, l2 = (b.len - 1) * Blen;
long long x = data[len], y = b[b.len];
while (x) x /= 10, l1++;
while (y) y /= 10, l2++;
bignum chu, B;
chu = *this;
B = b;
for (i = 1; i * Blen <= l1 - l2; ++i) B *= base;
for (i = 1; i <= (l1 - l2) % Blen; ++i) B *= 10;
for (i = l1 - l2; i >= 0; --i) {
while (chu >= B) chu -= B;
B /= 10;
}
return chu;
}
bignum operator+=(const bignum &b) { return *this = (*this + b); }
bignum operator*=(const bignum &b) { return *this = (*this * b); }
bignum operator-=(const bignum &b) { return *this = (*this - b); }
bignum operator/=(const bignum &b) { return *this = (*this / b); }
bignum operator%=(const bignum &b) { return *this = (*this % b); }
bignum operator*=(long long x) { return (*this = (*this * x)); }
bignum operator+=(long long x) { return (*this = (*this + x)); }
bignum operator-=(long long x) { return (*this = (*this - x)); }
bignum operator/=(long long x) { return (*this = (*this / x)); }
void read() {
char c[bignumlen * Blen + 10];
scanf("%s", c + 1);
int l = strlen(c + 1);
(*this).clear();
long long x;
for (int i = 1; i <= (l - 1) / Blen + 1; ++i) {
x = 0;
for (int j = l - Blen * i + 1; j <= l - Blen * i + Blen; ++j)
if (j >= 1) x = x * 10 + c[j] - 48;
data[++len] = x;
}
}
void write() {
printf("%lld", data[len]);
for (int i = len - 1; i >= 1; --i) printf("%0*lld", Blen, data[i]);
printf("\n");
}
};
long long track[100];
vector<long long> hap;
void sol(int pos) {
long long ans = 0;
long long base = 1;
for (int i = 0; i < pos; i++) {
ans += track[i] * base;
base *= 10;
}
if (ans) hap.push_back(ans);
if (pos == 18) return;
track[pos] = 4;
sol(pos + 1);
track[pos] = 7;
sol(pos + 1);
}
long long n, k;
struct node {
long long l, r, len;
node(long long a = 0, long long b = 0) : l(a), r(b) {}
};
struct val {
long long q, r;
val(long long a = 0, long long b = 0) : q(a), r(b) {}
};
const long long MAX = 1e5 + 20, MOD = 1e8;
node ns[MAX];
node ns2[MAX];
bignum zz[MAX], zz2[MAX];
int preY[MAX * 7];
const val operator+(const val &a, const val &b) {
long long r = a.r + b.r;
return {a.q + b.q + r / MOD, r % MOD};
}
const val operator*(const val &a, const val &b) {
long long r = a.r * b.r;
return {a.q * b.q * MOD + a.q * b.r + b.q * a.r + r / MOD, r % MOD};
}
const val operator-(const val &a, const val &b) {
long long r = a.r - b.r;
if (r >= 0)
return {a.q - b.q, r};
else {
assert(r + MOD >= 0 && r + MOD < MOD);
return {a.q - b.q - 1, r + MOD};
}
}
bool operator<(const val &a, const val &b) {
if (a.q != b.q)
return a.q < b.q;
else
return a.r < b.r;
}
bool operator<=(const val &a, const val &b) { return !(b < a); }
void print(const val &v) { printf("v = %lld\n", v.q * MOD + v.r); }
int main() {
sol(0);
sort(hap.begin(), hap.end());
scanf("%lld%lld", &n, &k);
long long minlen = LLONG_MAX;
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &ns[i].l, &ns[i].r);
ns[i].len = ns[i].r - ns[i].l;
minlen = min(minlen, ns[i].len);
ns2[i] = ns[i];
}
sort(ns, ns + n, [](const node &a, const node &b) { return a.r < b.r; });
sort(ns2, ns2 + n, [](const node &a, const node &b) { return a.l < b.l; });
for (int i = 0; i < n; i++) {
if (i == 0)
zz[i] = ns[i].r;
else
zz[i] = zz[i - 1] + ns[i].r;
}
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1)
zz2[i] = ns2[i].l;
else
zz2[i] = zz2[i + 1] + ns2[i].l;
}
for (int i = (int)hap.size() - 1; i >= 0; i--) {
long long cur = hap[i];
int l = 0, r = n - 1;
while (l < r) {
int mid = (l + r) / 2;
if (ns2[mid].l >= cur) {
r = mid;
} else
l = mid + 1;
}
if (ns2[l].l < cur)
preY[i] = -1;
else
preY[i] = l;
}
int ans = 0;
bignum limit = k;
for (int last = 0; last < hap.size(); last++) {
long long cur = hap[last];
bignum cc = cur;
int l = 0, r = n - 1;
bool debug = 0;
while (l < r) {
int mid = (l + r + 1) / 2;
if (ns[mid].r <= cur)
l = mid;
else
r = mid - 1;
}
bignum tmp = 0;
if (ns[l].r <= cur) {
tmp = cc * (l + 1) - zz[l];
}
if (tmp <= limit) {
bignum resi = limit - tmp;
int l = 0, r = last;
while (l < r) {
int mid = (l + r) / 2;
if (hap[last] - hap[mid] <= minlen)
r = mid;
else
l = mid + 1;
}
int l1 = l, r1 = last;
if (debug) resi.write();
while (l1 < r1) {
int mid = (l1 + r1) / 2;
int idx = preY[mid];
bignum cc2 = hap[mid];
if (idx == -1 || zz2[idx] - cc2 * (n - idx) <= resi)
r1 = mid;
else
l1 = mid + 1;
}
int idx = preY[l1];
bignum cc2 = hap[l1];
if (idx == -1 || zz2[idx] - cc2 * (n - idx) <= resi) {
ans = max(last - l1 + 1, ans);
}
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<ll>;
using VVI = vector<VI>;
using PII = pair<ll, ll>;
const ll LLINF = (1LL << 60);
const ll INF = (1LL << 30);
const ll MOD = 1000000007;
template <typename T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <typename T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
template <typename T>
bool IN(T a, T b, T x) {
return a <= x && x < b;
}
template <typename T>
T ceil(T a, T b) {
return a / b + !!(a % b);
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <class T>
ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
for (ll i = (ll)0; i < (ll)a.size(); ++i) {
out << a[i];
if (i != a.size() - 1) out << ',';
}
out << ']';
return out;
}
ll dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
ll a[200010];
ll cnt[1000010], pow2[1000010], dp[1000010];
signed main(void) {
ll n;
scanf("%lld", &n);
for (ll i = (ll)0; i < (ll)n; ++i) scanf("%lld", &a[i]);
for (ll i = (ll)0; i < (ll)n; ++i) {
for (ll j = 1; j * j <= a[i]; ++j) {
if (a[i] % j == 0) {
cnt[j]++;
if (j * j != a[i]) cnt[a[i] / j]++;
}
}
}
pow2[0] = 1;
for (ll i = (ll)1; i < (ll)1000010; ++i) pow2[i] = pow2[i - 1] * 2 % MOD;
ll ret = 0;
for (ll i = 1000000; i >= 2; --i) {
dp[i] = cnt[i] * pow2[cnt[i] - 1] % MOD;
if (dp[i] == 0) continue;
for (ll j = i * 2; j <= 1000000; j += i) (dp[i] -= dp[j]) %= MOD;
(dp[i] += MOD) %= MOD;
(ret += dp[i] * i) %= MOD;
}
cout << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string str;
int cnt[28], pos_s, pos_e;
char rp;
char mp[2][13];
pair<int, int> next_p(pair<int, int> pos, int dir) {
if (pos.first == 0) {
if ((pos.second > 0 || dir == 1) && (pos.second < 12 || dir == -1))
return pair<int, int>(0, pos.second + dir);
else if (pos.second == 0 && dir == -1)
return pair<int, int>(1, 0);
else if (pos.second == 12 && dir == 1)
return pair<int, int>(1, 12);
} else {
if ((pos.second > 0 || dir == -1) && (pos.second < 12 || dir == 1))
return pair<int, int>(1, pos.second - dir);
else if (pos.second == 0 && dir == 1)
return pair<int, int>(0, 0);
else if (pos.second == 12 && dir == -1)
return pair<int, int>(0, 12);
}
return pair<int, int>(-1, -1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
memset(cnt, 0, sizeof cnt);
memset(mp, 0, sizeof mp);
cin >> str;
for (int i = 0; i < 27; ++i) {
int new_c = ++cnt[str[i] - 'A'];
if (new_c == 2) {
rp = str[i];
pos_e = i;
}
}
for (int i = 0; i < 27; ++i)
if (str[i] == rp) {
pos_s = i;
break;
}
int diff = pos_e - pos_s - 1;
if (diff == 0) {
cout << "Impossible\n";
return 0;
}
int start_p = 12 - diff / 2;
int idx = pos_s;
pair<int, int> pos(0, start_p - 1);
int dir = 1;
while (idx != pos_e) {
pos = next_p(pos, dir);
mp[pos.first][pos.second] = str[idx];
idx++;
}
idx = pos_s - 1;
pos.first = 0;
pos.second = start_p;
dir = -1;
while (idx >= 0) {
pos = next_p(pos, dir);
mp[pos.first][pos.second] = str[idx];
idx--;
}
pos.first = 1;
dir = 1;
idx = pos_e + 1;
if (diff % 2 == 0)
pos.second = start_p + 1;
else
pos.second = start_p;
while (idx < 27) {
pos = next_p(pos, dir);
mp[pos.first][pos.second] = str[idx];
idx++;
}
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 13; ++j) {
cout << mp[i][j];
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
bool d(char c) { return '0' <= c && c <= '9'; }
bool v(char c) {
if (c == 'a') return 1;
if (c == 'e') return 1;
if (c == 'i') return 1;
if (c == 'o') return 1;
if (c == 'u') return 1;
return 0;
}
int main() {
string s;
cin >> s;
int ans = 0;
for (int i = 0; i < s.length(); i++)
ans += ((d(s[i]) && ((s[i] - '0') & 1)) || (!d(s[i]) && v(s[i])));
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int n, v[100003], l[100003], r[100003], fa[100003];
set<int> ok;
inline int rd() {
int res = 0;
char c, f = 0;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') f = 1;
while (c >= '0' && c <= '9') res = res * 10 + c - '0', c = getchar();
return f ? -res : res;
}
inline void dfs(int u, int L, int R) {
if (L > R) return;
if (L <= v[u] && R >= v[u]) ok.insert(v[u]);
if (~l[u]) dfs(l[u], L, min(R, v[u] - 1));
if (~r[u]) dfs(r[u], max(L, v[u] + 1), R);
}
int main() {
n = rd();
int i, ans = 0;
for (i = 1; i <= n; i++) {
v[i] = rd(), l[i] = rd(), r[i] = rd();
if (~l[i]) fa[l[i]] = i;
if (~r[i]) fa[r[i]] = i;
}
for (i = 1; i <= n; i++)
if (!fa[i]) break;
dfs(i, 0, inf);
for (i = 1; i <= n; i++)
if (ok.count(v[i])) ans++;
printf("%d\n", n - ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int min(int, int, int);
int main() {
int t;
cin >> t;
while (t--) {
long int c, m, x;
cin >> c >> m >> x;
int sum = 0;
if (x <= c && x <= m) {
int a = min(c - x, m - x);
int b = max(c - x, m - x);
int p = min(2 * a, b);
sum = x + (a + p) / 3;
}
if (x <= c && x >= m) sum = m;
if (x >= c && x <= m) sum = c;
if (x >= c && x >= m) sum = min(m, c);
cout << sum << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
unordered_set<int> arr1, arr2;
vector<int> arr[200005];
bool visited[200005];
void bfs1(int x) {
if (visited[x]) return;
visited[x] = 1;
for (int i : arr[x]) {
if (i == b || visited[i]) continue;
arr1.insert(i);
bfs1(i);
}
}
void bfs2(int x) {
if (visited[x]) return;
visited[x] = 1;
for (int i : arr[x]) {
if (visited[i] || i == a) continue;
if (arr1.find(i) != arr1.end())
arr1.erase(i);
else {
arr2.insert(i);
}
bfs2(i);
}
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> n >> m >> a >> b;
memset(visited, 0, sizeof(visited));
arr1.clear();
arr2.clear();
for (int i = 0; i <= n; i++) arr[i].clear();
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
arr[x].push_back(y);
arr[y].push_back(x);
}
memset(visited, 0, sizeof(visited));
bfs1(a);
memset(visited, 0, sizeof(visited));
bfs2(b);
long long aa = arr1.size();
long long bb = arr2.size();
cout << aa * bb << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x[60];
long long f[60][3010];
int main(){
int n, A;
scanf("%d%d", &n, &A);
for (int i = 0; i < n; i++){
scanf("%d", &x[i]);
}
f[0][0] = 1;
for (int i = 0; i < n; i++){
for (int j = n; j >= 1; j--){
for (int k = 3000; k >= x[i]; k--){
f[j][k] += f[j - 1][k - x[i]];
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++){
ans += f[i][i * A];
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
vector<int> G[N];
int n;
long long sum[N], odd[N], even[N];
long long sumodd[N], sumeven[N];
long long ans;
void dfs(int u, int fa) {
sum[u] = 1;
even[u] = odd[u] = 0;
for (auto v : G[u]) {
if (v == fa) continue;
dfs(v, u);
sumodd[u] += even[v] * even[u];
sumodd[u] += odd[v] * odd[u];
sumodd[u] += even[u];
odd[u]++;
odd[u] += even[v];
even[u] += odd[v];
ans += 1LL * (n - sum[v]) * sum[v];
sum[u] += sum[v];
}
}
int main() {
scanf("%d", &n);
for (int i = 0, u, v; i < n - 1; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
ans = 0;
dfs(1, 1);
for (int i = 1; i <= n; i++) {
ans += sumodd[i] + odd[i];
}
cout << ans / 2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const int maxn = 3333;
const double eps = 1e-10;
int n;
struct point {
double x, y;
point() {}
point(double xx, double yy) : x(xx), y(yy) {}
} P[maxn];
point operator+(point a, point b) { return point(a.x + b.x, a.y + b.y); }
point operator-(point a, point b) { return point(a.x - b.x, a.y - b.y); }
double cross(point a, point b) { return a.x * b.y - a.y * b.x; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lf%lf", &P[i].x, &P[i].y);
double ans = 0.0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
double lmx = 0, rmx = 0;
for (int k = 1; k <= n; k++) {
if (k == i || k == j) continue;
double cs = cross(P[i] - P[k], P[j] - P[k]) * 0.5;
if (cs < eps)
lmx = max(lmx, -cs);
else
rmx = max(rmx, cs);
}
if (lmx == 0 || rmx == 0) continue;
ans = max(ans, lmx + rmx);
}
}
printf("%.10f\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (scanf("%d %d", &n, &m) != EOF) {
int c[1002], a[1002];
int i, j;
for (i = 0; i < n; i++) {
scanf("%d", &c[i]);
}
for (j = 0; j < m; j++) {
scanf("%d", &a[j]);
}
int ans = 0;
for (i = 0, j = 0; i < n && j < m;) {
if (a[j] >= c[i]) {
i++;
j++;
ans++;
} else {
i++;
}
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
};
struct line {
long long a, b, c;
};
line contructline(point p1, point p2) {
return line{p2.y - p1.y, p1.x - p2.x,
(p1.y - p2.y) * p1.x + (p2.x - p1.x) * p1.y};
}
long double getdist(point p, line l) {
long long val = l.a * p.x + l.b * p.y + l.c, slope = l.a * l.a + l.b * l.b;
return abs(val) / sqrtl(slope);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long double ans = 1e18;
int n;
cin >> n;
point p[n + 1];
for (int i = 0; i < n; ++i) cin >> p[i].x >> p[i].y;
for (int i = 0; i < n; ++i)
ans = min(ans,
getdist(p[i], contructline(p[(i + 1) % n], p[(i - 1 + n) % n])));
cout << setprecision(10) << ans / 2 << "\n";
}
| 2 |
#include<iostream>
#include<vector>
using namespace std;
const int N=250010;
int n,m;
vector<int> a[N];
void dfs(vector<int> &v,int step)
{
vector<int> tmp;
for(int i=0;i<n;i++)
{
tmp.clear();
for(int j=0;j<m;j++)
if(a[i][j]!=v[j])tmp.push_back(j);
if(tmp.size()>2)
{
if((int)tmp.size()+step>4)return;
for(int j=0;j<tmp.size();j++)
{
int tt=v[tmp[j]];
v[tmp[j]]=a[i][tmp[j]];
dfs(v,step+1);
v[tmp[j]]=tt;
}
return;
}
}
puts("Yes");
for(int i=0;i<m;i++)
cout<<v[i]<<" ";
exit(0);
}
int main()
{
cin>>n>>m;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
{
int x;
cin>>x;
a[i].push_back(x);
}
int dif=0;
for(int i=0;i<n;i++)
{ int d=0;
for(int j=0;j<m;j++)
{
if(a[i][j]!=a[0][j])d++;
}
dif=max(dif,d);
}
if(dif>4)puts("No");
else if(dif<=2)
{
puts("Yes");
for(auto &it:a[0])cout<<it<<" ";
}
else
{
vector<int> t=a[0];
dfs(t,0);
puts("No");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, size = 1 << 20, mod = 998244353, inf = 2e9;
const long long INF = 1e15;
template <class o>
void qr(o& x) {
char c = getchar();
x = 0;
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x *= f;
}
template <class o>
void qw(o x) {
if (x / 10) qw(x / 10);
putchar(x % 10 + '0');
}
template <class o>
void pr1(o x) {
if (x < 0) x = -x, putchar('-');
qw(x);
putchar(' ');
}
template <class o>
void pr2(o x) {
if (x < 0) x = -x, putchar('-');
qw(x);
putchar('\n');
}
long long gcd(long long a, long long b) { return !a ? b : gcd(b % a, a); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long power(long long a, long long b = mod - 2, long long p = mod) {
long long c = 1;
while (b) {
if (b & 1) c = c * a % p;
b /= 2;
a = a * a % p;
}
return c;
}
template <class o>
void cmax(o& x, o y) {
if (x < y) x = y;
}
template <class o>
void cmin(o& x, o y) {
if (x > y) x = y;
}
template <typename t1, typename t2>
void ad(t1& x, t2 y) {
x += y;
if (x >= mod) x -= mod;
}
template <typename t1, typename t2>
void dl(t1& x, t2 y) {
x -= y;
if (x < 0) x += mod;
}
int n, a[N];
map<int, int> s;
int id;
struct rec {
int l, r;
bool operator<(rec b) const { return r == b.r ? l > b.l : r < b.r; }
} p[N];
int tot;
void solve() {
qr(n);
for (int i = 1; i <= n; i++) {
qr(a[i]);
if (!s.count(a[i])) s[a[i]] = ++id, p[id].l = i;
a[i] = s[a[i]];
p[a[i]].r = i;
}
sort(p + 1, p + id + 1);
for (int i = 1; i <= id; i++) {
while (tot && p[tot].r >= p[i].l) p[i].l = min(p[i].l, p[tot--].l);
p[++tot] = p[i];
}
pr2(power(2, tot - 1));
}
int main() {
int T = 1;
while (T--) solve();
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int i,j,n,m,c,a[100000],b;
int main(){
for(cin>>n,i=1;i<=n;i++){
cin>>b;
a[b]=i;
}
for(i=1;i<=n;i++)cout<<a[i]<<" ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > a[i - 1]) {
ans += (a[i] - a[i - 1]) * 1ll * (n - a[i] + 1);
} else if (a[i] < a[i - 1]) {
ans += a[i] * 1ll * (a[i - 1] - a[i]);
}
}
cout << ans;
return 0;
}
| 5 |
#include<iostream>
#include<string.h>
#include<string>
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<math.h>
#include<queue>
#include<set>
#include<map>
using namespace std;
typedef long long ll;
typedef long double db;
typedef pair<int,int> pii;
const int N=10000;
const db pi=acos(-1.0);
#define lowbit(x) (x)&(-x)
#define sqr(x) (x)*(x)
#define rep(i,a,b) for (register int i=a;i<=b;i++)
#define per(i,a,b) for (register int i=a;i>=b;i--)
#define fir first
#define sec second
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define maxd 998244353
#define eps 1e-8
int p;
ll c[3030][3030],a[3030];
int read()
{
int x=0,f=1;char ch=getchar();
while ((ch<'0') || (ch>'9')) {if (ch=='-') f=-1;ch=getchar();}
while ((ch>='0') && (ch<='9')) {x=x*10+(ch-'0');ch=getchar();}
return x*f;
}
void calc(int x,int pos)
{
a[0]=(a[0]+1)%maxd;
ll now=-1;
rep(i,0,p-1)
{
a[p-1-i]=(a[p-1-i]+now*c[p-1][i])%p;
now=now*(-pos)%p;
}
}
int main()
{
p=read();
rep(i,0,p)
{
c[i][0]=1;
rep(j,1,i) c[i][j]=(c[i-1][j-1]+c[i-1][j])%p;
}
rep(i,0,p-1)
{
int a=read();
if (a) calc(a,i);
}
rep(i,0,p-1)
{
a[i]=(a[i]+p)%p;
printf("%lld ",a[i]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long N, a[200001], x, i;
int main() {
cin >> N;
cin >> a[N];
a[1] = 0;
for (i = 2; i <= N / 2; ++i) {
cin >> x;
if (x <= a[N - i + 2] + a[i - 1]) {
a[N - i + 1] = x - a[i - 1];
;
a[i] = a[i - 1];
} else {
a[i] = x - a[N - i + 2];
a[N - i + 1] = x - a[i];
}
}
for (i = 1; i <= N; ++i) cout << a[i] << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int t = 1;
while (t--) {
int l, i;
cin >> l;
string str;
cin >> str;
int cnt = 0;
if (l == 1) {
cout << 1 << endl;
return 0;
}
for (i = 0; i < str.size() - 1;) {
if ((str[i] == 'U' && str[i + 1] == 'R') ||
(str[i] == 'R' && str[i + 1] == 'U'))
i += 2;
else
i++;
cnt++;
if (i == l - 2) {
if (str[l - 2] == str[l - 1]) {
cnt += 2;
} else {
cnt++;
}
break;
}
if (i == l - 1) {
cnt++;
break;
}
}
cout << cnt;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, ll, a, ans;
int t[maxn], l[maxn];
int main() {
cin >> n >> ll >> a;
for (int i = 1; i <= n; ++i) {
cin >> t[i] >> l[i];
}
ans += (t[1]) / a;
for (int i = 2; i <= n; ++i) {
int S = t[i];
int T = t[i - 1] + l[i - 1] - 1;
ans += (S - T - 1) / a;
}
ans += (ll - t[n] - l[n] + 1 - 1) / a;
std::cout << ans;
}
| 1 |
//AtCoder
//AGC013B Hamiltonish Path
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXN=100000+10;
int n,m;
vector<int> edge[MAXN];
int vis[MAXN];
vector<int> path1,path2;
void dfs(int t)
{
vis[t]=1;
path1.push_back(t);
for(int i=0;i<edge[t].size();++i)
if(!vis[edge[t][i]])
{
dfs(edge[t][i]);
return;
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin>>n>>m;
int x,y;
for(int i=0;i<m;++i)
{
cin>>x>>y;
edge[x].push_back(y);
edge[y].push_back(x);
}
dfs(1);
swap(path1,path2);
dfs(1);
cout<<path1.size()+path2.size()-1<<endl;
for(int i=int(path2.size())-1;i>=1;--i)
cout<<path2[i]<<' ';
for(int i=0;i<path1.size();++i)
cout<<path1[i]<<' ';
cout<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double E = 1e-11;
const long long MAX = 1e6 + 1;
bool prime(int n) {
for (int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, k;
cin >> n >> k;
int ar[n];
map<long long, long long> m1, m2;
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> ar[i];
long long g = 1LL * ar[i] * k;
ans += m2[ar[i]];
if (g <= INT_MAX) {
m2[g] += m1[ar[i]];
m1[g] += 1;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int maxn = 1e6 + 2;
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
long long po(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
} else {
return gcd(b % a, a);
}
}
int n, c;
int len[maxn], cnt[2 * maxn];
vector<int> val[maxn];
void add(int x, int y) {
if (x >= c || x > y) return;
cnt[x]++;
cnt[y + 1]--;
}
void solve() {
scanf("%d", &(n)), scanf("%d", &(c));
for (int i = 1; i <= n; i++) {
scanf("%d", &(len[i]));
for (int k = 1; k <= len[i]; k++) {
int x;
scanf("%d", &(x));
val[i].push_back(x);
}
}
for (int i = 1; i < n; i++) {
int minn = min(len[i], len[i + 1]);
int fl = 0;
for (int j = 0; j < minn; j++) {
if (val[i][j] == val[i + 1][j]) continue;
if (val[i][j] > val[i + 1][j]) {
add(c + 1 - val[i][j], c - val[i + 1][j]);
} else {
add(0, c - val[i + 1][j]);
int le = val[i][j] - 2;
add(c + 1 - val[i][j], c + 1 - val[i][j] + le);
}
fl = 1;
break;
}
if (!fl && len[i] > len[i + 1]) {
puts("-1");
return;
} else if (!fl) {
add(0, c - 1);
}
}
for (int i = 0; i < c; i++) {
cnt[i] += cnt[i - 1];
if (cnt[i] == n - 1) {
printf("%d", i);
return;
}
}
puts("-1");
}
int main() {
solve();
return 0;
}
| 4 |
#include<iostream>
#include<utility>
#include<queue>
#include<functional>
#include<cstring>
#include<vector>
#include<climits>
#include<map>
using namespace std;
#define FOR(i,n) for(int i=0;i<(int)n;i++)
#define FORI(i,k,n) for(int i=k;i<(int)n;i++)
#define ALL(x) (x).begin(),(x).end()
typedef pair<int,int> pii;
typedef vector<int> vi;
const int M=1010000;
vi pri;
int pf[M]={1,1};
void calc_pri()
{
FORI(i,2,M)
{
if(!pf[i])
{
pri.push_back(i);
for(int j=i+i;j<M;j+=i)
{
pf[j]=1;
}
}
}
}
int a[M];
int main()
{
calc_pri();
int x,n;
while(cin>>n>>x&&n)
{
FOR(i,M)a[i]=0;
a[0]=1;
FOR(i,n)
{
int k;cin>>k;
FOR(j,M)
{
if(j+k>=M)break;
if(a[j])a[j+k]=1;
}
}
for(int i=x;i>=0;i--)
{
if(i==0)cout<<"NA"<<endl;
if(a[i]&&!pf[i])
{
cout<<i<<endl;
break;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i, cnt, ans;
string s;
int main() {
cin >> n >> s;
while (i < s.size()) {
cnt = 0;
while (i < s.size() && s[i] == 'x') i++, cnt++;
ans += max(cnt - 2, 0);
i++;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <stdio.h>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <list>
#include <iterator>
#pragma warning(disable:4996)
typedef long long ll;
#define MIN(a, b) ((a)>(b)? (b): (a))
#define MAX(a, b) ((a)<(b)? (b): (a))
#define LINF 9223300000000000000
#define INF 2140000000
#define MOD 1000000007
using namespace std;
int main(int argc, char* argv[])
{
long n, k;
scanf("%ld%ld", &n, &k);
k++;
vector<long> a(n);
vector<pair<long, long> > z(n); // a[i],b[i]
long i;
for(i=0; i<n; i++) {
long b;
scanf("%ld%ld", &a[i], &b);
z[i] = make_pair(a[i], b);
}
sort(a.begin(), a.end());
sort(z.begin(), z.end());
ll ans=0;
for(i=30; i>=0; i--) {
if(k & (1<<i)) {
ll add = (1<<i);
long i1 = lower_bound(a.begin(), a.end(), add) - a.begin();
ll val = 0;
long p;
for(p=0; p<i1; p++) {
val += z[p].second;
}
ans = MAX(ans, val);
for(p=0; p<n; p++) {
z[p].first &= ~(1<<i);
}
sort(z.begin(), z.end());
for(p=0; p<n; p++) {
a[p] = z[p].first;
}
}
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
string s, t;
vector<int> r;
cin >> s >> t;
int carry = 0;
for (int i = n - 1; i >= 0; --i) {
int a = s[i] - 'a', b = t[i] - 'a';
int c = carry + a + b;
r.push_back('a' + c % 26);
carry = c / 26;
}
r.push_back('a' + carry);
reverse(r.begin(), r.end());
for (int i = 0; i <= n; ++i) {
int carry = (r[i] - 'a') % 2;
r[i] = (r[i] - 'a') / 2 + 'a';
if (carry) r[i + 1] += 26;
}
cout << string(r.begin(), r.end()).substr(1) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
double ans = (double)(arr[0] - 0);
for (int i = 1; i < n; i++) {
if ((double)(arr[i] - arr[i - 1]) / 2 > ans)
ans = (double)(arr[i] - arr[i - 1]) / 2;
}
if ((double)(l - arr[n - 1]) > ans) ans = (double)(l - arr[n - 1]);
printf("%.9f\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i, j, c = 0, k;
cin >> n;
long long int a[n], o = 0, e = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2)
o++;
else
e++;
}
cout << min(o, e);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long sum[200005];
pair<long long, long long> search(int id) {
long long lo = 0, hi = min(id - 1, N - id);
while (hi > lo) {
if (lo + 1 == hi) {
if ((2 * hi + 1) * (sum[N] - sum[N - (lo)] + sum[id] - sum[id - (lo)-1]) <
(2 * lo + 1) * (sum[N] - sum[N - (hi)] + sum[id] - sum[id - (hi)-1]))
lo = hi;
break;
}
long long mid = (lo + hi) / 2;
if ((2 * mid + 3) *
(sum[N] - sum[N - (mid)] + sum[id] - sum[id - (mid)-1]) >=
(2 * mid + 1) *
(sum[N] - sum[N - (mid + 1)] + sum[id] - sum[id - (mid + 1) - 1]))
hi = mid;
else
lo = mid;
}
return make_pair(
(sum[N] - sum[N - (lo)] + sum[id] - sum[id - (lo)-1]) -
(2 * lo + 1) * (sum[N] - sum[N - (0)] + sum[id] - sum[id - (0) - 1]),
lo);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < (int)N; i++) scanf("%I64d", &sum[i + 1]);
sort(sum + 1, sum + 1 + N);
for (int i = 1; i < (int)N + 1; i++) sum[i] += sum[i - 1];
pair<long long, long long> mx = make_pair(-1, 0);
int len = 0, p = 0;
for (int i = 1; i < (int)N + 1; i++) {
pair<long long, long long> d = search(i);
if ((2 * mx.second + 1) * d.first > (2 * d.second + 1) * mx.first)
mx = d, len = d.second, p = i;
}
printf("%d\n", 2 * len + 1);
for (int i = p - len; i < (int)p + 1; i++) {
if (i > p - len) printf(" ");
printf("%d", sum[i] - sum[i - 1]);
}
for (int i = N - len + 1; i < (int)N + 1; i++)
printf(" %d", sum[i] - sum[i - 1]);
puts("");
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 1000006;
int n, son[maxn][2];
char s[maxn][5];
bool w[maxn], f[maxn];
void getw(int x) {
if (s[x][0] == 'A') {
getw(son[x][0]);
getw(son[x][1]);
w[x] = (w[son[x][0]] && w[son[x][1]]);
} else if (s[x][0] == 'O') {
getw(son[x][0]);
getw(son[x][1]);
w[x] = (w[son[x][0]] || w[son[x][1]]);
} else if (s[x][0] == 'X') {
getw(son[x][0]);
getw(son[x][1]);
w[x] = (w[son[x][0]] ^ w[son[x][1]]);
} else if (s[x][0] == 'N') {
getw(son[x][0]);
w[x] = (!w[son[x][0]]);
}
}
void dp(int x) {
if (!f[x]) return;
if (s[x][0] == 'A') {
if (w[son[x][0]]) f[son[x][1]] = 1;
if (w[son[x][1]]) f[son[x][0]] = 1;
dp(son[x][0]);
dp(son[x][1]);
} else if (s[x][0] == 'O') {
if (!w[son[x][0]]) f[son[x][1]] = 1;
if (!w[son[x][1]]) f[son[x][0]] = 1;
dp(son[x][0]);
dp(son[x][1]);
} else if (s[x][0] == 'X') {
f[son[x][1]] = 1;
f[son[x][0]] = 1;
dp(son[x][0]);
dp(son[x][1]);
} else if (s[x][0] == 'N') {
f[son[x][0]] = 1;
dp(son[x][0]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1, x; i <= n; i++) {
scanf("%s", s[i]);
if (s[i][0] == 'I')
scanf("%d", &x), w[i] = (x == 1);
else if (s[i][0] == 'N')
scanf("%d", &son[i][0]);
else
scanf("%d%d", &son[i][0], &son[i][1]);
}
getw(1);
f[1] = 1;
dp(1);
for (int i = 1; i <= n; i++)
if (s[i][0] == 'I') putchar((f[i] ^ w[1]) ? '1' : '0');
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
int n;
int p[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int q[8] = {0, 1, 0, -1, 1, -1, 1, -1};
bool is_check(point K, point Q) {
return Q.x == K.x || Q.y == K.y || abs(Q.x - K.x) == abs(Q.y - K.y);
}
bool vis[1005][1005];
point Q;
bool bfs(point K, point C) {
queue<point> qx;
vis[K.x][K.y] = 1;
qx.push(K);
while (!qx.empty()) {
point now = qx.front();
qx.pop();
for (int i = 0; i < 8; i++) {
point tmp = now;
tmp.x += p[i];
tmp.y += q[i];
if (tmp.x > n || tmp.x < 1 || tmp.y > n || tmp.y < 1 || vis[tmp.x][tmp.y])
continue;
if (is_check(tmp, Q)) continue;
vis[tmp.x][tmp.y] = 1;
if (C.x == tmp.x && C.y == tmp.y) return 1;
qx.push(tmp);
}
}
return 0;
}
point K, C;
int main() {
scanf("%d", &n);
scanf("%d%d", &Q.x, &Q.y);
scanf("%d%d", &K.x, &K.y);
scanf("%d%d", &C.x, &C.y);
if (bfs(K, C)) {
printf("YES\n");
} else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(unsigned long long &x) { scanf("%llu", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
const int MOD = 1e9 + 7, mod = 998244353;
long long qpow(long long a, long long b) {
long long res = 1;
a %= MOD;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
const int MAXN = 4e5 + 10, MAXM = 2e6 + 10;
const int INF = INT_MAX, SINF = 0x3f3f3f3f;
const long long llINF = LLONG_MAX;
const int inv2 = (MOD + 1) / 2;
const int Lim = 1 << 20;
long long a[MAXN];
void solve() {
int n;
R(n);
memset(a, 0x3f, sizeof(a));
a[0] = -a[0];
for (int i = 1; i <= n; i++) R(a[i]);
for (int i = 1; i <= n; i++) {
long long mi = min(a[i] - a[i - 1], a[i + 1] - a[i]);
long long mx = max(a[i] - a[1], a[n] - a[i]);
W(mi, mx);
}
}
int main() {
int T = 1;
for (int kase = 1; kase <= T; kase++) {
solve();
}
return 0;
}
| 1 |
#include <stdio.h>
int main(){
int n,N[100];
int i=0;
scanf("%d",&n);
for(i=0; i<n; ++i){
scanf("%d",&N[i]);
}
for(i=n-1;i>0;--i){
printf("%d ",N[i]);
}
printf("%d\n",N[0]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
char c;
int state, len, bad, len2, end2;
int main() {
bad = 0;
c = 0;
len = 0;
do {
c = getchar();
if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' ||
c == '_') {
++len;
if (len > 16) bad = 1;
} else {
if (c != '@' || len == 0) bad = 1;
}
} while (c != '@' && !bad);
len = 0;
len2 = 0;
end2 = 0;
do {
c = getchar();
if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' ||
c == '_') {
++len;
++len2;
if (len > 16 || len2 > 32) bad = 1;
} else if (c == '.') {
if (len == 0) bad = 1;
len = 0;
len2++;
if (len2 > 32) bad = 1;
} else {
if (c == '/' || c == 0 || c == '\n' || c == -1) {
if (len == 0) bad = 1;
end2 = 1;
} else
bad = 1;
}
} while (!end2 && !bad);
len = 0;
if (!bad && c == '/') {
do {
c = getchar();
if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' ||
c >= '0' && c <= '9' || c == '_') {
++len;
if (len > 16) bad = 1;
} else {
if (c == 0 || c == '\n' || c == -1) {
if (len == 0) bad = 1;
} else
bad = 1;
}
} while (c != -1 && c != 0 && c != '\n' && !bad);
}
if (bad)
printf("NO");
else
printf("YES");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void INPUT() {}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
INPUT();
long long n, p;
cin >> n >> p;
string s;
cin >> s;
long long ans = 0;
vector<long long> pos;
for (long long i = 0; i < (long long)s.size() / 2; i++) {
ans += min(abs(s[i] - s[n - 1 - i]), 26 - abs(s[i] - s[n - i - 1]));
if (s[i] != s[n - i - 1]) pos.push_back(i + 1);
}
if (p > n / 2) p = n - p + 1;
if ((long long)pos.size()) {
ans += (pos.back() - pos[0]) + min(abs(pos.back() - p), abs(pos[0] - p));
}
cout << ans << "\n";
return 0;
}
| 3 |
#include<cstdio>
using namespace std;
#define N 10050
int n,k,tp;
char s[N],t[N],as[N],as1[N];
void solve()
{
int le=0,st=n;
while(t[st]==t[n])le++,st--;
le<<=(k-1);
if(le>n)le=n;
for(int i=1;i<=le;i++)as1[i]=t[n];
for(int i=le+1,k=st;i<=n;i++,k--)as1[i]=t[k];
for(int i=1;i<=n;i++)if(as[i]>as1[i]){for(int j=1;j<=n;j++)as[j]=as1[j];return;}
else if(as[i]<as1[i])return;
}
int main()
{
scanf("%d%d%s",&n,&k,s+1);
if(k>=14){char as='z';for(int i=1;i<=n;i++)if(s[i]<as)as=s[i];for(int i=1;i<=n;i++)printf("%c",as);return 0;}
tp=1<<k-1;
for(int i=1;i<=n;i++)s[n*2-i+1]=s[i];
as[1]='z'+1;
for(int i=n+1;i<=n*2;i++)
{
for(int j=i-n+1;j<=i;j++)t[j-i+n]=s[j];
solve();
}
printf("%s",as+1);
}//
| 0 |
#include <cstdio>
#include <vector>
using namespace std;
int main(){
for(int n,q;~scanf("%d%d",&n,&q);){
for(int i=1;;i*=2) if(i>=n){ n=i; break; }
vector<int> val(n),idx(2*n);
for(int i=0;i<n;i++) idx[n+i]=i;
for(int i=n;--i;) idx[i]=idx[i*2];
while(q--){
int a,v; scanf("%d%d",&a,&v);
val[--a]+=v;
for(int i=(n+a)/2;i;i/=2)
idx[i]=idx[i*2+(val[idx[i*2]]<val[idx[i*2+1]])];
printf("%d %d\n",idx[1]+1,val[idx[1]]);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
const int N = 1e6 + 10;
int n, m, q, a[N], b[N], f[N], fa[N][21], pre[N], v[N << 2];
int Log[N];
int get(int first, int k) {
while (k) first = fa[first][Log[k & -k]], k ^= k & -k;
return first ? first : INF;
}
int build(int o, int l, int r) {
if (l == r) return v[o] = get(l, n - 1);
return v[o] = min(build((o << 1), l, ((l + r) >> 1)),
build(((o << 1) | 1), ((l + r) >> 1) + 1, r));
}
int query(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return v[o];
if (((l + r) >> 1) >= qr) return query((o << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < ql)
return query(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr);
return min(query((o << 1), l, ((l + r) >> 1), ql, qr),
query(((o << 1) | 1), ((l + r) >> 1) + 1, r, ql, qr));
}
int main() {
for (int i = 0; i <= 19; ++i) Log[1 << i] = i;
scanf("%d%d%d", &n, &m, &q);
if (n == 1) {
for (int i = 1; i <= q; ++i) putchar('1');
return putchar(10), 0;
}
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i) f[a[i]] = a[i + 1];
f[a[n]] = a[1];
for (int i = 1; i <= m; ++i) scanf("%d", b + i);
for (int i = 1; i <= N - 1; ++i) pre[i] = N - 1;
for (int i = m; i >= 1; --i) {
fa[i][0] = pre[f[b[i]]];
pre[b[i]] = i;
for (int j = 1; j <= 20; ++j) fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
build(1, 1, m);
for (int i = 1; i <= q; ++i) {
int first, second;
scanf("%d%d", &first, &second);
putchar(query(1, 1, m, first, second) <= second ? '1' : '0');
}
putchar(10);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, ans, x, y, m1, m2[100001], m;
vector<pair<long long, long long> > heap;
vector<int> g[200001];
vector<pair<long long, long long> > a;
int viz[200001];
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> m1, a.push_back(make_pair(m1, i));
for (i = 1; i <= m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
m2[x] += a[y - 1].first;
m2[y] += a[x - 1].first;
};
sort(a.begin(), a.end());
for (i = n - 1; i >= 0; i--) {
ans += m2[a[i].second];
for (int j = 0; j < g[a[i].second].size(); j++) {
int to = g[a[i].second][j];
m2[to] -= a[i].first;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a, b, c, m[3]{}, count{};
cin >> a >> b >> c;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'R')
m[0]++;
else if (s[i] == 'P')
m[1]++;
else
m[2]++;
}
count = min(m[0], b) + min(m[1], c) + min(m[2], a);
int y[3];
char z[3];
y[0] = b;
y[1] = c;
y[2] = a;
z[0] = 'R';
z[1] = 'P';
z[2] = 'S';
if (count < (n + 1) / 2)
cout << "NO" << endl;
else {
cout << "YES" << endl;
int x[3];
x[0] = max(0, b - m[0]), x[1] = max(0, c - m[1]), x[2] = max(0, a - m[2]);
for (int i = 0; i < n; i++) {
int j;
for (j = 0; j < 3; j++) {
if (s[i] == z[j]) break;
}
if (y[j] > 0) {
cout << z[(j + 1) % 3];
y[j]--;
} else {
int mx = (j + 1) % 3;
if (x[(j + 2) % 3] > x[(j + 1) % 3]) mx = (j + 2) % 3;
cout << z[(mx + 1) % 3];
x[mx]--;
y[mx]--;
}
}
cout << endl;
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
bool flag=0;
getline (cin,s);
for(int i=0;i<s.length();i++){
if(s[i]=='C')flag=1;
if(flag&&s[i]=='F'){
puts("Yes");
return 0;
}
}
puts("No");
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int main(){
int m, f, r;
while(cin >> m >> f >> r, m!=-1||f!=-1||r!=-1){
if((m==-1 || f==-1) || (m+f<30)) cout << "F" << endl;
else if(m+f>=80) cout << "A" << endl;
else if(m+f>=65) cout << "B" << endl;
else if(m+f>=50||r>=50) cout << "C" << endl;
else cout << "D" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[(1 << 20)], cnt[(1 << 20)];
bool palin[(1 << 20)], okTo[(1 << 20)];
long long c1, oddNum, cntAv[(1 << 20)], ans;
int cntL[(1 << 20)], cntR[(1 << 20)];
bool pos(int l, int r) {
for (int i = 0; i <= n; i++) {
cntAv[i] = 0;
}
if (r < n / 2) {
if (n % 2 && a[n / 2] != oddNum) {
return 0;
}
for (int i = r + 1; i < n - r - 1; i++) {
if (a[i] != a[n - 1 - i]) {
return 0;
}
}
for (int i = l; i <= r; i++) {
cntAv[a[i]]++;
}
for (int i = n - r - 1; i < n - l; i++) {
cntAv[a[i]]--;
}
for (int i = 0; i <= n; i++) {
if (cntAv[i] < 0) {
return 0;
}
if (n % 2 && i == oddNum) {
} else {
if (cntAv[i] % 2) {
return 0;
}
}
}
return 1;
}
for (int i = l; i <= r; i++) {
cntAv[a[i]]++;
}
for (int i = r + 1; i < n - l; i++) {
cntAv[a[i]]--;
}
for (int i = 0; i <= n; i++) {
if (cntAv[i] < 0) {
return 0;
}
if (n % 2 && i == oddNum) {
if (cntAv[i] % 2 == 0) {
return 0;
}
} else {
if (cntAv[i] % 2) {
return 0;
}
}
}
return 1;
}
int lf;
void getC(bool b) {
int sInd = 0;
for (; palin[sInd]; sInd++) {
}
int l = sInd, r = n - sInd, m = (l + r) / 2;
for (; l + 1 < r; m = (l + r) / 2) {
if (pos(sInd, m)) {
r = m;
} else {
l = m;
}
}
int crr = (n - sInd - 1) - r + 1;
if (!b) {
lf = crr;
}
if (b) {
cntL[sInd] = crr;
for (int i = sInd - 1; i >= 0; i--) {
cntL[i] = cntL[i + 1] + 2;
}
} else {
r = max(1LL * r, n - lf);
crr = (n - sInd - 1) - r + 1;
cntR[n - 1 - sInd] = crr;
for (int i = sInd - 1; i >= 0; i--) {
cntR[n - 1 - i] = cntR[n - 1 - i - 1] + 2;
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
oddNum ^= a[i];
}
for (int i = 0; i < n; i++) {
cnt[a[i]]++;
if (cnt[a[i]] % 2) {
c1++;
} else {
c1--;
}
}
if (n % 2) {
if (c1 != 1 || cnt[oddNum] % 2 != 1) {
cout << "0\n";
return 0;
}
} else {
if (c1) {
cout << "0\n";
return 0;
}
}
for (int i = 0; i <= n / 2; i++) {
if (a[i] == a[n - 1 - i]) {
palin[i] = 1;
palin[n - 1 - i] = 1;
} else {
break;
}
}
if (palin[n / 2]) {
cout << n * (n + 1) / 2 << "\n";
return 0;
}
getC(0);
reverse(a, a + n);
getC(1);
reverse(a, a + n);
int l = 0, r = n - 1;
for (; l < r;) {
ans += cntL[l] + cntR[r] - 1;
if (!palin[l]) {
break;
}
l++;
r--;
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < int(b); ++i)
#define REP(i, n) FOR(i, 0, n)
using Weight = int;
struct Edge {
int src, dst, capacity;
Weight weight;
};
using Graph = vector<vector<Edge>>;
void add_edge(Graph& graph, int src, int dst, int capacity, Weight weight) {
graph[src].push_back((Edge){src, dst, capacity, weight});
graph[dst].push_back((Edge){dst, src, 0, -weight});
}
// Verified: AOJ 2293 (Dangerous Tower)
Weight minimum_cost_flow(const Graph& graph, int source, int sink) {
static const Weight inf = numeric_limits<Weight>::max() / 10;
vector<vector<int>> flow(graph.size(), vector<int>(graph.size()));
// calculate initial potential with Bellman Ford.
vector<Weight> potential(graph.size(), inf);
potential[source] = 0;
for (int i = 0; ; ++i) {
bool updated = false;
REP(u, graph.size()) {
if (potential[u] == inf) continue;
for (auto& e : graph[u]) {
if (e.capacity > 0 && potential[e.dst] > potential[e.src] + e.weight) {
potential[e.dst] = potential[e.src] + e.weight;
updated = true;
}
}
}
if (!updated) break;
if (i == (int)graph.size()) assert(false); // the graph has a negative cycle
}
Weight total = 0;
for (;;) {
// find path
using State = pair<Weight, int>; // (distance, vertex)
priority_queue<State, vector<State>, greater<State>> Q;
vector<Weight> dist(graph.size(), inf);
vector<const Edge*> prev(graph.size(), nullptr);
Q.push(State(0, source));
dist[source] = 0;
while (!Q.empty()) {
Weight w; int u; tie(w, u) = Q.top(); Q.pop();
if (dist[u] < w) continue;
for (auto& e : graph[u]) {
int residue = e.capacity - flow[e.src][e.dst];
int cost = e.weight + potential[e.src] - potential[e.dst];
if (residue > 0 && dist[e.dst] > dist[e.src] + cost) {
dist[e.dst] = dist[e.src] + cost;
prev[e.dst] = &e;
Q.push(State(dist[e.dst], e.dst));
}
}
}
if (prev[sink] == nullptr) return total;
REP(u, graph.size()) potential[u] += dist[u];
// augment flow
int aug = INT_MAX;
for (int v = sink; prev[v] != nullptr; v = prev[v]->src) {
auto e = prev[v];
aug = min(aug, e->capacity - flow[e->src][e->dst]);
}
for (int v = sink; prev[v] != nullptr; v = prev[v]->src) {
auto e = prev[v];
flow[e->src][e->dst] += aug;
flow[e->dst][e->src] -= aug;
}
total += aug * potential[sink];
}
}
int main() {
cin.tie(0); ios_base::sync_with_stdio(false);
int N;
while (cin >> N) {
vector<int> A(N), B(N);
REP(i, N) cin >> A[i] >> B[i];
vector<int> distinct;
distinct.insert(distinct.end(), A.begin(), A.end());
distinct.insert(distinct.end(), B.begin(), B.end());
sort(distinct.begin(), distinct.end());
distinct.erase(unique(distinct.begin(), distinct.end()), distinct.end());
Graph graph(N + distinct.size() + 3);
int trash = N + distinct.size();
int source = trash+1, sink = trash+2;
REP(u, N) add_edge(graph, source, u, 1, 0);
REP(v, distinct.size()) add_edge(graph, v+N, sink, 1, 0);
add_edge(graph, trash, sink, N, 0);
REP(i, N) {
int a_index = lower_bound(distinct.begin(), distinct.end(), A[i]) - distinct.begin();
int b_index = lower_bound(distinct.begin(), distinct.end(), B[i]) - distinct.begin();
add_edge(graph, i, N+a_index, 1, -B[i]);
add_edge(graph, i, N+b_index, 1, -A[i]);
add_edge(graph, i, trash, 1, 0);
}
cout << -minimum_cost_flow(graph, source, sink) << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> a(100005);
int main() {
ios::sync_with_stdio(0);
string s;
cin >> s;
int m, x;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> x;
x--;
a[x] = 1 - a[x];
}
int n = s.size() / 2;
int size = s.size() - 1;
bool flag = 0;
for (int i = 0; i < n; i++) {
if (a[i] ^ flag) {
char tmp = s[i];
s[i] = s[size - i];
s[size - i] = tmp;
}
flag = flag ^ a[i];
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 32;
int t;
int n, p;
bool mark[MAXN][MAXN];
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cerr << "HELLO WORLD :)\n";
cin >> t;
while (t--) {
cin >> n >> p;
memset(mark, 0, sizeof(mark));
for (int i = 0; i < n; i++) {
cout << i + 1 << ' ' << (i + 1) % n + 1 << '\n';
cout << i + 1 << ' ' << (i + 2) % n + 1 << '\n';
mark[i + 1][(i + 1) % n + 1] = mark[i + 1][(i + 2) % n + 1] = 1;
mark[(i + 1) % n + 1][i + 1] = mark[(i + 2) % n + 1][i + 1] = 1;
}
for (int i = 1; i <= n && p; i++) {
for (int j = i + 1; j <= n && p; j++) {
if (!mark[i][j]++) {
cout << i << ' ' << j << '\n';
p--;
}
}
}
}
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int n,c=0,r=0;
cin>>n;
for (int N=0;N<n;N++){
int a,b;
cin>>a>>b;
if(a==b){
c++;
}else{
c=0;
}
if(c>=3){
r=1;
}
}
if(r==1) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int main(){
int h,m,s,ansh[3],ansm[3],anss[3],h1,m1,s1,S,S1,memo;
for(int i=0;i<3;i++){
cin>>h>>m>>s>>h1>>m1>>s1;
S=h*3600+m*60+s;
S1=h1*3600+m1*60+s1;
memo=S1-S;
ansh[i]=memo/3600;
ansm[i]=memo/60-ansh[i]*60;
anss[i]=memo%60;
}
for(int i=0;i<3;i++){
cout<<ansh[i]<<" "<<ansm[i]<<" "<<anss[i]<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 5;
const int maxm = 1e6 + 5;
int n, k, a[maxn];
long long A[maxn + 5], AA[maxn + 5], sum[maxn + 5], pw10[maxn + 5];
long long QP(long long a, long long n) {
long long ans = 1, tmp = a;
while (n) {
if (n & 1) ans = ans * tmp % mod;
tmp = tmp * tmp % mod;
n >>= 1;
}
return ans;
}
void init() {
A[0] = 1;
for (int i = 1; i <= maxn; ++i) A[i] = A[i - 1] * i % mod;
AA[maxn] = QP(A[maxn], mod - 2);
for (int i = maxn; i >= 1; --i) AA[i - 1] = AA[i] * i % mod;
pw10[0] = 1;
for (int i = 1; i <= maxn; ++i) pw10[i] = pw10[i - 1] * 10 % mod;
}
long long C(int n, int m) {
if (n < m) return 0;
return A[n] * AA[n - m] % mod * AA[m] % mod;
}
int main() {
init();
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%1d", &a[i]);
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + a[i];
long long ans = 0;
for (int i = 1; i <= n - k; ++i) {
ans = (ans + C(n - 1 - i, k - 1) * pw10[i - 1] % mod * sum[n - i] % mod) %
mod;
ans = (ans + C(n - i, k) * a[n - i + 1] % mod * pw10[i - 1] % mod) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
# define ll long long
# define read read1<ll>()
# define Type template<typename T>
Type T read1(){
T t=0;
char k;
bool vis=0;
do (k=getchar())=='-'&&(vis=1);while('0'>k||k>'9');
while('0'<=k&&k<='9')t=(t<<3)+(t<<1)+(k^'0'),k=getchar();
return vis?-t:t;
}
# define fre(k) freopen(k".in","r",stdin);freopen(k".out","w",stdout)
int s,m,f[1<<14][105],u[1<<14][14],v[1<<14][105];//S where sum
ll g[1<<14][105];//S sum time
pair<int,int>a[14];
struct Query{
int x,y,t;
bool operator <(const Query &b)const{return t<b.t;}
pair<int,int> ret(){return make_pair(x,y);}
}q[105];
int dis(const pair<int,int> &x,const pair<int,int> &y){return abs(x.first-y.first)+abs(x.second-y.second);}
int main(){
s=read,m=read;
for(int i=0;i<s;++i)a[i].first=read,a[i].second=read;
for(int i=1;i<=m;++i)
q[i].x=read,q[i].y=read,q[i].t=read;
sort(q+1,q+m+1);
for(int i=0;i<s;++i)u[0][i]=1e9;
for(int i=1;i<=m;++i)v[0][i]=1e9;
for(int i=0;i<s;++i)
for(int j=0;j<s;++j)
u[1<<i][j]=dis(a[i],a[j]);
for(int i=0;i<s;++i)
for(int j=1;j<=m;++j)
v[1<<i][j]=dis(a[i],q[j].ret());
for(int i=1;i<(1<<s);++i){
int w=i&i-1,p=i&-i;if(!w)continue;
for(int j=0;j<s;++j)
u[i][j]=min(u[w][j],u[p][j]);
for(int j=1;j<=m;++j)
v[i][j]=min(v[w][j],v[p][j]);
}memset(g,0x7f>>1,sizeof(g));const ll gMax=**g;
memset(f,-1,sizeof(f));
for(int i=0;i<s;++i)g[1<<i][0]=0;
for(int i=1;i<=m;++i)f[0][i]=1;
int ans=0;
for(int i=0;i<(1<<s);++i){
for(int k=0;k<=m;++k)
if(g[i][k]!=gMax){
ans=max(ans,k);
// printf("g::%d %d %lld\n",i,k,g[i][k]);
for(int j=0;j<s;++j)
if(~i>>j&1)
g[i|1<<j][k]=min(g[i|1<<j][k],g[i][k]+u[i][j]);
for(int j=1;j<=m;++j)
if(q[j].t>=g[i][k]+v[i][j])
f[i][j]=max(f[i][j],k+1);
}
for(int k=1;k<=m;++k)
if(~f[i][k]){
// printf("f::%d %d %d\n",i,k,f[i][k]);
ans=max(ans,f[i][k]);
for(int j=0;j<s;++j)
if(~i>>j&1)
g[i|1<<j][f[i][k]]=min(g[i|1<<j][f[i][k]],min(dis(q[k].ret(),a[j]),u[i][j])+0ll+q[k].t);
for(int j=k+1;j<=m;++j)
if(q[j].t>=min(dis(q[k].ret(),q[j].ret()),v[i][j])+q[k].t)
f[i][j]=max(f[i][j],f[i][k]+1);
}
}cout<<ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s, s1;
cin >> s >> s1;
int flag = 0;
int dir = 0;
for (int i = 0; i < n; i++) {
if (s[i] - '0' <= 2) {
s[i] = '0';
} else {
s[i] = '1';
}
if (s1[i] - '0' <= 2) {
s1[i] = '0';
} else {
s1[i] = '1';
}
}
int i;
for (i = 0; i < n; i++) {
if (dir == 0) {
if (s[i] == '0') {
continue;
} else if (s[i] == '1' && s1[i] == '1') {
dir = 1;
} else
break;
} else {
if (s1[i] == '0') {
continue;
} else if (s[i] == '1' && s1[i] == '1') {
dir = 0;
} else
break;
}
}
if (dir == 1 && i == n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long max_n = 3e2 + 5;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tc;
cin >> tc;
while (tc--) {
cin >> n;
set<int> coor;
vector<int> l(n), r(n);
for (long long i = 0; (1 > 0 and i < n) or (1 < 0 and i > n); i += 1) {
cin >> l[i] >> r[i];
coor.insert(l[i]);
coor.insert(r[i]);
}
vector<set<int> > ivl(coor.size());
map<int, int> val;
int cntr = 0;
for (auto x : coor) val[x] = cntr++;
for (long long i = 0; (1 > 0 and i < n) or (1 < 0 and i > n); i += 1) {
l[i] = val[l[i]];
r[i] = val[r[i]];
ivl[l[i]].insert(r[i]);
}
n = coor.size();
vector<vector<int> > dp(n, vector<int>(n, 0));
for (long long i = n - 1; (-1 > 0 and i < -1) or (-1 < 0 and i > -1);
i += -1) {
for (long long j = i; (1 > 0 and j < n) or (1 < 0 and j > n); j += 1) {
int x = 0;
if (!ivl[i].empty() and ivl[i].find(j) != ivl[i].end()) x = 1;
dp[i][j] = x;
if (i < j) dp[i][j] = max(dp[i][j], x + dp[i + 1][j]);
for (auto y : ivl[i]) {
if (y >= j) break;
dp[i][j] = max(dp[i][j], x + dp[i][y] + dp[y + 1][j]);
}
}
}
cout << dp[0][n - 1] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long g[100000], o[100000];
long long odl(long long a, long long b) {
if (a - b > 0) return a - b;
return b - a;
}
bool ok(long long t, int n, int m) {
long long od, p, d;
for (int i = n - 1; i >= 0; i--) {
if (o[m - 1] - g[i] > t) return 0;
od = o[m - 1] - g[i];
if (od < 0) od = 0;
p = (o[m - 1] >= g[i]);
while (1) {
if (m == p) return 1;
if (o[m - 1 - p] >= g[i]) {
p++;
continue;
}
if (2 * odl(g[i], o[m - 1 - p]) + od <= t)
p++;
else
break;
}
d = (o[m - 1] >= g[i]);
while (1) {
if (m == d) return 1;
if (o[m - 1 - d] >= g[i]) {
d++;
continue;
}
if (odl(o[m - 1 - d], g[i]) + 2 * od <= t)
d++;
else
break;
}
if (p > d)
m -= p;
else
m -= d;
}
if (m > 0) return 0;
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> g[i];
for (int i = 0; i < m; i++) cin >> o[i];
long long p = 0, k = 1000000, s;
k = k * k;
while (k - p > 1) {
s = (p + k) / 2;
if (ok(s, n, m))
k = s;
else
p = s + 1;
}
if (ok(p, n, m))
cout << p << "\n";
else
cout << k << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans[100005];
set<int> s[100005];
int main() {
srand(time(NULL));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
s[u].insert(v);
s[v].insert(u);
}
for (int i = 1; i <= n; i++) ans[i] = i;
for (int k = 1; k <= 500; k++) {
random_shuffle(ans + 1, ans + 1 + n);
ans[0] = ans[n];
int cnt = 0;
for (int i = 0; i < n; i++)
if (s[ans[i]].count(ans[i + 1]))
continue;
else
cnt++;
if (cnt < m) continue;
cnt = m;
for (int i = 0; i < n; i++)
if (s[ans[i]].count(ans[i + 1]))
continue;
else if (cnt) {
cnt--;
printf("%d %d\n", ans[i], ans[i + 1]);
}
return 0;
}
printf("-1\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T &t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T &t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
struct Point {
long long x, y;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
long double abs() const { return hypot(x, y); }
long double arg() const { return atan2(y, x); }
Point operator*(double o) const { return Point(x * o, y * o); }
Point operator+(const Point &o) const { return Point(x + o.x, y + o.y); }
Point operator-(const Point &o) const { return Point(x - o.x, y - o.y); }
Point operator/(double o) const { return Point(x / o, y / o); }
bool operator<(const Point &o) const {
return x < o.x - 1e-9 || (x < o.x + 1e-9 && y < o.y - 1e-9);
}
friend bool operator==(const Point &r1, const Point &r2) {
return r1.x == r2.x && r1.y == r2.y;
}
Point scale(double o) const { return *this * (o / abs()); }
Point rotY() const { return Point(-y, x); }
Point rotX() const { return Point(y, -x); }
long long cross(Point b) const { return x * b.y - b.x * y; }
long long dot(Point b) const { return x * b.x + y * b.y; }
long double disToSeg(Point &a, Point &b) {
return fabs(((*this) - a).cross(b - a) / (b - a).abs());
}
pair<long long, long long> getVec() {
if (x == 0) return {0, y > 0 ? 1 : -1};
if (y == 0) return {x < 0 ? -1 : 1, 0};
long long gg = gcd1(::abs(x), ::abs(y));
long long px = x / gg, py = y / gg;
return {px, py};
}
void readin() { scanf("%lld%lld", &x, &y); }
} p[100035];
vector<Point> convex(vector<Point> &vp) {
sort(vp.begin(), vp.end());
int N = unique(vp.begin(), vp.end()) - vp.begin();
vector<Point> ans2;
for (int i = N - 1; i >= 0; i--) {
while (ans2.size() > 1) {
Point o = ans2[ans2.size() - 2], a = ans2.back();
if ((a - o).cross(vp[i] - o) <= 0) {
ans2.pop_back();
} else
break;
}
ans2.push_back(vp[i]);
}
return ans2;
}
void fmain(int tid) {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
p[i].readin();
}
vector<Point> vp;
long long mix = (1LL << 60), mxx = -(1LL << 60);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
mintt(mix, p[i].x);
maxtt(mxx, p[i].x);
vp.push_back(Point(p[i].x, p[i].y - p[i].x * p[i].x));
}
vector<Point> con = convex(vp);
long long ans = 0;
int pre = 0;
int N = con.size();
for (int j = 1; j < N; j++) {
if (con[j].x == con[j - 1].x) break;
ans++;
if (con[j % N].y == con[j - 1].y) {
ans += pre;
pre++;
} else {
pre = 0;
}
}
printf("%lld\n", ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3fffffff, M = (long long)(1e5 + 100);
long long n, m, place[M], aim[M];
bool C(long long x) {
int p = 0;
long long y;
for (int i = 0; i < n; i++) {
y = place[i];
if (y - aim[p] > x) return false;
if (y <= aim[p])
y += x;
else
y = max(y, max(aim[p] + x + aim[p] - y, ((x - y + aim[p]) / 2) + y));
while (p < m && aim[p] <= y) p++;
if (p >= m) return true;
}
if (p < m) return false;
return true;
}
long long slove(void) {
long long l = 0, r = (long long)10000000000000000LL, mid;
while (r - l > 1) {
mid = (r + l) / 2;
if (C(mid))
r = mid;
else
l = mid + 1;
}
if (C(l)) return l;
return r;
}
int main(void) {
while (~scanf("%I64d%I64d", &n, &m)) {
for (long long i = 0; i < n; i++) {
scanf("%I64d", &place[i]);
}
for (long long i = 0; i < m; i++) scanf("%I64d", &aim[i]);
printf("%I64d\n", slove());
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
ll n;
struct ip {
unsigned int addr;
unsigned int mask;
};
string encode_ipv4(ip x) {
string ans;
for (int b = 3; b >= 0; --b) {
ans += to_string((x.addr >> (8 * b)) & 0xff);
if (b > 0)
ans += '.';
else
ans += '/';
}
ans += to_string(x.mask);
return ans;
}
ip parse_ipv4(string ipv4) {
unsigned int token = 0;
bool mask = false;
ip ans = ip{0, 32};
for (char c : ipv4) {
if (c == '.' || c == '/') {
ans.addr <<= 8;
ans.addr |= token;
token = 0;
if (c == '/') {
mask = true;
}
} else {
token *= 10;
token += (c - '0');
}
}
if (mask) {
ans.mask = token;
} else {
ans.addr <<= 8;
ans.addr |= token;
}
return ans;
}
struct node {
node *next[2];
int type;
bool has_allowed_children;
bool has_blocked_children;
};
node *root;
node *new_node() {
node *x = new node;
x->next[0] = nullptr;
x->next[1] = nullptr;
x->type = 0;
x->has_allowed_children = false;
x->has_blocked_children = false;
return x;
}
void add_ipv4(ip y, int type) {
node *x = root;
for (int i = 0; i < y.mask; ++i) {
int d = (y.addr >> (31 - i)) & 1;
if (!x->next[d]) {
x->next[d] = new_node();
}
if (type == 1) {
x->has_allowed_children = true;
}
if (type == 2) {
x->has_blocked_children = true;
}
x = x->next[d];
}
x->type = type;
if (type == 1) {
x->has_allowed_children = true;
}
if (type == 2) {
x->has_blocked_children = true;
}
}
bool validate(node *x) {
if (x == nullptr) return true;
if (x->type == 2 && x->has_allowed_children) return false;
if (x->type == 1 && x->has_blocked_children) return false;
return validate(x->next[0]) && validate(x->next[1]);
}
vector<ip> ans;
void print(node *x, ip y) {
if (x == nullptr) return;
ip y0 = y;
y0.mask++;
ip y1 = y0;
y1.addr |= (1 << (32 - y1.mask));
for (int i = 0; i < y.mask; ++i) cout << ' ';
cout << encode_ipv4(y) << " (" << x->type << ")" << endl;
print(x->next[0], y0);
print(x->next[1], y1);
}
int solve(node *x, ip y) {
if (x == nullptr) return 0;
if (!x->has_blocked_children && !x->has_allowed_children) return 0;
if (x->has_allowed_children && !x->has_blocked_children) return 1;
if (!x->has_allowed_children) return 2;
ip y0 = y;
y0.mask++;
ip y1 = y0;
y1.addr |= (1 << (32 - y1.mask));
int v0 = solve(x->next[0], y0);
int v1 = solve(x->next[1], y1);
if (v0 == 0 && v1 == 0) return 0;
if (v0 != 1 && v1 != 1) return 2;
if (v0 == 1 && v1 == 1) return 1;
if (v0 == 1 && v1 == 2) {
ans.push_back(y1);
}
if (v1 == 1 && v0 == 2) {
ans.push_back(y0);
}
return 1;
}
int main() {
root = new_node();
cin >> n;
for (ll i = 0; i < (ll)n; ++i) {
string s;
cin >> s;
ip x = parse_ipv4(s.substr(1));
if (s[0] == '+') {
add_ipv4(x, 1);
} else {
add_ipv4(x, 2);
}
}
if (!validate(root)) {
cout << -1 << endl;
return 0;
}
int r = solve(root, ip{0, 0});
if (r == 2) {
ans.push_back(ip{0, 0});
}
cout << ans.size() << endl;
for (ip x : ans) {
cout << encode_ipv4(x) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int sum;
int main() {
int n;
cin >> n;
sum += n % 5;
n -= n % 5;
if (n % 10) {
sum++;
n -= 5;
}
n /= 10;
int x = n % 10;
n /= 10;
sum += x / 2 + x % 2;
sum += n;
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int N;
cin >> N;
vector<vector<int>> adj(N);
for (int i = 0; i < N - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<int> depth(N);
vector<int> st(N);
vector<pair<int, int>> inOrder;
inOrder.reserve(2 * N - 1);
function<void(int, int)> dfs = [&](int cur, int prv) {
depth[cur] = (prv == -1 ? 0 : depth[prv]) + 1;
st[cur] = int(inOrder.size());
for (int nxt : adj[cur]) {
if (nxt == prv) continue;
inOrder.emplace_back(depth[cur], cur);
dfs(nxt, cur);
}
inOrder.emplace_back(depth[cur], cur);
};
dfs(0, -1);
assert(int(inOrder.size()) == 2 * N - 1);
const int S = 1 << 19;
vector<pair<int, int>> seg(2 * S);
for (int i = 0; i < int(inOrder.size()); i++) {
seg[i + S] = inOrder[i];
}
for (int i = S - 1; i; i--) {
seg[i] = min(seg[2 * i], seg[2 * i + 1]);
}
assert(0 == st[0]);
auto get_lca = [&](int l, int r) -> int {
if (l > r) swap(l, r);
pair<int, int> res = inOrder[l];
for (int a = l + S, b = r + 1 + S; a < b; a /= 2, b /= 2) {
if (a & 1) res = min(res, seg[a++]);
if (b & 1) res = min(res, seg[--b]);
}
return st[res.second];
};
auto get_distance = [&](int l, int r) -> int {
int lca = get_lca(l, r);
return inOrder[l].first + inOrder[r].first - 2 * inOrder[lca].first;
};
int Q;
cin >> Q;
while (Q--) {
int K, M;
cin >> K >> M;
vector<pair<int, int>> viruses(K);
for (auto& it : viruses) {
cin >> it.first >> it.second;
it.first--;
}
vector<int> queries(M);
for (auto& it : queries) {
cin >> it;
it--;
}
vector<int> allCities;
allCities.reserve(2 * (K + M));
allCities.push_back(0);
for (auto it : viruses) allCities.push_back(st[it.first]);
for (auto it : queries) allCities.push_back(st[it]);
sort(allCities.begin(), allCities.end());
allCities.erase(unique(allCities.begin(), allCities.end()),
allCities.end());
for (int i = int(allCities.size()) - 1; i > 0; i--) {
int l = allCities[i - 1];
int r = allCities[i];
assert(l < r);
int lca = get_lca(l, r);
allCities.push_back(lca);
}
sort(allCities.begin(), allCities.end());
allCities.erase(unique(allCities.begin(), allCities.end()),
allCities.end());
int C = int(allCities.size());
auto compressId = [&](int i) -> int {
auto it = lower_bound(allCities.begin(), allCities.end(), i);
assert(it != allCities.end() && *it == i);
return int(it - allCities.begin());
};
for (auto& it : viruses) {
it.first = compressId(st[it.first]);
}
for (auto& it : queries) {
it = compressId(st[it]);
}
vector<vector<int>> curAdj(C);
for (int i = 0; i + 1 < int(allCities.size()); i++) {
int l = allCities[i];
int r = allCities[i + 1];
assert(l < r);
int lca = compressId(get_lca(l, r));
curAdj[lca].push_back(i + 1);
curAdj[i + 1].push_back(lca);
}
using distVal = pair<pair<int, int>, int>;
priority_queue<distVal, vector<distVal>, greater<distVal>> pq;
vector<pair<int, int>> dist(C, {N + 1, -1});
for (int i = 0; i < int(viruses.size()); i++) {
int v = viruses[i].first;
dist[v] = {0, i};
pq.emplace(dist[v], v);
}
while (!pq.empty()) {
auto pqD = pq.top().first;
int cur = pq.top().second;
pq.pop();
assert(pqD >= dist[cur]);
if (pqD != dist[cur]) continue;
for (int nxt : curAdj[cur]) {
pair<int, int> nd = {(get_distance(allCities[viruses[pqD.second].first],
allCities[nxt]) +
viruses[pqD.second].second - 1) /
viruses[pqD.second].second,
pqD.second};
if (nd < dist[nxt]) {
dist[nxt] = nd;
pq.emplace(nd, nxt);
}
}
}
for (int i = 0; i < int(queries.size()); i++) {
int v = queries[i];
cout << dist[v].second + 1 << " \n"[i + 1 == int(queries.size())];
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string temp, a, b;
cin >> temp;
int limit = temp.find('|');
a = temp.substr(0, limit);
b = temp.substr(limit + 1);
cin >> temp;
for (int i = 0; i < temp.size(); i++) {
if (a.size() <= b.size()) {
a.push_back(temp[i]);
} else
b.push_back(temp[i]);
}
if (a.size() == b.size()) {
cout << a << '|' << b;
} else
cout << "Impossible";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
cout << 2 * x << endl;
}
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef pair<int,int> P;
int main(){
int n;
cin>>n;
vector<P> data;
for(int i=0; i<n; i++) {
int a, v;
cin>>a>>v;
data.push_back(P(-v,a));
}
sort(data.begin(),data.end());
cout<<data[0].second<<" "<<-data[0].first<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long rt = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
rt = rt * 10 + ch - '0';
ch = getchar();
}
return rt;
}
long long n, k, data[200000], f[100030][22], ttt[100050];
void DAC(int qqq, int l, int r, int L, int R, long long sum) {
if (l > r) return;
int mid = (l + r) >> 1, M = -1;
int point = min(mid, R);
for (int i = l; i <= mid; i++) sum += ttt[data[i]]++;
for (int i = L; i <= point; i++) {
sum -= --ttt[data[i]];
if (sum + f[i][qqq - 1] < f[mid][qqq]) {
M = i;
f[mid][qqq] = sum + f[i][qqq - 1];
}
}
for (int i = point; i >= L; i--) sum += ttt[data[i]]++;
for (int i = mid; i >= l; i--) sum -= --ttt[data[i]];
DAC(qqq, l, mid - 1, L, M, sum);
for (int i = l; i <= mid; i++) sum += ttt[data[i]]++;
for (int i = L; i < M; i++) sum -= --ttt[data[i]];
DAC(qqq, mid + 1, r, M, R, sum);
for (int i = mid; i >= l; i--) sum -= --ttt[data[i]];
for (int i = M - 1; i >= L; i--) sum += ttt[data[i]]++;
}
int main() {
n = read();
k = read();
for (int i = 1; i <= n; i++) data[i] = read();
for (int i = 1; i <= n; i++) {
f[i][0] = f[i - 1][0] + (ttt[data[i]]++);
}
for (int i = 1; i < k; i++) {
memset(ttt, 0, sizeof ttt);
for (int j = 0; j <= n; j++) f[j][i] = 0x7fffffffffffffLL;
DAC(i, 1, n, 1, n, 0);
}
cout << f[n][k - 1];
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
int q=0;char ch=' ';
while(ch<'0'||ch>'9') ch=getchar();
while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
return q;
}
const int mod=1e9+7,N=100005;
int n,ans;
int a[N],du[N],cir[N],vis[N],footL[N],sum[N],f[N];
int qm(int x) {return x>=mod?x-mod:x;}
void workcir(int x) {
int now=0,fr=0,ed=0,frL=0;
while(cir[x]) {
++now,cir[x]=0;
if(footL[x]) {
if(!fr) ed=fr=now,frL=footL[x];
else {
int kl=(footL[x]<now-ed)+(footL[x]<=now-ed);
ans=1LL*ans*kl%mod,ed=now;
}
}
x=a[x];
}
if(!fr) ++sum[now];
else {
int kl=(frL<now-ed+fr)+(frL<=now-ed+fr);
ans=1LL*ans*kl%mod;
}
}
void work() {
for(RI i=1;i<=n;++i) {
if(du[i]) continue;
int x=i,len=0;while(!cir[x]) x=a[x],++len;
footL[x]=len;
}
ans=1;
for(RI i=1;i<=n;++i) if(cir[i]) workcir(i);
//cout<<ans<<endl;
for(RI i=1;i<=n;++i) {
if(!sum[i]) continue;
f[0]=1;
for(RI j=1;j<=sum[i];++j) {
if(i>1&&(i&1)) f[j]=qm(f[j-1]+f[j-1]);
else f[j]=f[j-1];
if(j>1) f[j]=qm(f[j]+1LL*f[j-2]*(j-1)%mod*i%mod);
}
ans=1LL*ans*f[sum[i]]%mod;
}
}
int main()
{
n=read();
for(RI i=1;i<=n;++i) a[i]=read(),++du[a[i]];
for(RI i=1;i<=n;++i) {
if(vis[i]) continue;
int x=i;while(!vis[x]) vis[x]=i,x=a[x];
if(vis[x]!=i) continue;
while(!cir[x]) cir[x]=1,x=a[x];
}
for(RI i=1;i<=n;++i)
if((cir[i]&&du[i]>2)||(!cir[i]&&du[i]>1)) {puts("0");return 0;}
work();
printf("%d\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v[2 * 400];
int color[2 * 400];
int bc[2 * 400];
bool dfs(int a, int col) {
color[a] = col;
int num = ((a << 1) | (col));
for (int i = 0; i < v[num].size(); i++) {
int adj = v[num][i] >> 1;
int ncol = ((v[num][i] & 1) ^ 1);
if ((color[adj] == -1 && !dfs(adj, ncol)) ||
(color[adj] != -1 && color[adj] != ncol)) {
color[a] = -1;
return false;
}
}
return true;
}
bool twosat() {
memset(color, -1, sizeof color);
for (int i = 0; i < n; i++) {
if (color[i] == -1) {
memcpy(bc, color, sizeof color);
if (!dfs(i, 0)) {
memcpy(color, bc, sizeof color);
if (!dfs(i, 1)) return false;
}
}
}
return true;
}
int main() {
int m, a, b, c;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b >> c;
--a, --b;
if (c == 1) {
v[(a << 1)].push_back(((b << 1) ^ 1));
v[((b << 1) ^ 1)].push_back((a << 1));
v[(b << 1)].push_back(((a << 1) ^ 1));
v[((a << 1) ^ 1)].push_back((b << 1));
} else {
v[(a << 1)].push_back((b << 1));
v[(b << 1)].push_back((a << 1));
v[((b << 1) ^ 1)].push_back(((a << 1) ^ 1));
v[((a << 1) ^ 1)].push_back(((b << 1) ^ 1));
}
}
if (twosat()) {
int cnt = 0;
for (int i = 0; i < n; ++i)
if (color[i] == 0) ++cnt;
cout << cnt << endl;
for (int i = 0; i < n; ++i)
if (color[i] == 0) cout << i + 1 << " ";
cout << endl;
} else {
cout << "Impossible" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N |= (1LL << pos); }
int Reset(int N, int pos) { return N &= ~(1LL << pos); }
bool Check(int N, int pos) { return N & (1LL << pos); }
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1}, dy[] = {1, -1, 0, 0, 1, -1, -1, 1};
inline void cn(long &n) {
n = 0;
long ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
n = n * sign;
}
template <class T>
void cmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void cmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
int len(const T &c) {
return (int)c.size();
}
template <class T>
int len(char c[]) {
return (int)strlen(c);
}
long stoi(string s) {
long n = 0;
for (int i(0), _n(len(s)); i < _n; ++i) n = n * 10 + (s[i] - 48);
return n;
}
long n, m, f, ar[100005] = {0}, flag = 0, flag1 = 0, res[100005] = {0},
pos[100005], b;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i(1), _n(n); i <= _n; ++i) {
cin >> f;
ar[f]++;
pos[f] = i;
}
for (int i(0), _n(m); i < _n; ++i) {
cin >> b;
if (ar[b] == 0) flag = 1;
if (ar[b] > 1) flag1 = 1;
res[i] = pos[b];
}
if (flag == 1)
cout << "Impossible\n";
else if (flag1 == 1)
cout << "Ambiguity\n";
else {
cout << "Possible\n";
for (int i(0), _n(m); i < _n; ++i) cout << res[i] << " ";
}
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
using namespace std;
static const int N = 100;
int main() {
int n, p[N + 1], m[N + 1][N + 1];
cin >> n;
for ( int i = 1; i <= n; i++ ) {
cin >> p[i - 1] >> p[i];
}
for ( int i = 0; i <= n; i++ ) m[i][i] = 0;
for ( int l = 2; l <= n; l++ ) {
for ( int i = 1; i <= n - l + 1; i++ ) {
int j = i + l - 1;
m[i][j] = (1 << 21);
for ( int k = i; k <= j - 1; k++ ) {
m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
}
}
}
cout << m[1][n] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 201000;
vector<int> vec, chain, e[N];
vector<vector<int> > ret, vc;
int q[N], f[N], vis[N], sz[N], ms[N];
int deg[N];
int n, u, v;
vector<int> find(int u) {
int t = 1;
q[0] = u;
f[u] = -1;
vector<int> res;
for (int i = 0; i < t; i++) {
u = q[i];
for (int j = 0; j < e[u].size(); j++) {
int v = e[u][j];
if (v != f[u]) f[q[t++] = v] = u;
}
ms[q[i]] = 0;
sz[q[i]] = 1;
}
for (int i = t - 1; i >= 0; i--) {
ms[q[i]] = max(ms[q[i]], t - sz[q[i]]);
if (ms[q[i]] * 2 <= t) res.push_back(q[i]);
sz[f[q[i]]] += sz[q[i]];
ms[f[q[i]]] = max(ms[f[q[i]]], sz[q[i]]);
}
return res;
}
void dfs(int u, int f) {
vec.push_back(u);
for (auto v : e[u])
if (v != f) dfs(v, u);
}
void oper(int u, int v, int w) { ret.push_back(vector<int>{u, v, w}); }
void gao(int u, int f) {
vec.clear();
chain.clear();
dfs(u, f);
chain.clear();
for (auto v : vec) deg[v] = ((int)(e[v]).size());
int t = 0;
for (auto v : vec)
if (deg[v] == 1) {
q[t++] = v;
}
chain.push_back(f);
vis[f] = 1;
int prev = f, prel = u;
for (int i = 0; i < t; i++) {
chain.push_back(q[i]);
vis[q[i]] = 1;
oper(prev, prel, q[i]);
--deg[prel];
if (deg[prel] == 1) {
q[t++] = prel;
assert(!vis[prel]);
}
prev = q[i];
prel = -1;
for (auto v : e[q[i]]) {
if (vis[v] == 0) prel = v;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
auto r = find(1);
if (((int)(r).size()) == 1) {
u = r[0];
for (auto v : e[u]) {
gao(v, u);
vc.push_back(chain);
}
} else {
u = r[0];
v = r[1];
for (auto w : e[u])
if (w != v) {
gao(w, u);
vc.push_back(chain);
}
for (auto w : e[v])
if (w != u) {
gao(w, v);
vc.push_back(chain);
}
}
for (auto p : vc) {
chain = p;
if (((int)(chain).size()) > 3) {
int mr = chain[((int)(chain).size()) - 2];
for (int i = ((int)(chain).size()) - 3 - 1; i >= 0; i--) {
oper(chain[i], chain[i + 1], mr);
}
}
}
printf("%d\n", ((int)(ret).size()));
for (auto p : ret) {
printf("%d %d %d\n", p[0], p[1], p[2]);
}
}
| 3 |
#include <bits/stdc++.h>
const long double EPS = 1e-10;
const long long int MOD = 1000000007ll;
const long long int mod1 = 1000000009ll;
const long long int mod2 = 1100000009ll;
int INF = 2147483645;
long long int INFINF = 9223372036854775807;
int debug = 0;
using namespace std;
long long int bit_count(long long int _x) {
long long int _ret = 0;
while (_x) {
if (_x % 2 == 1) _ret++;
_x /= 2;
}
return _ret;
}
long long int bit(long long int _mask, long long int _i) {
return (_mask & (1 << _i)) == 0 ? 0 : 1;
}
long long int powermod(long long int _a, long long int _b, long long int _m) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a) % _m;
_b /= 2;
_a = (_a * _a) % _m;
}
return _r;
}
long long int add(long long int a, long long int b) {
long long int x = a + b;
while (x >= MOD) x -= MOD;
return x;
}
long long int sub(long long int a, long long int b) {
long long int x = a - b;
while (x < 0) x += MOD;
return x;
}
long long int mul(long long int a, long long int b) {
long long int x = a * b;
x %= MOD;
return x;
}
const int N = 500010;
vector<int> G[N], temp;
int n;
void dfs(int u, int p, int d) {
int childcnt = 0;
for (int v : G[u]) {
if (v != p) {
dfs(v, u, d + 1);
childcnt++;
}
}
if (childcnt == 0) temp.push_back(d);
}
int main() {
srand(time(NULL));
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
G[u].push_back(v);
G[v].push_back(u);
}
int ans = -1;
for (int v : G[1]) {
temp.clear();
dfs(v, 1, 1);
sort(temp.begin(), temp.end());
for (int i = 1; i < temp.size(); i++) {
if (temp[i] <= temp[i - 1]) temp[i] = temp[i - 1] + 1;
}
ans = max(ans, temp[temp.size() - 1]);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long n, m, i, r, x, y, j, t;
scanf("%I64d", &n);
m = n / 3;
double sq1 = sqrt(m);
long long sq = (long long)sq1;
x = sq + 1;
x *= 3;
x *= sq;
if (x > n) sq--;
i = sq + 1;
i *= 3;
i *= sq;
if (i == n) {
x = 2 * sq;
y = 0;
} else {
t = sq + 1;
if (n < i + t) {
y = 2;
x = 1 + 2 * sq;
j = n - i - 1;
x -= j;
y += 2 * j;
} else if (n < i + 2 * t) {
y = 2 * t;
x = t;
j = n - i - t;
x -= 2 * j;
} else if (n < i + 3 * t) {
y = 2 * t;
x = -t;
j = n - i - 2 * t;
x -= j;
y -= 2 * j;
} else if (n < i + 4 * t) {
y = 0;
x = -2 * t;
j = n - i - 3 * t;
x += j;
y -= 2 * j;
} else if (n < i + 5 * t) {
y = -2 * t;
x = -t;
j = n - i - 4 * t;
x += 2 * j;
} else {
y = -2 * t;
x = t;
j = n - i - 5 * t;
x += j;
y += 2 * j;
}
}
printf("%I64d %I64d", x, y);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
const long long int mod = 998244353ll;
const long double eps = 1e-8;
long long int gcd(long long int a, long long int b, long long int& x,
long long int& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long int x1, y1;
long long int d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long int rev(long long int a, long long int m) {
long long int x, y;
long long int g = gcd(a, m, x, y);
if (g != 1) {
throw g;
}
return (x % m + m) % m;
}
long long int n, k;
vector<pair<long long int, long long int>> a;
vector<long long int> f;
void fillf() {
f = vector<long long int>(n + 1);
f[0] = 1;
for (long long int i = 1; i <= n; i++) {
f[i] = f[i - 1] * i;
f[i] %= mod;
}
}
long long int cnk(long long int n, long long int k) {
long long int fn = f[n];
long long int fk = f[k];
long long int fnk = f[n - k];
long long int R = fn;
R *= rev(fk, mod);
R %= mod;
R *= rev(fnk, mod);
R %= mod;
return R;
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(15);
cout.setf(ios::fixed);
cin >> n >> k;
a = vector<pair<long long int, long long int>>(n + 1);
for (long long int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
}
fillf();
map<long long int, vector<long long int>> q;
for (long long int i = 1; i <= n; i++) {
q[a[i].first].push_back(i);
q[a[i].second + 1].push_back(i);
}
long long int R = 0;
set<long long int> z;
for (auto t : q) {
long long int nc = 0;
for (auto u : t.second) {
if (!z.count(u)) {
z.insert(u);
nc += 1;
} else {
z.erase(u);
}
}
long long int n = z.size();
long long int old = n - nc;
if (n >= k) {
long long int t = cnk(n, k);
long long int m = old >= k ? cnk(old, k) : 0;
t = (t - m + mod) % mod;
R += t;
R %= mod;
}
}
cout << R << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
vector<long long> v;
long long n;
cin >> n;
long long i, j;
long long sume = 0, sumo = 0;
for (i = 1; i <= n / 2; i++) {
sume = sume + i * 2;
v.push_back(i * 2);
}
j = 1;
for (i = 1; i <= n / 2; i++) {
sumo = sumo + (j);
v.push_back(j);
j = j + 2;
}
j = j - 2;
bool flag = 0;
if (sume > sumo) {
long long diff = sume - sumo;
if ((diff + j) % 2 != 0) {
flag = 1;
v[n - 1] = diff + j;
}
} else if (sume == sumo)
flag = 1;
if (flag == 1) {
cout << "YES" << endl;
for (i = 0; i < n; i++) cout << v[i] << " ";
cout << endl;
} else
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[500];
cin.getline(a, 500);
int d = strlen(a), br = 0, q = 0, b = 0, mx = 0, mx1 = 0;
for (int i = 0; i < d; i++) {
if (a[i] == '-') b--;
if (a[i] == '+') b++;
if (mx < b * -1) mx = b * -1;
if (b > mx1) mx1 = b;
}
cout << mx + mx1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
char a[maxn], b[maxn];
const int INF = 0x3f3f3f3f;
int main() {
int n;
cin >> n;
cin >> a >> b;
int k = 0;
int l = INF, r = 0;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
l = min(l, i);
r = max(r, i);
}
}
int a1 = 1, a2 = 1;
for (int i = l + 1; i <= r; i++) {
if (a[i] != b[i - 1]) a1 = 0;
if (b[i] != a[i - 1]) a2 = 0;
}
cout << a1 + a2 << endl;
}
| 5 |
#include<iostream>
#include<algorithm>
#include<functional>
using namespace std;
int main(){
int n, m;
int place[110];
int array[110];
int input;
bool isStart = true;
while(cin >> n >> m, n || m){
isStart = true;
for(int i=0; i < 110; i++){
place[i] = 0;
array[i] = 0;
}
for(int i=0; i < n; i++){
for(int j=0; j < m; j++){
cin >> input;
if(input){
place[j]++;
array[j]++;
}
}
}
sort(array, array+m, greater<int>());
for(int i=0; i < m; i++){
for(int j=0; j < m; j++){
if(array[i] == place[j]){
if(isStart) isStart = false;
else cout << " ";
cout << j+1;
place[j] += 100000;
}
}
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
char s[100005];
unsigned int f[100005];
int main() {
int n = read();
if (n & 1) {
cout << 0;
return 0;
}
scanf("%s", s + 1);
int cnt = 0;
f[0] = 1;
for (int i = 1; i <= n; ++i) {
if (s[i] == '?')
for (int j = (i >> 1); j && j >= (i - n / 2); --j) f[j] += f[j - 1];
else
cnt++;
}
unsigned int ans = f[n / 2];
for (int i = 1; i <= (n / 2 - cnt); ++i) ans = ans * 25;
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll a, b;
cin >> a >> b;
ll cx = 0;
while (a) {
if (a > b) {
swap(a, b);
continue;
}
cx += b / a;
b %= a;
}
cout << cx << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long fact(long long n) {
long long ans = 1;
for (long long i = 1; i <= n; i++) {
ans *= i;
}
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T;
cin >> T;
for (long long tp = 1; tp <= T; ++tp) {
long long n, m, x, y;
cin >> n >> m >> x >> y;
long long mat[n][m];
for (long long i = 0; i < n; ++i) {
string s;
cin >> s;
for (long long j = 0; j < m; ++j) {
if (s[j] == '*')
mat[i][j] = 0;
else
mat[i][j] = 1;
}
}
long long ans = 0;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
if (mat[i][j] == 1) {
if (j + 1 < m and mat[i][j + 1] == 1) {
ans += min(2 * x, y);
mat[i][j] = mat[i][j + 1] = 0;
} else {
ans += x;
mat[i][j] = 0;
}
}
}
}
cout << ans;
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b;
cin >> a >> b;
cout << a-1 + (a<=b?1:0) << endl;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.