solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
int main() {
int e, n, i, arr[100000], min = 1000000000;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
if (arr[i] < min) min = arr[i];
}
for (i = 0; i < n; i++)
if (arr[i] % min != 0) {
printf("-1\n");
return 0;
}
printf("%d", min);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long h, q, a, l1, r1, x, f[51], M, lm, rm, s, lh, rh, mm;
pair<long long, long long> t, k[100010], t1;
vector<pair<long long, long long> > w, la;
int main() {
cin >> h >> q;
f[0] = 1;
for (long long i = 1; i <= h; i++) {
f[i] = f[i - 1] * 2;
}
M = f[h] + 1;
lm = f[h - 1];
rm = f[h] - 1;
s = 0;
for (long long i = 1; i <= q; i++) {
cin >> a >> l1 >> r1 >> x;
long long ll, rr;
ll = l1 * f[h - a];
rr = ll + (r1 - l1 + 1) * f[h - a] - 1;
if ((ll > rm || rr < lm) && x == 1) {
cout << "Game cheated!";
return 0;
}
if (x == 1) {
lm = max(ll, lm);
rm = min(rm, rr);
}
if (x == 0) {
s++;
k[s] = make_pair(ll, rr);
}
}
lh = lm;
rh = rm;
for (long long i = 1; i <= s; i++) {
w.push_back(make_pair(k[i].first, -1 * i));
w.push_back(make_pair(k[i].second, i));
if (k[i].first < lm && k[i].second > rm) {
cout << "Game cheated!";
return 0;
}
}
long long cd = lm, cc = rm, s1 = 0, s2 = 0, e = -1;
mm = 0;
if (!w.empty()) {
sort(w.begin(), w.end());
la.push_back(make_pair(lm - 1, 1));
la.push_back(make_pair(rm + 1, -1));
for (long long i = 0; i <= w.size() - 1; i++) {
if (w[i].second < 0) {
e = k[-1 * w[i].second].second;
if (w[i].first >= lm && w[i].first <= rm)
la.push_back(make_pair(w[i].first, -1));
while (true) {
if (w[i].first == e && w[i].second > 0) break;
i++;
if (w[i].second < 0) {
long long kx = k[-1 * w[i].second].second;
if (kx <= rm) e = max(e, kx);
}
}
if (e >= lm && e <= rm) la.push_back(make_pair(e, 1));
}
}
sort(la.begin(), la.end());
for (long long i = 1; i < la.size(); i++) {
if (la[i].second == -1 && la[i - 1].second == 1) {
if (la[i].first - 1 >= la[i - 1].first + 1) {
cd = la[i - 1].first + 1;
cc = la[i].first - 1;
mm += cc - cd + 1;
}
}
}
} else {
mm += cc - cd + 1;
}
if (mm == 0)
cout << "Game cheated!";
else if (mm > 1)
cout << "Data not sufficient!";
else
cout << cd;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(time(nullptr));
const long long INF = 1e18;
long long n, x, y;
vector<pair<long long, long long> > pref, suff;
bool check(long long l, long long r) {
long long x1 = (l == 0 ? 0 : pref[l - 1].first) +
(r == n - 1 ? 0 : suff[r + 1].first),
y1 = (l == 0 ? 0 : pref[l - 1].second) +
(r == n - 1 ? 0 : suff[r + 1].second);
long long a = abs(x - x1) + abs(y - y1);
if (a > r - l + 1) return false;
return ((r - l + 1 - a) % 2 == 0);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> n >> s >> x >> y;
pref.resize(n);
suff.resize(n);
map<char, pair<long long, long long> > m;
m['R'] = {1, 0};
m['L'] = {-1, 0};
m['U'] = {0, 1};
m['D'] = {0, -1};
for (long long i = 0; i < n; i++) {
pref[i] = {m[s[i]].first + (i != 0 ? pref[i - 1].first : 0),
m[s[i]].second + (i != 0 ? pref[i - 1].second : 0)};
}
for (long long i = n - 1; i > -1; i--) {
suff[i] = {m[s[i]].first + (i != n - 1 ? suff[i + 1].first : 0),
m[s[i]].second + (i != n - 1 ? suff[i + 1].second : 0)};
}
long long ans = INF;
if (pref[n - 1].first == x && pref[n - 1].second == y) {
cout << 0;
return 0;
}
for (long long i = 0; i < n; i++) {
long long l = i - 1, r = n - 1;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (check(i, mid))
r = mid;
else
l = mid;
}
if (check(i, r)) ans = min(ans, r - i + 1);
}
if (ans == INF)
cout << -1;
else
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int inf = 1e9;
const int maxn = 1e5 + 20;
int mn[2][maxn * 4 + 10];
void ADD(int s, int e, int v, int l, int r, int val, int det) {
if (l <= s && e <= r) {
mn[det][v] = min(mn[det][v], val + ((det)*2 - 1) * (s - l));
return;
}
if (l >= e || s >= r) {
return;
}
int mid = (s + e) / 2;
ADD(s, mid, 2 * v, l, r, val, det);
ADD(mid, e, 2 * v + 1, l, r, val, det);
}
int gt(int s, int e, int v, int pos) {
int ans = min(mn[0][v] - pos + s, mn[1][v] + pos - s);
while (e - s > 1) {
int mid = (s + e) / 2;
if (pos < mid) {
v *= 2;
e = mid;
} else {
v *= 2;
v++;
s = mid;
}
ans = min(min(mn[0][v] - pos + s, mn[1][v] + pos - s), ans);
}
return ans;
}
int A[maxn];
int B[maxn];
int pos[maxn];
int main() {
int n;
cin >> n;
fill(mn[0], mn[0] + maxn * 4 + 10, inf);
fill(mn[1], mn[1] + maxn * 4 + 10, inf);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
pos[B[i]] = i;
}
cout << endl;
cout << "\n";
for (int i = 0; i < n; i++) {
if (pos[A[i]] >= i) {
ADD(0, maxn, 1, 0, pos[A[i]] - i + 1, pos[A[i]] - i, 0);
ADD(0, maxn, 1, pos[A[i]] - i + 1, pos[A[i]] + 1, 1, 1);
ADD(0, maxn, 1, pos[A[i]] + 1, n, n - i - 1, 0);
} else {
ADD(0, maxn, 1, 0, pos[A[i]] + 1, i - pos[A[i]], 1);
ADD(0, maxn, 1, pos[A[i]] + 1, pos[A[i]] + n - i + 1, n - i - 1, 0);
ADD(0, maxn, 1, n - i + pos[A[i]] + 1, n, 1, 1);
}
}
for (int i = 0; i < n; i++) {
int tmp = gt(0, maxn, 1, i);
cout << tmp << "\n";
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long p, q;
long long ans;
bool primes[3000002];
long long ps[3000002];
long long pal = 0;
int pals(int i) {
int ans = 0;
int num = i;
int rev = 0;
while (num > 0) {
int dig = num % 10;
rev = rev * 10 + dig;
num = num / 10;
}
if (i == rev) ans++;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> p >> q;
memset(primes, 1, sizeof(primes));
primes[0] = primes[1] = 0;
for (int i = 2; i <= 3000001; i++) {
if (!primes[i]) continue;
for (int j = i + i; j <= 3000001; j += i) primes[j] = 0;
}
for (int i = 2; i <= 3000001; i++) ps[i] += ps[i - 1] + primes[i];
for (int i = 1; i <= 3000001; i++) {
if (i < 10)
pal++;
else
pal += pals(i);
if (q * ps[i] <= p * pal) ans = i;
}
if (ans)
cout << ans;
else
cout << "Palindromic tree is better than splay tree";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void ActivateFastIO() {
ios::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
}
using ll = long long;
const int N = 100005;
int n;
int a[N];
int dp[N][320];
int solve(int ndx, int k) {
if (ndx > n) {
return 0;
}
int &ret = dp[ndx][k];
if (ret) {
return ret;
}
return ret = solve(ndx + a[ndx] + k, k) + 1;
}
int main() {
ActivateFastIO();
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int q;
cin >> q;
int s_n = sqrt(n);
while (q--) {
int p, k;
cin >> p >> k;
int ans;
if (p > n) {
ans = 0;
} else if (k < s_n) {
ans = solve(p, k);
} else {
ans = 0;
while (p <= n) {
p = p + k + a[p];
++ans;
}
}
cout << ans << '\n';
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long f(long long r, long long c) {
return (n / (r + 1LL)) * (m / (c + 1LL));
}
signed main() {
ios::sync_with_stdio(0);
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
if (k > n + m - 2) {
cout << -1 << '\n';
return 0;
}
if (n > m) swap(n, m);
long long ans = 0;
if (k <= n - 1) {
ans = max(ans, f(0, k));
ans = max(ans, f(k, 0));
} else if (n <= (k + 1) and (k + 1) <= m) {
ans = f(0, k);
} else {
ans = f(k - (m - 1), m - 1);
}
cout << ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void rd(T &x) {
x = 0;
int f = 1;
char c;
while (!isdigit(c = getchar()))
if (c == '-') f = -1;
do {
x = (x << 3) + (x << 1) + (c ^ 48);
} while (isdigit(c = getchar()));
x *= f;
}
const int N = 1e5 + 5, mod = 998244323;
const long long INF = 0x3f3f3f3f3f3f3f3f;
struct node {
int to, val, id;
};
vector<node> G[2][N];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Que;
int n, m, s, l;
long long dis[2][N], cnt[2][N], ans1[N], ans2[N], cost;
void dijkstra(int s, int f) {
while (!Que.empty()) Que.pop();
for (int i = 1; i <= n; i++) dis[f][i] = INF;
dis[f][s] = 0;
cnt[f][s] = 1;
Que.push({0, s});
while (!Que.empty()) {
auto p = Que.top();
Que.pop();
long long u = p.second;
if (dis[f][u] ^ p.first) continue;
for (auto it : G[f][u]) {
if (dis[f][it.to] > dis[f][u] + it.val) {
dis[f][it.to] = dis[f][u] + it.val;
cnt[f][it.to] = cnt[f][u];
Que.push({dis[f][it.to], it.to});
} else if (dis[f][it.to] == dis[f][u] + it.val)
cnt[f][it.to] = (cnt[f][it.to] + cnt[f][u]) % mod;
}
}
}
int main() {
rd(n), rd(m), rd(s), rd(l);
for (int i = 1, a, b, c; i <= m; i++)
rd(a), rd(b), rd(c), G[0][a].push_back({b, c, i}),
G[1][b].push_back({a, c, i});
dijkstra(s, 0);
dijkstra(l, 1);
for (int u = 1; u <= n; u++)
for (auto it : G[0][u]) {
if (dis[0][u] + dis[1][it.to] + it.val == dis[0][l])
if (cnt[0][u] * cnt[1][it.to] % mod == cnt[0][l]) {
ans1[it.id] = 1;
continue;
}
cost = dis[0][u] + dis[1][it.to] + it.val - dis[0][l] + 1;
if (it.val - cost > 0)
ans1[it.id] = 0, ans2[it.id] = cost;
else
ans1[it.id] = -1;
}
for (int i = 1; i <= m; i++)
if (ans1[i] == 1)
puts("YES");
else if (ans1[i] == -1)
puts("NO");
else
printf("CAN %lld\n", ans2[i]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) {
if (b > a) {
swap(a, b);
}
if (b == 0) {
return a;
}
return GCD(b, a % b);
}
long long mul_mod(long long a, long long b, long long m) {
a %= m;
b %= m;
return ((((a * b) % m) + m) % m);
}
long long power(long long base, long long n, long long m) {
long long res = 1;
while (n) {
if (n & 1) res = mul_mod(res, base, m);
base = mul_mod(base, base, m);
n = n >> 1;
}
return res;
}
long long ncr(long long x, long long y) {
long long ans = 1;
y = (y > x - y ? x - y : y);
for (long long i = 0; i < y; i++) {
ans = (ans * (x - i)) % 1000000007;
ans = (ans * power(i + 1, 1000000007 - 2, 1000000007)) % 1000000007;
ans = ans % 1000000007;
}
return ans;
}
bool isPrime(long long n) {
if (n == 1 or n == 0) return false;
if (n == 2 or n == 3) return true;
if (n % 2 == 0 or n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i += 6) {
if (n % i == 0 or n % (i + 2) == 0) return false;
}
return true;
}
long long add_mod(long long a, long long b, long long m) {
a % m;
b % m;
return ((((a + b) % m) + m) % m);
}
long long sub_mod(long long a, long long b, long long m) {
a % m;
b % m;
return ((((a - b) % m) + m) % m);
}
vector<long long> prmFactors(long long n) {
vector<long long> res;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
res.push_back(i);
}
}
if (n > 1) res.push_back(n);
return res;
}
void run() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
}
void solve() {
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
vector<long long> mn(513, 1e9);
vector<long long> ans;
ans.push_back(0);
mn[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 513; j++) {
if (mn[j] < a[i]) {
mn[j ^ a[i]] = min(mn[j ^ a[i]], a[i]);
}
}
}
for (int i = 1; i < 513; i++)
if (mn[i] != 1e9) ans.push_back(i);
cout << ans.size() << endl;
for (auto x : ans) cout << x << " ";
cout << endl;
}
int main() {
run();
int t = 1;
while (t--) {
solve();
}
return 0LL;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[35][35];
bool out(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m) return true;
return false;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
int ans = 0;
for (int i = 0; i < (n + m - 1) / 2; i++) {
int suma = i;
int sumb = (n + m - 2) - i;
int sum[2] = {0, 0};
for (int j = 0; j <= suma; j++) {
if (out(j, suma - j)) continue;
sum[a[j][suma - j]]++;
}
for (int j = 0; j <= sumb; j++) {
if (out(j, sumb - j)) continue;
sum[a[j][sumb - j]]++;
}
ans += min(sum[0], sum[1]);
}
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 20];
int cost[30][30], f[30][30], change[30][30];
int n, m;
char s[30][30];
inline void getCost() {
for (int k = 0; k < n; ++k) {
for (int i = 0; i < m; ++i) {
int sum = 0, tem = 0;
f[i][k] = 0x7fffffff;
for (int j = 0; j < n; ++j) {
if (s[j][i] == s[k][i]) {
change[i][k] |= 1 << j;
sum += cost[j][i];
tem = max(tem, cost[j][i]);
}
}
f[i][k] = min(f[i][k], sum - tem);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> cost[i][j];
getCost();
memset(dp, 0x3f, sizeof dp);
dp[0] = 0;
for (int st = 0; st < (1 << n); ++st) {
for (int i = 0; i < n; ++i) {
if ((st & 1 << i) == 0) {
for (int j = 0; j < m; ++j) {
dp[st | change[j][i]] = min(dp[st | change[j][i]], dp[st] + f[j][i]);
dp[st | 1 << i] = min(dp[st | 1 << i], dp[st] + cost[i][j]);
}
break;
}
}
}
cout << dp[(1 << n) - 1] << endl;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int N;
char c[3000][3000];
int color[3000][3000];
int row[3000];
int col[3000];
int main() {
scanf("%d", &N);
for (int Ni = 0; Ni < N; Ni++) scanf("%s", c[Ni]);
for (int Ni = 0; Ni < N; Ni++)
for (int Nj = 0; Nj < N; Nj++) color[Ni][Nj] = c[Ni][Nj] - '0';
int cnt = 0;
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (int i = N - 1; i >= 0; i--)
for (int j = 0; j < i; j++)
if ((row[i] + col[j]) % 2 != color[i][j]) {
cnt++;
row[i]++;
col[j]++;
}
int p[3000];
for (int Ni = 0; Ni < N; Ni++) p[Ni] = (row[Ni] + col[Ni]) % 2;
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (int i = 0; i < N; i++)
for (int j = N - 1; j > i; j--)
if ((row[i] + col[j]) % 2 != color[i][j]) {
cnt++;
row[i]++;
col[j]++;
}
for (int Ni = 0; Ni < N; Ni++) {
p[Ni] = (p[Ni] + row[Ni] + col[Ni]) % 2;
if (p[Ni] != color[Ni][Ni]) cnt++;
}
printf("%d", cnt);
puts("");
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct bola {
double x, v, m;
int id;
};
bola ba[101];
bool cmp(bola a, bola b) { return a.x < b.x; }
bool cmp2(bola a, bola b) { return a.id < b.id; }
int main() {
int n, t;
scanf("%d %d", &n, &t);
for (int i = 0; i < n; i++) {
scanf("%lf %lf %lf", &ba[i].x, &ba[i].v, &ba[i].m);
ba[i].id = i;
}
sort(ba, ba + n, cmp);
for (double eps = 0.0; eps <= t; eps += 1.0 / 262144.0) {
for (int i = 0; i < n; i++) {
ba[i].x = ba[i].x + ba[i].v * 1.0 / 262144.0;
}
for (int i = 0; i < n - 1; i++) {
if (ba[i + 1].x - ba[i].x < 0.000001) {
double d = 2.0 * ba[i].m * ba[i].v;
ba[i].v = ((ba[i].m - ba[i + 1].m) * ba[i].v +
2.0 * ba[i + 1].m * ba[i + 1].v) /
(ba[i].m + ba[i + 1].m);
ba[i + 1].v = ((ba[i + 1].m - ba[i].m) * ba[i + 1].v + d) /
(ba[i].m + ba[i + 1].m);
}
}
}
sort(ba, ba + n, cmp2);
for (int i = 0; i < n; i++) printf("%.6f\n", ba[i].x);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long int infinity = 9e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int total = 0, odd = 0, even = 0;
long long int k;
for (int i = 0; i < n; i++) {
cin >> k;
total += k / 2;
if (k & 1) {
if (i & 1)
odd++;
else
even++;
}
}
cout << (total + min(odd, even));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, n1, n2, x, i, j, k;
long long f[1000005], ans;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &x);
if (x == 1)
++n1;
else
++n2;
}
f[0] = f[1] = 1;
for (i = 2; i <= n1; ++i) f[i] = (f[i - 1] + (i - 1) * f[i - 2]) % 1000000007;
ans = f[n1];
for (i = 1; i <= n2; ++i) ans = ans * (n1 + i) % 1000000007;
printf("%I64d\n", ans);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 7;
vector<int> adj[N];
int p[N];
int dp[N];
int mark[N];
bool relax(vector<int> &v, int x) {
bitset<N> ok;
ok[0] = 1;
for (auto val : v) ok = (ok | (ok << val));
return ok[x];
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int a[2], b[2];
for (int i = 0; i < 2; i++) {
cin >> a[i] >> b[i];
a[i]--, b[i]--;
}
for (int i = 1; i < n; i++) {
cin >> p[i];
p[i]--;
adj[p[i]].push_back(i);
}
for (int i = n - 1; i >= 0; i--) {
dp[i] = adj[i].empty();
for (auto u : adj[i]) dp[i] += dp[u];
}
if (dp[0] & 1) {
cout << "NO\n";
return 0;
}
bool good = true;
for (int x = 0; x < 2; x++) {
vector<int> tmp;
{
int v = a[x];
while (v != 0) {
mark[v]++;
int u = p[v];
for (auto w : adj[u])
if (w != v && w != b[x]) tmp.push_back(dp[w]);
v = u;
}
}
{
int v = b[x];
while (v != 0) {
mark[v]++;
int u = p[v];
if (u != 0)
for (auto w : adj[u])
if (w != v && w != a[x]) tmp.push_back(dp[w]);
v = u;
}
}
if (!relax(tmp, (dp[0] - 2) / 2)) good = false;
}
if (good)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
int sz(const T& a);
template <typename T>
int unq(vector<T>& a);
template <typename T>
T powi(T x, int i);
template <typename T>
T sqr(const T& x);
template <typename T, typename U>
auto maxx(const T& t, const U& u) -> typename common_type<T, U>::type;
template <typename T, typename U>
auto minn(const T& t, const U& u) -> typename common_type<T, U>::type;
template <typename T, typename U>
bool smin(T& t, const U& u);
template <typename T, typename U>
bool smax(T& t, const U& u);
template <typename T, typename U, typename... V>
auto maxx(const T& t, const U& u, const V&... v) ->
typename common_type<T, U, V...>::type;
template <typename T, typename U, typename... V>
auto minn(const T& t, const U& u, const V&... v) ->
typename common_type<T, U, V...>::type;
template <typename T, typename U, typename... V>
bool smin(T& t, const U& u, const V&... v);
template <typename T, typename U, typename... V>
bool smax(T& t, const U& u, const V&... v);
template <typename T>
inline string to_string(const vector<T>& x);
template <typename T>
inline string to_string(const vector<T>& x, int i);
template <typename T>
inline string to_string(const vector<T>& x, int i, int j);
namespace InputReader {
const int N = 1 << 16;
char buffer[N];
char* iptr = buffer + N;
char* endptr = buffer + N;
bool hasMore = true;
int bytesRead;
inline bool reloadBuffer();
inline int gc();
inline bool read(char& x);
inline bool read(char* x);
inline bool read(string& x);
inline bool readln(char* x);
inline bool readln(string& x);
template <typename T>
inline bool readz(T& x);
inline bool read(int& x);
inline bool read(long long& x);
template <typename T>
inline bool read(vector<T>& a);
template <typename T>
inline bool reada(T* a, int n);
template <typename T, typename... U>
inline bool read(T& x, U&... y);
inline int ni();
inline long long nl();
inline string ns();
inline vector<int> nvi(int n);
inline vector<long long> nvl(int n);
} // namespace InputReader
using InputReader::ni;
using InputReader::nl;
using InputReader::ns;
using InputReader::nvi;
using InputReader::nvl;
using InputReader::read;
using InputReader::reada;
using InputReader::readln;
namespace OutputWriter {
const int N = 1 << 16;
char buffer[N];
char* iptr = buffer;
char* const endptr = buffer + N;
int bytesWritten = 0;
void flushBuffer();
void pc(const int& c);
inline bool print(const char& c);
inline bool print(const char* a);
inline bool print(char* a);
inline bool print(const string& s);
template <typename T>
inline bool printz(T x);
inline bool print(const int& x);
inline bool print(const long long& x);
inline bool print(const double& x);
template <typename T, typename... U>
inline bool print(const T& t, const U&... u);
inline bool println();
template <typename T>
inline bool println(const T& x);
template <typename T, typename... U>
inline bool println(const T& t, const U&... u);
} // namespace OutputWriter
using OutputWriter::print;
using OutputWriter::println;
bool solve(int testNumber);
void solve();
int localTestCases = 1, testCount = 1;
int MXITR = (int)1e7;
const int inf = (int)1e9 + 7;
const long long infl = (long long)4.6e18 + 7;
const int md = (int)1e9 + 7;
const bool multipleTestCases = 0;
bool solve(int testNumber) {
int s = 0;
for (int _ = 0, _$ = 5; _ < _$; ++_) s += ni();
OutputWriter::println(s == 0 ? -1 : s % 5 == 0 ? s / 5 : -1);
;
return 1;
}
void solve() {
if (false) InputReader::read(localTestCases);
for (int i = 0; i < localTestCases; ++i) {
if (multipleTestCases) InputReader::read(testCount);
for (int testNumber = 1; testNumber <= testCount; ++testNumber)
solve(testNumber);
}
OutputWriter::flushBuffer();
}
int main() {
if (false) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
} else {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
auto t1 = high_resolution_clock::now();
solve();
auto t2 = high_resolution_clock::now();
duration<double> t = t2 - t1;
if (false) printf("\n\nTime taken: %.5fs\n", t.count());
fclose(stdin);
fclose(stdout);
return 0;
}
template <typename T>
int sz(const T& a) {
return (int)a.size();
}
template <typename T>
int unq(vector<T>& a) {
int n = a.size();
int m = unique(a.begin(), a.end()) - a.begin();
a.resize(m);
return n - m;
}
template <typename T>
T powi(T x, int i) {
T r = 1;
while (i) {
if (i & 1) r *= x;
x *= x;
i /= 2;
}
return r;
}
template <typename T>
T sqr(const T& x) {
return x * x;
}
template <typename T, typename U>
auto maxx(const T& t, const U& u) -> typename common_type<T, U>::type {
return (t > u) ? t : u;
}
template <typename T, typename U>
auto minn(const T& t, const U& u) -> typename common_type<T, U>::type {
return (t < u) ? t : u;
}
template <typename T, typename U>
bool smin(T& t, const U& u) {
return (u < t) ? (t = u, true) : false;
}
template <typename T, typename U>
bool smax(T& t, const U& u) {
return (u > t) ? (t = u, true) : false;
}
template <typename T, typename U, typename... V>
auto maxx(const T& t, const U& u, const V&... v) ->
typename common_type<T, U, V...>::type {
return maxx(maxx(t, u), v...);
}
template <typename T, typename U, typename... V>
auto minn(const T& t, const U& u, const V&... v) ->
typename common_type<T, U, V...>::type {
return minn(minn(t, u), v...);
}
template <typename T, typename U, typename... V>
bool smin(T& t, const U& u, const V&... v) {
if (auto m = minn(u, v...); m < t) return (t = m, true);
return false;
}
template <typename T, typename U, typename... V>
bool smax(T& t, const U& u, const V&... v) {
if (auto m = maxx(u, v...); m > t) return (t = m, true);
return false;
}
template <typename T>
inline string to_string(const vector<T>& x) {
return to_string(x, 0, (int)x.size() - 1);
}
template <typename T>
inline string to_string(const vector<T>& x, int i) {
return to_string(x, i, (int)x.size() - 1);
}
template <typename T>
inline string to_string(const vector<T>& x, int i, int j) {
string s = to_string(x[i]);
for (int k = i + 1; k <= j; ++k) s += ' ' + to_string(x[k]);
return s;
}
inline bool InputReader::reloadBuffer() {
bytesRead = fread(buffer, sizeof(buffer[0]), N, stdin);
iptr = buffer;
endptr = buffer + bytesRead;
hasMore = (bytesRead != 0);
return hasMore;
}
inline int InputReader::gc() {
if (iptr == endptr)
if (!reloadBuffer()) return EOF;
return *iptr++;
}
inline bool InputReader::read(char& x) {
int c = gc();
while (isspace(c) and c != EOF) c = gc();
if (c == EOF) {
x = (char)0;
if (false) assert(false);
return false;
}
x = (char)c;
return true;
}
inline bool InputReader::read(char* a) {
int c = gc();
while (isspace(c) and c != EOF) c = gc();
if (c == EOF) {
*a = '\0';
if (false) assert(false);
return false;
}
while (!isspace(c) and c != EOF) {
*a++ = (char)c;
c = gc();
}
*a = '\0';
return true;
}
inline bool InputReader::read(string& s) {
static char t[(int)2e6 + 10];
if (!read(t)) return false;
s.assign(t);
return true;
}
inline bool InputReader::readln(char* a) {
int c = gc();
while (isspace(c) and c != EOF) c = gc();
if (c == EOF) {
*a = '\0';
if (false) assert(false);
return false;
}
while ((c != '\n' and c != '\r' and c != '\f') and c != EOF) {
*a++ = (char)c;
c = gc();
}
*a = '\0';
return true;
}
inline bool InputReader::readln(string& s) {
static char t[(int)2e6 + 10];
if (!readln(t)) return false;
s.assign(t);
return true;
}
template <typename T>
inline bool InputReader::readz(T& x) {
int c = gc();
bool negative = false;
x = 0;
while (isspace(c) and c != EOF and c != '-') c = gc();
if (c == '-') {
negative = true;
c = gc();
}
if (c == EOF) {
if (false) assert(false);
return false;
}
while (isdigit(c)) {
x = x * 10 + (c - '0');
c = gc();
}
if (negative) x = -x;
return true;
}
inline bool InputReader::read(int& x) { return readz<int>(x); }
inline bool InputReader::read(long long& x) { return readz<long long>(x); }
template <typename T, typename... U>
inline bool InputReader::read(T& x, U&... y) {
bool b1 = read(x);
bool b2 = read(y...);
return b1 and b2;
}
template <typename T>
inline bool InputReader::read(vector<T>& a) {
bool b = true;
for (auto& e : a) b &= read(e);
return b;
}
inline int InputReader::ni() {
int _;
read(_);
return _;
}
inline long long InputReader::nl() {
long long _;
read(_);
return _;
}
inline string InputReader::ns() {
string _;
read(_);
return _;
}
inline vector<int> InputReader::nvi(int n) {
vector<int> v(n);
for (int& e : v) read(e);
return v;
}
inline vector<long long> InputReader::nvl(int n) {
vector<long long> v(n);
for (long long& e : v) read(e);
return v;
}
inline void OutputWriter::flushBuffer() {
int r = fwrite(buffer, sizeof(buffer[0]), bytesWritten, stdout);
if (false) assert(r == bytesWritten);
iptr = buffer;
bytesWritten = 0;
}
inline void OutputWriter::pc(const int& c) {
*iptr = (char)c;
++bytesWritten;
if (++iptr == endptr) flushBuffer();
}
inline bool OutputWriter::print(const char& c) {
pc(c);
return true;
}
inline bool OutputWriter::print(char* a) {
while (*a != '\0') pc(*a++);
return true;
}
inline bool OutputWriter::print(const char* a) {
while (*a != '\0') pc(*a++);
return true;
}
inline bool OutputWriter::print(const string& s) {
for (const char& c : s) pc(c);
return true;
}
template <typename T>
inline bool OutputWriter::printz(T x) {
if (x < 0) {
pc('-');
x = -x;
}
static int t[64];
if (x == 0) {
pc('0');
return true;
}
int* ptr = t;
int* const startptr = t;
while (x > 0) {
*ptr++ = x % 10;
x /= 10;
}
do {
pc(*--ptr + '0');
} while (ptr != startptr);
return true;
}
inline bool OutputWriter::print(const int& x) { return printz<int>(x); }
inline bool OutputWriter::print(const long long& x) {
return printz<long long>(x);
}
inline bool OutputWriter::print(const double& x) {
static char a[64];
sprintf(a, "%.12f", x);
return print(a);
}
template <typename T, typename... U>
inline bool OutputWriter::print(const T& t, const U&... u) {
print(t);
print(' ');
return print(u...);
}
inline bool OutputWriter::println() {
pc('\n');
return true;
}
template <typename T>
inline bool OutputWriter::println(const T& x) {
print(x);
return println();
}
template <typename T, typename... U>
inline bool OutputWriter::println(const T& t, const U&... u) {
print(t);
print(' ');
return println(u...);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%I64d", &x);
return x;
}
int deg[N];
map<int, int> Map;
struct Info {
int v, l, r;
Info() {}
Info(int _v, int _l, int _r) {
v = _v;
l = _l;
r = _r;
}
} node[N];
void dfs(int par, int mn, int mx) {
if (node[par].v >= mn && node[par].v <= mx) {
Map[node[par].v] = 1;
}
if (node[par].l != -1) {
dfs(node[par].l, mn, min(node[par].v - 1, mx));
}
if (node[par].r != -1) {
dfs(node[par].r, max(mn, node[par].v + 1), mx);
}
}
int main() {
int n = in();
for (int i = 1; i <= n; i++) {
int v = in(), l = in(), r = in();
if (l != -1) {
deg[l]++;
}
if (r != -1) {
deg[r]++;
}
node[i] = Info(v, l, r);
}
int root = -1;
for (int i = 1; i <= n; i++) {
if (deg[i] == 0) {
root = i;
}
}
dfs(root, -2e9, 2e9);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (Map[node[i].v] == 0) {
ans++;
}
}
printf("%d\n", ans);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long ans = 0;
if (k >= n) {
ans += 1;
k = n - 1;
}
ans += (k * (k + 1)) / 2;
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long pow_mod(long long a, long long i) {
long long ans = 1;
while (i) {
if (i % 2 == 1) ans = ans * a % 1000000007;
a = a * a % 1000000007;
i >>= 1;
}
return ans;
}
long long getSum(long long a, long long n) {
return (pow_mod(a, n) - 1) * pow_mod(a - 1, 1000000007 - 2) % 1000000007;
}
int main(int argc, const char* argv[]) {
ios::sync_with_stdio(false);
long long A, B, n, x;
cin >> A >> B >> n >> x;
long long ans = 0;
if (A == 1) {
ans = (x + n % 1000000007 * B) % 1000000007;
} else {
ans = (pow_mod(A, n) * x % 1000000007 + getSum(A, n) * B % 1000000007) %
1000000007;
}
ans = (ans % 1000000007 + 1000000007) % 1000000007;
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int M = 4e5 + 5;
const int N = 8e5 + 10;
using namespace std;
inline long long read() {
long long sum = 0, b = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') b = -1;
c = getchar();
}
while (isdigit(c)) {
sum = sum * 10 + c - '0';
c = getchar();
}
return b * sum;
}
int t, n, m, k;
long long ans, a[M], vis[N + 1];
int main() {
int i, j;
n = read();
for (i = 1; i <= n; i++) {
long long x = read();
vis[x - i + M] += x;
}
for (i = 1; i <= N; i++) {
ans = max(ans, vis[i]);
}
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tcase;
cin >> tcase;
while (tcase--) {
long long n;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
long long ans = 1;
if (n == 2)
ans = arr[0] * arr[1];
else {
for (int i = 1; i < n; i++) {
ans = max(ans, arr[i] * arr[i - 1]);
}
}
cout << ans << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int check(string st) {
for (int i = 1; i < st.size(); i++) {
if (st[i] == st[i - 1]) return 1;
}
for (int i = 2; i < st.size(); i++) {
if (st[i] == st[i - 2]) return 1;
}
return 0;
}
int ypa(string &st) {
int i;
for (i = st.size() - 1; i > 0; i--) {
if (st[i] == st[i - 1]) {
st[i] += 1;
for (int j = i + 1; j <= st.size() - 1; j++) {
st[j] = 'a';
}
for (int j = i; j > 0; j--) {
if (st[j] - 'a' + 1 == m + 1) {
st[j] = 'a';
st[j - 1]++;
}
}
}
}
for (i = st.size() - 1; i > 1; i--) {
if (st[i] == st[i - 2]) {
st[i] += 1;
for (int j = i + 1; j <= st.size() - 1; j++) {
st[j] = 'a';
}
for (int j = i; j > 0; j--) {
if (st[j] - 'a' + 1 == m + 1) {
st[j] = 'a';
st[j - 1]++;
}
}
}
}
}
int main() {
cin >> n >> m;
string st;
cin >> st;
string stt;
stt = st;
st[n - 1]++;
for (int i = n - 1; i > 0; i--) {
if (st[i] - 'a' + 1 == m + 1) {
st[i] = 'a';
st[i - 1]++;
}
}
if (st[0] - 'a' + 1 >= m + 1) {
cout << "NO";
return 0;
}
while (check(st)) {
st[n - 1]++;
for (int i = n - 1; i > 0; i--) {
if (st[i] - 'a' + 1 == m + 1) {
st[i] = 'a';
st[i - 1]++;
}
}
for (int i = 1; i <= 100; i++) ypa(st);
if (st[0] - 'a' + 1 >= m + 1) {
cout << "NO";
return 0;
}
}
if (st[0] < stt[0])
cout << "NO";
else {
cout << st;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const int maxnn = 2e5 + 7;
int n, m;
struct dy {
int a[4];
} sz[maxnn];
vector<int> cx[maxnn];
map<long long, vector<int>> que;
int ans[maxnn];
int s = 0, t = 0;
int ss = 0, tt = 0;
int flag = 0;
long long base = 1;
int check(int p1, int p2, int nxt) {
for (int i = 1; i <= 3; i++) {
if (sz[nxt].a[i] != p1 && sz[nxt].a[i] != p2) return sz[nxt].a[i];
}
}
void bfs(int p, long long p1, long long p2, int old) {
if (flag == 1) return;
if (p == n) {
if (ans[n - 1] != tt) return;
flag = 1;
for (int i = 0; i < n; i++) {
if (i < n - 1)
printf("%d ", ans[i]);
else
printf("%d\n", ans[i]);
}
return;
}
long long temp = p1 * base + p2;
int nxt = -1;
for (int i = 0; i < que[temp].size(); i++) {
if (que[temp][i] != old) {
nxt = que[temp][i];
break;
}
}
if (nxt == -1) return;
int p3 = check(p1, p2, nxt);
ans[p] = p3;
bfs(p + 1, p2, p3, nxt);
}
int main() {
scanf("%d", &n);
int tttt = n;
while (tttt) {
base++;
tttt /= 10;
}
base = (long long)pow(10, base);
for (int i = 1; i <= n - 2; i++) {
scanf("%d %d %d", &sz[i].a[1], &sz[i].a[2], &sz[i].a[3]);
sort(sz[i].a + 1, sz[i].a + 4);
cx[sz[i].a[1]].push_back(i);
cx[sz[i].a[2]].push_back(i);
cx[sz[i].a[3]].push_back(i);
for (int j = 1; j <= 3; j++) {
long long temp = (long long)sz[i].a[j];
for (int k = 1; k <= 3; k++) {
if (k != j) {
que[(long long)temp * base + (long long)sz[i].a[k]].push_back(i);
}
}
}
}
for (int i = 1; i <= n; i++) {
if (cx[i].size() == 1) {
if (s == 0) {
s = cx[i][0];
ss = i;
} else if (t == 0) {
t = cx[i][0];
tt = i;
}
}
}
int p1 = 0, p2 = 0;
for (int i = 1; i <= 3; i++) {
if (sz[s].a[i] != ss) {
if (p1 == 0)
p1 = sz[s].a[i];
else
p2 = sz[s].a[i];
}
}
ans[0] = ss;
ans[1] = p1;
ans[2] = p2;
bfs(3, (long long)p1, (long long)p2, s);
if (flag == 0) {
ans[1] = p2;
ans[2] = p1;
bfs(3, (long long)p2, (long long)p1, s);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
int n, x;
cin >> n >> x;
int start = 1;
int ans = 0;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
while (start + x <= l) {
start += x;
}
while (start <= r) {
start++;
ans++;
}
}
cout << ans << '\n';
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
using namespace chrono;
#define fastio() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define endl '\n'
#define MOD 1000000007
#define MOD1 998244353
#define INF 1e18
#define PI 3.141592653589793238462
#define set_bits __builtin_popcountll
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double lld;
/*----------------------------------------------------------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------------------------------------------------------*/
// bool check(ll n, ll a, ll b, ll c)
// {
// if (min((c * a), (b + c)) > n)
// return false;
// if ((log(c * a) == log(n)) || (n % (b + c) == 0))
// {
// return true;
// }
// }
void solve()
{
ll n, a, b;
cin >> n >> a >> b;
ll flag = 1;
if (a == 1)
{
if ((n - 1) % b == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return;
}
while (flag <= n)
{
ll j = (n - flag);
if (j % b == 0)
{
cout << "YES" << endl;
return;
}
flag = flag * a;
}
cout << "NO" << endl;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("Input.txt", "r", stdin);
freopen("Output.txt", "w", stdout);
freopen("Error.txt", "w", stderr);
#endif
fastio();
auto start1 = high_resolution_clock::now();
int t = 1;
cin >> t;
while (t--)
{
solve();
}
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
#ifndef ONLINE_JUDGE
cerr << "Time: " << duration . count() / 1000 << endl;
#endif
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct fenwickTree {
vector<long long> bit;
fenwickTree(long long n) : bit(n, 0) {}
void update(long long idx, long long d) {
for (; idx < (long long)bit.size(); idx = idx | (idx + 1)) bit[idx] += d;
}
long long sum(long long r) const {
long long ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
long long sum(long long l, long long r) const { return sum(r) - sum(l - 1); }
};
long long numIverserions(const vector<long long>& arr) {
const long long n = arr.size();
fenwickTree ft(n + 1);
long long inversions = 0;
for (long long val : arr) {
if (val + 1 <= n) inversions += ft.sum(val + 1, n);
ft.update(val, 1);
}
return inversions;
}
signed main() {
cin.tie(0)->sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> arr(n);
vector<bool> cnts(n + 1, false);
{
bool isDup = false;
for (long long& val : arr) {
cin >> val;
if (cnts[val]) {
isDup = true;
}
cnts[val] = true;
}
if (isDup) {
cout << "YES\n";
continue;
}
}
(numIverserions(arr) % 2 == 0 && cout << "YES\n") || cout << "NO\n";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, i, arr[3001];
int idx, j, mn = 1000000002;
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> arr[i];
cout << n << endl;
for (i = 0; i < n; i++) {
idx = i;
for (j = i; j < n; j++)
if (arr[j] < arr[idx]) idx = j;
swap(arr[idx], arr[i]);
cout << i << " " << idx << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int rdi() {
int d;
scanf("%d", &d);
return d;
}
inline char rdc() {
scanf(" ");
return getchar();
}
inline string rds() {
string s;
cin >> s;
return s;
}
inline double rddb() {
double d;
scanf("%lf", &d);
return d;
}
template <class T>
inline bool setmin(T& a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool setmax(T& a, T b) {
return a < b ? a = b, true : false;
}
struct debugger {
template <typename T>
debugger& operator,(const T& x) {
cerr << x << ",";
return *this;
}
} dbgr;
const int MAXN = 40100;
char str[MAXN];
int m, n, a[MAXN];
int b[10 * MAXN];
int main() {
while (scanf("%d%s", &m, str) == 2) {
n = strlen(str);
for (int i = 0; i < n; i++) a[i] = str[i] - '0';
memset(b, 0, sizeof b);
for (int i = (0); i < (n); ++i) {
int s = 0;
for (int j = (i); j < (n); ++j) {
s += a[j];
++b[s];
}
}
long long ans = 0;
for (int i = (0); i < (n); ++i) {
int s = 0;
for (int j = (i); j < (n); ++j) {
s += a[j];
if (s > 0 && m % s == 0 && m / s <= n * 9)
ans += b[m / s];
else if (s == 0 && m == 0)
ans += (n * (n + 1) / 2);
}
}
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(15);
}
int main() {
FastIO();
int n, i, j, y, maxval = -1, ans = 0, var;
vector<int> v;
vector<int>::iterator it;
set<int> s;
set<int>::iterator it1;
cin >> n;
for (i = 0; i < n; i++) {
cin >> var;
s.insert(var);
maxval = max(maxval, var);
}
v.resize(s.size());
it1 = s.begin();
i = 0;
while (it1 != s.end()) {
v[i] = *it1;
it1++;
i++;
}
n = v.size();
for (i = 0; i < n; i++) {
for (j = 2;; j++) {
it = lower_bound(v.begin(), v.end(), j * v[i]);
if (it == v.begin()) {
if (j * v[i] > maxval) break;
continue;
}
it--;
y = *it;
if (y >= v[i]) ans = max(ans, y % v[i]);
if (j * v[i] > maxval) break;
}
}
cout << ans << "\n";
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, a, b, k;
cin >> n >> a >> b >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) {
int h;
cin >> h;
int r = h / (a + b);
if (h % (a + b) == 0) r--;
if (r == 0 && a < h)
v[i] = (h + a - 1) / a - 1;
else if (r == 0 && a >= h)
v[i] = 0;
else if (h - r * (a + b) <= a)
v[i] = 0;
else if (h - r * (a + b) > a)
v[i] = (h - r * (a + b) + a - 1) / a - 1;
}
sort(v.begin(), v.end());
int ans = 0;
int sum = 0;
for (int i = 0; i < n; i++)
if (sum + v[i] > k)
break;
else {
sum += v[i];
ans++;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long long int solve1(long long int r1, long long int r2, long long int x,
long long int y, long long int a, long long int b) {
long long int dis_x = abs(x - r1);
if (dis_x % a) return 1e18;
long long int dis_y = abs(y - r2);
if (dis_y % b) return 1e18;
long long int x_move = dis_x / a;
long long int y_move = dis_y / b;
if ((x_move - y_move) % 2) return 1e18;
long long int ans = max(x_move, y_move);
return ans;
}
void solve() {
long long int n, m, x, y, a, b;
cin >> n >> m >> x >> y >> a >> b;
long long int ans = solve1(1, m, x, y, a, b);
ans = min(ans, solve1(n, 1, x, y, a, b));
ans = min(ans, solve1(1, 1, x, y, a, b));
ans = min(ans, solve1(n, m, x, y, a, b));
if (ans == 1e18 || (ans != 0 && (n <= a || m <= b)))
cout << "Poor Inna and pony!";
else
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l, a[1000009], b[1000009], dp[1 << 20 + 5], ans, cn, t, x, y,
z, mx, mn, s;
char c[25][10], d[1000009], ch;
int set1(int num, int pos) { return num = num | (1 << pos); }
int check(int num, int pos) { return num & (1 << pos); }
int go(int mask, int pos) {
if (dp[mask] != (1 << 30) + 1) {
return dp[mask];
}
if (pos == m) {
return dp[mask] = 0;
} else {
int ret, strength;
if (b[pos] == 1) {
ret = -(1 << 30);
for (int o = 0; o < m; o++) {
if (strcmp(c[pos], "p") == 0) {
strength = a[o];
} else {
strength = 0;
}
if (check(mask, o) == 0) {
ret = max(ret, go(set1(mask, o), pos + 1) + strength);
}
}
} else {
ret = (1 << 30);
for (int o = 0; o < m; o++) {
if (strcmp(c[pos], "p") == 0) {
strength = -a[o];
} else {
strength = 0;
}
if (check(mask, o) == 0) {
ret = min(ret, go(set1(mask, o), pos + 1) + strength);
}
}
}
return dp[mask] = ret;
}
}
int main() {
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
reverse(a, a + n);
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%s %d", c[i], &b[i]);
}
for (i = 0; i < (1 << 20) + 5; i++) {
dp[i] = (1 << 30) + 1;
}
ans = go(0, 0);
printf("%d\n", ans);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
void call(vector<int> a) {
int less = 0;
if (a.size() % 2 != 0)
less = 1;
else
less = 2;
for (int i = 0; i < a.size() - less; i += 2) {
cout << a[i] << " " << a[i + 1] << endl;
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<int> odd, even;
int x, e = 0, o = 0;
for (int i = 0; i < 2 * n; i++) {
cin >> x;
if (x % 2 != 0) {
odd.push_back(i + 1);
o++;
} else {
even.push_back(i + 1);
e++;
}
}
if (odd.size() % 2 != 0) {
call(even);
call(odd);
} else {
if (even.size() >= odd.size()) {
call(even);
for (int i = 0; i < odd.size(); i += 2)
cout << odd[i] << " " << odd[i + 1] << endl;
} else {
call(odd);
for (int i = 0; i < even.size(); i += 2)
cout << even[i] << " " << even[i + 1] << endl;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans, a[100000], n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) ans += a[i] * i;
printf("%d", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const long long LINF = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000 + 5;
const int MN = 100;
int sz;
long long fib[MN];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
fib[0] = 1, fib[1] = 2;
sz = 1;
while (fib[sz] <= n) {
fib[sz + 1] = fib[sz] + fib[sz - 1];
++sz;
}
cout << sz - 1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1550, K = 100050, P = 1e9 + 7;
inline int power(int x, int y) {
static int r;
r = 1;
while (y) {
if (y & 1) r = (long long)r * x % P;
x = (long long)x * x % P;
y >>= 1;
}
return r;
}
int fac[K], nfac[K], inv[K];
inline int C(int n, int m) {
return (long long)fac[n] * nfac[m] % P * nfac[n - m] % P;
}
int n, m, p, k;
int pr[N], prep[N];
int pref[N];
int dp[N], f[N];
int p1, s;
inline void work() {
int i;
s = dp[m];
for (i = 0; i <= m; ++i) f[i] = dp[i], dp[i] = 0;
pref[0] = (long long)f[0] * pr[0] % P;
for (i = 1; i <= m; ++i)
pref[i] = (pref[i - 1] + (long long)f[i] * pr[i]) % P;
for (i = 1; i <= m; ++i) {
dp[i] =
(long long)pr[m - i] *
((long long)prep[i - 1] * (s - f[m - i] + P) % P - pref[i - 1] + P) % P;
}
for (i = 1; i <= m; ++i) dp[i] = (dp[i] + dp[i - 1]) % P;
}
int main() {
int i;
fac[0] = nfac[0] = inv[0] = fac[1] = nfac[1] = inv[1] = 1;
for (i = 2; i <= 100000; ++i) {
fac[i] = (long long)fac[i - 1] * i % P;
inv[i] = (long long)(P - P / i) * inv[P % i] % P;
nfac[i] = (long long)nfac[i - 1] * inv[i] % P;
}
read(n), read(m), read(p), read(i), p = (long long)p * power(i, P - 2) % P,
read(k);
for (i = 0; i <= m && i <= k; ++i)
pr[i] = (long long)C(k, i) * power(p, i) % P *
power((1 + P - p) % P, k - i) % P;
prep[0] = pr[0];
for (i = 1; i <= m; ++i) prep[i] = (pr[i] + prep[i - 1]) % P;
dp[m] = 1;
p1 = prep[m - 1];
s = 1;
for (i = 1; i <= n; ++i) work(), s = (long long)s * p1 % P;
int ans = dp[m];
cout << ans << '\n';
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int mod = 1e9 + 7;
int n, m, k;
vector<int> numx, numy;
int m1[1010][1010];
struct node {
int x, y;
} pos[N];
int find1(int x) {
return lower_bound(numx.begin(), numx.end(), x) - numx.begin() + 1;
}
int find2(int x) {
return lower_bound(numy.begin(), numy.end(), x) - numy.begin() + 1;
}
bool check(int mid) {
memset(m1, 0, sizeof m1);
numx.clear();
numy.clear();
int i, j;
for (i = 1; i <= k; i++) {
numx.push_back(max(1, pos[i].x - mid));
numx.push_back(min(n + 1, pos[i].x + mid + 1));
numy.push_back(max(1, pos[i].y - mid));
numy.push_back(min(m + 1, pos[i].y + mid + 1));
}
numx.push_back(n + 1);
numy.push_back(m + 1);
numx.push_back(1);
numy.push_back(1);
sort(numx.begin(), numx.end());
sort(numy.begin(), numy.end());
numx.erase(unique(numx.begin(), numx.end()), numx.end());
numy.erase(unique(numy.begin(), numy.end()), numy.end());
for (i = 1; i <= k; i++) {
int pos1 = find1(max(1, pos[i].x - mid));
int pos2 = find1(min(n + 1, pos[i].x + mid + 1));
int pos3 = find2(max(1, pos[i].y - mid));
int pos4 = find2(min(m + 1, pos[i].y + mid + 1));
m1[pos1][pos3]++, m1[pos2][pos3]--, m1[pos1][pos4]--, m1[pos2][pos4]++;
}
int up = 0, down = (int)numx.size();
int l = (int)numy.size(), r = 0;
for (i = 1; i < (int)numx.size(); i++) {
for (j = 1; j < (int)numy.size(); j++) {
m1[i][j] += m1[i - 1][j] + m1[i][j - 1] - m1[i - 1][j - 1];
if (!m1[i][j]) {
up = max(up, i), down = min(down, i);
l = min(l, j), r = max(r, j);
}
}
}
if (down == (int)numx.size() || l == (int)numy.size()) return true;
down = numx[down - 1], up = numx[up] - 1;
l = numy[l - 1], r = numy[r] - 1;
if (up - down > 2 * mid) return false;
if (r - l > 2 * mid) return false;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
cin >> pos[i].x >> pos[i].y;
}
int l = 0, r = 1e9;
while (l < r) {
int mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
cout << l << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
inline int getint() {
int c, l = 0, x;
for (; !isdigit(c = getchar()); l = c)
if (c == EOF) return 1 << 31;
for (x = c - '0'; isdigit(c = getchar()); x = x * 10 + c - '0')
if (c == EOF) break;
return l == '-' ? -x : x;
}
int buf[100];
inline int putint(int x) {
int i = 0;
x = x < 0 ? putchar('-'), -x : x;
for (; buf[i++] = x % 10, x; x /= 10)
;
for (i = i - 1 ? i - 1 : 1; i--; putchar(buf[i] + '0'))
;
putchar('\n');
return 1;
}
const int N = 300000;
int ne[N], G[N], to[N], dis[N], xb;
int fa[N], dp[N], d1[N], d2[N], ma, maa[N], mma[N], tp[N], cnt, rt, b[N], dw[N];
int n, q, ans;
struct data {
int i, d;
data(int i = 0, int d = 0) : i(i), d(d) {}
bool operator<(const data& a) const { return d > a.d; }
} a[N];
void add(int z, int y, int x) {
ne[xb] = G[x];
to[xb] = y;
dis[xb] = z;
G[x] = xb++;
ne[xb] = G[y];
to[xb] = x;
dis[xb] = z;
G[y] = xb++;
}
void dfs1(int x, int fa, int* d) {
for (int i = G[x]; ~i; i = ne[i])
if (to[i] != fa) {
d[to[i]] = d[x] + dis[i];
if (d[to[i]] > d[ma]) ma = to[i];
dfs1(to[i], x, d);
}
}
int dfs2(int x) {
for (int i = G[x]; ~i; i = ne[i])
if (to[i] != fa[x]) {
fa[to[i]] = x;
dp[to[i]] = dp[x] + dis[i];
int t = dfs2(to[i]);
if (t + dis[i] > mma[x]) {
mma[x] = t + dis[i];
maa[x] = to[i];
}
}
return mma[x];
}
void dfs3(int x, int y) {
tp[x] = y;
if (maa[x])
dfs3(maa[x], y);
else
dw[y] = x;
for (int i = G[x]; ~i; i = ne[i])
if (to[i] != fa[x] && to[i] != maa[x]) {
a[++cnt] = data(to[i], mma[to[i]] + dis[i]);
dfs3(to[i], to[i]);
}
}
int main() {
memset(G, -1, sizeof(G));
n = getint();
q = getint();
for (int i = 1; i < n; i++) add(getint(), getint(), getint());
dfs1(1, -1, d1);
memset(d1, 0, sizeof(d1));
dfs1(ma, -1, d1);
dfs1(rt = ma, -1, d2);
dfs2(rt);
a[++cnt] = data(rt, mma[rt]);
dfs3(rt, rt);
sort(a + 1, a + 1 + cnt);
for (int i = 1; i <= cnt; i++) b[a[i].i] = i, a[i].d += a[i - 1].d;
while (q--) {
int x = (getint() + ans - 1) % n + 1;
int y = (getint() + ans - 1) % n + 1;
if (b[tp[x]] <= 2 * y - 1 || cnt <= 2 * y - 1) {
ans = a[min(cnt, 2 * y - 1)].d;
putint(ans);
continue;
}
x = dw[tp[x]];
if (y == 1) {
ans = max(d1[x], d2[x]);
putint(ans);
continue;
}
int dd = x;
for (; b[tp[dd]] > 2 * y - 1; dd = fa[tp[dd]])
;
ans = max(a[2 * y - 1].d - dp[dw[tp[dd]]] + dp[dd],
max(a[2 * y - 2].d, a[2 * y - 1].d - dp[dd])) -
dp[dd] + dp[x];
putint(ans);
}
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 15;
const int MOD = 1000000007;
const int inf = 0x3f3f3f3f;
struct Seg {
int l, r, idx;
bool operator<(const Seg& b) const { return l != b.l ? l < b.l : r < b.r; }
};
Seg seg[N];
int sum[N];
bool used[N];
int main() {
int k, n;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &seg[i].l, &seg[i].r);
seg[i].idx = i;
}
sort(seg + 1, seg + 1 + n);
int m = 0;
priority_queue<pair<int, int> > que;
for (int i = 1, it = 1; i <= N - 1; i++) {
while (it <= n && seg[it].l == i) {
que.push(make_pair(seg[it].r, seg[it].idx));
sum[i]++;
sum[seg[it].r + 1]--;
it++;
}
sum[i] += sum[i - 1];
while (sum[i] > k) {
auto pr = que.top();
que.pop();
used[pr.second] = true;
sum[i]--;
sum[pr.first + 1]++;
m++;
}
}
printf("%d\n", m);
for (int i = 1; i <= n; i++) {
if (used[i]) {
printf("%d ", i);
}
}
puts("");
}
| 10 |
#include <bits/stdc++.h>
int abs(int x) {
if (x < 0)
return -x;
else
return x;
}
int m(int x, int y) {
if (x > y)
return y;
else
return x;
}
int main() {
char s[4], t[4];
scanf("%s", s);
scanf("%s", t);
int x1, y1, x2, y2;
x1 = s[0] - 'a' + 1;
x2 = t[0] - 'a' + 1;
y1 = s[1] - '0';
y2 = t[1] - '0';
char c1, c2, c3;
int mov = 0, x = 0;
if (x1 != x2 && y1 != y2) {
mov = m(abs(x1 - x2), abs(y1 - y2));
if (x1 < x2) {
c1 = 'R';
x1 += mov;
} else {
c1 = 'L';
x1 -= mov;
}
if (y1 < y2) {
c2 = 'U';
y1 += mov;
} else {
c2 = 'D';
y1 -= mov;
}
}
x = mov;
if (x1 != x2 && y1 == y2) {
if (x1 < x2)
c3 = 'R';
else
c3 = 'L';
mov += abs(x1 - x2);
} else if (x1 == x2 && y1 != y2) {
if (y1 < y2)
c3 = 'U';
else
c3 = 'D';
mov += abs(y1 - y2);
}
printf("%d\n", mov);
if (x != 0) {
for (int i = 0; i < x; i++) {
printf("%c%c\n", c1, c2);
}
}
for (int i = 0; i < mov - x; i++) {
printf("%c\n", c3);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef struct node {
struct node* nexNode[2];
int cnt;
} Node;
Node* root;
void trie_insert(int num) {
int i = 30;
string s = "";
while (i > 0) {
char digit = '0' + num % 2;
s = digit + s;
num /= 2;
i--;
}
Node* current = root;
while (i < s.size()) {
int digit = s[i] - '0';
if (current->nexNode[digit] == NULL) {
Node* n_node = new Node;
n_node->cnt = 0;
n_node->nexNode[0] = n_node->nexNode[1] = NULL;
current->nexNode[digit] = n_node;
current = n_node;
} else
current = current->nexNode[digit];
i++;
current->cnt++;
}
}
void trie_delete(int num) {
int i = 30;
string s = "";
while (i > 0) {
char digit = '0' + num % 2;
s = digit + s;
num /= 2;
i--;
}
Node* current = root;
while (i < s.size()) {
int digit = s[i] - '0';
if (current->nexNode[digit] == NULL)
return;
else
current = current->nexNode[digit];
i++;
current->cnt--;
}
}
int find_respectors(int num, int l) {
int i = 30, ans = 0;
string s = "";
string sl = "";
while (i > 0) {
char digit = '0' + num % 2;
char digit_l = '0' + l % 2;
s = digit + s;
sl = digit_l + sl;
num /= 2;
l /= 2;
i--;
}
Node* current = root;
while (i < s.size()) {
if (sl[i] == '1') {
int digit = s[i] - '0';
if (current->nexNode[digit] != NULL) ans += current->nexNode[digit]->cnt;
if (current->nexNode[1 - digit] != NULL &&
current->nexNode[1 - digit]->cnt > 0)
current = current->nexNode[1 - digit];
else
return ans;
} else {
int digit = s[i] - '0';
if (current->nexNode[digit] != NULL && current->nexNode[digit]->cnt > 0)
current = current->nexNode[digit];
else
return ans;
}
i++;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
root = new Node;
root->cnt = 0;
root->nexNode[0] = root->nexNode[1] = NULL;
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
int p;
cin >> p;
if (type == 1) {
trie_insert(p);
continue;
}
if (type == 2) {
trie_delete(p);
continue;
}
int l;
cin >> l;
cout << find_respectors(p, l) << "\n";
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 100010;
const int MOD = 1000000007;
const double pi = acos(-1.0);
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int lcm(int a, int b) { return (a * (b / gcd(a, b))); }
int fx[] = {0, 0, 1, -1};
int fy[] = {-1, 1, 0, 0};
int n, m;
int flg = 0;
int gr[105][105];
int vis[105], dis[105];
void dfs(int u) {
int i;
vis[u] = 1;
for (i = 0; i < n + 1; i++) {
if (gr[u][i] && !vis[i]) {
;
dfs(i);
}
}
}
int main() {
int i = 0, j;
int t, cnt = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> t >> j;
gr[t][j] = gr[j][t] = 1;
}
if (n == m) {
for (i = 1; i < n + 1; i++) {
if (!vis[i]) {
cnt++;
if (cnt > 1) {
flg = 1;
;
break;
}
dfs(i);
}
}
} else {
flg = 1;
};
if (!flg) {
cout << "FHTAGN!";
} else {
cout << "NO";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 0x3f3f3f3f3f3f3f3fll;
const int LGN = 25;
const int MOD = 1e9 + 7;
const int N = 3e5 + 5;
int n, adj[N][26], dep[N];
vector<pair<int, int> > T[N];
vector<int> depset[N];
int sub[N], big[N];
void dfs1(int u = 1, int p = 0, int d = 1) {
dep[u] = d;
depset[d].push_back(u);
sub[u] = 1;
for (pair<int, int> e : T[u])
if (e.first != p) {
int v = e.first;
adj[u][e.second] = v;
dfs1(v, u, d + 1);
sub[u] += sub[v];
if (sub[big[u]] < sub[v]) big[u] = v;
}
}
int ans[N], depans[N];
vector<pair<int, int> > undo;
int merge(int u, int v) {
int ans = 0;
for (long long c = 0, __R = 25; c <= __R; c++)
if (adj[v][c]) {
if (adj[u][c])
ans += merge(adj[u][c], adj[v][c]);
else {
ans += sub[adj[v][c]];
adj[u][c] = adj[v][c];
undo.emplace_back(u, c);
}
}
return ans;
}
void dfs2(int u = 1) {
if (!big[u]) {
ans[u] = 1;
depans[dep[u]]++;
return;
}
for (long long c = 0, __R = 25; c <= __R; c++)
if (adj[u][c]) dfs2(adj[u][c]);
ans[u] = sub[big[u]];
for (long long c = 0, __R = 25; c <= __R; c++)
if (adj[u][c] && adj[u][c] != big[u]) {
ans[u] += merge(big[u], adj[u][c]);
}
depans[dep[u]] += ans[u];
for (pair<int, int> e : undo) adj[e.first][e.second] = 0;
undo.clear();
}
int main() {
std::ios::sync_with_stdio(false);
scanf("%d", &(n));
for (long long i = 2, __R = n; i <= __R; i++) {
int u, v;
scanf("%d%d", &(u), &(v));
char c[2];
scanf("%s", c);
T[u].emplace_back(v, c[0] - 'a');
T[v].emplace_back(u, c[0] - 'a');
}
dfs1();
dfs2();
int depsum = 0;
int ans = oo, p;
for (long long d = 1, __R = n; d <= __R; d++) {
depsum += depset[d - 1].size();
int alt = depsum + depans[d];
if (alt < ans) ans = alt, p = d;
}
printf("%d\n%d\n", ans, p);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long M, K, dp[70][70][2], bits;
bool bit[70];
long long f(int ind, int k, int t) {
if (dp[ind][k][t] != -1) return dp[ind][k][t];
if (ind == bits + 1) return k == 0;
dp[ind][k][t] = f(ind + 1, k, t ? 1 : (bit[ind] == 1 ? 1 : 0));
if (k and (t or bit[ind] == 1)) dp[ind][k][t] += f(ind + 1, k - 1, t);
return dp[ind][k][t];
}
long long F(long long N) {
bits = 0;
while (N) {
bit[++bits] = N & 1;
N >>= 1;
}
reverse(bit + 1, bit + bits + 1);
memset(dp, -1, sizeof(dp));
return f(1, K, 0);
}
int main() {
scanf("%lld%lld", &M, &K);
long long b = 0, e = 1e18;
while (b < e) {
if (F(2 * ((b + e) / 2 + 1)) - F(((b + e) / 2 + 1)) > M)
e = ((b + e) / 2 + 1) - 1;
else
b = ((b + e) / 2 + 1);
}
printf("%lld\n", b);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, t, i, j, k, m;
cin >> t;
while (t--) {
cin >> n >> k;
string s;
cin >> s;
string s1, s2, s3;
s1 = "";
s2 = "";
s3 = "";
for (i = 0; i < k; ++i) {
if (i % 3 == 0) {
s1 += 'R';
} else if (i % 3 == 1) {
s1 += 'G';
} else {
s1 += 'B';
}
}
for (i = 0; i < k; ++i) {
if (i % 3 == 0) {
s2 += 'G';
} else if (i % 3 == 1) {
s2 += 'B';
} else {
s2 += 'R';
}
}
for (i = 0; i < k; ++i) {
if (i % 3 == 0) {
s3 += 'B';
} else if (i % 3 == 1) {
s3 += 'R';
} else {
s3 += 'G';
}
}
long long int ans = INT_MAX;
for (i = 0; i < n - k + 1; ++i) {
long long int g = 0;
long long int gg = 0;
long long int ggg = 0;
for (j = 0; j < k; ++j) {
if (s[i + j] != s1[j]) {
g++;
}
if (s[i + j] != s2[j]) {
gg++;
}
if (s[i + j] != s3[j]) {
ggg++;
}
}
ans = min(ans, g);
ans = min(ans, gg);
ans = min(ans, ggg);
}
cout << ans << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double PI = acos(-1);
template <class T, class S>
inline void add(T& a, S b) {
a += b;
if (a >= mod) a -= mod;
}
template <class T, class S>
inline void sub(T& a, S b) {
a -= b;
if (a < 0) a += mod;
}
template <class T, class S>
inline bool chkmax(T& a, S b) {
return a < b ? a = b, true : false;
}
template <class T, class S>
inline bool chkmin(T& a, S b) {
return a > b ? a = b, true : false;
}
long long x, y;
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (!b) {
x = 1;
y = 0;
return a;
} else {
long long gcd, t;
gcd = exgcd(b, a % b, x, y);
t = x;
x = y;
y = t - (a / b) * y;
return gcd;
}
}
long long n, m, sx, sy, vx, vy;
long long gao(long long a, long long b, long long t1, long long t2) {
long long c = t2 - t1;
long long gcd = exgcd(a, b, x, y);
if (c % gcd) return INF;
x *= c / gcd;
y *= c / gcd;
long long mo = abs(b / gcd);
x = (x % mo + mo) % mo;
return 2 * n * x + t1;
}
long long calc(long long sx, long long sy, long long vx, long long vy,
long long tx, long long ty) {
long long t11 = 0, t12 = 0;
long long t21 = 0, t22 = 0;
if (vx > 0) {
if (tx >= sx)
t11 = tx - sx, t12 = t11 + 2 * (n - tx);
else
t11 = sx - tx + 2 * (n - sx), t12 = t11 + 2 * tx;
} else {
if (tx <= sx)
t11 = sx - tx, t12 = t11 + 2 * tx;
else
t11 = tx - sx + 2 * sx, t12 = t11 + 2 * (n - tx);
}
if (vy > 0) {
if (ty >= sy)
t21 = ty - sy, t22 = t21 + 2 * (m - ty);
else
t21 = sy - ty + 2 * (m - sy), t22 = t21 + 2 * ty;
} else {
if (ty <= sy)
t21 = sy - ty, t22 = t21 + 2 * ty;
else
t21 = ty - sy + 2 * sy, t22 = t21 + 2 * (m - ty);
}
long long tim = INF;
chkmin(tim, gao(2 * n, -2 * m, t11, t21));
chkmin(tim, gao(2 * n, -2 * m, t11, t22));
chkmin(tim, gao(2 * n, -2 * m, t12, t21));
chkmin(tim, gao(2 * n, -2 * m, t12, t22));
return tim;
}
void print(int who) {
if (who == 0)
cout << "0 0"
<< "\n";
else if (who == 1)
cout << n << " "
<< "0\n";
else if (who == 2)
cout << "0 " << m << "\n";
else if (who == 3)
cout << n << " " << m << "\n";
else
cout << "-1"
<< "\n";
exit(0);
}
int main() {
cin >> n >> m >> sx >> sy >> vx >> vy;
if (!vx) {
if (sx == 0 && vy == 1)
print(2);
else if (sx == 0 && vy == -1)
print(0);
else if (sx == n && vy == 1)
print(3);
else if (sx == n && vy == -1)
print(1);
else
print(-1);
} else if (!vy) {
if (sy == 0 && vx == 1)
print(1);
else if (sy == 0 && vx == -1)
print(0);
else if (sy == m && vx == 1)
print(3);
else if (sy == m && vx == -1)
print(2);
else
print(-1);
} else {
long long tim = INF, who = -1;
if (chkmin(tim, calc(sx, sy, vx, vy, 0, 0))) who = 0;
if (chkmin(tim, calc(sx, sy, vx, vy, n, 0))) who = 1;
if (chkmin(tim, calc(sx, sy, vx, vy, 0, m))) who = 2;
if (chkmin(tim, calc(sx, sy, vx, vy, n, m))) who = 3;
print(who);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int tp = 1;
for (int i = 1; i < n; i++) {
tp += i;
tp %= n;
if (tp == 0)
cout << n << " ";
else
cout << tp << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
const double EPS = 1e-6;
const int INF = 0x3f3f3f3f;
inline void read(long long& x) {
int f = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (f = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= f;
}
inline void read(int& x) {
long long t;
read(t);
x = t;
}
const int N = 1e6 + 10;
int n, k;
vector<int> E[1000005];
int fa[1000005];
int dep[1000005];
bool v[1000005];
int anc[1000005][35];
void dfs(int u, int f) {
fa[u] = f;
for (int i = 0; i < int((E[u]).size()); i++) {
if (E[u][i] != f) {
dep[E[u][i]] = dep[u] + 1;
dfs(E[u][i], u);
}
}
}
void rdfs(int u, int f) {
v[u] = 1;
if (u == f) return;
rdfs(fa[u], f);
}
void solve() {
for (int i = 0; i < n; i++) {
anc[i][0] = fa[i];
for (int j = 1; (1 << j) < n; j++) anc[i][j] = -1;
}
for (int j = 1; (1 << j) < n; j++) {
for (int i = 0; i < n; i++) {
if (anc[i][j - 1] != -1) {
int a = anc[i][j - 1];
anc[i][j] = anc[a][j - 1];
}
}
}
}
int main() {
memset(anc, -1, sizeof(anc));
read(n);
read(k);
k = n - k;
for (int i = 1; i < n; i++) {
int u, v;
read(u);
read(v);
u--;
v--;
E[u].push_back(v);
E[v].push_back(u);
}
dfs(n - 1, -1);
solve();
int num = 1;
v[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
if (v[i]) continue;
int t = i;
for (int j = 20; j >= 0; j--) {
if (anc[t][j] == -1) continue;
if (!v[anc[t][j]]) t = anc[t][j];
}
if (dep[i] - dep[t] + 1 + num <= k) {
num += dep[i] - dep[t] + 1;
rdfs(i, t);
}
}
for (int i = 0; i < n; i++) {
if (!v[i]) printf("%d ", i + 1);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int st1[1001], st2[1001];
int n;
void flip(int i) {
int j;
for (j = 1; j <= i; j++) st1[j] = st1[j] ^ 1;
j = 1;
while (j < i) {
swap(st1[i], st1[j]);
j++;
i--;
}
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> n;
char ch;
for (int i = 1; i <= n; i++) {
cin >> ch;
st1[i] = ch - '0';
}
for (int i = 1; i <= n; i++) {
cin >> ch;
st2[i] = ch - '0';
}
vector<int> v;
for (int i = n; i >= 2; i--) {
if (st1[i] != st2[i]) {
if (st2[i] == st1[1]) {
st1[1] = st1[1] ^ 1;
v.push_back(1);
}
v.push_back(i);
flip(i);
}
}
if (st1[1] != st2[1]) v.push_back(1);
cout << v.size() << " ";
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500010, inf = 1e9 + 233;
int Q, x;
long long sum[maxn];
multiset<int> s[40];
template <typename T>
inline void read(T &k) {
int f = 1;
k = 0;
char c = getchar();
while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
while (c <= '9' && c >= '0') k = k * 10 + c - '0', c = getchar();
k *= f;
}
int main() {
read(Q);
int cnt = 0;
while (Q--) {
char ty = getchar();
read(x);
int pos = (int)log2(x);
if (ty == '+')
s[pos].insert(x), sum[pos] += x, cnt++;
else
s[pos].erase(s[pos].find(x)), sum[pos] -= x, cnt--;
long long now = 0;
int ans = 0;
for (int i = 0; i < 30; i++) {
ans += (now << 1) < *s[i].begin();
now += sum[i];
}
printf("%d\n", cnt - ans);
}
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
bool make(int addo, int addz, int z, int o, int ex) {
if (addz == 0) {
if (o + ex >= addo + z)
return 1;
else
return 0;
} else {
if (z + ex >= addz + o)
return 1;
else
return 0;
}
}
int main() {
string s;
cin >> s;
int zero = 0, one = 0, estfham = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0')
zero++;
else if (s[i] == '1')
one++;
else
estfham++;
}
bool zz = 0, zo = 0, oz = 0, oo = 0;
if (make(2, 0, zero, one, estfham)) oo = 1;
if (make(0, 1, zero, one, estfham)) zz = 1;
if (s.size() % 2 == 0 && zero <= s.size() / 2 && one <= s.size() / 2) {
int f = s.size() / 2;
if (f == zero) {
if (s.back() == '0')
oz = 1;
else
zo = 1;
} else if (f == one) {
if (s.back() == '1')
zo = 1;
else
oz = 1;
} else {
if (s.back() == '0') oz = 1;
if (s.back() == '1') zo = 1;
if (s.back() == '?') oz = 1, zo = 1;
}
}
int f = s.size() / 2;
if (s.size() % 2 && zero <= f && one <= f + 1) {
if (f == zero) {
if (s.back() == '0')
oz = 1;
else
zo = 1;
} else if (f + 1 == one) {
if (s.back() == '1')
zo = 1;
else
oz = 1;
} else {
if (s.back() == '0') oz = 1;
if (s.back() == '1') zo = 1;
if (s.back() == '?') oz = 1, zo = 1;
}
}
vector<string> arr;
if (oo) arr.push_back("11");
if (oz) arr.push_back("10");
if (zo) arr.push_back("01");
if (zz) arr.push_back("00");
sort(arr.begin(), arr.end());
for (int i = 0; i < arr.size(); i++) cout << arr[i] << "\n";
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 100;
int x[MAXN];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(n); i++) cin >> x[i];
int res = 0;
while (m--) {
int u, v;
cin >> u >> v;
u--;
v--;
res += min(x[u], x[v]);
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 100100 * 2;
int n, m, d[maxn];
int fir[maxn], last[maxn << 2], nex[maxn << 2], a[maxn << 2], b[maxn << 2],
tot = 1;
vector<int> e[maxn];
bool vis[maxn];
long long dp[maxn][2][2];
int sgn(int x) {
if (x > 0) return 0;
if (x < 0) return 1;
}
void add(int u, int v, int aa, int bb) {
++tot;
last[tot] = v;
a[tot] = aa;
b[tot] = bb;
nex[tot] = fir[u];
fir[u] = tot;
}
struct node {
int a, b;
} fa[maxn];
bool evis[maxn << 2];
int s[maxn], cnt;
void dfs(int x) {
vis[x] = 1;
s[++cnt] = x;
for (int i = fir[x]; i; i = nex[i]) {
if (!evis[i]) {
evis[i] = 1;
evis[i ^ 1] = 1;
fa[x] = (node){a[i], b[i]};
if (!vis[last[i]]) dfs(last[i]);
}
}
}
void up(long long &a, long long b) {
a += b;
a %= mod;
}
int main() {
scanf("%d%d", &n, &m);
long long ans1 = 0, ans0 = 1;
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
if (k == 1) {
int x;
scanf("%d", &x);
e[abs(x)].push_back(sgn(x));
} else {
int u, v;
scanf("%d%d", &u, &v);
if (abs(u) == abs(v)) {
if (u != v) {
vis[abs(u)] = 1;
swap(ans1, ans0);
ans1 = ans1 * 2 % mod;
ans0 = ans0 * 2 % mod;
} else {
e[abs(u)].push_back(sgn(u));
}
continue;
}
add(abs(u), abs(v), sgn(u), sgn(v));
add(abs(v), abs(u), sgn(v), sgn(u));
d[abs(u)]++;
d[abs(v)]++;
}
}
for (int i = 1; i <= m; i++)
if (!vis[i] && d[i] == 0 && e[i].size() > 0) {
vis[i] = 1;
if (e[i].size() == 1) {
ans1 = (ans1 + ans0) % mod;
ans0 = ans1;
} else {
if (e[i][0] == e[i][1]) {
ans1 = ans1 * 2 % mod;
ans0 = ans0 * 2 % mod;
} else {
swap(ans1, ans0);
ans1 = ans1 * 2 % mod;
ans0 = ans0 * 2 % mod;
}
}
}
for (int i = 1; i <= m; i++)
if (d[i] == 1 && !vis[i]) {
cnt = 0;
dfs(i);
dp[i][0][0] = 1;
dp[i][0][1] = 0;
dp[i][1][0] = 1;
dp[i][1][1] = 0;
if (e[i].size()) {
if (e[i][0] == 1) {
swap(dp[i][0][0], dp[i][0][1]);
} else {
swap(dp[i][1][0], dp[i][1][1]);
}
}
for (int step = 1; step < cnt; step++) {
for (int ii = 0; ii < 2; ii++)
for (int jj = 0; jj < 2; jj++)
for (int kk = 0; kk < 2; kk++) {
up(dp[s[step + 1]][kk]
[((ii ^ fa[s[step]].a) | (kk ^ fa[s[step]].b)) ^ jj],
dp[s[step]][ii][jj]);
}
}
int x = s[cnt];
if (e[x].size()) {
if (e[x][0] == 1) {
swap(dp[x][0][0], dp[x][0][1]);
} else {
swap(dp[x][1][0], dp[x][1][1]);
}
}
long long a1 = 0, a0 = 0;
a1 = (dp[x][0][0] + dp[x][1][0]) * ans1 % mod +
(dp[x][0][1] + dp[x][1][1]) * ans0 % mod;
a0 = (dp[x][0][0] + dp[x][1][0]) * ans0 % mod +
(dp[x][0][1] + dp[x][1][1]) * ans1 % mod;
ans1 = a1 % mod;
ans0 = a0 % mod;
}
for (int i = 1; i <= m; i++)
if (d[i] == 2 && !vis[i]) {
cnt = 0;
dfs(i);
dp[i][0][0] = 1;
dp[i][0][1] = 0;
dp[i][1][0] = 0;
dp[i][1][1] = 0;
for (int step = 2; step <= cnt; step++)
memset(dp[s[step]], 0, sizeof(dp[s[step]]));
for (int step = 1; step < cnt; step++) {
for (int ii = 0; ii < 2; ii++)
for (int jj = 0; jj < 2; jj++)
for (int kk = 0; kk < 2; kk++) {
up(dp[s[step + 1]][kk]
[((ii ^ fa[s[step]].a) | (kk ^ fa[s[step]].b)) ^ jj],
dp[s[step]][ii][jj]);
}
}
int x = s[cnt];
for (int ii = 0; ii < 2; ii++)
if ((ii ^ fa[x].a) | (fa[x].b)) swap(dp[x][ii][0], dp[x][ii][1]);
long long a1 = 0, a0 = 0;
a1 += (dp[x][0][0] + dp[x][1][0]) * ans1 % mod +
(dp[x][0][1] + dp[x][1][1]) * ans0 % mod;
a0 += (dp[x][0][0] + dp[x][1][0]) * ans0 % mod +
(dp[x][0][1] + dp[x][1][1]) * ans1 % mod;
dp[i][0][0] = 0;
dp[i][0][1] = 0;
dp[i][1][0] = 1;
dp[i][1][1] = 0;
for (int step = 2; step <= cnt; step++)
memset(dp[s[step]], 0, sizeof(dp[s[step]]));
for (int step = 1; step < cnt; step++) {
for (int ii = 0; ii < 2; ii++)
for (int jj = 0; jj < 2; jj++)
for (int kk = 0; kk < 2; kk++) {
up(dp[s[step + 1]][kk]
[((ii ^ fa[s[step]].a) | (kk ^ fa[s[step]].b)) ^ jj],
dp[s[step]][ii][jj]);
}
}
for (int ii = 0; ii < 2; ii++)
if ((ii ^ fa[x].a) | (1 ^ fa[x].b)) swap(dp[x][ii][0], dp[x][ii][1]);
a1 += (dp[x][0][0] + dp[x][1][0]) * ans1 % mod +
(dp[x][0][1] + dp[x][1][1]) * ans0 % mod;
a0 += (dp[x][0][0] + dp[x][1][0]) * ans0 % mod +
(dp[x][0][1] + dp[x][1][1]) * ans1 % mod;
ans1 = a1 % mod;
ans0 = a0 % mod;
}
for (int i = 1; i <= m; i++)
if (!vis[i]) ans1 = ans1 * 2 % mod;
printf("%I64d\n", ans1);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
const int N = 3e5 + 10;
char S[] = "AGCT";
string s[N];
int pos[N], tpos[N];
int a[4], ta[4];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
int ans = INT_MAX, flag = -1;
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++)
for (int k = 0; k < 4; k++)
if (k != i && k != j) {
int p = 6 - (i + j + k);
a[0] = i;
a[1] = j;
a[2] = k;
a[3] = p;
int tmp = 0;
for (int i = 0; i < n; i++) {
int t1 = 0, t2 = 0;
for (int j = 0; j < m; j++) {
int k = ((i & 1) << 1) + (j & 1);
if (s[i][j] != S[a[k]]) t1++;
k = ((i & 1) << 1) + (1 - (j & 1));
if (s[i][j] != S[a[k]]) t2++;
}
if (t1 < t2)
pos[i] = 0;
else
pos[i] = 1;
tmp += min(t1, t2);
}
if (tmp < ans) {
ans = tmp;
flag = 1;
memcpy(ta, a, sizeof(a));
memcpy(tpos, pos, sizeof(pos));
}
}
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++)
for (int k = 0; k < 4; k++)
if (k != i && k != j) {
int p = 6 - (i + j + k);
a[0] = i;
a[1] = j;
a[2] = k;
a[3] = p;
int tmp = 0;
for (int i = 0; i < m; i++) {
int t1 = 0, t2 = 0;
for (int j = 0; j < n; j++) {
int k = ((i & 1) << 1) + (j & 1);
if (s[j][i] != S[a[k]]) t1++;
k = ((i & 1) << 1) + (1 - (j & 1));
if (s[j][i] != S[a[k]]) t2++;
}
if (t1 < t2)
pos[i] = 0;
else
pos[i] = 1;
tmp += min(t1, t2);
}
if (tmp < ans) {
ans = tmp;
flag = 2;
memcpy(ta, a, sizeof(a));
memcpy(tpos, pos, sizeof(pos));
}
}
memcpy(a, ta, sizeof(a));
memcpy(pos, tpos, sizeof(pos));
if (flag == 1) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int k;
if (pos[i] == 0)
k = ((i & 1) << 1) + (j & 1);
else
k = ((i & 1) << 1) + (1 - (j & 1));
s[i][j] = S[a[k]];
}
}
} else {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int k;
if (pos[i] == 0)
k = ((i & 1) << 1) + (j & 1);
else
k = ((i & 1) << 1) + (1 - (j & 1));
s[j][i] = S[a[k]];
}
}
}
for (int i = 0; i < n; i++) cout << s[i] << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, c = 0;
string s;
bool ck(string t, string u) {
if (t.size() != u.size()) {
return false;
}
for (int i = 0, z = t.size(); i < z; i++) {
if (t[i] != u[i]) {
return false;
}
}
return true;
}
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < n / 2; i++) {
string t = "", u = "";
for (int j = 0; j <= 2 * i + 1; j++) {
t += s[j];
}
for (int k = 0; k <= i; k++) {
u += s[k];
}
u += u;
if (ck(t, u)) {
if (t.size() > c) {
c = t.size();
}
}
}
if (c == 0) {
cout << n << endl;
} else {
cout << (n - c) + (c / 2 + 1) << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string a;
int i;
cin >> a;
if (a[0] == '0') {
cout << '0' << endl;
return 0;
}
cout << '1';
for (i = 0; i <= n; i++) {
if (a[i] == '0') {
cout << '0';
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, n, x[30], y[30];
char e[155][155];
bool go(int dir) {
int cur = 0;
for (int i = 0; i < n; i++) x[i] = y[i];
for (int i = 0; i < b; i++) {
int start, finish;
if (dir > 0) {
start = 0;
finish = a + c;
} else {
start = a + c - 1;
finish = -1;
}
for (int j = start; j != finish; j += dir) {
if (e[i][j] == '.') continue;
if (x[cur] == 0) cur++;
x[cur]--;
e[i][j] = 'a' + cur;
}
dir = -dir;
}
return !(e[d - 1][a + c - 1] == e[d][a - 1] &&
e[d][a - 1] != e[d - 1][a - 1]);
}
void solve() {
scanf("%d%d%d%d%d", &a, &b, &c, &d, &n);
bool rev = false;
if (b < d) {
swap(b, d);
swap(a, c);
rev = true;
}
for (int i = 0; i < n; i++) scanf("%d", &y[i]);
for (int i = d; i < b; i++)
for (int j = a; j < a + c; j++) e[i][j] = '.';
if (!go(1) && !go(-1))
printf("NO\n");
else {
printf("YES\n");
for (int i = 0; i < b; i++) {
int start, finish, dj;
if (!rev) {
start = 0;
finish = a + c;
dj = 1;
} else {
start = a + c - 1;
finish = -1;
dj = -1;
}
for (int j = start; j != finish; j += dj) printf("%c", e[i][j]);
printf("\n");
}
}
}
int main() {
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<vector<int> > g;
vector<int> sz;
const int INF = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
g.resize(n);
sz.resize(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a - 1].push_back(b - 1);
g[b - 1].push_back(a - 1);
}
queue<int> q;
vector<int> d(n, INF);
vector<int> sec(n, INF);
vector<int> p(n);
for (int i = 0; i < n; i++) {
sz[i] = g[i].size();
if (sz[i] == 1) {
q.push(i);
d[i] = 0;
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i : g[v]) {
if (sz[i] != 0) {
if (d[i] == INF) {
d[i] = d[v] + 1;
sz[i]--;
if (sz[i] == 1) {
q.push(i);
}
} else {
if (d[i] == d[v] + 1) {
sz[i]--;
if (sz[i] == 1) {
q.push(i);
}
} else {
if (sec[i] == INF) {
sec[i] = d[v] + 1;
} else {
if (sec[i] != d[v] + 1) {
cout << -1;
return 0;
}
}
}
}
}
}
sz[v] = 0;
}
int numb = -1;
for (int i = 0; i < n; i++) {
if (sec[i] != INF) {
if (numb != -1) {
cout << -1;
return 0;
}
numb = i;
}
}
int ans = 0;
if (numb != -1)
ans = d[numb] + sec[numb];
else {
for (int i = 0; i < n; i++) ans = max(ans, d[i]);
}
while (ans % 2 == 0) ans /= 2;
cout << ans;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = INT_MAX, df = 505, mod = 1e9 + 7;
long long i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, dp[df][df][2],
a[df][df];
inline long long read() {
long long x = 0, y = 1;
char ch = getchar();
while (ch > '9' || ch < '0') y = (ch == '-') ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * y;
}
int main() {
n = read();
for (long long i = (1); i <= (n); ++i)
for (long long j = (1); j <= (n); ++j) a[i][j] = read();
for (long long i = (1); i <= (n); ++i) dp[i][i][0] = 1;
for (long long i = (2); i <= (n); ++i) {
for (long long l = (1); l <= (n - i + 1); ++l) {
long long r = l + i - 1;
if (a[l][r])
for (long long k = (l); k <= (r - 1); ++k)
(dp[l][r][0] += (dp[l][k][0] + dp[l][k][1]) *
(dp[k + 1][r][0] + dp[k + 1][r][1]) % mod) %= mod;
for (long long k = (l + 1); k <= (r - 1); ++k) {
if (a[l][k])
(dp[l][r][1] += dp[l][k][0] * (dp[k][r][0] + dp[k][r][1]) % mod) %=
mod;
}
}
}
return printf("%lld\n", (dp[1][n][1] + dp[1][n][0]) % mod), 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
static uint_fast16_t t;
static uint_fast32_t n, k;
static uint_fast32_t l1, r1;
static uint_fast32_t l2, r2;
int main() {
scanf("%" SCNuFAST16, &t);
for (; t; t--) {
scanf("%" SCNuFAST32 " %" SCNuFAST32, &n, &k);
scanf("%" SCNuFAST32 " %" SCNuFAST32, &l1, &r1);
scanf("%" SCNuFAST32 " %" SCNuFAST32, &l2, &r2);
if (l2 < l1) {
swap(l1, l2);
swap(r1, r2);
}
uint_fast32_t a = 0;
if (l2 <= r1) {
uint_fast32_t x;
uint_fast32_t d;
if (r1 < r2) {
x = r1 - l2;
d = (l2 - l1) + (r2 - r1);
} else {
x = r2 - l2;
d = (l2 - l1) + (r1 - r2);
}
for (uint_fast32_t i = 0; i < n; i++) {
const uint_fast32_t m = min(x, k);
k -= m;
}
for (uint_fast32_t i = 0; i < n; i++) {
const uint_fast32_t m = min(d, k);
a += m;
k -= m;
}
} else {
const uint_fast32_t s = r2 - l1;
const uint_fast32_t g = l2 - r1;
for (uint_fast32_t i = 0; i < n; i++) {
if (i && k < g) {
a += 2 * k;
k -= k;
} else {
a += g;
const uint_fast32_t m = min(s, k);
a += m;
k -= m;
}
}
}
if (k) {
a += 2 * k;
k -= k;
}
printf("%" PRIuFAST32 "\n", a);
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int SQRT = 500;
vector<pair<int, int> > quer[SQRT];
int n, m, k;
int arr[MAXN];
int num[(1 << 20) + 5];
long long ans = 0;
map<pair<int, int>, long long> an;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
for (int g = 1; g <= n; g++) cin >> arr[g];
for (int g = 1; g <= n; g++) arr[g] = arr[g] ^ arr[g - 1];
vector<pair<int, int> > qu;
for (int g = 0; g < m; g++) {
int a, b;
cin >> a >> b;
a--;
qu.push_back(pair<int, int>(a, b));
quer[a / SQRT].push_back(pair<int, int>(a, b));
}
for (int g = 0; g < SQRT; g++) {
if (quer[g].size() == 0) continue;
ans = 0;
for (int y = 1; y <= n; y++) num[arr[y]] = 0;
stable_sort(quer[g].begin(), quer[g].end(), cmp);
int l = quer[g][0].first, r = quer[g][0].first;
num[arr[l]]++;
for (pair<int, int>& y : quer[g]) {
for (int z = r + 1; z <= y.second; z++) {
ans += num[arr[z] ^ k];
num[arr[z]]++;
}
for (int z = l - 1; z >= y.first; z--) {
ans += num[arr[z] ^ k];
num[arr[z]]++;
}
for (int z = l; z < y.first; z++) {
num[arr[z]]--;
ans -= num[arr[z] ^ k];
}
for (int z = r; z > y.second; z--) {
num[arr[z]]--;
ans -= num[arr[z] ^ k];
}
an[pair<int, int>(y.first, y.second)] = ans;
l = y.first, r = y.second;
}
}
for (int t = 0; t < qu.size(); t++) cout << an[qu[t]] << '\n';
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
return;
}
vector<bool> isPrime(n + 1, true);
isPrime[0] = isPrime[1] = false;
for (long long i = 2; i * i <= n; i++) {
if (isPrime[i]) {
for (long long j = i * i; j <= n; j += i) isPrime[j] = false;
}
}
vector<long long> ans;
for (int i = 1; i <= n; i++) {
if (isPrime[i]) {
long long q = 1;
while ((q * i) <= n) {
q *= i;
ans.push_back(q);
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int res = 0;
int neg;
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9' || ch == '-') {
if (ch == '-')
neg = -1;
else
neg = 1, res = ch - '0';
break;
}
}
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9')
res *= 10, res += ch - '0';
else
break;
}
return res * neg;
}
const int maxn = 3020;
const int maxm = 1020;
const int MOd = 1e9 + 7;
int a, b;
int dn[maxn][maxn];
char ar[maxn][maxn];
int add(int &a, int &b) { return a + b >= MOd ? a + b - MOd : a + b; }
long long f(int b1, int b2, int e1, int e2) {
for (int i = 1; i <= a; i++)
for (int j = 1; j <= b; j++) dn[i][j] = 0;
for (int i = e1; i >= b1; i--)
for (int j = e2; j >= b2; j--) {
if (ar[i][j] == '#') continue;
if (i == e1 && j == e2)
dn[i][j] = 1;
else
dn[i][j] = add(dn[i][j + 1], dn[i + 1][j]);
}
return (long long)dn[b1][b2];
}
int main() {
scanf("%d %d", &a, &b);
for (int i = 1; i <= a; i++) scanf(" %s", ar[i] + 1);
long long t = (long long)f(1, 2, a - 1, b) * f(2, 1, a, b - 1);
long long t2 = (long long)f(1, 2, a, b - 1) * f(2, 1, a - 1, b);
t %= MOd;
t2 %= MOd;
t -= t2;
if (t < 0) t += MOd;
cout << t << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
vector<int> c(100001);
vector<vector<int> > g(100001);
vector<int> color(100001);
vector<int> ans(100001, 1e9);
int t = 1;
void dfs(int u) {
color[u] = t;
ans[t] = min(ans[t], c[u]);
for (auto i : g[u])
if (color[i] == 0) dfs(i);
}
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> c[i];
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; ++i)
if (color[i] == 0) {
dfs(i);
++t;
}
long long sum = 0;
for (int i = 1; i < t; ++i) sum += ans[i];
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, arr[200005];
cin >> n;
if (n % 2 == 0)
cout << -1 << endl;
else {
for (i = 0; i < n; i++) cout << i << " ";
cout << endl;
for (i = 0; i < n; i++) cout << i << " ";
cout << endl;
for (i = 0; i < n; i++) cout << (2 * i) % n << " ";
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x, y, a[10000], sum = 0, b[1000], n, mx, mnloc, mxloc, one = 0, answer,
l = 1, ans = 0, one2 = 0;
int main() {
cin >> x;
for (int i = 0; i < x; i++) {
cin >> n;
if (n == 1) {
one++;
if (mx > 0) mx -= 1;
} else {
mx += 1;
if (mx > answer) answer = mx;
}
}
if (one != x)
cout << one + answer;
else
cout << x - 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, i;
string s;
cin >> n >> k >> s;
if (n == 1 && k != 0) {
cout << 0 << "\n";
return 0;
}
if (s[0] != '1' && k != 0) {
s[0] = '1';
k--;
}
for (i = 1; i < n; i++) {
if (k == 0) break;
if (s[i] != '0') {
s[i] = '0';
k--;
}
}
cout << s << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2005][2005];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, s = 0;
cin >> n >> k;
for (long long i = 1; i <= n; i++) dp[1][i] = 1;
for (long long i = 2; i <= k; i++) {
for (long long j = 1; j <= n; j++) {
for (long long l = j; l <= n; l += j) {
dp[i][l] += dp[i - 1][j];
dp[i][l] %= 1000000007;
}
}
}
for (long long i = 1; i <= n; i++) s += dp[k][i];
cout << s % 1000000007;
}
| 6 |
#include <bits/stdc++.h>
long long int precom[5005][5005];
long long int dp[5005];
int main() {
memset(precom, 0, sizeof precom);
int n, f = 0;
scanf("%d", &n);
char inp[n + 5];
precom[1][1] = 1;
long long int ans = 0, flag = 0;
for (int a = 0; a < n; a++) {
getchar();
scanf("%c", &inp[a]);
}
int cntf = 1;
for (int a = 1; a < n; a++) {
if (inp[a - 1] == 'f') {
cntf++;
for (int b = 1; b <= a + 1; b++) {
precom[a + 1][b] = precom[a][b - 1];
}
} else {
for (int b = cntf; b >= 1; b--) {
if (b == cntf)
precom[a + 1][b] = precom[a][b];
else
precom[a + 1][b] = precom[a + 1][b + 1] + precom[a][b];
precom[a + 1][b] %= 1000000007;
}
}
}
for (int a = 1; a <= n; a++) {
ans += precom[n][a];
ans %= 1000000007;
}
printf("%I64d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
using vll = vector<ll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
void buff() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
constexpr ll MOD = 1e9 + 7;
inline ll pow_mod(ll a, ll b, ll mod = MOD) {
ll res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
}
return res;
}
template <typename T>
inline void remin(T& x, const T& y) {
x = min(x, y);
}
template <typename T>
inline void remax(T& x, const T& y) {
x = max(x, y);
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
string sep;
for (const auto& x : v) os << sep << x, sep = ", ";
return os << "}";
}
template <typename T, size_t size>
ostream& operator<<(ostream& os, const array<T, size>& arr) {
os << "{";
string sep;
for (const auto& x : arr) os << sep << x, sep = ", ";
return os << "}";
}
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
set<pair<int, int> > lightning, fire;
set<pair<int, int> > large_k;
int count_top_L = 0;
long long sum_top = 0;
long long sum_top_L = 0;
long long total_sum = 0;
inline pii maior(const pii& a, const pii& b) {
if (a.first > b.first) return a;
return b;
}
int main() {
buff();
int n;
cin >> n;
int K = 0;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
if (y < 0) y = -y;
if (x == 1) {
if (large_k.find(make_pair(y, x)) != large_k.end()) {
sum_top -= y;
sum_top_L -= y;
total_sum -= y;
count_top_L--;
large_k.erase(make_pair(y, x));
--K;
} else if (lightning.count(make_pair(y, x)) == 1) {
lightning.erase(make_pair(y, x));
--K;
auto B = *(large_k.begin());
if (B.second == 1) {
lightning.insert(B);
sum_top -= B.first;
sum_top_L -= B.first;
count_top_L--;
} else {
fire.emplace(B);
sum_top -= B.first;
}
large_k.erase(large_k.begin());
total_sum -= y;
} else {
++K;
lightning.emplace(y, x);
total_sum += y;
if (fire.empty()) {
auto L = *(lightning.rbegin());
sum_top += L.first;
sum_top_L += L.first;
count_top_L++;
lightning.erase(L);
large_k.insert(L);
} else {
auto F = *(fire.rbegin());
auto L = *(lightning.rbegin());
if (L.first > F.first) {
sum_top += L.first;
sum_top_L += L.first;
count_top_L++;
lightning.erase(L);
large_k.insert(L);
} else {
large_k.insert(F);
sum_top += F.first;
fire.erase(F);
}
}
}
} else {
if (large_k.count(make_pair(y, x)) == 1) {
sum_top -= y;
total_sum -= y;
large_k.erase(make_pair(y, x));
pii best = make_pair(-1, 13);
if (!fire.empty()) best = maior(best, *(fire.rbegin()));
if (!lightning.empty()) best = maior(best, *(lightning.rbegin()));
if (best.second == 0) {
large_k.insert(best);
sum_top += best.first;
fire.erase(best);
} else if (best.second == 1) {
large_k.insert(best);
sum_top += best.first;
sum_top_L += best.first;
count_top_L++;
lightning.erase(best);
}
} else if (fire.count(make_pair(y, x)) == 1) {
total_sum -= y;
fire.erase(make_pair(y, x));
} else {
fire.emplace(y, x);
total_sum += y;
if (K > 0) {
auto SMALL = *(large_k.begin());
if (y > SMALL.first) {
sum_top += y;
sum_top -= SMALL.first;
if (SMALL.second == 1) {
sum_top_L -= SMALL.first;
count_top_L--;
}
large_k.erase(SMALL);
if (SMALL.second == 1)
lightning.insert(SMALL);
else
fire.insert(SMALL);
large_k.emplace(y, x);
fire.erase(make_pair(y, x));
}
}
}
}
long long resp = total_sum;
long long inc = 0ll;
;
;
;
if (K > 0) {
;
;
if (count_top_L == K) {
inc += sum_top;
inc -= large_k.begin()->first;
auto PAR = make_pair(-1, 13);
if (!fire.empty()) PAR = maior(PAR, *(fire.rbegin()));
if (!lightning.empty()) PAR = maior(PAR, *(lightning.rbegin()));
if (PAR.first != -1) inc += PAR.first;
} else {
inc += sum_top;
}
};
;
cout << resp + inc << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) {
return (a.first < b.first) || (a.first == b.first && a.second > b.second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
int m;
cin >> m;
vector<int> pos[26];
for (int i = 0; i < n; i++) pos[s[i] - 'a'].push_back(i + 1);
while (m--) {
string a;
cin >> a;
vector<int> x1(26, 0);
for (int i = 0; i < a.length(); i++) x1[a[i] - 'a']++;
int ans = -1;
for (int i = 0; i < 26; i++) {
if (x1[i] > 0) ans = max(ans, pos[i][x1[i] - 1]);
}
cout << ans << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 + 100;
vector<int> ans[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, col = 10000;
cin >> n >> m;
for (int i = (int)0; i < (int)m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
ans[u].push_back(col);
ans[v].push_back(col);
--col;
}
for (int i = (int)0; i < (int)n; ++i) {
ans[i].push_back(1 + i);
cout << ans[i].size() << '\n';
for (auto x : ans[i]) {
cout << 1 + i << " " << x << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
int a[200005];
long long f[200005];
long long pot(long long first, long long second) {
if (second == 0) return 1;
long long sol = pot(first, second / 2);
sol = (sol * sol) % MOD;
if (second % 2) sol = (sol * first) % MOD;
return sol;
}
long long div_(long long first, long long second) {
return first * pot(second, MOD - 2) % MOD;
}
long long fact(long long first) {
if (first == 0) return 1;
if (f[first] != -1) return f[first];
return f[first] = first * fact(first - 1) % MOD;
}
long long choose(long long first, long long second) {
return div_(fact(first), fact(first - second) * fact(second) % MOD);
}
int main() {
memset(f, -1, sizeof f);
long long n, k;
scanf("%I64d%I64d", &n, &k);
long long second = 0;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
if (i and a[i - 1] == a[i]) second++;
}
if (a[0] == a[n - 1]) second++;
if (n == second) {
printf("0\n");
return 0;
}
long long first = n - second;
long long br = 0;
for (long long p = 0; p <= first / 2; p++) {
br = (br + choose(first, p) * choose(first - p, p) % MOD *
pot(k - 2, first - p - p) % MOD * pot(k, second)) %
MOD;
}
printf("%I64d\n", div_((MOD + pot(k, n) - br) % MOD, 2));
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, c;
c = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
for (i = 1; i < n - 1; i++) {
if (a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1) {
a[i + 1] = 0;
c++;
}
}
cout << c;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[210], b[210];
long long dp[210][10010];
long long n, m, x, ans;
void djj_lxy() {
ios::sync_with_stdio(false);
cin.tie(0);
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
cin >> n >> m;
for (register long long i = 1; i <= n; i++) {
cin >> x;
while (x % 2 == 0) x /= 2, a[i]++;
while (x % 5 == 0) x /= 5, b[i]++;
}
for (register long long i = 1; i <= n; i++)
for (register long long j = m; j >= 0; j--)
for (register long long k = 10000; k >= 0; k--)
if (j >= 1 && k >= b[i] && dp[j - 1][k - b[i]] != -1)
dp[j][k] = max(dp[j][k], dp[j - 1][k - b[i]] + a[i]);
for (register long long i = 0; i <= 10000; i++)
ans = max(ans, min(i, dp[m][i]));
cout << ans;
}
signed main() { djj_lxy(); }
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[6] = {1, 2, 3, 4, 5, 6};
int a, b;
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
cin >> a >> b;
for (int i = 0; i < 6; i++) {
if (abs(arr[i] - a) == abs(arr[i] - b)) {
cnt2 += 1;
}
if (abs(arr[i] - a) < abs(arr[i] - b)) {
cnt1 += 1;
}
if (abs(arr[i] - a) > abs(arr[i] - b)) {
cnt3 += 1;
}
}
cout << cnt1 << " " << cnt2 << " " << cnt3 << endl;
return 0;
}
| 0 |
//2021 April 10 RAJIV HARLALKA
#include <bits/stdc++.h>
#define ll long long
#define en "\n"
#define f first
#define s second
#define pb push_back
#define fast ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;
int main() {
fast
ll t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
vector<ll> v(n);
ll sum=0;
ll a,b;
map<ll,ll> m;
for(ll i=0;i<n;i++)
{
cin>>v[i];
if(i==0)
{
a=v[i];
m[a]++;
}
if(v[i]!=a)
{
b=v[i];
m[b]++;
}
else
m[a]++;
}
if(m[a]>m[b])
{
for(ll i=0;i<n;i++)
{
if(v[i]==b)
{cout<<i+1<<"\n";break;}
}
}
else
{for(ll i=0;i<n;i++)
{
if(v[i]==a)
{cout<<i+1<<"\n";break;}
}}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, r;
cin >> n >> m >> r;
int s = 1e4;
for (int i = 0; i < n; i++) {
int inp;
cin >> inp;
s = min(s, inp);
}
int b = 0;
for (int i = 0; i < m; i++) {
int inp;
cin >> inp;
b = max(b, inp);
}
int ans = 0;
for (int i = 0; i * s <= r; i++) {
ans = max(ans, r + i * (b - s));
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int vis[200500];
int t[200500];
stack<int> s;
queue<int> a;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> t[i];
vis[t[i]]++;
a.push(t[i]);
}
int btop = 1;
while (btop <= n) {
if (!s.empty() && s.top() == btop) {
s.pop();
btop++;
} else if (!a.empty()) {
s.push(a.front());
a.pop();
} else {
if (s.empty()) {
for (int i = k; i < n; i++) t[i] = n - (i - k);
k = n, btop = n + 1;
} else {
for (int i = s.top() - 1; i >= btop; i--) {
if (!vis[i]) {
vis[i] = 1;
t[k++] = i;
} else {
cout << -1 << endl;
return 0;
}
}
btop = s.top();
}
}
}
if (!s.empty() || !a.empty() || k != n)
cout << -1 << endl;
else {
cout << t[0];
for (int i = 1; i < n; i++) cout << ' ' << t[i];
cout << endl;
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > A(55, vector<int>(2e4 + 5)), S(55, vector<int>(2e4 + 5));
vector<vector<int> > DP(2, vector<int>(2e4 + 5)), LR(2, vector<int>(2e4 + 5)),
RL(2, vector<int>(2e4 + 5));
int N, M, K;
int PS(int n, int l, int r = -1) {
if (r == -1) r = l + K - 1;
return S[n][r] - S[n][l - 1];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M >> K;
for (int r = 1; r <= N; r++) {
for (int c = 1; c <= M; c++) {
cin >> A[r][c];
S[r][c] = A[r][c] + S[r][c - 1];
}
}
int prev = 0, curr = 1;
for (int r = 1; r <= N; r++) {
for (int c = 1; c + K - 1 <= M; c++) {
int v = max(LR[prev][max(0, c - K)], RL[prev][c + K]);
int j = max(1, c - K + 1);
for (; j < c + K; j++) {
int s = PS(r, max(j, c), min(j + K - 1, c + K - 1));
v = max(v, DP[prev][j] - s);
}
LR[curr][c] = RL[curr][c] = DP[curr][c] = v + PS(r, c) + PS(r + 1, c);
}
for (int x = 1; x <= M; x++) {
LR[curr][x] = max(LR[curr][x], LR[curr][x - 1]);
RL[curr][M - x] = max(RL[curr][M - x], RL[curr][M - x + 1]);
}
swap(prev, curr);
}
cout << *max_element(DP[prev].begin(), DP[prev].end()) << endl;
return 0;
}
| 15 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define ld long double
#define pi (3.141592653589)
#define pb push_back
#define mp make_pair
#define INF 1000000000
#define MOD 1000000007
#define vll vector<ll>
#define vpll vector<pair<ll,ll> >
#define pll pair<ll>
#define ff first
#define ss second
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t;
cin>>t;
while(t--){
ll d,k;
cin>>d>>k;
ll j=k;
ll ma=0;
ll a,b;
while(d>=j)
{
a=j/k;
b=(d*d)-(j*j);
b=sqrt(b);
a+=(b/k);
if(a>ma)
ma=a;
j+=k;
}
if(ma%2)
cout<<"Ashish"<<"\n";
else
cout<<"Utkarsh"<<"\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#include <string.h>
using namespace std;
#define ar array
#define ll long long
#define pb push_back
#define fr(i,n) for(int i=0;i<n;i++)
const int MAX_N = 1e5 + 1;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll LINF = 1e18;
ll power(ll x, ll y, ll M) {ll res = 1; while (y > 0) {if (y & 1) res = (res * x) % M; y >>= 1; x = (x * x) % M;} return res % M;}
ll power(ll x, ll y) {ll res = 1; while (y > 0) {if (y & 1) res = (res * x); y >>= 1; x = (x * x);} return res;}
bool sortcol( const vector<ll>& v1, const vector<ll>& v2 ) {
return v1[0] < v2[0];
}
void sortArr(vector<pair<ll, ll> > & vp,vector<ll> v, int n)
{
for (int i = 0; i < n; ++i) {
vp.push_back(make_pair(v[i], i));
}
sort(vp.begin(), vp.end());
}
int max(int a, int b) { return (a > b)? a : b; }
int max(int a, int b, int c) { return max(max(a, b), c); }
int maxCrossingSum(int arr[], int l, int m, int h)
{
int sum = 0;
int left_sum = INT_MIN;
for (int i = m; i >= l; i--)
{
sum = sum + arr[i];
if (sum > left_sum)
left_sum = sum;
}
sum = 0;
int right_sum = INT_MIN;
for (int i = m+1; i <= h; i++)
{
sum = sum + arr[i];
if (sum > right_sum)
right_sum = sum;
}
return max(left_sum + right_sum, left_sum, right_sum);
}
int maxSubArraySum(int arr[], int l, int h)
{
if (l == h)
return arr[l];
int m = (l + h)/2;
return max(maxSubArraySum(arr, l, m),
maxSubArraySum(arr, m+1, h),
maxCrossingSum(arr, l, m, h));
}
bool isPalindrome(string str)
{
int j = str.length() - 1;
for (int i = 0; i < j; i++, j--)
{
if (str[i] != str[j])
{
return false;
}
}
return true;
}
void solve() {
string a,b;
cin>>a;
cin>>b;
if(a.length()>b.length())
{
string c=b;
b=a;
a=c;
}
string r=a;
int f=0;
int g=-1;
int l=a.length()*b.length();
while(r.length()<=l)
{
if(r.length()>=b.length())
{
fr(i,r.length())
{
// cout<<i%(b.length());
if(r[i]!=b[i%b.length()])
{
f=1;
break;
}
}
g=r.length()%b.length();
if(f==1)
break;
if(g==0)
break;
}
r+=a;
}
if(f==1 || g!=0)
cout<<-1;
else
cout<<r;
cout<<endl;
}
int main() {
ios_base::sync_with_stdio(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("error.txt", "w", stderr);
freopen("output.txt", "w", stdout);
#endif
cin.tie(0); cout.tie(0);
int tc; cin>>tc;
fr(t,tc) {
// cout<<"Case #"<<t<<": ";
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 10;
int k, m, n, tot;
int a[MAXN], ad[MAXN][2], ts[MAXN];
struct Node1 {
int idx, type, obj, val;
bool operator<(Node1 x) const {
if (obj != x.obj) return obj < x.obj;
if (type != x.type) return type < x.type;
return val > x.val;
}
} n1[MAXN];
struct Node2 {
long long num, din;
int idx;
} n2[MAXN];
struct Node3 {
int t, idx;
bool operator<(Node3 x) const { return t < x.t; }
} ans[MAXN];
bool cmp(Node2 A, Node2 B) { return A.num * B.din > A.din * B.num; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int x, y, z, i = 1; i <= m; ++i) {
scanf("%d%d%d", &x, &y, &z);
ts[i] = x;
if (x == 1) {
if (z <= a[y]) continue;
if (z > ad[y][0]) ad[y][0] = z, ad[y][1] = i;
} else if (x == 2) {
++tot;
n1[tot].idx = i;
n1[tot].obj = y;
n1[tot].type = 1;
n1[tot].val = z;
} else if (z > 1) {
++tot;
n1[tot].idx = i;
n1[tot].obj = y;
n1[tot].type = 2;
n1[tot].val = z;
}
}
for (int i = 1; i <= n; ++i)
if (ad[i][1] > 0) {
++tot;
n1[tot].idx = ad[i][1];
n1[tot].obj = i;
n1[tot].type = 1;
n1[tot].val = ad[i][0] - a[i];
}
sort(n1 + 1, n1 + 1 + tot);
if (tot <= k) k = tot;
long long tmp = 0;
for (int i = 1; i <= tot; ++i) {
if (n1[i].type == 2 || n1[i].obj != n1[i - 1].obj) tmp = 0;
if (n1[i].type == 2) {
n2[i].num = n1[i].val - 1;
n2[i].din = 1;
} else if (n1[i].obj != n1[i - 1].obj) {
tmp = a[n1[i].obj];
n2[i].num = n1[i].val;
n2[i].din = tmp;
tmp += n1[i].val;
} else {
n2[i].num = n1[i].val;
n2[i].din = tmp;
tmp += n1[i].val;
}
n2[i].idx = n1[i].idx;
}
sort(n2 + 1, n2 + 1 + tot, cmp);
for (int i = 1; i <= k; ++i) ans[i].t = ts[n2[i].idx], ans[i].idx = n2[i].idx;
sort(ans + 1, ans + 1 + k);
printf("%d\n", k);
for (int i = 1; i <= k; ++i) {
printf("%d", ans[i].idx);
if (i == k)
putchar('\n');
else
putchar(' ');
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int next, to, w;
} e[105 * 105];
bool notprime[32000 + 5];
int n, m, s, t, ans = 0, pcnt, p[3500], a[105], temp[105], x[105], y[105];
int ecnt = 1, head[105];
int tag[105];
bool visit[105];
void init() {
for (int i = 2; i <= 32000; i++) {
if (!notprime[i]) {
p[++pcnt] = i;
for (int j = i * i; j <= 32000; j += i) {
notprime[j] = 1;
}
}
}
}
inline void add(int u, int v, int w) {
e[++ecnt].to = v;
e[ecnt].next = head[u];
e[ecnt].w = w;
head[u] = ecnt;
e[++ecnt].to = u;
e[ecnt].next = head[v];
e[ecnt].w = 0;
head[v] = ecnt;
}
inline bool bfs() {
memset(tag, 0, sizeof(tag));
queue<int> q;
tag[0] = 1;
bool flag = 0;
q.push(0);
while (!q.empty()) {
int x = q.front();
q.pop();
if (x == t) flag = 1;
for (int now = head[x], v; now; now = e[now].next) {
v = e[now].to;
if (!tag[v] && e[now].w) {
tag[v] = tag[x] + 1;
q.push(v);
}
}
}
return flag;
}
int dfs(int x, int flow) {
visit[x] = 1;
if (x == t) return flow;
for (int now = head[x], v, re; now; now = e[now].next) {
v = e[now].to;
if (!visit[v] && e[now].w) {
if (re = dfs(v, min(flow, e[now].w))) {
e[now].w -= re;
e[now ^ 1].w += re;
return re;
}
}
}
visit[x] = 0;
return 0;
}
void work() {
ecnt = 1;
memset(head, 0, sizeof(head));
for (int i = 1; i <= n; i += 2) {
add(s, i, temp[i]);
}
for (int i = 2; i <= n; i += 2) {
add(i, t, temp[i]);
}
for (int i = 1; i <= m; i++) {
add(x[i], y[i], 12345678);
}
int re;
while (bfs()) {
while (re = dfs(0, 12345678)) {
ans += re;
memset(visit, 0, sizeof(visit));
}
memset(visit, 0, sizeof(visit));
}
}
int main() {
scanf("%d%d", &n, &m);
s = 0, t = n + 1;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", x + i, y + i);
if (y[i] & 1) swap(x[i], y[i]);
}
init();
for (int i = 1; i <= pcnt; i++) {
bool flag = 0;
for (int j = 1; j <= n; j++) {
temp[j] = 0;
while (!(a[j] % p[i])) {
a[j] /= p[i];
temp[j]++;
}
if (temp[j]) flag = 1;
}
if (flag) {
work();
}
}
for (int i = 1; i <= n; i++) {
if (a[i] > 1) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
temp[j] = 0;
while (!(a[j] % a[i])) {
a[j] /= a[i];
temp[j]++;
}
}
temp[i] = 1;
a[i] = 1;
work();
}
}
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
template <typename T>
inline T &read(T &x) {
register char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
register bool flag = c == '-';
x = flag ? 0 : c - '0';
while ((c = getchar()) >= '0' && c <= '9') (x *= 10) += c - '0';
if (flag) x = -x;
return x;
}
const int MAX_N = int(1e4) + 10;
struct Heap {
int len;
std::pair<long long, int> a[MAX_N];
inline void up(int x) {
int y = x >> 1;
std::pair<long long, int> tmp = a[x];
while (y && tmp < a[y]) a[x] = a[y], x = y, y = x >> 1;
a[x] = tmp;
}
inline void down(int x) {
int y = x << 1;
std::pair<long long, int> tmp = a[x];
while (y <= len) {
if (y < len && a[y + 1] < a[y]) ++y;
if (a[y] < tmp)
a[x] = a[y], x = y, y = x << 1;
else
break;
}
a[x] = tmp;
}
inline void push(const std::pair<long long, int> &x) {
a[++len] = x;
up(len);
}
inline void pop() {
a[1] = a[len--];
if (len) down(1);
}
} mice, hole;
int n, m, tot;
int v[MAX_N], h[MAX_N], c[MAX_N], a[MAX_N];
int cnt[MAX_N];
long long ans = 0LL;
int main() {
read(n), read(m);
for (int i = 1; i <= n; ++i) {
read(v[i]);
a[++tot] = v[i];
}
int sum = 0;
for (int i = 1; i <= m; ++i) {
read(h[i]), read(c[i]);
sum += c[i];
a[++tot] = h[i];
}
if (sum < n) {
printf("-1\n");
return 0;
}
std::sort(a + 1, a + tot + 1);
tot = std::unique(a + 1, a + tot + 1) - a - 1;
for (int i = 1; i <= n; ++i)
++cnt[std::lower_bound(a + 1, a + tot + 1, v[i]) - a];
for (int i = 1; i <= m; ++i)
cnt[std::lower_bound(a + 1, a + tot + 1, h[i]) - a] -= c[i];
for (int i = 1; i <= tot; ++i) {
int s = a[i], op = cnt[i];
while (op > 0) {
long long cost = (long long)INT_MAX * 10;
int ths = op;
if (hole.len && hole.a[1].first + s < cost) {
cost = hole.a[1].first + s;
ths = std::min(ths, hole.a[1].second);
if ((hole.a[1].second -= ths) == 0) hole.pop();
}
op -= ths;
ans += cost * ths;
mice.push(std::make_pair(-cost - s, ths));
}
while (op < 0) {
long long cost = 0LL;
int ths = -op;
if (mice.len && mice.a[1].first + s < cost) {
cost = mice.a[1].first + s;
ths = std::min(ths, mice.a[1].second);
if ((mice.a[1].second -= ths) == 0) mice.pop();
}
op += ths;
ans += cost * ths;
hole.push(std::make_pair(-cost - s, ths));
}
}
std::cout << ans << "\n";
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int N, M, P;
int a[200000];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<int> ans;
map<int, int> bMap;
cin >> N >> M >> P;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
for (int i = 0; i < M; i++) {
int tmp;
cin >> tmp;
bMap[tmp] += 1;
}
for (int i = 0; i < P; i++) {
int wrongAns = 0;
map<int, int> aMap;
for (int j = 0; j < M; j++) {
if (i + (long long)P * j >= N) {
wrongAns += 100;
break;
}
aMap[a[i + P * j]]++;
if (aMap[a[i + P * j]] > bMap[a[i + P * j]]) {
wrongAns++;
}
}
if (wrongAns == 0) ans.push_back(i);
for (int j = i; j + (long long)P * M < N; j += P) {
if (j + (long long)P * M >= N) break;
int pr = a[j];
aMap[pr]--;
if (aMap[pr] >= bMap[pr]) wrongAns--;
int nx = a[j + (long long)P * M];
aMap[nx]++;
if (aMap[nx] > bMap[nx]) wrongAns++;
if (wrongAns == 0) ans.push_back(j + P);
}
}
cout << ans.size() << endl;
sort(ans.begin(), ans.end());
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i] + 1;
if (i == N - 1)
cout << endl;
else
cout << " ";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e4 + 11;
const int M = 33;
using pii = pair<int, int>;
using vpii = vector<pii>;
int x[N], y[N];
int lb(int x) { return x & (-x); }
int y_comb[M];
vpii gauss(int x[], int n, int &b) {
vpii ret;
for (int i = 0; i < n; i++) {
for (int j = 0; j < b; j++)
if (lb(x[j]) & x[i]) {
x[i] ^= x[j];
ret.push_back({i, j});
}
if (x[i]) {
for (int j = 0; j < b; j++)
if (lb(x[i]) & x[j]) {
x[j] ^= x[i];
ret.push_back({j, i});
}
if (i != b) {
swap(x[i], x[b]);
ret.push_back({i, b});
ret.push_back({b, i});
ret.push_back({i, b});
}
b++;
}
}
return ret;
}
int p[M];
int cx[N];
int main() {
ios ::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i];
cx[i] = x[i];
}
for (int i = 0; i < n; i++) cin >> y[i];
int xb = 0, yb = 0;
vpii p1 = gauss(x, n, xb);
vpii p3 = gauss(y, n, yb);
bool f = true;
for (int i = 0; i < yb; i++) {
for (int j = 0; j < xb; j++)
if (lb(x[j]) & y[i]) {
y[i] ^= x[j];
y_comb[i] |= (1 << j);
}
if (y[i]) f = false;
}
if (!f) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < yb; i++) {
for (int j = 0; j < i; j++)
if (lb(y_comb[j]) & y_comb[i]) {
y_comb[i] ^= y_comb[j];
p3.push_back({i, j});
}
for (int j = 0; j < i; j++)
if (lb(y_comb[i]) & y_comb[j]) {
y_comb[j] ^= y_comb[i];
p3.push_back({j, i});
}
}
reverse(p3.begin(), p3.end());
vpii p2;
iota(p, p + xb, 0);
for (int i = 0; i < yb; i++) {
int now = y_comb[i];
for (int j = 0; j < i; j++)
if ((now >> p[j]) & 1) {
now ^= y_comb[j];
p2.push_back({i, j});
}
int l = __builtin_ctz(now);
if (p[i] != l) {
int t = -1;
for (int j = i + 1; j < xb; j++)
if (p[j] == l) t = j;
swap(p[i], p[t]);
p2.push_back({i, t});
p2.push_back({t, i});
p2.push_back({i, t});
}
for (int j = i + 1; j < xb; j++)
if ((now >> p[j]) & 1) {
p2.push_back({i, j});
now ^= (1 << p[j]);
}
}
for (int i = yb; i < xb; i++) p2.push_back({i, i});
cout << p1.size() + p2.size() + p3.size() << '\n';
for (vpii v : {p1, p2, p3}) {
for (pii p : v) cout << p.first + 1 << ' ' << p.second + 1 << '\n';
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 998244353;
int64_t powmo(int64_t a, int64_t b) {
int64_t r = 1;
for (; b; b >>= 1) {
if (b & 1) r = r * a % MOD;
a = a * a % MOD;
}
return r;
}
int64_t mdiv(int64_t a, int64_t b) { return a * powmo(b, MOD - 2) % MOD; }
bitset<300005> like;
int64_t w[300005];
int64_t ans[300005];
int64_t dp[3005][3005];
int32_t main() {
{
cin.tie(0);
ios_base::sync_with_stdio(false);
};
int64_t n, m, t, add, sub, sum;
add = sub = 0;
cin >> n >> m;
for (int64_t i = 0; i < n; i++) {
cin >> t;
like[i] = t;
}
for (int64_t i = 0; i < n; i++) {
cin >> w[i];
if (like[i])
add += w[i];
else
sub += w[i];
}
dp[0][0] = 1;
sum = add + sub;
int64_t ia, is;
ia = mdiv(1, add), is = mdiv(1, sub);
for (int64_t x = 1; x <= m; x++) {
for (int64_t i = x, j = 0; i >= 0 && j <= sub; i--, j++) {
int64_t nowsum = sum + i - j;
int64_t nowadd = add + i;
int64_t nowsub = sub - j;
dp[i][j] = 0;
if (i > 0)
dp[i][j] =
(dp[i][j] + dp[i - 1][j] * mdiv(nowadd - 1, nowsum - 1) % MOD) %
MOD;
if (j > 0)
dp[i][j] =
(dp[i][j] + dp[i][j - 1] * mdiv(nowsub + 1, nowsum + 1) % MOD) %
MOD;
}
}
int64_t sa, ss;
sa = ss = 0;
for (int64_t i = m, j = 0; i >= 0 && j <= sub; i--, j++) {
sa = (sa + i * dp[i][j]) % MOD;
ss = (ss + MOD - j * dp[i][j] % MOD) % MOD;
}
for (int64_t i = 0; i < n; i++) {
if (like[i])
cout << (w[i] + w[i] * ia % MOD * sa) % MOD << '\n';
else
cout << (w[i] + w[i] * is % MOD * ss) % MOD << '\n';
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
long a(2 * n), b(3 * m);
for (int p = 6; p <= a && p <= b; p += 6) {
if (a <= b)
a += 2;
else
b += 3;
}
if (a > b)
cout << a;
else
cout << b;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[101], b[101];
int i, l, j = 0, c = 0, k, p;
cin >> a;
l = strlen(a);
for (i = 0; i < l; i++) {
if (a[i] == 'Q' || a[i] == 'A') {
b[j] = a[i];
j++;
}
}
for (i = 0; i < j; i++) {
if (b[i] == 'Q') {
for (k = i + 1; k < j; k++) {
if (b[k] == 'A') {
for (p = k + 1; p < j; p++) {
if (b[p] == 'Q') c++;
}
}
}
}
}
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(int n) {
if (n == 1) return false;
if (n == 2) return true;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
void answer(int f) {
if (f) {
cout << "YES";
} else {
cout << "NO";
}
cout << endl;
}
long long int countSetBits(long long int n) {
long long int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
long long int factorial(long long int n) {
n = n % 1000000007;
return (n == 1 || n == 0) ? 1 : n * factorial(n - 1);
}
long long int FastExp(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return (ans % 1000000007);
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first - a.second > b.first - b.second;
}
int solvegraph(vector<long long int> adj[10001], int (&mark)[10001],
int (&val)[10001], int x) {
int k = 0;
if (mark[x] == 1) {
return val[x];
}
mark[x] = 1;
for (int i = 0; i < adj[x].size(); i++) {
k = k + solvegraph(adj, mark, val, adj[x][i]) + 1;
}
val[x] = k;
return k;
}
int solve(string str, int j) {
int a = 0;
while (str[j] <= '9' && str[j] >= '0') {
a = a * 10;
a += (str[j] - '0');
j++;
}
return a;
}
int index(string str, int j) {
int a = 0;
while (str[j] <= '9' && str[j] >= '0') {
a = a * 10;
a += (str[j] - '0');
j++;
}
return j;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int test = 1;
cin >> test;
while (test--) {
long long int n;
cin >> n;
long long int a[n], i;
long long int sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum == 0) {
cout << "NO";
cout << endl;
;
continue;
}
cout << "YES";
cout << endl;
;
sort(a, a + n);
if (sum > 0) {
for (i = 0; i < n; i++) {
cout << a[n - i - 1] << " ";
}
} else {
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
cout << endl;
;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long sum = 0;
long long n;
cin >> n;
vector<long long> arr(n), pre(2 * n + 1);
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
for (long long i = 0, k = 0; i < n; i++, k = (k + 2) % n) {
pre[i + 1] = pre[i + n + 1] = arr[k];
}
long long ans = 0;
for (long long i = 1; i <= 2 * n; i++) pre[i] += pre[i - 1];
for (long long i = n / 2 + 1; i <= 2 * n; i++) {
ans = max(ans, pre[i] - pre[i - n / 2 - 1]);
}
cout << ans << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, ns;
int n, i, num;
while (cin >> n >> s) {
for (i = 0; i < n; i++) {
if (s[i] != '0' && s[i] != '1') ns += s[i];
}
n = ns.size();
s.clear();
for (i = 0; i < n; i++) {
if (ns[i] == '4' || ns[i] == '8' || ns[i] == '6' || ns[i] == '9') {
if (ns[i] == '4') {
s += '3', s += '2', s += '2';
} else if (ns[i] == '6') {
s += '5', s += '3';
} else if (ns[i] == '8') {
s += '7', s += '2', s += '2', s += '2';
} else {
s += '7', s += '3', s += '3', s += '2';
}
} else
s += ns[i];
}
n = s.size();
sort(s.begin(), s.end());
for (i = n - 1; i >= 0; i--) {
cout << s[i];
}
cout << endl;
s.clear(), ns.clear();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[10][10];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
int idx[10] = {0, 1, 2, 3, 4, 5, 6, 7}, min1, max1, ans = (int)1e9, s1;
do {
min1 = int(1e9);
max1 = -1;
for (int i = 0; i < n; i++) {
s1 = 0;
for (int j = 0; j < k; j++) s1 = s1 * 10 + s[i][idx[j]] - '0';
min1 = min(s1, min1);
max1 = max(s1, max1);
}
ans = min(ans, max1 - min1);
} while (next_permutation(idx, idx + k));
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long sum[300005], b[300005], n, ans, k, ansi, ansj;
int search(int a) {
int left, right, mid;
left = 0;
right = n;
mid = (left + right) >> 1;
while (left < right) {
if (sum[mid] >= a) {
right = mid;
}
if (sum[mid] < a) {
left = mid + 1;
}
mid = (left + right) >> 1;
}
return left;
}
int main() {
scanf("%lld %lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &b[i]);
if (b[i] == 0) {
sum[i] = sum[i - 1] + 1;
} else {
sum[i] = sum[i - 1];
}
}
for (int i = 1; i <= n; i++) {
int x = search(sum[i] - k);
if (ans < i - x) {
ansi = x + 1;
ansj = i;
ans = i - x;
}
}
printf("%lld\n", ans);
for (int i = ansi; i <= ansj; i++) {
b[i] = 1;
}
for (int i = 1; i <= n; i++) {
printf("%lld ", b[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int x, n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
if (x % 2 != 0) {
cout << "First";
return 0;
}
}
cout << "Second";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005][3];
long long s[100005], m, n;
long long fun(long long ans) {
int l = 1, r = m, mid;
while (l <= r) {
mid = (l + r) / 2;
if (s[mid] >= ans && s[mid - 1] < ans)
return mid;
else if (s[mid] < ans)
l = mid + 1;
else
r = mid - 1;
}
return mid;
}
long long findres(long long res) {
long long p = fun(res);
if (a[p][0] == 1) return a[p][1];
long long w = p;
p = res - s[p - 1];
p = p % a[w][1];
if (p == 0) p = a[w][1];
return findres(p);
}
int main() {
while (cin >> m) {
int i;
memset(a, 0, sizeof(a));
memset(s, 0, sizeof(s));
for (i = 1; i <= m; i++) {
cin >> a[i][0];
if (a[i][0] == 1) {
cin >> a[i][1];
if (i == 1)
s[i] = 1;
else
s[i] = s[i - 1] + 1;
} else {
cin >> a[i][1] >> a[i][2];
s[i] = s[i - 1] + a[i][1] * a[i][2];
}
}
cin >> n;
long long res;
for (i = 0; i < n; i++) {
cin >> res;
cout << findres(res) << " ";
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int pows[1000100];
long long int phi[1000010];
void init() {
for (int i = 0; i < 1000010; ++i) {
phi[i] = i;
}
for (int i = 2; i < 1000010; ++i) {
if (phi[i] == i) {
for (int j = i; j < 1000010; j += i) {
phi[j] -= phi[j] / i;
}
}
}
}
long long int modp(long long int a, long long int n, long long int m) {
long long int r = 1;
while (n) {
if (n & 1) r = (r * a) % m;
a = (a * a) % m;
n >>= 1;
}
return r;
}
map<long long int, int> mark;
int main(void) {
init();
long long int a, b, p, x;
cin >> a >> b >> p >> x;
pows[0] = 1;
for (int i = 1; i < p; ++i) {
pows[i] = (pows[i - 1] * a);
if (pows[i] >= p) pows[i] %= p;
}
long long int ans = 0;
long long int N = p * (p - 1);
long long int n1 = p, n2 = p - 1;
long long int y1 = p - 1, y2 = p;
long long int z1 = modp(y1, phi[n1] - 1, n1), z2 = modp(y2, phi[n2] - 1, n2);
for (int i = 0; i < p; ++i) {
long long int a1 = (b * modp(pows[i], p - 2, p)) % p;
long long int a2 = i;
long long int an = (a1 * y1 * z1 + a2 * y2 * z2) % N;
if (mark[an]) continue;
mark[an] = 1;
if (an > x) continue;
ans += x / N;
if (an <= x % N) ++ans;
}
cout << ans << '\n';
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int n;
bool vis[220000];
int dcmp(double x) {
if (fabs(x) < eps) return 0;
return x < 0 ? -1 : 1;
}
struct Point {
double x, y;
int id;
Point() {}
Point(double _x, double _y, int _z) : x(_x), y(_y), id(_z) {}
Point operator-(const Point& b) const { return Point(x - b.x, y - b.y, 0); }
double operator*(const Point& b) const { return (x * b.y - y * b.x); }
double operator^(const Point& b) const { return (x * b.x + y * b.y); }
bool operator<(const Point& b) const {
if (dcmp(x - b.x) == 0) return y < b.y;
return x < b.x;
}
} p[220000], stk[220000];
int Graham(int n) {
sort(p, p + n);
int top = 0;
for (int i = 0; i < n; i++) {
if (i && !dcmp(p[i].x - p[i - 1].x)) continue;
while (top > 1 &&
dcmp((stk[top - 1] - stk[top - 2]) * (p[i] - stk[top - 2])) < 0)
top--;
stk[top++] = p[i];
}
return top;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
double x, y;
scanf("%lf%lf", &x, &y);
x = 10000 / x;
y = 10000 / y;
p[i] = {x, y, i};
}
int top = Graham(n);
for (int i = 0; i < top; i++) {
if (!i || dcmp(stk[i].y - stk[i - 1].y) < 0) vis[stk[i].id] = 1;
}
for (int i = 0; i < n; i++) {
if (i && !dcmp(p[i].x - p[i - 1].x) && !dcmp(p[i].y - p[i - 1].y) &&
vis[p[i - 1].id])
vis[p[i].id] = 1;
}
for (int i = 0; i < n; i++) {
if (vis[i]) printf("%d ", i + 1);
}
return 0;
}
| 18 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.