solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int vis[maxn];
int d[maxn];
vector<int> mp[maxn];
vector<int> tpath, rpath;
void dfs(int s) {
for (int i = 0; i < mp[s].size(); i++) {
int to = mp[s][i];
if (vis[to] || d[to] > 1) continue;
vis[to] = 1;
tpath.push_back(to);
dfs(to);
vis[to] = 0;
}
}
int main() {
int n, tmp;
vector<int> s;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &tmp);
if (tmp == 1) {
s.push_back(i);
vis[i] = 1;
}
}
for (int i = 1; i <= n; i++) {
scanf("%d", &tmp);
if (tmp == 0) continue;
mp[i].push_back(tmp);
d[tmp]++;
}
for (int i = 0; i < s.size(); i++) {
tpath.clear();
tpath.push_back(s[i]);
dfs(s[i]);
if (tpath.size() > rpath.size()) rpath.assign(tpath.begin(), tpath.end());
}
int size = rpath.size();
cout << size << endl;
for (int i = size - 1; i > 0; i--) printf("%d ", rpath[i]);
printf("%d\n", rpath[0]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using std::min;
const int MAXN = 305;
const int MOD = 1000000007;
int N, A[MAXN], size[MAXN], tot_s = 0, DP[MAXN][MAXN], C[MAXN][MAXN], Fac[MAXN];
bool grp[MAXN] = {0};
inline bool pfct_sq(long long x) {
long long sqr = floor(sqrt(x + 0.5));
return sqr * sqr == x;
}
inline void updata(int& x, int d) { x = ((long long)x + d) % MOD; }
void init();
int main() {
scanf("%d", &N);
int i = 0, j;
for (i = 0; i < N; i++) scanf("%d", &A[i]);
for (i = 0; i < N; i++)
if (!grp[i]) {
for (grp[i] = true, size[tot_s] = 1, j = i + 1; j < N; j++)
if (A[i] == A[j] || pfct_sq((long long)A[i] * A[j]))
grp[j] = true, size[tot_s]++;
tot_s++;
}
init();
int total = 0, k, lim_k, l, lim_l;
for (i = 0, DP[0][0] = 1; i < tot_s; total += size[i++])
for (j = 0; j <= total; j++)
if (DP[i][j]) {
for (k = 1, lim_k = size[i]; k <= lim_k; k++)
for (l = 0, lim_l = min(k, j); l <= lim_l; l++)
updata(DP[i + 1][j - l + size[i] - k],
(long long)DP[i][j] * Fac[size[i]] % MOD *
C[size[i] - 1][k - 1] % MOD * C[j][l] % MOD *
C[total - j + 1][k - l] % MOD);
}
printf("%d\n", DP[tot_s][0]);
return 0;
}
void init() {
int i, j;
for (C[0][0] = 1, i = 1; i <= N; i++)
for (C[i][0] = 1, j = 1; j <= i; j++)
C[i][j] = ((long long)C[i - 1][j - 1] + C[i - 1][j]) % MOD;
for (Fac[0] = i = 1; i <= N; i++) Fac[i] = (long long)i * Fac[i - 1] % MOD;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-10;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long double PI = 3.1415926535897932384626433832795028841;
map<string, int> ssol;
void checkAdd(string vs) {
if (ssol.find(vs) != ssol.end()) {
return;
}
ssol[vs] = 1;
}
bool TST = 0;
long long powmod(long long a, long long b) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
void Show(int *QQ, int N) {
if (not TST) {
return;
}
for (int x = 0; x < N; x++) {
cout << QQ[x];
if (x != N - 1) {
cout << ',';
}
}
cout << '\n';
}
void ShowLL(long long *QQ, int N) {
if (not TST) {
return;
}
for (int x = 0; x < N; x++) {
cout << QQ[x];
if (x != N - 1) {
cout << ',';
}
}
cout << '\n';
}
int a1[4];
int b1[4];
int gd(int num, int d) {
while (d--) num /= 10;
return num % 10;
}
set<int> pos;
bool dif(int n) {
if (gd(n, 0) == gd(n, 1)) return 0;
if (gd(n, 0) == gd(n, 2)) return 0;
if (gd(n, 0) == gd(n, 3)) return 0;
if (gd(n, 1) == gd(n, 2)) return 0;
if (gd(n, 1) == gd(n, 3)) return 0;
if (gd(n, 2) == gd(n, 3)) return 0;
return 1;
}
bool valid(int original, int target, int b, int c) {
int cnt = 0;
while (cnt < 4) {
a1[cnt++] = original % 10;
original /= 10;
}
cnt = 0;
while (cnt < 4) {
b1[cnt++] = target % 10;
target /= 10;
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (a1[i] == b1[j]) {
if (i == j) b--;
if (i != j) c--;
}
}
}
return (b == 0) and (c == 0);
}
int main() {
ios::sync_with_stdio(0);
for (int i = 0; i < 10000; i++)
if (dif(i)) pos.insert(i);
int st = 1;
while (pos.size() > 1) {
vector<int> vls;
for (set<int>::iterator it = pos.begin(); it != pos.end(); it++)
vls.push_back(*it);
int ans;
if (st == 0) {
int win = -1;
int min_worst_case = INT_MAX;
for (int i = 0; i < vls.size(); i++) {
int max_sum = 0;
for (int b = 0; b <= 4; b++) {
for (int c = 0; c <= 4; c++) {
if (b + c > 4) continue;
int sum = 0;
for (int j = 0; j < vls.size(); j++) {
if (valid(vls[i], vls[j], b, c)) {
sum++;
}
}
max_sum = max(max_sum, sum);
}
}
if (min_worst_case > max_sum) win = i;
min_worst_case = min(min_worst_case, max_sum);
}
ans = vls[win];
} else {
ans = 123;
st = 0;
}
if (ans < 10) cout << 0;
if (ans < 100) cout << 0;
if (ans < 1000) cout << 0;
cout << ans << '\n';
fflush(stdout);
int b, c;
cin >> b >> c;
if (b == 4) return 0;
vector<int> del;
for (int i = 0; i < vls.size(); i++) {
if (not valid(ans, vls[i], b, c)) {
del.push_back(vls[i]);
}
}
for (int i = 0; i < del.size(); i++) {
pos.erase(del[i]);
}
}
int rta = *(pos.begin());
if (rta < 10) cout << 0;
if (rta < 100) cout << 0;
if (rta < 1000) cout << 0;
cout << rta << '\n';
fflush(stdout);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int inf = (int)1e9 + 123;
const long long infl = (long long)1e18 + 123;
const double eps = 1e-10;
const int MAX_N = (int)3e5 + 123;
int n;
int dist[2005][2005];
long long ans[2005];
bool used[2005];
int main() {
scanf("%d", &n);
int mini = inf;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
scanf("%d", &dist[i][j]);
dist[j][i] = dist[i][j];
mini = min(mini, dist[i][j]);
}
}
for (int i = 1; i <= n; i++) {
ans[i] = inf;
for (int j = 1; j <= n; j++) {
if (j == i) continue;
dist[i][j] -= mini;
ans[i] = min(ans[i], 2ll * dist[i][j]);
}
}
for (int it = 0; it < n; it++) {
int id = -1;
for (int i = 1; i <= n; i++)
if (!used[i] && (id == -1 || ans[id] > ans[i])) id = i;
used[id] = 1;
for (int j = 1; j <= n; j++)
if (!used[j]) ans[j] = min(ans[j], ans[id] + dist[id][j]);
}
for (int i = 1; i <= n; i++) printf("%lld\n", ans[i] + 1ll * mini * (n - 1));
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 50;
int n, k, m;
long long a[maxn];
string s[maxn];
map<string, long long> M;
queue<string> Q;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int num;
for (int i = 1; i <= k; i++) {
cin >> num;
long long mn = INF;
int x;
while (num--) {
cin >> x;
Q.push(s[x]);
mn = min(a[x], mn);
}
while (Q.size()) {
M[Q.front()] = mn;
Q.pop();
}
}
string ss;
long long ans = 0;
for (int i = 1; i <= m; i++) {
cin >> ss;
ans += M[ss];
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
size_t t;
std::cin >> t;
while (t-- > 0) {
std::string s;
std::cin >> s;
size_t suf0, suf1, pref0, pref1;
suf0 = suf1 = pref0 = pref1 = 0;
for (auto it : s) {
suf0 += (it == '0');
suf1 += (it == '1');
}
size_t ans = std::min(suf0, suf1);
for (auto &it : s) {
pref0 += (it == '0'), suf0 -= (it == '0');
pref1 += (it == '1'), suf1 -= (it == '1');
ans = std::min(ans, pref1 + suf0);
ans = std::min(ans, pref0 + suf1);
}
std::cout << ans << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const string exam = "z1w2e3";
string inttostr(int x) {
string ans = "";
while (x) ans += char('0' + x % 10), x /= 10;
reverse(ans.begin(), ans.end());
return ans;
}
int strtoint(const string &s) {
int ans = 0;
for (int i = 0; i < s.size(); i++)
if ('a' <= s[i] && s[i] <= 'z') {
ans = -10;
break;
} else
ans += s[i] - '0', ans *= 10;
if (inttostr(ans / 10) != s) ans = -1;
return ans / 10;
}
set<int> fir, sec;
vector<int> l, r;
vector<pair<string, bool> > sp, sp2;
vector<pair<string, string> > ans;
void f1() {
for (int i = 0; i < sp.size(); i++) {
if (sp[i].second) {
if (fir.size()) {
ans.push_back(make_pair(sp[i].first, inttostr(*fir.begin())));
fir.erase(fir.begin());
} else {
int x = l.back();
l.pop_back();
if (sec.size()) {
ans.push_back(make_pair(inttostr(x), inttostr(*sec.begin())));
sec.erase(sec.begin());
} else {
ans.push_back(make_pair(inttostr(x), exam));
sp.push_back(make_pair(exam, 0));
}
ans.push_back(make_pair(sp[i].first, inttostr(x)));
}
}
}
}
void f2() {
for (int i = 0; i < r.size(); i++) {
if (fir.size()) {
ans.push_back(make_pair(inttostr(r[i]), inttostr(*fir.begin())));
sec.insert(r[i]);
fir.erase(fir.begin());
} else {
int x = l.back();
l.pop_back();
if (sec.size()) {
ans.push_back(make_pair(inttostr(x), inttostr(*sec.begin())));
sec.erase(sec.begin());
} else {
ans.push_back(make_pair(inttostr(x), exam));
sp.push_back(make_pair(exam, 0));
}
sec.insert(r[i]);
ans.push_back(make_pair(inttostr(r[i]), inttostr(x)));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int sch = 0;
for (int i = 0; i < n; i++) {
string s;
bool t;
cin >> s >> t;
sch += t;
sp.push_back(make_pair(s, t));
}
for (int i = 1; i <= sch; i++) fir.insert(i);
for (int i = sch + 1; i <= n; i++) sec.insert(i);
for (int i = 0; i < sp.size(); i++) {
int x = strtoint(sp[i].first);
if (0 < x && x <= sch) {
if (sp[i].second == 0) l.push_back(x);
fir.erase(x);
} else if (sch < x && x <= n) {
if (sp[i].second == 1) r.push_back(x);
sec.erase(x);
} else
sp2.push_back(sp[i]);
}
sp = sp2;
sp2.clear();
if (fir.size())
f2(), f1();
else
f1(), f2();
for (int i = 0; i < sp.size(); i++)
if (sp[i].second == 0) {
ans.push_back(make_pair(sp[i].first, inttostr(*sec.begin())));
sec.erase(sec.begin());
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << "move " << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int m, n, st[1005][1005], cnt = 0, pref[1005][1005];
cin >> n >> m;
for (int i = 0; i < n + 1; i++) {
pref[i][0] = 0;
}
for (int i = 0; i < m + 1; i++) {
pref[0][i] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> st[i][j];
pref[i][j] = st[i][j];
pref[i][j] += pref[i - 1][j];
pref[i][j] += pref[i][j - 1];
pref[i][j] -= pref[i - 1][j - 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (st[i][j] == 0) {
if (pref[i][j] - pref[i - 1][j] > 0) cnt++;
if (pref[i][j] - pref[i][j - 1] > 0) cnt++;
if (pref[n][j] - pref[n][j - 1] - pref[i][j] + pref[i][j - 1] > 0)
cnt++;
if (pref[i][m] - pref[i - 1][m] - pref[i][j] + pref[i - 1][j] > 0)
cnt++;
}
}
}
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
long long lc = lcm(a, b);
long long DashaFreq = (lc / a) - 1;
long long MashaFreq = (lc / b) - 1;
if (DashaFreq < MashaFreq) {
if (DashaFreq + 1 == MashaFreq)
cout << "Equal";
else
cout << "Masha";
} else {
if (DashaFreq == MashaFreq + 1)
cout << "Equal";
else
cout << "Dasha";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int head[N];
struct Edge {
int next, to, len;
} ed[N * 2];
int ecnt;
inline void addedge(int u, int v, int l) {
ed[ecnt].next = head[u];
ed[ecnt].to = v;
ed[ecnt].len = l;
head[u] = ecnt++;
}
long long h1[N], h2[N];
int id[N];
void dfs1(int u, int fa) {
h1[u] = h2[u] = 0;
for (int e = head[u]; ~e; e = ed[e].next) {
int v = ed[e].to;
if (v == fa) continue;
dfs1(v, u);
if (h1[v] + ed[e].len > h1[u]) {
h2[u] = h1[u];
h1[u] = h1[v] + ed[e].len;
id[u] = v;
} else {
h2[u] = max(h2[u], h1[v] + ed[e].len);
}
}
}
long long dis[N];
void dfs2(int u, int fa, long long fmx) {
dis[u] = max(fmx, h1[u]);
for (int e = head[u]; ~e; e = ed[e].next) {
int v = ed[e].to;
if (v == fa) continue;
if (v == id[u]) {
dfs2(v, u, max(fmx, h2[u]) + ed[e].len);
} else {
dfs2(v, u, max(fmx, h1[u]) + ed[e].len);
}
}
}
bool cmp(int x, int y) { return dis[x] > dis[y]; }
int seq[N], fa[N];
void dfs3(int u, int father) {
fa[u] = father;
for (int e = head[u]; ~e; e = ed[e].next) {
int v = ed[e].to;
if (v == father) continue;
dfs3(v, u);
}
}
int F[N], sz[N], n;
int findroot(int x) { return F[x] == x ? x : F[x] = findroot(F[x]); }
int solve(long long D) {
for (int i = 1; i <= n; ++i) {
F[i] = i;
sz[i] = 1;
}
int res = 0;
for (int l = 1, r = 1; r <= n; ++r) {
for (; dis[seq[l]] > dis[seq[r]] + D; ++l) {
--sz[findroot(seq[l])];
}
for (int e = head[seq[r]]; ~e; e = ed[e].next) {
int v = ed[e].to;
if (v == fa[seq[r]]) continue;
sz[findroot(seq[r])] += sz[findroot(v)];
F[findroot(v)] = findroot(seq[r]);
}
res = max(res, sz[findroot(seq[r])]);
}
return res;
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v, l;
scanf("%d%d%d", &u, &v, &l);
addedge(u, v, l);
addedge(v, u, l);
}
dfs1(1, 1);
dfs2(1, 1, 0);
for (int i = 1; i <= n; ++i) seq[i] = i;
sort(seq + 1, seq + 1 + n, cmp);
dfs3(seq[n], seq[n]);
int q;
scanf("%d", &q);
while (q--) {
long long D;
scanf("%I64d", &D);
printf("%d\n", solve(D));
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.txt");
ofstream out("output.txt");
;
long long n, k;
vector<long long> vec;
void input() {}
void init() { input(); }
unordered_map<long long, long long> mp;
void solve() {}
signed main() {
string s;
cin >> s;
long long sz = s.size();
long long curr = 0;
for (long long i = 1; i <= 5; i++) {
if ((sz / i) + (((sz % i) ? 1 : 0)) <= 20) {
vector<string> vec(i);
long long ost = sz % i;
if (ost) ost = i - ost;
for (long long j = 0; j < i; j++) {
long long c = 0;
if (ost) {
c++;
ost--;
vec[j].push_back('*');
}
for (; (sz % i != 0) ? c <= sz / i : c < sz / i; c++)
vec[j].push_back(s[curr++]);
}
cout << vec.size() << " " << sz / i + (sz % i != 0) << "\n";
for (long long j = 0; j < i; j++) cout << vec[j] << "\n";
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void stop() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
int main() {
fast();
cout << fixed << setprecision(6);
int n, m;
cin >> n >> m;
vector<long long> a(n, 0);
long long x = 0, dn = 0, dp = 0;
while (m--) {
int x1, d;
cin >> x1 >> d;
x += x1;
if (d >= 0)
dp += d;
else
dn += d;
}
int z = n / 2;
for (int i = 0; i < n; i++) a[i] += x + dp * i + dn * abs(i - z);
double sum = 0;
for (int i = 0; i < n; i++) sum += a[i];
cout << sum / n;
stop();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 201010;
int main() {
ios_base::sync_with_stdio(0);
int test;
cin >> test;
while (test--) {
int n, a, b;
cin >> a >> b >> n;
int f[3] = {a, b, a ^ b};
cout << f[n % 3] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, v, i, sum = 0;
scanf("%d%d", &n, &v);
int a[n], b[n];
float c[n], ans, x1, x2;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum = sum + a[i];
}
for (i = 0; i < n; i++) scanf("%d", &b[i]);
for (i = 0; i < n; i++) c[i] = ((float)b[i]) / a[i];
x2 = c[0];
for (i = 0; i < n; i++)
if (c[i] < x2) x2 = c[i];
x1 = ((float)v) / sum;
if (x1 < x2) {
ans = x1 * sum;
} else
ans = x2 * sum;
printf("%.4f", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
vector<pair<int, int>> graph[maxn];
int n, k;
long long dp[maxn][2];
void dfs(const int &u, const int &p) {
if (graph[u].size() == 1 && p != -1) return;
vector<pair<long long, int>> dpChildren;
int idx = -1;
for (const auto &[v, c] : graph[u]) {
idx++;
if (v == p) continue;
dfs(v, u);
dpChildren.push_back({dp[v][1] + c, idx});
}
sort(dpChildren.begin(), dpChildren.end(), greater<pair<long long, int>>());
long long sum = 0;
for (int i = 0; i < min((int)dpChildren.size(), k - 1); i++) {
sum += dpChildren[i].first;
}
dp[u][1] = sum;
if (dpChildren.size() >= k) sum += dpChildren[k - 1].first;
for (int i = 0; i < dpChildren.size(); i++) {
int idx = dpChildren[i].second;
int v = graph[u][idx].first;
int c = graph[u][idx].second;
if (i < k - 1)
dp[u][0] = max(dp[u][0], dp[v][0] + sum - dp[v][1]);
else
dp[u][0] = max(dp[u][0], dp[u][1] + dp[v][0] + c);
}
}
int main() {
cin >> n >> k;
for (int i = 1; i < n; i++) {
int u, v, c;
cin >> u >> v >> c;
graph[u].push_back({v, c});
graph[v].push_back({u, c});
}
dfs(0, -1);
cout << dp[0][0] << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, a, b, k;
int t1, f1, t2, f2;
scanf("%d%d%d%d%d", &n, &h, &a, &b, &k);
while (k--) {
scanf("%d%d%d%d", &t1, &f1, &t2, &f2);
if (t1 != t2) {
int ff;
long long res = 0;
if (f1 > b) {
ff = b;
res += f1 - b;
} else if (f1 < a) {
ff = a;
res += a - f1;
} else
ff = f1;
res += abs(t2 - t1);
res += abs(ff - f2);
cout << res << endl;
} else
cout << abs(f1 - f2) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void next() {
string a, b;
cin >> a >> b;
for (int i = 0; i < a.length(); ++i) {
if (a[i] == b[i])
cout << "0";
else
cout << "1";
}
}
int main() { next(); }
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 105;
int n, k;
int a[maxN][maxN];
char board[maxN][maxN];
void ReadInput() {
cin >> n >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> board[i][j];
fill_n(&a[0][0], sizeof(a) / sizeof(a[0][0]), 0);
}
bool Ngang(int x, int y) {
int cnt = 0;
for (int j = y; j - y < k && j < n; j++) {
if (board[x][j] == '#')
return false;
else
cnt++;
}
if (cnt < k) return false;
return true;
}
bool Doc(int x, int y) {
int cnt = 0;
for (int i = x; i - x < k && i < n; i++) {
if (board[i][y] == '#')
return false;
else
cnt++;
}
if (cnt < k) return false;
return true;
}
void Fil(int x, int y, int xx, int yy) {
for (int i = x; i <= xx; i++)
for (int j = y; j <= yy; j++) a[i][j]++;
}
void Solve() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (Ngang(i, j)) Fil(i, j, i, j + k - 1);
if (Doc(i, j)) Fil(i, j, i + k - 1, j);
}
int max_a = 0, posx = 0, posy = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i][j] > max_a) {
max_a = a[i][j];
posx = i;
posy = j;
}
cout << posx + 1 << ' ' << posy + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ReadInput();
Solve();
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using vi = std::vector<int>;
using vll = std::vector<ll>;
using vull = std::vector<ull>;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using namespace std;
int lft[300005], rgt[300005];
int minsuffix[300005], maxsuffix[300005], minprefix[300005], maxprefix[300005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> lft[i] >> rgt[i];
}
minsuffix[n - 1] = rgt[n - 1];
maxsuffix[n - 1] = lft[n - 1];
minprefix[0] = rgt[0];
maxprefix[0] = lft[0];
for (int i = 1; i < n; ++i) {
maxprefix[i] = max(maxprefix[i - 1], lft[i]);
minprefix[i] = min(minprefix[i - 1], rgt[i]);
}
for (int i = n - 2; i >= 0; --i) {
maxsuffix[i] = max(maxsuffix[i + 1], lft[i]);
minsuffix[i] = min(minsuffix[i + 1], rgt[i]);
}
int ans = 0;
ans = max(ans, minsuffix[1] - maxsuffix[1]);
ans = max(ans, minprefix[n - 2] - maxprefix[n - 2]);
for (int i = 1; i < n - 1; ++i) {
int p_l, p_r, s_l, s_r;
p_l = maxprefix[i - 1];
p_r = minprefix[i - 1];
s_l = maxsuffix[i + 1];
s_r = minsuffix[i + 1];
int l = max(p_l, s_l), r = min(p_r, s_r);
ans = max(ans, r - l);
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
int n, m;
int main() {
long long ans;
int b, c, A, B, C, l;
scanf("%d%d", &n, &m);
n++;
m++;
ans = 0;
for (c = m; c <= n >> 1; c++) {
C = (n * n - n * c + c * c) << 1;
A = (n << 1) - c;
for (b = n - m; b >= m; b--) {
B = b * (n + c);
l = (C - B) / (A - b);
if (m > l) l = m - 1;
if (l >= n - m) break;
ans += n - m - l;
if (c << 1 < n) ans += n - m - l;
}
}
printf("%I64d\n", ans * 3);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
int t;
cin >> t;
while (t--) {
cin >> s;
int lastR = 0;
int maxDist = 0;
int n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] == 'R') {
maxDist = max(maxDist, i + 1 - lastR);
lastR = i + 1;
}
}
maxDist = max(maxDist, n + 1 - lastR);
cout << maxDist << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
using vec = vector<T>;
template <class T>
using vvec = vector<vec<T>>;
template <class T>
bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
void solve() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vec<pair<int, int>> ans;
for (int i = 0; i < (2 * K - 2); i++) {
int r = 0;
for (int j = i; j < N; j++) {
if (i % 2 == 0) {
if (S[j] == '(') {
r = j;
break;
}
} else {
if (S[j] == ')') {
r = j;
break;
}
}
}
ans.emplace_back(i, r);
reverse(S.begin() + i, S.begin() + r + 1);
}
for (int i = 2 * K - 2; i < N; i++) {
for (int j = i; j < N; j++)
if (S[j] == '(') {
ans.emplace_back(i, j);
reverse(S.begin() + i, S.begin() + j + 1);
break;
}
}
cout << ans.size() << "\n";
for (auto& [l, r] : ans) cout << l + 1 << " " << r + 1 << "\n";
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110, S = int(1e4 + 10);
int a[N];
int dp[S][N];
bool pre[S][N];
int process[S][N];
int cnt[N];
int test;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
sort(a, a + n);
dp[0][0] = -1LL;
for (int i = 0; i < n; i++) {
for (int k = 1; k <= n; k++) {
for (int sum = 0; sum < S; sum++) {
if (sum - a[i] >= 0) {
if (!dp[sum - a[i]][k - 1]) {
continue;
}
if (process[sum - a[i]][k - 1] == i + 1) {
continue;
}
if (!dp[sum][k]) {
process[sum][k] = i + 1;
}
bool change = pre[sum][k];
if (pre[sum - a[i]][k - 1]) {
pre[sum][k] = true;
}
if (dp[sum][k] == 0LL || dp[sum][k] == a[i]) {
dp[sum][k] = a[i];
} else {
pre[sum][k] = true;
}
if (dp[sum - a[i]][k - 1] != -1LL) {
if (dp[sum - a[i]][k - 1] != a[i]) {
pre[sum][k] = true;
}
}
}
}
}
}
int best = 1;
int diff = 0;
int val = 0;
for (int i = 1; i < N; i++) {
if (cnt[i]) {
diff++;
val = max(cnt[i], val);
}
for (int k = 1; k <= cnt[i]; k++) {
int sum = i * k;
if (!pre[sum][k]) {
best = max(best, k);
} else {
}
}
}
if (diff == 2) {
if (val == best) {
best = n;
}
}
printf("%d\n", best);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using lol = long long int;
const int N = 300;
const lol modcon = 1000000007, mod = 998244353, hval = 31, inf = 2 * 1e9 + 5;
const double eps = 1e-7;
void recur(vector<int> &z, vector<int> &v, int q) {
if (q == 0) return;
int k = distance(v.begin(), max_element(v.begin(), v.begin() + q));
z.push_back(q - k);
recur(z, v, k);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(2 * n);
for (int i = 0; i < 2 * n; i++) {
cin >> v[i];
}
vector<int> z;
int k = distance(v.begin(), max_element(v.begin(), v.begin() + 2 * n));
z.push_back(2 * n - k);
recur(z, v, k);
int sum = 0;
int cnt = (int)z.size();
for (int i = 0; i < cnt; i++) {
sum += z[i];
}
if (sum % 2 != 0) {
cout << "NO"
<< "\n";
continue;
}
sum /= 2;
bool dp[sum + 1][cnt + 1];
for (int i = 0; i <= cnt; i++) {
dp[0][i] = 1;
}
for (int i = 1; i <= sum; i++) {
dp[i][0] = 0;
}
for (int i = 1; i <= sum; i++) {
for (int j = 1; j <= cnt; j++) {
dp[i][j] = dp[i][j - 1];
if (i >= z[j - 1]) dp[i][j] = (dp[i][j] || dp[i - z[j - 1]][j - 1]);
}
}
if (dp[sum][cnt] == 1) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
long long A;
string B, C;
string to_roman(int x) {
string I[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
string X[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
string C[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
string M[] = {"", "M", "MM", "MMM"};
string re;
re = I[x % 10] + re;
x /= 10;
re = X[x % 10] + re;
x /= 10;
re = C[x % 10] + re;
x /= 10;
re = M[x % 10] + re;
return re;
}
long long to_dec(string s, long long base) {
long long re = 0;
for (int a = 0; a < ((int)((s).size()) - 1 + 1); ++a)
if ('0' <= s[a] && s[a] <= '9')
re = re * base + (long long)(s[a] - '0');
else if ('A' <= s[a] && s[a] <= 'Z')
re = re * base + (long long)(s[a] - 'A' + 10);
return re;
}
string to_to(long long num, long long base) {
string re;
while (num > 0) {
long long rem = num % base;
if (rem <= 9)
re = string(1, '0' + rem) + re;
else
re = string(1, 'A' + rem - 10) + re;
num /= base;
}
if (re == "") re = "0";
return re;
}
int main() {
ios_base::sync_with_stdio(0);
while (cin >> A >> B >> C) {
long long z = to_dec(C, A);
if (B == "R")
cout << to_roman(z) << endl;
else {
int ba;
sscanf(B.c_str(), "%d", &ba);
cout << to_to(z, ba) << endl;
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
inline int n_black(int n, int m) { return (n * m + 1) >> 1; }
int main(void) {
int n, m, x;
std::cin >> n >> m >> x;
x = (x << 1) - 1;
if (std::min(n, m) < x) {
std::cout << "0\n";
} else {
int answer = n_black(n - x + 1, m - x + 1);
if (std::min(n, m) >= x + 2) {
answer -= n_black(n - x - 1, m - x - 1);
}
std::cout << answer << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Query {
int id, l, r, solution;
Query() {}
void olvas(int i) {
id = i;
cin >> l >> r;
l--;
r--;
}
const bool operator<(Query masik) const { return r < masik.r; }
};
const int maxn = 500005;
vector<Query> task;
int n, q;
int a[maxn], f[maxn];
int fa[maxn * 8];
map<int, int> ker;
void modosit(int hol, int tol, int ig, int poz, int val) {
if (tol == ig) {
fa[hol] = val;
return;
}
int mid = (tol + ig) / 2;
if (poz <= mid)
modosit(hol * 2, tol, mid, poz, val);
else
modosit(hol * 2 + 1, mid + 1, ig, poz, val);
fa[hol] = min(fa[hol * 2], fa[hol * 2 + 1]);
return;
}
int leker(int hol, int tol, int ig, int from, int to) {
if (from <= tol && ig <= to) {
return fa[hol];
}
if (ig < from || to < tol) {
return 1000000000;
;
}
int mid = (tol + ig) / 2;
return min(leker(hol * 2, tol, mid, from, to),
leker(hol * 2 + 1, mid + 1, ig, from, to));
}
bool kisebb(Query u, Query v) { return u.id < v.id; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cin >> q;
task.resize(q);
for (int i = 0; i < q; i++) {
task[i].olvas(i);
}
for (int i = 0; i < n; i++) {
if (ker.count(a[i]) == 0) {
f[i] = -a[i];
} else {
f[i] = ker[a[i]];
}
ker[a[i]] = i;
}
sort(task.begin(), task.end());
int kesz = -1;
for (int i = 0; i < q; i++) {
while (kesz < task[i].r) {
kesz++;
if (f[kesz] >= 0) {
modosit(1, 0, n - 1, f[kesz], f[kesz]);
}
modosit(1, 0, n - 1, kesz, f[kesz]);
}
int ans = leker(1, 0, n - 1, task[i].l, task[i].r);
if (ans < 0)
ans = -ans;
else if (ans < task[i].l)
ans = a[ans];
else
ans = 0;
task[i].solution = ans;
}
sort(task.begin(), task.end(), kisebb);
for (int i = 0; i < q; i++) {
cout << task[i].solution << '\n';
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxR = 505, kMaxN = 1e5 + 5, kInf = 0x3f3f3f3f;
int r, n, X[kMaxN], Y[kMaxN], T[kMaxN];
int f[kMaxN];
int main() {
scanf("%d %d", &r, &n);
for (int i = 1; i <= n; ++i) {
scanf("%d %d %d", T + i, X + i, Y + i);
}
int res = 0, cur = 0, ans = 0;
fill(f, f + kMaxN, -kInf);
for (int i = 1; i <= n; ++i) {
while (T[i] - T[cur + 1] > 2 * r) {
res = max(res, f[cur + 1]);
++cur;
}
if (abs(X[i] - 1) + abs(Y[i] - 1) <= T[i] - 0) {
f[i] = max(f[i], 1);
}
for (int j = cur + 1; j < i; ++j) {
if (abs(X[i] - X[j]) + abs(Y[i] - Y[j]) <= T[i] - T[j]) {
f[i] = max(f[i], f[j] + 1);
}
}
if (cur > 0) f[i] = max(f[i], res + 1);
ans = max(ans, f[i]);
}
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-16;
const int MOD = 1000000007;
const long long INF = (long long)1e9 * 500;
template <typename T>
vector<T> readVector0(int n) {
vector<T> res(n);
for (int i = 0; i < n; i++) cin >> res[i];
return res;
}
template <typename T>
vector<T> readVector1(int n) {
vector<T> res(n + 1);
for (int i = 1; i <= n; i++) cin >> res[i];
return res;
}
inline long long mod(long long x, long long m = MOD) { return ((x + m) % m); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<long long> a = readVector0<long long>(n);
long long amax = 0;
long long amin = INF;
for (int i = 0; i < n; ++i) {
if (a[i] > amax) amax = a[i];
if (a[i] < amin) amin = a[i];
}
int z = sqrt(amax) + 10;
long long ans = INF;
vector<long long> x;
for (int r = 1; r <= z; ++r) {
int _x = amin / r;
if (_x > 0) {
x.push_back({_x});
}
if (_x > 1 && _x * r == amin) x.push_back({_x - 1});
}
for (int j = 0; j < x.size(); ++j) {
long long res = 0;
bool impossible = false;
for (int i = 0; i < n; ++i) {
long long y = (a[i] / (x[j] + 1));
if (y * (x[j] + 1) < a[i]) y++;
if (y * x[j] > a[i]) {
impossible = true;
break;
}
res += y;
}
if (!impossible && res < ans) ans = res;
}
for (int j = 1; j <= z; ++j) {
long long res = 0;
bool impossible = false;
for (int i = 0; i < n; ++i) {
long long y = (a[i] / (j + 1));
if (y * (j + 1) < a[i]) y++;
if (y * j > a[i]) {
impossible = true;
break;
}
res += y;
}
if (!impossible && res < ans) ans = res;
}
cout << ans;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long int maxN = 1000000000000000000;
long long int res[100001];
long long int n;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t;
t = 1;
while (t--) {
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int r = a[0];
res[0] = a[0];
for (int i = 1; i < n; i++) {
r = gcd(r, a[i]);
res[i] = r;
}
long long int ans = 1;
for (int i = n - 1; i > 0; i--) {
if (i == n - 1) {
ans = (res[i - 1] / gcd(a[i], res[i - 1])) * a[i];
} else {
long long int k = (res[i - 1] / gcd(a[i], res[i - 1])) * a[i];
ans = gcd(ans, k);
}
}
cout << ans << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int total = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
total = total + a[i];
}
int sum = 0;
total = total / 2;
sort(a, a + n);
int c = 0;
for (int i = n - 1; i >= 0; i--) {
sum = sum + a[i];
c++;
if (sum > total) break;
}
cout << c;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[3][6];
int sum[1000];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 6; j++) {
scanf("%d", &a[i][j]);
sum[a[i][j]]++;
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
int xx = (0 + k) % n;
int yy = (1 + k) % n;
int x = a[xx][i];
int y = a[yy][j];
sum[x * 10 + y]++;
sum[y * 10 + x]++;
}
}
}
for (int k = 0; k < 6; k++) {
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
int x = a[0][k];
int y = a[1][i];
int z = a[2][j];
sum[z * 100 + x * 10 + y]++;
sum[z * 100 + y * 10 + x]++;
sum[x * 100 + y * 10 + z]++;
sum[x * 100 + z * 10 + y]++;
sum[y * 100 + z * 10 + x]++;
sum[y * 100 + x * 10 + z]++;
}
}
}
for (int i = 1; i < 1000; i++) {
if (!sum[i]) {
printf("%d\n", i - 1);
break;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Q {
int l, r, id;
bool operator<(const Q& b) const { return r < b.r; }
} b[200010];
struct node {
int mi, num, lazy, sum;
long long ans;
} tree[200010 << 2];
long long res[200010];
int n, q, top1, top2, a[200010], stk1[200010], stk2[200010];
void up(int i) {
tree[i].mi = min(tree[i * 2].mi, tree[i * 2 + 1].mi);
tree[i].num = 0;
if (tree[i * 2].mi == tree[i].mi) tree[i].num += tree[i * 2].num;
if (tree[i * 2 + 1].mi == tree[i].mi) tree[i].num += tree[i * 2 + 1].num;
tree[i].ans = tree[i * 2].ans + tree[i * 2 + 1].ans;
}
void addlazy(int j, int num) {
tree[j].lazy += num;
tree[j].mi += num;
}
void addsum(int i, int num) {
tree[i].sum += num;
tree[i].ans += 1ll * tree[i].num * num;
}
void down(int i) {
if (tree[i].lazy) {
addlazy(i * 2, tree[i].lazy);
addlazy(i * 2 + 1, tree[i].lazy);
tree[i].lazy = 0;
}
if (tree[i].sum) {
if (tree[i * 2].mi == tree[i].mi) addsum(i * 2, tree[i].sum);
if (tree[i * 2 + 1].mi == tree[i].mi) addsum(i * 2 + 1, tree[i].sum);
tree[i].sum = 0;
}
}
void build(int l, int r, int i) {
tree[i].mi = l;
tree[i].num = 1;
if (l == r) return;
build(l, (l + r) / 2, i * 2);
build((l + r) / 2 + 1, r, i * 2 + 1);
}
void update(int L, int R, int w, int l, int r, int i) {
if (L <= l && r <= R) {
addlazy(i, w);
return;
}
down(i);
if (L <= (l + r) / 2) update(L, R, w, l, (l + r) / 2, i * 2);
if (R > (l + r) / 2) update(L, R, w, (l + r) / 2 + 1, r, i * 2 + 1);
up(i);
}
long long query(int L, int R, int l, int r, int i) {
if (L <= l && r <= R) return tree[i].ans;
down(i);
long long res = 0;
if (L <= (l + r) / 2) res += query(L, R, l, (l + r) / 2, i * 2);
if (R > (l + r) / 2) res += query(L, R, (l + r) / 2 + 1, r, i * 2 + 1);
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &b[i].l, &b[i].r);
b[i].id = i;
}
sort(b + 1, b + 1 + q);
build(1, n, 1);
for (int i = 1, j = 1; i <= n; i++) {
addlazy(1, -1);
while (top1 && a[i] > a[stk1[top1]]) {
update(stk1[top1 - 1] + 1, stk1[top1], a[i] - a[stk1[top1]], 1, n, 1);
top1--;
}
stk1[++top1] = i;
while (top2 && a[i] < a[stk2[top2]]) {
update(stk2[top2 - 1] + 1, stk2[top2], a[stk2[top2]] - a[i], 1, n, 1);
top2--;
}
stk2[++top2] = i;
addsum(1, 1);
while (j <= q && b[j].r == i)
res[b[j].id] = query(b[j].l, b[j].r, 1, n, 1), j++;
}
for (int i = 1; i <= q; i++) printf("%lld\n", res[i]);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int lld;
typedef pair<int,int> pi;
typedef pair<lld,lld> pl;
typedef pair<int,lld> pil;
typedef pair<lld,int> pli;
typedef vector<int> vit;
typedef vector<vit> vitt;
typedef vector<lld> vlt;
typedef vector<vlt> vltt;
typedef vector<pi> vpit;
typedef vector<vpit> vpitt;
typedef long double ld;
#define x first
#define y second
#define pb push_back
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define mk(a,b) make_pair(a,b)
bool isrange(int y,int x,int n,int m){
if(0<=y&&y<n&&0<=x&&x<m) return true;
return false;
}
int dy[4] = {1,0,-1,0},dx[4]={0,1,0,-1},ddy[8] = {1,0,-1,0,1,1,-1,-1},ddx[8] = {0,1,0,-1,1,-1,1,-1};
const lld mod = 998244353;
const int MAX = 303030;
string arr[MAX];
lld two[MAX];
void solve(int tc){
int n,m;
cin >> n >> m;
int tot = 0;
for(int p=0;p<n;p++){
cin >> arr[p];
for(int q=0;q<m;q++){
if(arr[p][q]=='o') tot++;
}
}
if(tot<2){
cout << "0\n";
}else{
lld ans = 0;
two[0] = 1;
for(int e=1;e<MAX;e++) two[e] = (two[e-1]*2)%mod;
for(int e=0;e<n;e++){
int xx = 0;
for(int p=0;p<m;p++){
if(arr[e][p]=='o'){
xx++;
}else{
for(int q=2;q<=xx;q++){
lld vv = (1ll*(xx-q+1)*two[tot-q])%mod;
if(q%2==0){
ans = (ans+vv)%mod;
}else{
ans = (ans-vv)%mod;
ans = (ans%mod+mod)%mod;
}
}
xx = 0;
}
}
for(int q=2;q<=xx;q++){
lld vv = (1ll*(xx-q+1)*two[tot-q])%mod;
if(q%2==0){
ans = (ans+vv)%mod;
}else{
ans = (ans-vv)%mod;
ans = (ans%mod+mod)%mod;
}
}
}
for(int p=0;p<m;p++){
int xx = 0;
for(int e=0;e<n;e++){
if(arr[e][p]=='o'){
xx++;
}else{
for(int q=2;q<=xx;q++){
lld vv = (1ll*(xx-q+1)*two[tot-q])%mod;
if(q%2==0){
ans = (ans+vv)%mod;
}else{
ans = (ans-vv)%mod;
ans = (ans%mod+mod)%mod;
}
}
xx = 0;
}
}
for(int q=2;q<=xx;q++){
lld vv = (1ll*(xx-q+1)*two[tot-q])%mod;
if(q%2==0){
ans = (ans+vv)%mod;
}else{
ans = (ans-vv)%mod;
ans = (ans%mod+mod)%mod;
}
}
}
cout << ans << "\n";
}
}
int main(void){
ios_base :: sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tc = 1;
/*
cin >> tc;
*/
for(int test_number=1;test_number<=tc;test_number++){
solve(test_number);
}
return 0;
} | 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
getline(cin, s);
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') s.erase(i, 1);
}
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 65 && s[i] <= 90) s[i] += 32;
}
for (int i = 0; i < s.size(); i++) {
if (s[s.size() - 2] == 'a' || s[s.size() - 2] == 'e' ||
s[s.size() - 2] == 'i' || s[s.size() - 2] == 'o' ||
s[s.size() - 2] == 'u' || s[s.size() - 2] == 'y') {
cout << "YES";
return 0;
} else {
cout << "NO";
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = 1000000007;
long long qp(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
struct mint {
int n;
mint(int n_ = 0) : n(n_) {}
};
mint operator+(mint a, mint b) { return (a.n += b.n) >= mod ? a.n - mod : a.n; }
mint operator-(mint a, mint b) { return (a.n -= b.n) < 0 ? a.n + mod : a.n; }
mint operator*(mint a, mint b) { return 1LL * a.n * b.n % mod; }
mint &operator+=(mint &a, mint b) { return a = a + b; }
mint &operator-=(mint &a, mint b) { return a = a - b; }
mint &operator*=(mint &a, mint b) { return a = a * b; }
ostream &operator<<(ostream &o, mint a) { return o << a.n; }
template <class T>
inline bool scan(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void out(T x) {
if (x > 9) out(x / 10);
putchar(x % 10 + '0');
}
int n;
mint a[maxn];
mint dp[maxn];
mint pre[maxn * 10];
mint val[maxn * 10];
void add(int pos, mint x) {
while (pos < maxn * 10) {
val[pos] += x;
pos += pos & -pos;
}
}
mint query(int pos) {
mint res = 0;
while (pos > 0) {
res += val[pos];
pos -= pos & -pos;
}
return res;
}
int main() {
scan(n);
for (int i = 1; i <= n; ++i) scan(a[i].n);
mint res = 0;
for (int i = 1; i <= n; ++i) {
mint tmp = query(a[i].n) * a[i] + a[i];
dp[i] = tmp - pre[a[i].n];
pre[a[i].n] = tmp;
res += dp[i];
add(a[i].n, dp[i]);
}
out(res.n);
putchar('\n');
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int dp[N][N][N], n, m, k, p, c[N][N], fac[N];
inline int dfs(int i, int d, int k) {
if (i < 0) return 0;
if (~dp[i][d][k]) return dp[i][d][k];
if (d == m) return 0;
int &g = dp[i][d][k];
g = 0;
for (int j = 0; j <= (i - 1) / 2; ++j)
for (int x = 0; x <= j && x <= k; ++x)
g = (g + ((j != i - 1 - j) ? 2ll : 1ll) * dfs(j, d + 1, x) *
dfs(i - 1 - j, d + 1, k - x) % p * c[i - 1][j]) %
p;
return g;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &p);
fac[0] = 1;
for (int i = c[0][0] = 1; i <= n; ++i) {
c[i][0] = 1;
fac[i] = 1ll * fac[i - 1] * i % p;
for (int j = 1; j <= i; ++j) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % p;
}
memset(dp, -1, sizeof(dp));
for (int i = 0; i <= n; ++i) dp[0][i][0] = 1;
for (int i = 1; i <= n; ++i) dp[i][m][1] = fac[i];
printf("%d\n", dfs(n, 1, k));
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int a[2005][2005];
int b[10005];
char res[2000055];
int main() {
int ch, x;
int n;
int cnt = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
if (a[i][i] == 1) {
cnt++;
}
}
for (int i = 0; i < 10; i++) {
}
for (int i = 0; i < 10; i++) {
}
cnt %= 2;
int q;
int p = 0;
scanf("%d", &q);
while (q--) {
scanf("%d", &ch);
if (ch == 1 || ch == 2) {
scanf("%d", &x);
cnt++;
cnt %= 2;
} else {
cnt = cnt % 2;
res[p++] = cnt + '0';
res[p] = '\0';
}
}
for (int i = 0; i < 10; i++) {
}
printf("%s\n", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long ans[54322];
int main() {
ans[3] = 1, ans[4] = 4;
int n;
long long c = 1;
for (long long i = 5; i <= 54321; i++) {
ans[i] = i * (c + 1) - c;
c++;
}
while (~scanf("%d", &n)) {
cout << ans[n] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2005, MOD = 998244353;
int f[MAXN][MAXN], mat[MAXN][MAXN], g[MAXN], h[MAXN], fac[MAXN], n;
int cnt[MAXN], bit1[MAXN], bit2[MAXN];
void add(int *bit, int x) {
for (; x <= n; x += x & -x) ++bit[x];
}
int sum(int *bit, int x) {
int res = 0;
for (; x; x -= x & -x) res += bit[x];
return res;
}
int main() {
scanf("%d", &n);
g[0] = fac[0] = h[0] = f[0][0] = 1;
for (int i = 1; i <= n; i++) {
f[i][i] = g[i] =
(i == 1 ? 0 : (long long)(i - 1) * (g[i - 1] + g[i - 2])) % MOD;
f[i][0] = fac[i] = (long long)fac[i - 1] * i % MOD;
for (int j = 1; j < i; j++)
f[i][j] =
((long long)j * f[i - 1][j - 1] + (long long)(i - j) * f[i - 1][j]) %
MOD;
}
for (int i = 1; i <= n; i++) h[i] = (long long)h[i - 1] * g[n] % MOD;
int res = 0;
for (int j = 1; j <= n; j++) {
scanf("%d", &mat[1][j]);
res = ((long long)fac[n - j] * (mat[1][j] - sum(bit1, mat[1][j]) - 1) %
MOD * h[n - 1] +
res) %
MOD;
add(bit1, mat[1][j]);
}
for (int i = 2; i <= n; i++) {
memset(cnt, 0, sizeof(cnt)), memset(bit1, 0, sizeof(bit1)),
memset(bit2, 0, sizeof(bit2));
int rep = n;
for (int j = 1; j <= n; j++) {
scanf("%d", &mat[i][j]);
if (++cnt[mat[i - 1][j]] == 1) add(bit2, mat[i - 1][j]), --rep;
int a = mat[i][j] - sum(bit2, mat[i][j] - 1) - 1,
b = mat[i][j] - 1 - sum(bit1, mat[i][j]) - a;
if (cnt[mat[i - 1][j]] == 1 && mat[i - 1][j] < mat[i][j]) --b;
res = (((rep ? (long long)f[n - j][rep - 1] * a : 0) +
(long long)f[n - j][rep] * b) %
MOD * h[n - i] +
res) %
MOD;
if (++cnt[mat[i][j]] == 1) add(bit2, mat[i][j]), --rep;
add(bit1, mat[i][j]);
}
}
printf("%d\n", res);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float l, d, v, g, r, t1, t2, temp;
cin >> l >> d >> v >> g >> r;
t1 = d / v;
int count = 0;
while (t1 >= g + r) {
t1 -= (g + r);
count++;
}
if (t1 < g) {
t1 = t1 + count * (g + r);
} else {
t1 = (count + 1) * (g + r);
}
t2 = (l - d) / v;
cout << setprecision(8) << t1 + t2;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int pref[1 << 20];
int a[50013], b[50013];
int dp[50013];
int l[5013], r[5013];
int ans[5013];
int main() {
pref[0] = 0;
for (int i = 1; i < (1 << 20); i++) pref[i] = pref[i - 1] ^ i;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i] = pref[a[i]];
}
for (int i = 0; i < m; i++) scanf("%d%d", &l[i], &r[i]);
for (int i = 1; i <= n; i++) {
dp[i] = a[i];
for (int j = i + 1; j <= n; j++) {
dp[j] = max(dp[j - 1], b[i] ^ b[j] ^ min(a[i], a[j]));
}
for (int j = 0; j < m; j++) {
if (l[j] <= i && i <= r[j]) ans[j] = max(ans[j], dp[r[j]]);
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
const int N = 1e5 + 5;
vector<int> g[N];
int vis[N][2], pre[N][2], col[N];
bool cyc(int u) {
col[u] = 1;
for (int v : g[u]) {
if (col[v] == 1) {
return 1;
}
if (col[v] == 0) {
if (cyc(v)) return 1;
}
}
col[u] = 2;
return 0;
}
void dfs(int u, int pr, int p) {
vis[u][p] = 1;
pre[u][p] = pr;
for (int v : g[u])
if (not vis[v][p ^ 1]) {
dfs(v, u, p ^ 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, s;
cin >> n >> m;
for (int i = 1, e, x; i <= n; i++) {
cin >> e;
while (e--) {
cin >> x;
g[i].push_back(x);
}
}
cin >> s;
dfs(s, 0, 0);
for (int i = 1; i <= n; i++) {
if (g[i].size() == 0 and vis[i][1]) {
cout << "Win"
<< "\n";
vector<int> ans;
int u = i, p = 1;
while (u) {
ans.push_back(u);
u = pre[u][p];
p ^= 1;
}
reverse(ans.begin(), ans.end());
for (int x : ans) {
cout << x << " ";
}
return 0;
}
}
cout << (cyc(s) ? "Draw" : "Lose") << "\n";
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n;
string wzor;
string s;
bool check() {
int j = 0;
for (int i = 0; i < wzor.size(); i++) {
if (wzor[i] == 'H') {
if (s[j] != 'H') return 0;
j++;
} else {
if (n - wzor.size() < j) return 0;
for (int u = 0; u < wzor.size(); u++) {
if (wzor[u] != s[j]) return 0;
j++;
}
}
if ((j == s.size() && i + 1 < wzor.size())) return 0;
}
if (j < s.size()) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
int licz = 0;
n = s.size();
for (int i = 0; i < s.size(); i++) {
licz += (s[i] == 'Q');
}
int pom = sqrt(licz);
if (licz == 0 && n % 2 == 0) {
cout << "Yes";
return 0;
} else if (licz == 0 || pom * pom != licz) {
cout << "No";
return 0;
}
int poc = 0;
while (s[poc] == 'H') poc++;
int kon = n - 1;
while (s[kon] == 'H') kon--;
if (poc % 2 == 0 && (n - 1 - kon) % 2 == 0) {
int ter = 0;
for (int i = 0; i < poc / 2; i++) wzor += 'H';
for (int i = poc; ter < pom; i++) {
ter += (s[i] == 'Q');
wzor += s[i];
}
for (int i = kon; i < kon + (n - 1 - kon) / 2; i++) wzor += 'H';
if (check()) {
cout << "Yes";
return 0;
}
}
cout << "No";
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int MAX_N = 1000005;
const int Mod = 1000000007;
int N, Ones, Twos, DP[MAX_N], Solution;
void Solve() {
Solution = 1;
for (; Twos > 0; --Twos, --N) Solution = (1LL * Solution * N) % Mod;
DP[0] = 1;
for (int i = 1; i <= N; ++i) {
DP[i] = DP[i - 1];
if (i >= 2) DP[i] = (DP[i] + 1LL * (i - 1) * DP[i - 2]) % Mod;
}
Solution = (1LL * Solution * DP[N]) % Mod;
}
void Read() {
cin >> N;
for (int i = 1; i <= N; ++i) {
int capacity;
cin >> capacity;
if (capacity == 1)
++Ones;
else
++Twos;
}
}
void Print() { cout << Solution << "\n"; }
int main() {
Read();
Solve();
Print();
return 0;
}
| 15 |
#include <bits/stdc++.h>
long long INF = 1e9 + 7;
long double eps = 1e-9;
using namespace std;
bool comp(int a, int b) { return a > b; }
class compare {
public:
template <class T>
bool operator()(T a, T b) {
return comp(a, b);
}
};
char *string_to_char(string temp) {
char *ans = new char[temp.length() + 1];
strcpy(ans, temp.c_str());
return ans;
}
long long max_string_length = 1024;
string spget() {
char temp[max_string_length];
gets(temp);
string ans = temp;
return ans;
}
void spget(string &ans) {
char temp[max_string_length];
gets(temp);
ans = temp;
}
string ssget() {
char temp[max_string_length];
scanf("%s", &temp);
string ans = temp;
return ans;
}
void ssget(string &ans) {
char temp[max_string_length];
scanf("%s", &temp);
ans = temp;
}
void ssput(string temp) {
char *ttmp = string_to_char(temp);
printf("%s", ttmp);
}
unsigned long long gcd(unsigned long long a, unsigned long long b) {
if (a < b) swap(a, b);
long long t = a * b;
while (b > 0) {
a %= b;
if (a < b) swap(a, b);
}
t /= a;
return a;
}
int main() {
long long n;
cin >> n;
vector<long long> a(n);
vector<long long> ans(n + 1, INF);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
a[i]--;
}
queue<long long> q1, q2;
ans[0] = 0;
q1.push(0);
long long gg = 0;
while (q1.size() > 0) {
long long temp = q1.front();
q1.pop();
if (ans[temp] == gg) {
if (temp + 1 < n && ans[temp + 1] > gg + 1) {
q2.push(temp + 1);
ans[temp + 1] = ans[temp] + 1;
}
if (temp - 1 >= 0 && ans[temp - 1] > gg + 1) {
q2.push(temp - 1);
ans[temp - 1] = ans[temp] + 1;
}
if (ans[a[temp]] > gg + 1) {
q2.push(a[temp]);
ans[a[temp]] = ans[temp] + 1;
}
}
if (q1.empty()) {
swap(q1, q2);
gg++;
}
}
for (long long i = 0; i < n; i++) printf("%I64d ", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long n) {
long long k = ceil(sqrt(n));
for (long long i = k; i; i--) {
if (n % i == 0) {
return i;
}
}
}
long long e(long long n) {
long long k = ceil(cbrt(n)), mn = 1e12, x, x1;
for (long long i = k; i; i--) {
if (n % i == 0) {
x = f(n / i);
x1 = n / (i * x);
mn = min(mn, (i + 1) * (x + 2) * (x1 + 2));
}
}
return mn - n;
}
int main() {
long long n, s;
cin >> n;
cout << e(n) << " ";
cout << (n + 1) * 3 * 3 - n;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2222;
struct node {
int val, cnt1, cnt2;
node(int e, int x, int y) {
val = e;
cnt1 = x;
cnt2 = y;
}
node() { val = cnt1 = cnt2 = 0; }
};
node operator+(const node &x, const node &y) {
node sum;
sum.cnt1 = x.cnt1 + y.cnt1;
sum.cnt2 = x.cnt2 + y.cnt2;
sum.val = max(x.val + y.cnt1, x.cnt2 + y.val);
return sum;
}
int n, a[N];
int f1[N], f2[N];
node T[4 * N];
void build(int p, int l, int r) {
if (l > r) return;
if (l == r) {
node tmp;
if (a[l] == 1) {
tmp.val = 1;
tmp.cnt1 = 1;
tmp.cnt2 = 0;
} else {
tmp.val = 1;
tmp.cnt1 = 0;
tmp.cnt2 = 1;
}
T[p] = tmp;
return;
}
int mid = (l + r) / 2;
build(2 * p, l, mid);
build(2 * p + 1, mid + 1, r);
T[p] = T[2 * p] + T[2 * p + 1];
}
node get(int p, int l, int r, int i, int j) {
if (i > r || j < l) {
node tmp;
return tmp;
}
if (l >= i && r <= j) {
return T[p];
}
int mid = (l + r) / 2;
return get(2 * p, l, mid, i, j) + get(2 * p + 1, mid + 1, r, i, j);
}
int main(int argc, char const *argv[]) {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
f1[i] = f1[i - 1];
if (a[i] == 1) {
f1[i] = f1[i - 1] + 1;
}
}
for (int i = n; i; --i) {
f2[i] = f2[i + 1];
if (a[i] == 2) {
f2[i] = f2[i + 1] + 1;
}
}
build(1, 1, n);
int get_max = 0;
for (int i = 1; i <= n; ++i) {
get_max = max(get_max, f1[i] + f2[i]);
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; ++j) {
int res = f1[i - 1] + f2[j + 1] + get(1, 1, n, i, j).val;
get_max = max(get_max, res);
}
}
cout << get_max;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int A[109], B[109];
for (int i = 0; i < n; i++) cin >> A[i];
sort(A, A + n);
int l = 0, i;
for (i = n - 1; i >= 0; i--) {
l++;
if (l == k) break;
}
cout << A[i];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long arr[2000000] = {0}, vis[300000] = {0};
vector<long long> vec[300000];
string str;
long long mod = 1000000007;
map<long long, long long> mp;
long long fac(long long n) {
long long i, prod = 1;
for (i = 1; i <= n; i++) prod = ((i % mod) * (prod % mod)) % mod;
return prod;
}
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;
}
long long gcd(long long a, long long b) {
if (a == 0 || b == 0) return 0;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
void dfs(long long v) {
long long i;
vis[v] = 1;
for (i = 0; i < vec[v].size(); i++)
if (vis[vec[v][i]] == 0) dfs(vec[v][i]);
return;
}
int main() {
long long x, y, i, j, k, n, m, num, temp, fn,
cnt1 = 0, cnt0 = 0, d, l, r, flag = 0, sum1 = 0, sum2 = 0, a, b, len1 = 0,
t;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> num;
vec[i].push_back(num);
}
for (i = 1; i <= n; i++) {
cin >> temp;
if (temp == 1) cnt1++;
}
if (cnt1 % 2 == 0) sum1++;
dfs(1);
for (i = 2; i <= n; i++) {
if (vis[i] == 0) {
sum2++;
dfs(i);
}
}
if (sum2 > 0) sum2++;
printf("%lld\n", sum2 + sum1);
return 0;
}
| 9 |
// Problem: B. Replace and Keep Sorted
// Contest: Codeforces - Codeforces Round #701 (Div. 2)
// URL: https://codeforces.com/contest/1485/problem/B
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ll long long
#define mod 1000000007
// templates
#define all(v) v.begin(), v.end()
#define F first
#define S second
#define sz(x) (int)x.size()
#define po(x, y) fixed << setprecision(y) << x
#define ss(s) scanf(" %[^\n]%*c", s)
#define sc(n) scanf("%d", &n)
#define sl(n) scanf("%lld", &n)
#define ps(s) printf("%s\n", s)
#define pr(n) printf("%d\n", n)
#define pl(n) printf("%lld\n", n)
#define prs(n) printf("%d ", n)
#define pls(n) printf("%lld ", n)
using namespace std;
const ll inf = (ll)1e15 + 10;
const int N = (int)1e6 + 10;
void solve() {
int n, q;
ll k;
sc(n), sc(q), sl(k);
vector<ll> a(n + 2, 0);
for (int i = 1; i <= n; i++) {
sl(a[i]);
}
a[n + 1] = k;
vector<ll> pre(n + 2, 0);
for (int i = 1; i <= n; i++) {
pre[i] += a[i] - a[i - 1] - 1;
pre[i] += a[i + 1] - a[i] - 1;
pre[i] += pre[i - 1];
}
while (q--) {
int l, r;
sc(l), sc(r);
if (l == r) {
pl(k - 1);
continue;
}
if (r - l == 1) {
ll ans = a[l] - 1 + 2 * (a[r] - a[l] - 1) + k - a[r];
pl(ans);
continue;
}
ll ans = pre[r - 1] - pre[l];
ans += a[l] - 1 + (a[l + 1] - a[l] - 1);
ans += a[r] - a[r - 1] - 1;
ans += k - a[r];
pl(ans);
}
}
int main() {
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
int t = 1;
// sc(t);
while (t--) {
solve();
}
// cerr << (float)clock() / CLOCKS_PER_SEC * 1000 << " ms" << endl;
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m;
bool visited[1000000] = {false};
long long int BFS(long long int n, long long int m) {
queue<pair<long long int, long long int> > q1;
q1.push(make_pair(0, n));
visited[n] = true;
while (q1.size() > 0) {
long long int x = q1.front().second;
long long int y = q1.front().first;
long long int scenario1 = x * 2;
long long int scenario2 = x - 1;
if (x == m) {
return y;
}
q1.pop();
if (visited[scenario1] == false && scenario1 < 100000) {
q1.push(make_pair(y + 1, scenario1));
visited[scenario1] = true;
}
if (scenario2 >= 0) {
if (visited[scenario2] == false) {
q1.push(make_pair(y + 1, scenario2));
visited[scenario2] = true;
}
}
}
return 100000;
}
int32_t main() {
cin >> n >> m;
cout << BFS(n, m);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool like(int a, int b) { return a <= b && 2 * a >= b; }
int main() {
int v1, v2, v3, vm;
cin >> v1 >> v2 >> v3 >> vm;
v1 *= 2;
v2 *= 2;
v3 = max(v3, 2 * min(v3, vm));
if (!like(vm, v1) && !like(vm, v2) && like(vm, v3)) {
printf("%d\n%d\n%d\n", v1, v2, v3);
} else
printf("-1\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
int n, k, nxt[maxn], to[maxn], hd[maxn], tot = 0, f[maxn], d[maxn];
std::set<pair<int, int>> S;
inline void add(int u, int v) {
nxt[++tot] = hd[u];
to[tot] = v;
hd[u] = tot;
return;
}
inline void dfs(int u, int fa, int dst) {
d[u] = dst;
f[u] = fa;
for (register int i = hd[u]; i; i = nxt[i]) {
int nx = to[i];
if (nx == f[u]) continue;
dfs(nx, u, dst + 1);
}
return;
}
int main() {
scanf("%d", &n);
int u, v;
for (register int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 0, 0);
for (register int i = 1; i <= n; ++i)
if (d[i] > 2) S.insert(make_pair(-d[i], i));
long long ans = 0;
while (!S.empty()) {
v = S.begin()->second;
v = f[v];
ans++;
auto it = S.find(make_pair(-d[v], v));
if (it != S.end()) S.erase(it);
for (register int i = hd[v]; i; i = nxt[i]) {
int nx = to[i];
auto it = S.find(make_pair(-d[nx], nx));
if (it != S.end()) S.erase(it);
}
}
cout << ans;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int p[200010], fa[200010], dep[200010], a[200010];
int id[200010], num[200010], tot;
vector<int> son[200010];
struct Node {
int x;
Node operator=(const int &X) {
x = X;
return *this;
}
bool operator<(const Node &X) const { return dep[x] < dep[X.x]; }
} f[400010][19];
int lg[400010], L[200010], R[200010];
void dfs(int x) {
L[x] = id[x] = ++tot, f[tot][0] = x;
for (int i = 0; i < son[x].size(); i++) {
int v = son[x][i];
dfs(v);
f[++tot][0] = x;
}
R[x] = tot;
}
void get_f(int n) {
n *= 2;
for (int j = 1; j < 19; j++) {
for (int i = 1; i <= n; i++) {
if (i + (1 << j) - 1 > n) break;
f[i][j] = min(f[i][j - 1], f[i + (1 << j - 1)][j - 1]);
}
}
for (int i = 2; i <= n; i++) {
lg[i] = lg[i >> 1] + 1;
}
}
int get_min(int l, int r) {
if (l > r) swap(l, r);
int k = lg[r - l + 1];
return min(f[l][k], f[r - (1 << k) + 1][k]).x;
}
int get_lca(int x, int y) { return get_min(id[x], id[y]); }
bool is_anc(int x, int y) { return L[x] < id[y] && id[y] < R[x]; }
int down(int x, int y) {
return x == -1 || y == -1 ? x == -1 ? y : x : dep[x] > dep[y] ? x : y;
}
bool is_sub(int x, int y) { return is_anc(x, y) || is_anc(y, x); }
struct Chain {
int empty, alive;
int lca, x, y;
Chain() { empty = 1, alive = 1, lca = -1, x = y = -1; }
Chain(const int &X) { *this = X; }
Chain operator=(const int &X) {
lca = X, empty = 0, alive = 1, x = y = -1;
return *this;
}
Chain operator+(const Chain &A) const {
if (empty || A.empty) return empty ? A : *this;
Chain res;
res.empty = 0;
if (!alive || !A.alive || (lca != A.lca && y != -1 && A.y != -1)) {
res.alive = 0;
return res;
}
res.lca = get_lca(lca, A.lca);
if (res.lca != lca && res.lca != A.lca) {
if (y != -1 || A.y != -1) {
res.alive = 0;
return res;
}
res.x = x == -1 ? lca : x;
res.y = A.x == -1 ? A.lca : A.x;
return res;
}
if (y == -1 && A.y == -1) {
if (lca != res.lca) {
res.x = x == -1 ? lca : x;
if (A.x == -1) return res;
int tmp = get_lca(res.x, A.x);
if (tmp == res.lca)
res.y = A.x;
else if (tmp == res.x || tmp == A.x)
res.x = down(res.x, A.x);
else {
res.alive = 0;
return res;
}
return res;
}
if (A.lca != res.lca) {
res.x = A.x == -1 ? A.lca : A.x;
if (x == -1) return res;
int tmp = get_lca(res.x, x);
if (tmp == res.lca)
res.y = x;
else if (tmp == res.x || tmp == x)
res.x = down(res.x, x);
else {
res.alive = 0;
return res;
}
return res;
}
if (x != -1 && A.x != -1) {
if (is_sub(x, A.x))
res.x = down(x, A.x);
else
res.x = x, res.y = A.x;
} else if (x != -1)
res.x = x;
else if (A.x != -1)
res.x = A.x;
return res;
}
if (res.lca == lca && lca == A.lca) {
res.x = x, res.y = y;
if (A.x != -1) {
if (res.x == -1 || is_sub(res.x, A.x))
res.x = down(res.x, A.x);
else if (res.y == -1 || is_sub(res.y, A.x))
res.y = down(res.y, A.x);
else {
res.alive = 0;
return res;
}
}
if (A.y != -1) {
if (res.x == -1 || is_sub(res.x, A.y))
res.x = down(res.x, A.y);
else if (res.y == -1 || is_sub(res.y, A.y))
res.y = down(res.y, A.y);
else {
res.alive = 0;
return res;
}
}
return res;
}
if ((res.lca == lca && y == -1) || (res.lca == A.lca && A.y == -1)) {
res.alive = 0;
return res;
}
if (y == -1) {
res.x = A.x, res.y = A.y;
int tmp = x == -1 ? lca : x;
if (is_sub(tmp, res.x))
res.x = down(res.x, tmp);
else if (is_sub(tmp, res.y))
res.y = down(res.y, tmp);
else {
res.alive = 0;
return res;
}
return res;
}
assert(A.y == -1);
res.x = x, res.y = y;
int tmp = A.x == -1 ? A.lca : A.x;
if (is_sub(tmp, res.x))
res.x = down(res.x, tmp);
else if (is_sub(tmp, res.y))
res.y = down(res.y, tmp);
else {
res.alive = 0;
return res;
}
return res;
}
};
struct Segment_tree {
Chain T[800010];
void Build(int now, int l, int r) {
if (l == r) {
T[now] = a[l];
return;
}
int mid = l + r >> 1;
Build(now << 1, l, mid), Build(now << 1 | 1, mid + 1, r);
T[now] = T[now << 1] + T[now << 1 | 1];
}
void Update(int now, int l, int r, int pos, int x) {
if (l == r) {
T[now] = x;
return;
}
int mid = l + r >> 1;
if (pos <= mid)
Update(now << 1, l, mid, pos, x);
else
Update(now << 1 | 1, mid + 1, r, pos, x);
T[now] = T[now << 1] + T[now << 1 | 1];
}
int Query(int now, int l, int r, Chain tmp) {
if (l == r) return (tmp + T[now]).alive ? l : -1;
int mid = l + r >> 1;
if ((tmp + T[now << 1]).alive)
return max(mid, Query(now << 1 | 1, mid + 1, r, tmp + T[now << 1]));
return Query(now << 1, l, mid, tmp);
}
} seg;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
a[p[i]] = i;
}
for (int i = 2; i <= n; i++) {
scanf("%d", &fa[i]);
son[fa[i]].push_back(i);
dep[i] = dep[fa[i]] + 1;
}
dfs(1), get_f(n), seg.Build(1, 0, n - 1);
int q;
scanf("%d", &q);
while (q--) {
int op, x, y;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &x, &y);
swap(p[x], p[y]);
a[p[x]] = x, a[p[y]] = y;
seg.Update(1, 0, n - 1, p[x], x);
seg.Update(1, 0, n - 1, p[y], y);
} else
printf("%d\n", seg.Query(1, 0, n - 1, Chain()) + 1);
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int u = 0, l = 0, d = 0;
string s;
cin >> s;
for (int i = 0; i < int(s.size()); i++) {
if (s[i] > 96 && s[i] < 123) u = 1;
if (s[i] > 64 && s[i] < 91) l = 1;
if (s[i] > 47 && s[i] < 58) d = 1;
}
if (int(s.size()) > 4 && u && l && d)
cout << "Correct";
else
cout << "Too weak";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
long long n, T, ans;
long long t[N], pre[N], p[N];
long long fac[N], inv[N];
long long qpow(long long a, long long b) {
long long ret = 1;
for (; b; b >>= 1) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
}
return ret;
}
void prework(int n) {
fac[0] = inv[0] = inv[1] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
for (long long i = 2; i <= n; i++)
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (long long i = 2; i <= n; i++) inv[i] = inv[i] * inv[i - 1] % mod;
}
long long C(long long n, long long m) {
return fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int main() {
cin >> n >> T;
prework(n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &t[i]);
pre[i] = pre[i - 1] + t[i];
}
t[++n] = T + 1, pre[n] = pre[n - 1] + t[n];
for (long long i = 0; i <= n - 1; i++) {
if (pre[i] > T) break;
if (pre[i + 1] + i + 1 <= T) continue;
long long pw = qpow(qpow(2, i + 1), mod - 2);
long long l = max(0ll, T - pre[i + 1] + 1), r = min(T - pre[i], i);
for (long long k = l; k <= r; k++)
(ans += 1ll * i * C(i, k) % mod * pw % mod) %= mod;
l = max(0ll, T - pre[i + 1]), r = min(T - pre[i], i);
for (long long k = l; k <= r; k++)
(ans += 1ll * i * C(i, k) % mod * pw % mod) %= mod;
}
printf("%lld\n", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
vector<int> p[1010];
vector<int> q[1010];
int a[1010], b[1010], vis[1010];
int s[1010], n, m, w;
void dfs(int x, int y) {
int i, j, k;
k = p[x].size();
for (i = 0; i < k; i++) {
j = p[x][i];
if (vis[j] == 0) {
vis[j] = y;
dfs(j, y);
}
}
}
int main() {
int i, j, k, u, v, x, y;
scanf("%d%d%d", &n, &m, &w);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
p[x].push_back(y);
p[y].push_back(x);
}
k = 1;
memset(vis, 0, sizeof(vis));
for (i = 1; i <= n; i++) {
if (vis[i]) continue;
vis[i] = k;
dfs(i, k);
k++;
}
memset(s, 0, sizeof(s));
for (i = 1; i <= n; i++) q[vis[i]].push_back(i);
int t = k;
for (i = 1; i < t; i++) {
for (j = w; j >= 0; j--) {
u = 0;
v = 0;
for (k = 0; k < q[i].size(); k++) {
u = u + a[q[i][k]];
v = v + b[q[i][k]];
if (j >= a[q[i][k]]) s[j] = max(s[j], s[j - a[q[i][k]]] + b[q[i][k]]);
}
if (j >= u) s[j] = max(s[j], s[j - u] + v);
}
}
printf("%d\n", s[w]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, c;
cin >> n >> m;
long long x[n];
c = 0;
for (i = 0; i < n; i++) {
cin >> x[i];
if (x[i] > m) c++;
}
cout << c + n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int cnt = 0;
long long p[maxn], k[maxn];
int main() {
long long n, b;
cin >> n >> b;
long long s = sqrt(b);
for (long long i = 2; i <= s; i++) {
if (b % i == 0) {
p[cnt] = i;
while (b && b % i == 0) k[cnt]++, b /= i;
cnt++;
}
}
if (b > 1) p[cnt] = b, k[cnt++] = 1;
long long ans = 0x3f3f3f3f3f3f3f3f;
for (int i = 0; i < cnt; i++) {
s = 0;
long long t = n;
while (t) s += t /= p[i];
ans = min(ans, s / k[i]);
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
long long in[maxn];
long long out[maxn];
long long gx[maxn];
vector<int> e[maxn];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
if (x < y) swap(x, y);
out[x]++;
in[y]++;
e[y].push_back(x);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
gx[i] = out[i] * in[i];
ans += gx[i];
}
printf("%lld\n", ans);
int q;
scanf("%d", &q);
int kas = 0;
while (++kas <= q) {
int v;
scanf("%d", &v);
out[v] += in[v];
in[v] = 0;
ans -= gx[v];
gx[v] = 0;
for (auto nxt : e[v]) {
ans -= gx[nxt];
in[nxt]++;
out[nxt]--;
gx[nxt] = in[nxt] * out[nxt];
ans += gx[nxt];
e[nxt].push_back(v);
}
e[v].clear();
printf("%lld\n", ans);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int cx[51], cy[51];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
vector<pair<int, int> > v;
int n;
cin >> n;
for (int i = 0; i != 4 * n + 1; ++i) {
int x, y;
cin >> x >> y;
cx[x]++;
cy[y]++;
v.push_back({x, y});
}
int x1 = 51, x2 = -1;
for (int i = 0; i <= 50; ++i)
if (cx[i] >= n) x1 = min(x1, i), x2 = max(x2, i);
int y1 = 51, y2 = -1;
for (int i = 0; i <= 50; ++i)
if (cy[i] >= n) y1 = min(y1, i), y2 = max(y2, i);
for (pair<int, int> p : v) {
if (((p.first == x1 || p.first == x2) &&
(p.second >= y1 && p.second <= y2)) ||
((p.second == y1 || p.second == y2) &&
(p.first >= x1 && p.first <= x2)))
continue;
else
cout << p.first << ' ' << p.second << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int grundy(int heap_size, int k) {
if (k % 2 == 0) {
if (heap_size <= 2)
return heap_size;
else
return 1 - (heap_size % 2);
} else {
if (heap_size < 4)
return heap_size % 2;
else if (heap_size >= 4 && heap_size % 2 != 0)
return 0;
else if (heap_size == 4)
return 2;
else
return grundy(heap_size / 2, k) == 1 ? 2 : 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
int res = 0;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
res ^= grundy(a, k);
}
cout << ((res == 0) ? "Nicky" : "Kevin") << "\n";
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4005;
int n, dp[N][80][80][2], a[N];
int calc(int l, int diff, int prev, bool turn) {
int r = n - l + 1 - diff;
if (turn) diff += 80;
int &ret = dp[l][diff][prev][turn];
if (turn) diff -= 80;
if (ret != -1) return ret;
if (r - l + 1 < prev) return 0;
if (!turn) {
ret = -1e9;
ret = max(ret, calc(l + prev, diff - prev, prev, turn ^ 1) +
a[l + prev - 1] - a[l - 1]);
if (r - l + 1 > prev)
ret = max(ret, calc(l + prev + 1, diff - prev - 1, prev + 1, turn ^ 1) +
a[l + prev] - a[l - 1]);
} else {
ret = 1e9;
ret = min(ret, calc(l, diff + prev, prev, turn ^ 1) + a[r - prev] - a[r]);
if (r - l + 1 > prev)
ret = min(ret, calc(l, diff + prev + 1, prev + 1, turn ^ 1) +
a[r - prev - 1] - a[r]);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i], a[i] += a[i - 1];
memset(dp, -1, sizeof dp);
cout << calc(1, 0, 1, 0);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
string s[] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
int main() {
int n;
string str;
bool A[8];
for (int i = 0; i < 8; ++i) {
A[i] = true;
}
cin >> n;
cin >> str;
if (n == 8) {
cout << s[0] << endl;
return 0;
} else if (n == 6) {
cout << s[3] << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
if (str[i] == '.') {
continue;
}
for (int j = 0; j < 8; ++j) {
if (A[j] && str[i] != s[j][i]) {
A[j] = false;
}
}
}
for (int i = 1; i < 8; ++i) {
if (A[i]) {
cout << s[i] << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void eraseDups(vector<int>& a) { a.erase(unique(a.begin(), a.end()), a.end()); }
int strToInt(string& a) {
stringstream x(a);
int b;
x >> b;
return b;
}
int bitCnt(int a) {
bitset<64> b(a);
return b.count();
}
int bitCnt(string a) {
bitset<64> b(a);
return b.count();
}
vector<int> readVI(int n) {
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
return a;
}
vector<vector<int> > readVVI(int n, int m) {
vector<vector<int> > a(n, vector<int>(m));
for (int i = 0; i < n; i++) a[i] = readVI(m);
return a;
}
vector<long long> readVLL(long long n) {
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
return a;
}
vector<vector<long long> > readVVLL(long long n, long long m) {
vector<vector<long long> > a(n, vector<long long>(m));
for (int i = 0; i < n; i++) a[i] = readVLL(m);
return a;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void print(vector<int>& a) {
for (auto el : a) {
cout << el << ' ';
}
cout << '\n';
}
void print(vector<pair<int, int> >& a) {
for (auto el : a) {
cout << el.first << ',' << el.second << ' ';
}
cout << '\n';
}
void print(vector<int>& a, int n) {
int cnt = 0;
for (auto el : a) {
if (cnt++ == n) break;
cout << el << ' ';
}
cout << '\n';
}
void print(vector<vector<int> >& a) {
for (auto el : a) {
print(el);
}
}
const int MOD = 1e9 + 7;
const int MOD1 = 998244353;
const int INF = 2e9;
const long long INFF = INT64_MAX;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
int n, m, q;
const int N = 3e5 + 5;
vector<vector<int> > paths(N);
vector<pair<int, int> > edges(N);
vector<int> deg(N);
void mst() {
vector<pair<int, int> > res;
vector<int> par(n + 5);
for (int i = 0; i <= n; i++) par[i] = i;
function<int(int)> find = [&](int a) {
if (par[a] == a) return a;
return par[a] = find(par[a]);
};
auto merge = [&](int a, int b) {
a = find(a), b = find(b);
if (a == b) return 0;
par[b] = a;
return 1;
};
for (auto& [a, b] : edges) {
if (merge(a, b)) {
paths[a].push_back(b);
paths[b].push_back(a);
}
}
}
void go() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
edges.push_back({a, b});
}
mst();
vector<pair<int, int> > queries;
vector<int> par(n + 5), lvl(n + 5);
queue<pair<int, int> > bfs;
lvl[1] = 0;
bfs.push({1, 0});
while (!bfs.empty()) {
int pos, Par;
tie(pos, Par) = bfs.front();
bfs.pop();
for (auto el : paths[pos]) {
if (el == Par) continue;
lvl[el] = lvl[pos] + 1;
par[el] = pos;
bfs.push({el, pos});
}
}
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
deg[a] ^= 1;
deg[b] ^= 1;
queries.push_back({a, b});
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += deg[i];
if (ans == 0) {
cout << "YES\n";
auto answer = [&](int a, int b) {
vector<int> pre, suf;
while (a != b) {
int A = lvl[a], B = lvl[b];
if (A == B) {
pre.push_back(a);
suf.push_back(b);
a = par[a];
b = par[b];
} else if (A > B) {
pre.push_back(a);
a = par[a];
} else {
suf.push_back(b);
b = par[b];
}
}
pre.push_back(a);
while (!suf.empty()) {
pre.push_back(suf.back());
suf.pop_back();
}
cout << pre.size() << '\n';
print(pre);
};
for (auto& [a, b] : queries) answer(a, b);
return;
}
cout << "NO\n";
cout << ans / 2 << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) go();
return (0 - 0);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
string s[100005];
int p[100005];
auto cmp = [](int x, int y) { return s[x] > s[y]; };
priority_queue<int, vector<int>, decltype(cmp)> q(cmp);
string ss;
int k;
int main() {
cin >> ss >> k;
int len = ss.size();
for (int i = 0; i < len; ++i) {
s[i] = ss[i];
p[i] = i;
q.push(i);
}
for (int i = 1; i < k; ++i) {
int t = q.top();
q.pop();
if (p[t] != len - 1) {
++p[t];
s[t] += ss[p[t]];
q.push(t);
}
if (q.size() == 0) {
cout << "No such line." << endl;
return 0;
}
}
int ans = q.top();
cout << s[ans] << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int Query(vector<int> s, vector<int> t, int v) {
cout << s.size() << endl;
for (int i : s) cout << i << ' ';
cout << endl << t.size() << endl;
for (int i : t) cout << i << ' ';
cout << endl << v << endl;
cin >> v;
return v;
}
vector<int> Cut(vector<int> a, int l) {
vector<int> b(l + 1);
for (int i = 0; i <= l; ++i) {
b[i] = a[i];
}
return b;
}
int main() {
int n;
cin >> n;
vector<int> all(n - 1);
for (int i = 2; i <= n; ++i) {
all[i - 2] = i;
}
vector<int> size(n + 1, n), id(n - 1);
for (int i = 2; i <= n; ++i) {
size[i] = Query(vector<int>{1}, all, i);
id[i - 2] = i;
}
vector<vector<int> > g(n + 1);
sort(id.begin(), id.end(), [&](int x, int y) { return size[x] < size[y]; });
vector<int> now(1, id[0]);
for (int i = 1; i < n - 1; ++i) {
int x = id[i];
for (;;) {
int l = 0, r = now.size();
for (int md; l < r;) {
md = (l + r) >> 1;
if (Query(vector<int>{1}, Cut(now, md), x)) {
r = md;
} else {
l = md + 1;
}
}
if (l == now.size()) {
break;
}
g[x].push_back(now[l]);
now.erase(now.begin() + l);
}
now.push_back(x);
}
cout << "ANSWER" << endl;
for (int j : now) {
cout << 1 << ' ' << j << endl;
}
for (int i = 2; i <= n; ++i) {
for (int j : g[i]) {
cout << i << ' ' << j << endl;
}
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
long long d[100003], sum[403], shelf[403];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
long long x;
int t;
cin >> t;
for (int j = 1; j <= t; j++) {
cin >> x;
sum[j] = ((j == 1) ? 0LL : sum[j - 1]) + x;
}
memset(shelf, 0LL, sizeof(shelf));
for (int l = 0; l <= t; l++)
for (int r = 0; r <= t; r++)
shelf[l + r] = max(shelf[l + r], sum[l] + sum[t] - sum[t - r]);
for (int k = m; k >= 0; k--)
for (int j = min(k, t); j > 0; j--) d[k] = max(d[k], d[k - j] + shelf[j]);
}
cout << d[m] << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 4e5 + 5, inf = 0x3f3f3f3f;
map<int, int> tipo;
map<int, int> pos;
int inicioIdx[ms], sz[ms];
int seg[2 * ms], lazy[2 * ms];
int ciclo[ms], posicaoNoCiclo[ms];
int n;
int h;
int *t, *d;
void calc(int p, int k) {
if (d[p] == -1)
t[p] = max(t[p << 1], t[p << 1 | 1]);
else
t[p] = d[p];
}
void apply(int p, int value, int k) {
t[p] = value;
if (p < n) d[p] = value;
}
void build(int l, int r) {
int k = 2;
for (l += n, r += n - 1; l > 1; k <<= 1) {
l >>= 1, r >>= 1;
for (int i = r; i >= l; --i) calc(i, k);
}
}
void push(int l, int r) {
int s = h, k = 1 << (h - 1);
for (l += n, r += n - 1; s > 0; --s, k >>= 1)
for (int i = l >> s; i <= r >> s; ++i)
if (d[i] != -1) {
apply(i << 1, d[i], k);
apply(i << 1 | 1, d[i], k);
d[i] = -1;
}
}
void modify(int l, int r, int value) {
if (value == -1) return;
r++;
push(l, l + 1);
push(r - 1, r);
int l0 = l, r0 = r, k = 1;
for (l += n, r += n; l < r; l >>= 1, r >>= 1, k <<= 1) {
if (l & 1) apply(l++, value, k);
if (r & 1) apply(--r, value, k);
}
build(l0, l0 + 1);
build(r0 - 1, r0);
}
int query(int l) {
int r = l + 1;
push(l, l + 1);
push(r - 1, r);
int res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = max(res, t[l++]);
if (r & 1) res = max(res, t[--r]);
}
return res;
}
void updateGlobal(int i) {
d = lazy + inicioIdx[i];
t = seg + inicioIdx[i];
n = sz[i];
h = sizeof(int) * 8 - __builtin_clz(n);
}
int buscaBinaria(int t, int p) {
int n = sz[t];
updateGlobal(t);
int l = p + 1, r = p + n;
while (r - l > 1) {
int m = (l + r) / 2;
int check = query(m % n);
if (check == p)
r = m;
else
l = m;
}
int check = query(l % n);
if (check == p) {
return l % n;
} else {
return r % n;
}
}
int main() {
cin.tie(0);
cin.sync_with_stdio(false);
int h, m, n, ans = 0;
cin >> h >> m >> n;
memset(lazy, -1, sizeof lazy);
int zzz = 0;
int ciclosAteAgora = 0;
int cnt = 0;
for (int i = 0; i < h; i++) {
int pos = i;
if (!ciclo[pos]) ++ciclosAteAgora;
for (int j = 0; ciclo[pos] == 0; j++) {
ciclo[pos] = ciclosAteAgora;
posicaoNoCiclo[pos] = j;
sz[ciclosAteAgora]++;
cnt++;
pos = (pos + m) % h;
}
}
for (int i = 1; i <= ciclosAteAgora; i++) {
int qnt = sz[i];
inicioIdx[i] = zzz;
updateGlobal(i);
for (int j = 0; j < qnt; j++) modify(j, j, j);
zzz += 2 * qnt;
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s == "+") {
int hash, id;
cin >> id >> hash;
int t = ciclo[hash], p = posicaoNoCiclo[hash];
updateGlobal(t);
int posicaoInserir = query(p);
pos[id] = posicaoInserir;
tipo[id] = t;
ans += (posicaoInserir + sz[t] - p) % sz[t];
int apos = query((posicaoInserir + 1) % sz[t]);
if (apos == posicaoInserir) {
modify(0, sz[t] - 1, inf);
continue;
}
int inicioUpdate = buscaBinaria(t, posicaoInserir);
if (inicioUpdate > posicaoInserir) {
modify(inicioUpdate, sz[t] - 1, apos);
modify(0, posicaoInserir, apos);
} else {
modify(inicioUpdate, posicaoInserir, apos);
}
} else {
int id;
cin >> id;
int t = tipo[id], p = pos[id];
updateGlobal(t);
int posicaoApos = query(p);
if (posicaoApos == inf) {
modify(0, sz[t] - 1, p);
continue;
}
int inicioUpdate = buscaBinaria(t, posicaoApos);
if (inicioUpdate > p) {
modify(inicioUpdate, sz[t] - 1, p);
modify(0, p, p);
} else {
modify(inicioUpdate, p, p);
}
}
}
cout << ans << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool comp(unsigned long long x, unsigned long long y) { return x > y; }
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long mod = 1000000000 + 7;
void solveA() {
int n;
cin >> n;
vector<int> a(5, 0), b(5, 0);
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp;
a[tmp - 1]++;
;
}
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp;
b[tmp - 1]++;
}
int changes = 0, res = 0;
bool can = true;
for (int i = 0; i < 5; i++) {
if ((a[i] + b[i]) % 2 == 1) can = false;
res += abs(a[i] - (a[i] + b[i]) / 2);
}
if (can)
cout << res / 2 << endl;
else
cout << -1 << endl;
}
void solveB() {
string n;
int k;
cin >> n >> k;
int len = n.length();
if (k >= len) {
cout << len - 1 << endl;
return;
}
int res = 0;
string s = n;
for (int i = len - 1; i >= 0 && k > 0; i--) {
if (n[i] != '0') {
res++;
s.erase(i);
} else
k--;
}
bool gd = false;
for (int i = 0; i < s.length(); i++)
if (s[i] != '0') gd = true;
if (gd)
cout << res << endl;
else
cout << len - 1 << endl;
}
int main() {
solveB();
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
template <class T>
inline void gmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline void gmin(T &a, T b) {
if (b < a) a = b;
}
using namespace std;
const int N = 2e5 + 10, M = 2e6 + 10, Z = 1e9 + 7, maxint = 2147483647,
ms1 = 16843009, ms31 = 522133279, ms63 = 1061109567,
ms127 = 2139062143;
const double PI = acos(-1.0), eps = 1e-8;
void fre() {
freopen("/Users/luras/Desktop/in.txt", "r", stdin);
freopen("/Users/luras/Desktop/out.txt", "w", stdout);
}
const int INF = 1e9;
int casenum, casei;
int n, t[N], ans, s, val[N];
set<pair<int, int> > ret;
vector<int> pos;
bool valid(int x) {
if (x % 2 == 0) {
return (x == n - 1 || t[x] < t[x + 1]) && (x == 0 || t[x] < t[x - 1]);
} else {
return (x == n - 1 || t[x] > t[x + 1]) && (x == 0 || t[x] > t[x - 1]);
}
}
void upd(int x) {
if (x < 0 || x >= n) return;
s -= val[x];
val[x] = valid(x);
s += val[x];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &t[i]);
for (int i = 0; i < n; i++) {
val[i] = valid(i);
if (!val[i]) pos.push_back(i);
s += val[i];
}
if (pos.size() >= 10) {
puts("0");
return 0;
}
for (auto u : pos) {
for (int v = 0; v < n; v++) {
swap(t[u], t[v]);
upd(u - 1);
upd(u);
upd(u + 1);
upd(v - 1);
upd(v);
upd(v + 1);
if (s == n) ret.insert(make_pair(min(u, v), max(u, v)));
swap(t[u], t[v]);
upd(u - 1);
upd(u);
upd(u + 1);
upd(v - 1);
upd(v);
upd(v + 1);
}
}
printf("%d\n", ret.size());
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
int pod[27];
int main() {
long long n;
int cnt = 0;
string s;
cin >> n;
cin >> s;
if (s.size() > 26) {
cout << -1;
return 0;
}
for (int i = 0; i < s.size(); i++) {
pod[int(s[i] - 'a')]++;
}
for (int i = 0; i < 26; i++) {
while (pod[i] > 1) {
cnt++;
pod[i]--;
}
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int arr[100010];
long long ans = 0;
long long hun = 0, cop, total;
int main() {
scanf("%d%d", &n, &k);
cop = k;
total = n * 100;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
hun += arr[i];
ans += (arr[i] / 10);
arr[i] %= 10;
}
sort(arr, arr + n, greater<int>());
for (int i = 0; i < n; i++) {
if (k - (10 - arr[i]) >= 0) {
ans++;
k -= (10 - arr[i]);
}
}
total -= (hun + cop - k);
k = min(total, k);
ans += (k / 10);
cout << ans << endl;
return 0;
}
| 6 |
// Exported by Exporter.exe
// Included from g.cpp
// Compile flags -Wall -Wextra -Wshadow -D_GLIBCXX_ASSERTIONS -DDEBUG -ggdb3 -fmax-errors=2
#include <bits/stdc++.h>
using namespace std;
#define PB push_back
#define F first
#define S second
#define MP make_pair
#define MTP make_tuple
typedef long long int ll;
constexpr int kN = int(1E5 + 10);
constexpr int kSq3N = 2500;
constexpr int kSq = 320;
// constexpr int kMod = 998244353;
constexpr int kInf = 0x3f3f3f3f;
// constexpr ll kInf = 0x3f3f3f3f3f3f3f3f;
// constexpr double kPi = acos(-1);
// constexpr double kEps = 1E-9;
template <typename T> T ABS(T n) {return n >= 0 ? n : -n;}
// Included from C:\Users\ianli\Desktop\CP\template\Various\Fast_IO.cpp
static inline char Get_Raw_Char() {
static char buf[1 << 16], *p = buf, *end = buf;
if (p == end) {
if ((end = buf + fread(buf, 1, 1 << 16, stdin)) == buf) return '\0';
p = buf;
}
return *p++;
}
static inline int Get_Digit() {
char c = Get_Raw_Char();
while (!isdigit(c)) c = Get_Raw_Char();
return int(c - '0');
}
static inline int Get_PInt() {
char c = Get_Raw_Char();
int ret;
while (!isdigit(c)) c = Get_Raw_Char();
ret = int(c - '0');
while (isdigit(c = Get_Raw_Char())) ret = ret * 10 + int(c - '0');
return ret;
}
static inline int Get_Int() {
char c = Get_Raw_Char();
bool neg = false;
int ret;
while (!isdigit(c)) {
if (c == '-') neg = true;
c = Get_Raw_Char();
}
ret = int(c - '0');
while (isdigit(c = Get_Raw_Char())) ret = ret * 10 + int(c - '0');
if (neg) return -ret;
return ret;
}
static inline long long int Get_ll() {
char c = Get_Raw_Char();
bool neg = false;
long long int ret;
while (!isdigit(c)) {
if (c == '-') neg = true;
c = Get_Raw_Char();
}
ret = int(c - '0');
while (isdigit(c = Get_Raw_Char())) ret = ret * 10 + int(c - '0');
if (neg) return -ret;
return ret;
}
static inline long long int Get_Pll() {
char c = Get_Raw_Char();
long long int ret;
while (!isdigit(c)) c = Get_Raw_Char();
ret = int(c - '0');
while (isdigit(c = Get_Raw_Char())) ret = ret * 10 + int(c - '0');
return ret;
}
template <typename T> static inline void Read_P(T &n) {
static_assert(is_integral<T>::value);
char c = Get_Raw_Char();
while (!isdigit(c)) c = Get_Raw_Char();
n = int(c - '0');
while (isdigit(c = Get_Raw_Char())) n = n * 10 + int(c - '0');
return ;
}
template <typename T> static inline void Read(T &n) {
static_assert(is_integral<T>::value);
char c = Get_Raw_Char();
bool neg = false;
while (!isdigit(c)) {
if (c == '-') neg = true;
c = Get_Raw_Char();
}
n = int(c - '0');
while (isdigit(c = Get_Raw_Char())) n = n * 10 + int(c - '0');
if (neg) n = -n;
return ;
}
template <typename T> static inline void Read_Digit(T &n) {
static_assert(is_integral<T>::value);
char c = Get_Raw_Char();
while (!isdigit(c)) c = Get_Raw_Char();
n = int(c - '0');
return ;
}
template <typename T, typename... Targs> static inline void Read(T &n, Targs&... Fargs) {
Read(n);
return Read(Fargs...);
}
template <typename T, typename... Targs> static inline void Read_Digit(T &n, Targs&... Fargs) {
Read_Digit(n);
return Read_Digit(Fargs...);
}
template <typename T, typename... Targs> static inline void Read_P(T &n, Targs&... Fargs) {
Read_P(n);
return Read_P(Fargs...);
}
// End of C:\Users\ianli\Desktop\CP\template\Various\Fast_IO.cpp
int ans[kN], type[kN], a[kN], cnt[kN], cntcnt[kSq];
set<int> big;
void Insert(int x) {
if (cnt[x] < kSq) {
cntcnt[cnt[x]++]--;
if (cnt[x] >= kSq) big.insert(x);
else cntcnt[cnt[x]]++;
}
else {
cnt[x]++;
}
return ;
}
void Erase(int x) {
if (cnt[x] < kSq) {
cntcnt[cnt[x]--]--;
cntcnt[cnt[x]]++;
}
else {
cnt[x]--;
if (cnt[x] < kSq) {
big.erase(x);
cntcnt[cnt[x]]++;
}
}
return ;
}
int Cal(int k) {
//printf("cal %d\n", k);
int ans = kInf, sz;
vector<pair<int, int>> vec; // cnt, ppl
for (int i : big) vec.PB(MP(cnt[i], 1));
for (int i = 1; i < kSq; i++) if (cntcnt[i]) vec.PB(MP(i, cntcnt[i]));
sort(vec.begin(), vec.end());
//printf("vec\n");
//for (pair<int, int> i : vec) printf("(%d, %d)\n", i.F, i.S);
sz = int(vec.size());
for (int l = 0, r = 0, now = 0; r < sz; r++) {
now += vec[r].S;
while (l <= r && now - vec[l].S >= k) now -= vec[l++].S;
if (now >= k) ans = min(ans, vec[r].F - vec[l].F);
}
//printf("ans = %d\n", ans);
if (ans == kInf) return -1;
return ans;
}
int main() {
//ios::sync_with_stdio(false);
//cin.tie(0);
//freopen("file_name", "r", stdin);
//freopen("file_name", "w", stdout);
//fstream input, output;
//input.open("file_name", ios::in);
//output.open("file_name", ios::out);
int n, m;
vector<tuple<int, int, int, int, int, int>> querys; // val, l, r, event, k, id
stack<pair<int, int>> events_log;
vector<pair<int, int>> events;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
auto Val = [](int a, int b, int c) -> int {
return ((a / kSq3N) * kSq3N + b / kSq3N) * kSq3N + c / kSq3N;
};
for (int i = 1; i <= m; i++) {
scanf("%d", &type[i]);
if (type[i] == 1) {
int l, r, k;
scanf("%d%d%d", &l, &r, &k);
querys.PB(MTP(Val(l, r, int(events.size())), l, r, int(events.size()), k, i));
}
else {
int p, x;
scanf("%d%d", &p, &x);
events.PB(MP(p, x));
}
}
sort(querys.begin(), querys.end());
memset(ans, 0x3f, sizeof(ans));
int nl = 1, nr = 0;
auto Change = [&](int p, int x) -> void {
//printf("Change(%d, %d)\n", p, x);
//for (int i = 1; i <= n; i++) printf("cnt[%d] = %d\n", i, cnt[i]);
if (nl <= p && p <= nr) {
Erase(a[p]);
Insert(x);
}
//for (int i = 1; i <= n; i++) printf("cnt[%d] = %d\n", i, cnt[i]);
};
for (tuple<int, int, int, int, int, int> query : querys) {
//printf("query = (%d, %d, %d)\n", get<1>(query), get<2>(query), get<3>(query));
while (int(events_log.size()) < get<3>(query)) {
int p = events[int(events_log.size())].F, x = events[int(events_log.size())].S;
Change(p, x);
events_log.push(MP(p, a[p]));
a[p] = x;
}
while (nr < get<2>(query)) Insert(a[++nr]);
while (nl > get<1>(query)) Insert(a[--nl]);
while (int(events_log.size()) > get<3>(query)) {
int p = events_log.top().F, x = events_log.top().S;
events_log.pop();
Change(p, x);
a[p] = x;
}
while (nr > get<2>(query)) Erase(a[nr--]);
while (nl < get<1>(query)) Erase(a[nl++]);
ans[get<5>(query)] = Cal(get<4>(query));
}
for (int i = 1; i <= m; i++) if (type[i] == 1) printf("%d\n", ans[i]);
//input.close();
//output.close();
}
// End of g.cpp
| 23 |
#include <bits/stdc++.h>
using namespace std;
class NumArray {
public:
NumArray(vector<int> &nums) : nums_(nums) {
bit_ = vector<int>(nums_.size() + 1);
for (int i = 1; i < bit_.size(); ++i) {
bit_[i] = nums[i - 1] + bit_[i - 1];
}
for (int i = bit_.size() - 1; i >= 1; --i) {
int last_i = i - lower_bit(i);
bit_[i] -= bit_[last_i];
}
}
void update(int i, int val) {
if (val - nums_[i]) {
add(i, val - nums_[i]);
nums_[i] = val;
}
}
int sumRange(int i, int j) { return sum(j) - sum(i - 1); }
private:
vector<int> &nums_;
vector<int> bit_;
int sum(int i) {
++i;
int sum = 0;
for (; i > 0; i -= lower_bit(i)) {
sum += bit_[i];
}
return sum;
}
void add(int i, int val) {
++i;
for (; i <= nums_.size(); i += lower_bit(i)) {
bit_[i] += val;
}
}
inline int lower_bit(int i) { return i & -i; }
};
int main() {
int n, m, a, b;
cin >> n >> m;
int ml = 1e9;
vector<pair<int, pair<int, int> > > s;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
ml = min(ml, b - a + 1);
s.push_back(pair<int, pair<int, int> >(b - a + 1, pair<int, int>(a, b)));
}
sort(s.begin(), s.end());
int arr[n];
memset(arr, -1, sizeof arr);
int cc = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == -1) {
arr[i] = cc++ % ml;
} else {
cc = 0;
}
}
cout << ml << endl;
for (int i = 0; i < n; i++) {
if (i > 0) cout << " ";
cout << arr[i];
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
long long int x, y;
while (q--) {
scanf("%lld%lld", &x, &y);
long long int c = (cbrt(x * y));
long long int X = x / c, Y = y / c;
if (X * X * Y == x && Y * Y * X == y)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
long long n, x[MAXN], y[MAXN];
vector<long long> adj[MAXN];
long long dx[] = {1, -1, 0, 0};
long long dy[] = {0, 0, -1, 1};
void precalc() {}
bool read() {
if (scanf("%lld", &n) < 1) {
return false;
}
for (long long i = 1; i < n; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
--a;
--b;
adj[a].push_back(b);
adj[b].push_back(a);
}
return true;
}
long long op(long long x) {
if (x == 0) return 1;
if (x == 1) return 0;
if (x == 2) return 3;
return 2;
}
void construct(long long v, long long p, vector<long long> ok, long long jump) {
long long j = 0;
for (long long i = 0; i < ((long long)(adj[v]).size()); i++) {
long long u = adj[v][i];
if (u != p) {
if (!ok[j]) j++;
x[u] = x[v] + jump * dx[j];
y[u] = y[v] + jump * dy[j];
vector<long long> aux;
aux = {1, 1, 1, 1};
aux[op(j)] = 0;
j++;
construct(u, v, aux, jump / 2);
}
}
}
void solve() {
long long c4 = 0, raiz = 0;
for (long long i = 0; i < n; i++) {
if (((long long)(adj[i]).size()) > 4) {
printf("NO\n");
return;
}
}
puts("YES");
x[raiz] = 0;
y[raiz] = 0;
construct(raiz, -1, {1, 1, 1, 1}, (1LL << 32LL));
for (long long i = 0; i < n; i++) {
printf("%lld %lld\n", x[i], y[i]);
}
}
int32_t main() {
precalc();
while (read()) {
solve();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<pair<int, int>> v;
int main() {
ios_base::sync_with_stdio(0), ios::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
;
int n, x, d;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> x >> d;
v.push_back({x, d});
}
for (int i = 0; i <= n - 1; ++i) {
for (int j = 0; j <= n - 1; ++j) {
if (i == j) continue;
if (v[j].first + v[j].second == v[i].first &&
v[i].first + v[i].second == v[j].first)
return cout << "YES"
<< "\n",
0;
}
}
return cout << "NO"
<< "\n",
0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long maxx = 1e15;
template <class T>
istream &operator>>(istream &in, vector<T> &v) {
for (auto &x : v) in >> x;
return in;
}
template <class T>
ostream &operator<<(ostream &out, vector<T> &v) {
for (auto x : v) out << x << ' ';
return out;
}
bool sortbyfir(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first < b.first || (a.first == b.first && a.second < b.second));
}
long long inline power(long long a, long long b, long long p) {
a %= p;
long long ans = 1;
while (b > 0) {
if (b & 1) ans = ans * a % p;
a = a * a % p;
b >>= 1;
}
return ans;
}
long long inv(long long n, long long p) { return power(n, p - 2, p); }
inline vector<long long> allinv(long long n, long long p) {
vector<long long> arr(n);
arr[1] = 1;
for (long long i = (2); i < (n); i += 1) {
arr[i] = (p - (p / i) * arr[p % i] % p) % p;
}
return arr;
}
vector<long long> inline allncr(long long n, long long p) {
vector<long long> nci(n + 1);
nci[0] = 1;
nci[n] = 1;
vector<long long> v = allinv(n, maxx);
for (long long i = (1); i < (n); i += 1) {
nci[i] = (((nci[i - 1] * (n + 1 - i)) % maxx) * v[i]) % maxx;
}
return nci;
}
long long max3(long long a, long long b, long long c) {
return max(max(a, b), c);
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
bool inline isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
void prt(int i) { i ? cout << "YES\n" : cout << "NO\n"; }
long long getSum(long long n) {
long long sum = 0;
while (n != 0) {
sum = sum + n % 10;
n = n / 10;
}
return sum;
}
int main() {
long long test = 1;
while (test--) {
long long x = 0, y = 0;
long long a[100], b[100];
long long c, d;
fflush(stdout);
cout << "? ";
for (long long i = (1); i < (101); i += 1) cout << (i << 7) << " ";
cout << "\n";
fflush(stdout);
cin >> c;
for (long long i = 0; i < 7; i++) {
if (c % 2) y += (long long)pow(2, i);
c /= 2;
}
cout << "? ";
for (long long i = (1); i < (101); i += 1) cout << i << " ";
cout << "\n";
fflush(stdout);
cin >> d;
d >>= 7;
for (long long i = 0; i < 7; i++) {
if (d % 2) y += (long long)pow(2, i + 7);
d /= 2;
}
cout << "! " << y << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int E[411][411];
int V[411];
int bfs(int state) {
memset(V, 0, sizeof(V));
int ans = -1;
queue<pair<int, int> > q;
q.push({1, 0});
while (q.size() > 0) {
pair<int, int> pt = q.front();
q.pop();
int node = pt.first;
int t0 = pt.second + 1;
if (node == n) {
ans = t0 - 1;
}
for (int i = 1; i <= n; i++) {
if (E[node][i] == state && V[i] == 0) {
q.push({i, t0});
V[i] = 1;
}
}
}
return ans;
}
int main(int argc, char const *argv[]) {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
E[a][b] = E[b][a] = 1;
}
cout << bfs(0) * bfs(1) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const long long N = 1200021;
int cntP[N], isP[N];
int main() {
for (int i = 2; i < N; i++)
if (!isP[i])
for (int j = i; j < N; j += i) isP[j] = i;
int n = in(), k = in();
for (int i = 0; i < n; i++) {
int x = in();
while (x > 1) {
int p = isP[x];
int cnt = 0;
while (x % p == 0) {
cnt++;
x /= p;
}
cntP[p] = max(cntP[p], cnt);
}
}
bool ok = 1;
while (k > 1) {
ok &= (cntP[isP[k]] > 0);
cntP[isP[k]]--;
k /= isP[k];
}
cout << (ok ? "Yes\n" : "No\n");
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n == 1) {
puts("2");
} else if (n == 2) {
puts("3");
} else if (n == 3) {
puts("1");
} else if (n == 4) {
puts("2");
} else if (n == 5) {
puts("1");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
int n, a[N];
bool vis[N];
double p[N][N], f[N], g[N], pr[N];
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
n = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) p[i][j] = read() * 1.0 / 100;
for (int i = 1; i <= n; i++) pr[i] = f[i] = 1.0;
vis[n] = 1;
a[1] = n;
for (int i = 2; i <= n; i++) {
double mi = 1e18;
for (int j = 1; j <= n; j++) {
if (vis[j]) continue;
f[j] += g[a[i - 1]] * p[j][a[i - 1]] * pr[j];
pr[j] *= 1.0 - p[j][a[i - 1]];
if ((g[j] = f[j] / (1.0 - pr[j])) < mi) mi = g[j], a[i] = j;
}
vis[a[i]] = 1;
}
printf("%0.10lf", g[1]);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int T, n, tot, du[maxn], vis[maxn], id[maxn];
struct yz {
int y, z, id;
};
struct delta {
int x, y, z;
} a[maxn];
map<int, vector<yz> > mp;
void Swap(int& x, int& y, int& z) {
if (x > y) swap(x, y);
if (y > z) swap(y, z);
if (x > y) swap(x, y);
}
void InsertYz(int x, int y, int z, int id) {
if (mp.find(x) == mp.end())
mp[x] = vector<yz>(1, {y, z, id});
else
mp[x].push_back({y, z, id});
}
struct node {
int val, next;
} G[maxn];
int newNode(int x) {
G[++tot].val = x;
return id[x] = tot;
}
void build(int i, int j, int k) {
int pi = newNode(i), pj = newNode(j), pk = newNode(k);
G[pi].next = pj, G[pj].next = pk, G[pk].next = pi;
}
void InsertNode(int i, int j, int k) {
int pi = id[i], pj = id[j], pk = newNode(k);
if (G[pi].next != pj) swap(pi, pj);
G[pi].next = pk, G[pk].next = pj;
}
int main() {
ios_base::sync_with_stdio(false);
for (cin >> T; T--;) {
cin >> n;
mp.clear();
for (int i = 1; i <= n; i++) du[i] = vis[i] = 0;
int x, y, z, id;
tot = 0;
for (int i = 1; i <= n - 2; i++) {
cin >> x >> y >> z;
Swap(x, y, z);
a[i] = {x, y, z};
InsertYz(x, y, z, i);
InsertYz(y, x, z, i);
InsertYz(z, x, y, i);
du[x]++, du[y]++, du[z]++;
}
queue<int> q;
for (int i = 1; i <= n; i++)
if (du[i] == 1) q.push(i);
vector<int> s;
while (q.size()) {
x = q.front();
q.pop();
for (auto p : mp[x]) {
y = p.y, z = p.z, id = p.id;
if (du[y] && du[z]) break;
}
du[x]--, du[y]--, du[z]--;
s.push_back(id);
if (du[x] + du[y] + du[z] == 0) break;
if (du[y] == 1) q.push(y);
if (du[z] == 1) q.push(z);
}
for (int i = s.size() - 1; i >= 0; i--) {
x = a[s[i]].x, y = a[s[i]].y, z = a[s[i]].z;
if (i + 1 == s.size()) {
build(x, y, z);
vis[x] = vis[y] = vis[z] = 1;
} else {
if (vis[x] == 0)
InsertNode(y, z, x), vis[x] = 1;
else if (vis[y] == 0)
InsertNode(x, z, y), vis[y] = 1;
else
InsertNode(x, y, z), vis[z] = 1;
}
}
int now = 1;
do {
cout << G[now].val;
now = G[now].next;
cout << " \n"[now == 1];
} while (now != 1);
for (int i = 0; i < s.size(); i++) cout << s[i] << " \n"[i + 1 == s.size()];
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, l, r;
cin >> n >> l >> r;
long long idx = 1;
bool p = false;
bool end = false;
for (long long i = 1; i <= n - 1; i++) {
if (idx + 2 * (n - i) < l) {
idx += 2 * (n - i);
continue;
}
long long start = 0;
if (!p) {
start = l - idx;
idx += start;
p = true;
}
for (long long j = start; j < 2 * (n - i); j++) {
if (idx <= r) {
if (j % 2 == 0)
cout << i << " ";
else
cout << i + j / 2 + 1 << " ";
cout << endl;
} else {
end = true;
break;
}
idx++;
}
if (end) break;
}
if (r == n * (n - 1) + 1) cout << "1";
cout << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool check(const vector<int>& arr, const int m, const int k, int p) {
for (int i = m - 1; i >= 0; i -= k) {
p -= arr[i];
if (p < 0) {
return false;
}
}
return true;
}
int main() {
int t;
cin >> t;
vector<int> arr;
while (t--) {
int n, p, k;
cin >> n >> p >> k;
arr.resize(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
sort(arr.begin(), arr.end());
int l = 0, r = n + 1, m;
while (r - l > 1) {
m = (l + r) >> 1;
if (check(arr, m, k, p)) {
l = m;
} else {
r = m;
}
}
cout << l << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
int a[100009];
int main() {
int n;
scanf("%d", &n);
for (int i = int(0); i <= int(n - 1); i++) {
scanf("%d", &a[i]);
}
for (int i = 31; i >= 0; i--) {
int val = (1 << 31) - 1;
for (int j = int(0); j <= int(n - 1); j++) {
if (a[j] & (1 << i)) {
val &= a[j];
}
}
if (val % (1 << i) == 0) {
for (int j = int(0); j <= int(n - 1); j++) {
if (a[j] & (1 << i)) ans.push_back(a[j]);
}
printf("%d\n", ans.size());
for (vector<int>::iterator it = (ans).begin(); it != (ans).end(); it++) {
printf("%d ", *it);
}
printf("\n");
return 0;
}
}
printf("0\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool compare(long long x, long long y) { return x > y; }
long long isprime(long long n) {
if (n == 1)
return 0;
else if (n == 2)
return 1;
else {
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
}
vector<long long> get_prime_factors_less_than(long long n) {
vector<long long> factor;
vector<long long> prime(n, 1);
prime[0] = 0, prime[1] = 0;
for (long long i = 2; i <= n; i++) {
if (prime[i] == 1) {
for (long long j = i * i; j <= n; j = j + i) prime[j] = 0;
factor.push_back(i);
}
}
return factor;
}
vector<long long> retain_index(long long arr[], long long n) {
vector<pair<long long, long long>> vp;
for (long long i = 0; i < n; ++i) {
vp.push_back(make_pair(arr[i], i));
}
sort(vp.begin(), vp.end());
vector<long long> retain;
for (long long i = 0; i < vp.size(); i++) {
long long a = vp[i].second;
retain.push_back(a);
}
return retain;
}
long long power(long long x, long long y) {
if (y == 0) return 1;
long long a = power(x, y / 2);
if (y % 2 == 0)
return a * a;
else
return x * a * a;
}
int main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
long long test, i;
test = 1;
while (test--) {
double n, t;
cin >> n >> t;
double c, l;
set<pair<double, double>> s;
for (long long i = 0; i < n; i++) {
cin >> c >> l;
s.insert({c - (l / 2), c + (l / 2)});
}
long long ct = 0;
for (auto it = s.begin(); it != s.end(); it++) {
auto temp = it;
temp++;
if (temp == s.end()) break;
if (temp->first - it->second == t)
ct = ct + 1;
else if (temp->first - it->second > t)
ct = ct + 2;
}
cout << ct + 2 << endl;
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
v.push_back({a, b});
}
sort(v.begin(), v.end());
int cur = v[0].second;
int ans = 0;
for (int i = 1; i < n; i++) {
if (v[i].second < cur) {
ans++;
}
cur = max(cur, v[i].second);
}
cout << ans << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int d[1 << 16], s[1 << 16];
vector<pair<int, int> > res;
int resn;
vector<int> c;
int main() {
int n;
cin >> n;
for (int(i) = 0; i < (n); ++i) {
int x, y;
cin >> d[i] >> s[i];
}
for (int(i) = 0; i < (n); ++i) {
if (d[i] == 1) c.push_back(i);
}
while (c.size()) {
int k = c.back();
c.pop_back();
if (d[k] == 0) continue;
int id = s[k];
d[id]--;
s[id] = s[id] ^ k;
if (d[id] == 1) c.push_back(id);
res.push_back(make_pair(k, id));
}
cout << res.size() << endl;
for (int(i) = 0; i < (res.size()); ++i)
cout << res[i].first << " " << res[i].second << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 1;
int n;
bool is = true, vis[MAX];
vector<int> arr[MAX];
pair<int, int> ans[MAX], delta[4] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
void dfs(int v, int len, int x, int y, int direction) {
vis[v] = true;
ans[v].first = x;
ans[v].second = y;
int pnt = (direction + 3) % 4;
for (int i = 0; i < arr[v].size(); ++i)
if (!vis[arr[v][i]]) {
dfs(arr[v][i], len >> 1, x + len * delta[pnt % 4].first,
y + len * delta[pnt % 4].second, pnt % 4);
++pnt;
}
if (pnt - (direction + 3) % 4 > int(3 + (v == 1))) is = false;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int from, to;
cin >> from >> to;
arr[from].push_back(to);
arr[to].push_back(from);
}
dfs(1, 1 << n, 0, 0, 0);
if (is) {
cout << "YES\n";
for (int i = 1; i <= n; ++i)
cout << ans[i].first << ' ' << ans[i].second << endl;
} else
cout << "NO\n";
return 0;
}
| 12 |
#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define pii pair <int , int>
#define mp make_pair
#define fs first
#define sc second
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
T f=1;x=0;char s=getchar();
while(s<'0'||s>'9') {if(s=='-') f=-1;s=getchar();}
while(s>='0'&&s<='9') {x=(x<<3)+(x<<1)+(s^'0');s=getchar();}
x *= f;
}
template <typename T>
void write(T x , char s='\n') {
if(!x) {putchar('0');putchar(s);return;}
if(x<0) {putchar('-');x=-x;}
T t = 0 , tmp[25] = {};
while(x) tmp[t ++] = x % 10 , x /= 10;
while(t -- > 0) putchar(tmp[t] + '0');
putchar(s);
}
const LL mod = 1e9 + 7;
LL dp[105][10005] , c[105] , b[105] , n , x , Sum[105] , Sc[105];
int main() {
read(n);
for (int i = 1; i <= n; ++i) read(c[i]) , Sc[i] = Sc[i - 1] + c[i];
for (int i = 1; i < n; ++i) read(b[i]) , b[i] += b[i - 1];
int q;
read(q);
read(x);
Sum[1] = x;
for (int i = 2; i <= n; ++i) Sum[i] = Sum[i - 1] + b[i - 1] + x;
for (int i = 0; i <= Sc[n]; ++i) dp[0][i] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = max(0ll , Sum[i]); j <= Sc[i]; ++j) {
if(j <= c[i]) dp[i][j] = dp[i - 1][j];
else dp[i][j] = (dp[i - 1][j] - dp[i - 1][j - c[i] - 1] + mod) % mod;
}
for (int j = 1; j <= Sc[n]; ++j) dp[i][j] = (dp[i][j] + dp[i][j - 1]) % mod;
}
write(dp[n][Sc[n]]);
return 0;
} | 19 |
#include <bits/stdc++.h>
using namespace std;
int n, sum, a[26 * 2], w[2][26];
bitset<26 * 50000> f[26 * 2][26];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n * 2; ++i) scanf("%d", a + i);
sort(a + 1, a + n * 2 + 1);
w[0][1] = a[1];
w[1][n] = a[2];
f[2][0][0] = 1;
for (int i = 3; i <= n * 2; ++i) {
sum += a[i];
for (int j = 0; j < n; ++j) {
f[i][j] |= f[i - 1][j];
if (j) f[i][j] |= f[i - 1][j - 1] << a[i];
}
}
for (int i = sum / 2; i; --i) {
if (f[n * 2][n - 1][i]) {
int xb1 = n + 1, xb2 = 0;
for (int j = n * 2, u = n - 1, v = i; j > 2; --j) {
if (f[j - 1][u][v]) {
w[1][++xb2] = a[j];
} else {
w[0][--xb1] = a[j];
--u;
v -= a[j];
}
}
break;
}
}
for (int i : {0, 1}) {
for (int j = 1; j <= n; ++j) printf(j == n ? "%d\n" : "%d ", w[i][j]);
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1039714778;
template <typename T>
inline void chmin(T &x, const T &b) {
x = (x < b ? x : b);
}
template <typename T>
inline void chmax(T &x, const T &b) {
x = (x > b ? x : b);
}
int n;
long long a[5005];
int dp[5005];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%lld", a + i);
}
reverse(a, a + n);
memset(dp, 0x3f, sizeof(dp));
int res = inf;
for (int i = 0; i < n; i++) {
chmin(dp[i], i);
for (int j = i + 1; j < n; j++) {
long long t = a[i], rm = j - i - 1;
while (t % 2 == 0 && rm > 0) t /= 2, rm--;
if (((t & 1) && a[j] % t == 0) || ((t % 2 == 0) && a[j] % t == t / 2)) {
chmin(dp[j], dp[i] + (j - i - 1));
}
}
chmin(res, dp[i] + n - i - 1);
}
cout << res << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
float x, y;
cin >> x >> y;
double dis = sqrt(x * x + y * y);
if ((x > 0 && y > 0) || (x < 0 && y < 0)) {
long long a = floor(dis);
if (a == dis) {
cout << "black";
return;
}
if (a % 2)
cout << "white";
else
cout << "black";
} else {
long long a = floor(dis);
if (a == dis) {
cout << "black";
return;
}
if (a % 2 == 0)
cout << "white";
else
cout << "black";
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x[210000], y[210000], tx[210000], a[210000];
bool used[210000];
vector<int> ve[210000];
bool cmp(int a, int b) { return x[a] < x[b]; }
void add(int x, int y) { ve[x].push_back(y); }
void dfs(int k, int c) {
used[k] = true;
a[k] = c;
for (int i = 0; i < (int)ve[k].size(); i++)
if (!used[ve[k][i]]) dfs(ve[k][i], 1 - c);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &x[i + n]);
x[i + n]++;
add(i, i + n);
add(i + n, i);
}
for (int i = 0; i < 2 * n; i++) tx[i] = i;
sort(tx, tx + 2 * n, cmp);
for (int i = 0; i < 2 * n; i += 2)
add(tx[i], tx[i + 1]), add(tx[i + 1], tx[i]);
for (int i = 0; i < 2 * n; i++)
if (!used[i]) dfs(i, 0);
for (int i = 0; i < n; i++) printf("%d ", a[i]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool a[510][510];
int seq[510], seq0[510], seq1[510], _R[510];
int llen[510], L[510], R[510], S[510], T[510];
char s[510];
bool b[510], c[510];
int n;
inline void fail() {
printf("NO\n");
exit(0);
}
void update() {
int i, j;
for (i = 1; i <= n; i++) {
L[i] = n + 1;
R[i] = 0;
for (j = 1; j <= n; j++)
if (a[i][seq[j]]) {
L[i] = min(L[i], j);
R[i] = max(R[i], j);
}
}
}
int getsum(int i, int l, int r) {
int j, s;
s = 0;
for (j = l; j <= r; j++)
if (a[i][seq[j]]) s++;
return s;
}
void split(int l, int x) {
int i;
for (i = l; i <= x - 1; i++) _R[i] = x - 1;
}
int rearrange(int l, int r, int x, bool flag) {
int i, j, k;
j = 0;
k = 0;
for (i = l; i <= r; i++)
if (a[x][seq[i]] == flag) {
j++;
seq0[j] = seq[i];
} else {
k++;
seq1[k] = seq[i];
}
for (i = 1; i <= j; i++) seq[i + l - 1] = seq0[i];
for (i = 1; i <= k; i++) seq[i + l + j - 1] = seq1[i];
return j + l;
}
void work(int l, int r) {
int i, j, s, len, x, y, segnum, l0, r0, tot;
bool flag;
len = -1;
memset(b, false, sizeof(b));
for (i = 1; i <= n; i++) {
s = getsum(i, l, r);
if ((s == 0) || (s == r - l + 1))
b[i] = true;
else if (s > len) {
len = s;
x = i;
}
}
if (len < 0) return;
b[x] = true;
llen[1] = 0;
rearrange(l, r, x, true);
for (i = 1; i <= n; i++)
if (!b[i] && getsum(i, len + l, r)) {
s = getsum(i, l, len + l - 1);
if (s > llen[1]) {
llen[1] = s;
y = i;
}
}
tot = 1;
llen[1] = len - llen[1];
if (llen[1] < len) rearrange(l, l + len - 1, y, false);
while (llen[tot]) {
memset(c, false, sizeof(c));
for (i = 1; i <= n; i++)
if (!b[i] && getsum(i, l, l + llen[tot] - 1)) {
for (j = len + l; j <= r; j++)
if (a[i][seq[j]]) c[j] = true;
}
tot++;
llen[tot] = 0;
for (i = r; i >= l; i--)
if (c[i]) {
llen[tot]++;
seq0[llen[tot]] = seq[i];
} else
seq[i + llen[tot]] = seq[i];
for (i = 1; i <= llen[tot]; i++) seq[i + l - 1] = seq0[i];
len += llen[tot];
}
split(l, l + len);
for (i = tot - 1; i >= 1; i--) llen[i] += llen[i + 1];
for (i = 1; i <= tot - 1; i++) split(l, l + llen[i]);
update();
do {
flag = false;
for (i = 1; i <= n; i++)
if (!b[i] && (R[i] > _R[L[i]])) {
flag = true;
b[i] = true;
segnum = 0;
l0 = n + 1;
r0 = 0;
for (j = l; j <= r; j++)
if ((j == l) || (_R[j] != _R[j - 1])) {
segnum++;
T[segnum] = _R[j] - j + 1;
S[segnum] = getsum(i, j, _R[j]);
if (S[segnum]) {
l0 = min(l0, j);
r0 = max(r0, _R[j]);
}
}
x = l;
for (j = 1; j <= segnum; j++) {
if ((x >= l0) && (_R[x] <= r0)) {
if (x == l0) {
y = rearrange(x, _R[x], i, false);
split(x, y);
} else if (_R[x] == r0) {
y = rearrange(x, _R[x], i, true);
split(x, y);
} else if (S[j] != T[j])
fail();
}
x += T[j];
}
break;
}
update();
} while (flag);
for (i = l; i <= r; i++)
if ((i == l) || (_R[i] != _R[i - 1])) work(i, _R[i]);
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (j = 1; j <= n; j++) a[i][j] = (s[j] == '1');
}
memset(b, false, sizeof(b));
for (i = 1; i <= n; i++) {
seq[i] = i;
_R[i] = n;
}
work(1, n);
printf("YES\n");
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) printf("%d", int(a[i][seq[j]]));
printf("\n");
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int done[1005] = {0};
vector<long long int> graph[1005];
pair<long long int, long long int> dfs(long long int src) {
long long int n = 0, m = 0;
stack<long long int> s;
s.push(src);
while (!s.empty()) {
long long int x = s.top();
s.pop();
if (done[x]) continue;
done[x] = 1;
n++;
for (auto it : graph[x]) {
s.push(it);
m++;
}
}
return {n, m / 2};
}
int main() {
long long int n, m, k, ans = 0;
scanf("%lld", &n);
scanf("%lld", &m);
scanf("%lld", &k);
long long int yo[k];
for (__typeof(k) i = 0 - (0 > k); i != k - (0 > k); i += 1 - 2 * (0 > k))
scanf("%lld", &yo[i]);
for (__typeof(m) i = 0 - (0 > m); i != m - (0 > m); i += 1 - 2 * (0 > m)) {
long long int x, y;
scanf("%lld", &x);
scanf("%lld", &y);
graph[x].push_back(y);
graph[y].push_back(x);
}
long long int maxN = 0;
for (__typeof(k) i = 0 - (0 > k); i != k - (0 > k); i += 1 - 2 * (0 > k)) {
pair<long long int, long long int> info = dfs(yo[i]);
maxN = max(maxN, info.first);
ans += (((info.first * (info.first - 1)) / 2) - info.second);
}
for (__typeof(n + 1) i = 1 - (1 > n + 1); i != n + 1 - (1 > n + 1);
i += 1 - 2 * (1 > n + 1)) {
if (!done[i]) {
pair<long long int, long long int> info = dfs(i);
ans += (info.first * maxN);
ans += (((info.first * (info.first - 1)) / 2) - info.second);
maxN += info.first;
}
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int id;
int v;
} p[1005];
bool comp(node a, node b) { return a.v < b.v; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i].v);
p[i].id = i + 1;
}
sort(p, p + n, comp);
int count = 0;
for (int i = 1; i < n; i++) {
if (p[i].v != p[i - 1].v) count++;
}
if (count == 0)
printf("Exemplary pages.\n");
else if (count == 1) {
if (n == 2) {
if ((p[0].v + p[1].v) % 2 == 0)
printf("%d ml. from cup #%d to cup #%d.\n", (p[1].v - p[0].v) / 2,
p[0].id, p[n - 1].id);
else
printf("Unrecoverable configuration.\n");
} else
printf("Unrecoverable configuration.\n");
} else if (count == 2) {
if (p[0].v != p[1].v && p[n - 1].v != p[n - 2].v) {
if (p[n - 1].v - p[0].v == 2 * (p[1].v - p[0].v))
printf("%d ml. from cup #%d to cup #%d.\n", p[1].v - p[0].v, p[0].id,
p[n - 1].id);
else
printf("Unrecoverable configuration.\n");
} else
printf("Unrecoverable configuration.\n");
} else
printf("Unrecoverable configuration.\n");
return 0;
}
| 5 |