solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct BitTree {
int t[N];
void init() { memset(t, 0, sizeof t); }
void add(int p, int x) {
for (; p < N; p += p & -p) t[p] += x;
}
int sum(int p) {
int res = 0;
for (; p; p -= p & -p) res += t[p];
return res;
}
} b[4][11][10];
char s[N];
int mp[500];
int n;
void deal() {
for (int i = 0; i < (4); i++)
for (int j = 1; j <= (10); j++)
for (int k = 0; k < (j); k++) b[i][j][k].init();
for (int i = 1; i <= (n); i++) {
int x = mp[s[i]];
for (int j = 1; j <= (10); j++) {
b[x][j][i % j].add(i, 1);
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
mp['A'] = 0, mp['T'] = 1, mp['G'] = 2, mp['C'] = 3;
int q, typ, pos;
char ch;
string str;
cin >> (s + 1);
n = strlen(s + 1);
deal();
cin >> q;
while (q--) {
cin >> typ;
if (typ == 1) {
cin >> pos >> ch;
char y = s[pos];
int x = mp[y];
s[pos] = ch;
for (int j = 1; j <= (10); j++) {
b[x][j][pos % j].add(pos, -1);
}
x = mp[ch];
for (int j = 1; j <= (10); j++) {
b[x][j][pos % j].add(pos, 1);
}
} else {
int l, r;
cin >> l >> r >> str;
int len = str.length();
int ans = 0;
for (int i = 0; i < (len); i++) {
int x = mp[str[i]];
ans += b[x][len][(i + l) % len].sum(r) -
b[x][len][(i + l) % len].sum(l - 1);
}
cout << ans << endl;
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
bool node[1000000];
long long n, m;
cin >> n >> m;
for (long long i = (long long)1; i < (long long)m + 1; i++) {
long long x, y;
cin >> x >> y;
node[x] = node[y] = true;
}
long long center;
for (long long i = (long long)1; i < (long long)n + 1; i++) {
if (node[i] == false) {
center = i;
break;
}
}
cout << n - 1 << "\n";
for (long long i = (long long)1; i < (long long)n + 1; i++) {
if (i == center) continue;
cout << center << " " << i << "\n";
}
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long int maxn = 5e5 + 1;
void solve() {
long long int n;
cin >> n;
long long int a[n], len[11];
memset(len, 0, sizeof(len));
for (long long int i = 0; i < n; i++) {
cin >> a[i];
long long int d = a[i];
long long int k = 0;
while (d) {
d /= 10;
k++;
}
len[k]++;
}
long long int power[30];
power[0] = 1;
for (long long int i = 1; i < 30; i++) {
power[i] = power[i - 1] * 10;
power[i] %= (long long int)(998244353);
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
long long int d = a[i];
long long int k = 0;
vector<long long int> v;
while (d) {
long long int r = d % 10;
d /= 10;
k++;
for (long long int l = 1; l <= 10; l++) {
if (l >= k) {
long long int aa = power[2 * k - 1];
aa *= r;
aa %= (long long int)(998244353);
aa *= len[l];
aa %= (long long int)(998244353);
ans += aa;
ans %= (long long int)(998244353);
} else {
long long int aa = power[l + k - 1];
aa *= len[l];
aa %= (long long int)(998244353);
aa *= r;
aa %= (long long int)(998244353);
ans += aa;
ans %= (long long int)(998244353);
}
if (l >= k - 1) {
long long int aa = power[2 * (k - 1)];
aa *= len[l];
aa %= (long long int)(998244353);
aa *= r;
aa %= (long long int)(998244353);
ans += aa;
ans %= (long long int)(998244353);
} else {
long long int aa = power[l + k - 1];
aa *= len[l];
aa %= (long long int)(998244353);
aa *= r;
aa %= (long long int)(998244353);
ans += aa;
ans %= (long long int)(998244353);
}
}
}
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
for (long long int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 10;
int ft[maxN];
int L[maxN], R[maxN];
int n, m;
int cnt[maxN];
void upd(int pos, int v) {
pos += 1;
while (pos < maxN) {
ft[pos] = max(ft[pos], v);
pos += pos & -pos;
}
}
int qry(int pos) {
pos += 1;
int ans = 0;
while (pos > 0) {
ans = max(ans, ft[pos]);
pos -= pos & -pos;
}
return ans;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
int l, r;
scanf("%d %d", &l, &r);
cnt[l] += 1;
cnt[r + 1] -= 1;
}
for (int i = 1; i <= m; ++i) {
cnt[i] += cnt[i - 1];
}
for (int i = 1; i <= n; ++i) ft[i] = -1e9;
for (int i = 1; i <= m; ++i) {
L[i] = 1 + qry(cnt[i]);
upd(cnt[i], L[i]);
}
for (int i = 1; i <= n; ++i) ft[i] = -1e9;
for (int i = m; i >= 1; --i) {
R[i] = 1 + qry(cnt[i]);
upd(cnt[i], R[i]);
}
for (int i = 1; i <= m; ++i) L[i] = max(L[i], L[i - 1]);
for (int i = m; i >= 1; --i) R[i] = max(R[i], R[i + 1]);
int ans = 0;
for (int i = 0; i <= m; ++i) {
ans = max(ans, L[i] + R[i + 1]);
}
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
int debugnum = 0;
using namespace std;
const int MAXN = 1e6 + 50;
vector<int> arc[MAXN];
int DFS(int K, int pos, int &depth, int &score1, int &score2) {
if (arc[pos].size() == 0) {
depth = score1 = score2 = 1;
return 0;
}
depth = INT_MAX >> 1;
score1 = 0;
score2 = 0;
for (int i = (0); i < (arc[pos].size()); i++) {
int e = arc[pos][i];
int dep, s1, s2;
DFS(K, e, dep, s1, s2);
if (dep <= K) {
depth = min(depth, dep);
score1 += s1;
score2 = max(score2, s2 - s1);
} else
score2 = max(score2, s2);
}
depth++;
score2 += score1;
return 0;
}
int main() {
int N, M, K;
while (cin >> N >> K) {
for (int i = (0); i < (N + 5); i++) arc[i].clear();
for (int b = (2); b < (N + 1); b++) {
int a;
scanf("%d", &a);
arc[a].push_back(b);
}
int depth, score1, score2;
DFS(K, 1, depth, score1, score2);
cout << score2 << endl;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj;
vector<int> vis;
int dfs(int x) {
int y = adj[x];
vis[adj[x]]++;
if (vis[y] == 2) return y + 1;
dfs(y);
}
int main() {
int t = 1;
int n, a, b, c = 0, l;
string s;
cin >> n;
adj.resize(n);
vis.resize(n);
for (int i = 0; i < n; i++) {
cin >> a;
a--;
adj[i] = a;
}
for (int i = 0; i < n; i++) {
vis.assign(n, 0);
vis[i] = 1;
cout << dfs(i) << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void pre() {}
void solve() {}
int cnt[200009][26];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
pre();
string s;
cin >> s;
for (int i = 0; i < ((int)(s).size()); ++i) cnt[i + 1][s[i] - 'a']++;
for (int i = 1; i <= ((int)(s).size()); ++i)
for (int j = 0; j < (26); ++j) cnt[i][j] += cnt[i - 1][j];
int q;
cin >> q;
for (int i = 0; i < (q); ++i) {
int l, r;
cin >> l >> r;
int x = 0;
for (int j = 0; j < (26); ++j)
if (cnt[r][j] - cnt[l - 1][j] > 0) x++;
if (x > 2 || s[l - 1] != s[r - 1] || l == r)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int MAXN = 3e5 + 10;
typedef struct node {
int u;
int v;
int nxt;
int mode;
char ans;
bool ex;
bool fina;
} node;
node edge[MAXN * 2];
int head[MAXN], cnt;
void addedge(int a, int b, int c, int flag) {
edge[cnt].u = a;
edge[cnt].v = b;
edge[cnt].mode = c;
edge[cnt].fina = false;
if (c == 2 && flag == 1)
edge[cnt].ans = '+';
else if (c == 2 && flag == 2)
edge[cnt].ans = '-';
else
edge[cnt].ans = '0';
if (c == 1 && flag == 2)
edge[cnt].ex = false;
else
edge[cnt].ex = true;
edge[cnt].nxt = head[a];
head[a] = cnt++;
}
int vis[MAXN];
int dfs1(int s) {
int ans = 0;
vis[s] = 1;
for (int i = head[s]; i != -1; i = edge[i].nxt) {
node tmp = edge[i];
if (!tmp.ex) continue;
if (vis[tmp.v]) continue;
if (edge[i].fina) continue;
if (tmp.mode == 1) {
ans++;
ans += dfs1(tmp.v);
} else {
edge[i].fina = true;
ans++;
ans += dfs1(tmp.v);
}
}
return ans;
}
int dfs2(int s) {
int ans = 0;
vis[s] = 1;
for (int i = head[s]; i != -1; i = edge[i].nxt) {
node tmp = edge[i];
if (!tmp.ex) continue;
if (vis[tmp.v]) continue;
if (edge[i].fina) continue;
if (tmp.mode == 1) {
ans++;
ans += dfs2(tmp.v);
} else {
edge[i ^ 1].fina = true;
}
}
return ans;
}
int main() {
int n, m, s;
scanf("%d%d%d", &n, &m, &s);
memset(vis, 0, sizeof(vis));
memset(head, -1, sizeof(head));
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
addedge(b, c, a, 1);
addedge(c, b, a, 2);
}
int ans = 1;
ans += dfs1(s);
printf("%d\n", ans);
for (int i = 0; i < cnt; i += 2) {
if (edge[i].mode == 2) {
if (edge[i].fina) {
printf("%c", edge[i].ans);
} else if (edge[i ^ 1].fina) {
printf("%c", edge[i ^ 1].ans);
} else {
printf("+");
}
edge[i].fina = false;
edge[i ^ 1].fina = false;
}
}
printf("\n");
memset(vis, 0, sizeof(vis));
ans = 1;
ans += dfs2(s);
printf("%d\n", ans);
for (int i = 0; i < cnt; i += 2) {
if (edge[i].mode == 2) {
if (edge[i].fina) {
printf("%c", edge[i].ans);
} else if (edge[i ^ 1].fina) {
printf("%c", edge[i ^ 1].ans);
} else {
printf("+");
}
edge[i].fina = false;
edge[i ^ 1].fina = false;
}
}
printf("\n");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, t;
long long a[110000], h[110000];
struct edge {
long long y, nxt, w;
} e[110000];
void add(long long i) {
t++;
e[t].y = i;
e[t].nxt = h[x];
e[t].w = y;
h[x] = t;
}
void dfs(long long k, long long x, long long s) {
for (long long i = h[k]; i; i = e[i].nxt) dfs(e[i].y, k, e[i].w);
if (a[k] >= 0)
a[x] += a[k];
else {
double y = double(s) * double(a[k]);
if (!x || y < -23333333333333333) {
puts("NO");
exit(0);
}
a[x] += s * a[k];
if (a[x] < -23333333333333333) {
puts("NO");
exit(0);
}
}
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long i = 1; i <= n; i++) scanf("%lld", &x), a[i] -= x;
for (long long i = 2; i <= n; i++) scanf("%lld%lld", &x, &y), add(i);
dfs(1, 0, 0);
puts("YES");
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e4 + 15;
const int inf = 1e9;
struct Edge {
int v, cap, rev;
Edge() {}
Edge(int v, int cap, int rev) : v(v), cap(cap), rev(rev) {}
};
vector<Edge> vt[N];
void addEdge(int s, int e, int c) {
vt[s].push_back(Edge(e, c, (int)vt[e].size()));
vt[e].push_back(Edge(s, 0, (int)vt[s].size() - 1));
assert(vt[s].back().v == e);
assert(vt[e].back().v == s);
}
int level[N];
int work[N];
int source, sink;
bool bfs() {
memset(level, -1, sizeof(level));
queue<int> q;
q.push(source);
level[source] = 0;
int here, there, i;
Edge x;
while (!q.empty()) {
here = q.front();
q.pop();
for (i = 0; i < vt[here].size(); ++i) {
x = vt[here][i];
there = x.v;
int cap = x.cap;
if (level[there] == -1 && cap > 0) {
level[there] = level[here] + 1;
q.push(there);
}
}
}
return level[sink] != -1;
}
int dfs(int here, int mcap) {
if (here == sink) return mcap;
for (int &i = work[here]; i < vt[here].size(); ++i) {
Edge x = vt[here][i];
int there = x.v;
int cap = x.cap;
if (level[there] == level[here] + 1 && cap > 0) {
int flow = dfs(there, min(mcap, cap));
if (flow > 0) {
vt[here][i].cap -= flow;
vt[there][x.rev].cap += flow;
return flow;
}
}
}
return 0;
}
int maxFlow() {
int ret = 0;
while (bfs()) {
memset(work, 0, sizeof(work));
while (1) {
int flow = dfs(source, inf);
if (!flow) break;
ret += flow;
}
}
return ret;
}
vector<int> adj[N];
int a[N], b[N], c[N], par[N];
vector<vector<int> > colorList;
int depth[N];
void dfs2(int node, int p) {
for (int i = 0; i < adj[node].size(); ++i) {
int id = adj[node][i];
int ch = a[id] ^ b[id] ^ node;
if (ch == p) {
continue;
}
if (depth[ch] == 0) {
depth[ch] = depth[node] + 1;
par[ch] = id;
dfs2(ch, node);
} else if (depth[ch] < depth[node]) {
colorList.push_back(vector<int>());
colorList.back().push_back(id);
int u = node;
while (u != ch) {
int gid = par[u];
par[u] = -1;
colorList.back().push_back(gid);
u ^= a[gid] ^ b[gid];
}
}
}
}
int cc[N];
vector<int> graph[N];
int maxMatching(int n, int m) {
int ret = 0;
return ret;
}
void solve() {
memset(par, -1, sizeof(par));
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d %d %d", &a[i], &b[i], &c[i]);
adj[a[i]].push_back(i);
adj[b[i]].push_back(i);
}
depth[1] = 12;
dfs2(1, 0);
for (int i = 1; i <= n; ++i) {
if (par[i] != -1) {
++cc[c[par[i]]];
}
}
sink = n + m + 1;
int ret = 0;
for (int i = 1; i <= m; ++i) {
if (cc[i] == 0) {
addEdge(i + n, sink, 1);
} else {
++ret;
}
}
source = 0;
for (int i = 0; i < colorList.size(); ++i) {
int id = i + 1, rem = colorList[i].size();
addEdge(source, id, rem - 1);
for (int j = 0; j < colorList[i].size(); ++j) {
int color = c[colorList[i][j]];
if (cc[color] == 0) {
addEdge(id, color + n, 1);
}
}
}
ret += maxFlow();
printf("%d\n", ret);
}
int main() { solve(); }
| 16 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -f;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) { write(x), putchar('\n'); }
long long add(long long x, long long y) { return min(x + y, (long long)1e18); }
long long A1[255][2], A2[255][255], A3[255][255], n, k, m, z, p[255];
void build(const string& s) {
z = (int)(s.size()), p[0] = 0;
for (int i = 1; i < z; i++) {
int j = p[i - 1];
while (j > 0 && s[j] != s[i]) j = p[j - 1];
if (s[j] == s[i]) j++;
p[i] = j;
}
for (int i = 0; i <= z; i++)
for (int j = 0; j < 2; j++)
if (i < z && s[i] == char('0' + j))
A1[i][j] = i + 1;
else if (i == 0)
A1[i][j] = 0;
else
A1[i][j] = A1[p[i - 1]][j];
for (int i = 0; i <= z; i++)
for (int j = 0; j < 2; j++)
A3[i][j] = A1[i][j], A2[i][j] = (A3[i][j] == z ? 1 : 0);
for (int i = 2; i <= n; i++)
for (int j = 0; j <= z; j++) {
A3[j][i] = A3[A3[j][i - 2]][i - 1];
A2[j][i] = add(A2[j][i - 2], A2[A3[j][i - 2]][i - 1]);
}
}
string cur;
int main() {
n = read(), k = read(), m = read();
for (int i = 0; i < m; i++) {
if (cur != "") build(cur);
long long x = 0;
if (cur != "" && A3[0][n] == i) x = 1;
if (k == 1 && x == 1) break;
k -= x, build(cur + '0');
long long x1 = A2[0][n];
if (k > x1)
cur += '1', k -= x1;
else
cur += '0';
}
cout << cur << endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long base, long long exp) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base);
base = (base * base);
exp /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long n = s.length();
long long n1 = n;
long long cnt = 0;
for (long long i = 0; i < n1; i++) {
if (s[i] == '1') {
cnt++;
}
}
if (cnt <= 1) {
n--;
}
if (n % 2 == 0) {
cout << n / 2 << "\n";
} else {
cout << n / 2 + 1 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 2e9;
const int MAX_LOG = 21;
const int MAX_N = 12800;
string rep(string &s, int k, int n) {
string news;
int len = s.length();
while (news.length() < n - len) {
news.append(s);
}
for (char ch : s) {
news.insert(news.end(), 1, ch);
if (news.length() >= n) {
break;
}
}
return news;
}
string add1(string &s) {
string ans;
vector<int> digits;
for (int i = 0; i < s.length(); i++) {
digits.push_back(int(s[i] - '0'));
}
vector<int> newans;
int carry = 1;
for (int i = digits.size() - 1; i >= 0; i--) {
int x = carry + digits[i];
newans.push_back(x % 10);
carry = x / 10;
}
reverse(newans.begin(), newans.end());
for (int x : newans) {
ans.insert(ans.end(), 1, char(x + '0'));
}
return ans;
}
vector<int> find_divisors(int n) {
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
ans.push_back(i);
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> divs = find_divisors(k);
string ans;
int found = 0;
for (int div : divs) {
string news = s.substr(0, div);
string x = rep(news, k, n);
news = add1(news);
string y = rep(news, k, n);
if (x >= s) {
ans = (found ? min(x, ans) : x);
found = 1;
}
if (y >= s) {
ans = (found ? min(y, ans) : y);
found = 1;
}
}
cout << ans.length() << endl << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int color[105];
int num[105];
int bit(int i) { return 1 << i; }
int bitCount(int x) { return x == 0 ? 0 : bitCount(x / 2) + (x & 1); }
int judge(int x) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (color[i] == color[j]) {
if (num[i] != num[j] && (x & bit(num[i] + 5)) == 0 &&
(x & bit(num[j] + 5)) == 0)
return 0;
} else {
if ((x & bit(color[i])) || (x & bit(color[j]))) continue;
if (num[i] != num[j] &&
((x & bit(num[i] + 5)) || (x & bit(num[j] + 5))))
continue;
return 0;
}
}
}
return 1;
}
int main() {
while (cin >> n) {
string s;
for (int i = 1; i <= n; i++) {
cin >> s;
if (s[0] == 'R') color[i] = 0;
if (s[0] == 'G') color[i] = 1;
if (s[0] == 'B') color[i] = 2;
if (s[0] == 'Y') color[i] = 3;
if (s[0] == 'W') color[i] = 4;
num[i] = s[1] - '1';
}
int ans = 10;
for (int i = 0; i < bit(10); i++) {
if (judge(i)) ans = min(ans, bitCount(i));
}
cout << ans << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch - '0');
ch = getchar();
}
return f == 1 ? x : -x;
}
inline void print(int a[], int n, int offset = 0) {
for (int i = 0; i < n; i++) printf("%d ", a[i + offset]);
printf("\n");
}
inline void print(long long a[], int n, int offset = 0) {
for (int i = 0; i < n; i++) printf("%lld ", a[i + offset]);
printf("\n");
}
const int maxn = 1e4 + 10;
const int maxm = 1e4 + 10;
const int maxk = 100 + 10;
const long long inf = 1e16;
int n, m, k, s1, s2, f, tot = 0;
struct Edge {
int v, w, nxt;
} e[maxm + maxk];
int head[maxn], spe[maxk][3];
long long dis1[maxn], dis2[maxn];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
inline void addedge(int u, int v, int w) {
e[++tot].v = v;
e[tot].w = w;
e[tot].nxt = head[u];
head[u] = tot;
}
inline void init() {
n = read();
m = read();
k = read();
s1 = read();
s2 = read();
f = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read(), w = read();
addedge(u, v, w);
}
for (int i = 1; i <= k; i++) {
int u = read(), v = read(), l = read(), r = read();
addedge(u, v, r);
spe[i][0] = u;
spe[i][1] = l;
spe[i][2] = r;
}
}
inline void dijkstra(long long dis[]) {
while (!pq.empty()) {
long long d = pq.top().first;
int u = pq.top().second;
pq.pop();
if (d > dis[u]) continue;
for (int i = head[u]; i; i = e[i].nxt) {
if (dis[e[i].v] > d + e[i].w) {
dis[e[i].v] = d + e[i].w;
pq.push(pair<long long, int>(dis[e[i].v], e[i].v));
}
}
}
}
inline void print_sol() {
for (int i = 1; i <= k; i++) printf("%d ", e[m + i].w);
printf("\n");
}
inline void doit() {
for (int i = 1; i <= n; i++) dis1[i] = dis2[i] = inf;
dis1[s1] = 0;
pq.push(pair<long long, int>(0, s1));
dijkstra(dis1);
dis2[s2] = 0;
pq.push(pair<long long, int>(0, s2));
dijkstra(dis2);
while (1) {
bool flag = true;
for (int i = 1; i <= k; i++) {
int u = spe[i][0];
if (dis1[u] < dis2[u] && e[m + i].w ^ spe[i][1]) {
e[m + i].w = spe[i][1];
flag = false;
pq.push(pair<long long, int>(dis1[u], u));
dijkstra(dis1);
pq.push(pair<long long, int>(dis2[u], u));
dijkstra(dis2);
}
}
if (flag) break;
}
if (dis1[f] < dis2[f]) {
printf("WIN\n");
print_sol();
return;
}
while (1) {
bool flag = true;
for (int i = 1; i <= k; i++) {
int u = spe[i][0];
if (dis1[u] <= dis2[u] && e[m + i].w ^ spe[i][1]) {
e[m + i].w = spe[i][1];
flag = false;
pq.push(pair<long long, int>(dis1[u], u));
dijkstra(dis1);
pq.push(pair<long long, int>(dis2[u], u));
dijkstra(dis2);
}
}
if (flag) break;
}
if (dis1[f] <= dis2[f]) {
printf("DRAW\n");
print_sol();
return;
}
printf("LOSE\n");
}
int main() {
init();
doit();
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int l = log2(m);
if (l < n)
cout << m;
else
cout << (m % (int)pow(2, n));
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
double pi = 3.1415926535898;
const long long M = 1e9 + 7;
const int N = 50500;
const int inf = INT_MAX;
const double eps = 1e-6;
map<string, int> mp1;
map<int, vector<string>> mp2;
set<string> st;
int point[300];
int main() {
string name, s, s1, s2, s3, s4;
point['p'] = 15;
point['c'] = 10;
point['l'] = 5;
int n;
cin >> name;
cin >> n;
for (int i = 0; i < int(n); i++) {
cin >> s1 >> s2;
if (s2[0] != 'l') cin >> s4;
cin >> s3;
s3.pop_back();
s3.pop_back();
cin >> s4;
if (s1 == name)
mp1[s3] += point[s2[0]];
else if (s3 == name)
mp1[s1] += point[s2[0]];
else {
st.insert(s1);
st.insert(s3);
}
}
for (auto x : mp1) {
mp2[-x.second].push_back(x.first);
}
for (auto x : mp2) {
for (auto y : x.second) {
cout << y << endl;
st.erase(y);
}
}
for (auto x : st) {
cout << x << endl;
}
return 0;
;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, b[255][255], c[255][255], m, dp[255], F[255][2];
char a[4 * 255][4 * 255];
void up(int &F, int x) { F = (F + x) % 1000000007; }
int main() {
scanf("%d%d\n", &n, &m);
for (int i = 1; i <= 4 * n + 1; i++) {
for (int j = 1; j <= 4 * m + 1; j++) scanf("%c", &a[i][j]);
scanf("\n");
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
b[i][j] = 0;
int u = 4 * i - 2, v = 4 * j - 2;
for (int ii = u; ii <= u + 2; ii++)
for (int jj = v; jj <= v + 2; jj++) b[i][j] += (a[ii][jj] == 'O');
if (b[i][j] == 2 || b[i][j] == 3) {
if (a[u][v] == 'O')
c[i][j] = 1;
else
c[i][j] = 2;
}
if (b[i][j] == 6) {
if (a[u][v + 1] == 'O')
c[i][j] = 1;
else
c[i][j] = 2;
}
}
dp[0] = 1;
for (int i = 0; i <= m - 1; i++)
if (dp[i]) {
int check = 0;
for (int j = 1; j <= n; j++)
if (c[j][i + 1] == 1) check = 1;
if (check == 0 && n % 2 == 0) up(dp[i + 1], dp[i]);
if (i == m - 1) continue;
for (int j = 0; j <= n; j++)
for (int t = 0; t <= 1; t++) F[j][t] = 0;
F[0][0] = 1;
for (int j = 0; j <= n - 1; j++)
for (int t = 0; t <= 1; t++)
if (F[j][t]) {
if (c[j + 1][i + 1] != 2 && c[j + 1][i + 2] != 2) {
up(F[j + 1][1], F[j][t]);
}
if (j < n - 1 && c[j + 1][i + 1] != 1 && c[j + 1][i + 2] != 1 &&
c[j + 2][i + 1] != 1 && c[j + 2][i + 2] != 1) {
up(F[j + 2][t], F[j][t]);
}
}
up(dp[i + 2], ((long long)dp[i] * F[n][1]) % 1000000007);
}
cout << dp[m];
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 201000;
int b[MAX_N], x[MAX_N], a[MAX_N];
int main(void) {
int n, i;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
for (i = 1; i <= n; i++) {
x[i] = max(x[i - 1], a[i - 1]);
a[i] = b[i] + x[i];
}
for (i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long y, k, n;
cin >> y >> k >> n;
bool done = false;
for (int i = k; i <= n; i += k) {
if (y < i) {
done = true;
cout << i - y << " ";
}
}
if (done == false) cout << "-1" << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
if (n == 1 || n == 2) {
printf("-1\n");
} else {
for (int i = n; i >= 1; i--) {
printf("%d ", i);
}
printf("\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5143;
const long long Linf = 1e18 + 5413;
const double eps = 1e-10;
const double pi = acos(-1);
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T lcm(T a, T b) {
return a / __gcd(a, b) * b;
}
inline int read() {
int res = 0LL;
int neg;
while (1) {
char ch = getchar();
if (ch >= '0' && ch <= '9' || ch == '-') {
if (ch == '-')
neg = -1;
else
neg = 1, res = ch - '0';
break;
}
}
while (1) {
char ch = getchar();
if (ch >= '0' && ch <= '9')
res *= 10, res += ch - '0';
else
break;
}
return res * neg;
}
const int N = 171717;
const int LG = 20;
vector<int> G[N], g[N];
int s[N], t[N];
int id[N], low[N], st[N], ptr = 0, push = 0;
int scc[N], nn = 0;
void dfs(int node, int pre) {
id[node] = low[node] = ++ptr;
st[++push] = node;
for (__typeof(G[node].begin()) it = G[node].begin(); it != G[node].end();
it++) {
int u = *it;
if (u == pre) continue;
if (!id[u]) {
dfs(u, node);
umin(low[node], low[u]);
} else {
umin(low[node], id[u]);
}
}
if (low[node] == id[node]) {
++nn;
do {
scc[st[push]] = nn;
--push;
} while (st[push + 1] != node);
}
}
int anc[N][LG + 1], depth[N];
void rec(int node, int pre) {
anc[node][0] = pre;
depth[node] = depth[pre] + 1;
for (__typeof(g[node].begin()) it = g[node].begin(); it != g[node].end();
it++) {
int u = *it;
if (u != pre) {
rec(u, node);
}
}
}
int go_up(int u, int k) {
for (int(i) = (LG); (i) >= (0); (i)--)
if ((1LL << (i)) <= k) {
u = anc[u][i];
k -= (1LL << (i));
}
return u;
}
int LCA(int u, int v) {
if (depth[u] > depth[v]) u = go_up(u, depth[u] - depth[v]);
if (depth[v] > depth[u]) v = go_up(v, depth[v] - depth[u]);
if (u == v) return u;
for (int(i) = (LG); (i) >= (0); (i)--)
if (anc[u][i] != anc[v][i]) {
u = anc[u][i];
v = anc[v][i];
}
return anc[u][0];
}
int dist(int u, int v) { return depth[u] + depth[v] - 2 * depth[LCA(u, v)]; }
int main() {
int n = read();
int m = read();
for (int(i) = (1); (i) <= (m); (i)++) {
int u = read();
int v = read();
G[u].push_back(v);
G[v].push_back(u);
}
int k = read();
for (int(i) = (1); (i) <= (k); (i)++) {
s[i] = read();
t[i] = read();
}
dfs(1, 0);
for (int(i) = (1); (i) <= (n); (i)++) {
for (__typeof(G[i].begin()) it = G[i].begin(); it != G[i].end(); it++) {
int v = *it;
if (scc[i] != scc[v]) {
g[scc[i]].push_back(scc[v]);
}
}
}
for (int(i) = (1); (i) <= (n); (i)++) {
0;
}
rec(1, 0);
for (int(i) = (1); (i) <= (LG); (i)++) {
for (int(j) = (1); (j) <= (n); (j)++) anc[j][i] = anc[anc[j][i - 1]][i - 1];
}
for (int(i) = (1); (i) <= (k); (i)++) {
printf("%d\n", dist(scc[s[i]], scc[t[i]]));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class A, class B, class C>
struct Triple {
A first;
B second;
C third;
bool operator<(const Triple& t) const {
if (first != t.first) return first < t.first;
if (second != t.second) return second < t.second;
return third < t.third;
}
};
template <class T>
void ResizeVec(T&, vector<long long>) {}
template <class T>
void ResizeVec(vector<T>& vec, vector<long long> sz) {
vec.resize(sz[0]);
sz.erase(sz.begin());
if (sz.empty()) {
return;
}
for (T& v : vec) {
ResizeVec(v, sz);
}
}
template <class A, class B, class C>
ostream& operator<<(ostream& out, Triple<A, B, C> t) {
return out << "(" << t.first << ", " << t.second << ", " << t.third << ")";
}
template <class T>
ostream& operator<<(ostream& out, vector<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class T>
ostream& operator<<(ostream& out, set<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class L, class R>
ostream& operator<<(ostream& out, map<L, R> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
const long long N = 1e6 + 5;
long long rep[N];
long long Find(long long v) {
if (rep[v] == v) {
return rep[v];
}
return rep[v] = Find(rep[v]);
}
long long Union(long long a, long long b) {
a = Find(a);
b = Find(b);
if (a == b) {
return 0;
}
rep[b] = a;
return 1;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
if (0) cout << fixed << setprecision(10);
cin.tie(0);
long long n, m, q;
cin >> n >> m >> q;
for (long long i = (1); i <= (n + m); ++i) {
rep[i] = i;
}
long long ccs = n + m;
for (long long i = (1); i <= (q); ++i) {
long long r, c;
cin >> r >> c;
c += n;
ccs -= Union(r, c);
}
cout << ccs - 1 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * power(a * a % md, b / 2, md) % md
: power(a * a % md, b / 2, md) % md));
}
const int xn = 1e6 + 10;
const int xm = 1e1 + 16;
const int sq = 320;
const int inf = 1e9 + 10;
const long long INF = 1e18 + 10;
const int mod = 1e9 + 9, mod2 = 1e9 + 7;
const int base = 29;
int n, par[xn], dp[xn], mx[xn][2];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 2; i <= n + 1; ++i) {
cin >> par[i];
int v = i;
dp[v] = 1;
while (v != 1) {
if (dp[mx[par[v]][0]] < dp[v]) {
swap(mx[par[v]][0], mx[par[v]][1]);
mx[par[v]][0] = v;
} else if (v != mx[par[v]][0] && dp[mx[par[v]][1]] < dp[v])
mx[par[v]][1] = v;
v = par[v];
int mx1 = mx[v][0], mx2 = mx[v][1], flg = max(dp[mx1], dp[mx2] + 1);
if (dp[v] == flg) break;
dp[v] = flg;
}
cout << dp[mx[1][0]] << ' ';
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
char a[N][N];
int str[N], sto[N];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == '*') {
str[i]++;
sto[j]++;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (str[i] == 1 && sto[j] == 1) {
printf("%d %d\n", i, j);
return 0;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MOD = 1000000007;
int N, Q;
char c[MAXN];
int S[MAXN];
long long modpow(long long base, long long expo) {
base %= MOD;
long long res = 1;
while (expo > 0) {
if (expo & 1) res = res * base % MOD;
base = base * base % MOD;
expo >>= 1;
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N >> Q;
cin >> c + 1;
for (int i = (1); i <= (N); i++) S[i] = S[i - 1] + (c[i] == '1');
while (Q--) {
int L, R;
cin >> L >> R;
long long a = S[R] - S[L - 1];
long long b = (R - L + 1) - a;
cout << (modpow(2, a) - 1 + MOD) % MOD * modpow(2, b) % MOD << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
multiset<long long> a[maxn * 2], b[maxn * 2];
int main() {
int n, m, x;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> x, a[i + j].insert(x);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> x, b[i + j].insert(x);
for (int i = 1; i <= n + m; i++)
if (a[i] != b[i]) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int q, n;
long long num, x, a, y, b, k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> q;
while (q--) {
cin >> n;
vector<long long> tix(n);
for (long long& t : tix) cin >> t;
cin >> x >> a >> y >> b >> k;
if (x < y) {
swap(x, y);
swap(a, b);
}
vector<int> cA(n + 1), cB(n + 1), cAB(n + 1);
vector<long long> prefSum(n + 1);
for (int i = 1; i <= n; ++i) {
cA[i] = cA[i - 1];
cB[i] = cB[i - 1];
cAB[i] = cAB[i - 1];
if (i % a == 0 && i % b == 0)
cAB[i]++;
else if (i % a == 0)
cA[i]++;
else if (i % b == 0)
cB[i]++;
}
sort(tix.begin(), tix.end(), greater<long long>());
for (int i = 1; i <= n; ++i) prefSum[i] = prefSum[i - 1] + tix[i - 1];
int pos = -1;
for (int i = 1; i <= n && pos == -1; ++i) {
int ABs = cAB[i];
int As = cA[i];
int Bs = cB[i];
As += ABs;
Bs += As;
long long sco = prefSum[ABs] / 100 * (x + y) +
(prefSum[As] - prefSum[ABs]) / 100 * x +
(prefSum[Bs] - prefSum[As]) / 100 * y;
if (sco >= k) pos = i;
}
if (pos != -1)
cout << pos << endl;
else
cout << -1 << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
bool generated;
int n;
int a[N], nxt[N];
vector<int> v[N];
int query(int value, int i, int j) {
if (v[value].empty()) return -1;
int pos = lower_bound(v[value].begin(), v[value].end(), i) - v[value].begin();
if (pos >= v[value].size()) return -1;
if (v[value][pos] <= j) return v[value][pos];
return -1;
}
void process(int i, int j, int mx_nxt, int lo, int hi) {
if (!generated || i > j) return;
int position = query(mx_nxt, i, j);
if (position == -1) {
if (nxt[j] != -1) {
generated = false;
return;
}
a[j] = hi;
process(i, j - 1, j, lo, hi - 1);
} else {
a[position] = hi;
int sz = position - i;
process(i, position - 1, position, lo, lo + sz - 1);
process(position + 1, j, mx_nxt, lo + sz, hi - 1);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ntest;
cin >> ntest;
for (; ntest; ntest--) {
cin >> n;
generated = true;
for (int i = 1; i <= n; ++i) {
cin >> nxt[i];
if (nxt[i] != -1) v[nxt[i]].push_back(i);
}
process(1, n, n + 1, 1, n);
if (!generated)
cout << "-1\n";
else {
for (int i = 1; i <= n; ++i) cout << a[i] << ' ';
cout << '\n';
}
for (int i = 1; i <= n + 1; ++i) v[i].clear();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chkmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void chkmin(T &a, T b) {
if (a > b) a = b;
}
const int inf = 0x3f3f3f3f;
char s[5005];
vector<int> v[30];
int n, g[30], h[30], mx[30];
int main() {
scanf("%s", s);
int d;
int len = strlen(s);
for (int i = 0; i < len; i++) {
v[s[i] - 'a'].push_back(i);
}
for (int i = 0; i < 26; i++) {
for (int l = 0; l < len; l++) {
memset(h, 0, sizeof h);
d = 0;
for (int j = 0; j < v[i].size(); j++) {
int k = (v[i][j] + l) % len;
h[s[k] - 'a']++;
}
for (int i = 0; i < 26; i++)
if (h[i] == 1) d++;
mx[i] = max(mx[i], d);
}
}
double ans = 0;
for (int i = 0; i < 26; i++) {
ans += mx[i];
}
ans /= len;
printf("%.7lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int pr[100005], bt[100005], mbt[100005];
int process(vector<pair<int, int> > &b, int c) {
sort(b.begin(), b.end());
int n = b.size();
for (int i = 0; i < n; i++) {
pr[i] = b[i].first;
bt[i] = b[i].second;
if (i != 0)
mbt[i] = max(bt[i], mbt[i - 1]);
else
mbt[i] = bt[i];
}
int ans = 0;
for (int i = 1; i < n; i++) {
int ind = upper_bound(pr, pr + i, c - pr[i]) - pr;
ind--;
if (ind < 0) continue;
ans = max(ans, bt[i] + mbt[ind]);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(30);
int n, c, d;
cin >> n >> c >> d;
int b, p;
char ch;
vector<pair<int, int> > b1, b2;
int mxb1 = 0, mxb2 = 0;
for (int i = 1; i <= n; i++) {
cin >> b >> p >> ch;
if (ch == 'C' && p <= c) {
b1.push_back({p, b});
mxb1 = max(mxb1, b);
}
if (ch == 'D' && p <= d) {
b2.push_back({p, b});
mxb2 = max(mxb2, b);
}
}
if (b1.size() + b2.size() < 2) {
cout << 0 << endl;
exit(0);
}
int ans = 0;
if (!b1.empty() && !b2.empty()) ans = mxb1 + mxb2;
if (b1.size() > 1) ans = max(ans, process(b1, c));
if (b2.size() > 1) ans = max(ans, process(b2, d));
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, count = 1;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n - 1; i++) {
if (a[i] != a[i + 1]) {
count++;
}
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool check(string s) {
int N = (s).size();
sort((s).begin(), (s).end());
for (int i = 1; i < N; i++) {
if (s[i] == s[i - 1]) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int l, r, ans = -1;
cin >> l >> r;
for (int i = l; i <= r; i++) {
bool flag = check(to_string(i));
if (flag) {
ans = i;
break;
}
}
cout << ans << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
int A[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (c == '1') {
A[i][j] = 1;
} else {
A[i][j] = 0;
}
}
}
int B[n][m];
for (int i = 0; i < m; i++) {
B[0][i] = A[0][i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < m; j++) {
B[i][j] = B[i - 1][j] + A[i][j];
}
}
int flag = 0;
for (int i = 0; i < n; i++) {
int count = 0;
for (int j = 0; j < m; j++) {
if (B[n - 1][j] - A[i][j] > 0) {
count++;
}
}
if (count == m) {
flag = 1;
break;
}
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
static constexpr uint_fast8_t R = 26;
static uint_fast16_t n;
static uint_fast32_t e[R] = {1};
struct Command {
uint_fast8_t x;
uint_fast8_t y;
uint_fast8_t k;
uint_fast8_t z;
};
static vector<Command> m;
static vector<Command> p;
static void s(const uint_fast8_t f) {
if (e[f - 1] == n && m.size() < p.size()) {
p = m;
return;
}
for (uint_fast8_t zp1 = f; zp1 > 0; zp1--) {
const uint_fast8_t z = zp1 - 1;
const auto q = [f](const uint_fast8_t y, const uint_fast8_t k,
const uint_fast8_t z) {
const uint_fast32_t t = (y < R ? e[y] : 0) + k * e[z];
if (e[f - 1] < t && t <= n && m.size() + 1 <= p.size()) {
m.push_back({f, y, k, z});
e[f] = t;
s(f + 1);
m.pop_back();
}
};
for (uint_fast8_t k = 8; k >= 2; k >>= 1u) {
for (uint_fast8_t yp1 = f; yp1 > 0; yp1--) {
const uint_fast8_t y = yp1 - 1;
q(y, k, z);
}
q(R, k, z);
}
for (uint_fast8_t yp1 = z; yp1 > 0; yp1--) {
const uint_fast8_t y = yp1 - 1;
q(y, 1, z);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (uint_fast8_t i = 1; i < 8; i++) {
p.push_back({i, R, 2, static_cast<uint_fast8_t>(i - 1)});
}
{
uint_fast16_t n2 = n;
for (uint_fast8_t i = 0; i < 8; i++) {
const uint_fast8_t y = (n2 & 1u) ? i : R;
p.push_back({static_cast<uint_fast8_t>(8 + i + 1), y, 1,
static_cast<uint_fast8_t>(8 + i)});
n2 >>= 1u;
}
}
m.reserve(p.capacity());
s(1);
cout << p.size() << '\n';
for (const Command &c : p) {
cout << "lea e" << static_cast<char>('a' + c.x) << "x, [";
if (c.y < R) {
cout << "e" << static_cast<char>('a' + c.y) << "x + ";
}
cout << static_cast<uint_fast16_t>(c.k) << "*e"
<< static_cast<char>('a' + c.z) << "x";
cout << "]\n";
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 111111;
int f[NN];
struct Q {
int x, pos;
} q[NN * 10];
int main() {
int n, pos = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> f[i];
for (int i = 2; i <= n; i++)
if (f[i] < f[i - 1]) {
pos = i;
break;
}
if (pos == 0) {
cout << 0 << endl;
return 0;
}
int h = 0, t = 0;
int maxn = 0;
q[t++] = (Q){f[1], 1};
for (int i = pos; i <= n; i++) {
if (f[i] < q[t - 1].x) {
q[t++] = (Q){f[i], 1};
maxn = max(q[t - 1].pos, maxn);
} else if (f[i] > q[t - 1].x) {
int maxpos = 0;
while (f[i] > q[t - 1].x && t > 0) {
maxpos = max(maxpos, q[t - 1].pos);
t--;
}
if (t == 0)
q[t++] = (Q){f[i], 1};
else
q[t++] = (Q){f[i], maxpos + 1};
maxn = max(q[t - 1].pos, maxn);
}
}
cout << maxn << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i;
cin >> n >> k;
string a;
cin >> a;
if (k > (n / 2)) {
for (i = 0; i < n - k; i++) {
cout << "RIGHT" << endl;
}
for (i = n - 1; i >= 0; i--) {
cout << "PRINT " << a[i] << endl;
if (i == 0) {
break;
}
cout << "LEFT" << endl;
}
}
if (k <= (n / 2)) {
for (i = 0; i < k - 1; i++) {
cout << "LEFT" << endl;
}
for (i = 0; i <= n; i++) {
cout << "PRINT " << a[i] << endl;
if (i == (n - 1)) {
break;
}
cout << "RIGHT" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
const int mod = 1e9 + 7;
const ll inf = ll(1e18);
const double PI = acos(-1), eps = 1e-9;
const int mxa = 1e3;
const int mxn = 5e3, mxm = 2e5, mxk = 18;
int n, a[mxn];
int calc(int l, int r, int h) {
int ans = 0;
for (int i = l; i <= r; ++i) a[i] -= h;
for (int i = l; i <= r; ++i) {
if (a[i] == 0) continue;
int start = i;
while (i + 1 <= r && a[i + 1]) ++i;
int add = *min_element(a + start, a + i + 1);
ans += min(i - start + 1, add + calc(start, i, add));
}
return ans;
}
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
cout << calc(0, n - 1, 0) << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tt;
tt = 1;
while (tt-- > 0) solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, m;
int arr[N], b[N];
int ans = 1e7;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> arr[i];
arr[n] = 1e9;
sort(arr, arr + n);
int x = 0;
for (int i = 0; i < m; i++) {
int x1, x2, y;
cin >> x1 >> x2 >> y;
if (x1 > 1) continue;
b[x++] = x2;
}
sort(b, b + x);
int y = 0;
for (int i = 0; i <= n; i++) {
while (y < x && b[y] < arr[i]) y++;
ans = min(ans, i + x - y);
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 * 4;
inline int g() {
int x;
cin >> x;
return x;
}
inline long long gl() {
long long x;
cin >> x;
return x;
}
inline char gc() {
char x;
cin >> x;
return x;
}
inline string gs() {
string s;
cin >> s;
return s;
}
template <typename T>
inline vector<T> gv(int len) {
vector<T> a(len);
for (auto &it : a) cin >> it;
return a;
}
inline vector<int> gv(int len) {
vector<int> a(len);
for (auto &it : a) cin >> it;
return a;
}
inline vector<pair<int, int>> gv_andPairCnt(int len) {
vector<pair<int, int>> a(len);
int i = 1;
for (auto &it : a) {
it.second = i;
i++;
cin >> it.first;
}
return a;
}
double power_log(double power, double val) { return log(val) / log(power); }
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it : v) os << it << " ";
os << "\n";
return os;
}
template <typename T, typename H>
inline vector<pair<T, H>> gv_andBiPair(int len) {
vector<pair<T, H>> a(len);
for (auto &it : a) {
cin >> it.first >> it.second;
}
return a;
}
template <typename T>
inline set<T> vector_to_set(const vector<T> &vec) {
set<T> s;
for (auto &it : vec) s.insert(it);
return s;
}
const long long md = 1e9 + 7;
int main() {
int n = g(), k = g();
vector<pair<int, int>> v;
int ans = 0;
for (auto it : gv(n)) {
v.emplace_back(10 - (it % 10), it);
ans += it / 10;
}
sort(v.begin(), v.end());
int p = 0;
for (auto it : v) {
if (it.first > k) {
break;
}
ans++;
k -= it.first;
p += (100 - (it.first + it.second)) / 10;
}
cout << ans + min(p, k / 10);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2000 * 1000 * 1000;
template <typename T>
inline T sqr(T n) {
return n * n;
}
char s[10][10];
char name[6] = {'Q', 'R', 'B', 'N', 'P', 'K'};
char weight[6] = {9, 5, 3, 3, 1, 0};
int scoreWhite, scoreBlack;
int main() {
for (int i = 0; i < 8; i++) {
gets(s[i]);
}
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
for (int k = 0; k < 6; k++) {
if (toupper(s[i][j]) == name[k]) {
if (isupper(s[i][j])) {
scoreWhite += weight[k];
} else {
scoreBlack += weight[k];
}
break;
}
}
}
}
if (scoreWhite > scoreBlack) {
puts("White");
} else if (scoreWhite < scoreBlack) {
puts("Black");
} else {
puts("Draw");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int n, k, a[N], len[N];
map<int, int> freq[11];
int main(int argc, char **argv) {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
for (int b = a[i]; b != 0; b /= 10) ++len[i];
++freq[len[i]][a[i] % k];
}
long long res = 0;
for (int i = 0; i < n; ++i) {
int cur = a[i];
for (int j = 1; j <= 10; ++j) {
cur = (cur * 10LL) % k;
int mod = (k - cur) % k;
int to_add = freq[j][mod];
if (len[i] == j && a[i] % k == mod) --to_add;
res += to_add;
}
}
printf("%lld\n", res);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
struct iii {
int a, b, c;
bool operator>(iii other) const {
return tie(a, b, c) > tie(other.a, other.b, other.c);
}
};
int N, par[2 * MAXN];
int find(int n) { return par[n] = par[n] == n ? n : find(par[n]); }
bool merge(int a, int b) {
int x = find(a);
int y = find(b);
if (x == y) return false;
par[x] = y;
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) par[i] = i;
vector<pair<int, int>> arr;
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
arr.push_back({a, b});
}
sort(arr.begin(), arr.end());
set<pair<int, int>> out;
for (int i = 0; i < N; i++) {
auto ptr = out.lower_bound({arr[i].first, 0});
while (ptr != out.end() && ptr->first < arr[i].second) {
if (!merge(ptr->second, i)) {
cerr << ptr->second << " " << i << "\n";
cout << "NO\n";
return 0;
}
ptr++;
}
out.insert({arr[i].second, i});
}
for (int i = 1; i < N; i++) {
if (find(i) != find(0)) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const double PI = 3.14159265359;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k, ans = 0;
cin >> n >> k;
vector<long long> v(n);
for (auto& i : v) cin >> i;
vector<int> oneEnd(n);
int r = 0;
for (int i = 0; i < n; i++) {
if (v[i] == 1) {
r = max(r, i);
while (r < n && v[r] == 1) {
r++;
}
oneEnd[i] = r;
}
}
for (int i = 0; i < n; i++) {
long long prod = 1, sum = 0;
for (int j = i; j < n; j++) {
double dprod = prod;
dprod *= v[j];
if (dprod > 2e18) break;
if (v[j] == 1) {
if (!(prod % k)) {
long long goal = prod / k;
if (goal >= sum + 1 && goal <= sum + (oneEnd[j] - j)) ans++;
}
sum += (oneEnd[j] - j);
j = oneEnd[j] - 1;
} else {
prod *= v[j];
sum += v[j];
if (prod == sum * k) {
ans++;
}
}
}
}
cout << ans;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int a[1000015];
int b[1000015];
int n, m;
int check;
int dfs1(int x, int y) {
if (x == n && y == m) {
check = 0;
b[y + (x - 1) * m] = 0;
return 0;
}
int k1, k2;
k1 = x + 1;
k2 = y;
if (k1 <= n && k2 <= m && a[k2 + (k1 - 1) * m] == 1 && check == 1 &&
b[k2 + (k1 - 1) * m] == 0) {
b[k2 + (k1 - 1) * m] = 1;
dfs1(k1, k2);
if (check == 0) return 0;
}
k1 = x;
k2 = y + 1;
if (k1 <= n && k2 <= m && a[k2 + (k1 - 1) * m] == 1 && check == 1 &&
b[k2 + (k1 - 1) * m] == 0) {
b[k2 + (k1 - 1) * m] = 1;
dfs1(k1, k2);
if (check == 0) return 0;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char x;
cin >> x;
if (x == '.')
a[j + (i - 1) * m] = 1;
else
a[j + (i - 1) * m] = 0;
}
check = 1;
sizeof(b, 0, sizeof(b));
dfs1(1, 1);
if (check == 1) {
cout << 0;
return 0;
}
check = 1;
dfs1(1, 1);
if (check == 1) {
cout << 1;
return 0;
}
cout << 2;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int n;
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
int i, max = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
if (max < a[i]) max = a[i];
}
int t = gcd(a[0], a[1]);
for (i = 1; i < n; i++) t = gcd(t, a[i]);
int res = max / t - n;
if (res % 2)
printf("Alice\n");
else
printf("Bob\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
string to_str(T str) {
stringstream stream;
stream << str;
return stream.str();
}
template <typename T>
int to_int(T num) {
int val;
stringstream stream;
stream << num;
stream >> val;
return val;
}
vector<string> split(const string& s, char delim) {
vector<string> elems;
stringstream ss(s);
string item;
while (getline(ss, item, delim)) elems.push_back(item);
return elems;
}
const int dr[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int MAX = (8 << 20);
bool prime[MAX];
char s[10];
bool ispal(int n) {
int m = 0, a[10];
for (; n > 0; n /= 10) a[m++] = n % 10;
for (int i = 0; i < (m / 2); i++)
if (a[i] != a[m - 1 - i]) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
memset(prime, true, sizeof(prime));
prime[1] = false;
for (int n = (2); n <= (MAX); n++)
if (prime[n])
for (int m = n + n; m < MAX; m += n) prime[m] = false;
int p, q;
cin >> p >> q;
int c1 = 0, c2 = 0;
int ans = 1;
for (int i = 1; i <= MAX; i++) {
if (ispal(i)) c2++;
if (prime[i]) c1++;
if (1ll * q * c1 <= 1ll * p * c2) ans = i;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long n;
cin >> n;
string s[2 * n];
for (long long i = 0; i < 2 * n; i++) {
for (long long j = 0; j < 2 * n; j++) {
s[i].push_back((i + j) % 2 + '0');
}
}
vector<vector<string>> str(4, vector<string>(n));
for (long long i = 0; i < 4; i++)
for (long long j = 0; j < n; j++) cin >> str[i][j];
long long ans = 1000000007;
sort((str).begin(), (str).end());
do {
string tmp[2 * n];
for (long long i = 0; i < n; i++) {
for (auto j : str[0][i]) tmp[i].push_back(j);
for (auto j : str[1][i]) tmp[i].push_back(j);
}
for (long long i = 0; i < n; i++) {
for (auto j : str[2][i]) tmp[i + n].push_back(j);
for (auto j : str[3][i]) tmp[i + n].push_back(j);
}
long long cnt = 0;
for (long long i = 0; i < 2 * n; i++)
for (long long j = 0; j < 2 * n; j++)
if (tmp[i][j] != s[i][j]) cnt++;
ans = min(ans, min(cnt, 2 * n * 2 * n - cnt));
} while (next_permutation((str).begin(), (str).end()));
cout << ans;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void getint(int &v) {
char ch, fu = 0;
for (ch = '*'; (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') fu = 1, ch = getchar();
for (v = 0; ch >= '0' && ch <= '9'; ch = getchar()) v = v * 10 + ch - '0';
if (fu) v = -v;
}
int n, m, tt, tot, g[5555], p[5555];
char ans[3010][3010];
bool cmp(int x, int y) { return g[x] > g[y]; }
int main() {
cin >> n >> m;
tot = n * (n - 1);
for (int i = 1; i <= m; i++) {
cin >> g[i];
}
tt = tot;
for (int i = 1; i <= m; i++) tt -= g[i];
if (m < n) {
int re = tt % (n - m);
int le = tt / (n - m);
for (int i = m + 1; i <= n; ++i) {
if (i - m <= re)
g[i] = le + 1;
else
g[i] = le;
}
}
for (int i = 2; i <= n; i++)
if (g[i] > g[i - 1]) return puts("no"), 0;
int s = 0;
for (int i = n; i >= 1; i--) {
s += g[i];
if (s < (n - i + 1) * (n - i)) return puts("no"), 0;
}
if (s != n * (n - 1)) return puts("no"), 0;
puts("yes");
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= n - 1; i++) {
sort(p + i + 1, p + n + 1, cmp);
int l = 2 * (n - i) - g[p[i]];
for (int j = i + 1; j <= n; j++)
if (g[p[j]] >= min(2, l) && min(2, l) == 2) {
g[p[j]] -= min(2, l);
l -= min(2, l);
ans[p[i]][p[j]] = 'L';
ans[p[j]][p[i]] = 'W';
} else if (g[p[j]] >= min(1, l) && min(1, l) == 1) {
g[p[j]] -= min(1, l);
l -= min(1, l);
ans[p[i]][p[j]] = 'D';
ans[p[j]][p[i]] = 'D';
} else {
ans[p[i]][p[j]] = 'W';
ans[p[j]][p[i]] = 'L';
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (i == j)
putchar('X');
else
putchar(ans[i][j]);
puts("");
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
void nop();
using namespace std;
const int inf = (int)1e9;
const long long infl = (long long)2e18;
const int mod = 1000000007;
struct V {
int count = 0;
int n[2] = {-1, -1};
int p = -1;
};
int main() {
int n;
cin >> n;
vector<int> a(n), p(n);
for (int &ai : a) {
cin >> ai;
}
for (int &pi : p) {
cin >> pi;
}
vector<V> vs(1);
for (int pi : p) {
int vi = 0;
for (int i = 29; i >= 0; --i) {
int b = (bool)(pi & (1 << i));
assert(b == 0 || b == 1);
++vs[vi].count;
if (vs[vi].n[b] == -1) {
vs[vi].n[b] = vs.size();
vs.emplace_back();
}
vi = vs[vi].n[b];
}
assert(vs[vi].p == -1 || vs[vi].p == pi);
vs[vi].p = pi;
++vs[vi].count;
}
vector<int> ans;
for (int ai : a) {
int vi = 0;
for (int i = 29; i >= 0; --i) {
int b = (bool)(ai & (1 << i));
--vs[vi].count;
if (vs[vi].n[b] != -1 && vs[vs[vi].n[b]].count > 0) {
assert(vs[vi].n[b] != -1);
vi = vs[vi].n[b];
} else {
assert(vs[vi].n[1 - b] != -1);
vi = vs[vi].n[1 - b];
}
}
assert(vs[vi].count > 0);
assert(vs[vi].p != -1);
--vs[vi].count;
ans.push_back(ai ^ vs[vi].p);
}
for (int o : ans) {
cout << o << " ";
}
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long a[200004], s[200004];
int p[200004];
long long f[200004];
int main() {
scanf("%d%d%d", &n, &m, &k);
a[0] = 0;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
memset(p, 0, sizeof(p));
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
p[x] = max(p[x], y);
}
sort(a + 1, a + n + 1);
a[0] = 0;
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
long long sum = s[k];
memset(f, 0, sizeof(f));
for (int i = 1; i <= k; i++) {
for (int j = 0; j < i; j++) {
f[i] = max(f[i], f[j] + s[j + p[i - j]] - s[j]);
}
}
printf("%lld\n", sum - f[k]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n, m, a[401], f[1 << 15][71], g[1 << 15], fa[10001], in[1001],
c[201][201];
long long peach[1 << 15], ans = 1, hd = 0;
vector<long long> vec[101], Vec;
long long g_fa(long long x) {
if (fa[x] == x)
return x;
else
return g_fa(fa[x]);
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(1 + a, 1 + a + n);
for (long long i = 1; i <= n; i++) fa[i] = i;
for (long long i = 1; i <= n; i++) {
for (long long j = i + 1; j <= n; j++) {
if (a[j] % a[i] == 0) {
long long t1 = g_fa(i), t2 = g_fa(j);
in[j]++;
if (t1 != t2) fa[t2] = t1;
}
}
}
c[0][0] = c[0][1] = c[1][1] = 1;
for (long long i = 2; i <= 2 * n; i++) {
c[0][i] = 1;
for (long long j = 1; j <= i; j++)
c[j][i] = (c[j - 1][i - 1] + c[j][i - 1]) % mod;
}
for (long long i = 1; i <= n; i++) {
vec[g_fa(i)].push_back(i);
}
for (long long i = 1; i <= n; i++) {
if (vec[i].size() > 1) {
Vec.clear();
for (long long j = 0; j < vec[i].size(); j++) {
if (in[vec[i][j]] == 0) Vec.push_back(vec[i][j]);
}
long long N = 1 << Vec.size(), cnt = 0;
memset(g, 0, sizeof g), memset(f, 0, sizeof f);
for (long long j = 0; j < vec[i].size(); j++) {
if (in[vec[i][j]]) {
cnt++;
for (long long k = 0; k < Vec.size(); k++) {
if (a[vec[i][j]] % a[Vec[k]] == 0) peach[vec[i][j]] |= 1 << k;
}
g[peach[vec[i][j]]]++;
}
}
for (long long j = 0; j < Vec.size(); j++) {
for (long long k = 0; k < N; k++) {
if (k >> j & 1) g[k] += g[k - (1 << j)];
}
}
f[0][0] = 1;
for (long long j = 0; j < N; j++) {
for (long long k = 0; k <= cnt; k++) {
if (f[j][k]) {
if (k < g[j])
f[j][k + 1] = (f[j][k + 1] + f[j][k] * (g[j] - k) % mod) % mod;
for (long long p : vec[i]) {
if (in[p] && ((peach[p] & j) != peach[p]) &&
((peach[p] & j) || j == 0)) {
f[j | peach[p]][k + 1] =
(f[j | peach[p]][k + 1] + f[j][k]) % mod;
}
}
}
}
}
ans = ans * f[N - 1][cnt] % mod * c[cnt - 1][hd + cnt - 1] % mod;
hd += cnt - 1;
}
}
cout << ans;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
template <typename num_t>
inline void add_mod(num_t& a, const long long& b, const int& m) {
a = (a + b) % m;
if (a < 0) a += m;
}
template <typename num_t>
inline bool update_max(num_t& a, const num_t& b) {
return a < b ? a = b, true : false;
}
template <typename num_t>
inline bool update_min(num_t& a, const num_t& b) {
return a > b ? a = b, true : false;
}
template <typename num_t>
num_t gcd(num_t lhs, num_t rhs) {
return !lhs ? rhs : gcd(rhs % lhs, lhs);
}
template <typename num_t>
num_t pw(num_t n, num_t k, num_t mod) {
num_t res = 1;
for (; k > 0; k >>= 1) {
if (k & 1) res = 1ll * res * n % mod;
n = 1ll * n * n % mod;
}
return res;
}
const int inf = 1e9 + 7;
const int mod = inf;
const long long ll_inf = 9ll * inf * inf;
const int MAX_N = 5e5 + 7;
const int M = 20;
int first_bit[1 << M];
void init() {
first_bit[0] = -1;
for (int i = (1), _b = (1 << M); i < _b; ++i) {
if (i & (i - 1))
first_bit[i] = first_bit[i - 1];
else
first_bit[i] = first_bit[i - 1] + 1;
}
}
struct matrix {
int arr[M];
int mask = 0;
int left_index = 0;
bool changed = false;
int max_value = 0;
matrix(int idx) {
left_index = idx;
fill_n(arr, M, 0);
}
void add_row(int x) {
while (x > 0) {
int c = first_bit[x];
if (arr[c] == 0) {
arr[c] = x;
mask |= 1 << c;
c = 0;
changed = true;
} else
x ^= arr[c];
}
}
int get_max() {
if (!changed) return max_value;
int res = 0;
for (int i = M - 1; i >= 0; --i)
if (arr[i] && (res ^ arr[i]) > res) {
res ^= arr[i];
}
changed = false;
return max_value = res;
}
};
int n;
int a[MAX_N];
struct query {
int left, right;
};
vector<int> closed[MAX_N];
vector<query> queries;
vector<matrix> data;
int ans[MAX_N];
void solve() {
init();
cin >> n;
for (int i = (0), _b = (n); i < _b; ++i) cin >> a[i];
int q;
cin >> q;
queries.resize(q);
for (int i = (0), _b = (q); i < _b; ++i) {
cin >> queries[i].left >> queries[i].right;
--queries[i].left;
--queries[i].right;
closed[queries[i].right].push_back(i);
}
for (int i = (0), _b = (n); i < _b; ++i) {
data.push_back(matrix(i));
vector<matrix> new_data;
for (auto& mtx : data) {
mtx.add_row(a[i]);
if (new_data.empty() || new_data.back().mask != mtx.mask) {
new_data.push_back(mtx);
}
}
data = new_data;
for (int id : closed[i]) {
int j = 0;
while (j + 1 < data.size() && data[j + 1].left_index <= queries[id].left)
++j;
ans[id] = data[j].get_max();
}
}
for (int j = (0), _b = (q); j < _b; ++j) cout << ans[j] << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
| 17 |
#include <bits/stdc++.h>
char in[10][10];
char temp[10][10];
int ans = INT_MAX;
int mindiff(int n) {
int i, j, max = INT_MIN, diff;
if (n == 1) return 0;
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++) {
diff = abs(atoi(temp[i]) - atoi(temp[j]));
if (diff > max) max = diff;
}
return max;
}
void trythis(int words, int n, char *used) {
int i, cur, j;
for (j = 0; j < words; j++) {
for (i = 0; i < n; i++) temp[j][used[i]] = in[j][i];
temp[j][n] = '\0';
}
cur = mindiff(words);
if (cur < ans) ans = cur;
}
void permute(int words, int n, char *used, int level) {
int i;
for (i = 0; i < n; i++) {
if (used[i] == -1) {
used[i] = level;
permute(words, n, used, level + 1);
used[i] = -1;
}
}
if (level == n) trythis(words, n, used);
}
int makeperms(int words, int digits) {
char used[10];
memset(used, -1, sizeof(used));
permute(words, digits, used, 0);
return ans;
}
int main() {
int cases, cnt;
int digits;
for (scanf("%d%d", &cases, &digits), cnt = 1; cnt <= cases; cnt++)
scanf("%s", in[cnt - 1]);
printf("%d\n", makeperms(cases, digits));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, k, a[6], b[6], ans = 0, s, m;
int main() {
cin >> n >> m;
while (n % 2 == 0) {
n /= 2;
a[2]++;
}
while (m % 2 == 0) {
m /= 2;
b[2]++;
}
while (n % 3 == 0) {
n /= 3;
a[3]++;
}
while (m % 3 == 0) {
m /= 3;
b[3]++;
}
while (n % 5 == 0) {
n /= 5;
a[5]++;
}
while (m % 5 == 0) {
m /= 5;
b[5]++;
}
if (n != m)
cout << -1;
else
cout << abs(a[2] - b[2]) + abs(a[3] - b[3]) + abs(a[5] - b[5]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n;
inline int lowbit(int x) { return x & -x; }
int c[N];
bool vis[N];
void add(int pos) {
if (vis[pos]) return;
vis[pos] = 1;
while (pos <= n) {
c[pos]++;
pos += lowbit(pos);
}
}
int sum(int pos) {
int ret = 0;
while (pos) {
ret += c[pos];
pos -= lowbit(pos);
}
return ret;
}
struct Point {
int x, y;
};
Point a[N];
int main() {
scanf("%d", &n);
vector<int> x, y;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
x.push_back(a[i].x);
y.push_back(a[i].y);
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
x.erase(unique(x.begin(), x.end()), x.end());
y.erase(unique(y.begin(), y.end()), y.end());
for (int i = 1; i <= n; i++) {
a[i].x = lower_bound(x.begin(), x.end(), a[i].x) - x.begin() + 1;
a[i].y = lower_bound(y.begin(), y.end(), a[i].y) - y.begin() + 1;
}
sort(a + 1, a + n + 1,
[](Point a, Point b) { return a.y > b.y || (a.y == b.y && a.x < b.x); });
long long ans = 0;
for (int i = 1; i <= n; i++) {
add(a[i].x);
long long tmp = sum(a[i].x);
ans += tmp * (sum(a[i + 1].y == a[i].y ? a[i + 1].x - 1 : n) - tmp + 1);
}
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
int T, i, j, n, q[20];
long long A, B, C, a, b, c, M, MA, ans, v, p[20];
void cal(int s, long long now) {
if (now > M) return;
if (s > n) {
if (now < a) return;
b = now, c = v / a / b;
if (a * b + a * c + b * c < ans)
ans = a * b + a * c + b * c, A = a, B = b, C = c;
return;
}
if (q[s]) q[s]--, cal(s, now * p[s]), q[s]++;
cal(s + 1, now);
}
void dfs(int s, long long now) {
if (now > MA) return;
if (s > n) {
if (a = now, v / a + 2 * a * sqrt(v / a) < ans)
M = sqrt(v / a) + 1e-8, cal(1, 1);
return;
}
if (q[s]) q[s]--, dfs(s, now * p[s]), q[s]++;
dfs(s + 1, now);
}
int main() {
for (scanf("%d", &T); T--;) {
scanf("%d", &n);
for (v = i = 1; i <= n; i++) {
scanf("%I64d%d", &p[i], &q[i]);
for (j = 1; j <= q[i]; j++) v *= p[i];
}
ans = 5e18, MA = pow(v, 1. / 3) + 1e-8, dfs(1, 1);
printf("%I64d %I64d %I64d %I64d\n", 2 * ans, A, B, C);
}
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[200][150];
int n, m, i, c, p;
while (cin >> n) {
for (i = 1; i <= n; i++) {
cin >> s[i];
}
p = 0;
c = 0;
for (i = 1; i <= n; i++) {
if (s[i][0] == 'O' && s[i][1] == 'O') {
p = 1;
s[i][0] = '+';
s[i][1] = '+';
break;
} else if (s[i][3] == 'O' && s[i][4] == 'O') {
p = 1;
s[i][3] = '+';
s[i][4] = '+';
break;
}
}
if (p == 1) {
cout << "YES" << endl;
for (i = 1; i <= n; i++) {
cout << s[i] << endl;
}
} else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char A[52][52];
bool res = false;
char dif = 'a' - 'A';
int d;
void f(char c, int x, int y) {
if (A[x][y] != c) return;
A[x][y] += dif;
if (d != 1 && A[x - 1][y] == c + dif) {
res = true;
return;
}
if (d != 2 && A[x + 1][y] == c + dif) {
res = true;
return;
}
if (d != 3 && A[x][y - 1] == c + dif) {
res = true;
return;
}
if (d != 4 && A[x][y + 1] == c + dif) {
res = true;
return;
}
d = 1;
f(c, x + 1, y);
d = 2;
f(c, x - 1, y);
d = 3;
f(c, x, y + 1);
d = 4;
f(c, x, y - 1);
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> A[i] + 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (A[i][j] < 'a') f(A[i][j], i, j);
}
}
cout << (res ? "Yes" : "No") << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int f[100001];
int s[301];
inline int find(int l, int r, int x) {
while (l <= r) {
int mid = (l + r) / 2;
if (x >= f[mid])
l = mid + 1;
else
r = mid - 1;
}
return r;
}
int main() {
int n, T;
scanf("%d%d", &n, &T);
int i, j;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= min(n, T); i++) {
for (j = 1; j <= n; j++) a[i * n + j] = a[j];
}
int lim = n * min(n, T);
int len = 1;
f[1] = a[1];
for (i = 2; i <= lim; i++) {
int x = find(0, len, a[i]);
if (x == len) len++;
f[x + 1] = a[i];
}
if (T <= n)
printf("%d\n", len);
else {
int maxx = 0, maxi = 0;
for (i = 1; i <= n; i++) s[a[i]]++;
for (i = 1; i <= 300; i++) maxi = max(s[i], maxi);
printf("%d\n", len + maxi * (T - n));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string x;
for (int i = 0; i < n; i++) {
cin >> x;
for (int y = 0; y < m; y++) {
if (x[y] == '.') {
if (y % 2 == i % 2)
x[y] = 'W';
else
x[y] = 'B';
}
}
cout << x << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (2e5 + 10) * 4;
int s[maxn], lmx[maxn], rmx[maxn], lmn[maxn], rmn[maxn], lv[maxn], rv[maxn],
mv[maxn], mm[maxn];
void Pushup(int k) {
s[k] = s[k << 1] + s[k << 1 | 1];
lmx[k] = max(lmx[k << 1], s[k << 1] + lmx[k << 1 | 1]);
rmx[k] = max(rmx[k << 1 | 1], s[k << 1 | 1] + rmx[k << 1]);
lmn[k] = min(lmn[k << 1], s[k << 1] + lmn[k << 1 | 1]);
rmn[k] = min(rmn[k << 1 | 1], s[k << 1 | 1] + rmn[k << 1]);
lv[k] = max(max(lv[k << 1], lv[k << 1 | 1] - s[k << 1]),
mv[k << 1] + lmx[k << 1 | 1]);
rv[k] = max(max(rv[k << 1 | 1], s[k << 1 | 1] + rv[k << 1]),
mv[k << 1 | 1] - rmn[k << 1]);
mv[k] = max(mv[k << 1] + s[k << 1 | 1], mv[k << 1 | 1] - s[k << 1]);
mm[k] =
max(max(max(mm[k << 1], mm[k << 1 | 1]), lv[k << 1 | 1] - rmn[k << 1]),
rv[k << 1] + lmx[k << 1 | 1]);
}
char S[maxn];
void Build(int k, int l, int r) {
if (l == r)
return s[k] = (S[l] == '(' ? 1 : -1), lmx[k] = rmx[k] = max(s[k], 0),
lmn[k] = rmn[k] = min(s[k], 0), lv[k] = rv[k] = mv[k] = mm[k] = 1,
void(0);
int mid = l + r >> 1;
Build(k << 1, l, mid), Build(k << 1 | 1, mid + 1, r);
Pushup(k);
}
void Update(int k, int l, int r, int p, char d) {
if (l == r)
return s[k] = (d == '(' ? 1 : -1), lmx[k] = rmx[k] = max(s[k], 0),
lmn[k] = rmn[k] = min(s[k], 0), lv[k] = rv[k] = mv[k] = mm[k] = 1,
void(0);
int mid = l + r >> 1;
if (p > mid)
Update(k << 1 | 1, mid + 1, r, p, d);
else
Update(k << 1, l, mid, p, d);
Pushup(k);
}
char SWAP(char& x, char& y) {
char z = y;
y = x, x = z;
}
signed main() {
int x, y;
int n, m;
scanf("%d%d", &n, &m);
n = n - 1 << 1;
scanf("%s", S + 1);
Build(1, 1, n), printf("%d\n", mm[1]);
while (m--)
scanf("%d%d", &x, &y),
S[x] ^ S[y] ? (SWAP(S[x], S[y]), Update(1, 1, n, x, S[x]),
Update(1, 1, n, y, S[y]))
: void(0),
printf("%d\n", mm[1]);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int a[205];
int n;
int dp[205][405];
int f(int T, int i) {
if (i == n) {
return 0;
}
if (dp[i][T] != -1) return dp[i][T];
if (T > a[i]) {
dp[i][T] = abs(T - a[i]) + f(T + 1, i + 1);
} else {
dp[i][T] = min(f(T + 1, i), abs(T - a[i]) + f(T + 1, i + 1));
}
return dp[i][T];
}
void solve() {
memset(dp, -1, sizeof(dp));
int ans = f(1, 0);
cout << ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
solve();
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> alice;
vector<vector<int>> bob;
vector<vector<int>> used(3, vector<int>(3, 0));
int startA, startB;
long long k, scoreA, scoreB;
void input() {
cin >> k;
cin >> startA;
cin >> startB;
startA--;
startB--;
int num;
for (int i = 0; i < 3; i++) {
vector<int> temp;
for (int j = 0; j < 3; j++) {
cin >> num;
num--;
temp.push_back(num);
}
alice.push_back(temp);
}
for (int i = 0; i < 3; i++) {
vector<int> temp;
for (int j = 0; j < 3; j++) {
cin >> num;
num--;
temp.push_back(num);
}
bob.push_back(temp);
}
}
void compare(int a, int b) {}
void output() { cout << scoreA << " " << scoreB << endl; }
void process() {
vector<pair<int, int>> cycle;
long long cnt = k;
while (cnt > 0) {
int i = startA;
int j = startB;
if (used[i][j] == 1) {
cycle.push_back(make_pair(i, j));
}
if (used[i][j] == 2) break;
used[i][j] += 1;
if (startA == 0 && startB == 2 || startA == 1 && startB == 0 ||
startA == 2 && startB == 1)
scoreA++;
if (startA == 2 && startB == 0 || startA == 0 && startB == 1 ||
startA == 1 && startB == 2)
scoreB++;
startA = alice[i][j];
startB = bob[i][j];
cnt--;
}
if (cycle.size() != 0) {
int cycle_scoreA = 0;
int cycle_scoreB = 0;
for (int i = 0; i < cycle.size(); i++) {
if (cycle[i].first == 0 && cycle[i].second == 2 ||
cycle[i].first == 1 && cycle[i].second == 0 ||
cycle[i].first == 2 && cycle[i].second == 1)
cycle_scoreA++;
if (cycle[i].first == 2 && cycle[i].second == 0 ||
cycle[i].first == 0 && cycle[i].second == 1 ||
cycle[i].first == 1 && cycle[i].second == 2)
cycle_scoreB++;
}
long long div_cnt = cnt / cycle.size();
int mod_cnt = cnt % cycle.size();
scoreA += cycle_scoreA * div_cnt;
scoreB += cycle_scoreB * div_cnt;
for (int i = 0; i < mod_cnt; i++) {
if (cycle[i].first == 0 && cycle[i].second == 2 ||
cycle[i].first == 1 && cycle[i].second == 0 ||
cycle[i].first == 2 && cycle[i].second == 1)
scoreA++;
if (cycle[i].first == 2 && cycle[i].second == 0 ||
cycle[i].first == 0 && cycle[i].second == 1 ||
cycle[i].first == 1 && cycle[i].second == 2)
scoreB++;
}
}
}
int main() {
input();
process();
output();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
double fRand(double fMin, double fMax) {
double f = (double)rand() / RAND_MAX;
return fMin + f * (fMax - fMin);
}
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
int n, num[100005];
bool asked[100005];
int get(int i) {
i %= n;
++i;
if (!asked[i]) {
asked[i] = true;
printf("? %d\n", i);
fflush(stdout);
scanf("%d", &num[i]);
asked[i] = true;
}
return num[i];
}
void answer(int x) {
if (x == -1) x = -2;
printf("! %d\n", x + 1);
fflush(stdout);
exit(0);
}
int Solve(int l1, int r1, int l2, int r2) {
int lo = 1, hi = r1 - l1 - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
long long x = 1LL * (get(l1 + mid) - get(l2 + mid)) * (get(l1) - get(l2));
if (x < 0) {
hi = mid - 1;
} else if (x > 0) {
lo = mid + 1;
} else
return l1 + mid;
}
return -1;
}
int main() {
scanf("%d", &n);
int ans = -1;
if ((n / 2) % 2 == 1) answer(ans);
vector<int> pos = {0, n / 4, n / 2, 3 * n / 4};
for (int i = 0; i < 4; ++i) {
int a = pos[i], b = pos[(i + 1) % 4], c = pos[(i + 2) % 4],
d = pos[(i + 3) % 4];
if (get(a) == get(c)) answer(a);
if (get(b) == get(d)) answer(b);
if (1LL * (get(a) - get(c)) * (get(b) - get(d)) < 0) {
ans = Solve(a, b, c, d);
break;
}
}
answer(ans % n);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n = 0;
long long A, B, C, L;
int main() {
ios_base::sync_with_stdio(false);
cin >> A >> B >> C >> L;
long long T = (L + 1) * (L + 2) * (L + 3);
T /= 6;
for (int l = 0; l <= L; ++l) {
if (A + l >= (B + C)) {
long long x = min(A - B - C + l, L - l);
T -= ((x + 1) * (x + 2)) / 2;
}
if (B + l >= (A + C)) {
long long x = min(B - A - C + l, L - l);
T -= ((x + 1) * (x + 2)) / 2;
}
if (C + l >= A + B) {
long long x = min(C - A - B + l, L - l);
T -= ((x + 1) * (x + 2)) / 2;
}
}
cout << T;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = ((long long)1) << 40;
string s;
int n;
int main() {
cin >> s;
n = s.length();
if (n % 2 != 0) {
cout << "No" << endl;
return 0;
}
int i = 0;
while (true) {
n = s.length();
if (s.empty() || (!s.empty() && i == n - 1)) break;
if (s[i] == s[i + 1]) {
s = s.substr(0, i) + s.substr(i + 2, n - i + 2);
if (i > 0)
i -= 1;
else
i = 0;
continue;
}
i++;
}
if (s.empty())
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
};
| 8 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
int a, b, c;
int main() {
while (scanf("%d%d%d", &a, &b, &c) != EOF) {
int ha = a * c;
int ha1 = b * c;
int ha2 = (ha - ha1) / b;
if ((ha - ha1) % b != 0) ha2++;
cout << ha2 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 466666;
int n, p[N], pos[N], v1[N];
long long res;
pair<long long, long long> v[N];
void modify1(int p) {
while (p <= n) v1[p]++, p += p & -p;
}
int qry1(int p) {
int r = 0;
while (p) r += v1[p], p -= p & -p;
return r;
}
void add(pair<long long, long long> &a, pair<long long, long long> b) {
a = pair<long long, long long>(a.first + b.first, a.second + b.second);
}
void mdy(int p, pair<long long, long long> x) {
while (p <= n) add(v[p], x), p += p & -p;
}
pair<long long, long long> qry(int p) {
pair<long long, long long> res(0, 0);
while (p) add(res, v[p]), p -= p & -p;
return res;
}
int main() {
read(n);
for (register int i = (1); i <= (n); i++) read(p[i]), pos[p[i]] = i;
for (register int x = (1); x <= (n); x++) {
res += x - 1 - qry1(pos[x]);
modify1(pos[x]);
long long cur = 0;
mdy(pos[x], pair<long long, long long>(1, pos[x]));
int p = (x + 1) / 2, L = 1, R = n;
while (L < R) {
int mid = (L + R) >> 1;
if (qry(mid).first < p)
L = mid + 1;
else
R = mid;
}
cur += 1ll * p * (L - p) - (qry(L).second - 1ll * p * (p + 1) / 2);
cur += -1ll * (x - p) * (L - p) +
(qry(n).second - qry(L).second -
(1ll * x * (x + 1) / 2 - 1ll * p * (p + 1) / 2));
printf("%lld ", res + cur);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
b[n] = a[n];
for (int i = n - 1; i >= 1; i--) {
b[i] = a[i] + a[i + 1];
}
for (int i = 1; i <= n; i++) {
cout << b[i];
if (i == n)
cout << endl;
else
cout << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int vis[55];
vector<int> qwq[40];
long long Right[45], cntRight[1 << 20];
long long Onl() {
long long ans = 0;
for (int i = 0; i < N; i++)
if (qwq[i].size() == 0) ans++;
return ans;
}
void dfs(int Now, int x) {
if (vis[Now]) return;
vis[Now] = x;
for (int i = 0; i < qwq[Now].size(); i++) dfs(qwq[Now][i], 3 - x);
}
long long GetComponents() {
memset(vis, 0, sizeof(vis));
long long ans = 0;
for (int i = 0; i < N; i++)
if (!vis[i]) {
ans++;
dfs(i, 1);
}
return ans;
}
long long Get02() {
long long m1 = min(N, 20);
long long m2 = N - m1;
memset(cntRight, 0, sizeof(cntRight));
for (long long i = 0; i < (1ll << m1); i++) {
long long Nowmas = 0;
bool flag = true;
for (int j = 0; j < m1; j++) {
if ((i & (1ll << j)) == 0) continue;
if (Nowmas & (1ll << j)) flag = false;
Nowmas |= ((1ll << j) | Right[j]);
}
if (flag) cntRight[Nowmas >> m1]++;
}
for (int i = 0; i < m2; i++)
for (int j = 0; j < (1 << m2); j++)
if (j & (1ll << i)) cntRight[j] += cntRight[j ^ (1ll << i)];
long long ans = 0;
for (long long i = 0; i < (1 << m2); i++) {
long long Nowmas = 0;
bool flag = true;
for (int j = m1; j < N; j++) {
if ((i & (1 << (j - m1))) == 0) continue;
if (Nowmas & (1ll << j)) flag = false;
Nowmas |= (1ll << j) | Right[j];
}
if (flag) ans += cntRight[i ^ ((1ll << m2) - 1)];
}
return ans;
}
bool Non_Odd() {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < N; i++)
if (!vis[i]) dfs(i, 1);
for (int i = 0; i < N; i++) {
for (int j = 0; j < qwq[i].size(); j++)
if (vis[i] == vis[qwq[i][j]]) return false;
}
return true;
}
long long Pow(long long x, long long y) {
long long ans = 1;
for (; y; y >>= 1) {
if (y & 1) ans = ans * x;
x = x * x;
}
return ans;
}
long long Calc(int Mask) {
if (Mask == 0) return Pow(2, N);
if (Mask == 1 || Mask == 4) {
return Get02();
}
if (Mask == 2) {
return Pow(2, GetComponents());
}
if (Mask == 3 || Mask == 6) {
return Pow(2, Onl());
}
if (Mask == 5) {
if (Non_Odd())
return Pow(2, GetComponents());
else
return 0;
}
if (Mask == 7) {
if (M == 0)
return Pow(2, N);
else
return 0;
}
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
qwq[x].push_back(y);
qwq[y].push_back(x);
Right[x] ^= (1ll << y);
Right[y] ^= (1ll << x);
}
long long ans = 0;
for (int i = 0; i < 8; i++) {
if (__builtin_popcount(i) % 2 == 0)
ans += Calc(i);
else
ans -= Calc(i);
}
cout << ans;
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << a + b;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, p[110], num, g[110];
int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) p[i] = i, g[i] = 1;
int a;
int b;
int ans = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
int x = find(a);
int y = find(b);
if (x == y) {
if (g[x] % 2 == 1) ans++;
} else {
p[x] = y;
g[y] += g[x];
}
}
if ((n - ans) % 2 == 1) ans++;
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m;
int store[100005];
long long int gift[100005];
int main() {
cin >> t;
while (t--) {
cin >> m >> n;
vector<vector<long long int>> g(m, vector<long long int>(n, 0));
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) cin >> g[i][j];
multiset<long long int> s;
for (int i = 0; i < n; i++) gift[i] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[j][i] > gift[i]) {
gift[i] = g[j][i];
store[i] = j;
}
}
}
set<int> stores;
for (int i = 0; i < n; i++) stores.insert(store[i]);
for (int i = 0; i < n; i++) s.insert(gift[i]);
if (stores.size() <= (n - 1)) {
cout << *s.begin() << "\n";
} else {
long long int ans = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (k == j) continue;
long long int val = g[i][j];
long long int val2 = g[i][k];
long long int opval = gift[j], op2val = gift[k];
s.erase(s.find(opval));
s.erase(s.find(op2val));
s.insert(val);
s.insert(val2);
ans = max(ans, *s.begin());
s.erase(s.find(val));
s.erase(s.find(val2));
s.insert(opval);
s.insert(op2val);
}
}
}
cout << ans << "\n";
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x[2];
point() {}
point(long long a, long long b) {
x[0] = a;
x[1] = b;
}
long long& operator[](long long a) { return x[a]; }
long long operator*(point a) { return x[0] * a.x[1] - x[1] * a.x[0]; }
point operator+(point a) { return point(x[0] + a.x[0], x[1] + a.x[1]); }
point operator-(point a) { return point(x[0] - a.x[0], x[1] - a.x[1]); }
} p[5050], q[5050], ap[10];
long long n, s, top;
long long dis(point a, point b) {
return (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]);
}
bool cmp(point a, point b) {
long long t = (a - p[1]) * (b - p[1]);
if (!t) return dis(a, p[1]) < dis(b, p[1]);
return t > 0;
}
void graham() {
long long pos = 1;
for (long long i = 2; i <= n; i++)
if (p[i][0] < p[pos][0] || (p[i][0] == p[pos][0] && p[i][1] < p[pos][1]))
pos = i;
swap(p[1], p[pos]);
sort(p + 2, p + n + 1, cmp);
top = 2;
q[1] = p[1];
q[2] = p[2];
for (long long i = 3; i <= n; i++) {
while (top > 1 && (p[i] - q[top]) * (q[top] - q[top - 1]) >= 0) {
top--;
}
q[++top] = p[i];
}
}
void work() {
q[top + 1] = q[1];
point p1;
long long now, ans = 0;
for (long long i = 1; i <= top; i++) {
for (long long j = i + 1, v = i + 1; j <= top; j++) {
p1 = q[j] - q[i];
while (p1 * (q[v + 1] - q[i]) > p1 * (q[v] - q[i])) {
v++;
if (v == top + 1) v = 1;
}
now = p1 * (q[v] - q[i]);
if (now > ans) {
ans = now;
ap[1] = q[i];
ap[2] = q[j];
ap[3] = q[v];
}
}
}
ap[4] = ap[1] + (ap[2] - ap[3]);
ap[5] = ap[2] + (ap[3] - ap[1]);
ap[6] = ap[3] + (ap[1] - ap[2]);
printf("%lld %lld\n%lld %lld\n%lld %lld\n", ap[4][0], ap[4][1], ap[5][0],
ap[5][1], ap[6][0], ap[6][1]);
}
signed main() {
scanf("%lld%lld", &n, &s);
for (long long i = 1; i <= n; i++) scanf("%lld%lld", &p[i][0], &p[i][1]);
graham();
work();
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
vector<int> vec[N];
bool visited[N];
void dfs(int node) {
if (visited[node]) return;
visited[node] = true;
for (auto to : vec[node]) {
if (!visited[to]) dfs(to);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
x--, y--;
y += n;
vec[x].push_back(y);
vec[y].push_back(x);
}
int cevap = 0;
for (int i = 0; i < n + m; i++) {
if (!visited[i]) {
dfs(i);
cevap++;
}
}
cout << cevap - 1 << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char m[2005][2005];
int mk[2005][2005];
int p[2005][2005];
struct node {
int x, y;
};
int getid(int x, int y) { return (x - 1) * (n + 1) + y; }
vector<int> vec, que;
unordered_set<int> s;
string ans = "";
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
getchar();
for (int j = 1; j <= n; j++) {
scanf("%c", &m[i][j]);
p[i][j] = mk[i][j] = -1;
}
}
if (k >= 2 * n - 1) {
for (int i = 1; i <= 2 * n - 1; i++) printf("a");
printf("\n");
return 0;
}
int maxx = 0;
mk[1][1] = k - (m[1][1] == 'a' ? 0 : 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == 1 && j != 1)
mk[1][j] = mk[1][j - 1] - (m[1][j] == 'a' ? 0 : 1);
else if (j == 1 && i != 1)
mk[i][1] = mk[i - 1][1] - (m[i][1] == 'a' ? 0 : 1);
else if (i != 1 && j != 1)
mk[i][j] = max(mk[i - 1][j], mk[i][j - 1]) - (m[i][j] == 'a' ? 0 : 1);
if (!mk[i][j]) {
if (i + j - 1 > maxx) {
maxx = i + j - 1;
vec.clear();
vec.push_back(getid(i, j));
} else if (i + j - 1 == maxx)
vec.push_back(getid(i, j));
}
}
}
if (mk[n][n] >= 0) {
for (int i = 1; i <= 2 * n - 1; i++) printf("a");
printf("\n");
return 0;
}
for (int i = 0; i < vec.size(); i++)
p[vec[i] / (n + 1) + 1][vec[i] % (n + 1)] = 0;
int turn = 0;
if (k == 0 && m[1][1] != 'a') {
p[1][1] = 1;
vec.push_back(getid(1, 1));
turn = 1;
ans += m[1][1];
}
while (p[n][n] == -1) {
turn++;
char minc = 'z' + 1;
for (int i = 0; i < vec.size(); i++) {
int px = vec[i] / (n + 1) + 1, py = vec[i] % (n + 1);
if (px + 1 <= n && m[px + 1][py] < minc) {
minc = m[px + 1][py];
que.clear();
que.push_back(getid(px + 1, py));
} else if (px + 1 <= n && m[px + 1][py] == minc)
que.push_back(getid(px + 1, py));
if (py + 1 <= n && m[px][py + 1] < minc) {
minc = m[px][py + 1];
que.clear();
que.push_back(getid(px, py + 1));
} else if (py + 1 <= n && m[px][py + 1] == minc)
que.push_back(getid(px, py + 1));
}
ans += minc;
vec.clear();
s.clear();
for (int i = 0; i < que.size(); i++) {
p[que[i] / (n + 1) + 1][que[i] % (n + 1)] = turn;
if (s.find(que[i]) == s.end()) {
s.insert(que[i]);
vec.push_back(que[i]);
}
}
que.clear();
}
for (int i = 1; i <= maxx; i++) printf("a");
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long W(long long x, long long y) {
return ((x == 3 and y == 2) or (x == 2 and y == 1) or (x == 1 and y == 3));
}
int main() {
long long k, a, b, k1, al[4][4], bo[4][4], x;
cin >> k1 >> a >> b;
k = k1;
for (int i = 0; i < (3); i++)
for (int j = 0; j < (3); j++) cin >> al[i + 1][j + 1];
for (int i = 0; i < (3); i++)
for (int j = 0; j < (3); j++) cin >> bo[i + 1][j + 1];
vector<pair<long long, long long> > v;
set<pair<long long, long long> > st;
while (st.find({a, b}) == st.end()) {
v.push_back({a, b});
st.insert({a, b});
x = al[a][b];
b = bo[a][b];
a = x;
}
long long sz = v.size(), r1, r2, Q = 0, C = 0, Q2 = 0, C2 = 0;
for (int i = 0; i < (sz); i++) {
if (v[i].first == a and v[i].second == b) {
r1 = i;
break;
}
}
r2 = sz - 1;
for (int i = 0; i < (min(sz, k)); i++) {
if (W(v[i].first, v[i].second)) {
Q++;
if (i >= r1) C++;
}
if (W(v[i].second, v[i].first)) {
Q2++;
if (i >= r1) C2++;
}
}
k -= min(sz, k);
if (k != 0) {
long long T = k / (r2 - r1 + 1);
Q += T * C;
Q2 += T * C2;
k %= (r2 - r1 + 1);
for (int i = 0; i < (k); i++) {
if (W(v[r1 + i].first, v[r1 + i].second)) {
Q++;
}
if (W(v[r1 + i].second, v[r1 + i].first)) {
Q2++;
}
}
}
cout << Q << " " << Q2 << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 10, MAX = 2e5 + 1e4, MOD = 1e9 + 7, MAXL = 25;
void OUT(long double o, int x) {
cout << fixed << setprecision(x) << o;
return;
}
long long a[MAX];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, mi = INF, x = 0, ma = -INF, w;
cin >> n >> w;
for (int i = 1; i <= n; i++) {
cin >> a[i];
x += a[i];
mi = min(mi, x);
ma = max(ma, x);
}
long long l = max((long long)0, -mi);
long long r = w - max((long long)0, ma);
cout << max(r - l + 1, (long long)0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
vector<int> vec, ans;
int main() {
int n, k, a, b, c, d;
cin >> n >> k;
cin >> a >> b >> c >> d;
if (a != c && a != d && b != c && b != d) {
if (n == 4) {
cout << -1 << endl;
return 0;
}
if (n + 1 > k)
cout << -1 << endl;
else {
vec.push_back(a);
vec.push_back(c);
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) vec.push_back(i);
}
vec.push_back(d);
vec.push_back(b);
for (int i = 0; i < n; i++) cout << vec[i] << " ";
cout << endl;
swap(vec[0], vec[1]);
swap(vec[n - 2], vec[n - 1]);
for (int i = 0; i < n; i++) cout << vec[i] << " ";
cout << endl;
}
} else if (a == c && b == d) {
vec.push_back(a);
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) vec.push_back(i);
}
vec.push_back(b);
for (int i = 0; i < n; i++) cout << vec[i] << " ";
cout << endl;
for (int i = 0; i < n; i++) cout << vec[i] << " ";
cout << endl;
} else if (a == c && b != d) {
if (n > k) {
cout << -1 << endl;
} else {
vec.push_back(a);
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) vec.push_back(i);
}
vec.push_back(d);
vec.push_back(b);
for (int i = 0; i < n; i++) cout << vec[i] << " ";
cout << endl;
swap(vec[n - 2], vec[n - 1]);
for (int i = 0; i < n; i++) cout << vec[i] << " ";
cout << endl;
}
} else if (b == d && a != c) {
if (n > k) {
cout << -1 << endl;
} else {
vec.push_back(a);
vec.push_back(b);
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) vec.push_back(i);
}
vec.push_back(b);
for (int i = 0; i < n; i++) cout << vec[i] << " ";
cout << endl;
swap(vec[0], vec[1]);
for (int i = 0; i < n; i++) cout << vec[i] << " ";
cout << endl;
}
} else
cout << "-1" << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, tw;
int w[200020];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
}
sort(w + 1, w + n + 1);
int lim, sum = 0;
for (lim = 1; w[lim] <= k && lim <= n; lim++)
;
for (int i = lim; i <= n; i++) {
while (w[i] > 0) {
w[i] -= k;
lim++;
}
}
lim--;
sum = lim / 2;
if (lim % 2 == 1) sum++;
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e6 + 5;
const int Mod = 998244353;
long long n, a[Max];
long long fp(long long x, long long p) {
if (!p) return 1;
long long y = fp(x, p >> 1);
y = y * y % Mod;
if (p & 1) y = y * x % Mod;
return y;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] = (a[i] + a[i - 1]) % Mod;
long long ans = 0;
for (int i = 1; i <= n - 2; i++) {
long long temp = a[i] * fp(2, n - 2 - i) % Mod;
temp = temp * (n - 1 - i) % Mod;
ans = (ans + temp) % Mod;
}
for (int i = 1; i <= n - 1; i++) {
long long temp = a[i] * fp(2, n - 1 - i) % Mod;
temp = 2 * temp % Mod;
ans = (ans + temp) % Mod;
}
ans = (ans + a[n]) % Mod;
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int MAX = 1000006;
int a[maxn];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
n = unique(a, a + n) - a;
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 2 * a[i]; j < MAX; j += a[i]) {
ans = max(ans, *(lower_bound(a, a + n, j) - 1) % a[i]);
}
ans = max(ans, a[n - 1] % a[i]);
}
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
long long int x = a + b;
long long int y = c + d;
cout << max(x, y) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c(0);
cin >> n;
pair<int, int> a[2005];
for (int i = 0; cin >> a[i].first; i++) a[i].second = i;
sort(a, a + n);
for (int i = 0; i + 1 < n; i++) {
if (a[i].first == a[i + 1].first) c++;
if (c == 2) {
cout << "YES" << endl;
for (int j = 0; j < n; j++) cout << a[j].second + 1 << " ";
cout << endl;
c = 0;
for (int j = 0; j + 1 < n; j++) {
if (a[j].first == a[j + 1].first) {
c++;
swap(a[j].second, a[j + 1].second);
for (int k = 0; k < n; k++) cout << a[k].second + 1 << " ";
cout << endl;
swap(a[j].second, a[j + 1].second);
}
if (c == 2) return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int a[200010], b[200010];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int k = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
if (b[i] == a[k]) k++;
}
printf("%d\n", n - k + 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, tmp, a[100005], ans, x;
deque<long long> dq;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (a[i] != a[i - 1]) {
i += tmp;
tmp = 0;
}
if (!dq.size()) {
dq.push_back(a[i]);
} else {
if (dq.front() == a[i] && dq.back() == a[i]) {
tmp++;
dq.push_back(a[i] + 1);
dq.push_back(a[i]);
} else if (dq.back() + 1 == a[i]) {
dq.push_back(a[i]);
} else if (dq.front() + 1 == a[i]) {
dq.push_front(a[i]);
} else {
cout << "NO\n";
return 0;
}
}
}
if (abs(dq.front() - dq.back()) == 1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, d[200010];
int main() {
int sum = 0, cnt = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &d[i]);
sum += d[i];
}
if (sum % n == 0) {
sum /= n;
for (int i = 1; i <= n; i++)
if (d[i] == sum) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++, cnt--)
if (d[i] == sum) {
printf("%d", i);
if (cnt)
printf(" ");
else
printf("\n");
}
} else
printf("0\n\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n, x, y;
cin >> n >> x >> y;
vector<int> a(n, 0), b(n, 0);
vector<vector<int>> idx(n + 2), cnt(n + 1);
for (int i = 0; i < n; ++i) {
cin >> b[i];
idx[b[i]].push_back(i);
}
int subs;
for (int i = 1; i <= n + 1; ++i) {
cnt[idx[i].size()].push_back(i);
if (idx[i].size() == 0) subs = i;
}
int j = n;
for (int i = 0; i < x; ++i) {
while (cnt[j].empty()) --j;
int clr = cnt[j].back();
cnt[j].pop_back();
cnt[j - 1].push_back(clr);
a[idx[clr].back()] = clr;
idx[clr].pop_back();
}
while (cnt[j].empty()) --j;
if (2 * j > 2 * n - y - x) {
cout << "NO" << endl;
continue;
}
vector<int> ve;
while (j > 0) {
for (int clr : cnt[j])
ve.insert(ve.end(), idx[clr].begin(), idx[clr].end());
--j;
}
int ves = ve.size(), mismatch = y - x;
for (int i = 0; i < ves; ++i) {
if (mismatch > 0) {
j = (i + (n - x) / 2) % ves;
if (b[ve[i]] == b[ve[j]]) {
a[ve[i]] = subs;
} else {
a[ve[i]] = b[ve[j]];
--mismatch;
}
} else
a[ve[i]] = subs;
}
cout << "YES" << endl;
for (int i = 0; i < n; ++i) cout << a[i] << " ";
cout << endl;
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T, x, y, k;
int cost = 0;
int n, a, b;
cin >> n >> a >> b;
int c[n];
for (int i = 0; i < n; i++) {
cin >> c[i];
}
int i, j;
for (i = 0, j = n - 1; i < j; i++, j--) {
if (c[i] == c[j]) {
if (c[i] == 2) {
cost += (2 * min(a, b));
}
} else {
if (c[i] == 2 || c[j] == 2) {
if (c[i] == 2) {
if (c[j] == 1) {
cost += b;
} else {
cost += a;
}
} else {
if (c[i] == 1) {
cost += b;
} else {
cost += a;
}
}
} else {
cout << -1;
exit(0);
}
}
}
if (i == j) {
if (c[i] == 2) cost += (min(a, b));
}
cout << cost;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int m, n, v[50][4];
vector<int> comp(int o) {
vector<int> x;
for (int i = 0; i < n; ++i) {
x.push_back(v[i][o] - 1);
x.push_back(v[i][o]);
x.push_back(v[i][o + 2]);
}
sort(x.begin(), x.end());
x.resize(unique(x.begin(), x.end()) - x.begin());
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2; ++j)
v[i][o + j * 2] =
lower_bound(x.begin(), x.end(), v[i][o + j * 2]) - x.begin();
}
return x;
}
struct edge {
int u, v, cap, next;
};
const int N = 10000;
int p[N], last[N];
vector<edge> E;
int nodes;
bool getPath(int src, int sink) {
fill(p, p + nodes, -1);
p[src] = -2;
queue<int> q;
q.push(src);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int e = last[u]; e != -1; e = E[e].next)
if (E[e].cap > 0 && p[E[e].v] == -1) {
p[E[e].v] = e;
q.push(E[e].v);
}
}
return p[sink] != -1;
}
void addEdge(int a, int b, int c) {
E.push_back({a, b, c, last[a]});
last[a] = E.size() - 1;
E.push_back({b, a, 0, last[b]});
last[b] = E.size() - 1;
}
int maxFlow(int src, int sink) {
int res = 0;
int it = 0;
while (getPath(src, sink)) {
++it;
int flow = 1 << 29;
for (int cur = sink; cur != src; cur = E[p[cur]].u)
flow = min(flow, E[p[cur]].cap);
for (int cur = sink; cur != src; cur = E[p[cur]].u) {
E[p[cur]].cap -= flow;
E[p[cur] ^ 1].cap += flow;
}
res += flow;
}
assert(it <= 2 * (nodes - 2));
return res;
}
int main() {
cin >> m >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 4; ++j) cin >> v[i][j];
vector<int> mp[2] = {comp(0), comp(1)};
int L = mp[0].size();
int src = L + mp[1].size();
int sink = src + 1;
nodes = sink + 1;
memset(last, -1, sizeof(last));
vector<vector<bool> > vis(L, vector<bool>(mp[1].size()));
for (int i = 0; i < n; ++i) {
int x1 = v[i][0];
int y1 = v[i][1];
int x2 = v[i][2];
int y2 = v[i][3];
for (int i = x1; i <= x2; ++i)
for (int j = y1; j <= y2; ++j)
if (!vis[i][j]) {
vis[i][j] = true;
addEdge(i, j + L, 1 << 29);
}
}
for (int i = 1; i < L; ++i) addEdge(src, i, mp[0][i] - mp[0][i - 1]);
for (int i = 1; i < mp[1].size(); ++i)
addEdge(L + i, sink, mp[1][i] - mp[1][i - 1]);
cout << maxFlow(src, sink) << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
string a, d;
int b;
getline(cin >> ws, a, '.');
getline(cin >> ws, d, 'e');
cin >> b;
if (d == "0") d.pop_back();
reverse(d.begin(), d.end());
while (!d.empty() and b-- > 0) {
a += d.back();
d.pop_back();
}
while (b-- > 0) {
a += '0';
}
reverse(d.begin(), d.end());
if (d.empty()) {
cout << a << '\n';
} else {
cout << a << "." << d << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
bool f = 0;
int x = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
if (f == 1) x = -x;
return x;
}
int lowbit(int x) { return x & (-x); }
struct node {
int x, y, z, id;
} a[500005];
bool cmp(node a, node b) { return a.x > b.x; }
bool cmp1(node a, node b) { return a.y < b.y; }
int n, id, c[500005], tot = 0, ans = 0;
void add(int x, int num) {
while (x) c[x] = max(c[x], num), x -= lowbit(x);
}
int query(int x) {
int ll = -1;
while (x <= tot) ll = max(ll, c[x]), x += lowbit(x);
return ll;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i].x = read();
for (int i = 1; i <= n; i++) a[i].y = read();
for (int i = 1; i <= n; i++) a[i].z = read();
sort(a + 1, a + n + 1, cmp1);
for (int i = 1; i <= n; i++)
if (a[i].y == a[i - 1].y)
a[i].id = tot;
else
a[i].id = ++tot, c[tot] = -1;
sort(a + 1, a + n + 1, cmp);
a[n + 1].x = -1;
for (int i = 1; i <= n; i++) {
if (a[i].x != a[i + 1].x) {
for (int j = id; j <= i; j++)
if (query(a[j].id + 1) > a[j].z) ans++;
for (int j = id; j <= i; j++) add(a[j].id, a[j].z);
id = i + 1;
}
}
cout << ans;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int maxn = ((1 << 20) + 1000);
int dp[21][((1 << 20) + 1000)], n, ans, len;
int a[((1 << 20) + 1000)];
char str[21 + 10];
int main() {
scanf("%d", &n);
len = 0;
for (int i = 1; i <= n; ++i) {
scanf("%s", str);
if (len == 0) len = strlen(str);
for (int j = 0; j < len; ++j) {
a[i] = (a[i] << 1) + str[j] - '0';
}
}
ans = len;
memset(dp, 62, sizeof(dp));
dp[0][0] = 0;
for (int i = 2, j, maxx, k; i <= n; ++i) {
for (j = len; j; --j)
if ((a[i - 1] & ((1 << j) - 1)) == (a[i] >> (len - j))) break;
ans += (k = len - j), maxx = 214748364;
for (j = 0; j <= len; ++j) maxx = min(maxx, dp[len - j][a[i] >> j] + j);
for (j = 0; j <= len; ++j)
dp[j][a[i - 1] & ((1 << j) - 1)] =
min(dp[j][a[i - 1] & ((1 << j) - 1)], maxx - k);
}
int tt = 214748364;
for (int i = 0; i <= len; ++i) {
for (int j = 0; j < 1 << i; ++j) tt = min(tt, dp[i][j]);
}
cout << ans + tt << endl;
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
void test() {
int n, m;
cin >> n >> m;
int a[m];
for (int i = 0; i < m; i++) cin >> a[i];
sort(a, a + m);
int ans = a[n - 1] - a[0];
for (int i = n; i < m; i++) {
ans = min(ans, a[i] - a[i - n + 1]);
}
cout << ans << "\n";
}
int main() {
int tests = 1;
while (tests--) {
test();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
for (int i = ceil(n / 2.0); i <= n; i++) {
if (i % m == 0) {
cout << i;
return 0;
}
}
cout << "-1";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define endl '\n'
#define LL long long
#define LD long double
#define pb push_back
#define sz(a) (int)a.size()
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define debug(x) cerr << #x << " is " << x << endl;
using namespace std;
int const MAXN = 2e6 + 9;
set<pair<int,int>> have;
set<pair<int,int>> st;
int main(){
ios_base::sync_with_stdio (0),cin.tie(0);
cout.tie(0);
vector<int> out;
int q;
cin >> q;
int id = 0;
for(int i = 0; i < q; i++){
int t;
cin >> t;
if(t == 1){
int m;
cin >> m;
id++;
have.insert({id, m});
st.insert({m, -id});
}
if(t == 2){
auto x = (have.begin());
out.push_back(x->first);
have.erase(have.begin());
st.erase({x->second,-x->first});
}
if(t == 3){
auto x = st.end();
x--;
int it = -x->second;
out.push_back(it);
have.erase({-x->second,x->first});
st.erase(x);
}
}
for(auto x : out) cout << x << " ";
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, k, p;
cin >> n >> k >> p;
vector<long long> a(n);
for (auto &i : a) cin >> i;
vector<long long> b(k);
for (auto &j : b) cin >> j;
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long ans = INT_MAX;
long long curans = 0;
for (int i = 0; i <= k - n; i++) {
curans = 0;
for (int j = 0; j < n; j++)
curans = max(curans, abs(a[j] - b[i + j]) + abs(b[i + j] - p));
ans = min(ans, curans);
}
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long int n, i, j;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
long int p = 0;
long long temp;
for (i = 0, j = n - 1; i < j; i++, j--) {
if (p % 2 == 0) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
p++;
}
for (i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long d[300005], c[300005], mx[300005][19], mi[300005][19], p[300005];
long long sta[300005][2], L[300005], R[300005];
long long read() {
char c = getchar();
long long x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
long long qmx(long long l, long long r) {
long long k = (long long)floor(log(r - l + 1) / log(2));
return max(mx[l][k], mx[r - (1 << k) + 1][k]);
}
long long qmi(long long l, long long r) {
long long k = (long long)floor(log(r - l + 1) / log(2));
return min(mi[l][k], mi[r - (1 << k) + 1][k]);
}
int main() {
long long n = read(), a = read();
for (long long i = 1; i <= n; i++) {
d[i] = read();
c[i] = a - read();
}
long long ans = 0;
for (long long i = 1; i <= n; i++) ans = max(ans, c[i]);
for (long long i = 1; i <= n; i++) c[i] += c[i - 1];
for (long long i = 0; i <= n; i++) mx[i][0] = mi[i][0] = c[i];
for (long long j = 1; j <= 18; j++) {
for (long long i = 0; i + (1 << j) - 1 <= n; i++) {
mx[i][j] = max(mx[i][j - 1], mx[i + (1 << (j - 1))][j - 1]);
mi[i][j] = min(mi[i][j - 1], mi[i + (1 << (j - 1))][j - 1]);
}
}
for (long long i = 1; i < n; i++) p[i] = d[i + 1] - d[i];
long long top = 0;
for (long long i = 1; i < n; i++) {
while (top > 0 && sta[top][0] < p[i]) {
R[sta[top][1]] = i;
--top;
}
sta[++top][0] = p[i];
sta[top][1] = i;
}
while (top) R[sta[top--][1]] = n;
top = 0;
for (long long i = n - 1; i >= 1; i--) {
while (top > 0 && sta[top][0] < p[i]) {
L[sta[top][1]] = i;
--top;
}
sta[++top][0] = p[i];
sta[top][1] = i;
}
while (top) L[sta[top--][1]] = 0;
for (long long i = 1; i < n; i++) {
long long l = L[i], r = R[i];
ans = max(ans, qmx(i + 1, r) - qmi(l, i - 1) - p[i] * p[i]);
}
printf("%I64d\n", ans);
return 0;
}
| 16 |
Subsets and Splits