solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
map<int, int> M;
long long result = 0;
int n, a;
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
for (int j = 0; j < 31; ++j) {
int sucht = (1 << j) - a;
result += M[sucht];
}
M[a]++;
}
cout << result << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int l, r, d;
cin >> l >> r >> d;
if (d == 1) {
if (l > 1)
cout << 1;
else
cout << r + 1;
cout << endl;
continue;
}
int p = l / d;
int q = r / d;
if ((p == 1) && (l % d != 0))
cout << d;
else if (p > 1)
cout << d;
else
cout << (q + 1) * d;
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b;
c = a + b;
int Max = 0, A = 0, B = 0, sum, system;
for (int i = 0; i < c.length(); ++i) {
if (static_cast<int>(c[i]) - static_cast<int>('0') > Max)
Max = static_cast<int>(c[i]) - static_cast<int>('0');
}
system = Max + 1;
vector<int> x;
vector<int> y;
int p = 0;
for (int i = a.length() - 1; i >= 0; --i) {
x.push_back((static_cast<int>(a[i]) - static_cast<int>('0')) *
pow(system, p));
A = A + x[p];
++p;
}
p = 0;
for (int i = b.length() - 1; i >= 0; --i) {
y.push_back((static_cast<int>(b[i]) - static_cast<int>('0')) *
pow(system, p));
B = B + y[p];
++p;
}
sum = A + B;
vector<int> v;
for (;;) {
v.push_back(sum % system);
if (sum % system == sum) break;
sum = sum / system;
}
cout << v.size();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[1000007];
long long int freq[1000007];
int main() {
long long int n, i, flag = 0, maxi = -88, ans, index, curr;
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
maxi = max(maxi, arr[i]);
}
sort(arr, arr + n);
curr = 1;
for (i = 0; i < n; i++) {
if (arr[i] >= curr) curr++;
}
cout << curr;
}
| 2 |
#include <bits/stdc++.h>
int main(void) {
int k2, k3, k5, k6;
scanf("%d %d %d %d", &k2, &k3, &k5, &k6);
int max_256 = 0;
if (k5 > k6) {
max_256 = k6;
} else {
max_256 = k5;
}
if (max_256 > k2) {
max_256 = k2;
}
k2 -= max_256;
int max_32 = 0;
if (k2 > k3) {
max_32 = k3;
} else {
max_32 = k2;
}
printf("%d", max_256 * 256 + max_32 * 32);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int inf = 0x3f3f3f3f;
struct node {
int to, next, w, c;
} num[N * 10];
queue<int> q;
int cnt = 1, sc, S, T, dis[N], head[N], n, a[N], c[N], ans, k, pre[N], prevv[N],
preve[N], t[1000005];
void add(int x, int y, int w, int c) {
num[++cnt].to = y;
num[cnt].next = head[x];
num[cnt].w = w;
num[cnt].c = c;
head[x] = cnt;
num[++cnt].to = x;
num[cnt].next = head[y];
num[cnt].w = -w;
num[cnt].c = 0;
head[y] = cnt;
}
void build() {
for (int i = 1; i < n; i++) add(i, i + 1, 0, k - 1);
for (int i = 1; i <= n; i++)
if (pre[i] && pre[i] != i - 1) {
add(S, pre[i] + 1, 0, 1);
add(pre[i] + 1, ++sc, 0, 1);
add(i, sc, -c[a[i]], 1);
add(sc, T, 0, 1);
}
}
void spfa() {
q.push(S);
memset(dis, inf, sizeof(dis));
dis[S] = 0;
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = head[now]; i; i = num[i].next)
if (num[i].c && dis[num[i].to] > dis[now] + num[i].w) {
dis[num[i].to] = dis[now] + num[i].w, q.push(num[i].to);
prevv[num[i].to] = now;
preve[num[i].to] = i;
}
}
}
void solve() {
while (1 == 1) {
spfa();
if (dis[T] == inf) break;
int sum = 0;
for (int i = T, it; i != S; i = prevv[i])
it = preve[i], sum += num[it].w, num[it].c--, num[it ^ 1].c++;
ans += sum;
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) {
pre[i] = t[a[i]];
t[a[i]] = i;
if (i == 1 || pre[i] != i - 1) ans += c[a[i]];
}
S = n + 1;
T = sc = S + 1;
build();
solve();
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x, l;
cin >> n;
for (i = 0; i < n / 2; i++) {
l = (i + 1) * 2 - 1;
for (x = 0; x < (n - l) / 2; x++) cout << '*';
for (x = 0; x < l; x++) cout << 'D';
for (x = 0; x < (n - l) / 2; x++) cout << '*';
cout << endl;
}
for (i = 0; i < n; i++) cout << 'D';
for (i = 0; i < n / 2; i++) {
cout << endl;
l = (n / 2 - i) * 2 - 1;
for (x = 0; x < (n - l) / 2; x++) cout << '*';
for (x = 0; x < l; x++) cout << 'D';
for (x = 0; x < (n - l) / 2; x++) cout << '*';
}
}
| 0 |
#include <bits/stdc++.h>
int N, S;
int x[102];
int y[102];
int c[102];
int max(int a, int b) { return a > b ? a : b; }
int main() {
scanf("%d %d", &N, &S);
S *= 100;
for (int i = 1; i <= N; i++) scanf("%d %d", &x[i], &y[i]);
for (int i = 1; i <= N; i++) c[i] = x[i] * 100 + y[i];
int mx = -1;
for (int i = 1; i <= N; i++) {
if (S >= c[i]) {
mx = max(mx, (S - c[i]) % 100);
}
}
printf("%d\n", mx);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string str[] = {"Anka", "Chapay", "Cleo", "Troll",
"Dracul", "Snowy", "Hexadecimal"};
int n;
int mp[7][7];
vector<int> vc;
int sz[100000];
void divide() {
int t = 2;
for (int i = 1; i <= 6; i++) t *= 2;
sz[0] = 0;
for (int i = 1; i <= t; i++) {
sz[i] = sz[i >> 1] + (i & 1);
}
for (int i = 1; i < t; i++) {
int j = t - 1 - i;
if (j < i) break;
for (int x = ((j - 1) & j); x; x = ((x - 1) & j)) {
int y = j - x;
int z = x;
if (y > z) swap(y, z);
if (y > i) {
vc.push_back(i);
vc.push_back(y);
vc.push_back(z);
}
}
}
}
long long ans, ans2;
long long ask(long long a, long long b, long long c) {
long long ma = a;
if (ma < b) ma = b;
if (ma < c) ma = c;
long long mi = a;
if (mi > b) mi = b;
if (mi > c) mi = c;
return ma - mi;
}
int aask[1 << 7];
void update(int x, int y, int z, int a, int b, int c) {
long long at = ask(a / sz[x], b / sz[y], c / sz[z]);
long long at2 = aask[x] + aask[y] + aask[z];
if (at < ans) {
ans = at;
ans2 = at2;
} else if (at == ans) {
if (ans2 < at2) ans2 = at2;
}
}
void diao() {
aask[0] = 0;
int t = 1 << 7;
for (int i = 1; i < t; i++) {
aask[i] = 0;
for (int j = 0; j < 7; j++) {
if (i & (1 << j)) {
for (int k = 0; k < 7; k++) {
if (i & (1 << k)) {
if (mp[j][k]) aask[i]++;
}
}
}
}
}
}
int main(void) {
vc.clear();
divide();
while (scanf("%d", &n) == 1) {
memset(mp, 0, sizeof(mp));
for (int i = 0; i < n; i++) {
string a, b, c;
cin >> a >> b >> c;
int ii, j;
for (ii = 0; ii < 7; ii++)
if (a == str[ii]) break;
for (j = 0; j < 7; j++)
if (c == str[j]) break;
mp[ii][j]++;
}
diao();
int a, b, c;
cin >> a >> b >> c;
ans = 1000000000000000LL, ans2 = 0;
for (int i = 0; i < vc.size(); i += 3) {
int x = vc[i], y = vc[i + 1], z = vc[i + 2];
update(x, y, z, a, b, c);
update(x, y, z, a, c, b);
update(x, y, z, b, a, c);
update(x, y, z, b, c, a);
update(x, y, z, c, a, b);
update(x, y, z, c, b, a);
}
cout << ans << " " << ans2 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
int x[1000010], y[1000010];
bool used[1000010];
struct fhq_Treap {
struct T {
int lc;
int rc;
int v;
int w;
int size;
} t[2000010];
int root = 0;
int cnt = 0;
int cc = 0;
void push_up(int cur) {
t[cur].size = t[t[cur].lc].size + t[t[cur].rc].size + 1;
}
void split(int cur, int &a, int &b, int k) {
if (!cur) {
a = b = 0;
return;
}
if (t[t[cur].lc].size >= k) {
b = cur;
split(t[cur].lc, a, t[b].lc, k);
push_up(b);
} else {
a = cur;
split(t[cur].rc, t[a].rc, b, k - t[t[cur].lc].size - 1);
push_up(a);
}
}
int merge(int a, int b) {
if (!a || !b) return a + b;
if (t[a].w < t[b].w) {
t[a].rc = merge(t[a].rc, b);
push_up(a);
return a;
} else {
t[b].lc = merge(a, t[b].lc);
push_up(b);
return b;
}
}
int begin() {
int cur = root;
while (t[cur].lc) cur = t[cur].lc;
return t[cur].v;
}
void erase() {
int x;
split(root, x, root, 1);
}
void insert(int x, int pos) {
int l, r;
split(root, l, r, pos - 1);
t[++cnt] = (T){0, 0, x, rand(), 1};
root = merge(merge(l, cnt), r);
}
void print(int cur) {
if (cur == 0) return;
print(t[cur].lc);
if (!t[cur].v) {
cc++;
while (used[cc]) cc++;
}
printf("%d ", t[cur].v ? t[cur].v : cc);
print(t[cur].rc);
}
} t;
int main() {
int n = inp();
int m = inp();
for (int i = 1; i <= n; i++) t.insert(0, i);
for (int i = 1; i <= m; i++) {
x[i] = inp();
y[i] = inp();
}
for (int i = m; i >= 1; i--) {
int st = t.begin();
if ((used[x[i]] && st != x[i]) || (st != x[i] && st != 0)) {
printf("-1\n");
return 0;
}
t.erase();
t.insert(x[i], y[i]);
used[x[i]] = true;
}
t.print(t.root);
putchar('\n');
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<string> grid(2);
cin >> grid[0] >> grid[1];
vector<vector<int>> ccId(2, vector<int>(n, -1));
int id = 1;
const vector<int> di = {1, -1, 0, 0};
const vector<int> dj = {0, 0, 1, -1};
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < n; ++j) {
if (ccId[i][j] != -1) continue;
if (grid[i][j] == 'X') continue;
queue<pair<int, int>> q;
q.push({i, j});
ccId[i][j] = id;
while (!q.empty()) {
const int nodeI = q.front().first;
const int nodeJ = q.front().second;
q.pop();
for (int k = 0; k < 4; ++k) {
const int toI = nodeI + di[k];
const int toJ = nodeJ + dj[k];
if (toI < 0 || toI >= 2 || toJ < 0 || toJ >= n) continue;
if (grid[toI][toJ] == 'X') continue;
if (ccId[toI][toJ] != -1) continue;
ccId[toI][toJ] = id;
q.push({toI, toJ});
}
}
++id;
}
}
vector<vector<int>> next(2, vector<int>(n, 0));
vector<vector<int>> dp(17, vector<int>(2 * n + 3, 2 * n - 1));
for (int i = 0; i < 2; ++i) {
for (int j = n - 1; j >= 0; --j) {
if (grid[i][j] == 'X') continue;
if (j + 1 < n && grid[i][j + 1] == '.') {
next[i][j] = next[i][j + 1];
} else {
next[i][j] = j;
}
dp[0][i * n + j] = (i ^ 1) * n + next[i][j];
}
}
for (int lg = 1; lg < (int)dp.size(); ++lg) {
for (int node = 0; node < n + n; ++node) {
dp[lg][node] = dp[lg - 1][dp[lg - 1][node]];
}
}
while (m--) {
int start, end;
cin >> start >> end;
--start, --end;
int startRow = start / n;
int startCol = start % n;
int endRow = end / n;
int endCol = end % n;
if (ccId[startRow][startCol] != ccId[endRow][endCol]) {
cout << -1 << '\n';
continue;
}
if (startCol > endCol) {
swap(startRow, endRow);
swap(startCol, endCol);
}
int res = endCol - startCol;
int sum = 0;
int node = startRow * n + startCol;
for (int lg = (int)dp.size() - 1; lg >= 0; --lg) {
const int currDp = dp[lg][node];
if (currDp % n >= endCol) continue;
sum += (1 << lg);
node = currDp;
}
++sum;
res += sum;
node = startRow * n + startCol;
for (int lg = 0; lg < (int)dp.size(); ++lg) {
if (sum & (1 << lg)) {
node = dp[lg][node];
}
}
if ((startRow ^ (sum % 2)) == endRow) ++res;
cout << res - 1 << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T inline sqr(T x) {
return x * x;
}
template <class T>
inline T myAbs(T a) {
return a > 0 ? a : -a;
}
map<int, int> use;
int main() {
int n, b;
vector<int> a;
cin >> n >> b;
a.resize(n);
for (int i = 0; i < (int)(n); ++i) {
scanf("%d", &a[i]);
}
int res = b;
int sum = 0;
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(n); ++j) {
if (i == j) continue;
if (i < j) res = max(res, (b / a[i]) * a[j] + b % a[i]);
}
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T>
using v = vector<T>;
const long long inf = 4611686018427387903;
void read() {}
template <typename Arg, typename... Args>
void read(Arg& arg, Args&... args) {
cin >> (arg);
read(args...);
}
void print() {}
template <typename Arg, typename... Args>
void print(Arg arg, Args... args) {
cout << (arg) << " ";
print(args...);
}
void debug() { cout << endl; }
template <typename Arg, typename... Args>
void debug(Arg arg, Args... args) {
cout << (arg) << " ";
debug(args...);
}
long long getInt() {
long long a;
cin >> a;
return a;
}
void run() {
long long n, x1, x2;
read(n, x1, x2);
pair<long long, long long> c[n];
for (long long i = (0); i < (n); i++) {
long long a;
cin >> a;
c[i] = {a, i + 1};
}
sort(c, c + n);
v<pair<long long, long long>> seg1, seg2;
long long l = 0;
for (long long l = (0); l < (n); l++) {
long long v = c[l].first;
long long d = x1 / v;
if (d * v < x1) d++;
if (l + d - 1 >= n)
continue;
else
seg1.push_back({l, l + d - 1});
}
for (long long l = (0); l < (n); l++) {
long long v = c[l].first;
long long d = x2 / v;
if (d * v < x2) d++;
if (l + d - 1 >= n)
continue;
else
seg2.push_back({l, l + d - 1});
}
sort(seg1.begin(), seg1.end());
sort(seg2.begin(), seg2.end());
long long ans1 = -1, ans2;
for (long long i = (0); i < (((long long)(seg1).size())); i++) {
if (seg1.empty() || seg2.empty()) break;
if (seg1[i].second < seg2.back().first) {
ans1 = i;
ans2 = ((long long)(seg2).size()) - 1;
break;
}
}
for (long long i = (0); i < (((long long)(seg2).size())); i++) {
if (seg1.empty() || seg2.empty()) break;
if (seg2[i].second < seg1.back().first) {
ans1 = ((long long)(seg1).size()) - 1;
ans2 = i;
break;
}
}
if (ans1 == -1)
cout << "No";
else {
cout << "Yes";
cout << endl;
vector<long long> res1, res2;
for (long long i = (seg1[ans1].first); i < (seg1[ans1].second + 1); i++)
res1.push_back(c[i].second);
for (long long i = (seg2[ans2].first); i < (seg2[ans2].second + 1); i++)
res2.push_back(c[i].second);
print(((long long)(res1).size()), ((long long)(res2).size()));
cout << endl;
for (long long i : res1) print(i);
cout << endl;
for (long long i : res2) print(i);
cout << endl;
}
}
int32_t main() {
srand(time(0));
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
run();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
istream& operator>>(istream& is, vector<T>& vec) {
for (auto& v : vec) is >> v;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[ ";
for (int i = 0; i < v.size(); ++i) {
os << v[i];
if (i != v.size() - 1) os << ", ";
}
os << " ]\n";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[ ";
for (auto it : v) {
os << it;
if (it != *v.rbegin()) os << ", ";
}
os << " ]\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const map<T, S>& v) {
os << "{ ";
for (auto it : v) os << it.first << " : " << it.second << ", ";
os << " }\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << "(";
os << v.first << ", " << v.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, priority_queue<T> p) {
os << "[ ";
while (!p.empty()) {
os << p.top() << " ,";
p.pop();
}
os << " ]\n";
return os;
}
inline long long pmod(long long i, long long n) { return (i % n + n) % n; }
const long long INF = 1e18;
const long long mod = 1e9 + 7;
void solve() {
long long l, r;
cin >> l >> r;
long long x, y;
if (r & 1) {
if ((r - 1) / 2 >= l) {
cout << (r - 1) / 2 << ' ' << r - 1;
} else
cout << "-1 -1";
return;
}
if (r / 2 >= l) {
cout << r / 2 << ' ' << r;
} else
cout << "-1 -1";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
for (int t1 = 1; t1 <= t; ++t1) {
solve();
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<pair<int, int>>> node;
vector<int> par;
map<pair<int, int>, int> mp;
void process() {
int v = n;
vector<pair<int, pair<int, int>>> vec;
while (v != 1) {
int u = par[v];
if (!mp[{u, v}]) vec.push_back({u, {v, 1}});
mp.erase({u, v});
mp.erase({v, u});
v = par[v];
}
map<pair<int, int>, bool> visited;
for (auto it : mp) {
if (visited[{it.first.second, it.first.first}]) continue;
visited[{it.first.second, it.first.first}] = true;
visited[{it.first.first, it.first.second}] = true;
if (it.second) vec.push_back({it.first.first, {it.first.second, 0}});
}
cout << ((int)((vec).size())) << '\n';
for (auto i : vec)
cout << i.first << " " << i.second.first << " " << i.second.second << '\n';
}
void dijkstra() {
vector<int> dist(n + 1, -1);
set<pair<pair<int, int>, pair<int, int>>> st;
st.insert({{0, 0}, {1, 0}});
while (!st.empty()) {
auto it = *st.begin();
int cost = it.first.first;
int bayez = it.first.second;
int v = it.second.first;
int p = it.second.second;
st.erase(st.begin());
if (dist[v] != -1) continue;
par[v] = p;
dist[v] = cost;
if (v == n) {
process();
exit(0);
}
for (auto i : node[v]) {
if (dist[i.first] == -1)
st.insert({{cost + 1, bayez + !i.second}, {i.first, v}});
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
node = vector<vector<pair<int, int>>>(n + 1);
par = vector<int>(n + 1, -1);
while (m--) {
int u, v, c;
cin >> u >> v >> c;
mp[{u, v}] = mp[{v, u}] = c;
node[u].push_back({v, c});
node[v].push_back({u, c});
}
dijkstra();
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int maxn = 1e6 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long k, d, t;
cin >> k >> d >> t;
t <<= 1;
long double ans = 0;
long long ta = 0, tb = 0;
if (d >= k)
ta = k * 2LL, tb = d - k;
else
ta = k * 2LL, tb = d - k % d;
if (k % d == 0) tb = 0;
long long num = t / (ta + tb);
ans += num * (k + tb);
t = t % (ta + tb);
if (t <= ta)
ans += (long double)t / 2;
else
ans += k + (t - ta);
cout << setprecision(15) << setiosflags(ios::fixed) << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(228);
long long mod = 1e9 + 7;
long long pw(long long x, long long st) {
if (st == 0) return 1;
if (st % 2 == 0) {
long long y = pw(x, st / 2);
return (y * y) % mod;
}
return (pw(x, st - 1) * x) % mod;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, p;
cin >> n >> p;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
if (p == 1) {
cout << (n % 2) << '\n';
continue;
}
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
vector<pair<long long, long long>> s;
long long flag = -1;
for (long long i = 0; i < n; i++) {
if (flag != -1) {
if ((long long)s.size() > 0 && s[0].first == flag) {
s.clear();
flag = -1;
}
}
if (flag == -1) {
flag = a[i];
continue;
}
long long cnt = 1, st = a[i];
while ((long long)s.size() > 0) {
if (s.back().first == st) {
cnt += s.back().second;
s.pop_back();
if (cnt == p) {
cnt = 1, st++;
continue;
}
s.push_back({st, cnt});
break;
}
s.push_back({st, cnt});
break;
}
if ((long long)s.size() == 0) s.push_back({st, cnt});
}
if (flag != -1) {
if ((long long)s.size() > 0 && s[0].first == flag) {
s.clear();
flag = -1;
}
}
if (flag == -1) {
cout << 0 << '\n';
continue;
}
long long ans = pw(p, flag);
for (auto x : s) {
ans = (ans + mod - (pw(p, x.first) * x.second) % mod + mod) % mod;
}
cout << ans << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m, a, b, now;
cin >> n >> m;
vector<vector<int>> gr(n);
for (int i = 0; i < m; ++i) {
cin >> a >> b;
--a;
--b;
gr[a].push_back(b);
gr[b].push_back(a);
}
vector<int> used(n, 0);
long long ans = 1;
for (int i = 0; i < n; ++i) {
if (used[i] == 0) {
used[i] = 1;
now = 1;
vector<int> qq;
for (int j = 0; j < gr[i].size(); ++j) {
if (used[gr[i][j]] == 0) {
used[gr[i][j]] = 1;
qq.push_back(gr[i][j]);
++now;
}
}
while (qq.size() > 0) {
vector<int> q;
for (int j = 0; j < qq.size(); ++j) {
for (int h = 0; h < gr[qq[j]].size(); ++h) {
if (used[gr[qq[j]][h]] == 0) {
used[gr[qq[j]][h]] = 1;
q.push_back(gr[qq[j]][h]);
++now;
}
}
}
qq = q;
}
for (int j = 1; j < now; ++j) {
ans *= 2;
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
void fre() {
system("clear"), freopen("A.txt", "r", stdin);
freopen("Ans.txt", "w", stdout);
}
void Fre() { system("clear"), freopen("A.txt", "r", stdin); }
void Run(int x = 0) {}
using namespace std;
vector<long long> ar;
int main() {
Run();
long long T;
scanf("%lld", &T);
while (T--) {
ar.clear();
long long n, t = 0;
scanf("%lld", &n);
for (long long i = (long long)(4 * n); i >= (long long)(1); i--) {
if (i % 2) continue;
long long flag = 1;
for (long long j = (long long)(0); j <= (long long)(ar.size() * 1LL - 1);
j++) {
if (ar[j] % i == 0) flag = 0;
}
if (flag) {
ar.push_back(i);
t++;
if (t == n) break;
}
}
for (auto x : ar) printf("%lld ", x);
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[15];
char sub[15];
char ans[15];
int n;
void generate_sub(int x) {
int counter = 0;
for (int i = 0; i < n; ++i)
if (x & (1 << i)) sub[counter++] = s[i];
sub[counter] = 0;
}
bool pal() {
int i = 0, j = strlen(sub) - 1;
while (i <= j) {
if (sub[i] != sub[j]) return false;
++i;
--j;
}
return true;
}
int main(void) {
scanf("%s", s);
n = strlen(s);
ans[0] = 0;
for (int i = 0; i < (1 << n); ++i) {
generate_sub(i);
if (!pal()) continue;
if (strcmp(ans, sub) < 0) strcpy(ans, sub);
}
printf("%s", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<long long int> primes;
void sieve(long long int n) {
vector<bool> prime(n + 1, true);
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * 2; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p]) primes.push_back(p);
}
long long int gcd(long long int x, long long int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
vector<long long int> vin(long long int n) {
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
return a;
}
void out(vector<long long int> a) {
for (int i = 0; i < (long long int)a.size(); i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
void in(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) cin >> a[i];
}
void out(long long int *a, long long int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
void out1(vector<long long int> v) {
for (long long int i = 0; i < (long long int)v.size(); i++) {
cout << v[i] << " ";
}
cout << '\n';
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
vector<long long int> v1, v2, v3;
for (long long int i = 0; i < n / 2; i++) {
v1.push_back(a[i]);
}
if (n % 2 == 0) {
for (long long int i = n / 2; i < n; i++) {
v2.push_back(a[i]);
}
} else {
for (long long int i = n / 2 + 1; i < n; i++) {
v2.push_back(a[i]);
}
}
reverse(v2.begin(), v2.end());
for (long long int i = 0; i < v1.size(); i++) {
v3.push_back(v2[i]);
v3.push_back(v1[i]);
}
if (n % 2 != 0) {
v3.push_back(a[n / 2]);
}
reverse(v3.begin(), v3.end());
for (long long int i = 0; i < v3.size(); i++) {
cout << v3[i] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s, u;
int main() {
cin >> s >> u;
int slen = s.length(), ulen = u.length();
int sum = ulen;
for (int i = -ulen + 1; i < slen; i++) {
int temp = ulen;
for (int j = 0; j < ulen; j++) {
if (i + j >= 0 && i + j < slen && s[i + j] == u[j]) temp--;
}
sum = min(sum, temp);
}
cout << sum << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool s[475];
inline void calc(int& d, int& p) {
int i = d;
for (int t = 0; t < 25; t++) {
i = (i * 96 + 42) % 475;
if (i + 26 == p) {
s[d] = true;
return;
}
}
}
class Compare {
public:
bool operator()(pair<int, int> a, pair<int, int> b) {
return a.second > b.second;
}
};
bool isFound[1048576];
int main() {
int p, x, y;
scanf("%d%d%d", &p, &x, &y);
for (int i = 0; i < 475; i++) {
calc(i, p);
}
priority_queue<pair<int, int>, vector<pair<int, int> >, Compare> pq;
pq.push(make_pair(x, 0));
int cur, cnt;
while (!pq.empty()) {
cur = pq.top().first;
cnt = pq.top().second;
pq.pop();
if (cur < y || cur > 1048576) continue;
if (isFound[cur]) continue;
isFound[cur] = true;
if (s[(cur / 50) % 475]) break;
pq.push(make_pair(cur + 100, cnt + 1));
pq.push(make_pair(cur - 50, cnt));
}
printf("%d", cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, i, j;
int a, b, c, r;
while (scanf("%d", &n) == 1) {
c = 0;
r = 0;
for (i = 1; i <= 2 * n; i++) {
scanf("%d.%d", &a, &b);
r += b;
if (b == 0) {
c++;
}
}
r -= 1000 * n;
while (c > 0 && r < -500) {
r += 1000;
c--;
}
r = abs(r);
printf("%d.%03d\n", r / 1000, r % 1000);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400007;
int n, m;
pair<long long, long long> a[maxn];
struct rev {
int u;
int v;
long long w;
rev(int tt = 0, int vv = 0, long long ww = 0) {
u = tt;
v = vv;
w = ww;
}
};
rev edge[maxn];
long long ans = 0;
int fa[maxn];
int fd(int x) { return x == fa[x] ? x : fa[x] = fd(fa[x]); }
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = (1); i <= (n); ++i) {
long long x;
cin >> x;
fa[i] = i;
a[i] = {x, i};
}
sort(a + 1, a + 1 + n);
int p = 0;
for (int i = (2); i <= (n); ++i)
edge[p++] = rev(a[1].second, a[i].second, a[i].first + a[1].first);
for (int i = (1); i <= (m); ++i) {
int u, v;
long long w;
cin >> u >> v >> w;
edge[p++] = rev(u, v, w);
}
sort(edge, edge + p, [](const rev& a, const rev& b) {
if (a.w != b.w) return a.w < b.w;
if (a.u != b.u) return a.u < b.u;
return a.v < b.v;
});
for (int i = (0); i < (p); ++i) {
int fu, fv;
fu = fd(edge[i].u);
fv = fd(edge[i].v);
if (fu == fv) continue;
ans += edge[i].w;
fa[fu] = fv;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long Pow(long long x, long long y) {
long long res = 1;
for (; y; y >>= 1, x = 1LL * x * x % 998244353)
if (y & 1) res = 1LL * res * x % 998244353;
return res;
}
long long fac[1000010], inv[1000010];
inline long long C(long long m, long long n) {
return 1LL * fac[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
signed main() {
long long n;
cin >> n;
fac[0] = inv[0] = inv[1] = 1;
for (long long i = 1; i < 1000010; i++)
fac[i] = 1LL * i * fac[i - 1] % 998244353;
for (long long i = 2; i < 1000010; i++)
inv[i] = 1LL * (998244353 - 998244353 / i) * inv[998244353 % i] % 998244353;
for (long long i = 1; i < 1000010; i++)
inv[i] = 1LL * inv[i] * inv[i - 1] % 998244353;
long long ans = 0, w = 1, res = 0;
for (long long i = 1; i <= n; i++) {
(ans += 1LL * Pow(3, (1LL * n * (n - i) + i)) * w * C(i, n) % 998244353) %=
998244353;
if (ans < 0) ans += 998244353;
w *= -1;
}
w = -1;
for (long long i = 0; i < n; i++) {
long long t = 998244353 - Pow(3, i);
(res += 1LL * C(i, n) * w * (Pow(t + 1, n) - Pow(t, n) + 998244353) %
998244353) %= 998244353;
if (res < 0) res += 998244353;
w *= -1;
}
cout << (1LL * ans * 2 % 998244353 + 1LL * res * 3 % 998244353) % 998244353
<< endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
int _t, n, m, map[100001], head[100010], nxt[1000001], b[1000001], v[1000001],
k, S, T, SS, TT;
int dis[100010], p[100010], q[100010], h, t;
int ans[100001], val[100001];
void push(int s, int t, int val) {
nxt[++k] = head[s];
head[s] = k;
b[k] = t;
v[k] = val;
}
void link(int s, int t, int val) {
push(s, t, val);
push(t, s, 0);
}
int hash(int i, int j) { return (i - 1) * m + j; }
bool bfs() {
memset(dis, 0, sizeof dis);
h = t = 0;
q[++t] = SS;
dis[SS] = 1;
while (h < t) {
++h;
for (int i = head[q[h]]; i; i = nxt[i])
if (v[i] && !dis[b[i]]) {
dis[b[i]] = dis[q[h]] + 1;
q[++t] = b[i];
if (b[i] == TT) return 1;
}
}
return 0;
}
int dfs(int x, int flow) {
if (!flow || x == TT) return flow;
int used = 0;
for (int i = p[x]; i; i = nxt[i])
if (v[i] && dis[b[i]] == dis[x] + 1) {
int w = dfs(b[i], std::min(flow - used, v[i]));
v[i] -= w;
v[i ^ 1] += w;
if (w) p[x] = i;
used += w;
if (used == flow) return used;
}
if (!used) dis[x] = 0;
return used;
}
int main() {
scanf("%d", &_t);
for (int fd = 1; fd <= _t; fd++) {
k = 1;
memset(head, 0, sizeof head);
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &map[hash(i, j)]);
T = n * m + 1;
int fS = 0, fT = 0;
SS = T + 1;
TT = T + 2;
bool Ans = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
bool cando = 0;
cando |= (i > 1 && map[hash(i - 1, j)] < map[hash(i, j)]);
cando |= (j > 1 && map[hash(i, j - 1)] < map[hash(i, j)]);
cando |= (i < n && map[hash(i + 1, j)] < map[hash(i, j)]);
cando |= (j < m && map[hash(i, j + 1)] < map[hash(i, j)]);
if (!cando && map[hash(i, j)] == 1) Ans = 0;
if ((i + j) & 1) {
if (cando)
link(S, hash(i, j), 1);
else
link(SS, hash(i, j), 1), ++fS;
if (i > 1 && map[hash(i - 1, j)] == map[hash(i, j)])
link(hash(i, j), hash(i - 1, j), 1);
if (j > 1 && map[hash(i, j - 1)] == map[hash(i, j)])
link(hash(i, j), hash(i, j - 1), 1);
if (i < n && map[hash(i + 1, j)] == map[hash(i, j)])
link(hash(i, j), hash(i + 1, j), 1);
if (j < m && map[hash(i, j + 1)] == map[hash(i, j)])
link(hash(i, j), hash(i, j + 1), 1);
} else {
if (cando)
link(hash(i, j), T, 1);
else
link(hash(i, j), TT, 1), ++fT;
}
}
link(S, TT, fS);
link(SS, T, fT);
link(T, S, 0x7f7f7f7f);
while (bfs()) {
memcpy(p, head, sizeof p);
dfs(SS, 0x7f7f7f7f);
}
memset(ans, -1, sizeof ans);
for (int i = 2; i <= k; i += 2) {
if (!v[i]) {
int s = b[i], t = b[i ^ 1];
if (s >= 1 && s <= n * m && t >= 1 && t <= n * m) {
int x1 = (s - 1) / m + 1, y1 = (s - 1) % m + 1, x2 = (t - 1) / m + 1,
y2 = (t - 1) % m + 1;
if (x1 == x2)
ans[s] = (y1 < y2), ans[t] = (y1 > y2);
else
ans[s] = (x1 < x2) + 2, ans[t] = (x1 > x2) + 2;
val[s] = 1, val[t] = map[t] - 1;
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (!~ans[hash(i, j)]) {
bool cando = 0;
cando |= (i > 1 && map[hash(i - 1, j)] < map[hash(i, j)]);
cando |= (j > 1 && map[hash(i, j - 1)] < map[hash(i, j)]);
cando |= (i < n && map[hash(i + 1, j)] < map[hash(i, j)]);
cando |= (j < m && map[hash(i, j + 1)] < map[hash(i, j)]);
if (!cando) Ans = 0;
}
if (!Ans)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char ch = '0';
switch (ans[hash(i, j)]) {
case 0: {
ch = 'L';
break;
}
case 1: {
ch = 'R';
break;
}
case 2: {
ch = 'U';
break;
}
case 3: {
ch = 'D';
break;
}
case -1: {
ch = '0';
break;
}
}
if (ch == '0') {
if (i > 1 && map[hash(i - 1, j)] < map[hash(i, j)])
ch = 'U', val[hash(i, j)] = map[hash(i, j)] - map[hash(i - 1, j)];
if (j > 1 && map[hash(i, j - 1)] < map[hash(i, j)])
ch = 'L', val[hash(i, j)] = map[hash(i, j)] - map[hash(i, j - 1)];
if (i < n && map[hash(i + 1, j)] < map[hash(i, j)])
ch = 'D', val[hash(i, j)] = map[hash(i, j)] - map[hash(i + 1, j)];
if (j < m && map[hash(i, j + 1)] < map[hash(i, j)])
ch = 'R', val[hash(i, j)] = map[hash(i, j)] - map[hash(i, j + 1)];
}
ans[hash(i, j)] = ch;
}
for (int i = 1; i <= n; i++, putchar('\n'))
for (int j = 1; j <= m; j++) printf("%d ", val[hash(i, j)]);
for (int i = 1; i <= n; i++, putchar('\n'))
for (int j = 1; j <= m; j++) putchar(ans[hash(i, j)]), putchar(' ');
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 50;
int n;
int a[N];
pair<int, int> p[N];
struct BIT {
int n;
int bit[N];
void add(int x, int val) {
for (int i = x; i < n; i |= i + 1) bit[i] += val;
}
long long get(int x) {
long long res = 0;
for (int i = x; i >= 0; i = (i & (i + 1)) - 1) res += bit[i];
return res;
}
} bit;
struct S {
priority_queue<int, vector<int>, greater<int> > R;
priority_queue<int> L;
long long lsum = 0, rsum = 0;
void insert(int x) {
if (R.empty() || x >= R.top()) {
R.push(x);
rsum += x;
} else {
L.push(x);
lsum += x;
}
while (L.size() < (L.size() + R.size()) / 2) {
int v = R.top();
R.pop();
rsum -= v;
lsum += v;
L.push(v);
}
while (L.size() > (L.size() + R.size()) / 2) {
int v = L.top();
L.pop();
lsum -= v;
rsum += v;
R.push(v);
}
}
long long gc(int x) { return 1LL * (1 + x) * x / 2; }
long long getsum() {
long long res;
if (R.size() > L.size()) {
int v = R.top();
R.pop();
rsum -= v;
res = (rsum - 1LL * R.size() * v - gc(R.size())) +
(1LL * L.size() * v - lsum - gc(L.size()));
rsum += v;
R.push(v);
} else {
int v = L.top();
L.pop();
lsum -= v;
res = (rsum - 1LL * R.size() * v - gc(R.size())) +
(1LL * L.size() * v - lsum - gc(L.size()));
lsum += v;
L.push(v);
}
return res;
}
} st;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
p[i].first = a[i];
p[i].second = i;
}
sort(p, p + n);
bit.n = n;
long long cur_inv = 0;
for (int i = 0; i < n; i++) {
cur_inv += i - bit.get(p[i].second - 1);
bit.add(p[i].second, 1);
st.insert(p[i].second);
cout << cur_inv + st.getsum() << " ";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v, sp;
long long c;
int getV(int u) { return u == this->u ? this->v : this->u; }
};
vector<Edge> V;
vector<vector<int> > adj;
long long ditra(int s, int t) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
PQ;
PQ.push(pair<long long, int>(0, s));
vector<long long> D(adj.size(), 1000000000000000000LL);
D[s] = 0;
while (PQ.size()) {
pair<long long, int> c = PQ.top();
PQ.pop();
long long u = c.second, d = c.first;
if (D[u] < d) continue;
if (u == t) return d;
for (int e : adj[u]) {
Edge &ed = V[e];
long long v = ed.getV(u), nd = d + ed.c;
if (D[v] > nd) {
D[v] = nd;
PQ.push(pair<long long, int>(nd, v));
}
}
}
return 1000000000000000000LL;
}
int main() {
int N, M, s, t;
long long L;
cin >> N >> M >> L >> s >> t;
adj = vector<vector<int> >(N);
for (int i = 0; i < M; ++i) {
Edge e;
cin >> e.u >> e.v >> e.c;
if (e.c == 0)
e.sp = 1, e.c = 1;
else
e.sp = 0;
V.push_back(e);
adj[e.u].push_back(i);
adj[e.v].push_back(i);
}
if (ditra(s, t) < L)
for (Edge &e : V) {
if (e.sp == 0) continue;
e.c = 1000000000;
if (ditra(s, t) < L) continue;
int lo = 1, hi = 1000000000;
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
e.c = mi;
long long d = ditra(s, t);
if (d <= L) {
lo = mi;
} else {
hi = mi - 1;
}
}
e.c = lo;
break;
}
if (ditra(s, t) == L) {
cout << "YES" << endl;
for (Edge &e : V) {
cout << e.u << " " << e.v << " " << e.c << endl;
}
} else {
cout << "NO" << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int cnt[109];
int main() {
int n, i, j, k, r = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
for (k = i; k <= j; k++) cnt[k]++;
}
}
for (i = 1; i <= n; i++) r = max(r, cnt[i]);
printf("%d\n", r);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unsigned int n, p, q, Ans;
unsigned int c[140];
unsigned int Gcd(unsigned int x, unsigned int y) {
return !y ? x : Gcd(y, x % y);
}
unsigned int Cal(unsigned int x) {
vector<unsigned int> v1, v2;
for (unsigned int i = n - x + 1; i <= n; ++i) v1.push_back(i);
for (unsigned int i = 2; i <= x; ++i) v2.push_back(i);
for (unsigned int &a : v1) {
for (unsigned int &b : v2) {
unsigned int d = Gcd(a, b);
if (d > 1) a /= d, b /= d;
}
}
unsigned int ret = 1;
for (unsigned int a : v1) ret *= a;
return ret;
}
int main() {
scanf("%u%u%u", &n, &p, &q);
p = min(p, n - 1);
c[0] = 1;
for (unsigned int i = 1; i <= p; ++i) c[i] = Cal(i);
for (unsigned int d = 1; d <= q; ++d) {
unsigned int pw = 1, now = 0;
for (unsigned int i = 0; i <= p; ++i, pw *= d) now += c[i] * pw;
Ans ^= now * d;
}
printf("%u\n", Ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 500005;
long long A[MAX_N];
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int N;
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
if (N == 1) {
cout << A[0] << endl;
return 0;
}
int pos = 0, neg = 0;
long long ans = 0;
for (int i = 0; i < N; i++) {
ans += abs(A[i]);
if (A[i] > 0)
pos++;
else if (A[i] < 0)
neg++;
}
if (pos == N)
ans -= 2 * *min_element(A, A + N);
else if (neg == N)
ans += 2 * *max_element(A, A + N);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005], lazy[4 * 100005], num, value;
bool flag;
struct Node {
int maxi, mini, one, two;
} tree[4 * 100005];
Node merge(Node a, Node b) {
Node temp;
int num = max(a.maxi, b.maxi);
temp.maxi = num, temp.one = num == a.maxi ? a.one : b.one;
num = min(a.mini, b.mini);
temp.mini = num, temp.two = num == a.mini ? a.two : b.two;
return temp;
}
void build(int node, int a, int b) {
if (a > b) return;
if (a == b) {
tree[node] = (Node){arr[a], arr[a], a, a};
return;
}
int left, right;
left = 2 * node + 1, right = 2 * node + 2;
build(left, a, (a + b) / 2);
build(right, (a + b) / 2 + 1, b);
tree[node] = merge(tree[left], tree[right]);
}
void lazy_update(int node, int a, int b) {
int left, right;
left = 2 * node + 1, right = 2 * node + 2;
tree[node].maxi -= lazy[node];
tree[node].mini -= lazy[node];
if (a != b) {
lazy[left] += lazy[node];
lazy[right] += lazy[node];
}
lazy[node] = 0;
}
void update(int node, int a, int b, int i, int j, int val) {
if (lazy[node]) lazy_update(node, a, b);
if (a > b || a > j || b < i) return;
if (a >= i && b <= j) {
lazy[node] = val;
lazy_update(node, a, b);
return;
}
int left, right;
left = 2 * node + 1, right = 2 * node + 2;
update(left, a, (a + b) / 2, i, j, val);
update(right, (a + b) / 2 + 1, b, i, j, val);
tree[node] = merge(tree[left], tree[right]);
}
void query(int node, int a, int b, int i, int j, int val) {
if (lazy[node]) lazy_update(node, a, b);
if (flag) return;
if (a > b || a > j || b < i) return;
if (val > tree[node].mini) {
if (a == b) {
flag = true;
num = a;
return;
}
int left, right;
left = 2 * node + 1, right = 2 * node + 2;
query(left, a, (a + b) / 2, i, j, val);
query(right, (a + b) / 2 + 1, b, i, j, val);
}
}
int main() {
int n, a, b, one, two, k = 0, diff;
scanf("%d", &n);
set<int> zero;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
if (!arr[i]) zero.insert(i);
}
build(0, 0, n - 1);
zero.insert(n);
vector<pair<int, int> > vec;
while (true) {
if (lazy[0]) lazy_update(0, 0, n - 1);
if (tree[0].maxi == 0) break;
int index = tree[0].one, x, y;
y = *zero.upper_bound(index);
flag = false;
query(0, 0, n - 1, index + 1, y - 1, tree[0].maxi);
a = index;
b = flag ? num - 1 : min(n - 1, y - 1);
update(0, 0, n - 1, a, b, 1);
vec.push_back(make_pair(a + 1, b + 1));
}
printf("%d\n", vec.size());
for (int i = 0; i < vec.size(); i++)
printf("%d %d\n", vec[i].first, vec[i].second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100002;
const int MOD = 1000000007;
int n, nQueries, ps[MAX_N];
int64_t pw2[MAX_N];
void solve() {
cin >> n >> nQueries;
pw2[0] = 1;
for (int i = 1; i <= n; ++i) {
char x;
cin >> x;
ps[i] = ps[i - 1] + x - '0';
pw2[i] = pw2[i - 1] * 2 % MOD;
}
while (nQueries--) {
int l, r;
cin >> l >> r;
int64_t tmp1 = pw2[ps[r] - ps[l - 1]] - 1;
int64_t tmp2 = pw2[r - l + 1 - ps[r] + ps[l - 1]] - 1;
cout << (tmp1 + tmp1 * tmp2 % MOD) % MOD << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[605][605];
vector<pair<int, int> > x;
void filldp(int l, int r) {
if (l > r) return;
if (dp[l][r] != -1) return;
for (int i = x[l].first; i < x[l].second + 1; i++) {
if (i % 2 == 0) continue;
if ((i - 1) / 2 + l <= r) filldp(l + 1, (i - 1) / 2 + l);
if ((i - 1) / 2 + l + 1 <= r) filldp((i - 1) / 2 + l + 1, r);
if ((i == 1 or dp[l + 1][(i - 1) / 2 + l] >= 0) and
(i == 2 * r - 2 * l + 1 or dp[(i - 1) / 2 + l + 1][r] >= 0)) {
dp[l][r] = i;
return;
}
}
dp[l][r] = -2;
}
char ans[1205];
void dfs(int l, int r, int offset = 0) {
if (l > r) return;
ans[offset] = '(';
ans[offset + dp[l][r]] = ')';
dfs(l + 1, (dp[l][r] - 1) / 2 + l, offset + 1);
dfs((dp[l][r] - 1) / 2 + l + 1, r, offset + dp[l][r] + 1);
}
void solve() {
int n;
cin >> n;
memset(dp, -1, sizeof dp);
x.resize(n);
for (int i = 0; i < n; i++) cin >> x[i].first >> x[i].second;
filldp(0, n - 1);
if (dp[0][n - 1] < 0) {
cout << "IMPOSSIBLE";
return;
}
dfs(0, n - 1);
for (int i = 0; i < 2 * n; i++) cout << ans[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define MAXN 200005
#define lowbit(x) (x&-x)
#define reg register
#define mkpr make_pair
#define fir first
#define sec second
typedef long long LL;
typedef unsigned long long uLL;
const LL INF=0x3f3f3f3f3f3f3f3f;
const int mo=998244353;
const int zero=500;
const LL jzm=2333;
const int orG=3,invG=332748118;
const double Pi=acos(-1.0);
typedef pair<int,int> pii;
const double PI=acos(-1.0);
template<typename _T>
_T Fabs(_T x){return x<0?-x:x;}
template<typename _T>
void read(_T &x){
_T f=1;x=0;char s=getchar();
while(s>'9'||s<'0'){if(s=='-')f=-1;s=getchar();}
while('0'<=s&&s<='9'){x=(x<<3)+(x<<1)+(s^48);s=getchar();}
x*=f;
}
template<typename _T>
void print(_T x){if(x<0){x=(~x)+1;putchar('-');}if(x>9)print(x/10);putchar(x%10+'0');}
int add(int x,int y){return x+y<mo?x+y:x+y-mo;}
int n,m,p,tot,sum[65],Id[65],stak,ans;
bool cho[65],answ[65],mp[MAXN][65];
bitset<MAXN>bit[65],sta[65];
char maze[65];
void dosaka2(int id,int pre){
if(id+(tot-pre)<=ans||sta[id].count()<(n+1)/2)return ;
if(id>ans){ans=id;for(int i=1;i<=m;i++)answ[i]=cho[i];}
for(int j=pre+1;j<=tot;j++){
sta[id+1]=sta[id]&bit[j];
cho[Id[j]]=1;dosaka2(id+1,j);cho[Id[j]]=0;
if(ans==min(tot,p))return ;
}
}
signed main(){
read(n);read(m);read(p);
for(int i=1;i<=n;i++){
scanf("\n%s",maze+1);
for(int j=1;j<=m;j++)if(maze[j]=='1')mp[i][j]=1,sum[j]++;
}
for(int i=1;i<=m;i++)if(sum[i]>=(n+1)/2)Id[++tot]=i;
for(int i=1;i<=tot;i++)for(int j=1;j<=n;j++)bit[i][j]=mp[j][Id[i]];
for(int i=1;i<=n;i++)sta[0][i]=1;dosaka2(0,0);
for(int i=1;i<=m;i++)printf("%d",answ[i]);puts("");
return 0;
}
/*
30
*/
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int t, a[200005] = {}, b[200005] = {}, c[200005] = {};
cin >> t;
while (t--) {
int n;
vector<pair<int, int> > z;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) b[i] = c[i] = 0;
int l = n + 1, r = 0;
for (int i = 1; i <= n; i++) {
if (b[a[i]]) break;
l = min(l, a[i]);
r = max(r, a[i]);
if (l == 1 && r == i) c[i] = 1;
b[a[i]] = 1;
}
for (int i = 1; i <= n; i++) b[i] = 0;
l = n + 1, r = 0;
for (int i = n; i; i--) {
if (b[a[i]]) break;
l = min(l, a[i]);
r = max(r, a[i]);
if (l == 1 && r == n - i + 1 && c[i - 1]) z.push_back({i - 1, n - i + 1});
b[a[i]] = 1;
}
cout << z.size() << '\n';
for (pair<int, int> i : z) cout << i.first << ' ' << i.second << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
long int n, k, x;
char s[100001];
scanf("%ld%ld%s", &n, &k, s);
for (x = 0; x < n - 1 && k > 0; x++) {
if (s[x] == '4' && s[x + 1] == '7') {
k--;
if (x % 2 == 0) {
s[x + 1] = '4';
if (x < n - 2 && s[x + 2] == '7') {
if (k % 2 == 1) s[x + 1] = '7';
k = 0;
}
} else {
s[x] = '7';
if (x > 0 && s[x - 1] == '4') {
if (k % 2 == 1) s[x] = '4';
k = 0;
}
}
}
}
printf("%s", s);
return (0);
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int n;
long long count(long long x) {
if (n >= x - 1) return x / 2;
return n - x / 2;
}
int main() {
scanf("%d", &n);
long long up = n + n - 1;
if (up < 9) {
printf("%d\n", n * (n - 1) / 2);
exit(0);
}
if (up == 9 || up == 99 || up == 999 || up == 9999 || up == 99999 ||
up == 999999 || up == 9999999 || up == 99999999 || up == 999999999) {
printf("1\n");
exit(0);
}
long long tmp = up, ten = 1;
while (tmp >= 10) tmp /= 10, ten *= 10;
long long ans = 0;
for (int i = 1; i <= 9; i++) {
long long ck = ten * i - 1;
if (ck > up) break;
ans += count(ck);
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool cal(int x) {
for (int i = 0; i <= x / 7; i++) {
int y = x - 7 * i;
if (y % 3 == 0) return true;
}
return false;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (cal(x))
printf("YES\n");
else
puts("NO");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> v, a, b, tmp;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
char c;
cin >> c;
if (c == 'P') {
v.push_back(x);
} else if (c == 'B') {
a.push_back(x);
} else {
b.push_back(x);
}
}
long long ans = 0;
if (v.size() == 0) {
if (a.size() > 0) {
ans += a.back() - a[0];
}
if (b.size() > 0) {
ans += b.back() - b[0];
}
cout << ans << endl;
return 0;
}
ans += v.back() - v[0];
if (a.size() > 0) {
ans += max((long long)0, v[0] - a[0]);
ans += max((long long)0, a.back() - v.back());
}
if (b.size() > 0) {
ans += max((long long)0, v[0] - b[0]);
ans += max((long long)0, b.back() - v.back());
}
int it1 = 0, it2 = 0;
while (it1 < a.size() && a[it1] < v[0]) {
it1++;
}
while (it2 < b.size() && b[it2] < v[0]) {
it2++;
}
for (int i = 0; i < v.size() - 1; i++) {
vector<long long> t1, t2;
t1.push_back(v[i]);
t2.push_back(v[i]);
while (it1 < a.size() && a[it1] < v[i + 1]) {
t1.push_back(a[it1++]);
}
while (it2 < b.size() && b[it2] < v[i + 1]) {
t2.push_back(b[it2++]);
}
t1.push_back(v[i + 1]);
t2.push_back(v[i + 1]);
long long delta1 = v[i + 1] - v[i];
long long delta2 = v[i + 1] - v[i];
for (int j = 1; j < t1.size(); j++) {
delta1 = min(delta1, v[i + 1] - v[i] - (t1[j] - t1[j - 1]));
}
for (int j = 1; j < t2.size(); j++) {
delta2 = min(delta2, v[i + 1] - v[i] - (t2[j] - t2[j - 1]));
}
if (t1.size() == 2) {
delta1 = 0;
}
if (t2.size() == 2) {
delta2 = 0;
}
ans += min(delta1 + delta2, v[i + 1] - v[i]);
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
const double pi(3.14159265358979);
const int N = 2100000, C = 7 * 17, D = 23, mod = (C << D) + 1, G = 3;
int n, m, a[N] = {}, b[N] = {}, ans[N] = {}, tot = 0;
void init() {
scanf("%d%d", &n, &m);
for (int i = 1, x = 0; i <= n; ++i) {
scanf("%d", &x);
++a[x], ++b[x];
}
a[0] = b[0] = 1;
}
inline int power(int x, int y) {
int t = 1;
for (; y; y >>= 1, x = x * 1ll * x % mod)
if (y & 1) t = t * 1ll * x % mod;
return t;
}
void DFT_inplace(int *t, int l, int sign) {
int n = 1 << l, g = power(G, C << (D - l));
for (int i = 0, x = 0, d = 0; i < n; ++i) {
if (i < x) swap(t[i], t[x]);
for (d = 0; i & (1 << d); ++d) x ^= 1 << (l - 1 - d);
if (l - 1 - d >= 0) x ^= 1 << (l - 1 - d);
}
for (int i = 1, d = 2; i <= l; ++i, d <<= 1) {
int g1 = power(sign == 1 ? g : power(g, n - 1), 1 << (l - i));
for (int j = 0; j < n; j += d)
for (int k = j, w = 1; k < j + d / 2; ++k, w = w * 1ll * g1 % mod) {
int t1 = t[k], t2 = t[k + d / 2] * 1ll * w % mod;
t[k] = (t1 + t2) % mod, t[k + d / 2] = (t1 + mod - t2) % mod;
}
}
if (sign == -1)
for (int i = 0; i < n; ++i) t[i] = t[i] * 1ll * power(n, mod - 2) % mod;
}
void work() {
int l = 1;
while ((1 << l) < ((m + 1) << 1)) ++l;
DFT_inplace(a, l, 1);
for (int i = 0; i < (1 << l); ++i) a[i] = a[i] * 1ll * a[i] % mod;
DFT_inplace(a, l, -1);
for (int i = 0; i <= m; ++i)
if (a[i] && !b[i]) {
puts("NO");
return;
}
for (int i = 1; i <= m; ++i)
if (a[i] == 2) ans[++tot] = i;
puts("YES");
printf("%d\n", tot);
for (int i = 1; i <= tot; ++i) printf("%d%c", ans[i], " \n"[i == tot]);
}
int main() {
init();
work();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int Head[N], Next[N << 1], Adj[N << 1], tot = 0;
int n;
inline void addedge(int u, int v) {
Next[++tot] = Head[u], Head[u] = tot, Adj[tot] = v;
Next[++tot] = Head[v], Head[v] = tot, Adj[tot] = u;
}
int U, V, len;
inline void dfs(int rt, int x, int f, int l) {
if (l > len) U = rt, V = x, len = l;
for (int e = Head[x]; e; e = Next[e])
if (Adj[e] != f) dfs(rt, Adj[e], x, l + 1);
}
int deg[N], dep[N], c[N];
bool flag = true;
inline void ck(int x, int f) {
if (!c[dep[x]])
c[dep[x]] = deg[x];
else if (c[dep[x]] != deg[x])
flag = false;
for (int e = Head[x]; e; e = Next[e])
if (Adj[e] != f) {
dep[Adj[e]] = dep[x] + 1;
ck(Adj[e], x);
}
}
int d[2][N], mid;
inline void getdist(int p, int x, int f) {
for (int e = Head[x]; e; e = Next[e])
if (Adj[e] != f) {
d[p][Adj[e]] = d[p][x] + 1;
getdist(p, Adj[e], x);
}
}
inline void getmid() {
getdist(0, U, 0);
getdist(1, V, 0);
if (d[0][V] & 1) return;
int mn = n;
for (int i = 1; i <= n; i++)
if (d[0][i] == d[1][i]) mn = min(mn, d[0][i]);
for (int i = 1; i <= n; i++)
if (d[0][i] == d[1][i] && d[0][i] == mn) {
mid = i;
return;
}
}
inline bool check(int x) {
memset(c, 0, sizeof(c));
dep[x] = 0;
flag = true;
ck(x, 0);
return flag;
}
int pos;
inline void getleaf() {
d[0][mid] = 0;
getdist(0, mid, 0);
int mn = n;
for (int i = 1; i <= n; i++)
if (deg[i] == 1) mn = min(mn, d[0][i]);
for (int i = 1; i <= n; i++)
if (deg[i] == 1 && mn == d[0][i]) pos = i;
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
addedge(u, v), deg[u]++, deg[v]++;
}
U = V = 1;
dfs(U, U, 0, 0);
dfs(V, V, 0, 0);
getmid();
getleaf();
if (check(U)) {
printf("%d", U);
return 0;
}
if (check(V)) {
printf("%d", V);
return 0;
}
if (!mid) {
puts("-1");
return 0;
}
if (check(mid)) {
printf("%d", mid);
return 0;
}
if (check(pos)) {
printf("%d", pos);
return 0;
}
puts("-1");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
char arr[105];
scanf("%d%*c", &t);
while (t--) {
gets(arr);
int len = strlen(arr);
char temp[20] = {arr[len - 5], arr[len - 4], arr[len - 3], arr[len - 2],
arr[len - 1]};
char tem[20] = {arr[0], arr[1], arr[2], arr[3], arr[4]};
if (strcmp(temp, "lala.") == 0 && strcmp(tem, "miao.") == 0)
printf("OMG>.< I don't know!\n");
else if (strcmp(temp, "lala.") == 0)
printf("Freda's\n");
else if (strcmp(tem, "miao.") == 0)
printf("Rainbow's\n");
else
printf("OMG>.< I don't know!\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const long long mod = 1000000007;
long long quc[maxn], cuq[maxn];
int n, m;
pair<int, int> A[maxn];
long long ans;
long long pow(int a, int n) {
long long s = 1, t = a;
for (; n; n >>= 1) {
if (n & 1) s = s * t % mod;
t = t * t % mod;
}
return s;
}
long long C(int n, int k) { return quc[n] * cuq[k] % mod * cuq[n - k] % mod; }
void solve(int st, int pos) {
int L = pos, R = pos;
long long res = 1;
for (int i = st; i <= m; ++i) {
int num = A[i].first - A[i - 1].first - 1, now = A[i].second;
if (L <= now && now <= R) return;
if (now < L) {
int tmp1 = L - now - 1;
if (tmp1 > num) return;
L = now;
R = L - 1 + A[i].first;
res = res * C(num, tmp1) % mod;
} else {
int tmp1 = now - R - 1;
if (tmp1 > num) return;
R = now;
L = R - A[i].first + 1;
res = res * C(num, tmp1) % mod;
}
}
ans = (ans + res) % mod;
}
int main() {
scanf("%d", &n);
quc[0] = cuq[0] = 1;
for (int i = 1; i <= n; ++i) {
quc[i] = quc[i - 1] * i % mod;
cuq[i] = pow(quc[i], mod - 2);
}
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
if (x) A[++m] = pair<int, int>(x, i);
}
sort(A + 1, A + m + 1);
++n;
A[++m] = pair<int, int>(n, n);
A[0].first = 1;
ans = 0;
if (A[1].first == 1)
solve(2, A[1].second);
else
for (int i = 1; i <= n; ++i) solve(1, i);
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long powmod(long long a, long long b) {
long long res = 1;
if (a >= mod) a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= mod) res %= mod;
a = a * a;
if (a >= mod) a %= mod;
}
return res;
}
int a[100];
int main() {
ios_base::sync_with_stdio(false);
;
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (long long i = (long long)(1); i <= (long long)(n); i++) {
cin >> a[i];
}
bool flag = false;
for (long long i = (long long)(1); i <= (long long)(n); i++) {
int temp = a[i] - a[i - 1];
if (temp > 15) {
flag = true;
cout << a[i - 1] + 15;
break;
}
}
if (!flag) {
int temp = 90 - a[n];
if (temp > 15)
cout << (a[n] + 15);
else
cout << "90";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e6 + 5000, mod = 51123987;
int hw[N], n, l[N], r[N];
char st[N];
void solve() {
st[0] = 1;
int nn = n * 2 - 1;
for (int i = nn; i >= 1; i--) st[i] = (i & 1) ? st[(i >> 1) + 1] : '#';
int mx = 0, mid = 0;
long long cnt = 0;
for (int i = 1; i <= nn; i++) {
hw[i] = i <= mx ? min(hw[2 * mid - i], mx - i + 1) : 1;
for (; i + hw[i] <= nn && i - hw[i] >= 1 && st[i + hw[i]] == st[i - hw[i]];
hw[i]++)
;
if (i + hw[i] - 1 > mx) mx = i + hw[i] - 1, mid = i;
r[i]++, r[i + hw[i]]--;
l[i - hw[i] + 1]++, l[i + 1]--;
cnt += (hw[i] + (i & 1)) >> 1;
}
cnt %= mod;
for (int i = 1; i <= nn + 1; i++) l[i] += l[i - 1], r[i] += r[i - 1];
for (int i = nn; i >= 1; i--)
if (st[i] != '#')
l[i] = (l[i] + l[i + 1]) % mod;
else
l[i] = l[i + 1];
long long ans = (cnt * (cnt - 1) >> 1) % mod;
for (int i = 1; i < nn; i += 2) ans = (ans - 1ll * r[i] * l[i + 1]) % mod;
cout << (ans + mod) % mod << endl;
}
int main() {
scanf("%d", &n);
scanf("%s", st + 1);
solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long m[1000001];
bool circle(long a, long b, long c) {
if (m[a] == -1 || m[b] == -1 || m[c] == -1) return false;
if (a == b) return true;
if (m[a] < m[c]) {
if (m[a] < m[b] && m[b] < m[c])
return true;
else
return false;
} else {
if (m[a] > m[b] && m[b] > m[c])
return false;
else
return true;
}
return false;
}
int main() {
long la, lb;
scanf("%ld %ld", &la, &lb);
long *a = new long[la];
long *b = new long[lb];
for (long i = 0; i < la; i++) scanf("%ld", &a[i]);
for (long i = 0; i < 1000001; i++) m[i] = -1;
for (long i = 0; i < lb; i++) {
scanf("%ld", &b[i]);
m[b[i]] = i;
}
long to = 1;
long max = 0;
for (long i = 0; i < la; i++) {
if (m[a[i]] == -1) continue;
if (to <= i) to = i + 1;
while (circle(a[i], a[(to - 1) % la], a[to % la]) && to < i + la) {
to++;
}
if (to - i > max) max = to - i;
}
cout << max << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int temp = power(a, b / 2, m);
long long int ans = (temp % m * temp % m) % m;
if (b & 1) ans = (ans % m * a % m) % m;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) {
long long int n;
cin >> n;
long long int fact[n + 1];
fact[0] = 1;
for (long long int i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] % 998244353 * i % 998244353) % 998244353;
}
long long int ans = (n % 998244353 * fact[n] % 998244353) % 998244353;
for (long long int i = 1; i <= n - 1; i++) {
long long int temp =
(fact[n] % 998244353 * power(fact[i], 998244353 - 2, 998244353) %
998244353) %
998244353;
ans = (ans - temp + 998244353) % 998244353;
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char ar[100009];
char br[100009];
int main() {
while (gets(ar)) {
int n, i, j, cou, l;
gets(br);
l = strlen(ar), cou = 0;
for (i = 0; i < l; i++) {
if (ar[i] != br[i]) cou++;
}
if (cou % 2 != 0)
printf("impossible\n");
else {
int cou2 = 0, nw = cou / 2;
for (i = 0; i < l; i++) {
if (nw > cou2 && ar[i] != br[i]) {
cou2++;
if (ar[i] == '0')
printf("%c", '1');
else
printf("%c", '0');
} else
printf("%c", ar[i]);
}
printf("\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false), cout.tie(0), cin.tie(0);
int n, k, v;
cin >> n >> k >> v;
vector<int> A(n + 1);
for (int i = 1; i <= n; ++i) cin >> A[i];
vector<pair<pair<int, int>, int>> ans;
if (v % k == 0) {
for (int i = 2; i <= n; ++i) {
if ((A[i] + k - 1) / k) ans.push_back({{(A[i] + k - 1) / k, i}, 1});
A[1] += A[i];
}
if (A[1] >= v) {
if (v) ans.push_back({{v / k, 1}, 2});
cout << "YES\n";
for (int i = 0; i < ((int)(ans).size()); ++i) {
cout << ans[i].first.first << " " << ans[i].first.second << " "
<< ans[i].second << '\n';
}
} else {
cout << "NO\n";
}
return 0;
}
vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0));
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < k; ++j) {
if (dp[i - 1][j] == 0) continue;
dp[i][j] = 1;
dp[i][(j + A[i]) % k] = 1;
}
}
if (!dp[n][v % k]) {
cout << "NO\n";
return 0;
}
int cur = v % k;
vector<int> z, o;
for (int i = n; i; --i) {
if (dp[i - 1][((cur - A[i]) % k + k) % k]) {
o.push_back(i);
cur = ((cur - A[i]) % k + k) % k;
} else {
z.push_back(i);
}
}
for (int i = 1; i < ((int)(z).size()); ++i) {
if ((A[z[i]] + k - 1) / k)
ans.push_back({{(A[z[i]] + k - 1) / k, z[i]}, z[0]});
A[z[0]] += A[z[i]];
}
if (((int)(z).size()) && (A[z[0]]) / k)
ans.push_back({{(A[z[0]]) / k, z[0]}, o[0]}), A[o[0]] += (A[z[0]]) / k * k;
for (int i = 1; i < ((int)(o).size()); ++i) {
if ((A[o[i]] + k - 1) / k)
ans.push_back({{(A[o[i]] + k - 1) / k, o[i]}, o[0]});
A[o[0]] += A[o[i]];
}
if (A[o[0]] < v) {
cout << "NO\n";
return 0;
}
int oth = o[0] + 1;
if (oth == n + 1) oth = 1;
if ((A[o[0]] - v)) ans.push_back({{(A[o[0]] - v) / k, o[0]}, oth});
cout << "YES\n";
for (int i = 0; i < ((int)(ans).size()); ++i) {
cout << ans[i].first.first << " " << ans[i].first.second << " "
<< ans[i].second << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long modulo = 1000000007;
string subStr(string s, int &i, int l) {
string substr = "";
if (i < l) {
substr += s[i++];
}
while (i < l && s[i] == s[i - 1]) {
substr += s[i++];
}
return substr;
}
int main() {
string s;
cin >> s;
int n = s.length(), count = 0;
vector<string> substrings;
int i = 0;
while (i < n) {
substrings.push_back(subStr(s, i, n));
}
int size = substrings.size();
if (size % 2 == 0) {
cout << "0" << endl;
} else {
int answer = -1;
for (int j = 0; j < size / 2; j++) {
if (substrings[j][0] != substrings[size - 1 - j][0] ||
substrings[j].length() + substrings[size - 1 - j].length() < 3) {
answer = 0;
break;
}
}
int l = substrings[size / 2].length();
if (answer == -1) {
answer = l > 1 ? l + 1 : 0;
}
cout << answer << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int ans = max(abs(a - c), abs(b - d));
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long area(int x, int y, int steps);
int main() {
int x, y, c;
scanf("%d%d%d%d", &n, &x, &y, &c);
int s1 = 0, s2 = max(x - 1, n - x) + max(y - 1, n - y);
int s = 0;
while (true) {
if (area(x, y, s1) >= c) {
s = s1;
break;
} else if (s2 - s1 <= 1) {
s = s2;
break;
}
s = (s1 + s2) / 2;
if (area(x, y, s) < c)
s1 = s + 1;
else
s2 = s;
}
printf("%d\n", s);
}
long long rArea(long long n) { return n * (n + 1) * 2 + 1; }
long long tArea(long long n) { return n * n; }
long long cArea(long long n) { return n * (n + 1) / 2; }
long long area(int x, int y, int steps) {
long long area = rArea(steps);
int sat1 = n - x, sat2 = n - y, sat3 = x - 1, sat4 = y - 1;
int h1 = steps > sat1 ? steps - sat1 : 0;
int h2 = steps > sat2 ? steps - sat2 : 0;
int h3 = steps > sat3 ? steps - sat3 : 0;
int h4 = steps > sat4 ? steps - sat4 : 0;
area -= tArea(h1) + tArea(h2) + tArea(h3) + tArea(h4);
if (steps > sat1 + sat2) area += cArea(steps - sat1 - sat2 - 1);
if (steps > sat2 + sat3) area += cArea(steps - sat2 - sat3 - 1);
if (steps > sat3 + sat4) area += cArea(steps - sat3 - sat4 - 1);
if (steps > sat4 + sat1) area += cArea(steps - sat4 - sat1 - 1);
return area;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using vc = vector<T>;
template <typename T>
using vvc = vc<vc<T>>;
template <class T>
using vvvc = vector<vvc<T>>;
template <class T>
using vvvvc = vector<vvvc<T>>;
template <typename T>
using PQ = priority_queue<T, vc<T>, greater<T>>;
using vi = vc<int>;
using vl = vc<long long>;
using vd = vc<double>;
using vb = vc<bool>;
const string YESNO[2] = {"NO", "YES"};
const string YesNo[2] = {"No", "Yes"};
const string yesno[2] = {"no", "yes"};
void YES(bool t = 1) { cout << YESNO[t] << '\n'; }
void NO(bool t = 1) { YES(!t); }
void Yes(bool t = 1) { cout << YesNo[t] << '\n'; }
void No(bool t = 1) { Yes(!t); }
void yes(bool t = 1) { cout << yesno[t] << '\n'; }
void no(bool t = 1) { yes(!t); }
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T, class S>
void scan(pair<T, S> &p) {
scan(p.first), scan(p.second);
}
template <class T>
void scan(vector<T> &a) {
for (auto &i : a) scan(i);
}
void out(int &a) { cout << a << '\n'; }
void out(long long &a) { cout << a << '\n'; }
void out(char &a) { cout << a << '\n'; }
void out(double &a) { cout << a << '\n'; }
void out(string &a) { cout << a << '\n'; }
template <class T, class S>
void out(pair<T, S> &p) {
cout << p.first << " " << p.second << '\n';
}
template <class T>
void out(vector<T> &a) {
for (auto &i : a) out(i);
}
template <class T>
void scan(T &a) {
cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
template <class T>
void vout(vector<T> &a) {
for (long long i = 0; i < (int)(a).size(); ++i) {
if (i > 0) cout << " ";
cout << a[i];
}
cout << '\n';
}
template <class T>
void vvout(vvc<T> &a) {
for (auto x : a) vout(x);
}
long long pow2(int i) { return 1LL << i; }
int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(long long t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int lowbit(signed a) { return a == 0 ? 32 : __builtin_ctz(a); }
int lowbit(long long a) { return a == 0 ? 64 : __builtin_ctzll(a); }
long long allbit(long long n) { return (1LL << n) - 1; }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(long long t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }
template <class T>
pair<T, T> operator-(const pair<T, T> &x, const pair<T, T> &y) {
return pair<T, T>(x.first - y.first, x.second - y.second);
}
template <class T>
pair<T, T> operator+(const pair<T, T> &x, const pair<T, T> &y) {
return pair<T, T>(x.first + y.first, x.second + y.second);
}
template <class T>
long long operator*(const pair<T, T> &x, const pair<T, T> &y) {
return (long long)x.first * y.first + (long long)x.second * y.second;
}
template <class T1, class T2, class Pred = std::less<T2>>
struct sort_pair_second {
bool operator()(const std::pair<T1, T2> &left,
const std::pair<T1, T2> &right) {
Pred p;
return p(left.second, right.second);
}
};
bool valid(long long h, long long w, long long mh, long long mw) {
return h >= 0 && h < mh && w >= 0 && w < mw;
}
template <class T, class S>
inline bool chmax(T &a, const S &b) {
return (a < b ? a = b, 1 : 0);
}
template <class T, class S>
inline bool chmin(T &a, const S &b) {
return (a > b ? a = b, 1 : 0);
}
int MOD = 1e9 + 7;
double EPS = 1e-6;
int INF = 2000000005;
long long INFF = 4000000000000000005LL;
double PI = acos(-1);
int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};
int rdx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
int rdy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int mod = MOD;
const int MX = 400000;
using uint = unsigned;
using ull = unsigned long long;
struct mint {
uint x;
mint() : x(0) {}
mint(long long x) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(0) - *this; }
mint operator~() const { return mint(1) / *this; }
mint &operator+=(const mint &a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint &operator-=(const mint &a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint &operator*=(const mint &a) {
x = (ull)x * a.x % mod;
return *this;
}
mint &operator/=(const mint &a) {
x = (ull)x * a.pow(mod - 2).x % mod;
return *this;
}
mint operator+(const mint &a) const { return mint(*this) += a; }
mint operator-(const mint &a) const { return mint(*this) -= a; }
mint operator*(const mint &a) const { return mint(*this) *= a; }
mint operator/(const mint &a) const { return mint(*this) /= a; }
mint pow(long long t) const {
if (!t) return 1;
mint res = pow(t / 2);
res *= res;
return (t & 1) ? res * x : res;
}
bool operator<(const mint &a) const { return x < a.x; }
bool operator==(const mint &a) const { return x == a.x; }
bool operator!=(const mint &a) const { return x != a.x; }
};
istream &operator>>(istream &i, mint &a) {
i >> a.x;
return i;
}
ostream &operator<<(ostream &o, const mint &a) {
o << a.x;
return o;
}
long long modpow(long long a, long long b, long long Mod) {
long long res = 1;
for (a %= Mod; b; a = a * a % Mod, b >>= 1)
if (b & 1) res = res * a % Mod;
return res;
}
vector<int> ps, pf;
void sieve(int mx) {
pf = vector<int>(mx + 1);
for (long long i = 0; i < mx + 1; ++i) pf[i] = i;
for (int i = 2; i <= mx; ++i) {
if (pf[i] == i) ps.push_back(i);
for (int j = 0; j < (int)(ps).size() && ps[j] <= pf[i]; ++j) {
int x = ps[j] * i;
if (x > mx) break;
pf[x] = ps[j];
}
}
}
vc<pair<int, int>> factor(int x) {
if (x == 1) return {};
vector<pair<int, int>> res(1, pair<int, int>(pf[x], 0));
while (x != 1) {
if (res.back().first == pf[x])
res.back().second++;
else
res.push_back(pair<int, int>(pf[x], 1));
x /= pf[x];
}
return res;
}
template <typename T>
struct edge {
int src, to;
T cost;
edge(int _to, T _cost) : src(-1), to(_to), cost(_cost) {}
edge(int _src, int _to, T _cost) : src(_src), to(_to), cost(_cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T>>;
template <typename T>
using WeightedGraph = vector<Edges<T>>;
using UnweightedGraph = vector<vector<int>>;
UnweightedGraph graph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
UnweightedGraph g(N);
if (M == -1) M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
if (is_1origin) x--, y--;
g[x].push_back(y);
if (!is_directed) g[y].push_back(x);
}
return g;
}
template <typename T>
WeightedGraph<T> wgraph(int N, int M = -1, bool is_directed = false,
bool is_1origin = true) {
WeightedGraph<T> g(N);
if (M == -1) M = N - 1;
for (int _ = 0; _ < M; _++) {
int x, y;
cin >> x >> y;
T c;
cin >> c;
if (is_1origin) x--, y--;
g[x].emplace_back(x, y, c);
if (!is_directed) g[y].emplace_back(y, x, c);
}
return g;
}
vector<long long> dijkstra(WeightedGraph<long long> &g, int start = 0) {
using P = pair<long long, int>;
int N = (int)g.size();
vector<long long> d(N, INFF);
priority_queue<P, vector<P>, greater<P>> Q;
d[start] = 0;
Q.emplace(0, start);
while (!Q.empty()) {
P p = Q.top();
Q.pop();
int cur = p.second;
if (d[cur] < p.first) continue;
for (auto dst : g[cur]) {
if (d[dst] == INFF || d[cur] + dst.cost < d[dst]) {
d[dst] = d[cur] + dst.cost;
Q.emplace(d[dst], dst);
}
}
}
return d;
}
void solve() {
long long A, B;
IN(A, B);
if (A > B) swap(A, B);
vl ans;
unordered_map<long long, long long> m;
for (long long i = 0; i <= A + B; ++i) {
if (m[i]) continue;
bool flag = false;
long long a = (A + B) / 2, b = (A + B + 1) / 2;
if (a - i == A && b + i == B)
flag = true;
else if (b - i == A && a + i == B)
flag = true;
else if (a - i == B && b + i == A)
flag = true;
else if (b - i == A && a + i == B)
flag = true;
else if (i % 2 == 0 && ((a == A && b == B) || (b == A && a == B)))
flag = true;
else if (A - (a - i) == B - (b + i))
flag = true;
else if (A - (b - i) == B - (a + i))
flag = true;
else if (B - (a - i) == A - (b + i))
flag = true;
else if (B - (b - i) == A - (a + i))
flag = true;
if (flag) {
ans.push_back(i);
long long c = min(A, B - i);
for (long long j = i + 2; j <= i + c * 2; ++j) {
if (m[j]) break;
ans.push_back(j);
m[j] = 1;
j++;
}
m[i] = 1;
}
}
sort(begin(ans), end(ans));
cout << (int)(ans).size() << '\n';
vout(ans);
}
int main() {
cout.tie(nullptr);
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int T;
IN(T);
while (T--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> day_seq;
vector<int> main_seq;
int sec, mn, hr, dw, dm, month;
int mlen[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() {
cin >> sec >> mn >> hr >> dw >> dm >> month;
if (dw > 0) --dw;
if (dm > 0) --dm;
if (month > 0) --month;
int ctr0, ctr1;
ctr0 = 0;
for (int h = 0; h < 24; ++h) {
for (int m = 0; m < 60; ++m) {
for (int s = 0; s < 60; ++s) {
if (h == hr || hr == -1) {
if (m == mn || mn == -1) {
if (s == sec || sec == -1) {
day_seq.push_back(ctr0);
}
}
}
++ctr0;
}
}
}
int st = 3;
ctr1 = 0;
for (int _y = 0; _y < 400; ++_y) {
int is_leap = 0;
int second = _y + 1970;
if (second % 4 == 0 && (second % 400 == 0 || second % 100 > 0)) is_leap = 1;
if (is_leap) mlen[1]++;
for (int m = 0; m < 12; ++m) {
for (int d = 0; d < mlen[m]; ++d) {
if (m == month || month == -1) {
if (dm != -1 && dw != -1) {
if (d == dm || st == dw) {
main_seq.push_back(ctr1);
}
}
if (dm == -1 && dw == -1) {
main_seq.push_back(ctr1);
}
if (dm == -1 && st == dw) {
main_seq.push_back(ctr1);
}
if (dw == -1 && d == dm) {
main_seq.push_back(ctr1);
}
}
++st;
if (st == 7) st = 0;
++ctr1;
}
}
if (is_leap) mlen[1]--;
}
int ctr;
cin >> ctr;
while (ctr--) {
long long now;
cin >> now;
long long main_div = now / (1LL * ctr0 * ctr1);
long long main_mod = now % (1LL * ctr0 * ctr1);
long long day_div = main_mod / ctr0;
long long day_mod = main_mod % ctr0;
if (day_div > main_seq.back() ||
(day_div == main_seq.back() && day_mod >= day_seq.back())) {
day_div = main_seq[0];
day_mod = day_seq[0];
++main_div;
} else if (day_mod >= day_seq.back() ||
(*lower_bound((main_seq).begin(), (main_seq).end(), day_div)) !=
day_div) {
day_div = (*upper_bound((main_seq).begin(), (main_seq).end(), day_div));
day_mod = day_seq[0];
} else {
day_mod = (*upper_bound((day_seq).begin(), (day_seq).end(), day_mod));
}
cout << main_div * ctr0 * ctr1 + day_div * ctr0 + day_mod << endl;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 1;
int a[N], b[N];
long long res;
int n, m;
map<int, int> Mark;
int main() {
int u, v;
res = 1;
cin >> m;
Mark[0] = 1;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
if (u == a[n] && v == b[n]) {
continue;
}
a[++n] = u;
b[n] = v;
}
for (int i = 1; i <= n; i++) {
long long x = a[i - 1], y = a[i], u = b[i - 1], v = b[i];
if (x > u) {
swap(x, u);
swap(y, v);
}
if (u > y)
continue;
else
res += (min(y, v) - u + 1);
if (u == x && Mark[u]) res--;
Mark[min(y, v)] = 1;
}
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int x, y, z;
cin >> x >> y >> z;
long long int req = y * z + z;
long long int t = (req + x - 2) / (x - 1);
if ((req + x - 2) % (x - 1) != 0) t++;
cout << t + z - 1 << "\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[100007];
int main() {
scanf("%s", s);
int n = strlen(s);
int bal = 0, pos = -1;
for (int i = 0; i < n; i++) {
bal += (s[i] == '(' ? 1 : -1);
if (s[i] == '#') {
pos = i;
}
}
if (bal < 0) {
printf("%d\n", -1);
return 0;
}
int extra = bal + 1;
bal = 0;
for (int i = 0; i < n; i++) {
bal += (i == pos ? -extra : (s[i] == '(' ? 1 : -1));
if (bal < 0) {
printf("%d\n", -1);
return 0;
}
}
for (int i = 0; i < n; i++) {
if (s[i] == '#') {
if (i == pos) {
printf("%d\n", extra);
} else {
printf("%d\n", 1);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
const long long N = 2 + 2;
long long n, k, l, m, a[N][N], x[N][N], ans[N][N];
void ready() {
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
a[i][j] = 1;
ans[i][j] = 1;
}
}
a[1][1] = 0;
ans[0][1] = 0;
ans[1][0] = 0;
}
long long power(long long a1, long long b1) {
long long res = 1;
for (; b1; b1 /= 2) {
if (b1 % 2) {
res *= a1;
res %= m;
}
a1 *= a1;
a1 %= m;
}
return res;
}
long long fib(long long b) {
ready();
b++;
for (; b; b /= 2) {
if (b % 2) {
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
x[i][j] = 0;
for (long long k = 0; k < 2; k++) {
x[i][j] += ans[i][k] * a[k][j] % m;
}
}
}
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
ans[i][j] = x[i][j];
}
}
}
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
x[i][j] = 0;
for (long long k = 0; k < 2; k++) {
x[i][j] += a[i][k] * a[k][j] % m;
}
}
}
for (long long i = 0; i < 2; i++) {
for (long long j = 0; j < 2; j++) {
a[i][j] = x[i][j];
}
}
}
return ans[0][0] % m;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> l >> m;
if (l < 63 && (1LL << l) <= k) {
cout << 0;
return 0;
}
long long jv = 1;
for (long long i = 0; i < l; i++) {
if ((1LL << i) & k) {
jv *= (power(2, n) - fib(n));
jv %= m;
} else {
jv *= fib(n);
jv %= m;
}
}
if (jv < 0) {
jv += m;
}
cout << jv % m << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[100];
cin >> a;
int i, l, c = 0;
l = strlen(a);
for (i = 0; i < l; i++)
if (a[i] == '4' || a[i] == '7') c++;
if (c == 4 || c == 7)
printf("YES\n");
else
printf("NO\n");
}
| 0 |
#include<bits/stdc++.h>
#define pb push_back
#define x first
#define y second
#define pdd pair<double,double>
#define pii pair<int,int>
#define pll pair<LL,LL>
#define mp make_pair
#define LL long long
#define ULL unsigned long long
#define sqr(x) ((x)*(x))
#define pi acosl(-1)
#define MEM(x) memset(x,0,sizeof(x))
#define MEMS(x) memset(x,-1,sizeof(x))
using namespace std;
static const double INF = 2147483647;
int dpl[100005],dpr[100005];
void solve(){
MEMS(dpl);
MEMS(dpr);
int n,m;
scanf("%d %d",&n,&m);
set<pii> l,r;
l.insert(mp(0,0));
r.insert(mp(0,0));
for(int i = 1;i<=n;i++){
int k;
int la,lb,ra,rb;
scanf("%d %d %d %d %d",&k,&la,&lb,&ra,&rb);
int okl=0,okr=0;
if(k>=la&&k<=lb)okl=1;
if(k>=ra&&k<=rb)okr=1;
while(l.size()&&l.begin()->x<la){
l.erase(l.begin());
}
while(l.size()&&l.rbegin()->x>lb){
l.erase(*l.rbegin());
}
while(r.size()&&r.begin()->x<ra){
r.erase(r.begin());
}
while(r.size()&&r.rbegin()->x>rb){
r.erase(*r.rbegin());
}
int ookl=0,ookr=0;
if(okl&&r.size()){
dpl[i]=r.begin()->y;
// l.insert(mp(k,i));
ookl=1;
}
if(okr&&l.size()){
dpr[i]=l.begin()->y;
// r.insert(mp(k,i));
ookr=1;
}
if(!ookr)l.clear();
if(!ookl)r.clear();
if(ookl)l.insert(mp(k,i));
if(ookr)r.insert(mp(k,i));
if(!ookl&&!ookr){
printf("No\n");
return;
}
}
printf("Yes\n");
vector<int> v;
if(dpl[n]!=-1){
int l=1;
int now=n;
while(now){
if(l){
int x=dpl[now];
for(int i = now;i>x;i--)v.pb(0);
now=x;
}
else{
int x=dpr[now];
for(int i = now;i>x;i--)v.pb(1);
now=x;
}
l^=1;
}
}
else{
int l=0;
int now=n;
while(now){
if(l){
int x=dpl[now];
for(int i = now;i>x;i--)v.pb(0);
now=x;
}
else{
int x=dpr[now];
for(int i = now;i>x;i--)v.pb(1);
now=x;
}
l^=1;
}
}
reverse(v.begin(),v.end());
for(auto it:v)printf("%d ",it);
printf("\n");
}
int main(){
int t=1;
// scanf("%d",&t);
while(t--){
solve();
}
//printf("%.12f\n",sum/tt);
return 0;
}
/*
3 3 3 4 4 4 5 5 5 6 6 6 7
5 5 5 5 5 6 6 6 6 6 7 7 7
3 3 4 4 5 5 6 6 7 7 8
5 5 5 6 6 6 7 7 7 8 8
3 3 4 4 5 5 6
5 5 5 5 5 5 5
1 1 6
0 -3 -3
0 0 5
1 -2 -2
-2 -2 3
3 0 0
1 1
1 2 1
1 3 2 3 1
1 4 3 5 2 5 3 4 1
1 5 4 7 3 8 5 7 2 7 5 8 3 7 4 5 1
*/ | 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int N = 1e5 + 100;
int n, m, tim, cycleS, cycleE, cnt[N], tin[N], tout[N], depth[N], par[N];
set<int> gr[N];
void dfs(int v) {
depth[v] = depth[par[v]] + 1;
tin[v] = ++tim;
for (auto to : gr[v]) {
if (to == par[v])
continue;
else if (tin[to] == 0) {
par[to] = v;
dfs(to);
} else {
if (depth[to] < depth[v] &&
depth[v] - depth[to] + 1 > depth[cycleS] - depth[cycleE] + 1) {
cycleS = v;
cycleE = to;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
gr[a].insert(b);
gr[b].insert(a);
cnt[a]++;
cnt[b]++;
}
dfs(1);
int sq = sqrt(n);
if (sq * sq < n) sq++;
if (sq <= depth[cycleS] - depth[cycleE] + 1) {
cout << 2 << endl;
cout << depth[cycleS] - depth[cycleE] + 1 << endl;
while (cycleS != cycleE) {
cout << cycleS << ' ';
cycleS = par[cycleS];
}
cout << cycleE << ' ';
} else {
vector<int> ans;
set<pair<int, int> > st;
for (int i = 1; i <= n; i++) st.insert({cnt[i], i});
while (!st.empty()) {
ans.push_back(st.begin()->second);
st.erase(st.begin());
for (auto to : gr[ans.back()]) {
st.erase({cnt[to], to});
gr[to].erase(ans.back());
for (auto toto : gr[to]) {
st.erase({cnt[toto], toto});
cnt[toto]--;
st.insert({cnt[toto], toto});
gr[toto].erase(to);
}
}
}
cout << 1 << endl;
for (int i = 0; i < sq; i++) cout << ans[i] << ' ';
}
cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const double eps = 1e-8;
const int maxn = 1e6 + 5;
const int INF = 1e9;
const int maxnode = 7e6 + 5;
const int sigma_size = 2;
void tran2(int num, int s[]) {
for (int i = 0; i < 31; i++) {
s[i] = (num >> (30 - i)) & 1;
}
}
struct Trie {
int ch[maxnode][sigma_size];
int val[maxnode], able[maxnode];
int sz;
void init() {
sz = 1;
memset(ch, 0, sizeof(ch));
memset(val, 0, sizeof(val));
memset(able, 0, sizeof(able));
}
int idx(int c) { return c; }
void insert(int *s) {
int u = 0, n = 31;
for (int i = 0; i < n; i++) {
able[u]++;
int c = idx(s[i]);
if (!ch[u][c]) {
val[sz] = 0;
ch[u][c] = sz++;
}
u = ch[u][c];
}
able[u]++;
val[u]++;
}
void del(int *s) {
int u = 0, n = 31;
for (int i = 0; i < n; i++) {
able[u]--;
int c = idx(s[i]);
u = ch[u][c];
}
able[u]--;
val[u]--;
}
int find_min(int *s) {
int u = 0, i = 1, num = 0;
int k = 0;
int r = 0;
for (k = 0; k < 31; k++) {
int y = idx(s[k]);
int x = y ^ 1;
able[u]--;
if (ch[u][y] && able[ch[u][y]] > 0) {
u = ch[u][y];
} else {
r += 1 << (30 - k);
u = ch[u][x];
}
}
able[u]--;
val[u]--;
return r;
}
} trie;
int a[maxn], p[maxn], n, s[maxn];
int main(void) {
scanf("%d", &n);
trie.init();
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
tran2(p[i], s);
trie.insert(s);
}
int tmp;
for (int i = 0; i < n; i++) {
tran2(a[i], s);
tmp = trie.find_min(s);
printf("%d ", tmp);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool ee(int k) {
bool b = 1;
while (k != 0) {
if (k % 10 != 4 && k % 10 != 7) {
b = 0;
break;
}
k = k / 10;
}
return b;
};
int main() {
int l;
cin >> l;
int a[14] = {4, 7, 47, 74, 44, 77, 444, 447, 474, 477, 744, 747, 774, 777};
bool b = ee(l);
if (b) {
cout << "YES";
return 0;
} else {
for (int i = 0; i < 14; i++) {
if (a[i] > l)
break;
else {
if (l % a[i] == 0) {
cout << "YES";
return 0;
}
}
}
}
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
bool judge(int x)
{
for(int i=1;i<=100;i++)
{
if(i*i==x)
return true;
}
return false;
}
int main()
{
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
for(int i=1; i<=n; i++)
{
cin>>a[i];
}
int loop=0;
for(int i=1; i<=n; i++)
{
if(judge(a[i]))
{
continue;
}
else
{
cout<<"YES"<<endl;
loop=1;
break;
}
}
if(loop==0)
cout<<"NO"<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long cnt[200005];
int main() {
long long n, m;
cin >> n >> m;
string a, b;
cin >> a >> b;
b = " " + b;
for (long long i = 1; i < b.size(); i++) {
cnt[i] = cnt[i - 1] + (b[i] == '1');
}
long long pw = 1, len = (long long)b.size() - 1, ans = 0;
for (long long i = (long long)a.size() - 1; i >= 0; i--) {
if (a[i] == '1') {
ans = (ans + (pw * cnt[len]) % 998244353) % 998244353;
}
pw = (pw * 2) % 998244353;
len = max(len - 1, 0LL);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long longinf = 1LL << 60;
const long long mod = 1e9 + 7;
vector<long long> inv, fact, invfact;
void mod_build(int n = 101010) {
fact.resize(n + 1);
inv.resize(n + 1);
invfact.resize(n + 1);
fact[0] = inv[0] = invfact[0] = 1;
inv[1] = 1;
for (int i = (int)0; i < (int)n; ++i) {
fact[i + 1] = fact[i] * (i + 1) % mod;
if (i > 0) inv[i + 1] = mod - inv[mod % (i + 1)] * (mod / (i + 1)) % mod;
invfact[i + 1] = invfact[i] * inv[i + 1] % mod;
}
}
long long perm(int n, int k) {
if (n < 0 || k < 0 || k > n) return 0;
return fact[n] * invfact[n - k] % mod;
}
long long comb(int n, int k) {
if (n < 0 || k < 0 || k > n) return 0;
return (fact[n] * invfact[n - k] % mod) * invfact[k] % mod;
}
long long powmod(long long n, long long k) {
long long ret = 1;
while (k) {
if (k & 1) ret = ret * n % mod;
n = n * n % mod;
k >>= 1;
}
return ret;
}
template <typename T>
struct LazySegmentTree {
private:
int n;
vector<T> node, lazy;
T E0, E1;
inline void updatef(T& lazy, T& value) {
lazy.first = lazy.first * value.first % mod;
lazy.second |= value.second;
}
inline void calculatef(T& node, T& lazy, int len) {
node.first = node.first * powmod(lazy.first, len) % mod;
node.second |= lazy.second;
}
inline T queryf(T& x, T& y) {
return make_pair(x.first * y.first % mod, x.second | y.second);
}
public:
LazySegmentTree(int sz, T nodeE, T lazyE = 0) : E0(nodeE), E1(lazyE) {
n = 1;
while (n < sz) n <<= 1;
node.resize(2 * n - 1, E0);
lazy.resize(2 * n - 1, E1);
}
LazySegmentTree(vector<T>& v, T E0, T E1 = 0) : E0(E0), E1(E1) {
n = 1;
int sz = v.size();
while (n < sz) n <<= 1;
node.resize(2 * n - 1, E0);
lazy.resize(2 * n - 1, E1);
for (int i = (int)0; i < (int)sz; ++i) node[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i) {
node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
}
}
void eval(int k, int l, int r) {
if (lazy[k] == E1) return;
calculatef(node[k], lazy[k], r - l);
if (r - l > 1) {
updatef(lazy[2 * k + 1], lazy[k]);
updatef(lazy[2 * k + 2], lazy[k]);
}
lazy[k] = E1;
}
void update(int a, int b, T x, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (r <= a || b <= l) return;
if (a <= l && r <= b) {
updatef(lazy[k], x);
eval(k, l, r);
} else {
update(a, b, x, 2 * k + 1, l, (l + r) / 2);
update(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
}
}
T query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (r <= a || b <= l) return E0;
if (a <= l && r <= b) return node[k];
T xl = query(a, b, 2 * k + 1, l, (l + r) / 2);
T xr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return queryf(xl, xr);
}
};
int main() {
vector<int> isprime(303, 1);
vector<int> prime;
vector<long long> bs(303);
long long e = 1;
isprime[0] = isprime[1] = 0;
for (int i = (int)0; i < (int)303; ++i) {
if (!isprime[i]) continue;
prime.push_back(i);
for (int j = i; j < 303; j += i) {
bs[j] |= e;
isprime[j] = false;
}
e <<= 1;
}
mod_build(303);
int n, q;
cin >> n >> q;
vector<pair<long long, long long>> a(n);
vector<bitset<70>> b(n);
for (int i = (int)0; i < (int)n; ++i) {
scanf("%lld", &a[i].first);
a[i].second = bs[a[i].first];
}
LazySegmentTree<pair<long long, long long>> sg(a, {1, 0}, {1, 0});
while (q--) {
string s;
cin >> s;
if (s[0] == 'T') {
int l, r;
cin >> l >> r;
auto ret = sg.query(l - 1, r);
for (int i = (int)0; i < (int)prime.size(); ++i) {
if (ret.second & (1LL << i)) {
ret.first = ret.first * (mod + 1 - inv[prime[i]]) % mod;
}
}
printf("%lld\n", ret.first);
} else {
int l, r, x;
cin >> l >> r >> x;
sg.update(l - 1, r, {x, bs[x]});
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt[1000005], sum[1000005], x, y, val[1000005], root, an1, an2, lol;
vector<int> vt[1000005];
bool vis[1000005], flag1, flag2;
void dfs(int node) {
if (vis[node]) return;
int tmp, siz = vt[node].size();
cnt[node] = 1;
sum[node] = val[node];
vis[node] = true;
for (int i = 0; i < siz && (!flag1 || !flag2); i++) {
tmp = vt[node][i];
if (vis[tmp]) continue;
dfs(tmp);
if (tmp != an1) {
cnt[node] += cnt[tmp];
sum[node] += sum[tmp];
}
}
if (sum[node] == lol && !flag1 && !flag2) {
an1 = node;
flag1 = true;
} else if (sum[node] == lol && flag1 && !flag2 && cnt[an1] + cnt[node] < n) {
an2 = node;
flag2 = true;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &val[i]);
lol += val[i];
if (x == 0)
root = i;
else {
vt[x].push_back(i);
vt[i].push_back(x);
}
}
if (abs(lol) % 3) {
printf("-1");
return 0;
}
lol /= 3;
dfs(root);
if (flag1 && flag2)
printf("%d %d", an1, an2);
else
printf("-1");
return 0;
}
| 6 |
#include <bits/stdc++.h>
signed main() {
int n, m;
std::cin >> n >> m;
bool poss = true;
char a[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) std::cin >> a[i][j];
bool row = false, col = false;
for (int i = 0; i < n; i++) {
int min = 10001;
int max = -1;
int c = 0;
for (int j = 0; j < m; j++) {
if (a[i][j] == '#') {
max = std::max(j, max);
min = std::min(j, min);
c++;
}
}
if (max != -1 && max - min + 1 != c) poss = false;
if (max == -1) row = true;
}
for (int i = 0; i < m; i++) {
int min = 10001;
int max = -1;
int c = 0;
for (int j = 0; j < n; j++) {
if (a[j][i] == '#') {
max = std::max(j, max);
min = std::min(j, min);
c++;
}
}
if (max != -1 && max - min + 1 != c) poss = false;
if (max == -1) col = true;
}
if (row ^ col) poss = false;
if (!poss) {
std::cout << -1 << std::endl;
return 0;
}
int ans = 0;
std::vector<std::vector<int> > mark(n, std::vector<int>(m, false));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '#') {
if (!mark[i][j]) {
ans++;
std::queue<std::pair<int, int> > q;
q.push({i, j});
while (!q.empty()) {
std::pair<int, int> x = q.front();
q.pop();
if (x.second < m - 1 && a[x.first][x.second + 1] == '#' &&
mark[x.first][x.second + 1] == false) {
mark[x.first][x.second + 1] = true;
q.push({x.first, x.second + 1});
}
if (x.second > 0 && a[x.first][x.second - 1] == '#' &&
mark[x.first][x.second - 1] == false) {
mark[x.first][x.second - 1] = true;
q.push({x.first, x.second - 1});
}
if (x.first < n - 1 && a[x.first + 1][x.second] == '#' &&
mark[x.first + 1][x.second] == false) {
mark[x.first + 1][x.second] = true;
q.push({x.first + 1, x.second});
}
if (x.first > 0 && a[x.first - 1][x.second] == '#' &&
mark[x.first - 1][x.second] == false) {
mark[x.first - 1][x.second] = true;
q.push({x.first - 1, x.second});
}
}
}
}
}
}
std::cout << ans << std::endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
struct rge {
t h, n;
};
template <class t>
rge<t> range(t h, t n) {
return rge<t>{h, n};
}
template <class t>
auto dud(t *r) -> decltype(cerr << *r, 2);
template <class t>
char dud(...);
struct debug {
template <class t>
debug &operator<<(const t &) {
return *this;
}
};
const int MN = 1 << 11;
char in[MN][MN];
int dp[MN][MN];
int n, k;
template <class t>
void maxi(t &x, t y) {
if (x < y) x = y;
}
template <class t>
void mini(t &x, t y) {
if (x > y) x = y;
}
void fill() {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
dp[i][j] = 0;
if (i) maxi(dp[i][j], dp[i - 1][j]);
if (j) maxi(dp[i][j], dp[i][j - 1]);
dp[i][j] += (in[i][j] == 'a');
}
}
int hashi[MN][MN];
int main() {
scanf("%d%d", &n, &k);
if (k >= 2 * n - 1) {
for (int i = 0; i < 2 * n - 1; ++i) putchar('a');
printf("\n");
return 0;
}
k = min(k, 2 * n - 1);
for (int i = 0; i < n; ++i) scanf("%s", in[i]);
fill();
for (int i = 0; i < n; ++i)
debug() << __FUNCTION__ << "#" << 76 << ": "
<< "["
"i"
": "
<< (i) << "] " << range(dp[i], dp[i] + n);
int as = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (i + j + 1 - dp[i][j] <= k) maxi(as, i + j + 1);
debug() << __FUNCTION__ << "#" << 81 << ": "
<< "["
"as"
": "
<< (as) << "] ";
if (as == 2 * n - 1) {
for (int i = 0; i < 2 * n - 1; ++i) putchar('a');
printf("\n");
return 0;
}
hashi[n - 1][n - 1] = 0;
for (int sum = 2 * n - 3; sum >= 0; --sum) {
map<int, vector<pair<int, int> > > seen;
for (int i = 0; i < n; ++i) {
int j = sum - i;
if (j < 0 || j >= n) continue;
int suf_hash = 1e9;
if (i < n - 1) mini(suf_hash, hashi[i + 1][j]);
if (j < n - 1) mini(suf_hash, hashi[i][j + 1]);
debug() << __FUNCTION__ << "#" << 96 << ": "
<< "["
"i"
": "
<< (i)
<< "] "
"["
"j"
": "
<< (j)
<< "] "
"["
"suf_hash"
": "
<< (suf_hash) << "] ";
int my_hash = in[i][j] * 1000000 + suf_hash;
seen[my_hash].emplace_back(i, j);
}
debug() << __FUNCTION__ << "#" << 101 << ": "
<< "["
"seen"
": "
<< (seen) << "] ";
int cou = 0;
for (auto &x : seen) {
for (pair<int, int> y : x.second) hashi[y.first][y.second] = cou;
cou++;
}
}
for (int i = 0; i < n; ++i)
debug() << __FUNCTION__ << "#" << 109 << ": "
<< "["
"i"
": "
<< (i) << "] " << range(hashi[i], hashi[i] + n);
pair<int, pair<int, int> > start;
start.first = 1e9;
for (int i = 0; i < n; ++i) {
int j = as - i - 1;
if (j < 0 || j >= n) continue;
if (i + j + 1 - dp[i][j] <= k) {
debug() << __FUNCTION__ << "#" << 116 << ": "
<< "["
"i"
": "
<< (i)
<< "] "
"["
"j"
": "
<< (j) << "] ";
if (i != n - 1)
mini(start, make_pair(hashi[i + 1][j], make_pair(i + 1, j)));
if (j != n - 1)
mini(start, make_pair(hashi[i][j + 1], make_pair(i, j + 1)));
}
}
string ans(as, 'a');
ans.push_back(in[start.second.first][start.second.second]);
pair<int, int> pos = start.second;
while (pos != make_pair(n - 1, n - 1)) {
if (pos.second == n - 1)
pos.first++;
else if (pos.first == n - 1)
pos.second++;
else {
if (hashi[pos.first + 1][pos.second] < hashi[pos.first][pos.second + 1])
pos.first++;
else
pos.second++;
}
ans.push_back(in[pos.first][pos.second]);
}
printf("%s\n", ans.c_str());
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(0);
int n;
cin >> n;
long long int p[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
long int prize[5];
for (int i = 0; i < 5; i++) {
cin >> prize[i];
}
for (int i = 1; i < n; i++) {
p[i] += p[i - 1];
}
long long int cost = 0;
map<long int, long long int> count;
for (int i = 0; i < 5; i++) {
count.insert(make_pair(prize[i], 0));
}
for (int i = 0; i < n; i++) {
long long int temp = p[i] - cost;
while (temp >= prize[0]) {
long int value = *prev(upper_bound(prize, prize + 5, temp));
long long int valuecount = temp / value;
long long int next = temp - (valuecount * value);
count[value] += valuecount;
cost += valuecount * value;
temp = next;
}
}
for (int i = 0; i < 5; i++) {
cout << count[prize[i]] << " ";
}
cout << endl << p[n - 1] - cost;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[505][505];
string second;
long long ans;
long long cal(long long l, long long r) {
if (l > r) return dp[l][r] = 0;
if (l == r || dp[l][r] != -1) return dp[l][r];
dp[l][r] = 1 + cal(l + 1, r);
for (int i = l + 1; i <= r; i++) {
if (second[l] == second[i])
dp[l][r] = min(dp[l][r], cal(l + 1, i - 1) + cal(i, r));
}
return dp[l][r];
}
int main() {
long long n;
cin >> n;
cin >> second;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < second.length(); i++) dp[i][i] = 1;
cout << cal(0, n - 1);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void print(std::vector<long long> const &input) {
for (int i = 0; i < input.size(); i++) {
std::cout << input.at(i) << ' ';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long nr, ng, nb, i;
cin >> nr >> ng >> nb;
vector<long long> r(nr), g(ng), b(nb);
for (i = 0; i < nr; i++) {
cin >> r[i];
}
for (i = 0; i < ng; i++) {
cin >> g[i];
}
for (i = 0; i < nb; i++) {
cin >> b[i];
}
sort(r.begin(), r.end());
sort(g.begin(), g.end());
sort(b.begin(), b.end());
vector<long long> vec;
vector<long long> first;
vector<long long> second;
vector<long long> third;
long long num;
long long counting;
long long first_take, third_take, mid1, mid3, hi1, lo1, hi3, lo3, len;
for (int p = 1; p <= 6; p++) {
if (p == 1) first = g, second = r, third = b;
if (p == 2) first = b, second = r, third = g;
if (p == 3) first = r, second = g, third = b;
if (p == 4) first = b, second = g, third = r;
if (p == 5) first = r, second = b, third = g;
if (p == 6) first = g, second = b, third = r;
long long len_first = first.size();
long long len_third = third.size();
len = second.size();
for (i = 0; i < len; i++) {
num = second[i];
hi1 = len_first - 1;
lo1 = 0;
first_take = 0;
while (lo1 <= hi1) {
mid1 = (lo1 + hi1) / 2;
if (first[mid1] == num) {
first_take = first[mid1];
break;
}
if (num > first[mid1]) {
first_take = first[mid1];
lo1 = mid1 + 1;
} else {
hi1 = mid1 - 1;
}
}
if (first_take == 0) continue;
lo3 = 0, hi3 = len_third - 1, third_take = 0;
while (lo3 <= hi3) {
mid3 = (lo3 + hi3) / 2;
if (third[mid3] == num) {
third_take = third[mid3];
break;
}
if (num > third[mid3]) {
lo3 = mid3 + 1;
} else {
third_take = third[mid3];
hi3 = mid3 - 1;
}
}
if (third_take == 0) continue;
counting = ((first_take - second[i]) * (first_take - second[i])) +
((second[i] - third_take) * (second[i] - third_take)) +
((third_take - first_take) * (third_take - first_take));
vec.push_back(counting);
}
}
sort(vec.begin(), vec.end());
cout << vec[0] << endl;
vec.clear();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int inf = 0x3f3f3f3f;
long long a[2000001], p, n, sum1, sum2, maxx;
inline int read() {
int x = 0, c = 1;
char ch = ' ';
while ((ch > '9' || ch < '0') && ch != '-') ch = getchar();
while (ch == '-') c *= -1, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return x * c;
}
int main() {
n = read();
p = read();
a[1] = read();
sum1 = a[1];
for (register int i = 2; i <= n; i++) {
a[i] = read();
sum2 += a[i];
}
maxx = sum1 % p + sum2 % p;
for (register int i = 2; i < n; i++) {
sum1 += a[i];
sum2 -= a[i];
maxx = ((maxx) > (sum1 % p + sum2 % p) ? (maxx) : (sum1 % p + sum2 % p));
}
cout << maxx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
int N;
long long B[200100];
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin.tie(0);
cin >> N;
for (int(i) = 1; (i) <= (N); (i)++) cin >> B[i];
long long cur = 0;
long long ans = 0;
for (int(i) = 1; (i) <= (N); (i)++) {
ans += abs(B[i] - cur);
cur = B[i];
}
cout << ans << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, y;
cin >> n >> x >> y;
if (n > y) {
cout << -1 << endl;
return 0;
}
long long *ans = new long long[n + 1];
for (int i = 0; i < n - 1; i++) {
ans[i] = 1;
}
ans[n - 1] = y - (n - 1);
long long xx = 0;
for (int i = 0; i < n; i++) {
xx += ans[i] * ans[i];
}
if (xx >= x) {
for (int i = 0; i < n; i++) cout << ans[i] << endl;
} else
cout << -1 << endl;
delete[] ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 25;
const int MAXV = 1000;
int n, m, n1, n2;
char mat[MAXN][MAXN];
int r0, c0, t0, rs[MAXV], cs[MAXV], ts[MAXV];
bool v[MAXV][MAXN][MAXN], cap[2 * MAXV][2 * MAXV], vis[2 * MAXV];
int from[2 * MAXV];
int vs = 2 * MAXV - 2, vt = 2 * MAXV - 1;
int id(int r, int c) { return (r - 1) * m + (c - 1); }
bool dfs(int i) {
if (vis[i]) return 0;
vis[i] = 1;
if (i == vt) return 1;
for (int j = 0; j < 2 * MAXV; j++)
if (cap[i][j] && dfs(j)) {
from[j] = i;
return 1;
}
return 0;
}
bool check(long long mid) {
memset(v, 0, sizeof(v));
memset(cap, 0, sizeof(cap));
for (int i = 0; i < n1 + n2; i++) {
long long t = mid / ts[i];
queue<pair<int, int> > que;
que.push(pair<int, int>(rs[i], cs[i]));
for (int j = 0; j <= t && !que.empty(); j++) {
int sze = que.size();
for (int k = 0; k < sze; k++) {
int r = que.front().first, c = que.front().second;
que.pop();
if (v[i][r][c]) continue;
v[i][r][c] = 1;
if (i < n1)
cap[i][id(r, c) + 2 * n1] = 1;
else
cap[id(r, c) + 2 * n1 + 500][i] = 1;
for (int dr = -1; dr <= 1; dr++)
for (int dc = -1; dc <= 1; dc++)
if ((dr == 0) != (dc == 0)) {
int nr = r + dr, nc = c + dc;
if (mat[nr][nc] == '.' && !v[i][nr][nc])
que.push(pair<int, int>(nr, nc));
}
}
}
}
for (int i = 0; i < n1; i++) cap[vs][i] = 1;
for (int i = n1; i < n1 + n2; i++) cap[i][vt] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cap[id(i, j) + 2 * n1][id(i, j) + 2 * n1 + 500] = 1;
for (int i = 0; i < n1; i++) {
memset(vis, 0, sizeof(vis));
if (!dfs(vs)) return 0;
int cur = vt;
while (cur != vs) {
int nxt = from[cur];
cap[nxt][cur] = 0;
cap[cur][nxt] = 1;
cur = nxt;
}
}
return 1;
}
int main() {
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
cin >> n >> m >> n1 >> n2;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> mat[i][j];
cin >> r0 >> c0 >> t0;
if (abs(n1 - n2) != 1) {
cout << -1;
return 0;
}
memset(rs, -1, sizeof(rs));
if (n1 < n2)
rs[n1] = r0, cs[n1] = c0, ts[n1] = t0, n1++;
else
rs[n1 + n2] = r0, cs[n1 + n2] = c0, ts[n1 + n2] = t0, n2++;
for (int i = 0; i < n1 + n2; i++)
if (rs[i] == -1) cin >> rs[i] >> cs[i] >> ts[i];
long long lo = 0, hi = 1e12;
while (lo < hi) {
long long mid = lo + (hi - lo) / 2;
if (check(mid))
hi = mid;
else
lo = mid + 1;
}
if (check(lo))
cout << lo;
else
cout << -1;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long LL_INF = (long long)2e18 + 5;
template <typename T1, typename T2>
bool minimize(T1 &a, const T2 &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
struct offer {
int x, y;
bool operator<(const offer &other) const { return x < other.x; }
};
int N, M, K;
vector<int> shovels;
vector<long long> shovel_sum;
vector<offer> offers;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> M >> K;
shovels.resize(N);
for (auto &s : shovels) cin >> s;
sort(shovels.begin(), shovels.end());
shovel_sum.assign(N + 1, 0);
for (int i = 0; i < N; i++) shovel_sum[i + 1] = shovel_sum[i] + shovels[i];
offers.resize(M);
for (auto &offer : offers) {
cin >> offer.x >> offer.y;
offer.y = offer.x - offer.y;
}
sort(offers.begin(), offers.end());
vector<long long> dp(K + 1, LL_INF);
dp[0] = 0;
for (int k = 1; k <= K; k++) {
for (auto &offer : offers) {
if (offer.x > k) break;
minimize(dp[k],
dp[k - offer.x] + shovel_sum[k] - shovel_sum[k - offer.y]);
}
minimize(dp[k], dp[k - 1] + shovels[k - 1]);
}
cout << dp[K] << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long vis[1005][1005];
set<pair<long long, long long> > s;
vector<pair<long long, long long> > temp;
map<pair<long long, long long>, vector<pair<long long, long long> > > v;
long long ans[1005][1005];
bool flag = false;
long long res = 0;
long long dfs(pair<long long, long long> p) {
if (flag) return 0;
if (s.find(p) != s.end()) {
flag = true;
return 0;
}
if (vis[p.first][p.second]) {
return ans[p.first][p.second];
}
s.insert(p);
vis[p.first][p.second] = 1;
long long tmx = 0;
for (auto j : v[p]) {
tmx = max(tmx, dfs(j));
}
ans[p.first][p.second] = tmx + 1;
res = max(res, ans[p.first][p.second]);
s.erase(p);
return ans[p.first][p.second];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
string a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
if (a[i][j] == 'D') {
temp.push_back({i, j});
if (i < n - 1)
if (a[i + 1][j] == 'I') v[{i, j}].push_back({i + 1, j});
if (i > 0)
if (a[i - 1][j] == 'I') v[{i, j}].push_back({i - 1, j});
if (j < m - 1)
if (a[i][j + 1] == 'I') v[{i, j}].push_back({i, j + 1});
if (j > 0)
if (a[i][j - 1] == 'I') v[{i, j}].push_back({i, j - 1});
} else if (a[i][j] == 'I') {
if (i < n - 1)
if (a[i + 1][j] == 'M') v[{i, j}].push_back({i + 1, j});
if (i > 0)
if (a[i - 1][j] == 'M') v[{i, j}].push_back({i - 1, j});
if (j < m - 1)
if (a[i][j + 1] == 'M') v[{i, j}].push_back({i, j + 1});
if (j > 0)
if (a[i][j - 1] == 'M') v[{i, j}].push_back({i, j - 1});
} else if (a[i][j] == 'M') {
if (i < n - 1)
if (a[i + 1][j] == 'A') v[{i, j}].push_back({i + 1, j});
if (i > 0)
if (a[i - 1][j] == 'A') v[{i, j}].push_back({i - 1, j});
if (j < m - 1)
if (a[i][j + 1] == 'A') v[{i, j}].push_back({i, j + 1});
if (j > 0)
if (a[i][j - 1] == 'A') v[{i, j}].push_back({i, j - 1});
} else if (a[i][j] == 'A') {
if (i < n - 1)
if (a[i + 1][j] == 'D') v[{i, j}].push_back({i + 1, j});
if (i > 0)
if (a[i - 1][j] == 'D') v[{i, j}].push_back({i - 1, j});
if (j < m - 1)
if (a[i][j + 1] == 'D') v[{i, j}].push_back({i, j + 1});
if (j > 0)
if (a[i][j - 1] == 'D') v[{i, j}].push_back({i, j - 1});
}
}
for (auto i : temp) {
if (!vis[i.first][i.second]) {
dfs(i);
}
}
if (flag) {
cout << "Poor Inna!";
} else {
res /= 4;
if (res)
cout << res;
else {
cout << "Poor Dima!";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
void solve() {
long long int i, j, k, n, m;
string s, t, p;
cin >> s >> t >> p;
long long int cnt = 0;
i = 0;
j = 0;
long long int ind = 0;
for (i = 0; i < s.length(); i++) {
for (j = ind; j < t.length(); j++) {
if (s[i] == t[j]) {
cnt++;
break;
}
}
ind = j + 1;
if (ind >= t.length()) break;
}
if (cnt != s.length()) {
cout << "NO" << endl;
return;
}
map<char, int> ms, mt, mp;
for (i = 0; i < s.length(); i++) ms[s[i]]++;
for (i = 0; i < p.length(); i++) mp[p[i]]++;
for (i = 0; i < t.length(); i++) mt[t[i]]++;
for (i = 0; i < t.length(); i++) {
if (mp[t[i]] + ms[t[i]] < mt[t[i]]) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int i, j, l, k, t, n;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void fastRead(int *a) {
register char c = 0;
while (c < 33) c = getchar();
*a = 0;
while (c > 33) {
*a = *a * 10 + c - '0';
c = getchar();
}
}
inline void fastWrite(int a) {
char snum[20];
int i = 0;
do {
snum[i++] = a % 10 + 48;
a = a / 10;
} while (a != 0);
i = i - 1;
while (i >= 0) putchar(snum[i--]);
putchar('\n');
}
struct matrix {
int mat[2][2];
};
matrix base;
matrix iden;
matrix setvalue(int a, int b, int c, int d) {
matrix r;
r.mat[0][0] = a;
r.mat[0][1] = b;
r.mat[1][0] = c;
r.mat[1][1] = d;
return r;
}
void print(matrix a) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) cout << a.mat[i][j] << " ";
cout << '\n';
}
}
matrix multiply(matrix a, matrix b) {
matrix r;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
long long int sum = 0;
for (int k = 0; k < 2; k++) {
sum += (long long int)a.mat[i][k] * (long long int)b.mat[k][j];
if (sum > LLONG_MAX / 3) sum %= 1000000007;
}
if (sum > 1000000007) sum %= 1000000007;
r.mat[i][j] = sum;
}
return r;
}
matrix add(matrix &a, matrix &b) {
matrix r;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
r.mat[i][j] = a.mat[i][j] + b.mat[i][j];
if (r.mat[i][j] > 1000000007) r.mat[i][j] %= 1000000007;
}
return r;
}
matrix power(matrix a, long long int p) {
if (!p) return iden;
if (p == 1) return a;
if (p % 2 == 1) return multiply(a, power(a, p - 1));
matrix r = power(a, p / 2);
r = multiply(r, r);
return r;
}
matrix nfib(long long int n) { return power(base, n - 1); }
vector<int> v;
matrix tree[4 * 100005];
matrix lazy[4 * 100005];
bool lazyflag[4 * 100005];
void build(int n, int st, int en) {
if (st == en) {
tree[n] = nfib(v[st]);
return;
}
int mid = (st + en) / 2, lc = 2 * n, rc = lc + 1;
build(lc, st, mid);
build(rc, mid + 1, en);
tree[n] = add(tree[lc], tree[rc]);
}
void process(int n, int st, int en, matrix val) {
tree[n] = multiply(tree[n], val);
lazyflag[n] = 0;
int lc = 2 * n, rc = lc + 1;
if (st != en) {
if (!lazyflag[lc])
lazy[lc] = val;
else
lazy[lc] = multiply(lazy[lc], val);
if (!lazyflag[rc])
lazy[rc] = val;
else
lazy[rc] = multiply(lazy[rc], val);
lazyflag[lc] = 1;
lazyflag[rc] = 1;
}
}
void update(int n, int st, int en, int l, int r, long long int val) {
if (lazyflag[n]) process(n, st, en, lazy[n]);
if (en < l || r < st) return;
if (l <= st && en <= r) {
process(n, st, en, power(base, val));
return;
}
int mid = (st + en) / 2, lc = 2 * n, rc = lc + 1;
update(lc, st, mid, l, r, val);
update(rc, mid + 1, en, l, r, val);
tree[n] = add(tree[lc], tree[rc]);
}
int query(int n, int st, int en, int l, int r) {
if (lazyflag[n]) process(n, st, en, lazy[n]);
if (en < l || r < st) return 0;
if (l <= st && en <= r) return tree[n].mat[0][0];
int mid = (st + en) / 2, lc = 2 * n, rc = lc + 1;
int q1 = query(lc, st, mid, l, r);
int q2 = query(rc, mid + 1, en, l, r);
int ret = q1 + q2;
if (ret > 1000000007) ret %= 1000000007;
return ret;
}
int main() {
int n, q, inp, l, r, op;
base = setvalue(1, 1, 1, 0);
iden = setvalue(1, 0, 0, 1);
scanf("%d %d", &n, &q);
v.push_back(1);
for (int i = 0; i < n; i++) {
scanf("%d", &inp);
v.push_back(inp);
}
build(1, 1, n);
for (int j = 0; j < q; j++) {
scanf("%d %d %d", &op, &l, &r);
if (op == 1) {
scanf("%d", &inp);
update(1, 1, n, l, r, inp);
} else
printf("%d\n", query(1, 1, n, l, r));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000009;
const int MX = 100005;
const double EPS = 1e-9;
const int MOD = 1000000007;
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
map<long long, long long> pf;
map<long long, long long>::iterator it;
void precal(long long n) {
while ((n % 2) == 0) {
pf[2]++;
n /= 2;
}
for (long long i = 3; i <= sqrtl(n); i++) {
while (n % i == 0) {
pf[i]++;
n /= i;
}
}
if (n > 1) pf[n]++;
}
int main() {
long long n = ({
long long a;
read(a);
a;
});
if (n % 2 == 0)
cout << n / 2 << '\n';
else {
precal(n);
it = pf.begin();
n -= it->first;
cout << (n / 2) + 1 << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160000")
using namespace std;
void redirectIO() {
ios::sync_with_stdio(false);
cin.tie(0);
}
map<int, int> lines;
int main() {
redirectIO();
int n;
cin >> n;
for (int i = 0; i < (n); i++) {
int r;
cin >> r;
for (int j = 0; j < (r); j++) {
int a;
cin >> a;
lines[a]++;
}
}
for (pair<int, int> x : lines) {
if (x.second == n) cout << x.first << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
string s;
cin >> s;
map<char, int> mm;
for (int i = 0; i < n; i++) {
mm[s[i]]++;
}
int kol = 0;
int res = 0;
char last;
for (auto q : mm) {
if (kol == k) break;
if (kol == 0) {
last = q.first;
res += (int)q.first - (int)'a' + 1;
kol++;
} else {
if ((int)q.first != (int)last + 1) {
last = q.first;
res += (int)q.first - (int)'a' + 1;
kol++;
}
}
}
if (kol < k) {
cout << -1 << endl;
return 0;
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 100000007;
const int MAXN = 1000000;
const int inf = 0x3f3f3f3f;
int n, a[200005], b[200005];
int book[200005];
bool check(int x) {
memset(book, 0, sizeof(book));
for (int i = 1; i <= n; i++) {
if (a[i] == 1) book[i] = 0;
}
if (x <= n) {
int t = 1;
for (int i = x + 1; i <= n; i++) {
if (b[i] == t)
t++;
else
return false;
}
for (int i = 1; i <= x; i++) {
if (b[i] != 0) book[b[i]] = i;
}
int now = 0;
for (int i = n - x + 1; i <= n; i++) {
if (book[i] <= now)
now++;
else
return false;
}
return true;
} else {
for (int i = 1; i <= x - n; i++) {
if (b[i] != 0) book[b[i]] = 0;
}
int t = 0;
for (int i = x - n + 1; i <= n; i++) {
t++;
if (b[i] != 0) book[b[i]] = t;
}
int now = 0;
for (int i = 1; i <= n; i++) {
if (book[i] <= now)
now++;
else
return false;
}
return true;
}
}
int main() {
scanf("%d", &n);
int pos1 = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x == 1) pos1 = 0;
if (x != 0) a[x] = 1;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
if (b[i] == 1) pos1 = i;
}
int r = 2 * n + 10, l = n;
if (pos1 != 0 && check(pos1 - 1)) {
printf("%d\n", pos1 - 1);
return 0;
} else {
while (r > l + 1) {
int mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (check(l))
printf("%d\n", l);
else
printf("%d\n", r);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p[200005], q[200005];
int n;
bool vis[200005];
int main() {
cin >> n;
int sum = 0, mn = 0, mx = 0;
for (int i = 1; i < n; i++) {
cin >> q[i];
if (q[i] == 0 || q[i] <= -n || q[i] >= n) return cout << "-1\n", 0;
sum += q[i];
mn = min(mn, sum);
mx = max(mx, sum);
}
if (mx - mn + 1 == n) {
int tmp = abs(mn) + 1;
vis[tmp] = 1;
for (int i = 1; i < n; i++) {
tmp += q[i];
if (vis[tmp]) return cout << "-1\n", 0;
vis[tmp] = 1;
}
tmp = abs(mn) + 1;
cout << tmp << " ";
for (int i = 1; i < n; i++) {
tmp += q[i];
cout << tmp << " ";
}
cout << endl;
} else
cout << "-1\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dxx[] = {0, 0, 1, -1, -1, 1, -1, 1};
int dyy[] = {1, -1, 0, 0, -1, 1, 1, -1};
bool sortbysec(const pair<int, int>& a, const pair<int, int>& b) {
return (a.second < b.second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n;
map<string, int> m;
cin >> n;
stack<string> q;
for (int i = 0; i < n; i++) {
string k;
cin >> k;
q.push(k);
}
while (!q.empty()) {
string s = q.top();
if (!m[s]) cout << s << '\n';
m[s]++;
q.pop();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void rset();
void init_test();
void solve();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(20);
init_test();
return 0;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
template <typename T>
void MACRO_rdv2_Init(long long n, T& t) {
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_rdv2_Init(long long n, First& first, Rest&... rest) {
first.resize(n);
MACRO_rdv2_Init(n, rest...);
}
template <typename T>
void MACRO_rdv2_Scan(long long p, T& t) {
std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_rdv2_Scan(long long p, First& first, Rest&... rest) {
std::cin >> first[p];
MACRO_rdv2_Scan(p, rest...);
}
template <typename T>
void wrv(const vector<T>& v) {
for (long long(__ii) = (0); (__ii) < (((long long)v.size())); ++(__ii)) {
if (__ii) cout << ' ';
cout << v[__ii];
}
cout << '\n';
}
template <typename T>
void wrm(const vector<vector<T>>& v) {
for (long long(__ii) = (0); (__ii) < (((long long)v.size())); ++(__ii)) {
for (long long(__jj) = (0); (__jj) < (v[__ii].size()); ++(__jj)) {
if (__jj) cout << ' ';
cout << v[__ii][__jj];
}
cout << '\n';
}
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void wr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void wr(const Head& head, const Tail&... tail) {
cout << head << ' ';
wr(tail...);
}
template <typename T>
void wrf(const T& x) {
cout << x << endl;
}
template <typename Head, typename... Tail>
void wrf(const Head& head, const Tail&... tail) {
cout << head << ' ';
wrf(tail...);
}
template <typename T>
void debug_out(const T& x) {
cerr << x << '\n';
}
template <typename Head, typename... Tail>
void debug_out(const Head& head, const Tail&... tail) {
cerr << head << ' ';
debug_out(tail...);
}
template <typename... T>
void err(const T&... cod) {
wr(cod...);
exit(0);
}
void solve() {
long long n;
sc(n);
vector<long long> a(n);
for (long long(__ii) = (0); (__ii) < (n); ++(__ii)) cin >> a[__ii];
if (accumulate(a.begin(), a.end(), 0LL) % n != 0) {
wr(-1);
return;
};
long long s = accumulate(a.begin(), a.end(), 0LL) / n;
vector<pair<pair<long long, long long>, long long>> ans;
for (long long(i) = (1); (i) < (n); ++(i)) {
if (a[i] % (i + 1)) {
long long k = (i + 1) - (a[i] % (i + 1));
ans.push_back(make_pair(make_pair(1, i + 1), k));
a[i] += k;
a[0] -= k;
}
long long k = a[i] / (i + 1);
ans.push_back(make_pair(make_pair(i + 1, 1), k));
a[0] += k * (i + 1);
a[i] -= k * (i + 1);
}
for (long long(i) = (1); (i) < (n); ++(i)) {
ans.push_back(make_pair(make_pair(1, i + 1), s));
a[0] -= s;
a[i] += s;
}
wr(((long long)ans.size()));
for (long long(i) = (0); (i) < (((long long)ans.size())); ++(i)) {
wr(ans[i].first.first, ans[i].first.second, ans[i].second);
}
}
void init_test() {
long long qq = 1;
cin >> qq;
while (qq--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
int r, op[N], tt, f[N], st[N], tp;
long long ans[N];
vector<int> E[N];
void dp(int u) {
if (!op[u])
f[u] = 1;
else if (op[u] == 1)
f[u] = 0;
else
f[u] = 1e9;
for (auto v : E[u]) {
dp(v);
if (op[u] == 1)
f[u] += f[v];
else
f[u] = min(f[u], f[v]);
}
}
void getans(int u, int w) {
if (!op[u]) {
ans[u] = 1ll * w * r;
return;
}
if (op[u] == 2) {
for (auto v : E[u])
if (f[u] == f[v]) {
getans(v, w);
break;
}
} else {
for (auto v : E[u]) getans(v, w);
}
}
int main() {
int T = gi();
while (T--) {
r = gi();
tt = 0;
while (1) {
char ch = getchar();
if (ch == '\n') break;
if (ch == ' ') continue;
if (ch == '(') {
if (tp) E[st[tp]].push_back(tt + 1);
++tt;
E[tt].clear();
st[++tp] = tt;
} else if (ch == ')')
--tp;
else if (ch == 'P')
op[st[tp]] = 1;
else if (ch == 'S')
op[st[tp]] = 2;
else {
if (tp) E[st[tp]].push_back(tt + 1);
++tt, op[tt] = 0, E[tt].clear();
}
}
for (int i = 1; i <= tt; i++) ans[i] = 0;
dp(1);
getans(1, f[1]);
cout << "REVOLTING ";
for (int i = 1; i <= tt; i++)
if (!op[i]) cout << ans[i] << ' ';
cout << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
template <class T>
void Read(T& ret) {
ret = 0;
bool ok = 0, u = 0;
for (;;) {
int c = getchar();
if (c >= '0' && c <= '9')
ret = (ret << 3) + (ret << 1) + c - '0', ok = 1;
else if (c == '-')
u = 1;
else if (ok) {
if (u) ret *= -1;
return;
}
}
}
long long pow_mod(long long p, long long n, long long mod) {
long long ret = 1;
for (; n; n >>= 1) {
if (n & 1) ret = ret * p % mod;
p = p * p % mod;
}
return ret;
}
template <class T>
bool chmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool chmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
using namespace std;
int _;
struct seg {
int l, r;
int p;
};
pair<int, pair<int, int> > temp1, temp2;
bool operator==(const seg& x, const seg& y) {
return x.l == y.l && x.r == y.r && x.p == y.p;
}
bool operator<(const seg& x, const seg& y) {
temp1.first = x.r;
temp1.second.first = x.l;
temp1.second.second = x.p;
temp2.first = y.r;
temp2.second.first = y.l;
temp2.second.second = y.p;
return temp1 < temp2;
}
bool cmp(seg x, seg y) {
temp1.first = x.p;
temp1.second.first = x.l;
temp1.second.second = x.r;
temp2.first = y.p;
temp2.second.first = y.l;
temp2.second.second = y.r;
return temp1 < temp2;
}
bool cmp2(seg x, seg y) { return x.l < y.l; }
struct BIT {
const static int Max_N = 500005;
int c[Max_N], n;
void add(int x, int d) {
while (x <= n) c[x] += d, x += ((x) & (-x));
}
int sum(int x) {
int ret = 0;
while (x > 0) ret += c[x], x -= ((x) & (-x));
return ret;
}
int sum(int l, int r) { return l > r ? 0 : sum(r) - sum(l - 1); }
} bit;
vector<seg> H, C;
set<seg> st;
map<int, int> has;
int cope() {
set<int> t1;
map<int, int> t2;
for (auto i : C) {
t1.insert(i.p);
}
for (auto i : H) {
t1.insert(i.l);
t1.insert(i.r);
}
int t = 0;
for (auto i : t1) t2[i] = ++t;
for (auto& i : C) {
i.p = t2[i.p];
}
for (auto& i : H) {
i.l = t2[i.l];
i.r = t2[i.r];
}
return t;
}
void erase() {
auto it = has.find(st.begin()->p);
if (it->second == 1) {
bit.add(st.begin()->p, -1);
has.erase(it);
} else {
has[st.begin()->p] -= 1;
}
st.erase(st.begin());
}
void add(const seg& t) {
st.insert(t);
auto it = has.find(t.p);
if (it == has.end()) {
bit.add(t.p, 1);
has[t.p] = 1;
} else {
has[t.p] += 1;
}
}
int query(int l, int r) { return bit.sum(l, r); }
int main() {
int n;
while (cin >> n) {
seg tmp;
for (int i = 0, x1, y1, x2, y2; i < n; ++i) {
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
tmp.l = min(y1, y2);
tmp.r = max(y1, y2);
tmp.p = x1;
C.push_back(tmp);
} else {
tmp.l = min(x1, x2);
tmp.r = max(x1, x2);
tmp.p = y1;
H.push_back(tmp);
}
}
sort((H).begin(), (H).end()),
(H).erase(unique((H).begin(), (H).end()), (H).end());
sort((C).begin(), (C).end()),
(C).erase(unique((C).begin(), (C).end()), (C).end());
long long ans = 0;
sort(H.begin(), H.end(), cmp);
sort(C.begin(), C.end(), cmp);
int pre = -(1 << 30), mx = pre;
for (auto i : H) {
if (i.p != pre) {
mx = -(1 << 30);
pre = i.p;
}
if (i.l <= mx) ans -= min(mx, i.r) - i.l + 1;
ans += i.r - i.l + 1;
chmax(mx, i.r);
}
pre = -(1 << 30);
mx = pre;
for (auto i : C) {
if (i.p != pre) {
mx = -(1 << 30);
pre = i.p;
}
if (i.l <= mx) ans -= min(mx, i.r) - i.l + 1;
ans += i.r - i.l + 1;
chmax(mx, i.r);
}
bit.n = cope();
sort(C.begin(), C.end(), cmp2);
int idx = 0;
mx = -(1 << 30);
for (auto i : H) {
if (pre != i.p) {
for (; idx < ((int)(C).size()); ++idx) {
if (C[idx].l > i.p) break;
add(C[idx]);
}
while (!st.empty()) {
if (st.begin()->r >= i.p) break;
erase();
}
pre = i.p;
mx = -(1 << 30);
}
if (i.l > mx)
ans -= query(i.l, i.r);
else if (i.r > mx)
ans -= query(mx + 1, i.r);
chmax(mx, i.r);
}
cout << ans;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline long long add(long long a, long long b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
inline long long sub(long long a, long long b) {
a -= b;
if (a < 0) a += mod;
return a;
}
inline long long mul(long long a, long long b) {
return (long long)((long long)a * b % mod);
}
long long n;
long long fun(long long cnt, long long i, long long a[]) {
while (i <= n && cnt > 0) {
if (i != n) {
if (a[i] > a[i + 1]) {
cnt--;
}
}
i++;
}
return i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
cin >> t;
while (t--) {
cin >> n;
long long a[n + 1];
for (long long i = (1); i <= (n); i++) cin >> a[i];
long long h = 1;
long long cnt = 1, j = 2;
while (1) {
long long k = fun(cnt, j, a);
h++;
cnt = k - j;
j = k;
if (k > n) break;
}
cout << h - 1 << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long i, j, l, r, a[4][4], opt[5][5];
string s, t;
memset(opt, 0, sizeof(opt));
for (i = 1; i <= 3; i++)
for (j = 1; j <= 3; j++) {
cin >> a[i][j];
opt[i][j] = a[i][j];
}
for (i = 1; i <= 3; i++) {
for (j = 1; j <= 3; j++) {
if (a[i][j] > 0) {
opt[i - 1][j] += a[i][j];
opt[i][j - 1] += a[i][j];
opt[i][j + 1] += a[i][j];
opt[i + 1][j] += a[i][j];
}
}
}
for (long i = 1; i <= 3; i++) {
for (long j = 1; j <= 3; j++) {
if (opt[i][j] % 2 == 0)
cout << 1;
else
cout << 0;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
template <class T>
inline bool rd(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void pt(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) pt(x / 10);
putchar(x % 10 + '0');
}
using namespace std;
const int N = 5005;
const int inf = 1000000;
int n, k;
long long a[N];
int hehe;
int dd;
set<long long> myset;
long long work(long long x) {
long long ans = inf;
for (int i = 1; i <= n; i++) {
if (x % a[i] == 0 && x / a[i] <= k) ans = min(ans, x / a[i]);
for (int j = 0; j <= k; j++) {
long long y = x - a[i] * j;
for (int z = 1; z <= k; z++) {
if (z + j > k) break;
if (y % z == 0 && myset.count(y / z)) ans = min(ans, (long long)z + j);
}
}
}
if (ans == inf) return -1;
return ans;
}
int main() {
cin >> n >> k;
myset.clear();
for (int i = 1; i <= n; i++) rd(a[i]), myset.insert(a[i]);
int q;
rd(q);
while (q--) {
long long x;
rd(x);
pt(work(x));
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int i, j, k, n, f = 0, x;
scanf("%d", &n);
int a[n];
for (i = 0; i < n - 1; i++) {
scanf("%d", &a[i]);
}
k = n - 1;
std::sort(a, a + k);
for (i = 0, j = 1; i < n - 1; j++, i++) {
if (a[i] != j) {
f = 1;
x = j;
break;
}
}
if (f == 1)
printf("%d", x);
else
printf("%d", n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50 + 5;
char a[maxn][maxn];
int s[maxn][maxn];
int dp[maxn][maxn][maxn][maxn];
int n;
int d(int x1, int y1, int x2, int y2) {
if (x1 > x2 || y1 > y2) return 0;
if (dp[x1][y1][x2][y2] != -1) return dp[x1][y1][x2][y2];
int &tt = dp[x1][y1][x2][y2];
if (s[x2][y2] + s[x1 - 1][y1 - 1] - s[x1 - 1][y2] - s[x2][y1 - 1] == 0)
return tt = 0;
tt = max(y2 - y1, x2 - x1) + 1;
for (int i = (x1); i <= (x2); i++) {
if ((s[i][y2] - s[i - 1][y2]) - (s[i][y1 - 1] - s[i - 1][y1 - 1]) == 0)
tt = min(tt, d(x1, y1, i - 1, y2) + d(i + 1, y1, x2, y2));
}
for (int j = (y1); j <= (y2); j++) {
if ((s[x2][j] - s[x2][j - 1]) - (s[x1 - 1][j] - s[x1 - 1][j - 1]) == 0)
tt = min(tt, d(x1, y1, x2, j - 1) + d(x1, j + 1, x2, y2));
}
return tt;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = (1); i <= (n); i++) scanf("%s", a[i] + 1);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + (a[i][j] == '#');
cout << d(1, 1, n, n) << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<long long, long long>, pair<long long, long long> > > vc;
long long n, dp[109][2009], path[109][2009];
long long maximum(long long ind, long long time) {
if (ind > n) return 0;
if (~dp[ind][time]) return dp[ind][time];
long long ret1 = maximum(ind + 1, time);
long long ret2 = -1;
if (time + vc[ind].second.first < vc[ind].first.first)
ret2 =
vc[ind].second.second + maximum(ind + 1, time + vc[ind].second.first);
if (ret1 > ret2)
path[ind][time] = 1;
else
path[ind][time] = 0;
return dp[ind][time] = max(ret1, ret2);
}
int main() {
long long t, d, p;
cin >> n;
memset(dp, -1, sizeof dp);
memset(path, -1, sizeof path);
vc.push_back({{-1, -1}, {-1, -1}});
for (long long i = 1; i <= n; i++) {
cin >> t >> d >> p;
vc.push_back({{d, i}, {t, p}});
}
sort(vc.begin(), vc.end());
cout << maximum(1, 0) << endl;
vector<long long> vv;
long long ind = 1, time = 0;
while (ind <= n) {
if (path[ind][time] == 0) {
vv.push_back(vc[ind].first.second);
time += vc[ind].second.first;
}
ind++;
}
cout << vv.size() << endl;
for (long long i = 0; i < vv.size(); i++) cout << vv[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void PrintArrInt(int arr[], int s, int e) {
for (int i = (s); i <= (e); i++) printf("%d%c", arr[i], i == e ? '\n' : ' ');
}
const int maxn = 3e5 + 5;
int N, M, wval[maxn];
char str[maxn];
vector<int> ft[maxn];
struct Trie {
int nxt[maxn][26], fail[maxn], ed[maxn], wpos[maxn];
int root, cnt;
multiset<int> se[maxn];
int newnode() {
memset(nxt[cnt], -1, sizeof(nxt[cnt]));
ed[cnt++] = 0;
return cnt - 1;
}
void init() {
cnt = 0;
root = newnode();
}
void insert(char buf[], int idx) {
int now = root;
for (int i = 0; buf[i]; i++) {
if (nxt[now][buf[i] - 'a'] == -1) nxt[now][buf[i] - 'a'] = newnode();
now = nxt[now][buf[i] - 'a'];
}
wpos[idx] = now;
se[now].insert(0);
}
void getfail() {
queue<int> q;
fail[root] = root;
for (int i = (0); i <= (25); i++) {
if (nxt[root][i] == -1)
nxt[root][i] = root;
else {
fail[nxt[root][i]] = root;
q.push(nxt[root][i]);
}
}
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = (0); i <= (25); i++) {
if (nxt[now][i] == -1)
nxt[now][i] = nxt[fail[now]][i];
else {
fail[nxt[now][i]] = nxt[fail[now]][i];
q.push(nxt[now][i]);
}
}
}
for (int i = (1); i <= (cnt - 1); i++) ft[fail[i]].push_back(i);
}
} tr;
int sz[maxn], son[maxn], fa[maxn];
void dfs1(int u, int f) {
sz[u] = 1;
fa[u] = f;
int mxsz = 0;
for (int v : ft[u]) {
dfs1(v, u);
sz[u] += sz[v];
if (mxsz < sz[v]) mxsz = sz[v], son[u] = v;
}
}
int top[maxn], dfn[maxn], rdfn[maxn], dtfn;
void dfs2(int u, int up) {
top[u] = up;
dfn[u] = ++dtfn;
rdfn[dtfn] = u;
if (son[u]) dfs2(son[u], up);
for (int v : ft[u]) {
if (v == son[u]) continue;
dfs2(v, v);
}
}
int maxv[maxn * 4];
void build(int o, int L, int R) {
if (L == R) {
if (tr.se[rdfn[L]].size())
maxv[o] = 0;
else
maxv[o] = -1;
return;
}
int mid = (L + R) >> 1;
build(o * 2, L, mid);
build(o * 2 + 1, mid + 1, R);
maxv[o] = max(maxv[o * 2], maxv[o * 2 + 1]);
}
void update(int o, int L, int R, int pos, int val) {
if (L == R) {
maxv[o] = val;
return;
}
int mid = (L + R) >> 1;
if (pos <= mid)
update(o * 2, L, mid, pos, val);
else
update(o * 2 + 1, mid + 1, R, pos, val);
maxv[o] = max(maxv[o * 2], maxv[o * 2 + 1]);
}
int getmax(int o, int L, int R, int lft, int rht) {
if (L >= lft && rht >= R) return maxv[o];
int mid = (L + R) >> 1, res = -1;
if (lft <= mid) res = getmax(o * 2, L, mid, lft, rht);
if (rht > mid) res = max(res, getmax(o * 2 + 1, mid + 1, R, lft, rht));
return res;
}
int query_from_root(int u) {
int res = -1;
while (u > 0) {
res = max(res, getmax(1, 1, tr.cnt, dfn[top[u]], dfn[u]));
u = fa[top[u]];
}
return res;
}
int main() {
scanf("%d%d", &(N), &(M));
tr.init();
for (int i = (1); i <= (N); i++) {
scanf("%s", str);
tr.insert(str, i);
}
tr.getfail();
dfs1(0, -1);
dfs2(0, 0);
build(1, 1, tr.cnt);
int op, idx, x;
for (int i = (1); i <= (M); i++) {
scanf("%d", &(op));
if (op == 1) {
scanf("%d%d", &(idx), &(x));
int n = tr.wpos[idx], t = *tr.se[n].rbegin();
tr.se[n].erase(tr.se[n].find(wval[idx]));
tr.se[n].insert(x);
wval[idx] = x;
if (*tr.se[n].rbegin() == t) continue;
update(1, 1, tr.cnt, dfn[n], *tr.se[n].rbegin());
} else {
scanf("%s", str);
int now = 0, ans = -1;
for (int i = 0; str[i]; i++) {
now = tr.nxt[now][str[i] - 'a'];
ans = max(ans, query_from_root(now));
}
printf("%d\n", (ans));
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
int n, siz[MAXN], son[MAXN];
vector<int> e[MAXN], root;
struct Op {
int x, y, z;
Op() {}
Op(int _x, int _y, int _z) : x(_x), y(_y), z(_z) {}
};
vector<Op> ans;
void GetRoot(int u, int fa) {
siz[u] = 1;
son[u] = 0;
for (auto v : e[u]) {
if (v == fa) continue;
GetRoot(v, u);
son[u] = max(son[u], siz[v]);
siz[u] += siz[v];
}
son[u] = max(son[u], n - siz[u]);
if (son[u] < son[root[0]]) {
root.clear();
root.push_back(u);
} else if (son[u] == son[root[0]]) {
root.push_back(u);
}
}
void DFS(int u, int fa, int C, int p, int &q) {
if (u != p) {
ans.push_back(Op(C, q, u));
q = u;
ans.push_back(Op(u, fa, p));
}
for (auto v : e[u]) {
if (v == fa) continue;
DFS(v, u, C, p, q);
}
}
void Work(int C, int C2) {
for (auto v : e[C]) {
if (v == C2) continue;
int q = v;
DFS(v, C, C, v, q);
ans.push_back(Op(C, q, v));
}
}
void init() {
read(n);
for (int i = 1, u, v; i < n; ++i) {
read(u);
read(v);
e[u].push_back(v);
e[v].push_back(u);
}
}
void solve() {
son[0] = n;
root.push_back(0);
GetRoot(1, 0);
if (root.size() == 1) {
Work(root[0], 0);
} else {
Work(root[0], root[1]);
Work(root[1], root[0]);
}
printf("%d\n", ans.size());
for (auto op : ans) {
printf("%d %d %d\n", op.x, op.y, op.z);
}
}
int main() {
init();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> a;
int x[1005];
int n, i, Ans, tag;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &x[i]), a[x[i]]++;
for (i = 1; i <= n; i++) {
if (x[i] == 0) continue;
if (a[x[i]] == 2) Ans++;
if (a[x[i]] > 2) tag = 1;
}
if (tag == 1)
printf("-1\n");
else
printf("%d\n", (Ans >> 1));
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.