solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
long long arr[200005];
void solve() {
long long i, j, k, l, r, m, n, a, b, c, d, x, y, z, t;
cin >> n;
for (i = 0; i < n; i++) cin >> arr[i];
if (n == 1)
cout << arr[0] << endl;
else if (n == 2)
cout << (arr[0] | arr[1]) << endl;
else {
long long ret = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < n; k++) {
ret = max(ret, (arr[i] | arr[j]) | arr[k]);
}
}
}
cout << ret << endl;
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main(void){
int a,b;
cin>>a>>b;
cout<<"a ";
if(a<b)cout<<"< ";
if(a>b)cout<<"> ";
if(a==b)cout<<"== ";
cout<<"b"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long INF = ~0ULL >> 1;
const int maxn = 500000;
int c[maxn], cntx, cnty, N, hx[maxn], hy[maxn];
long long ans;
vector<pair<int, int> > A[maxn], B[maxn], sx[maxn], sy[maxn];
vector<int> E[maxn];
struct info {
int x1, y1, x2, y2;
} seg[maxn];
void add(int x, int y) {
while (x <= cntx) c[x] += y, x += x & (-x);
}
int query(int x) {
int ret = 0;
while (x) ret += c[x], x -= x & (-x);
return ret;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d%d%d%d", &seg[i].x1, &seg[i].y1, &seg[i].x2, &seg[i].y2);
if (seg[i].x1 > seg[i].x2) swap(seg[i].x1, seg[i].x2);
if (seg[i].y1 > seg[i].y2) swap(seg[i].y1, seg[i].y2);
hx[++cntx] = seg[i].x1;
hx[++cntx] = seg[i].x2;
hy[++cnty] = seg[i].y1;
hy[++cnty] = seg[i].y2;
}
sort(hx + 1, hx + cntx + 1);
sort(hy + 1, hy + cnty + 1);
for (int i = 1; i <= N; i++) {
if (seg[i].x1 == seg[i].x2) {
int x = lower_bound(hx + 1, hx + cntx + 1, seg[i].x1) - hx;
sx[x].push_back((make_pair(seg[i].y1, seg[i].y2)));
} else {
int y = lower_bound(hy + 1, hy + cnty + 1, seg[i].y1) - hy;
sy[y].push_back((make_pair(seg[i].x1, seg[i].x2)));
}
}
for (int i = 1; i <= cntx; i++) {
sort(sx[i].begin(), sx[i].end());
for (int j = 0; j < sx[i].size(); j++) {
int k = j, cur = sx[i][j].second;
while (k < sx[i].size() && sx[i][k].first <= cur) {
cur = max(cur, sx[i][k].second);
++k;
}
A[i].push_back((make_pair(sx[i][j].first, cur)));
int y = lower_bound(hy + 1, hy + cnty + 1, sx[i][j].first) - hy;
E[y].push_back(i);
y = lower_bound(hy + 1, hy + cnty + 1, cur) - hy;
E[y + 1].push_back(-i);
ans += cur - sx[i][j].first + 1;
j = k - 1;
}
}
for (int i = 1; i <= cnty; i++) {
sort(sy[i].begin(), sy[i].end());
for (int j = 0; j < sy[i].size(); j++) {
int k = j, cur = sy[i][j].second;
while (k < sy[i].size() && sy[i][k].first <= cur) {
cur = max(cur, sy[i][k].second);
++k;
}
B[i].push_back((make_pair(sy[i][j].first, cur)));
j = k - 1;
}
}
for (int i = 1; i <= cnty; i++) {
for (int j = 0; j < E[i].size(); j++)
if (E[i][j] > 0)
add(E[i][j], 1);
else
add(-E[i][j], -1);
for (int j = 0; j < B[i].size(); j++) {
int lx = lower_bound(hx + 1, hx + cntx + 1, B[i][j].first) - hx;
int rx = lower_bound(hx + 1, hx + cntx + 1, B[i][j].second) - hx;
ans += B[i][j].second - B[i][j].first + 1 - (query(rx) - query(lx - 1));
}
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int __ = 2e5 + 5;
const int inf = 1e9 + 7;
int a[__], b[__];
int main() {
int n;
scanf("%d", &n);
int f = 1, zp = 0, fp = 0;
a[0] = -inf;
for (int i = (1); i <= (n); ++i) {
scanf("%d", &a[i]);
if (a[i] < 0) {
f = -f;
if (a[i] > a[fp]) fp = i;
}
if (!a[i]) zp = i;
}
int idx = 0, last = 0;
if (f == -1) {
int cont = 0;
for (int i = (1); i <= (n); ++i)
if (!a[i] || i == fp) {
if (last) printf("1 %d %d\n", last, i);
last = i, a[i] = 0, ++cont;
}
if (cont != n) printf("2 %d\n", last);
for (int i = (1); i <= (n); ++i)
if (a[i]) b[++idx] = i;
} else {
int cont = 0;
for (int i = (1); i <= (n); ++i)
if (!a[i]) {
if (last) printf("1 %d %d\n", last, i);
last = i, a[i] = 0, ++cont;
}
if (zp && cont != n) printf("2 %d\n", last);
for (int i = (1); i <= (n); ++i)
if (a[i]) b[++idx] = i;
}
for (int i = (1); i <= (idx - 1); ++i) printf("1 %d %d\n", b[i], b[i + 1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
bool compare(std::string& a, std::string& b) {
for (int i = 0; i < a.size(); ++i) {
if (i % 2) {
if (std::tolower(a[i]) > std::tolower(b[i])) {
return true;
}
if (std::tolower(a[i]) < std::tolower(b[i])) {
return false;
}
} else {
if (std::tolower(a[i]) < std::tolower(b[i])) {
return true;
}
if (std::tolower(a[i]) > std::tolower(b[i])) {
return false;
}
}
}
return false;
}
int main() {
int n, m;
std::cin >> n >> m;
std::vector<std::pair<std::string, int>> arr(n);
for (int i = 0; i < n; ++i) {
std::cin >> arr[i].first;
arr[i].second = i + 1;
}
std::sort(arr.begin(), arr.end(),
[](std::pair<std::string, int>& a, std::pair<std::string, int>& b) {
return compare(a.first, b.first);
});
for (std::pair<std::string, int>& a : arr) {
std::cout << a.second << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
int main()
{
int w, n, i;
cin >> w >> n;
int num[w + 1], a[n + 1], b[n + 1];
REP(i, w) num[i] = i + 1;
REP(i, n) scanf("%d,%d" ,&a[i], &b[i]);
REP(i, n) swap(num[a[i] - 1], num[b[i] - 1]);
REP(i, w) cout << num[i] << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T = int, T _mod = 1000000007, typename U = long long>
struct Minter {
static constexpr int mod = _mod;
T val;
Minter() : val(0) {}
Minter(U x) {
x %= mod;
if (x < 0) x += mod;
val = x;
}
explicit operator int() const { return val; }
Minter& operator+=(Minter oth) {
val += oth.val;
if (val >= mod) val -= mod;
return *this;
}
Minter& operator-=(Minter oth) {
val -= oth.val;
if (val < 0) val += mod;
return *this;
}
Minter& operator*=(Minter oth) {
val = ((U)val) * oth.val % mod;
return *this;
}
Minter& operator/=(Minter oth) { return *this *= oth.inv(); }
Minter& operator^=(U oth) { return *this = pwr(*this, oth); }
Minter operator+(const Minter& oth) const { return Minter(*this) += oth; }
Minter operator-(const Minter& oth) const { return Minter(*this) -= oth; }
Minter operator*(const Minter& oth) const { return Minter(*this) *= oth; }
Minter operator/(const Minter& oth) const { return Minter(*this) /= oth; }
Minter operator^(long long oth) const { return Minter(*this) ^= oth; }
bool operator<(Minter oth) const { return val < oth.val; }
bool operator>(Minter oth) const { return val > oth.val; }
bool operator<=(Minter oth) const { return val <= oth.val; }
bool operator>=(Minter oth) const { return val >= oth.val; }
bool operator==(Minter oth) const { return val == oth.val; }
bool operator!=(Minter oth) const { return val != oth.val; }
Minter pwr(Minter a, long long b) const {
auto r = (Minter)1;
for (; b; a *= a, b >>= 1)
if (b & 1) r *= a;
return r;
}
};
using U = Minter<>;
ostream& operator<<(ostream& out, const U& oth) { return out << oth.val; }
istream& operator>>(istream& in, U& oth) {
in >> oth.val;
return in;
}
const int N = 6e5 + 2;
int p[N], d[N];
U s1[4 * N], s2[4 * N], lazy1[4 * N], lazy2[4 * N];
int n, q, timer = -1;
vector<int> adj[N];
int Tstart[N], Tend[N], vis[N];
void dfs(int v, int dep) {
vis[v] = 1;
d[v] = dep + 1;
Tstart[v] = ++timer;
for (auto x : adj[v]) {
if (!vis[x]) {
dfs(x, dep + 1);
}
}
Tend[v] = ++timer;
}
void init() {
for (int i = 0; i < n - 1; i++) {
cin >> p[i];
adj[p[i]].push_back(i + 2);
adj[i + 2].push_back(p[i]);
}
dfs(1, 0);
}
void change(int id, int l, int r, U x1, U x2) {
lazy1[id] += x1;
s1[id] += x1;
lazy2[id] += x2;
s2[id] += x2;
}
void pass(int id, int l, int r) {
int mid = (l + r) / 2;
change(2 * id, l, mid, lazy1[id], lazy2[id]);
change(2 * id + 1, l, mid, lazy1[id], lazy2[id]);
lazy1[id] = lazy2[id] = 0;
}
void update(int L, int R, U x1, U x2, int id = 1, int l = 0, int r = timer) {
if (R < l or L > r) {
return;
}
if (L <= l and r <= R) {
change(id, l, r, x1, x2);
return;
}
pass(id, l, r);
int mid = (l + r) / 2;
update(L, R, x1, x2, 2 * id, l, mid);
update(L, R, x1, x2, 2 * id + 1, mid + 1, r);
s1[id] = s1[2 * id] + s1[2 * id + 1];
s2[id] = s2[2 * id] + s2[2 * id + 1];
}
U query(int L, int R, int v, int id = 1, int l = 0, int r = timer) {
if (R < l or L > r) {
return (U)0;
}
if (L <= l and r <= R) {
return (U)(s1[id] - s2[id] * d[v]);
}
pass(id, l, r);
int mid = (l + r) / 2;
return (query(L, R, v, 2 * id, l, mid) +
query(L, R, v, 2 * id + 1, mid + 1, r));
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
init();
cin >> q;
while (q--) {
int t, v;
cin >> t >> v;
if (t == 2) {
cout << query(Tstart[v], Tstart[v], v) << "\n";
continue;
}
U x, k;
cin >> x >> k;
update(Tstart[v], Tend[v] - 1, x + (k * d[v]), k);
}
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <numeric>
#include <queue>
#include <algorithm>
#include <utility>
#include <functional>
using namespace std;
using Flow = int;
template<typename Flow = int>
struct PrimalDual {
struct Edge {
int dst;
Flow cap, cap_orig;
Flow cost;
int revEdge;
bool isRev;
Edge(int dst, Flow cap, Flow cost, int rev, bool isRev)
:dst(dst), cap(cap), cap_orig(cap), cost(cost), revEdge(rev), isRev(isRev) {
}
};
int n;
vector<vector<Edge> > g;
PrimalDual(int n_) : n(n_), g(vector<vector<Edge> >(n_)) {}
void addEdge(int src, int dst, Flow cap, Flow cost) {
g[src].emplace_back(dst, cap, cost, g[dst].size(), false);
g[dst].emplace_back(src, 0, -cost, g[src].size() - 1, true);
}
Flow solve(int s, int t, int f) {
constexpr Flow inf = numeric_limits<Flow>::max();
Flow res = 0;
vector<Flow> h(g.size()), dist(g.size());
vector<int> prevv(g.size()), preve(g.size());
while (f > 0) {
priority_queue<pair<Flow, int>> q;
fill(dist.begin(), dist.end(), inf);
dist[s] = 0;
q.emplace(0, s);
while (q.size()) {
int d, v;
tie(d,v) = q.top();
q.pop();
d = -d;
if (dist[v] < d) continue;
for(int i = 0; i < (int)g[v].size(); ++i){
Edge &e = g[v][i];
if (e.cap > 0 && dist[e.dst] > dist[v] + e.cost + h[v] - h[e.dst]) {
dist[e.dst] = dist[v] + e.cost + h[v] - h[e.dst];
prevv[e.dst] = v;
preve[e.dst] = i;
q.emplace(-dist[e.dst], e.dst);
}
}
}
if (dist[t] == inf) {
return -1;
}
for (int i = 0; i < n; ++i) {
h[i] += dist[i];
}
Flow d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, g[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.revEdge].cap += d;
}
}
return res;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, f;
cin >> n >> m >> f;
PrimalDual<int> pd(n);
for (int i = 0; i < m; i++) {
int u, v, c, d;
cin >> u >> v >> c >> d;
pd.addEdge(u, v, c, d);
}
cout << pd.solve(0, n - 1, f) << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int const N = 200001;
int t, x, c;
map<int, int> f, nxt;
int find(int u) { return !nxt[u] ? u : nxt[u] = find(nxt[u]); }
int main() {
scanf("%d%d", &t, &x);
int an = 0;
while (t--) {
scanf("%d", &c);
long long a = (c % x) + (x * f[c % x]);
++f[c % x];
nxt[find(a)] = find(a + 1);
an = find(0);
printf("%d\n", an);
}
}
| 4 |
#include <bits/stdc++.h>
#define IL __inline__ __attribute__((always_inline))
#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)
typedef long long LL;
template <class T>
IL bool chkmax(T &a, const T &b) {
return a < b ? ((a = b), 1) : 0;
}
template <class T>
IL bool chkmin(T &a, const T &b) {
return a > b ? ((a = b), 1) : 0;
}
template <class T>
IL T mmax(const T &a, const T &b) {
return a > b ? a : b;
}
template <class T>
IL T mmin(const T &a, const T &b) {
return a < b ? a : b;
}
template <class T>
IL T mabs(const T &a) {
return a > 0 ? a : -a;
}
const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);
#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...\n", __FUNCTION__, __LINE__)
#define SZ(x) ((int)(x).size())
const int MAXN = 100000 + 5, MAXM = 20 + 5;
int col[MAXM][MAXN];
IL void init() {
for (int i = 2; i <= 16; i <<= 1) {
int t = 1 << (i / 2);
FOR(j, 0, t) {
int f = (__builtin_popcount(j) & 1) * (i / 2), g = col[i / 2][j];
FOR(k, 0, t) {
int p = (j << (i / 2)) + k;
col[i][p] = (col[i / 2][k] + g) % (i / 2) + f;
}
}
}
}
std::vector<int> edge[MAXN];
std::queue<int> q;
int p[MAXN], fp[MAXN], num[MAXN], vis[MAXN], to[MAXN], cnt;
void work(const std::vector<int> &cur) {
int s = SZ(cur);
if (s == 1) {
p[0] = cur.back();
return;
}
++ cnt;
for (auto &x: cur) {
num[x] = cnt;
vis[x] = 0;
}
int k1 = cur[0], k2 = 0;
for (auto &x: edge[k1]) {
if (num[x] == cnt) {
k2 = x;
break;
}
}
vis[k1] = 1, vis[k2] = 2;
q.push(k1), q.push(k2);
std::vector<int> tmp, ap;
while (!q.empty()) {
int t = q.front();
q.pop();
(vis[t] == 1 ? tmp : ap).push_back(t);
for (auto &x: edge[t]) {
if (num[x] == cnt && !vis[x]) {
vis[x] = vis[t];
q.push(x);
} else if (num[x] == cnt && vis[x] == 1 && vis[t] == 2) {
to[t] = x;
}
}
}
work(tmp);
for (auto &x: ap) {
fp[x] = fp[to[x]] + s / 2;
p[fp[x]] = x;
}
}
int main() {
init();
int _;
scanf("%d", &_);
for (; _; -- _) {
int n;
scanf("%d", &n);
std::vector<int> tmp;
FOR(i, 0, 1 << n) {
edge[i].clear();
tmp.push_back(i);
}
FOR(i, 0, n * (1 << (n - 1))) {
int u, v;
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
work(tmp);
FOR(i, 0, 1 << n) {
printf("%d ", p[i]);
}
puts("");
if (__builtin_popcount(n) > 1) {
puts("-1");
} else {
FOR(i, 0, 1 << n) {
printf("%d ", col[n][fp[i]]);
}
puts("");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, cnt, ans, mx;
int d[200005] = {0}, clr[200005];
vector<vector<int> > g;
pair<int, int> c[200005];
void dfs(int i, int t) {
d[i] = 1;
cnt++;
if (c[clr[i]].second != t) {
c[clr[i]].first = 1;
c[clr[i]].second = t;
} else
c[clr[i]].first++;
mx = max(mx, c[clr[i]].first);
for (int j = 0; j < g[i].size(); j++) {
if (d[g[i][j]] != 1) dfs(g[i][j], t);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
g.resize(n + 1);
int a, b;
for (int i = 1; i < n + 1; i++) scanf("%d", &clr[i]);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < 200005; i++) c[i].first = c[i].second = 0;
int t = 1;
for (int i = 1; i < n + 1; i++) {
cnt = 0;
mx = 0;
if (d[i] == 0 && g[i].size() != 0) {
dfs(i, t);
t++;
}
ans += (cnt - mx);
}
cout << ans << endl;
return 0;
}
| 3 |
#include<iostream>
#include<cstdio>
#define MN 1000
using namespace std;
inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
char c[MN+5][MN+5];
int n,m,A,B;
int main()
{
n=read();m=read();A=read();B=read();
if(A*2+B*2>n*m) return 0*puts("NO");
for(int i=1;i<=n;++i) for(int j=1;j<=m;++j) c[i][j]='.';
if(n&1) for(int j=2;j<=m&&A;j+=2) c[1][j-1]='<',c[1][j]='>',--A;
if(m&1) for(int j=2;j<=n&&B;j+=2) c[j-1][m]='^',c[j][m]='v',--B;
for(int j=m;j>1;--j) for(int i=1;i<=n;++i)
if(c[i][j]=='.'&&c[i][j-1]=='.'&&A) --A,c[i][j]='>',c[i][j-1]='<';
for(int i=1;i<n;++i) for(int j=1;j<=m&&B;++j)
if(c[i][j]=='.'&&c[i+1][j]=='.') --B,c[i][j]='^',c[i+1][j]='v';
if(B||A) return 0*puts("NO");
puts("YES");
for(int i=1;i<=n;++i) puts(c[i]+1);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Int(T &a) {
bool minus = false;
a = 0;
char ch = getchar();
while (true) {
if (ch == '-' or (ch >= '0' && ch <= '9')) break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
a = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
a = a * 10 + (ch - '0');
}
if (minus) a *= -1;
}
template <typename T>
inline void Int(T &a, T &b) {
Int(a), Int(b);
}
template <typename T>
inline void Int(T &a, T &b, T &c) {
Int(a, b), Int(c);
}
template <typename T>
inline void Int(T &a, T &b, T &c, T &d) {
Int(a, b), Int(c, d);
}
void err(istream_iterator<string> it) { cout << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ' ';
err(++it, args...);
}
const int N = (int)1e4 + 5;
const int maxN = (int)1e6 + 6;
const long long Mod = (long long)1e9 + 7;
const int inf = (int)2e9;
const long long Inf = (long long)1e18;
const int mod = (int)1e9 + 7;
inline int add(int a, int b, int mod) {
a += b;
return a >= mod ? a - mod : a;
}
inline int sub(int a, int b, int mod) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(int a, int b, int mod) { return (long long)a * b % mod; }
vector<pair<int, int> > edge[N], res;
vector<int> contradictory;
bool vis[N];
int par[N], color[N], level[N], dp1[N], dp2[N];
int n, m;
bool Bipartite(int s, int p = 0) {
bool ok = 1;
color[s] = color[p] == 1 ? 2 : 1;
for (pair<int, int> i : edge[s]) {
if (i.first == p) continue;
if (!color[i.first]) {
ok &= Bipartite(i.first, s);
} else {
if (color[i.first] == color[s]) ok = 0;
}
}
return ok;
}
void dfs(int s, int tp, int p = 0) {
vis[s] = 1;
par[s] = p;
level[s] = 1 + level[p];
for (pair<int, int> i : edge[s]) {
if (i.first == p) continue;
if (!level[i.first]) {
dfs(i.first, i.second, s);
dp1[s] += dp1[i.first];
dp2[s] += dp2[i.first];
} else {
if (level[i.first] < level[s]) {
if (color[i.first] == color[s]) {
dp1[s]++;
contradictory.push_back(i.second);
}
dp2[s]++;
} else {
if (color[i.first] == color[s]) dp1[s]--;
dp2[s]--;
}
}
}
if (tp and dp1[s] == dp2[s]) res.push_back({s, tp});
}
int main() {
int test = 1, tc = 0;
while (test--) {
Int(n, m);
for (int i = 1, x, y; i <= m; ++i) {
Int(x, y);
edge[x].push_back(make_pair(y, i));
edge[y].push_back(make_pair(x, i));
}
int root = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (!color[i]) {
if (!Bipartite(i)) {
++cnt;
root = i;
if (cnt > 1) break;
}
}
}
if (!cnt) {
cout << m << '\n';
for (int i = 1; i <= m; ++i) cout << i << " \n"[i == m];
return 0;
}
if (cnt == 2) return puts("0"), 0;
dfs(root, 0);
vector<int> ans;
int backedge = (int)contradictory.size();
for (pair<int, int> i : res) {
if (dp1[i.first] == backedge) ans.push_back(i.second);
}
if (backedge == 1) ans.push_back(contradictory[0]);
sort(ans.begin(), ans.end());
cout << (int)ans.size() << '\n';
for (int i : ans) cout << i << ' ';
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> nei = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, r, c, x, y;
cin >> n >> m >> r >> c >> x >> y;
vector<vector<bool>> grid(n + 1, vector<bool>(m + 1, true));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == '*') {
grid[i][j] = false;
}
}
}
vector<vector<int>> seen(n + 1, vector<int>(m + 1, INT_MAX));
deque<vector<int>> dq;
dq.push_back({r, c});
seen[r][c] = 0;
while (!dq.empty()) {
vector<int> curr = dq.front();
dq.pop_front();
for (int k = 0; k < 4; k++) {
int rr = curr[0] + nei[k].first, cc = curr[1] + nei[k].second;
if (rr > n || rr < 1 || cc > m || cc < 1 || !grid[rr][cc] ||
seen[rr][cc] <= seen[curr[0]][curr[1]] + (k == 3)) {
continue;
}
if (k == 3) {
dq.push_back({rr, cc});
} else {
dq.push_front({rr, cc});
}
seen[rr][cc] = seen[curr[0]][curr[1]] + (k == 3);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (seen[i][j] <= x && j - c + seen[i][j] <= y) {
ans++;
}
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using Graph = vector<vector<T>>;
template <class T>
using Maxheap = priority_queue<T>;
template <class T>
using Minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T, typename T1>
inline T max(T a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
inline T min(T a, T1 b) {
if (b < a) a = b;
return a;
}
inline int64_t ssum(int64_t n) { return (n * (n + 1)) / 2; };
inline int64_t fastpow(int64_t a, int64_t b, int64_t m = (int64_t)(1e9 + 7)) {
int64_t res = 1;
a %= m;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
void go() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
struct Tree {
int64_t sz;
vector<int64_t> bit;
Tree(int64_t n) {
sz = n;
bit.assign(n, 0);
}
int64_t sum(int64_t i) {
int64_t ans = 0;
while (i >= 0) {
ans += bit[i];
i = (i & (i + 1)) - 1;
}
return ans;
}
void add(int64_t i, int64_t val) {
while (i < sz) {
bit[i] += val;
i |= (i + 1);
}
}
};
signed main() {
go();
int64_t T = 1;
cin >> T;
for (int64_t tt = 1; tt <= T; tt++) {
int64_t n;
cin >> n;
vector<int64_t> a(n);
for (int64_t i = 0; i < n; i++) {
cin >> a[i];
}
if (set<int64_t>(a.begin(), a.end()).size() < n) {
cout << "YES\n";
} else {
Tree t(*max_element(a.begin(), a.end()) + 1);
int64_t S = 0;
for (int64_t i = n - 1; i >= 0; i--) {
t.add(a[i], 1);
S += t.sum(a[i] - 1);
}
cout << ((S & 1) ? "NO\n" : "YES\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
for (int f = 0; f < t; f++) {
long long int n, k;
cin >> n >> k;
long long int ans = 0;
if (k >= n) {
ans += (k - n);
} else if (n % 2 == 0) {
if (k % 2 == 0) {
ans = 0;
} else {
ans = 1;
}
} else {
if (k % 2 == 0) {
ans = 1;
} else {
ans = 0;
}
}
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const int MOD = 1000003;
const int N = 2e6 + 10;
const ll INF = 9e18;
const int M = 1010;
int q1[N], q2[N], q3[N];
int cnt[N];
int ans[N];
bool used[N];
vector<pair<pair<int, int>, int> > a[N];
map<pair<int, int>, vector<int> > x;
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n - 2; ++i) {
cin >> q1[i] >> q2[i] >> q3[i];
cnt[q1[i]]++;
cnt[q2[i]]++;
cnt[q3[i]]++;
x[{q1[i], q2[i]}].push_back(q3[i]);
x[{q1[i], q3[i]}].push_back(q2[i]);
x[{q2[i], q3[i]}].push_back(q1[i]);
}
int pos = 0, pos1 = 0;
for (int i = 1; i <= n; ++i) {
if (cnt[q1[i]] == 1) (pos == 0 ? pos : pos1) = i;
if (cnt[q2[i]] == 1) (pos == 0 ? pos : pos1) = i;
if (cnt[q3[i]] == 1) (pos == 0 ? pos : pos1) = i;
}
int cur1 = 0, cur2 = 0;
if (cnt[q1[pos]] == 1) ans[1] = q1[pos], cur1 = q1[pos];
if (cnt[q2[pos]] == 1) ans[1] = q2[pos], cur1 = q2[pos];
if (cnt[q3[pos]] == 1) ans[1] = q3[pos], cur1 = q3[pos];
if (cnt[q1[pos]] == 2) ans[2] = q1[pos], cur2 = q1[pos];
if (cnt[q2[pos]] == 2) ans[2] = q2[pos], cur2 = q2[pos];
if (cnt[q3[pos]] == 2) ans[2] = q3[pos], cur2 = q3[pos];
int cnt = 3;
used[cur1] = 1;
used[cur2] = 1;
for (int i = 1; i <= n - 2; ++i) {
bool ok = 0;
for (int j = 0; j < (x[{cur1, cur2}]).size(); ++j) {
int z = x[{cur1, cur2}][j];
if (used[z] == 1) continue;
ok = 1;
x[{cur1, cur2}].erase(x[{cur1, cur2}].begin() + j);
cur1 = cur2;
cur2 = z;
used[z] = 1;
ans[cnt] = z;
cnt++;
break;
}
if (ok) continue;
for (int j = 0; j < (x[{cur2, cur1}]).size(); ++j) {
int z = x[{cur2, cur1}][j];
if (used[z] == 1) continue;
ok = 1;
x[{cur2, cur1}].erase(x[{cur2, cur1}].begin() + j);
cur1 = cur2;
cur2 = z;
used[z] = 1;
ans[cnt] = z;
cnt++;
break;
}
}
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
}
| 3 |
#include <iostream>
using namespace std;
int main() {
int k[105][105]={0};
int n,l,a,b;
cin>>n;
for(int j=0;j<n;j++){
cin>>l>>a;
for(int i=0;i<a;i++){
cin>>b;
k[j][b-1]=1;
}
}
for(int r=0;r<n;r++){
for(int e=0;e<n-1;e++){
cout<<k[r][e]<<" ";
}
cout<<k[r][n-1]<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int i, j, a, b, cnt = 0;
char temp;
vector<vector<int> > x;
bool is_w(pair<int, int> x1, pair<int, int> x2) {
int ret_1 = 1, ret_2 = 1;
for (int i = min(x1.first, x2.first); i <= max(x1.first, x2.first); ++i) {
if (x[i][x1.second] == 0) {
ret_1 = 0;
}
if (x[i][x2.second] == 0) {
ret_2 = 0;
}
}
for (int i = min(x1.second, x2.second); i <= max(x1.second, x2.second); ++i) {
if (x[x1.first][i] == 0) ret_2 = 0;
if (x[x2.first][i] == 0) ret_1 = 0;
}
return ret_1 || ret_2;
}
int main() {
int result = 1;
scanf("%d %d", &a, &b);
x = vector<vector<int> >(a, vector<int>(b, 1));
vector<pair<int, int> > bl;
for (i = 0; i < a; ++i) {
for (j = 0; j < b; ++j) {
cin >> temp;
if (temp == 'W') {
x[i][j] = 0;
}
if (temp == 'B') {
bl.push_back(pair<int, int>(i, j));
cnt++;
x[i][j] = 1;
}
}
}
for (i = 0; i < (int)bl.size(); ++i) {
for (j = i + 1; j < (int)bl.size(); ++j) result *= is_w(bl[i], bl[j]);
}
if (result)
printf("YES");
else
printf("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > sol;
vector<bool> point;
int main() {
int n, m, t1, t2;
scanf("%d%d", &n, &m);
point.resize(n + 1);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &t1, &t2);
point[t1] = point[t2] = true;
}
for (int i = 1; i <= n; ++i) {
if (!point[i]) {
printf("%d\n", n - 1);
for (int j = 1; j <= n; ++j)
if (j != i) printf("%d %d\n", i, j);
break;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100020;
const int maxk = 620;
const int MOd = 1e9 + 7;
const int K = 300;
int a, b;
int fail[maxn];
char ar[maxn];
int main() {
scanf("%d %d", &a, &b);
for (int i = 1, p = 0; i <= a; i++) {
scanf(" %c", &ar[i]);
while (p > 0 && ar[i] != ar[p + 1]) p = fail[p];
if (p + 1 < i && ar[i] == ar[p + 1]) p++;
fail[i] = p;
}
int ans = b;
for (int i = 1; i <= fail[a]; i++) printf("%c", ar[i]);
for (int i = 1; i <= ans; i++) {
for (int j = fail[a] + 1; j <= a; j++) printf("%c", ar[j]);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ans[1 << 13][13][13][14];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int N, M, Q;
cin >> N >> M >> Q;
if (N == 1) {
cout << "1\n";
return 0;
}
vector<vector<int> > E(N, vector<int>(N, 0));
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
E[--a][--b] = 1;
E[b][a] = 1;
}
vector<vector<pair<int, int> > > lcap(N);
vector<vector<int> > child(N);
for (int i = 0; i < Q; i++) {
int a, b, c;
cin >> a >> b >> c;
c--, b--, a--;
if (a == b && a != c) {
cout << "0\n";
return 0;
}
if (a == b) continue;
if (a != c && b != c) lcap[c].push_back(make_pair(a, b));
if (a != c) child[c].push_back(a);
if (b != c) child[c].push_back(b);
}
vector<bool> ban(1 << N, false);
for (int i = 0; i < (1 << N); i++) {
for (int j = 0; j < N; j++)
if ((((i >> j) & 1) == 0))
for (auto it = lcap[j].begin(); it != lcap[j].end(); it++)
if (((i >> it->second) & 1) && ((i >> it->first) & 1)) ban[i] = true;
for (int j = 0; j < N; j++)
if (((i >> j) & 1))
for (auto it = child[j].begin(); it != child[j].end(); it++)
if ((((i >> *it) & 1) == 0)) ban[i] = true;
}
vector<int> v(1 << N), sub;
for (int i = 1; i < (1 << N); i++)
for (int r = 0; r < N; r++)
if (((i >> r) & 1))
for (int pr = 0; pr < N; pr++)
if ((((i >> pr) & 1) == 0) || (r == 0 && pr == 0)) {
if ((1 << r) == i) ans[i][r][pr][0] = 1;
for (int k = 0; k < N; k++) {
if (!((i >> k) & 1) || k == r) {
ans[i][r][pr][k + 1] = ans[i][r][pr][k];
continue;
}
ans[i][r][pr][k + 1] = ans[i][r][pr][k];
sub.clear();
for (int j = 0; j < N; j++)
if (((i >> j) & 1) && j != r && j != k) sub.push_back(j);
int s = sub.size(), b = 0;
v[0] = 1 << k;
for (int j = 0; j < (1 << s); j++) {
while ((1 << b) <= j) b++;
for (int l = b; l < s; l++)
v[j + (1 << l)] = v[j] + (1 << sub[l]);
ans[i][r][pr][k + 1] +=
ans[v[j]][k][r][N] * ans[i - v[j]][r][pr][k];
}
}
bool ok = true;
for (int j = 0; j < N; j++)
if (E[r][j] && (pr != j && (((i >> j) & 1) == 0))) ok = false;
if (!ok || ban[i]) ans[i][r][pr][N] = 0;
}
cout << ans[(1 << N) - 1][0][0][N] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> b[i];
vector<long long> a(n);
int mx = *max_element(b.begin(), b.end());
int st = -1;
for (int i = 0; i < n; i++) {
if (b[(i + 1) % n] > b[i]) {
st = (i + 1) % n;
}
}
if (st == -1) {
if (b[0] == 0) {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << 1 << " ";
return 0;
}
cout << "NO";
return 0;
}
cout << "YES\n";
a[st] = b[st];
a[(st + n - 1) % n] = a[st] * (mx / a[st] + 5) + b[(st + n - 1) % n];
for (int i = (st + n - 2) % n; i != st; i = (i + n - 1) % n) {
a[i] = a[(i + 1) % n] + b[i];
}
for (long long i : a) cout << i << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<ll,ll>P;
const int MOD=1000000007;
const int INF=0x3f3f3f3f;
const ll INFL=0x3f3f3f3f3f3f3f3f;
int a[100][100],b[100][100];
bool dp[82][82][30000];
int dx[]{1,-1,0,0},dy[]{0,0,1,-1};
int main(){
int h,w;cin>>h>>w;
rep(i,h)rep(j,w)scanf("%d",&a[i][j]);
rep(i,h)rep(j,w)scanf("%d",&b[i][j]),a[i][j]-=b[i][j],a[i][j]=abs(a[i][j]);
int K=15000;
dp[0][0][K+a[0][0]]=1;
dp[0][0][K-a[0][0]]=1;
rep(i,h)rep(j,w){
rep(k,K*2){
if(dp[i][j][k]==0)continue;
if(i+1<h)dp[i+1][j][k+a[i+1][j]]=1,dp[i+1][j][k-a[i+1][j]]=1;
if(j+1<w)dp[i][j+1][k+a[i][j+1]]=1,dp[i][j+1][k-a[i][j+1]]=1;
}
}
int Min=INT_MAX;
rep(i,30000){
if(dp[h-1][w-1][i]==1)Min=min(Min,abs(i-K));
}
cout<<Min<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int binpow(int a, int b) {
if (b == 0) return 1;
int res = binpow(a, b / 2);
if (b % 2)
return res * res * a;
else
return res * res;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
string to_upper(string a) {
for (int i = 0; i < (int)a.size(); ++i)
if (a[i] >= 'a' && a[i] <= 'z') a[i] -= 'a' - 'A';
return a;
}
string to_lower(string a) {
for (int i = 0; i < (int)a.size(); ++i)
if (a[i] >= 'A' && a[i] <= 'Z') a[i] += 'a' - 'A';
return a;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
long long sum = 0;
cin >> n >> m;
int a[n][m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
sum += a[i][j];
}
}
for (int i = n - 2; i > 0; --i) {
for (int j = m - 2; j > 0; --j) {
if (!a[i][j]) {
a[i][j] = max(1, min(a[i + 1][j], a[i][j + 1])) - 1;
sum += a[i][j];
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m - 1; ++j) {
if (a[i][j] >= a[i][j + 1]) {
cout << "-1";
return 0;
}
}
}
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] >= a[i + 1][j]) {
cout << "-1";
return 0;
}
}
}
cout << sum;
return 0;
}
| 3 |
#include <bits/stdc++.h>
//#define MAXN
using namespace std;
char str[20];
int len,ans,ch;
int main()
{
cin>>str;
len=strlen(str);
ans=str[0]-'0';
for(int i=1; i<len; i++)
if(str[i]!='9') ch=1;
if(ch && len!=1) ans-=1;
printf("%d\n",(len-1)*9+ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, a, b, n, m, str, stra, strb, raz, k, pa = 1, pb = 1;
int main() {
cin >> m >> n >> a >> b;
if (m % n == 0)
str = m / n;
else
str = m / n + 1;
if (a % n == 0)
stra = a / n;
else
stra = a / n + 1;
if (b % n == 0)
strb = b / n;
else
strb = b / n + 1;
if (a == (stra - 1) * n + 1) pa = 0;
if (b == strb * n || b == m) pb = 0;
if (pa + pb == 2) {
if (a % n == (b % n + 1) % n) pa = 0;
}
if (stra == strb - 1 && pa && pb) {
cout << 2;
return 0;
}
if (stra == strb) {
cout << 1;
return 0;
}
cout << pa + pb + 1;
return 0;
}
| 3 |
#include<iostream>
#include<cstdio>
using namespace std;
int main(void)
{
string s[10] = {"NA", "YYMM", "MMYY", "AMBIGUOUS"};
int a,b,y=0;
scanf("%2d%2d" ,&a,&b);
if(a>=1 && a<=12)
y+=2;
if(b>=1 && b<=12)
y+=1;
cout << s[y];
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> g[300005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
long long u, v;
for (int i = 0, ggdem = m; i < ggdem; ++i) {
cin >> u >> v;
u--;
v--;
g[u].push_back({v, i});
g[v].push_back({u, i});
}
set<long long> st;
vector<long long> mat;
for (int i = 0, ggdem = 3 * n; i < ggdem; ++i) {
st.insert(i);
for (auto j : g[i]) {
if (st.count(j.first)) {
st.erase(i);
st.erase(j.first);
mat.push_back(j.second);
break;
}
}
if (((int)st.size()) == n || ((int)mat.size()) == n) break;
}
if (((int)st.size()) == n) {
cout << "IndSet\n";
for (auto i : st) cout << i + 1 << " ";
cout << "\n";
} else if (((int)mat.size()) == n) {
cout << "Matching\n";
for (auto i : mat) cout << i + 1 << " ";
cout << "\n";
}
for (int i = 0, ggdem = 3 * n; i < ggdem; ++i) {
g[i].clear();
}
}
return 0;
}
| 5 |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define MOD 1000000007
#define rep(i,n) for(i=0;i<n;i++)
#define loop(i,a,n) for(i=a;i<n;i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
typedef vector<int> vi;
typedef pair<int,int> pii;
int main(void) {
int i,j;
int n;
vector<bool> prime(40000,true);
for(i=2;i<40000;i++)
if(prime[i])
for(j=2;i*j<40000;j++)
prime[i*j]=false;
vi ans(40000,0);
for(i=2;i<40000;i++)
if(prime[i])
for(j=i;j<40000;j++)
if(prime[j] && i+j<40000)
ans[i+j]++;
while(1){
cin>>n;
if(n==0)break;
cout<<ans[n]<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'W') {
if (j != m - 1 && a[i][j + 1] == 'P') {
count++;
a[i][j + 1] = '.';
} else if (j != 0 && a[i][j - 1] == 'P') {
count++;
a[i][j - 1] = '.';
} else if (i != 0 && a[i - 1][j] == 'P') {
count++;
a[i - 1][j] = '.';
} else if (i != n - 1 && a[i + 1][j] == 'P') {
count++;
a[i + 1][j] = '.';
}
}
}
}
cout << count << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T x, T y) {
if (!y) return x;
return gcd(y, x % y);
}
template <class T>
inline T mod(T x) {
if (x < 0)
return -x;
else
return x;
}
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int MAX = 1e3 + 5;
int b[MAX], w[MAX], s[MAX], bs[MAX];
long long dp[MAX][MAX];
bool vis[MAX];
vector<int> adj[MAX], v[MAX];
void dfs(int x, int k) {
s[k] += w[x];
bs[k] += b[x];
v[k].push_back(x);
vis[x] = true;
for (__typeof(0) i = 0; i < adj[x].size(); i += 1) {
int to = adj[x][i];
if (vis[to] == false) {
dfs(to, k);
}
}
}
int main(int argc, char* argv[]) {
if (argc == 2 or argc == 3) freopen(argv[1], "r", stdin);
if (argc == 3) freopen(argv[2], "w", stdout);
ios::sync_with_stdio(false);
int n, m, W, k = 1, x, y;
cin >> n >> m >> W;
for (__typeof(1) i = 1; i < n + 1; i += 1) {
cin >> w[i];
}
for (__typeof(1) i = 1; i < n + 1; i += 1) {
cin >> b[i];
}
for (__typeof(0) i = 0; i < m; i += 1) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (__typeof(1) i = 1; i < n + 1; i += 1) {
if (vis[i] == false) {
dfs(i, k);
k++;
}
}
for (__typeof(0) i = 0; i < k; i += 1) {
for (__typeof(0) l = 0; l < v[i].size(); l += 1) {
for (__typeof(0) j = 0; j < W + 1; j += 1) {
if (i == 0 or j == 0) {
dp[i][j] = 0;
continue;
}
x = v[i][l];
if (w[x] <= j) {
dp[i][j] =
max(dp[i - 1][j - w[x]] + b[x], max(dp[i - 1][j], dp[i][j]));
} else
dp[i][j] = max(dp[i - 1][j], dp[i][j]);
if (s[i] <= j) {
dp[i][j] = max(dp[i - 1][j - s[i]] + bs[i], dp[i][j]);
}
}
}
}
cout << dp[k - 1][W] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, k, i, q, x, y;
cin >> q;
for (i = 0; i < q; i++) {
cin >> k >> n >> a >> b;
if ((k - b * n) % (a - b) == 0)
x = (k - b * n) / (a - b) - 1;
else
x = (k - b * n) / (a - b);
if (x < 0 || b * n >= k)
cout << -1 << endl;
else if (x > n)
cout << n << endl;
else
cout << x << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, v[2 * 100000 + 10], aint[4 * 100000 + 10], l[100000 + 10],
ans[100000 + 10];
void update(int poz, int val) {
poz = poz + k - 1;
aint[poz] = val;
poz /= 2;
while (poz) {
aint[poz] = min(aint[2 * poz], aint[2 * poz + 1]);
poz /= 2;
}
}
int query(int nod, int stnod, int drnod, int stq, int drq) {
if (stq <= stnod && drnod <= drq) return aint[nod];
int mij = (stnod + drnod) / 2, mini = 200000000;
if (stq <= mij) mini = min(mini, query(2 * nod, stnod, mij, stq, drq));
if (drq > mij) mini = min(mini, query(2 * nod + 1, mij + 1, drnod, stq, drq));
return mini;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> v[i];
int bit = 0;
k = n;
while ((1 << bit) < k) bit++;
k = (1 << bit);
for (int i = 1; i <= n + 1; i++) l[i] = 0;
for (int i = 1; i <= n; i++) {
if (v[i] > 1) ans[1] = 1;
if (v[i] == 1) {
l[1] = i;
update(1, i);
continue;
}
int p = l[v[i]], val = query(1, 1, k, 1, v[i] - 1);
if (val > p) ans[v[i]] = 1;
update(v[i], i);
l[v[i]] = i;
}
for (int i = 2; i <= n + 1; i++)
if (query(1, 1, k, 1, i - 1) > l[i]) ans[i] = 1;
for (int i = 1; i <= n + 1; i++)
if (!ans[i]) {
cout << i << ' ';
return 0;
}
cout << n + 2 << '\n';
return 0;
}
| 5 |
#include<iostream>
#include<iomanip>
#include<cmath>
int const MAXN = 50;
int x[MAXN], y[MAXN], N;
int main() {
std::cin >> N;
double cx = 0.0, cy = 0.0;
for(int i = 0; i < N; ++i) {
std::cin >> x[i] >> y[i];
cx += x[i]; cy += y[i];
}
cx /= N; cy /= N;
double ans2;
for(double lr=0.1; lr > 1e-9; lr*=0.999) {
int mI = 0;
double dx = x[mI] - cx, dy = y[mI] - cy;
double mD2 = dx*dx + dy*dy;
for(int i = 1; i < N; ++i) {
dx = x[i] - cx; dy = y[i] - cy;
double d2 = dx*dx + dy*dy;
if(d2 > mD2) { mI = i; mD2 = d2; }
}
cx += (x[mI]-cx)*lr;
cy += (y[mI]-cy)*lr;
ans2 = mD2;
}
std::cout << std::setprecision(10) << std::fixed << std::sqrt(ans2) << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> years(n);
for (auto i = 0; i < n; i++) cin >> years[i];
sort(begin(years), end(years));
cout << years[n / 2] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x1, x2;
int a, b;
int mod;
int is_reversed;
int main() {
scanf("%d %d %d %d", &x1, &x2, &a, &b);
if (x1 > x2) {
int tmp;
is_reversed = 1;
x1 = -x1;
x2 = -x2;
tmp = a;
a = -b;
b = -tmp;
}
if (a <= x2 - x1 && x2 - x1 <= b) {
puts("FIRST");
printf("%d\n", is_reversed ? -x2 : x2);
return 0;
}
if (a <= 0) {
puts("DRAW");
return 0;
}
mod = (x2 - x1) % (a + b);
if (mod == 0) {
puts("SECOND");
return 0;
}
if (a <= mod && mod <= b) {
puts("FIRST");
printf("%d\n", is_reversed ? (-x1 - mod) : (x1 + mod));
} else {
puts("DRAW");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a;
cin >> n >> k;
a = k*pow((k-1),(n-1));
cout << a << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
sort(a,a+n);
cout<<a[n/2]-a[(n/2)-1];
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, int> smash;
int iwo[100005 + 10];
int main() {
int n, m, k;
long long ans = 0;
cin >> n >> m >> k;
for (int i = (1); i < (n + 1); i++) {
int omg;
cin >> omg;
smash[omg] = i;
iwo[i] = omg;
}
for (int i = (0); i < (m); i++) {
int a, aux, aux2, rec;
cin >> a;
ans += ((smash[a] - 1) / k) + 1;
aux = smash[a];
if (aux != 1) {
smash[a] = smash[a] - 1;
smash[iwo[aux - 1]] = aux;
aux2 = iwo[aux];
iwo[aux] = iwo[aux - 1];
iwo[aux - 1] = a;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
vector<pair<int, int> > g[N + 100];
vector<int> ans;
int d[N + 100], vis[N + 100];
int dfs(int u) {
vis[u] = 1;
int now = 0;
for (auto it : g[u]) {
if (!vis[it.first]) {
int f = dfs(it.first);
if (f) ans.push_back(it.second);
now = (now + f) % 2;
}
}
if (now == d[u])
return 0;
else
return 1;
}
int main() {
int n, m, sum = 0, cnt = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", d + i);
if (d[i] == -1)
cnt++;
else {
sum = (sum + d[i]) % 2;
}
}
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(make_pair(v, i));
g[v].push_back(make_pair(u, i));
}
if (sum % 2 && !cnt) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) {
if (d[i] == -1) {
if (cnt == 1) {
if (sum == 0)
d[i] = 0;
else
d[i] = 1;
} else
d[i] = 0;
cnt--;
}
}
dfs(1);
printf("%d\n", (int)ans.size());
for (auto it : ans) {
printf("%d ", it);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> tree[n + 1];
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
tree[p].push_back(i);
}
bool is_spruce = true;
for (int i = 1; i <= n; i++) {
if (tree[i].empty())
continue;
else {
int count = 0;
for (auto c : tree[i]) {
if (count == 3) break;
if (tree[c].size() == 0) count++;
}
if (count != 3) {
is_spruce = false;
break;
}
}
}
if (is_spruce)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int a, b, i;
scanf("%d%d", &a, &b);
for (i = 1; i <= a; i++) {
printf("%c", 'a' + i % b);
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int k, n;
long long b;
pair<int, int> a[100010];
int pos[100010];
int main() {
cin >> n >> k >> b;
for (int i = 0; i < n - 1; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n, greater<pair<int, int> >());
for (int i = 0; i < n - 1; i++) pos[a[i].second] = i;
long long sum = 0;
for (int i = 0; i < k - 1; i++) sum = sum + a[i].first;
int ans = -1;
for (int i = 0; i < n - 1; i++) {
long long tmp = sum;
if (pos[i] < k - 1) tmp = tmp - a[pos[i]].first + a[k - 1].first;
if (b - tmp < a[pos[i]].first) {
ans = i;
break;
}
}
if (ans == -1)
cout << n << endl;
else
cout << ans + 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 600005, INF = 1000000000;
int N, K, a[MAXN];
vector<int> V[MAXN];
char S[MAXN];
int fa[MAXN], val[MAXN], ans;
int get(int x) {
if (fa[x] != x) fa[x] = get(fa[x]);
return fa[x];
}
void merge(int x, int y) {
x = get(x), y = get(y);
if (x != y) fa[y] = x, val[x] += val[y];
}
inline int va(int x) { return min(val[get(x)], val[get(x + K)]); }
int main() {
scanf("%d%d%s", &N, &K, S + 1);
int i, j;
for (i = 1; i <= K; ++i) {
int c, x;
scanf("%d", &c);
while (c--) scanf("%d", &x), V[x].push_back(i);
}
for (i = 1; i <= K * 2; ++i) fa[i] = i, val[i] = i > K;
fa[K * 2 + 1] = K * 2 + 1, val[K * 2 + 1] = INF;
for (i = 1; i <= N; ++i) {
if (V[i].size() == 1) {
int x = V[i][0] + (S[i] == '1') * K;
ans -= va(V[i][0]);
merge(x, K * 2 + 1);
ans += va(V[i][0]);
} else if (V[i].size() == 2) {
int x = V[i][0], y = V[i][1];
if (S[i] == '0') {
if (get(x) != get(y + K))
ans -= va(x) + va(y), merge(x, y + K), merge(x + K, y), ans += va(x);
} else {
if (get(x) != get(y))
ans -= va(x) + va(y), merge(x, y), merge(x + K, y + K), ans += va(x);
}
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int id[N][N], n, m, t, mo;
int fa[N * N], rn[N * N], t1;
int gf(int x) { return fa[x] == x ? x : fa[x] = gf(fa[x]); }
int ty[N][N];
long long c[N][N], cnt, ans;
int fail;
void merge(int x, int y) {
if (gf(x) == gf(y)) fail = 1;
fa[gf(x)] = gf(y);
}
long long power(long long a, long long b = mo - 2) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mo;
a = a * a % mo;
b >>= 1;
}
return ans;
}
int ths[N], used[N];
void solve(int n) {
if (n > 200) return;
for (int i = 1; i <= n; i++) {
int sum = 0;
for (int j = 1; j <= n; j++) c[i][j] %= mo, sum += c[i][j];
c[i][i] = (c[i][i] - sum + mo) % mo;
}
n--;
for (int i = 1; i <= n; i++) {
int k = 0;
for (int j = 1; j <= n; j++) {
if (!used[j] && c[j][i]) {
k = j;
break;
}
}
if (!k) return;
ths[i] = k;
used[k] = 1;
long long z = power(c[k][i]);
for (int j = 1; j <= n; j++) {
if (!used[j] && c[j][i]) {
long long p = mo - z * c[j][i] % mo;
for (int u = 1; u <= n; u++) c[j][u] = (c[j][u] + p * c[k][u]) % mo;
}
}
}
long long prd = 1;
for (int i = 1; i <= n; i++) prd = prd * c[ths[i]][i] * -1 % mo;
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++)
if (ths[i] < ths[j]) prd *= -1;
ans = (ans + prd + mo) % mo;
}
int main() {
cin >> n >> m >> mo;
for (int i = 1; i <= n + 1; i++)
for (int j = 1; j <= m + 1; j++) id[i][j] = ++t, fa[t] = t;
for (int i = 1; i <= n; i++) {
scanf("\n");
for (int j = 1; j <= m; j++) {
ty[i][j] = getchar();
if (ty[i][j] == '\\') merge(id[i][j], id[i + 1][j + 1]);
if (ty[i][j] == '/') merge(id[i + 1][j], id[i][j + 1]);
}
}
for (int i = 1; i <= n + 1; i++)
for (int j = 1; j <= m + 1; j++) {
if ((i + j) & 1) continue;
if (fa[id[i][j]] == id[i][j]) rn[id[i][j]] = ++t1;
t1 = min(t1, 201);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (ty[i][j] == '*')
;
else
continue;
if ((i + j) & 1) {
c[rn[gf(id[i + 1][j])]][rn[gf(id[i][j + 1])]]++;
c[rn[gf(id[i][j + 1])]][rn[gf(id[i + 1][j])]]++;
} else {
c[rn[gf(id[i + 1][j + 1])]][rn[gf(id[i][j])]]++;
c[rn[gf(id[i][j])]][rn[gf(id[i + 1][j + 1])]]++;
}
}
solve(t1);
memset(c, 0, sizeof c);
memset(ths, 0, sizeof ths);
memset(used, 0, sizeof used);
t1 = 0;
for (int i = 1; i <= n + 1; i++)
for (int j = 1; j <= m + 1; j++) {
if ((i + j) & 1)
;
else
continue;
if (fa[id[i][j]] == id[i][j]) rn[id[i][j]] = ++t1;
t1 = min(t1, 201);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (ty[i][j] == '*')
;
else
continue;
if ((i + j) & 1) {
c[rn[gf(id[i + 1][j + 1])]][rn[gf(id[i][j])]]++;
c[rn[gf(id[i][j])]][rn[gf(id[i + 1][j + 1])]]++;
} else {
c[rn[gf(id[i + 1][j])]][rn[gf(id[i][j + 1])]]++;
c[rn[gf(id[i][j + 1])]][rn[gf(id[i + 1][j])]]++;
}
}
solve(t1);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char a[105][105];
char b[10005];
int whose[10005];
int share[105];
int ans[105][105];
int main(void) {
int T;
scanf("%d", &T);
for (int t = 0; t < T; t++) {
int r, c, k;
scanf("%d %d %d", &r, &c, &k);
int rice = 0;
for (int i = 0; i < r; i++) {
scanf("%s", a[i]);
for (int j = 0; j < c; j++) {
if (a[i][j] == 'R') rice++;
}
}
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
if (i % 2 == 0)
b[c * i + j] = a[i][j];
else
b[c * i + j] = a[i][c - j - 1];
}
for (int i = 0; i < k; i++) share[i] = rice / k;
for (int i = 0; i < rice % k; i++) share[i]++;
int cnt = 0;
int chi = 0;
for (int i = 0; i < r * c; i++) {
whose[i] = chi;
if (b[i] == 'R') cnt++;
if (share[chi] == cnt) {
cnt = 0;
if (chi < k - 1) chi++;
}
}
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
if (i % 2 == 0)
ans[i][j] = whose[c * i + j];
else
ans[i][c - j - 1] = whose[c * i + j];
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (ans[i][j] < 10)
printf("%d", ans[i][j]);
else if (ans[i][j] < 36)
printf("%c", 'a' + ans[i][j] - 10);
else if (ans[i][j] < 62)
printf("%c", 'A' + ans[i][j] - 36);
}
printf("\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
map<int, int> mp;
int n, T;
int add[N];
int L[N], R[N];
int main() {
memset(add, 0, sizeof(add));
cin >> n >> T;
set<int> st;
mp.clear();
for (int i = 1; i <= n; i++) {
int num;
scanf("%d", &num);
int l = max(0, num - i), r = T - i;
if (r <= l) {
L[i] = R[i] = -1;
continue;
}
L[i] = l;
R[i] = r;
st.insert(l);
st.insert(r);
}
int i = 1;
for (auto it = st.begin(); it != st.end(); it++) {
mp[*it] = i;
i++;
}
for (int i = 1; i <= n; i++)
if (L[i] != -1) {
add[mp[L[i]]]++;
add[mp[R[i]]]--;
}
int MAX = 0;
int m = st.size();
for (int i = 1; i <= m; i++) {
add[i] += add[i - 1];
MAX = max(MAX, add[i]);
}
cout << MAX << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> beauty(2100, 0), weight(2100, 0);
vector<long long> b;
vector<vector<long long> > a(2100, b);
vector<vector<long long> > gr(2001);
vector<long long> ccc(2101, 0);
vector<vector<long long> > dp(2101, ccc);
long long w, n, m;
vector<long long> group(2100, 0);
void dfs(long long start, long long color) {
group[start] = color;
for (long long i = 0; i < a[start].size(); i++) {
if (group[a[start][i]] == 0) dfs(a[start][i], color);
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> w;
long long i, j, k;
for (i = 1; i <= n; i++) cin >> weight[i];
for (i = 1; i <= n; i++) cin >> beauty[i];
for (i = 0; i < m; i++) {
long long e, r;
cin >> e >> r;
a[e].push_back(r);
a[r].push_back(e);
}
long long next = 0;
for (i = 1; i <= n; i++) {
if (group[i] == 0) {
next++;
dfs(i, next);
}
}
for (i = 1; i <= n; i++) {
long long cur = group[i];
gr[cur].push_back(i);
}
for (j = 1; j <= 1; j++) {
long long sumw = 0, sumb = 0;
for (i = 0; i < gr[j].size(); i++) {
long long cur = gr[j][i];
sumw += weight[cur];
sumb += beauty[cur];
if (weight[cur] <= w) {
dp[weight[cur]][j] = max(dp[weight[cur]][j], beauty[cur]);
}
}
if (sumw <= w) dp[sumw][j] = max(dp[sumw][j], sumb);
}
for (j = 2; j <= next; j++) {
long long sumw = 0, sumb = 0;
long long nol = 0;
for (i = 0; i < gr[j].size(); i++) {
long long cur = gr[j][i];
sumw += weight[cur];
sumb += beauty[cur];
for (k = w; k >= 0; k--) {
long long znach = dp[j - 1][k];
if (k + weight[cur] <= w) {
dp[k + weight[cur]][j] =
max(dp[k + weight[cur]][j], dp[k][j - 1] + beauty[cur]);
}
dp[k][j] = max(dp[k][j], dp[k][j - 1]);
}
}
for (k = w; k >= 0; k--) {
long long znach = dp[j - 1][k];
if (k + sumw <= w) {
dp[k + sumw][j] = max(dp[k + sumw][j], dp[k][j - 1] + sumb);
}
}
}
long long ans = 0;
for (i = 1; i <= w; i++)
for (j = 1; j <= next; j++) ans = max(ans, dp[i][j]);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Contest {
int tasks;
int penalty;
};
int n, place, answer;
vector<Contest> command;
bool compare(Contest x, Contest y) {
if (x.tasks == y.tasks) {
return (x.penalty < y.penalty);
}
return x.tasks > y.tasks;
}
int main() {
scanf("%d %d", &n, &place);
place--;
command.resize(n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &command[i].tasks, &command[i].penalty);
}
sort(command.begin(), command.end(), compare);
Contest Find = command[place];
for (int i = 0; i < n; i++) {
if (command[i].tasks == Find.tasks && command[i].penalty == Find.penalty) {
answer++;
}
}
printf("%d\n", answer);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void fastInOut();
const int N = 1e5 + 5;
int main() {
fastInOut();
string s;
cin >> s;
int ver_c = 0, hor_c = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0') {
cout << "1 " << ver_c + 1 << "\n";
ver_c = (ver_c + 1) % 4;
} else {
cout << "3 " << hor_c + 1 << "\n";
hor_c = (hor_c + 2) % 4;
}
}
return 0;
}
void fastInOut() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300030;
const int inf = 0x3f3f3f3f;
int n, x, y;
int pre[maxn];
bool vis[maxn], xoy[maxn];
vector<int> mp[maxn];
void init() {
cin >> n >> x >> y;
memset(vis, false, sizeof(vis));
memset(xoy, false, sizeof(xoy));
memset(pre, -1, sizeof(pre));
int a, b;
for (int i = 1; i < n; i++) {
cin >> a >> b;
mp[a].push_back(b);
mp[b].push_back(a);
}
}
void pridfs(int a, int f) {
pre[a] = f;
if (a == y) return;
int size = mp[a].size();
for (int i = 0; i < size; i++) {
int v = mp[a][i];
if (v != f) {
pridfs(v, a);
}
}
}
int dfs(int u) {
vis[u] = true;
int size = mp[u].size();
int cnt = 1;
for (int i = 0; i < size; i++) {
int v = mp[u][i];
if (!vis[v] && v != x && v != y) {
cnt += dfs(v);
}
}
return cnt;
}
int main() {
init();
pridfs(x, -1);
for (int i = pre[y]; i != x; i = pre[i]) {
vis[i] = true;
}
int cntx = dfs(x);
int cnty = dfs(y);
cout << (long long)n * (n - 1) - (long long)cntx * cnty << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long powm(long long base, long long exp, long long mod = 1000000007) {
base %= mod;
long long ans = 1;
while (exp) {
if (exp & 1LL) ans = (ans * base) % mod;
exp >>= 1LL, base = (base * base) % mod;
}
return ans;
}
long long a[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, sum = 0;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i + 1];
sum += a[i + 1];
}
sort(a + 1, a + n + 1);
long long ans = 0;
long long curr = 1;
for (long long i = 1; i <= n; i++) {
if (curr <= a[i]) {
curr++;
}
ans++;
}
ans += a[n] - curr + 1;
cout << sum - ans << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
int n, e, idx[N], low[N], T;
vector<vector<int> > g;
vector<int> S;
bool vis[N];
int compID[N], compH[N], cmp;
void DFS(int u) {
idx[u] = low[u] = ++T;
S.push_back(u);
vis[u] = true;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (idx[v] == 0) DFS(v);
if (vis[v]) low[u] = min(low[u], low[v]);
}
if (idx[u] == low[u]) {
compH[cmp] = u;
while (true) {
int v = S.back();
S.pop_back();
vis[v] = false;
compID[v] = cmp;
if (v == u) break;
}
++cmp;
}
}
int Not(int u) {
if (u >= e) return u - e;
return u + e;
}
void add(int a, int b) {
g[Not(a)].push_back(b);
g[Not(b)].push_back(a);
}
int main() {
cin >> n >> e;
g.resize(2 * e);
vector<pair<int, int> > v;
for (int i = 0; i < e; ++i) {
int from, to;
cin >> from >> to;
--from;
--to;
if (from > to) swap(from, to);
v.push_back(make_pair(from, to));
}
for (int i = 0; i < e; ++i)
for (int j = 0; j < e; ++j) {
if (i == j) continue;
if (v[i].first < v[j].first && v[i].second > v[j].first &&
v[i].second < v[j].second) {
add(i, j);
add(Not(i), Not(j));
}
}
for (int i = 0; i < g.size(); ++i)
if (idx[i] == 0) DFS(i);
for (int i = 0; i < e; ++i)
if (compID[i] == compID[Not(i)]) {
puts("Impossible");
return 0;
}
vector<int> assign(g.size(), -1);
for (int i = 0; i < cmp; ++i)
if (assign[i] == -1) {
assign[i] = true;
assign[compID[Not(compH[i])]] = false;
}
for (int i = 0; i < e; ++i)
if (assign[compID[i]])
printf("o");
else
printf("i");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) cout << 4 << ' ';
cout << 1 << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int t;
cin >> t;
while (t > 0) {
t--;
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
vector<int> g[N];
vector<int> vec;
int n, root;
int dist[N], fa[N], ans[N], h[N], son[N];
bool mark[N];
void dfs1(int u, int f) {
dist[u] = dist[f] + 1;
if (dist[u] > dist[root]) root = u;
for (auto v : g[u]) {
if (v != f) {
dfs1(v, u);
}
}
}
void dfs2(int u, int f) {
h[u] = 1;
fa[u] = f;
vec.push_back(u);
for (auto v : g[u]) {
if (v != f) {
dfs2(v, u);
if (h[v] + 1 > h[u]) {
h[u] = h[v] + 1;
son[u] = v;
}
}
}
}
bool cmp(int i, int j) { return h[i] > h[j]; }
int main() {
scanf("%d", &n);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(1, 0);
dfs2(root, 0);
sort(vec.begin(), vec.end(), cmp);
ans[1] = 1;
mark[root] = true;
int it = 0;
for (int i = 2; i <= n; i++) {
int cnt = 0;
while (it < vec.size() && mark[vec[it]]) it++;
if (it == vec.size()) break;
u = vec[it];
while (u && !mark[u]) {
cnt++;
mark[u] = true;
u = son[u];
}
ans[i] = ans[i - 1] + cnt;
if (ans[i] == n) break;
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i] ? ans[i] : n);
puts("");
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int kMaxv = (int)5e6 + 10, kMaxe = (int)6e6 + 10;
typedef int IntArr[kMaxv];
struct Edge {
int to, next;
} E[kMaxe];
int n, m, d, totscc, dfs_clock, top, tote;
IntArr dfn, low, last, val, sumv, col, DP, S;
std::pair<int, int> E0[kMaxe];
char IN[60];
inline void Umin(int& x, int y) { x > y ? x = y : 0; }
inline void Umax(int& x, int y) { x < y ? x = y : 0; }
inline int Id(int u, int day) { return (u - 1) * d + day; }
inline int Node(int u) { return u / d + 1; }
inline void AddEdge(int u, int v) {
E[++tote].to = v, E[tote].next = last[u];
last[u] = tote;
}
void Tarjan(int u);
int Dfs(int);
int main() {
scanf("%d%d%d", &n, &m, &d);
int flag = 0;
for (int i = 0, u, v; i < m; i++) {
scanf("%d%d", &u, &v);
for (int j = 0; j < d; j++) {
AddEdge(Id(u, j), Id(v, (j + 1) % d));
}
}
if (flag) return puts("Fuck you!"), 0;
for (int i = 1; i <= n; i++) {
scanf("%s", IN);
for (int j = 0; j < d; j++) {
val[Id(i, j)] = IN[j] ^ '0';
}
}
int tot = Id(n, d - 1);
for (int i = 0; i <= tot; i++)
if (!dfn[i]) Tarjan(i);
tote = 0;
for (int i = 0, cur; i <= tot; i++) {
cur = col[i];
for (int e = last[i], v = E[e].to; e; v = E[e = E[e].next].to) {
if (cur == col[v]) continue;
E0[tote++] = std::pair<int, int>(cur, col[v]);
}
}
std::sort(E0, E0 + tote);
int tote0 = std::unique(E0, E0 + tote) - E0;
tote = 0;
memset(last, 0, sizeof last);
for (int i = 0; i < tote0; i++) {
AddEdge(E0[i].first, E0[i].second);
}
memset(DP, 0xff, sizeof DP);
printf("%d\n", Dfs(col[0]));
return 0;
}
int Dfs(int u) {
if (~DP[u]) return DP[u];
DP[u] = 0;
for (int e = last[u], v = E[e].to; e; v = E[e = E[e].next].to)
Umax(DP[u], Dfs(v));
return DP[u] += sumv[u];
}
void Tarjan(int u) {
dfn[u] = low[u] = ++dfs_clock;
S[top++] = u;
for (int e = last[u], v = E[e].to; e; v = E[e = E[e].next].to) {
if (!dfn[v]) {
Tarjan(v);
Umin(low[u], low[v]);
} else if (!col[v]) {
Umin(low[u], dfn[v]);
}
}
if (dfn[u] == low[u]) {
int top0 = top;
col[u] = ++totscc;
sumv[totscc] = DP[Node(u)] = val[u];
for (int cur; (cur = S[top - 1]) != u; --top) {
if (val[cur] && !DP[Node(cur)]) {
++sumv[totscc];
DP[Node(cur)] = 1;
}
col[cur] = totscc;
}
--top;
for (int i = top0 - 1; i >= top; i--) {
DP[Node(S[i])] = 0;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string st;
cin >> st;
int k = 0;
vector<int> res;
for (int i = 0; i < n; ++i) {
if (st[i] == 'B')
k++;
else {
if (k > 0) res.push_back(k);
k = 0;
}
}
if (k > 0) res.push_back(k);
if (res.empty()) {
cout << "0" << endl;
return 0;
}
cout << res.size() << endl;
cout << res[0];
for (int i = 1; i < res.size(); ++i) {
cout << " " << res[i];
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, i;
n = 1000;
printf("%d\n", n * 2);
for (i = 1; i <= n; i++) {
printf("%d 1 %d 2\n", i, i);
}
for (i = n; i > 0; i--) {
printf("%d 1 %d 2\n", i, i);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, tmp[51], h[100001], tag[100001], rr = 0, a1, a2, sv[100001];
long long s[100001], all, ans[100001], sh = 0;
vector<int> Ed[100001];
pair<int, int> W[100001], E[100001];
long long DFS(int now, int cent) {
if (tag[now] == rr) return 0;
tag[now] = rr;
all += s[now];
sv[now] = cent;
for (int i = 0; i < Ed[now].size(); i++) s[now] += DFS(Ed[now][i], cent);
return s[now];
}
int find(int now) {
if (h[now] != now) h[now] = find(h[now]);
return h[now];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) scanf("%d", &tmp[j]);
E[i] = make_pair(tmp[0], tmp[1]);
W[i] = make_pair(tmp[2], i);
}
sort(W + 1, W + n);
for (int i = 1; i <= n; i++) h[i] = i, s[i] = 1LL;
for (int i = 1, j = i; i < n; i++) {
for (j = i; j < n && W[i].first == W[j].first; j++) {
a1 = h[E[W[j].second].first] = find(h[E[W[j].second].first]);
a2 = h[E[W[j].second].second] = find(h[E[W[j].second].second]);
Ed[a1].push_back(a2);
Ed[a2].push_back(a1);
}
rr++;
for (int k = i; k < j; k++) {
if (tag[h[E[W[k].second].first]] < rr)
s[h[E[W[k].second].first]] =
DFS(h[E[W[k].second].first], h[E[W[k].second].first]);
}
for (int k = i; k < j; k++) {
a1 = h[E[W[k].second].first], a2 = h[E[W[k].second].second];
ans[W[k].second] = (s[sv[a1]] - min(s[a1], s[a2])) * min(s[a1], s[a2]);
sh = max(sh, ans[W[k].second]);
Ed[a1].pop_back();
Ed[a2].pop_back();
}
for (int k = i; k < j; k++) {
a1 = h[E[W[k].second].first], a2 = h[E[W[k].second].second];
h[a1] = sv[a1];
h[a2] = sv[a2];
}
i = j - 1;
}
int x = 0;
for (int i = 1; i < n; i++)
if (ans[i] == sh) x++;
printf("%I64d %d\n", sh * 2, x);
for (int i = 1; i < n; i++)
if (ans[i] == sh) printf("%d ", i);
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
int sum[10000001];
int main(){
int n;scanf("%d",&n);
rep(i,n){
int h;scanf("%d",&h);
sum[h]++;
}
for(int i=9999999;i>=0;i--)sum[i]+=sum[i+1];
ll cnt=1;
int a=4;
for(int i=1;i<=10000000;i++){
cnt+=min(a,sum[i]);
a+=4;
}
printf("%lld\n",cnt);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define all(V) (V).begin(),(V).end()
#define MOD 1000000007
#define mod 998244353
ll rw1[100010], rw2[100010];
int main(){
for (int i = 0;i < 100010;i++)rw1[i] = rw2[i] = 0;
ll N, M, a, b, ans = 0;
cin >> N >> M;
cin >> a;
for (int i = 1;i < N;i++) {
cin >> b;
if (a < b) {
rw1[a + 1]++;
rw1[b + 1]--;
rw2[a + 1]--;
rw2[b + 1] -= b - a - 1;
ans += b - a;
}
else {
rw1[1]++;
rw1[b + 1]--;
rw2[0] += M - a - 1;
rw2[b + 1] -= b + (M - a - 1);
rw1[a + 1]++;
rw2[a + 1]--;
ans += M - a + b;
}
a = b;
}
a = 0;
for (int i = 1;i <= M;i++)rw1[i] += rw1[i - 1];
rw2[0] += rw1[0];
for (int i = 1;i <= M;i++)rw2[i] += rw2[i - 1] + rw1[i];
for (int i = 1;i <= M;i++)a = max(a, rw2[i]);
cout << ans - a << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[9];
for (int i = 0; i < 9; i++) cin >> a[i];
if (a[0] == a[8] && a[1] == a[7] && a[2] == a[6] && a[3] == a[5])
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
set<int> intersection(set<int> a, set<int> b) {
set<int> c;
for (int i : a) {
if (b.find(i) != b.end()) c.insert(i);
}
return c;
}
void solveFunction() {
int n, m;
cin >> n >> m;
vector<pair<int, int> > edges;
set<int> s[n + 1];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
s[x].insert(y);
s[y].insert(x);
edges.push_back({x, y});
}
int color[n + 1];
memset(color, 0, sizeof color);
for (auto i : edges) {
if (color[i.first] == 0 && color[i.second] == 0) {
set<int> inter = intersection(s[i.first], s[i.second]);
color[i.first] = 1;
color[i.second] = 2;
for (auto j : inter) color[j] = 3;
for (auto j : s[i.first]) {
if (inter.find(j) == inter.end()) color[j] = 2;
}
for (auto j : s[i.second]) {
if (inter.find(j) == inter.end()) color[j] = 1;
}
}
}
int cnt[4], edgcnt[4];
memset(cnt, 0, sizeof cnt);
memset(edgcnt, 0, sizeof edgcnt);
for (int i = 1; i <= n; i++) cnt[color[i]]++;
for (auto i : edges) {
if (color[i.first] == color[i.second]) {
cout << -1;
return;
}
edgcnt[color[i.first]]++;
edgcnt[color[i.second]]++;
}
for (int i = 1; i <= 3; i++) {
if (cnt[i] * (n - cnt[i]) != edgcnt[i] || cnt[i] == 0) {
cout << -1 << "\n";
return;
}
}
for (int i = 1; i <= n; i++) cout << color[i] << " ";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
solveFunction();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char buf[1000];
struct Node {
int ne[26];
int ecnt;
Node() {
memset(ne, -1, sizeof ne);
ecnt = 0;
}
int& operator[](int x) { return ne[x]; }
};
const int INF = 2e9 + 2e6;
int main() {
int n, k;
while (scanf("%d%d", &n, &k) >= 1) {
vector<string> ss(n);
for (int i = 0; i < n; i++) {
scanf("%s", buf);
ss[i] = buf;
}
sort(ss.begin(), ss.end());
vector<int> lcp0(n - 1);
for (int i = 0; i + 1 < n; i++) {
int k = 0;
while (ss[i][k] && ss[i][k] == ss[i + 1][k]) k++;
lcp0[i] = k;
}
vector<vector<int> > lcp(n, vector<int>(n, 0));
for (int a = 0; a + 1 < n; a++) {
int k = lcp0[a];
for (int b = a + 1; b < n; b++) {
k = min(k, lcp0[b - 1]);
lcp[a][b] = lcp[b][a] = k;
}
}
vector<Node> ns(1);
for (int i = 0; i < n; i++) {
int v = 0;
for (int i2 = 0; ss[i][i2]; i2++) {
int c = ss[i][i2] - 'a';
if (ns[v][c] < 0) {
ns.push_back(Node());
ns[v][c] = ((int)(ns).size()) - 1;
}
v = ns[v][c];
}
ns[v].ecnt++;
}
vector<int> nextInt(((int)(ns).size()), -1), nextLen(((int)(ns).size()), 1);
for (int i = ((int)(ns).size()) - 1; i >= 0; i--) {
nextInt[i] = i;
if (ns[i].ecnt) continue;
for (int i2 = 0; i2 < 26; i2++)
if (ns[i][i2] >= 0) {
if (nextInt[i] != i) {
nextInt[i] = i;
nextLen[i] = 1;
break;
}
nextInt[i] = nextInt[ns[i][i2]];
nextLen[i] = 1 + nextLen[ns[i][i2]];
}
}
nextInt[0] = 0;
nextLen[0] = 1;
vector<int> prLen(((int)(ns).size()), 1);
for (int i = 0; i < ((int)(ns).size()); i++)
if (nextInt[i] == i) {
for (int i2 = 0; i2 < 26; i2++)
if (ns[i][i2] >= 0) {
prLen[nextInt[ns[i][i2]]] = nextLen[ns[i][i2]];
}
}
vector<vector<int> > dyn(((int)(ns).size()));
for (int i = 0; i < ((int)(ns).size()); i++)
if (nextInt[i] == i) dyn[i] = vector<int>(k + 1, -INF);
for (int v = ((int)(ns).size()) - 1; v >= 0; v--)
if (nextInt[v] == v) {
vector<vector<int> > dc(27, vector<int>(k + 1, -INF));
for (int ccnt = 0; ccnt <= ns[v].ecnt; ccnt++) dc[0][ccnt] = 0;
for (int i = 0; i < 26; i++) {
int b = ns[v][i];
if (b < 0) {
dc[i + 1] = dc[i];
continue;
}
b = nextInt[b];
assert(v <= b);
for (int wcnt = 0; wcnt <= k; wcnt++)
if (dc[i][wcnt] >= 0)
for (int ccnt = 0; wcnt + ccnt <= k; ccnt++) {
dc[i + 1][wcnt + ccnt] =
max(dc[i + 1][wcnt + ccnt], dc[i][wcnt] + dyn[b][ccnt]);
}
}
for (int ccnt = 0; ccnt <= k; ccnt++)
if (dc[26][ccnt] >= 0) {
dyn[v][ccnt] = dc[26][ccnt] + prLen[v] * ccnt * (ccnt - 1) / 2;
}
}
printf("%d\n", dyn[nextInt[0]][k] - k * (k - 1) / 2);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2048;
const long long MOD = 1000000007;
bool visited[MAXN][MAXN];
long long cache[MAXN][MAXN];
long long factorial[MAXN];
void factorial_init() {
factorial[0] = 1;
for (int i = 1; i < MAXN; i++) {
factorial[i] = (factorial[i - 1] * i) % MOD;
}
}
long long D(int n, int m) {
if (n < 0) return 0;
if (n == 0) return factorial[m];
long long &s = cache[n][m];
if (visited[n][m]) return s;
visited[n][m] = true;
s = (m * D(n - 1, m) + (n - 1) * D(n - 2, m + 1)) % MOD;
return s;
}
int a[MAXN];
bool pos[MAXN];
int TestNum;
int main() {
factorial_init();
int N;
cin >> N;
for (int i = 1; i <= N; i++) cin >> a[i];
int n = N;
for (int i = 1; i <= N; i++) {
if (a[i] != -1) {
n--;
pos[i] = true;
}
}
int m = 0;
for (int i = 1; i <= N; i++) {
if (a[i] != -1) {
int t = a[i];
if (!pos[t]) m++;
}
}
cout << D(n - m, m) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC diagnostic ignored "-Wmissing-declarations"
multiset<int> have;
long long sum;
int cnt = 0;
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
int q;
cin >> q;
long long cur = -1;
while (q--) {
int t;
cin >> t;
if (t == 1) {
if (cur != -1) have.insert(cur);
cin >> cur;
while (!have.empty() && (*have.begin() * 1LL * (cnt + 1) < sum + cur)) {
++cnt;
sum += *have.begin();
have.erase(have.begin());
}
} else {
cout << cur - static_cast<double>(sum + cur) / (cnt + 1) << '\n';
}
}
}
| 5 |
#include <stdio.h>
#define _USE_MATH_DEFINES
#include <math.h>
int main(void){
int n , i , buf;
float x1,x2,x3,y1,y2,y3,a1,a2,b1,b2,c1,c2,xp,yp,r;
scanf("%d" , &n);
for(i=1;i<=n;i++){
scanf("%f %f %f %f %f %f" , &x1 , &y1 , &x2 , &y2 , &x3 , &y3);
a1 = 2 * (x2 - x1);
b1 = 2 * (y2 - y1);
c1 = x1 * x1 - x2 * x2 + y1 * y1 - y2 * y2;
a2 = 2 * (x3 - x1);
b2 = 2 * (y3 - y1);
c2 = x1 * x1 - x3 * x3 + y1 * y1 - y3 * y3;
xp = (b1 * c2 - b2 * c1) / (a1 * b2 - a2 * b1);
yp = (c1 * a2 - c2 * a1) / (a1 * b2 - a2 * b1);
r = sqrt((xp - x1) * (xp - x1) + (yp - y1) * (yp - y1));
printf("%.3f %.3f %.3f\n" , xp , yp , r);
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int f,q,x;
string s;
map<string,int>m;
cin>>q;
while(q--){
cin>>f;
if(f==0){
cin>>s;
cin>>x;
m[s]=x;
}
else{
cin>>s;
cout<<m[s]<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b, i;
cin >> a >> b;
bool flag = 0;
long long int max1 = max(a, b);
long long int p = a + b;
if (p % 2) flag = 1;
max1 = 2 * max1;
long long int ans = max1 - p;
long long int q = sqrt(p);
for (i = 0; i < 100000; i++) {
long long int w = (i * (i + 1)) / 2;
if (w >= ans && flag && (i % 4 == 1 || i % 4 == 2)) break;
if (w >= ans && !flag && (i % 4 == 0 || i % 4 == 3)) break;
}
cout << i << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s1[110], s2[110], v[110];
int l1, l2, l3, go[110][110];
int f(int x, char y) {
string s = "";
for (int i = 0; i <= x; i++) s += v[i];
s += y;
for (int i = l3; i > 0; i--) {
int st2 = (int)s.length() - i;
if (st2 < 0) continue;
bool ok = 1;
for (int j = 1; j <= i; j++)
if (v[j - 1] != s[st2 + j - 1]) {
ok = 0;
break;
}
if (ok == 1) return i;
}
return 0;
}
int dp[110][110][110], zz[110][110][110];
pair<int, int> fr[110][110][110];
int nxt1[110][110], nxt2[110][110];
int main() {
cin >> s1 >> s2 >> v;
l1 = strlen(s1);
l2 = strlen(s2);
l3 = strlen(v);
for (int i = 1; i < l3; i++)
for (int j = 'A'; j <= 'Z'; j++) {
go[i][j] = f(i - 1, j);
}
go[0][v[0]] = 1;
for (int i = 'A'; i <= 'Z'; i++) nxt1[l1 - 1][i] = -1, nxt2[l2 - 1][i] = -1;
for (int i = l1 - 2; i >= 0; i--)
for (char j = 'A'; j <= 'Z'; j++) {
nxt1[i][j] = nxt1[i + 1][j];
if (s1[i + 1] == j) nxt1[i][j] = i + 1;
}
for (int i = l2 - 2; i >= 0; i--)
for (char j = 'A'; j <= 'Z'; j++) {
nxt2[i][j] = nxt2[i + 1][j];
if (s2[i + 1] == j) nxt2[i][j] = i + 1;
}
for (int i = 0; i < l1; i++)
for (int j = 0; j < l2; j++)
if (s1[i] == s2[j]) {
if (s1[i] == v[0])
dp[i][j][0] = -100000, dp[i][j][1] = 1;
else
dp[i][j][1] = -100000, dp[i][j][0] = 1;
}
for (int i = 0; i < l1; i++) {
for (int j = 0; j < l2; j++) {
if (s1[i] != s2[j]) continue;
for (int z = 0; z < l3; z++)
for (char e = 'A'; e <= 'Z'; e++) {
int to1 = nxt1[i][e], to2 = nxt2[j][e], pos;
pos = go[z][e];
if (pos == l3) continue;
if (to1 == -1 || to2 == -1) continue;
if (dp[to1][to2][pos] < dp[i][j][z] + 1) {
dp[to1][to2][pos] = dp[i][j][z] + 1;
fr[to1][to2][pos] = make_pair(i, j);
zz[to1][to2][pos] = z;
}
}
}
}
int mxans = 0, wh1, wh2, wh3;
for (int i = 0; i < l1; i++)
for (int j = 0; j < l2; j++)
for (int z = 0; z < l3; z++) {
if (dp[i][j][z] > mxans) {
mxans = dp[i][j][z];
wh1 = i;
wh2 = j;
wh3 = z;
}
}
if (mxans == 0) {
cout << 0 << endl;
return 0;
}
vector<char> ans;
for (int i = 1; i <= mxans; i++) {
ans.push_back(s1[wh1]);
int nwh1, nwh2, nwh3;
nwh1 = fr[wh1][wh2][wh3].first;
nwh2 = fr[wh1][wh2][wh3].second;
nwh3 = zz[wh1][wh2][wh3];
wh1 = nwh1;
wh2 = nwh2;
wh3 = nwh3;
}
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i];
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long fastpowMOD(long long a, long long p, long long MOD) {
if (p == 0) return 1;
long long z = fastpowMOD(a, p / 2, MOD);
z = (z * z) % MOD;
if (p % 2) z = (z * a) % MOD;
return z;
}
bool seive[100005];
long long dp[10005][105];
void SieveOfEratosthenes(long long n) {
memset(seive, true, sizeof(seive));
for (long long p = 2; p * p <= n; p++)
if (seive[p] == true)
for (long long i = p * p; i <= n; i += p) seive[i] = false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, i, j, k, m;
cin >> n >> m;
long long l = 0;
long long r = 1e9;
long long a[n + 5][m + 5];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a[i][j];
}
}
long long o = 3 | 5;
while (l < r) {
long long mid = (l + r + 1) / 2;
long long val[257] = {0};
for (i = 0; i < n; i++) {
long long sum = 0;
for (j = 0; j < m; j++) {
if (a[i][j] >= mid) {
sum += (1 << j);
}
}
val[sum]++;
}
long long flag = 0;
for (i = 0; i <= 255; i++) {
for (j = 0; j <= 255; j++) {
if ((i | j) == (1 << m) - 1) {
if (val[i] and val[j]) {
flag = 1;
}
}
}
}
if (flag) {
l = mid;
} else {
r = mid - 1;
}
}
long long mid = l;
long long val[257] = {0};
for (i = 0; i < n; i++) {
long long sum = 0;
for (j = 0; j < m; j++) {
if (a[i][j] >= mid) {
sum += (1 << j);
}
}
val[sum] = i + 1;
}
long long flag = 0;
long long c1, c2;
for (i = 0; i <= 255; i++) {
for (j = 0; j <= 255; j++) {
if ((i | j) == (1 << m) - 1) {
if (val[i] and val[j]) {
flag = 1;
c1 = val[i];
c2 = val[j];
}
}
}
}
cout << c1 << " " << c2;
}
| 4 |
// ๆๅทๅใฏใๅ
ฅๅใใใ้ ็ชใซในใฏใใๆไฝใใใใใฎใจใใใโใ(ๅฏใ
#include<iostream>
#include<cstdio>
#include<string>
#include<cstdlib>
#include<algorithm>
using namespace std;
int main(){
string message;
int n,a[111],b[111],c;
while(1){
cin >> n;
if(n==0)break;
cin >> message;
for(int i=0;i<n;i++){
cin >> a[i] >> b[i];
a[i]--;b[i]--;
}
for(int i=n-1;i>=0;i--){
c = abs(b[i] - a[i]);
for(int j=0;j<c;j++){
message[a[i]]++;
message[b[i]]++;
if(message[a[i]]>'z')message[a[i]]='a';
if(message[b[i]]>'z')message[b[i]]='a';
}
swap(message[a[i]],message[b[i]]);
}
cout << message << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
string print_iterable(T1 begin_iter, T2 end_iter, int counter) {
bool done_something = false;
stringstream res;
res << "[";
for (; begin_iter != end_iter and counter; ++begin_iter) {
done_something = true;
counter--;
res << *begin_iter << ", ";
}
string str = res.str();
if (done_something) {
str.pop_back();
str.pop_back();
}
str += "]";
return str;
}
vector<int> SortIndex(int size, std::function<bool(int, int)> compare) {
vector<int> ord(size);
for (int i = 0; i < size; i++) ord[i] = i;
sort(ord.begin(), ord.end(), compare);
return ord;
}
template <typename T>
bool MinPlace(T& a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool MaxPlace(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename Container>
int SZ(const Container& S) {
return S.size();
}
template <typename S, typename T>
ostream& operator<<(ostream& out, const pair<S, T>& p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
out << "[";
for (int i = 0; i < (int)v.size(); i++) {
out << v[i];
if (i != (int)v.size() - 1) out << ", ";
}
out << "]";
return out;
}
const int MAXN = -1;
struct Point {
long long x, y;
Point() : x(0), y(0) {}
Point(long long x, long long y) : x(x), y(y) {}
Point operator+(const Point& other) const {
return {x + other.x, y + other.y};
};
Point operator-(const Point& other) const {
return {x - other.x, y - other.y};
};
Point operator*(long long lambda) const { return {x * lambda, y * lambda}; };
long long operator*(const Point& other) const {
return x * other.x + y * other.y;
}
bool operator<(const Point& other) const { return x * other.y > y * other.x; }
};
Point Rotate90(const Point& P) { return {-P.y, P.x}; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
Point O;
vector<Point> P(N);
for (int i = 0; i < N; i++) {
cin >> P[i].x >> P[i].y;
O = O + P[i];
}
vector<bool> removed(N, false);
for (int i = 0; i < N; i++) {
if (removed[i]) continue;
for (int j = 0; j < N; j++) {
if (removed[j]) continue;
Point Q = ((P[i] + P[j]) * N) - (O * 2);
if (Q.x == 0 and Q.y == 0) {
removed[i] = true;
removed[j] = true;
break;
}
}
}
vector<int> not_removed;
for (int i = 0; i < N; i++) {
if (!removed[i]) not_removed.push_back(i);
}
if (not_removed.empty()) {
cout << "-1"
<< "\n";
return 0;
}
set<Point> good_lines;
int M = not_removed.size();
for (int index : not_removed) {
Point A = P[not_removed[0]];
Point B = P[index];
Point Q = ((A + B) * N) - (O * 2);
Q = Rotate90(Q);
if (Q.y < 0 || (Q.y == 0 and Q.x < 0)) Q = Q * (-1);
good_lines.insert(Q);
}
int res = 0;
for (const Point& line : good_lines) {
vector<long long> scal(M);
for (int i = 0; i < M; i++) scal[i] = P[not_removed[i]] * line;
sort(scal.begin(), scal.end());
long long center = scal.back() + scal[0];
bool works = true;
for (int i = 0; i <= M - 1 - i; i++) {
if (scal[i] + scal[M - 1 - i] != center) {
works = false;
break;
}
}
if (works) res++;
}
cout << res << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1 << 8;
long long dep[maxn], vis[maxn], c1[maxn], c2[maxn], c3[maxn], c[maxn], s[maxn],
up[maxn];
long long h;
void Try(long long x, long long from) {
if (vis[x]) return;
cout << "? " << x << endl;
fflush(stdout);
cin >> s[x];
vis[x] = 1;
c[x] = from;
cin >> c1[x];
if (s[x] > 1) cin >> c2[x];
if (s[x] > 2) cin >> c3[x];
}
long long next(long long x, long long from) {
Try(x, from);
if (c1[x] != c[x])
return c1[x];
else if (c2[x] != c[x])
return c2[x];
else
return c3[x];
}
long long next2(long long x, long long from) {
Try(x, from);
if (c3[x] != c[x])
return c3[x];
else if (c2[x] != c[x])
return c2[x];
else
return c1[x];
}
long long solve(long long x) {
if (s[x] == 2) return x;
if (!dep[x]) {
long long u1 = x, u2 = x, u3 = x;
long long n1 = c1[x], n2 = c2[x], n3 = c3[x];
dep[x] = h;
while (s[u1] != 1 && s[u2] != 1 && s[u3] != 1) {
long long l1 = u1, l2 = u2, l3 = u3;
u1 = n1, u2 = n2, u3 = n3;
n1 = next(u1, l1), n2 = next(u2, l2), n3 = next(u3, l3);
if (s[u1] == 2) return u1;
if (s[u2] == 2) return u2;
if (s[u3] == 2) return u3;
dep[x]--;
}
if (s[x] == 1)
up[x] = c1[x], Try(up[x], x);
else {
if (s[u1] != 1)
up[x] = c1[x];
else if (s[u2] != 1)
up[x] = c2[x];
else
up[x] = c3[x];
}
dep[up[x]] = dep[x] - 1;
return solve(up[x]);
}
if (dep[x] == 2) {
long long u = next(x, c[x]);
long long v = next2(x, c[x]);
Try(u, x);
if (s[u] == 2)
return u;
else
return v;
} else if (dep[x] == 3) {
long long u = next(x, c[x]);
Try(u, x);
long long v = next2(x, c[x]);
Try(v, x);
long long u1 = next(u, c[u]), u2 = next2(u, c[u]);
long long v1 = next(v, c[v]), v2 = next2(v, c[v]);
Try(u1, u), Try(u2, u), Try(v1, v);
if (s[u1] == 2)
return u1;
else if (s[u2] == 2)
return u2;
else if (s[v1] == 2)
return v1;
else
return v2;
} else {
long long u = x, lu = c[x], nu;
for (long long i = 1; i <= h - dep[x]; i++) {
nu = next(u, lu);
if (s[u] == 2) return u;
lu = u, u = nu;
}
Try(u, lu);
if (s[u] == 2)
return u;
else {
long long nx;
if (s[u] == 3)
nx = next(x, c[x]);
else
nx = next2(x, c[x]);
Try(nx, x);
dep[nx] = dep[x] - 1;
return solve(nx);
}
}
}
int main() {
long long T;
cin >> T;
while (T--) {
memset(dep, 0, sizeof(dep));
memset(vis, 0, sizeof(vis));
memset(c, 0, sizeof(c));
memset(c1, 0, sizeof(c1));
memset(c2, 0, sizeof(c2));
memset(c3, 0, sizeof(c3));
memset(s, 0, sizeof(s));
memset(up, 0, sizeof(up));
cin >> h;
if (h <= 4) {
for (long long i = 1; i <= (1 << h) - 1; i++) {
cout << "? " << i << endl;
fflush(stdout);
long long n;
cin >> n;
long long x;
for (long long j = 1; j <= n; j++) {
cin >> x;
}
if (n == 2) {
cout << "! " << i << endl;
break;
}
}
} else {
long long from = 1;
Try(from, 0);
cout << "!"
<< " " << solve(from) << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, mx[((int)1e5 + 5)], chi;
string s;
char ch;
int main() {
cin >> s;
n = s.size();
s = '0' + s;
for (int i = n; i >= 1; i--) {
if (s[i] >= ch) {
ch = s[i];
chi = i;
}
mx[i] = chi;
}
int i = 1;
while (i != n + 1) {
cout << s[mx[i]];
i = mx[i] + 1;
}
cout << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int n, p[300007], a[300007];
vector<pair<long long int, long long int>> v;
void s(long long int x, long long int y) {
swap(a[x], a[y]);
swap(p[a[x]], p[a[y]]);
v.push_back({x, y});
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long int i = 1; i <= n; ++i) {
cin >> a[i];
p[a[i]] = i;
}
for (long long int i = 1; i <= n; ++i) {
if (p[i] == i) continue;
if (abs(p[i] - i) * 2 >= n) {
s(p[i], i);
} else if (i - 1 >= n / 2) {
s(i, 1);
s(1, p[i]);
s(i, 1);
} else if (n / 2 <= n - p[i]) {
s(i, n);
s(p[i], n);
s(n, i);
} else {
s(i, n);
s(1, n);
s(p[i], 1);
s(1, n);
s(i, n);
}
}
cout << (long long int)v.size() << '\n';
for (long long int i = 0; i < (long long int)v.size(); ++i)
cout << v[i].first << ' ' << v[i].second << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> vv[201];
int computer[201], in[201], bk[201], temp[201];
int bfs(int st) {
queue<int> q;
int ans = n;
for (int i = 1; i <= n; i++) {
if (in[i] == 0) q.push(i);
}
while (!q.empty()) {
memset(bk, 0, sizeof(bk));
while (!q.empty()) {
int head = q.front();
q.pop();
if (bk[head] == 5) {
q.push(head);
break;
}
bk[head]++;
if (computer[head] != st) {
q.push(head);
continue;
}
for (int i = 0; i < vv[head].size(); i++) {
int v = vv[head][i];
in[v]--;
if (in[v] == 0) q.push(v);
}
}
st = (st == 3 ? 1 : st + 1);
if (!q.empty()) ans++;
}
return ans;
}
int main() {
while (cin >> n) {
memset(in, 0, sizeof(in));
for (int i = 1; i <= n; i++) vv[i].clear();
for (int i = 1; i <= n; i++) cin >> computer[i];
for (int i = 1; i <= n; i++) {
int ki;
cin >> ki;
for (int j = 1; j <= ki; j++) {
int aj;
cin >> aj;
vv[aj].push_back(i);
in[i]++;
}
}
int ans = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) temp[i] = in[i];
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= n; j++) in[j] = temp[j];
ans = min(ans, bfs(i));
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> a, dp;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
--a[i];
}
dp.assign(n, 0);
for (int i = 0; i < n; ++i) {
if (a[i] > 0)
dp[a[i]] = max(dp[a[i]], 1 + dp[a[i] - 1]);
else
dp[0] = 1;
}
int ma = 0;
for (int i = 0; i < n; ++i) ma = max(ma, dp[i]);
cout << n - ma << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 2e5 + 10;
int n;
int a[kN];
int id[kN];
set<int> s;
int le[30][kN], ri[30][kN];
int L[kN], R[kN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int j = 0; j < 30; j++) {
int cur = 0;
for (int i = 1; i <= n; i++) {
le[j][i] = cur;
if (a[i] & (1 << j)) cur = i;
}
cur = n + 1;
for (int i = n; i >= 1; i--) {
ri[j][i] = cur;
if (a[i] & (1 << j)) cur = i;
}
}
for (int i = 1; i <= n; i++) {
vector<int> v;
for (int j = 0; j < 30; j++)
if (!(a[i] & (1 << j))) v.push_back(j);
L[i] = 0;
for (int j : v) L[i] = max(L[i], le[j][i]);
}
for (int i = 1; i <= n; i++) {
vector<int> v;
for (int j = 0; j < 30; j++)
if (!(a[i] & (1 << j))) v.push_back(j);
R[i] = n + 1;
for (int j : v) R[i] = min(R[i], ri[j][i]);
}
for (int i = 1; i <= n; i++) id[i] = i;
sort(id + 1, id + n + 1,
[&](int i, int j) { return a[i] != a[j] ? a[i] > a[j] : i < j; });
s.insert(0);
s.insert(n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
int ii = id[i];
auto it = s.lower_bound(ii);
int l = max(L[ii], *prev(it));
int r = min(R[ii], *it);
ans += 1LL * (ii - l) * (r - ii);
s.insert(ii);
}
ans = 1LL * n * (n + 1) / 2 - ans;
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
int n;
long long t[100100], x[100100];
long long cp[100100], tt[100100];
bool isbet(long long a, long long x, long long y) {
if (a >= x && a <= y) return true;
if (a >= y && a <= x) return true;
return false;
}
int main() {
int oo;
cin >> oo;
for (int o = 0; o < oo; ++o) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%I64d%I64d", &t[i], &x[i]);
}
cp[0] = 0LL;
tt[0] = 0LL;
t[n] = 1000000000000000LL;
int res = 0;
int l = 0;
for (int i = 0; i < n; ++i) {
if (tt[l] <= t[i]) {
++l;
tt[l] = t[i] + abs(cp[l - 1] - x[i]);
tt[l - 1] = t[i];
cp[l] = x[i];
if (tt[l] <= t[i + 1])++res;
}
else {
if (isbet(x[i], cp[l], cp[l - 1])) {
//cout << x[i] << " " << cp[l] << " " << cp[l - 1] << " ";
long long h = x[i] - cp[l - 1];
long long temp = tt[l - 1] + abs(h);
if (temp >= t[i] && temp <= t[i + 1]) ++res;
}
}
}
printf("%d\n", res);
}
} | 3 |
#include "bits/stdc++.h"
using namespace std;
void solve()
{
long H, W, N;
cin >> H >> W >> N;
map<long, int> cnt;
while(N--)
{
long h, w;
cin >> h >> w;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
{
long y = h - i - 1, x = w - j - 1;
if (0 <= x && x + 2 < W && 0 <= y && y + 2 < H)
{
cnt[y*W+x]++;
}
}
}
vector<long> ans(10);
for (auto p : cnt)
{
ans[p.second]++;
}
ans[0] = (H-2)*(W-2);
for (int i = 1; i < 10; i++) ans[0] -= ans[i];
for (long a : ans)
{
cout << a << endl;
}
}
int main(void)
{
solve();
//cout << "yui(*-vใป)yui" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
map<string, int> mp;
int n;
void FileInit() {
{
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
};
}
void FileDebug() {
{
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
freopen(
""
".err",
"w", stderr);
};
}
void FileClose() {
fclose(stdin);
fclose(stdout);
}
int main() {
cin >> n >> s;
for (int i = 0; i < n - 1; ++i) {
string t;
t += s[i];
t += s[i + 1];
mp[t]++;
}
int res1 = -2345678;
string RES;
for (auto x : mp) {
if (res1 < x.second) res1 = x.second, RES = x.first;
}
cout << RES;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3fffffff;
const int maxn = 100000 + 10;
int n;
int color[maxn];
struct edge {
int next, to;
} e[2 * maxn];
int head[maxn];
int cnt;
void insert(int x, int y) {
e[++cnt].to = y, e[cnt].next = head[x], head[x] = cnt;
e[++cnt].to = x, e[cnt].next = head[y], head[y] = cnt;
}
int fa[maxn];
vector<int> v[maxn];
vector<int> v2[maxn];
int same_color[maxn];
int same_color2[maxn];
int same2[maxn];
int same3[maxn];
int dfs(int x) {
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa[x]) {
fa[e[i].to] = x;
v[x].push_back(dfs(e[i].to));
v2[x].push_back(e[i].to);
}
int tot = 0, pos = -1;
for (int i = 0; i < v[x].size(); i++)
if (v[x][i] == v[x][0])
tot++;
else
pos = i;
if (v[x].size() >= 2 && v[x][0] != -1 && tot == v[x].size() - 1) {
if (color[x] == v[x][0]) same_color2[v2[x][pos]] = color[x];
}
tot = 0, pos = -1;
if (v[x].size() >= 2) {
for (int i = 0; i < v[x].size(); i++)
if (v[x][i] == v[x][1])
tot++;
else
pos = i;
if (v[x][1] != -1 && tot == v[x].size() - 1) {
if (color[x] == v[x][1]) same_color2[v2[x][pos]] = color[x];
}
}
if (v[x].size() == 1) same_color2[v2[x][0]] = color[x];
for (int i = 0; i < v[x].size(); i++)
if (v[x][i] == -1) return -1;
same2[x] = 1;
for (int i = 1; i < v[x].size(); i++)
if (v[x][i] != v[x][i - 1]) return -1;
if (!v[x].size())
return same_color[x] = color[x];
else if (color[x] == v[x][0])
return same_color[x] = color[x];
else
return -1;
}
void dfs2(int x) {
if (color[x] == same3[fa[x]]) same3[x] = color[x];
if (x == 1) same3[x] = color[x];
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa[x]) {
dfs2(e[i].to);
}
}
int same4[maxn];
void dfs3(int x) {
if (same4[fa[x]] && same_color2[x] && color[fa[x]] == color[fa[fa[x]]])
same4[x] = 1;
if (x == 1 || fa[x] == 1 && same_color2[x]) same4[x] = 1;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa[x]) {
dfs3(e[i].to);
}
}
void solve() {
for (int i = 1; i <= n; i++) {
if (same2[i] && same4[i]) {
printf("YES\n%d\n", i);
return;
}
}
printf("NO\n");
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int x = 0, y = 0;
scanf("%d%d", &x, &y);
insert(x, y);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &color[i]);
}
dfs(1);
dfs2(1);
dfs3(1);
solve();
return 0;
}
| 1 |
#include <iostream>
#include <stdio.h>
using namespace std;
int main() {
char w[9][9],e[5]="URDL";
int x=0,y=0,h=1,i,g;
int dx[4]={0,1,0,-1},dy[4]={-1,0,1,0};
for (i=0;i<9;i++) gets(w[i]);
while(true) {
h=(h+3) % 4;
for (i=0;i<4;i++) {
if (y+dy[h]>=0 && y+dy[h]<=4 && x+dx[h]>=0 && x+dx[h]<=4) {
if (dx[h]==-1) g=-1; else g=0;
if (w[2*y+dy[h]][x+g]=='1') break;
}
h=(h+1) % 4;
}
x+=dx[h]; y+=dy[h];
cout << e[h];
if (x==0 && y==0) break;
}
cout << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e7 + 5;
const long double PI = 3.14159265358979323846;
const long double EPS = 1e-10;
const int MOD = 12345;
const int MOD2 = 23456;
const int N = 3000 + 10;
const int M = 1e5 + 10;
using namespace std;
vector<int> z;
int n;
int main() {
cin >> n;
z.push_back(-INF);
for (int i = 0, x; i < n; i++) {
cin >> x;
if (!x) z.push_back(i);
}
z.push_back(INF);
int curz = 0;
for (int i = 0; i < n; ++i) {
cout << min(i - z[curz], z[curz + 1] - i) << " ";
if (i >= z[curz + 1]) curz++;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, rs;
string s;
deque<pair<long long, long long>> q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
cin >> s;
q.push_back({0, 0});
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
long long x = q.back().first;
long long y = q.back().second;
if (s[i] == 'U')
y++;
else
x++;
q.push_back({x, y});
if (q.size() == 3) {
long long x1 = q.front().first;
long long y1 = q.front().second;
long long x2 = q.back().first;
long long y2 = q.back().second;
if ((x1 - y1) * (x2 - y2) < 0) rs++;
q.pop_front();
}
}
cout << rs;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, d, i;
int ans = 0;
int a[2005];
scanf("%d%d", &n, &d);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
ans += (1 + (a[i - 1] - a[i]) / d);
a[i] += (1 + (a[i - 1] - a[i]) / d) * d;
}
if (a[i] == a[i - 1]) {
++ans;
a[i] += d;
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int MAXBOX = 100010;
const int BLEN = 400;
int d[MAXN];
long long h[2 * MAXN], ps[2 * MAXN];
long long mxDec[MAXBOX], mxAdd[MAXBOX], inside[MAXBOX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> d[i];
for (int i = 0; i < n; i++) cin >> h[i];
for (int i = n; i < 2 * n; i++) h[i] = h[i - n];
for (int i = 0; i < 2 * n; i++) ps[i + 1] = ps[i] + d[i % n];
int mxBox = (2 * n - 1) / BLEN;
for (int i = 0; i <= mxBox; i++) {
int l = i * BLEN;
int r = min(2 * n - 1, (i + 1) * BLEN);
mxDec[i] = 2 * h[l] - ps[l];
mxAdd[i] = 2 * h[l] + ps[l];
for (int j = l + 1; j < r; j++) {
inside[i] = max(inside[i], mxDec[i] + 2 * h[j] + ps[j]);
mxDec[i] = max(mxDec[i], 2 * h[j] - ps[j]);
mxAdd[i] = max(mxAdd[i], 2 * h[j] + ps[j]);
}
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
a--, b++;
swap(a, b);
if (a > b) b += n;
int boxa = a / BLEN;
int boxb = b / BLEN;
long long ans = 0;
if (boxa == boxb) {
long long mxd = 2 * h[a] - ps[a];
for (int j = a + 1; j <= b; j++) {
ans = max(ans, mxd + 2 * h[j] + ps[j]);
mxd = max(mxd, 2 * h[j] - ps[j]);
}
} else {
long long mxd = 2 * h[a] - ps[a];
for (int j = a + 1; j / BLEN == boxa; j++) {
ans = max(ans, mxd + 2 * h[j] + ps[j]);
mxd = max(mxd, 2 * h[j] - ps[j]);
}
for (int j = boxa + 1; j < boxb; j++) {
ans = max(ans, inside[j]);
ans = max(ans, mxAdd[j] + mxd);
mxd = max(mxd, mxDec[j]);
}
for (int j = b - (b % BLEN); j <= b; j++) {
ans = max(ans, mxd + 2 * h[j] + ps[j]);
mxd = max(mxd, 2 * h[j] - ps[j]);
}
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int t[300001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int b = n;
cout << "1 ";
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
t[a] = 1;
while (t[b]) b--;
cout << i - (n - b) + 1 << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
const int MN = 5000;
const int ML = MN/2;
ll dp[2][MN][MN];
ll tp[MN];
ll bd[2][MN];
ll M;
int main() {
ll n;
cin >> n >> M;
memset(dp,0,sizeof(dp));
int cu = 0;
for(int i=0;i<n;i++) {
ll x = i;
ll y = n-i-1;
bd[cu][y] = max(bd[cu][y],x);
dp[cu][x][y] += 1;
}
int num = (n-1)/2;
ll res = 0;
bool extra = !(n&1);
for(int iter=0;iter<num;iter++) {
//cout << "iteration " << iter << '\n';
int nu = 1-cu;
ll C = 0;
memset(bd[nu],0,sizeof(bd[nu]));
for(int i=0;i<n;i++) {
ll lim = bd[cu][i];
tp[lim] = dp[cu][lim][i];
for(int j=lim-1;j>=0;j--) {
tp[j] = tp[j+1]+dp[cu][j][i];
if(tp[j] >= M) {tp[j] -= M;}
}
for(int j=lim;j>=0;j--) {
if(j > 0) {
tp[j-1] += tp[j];
if(tp[j-1] >= M) {tp[j-1] -= M;}
}
C++;
ll vy = i-j;
if(vy < 0) {continue;}
int u = j,v = vy;
//cout << "IJ " << i << " " << j << '\n';
//cout << "wat " << u << " " << v << " " << tp[j] << '\n';
dp[nu][u][v] = tp[j];
bd[nu][v] = max(bd[nu][v],ll(u));
}
}
//cout << "use count " << C << '\n';
cu = nu;
}
for(int i=0;i<n;i++) {
for(int j=0;j<=bd[cu][i];j++) {
if(extra) {
res += ll(j+1)*dp[cu][j][i];
} else {
res += dp[cu][j][i];
}
}
}
res %= M;
cout << res << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long f[2000010];
long long inv[2000010];
long long invf[2000010];
inline int comb(int n, int k) {
if (k < 0 || k > n) return 0;
return f[n] * invf[k] % mod * invf[n - k] % mod;
}
long long dp[2000010];
int a[10];
int easy(int n, int k) {
for (int i = 1; i <= n; i++) a[i - 1] = i;
int res = 0;
do {
int ans = 0, of = 0;
for (int i = 0; i < n; i++) {
if (ans < a[i]) {
ans = a[i];
of = 0;
} else {
of++;
if (of == k) {
break;
}
}
}
res += ans < n;
} while (next_permutation(a, a + n));
return res;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
f[0] = f[1] = 1;
inv[0] = inv[1] = 1;
invf[0] = invf[1] = 1;
for (int i = 2; i <= n; i++) {
f[i] = f[i - 1] * i % mod;
inv[i] = mod - mod / i * inv[mod % i] % mod;
invf[i] = invf[i - 1] * inv[i] % mod;
}
dp[0] = 1;
int ans = 0, pr = 0;
long long dec = 0;
for (int i = 0; i < n; i++) {
dp[i] = f[i];
if (i >= k + 1) {
dec += dp[i - k - 1] * invf[i - k - 1] % mod * inv[i] % mod;
if (dec >= mod) dec -= mod;
dp[i] -= dec * f[i] % mod;
if (dp[i] < 0) dp[i] += mod;
}
ans += dp[i] * f[n - 1 - i] % mod * comb(n - 1, i) % mod;
if (ans >= mod) ans -= mod;
}
ans = f[n] - ans;
if (ans < 0) ans += mod;
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p[300];
int main() {
int i, k, j, l;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 0; i < 2 * n; i++) {
cin >> p[i];
}
n *= 2;
int result = 200000000;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
vector<int> V;
for (k = 0; k < n; k++) {
if (k != i && k != j) {
V.push_back(p[k]);
}
}
sort(V.begin(), V.end());
int sum = 0;
for (l = 0; l < V.size(); l = l + 2) {
sum += (V[l + 1] - V[l]);
}
result = min(result, sum);
}
}
cout << result << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<pair<int, int>> v(n);
vector<tuple<int, int, int>> line;
for (int i = 0; i < n; i++) {
auto& [l, r] = v[i];
cin >> l >> r;
line.push_back({l, 0, i});
line.push_back({r, 1, i});
}
int open = 0;
vector<pair<int, int>> sats;
sort(line.begin(), line.end());
int start = -1;
for (auto& [pos, type, id] : line) {
if (type == 0) {
if (open == k - 1) start = pos;
open++;
} else {
if (open == k) sats.push_back({start, pos});
open--;
}
}
cout << sats.size() << '\n';
for (auto& [l, r] : sats) cout << l << ' ' << r << '\n';
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
int32_t main()
{
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
vector <pair<int,int>> arr(n);
for(int i = 0; i < n; i++)
{
cin>>arr[i].first;
arr[i].second = i;
}
sort(arr.begin(),arr.end());
vector <int> prefix_sum(n);
prefix_sum[0] = arr[0].first;
for(int i = 1; i < n; i++)
{
prefix_sum[i] = prefix_sum[i-1] + arr[i].first;
}
vector <bool> ans(n,false);
ans[arr[n-1].second] = true;
for(int i = n-2; i >= 0; i--)
{
if(prefix_sum[i] >= arr[i+1].first)
{
ans[arr[i].second] = ans[arr[i+1].second];
}
}
int cnt = 0;
vector <int> v;
for(int i = 0; i < n; i++)
{
if(ans[i])
{
cnt++;
v.push_back(i+1);
}
}
cout<<cnt<<endl;
for(int i : v)
{
cout<<i<<" ";
}
cout<<endl;
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double pi = acos(-1);
const long long int INF = 1e18;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int nax = 1000000 + 10;
int n, arr[nax], fail[nax];
int main() {
ios::sync_with_stdio(0);
int n, cnt;
cin >> n >> cnt;
string s;
cin >> s;
int len = s.length();
s = "#" + s;
int j = 0;
fail[1] = 0;
for (int i = 2; i <= len; i++) {
while (j && s[j + 1] != s[i]) j = fail[j];
if (s[j + 1] == s[i]) j++;
fail[i] = j;
}
vector<pair<int, int> > v;
while (cnt--) {
int l;
cin >> l;
int r = l + len - 1;
v.push_back({l, r});
}
v.push_back({0, 0});
v.push_back({n + 1, n + 1});
sort(v.begin(), v.end());
int sz = v.size();
long long int ans = 0, flag = 0;
int lastprefix = fail[len];
for (int i = 1; i < sz; i++) {
int l2 = v[i].first;
int r1 = v[i - 1].second;
if (l2 > r1) {
ans += (l2 - r1 - 1);
} else {
int lastlen = (r1 - l2 + 1);
bool f = 0;
int lastle = len;
while (lastle) {
if (lastle == lastlen) {
f = 1;
break;
}
lastle = fail[lastle];
}
if (f == 0) flag = 1;
}
}
if (flag == 1)
cout << 0;
else {
long long int ans1 = 1;
for (int i = 1; i <= ans; i++) {
ans1 = (ans1 % MOD * 26LL) % MOD;
}
cout << ans1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int m, n;
scanf("%d", &m);
;
scanf("%d", &n);
;
double x = m, y = m, z, temp = 0, sum = 0, ans = 0;
x = 1 / x;
y = 1 / y;
for (int i = 1; i <= m; i++) {
z = i;
temp = pow(x, n);
temp -= sum;
sum += temp;
ans = ans + z * temp;
x += y;
}
printf("%.6lf\n", ans);
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
long long x, y;
cin >> x >> y;
if (!y && x != 1) {
cout << "No solution" << endl;
return 0;
}
cout << y;
for (int i = 0; i < x - 1; i++) {
cout << 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
multimap<int, int> m;
int zo = 1e5;
int flag = -1;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
m.insert({a, i + 1});
}
map<int, vector<int>> b;
int i = 1;
for (; i <= k; i++) {
if ((--m.end())->first - m.begin()->first == zo) {
if (flag == -1) flag = i;
} else
flag = -1;
if ((--m.end())->first - m.begin()->first != 0) {
zo = (--m.end())->first - m.begin()->first;
int x, y, z, p;
x = (--m.end())->first;
y = (--m.end())->second;
b[i].push_back(y);
z = (m.begin())->first;
p = (m.begin())->second;
b[i].push_back(p);
m.erase(m.begin());
m.erase(--m.end());
m.insert({x - 1, y});
m.insert({z + 1, p});
} else {
i--;
break;
}
}
if (i > k) i--;
cout << (--m.end())->first - m.begin()->first << " " << i << endl;
for (auto it = b.begin(); it != b.end(); it++) {
cout << it->second[0] << " " << it->second[1] << endl;
}
}
| 2 |
#include <bits/stdc++.h>
#include <cmath>
using namespace std;
int main() {
string S;
cin>>S;
cout<<S[0]<<S[1]<<S[2];
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.