solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length(), k = n / 2, d = 2;
if (n % 2 == 0) {
cout << s[k - 1];
} else {
cout << s[k];
k++;
}
for (int i = k; i < n; i++, d += 2) {
if (i != n - 1 || n % 2 != 0) {
cout << s[i] << s[i - d];
} else {
cout << s[i];
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> sz{(long long)204761410474, 2046, 6, 2, 1};
vector<long long> sol;
long long lo = 1, k = 1e4, h[4], x, p, ert;
int main() {
h[0] = 1;
for (int i = 1; i <= 3; i++) h[i] = h[i - 1] * (k + 1);
while (p < 5) {
if (p >= 3) {
ert = lo;
if (p == 4) ert--;
for (int i = 1; i <= min(k, lo); i++) {
if (p == 3)
ert += min(ert, k);
else
ert++;
sol.push_back(ert);
if (p == 3) ert++;
}
} else {
if (lo == 1)
sol.push_back(sz[p]);
else {
ert = lo - 1;
if (lo == 2047) ert = 20468427 - h[2];
for (int i = 1; i <= min(k, lo); i++) {
ert += h[4 - p];
sol.push_back(ert);
}
}
}
cout << sol.size() << " ";
for (int i = 0; i < sol.size(); i++) cout << sol[i] << " ";
cout.flush() << "\n";
cin >> x;
if (x == -1) {
return 0;
}
if (x) lo = sol[x - 1] + 1;
p++;
sol.clear();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, i, max;
max = 0;
cin >> n;
int a[n];
int f = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
f += a[i];
if (a[i] > max) max = a[i];
}
int k = max;
while (k * n - 2 * f <= 0) ++k;
cout << k << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("unroll-loops")
using namespace std;
using ll = long long;
template <class T>
using V = vector<T>;
template <class T, class U>
using P = pair<T, U>;
using vll = V<ll>;
using vii = V<int>;
using vvll = V<vll>;
using vvii = V<V<int> >;
using PII = P<int, int>;
using PLL = P<ll, ll>;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long MOD = 1000000007;
const long long HIGHINF = (long long)1e18;
const int INF = (int)1e9;
void solve() {
int n, m, c, c0;
cin >> n >> m >> c >> c0;
ll sumall = c0;
V<P<int, PII> > tab(n);
for (ll i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
tab[i] = make_pair(t, PII(a, b));
sumall += a;
}
sort(tab.begin(), tab.end());
tab.emplace_back(make_pair(m, PII(0, 0)));
n++;
if (sumall < m) {
cout << -1 << '\n';
return;
}
map<int, int> costs;
costs[0] = c0;
int now = c0;
ll ans = 0;
for (ll i = 0; i < n; i++) {
int t = tab[i].first, a = tab[i].second.first, b = tab[i].second.second;
int diff = (i == 0 ? t : tab[i].first - tab[i - 1].first);
while (costs.size() > 0 and diff > 0) {
int tmp = min(costs.begin()->second, diff);
ans += ll(costs.begin()->first) * tmp;
now -= tmp;
diff -= tmp;
costs.begin()->second -= tmp;
if (costs.begin()->second == 0) costs.erase(costs.begin());
}
if (diff > 0) {
cout << -1 << '\n';
return;
}
int inc = min(c - now, a);
now += inc;
while (inc < a and costs.size() > 0 and costs.rbegin()->first > b) {
if (a - inc >= costs.rbegin()->second) {
inc += costs.rbegin()->second;
costs.erase(costs.rbegin()->first);
} else {
int minus = a - inc;
costs.rbegin()->second -= minus;
inc += minus;
}
}
costs[b] += inc;
}
cout << ans << '\n';
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int q;
cin >> q;
while (q-- > 0) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vv = vector<vector<T>>;
template <class T>
ostream &operator<<(ostream &os, const deque<T> &t) {
os << "{";
for (int(i) = 0; (i) < (t.size()); ++(i)) {
os << t[i] << ",";
}
os << "}" << endl;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
for (int(i) = 0; (i) < (t.size()); ++(i)) {
os << t[i] << ",";
}
os << "}" << endl;
return os;
}
template <class T, size_t n>
ostream &operator<<(ostream &os, const array<T, n> &t) {
os << "{";
for (int(i) = 0; (i) < (n); ++(i)) {
os << t[i] << ",";
}
os << "}" << endl;
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
template <class S, class T, class U>
ostream &operator<<(ostream &os, const tuple<S, T, U> &t) {
return os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ")";
}
template <class S, class T, class U, class V>
ostream &operator<<(ostream &os, const tuple<S, T, U, V> &t) {
return os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ","
<< get<3>(t) << ")";
}
template <class S, class T, class U, class V, class W>
ostream &operator<<(ostream &os, const tuple<S, T, U, V, W> &t) {
return os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ","
<< get<3>(t) << "," << get<4>(t) << ")";
}
template <class T>
inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(0);
int n, t;
cin >> n >> t;
vector<long long> a(n);
for (int(i) = 0; (i) < (n); ++(i)) cin >> a[i];
for (int(i) = (n - 1) - 1; (i) >= 0; --(i)) a[i] += a[i + 1];
(a, 1);
long long re = a[0];
a.erase(a.begin());
sort((a).rbegin(), (a).rend());
for (int(i) = 0; (i) < (t - 1); ++(i)) re += a[i];
cout << re << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
set<int> usedPrimes;
bool isBad[100009];
void getPrimes() {
for (int i = 2; i < 100000; i++) {
if (isBad[i]) continue;
primes.push_back(i);
for (int j = 2; j * i < 100000; j++) {
isBad[i * j] = true;
}
}
}
struct edge {
int start;
int end;
int left;
edge *rev;
};
bool used[2000];
int counter[2000];
vector<edge *> g[2000];
int n, m;
int dfs(int cur, int mini) {
used[cur] = true;
if (cur == n + 1) return mini;
if (mini == 0) return 0;
int deeper = 0;
for (; counter[cur] < g[cur].size(); counter[cur]++) {
if (g[cur][counter[cur]]->left == 0 || used[g[cur][counter[cur]]->end])
continue;
deeper =
dfs(g[cur][counter[cur]]->end, min(mini, g[cur][counter[cur]]->left));
g[cur][counter[cur]]->left -= deeper;
g[cur][counter[cur]]->rev->left += deeper;
if (deeper != 0) return deeper;
}
return deeper;
}
int getAns() {
int ans = 0;
int cur = 0;
for (int i = 0; i < 200; i++) {
used[i] = false;
counter[i] = 0;
}
used[0] = true;
while ((cur = dfs(0, 2000000000)) != 0) {
ans += cur;
for (int i = 0; i < 200; i++) {
used[i] = false;
counter[i] = 0;
}
used[0] = true;
}
return ans;
}
int main() {
getPrimes();
cin >> n >> m;
int arr[120];
pair<int, int> pairs[200];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < m; i++) cin >> pairs[i].first >> pairs[i].second;
for (int i = 0; i < m; i++)
if (pairs[i].first % 2 == 0) swap(pairs[i].first, pairs[i].second);
for (int i = 0; i < n; i++) {
int cur = arr[i];
for (int j = 0; j < primes.size(); j++) {
if (cur % primes[j] == 0 &&
usedPrimes.find(primes[j]) == usedPrimes.end()) {
usedPrimes.insert(primes[j]);
}
while (cur % primes[j] == 0) {
cur /= primes[j];
}
}
if (cur > 1 && usedPrimes.find(cur) == usedPrimes.end()) {
usedPrimes.insert(cur);
primes.push_back(cur);
}
}
set<int>::iterator it = usedPrimes.begin();
int getCount[200];
int ans = 0;
for (; it != usedPrimes.end(); it++) {
for (int i = 0; i < 200; i++) getCount[i] = 0;
for (int i = 0; i < 200; i++) g[i].clear();
int p = *it;
for (int i = 0; i < n; i++) {
int cur = arr[i];
while (cur % p == 0) {
cur /= p;
getCount[i]++;
}
}
for (int i = 0; i < m; i++) {
edge *e1 = new edge;
edge *e2 = new edge;
int sz = 0;
int x = arr[pairs[i].first - 1];
int y = arr[pairs[i].second - 1];
while (x % p == 0 && y % p == 0) {
sz++;
x /= p;
y /= p;
}
e1->start = pairs[i].first;
e1->end = pairs[i].second;
e1->left = sz;
e2->start = e1->end;
e2->end = e1->start;
e2->left = 0;
e1->rev = e2;
e2->rev = e1;
g[pairs[i].first].push_back(e1);
g[pairs[i].second].push_back(e2);
}
for (int i = 0; i < n; i += 2) {
edge *e1 = new edge;
edge *e2 = new edge;
e1->start = 0;
e1->end = i + 1;
e1->left = getCount[i];
e2->start = e1->end;
e2->end = e1->start;
e2->left = 0;
e1->rev = e2;
e2->rev = e1;
g[0].push_back(e1);
g[i + 1].push_back(e2);
}
for (int i = 1; i < n; i += 2) {
edge *e1 = new edge;
edge *e2 = new edge;
e1->start = i + 1;
e1->end = n + 1;
e1->left = getCount[i];
e2->start = e1->end;
e2->end = e1->start;
e2->left = 0;
e1->rev = e2;
e2->rev = e1;
g[i + 1].push_back(e1);
g[n + 1].push_back(e2);
}
ans += getAns();
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
typedef struct {
int x1, y1, x2, y2;
} rect;
char a[1000][1001];
int cc;
int cover(rect r) {
for (int x = r.x1; x <= r.x2; x++) {
if (a[x][r.y1] == '.' || a[x][r.y2] == '.') return 0;
if (a[x][r.y1] == '#') a[x][r.y1] = '%', cc++;
if (a[x][r.y2] == '#') a[x][r.y2] = '%', cc++;
}
for (int y = r.y1; y <= r.y2; y++) {
if (a[r.x1][y] == '.' || a[r.x2][y] == '.') return 0;
if (a[r.x1][y] == '#') a[r.x1][y] = '%', cc++;
if (a[r.x2][y] == '#') a[r.x2][y] = '%', cc++;
}
return 1;
}
void print(rect r) {
printf("%d %d %d %d\n", r.x1 + 1, r.y1 + 1, r.x2 + 1, r.y2 + 1);
}
void clear(rect r) {
for (int x = r.x1; x <= r.x2; x++) {
if (a[x][r.y1] == '%') a[x][r.y1] = '#';
if (a[x][r.y2] == '%') a[x][r.y2] = '#';
}
for (int y = r.y1; y <= r.y2; y++) {
if (a[r.x1][y] == '%') a[r.x1][y] = '#';
if (a[r.x2][y] == '%') a[r.x2][y] = '#';
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int c = 0;
for (int i = 0; i < n; i++) {
scanf("%s", a[i]);
for (int j = 0; j < m; j++)
if (a[i][j] == '#') c++;
}
int hn = 0, h[1000], vn = 0, v[1000];
for (int i = 0; i < n; i++)
for (int j = 0; j < m - 2; j++)
if (a[i][j] == '#' && a[i][j + 1] == '#' && a[i][j + 2] == '#') {
h[hn++] = i;
break;
}
for (int j = 0; j < m; j++)
for (int i = 0; i < n - 2; i++)
if (a[i][j] == '#' && a[i + 1][j] == '#' && a[i + 2][j] == '#') {
v[vn++] = j;
break;
}
if (hn > 4) {
h[2] = h[hn - 2];
h[3] = h[hn - 1];
hn = 4;
}
if (vn > 4) {
v[2] = v[vn - 2];
v[3] = v[vn - 1];
vn = 4;
}
int rects_n = 0;
rect rects[40];
for (int i1 = 0; i1 < hn; i1++)
for (int i2 = i1; i2 < hn; i2++)
for (int j1 = 0; j1 < vn; j1++)
for (int j2 = j1; j2 < vn; j2++)
if (h[i2] - h[i1] > 1 && v[j2] - v[j1] > 1) {
rect r = {h[i1], v[j1], h[i2], v[j2]};
rects[rects_n++] = r;
}
for (int i = 0; i < rects_n; i++)
for (int j = i; j < rects_n; j++) {
rect r1 = rects[i], r2 = rects[j];
cc = 0;
if (cover(r1) && cover(r2) && cc == c) {
puts("YES");
print(r1);
print(r2);
return 0;
}
clear(r1);
clear(r2);
}
puts("NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
long long test;
cin >> test;
while (test--) {
unsigned long long a, b, n, m;
cin >> a >> b >> n >> m;
long long suma = a + b, mini = min(a, b);
if (m > mini) {
cout << "No" << endl;
continue;
}
suma -= m;
if (n > suma) {
cout << "No" << endl;
continue;
}
cout << "Yes" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, x, i, j, cnt = 0;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
if (a[i] != a[i + 1]) cnt++;
}
printf("%d", cnt);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int NUM = 1e6 + 10;
vector<int> ma[NUM];
int vis[NUM];
long long deg[NUM];
void dfs(int now);
int main() {
int n, m, u, v;
long long cnt = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
deg[u]++, deg[v]++;
if (u != v) {
ma[u].push_back(v);
ma[v].push_back(u);
} else
cnt++;
}
for (int i = 1; i <= n; i++)
if (ma[i].size()) {
dfs(i);
break;
}
for (int i = 1; i <= n; i++)
if (!vis[i] && deg[i]) {
printf("0\n");
return 0;
}
long long ans = 0;
for (int i = 0; i <= n; i++)
ans += (long long)ma[i].size() * (ma[i].size() - 1) / 2;
ans += cnt * (m - 1) - cnt * (cnt - 1) / 2;
printf("%lld\n", ans);
return 0;
}
void dfs(int now) {
vis[now] = 1;
for (int i = 0; i < ma[now].size(); i++) {
if (!vis[ma[now][i]]) dfs(ma[now][i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int arr[1003];
void read() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> arr[i];
}
pair<int, int> curr[103];
int done = 0, next_idx;
bool is[1003];
void solve() {
for (int i = 1; i <= min(n, k); i++) curr[i] = {1, i};
next_idx = min(n, k) + 1;
for (;;) {
bool can = false;
for (int i = 1; i <= min(n, k); i++)
if (curr[i].first != -1) {
can = true;
break;
}
if (!can) break;
for (int i = 1; i <= min(n, k); i++) {
if (curr[i].first == round((long double)done / (long double)n * 100.0))
is[curr[i].second] = true;
}
for (int i = 1; i <= min(n, k); i++)
if (curr[i].first != -1) {
curr[i].first++;
if (curr[i].first == arr[curr[i].second] + 1) {
done++;
if (next_idx <= n) {
curr[i].first = 1;
curr[i].second = next_idx;
next_idx++;
} else
curr[i].first = -1;
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (is[i]) ans++;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
read();
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 5e5 + 20;
struct edge {
int v, u, w;
edge() { v = u = w = 0; }
edge(int V, int U, int W) {
v = V;
u = U;
w = W;
}
bool operator<(const edge &e) const { return w < e.w; }
};
struct query {
int w, idx;
vector<pair<int, int> > ed;
query(int W = 0, int i = -1) {
w = W;
idx = i;
}
int size() { return ed.size(); }
void push_back(int a, int b) { ed.push_back({a, b}); }
void clear() { ed.clear(); }
pair<int, int> operator[](int x) { return ed[x]; }
};
int n, m, t;
vector<edge> e;
vector<query> q[MXN];
vector<int> adj[MXN];
bool ans[MXN], mark[MXN];
int par[MXN], sz[MXN];
void dsu_prep() {
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
}
int get_par(int v) { return (par[v] == v ? v : par[v] = get_par(par[v])); }
bool unite(int v, int u) {
v = get_par(v);
u = get_par(u);
if (v == u) return 0;
if (sz[v] < sz[u]) swap(v, u);
sz[v] += sz[u];
par[u] = v;
return 1;
}
bool DFS(int v, int dad) {
mark[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (u == dad) continue;
if (mark[u]) {
return 1;
} else {
if (DFS(u, v)) return 1;
}
}
return 0;
}
void add_edges(query q) {
for (int i = 0; i < q.size(); i++) {
adj[get_par(q[i].first)].push_back(get_par(q[i].second));
adj[get_par(q[i].second)].push_back(get_par(q[i].first));
}
for (int i = 0; i < q.size(); i++) {
if (mark[get_par(q[i].first)]) continue;
if (DFS(get_par(q[i].first), -1)) {
ans[q.idx] = 1;
}
}
for (int i = 0; i < q.size(); i++) {
adj[get_par(q[i].first)].clear();
mark[get_par(q[i].first)] = 0;
adj[get_par(q[i].second)].clear();
mark[get_par(q[i].second)] = 0;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u, w;
cin >> v >> u >> w;
e.push_back(edge(v, u, w));
}
cin >> t;
for (int i = 0; i < t; i++) {
int k;
cin >> k;
vector<edge> tmp;
for (int j = 0; j < k; j++) {
int x;
cin >> x;
tmp.push_back(e[x - 1]);
}
sort(tmp.begin(), tmp.end());
tmp.push_back(edge(-1, -1, -1));
query qtmp(0, i);
for (int j = 0; j < k; j++) {
qtmp.push_back(tmp[j].v, tmp[j].u);
if (tmp[j].w != tmp[j + 1].w) {
qtmp.w = tmp[j].w;
q[tmp[j].w].push_back(qtmp);
qtmp.clear();
}
}
}
dsu_prep();
sort(e.begin(), e.end());
e.push_back(edge(-1, -1, -1));
int l = 0;
for (int i = 0; i < m; i++) {
if (e[i].w == e[i + 1].w) continue;
int w = e[i].w;
for (int j = 0; j < q[w].size(); j++) {
add_edges(q[w][j]);
}
for (int j = l; j <= i; j++) {
unite(e[j].v, e[j].u);
}
l = i + 1;
}
for (int i = 0; i < t; i++) {
if (ans[i])
cout << "NO\n";
else
cout << "YES\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
void inp_out() {}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
inp_out();
{
long long i, j, k, n, m, ans = 1e18, cnt = 0, sum = 0;
cin >> n;
if (n % 2 == 0) {
cout << n / 2 << "\n";
return 0;
}
for (i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (i != 1) {
ans = min(ans, i);
}
ans = min(ans, n / i);
}
}
n -= ans;
cnt++;
cout << cnt + n / 2 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = 2e6 + 7;
const int lim = 2e5;
const int mod = 998244353;
const int inf = 0x3f3f3f3f;
int a[N];
int main() {
int n, k, t = 1, sum = 0, ans;
scanf("%d%d", &n, &k);
while (k > t) k -= t, t++;
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
if (i == k) ans = x;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int maxn = 1e6 + 5;
int n, W, k, Q, t, f[maxn];
long long v[10], w[10], m[10], pw[10];
long long dp[10][maxn], q[maxn][2];
long long g[maxn];
signed main() {
scanf("%d", &k);
n = 6, W = 999999, pw[0] = 1;
for (int i = 1; i < 10; i++) pw[i] = pw[i - 1] * 10;
for (int i = 1; i <= n; i++) scanf("%d", f + i);
for (int i = 0; i <= W; i++) {
int tmp = i, cnt = 1;
while (tmp) {
int dig = tmp % 10;
if (dig == 3)
g[i] += f[cnt];
else if (dig == 6)
g[i] += 2ll * f[cnt];
else if (dig == 9)
g[i] += 3ll * f[cnt];
tmp /= 10, cnt++;
}
dp[0][i] = g[i];
}
for (int i = 1; i <= n; i++) {
v[i] = f[i], w[i] = 3 * pw[i - 1], m[i] = 3 * (k - 1);
for (int d = 0; d < w[i]; d++) {
int head = 1, tail = 0;
int k1 = (W - d) / w[i];
for (int k = 0; k <= k1; k++) {
while (head <= tail && q[tail][1] <= dp[i - 1][d + k * w[i]] - k * v[i])
tail--;
q[++tail][0] = k, q[tail][1] = dp[i - 1][d + k * w[i]] - k * v[i];
while (head <= tail && q[head][0] < k - m[i]) head++;
dp[i][d + k * w[i]] = max(dp[i][d + k * w[i]], q[head][1] + k * v[i]);
}
}
}
scanf("%d", &Q);
while (Q--) {
scanf("%d", &t);
printf("%lld\n", dp[n][t]);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
bool temp = false;
cin >> n;
string *arr = new string[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
if (arr[i][0] == 'O' && arr[i][1] == 'O') {
temp = true;
cout << "YES" << endl;
arr[i][0] = '+';
arr[i][1] = '+';
for (int i = 0; i < n; i++) cout << arr[i] << endl;
break;
}
if (arr[i][3] == 'O' && arr[i][4] == 'O') {
temp = true;
cout << "YES" << endl;
arr[i][3] = '+';
arr[i][4] = '+';
for (int i = 0; i < n; i++) cout << arr[i] << endl;
break;
}
}
if (temp == false) {
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using std::abs;
using std::cerr;
using std::cin;
using std::cout;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::string;
using std::swap;
using std::vector;
using ll = long long;
using uint = unsigned int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
void _dbg(const char* _s, T _h) {
cerr << _s << " = " << _h << "\n";
}
template <typename T, typename... Ts>
void _dbg(const char* _s, T _h, Ts... _t) {
int _b = 0;
while (((_b += *_s == '(') -= *_s == ')') != 0 || *_s != ',') cerr << *_s++;
cerr << " = " << _h << ",";
_dbg(_s + 1, _t...);
}
struct init {
init() {
cin.tie(0);
std::iostream::sync_with_stdio(0);
cout << std::fixed << std::setprecision(10);
cerr << std::fixed << std::setprecision(5);
}
~init() {}
} init;
const int MAXN = 5017;
const ll INF = 1e18;
ll c[MAXN], d[MAXN];
int p[MAXN];
vector<int> g[MAXN];
vector<ll> a[MAXN], b[MAXN];
int size[MAXN];
int n;
void dfs(int v) {
a[v].assign(n + 1, INF);
b[v].assign(n + 1, INF);
a[v][0] = b[v][0] = 0;
size[v] = 1;
int mx = -1;
for (int to : g[v]) {
dfs(to);
size[v] += size[to];
if (mx == -1 || size[to] > size[mx]) mx = to;
}
if (mx != -1) {
a[v].swap(a[mx]);
b[v].swap(b[mx]);
for (int i = 0; i <= size[v]; ++i) {
if (b[v][i] > a[v][i]) b[v][i] = a[v][i];
}
for (int to : g[v]) {
if (to ^ mx) {
for (int i = size[v]; i >= 0; --i) {
for (int j = 0; j <= min(i, size[to]); ++j) {
{
ll pot = a[v][i - j] + a[to][j];
if (a[v][i] > pot) a[v][i] = pot;
}
}
}
}
}
for (int to : g[v]) {
if (to ^ mx) {
for (int i = size[v]; i >= 1; --i) {
for (int j = 0; j <= min(i, size[to]); ++j) {
{
ll pot = b[v][i - j] + a[to][j];
if (b[v][i] > pot) b[v][i] = pot;
}
{
ll pot = b[v][i - j] + b[to][j];
if (b[v][i] > pot) b[v][i] = pot;
}
}
}
}
}
}
for (int i = size[v]; i >= 1; --i) {
ll pot = a[v][i - 1] + c[v];
if (a[v][i] > pot) a[v][i] = pot;
b[v][i] = b[v][i - 1] + d[v];
}
for (int i = 0; i <= size[v]; ++i)
;
}
int main() {
ll W;
cin >> n >> W;
for (int i = 1; i <= n; ++i) {
cin >> c[i] >> d[i];
if (i > 1) {
cin >> p[i];
g[p[i]].emplace_back(i);
}
d[i] = c[i] - d[i];
}
dfs(1);
int ans = 0;
for (int i = 1; i <= n; ++i)
if (a[1][i] <= W || b[1][i] <= W) ans = i;
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int tc = 1, n, pow_2[30];
map<int, int> cnt;
string str;
int getHash() {
int freq[30] = {0};
for (char c : str) freq[c - 'a']++;
int hash = 0;
for (int i = 0; i < 26; i++) hash += (freq[i] % 2) * pow_2[i];
return hash;
}
void preprocess() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
pow_2[0] = 1;
for (int i = 1; i < 30; i++) pow_2[i] = pow_2[i - 1] << 1;
}
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str;
cnt[getHash()]++;
}
}
void solve() {
long long int ans = 0;
for (auto it = cnt.begin(); it != cnt.end(); it++) {
ans += (long long int)it->second * (it->second - 1) / 2;
for (int i = 0; i < 26; i++) {
if (it->first & (1 << i)) {
auto temp = cnt.find(it->first - (1 << i));
if (temp != cnt.end()) ans += (long long int)temp->second * it->second;
}
}
}
cout << ans << endl;
}
int main() {
preprocess();
while (tc--) {
input();
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
list<int> l;
list<int>::iterator it;
l.push_back(1);
string s;
cin >> s;
int temp = 2;
it = l.begin();
int z = (int)s.size();
for (auto x : s) {
if (temp > z) break;
if (x == 'l') {
l.insert(it, temp);
} else {
it++;
l.insert(it, temp);
}
temp++;
it--;
}
for (auto it2 : l) printf("%d\n", it2);
return 0;
}
| 2 |
#include <bits/stdc++.h>
const long long mxn = 1e6 + 7;
const long long mod = 1e9 + 7;
const long long inf = 1e18 + 9;
using namespace std;
long long n, nb, ns, nc, cnt;
long long push_back, ps, pc;
long long ab, as, ac;
string s;
long long check(long long x) {
long long mx_b = max(0ll, (x * ab - nb) * push_back);
long long mx_s = max(0ll, (x * as - ns) * ps);
long long mx_c = max(0ll, (x * ac - nc) * pc);
return mx_b + mx_s + mx_c <= n;
}
long long bin_search() {
long long l = 0, r = 1e13;
while (r - l > 1) {
long long mid = (r + l) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
return l;
}
int main() {
ios_base::sync_with_stdio(0), cout.tie(0);
cin.tie(0);
cin >> s;
cin >> nb >> ns >> nc;
cin >> push_back >> ps >> pc;
cin >> n;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'B')
ab++;
else if (s[i] == 'S')
as++;
else
ac++;
}
cout << bin_search();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
map<int, int> dp[35][100005];
long long a, b, h, w, n, ar[100005];
long long dpcall(int id, long long x, long long y) {
if (a <= x && b <= y) return 0;
if (id == n) return 100;
if (dp[id][x].count(y)) return dp[id][x][y];
long long ret = 100;
if (x < a) ret = min(ret, 1 + dpcall(id + 1, min(100001LL, ar[id] * x), y));
if (y < b) ret = min(ret, 1 + dpcall(id + 1, x, min(100001LL, ar[id] * y)));
dp[id][x][y] = ret;
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> h >> w >> n;
for (int i = 0; i < (n); i++) cin >> ar[i];
sort(ar, ar + n);
reverse(ar, ar + n);
n = min(34LL, n);
long long ret = dpcall(0, h, w);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 100001; j++) dp[i][j].clear();
}
swap(a, b);
ret = min(ret, dpcall(0, h, w));
if (ret > 50) ret = -1;
cout << ret << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500000;
vector<int> g[N];
int n, x, y, sum[N], ans[N], mx1 = 0, mx2 = 0;
void dfs(int v, int z, int s, int p = 0) {
if (s <= n / 2) z = max(s, z);
if (s - z > (n / 2)) return;
ans[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] != p) dfs(g[v][i], z, s + sum[v] - sum[g[v][i]], v);
}
}
void dfs1(int v, int p = 0) {
sum[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] != p) dfs1(g[v][i], v), sum[v] += sum[g[v][i]];
}
}
int dfs2(int v, int s = 0, int p = 0) {
int t;
bool is = 1;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] == p) continue;
t = dfs2(g[v][i], s + sum[v] - sum[g[v][i]], v);
if (sum[g[v][i]] > (n / 2)) {
is = 0;
}
if (t != 0) return t;
}
if (is && (n - sum[v] <= (n / 2))) return v;
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs1(1);
int centr = dfs2(1);
dfs1(centr);
int id = 0;
for (int i = 0; i < g[centr].size(); i++) {
if (sum[g[centr][i]] >= mx1) {
mx2 = mx1;
id = i;
mx1 = sum[g[centr][i]];
} else if (sum[g[centr][i]] >= mx2) {
mx2 = sum[g[centr][i]];
}
}
ans[centr] = 1;
for (int i = 0; i < g[centr].size(); i++) {
if (i == id)
dfs(g[centr][i], mx2, sum[centr] - sum[g[centr][i]], centr);
else
dfs(g[centr][i], mx1, sum[centr] - sum[g[centr][i]], centr);
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
int n;
int ar[MAXN * 2];
int main() {
scanf(" %d", &n);
for (int(i) = (1); (i) <= (n); (i)++) ar[i] = i;
int beg = 0;
for (int(j) = (2); (j) <= (n); (j)++) {
for (int i = beg + j + 1; i <= n + beg; i += j) {
swap(ar[i], ar[beg + 1]);
}
ar[beg + n + 1] = ar[beg + 1];
beg++;
}
for (int(i) = (1); (i) <= (n); (i)++) printf("%d ", ar[beg + i]);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int dp[N], n;
vector<int> g[N];
double ans[N];
void dfs(int u, int p) {
dp[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
dfs(v, u);
dp[u] += dp[v];
}
}
void cal(int u, int p) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) continue;
ans[v] = ans[u] + 1 + 0.5 * (dp[u] - dp[v] - 1);
cal(v, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
g[x].push_back(i);
g[i].push_back(x);
}
dfs(1, 1);
ans[1] = 1;
cal(1, 1);
for (int i = 1; i <= n; i++)
cout << fixed << setprecision(9) << ans[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
struct point {
double x, y;
point() {}
point(double _x, double _y) {
x = _x;
y = _y;
}
point operator+(const point &t) { return point(x + t.x, y + t.y); }
point operator-(const point &t) { return point(x - t.x, y - t.y); }
double dist(const point &t) {
return ((x - t.x) * (x - t.x) + (y - t.y) * (y - t.y));
}
};
struct line {
double a, b, c;
line() {}
line(double _a, double _b, double _c) {
a = _a;
b = _b;
c = _c;
}
void build(const point &p, const point &q) {
a = p.y - q.y;
b = q.x - p.x;
c = -(p.x * (p.y - q.y) + p.y * (q.x - p.x));
}
};
int n, lt, rt;
point p[2000];
double mx = 1e+15, mn = -(1e+15);
bool intersect(const line &a, point &res) {
if (fabs(a.a) <= eps) return false;
res.y = p[0].y;
res.x = (-a.c - (a.b * res.y)) / a.a;
return true;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf%lf", &p[i].x, &p[i].y);
p[n] = p[0];
lt = int(min(p[0].x, p[1].x));
rt = int(max(p[0].x, p[1].x));
p[n + 1] = p[1];
for (int i = 1; i < n; i++) {
line l;
l.build(p[i], p[i + 1]);
point res, tt = p[i + 1] - p[i];
if (intersect(l, res)) {
if (tt.y < eps)
mx = min(mx, res.x);
else
mn = max(mn, res.x);
} else if ((p[1].x - p[0].x) * tt.x > eps) {
printf("0\n");
return 0;
}
}
int x = ceil(mn - eps), y = floor(mx + eps);
printf("%d\n", max(0, min(y, rt) - max(x, lt) + 1));
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int sum1 = 0, sum2 = 0, a, b, n, i;
for (i = 1; i <= 3; i++) {
scanf("%d", &a);
sum1 += a;
}
for (i = 1; i <= 3; i++) {
scanf("%d", &b);
sum2 += b;
}
scanf("%d", &n);
int x, y;
if (sum1 % 5 == 0) {
x = sum1 / 5;
} else {
x = (sum1 / 5) + 1;
}
if (sum2 % 10 == 0) {
y = sum2 / 10;
} else {
y = (sum2 / 10) + 1;
}
if (x + y <= n)
printf("YES");
else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long pw(long long a, long long n) {
long long ans = 1;
while (n > 0) {
if (n % 2 != 0) {
ans = ans * a;
}
a = a * a;
n = n / 2;
}
return ans;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
vector<string> L;
for (int i = 0; i < n; i++) {
string ch;
cin >> ch;
L.push_back(ch);
}
for (int i = 0; i < n; i++) {
long long sum = 0;
int hash[10] = {0};
bool B, F, M = true;
long long k = 0;
for (int j = 0; j < L[i].size(); j++) {
hash[L[i][j] - '0']++;
sum += L[i][j] - '0';
}
if (hash[0] != 0) {
for (int i = 1; i <= 9; i++) {
if (hash[i] == 0) k++;
}
if (k == 9) cout << "red";
}
for (int i = 4; i <= 99; i += 4) {
B = false, F = false;
int dup = i;
int freq[10] = {0};
freq[dup % 10]++;
dup = dup / 10;
freq[dup % 10]++;
dup = i;
if (hash[dup % 10] != 0) F = true;
dup = dup / 10;
if (i >= 10) {
if (hash[dup % 10] != 0) B = true;
}
if (F == true && B == true) {
break;
}
B = false;
F = false;
}
if (k != 9 && ((B == true) && (F == true) || hash[0] >= 2) &&
(hash[0] != 0) && (sum % 3 == 0))
cout << "red ";
else {
if (k != 9) cout << "cyan";
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long T, t, n, ans, x, y, w, h[1100000], s[1100000];
struct edge {
long long to, w, nxt;
} e[2000010];
void add(long long x, long long y, long long w) {
++t;
e[t].to = y, e[t].w = w;
e[t].nxt = h[x], h[x] = t;
}
void dfs1(long long x, long long fa = 0) {
s[x] = 1;
for (long long i = h[x]; i; i = e[i].nxt) {
long long y = e[i].to;
if (y == fa) continue;
dfs1(y, x);
s[x] += s[y];
if (s[y] % 2) ans += e[i].w;
}
}
void dfs2(long long x, long long fa = 0) {
for (long long i = h[x]; i; i = e[i].nxt) {
long long y = e[i].to;
if (y == fa) continue;
dfs2(y, x);
ans += min(s[y], n - s[y]) * e[i].w;
}
}
signed main() {
cin >> T;
while (T--) {
cin >> n;
n *= 2;
for (long long i = 1; i < n; i++)
scanf("%d%d%d", &x, &y, &w), add(x, y, w), add(y, x, w);
ans = 0;
dfs1(1);
cout << ans << " ";
ans = 0;
dfs2(1);
cout << ans << endl;
for (long long i = 1; i <= n; i++) h[i] = 0, s[i] = 0;
t = 0;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool g[100 + 1][100 + 1];
int res[100 + 1][100 + 1];
void dfs(int x, int y, int currK, int n, int k, bool dir) {
if (!g[x][y]) {
return;
}
if (currK == 0) {
if (dir) {
for (int i = 0; i < k; ++i) {
++res[x - i][y];
}
} else {
for (int i = 0; i < k; ++i) {
++res[x][y - i];
}
}
return;
}
if (dir) {
if (x + currK >= n) {
return;
}
dfs(x + 1, y, currK - 1, n, k, dir);
} else {
if (y + currK >= n) {
return;
}
dfs(x, y + 1, currK - 1, n, k, dir);
}
}
int main(int argc, const char* argv[]) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
char c;
cin >> c;
if (c == '#') {
g[i][j] = 0;
} else {
g[i][j] = 1;
}
res[i][j] = 0;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
dfs(i, j, k - 1, n, k, true);
dfs(i, j, k - 1, n, k, false);
}
}
int maxVal = 0;
int maxI = 1;
int maxJ = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (res[i][j] > maxVal) {
maxVal = res[i][j];
maxI = i + 1;
maxJ = j + 1;
}
}
}
cout << maxI << " " << maxJ;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
template <typename T>
struct Dijkstra {
bool vis[MAXN];
T dist[MAXN];
struct Edge {
int to;
T value;
Edge() {}
Edge(int to, T value) : to(to), value(value) {}
};
vector<Edge> edges[MAXN];
void add_edge(int from, int to, T value, int d) {
edges[from].push_back(Edge(to, value));
if (d == 2) edges[to].push_back(Edge(from, value));
}
void init(int n) {
for (int i = 0; i <= n; i++) edges[i].clear();
}
T operator[](int i) const { return dist[i]; }
void solve(int s) {
memset(vis, false, sizeof vis);
memset(dist, 0x3f, sizeof dist);
dist[s] = 0;
typedef pair<int, T> Element;
auto cmp = [](const Element& a, const Element& b) -> bool {
return a.second > b.second;
};
priority_queue<Element, vector<Element>, decltype(cmp)> q(cmp);
q.push(make_pair(s, 0));
while (!q.empty()) {
int x = q.top().first;
q.pop();
if (vis[x]) continue;
vis[x] = true;
for (auto& i : edges[x])
if (dist[i.to] > dist[x] + i.value) {
dist[i.to] = dist[x] + i.value;
q.push(make_pair(i.to, dist[i.to]));
}
}
}
};
int n;
Dijkstra<int> dijk;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
dijk.add_edge(i, a, 1, 1);
dijk.add_edge(i, i - 1, 1, 1);
dijk.add_edge(i, i + 1, 1, 1);
}
dijk.solve(1);
for (int i = 1; i <= n; i++) printf("%d ", dijk[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cnt[262144], q;
void enter() {}
void solve() {
cin >> q;
for (int i = 1; i <= q; i++) {
char kind;
string s;
cin >> kind;
cin >> s;
while (s.size() < 18) s = "0" + s;
int tmp = 0;
for (int i = 0; i <= 17; i++) tmp += ((s[i] - 48) % 2) * (1 << i);
if (kind == '+')
cnt[tmp]++;
else if (kind == '-')
cnt[tmp]--;
else
cout << cnt[tmp] << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
enter();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
long long sum(int n) { return 1LL * (n) * (n + 1) / 2; }
long long get(int x, int y, int m) {
long long ret = 0;
if (x < 1 || y < 1 || m <= 0) return 0;
int addx = max(m - x, 0), addy = max(m - y, 0);
ret += 1LL * (addx) * (addx + 1) / 2 + 1LL * (addy) * (addy + 1) / 2;
ret -= sum(max(m - x - y, 0));
return sum(m) - ret;
}
int main() {
int n, x, y, c;
cin >> n >> x >> y >> c;
int l = 0, r = 2 * n + 1;
while (r - l > 1) {
int m = (l + r) >> 1;
long long sum = get(x, y, m);
sum += get(x, n - y, m - 1);
sum += get(n - x, y, m - 1);
sum += get(n - x, n - y, m - 2);
if (sum >= c)
r = m;
else
l = m;
}
cout << r - 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
long long t, x, n, y;
cin >> t;
for (int i = 0; i < t; ++i) {
cin >> x >> y >> n;
int p = (n - y) / x;
int k = p * x + y;
cout << k << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n;
int a[N];
int cnt[N];
int out[N];
int ed[N];
int mp[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
for (int i = 1; i <= n; ++i) {
if (cnt[a[i]] % (n - a[i]) != 0) {
cout << "Impossible" << endl;
return 0;
}
}
puts("Possible");
int c = 0;
for (int i = 1; i <= n; ++i) {
if (ed[a[i]] % (n - a[i]) == 0) mp[a[i]] = ++c;
printf("%d ", mp[a[i]]);
++ed[a[i]];
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x7fffffffffffffff;
struct stPoint {
long long x;
long long y;
int nSet;
bool operator<(const stPoint& obj) const {
if (y != obj.y)
return (y < obj.y);
else if (x != obj.x)
return (x < obj.x);
else
return (nSet < obj.nSet);
}
};
int nN, nM;
stPoint vA[120001];
stPoint ptBottom;
vector<stPoint> vConvex;
int compare(const void* pta, const void* ptb) {
stPoint* pt1 = (stPoint*)pta;
stPoint* pt2 = (stPoint*)ptb;
long long x1 = pt1->x - ptBottom.x;
long long y1 = pt1->y - ptBottom.y;
long long x2 = pt2->x - ptBottom.x;
long long y2 = pt2->y - ptBottom.y;
long long lTemp = x2 * y1 - y2 * x1;
if (lTemp < 0)
return -1;
else if (lTemp == 0) {
if (y1 < y2)
return -1;
else if (y1 == y2)
return (pt1->nSet - pt2->nSet);
else
return 1;
} else
return 1;
}
int main(void) {
ptBottom.x = INF;
ptBottom.y = INF;
scanf("%d", &nN);
int nIndex;
for (int i = 0; i < nN; ++i) {
stPoint stTemp;
scanf("%I64d %I64d", &stTemp.x, &stTemp.y);
stTemp.nSet = 1;
vA[i] = stTemp;
if (stTemp < ptBottom) {
ptBottom = stTemp;
nIndex = i;
}
}
scanf("%d", &nM);
for (int i = nN; i < nN + nM; ++i) {
stPoint stTemp;
scanf("%I64d %I64d", &stTemp.x, &stTemp.y);
stTemp.nSet = 0;
vA[i] = stTemp;
if (stTemp < ptBottom) {
ptBottom = stTemp;
nIndex = i;
}
}
if (ptBottom.nSet == 0) {
printf("NO\n");
return 0;
}
if (nIndex != 0) {
vA[nIndex] = vA[0];
vA[0] = ptBottom;
}
qsort(vA + 1, nN + nM - 1, sizeof(stPoint), compare);
stPoint p1 = vA[0], p2, p3;
if (vA[nN + nM - 1].nSet == 0) {
printf("NO\n");
return 0;
} else {
p2 = vA[nN + nM - 2];
p3 = vA[nN + nM - 1];
long long x1 = p2.x - p1.x;
long long y1 = p2.y - p1.y;
long long x2 = p3.x - p2.x;
long long y2 = p3.y - p2.y;
if (x1 * y2 - x2 * y1 == 0) {
printf("NO\n");
return 0;
}
}
vConvex.push_back(vA[0]);
vConvex.push_back(vA[1]);
p2 = vA[1];
bool bIsIn = true;
for (int i = 2; i <= nN + nM; ++i) {
if (i == nN + nM)
p3 = vA[0];
else
p3 = vA[i];
long long x1 = p2.x - p1.x;
long long y1 = p2.y - p1.y;
long long x2 = p3.x - p2.x;
long long y2 = p3.y - p2.y;
if (x2 == 0 && y2 == 0) {
bIsIn = false;
break;
}
if (x1 * y2 - x2 * y1 < 0) {
vConvex.pop_back();
if (vConvex.size() == 1) {
vConvex.push_back(p3);
p2 = p3;
} else {
p2 = p1;
p1 = vConvex[int(vConvex.size()) - 2];
--i;
}
} else {
if (i == nN + nM) break;
vConvex.push_back(p3);
p1 = p2;
p2 = p3;
}
}
if (int(vConvex.size()) > nN)
bIsIn = false;
else {
for (int i = 0; i < (int)vConvex.size(); ++i) {
if (vConvex[i].nSet == 0) {
bIsIn = false;
break;
}
}
}
if (bIsIn)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 6 |
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <cctype>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <limits.h>
#include <queue>
#include <stack>
#include <set>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iomanip>
using namespace std;
#define int long long
#define ll long long
#define ss second
#define ff first
#define double long double
#define pb push_back
#define mod 1000000007
using namespace std;
#define endl '\n'
int mpow(int a, int x) {
int ret = 1;
while(x) {
if(x&1) {
ret*=a;
}
a*=a;
ret%=mod;
a%=mod;
x>>=1;
}
return ret;
}
const int N = 2e5 + 100;
// std::vector<pair<int,int>> gr[N];
int par[N];
int rnk[N];
int n, m, k;
struct Edge
{
int x, y, s;
Edge(int a, int b, int c) {
x = a;
y = b;
s = c;
}
};
int find(int x) {
// cout << x << endl;
if(par[x] == -1) return x;
return par[x] = find(par[x]);
}
void union_it(int x, int y) {
x = find(x);
y = find(y);
if(x == y) return;
if(rnk[x] > rnk[y]) {
swap(x, y);
}
// x < y. x to be merged into y.
par[x] = y;
rnk[y] += rnk[x];
}
std::vector<Edge> edges;
std::vector<Edge> edgesLtK;
std::vector<Edge> edgesGtK;
void init(){
edges.clear();
edgesLtK.clear();
edgesGtK.clear();
for(int i=0;i<=n;i++) {
par[i] = -1;
rnk[i] = 1;
}
}
bool sortCool(Edge & l, Edge & r) {
return l.s < r.s;
}
void solve() {
cin >> n >> m >> k;
init();
for(int i=0;i<m;i++) {
int x, y, s;
cin >> x >> y >> s;
Edge e = Edge(x, y, s);
edges.pb(e);
if (s <= k) {
edgesLtK.pb(e);
} else {
edgesGtK.pb(e);
}
}
sort(edgesLtK.begin(), edgesLtK.end(), sortCool);
sort(edgesGtK.begin(), edgesGtK.end(), sortCool);
reverse(edgesLtK.begin(), edgesLtK.end());
// Nice. Now process.
int best_answer = INT_MAX;
for(auto x: edgesLtK) {
// Process these. And silently add to DSU.
union_it(x.x, x.y);
}
int par1 = find(1);
int one_not_exists_in_tree = false;
for(int i=1;i<=n;i++) {
if(find(i) != par1) {
one_not_exists_in_tree = true;
}
}
if(one_not_exists_in_tree) {
// Now I need to silently proceed with the gt edges and make then in
// the tree.
best_answer = 0;
} else {
best_answer = k - edgesLtK[0].s;
}
for(auto x: edgesGtK) {
// Now process these.
int parX = find(x.x);
int parY = find(x.y);
if(parX != parY) {
union_it(x.x, x.y);
best_answer += x.s - k;
} else {
if(not one_not_exists_in_tree) {
best_answer = min(best_answer, x.s - k);
}
}
}
cout << best_answer << endl;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int t;
t = 1;
cin >> t;
for(int tc=1;tc<=t;tc++) {
// cout << "Case #" << tc << ": ";
solve();
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long modexp(long long x, long long n) {
if (n == 0) return 1;
if (n % 2 == 0) {
long long y = modexp(x, n / 2) % mod;
return (y * y) % mod;
}
return (x * modexp(x, n - 1) % mod) % mod;
}
int main() {
int n;
long long d;
scanf("%d%lld", &n, &d);
long long a[n];
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
long long curr = 0;
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
if (a[i] == 0) {
if (sum < 0) sum = 0;
}
if (sum > d) {
printf("-1\n");
return 0;
}
}
long long x = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] > 0) {
curr += a[i];
} else if (a[i] < 0) {
curr += a[i];
} else {
if (curr < 0) {
if (abs(curr) <= x) {
x = x - abs(curr);
} else {
ans++;
x = d;
}
curr = 0;
}
}
if (curr > d) {
printf("-1\n");
return 0;
}
x = min(x, d - curr);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 20, MA = 400005;
int n, mem[1 << MX], mn[MX], sum[MX], mp[MX][2 * MA];
int dp(int mk) {
if (__builtin_popcount(mk) == n) return 0;
int &res = mem[mk];
if (res != -1) return res;
res = 0;
int s = 0;
for (int i = 0; i < int(n); i++)
if (mk & (1 << i)) s += sum[i];
for (int i = 0; i < int(n); i++)
if (~mk & (1 << i)) {
if (s + mn[i] < 0) {
res = max(res, mp[i][MA - s]);
} else {
res = max(res, dp(mk | (1 << i)) + mp[i][MA - s]);
}
}
return res;
}
void main_() {
cin >> n;
for (int i = 0; i < int(n); i++) {
string s;
cin >> s;
for (char c : s) {
if (c == '(')
sum[i]++;
else
sum[i]--;
if (sum[i] <= mn[i]) {
mp[i][MA + sum[i]]++;
mn[i] = sum[i];
}
}
}
memset(mem, -1, sizeof(mem));
cout << dp(0) << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) main_();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod_mult_inverse(long long a, long long m) {
long long x = 0, lastx = 1;
long long y = 1, lasty = 0;
long long b = m;
long long aux;
while (b != 0) {
long long quotient = a / b;
long long aux;
aux = b;
b = a % b;
a = aux;
aux = x;
x = lastx - quotient * x;
lastx = aux;
aux = y;
y = lasty - quotient * y;
lasty = aux;
}
if (a != 1) return 0;
x = lastx;
if (x < 0) return x + m;
return x;
}
long long a, b;
long long m = 1000000007;
long long mu(long long a, long long b) { return (a * b) % m; }
long long g() {
long long s = 0, x;
for (long long x = 1; x < 100000; x++) {
if (x % b == 0) continue;
if ((x / b) / (x % b) > a) {
continue;
}
cout << x << endl;
s = (s + x) % m;
}
return s;
}
long long h(long long i) {
long long x;
for (long long p = 0; p < 10000; p++) {
x = p * a + i;
if ((x / b) / (x % b) > a) {
continue;
}
cout << x << endl;
}
return mu(a, i) + i - 1ll;
}
long long pre(long long p) { return mu(mu(p, p + 1), mod_mult_inverse(2, m)); }
int main() {
long long sum = 0;
cin >> a >> b;
long long mu2 = mod_mult_inverse(2, m);
long long res = mu(b, mu(mu(mu(a, a + 1), mu2), mu(mu(b, b - 1), mu2))) +
mu(a, mu(mu(b, b - 1), mu2));
cout << (res % m) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int i = 0; i < t.size(); i++) s << t[i] << " ";
return s;
}
int main() {
int i, j, k;
int s12, s13, s14, s23, s24, s34;
while (~scanf("%d%d%d%d%d%d", &s12, &s13, &s14, &s23, &s24, &s34)) {
int first = (s13 + s23 - s12);
if (first % 2) {
puts("-1");
return 0;
}
first /= 2;
int second = s13 - first, z = s12 - second;
int a = (first + second - s14 + s34);
if (a < 0 || a % 2) {
puts("-1");
return 0;
}
a /= 2;
int b = (second + z - s14 + s24);
if (b < 0 || b % 2) {
puts("-1");
return 0;
}
b /= 2;
int ans = second + z + s24 - b, d[8];
for (i = 0; i <= min(a, first); i++) {
d[1] = i;
d[5] = a - d[1];
d[3] = b - d[5];
d[2] = first - d[1];
d[6] = second - d[5];
d[4] = z - d[3];
d[7] = s24 - d[2] - d[3] - d[5];
if (d[5] >= 0 && d[3] >= 0 && d[2] >= 0 && d[6] >= 0 && d[4] >= 0 &&
d[7] >= 0)
break;
}
if (i > min(a, first)) {
puts("-1");
continue;
}
ans += i;
printf("%d\n", ans);
for (j = 0; j < ans; j++) printf("a");
puts("");
for (j = 0; j < ans - s12; j++) printf("a");
for (; j < ans; j++) printf("b");
puts("");
for (j = 0; j < ans - (first + s12); j++) printf("a");
for (j = 0; j < first; j++) printf("b");
for (j = 0; j < z; j++) printf("a");
for (j = 0; j < second; j++) printf("b");
puts("");
for (i = 0; i < d[7]; i++) printf("b");
for (i = 0; i < d[1]; i++) printf("a");
for (i = 0; i < d[2]; i++) printf("b");
for (i = 0; i < d[3]; i++) printf("a");
for (i = 0; i < d[4]; i++) printf("b");
for (i = 0; i < d[5]; i++) printf("a");
for (i = 0; i < d[6]; i++) printf("b");
puts("");
}
}
| 8 |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
int64_t n, m, k;
std::cin >> n >> m >> k;
if (k < n) {
std::cout << k + 1 << " 1\n";
return 0;
}
k -= n;
--m;
if ((k / m) % 2 == 0) {
std::cout << n - (k / m) << " " << 2 + k % m << '\n';
} else {
std::cout << n - (k / m) << " " << m + 1 - k % m << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ff[307 * 307], Id[307 * 307], id[307][307], n, m;
char s[307][307];
long long mod;
long long pw(long long x, long long p) {
long long ans = 1;
for (; p; p >>= 1, x = x * x % mod)
if (p & 1) ans = ans * x % mod;
return ans;
}
struct Det {
long long A[307][307];
int num;
Det() { memset(A, 0, sizeof(A)), num = 0; }
void Add(int x, int y) {
(A[x][x] += 1) %= mod, (A[y][y] += 1) %= mod;
(A[x][y] += mod - 1) %= mod;
(A[y][x] += mod - 1) %= mod;
}
void debug() {
for (int i = 1; i < num; i++) {
for (int j = 1; j < num; j++) printf("%lld ", A[i][j]);
printf("\n");
}
printf("\n");
}
long long Calc() {
long long ans = 1;
for (int i = 1; i < num; i++) {
for (int j = i; j < num; j++) {
if (A[j][i]) {
if (j != i) {
for (int k = i; k < num; k++) swap(A[i][k], A[j][k]);
ans = (mod - ans) % mod;
}
break;
}
}
if (!A[i][i]) return 0;
ans = ans * A[i][i] % mod;
long long inv = pw(A[i][i], mod - 2);
for (int j = i; j < num; j++) A[i][j] = A[i][j] * inv % mod;
for (int j = i + 1; j < num; j++) {
for (int k = i + 1; k < num; k++)
A[j][k] = (A[j][k] - A[j][i] * A[i][k] % mod + mod) % mod;
A[j][i] = 0;
}
}
return ans;
}
} D;
int find(int x) { return ff[x] == x ? x : ff[x] = find(ff[x]); }
void merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) puts("0"), exit(0);
ff[x] = y;
}
void Merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
D.Add(Id[x], Id[y]);
}
int main() {
scanf("%d%d%lld", &n, &m, &mod);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n + 1; i++)
for (int j = 1; j <= m + 1; j++) id[i][j] = (i - 1) * (m + 1) + j;
for (int i = 1; i <= (n + 1) * (m + 1); i++) ff[i] = i;
int k = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (s[i][j] == '/')
merge(id[i][j + 1], id[i + 1][j]);
else if (s[i][j] == '\\')
merge(id[i][j], id[i + 1][j + 1]);
else
k++;
}
long long ans = 0;
for (int o = 0; o <= 1; o++) {
D = Det();
int Cnt = 0;
for (int i = 1; i <= n + 1; i++)
for (int j = (((i & 1) ^ o) + 1); j <= m + 1; j += 2)
if (!Id[find(id[i][j])]) Id[find(id[i][j])] = ++Cnt;
if (Cnt > k + 1) continue;
D.num = Cnt;
for (int i = 1; i <= n + 1; i++)
for (int j = (((i & 1) ^ o) + 1); j <= m + 1; j += 2) {
if (s[i][j] == '*') Merge(id[i][j], id[i + 1][j + 1]);
if (s[i][j - 1] == '*') Merge(id[i][j], id[i + 1][j - 1]);
}
long long x = D.Calc();
ans = (ans + x) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
map<long double, pair<long double, long double> > m1;
int main() {
long long i, j, k, n, c1 = 0, c2 = 0;
string str, str1;
char ob = '[', colon = ':', vline = '|', cb = ']';
cin >> str;
str1 = str;
n = str.length();
for (i = 0; i < str.length(); i++) {
if (str[i] != '[' && str[i] != ']' && str[i] != '|' && str[i] != ':') {
str1.erase(str1.begin() + c1);
c1--;
}
c1++;
}
str = str1;
n = str.length();
c1 = 0, c2 = 0;
for (i = 0, j = n - 1; (i < j) && (i >= 0 && j >= 0);) {
if (str[i] != ob) {
str1.erase(str1.begin() + c1);
i++;
}
if (str[j] != cb) {
str1.erase(str1.end() - 1 - c2);
j--;
}
if (str[i] == ob && str[j] == cb) break;
}
str = str1;
n = str.length();
c1 = 1, c2 = 1;
if ((str[0] == ob && str[n - 1] == cb) && n > 1) {
for (i = 1, j = n - 2; ((i != j && i < j) && (i >= 0 && j >= 0));) {
if (str[i] != colon) {
str1.erase(str1.begin() + c1);
i++;
}
if (str[j] != colon) {
str1.erase(str1.end() - 1 - c2);
j--;
}
if (str[i] == colon && str[j] == colon) break;
}
str = str1;
n = str.length();
if (n >= 4) {
c1 = 2;
if (str[1] == colon && str[n - 2] == colon) {
for (j = 2; j <= n - 3; j++) {
if (str[j] != vline) {
str1.erase(str1.begin() + c1);
} else
c1++;
}
str = str1;
cout << str.length();
}
} else
cout << "-1" << endl;
} else
cout << "-1" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, i, a[1111], L[11], R[11];
void dfs(int made) {
bool S = 1;
for (int i = 1; i <= n; ++i)
if (a[i] != i) {
S = 0;
break;
}
if (S) {
printf("%d\n", made - 1);
for (int i = made - 1; i > 0; --i) printf("%d %d\n", L[i], R[i]);
exit(0);
}
if (made > 3) return;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
if ((abs(a[i - 1] - a[j]) == 1) || (abs(a[i] - a[j + 1]) == 1)) {
L[made] = i, R[made] = j;
reverse(a + i, a + j + 1);
dfs(made + 1);
reverse(a + i, a + j + 1);
}
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
a[0] = 0, a[n + 1] = n + 1;
dfs(1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using db = double;
using vi = vector<int>;
const int inf = 0x3f3f3f3f;
const db eps = 1e-8;
const int mod = 998244353;
ll qpow(ll a, ll b) {
ll ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
const int maxn = 2e5 + 7;
int a[maxn], b[maxn];
int vis[maxn], p[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n, k;
cin >> n >> k;
for (int i = 0; i <= n + 1; i++) {
p[i] = 0;
vis[i] = 0;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[a[i]] = i;
}
a[n + 1] = 0;
a[0] = 0;
for (int i = 1; i <= k; i++) {
cin >> b[i];
vis[b[i]] = 1;
}
ll ans = 1;
vis[0] = 1;
for (int i = 1; i <= k; i++) {
int tmp = b[i];
int pos = p[tmp];
if (vis[a[pos - 1]] == 1 && vis[a[pos + 1]] == 1) {
ans = 0;
break;
} else {
if (vis[a[pos - 1]] == 0 && vis[a[pos + 1]] == 0) {
ans = ans * 2 % mod;
}
}
vis[tmp] = 0;
}
cout << ans << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
long long poww(long long a, long long b, long long mod) {
long long res = 1;
if (b < 0) b = (b % (mod - 1) + mod - 1) % (mod - 1);
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) res = 1ll * res * a % mod;
return res;
}
void Max(long long& x, long long y) { x = max(x, y); }
void Min(long long& x, long long y) { x = min(x, y); }
void OK(bool yes) { cout << (yes ? "Yes\n" : "No\n"); }
const long long N = 200500, M = 2010, LN = (1 << 24), K = 17, Mx = 4e6 + 50,
inf = 3e18, Mod1 = 1e9 + 7, Mod2 = 999997457;
const long double pi = acos(-1), eps = 1e-12;
long long Fact[N];
void init() {
Fact[0] = 1ll;
for (int i = 1; i < N; i++) Fact[i] = (1ll * Fact[i - 1] * i) % Mod;
}
int Cnk(long long x, long long y) {
if (y > x) return 0;
return (((Fact[x] * poww(Fact[y], -1, Mod)) % Mod) *
poww(Fact[x - y], -1, Mod)) %
Mod;
}
void Add(long long& x, long long y, int j = 0) {
long long mod = Mod;
if (j == 1) mod = Mod1;
if (j == 2) mod = Mod2;
x %= mod;
y %= mod;
if (x < 0) x += mod;
if (y < 0) y += mod;
x = (x + y >= mod ? x + y - mod : x + y);
}
long long dp[2020], a[2020];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int T = 1;
int Case = 1;
init();
cin >> T;
while (T--) {
int n, k;
cin >> n >> k;
for (int i = 0; i <= n; i++) dp[i] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i - a[i] >= 0) dp[i] = 1;
}
long long Ans = inf;
if (k == 1) {
for (int i = 1; i <= n; i++)
if (a[i] <= i) Min(Ans, i - a[i]);
if (Ans == inf)
cout << -1 << '\n';
else
cout << Ans << '\n';
continue;
}
for (int i = 1; i <= n; i++) {
if (i - a[i] < 0) continue;
for (int j = 1; j < i; j++) {
if (j - a[j] < 0) continue;
if (i - a[i] >= j - a[j] && a[i] > a[j]) {
Max(dp[i], dp[j] + 1);
if (dp[i] >= k) {
Min(Ans, i - a[i]);
}
}
}
}
if (Ans < inf)
cout << Ans << '\n';
else
cout << -1 << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10, D = 15;
int n, d, mod;
int dp[D][N][N];
int ifac[N];
void Add(int &x, int y) {
if ((x += y) >= mod && (x -= mod))
;
}
int binom(int n, int m) {
n %= mod;
if (n < m) return 0;
int pro = 1;
for (int i = n; i >= n - m + 1; i--) pro = 1ll * pro * i % mod;
pro = 1ll * pro * ifac[m] % mod;
return pro;
}
int DP(int g, int n, int k) {
if (dp[g][n][k] != -1) return dp[g][n][k];
int &res = dp[g][n][k];
if (n == 1) return res = (g % (d - 1) == 0);
if (g == 0) return res = (n == 1);
if (k == 0) return 0;
res = 0;
Add(res, DP(g, n, k - 1));
if ((k - 1) % (d - 1)) return res;
int f = DP(d - 1, k, k - 1);
for (int i = 1; i <= g; i++) {
if (i * k >= n) break;
Add(res, 1ll * DP(g - i, n - k * i, k - 1) * binom(f + i - 1, i) % mod);
}
return res;
}
void quit(int x) { printf("%d\n", x), exit(0); }
void initmath(int n) {
ifac[0] = ifac[1] = 1;
for (int i = 2; i <= n; i++)
ifac[i] = 1ll * (mod - mod / i) * ifac[mod % i] % mod;
for (int i = 1; i <= n; i++) ifac[i] = 1ll * ifac[i - 1] * ifac[i] % mod;
return;
}
int calc(int g, int n, int k) {
if (n == 1 || n == 2) return 1;
if (n < g + 1) return 0;
if ((n - g - 1) % (d - 1) != 0) return 0;
return DP(g, n, k);
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d%d%d", &n, &d, &mod);
if (n == 1 || n == 2) quit(1);
if (n < d + 1) quit(0);
if ((n - d - 1) % (d - 1) != 0) quit(0);
initmath(d);
if (n & 1) quit(DP(d, n, n / 2));
int ans = DP(d, n, n / 2);
ans = (ans - binom(DP(d - 1, n / 2, n / 2), 2) + mod) % mod;
quit(ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sum = 0;
scanf("%I64d", &n);
cout << (n / 2) + 1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 500;
vector<pair<int, int> > g[N];
int n, sz[N];
long long dp[3][3], ans;
bool used[N];
void sizes(int v, int p) {
sz[v] = 1;
for (auto u : g[v]) {
if (u.first == p || used[u.first]) continue;
sizes(u.first, v);
sz[v] += sz[u.first];
}
}
int centroid(int v, int p, int sz_comp) {
for (auto u : g[v])
if (u.first != p && !used[u.first] && sz[u.first] > sz_comp / 2)
return centroid(u.first, v, sz_comp);
return v;
}
void dfs1(int v, int p, int f, int e) {
ans++;
if (f == e) ans++;
if (f == 0 && e == 0) ans += 2 * dp[0][0] + dp[0][1] + dp[1][1];
if (f == 0 && e == 1) ans += dp[0][0];
if (f == 1 && e == 0) ans += dp[1][1];
if (f == 1 && e == 1) ans += 2 * dp[1][1] + dp[0][0] + dp[1][0];
for (auto u : g[v]) {
if (u.first == p || used[u.first]) continue;
if (f < e && u.second < e) continue;
if (f > e && u.second > e) continue;
dfs1(u.first, v, f, u.second);
}
}
void dfs2(int v, int p, int f, int e) {
dp[f][e]++;
for (auto u : g[v]) {
if (u.first == p || used[u.first]) continue;
if (f < e && u.second < e) continue;
if (f > e && u.second > e) continue;
dfs2(u.first, v, f, u.second);
}
}
void solve(int v) {
sizes(v, v);
dp[0][0] = dp[0][1] = dp[1][0] = dp[1][1] = 0;
v = centroid(v, v, sz[v]);
for (auto u : g[v]) {
if (used[u.first]) continue;
dfs1(u.first, v, u.second, u.second);
dfs2(u.first, v, u.second, u.second);
}
used[v] = 1;
for (auto u : g[v])
if (!used[u.first]) solve(u.first);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, z;
cin >> u >> v >> z;
g[u].push_back({v, z});
g[v].push_back({u, z});
}
solve(1);
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline void p(int x[], int n) {
int i;
for (i = 0; i < n; i++) cout << x[i] << " ";
cout << endl;
}
vector<int> bfs(vector<int> adj[], int root, int N) {
int lev = 0;
vector<int> level(N + 1);
vector<bool> vis(N + 1, false);
queue<int> st;
st.push(root);
level[root] = lev;
while (!st.empty()) {
int second = st.front();
vis[second] = true;
st.pop();
for (int i = 0; i < adj[second].size(); i++) {
if (!vis[adj[second][i]]) {
vis[adj[second][i]] = true;
st.push(adj[second][i]);
level[adj[second][i]] = level[second] + 1;
}
}
}
return level;
}
void solve() {
long long int N, M, K, i, j, sum = 0;
cin >> N >> M;
long long int res = abs(N - M);
if (res % 10) {
cout << (res / 10) + 1;
} else {
cout << (res / 10);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1, c = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 0 |
#include <cstdio>
#include <iostream>
using namespace std;
#define maxn 400005
#define inf 0x3f3f3f3f
int n, ans;
bool flag[maxn];
int minn[maxn], maxx[maxn], f[maxn];
int main() {
scanf( "%d", &n );
for( int i = 1, x, y;i <= n;i ++ ) {
scanf( "%d %d", &x, &y );
if( x <= n && y <= n ) return ! printf( "-1\n" );
if( x <= n ) f[x] = y, flag[x] = 0;
else f[y] = x, flag[y] = 1;
}
minn[0] = inf, maxx[n + 1] = -inf;
for( int i = 1;i <= n;i ++ )
minn[i] = min( minn[i - 1], f[i] );
for( int i = n;i;i -- )
maxx[i] = max( maxx[i + 1], f[i] );
int top_s1 = inf, top_s2 = inf, tot_s1 = 0, tot_s2 = 0, rev_s1 = 0, rev_s2 = 0;
for( int i = 1;i <= n;i ++ ) {
if( top_s1 > top_s2 ) {
swap( top_s1, top_s2 );
swap( tot_s1, tot_s2 );
swap( rev_s1, rev_s2 );
} else;
if( top_s1 > f[i] )
top_s1 = f[i], tot_s1 ++, rev_s1 += flag[i];
else if( top_s2 > f[i] )
top_s2 = f[i], tot_s2 ++, rev_s2 += flag[i];
else
return ! printf( "-1\n" );
if( minn[i] > maxx[i + 1] ) {
ans += min( rev_s1 + tot_s2 - rev_s2, rev_s2 + tot_s1 - rev_s1 );
top_s1 = top_s2 = inf, tot_s1 = tot_s2 = rev_s1 = rev_s2 = 0;
}
}
printf( "%d\n", ans );
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1E6 + 7;
vector<long long> pre[N], dis[N];
int t[N];
long long query(int s, long long h) {
if (h <= 0) return 0;
int p = upper_bound(begin(dis[s]), end(dis[s]), h) - begin(dis[s]);
return p * h - pre[s][p - 1];
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 2; i <= n; i++) cin >> t[i];
for (int i = n; i >= 1; i--) {
dis[i].emplace_back(0);
for (int c = 0; c < 2; c++) {
int x = 2 * i + c;
if (x > n) continue;
for (long long it : dis[x]) {
dis[i].emplace_back(it + t[x]);
}
}
sort(begin(dis[i]), end(dis[i]));
int tot = dis[i].size();
pre[i].resize(tot);
for (int j = 1; j < tot; j++) pre[i][j] = pre[i][j - 1] + dis[i][j];
}
while (m--) {
int a, h;
long long ans = 0;
cin >> a >> h;
ans += query(a, h);
while (a > 1) {
int b = a;
a >>= 1;
h -= t[b];
if (h <= 0) break;
ans += h;
int x = 2 * a == b ? 2 * a + 1 : 2 * a;
if (x <= n) ans += query(x, h - t[x]);
}
cout << ans << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int f[100005], kind[100005];
int find(int x) {
if (f[x] == x) return x;
int nowfa = f[x];
f[x] = find(f[x]);
kind[x] = (kind[x] + kind[nowfa] + 1) % 2;
return f[x];
}
void unions(int fa1, int fa2, int u, int v, int kinds) {
f[fa1] = fa2;
kind[fa1] = (kind[v] - kind[u] + 2 + kinds) % 2;
}
long long quick_pow(long long x, long long y, int mod) {
long long z = 1;
while (y) {
if (y % 2) z = (z * x) % mod;
x = (x * x) % mod;
y = y / 2;
}
return z;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
f[i] = i;
kind[i] = 1;
}
int u, v, kinds;
int ok = 1;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &kinds);
if (ok == 0) continue;
int fa1 = find(u), fa2 = find(v);
if (fa1 == fa2) {
if (kinds == 0 && kind[u] == kind[v])
ok = 0;
else if (kinds == 1 && kind[u] != kind[v])
ok = 0;
} else {
unions(fa1, fa2, u, v, kinds);
}
}
if (ok == 0)
printf("0\n");
else {
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (f[i] == i) cnt++;
}
long long ans = quick_pow(2, cnt - 1, 1000000007);
printf("%I64d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string a[50][50];
int n, m;
set<string> temp;
int cnt;
pair<int, int> square1, square2;
bool check() {
for (int z = 0; z < n; z++) {
for (int k = 0; k < m; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (abs(z - i) < 3 && abs(k - j) < 3) {
continue;
}
if ((i + 2) > n - 1 || (z + 2) > n - 1 || abs(j + 2) > m - 1 ||
(k + 2) > m - 1) {
continue;
}
set<char> rank1, suit1, rank2, suit2;
for (int y = i; y <= i + 2; y++) {
for (int l = j; l <= j + 2; l++) {
string x = a[y][l];
rank1.insert(x[0]);
suit1.insert(x[1]);
}
}
for (int y = z; y <= z + 2; y++) {
for (int l = k; l <= k + 2; l++) {
string x = a[y][l];
rank2.insert(x[0]);
suit2.insert(x[1]);
}
}
if (((int)rank1.size() == 9 || (int)suit1.size() == 1) &&
((int)rank2.size() == 9 || (int)suit2.size() == 1)) {
square1.first = i + 1;
square1.second = j + 1;
square2.first = z + 1;
square2.second = k + 1;
return 1;
}
}
}
}
}
return 0;
}
int main() {
string ranks[] = {"2", "3", "4", "5", "6", "7", "8",
"9", "T", "J", "Q", "K", "A"};
string suits[] = {"C", "D", "H", "S"};
for (int i = 0; i < 13; i++) {
for (int j = 0; j < 4; j++) {
string x = ranks[i] + suits[j];
temp.insert(x);
}
}
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == "J1" || a[i][j] == "J2") {
cnt++;
} else {
temp.erase(a[i][j]);
}
}
}
vector<string> table;
for (auto it = temp.begin(); it != temp.end(); it++) {
table.push_back(*it);
}
string j1, j2;
for (int z = 0; z < (int)table.size(); z++) {
for (int k = 0; k < (int)table.size(); k++) {
if (z == k) continue;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == "J1") {
a[i][j] = table[z];
j1 = table[z];
}
if (a[i][j] == "J2") {
a[i][j] = table[k];
j2 = table[k];
}
}
}
if (check()) {
cout << "Solution exists." << endl;
if (j1 != "" && j2 != "") {
cout << "Replace J1 with " << j1 << " and J2 with " << j2 << "."
<< endl;
}
if (j1 != "" && j2 == "") {
cout << "Replace J1 with " << j1 << "." << endl;
}
if (j2 != "" && j1 == "") {
cout << "Replace J2 with " << j2 << "." << endl;
}
if (j1 == "" && j2 == "") {
cout << "There are no jokers." << endl;
}
cout << "Put the first square to (" << square1.first << ", "
<< square1.second << ")." << endl;
cout << "Put the second square to (" << square2.first << ", "
<< square2.second << ")." << endl;
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == j1) {
a[i][j] = "J1";
}
if (a[i][j] == j2) {
a[i][j] = "J2";
}
}
}
}
}
cout << "No solution.";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int lose = 1, win = 2;
int cur[2][7111];
int k[2];
int what[2][7111];
int dp[2][7111];
int n;
void f(int p, int q, int r) {
if (dp[p][q]) return;
dp[p][q] = r;
int i;
if (r == lose) {
for (i = 1; i <= k[!p]; i++) {
f(!p, (q + n - what[!p][i]) % n, win);
}
} else {
for (i = 1; i <= k[!p]; i++) {
if (!--cur[!p][(q + n - what[!p][i]) % n])
f(!p, (q + n - what[!p][i]) % n, lose);
}
}
}
int main() {
int i;
scanf("%d", &n);
scanf("%d", &k[0]);
for (i = 1; i <= k[0]; i++) scanf("%d", &what[0][i]);
for (i = 0; i < n; i++) cur[0][i] = k[0];
scanf("%d", &k[1]);
for (i = 1; i <= k[1]; i++) scanf("%d", &what[1][i]);
for (i = 0; i < n; i++) cur[1][i] = k[1];
dp[0][0] = lose, dp[1][0] = lose;
for (i = 1; i <= k[0]; i++) f(0, (n - what[0][i]) % n, win);
for (i = 1; i <= k[1]; i++) f(1, (n - what[1][i]) % n, win);
for (int x = 0; x < 2; x++) {
for (i = 1; i < n; i++) {
if (dp[x][i] == win)
printf("Win ");
else if (dp[x][i] == lose)
printf("Lose ");
else
printf("Loop ");
}
printf("\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int query(int u, int v) {
printf("? %d %d\n", u, v);
fflush(stdout);
int ans;
scanf("%d", &ans);
return ans;
}
vector<int> G[2020];
void dfs(int v, int fa) {
G[v].erase(remove(G[v].begin(), G[v].end(), fa), G[v].end());
for (auto u : G[v]) dfs(u, v);
}
void dfs2(int v) {
while (G[v].size() >= 2U) {
int a = G[v][G[v].size() - 1], b = G[v][G[v].size() - 2], lca = query(a, b);
if (lca == a) {
dfs2(a);
return;
} else if (lca == b) {
dfs2(b);
return;
} else
G[v].pop_back(), G[v].pop_back();
}
if (G[v].size() == 0U) {
printf("! %d\n", v);
fflush(stdout);
exit(0);
}
if (G[G[v][0]].size() == 0U) {
int c = query(G[v][0], v);
printf("! %d\n", c);
fflush(stdout);
exit(0);
}
int a = G[v][0], b = G[a].back(), lca = query(v, b);
if (lca == v) {
printf("! %d\n", v);
fflush(stdout);
exit(0);
} else if (lca == a) {
G[a].pop_back();
dfs2(a);
} else if (lca == b) {
dfs2(b);
} else
assert(false);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
static int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, -1);
dfs2(1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
namespace solution {
class SolutionInterface {
public:
virtual int run() = 0;
protected:
virtual void pre_calc() {}
virtual bool action() = 0;
virtual void init(){};
virtual bool input() { return false; };
virtual void output(){};
SolutionInterface() {}
private:
};
} // namespace solution
namespace solution {
class SolutionBase : public SolutionInterface {
public:
virtual int run() {
pre_calc();
while (action())
;
return 0;
}
};
} // namespace solution
namespace solution {}
namespace solution {
using namespace std;
}
namespace solution {
const int SIZE = 100 + 11;
const int OFF = 0;
const int ON = 1;
const long long DP_NONE = -100;
const long long NONE = std::numeric_limits<long long>::min() / 2;
int n, m;
string jiro_p[SIZE];
int jiro_s[SIZE];
int ciel_s[SIZE];
int jiro_def_s[SIZE];
int jiro_def_s_num;
int jiro_atk_s[SIZE];
int jiro_atk_s_num;
long long dp[SIZE][SIZE][SIZE][2];
long long result;
} // namespace solution
namespace solution {
class Solver {
public:
void solve() {
split_jiro();
sort_cards();
result = calc_maximum_damages();
}
void sort_cards() {
std::sort(jiro_def_s, jiro_def_s + jiro_def_s_num);
std::sort(jiro_atk_s, jiro_atk_s + jiro_atk_s_num);
std::sort(ciel_s, ciel_s + m);
}
long long calc_maximum_damages() {
return std::max(rec(0, 0, 0, OFF), rec(0, 0, 0, ON));
}
long long rec(int jiro_atk, int jiro_def, int ciel, int flag) {
long long& res = dp[jiro_atk][jiro_def][ciel][flag];
if (res != DP_NONE) return res;
if (ciel >= m) {
if (flag == ON &&
(jiro_atk < jiro_atk_s_num || jiro_def < jiro_def_s_num)) {
return res = NONE;
}
return res = 0;
}
long long ret = NONE;
ret = max(ret, rec(jiro_atk, jiro_def, ciel + 1, flag));
ret = max(ret, rec(jiro_atk, jiro_def, ciel + 1, ON) + ciel_s[ciel]);
if (jiro_atk < jiro_atk_s_num && ciel_s[ciel] >= jiro_atk_s[jiro_atk]) {
ret = max(ret, rec(jiro_atk + 1, jiro_def, ciel + 1, flag) +
ciel_s[ciel] - jiro_atk_s[jiro_atk]);
}
if (jiro_def < jiro_def_s_num && ciel_s[ciel] > jiro_def_s[jiro_def]) {
ret = max(ret, rec(jiro_atk, jiro_def + 1, ciel + 1, flag));
}
return res = ret;
}
void split_jiro() {
for (int i = 0; i < n; ++i) {
if (jiro_p[i] == "ATK") {
jiro_atk_s[jiro_atk_s_num++] = jiro_s[i];
} else {
jiro_def_s[jiro_def_s_num++] = jiro_s[i];
}
}
}
private:
};
} // namespace solution
namespace solution {
class Solution : public SolutionBase {
public:
protected:
virtual bool action() {
init();
if (!input()) return false;
solver.solve();
output();
return true;
}
void init() {
for (int i = 0; i < SIZE; ++i)
for (int j = 0; j < SIZE; ++j)
for (int k = 0; k < SIZE; ++k)
for (int l = 0; l < 2; ++l) dp[i][j][k][l] = DP_NONE;
jiro_atk_s_num = 0;
jiro_def_s_num = 0;
}
bool input() {
if (!(cin >> n >> m)) return false;
for (int i = 0; i < n; ++i) {
cin >> jiro_p[i] >> jiro_s[i];
}
for (int i = 0; i < m; ++i) {
cin >> ciel_s[i];
}
return true;
}
void output() { cout << result << endl; }
private:
Solver solver;
};
} // namespace solution
int main() { return solution::Solution().run(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int result = n;
int a, b, c, d, y = 0;
int input[4040];
string sym;
int i;
for (i = 0; i < n; i++) {
int num1, num2;
cin >> num1;
a = num1 / 10;
b = num1 % 10;
cin >> num2;
d = num2 / 10;
c = num2 % 10;
input[y] = a * 1000 + b * 100 + c * 10 + d;
for (int k = 0; k < 4 * i; k++) {
if (input[y] == input[k]) {
result--;
break;
}
}
input[y + 1] = b * 1000 + c * 100 + d * 10 + a;
input[y + 2] = c * 1000 + d * 100 + a * 10 + b;
input[y + 3] = d * 1000 + a * 100 + b * 10 + c;
y += 4;
if (i < n - 1) {
cin >> sym;
} else
continue;
}
cout << result << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char buf[200];
int rem[256];
int main() {
rem['>'] = 8;
rem['<'] = 9;
rem['+'] = 10;
rem['-'] = 11;
rem['.'] = 12;
rem[','] = 13;
rem['['] = 14;
rem[']'] = 15;
int res = 0;
int bim = 1000003;
scanf("%s", buf);
int len = strlen(buf);
int p2 = 1;
for (int i = len; i--;) {
res += p2 * rem[buf[i]];
res %= bim;
p2 *= 16;
p2 %= bim;
}
printf("%d\n", res);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
return 0;
}
if (n == 2) {
cout << 3 << endl;
return 0;
}
long long a, b, c;
a = 0;
b = 3;
c = 6;
for (int i = 3; i <= n; i++) {
c = ((a * 3) % 1000000007 + (b * 2) % 1000000007) % 1000000007;
a = b;
b = c;
}
cout << c << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
char g[s.length()];
int j = 0;
for (int i = 2; i < s.length(); i++) {
if (s[i] == s[i - 1] && s[i - 1] == s[i - 2] && s[i] != '0') {
s[i - 2] = '0';
char cc = s[i];
while (i + 1 < s.length() && s[i + 1] == cc) {
s[i + 1] = '0';
i++;
}
}
}
for (int i = 0; i < s.length(); i++) {
if (s[i] != '0') g[j] = s[i], j++;
}
for (int i = 3; i < j; i++) {
if (g[i] == g[i - 1] && g[i - 2] == g[i - 3]) {
g[i] = '0';
}
}
for (int i = 0; i < j; i++)
if (g[i] != '0') cout << g[i];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
void f(long long x) {
long long t = x;
int s = 0;
while (t) {
s += t % 10;
t /= 10;
}
t = ans;
while (t) {
s -= t % 10;
t /= 10;
}
if (s > 0)
ans = x;
else if (s == 0)
ans = max(ans, x);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long x;
cin >> x;
f(x);
long long n = 1;
while (n <= x / 10) {
n *= 10;
f(x / n * n - 1);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma optimize("Ofast")
using namespace std;
using ll = long long;
const int N = 1e5 + 5;
int main() {
ios_base::sync_with_stdio(0);
vector<ll> fib;
fib.push_back(0);
fib.push_back(2);
fib.push_back(3);
ll sum = 5;
while (1) {
ll x = fib[fib.size() - 1] + fib[fib.size() - 2];
sum += x;
if (sum <= 1e18)
fib.push_back(x);
else
break;
}
for (int i = 1; i < fib.size(); ++i) {
fib[i] = fib[i] + fib[i - 1];
}
ll n;
cin >> n;
if (n == 2)
cout << 1;
else if (n == 3)
cout << 2;
else {
int indx = lower_bound(fib.begin(), fib.end(), (n - 3) + 1) - fib.begin();
--indx;
cout << indx + 2 << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[300000] = {0}, t[300000] = {0};
void solve(int k) {
int n = strlen(s + 1);
int m = strlen(t + 1);
for (int i = 1; i <= m; i++) {
if (t[i] >= '5') {
t[i] = '\0';
t[i - 1]++;
for (int j = i - 1; j > 0; j--) {
if (t[j] > '9') {
t[j] = '0';
t[j - 1]++;
}
}
break;
} else if (t[i] == '4') {
int j;
for (j = i; t[j] == '4'; j++)
;
if (t[j] >= '5') {
for (; j >= i && k > 0; k--) {
t[j] = '\0';
t[--j]++;
}
break;
}
i = j;
}
}
s[n] += t[0];
for (int i = n; i > 0; i--) {
if (s[i] > '9') {
s[i] = '0';
s[i - 1]++;
}
}
s[0] += '0';
t[0] = '\0';
for (int i = 1; i <= m + 1; i++) {
if (t[i] == '\0') {
for (int j = i - 1; t[j] == '0'; j--) t[j] = '\0';
break;
}
}
printf("%s", s[0] == '0' ? s + 1 : s);
printf(t[1] == '\0' ? "\n" : ".%s\n", t + 1);
}
int main() {
int k;
scanf("%*d%d %[0-9].%[0-9]", &k, s + 1, t + 1);
solve(k);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y;
cin >> x >> y;
cout << min(x, y) << " " << (max(x, y) - min(x, y)) / 2 << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int M = 1000000007;
const long double PI = acos(-1);
int n, m, t, l, c;
char x;
long long p;
int good[N][N], aux[N][N];
bool a[N][N];
int dl[] = {-1, 0, 1, 0};
int dc[] = {0, 1, 0, -1};
queue<pair<int, int> > q;
bool inline inside(pair<int, int> v) {
return v.first >= 1 && v.first <= n && v.second >= 1 && v.second <= m;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int i, j;
cin >> n >> m >> t;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
cin >> x;
a[i][j] = x - '0';
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (a[i][j] == a[i - 1][j] && i > 1) {
good[i][j] = aux[i][j] = 1;
q.push({i, j});
continue;
}
if (a[i][j] == a[i][j + 1] && j < m) {
good[i][j] = aux[i][j] = 1;
q.push({i, j});
continue;
}
if (a[i][j] == a[i + 1][j] && i < n) {
good[i][j] = aux[i][j] = 1;
q.push({i, j});
continue;
}
if (a[i][j] == a[i][j - 1] && j > 1) {
good[i][j] = aux[i][j] = 1;
q.push({i, j});
continue;
}
}
pair<int, int> pf, v;
while (!q.empty()) {
pf = q.front();
q.pop();
for (i = 0; i < 4; i++) {
v.first = pf.first + dl[i];
v.second = pf.second + dc[i];
if (inside(v) && !aux[v.first][v.second]) {
aux[v.first][v.second] = 1 + aux[pf.first][pf.second];
good[v.first][v.second] = aux[v.first][v.second];
q.push(v);
}
}
}
for (i = 1; i <= t; i++) {
cin >> l >> c >> p;
if (good[l][c] == 0)
cout << a[l][c] << '\n';
else {
if (good[l][c] > p)
cout << a[l][c] << '\n';
else {
if (good[l][c] % 2 == p % 2)
cout << 1 - a[l][c] << '\n';
else
cout << a[l][c] << '\n';
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
long long sum = 0;
bool hasOdd = false;
for (int c = 0; c < N; c++) {
long long z;
cin >> z;
sum += z;
if (z % 2 == 1) {
hasOdd = true;
}
}
if (sum % 2 == 0) {
if (hasOdd) {
cout << "First" << endl;
} else {
cout << "Second" << endl;
}
} else {
cout << "First" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("-O2")
const long long LIM = 2e5 + 5;
const long long MOD = 1e9 + 7;
const long long inf = 1e10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, a, b;
cin >> n >> a >> b;
vector<int> r(4, 0);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
x = x - a;
y = y - b;
if (x >= 1) r[0]++;
if (y >= 1) r[1]++;
if (x <= (-1)) r[2]++;
if (y <= (-1)) r[3]++;
}
int maxsofar = 0;
for (int i = 0; i < 4; i++) {
maxsofar = max(r[i], maxsofar);
}
cout << maxsofar << endl;
int j;
for (int i = 0; i < 4; i++) {
if (maxsofar == r[i]) j = i;
}
switch (j) {
case 0:
cout << a + 1 << " " << b;
break;
case 1:
cout << a << " " << b + 1;
break;
case 2:
cout << a - 1 << " " << b;
break;
case 3:
cout << a << " " << b - 1;
break;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long k = 0, k1 = 0, k2 = 0;
for (long long i = 0; i < s.size(); ++i) {
if (s[i] == 'A') k++;
if (s[i] == 'B') k1++;
if (s[i] == 'C') k2++;
}
if (k + k2 == k1)
cout << "YES";
else
cout << "NO";
cout << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool appear[100010];
bool on[100010];
int _time[100010];
bool bad[100010];
struct event {
int z, id;
};
vector<event> in;
vector<event> comp;
int main() {
int n, m;
scanf("%d%d\n", &n, &m);
char c;
int d;
vector<int> prv;
for (int i = 0; i < m; i++) {
scanf("%c %d\n", &c, &d);
d--;
appear[d] = true;
if (c == '-') {
if (!on[d]) prv.push_back(d);
on[d] = false;
}
if (c == '+') {
on[d] = true;
_time[d] = i;
}
in.push_back({c == '+' ? 1 : -1, d});
}
for (auto it = prv.rbegin(); it != prv.rend(); it++) {
comp.push_back({1, *it});
}
for (auto pp : in) {
comp.push_back(pp);
}
vector<pair<int, int>> vp;
for (int i = 0; i < n; i++) {
if (on[i]) {
vp.push_back({-_time[i], i});
}
}
sort(begin(vp), end(vp));
for (int i = 0; i < vp.size(); i++) {
comp.push_back({-1, vp[i].second});
}
int cnt = 0;
vector<int> ap;
int leader = -1;
for (auto pp : comp) {
if (pp.z == 1) {
if (cnt != 0) bad[pp.id] = true;
cnt++;
} else {
cnt--;
if (cnt != 0) bad[pp.id] = true;
if (cnt == 0) {
if (leader >= 0 && pp.id != leader) {
leader = -2;
} else if (leader == -1) {
leader = pp.id;
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!appear[i])
ans++;
else if (!bad[i] && i == leader)
ans++;
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
if (!appear[i] || (!bad[i] && i == leader)) printf("%d ", i + 1);
}
puts("");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 51;
int cnt, k, tmp;
int num[MAXN];
inline int read() {
register int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
int main() {
cnt = read(), k = read();
for (register int i = 0; i < cnt; i++) {
num[i] = read();
}
sort(num, num + cnt);
for (register int i = 0; i < cnt; i++) {
if (num[i] - k >= num[tmp]) {
tmp++;
}
}
printf("%d\n", min(tmp, cnt >> 1));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, next;
};
Edge E[400005];
int head[200005], Ecou;
int N;
void init() {
Ecou = 0;
memset(head, -1, sizeof(head));
}
inline void addEdge(int u, int v) {
E[Ecou].to = v;
E[Ecou].next = head[u];
head[u] = Ecou++;
}
int ccc = 0;
inline int cmd(char c, int v) {
++ccc;
assert(ccc <= 36);
printf("%c %d\n", c, v);
fflush(stdout);
int ret;
scanf("%d", &ret);
assert(ret != -1);
return ret;
}
int vis[200005];
int fa[200005];
int ans, ansrem, sum;
int nnn[200005], dep[200005];
int dfs1(int u, int f) {
int ret = 1;
fa[u] = f;
int maxn = -1, rem = -1;
for (int i = head[u]; i != -1; i = E[i].next)
if (E[i].to != f && vis[E[i].to] == 0) {
dep[E[i].to] = dep[u] + 1;
int tmp = dfs1(E[i].to, u);
ret += tmp;
if (tmp > maxn) {
maxn = tmp;
rem = E[i].to;
}
}
nnn[u] = rem;
return ret;
}
vector<int> path;
int findPath(int r) {
path.clear();
dep[r] = 0;
dfs1(r, -1);
for (int i = r; i != -1; i = nnn[i]) path.push_back(i);
return *(path.rbegin());
}
int main() {
init();
scanf("%d", &N);
for (int i = 1; i < N; ++i) {
int a, b;
scanf("%d %d", &a, &b);
addEdge(a, b);
addEdge(b, a);
}
int depx = cmd('d', 1);
int root = 1;
while (1) {
if (depx == 0) {
printf("! %d\n", root);
break;
}
int v = findPath(root);
int dis1 = cmd('d', v);
if (dis1 == 0) {
printf("! %d\n", v);
break;
}
int depy = (depx + dep[v] - dis1) / 2;
int y = path[depy];
assert(dep[y] == depy);
if (depy == depx) {
printf("! %d\n", y);
break;
}
vis[y] = 1;
root = cmd('s', y);
depx -= depy + 1;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, f[100001][2], b[100001][2], c[100001], i, m, v, kq;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
f[i][0] = 0;
b[i][0] = 0;
}
for (i = 1; i <= n; i++) {
scanf("%d", &v);
f[v][0]++;
f[v][1] = i;
}
for (i = 1; i <= m; i++) {
scanf("%d", &v);
c[i] = v;
b[v][0]++;
b[v][1] = i;
}
kq = 1;
for (i = 1; i <= n; i++) {
if (f[i][0] == 0 && b[i][0] > 0) {
kq = 0;
break;
}
if (f[i][0] > 1 && b[i][0] > 0) kq = 2;
}
if (kq == 0)
printf("Impossible");
else if (kq == 2)
printf("Ambiguity");
else {
printf("Possible\n");
for (i = 1; i <= m; i++) printf("%d ", f[c[i]][1]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 1e18;
const long long INF = 1e9;
const long long MOD = 10000007;
long long strtoll(string s) {
stringstream str(s);
long long number = 0;
str >> number;
return number;
}
string lltostr(long long n) {
stringstream ss;
ss << n;
return ss.str();
}
long long power(long long a, long long b, long long m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long t = power(a, b / 2, m);
t = (t * t) % m;
if (b & 1) t = (t * a) % m;
return t;
}
long long llsqrt(long long x) {
if (x == 0 || x == 1) return x;
long long start = 1, end = x / 2, ans;
while (start <= end) {
long long mid = (start + end) / 2;
if (mid * mid == x)
return mid;
else if (mid <= x / mid)
ans = mid, start = mid + 1;
else
end = mid - 1;
}
return ans;
}
vector<long long> spf;
void sieve(long long size) {
spf.resize(size + 1);
for (long long i = 1; i <= size; ++i) spf[i] = i;
for (long long i = 4; i <= size; i += 2) spf[i] = 2;
for (long long i = 3; i * i <= size; ++i) {
if (spf[i] == i) {
for (long long j = i * i; j <= size; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
vector<string> s;
for (long long i = 0; i < n; i++) {
string p;
cin >> p;
s.push_back(p);
}
for (long long i = 0; i < n; i++) {
set<long long> ss;
for (long long j = 0; j < m; j++) {
if (s[i][j] == '#') ss.insert(j);
}
for (auto it = ss.begin(); it != ss.end(); it++) {
long long c = *it;
for (long long j = 0; j < n; j++) {
if (s[j][c] == '#') {
for (auto it1 = ss.begin(); it1 != ss.end(); it1++)
if (s[j][*it1] == '#')
continue;
else {
cout << "No";
return 0;
}
}
}
}
}
cout << "Yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int main() {
long long n;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
if (i == 1)
printf("2\n");
else
printf("%lld\n", (i + 1) * (i + 1) * i - i + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long x, long long k, long long p) {
long long base = x % p, r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * base % p;
base = base * base % p;
}
return r;
}
void solve() {
long long n, m;
while (cin >> n >> m) {
if (m <= 2) {
cout << 0 << endl;
continue;
}
n = min(n, m - 1);
long long s = (m >> 1) + 1;
if (n < s) {
cout << 0 << endl;
continue;
}
cout << (n - s + 1) << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> p(n + 1), pos(n + 1), isEnd(n + 1, -1);
for (long long i = 1; i <= n; ++i) cin >> p[i], pos[p[i]] = i;
queue<long long> q;
vector<pair<long long, long long>> f(m + 1);
for (long long i = 1; i <= m; ++i) {
cin >> f[i].first >> f[i].second;
if (pos[f[i].second] < pos[f[i].first]) swap(f[i].second, f[i].first);
isEnd[pos[f[i].second]] = max(isEnd[pos[f[i].second]], pos[f[i].first]);
}
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
if (isEnd[i] == -1)
q.push(i);
else {
while (q.size() && q.front() <= isEnd[i]) {
ans += i - q.front();
q.pop();
}
q.push(i);
}
}
while (q.size()) {
ans += (n + 1) - q.front();
q.pop();
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400000;
int tot = 0;
int h[6 * maxn];
bool used[6 * maxn];
bool ch[30];
vector<int> v[30];
struct Edge {
int u, v, next;
} e[maxn * 12];
int ans = 0;
void add(int u, int v) {
tot++;
e[tot].u = u;
e[tot].v = v;
e[tot].next = h[u];
h[u] = tot;
}
void dfs(int u) {
used[u] = false;
for (int i = h[u]; i != 0; i = e[i].next) {
int k = e[i].v;
if (used[k]) {
dfs(k);
}
}
}
int main() {
string s;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s;
memset(ch, false, sizeof(ch));
int len = s.size();
for (int j = 0; j < len; j++) {
if (!ch[s[j] - 'a']) {
v[s[j] - 'a'].push_back(i);
ch[s[j] - 'a'] = true;
}
}
}
for (int i = 0; i < 26; ++i) {
int len = v[i].size();
if (len <= 1) continue;
for (int k = 1; k < len; k++) {
add(v[i][0], v[i][k]);
add(v[i][k], v[i][0]);
}
}
memset(used, true, sizeof(used));
for (int i = 1; i <= n; i++) {
if (used[i]) {
ans++;
dfs(i);
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
fast();
int n, m, wPos, bPos, left, right;
cin >> n;
int arr[n];
for (int i = 0; (int)i < n; i++) {
cin >> arr[i];
}
cin >> m;
for (int i = 0; (int)i < m; i++) {
cin >> wPos >> bPos;
left = bPos - 1;
right = arr[wPos - 1] - bPos;
if (wPos - 2 >= 0) {
arr[wPos - 2] += left;
}
if (wPos <= n - 1) {
arr[wPos] += right;
}
arr[wPos - 1] = 0;
}
for (int i = 0; (int)i < n; i++) {
cout << arr[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long mod = 1000000007;
long long qpow(long long v, long long st) {
long long r = 1;
while (st) {
if (st & 1) {
r *= v;
r %= mod;
}
v = v * v;
v %= mod;
st = st / 2;
}
return r;
}
long long f[1024];
long long dp[1024][1024];
long long sdp[1024][1024];
long long getDP(int, int);
long long getSdp(int b1, int b2) {
if (sdp[b1][b2] != -1) return sdp[b1][b2];
if (b2 == 0) return getDP(b1 - 2, 0);
sdp[b1][b2] = getSdp(b1, b2 - 1) + getDP(b1 - 2, b2) * qpow(f[b2], mod - 2);
sdp[b1][b2] %= mod;
return sdp[b1][b2];
}
long long getDP(int b1, int b2) {
if (dp[b1][b2] != -1) return dp[b1][b2];
if (!b1) return f[b2];
long long sol = 0;
if (b1 >= 2) {
long long p = getSdp(b1, b2);
p *= f[b2];
p %= mod;
p *= (b1 - 1);
p %= mod;
sol += p;
sol %= mod;
}
if (b2 > 0) {
sol += getDP(b1, b2 - 1) * b2;
sol %= mod;
}
sol += getDP(b1 - 1, b2);
if (sol >= mod) sol %= mod;
dp[b1][b2] = sol;
return dp[b1][b2];
}
int main() {
int i, j, k;
f[0] = 1;
for (i = 1; i <= 1000; i++) {
f[i] = f[i - 1] * i;
f[i] %= mod;
}
j = k = 0;
int n, l;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &l);
if (l == 1)
j++;
else
k++;
}
memset(dp, -1, sizeof(dp));
memset(sdp, -1, sizeof(sdp));
printf("%d\n", (int)getDP(j, k));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct rec {
int x, y, d;
};
int n, m, k;
long long ans;
set<int> s1[200010], s2[200010];
map<pair<int, int>, bool> mp;
int getid(int x, int y, int d) { return d == 1 ? x - y + m + 1 : x + y; }
bool same(rec a, rec b) {
if (a.x == b.x && a.y == b.y && a.d == b.d) return 1;
return 0;
}
bool check(int x, int y) { return mp[make_pair(x, y)]; }
void add(int x, int y) {
s1[getid(x, y, 1)].insert(x);
s2[getid(x, y, 2)].insert(x);
mp[make_pair(x, y)] = 1;
}
inline pair<rec, int> move(rec u) {
rec re;
set<int>::iterator it;
if (u.d == 1) {
it = s1[getid(u.x, u.y, 1)].lower_bound(u.x);
it--;
re.x = u.x - (abs(*it - u.x) - 1);
re.y = u.y - (abs(*it - u.x) - 1);
if (check(re.x - 1, re.y) && check(re.x, re.y - 1))
re.d = 3;
else if (check(re.x - 1, re.y)) {
re.y--;
re.d = 4;
} else if (check(re.x, re.y - 1)) {
re.x--;
re.d = 2;
} else
re.d = 3;
}
if (u.d == 2) {
it = s2[getid(u.x, u.y, 2)].lower_bound(u.x);
it--;
re.x = u.x - (abs(*it - u.x) - 1);
re.y = u.y + (abs(*it - u.x) - 1);
if (check(re.x - 1, re.y) && check(re.x, re.y + 1))
re.d = 4;
else if (check(re.x - 1, re.y)) {
re.y++;
re.d = 3;
} else if (check(re.x, re.y + 1)) {
re.x--;
re.d = 1;
} else
re.d = 4;
}
if (u.d == 3) {
it = s1[getid(u.x, u.y, 1)].lower_bound(u.x);
re.x = u.x + (abs(*it - u.x) - 1);
re.y = u.y + (abs(*it - u.x) - 1);
if (check(re.x + 1, re.y) && check(re.x, re.y + 1))
re.d = 1;
else if (check(re.x + 1, re.y)) {
re.y++;
re.d = 2;
} else if (check(re.x, re.y + 1)) {
re.x++;
re.d = 4;
} else
re.d = 1;
}
if (u.d == 4) {
it = s2[getid(u.x, u.y, 2)].lower_bound(u.x);
re.x = u.x + (abs(*it - u.x) - 1);
re.y = u.y - (abs(*it - u.x) - 1);
if (check(re.x + 1, re.y) && check(re.x, re.y - 1))
re.d = 2;
else if (check(re.x + 1, re.y)) {
re.y--;
re.d = 1;
} else if (check(re.x, re.y - 1)) {
re.x++;
re.d = 3;
} else
re.d = 2;
}
return make_pair(re, abs(*it - u.x));
}
bool solve(rec u) {
rec re = u;
do {
pair<rec, int> cur = move(u);
ans += (long long)cur.second;
if ((cur.first.d + 1) % 4 + 1 == u.d) return 0;
u = cur.first;
} while (!same(re, u));
return 1;
}
void pre_build() {
for (int i = 0; i <= m + 1; i++) {
add(0, i);
add(n + 1, i);
}
for (int i = 1; i <= n; i++) {
add(i, 0);
add(i, m + 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
pre_build();
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
}
int x, y, d;
char ch[5];
scanf("%d%d%s", &x, &y, ch + 1);
if (ch[1] == 'N' && ch[2] == 'W') d = 1;
if (ch[1] == 'N' && ch[2] == 'E') d = 2;
if (ch[1] == 'S' && ch[2] == 'E') d = 3;
if (ch[1] == 'S' && ch[2] == 'W') d = 4;
rec st = {x, y, d};
st = move(st).first;
if (!solve(st)) {
ans--;
st.d = (st.d + 1) % 4 + 1;
solve(st);
}
printf("%lld", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void kk() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
int main() {
kk();
long long int n;
cin >> n;
vector<int> v;
long long int a = 0;
while (n > 0) {
if (n % 7 == 0) {
a = n / 7;
break;
}
n -= 4;
v.push_back(4);
}
if (n < 0) return cout << -1, 0;
while (a--) v.push_back(7);
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) cout << v[i];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solution() {
long long int n;
cin >> n;
vector<long long int> arr(n);
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
long long int cnt = 0;
for (long long int i = n - 1; i > 0; i--) {
if (arr[i - 1] > arr[i]) cnt += arr[i - 1] - arr[i];
}
cout << cnt;
}
int main() {
long long int t = 1;
cin >> t;
while (t--) {
solution();
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, num[70005][11][11];
map<int, int> mp;
char s[15], fuck[70005][15];
void clac() {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= 9; i++) {
mp[num[k][i][i]]--;
for (int j = i + 1; j <= 9; j++) {
mp[num[k][i][j]]--;
}
}
int q = 0, p = 10;
for (int i = 1; i <= 9; i++) {
if (!mp[num[k][i][i]]) p = i, q = i;
for (int j = i + 1; j <= 9; j++) {
if (!mp[num[k][i][j]] && j - i < p - q) {
q = i, p = j;
}
}
}
for (int i = q; i <= p; i++) putchar(fuck[k][i]);
puts("");
for (int i = 1; i <= 9; i++) {
mp[num[k][i][i]]++;
for (int j = i + 1; j <= 9; j++) {
mp[num[k][i][j]]++;
}
}
}
}
inline void splay(int &v) {
v = 0;
char c = 0;
int p = 1;
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
v = (v << 3) + (v << 1) + c - '0';
c = getchar();
}
v *= p;
}
int anc[5];
struct splay_node {
int num, maxx, ls, rs, fath;
bool lazy;
} p[5];
struct lct {
inline void _pushdown(int i) {
p[i].lazy ^= 1;
p[p[i].ls].lazy ^= 1;
p[p[i].rs].lazy ^= 1;
int t = p[i].ls;
p[i].ls = p[i].rs;
p[i].rs = t;
}
inline void _pushup(int i) {
p[i].maxx = max(max(p[p[i].ls].maxx, p[p[i].rs].maxx), p[i].num);
}
inline void _zig(int i) {
int j = p[i].fath, k;
k = p[j].fath;
if (k != 0 && j == p[k].ls)
p[k].ls = i;
else if (k != 0)
p[k].rs = i;
p[i].fath = k;
p[j].fath = i;
p[p[i].rs].fath = j;
p[j].ls = p[i].rs;
p[i].rs = j;
anc[i] = anc[j];
p[i].maxx = p[j].maxx;
_pushup(j);
}
inline void _zag(int i) {
int j = p[i].fath, k;
k = p[j].fath;
if (k != 0 && j == p[k].ls)
p[k].ls = i;
else if (k != 0)
p[k].rs = i;
p[i].fath = k;
p[j].fath = i;
p[p[i].ls].fath = j;
p[j].rs = p[i].ls;
p[i].ls = j;
anc[i] = anc[j];
p[i].maxx = p[j].maxx;
_pushup(j);
}
void _splay(int i) {
int j;
while (p[i].fath != 0) {
j = p[i].fath;
if (p[p[j].fath].lazy == true) _pushdown(p[j].fath);
if (p[j].lazy == true) _pushdown(j);
if (p[i].lazy == true) _pushdown(i);
if (p[j].fath == 0) {
if (i == p[j].ls)
_zig(i);
else
_zag(i);
} else if (j == p[p[j].fath].ls) {
if (i == p[j].ls)
_zig(j), _zig(i);
else
_zag(i), _zig(i);
} else {
if (i == p[j].rs)
_zag(j), _zag(i);
else
_zig(i), _zag(i);
}
}
}
int _find_max(int i) {
while (i != 0) {
if (p[i].lazy == true) _pushdown(i);
if (p[i].ls != 0 && p[i].maxx == p[p[i].ls].maxx)
i = p[i].ls;
else if (p[i].maxx == p[i].num)
return i;
else
i = p[i].rs;
}
return i;
}
void _access(int i) {
int j = 0;
while (i != 0) {
_splay(i);
if (p[i].lazy == true) _pushdown(i);
if (p[i].rs != 0) {
p[p[i].rs].fath = 0;
anc[p[i].rs] = i;
}
p[i].rs = j;
p[j].fath = i;
_pushup(i);
j = i;
i = anc[i];
}
}
void _setroot(int i) {
_access(i);
_splay(i);
p[i].lazy ^= 1;
}
} T;
struct cp {
double x, y;
cp() {}
cp(double x, double y) : x(x), y(y) {}
cp operator+(const cp &b) { return cp(x + b.x, y + b.y); }
cp operator-(const cp &b) { return cp(x - b.x, y - b.y); }
cp operator*(const cp &b) { return cp(x * b.x - y * b.y, x * b.y + y * b.x); }
};
void init() {
splay(n);
for (int k = 1; k <= n; k++) {
scanf("%s", s + 1);
for (int i = 1; i <= 9; i++) {
if (s[i] == '0') s[i] = '9' + 1;
}
for (int i = 1; i <= 9; i++) {
num[k][i][i] = s[i] - '0';
mp[num[k][i][i]]++;
for (int j = i + 1; j <= 9; j++) {
num[k][i][j] = num[k][i][j - 1] * 10 + s[j] - '0';
mp[num[k][i][j]]++;
}
}
for (int i = 1; i <= 9; i++) {
if (s[i] == '9' + 1) s[i] = '0';
}
memcpy(fuck[k], s, sizeof s);
}
}
int main() {
init();
clac();
}
| 4 |
#include <bits/stdc++.h>
const int inf = 2e9;
using namespace std;
int A[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &A[i]);
int maximo = min(2, n), aux = min(2, n);
for (int i = 2; i < n; i++) {
if (A[i] == A[i - 1] + A[i - 2]) {
aux++;
} else {
maximo = max(maximo, aux);
aux = 2;
}
}
maximo = max(maximo, aux);
return !printf("%d\n", maximo);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool fl[6][6][6][6][6][6];
string col = "ROYGBV";
int res = 0;
int Rec(int u, int d, int l, int r, int f, int b) {
if (fl[u][d][l][r][f][b]) return 0;
fl[u][d][l][r][f][b] = true;
Rec(r, l, u, d, f, b);
Rec(l, r, d, u, f, b);
Rec(f, b, l, r, d, u);
Rec(b, f, l, r, u, d);
Rec(u, d, f, b, r, l);
Rec(u, d, b, f, l, r);
return 1;
}
int get(char ch) { return col.find(ch); }
int main() {
string s;
cin >> s;
int ord[6];
for (int i = 0; i < 6; i++) ord[i] = i;
do {
res += Rec(get(s[ord[0]]), get(s[ord[1]]), get(s[ord[2]]), get(s[ord[3]]),
get(s[ord[4]]), get(s[ord[5]]));
} while (next_permutation(ord, ord + 6));
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3E5 + 1;
const int inf = 1 << 30;
long long read() {
long long a = 0;
char b = 1, c;
do
if ((c = getchar()) == 45) b = -1;
while (c < 48 || c > 57);
do a = (a << 3) + (a << 1) + (c & 15);
while ((c = getchar()) > 47 && c < 58);
return a * b;
}
void write(long long x, char c) {
if (x < 0) putchar(45), x = -x;
char a[20], s = 0;
do a[++s] = x % 10 | 48;
while (x /= 10);
do putchar(a[s]);
while (--s);
putchar(c);
}
int a[N];
long long b[N];
int aska(int x) {
int res = 0;
for (int i = x; i; i -= i & -i) res += a[i];
return res;
}
long long askb(int x) {
long long res = 0;
for (int i = x; i; i -= i & -i) res += b[i];
return res;
}
int main() {
int n = read();
long long ans = 0, s = 0;
for (int i = 0; i < n; ++i) {
int x = read();
ans += s + x * 1LL * i;
for (int i = 1, l = x - 1, u = aska(l); 1; ++i) {
int r = l + x;
bool op = 0;
if (r >= N) r = N - 1, op = 1;
int v = aska(r);
ans -= x * 1LL * i * (v - u);
if (op) break;
l = r;
u = v;
}
long long u = askb(x);
for (int i = 1, l = x; l;) {
int t = x / l, r = x / (t + 1);
long long v = askb(r);
ans -= (u - v) * i * t;
l = r;
u = v;
}
write(ans, ' ');
for (int i = x; i < N; i += i & -i) ++a[i], b[i] += x;
s += x;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
set<int> s[100003];
vector<int> b;
bool a[100003], p;
int n, m, i, j, k, k0;
char x;
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < m; ++i) {
p = false;
cin >> x >> k;
if (k == 1) {
}
if (x == '+') {
if (a[k]) {
printf("Already on\n");
continue;
}
j = 2;
k0 = k;
while (j * j <= k0) {
if (k % j == 0) {
k /= j;
b.push_back(j);
if (s[j].size() > 0) {
printf("Conflict with %d\n", (*s[j].begin()));
p = true;
break;
}
while (k % j == 0) k /= j;
} else
++j;
}
if (p) {
b.clear();
continue;
}
if (k != 1) {
j = k;
b.push_back(j);
if (s[j].size() > 0) {
printf("Conflict with %d\n", (*s[j].begin()));
p = true;
b.clear();
continue;
}
}
if (!p) {
a[k0] = true;
printf("Success\n");
for (j = 0; j < b.size(); ++j) s[b[j]].insert(k0);
}
b.clear();
} else {
if (!a[k]) {
printf("Already off\n");
continue;
}
a[k] = false;
k0 = k;
j = 2;
while (j * j <= k0) {
if (k % j == 0) {
k /= j;
s[j].erase(k0);
while (k % j == 0) k /= j;
}
++j;
}
if (k > 1) s[k].erase(k0);
printf("Success\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25 * 18 * 12 * 10 * 8;
int p[5][30];
int prime[5] = {2, 3, 5, 7, 11};
int c[5] = {1, 25, 25 * 18, 25 * 18 * 12, 25 * 18 * 12 * 10};
int m[5] = {25, 18, 12, 10, 8};
int vis[1000000];
int total;
int k;
void init() {
p[0][0] = p[1][0] = p[2][0] = p[3][0] = p[4][0] = 1;
for (int i = 1; i < 30; i++) {
p[0][i] = p[0][i - 1] * 2;
p[1][i] = p[1][i - 1] * 3;
p[2][i] = p[2][i - 1] * 5;
p[3][i] = p[3][i - 1] * 7;
p[4][i] = p[4][i - 1] * 11;
}
}
long long getnum(int x) {
long long ans = 1;
for (int i = 0; i < 5; i++) {
ans *= p[i][x % m[i]];
x /= m[i];
}
return ans;
}
int bitcount(int x) { return x == 0 ? 0 : bitcount(x / 2) + (x & 1); }
void bfs(int s, int st, int lim) {
queue<int> q;
q.push(s);
vis[s] = 1;
int tmp = 0;
while (!q.empty()) {
int t = q.front();
q.pop();
long long u = getnum(t);
if (u <= (long long)2 * k * k) {
tmp++;
if (tmp > lim) break;
total++;
if (total == k) {
printf("%d\n", (int)u);
break;
} else
printf("%d ", (int)u);
for (int i = 0; i < 5; i++)
if (st & (1 << i)) {
int v = t + c[i], x = u, y = 0;
while (x % prime[i]) {
x /= prime[i];
y++;
}
if (!vis[v] && y + 1 < m[i] && v < maxn) {
vis[v] = 1;
q.push(v);
}
}
}
}
}
int main() {
init();
scanf("%d", &k);
memset(vis, 0, sizeof(vis));
total = 0;
if (k < 200) {
bfs(c[0] + c[1] + c[2], 7, k);
if (total < k) {
int lim = (k - total) / 3;
bfs(c[0] + c[1], 3, lim);
bfs(c[0] + c[2], 5, lim);
bfs(c[1] + c[2], 6, k - total);
for (int i = 0; i < 3; i++)
if (total < k) bfs(c[i], (1 << i), k - total);
}
} else if (k < 1750) {
bfs(c[0] + c[1] + c[2] + c[3], 15, k);
if (total < k) {
int l1 = (k - total) / 4;
for (int i = 0; i < 15; i++)
if (bitcount(i) == 3) {
int s = 0;
for (int j = 0; j < 4; j++)
if (i & (1 << j)) s += c[j];
bfs(s, i, l1);
}
if (total < k) {
int l2 = (k - total) / 6;
for (int i = 0; i < 15; i++)
if (bitcount(i) == 2) {
int s = 0;
for (int j = 0; j < 4; j++)
if (i & (1 << j)) s += c[j];
bfs(s, i, l2);
}
for (int i = 0; i < 4; i++)
if (total < k) bfs(c[i], (1 << i), k - total);
}
}
} else {
bfs(c[0] + c[1] + c[2] + c[3] + c[4], 31, k);
if (total < k) {
int l1 = (k - total) / 5;
for (int i = 0; i < 31; i++)
if (bitcount(i) == 4) {
int s = 0;
for (int j = 0; j < 5; j++)
if (i & (1 << j)) s += c[j];
bfs(s, i, l1);
}
if (total < k) {
int l2 = (k - total) / 10;
for (int i = 0; i < 31; i++)
if (bitcount(i) == 3) {
int s = 0;
for (int j = 0; j < 5; j++)
if (i & (1 << j)) s += c[j];
bfs(s, i, l2);
}
if (total < k) {
int l3 = (k - total) / 10;
for (int i = 0; i < 31; i++)
if (bitcount(i) == 2) {
int s = 0;
for (int j = 0; j < 5; j++)
if (i & (1 << j)) s += c[j];
bfs(s, i, l3);
}
for (int i = 0; i < 5; i++)
if (total < k) bfs(c[i], (1 << i), k - total);
}
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
using namespace std;
void solve() {
long long n, k, gain;
cin >> n >> k;
vector<long long> a(n), cost(n);
for (auto &it : a) cin >> it;
cin >> gain;
for (auto &it : cost) cin >> it;
long long ans = 0;
set<long long> redbull;
for (long long i = 0; i < n; ++i) {
redbull.insert(cost[i]);
if (k < a[i]) {
while (k < a[i] && !redbull.empty()) {
k += gain;
ans += *redbull.begin();
redbull.erase(redbull.begin());
}
if (k < a[i]) {
cout << -1;
return;
}
}
}
cout << ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct T {
int grey, disp, Rank, n;
} vote[100000];
bool cmp1(const T& a, const T& b) {
if (a.disp == b.disp)
return (a.grey > b.grey);
else
return (a.disp < b.disp);
}
bool cmp2(const T& a, const T& b) {
if (a.grey == b.grey)
return (a.disp > b.disp);
else
return (a.grey > b.grey);
}
bool cmp3(const T& a, const T& b) { return (a.Rank < b.Rank); }
int main() {
ios::sync_with_stdio(false);
int n, p, k;
cin >> n >> p >> k;
for (int i = 0; i != n; ++i) {
cin >> vote[i].grey >> vote[i].disp;
vote[i].n = i + 1;
}
sort(vote, vote + n, cmp1);
for (int i = 0; i != n; ++i) vote[i].Rank = i + 1;
sort(vote, vote + n, cmp2);
int i1 = 0;
int cnt1 = 0;
int end1 = k;
int end2 = p - k;
int Rmin = 1e9 + 7;
while (cnt1 < end1) {
if (vote[i1].Rank > end2) {
++cnt1;
cout << vote[i1].n << ' ';
Rmin = min(Rmin, vote[i1].Rank);
vote[i1].n = -1;
}
++i1;
}
sort(vote, vote + n, cmp3);
int i2 = Rmin - 1 - 1;
int cnt2 = 0;
while (cnt2 < end2) {
++cnt2;
cout << vote[i2].n << ' ';
--i2;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int l, r;
int win;
int min1(int a, int b) { return a > b ? b : a; }
int main() {
int n;
int a, b, c, i, j, k, m, t;
while (scanf("%d%d%d%d", &n, &a, &b, &c) != EOF) {
n = (n << 1);
int sum = 0, hold;
for (i = 0; i <= b; i++) {
for (j = 0; j <= c; j++) {
if ((i * 2) + (j * 4) <= n) {
hold = n - 2 * i - 4 * j;
if (hold >= 0 && hold <= a) {
sum++;
}
}
}
}
printf("%d\n", sum);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct ST {
vector<int> t;
int n;
ST(int _n) {
n = 1;
while (n < _n) n <<= 1;
t.resize(n << 1);
for (int i = 0; i < (n << 1); i++) t[i] = 0;
}
inline void update(int v, int x) {
v += n;
t[v] = x;
v >>= 1;
while (v) t[v] = max(t[v << 1], t[(v << 1) + 1]), v >>= 1;
}
inline int get(int v, int a, int b, int l, int r) {
if (l > b || a > r) return -int(1e9);
if (l <= a && b <= r) return t[v];
int m = (a + b) >> 1;
return max(get(v << 1, a, m, l, r), get((v << 1) + 1, m + 1, b, l, r));
}
inline int get(int l, int r) {
return get(1, n, (n << 1) - 1, l + n - 1, r + n - 1);
}
};
int main() {
int n;
scanf("%d", &n);
vector<int> p(n);
ST tree = ST(n + 1);
vector<int> killedby(n);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
killedby[i] = tree.get(p[i], n);
tree.update(p[i] - 1, i + 1);
}
for (int i = 0; i < (tree.n << 1); i++) tree.t[i] = 0;
int ans = 0;
for (int i = 0; i < n; i++)
if (killedby[i]) {
int val = tree.get(killedby[i] + 1, i + 1) + 1;
tree.update(i, val);
ans = max(ans, val);
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct rolling_hash {
long long val[1000111];
long long ep[1000111];
long long mod = 1e9 + 7;
int base = 41;
int N;
void init(int base = 41, long long mod = 1e9 + 7) {
int i;
this->base = base, this->mod = mod;
ep[0] = 1;
for (i = 1; i < 1000111; ++i) {
ep[i] = ep[i - 1] * base;
ep[i] %= mod;
}
}
void calc(char st[], int N) {
this->N = N;
for (int i = 1; i <= N; ++i) {
val[i] = val[i - 1] * base + (st[i] - 'a');
val[i] %= mod;
}
}
long long decode(int l, int r) {
long long valL = val[l - 1] * ep[r - l + 1];
long long valR = val[r];
return ((valR - valL) % mod + mod) % mod;
}
bool equal(int l1, int r1, int l2, int r2) {
if (r1 - l1 != r2 - l2) return false;
return decode(l1, r1) == decode(l2, r2);
}
};
char st[1000111];
int best[1000111];
int ans[1000111];
int N;
rolling_hash h1, h2;
int main() {
int i;
scanf("%d", &N);
scanf("%s", st + 1);
h1.init(29, 19260817);
h2.init();
h1.calc(st, N);
h2.calc(st, N);
for (i = 1; i <= N / 2; ++i) {
best[i] = -1;
if (st[i] != st[N - i + 1]) continue;
int low = 0, high = i - 1;
while (low <= high) {
int mid = (low + high) >> 1;
int l1 = i - mid, r1 = i + mid;
int l2 = N - i + 1 - mid, r2 = N - i + 1 + mid;
if (h1.equal(l1, r1, l2, r2) && h2.equal(l1, r1, l2, r2)) {
best[i] = mid;
low = mid + 1;
} else {
high = mid - 1;
}
}
}
for (i = 1; i <= N / 2; ++i) {
if (best[i] != -1) {
ans[i - best[i]] = max(ans[i - best[i]], 2 * best[i] + 1);
}
}
for (i = 1; i <= N / 2; ++i) {
ans[i] = max(ans[i], ans[i - 1] - 2);
}
for (i = 1; i <= (N + 1) / 2; ++i) {
printf("%d ", ans[i] > 0 ? ans[i] : -1);
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
vector<long long> inc(n, 0), dec(n, 0);
for (long long i = 1; i < n; i++) {
if (v[i] > v[i - 1]) {
inc[i] = inc[i - 1];
dec[i] = i;
} else if (v[i] < v[i - 1]) {
dec[i] = dec[i - 1];
inc[i] = i;
} else {
dec[i] = dec[i - 1];
inc[i] = inc[i - 1];
}
}
for (long long k = 0; k < m; k++) {
long long i, j;
cin >> i >> j;
i--;
j--;
if (inc[dec[j]] <= i)
cout << "Yes\n";
else
cout << "No\n";
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, A, B, C, sum = 0, k = 0;
struct mouse {
long long value;
long port;
};
mouse a[300001];
bool compare(mouse x, mouse y) { return x.value < y.value; }
int main() {
cin >> A >> B >> C >> n;
for (int i = 1; i <= n; i++) {
string s;
cin >> a[i].value >> s;
if (s == "USB")
a[i].port = 0;
else
a[i].port = 1;
}
sort(a + 1, a + n + 1, compare);
for (int i = 1; (i <= n) && (A + B + C > 0); i++) {
bool w = false;
if ((a[i].port == 0) && (A > 0)) {
k++;
A--;
sum += a[i].value;
w = true;
}
if ((a[i].port == 1) && (B > 0)) {
k++;
B--;
sum += a[i].value;
w = true;
}
if ((!w) && (C > 0)) {
k++;
C--;
sum += a[i].value;
}
}
cout << k << " " << sum;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int lim = 100000;
typedef struct {
int L, R;
bool down;
} node;
int n, m, a[lim + 1], b[lim + 1], t, x, y;
node it[lim << 2];
void Down(const int id) {
if (it[id].down) {
int tmp = id << 1, mid = it[id].L + it[id].R >> 1;
it[tmp] = {it[id].L, mid, true};
it[tmp + 1] = {mid + 1, it[id].R, true};
it[id].down = false;
}
}
void Copy(const int id, const int l, const int r) {
if (l < y + t && r >= y)
if (l < y || r >= y + t) {
Down(id);
int tmp = id << 1, mid = l + r >> 1;
Copy(tmp, l, mid);
Copy(tmp + 1, mid + 1, r);
} else
it[id] = {x + l - y, x + r - y, true};
}
void determine(const int id, const int l, const int r) {
if (l < r) {
Down(id);
int mid = l + r >> 1;
if (x > mid)
determine((id << 1) + 1, mid + 1, r);
else
determine(id << 1, l, mid);
} else if (it[id].L > 0)
b[x] = a[it[id].L];
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (t = 1; t <= n; t++) cin >> a[t];
for (t = 1; t <= n; t++) cin >> b[t];
x = n << 2;
for (t = 1; t < x; t++) {
it[t].L = 0;
it[t].down = false;
}
do {
m--;
cin >> t >> x;
if (t < 2) {
cin >> y >> t;
Copy(1, 1, n);
} else {
determine(1, 1, n);
cout << b[x] << '\n';
}
} while (m > 0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v;
vector<int> g[100010];
int color[100010];
bool bfs(int x) {
queue<int> q;
q.push(x);
color[x] = 1;
bool flag = true;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int adj : g[cur]) {
if (color[adj] == 0) {
color[adj] = 3 - color[cur];
q.push(adj);
} else {
if (color[adj] == color[cur]) {
flag = false;
break;
}
}
}
}
return flag;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (color[i] == 0) {
if (!bfs(i)) {
printf("-1\n");
return 0;
}
}
}
vector<int> a, b;
for (int i = 1; i <= n; i++) {
if (color[i] == 1)
a.push_back(i);
else
b.push_back(i);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
printf("%d\n", (int)a.size());
for (int i : a) printf("%d ", i);
printf("\n");
printf("%d\n", (int)b.size());
for (int i : b) printf("%d ", i);
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
int n, m;
int a[N], b[N];
bool used[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
}
int res = 0;
for (int i = 1; i <= n; i++) {
int p = -1;
for (int j = 1; j <= m; j++) {
if (used[j]) {
continue;
}
if (b[j] >= a[i]) {
p = j;
break;
}
}
if (p == -1) {
res++;
} else {
used[p] = true;
}
}
cout << res << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, z, u, l, s, h, k, y, x, a[788857], t, b[889655], d[677676],
e[685868];
long long i, j, c[1000][1000];
string p, q, r;
int main() {
cin >> n;
s = 1;
while (n > 1) {
x = 0;
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
x++;
s *= i;
while (n % i == 0) {
n /= i;
}
}
}
if (x == 0) {
cout << s * n;
return 0;
}
}
cout << s;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.