solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int t, a[1001][1001], d[1001][1001];
int check(int v) {
if (v % 3 == 2 || v == 2) return 2;
if (v % 3 == 1 || v == 1) return 1;
if (v % 3 == 0) return 3;
}
int main() {
cin >> t;
for (int i = 1; i <= t; ++i) {
int n, one = 0, two = 0, cnt = 0;
cin >> n;
for (int j = 1; j <= n; ++j) {
cin >> a[i][j];
if (check(a[i][j]) == 2) ++two;
if (check(a[i][j]) == 1) ++one;
if (check(a[i][j]) == 3) ++cnt;
}
int mn = min(one, two);
cnt += mn;
one -= mn, two -= mn;
cnt += one / 3;
cnt += two / 3;
cout << cnt << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int di[4] = {-1, 1, 0, 0};
int dj[4] = {0, 0, 1, -1};
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<vector<int> > a(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
char c;
cin >> c;
if (c == '.') {
a[i].push_back(0);
} else
a[i].push_back(-1);
}
}
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
--x1;
--x2;
--y1;
--y2;
queue<pair<int, int> > q;
q.push(make_pair(x1, y1));
a[x1][y1] = 1;
while (q.size() > 0) {
if (a[x2][y2] > 0) break;
pair<int, int> s = q.front();
q.pop();
for (int j = 0; j < 4; ++j) {
for (int i = 1; i <= k; ++i) {
if (s.first + i * di[j] >= 0 && s.first + i * di[j] < n &&
s.second + i * dj[j] >= 0 && s.second + i * dj[j] < m) {
if (a[s.first + i * di[j]][s.second + i * dj[j]] == 0) {
a[s.first + i * di[j]][s.second + i * dj[j]] =
a[s.first][s.second] + 1;
q.push(make_pair(s.first + i * di[j], s.second + i * dj[j]));
} else if (a[s.first + i * di[j]][s.second + i * dj[j]] < 0)
break;
} else
break;
}
}
}
cout << a[x2][y2] - 1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char a[1005];
int dp[1005];
dp[0] = 1;
cin >> n >> a;
for (int i = 1; i < n; i++) {
if (a[i - 1] == '=')
dp[i] = dp[i - 1];
else if (a[i - 1] == 'R')
dp[i] = dp[i - 1] + 1;
else if (dp[i - 1] > 1) {
dp[i] = 1;
} else {
dp[i] = 1;
for (int j = i - 1; j >= 0; j--) {
if (a[j] == 'L') {
if (dp[j] <= dp[j + 1]) dp[j] = dp[j + 1] + 1;
} else if (a[j] == '=') {
if (dp[j] < dp[j + 1])
dp[j] = dp[j + 1];
else if (dp[j] > dp[j + 1]) {
dp[j + 1] = dp[j];
break;
}
} else
break;
}
}
}
cout << dp[0];
for (int i = 1; i < n; i++) cout << " " << dp[i];
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e9;
const long long MB = 20;
const long long MOD = 998244353;
const long long maxN = 1e7 + 1;
vector<vector<long long>> g;
vector<bool> used;
vector<long long> h, pr;
long long n, m, k, q = -1, st = -1;
void dfs(long long v) {
used[v] = true;
for (long long u : g[v]) {
if (!used[u]) {
h[u] = h[v] + 1;
pr[u] = v;
dfs(u);
} else if (h[v] - h[u] < k && h[v] - h[u] > 1) {
q = v;
st = u;
}
}
}
vector<long long> c;
void dfs1(long long v) {
used[v] = true;
for (long long u : g[v]) {
if (!used[u] && h[u] < k) {
c[u] = c[v] ? 0 : 1;
dfs1(u);
}
}
}
void solve() {
cin >> n >> m >> k;
g.resize(n);
for (long long i = 0; i < m; i++) {
long long from, to;
cin >> from >> to;
from--;
to--;
g[from].push_back(to);
g[to].push_back(from);
}
used.resize(n);
pr.resize(n);
h.resize(n);
dfs(0);
if (q != -1) {
vector<long long> ans = {q};
while (q != st) {
q = pr[q];
ans.push_back(q);
}
cout << "2\n" << ans.size() << "\n";
for (long long i : ans) cout << i + 1 << " ";
return;
}
c.resize(n, -1);
fill(used.begin(), used.end(), false);
c[0] = 0;
dfs1(0);
vector<long long> ans;
long long cnt1 = 0, cnt2 = 0;
for (long long i = 0; i < n; i++) {
if (c[i] == 0)
cnt1++;
else if (c[i] == 1)
cnt2++;
}
if (cnt1 > cnt2) {
for (long long i = 0; i < n; i++) {
if (c[i] == 0) ans.push_back(i);
}
} else {
for (long long i = 0; i < n; i++) {
if (c[i] == 1) ans.push_back(i);
}
}
cout << "1\n";
for (long long i = 0; i < (k + 1) / 2; i++) cout << ans[i] + 1 << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed;
cout.precision(12);
srand(time(0));
long long t = 1;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, rt, delta, now, limit, m;
int weight[N], sz[N], value[N];
pair<int, int> p[N];
vector<int> a[N];
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline void getroot(int u, int par) {
sz[u] = 1;
weight[u] = 0;
for (unsigned i = 0; i < a[u].size(); ++i) {
int v = a[u][i];
if (v == par) continue;
getroot(v, u);
sz[u] += sz[v];
chkmax(weight[u], sz[v]);
}
chkmax(weight[u], n - sz[u]);
if (weight[u] < weight[rt]) rt = u;
}
inline void DFS(int u, int par) {
sz[u] = 1;
for (unsigned i = 0; i < a[u].size(); ++i) {
int v = a[u][i];
if (v == par) continue;
DFS(v, u);
sz[u] += sz[v];
}
}
inline void work(int u, int par) {
now += delta;
value[u] = now;
printf("%d %d %d\n", u, par, value[u] - value[par]);
for (unsigned i = 0; i < a[u].size(); ++i) {
int v = a[u][i];
if (v != par) work(v, u);
}
}
int main() {
read(n);
for (int i = 1; i < n; ++i) {
int u, v;
read(u);
read(v);
a[u].push_back(v);
a[v].push_back(u);
}
weight[rt = 0] = n;
getroot(1, 0);
DFS(rt, 0);
for (unsigned i = 0; i < a[rt].size(); ++i)
p[++m] = make_pair(sz[a[rt][i]], a[rt][i]);
sort(p + 1, p + m + 1);
now = 0;
for (int i = 1; i <= m; ++i) {
now += p[i].first;
if (now >= (n - 1) / 3) {
limit = i;
break;
}
}
delta = 1;
now = 0;
for (int i = 1; i <= limit; ++i) work(p[i].second, rt);
delta = now + 1;
now = 0;
for (int i = limit + 1; i <= m; ++i) work(p[i].second, rt);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int main() {
long long fib[100005];
fib[0] = fib[1] = 1;
for (int i = 2; i <= 100000; ++i) {
fib[i] = (fib[i - 1] + fib[i - 2]) % MOD;
}
int n, m;
scanf("%d%d", &n, &m);
printf("%I64d\n", 2LL * (fib[n] + fib[m] + MOD - 1) % MOD);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void pn(Arg1&& arg1) {
cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void pn(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
pn(args...);
}
template <typename Arg1>
void ps(Arg1&& arg1) {
cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void ps(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
ps(args...);
}
template <typename Arg1>
void read(Arg1&& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void read(Arg1&& arg1, Args&&... args) {
cin >> arg1;
read(args...);
}
int main() {
clock_t z = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long sum = 0;
for (long long i = 0; i < m; i++) {
if (a[i] > 0) {
break;
} else {
sum += a[i];
}
}
pn(-sum);
fprintf(stderr, "Total Time: %.3f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
template <typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }
clock_t startTime;
double getCurrentTime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
struct Edge {
int v, to, cap;
ll cost;
Edge() : v(), to(), cap(), cost() {}
Edge(int _v, int _to, int _cap, ll _cost)
: v(_v), to(_to), cap(_cap), cost(_cost) {}
};
const int N = 222;
const int V = N * N + 3;
const int E = N * N * 9 + 3;
vector<int> g[V];
Edge ed[E];
int edSz;
int S, T;
void addEdge2(int v, int to, int cap, ll cost) {
ed[edSz] = Edge(v, to, cap, cost);
g[v].push_back(edSz++);
}
void addEdge(int v, int to, int cap, ll cost) {
addEdge2(v, to, cap, cost);
addEdge2(to, v, 0, -cost);
}
ll a[N][N];
ll b[V];
int n;
bool good[V];
bool used[V];
int par[V];
int bV, bU;
int bstVal;
void dfs1(int v, int st) {
used[v] = 1;
if (good[v] && b[v] - b[st] < bstVal) {
bstVal = b[v] - b[st];
bV = st;
bU = v;
}
for (int id : g[v]) {
Edge e = ed[id];
if (e.cap <= 0) continue;
int to = e.to;
if (used[to]) continue;
par[to] = id;
dfs1(to, st);
}
}
ll MCMF() {
ll ans = 0;
while (true) {
vector<pli> ord;
for (int i = 0; i < n; i++) {
used[i] = false;
if (good[i]) ord.push_back(make_pair(b[i], i));
}
sort((ord).begin(), (ord).end());
reverse((ord).begin(), (ord).end());
bV = bU = -1;
bstVal = 0;
for (auto t : ord) {
int v = t.second;
if (used[v]) continue;
dfs1(v, v);
}
if (bstVal == 0) return ans;
ans += bstVal;
int v = bU;
while (v != bV) {
int id = par[v];
ed[id].cap--;
ed[id ^ 1].cap++;
v = ed[id].v;
}
good[bV] = good[bU] = false;
}
return ans;
}
void read() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%lld", &a[i][j]);
}
}
int main() {
startTime = clock();
read();
S = n * n;
T = S + 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (a[i][j] > 0) {
b[i * n + j] = a[i][j];
good[i * n + j] = 1;
}
}
ll ans = 0;
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++) {
if (a[x][y] == -1) continue;
if (x + 1 < n && a[x + 1][y] != -1) {
if (a[x][y] != 0 && a[x + 1][y] != 0) {
ans += abs(a[x][y] - a[x + 1][y]);
} else {
int v = x * n + y, u = (x + 1) * n + y;
addEdge2(v, u, 1, 0);
addEdge2(u, v, 1, 0);
}
}
if (y + 1 < n && a[x][y + 1] != -1) {
if (a[x][y] != 0 && a[x][y + 1] != 0) {
ans += abs(a[x][y] - a[x][y + 1]);
} else {
int v = x * n + y, u = x * n + y + 1;
addEdge2(v, u, 1, 0);
addEdge2(u, v, 1, 0);
}
}
}
n = n * n;
printf("%lld\n", ans - MCMF());
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
bool init[101010], goal[101010];
vector<int> v[101010], z;
int r(int a, int b, bool f1, bool f2) {
bool f = init[a] ^ goal[a] ^ f1;
int x = f;
if (f) z.push_back(a);
for (int c : v[a]) {
if (c != b) x += r(c, a, f2, f ? f1 ^ 1 : f1);
}
return x;
}
int main() {
ios::sync_with_stdio(0);
cin.tie();
int n, a, b;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 1; i <= n; i++) cin >> init[i];
for (int i = 1; i <= n; i++) cin >> goal[i];
cout << r(1, 0, 0, 0) << '\n';
for (int i : z) cout << i << '\n';
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
long long mod = 1e9 + 7;
long long power(long long x, long long n, long long mod) {
long long res = 1;
x %= mod;
while (n) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (auto &it : a) cin >> it;
int pos = n - 1;
while (pos > 0 && a[pos - 1] >= a[pos]) --pos;
while (pos > 0 && a[pos - 1] <= a[pos]) --pos;
cout << pos << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000;
int K, c, x, y, m, n, cnt, t, mx;
pair<pair<int, int>, int> a[maxn + 5];
int main() {
scanf("%d", &n);
for (int i = (1); i <= int(n); i++) {
scanf("%d%d%d%d%d", &K, &c, &x, &y, &m);
t = 0;
for (int j = (1); j <= int(K); j++) {
if (cnt <= maxn) a[++cnt] = make_pair(make_pair(t, c), i);
if (j < K && c > (1LL * c * x + y) % m) t++;
c = (1LL * c * x + y) % m;
}
mx = max(mx, t);
}
sort(a + 1, a + cnt + 1);
printf("%d\n", mx);
if (cnt <= maxn)
for (int i = (1); i <= int(cnt); i++)
printf("%d %d\n", a[i].first.second, a[i].second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 7;
const long long mod = 1e9 + 7;
const long long INF = 1e6 + 7;
const long long mlog = 20;
const long long SQ = 400;
long long n, k;
long long root;
long long a[maxn], dp[maxn], sz[maxn];
vector<long long> adj[maxn];
bool mark[maxn];
bool dfs(long long val, long long v = root, long long par = -1) {
bool flag = false;
mark[v] = true, sz[v] = dp[v] = 1;
if (a[v] < val) {
mark[v] = false, dp[v] = 0;
for (long long u : adj[v])
if (u != par) flag |= dfs(val, u, v), sz[v] += sz[u];
return flag;
}
long long mx1 = 0, mx2 = 0;
for (long long u : adj[v]) {
if (u == par) continue;
flag |= dfs(val, u, v), sz[v] += sz[u];
if (mark[u])
dp[v] += sz[u];
else {
mark[v] = false;
if (dp[u] >= mx1)
swap(mx1, mx2), mx1 = dp[u];
else
mx2 = max(mx2, dp[u]);
}
}
dp[v] += mx1;
return dp[v] + mx2 >= k || flag;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(), cout.tie();
;
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
long long u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v), adj[v].push_back(u);
}
root = 0;
for (long long i = 0; i < n; i++)
if (a[i] < a[root]) root = i;
long long L = a[root], R = +INF;
while (R - L > 1) {
long long mid = (L + R) / 2;
if (dfs(mid))
L = mid;
else
R = mid;
}
cout << L << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
static int s_n = 0, s_m = 0;
int s_arr[1024][1024] = {0};
int s_rrr[1024][1024] = {0};
int s_crr[1024][1024] = {0};
int s_res = 0;
int main() {
cin >> s_n >> s_m;
for (int r = 1; r <= s_n; r++) {
for (int c = 1; c <= s_m; c++) {
scanf("%d", &s_arr[r][c]);
s_rrr[r][c] = s_rrr[r][c - 1] + s_arr[r][c];
s_crr[c][r] = s_crr[c][r - 1] + s_arr[r][c];
}
}
for (int r = 1; r <= s_n; r++) {
for (int c = 1; c <= s_m; c++) {
if (s_arr[r][c] == 0) {
if (s_rrr[r][c] > 0) s_res++;
if ((s_rrr[r][s_m] - s_rrr[r][c]) > 0) s_res++;
if (s_crr[c][r] > 0) s_res++;
if ((s_crr[c][s_n] - s_crr[c][r]) > 0) s_res++;
}
}
}
cout << s_res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2.5e5;
int n, k, mod;
int f[maxn + 5][20];
int ans;
namespace usual {
int fac[maxn + 5], ifac[maxn + 5];
int add(int ta, int tb) { return ta + tb >= mod ? ta + tb - mod : ta + tb; }
int sub(int ta, int tb) { return ta < tb ? ta - tb + mod : ta - tb; }
int ksm(long long ta, int tp) {
int s = 1;
for (; tp; ta = ta * ta % mod, tp >>= 1)
if (tp & 1) s = ta * s % mod;
return s;
}
void make_fac() {
fac[0] = 1;
for (int i = 1; i <= maxn; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
ifac[maxn] = ksm(fac[maxn], mod - 2);
for (int i = maxn; i; i--) ifac[i - 1] = 1ll * ifac[i] * i % mod;
}
} // namespace usual
using namespace usual;
int dfs(int S, int i) {
if (f[S][i] != -1) return f[S][i];
if (S == 0 || i == 0) return 0;
int ST = S - (S & -S);
f[S][i] = 0;
for (int T = ST; T; T = (T - 1) & ST)
f[S][i] = add(
f[S][i], 1ll * dfs(S - T - (S & -S), i - 1) * ifac[T + (S & -S)] % mod);
f[S][i] = add(f[S][i], 1ll * dfs(S - (S & -S), i - 1) * ifac[(S & -S)] % mod);
return f[S][i];
}
int main() {
scanf("%d %d %d", &n, &k, &mod);
if (n & 1) {
printf("%d\n", ksm(k, n));
return 0;
}
make_fac();
memset(f, -1, sizeof f);
f[0][0] = 1;
for (int i = 1; i <= min(17, k); i++)
ans = add(ans, 1ll * dfs(n, i) * fac[k] % mod * ifac[k - i] % mod);
printf("%d\n", sub(ksm(k, n), 1ll * ans * fac[n] % mod));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, m, l, t = -1, arr[10000] = {0};
scanf("%d %d %d", &n, &m, &k);
int a[n][m];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) a[i][j] = 0;
for (l = 0; l < k; l++) {
scanf("%d %d", &i, &j);
i--;
j--;
a[i][j] = 1;
if (t == -1) {
if (i + 1 < n && j + 1 < m && a[i][j + 1] == 1 && a[i + 1][j] == 1 &&
a[i + 1][j + 1] == 1) {
t = l;
} else if (j - 1 >= 0 && i + 1 < n && a[i][j - 1] == 1 &&
a[i + 1][j] == 1 && a[i + 1][j - 1] == 1) {
t = l;
} else if (j + 1 < m && i - 1 >= 0 && a[i - 1][j + 1] == 1 &&
a[i - 1][j] == 1 && a[i][j + 1] == 1) {
t = l;
} else if (i - 1 >= 0 && j - 1 >= 0 && a[i][j - 1] == 1 &&
a[i - 1][j - 1] == 1 && a[i - 1][j] == 1) {
t = l;
}
}
}
if (t == -1)
printf("0\n");
else
printf("%d\n", t + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
struct Treap {
struct node {
long long key, prior, sum;
long long sz;
node *l, *r;
node(long long x)
: key(x), sum(x), sz(1), prior(rnd()), l(nullptr), r(nullptr) {}
};
using pNode = node *;
pNode root = nullptr;
long long getsum(pNode t) {
if (t == nullptr) {
return 0;
}
return t->sum;
}
long long getsz(pNode t) {
if (t == nullptr) {
return 0;
}
return t->sz;
}
void calc(pNode t) {
if (t == nullptr) {
return;
}
t->sum = t->key + getsum(t->l) + getsum(t->r);
t->sz = 1 + getsz(t->l) + getsz(t->r);
}
pair<pNode, pNode> split(pNode t, long long x) {
if (t == nullptr) {
return {nullptr, nullptr};
}
if (t->key <= x) {
auto res = split(t->r, x);
t->r = res.first;
calc(t);
return {t, res.second};
}
if (t->key > x) {
auto res = split(t->l, x);
t->l = res.second;
calc(t);
return {res.first, t};
}
}
pNode merge(pNode l, pNode r) {
if (l == nullptr) {
return r;
}
if (r == nullptr) {
return l;
}
if (l->prior > r->prior) {
l->r = merge(l->r, r);
calc(l);
return l;
} else {
r->l = merge(l, r->l);
calc(r);
return r;
}
}
void erase(long long x) {
auto res1 = split(root, x);
auto res2 = split(res1.first, x - 1);
root = merge(res2.first, res1.second);
}
void insert(long long x) {
auto res1 = split(root, x);
root = merge(merge(res1.first, new node(x)), res1.second);
}
bool sufix(long long x, long long siz) {
auto res1 = split(root, x - 1);
bool ans = (getsz(res1.second) <= siz);
root = merge(res1.first, res1.second);
return ans;
}
long long getsum(long long l, long long r) {
auto res1 = split(root, r);
auto res2 = split(res1.first, l - 1);
long long ans = getsum(res2.second);
res1.first = merge(res2.first, res2.second);
root = merge(res1.first, res1.second);
return ans;
}
};
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
long long cur_sum = 0;
set<long long> light;
Treap t;
for (long long i = 1; i <= n; i++) {
long long ans = 0;
long long type, x;
cin >> type >> x;
cur_sum += x;
if (x > 0) {
t.insert(x);
if (type == 1) {
light.insert(x);
}
} else {
t.erase(-x);
if (type == 1) {
light.erase(-x);
}
}
long long min_light = (light.size() ? *light.begin() : -1);
if (min_light == -1) {
cout << cur_sum << endl;
} else {
t.erase(min_light);
long long l = -1, r = 1e9 + 7;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (t.sufix(mid, (long long)light.size())) {
r = mid;
} else {
l = mid;
}
}
cout << cur_sum + t.getsum(r, 1e9) << endl;
t.insert(min_light);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
while (n % 10 == 0) {
n = n / 10;
}
long long int k = n;
long long int ne = 0;
while (k) {
ne = ne * 10 + k % 10;
k = k / 10;
}
if (ne == n)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int bit[4][12][12][maxn];
char s[maxn];
char e[20];
int q, x, l, r, y;
int ans;
int n, n1;
char c;
int sum(int a, int b, int c, int i) {
int s = 0;
while (i > 0) {
s += bit[a][b][c][i];
i -= i & -i;
}
return s;
}
void add(int a, int b, int c, int i, int x) {
while (i <= n) {
bit[a][b][c][i] += x;
i += i & -i;
}
}
inline int get(char x) {
if (x == 'A') return 0;
if (x == 'G') return 1;
if (x == 'C') return 2;
if (x == 'T') return 3;
}
int main() {
scanf("%s", s + 1);
cin >> q;
n = strlen(s + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 10; j++) add(get(s[i]), j, i % j, i, 1);
while (q--) {
scanf("%d", &y);
if (y == 1) {
scanf("%d %c", &x, &c);
for (int i = 1; i <= 10; i++) {
add(get(c), i, x % i, x, 1);
add(get(s[x]), i, x % i, x, -1);
}
s[x] = c;
} else {
scanf("%d%d%s", &l, &r, e + 1);
n1 = strlen(e + 1);
ans = 0;
for (int i = 1; i <= n1; i++)
ans += sum(get(e[i]), n1, (l + i - 1) % n1, r) -
sum(get(e[i]), n1, (l + i - 1) % n1, l - 1);
printf("%d\n", ans);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = 130;
const int MOD = 1000000000 + 7;
int divisors[M], pivot[N];
int a[N], b[N];
int n;
int power(int x, int y) {
if (y == 0) return 1;
int result = power(x, y >> 1);
result = (long long)result * result % MOD;
if (y & 1) {
result = (long long)result * x % MOD;
}
return result;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= a[n]; ++i) {
pivot[i] = lower_bound(a + 1, a + n + 1, i) - a;
}
long long ans = 0;
for (int x = 1; x <= a[n]; ++x) {
int length = 0;
for (int i = 1; i * i <= x; ++i) {
if (x % i == 0) {
divisors[++length] = i;
if (i * i != x) {
divisors[++length] = x / i;
}
}
}
sort(divisors + 1, divisors + length + 1);
long long temp1 = 1;
for (int i = 1; i <= length; ++i) {
int number = i == length ? n - pivot[divisors[i]] + 1
: pivot[divisors[i + 1]] - pivot[divisors[i]];
temp1 = temp1 * power(i, number) % MOD;
}
long long temp2 = 1;
if (length == 1)
temp2 = 0;
else {
for (int i = 1; i < length; ++i) {
int number = i == length - 1
? n - pivot[divisors[i]] + 1
: pivot[divisors[i + 1]] - pivot[divisors[i]];
temp2 = temp2 * power(i, number) % MOD;
}
}
ans = ((ans + temp1 - temp2) % MOD + MOD) % MOD;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<bool> > pic, ray, vis;
vector<int> ans;
int cnt;
void floodfill(int x, int y) {
if (vis[x][y] || !pic[x][y]) return;
vis[x][y] = true;
if (!pic[x - 2][y] && !pic[x + 2][y]) {
if (!pic[x][y - 1] && (!pic[x - 2][y + 5] || !pic[x + 2][y + 5]))
ray[x][y] = true;
if (!pic[x][y + 1] && (!pic[x - 2][y - 5] || !pic[x + 2][y - 5]))
ray[x][y] = true;
}
if (!pic[x][y - 2] && !pic[x][y + 2]) {
if (!pic[x - 1][y] && (!pic[x + 5][y - 2] || !pic[x + 5][y + 2]))
ray[x][y] = true;
if (!pic[x + 1][y] && (!pic[x - 5][y - 2] || !pic[x - 5][y + 2]))
ray[x][y] = true;
}
if (ray[x][y] && !ray[x - 1][y - 1] && !ray[x - 1][y + 1] &&
!ray[x + 1][y - 1] && !ray[x + 1][y + 1])
++cnt;
floodfill(x - 1, y);
floodfill(x + 1, y);
floodfill(x, y - 1);
floodfill(x, y + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
pic = ray = vis = vector<vector<bool> >(n + 4, vector<bool>(m + 4));
char c;
n++, m++;
for (int i = 2; i <= n; ++i) {
for (int j = 2; j <= m; ++j) {
cin >> c;
pic[i][j] = (c == '1');
}
}
for (int i = 2; i <= n; ++i) {
for (int j = 2; j <= m; ++j) {
if (pic[i][j] && !vis[i][j]) {
cnt = 0;
floodfill(i, j);
ans.push_back(cnt);
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (vector<int>::iterator it = ans.begin(); it != ans.end(); ++it)
cout << *it << ' ';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void init_code() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long N = 3e5;
int a[N];
int ma[N];
int dp[4001][4001][2];
int n;
int make(int i, int j, int k) {
if (i == 2 * n) {
if (j == n) return 1;
return 0;
}
if (dp[i][j][k] == -1) {
if (k == 0) {
if (ma[i] == a[i]) {
dp[i][j][k] = (make(i + 1, j, 1) | make(i + 1, j + 1, 0));
} else
dp[i][j][k] = make(i + 1, j + 1, 0);
} else {
if (ma[i] == a[i]) {
dp[i][j][k] = (make(i + 1, j, 1) | make(i + 1, j + 1, 0));
} else
dp[i][j][k] = make(i + 1, j, 1);
}
}
return dp[i][j][k];
}
int main() {
init_code();
long long t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
if (i == 0)
ma[i] = a[i];
else
ma[i] = max(ma[i - 1], a[i]);
}
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < 2 * n; j++) {
for (int k = 0; k < 2; k++) dp[i][j][k] = -1;
}
}
if (make(0, 0, 0))
cout << "YES";
else
cout << "NO";
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int v, id;
bool operator<(const node& tmp) const { return v < tmp.v; }
};
vector<node> fi;
vector<node> se;
long long ans;
int mark[200005];
int cnt;
int qi[5];
int main() {
int n, m, i, j, a, b, c, d, k;
cin >> n >> k;
ans = 2000000007;
ans *= 2000000007;
for (i = 1; i <= n; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
fi.push_back((node){a + c, i});
se.push_back((node){b + d, i});
}
if (n == 2 && k == 1) {
puts("1");
return 0;
}
sort(fi.begin(), fi.end());
sort(se.begin(), se.end());
int q = fi.size(), w = se.size();
int t1 = min(k + 1, q), t2 = min(k + 1, w);
for (i = 0; i < t1; i++) {
if (i != 0) {
if (mark[fi[i - 1].id] == 0) cnt++;
mark[fi[i - 1].id]++;
}
if (i != 0 && fi[i].v == fi[i - 1].v) continue;
for (j = 0; j < t2; j++) {
if (j != 0) {
if (mark[se[j - 1].id] == 0) cnt++;
mark[se[j - 1].id]++;
} else {
if (qi[2]) {
for (a = 1; a < t2; a++) {
if (mark[se[a - 1].id] == 1) cnt--;
mark[se[a - 1].id]--;
}
}
}
if (j != 0 && se[j].v == se[j - 1].v) continue;
int t3 = max(q - k - 1, i);
for (a = q - 1; a >= t3; a--) {
if (a != q - 1) {
if (mark[fi[a + 1].id] == 0) cnt++;
mark[fi[a + 1].id]++;
} else {
if (qi[3]) {
for (b = q - 2; b >= t3; b--) {
if (mark[fi[b + 1].id] == 1) cnt--;
mark[fi[b + 1].id]--;
}
}
}
if (a != q - 1 && fi[a].v == fi[a + 1].v) continue;
int t4 = max(w - k - 1, j);
for (b = w - 1; b >= t4; b--) {
if (b != w - 1) {
if (mark[se[b + 1].id] == 0) cnt++;
mark[se[b + 1].id]++;
} else {
if (qi[4]) {
for (c = w - 2; c >= t4; c--) {
if (mark[se[c + 1].id] == 1) cnt--;
mark[se[c + 1].id]--;
}
}
}
if (b != w - 1 && se[b].v == se[b + 1].v) continue;
if (cnt <= k) {
int L = se[b].v - se[j].v;
int R = fi[a].v - fi[i].v;
if (L <= 1) L = 2;
if (R <= 1) R = 2;
ans = min(ans, 1LL * L * R / 4);
}
}
qi[4]++;
}
qi[3]++;
}
qi[2]++;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int DP[105][105];
int solve(int a, int b) {
if (a == 0 || b == 0) return 0;
if (DP[a][b] != -1) return DP[a][b];
int chargeA = 0;
int chargeB = 0;
if (b - 2 >= 0) chargeA += 1 + solve(a + 1, b - 2);
if (a - 2 >= 0) chargeB += 1 + solve(a - 2, b + 1);
DP[a][b] = max(chargeA, chargeB);
return max(chargeA, chargeB);
}
int main() {
memset(DP, -1, sizeof(DP));
int a, b;
cin >> a >> b;
cout << solve(a, b);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18 + 7;
const long long MOD = 1e9 + 7;
const int N = 1e5 + 7;
const double pi = acos(-1);
vector<pair<long long, int> > a;
int n;
long long st[4 * N];
bool cmp(pair<long long, int> a, pair<long long, int> b) {
if (abs(a.first - b.first) > 0.0001) return a.first < b.first;
return a.second > b.second;
}
void update(int id, int l, int r, int i, long long v) {
if (i < l || i > r) return;
if (l == r) {
st[id] = v;
return;
}
int mid = (l + r) / 2;
update(id * 2, l, mid, i, v);
update(id * 2 + 1, mid + 1, r, i, v);
st[id] = max(st[id * 2], st[id * 2 + 1]);
}
long long get(int id, int l, int r, int u, int v) {
if (u > v) return 0;
if (l > v || u > r) return 0;
if (u <= l && r <= v) return st[id];
int mid = (l + r) / 2;
return max(get(id * 2, l, mid, u, v), get(id * 2 + 1, mid + 1, r, u, v));
}
int main() {
srand(time(NULL));
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
assert(1 <= n && n <= 1e5);
for (int i = 0; i < n; i++) {
long long r, h;
cin >> r >> h;
assert(1 <= r && r <= 1e4);
assert(1 <= h && h <= 1e4);
a.push_back(pair<long long, int>(r * r * h, i));
}
sort(a.begin(), a.end(), cmp);
long long res = 0;
for (auto e : a) {
long long tmp = e.first + get(1, 0, n - 1, 0, e.second - 1);
res = max(res, tmp);
update(1, 0, n - 1, e.second, tmp);
}
cout << setprecision(10) << setiosflags(ios::fixed) << res * pi << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int prime = 151;
const long long mod = 1e9 + 7;
const int maxn = 5e1 + 5;
const int inf = 0x3f3f3f3f;
int t, n;
vector<string> vt(maxn);
inline bool ok() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (vt[i][j] == '1') {
if (i == n - 1 || j == n - 1) continue;
if (vt[i][j + 1] != '1' && vt[i + 1][j] != '1') return false;
}
}
}
return true;
}
int main() {
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; ++i) cin >> vt[i];
if (ok())
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-4;
const long double PI = acos((long double)-1.0);
const long long int MOD = 1e9 + 7;
long long int powmod(long long int a, long long int b, long long int mod) {
long long int res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int debug = 1;
template <typename T, typename S>
void DBG(pair<T, S> p) {
if (debug) cout << p.first << " " << p.second << endl;
}
template <typename T>
void DBG(vector<T> v) {
if (debug) {
for (T t : v) cout << t << " ";
cout << endl;
}
}
template <typename T>
void DBG(T t) {
if (debug) cout << t << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(10);
cout << fixed;
int n;
cin >> n;
vector<long long int> diag(2 * n - 1, 0), anti(2 * n - 1, 0);
vector<vector<int>> v(n, vector<int>(n));
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (n); ++j) {
cin >> v[i][j];
diag[j - i + (n - 1)] += v[i][j];
anti[i + j] += v[i][j];
}
}
vector<long long int> best(2, 0);
vector<pair<int, int>> p(2);
multimap<long long int, pair<int, int>> mm, mm2;
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (n); ++j) {
long long int value = (diag[j - i + (n - 1)] + anti[i + j] - v[i][j]);
if (value >= best[(i + j) % 2]) {
best[(i + j) % 2] = value;
p[(i + j) % 2] = make_pair(i + 1, j + 1);
}
}
}
DBG(accumulate(best.begin(), best.end(), 0LL));
DBG(vector<int>{p[0].first, p[0].second, p[1].first, p[1].second});
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[110], b[22], c[10010], d[10010], f[1100000], g[22][22], n, t, m, p, i, j,
k, x;
void bfs(int x) {
memset(d, 0x3f, sizeof(d));
queue<int> q;
q.push(x), d[x] = 0;
while (q.size()) {
x = q.front(), q.pop();
for (int i = 1; i <= m; i++) {
if (x >= a[i] && d[x - a[i]] > d[x] + 1)
d[x - a[i]] = d[x] + 1, q.push(x - a[i]);
if (x + a[i] <= n && d[x + a[i]] > d[x] + 1)
d[x + a[i]] = d[x] + 1, q.push(x + a[i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> t >> m;
for (i = 1; i <= t; i++) cin >> x, c[x] = 1;
for (i = 0; i <= n; i++)
if (c[i] != c[i + 1]) b[++p] = i;
for (i = 1; i <= m; i++) cin >> a[i];
for (i = 1; i <= p; i++) {
bfs(b[i]);
for (j = 1; j <= p; j++) g[i][j] = d[b[j]];
}
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (i = 0; i < 1 << p; i++)
for (j = 0; j < p; j++)
if (!(i >> j & 1))
for (k = j + 1; k < p; k++)
if (!(i >> k & 1))
f[i | 1 << j | 1 << k] =
min(f[i | 1 << j | 1 << k], f[i] + g[j + 1][k + 1]);
cout << (f[(1 << p) - 1] == 0x3f3f3f3f ? -1 : f[(1 << p) - 1]) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, L, s, t;
vector<pair<long long, long long> > adj[1111];
vector<long long> todo;
long long w[11111], u[11111], v[11111], d[1111];
void dijkstra() {
for (long long i = 0; i <= n; i++) d[i] = (1LL << 60);
d[s] = 0LL;
priority_queue<pair<long long, long long> > pq;
pq.push({0, s});
while (!pq.empty()) {
long long x = pq.top().second;
long long t = -pq.top().first;
pq.pop();
if (d[x] < t) continue;
for (auto i : adj[x]) {
if (d[i.first] > d[x] + i.second) {
d[i.first] = d[x] + i.second;
pq.push({-d[i.first], i.first});
}
}
}
}
long long check(long long x) {
for (auto i : todo) {
w[i] = 1 + min(x, 1000000000LL);
x -= w[i] - 1;
}
for (long long i = 0; i <= n; i++) adj[i].clear();
for (long long i = 0; i < m; i++) {
adj[v[i]].push_back({u[i], w[i]});
adj[u[i]].push_back({v[i], w[i]});
}
dijkstra();
return d[t];
}
int main() {
scanf("%lld%lld%lld%lld%lld", &n, &m, &L, &s, &t);
for (long long i = 0; i < m; i++) {
long long a, b, c;
scanf("%lld%lld%lld", u + i, v + i, w + i);
if (w[i] == 0) todo.push_back(i);
}
long long l = 0, d = 1000000000LL * todo.size(), mid, ans = -1;
if (check(0) > L || check(d) < L) {
printf("NO\n");
return 0;
}
while (l <= d) {
mid = (l + d) / 2;
if (check(mid) <= L) {
ans = mid;
l = mid + 1;
} else
d = mid - 1;
}
check(ans);
printf("YES\n");
for (long long i = 0; i < m; i++) {
printf("%lld %lld %lld\n", u[i], v[i], w[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string uncle;
string cat;
string dog;
cin >> uncle;
cin >> cat;
cin >> dog;
if (uncle == "rock" && cat == "rock" && dog == "rock") {
cout << "?";
} else if (uncle == "rock" && cat == "rock" && dog == "paper") {
cout << "S";
} else if (uncle == "rock" && cat == "rock" && dog == "scissors") {
cout << "?";
} else if (uncle == "rock" && cat == "paper" && dog == "rock") {
cout << "M";
} else if (uncle == "rock" && cat == "paper" && dog == "paper") {
cout << "?";
} else if (uncle == "rock" && cat == "paper" && dog == "scissors") {
cout << "?";
} else if (uncle == "rock" && cat == "scissors" && dog == "rock") {
cout << "?";
} else if (uncle == "rock" && cat == "scissors" && dog == "paper") {
cout << "?";
} else if (uncle == "rock" && cat == "scissors" && dog == "scissors") {
cout << "F";
} else if (uncle == "paper" && cat == "rock" && dog == "rock") {
cout << "F";
} else if (uncle == "paper" && cat == "rock" && dog == "paper") {
cout << "?";
} else if (uncle == "paper" && cat == "rock" && dog == "scissors") {
cout << "?";
} else if (uncle == "paper" && cat == "paper" && dog == "rock") {
cout << "?";
} else if (uncle == "paper" && cat == "paper" && dog == "paper") {
cout << "?";
} else if (uncle == "paper" && cat == "paper" && dog == "scissors") {
cout << "S";
} else if (uncle == "paper" && cat == "scissors" && dog == "rock") {
cout << "?";
} else if (uncle == "paper" && cat == "scissors" && dog == "paper") {
cout << "M";
} else if (uncle == "paper" && cat == "scissors" && dog == "scissors") {
cout << "?";
} else if (uncle == "scissors" && cat == "rock" && dog == "rock") {
cout << "?";
} else if (uncle == "scissors" && cat == "rock" && dog == "paper") {
cout << "?";
} else if (uncle == "scissors" && cat == "rock" && dog == "scissors") {
cout << "M";
} else if (uncle == "scissors" && cat == "paper" && dog == "rock") {
cout << "?";
} else if (uncle == "scissors" && cat == "paper" && dog == "paper") {
cout << "F";
} else if (uncle == "scissors" && cat == "paper" && dog == "scissors") {
cout << "?";
} else if (uncle == "scissors" && cat == "scissors" && dog == "rock") {
cout << "S";
} else if (uncle == "scissors" && cat == "scissors" && dog == "paper") {
cout << "?";
} else if (uncle == "scissors" && cat == "scissors" && dog == "scissors") {
cout << "?";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
;
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long n = s.length(), c1 = 0, ca = 0, cb = 0;
for (int i = 0; i < n; i++) {
if (isdigit(s[i])) {
c1++;
} else if ((s[i] - 'a') >= 0 && (s[i] - 'a') < 26) {
ca++;
} else if ((s[i] - 'A') >= 0 && (s[i] - 'A') < 26) {
cb++;
}
}
if (c1 == 0 && ca == 0) {
s = "a1" + s.substr(2);
cout << s << endl;
continue;
}
if (c1 == 0 && cb == 0) {
s = "A1" + s.substr(2);
cout << s << endl;
continue;
}
if (cb == 0 && ca == 0) {
s = "aA" + s.substr(2);
cout << s << endl;
continue;
}
if (c1 == 0) {
if (cb != 1) {
for (int i = 0; i < n; i++) {
if ((s[i] - 'A') >= 0 && (s[i] - 'A') < 26) {
s[i] = '1';
break;
}
}
} else {
for (int i = 0; i < n; i++) {
if ((s[i] - 'a') >= 0 && (s[i] - 'a') < 26) {
s[i] = '1';
break;
}
}
}
cout << s << endl;
continue;
}
if (cb == 0) {
if (ca != 1) {
for (int i = 0; i < n; i++) {
if ((s[i] - 'a') >= 0 && (s[i] - 'a') < 26) {
s[i] = 'A';
break;
}
}
} else {
for (int i = 0; i < n; i++) {
if (isdigit(s[i])) {
s[i] = 'A';
break;
}
}
}
cout << s << endl;
continue;
}
if (ca == 0) {
if (cb != 1) {
for (int i = 0; i < n; i++) {
if ((s[i] - 'A') >= 0 && (s[i] - 'A') < 26) {
s[i] = 'a';
break;
}
}
} else {
for (int i = 0; i < n; i++) {
if (isdigit(s[i])) {
s[i] = 'a';
break;
}
}
}
cout << s << endl;
continue;
}
cout << s << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, i, m, ans = 0;
cin >> n >> m;
vector<long long> vec(m);
for (i = 0; i < m; i++) {
cin >> vec[i];
}
ans += vec[0] - 1;
for (i = 0; i < m - 1; i++) {
if (vec[i] <= vec[i + 1]) {
ans += vec[i + 1] - vec[i];
} else {
ans += n - vec[i];
ans += vec[i + 1];
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long test = 1;
while (test--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s = "ROYGBIV";
int n, x, r;
cin >> n;
x = n % 7;
r = n / 7;
for (int i = 0; i < r; i++) {
cout << s;
n = n - 7;
}
if (x > 3) cout << s.substr(0, x);
if (x <= 3 && x > 1) cout << s.substr(x, n);
if (x == 1) cout << 'G';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool sortsec(const pair<int, int> &a, const pair<int, int> &b) {
return a.first + a.second > b.first + b.second;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, r;
int a, b;
vector<pair<int, int> > vect, rect;
cin >> n >> r;
for (int i = 0; i < n; i++) {
cin >> a >> b;
(b >= 0 ? vect : rect).emplace_back(a, b);
}
sort(vect.begin(), vect.end());
for (auto &ve : vect) {
if (ve.first > r) {
cout << "NO"
<< "\n";
exit(0);
}
r = r + ve.second;
}
sort(rect.begin(), rect.end(), sortsec);
for (auto &re : rect) {
if (r < re.first) {
cout << "NO"
<< "\n";
exit(0);
}
r = r + re.second;
}
if (r < 0) {
cout << "NO"
<< "\n";
exit(0);
}
cout << "YES"
<< "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool prime(int p) {
for (int i = 2; i * i <= p; ++i) {
if (p % i == 0) return 0;
}
return 1;
}
int main() {
int p, y;
cin >> p >> y;
int pp = y;
while (!prime(pp)) --pp;
for (int i = y; i > pp; --i) {
bool yes = 1;
for (int j = 2; j <= p; ++j) {
if (i % j == 0) {
yes = 0;
break;
}
}
if (yes) {
cout << i << endl;
return 0;
}
}
if (pp <= p) {
puts("-1");
return 0;
}
cout << pp << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
inline int in() {
int k = 0;
char ch = getchar();
bool p = 1;
while (ch < '-') ch = getchar();
if (ch == '-') ch = getchar(), p = 0;
while (ch > '-') k = k * 10 + ch - '0', ch = getchar();
return p ? k : -k;
}
const int YL = 1e9 + 7, N = 1 << 20;
inline int MO(const int &x) { return x >= YL ? x - YL : x; }
inline int ksm(int a, int k) {
int r = 1;
while (k) {
if (k & 1) r = 1ll * r * a % YL;
a = 1ll * a * a % YL, k >>= 1;
}
return r;
}
int len, a[N], cnt[N];
void fwt(int *a, int opt = 1) {
for (int st = 2, m = 1; st <= len; st <<= 1, m <<= 1)
for (int *p = a; p != a + len; p += st)
for (int k = 0, x, y; k < m; p[k] = MO(x + y), ++k)
x = p[k], y = p[k + m], p[k + m] = MO(x - y + YL);
if (opt == 1) return;
int inv = ksm(len, YL - 2);
for (int i = 0; i < len; ++i) a[i] = 1ll * a[i] * inv % YL;
}
char S[N];
int main() {
int n = in();
len = 1 << n;
scanf("%s", S);
for (int i = 0; i < len; ++i) a[i] = S[i] - '0';
for (int i = 0; i < len; ++i) cnt[i] = cnt[i >> 1] + (i & 1);
fwt(a);
for (int i = 0; i < len; ++i) a[i] = 1ll * a[i] * a[i] % YL;
fwt(a, -1);
int ans = 0;
for (int i = 0; i < len; ++i)
ans = (1ll * a[i] * ksm(2, n - cnt[i]) + ans) % YL;
ans = MO(MO(ans + ans) + ans);
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int maxn = 1e4 + 100;
int T, n, a[maxn], ans1[maxn * 3], ans2[maxn * 3], ans3[maxn * 3], cnt;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
cnt = 0;
int sum = 0;
for (int i = 1; i <= n; ++i) scanf("%d", a + i), sum += a[i];
if (sum % n) {
puts("-1");
continue;
}
sum /= n;
for (int i = 2; i <= n; ++i) {
int need = (i - (a[i] % i)) % i;
if (need) ans1[++cnt] = 1, ans2[cnt] = i, ans3[cnt] = need;
ans1[++cnt] = i, ans2[cnt] = 1, ans3[cnt] = (a[i] + need) / i;
}
for (int i = 2; i <= n; ++i)
ans1[++cnt] = 1, ans2[cnt] = i, ans3[cnt] = sum;
printf("%d\n", cnt);
for (int i = 1; i <= cnt; ++i)
printf("%d %d %d\n", ans1[i], ans2[i], ans3[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int t, f, next;
Edge() {}
Edge(int a, int b, int c) : t(a), f(b), next(c) {}
};
Edge e[5000000];
int head[100010], vs, vt, tot;
inline void addEdge(int x, int y, int z) {
e[++tot] = Edge(y, z, head[x]);
head[x] = tot;
e[++tot] = Edge(x, 0, head[y]);
head[y] = tot;
}
namespace Flow {
int d[100010], cur[100010];
queue<int> q;
bool bfs() {
while (!q.empty()) q.pop();
for (int i = vs; i <= vt; i++) d[i] = -1;
d[vs] = 0;
cur[vs] = head[vs];
q.push(vs);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i != -1; i = e[i].next)
if (e[i].f && d[e[i].t] == -1) {
int u = e[i].t;
d[u] = d[x] + 1;
cur[u] = head[u];
if (u == vt) return 1;
q.push(u);
}
}
return 0;
}
int dfs(int x, int a) {
if (x == vt || !a) return a;
int ans = 0;
for (int &i = cur[x]; i != -1; i = e[i].next)
if (e[i].f && d[e[i].t] == d[x] + 1) {
int u = e[i].t;
int f = dfs(u, min(a, e[i].f));
if (f) {
e[i].f -= f;
e[i ^ 1].f += f;
ans += f;
a -= f;
if (!a) break;
}
}
return ans;
}
int maxflow() {
int ans = 0;
while (bfs()) ans += dfs(vs, 0x3f3f3f3f);
return ans;
}
} // namespace Flow
int *num[100005], *id[100005], *ans1[100005];
char *ans2[100005];
pair<int, int> a[100005];
bool solve(int n, int m, int k, int val) {
vs = 0;
vt = k + 3;
tot = -1;
for (int i = vs; i <= vt; i++) head[i] = -1;
int sz1 = 0, sz2 = 0;
for (int i = 1; i <= k; i++) id[a[i].first][a[i].second] = i;
for (int i = 1; i <= k; i++) {
int x = a[i].first, y = a[i].second;
if (!((x ^ y) & 1)) {
sz1++;
addEdge(vs, i, 1);
bool v = 0;
if (x > 1) {
if (num[x - 1][y] < val)
v = 1;
else if (num[x - 1][y] == val)
addEdge(id[x][y], id[x - 1][y], 1);
}
if (x < n) {
if (num[x + 1][y] < val)
v = 1;
else if (num[x + 1][y] == val)
addEdge(id[x][y], id[x + 1][y], 1);
}
if (y > 1) {
if (num[x][y - 1] < val)
v = 1;
else if (num[x][y - 1] == val)
addEdge(id[x][y], id[x][y - 1], 1);
}
if (y < m) {
if (num[x][y + 1] < val)
v = 1;
else if (num[x][y + 1] == val)
addEdge(id[x][y], id[x][y + 1], 1);
}
if (v) addEdge(i, k + 2, 1);
} else {
sz2++;
addEdge(i, vt, 1);
bool v = 0;
if (x > 1 && num[x - 1][y] < val) v = 1;
if (x < n && num[x + 1][y] < val) v = 1;
if (y > 1 && num[x][y - 1] < val) v = 1;
if (y < m && num[x][y + 1] < val) v = 1;
if (v) addEdge(k + 1, i, 1);
}
}
addEdge(k + 2, k + 1, 0x3f3f3f3f);
addEdge(k + 1, vt, sz1);
addEdge(vs, k + 2, sz2);
if (Flow::maxflow() < sz1 + sz2) return 0;
for (int i = 1; i <= k; i++) {
int x = a[i].first, y = a[i].second;
if (!((x ^ y) & 1)) {
for (int j = head[i]; j != -1; j = e[j].next)
if (e[j].t == k + 2 && !e[j].f) {
if (x > 1 && num[x - 1][y] < val) {
ans1[x][y] = val - num[x - 1][y];
ans2[x][y] = 'U';
} else if (x < n && num[x + 1][y] < val) {
ans1[x][y] = val - num[x + 1][y];
ans2[x][y] = 'D';
} else if (y > 1 && num[x][y - 1] < val) {
ans1[x][y] = val - num[x][y - 1];
ans2[x][y] = 'L';
} else if (y < m && num[x][y + 1] < val) {
ans1[x][y] = val - num[x][y + 1];
ans2[x][y] = 'R';
}
} else if (e[j].t >= 1 && e[j].t <= k && !e[j].f) {
int u = a[e[j].t].first, v = a[e[j].t].second;
ans1[x][y] = 1;
ans1[u][v] = val - 1;
if (u == x - 1) {
ans2[x][y] = 'U';
ans2[u][v] = 'D';
} else if (u == x + 1) {
ans2[x][y] = 'D';
ans2[u][v] = 'U';
} else if (v == y - 1) {
ans2[x][y] = 'L';
ans2[u][v] = 'R';
} else if (v == y + 1) {
ans2[x][y] = 'R';
ans2[u][v] = 'L';
}
}
} else {
for (int j = head[i]; j != -1; j = e[j].next)
if (e[j].t == k + 1 && e[j].f) {
if (x > 1 && num[x - 1][y] < val) {
ans1[x][y] = val - num[x - 1][y];
ans2[x][y] = 'U';
} else if (x < n && num[x + 1][y] < val) {
ans1[x][y] = val - num[x + 1][y];
ans2[x][y] = 'D';
} else if (y > 1 && num[x][y - 1] < val) {
ans1[x][y] = val - num[x][y - 1];
ans2[x][y] = 'L';
} else if (y < m && num[x][y + 1] < val) {
ans1[x][y] = val - num[x][y + 1];
ans2[x][y] = 'R';
}
}
}
}
return 1;
}
bool cmp(pair<int, int> x, pair<int, int> y) {
return num[x.first][x.second] < num[y.first][y.second];
}
pair<int, int> b[100005];
int main() {
int cases;
scanf("%d", &cases);
for (; cases; cases--) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n + 1; i++) {
num[i] = new int[m + 2];
id[i] = new int[m + 2];
ans1[i] = new int[m + 2];
ans2[i] = new char[m + 2];
memset(num[i], 0, sizeof(int) * (m + 2));
memset(id[i], 0, sizeof(int) * (m + 2));
memset(ans1[i], 0, sizeof(int) * (m + 2));
memset(ans2[i], 0, sizeof(char) * (m + 2));
}
int sz = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &num[i][j]);
b[++sz] = pair<int, int>(i, j);
}
sort(b + 1, b + sz + 1, cmp);
bool v = 1;
for (int i = 1, j = 1; i <= sz; i = j + 1) {
while (j < sz && num[b[i].first][b[i].second] ==
num[b[j + 1].first][b[j + 1].second])
j++;
int sz2 = 0;
for (int k = i; k <= j; k++) a[++sz2] = b[k];
if (!solve(n, m, sz2, num[b[i].first][b[i].second])) {
v = 0;
break;
}
}
if (!v)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d ", ans1[i][j]);
printf("\n");
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c ", ans2[i][j]);
printf("\n");
}
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
int n, m;
long long lb, ub, mid;
long long a[100024];
inline bool C(long long x) {
int index = n, k = 0;
long long cur = a[index], tee = x;
while (index > 0 && k < m) {
x = tee - index;
if (x <= 0) return 0;
while (x >= cur) {
x -= cur;
--index;
if (index < 1) return 1;
cur = a[index];
}
cur -= x;
++k;
}
if (index > 0) return false;
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1), __ = (n); i <= __; ++i) scanf("%I64d", a + i), ub += a[i];
for (int i = (n), __ = (1); i >= __; --i)
if (!a[i])
--n;
else
break;
lb = 0;
ub += n;
while (lb <= ub) {
mid = (lb + ub) >> 1;
if (C(mid))
ub = mid - 1;
else
lb = mid + 1;
}
if (lb > mid) mid = lb;
if (ub > mid) mid = ub;
printf("%I64d\n", mid);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int MAX_N = 100000;
int N;
int A[MAX_N + 1];
int C[MAX_N + 1];
int min(int a, int b) { return a < b ? a : b; }
bool isPalindrome() {
int i = 0;
int j = N - 1;
while (i <= j && A[i] == A[j]) {
++i;
--j;
}
return i > j;
}
struct Result {
Result() : ok(false) {}
Result(int left, int right) : ok(true), left(left), right(right) {}
bool ok;
int left;
int right;
};
Result solve() {
int i = 0;
int j = N - 1;
for (int i = 1; i <= N; ++i) {
C[i] = 0;
}
while (i <= j && A[i] == A[j]) {
++i;
--j;
}
int left = i;
int right = j;
int miss_matches = 0;
while (i <= j) {
while (i <= j && C[A[j]] == 0) {
C[A[i]] += 1;
miss_matches += 1;
++i;
}
right = i - 1;
if (i > j) {
break;
}
while (i <= j && C[A[j]] > 0) {
C[A[j]] -= 1;
miss_matches -= 1;
--j;
}
if (miss_matches == 0) {
while (i <= j && A[i] == A[j]) {
++i;
--j;
}
}
}
int odds = 0;
for (int i = 1; i <= N; ++i) {
if (C[i] & 1) {
odds += 1;
}
}
if (odds > ((N & 1) ? 1 : 0)) {
return Result();
} else {
return Result(left + 1, N - right);
}
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", &A[i]);
}
if (isPalindrome()) {
printf("%lld\n", (long long)N * (N + 1) / 2);
} else {
Result res1 = solve();
for (int i = 0, j = N - 1; i < j; ++i, --j) {
int t = A[i];
A[i] = A[j];
A[j] = t;
}
Result res2 = solve();
long long ans = 0;
if (res1.ok) {
ans += (long long)res1.left * res1.right;
}
if (res2.ok) {
ans += (long long)res2.left * res2.right;
}
if (res1.ok && res2.ok) {
ans -= (long long)res1.left * res2.left;
}
printf("%lld\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000003;
char s[maxn], t[maxn], tt[maxn];
int kmp[maxn];
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%s", s + 1);
int n = strlen(s + 1), p, len = 0;
for (p = 1; p <= n / 2 && s[p] == s[n - p + 1]; p++)
;
if (p > n / 2) {
puts(s + 1);
continue;
}
for (int i = p; i <= n - p + 1; i++) t[++len] = s[i];
for (int i = 1; i <= len; i++) t[i + len] = t[i];
reverse(t + len + 1, t + len * 2 + 1);
len *= 2;
int pos = 0;
for (int i = 2; i <= len; i++) {
while (pos && t[pos + 1] != t[i]) pos = kmp[pos];
if (t[pos + 1] == t[i]) pos++;
kmp[i] = pos;
}
int tmp = kmp[len];
while (tmp > len / 2) tmp = kmp[tmp];
int ANS1 = (p - 1) * 2 + tmp;
for (int i = 1; i <= len; i++) tt[i] = t[i], kmp[i] = 0;
len = 0;
for (int i = n - p + 1; i >= p; i--) t[++len] = s[i];
for (int i = 1; i <= len; i++) t[i + len] = t[i];
reverse(t + len + 1, t + len * 2 + 1);
len *= 2;
pos = 0;
for (int i = 2; i <= len; i++) {
while (pos && t[pos + 1] != t[i]) pos = kmp[pos];
if (t[pos + 1] == t[i]) pos++;
kmp[i] = pos;
}
tmp = kmp[len];
while (tmp > len / 2) tmp = kmp[tmp];
int ANS2 = (p - 1) * 2 + tmp;
for (int i = 1; i <= len; i++) kmp[i] = 0;
for (int i = 1; i < p; i++) putchar(s[i]);
if (ANS1 > ANS2)
for (int i = 1; i <= ANS1 - (p - 1) * 2; i++) putchar(tt[i]);
else
for (int i = 1; i <= ANS2 - (p - 1) * 2; i++) putchar(t[i]);
for (int i = p - 1; i >= 1; i--) putchar(s[i]);
putchar('\n');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l, c, d, p, nl, np;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
int a = k * l / nl;
int b = c * d;
int z = p / np;
int m = min(a, b);
m = min(m, z);
cout << m / n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int n, a, k;
char s[2000007], res[2000007];
bool vis[2000007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
long long int maxn = -1;
for (long long int i = 0; i < n; ++i) {
cin >> s >> k;
long long int len = strlen(s);
long long int cur = INT_MIN;
for (long long int j = 0; j < k; ++j) {
cin >> a;
a--;
maxn = max(maxn, a + len);
for (long long int jj = max(cur, a); jj <= a + len - 1; ++jj) {
if (!vis[jj]) {
vis[jj] = 1;
res[jj] = s[jj - a];
}
}
cur = max(cur, a + len - 1);
}
}
for (long long int i = 0; i < maxn; ++i)
if (!res[i])
cout << 'a';
else
cout << res[i];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10, size = 1 << 20, mod = 998244353, inf = 2e9;
const long long INF = 1e15;
template <class o>
void qr(o& x) {
char c = getchar();
x = 0;
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x *= f;
}
template <class o>
void qw(o x) {
if (x / 10) qw(x / 10);
putchar(x % 10 + '0');
}
template <class o>
void pr1(o x) {
if (x < 0) x = -x, putchar('-');
qw(x);
putchar(' ');
}
template <class o>
void pr2(o x) {
if (x < 0) x = -x, putchar('-');
qw(x);
putchar(10);
}
long long gcd(long long a, long long b) { return !a ? b : gcd(b % a, a); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long power(long long a, long long b = mod - 2, long long p = mod) {
long long c = 1;
while (b) {
if (b & 1) c = c * a % p;
b /= 2;
a = a * a % p;
}
return c;
}
template <class o>
void cmax(o& x, o y) {
if (x < y) x = y;
}
void cmax(int& x, int y) { x = x - y >> 31 ? y : x; }
template <class o>
void cmin(o& x, o y) {
if (x > y) x = y;
}
void cmin(int& x, int y) { x = x - y >> 31 ? x : y; }
template <typename t1, typename t2>
void ad(t1& x, t2 y) {
x += y;
if (x >= mod) x -= mod;
}
template <typename t1, typename t2>
void dl(t1& x, t2 y) {
x -= y;
if (x < 0) x += mod;
}
long long jc[N], inv[N];
void jc_init(int n) {
jc[0] = 1;
for (int i = 1; i <= n; i++) jc[i] = jc[i - 1] * i % mod;
inv[n] = power(jc[n]);
for (int i = n; i; i--) inv[i - 1] = inv[i] * i % mod;
}
long long C(int x, int y) {
if (x < y || y < 0) return 0;
return jc[x] * inv[y] % mod * inv[x - y] % mod;
}
int n, a[N], vis[N], L[N], R[N], zero, cnt, ans, m, pre[N], nxt[N], type[N];
int mn[N << 1], tag[N << 1];
void bt(int x, int l, int r) {
tag[x] = 0;
if (l == r) {
mn[x] = l + cnt;
return;
}
int mid = (l + r) / 2;
bt((x << 1), l, mid);
bt((x << 1 | 1), mid + 1, r);
cmin(mn[x] = mn[(x << 1)], mn[(x << 1 | 1)]);
}
void add(int x, int y) {
mn[x] += y;
tag[x] += y;
}
void pushdown(int x) {
if (tag[x]) add((x << 1), tag[x]), add((x << 1 | 1), tag[x]), tag[x] = 0;
}
void del(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return add(x, -1);
int mid = (l + r) / 2;
pushdown(x);
if (L <= mid) del((x << 1), l, mid, L, R);
if (mid < R) del((x << 1 | 1), mid + 1, r, L, R);
cmin(mn[x] = mn[(x << 1)], mn[(x << 1 | 1)]);
}
void solve() {
qr(n);
nxt[n + 1] = 0;
for (auto i = 1; i <= n; i++) qr(a[i]), L[i] = R[i] = vis[i] = 0;
for (auto i = 1; i <= n; i++) pre[i] = pre[i - 1] + !a[i];
for (auto i = n; i >= 1; i--) nxt[i] = nxt[i + 1] + !a[i];
zero = pre[n] / 2;
ans = zero;
for (auto i = 1; i <= n; i++) vis[a[i]] = 1;
cnt = 0;
for (auto i = 1; i <= n; i++)
cnt += vis[i], type[i] = (pre[i] <= zero) ? 1 : 2;
for (auto i = 1; i <= n; i++)
if (type[i] == 1) L[a[i]] = i;
for (auto i = n; i >= 1; i--)
if (type[i] == 2) R[a[i]] = i;
bt(1, 0, m = pre[n] - zero);
for (auto i = 1; i <= n; i++)
if (!L[i] && R[i]) del(1, 0, m, nxt[R[i]], m);
cmin(ans, mn[1]);
for (auto i = 1; i <= n; i++) {
if (type[i] == 2) break;
if (a[i] && L[a[i]] == i) {
del(1, 0, m, nxt[R[a[i]]], m);
cmin(ans, pre[i] + mn[1]);
}
}
pr2(ans);
}
int main() {
int T = 1;
qr(T);
while (T--) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
const double EPS = 1e-9;
const int INT_INF = 1 << 31 - 1;
const long long I64_INF = 1ll << 63 - 1ll;
const double PI = acos(-1.0);
using namespace std;
int n, r;
int res = INT_INF;
char second[1005000];
int sz = 0;
void go(int a, int b, int id, int was) {
if (a == 1 && b == 1 && id == 1 && res > was) {
res = was;
return;
}
if (a < 1 || b < 1 || id < 1 || (a == 1 && b == 1)) return;
if (b == 1)
go(1, 1, id - (a - 1), was + a - 2);
else if (a == 1)
go(1, 1, id - (b - 1), was + b - 2);
else if (a > b)
go(a % b, b, id - (a / b), was + (a / b) - 1);
else
go(a, b % a, id - (b / a), was + (b / a) - 1);
}
bool isGood(int a, int b, int id, int was) {
if (was == res && a == 1 && b == 1 && id == 1) {
second[sz++] = 'T';
return 1;
}
if (a < 1 || b < 1 || id < 1 || (a == 1 && b == 1)) return 0;
if (b == 1) {
if (isGood(1, 1, id - (a - 1), was + a - 2)) {
char c = (second[sz - 1] == 'T') ? 'B' : 'T';
for (int i = 0; i < (int)a - 1; i++) second[sz++] = c;
return 1;
}
return 0;
} else if (a == 1) {
if (isGood(1, 1, id - (b - 1), was + b - 2)) {
char c = (second[sz - 1] == 'T') ? 'B' : 'T';
for (int i = 0; i < (int)b - 1; i++) second[sz++] = c;
return 1;
}
return 0;
} else if (a > b) {
if (isGood(a % b, b, id - (a / b), was + (a / b) - 1)) {
char c = (second[sz - 1] == 'T') ? 'B' : 'T';
for (int i = 0; i < (int)a / b; i++) second[sz++] = c;
return 1;
}
return 0;
} else {
if (isGood(a, b % a, id - (b / a), was + (b / a) - 1)) {
char c = (second[sz - 1] == 'T') ? 'B' : 'T';
for (int i = 0; i < (int)b / a; i++) second[sz++] = c;
return 1;
}
return 0;
}
}
int main() {
cin >> n >> r;
if (n == 1 && r == 1) {
printf("0\nT");
return 0;
}
for (int a = 1; a < r; a++) go(a, r - a, n - 1, 0);
for (int a = 1; a < r; a++)
if (isGood(a, r - a, n - 1, 0)) break;
second[sz] = (second[sz - 1] == 'T') ? 'B' : 'T';
second[sz + 1] = '\n';
if (res == INT_INF)
puts("IMPOSSIBLE");
else
printf("%d\n", res), puts(second);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> f, a, b, c;
vector<long long> v[110000];
long long n, dp[110000], p[110000];
int pcnt = 0, cnt;
bool prime(int n) {
int i;
if ((n != 2 && !(n % 2)) || (n != 3 && !(n % 3)) || (n != 5 && !(n % 5)) ||
(n != 7 && !(n % 7))) {
return false;
}
for (i = 0; p[i] * p[i] <= n; i++) {
if (!(n % p[i])) {
return false;
}
}
return n > 1;
}
void initPrime() {
p[pcnt++] = 2;
for (int i = 3; i < 1001000; i += 2) {
if (prime(i)) {
p[pcnt++] = i;
}
}
}
long long check(long long k) {
if (k < 2) return 0;
for (int i = 0; p[i] * p[i] <= k; i++)
if (!(k % p[i])) {
while (!(k % p[i])) k /= p[i];
return k == 1 ? p[i] : 0;
}
return k;
}
void insert(long long k) {
f.push_back(k);
long long t = check(k - 1);
if (t) {
a.push_back(t);
b.push_back(t);
c.push_back(k);
}
}
int main() {
initPrime();
{
a.clear();
b.clear();
c.clear();
f.clear();
cnt = 0;
scanf("%lld", &n);
for (long long i = 1; i * i <= n; i++)
if (!(n % i)) {
insert(i);
if (i * i != n) insert(n / i);
}
sort(f.begin(), f.end());
sort(a.begin(), a.end());
auto pt = unique(a.begin(), a.end());
a.erase(pt, a.end());
cnt = a.size();
int tmp = b.size();
for (int i = 0; i < tmp; i++) {
long long j = c[i];
v[lower_bound(a.begin(), a.end(), b[i]) - a.begin()].push_back(j);
}
int l = f.size();
for (int i = 0; i < l + 1; i++) dp[l] = 0;
dp[0] = 1;
for (int i = 0; i < cnt; i++)
for (int j = l - 1; j >= 0; j--)
for (auto k : v[i])
if (!(f[j] % k))
dp[j] += dp[lower_bound(f.begin(), f.end(), f[j] / k) - f.begin()];
printf("%lld\n", dp[l - 1]);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200005];
long long fib[200005], MOD = 1000000000;
int n, m;
long long tree1[(200005 << 2)], tree2[(200005 << 2)];
int lChild(int ind) { return (ind << 1) + 1; }
int rChild(int ind) { return (1 + ind) << 1; }
void init(long long *tree, long long *coeff, int ind, int left, int right) {
int mid = (left + right) >> 1, lc = lChild(ind), rc = rChild(ind);
if (left == right) {
tree[ind] = (arr[left] * coeff[left]) % MOD;
return;
}
init(tree, coeff, lc, left, mid);
init(tree, coeff, rc, mid + 1, right);
tree[ind] = tree[lc] + tree[rc];
if (tree[ind] >= MOD) tree[ind] -= MOD;
}
int lo, hi;
void update1(long long *tree, long long *coeff, int ind, int left, int right,
int val) {
int mid = (left + right) >> 1, lc = lChild(ind), rc = rChild(ind);
if (left == right) {
tree[ind] = (val * coeff[left]) % MOD;
return;
}
if (lo <= mid) update1(tree, coeff, lc, left, mid, val);
if (hi > mid) update1(tree, coeff, rc, mid + 1, right, val);
tree[ind] = tree[lc] + tree[rc];
if (tree[ind] >= MOD) tree[ind] -= MOD;
}
long long query(long long *tree, long long *coeff, int ind, int left,
int right) {
int mid = (left + right) >> 1, lc = lChild(ind), rc = rChild(ind);
if (lo > right || hi < left) return 0;
if (lo <= left && right <= hi) return tree[ind];
return (query(tree, coeff, lc, left, mid) +
query(tree, coeff, rc, mid + 1, right)) %
MOD;
}
int main() {
fib[0] = fib[1] = 1;
for (int i = 2; i < 200005; i++) {
fib[i] = (fib[i - 1] + fib[i - 2]);
if (fib[i] >= MOD) fib[i] -= MOD;
}
while (cin >> n >> m) {
for (int i = 1; i <= n; i++) scanf("%I64d", &arr[i]);
init(tree1, fib, 0, 1, n);
init(tree2, fib + 1, 0, 1, n);
while (m--) {
int type, xx, v;
scanf("%d", &type);
if (type == 1) {
scanf("%d%d", &xx, &v);
arr[xx] = v;
lo = hi = xx;
update1(tree1, fib, 0, 1, n, v);
update1(tree2, fib + 1, 0, 1, n, v);
} else if (type == 2) {
scanf("%d%d", &lo, &hi);
long long sm = 0;
sm = (query(tree2, fib + 1, 0, 1, n) * fib[lo - 1] -
query(tree1, fib, 0, 1, n) * fib[lo]) %
MOD;
if (!(lo & 1)) sm = -sm;
printf("%I64d\n", (sm + MOD) % MOD);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1e5 + 8;
int n, ZZ, L[12], R[12];
long long ans;
char s[N];
queue<int> q;
struct SAM {
int tot, rt, last, go[N][26], fa[N], Len[N], sz[N], cnt[N][11], deg[N];
SAM() { tot = last = rt = 1; }
void expand(int w, int t) {
int p = last, np = ++tot;
last = np;
cnt[np][t]++;
Len[np] = Len[p] + 1;
while (p && !go[p][w]) go[p][w] = np, p = fa[p];
if (!p) {
fa[np] = rt;
return;
}
int q = go[p][w];
if (Len[q] == Len[p] + 1)
fa[np] = q;
else {
int nq = ++tot;
Len[nq] = Len[p] + 1;
fa[nq] = fa[q];
fa[q] = nq;
fa[np] = nq;
memcpy(go[nq], go[q], sizeof(go[q]));
while (p && go[p][w] == q) go[p][w] = nq, p = fa[p];
}
}
void solve() {
for (int i = 2; i <= tot; i++) deg[fa[i]]++;
for (int i = 1; i <= tot; i++)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
int ok = 1;
for (int i = 1; i <= n; i++)
if (!cnt[u][0] || !(cnt[u][i] >= L[i] && cnt[u][i] <= R[i])) {
ok = 0;
break;
}
if (ok == 1) ans += Len[u] - Len[fa[u]];
if (fa[u]) {
for (int i = 0; i <= n; i++) cnt[fa[u]][i] += cnt[u][i];
deg[fa[u]]--;
if (!deg[fa[u]]) q.push(fa[u]);
}
}
}
} sam;
int main() {
scanf("%s", s + 1);
int slen = strlen(s + 1);
for (int i = 1; i <= slen; i++) sam.expand(s[i] - 'a', 0);
ZZ = sam.tot;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
slen = strlen(s + 1);
sam.last = sam.rt;
for (int j = 1; j <= slen; j++) sam.expand(s[j] - 'a', i);
scanf("%d%d", &L[i], &R[i]);
}
sam.solve();
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e6 + 3;
long long quickpow(long long a, long long x) {
long long ans = 1;
while (x) {
if (x & 1) ans = ans * a % mod;
x >>= 1;
a = a * a % mod;
}
return ans;
}
int main() {
long long n, k, x = 0, m = 0;
cin >> n >> k;
while ((1ll << x) < k) x++;
if (x > n) {
cout << "1 1" << endl;
return 0;
}
for (long long i = 2; i < k; i <<= 1) m += (k - 1) / i;
long long p = quickpow(2, mod - 1 - m % (mod - 1));
long long ans = (quickpow(quickpow(2, n), k - 1) * p) % mod;
if (mod <= k - 1)
cout << ans << " " << ans << endl;
else {
long long ans1 = 1, ori = quickpow(2, n);
for (long long i = 1; i < k; i++) ans1 = (ans1 * (ori - i)) % mod;
ans1 = ans1 * p % mod;
cout << ((ans - ans1) % mod + mod) % mod << " " << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int s1 = 0, s2 = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == 1)
s1++;
else
s2++;
}
if (s2) {
cout << "2 ";
s2--;
}
if (s1) {
cout << "1 ";
s1--;
}
while (s2) {
cout << "2 ";
s2--;
}
while (s1) {
cout << "1 ";
s1--;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout.precision(30);
int t = 1;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n % 2 == 0)
cout << 2;
else
cout << 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct o {
int x;
double y;
} area[1010];
bool cmp(o x, o y) { return (x.y < y.y); }
int n, tot, iCross, cross[1010];
vector<int> p, q;
int main() {
cin >> n;
for (int i = 3; i <= n; i++) {
cout << "1 1 2 " << i << endl;
cout.flush();
double iArea;
cin >> iArea;
area[i].y = iArea;
area[i].x = i;
cout << "2 1 2 " << i << endl;
cout.flush();
cin >> iCross;
cross[i] = iCross;
}
sort(area + 1, area + 1 + n, cmp);
for (int i = 3; i <= n; i++) {
iCross = cross[area[i].x];
if (iCross == 1)
tot++, p.push_back(i);
else
q.push_back(i);
}
int headId = 1, head = 1, tail = tot;
int left[1010], right[1010];
for (int i = 0; i < p.size(); i++) {
if (i == p.size() - 1) {
left[head++] = area[p[i]].x;
headId = area[p[i]].x;
continue;
}
cout << "2 " << headId << " " << area[p[i + 1]].x << " " << area[p[i]].x
<< endl;
cout.flush();
cin >> iCross;
if (iCross == 1) {
left[head++] = area[p[i]].x;
headId = area[p[i]].x;
} else {
left[tail--] = area[p[i]].x;
}
}
headId = 1, head = 1, tail = n - 2 - tot;
for (int i = 0; i < q.size(); i++) {
if (i == q.size() - 1) {
right[head++] = area[q[i]].x;
headId = area[q[i]].x;
continue;
}
cout << "2 " << headId << " " << area[q[i + 1]].x << " " << area[q[i]].x
<< endl;
cout.flush();
cin >> iCross;
if (iCross == -1) {
right[head++] = area[q[i]].x;
headId = area[q[i]].x;
} else {
right[tail--] = area[q[i]].x;
}
}
cout << "0 1 ";
for (int i = 1; i <= n - 2 - tot; i++) {
cout << right[i] << " ";
}
cout << "2 ";
for (int i = tot; i > 0; i--) {
cout << left[i] << " ";
}
cout.flush();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
sort(s.begin(), s.end());
if (s[0] != s.back()) {
cout << s << '\n';
} else {
cout << "-1\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int z;
cin >> z;
string s;
cin >> s;
long l, r;
l = r = 0;
long i = 0;
long le = s.length();
while (i < le && s[i] == '<') {
l++;
i++;
}
i = le - 1;
while (i > -1 && s[i] == '>') {
r++;
i--;
}
cout << r + l;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool triangle(long long int a, long long int b, long long int c) {
long long int temp[] = {a, b, c};
sort(temp, temp + 3);
return (temp[0] + temp[1] > temp[2]);
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
if (n >= 45) {
cout << "YES"
<< " "
<< "\n";
;
return 0;
}
long long int flag = -1;
for (long long int i = 0; i < n; i++) {
for (long long int j = i + 1; j < n; j++) {
for (long long int k = j + 1; k < n; k++) {
flag = triangle(v[i], v[j], v[k]);
if (flag) {
cout << "YES"
<< " "
<< "\n";
;
break;
}
}
if (flag) break;
}
if (flag) break;
}
if (flag != 1)
cout << "NO"
<< " "
<< "\n";
;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, v, a[30], b[30], sum;
int main() {
scanf("%d %d", &n, &v);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
double minn = 1e10;
for (int i = 0; i < n; i++) minn = min(minn, b[i] / double(a[i]));
minn = min<double>(minn * sum, v);
printf("%lf", minn);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct ball {
double x;
double v;
double m;
double time;
ball() {}
ball(double x_, double v_, double m_, double t_)
: x(x_), v(v_), m(m_), time(t_) {}
};
struct boom {
int b1;
int b2;
double time;
boom() {}
boom(int b1_, int b2_, double time_) : b1(b1_), b2(b2_), time(time_) {}
};
int n;
double t;
double world_time = 0;
vector<ball> world;
stringstream dbg;
bool boom_was() {
dbg << t << " WORLD TIME " << world_time << endl;
vector<boom> booms(1, boom(-1, -1, t + 1));
vector<vector<bool> > used(n, vector<bool>(n, false));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
ball b1 = world[i];
ball b2 = world[j];
if (b1.v == b2.v || b1.x == b2.x || (b2.x - b1.x) / (b1.v - b2.v) <= 0)
continue;
double boom_time = world_time + (b2.x - b1.x) / (b1.v - b2.v);
if (!used[i][j] && boom_time <= t && boom_time <= booms[0].time) {
used[i][j] = true;
used[j][i] = true;
if (boom_time < booms[0].time) booms.clear();
booms.push_back(boom(i, j, boom_time));
dbg << "BOOM " << i << " in " << b1.x << " and " << j << " in " << b2.x
<< " time " << boom_time << " local_time "
<< (b2.x - b1.x) / (b1.v - b2.v) << endl;
}
}
if (booms[0].b1 < 0) return false;
vector<bool> boomers(n, true);
double l_boom_time = 0;
for (int i = 0; i < booms.size(); i++) {
boomers[booms[i].b1] = false;
boomers[booms[i].b2] = false;
dbg << "boom bitween " << booms[i].b1 << " and " << booms[i].b2
<< " at time " << booms[i].time << endl;
l_boom_time = booms[i].time - world_time;
ball b1 = world[booms[i].b1];
ball b2 = world[booms[i].b2];
world[booms[i].b1].v =
((b1.m - b2.m) * b1.v + 2 * b2.m * b2.v) / (b1.m + b2.m);
world[booms[i].b2].v =
((b2.m - b1.m) * b2.v + 2 * b1.m * b1.v) / (b1.m + b2.m);
world[booms[i].b1].x = world[booms[i].b2].x = b1.x + b1.v * l_boom_time;
}
for (int i = 0; i < n; i++)
if (boomers[i]) world[i].x = world[i].x + world[i].v * l_boom_time;
dbg << "WORLD STATE NOW:" << endl;
for (int i = 0; i < n; i++)
dbg << i + 1 << " x=" << world[i].x << ", v=" << world[i].v << endl;
world_time = booms[0].time;
return true;
}
int main() {
cin >> n >> t;
world = vector<ball>(n, ball(0, 0, 0, t));
for (int i = 0; i < n; i++) cin >> world[i].x >> world[i].v >> world[i].m;
while (boom_was()) {
}
for (int i = 0; i < n; i++)
cout << (world[i].x + world[i].v * (t - world_time)) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int mx = *max_element(v.begin(), v.end());
int mn = *min_element(v.begin(), v.end());
int ind1 = 0, ind2 = 0;
for (int i = 0; i < n; i++) {
if (v[i] == mx && ind1 == 0)
ind1 = i + 1;
else if (v[i] == mn)
ind2 = i + 1;
}
ind2--;
ind1--;
if (ind1 > ind2) ind2++;
long long result = ind1 + n - ind2 - 1;
cout << result;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
int n;
map<int, int> m;
scanf("%d", &n);
int x;
for (int i = 0; i < n * n; i++) {
scanf("%d", &x);
m[x]++;
}
vector<int> a;
map<int, int>::iterator it;
map<int, int>::iterator it1;
int GCD;
int ak;
for (int i = 0; i < n; i++) {
it = m.end();
it--;
ak = it->first;
it->second--;
if (it->second == 0) m.erase(it);
for (int j = 0; j < a.size(); j++) {
GCD = gcd(ak, a[j]);
it1 = m.find(GCD);
it1->second -= 2;
if (it1->second == 0) m.erase(it1);
}
a.push_back(ak);
}
for (int i = 0; i < n; i++) {
if (i > 0) printf(" ");
printf("%d", a[i]);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int powe(long long int a, long long int b, long long int mod) {
if (b == 0) return 1;
long long int x = powe(a, b / 2, mod) % mod;
if (b % 2 == 0)
return (x * x) % mod;
else
return (((x * x) % mod) * a) % mod;
}
long long int PrintAns(long long int p, long long int q, long long int mod) {
return (p * (powe(q, mod - 2, mod))) % mod;
}
long long int gcd(long long int a, long long int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, i;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] < a[n - 1])
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const long double PI = acosl((long double)-1.0);
const long long LINF = ((1ull << 63) - 1ull);
const int MOD = 1000000007;
const int MAXN = 1000005;
int n, m, k;
int v1[MAXN], v2[MAXN];
pair<int, int> w[MAXN];
int ans[1001];
int p[1001];
int c[1001];
int l[1001];
int r[1001];
vector<vector<vector<int> > > comps;
int num;
void init() {
scanf("%d%d%d", &n, &m, &k);
comps.resize(k + 1);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &v1[i], &v2[i], &w[i].first);
w[i].second = i;
}
for (int i = 1; i <= k; i++) {
scanf("%d%d", &l[i], &r[i]);
}
}
void init_dsu() {
comps[num].resize(n + 1);
for (int i = 1; i <= n; i++) {
p[i] = i;
comps[num][i].push_back(i);
}
}
inline bool union_sets(int v1, int v2) {
if (p[v1] == p[v2]) {
return c[v1] != c[v2];
}
int p1 = p[v1];
int p2 = p[v2];
if (comps[num][p1].size() < comps[num][p2].size()) {
swap(p1, p2);
}
for (int i = 0; i < comps[num][p2].size(); i++) {
p[comps[num][p2][i]] = p1;
}
comps[num][p1].insert(comps[num][p1].end(), comps[num][p2].begin(),
comps[num][p2].end());
if (c[v1] == c[v2]) {
for (int i = 0; i < comps[num][p2].size(); i++) {
c[comps[num][p2][i]] ^= 1;
}
}
return true;
}
void solve() {
init();
sort(w + 1, w + m + 1);
for (num = 1; num <= k; num++) {
init_dsu();
int ans = -1;
for (int j = m; j >= 1; j--) {
if (l[num] <= w[j].second && w[j].second <= r[num]) {
if (!union_sets(v1[w[j].second], v2[w[j].second])) {
ans = w[j].first;
break;
}
}
}
printf("%d\n", ans);
}
}
void precalc() {}
int main() {
srand(25);
precalc();
int tests = 1;
for (int i = 1; i <= tests; i++) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int t = sqrt(n);
if (n % t == 0) {
int h = n / t;
for (int i = 1; i <= h; ++i) {
for (int j = n - t + 1; j <= n; ++j) cout << j << " ";
n = n - t;
}
cout << '\n';
} else {
int h = n / t;
int resst = n % t;
++t;
for (int i = 1; i <= resst; ++i) {
for (int j = n - t + 1; j <= n; ++j) cout << j << " ";
n = n - t;
}
--t;
for (int i = resst + 1; i <= h; ++i) {
for (int j = n - t + 1; j <= n; ++j) cout << j << " ";
n = n - t;
}
cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double const INF = DBL_MAX / 2;
double const eps = 1e-8;
struct ball {
double x, v, m;
int id;
ball(double x = 0, double v = 0, double m = 0, int id = 0)
: x(x), v(v), m(m), id(id) {}
double after(double t) { return x + t * v; }
bool operator<(ball const &rhs) const { return x < rhs.x; }
} b[10];
double collide_time(ball &l, ball &r) {
if (l.v <= 0 && r.v >= 0) return INF;
if (l.v <= 0 && r.v <= 0 && l.v <= r.v) return INF;
if (l.v >= 0 && r.v >= 0 && l.v <= r.v) return INF;
return (r.x - l.x) / fabs(r.v - l.v);
}
void collide(ball &l, ball &r) {
double lv = ((l.m - r.m) * l.v + 2 * r.m * r.v) / (l.m + r.m);
double rv = ((r.m - l.m) * r.v + 2 * l.m * l.v) / (l.m + r.m);
l.v = lv, r.v = rv;
}
int main() {
int n, t;
scanf("%d%d", &n, &t);
for (int i = 0, x, v, m; i < n; ++i) {
scanf("%d%d%d", &x, &v, &m);
b[i] = ball(x, v, m, i);
}
sort(b, b + n);
double ct[10]{};
for (double rem = t; rem > 0;) {
double mn = rem;
for (int i = 0; i + 1 < n; ++i)
mn = min(mn, ct[i] = collide_time(b[i], b[i + 1]));
for (int i = 0; i < n; ++i) b[i].x = b[i].after(mn);
rem -= mn;
if (fabs(rem) < eps) break;
for (int i = 0; i + 1 < n; ++i)
if (fabs(mn - ct[i]) < eps) {
collide(b[i], b[i + 1]);
}
}
double p[10]{};
for (int i = 0; i < n; ++i) p[b[i].id] = b[i].x;
for (int i = 0; i < n; ++i) printf("%.16f\n", p[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int n, x, ans;
set<int> s;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
reverse(v.begin(), v.end());
for (int k : v) {
if (s.find(k) == s.end()) {
ans = k;
s.insert(k);
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n, a, b, i, j, x, y, t;
scanf("%d", &t);
while (t--) {
v.clear();
int flag = 0, flag2 = 0;
scanf("%d", &n);
while (n--) {
scanf("%d", &a);
v.push_back(a);
}
for (i = 0; i < v.size(); i++) {
if (v[i] == 1) {
a = i;
break;
}
}
b = 1;
for (i = a; i < v.size(); i++) {
if (v[i] != b) {
flag = 1;
}
b++;
}
if (flag == 0) {
for (i = 0; i < a; i++) {
if (v[i] != b) {
flag = 1;
}
b++;
}
}
for (i = 0; i < v.size(); i++) {
if (v[i] == 1) {
a = i;
break;
}
}
b = 1;
for (i = a; i >= 0; i--) {
if (v[i] != b) {
flag2 = 1;
}
b++;
}
for (i = v.size() - 1; i >= a + 1; i--) {
if (v[i] != b) {
flag2 = 1;
}
b++;
}
if (flag == 0 || flag2 == 0) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int N = 2005;
int n;
long long ans;
pair<int, int> a[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
}
for (int i = 1; i <= n; i++) {
vector<double> v;
for (int j = 1; j <= n; j++)
if (i != j) {
v.push_back(atan2(a[j].second - a[i].second, a[j].first - a[i].first));
v.push_back(v.back() + 2 * acos(-1));
}
sort(v.begin(), v.end());
int k = 0;
for (int j = 0; j < v.size() / 2; j++) {
while (v[k] - v[j] < acos(-1)) k++;
int L = k - j - 1;
int R = n - 2 - L;
ans += L * (L - 1) / 2 * (long long)R * (R - 1) / 2;
}
}
cout << ans / 2 << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int b, n, x, y, t, d, p, q;
scanf("%d", &n);
x = 0;
for (b = 2; b < n; b++) {
t = n;
while (t > 0) {
x += t % b;
t /= b;
}
}
y = n - 2;
if (x >= y) {
p = x;
q = y;
} else {
p = y;
q = x;
}
while ((t = p % q) > 0) {
p = q;
q = t;
}
d = q;
x /= d;
y /= d;
printf("%d/%d\n", x, y);
return EXIT_SUCCESS;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100000], dp[30005][500];
int main() {
int n, x, d;
cin >> n >> d;
int mi = d, mx = d, pi = d, px = d;
for (long long i = 0; i < n; i++) {
scanf("%d", &x);
cnt[x]++;
}
int an = 0, i = d, k = max(0, d - 245);
for (int i = 30000; i >= d; i--) {
for (long long j = k + 1; j < d + 245; j++) {
if (i + j > 30001)
;
else if (j > 1)
dp[i][j - k] =
max(max(dp[i + j - 1][j - k - 1], dp[i + j + 1][j - k + 1]),
dp[i + j][j - k]);
else
dp[i][j - k] = max(dp[i + j][j - k], dp[i + j + 1][j - k + 1]);
dp[i][j - k] += cnt[i];
if (an < dp[i][j - k]) an = dp[i][j - k];
}
}
cout << dp[d][d - k] << endl;
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long a, b;
long long mod = 1000000007;
long long inv2 = 500000004;
while (scanf("%I64d%I64d", &a, &b) == 2) {
long long ans = 0, a1, a2;
a1 = ((b - 1) * b) % mod;
a1 = (a1 * inv2) % mod;
a2 = (a * b) % mod;
a2 = (a2 * (a + 1)) % mod;
a2 = (a2 * inv2) % mod;
a2 = (a2 + a) % mod;
ans = (a1 * a2) % mod;
printf("%I64d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long inf = 4e18;
const long long N = 5e5 + 5;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tt = 1;
cin >> tt;
while (tt--) {
long long n;
cin >> n;
string s;
cin >> s;
set<char> st;
for (auto it : s) {
st.insert(it);
}
if (st.size() == 1) {
cout << (n + 2) / 3 << "\n";
} else {
long long idx = n;
long long ct = 0;
for (long long i = n - 1; i >= 0; --i) {
if (s[0] == s[i]) {
++ct;
idx = i;
} else
break;
}
long long ans = 0;
for (long long i = 0; i < idx; ++i) {
++ct;
if (s[i] != s[i + 1]) {
ans += (ct / 3);
ct = 0;
}
}
cout << ans << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s.push_back('a');
int k = 1, p = 0;
int i = 0;
while (i < (s.length() - 1)) {
if (s[i] != s[i + 1]) {
k = 1;
p++;
} else if (k >= 5) {
k = 1;
p++;
} else
k++;
i++;
}
cout << p << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
char ch = getchar();
int pd = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') pd = -pd;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= pd;
}
inline void write(const int &x) {
char ggg[10001];
int s = 0;
int tmp = x;
if (tmp == 0) {
putchar('0');
return;
}
if (tmp < 0) {
tmp = -tmp;
putchar('-');
}
while (tmp > 0) {
ggg[s++] = tmp % 10 + '0';
tmp /= 10;
}
while (s > 0) {
putchar(ggg[--s]);
}
}
int n, a[100010];
int main() {
read(n);
for (register int i = 1; i <= n; ++i) read(a[i]);
for (register int i = 1; i <= n; ++i) {
if (a[i] >= 0) {
a[i] = -a[i] - 1;
}
}
if (n & 1) {
int mx = -1e9;
int now;
for (register int i = 1; i <= n; ++i) {
if (abs(a[i]) > mx) {
mx = abs(a[i]);
now = i;
}
}
a[now] = -a[now] - 1;
}
for (register int i = 1; i <= n; ++i) {
write(a[i]);
putchar(' ');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long n, m, t;
long long ans[N];
pair<long long, pair<long long, long long> > a[N];
vector<long long> vR, vL;
long long get(long long l, long long r, vector<long long> &v) {
return upper_bound(v.begin(), v.end(), r) -
lower_bound(v.begin(), v.end(), l);
}
int main() {
scanf("%lld %lld %lld", &n, &m, &t);
t *= 2;
long long cR = 0, cL = 0;
for (int i = 0; i < n; i++) {
long long x;
char c;
scanf("%lld %c", &x, &c);
x--;
a[i] = {x, {c, i}};
if (c == 'R') {
vR.push_back(x - m);
vR.push_back(x);
vR.push_back(x + m);
cR++;
} else {
vL.push_back(x - m);
vL.push_back(x);
vL.push_back(x + m);
cL++;
}
}
sort(vR.begin(), vR.end());
sort(vL.begin(), vL.end());
sort(a, a + n);
memset(ans, -1, sizeof(ans));
for (int i = 0; i < n; i++) {
long long x = a[i].first;
long long c = a[i].second.first;
if (c == 'L') {
long long end = (x - t % m + m) % m;
long long full = t / m;
long long rem = t % m;
long long ind = i;
ind -= full % n * cR % n;
ind -= get(x - rem, x, vR);
ind = (ind % n + n) % n;
ans[a[ind].second.second] = end;
}
}
for (int i = 0; i < n; i++) {
long long x = a[i].first;
long long c = a[i].second.first;
if (c == 'R') {
long long end = x;
long long full = t / m;
long long rem = t % m;
long long ind = i;
ind += full % n * cL % n;
ind += get(x, x + rem, vL);
ind = (ind % n + n) % n;
ans[a[ind].second.second] = end;
}
}
for (int i = 0; i < n; i++) assert(ans[i] != -1);
t /= 2;
for (int i = 0; i < n; i++) {
ans[i] = (ans[i] + t) % m + 1;
printf("%lld ", ans[i]);
}
puts("");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, Q, col;
int vis[100005], f[100005], sz[100005];
vector<int> d[100005], v[100005];
int pos[100005];
long long s[100005];
vector<long long> sum[100005];
map<pair<int, int>, long long> mp;
void dfs(int x, int last) {
vis[x] = col;
f[x] = 0;
for (int i = 0; i < (int)v[x].size(); i++) {
if (v[x][i] != last) {
dfs(v[x][i], x);
f[x] = max(f[x], f[v[x][i]] + 1);
}
}
}
void dfs2(int x, int last, int now) {
int tmp = max(f[x], now);
d[col].push_back(tmp);
pos[x] = col;
int mx1 = -1, mx2 = -1;
for (int i = 0; i < (int)v[x].size(); i++) {
if (v[x][i] == last) continue;
if (f[v[x][i]] > mx1) {
mx2 = mx1;
mx1 = f[v[x][i]];
} else if (f[v[x][i]] > mx2) {
mx2 = f[v[x][i]];
}
}
for (int i = 0; i < (int)v[x].size(); i++) {
if (v[x][i] == last) continue;
int tmp = now + 1;
if (f[v[x][i]] != mx1)
tmp = max(tmp, mx1 + 2);
else
tmp = max(tmp, mx2 + 2);
dfs2(v[x][i], x, tmp);
}
}
int main() {
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
col++;
dfs(i, 0);
dfs2(i, 0, 0);
}
}
for (int i = 1; i <= col; i++) {
sort(d[i].begin(), d[i].end()), sz[i] = d[i].size();
long long now = 0;
sum[i].push_back(0);
for (int j = 0; j < (int)d[i].size(); j++) {
now += d[i][j];
sum[i].push_back(now);
}
s[i] = now;
}
while (Q--) {
int x, y;
scanf("%d%d", &x, &y);
if (pos[x] == pos[y]) {
puts("-1");
continue;
}
x = pos[x];
y = pos[y];
if (x > y) swap(x, y);
if (mp[make_pair(x, y)]) {
printf("%.8lf\n", 1.0 * mp[make_pair(x, y)] / (1.0 * sz[x] * sz[y]));
continue;
}
if (sz[x] > sz[y]) swap(x, y);
int D = max(d[x][d[x].size() - 1], d[y][d[y].size() - 1]);
long long res = 0;
for (int i = 0; i < (int)d[x].size(); i++) {
int X =
upper_bound(d[y].begin(), d[y].end(), D - d[x][i] - 1) - d[y].begin();
res += 1ll * D * X + 1ll * (d[x][i] + 1) * (sz[y] - X) + s[y] - sum[y][X];
}
mp[make_pair(min(x, y), max(x, y))] = res;
double rr = 1.0 * res / (1.0 * sz[x] * sz[y]);
printf("%.8lf\n", rr);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int i, n, t, k, sum = 0, x;
bool a[10], b;
int main() {
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &t), b = 1;
for (x = 0; x <= k; x++) a[x] = 0;
while (t) a[t % 10] = 1, t /= 10;
for (x = 0; x <= k; x++)
if (!a[x]) b = 0;
if (b) sum++;
}
printf("%d", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int inf = (1ll << 31) - 1;
using namespace std;
pair<int, int> b[111];
int a[111];
int n;
int m;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> b[i].first;
b[i].second = i;
}
sort(b, b + n);
for (int i = 0; i < n; i++) {
a[b[i].second] = i % 2;
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 51123987;
int len, n;
char s[4000010], tmp[2000010];
long long p[4000010];
long long sum, ans;
long long le[4000010], ri[4000010];
int main() {
scanf("%d%s", &len, tmp + 1);
s[++n] = '@';
for (int i = 1; i <= len; i++) {
s[++n] = '#';
s[++n] = tmp[i];
}
s[++n] = '#';
long long id = 0, mx = 0;
for (long long i = 1; i <= n; i++) {
p[i] = ((mx > i) ? min(p[id * 2 - i], mx - i) : 1);
while (s[i + p[i]] == s[i - p[i]]) p[i]++;
if (i + p[i] > mx) {
mx = i + p[i];
id = i;
}
sum += 1ll * p[i] / 2;
sum %= mod;
le[i - p[i]]++;
le[i]--;
ri[i - 1]++;
ri[i + p[i] - 1]--;
}
sum = sum * (sum - 1) / 2;
sum %= mod;
for (int i = 1; i <= n; i++) {
le[i] += le[i - 1];
ri[i] += ri[i - 1];
if (i % 2 == 0) {
sum -= 1ll * ans * le[i] % mod;
sum = (sum + mod) % mod;
ans = (ans + ri[i]) % mod;
}
}
cout << (sum + mod) % mod;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x;
vector<int> a;
cin >> n >> x;
bool f = false;
for (i = 0; i < n; i++) {
int q;
cin >> q;
if (q == x) f = true;
a.push_back(q);
}
int ans = 0;
if (!f) {
n++;
ans++;
a.push_back(x);
}
sort(a.begin(), a.end());
int place = (n + 1) / 2 - 1;
while (a[place] != x) {
if (a[place] > x)
a.push_back(0);
else
a.push_back(100500);
sort(a.begin(), a.end());
ans++;
n++;
place = (n + 1) / 2 - 1;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool check(string t) {
bool ans = true;
for (int i = 0; i < t.length() - 1; i++) {
ans &= (abs(t[i] - t[i + 1]) != 1);
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
string even = "", odd = "";
for (int i = 0; i < s.length(); i++) {
if (s[i] % 2 == 0)
even.push_back(s[i]);
else
odd.push_back(s[i]);
}
sort(even.begin(), even.end());
sort(odd.begin(), odd.end());
if (check(even + odd)) {
cout << (even + odd).c_str();
} else if (check(odd + even)) {
cout << (odd + even).c_str();
} else
cout << "No answer";
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char text[200001];
int txtlen;
char target[200001];
int len;
int rorder[200001];
bool evaluate(int n) {
int tlen = 0;
for (decltype(0) i = 0; i < txtlen; i++) {
if (rorder[i] < n) continue;
if (text[i] != target[tlen]) continue;
tlen++;
if (tlen == len) return true;
}
return false;
}
int main() {
scanf("%s", text) == 0;
scanf("%s", target) == 0;
txtlen = strlen(text);
len = strlen(target);
int r;
for (decltype(0) i = 0; i < txtlen; i++) {
scanf("%d", &r) == 0;
r--;
rorder[r] = i;
}
int start = 0, end = txtlen - 1, mid, li = 0;
while (start <= end) {
mid = (start + end) / 2;
bool b = evaluate(mid);
if (!b)
end = mid - 1;
else
start = mid + 1, li = mid;
}
printf("%d", li);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
scanf("%d%d", &n, &k);
if (n == 2 || n == 3) {
printf("-1\n");
return 0;
}
if (k == 1 || k > 3) {
printf("-1\n");
return 0;
}
if (k == 2) {
if (n == 4)
printf("-1\n");
else {
printf("%d\n", n - 1);
for (int i = (1); i <= (n - 1); i++) printf("%d %d\n", i, i + 1);
}
return 0;
}
if (k == 3) {
int r = ((n - 2) * (n - 3)) / 2 + 2;
printf("%d\n", r);
for (int i = 1; i < n - 1; i++)
for (int j = i + 1; j < n - 1; j++) printf("%d %d\n", i, j);
printf("%d %d\n%d %d\n", n - 2, n - 1, n - 1, n);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int64_t t;
cin >> t;
while (t--) {
int64_t n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
bool ret = 0;
for (int64_t i = c - d; i <= c + d; i++) {
int64_t g = i - (a - b) * n;
if (g >= 0 && g <= 2 * b * n) ret = 1;
}
cout << (ret ? "Yes" : "No") << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
template <class T>
struct _iter_wrapper {
T begin_, end_;
T begin() { return begin_; }
T end() { return end_; }
};
template <class T>
_iter_wrapper<const T*> span(const T* arr, int n) {
return _iter_wrapper<const T*>{arr, arr + n};
}
template <class T, int N>
_iter_wrapper<const T*> span(const T (&arr)[N]) {
return span(arr, N);
}
using namespace std;
using namespace rel_ops;
using ll = long long;
using ull = unsigned long long;
using Vi = vector<int>;
using Vll = vector<ll>;
using Vull = vector<ull>;
using Pii = pair<int, int>;
template <class T, class V>
auto operator<<(T& out, V val) -> decltype(val.print(0), out) {
out << "{";
val.print();
return out << "}";
}
template <class T, class V>
auto operator<<(T& out, V val) -> decltype(get<1>(val), out) {
return out << "(" << val.first << ", " << val.second << ")";
}
template <class T, class V>
auto operator<<(T& out, V val) -> decltype((val).begin(), (val).end(), out) {
out << "[";
bool comma = false;
for (auto elem : val) {
if (comma) out << ", ";
out << elem;
comma = true;
}
return out << "]";
}
void DD(...) {}
template <class T, class... S>
void DD(const char* format, T elem, S... rest) {
int braces = 0;
while (*format && (braces > 0 || *format != ',')) {
if (*format == '(' || *format == '[' || *format == '{' || *format == '<') {
braces++;
}
if (*format == ')' || *format == ']' || *format == '}' || *format == '>')
braces--;
cerr << *format++;
}
cerr << ": " << elem << *format++;
DD(format, rest...);
}
template <class... T>
void _printDebug(int line, const char* format, T... elems) {
cerr << '<';
if (line < 10) cerr << '0';
if (line < 100) cerr << '0';
cerr << line << "> ";
DD(format, elems...);
cerr << endl;
}
void run();
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
run();
return 0;
}
void transpose64(array<ull, 64>& M) {
for (ull i = 0; i < 64; i += 1 * 2)
for (ull j = i; j < i + 1; j++) {
ull a = (M[j] >> 1) & 0x5555555555555555;
ull b = (M[j + 1] << 1) & 0xAAAAAAAAAAAAAAAA;
M[j] = (M[j] & 0x5555555555555555) | b;
M[j + 1] = (M[j + 1] & 0xAAAAAAAAAAAAAAAA) | a;
};
for (ull i = 0; i < 64; i += 2 * 2)
for (ull j = i; j < i + 2; j++) {
ull a = (M[j] >> 2) & 0x3333333333333333;
ull b = (M[j + 2] << 2) & 0xCCCCCCCCCCCCCCCC;
M[j] = (M[j] & 0x3333333333333333) | b;
M[j + 2] = (M[j + 2] & 0xCCCCCCCCCCCCCCCC) | a;
};
for (ull i = 0; i < 64; i += 4 * 2)
for (ull j = i; j < i + 4; j++) {
ull a = (M[j] >> 4) & 0xF0F0F0F0F0F0F0F;
ull b = (M[j + 4] << 4) & 0xF0F0F0F0F0F0F0F0;
M[j] = (M[j] & 0xF0F0F0F0F0F0F0F) | b;
M[j + 4] = (M[j + 4] & 0xF0F0F0F0F0F0F0F0) | a;
};
for (ull i = 0; i < 64; i += 8 * 2)
for (ull j = i; j < i + 8; j++) {
ull a = (M[j] >> 8) & 0xFF00FF00FF00FF;
ull b = (M[j + 8] << 8) & 0xFF00FF00FF00FF00;
M[j] = (M[j] & 0xFF00FF00FF00FF) | b;
M[j + 8] = (M[j + 8] & 0xFF00FF00FF00FF00) | a;
};
for (ull i = 0; i < 64; i += 16 * 2)
for (ull j = i; j < i + 16; j++) {
ull a = (M[j] >> 16) & 0xFFFF0000FFFF;
ull b = (M[j + 16] << 16) & 0xFFFF0000FFFF0000;
M[j] = (M[j] & 0xFFFF0000FFFF) | b;
M[j + 16] = (M[j + 16] & 0xFFFF0000FFFF0000) | a;
};
for (ull i = 0; i < 64; i += 32 * 2)
for (ull j = i; j < i + 32; j++) {
ull a = (M[j] >> 32) & 0xFFFFFFFF;
ull b = (M[j + 32] << 32) & 0xFFFFFFFF00000000;
M[j] = (M[j] & 0xFFFFFFFF) | b;
M[j + 32] = (M[j + 32] & 0xFFFFFFFF00000000) | a;
};
}
struct DenseGraph {
Vull M, marked;
int n, stride;
void init(int k) {
n = k;
stride = (k + 63) >> 6;
M.resize(n * stride);
clearVisited();
}
ull* edges(int i) { return &M[i * stride]; }
bool hasEdge(int i, int j) { return (edges(i)[j >> 6] >> (j & 63)) & 1; }
void addEdge(int i, int j) { edges(i)[j >> 6] |= 1ull << (j & 63); }
void delEdge(int i, int j) { edges(i)[j >> 6] &= ~(1ull << (j & 63)); }
void clearVisited() { marked.assign(stride, -1); }
void visit(int i) { marked[i >> 6] &= ~(1ull << (i & 63)); }
bool isVisited(int i) { return ~marked[i >> 6] & (1ull << (i & 63)); }
template <class T>
void dfsStep(int i, T func) {
ull* E = edges(i);
for (int w = 0; w < stride;) {
ull first = E[w] & marked[w];
if (first)
func((w << 6) | __builtin_ctzll(first));
else
w++;
}
}
};
struct PathSet {
map<int, ull> masks;
bool get(int i) { return (masks[i >> 6] >> (i & 63)) & 1; }
void insert(int i) { masks[i >> 6] |= 1ull << (i & 63); }
bool xorIt(int i) {
ull& mask = masks[i >> 6];
i &= 63;
mask ^= 1ull << i;
return (mask >> i) & 1;
}
template <class T>
void forEach(T func) {
for (auto& mask : (masks)) {
int offset = mask.first << 6;
ull first = mask.second;
while (first) {
int bit = __builtin_ctzll(first);
func(offset | bit);
first &= ~(1ull << bit);
}
}
}
};
struct Vert {
Vi edges;
PathSet paths;
bool visited{false};
};
int n, m, nVars;
vector<Vert> tree;
DenseGraph sat;
stack<int> postOrder;
vector<int> vars;
void dfsCrossing(int i) {
auto& cur = tree[i].paths;
tree[i].visited = true;
unordered_set<int> free;
cur.forEach([&cur, &free](int path) { free.insert(path); });
for (auto& e : (tree[i].edges)) {
if (tree[e].visited) continue;
dfsCrossing(e);
auto& child = tree[e].paths;
if (int((child.masks).size()) > int((cur.masks).size())) swap(cur, child);
child.forEach([&cur, &free](int path) {
if (cur.xorIt(path)) free.insert(path);
});
}
for (auto& path : (free))
if (cur.get(path)) {
ull* edges = sat.edges(nVars + path);
for (auto& mask : (cur.masks)) edges[mask.first] |= mask.second;
}
}
int neg(int i) { return i < nVars ? i + nVars : i - nVars; }
bool tryAssign(int i, int val) {
if (i < nVars) {
if (vars[i]) return false;
vars[i] = -val;
} else {
if (vars[i - nVars]) return false;
vars[i - nVars] = val;
}
return true;
}
void dfsPostorder(int i) {
sat.visit(i);
sat.dfsStep(i, dfsPostorder);
postOrder.push(i);
}
void dfsAssign(int i, bool first) {
sat.visit(i);
if (!tryAssign(i, 1)) {
if (first) return;
cout << "NO" << endl;
exit(0);
}
sat.dfsStep(i, [](int j) { dfsAssign(j, false); });
}
void run() {
cin >> n;
tree.resize(n);
for (int i = (1); i < (n); i++) {
int a, b;
cin >> a >> b;
tree[a - 1].edges.push_back(b - 1);
tree[b - 1].edges.push_back(a - 1);
}
cin >> m;
for (int i = (0); i < (m); i++)
for (int j = (0); j < (2); j++) {
int a, b;
cin >> a >> b;
tree[a - 1].paths.insert(i * 2 + j);
tree[b - 1].paths.insert(i * 2 + j);
}
nVars = m * 2;
sat.init(nVars * 2);
dfsCrossing(0);
for (int i = (0); i < (nVars); i++) sat.delEdge(nVars + i, i);
array<ull, 64> block1, block2;
for (int i = 0; i * 64 < nVars; i++) {
for (int j = 0; j * 64 < nVars; j++) {
for (int second = (0); second < (64); second++) {
int row1 = nVars + i * 64 + second, row2 = nVars + j * 64 + second;
block1[second] = (row1 < sat.n ? sat.edges(row1)[j] : 0);
block2[second] = (row2 < sat.n ? sat.edges(row2)[i] : 0);
}
transpose64(block1);
transpose64(block2);
for (int second = (0); second < (64); second++) {
int row1 = nVars + i * 64 + second, row2 = nVars + j * 64 + second;
if (row1 < sat.n) sat.edges(row1)[j] |= block2[second];
if (row2 < sat.n) sat.edges(row2)[i] |= block1[second];
}
}
}
for (int i = (0); i < (m); i++) {
int a = i * 2, b = i * 2 + 1;
sat.addEdge(a, nVars + b);
sat.addEdge(b, nVars + a);
sat.addEdge(nVars + a, b);
sat.addEdge(nVars + b, a);
}
for (int i = (0); i < (sat.n); i++)
if (!sat.isVisited(i)) dfsPostorder(i);
sat.clearVisited();
vars.resize(nVars);
while (!postOrder.empty()) {
int i = postOrder.top();
postOrder.pop();
if (!sat.isVisited(i)) dfsAssign(neg(i), true);
}
cout << "YES\n";
for (int i = (0); i < (m); i++) {
cout << (vars[i * 2] == 1 ? 1 : 2) << '\n';
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using ld = long double;
const int mod = 1e9 + 7;
const ll inf = 1e9;
const ll INF = 2e18;
const int N = 2e6 + 66;
int p[N], used[N];
void solve() {
int n;
cin >> n;
if (n == 1) return void(cout << "YES");
for (int i = 1; i <= n; ++i) {
cin >> p[i];
}
vector<vector<int>> cycles;
for (int i = 1; i <= n; ++i) {
if (used[i]) continue;
vector<int> now;
int j = i;
while (!used[j]) {
used[j] = 1;
now.push_back(j);
j = p[j];
}
cycles.push_back(now);
}
sort(cycles.begin(), cycles.end(),
[](vector<int> a, vector<int> b) { return a.size() < b.size(); });
auto a = cycles[0];
if ((int)a.size() > 2) return void(cout << "NO");
if ((int)a.size() == 1) {
cout << "YES\n";
for (int i = 1; i < (int)cycles.size(); ++i) {
auto b = cycles[i];
for (int j = 0; j < (int)b.size(); ++j) {
cout << a[0] << " " << b[j] << "\n";
}
}
return;
}
bool ok = true;
for (int i = 1; i < (int)cycles.size(); ++i) {
ok &= cycles[i].size() % 2 == 0;
}
if (!ok) return void(cout << "NO");
cout << "YES\n" << a[0] << " " << a[1] << "\n";
for (int i = 1; i < (int)cycles.size(); ++i) {
auto b = cycles[i];
for (int j = 0; j < (int)b.size(); ++j) {
cout << a[j & 1] << " " << b[j] << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int tt = 1;
while (tt--) {
solve();
cout << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const double eps = 1e-10;
const long long linf = 1e18 + 7;
const long long hh = 523;
int dp[2][200007];
int ans[2][200007];
vector<int> G[2][200007];
int fa[200007];
long long res = 0, sum0 = 0, sum1 = 0;
void dfs(int v, int p) {
fa[v] = p;
dp[0][v] = 1;
dp[1][v] = 0;
for (int k = 0; k <= 1; k++) {
for (int j = 0; j < G[k][v].size(); j++) {
int u = G[k][v][j];
if (u == p) {
continue;
}
dfs(u, v);
if (k == 0) {
dp[0][v] += dp[0][u];
} else {
dp[0][v] += dp[1][u] + 1;
dp[1][v] += dp[1][u] + 1;
}
}
}
}
void calc(int v, int e) {
if (v == 0) {
res += dp[0][0];
} else {
if (e == 1) {
res += dp[0][v] + sum1;
} else {
res += dp[0][v] + sum0;
}
}
for (int k = 0; k <= 1; k++) {
for (int j = 0; j < G[k][v].size(); j++) {
int u = G[k][v][j];
if (u == fa[v]) {
continue;
}
long long t0 = sum0, t1 = sum1;
if (k == 1) {
sum1 += dp[1][v] - dp[1][u];
sum0 = sum1;
} else {
sum0 += dp[0][v] - dp[0][u];
sum1 = 0;
}
calc(u, k);
sum0 = t0;
sum1 = t1;
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int x, y, c;
scanf("%d%d%d", &x, &y, &c);
x--;
y--;
G[c][x].push_back(y);
G[c][y].push_back(x);
}
dfs(0, 0);
calc(0, 0);
printf("%I64d\n", res - n);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void r1(T &x) {
x = 0;
char c(getchar());
int f(1);
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; '0' <= c && c <= '9'; c = getchar()) x = (x * 10) + (c ^ 48);
x *= f;
}
const int maxn = 5e5 + 5;
const int maxk = 1e2 + 5;
const int maxp = 1e2 + 5;
const int maxm = maxn << 1;
const int inf = 0x3f3f3f3f;
int n, k, p;
int f[maxn][maxk], g[maxp], a[maxn], g1[maxp];
int sz;
struct Seg {
int t[maxp << 2];
int lowbit(int x) { return x & (-x); }
void add(int pos, int c) {
for (; pos <= sz; pos += lowbit(pos)) t[pos] = max(t[pos], c);
}
int ask(int pos) {
int res(0);
for (; pos; pos -= lowbit(pos)) res = max(res, t[pos]);
return res;
}
} T;
int sum[maxn], dp[maxn];
signed main() {
int i, j;
r1(n), r1(k), r1(p);
for (i = 1; i <= n; ++i) r1(a[i]), a[i] %= p;
if (k * p >= n) {
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (j = 1; j <= k; ++j) {
for (i = 0; i < p; ++i) g[i] = inf;
for (i = 1; i <= n; ++i) {
for (int z = 0; z < p; ++z) g1[(a[i] + z) % p] = g[z];
for (int z = 0; z < p; ++z) g[z] = g1[z];
g[a[i]] = min(g[a[i]], f[i - 1][j - 1]);
for (int z = 0; z < p; ++z) f[i][j] = min(f[i][j], g[z] + z);
}
}
printf("%d\n", f[n][k]);
} else {
for (i = 1; i <= n; ++i) sum[i] = (sum[i - 1] + a[i]) % p;
sz = 1;
while (sz < p) sz *= 2;
for (i = 1; i <= n; ++i) {
dp[i] = T.ask(sum[i] + 1) + 1;
T.add(sum[i] + 1, dp[i]);
}
if (dp[n] >= k)
printf("%d\n", sum[n]);
else
printf("%d\n", sum[n] + p);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T;
long long a[200080];
long long b[200080];
string s;
long long n;
long long ans;
long long now;
long long num = 0;
int main() {
cin >> n;
cin >> s;
ans = (n * (n - 1)) / 2;
now = 0;
for (int i = 1; i <= n - 1; i++) {
if (s[i] == s[i - 1]) continue;
num += 1;
ans -= (i - now);
now = i;
}
now = n - 1;
for (int i = n - 2; i >= 0; i--) {
if (s[i] == s[i + 1]) continue;
ans -= (now - i);
now = i;
}
cout << ans + num;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int maxn = 505;
int a[maxn], dp[maxn][maxn];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
dp[i][j] = 999;
}
}
for (int i = 0; i < n; ++i) {
dp[i][i] = 1;
}
for (int len = 2; len <= n; ++len) {
for (int i = 0; i + len - 1 < n; ++i) {
int j = i + len - 1;
if (a[i] == a[j]) {
if (len == 2) {
dp[i][j] = 1;
} else {
dp[i][j] = dp[i + 1][j - 1];
}
}
for (int k = i; k < j; ++k) {
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j]);
}
}
}
printf("%d\n", dp[0][n - 1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
if (t == 10) {
if (n == 1)
cout << -1 << endl;
else {
for (int i = 0; i < n - 1; i++) cout << 1;
cout << 0 << endl;
}
} else {
for (int i = 0; i < n; i++) cout << t;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool issqr(long long n) {
long long r = round(sqrt((n)));
return n == r * r;
}
int main() {
long long k = 1;
int n;
cin >> n;
long long a[100005];
for (int i = 0; i < n / 2; i++) {
cin >> a[i];
}
int ap = 0;
long long ps = 0;
long long o[100005];
long long x = 0;
while ((++x) * x - ps <= 10e13) {
if (x * x <= ps) continue;
if (issqr(x * x + a[ap])) {
o[ap] = x * x - ps;
ps += o[ap] + a[ap];
ap++;
if (ap == n / 2) break;
}
if (x * x - (x - 1) * (x - 1) > a[ap]) break;
}
if (ap != n / 2) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
for (int i = 0; i < n / 2; i++) {
cout << o[i] << " " << a[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int Bs = 317, N = 2e5 + 10, mod = 998244353;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
template <typename T>
void add(T &x, T y, T mod) {
x = x + y > mod ? x + y - mod : x + y;
}
template <typename T>
void sub(T &x, T y, T mod) {
x = x - y < 0 ? x - y + mod : x - y;
}
template <typename T>
void multi(T &x, T y, T mod) {
x = 1ll * x * y % mod;
}
const int INF = (1ll << 30);
template <typename T>
void read(T &x) {
x = 0;
bool f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = 0;
} while (ch > '9' || ch < '0');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
x = f ? x : -x;
}
template <typename T>
void write(T x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
int pr[N], las[N], a[N], val[Bs][N], sum[N], f[N], tag[Bs], B, ans, k, n;
int belong(int x) { return (x - 1) / B + 1; }
inline void insert(int u, int v) {
int bu = belong(u);
sum[u] -= tag[bu];
add(ans, v, mod);
add(val[bu][sum[u] + n], v, mod);
}
void change(int u, int v) {
int bu = belong(u);
if (sum[u] + tag[bu] <= k) sub(ans, f[u - 1], mod);
sub(val[bu][sum[u] + n], f[u - 1], mod);
sum[u] += v;
if (sum[u] + tag[bu] <= k) add(ans, f[u - 1], mod);
add(val[bu][sum[u] + n], f[u - 1], mod);
}
inline void modify(int l, int r, int v) {
if (l > r) return;
int bl = belong(l), br = belong(r);
if (bl + 1 >= br) {
for (int i = l; i <= r; i++) change(i, v);
} else {
for (int i = l; i <= B * bl; i++) change(i, v);
for (int i = B * (br - 1) + 1; i <= r; i++) change(i, v);
for (int i = bl + 1; i < br; i++) {
if (~v)
sub(ans, val[i][k - tag[i] + n], mod);
else
add(ans, val[i][k - tag[i] + 1 + n], mod);
tag[i] += v;
}
}
}
int main() {
read(n);
read(k);
for (int i = 1, a; i <= n; ++i) read(a), pr[i] = las[a], las[a] = i;
B = sqrt(n);
f[0] = 1;
for (int i = 1; i <= n; ++i) {
insert(i, f[i - 1]);
modify(pr[i] + 1, i, 1);
modify(pr[pr[i]] + 1, pr[i], -1);
f[i] = ans;
}
printf("%d\n", f[n]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long sum[300001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
long long a, b, c;
cin >> a >> b >> c;
sum[a] -= c;
sum[b] += c;
}
vector<int> v;
for (int i = 1; i <= n; i++) {
if (sum[i] < 0) v.push_back(i);
}
vector<pair<pair<int, int>, long long> > ans;
for (int i = 1; i <= n; i++) {
if (sum[i] <= 0) continue;
while (sum[i] > 0) {
int j = v.back();
long long cur = min(sum[i], -sum[j]);
sum[i] -= cur;
sum[j] += cur;
ans.push_back({{j, i}, cur});
if (!sum[j]) v.pop_back();
}
}
cout << ans.size() << endl;
for (auto cur : ans)
cout << cur.first.first << " " << cur.first.second << " " << cur.second
<< endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long arr[15000000];
int main() {
long long int n, p, q, i, j, x, k, c;
c = 0;
for (i = 1;; i++) {
c += i;
arr[i] = c;
if (c > 100000000001000) break;
}
cin >> n;
for (i = 0;; i++) {
if (n > arr[i] && n <= arr[i + 1]) {
if (n == arr[i + 1]) {
x = i + 1;
} else if (n < arr[i + 1]) {
p = arr[i + 1] - n;
x = i + 1 - p;
}
break;
}
}
cout << x << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
inline int read() {
int data = 0, w = 1;
char ch = getchar();
while (ch != '-' && !isdigit(ch)) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (isdigit(ch)) data = data * 10 + (ch ^ 48), ch = getchar();
return data * w;
}
const int N(1e5 + 100);
struct edge {
int next, to, dis;
} e[N << 2];
int n, col[N], dis[N], vis[N], set[N], head[N], e_num, D, deg[N];
long long ans, cnt, cntf[270];
std::vector<int> R[N], v[N];
std::bitset<N> f[270];
inline void add_edge(int from, int to, int dis) {
e[++e_num] = (edge){head[from], to, dis}, head[from] = e_num;
}
void Dijkstra(int c) {
std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int> >,
std::greater<std::pair<int, int> > >
Q;
std::memset(dis, 0x3f, sizeof dis), std::memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++)
if (col[i] == c) Q.emplace(dis[i] = 0, i);
if (Q.empty()) return (void)(D = 0x3f3f3f3f);
while (!Q.empty()) {
int x = Q.top().second;
Q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int to = e[i].to, d = dis[x] + e[i].dis;
if (dis[to] > d) Q.emplace(dis[to] = d, to);
}
}
for (int i = 1; i <= n + 8; i++) R[i].clear();
for (int i = 1; i <= n + 8; i++)
for (int j = head[i]; j; j = e[j].next) {
int to = e[j].to;
if (dis[to] == dis[i] + e[j].dis) R[to].push_back(i);
}
D = 0;
for (int i = 1; i <= n; i++) D = std::max(D, dis[i]);
}
void dfs(int x, int c) {
if (x > n) {
f[1 << (x - n - 1)][c] = 1;
return;
}
if (dis[x] == 0) {
if (v[x].empty() || v[x].back() != c) v[x].push_back(c);
return;
}
for (auto i : R[x]) dfs(i, c);
}
char s[N];
int main() {
n = read(), std::scanf("%s", s + 1);
for (int i = 1; i <= n; i++) col[i] = s[i] - 'a' + 1;
for (int i = 1; i < n; i++) add_edge(i, i + 1, 1), add_edge(i + 1, i, 1);
for (int c = 1; c <= 8; c++)
for (int i = 1; i <= n; i++)
if (col[i] == c) add_edge(i, n + c, 0), add_edge(n + c, i, 1);
for (int c = 1; c <= 8; c++) {
Dijkstra(c);
long long res = 0, tot = 0, sum = 0;
if (D == 0x3f3f3f3f) continue;
auto calc = [&]() {
for (int i = 0; i < 8; i++) f[1 << i].reset();
for (int i = 1; i <= n; i++) v[i].clear();
for (int i = 1; i <= n; i++)
if (dis[i] == D) dfs(i, i), ++tot;
for (int i = 1; i < 256; cntf[i] = f[i].count(), i++)
if (!(i >> (c - 1) & 1) && i != (i & -i))
f[i] = f[i ^ (i & -i)] | f[i & -i];
for (int i = 1; i <= n + 8; i++) set[i] = deg[i] = 0;
for (int i = 1; i <= n + 8; i++)
for (auto j : R[i]) ++deg[j];
for (int i = 1; i <= 8; i++)
if (i != c) set[i + n] = 1 << (i - 1);
std::queue<int> Q;
for (int i = 1; i <= n + 8; i++)
if (!deg[i]) Q.push(i);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (auto i : R[x]) {
set[i] |= set[x];
if (!--deg[i]) Q.push(i);
}
}
for (int i = 1; i <= n; i++)
if (dis[i] == 0) {
++sum;
int s = cntf[set[i]];
for (auto j : v[i])
if (!f[set[i]][j]) ++s;
res += tot - s;
}
};
calc();
if (res == 0) {
--D, res = sum * tot, tot = 0, calc();
if (ans < D + 1) ans = D + 1, cnt = 0;
if (ans == D + 1) cnt += res;
} else {
if (ans < D + 1) ans = D + 1, cnt = 0;
if (ans == D + 1) cnt += res;
}
}
printf("%lld %lld\n", ans, cnt / 2);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[510];
int kk[510];
bool allSame(int l, int r) {
int num = a[l];
for (int i = l + 1; i <= r; i++) {
if (a[i] != num) {
return false;
}
}
return true;
}
int startIdx(int l, int r) {
int mx = 0;
int idx = l;
for (int i = l; i <= r; i++) {
bool valid = false;
if (i > l && a[i] > a[i - 1]) {
valid = true;
}
if (i < r && a[i] > a[i + 1]) {
valid = true;
}
if (valid && a[i] >= mx) {
mx = a[i];
idx = i;
}
}
return idx;
}
int main() {
memset(a, 0, sizeof(a));
memset(kk, 0, sizeof(kk));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", kk + i);
}
vector<pair<int, int> > ranges;
int idx = 1;
for (int i = 1; i <= k; i++) {
int num = kk[i];
int j = idx - 1;
while (j < n && num > 0) {
num -= a[++j];
}
if (num != 0) {
printf("NO\n");
return 0;
}
ranges.push_back(make_pair(idx, j));
idx = j + 1;
}
if (idx != n + 1) {
printf("NO\n");
return 0;
}
vector<string> ans;
for (int i = 1; i <= ranges.size(); i++) {
int l = ranges[i - 1].first, r = ranges[i - 1].second;
if (l == r) {
continue;
}
if (allSame(l, r)) {
printf("NO\n");
return 0;
}
int sIdx = startIdx(l, r);
if (sIdx == l) {
ans.push_back(to_string(i) + " R");
} else if (sIdx == r) {
ans.push_back(to_string(i + r - l) + " L");
sIdx--;
} else {
if (a[sIdx] > a[sIdx - 1]) {
ans.push_back(to_string(i + sIdx - l) + " L");
sIdx--;
} else {
ans.push_back(to_string(i + sIdx - l) + " R");
}
}
int tot = r - l - 1;
while (sIdx > l) {
ans.push_back(to_string(sIdx + i - l) + " L");
sIdx--;
tot--;
}
while (tot > 0) {
ans.push_back(to_string(sIdx + i - l) + " R");
tot--;
}
}
printf("YES\n");
for (auto& str : ans) {
printf("%s\n", str.c_str());
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int n, u, v, x, trie[maxn << 1][26], sz[maxn << 1], tot, cnt[maxn], res;
char op[2];
int merge(int a, int b) {
if (!a || !b) return a + b;
int rt = ++tot;
sz[rt] = 1;
for (int i = 0; i < 26; ++i) {
trie[rt][i] = merge(trie[a][i], trie[b][i]);
if (trie[rt][i]) sz[rt] += sz[trie[rt][i]];
}
return rt;
}
void dfs(int u, int dep) {
sz[u] = 1;
for (int i = 0; i < 26; ++i)
if (trie[u][i]) {
dfs(trie[u][i], dep + 1);
sz[u] += sz[trie[u][i]];
}
cnt[dep] += sz[u];
tot = n;
int rt = 0;
for (int i = 0; i < 26; ++i) rt = merge(rt, trie[u][i]);
cnt[dep] -= sz[rt];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d%s", &u, &v, op);
trie[u][op[0] - 'a'] = v;
}
sz[0] = 1;
dfs(1, 0);
res = 0;
for (int i = 1; i < n; ++i)
if (cnt[i] > cnt[res]) res = i;
printf("%d\n%d\n", sz[1] - cnt[res], res + 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(20) << fixed;
long long n, w;
cin >> n >> w;
long long a[n];
long long x;
vector<pair<long long, long long>> v;
long long s = 0;
for (long long i = 0; i < n; i++) {
cin >> x;
v.push_back({x, i});
s += (x + 1) / 2;
}
if (s > w) {
cout << -1 << endl;
return 0;
}
w -= s;
sort(v.begin(), v.end(), greater<pair<long long, long long>>());
for (pair<long long, long long> x : v) {
long long t = (x.first + 1) / 2;
long long mn = min(x.first - t, w);
w -= mn;
a[x.second] = t + mn;
}
for (long long i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
signed main() {
long long t = 1;
while (t--) {
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << power(m, n, mod) << '\n';
} else if (k == n) {
cout << power(m, (n + 1) / 2, mod) << '\n';
} else if (k % 2) {
cout << power(m, 2, mod) << '\n';
} else {
cout << m << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, father[1000010];
vector<int> a[1000010], num[1000010];
vector<pair<int, int> > wz[1000010];
map<int, int> mp;
map<int, int> ans, mxx, mxy;
priority_queue<pair<pair<int, int>, int>, vector<pair<pair<int, int>, int> >,
greater<pair<pair<int, int>, int> > >
pq;
int xy(int x, int y) { return (x - 1) * m + y; }
int findfather(int x) {
if (father[x] == x)
return father[x];
else
return father[x] = findfather(father[x]);
}
void ak(int aa, int bb) {
int a1 = findfather(aa), b1 = findfather(bb);
if (a1 != b1) father[a1] = b1;
}
int main() {
int MX, len, i, j, val, x, y, cc, s1;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
a[i].push_back(0);
num[i].push_back(0);
for (j = 1; j <= m; j++) {
scanf("%d", &s1);
a[i].push_back(s1);
num[i].push_back(xy(i, j));
pq.push(make_pair(make_pair(a[i][j], i), j));
}
}
for (i = 1; i <= n * m; i++) father[i] = i;
for (i = 1; i <= n; i++) {
mp.clear();
for (j = 1; j <= m; j++) {
if (mp[a[i][j]] == 0)
mp[a[i][j]] = findfather(num[i][j]);
else
ak(mp[a[i][j]], num[i][j]);
}
}
for (j = 1; j <= m; j++) {
mp.clear();
for (i = 1; i <= n; i++) {
if (mp[a[i][j]] == 0)
mp[a[i][j]] = findfather(num[i][j]);
else
ak(mp[a[i][j]], num[i][j]);
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
wz[findfather(num[i][j])].push_back(make_pair(i, j));
}
while (!pq.empty()) {
pair<pair<int, int>, int> T = pq.top();
pq.pop();
val = T.first.first;
x = T.first.second;
y = T.second;
if (ans[findfather(num[x][y])] == 0) {
MX = 0;
len = wz[findfather(num[x][y])].size();
for (i = 0; i < len; i++) {
MX = max(MX, max(mxx[wz[findfather(num[x][y])][i].first],
mxy[wz[findfather(num[x][y])][i].second]));
}
ans[findfather(num[x][y])] = MX + 1;
cc = ans[findfather(num[x][y])];
mxx[x] = max(mxx[x], cc);
mxy[y] = max(mxy[y], cc);
} else {
cc = ans[findfather(num[x][y])];
mxx[x] = max(mxx[x], cc);
mxy[y] = max(mxy[y], cc);
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) printf("%d ", ans[findfather(num[i][j])]);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long curr_edges, vertices;
vector<vector<int> > graph;
void DFS(int i, vector<bool> &visited) {
curr_edges += graph[i].size();
visited[i] = true;
for (int j = 0; j < graph[i].size(); j++) {
if (visited[graph[i][j]] == false) {
vertices++;
DFS(graph[i][j], visited);
}
}
}
bool check_for_complete_graph(int n) {
vector<bool> visited(n + 1, false);
for (int i = 1; i <= n; i++) {
if (visited[i] == false) {
vertices = 1;
curr_edges = 0;
DFS(i, visited);
curr_edges /= 2;
if (curr_edges != ((vertices * (vertices - 1)) / 2)) return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
graph.clear();
graph.resize(n + 1);
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
if (check_for_complete_graph(n))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y, b, r;
cin >> y >> b >> r;
if (r <= b && r <= y)
cout << (r + (r - 1) + (r - 2));
else if (b < r && b <= y)
cout << (b * 3);
else if (y < b && r - y > 1)
cout << y * 3 + 3;
else
cout << y * 3;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.