solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
struct tr {
int l, r, val;
};
int sz, h, m, res;
bool used[200200];
int col[200200], pos[200200], maxv[200200];
vector<int> lst[200200];
vector<tr> rmq[200200];
void dfs(int a) {
used[a] = true;
col[a] = sz;
pos[a] = lst[sz].size();
lst[sz].push_back(a);
a = (a + m) % h;
if (!used[a]) {
dfs(a);
}
}
inline void update(vector<tr> &rmq, int maxv, int a, int b) {
a += maxv;
rmq[a].val = b;
while (a > 1) {
a /= 2;
rmq[a].val = min(rmq[a * 2].val, rmq[a * 2 + 1].val);
}
}
void dfs(vector<tr> &rmq, int maxv, int v, int l, int r) {
if (rmq[v].l > r || rmq[v].r < l || l > r) {
return;
}
if (rmq[v].val > 0) {
return;
}
if (v >= maxv) {
res = min(res, v - maxv);
return;
}
if (rmq[v].l >= l && rmq[v].r <= r) {
if (rmq[v * 2].val == 0) {
dfs(rmq, maxv, v * 2, l, r);
} else {
dfs(rmq, maxv, v * 2 + 1, l, r);
}
return;
}
dfs(rmq, maxv, v * 2, l, r);
dfs(rmq, maxv, v * 2 + 1, l, r);
}
int main() {
int n;
scanf("%d %d %d", &h, &m, &n);
sz = 0;
for (int i = 0; i < h; i++) {
if (!used[i]) {
dfs(i);
sz++;
}
}
for (int i = 0; i < sz; i++) {
maxv[i] = 1;
while (maxv[i] < (int)lst[i].size()) {
maxv[i] *= 2;
}
rmq[i].resize(2 * maxv[i]);
for (int j = 0; j < maxv[i]; j++) {
rmq[i][j + maxv[i]].l = rmq[i][j + maxv[i]].r = j;
rmq[i][j + maxv[i]].val = 0;
}
for (int j = maxv[i] - 1; j > 0; j--) {
rmq[i][j].l = rmq[i][j * 2].l;
rmq[i][j].r = rmq[i][j * 2 + 1].r;
rmq[i][j].val = 0;
}
}
map<int, int> mem;
long long ans = 0;
for (int i = 0; i < n; i++) {
char ch;
int id;
scanf(" %c %d", &ch, &id);
if (ch == '+') {
int hash;
scanf("%d", &hash);
res = inf;
dfs(rmq[col[hash]], maxv[col[hash]], 1, pos[hash],
(int)lst[col[hash]].size() - 1);
if (res == inf) {
ans += (int)lst[col[hash]].size() - pos[hash];
dfs(rmq[col[hash]], maxv[col[hash]], 1, 0, pos[hash] - 1);
ans += res;
} else {
ans += res - pos[hash];
}
mem[id] = lst[col[hash]][res];
update(rmq[col[hash]], maxv[col[hash]], res, 1);
continue;
}
int elem = mem[id];
update(rmq[col[elem]], maxv[col[elem]], pos[elem], 0);
}
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
static int r, sign;
static char c;
r = 0, c = getchar(), sign = 1;
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') sign = -1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + (c - '0'), c = getchar();
return r * sign;
}
template <typename T>
inline void print(T* a, int n) {
for (int i = 1; i < n; ++i) cout << a[i] << " ";
cout << a[n] << endl;
}
void print(int n) {
if (n >= 5) {
printf("-O|");
n -= 5;
} else
printf("O-|");
int cnt = 0;
while (n--) {
++cnt;
printf("O");
}
printf("-");
while (cnt++ < 4) printf("O");
printf("\n");
}
int main(int argc, char* argv[]) {
int n;
scanf("%d", &n);
if (n == 0) print(n);
while (n > 0) {
print(n % 10);
n /= 10;
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
double c[205], p[205], ans;
int main() {
cin >> n;
for (int i = 0; i <= n; i++) scanf("%lf", &p[i]);
for (int i = 0; i <= n; i++) c[i] = fabs(n - 2 * i);
for (int i = 0; i <= (n - 1) / 2; i++)
for (int j = (n - 1) / 2 + 1; j <= n; j++)
ans = max(ans, (c[j] * p[i] + c[i] * p[j]) / (c[j] + c[i]));
printf("%.12lf", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
struct BstNode {
int data;
BstNode *left;
BstNode *right;
};
BstNode *GetNewNode(int data) {
BstNode *newNode = new BstNode();
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
BstNode *Insert(BstNode *root, int data) {
if (root == NULL) {
root = GetNewNode(data);
} else if (data <= root->data) {
root->left = Insert(root->left, data);
} else {
root->right = Insert(root->right, data);
}
return root;
}
bool Search(BstNode *root, int data) {
if (root == NULL) {
return false;
} else if (root->data == data) {
return true;
} else if (data <= root->data) {
return Search(root->left, data);
} else {
return Search(root->right, data);
}
}
int find_min(BstNode *root) {
BstNode *current = root;
if (current->left == NULL) {
return current->data;
}
find_min(current->left);
}
int cnt = 1;
int max_e(BstNode *root) {
BstNode *cure = root;
if (root == NULL) {
return cure->data;
}
max_e(root->right);
}
void travel_orde(BstNode *root) {
if (root == NULL) {
return;
}
queue<BstNode *> Q;
Q.push(root);
while (!Q.empty()) {
BstNode *current = Q.front();
Q.pop();
cout << current->data << " ";
if (current->left != NULL) Q.push(current->left);
if (current->right != NULL) Q.push(current->right);
}
}
void prorder(BstNode *root) {
if (root == NULL) {
return;
}
cout << root->data << " ";
prorder(root->left);
prorder(root->right);
}
void inorder(BstNode *root) {
if (root == NULL) {
return;
}
inorder(root->left);
cout << root->data << " ";
inorder(root->right);
}
void postorder(BstNode *root) {
if (root == NULL) {
return;
}
postorder(root->left);
postorder(root->right);
cout << root->data << " ";
}
int find_hieg(BstNode *root) {
if (root == NULL) {
return -1;
}
int le = find_hieg(root->left);
int ri = find_hieg(root->right);
cout << "val " << root->data << " "
<< " " << endl;
cout << le << " " << ri << endl;
return max(le, ri) + 1;
}
long long generate_divisors(long long n) {
vector<int> v;
long long i;
for (i = 1; i * i < n; i++) {
if (v.size() > 3) {
return 4;
}
if (n % i == 0) {
v.push_back(i), v.push_back(n / i);
}
}
if (i * i == n) v.push_back(i);
return v.size();
}
deque<int> t;
void terrnary(int number) {
if (number == 0) {
return;
}
terrnary(number / 3);
t.push_back(number % 3);
}
int main() {
deque<int> temp;
long long a, b;
cin >> a;
cin >> b;
if (a == b & a == 0) {
cout << a;
return 0;
}
terrnary(a);
for (int i = 0; i < t.size(); i++) {
temp.push_back(t[i]);
}
t.clear();
terrnary(b);
if (temp.size() > t.size()) {
int diff = temp.size() - t.size();
while (diff) {
t.push_front(0);
diff--;
}
} else if (temp.size() < t.size()) {
int diff = t.size() - temp.size();
while (diff) {
temp.push_front(0);
diff--;
}
}
vector<int> num;
for (int i = 0; i < t.size(); i++) {
if (t[i] == 1) {
if (temp[i] != 2)
num.push_back(!temp[i]);
else
num.push_back(2);
} else if (t[i] == 0) {
if (temp[i] != 0)
num.push_back(3 - temp[i]);
else
num.push_back(0);
} else if (t[i] == 2) {
num.push_back(2 - temp[i]);
}
}
int len = num.size();
long long number = 0;
for (int i = 0; i < num.size(); i++) {
len--;
number += num[i] * pow(3, len);
if (i + 1 == num.size()) cout << number;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1012;
int n, k, t = 0, tot = 0, ans[N], tim[N], du[N];
int w[N * N];
bool del[N];
struct Point {
int x, y;
} a[N];
inline int Dist(Point a, Point b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
struct Edge {
int u, v;
Edge *next;
} e[N * N], *P, *point[N];
inline void Add_Edge(int a, int b) {
P->u = a;
P->v = b;
P->next = point[a];
point[a] = P++;
++du[b];
}
inline void Remove(int now) {
if (++tim[now] > 1) return;
del[now] = true;
++tot;
for (Edge *j = point[now]; j; j = j->next)
if (!del[j->v]) --du[now], --du[j->v];
}
inline void Resume(int now) {
if (--tim[now] > 0) return;
del[now] = false;
--tot;
for (Edge *j = point[now]; j; j = j->next)
if (!del[j->v]) ++du[now], ++du[j->v];
}
bool Dfs(int now) {
if (tot > k) return false;
if (now > n) {
int l = 0, r = n + 1;
for (int i = 1; i <= n; ++i)
if (del[i])
ans[++l] = i;
else
ans[--r] = i;
return true;
}
if (du[now] == 0) return Dfs(now + 1);
if (du[now] > 1) {
Remove(now);
if (Dfs(now + 1)) return true;
Resume(now);
}
for (Edge *j = point[now]; j; j = j->next) Remove(j->v);
if (Dfs(now + 1)) return true;
for (Edge *j = point[now]; j; j = j->next) Resume(j->v);
return false;
}
bool Check(int key) {
memset(du, 0, sizeof(du));
memset(tim, 0, sizeof(tim));
memset(del, false, sizeof(del));
P = e;
memset(point, 0, sizeof(point));
tot = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j < i; ++j)
if (Dist(a[i], a[j]) > key) Add_Edge(i, j), Add_Edge(j, i);
return Dfs(1);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d%d", &a[i].x, &a[i].y);
for (int i = 1; i <= n; ++i)
for (int j = 1; j < i; ++j) w[++t] = Dist(a[i], a[j]);
sort(w + 1, w + t + 1);
int l = 1, r = t;
while (l <= r) {
int mid = (l + r) / 2;
if (Check(w[mid]))
r = mid - 1;
else
l = mid + 1;
}
Check(w[l]);
for (int i = 1; i <= k; ++i) printf("%d ", ans[i]);
puts("");
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e5 + 10;
int p[Maxn];
int b[Maxn];
pair<long long, long long> a[Maxn];
long long t[Maxn];
long long sum[Maxn];
int c[Maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < m; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a, a + m);
for (int i = 0; i < m; i++) {
t[i] = a[i].first;
}
for (int i = 0; i < m; i++) {
sum[i + 1] = sum[i] + a[i].second;
}
for (int i = 0; i < n; i++) {
long long re = p[i];
int pos = upper_bound(t, t + m, re) - t;
printf("%lld ", sum[pos]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, i, f = -1, l = -1;
scanf("%d\n", &n);
char a[n + 1], c;
gets(a);
for (i = 0; i < n; i++) {
if (a[i] != '.' && (f == -1 && l == -1)) {
if (a[i] == 'R')
f = i + 1;
else {
l = i;
}
c = a[i];
}
if (a[i] != c && (f != -1 || l != -1)) {
if (a[i - 1] == 'R') {
l = i;
if (a[i] == '.') l++;
} else if (a[i - 1] == 'L') {
f = i;
}
break;
}
}
printf("%d %d", f, l);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef struct node {
int idx, up, cost;
node(){};
node(int a, int b, int c) { idx = a, up = b, cost = c; }
bool operator<(const node& x) const {
if (cost != x.cost) return cost < x.cost;
if (idx != x.idx) return idx < x.idx;
if (up != x.up) return up < x.up;
}
} node;
int maxiRightIdx;
int vis[1005][3 * 1005];
pair<int, int> edges[3 * 1005];
vector<pair<int, int> > adj[1005];
int n, m, a, b, c, d;
int dijkstra() {
int ret = -1e9;
memset(vis, 63, sizeof vis);
set<node> pq;
pq.insert(node(1, maxiRightIdx, 0));
while (!pq.empty()) {
node cur = *pq.begin();
pq.erase(pq.begin());
if (cur.idx == n) {
ret = max(ret, edges[cur.up].second - cur.cost + 1);
continue;
}
if (cur.cost > vis[cur.idx][cur.up]) continue;
for (int i = 0; i < adj[cur.idx].size(); i++) {
int to = adj[cur.idx][i].first;
int e = adj[cur.idx][i].second;
if (edges[cur.up].second < edges[e].first || cur.cost > edges[e].second)
continue;
node next(to, edges[cur.up].second < edges[e].second ? cur.up : e,
max(cur.cost, edges[e].first));
if (vis[next.idx][next.up] > next.cost) {
set<node>::iterator it =
pq.find(node(next.idx, next.up, vis[next.idx][next.up]));
if (it != pq.end()) pq.erase(it);
pq.insert(next);
vis[next.idx][next.up] = next.cost;
}
}
}
return ret;
}
int main() {
int besti = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
edges[i].first = c;
edges[i].second = d;
adj[a].push_back(pair<int, int>(b, i));
adj[b].push_back(pair<int, int>(a, i));
if (d >= besti) {
besti = d;
maxiRightIdx = i;
}
}
int ans = dijkstra();
if (ans > 0) {
cout << ans << endl;
} else {
cout << "Nice work, Dima!" << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 100009;
int t, n;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int x1 = -1;
for (int i = 1; i <= 10000; i++) {
if (i >= a && i >= d && a * 2 >= i && d * 2 < i) {
x1 = i;
break;
}
}
int x2 = -1;
for (int i = 1; i <= 10000; i++) {
if (i >= b && i >= d && b * 2 >= i && d * 2 < i) {
x2 = i;
break;
}
}
int x3 = -1;
for (int i = 1; i <= 10000; i++) {
if (i >= c && i >= d && c * 2 >= i && d * 2 >= i) {
x3 = i;
break;
}
}
if (x1 == -1 || x2 == -1 || x3 == -1)
puts("-1");
else {
while (x3 >= x2) x2++;
while (x1 <= x2) x1++;
if (!(x1 >= a && a * 2 >= x1 && x1 >= d && d * 2 < x1)) x1 = -1;
if (!(x2 >= b && b * 2 >= x2 && x2 >= d && d * 2 < x2)) x2 = -1;
if (x1 == -1 || x2 == -1 || x3 == -1)
puts("-1");
else
printf("%d\n%d\n%d\n", x1, x2, x3);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int nextInt() {
int x;
scanf("%d", &x);
return x;
}
long long nextLong() {
long long x;
scanf("%I64d", &x);
return x;
}
double nextDouble() {
double x;
scanf("%lf", &x);
return x;
}
const int BUFSIZE = 1000000;
char buf[BUFSIZE + 1];
string nextString() {
scanf("%s", buf);
return buf;
}
const int MOD = 1000000009;
const int WORDLENGTH = 10;
const int DICTSIZE = 10;
const int TRIESIZE = WORDLENGTH * DICTSIZE + 1;
const int LENGTH = 1000;
vector<string> dict;
int trie[TRIESIZE][26];
int trieSize;
int nextPref[TRIESIZE][26];
int maxWordInPref[TRIESIZE];
int prefLength[TRIESIZE];
int memo[TRIESIZE][WORDLENGTH + 1][LENGTH + 1];
int solve(int pref, int notCover, int length) {
if (length == 0) {
return notCover == 0;
}
int &res = memo[pref][notCover][length];
if (res != -1) {
return res;
}
res = 0;
for (int c = 0; c < 26; ++c) {
int npref = nextPref[pref][c];
if (npref == 0) {
continue;
}
int nnotCover = notCover + 1;
if (maxWordInPref[npref] >= nnotCover) {
nnotCover = 0;
}
if (nnotCover > prefLength[npref]) {
continue;
}
res = (res + solve(npref, nnotCover, length - 1)) % MOD;
}
return res;
}
void initTrie() {
memset(trie, -1, sizeof(trie));
trieSize = 1;
for (int i = 0; i < dict.size(); ++i) {
int at = 0;
for (int j = 0; j < dict[i].size(); ++j) {
int c = dict[i][j] - 'a';
if (trie[at][c] == -1) {
prefLength[trieSize] = j + 1;
trie[at][c] = trieSize++;
}
at = trie[at][c];
}
}
}
int getPref(string s) {
int at = 0;
for (int i = 0; i < s.size(); ++i) {
int c = s[i] - 'a';
if (trie[at][c] == -1) {
return -1;
}
at = trie[at][c];
}
return at;
}
void initNextPref() {
memset(nextPref, -1, sizeof(nextPref));
for (int i = 0; i < dict.size(); ++i) {
for (int prefLength = 0; prefLength <= dict[i].size(); ++prefLength) {
string str = dict[i].substr(0, prefLength);
int pref = getPref(str);
for (int c = 0; c < 26; ++c) {
if (nextPref[pref][c] == -1) {
string ex = str;
ex += c + 'a';
for (int length = ex.size(); length >= 0; --length) {
int npref = getPref(ex.substr(ex.size() - length));
if (npref != -1) {
nextPref[pref][c] = npref;
break;
}
}
}
}
}
}
}
void initMaxWordInPref() {
memset(maxWordInPref, -1, sizeof(maxWordInPref));
for (int i = 0; i < dict.size(); ++i) {
for (int prefLength = 0; prefLength <= dict[i].size(); ++prefLength) {
string prefStr = dict[i].substr(0, prefLength);
int pref = getPref(prefStr);
if (maxWordInPref[pref] == -1) {
for (int subLength = prefStr.size(); subLength >= 0; --subLength) {
string subStr = prefStr.substr(prefStr.size() - subLength);
for (int j = 0; j < dict.size(); ++j) {
if (dict[j] == subStr) {
maxWordInPref[pref] = subLength;
break;
}
}
if (maxWordInPref[pref] != -1) {
break;
}
}
}
}
}
}
int main() {
int n = nextInt();
int m = nextInt();
dict = vector<string>(m);
for (int i = 0; i < dict.size(); ++i) {
dict[i] = nextString();
for (int j = 0; j < dict[i].size(); ++j) {
dict[i][j] = tolower(dict[i][j]);
}
}
initTrie();
initNextPref();
initMaxWordInPref();
memset(memo, -1, sizeof(memo));
int res = solve(0, 0, n);
cout << res << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, m, k;
char s[N], t[N];
int f[N], l[N], r[N];
void build(string &s) {
int j = 0;
for (int i = 1; i < s.size(); ++i) {
while (j && s[i] != s[j]) j = f[j - 1];
if (s[i] == s[j]) ++j;
f[i] = j;
}
}
int len;
string S, T;
void validate(int a, int b) {
return;
assert(a >= 0 && a + k - 1 < b && b + k - 1 < S.size());
string q = S.substr(a, k) + S.substr(b, k);
q = T + "#" + q;
build(q);
bool ok = false;
for (int i = T.size(); i < q.size(); ++i)
if (f[i] == len) {
ok = true;
break;
}
if (!ok)
while (1)
;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf("%s%s", s, t);
S = s;
T = t;
string x = T + "#" + S;
build(x);
memset(l, -1, sizeof(l));
memset(r, -1, sizeof(r));
len = T.size();
for (int i = T.size(); i < x.size(); ++i) {
int cur = f[i];
if (len <= k && cur == len) {
int e = i - T.size() - 1;
int s = e - len + 1;
int l = e - k + 1;
l = max(l, 0);
int r = l + k - 1;
if (r < S.size() && S.size() - r - 1 >= k) {
puts("Yes");
validate(l, r + 1);
printf("%d %d\n", l + 1, r + 2);
return 0;
}
r = s + k - 1;
r = min(r, (int)S.size() - 1);
l = r - k + 1;
if (l >= k) {
puts("Yes");
validate(0, l);
printf("%d %d\n", 1, l + 1);
return 0;
}
}
}
for (int i = T.size() + k; i < x.size(); ++i) {
if (f[i]) {
int cur = f[i];
while (cur) {
if (l[cur] != -1) break;
l[cur] = i - T.size() - 1;
cur = f[cur - 1];
}
}
}
reverse(S.begin(), S.end());
reverse(T.begin(), T.end());
x = T + "#" + S;
build(x);
for (int i = T.size() + k; i < x.size(); ++i) {
if (f[i]) {
int cur = f[i];
while (cur) {
if (r[cur] != -1) break;
r[cur] = i - T.size() - 1;
r[cur] = S.size() - r[cur] - 1;
cur = f[cur - 1];
}
}
}
reverse(S.begin(), S.end());
reverse(T.begin(), T.end());
l[0] = k - 1;
r[0] = S.size() - k;
for (int i = 0; i <= len; ++i) {
if (l[i] != -1) assert(l[i] >= k - 1);
if (r[i] != -1) assert(r[i] <= S.size() - k);
}
for (int i = 0; i <= len; ++i) {
if (i <= k && len - i <= k && l[i] != -1 && r[len - i] != -1 &&
l[i] < r[len - i]) {
puts("Yes");
int a = l[i] - k + 1;
int b = r[len - i];
printf("%d %d\n", a + 1, b + 1);
return 0;
}
}
puts("No");
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
bool isrange(int second, int first, int n, int m) {
if (0 <= second && second < n && 0 <= first && first < m) return true;
return false;
}
int dy[4] = {1, 0, -1, 0}, dx[4] = {0, 1, 0, -1},
ddy[8] = {1, 0, -1, 0, 1, 1, -1, -1}, ddx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const int MAX = 202020;
pair<long long int, long long int> arr[MAX];
int n, k;
struct inf {
long long int val, tot;
int lw, wh;
bool operator<(inf a) const { return val < a.val; }
};
priority_queue<inf> pq;
bool can(long long int first) {
priority_queue<inf> q = pq;
for (int e = 1; e <= k; e++) {
inf now = q.top();
q.pop();
long long int lim = e - now.lw - 1;
long long int nlim = -now.val - now.lw;
if (lim > nlim) {
if (e < k) return false;
long long int df = lim - nlim;
if (df >= 1) return false;
}
if (e == k) return true;
long long int kk = now.tot - (lim + 1) * arr[now.wh].second + first;
if (kk < 0) return false;
long long int f1 = (kk / arr[now.wh].second) + e;
q.push({-f1, kk, e, now.wh});
}
return true;
}
int main(void) {
scanf("%d%d", &n, &k);
for (int e = 0; e < n; e++) scanf("%lld", &arr[e].first);
for (int e = 0; e < n; e++) scanf("%lld", &arr[e].second);
for (int e = 0; e < n; e++)
pq.push({-(arr[e].first / arr[e].second), arr[e].first, 0, e});
long long int ll = 0, rr = 2e12, ans = 1e18, mid;
while (ll <= rr) {
mid = (ll + rr) / 2;
if (can(mid)) {
ans = min(ans, mid);
rr = mid - 1;
} else
ll = mid + 1;
}
if (ans == 1e18) ans = -1;
printf("%lld", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
for (int i = 0; i < 500; ++i) {
if ((i * (i + 1)) / 2 == n) {
cout << "YES\n";
return;
}
}
cout << "NO\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, n, c, k;
cin >> n >> k;
vector<long long> x(n);
for (i = 0; i < n; i++) {
cin >> x[i];
}
sort(x.begin(), x.end());
if (k == 0 && x[k] - 1 != 0)
cout << x[k] - 1 << endl;
else if (x[k - 1] != x[k] && k != 0)
cout << x[k - 1] << endl;
else
cout << "-1" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 1e6 + 10;
using namespace std;
int rd() {
int t;
scanf("%d", &t);
return t;
}
int res[maxn];
vector<int> vec[maxn];
void dfs(int x, int f, int mi) {
res[x] = min(mi, x);
for (int i = 0; i < vec[x].size(); i++) {
int y = vec[x][i];
if (y == f) continue;
dfs(y, x, res[x]);
}
}
signed main() {
int n = rd(), q = rd();
for (int i = 1; i < n; i++) {
int x = rd(), y = rd();
vec[x].push_back(y), vec[y].push_back(x);
}
q -= 1;
int las = 0;
int op = rd(), x = rd();
x = (x + las) % n + 1;
dfs(x, 0, x);
int tem = x;
while (q--) {
int op = rd(), x = rd();
x = (x + las) % n + 1;
if (op == 1) {
tem = min(tem, res[x]);
} else {
las = min(res[x], tem);
cout << las << '\n';
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
double ans = 0;
int a[22], b[22], p[22], q[22], l[22], N, M, A;
double efs() {
for (int i = 1; i <= N; ++i) q[i] = min(p[i] + b[i] * 10, 100);
double ret = 1;
for (int x = 0; x < 1 << N; ++x) {
for (int xx = x, i = 1; i <= N; xx >>= 1, ++i) a[i] = xx & 1;
double prob = 1;
for (int i = 1; i <= N; ++i) prob *= (a[i] ? q[i] : 100 - q[i]) / 100.0;
int agree = 0;
for (int i = 1; i <= N; ++i) agree += a[i];
int B = 0;
for (int i = 1; i <= N; ++i) B += (a[i] ? 0 : l[i]);
ret -= prob * (agree * 2 > N ? 0.0 : (double)B / (A + B));
}
return ret;
}
void dfs(int now, int tot) {
if (now == N) {
ans = max(ans, efs());
return;
}
for (int i = 0; tot + i <= M; ++i) {
b[now + 1] = i;
dfs(now + 1, tot + i);
}
}
int main() {
scanf("%d%d%d", &N, &M, &A);
for (int i = 1; i <= N; ++i) scanf("%d%d", &l[i], &p[i]);
dfs(0, 0);
printf("%.10lf\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long T[5005][5005];
long long powi(long long a, long long b) {
if (!b) return 1;
long long p = powi(a, b / 2);
p = (p * p) % 998244353;
if (b & 1) p = (p * a) % 998244353;
return p;
}
long long mmi(long long x) { return powi(x, 998244353 - 2); }
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
T[0][0] = 1;
for (int i = 1; i <= k; i++)
T[i][1] = 1, T[i][i] = (T[i - 1][i - 1] * i) % 998244353;
for (int i = 3; i <= k; i++) {
for (int j = 2; j < i; j++)
T[i][j] = (T[i - 1][j] + T[i - 1][j - 1]) * j % 998244353;
}
long long ans = 0;
for (int i = 1; i <= k; i++) {
long long x = 1;
for (int j = 0; j < i; j++) x = x * (n - j) % 998244353;
x = (x * mmi(T[i][i])) % 998244353;
x = (x * T[k][i]) % 998244353;
x = (x * mmi(powi(m, i))) % 998244353;
ans = (ans + x) % 998244353;
}
printf("%lld\n", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
long n, s, k, c;
while (t--) {
cin >> n >> s >> k;
set<int> v;
for (int i = 0; i < k; i++) {
cin >> c;
v.insert(c);
}
if (v.find(s) == v.end())
cout << 0 << endl;
else {
long i = 1;
while (i <= k) {
if ((s > i) && (v.find(s - i) == v.end())) break;
if (((s + i) < n + 1) && (v.find(s + i) == v.end())) break;
i++;
}
cout << i << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
map<char, int> base;
char ch;
ch = '0';
for (long long int i = 0; i < 10; i++) {
base[ch] = i;
ch++;
}
ch = 'A';
for (long long int i = 10; i < 36; i++) {
base[ch] = i;
ch++;
}
ch = 'a';
for (long long int i = 36; i < 62; i++) {
base[ch] = i;
ch++;
}
ch = '-';
base[ch] = 62;
ch = '_';
base[ch] = 63;
long long int ways[64];
long long int rem, store;
for (long long int i = 0; i < 64; i++) {
long long int temp = 1;
store = i;
for (long long int j = 1; j <= 6; j++) {
rem = store % 2;
store = store / 2;
if (rem == 0) {
temp = temp * 3;
}
}
ways[i] = temp;
}
long long int ans = 1, len, val;
string str;
cin >> str;
len = str.size();
for (long long int i = 0; i < len; i++) {
val = ways[base[str[i]]];
ans = (ans * val) % 1000000007;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> type;
int main() {
type["void"] = 1;
type["errtype"] = 0;
int n;
string A, B, op;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> op >> A;
int start = 0, end = A.size() - 1;
while (A[start] == '&') start++;
while (A[end] == '*') end--;
if (op == "typedef") {
cin >> B;
int v = type[A.substr(start, end - start + 1)];
if (v == 0) {
type[B] = 0;
continue;
}
v += A.size() - end - 1;
v -= start;
if (v <= 0)
type[B] = 0;
else
type[B] = v;
} else {
int a = type[A.substr(start, end - start + 1)];
if (a == 0) {
cout << "errtype\n";
continue;
}
a += A.size() - end - 1;
a -= start;
if (a <= 0)
cout << "errtype\n";
else {
cout << "void";
for (int i = 1; i < a; i++) cout << '*';
cout << endl;
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5, mod = 1e9 + 7;
int n, m, key[maxn + 5], cnt, c[maxn + 5], suf[maxn + 5], b[maxn + 5],
id[maxn + 5], rk[maxn + 5];
struct node {
int l, r;
} a[maxn + 5];
int Add(int x, int y) { return (x += y) >= mod ? x - mod : x; }
int lb(int x) { return x & (-x); }
void add(int x, int d) {
for (int i = x; i; i -= lb(i)) {
c[i] = Add(c[i], d);
}
}
int sum(int x) {
int ret = 0;
for (int i = x; i <= cnt; i += lb(i)) ret = Add(ret, c[i]);
return ret;
}
vector<int> Q[maxn + 5];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].l, &a[i].r);
key[++cnt] = a[i].l;
id[i] = i;
}
scanf("%d", &m);
sort(key + 1, key + cnt + 1);
cnt = unique(key + 1, key + cnt + 1) - key - 1;
for (int i = 1; i <= n; i++) {
a[i].l = lower_bound(key + 1, key + cnt + 1, a[i].l) - key;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
}
sort(id + 1, id + n + 1, [&](int x, int y) { return a[x].r < a[y].r; });
sort(b + 1, b + m + 1, [&](int x, int y) { return a[x].r < a[y].r; });
for (int i = 1; i <= n; i++) rk[id[i]] = i;
suf[m + 1] = 0;
for (int i = m; i >= 1; i--) {
suf[i] = max(suf[i + 1], a[b[i]].l);
if (suf[i] != suf[i + 1]) {
Q[rk[b[i]] - 1].push_back(suf[i + 1] + 1);
}
}
sort(a + 1, a + n + 1, [&](node x, node y) { return x.r < y.r; });
cnt++;
int ans = 0;
for (auto x : Q[0]) ans++;
for (int i = 1; i <= n; i++) {
int x = a[i].l;
int f = sum(x + 1);
add(x, f + 1);
for (auto x : Q[i]) ans = Add(ans, Add(1, sum(x)));
;
}
cout << ans << '\n';
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
struct edge {
int u, v, i;
edge() {}
edge(int u, int v, int i) : u(u), v(v), i(i) {}
};
const int maxn = 1e5 + 6, maxw = 1e6 + 6;
int n, m;
vector<edge> edgl[maxw];
int ans[maxn];
int par[maxn], sez[maxn];
int find(int x) {
while (x != par[x]) x = par[x];
return x;
}
void unite(int u, int v) {
u = find(u);
v = find(v);
if (sez[u] > sez[v]) swap(u, v);
par[u] = v;
sez[v] += sez[u];
}
void getbridge(map<int, vector<pair<int, int>>>& adjl, set<int>& bridges,
map<int, vector<int>>& to, map<int, int>& lvl, map<int, int>& mn,
int now, int prev, int d) {
lvl[now] = mn[now] = d;
bool cek = 1;
for (auto p : adjl[now]) {
int next = p.first, i = p.second;
if (next == prev) {
to[now].push_back(i);
if (cek) {
cek = 0;
continue;
}
}
if (lvl.count(next))
mn[now] = min(mn[now], lvl[next]);
else {
getbridge(adjl, bridges, to, lvl, mn, next, now, d + 1);
mn[now] = min(mn[now], mn[next]);
}
}
if (mn[now] == lvl[now]) {
for (int i : to[now]) bridges.insert(i);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
edgl[w].push_back(edge(u, v, i));
}
for (int i = 1; i <= n; i++) {
par[i] = i;
sez[i] = 1;
}
for (int w = 1; w < maxw; w++) {
if (edgl[w].empty()) continue;
map<int, vector<pair<int, int>>> adjl;
for (edge e : edgl[w]) {
int u = find(e.u), v = find(e.v);
if (u != v) {
adjl[u].push_back({v, e.i});
adjl[v].push_back({u, e.i});
}
}
map<int, int> lvl, mn;
set<int> bridges;
for (auto p : adjl) {
map<int, vector<int>> to;
if (!lvl.count(p.first))
getbridge(adjl, bridges, to, lvl, mn, p.first, 0, 0);
}
for (edge e : edgl[w]) {
if (find(e.u) == find(e.v))
ans[e.i] = 0;
else if (bridges.count(e.i))
ans[e.i] = 2;
else
ans[e.i] = 1;
}
for (edge e : edgl[w]) {
if (find(e.u) != find(e.v)) unite(e.u, e.v);
}
}
for (int i = 0; i < m; i++) {
if (ans[i] == 0)
cout << "none\n";
else if (ans[i] == 1)
cout << "at least one\n";
else
cout << "any\n";
}
}
| 15 |
#include <bits/stdc++.h>
const int N = 1e5 + 5;
int n, m, a[N], b[N];
long long ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), ans += 1LL * a[i] * m;
for (int i = 1; i <= m; ++i) scanf("%d", &b[i]);
std::sort(a + 1, a + 1 + n), std::sort(b + 1, b + 1 + m);
if (a[n] > b[1]) return puts("-1"), 0;
for (int i = 2; i <= m; ++i) ans += b[i] - a[n];
printf("%lld\n", a[n] == b[1] ? ans : ans + b[1] - a[n - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b, c, d;
long long int w, x, y, z;
long long int a2, a3, b2, b3, c2, c3, d2, d3, ans;
int main() {
cin >> a >> b >> c >> d;
while (a % 2 == 0) {
a /= 2;
a2++;
}
while (a % 3 == 0) {
a /= 3;
a3++;
}
while (b % 2 == 0) {
b /= 2;
b2++;
}
while (b % 3 == 0) {
b /= 3;
b3++;
}
while (c % 2 == 0) {
c /= 2;
c2++;
}
while (c % 3 == 0) {
c /= 3;
c3++;
}
while (d % 2 == 0) {
d /= 2;
d2++;
}
while (d % 3 == 0) {
d /= 3;
d3++;
}
if (a * b != c * d) {
printf("-1\n");
return 0;
}
if (a3 + b3 > c3 + d3) {
ans += (a3 + b3 - c3 - d3);
if (b3 >= a3 + b3 - c3 - d3) {
b2 = b2 + (a3 + b3 - c3 - d3);
b3 = b3 - (a3 + b3 - c3 - d3);
} else {
b2 = b2 + b3;
a2 = a2 + a3 - c3 - d3;
a3 = a3 - (a3 - c3 - d3);
b3 = 0;
}
} else if (a3 + b3 < c3 + d3) {
ans += (c3 + d3 - a3 - b3);
if (d3 >= c3 + d3 - a3 - b3) {
d2 = d2 + (c3 + d3 - a3 - b3);
d3 = d3 - (c3 + d3 - a3 - b3);
} else {
d2 = d2 + d3;
c2 = c2 + c3 - a3 - b3;
c3 = c3 - (c3 - a3 - b3);
d3 = 0;
}
}
if (a2 + b2 > c2 + d2) {
ans += (a2 + b2 - c2 - d2);
if (a2 >= (a2 + b2 - c2 - d2)) {
a2 = a2 - (a2 + b2 - c2 - d2);
} else {
b2 = b2 - (b2 - c2 - d2);
a2 = 0;
}
} else if (a2 + b2 < c2 + d2) {
ans += (c2 + d2 - a2 - b2);
if (c2 >= (c2 + d2 - a2 - b2)) {
c2 = c2 - (c2 + d2 - a2 - b2);
} else {
d2 = d2 - (d2 - a2 - b2);
c2 = 0;
}
}
while (a2 > 0) {
a *= 2;
a2--;
}
while (a3 > 0) {
a *= 3;
a3--;
}
while (b2 > 0) {
b *= 2;
b2--;
}
while (b3 > 0) {
b *= 3;
b3--;
}
while (c2 > 0) {
c *= 2;
c2--;
}
while (c3 > 0) {
c *= 3;
c3--;
}
while (d2 > 0) {
d *= 2;
d2--;
}
while (d3 > 0) {
d *= 3;
d3--;
}
cout << ans << endl;
cout << a << " " << b << endl;
cout << c << " " << d << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m;
int n;
long long int mod = 1000000007;
long long int f(int a, int b) {
if (b == 1) {
return a - 1;
} else if (b <= 0 || a <= 0) {
return INT_MAX;
}
if (a < b) {
int temp = b;
b = a;
a = temp;
}
return (a / b) + f(a % b, b);
}
int main() {
cin >> n;
long long int mini = INT_MAX;
if (n == 1) {
cout << 0 << endl;
return 0;
} else if (n == 2) {
cout << 1 << endl;
return 0;
}
for (int i = 1; i < n; i += 2) {
mini = min(mini, f(n, i));
}
cout << mini << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> mas[100100];
vector<vector<int> > vis;
vector<vector<int> > dist[2];
int main() {
int n, m;
scanf("%d %d", &n, &m);
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
scanf("%d", &mas[i].first);
mas[i].second = 0;
}
int l;
scanf("%d", &l);
for (int i = k; i < k + l; i++) {
scanf("%d", &mas[i].first);
mas[i].second = 1;
}
sort(mas, mas + n * m);
vis.resize(n + 1);
dist[0].resize(n + 1);
dist[1].resize(n + 1);
for (int i = 1; i <= n; i++) {
vis[i].resize(m + 1);
dist[0][i].resize(m + 1);
dist[1][i].resize(m + 1);
for (int j = 1; j <= m; j++) {
vis[i][j] = true;
dist[0][i][j] = i + j;
dist[1][i][j] = i + m + 1 - j;
}
}
for (int q = 0; q < n * m; q++) {
int v = mas[q].first;
int type = mas[q].second;
int idxI = -1;
int idxJ = -1;
int saved = -1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!vis[i][j]) continue;
if (dist[type][i][j] <= v && dist[!type][i][j] > saved) {
idxI = i;
idxJ = j;
saved = dist[!type][i][j];
}
}
}
if (saved != -1) {
vis[idxI][idxJ] = false;
} else {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
| 12 |
#include <bits/stdc++.h>
int main() {
int a, b, x;
scanf("%d %d", &a, &b);
for (x = 1; x < a; x++) {
int y = (int)sqrt(a * a - x * x);
if (x * x + y * y == a * a) {
if (b * y % a == 0 && b * x % a == 0) {
int dx = b * y / a;
int dy = b * x / a;
if (y == dy) continue;
printf("YES\n");
printf("0 0\n");
printf("%d %d\n", x, y);
printf("%d %d\n", x + dx, y - dy);
return 0;
}
}
}
printf("NO\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int t = 0;
for (int i = 0; i < n - 1; i++) {
if (s.substr(0, i + 1) == s.substr(n - i - 1)) {
t = i + 1;
}
}
cout << s;
for (int i = 1; i < k; i++) {
cout << s.substr(t);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int N = 2e5 + 9;
inline int popcount(int x) {
int counter = 0;
__asm__ volatile("POPCNT %1, %0;" : "=r"(counter) : "r"(x) :);
return counter;
}
unsigned long long a[N], b[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string A, B;
cin >> A >> B;
int M = 0;
for (int i = 0; i < 31; i++) M |= 1 << i;
int n = A.size();
for (int i = 0; i < n; i++) {
if (i + 61 < n) {
unsigned long long mask = 0;
for (int j = i; j <= i + 61; j++) {
mask = (mask << 1) + (A[j] - '0');
}
a[i] = mask;
}
}
int m = B.size();
for (int i = 0; i < m; i++) {
if (i + 61 < m) {
unsigned long long mask = 0;
for (int j = i; j <= i + 61; j++) {
mask = (mask << 1) + (B[j] - '0');
}
b[i] = mask;
}
}
int q;
cin >> q;
while (q--) {
int l1, l2, x;
cin >> l1 >> l2 >> x;
int ans = 0;
while (x >= 62) {
unsigned long long nw = a[l1] ^ b[l2];
ans += popcount(nw & M) + popcount(nw >> 31);
l1 += 62;
l2 += 62;
x -= 62;
}
for (int i = 0; i < x; i++) ans += A[l1 + i] != B[l2 + i];
cout << ans << '\n';
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
int a[100][100];
int hh[100];
int ww[100];
int main() {
const int h = getInt();
const int w = getInt();
for (int i = 0; i < (int)(h); i++)
for (int j = 0; j < (int)(w); j++) a[i][j] = getInt();
for (int i = 0; i < (int)(h); i++) hh[i] = 1;
for (int i = 0; i < (int)(w); i++) ww[i] = 1;
bool ok = false;
while (!ok) {
ok = true;
for (int i = 0; i < (int)(h); i++) {
int s = 0;
for (int j = 0; j < (int)(w); j++) s += hh[i] * ww[j] * a[i][j];
if (s < 0) {
ok = false;
hh[i] *= -1;
}
}
for (int i = 0; i < (int)(w); i++) {
int s = 0;
for (int j = 0; j < (int)(h); j++) s += hh[j] * ww[i] * a[j][i];
if (s < 0) {
ok = false;
ww[i] *= -1;
}
}
}
{
vector<int> b;
for (int i = 0; i < (int)(h); i++)
if (hh[i] < 0) b.push_back(i + 1);
printf("%d", b.size());
for (int i = 0; i < (int)(b.size()); i++) printf(" %d", b[i]);
puts("");
}
{
vector<int> b;
for (int i = 0; i < (int)(w); i++)
if (ww[i] < 0) b.push_back(i + 1);
printf("%d", b.size());
for (int i = 0; i < (int)(b.size()); i++) printf(" %d", b[i]);
puts("");
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
long long T[4][N][N];
int n, m;
int Get(int x, int y) {
int Res = 0;
if (x % 2) Res += 1;
if (y % 2) Res += 2;
return Res;
}
void Add(int x, int y, long long v) {
int Index = Get(x, y);
for (int i = x; i <= n; i += i & (-i))
for (int j = y; j <= n; j += j & (-j)) T[Index][i][j] ^= v;
}
long long Sum(int x, int y) {
long long Res = 0;
int Index = Get(x, y);
for (int i = x; i; i -= i & (-i))
for (int j = y; j; j -= j & (-j)) Res ^= T[Index][i][j];
return Res;
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int Case;
int x0, y0, x1, y1;
long long v = 0;
scanf("%d", &Case);
if (Case == 2) {
scanf("%d%d%d%d%I64d", &x0, &y0, &x1, &y1, &v);
Add(x0, y0, v);
Add(x1 + 1, y0, v);
Add(x0, y1 + 1, v);
Add(x1 + 1, y1 + 1, v);
} else {
scanf("%d%d%d%d", &x0, &y0, &x1, &y1);
v ^= Sum(x1, y1);
v ^= Sum(x1, y0 - 1);
v ^= Sum(x0 - 1, y1);
v ^= Sum(x0 - 1, y0 - 1);
printf("%I64d\n", v);
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, len1, len2;
bool cell[55][55];
int dp[55][55][55][55];
string s;
int max_(int a, int b) {
if (a > b)
return a;
else
return b;
}
int min_(int a, int b) {
if (a < b)
return a;
else
return b;
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s;
for (j = 1; j <= n; j++) cell[i][j] = s[j - 1] == '#';
}
for (len1 = 1; len1 <= n; len1++) {
for (i = 1; i + len1 - 1 <= n; i++) {
for (len2 = 1; len2 <= n; len2++) {
for (j = 1; j + len2 - 1 <= n; j++) {
int a = i + len1 - 1;
int b = j + len2 - 1;
int &p = dp[i][j][a][b];
if (len1 == 1 && len2 == 1 && !cell[i][j])
p = 0;
else
p = max_(len1, len2);
for (k = i; k < a; k++)
p = min_(p, dp[i][j][k][b] + dp[k + 1][j][a][b]);
for (k = j; k < b; k++)
p = min_(p, dp[i][j][a][k] + dp[i][k + 1][a][b]);
}
}
}
}
cout << dp[1][1][n][n] << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : ~x + 1;
}
int n, m, q;
std::vector<int> vec[300010], nvec[300010];
int dfn[300010], low[300010], belong[300010];
int idx, cnt;
std::vector<int> stcc[300010];
bool vis[300010];
int stk[300010], top;
void tarjan(int x, int fa) {
dfn[x] = low[x] = ++idx;
stk[++top] = x;
vis[x] = 1;
sort(vec[x].begin(), vec[x].end());
for (int i = 0; i < vec[x].size(); ++i) {
int v = vec[x][i];
if (v == fa) continue;
if (!dfn[v]) {
if (i != vec[x].size() - 1 && vec[x][i + 1] == vec[x][i]) {
tarjan(v, 0);
++i;
} else
tarjan(v, x);
low[x] = std::min(low[x], low[v]);
} else if (vis[v])
low[x] = std::min(low[x], dfn[v]);
}
if (low[x] == dfn[x]) {
++cnt;
while (stk[top] != x) {
vis[stk[top]] = 0;
stcc[cnt].push_back(stk[top]);
belong[stk[top--]] = cnt;
}
vis[x] = 0;
stcc[cnt].push_back(x);
belong[stk[top--]] = cnt;
}
}
std::map<std::pair<int, int>, bool> Map;
namespace xu {
int Dfn[300010], low[300010], Belong[300010];
std::vector<int> Vec[300010];
int fa[300010];
int logt[300010], dep[300010], Fa[300010][20];
int dfn[300010];
int idx;
bool Vis[300010];
int Stk[300010], Top;
int Cnt;
void tarjan(int x, int fa) {
sort(Vec[x].begin(), Vec[x].end());
Dfn[x] = low[x] = ++idx;
Stk[++Top] = x;
Vis[x] = 1;
for (int i = 0; i < Vec[x].size(); ++i) {
int v = Vec[x][i];
if (v == fa) continue;
if (!Dfn[v]) {
if (i + 1 < Vec[x].size() && Vec[x][i + 1] == Vec[x][i]) {
tarjan(v, 0);
++i;
} else
tarjan(v, x);
low[x] = std::min(low[x], low[v]);
} else if (Vis[v])
low[x] = std::min(low[x], Dfn[v]);
}
if (Dfn[x] == low[x]) {
++Cnt;
while (Stk[Top] != x) {
Vis[Stk[Top]] = 0;
Belong[Stk[Top--]] = Cnt;
}
Vis[x] = 0;
Belong[Stk[Top--]] = Cnt;
}
}
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
bool cmp(int x, int y) { return dfn[x] < dfn[y]; }
int LCA(int x, int y) {
if (find(x) != find(y)) return -1;
if (dep[x] < dep[y]) std::swap(x, y);
while (dep[x] > dep[y]) {
x = Fa[x][logt[dep[x] - dep[y]]];
}
for (int i = 18; i >= 0; --i) {
if (Fa[x][i] != Fa[y][i]) x = Fa[x][i], y = Fa[y][i];
}
int p = x == y ? x : Fa[x][0];
if (p == 0) {
exit(0);
}
if (x == y)
return x;
else
return Fa[x][0];
}
void dfs(int x, int fa) {
dfn[x] = ++idx;
;
dep[x] = dep[fa] + 1;
Fa[x][0] = fa;
for (int i = 1; (1 << i) <= dep[x]; ++i) Fa[x][i] = Fa[Fa[x][i - 1]][i - 1];
for (int v : vec[x]) {
if (v != fa) dfs(v, x);
}
}
int stk[300010], top;
void insert(int x) {
Vec[x].clear();
Dfn[x] = low[x] = Vis[x] = Belong[x] = 0;
if (!top) {
stk[++top] = x;
return;
}
int p = LCA(x, stk[top]);
if (p == stk[top] || p == -1) {
stk[++top] = x;
return;
}
while (top > 1 && find(stk[top - 1]) == find(p) &&
dfn[stk[top - 1]] >= dfn[p]) {
Vec[stk[top - 1]].push_back(stk[top]);
Vec[stk[top]].push_back(stk[top - 1]);
--top;
}
if (p != stk[top]) {
Vec[p].clear();
Dfn[p] = low[p] = Vis[p] = Belong[p] = 0;
Vec[stk[top]].push_back(p);
Vec[p].push_back(stk[top]);
stk[top] = p;
}
stk[++top] = x;
}
void build(std::vector<int> v) {
top = 0;
for (int i : v) insert(i);
while (top > 1) {
if (find(stk[top]) == find(stk[top - 1]))
Vec[stk[top]].push_back(stk[top - 1]),
Vec[stk[top - 1]].push_back(stk[top]);
--top;
}
}
void solve() {
for (int i = cnt + 1; i <= n; ++i) vec[i].clear();
for (int i = 1; i <= cnt; ++i) fa[i] = i;
for (int i = 2; i <= cnt; ++i) logt[i] = logt[i >> 1] + 1;
for (int i = 1; i <= cnt; ++i)
for (int v : vec[i])
if (find(i) != find(v)) fa[find(i)] = find(v);
for (int i = 1; i <= cnt; ++i)
if (fa[i] == i) dfs(i, 0);
int R = 0;
for (int i = 1; i <= q; ++i) {
auto rotate = [&](int x) {
x = (x + R) % n;
return x == 0 ? n : x;
};
int N = read(), M = read();
std::vector<int> fav, nod;
std::vector<std::pair<int, int> > edg;
for (int i = 1; i <= N; ++i) {
int x = rotate(read());
fav.push_back(belong[x]);
nod.push_back(belong[x]);
}
for (int i = 1; i <= M; ++i) {
int u = rotate(read()), v = rotate(read());
int x = belong[u], y = belong[v];
if (x != y) edg.emplace_back(x, y);
nod.push_back(x);
nod.push_back(y);
}
sort(fav.begin(), fav.end());
auto it = unique(fav.begin(), fav.end());
while (it != fav.end()) fav.erase(it);
sort(nod.begin(), nod.end());
it = unique(nod.begin(), nod.end());
while (it != nod.end()) nod.pop_back();
sort(nod.begin(), nod.end(), cmp);
build(nod);
for (std::pair<int, int> E : edg) {
int u = E.first, v = E.second;
if (u != v) Vec[u].push_back(v), Vec[v].push_back(u);
}
idx = 0;
for (int v : nod) {
if (!Dfn[v]) {
tarjan(v, 0);
}
}
int t = -1;
bool f = 0;
for (int v : fav) {
if (t == -1)
t = Belong[v];
else if (Belong[v] != t) {
f = 1;
break;
}
}
if (f)
printf("NO\n");
else
printf("YES\n");
if (!f) (R += i) %= n;
}
}
} // namespace xu
int main() {
n = read(), m = read(), q = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
vec[u].push_back(v), vec[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i, 0);
for (int i = 1; i <= cnt; ++i) {
for (int j : stcc[i]) {
for (int v : vec[j]) {
if (belong[v] != belong[j]) {
if (!Map.count(std::make_pair(belong[v], belong[j]))) {
nvec[belong[j]].push_back(belong[v]);
nvec[belong[v]].push_back(belong[j]);
Map[std::make_pair(belong[v], belong[j])] =
Map[std::make_pair(belong[j], belong[v])] = 1;
}
}
}
}
}
memset(dfn, 0, sizeof(dfn));
idx = 0;
for (int i = 1; i <= cnt; ++i) {
vec[i] = move(nvec[i]);
}
xu::solve();
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k;
long long int a[200005] = {0};
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long long int ans = 0;
if (k == 1) {
ans = ((m + 1) / 2 * a[n]) + (m / 2 * a[n - 1]);
} else {
ans = ((m / (k + 1)) * a[n] * k) + ((m / (k + 1)) * a[n - 1]) +
((m - ((m / (k + 1)) * (k + 1))) * a[n]);
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int n, bas;
vector<long long int> ans;
void solve() {
cin >> n;
ans.clear();
bas = -1;
long long int sayi = n;
while (n > 0) {
long long int basamak = n % 10;
n /= 10;
bas++;
if (basamak) {
long long int koy = basamak * (pow(10, bas));
if (koy % 10 and koy > 10) koy++;
ans.push_back(koy);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
}
int main() {
long long int t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
long long n, a[N], x, book, book2, ans;
long long cmp(long long a, long long b) { return a > b; }
int main() {
book = ans = book2 = 0;
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &x);
if (x & 1) {
if (x > 0) book2++;
a[book++] = x;
} else {
if (x > 0) ans += x;
}
}
sort(a, a + book, cmp);
if (!book2)
ans += a[0];
else {
if (book2 & 1) {
for (int i = 0; i < book2; i++) {
ans += a[i];
}
} else {
for (int i = 0; i < book2 - 1; i++) {
ans += a[i];
}
if ((ans + a[book2 - 1] + a[book2]) & 1)
ans = max(ans, ans + a[book2 - 1] + a[book2]);
}
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100233;
vector<int> v;
struct mmp {
int to, next, len;
mmp() {}
mmp(int a, int b, int c) { to = a, next = b, len = c; }
} e[maxn << 1];
int vis[maxn], st, ed, cnt, head[maxn], val[maxn], len;
void add(int u, int v, int len) {
e[++cnt] = mmp(v, head[u], len);
head[u] = cnt;
}
void add(int x) {
for (int i = 0; i < (int)v.size(); i++) {
x = min(x, x ^ v[i]);
}
if (x) v.push_back(x);
}
void dfs(int x, int now) {
vis[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int to = e[i].to;
if (vis[to])
add(val[to] ^ now ^ e[i].len);
else {
val[to] = now ^ e[i].len;
dfs(to, val[to]);
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &st, &ed, &len);
add(st, ed, len);
add(ed, st, len);
}
dfs(1, 0);
for (int i = 0; (int)i < v.size(); i++) {
val[n] = min(val[n], val[n] ^ v[i]);
}
return 0 * printf("%d", val[n]);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
char str[13];
int a[13][103], b[13][103], c[13][103], arr[10003];
int main() {
int n, m, K, i, j, ans, c1, k, l, sum;
scanf("%d%d%d", &n, &m, &K);
for (i = 0; i < n; i++) {
scanf("%s", str);
for (j = 0; j < m; j++) scanf("%d%d%d", &a[i][j], &b[i][j], &c[i][j]);
}
ans = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j) continue;
c1 = 0;
for (k = 0; k < m; k++) {
if (a[i][k] < b[j][k]) {
for (l = 0; l < c[i][k]; l++) arr[c1++] = b[j][k] - a[i][k];
}
}
sort(arr, arr + c1);
reverse(arr, arr + c1);
sum = 0;
for (k = 0; k < c1 && k < K; k++) sum += arr[k];
if (sum > ans) ans = sum;
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[1000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
int n;
cin >> n;
while (n--) {
int count = 0;
vector<int> v;
string s;
cin >> s;
for (int i = 0; i < int(s.size()); i++) {
if (s[i] == '1') count++;
if (s[i] == '0') {
v.push_back(count);
count = 0;
}
}
v.push_back(count);
sort(v.begin(), v.end(), greater<int>());
int val = 0;
for (int i = 0; i < v.size(); i += 2) {
val += v[i];
}
cout << val << endl;
}
}
| 0 |
#include <bits/stdc++.h>
int main(void) {
int n, cnt = 0, num[50];
char s[101];
scanf("%d%s", &n, s);
for (int i = 0; i < n; i++)
if (s[i] == 'B') {
num[cnt] = 1;
while (s[i + 1] == 'B') {
i++;
num[cnt]++;
}
cnt++;
}
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++) printf("%d%c", num[i], i + 1 < n ? 32 : 10);
return 0;
}
| 0 |
#include <bits/stdc++.h>
int inv;
void merge(int a[], int low, int high, int mid) {
int i, j, k, c[high + 1];
i = low;
j = mid + 1;
k = low;
while ((i <= mid) && (j <= high)) {
if (a[i] < a[j]) {
c[k] = a[i];
k++;
i++;
} else {
c[k] = a[j];
inv = inv + mid - i + 1;
k++;
j++;
}
}
while (i <= mid) {
c[k] = a[i];
k++;
i++;
}
while (j <= high) {
c[k] = a[j];
k++;
j++;
}
for (i = low; i < k; i++) {
a[i] = c[i];
}
}
void mergesort(int a[], int low, int high) {
int mid;
if (low < high) {
mid = (low + high) / 2;
mergesort(a, low, mid);
mergesort(a, mid + 1, high);
merge(a, low, high, mid);
}
}
int main() {
int n;
int ar[3005];
inv = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
}
mergesort(ar, 1, n);
if (inv == 0) {
printf("0\n");
} else if (inv == 1) {
printf("1\n");
} else if (inv == 2) {
printf("4\n");
} else if (inv % 2 == 0) {
printf("%d\n", inv * 2);
} else
printf("%d\n", (2 * inv) - 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int N = 3000;
int n, a[N], m, b[N], c[N];
int f(int *a, int n) {
memcpy(b, a, n * sizeof(int));
for (int i = 0; i < n; ++i) {
c[b[i]] = i;
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (i != c[i]) {
c[b[i]] = c[i];
b[c[i]] = b[i];
ans++;
}
}
return ans;
}
int p[N];
int find(int x) { return x == p[x] ? x : (p[x] = find(p[x])); }
void inc(int s) {
if (s <= 0) {
return;
}
for (int i = 0; i < n; ++i) {
p[i] = i;
}
for (int i = 0; i < n; ++i) {
p[find(i)] = find(a[i]);
}
for (int i = 0; i < n; ++i) {
if (find(a[0]) != find(a[i])) {
printf("1 %d%s", i + 1, s == 1 ? "\n" : " ");
std::swap(a[0], a[i]);
break;
}
}
inc(s - 1);
}
int pos[N];
void dec(int s) {
for (int i = 0; i < n && s; ++i) {
std::fill(pos, pos + n, -1);
for (int j = a[i], k = 0; j != i; j = a[j], ++k) {
pos[j] = k;
}
int cur = 0;
for (int j = i + 1; j < n && s; ++j) {
if (pos[j] >= cur) {
printf("%d %d\n", i + 1, j + 1);
std::swap(a[i], a[j]);
cur = pos[j] + 1;
--s;
}
}
}
}
int main() {
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
--a[i];
}
scanf("%d", &m);
int cur = f(a, n);
printf("%d\n", std::abs(cur - m));
if (cur < m) {
inc(m - cur);
} else {
dec(cur - m);
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int Mx = 1e5 + 5;
int arr[Mx];
int main() {
int n, i, j;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", arr + i);
for (i = 30; i >= 0; i--) {
int T = 1 << i;
bool flag = false;
for (j = n; j >= 1 && arr[j] >= T; j--)
if (T & arr[j]) {
flag = true;
break;
}
if (flag) {
int cnt = 0, tmp = (1 << 30) - 1;
for (j; j >= 1 && arr[j] >= T; j--) {
if (T & arr[j]) {
tmp &= arr[j];
cnt++;
}
}
if (tmp % T != 0) continue;
printf("%d\n", cnt);
for (j = n; j >= 1 && arr[j] >= T; j--)
if (T & arr[j]) printf("%d ", arr[j]);
break;
}
}
if (i < 0) puts("-1");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int c[1005][1005];
int a[1005];
int main() {
int i, j, k;
c[1][0] = c[1][1] = 1;
for (i = 2; i < 1005; i++) {
c[i][0] = 1;
for (j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
scanf("%d", &k);
int x, sum = 0;
for (i = 1; i <= k; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
long long res = 1;
for (i = k; i > 1; i--) {
res = (res * (long long)c[sum - 1][a[i] - 1]) % 1000000007;
sum -= a[i];
}
cout << res << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, v, m, a[305], b[305];
int dist[305][305], fa[305][305], lft;
vector<pair<pair<int, int>, int>> seq;
void dfs(const int &s, const int &t, const int &d) {
const int &f = fa[s][t];
int dd = d - a[f];
seq.emplace_back(make_pair(f, t), min(d, a[f]));
a[t] += min(d, a[f]);
a[f] -= min(d, a[f]);
if (s != f) dfs(s, f, d);
if (dd > 0) {
seq.emplace_back(make_pair(f, t), dd);
a[f] -= dd;
a[t] += dd;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> v >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
cin >> b[i];
lft += a[i] != b[i];
}
memset(dist, 0x3f, sizeof(dist));
for (int i = 1; i <= m; i++) {
static int u, v;
cin >> u >> v;
dist[u][v] = dist[v][u] = 1;
fa[u][v] = u;
fa[v][u] = v;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (dist[i][k] + dist[k][j] < dist[i][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
fa[i][j] = fa[k][j];
}
}
}
}
while (lft) {
bool ntrans = true;
for (int s = 1; s <= n && ntrans; s++)
if (a[s] > b[s]) {
for (int t = 1; t <= n && ntrans; t++)
if (a[t] < b[t] && dist[s][t] != 0x3f3f3f3f) {
dfs(s, t, min(a[s] - b[s], b[t] - a[t]));
lft -= a[s] == b[s];
lft -= a[t] == b[t];
ntrans = false;
}
}
if (ntrans) {
cout << "NO\n";
return 0;
}
}
cout << seq.size() << '\n';
for (const pair<pair<int, int>, int> &p : seq) {
cout << p.first.first << ' ' << p.first.second << ' ' << p.second << '\n';
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
while (n--) {
long long int a, b;
cin >> a >> b;
long long int temp = max(a, b);
long long int temp2 = min(a, b);
a = temp;
b = temp2;
if (((a + b) % 3 == 0) && (2 * b >= a))
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
int n, a[1000007], b[1000007], tot;
int ask() {
cout << "? ";
for (int i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl, tot++;
if (tot > n + n) {
cerr << "fuck";
}
int out = 0;
cin >> out;
return out;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) a[i] = 1;
int p = 0;
for (int i = 1; i <= n; i++) {
a[n]++;
if (i != n)
p = ask();
else
p = 0;
if (!p) {
b[n] = n - i + 1;
for (int j = 1; j <= n - 1; j++)
if (b[j]) b[j] += b[n];
break;
} else
b[p] = i;
}
a[n] = 1;
for (int i = 1; i <= b[n] - 1; i++) {
for (int j = 1; j <= n - 1; j++)
if (b[j])
a[j] = n;
else
a[j] = i + 1;
b[ask()] = b[n] - i;
}
cout << "! ";
for (int i = 1; i <= n; i++) cout << b[i] << ' ';
cout << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int m, n;
int mn[100005], mx[100005];
bool vis[100005], inq[100005];
vector<int> u[100005], v[100005];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
struct data {
int id, w, r, sum;
vector<int> v;
} p[100005];
void dijkstra() {
memset(mn, 127, sizeof(mn));
while (!q.empty()) {
int d = min(1000000000, q.top().first), x = q.top().second;
q.pop();
if (d < mn[x]) {
for (int i = 0; i < v[x].size(); i++) {
int t = v[x][i];
if (mn[x] > 1000000000)
p[t].r--, p[t].sum += d;
else
p[t].sum += d - mn[x];
if (!p[t].r) q.push(make_pair(p[t].sum, p[t].id));
p[t].sum = min(p[t].sum, 1000000000);
}
mn[x] = d;
}
}
for (int i = 1; i <= n; i++)
if (mn[i] > 1000000000) mn[i] = mx[i] = -1;
}
void dp(int x) {
if (vis[x] || inq[x]) return;
vis[x] = inq[x] = 1;
for (int i = 0; i < u[x].size(); i++) {
int t = u[x][i], sum = p[t].w;
for (int j = 0; j < p[t].v.size(); j++)
if (mx[p[t].v[j]] == -1) {
sum = -1;
break;
}
if (sum == -1) continue;
for (int j = 0; j < p[t].v.size(); j++) {
int v = p[t].v[j];
dp(v);
if (inq[v] || mx[v] == 1000000000) {
sum = 1000000000;
break;
}
sum += mx[v];
}
mx[x] = max(mx[x], sum);
}
inq[x] = 0;
}
int main() {
m = read();
n = read();
for (int i = 1; i <= m; i++) {
p[i].id = read();
u[p[i].id].push_back(i);
int x = read(), y;
for (int j = 1; j <= x; j++) {
y = read();
if (y == -1)
p[i].w++;
else {
p[i].r++;
p[i].v.push_back(y);
v[y].push_back(i);
}
}
if (p[i].w == x) q.push(make_pair(p[i].w, p[i].id));
p[i].sum = p[i].w;
}
dijkstra();
for (int i = 1; i <= n; i++)
if (mx[i] != -1 && !vis[i]) dp(i);
for (int i = 1; i <= n; i++)
if (mx[i] == 1000000000) mx[i] = -2;
for (int i = 1; i <= n; i++)
cout << min(mn[i], 314000000) << ' ' << min(mx[i], 314000000) << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
double exact(long long int a, long long int b) { return (double)a / b; }
long long int gcd(long long int a, long long int b) {
if (a == 0 || b == 0) {
return (a + b);
}
return gcd(b, a % b);
}
long long int fastExpo(long long int a, long long int n, long long int mod) {
long long int result = 1;
while (n > 0) {
if (n & 1) result = (result * a) % mod;
a = (a * a) % mod;
n >>= 1;
}
return result;
}
long long int modInverse(long long int n, long long int mod) {
return fastExpo(n, mod - 2, mod);
}
vector<long long int> factorial(long long int n) {
std::vector<long long int> fac(n + 2, 0);
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % 1000000007;
return fac;
}
long long int __nCr(long long int n, long long int r,
vector<long long int>& Fact, long long int mod) {
long long int ans = (((Fact[n] * modInverse(Fact[r], mod)) % mod) *
modInverse(Fact[n - r], mod)) %
mod;
return ans;
}
vector<long long int> sieve(long long int n) {
vector<long long int> v(n + 2, 0);
vector<long long int> primes;
n++;
v[0] = 1;
for (long long int i = 2; i < n; i++) {
if (!v[i]) {
primes.push_back(i);
for (long long int j = 2 * i; j < n; j += i) v[j]++;
}
}
return primes;
}
void solve(long long int T) {
long long int n, a, b;
cin >> n >> a >> b;
vector<long long int> v;
long long int first;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
if (i == 0) {
first = x;
} else {
v.push_back(x);
}
}
long long int req = (first * a) / b;
long long int sum = accumulate(v.begin(), v.end(), 0ll) + first;
if (req >= sum) {
cout << 0 << endl;
return;
}
sort(v.begin(), v.end(), greater<long long int>());
long long int count = 0;
for (long long int i = 0; i < n - 1; i++) {
sum -= v[i];
count++;
if (req >= sum) {
cout << count << endl;
return;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int T = 1;
for (long long int t = 1; t <= T; t++) {
solve(t);
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void go(int n, int m, bool c) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (c && i == n - 1 && j >= m - 2) {
cout << 'B';
continue;
}
if ((i + j) & 1) {
cout << 'W';
} else {
cout << 'B';
}
}
cout << endl;
}
}
int main() {
int t, n, m;
cin >> t;
while (t--) {
cin >> n >> m;
if ((n * m) & 1) {
go(n, m, false);
} else {
go(n, m, true);
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y % 2 == 1) res *= x;
y /= 2;
x *= x;
}
return res;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
;
int n, no;
cin >> n;
long long count = 0, maxo = 0;
vector<long long> v(2 * n, 0);
vector<bool> table(n, false);
for (long long i = 0; i < 2 * n; i++) cin >> v[i];
for (long long i = 0; i < 2 * n; i++) {
if (table[v[i] - 1] == false) {
count++;
table[v[i] - 1] = true;
} else
count--;
maxo = max(maxo, count);
}
cout << maxo << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long MOD = 1e9;
const double PI = acos(-1.0);
struct Matr {
long long matr[2][2];
void Init() { memset(matr, 0, sizeof matr); }
} F[210000];
Matr Multi(Matr a, Matr b) {
Matr res;
res.Init();
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 2; ++k)
res.matr[i][j] = (res.matr[i][j] + a.matr[i][k] * b.matr[k][j]) % MOD;
return res;
}
Matr X;
long long Fib[201000];
long long a[200100];
struct Tree {
long long A, B;
} tree[200010 * 4];
long long lazy[200010 * 4];
void Push_up(int l, int r, int rt) {
int mid = (l + r) / 2;
Matr tmp = F[mid - l + 1];
tree[rt].A = tree[rt << 1].A + (tree[rt << 1 | 1].A * tmp.matr[0][0] % MOD) +
(tree[rt << 1 | 1].B * tmp.matr[1][0] % MOD);
tree[rt].A %= MOD;
tree[rt].B = tree[rt << 1].B + (tree[rt << 1 | 1].A * tmp.matr[0][1] % MOD) +
(tree[rt << 1 | 1].B * tmp.matr[1][1] % MOD);
tree[rt].B %= MOD;
}
void Build(int l, int r, int rt) {
lazy[rt] = 0;
if (l == r) {
tree[rt].A = a[l];
tree[rt].B = 0;
return;
}
int mid = (l + r) / 2;
Build(l, mid, rt << 1);
Build(mid + 1, r, (rt << 1) | 1);
Push_up(l, r, rt);
}
void Push_down(int l, int r, int rt) {
int mid = (l + r) / 2;
if (lazy[rt]) {
long long ret1 = (F[mid - l + 1 + 2 - 1].matr[0][0] - 1) * lazy[rt] % MOD;
long long ret2 = (F[mid - l + 2 - 1].matr[0][0] - 1) * lazy[rt] % MOD;
tree[rt << 1].A = (tree[rt << 1].A + ret1) % MOD;
tree[rt << 1].B = (tree[rt << 1].B + ret2) % MOD;
ret1 = (F[r - mid + 2 - 1].matr[0][0] - 1) * lazy[rt] % MOD;
ret2 = (F[r - mid - 1 + 2 - 1].matr[0][0] - 1) * lazy[rt] % MOD;
tree[rt << 1 | 1].A = (tree[rt << 1 | 1].A + ret1) % MOD;
tree[rt << 1 | 1].B = (tree[rt << 1 | 1].B + ret2) % MOD;
lazy[rt << 1] += lazy[rt];
lazy[rt << 1] %= MOD;
lazy[rt << 1 | 1] += lazy[rt];
lazy[rt << 1 | 1] %= MOD;
lazy[rt] = 0;
}
}
void Update1(int L, int R, int l, int r, int rt, long long val) {
if (L <= l && r <= R) {
long long ret1 = (F[r - l + 1 + 2 - 1].matr[0][0] - 1) * val % MOD;
long long ret2 = (F[r - l + 2 - 1].matr[0][0] - 1) * val % MOD;
tree[rt].A = (tree[rt].A + ret1) % MOD;
tree[rt].B = (tree[rt].B + ret2) % MOD;
lazy[rt] += val;
return;
}
Push_down(l, r, rt);
int mid = (l + r) / 2;
if (L <= mid) Update1(L, R, l, mid, rt << 1, val);
if (R > mid) Update1(L, R, mid + 1, r, (rt << 1) | 1, val);
Push_up(l, r, rt);
}
Tree Que(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return tree[rt];
int mid = (l + r) / 2;
Push_down(l, r, rt);
Tree res1, res2, ans;
if (L <= mid && R <= mid)
return Que(L, R, l, mid, rt << 1);
else if (L > mid && R > mid)
return Que(L, R, mid + 1, r, (rt << 1) | 1);
else {
Matr tmp = F[mid - max(L, l) + 1];
res1 = Que(L, R, l, mid, rt << 1);
res2 = Que(L, R, mid + 1, r, (rt << 1) | 1);
ans.A = res1.A + (res2.A * tmp.matr[0][0] % MOD) +
(res2.B * tmp.matr[1][0] % MOD);
ans.A %= MOD;
ans.B = res1.B + (res2.A * tmp.matr[0][1] % MOD) +
(res2.B * tmp.matr[1][1] % MOD);
ans.B %= MOD;
return ans;
}
}
int main() {
int n, m;
X.matr[0][0] = 1;
X.matr[1][0] = 1;
X.matr[0][1] = 1;
X.matr[1][1] = 0;
F[1] = X;
for (int i = 2; i <= 200000; ++i) F[i] = Multi(F[i - 1], X);
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
Build(1, n, 1);
int t;
int l, r;
long long val;
long long temp;
Tree RES;
while (m--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%lld", &l, &val);
RES = Que(l, l, 1, n, 1);
temp = val - RES.A;
Update1(l, l, 1, n, 1, temp);
} else if (t == 2) {
scanf("%d%d", &l, &r);
RES = Que(l, r, 1, n, 1);
printf("%lld\n", RES.A);
} else {
scanf("%d%d%lld", &l, &r, &val);
Update1(l, r, 1, n, 1, val);
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int d[100005];
vector<int> tree[100005];
int t, k = 0;
int arr[100005];
void solve() {
for (int i = 0; i < k; i++) {
int u = arr[i], siz = tree[u].size();
for (int j = 0; j < siz; j++) {
int v = tree[u][j];
if (d[v] <= 1 + d[u]) continue;
d[v] = 1 + d[u];
arr[k++] = v;
}
}
k = 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int u, v;
fill(d, d + n + 1, INT_MAX);
n--;
while (n--) {
scanf("%d%d", &u, &v);
tree[u].push_back(v);
tree[v].push_back(u);
}
d[1] = 0;
arr[k++] = 1;
while (m--) {
scanf("%d%d", &t, &v);
if (t == 1) {
arr[k++] = v;
d[v] = 0;
} else {
solve();
printf("%d\n", d[v]);
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
void fun(long long int n, long long int i, long long int j,
vector<vector<long long int> > &vec, long long int &ind) {
ind += 1;
if (n == 1) {
vec[ind][0] = i;
vec[ind][1] = j + 1;
vec[ind][2] = i + 1;
vec[ind][3] = j;
vec[ind][4] = i + 1;
vec[ind][5] = j + 1;
} else if (n == 2) {
vec[ind][0] = i;
vec[ind][1] = j;
vec[ind][2] = i + 1;
vec[ind][3] = j;
vec[ind][4] = i + 1;
vec[ind][5] = j + 1;
} else if (n == 3) {
vec[ind][0] = i;
vec[ind][1] = j;
vec[ind][2] = i;
vec[ind][3] = j + 1;
vec[ind][4] = i + 1;
vec[ind][5] = j + 1;
} else if (n == 4) {
vec[ind][0] = i;
vec[ind][1] = j;
vec[ind][2] = i;
vec[ind][3] = j + 1;
vec[ind][4] = i + 1;
vec[ind][5] = j;
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int a, b, c, d, i, j, k, l, m, n, p, q, r, s, x, y, z, ans = 0,
ind = -1;
string s1 = "", s2 = "";
cin >> n >> m;
a = 0, b = 0;
char ch;
vector<vector<long long int> > v(n, vector<long long int>(m, 0)),
vec((n + 1) * (m + 1), vector<long long int>(6, 0));
for (long long int i = 0; i <= n - 1; i++) {
for (long long int j = 0; j <= m - 1; j++) {
cin >> ch;
if (ch == '1') v[i][j] = 1;
}
}
if (n & 1) {
for (long long int j = 0; j <= m - 2; j++) {
if (v[n - 1][j] == 1) {
ind += 1;
vec[ind][0] = n - 1;
vec[ind][1] = j;
vec[ind][2] = n - 2;
vec[ind][3] = j;
vec[ind][4] = n - 2;
vec[ind][5] = j + 1;
if (v[n - 2][j] == 0)
v[n - 2][j] = 1;
else
v[n - 2][j] = 0;
if (v[n - 2][j + 1] == 0)
v[n - 2][j + 1] = 1;
else
v[n - 2][j + 1] = 0;
}
}
if (v[n - 1][m - 1] == 1) {
ind += 1;
j = m - 1;
vec[ind][0] = n - 1;
vec[ind][1] = j;
vec[ind][2] = n - 2;
vec[ind][3] = j;
vec[ind][4] = n - 2;
vec[ind][5] = j - 1;
if (v[n - 2][j] == 0)
v[n - 2][j] = 1;
else
v[n - 2][j] = 0;
if (v[n - 2][j - 1] == 0)
v[n - 2][j - 1] = 1;
else
v[n - 2][j - 1] = 0;
}
}
if (m & 1) {
z = n - 2;
if (n & 1) z = n - 3;
for (long long int i = 0; i <= z; i++) {
if (v[i][m - 1] == 1) {
ind += 1;
vec[ind][0] = i;
vec[ind][1] = m - 1;
vec[ind][2] = i;
vec[ind][3] = m - 2;
vec[ind][4] = i + 1;
vec[ind][5] = m - 2;
if (v[i][m - 2] == 0)
v[i][m - 2] = 1;
else
v[i][m - 2] = 0;
if (v[i + 1][m - 2] == 0)
v[i + 1][m - 2] = 1;
else
v[i + 1][m - 2] = 0;
}
}
if (v[z + 1][m - 1] == 1) {
ind += 1;
vec[ind][0] = z + 1;
vec[ind][1] = m - 1;
vec[ind][2] = z + 1;
vec[ind][3] = m - 2;
vec[ind][4] = z;
vec[ind][5] = m - 2;
if (v[z][m - 2] == 0)
v[z][m - 2] = 1;
else
v[z][m - 2] = 0;
if (v[z + 1][m - 2] == 0)
v[z + 1][m - 2] = 1;
else
v[z + 1][m - 2] = 0;
}
}
for (long long int i = 0; i < n - 1; i += 2) {
for (j = 0; j < m - 1; j += 2) {
x = v[i][j] + v[i + 1][j] + v[i][j + 1] + v[i + 1][j + 1];
if (x == 1 || x == 3) {
if (v[i][j] == 0) fun(1, i, j, vec, ind);
if (v[i + 1][j] == 0) fun(3, i, j, vec, ind);
if (v[i][j + 1] == 0) fun(2, i, j, vec, ind);
if (v[i + 1][j + 1] == 0) fun(4, i, j, vec, ind);
}
if (x == 2 || x == 4) {
if (v[i][j] == 1) fun(1, i, j, vec, ind);
if (v[i][j + 1] == 1) fun(2, i, j, vec, ind);
if (v[i + 1][j] == 1) fun(3, i, j, vec, ind);
if (v[i + 1][j + 1] == 1) fun(4, i, j, vec, ind);
}
}
}
cout << ind + 1 << "\n";
for (long long int i = 0; i <= ind; i++) {
for (long long int j = 0; j <= 5; j++) {
cout << vec[i][j] + 1 << " ";
}
cout << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50;
int dp[MAXN][MAXN][MAXN][MAXN][2];
char s[MAXN][MAXN];
bool hasher[MAXN];
int n, m;
int dfs(int MINX, int MAXX, int MINY, int MAXY, int op) {
int res = dp[MINX][MAXX][MINY][MAXY][op];
if (res != -1) return res;
set<int> sa;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (((i + j) & 1) == op) {
int x = i + j, y = i - j + m - 1;
if (x >= MINX && x < MAXX && y >= MINY && y < MAXY) {
int tmp = 0;
if (s[i][j] == 'L') {
tmp =
dfs(MINX, x, MINY, MAXY, op) ^ dfs(x + 1, MAXX, MINY, MAXY, op);
} else if (s[i][j] == 'R') {
tmp =
dfs(MINX, MAXX, MINY, y, op) ^ dfs(MINX, MAXX, y + 1, MAXY, op);
} else if (s[i][j] == 'X') {
tmp = dfs(MINX, x, MINY, y, op) ^ dfs(MINX, x, y + 1, MAXY, op) ^
dfs(x + 1, MAXX, MINY, y, op) ^
dfs(x + 1, MAXX, y + 1, MAXY, op);
}
sa.insert(tmp);
}
}
}
}
int tmper;
for (tmper = 0;; tmper++) {
if (sa.count(tmper) == 0) break;
}
return dp[MINX][MAXX][MINY][MAXY][op] = res = tmper;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
memset(dp, -1, sizeof(dp));
int t =
dfs(0, n + m - 1, 0, n + m - 1, 0) ^ dfs(0, n + m - 1, 0, n + m - 1, 1);
if (t)
printf("WIN\n");
else
printf("LOSE\n");
return 0;
}
| 17 |
#include <bits/stdc++.h>
const double PI =
3.141592653589793238462643383279502884197169399375105820974944;
using namespace std;
int MOD = 1e9 + 7;
double gcd(double a, double b) { return a < 0.01 ? b : gcd(fmod(b, a), a); }
template <typename T>
T mymax(T a, T b) {
return (a > b) ? a : b;
}
template <typename T>
T mymax(T a, T b, T c) {
return mymax(a, mymax(b, c));
}
template <typename T>
T mymin(T a, T b) {
return (a < b) ? a : b;
}
template <typename T>
T mymin(T a, T b, T c) {
return mymin(a, mymin(b, c));
}
template <typename T>
T power(T x, T y) {
T res = 1;
x = x % MOD;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1;
x = (x * x) % MOD;
}
return res;
}
template <typename T>
void swap(T *x, T *y) {
T temp;
temp = *y;
*y = *x;
*x = temp;
}
template <typename T>
T mod(T a) {
if (a > 0)
return a;
else
return -a;
}
template <typename T>
T logg(T a) {
T x = 0;
while (a > 1) {
x++;
a /= 2;
}
return x;
}
vector<vector<pair<int, int>>> g;
vector<vector<int>> leaves;
vector<int> pr;
vector<bool> vis;
vector<vector<int>> op;
int root = 1;
void dfs1(int s) {
vis[s] = 1;
for (auto k : g[s]) {
if (!vis[k.first]) {
pr[k.first] = s;
dfs1(k.first);
leaves[s].push_back(leaves[k.first][0]);
}
}
if (leaves[s].size() == 0) leaves[s].push_back(s);
}
void add_path(int v, int x) {
if (leaves[v].size() == 1) {
op.push_back({root, v, x});
return;
}
op.push_back({root, leaves[v][0], x / 2});
op.push_back({root, leaves[v][1], x / 2});
op.push_back({leaves[v][0], leaves[v][1], -x / 2});
}
void add_edge(int v, int x) {
if (root == pr[v]) {
add_path(v, x);
return;
}
add_path(v, x);
add_path(pr[v], -x);
}
void dfs2(int s) {
vis[s] = 1;
for (auto k : g[s]) {
if (!vis[k.first]) {
add_edge(k.first, k.second);
dfs2(k.first);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
leaves.resize(n + 1);
g.resize(n + 1);
pr.resize(n + 1);
vis.resize(n + 1);
for (int i = 1; i <= n; i++) vis[i] = 0;
for (int i = 1; i <= n - 1; i++) {
int a, b, x;
cin >> a >> b >> x;
g[a].push_back({b, x});
g[b].push_back({a, x});
}
for (int i = 1; i <= n; i++)
if (g[i].size() == 2) {
cout << "NO\n";
return 0;
}
while (g[root].size() != 1) root++;
dfs1(root);
vis = vector<bool>(n + 1);
dfs2(root);
cout << "YES\n";
cout << op.size() << '\n';
for (auto it = op.begin(); it != op.end(); it++) {
cout << (*it)[0] << ' ' << (*it)[1] << ' ' << (*it)[2] << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << -1 << '\n';
return 0;
}
for (int i = 0; i < n; i++) cout << i << " ";
cout << '\n';
for (int i = 0; i < n; i++) cout << i << " ";
cout << '\n';
for (int i = 0; i < n; i++) cout << (2 * i) % n << " ";
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
template <typename T>
void MACRO_VAR_Scan(T& t) {
std::cin >> t;
}
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First& first, Rest&... rest) {
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
template <typename T>
void MACRO_VEC_ROW_Init(int n, T& t) {
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First& first, Rest&... rest) {
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T>
void MACRO_VEC_ROW_Scan(int p, T& t) {
std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First& first, Rest&... rest) {
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
template <typename T>
inline T CHMAX(T& a, const T b) {
return a = (a < b) ? b : a;
}
template <typename T>
inline T CHMIN(T& a, const T b) {
return a = (a > b) ? b : a;
}
void CHECKTIME(std::function<void()> f) {
auto start = std::chrono::system_clock::now();
f();
auto end = std::chrono::system_clock::now();
auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start))
.count();
std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n";
}
template <class T>
std::vector<std::vector<T>> VV(int n) {
return std::vector<std::vector<T>>(n);
}
template <class T>
std::vector<std::vector<T>> VV(int n, int m, T init = T()) {
return std::vector<std::vector<T>>(n, std::vector<T>(m, init));
}
template <typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<ll, ll>;
using PAIRLL = std::pair<ll, ll>;
constexpr ll INFINT = 1 << 30;
constexpr ll INFINT_LIM = (1LL << 31) - 1;
constexpr ll INFLL = 1LL << 60;
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);
constexpr double EPS = 1e-9;
constexpr ll MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
;
ll n;
MACRO_VAR_Scan(n);
;
std::vector<ll> p(n);
for (auto& i : p) std::cin >> i;
;
ll r = n - 1;
std::vector<bool> put(n, false);
std::cout << "1 ";
;
for (ll i = 0; i < ll(n); ++i) {
--p[i];
put[p[i]] = true;
while (r >= 0 && put[r]) --r;
std::cout << i + 2 - (n - r - 1);
std::cout << (i + 1 == n ? '\n' : ' ');
;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int setbit(int n, int i, int v) {
return ((v) ? (n | (1 << i)) : (n & ~(1 << i)));
}
long long gcd(int i, int j) {
if (j == 0) return i;
return gcd(j, i % j);
}
bool chk(int n, int i) {
if ((n >> i) & 1 == 1) return 1;
return 0;
}
bool T(pair<pair<int, int>, int> p1, pair<pair<int, int>, int> p2) {
return (p2.second > p1.second);
}
int n, k;
long long mem[104][30005];
pair<long long, long long> a[105];
long long dp(int i, int s) {
if (s < -1e4) return -1e6;
if (i >= n) {
if (s == 0) return 0;
return -1e6;
}
int tmp = s + 1e5;
long long& ret = mem[i][tmp];
if (ret != -1) return ret;
ret = 0;
ret = dp(i + 1, s + (a[i].first - a[i].second * k)) + a[i].first;
ret = max(ret, dp(i + 1, s));
return ret;
}
int main() {
ios::sync_with_stdio(0);
while (cin >> n) {
cin >> k;
for (int i = 0; i < n; i++) cin >> a[i].first;
for (int i = 0; i < n; i++) cin >> a[i].second;
memset(mem, -1, sizeof mem);
int ans = dp(0, 0);
if (ans <= 0)
cout << -1 << endl;
else
cout << ans << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 500005;
const long long mod = 1e9 + 7;
void solve() {
long long x = 0, y = 0, c = 0, ans = 0;
long long n, m, k;
cin >> n;
long long a[3][n], dp[3][n];
for (long long i = 0; i < 3; ++i) {
for (long long j = 0; j < n; ++j) {
cin >> a[i][j];
dp[i][j] = -1e18;
}
}
dp[0][0] = a[0][0];
for (long long i = 1; i < n; ++i) {
dp[0][i] = a[0][i] + max({dp[0][i - 1], dp[1][i - 1] + a[0][i - 1],
dp[2][i - 1] + a[1][i - 1] + a[0][i - 1]});
dp[1][i] = a[1][i] + max({dp[1][i - 1], dp[0][i - 1] + a[1][i - 1],
dp[2][i - 1] + a[1][i - 1]});
dp[2][i] = a[2][i] + max({dp[2][i - 1], dp[1][i - 1] + a[2][i - 1],
dp[0][i - 1] + a[1][i - 1] + a[2][i - 1]});
if (i > 1) {
dp[0][i] =
max(dp[0][i], dp[2][i - 2] + a[2][i - 1] + a[1][i - 1] + a[1][i - 2] +
a[0][i - 2] + a[0][i - 1] + a[0][i]);
dp[2][i] =
max(dp[2][i], dp[0][i - 2] + a[0][i - 1] + a[1][i - 1] + a[1][i - 2] +
a[2][i - 2] + a[2][i - 1] + a[2][i]);
}
}
ans = max({dp[2][n - 1], a[2][n - 1] + dp[1][n - 1],
a[1][n - 1] + a[2][n - 1] + dp[0][n - 1]});
if (n > 1)
ans = max({ans, dp[0][n - 2] + a[1][n - 2] + a[2][n - 2] + a[0][n - 1] +
a[1][n - 1] + a[2][n - 1]});
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
int n, m, f[20][20][20][20][2][2], g[20][20][20][20][2][2];
int cnx[32], cpx[32], cny[32], cpy[32];
void red(int &x) { x += x >> 31 & P; }
int main() {
scanf("%d %d", &n, &m);
for (int i = 0, x, y; i < n; i++) {
scanf("%d %d", &x, &y);
x < 0 ? cnx[1 << i] -= x : cpx[1 << i] += x;
y < 0 ? cny[1 << i] -= y : cpy[1 << i] += y;
}
int U = (1 << n) - 1;
for (int i = 1; i <= U; i++) {
auto upd = [&](int *c) { c[i] = c[i & (i - 1)] + c[i & -i]; };
upd(cnx), upd(cpx), upd(cny), upd(cpy);
}
for (******f = 1; m; m >>= 1, swap(f, g)) {
int c = m & 1;
memset(g, 0, sizeof(g));
for (int nx = 0; nx <= cnx[U]; nx++)
for (int px = 0; px <= cpx[U]; px++) {
for (int ny = 0; ny <= cny[U]; ny++)
for (int py = 0; py <= cpy[U]; py++) {
for (int xm : {0, 1})
for (int ym : {0, 1})
if (f[nx][px][ny][py][xm][ym]) {
for (int C = 0; C <= U; C++) {
int _nx = nx + cnx[C], _px = px + cpx[C];
int _ny = ny + cny[C], _py = py + cpy[C];
if (((_nx ^ _px) & 1) || ((_ny ^ _py) & 1)) continue;
red(g[_nx >> 1][_px >> 1][_ny >> 1][_py >> 1]
[(_nx ^ c) & 1 ? !c : xm][(_ny ^ c) & 1 ? !c : ym] +=
f[nx][px][ny][py][xm][ym] - P);
}
}
}
}
}
printf("%d\n", (******f + P - 1) % P);
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
const int MAX = 1000010;
const int MOD2 = 998244353;
const int MOD1 = 1000000007;
const int INF = 0x3f;
const long long int LLINF = 0x3f3f3f3f3f3f3f3fll;
const long double EPS = 1e-7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(25);
cerr << fixed << setprecision(10);
string s;
cin >> s;
int n = static_cast<int>(s.size());
vector<int> a(n + 1), pref(n + 1), dp(n + 1);
for (int i = 1; i <= n; i++) {
a[i] = (s[i - 1] == 'F' ? 0 : 1);
pref[i] = pref[i - 1] + a[i];
}
for (int i = 1; i <= n; i++) {
if (a[i])
dp[i] = dp[i - 1];
else if (pref[i])
dp[i] = max(dp[i - 1] + 1, pref[i]);
}
cout << dp[n] << "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXP = 100500;
bool is_prime[MAXP];
const int MAXN = 300;
int ans[MAXN];
int rev[MAXN];
int rev1[MAXN];
int sm[MAXN][MAXN];
int n, arr[MAXN];
bool used[MAXN];
void gen_primes() {
for (int i = 0; i < MAXP; ++i) {
is_prime[i] = true;
}
is_prime[0] = is_prime[1] = false;
for (int i = 2; i * i < MAXP; ++i) {
if (is_prime[i]) {
for (int j = i * i; j < MAXP; j += i) {
is_prime[j] = false;
}
}
}
}
bool try_kuhn(int x) {
if (used[x]) {
return false;
}
used[x] = true;
for (int j = 0; j < n; ++j) {
if (sm[x][j]) {
if (rev[j] == -1 || try_kuhn(rev[j])) {
rev[j] = x;
return true;
}
}
}
return false;
}
bool upd_kuhn(int x) {
if (used[x]) {
return false;
}
used[x] = true;
for (int j = 0; j < n; ++j) {
if (sm[x][j] && j != rev[x]) {
if (rev[j] == -1 || upd_kuhn(rev[j])) {
rev[j] = x;
return true;
}
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
gen_primes();
cin >> n;
int odd = 0, even = 0;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
if (arr[i] % 2 == 0) {
odd++;
} else {
even++;
}
}
for (int i = 0; i < n; ++i) {
if (arr[i] % 2 == 1) {
continue;
}
for (int j = 0; j < n; ++j) {
if (is_prime[arr[i] + arr[j]]) {
sm[i][j] = 1;
}
}
}
for (int i = 0; i < n; ++i) {
rev[i] = -1;
}
for (int i = 0; i < n; ++i) {
if (arr[i] % 2 == 1) {
continue;
}
memset(used, 0, sizeof(used[0]) * n);
try_kuhn(i);
}
bool ok = true;
for (int i = 0; i < n && ok; ++i) {
if (arr[i] % 2 == 1 && rev[i] == -1) {
ok = false;
} else if (arr[i] % 2 == 1) {
rev[rev[i]] = i;
}
}
if (ok && odd == even) {
for (int i = 0; i < n && ok; ++i) {
if (arr[i] % 2 == 0) {
continue;
}
int start = rev[i];
if (rev[start] != i) {
continue;
}
memset(used, 0, sizeof(used[0]) * n);
rev[i] = -1;
sm[start][i] = 0;
if (!upd_kuhn(start)) {
ok = false;
}
sm[start][i] = 1;
}
if (!ok) {
cout << "Impossible\n";
} else {
vector<vector<int> > res;
memset(used, 0, sizeof(used[0]) * n);
for (int i = 0; i < n; ++i) {
if (!used[i]) {
vector<int> tmp;
int cur = i;
while (!used[cur]) {
used[cur] = 1;
tmp.push_back(cur);
cur = rev[cur];
}
res.push_back(tmp);
}
}
cout << res.size() << '\n';
for (auto &tmp : res) {
cout << tmp.size();
for (auto x : tmp) {
cout << " " << x + 1;
}
cout << '\n';
}
}
} else {
cout << "Impossible\n";
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
long long t, w, b;
cin >> t >> w >> b;
long long g = gcd(w, b);
long long nl = t / w * g / b;
long long ml = nl * (w / g * b);
long long res = nl * min(w, b) + min(t - ml + 1, min(w, b)) - 1;
long long g2 = gcd(res, t);
res /= g2, t /= g2;
cout << res << '/' << t << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e6;
void my_dbg() { cout << endl; }
template <typename Arg, typename... Args>
void my_dbg(Arg A, Args... B) {
cout << ' ' << A;
my_dbg(B...);
}
int main() {
int n;
scanf("%d", &n);
vector<int> a(n), b(n), c(n), d(n);
for (int i = 0; i < (int)n; i++)
scanf("%d", &a[i]), scanf("%d", &b[i]), scanf("%d", &c[i]),
scanf("%d", &d[i]);
set<int> s;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i] < a[j] and b[i] < b[j] and c[i] < c[j]) s.insert(i);
}
}
int id = -1, mn = INT_MAX;
for (int i = 0; i < (int)n; i++) {
if (s.find(i) != s.end()) continue;
if (mn > d[i]) mn = d[i], id = i + 1;
}
printf("%d\n", (int)id);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int c=300002;
int w, n, db[c], t[c], kezd, veg, sp, ert, pos;
int main()
{
ios_base::sync_with_stdio(false);
cin >> w;
while(w--) {
cin >> n, kezd=1, veg=n, ert=0, sp=1, pos=1;
for (int i=1; i<=n; i++) db[i]=0;
for (int i=1; i<=n; i++) {
cin >> t[i];
db[t[i]]++;
if (db[t[i]]>1) sp=0;
}
while(true) {
if (db[pos]) ert++;
if (db[pos]>1 || min(t[kezd], t[veg])!=pos) break;
if (t[kezd]==pos) kezd++;
if (t[veg]==pos) veg--;
pos++;
}
cout << sp;
for (int i=2; i<=n; i++) {
if (i<=n-ert) cout << 0;
else cout << 1;
}
cout << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long fun(char a, char b, char c) {
long long ans = 0;
for (long long i = 0; i < s.size(); i++) {
if (s[i] != a && i % 3 == 0) ans++;
if (i % 3 == 1 && s[i] != b) ans++;
if (i % 3 == 2 && s[i] != c) ans++;
}
return ans;
}
void print(char a, char b, char c) {
for (long long i = 0; i < s.size(); i++) {
if (i % 3 == 0) cout << a;
if (i % 3 == 1) cout << b;
if (i % 3 == 2) cout << c;
}
}
int32_t main() {
cin.sync_with_stdio(false);
long long n;
cin >> n;
cin >> s;
long long rg, rb, gb, gr, bg, br;
rg = fun('R', 'G', 'B');
long long mx = rg, mw = 0;
rb = fun('R', 'B', 'G');
if (rb < mx) {
mx = rb;
mw = 1;
}
gb = fun('G', 'B', 'R');
if (gb < mx) {
mx = gb;
mw = 2;
}
gr = fun('G', 'R', 'B');
if (gr < mx) {
mx = gr;
mw = 3;
}
bg = fun('B', 'G', 'R');
if (bg < mx) {
mx = bg;
mw = 4;
}
br = fun('B', 'R', 'G');
if (br < mx) {
mx = br;
mw = 5;
}
cout << mx << "\n";
if (mw == 0) print('R', 'G', 'B');
if (mw == 1) print('R', 'B', 'G');
if (mw == 2) print('G', 'B', 'R');
if (mw == 3) print('G', 'R', 'B');
if (mw == 4) print('B', 'G', 'R');
if (mw == 5) print('B', 'R', 'G');
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll n, k;
cin >> n >> k;
string s;
cin >> s;
ll mx = -1, mn = 1e9;
map<char, ll> mp;
for (char i : s) {
mp[i]++;
}
for (auto i : mp) {
mx = max(mx, i.second);
mn = min(mn, i.second);
}
if (mp.size() < k or k > n) return cout << 0, 0;
return cout << ((ll)mp.size() * mn), 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100100, MMAX = 100100;
const int VMAX = 100100, EMAX = 200100;
struct Digonal {
int x;
int y;
int cnt;
};
struct Polygon {
int color;
vector<int> point;
};
struct Edge {
int y;
int nxt;
int rev;
bool ban;
};
int N, M;
Digonal dig[MMAX];
int pid, nxt[NMAX], polyId[NMAX];
Polygon polygon[NMAX];
int V[VMAX], eid, cnt[VMAX], maxSize[VMAX];
Edge edge[EMAX];
void insert(int x, int y) {
edge[++eid] = (Edge){y, V[x], 0, false};
V[x] = eid;
edge[++eid] = (Edge){x, V[y], 0, false};
V[y] = eid;
edge[V[x]].rev = V[y];
edge[V[y]].rev = V[x];
}
bool cmp(const Digonal &x, const Digonal &y) { return x.cnt < y.cnt; }
int DFS(int x, int fa) {
int i;
cnt[x] = 1;
maxSize[x] = 0;
for (i = V[x]; i; i = edge[i].nxt) {
if (edge[i].ban || edge[i].y == fa) continue;
cnt[x] += DFS(edge[i].y, x);
maxSize[x] = max(maxSize[x], cnt[edge[i].y]);
}
return cnt[x];
}
int findCent(int x, int tot, int fa) {
int i, res = x, cand;
for (i = V[x]; i; i = edge[i].nxt) {
if (edge[i].ban || edge[i].y == fa) continue;
cand = findCent(edge[i].y, tot, x);
if (max(maxSize[res], tot - cnt[res]) > max(maxSize[cand], tot - cnt[cand]))
res = cand;
}
return res;
}
void solve(int x, int color) {
int i, cent;
DFS(x, 0);
cent = findCent(x, cnt[x], 0);
polygon[cent].color = color;
for (i = V[cent]; i; i = edge[i].nxt) {
if (edge[i].ban) continue;
edge[i].ban = edge[edge[i].rev].ban = true;
solve(edge[i].y, color + 1);
}
}
bool vectorCmp(Polygon &x, Polygon &y) {
int i;
for (i = 0; i < x.point.size() && i < y.point.size(); i += 1) {
if (x.point[i] < y.point[i])
return true;
else if (x.point[i] > y.point[i])
return false;
}
return i < y.point.size();
}
bool greatCmp(int &x, int &y) { return x > y; }
int main() {
int i, x, y, pos, begin;
scanf("%d %d", &N, &M);
for (i = 0; i < M; i += 1) {
scanf("%d %d", &x, &y);
x -= 1;
y -= 1;
if (x > y) swap(x, y);
dig[i].cnt = min(y - x - 1, x + N - y - 1);
if (y - x - 1 > x + N - y - 1) swap(x, y);
dig[i].x = x;
dig[i].y = y;
}
sort(dig, dig + M, cmp);
for (i = 0; i < N; i += 1) nxt[i] = (i + 1) % N;
for (i = pos = 0; i < M; i += 1) {
pid += 1;
pos = dig[i].x;
while (pos != dig[i].y) {
polygon[pid].point.push_back(pos);
if (polyId[pos]) insert(polyId[pos], pid);
pos = nxt[pos];
}
polygon[pid].point.push_back(pos);
sort(polygon[pid].point.begin(), polygon[pid].point.end(), greatCmp);
nxt[dig[i].x] = dig[i].y;
polyId[dig[i].x] = pid;
}
pid += 1;
begin = pos;
do {
polygon[pid].point.push_back(pos);
if (polyId[pos]) insert(polyId[pos], pid);
pos = nxt[pos];
} while (pos != begin);
sort(polygon[pid].point.begin(), polygon[pid].point.end(), greatCmp);
solve(pid, 1);
sort(polygon + 1, polygon + pid + 1, vectorCmp);
for (i = 1; i <= pid; i += 1)
printf("%d%c", polygon[i].color, " \n"[i == pid ? 1 : 0]);
exit(0);
}
| 20 |
#include<bits/stdc++.h>
#define t int t;cin>>t;while(t--)
using namespace std;
int main()
{
t{
int n;
cin>>n;
long long val[n];
for(int i=0;i<n;i++)
cin>>val[i];
if(n%2!=0){
for(int i=0;i<n/2;i++){
cout<<val[i]<<" "<<val[n-i-1]<<" ";
}
cout<<val[n/2]<<endl;
}
else{
for(int i=0;i<n/2;i++){
cout<<val[i]<<" "<<val[n-i-1]<<" ";
}
cout<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long x;
cin >> x;
x *= 6;
long long ans = 0;
vector<pair<long long, long long> > answers;
for (long long m = 1; m * (m + 1) * (2 * m + 1) <= x; ++m) {
long long d = m * (m + 1);
if (x % d != 0) {
continue;
}
long long xx = x / d;
xx += (m - 1);
if ((xx < 3 * m) || (xx % 3 != 0)) {
continue;
}
long long n = xx / 3;
answers.push_back(make_pair(m, n));
if (n != m) answers.push_back(make_pair(n, m));
}
sort(answers.begin(), answers.end());
cout << answers.size() << "\n";
for (int i = 0; i < answers.size(); ++i) {
cout << answers[i].first << " " << answers[i].second << "\n";
}
return 14 / 88;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int P[N], n;
int main(void) {
int ans = 2;
int len = 2;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &P[i]);
if (i >= 2) {
if (P[i] == P[i - 1] + P[i - 2]) {
len++;
ans = max(ans, len);
} else
len = 2;
}
}
if (n == 1) {
printf("1\n");
return 0;
} else {
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
char a[2], b[2], c, d;
int x, y;
cin >> a >> b;
x = a[0] - b[0];
y = a[1] - b[1];
c = (x < 0 ? x = -x, 'R' : 'L');
d = (y < 0 ? y = -y, 'U' : 'D');
cout << max(x, y);
while (x || y) {
cout << "\n";
if (x) x--, cout << c;
if (y) y--, cout << d;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int n, m, a[N][N], dp[1 << N], se[N][N], co[N][N];
char s[N + 2][N + 2];
bool vis[26];
void upd(int &u, const int &v) { u == -1 ? u = v : u = min(u, v); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= n; k++)
if (s[i][j] == s[k][j]) {
se[i][j] ^= 1 << (k - 1);
if (i == k) continue;
co[i][j] += a[k][j];
}
}
}
fill(dp + 1, dp + (1 << n), -1);
dp[0] = 0;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < n; j++)
if (!(i >> j & 1)) {
for (int k = 1; k <= m; k++) {
upd(dp[i | (1 << j)], dp[i] + a[j + 1][k]);
upd(dp[i | se[j + 1][k]], dp[i] + co[j + 1][k]);
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, l, n, m, t;
string a, b, c, d;
cin >> a;
int after = 0;
int op, cl, ha;
op = cl = ha = 0;
int lst;
for (i = 0; i < a.size(); i++) {
if (a[i] == '(')
op++;
else if (a[i] == ')')
cl++;
else {
ha++;
lst = i;
}
}
for (i = lst + 1; i < a.size(); i++) {
if (a[i] == ')') after++;
}
int dif = op - cl;
int flag = 0;
int arr[100005];
int si = 0;
if (dif <= 0 || dif < ha)
flag = 1;
else {
int op1, cl1;
op1 = cl1 = 0;
for (i = 0; i < a.size(); i++) {
if (a[i] == '(') {
op1++;
} else if (a[i] == ')') {
cl1++;
} else {
if (i != lst) {
cl1++;
arr[si++] = 1;
} else {
arr[si++] = op - cl1 - after;
cl1 = op - after;
}
}
if (cl1 > op1) flag = 1;
}
if (cl1 != op1) flag = 1;
}
if (flag)
cout << "-1" << endl;
else {
for (i = 0; i < si; i++) cout << arr[i] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void output_strings(int ind[], string s[]) {
for (int i = 0; i < 6; i++) {
cout << s[ind[i]] << " ";
}
cout << endl;
return;
}
bool check(int ind[], string s[]) {
int l[6];
char b[6], e[6];
for (int i = 0; i < 6; i++) {
l[i] = s[ind[i]].length();
b[i] = s[ind[i]][0];
e[i] = s[ind[i]][l[i] - 1];
}
bool cond = true;
cond &= (l[0] + l[2] == l[1] + 1);
cond &= (l[3] + l[5] == l[4] + 1);
if (!cond) {
return false;
}
cond &= (b[0] == b[3]);
cond &= (b[4] == e[0]);
cond &= (b[1] == e[3]);
cond &= (b[5] == e[1]);
cond &= (e[2] == e[5]);
cond &= (e[4] == b[2]);
if (!cond) {
return false;
}
cond &= (s[ind[1]][l[0] - 1] == s[ind[4]][l[3] - 1]);
if (!cond) {
return false;
}
return true;
};
void make_result(vector<string>* v, int ind[], string s[]) {
int rows = s[ind[4]].length();
int cols = s[ind[1]].length();
string ss = string(cols, '.');
(*v).resize(rows, ss);
int i;
int j;
string sx;
sx = s[ind[0]];
for (int k = 0; k < sx.length(); k++) {
i = 0;
j = k + 0;
(*v)[i][j] = sx[k];
}
sx = s[ind[1]];
for (int k = 0; k < sx.length(); k++) {
i = s[ind[3]].length() - 1;
j = k + 0;
(*v)[i][j] = sx[k];
}
sx = s[ind[2]];
for (int k = 0; k < sx.length(); k++) {
i = s[ind[4]].length() - 1;
j = s[ind[0]].length() - 1 + k;
(*v)[i][j] = sx[k];
}
sx = s[ind[3]];
for (int k = 0; k < sx.length(); k++) {
i = k + 0;
j = 0;
(*v)[i][j] = sx[k];
}
sx = s[ind[4]];
for (int k = 0; k < sx.length(); k++) {
i = k + 0;
j = s[ind[0]].length() - 1;
(*v)[i][j] = sx[k];
}
sx = s[ind[5]];
for (int k = 0; k < sx.length(); k++) {
i = s[ind[3]].length() - 1 + k;
j = s[ind[1]].length() - 1;
(*v)[i][j] = sx[k];
}
return;
};
bool is_smaller(vector<string>* v1, vector<string>* v2) {
if ((*v2).empty()) {
return true;
}
for (int i = 0; i < min((*v1).size(), (*v2).size()); i++) {
if ((*v1)[i] < (*v2)[i]) {
return true;
} else if ((*v1)[i] > (*v2)[i]) {
return false;
}
}
return false;
};
int main() {
int ind[] = {0, 1, 2, 3, 4, 5};
vector<string>* best;
vector<string>* curr;
best = new vector<string>;
string s[6];
for (int i = 0; i < 6; i++) {
getline(cin, s[i]);
}
do {
if (check(ind, s)) {
curr = new vector<string>;
make_result(curr, ind, s);
if (is_smaller(curr, best)) {
delete best;
best = curr;
}
}
} while (next_permutation(ind, ind + 6));
if ((*best).empty()) {
cout << "Impossible" << endl;
} else {
for (int i = 0; i < (*best).size(); i++) {
cout << (*best)[i] << endl;
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int GO_MAX = 26;
const int ESP = 1e-9;
const int MAX = 101001;
const int INF = 1e9;
const int H_val = 37;
const int mod = 1000000;
const double PI = 3.14159265359;
int n, m, k, t, p, q;
int num[MAX * 5];
bool vst[MAX * 5], trig = true;
vector<int> vec[MAX * 5];
struct str {
int val, idx;
bool operator<(const str& A) const { return val < A.val; }
};
str arr[MAX * 5];
struct str2 {
int val, nxt;
bool operator<(const str2& A) const { return val < A.val; }
};
vector<str2> nvec[MAX * 5];
void dfs(int cur) {
vst[cur] = true;
int cnt = 0;
for (str2 nxt : nvec[cur]) {
if (!vst[nxt.nxt]) {
dfs(nxt.nxt);
}
if (nxt.val == num[cur]) trig = false;
if (cnt == nxt.val - 1) cnt++;
}
if (cnt < num[cur] - 1) trig = false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d %d", &a, &b);
vec[a].push_back(b);
vec[b].push_back(a);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &num[i]);
arr[i] = {num[i], i};
}
for (int i = 1; i <= n; ++i) {
for (int node : vec[i]) {
nvec[i].push_back({num[node], node});
}
sort(nvec[i].begin(), nvec[i].end());
}
for (int i = 1; i <= n && trig; ++i) {
if (!vst[i]) dfs(i);
}
if (!trig) {
printf("-1");
return 0;
}
sort(arr + 1, arr + n + 1);
for (int i = 1; i <= n; ++i) {
printf("%d ", arr[i].idx);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxRange = 100000;
int n, m;
int np = 0;
int nf;
int factor[100001];
int l[100001];
int on[100001];
bool seive[maxRange + 1];
int prime[100001];
void createSieve();
void analize(int);
int main() {
list<int>::iterator it;
createSieve();
for (int i = 2; i <= 100000; i++)
if (seive[i]) prime[++np] = i;
scanf("%d %d%*c", &n, &m);
for (int q = 1; q <= m; q++) {
int k;
char op;
scanf("%c%*c%d%*c", &op, &k);
if (k == 1) {
if (op == '+') {
if (on[k] == 1)
cout << "Already on" << endl;
else {
cout << "Success" << endl;
on[k] = 1;
}
} else {
if (on[k] == 0)
cout << "Already off" << endl;
else {
cout << "Success" << endl;
on[k] = 0;
}
}
continue;
}
analize(k);
if (op == '+') {
if (on[k] == 1)
printf("%s\n", "Already on");
else {
bool ok = true;
for (int i = 1; i <= nf; i++)
if (l[factor[i]] > 0) {
ok = false;
printf("%s %d\n", "Conflict with", l[factor[i]]);
break;
}
if (ok) {
for (int i = 1; i <= nf; i++) l[factor[i]] = k;
on[k] = 1;
cout << "Success" << endl;
}
}
} else {
if (on[k] == 0)
printf("%s\n", "Already off");
else {
on[k] = 0;
printf("%s\n", "Success");
for (int i = 1; i <= nf; i++) l[factor[i]] = 0;
}
}
}
return 0;
}
void createSieve() {
for (int i = 1; i <= maxRange; i++) seive[i] = true;
seive[1] = false;
for (int i = 2; i <= floor(sqrt(maxRange)) + 1; i++)
if (seive[i]) {
int k = i;
seive[i] = true;
while (i * k <= maxRange) {
seive[i * k] = false;
k++;
}
}
}
void analize(int k) {
if (seive[k]) {
nf = 1;
factor[1] = k;
return;
}
nf = 0;
for (int i = 1; i <= np; i++)
if (k % prime[i] == 0) {
nf++;
factor[nf] = prime[i];
while (k % prime[i] == 0) k = k / prime[i];
if (seive[k]) {
nf++;
factor[nf] = k;
return;
}
if (k == 1) break;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int A[200000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int N, K;
cin >> N >> K;
N *= 2;
for (int i = 0; i < N; ++i) A[i] = i + 1;
for (int i = 0; i < 2 * K; i += 2) swap(A[i], A[i ^ 1]);
for (int i = 0; i < N; ++i) cout << A[i] << " \n"[i == N - 1];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long num[100009], a[100009];
int f[100009];
struct edge {
int x, y;
long long w;
void input() {
scanf("%d%d", &x, &y);
w = min(a[x], a[y]);
}
bool operator<(const struct edge &b) const { return w > b.w; }
} e[100009];
int refa(int x) { return (f[x] == x ? f[x] : (f[x] = refa(f[x]))); }
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
e[i].input();
}
for (int i = 1; i <= n; i++) {
f[i] = i;
num[i] = 1;
}
int x, y;
double ans = 0;
sort(e, e + m);
for (int i = 0; i < m; i++) {
x = e[i].x;
y = e[i].y;
int fx = refa(x);
int fy = refa(y);
if (fx == fy)
continue;
else {
ans += e[i].w * (num[fx]) * num[fy];
f[fy] = fx;
num[fx] = num[fx] + num[fy];
}
}
ans *= 2;
ans = ans / (n * (n - 1));
printf("%.6f\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
#define i64 long long
#define sz(a) int ((a).size())
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
#define per(i, a, b) for (int i = (b) - 1; i >= (a); --i)
using namespace std;
const int N = 1501, Nk = 11;
int n, k, a[N][N], cnt[Nk], f[N];
bool vis[N * N];
vector<pair<int, int>> c[N][N];
#define hold(v) for (auto &p : v) { \
C.emplace_back(p.first + 1, p.second); \
}
void GetC(int i, int j) {
vector<pair<int, int>> C;
C.emplace_back(0, a[i][j]);
hold(c[i + 1][j]);
hold(c[i][j + 1]);
hold(c[i + 1][j + 1]);
sort(C.begin(), C.end());
for (auto &p : C) {
if (not vis[p.second]) {
vis[p.second] = true;
c[i][j].push_back(p);
if (sz(c[i][j]) == k + 1) {
break;
}
}
}
for (auto &p : c[i][j]) {
vis[p.second] = false;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
rep(i, 0, n) {
rep(j, 0, n) {
cin >> a[i][j], --a[i][j];
}
}
per(i, 0, n) {
per(j, 0, n) {
GetC(i, j);
int p = min(n - i, n - j);
if (sz(c[i][j]) > k) {
p = min(p, c[i][j][k].first);
}
f[p] += 1;
}
}
per(i, 1, n) {
f[i] += f[i + 1];
}
rep(i, 1, n + 1) {
cout << f[i] << '\n';
}
return 0;
}
/*
* Read Carefully! Multiple cases? Data range?
* Transformation? Special cases? Brute & Regularities?
* Don't get stuck! New directions! Record thoughts!
* Int overflow? Array bounds? N = 1?
*/
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e10;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
int n, k;
vector<int> G[110];
long long f[110][25], g[110][25], t1[25], t2[25];
void dfs(int u = 1, int par = 0) {
f[u][k] = g[u][0] = 1ll;
for (auto v : G[u])
if (v != par) {
dfs(v, u);
memcpy(t1, f[u], sizeof(t1));
memcpy(t2, g[u], sizeof(t2));
memset((f[u]), (0), sizeof((f[u])));
memset((g[u]), (0), sizeof((g[u])));
for (int i = (0); i <= (k); i++)
for (int j = (0); j <= (k); j++)
(f[u][max(i, j - 1)] += t1[i] * f[v][j]) %= 1000000007;
for (int i = (0); i <= (k); i++)
for (int j = (0); j <= (k); j++)
if (i >= j + 1)
(f[u][i] += t1[i] * g[v][j]) %= 1000000007;
else
(g[u][j + 1] += t1[i] * g[v][j]) %= 1000000007;
for (int i = (0); i <= (k); i++)
for (int j = (0); j <= (k); j++)
if (j - 1 >= i)
(f[u][j - 1] += t2[i] * f[v][j]) %= 1000000007;
else
(g[u][i] += t2[i] * f[v][j]) %= 1000000007;
for (int i = (0); i <= (k); i++)
for (int j = (0); j <= (k); j++)
(g[u][max(i, j + 1)] += t2[i] * g[v][j]) %= 1000000007;
}
return;
}
int main() {
scf(n, k);
for (int i = 0; i < (n - 1); i++) {
int u, v;
scf(u, v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs();
long long ans = 0;
for (int i = (0); i <= (k); i++) (ans += f[1][i]) %= 1000000007;
printf("%I64d\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, m;
cin >> n >> m;
if (m > n) swap(m, n);
if (m * 2 >= n)
cout << m * 2 * m * 2 << endl;
else
cout << n * n << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
Point() {}
Point(double _x, double _y) {
x = _x;
y = _y;
}
double get() {
int a, b;
scanf("%d%d", &a, &b);
return 1.0 * a / b;
}
void read() {
double x1 = get(), y1 = get();
x = x1 / (x1 * x1 + y1 * y1);
y = y1 / (x1 * x1 + y1 * y1);
}
Point operator+(Point b) { return Point(x + b.x, y + b.y); }
Point operator-(Point b) { return Point(x - b.x, y - b.y); }
bool operator<(Point b) {
if (((x - b.x) > 0 ? (x - b.x) : -(x - b.x)) > 1e-9) return x < b.x;
if (((y - b.y) > 0 ? (y - b.y) : -(y - b.y)) > 1e-9) return y < b.y;
return false;
}
} p[1100], Q[1100000];
int n, i, j, len, q, h, q1, h1, ans, tt, t[1000000], tx[1100000];
double f[1000000];
bool cmp(int x, int y) {
if (Q[x] < Q[y] || Q[y] < Q[x]) return Q[x] < Q[y];
if (t[x] != t[y]) return t[x] < t[y];
return f[x] < f[y];
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) p[i].read();
for (i = 1; i <= n; i++)
for (j = 1; j < i; j++) {
len++;
Q[len] = p[i] + p[j];
Point pp = p[i] - p[j];
if (((pp.x) > 0 ? (pp.x) : -(pp.x)) > 1e-9)
t[len] = 0, f[len] = pp.y / pp.x;
else
t[len] = 1, f[len] = pp.x / pp.y;
}
for (i = 1; i <= len; i++) tx[i] = i;
sort(tx + 1, tx + len + 1, cmp);
for (q = 1; q <= len; q = h + 1) {
for (h = q;
h < len && !(Q[tx[q]] < Q[tx[h + 1]]) && !(Q[tx[h + 1]] < Q[tx[q]]);
h++)
;
tt = 1;
for (q1 = q; q1 <= h; q1 = h1 + 1) {
for (h1 = q1; h1 < h && t[tx[h1 + 1]] == t[tx[q1]] &&
((f[tx[h1 + 1]] - f[tx[q1]]) > 0
? (f[tx[h1 + 1]] - f[tx[q1]])
: -(f[tx[h1 + 1]] - f[tx[q1]])) < 1e-9;
h1++)
;
tt = 1LL * tt * (h1 - q1 + 2) % 1000000007;
}
ans = (ans + tt - (h - q + 1) - 1) % 1000000007;
}
printf("%d\n", (ans + 1000000007) % 1000000007);
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
set<int> st[26];
bool vis[26];
string s, ans;
char ab;
void dfs(int pos) {
vis[pos] = true;
for (auto i : st[pos]) {
if (!vis[i]) dfs(i);
}
ab = (char)'a' + pos;
ans += ab;
}
int main() {
int t;
cin >> t;
while (t--) {
ans = "";
cin >> s;
for (int i = 0; i < 26; i++) st[i].clear();
for (int i = 0; i < 26; i++) vis[i] = false;
int n = s.size();
for (int i = 0; i < n - 1; i++) {
st[s[i] - 'a'].insert(s[i + 1] - 'a');
st[s[i + 1] - 'a'].insert(s[i] - 'a');
}
int count = 0;
for (auto it : st) {
if (it.size() == 1) count++;
if (it.size() > 2) count += 1000;
}
if (count != 2 && s.size() != 1) {
cout << "NO\n";
continue;
}
int pos = 0;
for (auto it : st) {
if (it.size() == 1) break;
pos++;
}
if (pos == 26)
ans = s;
else
dfs(pos);
map<int, bool> mp;
for (int i = 0; i < ans.size(); i++) mp[ans[i]] = true;
for (int i = 0; i < 26; i++) {
if (!mp['a' + i]) ans += 'a' + i;
}
cout << "YES\n" << ans << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c, x, aux[1010];
int main() {
scanf("%d %d %d", &n, &m, &c);
for (int i = 0; i < 1010; i++) aux[i] = 1010;
for (int i = 0; i < m; i++) {
scanf("%d", &x);
if (x <= c / 2) {
for (int j = 0; j < n; j++)
if (aux[j] > x) {
aux[j] = x;
printf("%d\n", j + 1);
fflush(stdout);
break;
}
} else {
for (int j = n - 1; j >= 0; j--)
if (aux[j] < x || aux[j] == 1010) {
aux[j] = x;
printf("%d\n", j + 1);
fflush(stdout);
break;
}
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int cnt[30];
long long ans;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
cnt[s[0] - 'a']++;
}
for (int i = 0; i < 26; i++) {
long long x = cnt[i] / 2, y = cnt[i] / 2 + cnt[i] % 2;
ans += x * (x - 1) / 2 + y * (y - 1) / 2;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<unsigned int> ips;
char _;
for (int i = 0; i < n; i++) {
unsigned int ip = 0;
vector<int> A(4);
cin >> A[3] >> _ >> A[2] >> _;
cin >> A[1] >> _ >> A[0];
for (int j = 0; j < 4; j++)
for (int b = 0; b < 8; b++)
if (A[j] & (1 << b)) ip |= 1 << (8 * j + b);
ips.push_back(ip);
}
unsigned int mask = 0;
for (int i = 31; i; i--) {
mask |= 1 << i;
set<unsigned int> nets;
for (unsigned int ip : ips) nets.insert(mask & ip);
if (int(nets.size()) == k) {
vector<int> ans;
for (int j = 0; j < 4; j++) {
ans.push_back(mask & 255);
mask >>= 8;
}
cout << ans[3] << '.' << ans[2] << '.';
cout << ans[1] << '.' << ans[0] << '\n';
return;
}
}
cout << "-1\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
};
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> e1[250010], e2[250010];
int tin[250010], tout[250010], curt;
int par[250010][18];
int uf[250010];
int find(int u) {
if (u == uf[u]) return u;
return uf[u] = find(uf[u]);
}
void merge(int u, int v) {
u = find(u);
v = find(v);
uf[v] = u;
}
bool isanc(int a, int u) {
return a == 0 || tin[a] <= tin[u] && tin[u] <= tout[a];
}
int lca(int u, int v) {
if (isanc(u, v)) return u;
if (isanc(v, u)) return v;
for (int i = 18 - 1; i >= 0; i--) {
if (!isanc(par[u][i], v)) u = par[u][i];
}
return par[u][0];
}
void dfs1(int u, int prv) {
tin[u] = ++curt;
uf[u] = u;
par[u][0] = prv;
for (int i = 1; i < 18; i++) par[u][i] = par[par[u][i - 1]][i - 1];
for (int v : e1[u]) {
if (v == prv) continue;
dfs1(v, u);
}
tout[u] = curt;
}
void dfs2(int u, int prv) {
for (int v : e2[u]) {
if (v == prv) continue;
dfs2(v, u);
}
if (prv == 0) return;
int a = lca(u, prv);
int x = find(u);
if (isanc(x, a)) {
x = prv;
for (int i = 18 - 1; i >= 0; i--) {
if (!isanc(find(par[x][i]), a)) x = par[x][i];
}
}
cout << x << ' ' << par[x][0] << ' ' << u << ' ' << prv << '\n';
merge(par[x][0], x);
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
e1[a].push_back(b);
e1[b].push_back(a);
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
e2[a].push_back(b);
e2[b].push_back(a);
}
dfs1(1, 0);
cout << n - 1 << '\n';
dfs2(1, 0);
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3e5 + 4;
int n, m, loga;
bool vis[maxN];
char str[maxN];
set<int> Set[256];
int aib[maxN];
inline int lsb(int x) { return x & (-x); }
void update(int pos, int val) {
for (int i = pos; i <= loga; i += lsb(i)) aib[i] += val;
}
int query(int val) {
int sum = 0;
for (int i = loga >> 1; i > 0; i >>= 1)
if (aib[sum + i] < val) {
val -= aib[sum + i];
sum += i;
}
return sum + 1;
}
int main() {
scanf("%d%d%s", &n, &m, str + 1);
for (int i = 1; i <= n; i++) Set[str[i]].insert(i);
for (loga = 1; loga < n; loga <<= 1)
;
for (int i = 1; i <= n; i++) update(i, 1);
while (m--) {
int st, dr;
char ch;
scanf("%d %d %c", &st, &dr, &ch);
st = query(st);
dr = query(dr);
for (set<int>::iterator it = Set[ch].lower_bound(st);
it != Set[ch].end() && *it <= dr;) {
vis[*it] = true;
update(*it, -1);
Set[ch].erase(it++);
}
}
for (int i = 1; i <= n; i++)
if (!vis[i]) printf("%c", str[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
bool bj = 0;
int n, m, ans, tmp, a[100005], b[100005], q[100005];
long long s1[100005], s2[100005];
struct node {
long long icr, num, mn, mx, val;
} P[100005 << 2];
void mdy(int k, long long x) {
node &o = P[k];
o.icr += x;
o.mx += x;
o.mn += x;
o.val += x;
}
void pushdn(int k) {
if (P[k].icr) {
mdy(k << 1, P[k].icr);
mdy(k << 1 | 1, P[k].icr);
P[k].icr = 0;
}
}
long long work(int k, int l, int r, long long x) {
if (l == r) return P[k].num + x;
int mid = l + r >> 1;
pushdn(k);
if (x >= P[k << 1].mx)
return min(P[k << 1].num + x,
work(k << 1 | 1, mid + 1, r, max(x, P[k << 1].mx)));
else
return min(work(k << 1, l, mid, x), P[k].val);
}
void maintain(int k, int l, int r) {
node &o = P[k], &u = P[k << 1], &v = P[k << 1 | 1];
o.mx = max(u.mx, v.mx);
o.mn = min(u.mn, v.mn);
o.num = min(u.num, v.num);
int mid = l + r >> 1;
o.val = work(k << 1 | 1, mid + 1, r, u.mx);
}
void ins(int k, int l, int r, int x, long long y) {
if (x <= l) {
mdy(k, y);
return;
}
int mid = l + r >> 1;
pushdn(k);
if (x <= mid) ins(k << 1, l, mid, x, y);
ins(k << 1 | 1, mid + 1, r, x, y);
maintain(k, l, r);
}
long long getmax(int k, int l, int r, int x) {
if (x > r) return -1000000000000000000ll;
if (x <= l) return P[k].mx;
int mid = l + r >> 1;
pushdn(k);
return (x > mid) ? getmax(k << 1 | 1, mid + 1, r, x)
: max(getmax(k << 1, l, mid, x), P[k << 1 | 1].mx);
}
void qry(int k, int l, int r, int x, int y, long long z) {
if (x <= l && r <= y)
if (work(k, l, r, z) > m) return;
if (l == r) {
tmp = max(tmp, l);
return;
}
int mid = l + r >> 1;
pushdn(k);
if (y > mid)
qry(k << 1 | 1, mid + 1, r, x, y, max(z, getmax(k << 1, l, mid, x)));
if (x <= mid && mid >= tmp) qry(k << 1, l, mid, x, y, z);
}
int getrg(int k, int l, int r) {
if (l == r) return (P[k].mn <= m) ? l : 0;
int mid = l + r >> 1;
pushdn(k);
return (P[k << 1 | 1].mn <= m) ? getrg(k << 1 | 1, mid + 1, r)
: getrg(k << 1, l, mid);
}
void build(int k, int l, int r) {
if (l == r) {
P[k].num = s2[l];
P[k].mx = -s2[l];
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
maintain(k, l, r);
}
int main() {
scanf("%d%d", &n, &m);
int i, j, k;
for (i = 1; i < n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
for (i = 1; i <= n; i++) {
s1[i] = s1[i - 1] + a[i - 1] - b[i - 1];
s2[i] = s2[i - 1] + a[i - 1] - b[i];
}
build(1, 1, n);
for (i = n, j = 0; i; i--) {
for (; j && s1[i] >= s1[q[j]]; j--)
if (j > 1) ins(1, 1, n, q[j - 1] - 1, s1[q[j]] - s1[q[j - 1]]);
if (j) ins(1, 1, n, q[j] - 1, s1[q[j]] - s1[i]);
q[++j] = i;
if (i < n) {
k = min(getrg(1, 1, n) + 1, n);
if (i <= k) {
tmp = 0;
qry(1, 1, n, i, k, -1000000000000000000ll);
ans = max(ans, tmp - i + 1);
}
}
}
printf("%d\n", ans);
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long pp(long long x, long long y) { return x * y / gcd(x, y); }
int main() {
long long n, a, b, p, q;
long long ans = 0;
cin >> n >> a >> b >> p >> q;
long long a0 = n / a, b0 = n / b;
ans += a0 * p;
ans += b0 * q;
long long ab = pp(a, b);
long long ab0 = n / ab;
ans -= ab0 * min(p, q);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 3e5 + 5;
int Head[MX], erear;
struct Edge {
int u, v, nxt, z;
} E[MX << 1];
void edge_init() {
erear = 0;
memset(Head, -1, sizeof(Head));
}
void edge_add(int u, int v, int z) {
E[erear].u = u;
E[erear].v = v;
E[erear].z = z;
E[erear].nxt = Head[u];
Head[u] = erear++;
}
int n, m;
int DFN[MX], Low[MX], dsz;
int Stack[MX], inStack[MX], Belong[MX], bsz, ssz;
int A[MX];
void trajan(int u, int e) {
inStack[u] = 1;
Stack[++ssz] = u;
DFN[u] = Low[u] = ++dsz;
for (int i = Head[u]; ~i; i = E[i].nxt) {
int v = E[i].v;
if ((i ^ 1) == e) continue;
if (!DFN[v]) {
trajan(v, i);
Low[u] = min(Low[u], Low[v]);
} else if (inStack[v]) {
Low[u] = min(Low[u], Low[v]);
}
}
if (DFN[u] == Low[u]) {
bsz++;
int v;
do {
v = Stack[ssz--];
inStack[v] = 0;
Belong[v] = bsz;
} while (ssz && v != u);
}
}
void tarjan_solve(int n) {
dsz = bsz = ssz = 0;
memset(DFN, 0, sizeof(DFN));
for (int i = 1; i <= n; i++) {
if (!DFN[i]) trajan(i, -1);
}
}
bool DFS(int st, int ed, int f, int s) {
s |= A[st];
if (st == ed) return s;
for (int i = Head[st]; ~i; i = E[i].nxt) {
int v = E[i].v;
if (v == f) continue;
if (DFS(v, ed, st, s | E[i].z)) return true;
}
return false;
}
int main() {
edge_init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v, z;
scanf("%d%d%d", &u, &v, &z);
edge_add(u, v, z);
edge_add(v, u, z);
}
tarjan_solve(n);
int etot = erear;
edge_init();
for (int i = 0; i < etot; i++) {
int u = Belong[E[i].u], v = Belong[E[i].v];
if (u == v)
A[u] |= E[i].z;
else
edge_add(u, v, E[i].z);
}
int st, ed;
scanf("%d%d", &st, &ed);
if (DFS(Belong[st], Belong[ed], -1, 0)) {
printf("YES\n");
} else
printf("NO\n");
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
const long long mod = 1000000007LL;
const long long inv = 500000004LL;
long long mult(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long sub(long long a, long long b) {
return (mod * 2LL + (a % mod) - (b % mod)) % mod;
}
long long add(long long a, long long b) {
return ((a % mod) + (b % mod)) % mod;
}
int main() {
ios_base::sync_with_stdio(0);
long long a, b;
cin >> a >> b;
long long ans = 0;
long long as = a * (a + 1) / 2LL;
long long all = mult(as, b);
all = add(a, all);
for (long long c = 1; c < b; c++) {
long long tp = mult(c, all);
ans = add(ans, tp);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, t, m, k, l, sum, v1, r, q, f, x, kol, y, p, z;
string s;
cin >> p;
cin >> s;
char a, b;
k = 0;
for (j = 25; j > 0; j--) {
for (i = p - 1; i > -1; i--) {
if (s[i] == 97 + j) {
a = s[i];
b = s[i - 1];
if (a == b + 1) {
s.erase(s.begin() + i);
k = k + 1;
p = p - 1;
if (i != p) {
i++;
}
} else {
if (i != p - 1) {
b = s[i + 1];
if (a == b + 1) {
s.erase(s.begin() + i);
k = k + 1;
p = p - 1;
if (i != p) {
i++;
}
}
}
}
}
}
}
cout << k << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool vowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') return 1;
return 0;
}
int main() {
string s;
cin >> s;
for (int i = 1; i < s.length(); i++) {
if (!vowel(s[i]) && !vowel(s[i - 1]) && s[i - 1] != 'n') {
cout << "NO";
return 0;
}
}
if (!vowel(s[s.length() - 1]) && s[s.length() - 1] != 'n') {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
char a[100];
cin >> s;
int x = 0;
for (int i = 0; i < s.length(); i++) {
if (!((tolower(s.at(i)) == 'a') || (tolower(s.at(i)) == 'e') ||
(tolower(s.at(i)) == 'u') || (tolower(s.at(i)) == 'i') ||
(tolower(s.at(i)) == 'o') || (tolower(s.at(i)) == 'y'))) {
a[x] = s[i];
x++;
}
}
for (int i = 0; i < x; i++) {
cout << '.' << char(tolower(a[i]));
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int height, width;
cin >> height >> width;
int i;
char* row = (char*)malloc(width);
int answer = 0;
for (i = 0; i < height; i++) {
cin >> row;
if (i == height - 1) {
int j;
int last = 0;
for (j = 0; j < width; j++) {
if (row[j] == 'B' && last == 0) {
answer++;
last = 1;
} else if (row[j] != 'B' && last == 1) {
last = 0;
}
}
}
}
cout << answer << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, b, a;
cin >> n;
a = n / 3;
if (n == 3) {
cout << a << " " << a << " " << a;
} else {
b = n - 3;
if (b % 3 != 0) {
cout << 1 << " " << 2 << " " << b;
} else {
cout << 2 << " " << 2 << " " << b - 1;
}
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.