solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int s[100024], v[100024];
int recs[100024], recv[100024];
int main() {
int i, j, k;
int n, m, x, y;
while (scanf("%d %d %d %d", &n, &m, &x, &y) != EOF) {
for (i = 0; i < n; i++) {
scanf("%d", &s[i]);
}
j = 0;
int ans = 0;
for (i = 0; i < m; i++) {
scanf("%d", &v[i]);
while (j < n && s[j] + y < v[i]) j++;
if (j >= n) continue;
if (s[j] + y >= v[i] && s[j] - x <= v[i]) {
recs[ans] = j + 1;
recv[ans] = i + 1;
ans++;
j++;
}
}
printf("%d\n", ans);
for (i = 0; i < ans; i++) {
printf("%d %d\n", recs[i], recv[i]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int a[N];
int n, k, l, r, sum, sumk;
int main() {
cin >> n >> k >> l >> r >> sum >> sumk;
int x = sumk / k, y = sumk % k;
if ((n - k) != 0) {
int xx = (sum - sumk) / (n - k), yy = (sum - sumk) % (n - k);
for (int i = 1; i <= y; i++) cout << x + 1 << ' ';
for (int i = 1; i <= k - y; i++) cout << x << ' ';
for (int i = 1; i <= yy; i++) cout << xx + 1 << ' ';
for (int i = 1; i <= n - k - yy; i++) cout << xx << ' ';
} else {
for (int i = 1; i <= y; i++) cout << x + 1 << ' ';
for (int i = 1; i <= k - y; i++) cout << x << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string a[11];
int n = 10;
int main() {
for (int i = 0; i < n; i++) cin >> a[i];
bool flag = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] != '.') continue;
a[i][j] = 'X';
int how = 0;
for (int k = j; k < n && a[i][k] == 'X'; k++) how++;
for (int k = j - 1; k >= 0 && a[i][k] == 'X'; k--) how++;
if (how >= 5) flag = true;
how = 0;
for (int k = i; k < n && a[k][j] == 'X'; k++) how++;
for (int k = i - 1; k >= 0 && a[k][j] == 'X'; k--) how++;
if (how >= 5) flag = true;
how = 0;
for (int k1 = i, k2 = j; k1 >= 0 && k2 >= 0 && a[k1][k2] == 'X';
k1--, k2--)
how++;
for (int k1 = i + 1, k2 = j + 1; k1 < n && k2 < n && a[k1][k2] == 'X';
k1++, k2++)
how++;
if (how >= 5) flag = true;
how = 0;
for (int k1 = i, k2 = j; k1 >= 0 && k2 < n && a[k1][k2] == 'X';
k1--, k2++)
how++;
for (int k1 = i + 1, k2 = j - 1; k1 < n && k2 >= 0 && a[k1][k2] == 'X';
k1++, k2--)
how++;
if (how >= 5) flag = true;
a[i][j] = '.';
}
}
if (flag)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, M, a, b, v;
int m[410][410];
void bfs() {
v = (m[1][N] + 1) % 2;
queue<int> f;
f.push(1);
int c[410];
bool marc[410];
memset(c, 0, sizeof c);
memset(marc, 0, sizeof marc);
while (!f.empty()) {
int t = f.front();
f.pop();
marc[t] = true;
for (int i = 1; i < N + 1; i++) {
if (m[t][i] == v && !marc[i]) {
c[i] = c[t] + 1;
f.push(i);
marc[i] = true;
}
}
}
if (!marc[N]) c[N] = -1;
printf("%d\n", c[N]);
}
int main() {
memset(m, 0, sizeof m);
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
scanf("%d%d", &a, &b);
m[a][b] = m[b][a] = 1;
}
bfs();
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
void solve() {
long long a, b;
cin >> a >> b;
if (a == b) {
cout << 0 << endl;
return;
} else if (a < b) {
if (abs(a - b) % 2 == 0) {
cout << 2 << endl;
return;
} else
cout << 1 << endl;
return;
} else {
if (abs(a - b) % 2 == 0) {
cout << 1 << endl;
return;
} else
cout << 2 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
for (int it = 1; it <= t; it++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int inf = 1e9;
const double pi = acos(-1.0);
int main() {
int tt;
cin >> tt;
while (tt--) {
int n, l = 0, r = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '1') l = max(l, abs(n - i));
if (s[n - i - 1] == '1') r = max(r, abs(n - i));
}
int ans = max(l, r) != 0 ? max(l, r) * 2 : n;
cout << ans << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t) {
t--;
long long n;
cin >> n;
string s;
cin >> s;
vector<long long> c1(n + 1, 0);
vector<long long> c2(n + 1, 0);
vector<pair<pair<long long, long long>, long long> > v1;
v1.push_back({{0, 0}, 0});
for (long long i = 0; i < n; i++) {
if (s[i] == 'L') {
c1[i + 1] = c1[i] + 1;
c2[i + 1] = c2[i];
} else if (s[i] == 'R') {
c1[i + 1] = c1[i] - 1;
c2[i + 1] = c2[i];
} else if (s[i] == 'U') {
c1[i + 1] = c1[i];
c2[i + 1] = c2[i] + 1;
} else {
c1[i + 1] = c1[i];
c2[i + 1] = c2[i] - 1;
}
v1.push_back({{c1[i + 1], c2[i + 1]}, (i + 1)});
}
sort(v1.begin(), v1.end());
int f = 0;
long long i1 = 0, i2 = INT_MAX;
for (long long i = 1; i <= n; i++) {
if (v1[i - 1].first == v1[i].first) {
long long idx2 = v1[i].second;
long long idx1 = v1[i - 1].second;
f = 1;
if (idx2 - idx1 < i2 - i1) {
i2 = idx2;
i1 = idx1;
}
}
}
if (f == 0)
cout << -1;
else {
cout << i1 + 1 << " " << i2;
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int vis[110];
int b[100];
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
int cnt = min(a / 3, min(b / 2, c / 2));
ans += cnt * 7;
int k = 0;
int maxn = 0;
for (int i = 1; i <= 7; i++) {
int ta = a - 3 * cnt;
int tb = b - 2 * cnt;
int tc = c - 2 * cnt;
int k = 0;
if (i == 1) {
while (1) {
if (ta) {
k++;
ta--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
}
}
if (i == 2) {
while (1) {
if (tb) {
k++;
tb--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
}
}
if (i == 3) {
while (1) {
if (tc) {
k++;
tc--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
}
}
if (i == 4) {
while (1) {
if (ta) {
k++;
ta--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
}
}
if (i == 5) {
while (1) {
if (tc) {
k++;
tc--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
}
}
if (i == 6) {
while (1) {
if (tb) {
k++;
tb--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
}
}
if (i == 7) {
while (1) {
if (ta) {
k++;
ta--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (ta) {
k++;
ta--;
} else
break;
if (tc) {
k++;
tc--;
} else
break;
if (tb) {
k++;
tb--;
} else
break;
}
}
maxn = max(maxn, k);
}
cout << ans + maxn << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 8;
const int MAXM = 1e6 + 8;
vector<int> sons[MAXN];
map<char, bool> mp;
struct edge {
int u, v, w;
edge(int u = 0, int v = 0, int w = 0) : u(u), v(v), w(w) {}
} e[MAXM];
inline bool cmp(const edge &a, const edge &b) { return a.w < b.w; }
int fa[MAXN], _rank[MAXN];
inline void init(int n) {
for (int i = 0; i <= n; i++) {
fa[i] = i;
_rank[i] = 0;
}
}
inline int _find(int u) { return fa[u] = fa[u] == u ? u : _find(fa[u]); }
inline void _merge(int u, int v) {
int x = _find(u), y = _find(v);
if (x == y) return;
if (_rank[x] < _rank[y]) {
fa[x] = y;
} else {
fa[y] = x;
if (_rank[x] == _rank[y]) _rank[x]++;
}
}
inline int kruskal(int n, int m) {
sort(e, e + m, cmp);
int i;
long long ans = 0;
init(n);
for (i = 0; i < m; i++) {
if (_find(e[i].u) != _find(e[i].v)) {
_merge(e[i].u, e[i].v);
sons[e[i].u].push_back(e[i].v);
sons[e[i].v].push_back(e[i].u);
ans += e[i].w;
}
}
return ans;
}
int c[26][26];
string s1, s2;
vector<pair<char, char> > ansvec;
inline void dfs(int u, int fa) {
int sz = sons[u].size(), v, i;
mp[u] = false;
for (i = 0; i < sz; i++) {
v = sons[u][i];
if (v == fa) continue;
ansvec.push_back(pair<char, char>(char(u + 'a'), char(v + 'a')));
dfs(v, u);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, i, m = 0, ans, root;
cin >> n;
cin >> s1 >> s2;
for (i = 0; i < n; i++) {
if (s1[i] == s2[i]) continue;
if (c[s1[i] - 'a'][s2[i] - 'a'] == 0) {
e[m].u = s1[i] - 'a', e[m].v = s2[i] - 'a', e[m].w = 1;
root = e[m].u;
mp[e[m].u] = true;
mp[e[m].v] = true;
m++;
}
c[s1[i] - 'a'][s2[i] - 'a']++;
c[s2[i] - 'a'][s1[i] - 'a']++;
}
if (mp.size() == 0)
cout << 0 << endl;
else {
kruskal((int)26, m);
for (auto x = mp.begin(); x != mp.end(); x++) {
if ((x->second) == false) continue;
dfs(x->first, -1);
}
ans = ansvec.size();
cout << ans << "\n";
for (auto x = ansvec.begin(); x != ansvec.end(); x++) {
cout << x->first << " " << x->second << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long a[] = {
1, 2, 4, 8, 16, 32,
64, 128, 256, 512, 1024, 2048,
4096, 8092, 16184, 32368, 64736, 129472,
258944, 517888, 1035776, 2071552, 4143104, 8286208,
16572416, 33144832, 66289664, 132579328, 265158656, 530317312,
1060634624, 2121269248, 4242538496, 8485076992, 16970153984, 33940307968};
int b;
cin >> b;
cout << a[b];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = int(1e5) + 1000;
vector<pair<int, int> > ver[Maxn];
vector<pair<int, int> > store;
int n, sz[Maxn], W0, L0, fen[Maxn];
bool mark[Maxn];
long long ans = 0;
inline void add_fen(int x, int val) {
if (x <= 0) return;
for (; x < Maxn; x += x & -x) fen[x] += val;
}
inline long long get_fen(int x) {
long long sum = 0;
for (x = max(x, 0); x > 0; x -= x & -x) sum += fen[x];
return sum;
}
void dfs_size(int v, int par) {
sz[v] = 1;
for (pair<int, int> nex : ver[v]) {
if (!mark[nex.first] && nex.first != par)
dfs_size(nex.first, v), sz[v] += sz[nex.first];
}
}
void dfs_gen(int v, int par, int curL, int curW, int L, int W) {
if (curW > W || curL > L) return;
store.push_back(make_pair(curW, curL));
for (pair<int, int> nex : ver[v])
if (!mark[nex.first] && nex.first != par)
dfs_gen(nex.first, v, curL + 1, curW + nex.second, L, W);
}
inline int find_center(int v) {
dfs_size(v, -1);
int par = -1, cap = sz[v] / 2;
while (1) {
bool found = false;
for (pair<int, int> nex : ver[v])
if (!mark[nex.first] && nex.first != par && sz[nex.first] > cap) {
par = v, v = nex.first, found = true;
break;
}
if (!found) return v;
}
}
inline long long cnt(int u, int par, int L, int W) {
long long ret = 0;
store.clear();
dfs_gen(u, par, 0, 0, L, W);
sort(store.begin(), store.end());
int po1 = 0;
for (int po2 = store.size() - 1; po2 >= 0; --po2) {
while (po1 < store.size() && store[po1].first + store[po2].first <= W)
add_fen(store[po1].second + 1, 1), ++po1;
ret += get_fen(L - store[po2].second + 1);
}
while (--po1 >= 0) add_fen(store[po1].second + 1, -1);
return ret;
}
inline void solve(int v) {
v = find_center(v);
ans += cnt(v, -1, L0, W0) - 1;
mark[v] = true;
for (pair<int, int> nex : ver[v])
if (!mark[nex.first]) ans -= cnt(nex.first, v, L0 - 2, W0 - 2 * nex.second);
for (pair<int, int> nex : ver[v])
if (!mark[nex.first]) solve(nex.first);
}
int main() {
scanf("%d%d%d", &n, &L0, &W0);
for (int i = 0; i < n - 1; ++i) {
int a, b, w;
scanf("%d%d", &a, &w);
--a;
ver[a].push_back(make_pair(i + 1, w));
ver[i + 1].push_back(make_pair(a, w));
}
solve(0);
printf("%I64d\n", ans / 2);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int len = 2e5 + 10;
struct Node {
int l, r, d;
} p[len];
int a[len], vis[len];
int m, n, k, t;
bool solve(int mid) {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= k; ++i) {
if (p[i].d > a[mid]) {
vis[p[i].l - 1] += 1;
vis[p[i].r] -= 1;
}
}
int sum = n + 1;
for (int i = 0; i < n; ++i) {
vis[i] += vis[i - 1];
if (vis[i]) sum += 2;
}
return sum <= t;
}
int main() {
cin >> m >> n >> k >> t;
for (int i = 1; i <= m; ++i) cin >> a[i];
sort(a + 1, a + 1 + m, greater<int>());
for (int i = 1; i <= k; ++i) cin >> p[i].l >> p[i].r >> p[i].d;
int l = 0, r = m, mid;
while (l < r) {
mid = (l + r + 1) / 2;
if (solve(mid))
l = mid;
else
r = mid - 1;
}
cout << l << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using iv = vector<int>;
using ll = long long;
const int N = 5e3 + 1;
int dp[N][N], m, n;
iv g[N];
struct bees {
int a, b, c;
bees(int A = 0, int B = 0, int C = 0) : a(A), b(B), c(C) {}
bool operator<(const bees &x) const {
if (a != x.a) return a < x.a;
if (b != x.b) return b < x.b;
if (c != x.c) return c < x.c;
return false;
}
bees sort() {
int x[] = {a, b, c};
std::sort(x, x + 3), a = x[0], b = x[1], c = x[2];
return *this;
}
bees sorted(int p) const { return bees(dp[a][p], dp[b][p], dp[c][p]).sort(); }
bees f(int p) const {
bees h;
for (auto i : g[p]) h = max(h, sorted(i));
return h;
}
bees next_move(const int p) {
bees h, u, ans = *this, m = f(p);
for (auto x0 : g[a])
for (auto x1 : g[b])
if (x1 != x0)
for (auto x2 : g[c])
if (x2 != x0 and x2 != x1)
if (u = bees(x0, x1, x2), h = u.f(p), h < m) m = h, ans = u;
return ans;
}
void write() const { cout << a << ' ' << b << ' ' << c << endl; }
bool done(int p) const { return a == p or b == p or c == p; }
};
void bfs(int u) {
queue<int> q;
for (q.push(u), dp[u][u] = 1; not q.empty(); q.pop()) {
int p = q.front();
for (auto i : g[p])
if (not dp[u][i]) dp[u][i] = dp[u][p] + 1, q.push(i);
}
for (int v = 1; v <= n; ++v) --dp[u][v];
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cin >> n >> m;
for (int u, v, i = 0; i < m; ++i)
cin >> u >> v, g[u].push_back(v), g[v].push_back(u);
for (int u = 1; u <= n; ++u) bfs(u);
for (int u = 1; u <= n; ++u) g[u].push_back(u);
int p;
bees b(1, 2, 3);
b.write();
while (cin >> p, not b.done(p))
if (b = b.next_move(p), b.write(), b.done(p)) break;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m;
char s[2020][2020];
set<int> r[30], c[30];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", &s[i]);
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') continue;
r[s[i][j] - 'a'].insert(i);
c[s[i][j] - 'a'].insert(j);
}
}
bool ok = 1;
int cnt = 0;
for (int i = 0; i < 30; i++) {
if (!r[i].size() && !c[i].size()) continue;
cnt = i + 1;
if (r[i].size() != 1 && c[i].size() != 1) {
ok = 0;
break;
}
auto it = --c[i].end();
for (int j = *c[i].begin(); j <= *it && r[i].size() == 1; j++) {
if (s[*r[i].begin()][j] - 'a' < i) {
ok = 0;
break;
}
}
it = --r[i].end();
for (int j = *r[i].begin(); j <= *it && c[i].size() == 1; j++) {
if (s[j][*c[i].begin()] - 'a' < i) {
ok = 0;
break;
}
}
if (!ok) break;
}
if (ok) {
printf("YES\n%d\n", cnt);
int l, rr, f, ss;
for (int i = 29; i >= 0; i--) {
if (r[i].size() == 1) {
l = *r[i].begin() + 1, rr = *c[i].begin() + 1, f = *r[i].begin() + 1,
ss = *(--c[i].end()) + 1;
break;
} else if (c[i].size() == 1) {
l = *r[i].begin() + 1, rr = *c[i].begin() + 1,
f = *(--r[i].end()) + 1, ss = *c[i].begin() + 1;
break;
}
}
for (int i = 0; i < cnt; i++) {
if (!r[i].size() && !c[i].size()) {
printf("%d %d %d %d\n", l, rr, f, ss);
continue;
}
if (r[i].size() == 1) {
printf("%d %d %d %d\n", *r[i].begin() + 1, *c[i].begin() + 1,
*r[i].begin() + 1, *(--c[i].end()) + 1);
} else
printf("%d %d %d %d\n", *r[i].begin() + 1, *c[i].begin() + 1,
*(--r[i].end()) + 1, *c[i].begin() + 1);
}
} else
printf("NO\n");
for (int i = 0; i < 30; i++) {
r[i].clear();
c[i].clear();
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.);
struct str {
int s;
} sss;
int abs(int a) { return (a < 0 ? -a : a); }
void sort(str a[], int l, int r);
int main() {
char ans[1000666];
int s, l = 0;
cin >> s;
while (s) {
if (s % 7 == 0)
s -= 7, ans[l++] = '7';
else if (s >= 4)
s -= 4, ans[l++] = '4';
else
break;
}
ans[l] = '\0';
if (s)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
void sort(str a[], int l, int r) {
int i = l, j = r;
str x, tmp;
x = a[(l + r) / 2];
while (i < j) {
while (a[i].s < x.s) i++;
while (a[j].s > x.s) j--;
if (i <= j) {
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
i++;
j--;
}
}
if (j > l) sort(a, l, j);
if (r > i) sort(a, i, r);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool a[15];
int main() {
int x, cnt = 0;
int tmp;
bool flag;
memset(a, false, sizeof(a));
scanf("%d", &x);
tmp = x;
while (tmp) {
a[tmp % 10] = true;
tmp /= 10;
}
for (int i = 1; i * i <= x; ++i) {
if (x % i == 0) {
tmp = i;
flag = false;
while (tmp) {
if (a[tmp % 10]) {
flag = true;
break;
}
tmp /= 10;
}
if (flag) ++cnt;
if (i == x / i) continue;
tmp = x / i;
flag = false;
while (tmp) {
if (a[tmp % 10]) {
flag = true;
break;
}
tmp /= 10;
}
if (flag) ++cnt;
}
}
printf("%d\n", cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
scanf("%d", &n);
int len = sqrt(n), f[n + 1];
for (register int i = 0; i < n; ++i) f[i] = i + 1;
int num1 = n / len;
for (register int i = 0; i != num1; ++i) {
for (register int j = i * len, k = j + len - 1; j < k; ++j, --k) {
swap(f[j], f[k]);
}
}
for (register int i = num1 * len, j = n - 1; i < j; ++i, --j)
swap(f[i], f[j]);
for (register int i = 0; i < n - 1; ++i) printf("%d ", f[i]);
printf("%d", f[n - 1]);
}
int main(void) {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long powmod(long long x, long long y) {
if (y == 0) return 1;
long long p = powmod(x, y / 2) % 998244353;
p = (p * p) % 998244353;
return (y % 2 == 0) ? p : (x * p) % 998244353;
}
long long inverse(long long a) { return powmod(a, 998244353 - 2); }
const long long limbin = 500001;
long long fact[limbin], factinv[limbin], coefficientflag = 0;
void Util_nCr() {
fact[0] = 1, factinv[0] = 1;
for (long long i = 1; i < limbin; i++) {
fact[i] = (fact[i - 1] * i) % 998244353;
factinv[i] = (factinv[i - 1] * inverse(i)) % 998244353;
}
}
long long nCr(long long n, long long r) {
if (!coefficientflag) coefficientflag = 1, Util_nCr();
if (n < r) return 0;
return ((fact[n] * inverse(fact[n - r]) % 998244353 * inverse(fact[r])) %
998244353);
}
void solve() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = n - 1; i >= 1; i--) a[i] -= a[i - 1];
long long sum = 0;
for (long long i = 0; i < n; i++) sum -= (a[i] < 0) * a[i];
cout << ((sum > a[0]) ? "NO\n" : "YES\n");
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
for (long long i = 0; i < t; i++) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5 + 7;
int n, k, i, br3, ost, zatv[NMAX], d[NMAX], deg[NMAX];
vector<pair<int, int> > g[NMAX];
queue<int> Q;
int jeli(int MJ) {
memset(zatv, 0, sizeof(zatv));
memset(d, 0, sizeof(d));
ost = n;
br3 = 0;
for (int i = 1; i <= n; i++) {
if (g[i].size() == 1) Q.push(i);
if (g[i].size() >= 3) br3++;
deg[i] = g[i].size();
}
while (!Q.empty()) {
int sad = Q.front();
Q.pop();
pair<int, int> ima = {-1, 1e9 + 1};
for (pair<int, int> ide : g[sad]) {
if (!zatv[ide.first]) {
ima = ide;
break;
}
}
int sl = ima.first;
int duz = ima.second;
if (d[sad] + duz > MJ) continue;
d[sl] = max(d[sl], d[sad] + duz);
zatv[sad] = 1;
if (deg[sl] == 3) br3--;
deg[sl]--;
ost--;
if (deg[sl] == 1) Q.push(sl);
}
return (ost <= k && br3 == 0);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n - 1; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a].push_back({b, c});
g[b].push_back({a, c});
}
int l = 0, ans;
int r = 1e9 + 7;
while (l <= r) {
int mid = (l + r) / 2;
if (jeli(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int primos[100100], ans[100100], atual = 1;
void crivo(int n) {
primos[1] = 0;
for (int i = 2; i * i <= n; i++) {
if (primos[i] == -1) {
primos[i] = 1;
ans[i] = atual;
for (int j = i * i; j <= n; j += i) {
primos[j] = 0;
if (ans[j] == 0) {
ans[j] = atual;
}
}
atual++;
}
}
}
int main() {
int n;
cin >> n;
memset(primos, -1, sizeof primos);
crivo(n);
for (int i = 2; i <= n; i++) {
if (ans[i] == 0) {
ans[i] = atual++;
}
cout << ans[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, m, q;
int p[N];
int wei[N], w[N];
int tim[N], seq[N];
struct edge {
int l, r;
} e[N];
struct query {
int l, r, id;
} qq[N];
int tot;
int find(int x) {
if (x == p[x]) return x;
return p[x] = find(p[x]);
}
int cmp(int a, int b) { return tim[a] > tim[b]; }
int ans[N];
vector<int> g[N];
int in[N], out[N], num, pre[N], f[N][21];
int tr[N << 2];
void dfs(int u) {
in[u] = ++num;
pre[num] = u;
for (int j = 1; j <= 20; j++) f[u][j] = f[f[u][j - 1]][j - 1];
for (auto &j : g[u]) {
f[j][0] = u;
dfs(j);
}
out[u] = num;
}
void pushup(int rt) {
if (w[tr[rt << 1]] >= w[tr[rt << 1 | 1]]) {
tr[rt] = tr[rt << 1];
} else
tr[rt] = tr[rt << 1 | 1];
}
int get(int x, int t) {
for (int i = 20; i >= 0; i--)
if (f[x][i] && wei[f[x][i]] >= t) x = f[x][i];
return x;
}
void build(int rt, int l, int r) {
if (l == r) {
tr[rt] = pre[l];
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
int query(int rt, int L, int R, int l, int r) {
if (L <= l && R >= r) {
return tr[rt];
}
int mid = l + r >> 1;
int res = 0, res1 = 0, res2 = 0;
if (L <= mid) res1 = query(rt << 1, L, R, l, mid);
if (R > mid) res2 = query(rt << 1 | 1, L, R, mid + 1, r);
if (w[res1] >= w[res2])
res = res1;
else
res = res2;
return res;
}
void update(int rt, int L, int C, int l, int r) {
if (l == r) {
w[pre[l]] = C;
tr[rt] = pre[l];
return;
}
int mid = l + r >> 1;
if (L <= mid)
update(rt << 1, L, C, l, mid);
else
update(rt << 1 | 1, L, C, mid + 1, r);
pushup(rt);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]), wei[i] = q + 1;
for (int i = 1; i <= n + n + 10; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &e[i].l, &e[i].r);
tim[i] = q + 1;
seq[i] = i;
}
for (int i = 1; i <= q; i++) {
scanf("%d%d", &qq[i].l, &qq[i].r);
qq[i].id = i;
if (qq[i].l == 2) tim[qq[i].r] = i;
}
sort(seq + 1, seq + m + 1, cmp);
tot = n;
for (int i = 1; i <= m; i++) {
int u = e[seq[i]].l, v = e[seq[i]].r, t = tim[seq[i]];
int fx = find(u), fy = find(v);
if (fx == fy) continue;
wei[++tot] = t;
g[tot].push_back(fx);
g[tot].push_back(fy);
p[fx] = tot, p[fy] = tot;
}
for (int i = tot; i >= 1; i--)
if (!in[i]) dfs(i);
build(1, 1, num);
for (int i = 1; i <= q; i++) {
if (qq[i].l == 1) {
int v = get(qq[i].r, i);
int tmp = query(1, in[v], out[v], 1, num);
ans[i] = w[tmp];
if (ans[i]) update(1, in[tmp], 0, 1, num);
printf("%d\n", ans[i]);
}
}
}
| 9 |
#include<bits/stdc++.h>
using namespace std;
///// Defines /////
#define FAST ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define f(i, beg, end) for(int i=beg; i<end; i++)
#define rf(i, beg, end) for(int i=beg; i>=end; i--)
#define ms(x, a) memset(x, a, sizeof(x))
#define Max(x, y, z) max(x, max(y, z))
#define Min(x, y, z) min(x, min(y, z))
#define max__(a, n) *max_element(a, a+n)
#define min__(a, n) *min_element(a, a+n)
#define endl '\n'
#define ln cout << '\n'
#define yes cout << "YES\n"
#define no cout << "NO\n"
#define imp cout << "-1\n"
#define all(v) v.begin(), v.end()
#define rev(v) v.rbegin(), v.rend()
#define in insert
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define sz(v) (int)v.size()
#define len length()
#define ub upper_bound
#define lb lower_bound
///// Data types and Containers /////
typedef long long ll;
typedef vector<int> vi;
typedef vector<int>::iterator viit;
typedef vector<char> vc;
typedef vector<char>::iterator vcit;
///// Constants /////
const long long MOD = 1e9+7;
const long long INF = LONG_LONG_MAX;
const long long MINF = LONG_LONG_MIN;
const int N = 2e5+5;
///// F(X)'s /////
template <typename T> inline T abs(T x) {return x < 0? -x : x;}
inline ll pow_mod(ll x,ll n) {ll r=1;while(n){if(n%2)r=(r*x)%MOD;x=(x*x)%MOD;n/=2;}return r;}
inline ll pow_(ll x,ll n) {ll r=1;while(n){if(n%2)r=(r*x);x=(x*x);n/=2;}return r;}
inline void solve()
{
int n; cin >> n;
int a[n];
f(i,0,n) cin >> a[i];
int i = 0, j = n-1, f = 1;
while(i<=j) {
if(f) cout << a[i++] << " ";
else cout << a[j--] << " ";
f ^= 1;
}
ln;
}
int main()
{
FAST
int t=1; cin >> t;
while(t--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int len = s.length();
int ans = 0;
int maxx = 0;
int pos = -1;
for (int i = 0; i < len; i++) {
if (s[i] == '[') {
pos = i;
break;
}
}
int pos2 = -1;
for (int i = len - 1; i >= 0; i--) {
if (s[i] == ']') {
pos2 = i;
break;
}
}
int pos3 = -1;
if (pos == -1 || pos2 == -1) {
cout << -1 << endl;
return 0;
}
for (int i = pos; i <= pos2; i++) {
if (s[i] == ':') {
pos3 = i;
break;
}
}
int pos4 = -1;
for (int i = pos2; i >= pos; i--) {
if (s[i] == ':') {
pos4 = i;
break;
}
}
if (pos3 < pos4 && (pos != -1) && (pos2 != -1) && (pos3 != -1) &&
(pos4 != -1)) {
ans += 4;
for (int i = pos3; i <= pos4; i++) {
if (s[i] == '|') ans++;
}
cout << ans << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 1003;
int a[nax][nax];
int vis[nax][nax];
int dp[nax][nax];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
memset(vis, 0, sizeof vis);
int n, m, t;
cin >> n >> m >> t;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
a[i][j] = s[j] == '1';
}
}
queue<pair<int, int>> q;
bool ff = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int f = a[i][j];
int cnt = 0;
if (i + 1 < n && a[i + 1][j] == f) cnt++;
if (j + 1 < m && a[i][j + 1] == f) cnt++;
if (i - 1 >= 0 && a[i - 1][j] == f) cnt++;
if (j - 1 >= 0 && a[i][j - 1] == f) cnt++;
if (cnt) {
vis[i][j] = 1;
dp[i][j] = 0;
q.push({i, j});
}
ff &= (cnt == 0);
}
}
vector<pair<int, int>> move = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
int i = u.first;
int j = u.second;
for (auto v : move) {
int x = i + v.first;
int y = j + v.second;
if (x >= 0 && x < n && y < m && y >= 0) {
if (vis[x][y]) continue;
vis[x][y] = 1;
dp[x][y] = dp[i][j] + 1;
q.push({x, y});
}
}
}
while (t--) {
int i, j;
long long p;
cin >> i >> j >> p;
i--;
j--;
if (ff) {
cout << a[i][j] << endl;
} else {
if (dp[i][j]) {
long long aux = p - (dp[i][j] * 1ll);
if (aux <= 0) {
cout << a[i][j] << endl;
} else {
cout << (aux & 1ll ? (!a[i][j]) : (a[i][j])) << endl;
}
} else {
cout << (p & 1ll ? (!a[i][j]) : (a[i][j])) << endl;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double EPS = 1e-9;
class Point2D {
public:
double x, y;
Point2D();
Point2D(double, double);
Point2D(const Point2D &p);
Point2D operator+(Point2D);
Point2D operator-(Point2D);
Point2D operator*(Point2D);
friend ostream &operator<<(ostream &, Point2D);
friend istream &operator>>(istream &, Point2D &);
double dot(Point2D);
double magnitude();
double cross(Point2D);
double distanceSqr(Point2D, Point2D);
int sideSign(Point2D, Point2D, Point2D);
};
ostream &operator<<(ostream &c, Point2D p) {
c << p.x << " " << p.y;
return c;
}
istream &operator>>(istream &c, Point2D &p) {
c >> p.x >> p.y;
return c;
}
Point2D::Point2D(double x, double y) {
(*this).x = x;
(*this).y = y;
}
Point2D::Point2D(const Point2D &p) { (*this) = p; }
Point2D::Point2D() {
(*this).x = 0.0;
(*this).y = 0.0;
}
Point2D Point2D::operator+(Point2D p) { return Point2D(x + p.x, y + p.y); }
Point2D Point2D::operator-(Point2D p) { return Point2D(x - p.x, y - p.y); }
Point2D Point2D::operator*(Point2D p) { return Point2D(x * p.x, y * p.y); }
double Point2D::dot(Point2D p) { return x * p.x + y * p.y; }
double Point2D::magnitude() { return sqrt(x * x + y * y); }
double Point2D::cross(Point2D p) { return (x * p.y) - (y * p.x); }
double Point2D::distanceSqr(Point2D p1, Point2D p2) {
return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}
int Point2D::sideSign(Point2D p1, Point2D p2, Point2D a) {
double sg = (p1.x - a.x) * (p2.y - a.y) - (p1.y - a.y) * (p2.x - a.x);
if (fabs(sg) < EPS) return 0;
if (sg > 0) return 1;
return -1;
}
bool isRight(int x1, int y1, int x2, int y2, int x3, int y3) {
Point2D p1((double)x1, (double)y1);
Point2D p2((double)x2, (double)y2);
Point2D p3((double)x3, (double)y3);
Point2D v1;
Point2D v2;
v1 = p1 - p2;
v2 = p3 - p2;
if (v1.dot(v2) == 0) {
if (abs(v1.cross(v2)) != 0) return true;
}
v1 = p2 - p1;
v2 = p3 - p1;
if (v1.dot(v2) == 0)
if (abs(v1.cross(v2)) != 0) return true;
v1 = p2 - p3;
v2 = p1 - p3;
if (v1.dot(v2) == 0)
if (abs(v1.cross(v2)) != 0) return true;
return false;
}
int main() {
int x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
if (isRight(x1, y1, x2, y2, x3, y3))
cout << "RIGHT\n";
else if (isRight(x1 + 1, y1, x2, y2, x3, y3) ||
isRight(x1, y1 + 1, x2, y2, x3, y3) ||
isRight(x1, y1, x2 + 1, y2, x3, y3) ||
isRight(x1, y1, x2, y2 + 1, x3, y3) ||
isRight(x1, y1, x2, y2, x3 + 1, y3) ||
isRight(x1, y1, x2, y2, x3, y3 + 1) ||
isRight(x1 - 1, y1, x2, y2, x3, y3) ||
isRight(x1, y1 - 1, x2, y2, x3, y3) ||
isRight(x1, y1, x2 - 1, y2, x3, y3) ||
isRight(x1, y1, x2, y2 - 1, x3, y3) ||
isRight(x1, y1, x2, y2, x3 - 1, y3) ||
isRight(x1, y1, x2, y2, x3, y3 - 1))
cout << "ALMOST\n";
else
cout << "NEITHER\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, x, y;
int main() {
cin >> n;
while (n--) {
cin >> x >> y;
if (x > y)
a++;
else if (x < y)
b++;
}
if (a > b)
cout << "Mishka";
else if (a < b)
cout << "Chris";
else
cout << "Friendship is magic!^^";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long arr[60][60];
long long ans[100];
int main() {
std::ios::sync_with_stdio(false);
long long n;
cin >> n;
memset(ans, 0, sizeof(ans));
for (long long i = (long long)(1); i <= (long long)(n); i++) {
for (long long j = (long long)(1); j <= (long long)(n); j++) {
cin >> arr[i][j];
}
}
long long val = 1;
long long count = 0;
while (1) {
if (count == n) break;
for (long long i = (long long)(1); i <= (long long)(n); i++) {
bool f = true;
if (ans[i]) continue;
for (long long j = (long long)(1); j <= (long long)(n); j++) {
if (arr[i][j] > val) {
f = false;
}
}
if (f) {
ans[i] = val;
for (long long j = (long long)(1); j <= (long long)(n); j++) {
arr[i][j] = INT_MAX;
}
val++;
count++;
}
if (count == n) break;
}
}
for (long long i = (long long)(1); i <= (long long)(n); i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, j, x;
long long int a;
int main() {
scanf("%d%d", &n, &k);
int val;
j = 1;
x = n;
for (i = 1; i <= n; i++) {
scanf("%d", &val);
if (a - (long long int)val * (j - 1) * (x - j) < k)
printf("%d\n", i), x--;
else
a += (long long int)val * (j - 1), j++;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x *= f, void();
}
template <typename T>
void ckmax(T &a, T b) {
a = b > a ? b : a;
}
template <typename T>
void ckmin(T &a, T b) {
a = b < a ? b : a;
}
const int N = 1e5 + 5;
int n, a[N], row[N], vis[N], rowcnt;
vector<pair<int, int> > ans;
int main() {
read(n);
for (int i = 1; i <= n; i++) {
read(a[i]);
}
for (int i = 1; i <= n; i++) {
if (a[i] == 1) {
row[i] = ++rowcnt;
ans.push_back(make_pair(row[i], i));
}
}
int pos = 1;
for (int i = 1; i <= n; i++) {
if (a[i] == 2) {
ckmax(pos, i);
while (pos <= n && a[pos] != 1) {
pos++;
}
if (pos == n + 1) {
puts("-1");
exit(0);
}
row[i] = row[pos];
vis[pos] = true;
ans.push_back(make_pair(row[i], i));
pos++;
}
}
pos = n;
for (int i = n; i >= 1; i--) {
if (a[i] == 3) {
while (pos >= i && !((a[pos] == 1 && !vis[pos]) || a[pos] == 2 ||
(a[pos] == 3 && row[pos])))
pos--;
if (pos == i - 1) {
puts("-1");
exit(0);
}
row[i] = ++rowcnt;
ans.push_back(make_pair(row[i], i));
ans.push_back(make_pair(row[i], pos));
pos--;
}
}
if (rowcnt > n || (int)ans.size() > n * 2) {
puts("-1");
exit(0);
}
printf("%d\n", (int)ans.size());
for (auto p : ans) {
printf("%d %d\n", n - p.first + 1, p.second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
template <typename T1, typename T2>
inline T1 gmax(T1 &a, T2 b) {
return a = a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 gmin(T1 &a, T2 b) {
return a = a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 207, inf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
int n, tar;
long long per;
long long bas[_] = {0}, dlt[_] = {0}, lim[_] = {0};
long long sbas[_] = {0}, sdlt[_] = {0};
inline long long hanging(long long i, long long tim, long long sta) {
return sbas[i] * sta + sdlt[i] * tim;
}
long long f[_][_][2], g[_][_][2];
inline long long ceiling(long long x, long long b) { return (x + b - 1) / b; }
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), tar = ty(), per = ty();
for (int i = 1; i <= n; i++) bas[i] = ty(), dlt[i] = ty(), lim[i] = ty();
n++, bas[n] = dlt[n] = inf, lim[n] = linf;
for (int i = 1; i <= n; i++)
sbas[i] = sbas[i - 1] + bas[i], sdlt[i] = sdlt[i - 1] + dlt[i];
memset(f, 63, sizeof(f)), memset(g, 63, sizeof(g));
memset(f[0], 0, sizeof(f[0])), memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= tar; j++) {
for (int k = 0; k < 2; k++) {
if (f[i - 1][j][k] < linf && bas[i] * k + dlt[i] * j <= lim[i]) {
gmin(f[i][j][k], f[i - 1][j][k]);
long long t = ceiling(hanging(i - 1, j, k), per);
if (t * per <= hanging(i, j, k)) gmin(g[i][j][k], t);
}
for (int a = 0; a < j; a++) {
long long now = g[i][a][k];
if (now > linf) continue;
long long lef = hanging(i, a, k) - now * per;
long long tran =
ceiling(max(lef + dlt[i] * (j - a) - lim[i], 0), per);
if (f[i - 1][j - a][0] < linf && tran * per <= lef) {
gmin(f[i][j][k], now + tran + f[i - 1][j - a][0]);
long long temp = ceiling(sdlt[i - 1] * (j - a), per);
if (temp * per <= sdlt[i] * (j - a) + lef - tran * per)
gmin(g[i][j][k], now + tran + temp);
}
}
}
}
}
cout << f[n][tar][1] << lf;
return 0;
}
| 13 |
#include<bits/stdc++.h>
using namespace std;
int miss[1005];
int war[1005];
long long losuj(long long a)
{
long long res = 1;
for(int x=1;x<=10;x++)
res = (res*rand())%a+1;
return res;
}
int main()
{
srand(time(NULL) + clock());
int a,t;
cin>>a>>t;
while(t--)
{
string d;
cin>>d;
int mini = 1e9 , maks = -1e9;
for(int x=0;x<a;x++)
{
maks = max(maks , miss[x]);
mini = min(mini , miss[x]);
}
if(maks - mini > 110)
maks = mini + 110;
long long sum = 0;
for(int x=0;x<a;x++)
{
if(miss[x] > maks)
war[x] = 0;
else
war[x] = 1<<((maks - miss[x])/4);
sum += war[x];
}
sum = losuj(sum);
int co = -1;
for(int x=0;x<a;x++)
{
if(sum <= war[x])
{
co = x;
break;
}
sum -= war[x];
}
cout<<d[co]<<endl;
cout.flush();
char c;
cin>>c;
for(int x=0;x<a;x++)
if(d[x] != c)
miss[x]++;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, d[107], c[107], k[107], is[107];
vector<long long> blt[107];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
long long s;
cin >> s >> d[i] >> c[i];
blt[s].push_back(i);
is[d[i]] = i;
}
vector<long long> ans;
for (int i = 1; i <= n; ++i) {
for (auto j : blt[i]) q.push({d[j], j});
if (is[i] != 0) {
if (k[is[i]] < c[is[i]]) return cout << -1, 0;
ans.push_back(m + 1);
continue;
}
while (q.size() && k[q.top().second] == c[q.top().second]) q.pop();
if (q.size() == 0) {
ans.push_back(0);
} else {
k[q.top().second]++;
ans.push_back(q.top().second);
}
while (q.size() && k[q.top().second] == c[q.top().second]) q.pop();
}
for (auto i : ans) cout << i << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int x, y;
int req;
int mind = 987654321;
map<int, int> mst;
struct boja {
int count_up;
int count_down;
int mov_need;
};
int idd = 1;
boja B[200000];
int main() {
scanf("%d", &n);
if (n % 2 == 0)
req = n / 2;
else
req = n / 2 + 1;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
if (mst.find(x) == mst.end()) {
mst[x] = idd;
idd++;
}
if (mst.find(y) == mst.end()) {
mst[y] = idd;
idd++;
}
B[mst[x]].count_up++;
if (x != y) B[mst[y]].count_down++;
}
map<int, int>::iterator it;
for (int i = 0; i < idd; i++) {
if (B[i].count_up + B[i].count_down >= req) {
int req1 = req;
req1 -= B[i].count_up;
if (req1 < 0) req1 = 0;
if (req1 < mind) mind = req1;
}
}
if (mind == 987654321) {
printf("-1\n");
} else
printf("%d\n", mind);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[101] = {0};
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[x]++;
}
int ans = a[0], cf = a[0], temp = a[0];
for (int i = 1; i <= 100; i++) {
cf = cf + a[i];
temp = cf / (i + 1);
if (cf % (i + 1) != 0) temp++;
if (temp > ans) ans = temp;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int arr[4005][4005];
int dp[4005][810];
int cost(int i, int j) {
return (arr[j][j] - arr[i - 1][j] - arr[j][i - 1] + arr[i - 1][i - 1]) / 2;
}
void divide(int j, int l, int r, int bestl, int bestr) {
int mid = (l + r) / 2;
int best_mid = bestl;
for (int i = bestl; i <= bestr && i <= mid; i++) {
int tmp = dp[i - 1][j - 1] + cost(i, mid);
if (tmp < dp[mid][j]) {
dp[mid][j] = tmp;
best_mid = i;
}
}
if (mid > l) divide(j, l, mid - 1, bestl, best_mid);
if (mid < r) divide(j, mid + 1, r, best_mid, bestr);
}
int main() {
scanf("%d%d\n", &n, &k);
char buffer[8005];
for (int i = 1; i <= n; i++) {
gets(buffer);
for (int j = 1; j <= n; j++) {
arr[i][j] = arr[i - 1][j] + arr[i][j - 1] - arr[i - 1][j - 1] +
buffer[(j - 1) * 2] - '0';
}
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= k; j++) dp[i][j] = 1e8;
dp[0][0] = 0;
for (int j = 1; j <= k; j++) {
divide(j, j, n, j, n);
}
cout << dp[n][k];
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
int office[5];
vector<int> mp[5005];
bool nlf[5005];
int sz[5005], p[5005], be[5005], sz4[5];
bitset<5005> oth, off4[5];
void calsz(int x) {
sz[x] = nlf[x] ? 0 : 1;
for (int c : mp[x]) {
calsz(c);
sz[x] += sz[c];
if (x == 1 && be[c] == 0) {
oth |= oth << sz[c];
}
if (be[x] != 0 && be[c] == 0) {
off4[be[x]] |= off4[be[x]] << sz[c];
}
if (x == 1 && be[c] != 0) sz4[be[c]] = sz[c];
}
}
void fmain(int tid) {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(4); (i)++) scanf("%d", office + i);
for (int(i) = 1; (i) <= (int)(n - 1); (i)++) {
scanf("%d", &k);
p[i + 1] = k;
mp[k].push_back(i + 1);
nlf[k] = 1;
}
for (int(i) = 1; (i) <= (int)(4); (i)++) {
for (int x = office[i]; x != 1; x = p[x]) be[x] = i;
off4[i][0] = 1;
}
oth[0] = 1;
calsz(1);
if (sz[1] & 1) etp();
bool ok1 = 0, ok2 = 0;
for (int(i) = 0; (i) < (int)(5005 - 1); (i)++)
for (int(j) = 0; (j) < (int)(5005 - 1); (j)++) {
if (off4[1][i] == 1 && off4[2][j] == 1) {
int tar = sz[1] / 2 - (i + j + 1 + sz4[3]);
if (tar >= 0 && oth[tar] == 1) ok1 = 1;
}
if (off4[3][i] == 1 && off4[4][j] == 1) {
int tar = sz[1] / 2 - (i + j + 1 + sz4[2]);
if (tar >= 0 && oth[tar] == 1) ok2 = 1;
}
}
etp(ok1 && ok2);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n;
std::cin >> n;
std::vector<bool> col(6 * n);
for (int i = 0; i < 3 * n; ++i) {
int x;
std::cin >> x;
--x;
col[x] = true;
}
std::vector<int> sta;
std::vector<std::vector<int>> tmp(6 * n);
std::vector<std::tuple<int, int, int>> tp;
std::vector<bool> bel;
std::vector<std::vector<int>> E(2 * n);
for (int i = 0; i < 6 * n; ++i) {
sta.push_back(i);
if ((int)sta.size() >= 3) {
auto c = std::prev(sta.end()), b = std::prev(c), a = std::prev(b);
if (col[*a] == col[*b] && col[*b] == col[*c]) {
int u = tp.size();
tp.emplace_back(*a, *b, *c);
bel.push_back(col[*a]);
if (a != sta.begin()) {
tmp[*std::prev(a)].push_back(u);
}
E[u].insert(E[u].end(), tmp[*a].begin(), tmp[*a].end());
E[u].insert(E[u].end(), tmp[*b].begin(), tmp[*b].end());
sta.pop_back(), sta.pop_back(), sta.pop_back();
}
}
}
std::vector<int> fa(2 * n, -1), deg(2 * n, 0);
for (int u = 0; u < 2 * n; ++u) {
for (int v : E[u]) {
fa[v] = u;
}
deg[u] = E[u].size();
}
int cnt = 0;
for (int u = 0; u < 2 * n; ++u) {
if (fa[u] == -1 && !bel[u]) {
++cnt;
}
}
int p = -1;
std::array<std::queue<int>, 2> Q;
for (int u = 0; u < 2 * n; ++u) {
if (!deg[u]) {
Q[bel[u]].push(u);
}
}
std::vector<std::tuple<int, int, int>> ans;
int c = 0;
for (int i = 0; i < 2 * n - 1; ++i) {
c ^= 1;
while (1) {
int u = Q[c].front();
Q[c].pop();
if (fa[u] == -1 && !bel[u]) {
if (cnt == 1) {
p = u;
continue;
}
--cnt;
}
ans.emplace_back(tp[u]);
if (fa[u] != -1) {
--deg[fa[u]];
if (!deg[fa[u]]) {
Q[bel[fa[u]]].push(fa[u]);
}
}
break;
}
}
if (p == -1) {
c ^= 1;
p = Q[c].front();
}
ans.emplace_back(tp[p]);
for (auto [x, y, z] : ans) {
std::cout << x + 1 << " " << y + 1 << " " << z + 1 << "\n";
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
char val[n][m];
memset(val, '&', sizeof(val));
long long i, j;
for (i = 0; i < n; i++) {
long long x;
cin >> x;
for (j = 0; j < x; j++) {
val[i][j] = 'f';
}
if (x < m) {
val[i][x] = 'e';
}
}
bool flag = true;
for (j = 0; j < m; j++) {
long long x;
cin >> x;
for (i = 0; i < x; i++) {
if (val[i][j] == 'e') {
flag = false;
} else
val[i][j] = 'f';
}
if (x < n) {
if (val[x][j] == 'f') {
flag = false;
} else
val[x][j] = 'e';
}
}
if (flag == false) {
cout << 0;
return 0;
}
long long cnt = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (val[i][j] == '&') {
cnt++;
cnt %= 1000000007;
}
}
}
long long ans = 1;
for (long long i = 0; i < cnt; i++) {
ans *= 2;
ans %= 1000000007;
}
cout << (ans % 1000000007);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long c = 1;
long long cost = LLONG_MAX;
sort(a, a + n);
while (1) {
long long pw = 1, n_cost = 0;
for (long long i = 0; i < n; i++, pw *= c) {
if (pw >= 1e15) {
n_cost = -1;
break;
}
n_cost += abs(a[i] - pw);
}
if (n_cost == -1) break;
cost = min(cost, n_cost);
c++;
}
cout << cost << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
vector<pair<int, string> > v;
int x[10], n, m;
bool d[10];
void makep() {
int res;
string s;
res = 0;
s = "0";
for (int i = 1; i <= n; i++) {
s += "0";
s[i] = (char)(x[i] + 48);
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int t = 1000;
for (int k = i; k <= j; k++) t = min(t, x[k]);
res += t;
}
}
v.push_back(pair<int, string>(res, s));
}
void make(int pos) {
for (int l = 1; l <= n; l++)
if (!d[l]) {
x[pos] = l;
d[l] = 1;
if (pos == n)
makep();
else
make(pos + 1);
d[l] = 0;
}
}
bool smaller(string X, string y) {
for (int i = 1; i < X.length(); i++)
if (X[i] < y[i])
return true;
else if (X[i] > y[i])
return false;
return false;
}
bool comp(pair<int, string> X, pair<int, string> y) {
if (X.first > y.first) return true;
if ((X.first == y.first) && smaller(X.second, y.second)) {
return true;
}
return false;
}
int main() {
cin >> n >> m;
make(1);
sort(v.begin(), v.end(), comp);
string s = v[m - 1].second;
for (int i = 1; i <= n; i++) {
cout << s[i] << ' ';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, y;
cin >> n >> y;
vector<int> a(n);
for (auto& x : a) cin >> x;
int m, y2;
cin >> m >> y2;
vector<int> b(m);
for (auto& x : b) cin >> x;
int best = min(2, n + m);
for (int l = 0; l < 30; l++) {
int MOD = 1 << l;
map<int, int> ma;
for (int x : a) ma[x % (2 * MOD)]++;
for (int x : b) ma[(x + MOD) % (2 * MOD)]++;
for (auto [_, c] : ma) best = max(best, c);
}
cout << best << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[100001][5] = {0};
int note[100001];
vector<int> v;
int print(int n) {
int pre;
for (int i = 0; i < 5; i++) {
if (a[n - 1][i]) {
v.push_back(i + 1);
pre = a[n - 1][i];
for (int j = n - 2; j >= 0; j--) {
v.push_back(pre);
pre = a[j][pre - 1];
}
return 1;
}
}
return 0;
}
int main() {
int n, pre;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> note[i];
}
for (int i = 0; i < 5; i++) {
a[0][i] = i + 1;
}
for (int i = 1; i < n; i++) {
if (note[i] < note[i - 1]) {
for (int j = 0; j < 5; j++) {
for (int k = 4; k > j; k--) {
if (a[i - 1][k]) {
a[i][j] = k + 1;
}
}
}
} else if (note[i] > note[i - 1]) {
for (int j = 0; j < 5; j++) {
for (int k = 0; k < j; k++) {
if (a[i - 1][k]) {
a[i][j] = k + 1;
}
}
}
} else {
for (int j = 0; j < 5; j++) {
for (int k = 0; k < 5; k++) {
if (a[i - 1][k] && j != k) {
a[i][j] = k + 1;
}
}
}
}
}
if (print(n)) {
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
} else {
cout << "-1" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, K, rel[75][75];
long long dp[75][40];
string sign[5] = {"=", "<", ">", "<=", ">="};
int rev[5] = {0, 2, 1, 4, 3};
vector<int> rs[75];
long long solve(int st, int pos) {
if (pos >= N) {
if (rel[st][st + 1] == 1 || rel[st][st + 1] == 2) return 0;
return 1;
}
long long &res = dp[st][pos];
if (res != -1) return res;
res = 0;
int en = 2 * N - (2 * pos - st - 1), fl = 1, p, s;
for (int i = 0; i < (int)rs[st].size(); i++) {
p = rs[st][i], s = rel[st][p];
if (p == en || p == st) {
if ((s == 2) || (s == 1)) fl = 0;
} else if (p < st || p > en) {
if ((s != 2) && (s != 4)) fl = 0;
} else if ((s != 1) && (s != 3))
fl = 0;
}
for (int i = 0; i < (int)rs[en].size(); i++) {
p = rs[en][i], s = rel[en][p];
if (p == st || p == en) {
if ((s == 2) || (s == 1)) fl = 0;
} else if (p < st || p > en) {
if ((s != 2) && (s != 4)) fl = 0;
} else if ((s != 1) && (s != 3))
fl = 0;
}
if (fl) res += solve(st + 1, pos + 1);
fl = 1;
for (int i = 0; i < (int)rs[st].size(); i++) {
p = rs[st][i], s = rel[st][p];
if (p == (st + 1) || p == st) {
if ((s == 2) || (s == 1)) fl = 0;
} else if (p < st || p > en) {
if ((s != 2) && (s != 4)) fl = 0;
} else if ((s != 1) && (s != 3))
fl = 0;
}
for (int i = 0; i < (int)rs[st + 1].size(); i++) {
p = rs[st + 1][i], s = rel[st + 1][p];
if (p == st || p == (st + 1)) {
if ((s == 2) || (s == 1)) fl = 0;
} else if (p < st || p > en) {
if ((s != 2) && (s != 4)) fl = 0;
} else if ((s != 1) && (s != 3))
fl = 0;
}
if (fl) res += solve(st + 2, pos + 1);
fl = 1;
for (int i = 0; i < (int)rs[en - 1].size(); i++) {
p = rs[en - 1][i], s = rel[en - 1][p];
if (p == en || p == (en - 1)) {
if ((s == 2) || (s == 1)) fl = 0;
} else if (p < st || p > en) {
if ((s != 2) && (s != 4)) fl = 0;
} else if ((s != 1) && (s != 3))
fl = 0;
}
for (int i = 0; i < (int)rs[en].size(); i++) {
p = rs[en][i], s = rel[en][p];
if (p == (en - 1) || p == en)
http : {
if ((s == 2) || (s == 1)) fl = 0;
}
else if (p < st || p > en) {
if ((s != 2) && (s != 4)) fl = 0;
}
else if ((s != 1) && (s != 3))
fl = 0;
}
if (fl) res += solve(st, pos + 1);
return res;
}
int main() {
cin >> N >> K;
for (int i = 0; i < (int)K; i++) {
int a, b, x;
string s;
cin >> a >> s >> b;
for (int i = 0; i < (int)5; i++)
if (s == sign[i]) {
x = i;
break;
}
rs[a].push_back(b);
rs[b].push_back(a);
rel[a][b] = x;
rel[b][a] = rev[x];
}
memset(dp, -1, sizeof(dp));
cout << solve(1, 1) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
vector<pair<int, pair<int, int> > > ans;
vector<int> adj[maxn];
int sub[maxn], n, cen, prv;
bool Mark[maxn];
void dfs_do(int v, int par = -1) {
sub[v] = 1;
for (auto u : adj[v])
if (u != par) {
dfs_do(u, v);
sub[v] += sub[u];
}
}
void find_cen(int sr) {
dfs_do(sr);
for (int v = 0; v < n; v++) {
bool okay = true;
for (auto u : adj[v])
if (sub[v] > sub[u] && sub[u] * 2 > n) okay = false;
if (sub[v] * 2 < n) okay = false;
if (okay) Mark[v] = true;
}
}
void dfs_str(int v, int par, int root) {
for (auto u : adj[v])
if (u != par) {
if (prv != u) ans.push_back({cen, {prv, u}});
if (v != root) ans.push_back({u, {v, root}});
prv = u;
dfs_str(u, v, root);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int v, u;
cin >> v >> u;
v--, u--;
adj[v].push_back(u);
adj[u].push_back(v);
}
find_cen(0);
vector<int> cens;
for (int v = 0; v < n; v++)
if (Mark[v]) cens.push_back(v);
for (int i = 0; i < cens.size(); i++) {
cen = cens[i];
for (auto v : adj[cen]) {
if (Mark[v]) continue;
prv = v;
dfs_str(v, cen, v);
if (prv != v) ans.push_back({cen, {prv, v}});
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first + 1 << ' ' << ans[i].second.first + 1 << ' '
<< ans[i].second.second + 1 << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
const int MOD = 1000003;
string s[N];
int n, m;
int row[N][2], col[N][2];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') continue;
row[i][(j & 1) ^ (s[i][j] < '3')] = 1;
col[j][(i & 1) ^ (s[i][j] == '1' || s[i][j] == '4')] = 1;
}
}
int ans = 1;
for (int i = 0; i < n; i++) ans = (ans * (2 - row[i][0] - row[i][1])) % MOD;
for (int i = 0; i < m; i++) ans = (ans * (2 - col[i][0] - col[i][1])) % MOD;
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s[2000 + 5];
int a[2000 + 5];
map<pair<pair<int, int>, int>, int> f;
map<pair<pair<int, int>, int>, bool> g;
int val(int id1, int id2) {
for (int i = 0; i < min(s[id1].length(), s[id2].length()); i++)
if (s[id1][i] != s[id2][i]) return i;
return min(s[id1].length(), s[id2].length());
}
int dfs(int l, int r, int k) {
if (k == 0) return 0;
if (l == r) {
if (k <= 1) return 0;
return -1e9;
}
if (g[make_pair(make_pair(l, r), k)]) return f[make_pair(make_pair(l, r), k)];
g[make_pair(make_pair(l, r), k)] = true;
int id = l;
for (int i = l + 1; i < r; i++)
if (a[i] < a[id]) id = i;
int ans = -1e9;
for (int i = 0; i <= k; i++)
ans = max(ans, dfs(l, id, i) + dfs(id + 1, r, k - i) + a[id] * i * (k - i));
return f[make_pair(make_pair(l, r), k)] = ans;
}
int main() {
int n, k, r, i;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) cin >> s[i];
sort(s + 1, s + n + 1);
for (i = 1; i < n; i++) a[i] = val(i, i + 1);
printf("%d\n", dfs(1, n, k));
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, tmp, a[200015], b[200015], d1 = 0, d2 = 0;
unsigned long long t1 = 0, t2 = 0;
bool last;
int ss() {
if (t1 > t2) return 1;
if (t2 > t1) return 2;
long long xxx = min(d1, d2);
for (long long i = 0; i < xxx; i++) {
if (a[i] > b[i])
return 1;
else if (b[i] > a[i])
return 2;
}
if (d1 > xxx) return 1;
if (d2 > xxx) return 2;
if (last)
return 1;
else
return 2;
}
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> tmp;
if (tmp > 0) {
a[d1] = tmp;
d1++;
t1 += tmp;
last = true;
} else {
tmp = -tmp;
b[d2] = tmp;
d2++;
t2 += tmp;
last = false;
}
}
tmp = ss();
if (tmp == 1)
cout << "first";
else
cout << "second";
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool check(int x) {
int num = 0;
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
++num;
while (x % i == 0) x /= i;
if (x == 0) break;
}
}
if (x != 1) ++num;
return num == 2;
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
int res = 0;
for (int i = 6; i <= n; ++i) res += check(i);
printf("%d\n", res);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int main() {
scanf("%d%d%d", &n, &a, &b);
printf("%d", n - max(a + 1, n - b) + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, tot, pri[9] = {2, 3, 5, 7, 11, 13, 17, 19, 23}, top;
long long m, x, a[50005], b[50005], f[50005], l[50005], prime[105];
std::map<long long, int> id;
long long gcd(long long x, long long y) {
if (!y)
return x;
else
return gcd(y, x % y);
}
long long mul(long long x, long long y, long long mo) {
x %= mo;
y %= mo;
long long ans = (x * y - (long long)((double)x * y / mo + 0.1) * mo) % mo;
ans += ans < 0 ? mo : 0;
return ans;
}
long long ksm(long long x, long long y, long long mo) {
long long ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x, mo);
x = mul(x, x, mo);
y >>= 1;
}
return ans;
}
bool MR(long long n) {
if (n == 2) return 1;
if (n % 2 == 0) return 0;
long long w = n - 1;
int lg = 0;
while (w % 2 == 0) w /= 2, lg++;
for (int i = 0; i < 9; i++) {
if (n == pri[i]) return 1;
long long x = ksm(pri[i], w, n);
for (int j = 0; j < lg; j++) {
long long y = mul(x, x, n);
if (x != 1 && x != n - 1 && y == 1) return 0;
x = y;
}
if (x != 1) return 0;
}
return 1;
}
long long rho(long long n) {
long long c = rand() * rand() % (n - 1) + 1, x1 = rand() * rand() % n,
x2 = x1, k = 1, p = 1;
for (int i = 1; p == 1; i++) {
x1 = (mul(x1, x1, n) + c) % n;
if (x1 == x2) return 1;
p = gcd(n, abs(x1 - x2));
if (i == k) k <<= 1, x2 = x1;
}
return p;
}
void divi(long long n) {
if (n == 1) return;
if (MR(n)) {
b[++tot] = n;
return;
}
long long p = 1;
while (p == 1) p = rho(n);
divi(p);
divi(n / p);
}
void pre() {
for (long long i = 1; i * i <= m; i++)
if (m % i == 0) {
a[++n] = i;
if (m / i != i) a[++n] = m / i;
}
std::sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) id[a[i]] = i;
long long tmp = m;
for (long long i = 2; i * i <= tmp; i++)
if (tmp % i == 0) {
prime[++top] = i;
while (tmp % i == 0) tmp /= i;
}
if (tmp > 1) prime[++top] = tmp;
}
int main() {
scanf("%lld%lld", &m, &x);
pre();
for (int i = 1; i <= n; i++) f[i] = m / a[i] - 1;
for (int j = 1; j <= top; j++)
for (int i = 1; i <= n; i++)
if (a[i] % prime[j] == 0) f[id[a[i] / prime[j]]] -= f[i];
for (int i = n; i >= 1; i--) {
l[i] = a[i];
for (int j = 1; j <= top; j++)
if (l[i] % prime[j] == 0) l[i] = l[i] / prime[j] * (prime[j] - 1);
tot = 0;
divi(l[i]);
std::sort(b + 1, b + tot + 1);
tot = std::unique(b + 1, b + tot + 1) - b - 1;
for (int j = 1; j <= tot; j++)
while (l[i] % b[j] == 0 && ksm(x, l[i] / b[j], a[i]) == 1) l[i] /= b[j];
}
long long ans = 1;
for (int i = 1; i < n; i++) {
int j;
for (j = 1; a[j] != m / a[i]; j++)
;
ans += f[i] / l[j];
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
char s[1000 + 10];
int ba1;
char ba2[4];
string ex[4][10] = {
{"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"},
{"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"},
{"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"},
{"", "M", "MM", "MMM"},
};
void solve() {
int i = 0, len = strlen(s);
while (i < len && s[i] == '0') i++;
if (i == len) {
puts("0");
return;
}
long long dec = 0;
while (i < len) {
int t;
if (s[i] >= '0' && s[i] <= '9') {
t = s[i] - '0';
} else {
t = 10 + s[i] - 'A';
}
dec = dec * ba1 + t;
i++;
}
if (ba2[0] == 'R') {
string res = "";
res = ex[3][dec / 1000] + ex[2][(dec % 1000) / 100] +
ex[1][(dec % 100) / 10] + ex[0][dec % 10];
cout << res << endl;
} else {
int B;
sscanf(ba2, "%d", &B);
int l = 0;
while (dec > 0) {
int t = dec % B;
dec /= B;
if (t < 10) {
s[l++] = t + '0';
} else {
s[l++] = 'A' + t - 10;
}
}
for (i = l - 1; i >= 0; i--) {
putchar(s[i]);
}
puts("");
}
}
int main() {
scanf("%d%s%s", &ba1, ba2, s);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> q;
long long int uo = -9223372036854775807;
long long int a[58], b[58];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
int u, o;
long long int ou = 9223372036854775807;
int k = 0, j = 0, ji;
for (int i = 0; i < n; i++) {
uo = -9223372036854775807;
while (k < n) {
if (k != i) {
while (j < m) {
if (k != i && a[k] * b[j] > uo) {
uo = a[k] * b[j];
}
j++;
}
}
k++;
j = 0;
}
k = 0;
ou = min(ou, uo);
}
cout << ou;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, last, dif = 0, cl = 0, ans[100005];
void setup() {
cin >> s;
n = s.length();
for (int i = n - 1; i >= 0; i--) {
cl += (s[i] == ')');
if (s[i] == '#') {
last = i;
break;
}
}
}
void xuly() {
int r = 0;
for (int i = 0; i <= n - 1; i++) {
if (s[i] == '#') {
if (i == last) {
int op = s.length() - i - 1 - cl;
int needToAdd = dif + op - cl;
if (needToAdd <= 0) {
cout << -1;
return;
}
dif -= needToAdd;
ans[++r] = needToAdd;
} else {
s[i] = ')';
ans[++r] = 1;
}
}
dif -= (s[i] == ')');
dif += (s[i] == '(');
if (dif < 0) {
cout << -1;
return;
}
}
for (int i = 1; i <= r; i++) cout << ans[i] << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
setup();
xuly();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[101][101];
int n;
int ok;
void dfs(int s, int sum, int l) {
if (s == n) {
double temp = sqrt(sum);
if (temp == floor(temp)) ok = 1;
return;
}
for (int i = 1; i <= l && ok == 0; ++i) {
a[n][s] = i;
dfs(s + 1, sum + i * i, i);
}
return;
}
int main() {
for (n = 1; n <= 100; ++n) {
ok = 0;
dfs(0, 0, 10000000);
}
int m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) printf("%d ", a[n][i] * a[m][j]);
puts("");
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 55;
int n, rt, m, du[M], cot[M], edge[M][M], dp[M][M][M][M], g[2][M];
vector<int> mmp[M];
void in() {
int a, b, c;
scanf("%d", &n);
for (int i = 1; i < n; ++i)
scanf("%d%d%d", &a, &b, &c), mmp[a].push_back(b), mmp[b].push_back(a),
edge[a][b] = edge[b][a] = c, ++du[a], ++du[b];
scanf("%d%d", &rt, &m);
for (int i = 1; i <= m; ++i) scanf("%d", &a), ++cot[a];
}
void dfs(int v, int f) {
int to;
for (int i = mmp[v].size() - 1; i >= 0; --i) {
to = mmp[v][i];
if (to == f) continue;
dfs(to, v);
cot[v] += cot[to];
}
}
int dfs2(int f, int v, int s1, int s2) {
if (!s1 && !s2) return 0;
if (!s1) return 1061109567;
if (dp[f][v][s1][s2] < 1061109567) return dp[f][v][s1][s2];
if (du[v] == 1) {
dp[f][v][s1][s2] = dfs2(v, f, s2, 0) + edge[f][v];
return dp[f][v][s1][s2];
}
int to, dis, p = 0;
for (int i = mmp[v].size() - 1; i >= 0; --i) {
to = mmp[v][i];
if (to == f) continue;
for (int j = 0; j <= s1; ++j) dfs2(v, to, j, s1 + s2 - j);
}
memset(g[1], 0, sizeof(g[1]));
g[1][0] = 1061109567;
for (int i = mmp[v].size() - 1; i >= 0; --i) {
to = mmp[v][i];
if (to == f) continue;
memset(g[p], 0, sizeof(g[p]));
for (int j = 0; j <= s1; ++j)
for (int k = 0; j + k <= s1; ++k)
g[p][j + k] =
max(g[p][j + k], min(g[p ^ 1][j], dfs2(v, to, k, s1 + s2 - k)));
p ^= 1;
}
dp[f][v][s1][s2] = g[!p][s1] + edge[f][v];
return dp[f][v][s1][s2];
}
void ac() {
int mn = 1061109567, to;
dfs(rt, 0);
memset(dp, 63, sizeof(dp));
for (int i = mmp[rt].size() - 1; i >= 0; --i) {
to = mmp[rt][i];
mn = min(mn, dfs2(rt, to, cot[to], m - cot[to]));
}
printf("%d", mn);
}
int main() {
in();
ac();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
const int MAXN = 222;
int n;
long long m;
template <int N>
struct Matrix {
long long mat[N][N];
Matrix(long long x) {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) mat[i][j] = i == j ? x : -1;
}
long long* operator[](int I) { return mat[I]; }
Matrix operator*(Matrix rhs) {
Matrix ret(-1);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < N; k++) {
if (mat[i][k] < 0 or rhs[k][j] < 0) continue;
ret[i][j] = max(ret[i][j], mat[i][k] + rhs[k][j]);
}
return ret;
}
Matrix operator^(long long b) {
Matrix ret(0), a(*this);
for (; b; b >>= 1, a = a * a) {
if (b & 1) ret = ret * a;
}
return ret;
}
};
using matrix = Matrix<207>;
struct Aho_chrosick {
int tot, ch[MAXN][26], fail[MAXN], w[MAXN];
vector<int> G[MAXN];
Aho_chrosick() {
tot = 0;
memset(ch, 0, sizeof(ch));
}
void insert(char* s, int wt) {
int u = 0;
for (int i = 0; s[i]; i++) {
int c = s[i] - 'a';
if (!ch[u][c]) ch[u][c] = ++tot;
u = ch[u][c];
}
w[u] += wt;
}
void buildFail() {
queue<int> que;
for (int c = 0; c < 26; c++) {
if (!ch[0][c]) continue;
fail[ch[0][c]] = 0;
que.push(ch[0][c]);
}
while (!que.empty()) {
int u = que.front();
que.pop();
for (int c = 0; c < 26; c++) {
if (!ch[u][c]) {
ch[u][c] = ch[fail[u]][c];
continue;
}
int v = ch[u][c];
que.push(v);
int p = fail[u];
while (p and !ch[p][c]) p = fail[p];
fail[v] = ch[p][c];
}
}
for (int i = 1; i <= tot; i++) G[fail[i]].push_back(i);
}
void dfs(int u) {
for (int v : G[u]) w[v] += w[u], dfs(v);
}
} aho;
int awd[MAXN];
char buf[MAXN];
matrix M(-1), F(-1);
void solve() {
scanf("%d %lld", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &awd[i]);
for (int i = 1; i <= n; i++) {
scanf("%s", buf);
aho.insert(buf, awd[i]);
}
aho.buildFail();
aho.dfs(0);
F[0][0] = 0;
for (int i = 0; i <= aho.tot; i++)
for (int c = 0; c < 26; c++) {
M[i][aho.ch[i][c]] = aho.w[aho.ch[i][c]];
}
M = F * (M ^ m);
long long ret = 0;
for (int i = 0; i <= aho.tot; i++) ret = max(ret, M[0][i]);
cout << ret << endl;
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int m[4][4];
int main() {
int x1, x2, x3;
int y1, y2, y3;
int z1, z2, z3;
scanf("%d %d %d", &x1, &y1, &z1);
scanf("%d %d %d", &x2, &y2, &z2);
scanf("%d %d %d", &x3, &y3, &z3);
long long W = x2 + x3 + y1 + y3 + z1 + z2;
W /= 2;
x1 = W - x2 - x3;
y2 = W - y1 - y3;
z3 = W - z1 - z2;
printf("%d %d %d\n", x1, y1, z1);
printf("%d %d %d\n", x2, y2, z2);
printf("%d %d %d\n", x3, y3, z3);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
bool allzero() {
int s = a.size();
for (int i = 0; i < s; i++)
if (a[i] == '1') return false;
return true;
}
bool hasone() {
int s = b.size();
for (int i = 0; i < s; i++) {
if (b[i] == '1') return true;
}
return false;
}
int main() {
cin >> a >> b;
if (a == b) {
puts("YES");
} else if (a.size() != b.size()) {
puts("NO");
} else if (allzero()) {
puts("NO");
} else if (hasone() && !allzero()) {
puts("YES");
} else {
puts("NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
template <typename T, typename U>
inline void swap(T &a, U &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
inline void swap(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
inline void swap(long long &a, long long &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (b > a) a = b;
}
template <typename T, typename U>
inline void smin(T &a, U b) {
if (b < a) a = b;
}
inline int gcd(int a, int b) {
if (a < b) swap(a, b);
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
long long nchose(int a, int b) {
long long ans = 1;
smax(a, b - a);
int p = 2;
for (int i = (b - a + 1); i <= (b); i++) {
ans *= (long long)i;
while (p <= a && ans % p == 0) ans /= p++;
}
return ans;
}
using namespace std;
static long long MOD = 1000000009;
long long n, m;
int main() {
cin >> n >> m;
long long ans = 1, three = 3;
while (n > 0) {
if (n % 2) ans *= three;
three *= three;
n /= 2;
ans %= m;
three %= m;
}
ans = ans - 1;
if (ans < 0) ans += m;
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T f_min(T x, T y) {
return x < y ? x : y;
}
template <class T>
T f_max(T x, T y) {
return x > y ? x : y;
}
template <class T>
T f_abs(T x) {
return x < 0 ? -x : x;
}
template <class T>
T gcd(T x, T y) {
while (T t = x % y) x = y, y = t;
return y;
}
const double eps = 1e-9;
const double PI = acos(-1.);
const int INF = 1000000000;
const int MOD = 1000000007;
const double E = 2.7182818284590452353602874713527;
bool isdig(char x) { return x >= '0' && x <= '9'; }
bool isup(char x) { return x >= 'A' && x <= 'Z'; }
bool isdown(char x) { return x >= 'a' && x <= 'z'; }
bool islet(char x) { return isup(x) || isdown(x); }
int N, K, num[100005];
void get_data() {
cin >> N >> K;
for (int i = 0; i < N; i++) cin >> num[i];
}
int red[100005];
void run() {
int tot = 0;
for (int i = 1; i <= N - 1; i++) {
if (num[i] != num[i - 1]) tot++;
}
memset(red, 0, sizeof(red));
;
int s, e;
for (s = 0; s < N; s = e) {
for (e = s; e < N && num[e] == num[s]; e++)
;
int bf, af, org = 0, now = 0;
if (s)
bf = num[s - 1], org++;
else
bf = -1;
if (e < N)
af = num[e], org++;
else
af = -2;
if (af >= 0 && bf >= 0 && af != bf)
now = 1;
else
now = 0;
red[num[s]] += now - org;
}
int res = 1;
for (int i = 1; i <= K; i++) {
if (red[i] < red[res]) res = i;
}
cout << res << endl;
}
int main() {
get_data();
run();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
scanf("%d %d", &n, &m);
char arr[n][m];
int flag = 0;
int marked[n];
memset(marked, 0, sizeof marked);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i % 2 == 0)
arr[i][j] = '#';
else if (flag == 0 && j == m - 1 && !marked[i]) {
arr[i][j] = '#';
flag = 1;
marked[i]++;
} else if (flag == 1 && j == 0 && !marked[i]) {
arr[i][j] = '#';
flag = 0;
marked[i]++;
} else
arr[i][j] = '.';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", arr[i][j]);
}
printf("\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void func() {
int n, m;
cin >> n >> m;
int arr[n + 1];
for (int i = 1; i <= (n); i++) cin >> arr[i];
unordered_map<int, unordered_set<int>> mm, vis;
int a, b;
for (int i = 1; i <= (m); i++) {
cin >> a >> b;
mm[a].insert(b);
}
int pos = n;
while (1) {
for (int i = pos; i >= 1;) {
if (mm[arr[i - 1]].count(arr[i])) {
if (vis[arr[i]].count(arr[i - 1])) {
i--;
continue;
}
vis[arr[i - 1]].insert(arr[i]);
swap(arr[i - 1], arr[i]);
i++;
if (i > pos) {
pos--;
break;
}
continue;
}
i--;
if (i == 0) {
cout << n - pos;
return;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
func();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
string a[100];
cin >> n >> m;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (a[i][j] == '.') {
a[i][j] = ((i + j) % 2 == 1) ? 'W' : 'B';
}
for (i = 0; i < n; i++) cout << a[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
const int N = 350, mo = 1e9 + 7;
int n, f[N][N], len, A[N], fac[N], ifac[N], qz[N];
map<int, int> Map;
inline void exgcd(int a, int b, int &x, int &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
inline int inv(int a) {
int x, y;
exgcd(a, mo, x, y);
return x >= 0 ? x : x + mo;
}
inline int C(int n, int m) {
if (m < 0 || m > n) return 0;
return 1LL * fac[n] * ifac[m] % mo * ifac[n - m] % mo;
}
inline void add(int &a, int b) { a = a + b < mo ? a + b : a + b - mo; }
int main() {
read(n);
for (register int i = 1; i <= n; i++) {
int x;
read(x);
for (register int j = 2; j * j <= x; j++) {
while (x % (j * j) == 0) x /= j * j;
}
Map[x]++;
}
while (!Map.empty()) {
A[++len] = (*Map.begin()).second;
qz[len] = qz[len - 1] + A[len];
Map.erase(Map.begin());
}
fac[0] = 1;
for (register int i = 1; i <= n; i++) fac[i] = 1LL * fac[i - 1] * i % mo;
ifac[n] = inv(fac[n]);
for (register int i = n - 1; i >= 0; i--)
ifac[i] = 1LL * ifac[i + 1] * (i + 1) % mo;
f[0][0] = 1;
for (register int i = 0; i <= len - 1; i++)
for (register int j = 0; j <= n + 1; j++)
if (f[i][j]) {
int now = f[i][j];
int red = j, blue = qz[i] - j + 1;
for (register int a = 0; a <= blue; a++)
for (register int b = min(red, A[i + 1] - a); b >= 0; b--)
if (a + b <= A[i + 1])
add(f[i + 1][j - b + A[i + 1] - a - b],
1LL * now * C(blue, a) % mo * C(red, b) % mo *
C(A[i + 1] - 1, a + b - 1) % mo * fac[A[i + 1]] % mo);
}
cout << f[len][0];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, l = -1, sum, i, j, d = -1;
cin >> n >> k;
for (i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (2 * n / (i * k) >= k + 1) d = max(i, d);
if (2 * i / k >= k + 1) d = max(n / i, d);
}
}
if (d == -1)
cout << "-1";
else {
for (i = 1; i < k; i++) cout << i * d << " ";
cout << n - d * k * (k - 1) / 2;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 17;
const int DEG = N << 1;
int lvl[N], up[N], d[N], n, m, k, root, a, b, color[N], st[DEG << 1], in[N],
cnt, l, i, A[N], B[N];
vector<int> g[N], g_ind[N];
bool edge[N << 2];
void dfs(int v, int pr, int cur) {
lvl[v] = cur;
up[v] = n + 1;
int i, u, ind, sz = g[v].size();
for (i = 0; i < sz; i++) {
u = g[v][i];
ind = g_ind[v][i];
if (!lvl[u]) {
dfs(u, v, cur + 1);
up[v] = min(up[v], up[u]);
if (up[u] > lvl[v]) edge[ind] = 1;
} else if (u != pr)
up[v] = min(up[v], lvl[u]);
}
}
void condence(int v, int c) {
color[v] = c;
int i, u, sz = g[v].size();
for (i = 0; i < sz; i++) {
u = g[v][i];
if (!color[u]) condence(u, c);
}
}
void calc_lca(int v, int cur, int dist) {
d[v] = dist;
st[DEG + l++] = cur;
if (!in[v]) in[v] = l;
int i, u, sz = g[v].size();
for (i = 0; i < sz; i++) {
u = g[v][i];
if (!in[u]) {
calc_lca(u, cur + 1, dist + 1);
st[DEG + l++] = cur;
}
}
}
int lca(int a, int b) {
int l = DEG + in[a] - 1, r = DEG + in[b] - 1, res = n + 1;
if (l > r) swap(l, r);
while (l <= r) {
res = min(res, min(st[l], st[r]));
l = (l + 1) / 2;
r = (r - 1) / 2;
}
return res;
}
int main() {
scanf("%d %d", &n, &m);
root = 1;
for (i = 0; i < m; i++) {
scanf("%d %d", A + i, B + i);
a = A[i];
b = B[i];
g[a].push_back(b);
g_ind[a].push_back(i);
g[b].push_back(a);
g_ind[b].push_back(i);
}
dfs(root, 0, 1);
for (i = 1; i <= n; i++) g[i].clear();
for (i = 0; i < m; i++) {
a = A[i];
b = B[i];
if (!edge[i]) {
g[a].push_back(b);
g[b].push_back(a);
}
}
for (i = 1; i <= n; i++)
if (!color[i]) condence(i, ++cnt);
for (i = 1; i <= n; i++) g[i].clear();
n = cnt;
root = color[root];
for (i = 0; i < m; i++) {
a = A[i];
b = B[i];
a = color[a];
b = color[b];
if (a != b) {
g[a].push_back(b);
g[b].push_back(a);
}
}
calc_lca(root, 1, 0);
for (i = DEG + l; i < (DEG << 1); i++) st[i] = n + 1;
for (i = DEG - 1; i > 0; i--) st[i] = min(st[i * 2], st[i * 2 + 1]);
scanf("%d", &k);
for (i = 0; i < k; i++) {
scanf("%d %d", &a, &b);
a = color[a];
b = color[b];
printf("%d\n", d[a] + d[b] - 2 * (lca(a, b) - 1));
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int mo = 1e9 + 7;
int inv(int x) {
return x == 1 ? x : (long long)(mo - mo / x) * inv(mo % x) % mo;
}
int n, m, a[N], f[N];
int main() {
scanf("%d", &m);
for (int i = 0; i < m; ++i) scanf("%d", &a[i]), n += a[i];
f[0] = 0;
f[1] = (long long)(n - 1) * (n - 1) % mo * inv(n) % mo;
for (int i = 2; i < N && i <= n; ++i) {
long long delta =
2 * f[i - 1] - f[i - 2] - (long long)(n - 1) * inv(n - i + 1) % mo;
f[i] = delta = (mo + delta % mo) % mo;
}
int ans = 0;
for (int i = 0; i < m; ++i) ans = (ans + f[a[i]]) % mo;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long st[4 * 100005][12];
long long ar[100005], n, K;
void print(long long id, long long l, long long r, long long k) {
cout << st[id][k] << " " << id << " " << l << " " << r << endl;
if (l == r) {
return;
}
long long mid = (l + r) / 2;
print(id * 2, l, mid, k);
print(id * 2 + 1, mid + 1, r, k);
}
void build(long long id, long long l, long long r, long long k) {
if (l == r) {
st[id][k] = ar[l];
return;
}
long long mid = (l + r) / 2;
build(id * 2, l, mid, k);
build(id * 2 + 1, mid + 1, r, k);
st[id][k] = (st[id * 2][k] + st[id * 2 + 1][k]);
}
long long query(long long id, long long l, long long r, long long x,
long long y, long long k) {
if (l > y || r < x || l > r) {
return 0;
}
if (l >= x && r <= y) {
return st[id][k];
}
long long mid = (l + r) >> 1;
return (query(id * 2, l, mid, x, y, k) +
query(id * 2 + 1, mid + 1, r, x, y, k));
}
void update(long long id, long long l, long long r, long long x, long long val,
long long k) {
long long mid = (l + r) >> 1;
if (l == r && x == l) {
st[id][k] = val;
return;
}
if (x <= mid)
update(id * 2, l, mid, x, val, k);
else
update((id * 2) + 1, mid + 1, r, x, val, k);
st[id][k] = (st[id * 2][k] + st[(id * 2) + 1][k]);
}
int main() {
memset(st, 0, sizeof st);
scanf("%I64d", &n);
scanf("%I64d", &K);
for (int i = 0; i < n; i++) scanf("%I64d", &ar[i]);
for (int i = 0; i < n; i++) {
for (int k = 0; k < K + 1; k++) {
if (k == 0)
update(1, 1, n, ar[i], 1, k);
else {
long long q = query(1, 1, n, 1, ar[i] - 1, k - 1);
update(1, 1, n, ar[i], q, k);
}
}
}
printf("%I64d", query(1, 1, n, 1, 100005, K));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
const int inf = 1e9 + 7;
int a[N], dp[2][N];
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < N; i++) {
for (int _ = 0; _ < 2; _++) {
dp[_][i] = inf;
}
}
int lastNotUsedBadElement = -1;
for (int i = 0; i < n; i++) {
if (i) {
*upper_bound(dp[1], dp[1] + n, a[i] - i + 1) = a[i] - i + 1;
dp[1][lastNotUsedBadElement] =
min(dp[1][lastNotUsedBadElement], a[i - 1] - i + 1);
}
lastNotUsedBadElement = upper_bound(dp[0], dp[0] + n, a[i] - i) - dp[0];
dp[0][lastNotUsedBadElement] = a[i] - i;
}
int answer = lower_bound(dp[1], dp[1] + n, inf) - dp[1];
printf("%d\n", max(0, n - answer - 1));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int n, m;
int main() {
cin >> n >> m;
int k;
for (int i = 1; i <= n; i++) {
cin >> k;
a.push_back(k);
}
sort(a.begin(), a.end());
int calc = 0, sum = 0;
for (vector<int>::iterator ii = a.begin(); ii != a.end(); ii++) {
if (calc == m) break;
if (*ii > 0) break;
sum += *ii;
calc++;
}
cout << -sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool RD(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 PT(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) PT(x / 10);
putchar(x % 10 + '0');
}
const int N = 22;
const int MOD = 1e9 + 7;
struct mat {
int a[N][N];
mat() { memset(a, 0, sizeof(a)); }
int r, c;
mat operator*(const mat &m) const {
mat ans;
ans.r = r;
ans.c = m.c;
for (int i = 1; i <= int(r); i++)
for (int j = 1; j <= int(ans.c); j++)
for (int k = 1; k <= int(c); k++) {
ans.a[i][j] += ((unsigned long long)a[i][k] * m.a[k][j]) % MOD;
if (ans.a[i][j] >= MOD) ans.a[i][j] -= MOD;
}
return ans;
}
} all[1111];
int top;
mat mul(mat &m1, mat &m2) {
mat ans = all[top++];
memset(ans.a, 0, sizeof(ans.a));
ans.r = m1.r;
ans.c = m2.c;
for (int i = 1; i <= int(ans.r); i++)
for (int j = 1; j <= int(ans.c); j++)
for (int k = 1; k <= int(m1.c); k++) {
ans.a[i][j] += ((unsigned long long)m1.a[i][k] * m2.a[k][j]) % MOD;
if (ans.a[i][j] >= MOD) ans.a[i][j] -= MOD;
}
top--;
return ans;
}
void quickpow(mat &ans, mat m, int k) {
if (k == 1) {
ans = m;
return;
}
if (k % 2 == 0) {
quickpow(ans, m, k / 2);
ans = ans * ans;
return;
}
quickpow(ans, m, k / 2);
ans = ans * ans;
ans = ans * m;
}
int r, c, Q;
bool mp[N][N];
mat A, M;
inline int f(int x, int y) { return (x - 1) * c + y; }
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
bool ok(int x, int y) {
return x >= 1 && x <= r && y >= 1 && y <= c && !mp[x][y];
}
void build() {
memset(M.a, 0, sizeof(M.a));
M.r = r * c;
M.c = r * c;
for (int x = 1; x <= int(r); x++)
for (int y = 1; y <= int(c); y++) {
for (int k = 0; k < int(4); k++) {
int nx = x + dx[k];
int ny = y + dy[k];
if (ok(nx, ny) && !mp[x][y]) M.a[f(x, y)][f(nx, ny)] = 1;
}
if (!mp[x][y]) M.a[f(x, y)][f(x, y)] = 1;
}
}
int main() {
scanf("%d%d%d", &r, &c, &Q);
int last = 1;
A.r = r * c;
A.c = 1;
A.a[1][1] = 1;
for (int i = 1; i <= int(Q); i++) {
int op;
RD(op);
int x, y, t;
RD(x), RD(y), RD(t);
build();
mat tmp;
quickpow(tmp, M, t - last);
A = tmp * A;
last = t;
if (op == 1)
printf("%d\n", A.a[f(x, y)][1]);
else if (op == 2)
A.a[f(x, y)][1] = 0, mp[x][y] = 1;
else
mp[x][y] = 0;
}
}
| 8 |
#include <bits/stdc++.h>
int Q;
long long N, K, E;
int main() {
scanf("%d", &Q);
for (int qi = 0; qi < Q; qi++) {
scanf("%lld", &N);
K = sqrt(2.0 * ((double)N) + 1.0 / 4) - 0.5;
E = K * (K - 1) / 2;
printf("%lld\n", (N - K >= E + 3) ? 2 * (N - K - 1) : E + N - K);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int p[1000001];
char s[1000005];
int x[27];
int main() {
scanf("%s", &s);
int len = 0;
p[len] = 0;
int i = 1;
int length = strlen(s) - 1;
while (i < strlen(s)) {
if (s[i] == s[len]) {
len++;
p[i] = len;
i++;
} else {
if (len != 0) {
len = p[len - 1];
} else {
p[i] = 0;
i++;
}
}
}
if (p[length] == 0) {
printf("Just a legend");
return 0;
}
for (i = 0; i < length; i++) {
if (p[i] == p[length]) break;
}
if (i < length) {
for (i = 0; i < p[length]; i++) printf("%c", s[i]);
return 0;
}
int d = p[length];
d = p[d - 1];
if (d == 0) {
printf("Just a legend");
} else {
for (i = 0; i < d; i++) printf("%c", s[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
int mask = 1;
for (int i = 2; i < 32; i++) {
if (n % ((mask << i) - 1) == 0) {
cout << n / ((mask << i) - 1) << endl;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(0);
int tes;
cin >> tes;
while (tes--) {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int till = INT_MIN;
int ans = 0;
for (int i = 0; i < n; i++) {
if (v[i] <= till) {
ans = max(ans, till - v[i]);
} else {
till = v[i];
}
}
int ind = 0;
while (ans) {
ans = ans / 2;
ind++;
}
cout << ind << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, is[1050], fg;
void doit(int a, int b) {
if (a > b) a ^= b ^= a ^= b;
if (fg && !is[a] && !is[b])
printf("%d %d\n%d %d\n%d %d\n", a, n, a, b, b, n), is[a] = is[b] = 1;
else
printf("%d %d\n", a, b);
}
void doit1(int s) {
doit(s, s + 1);
doit(s + 2, s + 3);
doit(s, s + 3);
doit(s + 1, s + 2);
doit(s, s + 2);
doit(s + 1, s + 3);
}
void doit2(int s, int t) {
for (int i = 1; i <= 4; i++) doit(s + i % 4, t + i % 4);
for (int i = 1; i <= 4; i++) doit(s + i % 4, t + (i + 2) % 4);
for (int i = 1; i <= 4; i++) doit(s + i % 4, t + (i + 1) % 4);
for (int i = 1; i <= 4; i++) doit(s + i % 4, t + (i + 3) % 4);
}
int main() {
scanf("%d", &n);
if (n * (n - 1) / 2 % 2) {
printf("NO\n");
return 0;
}
printf("YES\n");
if (n & 1) fg = 1;
for (int i = 1; i <= n / 4; i++) doit1(i * 4 - 3);
for (int i = 1; i <= n / 4; i++)
for (int j = i + 1; j <= n / 4; j++) doit2(i * 4 - 3, j * 4 - 3);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> arr;
vector<int> dp;
int readData() {
int k;
cin >> n >> k;
arr.assign(n + 1, 0);
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
return k;
}
void initDp() {
vector<bool> used(n + 1, false);
dp.assign(n + 1, 0);
for (int i = 1; i <= n; ++i) {
dp[i] = dp[i - 1] + !used[arr[i]];
used[arr[i]] = true;
}
}
vector<int> tree;
vector<int> toAdd;
int buildTree(int i, int l, int r) {
if (l == r) {
return tree[i] = dp[l];
}
int m = (l + r) / 2;
return tree[i] = max(buildTree(2 * i, l, m), buildTree(2 * i + 1, m + 1, r));
}
void push(int i, int l, int r) {
tree[i] += toAdd[i];
if (l != r) {
toAdd[2 * i] += toAdd[i];
toAdd[2 * i + 1] += toAdd[i];
}
toAdd[i] = 0;
}
void increment(int i, int l, int r, int lt, int rt) {
push(i, l, r);
if (l == lt && r == rt) {
++toAdd[i];
push(i, l, r);
return;
}
int m = (l + r) / 2;
if (lt <= m) {
increment(2 * i, l, m, lt, min(rt, m));
tree[i] = max(tree[i], tree[2 * i]);
}
if (rt > m) {
increment(2 * i + 1, m + 1, r, max(lt, m + 1), rt);
tree[i] = max(tree[i], tree[2 * i + 1]);
}
}
int solveSegment(int i, int l, int r, int lt, int rt) {
push(i, l, r);
if (l == lt && r == rt) {
return tree[i];
}
int m = (l + r) / 2;
int res = 0;
if (lt <= m) {
res = max(res, solveSegment(2 * i, l, m, lt, min(rt, m)));
}
if (rt > m) {
res = max(res, solveSegment(2 * i + 1, m + 1, r, max(lt, m + 1), rt));
}
return res;
}
void updateDp() {
vector<int> start(n + 1, 1);
vector<int> dpNew(n + 1, 0);
tree.assign(4 * n, 0);
toAdd.assign(4 * n, 0);
buildTree(1, 1, n);
dpNew[1] = dp[1];
for (int i = 2; i <= n; ++i) {
increment(1, 1, n, start[arr[i]], i - 1);
start[arr[i]] = i;
dpNew[i] = solveSegment(1, 1, n, 1, i - 1);
}
swap(dp, dpNew);
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
int k = readData();
initDp();
while (--k) {
updateDp();
}
cout << dp[n];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int p[200010], rp[200010], ri[200010];
void pre() {
int t;
p[0] = 1;
rp[0] = rp[1] = 1, ri[1] = 1;
for (int i = 1; i < 200010; i++) {
p[i] = (1ll * p[i - 1] * i) % mod;
}
for (int i = 2; i < 200010; i++) {
t = mod / i;
ri[i] = (1ll * t * (mod - ri[mod % i])) % mod;
rp[i] = (1ll * rp[i - 1] * ri[i]) % mod;
}
}
int x[200010], y[200010], id[200010];
bool cmp(int a, int b) {
if (x[a] != x[b]) return x[a] < x[b];
return y[a] < y[b];
}
int mul(int x, int y) {
if (y == 0) return 1;
int tmp = mul(x, y >> 1);
tmp = (1ll * tmp * tmp) % mod;
if (y & 1) return (1ll * tmp * x) % mod;
return tmp;
}
int wa[200010][25];
int n, m, k, s;
int main() {
pre();
scanf("%d %d %d %d", &n, &m, &k, &s);
for (int i = 0; i < k; i++) {
scanf("%d %d", x + i, y + i);
id[i] = i;
}
sort(id, id + k, cmp);
id[k] = k;
x[k] = n, y[k] = m;
int tot, xx, yy, tmp;
for (int i = 0; i <= k; i++) {
tot = p[x[i] + y[i] - 2];
tot = (1ll * tot * rp[x[i] - 1]) % mod;
tot = (1ll * tot * rp[y[i] - 1]) % mod;
wa[i][0] = tot;
}
for (int i = 0; i < k; i++) {
for (int j = i + 1; j <= k; j++) {
if (y[id[i]] > y[id[j]]) continue;
xx = x[id[j]] - x[id[i]], yy = y[id[j]] - y[id[i]];
tot = p[xx + yy];
tot = (1ll * rp[xx] * tot) % mod;
tot = (1ll * rp[yy] * tot) % mod;
for (int u = 21; u >= 0; u--) {
wa[id[j]][u + 1] = (1ll * wa[id[i]][u] * tot + wa[id[j]][u + 1]) % mod;
wa[id[j]][u] =
(mod - (1ll * wa[id[i]][u] * tot) % mod + wa[id[j]][u]) % mod;
}
}
}
int ans = 0, res;
for (int u = 0; u <= 22; u++) {
ans = (1ll * s * wa[k][u] + ans) % mod;
s = (s + 1) / 2;
}
tmp = (((1ll * p[x[k] - 1] * p[y[k] - 1]) % mod) * rp[x[k] + y[k] - 2]) % mod;
ans = (1ll * ans * tmp) % mod;
printf("%d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#define mod 1e9 + 7
#define FOR(a, c) for (int(a) = 0; (a) < (c); (a)++)
#define FORL(a, b, c) for (int(a) = (b); (a) <= (c); (a)++)
#define FORR(a, b, c) for (int(a) = (b); (a) >= (c); (a)--)
#define INF 1000000000000000003
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define ff first
#define ss second
#define PB push_back
#define POB pop_back
#define MP make_pair
#define nl '\n'
int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
ll ans = 1;
while(ans<=1)
{
ll sumofdigits=0;
ll counter = n;
ll othercounter = n;
while(counter)
{
sumofdigits+=(counter%10);
counter/=10;
}
ans=gcd(n,sumofdigits);
if(ans>1)
cout<<n<<nl;
else
n++;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 4;
struct node {
string str;
int pos, num;
};
node po[N];
int cmp(node x, node y) {
if (x.pos == y.pos) return x.num > y.num;
return x.pos < y.pos;
}
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
cin >> po[i].str >> po[i].pos >> po[i].num;
}
sort(po, po + n, cmp);
if (po[1].pos == po[2].pos) {
if (po[1].num == po[2].num)
cout << "?"
<< "\n";
else
cout << po[0].str << " " << po[1].str << "\n";
} else {
cout << po[0].str << " " << po[1].str << "\n";
}
po[n].pos = po[n - 1].pos;
po[n].num = -1;
for (int i = 2; i < n - 1; i++) {
if (po[i].pos == po[i - 1].pos) continue;
if (po[i + 1].pos == po[i + 2].pos) {
if (po[i + 1].num == po[i + 2].num)
cout << "?"
<< "\n";
else
cout << po[i].str << " " << po[i + 1].str << "\n";
} else
cout << po[i].str << " " << po[i + 1].str << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& n) {
char ch;
int flag = 1;
while (!isdigit(ch = getchar()))
if (ch == '-') flag = -1;
n = ch - '0';
while (isdigit(ch = getchar())) n = n * 10 + ch - '0';
n *= flag;
}
const int INF = 1e9 + 7;
const double eps = 1e-18;
int n = 27, pos1, pos2;
char ch[311];
int ans[3][311];
int main() {
for (int i = 1; i <= n; ++i) {
scanf("%c", &ch[i]);
for (int j = 1; j < i; ++j)
if (ch[i] == ch[j]) pos1 = j, pos2 = i;
}
int r = pos2 - pos1 - 1;
if (r <= 0) {
puts("Impossible");
return 0;
}
if (r % 2 == 0) {
int right = r / 2, dir = 1, col = 13 - right - pos1 + 2, row = 2;
if (col < 1)
for (int i = 1; i <= 1 - col; ++i) ch[++n] = ch[i];
if (pos1 == 1) row = 1, col = 13 - right;
pos1 = 13 - right;
for (int i = 1; i <= n; ++i) {
if (ans[row][col] && col != pos1) {
puts("Impossible");
return 0;
}
ans[row][col] = i;
if (dir == 1 && col == pos1 && row == 2) {
row--;
continue;
}
if (dir == -1 && col == pos1 + 1 && row == 2) {
row--, col--;
continue;
}
col += dir;
if (col == 14 && row == 1) {
row++, dir = -1, col--;
continue;
}
if (col == 0 && row == 1) {
col++, row++, dir = 1;
continue;
}
}
}
if (r % 2 == 1) {
int right = (r - 1) / 2, dir = 1, col = 13 - right - pos1 + 1, row = 2;
if (col < 1)
for (int i = 1; i <= 1 - col; ++i) ch[++n] = ch[i];
if (pos1 == 1) row = 1, col = 13 - right;
pos1 = 13 - right;
for (int i = 1; i <= n; ++i) {
if (ans[row][col] && col != pos1) {
puts("Impossible");
return 0;
}
ans[row][col] = i;
if (dir == 1 && col == pos1 - 1 && row == 2) {
row--, col++;
continue;
}
if (dir == -1 && col == pos1 && row == 2) {
row--;
continue;
}
col += dir;
if (col == 14 && row == 1) {
row++, dir = -1, col--;
continue;
}
if (col == 0 && row == 1) {
col++, row++, dir = 1;
continue;
}
}
}
for (int i = 1; i <= 13; ++i) printf("%c", ch[ans[1][i]]);
puts("");
for (int i = 1; i <= 13; ++i) printf("%c", ch[ans[2][i]]);
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void show(const vector<T> &a) {
for (T x : a) cout << x << " ";
cout << '\n';
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());
vector<long long> xx = {1, 0, -1, 0, 1, -1, 1, -1};
vector<long long> yy = {0, 1, 0, -1, -1, -1, 1, 1};
string dir = "RDLU";
string travel = "ENWS";
const long long N = 1e5 + 50, oo = 3e18 + 500;
const long long mod = 998244353;
const long long M2 = 1000000093, x2 = 27162;
const long long M1 = 1000000087, x1 = 241;
const long double eps = 1e-18, PI = 2 * acos(0.0);
long long n, m, k;
long long cnt = 0;
long long lg = 18;
vector<vector<long long> > g;
vector<vector<long long> > rg;
vector<long long> visit;
long long a[4][N];
long long b[4][N];
vector<long long> check(vector<long long> &n) {
long long j, z, k;
j = z = k = 0;
vector<long long> ret(5, oo);
for (long long i = 0; i < n[0]; i++) {
while (j + 1 < n[1] && b[1][j] < b[0][i]) {
j++;
}
while (z + 1 < n[2] && b[2][z] < b[0][i]) {
z++;
}
while (k + 1 < n[3] && (b[3][k] < b[1][j] || b[3][k] < b[2][z])) {
k++;
}
if (b[3][k] >= b[1][j] && b[3][k] >= b[2][z] && b[1][j] >= b[0][i] &&
b[2][z] >= b[0][i]) {
vector<long long> kek = {b[3][k] - b[0][i], b[0][i], b[1][j], b[2][z],
b[3][k]};
ret = min(ret, kek);
;
}
}
return ret;
}
signed main() {
ios::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
long long k;
cin >> k;
while (k--) {
cin >> n;
long long D = 9 + 8 * (n - 1);
long long y = (-3 + sqrt(D)) / 2;
long long ans = 0;
for (long long yy = max(y - 100, 0ll); yy <= y + 100 && yy <= n - 1; yy++) {
ans = max(ans, n - 1 - yy + min(yy * (yy + 1) / 2, n - 1 - yy));
;
}
cout << ans << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 5;
int n, m;
long long ans;
long long mod = 998244353;
long long int f[1000005];
void work(int n, long long p) {
f[1] = 1;
for (long long i = 2; i <= n; i++) {
f[i] = -(p / i) * f[p % i];
f[i] = (f[i] % p + p) % p;
}
}
long long zu(int a, int b) {
if (a == b) {
return 1;
} else if (a < b) {
return 0;
}
long long int res = 1;
for (int i = b + 1; i <= a; i++) {
res = ((res % mod) * (i % mod)) % mod;
}
for (int i = 1; i <= a - b; i++) {
res = ((res % mod) * (f[i] % mod)) % mod;
}
return res;
}
int main() {
cin >> n >> m;
work(m + 1, mod);
if (n == 2) {
printf("0\n");
return 0;
}
long long mymod = (long long)pow(2, n - 3) % mod;
if (mymod < 0) {
mymod += mod;
}
ans = (zu(m, n - 1) % mod) * ((n - 2) % mod);
for (int i = 1; i <= n - 3; i++) {
ans *= 2;
ans %= mod;
}
printf("%lld\n", ans % mod);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
const int maxl = (int)1e6;
char tmp[maxl];
long long r;
string s;
bool read() {
if (scanf("%lld", &r) < 1) {
return false;
}
scanf(" ");
fgets(tmp, sizeof(tmp), stdin);
s = tmp;
return true;
}
const int maxn = (int)2e5 + 5;
int n;
int t[maxn];
vector<int> g[maxn];
vector<int> rs;
int newRes() {
int v = n++;
g[v].clear();
t[v] = 0;
rs.push_back(v);
return v;
}
void readSpace(int &i) {
while (i < ((int)(s).size()) && isspace(s[i])) {
i++;
}
}
int buildTree(int &i) {
readSpace(i);
if (s[i] == '*') {
i++;
return newRes();
}
assert(s[i] == '(');
i++;
int v = n++;
g[v].clear();
t[v] = -1;
while (true) {
int u = buildTree(i);
g[v].push_back(u);
readSpace(i);
if (s[i] == ')') {
i++;
break;
}
if (s[i] == 'S') {
t[v] = 1;
} else if (s[i] == 'P') {
t[v] = 2;
} else {
assert(false);
}
i++;
}
assert(t[v] != -1);
return v;
}
long long dp[maxn];
void dfs(int v) {
if (t[v] == 0) {
dp[v] = 1;
return;
}
if (t[v] == 1) {
dp[v] = infll;
for (int i = 0; i < ((int)(g[v]).size()); i++) {
int u = g[v][i];
dfs(u);
dp[v] = min(dp[v], dp[u]);
}
return;
}
dp[v] = 0;
for (int i = 0; i < ((int)(g[v]).size()); i++) {
int u = g[v][i];
dfs(u);
dp[v] = min(infll, dp[v] + dp[u]);
}
}
long long ans[maxn];
void getAns(int v, long long need) {
if (t[v] == 0) {
ans[v] = need;
return;
}
if (t[v] == 1) {
int best = -1;
for (int i = 0; i < ((int)(g[v]).size()); i++) {
int u = g[v][i];
if (best == -1 || dp[u] < dp[best]) {
best = u;
}
}
getAns(best, need);
return;
}
for (int i = 0; i < ((int)(g[v]).size()); i++) {
int u = g[v][i];
getAns(u, need);
}
}
void solve() {
n = 0;
rs.clear();
int pos = 0;
int root = buildTree(pos);
dfs(root);
for (int i = 0; i < n; i++) {
ans[i] = 0;
}
getAns(root, dp[root] * r);
printf("REVOLTING ");
for (int i = 0; i < ((int)(rs).size()); i++) {
printf("%lld ", ans[rs[i]]);
}
printf("\n");
}
int main() {
precalc();
int t;
scanf("%d", &t);
while (read()) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 2], b[n + 2], p[n + 2];
for (int i = 0; i < n; ++i) {
int num;
cin >> num;
a[num] = i + 1;
}
for (int j = 0; j < n; ++j) {
int num;
cin >> num;
b[j + 1] = num;
}
int z = 4;
for (int i = 1; i <= n; ++i) {
p[i] = b[a[i]];
}
for (int i = 1; i <= n; ++i) {
cout << p[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double x1, x2;
pair<int, int> lines[100000];
int main() {
int n;
scanf("%d", &n);
scanf("%lf%lf", &x1, &x2);
for (int i = 0; i < n; i++) {
scanf("%d%d", &lines[i].first, &lines[i].second);
}
vector<pair<long long, long long> > debut(n);
for (int i = 0; i < n; i++) {
debut[i].first = lines[i].first * x1 + lines[i].second;
debut[i].second = lines[i].first * x2 + lines[i].second;
}
sort(debut.begin(), debut.end());
bool res = true;
for (int i = 1; i < n; i++) {
if (debut[i].second < debut[i - 1].second) {
res = false;
break;
}
}
if (res) {
printf("NO");
} else {
printf("YES");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b, c, mini;
vector<vector<int>> g;
long long int cost;
pair<int, int> dfs(int curr, int par, int m) {
pair<int, int> p = {0, 0};
if (b[curr] != c[curr]) {
p.first += (b[curr] == 0);
p.second += (b[curr] == 1);
}
for (int i = 0; i < g[curr].size(); i++) {
int s = g[curr][i];
if (s == par) continue;
int mn = min(m, a[curr]);
pair<int, int> a = dfs(s, curr, mn);
p.first += a.first;
p.second += a.second;
}
if (m > a[curr]) {
int solved = min(p.first, p.second);
p.first -= solved;
p.second -= solved;
cost += solved * 2LL * a[curr];
}
return p;
}
int main() {
int n;
cin >> n;
a.resize(n + 1), b.resize(n + 1), c.resize(n + 1);
cost = 0;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i];
g.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
a[0] = INT_MAX;
pair<int, int> p = dfs(1, 0, INT_MAX);
if (!p.first && !p.second)
cout << cost << endl;
else
cout << -1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> graph;
vector<bool> used;
string s;
int clr[26];
void bfs(int v) {
queue<int> q;
q.push(v);
while (!q.empty()) {
auto u = q.front();
q.pop();
if (used[u]) continue;
used[u] = true;
++clr[s[u] - 'a'];
for (auto t : graph[u]) q.push(t);
}
}
void connect(int i, int j) {
graph[i].push_back(j);
graph[j].push_back(i);
}
void solve() {
int n, k;
cin >> n >> k >> s;
graph.assign(n, vector<int>());
used.assign(n, false);
for (int i = 0; i < n / 2; i++) connect(i, n - 1 - i);
for (int i = 0; i < k; i++)
for (int j = k + i; j < n; j += k) connect(i, j);
int ans = 0;
for (int i = 0; i < n; i++) {
if (used[i]) continue;
fill(clr, clr + 26, 0);
bfs(i);
int cmax = -1e9, cnt = 0;
for (int j = 0; j < 26; j++) cmax = max(cmax, clr[j]), cnt += clr[j];
ans += cnt - cmax;
}
cout << ans << '\n';
}
int main(int argc, char** argv) {
ios::sync_with_stdio(false), cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int UNDEF = -1;
const long long INF = 1e18;
template <typename T>
inline bool chkmax(T& aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T& aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
int rint();
char rch();
long long rlong();
const int mn = 5e5 + 2;
char a[mn];
int sum[mn];
int getsum(int l, int r) { return sum[r + 1] - sum[l]; }
int n, t;
int last = -1;
long long f(int mmid) {
int k = mmid;
stack<int> S;
int right = 0;
long long final = 1e18;
long long need = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 'H') {
chkmax(right, i);
if (k == 0) {
if (S.empty()) {
int imin = last, imax = n;
while (imin < imax) {
int imid = (imin + imax) >> 1;
if (getsum(i, imid) < 0)
imin = imid + 1;
else
imax = imid;
}
if (imin < n) {
long long ans = need + right + 1ll + 2ll * (imin - i);
chkmin(final, ans);
}
}
S.push(i);
} else
k--;
} else if (a[i] == 'S') {
if (!S.empty()) {
chkmax(right, i);
int top = S.top();
S.pop();
if (S.empty()) {
int dist = i - top;
if (i < last) dist *= 2;
need += dist;
}
} else {
k++;
}
}
}
if (S.empty()) {
long long ans = need + right + 1;
chkmin(final, ans);
}
return final;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
scanf("%d %d\n%s\n", &n, &t, a);
for (int i = n - 1; i >= 0; i--) {
if (a[i] == 'H') {
last = i;
break;
}
}
int numh = 0;
sum[0] = 0;
for (int i = 0; i < n; i++) {
sum[i + 1] = sum[i];
if (a[i] == 'H') {
sum[i + 1]--;
numh++;
} else if (a[i] == 'S')
sum[i + 1]++;
}
int imin = 0, imax = numh + 1;
while (imin < imax) {
int imid = (imin + imax) >> 1;
long long need = f(imid);
if (need > t)
imin = imid + 1;
else
imax = imid;
}
if (imin >= numh + 1)
printf("-1\n");
else
printf("%d\n", imin);
}
static char stdinBuffer[1024];
static char* stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char* stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int rint() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
char rch() {
readAhead(16);
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
char ans = *stdinPos;
++stdinPos;
return ans;
}
long long rlong() {
readAhead(32);
long long x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[100010], b[100010];
long long l[100010], r[100010];
stack<int> s;
int main() {
int n, q, i, j, x, y;
scanf("%d", &n);
scanf("%d", &q);
for (i = 0; i < n; ++i) scanf("%lld", &b[i]);
for (i = 0; i < n - 1; ++i) a[i] = abs(b[i + 1] - b[i]);
for (i = 0; i < n - 1; ++i) {
while (!s.empty()) {
if (a[s.top()] <= a[i]) {
r[s.top()] = i - 1;
s.pop();
} else {
l[i] = s.top() + 1;
break;
}
}
if (s.empty()) l[i] = 0;
s.push(i);
}
while (!s.empty()) {
r[s.top()] = n - 2;
s.pop();
}
while (q--) {
scanf("%d", &x);
scanf("%d", &y);
--x;
--y;
--y;
long long ans = 0;
for (i = x; i <= y; ++i) {
long long v1 = i - max(l[i], (long long)x) + 1;
long long v2 = min(r[i], (long long)y) - i + 1;
ans = ans + v1 * v2 * a[i];
}
printf("%lld\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vec[105];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) vec[i].push_back(make_pair(i, i));
int ct = 101;
int a, b;
for (int i = 1; i <= k; i++) {
scanf("%d%d", &a, &b);
vec[a].push_back(make_pair(ct, a));
vec[b].push_back(make_pair(ct, b));
ct++;
}
for (int i = 1; i <= n; i++) {
printf("%d\n", vec[i].size());
for (int j = 0; j < vec[i].size(); j++)
printf("%d %d\n", vec[i][j].first, vec[i][j].second);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int lis[20], ln;
void split(int x) {
ln = 0;
int m = sqrt(x);
for (int i = 2; i <= m; i++) {
if (x % i == 0) {
while (x % i == 0) x /= i;
lis[++ln] = i;
}
}
if (x > 1) lis[++ln] = x;
}
int calc(int n, int m) {
int ans = 0;
for (int s = 0; s < 1 << ln; s++) {
int mu = 1, cnt = 0;
for (int i = 1; i <= ln; i++) {
if (s & (1 << (i - 1))) {
mu *= lis[i];
cnt++;
}
}
if (cnt & 1)
ans -= n / mu - m / mu;
else
ans += n / mu - m / mu;
}
return ans;
}
int binary(int k, int w) {
int l = 1, r = 1e7;
while (l <= r) {
int m = (l + r) >> 1;
if (calc(m, w) < k)
l = m + 1;
else
r = m - 1;
}
return l;
}
int T;
int main() {
scanf("%d", &T);
for (int t = 1; t <= T; t++) {
int x, p, k;
scanf("%d%d%d", &x, &p, &k);
split(p);
cout << binary(k, x) << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, s, cnt, ans, Max, A[200000 + 5], T[200000 + 5];
int main() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; i++) {
scanf("%d", A + i);
if (A[i] == 0 && i != s)
cnt++, ans++;
else if (A[i] != 0 && i == s)
ans++, A[i] = 0;
else {
T[A[i]]++;
Max = max(Max, A[i]);
}
}
bool ok = 0;
for (int i = 1; cnt && i <= Max; i++) {
if (!T[i]) T[i] = 1, cnt--;
if (i == Max) ok = 1;
}
if (ok)
printf("%d\n", ans);
else {
for (int i = 1, t = Max; i < t; i++) {
if (!T[i]) T[i] = 1, T[t]--, ans++;
for (; i < t && !T[t]; t--)
;
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
string str;
int M;
int lst[26];
long long DP[2][26];
long long LDP[26][26];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K >> str;
M = (int)(str.size());
for (int i = 1; i <= M; i++) {
int ai = (int)(str[i - 1] - 'a');
for (int j = 0; j <= K - 1; j++) DP[i % 2][j] = DP[(i + 1) % 2][j];
if (lst[ai] == 0) {
for (int j = 0; j <= K - 1; j++)
DP[i % 2][ai] = (DP[i % 2][ai] + DP[(i + 1) % 2][j]) % 1000000007;
DP[i % 2][ai] = (DP[i % 2][ai] + 1) % 1000000007;
} else {
for (int j = 0; j <= K - 1; j++)
DP[i % 2][ai] =
(DP[i % 2][ai] + DP[(i + 1) % 2][j] - LDP[ai][j] + 1000000007) %
1000000007;
}
for (int j = 0; j <= K - 1; j++) LDP[ai][j] = DP[(i + 1) % 2][j];
lst[ai] = i;
}
for (int i = M + 1; i <= M + N; i++) {
int ai = 0;
int mn = i;
for (int j = 0; j <= K - 1; j++)
if (lst[j] < mn) {
ai = j;
mn = lst[j];
}
for (int j = 0; j <= K - 1; j++) DP[i % 2][j] = DP[(i + 1) % 2][j];
if (lst[ai] == 0) {
for (int j = 0; j <= K - 1; j++)
DP[i % 2][ai] = (DP[i % 2][ai] + DP[(i + 1) % 2][j]) % 1000000007;
DP[i % 2][ai] = (DP[i % 2][ai] + 1) % 1000000007;
} else {
for (int j = 0; j <= K - 1; j++)
DP[i % 2][ai] =
(DP[i % 2][ai] + DP[(i + 1) % 2][j] - LDP[ai][j] + 1000000007) %
1000000007;
}
for (int j = 0; j <= K - 1; j++) LDP[ai][j] = DP[(i + 1) % 2][j];
lst[ai] = i;
}
long long now = 0;
for (int i = 0; i <= K - 1; i++)
now = (now + DP[(M + N) % 2][i]) % 1000000007;
now = (now + 1) % 1000000007;
cout << now << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int64_t check_num(int64_t request) {
int64_t steps = 0;
while (request != 1) {
if ((request % 2 != 0) && (request % 3 != 0) && (request % 5 != 0)) {
return -1;
}
if (request % 2 == 0) {
request /= 2;
steps++;
}
if (request % 5 == 0) {
request /= 5;
steps += 3;
}
if (request % 3 == 0) {
request /= 3;
steps += 2;
}
}
return steps;
}
int main() {
uint64_t num_requests;
cin >> num_requests;
while (num_requests--) {
int64_t steps = 0, cur_num;
cin >> cur_num;
steps = check_num(cur_num);
cout << steps << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, H;
bool C(long long x) {
if (x <= H) {
return x * x + x <= 2 * n;
} else {
return 2 * (double)(x * x - n) / (double)(H) <= (double)(H - 1);
}
}
void solve() {
long long ub = 1e9 * 2, lb = 0, mid;
while (ub - lb > 1) {
mid = (ub + lb) / 2;
if (C(mid))
lb = mid;
else
ub = mid;
}
long long res = lb <= H ? lb : lb + lb - H;
n -= (lb + 1) * lb / 2 + (lb <= H ? 0 : (H + lb - 1) * (lb - H) / 2);
for (long long i = min(lb, n); n > 0 && i > 0; i = min(i - 1, n)) {
res += n / i;
n %= i;
}
cout << res << endl;
}
int main() {
cin >> n >> H;
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void error2(const string &s, const int &t) {
cerr << endl << " " << s << " = " << t << endl;
}
void error3(const string &s, const long double &t) {
cerr << endl << " " << s << " = " << t << endl;
}
const int MAXINT = 2147483647, MAXSINT = 32767, MAXLDOUBLE = 1000 * 1000 - 1;
const long long N = 5000 + 5, INF = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000ll;
vector<pair<int, pair<int, int> > > edl;
vector<pair<int, int> > adj[N], path;
vector<long long> di[N];
bool f = 0;
long long w[N], s[2], h[N], d[N], S, came[N];
void dfs(int v, int fa) {
d[v] = 1;
di[v].resize(path.size());
for (register int i = (0); i < (int)(((int)(adj[v]).size())); ++i) {
int u = adj[v][i].second;
int w = adj[v][i].first;
if (u != fa) {
h[u] = h[v] + 1;
path.push_back(make_pair(w, u));
dfs(u, v);
path.pop_back();
S += came[v] * d[u] + (came[u] + d[u] * w) * d[v];
came[v] += came[u] + d[u] * w;
d[v] += d[u];
}
}
di[v].back() = came[v];
}
void dfsf(int v, int fa) {
for (register int i = (0); i < (int)(((int)(adj[v]).size())); ++i) {
int u = adj[v][i].second;
int w = adj[v][i].first;
if (u != fa) {
path.push_back(make_pair(w, u));
dfsf(u, v);
path.pop_back();
}
}
long long dis = 0;
for (int i = path.size() - 2; i > -1; i--) {
int u = path[i].second, u2 = path[i + 1].second;
int w = path[i + 1].first;
dis += w;
long long tmp = came[u] - came[u2] - d[u2] * w;
tmp += (d[u] - d[u2]) * dis;
di[v][i] = di[v][i + 1] + tmp;
}
}
void bfs(int v, int fa, int cost, int base) {
queue<pair<int, pair<int, int> > > q;
q.push(make_pair(v, make_pair(fa, cost)));
while (!q.empty()) {
v = q.front().first;
fa = q.front().second.first;
cost = q.front().second.second;
q.pop();
for (register int i = (0); i < (int)(((int)(adj[v]).size())); ++i) {
int u = adj[v][i].second;
if (u != fa) {
if (!f)
q.push(make_pair(u, make_pair(v, cost + adj[v][i].first)));
else
q.push(make_pair(u, make_pair(v, cost + 1)));
}
}
if (!f) {
long long dis = di[v][0] - cost * d[base] - di[base].back();
if (s[f] > dis) s[f] = dis;
} else {
cost = ((int)(di[v]).size()) - cost;
if (s[f] > di[v][cost]) s[f] = di[v][cost];
}
}
}
int main() {
ios::sync_with_stdio(false);
int n, a, b, cost;
long long ans = 0;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
cin >> a >> b >> cost;
adj[a].push_back(make_pair(cost, b));
adj[b].push_back(make_pair(cost, a));
edl.push_back(make_pair(cost, make_pair(a, b)));
}
path.push_back(make_pair(0, 1));
dfs(1, 1);
dfsf(1, 1);
for (register int i = (0); i < (int)(n - 1); ++i) {
int v = edl[i].second.first, u = edl[i].second.second;
if (h[u] < h[v]) swap(v, u);
s[0] = s[1] = INF;
f = 0;
bfs(v, u, edl[i].first, u);
f = 1;
bfs(u, v, 1, v);
long long dv = di[v][0] - (d[u] * edl[i].first + di[u].back());
long long du = di[u].back();
w[i] += dv * d[u] + du * (n - d[u]) - (s[0] * d[u] + s[1] * (n - d[u]));
cerr << dv * d[u] + du * (n - d[u]) << endl;
}
for (int i = 0; i < n - 1; ++i) ans = max(ans, w[i]);
cout << S - ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const int MAXN = 510;
const int INF = (int)(2e9 + 1e-9);
int a[MAXN][MAXN];
int b[MAXN][MAXN], c[MAXN][MAXN];
int sum(int x1, int y1, int x2, int y2) {
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2) return b[x1][y2 + 1] - b[x1][y1];
return c[x2 + 1][y1] - c[x1][y1];
}
void up(int &a, int b) { a = max(a, b); }
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < (int)(n); ++i) {
b[i][0] = 0;
for (int j = 0; j < (int)(m); ++j) {
b[i][j + 1] = b[i][j] + a[i][j];
}
}
for (int j = 0; j < (int)(m); ++j) {
c[0][j] = 0;
for (int i = 0; i < (int)(n); ++i) {
c[i + 1][j] = c[i][j] + a[i][j];
}
}
int ans = -INF;
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
int l = -1, cur = 0;
int x, y;
if (i == 3 && j == 3) {
i = i;
}
while (true) {
if (min(i, n - 1 - i) < l + 2) break;
if (min(j, m - 1 - j) < l + 2) break;
if (l == -1) {
cur = sum(i - 1, j - 1, i - 1, j + 1) + sum(i, j + 1, i + 1, j + 1) +
sum(i + 1, j, i + 1, j - 1);
} else {
x = i - l;
y = j - l;
cur += a[x][y - 1];
cur += sum(x, y - 2, x + 2 * l + 2, y - 2);
cur += sum(x + 2 * l + 2, y - 1, x + 2 * l + 2, y + 2 * l + 2);
cur += sum(x + 2 * l + 1, y + 2 * l + 2, x - 2, y + 2 * l + 2);
cur += sum(x - 2, y + 2 * l + 1, x - 2, y - 2);
}
up(ans, cur);
l += 2;
}
}
}
for (int i = 0; i < (int)(n); ++i) {
for (int j = 0; j < (int)(m); ++j) {
int l = 0, cur = 0;
int x, y;
while (true) {
if (min(i, n - 1 - i) < l + 2) break;
if (min(j, m - 1 - j) < l + 2) break;
if (l == 0) {
cur = sum(i - 2, j - 2, i - 2, j + 2) +
sum(i - 1, j + 2, i + 2, j + 2) +
sum(i + 2, j + 1, i + 2, j - 2) + sum(i + 1, j - 2, i, j - 2) +
sum(i, j - 1, i, j);
} else {
x = i - l;
y = j - l;
cur += a[x][y - 1];
cur += sum(x, y - 2, x + 2 * l + 2, y - 2);
cur += sum(x + 2 * l + 2, y - 1, x + 2 * l + 2, y + 2 * l + 2);
cur += sum(x + 2 * l + 1, y + 2 * l + 2, x - 2, y + 2 * l + 2);
cur += sum(x - 2, y + 2 * l + 1, x - 2, y - 2);
}
up(ans, cur);
l += 2;
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
map<char, map<char, int>> m;
ll dp[10][10];
ll sol(char z, int n) {
ll ss = 0;
ll kk;
if (n == 1) return 1;
for (char i = 'a'; i <= 'f'; i++) {
if (m[z][i] > 0) {
kk = ((dp[(int)i - (int)'a'][n - 1] > 0) ? dp[(int)i - (int)'a'][n - 1]
: sol(i, n - 1));
dp[(int)i - (int)'a'][n - 1] = kk;
ss += m[z][i] * kk;
}
}
return ss;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
string a, b;
while (q--) {
cin >> a >> b;
m[b[0]][a[0]]++;
}
cout << sol('a', n);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int N, Q, W[maxn];
int main() {
scanf("%d%d", &N, &Q);
for (int i = 1; i <= N; i++) W[i] = i;
bool flag = false;
int k, l, r;
int n = N, bw = 0;
while (Q--) {
scanf("%d%d", &k, &l);
if (k == 1) {
if (l > n - l) {
flag = !flag;
l = n - l;
}
if (flag) {
for (int i = 0; i < l; i++) W[bw + n - l - i] += N - W[bw + n - l + i];
} else {
bw += l;
for (int i = 0; i < l; i++) W[bw + i] -= W[bw - i];
}
n -= l;
} else {
scanf("%d", &r);
if (flag) {
int tmp = n - r;
r = n - l;
l = tmp;
}
printf("%d\n", W[bw + r] - W[bw + l]);
}
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.