solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long temp;
long long dp[100001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
long long a, b, x;
cin >> a;
cin >> b;
for (int i = 0; i < n; i++) {
cin >> x;
cout << (((x % b) * (a % b)) % b) / a << " ";
}
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char buf[2048], *_s = buf + 2048;
inline char getc1(void) {
if (_s >= buf + 2048) {
fread(buf, 1, 2048, stdin);
_s = buf;
}
return *(_s++);
}
inline int readint() {
char t = getc1();
int n = 1, res = 0;
while (t != '-' && !isdigit(t)) t = getc1();
if (t == '-') {
n = -1;
t = getc1();
}
while (isdigit(t)) {
res = 10 * res + (t & 15);
t = getc1();
}
return res * n;
}
inline long long readLL() {
char t = getc1();
int n = 1;
long long res = 0;
while (t != '-' && !isdigit(t)) t = getc1();
if (t == '-') {
n = -1;
t = getc1();
}
while (isdigit(t)) {
res = 10 * res + (t & 15);
t = getc1();
}
return res * n;
}
inline char skipwhitespace() {
char ch = getc1();
while (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t') ch = getc1();
return ch;
}
inline int readline(char *s) {
char ch = skipwhitespace();
int n = 0;
while ((ch != '\n')) {
s[n++] = ch;
ch = getc1();
}
s[n] = 0;
return n;
}
inline int readstr(char *s) {
char ch = skipwhitespace();
int n = 0;
while ((ch != '\n' && ch != ' ' && ch != '\t')) {
s[n++] = ch;
ch = getc1();
}
s[n] = 0;
return n;
}
inline char readchar() { return skipwhitespace(); }
char outbuf[2048];
int outbuf_p;
inline void putc1(char ch) {
if (outbuf_p >= 2048) {
fwrite(outbuf, 1, 2048, stdout);
outbuf_p = 0;
}
outbuf[outbuf_p++] = ch;
}
inline void flush() {
fwrite(outbuf, 1, outbuf_p, stdout);
outbuf_p = 0;
}
inline void writeint(int n) {
int sign = n >= 0 ? 1 : -1;
n = n > 0 ? n : -n;
char buf[10];
int i = 9;
if (!n) buf[i--] = 48;
while (n) {
buf[i--] = n % 10 + 48;
n /= 10;
}
if (sign < 0) putc1('-');
while (++i < 10) putc1(buf[i]);
}
inline void writeLL(long long n) {
int sign = n >= 0 ? 1 : -1;
n = n > 0 ? n : -n;
char buf[25];
int i = 24;
if (!n) buf[i--] = 48;
while (n) {
buf[i--] = n % 10 + 48;
n /= 10;
}
if (sign < 0) putc1('-');
while (++i < 25) putc1(buf[i]);
}
inline void writestr(char *s) {
char *p = s;
while (*p) {
putc1(*p);
p++;
}
}
inline void writedouble(double d, int p) {
char buf[40];
sprintf(buf, "%.*f", p, d);
writestr(buf);
}
long long pow1(long long b, long long e, long long mod) {
if (e == 0) return 1;
long long ans = pow1(b, e / 2, mod);
ans = (ans * ans) % mod;
if (e & 1)
return (ans * b) % mod;
else
return ans;
}
inline long long pow(long long b, long long e, long long mod) {
if (e < 0)
return pow1(pow1(b, -e, mod), mod - 2, mod);
else
return pow1(b, e, mod);
}
int egcd(int a, int b, int &x, int &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
int x1, y1;
int d = egcd(b % a, a, x1, y1);
x = y1 - x1 * (b / a);
y = x1;
return d;
}
long long egcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = egcd(b % a, a, x1, y1);
x = y1 - x1 * (b / a);
y = x1;
return d;
}
long long inv(long long a, long long m) {
long long inv, y;
assert(egcd(a, m, inv, y) == 1);
if (inv < 0) inv += m;
return inv;
}
inline long long gcd(long long a, long long b) {
while (b) {
long long t = b;
b = a % b;
a = t;
}
return a;
}
vector<int> getfactors(int n) {
vector<int> f;
for (int a = 2; a * a <= n; a++) {
int p = 1;
while (n % a == 0) {
n /= a;
p *= a;
}
if (p > 1) f.push_back(p);
}
return f;
}
inline int getbit(long long n, int i) { return n & (1 << i); }
struct v {
int x1, y1, x2, y2;
};
int main() {
int n;
scanf("%d", &n);
int sum = 0;
v ar[n];
int row = 0, col = 0;
for (int a = 0; a < n; a++) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
ar[a].x1 = x1;
ar[a].y1 = y1;
ar[a].x2 = x2;
ar[a].y2 = y2;
row = max(row, max(x1, x2));
col = max(col, max(y1, y2));
}
for (int a = 1; a <= row; a++) {
for (int b = 1; b <= col; b++) {
for (v i : ar) {
if (a >= i.x1 and a <= i.x2 and b >= i.y1 and b <= i.y2) sum++;
}
}
}
printf("%d\n", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const long long mod = 1e9 + 7;
int n;
long long value[MAXN];
vector<int> graph[MAXN];
long long pathSum, pathCnt;
long long currSum, currCnt;
bool isCentroid[MAXN];
int treeSize[MAXN];
long long answer = 0;
long long cnt[MAXN], sum[MAXN];
void DFSInit(int x, int last) {
treeSize[x] = 1;
for (int i = 0; i < graph[x].size(); i++) {
if (graph[x][i] == last || isCentroid[graph[x][i]] == true) continue;
DFSInit(graph[x][i], x);
treeSize[x] += treeSize[graph[x][i]];
}
}
int findCentroid(int root) {
int last = root;
int centroid = root;
DFSInit(root, -1);
while (true) {
bool found = false;
for (int i = 0; i < graph[centroid].size(); i++) {
if (isCentroid[graph[centroid][i]] == false &&
treeSize[graph[centroid][i]] > treeSize[root] / 2 &&
graph[centroid][i] != last) {
found = true;
last = centroid;
centroid = graph[centroid][i];
break;
}
}
if (found == false) {
break;
}
}
return centroid;
}
void DFSLoad(int x, int last, long long sum, int depth, bool mode) {
if (isCentroid[x] == true) return;
sum = (sum + ((depth % 2 == 1) ? value[x] : -value[x]) + mod) % mod;
if (mode == false) {
answer = (answer + sum) % mod;
pathCnt++;
pathSum = (pathSum + sum) % mod;
}
currCnt++;
currSum = (currSum + sum) % mod;
for (int i = 0; i < graph[x].size(); i++) {
if (graph[x][i] == last) continue;
DFSLoad(graph[x][i], x, sum, depth + 1, mode);
}
}
void DFSCalc(int x, int last, long long sum, int depth, int centroid) {
if (isCentroid[x] == true) return;
if (depth != 1) {
answer =
(answer + sum +
((depth % 2 == 0) ? -value[centroid] : value[centroid]) + 2 * mod) %
mod;
if (depth % 2 == 0) {
answer = (answer + sum * (pathCnt) % mod - pathSum + 2 * mod) % mod;
} else {
answer = (answer + sum * (pathCnt) % mod + pathSum) % mod;
}
}
for (int i = 0; i < graph[x].size(); i++) {
if (graph[x][i] == last) continue;
DFSCalc(graph[x][i], x, (-sum + value[graph[x][i]] + mod) % mod, depth + 1,
centroid);
}
}
void solve(int root) {
int centroid = findCentroid(root);
pathSum = 0;
pathCnt = 0;
for (int i = 0; i < graph[centroid].size(); i++) {
if (isCentroid[graph[centroid][i]] == true) continue;
currCnt = 0;
currSum = 0;
DFSLoad(graph[centroid][i], centroid, value[centroid], 2, false);
cnt[graph[centroid][i]] = currCnt;
sum[graph[centroid][i]] = currSum;
}
for (int i = 0; i < graph[centroid].size(); i++) {
if (isCentroid[graph[centroid][i]] == true) continue;
pathCnt -= cnt[graph[centroid][i]];
pathSum -= sum[graph[centroid][i]];
pathCnt = (pathCnt + mod) % mod;
pathSum = (pathSum + mod) % mod;
DFSCalc(graph[centroid][i], centroid, value[graph[centroid][i]], 2,
centroid);
pathCnt += cnt[graph[centroid][i]];
pathSum += sum[graph[centroid][i]];
pathCnt = (pathCnt + mod) % mod;
pathSum = (pathSum + mod) % mod;
}
isCentroid[centroid] = true;
for (int i = 0; i < graph[centroid].size(); i++) {
if (isCentroid[graph[centroid][i]] == false) {
solve(graph[centroid][i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> value[i];
value[i] = (value[i] + mod) % mod;
answer = (answer + value[i]) % mod;
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
solve(3);
cout << answer % mod << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, a[26] = {0}, b[100005];
string s, ans;
cin >> n;
cin >> s;
for (i = 0; i < s.length(); i++) {
a[s[i] - 'a']++;
}
j = 0;
for (i = 0; i < a['n' - 'a']; i++) {
b[j++] = 1;
}
for (i = 0; i < a['z' - 'a']; i++) {
b[j++] = 0;
}
for (i = 0; i < j; i++) {
cout << b[i] << " ";
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000100;
int n;
int a[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
long long res = 0;
for (int i = 0; i < n / 2; i++) {
res += (long long)(a[i] + a[n - i - 1]) * (a[i] + a[n - i - 1]);
}
cout << res;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int k = 0;
int s = 0;
int a[x];
for (int i = 0; i < x; i++) {
cin >> a[i];
if (a[i] < 0) {
k++;
}
s = s + a[i];
}
if (k == y) {
int m = 0;
for (int i = 0; i < x; i++) {
m = m + abs(a[i]);
}
cout << m;
} else if (k > y) {
for (int i = 0; i < y; i++) {
s = s + 2 * abs((a[i]));
}
cout << s;
} else if (k < y) {
for (int i = 0; i < k; i++) {
a[i] = a[i] * -1;
s = s + 2 * abs((a[i]));
}
sort(a, a + x);
if ((k - y) % 2 == 0) {
cout << s;
} else {
cout << s - 2 * a[0];
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
sort(s.begin(), s.end());
if (s[k - 1] != s[0]) {
cout << s[k - 1] << endl;
} else {
if (s[k] == s[n - 1]) {
cout << s[0];
for (int i = 1; i < (n + k - 1) / k; i++) cout << s[k];
cout << endl;
} else {
cout << s[0];
cout << s.substr(k);
cout << endl;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, dr, st, i, p;
int main() {
cin >> n >> m >> k;
if (n == 1)
cout << m;
else if (n == m)
cout << "1";
else {
p = m - n;
i = 1;
dr = k;
st = k;
while (p > 0) {
if (dr - st + 1 <= p) {
i++;
p -= dr - st + 1;
if (dr < n) dr++;
if (st > 1) st--;
} else
p -= p;
}
cout << i;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, ans = "";
cin >> a >> b;
for (int i = 0; i < a.length(); i++) ans += (a[i] == b[i] ? '0' : '1');
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
const int mod = 1e9 + 7, mxn = 2e5 + 1;
int n, m;
vector<int> v[mxn], match(mxn), dist(mxn);
bool bfs() {
int i, u, x, len;
queue<int> Q;
for (i = 1; i <= n; i++) {
if (match[i] == 0) {
dist[i] = 0;
Q.push(i);
} else
dist[i] = mxn;
}
dist[0] = mxn;
while (!Q.empty()) {
u = Q.front();
Q.pop();
if (u != 0) {
len = v[u].size();
for (i = 0; i < len; i++) {
x = v[u][i];
if (dist[match[x]] == mxn) {
dist[match[x]] = dist[u] + 1;
Q.push(match[x]);
}
}
}
}
return (dist[0] != mxn);
}
bool dfs(int u) {
int i, x, len;
if (u != 0) {
len = v[u].size();
for (i = 0; i < len; i++) {
x = v[u][i];
if (dist[match[x]] == dist[u] + 1) {
if (dfs(match[x])) {
match[x] = u;
match[u] = x;
return true;
}
}
}
dist[u] = mxn;
return false;
}
return true;
}
int hopcroft_karp() {
int matching = 0, i;
while (bfs())
for (i = 1; i <= n; i++)
if (match[i] == 0 and dfs(i)) matching++;
return matching;
}
int solve() {
cin >> n >> m;
vector<pair<int, pair<int, int>>> vp(m);
for (long long i = (0); i < (m); ++i)
cin >> vp[i].first >> vp[i].second.first >> vp[i].second.second;
int l = 0, r = mod;
while (l < r) {
int mid = (l + r) / 2;
for (long long i = (0); i < (mxn); ++i)
match[i] = 0, dist[i] = 0, v[i].clear();
for (long long i = (0); i < (m); ++i) {
if (vp[i].second.second <= mid) {
v[vp[i].first].push_back(n + vp[i].second.first);
v[n + vp[i].second.first].push_back(vp[i].first);
}
}
int matching = hopcroft_karp();
if (matching == n)
r = mid;
else
l = mid + 1;
}
if (l == mod) l = -1;
cout << l << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, k;
int x, y, z;
cin >> n;
while (n--) {
k = 0;
cin >> x >> y >> z;
cout << max(0, min(z + 1, (x + z + 1 - y) / 2)) << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int adj[1007][1007];
int step[1007];
int n, m;
void BFS(int k) {
queue<int> q;
q.push(1);
step[1] = 1;
while (q.size()) {
int u = q.front();
q.pop();
for (int v = (1); v <= (n); ++v) {
if (adj[u][v] == k && !step[v]) {
step[v] = step[u] + 1;
q.push(v);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (m); ++i) {
int u, v;
scanf("%d%d", &u, &v);
adj[u][v] = adj[v][u] = 1;
}
if (adj[1][n])
BFS(0);
else
BFS(1);
if (!step[n])
puts("-1");
else
printf("%d\n", step[n] - 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int q;
int par[1000100][20];
int cnt[1000100];
int k1, k2, k3;
int lca(int a, int b) {
int aa = a, bb = b;
if (cnt[a] < cnt[b]) swap(a, b);
int d = cnt[a] - cnt[b];
for (int i = 0; d; i++, d >>= 1) {
if (d & 1) a = par[a][i];
}
for (int i = 19; i >= 0; i--) {
if (par[a][i] != par[b][i]) {
a = par[a][i];
b = par[b][i];
}
}
int tmp = a;
if (a != b) tmp = par[tmp][0];
return cnt[aa] + cnt[bb] - 2 * cnt[tmp];
}
int main() {
cin >> q;
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 4; j++) par[j][i] = 0;
}
cnt[1] = 1;
cnt[2] = 1;
cnt[3] = 1;
k1 = 1;
k2 = 2;
int n = 4;
int m = 2;
for (int i = 0; i < q; i++) {
int v;
scanf("%d", &v);
v--;
int tmp = lca(v, k1);
int t = k1;
int tmp2 = lca(v, k2);
if (tmp2 > tmp) {
t = k2;
tmp = tmp2;
}
par[n][0] = par[n + 1][0] = v;
for (int i = 1; i < 20; i++) {
par[n][i] = par[n + 1][i] = par[par[n][i - 1]][i - 1];
}
cnt[n] = cnt[n + 1] = cnt[v] + 1;
n += 2;
if (tmp + 1 > m) {
m = tmp + 1;
k1 = n - 1;
k2 = t;
}
cout << m << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int spf[1000001];
void sieve1() {
spf[1] = 1;
for (int i = 2; i < 1000001; i++) spf[i] = i;
for (int i = 4; i < 1000001; i += 2) spf[i] = 2;
for (int i = 3; i * i < 1000001; i++) {
if (spf[i] == i) {
for (int j = i * i; j < 1000001; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
long long int getFactorization(int x) {
vector<int> ret;
long long int p = 0;
while (x != 1) {
ret.push_back(spf[x]);
x = x / spf[x];
}
sort(ret.begin(), ret.end());
for (int i = 0; i < ret.size() - 1; i++) {
if (ret[i] != ret[i + 1]) p = p + ret[i];
}
p = p + ret[ret.size() - 1];
return p;
}
long long int d[1000055], u = 0;
void Sieve(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * 2; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p]) {
d[u] = p;
u++;
}
}
long long int minverse(long long int x, long long int n, long long int M) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return minverse((x * x) % M, n / 2, M);
else
return (x * minverse((x * x) % M, (n - 1) / 2, M)) % M;
}
long long int prime(long long int n) {
long long int i;
if (n == 1 || n == 0) return 0;
for (i = 2; i < sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
map<long long int, long long int> mp;
long long int a[30], i;
for (i = 1; i <= 30; i++) {
a[i - 1] = pow(2, i) - 1;
mp[a[i - 1]] = 1;
}
long long int x;
cin >> x;
long long int c = 0;
vector<long long int> v;
while (1) {
if (mp[x] == 1) break;
if (c % 2 == 0) {
long long int p = x;
long long int u = 0, u1, j = 0;
while (p > 0) {
j++;
if (p % 2 == 0) u = j;
p /= 2;
}
u1 = pow(2, u) - 1;
x ^= u1;
v.push_back(u);
} else
x++;
c++;
}
if (c == 0)
cout << 0 << endl;
else {
cout << c << endl;
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int n, m, q, curcol, col[100010], depth[100010], val[100010], sum[100010],
par[20][100010], parr[100010];
bool vis[100010];
vector<int> g[100010];
int FIND(int pos) {
if (parr[pos] != pos) parr[pos] = FIND(parr[pos]);
return parr[pos];
}
void dfs(int pos, int no, int d) {
vis[pos] = true;
col[pos] = curcol;
par[0][pos] = no;
depth[pos] = d;
for (int i = 0; i < g[pos].size(); i++) {
if (g[pos][i] == no) continue;
if (vis[g[pos][i]]) {
if (depth[pos] > depth[g[pos][i]] + 1) {
if ((depth[pos] - depth[g[pos][i]]) % 2 == 0) val[pos] = 1;
for (int j = FIND(pos); depth[j] > depth[g[pos][i]] + 1; j = FIND(j))
parr[j] = par[0][j];
}
continue;
}
dfs(g[pos][i], pos, d + 1);
if (FIND(pos) == FIND(g[pos][i])) val[pos] |= val[g[pos][i]];
}
}
void dfs2(int pos) {
sum[pos] += val[pos];
for (int i = 0; i < g[pos].size(); i++) {
if (depth[g[pos][i]] != depth[pos] + 1) continue;
if (FIND(pos) == FIND(g[pos][i])) val[g[pos][i]] |= val[pos];
sum[g[pos][i]] = sum[pos];
dfs2(g[pos][i]);
}
}
int lca(int pos, int pos2) {
if (depth[pos] < depth[pos2]) swap(pos, pos2);
for (int i = 18; i >= 0; i--)
if (depth[pos] - (int)pow(2, i) >= depth[pos2]) pos = par[i][pos];
for (int i = 18; i >= 0; i--) {
if (par[i][pos] != par[i][pos2]) {
pos = par[i][pos];
pos2 = par[i][pos2];
}
}
if (pos == pos2) return pos;
return par[0][pos];
}
int main() {
cin >> n >> m;
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) parr[i] = i;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
curcol = i;
dfs(i, 0, 0);
dfs2(i);
}
for (int i = 0; i < 18; i++) {
for (int j = 1; j <= n; j++) {
if (par[i][j] == 0) continue;
par[i + 1][j] = par[i][par[i][j]];
}
}
cin >> q;
for (int qn = 0; qn < q; qn++) {
scanf("%d%d", &x, &y);
int z = lca(x, y);
if (z == 0)
puts("No");
else {
if ((depth[x] - depth[z] + depth[y] - depth[z]) % 2 == 1 ||
sum[x] + sum[y] - sum[z] * 2 > 0)
puts("Yes");
else
puts("No");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
int a[n + 5][m + 5];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a[i][j] = 0;
}
}
int num1 = 0, num2 = 0, num = n * m / 2, t = 1;
if (n % 2 == 0) {
for (int i = 1; i + 1 <= m; i += 2) {
for (int j = 1; j <= n; j++) {
if (k == 0) {
break;
i = m + 1;
} else {
while (a[j - 1][i] == t || a[j - 1][i + 1] == t ||
a[j + 1][i] == t || a[j + 1][i + 1] == t ||
a[j][i - 1] == t || a[j][i + 2] == t)
t = t % 26 + 1;
a[j][i] = t;
a[j][i + 1] = t;
k--;
num--;
}
}
}
for (int i = 1; i < n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 0 && a[i + 1][j] == 0) {
while (a[i - 1][j] == t || a[i + 2][j] == t ||
a[i + 1][j - 1] == t || a[i + 1][j + 1] == t ||
a[i][j - 1] == t || a[i][j + 1] == t)
t = t % 26 + 1;
a[i][j] = t;
a[i + 1][j] = t;
num--;
}
}
}
if (num <= 0 && k == 0) {
puts("YES");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%c", 'a' + a[i][j] - 1);
}
puts("");
}
} else
puts("NO");
} else {
t = 1;
for (int i = 1; i + 1 <= m; i += 2) {
a[1][i] = t, a[1][i + 1] = t, k--, num--;
t = t % 26 + 1;
}
for (int i = 1; i + 1 <= m; i += 2) {
for (int j = 2; j <= n; j++) {
if (k == 0) {
break;
i = m + 1;
} else {
while (a[j - 1][i] == t || a[j - 1][i + 1] == t ||
a[j + 1][i] == t || a[j + 1][i + 1] == t ||
a[j][i - 1] == t || a[j][i + 2] == t)
t = t % 26 + 1;
a[j][i] = t;
a[j][i + 1] = t;
k--;
num--;
}
}
}
for (int i = 1; i < n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 0 && a[i + 1][j] == 0) {
while (a[i - 1][j] == t || a[i + 2][j] == t ||
a[i + 1][j - 1] == t || a[i + 1][j + 1] == t ||
a[i][j - 1] == t || a[i][j + 1] == t)
t = t % 26 + 1;
a[i][j] = t;
a[i + 1][j] = t;
num--;
}
}
}
if (num <= 0 && k == 0) {
puts("YES");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%c", 'a' + a[i][j] - 1);
}
puts("");
}
} else
puts("NO");
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
int x, y;
cin >> n >> m >> x >> y;
cout << x << " " << y << "\n";
cout << 1 << " " << y << "\n";
vector<pair<int, int>> v;
int z = 1;
for (int i = 1; i <= n; i++) {
vector<pair<int, int>> te;
for (int j = 1; j <= m; j++) {
te.push_back({i, j});
}
if (z == 0) {
reverse(te.begin(), te.end());
}
z ^= 1;
for (auto it : te) {
v.push_back({it.first, it.second});
}
}
for (auto it : v) {
if ((it.first == x && it.second == y) || (it.first == 1 && it.second == y))
continue;
cout << it.first << " " << it.second << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool get_int(T &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-' && t != EOF; t = getchar())
;
if (t == '-') neg = true, t = getchar();
if (t == EOF) return false;
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
return true;
}
template <typename T>
void print_int(T x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
const int maxn = 200111;
int lg[maxn];
struct arithseq {
int st, ed, diff;
arithseq() {}
arithseq(int a, int b, int c) {
st = a;
ed = b;
diff = c;
}
arithseq shift(const int &x) const { return arithseq(st + x, ed + x, diff); }
arithseq neg() const { return arithseq(-ed, -st, diff); }
bool have(const int &x) const {
return (x >= st && x <= ed && (st - x) % diff == 0);
}
};
int un(const arithseq &a, const arithseq &b) {
if (a.diff != b.diff) {
int ret = 0;
if ((a.ed - a.st) <= (a.diff << 1)) {
for (int i = a.st; i <= a.ed; i += a.diff)
if (b.have(i)) return 1;
} else if ((b.ed - b.st) <= (b.diff << 1)) {
for (int i = b.st; i <= b.ed; i += b.diff)
if (a.have(i)) return 1;
} else {
puts("baojing");
}
return ret;
} else if ((b.st - a.st) % a.diff)
return 0;
else
return (min(a.ed, b.ed) - max(a.st, b.st)) / a.diff + 1;
}
struct IPM {
int sa[maxn], rk[maxn], nrk[maxn], c[maxn], n;
int v[20][maxn];
int id[20][maxn], mxl;
vector<int> sq[20 * maxn];
void construct(char *s) {
n = strlen(s) + 1;
int m = 256;
int *x = rk, *y = nrk;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[i] = s[i]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
int tot = 0;
mxl = 0;
for (int k = 1; k <= n; k <<= 1) {
for (int i = 0, nxt = 0; i < n; i = nxt) {
for (; nxt < n && x[sa[i]] == x[sa[nxt]]; nxt++)
;
tot++;
sq[tot].clear();
for (int j = i; j < nxt; j++) {
sq[tot].push_back(sa[j]);
id[lg[k]][sa[j]] = tot;
}
sort(sq[tot].begin(), sq[tot].end());
}
mxl = k;
int p = 0;
for (int i = n - k; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[y[i]]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
swap(x, y);
x[sa[0]] = 0;
p = 1;
for (int i = 1; i < n; i++)
x[sa[i]] =
(y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k])
? p - 1
: p++;
if (p >= n) break;
m = p;
}
int k = 0;
for (int i = 0; i < n; i++) rk[sa[i]] = i;
for (int i = 0; i < n - 1; i++) {
if (k) k--;
int j = sa[rk[i] - 1];
while (s[i + k] == s[j + k]) k++;
v[0][rk[i]] = k;
}
for (int i = 1; i < 20; i++) {
for (int j = 2; j < n; j++) {
int nxt = j + (1 << i - 1);
if (nxt >= n)
v[i][j] = v[i - 1][j];
else
v[i][j] = min(v[i - 1][j], v[i - 1][nxt]);
}
}
}
int qlcp(int l, int r) {
if (l == r) return n - l;
l = rk[l];
r = rk[r];
if (l > r) swap(l, r);
l++;
int t = lg[r - l + 1];
return min(v[t][l], v[t][r - (1 << t) + 1]);
}
int pred(int l, int k, int pos) {
if (k > mxl) {
if (pos >= l)
return l;
else
return -1;
}
vector<int> &v = sq[id[lg[k]][l]];
int id = upper_bound(v.begin(), v.end(), pos) - v.begin();
if (id)
return v[id - 1];
else
return -1;
}
int succ(int l, int k, int pos) {
if (k > mxl) {
if (pos <= l)
return l;
else
return -1;
}
vector<int> &v = sq[id[lg[k]][l]];
int id = lower_bound(v.begin(), v.end(), pos) - v.begin();
if (id < (int)v.size())
return v[id];
else
return -1;
}
int get_border(int l, int r) {
int len = r - l + 1, l1, l2, l3, r1, r2, r3;
for (int k = 1; k < len; k <<= 1) {
int tl = l, tr = r - k + 1;
l1 = succ(tr, k, tl);
if (l1 == -1 || l1 >= l + k || l1 >= r) continue;
r1 = pred(tl, k, tr);
if (r1 == -1 || r1 <= tr - k || r1 <= l) continue;
l2 = succ(tr, k, l1 + 1);
l3 = pred(tr, k, l + k - 1);
r2 = pred(tl, k, r1 - 1);
r3 = succ(tl, k, max(l + 1, tr - k + 1));
arithseq k1, k2;
if (l2 != -1)
k1 = arithseq(l1 - l, l3 - l, l2 - l1);
else
k1 = arithseq(l1 - l, l1 - l, 1);
if (r2 != -1)
k2 = arithseq(tr - r1, tr - r3, r1 - r2);
else
k2 = arithseq(tr - r1, tr - r1, 1);
if (un(k1, k2)) return 1;
}
return 0;
}
} thor;
struct suffix {
int sa[maxn], rk[maxn], nrk[maxn], c[maxn], n;
int v[20][maxn];
void construct(char *s) {
n = strlen(s) + 1;
int m = 256;
int *x = rk, *y = nrk;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[i] = s[i]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
for (int k = 1; k <= n; k <<= 1) {
int p = 0;
for (int i = n - k; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[y[i]]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
swap(x, y);
x[sa[0]] = 0;
p = 1;
for (int i = 1; i < n; i++)
x[sa[i]] =
(y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k])
? p - 1
: p++;
if (p >= n) break;
m = p;
}
int k = 0;
for (int i = 0; i < n; i++) rk[sa[i]] = i;
for (int i = 0; i < n - 1; i++) {
if (k) k--;
int j = sa[rk[i] - 1];
while (s[i + k] == s[j + k]) k++;
v[0][rk[i]] = k;
}
for (int i = 1; i < 20; i++) {
for (int j = 2; j < n; j++) {
int nxt = j + (1 << i - 1);
if (nxt >= n)
v[i][j] = v[i - 1][j];
else
v[i][j] = min(v[i - 1][j], v[i - 1][nxt]);
}
}
}
int qlcp(int l, int r) {
if (l == r) return n - l;
l = rk[l];
r = rk[r];
if (l > r) swap(l, r);
l++;
int t = lg[r - l + 1];
return min(v[t][l], v[t][r - (1 << t) + 1]);
}
} loki;
char s[maxn];
int n, q, sum[maxn][26], v[20][maxn];
struct solver {
int f[maxn], a[maxn];
void prework(int coef) {
for (int i = 1; i <= n; i++) {
f[i] = i;
a[i] = (coef == 1 ? inf : -inf);
}
}
int gf(int x) { return x == f[x] ? x : f[x] = gf(f[x]); }
void modify(int l, int r, int v) {
while (true) {
l = gf(l);
if (l && l <= r) {
a[l] = l + v;
f[l] = l + 1;
} else
break;
}
}
void construct() {
for (int i = 1; i <= n; i++) v[0][i] = a[i];
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= n; j++) {
int nxt = j + (1 << i - 1);
if (nxt <= n)
v[i][j] = min(v[i - 1][j], v[i - 1][nxt]);
else
v[i][j] = v[i - 1][j];
}
}
}
};
solver mnl, mnr;
int query(int l, int r) {
int t = lg[r - l + 1];
return min(v[t][l], v[t][r - (1 << t) + 1]);
}
int lcp(int a, int b) { return thor.qlcp(a - 1, b - 1); }
int lcs(int a, int b) { return loki.qlcp(n - a, n - b); }
vector<int> pr[maxn];
bool per(int l, int r) {
int len = r - l + 1;
for (int i = 0; i < (int)pr[len].size(); i++) {
if (lcp(l, l + len / pr[len][i]) + len / pr[len][i] >= len) return true;
}
return false;
}
int main() {
for (int i = 2; i < maxn; i++) {
lg[i] = lg[i >> 1] + 1;
if (pr[i].size() == 0) {
for (int j = i; j < maxn; j += i) pr[j].push_back(i);
}
}
scanf("%d%s", &n, s + 1);
thor.construct(s + 1);
reverse(s + 1, s + n + 1);
loki.construct(s + 1);
reverse(s + 1, s + n + 1);
for (int i = 1; i <= n; i++) {
memcpy(sum[i], sum[i - 1], sizeof(sum[i]));
sum[i][s[i] - 'a']++;
}
mnl.prework(1);
mnr.prework(-1);
for (int len = 1; len + len <= n; len++) {
for (int i = len; i + len <= n; i += len) {
int j = i + len, l1 = lcs(i, j), l2 = lcp(i + 1, j + 1);
if (l1 + l2 < len || l1 == 0) continue;
int l = i - min(len, l1) + 1, r = i - max(1, len - l2) + 1;
mnl.modify(l, r, len + len - 1);
mnr.modify(l + len + len - 1, r + len + len - 1, -len - len + 1);
}
}
mnl.construct();
get_int(q);
for (int i = 1, l, r; i <= q; i++) {
(get_int(l) && get_int(r));
int ans = -1;
for (int j = 0; j < 26 && ans == -1; j++)
if (sum[r][j] - sum[l - 1][j] > 1) ans = 0;
if (ans == -1)
puts("-1");
else if (per(l, r))
puts("1");
else if (mnl.a[l] < r || mnr.a[r] > l || thor.get_border(l - 1, r - 1))
puts("2");
else if (sum[r][s[l] - 'a'] > sum[l][s[l] - 'a'] ||
sum[r - 1][s[r] - 'a'] > sum[l - 1][s[r] - 'a'] ||
query(l, r) <= r)
puts("3");
else
puts("4");
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
int x, y;
pt(int x = 0, int y = 0) : x(x), y(y) {}
} v[200100];
bool cmp(pt a, pt b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
int main() {
int n, k;
while (scanf("%d%d", &n, &k) == 2) {
for (int i = 0; i < (int)(n); i++) scanf("%d%d", &v[i].x, &v[i].y);
sort(v, v + n, cmp);
if (n == k) {
printf("-1\n");
continue;
}
vector<pair<int, int> > vres;
for (int ia = 0; ia < min(n, k + 1); ia++)
for (int ib = 0; ib + ia < min(n, k + 1); ib++) {
int qi = ia + ib, a = v[ia].x + v[n - ib - 1].x,
b = v[ia].y + v[n - ib - 1].y;
int i, j;
for (i = ia + 1, j = n - ib - 2; i <= j;) {
pt pa = pt(v[i].x + v[j].x, v[i].y + v[j].y);
pt pb = pt(a, b);
if (i == j) {
if (a != 2 * v[i].x || b != 2 * v[i].y) qi++;
break;
}
if (!cmp(pa, pb) && !cmp(pb, pa)) {
i++;
j--;
} else if (cmp(pa, pb))
i++, qi++;
else
j--, qi++;
}
if (qi <= k) vres.push_back(pair<int, int>(a, b));
}
sort(vres.begin(), vres.end());
vres.resize(unique(vres.begin(), vres.end()) - vres.begin());
printf("%d\n", (int)vres.size());
for (int i = 0; i < (int)(vres.size()); i++)
printf("%.1lf %.1lf\n", vres[i].first / 2.0, vres[i].second / 2.0);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct AC {
static const int MAX_N = 1e3 + 3;
int n;
int W[MAX_N][MAX_N];
vector<int> G[MAX_N];
vector<pair<int, int>> NG[MAX_N];
vector<tuple<int, int, int>> ans;
int root;
void add_edge(int u, int v, int w) {
G[u].emplace_back(v);
G[v].emplace_back(u);
W[u][v] = W[v][u] = w;
}
bool valid() {
for (int i = 1; i <= n; i++)
if (G[i].size() == 2)
if (W[i][G[i][0]] != W[i][G[i][1]]) return false;
return true;
}
void merge(int u, int v, int w) {
ans.emplace_back(root, v, w);
ans.emplace_back(root, u, -w);
}
void dfs(int pa, int now) {
if (G[now].size() == 1) {
NG[pa].emplace_back(now, W[pa][now]);
return;
}
vector<pair<int, int>>& edge = NG[now];
for (auto i : G[now])
if (i != pa) dfs(now, i);
while (edge.size() != 2) {
merge(edge[0].first, edge.back().first, edge.back().second);
edge[0].second += edge.back().second;
edge.pop_back();
}
if (edge.size() == 2) {
int d = (W[pa][now] - edge[0].second - edge[1].second) / 2;
ans.emplace_back(edge[0].first, edge[1].first, -d);
edge[0].second += d;
edge[1].second += d;
merge(edge[0].first, edge[1].first, edge[1].second);
edge[0].second += edge[1].second;
edge.pop_back();
}
NG[pa].emplace_back(edge[0]);
}
void solve() {
if (!valid()) {
cout << "NO\n";
return;
}
cout << "YES\n";
for (root = 1; G[root].size() != 1; root++)
;
dfs(root, G[root][0]);
for (auto i : NG[root]) ans.emplace_back(root, i.first, i.second);
}
void print() {
if (ans.size() == 0) return;
cout << ans.size() << '\n';
for (auto& [u, v, w] : ans) cout << u << ' ' << v << ' ' << w << " \n";
}
} solver;
int n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
solver.n = n;
for (int i = 0, t1, t2, t3; i < n - 1; i++) {
cin >> t1 >> t2 >> t3;
solver.add_edge(t1, t2, t3);
}
solver.solve();
solver.print();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int H, W;
int L[20], R[20];
int dp[20][2];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> H >> W;
W += 2;
int last = -1;
for (y = 0; y < (H); y++) {
cin >> s;
L[H - 1 - y] = R[H - 1 - y] = -1;
for (x = 0; x < (W); x++)
if (s[x] == '1') {
if (L[H - 1 - y] == -1) L[H - 1 - y] = x;
R[H - 1 - y] = x;
}
if (L[H - 1 - y] >= 0) last = max(H - 1 - y, last);
}
if (last == -1) return (void)printf("0\n");
if (last == 0) return (void)printf("%d\n", R[0]);
if (L[0] == -1) {
dp[0][0] = 0;
dp[0][1] = W - 1;
} else {
dp[0][0] = R[0] * 2;
dp[0][1] = W - 1;
}
for (y = 1; y < last; y++) {
dp[y][0] = min(dp[y - 1][0] + 1 + ((L[y] == -1) ? 0 : R[y] * 2),
dp[y - 1][1] + 1 + (W - 1));
dp[y][1] = min(dp[y - 1][1] + 1 + ((L[y] == -1) ? 0 : (W - 1 - L[y]) * 2),
dp[y - 1][0] + 1 + (W - 1));
}
int ret = min(dp[y - 1][0] + 1 + R[y], dp[y - 1][1] + 1 + (W - 1 - L[y]));
cout << ret << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct sofa {
int x1, y1, x2, y2;
};
sofa arr[100005];
int lof[100005];
int rof[100005];
int tof[100005];
int bof[100005];
int main() {
int d;
int n, m;
cin >> d;
cin >> n >> m;
for (int i = 0; i < 1e5; i++) {
lof[i] = rof[i] = tof[i] = bof[i] = 0;
}
for (int i = 0; i < d; i++) {
cin >> arr[i].x1 >> arr[i].y1 >> arr[i].x2 >> arr[i].y2;
lof[min(arr[i].x1, arr[i].x2)]++;
rof[max(arr[i].x1, arr[i].x2)]++;
tof[min(arr[i].y1, arr[i].y2)]++;
bof[max(arr[i].y1, arr[i].y2)]++;
}
for (int i = 0; i < 1e5; i++) {
lof[i] += lof[i - 1];
tof[i] += tof[i - 1];
}
for (int i = 1e5 - 1; i >= 0; i--) {
rof[i] += rof[i + 1];
bof[i] += bof[i + 1];
}
int cntl, cntr, cntt, cntb;
cin >> cntl >> cntr >> cntt >> cntb;
for (int i = 0; i < d; i++) {
int checks = 0;
if (arr[i].x1 != arr[i].x2) {
if (lof[max(arr[i].x1, arr[i].x2) - 1] == cntl + 1) checks++;
} else if (lof[max(arr[i].x1, arr[i].x2) - 1] == cntl)
checks++;
if (arr[i].x1 != arr[i].x2) {
if (rof[min(arr[i].x1, arr[i].x2) + 1] == cntr + 1) checks++;
} else if (rof[min(arr[i].x1, arr[i].x2) + 1] == cntr)
checks++;
if (arr[i].y1 != arr[i].y2) {
if (bof[min(arr[i].y1, arr[i].y2) + 1] == cntb + 1) checks++;
} else if (bof[min(arr[i].y1, arr[i].y2) + 1] == cntb)
checks++;
if (arr[i].y1 != arr[i].y2) {
if (tof[max(arr[i].y1, arr[i].y2) - 1] == cntt + 1) checks++;
} else if (tof[max(arr[i].y1, arr[i].y2) - 1] == cntt)
checks++;
if (checks == 4) {
cout << i + 1;
return 0;
}
}
cout << -1 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[3], cnt = 0;
for (long long i = 0; i < 3; i++) cin >> a[i];
long long meals = max(a[0], max(a[1], a[2]));
for (long long i = 0; i < 3; i++) {
if (a[i] == meals) continue;
if ((meals - 1) - a[i] > 0) cnt += (meals - 1) - a[i];
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 5;
const int LOG = 20;
int n, m, len, tot;
int head[MAXN], root[MAXN], vis[MAXN], son[MAXN], size[MAXN], dep[MAXN],
f[MAXN][LOG], ans[MAXN], cnt[MAXN];
struct Edge {
int to, next;
} e[MAXN << 1];
struct Query {
int x, id;
};
vector<Query> vec[MAXN];
void add(int u, int v) {
e[++len].to = v;
e[len].next = head[u];
head[u] = len;
}
void dfs(int u, int fa, int d) {
dep[u] = d;
f[u][0] = fa;
for (int i = 1; i < LOG; i++) f[u][i] = f[f[u][i - 1]][i - 1];
size[u] = 1;
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
dfs(v, u, d + 1);
size[u] += size[v];
if (size[v] > size[son[u]]) son[u] = v;
}
}
void Calc(int u, int fa, int val) {
cnt[dep[u]] += val;
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].to;
if (v == fa || vis[v]) continue;
Calc(v, u, val);
}
}
void Dsu(int u, int fa, int flag) {
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].to;
if (v == fa || v == son[u]) continue;
Dsu(v, u, 0);
}
if (son[u]) {
Dsu(son[u], u, 1);
vis[son[u]] = 1;
}
Calc(u, fa, 1);
for (int i = 0; i < (int)vec[u].size(); i++)
ans[vec[u][i].id] = cnt[vec[u][i].x] - 1;
vis[son[u]] = 0;
if (!flag) Calc(u, fa, -1);
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x)
add(x, i);
else
root[++tot] = i;
}
for (int i = 1; i <= tot; i++) dfs(root[i], 0, 1);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, k;
scanf("%d%d", &x, &k);
int d = dep[x];
for (int i = LOG - 1; i >= 0; i--) {
if (k & (1 << i)) x = f[x][i];
}
vec[x].push_back((Query){d, i});
}
for (int i = 1; i <= tot; i++) Dsu(root[i], 0, 0);
for (int i = 1; i <= m; i++) printf("%d ", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int n, m, t;
int xl[100], yl[100], xr[100], yr[100], nt, area[100];
char s[1100][1100];
int lt[1100][1100];
int up[1100][1100];
int dw[1100][1100];
int p[1100][1100];
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
bool used[1100][1100];
bool val(int x, int y) { return (0 <= x && x < n && 0 <= y && y < m); }
void dfs(int x, int y) {
if (used[x][y]) return;
used[x][y] = true;
xl[nt] = min(x, xl[nt]), xr[nt] = max(x, xr[nt]);
yl[nt] = min(y, yl[nt]), yr[nt] = max(y, yr[nt]);
for (int i = 0; i < 4; i++)
if (val(x + dx[i], y + dy[i]) && s[x + dx[i]][y + dy[i]] == '*')
dfs(x + dx[i], y + dy[i]);
}
int sum(int x, int y) {
if (x < 0 || y < 0) return 0;
return p[x][y];
}
int sum(int x1, int y1, int x2, int y2) {
return p[x2][y2] - sum(x1 - 1, y2) - sum(x2, y1 - 1) + sum(x1 - 1, y1 - 1);
}
int nl[1100], nr[1100];
int a[1100];
int levo[1100], pravo[1100];
int ml[1100], mr[1100];
int sl[1100], sr[1100];
int getsum(int i, int r) {
if (r <= ml[i]) return (r + 1) * levo[i];
return (ml[i] + 1) * levo[i] + sr[r] - sr[ml[i]];
}
int getsum2(int i, int r) {
if (r <= mr[i]) return (r + 1) * pravo[i];
return (mr[i] + 1) * pravo[i] + sl[r] - sl[mr[i]];
}
long long solve(int x1, int y1, int x2, int y2) {
int segs = 0;
if (y1 == 0) {
} else {
int sl = x1 - 1, sr = x2 + 1;
int f = y2 - y1 + 1;
while (sl >= 0) {
if (lt[sl][y1 - 1] >= f + 1 && s[sl][y1 - 1] == '.')
sl--;
else
break;
}
sl++;
while (sr < n) {
if (lt[sr][y1 - 1] >= f + 1 && s[sr][y1 - 1] == '.')
sr++;
else
break;
}
sr--;
if (up[sr][y1 - 1] >= sr - sl + 1) {
segs++;
nl[segs] = sl, nr[segs] = sr;
for (int i = y1 - 2; i >= 0; i--) {
int L = x1 - up[x1][i] + 1, R = x1 + dw[x1][i] - 1;
if (L > x1 || R < x2) break;
sl = max(sl, L), sr = min(sr, R);
segs++;
nl[segs] = sl, nr[segs] = sr;
}
}
}
int s1 = nl[1], s2 = nr[1];
for (int i = s1; i <= s2; i++) a[i] = lt[i][y2 + 1] + 1;
int mn = 1000000;
for (int i = x1; i <= x2; i++) mn = min(mn, a[i]);
int l1 = x1 - s1, l2 = s2 - x2;
levo[0] = pravo[0] = mn;
for (int i = 1; i <= l1; i++)
levo[i] = min(levo[i - 1], lt[x1 - i][y2 + 1] + 1);
for (int i = 1; i <= l2; i++)
pravo[i] = min(pravo[i - 1], lt[x2 + i][y2 + 1] + 1);
int v;
v = 1;
for (int i = 1; i <= l1; i++) {
while (v <= l2 && pravo[v] >= levo[i]) v++;
ml[i] = v - 1;
}
v = 1;
for (int i = 1; i <= l2; i++) {
while (v <= l1 && levo[v] >= pravo[i]) v++;
mr[i] = v - 1;
}
sl[0] = sr[0] = mn;
for (int i = 1; i <= l1; i++) sl[i] = sl[i - 1] + levo[i];
for (int i = 1; i <= l2; i++) sr[i] = sr[i - 1] + pravo[i];
long long res = 0;
int cur = 0;
for (int h = 1; h <= segs; h++)
if (h == 1) {
for (int i = 0; i <= l1; i++)
cur += (ml[i] + 1) * levo[i] + (sr[l2] - sr[ml[i]]);
res += (long long)(cur);
} else {
for (int i = nl[h - 1]; i < nl[h]; i++)
cur -= getsum(x1 - i, nr[h - 1] - x2);
for (int i = nr[h - 1]; i > nr[h]; i--)
cur -= getsum2(i - x2, x1 - nl[h]);
res += (long long)(cur);
}
int mup = 1000000, mdw = 1000000;
for (int i = y1; i <= y2; i++) {
if (x1 == 0)
mup = 0;
else
mup = min(mup, up[x1 - 1][i]);
if (x2 == n - 1)
mdw = 0;
else
mdw = min(mdw, dw[x2 + 1][i]);
}
s1 = x1 - mup, s2 = x2 + mdw;
mn = 1000000;
for (int i = s1; i <= s2; i++) a[i] = lt[i][y2 + 1] + 1;
for (int i = x1; i <= x2; i++) mn = min(mn, a[i]);
l1 = x1 - s1, l2 = s2 - x2;
levo[0] = pravo[0] = mn;
for (int i = 1; i <= l1; i++)
levo[i] = min(levo[i - 1], lt[x1 - i][y2 + 1] + 1);
for (int i = 1; i <= l2; i++)
pravo[i] = min(pravo[i - 1], lt[x2 + i][y2 + 1] + 1);
v = 1;
for (int i = 1; i <= l1; i++) {
while (v <= l2 && pravo[v] >= levo[i]) v++;
ml[i] = v - 1;
}
v = 1;
for (int i = 1; i <= l2; i++) {
while (v <= l1 && levo[v] >= pravo[i]) v++;
mr[i] = v - 1;
}
sl[0] = sr[0] = mn;
for (int i = 1; i <= l1; i++) sl[i] = sl[i - 1] + levo[i];
for (int i = 1; i <= l2; i++) sr[i] = sr[i - 1] + pravo[i];
cur = 0;
for (int i = 0; i <= l1; i++)
cur += (ml[i] + 1) * levo[i] + (sr[l2] - sr[ml[i]]);
res += (long long)(cur);
return res;
}
void precalc() {
for (int i = 0; i < n; i++) {
lt[i][m - 1] = (s[i][m - 1] == '*' ? 0 : 1);
for (int j = m - 2; j >= 0; j--)
if (s[i][j] == '*')
lt[i][j] = 0;
else
lt[i][j] = lt[i][j + 1] + 1;
}
for (int j = 0; j < m; j++) {
up[0][j] = (s[0][j] == '*' ? 0 : 1);
for (int i = 1; i < n; i++)
if (s[i][j] == '*')
up[i][j] = 0;
else
up[i][j] = up[i - 1][j] + 1;
}
for (int j = 0; j < m; j++) {
dw[n - 1][j] = (s[n - 1][j] == '*' ? 0 : 1);
for (int i = n - 2; i >= 0; i--)
if (s[i][j] == '*')
dw[i][j] = 0;
else
dw[i][j] = dw[i + 1][j] + 1;
}
}
int check(int x1, int y1, int x2, int y2) {
int res = 0;
for (int i = 0; i <= x1; i++)
for (int j = 0; j <= y1; j++)
for (int k = x2; k < n; k++)
for (int l = y2; l < m; l++)
if (sum(i, j, k, l) == sum(x1, y1, x2, y2)) res++;
return res;
}
int main() {
scanf("%d%d%d\n", &n, &m, &t);
for (int i = 0; i < n; i++) gets(s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!used[i][j] && s[i][j] == '*') {
nt++;
xl[nt] = yl[nt] = 1000000;
xr[nt] = yr[nt] = 0;
dfs(i, j);
area[nt] = (xr[nt] - xl[nt] + 1) * (yr[nt] - yl[nt] + 1);
}
p[0][0] = (s[0][0] == '*' ? 1 : 0);
for (int i = 1; i < m; i++) p[0][i] = p[0][i - 1] + (s[0][i] == '*' ? 1 : 0);
for (int i = 1; i < n; i++) p[i][0] = p[i - 1][0] + (s[i][0] == '*' ? 1 : 0);
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++)
p[i][j] = (p[i - 1][j] + p[i][j - 1] - p[i - 1][j - 1]) +
(s[i][j] == '*' ? 1 : 0);
t = nt;
precalc();
long long res = 0, cur = 0;
for (int i = 1; i <= t; i++) res += solve(xl[i], yl[i], xr[i], yr[i]);
for (int i = 1; i <= t; i++)
for (int j = i + 1; j <= t; j++) {
int x1 = xl[i], y1 = yl[i], x2 = xr[i], y2 = yr[i];
x1 = min(x1, xl[j]), y1 = min(y1, yl[j]);
x2 = max(x2, xr[j]), y2 = max(y2, yr[j]);
if (sum(x1, y1, x2, y2) == area[i] + area[j])
res += solve(x1, y1, x2, y2);
}
for (int i = 1; i <= t; i++)
for (int j = i + 1; j <= t; j++)
for (int k = j + 1; k <= t; k++) {
int x1 = xl[i], y1 = yl[i], x2 = xr[i], y2 = yr[i];
x1 = min(x1, xl[j]), y1 = min(y1, yl[j]);
x2 = max(x2, xr[j]), y2 = max(y2, yr[j]);
x1 = min(x1, xl[k]), y1 = min(y1, yl[k]);
x2 = max(x2, xr[k]), y2 = max(y2, yr[k]);
if (sum(x1, y1, x2, y2) == area[i] + area[j] + area[k])
res += solve(x1, y1, x2, y2);
}
cout << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = (int)1e5 + 10;
int v[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
sort(v, v + n);
long long ans = 0;
int mod = 10007;
for (int i = 0; i < n; i++) {
ans += (long long)v[i] * (v[n - i - 1]);
}
cout << ans % mod << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5 + 10;
struct radio {
int x, r, f;
radio() { x = r = f = 0; }
bool operator<(const radio &other) const {
if (f != other.f) return f < other.f;
return x < other.x;
}
};
int n, k;
radio a[nmax];
int fen[nmax];
vector<int> val;
void fen_update(int pos, int cnt) {
if (pos == 0) return;
for (; pos <= n + 1; pos += (pos & (-pos))) fen[pos] += cnt;
}
int fen_query(int pos) {
int res = 0;
for (; pos; pos -= (pos & (-pos))) res += fen[pos];
return res;
}
void update(int x, int cnt) {
int it = upper_bound(val.begin(), val.end(), x) - val.begin();
fen_update(it, cnt);
}
int query(int x) {
int it = upper_bound(val.begin(), val.end(), x) - val.begin();
return fen_query(it);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d %d %d", &a[i].x, &a[i].r, &a[i].f);
val.push_back(a[i].x);
}
sort(a + 1, a + n + 1);
sort(val.begin(), val.end());
val.push_back(val.back() + 1);
long long ans = 0;
int low = 1, high = 0;
set<pair<int, int> > S;
for (int i = 1; i <= n; ++i) {
int j = i;
while (j < n && a[j + 1].f == a[i].f) j++;
while (a[low].f + k < a[i].f) {
auto it = S.find({a[low].x - a[low].r, a[low].x});
S.erase(it);
low++;
}
while (high < n && a[high + 1].f - k <= a[i].f) {
high++;
S.insert({a[high].x - a[high].r, a[high].x});
}
auto it = S.begin();
for (int p = i; p <= j; ++p) {
while (it != S.end() && it->first <= a[p].x) {
update(it->second, 1);
it++;
}
ans += query(a[p].x + a[p].r) - query(a[p].x);
}
for (auto it = S.begin(); it != S.end(); ++it) {
if (it->first > a[j].x) break;
update(it->second, -1);
}
i = j;
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1550, INF = 0x3f3f3f3f, MAX_S = 1e7 + 200;
int n, start_pos, end_pos, head[MAX_N], current, dep[MAX_N], cur[MAX_N],
ptot = 1;
int ch[MAX_S][2], fail[MAX_S], tag[MAX_S], pos[MAX_N], fa[MAX_S];
bool mp[755][755];
char str[MAX_S];
struct edge {
int to, nxt, weight;
} edges[MAX_N * MAX_N];
void addpath(int src, int dst, int weight) {
edges[current].to = dst, edges[current].nxt = head[src];
edges[current].weight = weight, head[src] = current++;
}
void addtube(int src, int dst, int weight) {
addpath(src, dst, weight);
addpath(dst, src, 0);
}
bool bfs() {
memset(dep, 0, sizeof(dep));
queue<int> q;
q.push(start_pos), dep[start_pos] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = edges[i].nxt)
if (edges[i].weight > 0 && dep[edges[i].to] == 0)
dep[edges[i].to] = dep[u] + 1, q.push(edges[i].to);
}
return dep[end_pos] != 0;
}
int dfs(int u, int flow) {
if (u == end_pos || flow == 0) return flow;
for (int &i = cur[u]; i != -1; i = edges[i].nxt)
if (edges[i].weight > 0 && dep[edges[i].to] == dep[u] + 1)
if (int di = dfs(edges[i].to, min(flow, edges[i].weight))) {
edges[i].weight -= di, edges[i ^ 1].weight += di;
return di;
}
return 0;
}
int dinic() {
int ret = 0;
while (bfs()) {
memcpy(cur, head, sizeof(cur));
while (int di = dfs(start_pos, INF)) ret += di;
}
return ret;
}
void build() {
queue<int> q;
for (int i = 0; i < 2; i++)
if (ch[1][i])
fail[ch[1][i]] = 1, q.push(ch[1][i]);
else
ch[1][i] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int c = 0; c < 2; c++)
if (ch[u][c])
fail[ch[u][c]] = ch[fail[u]][c], q.push(ch[u][c]);
else
ch[u][c] = ch[fail[u]][c];
}
vector<int> path;
for (int i = 1; i <= n; i++)
for (int org = pos[i]; org != 1; org = fa[org]) {
int u = fail[org];
path.clear();
while (!tag[u]) path.push_back(u), u = fail[u];
while (!path.empty()) fail[path.back()] = u, path.pop_back();
fail[org] = u;
if (org != pos[i] && tag[org]) u = org;
if (u != 1) mp[i][tag[u]] = true;
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d", &n), tag[1] = -1;
for (int ptr = 1, len; ptr <= n; ptr++) {
scanf("%s", str + 1), len = strlen(str + 1);
int p = 1;
for (int i = 1; i <= len; i++) {
if (ch[p][str[i] - 'a'] == 0) fa[ch[p][str[i] - 'a'] = ++ptot] = p;
p = ch[p][str[i] - 'a'];
}
tag[p] = ptr, pos[ptr] = p;
}
build();
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) mp[i][j] |= mp[i][k] && mp[k][j];
for (int i = 1; i <= n; i++) mp[i][i] = false;
start_pos = 2 * n + 1, end_pos = start_pos + 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (mp[i][j]) addtube(i, j + n, 1);
for (int i = 1; i <= n; i++)
addtube(start_pos, i, 1), addtube(i + n, end_pos, 1);
printf("%d\n", n - dinic());
for (int i = 1; i <= n; i++)
if (dep[i] != 0 && dep[i + n] == 0) printf("%d ", i);
puts("");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
set<int> s[N];
int pfactor[N];
vector<int> fact(int n) {
vector<int> v;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
v.emplace_back(i);
if (n / i != i) {
v.emplace_back(n / i);
}
}
}
if (n != 1) v.emplace_back(n);
return v;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
char c;
int v;
cin >> c >> v;
if (c == '+') {
if (pfactor[v]) {
cout << "Already on\n";
continue;
}
vector<int> f = fact(v);
bool fg = true;
for (auto& i : f) {
if (s[i].size() > 0) {
cout << "Conflict with " << *s[i].begin() << "\n";
fg = false;
break;
}
}
if (fg) {
cout << "Success\n";
for (auto& i : f) s[i].insert(v);
pfactor[v] = 1;
}
} else {
if (!pfactor[v]) {
cout << "Already off\n";
continue;
}
vector<int> f = fact(v);
cout << "Success\n";
for (auto& i : f) s[i].erase(v);
pfactor[v] = 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[1000000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i < n + 1; i += 1) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
int l = 1, r = n;
for (int i = n; i > 0; --i)
if (a[i] == a[r])
r = i;
else
break;
for (int i = 1; i < n + 1; i += 1)
if (a[i] == a[l])
l = i;
else
break;
long long res = 0;
while (l < r) {
if (l < (n - r + 1)) {
if (k >= l * (a[l + 1] - a[l])) {
k -= l * (a[l + 1] - a[l]);
l++;
for (int i = 1; i < n + 1; i += 1)
if (a[i] == a[l])
l++;
else
break;
} else {
res = k / l;
break;
}
} else {
if (k >= (n - r + 1) * (a[r] - a[r - 1])) {
k -= ((n - r + 1) * (a[r] - a[r - 1]));
r--;
for (int i = n; i > 0; --i)
if (a[i] == a[r])
r--;
else
break;
} else {
res = k / (n - r + 1);
break;
}
}
}
cout << a[r] - a[l] - res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p[200001], base = 419, mod = 1e9 + 7;
string s;
vector<int> ch[26], sum[26];
int powlog(int a, int b) {
if (b == 0) return 1;
int ret = powlog(a, b / 2);
if (b % 2) return 1LL * ret * ret % mod * a % mod;
return 1LL * ret * ret % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> s;
p[0] = 1;
for (int i = 1; i <= n; i++) p[i] = 1LL * base * p[i - 1] % mod;
for (int i = 0; i < s.size(); i++) ch[s[i] - 'a'].push_back(i);
for (int i = 0; i < 26; i++) {
int cur = 0;
for (auto &j : ch[i]) {
cur = (cur + p[j]) % mod;
sum[i].push_back(cur);
}
}
while (m--) {
int a, b, c, d, len;
cin >> a >> c >> len;
a--, c--;
b = a + len - 1;
d = c + len - 1;
bool ans = 1;
for (int i = 0; i < 26; i++) {
int l1 = lower_bound(ch[i].begin(), ch[i].end(), a) - ch[i].begin();
int r1 = upper_bound(ch[i].begin(), ch[i].end(), b) - ch[i].begin() - 1;
if (r1 < l1) continue;
int cor = s[c + ch[i][l1] - a] - 'a';
int l2 = lower_bound(ch[cor].begin(), ch[cor].end(), c) - ch[cor].begin();
int r2 =
upper_bound(ch[cor].begin(), ch[cor].end(), d) - ch[cor].begin() - 1;
if (r1 - l1 != r2 - l2) {
ans = 0;
break;
}
int val1 = (sum[i][r1] - (l1 == 0 ? 0 : sum[i][l1 - 1]) + mod) % mod;
int val2 = (sum[cor][r2] - (l2 == 0 ? 0 : sum[cor][l2 - 1]) + mod) % mod;
val1 = 1LL * val1 * powlog(p[ch[i][l1]], mod - 2) % mod;
val2 = 1LL * val2 * powlog(p[ch[cor][l2]], mod - 2) % mod;
if (val1 != val2) {
ans = 0;
break;
}
}
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N;
char c[3000][3000];
int color[3000][3000];
int row[3000];
int col[3000];
int main() {
scanf("%d", &N);
for (int Ni = 0; Ni < N; Ni++) scanf("%s", c[Ni]);
for (int Ni = 0; Ni < N; Ni++)
for (int Nj = 0; Nj < N; Nj++) color[Ni][Nj] = c[Ni][Nj] - '0';
int cnt = 0;
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (int i = N - 1; i >= 0; i--)
for (int j = 0; j < i; j++)
if ((row[i] + col[j]) % 2 != color[i][j]) {
cnt++;
row[i]++;
col[j]++;
}
int p[3000];
for (int Ni = 0; Ni < N; Ni++) p[Ni] = (row[Ni] + col[Ni]) % 2;
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (int i = 0; i < N; i++)
for (int j = N - 1; j > i; j--)
if ((row[i] + col[j]) % 2 != color[i][j]) {
cnt++;
row[i]++;
col[j]++;
}
for (int Ni = 0; Ni < N; Ni++) {
p[Ni] = (p[Ni] + row[Ni] + col[Ni]) % 2;
if (p[Ni] != color[Ni][Ni]) cnt++;
}
printf("%d", cnt);
puts("");
}
| 6 |
#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...);
}
const int M = 3e6 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
long long arr[n];
map<int, int> mp;
vector<long long> v;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mp[arr[i]]++;
}
for (int k = 0; k < 32; k++) {
v.push_back(1 << k);
}
long long cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < v.size(); j++) {
int diff = v[j] - arr[i];
if (mp[diff]) {
if (diff == arr[i])
cnt += mp[diff] - 1;
else
cnt += mp[diff];
}
}
}
cout << cnt / 2 << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
const int M = 100500;
const int dx[] = {0, 0, 1, 0, -1};
const int dy[] = {0, 1, 0, -1, 0};
pair<int, int> p[M];
bool nw[M];
char c[N][N];
int n, m, k, col, ans, sz[M], u[N][N];
bool in(int x, int y) { return (x >= 1 && x <= n && y >= 1 && y <= m); }
void dfs(int x, int y) {
u[x][y] = col;
if (col >= 1) sz[col]++;
for (int i = 1; i <= 4; i++) {
int tox = x + dx[i];
int toy = y + dy[i];
if (in(tox, toy) && c[tox][toy] == '.' && u[tox][toy] == 0) dfs(tox, toy);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c[i][j];
}
}
col = -1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (c[i][j] == '.' && (i == 1 || i == n || j == 1 || j == m)) dfs(i, j);
}
}
col = 0;
for (int i = 2; i < n; i++) {
for (int j = 2; j < m; j++) {
if (c[i][j] == '.' && u[i][j] == 0) {
col++;
dfs(i, j);
p[col] = make_pair(sz[col], col);
}
}
}
sort(p + 1, p + 1 + col);
for (int i = 1; col > k; i++) {
ans += p[i].first;
nw[p[i].second] = 1;
col--;
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (c[i][j] == '.' && u[i][j] >= 1 && nw[u[i][j]])
cout << '*';
else
cout << c[i][j];
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, s;
cin >> s;
cin >> a >> b;
int A, B, A1 = 0, B1 = 0;
swap(a[0], a[1]);
if (a[0] == s[0]) A1 = 1000000007;
if (a[1] >= '6' && a[1] <= '9')
A = a[1] - '0';
else if (a[1] == 'T')
A = 10;
else if (a[1] == 'J')
A = 11;
else if (a[1] == 'Q')
A = 12;
else if (a[1] == 'K')
A = 13;
else if (a[1] == 'A')
A = 14;
swap(b[0], b[1]);
if (b[0] == s[0]) B1 = 1000000007;
if (b[1] >= '6' && b[1] <= '9')
B = b[1] - '0';
else if (b[1] == 'T')
B = 10;
else if (b[1] == 'J')
B = 11;
else if (b[1] == 'Q')
B = 12;
else if (b[1] == 'K')
B = 13;
else if (b[1] == 'A')
B = 14;
if ((A1 == 1000000007 && B1 != 1000000007) || (a[0] == b[0] && A > B))
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long MAXVAL = 1e12;
const int MAXN = 1e6;
const int MAXM = 4096;
const int MAXP = 78498;
const int MAXPP = 80070;
bool mark[MAXN + 1];
int pf[MAXP + 1];
long long pf_power[MAXPP + 1];
map<long long, int> rt;
map<long long, int> rem;
vector<long long> g[MAXM];
long long used[MAXM];
long long idx[MAXM];
map<long long, int> dp[2];
long long n;
int m, tmp;
bool now, pre;
void fast_io() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void prepare() {
memset(mark, 1, sizeof(mark));
mark[0] = mark[1] = 0;
int cnt = 0;
for (int i = 2; i <= MAXN; i++) {
if (mark[i]) {
pf[cnt++] = i;
for (int j = (i << 1); j <= MAXN; j += i) mark[j] = 0;
}
}
int len = 0;
for (int i = 0; i < cnt; i++) {
long long curr = pf[i];
rt[curr] = pf[i];
for (int j = 0; true; j++) {
curr *= pf[i];
if (curr >= MAXVAL) break;
pf_power[len++] = curr;
rt[curr] = pf[i];
}
}
sort(pf_power, pf_power + len);
}
bool ok(long long x) {
if (x <= 1) return 0;
if (rt.count(x)) return 1;
for (int i = 0; (1LL * pf[i] * pf[i]) <= x and i < MAXP; i++) {
if (x % pf[i] == 0) return 0;
}
rt[x] = x;
return 1;
}
int main() {
fast_io();
prepare();
cin >> n;
m = 0;
for (long long i = 1; i * i <= n; i++) {
if (n % i) continue;
long long a = (n / i), b = i;
int root;
if (ok(a - 1)) {
root = rt[a - 1];
used[m] = a;
idx[m++] = root;
}
if (a ^ b and ok(b - 1)) {
root = rt[b - 1];
used[m] = b;
idx[m++] = root;
}
}
tmp = m;
sort(idx, idx + m);
m = unique(idx, idx + m) - idx;
for (int i = 0; i < tmp; i++) {
int pos = lower_bound(idx, idx + m, rt[used[i] - 1]) - idx + 1;
g[pos].push_back(used[i]);
}
dp[0][n] = 1;
for (int i = 1; i <= m; i++) {
now = (i & 1);
pre = (now ^ 1);
dp[now].clear();
for (auto x : dp[pre]) {
dp[now][x.first] = dp[pre][x.first];
}
for (auto v : g[i]) {
for (auto x : dp[pre]) {
if (x.first % v) continue;
dp[now][x.first / v] += dp[pre][x.first];
}
}
}
cout << dp[now][1] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, t, a, b, da, db, i, k;
cin >> x >> t >> a >> b >> da >> db;
int pointsa[t + 1], bpoints[t + 1];
pointsa[t] = 0;
bpoints[t] = 0;
for (i = 0; i < t; i++) {
pointsa[i] = a - da * i;
bpoints[i] = b - db * i;
}
for (i = 0; i <= t; i++)
for (k = 0; k <= t; k++)
if (pointsa[i] + bpoints[k] == x) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[5000], v[3][5000], a = 0, b = 0, c = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
if (arr[i] == 1) {
v[0][a] = i;
a++;
} else if (arr[i] == 2) {
v[1][b] = i;
b++;
} else if (arr[i] == 3) {
v[2][c] = i;
c++;
}
}
if (a == 0 || b == 0 || c == 0)
cout << "0";
else {
int x = min(a, b);
int y = min(x, c);
cout << y << endl;
for (int i = 0; i < y; i++) {
cout << v[0][i] + 1 << " " << v[1][i] + 1 << " " << v[2][i] + 1 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
int n, len = 0, w = 0;
std::string t;
char s[200];
std::map<std::string, int> mp;
int eval(int l, int r) {
for (int i = r, w = 0; i > l; i--)
if (w += (s[i] == ')'), w -= (s[i] == '('),
!w && (s[i] == '-' || s[i] == '+')) {
int L = eval(l, i - 1), R = eval(i + 1, r);
return L && R && (s[i] != '-' || R > 1);
}
for (int i = r, w = 0; i > l; i--)
if (w += (s[i] == ')'), w -= (s[i] == '('),
!w && (s[i] == '*' || s[i] == '/')) {
int L = eval(l, i - 1), R = eval(i + 1, r);
return (L > 1) && (R > 1) && (s[i] != '/' || R > 2) ? 2 : 0;
}
if (s[l] == '(') return eval(l + 1, r - 1) ? 3 : 0;
std::string a(s + l, s + r + 1);
return mp.count(a) ? mp[a] : 3;
}
int Get() {
gets(s);
for (int i = len = 0; s[i]; i++)
if (s[i] != ' ') s[len++] = s[i];
return eval(0, len - 1);
}
int main() {
std::cin >> n;
for (int i = 1; i <= n; i++) {
scanf(" #%*s");
std::cin >> t;
mp[t] = Get();
}
puts(Get() ? "OK" : "Suspicious");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chkmax(T &x, const T &y) {
if (x < y) x = y;
}
template <class T>
inline void chkmin(T &x, const T &y) {
if (x > y) x = y;
}
const long long MAXN = (1 << 20);
long long n, m, a, d;
long long t[MAXN];
void read() {
cin >> n >> m >> a >> d;
for (long long i = 0; i < m; i++) cin >> t[i];
}
long long last, last_close, answer = 0;
void open_until(long long T) {
if (last > n) return;
long long x = d / a + 1;
long long from = last, to = min(n, T / a);
answer += (to - from + 1) / x + ((to - from + 1) % x != 0);
last_close =
d + (from + ((to - from + 1) / x - ((to - from + 1) % x == 0)) * x) * a;
last = (last_close / a) + 1;
}
void solve() {
last_close = 0, last = 1;
for (long long i = 0; i < m; i++) {
if (t[i] > last * a) open_until(t[i]);
if (t[i] <= last_close) continue;
last_close = t[i] + d;
last = (last_close / a) + 1;
answer++;
}
open_until((long long)2e18);
cout << answer << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int d, e, i, k, l, c, m, a[100], b[100], f, j, t, q, z, p, m1, m2, m3, m4;
int main(int argc, char *argv[]) {
cin >> d >> e;
while (e > 0) {
c = e % 10;
m++;
b[m] = c;
e = e / 10;
}
for (i = 1; i <= m; i++) {
if (b[i] == 4) m1++;
if (b[i] == 7) m2++;
}
for (i = d + 1; i <= 2000000; i++) {
k = i;
l = 0;
q = 1;
m3 = m4 = 0;
memset(a, 0, sizeof(a));
while (k > 0) {
c = k % 10;
l++;
a[l] = c;
k = k / 10;
}
for (j = 1; j <= l; j++) {
if (a[j] == 4) m3++;
if (a[j] == 7) m4++;
}
if ((m1 == m3 && m2 == m4)) {
for (j = 1; j <= m; j++) {
p = 0;
for (z = q; z <= l; z++) {
if (b[j] == a[z]) {
p = 1;
q = z + 1;
break;
}
}
if (p == 0) break;
}
}
if (p == 1) {
cout << i << endl;
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while ((c < '0' || c > '9') && (c != '-')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int N = 2e5 + 10;
int n, b[N];
long long g[N];
map<int, long long> f;
int main() {
n = read();
for (register int i = (1); i <= (n); i++) b[i] = read();
long long ans = 0;
for (register int i = (1); i <= (n); i++) {
g[i] = max((long long)b[i], f[i - b[i]] + b[i]);
f[i - b[i]] = max(f[i - b[i]], g[i]);
ans = max(ans, g[i]);
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000010], A, B, n, l, t, m;
long long get(int x) { return A + B * (x - 1); }
long long getnum(int x) {
long long sum = 0;
sum = (get(l) * (x - l + 1) + (x - l + 1) * (x - l) * 0.5 * B);
return sum;
}
int main() {
while (~scanf("%I64d %I64d %I64d", &A, &B, &n)) {
for (int i = 0; i < n; i++) {
scanf("%I64d %I64d %I64d", &l, &t, &m);
if (get(l) > t) {
printf("-1\n");
continue;
}
long long L = l, R = (t - A) / B + 1, ans;
while (L <= R) {
long long mid = (L + R) / 2;
if (getnum(mid) <= t * m) {
ans = mid;
L = mid + 1;
} else
R = mid - 1;
}
printf("%I64d\n", ans);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const MAXn = 2e5 + 2;
int mat[4][4];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int k;
cin >> k;
int i = 1;
while (i <= 300000) i *= 2;
i /= 2;
i--;
mat[1][1] = i;
mat[3][3] = i;
int y = (k ^ i);
mat[1][2] = mat[2][3] = k;
mat[2][1] = y;
mat[2][2] = i;
cout << 3 << " " << 3 << "\n";
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
cout << mat[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 330000;
const int MAXB = 20;
int a[MAXN], b[MAXB];
int f[MAXN][MAXB];
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < 19; i++) b[i] = f[n + 1][i] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 19; j++) {
if (a[i] & 1 << j)
f[i][j] = i;
else {
f[i][j] = n + 1;
for (int k = 0; k < 19; k++)
if (a[i] & 1 << k) f[i][j] = min(f[i][j], f[b[k]][j]);
}
}
for (int j = 0; j < 19; j++)
if (a[i] & 1 << j) b[j] = i;
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
bool flag = 0;
for (int i = 0; i < 19; i++)
if (a[y] & 1 << i && f[x][i] <= y) {
flag = 1;
break;
}
puts(flag ? "Shi" : "Fou");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, a[1001], kid[200001], k, l, sum, ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n - 1; i++) {
for (j = i + 1; j < n; j++) {
sum = a[i] + a[j];
kid[sum]++;
if (kid[sum] > ans) ans = kid[sum];
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long t, ans, med, tmp, n, m, k;
int main() {
cin >> n >> m >> k;
if (n > m) swap(n, m);
ans = min(((n * 2) + (m * 2)), n + m + k);
ans = min(ans, (n + n + k + k));
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int n, i, j, l, a[N], f[N][N];
int main() {
scanf("%d", &n);
memset(f, 0, sizeof(f));
for (i = 1; i <= n; i++) scanf("%d", &a[i]), f[i][i] = 1;
for (i = 2; i <= n; i++)
for (j = 1; i + j - 1 <= n; j++) {
f[j][i + j - 1] = f[j + 1][i + j - 1] + 1;
if (a[j] == a[j + 1])
f[j][i + j - 1] = min(f[j][i + j - 1], f[j + 2][i + j - 1] + 1);
for (l = j + 2; l <= i + j - 1; l++)
if (a[j] == a[l])
f[j][i + j - 1] =
min(f[j][i + j - 1], f[j + 1][l - 1] + f[l + 1][i + j - 1]);
}
return printf("%d\n", f[1][n]), 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int b[n];
for (int i = 0; i < n; i++) cin >> b[i];
int a[n];
a[0] = b[0];
int j = 0;
int c = a[0];
while (j < n - 1) {
a[j + 1] = b[j + 1] + c;
c = max(c, a[j + 1]);
j++;
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int c = 0;
int c2 = 0;
cin >> str;
for (int i = 0; i < str.size(); i++) {
if (str[i] == '0' || str[i] == '1') {
c++;
if (str[i] == '1') {
c = 0;
}
if (c == 7) {
cout << "YES" << endl;
return 0;
}
}
if (str[i] == '0' || str[i] == '1') {
c2++;
if (str[i] == '0') {
c2 = 0;
}
if (c2 == 7) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string Arr, Brr;
int larr, lbrr;
cin >> Arr >> Brr;
larr = Arr.size();
lbrr = Brr.size();
if (larr != lbrr)
cout << "NO" << endl;
else {
bool p = true;
for (int i = 0; i < larr; i++) {
if ((Arr[i] == 'a' || Arr[i] == 'e' || Arr[i] == 'i' || Arr[i] == 'o' ||
Arr[i] == 'u') &&
(Brr[i] != 'a' && Brr[i] != 'e' && Brr[i] != 'i' && Brr[i] != 'o' &&
Brr[i] != 'u')) {
p = false;
break;
} else if ((Arr[i] != 'a' && Arr[i] != 'e' && Arr[i] != 'i' &&
Arr[i] != 'o' && Arr[i] != 'u') &&
(Brr[i] == 'a' || Brr[i] == 'e' || Brr[i] == 'i' ||
Brr[i] == 'o' || Brr[i] == 'u')) {
p = false;
break;
}
}
if (p == true)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
int p = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') p = -p;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch - '0'), ch = getchar();
x = x * p;
}
const int maxn = 1005;
int siz[maxn], n, root, son[maxn], head[maxn], cnt, tot, hh[maxn], a, b, now;
struct node {
int from, to, v;
} ans[maxn];
struct edge {
int to, next;
} e[maxn << 1];
vector<int> vec;
void add(int x, int y) {
e[cnt].to = y;
e[cnt].next = head[x];
head[x] = cnt++;
}
void findroot(int u, int pre) {
siz[u] = 1;
son[u] = 0;
for (int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre) continue;
findroot(e[i].to, u);
siz[u] += siz[e[i].to];
son[u] = max(son[u], siz[e[i].to]);
}
son[u] = max(son[u], n - siz[u]);
if (son[root] > son[u]) root = u;
}
bool cmp(const int &a, const int &b) { return siz[a] > siz[b]; }
void dfs(int u, int pre) {
siz[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre) continue;
dfs(e[i].to, u);
siz[u] += siz[e[i].to];
if (u == root) vec.push_back(e[i].to);
}
}
void dfs1(int u, int pre, int g) {
for (int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre) continue;
now++;
ans[++tot] = (node){u, e[i].to, now - g};
dfs1(e[i].to, u, now);
}
}
void dfs2(int u, int pre, int g) {
for (int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre) continue;
now += a;
ans[++tot] = (node){u, e[i].to, now - g};
dfs2(e[i].to, u, now);
}
}
int main() {
cnt = 1;
tot = -0;
a = 0;
b = 0;
son[0] = 99999999;
root = 0;
read(n);
for (int i = 1; i < n; ++i) {
int x, y;
read(x);
read(y);
add(x, y);
add(y, x);
}
findroot(1, 0);
dfs(root, 0);
sort(vec.begin(), vec.end(), cmp);
for (int i = 0; i < vec.size(); ++i) {
int to = vec[i];
if (a <= b)
hh[to] = 0, a += siz[to];
else
hh[to] = 1, b += siz[to];
}
now = 0;
for (int i = head[root]; i; i = e[i].next) {
if (hh[e[i].to]) continue;
ans[++tot] = (node){root, e[i].to, now + 1};
now++;
dfs1(e[i].to, root, now);
}
now = a;
for (int i = head[root]; i; i = e[i].next) {
if (!hh[e[i].to]) continue;
ans[++tot] = (node){root, e[i].to, now};
now += a;
dfs2(e[i].to, root, now);
}
for (int i = 1; i < n; ++i) {
printf("%d %d %d\n", ans[i].from, ans[i].to, ans[i].v);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, N;
while (cin >> A >> B >> N) {
int res;
bool flag = false;
for (int i = -1000; i <= 1000; i++) {
if (fabs((double)A * pow(double(i), N) - double(B)) < 1e-11) {
flag = true;
res = i;
break;
}
}
if (flag)
cout << res << endl;
else
cout << "No solution\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int cnt = 0;
vector<int> cand;
int prime[1000005];
void SieveOfEratosthenes(int n) {
memset(prime, 0, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == 0) {
for (int i = p * p; i <= n; i += p) prime[i] = p;
}
}
}
long long power(long long x, long long y) {
long long res = 1ll;
x = x % 998244353;
if (x == 0ll) return 0;
while (y > 0ll) {
if (y & 1ll) res = (res * x) % 998244353;
y = y >> 1ll;
x = (x * x) % 998244353;
}
return res;
}
long long add(long long x, long long y) {
x += y;
while (x >= 998244353) x -= 998244353;
while (x < 0) x += 998244353;
return x;
}
long long mul(long long x, long long y) { return (x * 1ll * y) % 998244353; }
long long binpow(long long x, long long y) {
long long z = 1ll;
while (y) {
if (y & 1) z = mul(z, x);
x = mul(x, x);
y >>= 1ll;
}
return z;
}
long long inv(long long x) { return binpow(x, 998244353 - 2); }
long long divide(long long x, long long y) { return mul(x, inv(y)); }
long long fact[1000001];
void precalc() {
fact[0] = 1;
for (long long i = 1; i < 1000001; i++) fact[i] = mul(fact[i - 1], i);
}
long long C(long long n, long long k) {
if (n == 0) return 1;
return divide(fact[n], mul(fact[k], fact[n - k]));
}
long long sub(long long A, long long B) {
return (A - B + 998244353) % 998244353;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(5);
int t = 1;
while (t--) {
long long l, n;
string s;
cin >> l >> s;
n = s.length();
if (n % l != 0) {
n = 1 + (n - 1) / l;
string t(l, '0');
t[0] = '1';
while (n--) cout << t;
cout << endl;
} else {
string t = s.substr(0, l);
string r;
for (long long i = 1; i <= n; i += l) r += t;
if (r <= s) {
for (long long i = l - 1; i >= 0; --i) {
if (t[i] == '9')
t[i] = '0';
else {
t[i]++;
break;
}
}
if (t[0] == '0') {
t[0] = '1';
n += l;
}
r = "";
for (long long i = 1; i <= n; i += l) r += t;
}
cout << r << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
void gen(int diff) {
for (int i = 0; i < 1000; i++) {
putchar('.');
}
putchar('\n');
for (int i = 0; i < 1000; i++) {
if (i % 2 == 0 && i / 2 < diff) {
putchar('X');
} else {
putchar('.');
}
}
putchar('\n');
for (int i = 0; i < 1000; i++) {
if (i == 0) {
putchar('X');
} else {
putchar('.');
}
}
putchar('\n');
}
char str[100];
int main() {
scanf("%s", str);
int last = 0;
for (int i = 0; str[i]; i++) {
gen((last - str[i] + 250) % 256 + 6);
last = str[i];
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
using namespace std;
long long int sum = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int g;
cin >> g;
sum += g;
}
if (sum % n == 0) {
cout << n << endl;
} else {
cout << n - 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 8;
char arr[8][8];
bool if_all_black() {
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
if (arr[i][j] != 'B') return false;
}
}
return true;
}
int column_black() {
int cnt = 0;
for (int i = 0; i < N; ++i) {
bool bol = true;
for (int j = 0; j < N; ++j) {
if (arr[i][j] != 'B') bol = false;
}
if (bol == true) cnt++;
}
return cnt;
}
int row_black() {
int cnt = 0;
for (int j = 0; j < N; ++j) {
bool bol = true;
for (int i = 0; i < N; ++i) {
if (arr[i][j] != 'B') bol = false;
}
if (bol == true) cnt++;
}
return cnt;
}
int main() {
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
cin >> arr[i][j];
}
}
if (if_all_black())
cout << "8";
else
cout << row_black() + column_black();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
long long a, b;
scanf("%d", &tc);
for (int i = 1; i <= tc; i++) {
scanf("%lld %lld", &a, &b);
long long val = a * b;
long long cube_root = round(cbrt(val));
if (cube_root * cube_root * cube_root == val && a % cube_root == 0 &&
b % cube_root == 0)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pp(T v) {
for (__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
cout << *it << ' ';
cout << endl;
}
template <class T>
void pp(T v, int n) {
for (int i = 0; i < (int)n; i++) cout << v[i] << ' ';
cout << endl;
}
const int INF = 1 << 28;
const double EPS = 1.0e-9;
static const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
int main(void) {
int a, b, x1, y1, x2, y2;
cin >> a >> b >> x1 >> y1 >> x2 >> y2;
int add1 = x1 + y1, add2 = x2 + y2;
int sub1 = x1 - y1, sub2 = x2 - y2;
int add1_i = add1 / (2 * a);
if (add1 < 0) add1_i--;
int add2_i = add2 / (2 * a);
if (add2 < 0) add2_i--;
int sub1_i = sub1 / (2 * b);
if (sub1 < 0) sub1_i--;
int sub2_i = sub2 / (2 * b);
if (sub2 < 0) sub2_i--;
int dx = abs(add1_i - add2_i);
int dy = abs(sub1_i - sub2_i);
int ans = max(dx, dy);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[200001][5];
vector<vector<int>> g;
int dfs(int s, int p, int d) {
if (dp[s][d] == -1) {
int ans = 0;
if (d == 0 || d == 1) {
for (auto it : g[s]) {
if (it != p) ans += dfs(it, s, d + 1);
}
}
if (d == 2) {
int lans = 1;
for (auto it : g[s]) {
if (it != p) {
lans += dfs(it, s, 2);
ans += dfs(it, s, 3);
}
}
ans = min(ans, lans);
}
if (d == 3) {
int lans = 0;
int add = 10000000;
for (auto it : g[s]) {
if (it != p) {
lans += dfs(it, s, 3);
ans += dfs(it, s, 2);
add = min(add, -dfs(it, s, 3) + 1 + dfs(it, s, 1));
}
}
ans++;
lans = lans + add;
if (lans <= 0) lans = 1;
ans = min(ans, lans);
}
dp[s][d] = ans;
return ans;
} else
return dp[s][d];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(dp, -1, sizeof(dp));
int n;
cin >> n;
g.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
cout << dfs(1, 1, 0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int n, m, b, mode;
long long a[N], dp[N][N];
int main() {
scanf("%d %d %d %d", &n, &m, &b, &mode);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
dp[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int k = a[i]; k <= b; k++) {
dp[j][k] = dp[j][k] + dp[j - 1][k - a[i]];
dp[j][k] %= mode;
}
}
long long ans = 0;
for (int i = 0; i <= b; i++) {
ans += dp[m][i];
ans %= mode;
}
printf("%lld", ans);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define imax 0x3f3f3f3f
#define lmax 0x3f3f3f3f3f3f3f3f
void swap(ll* a, ll* b) {
int swapp = *a;
*a = *b;
*b = swapp;
}
ll max(ll a, ll b) {
if (a > b) return a;
return b;
}
ll min(ll a, ll b) {
if (a < b) return a;
return b;
}
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
}
int lcm(const int a, const int b)
{
return a / gcd(a, b) * b;
}
bool isprime(ll num)
{
if (num == 1)
return 0;
if (num == 2 || num == 3)
return 1;
if (num % 6 != 1 && num % 6 != 5)
return 0;
int tmp = sqrt(num);
for (ll i = 5; i <= tmp; i += 6)
if (num % i == 0 || num % (i + 2) == 0)
return 0;
return 1;
}
struct node{
int top;
int bottom;
int num;
/*bool operator < (node a){
if(h!=a.h)
return h < a.h;
return w < a.w;
}
*/
};
bool check(ll num,ll d){
while(num!=0){
if(num%10==d) return 1;
else num=num/10;
}
return 0;
}
int main(void)
{
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int _;
cin>>_;
while(_--){
int n;
cin>>n;
int s;
int a0=0,a1=0,a2=0;
for(int i=0;i<n;i++){
cin>>s;
if(s%3==0) a0++;
else if(s%3==1) a1++;
else a2++;
}
ll re=0;
if(a0<n/3&&a1<n/3){
re=(n/3-a0)+2*(n/3-a1);
}
else if(a0<n/3&&a2<n/3){
re=(n/3-a2)+2*(n/3-a0);
}
else if(a1<n/3&&a2<n/3){
re=(n/3-a1)+2*(n/3-a2);
}
else if(a0<n/3){
re=(a2-n/3)+2*(a1-n/3);
}
else if(a1<n/3){
re=(a0-n/3)+2*(a2-n/3);
}
else if(a2<n/3){
re=(a1-n/3)+2*(a0-n/3);
}
cout<<re<<endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 1;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
if (f) x = -x;
}
template <typename F>
inline void write(F x) {
static short st[30];
short tp = 0;
if (x < 0) putchar('-'), x = -x;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar('0' | st[tp--]);
putchar('\n');
}
template <typename T>
inline void Mx(T &x, T y) {
x < y && (x = y);
}
template <typename T>
inline void Mn(T &x, T y) {
x > y && (x = y);
}
const int N = 550, M = 15000;
int cnt, m, n;
struct node {
int x, y, w;
bool operator<(const node &i) const { return w > i.w; }
} ed[M];
namespace MxFlow {
int h[N], ne[M], to[M], w[M], tot = 1;
void add(int x, int y, int z) {
ne[++tot] = h[x], to[h[x] = tot] = y, w[tot] = z;
}
int dep[N], cur[N], s, t;
bool bfs(void) {
memset(dep, 0, n * 4 + 50);
queue<int> q;
dep[s] = 1, q.push(s);
while (q.size()) {
int x = q.front();
q.pop();
for (int i = h[x], y; i; i = ne[i]) {
if (dep[y = to[i]] || !w[i]) continue;
dep[y] = dep[x] + 1, q.push(y);
}
}
if (!dep[t]) return 0;
for (int i = 1; i <= n; i++) cur[i] = h[i];
return 1;
}
int dfs(int x, int lim) {
if (x == t || !lim) return lim;
int res = 0, fl;
for (int &i = cur[x]; i; i = ne[i]) {
int y = to[i];
if (dep[y] != dep[x] + 1) continue;
fl = dfs(y, min(w[i], lim));
w[i ^ 1] += fl, w[i] -= fl, res += fl, lim -= fl;
if (!lim) return res;
}
return res;
}
int Maxflow(int x, int y) {
int ans = 0;
for (int i = 2; i <= tot; i += 2)
w[i] += w[i ^ 1], w[i] = w[i ^ 1] = w[i] >> 1;
while (bfs()) ans += dfs(s, 1e6);
return ans;
}
int col[N], p[N], tp[N];
void Col(int x) {
col[x] = 1;
for (int i = h[x]; i; i = ne[i]) {
int y = to[i];
if (col[y]) continue;
if (!w[i]) continue;
Col(y);
}
}
void solve(int l, int r) {
if (l >= r) return;
int cut = Maxflow(s = p[l], t = p[r]);
memset(col, 0, sizeof(col)), Col(s);
int tl = l - 1, tr = r + 1;
for (int i = l; i <= r; i++)
if (col[p[i]])
tp[++tl] = p[i];
else
tp[--tr] = p[i];
ed[++cnt] = (node){p[r], p[l], cut};
for (int i = l; i <= r; i++) p[i] = tp[i];
solve(l, tl), solve(tr, r);
}
void init() {
read(n), read(m);
for (int i = 1, x, y, z; i <= m; i++) {
read(x), read(y), read(z);
add(x, y, z), add(y, x, z);
}
for (int i = 1; i <= n; i++) p[i] = i;
solve(1, n);
}
} // namespace MxFlow
int f[N], h[N], t[N], ans;
int main() {
MxFlow::init(), sort(ed + 1, ed + cnt + 1);
for (int i = 1; i <= n; i++) t[i] = h[i] = f[i] = i;
for (int i = 1; i <= cnt; i++) {
int fx = h[ed[i].x], fy = t[ed[i].y];
f[fx] = fy;
for (int x = t[fx]; x != h[ed[i].y]; x = f[x])
h[x] = h[ed[i].y], t[x] = t[ed[i].x];
fx = h[ed[i].y];
t[fx] = t[ed[i].x], ans += ed[i].w;
}
int x = t[1];
write(ans);
for (; f[x] != x; x = f[x]) printf("%d ", x);
printf("%d\n", x);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a;
cin >> n >> m >> a;
n = ((n % a) ? (1) : (0)) + n / a;
m = ((m % a) ? (1) : (0)) + m / a;
cout << m * n << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
long long lim;
long long M, A, B;
long long cur = 1, ans = 0;
bool vis[MAXN];
long long gcd(long long a, long long b) {
while (a % b) {
a %= b;
swap(a, b);
}
return b;
}
long long gsum(long long N, long long g) {
long long ans = N + 1;
ans += (N % g + 1) * (N / g);
N = N / g * g - 1;
long long steps = N / g;
ans += g * (steps * (steps + 1) / 2);
return ans;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cin >> M >> A >> B;
vis[0] = true;
lim = 0;
while (lim < MAXN && lim <= M) {
if (lim - A >= 0 && vis[lim - A]) {
queue<int> q;
q.push(lim);
vis[lim] = true;
while (!q.empty()) {
cur++;
int fr = q.front();
q.pop();
if (fr + A <= lim && !vis[fr + A]) {
q.push(fr + A);
vis[fr + A] = true;
}
if (fr - B >= 0 && !vis[fr - B]) {
q.push(fr - B);
vis[fr - B] = true;
}
}
}
lim++;
ans += cur;
}
if (M >= MAXN) {
long long g = gcd(A, B);
ans += gsum(M, g) - gsum(MAXN - 1, g);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
point() {}
point(int a, int b) { x = a, y = b; }
};
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T power(T n, T p) {
T res = 1;
for (int i = 0; i < p; i++) res *= n;
return res;
}
template <class T>
double getdist(T a, T b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
template <class T>
T extract(string s, T ret) {
stringstream ss(s);
ss >> ret;
return ret;
}
template <class T>
string tostring(T n) {
stringstream ss;
ss << n;
return ss.str();
}
template <class T>
inline T Mod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
void show(T a) {
cout << a << endl;
}
template <class T>
void show(T a, T b) {
cout << a << ' ' << b << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int hy, ay, dy, hm, am, dm, tem, res = (1 << 28), ph, pa, pd, thy, tay, tdy,
ydec, mdec, time_y, time_m, i, j, k;
cin >> hy >> ay >> dy;
cin >> hm >> am >> dm;
cin >> ph >> pa >> pd;
for (i = 0; i <= 3000; i++) {
for (j = 0; j <= 200; j++) {
for (k = 0; k <= 100; k++) {
thy = hy + i;
tay = ay + j;
tdy = dy + k;
mdec = max(0, tay - dm);
ydec = max(0, am - tdy);
time_y = time_m = (1 << 28);
if (ydec) time_y = (thy / ydec) + (thy % ydec != 0);
if (mdec) time_m = (hm / mdec) + ((hm % mdec != 0));
if (time_y > time_m) res = min(res, (i * ph) + (j * pa) + (k * pd));
}
}
}
assert(res < (1 << 28));
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
inline long long power(long long a, long long b) {
long long x = 1;
a = a % 1000000007ULL;
while (b) {
if (b & 1) x = (x * a) % 1000000007ULL;
a = (a * a) % 1000000007ULL;
b >>= 1;
}
return x;
}
inline long long inv(long long a) { return power(a, 1000000007ULL - 2); }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
int n, k;
bool a[105][105];
int main() {
cin >> n >> k;
if ((long long)k > (long long)n * (long long)n) {
cout << "-1\n";
return 0;
} else {
for (int i = 1; i <= n; i++) {
if (k <= 1) break;
for (int j = 1; j <= n; j++) {
if (k <= 1) break;
if (a[i][j])
continue;
else {
a[i][j] = true;
a[j][i] = true;
k -= 2;
if (i == j) k++;
}
}
}
if (k == 1) {
int i;
for (i = 1; i <= n; i++) {
if (!a[i][i]) {
break;
}
}
if (i == n + 1) {
cout << "-1\n";
return 0;
}
a[i][i] = true;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (a[i][j])
cout << "1 ";
else
cout << "0 ";
}
cout << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void swap(int& a, int& b) {
int c = a;
a = b;
b = c;
}
int main() {
int n;
cin >> n;
int a[100];
int max = 0, min = 0, cmax = 0, cmin = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i == 0)
min = a[i];
else {
if (a[i] <= min) {
min = a[i];
cmin = i;
}
}
if (a[i] > max) {
max = a[i];
cmax = i;
}
}
int count = 0;
for (int i = cmin; i < n - 1; i++) {
swap(a[i], a[i + 1]);
count++;
}
for (int i = 0; i < n; i++) {
if (a[i] == max) {
cmax = i;
break;
}
}
cout << count + cmax;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
double h[N];
int sz[N];
int main() {
int n, t = 0;
scanf("%d", &n);
for (auto i = (1); i <= (n); ++i) {
int x;
scanf("%d", &x);
h[++t] = x;
sz[t] = 1;
while (t > 1 && h[t] <= h[t - 1]) {
h[t - 1] = (h[t] * sz[t] + h[t - 1] * sz[t - 1]) / (sz[t] + sz[t - 1]);
sz[t - 1] += sz[t];
--t;
}
}
for (auto i = (1); i <= (t); ++i) {
for (auto j = (1); j <= (sz[i]); ++j) printf("%.11lf\n", h[i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
int dp[1000];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] == 'V' && s[i + 1] == 'K') {
count++;
dp[i] = 7;
dp[i + 1] = 7;
i = i + 1;
} else if (s[i] == s[i + 1]) {
dp[i] = 1;
dp[i + 1] = 1;
}
}
for (int i = 0; i < 1000; i++) {
if (dp[i] == 1 && dp[i + 1] == 1) {
cout << count + 1 << endl;
return 0;
}
}
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int m) {
bool f = true;
if (m == 2) return f;
if (m == 1) return !f;
int i = 2;
while (i * i <= m) {
if (m % i++ == 0) {
f = false;
break;
}
}
return f;
}
void my_print(int n, int x, int y) {
for (int i = 1; i <= n; i++) {
if (i != x && i != y)
cout << "1 ";
else if (i == x)
cout << "2 ";
else
cout << "3 ";
}
}
int main() {
int n, sum = 0;
cin >> n;
for (int i = 1; i <= n; i++) sum += i;
if (isPrime(sum))
my_print(n, -1, -1);
else {
for (int i = 2; i <= n; i++)
if (isPrime(i) && isPrime(sum - i)) {
my_print(n, i, -1);
return 0;
}
for (int i = 2; i <= n; i++) {
if (i == 3) continue;
if (isPrime(i) && isPrime(sum - 3 - i)) {
my_print(n, i, 3);
return 0;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int arr[300000][8];
int n, m;
int a, b;
void bin_search(int lb, int ub) {
int pos[256];
if (ub - lb < 2) {
return;
}
int next;
next = (lb + ub) / 2;
memset(pos, -1, sizeof(pos));
for (int i = 0; i < n; i++) {
int mask = 0;
for (int j = 0; j < m; j++) {
if (arr[i][j] >= next) {
mask |= 1 << j;
}
}
pos[mask] = i;
}
for (int i = (1 << m) - 1; i >= 0; i--) {
if (pos[i] != -1) {
for (int j = 0; j < m; j++) {
pos[i & (~(1 << j))] = pos[i];
}
}
}
bool valid = false;
for (int i = 0; i < (1 << m); i++) {
if (pos[i] != -1) {
int another;
another = ~i & ((1 << m) - 1);
if (pos[~i & ((1 << m) - 1)] != -1) {
a = pos[i];
b = pos[another];
valid = true;
break;
}
}
}
if (valid) {
bin_search(next, ub);
} else {
bin_search(lb, next);
}
}
int main() {
scanf("%lld %lld", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &arr[i][j]);
}
}
if (n == 1) {
printf("1 1\n");
return 0;
}
bin_search(0, 1000000001);
printf("%d %d\n", a + 1, b + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const double pi = acos(-1.0), eps = 1e-6;
void File() {
freopen("D:\\in.txt", "r", stdin);
freopen("D:\\out.txt", "w", stdout);
}
template <class T>
inline void read(T &x) {
char c = getchar();
x = 0;
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
}
const int maxn = 1000010;
int n, k, pre[maxn];
long long f[30], mod = 1e9 + 7;
char s[maxn];
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s);
int m = strlen(s);
for (int i = 1; i <= m; i++) {
long long sum = 0;
for (int j = 1; j <= k; j++) sum = (sum + f[j]) % mod;
f[s[i - 1] - 'a' + 1] = (sum + 1) % mod;
pre[s[i - 1] - 'a' + 1] = i;
}
for (int i = m + 1; i <= m + n; i++) {
long long sum = 0;
for (int j = 1; j <= k; j++) sum = (sum + f[j]) % mod;
int mx = 3 * maxn, mi;
for (int j = 1; j <= k; j++)
if (pre[j] < mx) mi = j, mx = pre[j];
f[mi] = (sum + 1) % mod;
pre[mi] = i;
}
long long ans = 0;
for (int i = 1; i <= k; i++) ans = (ans + f[i]) % mod;
printf("%lld\n", (ans + 1) % mod);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, b, c = 0;
cin >> n;
stack<long long> s;
map<long long, long long> ma;
queue<long long> q;
for (long long i = 0; i < n; i++) {
cin >> b;
q.push(b);
}
for (long long j = 0; j < n; j++) {
cin >> b;
if (ma.find(b) == ma.end()) {
while (b != q.front()) {
ma[q.front()]++;
c++;
q.pop();
}
c++;
q.pop();
cout << c << " ";
c = 0;
} else
cout << c << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 + 9e6;
const int inf = 0x3f3f3f;
vector<bool> dp[24];
int n;
int a[23];
vector<pair<int, int> > pre[23];
int ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < 24; i++) dp[i].resize(1 << n);
for (int i = 1; i < n; ++i) {
for (int j = 0; j < i; ++j) {
for (int k = j; k < i; ++k) {
if (a[j] + a[k] == a[i]) {
pre[i].push_back({j, k});
}
}
}
}
dp[0][0] = 0;
dp[0][1] = 1;
for (int i = 0; i < n - 1; ++i) {
for (int mask = 0; mask < (1 << n); ++mask) {
if (dp[i][mask]) {
for (int j = 0; j < pre[i + 1].size(); ++j) {
int u = pre[i + 1][j].first;
int v = pre[i + 1][j].second;
if (((mask >> u) & 1) && ((mask >> v) & 1)) {
int bit = mask + (1 << (i + 1));
dp[i + 1][bit] = 1;
for (int k = 0; k < i + 1; ++k) {
if (((bit >> k) & 1)) {
dp[i + 1][bit ^ (1 << k)] = 1;
}
}
}
}
}
}
}
ans = inf;
for (int mask = 0; mask < (1 << n); ++mask) {
if (dp[n - 1][mask]) {
ans = min(ans, (int)(__builtin_popcount(mask)));
}
}
if (ans == inf)
cout << -1;
else
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long const MX = 90;
long long t, fib[MX];
bool used[MX];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
fib[0] = 1;
fib[1] = 2;
for (long long i = 2; i < MX; i++) fib[i] = fib[i - 1] + fib[i - 2];
while (t--) {
long long n;
cin >> n;
for (long long i = MX - 1; ~i; i--)
if (used[i] = (n >= fib[i])) n -= fib[i];
long long dp1 = 1, dp2 = 0, last = -1;
for (long long i = 0; i < MX; i++)
if (used[i]) {
long long tmp1 = dp1 + dp2,
tmp2 = ((i - last - 1) / 2) * dp1 + ((i - last) / 2) * dp2;
dp1 = tmp1, dp2 = tmp2, last = i;
}
cout << dp1 + dp2 << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, x, p[55], a[55][55];
int cnt[55], q;
bool s = 1;
void solve1() {
cin >> n;
for (int i = 1; i <= n; i++) {
q = 0;
for (int j = 1; j <= n; j++) {
cin >> x;
q = max(q, x);
}
if (q == n - 1) {
if (s) {
q = n;
s = 0;
}
}
cout << q << " ";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve1();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int n;
long long s, cntv[30];
long long Pow(long long x, long long p) {
long long rnt = 1;
while (p) {
if (p & 1) rnt = rnt * x % MOD;
x = x * x % MOD;
p >>= 1;
}
return rnt;
}
long long Inv(long long x) {
return x == 1 ? 1 : Inv(MOD % x) * (MOD - MOD / x) % MOD;
}
long long C(long long a, long long b) {
long long rnt = 1, tmp = 1;
for (int i = 1; i <= b; ++i) rnt = (a - i + 1) % MOD * rnt % MOD;
for (int i = 1; i <= b; ++i) rnt = rnt * Inv(i) % MOD;
return rnt;
}
int main() {
int n;
long long s;
scanf("%d%lld", &n, &s);
for (int i = 1; i <= n; ++i) scanf("%lld", &cntv[i]);
long long ans = 0;
for (int i = 0; i < (1 << n); ++i) {
int k = (__builtin_popcount(i) & 1) ? -1 : 1;
long long sumv = 0;
for (int j = 1; j <= n; ++j)
if (i & (1 << j - 1)) sumv += cntv[j] + 1;
if (sumv > s) continue;
ans = (ans + k * C(s - sumv + n - 1, n - 1)) % MOD;
}
printf("%lld", (ans % MOD + MOD) % MOD);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void da(int *a, int s, int e) {
for (int i = s; i < e; i++) cout << a[i] << " ";
}
void db(string s) { cout << s << '\n'; }
void cp(int *a, int *b, int n) {
for (int i = 0; i < n; i++) b[i] = a[i];
}
void de(int a) { cout << a << " <\n"; }
const long long N = 1e5 + 10, MOD = 1e9 + 7, INF = 1e15 + 10, LOG = 20;
long long g[N];
int dp[2][1 << LOG];
inline double calc(double k, int n) { return k * k / 2 * (n - 1) / n; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
long long x;
cin >> x;
g[i] ^= x << j;
}
int n2 = n / 2;
for (int mask = 0; mask < 1 << n2; mask++)
if (mask) {
int u = 63 - __builtin_clzll(mask);
dp[0][mask] = max(dp[0][mask ^ 1LL << u], dp[0][mask & g[u]] + 1);
}
int M = n - n2, ans = 0;
for (int mask = 0; mask < 1 << M; mask++) {
if (mask) {
int u = 63 - __builtin_clzll(mask);
dp[1][mask] =
max(dp[1][mask ^ 1LL << u], dp[1][mask & (g[u + n2] >> n2)] + 1);
}
int T = (1 << n2) - 1;
for (int i = 0; i < M; i++)
if (mask >> i & 1) T &= g[i + n2];
ans = max(ans, dp[1][mask] + dp[0][T]);
}
cout << fixed << setprecision(10) << calc(k, ans) << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[200000];
char n[128];
char str1[10], str2[10];
int j, m, len;
while (scanf("%d%d", &len, &m) != EOF) {
scanf("%s", str);
for (int i = 97; i <= 122; i++) {
n[i] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%s%s", str1, str2);
for (int i = 97; i <= 122; i++) {
if (n[i] == str1[0]) {
n[i] = str2[0];
} else if (n[i] == str2[0]) {
n[i] = str1[0];
}
}
}
for (int i = 0; i < len; i++) {
printf("%c", n[str[i]]);
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long arr[k + 1];
long long c[k + 1];
memset(arr, 0, sizeof(arr));
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
arr[a]++;
}
for (int i = 1; i <= k; i++) cin >> c[i];
long long dea[k + 1];
memset(dea, 0, sizeof(dea));
dea[k] = arr[k];
long long ans = dea[k] / c[k];
for (int i = k - 1; i >= 0; i--) {
dea[i] = dea[i + 1] + arr[i];
ans = max(ans, (long long)ceil((double)dea[i] / (double)c[i]));
}
cout << ans << endl;
vector<vector<int> > dus(ans);
long long y = k;
int i = 0;
while (1) {
while (y >= 0 && arr[y] == 0) y--;
if (y == -1) break;
dus[i].push_back(y);
arr[y]--;
i = (i + 1) % ans;
}
for (int i = 0; i < ans; i++) {
cout << dus[i].size() << " ";
for (int j = 0; j < dus[i].size(); j++) cout << dus[i][j] << " ";
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int g_s[100100];
struct tagst {
int ty;
int tar;
int id;
};
struct tagin {
int t, s, f, id;
bool operator<(const tagin& aa) const { return t < aa.t; }
};
tagin gin[100100];
vector<tagst> g_v[100100];
int g_h;
long long g_ans[100100];
int indWait, iInEle, iReach, wsum;
void update(int pos, int val) {
while (pos < 100100) {
g_s[pos] += val;
pos += ((pos) & (-(pos)));
}
}
int getsum(int pos) {
int ret = 0;
while (pos) {
ret += g_s[pos];
pos -= ((pos) & (-(pos)));
}
return ret;
}
int search(int low, int high, int val) {
int mid;
while (low <= high) {
mid = (low + high) >> 1;
if (getsum(mid) >= val) {
high = mid - 1;
} else
low = mid + 1;
}
return low;
}
int main() {
int n, i, cnt, j, wup, wdown, nowfloor = 1;
cin >> n >> g_h;
for (i = 0; i < n; i++) {
scanf("%d%d%d", &gin[i].t, &gin[i].s, &gin[i].f);
gin[i].id = i;
}
long long iTo, iTmp, iCha;
sort(gin, gin + n);
long long time = gin[0].t;
tagst sttmp;
while (1) {
while (time == gin[indWait].t && indWait < n) {
sttmp.tar = gin[indWait].f;
sttmp.ty = 0;
sttmp.id = gin[indWait].id;
g_v[gin[indWait].s].push_back(sttmp);
update(gin[indWait].s, 1);
indWait++;
wsum++;
}
if (cnt = g_v[nowfloor].size()) {
for (i = 0; i < g_v[nowfloor].size(); i++) {
if (g_v[nowfloor][i].ty == 0) {
sttmp.ty = !0;
sttmp.id = g_v[nowfloor][i].id;
update(g_v[nowfloor][i].tar, 1);
g_v[g_v[nowfloor][i].tar].push_back(sttmp);
} else {
g_ans[g_v[nowfloor][i].id] = time;
iReach++;
wsum--;
}
}
update(nowfloor, -cnt);
g_v[nowfloor].clear();
}
if (iReach == n) break;
wdown = getsum(nowfloor);
wup = wsum - wdown;
if (wup >= wdown) {
if (wup == 0) {
time = gin[indWait].t;
continue;
} else {
iTo = search(nowfloor, g_h, getsum(nowfloor) + 1);
iCha = iTo - nowfloor;
if (indWait < n)
iTmp = gin[indWait].t - time;
else
iTmp = iCha + 1;
}
if (iCha > iTmp) {
nowfloor += iTmp;
time = gin[indWait].t;
} else {
time += iCha;
nowfloor = iTo;
}
} else {
iTo = search(1, nowfloor, getsum(nowfloor));
iCha = nowfloor - iTo;
if (indWait < n)
iTmp = gin[indWait].t - time;
else
iTmp = iCha + 1;
if (iCha > iTmp) {
nowfloor -= iTmp;
time = gin[indWait].t;
} else {
time += iCha;
nowfloor = iTo;
}
}
}
for (i = 0; i < n; i++) {
printf("%I64d\n", g_ans[i]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
mt19937 eng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 1e5 + 4;
struct Node {
int l, r, val;
Node* lc;
Node* rc;
Node(int l_, int r_) : l(l_), r(r_), val(-1) {
lc = rc = nullptr;
if (l == r) {
return;
}
int m = (l + r) / 2;
lc = new Node(l, m);
rc = new Node(m + 1, r);
}
void update(int x, int pos) {
if (l == r) {
val = x;
return;
}
int m = (l + r) / 2;
if (pos <= m) {
lc->update(x, pos);
} else {
rc->update(x, pos);
}
val = min(rc->val, lc->val);
}
int compute(int l_, int r_) {
if (l_ == l && r_ == r) {
return val;
}
int m = (l + r) / 2;
if (r_ <= m) {
return lc->compute(l_, r_);
} else if (l_ > m) {
return rc->compute(l_, r_);
} else {
return min(lc->compute(l_, m), rc->compute(m + 1, r_));
}
}
};
bool used[N];
int l[N], n;
vector<int> a;
void read() {
cin >> n;
a.resize(n);
for (int& i : a) cin >> i;
}
void solve() {
read();
Node* root = new Node(1, n + 4);
for (int i = 0; i < n; ++i) {
int u = a[i];
int cur;
if (u == 1) {
cur = (l[u] == i - 1 ? -1 : i - 1);
} else {
cur = root->compute(1, u - 1);
}
used[u] |= (cur >= l[u]);
l[u] = i;
root->update(i, u);
}
used[1] |= (l[1] < n - 1);
for (int i = 2; i <= n + 1; ++i) {
int cur = root->compute(1, i - 1);
used[i] |= (cur >= l[i]);
}
for (int i = 1; i <= n + 2; ++i) {
if (!used[i]) {
cout << i << "\n";
return;
}
}
}
int main() {
ios::sync_with_stdio(0);
cout.tie(0), cin.tie(0);
int z = 1;
while (z--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxElement = 1e6;
vector<int> smallest_pf(kMaxElement);
void sieve_of_eratosthenes() {
for (int i = 1; i < kMaxElement; ++i) smallest_pf[i] = (i % 2 ? i : 2);
for (int i = 3; i * i < kMaxElement; i += 2) {
if (smallest_pf[i] != i) continue;
for (int j = i * i; j < kMaxElement; j += i) {
if (smallest_pf[j] == j) smallest_pf[j] = i;
}
}
}
vector<long long> a;
long long min_rearrangement(vector<long long>& vec, long long factor) {
int n = vec.size();
long long sum = 0, median_idx = -1;
for (long long i = 0; i < n; ++i) {
long long sum_before = sum;
long long sum_after = sum + vec[i];
if (sum_before <= factor / 2 && sum_after > factor / 2) {
median_idx = i;
break;
}
sum = sum_after;
}
long long num_moves = 0;
for (int i = 0; i < n; ++i) {
num_moves += 1ll * abs(median_idx - i) * vec[i];
}
return num_moves;
}
long long find_ans(long long factor) {
int n = a.size();
long long sum = 0, ret_value = 0;
vector<long long> current_set;
for (int i = 0; i < n; ++i) {
if (sum + a[i] % factor >= factor) {
current_set.push_back(factor - sum);
ret_value += min_rearrangement(current_set, factor);
current_set.clear();
long long retained_value = sum + a[i] % factor - factor;
if (retained_value) {
current_set.push_back(retained_value);
}
sum = retained_value;
} else {
if (a[i] % factor == 0 && current_set.empty()) continue;
current_set.push_back(a[i] % factor);
sum += a[i] % factor;
}
}
return ret_value;
}
int main() {
int n;
scanf("%d", &n);
a = vector<long long>(n);
long long sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%lld", &a[i]);
sum += a[i];
}
sieve_of_eratosthenes();
long long ans = 2e18, dup_sum = sum;
for (long long i = 2; i * i <= sum; ++i) {
if (smallest_pf[i] != i || sum % i) continue;
ans = min(ans, find_ans(i));
while (dup_sum % i == 0) dup_sum /= i;
}
if (dup_sum > 1) {
ans = min(ans, find_ans(dup_sum));
}
if (ans == 2e18) ans = -1;
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
cin >> test;
while (test--) {
long long n, k, ans = 0;
cin >> n >> k;
while (n) {
ans += (n % k);
if (n >= k) ans++;
n /= k;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
cout << (n + 1) / 2 << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, p[16];
long long k;
long long ofmul(long long a, long long b) {
if (a * 1.0 * b > 4e18) {
return 3e18;
}
return a * b;
}
void generisi(vector<int> p, vector<long long>& a) {
set<long long> sk;
sk.insert(1);
long long last = -1;
while (last < 1.1e18) {
last = *sk.begin();
sk.erase(last);
a.push_back(last);
for (int pr : p) {
sk.insert(ofmul(last, pr));
}
}
}
vector<int> p1, p2;
vector<long long> a, b;
long long soll(long long x) {
long long sol = 0;
for (long long y : a) {
sol += upper_bound(b.begin(), b.end(), x / y) - b.begin();
}
return sol;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
cin >> k;
for (int i = 0; i < n; i++) {
if (__builtin_popcount(i) % 2) {
p1.push_back(p[i]);
} else {
p2.push_back(p[i]);
}
}
generisi(p1, a);
generisi(p2, b);
long long l = 0, r = 1.1e18, m, o = -1;
while (l <= r) {
m = (l + r) / 2;
long long vr = soll(m);
cerr << m << ' ' << vr << '\n';
if (vr < k) {
l = m + 1;
} else {
r = m - 1;
o = m;
}
}
cout << o;
}
| 8 |
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
using namespace std;
int main() {
int q = 1;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> qu(n, -1), ki(n, -1);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 0; j < x; j++) {
int m;
cin >> m;
if (ki[m - 1] == -1 && qu[i] == -1) {
qu[i] = m;
ki[m - 1] = i;
}
}
}
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
if (qu[i] == -1) {
int j = 0;
while (ki[j] != -1) {
j++;
}
v.push_back({i + 1, j + 1});
}
}
if (v.size()) {
cout << "IMPROVE" << endl;
cout << v[0].first << " " << v[0].second << endl;
} else
cout << "OPTIMAL" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, sum;
int main() {
cin >> a >> b;
for (int i = 1; i <= a; i++) {
cin >> n;
if (n > b)
sum += 2;
else
sum++;
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
long long int i, j, k, n, m, a, b, c, d, p, q, r, l, x, t = 1;
long long int sum, counted, ans = 0;
string s;
cin >> n;
while (n >= 100) {
n -= 100;
ans++;
}
while (n >= 20) {
n -= 20;
ans++;
}
while (n >= 10) {
n -= 10;
ans++;
}
while (n >= 5) {
n -= 5;
ans++;
}
while (n >= 1) {
n -= 1;
ans++;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const char NL = '\n';
long long int mod = 1000000007;
clock_t startTime;
double getCurrentTime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
void read(vector<long long int> &a) {
for (auto &it : a) cin >> it;
}
struct ele {
long long int val;
long long int dir;
long long int cost;
};
vector<bool> vis(101);
long long int dfs(long long int proot, long long int root,
vector<vector<struct ele>> &g) {
if (vis[root] || (root == 1 && proot != -1)) return 0;
vis[root] = 1;
long long int cost = 0;
long long int mcost = LLONG_MAX;
for (struct ele i : g[root]) {
if (i.val != proot) {
if (i.dir == 0) {
cost += i.cost;
}
cost += dfs(root, i.val, g);
mcost = min(mcost, cost);
}
}
return mcost;
}
inline void solve() {
long long int n;
cin >> n;
vector<vector<struct ele>> g(n + 1);
long long int totalcost = 0;
for (long long int i = 0; i < n; i++) {
long long int x, y, c;
cin >> x >> y >> c;
totalcost += c;
g[x].push_back({y, 1, c});
g[y].push_back({x, 0, c});
}
long long int cost = dfs(-1, 1, g);
cout << min(cost, totalcost - cost) << NL;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
startTime = clock();
solve();
fflush(stdin);
fflush(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5050;
const int MOD = 1000000007;
int n, threshold;
short x[MAXN], y[MAXN], dist[MAXN][MAXN];
int mark[MAXN];
bool dfs(int pos, int color = 0) {
if (mark[pos] != -1) return mark[pos] == color;
mark[pos] = color;
for (register int i = (0); i < (int)(n); ++i)
if (dist[pos][i] > threshold && !dfs(i, color ^ 1)) return false;
return true;
}
int count_ways() {
memset(mark, -1, sizeof mark);
int res = 1;
for (register int i = (0); i < (int)(n); ++i)
if (mark[i] == -1) {
if (!dfs(i)) return -1;
res = res * 2 % MOD;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (register int i = (0); i < (int)(n); ++i) {
cin >> x[i] >> y[i];
for (register int j = (0); j < (int)(i + 1); ++j)
dist[i][j] = dist[j][i] = abs(x[i] - x[j]) + abs(y[i] - y[j]);
}
int lo = 0, hi = 10000;
while (lo < hi) {
threshold = (lo + hi) / 2;
if (count_ways() == -1)
lo = threshold + 1;
else
hi = threshold;
}
threshold = lo;
cout << threshold << endl;
cout << count_ways() << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = -1;
long long n, DOS[60], S[60];
long long solve(long long n) {
if (!n) return 0;
int p = 0;
while (DOS[p + 1] <= n) p++;
long long k = DOS[p];
return DOS[p] + (p ? DOS[p - 1] * p : 0) + solve(n - k);
}
int main() {
DOS[0] = 1;
for (int i = (1); i < (int)(50); i++) DOS[i] = DOS[i - 1] * 2;
while (scanf("%lld", &n) == 1) {
printf("%lld\n", solve(n - 1));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
}
if (n <= 3 || n % 2 == 1) {
cout << "NO\n";
return 0;
}
vector<pair<int, int>> b;
a.push_back(a[0]);
for (int i = 1; i <= n; ++i) {
b.push_back({a[i].first - a[i - 1].first, a[i].second - a[i - 1].second});
}
bool good = true;
for (int i = 0; i < n / 2; ++i) {
good = good & (b[i].first == -b[i + n / 2].first &&
b[i].second == -b[i + n / 2].second);
}
cout << (good ? "YES" : "NO") << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, mod = 1e9 + 7;
const int N = 100005;
int i, j, k, n, m, x, y, x2, y2, M;
pair<int, int> ST[4 * N], a[N], b[N];
vector<pair<int, int> > v[N], v2[N];
vector<pair<int, pair<int, int> > > blue;
vector<pair<pair<int, int>, int> > red;
vector<pair<pair<int, pair<int, int> >, pair<int, int> > > temp;
map<int, int> h;
pair<int, int> merge(pair<int, int> x, pair<int, int> y) {
pair<int, int> temp;
if (x.first > y.first) {
temp.first = x.first;
temp.second = max(x.second, y.first);
} else {
temp.first = y.first;
temp.second = max(y.second, x.first);
}
return temp;
}
pair<int, int> update(int k, int bas, int son, int x, int t) {
if (bas > x || son < x) return ST[k];
if (bas == son) {
if (ST[k].first <= t) ST[k].first = t;
return ST[k];
}
return ST[k] = merge(update((k + k), bas, (bas + son >> 1), x, t),
update((k + k + 1), (bas + son >> 1) + 1, son, x, t));
}
pair<int, int> query(int k, int bas, int son, int x, int y) {
if (bas > y || son < x) return make_pair(-inf, -inf);
if (x <= bas && son <= y) return ST[k];
return merge(query((k + k), bas, (bas + son >> 1), x, y),
query((k + k + 1), (bas + son >> 1) + 1, son, x, y));
}
bool ctr(int time) {
temp.clear();
h.clear();
for (int i = 1; i <= 20000; i++) {
v[i].clear();
v2[i].clear();
}
blue.clear();
red.clear();
for (int i = 1; i <= 100000; i++) ST[i] = make_pair(-inf, -inf);
for (int i = 1; i <= n; i++) {
x = a[i].first - time;
y = a[i].second + time;
x2 = a[i].first + time;
y2 = a[i].second - time;
int temp = x;
x = x + y;
y = y - temp;
temp = x2;
x2 = x2 + y2;
y2 = y2 - temp;
::temp.push_back(
make_pair(make_pair(0, make_pair(x, y)), make_pair(x2, y2)));
h[x] = 1;
h[x2] = 1;
h[y] = 1;
h[y2] = 1;
}
for (int i = 1; i <= m; i++) {
x = b[i].first - time;
y = b[i].second - time;
x2 = b[i].first + time;
y2 = b[i].second + time;
int temp = x;
x = x + y;
y = y - temp;
temp = x2;
x2 = x2 + y2;
y2 = y2 - temp;
::temp.push_back(
make_pair(make_pair(1, make_pair(x, y)), make_pair(x2, y2)));
h[x] = 1;
h[x2] = 1;
h[y] = 1;
h[y2] = 1;
}
M = 0;
for (__typeof(h.begin()) it = h.begin(); it != h.end(); it++)
it->second = ++M;
for (__typeof(temp.begin()) it = temp.begin(); it != temp.end(); it++)
if (it->first.first == 0) {
v[h[it->first.second.first]].push_back(
make_pair(h[it->second.second], h[it->first.second.second]));
} else {
v2[h[it->second.second]].push_back(
make_pair(h[it->first.second.first], h[it->second.first]));
}
for (int i = 1; i <= M; i++) {
sort(v[i].begin(), v[i].end());
int k = 0, last = 0;
for (int j = 0; j <= (int)v[i].size() - 1; j++) {
last = max(last, v[i][j].second);
while (k < v[i].size() && last >= v[i][k].first) {
last = max(last, v[i][k].second);
k++;
}
v[i][j].second = last;
blue.push_back(make_pair(i, make_pair(v[i][j].first, v[i][j].second)));
}
}
for (int i = 1; i <= M; i++) {
sort(v2[i].begin(), v2[i].end());
int k = 0, last = 0;
for (int j = 0; j <= (int)v2[i].size() - 1; j++) {
last = max(last, v2[i][j].second);
while (k < v2[i].size() && last >= v2[i][k].first) {
last = max(last, v2[i][k].second);
k++;
}
v2[i][j].second = last;
red.push_back(make_pair(make_pair(v2[i][j].first, v2[i][j].second), i));
}
}
sort(blue.begin(), blue.end());
sort(red.begin(), red.end());
int w = 0;
for (int i = 0; i <= (int)blue.size() - 1; i++) {
while (w < red.size() && red[w].first.first <= blue[i].first) {
update(1, 1, M, red[w].second, red[w].first.second);
w++;
}
for (int j = i + 1; j <= blue.size() - 1; j++) {
if (blue[j].first == blue[i].first) continue;
int xx = max(blue[i].second.first, blue[j].second.first);
int yy = min(blue[i].second.second, blue[j].second.second);
if (query(1, 1, M, xx, yy).second >= blue[j].first) return true;
}
}
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &b[i].first, &b[i].second);
}
int l = 0, r = 1e6 + 1;
if (ctr(r) == 0) {
cout << "Poor Sereja!" << '\n';
return 0;
}
while (l < r) {
int mid = l + r >> 1;
if (ctr(mid))
r = mid;
else
l = mid + 1;
}
cout << l << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
int p = 0;
for (int i = 0; i < s.size(); i++) {
int t = (int)s[i];
int y = 0;
for (int j = 0; j < 8; j++) {
y *= 2;
y += t % 2;
t /= 2;
}
int u = y;
y = (p - y) % 256;
while (y < 0) y += 256;
cout << y << endl;
p = u;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using V = vector<T>;
const double Pi = acos(-1.0);
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int hh, mm, d;
char ch;
while (cin >> hh >> ch >> mm >> d) {
d += mm;
mm = d % 60;
hh += d / 60;
hh %= 24;
cout.fill('0');
cout << setw(2) << hh << ch << setw(2) << mm << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int v[105];
int main() {
int i, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &v[i]);
int l, r;
do {
l = r = -1;
for (i = 1; i < n; i++) {
if (l == -1) {
if (v[i] > v[i + 1]) {
l = i;
swap(v[i], v[i + 1]);
i++;
}
} else {
if (v[i] <= v[i + 1]) {
r = i - 1;
break;
}
swap(v[i], v[i + 1]);
i++;
}
}
if (r == -1) r = (((n - l) & 1) ? n : n - 1);
if (l != -1) printf("%d %d\n", l, r);
} while (l != -1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[100001], s[100001], n, d, b, ans;
int main() {
long long i, j, l, r, mid, s1, s2, t1, t2;
scanf("%I64d %I64d %I64d", &n, &d, &b);
for (i = 1; i <= n; i++) scanf("%I64d", &a[i]), s[i] = s[i - 1] + a[i];
l = 1;
r = n;
ans = n + 1;
while (l <= r) {
mid = (l + r) / 2;
s1 = 0;
s2 = 0;
t1 = 0;
t2 = 0;
for (i = 1; i <= mid; i++) {
j = min(i + min(i, n - i + 1) * d, mid);
if (a[i] + s1 + s[j] - s[i] >= b) {
t1++;
s1 = s1 - (b - a[i]);
} else {
s1 = s1 + a[i];
}
}
for (i = n; i >= mid; i--) {
j = max(mid, i - min(i, (n - i + 1)) * d);
if (a[i] + s2 + s[i - 1] - s[j - 1] >= b) {
t2++;
s2 = s2 - (b - a[i]);
} else {
s2 = s2 + a[i];
}
}
ans = min(ans, max(mid - t1, n - mid - t2 + 1));
if (mid - t1 < n - mid - t2 + 1)
r = mid - 1;
else
l = mid + 1;
}
printf("%I64d", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline void bin(T n, int pos) {
T i, one = 1, two = 2;
for (i = (one << (pos - 1)); i > 0; i = (i >> 1))
cout << ((n & i) ? "1" : "0");
cout << endl;
}
int lsb(unsigned int v) {
int r;
static const int MultiplyDeBruijnBitPosition[32] = {
0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9};
r = MultiplyDeBruijnBitPosition[((uint32_t)((v & -v) * 0x077CB531U)) >> 27];
return r + 1;
}
template <class T>
inline int msb(T n) {
return (n == 0) ? 0 : (1 + msb(n >> 1));
}
template <class T>
inline T getbit(T n, int pos) {
return ((n & (1 << pos)) ? 1 : 0);
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline void setbit(T &n, int p) {
n = n | (1LL << p);
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
bool isequal(vector<int> a, vector<int> b) {
for (int i = 0; i < (a.size()); i++)
if (a[i] != b[i]) return false;
return true;
}
template <class T>
bool allequal(vector<T> a) {
sort(a.begin(), a.end());
return a[0] == a[a.size() - 1];
}
template <class T>
void printarray(vector<T> a) {
for (int i = 0; i < (a.size()); i++) cout << a[i] << " ";
cout << endl;
}
void printmatrix(vector<vector<int>> a, int n, int m) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << setw(4) << a[i][j];
}
cout << endl;
}
}
void readmatrix(vector<vector<int>> &a, int n, int m) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
}
template <class T>
void printsubarray(vector<T> a, int start, int end) {
if (start < 0 or end > a.size() - 1) cout << "Out of bounds" << endl;
for (int i = start; i <= end; i++) cout << a[i] << " ";
cout << endl;
}
bool isprime(int n) {
if (n < 2) return false;
if (n == 2) return true;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
void split(const string &s, char c, vector<string> &result) {
stringstream ss(s);
string x;
while (getline(ss, x, c)) result.push_back(x);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
void yup() { cout << "Yes" << endl; }
void nope() { cout << "No" << endl; }
void Yup() { cout << "YES" << endl; }
void Nope() { cout << "NO" << endl; }
void readarray(vector<int> &a, int size) {
int tmp;
a.clear();
for (int i = 0; i < (size); i++) {
cin >> tmp;
a.push_back(tmp);
}
}
void solvecase() {
int n, m;
int k;
cin >> n;
pair<int, int> g[111];
for (int i = 0; i < n; i++) {
cin >> g[i].first >> g[i].second;
}
bool ok = true;
if (g[0].first < g[0].second) ok = false;
for (int i = 1; i < n; i++) {
if ((g[i].first < g[i - 1].first) or (g[i].second < g[i - 1].second))
ok = false;
}
for (int i = 1; i < n; i++) {
int jumpc = g[i].second - g[i - 1].second;
int jumpp = g[i].first - g[i - 1].first;
if (jumpc > jumpp) ok = false;
}
ok ? Yup() : Nope();
}
int main() {
int cases = 1;
cin >> cases;
while (cases--) {
solvecase();
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.