solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int MODP(long long x) {
int r = x % 1000000007;
if (r < 0) r += 1000000007;
return r;
}
template <class T, class Q>
using TreeMergeFunction = function<Q(const Q &, const Q &)>;
template <class T, class Q>
using TreeUpdateLeafFunction =
function<Q(const Q &, const T &, const T &, int, int)>;
template <class T, class Q>
using TreeSplitFunction = function<void(Q &, Q &, Q &, T, int, int, int)>;
template <class T, class Q>
using TreeInitFunction = function<Q(const T &, int, int)>;
template <class T, class Q>
struct SegmentTree {
struct TreeNode {
bool leaf = true;
T value;
Q query;
int leftChild = -1, rightChild = -1;
};
protected:
vector<TreeNode> node;
TreeMergeFunction<T, Q> merge;
TreeUpdateLeafFunction<T, Q> updateLeaf;
TreeSplitFunction<T, Q> split;
TreeInitFunction<T, Q> init;
const T defaultValue;
int addNode(int l, int r) {
TreeNode newNode;
newNode.value = defaultValue;
node.push_back(newNode);
return (int)node.size() - 1;
}
void splitNode(int p, int l, int r) {
assert(node[p].leaf);
int m = (l + r) / 2;
node[p].leaf = false;
if (node[p].leftChild == -1) {
int c = addNode(l, m);
node[p].leftChild = c;
c = addNode(m + 1, r);
node[p].rightChild = c;
}
int lc = node[p].leftChild;
int rc = node[p].rightChild;
node[lc].leaf = true;
node[rc].leaf = true;
node[lc].value = node[p].value;
node[rc].value = node[p].value;
split(node[p].query, node[lc].query, node[rc].query, node[p].value, l, m,
r);
}
void update(int p, int l, int r, int i, int j, const T &v) {
if (j < l || i > r) return;
int m = (l + r) / 2;
if (i <= l && r <= j) {
if (node[p].leaf) {
node[p].query = updateLeaf(node[p].query, node[p].value, v, l, r);
node[p].value = v;
return;
} else {
node[p].leaf = true;
node[p].value = v;
}
} else if (node[p].leaf) {
splitNode(p, l, r);
}
update(node[p].leftChild, l, m, i, j, v);
update(node[p].rightChild, m + 1, r, i, j, v);
node[p].query =
merge(node[node[p].leftChild].query, node[node[p].rightChild].query);
}
Q query(int p, int l, int r, int i, int j) {
if (i <= l && r <= j) {
return node[p].query;
}
if (node[p].leaf) {
splitNode(p, l, r);
}
int m = (l + r) / 2;
Q ret;
if (j <= m) {
ret = query(node[p].leftChild, l, m, i, j);
} else if (i >= m + 1) {
ret = query(node[p].rightChild, m + 1, r, i, j);
} else {
ret = merge(query(node[p].leftChild, l, m, i, j),
query(node[p].rightChild, m + 1, r, i, j));
}
node[p].query =
merge(node[node[p].leftChild].query, node[node[p].rightChild].query);
return ret;
}
int minIndex, maxIndex;
int root;
public:
explicit SegmentTree(int minIndex, int maxIndex, T defaultValue,
const TreeMergeFunction<T, Q> &merge,
const TreeUpdateLeafFunction<T, Q> &updateLeaf,
const TreeSplitFunction<T, Q> &split)
: merge(merge),
updateLeaf(updateLeaf),
split(split),
defaultValue(defaultValue),
minIndex(minIndex),
maxIndex(maxIndex) {
root = addNode(minIndex, maxIndex);
}
SegmentTree(int minIndex, int maxIndex, T defaultValue,
const TreeMergeFunction<T, Q> &merge,
const function<Q(T, int, int)> &init)
: merge(merge),
defaultValue(defaultValue),
minIndex(minIndex),
maxIndex(maxIndex),
init(init) {
updateLeaf = [&](const Q &cur, T oldV, T curV, int l, int r) {
return this->init(curV, l, r);
};
split = [&](Q &cur, Q &lQ, Q &rQ, T v, int l, int m, int r) {
lQ = this->init(v, l, m);
rQ = this->init(v, m + 1, r);
};
root = addNode(minIndex, maxIndex);
}
void update(int i, int j, T v) { update(root, minIndex, maxIndex, i, j, v); }
Q query(int i, int j) { return query(root, minIndex, maxIndex, i, j); }
Q query() { return query(root, minIndex, maxIndex, minIndex, maxIndex); }
};
void testGen() {
freopen("biginput1.txt", "w", stdout);
fclose(stdout);
}
int nRow, nCol, k, q;
vector<pair<int, int>> rook;
vector<vector<int>> row;
struct Query {
int r1, c1, r2, c2, id;
};
vector<Query> query;
vector<int> goodQuery;
void solve() {
row.clear();
row.resize(nRow + 1);
for (auto &r : rook) {
row[r.first].push_back(r.second);
}
sort(query.begin(), query.end(),
[&](const Query &a, const Query &b) { return a.r2 < b.r2; });
SegmentTree<int, int> lastR(
1, nCol, 0, [](int x, int y) { return min(x, y); },
[](int v, int l, int r) { return v; });
int qId = 0;
for (auto i = 1; i <= nRow; ++i) {
for (auto &c : row[i]) {
lastR.update(c, c, i);
if (1 <= 0) cout << "Update " << i << " " << c << endl;
}
while (qId < query.size() && query[qId].r2 <= i) {
if (1 <= 0)
cout << "Process query: " << query[qId].r1 << " " << query[qId].c1
<< " " << query[qId].r2 << " " << query[qId].c2 << endl;
int minR = lastR.query(query[qId].c1, query[qId].c2);
if (1 <= 0) cout << "minR " << minR << endl;
if (query[qId].r1 > minR) {
if (1 <= 0) cout << "Bad" << endl;
goodQuery[query[qId].id]--;
}
++qId;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> nCol >> nRow >> k >> q;
for (auto repeat_var = 0; repeat_var < k; ++repeat_var) {
int r, c;
cin >> c >> r;
rook.push_back(make_pair(r, c));
}
goodQuery.resize(q);
for (auto i = 0; i < q; ++i) {
goodQuery[i] = 2;
int r1, c1, r2, c2;
cin >> c1 >> r1 >> c2 >> r2;
query.push_back(Query{r1, c1, r2, c2, i});
}
solve();
if (1 <= 0) cout << "Flipping..." << endl;
swap(nCol, nRow);
for (auto i = 0; i < rook.size(); ++i) {
rook[i] = make_pair(rook[i].second, rook[i].first);
}
for (auto i = 0; i < q; ++i) {
query[i] =
Query{query[i].c1, query[i].r1, query[i].c2, query[i].r2, query[i].id};
}
solve();
for (auto i = 0; i < q; ++i) {
if (goodQuery[i] > 0)
cout << "YES";
else
cout << "NO";
cout << endl;
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 10;
int n, m;
vector<pair<int, int> > vertex[maxn];
bool mark[maxn];
stack<int> f[maxn];
stack<int> adj[maxn];
int build(int v) {
for (int i = 0; i < ((int(vertex[v].size()))); i++) {
int u = vertex[v][i].first, e = vertex[v][i].second;
if (!mark[e]) {
adj[v].push(u);
mark[e] = true;
}
}
while (!adj[v].empty()) {
int u = adj[v].top();
adj[v].pop();
int w = build(u);
if (w == 0)
f[v].push(u);
else
printf("%d %d %d\n", v, u, w);
}
while (((int(f[v].size()))) >= 2) {
int u = f[v].top();
f[v].pop();
int w = f[v].top();
f[v].pop();
printf("%d %d %d\n", u, v, w);
}
if (!f[v].empty()) {
int w = f[v].top();
f[v].pop();
return w;
} else
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
vertex[u].push_back(make_pair(v, i));
vertex[v].push_back(make_pair(u, i));
}
if (m & 1) {
printf("No solution");
return 0;
}
build(1);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<string> v;
for (long long i = 0; i < n; i = i + 1) {
string h;
cin >> h;
v.push_back(h);
}
pair<long long, long long> s, t;
for (long long i = 0; i < n; i = i + 1) {
for (long long j = 0; j < m; j = j + 1) {
if (v[i][j] == 'S') s = pair<long long, long long>(i, j);
if (v[i][j] == 'T') t = pair<long long, long long>(i, j);
}
}
long long d[n][m];
memset(d, -1, sizeof(d));
d[s.first][s.second] = -1;
queue<pair<long long, long long> > q;
q.push(s);
v[t.first][t.second] = '.';
while (!q.empty()) {
long long i = q.front().first, j = q.front().second;
q.pop();
for (int y = i + 1; y < n; y++) {
if ((d[y][j] == -1 || 1 + d[i][j] <= d[y][j]) && v[y][j] == '.') {
d[y][j] = 1 + d[i][j];
q.push(pair<long long, long long>(y, j));
} else
break;
}
for (int y = i - 1; y >= 0; y--) {
if ((d[y][j] == -1 || 1 + d[i][j] <= d[y][j]) && v[y][j] == '.') {
d[y][j] = 1 + d[i][j];
q.push(pair<long long, long long>(y, j));
} else
break;
}
for (int x = j + 1; x < m; x++) {
if ((d[i][x] == -1 || 1 + d[i][j] <= d[i][x]) && v[i][x] == '.') {
d[i][x] = 1 + d[i][j];
q.push(pair<long long, long long>(i, x));
} else
break;
}
for (int x = j - 1; x >= 0; x--) {
if ((d[i][x] == -1 || 1 + d[i][j] <= d[i][x]) && v[i][x] == '.') {
d[i][x] = 1 + d[i][j];
q.push(pair<long long, long long>(i, x));
} else
break;
}
if (d[t.first][t.second] != -1) {
if (d[t.first][t.second] > 2) {
cout << "NO\n";
break;
} else {
cout << "YES";
return 0;
}
}
}
if (d[t.first][t.second] == -1) {
cout << "NO";
}
}
| 8
|
#include <bits/stdc++.h>
long long rnb[40 + 1];
int main() {
long long n;
int nrb;
scanf("%I64d", &n);
nrb = 0;
while ((1LL << nrb) <= (n - 1)) nrb++;
nrb--;
int i;
rnb[1] = 1;
for (i = 2; i <= 40; i++) rnb[i] = 2 * rnb[i - 1] + (1LL << (i - 1));
long long rez = 0;
while (nrb >= 0) {
while (nrb >= 0 && (1LL << nrb) > (n - 1)) nrb--;
if (nrb >= 0) {
rez += (1LL << nrb);
rez += rnb[nrb];
n -= (1LL << nrb);
}
}
printf("%I64d", rez);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
int x = 97;
int cnt = 0;
int dif;
for (int i = 0; i < n; i++) {
dif = abs(s[i] - x);
if (dif > 13) {
dif = 26 - dif;
}
cnt += dif;
x = s[i];
}
cout << cnt;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
;
int f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
x *= f;
}
const int N = 1e6 + 10;
struct seg {
int l, r, val;
seg() {}
} t[N << 2];
void build(int p, int l, int r) {
t[p].l = l;
t[p].r = r;
t[p].val = 0;
if (l == r) return;
int mid = (l + r) / 2;
build(p * 2, l, mid);
build(p * 2 + 1, mid + 1, r);
}
int query(int p, int l, int r) {
if (l <= t[p].l && t[p].r <= r) return t[p].val;
int ans = 0, mid = (t[p].l + t[p].r) / 2;
if (l <= mid) ans = max(ans, query(p * 2, l, r));
if (r > mid) ans = max(ans, query(p * 2 + 1, l, r));
return ans;
}
void modify(int p, int l, int d) {
if (t[p].l == t[p].r) {
t[p].val = d;
return;
}
int mid = (t[p].l + t[p].r) / 2;
if (l <= mid)
modify(p * 2, l, d);
else
modify(p * 2 + 1, l, d);
t[p].val = max(t[p * 2].val, t[p * 2 + 1].val);
}
int a[N], b[N], pos[N], f[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
pos[b[i]] = i;
}
for (int i = 1; i <= n; i++) a[i] = pos[a[i]];
build(1, 1, n);
int ans = 0;
for (int i = 1; i <= n; i++) {
f[i] = max(1, query(1, a[i] + 1, n) + 1);
modify(1, a[i], f[i]);
ans = max(ans, f[i]);
}
printf("%d", ans);
return 0;
}
| 11
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC target("avx,tune=native")
using namespace std;
namespace fastio {
char in[100000];
int itr = 0, llen = 0;
char get() {
if (itr == llen) llen = fread(in, 1, 100000, stdin), itr = 0;
if (llen == 0) return EOF;
return in[itr++];
}
char out[100000];
int itr2 = 0;
void put(char c) {
out[itr2++] = c;
if (itr2 == 100000) {
fwrite(out, 1, 100000, stdout);
itr2 = 0;
}
}
int clear() {
fwrite(out, 1, itr2, stdout);
itr2 = 0;
return 0;
}
int getint() {
int ret = 0;
char ch = get();
while (ch < '0' || ch > '9') {
ch = get();
if (ch == '-') return -getint();
}
while ('0' <= ch && ch <= '9') {
ret = ret * 10 - 48 + ch;
ch = get();
}
return ret;
}
string getstr() {
string ret = "";
char ch = get();
while (ch == ' ' || ch == '\n') ch = get();
while (ch != ' ' && ch != '\n') ret.push_back(ch), ch = get();
return ret;
}
void putstr(string s) {
for (int i = 0; i < s.size(); i++) put(s[i]);
}
void putint(int x) {
if (x < 0) {
put('-');
putint(-x);
return;
}
if (x == 0) {
put('0');
return;
}
char c[40];
int pos = 0;
while (x) {
c[pos++] = '0' + x % 10;
x /= 10;
}
for (int i = pos - 1; i >= 0; i--) put(c[i]);
put(' ');
}
void putln(int x) {
if (x < 0) {
put('-');
putln(-x);
return;
}
if (x == 0) {
put('0');
put('\n');
return;
}
char c[40];
int pos = 0;
while (x) {
c[pos++] = '0' + x % 10;
x /= 10;
}
for (int i = pos - 1; i >= 0; i--) put(c[i]);
put('\n');
}
} // namespace fastio
using namespace fastio;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
int n, m;
string s[3005];
bitset<3003> dif[6005], row[3005];
bitset<3003> f[2][3005], g[2][3005];
bitset<3003> Tmp;
int now, nxt;
void init(int x) {
for (int i = 1; i <= m; i++) f[nxt][i] <<= 1, f[nxt][i].set(0);
for (int i = 1; i <= m; i++) {
f[now][i] = (f[nxt][i] & (dif[x - i + 3001] >> x));
}
for (int i = 1; i <= m; i++) g[nxt][i] <<= 1, g[nxt][i].set(0);
for (int i = 1; i <= m; i++) {
g[now][i] = g[nxt][i] & (row[x] >> i);
}
}
int T[3003];
bitset<3003> dat[3003];
int solve(int x) {
int ret = 0;
int r = 0;
for (int i = 1; i <= m; i++) {
r = max(r, i);
while (row[x][r]) r++;
T[i] = r - i;
}
for (int i = 1; i <= m; i++) {
ret += (f[now][i] & g[now][i] & dat[T[i]]).count();
}
now ^= 1;
nxt ^= 1;
return ret;
}
int main() {
n = getint();
m = getint();
for (int i = 1; i <= n; i++) s[i] = " " + getstr();
for (int i = 0; i <= 3000; i++)
for (int j = 0; j <= i; j++) dat[i].set(j);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] == 'z') dif[i - j + 3001].set(i), row[i].set(j);
}
}
long long ans = 0;
now = 0;
nxt = 1;
for (int i = n; i >= 1; i--) {
init(i);
ans += solve(i);
}
cout << ans << endl;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:250000000")
template <typename T>
int size(T& a) {
return (int)a.size();
}
template <typename T>
T sqr(T a) {
return a * a;
}
const int INF = 1000 * 1000 * 1000;
struct rib {
int b, u, c, f;
size_t back;
};
void add_rib(vector<vector<rib> >& g, int a, int b, int u, int c) {
rib r1 = {b, u, c, 0, g[b].size()};
rib r2 = {a, 0, -c, 0, g[a].size()};
g[a].push_back(r1);
g[b].push_back(r2);
}
vector<vector<rib> > g;
int emaxxflow(int k, int n, int s, int t) {
int flow = 0, cost = 0;
while (flow < k) {
vector<int> id(n, 0);
vector<int> d(n, INF);
vector<int> q(n);
vector<int> p(n);
vector<size_t> p_rib(n);
int qh = 0, qt = 0;
q[qt++] = s;
d[s] = 0;
while (qh != qt) {
int v = q[qh++];
id[v] = 2;
if (qh == n) qh = 0;
for (size_t i = 0; i < g[v].size(); ++i) {
rib& r = g[v][i];
if (r.f < r.u && d[v] + r.c < d[r.b]) {
d[r.b] = d[v] + r.c;
if (id[r.b] == 0) {
q[qt++] = r.b;
if (qt == n) qt = 0;
} else if (id[r.b] == 2) {
if (--qh == -1) qh = n - 1;
q[qh] = r.b;
}
id[r.b] = 1;
p[r.b] = v;
p_rib[r.b] = i;
}
}
}
if (d[t] == INF) break;
int addflow = k - flow;
for (int v = t; v != s; v = p[v]) {
int pv = p[v];
size_t pr = p_rib[v];
addflow = min(addflow, g[pv][pr].u - g[pv][pr].f);
}
for (int v = t; v != s; v = p[v]) {
int pv = p[v];
size_t pr = p_rib[v], r = g[pv][pr].back;
g[pv][pr].f += addflow;
g[v][r].f -= addflow;
cost += g[pv][pr].c * addflow;
}
flow += addflow;
}
if (flow == k) return cost;
return -1;
}
void solve() {
string t;
cin >> t;
int n;
cin >> n;
vector<string> s(n);
vector<int> a(n);
for (int i = (0), _up = (int)n; i < _up; ++i) cin >> s[i] >> a[i];
int N = 2 + 26 + n * 26 + n;
g.resize(N);
vector<int> c(26);
for (int i = (0), _up = (int)size(t); i < _up; ++i) c[t[i] - 'a']++;
int S = N - 2, T = N - 1;
for (int i = (0), _up = (int)26; i < _up; ++i) {
add_rib(g, S, i, c[i], 0);
for (int j = (0), _up = (int)n; j < _up; ++j) {
add_rib(g, i, 26 + j * 26 + i, 1000000, j + 1);
}
}
for (int i = (0), _up = (int)n; i < _up; ++i) {
vector<int> cnt(26);
for (int e = (0), _up = (int)size(s[i]); e < _up; ++e) cnt[s[i][e] - 'a']++;
for (int j = (0), _up = (int)26; j < _up; ++j) {
add_rib(g, 26 + i * 26 + j, 26 * (n + 1) + i, cnt[j], 0);
}
}
for (int j = (0), _up = (int)n; j < _up; ++j) {
add_rib(g, 26 * (n + 1) + j, T, a[j], 0);
}
cout << emaxxflow(size(t), N, S, T);
}
int main() { solve(); }
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int MAXINT = 2147483647;
const long long MAXLONGINT = 9223372036854775807;
const int MAX = 300000;
long long n, a, s;
vector<long long> ans, v[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
v[a].push_back(i);
}
s = 0;
while (n > 0) {
if (!v[s].empty()) {
ans.push_back(v[s][v[s].size() - 1]);
v[s].pop_back();
s++;
n--;
} else {
if (s >= 3)
s -= 3;
else
break;
}
if (n == 0) break;
}
if (n == 0) {
cout << "Possible\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
cout << '\n';
} else
cout << "Impossible\n";
return 0;
}
| 11
|
#include <bits/stdc++.h>
using std::cerr;
using std::cin;
using std::max;
using std::min;
int n, top;
struct point {
long long x, y;
friend point operator-(point t1, point t2) {
return {t1.x - t2.x, t1.y - t2.y};
}
friend long long operator*(point t1, point t2) {
return t1.x * t2.y - t2.x * t1.y;
}
friend bool operator<(point t1, point t2) {
return t1.x < t2.x || t1.x == t2.x && t1.y > t2.y;
}
} A[100005], sta[100005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%lld%lld", &A[i].x, &A[i].y), A[i].y -= (long long)A[i].x * A[i].x;
std::sort(A + 1, A + 1 + n);
for (int i = 1; i <= n; i++) {
if (i > 1 && A[i].x == A[i - 1].x) continue;
for (; top > 1 && (A[i] - sta[top - 1]) * (sta[top] - sta[top - 1]) <= 0;
top--)
;
sta[++top] = A[i];
}
printf("%d\n", top - 1);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 51;
map<int, int> mp;
int n, kk, MOD, res, u, v, w, x;
int invf[MAXN], pr[MAXN];
inline int read() {
register int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
inline void dfs(int l, int r, int depth) {
if (depth >= kk || l == r) {
return (void)mp[r - l + 1]++;
}
int mid = (l + r) >> 1;
dfs(l, mid, depth + 1), dfs(mid + 1, r, depth + 1);
}
inline int calc(int x, int y) {
int res = 0;
for (register int i = 1; i <= x; i++) {
res = (res + (pr[i + y] - pr[i] + MOD) % MOD * 2 % MOD) % MOD;
}
return (((long long int)x * y - res) % MOD + MOD) % MOD;
}
int main() {
n = read(), kk = read(), MOD = read(), invf[1] = pr[1] = 1, dfs(1, n, 1);
for (register int i = 2; i <= max(n, 2); i++) {
invf[i] = MOD - (long long int)(MOD / i) * invf[MOD % i] % MOD,
pr[i] = (pr[i - 1] + invf[i]) % MOD;
}
for (auto i : mp) {
tie(u, v) = i, res = (res + (long long int)u * (u - 1) / 2 % MOD * v) % MOD;
v >= 2
? res = (res + (long long int)v * (v - 1) / 2 % MOD * calc(u, u)) % MOD
: 1;
}
for (auto i : mp) {
for (auto j : mp) {
if (i.first < j.first) {
tie(u, v) = i, tie(w, x) = j;
res = (res + (long long int)calc(u, w) * v % MOD * x % MOD) % MOD;
}
}
}
printf("%d\n", (long long int)res * invf[2] % MOD);
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
const int G = 1e9 + 1;
unordered_map<int, int> ft;
void gnk(int i) {
while (i < G) {
++ft[i];
i += (i & -i);
}
}
int pj(long long i) {
int dr = 0;
while (i) {
dr += ft[i];
i -= (i & -i);
}
return dr;
}
int sj(int l, int r) { return pj(r) - pj(l - 1); }
int n, x, y, s;
unordered_map<int, vector<int> > v;
vector<int> u;
long long fp;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
u.push_back(G);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> x >> y;
u.push_back(y);
v[y].push_back(x);
}
sort(u.begin(), u.end());
reverse(u.begin(), u.end());
for (int i = 1; i < u.size(); ++i) {
if (u[i] != u[i - 1]) {
sort(v[u[i]].begin(), v[u[i]].end());
for (int j = 0; j < v[u[i]].size(); ++j) {
if (pj(v[u[i]][j]) == pj(v[u[i]][j] - 1)) ++s, gnk(v[u[i]][j]);
}
for (int j = 0; j < v[u[i]].size(); ++j) {
fp += 1ll * (sj((j ? v[u[i]][j - 1] + 1 : 1), v[u[i]][j] - 1) + 1) *
(s - pj(v[u[i]][j]) + 1);
}
}
}
cout << fp << endl;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s1, s2;
cin >> n;
cin >> s1 >> s2;
int vverh[100000], vniz[100000], rovno[100000];
for (int i = 0; i < n; i++) {
if ((s1[i] == '?') && (s2[i] == '?')) {
vverh[i] = 45;
vniz[i] = 45;
rovno[i] = 10;
} else if (s1[i] == '?') {
vverh[i] = 9 - (int)s2[i] + '0';
vniz[i] = (int)s2[i] - '0';
rovno[i] = 1;
} else if (s2[i] == '?') {
vverh[i] = (int)s1[i] - '0';
vniz[i] = 9 - (int)s1[i] + '0';
rovno[i] = 1;
} else {
if (s1[i] > s2[i]) {
vverh[i] = 1;
vniz[i] = 0;
rovno[i] = 0;
}
if (s1[i] < s2[i]) {
vverh[i] = 0;
vniz[i] = 1;
rovno[i] = 0;
}
if (s1[i] == s2[i]) {
vverh[i] = 0;
vniz[i] = 0;
rovno[i] = 1;
}
}
}
long long mod = 1000000007;
long long vsevverh = 1, vsevniz = 1, vserovno = 1;
;
for (int i = 0; i < n; i++) {
vsevverh *= (vverh[i] + rovno[i]);
vsevverh %= mod;
vsevniz *= (vniz[i] + rovno[i]);
vsevniz %= mod;
vserovno *= rovno[i];
vserovno %= mod;
}
long long result = 1;
for (int i = 0; i < n; i++) {
if (s1[i] == '?') {
result *= 10;
result %= mod;
}
if (s2[i] == '?') {
result *= 10;
result %= mod;
}
}
result -= vsevniz;
result -= vsevverh;
result += vserovno;
while (result < 0) {
result += mod;
}
cout << result % mod;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd;
const int mod = 998244353;
inline int add(int a, int b) {
if (a + b >= mod)
return a + b - mod;
else
return a + b;
}
inline int sub(int a, int b) {
if (a - b < 0)
return a - b + mod;
else
return a - b;
}
inline int mult(int a, int b) { return 1ll * a * b % mod; }
inline int binpow(int a, int n) {
int res = 1;
while (n) {
if (n & 1) {
res = mult(res, a);
}
a = mult(a, a);
n >>= 1;
}
return res;
}
inline int inv(int a) { return binpow(a, mod - 2); }
inline int divi(int a, int b) { return mult(a, inv(b)); }
const int N = 2e5 + 10;
int f[N];
int f_inv[N];
inline int C(int n, int k) {
if (n < k || k < 0 || n < 0) return 0;
return mult(f[n], mult(f_inv[k], f_inv[n - k]));
}
void init() {
f[0] = 1;
for (int i = 1; i <= N - 1; i++) {
f[i] = mult(f[i - 1], i);
}
f_inv[N - 1] = inv(f[N - 1]);
for (int i = N - 2; i >= 0; i--) {
f_inv[i] = mult(f_inv[i + 1], i + 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
init();
int n, m;
cin >> n >> m;
if (n == 2) {
cout << "0\n";
return 0;
}
cout << mult(mult(n - 2, binpow(2, n - 3)), C(m, n - 1)) << "\n";
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100009;
const int mod = 1e9 + 7;
int n, m, f[maxn];
int main() {
scanf("%d%d", &n, &m);
f[0] = f[1] = 2;
for (int i = 2; i <= max(n, m); i++) f[i] = (f[i - 1] + f[i - 2]) % mod;
printf("%d", (f[n] + f[m] - 2) % mod);
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long nxt() {
long long x;
cin >> x;
return x;
}
long long _gcd(long long a, long long b) {
if (a == 0) return b;
return _gcd(b % a, a);
}
void testcase() {
long long a, m;
cin >> a >> m;
const long long gcd = _gcd(a, m);
const long long m_dash = m / gcd;
long long f = (long long)(sqrt(m_dash) + 2);
vector<long long> prime_factors;
long long m_dash_2 = m_dash;
for (long long i = 2; i < f; i++) {
if (m_dash_2 % i == 0) {
prime_factors.push_back(i);
while (m_dash_2 % i == 0) {
m_dash_2 /= i;
}
}
}
if (m_dash_2 > 2) {
prime_factors.push_back(m_dash_2);
}
long long ans = m_dash;
for (long long x : prime_factors) {
ans -= ans / x;
}
cout << ans << "\n";
}
signed main() {
std::ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
long long t;
cin >> t;
while (t--) testcase();
}
| 10
|
#include <bits/stdc++.h>
int i, j, k, m, n;
int main() {
fscanf(stdin, "%d%d", &m, &n);
double r = m;
for (i = m - 1; i >= 1; i--) r -= pow((double)i / m, n);
printf("%.16lf", r);
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
struct edge {
int u, v, w, next, id;
} e[N];
int mcnt, link[N], x[N], y[N], z[N], dis[N], k[N], pre[N];
bool flag[N];
queue<pair<int, int> > q;
void add(int x, int y, int z, int ID) {
e[mcnt].u = x;
e[mcnt].v = y;
e[mcnt].w = z;
e[mcnt].next = link[x];
e[mcnt].id = ID;
link[x] = mcnt++;
}
void work(int x) {
if (x == 1) return;
flag[e[pre[x]].id] = !flag[e[pre[x]].id];
work(e[pre[x]].u);
}
int main() {
memset(link, -1, sizeof(link));
int n, m, cnt = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &x[i], &y[i], &z[i]);
if (z[i] == 1) {
++cnt;
flag[i] = 1;
}
add(x[i], y[i], z[i], i);
add(y[i], x[i], z[i], i);
}
q.push(make_pair(1, 0));
memset(dis, -1, sizeof(dis));
dis[1] = 0;
memset(k, 0, sizeof(k));
while (!q.empty()) {
pair<int, int> h = q.front();
q.pop();
if (k[h.first] != h.second) continue;
for (int i = link[h.first]; ~i; i = e[i].next) {
if (dis[e[i].v] == -1) {
dis[e[i].v] = dis[h.first] + 1;
k[e[i].v] = k[h.first] + (!e[i].w);
pre[e[i].v] = i;
q.push(make_pair(e[i].v, k[e[i].v]));
continue;
}
if (dis[e[i].v] == dis[h.first] + 1 &&
k[h.first] + (!e[i].w) < k[e[i].v]) {
k[e[i].v] = k[h.first] + (!e[i].w);
pre[e[i].v] = i;
q.push(make_pair(e[i].v, k[e[i].v]));
}
}
}
printf("%d\n", cnt + 2 * k[n] - dis[n]);
work(n);
for (int i = 0; i < m; ++i)
if (flag[i]) printf("%d %d %d\n", x[i], y[i], !z[i]);
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
if (n == 1) {
cout << n << " ";
continue;
}
int s = 1;
for (int i = 1; i < n; i++) {
int x = (i + s) % n;
if (x == 0) x = n;
cout << x << " ";
s += i;
}
cout << endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1111111;
int n, x;
int a[maxn];
int pre_big[maxn];
int aft_little[maxn];
int main() {
ios::sync_with_stdio(false);
while (cin >> n >> x) {
for (int i = 0; i < n; i++) cin >> a[i];
set<int> st;
memset(pre_big, 0, sizeof pre_big);
for (int i = 0; i < n; i++) {
if (!st.empty() && *st.rbegin() > a[i]) pre_big[a[i]] = *st.rbegin();
st.insert(a[i]);
}
set<int> st2;
memset(aft_little, 0, sizeof aft_little);
for (int i = n - 1; i >= 0; i--) {
if (!st2.empty() && *st2.begin() < a[i]) aft_little[a[i]] = *st2.begin();
st2.insert(a[i]);
}
int top = x;
while (top && !pre_big[top]) top--;
int bottom = 1;
while (bottom <= x && !aft_little[bottom]) bottom++;
if (top == 0) {
long long ans = (long long)x * (x + 1) / 2;
cout << ans << endl;
} else {
int mx = 0;
long long ans = 0;
for (int l = 1; l <= bottom; l++) {
mx = max(mx, pre_big[l - 1]);
int r = max(mx, top);
ans += x - r + 1;
}
cout << ans << endl;
}
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int INF = -1u / 2;
const int MAX_N = 1e5 + 5;
int n, m, d;
int ans;
int down[MAX_N][2];
bool spec[MAX_N];
vector<int> adj[MAX_N];
inline void dfs1(int u, int p = 0) {
down[u][0] = down[u][1] = spec[u] ? 0 : -INF;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v != p) {
dfs1(v, u);
if (down[v][0] + 1 > down[u][1]) {
down[u][1] = down[v][0] + 1;
}
if (down[u][0] < down[u][1]) {
swap(down[u][0], down[u][1]);
}
}
}
}
inline void dfs2(int u, int p = 0, int up = -INF) {
int tmp = max(up, down[u][0]);
if (tmp >= 0 and tmp <= d) {
ans++;
}
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v != p) {
if (down[v][0] + 1 != down[u][0]) {
dfs2(v, u, max(up, down[u][0]) + 1);
} else {
dfs2(v, u, max(up, down[u][1]) + 1);
}
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &d);
while (m--) {
int x;
scanf("%d", &x);
spec[x] = true;
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs1(1);
dfs2(1);
printf("%d\n", ans);
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e3 + 2;
const long long mod = 998244353;
long long n, a[N], c[N], f[N][N], sum[N];
signed main() {
scanf("%lld", &n);
for (register long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
long long pos = 0;
for (register long long i = 1; i <= n; i++) {
while (a[pos + 1] * 2 <= a[i]) {
pos++;
}
c[i] = pos;
}
for (register long long i = 1; i <= n; i++) {
f[1][i] = 1;
}
for (register long long i = 2; i <= n; i++) {
for (register long long j = 1; j <= n; j++) {
sum[j] = sum[j - 1] + f[i - 1][j];
sum[j] %= mod;
}
for (register long long j = 1; j <= n; j++) {
f[i][j] = f[i - 1][j] * (c[j] - i + 2) + sum[c[j]];
f[i][j] %= mod;
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans += f[n][i];
ans %= mod;
}
cout << ans;
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
long long a[10][10];
int nn;
int num[10];
int d[10];
int row[10];
int col[10];
int dia[10];
long long tot;
int n;
bool rec(int r, int c) {
if (r == n - 1) {
long long rem = tot - col[c];
for (int i = 0; i < nn; i++) {
if (d[i] && num[i] == rem) {
if (c == 0 && dia[1] + rem != tot) return false;
if (c == n - 1) {
if (dia[0] + rem != tot)
return false;
else {
a[r][c] = rem;
return true;
}
}
d[i]--;
if (rec(r, c + 1)) {
a[r][c] = rem;
return true;
} else {
d[i]++;
return false;
}
}
}
return false;
}
if (c == n - 1) {
long long rem = tot - row[r];
for (int i = 0; i < nn; i++) {
if (d[i] && num[i] == rem) {
if (r == 0) dia[1] += num[i];
col[c] += num[i];
d[i]--;
if (rec(r + 1, 0)) {
a[r][c] = rem;
return true;
} else {
if (r == 0) dia[1] -= num[i];
col[c] -= num[i];
d[i]++;
return false;
}
}
}
return false;
}
for (int i = 0; i < nn; i++) {
if (d[i]) {
if (r == c) dia[0] += num[i];
if (r + c == n - 1) dia[1] += num[i];
row[r] += num[i];
col[c] += num[i];
d[i]--;
if (rec(r, c + 1)) {
a[r][c] = num[i];
return true;
} else {
d[i]++;
row[r] -= num[i];
col[c] -= num[i];
if (r == c) dia[0] -= num[i];
if (r + c == n - 1) dia[1] -= num[i];
}
}
}
return false;
}
int main() {
map<int, int> mp;
tot = 0;
int x;
cin >> n;
int k = n * n;
for (int i = 0; i < k; i++) {
cin >> x;
tot += x;
mp[x]++;
}
tot /= n;
nn = 0;
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++) {
num[nn] = it->first;
d[nn] = it->second;
nn++;
}
cout << tot << endl;
rec(0, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 6e5 + 500;
const int mod = 1e9 + 7;
const int inf = 1e9 + 500;
vector<pair<int, char> > ger[maxn];
int bach[maxn][26];
int par[maxn];
vector<int> hh[maxn];
int siz[maxn];
void dfs(int a, int p = -1, int h = 1) {
hh[h].push_back(a);
siz[a] = 1;
par[a] = p;
for (auto e : ger[a]) {
int v = e.first;
if (v != p) {
dfs(v, a, h + 1);
siz[a] += siz[v];
bach[a][e.second] = v;
}
}
}
int p;
int dfss(int a, int b, int pa = -1) {
int res = 1;
for (auto e : ger[a]) {
int v = e.first;
if (v != pa) {
if (bach[b][e.second] == 0) {
bach[b][e.second] = p;
ger[p].push_back(make_pair(b, e.second));
ger[b].push_back(make_pair(p, e.second));
p++;
res--;
}
res += dfss(v, bach[b][e.second], a);
}
}
return res;
}
int n;
int behine(int a) {
p = n + 1;
pair<int, int> ma = make_pair(-1, 0);
for (auto e : ger[a]) {
int v = e.first;
if (v != par[a]) {
ma = max(ma, make_pair(siz[v], v));
}
}
if (ma.first == -1) {
return 0;
}
int res = 1;
for (auto e : ger[a]) {
int v = e.first;
if (v != ma.second && v != par[a]) {
res += dfss(v, ma.second, a);
}
}
for (int i = n + 1; i < p; i++) {
memset(&bach[i], 0, 26 * sizeof(int));
for (auto e : ger[i]) {
int v = e.first;
if (v <= n) {
bach[v][e.second] = 0;
}
while (ger[v].size() && ger[v].back().first >= n) {
ger[v].pop_back();
}
}
ger[i].clear();
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int v, u;
char c;
cin >> v >> u >> c;
c -= 'a';
ger[v].push_back(make_pair(u, c));
ger[u].push_back(make_pair(v, c));
}
dfs(1);
pair<int, int> ans = make_pair(inf, inf);
for (int i = 1; i <= n; i++) {
int res = n;
for (auto v : hh[i]) {
res -= behine(v);
}
ans = min(ans, make_pair(res, i));
}
cout << ans.first << ' ' << ans.second;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
void(o_o)();
long long int i, j, k;
const long long int mod = 1000000007;
const long long int inf = 0x3f3f3f3f3f3f3f3fLL;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout << fixed << setprecision(10);
int t = 1;
while (t--) (o_o)();
}
long long int n, l, timer;
long long int f[100005], euler[200005], tin[100005], tout[100005], gen[100005],
res[100005];
vector<long long int> node[100005];
vector<vector<long long int>> up;
vector<pair<pair<long long int, long long int>, long long int>> Q;
void dfs(long long int idx, long long int p) {
tin[idx] = ++timer;
euler[timer] = idx;
up[idx][0] = p;
for (long long int i = 1; i <= l; i++) up[idx][i] = up[up[idx][i - 1]][i - 1];
for (auto it : node[idx])
if (it != p) dfs(it, idx);
tout[idx] = ++timer;
euler[timer] = idx;
}
bool is_ancestor(long long int u, long long int v) {
if (tin[u] <= tin[v] && tout[u] >= tout[v]) return 1;
return 0;
}
long long int lca(long long int u, long long int v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (long long int i = l; i >= 0; i--)
if (!is_ancestor(up[u][i], v)) u = up[u][i];
return up[u][0];
}
unordered_map<long long int, long long int[2]> cnt;
long long int freq[100005];
void add(long long int idx, long long int& ans) {
long long int u = euler[idx];
long long int sign = 1;
++freq[u];
if (freq[u] == 2) sign *= -1;
cnt[f[u]][gen[u]] += sign;
ans += 1LL * sign * cnt[f[u]][gen[u] ^ 1];
}
void remove(long long int idx, long long int& ans) {
long long int u = euler[idx];
long long int sign = -1;
--freq[u];
if (freq[u] == 1) sign *= -1;
cnt[f[u]][gen[u]] += sign;
ans += 1LL * sign * cnt[f[u]][gen[u] ^ 1];
}
void compute() {
long long int curL = 1, curR = 0;
long long int ans = 0;
for (auto it : Q) {
while (curR < it.first.second) ++curR, add(curR, ans);
while (curL < it.first.first) remove(curL, ans), ++curL;
while (curL > it.first.first) --curL, add(curL, ans);
while (curR > it.first.second) remove(curR, ans), --curR;
long long int u = euler[it.first.first], v = euler[it.first.second];
long long int l = lca(u, v);
if (l != u && l != v) add(tin[l], ans);
res[it.second] = ans;
if (l != u && l != v) remove(tin[l], ans);
}
}
long long int S;
bool cmp(pair<pair<long long int, long long int>, long long int> p,
pair<pair<long long int, long long int>, long long int> q) {
if (p.first.first / S != q.first.first / S)
return p.first.first / S < q.first.first / S;
return ((p.first.first / S) & 1) ? (p.first.second < q.first.second)
: (p.first.second > q.first.second);
}
void(o_o)() {
long long int n;
cin >> n;
l = log2(n + 1);
up.resize(n + 1, vector<long long int>(l + 1, 0));
for (i = 1; i <= n; i++) cin >> gen[i];
for (i = 1; i <= n; i++) cin >> f[i];
for (i = 1; i < n; i++) {
long long int u, v;
cin >> u >> v;
node[u].emplace_back(v);
node[v].emplace_back(u);
}
dfs(1, 1);
long long int q;
cin >> q;
for (i = 1; i <= q; i++) {
long long int u, v;
cin >> u >> v;
if (tin[u] > tin[v]) swap(u, v);
if (lca(u, v) == u)
Q.emplace_back(make_pair(make_pair(tin[u], tin[v]), i));
else
Q.emplace_back(make_pair(make_pair(tout[u], tin[v]), i));
}
S = sqrt(n);
sort(Q.begin(), Q.end(), cmp);
compute();
for (i = 1; i <= q; i++) cout << res[i] << endl;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ciur[100005], p[100000], cmmdc[5005];
unordered_map<int, int> bad;
int a[5005], b[5005];
inline int gcd(int a, int b) {
int r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
for (int i = 2; i <= 100000; ++i) {
if (ciur[i]) continue;
p[++p[0]] = i;
for (int j = i + i; j <= 100000; j += i) {
ciur[j] = 1;
}
}
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; ++i) {
scanf("%d", &b[i]);
bad[b[i]] = 1;
}
for (int i = 1; i <= n; ++i) {
cmmdc[i] = gcd(cmmdc[i - 1], a[i]);
}
int sol = 0;
for (int i = 1; i <= n; ++i) {
int x = a[i];
for (int j = 1; j <= p[0] && p[j] * p[j] <= x; ++j) {
int add = bad[p[j]] ? -1 : 1;
while (x % p[j] == 0) {
sol += add;
x /= p[j];
}
}
if (x > 1) {
sol += bad[x] ? -1 : 1;
}
}
int divide = 1;
for (int i = n; i >= 1; --i) {
int aux_cmmdc = cmmdc[i] / divide, now = 0, acum = cmmdc[i] / divide;
for (int j = 1; j <= p[0] && p[j] * p[j] <= aux_cmmdc; ++j) {
int add = bad[p[j]] ? -1 : 1;
while (aux_cmmdc % p[j] == 0) {
now += add;
aux_cmmdc /= p[j];
}
}
if (aux_cmmdc > 1) {
now += bad[aux_cmmdc] ? -1 : 1;
}
if (now < 0) {
sol -= now * i;
divide *= acum;
}
}
printf("%d\n", sol);
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 100;
void solve() {
int n;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int chek = n * (n - 1) / 2 - 1;
int ans = 0;
for (int i = 0; i < n - 1; i++) {
if (arr[i] > arr[i + 1]) ans++;
}
if (ans != n - 1)
cout << "YES\n";
else
cout << "NO\n";
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
};
| 1
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ull = unsigned long long int;
using dd = double;
using ldd = long double;
ll mod = 998244353;
ll bp(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
int _size = 1 << 18;
pair<ll, ll> f(pair<ll, ll> a, pair<ll, ll> b) {
if (a.first == -1 || b.first == -1) {
return (a.first == -1 ? b : a);
}
pair<ll, ll> ans;
ans.first = a.first * b.second + b.first + a.first;
ans.first %= mod;
ans.second = a.second * b.second + b.second + a.second;
ans.second %= mod;
return ans;
}
vector<pair<ll, ll>> tree(_size << 1, {-1, -1});
pair<ll, ll> get(int v, int l, int r, int fl, int fr) {
if (r <= fl || fr <= l || r <= l) {
return {-1, -1};
}
if (fl <= l && r <= fr) return tree[v];
return f(get(v << 1, l, (r + l) >> 1, fl, fr),
get(v << 1 | 1, (r + l) >> 1, r, fl, fr));
}
void solve() {
int n, q;
cin >> n >> q;
vector<ll> arr(n);
for (int i = 0; i < n; ++i) cin >> arr[i];
ll ans = 0;
for (int i = 0; i < n; ++i) {
tree[i + _size].first = 100LL * bp(arr[i], mod - 2) % mod;
tree[i + _size].second = (100LL - arr[i]) * bp(arr[i], mod - 2) % mod;
}
for (int i = _size - 1; i > 0; --i)
tree[i] = f(tree[i << 1], tree[i << 1 | 1]);
ans = get(1, 0, _size, 0, n).first;
0;
;
set<int> check;
check.insert(n);
check.insert(0);
for (int i = 0; i < q; ++i) {
int x;
cin >> x;
--x;
if (check.find(x) != check.end()) {
auto r = check.upper_bound(x);
auto l = r;
l--;
l--;
ans -= get(1, 0, _size, *l, x).first + get(1, 0, _size, x, *r).first;
ans += get(1, 0, _size, *l, *r).first;
ans %= mod;
ans += mod;
ans %= mod;
check.erase(x);
} else {
auto r = check.upper_bound(x);
auto l = r;
l--;
ans -= get(1, 0, _size, *l, *r).first;
ans += get(1, 0, _size, *l, x).first + get(1, 0, _size, x, *r).first;
ans %= mod;
ans += mod;
ans %= mod;
check.insert(x);
}
cout << ans << '\n';
0;
;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
t = 1;
for (int i = 0; i < t; ++i) solve();
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
int n,m,t,k;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--)
{
cin >> n >> k;
// k = 2
int prv = 0, r = 0;
for (int i = 0; i < n; i++)
{
cout << (prv^i) << endl;
prv = i;
cin >> r;
if (r == 1) break;
}
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
cout << (m * (m - 1)) / 2 << endl;
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
if (k == 1) {
cout << max(i, j) << " " << min(i, j) << endl;
} else {
cout << min(i, j) << " " << max(i, j) << endl;
}
}
}
}
| 7
|
#include <bits/stdc++.h>
using ll = long long;
const int C = 200001, M = 998244353;
inline ll pow(ll a, ll b, ll M) {
if (b == 0) return 1;
ll c = 1;
while (b > 0) {
if (b % 2 == 1) c = (c * a) % M;
b /= 2;
a = (a * a) % M;
}
return c;
}
ll fac[C], af[C];
inline ll cn(int n, int k) {
if (n < k || n < 0) return 0;
return (((fac[n] * af[k]) % M) * af[n - k]) % M;
}
int a[C];
int main() {
int n, i, b = 0;
ll h, sum = 0, partial;
fac[0] = af[0] = 1;
for (i = 1; i < C; i++) fac[i] = (fac[i - 1] * i) % M;
for (i = 1; i < C; i++) af[i] = (af[i - 1] * pow(i, M - 2, M)) % M;
scanf("%d %lld", &n, &h);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
if (a[i] != a[(i + 1) % n]) b += 1;
}
ll pw_cur = 1;
for (i = 0; i <= b; i++) {
if (i > 0) pw_cur = (pw_cur * (h - 2)) % M;
if ((b - i) % 2 != 0) continue;
sum = (sum + ((pw_cur * cn(b, i)) % M) * cn(b - i, (b - i) / 2)) % M;
}
partial = (pow(h, b, M) - sum) % M;
partial = (partial * pow(2, M - 2, M)) % M;
if (partial < 0) partial += M;
printf("%lld\n", (partial * pow(h, n - b, M)) % M);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const double eps = 1e-6;
int x[MAXN], y[MAXN];
int n;
int add(int x) {
x = x + 1;
x %= n;
return x;
}
int sub(int x) {
x = x - 1;
if (x < 0) x += n;
return x;
}
double Cal(int x1, int y1, int x2, int y2, int x3, int y3) {
double x4 = x1 - x2, y4 = y1 - y2;
double x5 = x3 - x2, y5 = y3 - y2;
double sum = abs(x4 * y5 - x5 * y4);
return sum / sqrt(x5 * x5 + y5 * y5);
}
double solve(int p) {
double ans = 1e18;
int i = add(p), j = sub(p);
ans = min(ans, Cal(x[p], y[p], x[i], y[i], x[j], y[j]) / 2);
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
}
double ans = 1e18;
for (int i = 0; i < n; i++) {
ans = min(ans, solve(i));
}
printf("%.10f\n", ans);
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
char a[205];
int n, m;
const int oo = 1000000;
int f[110][110][2], ans = -oo;
int work(int x, int y, int d) {
if (y > m) return -oo;
if (x >= n) {
if (y == m)
return 0;
else
return -oo;
}
if (f[x][y][d] > -1000) return f[x][y][d];
int s1 = -oo, s2, e, i;
if (d == 0)
e = 1;
else
e = -1;
if (a[x] == 'F') {
for (i = 0; i <= m - y; i++) {
if (i % 2 == 0)
s2 = work(x + 1, y + i, d) + e;
else
s2 = work(x + 1, y + i, 1 - d);
if (s2 > s1) s1 = s2;
}
} else {
for (i = 0; i <= m - y; i++) {
if (i % 2 == 1)
s2 = work(x + 1, y + i, d) + e;
else
s2 = work(x + 1, y + i, 1 - d);
if (s2 > s1) s1 = s2;
}
}
if (s2 > s1) s1 = s2;
f[x][y][d] = s1;
return s1;
}
int main(void) {
int i, j;
for (i = 0; i < 110; i++)
for (j = 0; j < 110; j++) f[i][j][0] = f[i][j][1] = -1000;
scanf("%s", &a);
n = strlen(a);
scanf("%d", &m);
work(0, 0, 0);
work(0, 0, 1);
if (f[0][0][1] > ans) ans = f[0][0][1];
if (f[0][0][0] > ans) ans = f[0][0][0];
printf("%d\n", ans);
return 0;
}
| 10
|
#include <bits/stdc++.h>
int main() {
int i, j, n, m, x, y, z, p, a, b, ta, tb, nn, mm, temp;
scanf("%d%d%d%d%d%d", &n, &m, &x, &y, &z, &p);
for (i = 0; i < p; i++) {
scanf("%d%d", &a, &b);
ta = a, tb = b;
nn = n, mm = m;
if (x % 4 == 1) {
a = tb;
b = nn + 1 - ta;
temp = nn;
nn = mm;
mm = temp;
}
if (x % 4 == 2) {
a = nn + 1 - ta;
b = mm + 1 - tb;
}
if (x % 4 == 3) {
b = ta;
a = mm + 1 - tb;
temp = nn;
nn = mm;
mm = temp;
}
ta = a, tb = b;
if (y % 2 == 1) {
a = ta;
b = mm + 1 - tb;
}
ta = a;
tb = b;
if (z % 4 == 3) {
a = tb;
b = nn + 1 - ta;
}
if (z % 4 == 2) {
a = nn + 1 - ta;
b = mm + 1 - tb;
}
if (z % 4 == 1) {
b = ta;
a = mm + 1 - tb;
}
printf("%d %d\n", a, b);
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, a[N];
bool used[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dir = 0;
int cur = 0;
int ans = 0;
while (true) {
bool ok = false;
if (dir == 0) {
for (int i = 0; i < n; i++) {
if (!used[i] && a[i] <= cur) {
used[i] = true;
cur++;
ok = true;
}
}
} else {
for (int i = n - 1; i >= 0; i--) {
if (!used[i] && a[i] <= cur) {
used[i] = true;
cur++;
ok = true;
}
}
}
if (!ok) break;
dir = 1 - dir;
ans++;
}
cout << ans - 1 << "\n";
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
long long int x;
cin >> x;
if (x & 1)
cout << (x / 2) + 1 << endl;
else
cout << x / 2 << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int arr[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
int count = 0;
for (int i = 0; i < n; i++) {
int p = 0;
for (int j = 0; j < m; j++) {
if (arr[i][j] == 1) {
p = 1;
break;
}
}
if (p == 0) {
count++;
}
}
int count1 = 0;
for (int i = 0; i < m; i++) {
int p = 0;
for (int j = 0; j < n; j++) {
if (arr[j][i] == 1) {
p = 1;
break;
}
}
if (p == 0) {
count1++;
}
}
int s = min(count, count1);
if (s % 2 == 0) {
cout << "Vivek" << endl;
} else {
cout << "Ashish" << endl;
}
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int s, n, k, i, x, nr;
int main() {
cin >> n;
cin >> x;
for (i = 1; i <= n; i++) {
s = s + i;
k++;
}
while (s != x) {
s = s - (k + 1);
k--;
nr++;
}
cout << nr;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
double eps = 1e-6;
struct node {
node *l, *r;
int x, y, cnt;
long long sum;
node() {
l = r = NULL;
cnt = sum = 0;
}
} * t;
void out(node *t) {
if (!t) return;
out(t->l);
cout << t->x << " ";
out(t->r);
}
void upd(node *&x) {
if (!x) return;
long long s = x->x, s2 = 1;
if (x->l) s += x->l->sum, s2 += x->l->cnt;
if (x->r) s += x->r->sum, s2 += x->r->cnt;
x->sum = s;
x->cnt = s2;
}
node *merge(node *l, node *r) {
if (!l) return r;
if (!r) return l;
if (l->y > r->y) {
l->r = merge(l->r, r);
upd(l);
return l;
} else {
r->l = merge(l, r->l);
upd(r);
return r;
}
}
void split(node *t, double x, node *&l, node *&r) {
if (!t) {
l = r = NULL;
return;
}
if (t->x < x) {
l = t;
split(l->r, x, l->r, r);
upd(l);
} else {
r = t;
split(r->l, x, l, r->l);
upd(r);
}
}
void insert(long long val) {
node *z = new node;
node *l, *r;
split(t, val, l, r);
z->sum = z->x = val;
z->y = rand();
z->cnt = 1;
t = merge(l, merge(z, r));
}
void del(long long val) {
node *l, *m, *r;
split(t, val, l, r);
split(r, val + 1, m, r);
node *ml = new node;
node *mr = new node;
ml = mr = NULL;
if (m->l) ml = m->l;
if (m->r) mr = m->r;
ml = merge(ml, mr);
if (ml)
t = merge(merge(l, ml), r);
else
t = merge(l, r);
}
double need(double val) {
long long ans = 0, sm = 0;
node *l, *r;
split(t, val + eps, l, r);
if (l) ans = l->cnt;
if (l) sm = l->sum;
t = merge(l, r);
return ans * 1.0 * val - sm;
}
int n, q;
int id, x;
int a[N];
int tp;
long long V;
double l, r, mid;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
insert(a[i]);
}
for (int i = 1; i <= q; ++i) {
scanf("%d", &tp);
if (tp == 1) {
scanf("%d%d", &id, &x);
del(a[id]);
a[id] = x;
insert(a[id]);
} else {
scanf("%I64d", &V);
double l = 0, r = double(50000000000ll);
for (int it = 0; it < 50; ++it) {
mid = (l + r) / 2.0;
if (V - need(mid) > eps)
l = mid;
else
r = mid;
}
printf("%.5f\n", l);
}
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int n, m, qq, to[200021 * 4][2][33], pos[200021 * 4], lz[200021 * 4];
int a[200021];
void push_up(int u) {
for (int t = 0; t < 2; t++) {
for (int i = 0; i < 1 << m; i++) {
to[u][pos[u] ^ t][i] =
to[u << 1][pos[u << 1] ^ t][to[u << 1 | 1][pos[u << 1 | 1] ^ t][i]];
}
}
}
void push_down(int u) {
if (!lz[u]) return;
lz[u << 1] ^= 1;
lz[u << 1 | 1] ^= 1;
pos[u << 1] ^= 1;
pos[u << 1 | 1] ^= 1;
lz[u] = 0;
}
int Q(int x) {
int ans = 1;
for (int i = 0; i < m; i++) {
ans &= (x >> i);
}
return ans;
}
void build(int u, int l, int r) {
if (l == r) {
for (int i = 0; i < 1 << m; i++) {
to[u][0][i] = (i >> 1) | (1 << (m - 1));
to[u][1][i] = (i >> 1) | ((!Q(i)) << (m - 1));
if (a[l] == 1) swap(to[u][0][i], to[u][1][i]);
}
return;
}
int mid = l + r >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
push_up(u);
}
void update(int u, int l, int r, int x, int y) {
if (l == x && r == y) {
pos[u] ^= 1;
lz[u] ^= 1;
return;
}
int mid = l + r >> 1;
push_down(u);
if (x > mid)
update(u << 1 | 1, mid + 1, r, x, y);
else if (y <= mid)
update(u << 1, l, mid, x, y);
else
update(u << 1, l, mid, x, mid), update(u << 1 | 1, mid + 1, r, mid + 1, y);
push_up(u);
}
int query(int u, int l, int r, int x, int y, int now) {
if (l == x && r == y) return to[u][pos[u]][now];
int mid = l + r >> 1;
push_down(u);
if (x > mid)
return query(u << 1 | 1, mid + 1, r, x, y, now);
else if (y <= mid)
return query(u << 1, l, mid, x, y, now);
else
return query(u << 1, l, mid, x, mid,
query(u << 1 | 1, mid + 1, r, mid + 1, y, now));
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> qq;
long long y;
for (int i = 1; i <= n; i++) {
cin >> y;
a[i] = y & 1;
}
build(1, 1, n);
int p, l, r, add, x;
while (qq--) {
cin >> p;
if (p == 1) {
cin >> l >> r >> y;
if (y & 1) update(1, 1, n, l, r);
} else {
cin >> l >> r;
x = query(1, 1, n, l, r, (1 << m) - 1);
if (x & (1 << m - 1))
cout << 1 << endl;
else
cout << 2 << endl;
}
}
return 0;
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int f = 0, d = 0, g = 0;
if (s.size() > 1)
for (int i = 0; i < s.size() - 2; i++) {
if ((s[i] == 'A' && s[i + 1] == 'B' && s[i + 2] == 'A') ||
(s[i] == 'B' && s[i + 1] == 'A' && s[i + 2] == 'B')) {
s[i] = 'C';
s[i + 1] = 'C';
s[i + 2] = 'C';
d++;
}
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A')
if (s[i + 1] == 'B') {
f = 1;
s[i] = 'C';
s[i + 1] = 'C';
}
if (s[i] == 'B')
if (s[i + 1] == 'A') {
g = 1;
s[i] = 'C';
s[i + 1] = 'C';
}
}
if (f + d + g >= 2)
cout << "YES";
else
cout << "NO";
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 64;
long long t1[maxn + 5];
long long t2[maxn + 5];
long long base[maxn + 5];
int len(long long n) {
int ans = 0;
for (int len = 0; len < 63; len++) {
if ((1LL << len) & n) {
ans = len + 1;
}
}
return ans;
}
long long parent(long long x) {
int idx = len(x);
long long shift = t1[idx] + t2[idx];
shift %= base[idx];
if (shift < 0) shift += base[idx];
long long new_base = ((x - base[idx] + shift) % base[idx]) + base[idx];
new_base >>= 1;
long long shift_p = t1[idx - 1];
if (shift_p < 0) shift_p += base[idx - 1];
new_base = new_base - base[idx - 1] - shift_p;
if (new_base < base[idx - 1]) new_base += base[idx - 1];
new_base %= base[idx - 1];
return base[idx - 1] + new_base;
}
int main() {
int q;
scanf("%d", &q);
memset(t1, 0, sizeof t1);
memset(t2, 0, sizeof t2);
for (int i = 1; i < maxn; i++) {
base[i] = 1LL << (i - 1);
}
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
long long x, k;
scanf("%I64d %I64d", &x, &k);
int bits = len(x);
t1[bits] += k;
t1[bits] %= base[bits];
} else if (t == 2) {
long long x, k;
scanf("%I64d %I64d", &x, &k);
int bits = len(x);
t2[bits] += k;
t2[bits] %= base[bits];
} else {
long long x;
scanf("%I64d", &x);
while (x != 1LL) {
printf("%I64d ", x);
x = parent(x);
}
printf("1\n");
}
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a[1005], b[1005], i, j, r = 0, c = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (a[i] == b[i]) r++;
}
for (j = 0; j < n - 1; j++) {
if (a[j + 1] > a[j]) c++;
}
if (c == 0 && r == n)
cout << "maybe";
else if (c > 0 && r == n)
cout << "unrated";
else if (r != n)
cout << "rated";
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, s;
cin >> a >> b;
s = a * b / 2;
cout << s << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500 + 10;
const long long int mod = 1e9 + 7;
clock_t startTime;
double getCurrenttime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
void fastio() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
}
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
long long int mod_exp(long long int x, long long int y, long long int mm) {
if (y <= 0)
return (1);
else if (y % 2 == 0)
return (mod_exp((x * x) % mm, y / 2, mm));
else
return ((x * mod_exp((x * x) % mm, (y - 1) / 2, mm)) % mm);
}
bool powerof2(long long int n) {
return (int)(ceil(log2(n))) == (int(floor(log2(n))));
}
int modstring(string s, int k) {
int ans = 0;
for (int i = 0; i < (int)s.length(); i++) {
ans = (ans * 10 + s[i] - '0') % k;
}
return ans;
}
void solve() {
string s;
cin >> s;
int k = modstring(s, 4);
cout << ((int)(1 + pow(2, k) + pow(3, k) + pow(4, k))) % 5 << '\n';
}
int main() {
fastio();
int t = 1;
while (t--) {
solve();
}
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3000 + 10, mod = 998244353;
int a[N];
int ans[N][N];
pair<long long, long long> p[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], p[i] = {-a[i], i};
sort(p, p + n);
for (int i = 0; i < n; i++) {
int id = p[i].second;
int st = i;
for (int j = 0; j < a[id]; j++) {
ans[st][id] = 1;
st = (st + 1) % (n + 1);
}
}
cout << n + 1 << endl;
for (int i = 0; i < n + 1; i++, cout << '\n')
for (int j = 0; j < n; j++) cout << ans[i][j];
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int abs(int x) { return (x > 0 ? x : -x); }
int main() {
ios::sync_with_stdio(false);
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 != x2 && y1 != y2 && abs(x1 - x2) != abs(y1 - y2))
cout << -1 << endl;
else if (x1 == x2)
cout << x1 + abs(y1 - y2) << " " << y1 << " " << x2 + abs(y1 - y2) << " "
<< y2 << endl;
else if (y1 == y2)
cout << x1 << " " << y1 + abs(x1 - x2) << " " << x2 << " "
<< y2 + abs(x1 - x2) << endl;
else
cout << x1 << " " << y2 << " " << x2 << " " << y1 << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 1e6;
const long long inf = 1e9 + 7;
const long double PI = acos(-1);
long long bin_pow(long long x, long long y) {
long long res = 1, base = x;
while (y) {
if (y & 1) {
res *= base;
res %= inf;
}
base *= base;
base %= inf;
y /= 2;
}
return res;
}
int n;
int mx, pos, d;
int deep[N];
int up[N][21];
bool upper(int v, int u) { return deep[v] < deep[u]; }
int lca(int v, int u) {
if (!upper(v, u)) {
swap(v, u);
}
int mask = deep[u] - deep[v];
for (int i = 20; i >= 0; i--) {
if (mask & (1 << i)) {
u = up[u][i];
}
}
if (v == u) {
return v;
}
for (int i = 20; i >= 0; i--) {
if (up[v][i] != up[u][i]) {
v = up[v][i];
u = up[u][i];
}
}
return up[v][0];
}
int main() {
boost();
cin >> n;
deep[1] = 0;
up[1][0] = 1;
for (int i = 1; i < 21; i++) {
up[1][i] = 1;
}
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
up[i][0] = x;
for (int j = 1; j < 21; j++) {
up[i][j] = up[up[i][j - 1]][j - 1];
}
deep[i] = deep[x] + 1;
if (deep[i] > mx) {
d++;
mx = deep[i];
pos = i;
} else {
int y = lca(pos, i);
d = max(d, deep[i] + mx - 2 * deep[y]);
}
cout << d << endl;
}
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> g(n);
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--, u--;
g[v].push_back(u);
g[u].push_back(v);
}
array<int, 2> s, t, len;
for (int i = 0; i < 2; i++) {
cin >> s[i] >> t[i] >> len[i];
s[i]--, t[i]--;
}
auto bfs = [&](int v) -> vector<int> {
vector<int> dist(n, INF);
dist[v] = 0;
queue<int> q;
q.push(v);
while (q.size()) {
int v = q.front();
q.pop();
for (auto u : g[v]) {
if (dist[u] > dist[v] + 1) {
dist[u] = dist[v] + 1;
q.push(u);
}
}
}
return dist;
};
array<vector<int>, 2> dist_s, dist_t;
for (int i = 0; i < 2; i++) {
dist_s[i] = bfs(s[i]);
dist_t[i] = bfs(t[i]);
}
for (int i = 0; i < 2; i++) {
if (dist_s[i][t[i]] > len[i]) return cout << "-1\n", 0;
}
int mn = dist_s[0][t[0]] + dist_s[1][t[1]];
auto process = [&]() {
for (int v = 0; v < n; v++) {
vector<int> dist_v = bfs(v);
for (int u = 0; u < n; u++) {
bool ok = true;
for (int i = 0; i < 2; i++)
ok &= (dist_v[u] + dist_s[i][v] + dist_t[i][u] <= len[i]);
if (ok)
mn = min(mn, dist_s[0][v] + dist_v[u] + dist_t[0][u] + dist_s[1][v] +
dist_t[1][u]);
}
}
};
process();
swap(s[0], t[0]);
swap(dist_s[0], dist_t[0]);
process();
cout << m - mn << '\n';
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 20;
const int maxM = (1 << maxN) + 10;
const int Mod = 1000000007;
const int inv2 = 500000004;
int n;
char In[maxM];
int A[maxM], C[maxM], pw[maxN + 10];
void FWT(int N, int *P, int opt);
int main() {
scanf("%d", &n);
int N = 1 << n;
scanf("%s", In);
for (int i = 0; i < N; i++) A[i] = In[i] - '0';
FWT(N, A, 1);
for (int i = 0; i < N; i++) A[i] = 1ll * A[i] * A[i] % Mod;
FWT(N, A, -1);
pw[0] = 1;
for (int i = 1; i < maxN + 10; i++) pw[i] = 2ll * pw[i - 1] % Mod;
for (int i = 0; i < N; i++) C[i] = C[i >> 1] + (i & 1);
int Ans = 0;
for (int i = 0; i < N; i++)
Ans = (Ans + 1ll * pw[n - C[i]] * A[i] % Mod) % Mod;
Ans = 3ll * Ans % Mod;
printf("%d\n", Ans);
return 0;
}
void FWT(int N, int *P, int opt) {
for (int i = 1; i < N; i <<= 1)
for (int j = 0; j < N; j += (i << 1))
for (int k = 0; k < i; k++) {
int X = P[j + k], Y = P[j + k + i];
P[j + k] = (X + Y) % Mod;
P[j + k + i] = (X - Y + Mod) % Mod;
if (opt == -1)
P[j + k] = 1ll * P[j + k] * inv2 % Mod,
P[j + k + i] = 1ll * P[j + k + i] * inv2 % Mod;
}
return;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const long long int MAX = 2e18;
bool GoodNumber(long long int N) {
while (N > 0) {
if (N % 3 == 2) {
return false;
}
N /= 3;
}
return true;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int i = n;
while (1) {
if (GoodNumber(i)) {
cout << i << endl;
break;
}
i++;
}
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s, t;
cin >> s >> t;
int n = s.size(), m = t.size();
int ans = 0, x, f;
string q = "", w;
for (int i = 0; i < n; i++) {
if (i >= m - 1) {
f = 1;
for (int j = i - m + 1; j <= i; j++) {
if (s[j] != t[j - i + m - 1]) {
f = 0;
break;
}
}
if (f) {
ans++;
s[i] = '#';
}
}
}
cout << ans;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int(i) = 0; (i) < (((int)((t).size()))); ++(i)) s << t[i] << " ";
return s;
}
int main() {
int(n);
cin >> (n);
;
set<string> st;
unordered_map<string, string> m;
vector<string> ans;
for (int(i) = 0; (i) < (n); ++(i)) {
string s1, s2;
cin >> s1 >> s2;
if (st.find(s1) == st.end()) {
ans.push_back(s1);
}
st.insert(s2);
m[s1] = s2;
}
cout << ans.size() << endl;
for (auto s : ans) {
cout << s << " ";
string str = s;
auto it = m.find(str);
while (it != m.end()) {
str = it->second;
it = m.find(str);
}
cout << str << endl;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int n, k, g[123][123], f[123], a[123], b[123], u[123], v[123];
int fpow(int a, int n) {
int res = 1;
for (; n; n >>= 1, a = (long long)a * a % 1000000007)
if (n & 1) res = (long long)res * a % 1000000007;
return res;
}
int main() {
int i = 1, j, k, l, o;
for (scanf("%d", &n), i = 2; i <= n; i++) {
scanf("%d%d", u + i, v + i);
}
for (i = 0; i < n; i++) {
for (j = 1; j < n; j++)
for (k = 1; k <= n; k++) g[j][k] = -i;
for (j = 2; j <= n; j++) g[u[j]][v[j]] = g[v[j]][u[j]] = -1;
for (j = 1; j < n; j++) {
g[j][j] = 0;
for (k = 1; k <= n; k++) g[j][j] -= (k != j) * g[j][k];
}
for (l = j = 1; j < n; j++) {
for (k = j; k < n; k++)
if (g[j][k]) break;
if (k == n) {
l = 0;
break;
}
if (k > j)
for (l *= -1, o = j; o < n; o++) swap(g[j][o], g[k][o]);
l = (long long)l * g[j][j] % 1000000007;
o = fpow(g[j][j], 1000000007 - 2);
for (k = j; k < n; k++) g[j][k] = (long long)g[j][k] * o % 1000000007;
for (k = j + 1; k < n; k++)
if (g[k][j])
for (o = n - 1; o >= j; o--)
g[k][o] = (g[k][o] - (long long)g[k][j] * g[j][o]) % 1000000007;
}
f[i] = (l + 1000000007) % 1000000007;
}
for (i = 1; i < n; i++)
for (j = n - 1; j >= i; j--)
f[j] = (f[j] - f[j - 1] + 1000000007) % 1000000007;
for (b[0] = f[0], i = k = a[0] = 1; i < n;
k = (long long)k * ++i % 1000000007) {
for (j = i; j; j--)
a[j] = (a[j - 1] - (long long)a[j] * (i - 1) % 1000000007 + 1000000007) %
1000000007;
for (f[i] = (long long)f[i] * fpow(k, 1000000007 - 2) % 1000000007,
a[0] = j++;
j <= i; j++) {
b[j] = (b[j] + (long long)a[j] * f[i] % 1000000007) % 1000000007;
}
}
for (i = n - 1; ~i; i--) printf("%d ", b[i]);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e18;
const int mod = (int)1e9 + 7;
const int MAXN = (int)3e5 + 5;
long long n;
long long a[MAXN];
long long b[MAXN];
map<pair<long long, long long>, long long> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < (1 << 15); i++) {
int cur = i;
long long hash = 0;
long long base = 1;
long long hash2 = 0, base2 = 1;
for (int j = 0; j < n; j++) {
long long sim = a[j] ^ cur;
long long cnt = 0;
for (int k = 0; k < 15; k++) {
if (sim % 2) cnt++;
sim /= 2;
}
hash += base * (cnt + 1);
hash %= mod;
hash2 += base2 * (cnt + 1);
base2 *= 43;
hash2 %= mod;
base2 %= mod;
base *= 37;
base %= mod;
}
mp[{hash, hash2}] = i;
}
long long addend = 0;
long long addend2 = 0;
long long base = 1;
long long base2 = 1;
long long num = 0;
for (int i = 0; i < n; i++) {
addend += base;
addend %= mod;
addend2 += base2;
addend2 %= mod;
base2 *= 43;
base2 %= mod;
base *= 37;
base %= mod;
}
for (int i = 0; i < (1 << 15); i++) {
int cur = i;
long long mx = 0;
for (int j = 0; j < n; j++) {
long long sim = (a[j] >> 15);
sim ^= cur;
long long cnt = 0;
for (int k = 0; k < 15; k++) {
if (sim % 2) cnt++;
sim /= 2;
}
b[j] = cnt;
mx = max(mx, b[j]);
}
long long hash = 0;
long long base = 1;
long long hash2 = 0;
long long base2 = 1;
for (int j = 0; j < n; j++) {
hash += base * (mx - b[j] + 1);
hash %= mod;
hash2 += base2 * (mx - b[j] + 1);
hash2 %= mod;
base2 *= 43;
base2 %= mod;
base *= 37;
base %= mod;
}
for (int j = 0; j <= 31 - mx; j++) {
if (mp.find({hash, hash2}) != mp.end()) {
num += (1 << 15) * i;
num += mp[{hash, hash2}];
int gt = __builtin_popcount(a[0] ^ num);
bool cn = 0;
for (int k = 1; k < n; k++) {
int dis = __builtin_popcount(a[k] ^ num);
if (dis != gt) {
cn = 1;
break;
}
}
if (cn) continue;
cout << num << '\n';
return 0;
}
hash += addend;
hash %= mod;
hash2 += addend2;
hash2 %= mod;
}
}
cout << -1 << '\n';
}
| 16
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int inf=0x3f3f3f3f;
const int maxn=1e5+5;
int n,T;
ll a[maxn];
int main(){
cin>>T;
while(T--){
cin>>n;
ll sum=0,mx=0;
for(int i=0;i<n;i++){
cin>>a[i];
mx=max(mx,a[i]);
sum+=a[i];
}
ll tot=mx*(n-1);
if(sum<tot)cout<<tot-sum<<endl;
else{
ll tmp=sum%(n-1);
cout<<(n-1-tmp)%(n-1)<<endl;
}
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e4 + 5, maxm = 1e6 + 5;
struct node {
int l, r;
} q[maxn];
int n, m, s[maxm], a[maxm], ans[maxm], f[maxm];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= maxm - 5; i++) s[i] = s[i - 1] ^ i;
for (int i = 1; i <= m; i++) q[i].l = read(), q[i].r = read();
for (register int i = 1; i <= n; i++) {
f[i] = a[i];
for (register int j = i + 1; j <= n; j++)
f[j] = max(f[j - 1], s[min(a[i], a[j]) - 1] ^ s[max(a[i], a[j])]);
for (register int j = 1; j <= m; j++)
if (i >= q[j].l && i <= q[j].r) ans[j] = max(ans[j], f[q[j].r]);
}
for (int i = 1; i <= m; i++) write(ans[i]), puts("");
return 0;
}
| 20
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
void solve() {
int n;
cin >> n;
map<int, int> m;
m.insert(make_pair(25, 0));
m.insert(make_pair(50, 0));
m.insert(make_pair(100, 0));
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == 25)
m[0] += 1;
else if (x == 50) {
m[1] += 1;
if (m[0] >= 1)
m[0] -= 1;
else {
cout << "NO";
return;
}
} else {
m[2] += 1;
if (m[1] >= 1 && m[0] >= 1) {
m[1] -= 1;
m[0] -= 1;
} else if (m[0] >= 3)
m[0] -= 3;
else {
cout << "NO";
return;
}
}
}
cout << "YES";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) solve();
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
std::vector<long double> v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long double n, a, b, s1, tt;
cin >> n >> a >> b;
int ans = 0;
cin >> s1;
long double sumis = s1;
for (int i = 1; i < n; ++i) {
cin >> tt;
v.push_back(tt);
sumis += tt;
}
sort(v.rbegin(), v.rend());
if ((s1 * a) / sumis >= b) {
cout << "0";
return 0;
}
for (int i = 0; i < n - 1; ++i) {
sumis -= v[i];
ans++;
if ((s1 * a) / sumis >= b) {
cout << ans;
return 0;
}
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int IINF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const double DINF = numeric_limits<double>::infinity();
const int MOD = 1000000007;
const double EPS = 1e-9;
const int DX[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int DY[] = {0, 1, 0, -1, 1, -1, -1, 1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long sqr(long long x) { return x * x; }
long long sqr(int x) { return (long long)x * x; }
double sqr(double x) { return x * x; }
long double sqr(long double x) { return x * x; }
mt19937 mmtw(960172);
long long rnd(long long x, long long y) {
static uniform_int_distribution<long long> d;
return d(mmtw) % (y - x + 1) + x;
}
const int N = 100179;
long long solve(vector<pair<int, int>> a) {
if (a.empty()) return 0;
vector<vector<int>> w(N * 6);
multiset<int> ss1, ss2;
for (pair<int, int>& p : a) {
int x = p.first;
int y = p.second;
p.first = (x + y) / 2;
p.second = (x - y) / 2;
w[p.first + N * 2].push_back(p.second);
ss2.insert(p.second);
}
long long ans = 0;
for (int i = 0; i < N * 6; ++i) {
for (int y : w[i]) {
ss2.erase(ss2.find(y));
ss1.insert(y);
}
if (ss1.empty() || ss2.empty()) continue;
ans += max(
0, min(*ss1.rbegin(), *ss2.rbegin()) - max(*ss1.begin(), *ss2.begin()));
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<pair<int, int>> a1, a2;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
if ((x + y) % 2 == 0)
a1.push_back({x, y});
else
a2.push_back({x, y + 1});
}
cout << solve(a1) + solve(a2) << "\n";
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> pos;
int main() {
int k;
string X;
scanf("%d", &k);
cin >> X;
for (int i = 0; i < X.length(); i++) {
if (X[i] == '1') pos.push_back(i);
}
int n = pos.size();
if (n < k) {
cout << "0";
return 0;
}
if (k == 0) {
long long int ans = 0;
long long int left = -1, right = -1;
for (int i = 0; i < X.length(); i++) {
if ((X[i] == '1') && (left != -1)) {
right = i;
long long int len = right - left + 1 - 2;
ans += (len * (len + 1)) / 2;
left = right;
} else if ((X[i] == '1') && (left == -1)) {
left = i;
long long int len = (left - 1 - 0 + 1);
ans += (len * (len + 1)) / 2;
} else if (i == X.length() - 1) {
right = i;
long long int len = right - left + 1 - 1;
ans += (len * (len + 1)) / 2;
left = right;
}
}
cout << ans;
return 0;
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
if ((i + k - 1) >= n) break;
if ((i == 0) && (i + k - 1 == n - 1)) {
ans += (pos[i] - 0 + 1) * (X.length() - 1 - pos[i + k - 1] + 1);
} else if (i == 0) {
ans += (pos[i] - 0 + 1) * (pos[i + k] - 1 - pos[i + k - 1] + 1);
} else if (i + k - 1 == n - 1) {
ans +=
(pos[i] - pos[i - 1] - 1 + 1) * (X.length() - 1 - pos[i + k - 1] + 1);
} else {
ans +=
(pos[i] - pos[i - 1] - 1 + 1) * (pos[i + k] - 1 - pos[i + k - 1] + 1);
}
}
cout << ans;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const long long INFLL = 1000000000000000000LL;
int n, m, i, j, a, b, nx, px, ny, py;
int main() {
scanf("%d%d%d%d%d%d", &n, &m, &i, &j, &a, &b);
nx = ny = px = py = INF;
if ((i - 1) % a == 0) {
if (((i - 1) / a) % 2) {
nx = min(nx, (i - 1) / a);
} else {
px = min(px, (i - 1) / a);
}
}
if ((n - i) % a == 0) {
if (((n - i) / a) % 2) {
nx = min(nx, (n - i) / a);
} else {
px = min(px, (n - i) / a);
}
}
if ((j - 1) % b == 0) {
if (((j - 1) / b) % 2) {
ny = min(ny, (j - 1) / b);
} else {
py = min(py, (j - 1) / b);
}
}
if ((m - j) % b == 0) {
if (((m - j) / b) % 2) {
ny = min(ny, (m - j) / b);
} else {
py = min(py, (m - j) / b);
}
}
int a1 = INF;
int a2 = INF;
if (py < INF && px < INF) {
if (px > py && (b < j || b <= m - j)) a1 = max(py, px);
if (px < py && (a < i || a <= n - i)) a1 = max(py, px);
if (px == py) a1 = px;
}
if (ny < INF && nx < INF) {
if (nx > ny && (b < j || b <= m - j)) a2 = max(ny, nx);
if (nx < ny && (a < i || a <= n - i)) a2 = max(ny, nx);
if (nx == ny) a2 = nx;
}
if (min(a1, a2) < INF)
printf("%d\n", min(a1, a2));
else
printf("Poor Inna and pony!\n");
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int n, m, b;
struct poi {
int x, k, a;
} P[106];
bool cmp(poi a, poi b) { return a.k < b.k; }
long long dp[2][1 << 20];
signed main() {
cin >> n >> m >> b;
for (int i = 1, c, x; i <= n; ++i) {
scanf("%d%d%d", &P[i].x, &P[i].k, &c);
while (c-- > 0) scanf("%d", &x), P[i].a |= (1 << x - 1);
}
sort(P + 1, P + 1 + n, cmp);
int cur = 0, pre = 1;
long long res = 0x3f3f3f3f3f3f3f3f;
memset(dp[0], 0x3f3f, sizeof dp[0]);
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
cur ^= 1, pre ^= 1;
memset(dp[cur], 0x3f3f, sizeof dp[cur]);
for (int sta = 0; sta < (1 << m); ++sta) {
dp[cur][sta] = min(dp[cur][sta], dp[pre][sta]);
dp[cur][sta | P[i].a] = min(dp[cur][sta | P[i].a], dp[pre][sta] + P[i].x);
}
res = min(res, dp[cur][(1 << m) - 1] + 1ll * P[i].k * b);
}
cout << (res == 0x3f3f3f3f3f3f3f3f ? -1 : res) << endl;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007, ar = 2000005;
unordered_map<string, vector<string> > mp;
vector<string> one, two, tr, all;
map<char, bool> vis;
vector<string> v1, v2, v3, last;
int main() {
int x;
cin >> x;
while (x--) {
int p;
string s;
cin >> p >> s;
all.push_back(s);
for (int w = 0; w < p; w++) {
string z = "";
char a, b;
cin >> a >> b;
z += a;
z += b;
cin >> a;
cin >> a >> b;
z += a;
z += b;
cin >> a;
cin >> a >> b;
z += a;
z += b;
mp[s].push_back(z);
}
if (p == 0) {
v1.push_back(s);
v2.push_back(s);
v3.push_back(s);
last.push_back(s);
}
}
int tax = 0, gir = 0, piz = 0;
for (auto i : mp) {
vector<string> tmp = i.second;
int a = 0, k = 0;
for (int w = 0; w < tmp.size(); w++) {
for (int i = 0; i < tmp[w].size() - 1; i++) {
if (tmp[w][i] == tmp[w][i + 1]) a++;
}
if (a == tmp[w].size() - 1) k++;
a = 0;
}
tax = max(tax, k);
}
if (tax > 0) v1.clear();
for (auto i : mp) {
vector<string> tmp = i.second;
int a = 0, k = 0;
for (int w = 0; w < tmp.size(); w++) {
for (int i = 0; i < tmp[w].size() - 1; i++) {
if (tmp[w][i] == tmp[w][i + 1]) a++;
}
if (a == tmp[w].size() - 1) k++;
a = 0;
}
if (k == tax) {
v1.push_back(i.first);
}
}
for (auto i : mp) {
vector<string> tmp = i.second;
int a = 0, k = 0;
for (int w = 0; w < tmp.size(); w++) {
for (int i = 0; i < tmp[w].size() - 1; i++) {
if (tmp[w][i] > tmp[w][i + 1] && !vis[tmp[w][i]]) {
a++;
vis[tmp[w][i]] = 1;
}
}
vis.clear();
if (a == tmp[w].size() - 1) k++;
a = 0;
}
piz = max(piz, k);
}
if (piz > 0) v2.clear();
for (auto i : mp) {
vector<string> tmp = i.second;
int a = 0, k = 0;
for (int w = 0; w < tmp.size(); w++) {
for (int i = 0; i < tmp[w].size() - 1; i++) {
if (tmp[w][i] > tmp[w][i + 1] && !vis[tmp[w][i]]) {
a++;
vis[tmp[w][i]] = 1;
}
}
vis.clear();
if (a == tmp[w].size() - 1) k++;
a = 0;
}
if (piz == k) v2.push_back(i.first);
}
for (auto i : mp) {
vector<string> tmp = i.second;
int a = 0, k = 0, aa = 0, kk = 0;
for (int w = 0; w < tmp.size(); w++) {
for (int i = 0; i < tmp[w].size() - 1; i++) {
if (tmp[w][i] > tmp[w][i + 1] && !vis[tmp[w][i]]) {
a++;
vis[tmp[w][i]] = 1;
}
if (tmp[w][i] == tmp[w][i + 1]) aa++;
}
vis.clear();
bool fin = 0;
if (a != tmp[w].size() - 1 && aa != tmp[w].size() - 1) k++;
a = 0, aa = 0;
}
gir = max(gir, k);
}
if (gir > 0) v3.clear();
for (auto i : mp) {
vector<string> tmp = i.second;
int a = 0, k = 0, aa = 0, kk = 0;
for (int w = 0; w < tmp.size(); w++) {
for (int i = 0; i < tmp[w].size() - 1; i++) {
if (tmp[w][i] > tmp[w][i + 1] && !vis[tmp[w][i]]) {
a++;
vis[tmp[w][i]] = 1;
}
if (tmp[w][i] == tmp[w][i + 1]) aa++;
}
vis.clear();
bool fin = 0;
if (a != tmp[w].size() - 1 && aa != tmp[w].size() - 1) k++;
a = 0, aa = 0;
}
if (gir == k) {
v3.push_back(i.first);
}
}
for (int w = 0; w < all.size(); w++) {
for (int i = 0; i < v1.size(); i++) {
if (all[w] == v1[i]) one.push_back(all[w]);
}
for (int i = 0; i < v2.size(); i++) {
if (all[w] == v2[i]) two.push_back(all[w]);
}
for (int i = 0; i < v3.size(); i++) {
if (all[w] == v3[i]) tr.push_back(all[w]);
}
}
v1 = one;
v2 = two;
v3 = tr;
cout << "If you want to call a taxi, you should call: ";
if (v1.size())
for (int w = 0; w < v1.size() - 1; w++) {
cout << v1[w] << ", ";
}
if (v1.size()) cout << v1[v1.size() - 1] << ".";
cout << endl;
cout << "If you want to order a pizza, you should call: ";
if (v2.size())
for (int w = 0; w < v2.size() - 1; w++) {
cout << v2[w] << ", ";
}
if (v2.size()) {
cout << v2[v2.size() - 1] << ".";
}
cout << endl;
cout
<< "If you want to go to a cafe with a wonderful girl, you should call: ";
if (v3.size())
for (int w = 0; w < v3.size() - 1; w++) {
cout << v3[w] << ", ";
}
if (v3.size()) {
cout << v3[v3.size() - 1] << ".";
}
cout << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x = sqrt(8 * n + 1) + 1e-8;
cout << (x * x == 8 * n + 1 ? "YES" : "NO");
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int inf = 1e9;
int n, m, h;
vector<int> g[maxn];
int degree[maxn], killed[maxn];
void print_ans(vector<int> &ans, int i, int j) {
printf("%d\n", j - i + 1);
for (int k = (i); k <= (j); k++) printf("%d%c", ans[k], k == j ? '\n' : ' ');
}
int idx[maxn];
void find_cycle() {
int u = 1;
while (killed[u]) u++;
vector<int> ans;
ans.push_back(u);
for (int i = (1); i <= (n); i++) idx[i] = -1;
idx[u] = 0;
while (1) {
for (int v : g[u])
if (!killed[v]) {
if (idx[v] == -1) {
idx[v] = ans.size();
ans.push_back(u = v);
break;
} else if (idx[u] - idx[v] + 1 >= h) {
puts("2");
print_ans(ans, idx[v], idx[u]);
return;
}
}
}
}
const int maxnode = 4 * maxn;
struct Node {
int l, r, mdeg, mpos;
} tr[maxnode];
void maintain(int o) {
if (tr[tr[o].l].mdeg < tr[tr[o].r].mdeg) {
tr[o].mdeg = tr[tr[o].l].mdeg;
tr[o].mpos = tr[tr[o].l].mpos;
} else {
tr[o].mdeg = tr[tr[o].r].mdeg;
tr[o].mpos = tr[tr[o].r].mpos;
}
}
int tc;
int build(int L, int R) {
int o = ++tc;
if (L == R) {
tr[o].mdeg = degree[L];
tr[o].mpos = L;
} else {
int M = (L + R) / 2;
tr[o].l = build(L, M);
tr[o].r = build(M + 1, R);
maintain(o);
}
return o;
}
int query(int o) { return tr[o].mpos; }
void update(int o, int L, int R, int p, int d = 0) {
if (L == R) {
if (d == 0) {
killed[L] = 1;
degree[L] = inf;
} else {
degree[L] += d;
}
tr[o].mdeg = degree[L];
} else {
int M = (L + R) / 2;
if (p <= M)
update(tr[o].l, L, M, p, d);
else
update(tr[o].r, M + 1, R, p, d);
maintain(o);
}
}
void print_tree(int o, int L, int R, int indent = 0) {
int M = (L + R) / 2;
for (int i = (1); i <= (indent); i++) printf(" ");
if (L != R)
printf("[%d,%d]:deg=%d,pos=%d\n", L, R, tr[o].mdeg, tr[o].mpos);
else {
printf("[%d]:deg=%d,pos=%d\n", L, tr[o].mdeg, tr[o].mpos);
return;
}
print_tree(tr[o].l, L, M, indent + 1);
print_tree(tr[o].r, M + 1, R, indent + 1);
}
int root;
void kill(int u) { update(root, 1, n, u); }
void upd(int u) { update(root, 1, n, u, -1); }
int main() {
scanf("%d", &n);
scanf("%d", &m);
while (h * h < n) h++;
for (int i = (1); i <= (m); i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
g[u].push_back(v);
g[v].push_back(u);
degree[u]++;
degree[v]++;
}
root = build(1, n);
vector<int> ans;
for (int k = (1); k <= (h); k++) {
int u = query(root);
if (degree[u] < h - 1) {
kill(u);
for (int v : g[u])
if (!killed[v]) {
kill(v);
for (int first : g[v])
if (!killed[first]) upd(first);
}
ans.push_back(u);
} else {
find_cycle();
return 0;
}
}
puts("1");
int last = ans.size() - 1;
for (int i = (0); i <= (last); i++)
printf("%d%c", ans[i], i == last ? '\n' : ' ');
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int a[10];
int n, ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
a[t]++;
}
while (a[1] >= 1 && a[2] >= 1) {
a[1] -= 1;
a[2] -= 1;
a[3] += 1;
ans += 1;
}
while (a[2] >= 3) {
a[2] -= 3;
a[3] += 2;
ans += 2;
}
while (a[2] >= 2) {
a[2] -= 2;
a[4] += 1;
ans += 2;
}
while (a[2] >= 1 && a[4] >= 1) {
a[4] -= 1;
a[2] -= 1;
a[3] += 2;
ans += 1;
}
while (a[1] >= 2 && a[2] >= 1) {
a[1] -= 2;
a[2] -= 1;
a[4] += 1;
ans += 2;
}
while (a[1] >= 3) {
a[1] -= 3;
a[3] += 1;
ans += 2;
}
while (a[1] >= 4) {
a[1] -= 4;
a[4] += 1;
ans += 3;
}
while (a[2] >= 1 && a[3] >= 2) {
a[2] -= 1;
a[3] -= 2;
a[4] += 2;
ans += 2;
}
while (a[1] >= 2 && a[4] >= 1) {
a[1] -= 2;
a[4] -= 1;
a[3] += 2;
ans += 2;
}
while (a[1] >= 1 && a[3] >= 1) {
a[1] -= 1;
a[3] -= 1;
a[4] += 1;
ans += 1;
}
while (a[1] >= 1 && a[4] >= 2) {
a[1] -= 1;
a[4] -= 2;
a[3] += 3;
ans += 2;
}
if (a[1] || a[2])
printf("-1");
else
printf("%d", ans);
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int n;
deque<int> adj[1001];
deque<int> leaf;
int sze[1001];
bool visit[1001];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
sze[x]++, sze[y]++;
}
for (int i = 1; i <= n; i++)
if (adj[i].size() == 1) leaf.push_back(i);
for (int i = 0; i < n / 2; i++) {
int a = leaf.front();
int b = leaf.back();
leaf.pop_front();
leaf.pop_back();
cout << "? " << a << ' ' << b << endl;
int reply;
cin >> reply;
if (reply == a || reply == b) {
cout << "! " << reply << endl;
return 0;
}
for (auto i : adj[a]) {
if (visit[i]) continue;
sze[i]--;
if (sze[i] == 1) leaf.push_back(i);
}
for (auto i : adj[b]) {
if (visit[i]) continue;
sze[i]--;
if (sze[i] == 1) leaf.push_back(i);
}
visit[a] = visit[b] = true;
}
cout << "! " << leaf.front() << endl;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int n, a[N], dp[N][N];
int rec(int i, int j) {
if (j > n) {
return a[i];
}
if (dp[i][j] > 0) {
return dp[i][j];
}
return dp[i][j] = min({max(a[i], a[j]) + rec(j + 1, j + 2),
max(a[i], a[j + 1]) + rec(j, j + 2),
max(a[j], a[j + 1]) + rec(i, j + 2)});
}
void get(int i, int j) {
if (j > n) {
if (i <= n) {
cout << i << "\n";
}
return;
}
if (dp[i][j] == max(a[i], a[j]) + rec(j + 1, j + 2)) {
cout << i << " " << j << "\n";
get(j + 1, j + 2);
} else if (dp[i][j] == max(a[i], a[j + 1]) + rec(j, j + 2)) {
cout << i << " " << j + 1 << "\n";
get(j, j + 2);
} else {
cout << j << " " << j + 1 << "\n";
get(i, j + 2);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cout << rec(1, 2) << "\n";
get(1, 2);
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, d;
scanf("%d%d", &n, &d);
char opp[d][n];
for (int i = 0; i < d; i++) {
scanf("%s", opp[i]);
}
int counter = 0, maxi = 0;
for (int i = 0; i < d; i++) {
bool beaten = false;
for (int k = 0; k < n; k++) {
if (opp[i][k] == '0') {
beaten = true;
counter++;
break;
}
}
if (!beaten) {
counter = 0;
}
if (counter > maxi) {
maxi = counter;
}
}
printf("%d\n", maxi);
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
void make_change(vector<int> &a, int idx, int val, long long &ans) {
int n = a.size() - 2;
for (int i = idx - 1; i <= idx + 1; i++) {
if (1 <= i && i <= n) {
if (a[i - 1] <= a[i] && a[i] >= a[i + 1]) {
ans -= a[i];
} else if (a[i - 1] >= a[i] && a[i] <= a[i + 1]) {
ans += a[i];
}
}
}
a[idx] = val;
for (int i = idx - 1; i <= idx + 1; i++) {
if (1 <= i && i <= n) {
if (a[i - 1] <= a[i] && a[i] >= a[i + 1]) {
ans += a[i];
} else if (a[i - 1] >= a[i] && a[i] <= a[i + 1]) {
ans -= a[i];
}
}
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, q;
scanf("%d%d", &n, &q);
vector<int> a(n + 2);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i - 1] <= a[i] && a[i] >= a[i + 1]) {
ans += a[i];
} else if (a[i - 1] >= a[i] && a[i] <= a[i + 1]) {
ans -= a[i];
}
}
printf("%lld\n", ans);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
int l_val = a[l], r_val = a[r];
make_change(a, l, r_val, ans);
make_change(a, r, l_val, ans);
printf("%lld\n", ans);
}
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int main() { cout << "Red" << endl; }
| 10
|
#include <bits/stdc++.h>
int main() {
int n, a, b, t;
scanf("%d", &(n)), scanf("%d", &(a)), scanf("%d", &(b));
t = n * b;
t = ceil((double)t / 100);
printf("%d", (0 > (t - a) ? 0 : (t - a)));
printf("\n");
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 1;
long long getS(long long x) { return x * (x + 1) / 2; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T-- > 0) {
long long x;
cin >> x;
int ans = 0;
for (int i = 1; getS((1LL << i) - 1) <= x; i++) {
ans++;
x -= getS((1LL << i) - 1);
}
cout << ans << '\n';
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, i, ans = 0;
cin >> n;
long long int ar[n + 1];
for (i = 0; i < n; i++) {
cin >> ar[i];
}
while (!is_sorted(ar, ar + n)) {
if (ans & 1) {
for (i = 1; i < n - 1; i += 2) {
if (ar[i] > ar[i + 1]) swap(ar[i], ar[i + 1]);
}
} else {
for (i = 0; i < n - 1; i += 2) {
if (ar[i] > ar[i + 1]) swap(ar[i], ar[i + 1]);
}
}
ans++;
}
cout << ans << endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2021;
int d[N][N], vis[N][N];
int n, m, ex, ey, k, x, y;
bool inmap(int x, int y) { return x > 0 && x <= n && y > 0 && y <= m; }
bool check(int x, int y) {
int l = max(x - d[x][y], 1), r = min(x + d[x][y], n);
for (int i = l; i <= r; i++) {
int t = d[x][y] - abs(i - x);
if (inmap(i, y - t) && !vis[i][y - t]) {
ex = i;
ey = y - t;
return false;
}
if (inmap(i, y + t) && !vis[i][y + t]) {
ex = i;
ey = y + t;
return false;
}
}
return true;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
while (k--) {
scanf("%d%d", &x, &y);
if (!vis[x][y]) {
printf("%d %d\n", x, y);
vis[x][y] = 1;
continue;
}
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
if (!inmap(x + i, y + j)) continue;
d[x][y] = max(d[x][y], d[x + i][y + j] - abs(i) - abs(j));
}
}
while (check(x, y)) d[x][y]++;
vis[ex][ey]++;
printf("%d %d\n", ex, ey);
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool isPrime(T x) {
if (x <= 1) return false;
T i;
for (i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
template <class T>
class Prime {
public:
vector<T> z;
Prime() {
z.resize(1e5 + 7);
for (int i = (0); i < (((int)z.size())); i++) z[i] = 1;
z[0] = 0;
z[1] = 0;
T j;
for (int i = (2); i < (((int)z.size())); i++) {
if (z[i]) {
j = i + i;
while (j < ((int)z.size())) {
z[j] = 0;
j += i;
}
}
}
}
};
template <class T>
double dist(T x1, T y1, T x2, T y2) {
return sqrt(1. * (x2 - x1) * (x2 - x1) + 1. * (y2 - y1) * (y2 - y1));
}
template <class T>
class Point {
public:
T x, y;
Point() {}
Point(T a, T b) : x(a), y(b) {}
bool operator==(const Point& tmp) const { return (x == tmp.x && y == tmp.y); }
Point operator-(const Point& tmp) const {
return Point<T>(x - tmp.x, y - tmp.y);
}
};
char toLowerCase(char x) { return (x + 32); }
char toUpperCase(char x) { return (x - 32); }
bool isUpperCase(char x) { return (65 <= x && x <= 90) ? 1 : 0; }
bool isLowerCase(char x) { return (97 <= x && x <= 122) ? 1 : 0; }
bool isAlpha(char x) { return (isUpperCase(x) || isLowerCase(x)) ? 1 : 0; }
bool isDigit(char x) { return ('0' <= x && x <= '9') ? 1 : 0; }
template <class T>
T toDec(string s) {
stringstream is(s);
T res;
is >> res;
return res;
}
template <class T>
string toStr(T n) {
string s;
stringstream is;
is << n;
is >> s;
return s;
}
template <class T>
void checkmin(T& a, T b) {
if (a > b) a = b;
}
template <class T>
void checkmax(T& a, T b) {
if (a < b) a = b;
}
int main() {
int n, k, ans = -1e9;
cin >> n >> k;
vector<int> was(n);
int i;
for (i = 0; i < n; i++) cin >> was[i];
int l, r;
for (l = 0; l < n; l++) {
for (r = l; r < n; r++) {
vector<int> inn, outt;
for (i = 0; i < l; i++) outt.push_back(was[i]);
int sum = 0;
for (i = r + 1; i < n; i++) outt.push_back(was[i]);
for (i = l; i <= r; i++) inn.push_back(was[i]), sum += was[i];
sort(inn.begin(), inn.end());
sort(outt.begin(), outt.end());
reverse(outt.begin(), outt.end());
ans = max(ans, sum);
int take = min(k, min(((int)inn.size()), ((int)outt.size())));
for (i = 0; i < take; i++) {
sum = sum - inn[i] + outt[i];
ans = max(ans, sum);
}
}
}
cout << ans;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
long long add(long long a, long long b) { return min((long long)2e18, a + b); }
long long mul(long long a, long long b) {
if ((long double)a * b > 4e18) return 2e18;
return min((long long)2e18, a * b);
}
const int nax = 60;
long long g[nax];
long long mem[nax];
long long f(int n) {
if (n <= 1) return 1;
if (!mem[n]) {
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = add(ans, mul(g[i], f(n - i - 1)));
}
mem[n] = ans;
}
return mem[n];
}
int main() {
g[0] = g[1] = 1;
for (int i = 2; i < nax; i++) {
g[i] = mul(g[i - 1], i - 1);
}
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
k--;
if (f(n) <= k) {
cout << -1 << endl;
continue;
}
vector<int> p(n, -1);
int ma = -1;
long long ind = 0;
set<int> left;
map<int, int> par;
function<int(int)> find = [&](int p) {
return par[p] == p ? p : par[p] = find(par[p]);
};
for (int i = 0; i < n; i++) {
if (left.empty()) {
ma = -1;
for (int j = i; j < n; j++) {
long long cp = ind;
ind = add(ind, mul(g[j - i], f(n - j - 1)));
if (ind > k) {
ma = j;
ind = cp;
break;
}
}
par.clear();
for (int j = i; j <= ma; j++) {
left.insert(j);
par[j] = j;
}
p[i] = ma;
assert(ma != -1);
} else {
for (int j : left) {
if (find(j) == i) continue;
int ls = left.size();
long long cp = ind;
ind = add(ind, mul(g[ls - 1], f(n - ma - 1)));
if (ind > k) {
ind = cp;
p[i] = j;
break;
}
}
assert(p[i] != -1);
}
assert(ind <= k);
assert(p[i] != -1);
if (p[i] != ma) {
par[i] = par[p[i]];
}
assert(left.count(p[i]));
left.erase(p[i]);
}
assert(ind == k);
for (int v : p) cout << v + 1 << ' ';
cout << endl;
for (int i = 0; i < n; i++) {
int j = i, ma = -1, cnt = 0;
do {
cnt++;
j = p[j];
ma = max(ma, j);
} while (j != i);
assert(cnt == ma - i + 1);
i = ma;
}
}
}
| 19
|
#include <bits/stdc++.h>
int main() {
int n;
int x;
long long total = 0;
int i;
int j = 1;
scanf("%d %d", &n, &x);
for (i = 0; i < n; i++) {
int first;
int second;
scanf("%d %d", &first, &second);
total += (second - first) + (first - j) % x + 1;
j = second + 1;
}
printf("%I64d", total);
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 1e4 + 10;
const int MAXE = 1e5 + 5;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long tot;
long long head[MAXV], level[MAXV], iter[MAXV];
struct Edge {
long long v, cap, nxt;
Edge() {}
Edge(long long v, long long cap, long long nxt) : v(v), cap(cap), nxt(nxt) {}
} edge[MAXE << 1];
void init() {
tot = 0;
memset(head, -1, sizeof(head));
}
void add_edge(long long u, long long v, long long c) {
edge[tot] = Edge(v, c, head[u]);
head[u] = tot++;
edge[tot] = Edge(u, 0, head[v]);
head[v] = tot++;
}
void bfs(long long s) {
memset(level, -1, sizeof(level));
level[s] = 0;
queue<long long> que;
que.push(s);
while (!que.empty()) {
long long u = que.front();
que.pop();
for (long long i = head[u]; ~i; i = edge[i].nxt) {
long long v = edge[i].v;
long long c = edge[i].cap;
if (c > 0 && level[v] < 0) {
level[v] = level[u] + 1;
que.push(v);
}
}
}
}
long long dfs(long long u, long long t, long long f) {
if (u == t) return f;
for (long long &i = iter[u]; ~i; i = edge[i].nxt) {
long long v = edge[i].v;
long long c = edge[i].cap;
if (c > 0 && level[u] < level[v]) {
long long d = dfs(v, t, min(f, c));
if (d > 0) {
edge[i].cap -= d;
edge[i ^ 1].cap += d;
return d;
}
}
}
return 0;
}
long long max_flow(long long s, long long t) {
long long flow = 0;
while (1) {
bfs(s);
if (level[t] < 0) return flow;
long long f;
memcpy(iter, head, sizeof(head));
while (f = dfs(s, t, INF)) flow += f;
}
}
int node[55][55];
int main() {
init();
int n, h, m;
scanf("%d%d%d", &n, &h, &m);
long long ans = 1LL * n * h * h;
int tot = 0;
int s = ++tot;
int t = ++tot;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= h; j++) {
node[i][j] = ++tot;
if (j != 1) {
add_edge(node[i][j], node[i][j - 1], INF);
}
add_edge(s, node[i][j], 2 * j - 1);
}
}
for (int i = 1; i <= m; i++) {
++tot;
int l, r, x, c;
scanf("%d%d%d%d", &l, &r, &x, &c);
if (x >= h) continue;
for (int j = l; j <= r; j++) {
add_edge(node[j][x + 1], tot, INF);
}
add_edge(tot, t, c);
}
printf("%lld", ans - max_flow(s, t));
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int a[1007];
int b[1007];
int main() {
int n, x, y;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
cin >> b[i];
}
int co = 0;
for (int i = 0; i < n; i++) {
int r = 0, d = 0, l = 0, u = 0;
for (int j = 0; j < n; j++) {
if (b[i] == b[j] && a[i] > a[j])
r++;
else if (b[i] == b[j] && a[i] < a[j])
l++;
else if (a[i] == a[j] && b[i] > b[j])
d++;
else if (a[i] == a[j] && b[i] < b[j])
u++;
}
if (r && l && d && u) co++;
}
cout << co << endl;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int dp[100005];
int main() {
int n, m;
cin >> n >> m;
int arr[100005];
int l;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
set<int> s;
for (int i = n - 1; i >= 0; i--) {
s.insert(arr[i]);
dp[i + 1] = s.size();
}
for (int i = 0; i < m; i++) {
cin >> l;
cout << dp[l] << endl;
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, t;
long long bs_ch(long long mid, long long x) {
if (mid * mid + mid <= 2 * x) return 1;
return 0;
}
long long bs(long long l, long long r, long long x) {
long long mid = (l + r) / 2;
while (r - l > 1) {
bs_ch(mid, x) ? l = mid : r = mid;
mid = (l + r) / 2;
}
return r;
}
int main() {
cin >> t;
while (t--) {
cin >> n >> k;
k--;
long long x = bs(0, n - 1, k);
k -= x * (x + 1) / 2;
if (k)
for (int i = n - 1; i >= 0; i--)
(i == x || i == k + x) ? cout << 'b' : cout << 'a';
else {
for (int i = n - 1; i > 0; i--)
(i == x || i == k + x) ? cout << 'b' : cout << 'a';
cout << "b";
}
cout << endl;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long N = 3e5 + 5;
const int32_t M = 998244353;
long long pw(long long a, long long p = M - 2, long long MOD = M) {
long long result = 1;
while (p > 0) {
if (p & 1) result = a * result % MOD;
a = a * a % MOD;
p >>= 1;
}
return result;
}
long long fact[N], invfact[N];
void init() {
long long p = M;
fact[0] = 1;
long long i;
for (i = 1; i < N; i++) {
fact[i] = i * fact[i - 1] % p;
}
i--;
invfact[i] = pw(fact[i], p - 2, p);
for (i--; i >= 0; i--) {
invfact[i] = invfact[i + 1] * (i + 1) % p;
}
}
long long ncr(long long n, long long r) {
if (r > n || n < 0 || r < 0) return 0;
return fact[n] * invfact[r] % M * invfact[n - r] % M;
}
void solve() {
long long n;
cin >> n;
vector<long long> a(2 * n);
for (long long i = 0; i < (long long)2 * n; ++i) {
cin >> a[i];
}
sort((a).begin(), (a).end());
long long sum1 = 0;
long long sum2 = 0;
for (long long i = 0; i < (long long)n; ++i) sum1 += a[i];
for (long long i = 0; i < (long long)n; ++i) sum2 += a[i + n];
long long tot = (sum2 - sum1) % M;
cout << ncr(2 * n, n) * tot % M << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
init();
long long a = 1;
while (t--) {
solve();
a += 1;
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long a[9];
long long dfs(long long vis, long long w) {
if (vis > 8) return w;
long long res = min(a[vis], w / vis), mins = 1e18;
for (long long i = res; i >= max(res - 8 / vis - 2, (long long)0); i--) {
mins = min(mins, dfs(vis + 1, w - i * vis));
}
return mins;
}
int main() {
long long w;
while (cin >> w) {
for (long long i = 1; i <= 8; i++) cin >> a[i];
cout << w - dfs(1, w) << endl;
}
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long n, long long k, int p = (int)1e9 + 7) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = 2 * acos((long double)0);
const int maxn = 10;
int n, k;
int a[maxn];
int id[maxn][maxn];
vector<pair<int, int> > per;
int ans, cnt;
void go(int k) {
if (!k) {
for (int i = (0); i < (n); i++)
for (int j = (i + 1); j < (n); j++) {
ans += a[i] > a[j];
}
cnt++;
return;
}
for (int i = (0); i < (int((per).size())); i++) {
int l = per[i].first;
int r = per[i].second;
reverse(a + l, a + r + 1);
go(k - 1);
reverse(a + l, a + r + 1);
}
}
void solve() {
scanf("%d%d", &n, &k);
for (int i = (0); i < (n); i++) scanf("%d", a + i);
for (int l = (0); l < (n); l++)
for (int r = (l); r < (n); r++) {
per.push_back(make_pair(l, r));
}
go(k);
cout << fixed << setprecision(9) << (long double)ans / cnt;
}
int main() {
solve();
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, i2, i3, re = 0;
vector<int> disc, prices;
cin >> m;
disc.reserve(m);
for (i = 0; i < m; i++) {
cin >> i2;
disc.push_back(i2);
}
cin >> n;
prices.reserve(n);
for (i = 0; i < n; i++) {
cin >> i2;
prices.push_back(i2);
}
sort(disc.begin(), disc.end());
sort(prices.begin(), prices.end());
i2 = n - 1;
while (i2 >= 0) {
for (i3 = 0; i3 < disc[0] && i2 >= 0; i3++) {
re += prices[i2];
i2--;
}
i2 -= 2;
}
cout << re;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
bool f = 0;
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
if (f) return -sum;
return sum;
}
const int N = 100005;
const int M = 20000007;
const int orz = 1000000000;
char S[N], T[N];
int n, m, p, f[M], s[N], t[N], nxt[N], to[N][30];
inline void up(int &x, int y) {
if (y > x) x = y;
}
int main() {
int i, j, k, z;
scanf("%s", S + 1);
n = strlen(S + 1);
scanf("%s", T + 1);
m = strlen(T + 1);
for (i = 1; i <= n; i++) s[i] = S[i] - 'a' + 1;
for (i = 1; i <= m; i++) t[i] = T[i] - 'a' + 1;
to[0][t[1]] = 1;
for (i = 2, j = 0; i <= m + 1; i++) {
for (k = 1; k <= 26; k++) to[i - 1][k] = to[j][k];
while (j && t[j + 1] != t[i]) j = nxt[j];
if (t[j + 1] == t[i]) j++;
nxt[i] = j;
to[i - 1][t[i]] = i;
}
p = m + 1;
k = n * (m + 1);
for (i = 1; i <= k; i++) f[i] = -orz;
for (i = 0; i < n; i++)
if (S[i + 1] == '?')
for (j = 0; j <= m; j++)
for (z = f[(i)*p + j], k = 1; k <= 26; k++)
up(f[(i + 1) * p + to[j][k]], z + (to[j][k] == m));
else
for (j = 0; j <= m; j++)
z = to[j][s[i + 1]], up(f[(i + 1) * p + z], f[(i)*p + j] + (z == m));
int ans = 0;
for (j = 0; j <= m; j++) up(ans, f[(n)*p + j]);
printf("%d", ans);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int N, A, B, d[2003], a[2003], b[2003], ab[2003];
pair<int, int> calc(int c1, int c2) {
int ans1 = 0, ans2 = 0, rem = 0;
for (int i = 1; i <= N; i++) {
int add1 = a[i] - c1, add2 = b[i] - c2;
int add3 = ab[i] - c1 - c2;
if (add1 <= 0 && add2 <= 0 && add3 <= 0)
d[i] = d[i - 1];
else if (add3 > add1 && add3 > add2)
d[i] = d[i - 1] + add3, ans1++, ans2++;
else if (add1 > add2)
d[i] = d[i - 1] + add1, ans1++;
else if (add2 > add1)
d[i] = d[i - 1] + add2, ans2++;
else
d[i] = d[i - 1] + add1, rem++;
}
if (ans1 >= A) return {ans1, ans2 + rem};
int da = min(A - ans1, rem);
return {ans1 + da, ans2 + rem - da};
}
int main() {
scanf("%d %d %d", &N, &A, &B);
for (int i = 1, x, f; i <= N; i++) {
scanf("%d.%d", &x, &f);
a[i] = x * 1000000 + f * 1000;
}
for (int i = 1, x, f; i <= N; i++) {
scanf("%d.%d", &x, &f);
b[i] = x * 1000000 + f * 1000;
}
for (int i = 1; i <= N; i++)
ab[i] = a[i] + b[i] - (a[i] / 1000) * (b[i] / 1000);
int al = 0, ar = 1000000, am, bm, ansa = 1000001, ansb = 1000001;
while (al <= ar) {
am = (al + ar) / 2;
int bl = 0, br = 1000000, tmp = 1000001;
while (bl <= br) {
bm = (bl + br) / 2;
if (calc(am, bm).second <= B)
br = bm - 1, tmp = bm;
else
bl = bm + 1;
}
if (calc(am, tmp).first <= A)
ar = am - 1, ansa = am, ansb = tmp;
else
al = am + 1;
}
calc(ansa, ansb);
int sum = d[N] + ansa * A + ansb * B;
printf("%d.%06d\n", sum / 1000000, sum % 1000000);
return 0;
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int res = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) res = res * 10 + c - '0', c = getchar();
return res;
}
const int N = 2e3 + 10;
const int Mod = 998244353;
int n, ans = 0;
int matrix[N][N], p[N][N], t[N];
bitset<N> f, g, pre[N], a, b, c;
int add(int a, int b) { return (a += b) >= Mod ? a - Mod : a; }
int sub(int a, int b) { return (a -= b) < 0 ? a + Mod : a; }
int mul(int a, int b) { return 1ll * a * b % Mod; }
int fast_pow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) res = mul(res, a);
return res;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
pre[i] = (pre[i - 1] << 1);
pre[i].set(1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) matrix[i][j] = read();
t[1] = 0, t[2] = 1;
for (int i = 3; i <= n; i++) t[i] = mul(i - 1, add(t[i - 1], t[i - 2]));
p[0][0] = 1;
for (int i = 1; i <= n; i++) p[i][0] = mul(p[i - 1][0], i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++) p[i][j] = sub(p[i][j - 1], p[i - 1][j - 1]);
for (int i = 1; i <= n; i++) {
a = f & pre[matrix[1][i] - 1];
ans = add(ans, mul(matrix[1][i] - 1 - a.count(), p[n - i][0]));
f.set(matrix[1][i]);
}
ans = mul(ans, fast_pow(t[n], n - 1));
for (int i = 2; i <= n; i++) {
f.reset(), g = pre[n];
int tmp = 0;
for (int j = 1; j <= n; j++) {
g.reset(matrix[i - 1][j]);
a = (pre[n] ^ f) & pre[matrix[i][j] - 1];
a.reset(matrix[i - 1][j]);
b = a & g;
c = f & g;
tmp = add(tmp, mul(b.count(), p[n - j][n - j - (1 + c.count())]));
tmp = add(tmp, mul(a.count() - b.count(), p[n - j][n - j - c.count()]));
f.set(matrix[i][j]);
}
ans = add(ans, mul(tmp, fast_pow(t[n], n - i)));
}
printf("%d", ans);
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
using dpii = deque<pii>;
dpii split(string str) {
dpii res;
for (int i = 0, j; i < int((str).size()); i = j) {
j = i;
while (j < int((str).size()) && str[j] == str[i]) j++;
res.push_back({str[i] - 'a', j - i});
}
return res;
}
int main() {
setIO();
string _s, _t;
re(_s, _t);
dpii second = split(_s), t = split(_t);
auto sim_swap = [&](int si, int ti) {
assert(0 <= si && si <= int((second).size()));
assert(0 <= ti && ti <= int((t).size()));
int tsz = int((t).size()) - ti + si, tf = 0;
if (tsz) {
if (si > 0 && ti < int((t).size()) && second[si - 1].first == t[ti].first)
tsz--;
tf = si ? second.front().first : t[ti].first;
}
int ssz = int((second).size()) - si + ti, sf = 0;
if (ssz) {
if (ti > 0 && si < int((second).size()) &&
t[ti - 1].first == second[si].first)
ssz--;
sf = ti ? t.front().first : second[si].first;
}
int ops = (si > 0 || ti > 0) + max(tsz - 1, 0) + max(ssz - 1, 0);
if (tf == sf) {
if (tsz > ssz)
tsz--;
else
ssz--;
}
ops -= max(0, min(tsz, ssz) - 1);
return ops;
};
vpii ops;
auto do_swap = [&](int si, int ti) {
if (si == 0 && ti == 0) return;
ops.push_back({0, 0});
stack<pii> st, ts;
for (int i = 0; i < (si); i++) {
pii p = second.front();
second.pop_front();
ops.back().first += p.second;
st.push(p);
}
for (int i = 0; i < (ti); i++) {
pii p = t.front();
t.pop_front();
ops.back().second += p.second;
ts.push(p);
}
if (!ts.empty() && !second.empty() &&
ts.top().first == second.front().first) {
second.front().second += ts.top().second;
ts.pop();
}
while (!ts.empty()) {
second.push_front(ts.top());
ts.pop();
}
if (!st.empty() && !t.empty() && st.top().first == t.front().first) {
t.front().second += st.top().second;
st.pop();
}
while (!st.empty()) {
t.push_front(st.top());
st.pop();
}
};
array<int, 3> ans{INT_MAX, -1, -1};
for (int si = 0; si < (int((second).size()) + 1); si++) {
int tn = (2 * si + int((t).size()) - int((second).size())) / 2;
for (int ti = (max(tn - 3, 0)); ti < (min(tn + 3, int((t).size())) + 1);
ti++) {
ckmin(ans, {sim_swap(si, ti), si, ti});
}
}
do_swap(ans[1], ans[2]);
while (int((second).size()) > 1 || int((t).size()) > 1) {
array<int, 3> best{INT_MAX, -1, -1};
for (int si = 0; si < (min(2, int((second).size())) + 1); si++)
for (int ti = (!si); ti < (min(2, int((t).size())) + 1); ti++)
ckmin(best, {sim_swap(si, ti), si, ti});
do_swap(best[1], best[2]);
}
ps(int((ops).size()));
for (auto& p : ops) ps(p.first, p.second);
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[100];
cin >> str;
int l = 0;
while (str[l] != '\0') l++;
int m = 0;
for (int i = 1; i < l; i++) {
if (str[i] == str[i - 1])
m++;
else
m = 0;
if (m == 6) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 3;
set<pair<int, int> > s;
int ans[maxn];
int main() {
long long sum = 0;
int n, k, a;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a);
s.insert(make_pair(a, i));
if (i >= k + 1) {
auto t = s.end();
--t;
ans[t->second] = i;
sum = sum + 1LL * (i - t->second) * t->first;
s.erase(t);
}
}
for (int i = 1; i <= k; ++i) {
auto t = s.end();
--t;
ans[t->second] = n + i;
sum = sum + 1LL * (i + n - t->second) * t->first;
s.erase(t);
}
printf("%lld\n", sum);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
char temp[15];
int dp[26][26] = {0};
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> temp;
int sized = strlen(temp);
int start = temp[0] - 97;
int end = temp[sized - 1] - 97;
for (int i = 0; i < 26; ++i) {
if (dp[i][start] != 0)
dp[i][end] = max(dp[i][end], dp[i][start] + (int)sized);
}
dp[start][end] = max(dp[start][end], (int)sized);
}
int mans = -1;
for (int i = 0; i < 26; ++i) {
mans = max(mans, dp[i][i]);
}
cout << mans << endl;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int nm = 1005;
const int mm = 1005;
int n, k, m, t;
int res;
int f[2002][2055];
bool check[nm];
const int MOD = 1000000007;
int main() {
int i, j, x, y, z, w;
f[0][0] = 1;
scanf("%d%d", &n, &k);
t = 1 << k;
for (i = 1; i <= n; i++) {
scanf("%d", &x);
for (j = 0; j < t; j += 2) {
if (x != 4) {
if (f[i - 1][j]) {
f[i][j + 2] = (f[i][j + 2] + f[i - 1][j]) % MOD;
}
}
if (x != 2) {
if (f[i - 1][j])
if (j % 4 == 0)
f[i][j + 4] = (f[i][j + 4] + f[i - 1][j]) % MOD;
else
f[i][4] = (f[i][4] + f[i - 1][j]) % MOD;
}
}
if (x == 0) {
res <<= 1;
res %= MOD;
}
res = (res + f[i][t]) % MOD;
}
printf("%d ", res);
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
long long int x[1000001], y[1000001], n, mx, a, b;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n, m, ans = 0;
cin >> n >> m;
long long int a[100] = {}, b[100] = {};
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
long long int x;
cin >> x;
if (x == 0) {
a[i + j]++;
} else {
b[i + j]++;
}
}
}
long long int k = n + m - 2;
for (long long int i = 0; i < k; i++, k--) {
ans += min(a[i] + a[k], b[i] + b[k]);
}
cout << ans << "\n";
ans = 0;
}
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
long long int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}, inf = 1e18 + 1;
bool valid(long long int x, long long int y, long long int n, long long int m) {
return (x >= 0 and y >= 0 and x < n and y < m);
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
vector<string> v(n - 2);
for (long long int i = 0; i < n - 2; i++) cin >> v[i];
string ans = "";
ans.push_back(v[0][0]);
for (long long int i = 1; i < n - 2; i++) {
if (v[i][0] != v[i - 1][1]) ans.push_back(v[i - 1][1]);
ans.push_back(v[i][0]);
if (i == n - 3) ans.push_back(v[i][1]);
}
while (ans.length() < n) ans.push_back(v[n - 3][1]);
cout << ans << "\n";
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<long long> a(n + 1), b(n + 1);
deque<pair<long long, long long> > lines;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
lines.push_back({b[1], 0});
long long ans = 0;
for (int i = 2; i <= n; i++) {
while (lines.size() > 1) {
pair<long long, long long> c = lines[0], d = lines[1];
if (a[i] >= (d.second - c.second) / (c.first - d.first))
lines.pop_front();
else
break;
}
long long g = lines.front().first, h = lines.front().second;
ans = a[i] * g + h;
while (lines.size() > 1) {
pair<long long, long long> c = lines[lines.size() - 1],
d = lines[lines.size() - 2];
long long x =
(d.second - c.second + (c.first - d.first)) / (c.first - d.first);
if (c.first - b[i] >= (ans - c.second + x - 1) / x)
lines.pop_back();
else
break;
}
lines.push_back({b[i], ans});
}
cout << ans << endl;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
char str[55];
int num[55], low[55], oth[55];
int main() {
int n, len;
while (scanf("%d%d", &n, &len) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%s", str);
num[i] = low[i] = oth[i] = 1000000;
for (int j = 0; j < len; j++) {
int tmp = min(j, len - j);
if (str[j] >= '0' && str[j] <= '9')
num[i] = min(num[i], tmp);
else if (str[j] >= 'a' && str[j] <= 'z')
low[i] = min(low[i], tmp);
else
oth[i] = min(oth[i], tmp);
}
}
int ans = 1000000;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) {
if (i == j || i == k || j == k) continue;
ans = min(ans, num[i] + low[j] + oth[k]);
}
printf("%d\n", ans);
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
long long mod = 1e9 + 7;
using namespace std;
void solve() {
int n;
cin >> n;
cout << 3 << " " << 3 << endl;
int ans[3][3];
int k = 0;
while (n >= (1 << k)) k++;
ans[0][0] = ans[1][2] = (1 << (k + 1)) - 1;
ans[0][1] = ans[0][2] = ans[2][2] = n;
ans[1][0] = ans[1][1] = ans[2][0] = ans[2][1] = (1 << k);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long q;
q = 1;
for (long long i = 0; i < q; i++) {
solve();
}
return 0;
}
| 9
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.