solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("unroll-all-loops")
using namespace std;
const long long INF = (long long)1e18;
const long long MAXN = (long long)1e7;
const long long MOD = (long long)1e9 + 7;
const long double EPS = (long double)1e-12;
long long power(long long x, long long n, long long mod = 1e9 + 7) {
if (n == 0) return 1ll;
if (n & 1ll) return power(x, n - 1ll, mod) * x % mod;
long long tmp = power(x, n >> 1ll, mod);
return (tmp * tmp) % mod;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long g = gcd(b % a, a, x, y);
long long y0 = y;
long long x0 = x;
x = y0 - (b / a) * x0;
y = x0;
return g;
}
signed main() {
iostream::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(NULL));
vector<long long> calc(MAXN);
long long M = 1e6;
calc[0] = 1;
for (long long i = 1; i <= M; i++) {
calc[i] = (calc[i - 1] * 2) % MOD;
}
long long n;
cin >> n;
vector<long long> input(MAXN, 0);
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
input[x]++;
}
for (long long i = 1; i <= M; i++) {
for (long long j = i * 2; j <= M; j += i) {
input[i] += input[j];
}
}
for (long long i = 1; i <= M; i++) {
if (input[i] == 0) continue;
input[i] = (calc[input[i] - 1] * input[i]) % MOD;
}
long long ans = 0;
for (long long i = M; i > 1; i--) {
for (long long j = 2 * i; j <= M; j += i)
input[i] = (input[i] + MOD - input[j]) % MOD;
ans += input[i] * i;
ans %= MOD;
}
cout << ans % MOD << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
long long a, b, lcm, cnt = 0, pre = 0, ai = 1, bi = 1;
cin >> a >> b;
lcm = a * b / gcd(a, b);
while (a * ai != lcm || b * bi != lcm) {
if (a * ai < b * bi) {
cnt += (a * ai) - pre;
pre = a * ai;
++ai;
} else {
cnt -= (b * bi) - pre;
pre = b * bi;
++bi;
}
}
if (a > b) {
cnt += lcm - pre;
} else {
cnt -= lcm - pre;
}
if (cnt > 0)
puts("Dasha");
else if (cnt < 0)
puts("Masha");
else
puts("Equal");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long used[1000];
long long ans = 1;
vector<vector<long long> > g(1000);
void dfs(int v, int p = -1) {
used[v] = 1;
if (p != -1) {
ans *= 2;
}
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to]) {
dfs(to, v);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i < n + 1; i++) {
if (!used[i]) {
dfs(i);
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> n >> t;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
t -= 86400 - a[i];
if (t <= 0) {
cout << i + 1;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
vector<pair<long double, int> > v;
bool cmp(const pair<long double, int> &a, const pair<long double, int> &b) {
if (fabs(a.first - b.first) < 1e-9) {
return false;
}
return a.first < b.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
vector<int> L, R;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'l') {
L.push_back(i + 1);
} else {
R.push_back(i + 1);
}
}
for (int i = 0; i < (int)R.size(); i++) {
cout << R[i] << "\n";
}
for (int i = (int)L.size() - 1; i >= 0; i--) {
cout << L[i] << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
constexpr long long MAX = 5100000;
constexpr long long INF = 1LL << 62;
constexpr int inf = 1000000007;
constexpr long long mod = 998244353LL;
const long double PI = acos(-1);
using namespace std;
struct BIT {
int N;
vector<long long> node;
BIT() {}
BIT(int M) {
node = vector<long long>(M + 1, 0);
N = M;
}
long long sum1(int i) {
long long s = 0;
while (i > 0) {
s += node[i];
i -= i & -i;
}
return s;
}
long long sum1(int i, int j) {
long long l = sum1(i - 1);
long long r = sum1(j);
return r - l;
}
void add1(int i, long long x) {
while (i <= N) {
node[i] += x;
i += i & -i;
}
}
long long sum(int left, int right) {
if (left >= right) return 0;
return sum1(left + 1, right);
}
void add(int i, long long x) { add1(i + 1, x); }
int lower_bound(long long x) {
int ret = 0;
int k = 1;
while (2 * k <= N) k <<= 1;
for (; k > 0; k >>= 1) {
if (ret + k <= N and node[ret + k] < x) {
x -= node[ret + k];
ret += k;
}
}
return ret;
}
};
int cnv(char c) {
if (c == 'A') return 0;
if (c == 'T') return 1;
if (c == 'G') return 2;
if (c == 'C') return 3;
}
BIT vvb[4][10][10];
string s;
void solve() {
int t;
cin >> t;
if (t == 1) {
int x;
char c;
cin >> x >> c;
x--;
int bf = cnv(s[x]);
int af = cnv(c);
s[x] = c;
for (int j = 1; j <= 10; j++) {
vvb[bf][j - 1][x % j].add(x / j, -1);
vvb[af][j - 1][x % j].add(x / j, 1);
}
} else {
int l, r;
string e;
cin >> l >> r >> e;
l--;
r--;
long long res = 0;
while (e.size() > (r - l + 1)) e.pop_back();
int sz = e.size();
for (int i = 0; i < e.size(); i++) {
int idx = (l + i) % sz;
res += vvb[cnv(e[i])][sz - 1][idx].sum((l - idx + sz - 1) / sz,
(r - idx) / sz + 1);
}
cout << res << "\n";
}
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cin >> s;
int n = s.size();
for (int i = 0; i < 4; i++)
for (int j = 0; j < 10; j++)
for (int k = 0; k <= j; k++) vvb[i][j][k] = BIT(n / (j + 1) + 1);
for (int i = 0; i < s.size(); i++) {
for (int j = 1; j <= 10; j++) {
vvb[cnv(s[i])][j - 1][i % j].add(i / j, 1);
}
}
int kkt;
cin >> kkt;
while (kkt--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
void level(vector<vector<int64_t>>& adj, vector<int64_t>& arr) {
int64_t i, n;
n = adj.size();
vector<bool> visited(n, false);
queue<int64_t> q;
q.push(0);
visited[0] = true;
arr[0] = 1;
while (q.size()) {
i = q.front();
for (auto v : adj[i]) {
if (visited[v]) continue;
arr[v] = arr[i] + 1;
visited[v] = true;
q.push(v);
}
q.pop();
}
}
bool dfs(vector<vector<int64_t>>& adj, vector<bool>& visited,
vector<int64_t>& arr, int64_t x, int64_t node) {
visited[node] = true;
if (arr[node] < x && arr[node] != -1) return false;
int64_t j;
if (arr[node] == -1)
j = x;
else
j = arr[node];
bool f;
for (auto v : adj[node]) {
if (visited[v]) continue;
f = dfs(adj, visited, arr, j, v);
if (!f) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int64_t i, j, k, n;
cin >> n;
vector<int64_t> arr(n), depth(n);
vector<vector<int64_t>> adj(n);
for (i = 1; i < n; ++i) {
cin >> j, --j;
adj[i].push_back(j);
adj[j].push_back(i);
}
for (i = 0; i < n; ++i) cin >> arr[i];
level(adj, depth);
bool f = true;
for (i = 0; i < n; ++i) {
if (depth[i] & 1) {
if (arr[i] == -1) {
f = false;
break;
}
} else {
if (arr[i] != -1) {
f = false;
break;
}
}
}
if (!f) {
cout << "-1\n";
return 0;
}
vector<bool> visited(n, false);
f = dfs(adj, visited, arr, 0, 0);
if (!f) {
cout << "-1\n";
return 0;
}
int64_t ans = 0;
vector<int64_t> ans1(n, 0);
ans1[0] = arr[0];
vector<int64_t> temp;
for (i = 0; i < n; ++i)
if (depth[i] % 2 == 0) temp.push_back(i);
for (i = 0; i < temp.size(); ++i) {
int64_t x = 100000000000;
j = 0;
for (auto v : adj[temp[i]]) {
if (depth[v] > depth[temp[i]]) {
j++;
x = min(x, arr[v]);
} else
k = arr[v];
}
if (j >= 1) {
ans1[temp[i]] = x - k;
for (auto v : adj[temp[i]]) {
if (depth[v] > depth[temp[i]]) ans1[v] = arr[v] - ans1[temp[i]] - k;
}
} else
ans1[temp[i]] = 0;
}
for (i = 0; i < n; ++i) ans += ans1[i];
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
inline int read() {
int x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x;
}
struct edge {
int to, next;
} e[N << 1];
int head[N], tot;
inline void add(int u, int v) {
e[++tot] = (edge){v, head[u]};
head[u] = tot;
}
int n, siz[N], son[N], col[N], Son, cnt[N], maxx, fa[N];
long long sum, ans[N];
void dfs1(int x, int ff) {
siz[x] = 1;
fa[x] = ff;
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == ff) continue;
dfs1(v, x);
siz[x] += siz[v];
if (siz[son[x]] < siz[v]) son[x] = v;
}
}
void addsum(int x, int val) {
cnt[col[x]] += val;
if (cnt[col[x]] > maxx)
maxx = cnt[col[x]], sum = col[x];
else if (cnt[col[x]] == maxx)
sum += col[x];
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == Son || v == fa[x]) continue;
addsum(v, val);
}
}
void dfs2(int x, int op) {
for (int i = head[x]; i; i = e[i].next) {
int v = e[i].to;
if (v == fa[x] || v == son[x]) continue;
dfs2(v, 0);
}
if (son[x]) dfs2(son[x], 1), Son = son[x];
addsum(x, 1);
Son = 0;
ans[x] = sum;
if (!op) addsum(x, -1), sum = 0, maxx = 0;
}
int main() {
n = read();
int u, v;
for (int i = 1; i <= n; ++i) col[i] = read();
for (int i = 1; i < n; ++i) {
u = read();
v = read();
add(u, v);
add(v, u);
}
dfs1(1, 0);
dfs2(1, 0);
for (int i = 1; i <= n; ++i) printf("%lld ", ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long double x, y;
} nod[100000 + 10];
int n;
const long double eps = 1e-10;
long double f(long double x) {
long double r = 0;
for (int i = 0; i < n; i++) {
long double xx = ((nod[i].x - x) * (nod[i].x - x) + (nod[i].y * nod[i].y));
xx /= nod[i].y;
xx /= 2.0;
r = max(xx, r);
}
return r;
}
const long double h1 = (3.0 - sqrt(5)) / 2.0;
const long double h2 = (sqrt(5) - 1.0) / 2.0;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> nod[i].x >> nod[i].y;
}
int zheng = 0;
int fu = 0;
for (int i = 0; i < n; i++) {
if (nod[i].y > 0)
zheng++;
else
fu++;
}
if (min(zheng, fu) >= 1) {
printf("-1\n");
return 0;
}
if (zheng == 0) {
for (int i = 0; i < n; i++) {
nod[i].y = -1.0 * nod[i].y;
}
}
long double l, r, mid1, mid2;
l = -100000000.0;
r = 100000000.0;
while (r - l > eps) {
mid1 = h1 * (r - l) + l;
mid2 = h2 * (r - l) + l;
if (f(mid2) < f(mid1)) {
l = mid1;
} else {
r = mid2;
}
}
printf("%.11Lf\n", f(r));
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long POW(int m, int n) {
if (n == 1) return m;
long long t = POW(m, n / 2);
t = t * t % 1000000007;
if (n % 2) t = t * m % 1000000007;
return t;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (k == 1 || k > n)
printf("%d\n", POW(m, n));
else if (k == n)
printf("%d\n", POW(m, (n + 1) / 2));
else if (k % 2)
printf("%d\n", m * m);
else
printf("%d\n", m);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e5 + 7, MOD = 1e9 + 7, INF = 1e9 + 7;
long long Phi(long long n) {
long long ret = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i) continue;
while (n % i == 0) n /= i;
ret -= ret / i;
}
if (n > 1) ret -= ret / n;
return ret;
}
long long Power(long long base, long long pow, long long mod) {
long long ret = 1;
while (pow) {
if (pow & 1) ret = ret * base % mod;
pow >>= 1;
base = base * base % mod;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, m;
cin >> n >> m;
long long W[n + 1], mod[100], Limit = 0;
mod[0] = m;
while (mod[Limit] > 1) mod[++Limit] = Phi(mod[Limit - 1]);
vector<long long> Exp[MX];
for (long long i = 2; i < MX; i++)
for (long long x = 1; x < INF; x *= i) Exp[i].push_back(x);
for (long long i = 1; i <= n; i++) cin >> W[i];
long long q;
cin >> q;
while (q--) {
long long L, R;
cin >> L >> R;
long long Ans = 1;
for (long long i = min(R, L + Limit); i >= L; i--) {
if (W[i] == 1)
Ans = 1;
else if (W[i] < MX && Exp[W[i]].size() > Ans)
Ans = Exp[W[i]][Ans];
else
Ans = Power(W[i], Ans, mod[i - L]) + mod[i - L];
}
cout << Ans % m << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
struct Snake {
int x, y, id;
ll b;
};
const int N = 2e3;
const ll M = 1e9 + 7;
int n, m, r;
vector<Snake> s;
vector<bitset<N>> adj;
ll nCk[N + 1][N + 1];
ll sum1[N + 1];
ll sum2[2 * N + 1][N + 1];
ll nck(int n_, int k_) {
if (n_ >= 0 and k_ >= 0 and k_ <= n_) return nCk[n_][k_];
return 0;
}
int dist(const Snake& a, const Snake& b) {
return max(abs(a.x - b.x), abs(a.y - b.y));
}
ll solve_2prod(int k1, int k2) {
int cnt1 = (adj[k1] & (~adj[k2])).count();
int cnt2 = (adj[k2] & (~adj[k1])).count();
int cnt12 = (adj[k1] & adj[k2]).count();
ll ans = 0;
ans += sum1[cnt12];
ans += sum2[cnt12 + cnt1][cnt2] - sum2[cnt12][cnt2];
return (ans % M + M) % M;
}
ll solve_sq(int k) {
int cnt = adj[k].count();
return sum1[cnt];
}
int main() {
cin >> n >> m >> r;
memset(nCk, 0, sizeof(nCk));
nCk[0][0] = 1;
for (int i = 1; i <= N; ++i) {
nCk[i][0] = nCk[i][i] = 1;
for (int j = 1; j <= i - 1; ++j) {
nCk[i][j] = (nCk[i - 1][j - 1] + nCk[i - 1][j]) % M;
}
}
memset(sum1, 0, sizeof(sum1));
for (int i = 1; i <= N; ++i) {
sum1[i] = (sum1[i - 1] + nck(n - i, m - 1)) % M;
}
memset(sum2, 0, sizeof(sum2));
for (int i = 1; i <= 2 * N; ++i) {
for (int j = 1; j <= N; ++j) {
sum2[i][j] = (sum2[i][j - 1] + sum2[i - 1][j] - sum2[i - 1][j - 1] +
nck(n - i - j, m - 2)) %
M;
}
}
s = vector<Snake>(n);
for (int i = 0; i < n; ++i) {
cin >> s[i].x >> s[i].y >> s[i].b;
s[i].id = i;
}
adj = vector<bitset<N>>(n);
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
if (dist(s[i], s[j]) <= r) {
adj[i][j] = adj[j][i] = 1;
}
}
}
ll ans = 0;
for (int i = 0; i < n; ++i) {
ans += solve_sq(i) * s[i].b % M * s[i].b;
ans %= M;
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
ans += 2 * solve_2prod(i, j) * s[i].b % M * s[j].b;
ans %= M;
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const long long int mxn = 1e5 + 1;
const string fuck = "fuck";
long long int a, b, mx;
void battery(long long int s) {
if (s == 1) a = min(a + 1, mx);
--b;
}
void acc() { --a; }
void solve() {
long long int n;
cin >> n >> b >> a;
mx = a;
vector<long long int> v(n);
for (auto &x : v) cin >> x;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
if (a == 0 and b == 0) {
break;
} else if (a == 0) {
battery(v[i]);
} else if (b == 0) {
acc();
} else if (v[i] == 1 && a < mx)
battery(v[i]);
else
acc();
ans++;
}
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int cse = 1;
while (cse--) {
solve();
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string grid[100], grid2[100];
void funRo(int n) {
string tm[105];
for (int col = 0; col < n; col++) {
for (int row = n - 1; row >= 0; row--) {
tm[col].push_back(grid[row][col]);
}
}
for (int i = 0; i < n; i++) {
grid[i] = tm[i];
}
return;
}
int flip(int n) {
string tm[100];
for (int row = 0; row < n; row++) {
for (int col = n - 1; col >= 0; col--) {
tm[row].push_back(grid[row][col]);
}
}
for (int i = 0; i < n; i++) {
if (grid2[i] != tm[i]) {
return 0;
}
}
return 1;
}
int main() {
int n;
while (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> grid[i];
}
for (int i = 0; i < n; i++) {
cin >> grid2[i];
}
bool ans = 0;
for (int x = 1; x <= 5; x++) {
funRo(n);
bool ck = 1;
for (int i = 0; i < n; i++) {
if (grid[i] != grid2[i]) {
ck = 0;
break;
}
}
if (ck) {
ans = 1;
break;
}
if (flip(n)) {
ans = 1;
break;
}
}
if (ans) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m;
cin >> m;
int n;
cin >> n;
if (m == n) {
cout << m << " "
<< "0";
return 0;
} else {
int b = max(m, n);
int c = min(m, n);
int x = b - c;
int z = x / 2;
cout << c << " " << z << endl;
return 0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
int color[100010];
int vis[100010];
int in[100010];
int main() {
set<long long> ss;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &color[i]), vis[color[i]] = 1;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
a = color[a];
b = color[b];
if (a == b) continue;
if (a > b) swap(a, b);
if (ss.find(a * 100007LL + b) == ss.end()) {
in[a]++;
in[b]++;
ss.insert(a * 100007LL + b);
}
}
int ans = -1;
int pos = 0;
for (int i = 1; i <= 100000; i++) {
if (vis[i] && ans < in[i]) ans = in[i], pos = i;
}
printf("%d\n", pos);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5007, inf = 1 << 30;
int cnt[N], minn[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, a, b, res;
cin >> n >> m;
for (int i = 1; i <= n; i++) minn[i] = inf;
for (int i = 0; i < m; i++) {
cin >> a >> b;
cnt[a]++;
minn[a] = min(minn[a], (b - a + n) % n);
}
for (int i = 1; i <= n; i++) {
res = 0;
for (int j = 1; j <= n; j++) {
if (cnt[j]) res = max(res, n * (cnt[j] - 1) + (j - i + n) % n + minn[j]);
}
cout << res << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int maxn = 200010;
const long long Mod = 1000000007;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
;
int t;
int n;
long long a, b, c;
cin >> t;
while (t--) {
cin >> a >> b >> c;
if (a >= c) {
cout << -1 << ' ';
} else {
cout << 1 << ' ';
}
if (a * b <= c) {
cout << -1 << endl;
} else
cout << b << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct name {
long long a, b, h;
} p[100005];
long long n, ans, flag;
stack<int> st;
int cmp(name x, name y) {
if (x.b == y.b) return x.a > y.a;
return x.b > y.b;
}
int does(int x) {
if (st.empty()) return 1;
if (p[st.top()].a >= p[x].b) return 0;
return 1;
}
int main() {
ans = 0;
flag = 0;
scanf("%lld", &n);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", &p[i].a, &p[i].b, &p[i].h);
sort(p + 1, p + n + 1, cmp);
for (int i = 1; i <= n; i++) {
while (!does(i)) {
int ha = st.top();
flag -= p[ha].h;
st.pop();
}
st.push(i);
flag += p[i].h;
ans = max(ans, flag);
}
printf("%lld", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n % 3 != 0) {
puts("0");
return 0;
}
n /= 3;
vector<long long int> d;
for (long long int x = 1; x * x <= n; x++)
if (n % x == 0) {
d.push_back(x);
d.push_back(n / x);
}
sort(d.begin(), d.end());
d.resize(unique(d.begin(), d.end()) - d.begin());
int cnt = d.size();
int ans = 0;
for (int i = 0; i < cnt; i++) {
for (int j = i; j < cnt; j++) {
long long int z = n / d[i];
if (z % d[j] != 0) continue;
z /= d[j];
long long int x = d[i], y = d[j];
if (y > z) continue;
if (x - y + z >= 0 && (x - y + z) % 2 == 0) {
long long int b = (x - y + z) / 2;
long long int a = x - b;
long long int c = y - a;
if (a > 0 && b > 0 && c > 0) {
if (a == b && b == c)
ans++;
else if (a == b)
ans += 3;
else if (b == c)
ans += 3;
else
ans += 6;
}
}
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int t, n, k, x, maxnum;
int main() {
cin >> t;
while (t--) {
maxnum = -1000;
bool flag = false;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> k;
if (k == x) flag = true;
maxnum = max(maxnum, k);
}
if (flag)
cout << 1 << endl;
else
cout << max(2, (maxnum + x - 1) / maxnum) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int d[100010], a[100010];
vector<int> vec[100010];
priority_queue<int> q;
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
int i, j;
memset(d, 0, sizeof(d));
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
d[u]++;
vec[v].push_back(u);
}
for (i = 1; i <= n; i++)
if (d[i] == 0) q.push(i);
for (i = n; q.size();) {
int p = q.top();
q.pop();
a[p] = i;
i--;
for (j = 0; j < vec[p].size(); j++) {
int t = vec[p][j];
d[t]--;
if (d[t] == 0) q.push(t);
}
}
for (i = 1; i < n; i++) printf("%d ", a[i]);
printf("%d\n", a[n]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
string s;
cin >> s;
for (int i = 1; i < s.size(); i++) {
if (s[i] == s[i - 1] &&
(s[i] == 'a' || s[i] == 'y' || s[i] == 'u' || s[i] == 'i')) {
s.erase(i, 1);
i--;
} else if (s[i] == s[i - 1] && s[i + 1] == s[i] &&
(s[i] == 'e' || s[i] == 'o')) {
int j = i;
while (s[j] == s[i - 1]) {
s.erase(j, 1);
}
}
}
cout << s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long INF = (long long)1e18 + 123;
const int inf = (int)2e9 + 123;
const int mod = 1e9 + 7;
using namespace std;
int n;
int t[500011], k[500011], a[100011];
void push(int v, int tl, int tr) {
if (!k[v]) return;
t[v] += k[v];
if (tl != tr) {
k[v * 2] += k[v];
k[v * 2 + 1] += k[v];
}
k[v] = 0;
}
void upd(int r, int x, int v = 1, int tl = 1, int tr = n) {
push(v, tl, tr);
if (tl > r) return;
if (tr <= r) {
k[v] += x;
push(v, tl, tr);
return;
}
int mid = (tl + tr) / 2;
upd(r, x, v * 2, tl, mid);
upd(r, x, v * 2 + 1, mid + 1, tr);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
int get(int v = 1, int tl = 1, int tr = n) {
push(v, tl, tr);
if (tl == tr) return tl;
int mid = (tl + tr) / 2;
push(v * 2 + 1, mid + 1, tr);
push(v * 2, tl, mid);
int h;
if (t[v * 2 + 1] > 0) {
h = get(v * 2 + 1, mid + 1, tr);
} else
h = get(v * 2, tl, mid);
t[v] = max(t[v * 2], t[v * 2 + 1]);
return h;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int ti, type, x;
cin >> ti >> type;
if (type == 0) {
upd(ti, -1);
} else {
cin >> x;
upd(ti, 1);
a[ti] = x;
}
if (t[1] <= 0) {
cout << -1 << endl;
} else
cout << a[get()] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
int x, y;
cin >> t;
while (t--) {
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
if (a % c == 0) x = a / c;
if (a % c != 0) x = a / c + 1;
if (b % d == 0) y = b / d;
if (b % d != 0) y = b / d + 1;
if (x + y > k) cout << "-1" << endl;
if (x + y <= k) cout << x << " " << y << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int k, a, b, v, te, s, num;
while (~scanf("%d%d%d%d", &k, &a, &b, &v)) {
if ((b + 1) * v >= a) {
te = a / v;
s = te + (te * v < a ? 1 : 0);
num = s / k;
printf("%d\n", num + (num * k < s ? 1 : 0));
} else {
num = b / k;
a -= (k * v * num);
a -= ((b - (k - 1) * num + 1) * v), num++;
te = a / v;
num += te;
printf("%d\n", num + (te * v < a ? 1 : 0));
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)(2e5 + 123);
map<int, int> pmx;
vector<int> ans[N];
int a[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int cnt = 1;
for (int i = 1; i <= n; i++) {
auto it = pmx.lower_bound(a[i]);
if (it != pmx.begin()) {
it--;
int x = (*it).second;
pmx[a[i]] = x;
pmx.erase((*it).first);
ans[x].push_back(a[i]);
} else {
pmx[a[i]] = cnt;
ans[cnt].push_back(a[i]);
cnt++;
}
}
for (int i = 1; i <= cnt; i++) {
for (int j = 0; j < ans[i].size(); j++) cout << ans[i][j] << " ";
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], n;
bool tui() {
int nd2 = n / 2, w = 2;
if (n % 4 == 0) {
for (int i = 1; i <= nd2; i += 2) {
a[i] = w, a[i + 1] = n + 2 - w;
w += 2;
}
w = nd2 - 1;
for (int i = nd2 + 1; i <= n; i += 2) {
a[i] = w, a[i + 1] = n - w, w -= 2;
}
} else if (n % 4 == 1) {
a[n / 2 + 1] = n / 2 + 1;
for (int i = 1; i <= nd2; i += 2) {
a[i] = w, a[i + 1] = n + 2 - w;
w += 2;
}
w = nd2 - 1;
for (int i = nd2 + 2; i <= n; i += 2) {
a[i] = w, a[i + 1] = n - w, w -= 2;
}
} else
return false;
return true;
}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("1\n");
return 0;
}
a[1] = 2;
if (tui()) {
for (int i = 1; i < n; ++i) printf("%d ", a[i]);
printf("%d\n", a[n]);
} else {
printf("-1\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
vector<vector<long long> > dp[4];
for (int i = 0; i < 4; i++) {
dp[i].resize(n + 1, vector<long long>(k + 1, 0));
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= k; j++) {
for (long long p = 0; p < 4; p++) {
if (i * 2 < j || j == 0) {
dp[p][i][j] = 0;
} else if (i == 1) {
if ((p == 0 || p == 3) && j == 1)
dp[p][i][j] = 1;
else if ((p == 1 || p == 2) && j == 2)
dp[p][i][j] = 1;
else
dp[p][i][j] = 0;
} else {
if (p == 0) {
dp[p][i][j] = (dp[0][i - 1][j] + dp[1][i - 1][j] + dp[2][i - 1][j] +
dp[3][i - 1][j - 1]) %
mod;
} else if (p == 1) {
dp[p][i][j] =
(dp[0][i - 1][j - 1] + dp[1][i - 1][j] + dp[3][i - 1][j - 1]) %
mod;
if (j >= 2) {
dp[p][i][j] = (dp[p][i][j] + dp[2][i - 1][j - 2]) % mod;
}
} else if (p == 2) {
dp[p][i][j] =
(dp[0][i - 1][j - 1] + dp[2][i - 1][j] + dp[3][i - 1][j - 1]) %
mod;
if (j >= 2) {
dp[p][i][j] = (dp[p][i][j] + dp[1][i - 1][j - 2]) % mod;
}
} else if (p == 3) {
dp[p][i][j] = (dp[0][i - 1][j - 1] + dp[1][i - 1][j] +
dp[2][i - 1][j] + dp[3][i - 1][j]) %
mod;
}
}
}
}
}
long long ans = 0;
for (long long p = 0; p < 4; p++) {
ans += dp[p][n][k];
ans %= mod;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, M, sx, sy;
vector<string> board;
bool vis[3003][3003];
bool can;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
void dfs(int x, int y) {
can |= (board[x % N][y % M] == 'S' && (x != sx || y != sy));
if (can || vis[x][y]) return;
vis[x][y] = true;
for (int i = 0; i < 4; i++) {
int ni = x + dx[i], nj = y + dy[i];
if (ni < 0) ni += 2 * N;
if (ni >= 2 * N) ni -= 2 * N;
if (nj < 0) nj += 2 * M;
if (nj >= 2 * M) nj -= 2 * M;
if (vis[ni][nj] || board[ni % N][nj % M] == '#') continue;
dfs(ni, nj);
}
}
int main() {
cin >> N >> M;
board.clear();
board.resize(N);
for (int i = 0; i < N; i++) cin >> board[i];
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
if (board[i][j] == 'S') {
sx = i;
sy = j;
}
dfs(sx, sy);
if (can)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
int main() {
int n;
cin >> s;
n = strlen(s);
int open = 0, close = 0, hashh = 0, i, j, hashd = 0, xx, r, boy;
for (i = 0; s[i] != '\0'; i++) {
if (s[i] == '(')
open++;
else if (s[i] == ')')
close++;
else if (s[i] == '#') {
hashh++;
}
}
xx = open - close - hashh;
if (xx < 0)
cout << -1;
else {
hashd = 0;
for (i = 0; s[i] != '\0'; i++) {
if (s[i] == '#' && hashd != (hashh - 1)) {
s[i] = ')';
hashd++;
} else if (s[i] == '#' && hashd == hashh - 1) {
s[i] = ')';
hashd++;
break;
}
}
for (j = n - 1 + xx; j >= (i + 1 + xx); j--) {
s[j] = s[j - xx];
}
s[n + xx] = '\0';
for (j = i + 1; j <= i + xx; j++) s[j] = ')';
r = 0;
boy = 0;
for (i = 0; s[i] != '\0'; i++) {
if (r < 0) {
boy = 1;
break;
} else if (s[i] == '(')
r++;
else if (s[i] == ')')
r--;
}
if (boy == 1)
cout << -1 << endl;
else {
for (i = 1; i <= hashh - 1; i++) cout << 1 << endl;
cout << xx + 1;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string str;
long long d[101][2501];
int main() {
int n, i, j, k;
d[0][0] = 1;
for (j = 1; j < 101; j++) {
for (i = 0; i < 2501; i++) {
for (k = 0; k < 26; k++) {
if (i < k) continue;
d[j][i] = (d[j][i] + d[j - 1][i - k]) % 1000000007;
}
}
}
cin >> n;
for (; n--;) {
cin >> str;
for (i = k = 0; i < (int)str.size(); i++) {
k += str[i] - 'a';
}
printf("%lld\n", d[str.size()][k] - 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int N = int(2e5);
const int INF = (2e9);
const int MOD = (1e9) + 7;
const int MAX_SIZE = 30;
int n, a[N];
std::vector<int> ans;
map<int, int> used;
int main() {
freopen("debug.txt", "w", stderr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int k = 1; k <= n; k++) {
used.clear();
bool flag = 0;
for (int i = 1; i <= n; i++) {
int pos = i % k;
int d = a[i] - a[i - 1];
if (used.find(pos) == used.end())
used[pos] = d;
else {
if (used[pos] != d) {
flag = 1;
break;
}
}
}
if (!flag) ans.push_back(k);
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int k, d;
char ak[1000], ad[1000], c = 'q';
for (int i = 0; i < 1000; i++) {
scanf("%c", &ak[i]);
if (ak[i] == '.') {
k = i;
break;
}
}
gets(ad);
d = strlen(ad);
if (ak[k - 1] == '9') {
printf("GOTO Vasilisa.");
return 0;
}
for (int i = 0; i < k - 1; i++) {
printf("%c", ak[i]);
}
if (ad[0] >= '5')
printf("%c", ak[k - 1] + 1);
else
printf("%c", ak[k - 1]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k;
long long int n;
string s, t;
map<char, char> mp;
cin >> s >> t;
for (i = 0; i < s.length(); i++) mp[s[i]] = t[i];
cin >> s;
char ch;
for (i = 0; i < s.length(); i++) {
if (isdigit(s[i])) {
cout << s[i];
continue;
}
if (mp[s[i]])
cout << mp[s[i]];
else {
if (isupper(s[i])) {
ch = mp[s[i] + 32] - 32;
cout << (ch);
} else {
ch = mp[s[i] - 32] + 32;
cout << ch;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 1e5 + 10;
int ar[MAXn], ar2[MAXn], n, ans[MAXn];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
ar2[a]++;
ans[i] = ++ar[a];
}
for (int i = 1; i < MAXn - 1; i++)
if (ar2[i] < ar2[i + 1]) return cout << -1, 0;
cout << ar2[1] << endl;
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b);
long long lcm(long long a, long long b);
int main() {
long long a, b;
cin >> a >> b;
long long c = lcm(a, b);
long long t = 1;
long long t1 = 0;
long long x = 0, y = 0;
long long k = 2;
long long d = a, e = b;
vector<long long> f;
f.push_back(0);
while (d < c) {
f.push_back(d);
d = a * k;
k++;
}
k = 2;
while (e < c) {
f.push_back(e);
e = b * k;
k++;
}
sort(f.begin(), f.end());
long long size = f.size();
for (int i = 1; i < size; i++) {
if (f[i] % a == 0) {
x += f[i] - f[i - 1];
} else if (f[i] % b == 0) {
y += f[i] - f[i - 1];
}
}
if (a > b) {
x += c - f[size - 1];
} else {
y += c - f[size - 1];
}
if (x > y) {
cout << "Dasha";
} else if (x < y) {
cout << "Masha";
} else
cout << "Equal";
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXI = 200004;
int main() {
int n;
pair<int, int> t[104];
cin >> n;
char ch;
for (int i = 0; i < n; i++) {
cin >> t[i].first >> ch >> t[i].second;
}
sort(t, t + n);
pair<int, int> maxi;
maxi.first = 0;
maxi.second = 0;
for (int i = 1; i < n; i++) {
pair<int, int> temp;
temp.first = t[i].first - t[i - 1].first;
temp.second = t[i].second - (t[i - 1].second + 1);
if (temp.second < 0) {
temp.second += 60;
temp.first -= 1;
}
if (maxi.first < temp.first) {
maxi.first = temp.first;
maxi.second = temp.second;
} else if (maxi.first == temp.first && maxi.second < temp.second) {
maxi.first = temp.first;
maxi.second = temp.second;
}
}
pair<int, int> temp;
t[0].first += 24;
temp.first = t[0].first - t[n - 1].first;
temp.second = t[0].second - (t[n - 1].second + 1);
if (temp.second < 0) {
temp.second += 60;
temp.first -= 1;
}
if (maxi.first < temp.first) {
maxi.first = temp.first;
maxi.second = temp.second;
} else if (maxi.first == temp.first && maxi.second < temp.second) {
maxi.first = temp.first;
maxi.second = temp.second;
}
if (n == 1)
cout << "23:59";
else
printf("%02d:%02d", maxi.first, maxi.second);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void IO() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
IO();
int t;
cin >> t;
while (t--) {
long long int n, c0, c1, h;
cin >> n >> c0 >> c1 >> h;
string s;
cin >> s;
long long int one = 0;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
if (s[i] == '1') {
one++;
}
}
long long int zero = n - one;
long long int mi = 1e9;
for (__typeof(n + 1) i = (0) - ((0) > (n + 1));
i != (n + 1) - ((0) > (n + 1)); i += 1 - 2 * ((0) > (n + 1))) {
long long int c = abs(one - i) + abs(zero - (n - i));
c /= 2;
long long int cost = c * h + i * c1 + (n - i) * c0;
mi = min(mi, cost);
}
cout << mi << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, q, t, x;
scanf("%d %d", &n, &q);
int k = n / 2;
int shift_a = 0;
int shift_b = 0;
int isSwap = 0;
for (int i = 0; i < q; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d", &x);
if (x & 1) {
if (x < 0) x = ((x % n) + n) % n;
swap(shift_a, shift_b);
shift_a += x - x / 2;
shift_b += x / 2;
isSwap = 1 - isSwap;
} else {
shift_a += x / 2;
shift_b += x / 2;
}
shift_a = ((shift_a % k) + k) % k;
shift_b = ((shift_b % k) + k) % k;
} else {
isSwap = 1 - isSwap;
swap(shift_a, shift_b);
}
}
vector<int> a(k);
vector<int> b(k);
if (isSwap) swap(shift_a, shift_b);
for (int i = 0; i < k; i++) {
a[(((i + shift_a) % k) + k) % k] = 2 * i + 1;
b[(((i + shift_b) % k) + k) % k] = 2 * i + 2;
}
if (isSwap == 1) swap(a, b);
for (int i = 0; i < k; i++) {
printf("%d %d ", a[i], b[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t;
int seg[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
cin >> t;
while (t--) {
int n;
cin >> n;
if (n % 2 == 0) {
int k = n / 2;
for (int i = 0; i < k; ++i) {
cout << 1;
}
} else {
cout << 7;
int k = (n / 2) - 1;
for (int i = 0; i < k; ++i) {
cout << 1;
}
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int UNDEF = -1;
const int INF = 2000000000;
const double EPS = 1e-9;
const double PI = 3.1415926535897932384626433832795;
template <typename T>
const T sqr(const T &x) {
return x * x;
}
template <typename T>
const string GetString(const T &val) {
ostringstream sout;
sout << val;
return sout.str();
}
const int MAXN = 10000 + 5;
int n, m, c;
int a[MAXN], b[MAXN];
int pref[MAXN];
void Init() {
cin >> n >> m >> c;
for (int i = 0; i < (n); ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < (m); ++i) {
scanf("%d", &b[i]);
pref[i] = b[i];
if (i) pref[i] += pref[i - 1];
}
}
int GetSum(int l, int r) {
int res = pref[r];
if (l) res -= pref[l - 1];
return res;
}
int main() {
Init();
int k = min(n - m + 1, m);
int l = 0, r = 0;
int pos = 0;
for (int i = 0; i < (k - 1); ++i) {
printf("%d ", (GetSum(l, r++) + a[pos++]) % c);
}
for (int i = 0; i < (n - 2 * (k - 1)); ++i) {
printf("%d ", (GetSum(l, r) + a[pos++]) % c);
if (r < m - 1 || i == n - 2 * (k - 1) - 1) ++l, ++r;
}
l, --r;
for (int i = 0; i < (k - 1); ++i) {
printf("%d ", (GetSum(l++, r) + a[pos++]) % c);
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 10;
int a[MAXN], m, can[MAXN];
string s;
int dp[MAXN][1 << 6], cnt[6];
bool check(int index) {
for (int mask = 0; mask < 1 << 6; ++mask) {
int have = 0;
for (int i = 0; i < 6; ++i) {
if ((mask >> i) & 1) {
have += cnt[i];
}
}
if (have < dp[index][mask]) {
return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
int n = s.length();
for (int i = 0; i < s.length(); ++i) a[i + 1] = s[i] - 'a', cnt[a[i + 1]]++;
cin >> m;
for (int i = 1; i <= m; ++i) {
int pos;
string s;
cin >> pos >> s;
for (int j = 0; j < s.length(); ++j) {
can[pos] |= 1 << (s[j] - 'a');
}
}
for (int i = 1; i <= n; ++i)
if (!can[i]) can[i] = (1 << 6) - 1;
for (int i = n; i >= 1; --i) {
for (int mask = 0; mask < 1 << 6; ++mask) {
dp[i][mask] = max(dp[i][mask], dp[i + 1][mask]);
dp[i][mask | can[i]] = max(dp[i][mask | can[i]], dp[i + 1][mask] + 1);
}
}
string rest = "";
if (!check(1)) {
cout << "Impossible\n";
return 0;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 6; ++j) {
if ((can[i] >> j) & 1)
if (cnt[j]) {
cnt[j]--;
if (!check(i + 1)) {
cnt[j]++;
} else {
rest += char('a' + j);
break;
}
}
}
}
cout << rest << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<string> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<vector<int> > dp(n, vector<int>(m + 1, 0));
for (int i = 0; i < n; i++) {
if (a[i][0] == '.') {
dp[i][0] = 1;
}
}
for (int i = 0; i < m; i++) {
if (a[0][i] == '.') {
dp[0][i] = 1;
}
}
vector<int> b(m, 0);
vector<int> p(m + 1, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i != 0 && j != 0) {
if (a[i - 1][j] != '.' && a[i][j - 1] != '.') {
b[j] = 1;
}
}
}
}
for (int i = 0; i < m; i++) {
p[i + 1] = p[i] + b[i];
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
if (p[r] - p[l] > 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int n, m, k[N];
pair<int, int> a[N];
int tmp[N];
bool check(int x) {
memcpy(tmp, k, sizeof(k));
int xx = x;
int used = 0, now = x;
for (int i = m; i >= 1; i--) {
if (a[i].first > xx) continue;
now = min(now, a[i].first);
if (tmp[a[i].second]) {
used = min(now, tmp[a[i].second]);
tmp[a[i].second] -= used;
x -= used;
now -= used;
}
}
int sum = 0;
for (int i = 1; i <= n; i++) sum += tmp[i];
return x >= 2 * sum;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> k[i];
for (int i = 1; i <= m; i++) cin >> a[i].first >> a[i].second;
sort(a + 1, a + m + 1);
int l = 0, r = N * 2, mid, ans;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, x;
cin >> n >> x;
int a[n];
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
int k1 = -1;
long long sum1 = 0;
for (int i = 0; i < n; i++) {
sum1 += a[i];
if (sum1 % x != 0 && x % sum1 != 0) k1 = i + 1;
}
int k2 = -1;
long long sum2 = 0;
for (int i = n - 1; i >= 0; i--) {
sum2 += a[i];
if (sum2 % x != 0 && x % sum2 != 0) k2 = n - i;
}
if (k1 == -1 && k2 == -1) {
cout << -1 << endl;
} else {
cout << max(k1, k2) << endl;
}
}
int main() {
int t;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unsigned int n, a, b, c, d;
unsigned int ans;
bitset<100000001> bit;
inline unsigned int f(unsigned int x) {
return a * x * x * x + b * x * x + c * x + d;
}
inline unsigned int Get(unsigned int x) {
unsigned int ret = f(x);
unsigned int tmp = 0;
for (unsigned int i = 1; i <= n / x; i *= x) {
tmp += n / (i * x);
}
return ret * tmp;
}
int main() {
while (~scanf("%u%u%u%u%u", &n, &a, &b, &c, &d)) {
ans = Get(2) + Get(3);
bit.reset();
for (unsigned int i = 5; i <= n; i++) {
if (i % 2 == 0 || i % 3 == 0) {
continue;
}
if (bit[i / 3] == 0) {
ans += Get(i);
for (unsigned int j = i; j <= n; j += i) {
if (j % 2 == 0 || j % 3 == 0) continue;
bit[j / 3] = 1;
}
}
}
printf("%u\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char grid[510][510];
int main() {
scanf("%d%d", &n, &m);
memset(grid, 0, sizeof(grid));
for (int i = 0; i < n; i++) {
scanf("%s", grid[i]);
}
int l = 1000, r = 0, u = 1000, d = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == 'X') {
l = min(l, j);
r = max(r, j);
u = min(u, i);
d = max(d, i);
}
}
}
bool flag = true;
for (int i = u; i <= d; i++) {
for (int j = l; j <= r; j++) {
if (grid[i][j] == '.') {
flag = false;
break;
}
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
string s;
cin >> s;
char c;
while (t) {
for (int i = 0; i < s.length() - 1; i++) {
if (s[i] == 'B' && s[i + 1] == 'G') {
c = s[i];
s[i] = s[i + 1];
s[i + 1] = c;
i++;
}
}
t--;
}
cout << s << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, kq;
void doc() { cin >> n; }
void xl() {
n = n * (n + 1) / 2;
kq = n * 6 + 1;
cout << kq;
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
doc();
xl();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct bData {
int openLeft, value, openRight;
bData() : openLeft(0), value(0), openRight(0) {}
bData(int l, int v, int r) : openLeft(l), value(v), openRight(r) {}
};
int log(int x) {
int output = 0;
while (x > 1) {
output++;
x /= 2;
}
return output;
}
int max(int x, int y) { return x > y ? x : y; }
bData merge(bData bd1, bData bd2) {
int dValue = min(bd1.openLeft, bd2.openRight);
int value = bd1.value + bd2.value + 2 * dValue;
return bData((bd1.openLeft - dValue) + bd2.openLeft, value,
bd1.openRight + (bd2.openRight - dValue));
}
bData merge(bData bd1, bData bd2, bData bd3) {
return merge(merge(bd1, bd2), bd3);
}
bData mergeAll(bData** data, int n, int start, int end) {
if (end <= start) {
return bData(0, 0, 0);
} else if (end - start == 1) {
return data[0][start];
} else {
int logn = log(n);
int level = logn;
int p = 1 << logn;
while (p >= 1) {
if (end / p > start / p) {
if (start % p == 0) {
return merge(data[level][start / p],
mergeAll(data, n, start + p, end));
} else if (((start / p) + 1) * p + p <= end) {
return merge(mergeAll(data, n, start, (start / p + 1) * p),
data[level][start / p + 1],
mergeAll(data, n, ((start / p) + 1) * p + p, end));
} else {
p /= 2;
level--;
}
} else {
p /= 2;
level--;
}
}
return bData(0, 0, 0);
}
}
int main() {
string str;
cin >> str;
const char* cstr = str.c_str();
int n = str.length();
int m;
cin >> m;
int l, r;
int lg = log(n) + 1;
bData** data = new bData*[lg];
for (int i = 0, p = 1; i < lg; i++, p *= 2) {
data[i] = new bData[n / p + 1];
for (int j = 0, start = 0, end = p - 1; end < n;
start += p, end = min(start + p - 1, n), j++) {
if (i == 0) {
data[0][j] = cstr[start] == '(' ? bData(1, 0, 0) : bData(0, 0, 1);
} else {
data[i][j] = merge(data[i - 1][2 * j], data[i - 1][2 * j + 1]);
}
}
}
for (int t = 0; t < m; t++) {
cin >> l;
l--;
cin >> r;
r--;
cout << mergeAll(data, n, l, r + 1).value << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, a, b, c;
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
void input_data() { cin >> l >> r; }
void process_data() {
a = -1;
for (long long i = l; i <= r - 2; i++) {
for (long long j = i + 2; j <= r; j++) {
if (gcd(i, j) == 1) continue;
for (long long k = i + 1; k < j; k++) {
if (gcd(i, k) == 1 && gcd(j, k) == 1) {
a = i;
b = k;
c = j;
break;
}
}
}
}
}
void output_data() {
if (a != -1)
cout << a << " " << b << " " << c;
else
cout << a;
}
int main() {
input_data();
process_data();
output_data();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 2e9;
const int MOD = 1e9 + 7;
const double Pi = 3.141592653589793;
const int N = 3e5 + 5;
long long c[N], v[N], g[N], a[N], n, k, s, t, m = 0, mx = 0, mn = -1, res = OO;
bool check(long long cap) {
long long time = 0;
for (int i = (int)1; i <= (int)m; i++) {
if (a[i] > cap) return false;
long long y = max(0LL, min(a[i], cap - a[i])), x = a[i] - y;
time += 2LL * x + y;
}
return (time <= t);
}
int main() {
cin >> n >> k >> s >> t;
if (s > t) {
cout << -1;
return 0;
}
for (int i = (int)1; i <= (int)n; i++) scanf("%i%i", &v[i], &c[i]);
for (int i = (int)1; i <= (int)k; i++) scanf("%i", &g[i]);
g[++k] = s;
g[++k] = 0;
sort(g + 1, g + k + 1);
for (int i = (int)2; i <= (int)k; i++)
a[++m] = g[i] - g[i - 1], mx = max(mx, a[m]);
long long l = mx, r = s * 2, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
mn = mid, r = mid - 1;
else
l = mid + 1;
}
for (int i = (int)1; i <= (int)n; i++)
if (c[i] >= mn) res = min(res, v[i]);
if (res == OO)
cout << -1;
else
cout << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
int A[100010];
int a, b;
int ans;
int main(void) {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", A + i);
scanf("%d%d", &a, &b);
sort(A + 1, A + 1 + N);
N = unique(A + 1, A + 1 + N) - A - 1;
while (a > b) {
int nxt = a - 1;
for (int i = N; i >= 1 && A[i] > a - nxt; i--) {
if (a - a % A[i] >= b && a - a % A[i] < nxt) nxt = a - a % A[i];
}
a = nxt;
ans++;
while (N && a - a % A[N] < b) N--;
}
return 0 * printf("%d", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long sum, n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
sum += a * i;
}
cout << sum << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000, M = 1000;
long long n, m, n0, m0;
long long a[N + 1][M + 1];
long long Sum[N + 1][M + 1];
long long q[N], head, tail;
long long mn1[N + 1][M + 1], mn2[N + 1][M + 1];
vector<pair<long long, long long> > ord;
long long cst[N + 1][M + 1];
long long calc_cst(long long x, long long y) {
return Sum[x + n0 - 1][y + m0 - 1] - Sum[x - 1][y + m0 - 1] -
Sum[x + n0 - 1][y - 1] + Sum[x - 1][y - 1] - n0 * m0 * mn2[x][y];
}
bool cmp(pair<long long, long long> x, pair<long long, long long> y) {
return cst[x.first][x.second] != cst[y.first][y.second]
? cst[x.first][x.second] < cst[y.first][y.second]
: x.first != y.first ? x.first < y.first
: x.second < y.second;
}
bool vis[N + 1][M + 1];
signed main() {
scanf("%lld%lld%lld%lld", &n, &m, &n0, &m0);
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
scanf("%lld", &a[i][j]);
Sum[i][j] = Sum[i - 1][j] + Sum[i][j - 1] - Sum[i - 1][j - 1] + a[i][j];
}
for (long long i = 1; i <= n; i++) {
head = tail = 0;
for (long long j = 1; j < m0; j++) {
while (head < tail && a[i][q[tail - 1]] >= a[i][j]) tail--;
q[tail++] = j;
}
for (long long j = 1; j + m0 - 1 <= m; j++) {
while (head < tail && q[head] < j) head++;
while (head < tail && a[i][q[tail - 1]] >= a[i][j + m0 - 1]) tail--;
q[tail++] = j + m0 - 1;
mn1[i][j] = a[i][q[head]];
}
}
for (long long j = 1; j + m0 - 1 <= m; j++) {
head = tail = 0;
for (long long i = 1; i < n0; i++) {
while (head < tail && mn1[q[tail - 1]][j] >= mn1[i][j]) tail--;
q[tail++] = i;
}
for (long long i = 1; i + n0 - 1 <= n; i++) {
while (head < tail && q[head] < i) head++;
while (head < tail && mn1[q[tail - 1]][j] >= mn1[i + n0 - 1][j]) tail--;
q[tail++] = i + n0 - 1;
mn2[i][j] = mn1[q[head]][j];
}
}
for (long long i = 1; i + n0 - 1 <= n; i++)
for (long long j = 1; j + m0 - 1 <= m; j++)
cst[i][j] = calc_cst(i, j), ord.push_back(make_pair(i, j));
sort(ord.begin(), ord.end(), cmp);
vector<pair<long long, long long> > ans;
for (long long i = 0; i < ord.size(); i++) {
long long x = ord[i].first, y = ord[i].second;
if (vis[x][y] || vis[x][y + m0 - 1] || vis[x + n0 - 1][y] ||
vis[x + n0 - 1][y + m0 - 1])
continue;
ans.push_back(ord[i]);
for (long long j = x; j <= x + n0 - 1; j++)
for (long long k = y; k <= y + m0 - 1; k++) vis[j][k] = true;
}
cout << ans.size() << "\n";
for (long long i = 0; i < ans.size(); i++)
printf("%lld %lld %lld\n", ans[i].first, ans[i].second,
cst[ans[i].first][ans[i].second]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int maxn = 200001;
long long int binpow(long long int a, long long int b, long long int mod) {
long long int res = 1;
while (b > 0) {
if (b % 2) {
res = (res * a) % mod;
b--;
}
a = (a * a) % mod;
b /= 2;
}
return res % mod;
}
long long int binpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b % 2) {
res = (res * a);
b--;
}
a = (a * a);
b /= 2;
}
return res;
}
bool isPrime(long long int n) {
if (n == 1) return false;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
signed main() {
long long int t = 1;
while (t--) {
long long int n;
cin >> n;
long long int ans;
long long int mx = mod;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
long long int y = ceil(1.0 * (x - i) / n) * n + i;
if (mx > y) {
mx = y;
ans = i + 1;
}
}
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int main() {
int i, j, x, n;
while (~scanf("%d", &n)) {
int a[5] = {0};
int sum = 0, ok = 0;
for (i = 0; i < n; i++) {
scanf("%d", &x);
ok += x;
a[x]++;
}
if (ok % 3 > ok / 3) {
printf("-1\n");
continue;
}
if (a[1] <= a[2]) {
sum += a[1];
a[2] -= a[1];
a[3] += a[1];
a[1] = 0;
sum += a[2] / 3 * 2;
if (a[2] % 3 == 1) {
if (a[4])
sum += 1;
else
sum += 2;
} else if (a[2] % 3 == 2)
sum += 2;
} else {
sum += a[2];
a[3] += a[2];
a[1] -= a[2];
a[2] = 0;
sum += a[1] / 3 * 2;
a[3] += a[1] / 3 * 2;
a[1] = a[1] % 3;
if (a[1] == 1) {
if (a[3])
sum += 1;
else
sum += 2;
}
if (a[1] == 2) {
sum += 2;
}
}
printf("%d\n", sum);
}
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, k, a[100050], m, mini;
long long int ans;
bool b = true;
scanf("%d %d\n", &n, &k);
scanf("%d", &a[1]);
m = a[1] % k;
for (int i = 2; i <= n; i++) {
scanf("%d", &a[i]);
if (m != a[i] % k) {
b = false;
}
}
if (!b) {
printf("-1");
} else {
mini = a[1];
for (int i = 2; i <= n; i++) {
if (mini > a[i]) {
mini = a[i];
}
}
ans = 0;
for (int i = 1; i <= n; i++) {
ans = ans + ((a[i] - mini) / k);
}
printf("%I64d", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int i, t, temp, r, temp2, rev, x;
scanf("%d", &n);
temp = n;
for (i = 1; i < 1000000001; i++) {
x = pow(10, i);
if (n % x == 0) {
continue;
} else {
t = i - 1;
break;
}
}
temp = temp / pow(10, t);
temp2 = temp;
rev = 0;
while (temp != 0) {
r = temp % 10;
rev = rev * 10 + r;
temp = temp / 10;
}
if (rev == temp2) {
printf("YES\n");
} else {
printf("NO\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool chck(long long x, long long n, long long k) {
long long j = x;
long long c = 0;
while (j <= n) j = j * 2, c++;
j = j / 2;
c--;
long long a;
if (x % 2 != 0) {
a = pow(2, c) - 1;
long long l = pow(2, c);
a += min(n - j + 1, l);
} else {
a = 2 * (pow(2, c) - 1);
long long l = pow(2, c + 1);
a += min(n - j + 1, l);
}
if (a >= k)
return true;
else
return false;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
long long s = 1, l = n;
long long ans = 1;
while (s <= l) {
long long x = (s + l) / 2;
long long f1 = 0, f2 = 0;
if (chck(x, n, k)) {
f1 = 1;
ans = max(ans, x);
s = x + 1;
}
if (chck(x + 1, n, k)) {
f2 = 1;
ans = max(ans, x + 1);
s = x + 2;
}
if (f1 == 0 && f2 == 0) {
l = x - 1;
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i{0}, x; i < n; ++i) {
cin >> x;
v[i] = x;
}
sort(begin(v), end(v));
int count{0};
for (int i{1}, gap; i < n; ++i) {
gap = v[i] - v[i - 1] - 1;
if (gap) {
count += gap;
}
}
cout << count << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t;
long long n, f[87 + 1], cnt[87 + 1];
bool app[87 + 1];
int blk[87 + 1], p;
long long dp[87 + 1][2];
void solve() {
for (int i = (1); i <= (87); i++) app[i] = false;
p = 0;
for (int i = (87); i >= (1); i--)
if (n >= f[i]) {
n -= f[i];
app[i] = true;
blk[++p] = 1;
} else if (p > 0)
blk[p]++;
dp[p][0] = 1, dp[p][1] = cnt[blk[p]] - 1;
for (int i = (p - 1); i >= (1); i--) {
dp[i][0] = dp[i + 1][0] + dp[i + 1][1];
dp[i][1] =
dp[i + 1][0] * (cnt[blk[i]] - 1) + dp[i + 1][1] * (cnt[blk[i] + 1] - 1);
}
printf("%lld\n", dp[1][0] + dp[1][1]);
return;
}
int main() {
f[1] = 1;
f[2] = 2;
for (int i = (3); i <= (87); i++) f[i] = f[i - 1] + f[i - 2];
for (int i = (1); i <= (87); i++) cnt[i] = (i + 1) / 2;
scanf("%d", &t);
while (t--) {
scanf("%lld", &n);
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long int dp[2][320][320];
int main() {
int n, m, x;
scanf("%d%d%d", &n, &m, &x);
if (n > m)
puts("0");
else {
dp[0][0][0] = 1;
for (int i = 1; i <= m; i++)
for (int l = 0; l <= n; l++)
for (int r = 0; r <= l; r++) {
dp[i & 1][l][r] = 0;
if (i == x) {
if (l) dp[i & 1][l][r] += dp[~i & 1][l - 1][r];
if (l && r) dp[i & 1][l][r] += dp[~i & 1][l - 1][r - 1];
} else {
dp[i & 1][l][r] += dp[~i & 1][l][r];
if (l - 1 >= r) dp[i & 1][l][r] += dp[~i & 1][l - 1][r];
if (r) dp[i & 1][l][r] += dp[~i & 1][l][r - 1];
if (l && r) dp[i & 1][l][r] += dp[~i & 1][l - 1][r - 1];
}
dp[i & 1][l][r] %= mod;
}
long long int ans = dp[m & 1][n][n];
for (int i = 1; i <= n; i++) ans = (ans * i) % mod;
printf("%I64d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, L = 0, R = 300000, t, Le, k, l, I;
string s;
cin >> n >> s;
vector<int> A, B;
for (int i = 0; i < n; i++) {
if (s[i] == 'P') {
A.push_back(i);
}
if (s[i] == '*') {
B.push_back(i);
}
}
while (R - L > 1) {
t = (L + R) / 2;
k = 0;
for (int i = 0; i < A.size(); i++) {
I = A[i];
l = t;
Le = 0;
while (k != B.size() && (fabs(I - B[k]) <= l ||
(A[i] < B[k] && Le + 2 * (B[k] - A[i]) <= t))) {
l -= fabs(I - B[k]);
Le = max(Le, A[i] - B[k]);
I = B[k];
k++;
while (k != B.size() && B[k] < A[i]) {
k++;
}
}
if (k == B.size()) {
break;
}
}
if (k == B.size()) {
R = t;
} else {
L = t;
}
}
cout << R;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
string s;
vector<vector<ll>> cnt(2, vector<ll>(2, 0));
ll e = 0, o = 0;
void solve() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
o++;
if (i % 2 == 0) {
o += cnt[s[i] - 'a'][0];
e += cnt[s[i] - 'a'][1];
cnt[s[i] - 'a'][0]++;
} else {
e += cnt[s[i] - 'a'][0];
o += cnt[s[i] - 'a'][1];
cnt[s[i] - 'a'][1]++;
}
}
cout << e << " " << o << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return EXIT_SUCCESS;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long mn[301][301];
long long dp[301][301];
vector<int> l(100001);
vector<int> r(100001);
vector<long long> c(100001);
long long mx = 5e11;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i] >> c[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
mn[i][j] = mx;
}
}
for (int i = 0; i < m; i++) {
int b = l[i];
for (int j = l[i]; j <= r[i]; j++) {
mn[b][j] = min(mn[b][j], c[i]);
}
}
for (int i = 0; i <= n; i++) {
dp[i][0] = 0;
}
for (int i = 1; i <= k; i++) dp[0][i] = mx;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
dp[i][j] = dp[i - 1][j];
for (int b = i; b >= 1; b--) {
dp[i][j] = min(dp[i][j], mn[b][i] + dp[b - 1][max(0, j - (i - b + 1))]);
}
}
}
if (dp[n][k] == mx) {
cout << -1 << endl;
return 0;
}
cout << dp[n][k] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, x, f = 0, p = 0;
cin >> n >> x;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = n - 1; i >= 0; i--) {
p += a[i] - x;
if (p < 0) break;
f++;
}
cout << f;
cout << endl;
}
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <ctype.h>
#include <deque>
#include <cstring>
#include <set>
#include <bitset>
#include <map>
#include <chrono>
#include <queue>
#include <random>
#include <unordered_map>
#include <stdio.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef std::vector<int> vi;
typedef std::vector<bool> vb;
typedef std::vector<string> vs;
typedef std::vector<double> vd;
typedef std::vector<long long> vll;
typedef std::vector<std::vector<int> > vvi;
typedef vector<vll> vvll;
typedef std::vector<std::pair<int, int> > vpi;
typedef vector<vpi> vvpi;
typedef std::pair<int, int> pi;
typedef std::pair<ll, ll> pll;
typedef std::vector<pll> vpll;
const long long mod = 1000000007;
const unsigned gen_seed = std::chrono::system_clock::now().time_since_epoch().count();
std::mt19937_64 gen(gen_seed);
#define all(c) (c).begin(),(c).end()
#define srt(c) sort(all(c))
#define srtrev(c) sort(all(c)); reverse(all(c))
#define forn(i, a, b) for(int i = a; i < b; i++)
#define read(x) scanf("%d", &x)
#define readv(x, n) vi x(n); forn(i,0,n) scanf("%d", &x[i])
#define pb push_back
#define mp make_pair
vvi g;
vvi gn;
vi ans;
int n;
vi d2(1,1);
map<int, vi> gdp;
vi getdist(int s, int imax) {
if(gdp[s].size() > 0) return gdp[s];
vi res(d2[n], -1);
res[s] = 0;
priority_queue<pi> q;
// set<pi> q;
// q.insert(mp(0, s));
q.push(mp(0,s));
while(!q.empty()) {
auto it = q.top();
int v = it.second;
int d = -it.first;
// q.erase(it);
q.pop();
forn(i,0,imax+1) if(res[g[v][i]] == -1) {
res[g[v][i]] = d + 1;
q.push(mp(-d-1, g[v][i]));
// q.insert(mp(d+1, u));
}
}
vi ver;
forn(i,0,d2[n]) if(res[i]!=-1) ver.pb(i);
forn(i,imax+1,n) {
int k = ver.size();
forn(j,0,k) {
int u = g[ver[j]][i];
ver.pb(u);
res[u] = res[ver[j]]+1;
}
}
gdp[s] = res;
return res;
}
//map<int, int> getdist(int s) {
// map<int, int> ret;
// map<int, int> done;
// ret[s] = 0;
// set<pi> q;
// q.insert(mp(0, s));
// while(!q.empty()) {
// auto it = q.begin();
// int v = it->second;
// int d = it->first;
// q.erase(it);
// if(done[v]) continue;
// done[v] = 1;
// ret[v] = d;
// for(auto u : g[v]) q.insert(mp(d+1, u));
// }
// return ret;
//}
void gos(int v, int v2, int imax) {
// map<int, int> tp;
vi tp(d2[n]);
// map<int, int> d1 = getdist(v);
// map<int, int> dd2 = getdist(v2);
vi d1 = getdist(v, imax);
vi dd2 = getdist(v2, imax);
forn(x,0,d2[n]) {
if(d1[x] < dd2[x]) tp[x] = 1;
else tp[x] = 2;
}
forn(x,0,d2[n]) {
forn(i,0, imax) if(tp[x] != tp[g[x][i]]) {
swap(g[x][i], g[x][imax]);
break;
}
}
}
void split(int v, int i) {
int v2 = g[v][i];
vi ver(1,v2);
ans[v2] += d2[i];
forn(j,0,i) {
int k = ver.size();
forn(ii,0,k) {
int v3 = g[ver[ii]][j];
ans[v3] += d2[i];
ver.pb(v3);
}
}
if(i>0) {
split(v,i-1);
split(v2,i-1);
}
}
//void go(int v, vi & ord) {
// if(g[v].empty()) return;
// int v2 = ord.back();
// map<int, int> tp;
// map<int, int> d1 = getdist(v);
// map<int, int> d2 = getdist(v2);
// for(auto x : d1) {
// if(d1[x.first] < d2[x.first]) tp[x.first] = 1;
// else tp[x.first] = 2;
// }
// ord.pop_back();
// vi ord2;
// for(auto x : ord) {
// for(auto u : g[x]) if(tp[u] == 2) ord2.pb(u);
// }
// for(auto x : d1) {
// for(auto u : g[x.first]) if(tp[x.first] != tp[u]) {
// g[x.first].erase(u);
// break;
// }
// }
// int dwas = d1.size()/2;
// for(auto x : d1) if(tp[x.first] == 2) ans[x.first] += dwas;
//
// go(v, ord);
// go(v2, ord2);
//}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
forn(i,0,20) d2.pb(d2.back()*2);
vi bitodd(1,0);
forn(i,1,d2[16]+1) {
bitodd.pb((i%2)^bitodd[i/2]);
}
vvi col(17);
col[1] = {0,0};
forn(id,1,5) {
int dd = d2[id-1];
int dn = d2[id];
forn(i,0,d2[dd]) {
forn(j,0,d2[dd]) {
col[dn].pb((col[dd][j] + col[dd][i]) % dd + (bitodd[i])*dd);
}
}
}
int t;
scanf("%d", &t);
vpi e;
forn(i,0,d2[4]) {
forn(j,0,4) if((i^d2[j]) < i) e.pb(mp(i, i^d2[j]));
}
while(t--) {
gdp =map<int, vi>();
scanf("%d", &n);
g = vvi (d2[n]);
gn = vvi(d2[n], vi(n));
ans = vi(d2[n], 0);
forn(i,0,n*d2[n-1]) {
int u,v;
scanf("%d %d", &u, &v);
// u = e[i].first;
// v = e[i].second;
g[u].pb(v);
g[v].pb(u);
}
vi ord;
int pt = 0;
vi spor = g[0];
for(auto v : spor) gos(0, v, n-1-(pt++));
// for(auto v : g[0]) ord.pb(v);
// go(0, ord);
split(0, n-1);
vi res(d2[n]);
forn(i,0,d2[n]) res[ans[i]] = i;
forn(i,0,d2[n]) printf("%d ", res[i]);
printf("\n");
if(col[n].size() == 0) {
printf("-1\n");
}
else {
forn(i,0,d2[n]) printf("%d ", col[n][ans[i]]);
printf("\n");
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > a;
int func(int mask) {
int i, j;
for (i = 0; i < a.size(); i++) {
for (j = i + 1; j < a.size(); j++) {
if (a[i] == a[j]) continue;
if (a[i].first != a[j].first && mask & (1 << a[i].first)) continue;
if (a[i].first != a[j].first && mask & (1 << a[j].first)) continue;
if (a[i].second != a[j].second && mask & (1 << a[i].second)) continue;
if (a[i].second != a[j].second && mask & (1 << a[j].second)) continue;
return false;
}
}
return true;
}
int main() {
int n;
cin >> n;
char x;
int y;
while (n--) {
cin >> x >> y;
if (x == 'R')
x = 0;
else if (x == 'G')
x = 1;
else if (x == 'B')
x = 2;
else if (x == 'Y')
x = 3;
else
x = 4;
y--;
a.push_back(make_pair(x, y));
}
sort(a.begin(), a.end());
int i;
for (i = 0; i < a.size(); i++) a[i].second += 5;
if (a[0] == a.back()) {
cout << "0";
return 0;
}
int ans = 10;
for (i = 0; i < 1 << 10; i++) {
if (!func(i)) continue;
ans = min(ans, __builtin_popcount(i));
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
long long f[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
f[1] = 1, f[2] = 5;
for (int i = 3; i <= n; i++) f[i] = f[i - 1] + 4 + 4 * (i - 2);
cout << f[n];
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const int INF = (int)1E9 + 7;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int NMAX = 1100;
int n, m;
char s[NMAX][NMAX];
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
bool in(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
int flag = 1;
int used[NMAX][NMAX], C[NMAX * NMAX];
int ans[NMAX][NMAX], u1[NMAX][NMAX], u2[NMAX][NMAX];
int cs[20];
void calc(int x, int y, int c, int u[NMAX][NMAX]) {
ans[x][y] = c;
u[x][y] = true;
for (int i = 0; i < int(4); ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (in(nx, ny) && s[nx][ny] == '.') {
if (used[nx][ny] == used[x][y]) {
if (!u[nx][ny]) calc(nx, ny, c, u);
} else {
if (ans[nx][ny] != -1) cs[ans[nx][ny]] = true;
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
gets(s[0]);
for (int i = 0; i < int(n); ++i) gets(s[i]);
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(m); ++j) {
int cnt = 0;
for (int k = 0; k < int(4); ++k) {
int ni = i + dx[k], nj = j + dy[k];
if (in(ni, nj) && s[ni][nj] == '.') cnt++;
}
if (cnt == 0 && s[i][j] == '.') {
puts("-1");
exit(0);
}
}
}
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(m); ++j) {
if (s[i][j] == '.' && used[i][j] == 0) {
bool was = false;
for (int k = 0; k < int(4); ++k) {
int ni = i + dx[k], nj = j + dy[k];
if (in(ni, nj) && s[ni][nj] == '.' && used[ni][nj] == 0) {
C[flag] = 2;
used[i][j] = used[ni][nj] = flag;
flag++;
was = true;
break;
}
}
if (!was) {
for (int k = 0; k < int(4); ++k) {
int ni = i + dx[k], nj = j + dy[k];
if (in(ni, nj) && s[ni][nj] == '.' && C[used[ni][nj]] != 5) {
int cflag = used[ni][nj];
C[cflag]++;
used[i][j] = cflag;
was = true;
break;
}
}
assert(was);
}
}
}
}
memset(ans, -1, sizeof ans);
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(m); ++j) {
if (ans[i][j] == -1) {
memset(cs, 0, sizeof cs);
calc(i, j, -1, u1);
for (int k = 0; k < int(10); ++k)
if (!cs[k]) {
calc(i, j, k, u2);
break;
}
}
}
}
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(m); ++j) {
if (s[i][j] != '.')
printf("%c", s[i][j]);
else
printf("%c", char(ans[i][j] + '0'));
}
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e16;
const int N = 1e5 + 1;
const long long mod = 1e9 + 7;
const int bits = 19;
const long double pi = 3.14159265358979323846;
long long power(long long x, long long n) {
long long res = 1;
x %= mod;
while (n) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
long long modInv(long long n) { return power(n, mod - 2); }
void solve() {
int n, m;
cin >> n >> m;
vector<int> arr(m);
for (int i = 0; i < m; i++) {
cin >> arr[i];
}
sort(arr.begin(), arr.end());
vector<long long> fact(n + 1, 1), pow(n + 1, 1);
for (int i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % mod;
pow[i] = (pow[i - 1] * 2) % mod;
}
vector<int> size;
long long num = 1, sum = 0;
long long denom = 1;
for (int i = 0; i + 1 < m; i++) {
if (arr[i + 1] - arr[i] - 1) size.push_back(arr[i + 1] - arr[i] - 1);
}
for (int x : size) {
sum += x;
num = (num * pow[x - 1]) % mod;
denom = (denom * fact[x]) % mod;
}
sum += arr[0] - 1;
denom = (denom * fact[arr[0] - 1]) % mod;
sum += n - arr.back();
denom = (denom * fact[n - arr.back()]) % mod;
num = (num * fact[sum]) % mod;
long long ans = (num * modInv(denom)) % mod;
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
std::cout << std::fixed << std::setprecision(20);
;
int t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int getint() {
int t = 0, flag = 1;
char c = getchar();
while (c < '0' || c > '9' || c == '-') {
if (c == '-') flag = -1;
c = getchar();
}
while (c >= '0' && c <= '9') t = t * 10 + c - '0', c = getchar();
return t * flag;
}
int GCD(int m, int n) { return !m ? n : GCD(n % m, m); }
template <typename T>
string to_string(T value) {
ostringstream os;
os << value;
return os.str();
}
long long MultMod(long long a, long long b, long long MOD) {
a %= MOD;
b %= MOD;
long long ret = 0;
while (b) {
if (b & 1) {
ret += a;
if (ret >= MOD) ret -= MOD;
}
a = a << 1;
if (a >= MOD) a -= MOD;
b = b >> 1;
}
return ret;
}
int a[maxn], b[maxn], n, t, m;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int l[n + 2];
memset(l, 0, sizeof l);
for (int i = 1; i <= n; i++) {
int j = i - 1;
while (a[j] >= a[i]) j = l[j];
l[i] = j;
}
int r[n + 2];
memset(r, 0, sizeof r);
for (int i = n; i >= 1; i--) {
int j = i + 1;
while (a[j] >= a[i]) j = r[j];
r[i] = j;
}
int dp[n + 2];
memset(dp, 0, sizeof dp);
for (int i = 1; i <= n; i++) {
int len = r[i] - l[i] - 1;
dp[len] = max(dp[len], a[i]);
}
for (int i = n - 1; i >= 1; i--) dp[i] = max(dp[i], dp[i + 1]);
for (int i = 1; i <= n; i++) cout << dp[i] << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
int a, b, c, d, sum, temp;
sum = n - 1;
for (int i = 2; i < n; i++) {
temp = 1;
a = n;
b = i;
while (a != 2 && b != 1) {
if (a % b == 0) break;
c = a % b;
temp += a / b;
a = b;
b = c;
if (temp > sum) break;
if (b == 1) {
temp += a - 2;
a = 2;
}
}
if (a == 2 && b == 1 && temp < sum) sum = temp;
}
printf("%d\n", sum);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:512000000")
template <class T>
T sqr(T a) {
return a * a;
}
int n, m;
int a[50][50];
bool okc(int x1, int x2, int y) {
for (int i = x1; i < x2 + 1; ++i)
if (!a[i][y]) return 0;
return 1;
}
bool okr(int x, int y1, int y2) {
for (int i = y1; i < y2 + 1; ++i)
if (!a[x][i]) return 0;
return 1;
}
bool ok(int x1, int y1, int x2, int y2) {
if (x1 > x2) swap(x1, x2), swap(y1, y2);
return okr(x1, min(y1, y2), max(y1, y2)) && okc(x1, x2, y2) ||
okr(x2, min(y1, y2), max(y1, y2)) && okc(x1, x2, y1);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int j = 0; j < m; ++j) a[i][j] = s[j] == 'B';
}
bool res = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
for (int k = 0; k < n; ++k) {
for (int l = 0; l < m; ++l) {
if (!a[i][j] || !a[k][l]) continue;
if (!ok(i, j, k, l)) res = 0;
}
}
}
}
puts(res ? "YES" : "NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e4;
int n, k, a[mxN], dp[2][mxN + 1], qt, m[mxN], b[mxN], mx[mxN + 1];
void al(int mi, int bi, bool mo) {
if (qt && mi == m[qt - 1]) {
if (bi > b[qt - 1]) return;
--qt;
}
while (qt > 1 && (bi - b[qt - 1]) / (m[qt - 1] - mi) <
(b[qt - 1] - b[qt - 2]) / (m[qt - 2] - m[qt - 1]) ^
mo)
--qt;
m[qt] = mi;
b[qt] = bi;
++qt;
}
int qry(int x) {
while (qt > 1 && m[qt - 2] * x + b[qt - 2] < m[qt - 1] * x + b[qt - 1]) --qt;
return m[qt - 1] * x + b[qt - 1];
}
void cdp(int f[mxN + 1], int t[mxN + 1], int l, int r) {
if (l >= r) return;
int m = (l + r) / 2;
mx[m] = mx[m + 1] = a[m];
for (int i = m - 1; i >= l; --i) mx[i] = max(a[i], mx[i + 1]);
for (int i = m + 2; i <= r; ++i) mx[i] = max(a[i - 1], mx[i - 1]);
for (int il = m + 1, ir = m + 1; ir <= r; ++ir) {
while (il > l && mx[il - 1] <= mx[ir]) {
--il;
al(-il, f[il], 1);
}
t[ir] = min(qry(mx[ir]) + ir * mx[ir], t[ir]);
}
qt = 0;
al(2e4, 1e9, 0);
for (int il = l, ir = r; ir > m; --ir) {
while (il <= m && mx[il] >= mx[ir]) {
al(mx[il], f[il] - il * mx[il], 0);
++il;
}
t[ir] = min(qry(ir), t[ir]);
}
qt = 0;
cdp(f, t, l, m);
cdp(f, t, m + 1, r);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
memset(dp[0], 0x3f, sizeof(dp[0]));
dp[0][0] = 0;
for (int i = 1; i <= k; ++i) {
memset(dp[i & 1], 0x3f, sizeof(dp[0]));
cdp(dp[i & 1 ^ 1], dp[i & 1], 0, n);
}
cout << dp[k & 1][n];
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, ed[65][65][65], con[65][65][3];
stack<int> st;
int cv(char c) {
if (c <= '9') return c - '0';
if (c <= 'Z') return c - 'A' + 10;
return c - 'a' + 10 + 26;
}
char rcv(int in) {
if (in <= 9) return in + '0';
if (in <= 35) return in - 10 + 'A';
return in - 10 - 26 + 'a';
}
void brute(int a, int b) {
for (int i = 0; i < 62; i++) {
if (ed[a][b][i] == 0) continue;
ed[a][b][i]--;
brute(b, i);
st.push(i);
}
}
int main() {
char in[5];
int a, b, c, ra, rb, ta, tb, ci, co;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", in);
a = cv(in[0]);
b = cv(in[1]);
c = cv(in[2]);
con[a][b][0]++;
con[b][c][1]++;
ed[a][b][c]++;
}
ra = rb = ta = tb = -1;
ci = co = 0;
for (int i = 0; i < 62; i++) {
for (int j = 0; j < 62; j++) {
if (abs(con[i][j][0] - con[i][j][1]) > 1) {
printf("NO\n");
return 0;
}
if (con[i][j][0] - con[i][j][1] == 1) {
ci++;
ra = i;
rb = j;
} else if (con[i][j][1] - con[i][j][0] == 1) {
co++;
} else if (con[i][j][0] > 0 && con[i][j][0] == con[i][j][1]) {
ta = i;
tb = j;
}
}
}
if (!((ci == 1 && co == 1) || (ci == 0 && co == 0))) {
printf("NO\n");
return 0;
}
if (ci == 0 && co == 0) {
ra = ta;
rb = tb;
}
for (int i = 0; i < 62; i++) {
if (ed[ra][rb][i]) {
ed[ra][rb][i]--;
brute(rb, i);
st.push(i);
}
}
if (st.size() < n) {
printf("NO\n");
return 0;
}
printf("YES\n%c%c", rcv(ra), rcv(rb));
while (!st.empty()) {
printf("%c", rcv(st.top()));
st.pop();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int main() {
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
;
int a, k;
cin >> a;
k = a;
vector<vector<int>> d(100000, vector<int>());
for (int q = 0; q < a; q++) {
int x;
cin >> x;
x--;
d[x].push_back(q);
}
long long o = 0, ps = 0;
for (; k > 0;) {
int lp = -1, st = k;
for (; k > 0; ps++) {
if (d[ps].size() == 0) continue;
int t = d[ps].back();
for (; d[ps].size() && d[ps].back() > lp; k--) d[ps].pop_back();
lp = t;
if (d[ps].size()) break;
}
o += st;
}
cout << o;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mxm = 1e18;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long f, t, t0, a1, t1, p1, a2, t2, p2, rf, rt, ans(mxm), i, j, tmp;
cin >> f >> t >> t0;
cin >> a1 >> t1 >> p1;
cin >> a2 >> t2 >> p2;
if (t1 > t2) swap(a1, a2), swap(t1, t2), swap(p1, p2);
for (i = 0; i < f; i += a1) {
rf = f - i;
rt = t - i * t1;
if (rf * t2 > rt && rf * t0 > rt) continue;
if (t0 <= t2 || rf * t0 <= rt)
j = 0;
else
j = ((t0 * rf - rt + t0 - t2 - 1) / (t0 - t2) + a2 - 1) / a2;
ans = min(ans, p1 * i / a1 + p2 * j);
}
if (f * t1 <= t) ans = min(ans, (f + a1 - 1) / a1 * p1);
if (ans == mxm)
cout << -1 << '\n';
else
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, top, pos, sl, sr, cnt_0, tot, ans, ans_i, ans_j;
char s[N];
struct myt {
int c, id;
} ok[N];
struct Alexstrasza {
int rst, id;
} stk[N];
struct Malygos {
int cnt, dep, lp, rp;
} mat[N];
int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + ch - '0', ch = getchar();
return s * w;
}
int main() {
n = read();
scanf("%s", s + 1);
for (int i = 1; i <= n; ++i)
if (s[i] == '(')
++sl;
else
++sr;
if (sl != sr) {
printf("0\n");
printf("1 1");
return 0;
}
top = 0;
for (int i = 1; i <= n; ++i)
if (s[i] == '(')
++top;
else {
if (!top)
pos = i;
else
--top;
}
for (int i = pos + 1; i <= n; ++i) ok[i - pos].c = s[i], ok[i - pos].id = i;
for (int i = 1; i <= pos; ++i)
ok[n - pos + i].c = s[i], ok[n - pos + i].id = i;
top = 0;
for (int i = 1; i <= n; ++i)
if (ok[i].c == '(')
++top, stk[top].id = ok[i].id, stk[top].rst = 0;
else {
mat[++tot].cnt = stk[top].rst;
mat[tot].dep = top;
mat[tot].lp = stk[top].id;
mat[tot].rp = ok[i].id;
--top;
++stk[top].rst;
}
ans = stk[0].rst;
ans_i = ans_j = 1;
cnt_0 = stk[0].rst;
for (int i = 1; i <= tot; ++i) {
if (mat[i].dep == 1) {
if (mat[i].cnt + 1 > ans) {
ans = mat[i].cnt + 1;
ans_i = mat[i].lp;
ans_j = mat[i].rp;
}
}
if (mat[i].dep == 2) {
if (cnt_0 + mat[i].cnt + 1 > ans) {
ans = cnt_0 + mat[i].cnt + 1;
ans_i = mat[i].lp;
ans_j = mat[i].rp;
}
}
}
printf("%d\n", ans);
printf("%d %d", ans_i, ans_j);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng((unsigned long long)new char);
const double eps = 1e-10;
const int maxn = 500010;
const long long INF = 1e8;
const int mod = 1e9 + 7;
long long a, b, c, l;
inline long long c3(long long x) { return x * (x - 1) * (x - 2) / 6; }
inline long long c2(long long x) { return x * (x - 1) / 2; }
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> a >> b >> c >> l;
long long ans = c3(l + 3);
for (int t = (0); t < (l + 1); ++t) {
int x = min(a - b - c + t, l - t);
if (x >= 0) ans -= c2(x + 2);
x = min(b - a - c + t, l - t);
if (x >= 0) ans -= c2(x + 2);
x = min(c - a - b + t, l - t);
if (x >= 0) ans -= c2(x + 2);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, k = 0, o;
string ss[1000005];
string s, tmp;
int D[1000005];
vector<string> vt[1000005];
void convertstring(string txt) {
ss[x] = txt;
x++;
}
void convertint(int nm) {
D[y] = nm;
y++;
}
void dfs(int m) {
o = max(o, m + 1);
vt[m].push_back(ss[k]);
int p = k;
for (int i = 0; i < D[p]; i++) k++, dfs(m + 1);
}
int main() {
cin >> s;
s += ',';
int s_size = s.size();
for (int i = 0; i < s_size; i++) {
int kop = 0;
if (s[i] >= '0' && s[i] <= '9') {
while (s[i] != ',') {
kop = kop * 10 + (s[i] - '0');
i++;
}
convertint(kop);
continue;
} else if (s[i] == ',') {
if (tmp != "") convertstring(tmp);
tmp = "";
} else
tmp += s[i];
}
int cnt = max(x, y);
while (k != cnt) {
dfs(0);
k++;
}
cout << o << endl;
for (int i = 0; i < o; i++) {
bool tt = true;
for (auto j : vt[i])
if (tt)
cout << j, tt = false;
else
cout << " " << j;
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char c[505];
int a[505], b[505];
vector<int> occ[30];
int vlu[100005];
int lp, sz;
int fnc(int j, int z) {
if (z == sz) return lp;
if (z >= 0) return occ[c[j] - 'a'][z];
return -1;
}
char str[100005];
int main() {
int i, k, l, r;
scanf("%s", str);
scanf("%d%d%d", &k, &l, &r);
int zr = 0;
for (i = 0; i < k; i++) {
scanf("%c", &c[i]);
while (c[i] == ' ' || c[i] == '\n') scanf("%c", &c[i]);
scanf("%d%d", &a[i], &b[i]);
if (a[i] == 0) zr++;
}
for (i = 0; i < k; i++) {
}
int n = strlen(str);
int j, m, st, en;
long long rs = 0, sm = 0;
for (i = 0; i < n; i++) {
lp = i;
vlu[i] = zr;
occ[str[i] - 'a'].push_back(i);
if (l <= vlu[i] && vlu[i] <= r) sm++;
for (j = 0; j < k; j++) {
if (c[j] != str[i]) continue;
sz = occ[c[j] - 'a'].size();
st = fnc(j, sz - (b[j] + 2));
en = fnc(j, sz - (b[j] + 1));
for (m = st + 1; m <= en; m++) {
if (l <= vlu[m] && vlu[m] <= r) sm--;
vlu[m]--;
if (l <= vlu[m] && vlu[m] <= r) sm++;
}
st = fnc(j, sz - (a[j] + 1));
en = fnc(j, sz - (a[j]));
for (m = st + 1; m <= en; m++) {
if (l <= vlu[m] && vlu[m] <= r) sm--;
vlu[m]++;
if (l <= vlu[m] && vlu[m] <= r) sm++;
}
}
rs += sm;
}
printf("%lld\n", rs);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
register char c = getchar();
bool f = 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') c = getchar(), f = 1;
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
x = f ? -x : x;
return;
}
template <class T>
inline void write(T x) {
if (!x) {
putchar(48);
return;
}
if (x < 0) x = -x, putchar('-');
int len = -1, z[20];
while (x > 0) z[++len] = x % 10, x /= 10;
for (register int i = len; i >= 0; i--) putchar(z[i] + 48);
return;
}
const int N = 500010;
struct node {
int u, v, w, id;
} e[N], q[N];
inline bool cmp_w(const node &x, const node &y) { return x.w < y.w; }
inline bool cmp_id(const node &x, const node &y) { return x.id < y.id; }
int fa[N];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
bool solve() {
int k;
read(k);
for (int i = 1, x; i <= k; i++) read(x), q[i] = e[x];
sort(q + 1, q + 1 + k, cmp_w);
for (int i = 1, j; i <= k; i = j + 1) {
j = i;
while (j < k && q[j + 1].w == q[j].w) j++;
for (int l = i; l <= j; l++) fa[q[l].u] = q[l].u, fa[q[l].v] = q[l].v;
for (int l = i; l <= j; l++) {
int u = find(q[l].u), v = find(q[l].v);
if (u == v) return 0;
fa[v] = u;
}
}
return 1;
}
int main() {
int n, m;
read(n), read(m);
for (int i = 1; i <= m; i++)
read(e[i].u), read(e[i].v), read(e[i].w), e[i].id = i;
for (int i = 1; i <= n; i++) fa[i] = i;
sort(e + 1, e + 1 + m, cmp_w);
for (int i = 1, j; i <= m; i = j + 1) {
j = i;
while (j < m && e[j].w == e[j + 1].w) j++;
for (int k = i; k <= j; k++) e[k].u = find(e[k].u), e[k].v = find(e[k].v);
for (int k = i; k <= j; k++) {
int u = find(e[k].u), v = find(e[k].v);
if (u == v) continue;
fa[v] = u;
}
}
sort(e + 1, e + 1 + m, cmp_id);
int T;
read(T);
while (T--) puts(solve() ? "YES" : "NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long dp[4][1010][1010];
long long arr[1010][1010];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%lld", &arr[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[0][i][j] = arr[i][j] + max(dp[0][i - 1][j], dp[0][i][j - 1]);
}
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
dp[1][i][j] = arr[i][j] + max(dp[1][i][j + 1], dp[1][i + 1][j]);
}
}
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= m; j++) {
dp[2][i][j] = arr[i][j] + max(dp[2][i][j - 1], dp[2][i + 1][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = m; j >= 1; j--) {
dp[3][i][j] = arr[i][j] + max(dp[3][i][j + 1], dp[3][i - 1][j]);
}
}
long long ans = -1;
for (int i = 2; i < n; i++) {
for (int j = 2; j < m; j++) {
ans = max(ans, dp[0][i][j - 1] + dp[1][i][j + 1] + dp[2][i + 1][j] +
dp[3][i - 1][j]);
ans = max(ans, dp[0][i - 1][j] + dp[1][i + 1][j] + dp[2][i][j - 1] +
dp[3][i][j + 1]);
}
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = (1e9) + 9;
long long power(long long x, long long y) {
if (y == 0) return 1;
if (y % 2) {
return ((x % mod) * (power(x, y - 1) % mod)) % mod;
} else
return (power((x * x) % mod, y / 2) % mod);
}
int n, a, b, k;
int main() {
scanf("%d %d", &n, &a);
scanf("%d %d", &b, &k);
char temp[100005];
scanf("%s", temp);
long long x = 0;
for (int i = 0; i < k; ++i) {
if (temp[i] == '+')
x = (x + (power(a, k - 1 - i) * power(b, i) % mod)) % mod;
else
x = (x - (power(a, k - 1 - i) * power(b, i) % mod)) % mod;
}
int m = (n + 1) / k;
long long alp = power(a, k), bet = power(b, k), ans = 0;
if (alp - bet) {
ans = (((x * power(alp - bet, mod - 2)) % mod) *
((power(alp, m) - power(bet, m)) % mod)) %
mod;
} else {
ans = (((x * m) % mod) * power(alp, m - 1)) % mod;
}
if (ans < 0)
printf("%lld\n", mod + ans);
else
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long A[500005];
int n;
long long B[500005];
long long C[500005];
set<long long> S;
bool check(long long k) {
S.clear();
int t = upper_bound(A + 1, A + n + 1, k) - A;
for (int i = t; i <= n; i++) {
long long x = A[i];
while (x > k || S.find(x) != S.end()) {
x /= 2;
if (!x) return 0;
}
B[i] = x;
S.insert(x);
}
for (int i = 1; i < t; i++) {
long long x = A[i];
long long ans = -1;
while (x) {
if (S.find(x) == S.end()) {
ans = x;
break;
}
x /= 2;
}
if (ans == -1) return 0;
B[i] = ans;
S.insert(ans);
}
memcpy(C, B, sizeof(B));
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &A[i]);
}
sort(A + 1, A + n + 1);
long long l = 1, r = A[n];
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid)) {
r = mid - 1;
} else
l = mid + 1;
}
for (int i = 1; i <= n; i++) {
printf("%I64d ", C[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 7;
const int N = 1e6 + 10;
vector<int> a, dd;
int n;
void xuly() {
dd.resize(n, 0);
int l = oo;
int kq = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] != a[i + 1]) {
if (l == oo) l = i;
} else {
if (l == oo) continue;
dd[l] = i;
kq = max(kq, i - l);
l = oo;
}
}
if (l != oo) {
dd[l] = n - 1;
kq = max(kq, dd[l] - l);
}
kq /= 2;
if (!kq) {
printf("0\n");
for (int i = 0; i < n; i++) printf("%d ", a[i]);
return;
}
for (int i = 0; i < n - 2; i++) {
if (dd[i]) {
int k = dd[i] - i;
for (int t = 1; t < k; t++) a[i + t] = a[i];
if ((k % 2) == 1)
for (int t = k / 2 + 1; t < k; t++) a[i + t] ^= 1;
}
}
printf("%d\n", kq);
for (int i = 0; i < n; i++) printf("%d ", a[i]);
}
int main() {
scanf("%d", &n);
a.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
xuly();
}
| 4 |
#include <bits/stdc++.h>
const double PI = acosl(-1.0);
int bits[1 << 23];
void pre(int n) {
int LOG = 0;
while (1 << (LOG + 1) < n) {
LOG++;
}
for (int i = 1; i < n; i++) {
bits[i] = (bits[i >> 1] >> 1) | ((i & 1) << LOG);
}
}
std::vector<std::complex<double> > fft(std::vector<std::complex<double> > a,
bool inv = false) {
int n = a.size();
pre(n);
for (int i = 0; i < n; i++) {
int to = bits[i];
if (to > i) {
std::swap(a[to], a[i]);
}
}
double angle = inv ? -1 : 1;
angle *= PI;
for (int len = 1; len < n; len *= 2) {
std::complex<double> delta(cosl(angle / len), sinl(angle / len));
for (int i = 0; i < n; i += 2 * len) {
std::complex<double> cur_root = 1;
for (int j = 0; j < len; j++) {
std::complex<double> u = a[i + j], v = a[i + j + len] * cur_root;
a[i + j] = u + v;
a[i + j + len] = u - v;
cur_root *= delta;
}
}
}
if (inv) {
for (int i = 0; i < n; i++) a[i] /= n;
}
return a;
}
std::vector<int> mul(std::vector<int> &a, std::vector<int> &b) {
std::vector<std::complex<double> > A, B;
A.resize(a.size());
B.resize(b.size());
for (int i = 0; i < a.size(); i++) {
A[i] = a[i];
B[i] = b[i];
}
A = fft(A);
B = fft(B);
for (int i = 0; i < a.size(); i++) {
A[i] *= B[i];
}
A = fft(A, true);
std::vector<int> ans(a.size());
for (int i = 0; i < a.size(); i++) {
ans[i] = std::real(A[i]) + 0.5;
}
return ans;
}
int decode[256];
int freq[4];
void print_vector(std::vector<int> A) {
for (auto a : A) std::cout << a << ' ';
std::cout << std::endl;
}
int main() {
int n, m, k;
std::cin >> n >> m >> k;
std::string s, t;
std::cin >> s >> t;
int N = 1;
while (N < n + m) N <<= 1;
std::vector<int> A[4], B[4];
for (int i = 0; i < 4; i++) {
A[i].resize(N);
B[i].resize(N);
}
decode['A'] = 0;
decode['G'] = 1;
decode['C'] = 2;
decode['T'] = 3;
for (int i = 0; i < n; i++) {
A[decode[s[i]]][std::max(i - k, 0)] += 1;
if (i + k + 1 < n) A[decode[s[i]]][i + k + 1] -= 1;
}
for (int i = 0; i < m; i++) {
B[decode[t[i]]][m - i - 1] = 1;
freq[decode[t[i]]]++;
}
for (int i = 0; i < 4; i++) {
for (int j = 1; j < N; j++) A[i][j] += A[i][j - 1];
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < N; j++) A[i][j] = std::min(1, A[i][j]);
}
std::vector<int> C[4];
for (int j = 0; j < 4; j++) {
C[j] = mul(A[j], B[j]);
}
int ans = 0;
for (int i = 0; i <= n - m; i++) {
bool can = true;
for (int j = 0; j < 4; j++) can = can && (C[j][m - 1 + i] == freq[j]);
if (can) {
ans++;
}
}
std::cout << ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int n, r[16], b[16], dp[1 << 16][545];
char t[16][2];
int f(int bitmask, int x) {
if (bitmask == (1 << n) - 1) return 0;
if (dp[bitmask][x] != -1) return dp[bitmask][x];
int sum_red = 0, num_red = 0;
int sum_blue = 0, num_blue = 0;
for (int(i) = 0; (i) < (n); (i)++) {
if (bitmask & (1 << i)) {
if (t[i][0] == 'R')
num_red++;
else
num_blue++;
sum_red += r[i];
sum_blue += b[i];
}
}
int xx = x - 272;
int ret = INF;
for (int(i) = 0; (i) < (n); (i)++) {
if (bitmask & (1 << i)) continue;
int diff = sum_red - sum_blue + xx;
int red_token, blue_token;
if (diff >= 0) {
red_token = 0;
blue_token = abs(diff);
} else {
red_token = abs(diff);
blue_token = 0;
}
int new_red = max(r[i] - num_red, 0);
int new_blue = max(b[i] - num_blue, 0);
int new_x = xx - (r[i] - new_red) + (b[i] - new_blue);
int cost = max(new_red - red_token, new_blue - blue_token);
cost = max(cost, 0);
ret = min(ret, f(bitmask | (1 << i), new_x + 272) + cost);
}
return dp[bitmask][x] = ret;
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (n); (i)++) scanf("%s %d %d", &t[i], &r[i], &b[i]);
memset((dp), (-1), sizeof(dp));
int an = f(0, 272);
printf("%d\n", an + n);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using ll = long long;
using std::cin;
using std::cout;
using std::endl;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int inf = (int)1e9 + 7;
const long long INF = 1LL << 60;
void solve() {
int n;
cin >> n;
std::vector<int> next(n);
for (int i = 0; i < n; ++i) {
cin >> next[i];
if (next[i] > 0) next[i] -= 1;
}
std::vector<std::vector<int>> dag(n + 1);
std::vector<int> deg(n + 1);
for (int i = 0; i < n; ++i) {
if (next[i] >= 0) {
dag[next[i]].emplace_back(i);
deg[i] += 1;
} else {
dag[i + 1].emplace_back(i);
deg[i] += 1;
}
}
std::queue<int> q;
for (int i = 0; i <= n; ++i) {
if (deg[i] == 0) q.emplace(i);
}
std::vector<int> topo;
while (not q.empty()) {
int cur = q.front();
topo.emplace_back(cur);
q.pop();
for (auto nxt : dag[cur]) {
deg[nxt]--;
if (deg[nxt] == 0) {
q.emplace(nxt);
}
}
}
if ((int)topo.size() != n + 1) {
cout << -1 << "\n";
return;
}
std::vector<int> res(n);
for (int i = 1; i <= n; ++i) {
res[topo[i]] = n + 1 - i;
}
std::vector<int> check(n);
std::set<int> s;
for (int i = 1; i <= n; ++i) {
auto itr = s.upper_bound(topo[i]);
if (itr == s.end())
check[topo[i]] = n;
else
check[topo[i]] = *itr;
s.emplace(topo[i]);
}
bool ok = true;
for (int i = 0; i < n; ++i) {
if (not(check[i] == next[i] or next[i] == -1)) {
ok = false;
break;
}
}
if (ok) {
for (int i = 0; i < n; ++i) {
cout << res[i] << " \n"[i + 1 == n];
}
} else {
cout << -1 << "\n";
}
}
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int vis[3], value[1010], c[4][10], n;
void dfs(int a, int b) {
value[b] = 1;
if (a >= n) return;
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
for (int j = 0; j < 6; j++) {
vis[i] = 1;
dfs(a + 1, b * 10 + c[i][j]);
vis[i] = 0;
}
}
}
int main() {
while (cin >> n && n) {
memset(value, 0, sizeof(value));
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++)
for (int j = 0; j < 6; j++) cin >> c[i][j];
dfs(0, 0);
for (int i = 1; i < pow(10, n); i++)
if (value[i] == 0) {
cout << i - 1 << endl;
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int a[5007], b[5007];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string second;
long long int n, i, j, ans = 0;
cin >> second;
n = second.size();
for (i = 1; i <= n; i++) {
if (second[i - 1] == 'a') {
a[i] = a[i - 1] + 1;
b[i] = b[i - 1];
} else {
a[i] = a[i - 1];
b[i] = b[i - 1] + 1;
}
}
for (i = 0; i <= n; i++)
for (j = i; j <= n; j++) {
long long int u = a[n] - a[j] + b[j] - b[i] + a[i];
ans = max(ans, u);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const double eps = 1e-9;
const double pi = acos(0) * 2;
long long powmod(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long n, m, a[100005], b[100005], c[200005], ans, tmp, pa, pb;
int main() {
scanf("%I64d%I64d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%I64d", a + i), c[i] = a[i];
for (int i = 1; i <= m; i++) scanf("%I64d", b + i), c[n + i] = b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
if (a[1] >= b[m]) {
puts("0");
return 0;
}
sort(c + 1, c + n + m + 1);
ans = 0;
pa = n;
for (int i = 1; i <= n; i++)
if (a[i] < c[1])
ans += c[1] - a[i];
else {
pa = i;
break;
}
pb = 1;
for (int i = m; i >= 1; i--)
if (b[i] > c[1])
ans += b[i] - c[1];
else {
pb = i;
break;
}
tmp = ans;
for (int i = 2; i <= n + m; i++) {
while (a[pa] < c[i] && pa <= n) tmp -= a[pa] - c[i - 1], pa++;
tmp += (pa - 1) * (c[i] - c[i - 1]);
while (c[i] > b[pb] && pb <= m) tmp -= b[pb] - c[i - 1], pb++;
tmp -= (m - pb + 1) * (c[i] - c[i - 1]);
if (ans > tmp) ans = tmp;
}
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long x[1000], y[1000];
long long calculated[1000][1000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
double ans = DBL_MAX;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
calculated[i][j] =
(x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
ans = min(ans, sqrt(calculated[i][j]));
}
}
for (int i = 0; i < n; i++) {
int j = (i + 1) % n;
for (int k = 0; k < n; k++) {
if (k == i || k == j) continue;
double A =
abs(((x[j] - x[i]) * (y[k] - y[i]) - (x[k] - x[i]) * (y[j] - y[i])) /
2.0);
long long best =
max(max(calculated[i][j], calculated[j][k]), calculated[k][i]);
ans = min(ans, A / sqrt(best));
}
}
printf("%.10lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
int par[500000];
void init(int N) {
for (int i = 0; i < (int)(N); i++) par[i] = i;
}
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
bool same(int x, int y) { return find(x) == find(y); }
void unite(int x, int y) {
x = find(x), y = find(y);
par[x] = y;
}
} UF;
int N;
vector<int> G1[500000], G2[500000];
set<pair<int, int> > es;
int I;
pair<int, int> p1[500000], p2[500000];
int ord[500000];
void dfs1(int v, int p) {
for (int u : G1[v])
if (u != p) dfs1(u, v);
if (p != -1 && !UF.same(v, p))
p1[UF.find(v)] = pair<int, int>(v, p), ord[I++] = UF.find(v);
}
void dfs2(int v, int p) {
for (int u : G2[v])
if (u != p) dfs2(u, v);
if (p != -1 && !UF.same(v, p)) p2[UF.find(v)] = pair<int, int>(v, p);
}
int main() {
cin >> N;
UF.init(N);
for (int i = 0; i < (int)(N - 1); i++) {
int a, b;
cin >> a >> b;
a--, b--;
if (a > b) swap(a, b);
es.insert(pair<int, int>(a, b));
G1[a].push_back(b);
G1[b].push_back(a);
}
for (int i = 0; i < (int)(N - 1); i++) {
int c, d;
cin >> c >> d;
c--, d--;
if (c > d) swap(c, d);
if (es.find(pair<int, int>(c, d)) != es.end()) UF.unite(c, d);
G2[c].push_back(d);
G2[d].push_back(c);
}
dfs1(0, -1);
dfs2(0, -1);
cout << I << endl;
for (int i = 0; i < (int)(I); i++) {
int v = ord[i];
printf("%d %d %d %d\n", p1[v].first + 1, p1[v].second + 1, p2[v].first + 1,
p2[v].second + 1);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char s1[50], s2[50], s3[50];
struct P {
int v, s;
};
map<string, P> mp[3];
int a[3][200];
char s[100];
int main() {
int i, j, k, m, n;
int tt = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
int atk, def, res, si;
scanf("%s%s", s1, s2);
scanf("%d%d%d%d", &atk, &def, &res, &si);
if (s2[0] == 'w') {
mp[0][s1].v = atk;
mp[0][s1].s = si;
} else if (s2[0] == 'a') {
mp[1][s1].v = def;
mp[1][s1].s = si;
} else {
mp[2][s1].v = res;
mp[2][s1].s = si;
}
tt += si;
}
scanf("%d", &k);
vector<pair<int, string> > v[3], v2[3];
for (i = 0; i < k; i++) {
int val;
scanf("%s%s%d%s", s1, s2, &val, s3);
if (s2[0] == 'g') {
v[0].push_back(make_pair(val, s3));
v2[0].push_back(make_pair(val, s1));
} else if (s2[0] == 's') {
v[1].push_back(make_pair(val, s3));
v2[1].push_back(make_pair(val, s1));
} else {
v[2].push_back(make_pair(val, s3));
v2[2].push_back(make_pair(val, s1));
}
}
if (k == tt) {
for (i = 0; i < 3; i++) {
for (j = 0; j < v[i].size(); j++) {
if (mp[i].count(v[i][j].second))
mp[i][v[i][j].second].v += v[i][j].first;
}
map<string, P>::iterator it2 = mp[i].begin();
for (map<string, P>::iterator it = mp[i].begin(); it != mp[i].end(); it++)
if (it->second.v > it2->second.v) it2 = it;
vector<string> ans;
for (int l = 0; l < 3; l++) {
for (j = 0; j < v[l].size(); j++) {
if (it2->first == v[l][j].second) ans.push_back(v2[l][j].second);
}
}
printf("%s %d", it2->first.c_str(), ans.size());
for (j = 0; j < ans.size(); j++) printf(" %s", ans[j].c_str());
puts("");
}
} else {
vector<string> ans[3];
string name[3];
set<string> st;
for (i = 0; i < 3; i++) {
sort(v2[i].begin(), v2[i].end());
map<string, P>::iterator it2 = mp[i].begin();
for (map<string, P>::iterator it = mp[i].begin(); it != mp[i].end();
it++) {
int t = 0;
for (j = v2[i].size() - 1; j >= 0 && t < it->second.s; j--, t++) {
it->second.v += v2[i][j].first;
}
if (it->second.v > it2->second.v) it2 = it;
}
name[i] = it2->first;
for (j = v2[i].size() - 1; j >= 0 && ans[i].size() < it2->second.s; j--) {
ans[i].push_back(v2[i][j].second);
st.insert(v2[i][j].second);
}
}
for (i = 0; i < 3; i++)
for (j = 0; j < v2[i].size(); j++)
if (!st.count(v2[i][j].second)) {
for (int l = 0; l < 3; l++)
if (ans[l].size() < mp[l][name[l]].s) {
ans[l].push_back(v2[i][j].second);
st.insert(v2[i][j].second);
break;
}
}
for (i = 0; i < 3; i++) {
printf("%s %d", name[i].c_str(), ans[i].size());
for (j = 0; j < ans[i].size(); j++) printf(" %s", ans[i][j].c_str());
puts("");
}
}
scanf("%*d");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
string s;
cin >> s;
long long int c1 = 0;
if (s.size() == 1) {
cout << s[0] << "\n";
continue;
}
map<int, int> mp;
string s1 = s;
sort(s1.begin(), s1.end());
for (int i = 0; i < n; i++) {
mp[s[i]]++;
}
if (s[0] == '0' && s[n - 1] == '0') {
if (mp['1'] > 0) {
int c = 0;
string s2 = "";
while (s[c] != '1') {
c++;
s2 += '0';
}
cout << s2 + '0' << "\n";
} else
cout << s << "\n";
} else if (s[0] == '0' && s[n - 1] == '1') {
if (s.compare(s1) == 0) {
cout << s << "\n";
} else {
int c = 0;
string s2 = "";
while (s[c] != '1') {
c++;
s2 += '0';
}
int j = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
j = i;
}
}
string s3 = "";
j = n - 1 - j;
while (j--) {
s3 += '1';
}
cout << s2 + "0" + s3 << "\n";
}
} else if (s[0] == '1' && s[n - 1] == '0') {
cout << '0' << "\n";
} else if (s[0] == '1' && s[n - 1] == '1') {
int j = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
j = i;
}
}
string s3 = "";
j = n - 1 - j;
while (j--) {
s3 += '1';
}
if (mp['0'] > 0) {
cout << "0" + s3 << "\n";
} else {
cout << s << "\n";
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long n1 = n / 1 * (n - 1) / 2 * (n - 2) / 3 * (n - 3) / 4 * (n - 4) / 5;
long long n2 = n1 * (n - 5) / 6;
long long n3 = n2 * (n - 6) / 7;
cout << n1 + n2 + n3;
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.