solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int i, i0, n, m, ans, p;
int main() {
scanf("%d %d", &n, &p);
for (int i = 0; i <= 1000000; i++) {
int m = n - i * p;
if (m < 0) break;
if (__builtin_popcount(m) <= i && m >= i && __builtin_popcount(m)) {
printf("%d\n", i);
return 0;
}
}
printf("-1\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
int Ans;
string s;
int Cost(char Bla1, char Bla2) {
int Blaa = Bla1 - 'a';
int Blla = Bla2 - 'a';
int Cost1 = max(Blaa, Blla) - min(Blaa, Blla);
int Cost2 = (min(Blaa, Blla) + 1) + (25 - max(Blaa, Blla));
return min(Cost1, Cost2);
}
int Get(int X) {
int Bla = n - 1 - X;
return Bla;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
cin >> s;
q--;
if (q > (n >> 1) - 1) q = (n - q - 1);
int Bla = q, BlaBla = q;
for (int i = 0; i <= (n >> 1) - 1; i++) {
if (s[i] != s[Get(i)]) {
Ans += Cost(s[i], s[Get(i)]);
Bla = min(Bla, i);
BlaBla = max(BlaBla, i);
}
}
cout << Ans + (max(Bla, BlaBla) - min(Bla, BlaBla)) +
min((max(q, Bla) - min(q, Bla)),
(max(q, BlaBla) - min(q, BlaBla)))
<< endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long pow(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % c;
a = (a * a) % c;
b >>= 1;
}
return ans;
}
long long modInv(long long p) { return pow(p, 1000000007 - 2, 1000000007); }
long long F[100000 + 5], FP[100000 + 5];
void initFact() {
F[0] = 1;
for (int i = 1; i <= 100000; ++i)
F[i] = ((long long)i * F[i - 1]) % 1000000007;
FP[100000] = modInv(F[100000]);
for (int i = 100000 - 1; i >= 0; --i)
FP[i] = (FP[i + 1] * (long long)(i + 1)) % 1000000007;
}
long long comb(int n, int k) {
if (k > n) return 0;
long long ans = (F[n] * FP[n - k]) % 1000000007;
ans = (ans * FP[k]) % 1000000007;
return ans;
}
int P[100000 + 5];
vector<int> D[100000 + 5];
void initSieve() {
memset(P, -1, sizeof(P));
for (int i = 2; i * i <= 100000; ++i)
if (P[i] == -1)
for (int j = i * i; j <= 100000; j += i) P[j] = i;
}
void primefact(int n, vector<int> &p, vector<int> &e) {
while (1) {
if (n == 1) break;
if (P[n] == -1) {
p.push_back(n);
e.push_back(1);
return;
}
int pk = P[n], exp = 0;
while (n % pk == 0) n /= pk, exp++;
p.push_back(pk);
e.push_back(exp);
}
}
vector<int> getDiv(vector<int> &p, vector<int> &e) {
int n = p.size();
vector<int> d(1, 1);
for (int i = 0; i < n; ++i) {
int m = ((int)d.size());
for (int j = 0; j < e[i]; ++j) {
for (int k = 0; k < m; ++k) d.push_back(p[i] * d[k + j * m]);
}
}
return d;
}
void impr(vector<int> v) {
for (int i = 0; i < ((int)v.size()); ++i)
printf("%d%c", v[i], i + 1 == ((int)v.size()) ? 10 : 32);
}
int fix(int x) {
while (x >= 1000000007) x -= 1000000007;
while (x < 0) x += 1000000007;
return x;
}
int memo[100000 + 5];
bool used[100000 + 5];
int f;
vector<int> p, e, d;
int dp(int n) {
if (used[n]) return memo[n];
used[n] = 1;
int &dev = memo[n] = 0;
for (int i = 0; i < ((int)D[n].size()); ++i)
if (D[n][i] < n) {
if (n % D[n][i] == 0) dev = fix(dev + dp(D[n][i]));
} else
break;
dev = fix(comb(n - 1, f - 1) - dev);
return dev;
}
int main() {
initFact();
initSieve();
for (int n = 1; n <= 100000; ++n) {
p.clear();
e.clear();
primefact(n, p, e);
d = getDiv(p, e);
sort(d.begin(), d.end());
D[n] = d;
}
int cases, n;
scanf("%d", &cases);
for (int tc = 0; tc < cases; ++tc) {
scanf("%d", &n), scanf("%d", &f);
for (int i = 0; i < ((int)D[n].size()); ++i) used[D[n][i]] = 0;
printf("%d\n", dp(n));
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
unsigned long long int bigMod(unsigned long long int b,
unsigned long long int p,
unsigned long long int m) {
b = b % m;
if (p == 0)
return 1;
else if (p % 2 == 0)
return ((unsigned long long int)pow(bigMod(b, p / 2, m), 2)) % m;
else
return ((unsigned long long int)pow(bigMod(b, (p - 1) / 2, m), 2) * b) % m;
}
unsigned long long int nCr(unsigned long long int n, unsigned long long int r) {
unsigned long long int ans = 1;
if (r >= n - r) {
for (unsigned long long int i = r + 1; i <= n; i++) {
ans = ans * i;
}
for (unsigned long long int i = 1; i <= n - r; i++) {
ans = ans / i;
}
} else {
for (unsigned long long int i = n - r + 1; i <= n; i++) {
ans = ans * i;
}
for (unsigned long long int i = 1; i <= r; i++) {
ans = ans / i;
}
}
return ans;
}
unsigned long long int fib(unsigned long long int a) {
const long double root5 = sqrt(5);
const long double root5plus1div2 = (root5 + 1) / 2;
return round(pow(root5plus1div2, a) / root5);
}
unsigned long long int gcd(unsigned long long int a, unsigned long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
unsigned long long int lcm(unsigned long long int a, unsigned long long int b) {
return ((a * b) / gcd(a, b));
}
bool isPrime(unsigned long long int a) {
if (a % 2 == 0) return false;
for (int i = 3; i <= sqrt(a); i += 2) {
if (a % i == 0) return false;
}
return true;
}
bool isComposite(unsigned long long int a) {
if (isPrime(a))
return false;
else
return true;
}
bool coPrime(unsigned long long int a, unsigned long long int b) {
if (gcd(a, b) == 1)
return true;
else
return false;
}
long double toRadian(long double deg) { return (deg * acos(-1) / 180); }
unsigned long long int strToInt(string a) {
int len = a.length();
int power = 0;
unsigned long long int tot = 0;
for (int i = len - 1; i >= 0; i--) {
tot = tot + pow(10, power) * (a[i] - '0');
power++;
}
return tot;
}
bool desc(int a, int b) { return a > b; }
unsigned long long int mex(int* arr, int n) {
sort(arr, arr + n);
int now = -1;
for (int i = 0; i < n; i++) {
if (arr[i] == now + 1) {
now++;
} else if (arr[i] == now) {
} else {
return now + 1;
}
}
return now + 1;
}
long long int euclid_ext(long long int a, long long int b, long long int* x,
long long int* y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
long long int sx, sy;
long long int gcd = euclid_ext(b % a, a, &sx, &sy);
*x = sy - (b / a) * sx;
*y = sx;
return gcd;
}
long long int modInv(long long int b, long long int m) {
long long int x, y;
long long int gcd = euclid_ext(b, m, &x, &y);
if (gcd == -1) {
return -1;
} else {
return (x % m + m) % m;
}
}
long double slope(long double xdiff, long double ydiff) {
return (ydiff / xdiff);
}
bool binSearch(long long int* arr, long long int n, long long int target) {
unsigned long long int l = 0, r = n - 1;
while (l < r) {
int mid = (l + r) / 2;
if (arr[mid] >= target) {
r = mid;
} else {
l = mid + 1;
}
}
if (arr[l] == target) {
return true;
} else {
return false;
}
}
int ascii(char x) { return int(x); }
long double sine(long double x) { return sin(toRadian(x)); }
long double cosine(long double x) { return cos(toRadian(x)); }
long double tangent(long double x) { return tan(toRadian(x)); }
unsigned long long int hammDist(string a, string b,
unsigned long long int len) {
unsigned long long int cnt = 0;
for (int i = 0; i < len; i++) {
if (a[i] != b[i]) cnt++;
}
return cnt;
}
unsigned long long int binStrToInt(string a, unsigned long long int len) {
unsigned long long int num = 0;
for (int i = len - 1; i >= 0; i--) {
if (a[i] == '1') {
num = num + pow((unsigned long long int)2, len - i - 1);
}
}
return num;
}
const long long int maxn = 10;
class fenwick {
long long int arr[maxn] = {0};
long long int n;
public:
void init(long long int);
void update(int, long long int);
long long int sum(int);
int g(int);
int h(int);
};
int fenwick::g(int a) { return (a & (a + 1)); }
int fenwick::h(int a) { return (a | (a + 1)); }
void fenwick::update(int pos, long long int ch) {
for (; pos < n; pos = h(pos)) {
arr[pos] += ch;
}
}
long long int fenwick::sum(int pos) {
long long int ans = 0;
while (pos >= 0) {
ans += arr[pos];
pos = g(pos) - 1;
}
return ans;
}
void fenwick::init(long long int t) { n = t; }
class dsu {
int arr[maxn];
int n;
public:
void merge(int, int);
int get(int);
void init(int);
};
void dsu::init(int a) {
n = a;
for (int i = 0; i < n; i++) arr[i] = i;
}
int dsu::get(int u) {
if (u == arr[u])
return u;
else
return arr[u] = get(arr[u]);
}
void dsu::merge(int u, int v) { arr[get(u)] = get(v); }
void yes() { cout << "YES\n"; }
void no() { cout << "NO\n"; }
void solve() {
int a, b, c;
cin >> a >> b >> c;
if (a == b + c || b == a + c || c == a + b)
yes();
else if ((a % 2 == 0 && b == c) || (b % 2 == 0 && a == c) ||
(c % 2 == 0 && a == b))
yes();
else
no();
}
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 100005;
const double PI = 4 * atan(1);
const long long MAX = 9223372036854775807;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool issquare(long long w) { return trunc(sqrt(w)) * trunc(sqrt(w)) == w; }
bool isprime(long long u) {
for (long long i = 2; i <= (int)sqrt(u); i++) {
if (u % i == 0) return 0;
}
return 1;
}
long long mod(long long to_mod) {
to_mod %= MOD;
while (to_mod < 0) to_mod += MOD;
return to_mod % MOD;
}
long long moduloMultiplication(long long a, long long b, long long mod) {
long long res = 0;
a %= mod;
while (b) {
if (b & 1) res = (res + a) % mod;
a = (2 * a) % mod;
b >>= 1;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long n, m, x, y, res, t, k, ans = 0, b, q, z;
string ch, sh;
bool type[105];
bool vis[105];
char r[105];
char c;
vector<string> v;
int main() {
ios::sync_with_stdio(0);
memset(vis, 0, sizeof(vis));
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ch;
for (int i = 0; i < ch.size(); i++) {
ch[i] = tolower(ch[i]);
}
v.push_back(ch);
}
cin >> ch;
m = ch.size();
cin >> c;
for (int i = 0; i < m; i++) {
type[i] = isupper(ch[i]);
ch[i] = tolower(ch[i]);
}
for (int i = 0; i < n; i++) {
sh = v[i];
for (int j = 0; j < m - sh.size() + 1; j++) {
bool flag = true;
for (int k = j; k < j + sh.size(); k++) {
if (sh[k - j] != ch[k]) {
flag = false;
break;
}
}
if (flag) {
for (int k = j; k < j + sh.size(); k++) {
vis[k] = 1;
}
}
}
}
for (int i = 0; i < m; i++) {
if (vis[i] == 0) {
if (type[i]) {
r[i] = toupper(ch[i]);
} else {
r[i] = ch[i];
}
} else {
char cc;
if (ch[i] == c) {
for (char ccc = 'a'; ccc <= 'z'; ccc++)
if (ccc != c) {
cc = ccc;
break;
}
} else {
cc = c;
}
if (type[i]) {
r[i] = toupper(cc);
} else
r[i] = cc;
}
cout << r[i];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n + 1);
for (int i = 0; i < n; i++) cin >> v[i];
v[n] = 1;
int ans = 0;
for (int i = 0; i <= n; i++) {
int cnt = 0;
for (int j = 0; j < i; j++) {
cnt += v[j];
}
for (int j = i; j <= n; j++) {
cnt += (v[j] ^ 1);
}
ans = max(ans, n - cnt);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, i, gr = 0;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
if (a[i] == a[i + 1])
continue;
else
gr = gr + 1;
}
printf("%d", gr);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int k = 1, re = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') k = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
re = re * 10 + ch - 48;
ch = getchar();
}
return re * k;
}
inline void write(int x) {
if (x < 0) return putchar('-'), write(-x), void();
if (x <= 9) return putchar(x + 48), void();
return write(x / 10), write(x % 10), void();
}
int head[10005], cur[10005], tot = 1, dis[10005], cnt, s, t, n, k, ans;
double d[10005];
bool vis[10005];
struct ss {
int node, nxt, w;
double f;
} e[500005];
inline void add(int u, int v, int w, double f) {
e[++tot].nxt = head[u];
e[tot].node = v;
e[tot].w = w;
e[tot].f = f;
head[u] = tot;
}
inline void _add(int u, int v, int w, double f) {
add(u, v, w, f);
add(v, u, 0, -f);
}
bool bfs() {
for (register int i = 0; i <= cnt; i++) vis[i] = 0, d[i] = 1e9;
queue<int> q;
q.push(s);
d[s] = 0;
vis[s] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
vis[x] = 0;
for (register int i = head[x]; i; i = e[i].nxt) {
if (!e[i].w) continue;
int y = e[i].node;
if (d[y] > d[x] + e[i].f + 1e-8) {
d[y] = d[x] + e[i].f;
if (!vis[y]) {
vis[y] = 1;
q.push(y);
}
}
}
}
return d[t] + 1e-8 < 1e9;
}
double tans;
int fans;
int dinic(int x, int now) {
if (!now || x == t) return now;
vis[x] = 1;
int ans = 0;
for (register int i = cur[x]; i && now != ans; i = e[i].nxt) {
int y = e[i].node;
cur[x] = i;
if (!vis[y] &&
(d[y] < d[x] + e[i].f + 1e-8 && d[y] > d[x] + e[i].f - 1e-8) &&
e[i].w) {
int t = dinic(y, min(e[i].w, now - ans));
e[i].w -= t;
e[i ^ 1].w += t;
ans += t;
tans += t * e[i].f;
}
}
vis[x] = 0;
return ans;
}
struct st {
int x, y;
bool operator<(const st ot) const { return y < ot.y; }
} a[405];
signed main() {
n = read();
for (register int i = 1; i <= n; i++) {
a[i].x = read();
a[i].y = read();
}
sort(a + 1, a + n + 1);
cnt = t = n + n + 1;
for (register int i = 1; i <= n; i++) {
_add(s, i + n, 2, 0);
if (i < n) _add(i, t, 1, 0);
for (register int j = 1; j < i; j++) {
if (a[j].y != a[i].y)
_add(i + n, j, 1,
sqrt((a[i].x - a[j].x) * (a[i].x - a[j].x) +
(a[i].y - a[j].y) * (a[i].y - a[j].y)));
}
}
while (bfs()) {
int now;
do {
for (register int i = 0; i <= cnt; i++) cur[i] = head[i];
now = dinic(s, 0x3f3f3f3f);
fans += now;
} while (now);
}
if (fans != n - 1)
write(-1);
else
cout << fixed << setprecision(8) << tans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int q;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
if (d < l || d > r)
cout << d << endl;
else {
long long t = r / d;
cout << (t + 1) * d << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t = 1;
while (t--) {
long long int n, sum = 0, ct = 0, l, r, m, k, ans = 0;
cin >> n >> m;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
long long int b[m];
for (long long int i = 0; i < m; i++) cin >> b[i];
long long int mi = *min_element(b, b + m);
long long int ma = *max_element(a, a + n);
if (ma > mi) {
cout << -1 << endl;
continue;
}
sort(a, a + n);
sort(b, b + m);
reverse(b, b + m);
long long int ai = a[n - 2];
for (long long int i = 0; i < m; i++) {
if (b[i] == ma) {
ans += sum;
continue;
} else if (i != m - 1) {
long long int tmp = sum;
tmp -= ma;
tmp += b[i];
ans += tmp;
} else {
long long int tmp = sum;
tmp -= ai;
tmp += b[i];
ans += tmp;
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N;
int a[60][60];
set<int> S;
int main() {
cin >> N;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) scanf("%d", &a[i][j]);
bool was = 0;
for (int i = 0; i < N; i++) {
S.clear();
for (int j = 0; j < N; j++) S.insert(a[i][j]);
if ((int)S.size() < N)
printf("%d ", (int)S.size() - 1);
else {
if (!was) {
printf("%d ", (int)S.size());
was = 1;
} else {
printf("%d ", (int)S.size() - 1);
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
int dp[105][105][12];
struct DP {
int col, d;
} path[105][105][12];
char str[105];
int maze[105][105];
char road[105 * 2], cnt;
int main() {
int n, m, k;
while (scanf("%d %d %d", &n, &m, &k) != EOF) {
k++;
for (int i = 1; i <= n; i++) {
scanf("%s", str + 1);
for (int j = 1; j <= m; j++) maze[i][j] = str[j] - '0';
}
memset(dp, -1, sizeof dp);
memset(path, -1, sizeof path);
for (int i = 1; i <= m; i++) dp[n][i][maze[n][i] % k] = maze[n][i];
for (int i = n - 1; i >= 1; i--) {
for (int j = 1; j <= m; j++) {
int now;
for (int l = 0; l <= k; l++) {
if (dp[i + 1][j - 1][l] == -1) continue;
now = (l + maze[i][j]) % k;
if (dp[i][j][now] < dp[i + 1][j - 1][l] + maze[i][j]) {
dp[i][j][now] = dp[i + 1][j - 1][l] + maze[i][j];
path[i][j][now].col = j - 1;
path[i][j][now].d = l;
}
}
for (int r = 0; r <= k; r++) {
if (dp[i + 1][j + 1][r] == -1) continue;
now = (r + maze[i][j]) % k;
if (dp[i][j][now] < dp[i + 1][j + 1][r] + maze[i][j]) {
dp[i][j][now] = dp[i + 1][j + 1][r] + maze[i][j];
path[i][j][now].col = j + 1;
path[i][j][now].d = r;
}
}
}
}
int col, d = 0, ans = -1, row = 1;
for (int i = 1; i <= m; i++)
if (ans < dp[1][i][0]) {
ans = dp[1][i][0];
col = i;
}
printf("%d\n", ans);
if (ans == -1) continue;
cnt = 0;
while (path[row][col][d].d != -1) {
int next_col = path[row][col][d].col;
int next_d = path[row][col][d].d;
if (col < next_col)
road[++cnt] = 'L';
else
road[++cnt] = 'R';
row++;
col = next_col;
d = next_d;
}
printf("%d\n", col);
for (int i = cnt; i >= 1; i--) printf("%c", road[i]);
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 510, Inf = 1e18;
int n, m;
struct Matrix {
int r, c;
bitset<MXN> row[MXN], col[MXN];
bool identity;
Matrix() { identity = 1; }
Matrix(int a, int b, bool iden = 1) {
identity = iden;
r = a, c = b;
}
void set(int i, int j, int k) {
row[i][j] = k;
col[j][i] = k;
}
int get(int i, int j) { return row[i][j]; }
Matrix operator*(Matrix M) {
if (identity) return M;
if (M.identity) return *this;
Matrix res(r, M.c, 0);
for (int i = 0; i < r; i++) {
for (int j = 0; j < M.c; j++) {
res.set(i, j, (row[i] & M.col[j]).any());
}
}
return res;
}
} M[61][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
M[0][0] = Matrix(n, n, false);
M[0][1] = Matrix(n, n, false);
for (int i = 0; i < m; i++) {
int v, u, t;
cin >> v >> u >> t;
v--;
u--;
M[0][t].set(v, u, 1);
}
for (int i = 1; i <= 60; i++) {
M[i][0] = M[i - 1][0] * M[i - 1][1];
M[i][1] = M[i - 1][1] * M[i - 1][0];
}
if (M[60][0].row[0].any()) {
cout << "-1\n";
return 0;
}
long long ans = 0;
int current_type = 0;
Matrix cur;
for (int i = 60; i >= 0; i--) {
Matrix tmp = cur * M[i][current_type];
if (tmp.row[0].any()) {
cur = tmp;
ans += (1LL << i);
current_type ^= 1;
}
}
cout << (ans > Inf ? -1 : ans) << "\n";
}
| 8 |
#include <bits/stdc++.h>
const long double PI = 3.141592653589793238L;
const long long N = 2000005;
using namespace std;
long long ans[1 << 20], tmp[1 << 20];
pair<pair<long long, long long>, long long> a[101];
long long n, m, b;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, a, b, T;
cin >> n >> a >> b >> T;
long long t[n + 1];
for (long long i = (long long)(1); i <= (long long)(n); ++i) {
char ch;
cin >> ch;
t[i] = b * (ch == 'w');
}
if (T < 1 + t[1]) {
cout << "0\n";
return 0;
}
T -= 1 + t[1];
long long ans = 1;
long long l[n + 1];
long long curr = 0;
for (long long i = (long long)(2); i <= (long long)(n); ++i) {
if (curr + a + 1 + t[i] > T) {
curr = 2e9;
l[i] = curr;
continue;
}
curr += a + 1 + t[i];
l[i] = curr;
ans = max(ans, i);
}
long long r[n + 1];
curr = 0;
for (long long i = (long long)(n); i >= (long long)(2); --i) {
if (curr + a + 1 + t[i] > T) {
curr = 2e9;
r[i] = curr;
continue;
}
curr += a + 1 + t[i];
r[i] = curr;
ans = max(ans, n - i + 2);
}
for (long long i = (long long)(2); i <= (long long)(n); ++i) {
long long low = i + 1, high = n;
while (low <= high) {
long long mid = (low + high) / 2;
if (l[i] + a * (i - 1) + r[mid] <= T)
ans = max(ans, i + n - mid + 1), high = mid - 1;
else
low = mid + 1;
}
}
for (long long i = (long long)(n); i >= (long long)(2); --i) {
long long low = 2, high = i - 1;
while (low <= high) {
long long mid = (low + high) / 2;
if (r[i] + a * (n - i + 1) + l[mid] <= T)
ans = max(ans, mid + n - i + 1), low = mid + 1;
else
high = mid - 1;
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, dp[501][501] = {{0}};
string s;
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> n >> s;
for (long long l = 0; l < n; l++) {
for (long long i = 0; i < n - l; i++) {
long long j = i + l;
if (l == 0) {
dp[i][i] = 1;
continue;
}
dp[i][j] = dp[i + 1][j] + 1;
for (long long k = i + 1; k < j + 1; k++) {
if (s[i] == s[k]) {
dp[i][j] = min(dp[i][j], dp[i + 1][k] + dp[k + 1][j]);
} else
dp[i][j] = min(dp[i][k - 1] + dp[k + 1][j] + 1, dp[i][j]);
}
}
}
cout << dp[0][n - 1] << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = (long double)1e-7;
const long double PI = acos(0) * 2;
bool isZero(const long double& x) { return abs(x) <= EPS; }
int sign(const long double& x) { return isZero(x) ? 0 : (0 < x ? 1 : -1); }
long long gcd(long long a, long long b) {
for (; b; a %= b, swap(a, b)) {
}
return abs(a);
}
pair<long long, long long> operator+(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return pair<long long, long long>(a.first + b.first, a.second + b.second);
}
pair<long long, long long> operator-(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return pair<long long, long long>(a.first - b.first, a.second - b.second);
}
pair<long long, long long> operator*(const pair<long long, long long>& a,
const long long& b) {
return pair<long long, long long>(a.first * b, a.second * b);
}
long long operator*(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return a.first * b.second - b.first * a.second;
}
long long ccw(const pair<long long, long long>& a,
const pair<long long, long long>& b,
const pair<long long, long long>& c) {
return a * b + b * c + c * a;
}
void fg(vector<int> G[], int a, int b) {
G[a].emplace_back(b);
G[b].emplace_back(a);
}
void fg(vector<pair<int, int>> G[], int a, int b, int c) {
G[a].emplace_back(b, c);
G[b].emplace_back(a, c);
}
const int MOD = 1000000007;
const int MAXN = 100055;
const int MAXM = 100055;
const int MAXC = 600055;
int dgl[MAXM], pw10[9];
int rel[MAXN], bcd[MAXN], bidx[MAXN];
vector<pair<int, int>> G[MAXN];
vector<int> CV[MAXC];
long long Ans[MAXN];
int A[MAXM], B[MAXM];
int C[MAXN];
int N, M;
void precal() {
for (int s = 0, e = 1, g = 0;; e++) {
if (e >= MAXC) break;
for (int v : CV[e]) {
rel[v] = (0x3f3f3f3f);
for (auto& ed : G[v]) {
int idx, dst;
tie(idx, dst) = ed;
dst = C[idx] + dgl[dst];
if (dst != C[v]) continue;
dst = ed.second;
int nrel = rel[idx];
int nbcd = bcd[idx] * pw10[dgl[dst]] + dst;
if (pair<int, int>(nrel, nbcd) < pair<int, int>(rel[v], bcd[v])) {
rel[v] = nrel;
bcd[v] = nbcd;
bidx[v] = idx;
}
}
}
if (e - s < 6) continue;
s++;
vector<pair<int, int>> O;
for (int i = s; i <= e; i++)
for (int v : CV[i]) {
int key = rel[v] * 10 + bcd[v] / pw10[i - s];
bcd[v] %= pw10[i - s];
O.emplace_back(key, v);
}
sort(((O).begin()), ((O).end()));
for (int p = 0, q, n = ((int)(O).size()), cnt = 0; p < n; p = q) {
for (q = p; q < n && O[p].first == O[q].first; q++)
rel[O[q].second] = cnt;
cnt++;
}
}
for (int i = 1; i < MAXC; i++) {
for (int v : CV[i]) {
int pv = bidx[v];
for (auto& ed : G[v]) {
int idx, dst;
tie(idx, dst) = ed;
if (idx != pv) continue;
Ans[v] = (Ans[idx] * pw10[dgl[dst]] + dst) % MOD;
break;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
pw10[0] = 1;
for (int i = 1; i < 9; i++) pw10[i] = pw10[i - 1] * 10;
cin >> N >> M;
for (int i = 1; i <= M; i++) {
cin >> A[i] >> B[i];
fg(G, A[i], B[i], i);
}
for (int i = 1; i <= M; i++) {
int& ret = dgl[i];
for (int j = i; j; j /= 10) ret++;
}
{
fill(C + 2, C + N + 1, (0x3f3f3f3f));
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
PQ;
PQ.emplace(0, 1);
for (int idx, dst; !PQ.empty();) {
tie(dst, idx) = PQ.top();
PQ.pop();
for (auto& ed : G[idx]) {
int ndst, nidx;
tie(nidx, ndst) = ed;
ndst = dst + dgl[ndst];
if (C[nidx] <= ndst) continue;
C[nidx] = ndst;
PQ.emplace(ndst, nidx);
}
}
}
for (int i = 1; i <= N; i++) CV[C[i]].emplace_back(i);
precal();
for (int i = 2; i <= N; i++) cout << Ans[i] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans;
scanf("%d", &n);
ans = n;
int arr[n];
for (int i = (0); i < (n); ++i) scanf("%d", &arr[i]);
sort(arr, arr + n);
int st = 0, end = n / 2;
while (st < n / 2 && end < n) {
if (2 * arr[st] <= arr[end]) {
ans--;
end++;
st++;
} else
end++;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int i, j, n;
scanf("%d", &n);
for (i = (n / 2); i >= 0; i--) {
for (j = 1; j <= n; j++) {
if (j > i && j < n - i + 1) {
printf("D");
} else {
printf("*");
}
}
printf("\n");
}
for (i = 1; i <= (n / 2); i++) {
for (j = 1; j <= n; j++) {
if (j > i && j < n - i + 1) {
printf("D");
} else {
printf("*");
}
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[200001], val[200001], ans = 0, T = 1;
int roun[200001], c[200001];
stack<int> s;
void DFS(int v, int rou) {
roun[v] = rou;
val[v] = T++;
s.push(v);
if (val[a[v]] == 0) {
DFS(a[v], rou);
} else if (roun[rou] == roun[a[v]]) {
int x = 1e9;
while (true) {
int f = s.top();
s.pop();
x = min(x, c[f]);
if (val[f] == val[a[v]]) break;
}
ans += x;
return;
} else
return;
}
int main(int argc, char const *argv[]) {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
for (int i = 0; i < n; i++) {
if (val[i] == 0) {
while (!s.empty()) s.pop();
T = 1;
DFS(i, i);
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
std::set<std::pair<int, int> > adj;
int a[100005];
int main() {
srand(time(0));
int n, m;
int aprox;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
adj.insert(std::make_pair(u, v));
adj.insert(std::make_pair(v, u));
}
for (int i = 0; i < n; ++i) a[i] = i + 1;
for (aprox = 0; aprox < 999; ++aprox) {
std::random_shuffle(a, a + n);
int ok = 1;
for (int i = 0; i < n; ++i) {
int u, v;
u = a[i];
v = a[(i + 1) % n];
if (i == m) break;
if (adj.find(std::make_pair(u, v)) != adj.end()) {
ok = 0;
break;
}
}
if (ok) {
for (int i = 0; i < n; ++i) {
int u, v;
u = a[i];
v = a[(i + 1) % n];
if (i == m) break;
printf("%d %d\n", u, v);
}
break;
}
}
if (aprox == 999) printf("-1\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long a, b = 1;
bool check(int x) {
if (x < 0) x = -x;
while (x) {
if (x % 10 == 8) return true;
x /= 10;
}
return false;
}
int main() {
scanf("%lld", &a);
while (!check(a + b)) ++b;
printf("%lld\n", b);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int k;
scanf("%d", &k);
char c;
scanf("%c", &c);
char string[1001];
gets(string);
int letter[26];
int m = 0;
for (int i = 0; i < 26; i++) {
letter[i] = 0;
}
int a = strlen(string);
for (int i = 0; i < a; i++) {
letter[string[i] - 97]++;
}
for (int i = 0; i < 26; i++) {
if (letter[i] != 0) {
if (letter[i] % k == 0) {
continue;
} else {
printf("-1");
return 0;
}
}
}
for (int o = 0; o < k; o++) {
for (int i = 0; i < 26; i++) {
for (int j = 0; j < (letter[i] / k); j++) {
printf("%c", i + 'a');
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inft = 1000000009;
const int MAXN = 1000006;
int ile[MAXN], t[MAXN], tt[MAXN];
int n;
int get(int pocz, int kon) {
multiset<int> S;
for (int i = pocz; i <= kon; i++) S.insert(t[i]);
int ans = 0, med = -1;
vector<int> V;
for (typeof((S).begin()) it = (S).begin(); it != (S).end(); ++it)
V.push_back(*it);
for (int i = 0; i < (V.size()); ++i) {
if (i == V.size() - 1) {
if (med != -1) return ans;
break;
}
if (V[i] == V[i + 1])
i++;
else {
if (med != -1) return ans;
med = V[i];
}
}
ans++;
do {
if (kon >= pocz) {
if (S.find(t[kon]) == S.end()) return ans;
S.erase(S.find(t[kon]));
if (pocz < kon) {
if (S.find(t[kon]) == S.end()) return ans;
S.erase(S.find(t[kon]));
}
} else if (t[kon] != t[pocz] || (kon == pocz && t[pocz] != med))
return ans;
ans++;
kon--;
pocz++;
} while (1);
return ans;
}
void solve() {
scanf("%d", &n);
for (int i = 0; i < (n); ++i) scanf("%d", &t[i]);
int nr = 0;
int i = 0, j = n - 1;
for (; i <= j; i++, j--)
if (t[i] == t[j])
nr = i + 1;
else
break;
if (i > j) {
long long aa = 1LL * n * (n + 1) / 2;
cout << aa << endl;
return;
}
long long ans1 = get(i, j);
reverse(t + i, t + j + 1);
long long ans2 = get(i, j);
if (ans1 == ans2 && ans1 == 0) {
printf("0\n");
return;
}
cout << 1LL * (nr + 1) * (ans1 - 1) + 1LL * (nr + 1) * (ans2 - 1) +
1LL * (nr + 1) * (nr + 1)
<< endl;
}
int main() {
int t = 1;
for (int i = 0; i < (t); ++i) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long NR = 210000;
long long n, a[NR], b[NR], c[NR], dp[NR], p[NR], w[NR];
vector<long long> v[NR];
void dfs(long long rt, long long u, long long s) {
long long l = 0, r = u, mid;
while ((r - l) > 1) {
mid = (l + r) >> 1;
if (b[mid] >= s - a[rt]) {
r = mid;
} else {
l = mid;
}
}
dp[c[u - 1]]--;
dp[c[r - 1]]++;
b[u] = s;
c[u] = rt;
for (long long i = 0; i < v[rt].size(); i++) {
dfs(v[rt][i], u + 1, s + w[v[rt][i]]);
}
}
void DFS(long long rt) {
for (long long i = 0; i < v[rt].size(); i++) {
DFS(v[rt][i]);
dp[rt] += dp[v[rt][i]];
}
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (long long i = 2; i <= n; i++) {
scanf("%lld%lld", &p[i], &w[i]);
v[p[i]].push_back(i);
}
dfs(1, 1, 0);
DFS(1);
for (long long i = 1; i <= n; i++) {
printf("%lld ", -dp[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, a[N], b[N];
long long ans = 0;
void dfs(int x, int w) {
if (!ans) return;
if (0 <= a[x + 1] + w && a[x + 1] + w <= 9) {
printf("%d %d\n", x, w);
a[x] += w;
a[x + 1] += w;
ans--;
return;
}
dfs(x + 1, -w);
if (!ans) return;
printf("%d %d\n", x, w);
a[x] += w;
a[x + 1] += w;
ans--;
}
int main() {
scanf("%d", &n);
getchar();
for (int i = 1; i <= n; i++) {
char ch = getchar();
a[i] = ch - '0';
}
getchar();
for (int i = 1; i <= n; i++) {
char ch = getchar();
b[i] = ch - '0';
}
int c[N];
for (int i = 1; i <= n; i++) c[i] = a[i];
for (int i = 1, d; i < n; i++)
d = b[i] - c[i], c[i] += d, c[i + 1] += d, ans += abs(d);
if (c[n] != b[n]) {
printf("-1");
return 0;
}
printf("%lld\n", ans);
ans = min(ans, 100000ll);
for (int i = 1; i < n && ans > 0; i++)
while (a[i] != b[i] && ans > 0) dfs(i, (b[i] - a[i]) / abs(b[i] - a[i]));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, sum = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> k;
if (i == j) {
sum += k;
} else if (j == (int)(n + 1) / 2) {
sum += k;
} else if (i == n - j + 1) {
sum += k;
} else if (i == (int)((n + 1) / 2)) {
sum += k;
}
}
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long flag = 0;
for (long long i = 1; i < n; i++) {
if (abs(a[i] - a[i - 1]) == 1 || abs(a[i] - a[i - 1]) == n - 1) {
continue;
} else {
cout << "NO"
<< "\n";
flag = 1;
break;
}
}
if (flag == 0) {
cout << "YES"
<< "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int tdata = a * c;
int down = b;
int ttime = c;
int extra = tdata / b;
int newt = extra - c;
int newt1 = tdata - newt * b;
if (newt1 % b == 0) {
cout << newt;
} else {
cout << newt + 1;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 * 100010;
set<long long int> s;
set<long long int>::iterator itlow, itup;
long long int data[4 * MAXN], ind[4 * MAXN], a[MAXN];
const long long int INF = 10000000000000;
void build(int s = 0, int e = 5e5 + 1, int id = 1) {
if (e - s < 2) {
data[id] = a[s];
ind[id] = s;
return;
}
int mid = (s + e) / 2;
build(s, mid, 2 * id + 0);
build(mid, e, 2 * id + 1);
if (data[2 * id + 0] == 0) data[2 * id + 0] = INF;
if (data[2 * id + 1] == 0) data[2 * id + 1] = INF;
data[id] = min(data[2 * id + 0], data[2 * id + 1]);
if (data[2 * id + 0] < data[2 * id + 1]) {
ind[id] = ind[2 * id + 0];
} else {
ind[id] = ind[2 * id + 1];
}
}
void update(int p, int s = 0, int e = 5e5 + 1, int id = 1) {
if (e - s < 2) {
data[id] = INF;
ind[id] = s;
return;
}
int mid = (s + e) / 2;
if (p < mid) {
update(p, s, mid, 2 * id + 0);
} else {
update(p, mid, e, 2 * id + 1);
}
if (data[2 * id + 0] == 0) data[2 * id + 0] = INF;
if (data[2 * id + 1] == 0) data[2 * id + 1] = INF;
data[id] = min(data[2 * id + 0], data[2 * id + 1]);
if (data[2 * id + 0] < data[2 * id + 1]) {
ind[id] = ind[2 * id + 0];
} else {
ind[id] = ind[2 * id + 1];
}
}
int main() {
for (int i = 0; i < 4 * MAXN; i++) {
data[i] = INF;
}
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
s.insert(i);
}
build();
long long int answer = 0;
long long int sub = 0;
long long int num = n;
for (int i = 0; i < n - 2; i++) {
long long int mini = data[1] - sub;
long long int indexi = ind[1];
answer += (num - 2) * mini;
sub += mini;
num--;
itlow = s.begin();
itup = s.end();
itup--;
if (indexi == *(itlow) or indexi == *(itup)) {
update(indexi);
s.erase(indexi);
continue;
}
int lefti, righti;
itlow = s.lower_bound(indexi);
itup = s.upper_bound(indexi);
itlow--;
answer += min(a[*(itlow)], a[*(itup)]);
answer -= sub;
s.erase(indexi);
update(indexi);
}
cout << answer << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, p[666], f[666][666];
char c;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> c, f[i][j] = c - 48;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] |= f[i][k] && f[k][j];
for (int i = 1; i <= n; i++) {
int pos = i;
for (int j = i + 1; j <= n; j++)
if (f[i][j] && p[j] < p[pos]) pos = j;
swap(p[i], p[pos]);
}
for (int i = 1; i <= n; i++) cout << p[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e3;
int x[MAXN + 1], y[MAXN + 1];
inline long long ccw(int i, int j) {
return 1LL * x[i] * y[j] - 1LL * x[j] * y[i];
}
inline long long get(int t, int i, int j, int k) {
if (t == 1) {
return llabs(ccw(i, j) + ccw(j, k) + ccw(k, i));
} else {
return ccw(i, j) + ccw(j, k) + ccw(k, i);
}
}
inline long long ask(int t, int i, int j, int k) {
if (i == j || j == k || i == k) return 0;
cout << t << " " << i << " " << j << " " << k << endl;
long long ans;
cin >> ans;
return ans;
}
inline vector<int> solve(int a, int b, vector<int> arr) {
long long mx = 0;
int c;
vector<long long> area;
for (auto it : arr) {
long long cur = ask(1, a, it, b);
area.push_back(cur);
if (cur > mx) {
mx = cur, c = it;
}
}
vector<pair<long long, int> > x, y;
int p = 0;
for (auto it : arr) {
if (ask(2, it, a, c) < 0) {
x.push_back({area[p], it});
} else {
y.push_back({area[p], it});
}
p++;
}
sort(x.begin(), x.end());
sort(y.rbegin(), y.rend());
vector<int> ans;
for (auto it : x) {
ans.push_back(it.second);
}
for (auto it : y) {
ans.push_back(it.second);
}
return ans;
}
int main() {
int i, n;
cin >> n;
vector<int> a, b;
for (i = 3; i <= n; i++) {
if (ask(2, 1, 2, i) < 0) {
a.push_back(i);
} else {
b.push_back(i);
}
}
auto A = solve(1, 2, a);
auto B = solve(2, 1, b);
cout << 0 << " " << 1 << " ";
for (auto it : A) {
cout << it << " ";
}
cout << 2 << " ";
for (auto it : B) {
cout << it << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long int
#define rep(i, a, b) for (int i = a; i < b; i++)
#define revrep(i, a, b) for (int i = a; i >= b; i--)
#define pb push_back
#define pii pair<int, int>
#define vi vector<int>
#define vii vector<pii>
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
ostream &operator<<( ostream &output, const pii &p ) { output << p.first << " " << p.second;return output; }
istream &operator>>( istream &input, pii &p ) { input >> p.first >> p.second;return input; }
template<typename T>
void inline println(vector<T> args){ for(T i: args)cout<<i<<" ";cout<<endl; }
void amax(int& a, int b) { a = max(a, b); }
void amin(int& a, int b) { a = min(a, b); }
int INF = 1e9;
int MOD = 1e9+7;
void solve()
{
int n; cin>>n;
int arr[n];
rep(i, 0, n) cin>>arr[i];
int ans[n];
for(int i=n-1; i>=0; i--) {
int fin = i+arr[i];
ans[i] = arr[i];
if(fin < n) ans[i] += ans[fin];
}
cout<<*max_element(ans, ans+n)<<endl;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
int t = 1;
cin >> t;
rep(i, 0, t)
{
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vec = std::vector<T>;
bool __hack = std::ios::sync_with_stdio(false);
auto __hack1 = cin.tie(nullptr);
namespace template_util {
constexpr int bytecount(uint64_t x) { return x ? 1 + bytecount(x >> 8) : 0; }
template <int N>
struct bytetype {};
template <uint64_t N>
struct minimal_uint : bytetype<bytecount(N)> {};
} // namespace template_util
template <class T>
T next(istream& in) {
T ret;
in >> ret;
return ret;
}
template <class T>
vector<T> next_vec(istream& in, size_t n) {
vector<T> ret(n);
for (size_t i = 0; i < n; ++i) {
ret[i] = next<T>(in);
}
return ret;
}
template <class T>
void outVec(ostream& out, const vector<T>& v) {
out << v[0];
for (size_t i = 1; i < v.size(); ++i) {
out << ' ' << v[i];
}
out << "\n";
}
template <typename T>
static constexpr T wrap_pos(T a, T m) {
return a < 0 ? a + m : a;
}
template <typename T>
static constexpr T mod(T a, T m) {
return wrap_pos(a % m, m);
}
template <typename T>
static constexpr T inverse2(T a, T m) {
return a <= 1 ? a : mod((1 - inverse2(m % a, a) * m) / a, m);
}
template <typename T>
static constexpr T inverse(T a, T m) {
return inverse2(mod(a, m), m);
}
template <typename T, typename C, T Modulus>
class MR {
private:
struct tag_plus {};
struct tag_minus {};
struct tag_good {};
static_assert(std::numeric_limits<C>::max() / Modulus / Modulus > 0,
"compute type is too small");
static_assert(Modulus < std::numeric_limits<T>::max() / 2,
"storage type is too small");
static constexpr T reduce(T value, tag_plus) {
return value >= Modulus ? value - Modulus : value;
}
static constexpr T reduce(T value, tag_minus) {
return value < 0 ? value + Modulus : value;
}
static constexpr T reduce(T value, tag_good) { return value; }
public:
T value;
constexpr MR() : value(0) {}
constexpr MR(C value) : value(reduce(value % Modulus, tag_minus())) {}
template <typename tag_t>
constexpr MR(T value, tag_t tag) : value(reduce(value, tag)) {}
MR& operator=(C value) {
this->value = reduce(value % Modulus, tag_minus());
return *this;
}
constexpr MR operator+(MR b) const { return MR(value + b.value, tag_plus()); }
constexpr MR operator*(MR b) const {
return MR(C(value) * C(b.value) % Modulus, tag_good());
}
constexpr T get() const { return value; }
constexpr MR inverse() const {
return MR(::inverse(C(value), C(Modulus)), tag_good());
}
constexpr MR operator/(MR b) const { return *this * b.inverse(); }
};
template <typename T, typename C, T Modulus>
static inline std::ostream& operator<<(std::ostream& o, MR<T, C, Modulus> mr) {
return o << mr.get();
}
template <class T>
vector<T> getFactorials(int n) {
vector<T> res(n);
res[0] = T(1);
for (int i = 1; i < n; ++i) {
res[i] = res[i - 1] * i;
}
return res;
}
void solve(istream& in, ostream& out) {
auto n = next<int>(in);
auto k = next<int>(in);
auto a = next_vec<int>(in, n);
if (k == 0) {
outVec(out, a);
return;
}
vec<MR<int, int64_t, 1000000007> > f =
getFactorials<MR<int, int64_t, 1000000007> >(n + 1);
vec<MR<int, int64_t, 1000000007> > ki(n + 1);
--k;
ki[1] = MR<int, int64_t, 1000000007>(k + 1);
for (int i = 2; i <= n; ++i) {
ki[i] = ki[i - 1] * MR<int, int64_t, 1000000007>(k + i);
}
auto C2 = [&](int i) -> MR<int, int64_t, 1000000007> { return ki[i] / f[i]; };
vec<MR<int, int64_t, 1000000007> > cRow(n);
cRow[0] = 1;
for (int i = 1; i < n; ++i) {
cRow[i] = C2(i);
}
reverse(cRow.begin(), cRow.end());
;
;
vec<MR<int, int64_t, 1000000007> > res;
for (int i = 0; i < (n); ++i) {
MR<int, int64_t, 1000000007> cur = 0;
for (int j = 0; j < (n); ++j) {
cur = cur + MR<int, int64_t, 1000000007>(a[j]) * cRow[j];
}
res.push_back(cur);
cRow.push_back(0);
cRow.erase(cRow.begin());
}
reverse(res.begin(), res.end());
for (auto i : res) {
out << i << ' ';
}
out << "\n";
}
int main() {
solve(cin, cout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int inf = 0x7FFFFFFF;
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>
void show(T a, int n) {
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
cout << endl;
}
template <class T>
void show(T a, int r, int l) {
for (int i = 0; i < r; ++i) show(a[i], l);
cout << endl;
}
int main() {
int n, k;
char s[100005];
while (cin >> n >> k) {
scanf("%s", s);
if (k)
for (int i = 0; i < n; i++) {
if (i < n - 2) {
if (i % 2 == 0 && s[i] == '4' && s[i + 1] == '7' && s[i + 2] == '7') {
k = k % 2;
if (k) s[i + 1] = '4';
break;
} else if (i % 2 == 0 && s[i] == '4' && s[i + 1] == '4' &&
s[i + 2] == '7') {
k = k % 2;
if (k) s[i + 1] = '7';
break;
}
}
if (s[i] == '4' && s[i + 1] == '7') {
if (i % 2 == 0)
s[i + 1] = '4';
else
s[i] = '7';
k--;
}
if (k == 0) break;
}
printf("%s\n", s);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
const int mod = 998244353;
inline void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int n, m, dp[2][N][2];
char s[N], t[N];
int main() {
scanf("%s", s);
scanf("%s", t);
n = strlen(s);
m = strlen(t);
reverse(s, s + n);
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
int k;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
dp[1][j][0] = 0;
dp[1][j][1] = 0;
}
for (int j = 0; j <= m; j++) {
if (j < m && s[i - 1] == t[j]) {
add(dp[1][j + 1][1], dp[0][j][0]);
add(dp[1][j + 1][1], dp[0][j][1]);
}
k = n - (i - j);
if (k >= m) {
add(dp[1][j][1], dp[0][j][0]);
add(dp[1][j][1], dp[0][j][1]);
if (j == m) {
add(dp[1][j][1], dp[0][j][0]);
add(dp[1][j][1], dp[0][j][1]);
}
add(dp[1][j][0], dp[0][j][0]);
} else if (s[i - 1] == t[k]) {
add(dp[1][j][1], dp[0][j][0]);
add(dp[1][j][1], dp[0][j][1]);
}
}
swap(dp[0], dp[1]);
}
int ans = 0;
for (int i = 0; i <= m; i++) {
add(ans, dp[0][i][1]);
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXA = 1000100, INF = 0x3f3f3f3f;
int n, ans = INF, lvl[MAXA], p[MAXA];
vector<int> g[MAXA];
void bfs(int v) {
memset(lvl, INF, sizeof lvl);
queue<int> q;
lvl[v] = 0;
q.push(v);
while (!q.empty()) {
v = q.front(), q.pop();
for (const int &u : g[v])
if (u != p[v]) {
if (lvl[u] == INF)
p[u] = v, lvl[u] = lvl[v] + 1, q.push(u);
else
ans = min(ans, lvl[u] + lvl[v] + 1);
}
}
}
void f(int x) {
for (int i = 2; i * i <= x; ++i)
if (x % (i * i) == 0) {
while (x % (i * i) == 0) x /= i * i;
}
if (x == 1) ans = 1;
int p1 = x, p2 = 1;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) p1 = x / i, p2 = i;
g[p1].push_back(p2);
g[p2].push_back(p1);
}
int main() {
cin >> n;
for (int i = 1, x; i <= n; ++i) cin >> x, f(x);
for (int i = 1; i * i < MAXA; ++i) bfs(i);
if (ans == INF)
cout << -1;
else
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
bool b = 0;
char c;
while (!isdigit(c = getchar()) && c != '-')
;
if (c == '-') c = getchar(), b = 1;
x = c - 48;
while (isdigit(c = getchar())) x = (x << 3) + (x << 1) + c - 48;
if (b) x = -x;
}
template <typename T>
inline void wrip(T x) {
if (x > 9) wrip(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
wrip(x);
}
void reads(string &s) {
char c;
while (!isalpha(c = getchar()))
;
s = c;
while (isalpha(c = getchar())) s += c;
}
const long long mod = 1e9 + 7;
const int N = 2e5 + 11;
int n, a[N];
long long s[N], it[4 * N], lazy[4 * N];
void push(int id) {
it[id << 1] += lazy[id];
it[(id << 1) + 1] += lazy[id];
lazy[id << 1] += lazy[id];
lazy[(id << 1) + 1] += lazy[id];
lazy[id] = 0;
}
void update(int id, int l, int r, int u, int v, long long val) {
if (l > v || r < u) return;
if (u <= l && r <= v) {
lazy[id] += val;
it[id] += val;
return;
}
if (lazy[id]) push(id);
int mid = l + r >> 1;
update(id << 1, l, mid, u, v, val);
update((id << 1) + 1, mid + 1, r, u, v, val);
it[id] = min(it[id << 1], it[(id << 1) + 1]);
}
int Find(int id, int l, int r, long long val) {
if (it[id] > val) return l - 1;
if (l == r) return l;
if (lazy[id]) push(id);
int mid = l + r >> 1;
if (it[(id << 1) + 1] <= val) return Find((id << 1) + 1, mid + 1, r, val);
return Find(id << 1, l, mid, val);
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(s[i]);
for (int i = 1; i <= n; i++) {
s[0] += i;
update(1, 1, n, i, i, s[0]);
}
for (int i = n; i > 0; i--) {
int pos = Find(1, 1, n, s[i]);
a[i] = pos + 1;
update(1, 1, n, pos + 1, n, -a[i]);
}
for (int i = 1; i <= n; i++) {
write(a[i]);
putchar(' ');
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
multiset<pair<long long, long long> > s;
vector<pair<long long, long long> > v;
int32_t main() {
long long n, x, y;
cin >> n >> x >> y;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
for (auto i : v) {
auto t1 = s.lower_bound({i.first, 0});
if (s.empty() || t1 == s.begin())
s.insert({i.second, i.first});
else {
t1--;
if ((i.first - t1->first) * y <= x) {
auto t2 = *t1;
t2.first = i.second;
s.erase(t1);
s.insert(t2);
} else
s.insert({i.second, i.first});
}
}
long long ans = 0;
for (auto i : s)
ans = ((ans % 1000000007 + x % 1000000007) % 1000000007 +
((i.first - i.second) % 1000000007 * y % 1000000007) % 1000000007) %
1000000007;
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e6 + 5;
int mod = 998244353;
const double PI = acos(-1);
int n, k;
int d[14];
const int MOD = 998244353;
long long w[2][3000005];
inline long long qp(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ans;
}
int K;
inline void fftinit(int n) {
for (K = 1; K < n; K <<= 1)
;
w[0][0] = w[0][K] = 1;
long long g = qp(3, (MOD - 1) / K);
for (int i = 1; i < K; i++) w[0][i] = w[0][i - 1] * g % MOD;
for (int i = 0; i <= K; i++) w[1][i] = w[0][K - i];
}
inline void fft(int* x, int v) {
for (int i = 0; i < K; i++) x[i] = (x[i] % MOD + MOD) % MOD;
for (int i = 0, j = 0; i < K; i++) {
if (i > j) swap(x[i], x[j]);
for (int l = K >> 1; (j ^= l) < l; l >>= 1)
;
}
for (int i = 2; i <= K; i <<= 1)
for (int l = 0; l < i >> 1; l++) {
register int W = w[v][K / i * l], *p = x + l + (i >> 1), *q = x + l, t;
for (register int j = 0; j < K; j += i) {
p[j] = (q[j] - (t = (long long)p[j] * W % MOD) < 0) ? (q[j] - t + MOD)
: (q[j] - t);
q[j] = (q[j] + t - MOD >= 0) ? (q[j] + t - MOD) : (q[j] + t);
}
}
if (!v) return;
long long rv = qp(K, MOD - 2);
for (int i = 0; i < K; i++) x[i] = x[i] * rv % MOD;
}
vector<int> operator*(vector<int> a, vector<int> b) {
if (a.size() && b.size())
;
else
return vector<int>();
static int aa[3000005], bb[3000005];
fftinit(a.size() + b.size());
for (int i = 0; i < K; ++i) aa[i] = bb[i] = 0;
for (int i = 0; i < int(a.size()); ++i) aa[i] = a[i];
for (int i = 0; i < int(b.size()); ++i) bb[i] = b[i];
fft(aa, 0);
fft(bb, 0);
for (int i = 0; i < K; ++i) aa[i] = (long long)aa[i] * bb[i] % MOD;
vector<int> v;
fft(aa, 1);
for (int i = 0; i < int(a.size()) + int(b.size()) - 1; ++i)
v.push_back(aa[i]);
return v;
}
vector<int> operator+(vector<int> a, vector<int> b) {
vector<int> s(max(a.size(), b.size()));
for (int i = 0; i < int(a.size()); ++i) (s[i] += a[i]) %= MOD;
for (int i = 0; i < int(b.size()); ++i) (s[i] += b[i]) %= MOD;
return s;
}
vector<int> solve(int sz) {
vector<int> res((sz * 9) + 1, 0);
if (sz == 0) return res;
if (sz == 1) {
for (int i = 1; i <= k; i++) res[d[i]] = 1;
return res;
}
int h1, h2;
h1 = sz / 2;
h2 = sz - h1;
vector<int> v1, v2;
v1 = solve(h1);
v2 = solve(h2);
res = v1 * v2;
return res;
}
long long ans;
vector<int> poly;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (int i = 1; i <= k; i++) cin >> d[i];
n /= 2;
poly = solve(n);
for (int i = 0; i < poly.size(); i++) {
long long x = (1LL * poly[i] * poly[i]) % mod;
ans = (ans + x) % mod;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
long long a[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long sum = 1e18;
for (long long i = 1; i; i++) {
long long res = 1;
long long g = 0;
int f = 1;
for (int j = 0; j < n; j++) {
if (res > 1e14) {
f = 0;
break;
}
g += abs(a[j] - res);
res = res * i;
}
if (f == 1) {
sum = min(sum, g);
} else {
break;
}
}
cout << sum << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
long long int x = n / 2 / (k + 1);
cout << x << " " << k * x << " " << n - x - k * x;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[10010], b[10010] = {0};
int main() {
int n, ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
if (!b[a[i]] && a[i] <= n) {
b[a[i]] = 1;
} else if (b[a[i]] || a[i] > n) {
ans++;
}
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int a;
while (~scanf("%d", &a)) {
int b[60] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31,
30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29, 31, 30, 31, 30,
31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30,
31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
c[24], ans;
for (int i = 0; i < a; i++) {
scanf("%d", &c[i]);
}
for (int i = 0; i < 60 - a; i++) {
if (b[i] == c[0]) {
ans = 0;
int z = i;
for (int j = 0; j < a; j++) {
if (c[j] == b[z]) ans++;
z++;
}
if (ans == a) break;
}
}
if (ans == a)
printf("Yes\n");
else
printf("No\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)5e4 + 10;
const int mod = (int)1e9 + 7;
const long long inf = 1e18;
vector<bool> sieve(long long N) {
vector<bool> prime(N + 1, 1);
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= N; i++) {
if (prime[i]) {
for (int j = i * i; j <= N; j += i) {
prime[j] = 0;
}
}
}
return prime;
}
inline int sum(int a, int b) { return (a + b) % mod; }
vector<vector<int>> mult(vector<vector<int>> a, vector<vector<int>> b) {
vector<vector<int>> c(a.size(), vector<int>(a.size(), 0));
int n = a.size();
int m = a[0].size();
int k = b.size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int l = 0; l < k; l++) {
c[i][j] += ((a[i][l] * b[l][j]) % mod);
c[i][j] %= mod;
}
}
}
return c;
}
vector<vector<int>> binxpow(vector<vector<int>> a, int n) {
if (n == 1) return a;
if (n == 2) {
return mult(a, a);
}
if (n % 2 == 0) {
vector<vector<int>> res = binxpow(a, n / 2);
return (mult(res, res));
} else
return (mult(binxpow(a, n - 1), a));
}
int gcd(int a, int b) {
if (b == 0) return a;
return b == 0 ? a : gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
vector<long long> fact(long long num) {
vector<long long> arr;
long long n = num;
for (int i = 2; i * i <= n && num > 1; i++) {
while (num % i == 0) {
arr.push_back(i);
num /= i;
}
}
if (num > 1) {
arr.push_back(num);
}
return arr;
}
bool prime(long long n) {
for (long long i = 2; i <= sqrt(abs(n)); i++) {
if (n % i == 0) return false;
}
return true;
}
int str_to_int(string s) {
stringstream ss;
ss << s;
int x;
ss >> x;
return x;
}
string int_to_str(int s) {
stringstream ss;
ss << s;
string x;
ss >> x;
return x;
}
int check(int a) {
if (a == 1) {
return -1;
} else {
return 1;
}
}
vector<int> prefix_f(string s) {
int n = (int)s.length();
vector<int> arr(n);
for (int i = 1; i < n; ++i) {
int j = arr[i - 1];
while (j > 0 && s[i] != s[j]) j = arr[j - 1];
if (s[i] == s[j]) ++j;
arr[i] = j;
}
return arr;
}
vector<vector<int>> cnk(int n) {
vector<vector<int>> crn(n, vector<int>(n, 0));
for (int i = 1; i < n; i++) {
crn[i][0] = 1;
crn[i][i] = 1;
for (int k = 1; k < n; k++) {
crn[i][k] = crn[i - 1][k] + crn[i - 1][k - 1];
}
}
return crn;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long res = binpow(a, b / 2);
return (res * res);
} else
return (binpow(a, b - 1) * a);
}
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first)
return 1;
else
return 0;
}
vector<vector<int>> g;
vector<int> used;
vector<int> ans(100, 1e8);
void dfs(int v) {
used[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
ans[g[v][i]] = min(ans[g[v][i]], ans[v] + 1);
}
for (int i = 0; i < g[v].size(); i++) {
if (!used[g[v][i]]) {
dfs(g[v][i]);
}
}
}
int seil(int a, int b) { return (a + b - 1) / b; }
long long f(long long n) { return ((n * (n + 1)) / 2); }
void solve() {
int n, p, k;
cin >> n >> p >> k;
int z = p;
vector<int> a(n, 0);
for (int i = 0; i < n; ++i) cin >> a[i];
sort((a).begin(), (a).end());
int j = 0;
int idx = -1;
for (int i = 1; i < n; i += 2) {
if (p - a[i] >= 0) {
j += 2;
p -= a[i];
continue;
} else {
if (p - a[i - 1] >= 0) {
j++;
break;
}
}
}
int j1 = 0;
for (int i = 2; i < n; i += 2) {
if (z - a[i] >= 0) {
j1 += 2;
z -= a[i];
} else {
if (z - a[i - 1] >= 0) {
j1 += 2;
z = -1e9;
break;
}
}
}
if (z - a[0] >= 0) j1++;
cout << max(j1, j);
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
cout << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class Ty>
Ty randint(Ty a, Ty b) {
return uniform_int_distribution<Ty>(a, b)(rng);
}
template <class num>
inline void rd(num& x) {
char c;
while (isspace(c = getchar()))
;
bool neg = false;
if (!isdigit(c))
neg = (c == '-'), x = 0;
else
x = c - '0';
while (isdigit(c = getchar())) x = (x << 3) + (x << 1) + c - '0';
x = neg ? -x : x;
}
template <class... Args>
inline void rd(Args&... args) {
(rd(args), ...);
}
template <class... Args>
inline void rf(Args&... args) {
(cin >> ... >> args);
}
template <class... Args>
inline void pr(Args&&... args) {
(cout << ... << args);
}
const int MAXN = 5e5 + 5, INF = 0x3f3f3f3f;
int a[MAXN];
ll sum[MAXN];
int main() {
int n;
rd(n);
for (int i = 1; i <= (n + 1) / 2; i++) rd(a[i]);
int x;
rd(x);
for (int i = (n + 1) / 2 + 1; i <= n; i++) a[i] = x;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
vector<int> pos;
for (int i = n / 2; i <= n; i++) pos.emplace_back(i);
shuffle(pos.begin(), pos.end(), rng);
vector<int> I;
for (int i = 1; i <= n; i++) I.emplace_back(i);
shuffle(I.begin(), I.end(), rng);
auto ck = clock();
for (int at = 0;
at < (int)pos.size() && (double(clock() - ck) / CLOCKS_PER_SEC <= 1.85);
at++) {
int k = pos[at];
bool ok = true;
for (int i : I)
if (i <= n - k + 1 && sum[i + k - 1] - sum[i - 1] <= 0) {
ok = false;
break;
}
if (ok) {
printf("%d\n", k);
return 0;
}
}
printf("-1\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using Key = int;
using ll = long long;
const int mxn = 100006;
const int mxv = mxn;
struct Val {
ll l, r;
ll c, S, L, R;
Val operator+(Val b) {
if (!c) return b;
if (!b.c) return *this;
return {l,
b.r,
c + b.c,
S + b.S + R * b.c + b.L * c + (b.l - r) * c * b.c,
L + b.L + (b.l - l) * b.c,
b.R + R + (b.r - r) * c};
}
};
struct Node {
int fit;
Node *l, *r;
int cnt, cnts;
Key key;
Val val, vals;
};
using ptr = Node *;
Node mem[mxv] = {{0, mem, mem, 0, 0}};
int sz;
ptr renew(ptr x) {
x->vals = x->l->vals + x->val + x->r->vals;
x->cnts = x->l->cnts + 1 + x->r->cnts;
return x;
}
pair<ptr, ptr> split(ptr x, Key key) {
if (x == mem) return {mem, mem};
ptr t;
if (x->key >= key)
return tie(t, x->l) = split(x->l, key), make_pair(t, renew(x));
else
return tie(x->r, t) = split(x->r, key), make_pair(renew(x), t);
}
tuple<ptr, ptr, ptr> split(ptr x, Key l, Key r) {
auto a = split(x, l);
auto b = split(a.second, r + 1);
return make_tuple(a.first, b.first, b.second);
}
ptr merge(ptr x, ptr y) {
if (x == mem) return y;
if (y == mem) return x;
if (x->fit > y->fit)
return x->r = merge(x->r, y), renew(x);
else
return y->l = merge(x, y->l), renew(y);
}
ptr merge(ptr x, ptr y, ptr z) { return merge(merge(x, y), z); }
ptr root = mem;
int n;
int key[mxn];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
ptr L, R;
tie(L, R) = split(root, x);
key[i] = x;
root = merge(L,
new (mem + ++sz)
Node{rand(), mem, mem, 1, 1, x, {x, x, 1}, {x, x, 1}},
R);
}
int q;
cin >> q;
while (q--) {
int op, l, r, &p = l, &d = r;
scanf("%d%d%d", &op, &l, &r);
if (op == 1) {
ptr L, P, R;
tie(L, P, R) = split(root, key[p], key[p]);
root = merge(L, R);
key[p] = P->key += d;
P->val = P->vals = Val{P->key, P->key, 1};
tie(L, R) = split(root, P->key);
root = merge(L, P, R);
} else {
ptr L, M, R;
tie(L, M, R) = split(root, l, r);
printf("%lld\n", M->vals.S);
root = merge(L, M, R);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int rd() {
char c = getchar();
int t = 0, f = 1;
while (!isdigit(c)) f = (c == '-') ? -1 : 1, c = getchar();
while (isdigit(c)) t = t * 10 + c - 48, c = getchar();
return t * f;
}
void wt(int x) {
if (x < 0)
putchar('-'), wt(-x);
else {
if (x > 9) wt(x / 10);
putchar(x % 10 + 48);
}
}
const int N = 300035;
vector<int> VI[N];
int n, m, ele, x[N], y[N], be[N], id[N];
int chk(int x, int y) { return VI[x] == VI[y]; }
bool cmp_VI(int x, int y) { return VI[x] < VI[y]; }
vector<int> E[N];
int ok[N], col[N], C;
void dfs(int x) {
ok[x] = 1, col[x] = ++C;
for (int i = ((int)0); i <= ((int)E[x].size() - 1); i++)
if (!ok[E[x][i]]) dfs(E[x][i]);
}
int deg[N], st;
map<int, int> vis[N];
int main() {
n = rd(), m = rd();
for (int i = ((int)1); i <= ((int)n); i++) VI[i].push_back(i), id[i] = i;
for (int i = ((int)1); i <= ((int)m); i++) {
x[i] = rd(), y[i] = rd();
VI[x[i]].push_back(y[i]), VI[y[i]].push_back(x[i]);
}
for (int i = ((int)1); i <= ((int)n); i++) sort(VI[i].begin(), VI[i].end());
sort(id + 1, id + n + 1, cmp_VI);
for (int j = 1, i = 1; i <= n;) {
ele++;
while (chk(id[i], id[j])) j++;
while (i < j) be[id[i]] = ele, i++;
}
if (ele == 1) {
puts("YES");
for (int i = ((int)1); i <= ((int)n); i++) printf("1 ");
return 0;
}
for (int i = ((int)1); i <= ((int)m); i++)
if (be[x[i]] != be[y[i]] && vis[be[x[i]]][be[y[i]]] == 0) {
if (++deg[be[x[i]]] == 3) return puts("NO"), 0;
if (++deg[be[y[i]]] == 3) return puts("NO"), 0;
E[be[x[i]]].push_back(be[y[i]]), E[be[y[i]]].push_back(be[x[i]]);
vis[be[x[i]]][be[y[i]]] = 1, vis[be[y[i]]][be[x[i]]] = 1;
}
for (int i = ((int)1); i <= ((int)ele); i++)
if (deg[i] == 1) st = i;
puts("YES"), dfs(st);
for (int i = ((int)1); i <= ((int)n); i++) printf("%d ", col[be[i]]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 5e5 + 100;
int pa[MN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
list<int> lt;
int n, m, p;
cin >> n >> m >> p;
string s;
cin >> s;
vector<int> v;
for (int i = 0; i < n; ++i) {
if (s[i] == '(')
v.push_back(i);
else {
pa[i] = v.back();
pa[v.back()] = i;
v.pop_back();
}
lt.push_back(i);
}
auto pos = lt.begin();
for (int i = 0; i < p - 1; ++i) {
++pos;
}
string edit;
cin >> edit;
for (int i = 0; i < m; ++i) {
if (edit[i] == 'L') {
--pos;
}
if (edit[i] == 'R') {
++pos;
}
if (edit[i] == 'D') {
int q = *pos;
if (s[*pos] == '(') {
while (1) {
int w = pa[*pos];
pos = lt.erase(pos);
if (pos == lt.end()) --pos;
if (w == q) break;
}
} else {
while (1) {
int w = pa[*pos];
pos = lt.erase(pos);
if (pos == lt.begin()) break;
if (w == q) {
if (pos == lt.end()) --pos;
break;
}
--pos;
}
}
}
}
for (auto x : lt) cout << s[x];
cout << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[300010][2], x[300010][2];
int pa, pb, a, b;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> x[i][0];
for (int i = 1; i <= n; i++) cin >> x[i][1];
memset(dp, 0x3f, sizeof dp);
dp[0][0] = 0, dp[0][1] = 0;
for (int i = 1; i <= n; i++) {
for (int f = 0; f < 2; f++) {
int g = f ^ 1;
int a = x[i][f], b = x[i][g], pa = dp[i - 1][f], pb = dp[i - 1][g];
if (pa != 0x3f3f3f3f) {
int cnt = (pa + a + k - 1) / k - 1, x = (pa + a) % k;
if (!x) x = k;
if (b > cnt && b <= 1LL * a * k) dp[i][f] = 1;
if (b == cnt) dp[i][f] = x;
}
if (pb != 0x3f3f3f3f) {
long long L = (a + k - 1) / k - 1, R = 1LL * (a - 1) * k + (k - pb);
if (b >= L && b <= R) {
int x = a % k;
if (!x) x = k;
if (b > L)
dp[i][f] = 1;
else
dp[i][f] = x;
}
}
}
if (dp[i][0] == 0x3f3f3f3f && dp[i][1] == 0x3f3f3f3f) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 8 |
#include <bits/stdc++.h>
int n, tl, a[1000005], x[1000005];
std::stack<int> stk;
char opt[1000005][5];
void NO() {
puts("NO");
exit(0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 2 * n; ++i) {
scanf("%s", opt[i] + 1);
if (opt[i][1] == '+')
stk.push(++tl);
else {
scanf("%d", &x[i]);
if (stk.empty()) NO();
a[stk.top()] = x[i];
stk.pop();
}
}
std::set<int> S;
tl = 0;
for (int i = 1; i <= 2 * n; ++i) {
if (opt[i][1] == '+')
S.insert(a[++tl]);
else {
int p = *S.begin();
if (p != x[i]) NO();
S.erase(S.begin());
}
}
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct E {
long long x;
int y, z;
E() {}
E(long long _, int __, int ___) : x(_), y(__), z(___) {}
bool operator<(const E &a) const { return x == a.x ? y < a.y : x < a.x; }
E operator+(const long long &a) const { return E(x + a, y, z); }
void operator+=(const long long &a) {
this->x += a;
return;
}
bool empty() { return x == ~(1LL << 63); }
};
struct SegmentTree {
int p, r, m;
long long lazy;
E x;
};
struct link {
int to, nxt;
};
link e[100005 << 1];
SegmentTree tree[1 << 18];
int head[100005], cnt;
int n, T, R = 1, m, o, u, v, k, c[100005];
int fa[100005], pos[100005], rev[100005], in[100005], out[100005], siz[100005],
mx[100005], dep[100005], top[100005];
vector<int> a[100005];
int pa[100005], ans[100005];
inline void add(int u, int v) {
e[cnt] = (link){v, head[u]};
head[u] = cnt++;
e[cnt] = (link){u, head[v]};
head[v] = cnt++;
}
void dfs1(int x) {
siz[x] = 1;
mx[x] = -1;
for (int i = head[x]; ~i; i = e[i].nxt)
if (e[i].to != fa[x]) {
fa[e[i].to] = x;
dep[e[i].to] = dep[x] + 1;
dfs1(e[i].to);
siz[x] += siz[e[i].to];
if (!~mx[x] || siz[e[i].to] > siz[mx[x]]) mx[x] = e[i].to;
}
return;
}
void dfs2(int x, int t) {
top[x] = t;
pos[x] = in[x] = R;
rev[R++] = x;
if (~mx[x]) dfs2(mx[x], t);
for (int i = head[x]; ~i; i = e[i].nxt)
if (e[i].to != fa[x] && e[i].to != mx[x]) dfs2(e[i].to, e[i].to);
out[x] = R;
return;
}
void BuildTree(int u) {
if (tree[u].p + 1 == tree[u].r) {
int p = rev[tree[u].p];
if (a[p].size())
tree[u].x = E(a[p][0], p, a[p][0]);
else
tree[u].x = E(~(1LL << 63), ~(1 << 31), -1);
return;
}
tree[u].m = tree[u].p + tree[u].r >> 1;
tree[u << 1].p = tree[u].p;
tree[u << 1].r = tree[u].m;
BuildTree(u << 1);
tree[u << 1 | 1].p = tree[u].m;
tree[u << 1 | 1].r = tree[u].r;
BuildTree(u << 1 | 1);
tree[u].x = min(tree[u << 1].x, tree[u << 1 | 1].x);
return;
}
inline void PushDown(int u) {
if (!tree[u].lazy) return;
if (!tree[u << 1].x.empty()) {
tree[u << 1].x += tree[u].lazy;
tree[u << 1].lazy += tree[u].lazy;
}
if (!tree[u << 1 | 1].x.empty()) {
tree[u << 1 | 1].x += tree[u].lazy;
tree[u << 1 | 1].lazy += tree[u].lazy;
}
tree[u].lazy = 0;
return;
}
void modify(int u, int l, int r, long long v, bool f) {
if (tree[u].p == l && tree[u].r == r) {
if (tree[u].x.empty()) return;
if (f) {
tree[u].x += v;
tree[u].lazy += v;
} else {
int p = rev[tree[u].p];
if (pa[p] + 1 == a[p].size())
tree[u].x = E(~(1LL << 63), ~(1 << 31), -1);
else {
++pa[p];
tree[u].x = E(a[p][pa[p]] + tree[u].lazy, tree[u].x.y, a[p][pa[p]]);
}
}
return;
}
PushDown(u);
if (r <= tree[u].m)
modify(u << 1, l, r, v, f);
else if (tree[u].m <= l)
modify(u << 1 | 1, l, r, v, f);
else {
modify(u << 1, l, tree[u].m, v, f);
modify(u << 1 | 1, tree[u].m, r, v, f);
}
tree[u].x = min(tree[u << 1].x, tree[u << 1 | 1].x);
return;
}
inline E query(int u, int l, int r) {
if (tree[u].p == l && tree[u].r == r) return tree[u].x;
PushDown(u);
if (r <= tree[u].m)
return query(u << 1, l, r);
else if (tree[u].m <= l)
return query(u << 1 | 1, l, r);
else
return min(query(u << 1, l, tree[u].m), query(u << 1 | 1, tree[u].m, r));
}
inline int Qlink(int l, int r) {
E res = E(~(1LL << 63), ~(1 << 31), -1);
while (top[l] != top[r]) {
if (dep[top[l]] < dep[top[r]]) swap(l, r);
res = min(res, query(1, pos[top[l]], pos[l] + 1));
l = fa[top[l]];
}
if (pos[l] > pos[r]) swap(l, r);
res = min(res, query(1, pos[l], pos[r] + 1));
if (res.z == -1) return -1;
modify(1, pos[c[res.z]], pos[c[res.z]] + 1, 0, false);
return res.z;
}
inline void Q(int u, int v, int k) {
ans[0] = 0;
for (int i = 1; i <= k; i++) {
int x = Qlink(u, v);
if (!~x) break;
ans[++ans[0]] = x;
}
printf("%d", ans[0]);
for (int i = 1; i <= ans[0]; i++) printf(" %d", ans[i]);
putchar('\n');
return;
}
inline void read(int &x) {
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return;
}
int main() {
memset(head, -1, sizeof head);
read(n);
read(m);
read(T);
for (int i = 1; i < n; i++) read(u), read(v), add(u, v);
for (int i = 1; i <= m; i++) read(c[i]), a[c[i]].push_back(i);
dfs1(1);
dfs2(1, 1);
tree[1].p = 1;
tree[1].r = n + 1;
BuildTree(1);
while (T--) {
read(o);
read(u);
read(v);
if (o == 1)
read(k), Q(u, v, k);
else
modify(1, in[u], out[u], v, true);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500 * 1000 + 20;
int n, m, ver_3k, root, par[N], h[N], d[N], cnt;
set<int> st, pap1, pap2;
bool vis[N], ok, seen, no;
vector<int> gr[N];
void find_3k_ver() {
for (int i = 1; i <= n; i++)
if (d[i] % 3 == 0)
if (st.empty()) st.insert(i);
}
void dfs_find_cycle(int v) {
vis[v] = true;
int mx = -1;
for (auto u : gr[v]) {
if (st.size()) return;
if (vis[u] && u != par[v]) {
if (mx == -1)
mx = u;
else if (h[u] > h[mx])
mx = u;
}
}
if (mx != -1) {
st.insert(v);
while (v != mx && v) v = par[v], st.insert(v);
return;
}
if (st.size()) return;
for (auto u : gr[v]) {
if (st.size()) return;
if (!vis[u] && d[u] % 3 == 2)
par[u] = v, h[u] = h[v] + 1, dfs_find_cycle(u);
}
}
void find_2_cycle() {
root = 0;
for (int i = 1; i <= n; i++) vis[i] = false, h[i] = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i] && d[i] % 3 == 2) dfs_find_cycle(i);
if (st.size()) return;
}
}
bool bfs(int v) {
queue<int> q;
q.push(v);
vis[v] = true;
while (!q.empty()) {
int f = q.front();
q.pop();
if (d[f] % 3 == 1 && f != v) {
st.insert(f);
while (f != v) f = par[f], st.insert(f);
return true;
}
for (auto u : gr[f])
if (!vis[u]) par[u] = f, vis[u] = true, q.push(u);
}
return false;
}
void find_1_1_path() {
root = 0;
for (int i = 1; i <= n; i++) vis[i] = false, h[i] = 0, par[i] = 0;
for (int i = 1; i <= n; i++)
if (d[i] % 3 == 1 && !vis[i])
if (bfs(i)) return;
}
void dfs(int v, int p) {
vis[v] = true;
for (auto u : gr[v]) {
if (root != p && u == root) {
seen = true;
st.insert(v);
while (v != root) v = par[v], st.insert(v);
return;
}
}
if (seen) return;
for (auto u : gr[v]) {
if (seen) return;
if (!vis[u]) par[u] = v, dfs(u, v);
}
if (seen) return;
}
void dfs_vis_cmp(int v) {
vis[v] = true;
for (auto u : gr[v])
if (u != root && !vis[u]) dfs_vis_cmp(u);
}
void find_papion() {
root = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
vis[i] = false;
if (d[i] % 3 == 1) root = i;
}
if (!root) return;
seen = false;
dfs(root, -1);
for (auto u : st) {
pap1.insert(u);
if (u != root) dfs_vis_cmp(u);
}
st.clear();
seen = false;
dfs(root, -1);
if (!st.size()) return;
for (auto u : pap1) st.insert(u);
pap1.clear();
}
void find_yale_1_1() {
for (int i = 1; i <= n; i++)
if (d[i] % 3 == 1)
for (auto u : gr[i])
if (d[u] % 3 == 1) {
st.insert(u), st.insert(i);
return;
}
}
void print_ans() {
ok = true;
cout << "YES" << endl << n - st.size() << endl;
for (int i = 1; i <= n; i++)
if (!st.count(i)) cout << i << " ";
cout << endl;
}
void solve() {
find_3k_ver();
if (st.size() && st.size() < n) {
if (no) cout << "T1" << endl;
print_ans();
return;
}
find_yale_1_1();
if (st.size() && st.size() < n) {
if (no) cout << "T2" << endl;
print_ans();
return;
}
find_2_cycle();
if (st.size() && st.size() < n) {
if (no) cout << "T3" << endl;
print_ans();
return;
}
find_1_1_path();
if (st.size() && st.size() < n) {
if (no) cout << "T4" << endl;
print_ans();
return;
}
find_papion();
if (st.size() && st.size() < n) {
if (no) cout << "T5" << endl;
print_ans();
return;
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
ok = false;
cin >> n >> m;
for (int i = 1; i <= n; i++)
d[i] = 0, par[i] = 0, vis[i] = false, h[i] = 0, gr[i].clear();
st.clear();
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
gr[u].push_back(v), gr[v].push_back(u);
d[u]++, d[v]++;
}
solve();
if (!ok) cout << "NO" << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int p, n, j, i, k = 0, t = 0, l, h, mid, u = 0, v = 0,
cnt[26] = {0}, T, f = 0, q, r, x, y, a, b, c, d;
cin >> a >> b >> c >> d;
x = max((3 * a) / 10, a - ((a / 250) * c));
y = max((3 * b) / 10, b - ((b / 250) * d));
if (x > y) {
cout << "Misha";
}
if (x < y) {
cout << "Vasya";
}
if (x == y) {
cout << "Tie";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 7;
const int maxn = 2e3 + 7;
int n, k, a[maxn], f[maxn];
long long l, r;
inline void read(int &x);
void nhap() {
read(n);
read(k);
for (int i = (1), _b = (n); i <= _b; ++i) {
read(a[i]);
}
}
bool check(long long x) {
int res = n;
for (int i = (1), _b = (n); i <= _b; ++i) {
f[i] = i - 1;
for (int j = (1), _b = (i - 1); j <= _b; ++j)
if (abs(a[i] - a[j]) <= (i - j) * x) f[i] = min(f[i], f[j] + i - j - 1);
res = min(res, f[i] + n - i);
}
return (res <= k);
}
void solve() {
l = 0;
r = 1LL * 2e9 + 1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
}
void print() { printf("%I64d", l); }
int main() {
nhap();
solve();
print();
}
void read(int &x) {
x = 0;
register char ch;
bool neg = false;
ch = getchar();
for (;;) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
neg = true;
else
x = ch - '0';
for (;;) {
ch = getchar();
if (ch < '0' || ch > '9') break;
x = (x << 3) + (x << 1) + ch - '0';
}
if (neg) x = -x;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
struct mem {
long long a, b, c;
};
vector<mem> ans, ans1;
long long a[N], b[N], p[N], p1[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
sort(a, a + n);
sort(b, b + n);
for (int i = 0; i < n; i++) {
ans += max(a[i], b[i]);
}
cout << ans + n;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
int x, k, X, Y, n, m, u[100005];
long long ans[2];
int f[2], g[2][2][2], G[2][2][2], vis[100005];
vector<int> a[100005], A[100005], e[100005], w[100005];
void dfs(int x) {
if (vis[x]) return;
vis[x] = 1;
memset(G, 0, sizeof G);
int j = a[x][0] == Y, i = j ^ 1;
if (a[x].size() == 1) {
for (int p = 0; p < 2; ++p)
for (int q = 0; q < 2; ++q)
for (int k = 0; k < 2; ++k)
(G[p][q][k ^ q ^ w[x][0]] += g[p][q][k]) %= mo;
memcpy(g, G, sizeof G);
dfs(e[x][0]);
} else {
for (int p = 0; p < 2; ++p)
for (int q = 0; q < 2; ++q)
for (int k = 0; k < 2; ++k) {
if (X == a[x][j]) {
int t = p;
(G[p][t][k ^ ((q ^ w[x][i]) | (t ^ w[x][j]))] += g[p][q][k]) %= mo;
} else {
for (int t = 0; t < 2; ++t)
(G[p][t][k ^ ((q ^ w[x][i]) | (t ^ w[x][j]))] += g[p][q][k]) %=
mo;
}
}
Y = a[x][j];
memcpy(g, G, sizeof G);
if (A[Y][0] != x)
dfs(A[Y][0]);
else if (A[Y].size() == 2)
dfs(A[Y][1]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
for (scanf("%d", &k); k; --k) {
scanf("%d", &x);
a[i].push_back(abs(x));
w[i].push_back(x < 0);
A[abs(x)].push_back(i);
}
}
ans[0] = 1;
ans[1] = 0;
for (int i = 1; i <= m; ++i)
if (A[i].size() == 2 && A[i][0] != A[i][1]) {
++u[A[i][0]];
++u[A[i][1]];
e[A[i][0]].push_back(A[i][1]);
e[A[i][1]].push_back(A[i][0]);
} else if (!A[i].size()) {
ans[0] = ans[0] * 2 % mo;
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
if (!e[i].size()) {
vis[i] = 1;
f[0] = f[1] = 0;
if (a[i].size() == 1) {
f[0] = f[1] = 1;
} else {
if (a[i][0] != a[i][1]) {
for (int p = 0; p < 2; ++p)
for (int q = 0; q < 2; ++q) ++f[(p ^ w[i][0]) | (q ^ w[i][1])];
} else {
for (int p = 0; p < 2; ++p) ++f[(p ^ w[i][0]) | (p ^ w[i][1])];
}
}
long long pp = f[0] * ans[0] + f[1] * ans[1],
qq = f[1] * ans[0] + f[0] * ans[1];
ans[0] = pp % mo;
ans[1] = qq % mo;
} else if (u[i] == 1) {
if (a[i].size() == 1 || A[a[i][0]].size() == 1)
X = Y = a[i][0];
else
X = Y = a[i][1];
memset(g, 0, sizeof g);
g[0][0][0] = g[1][1][0] = 1;
dfs(i);
f[0] = f[1] = 0;
for (int p = 0; p < 2; ++p)
for (int q = 0; q < 2; ++q)
for (int k = 0; k < 2; ++k) (f[k] += g[p][q][k]) %= mo;
long long pp = f[0] * ans[0] + f[1] * ans[1],
qq = f[1] * ans[0] + f[0] * ans[1];
ans[0] = pp % mo;
ans[1] = qq % mo;
}
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
X = Y = a[i][0];
memset(g, 0, sizeof g);
g[0][0][0] = g[1][1][0] = 1;
dfs(i);
f[0] = f[1] = 0;
for (int p = 0; p < 2; ++p)
for (int q = 0; q < 2; ++q)
for (int k = 0; k < 2; ++k) (f[k] += g[p][q][k]) %= mo;
long long pp = f[0] * ans[0] + f[1] * ans[1],
qq = f[1] * ans[0] + f[0] * ans[1];
ans[0] = pp % mo;
ans[1] = qq % mo;
}
printf("%lld\n", ans[1] % mo);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
return out << '(' << p.first << ' ' << p.second << ')';
}
const long long MOD = 998244353;
long long n, k, m, ans;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
ans = n;
for (long long i = 1; i <= n; i++) {
ans *= i;
ans %= MOD;
}
long long p = 1;
for (long long i = n; i >= 2; i--) {
p *= i;
p %= MOD;
ans -= p;
ans %= MOD;
ans += MOD;
ans %= MOD;
}
cout << ans << '\n';
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-10;
const int inf = 2000000000;
const int MOD = 1000000007;
int MOD1 = 1000000007;
int MOD2 = 1000000009;
inline bool checkBit(long long int n, long long int i) {
return n & (1LL << i);
}
inline long long int setBit(long long int n, long long int i) {
return n | (1LL << i);
;
}
inline long long int resetBit(long long int n, long long int i) {
return n & (~(1LL << i));
}
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long int year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long int &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long int modMul(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long int modAdd(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long int modSub(long long int a, long long int b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long int modPow(long long int b, long long int p) {
long long int r = 1LL;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1LL;
}
return r;
}
inline long long int modDiv(long long int a, long long int b) {
return modMul(a, modPow(b, MOD - 2));
}
bool comp(const pair<long long int, pair<long long int, long long int> > &p1,
const pair<long long int, pair<long long int, long long int> > &p2) {
return p1.first > p2.first;
}
long long int converter(string a) {
long long int i, mul = 1, r, t, ans = 0LL;
if (a.length() == 0) return 0;
for (i = a.length() - 1; i >= 0; i--) {
t = a[i] - '0';
r = t % 10;
ans += (mul * r);
mul = mul * 10;
}
return ans;
}
string s;
int tree[4][100005][12][12], n;
int fun(char c) {
if (c == 'A') return 0;
if (c == 'T') return 1;
if (c == 'G')
return 2;
else
return 3;
}
void update(int id, int x, int len, int j, int val) {
while (x <= 100000) {
tree[id][x][len][j] += val;
x += (x & -x);
}
}
int query(int id, int x, int len, int j) {
int sum = 0;
while (x > 0) {
sum += tree[id][x][len][j];
x -= (x & -x);
}
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string temp;
int i, l, r, tp, q, j, len, c, x, id, id2, ans;
string ch, cur;
cin >> s;
n = s.size();
for (i = 1; i <= n; ++i) {
id = fun(s[i - 1]);
for (len = 1; len <= 10; ++len) {
j = i % len;
update(id, i, len, j, 1);
}
}
cin >> q;
for (int f = 1; f <= q; ++f) {
cin >> tp;
if (tp == 1) {
cin >> x >> ch;
id = fun(ch[0]);
id2 = fun(s[x - 1]);
for (len = 1; len <= 10; ++len) {
j = x % len;
update(id, x, len, j, 1);
update(id2, x, len, j, -1);
s[x - 1] = ch[0];
}
} else if (tp == 2) {
ans = 0;
cin >> l >> r >> cur;
int d = l;
len = cur.size();
for (i = 1; i <= cur.size(); ++i) {
if (l > r) break;
id = fun(cur[i - 1]);
j = l % len;
ans += (query(id, r, len, j) - query(id, d - 1, len, j));
++l;
}
cout << ans << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int pw(int a, int b, int mod) {
int r = 1;
while (b) {
if (b & 1) {
r = (long long)r * a % mod;
}
a = (long long)a * a % mod;
b /= 2;
}
return r;
}
int dv(int a, int b, int mod) {
return (long long)a * pw(b, mod - 2, mod) % mod;
}
const int C = 2;
const int mods[] = {1000000271, 1000000787, 1000000931};
struct T {
int first, second;
};
bool operator<(T f, T s) {
if (f.first != s.first) {
return f.first < s.first;
}
return f.second < s.second;
}
T operator+(T f, T s) {
f.first += s.first;
if (f.first >= mods[0]) {
f.first -= mods[0];
}
f.second += s.second;
if (f.second >= mods[1]) {
f.second -= mods[1];
}
return f;
}
T operator-(T f, T s) {
f.first -= s.first;
if (f.first < 0) {
f.first += mods[0];
}
f.second -= s.second;
if (f.second < 0) {
f.second += mods[1];
}
return f;
}
T operator*(T f, T s) {
f.first = (long long)f.first * s.first % mods[0];
f.second = (long long)f.second * s.second % mods[1];
return f;
}
T operator^(T f, int x) {
f.first = pw(f.first, x, mods[0]);
f.second = pw(f.second, x, mods[1]);
return f;
}
T operator/(T f, T s) {
f.first = dv(f.first, s.first, mods[0]);
f.second = dv(f.second, s.second, mods[1]);
return f;
}
bool operator==(T f, T s) {
return (f.first == s.first && f.second == s.second);
}
const int K = (int)1e6 + 7;
T kwk[K], iki[K];
struct magma {
vector<T> lol;
int ln;
void init(string s) {
ln = (int)s.size();
lol.resize(ln + 1);
for (int j = 0; j < ln; j++) {
T now;
now.first = now.second = s[j] - 'a';
lol[j + 1] = lol[j] + now * kwk[j + 1];
}
}
T get(int l, int r) {
l++;
r++;
T sol = lol[r] - lol[l - 1];
sol = sol * iki[l - 1];
return sol;
}
T get_skip(int skp, int i) {
if (i < skp) {
return get(0, i);
} else {
T a = get(0, skp - 1);
T b = get(skp + 1, i + 1);
return a + b * kwk[skp];
}
}
T get_pos(int skp, int i) {
if (i < skp) {
return get(i, i);
} else {
return get(i + 1, i + 1);
}
}
};
void upd(vector<int> x) {
for (auto &it : x) {
if (it == -1) {
return;
}
}
vector<int> y = x;
sort(y.begin(), y.end());
for (int i = 1; i < (int)y.size(); i++) {
if (y[i] == y[i - 1]) {
return;
}
}
cout << "YES\n";
for (auto &it : x) {
cout << it << " ";
}
cout << "\n";
exit(0);
}
vector<int> get_sorted(string s) {
int n = (int)s.size();
vector<int> nd(n);
nd[n - 1] = n - 1;
for (int i = n - 2; i >= 0; i--) {
if (s[i] == s[i + 1]) {
nd[i] = nd[i + 1];
} else {
nd[i] = i + 1;
}
}
vector<int> sol(n);
int l = 0, r = n - 1;
for (int i = 0; i < n; i++) {
if (s[nd[i]] <= s[i]) {
sol[l++] = i;
} else {
sol[r--] = i;
}
}
vector<int> ret;
for (auto &it : sol) {
ret.push_back(it);
if (it == n - 1) {
ret.push_back(n);
}
}
return ret;
}
vector<int> get_sorted_smart(string s) {
int n = (int)s.size();
vector<pair<string, int>> vec;
vec.push_back({s, n});
for (int j = 0; j < n; j++) {
string t;
for (int i = 0; i < n; i++) {
if (i != j) {
t += s[i];
}
}
vec.push_back({t, j});
}
sort(vec.begin(), vec.end());
vector<int> sol;
for (auto &it : vec) {
sol.push_back(it.second);
}
return sol;
}
const int N = (int)1e5 + 7;
const int MOD = (int)1e9 + 7;
int n;
string a[N];
magma b[N];
vector<int> so[N];
int comp(int i, int skp1, int skp2) {
int ln1 = (int)a[i].size() - (skp1 < (int)a[i].size());
int ln2 = (int)a[i + 1].size() - (skp2 < (int)a[i + 1].size());
int com = 0, lo = 1, hi = min(ln1, ln2);
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (b[i].get_skip(skp1, mid - 1) == b[i + 1].get_skip(skp2, mid - 1)) {
com = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
if (com == min(ln1, ln2)) {
if (ln1 == ln2) {
return 0;
}
if (ln1 < ln2) {
return 1;
} else {
return 2;
}
}
if (b[i].get_pos(skp1, com) < b[i + 1].get_pos(skp2, com)) {
return 1;
} else {
return 2;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
T p26;
p26.first = p26.second = 26;
kwk[0].first = kwk[0].second = 1;
for (int j = 1; j < K; j++) {
kwk[j] = kwk[j - 1] * p26;
}
iki[K - 1] = kwk[0] / kwk[K - 1];
for (int j = K - 2; j >= 0; j--) {
iki[j] = iki[j + 1] * kwk[1];
}
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
so[i] = get_sorted(a[i]);
b[i].init(a[i]);
}
vector<int> dp((int)so[1].size(), 1);
for (int i = 2; i <= n; i++) {
vector<int> ndp((int)so[i].size(), 0);
int pos = 0, sum = 0;
for (int k = 0; k < (int)so[i].size(); k++) {
while (pos < (int)so[i - 1].size() &&
comp(i - 1, so[i - 1][pos], so[i][k]) <= 1) {
sum = (sum + dp[pos]) % MOD;
pos++;
}
ndp[k] = sum;
}
dp = ndp;
}
int sol = 0;
for (auto &it : dp) {
sol = (sol + it) % MOD;
}
cout << sol << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, m, q, k;
long long mulmod(long long a, long long b) {
long long ret = 0;
while (b) {
if (b & 1) ret = (ret + a) % 1000000009;
a = (a << 1) % 1000000009;
b >>= 1;
}
return ret;
}
long long fastPow(long long x, long long n) {
long long ret = 1;
while (n) {
if (n & 1) ret = mulmod(ret, x);
x = mulmod(x, x);
n >>= 1;
}
return ret;
}
long long a, b;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> a >> b >> k;
long long ans = 0;
string str;
cin >> str;
long long inva = fastPow(a, 1000000009 - 2);
long long aux = 0, term, q;
q = b * inva % 1000000009;
term = fastPow(a, n);
for (int i = int(0); i < int(k); i++) {
char c = str[i % k];
if (c == '+') {
aux += term;
} else {
aux += 1000000009;
aux -= term;
}
aux %= 1000000009;
term = mulmod(term, q);
}
q = fastPow(q, k);
int quot = (n + 1) / k;
long long inv = fastPow(q - 1 + 1000000009, 1000000009 - 2);
if (q <= 1)
q = q * quot;
else
q = mulmod(((fastPow(q, quot) - 1) % 1000000009), inv);
ans = mulmod(aux, q);
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<int> st[100005];
priority_queue<pair<int, int> > q;
vector<pair<int, int> > v[100005];
long long dist[100005];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < 100005; i++) {
dist[i] = 1e11;
}
dist[1] = 0;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
v[a].push_back({b, c});
v[b].push_back({a, c});
}
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
while (k--) {
int x;
cin >> x;
st[i].insert(x);
}
}
q.push({0, 1});
while (q.size() > 0) {
int f = -q.top().first, s = q.top().second;
q.pop();
if (dist[s] < f) continue;
if (s == n) {
cout << f << endl;
return 0;
}
while (st[s].count(f) == 1) {
f++;
}
for (int i = 0; i < v[s].size(); i++) {
pair<int, int> to = v[s][i];
if (dist[to.first] > f + to.second) {
q.push({-(f + to.second), to.first});
dist[to.first] = f + to.second;
}
}
}
cout << -1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, d;
int a[N];
int main() {
scanf("%d%d", &n, &d);
long long sm = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
sm += a[i];
if (a[i] == 0 && sm < 0) sm = 0;
if (sm > d) {
cout << -1;
return 0;
}
}
long long sum = 0;
int cnt = 0, check = 0;
for (int i = 0; i < n; ++i) {
sum += a[i];
if (sum > d) {
check -= (sum - d);
sum = d;
if (check < 0) {
cout << -1;
return 0;
}
}
if (a[i] == 0 && sum < 0) {
cnt++;
sum = check = d;
}
}
cout << cnt;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
string s(n, '?');
auto Ask = [&](string t) {
cout << "? " << t << endl;
int foo;
cin >> foo;
for (int i = 0; i < foo; i++) {
int bar;
cin >> bar;
--bar;
for (int j = 0; j < (int)t.size(); j++) {
s[bar + j] = t[j];
}
}
};
if (n <= 7) {
Ask("CH");
Ask("CO");
if (s == string(n, '?')) {
if (n == 4) {
Ask("HO");
if (s == string(n, '?')) {
Ask("OH");
if (s == string(n, '?')) {
Ask("CCC");
if (s == string(n, '?')) {
Ask("OOO");
if (s[0] == 'O') {
if (s[n - 1] == '?') s[n - 1] = 'C';
} else {
Ask("HHH");
if (s[0] == 'H') {
if (s[n - 1] == '?') s[n - 1] = 'C';
} else {
Ask("OOCC");
if (s == string(n, '?')) s = "HHCC";
}
}
} else {
Ask("HCCC");
Ask("OCCC");
}
} else {
for (int i = 0; i < n; i++) {
if (s[i] == '?') {
s[i] = 'O';
} else {
break;
}
}
goto haha;
}
} else {
goto haha;
}
} else {
Ask("CC");
if (s[1] != '?' && s[0] == '?') {
string q = s;
q[0] = 'H';
Ask(q);
if (s[0] == '?') {
s[0] = 'O';
}
} else {
Ask("OH");
Ask("HO");
if (s == string(n, '?')) {
Ask(string(n, 'H'));
Ask(string(n, 'O'));
if (s == string(n, '?')) {
string q(n, 'H');
q[n - 1] = 'C';
Ask(q);
if (s == string(n, '?')) {
s = string(n, 'O');
s[n - 1] = 'C';
}
}
} else {
if (s[n - 1] == 'C' && s.find("H") == string::npos &&
s.find("O") == string::npos) {
string q = s;
for (int i = 0; i < n; i++) {
if (q[i] == '?') {
q[i] = 'H';
}
}
Ask(q);
if (s[0] == '?') {
for (int i = 0; i < n; i++) {
if (s[i] == '?') {
s[i] = 'O';
}
}
}
} else {
int beg = 0;
while (beg < n) {
if (s[beg] != '?') {
++beg;
continue;
}
int end = beg;
while (end + 1 < n && s[end + 1] == '?') {
++end;
}
if (beg == 0) {
for (int i = beg; i <= end; i++) {
s[i] = s[end + 1];
}
} else {
for (int i = beg; i <= end; i++) {
s[i] = s[beg - 1];
}
}
beg = end + 1;
}
string q = s;
q[n - 1] = 'C';
Ask(q);
}
}
}
}
} else {
haha:
while (true) {
bool any = false;
for (int i = 0; i < n; i++) {
if (s[i] == '?') {
any = true;
break;
}
}
if (!any) {
break;
}
bool found = false;
for (int i = 0; i + 4 < n; i++) {
if (s[i] == '?' && s[i + 1] != '?' && s[i + 2] != '?' &&
s[i + 3] != '?' && s[i + 4] != '?') {
string q = "C";
q += s[i + 1];
q += s[i + 2];
q += s[i + 3];
q += s[i + 4];
Ask(q);
if (s[i] == '?') {
q[0] = 'O';
Ask(q);
if (s[i] == '?') {
s[i] = 'H';
}
}
found = true;
break;
}
}
if (found) continue;
for (int i = 0; i + 4 < n; i++) {
if (s[i] != '?' && s[i + 1] != '?' && s[i + 2] != '?' &&
s[i + 3] != '?' && s[i + 4] == '?') {
string q = "";
q += s[i];
q += s[i + 1];
q += s[i + 2];
q += s[i + 3];
q += "C";
Ask(q);
if (s[i + 4] == '?') {
q[4] = 'O';
Ask(q);
if (s[i + 4] == '?') {
s[i + 4] = 'H';
}
}
found = true;
break;
}
}
if (found) continue;
for (int i = 0; i + 3 < n; i++) {
if (s[i] == '?' && s[i + 1] != '?' && s[i + 2] != '?' &&
s[i + 3] != '?') {
string q = "C";
q += s[i + 1];
q += s[i + 2];
q += s[i + 3];
Ask(q);
if (s[i] == '?') {
q[0] = 'O';
Ask(q);
if (s[i] == '?') {
s[i] = 'H';
}
}
found = true;
break;
}
}
if (found) continue;
for (int i = 0; i + 3 < n; i++) {
if (s[i] != '?' && s[i + 1] != '?' && s[i + 2] != '?' &&
s[i + 3] == '?') {
string q = "";
q += s[i];
q += s[i + 1];
q += s[i + 2];
q += "C";
Ask(q);
if (s[i + 3] == '?') {
q[3] = 'O';
Ask(q);
if (s[i + 3] == '?') {
s[i + 3] = 'H';
}
}
found = true;
break;
}
}
if (found) continue;
for (int i = 0; i + 2 < n; i++) {
if (s[i] == '?' && s[i + 1] != '?' && s[i + 2] != '?') {
string q = "C";
q += s[i + 1];
q += s[i + 2];
Ask(q);
if (s[i] == '?') {
q[0] = 'O';
Ask(q);
if (s[i] == '?') {
s[i] = 'H';
}
}
found = true;
break;
}
}
if (found) continue;
for (int i = 0; i + 2 < n; i++) {
if (s[i] != '?' && s[i + 1] != '?' && s[i + 2] == '?') {
string q = "";
q += s[i];
q += s[i + 1];
q += "C";
Ask(q);
if (s[i + 2] == '?') {
q[2] = 'O';
Ask(q);
if (s[i + 2] == '?') {
s[i + 2] = 'H';
}
}
found = true;
break;
}
}
assert(found);
}
}
} else {
Ask("CH");
Ask("CO");
Ask("HC");
Ask("HO");
Ask("OC");
if (s == string(n, '?')) {
Ask(string(n, 'C'));
if (s == string(n, '?')) {
Ask("OHH");
if (s == string(n, '?')) {
Ask(string(n - 1, 'O'));
if (s == string(n, '?')) {
s = string(n, 'H');
} else {
if (s[n - 1] == '?') {
s[n - 1] = 'H';
}
}
} else {
for (int i = 0; i < n; i++) {
if (s[i] == '?') {
s[i] = 'O';
} else {
break;
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '?') {
s[i] = 'H';
} else {
break;
}
}
}
}
} else {
Ask("OHH");
int pref = 0, suf = 0;
int beg = 0;
while (beg < n) {
if (s[beg] != '?') {
++beg;
continue;
}
int end = beg;
while (end + 1 < n && s[end + 1] == '?') {
++end;
}
if (beg == 0) {
if (s[end + 1] != 'H') {
for (int i = beg; i <= end; i++) {
s[i] = s[end + 1];
}
} else {
pref = end + 1;
}
} else {
if (end == n - 1) {
if (s[beg - 1] != 'O') {
for (int i = beg; i <= end; i++) {
s[i] = s[beg - 1];
}
} else {
for (int i = beg; i <= end - 1; i++) {
s[i] = 'O';
}
suf = 1;
}
} else {
if (s[beg - 1] == 'O' && s[end + 1] == 'H') {
for (int i = beg; i <= end; i++) {
s[i] = 'O';
}
} else {
assert(s[beg - 1] == s[end + 1]);
for (int i = beg; i <= end; i++) {
s[i] = s[beg - 1];
}
}
}
}
beg = end + 1;
}
if (pref > 0) {
string q = s;
if (suf > 0) {
q.pop_back();
}
for (int i = 0; i < pref; i++) {
q[i] = 'O';
}
Ask(q);
if (s[0] == '?') {
for (int i = 0; i < pref; i++) {
s[i] = 'H';
}
}
}
if (suf > 0) {
string q = s;
q[n - 1] = 'O';
Ask(q);
if (s[n - 1] == '?') {
s[n - 1] = 'H';
}
}
}
}
cout << "! " << s << endl;
int foo;
cin >> foo;
if (foo == 0) break;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
vector<int> readVec(int n) {
vector<int> result;
result.resize(static_cast<std::size_t>(n));
for (int i = 0; i < n; i++) {
int a;
cin >> a;
result[i] = a;
}
return result;
}
void solve() {
int n;
cin >> n;
int b = sqrt(n);
vector<int> result;
for (int i = 0; i <= b; i++) {
result.push_back(i);
}
for (int i = b; i > 0; i--) {
result.push_back(n / i);
}
result.erase(unique(result.begin(), result.end()), result.end());
cout << result.size() << endl;
for (auto a : result) {
cout << a << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int S = 2001;
const int P = 1073741824;
int Gcd[S][S], flag[S], prime[S], mul[S];
int ans, A, B, C, i, j, a, d, t, cnt;
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int F(int n, int g) {
int ret = 0;
for (int i = 1; i <= n; i++)
if (Gcd[i][g] == 1) ret += n / i;
return ret;
}
int main() {
scanf("%d%d%d", &A, &B, &C);
for (mul[1] = 1, i = 2; i < S; i++) {
if (!flag[i]) prime[++cnt] = i, mul[i] = -1;
for (j = 1; j <= cnt; j++) {
if ((t = prime[j] * i) >= S) break;
flag[t] = 1;
mul[t] = -mul[i];
if (i % prime[j] == 0) {
mul[t] = 0;
break;
}
}
}
for (i = 1; i < S; i++)
for (j = 1; j < S; j++) Gcd[i][j] = gcd(i, j);
for (a = 1; a <= A; a++) {
for (d = 1; d <= B && d <= C; d++)
if (Gcd[a][d] == 1) ans += mul[d] * (A / a) * F(B / d, a) * F(C / d, a);
ans %= P;
if (ans < 0) ans += P;
}
printf("%d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
inline int nxt() {
int wow;
scanf("%d", &wow);
return wow;
}
inline long long int lxt() {
long long int wow;
scanf("%lld", &wow);
return wow;
}
inline double dxt() {
double wow;
scanf("%lf", &wow);
return wow;
}
int main() {
int n = nxt(), k = nxt(), ans = 0;
double sum = 0.0, avg = 0.0;
for (int i = 0; i < n; i++) {
int x = nxt();
sum += (double)x;
}
avg = sum / n;
while (avg < (double)k - 0.5) {
sum += (double)k;
ans++;
avg = sum / (n + ans);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[10006];
int main() {
int i, j, k, m, n, t;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
int sum = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
if (sum % n != 0) {
printf("-1\n");
continue;
}
int o = sum / n;
bool flag = 1;
printf("%d\n", 3 * n - 3);
for (i = 2; i <= n; i++) {
int r = ((a[i] - 1) / i + 1) * i;
printf("%d %d %d\n", 1, i, r - a[i]);
printf("%d %d %d\n", i, 1, r / i);
a[i] %= i;
}
for (i = 2; i <= n; i++) {
printf("%d %d %d\n", 1, i, o);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e6 + 6;
const long long MOD = 1e9 + 7;
bool comparator(long long i, long long j) { return (i < j); }
long long power(long long x, long long i) {
long long ans = 1;
while (i > 0) {
if (i & 1) ans = (ans * x) % MOD;
i >>= 1;
x = (x * x) % MOD;
}
return ans;
}
long long power(long long x, long long i, long long mod) {
long long ans = 1;
while (i > 0) {
if (i & 1) ans = (ans * x) % mod;
i >>= 1;
x = (x * x) % mod;
}
return ans;
}
long long modInverse(long long x, long long mod) {
return power(x, mod - 2, mod);
}
bool isPalindrome(string s) {
long long limit = s.length() / 2;
for (long long i = 0; i < limit; i++) {
if (s[i] != s[s.length() - i - 1]) return 0;
}
return true;
}
long long gcd(long long x, long long y) {
long long t;
while (y != 0) {
t = x % y;
x = y;
y = t;
}
return x;
}
bool isVowel(char ch) {
if (ch == 'a' || ch == 'i' || ch == 'e' || ch == 'u' || ch == 'o' ||
ch == 'y') {
return true;
}
return false;
}
bool isPrime(long long n) {
long long root = sqrt(n);
for (long long i = 2; i <= root; i++)
if (n % i == 0) return 0;
return 1;
}
long double getDis(long double asdfg, long double qwert, long double gfdsa,
long double trewq) {
return sqrt((asdfg - gfdsa) * (asdfg - gfdsa) +
(qwert - trewq) * (qwert - trewq));
}
long double getDisSquare(long double asdfg, long double qwert,
long double gfdsa, long double trewq) {
return (asdfg - gfdsa) * (asdfg - gfdsa) + (qwert - trewq) * (qwert - trewq);
}
bool isSquareHelper(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3, long long x4,
long long y4) {
long double d1, d2, d3, d4, d5, d6;
d1 = getDisSquare(asdfg, qwert, gfdsa, trewq);
d2 = getDisSquare(gfdsa, trewq, x3, y3);
d3 = getDisSquare(x3, y3, x4, y4);
d4 = getDisSquare(x4, y4, asdfg, qwert);
if (d1 == d2 && d1 == d3 && d1 == d4) {
d5 = getDisSquare(asdfg, qwert, x3, y3);
d6 = getDisSquare(gfdsa, trewq, x4, y4);
if (d5 == d6) {
return 1;
}
}
return 0;
}
bool isSquare(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3, long long x4,
long long y4) {
if (isSquareHelper(asdfg, qwert, gfdsa, trewq, x3, y3, x4, y4) ||
isSquareHelper(asdfg, qwert, gfdsa, trewq, x4, y4, x3, y3) ||
isSquareHelper(asdfg, qwert, x3, y3, gfdsa, trewq, x4, y4))
return 1;
else
return 0;
}
bool isEqualateralTriangle(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3) {
long long d1 = getDisSquare(asdfg, qwert, gfdsa, trewq);
long long d2 = getDisSquare(gfdsa, trewq, x3, y3);
long long d3 = getDisSquare(x3, y3, asdfg, qwert);
if (d1 == d2 && d1 == d3) {
return 1;
} else
return 0;
}
bool isRightAngleTriangleHelper(long long asdfg, long long qwert,
long long gfdsa, long long trewq, long long x3,
long long y3) {
long long d1 = getDisSquare(asdfg, qwert, gfdsa, trewq);
long long d2 = getDisSquare(gfdsa, trewq, x3, y3);
long long d3 = getDisSquare(x3, y3, asdfg, qwert);
if (d2 == (d1 + d3)) {
return 1;
}
return 0;
}
bool isRightAngleTriangle(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3) {
if (isRightAngleTriangleHelper(asdfg, qwert, gfdsa, trewq, x3, y3) ||
isRightAngleTriangleHelper(gfdsa, trewq, x3, y3, asdfg, qwert) ||
isRightAngleTriangleHelper(x3, y3, asdfg, qwert, gfdsa, trewq))
return 1;
return 0;
}
bool areCollinear(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3) {}
long long n, a[maxn], f[maxn];
set<long long> l;
struct myCompare {
bool operator()(const pair<long long, long long>& l,
const pair<long long, long long>& r) const {
if (l.first != r.first) {
return l.first > r.first;
} else {
return l.second < r.second;
}
}
};
set<pair<long long, long long>, myCompare> ms;
void getInput() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
}
void getAnswer() {}
void setupFrequencies() {
for (long long i = 0; i < n; i++) {
long long j = i;
while (j < n && a[i] == a[j]) j++;
f[i] = (j - i);
i = j - 1;
}
for (long long i = 0; i < n; i++)
if (f[i]) l.insert(i), ms.insert(make_pair(f[i], i));
}
void removeInterval(long long ind) {
l.erase(ind);
f[ind] = 0;
auto right_itr = l.lower_bound(ind);
if (right_itr == l.begin()) return;
if (right_itr == l.end()) return;
auto left_itr = --right_itr;
right_itr++;
if (a[*left_itr] == a[*right_itr]) {
ms.erase(make_pair(f[*left_itr], *left_itr));
ms.erase(make_pair(f[*right_itr], *right_itr));
f[*left_itr] += f[*right_itr];
f[*right_itr] = 0;
ms.insert(make_pair(f[*left_itr], *left_itr));
l.erase(right_itr);
}
}
void solve() {
setupFrequencies();
long long counter = 0;
while (ms.size()) {
auto itr = ms.begin();
auto ind = itr->second;
ms.erase(itr);
removeInterval(ind);
counter++;
}
cout << counter << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) getInput(), solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
string a;
cin >> a;
int n = a.size(), ans = 0, pos[n];
for (int i = 0; i < n - 2; i++) {
if (a[i] == 't' && a[i + 1] == 'w' && a[i + 2] == 'o') {
i += 2;
pos[ans] = i;
ans++;
if (i > n - 3) break;
if (a[i + 1] == 'n' && a[i + 2] == 'e') {
pos[ans - 1] = i + 1;
i += 2;
}
}
if (a[i] == 'o' && a[i + 1] == 'n' && a[i + 2] == 'e') {
pos[ans] = i + 2;
ans++;
i += 2;
}
}
cout << ans << endl;
for (int i = 0; i < ans; i++) cout << pos[i] << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-8;
static const double PI = 4.0 * atan(1.0);
bool ISINT(double x) { return fabs(x - (int)round(x)) < EPS; }
bool ISEQ(double x, double y) { return fabs(x - y) < EPS; }
string itos(long long x) {
stringstream ss;
ss << x;
return ss.str();
}
long long n, k, d[2];
bool check(long long bit) {
long long t[3] = {0};
long long minVal = 0;
for (long long i = 0; i < 2; i++) {
if (bit & (1LL << i)) {
t[i + 1] = t[i] + d[i];
} else {
t[i + 1] = t[i] - d[i];
}
minVal = min(minVal, t[i + 1]);
}
if (minVal < 0) {
for (long long i = 0; i < 3; i++) {
t[i] += -minVal;
}
}
long long sum = 0;
for (long long i = 0; i < 3; i++) {
sum += t[i];
}
if (sum > k) return false;
if ((k - sum) % 3LL != 0) return false;
for (long long i = 0; i < 3; i++) {
t[i] += (k - sum) / 3LL;
}
for (long long i = 0; i < 3; i++) {
if (t[i] > n / 3LL) {
return false;
}
}
return true;
}
int main(void) {
long long T;
cin >> T;
while (T--) {
cin >> n >> k >> d[0] >> d[1];
bool flg = false;
if (n % 3LL != 0LL) {
cout << "no" << endl;
continue;
}
for (long long i = 0; i < (1LL << 2LL); i++) {
if (check(i)) {
flg = true;
break;
}
}
cout << (flg ? "yes" : "no") << endl;
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define MAX 1000001
int main()
{
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
ll ans=0;
int a[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
for(int i=0;i<n;i++)
{
if(a[i]==1 || a[i]==3)
ans++;
}
cout<<ans<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long> q1;
priority_queue<long long> q2;
long long x, ans1, ans2;
int main() {
int a;
cin >> a;
q1.push(0);
q2.push(0);
q1.push(0);
q2.push(0);
for (int i = 0; i < a; i++) {
scanf("%lld", &x);
q1.push(x);
}
for (int i = 0; i < a; i++) {
scanf("%lld", &x);
q2.push(x);
}
while (a--) {
if (q1.top() > q2.top()) {
ans1 += q1.top();
q1.pop();
} else {
q2.pop();
}
if (q2.top() > q1.top()) {
ans2 += q2.top();
q2.pop();
} else {
q1.pop();
}
}
printf("%lld", ans1 - ans2);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
const int inf = 1034567891;
const long long LL_INF = 1234567890123456789ll;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T>
T GCD(T a, T b) {
long long t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T>
string toString(T a) {
return to_string(a);
}
template <typename T>
void toInt(string s, T& x) {
stringstream str(s);
str >> x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int powr(int a, long long b) {
int x = 1 % mod;
while (b) {
if (b & 1) x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline int inv(int a) { return powr(a, mod - 2); }
const int N = 2e5 + 5;
int fact[N], invFact[N];
void pre() {
fact[0] = invFact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = mul(fact[i - 1], i);
}
invFact[N - 1] = inv(fact[N - 1]);
for (int i = N - 2; i >= 1; i--) {
invFact[i] = mul(invFact[i + 1], i + 1);
}
}
int nCr(int n, int r) {
if (r > n) return 0;
int ans = fact[n];
ans = mul(ans, invFact[r]);
ans = mul(ans, invFact[n - r]);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, p;
cin >> n >> p;
mod = p;
pre();
vector<int> vec;
int v;
for (int i = 0; i < n; i++) {
cin >> v;
vec.push_back(v);
}
sort(vec.begin(), vec.end());
vector<int> ans;
for (int x = 1;; x++) {
int ind = lower_bound(vec.begin(), vec.end(), x + 1) - vec.begin();
if (ind == vec.size()) {
break;
}
int y = x;
int cur = 1, sz = 0, a = 0, idx = 0;
bool can = true;
for (int i = 0; i < n;) {
if (vec[i] > x) {
v = vec[i];
int d = vec[i] - x;
if (d > i) {
cur = 0;
can = false;
break;
}
int cnt = 0;
while (i < n && vec[i] == v) {
i++;
cnt++;
}
while (idx < d) {
idx++;
cur = mul(cur, a);
a--;
}
a += cnt;
} else {
a++;
i++;
}
}
if (can) {
while (a > 0) {
cur = mul(cur, a);
a--;
}
}
if (cur % p) {
ans.push_back(x);
}
}
cout << ans.size() << '\n';
for (auto it : ans) cout << it << " ";
cout << '\n';
;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, m;
cin >> w >> m;
while (m > 0) {
if (m % w == 0) {
m = m / w;
} else {
if (m % w == 1) {
m = (m - 1) / w;
} else {
if (m % w == w - 1) {
m = (m + 1) / w;
} else {
break;
}
}
}
}
if (m == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[2000][2001];
int q, w, t = 0, s[2000][2000], d[4000000], f[4000000];
void add(int e, int r) {
if ((0 <= e) && (0 <= r)) s[e][r]++;
}
void del(int e, int r) {
if ((0 <= e) && (0 <= r)) {
s[e][r]--;
if (s[e][r] == 1) {
d[t] = e;
f[t] = r;
t++;
}
}
}
void ch(int e, int r) {
if ((e < q) && ((r < w) && (a[e][r] == '*'))) {
a[e][r] = '.';
del(e, r);
del(e - 1, r);
del(e, r - 1);
del(e - 1, r - 1);
}
}
int main() {
int e, r, c, v;
scanf("%d%d", &q, &w);
for (e = 0; e < q; e++) {
scanf("%s", a[e]);
for (r = 0; r < w; r++) {
s[e][r] = 0;
if ((e == q - 1) || (r == w - 1)) s[e][r] = 9;
}
}
for (e = 0; e < q; e++)
for (r = 0; r < w; r++)
if (a[e][r] == '*') {
add(e, r);
add(e - 1, r);
add(e, r - 1);
add(e - 1, r - 1);
}
for (e = 0; e < q; e++)
for (r = 0; r < w; r++)
if (s[e][r] == 1) {
d[t] = e;
f[t] = r;
t++;
}
for (e = 0, r = t; e < r; r = t)
for (; e < r; e++) {
c = d[e];
v = f[e];
ch(c, v);
ch(c + 1, v);
ch(c, v + 1);
ch(c + 1, v + 1);
}
for (e = 0; e < q; e++) printf("%s\n", a[e]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using max_priority_queue = priority_queue<T, vector<T>, less<T>>;
const int64_t MODVAL = 1e9 + 7;
template <typename T1, typename T2>
istream &operator>>(istream &obj, pair<T1, T2> &p) {
obj >> p.first >> p.second;
return obj;
}
template <typename T>
void readv(vector<T> &v, int offset = 0) {
for (int i = offset; i < v.size(); ++i) {
cin >> v[i];
}
}
template <typename T>
void readv(vector<vector<T>> &v, int offset = 0) {
for (int i = offset; i < v.size(); ++i) {
readv(v[i], offset);
}
}
template <typename T>
istream &operator>>(istream &obj, vector<T> &v) {
readv(v);
return obj;
}
int64_t powermod(int64_t x, int64_t n, int64_t mod = MODVAL) {
if (n == 0) {
return 1;
} else if (n % 2) {
return (x * powermod(x, n - 1, mod)) % mod;
}
int64_t temp = powermod(x, n / 2, mod);
return (temp * temp) % mod;
}
int64_t power(int64_t x, int64_t n) {
if (n == 0) {
return 1;
} else if (n % 2) {
return (x * power(x, n - 1));
}
int64_t temp = power(x, n / 2);
return (temp * temp);
}
map<int64_t, int64_t> modinv;
int64_t inv(int64_t n, int64_t mod = MODVAL) {
if (modinv[n] == 0) {
modinv[n] = powermod(n, mod - 2, mod);
}
return modinv[n];
}
class dsu {
public:
vector<int64_t> par, size;
dsu(int64_t n)
: par(vector<int64_t>(n + 1)), size(vector<int64_t>(n + 1, 1)) {
for (int i = 0; i < n + 1; ++i) {
par[i] = i;
}
}
int64_t rep(int64_t x) {
if (par[x] != x) {
x = rep(par[x]);
}
return par[x];
}
bool check(int64_t a, int64_t b) { return par[a] == par[b]; }
void join(int64_t a, int64_t b) {
a = rep(a);
b = rep(b);
if (size[a] < size[b]) {
swap(a, b);
}
par[b] = a;
size[a] += size[b];
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int64_t N, count = 0;
long double S;
cin >> N >> S;
vector<vector<int64_t>> tree(N + 1, vector<int64_t>());
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
tree[a].push_back(b);
tree[b].push_back(a);
}
for (auto &x : tree) {
if (x.size() == 1) {
++count;
}
}
cout << fixed << 2 * S / count;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_M = 106;
int pos[MAX_M];
int add[MAX_M];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int b, d;
while (cin >> b >> d) {
string a, c;
cin >> a >> c;
for (int i = 0; c.size() > i; i++) {
pos[i] = 0;
add[i] = 0;
int p = 0;
int q = i;
while (p < a.size()) {
if (a[p] == c[q]) {
q++;
if (q == c.size()) {
add[i]++;
q = 0;
}
}
p++;
}
pos[i] = q;
}
long long cnt = 0;
int q = 0;
for (int i = 0; b > i; i++) {
cnt += add[q];
q = pos[q];
}
cout << cnt / d << endl;
}
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, j, i;
int a[1000];
char b[1000];
j = 97;
for (i = 1; i <= 26; i++, j++) {
a[i] = j;
}
scanf("%d", &n);
char o;
o = getchar();
for (i = 0; i < n; i++) {
scanf("%c", &b[i]);
if (b[i] < 97) b[i] += 32;
a[b[i] - 96] = 0;
}
for (i = 1; i <= 26; i++) {
if (a[i] != 0) {
printf("NO");
exit(0);
}
}
printf("YES");
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
const int maxn = 1000100;
int f[maxn], g[maxn], a[maxn], b[maxn];
int main() {
int n, m, c, ans = 0;
scanf("%d%d", &n, &m);
int up = n - 2 < m - 1 ? n - 2 : m - 1;
for (int i = (0); i <= (maxn - 1); ++i) {
f[i] = i == 0 ? 1 : (long long)f[i - 1] * i % MOD;
g[i] = i <= 1 ? 1 : (long long)g[MOD % i] * (MOD - MOD / i) % MOD;
a[i] = i == 0 ? 1 : (long long)a[i - 1] * m % MOD;
b[i] = i == 0 ? 1 : (long long)b[i - 1] * n % MOD;
}
for (int i = (1); i <= (maxn - 1); ++i)
g[i] = (long long)g[i - 1] * g[i] % MOD;
for (int i = (0); i <= (up); ++i) {
c = (long long)f[n - 2] * g[n - 2 - i] % MOD;
c = (long long)c * f[m - 1] % MOD;
c = (long long)c * g[i] % MOD;
c = (long long)c * g[m - 1 - i] % MOD;
c = (long long)c * a[n - 2 - i] % MOD;
c = (long long)c * (i + 2) % MOD;
c = (long long)c * b[n - 2 - i] % MOD;
c = (long long)c * f[n - 1] % MOD;
c = (long long)c * g[n] % MOD;
ans = (ans + c) % MOD;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> duyet(int l, int r) {
vector<int> ans1, ans2, ans;
ans1.clear();
ans2.clear();
ans.clear();
if (k == 0 || r - l == 1) {
for (int i = l; i < r; i++) ans.push_back(i);
return ans;
}
int mid = (l + r + 1) / 2;
if (k >= 2) {
k -= 2;
ans1 = duyet(l, mid);
ans2 = duyet(mid, r);
for (int i = 0; i < ans2.size(); i++) ans.push_back(ans2[i]);
for (int i = 0; i < ans1.size(); i++) ans.push_back(ans1[i]);
return ans;
}
}
void solve() {
cin >> n >> k;
k--;
vector<int> q = duyet(0, n);
if (k != 0)
cout << -1;
else {
for (int i = 0; i < q.size(); i++) cout << q[i] + 1 << " ";
}
}
int main() { solve(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i = 1, j = n - 1, ans1 = 1, ans2 = n - 1;
while (i < j) {
int c = 0;
for (int k = 2; k <= i; k++) {
if (i % k == 0 && j % k == 0) {
c++;
}
}
if (c == 0) {
ans1 = i;
ans2 = j;
}
i++;
j--;
}
cout << ans1 << " " << ans2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, sum[2][1005], num[1005], mn, mx;
char grid[2005][2005];
void print() {
for (int i = mx - 1; i >= 0; i--) {
for (int j = 0; j < sum[0][n]; j++) printf("%c", grid[i][j]);
printf("\n");
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
for (int i = 1; i <= n; i++) {
sum[0][i] = sum[0][i - 1] + num[i];
sum[1][i] = sum[1][i - 1] + num[i] * (i % 2 == 1 ? 1 : -1);
mn = min(mn, sum[1][i]);
}
for (int i = 0; i <= n; i++) sum[1][i] -= mn, mx = max(mx, sum[1][i]);
for (int i = 0; i < mx; i++)
for (int j = 0; j < sum[0][n]; j++) grid[i][j] = ' ';
int cur = sum[1][0];
for (int i = 1; i <= n; i++) {
int dir = sum[1][i - 1] < sum[1][i] ? 1 : -1;
for (int j = sum[0][i - 1]; j < sum[0][i]; j++) {
grid[cur][j] = dir == 1 ? '/' : '\\';
cur += dir;
}
cur -= dir;
}
for (int i = mx - 1; i >= 0; i--) {
for (int j = 0; j < sum[0][n]; j++) printf("%c", grid[i][j]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, t;
scanf("%d %d", &n, &t);
int ara[n - 1];
for (int i = 0; i < n - 1; i++) {
scanf("%d", &ara[i]);
}
int i = 0;
while (i < n - 1) {
i = i + ara[i];
if (i == t - 1) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 2e5 + 1;
int ct[kN], bit[kN];
int n;
void Update(int x) {
++x;
while (x <= n) {
bit[x]++;
x += x & -x;
}
}
int Query(int x) {
int c = 0;
while (x) {
c += bit[x];
x -= x & -x;
}
return c;
}
void ReadProcess() {
int x;
for (int i = 0; i < n; ++i) {
cin >> x;
ct[i] += x - Query(x);
Update(x);
}
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin >> n;
ReadProcess();
memset(bit, 0, sizeof bit);
ReadProcess();
for (int i = n - 1; i >= 0; --i) {
if (ct[i] >= (n - i)) {
ct[i] %= (n - i);
if (i > 0) {
ct[i - 1]++;
}
}
}
memset(bit, 0, sizeof bit);
for (int i = 0; i < n; ++i) {
int si = 0, ei = n;
while (si + 1 < ei) {
int mi = (si + ei) >> 1;
int diff = mi - Query(mi);
if (diff <= ct[i]) {
si = mi;
} else {
ei = mi;
}
}
cout << si << " ";
Update(si);
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int a[N][N];
int r[N], c[N];
int fr[N], fc[N];
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
r[i] += a[i][j];
c[j] += a[i][j];
}
int change = 1;
while (change) {
change = 0;
for (int i = 1; i <= n; i++)
if (r[i] < 0) {
for (int j = 1; j <= m; j++) {
c[j] -= a[i][j] * 2;
a[i][j] = -a[i][j];
}
r[i] = -r[i];
fr[i] ^= 1;
change = 1;
}
for (int i = 1; i <= m; i++)
if (c[i] < 0) {
for (int j = 1; j <= n; j++) {
r[j] -= a[j][i] * 2;
a[j][i] = -a[j][i];
}
c[i] = -c[i];
fc[i] ^= 1;
change = 1;
}
}
int frn = 0, fcn = 0;
for (int i = 1; i <= n; i++) frn += fr[i];
for (int i = 1; i <= m; i++) fcn += fc[i];
printf("%d", frn);
for (int i = 1; i <= n; i++)
if (fr[i]) printf(" %d", i);
puts("");
printf("%d", fcn);
for (int i = 1; i <= m; i++)
if (fc[i]) printf(" %d", i);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a, b, c, d;
cin >> n;
cout << "YES" << endl;
while (n--) {
cin >> a >> b >> c >> d;
int ans = abs(a) % 2;
int bns = abs(b) % 2;
cout << 1 + 2 * ans + bns << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t > 0) {
int n, x, y, d;
cin >> n >> x >> y >> d;
if (x == y || (abs(y - x)) % d == 0) {
cout << abs(y - x) / d << endl;
} else if (y == 1 || (y - 1) % d == 0) {
int temp = (x - 1) / d + 1 + (y - 1) / d;
if (y == n || (n - y) % d == 0) {
if (temp > (n - x) / d + 1 + (n - y) / d) {
temp = (n - x) / d + 1 + (n - y) / d;
}
}
cout << temp << endl;
} else if (y == n || (n - y) % d == 0) {
int temp = (n - x) / d + 1 + (n - y) / d;
if (y == 1 || (y - 1) % d == 0) {
if (temp > (x - 1) / d + 1 + (y - 1) / d) {
temp = (x - 1) / d + 1 + (y - 1) / d;
}
}
cout << temp << endl;
} else {
cout << "-1" << endl;
}
t--;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100003, K = 13;
const int MOD = 1e9 + 7;
int f[N][K][3], w[K][3], s[N];
int n, m, mk, x;
unsigned long long res;
vector<int> g[N];
void dfs(int u, int fa) {
s[u] = 1;
f[u][0][0] = mk - 1;
f[u][1][1] = 1;
f[u][0][2] = m - mk;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa) continue;
dfs(v, u);
memset(w, 0, sizeof w);
for (int j = 0; j <= s[u] && j <= x; j++)
for (int k = 0; k <= s[v] && j + k <= x; k++)
w[j + k][0] = (w[j + k][0] + (unsigned long long)f[u][j][0] *
((unsigned long long)f[v][k][0] +
f[v][k][1] + f[v][k][2])) %
MOD,
w[j + k][1] =
(w[j + k][1] + (unsigned long long)f[u][j][1] * f[v][k][0]) %
MOD,
w[j + k][2] = (w[j + k][2] + (unsigned long long)f[u][j][2] *
((unsigned long long)f[v][k][0] +
f[v][k][2])) %
MOD;
s[u] = min(s[u] + s[v], x);
for (int j = 0; j <= s[u]; j++)
for (int k = 0; k < 3; k++) f[u][j][k] = w[j][k];
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
scanf("%d%d", &mk, &x);
dfs(1, 0);
for (int i = 0; i <= s[1]; i++)
for (int j = 0; j < 3; j++)
res = (res + (unsigned long long)f[1][i][j]) % MOD;
printf("%d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
void solve(long long x) {
if (x > (long long)(1e9)) return;
v.push_back(x * 10 + 7);
v.push_back(x * 10 + 4);
solve(x * 10 + 4);
solve(x * 10 + 7);
}
int main() {
long long n, res = 0, i = 1;
cin >> n;
while (n) {
if (n % 10 == 4)
res += i;
else
res += (i * 2);
n /= 10;
i *= 2;
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void file(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
template <typename Tp>
void read(Tp &x) {
int fh = 1;
char c = getchar();
x = 0;
while (c > '9' || c < '0') {
if (c == '-') {
fh = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
x *= fh;
}
vector<int> G[1000005], nG[1000005];
int n, m;
int ff[1000005];
int fid(int x) { return ff[x] == x ? ff[x] : ff[x] = fid(ff[x]); }
int cycdep[1000005], ffa[1000005], nm;
void dfs0(int x, int pa) {
ffa[x] = pa;
for (auto y : G[x]) {
if (y == pa) continue;
if (ffa[y]) {
cycdep[x] = 1;
for (int yy = ffa[x], nm = 2; yy != x; yy = ffa[yy], ++nm)
cycdep[yy] = nm;
return;
} else
dfs0(y, x);
}
}
long double ans;
void dfs(int x, int pa, int dep, int flg1, int flg2) {
if (x == n + 1) {
for (auto y : nG[x]) {
if (y == pa) continue;
dfs(y, x, dep, pa, y);
}
return;
}
for (auto y : nG[x]) {
if (y == pa) continue;
dfs(y, x, dep + 1, flg1, flg2);
}
if (flg1) {
int a = cycdep[flg1], b = cycdep[flg2];
int aa = abs(a - b), bb = nm - aa;
--aa, --bb;
ans += 1.0 / (dep + aa);
ans += 1.0 / (dep + bb);
ans -= 1.0 / (dep + aa + bb);
} else {
ans += 1.0 / dep;
}
}
signed main() {
int RT, X;
read(n);
for (int i = 1; i <= n; ++i) ff[i] = i;
for (int i = 1, u, v; i <= n; ++i) {
read(u);
read(v);
++u;
++v;
G[u].push_back(v);
G[v].push_back(u);
if (fid(u) == fid(v)) {
RT = u;
X = v;
} else {
ff[fid(u)] = fid(v);
}
}
dfs0(RT, X);
for (int i = 1; i <= n; ++i) {
for (auto y : G[i]) {
if (cycdep[i] && cycdep[y]) continue;
nG[i].push_back(y);
}
}
for (int i = 1; i <= n; ++i) {
if (cycdep[i]) {
nG[n + 1].push_back(i);
nG[i].push_back(n + 1);
++nm;
}
}
for (int i = 1; i <= n; ++i) {
dfs(i, 0, 1, 0, 0);
}
cout << fixed << setprecision(15) << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
int l[1005], r[1005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d %d", &l[i], &r[i]);
int curr = l[1];
printf("%d ", curr);
curr++;
for (int i = 2; i <= n; i++) {
if (curr > r[i])
printf("0 ");
else {
curr = max(curr, l[i]);
printf("%d ", curr);
curr++;
}
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
bool flag = false;
for (int i = 0; i < n - 2; i++) {
if (a[i] + a[i + 1] > a[i + 2] && a[i] + a[i + 2] > a[i + 1] &&
a[i + 2] + a[i + 1] > a[i]) {
flag = true;
break;
}
}
cout << (flag ? "YES" : "NO");
}
| 1 |
#include <bits/stdc++.h>
const int inf = (int)1e9;
const int mod = 1e9 + 7;
using namespace std;
int n;
int k;
int a[500011];
bool check1(int v) {
long long sum = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= v) {
cnt += a[i] - v;
} else
sum += v - a[i];
}
if (sum <= k && sum <= cnt) {
return 1;
}
return 0;
}
bool check2(int v) {
long long sum = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
if (a[i] <= v) {
cnt += v - a[i];
} else
sum += a[i] - v;
}
if (sum <= k && sum <= cnt) {
return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int mn = 0;
int l = 0, r = inf;
while (r >= l) {
int mid = (l + r) / 2;
if (check1(mid)) {
mn = max(mn, mid);
l = mid + 1;
} else
r = mid - 1;
}
l = 0;
r = inf;
int mx = inf;
while (r >= l) {
int mid = (l + r) / 2;
if (check2(mid)) {
mx = min(mx, mid);
r = mid - 1;
} else
l = mid + 1;
}
cout << mx - mn;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, k;
int main() {
cin >> k >> a >> b;
long long x, y;
if (a > 0 && b > 0) {
cout << (b / k) - ((a - 1) / k);
return 0;
}
if (a <= 0 && b >= 0) {
cout << (b / k) + 1 + (abs(a) / k);
return 0;
}
cout << (abs(a) / k) - ((abs(b) - 1) / k);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, min = 10000000, sum = 0, val;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < arr[i]; j++) {
cin >> val;
sum += val;
}
sum = (sum * 5) + (arr[i] * 15);
if (sum < min) {
min = sum;
}
sum = 0;
}
cout << min;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& num) {
char CH;
bool F = false;
for (CH = getchar(); CH < '0' || CH > '9'; F = CH == '-', CH = getchar())
;
for (num = 0; CH >= '0' && CH <= '9';
num = num * 10 + CH - '0', CH = getchar())
;
F && (num = -num);
}
int stk[70], tp;
template <class T>
inline void print(T p) {
if (!p) {
puts("0");
return;
}
while (p) stk[++tp] = p % 10, p /= 10;
while (tp) putchar(stk[tp--] + '0');
putchar('\n');
}
const double PI = acos(-1.0);
const long long inf = 1e18;
const int N = 2e5 + 10;
const int maxn = 1005;
const double eps = 1e-10;
int n, a[1010];
int main() {
read(n);
int sum = 0;
for (int i = 1; i <= n; i++) {
read(a[i]);
sum += a[i];
}
if (n == 1) {
if (a[1] == 1)
cout << "YES";
else
cout << "NO";
} else {
if (sum == n - 1)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void par(int a[], int n) {
for (long long int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
void pv(vector<long long int> a) {
for (long long int i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
}
long long int ceiling(long long int n, long long int m) {
if (n % m == 0)
return n / m;
else
return n / m + 1;
}
long long int mod = 1e9 + 7;
long long int MOD = mod;
long long int fact(long long int n);
long long int nCr(long long int n, long long int r) {
return fact(n) / (fact(r) * fact(n - r));
}
bool isprime(long long int n) {
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
long long int fact(long long int n) {
int res = 1;
for (int i = 2; i <= n; i++) res = res * i;
return res;
}
bool seive(long long int n) {
long long int prime[n + 1];
memset(prime, 1, sizeof(prime));
for (int i = 2; i * i <= n; i++) {
if (prime[i] == 1) {
for (int j = i * i; j <= n; j++) {
prime[i] = 0;
}
}
}
return prime[n];
}
void re() {
long long int n, q;
cin >> n >> q;
vector<vector<long long int>> a(3, vector<long long int>(n + 2, 0));
long long int d = 0;
while (q--) {
long long int x, y;
cin >> x >> y;
a[x][y] = 1 - a[x][y];
long long int h = (x == 1 ? 2 : 1);
for (long long int j = y - 1; j < y + 2; j++) {
if (a[x][y] && a[h][j]) {
d++;
} else if (a[x][y] == 0 && a[h][j]) {
d--;
}
}
if (d == 0 && a[2][n] == 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
;
re();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long modx(long long Base, long long exponent) {
long long ans = 1;
if (Base == 1) return Base;
while (exponent) {
if (exponent & 1) ans = (ans * Base) % 1000000007LL;
Base = (Base * Base) % 1000000007LL;
exponent = exponent >> 1;
}
return ans;
}
long long inmodx(long long num) { return (modx(num, 1000000007LL - 2LL)); }
bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.first / 900 < b.first.first / 900) return 1;
if (a.first.first / 900 > b.first.first / 900) return 0;
if (a.first.second <= b.first.second) return 1;
return 0;
}
const int N = (5e3) + 9;
const int M = (N << 2) + 9;
const int LOGN = ((int)log2(N)) + 3;
const int LOGM = ((int)log2(M)) + 3;
const int BUCK = 450;
string s;
int a[N], b[N];
int calc(int x[], int l, int r) {
if (l > r) return 0;
return (x[r] - x[l - 1]);
}
void solve() {
int n, i, j, ans = 0, val;
cin >> s;
n = s.length();
for (i = (0); i < (n); i++) {
a[i + 1] = a[i];
b[i + 1] = b[i];
if (s[i] == 'a')
a[i + 1]++;
else
b[i + 1]++;
}
ans = max(a[n], b[n]);
for (i = (1); i < (n + 1); i++)
for (j = (i); j < (n + 1); j++) {
val = calc(a, 1, i - 1) + calc(b, i, j) + calc(a, j + 1, n);
ans = max(ans, val);
}
cout << ans << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1, cs;
cout << fixed << setprecision(9);
for (cs = (1); cs < (t + 1); cs++) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int MIN(int a, int b) { return a < b ? a : b; };
int MAX(int a, int b) { return a > b ? a : b; };
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int n, m, q;
int flag[110];
int main() {
int i, j, k;
int m, t, cnt, d;
char str[110];
while (~scanf("%d%d", &n, &d)) {
getchar();
for (i = 0; i < d; i++) {
scanf("%s", str);
for (j = 0; str[j] != NULL; j++) {
if (str[j] == '0') break;
}
if (str[j] == NULL)
flag[i] = 1;
else
flag[i] = 0;
}
m = 0;
for (i = 0, cnt = 0; i < d; i++) {
if (!flag[i]) {
cnt++;
} else if (cnt > m) {
m = cnt;
cnt = 0;
} else
cnt = 0;
}
if (cnt > m) m = cnt;
printf("%d\n", m);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
typedef long double ld;
#define int long long
#define gcd __gcd
#define endl "\n"
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define mod2 998244353
#define maxe *max_element
#define mine *min_element
#define inf 1e18
#define pb push_back
#define all(x) x.begin(), x.end()
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define ins insert
#define sz(x) (int)(x).size()
#define mk make_pair
#define deci(x, y) fixed<<setprecision(y)<<x
#define w(t) int t; cin>>t; while(t--)
#define nitin ios_base::sync_with_stdio(false); cin.tie(nullptr)
#define PI 3.141592653589793238
#define mem0(x) memset(x,0,sizeof x)
#define mem1(x) memset(x,-1,sizeof x)
using namespace std;
template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.f << ", " << p.second << ')'; }
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> ostream& operator<<(ostream &os, const T_container &v) { os << '{'; string sep; for (const T &x : v) os << sep << x, sep = ", "; return os << '}'; }
void dbg_out() { cerr << endl; }
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }
#ifdef NITIN
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...)
#endif
int good(int m,int n,int *a,int len){
int p[n];
mem0(p);
for(int i=0;i<n;i++){
if(a[i]<m){
p[i]=-1;
}else{
p[i]=1;
}
}
for(int i=1;i<n;i++)
p[i]+=p[i-1];
int tot=0;
for(int i=len-1;i<n;i++){
if(i>=len){
tot=min(tot,p[i-len]);
}
if(p[i]-tot>0)
return true;
}
return false;
}
void solve() {
int n,k;
cin>>n>>k;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
int l=1;
int r=n+1;
while(l+1<r){
int m=(l+r)/2;
if(good(m,n,a,k)){
l=m;
}else{
r=m;
}
}
cout<<l<<endl;
}
int32_t main() {
nitin;
solve();
} | 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.