solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
bool op(pair<int, int> &x, pair<int, int> &y) {
return (x.first - x.second > y.first - y.second);
}
int main() {
int n;
long long cnt = 0;
pair<int, int> p[100005];
cin >> n;
n--;
for (int i = 0; i <= n; i++) cin >> p[i].first >> p[i].second;
sort(p, p + n + 1, op);
for (int i = 0; i <= n; i++)
cnt += 1LL * i * p[i].first + 1LL * (n - i) * p[i].second;
cout << cnt << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long int n, m, i, var, tot, t, v, x, y, q;
vector<long long int> vec;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> var;
vec.push_back(var);
}
tot = 0;
for (i = 0; i < m; i++) {
cin >> t;
if (t == 1) {
cin >> v >> x;
vec[v - 1] = x - tot;
} else if (t == 2) {
cin >> y;
tot += y;
} else if (t == 3) {
cin >> q;
cout << vec[q - 1] + tot << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
int cnt;
vector<int> grf1[300005], grf2[300005];
vector<pair<int, int> > non;
int vis[300005];
void dfs1(int node) {
if (vis[node]) return;
cnt++;
vis[node] = cnt;
for (int i = 0; i < grf1[node].size(); i++) {
int now = grf1[node][i];
dfs1(now);
}
}
void dfs2(int node) {
if (vis[node]) return;
cnt++;
vis[node] = 1;
for (int i = 0; i < grf2[node].size(); i++) {
int now = grf2[node][i];
dfs2(now);
}
}
int main() {
cin >> n >> m >> s;
for (int i = 0; i < m; i++) {
int t, u, v;
scanf("%d %d %d", &t, &u, &v);
if (t == 1) {
grf2[u].push_back(v);
grf1[u].push_back(v);
} else {
grf1[u].push_back(v);
grf1[v].push_back(u);
non.push_back(make_pair(u, v));
}
}
cnt = 0;
dfs1(s);
cout << cnt << endl;
string ans = "";
for (int i = 0; i < non.size(); i++) {
if (vis[non[i].first] < vis[non[i].second])
ans += '+';
else
ans += '-';
}
cout << ans << endl;
memset(vis, 0, sizeof(vis));
cnt = 0;
dfs2(s);
cout << cnt << endl;
ans = "";
for (int i = 0; i < non.size(); i++) {
if (vis[non[i].first] < vis[non[i].second])
ans += '+';
else
ans += '-';
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void FAST();
long long int big_mod(long long int val, long long int pow, long long int mod);
long long int mod_inverse(long long int val, long long int mod);
int main() {
FAST();
int m, n;
scanf("%d %d", &n, &m);
if (m < 2) {
printf("1");
} else {
if (n & 1 == 0) {
if (m >= n / 2) {
printf("%d", n - m);
} else {
printf("%d", m);
}
} else {
if (m > n / 2) {
printf("%d", n - m);
} else {
printf("%d", m);
}
}
}
return 0;
}
void FAST() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
long long int big_mod(long long int val, long long int pow, long long int mod) {
long long int res = 1;
val = val % mod;
while (pow > 0) {
if (pow & 1) {
res = (res * val) % mod;
}
pow = pow >> 1;
val = (val * val) % mod;
}
return res;
}
long long int mod_inverse(long long int val, long long int mod) {
long long int mod1 = mod;
if (mod == 1) {
return 0;
}
long long int y = 0;
long long int x = 1;
long long int quotient, temp;
while (val > 1) {
quotient = val / mod;
temp = mod;
mod = val % mod;
val = temp;
temp = y;
y = x - quotient * y;
x = temp;
}
if (x < 0) {
x += mod1;
}
return x;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long maxn[4];
long long minn[4];
long long maxans;
int main() {
int t;
cin >> t;
while (t--) {
memset(maxn, 0, sizeof(maxn));
memset(minn, 0x7f, sizeof(minn));
maxans = -1;
int w, h;
cin >> w >> h;
for (int i = 0; i < 4; i++) {
int n;
cin >> n;
for (int j = 0; j < n; j++) {
long long x;
cin >> x;
maxn[i] = max(maxn[i], x);
minn[i] = min(minn[i], x);
}
}
for (int i = 0; i < 4; i++) {
if (i == 0 || i == 1) {
maxans = max(maxans, (maxn[i] - minn[i]) * h);
} else {
maxans = max(maxans, (maxn[i] - minn[i]) * w);
}
}
cout << maxans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INFF = 1e18 + 5;
const long long INF = 1e10 + 5;
const long long MX = 1e6 + 5;
const long long MXL = 105;
const long long mod = 1e9 + 7;
const double ERROR = 1e-8;
const long double pi = 3.14159265358979323846;
const long long set_inf = 0x3f3f3f3f;
long long a, b, c;
string s;
void solve() {
cin >> s;
a = 0, b = 0, c = 0;
for (auto i : s) {
if (i == 'A') a++;
if (i == 'B') b++;
if (i == 'C') c++;
}
if (b == a + c)
cout << "YES\n";
else
cout << "NO\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long tc;
cin >> tc;
while (tc--) solve();
exit(0);
;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(1e8);
const int N_MAX = 100000;
const int M_MAX = N_MAX;
int n, m, d;
int p[M_MAX];
int a[N_MAX - 1];
int b[N_MAX - 1];
vector<int> g[N_MAX + 1];
set<int> q;
int dp[N_MAX + 1];
bool used[N_MAX + 1];
int dfs(int x) {
dp[x] = -INF;
used[x] = true;
for (int i = 0; i < (g[x].size()); ++i)
if (!used[g[x][i]]) dp[x] = max(dp[x], dfs(g[x][i]) + 1);
if (q.find(x) != q.end()) dp[x] = max(dp[x], 0);
return dp[x];
}
int dfs2(int x, int y) {
if (q.find(x) != q.end()) y = max(y, 0);
used[x] = true;
if (y > d) return 0;
int h = -INF;
int j = 0;
int h2 = -INF;
for (int i = 0; i < (g[x].size()); ++i)
if (!used[g[x][i]]) {
if (dp[g[x][i]] + 1 >= h) {
h2 = h;
h = dp[g[x][i]] + 1;
j = i;
} else if (dp[g[x][i]] + 1 > h2)
h2 = dp[g[x][i]] + 1;
}
int res = 0;
if (h <= d) res = 1;
for (int i = 0; i < (g[x].size()); ++i)
if (!used[g[x][i]]) {
if (i == j)
res += dfs2(g[x][i], max(y + 1, h2 + 1));
else
res += dfs2(g[x][i], max(y + 1, h + 1));
}
return res;
}
void solve() {
if (d == 0) {
if (m == 1)
cout << 1 << endl;
else
cout << 0 << endl;
return;
}
for (int i = 0; i < (n - 1); ++i) {
g[a[i]].push_back(b[i]);
g[b[i]].push_back(a[i]);
}
for (int i = 0; i < (m); ++i) q.insert(p[i]);
dfs(1);
memset(used, 0, sizeof(used));
int ans = dfs2(1, -INF);
cout << ans << endl;
}
int main() {
cin >> n >> m >> d;
for (int i = 0; i < (m); ++i) cin >> p[i];
for (int i = 0; i < (n - 1); ++i) cin >> a[i] >> b[i];
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int Case = 1;
int n, m, k;
char dump[2];
while (cin >> n >> m) {
int ans = 1;
int last, cur;
cin >> last;
for (int i = 1; i < n; i++) {
cin >> cur;
if (cur - last <= m) {
ans++;
} else {
ans = 1;
}
last = cur;
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define MP make_pair
#define PB push_back
#define int long long
#define st first
#define nd second
#define rd third
#define FOR(i, a, b) for(int i =(a); i <=(b); ++i)
#define RE(i, n) FOR(i, 1, n)
#define FORD(i, a, b) for(int i = (a); i >= (b); --i)
#define REP(i, n) for(int i = 0;i <(n); ++i)
#define VAR(v, i) __typeof(i) v=(i)
#define FORE(i, c) for(VAR(i, (c).begin()); i != (c).end(); ++i)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define __builtin_ctz __builtin_ctzll
#define __builtin_clz __builtin_clzll
#define __builtin_popcount __builtin_popcountll
using namespace std;
template<typename TH> void _dbg(const char* sdbg, TH h) { cerr<<sdbg<<"="<<h<<"\n"; }
template<typename TH, typename... TA> void _dbg(const char* sdbg, TH h, TA... t) {
while(*sdbg != ',') { cerr<<*sdbg++; } cerr<<"="<<h<<","; _dbg(sdbg+1, t...);
}
#ifdef LOCAL
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#define debugv(x) {{cerr <<#x <<" = "; FORE(itt, (x)) cerr <<*itt <<", "; cerr <<"\n"; }}
#else
#define debug(...) (__VA_ARGS__)
#define debugv(x)
#define cerr if(0)cout
#endif
#define next ____next
#define prev ____prev
#define left ____left
#define hash ____hash
typedef long long ll;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VLL;
typedef vector<pair<int, int> > VPII;
typedef vector<pair<ll, ll> > VPLL;
template<class C> void mini(C&a4, C b4){a4=min(a4, b4); }
template<class C> void maxi(C&a4, C b4){a4=max(a4, b4); }
template<class T1, class T2>
ostream& operator<< (ostream &out, pair<T1, T2> pair) { return out << "(" << pair.first << ", " << pair.second << ")";}
template<class A, class B, class C> struct Triple { A first; B second; C third;
bool operator<(const Triple& t) const { if (st != t.st) return st < t.st; if (nd != t.nd) return nd < t.nd; return rd < t.rd; } };
template<class T> void ResizeVec(T&, vector<int>) {}
template<class T> void ResizeVec(vector<T>& vec, vector<int> sz) {
vec.resize(sz[0]); sz.erase(sz.begin()); if (sz.empty()) { return; }
for (T& v : vec) { ResizeVec(v, sz); }
}
typedef Triple<int, int, int> TIII;
template<class A, class B, class C>
ostream& operator<< (ostream &out, Triple<A, B, C> t) { return out << "(" << t.st << ", " << t.nd << ", " << t.rd << ")"; }
template<class T> ostream& operator<<(ostream& out, vector<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class T> ostream& operator<<(ostream& out, set<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class L, class R> ostream& operator<<(ostream& out, map<L, R> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
int Sq(int x) {
return x * x;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
cin.tie(0);
//double beg_clock = 1.0 * clock() / CLOCKS_PER_SEC;
int n;
cin>>n;
VPII pts;
RE (i, n) {
int x, y;
cin>>x>>y;
pts.PB({x, y});
}
function<int(PII, PII)> Dis = [&](PII A, PII B) {
return Sq(A.st - B.st) + Sq(A.nd - B.nd);
};
int wh = 0;
RE (i, n - 1) {
if (pts[i] < pts[wh]) {
wh = i;
}
}
VI dead(n);
dead[wh] = 1;
VI res{wh};
int prv = wh;
RE (turn, n - 1) {
int best_dis = 0;
int best_wh = 0;
REP (i, n) {
if (dead[i]) { continue; }
int sq = Dis(pts[prv], pts[i]);
if (sq > best_dis) {
best_dis = sq;
best_wh = i;
}
}
dead[best_wh] = 1;
prv = best_wh;
res.PB(best_wh);
}
for (auto x : res) {
cout<<x + 1<<" ";
}
cout<<"\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, t;
cin >> n >> t;
int dp[21][5][11][2];
memset(dp, 0, sizeof dp);
for (int i = 1; i <= 4; ++i) {
dp[1][i][1][1] = 1;
}
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= t; ++j) {
for (int now = 1; now <= 4; ++now) {
for (int pre = 1; pre <= 4; ++pre) {
if (now > pre) {
dp[i][now][j][1] += dp[i - 1][pre][j - 1][0] + dp[i - 1][pre][j][1];
}
if (pre > now) {
dp[i][now][j][0] += dp[i - 1][pre][j][0] + dp[i - 1][pre][j][1];
}
if (i == 2) {
dp[i][now][j][0] = 0;
}
}
}
}
}
int sum = 0;
for (int i = 1; i <= 4; ++i) {
sum += dp[n][i][t][0];
}
cout << sum << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2050;
int a[maxN][maxN];
int b[maxN][maxN];
int c[maxN][maxN];
int n;
void parasite() {
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
b[x][y] =
a[x][y] || a[x - 1][y] || a[x][y - 1] || a[x + 1][y] || a[x][y + 1];
memcpy(a, b, sizeof(b));
}
int main() {
bool readInput = true;
bool doCircle = false;
if (readInput)
scanf("%d", &n);
else
n = 70;
for (int y = 0; y < n; y++)
for (int x = 0; x < n; x++) {
if (readInput)
scanf("%d", &a[x + 1][y + 1]);
else {
if (doCircle)
a[x + 1][y + 1] = hypot(x - n / 2, y - n / 2) < n / 4;
else
a[x + 1][y + 1] = max(abs(x - n / 2), abs(y - (n / 2))) < n / 4;
}
}
if (!readInput) {
for (int y = 0; y < n; y++) {
for (int x = 0; x <= n; x++) printf("%c", a[x][y] ? '#' : '.');
printf("\n");
}
}
for (int i = 0; i < 4; i++) parasite();
int nRectangles = 0, nCircles = 0;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
if (!c[x][y] && a[x][y]) {
struct point {
int x, y;
point(int x, int y) : x(x), y(y) {}
point() : x(0), y(0) {}
};
deque<point> bfs;
bfs.push_back(point(x, y));
vector<point> border;
while (!bfs.empty()) {
point p = bfs.front();
bfs.pop_front();
if (p.x <= 0 || p.y <= 0 || p.x > n || p.y > n) continue;
if (c[p.x][p.y]) continue;
if (!a[p.x][p.y]) continue;
c[p.x][p.y] = 1;
if (!a[p.x + 1][p.y] || !a[p.x - 1][p.y] || !a[p.x][p.y - 1] ||
!a[p.x][p.y + 1])
border.push_back(p);
bfs.push_back(point(p.x + 1, p.y));
bfs.push_back(point(p.x - 1, p.y));
bfs.push_back(point(p.x, p.y + 1));
bfs.push_back(point(p.x, p.y - 1));
}
double cx = 0, cy = 0;
for (auto p : border) {
cx += p.x;
cy += p.y;
}
cx /= border.size();
cy /= border.size();
double dMin = 1e9, dMax = -1e9;
for (auto p : border) {
double d = hypot(p.x - cx, p.y - cy);
dMin = min(dMin, d);
dMax = max(dMax, d);
}
double ratio = dMax / dMin;
if (ratio > (sqrt(2) + 1) / 2)
nRectangles++;
else
nCircles++;
}
printf("%d %d\n", nCircles, nRectangles);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long q, k;
long long getsl(int x, int opt) {
long long sum = 0, add = 0, pw = 1, len = 0, cnt;
while (1) {
pw *= 10;
len++;
if (x > pw - 1) {
cnt = pw - pw / 10;
sum += add * cnt + cnt * (cnt + 1) / 2 * len;
add += cnt * len;
} else {
cnt = x - pw / 10 + 1;
sum += add * cnt + cnt * (cnt + 1) / 2 * len;
add += cnt * len;
break;
}
}
return opt ? sum : add;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> q;
while (q--) {
cin >> k;
int l = 0, r = 1e9, ans, mid;
while (l <= r) {
mid = l + r >> 1;
if (getsl(mid, 1) < k)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
k -= getsl(ans, 1);
l = 0, r = ans + 1;
while (l <= r) {
mid = (l + r) >> 1;
if (getsl(mid, 0) < k)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
k -= getsl(ans, 0);
ans += 1;
int t = ans, len = 0;
while (t) t /= 10, len++;
int rk = len - k + 1;
while (rk != 1) ans /= 10, rk--;
cout << ans % 10 << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
long long n, a[N], s, c, p[N], q[N], t;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
s = a[i], c = 1;
while (t && p[t] * c >= s * q[t]) s += p[t], c += q[t--];
p[++t] = s, q[t] = c;
}
for (int i = 1; i <= t; i++)
for (int j = 1; j <= q[i]; j++) printf("%.9lf\n", (double)p[i] / q[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 5;
int a[maxn], b[maxn];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int j = 0; j < m; ++j) {
cin >> b[j];
}
sort(a, a + n);
sort(b, b + m);
if (b[0] < a[n - 1]) {
cout << -1 << endl;
return 0;
}
long long ans = 0;
for (int i = 0; i < m; i++) {
ans += b[i];
}
for (int i = 0; i < n - 1; i++) {
ans += (long long)m * a[i];
}
if (a[n - 1] != b[0]) {
ans -= b[0];
ans += a[n - 1];
ans += b[0];
ans -= a[n - 2];
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MAX = 2048;
struct candy {
int h, m;
candy(int h, int m) : h(h), m(m) {}
bool operator<(const candy &c) const { return h < c.h; }
};
struct segtree {
int N, dat[2 * MAX], idx[2 * MAX];
segtree() {}
segtree(int n) {
N = 1;
while (N < n) N *= 2;
memset(dat, 0, sizeof(dat));
memset(idx, 0, sizeof(idx));
}
void update(int id, int a) {
int k = id + N - 1;
dat[k] = a;
idx[k] = id;
while (k > 0) {
k = (k - 1) / 2;
if (dat[k * 2 + 1] < dat[k * 2 + 2])
idx[k] = idx[k * 2 + 2];
else
idx[k] = idx[k * 2 + 1];
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
pair<int, int> query(int a, int b) { return query(a, b, 0, 0, N); }
pair<int, int> query(int a, int b, int k, int l, int r) {
if (r <= a or b <= l) return pair<int, int>(0, 0);
if (a <= l and r <= b) return pair<int, int>(dat[k], idx[k]);
int m = (l + r) / 2;
pair<int, int> lq = query(a, b, k * 2 + 1, l, m);
pair<int, int> rq = query(a, b, k * 2 + 2, m, r);
if (lq.first > rq.first) return lq;
return rq;
}
};
vector<candy> cs[2];
int N, x;
int solve() {
int ans = 0;
segtree st[2];
sort(begin(cs[0]), end(cs[0]));
sort(begin(cs[1]), end(cs[1]));
for (int i = (int)(0); i < (int)(2); i++) {
for (int j = (int)(0); j < (int)(2); j++) {
st[j] = segtree((int)cs[j].size());
for (int k = (int)(0); k < (int)(cs[j].size()); k++)
st[j].update(k, cs[j][k].m);
}
int y = x, cd = i, cnt[2] = {0};
while (1) {
int mx =
upper_bound(begin(cs[cd]), end(cs[cd]), candy(y, 0)) - cs[cd].begin();
if (mx < (int)cs[cd].size() and cs[cd][mx].h == y) mx++;
pair<int, int> gt = st[cd].query(0, mx);
if (gt.first == 0) break;
y += gt.first;
st[cd].update(gt.second, 0);
cnt[cd]++;
cd ^= 1;
}
ans = max(ans, cnt[0] + cnt[1]);
}
return ans;
}
void input() {
cin >> N >> x;
for (int i = (int)(0); i < (int)(N); i++) {
int t, h, m;
cin >> t >> h >> m;
cs[t].push_back(candy(h, m));
}
}
signed main() {
input();
cout << solve() << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1, n2, k1, k2;
cin >> n1 >> n2 >> k1 >> k2;
if (n1 > n2)
cout << "First" << endl;
else
cout << "Second" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
queue<int> q;
map<int, int> m;
for (int i = 0; i <= 29; i++) {
if (n & (1 << i)) {
m[1 << i]++;
if (i > 0) {
q.push(1 << i);
}
}
}
if (m.size() > k) {
cout << "NO";
return 0;
}
int count1 = m.size();
while (count1 < k && !q.empty()) {
int p = q.front();
q.pop();
m[p]--;
m[p / 2]++;
m[p / 2]++;
if (p / 2 > 1) {
q.push(p / 2);
q.push(p / 2);
}
count1++;
}
if (count1 < k) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (auto it = m.begin(); it != m.end(); it++) {
for (int i = 0; i < it->second; i++) {
cout << it->first << " ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < s.length(); i++)
cnt += (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u' ||
((s[i] >= '0' && s[i] <= '9') && (s[i] - '0') % 2 == 1));
cout << cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a;
int c, d, i, j;
cin >> a >> d;
c = a;
c = c % 96;
if ((c == 1 && d == 1) || (c == 1 && d == 8) || (c == 8 && d == 1) ||
(c == 8 && d == 8)) {
cout << "3";
} else if (c > 1 && d > 1 && d < 8 && c < 8)
cout << "8";
else
cout << "5";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int binpowmod(long long int a, long long int b, long long int m) {
a %= m;
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long int binpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return binpowmod(n, p - 2, p);
}
vector<vector<long long int>> adj1, adj2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, m, n, i, f = 0, j, ans = 0, l, r;
long long int a, b, x, t1;
cin >> a >> b >> n;
for (i = 0; i < n; ++i) {
cin >> l >> t >> m;
long long int l1, r1, mid;
t1 = a + (l - 1) * b;
if (t1 > t) {
cout << -1 << endl;
continue;
}
x = (t - a) / b + 1;
l1 = l, r1 = x;
while (l1 <= r1) {
mid = l1 + (r1 - l1) / 2;
t1 =
a * (mid - l + 1) + b * (((mid - 1) * (mid) - (l - 1) * (l - 2)) / 2);
if (t1 <= t * m) {
r = mid;
l1 = mid + 1;
} else {
r1 = mid - 1;
}
}
cout << r << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void GO() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
const long long INF = 1e18;
const long long mod = 998244353;
const int maxn = (int)5e3 + 1;
const int maxd = 501;
const long double PI = acos(-1.0);
mt19937 rnd(time(0));
void solve() {
long long n, ans = 0;
cin >> n;
vector<long long> a(n);
for (auto &i : a) cin >> i;
vector<long long> pref(n);
pref[0] = a[0];
for (int i = 0; i < n - 1; ++i)
pref[i + 1] = (i & 1 ? a[i + 1] : -a[i + 1]) + pref[i];
for (int i = 0; i < n; ++i) {
long long one = (i ? pref[i - 1] : 0);
long long two = (i + 1 < n ? pref.back() - pref[i] : 0);
ans += !(one - two);
}
cout << ans;
}
signed main() {
GO();
int Q = 1;
while (Q--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int q, n, k, pos, ans, a;
char c[3] = {'R', 'G', 'B'};
string s;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> q;
for (int l = 1; l <= q; l++) {
cin >> n >> k >> s;
ans = k;
for (int d = 0; d < 3; d++) {
a = k;
pos = 0;
for (int i = 0; i < k; i++) {
if (s[i] == c[(i + d) % 3]) a--;
}
ans = min(a, ans);
for (int i = k; i < n; i++) {
if (s[i - k] == c[(i - k + d) % 3]) a++;
if (s[i] == c[(i + d) % 3]) {
a--;
ans = min(a, ans);
}
}
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<long long, long long>, int> > v;
int cmp(pair<pair<long long, long long>, int> p1,
pair<pair<long long, long long>, int> p2) {
return p1.first.first * p2.first.second > p2.first.first * p1.first.second;
}
long long findsh(string str) {
long long s = 0;
long long h = 0;
long long ans = 0;
for (int i = 0; i < str.length(); i++) {
if (str[i] == 's')
s++;
else
ans = ans + s;
}
return ans;
}
int main() {
int n;
cin >> n;
while (n--) {
string s;
cin >> s;
int cs = 0;
int ch = 0;
int sz = s.length();
for (int i = 0; i < sz; i++) {
if (s[i] == 's')
cs++;
else
ch++;
}
v.push_back(make_pair(make_pair(cs, ch), findsh(s)));
}
sort(v.begin(), v.end(), cmp);
long long s = 0;
long long h = 0;
long long ans = 0;
for (int i = 0; i < v.size(); i++) {
ans = ans + s * v[i].first.second;
s = s + v[i].first.first;
ans = ans + v[i].second;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int tree[16 * 100000 + 5];
int lazy[16 * 100000 + 5];
void update(int si, int sj, int idx, int val, int ql, int qr) {
if (si == ql and sj == qr) {
lazy[idx] |= val;
tree[idx] |= val;
} else {
int mid = (si + sj) / 2;
if (qr <= mid)
update(si, mid, 2 * idx, val, ql, qr);
else if (mid + 1 <= ql)
update(mid + 1, sj, 2 * idx + 1, val, ql, qr);
else
update(si, mid, 2 * idx, val, ql, mid),
update(mid + 1, sj, 2 * idx + 1, val, mid + 1, qr);
tree[idx] = lazy[idx] | (tree[2 * idx] & tree[2 * idx + 1]);
}
}
int query(int si, int sj, int idx, int ql, int qr) {
if (si == ql and sj == qr)
return tree[idx];
else {
int mid = (si + sj) / 2;
if (qr <= mid)
return lazy[idx] | query(si, mid, 2 * idx, ql, qr);
else if (mid + 1 <= ql)
return lazy[idx] | query(mid + 1, sj, 2 * idx + 1, ql, qr);
else
return lazy[idx] | (query(si, mid, 2 * idx, ql, mid) &
query(mid + 1, sj, 2 * idx + 1, mid + 1, qr));
}
}
int l[100000 + 5], r[100000 + 5], q[100000 + 5];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> l[i] >> r[i] >> q[i];
update(1, n, 1, q[i], l[i], r[i]);
}
for (int i = 1; i <= m; ++i) {
if (query(1, n, 1, l[i], r[i]) != q[i]) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (int i = 1; i <= n; ++i) {
cout << query(1, n, 1, i, i) << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 30005;
const int inf = 100000;
map<pair<int, int>, int> was;
int l, first, i, a[N], mx, ans, n, d, dp[N][2100];
void rec(int i, int l, int res) {
ans = max(ans, res);
if (res < was[make_pair(i, l)])
return;
else
was[make_pair(i, l)] = res;
if (i + l - 1 <= mx && l > 1) rec(i + l - 1, l - 1, res + a[i + l - 1]);
if (i + l + 1 <= mx) rec(i + l + 1, l + 1, res + a[i + l + 1]);
if (i + l <= mx) rec(i + l, l, res + a[i + l]);
}
int main() {
cin >> n >> d;
for (i = 0; i < n; i++) {
cin >> first;
a[first]++;
mx = max(mx, first);
}
if (d > 2000) {
rec(d, d, a[d]);
cout << ans;
} else {
for (i = 0; i <= 30000; i++)
for (l = 1; l < 2099; l++) dp[i][l] = -inf;
dp[d][d] = a[d];
for (i = d + 1; i <= 30000; i++)
for (l = 1; l < 2098; l++) {
if (i - l >= d) {
if (l > 1 && dp[i - l][l - 1] != -inf)
dp[i][l] = max(dp[i][l], dp[i - l][l - 1] + a[i]);
if (dp[i - l][l + 1] != -inf)
dp[i][l] = max(dp[i][l], dp[i - l][l + 1] + a[i]);
if (dp[i - l][l] != -inf)
dp[i][l] = max(dp[i][l], dp[i - l][l] + a[i]);
}
ans = max(ans, dp[i][l]);
}
cout << ans;
}
}
| 5 |
#include <bits/stdc++.h>
struct TData {
private:
public:
using Shared = std::shared_ptr<TData>;
int _index = 0;
int _size = 0;
int _weight = 0;
bool _paired = false;
std::pair<Shared, Shared> _pair;
TData(const TData& a) = delete;
TData& operator=(const TData& a) = delete;
TData() {}
TData(int ind, int sz, int we) : _index(ind), _size(sz), _weight(we) {}
TData(Shared& a, Shared& b) { makepair(a, b); }
~TData() {}
inline void makepair(Shared& a, Shared& b) {
_pair.first = a;
_pair.second = b;
_index = 0;
_size = a->_size + b->_size;
_weight = a->_weight + b->_weight;
_paired = true;
}
};
using TVec = std::vector<TData::Shared>;
void printVec(const TVec& vec, bool debug = false) {
if (debug) {
printf("----\n");
for (auto& pr : vec) {
printf("%d %d %d\n", pr->_index, pr->_size, pr->_weight);
}
} else {
for (auto& pr : vec) printf("%d ", pr->_index);
}
}
void printVecInLine(int _weight, const TVec& vec) {
printf("%d : ", _weight);
for (auto& pr : vec) {
printf("%d ", pr->_weight);
}
printf("\n");
}
void sortVec(TVec& vec, bool reverse = false) {
std::sort(std::begin(vec), std::end(vec),
[reverse](const TData::Shared& a, const TData::Shared& b) {
if (reverse) return a->_weight > b->_weight;
return a->_weight < b->_weight;
});
}
void pairBaydarkas(TVec& vec, TVec& outVec) {
auto vsize = vec.size();
for (unsigned int i = 0; i < vsize;) {
if (i + 1 < vsize) {
outVec.emplace_back(std::make_shared<TData>(vec[i], vec[i + 1]));
i += 2;
} else {
outVec.emplace_back(vec[i]);
++i;
}
}
}
int main() {
int n = 0;
int v = 0;
scanf("%d %d", &n, &v);
int sz = 0;
int we = 0;
TVec vec1;
TVec vec2;
for (int i = 0; i < n; ++i) {
scanf("%d %d", &sz, &we);
if (sz == 1)
vec1.emplace_back(std::make_shared<TData>(i + 1, sz, we));
else
vec2.emplace_back(std::make_shared<TData>(i + 1, sz, we));
}
int needSize = v;
int fullWeight = 0;
TVec vecRes;
if (needSize == 1) {
sortVec(vec1, true);
if (!vec1.empty()) {
vecRes.emplace_back(vec1[0]);
fullWeight += vec1[0]->_weight;
}
} else {
vecRes.reserve(vec1.size() + vec2.size());
sortVec(vec1, true);
if (v % 2 == 1 && !vec1.empty()) {
needSize -= vec1[0]->_size;
fullWeight += vec1[0]->_weight;
vecRes.emplace_back(vec1[0]);
TVec vec1_1(vec1.begin() + 1, vec1.end());
vec1.swap(vec1_1);
}
TVec vec3;
vec3.reserve(vec1.size() / 2);
pairBaydarkas(vec1, vec3);
std::copy(std::begin(vec2), std::end(vec2), std::back_inserter(vec3));
sortVec(vec3, true);
for (unsigned int i = 0; i < vec3.size() && needSize > 0; ++i) {
auto& data = vec3[i];
if (needSize >= data->_size) {
if (data->_paired) {
vecRes.emplace_back(data->_pair.first);
vecRes.emplace_back(data->_pair.second);
} else {
vecRes.emplace_back(data);
}
needSize -= data->_size;
fullWeight += data->_weight;
} else {
for (unsigned int j = i + 1; j < vec3.size(); ++j) {
auto& data2 = vec3[j];
if (data2->_paired) {
vecRes.emplace_back(data2->_pair.first);
needSize -= data2->_pair.first->_size;
fullWeight += data2->_pair.first->_weight;
} else if (data2->_size == needSize) {
vecRes.emplace_back(data2);
needSize -= data2->_size;
fullWeight += data2->_weight;
}
}
}
}
}
printf("%d\n", fullWeight);
for (auto& data : vecRes) {
printf("%d ", data->_index);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, t, i = 1;
string x, res;
string toStr(int x) {
string ans = "";
while (x) {
ans += ((x % 10) + '0');
x /= 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
int main() {
cin >> n >> t;
x = toStr(t);
if (x.length() > n) {
cout << -1;
return 0;
}
res = x;
for (int i = 0; i < n - x.length(); i++) {
res += '0';
}
cout << res;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int res[13][2];
char tmp[10];
int main() {
int n;
scanf("%d", &n);
for (int j = 0; j < 10; j++) res[j][0] = 0, res[j][1] = 1;
for (int i = 1; i <= n; i++) {
int v;
scanf("%s%d", tmp, &v);
for (int j = 0; j < 10; j++) {
if (tmp[0] == '|') {
res[j][0] = (res[j][0] | (v >> j)) & 1;
res[j][1] = (res[j][1] | (v >> j)) & 1;
}
if (tmp[0] == '^') {
res[j][0] = (res[j][0] ^ (v >> j)) & 1;
res[j][1] = (res[j][1] ^ (v >> j)) & 1;
}
if (tmp[0] == '&') {
res[j][0] = (res[j][0] & (v >> j)) & 1;
res[j][1] = (res[j][1] & (v >> j)) & 1;
}
}
}
int v1 = 0, v2 = 0, v3 = 0;
for (int j = 0; j < 10; j++) {
if (res[j][0] == 0 && res[j][1] == 0)
v1 = v1 | (0 << j);
else
v1 = v1 | (1 << j);
if (res[j][0] == 1 && res[j][1] == 0)
v2 = v2 | (1 << j);
else
v2 = v2 | (0 << j);
if (res[j][0] == 1 && res[j][1] == 1)
v3 = v3 | (1 << j);
else
v3 = v3 | (0 << j);
}
printf("3\n");
printf("& %d\n", v1);
printf("^ %d\n", v2);
printf("| %d\n", v3);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {-2, +2, -2, +2};
int dy[4] = {-2, +2, +2, -2};
bool mark[10][10][2][201];
struct Tri {
int first, second, T;
Tri(int _X, int _Y, int _T) {
first = _X;
second = _Y;
T = _T;
}
};
void bfs(int x, int y, int num) {
vector<Tri> q;
q.push_back(Tri(x, y, 0));
for (__typeof(((int)((q).size())) - 1) i = (0);
i <= (((int)((q).size())) - 1); i++) {
Tri v = q[i];
mark[v.first][v.second][num][v.T] = true;
for (__typeof(3) j = (0); j <= (3); j++) {
Tri u = Tri(v.first + dx[j], v.second + dy[j], v.T + 1);
if (u.first >= 1 && u.first <= 8 && u.second >= 1 && u.second <= 8 &&
u.T <= 200)
if (!mark[u.first][u.second][num][u.T]) {
mark[u.first][u.second][num][u.T] = true;
q.push_back(u);
}
}
}
}
int t;
char a[10][10];
int main() {
cin >> t;
int cnt;
bool ans;
for (__typeof(t) i = (1); i <= (t); i++) {
cnt = 0;
memset(mark, 0, sizeof mark);
for (__typeof(8) y = (1); y <= (8); y++)
for (__typeof(8) x = (1); x <= (8); x++) {
cin >> a[x][y];
if (a[x][y] == 'K') {
bfs(x, y, cnt);
cnt++;
}
}
ans = false;
for (__typeof(8) y = (1); y <= (8); y++)
if (!ans)
for (__typeof(8) x = (1); x <= (8); x++)
if (!ans && a[x][y] != '#')
for (__typeof(200) tm = (0); tm <= (200); tm++)
if (mark[x][y][0][tm] && mark[x][y][1][tm]) {
ans = true;
break;
}
if (cnt == 1) ans = true;
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int dp[2][515][515];
int main() {
int N, M, B, MOD;
cin >> N >> M >> B >> MOD;
for (int n = 0, _a = (N); n < _a; n++) {
int ai;
cin >> ai;
a.push_back(ai);
}
int atual(1);
int anterior(0);
int ans(0);
dp[0][0][0] = 1;
for (int i = (1), _b = (N); i <= _b; i++) {
int aux = i & 1;
for (int j = (0), _b = (M); j <= _b; j++) {
for (int k = (0), _b = (B); k <= _b; k++) {
dp[aux][j][k] = dp[aux ^ 1][j][k];
if (j > 0 && k >= a[i - 1]) {
dp[aux][j][k] += dp[aux][j - 1][k - a[i - 1]];
}
while (dp[aux][j][k] >= MOD) dp[aux][j][k] -= MOD;
}
}
}
for (int i = (0), _b = (B); i <= _b; i++) {
ans = ans + dp[N & 1][M][i];
while (ans >= MOD) ans -= MOD;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
long long n, m, b, ans;
long long a[1005];
int l, r, mid;
long long dp[1005][1005];
struct Node {
long long w, id;
} f[1005];
bool cmp(Node a, Node b) {
if (a.w != b.w) return a.w < b.w;
return a.id > b.id;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n + 1; ++i)
for (int j = 0; j <= n + 1; ++j) dp[i][j] = 1e18;
dp[n + 1][0] = 0;
for (int i = n; i >= 1; --i) {
for (int j = 0; j <= n; ++j)
dp[i][j] = min(dp[i][j], max(0LL, dp[i + 1][j] - a[i]));
for (int j = 1; j <= n; ++j) dp[i][j] = min(dp[i][j], dp[i + 1][j - 1]);
}
for (int i = 0; i <= n; ++i) {
f[i].w = dp[1][i];
f[i].id = i;
}
sort(f, f + n + 1, cmp);
for (int i = 1; i <= m; ++i) {
cin >> b;
l = 0;
r = n;
ans = -1;
while (l <= r) {
mid = (l + r) / 2;
if (f[mid].w <= b) {
ans = f[mid].id;
l = mid + 1;
} else
r = mid - 1;
}
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[200010];
int ans[200010];
int main() {
int n, a, b, k, i, j, l = 0, falg;
cin >> n >> a >> b >> k;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == '0') {
falg = 0;
for (j = i; j <= i + b - 1; j++) {
if (j == n) {
falg = 1;
break;
}
if (s[j] == '1') {
falg = 1;
break;
}
}
if (falg == 0) {
ans[l] = j - 1;
l++;
i = j - 1;
}
}
}
if (l - a + 1 < 1)
cout << "1" << endl;
else
cout << l - a + 1 << endl;
for (i = 0; i < l - a; i++) cout << ans[i] + 1 << " ";
cout << ans[l - a] + 1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool palin(string& s) {
for (int i = 0; i < s.size(); i++)
if (s[i] != s[s.size() - 1 - i]) return false;
return true;
}
bool test1(string& s) {
for (int i = 0; i < s.size() - 1; i++) {
string g = s.substr(i + 1) + s.substr(0, i + 1);
if (palin(g) && g != s) return true;
}
return false;
}
bool possible(string& s) {
for (int i = 0; i < s.size() / 2; i++)
if (s[0] != s[i]) return true;
return false;
}
int main() {
iostream::sync_with_stdio(false);
string s;
cin >> s;
if (!possible(s))
cout << "Impossible\n";
else
cout << 2 - test1(s) << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long double arr[n][4];
for (int i = 0; i < n; i++)
cin >> arr[i][0] >> arr[i][1] >> arr[i][2] >> arr[i][3];
long double l = 0, r = 1000000000000;
for (int i = 0; i < n; ++i) {
if (arr[i][2] == 0 && !(x1 < arr[i][0] && arr[i][0] < x2)) {
cout << -1;
return 0;
}
if (arr[i][3] == 0 && !(y1 < arr[i][1] && arr[i][1] < y2)) {
cout << -1;
return 0;
}
if (arr[i][3] != 0) {
if ((arr[i][3] > 0)) {
l = max(l, (long double)(y1 - arr[i][1]) / (long double)arr[i][3]);
r = min(r, (long double)(y2 - arr[i][1]) / (long double)arr[i][3]);
} else {
l = max(l, (long double)(y2 - arr[i][1]) / (long double)arr[i][3]);
r = min(r, (long double)(y1 - arr[i][1]) / (long double)arr[i][3]);
}
}
if (arr[i][2] != 0) {
if ((arr[i][2] > 0)) {
l = max(l, (long double)(x1 - arr[i][0]) / (long double)arr[i][2]);
r = min(r, (long double)(x2 - arr[i][0]) / (long double)arr[i][2]);
} else {
l = max(l, (long double)(x2 - arr[i][0]) / (long double)arr[i][2]);
r = min(r, (long double)(x1 - arr[i][0]) / (long double)arr[i][2]);
}
}
}
if (l < r)
printf("%0.16f", (double)l);
else
cout << "-1";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
struct Node {
Node *l = 0, *r = 0;
int lo, hi;
int mx[2];
bool lz = 0;
Node(int _lo, int _hi) : lo(_lo), hi(_hi) { mx[0] = mx[1] = 0; }
Node(ii v[], int _lo, int _hi) : lo(_lo), hi(_hi) {
mx[0] = mx[1] = 0;
if (lo + 1 < hi) {
int mid = lo + (hi - lo) / 2;
l = new Node(v, lo, mid);
r = new Node(v, mid, hi);
for (int i : {0, 1}) mx[i] = max(l->mx[i], r->mx[i]);
} else {
mx[v[lo].first] = v[lo].second;
}
}
void upd() {
swap(mx[0], mx[1]);
lz ^= 1;
}
void flip(int L, int R) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R) {
upd();
} else {
push(), l->flip(L, R), r->flip(L, R);
for (int i : {0, 1}) mx[i] = max(l->mx[i], r->mx[i]);
}
}
void push() {
if (lo + 1 < hi and lz) {
l->upd(), r->upd();
}
lz = 0;
}
};
const int N = 5e5 + 5;
int n, q;
int l[N], r[N], w[N];
vi g[N];
int d1, d2;
int tym;
ii dis[N];
int IN[N], OUT[N];
int EDGE[N];
ii dis_[N];
void dfs(int u, int daddy, int pe) {
IN[u] = ++tym;
EDGE[pe] = u;
for (int i : g[u]) {
int v = l[i] ^ r[i] ^ u;
if (v != daddy) {
dis[v] = {dis[u].first ^ w[i], dis[u].second + 1};
dfs(v, u, i);
}
}
OUT[u] = tym;
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d %d %d", &l[i], &r[i], &w[i]);
g[l[i]].emplace_back(i);
g[r[i]].emplace_back(i);
}
dis[1] = {0, 0};
dfs(1, 0, 0);
{
int mx = INT_MIN;
for (int i = 1; i <= n; ++i) {
if (dis[i].second > mx) {
d1 = i;
mx = dis[i].second;
}
}
}
42;
vi in[2], out[2], e[2];
Node *t[2];
dis[d1] = {0, 0}, tym = 0;
dfs(d1, 0, 0);
for (int i = 1; i <= n; ++i) {
dis_[IN[i]] = dis[i];
}
42;
t[0] = new Node(dis_, 1, n + 1);
42;
in[0] = vi(IN, IN + 1 + n);
out[0] = vi(OUT, OUT + 1 + n);
e[0] = vi(EDGE, EDGE + 1 + n);
{
int mx = INT_MIN;
for (int i = 1; i <= n; ++i) {
if (dis[i].second > mx) {
d2 = i;
mx = dis[i].second;
}
}
}
dis[d2] = {0, 0}, tym = 0;
dfs(d2, 0, 0);
for (int i = 1; i <= n; ++i) {
dis_[IN[i]] = dis[i];
}
42;
t[1] = new Node(dis_, 1, n + 1);
in[1] = vi(IN, IN + 1 + n);
out[1] = vi(OUT, OUT + 1 + n);
e[1] = vi(EDGE, EDGE + 1 + n);
scanf("%d", &q);
while (q--) {
int id;
scanf("%d", &id);
42;
int ans = 0;
for (int i : {0, 1}) {
42;
t[i]->flip(in[i][e[i][id]], out[i][e[i][id]] + 1);
ans = max(ans, t[i]->mx[0]);
}
42;
42;
printf("%d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int Q = 100005;
int n, m, q;
int now[N][N];
int ans[Q];
int cur;
int op[Q], x[Q], y[Q];
vector<int> go[Q];
void modify(int &nw, int val) {
cur -= nw;
nw = val;
cur += nw;
}
void dfs(int u) {
int save = -1;
if (op[u] == 1) {
save = now[x[u]][y[u]];
modify(now[x[u]][y[u]], 1);
} else if (op[u] == 2) {
save = now[x[u]][y[u]];
modify(now[x[u]][y[u]], 0);
} else if (op[u] == 3) {
for (int y = 1; y <= m; ++y) {
modify(now[x[u]][y], now[x[u]][y] ^ 1);
}
}
ans[u] = cur;
for (int v : go[u]) {
dfs(v);
}
if (op[u] == 1 || op[u] == 2) {
modify(now[x[u]][y[u]], save);
} else if (op[u] == 3) {
for (int y = 1; y <= m; ++y) {
modify(now[x[u]][y], now[x[u]][y] ^ 1);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 1; i <= q; ++i) {
cin >> op[i];
if (op[i] == 4) {
int pr;
cin >> pr;
go[pr].push_back(i);
} else {
go[i - 1].push_back(i);
cin >> x[i];
if (op[i] <= 2) {
cin >> y[i];
}
}
}
dfs(0);
for (int i = 1; i <= q; ++i) {
cout << ans[i] << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long setbit(long long num, int idx, int val = 1) {
return (val) ? (num | (1 << idx)) : (num & ~(1 << idx));
}
long long getbit(long long num, int idx) { return ((num >> idx) & 1) == 1; }
int contbit(int num) {
int ret = 0;
while (num) {
if (num % 2) ret++;
num /= 2;
}
return ret;
}
int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
int main() {
file();
fast();
int n;
cin >> n;
vector<int> a(n + 5), f(200005, 0);
queue<int> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
f[a[i]]++;
}
int x = 0;
for (int i = 1; i <= n; i++)
if (f[x] < f[a[i]]) x = a[i];
for (int i = 1; i <= n; i++)
if (a[i] == x) q.push(i);
cout << n - f[x] << "\n";
while (q.size()) {
int z = q.front();
q.pop();
if (z > 1 && a[z - 1] != x) {
if (a[z - 1] > a[z])
cout << 2;
else
cout << 1;
cout << " " << z - 1 << " " << z << "\n";
a[z - 1] = x;
q.push(z - 1);
}
if (z < n && a[z + 1] != x) {
if (a[z + 1] > a[z])
cout << 2;
else
cout << 1;
cout << " " << z + 1 << " " << z << "\n";
a[z + 1] = x;
q.push(z + 1);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long b, long long e, long long m) {
b %= m;
long long ans = 1;
for (; e; b = b * b % m, e /= 2)
if (e & 1) ans = ans * b % m;
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
priority_queue<int, vector<int>, greater<int> > pq;
long long res = 0;
int p;
cin >> p;
pq.push(p);
for (int i = 1; i < (n); ++i) {
cin >> p;
pq.push(p);
if (pq.top() < p) {
res += p - pq.top();
pq.pop();
pq.push(p);
}
}
cout << res << "\n";
}
| 8 |
#include <iostream>
using namespace std;
int main() {
int t,n,m,k,p;
cin>>t;
while(t--){
cin>>n>>m>>k;
p=(m-1)+m*(n-1);
if(p==k)
cout<<"YES"<<endl;
else cout<<"NO"<<endl;}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int count[2] = {0, 0}, cnt;
cin >> n;
string s;
cin >> s;
char c = 'r';
cnt = n;
for (int i = 0; i < 2; i++) {
count[0] = 0;
count[1] = 0;
for (int j = 0; j < s.length(); j++) {
if (s[j] != c) {
if (c == 'r')
count[0]++;
else
count[1]++;
}
c = c == 'r' ? 'b' : 'r';
}
if (cnt > max(count[0], count[1])) cnt = max(count[0], count[1]);
c = 'b';
}
cout << cnt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
const int maxN = 3e5 + 10;
long long c[maxN], w[maxN];
int x[maxN], y[maxN];
struct twoedge {
int n;
int m;
vector<vector<pair<int, int>>> g;
vector<bool> used;
vector<int> up;
vector<int> h;
vector<bool> bridges;
void dfs(int v, int p, int id) {
up[v] = h[v];
used[v] = true;
for (auto& it : g[v]) {
if (used[it.first]) {
if (id != it.second) {
up[v] = min(up[v], h[it.first]);
}
} else {
h[it.first] = h[v] + 1;
dfs(it.first, v, it.second);
if (up[it.first] == h[it.first]) {
bridges[it.second] = true;
}
up[v] = min(up[v], up[it.first]);
}
}
}
vector<vector<int>> components;
void sec_dfs(int v, vector<int>& f) {
f.emplace_back(v);
used[v] = true;
for (auto& it : g[v]) {
if (!used[it.first] && !bridges[it.second]) {
sec_dfs(it.first, f);
}
}
}
twoedge(vector<vector<pair<int, int>>>& edge) {
g = edge;
n = g.size();
m = -1;
for (int i = 0; i < n; i++) {
for (auto& it : g[i]) {
m = max(m, it.second);
}
}
m++;
h = vector<int>(n, 0);
up = vector<int>(n, 0);
bridges = vector<bool>(m, false);
used = vector<bool>(n, false);
for (int i = 0; i < n; i++) {
if (!used[i]) {
dfs(i, -1, -1);
}
}
used.assign(n, false);
for (int i = 0; i < n; i++) {
if (!used[i]) {
vector<int> cmps;
sec_dfs(i, cmps);
components.emplace_back(cmps);
}
}
}
};
bool is[maxN];
int v[maxN];
long long cost[maxN];
int id[maxN];
bool spec[maxN];
int par[maxN];
vector<pair<int, int>> edges[maxN];
vector<pair<int, int>> gg[maxN];
long long dp[maxN][2];
void dfs_first(int v, int p) {
dp[v][1] = cost[v];
dp[v][0] = 0;
for (auto& it : gg[v]) {
if (it.first == p) continue;
dfs_first(it.first, v);
}
for (auto& it : gg[v]) {
if (it.first == p) continue;
dp[v][0] += max(dp[it.first][0], dp[it.first][1]);
dp[v][1] += max(0LL, dp[it.first][1] - it.second);
}
}
long long up[maxN];
long long ans[maxN];
void dfs_second(int v, int p) {
if (p == -1) up[v] = cost[v];
long long total = 0;
for (auto& it : gg[v]) {
if (it.first == p) continue;
total += max(0LL, dp[it.first][1] - it.second);
}
ans[v] = up[v] + total;
for (auto& it : gg[v]) {
if (it.first == p) continue;
up[it.first] =
max(cost[it.first], cost[it.first] + up[v] + total - it.second -
max(0LL, dp[it.first][1] - it.second));
dfs_second(it.first, v);
}
}
int getPar(int i) {
if (par[i] == i) return i;
return par[i] = getPar(par[i]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> v[i];
v[i]--;
is[v[i]] = true;
}
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < m; i++) cin >> w[i];
vector<vector<pair<int, int>>> g(n);
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
x[i]--;
y[i]--;
g[x[i]].emplace_back(y[i], i);
g[y[i]].emplace_back(x[i], i);
}
auto P = twoedge(g);
int SZ = P.components.size();
int c = 0;
for (auto& it : P.components) {
for (int v : it) {
id[v] = c;
}
c++;
}
assert(c == SZ);
int EDGES_ADD = 0;
for (auto& it : P.components) {
for (int v : it) {
if (is[v]) {
spec[id[v]] = true;
}
cost[id[v]] += ::c[v];
for (auto& to : g[v]) {
if (id[v] < id[to.first]) {
EDGES_ADD++;
edges[id[v]].emplace_back(id[to.first], to.second);
edges[id[to.first]].emplace_back(id[v], to.second);
}
}
}
}
assert(EDGES_ADD == SZ - 1);
vector<int> deg(SZ);
queue<int> q;
for (int i = 0; i < SZ; i++) par[i] = i;
for (int i = 0; i < SZ; i++) {
deg[i] = edges[i].size();
if (!spec[i] && deg[i] == 1) {
q.push(i);
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
deg[v]--;
int who = -1;
for (auto& it : edges[v]) {
if (deg[it.first] > 0) {
who = it.first;
break;
}
}
assert(who != -1);
par[v] = who;
cost[who] += cost[v];
deg[who]--;
if (deg[who] == 1 && !spec[who]) {
q.push(who);
}
}
int root = -1;
for (int i = 0; i < SZ; i++) {
if (par[i] == i) {
root = i;
}
}
assert(root != -1);
for (int i = 0; i < SZ; i++) {
if (par[i] == i) {
for (auto& it : edges[i]) {
if (par[it.first] == it.first) {
gg[i].emplace_back(it.first, w[it.second]);
}
}
}
}
dfs_first(root, -1);
dfs_second(root, -1);
for (int i = 0; i < n; i++) {
cout << ans[getPar(id[i])] << " ";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
string fun(string a) {
if (a.length() % 2 == 1) {
return a;
}
string b, c;
for (long long i = 0; i < a.length() / 2; i++) {
b += a[i];
c += a[i + a.length() / 2];
}
string d = fun(b);
string e = fun(c);
return min(d + e, e + d);
}
void solve() {
string a, b;
cin >> a >> b;
if (fun(a) == fun(b)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = 0; k < n; k++)
if (a[i] + a[j] == a[k]) {
cout << k + 1 << " " << i + 1 << " " << j + 1 << endl;
exit(0);
}
cout << -1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a[300], l, r, t, ans = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
t = 0;
cin >> l >> r;
for (int j = l; j <= r; j++) {
t += a[j];
}
if (t > 0) {
ans += t;
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
long long n;
std::cin >> n;
long long i = 1;
while ((i + 1) * (i + 1) <= n) {
i++;
}
if (i * i == n)
std::cout << 2 * i;
else if (i * i + i >= n)
std::cout << 2 * i + 1;
else
std::cout << 2 * i + 2;
std::cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
const long long INF = 1e9 + 7;
long long n, ans = INF;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s;
long long n = s.size();
for (long long mask = 1; mask < 1 << n; mask++) {
long long t = 0;
bool check = true;
for (long long i = 0; i < n; i++)
if (mask >> i & 1) {
t = t * 10 + s[i] - '0';
if (t == 0 && s[i] == '0') check = false;
}
long long tt = sqrt(t);
if (tt * tt == t && tt != 0 && check)
ans = min(ans, n - __builtin_popcount(mask));
}
cout << (ans == INF ? -1 : ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
void P_1_30() {
std::unordered_map<int, int> elemToIndex;
int n;
std::cin >> n;
for (int i = 1; i <= n; i++) {
int e;
std::cin >> e;
elemToIndex[e] = i;
}
int m;
std::cin >> m;
long long opCount = 0, opCountReverse = 0;
for (int i = 0; i < m; i++) {
int q;
std::cin >> q;
int index = elemToIndex[q];
opCount += index;
opCountReverse += (n - index + 1);
}
std::cout << opCount << " " << opCountReverse;
}
int main() { P_1_30(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using LD = long double;
constexpr int maxn = 120000;
int sgn(LL x) {
if (x < 0) return -1;
if (x > 0) return 1;
return 0;
}
struct P {
LL x, y, z;
P(LL x = 0, LL y = 0, LL z = 0) : x(x), y(y), z(z){};
} p[2][maxn], n[2];
LL operator*(P A, P B) { return A.x * B.x + A.y * B.y + A.z * B.z; }
P operator+(P A, P B) { return P(A.x + B.x, A.y + B.y, A.z + B.z); }
P operator-(P A, P B) { return P(A.x - B.x, A.y - B.y, A.z - B.z); }
P operator*(P A, LL k) { return P(A.x * k, A.y * k, A.z * k); }
P cross(P A, P B) {
return P(A.y * B.z - A.z * B.y, A.z * B.x - A.x * B.z, A.x * B.y - A.y * B.x);
}
int m[2], mix[maxn];
int main() {
ios::sync_with_stdio(false);
for (int t = 0; t < 2; t += 1) {
cin >> m[t];
for (int i = 0; i < m[t]; i += 1)
cin >> p[t][i].x >> p[t][i].y >> p[t][i].z;
p[t][m[t]] = p[t][0];
n[t] = cross(p[t][1] - p[t][0], p[t][2] - p[t][0]);
}
if (cross(n[0], n[1]) * cross(n[0], n[1]) == 0) {
cout << "NO";
return 0;
}
P X = cross(n[0], n[1]);
vector<pair<LD, pair<int, int>>> v;
for (int t = 0; t < 2; t += 1) {
for (int i = 0; i <= m[t]; i += 1)
mix[i] = sgn((p[t][i] - p[t ^ 1][0]) * n[t ^ 1]);
for (int i = 0; i < m[t]; i += 1) {
if (mix[i] == mix[i + 1]) continue;
LD k = (LD)(n[t ^ 1] * (p[t][i] - p[t ^ 1][0])) /
(n[t ^ 1] * (p[t][i] - p[t][i + 1]));
LD Y = (p[t][i] * X) + (p[t][i + 1] - p[t][i]) * X * k;
v.push_back(make_pair(Y, make_pair(t, mix[i] - mix[i + 1])));
}
}
sort(v.begin(), v.end());
int sgn = 0, io = 0;
for (auto p : v) {
if (p.second.first)
sgn += io * p.second.second;
else
io += p.second.second;
}
cout << (sgn == 0 ? "NO" : "YES");
}
| 10 |
#include <bits/stdc++.h>
int min2(int a, int b) { return a > b ? b : a; }
int main(int argc, char **argv) {
int t;
scanf("%d", &t);
while (t--) {
int rows, columns;
scanf("%d %d", &rows, &columns);
std::vector<std::vector<int>> claimed(rows, std::vector<int>(columns, 0));
for (int r = 0; r < rows; r++)
for (int c = 0; c < columns; c++) scanf("%d", &claimed[r][c]);
for (int r = 0; r < rows; r++)
for (int c = 0; c < columns; c++) -1;
std::vector<int> unclaimed_rows, unclaimed_columns;
for (int r = 0; r < rows; r++) {
bool cl = false;
for (int c = 0; c < columns && !cl; c++)
if (claimed[r][c]) cl = true;
if (!cl) unclaimed_rows.push_back(r);
}
for (int c = 0; c < columns; c++) {
bool cl = false;
for (int r = 0; r < rows && !cl; r++)
if (claimed[r][c]) cl = true;
if (!cl) unclaimed_columns.push_back(c);
}
int turns = min2(unclaimed_rows.size(), unclaimed_columns.size());
-1;
printf("%s\n", turns % 2 == 1 ? "Ashish" : "Vivek");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, P1, P2, P3, T1, T2;
scanf("%d %d %d %d %d %d", &n, &P1, &P2, &P3, &T1, &T2);
int l[n], r[n], ans = 0;
for (int i = 0; i < n; ++i) {
scanf("%d %d", &l[i], &r[i]);
ans += (r[i] - l[i]) * P1;
}
for (int i = 0; i + 1 < n; ++i) {
ans += min(T1, l[i + 1] - r[i]) * P1;
ans += min(T2, max(0, l[i + 1] - r[i] - T1)) * P2;
ans += max(0, l[i + 1] - r[i] - T1 - T2) * P3;
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int _inf = 0xc0c0c0c0;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long _INF = 0xc0c0c0c0c0c0c0c0;
const long long mod = (int)1e9 + 7;
const int N = 2e5 + 100;
vector<int> vc[N];
map<int, int> odd, even;
int a[N];
int deep[N];
int ans = 0;
int num = 0;
void dfs(int u) {
for (int v : vc[u]) {
deep[v] = deep[u] + 1;
dfs(v);
}
if (!(deep[u] & 1)) {
ans ^= a[u];
even[a[u]]++;
++num;
} else
odd[a[u]]++;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 2, v; i <= n; ++i) {
scanf("%d", &v);
deep[i] = deep[v] + 1;
vc[v].push_back(i);
}
if (deep[n] & 1) deep[1] = 1;
dfs(1);
long long tot = 0;
if (ans == 0) {
tot = (num - 1ll) * num / 2;
num = n - num;
tot += (num - 1ll) * num / 2;
}
for (auto it : even) {
int tans = ans ^ it.first;
if (odd.count(tans)) {
tot += 1ll * it.second * odd[tans];
}
}
cout << tot << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n == 1) {
cout << "1";
} else {
cout << n / 2 + 1;
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int p1, p2, n, tx1, tx2, v;
double tempo, min = 1000;
scanf("%d %d", &p1, &p2);
scanf("%d", &n);
for (; n > 0; n--) {
scanf("%d %d %d", &tx1, &tx2, &v);
tempo = (sqrt(((tx1 - p1) * (tx1 - p1)) + ((tx2 - p2) * (tx2 - p2)))) / v;
if (tempo <= min) min = tempo;
}
printf("%.20f\n", min);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500000 + 5;
int dp[maxn][26], pre[maxn][26];
char s[maxn];
void print(int i, int j) {
if (i == -1) {
return;
}
print(i - 1, pre[i][j]);
printf("%c", j + 'A');
}
int main(void) {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s);
for (int j = 0; j < k; j++) {
dp[0][j]++;
}
dp[0][s[0] - 'A']--;
memset(pre, -1, sizeof(pre));
for (int i = 1; i < n; i++) {
for (int j = 0; j < k; j++) {
int mi = maxn, who = -1;
for (int p = 0; p < k; p++) {
if (p != j) {
int tmp = dp[i - 1][p] + (s[i] - 'A' == j ? 0 : 1);
if (tmp < mi) {
mi = tmp;
who = p;
}
}
}
dp[i][j] = mi;
pre[i][j] = who;
}
}
int pos = min_element(dp[n - 1], dp[n - 1] + k) - dp[n - 1];
printf("%d\n", dp[n - 1][pos]);
print(n - 1, pos);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int A[300010][10];
int ton[1000];
int N, M;
int I, J;
bool check(int);
int main() {
int i, j, k;
scanf("%d%d", &N, &M);
for (i = 1; i <= N; i++)
for (j = 1; j <= M; j++) scanf("%d", &A[i][j]);
int L = 0, R = 1e9;
int mid = (L + R) >> 1;
while (R - L >= 3) {
if (check(mid))
L = mid;
else
R = mid - 1;
mid = (L + R) >> 1;
}
for (mid = R; mid >= L; mid--)
if (check(mid)) {
printf("%d %d\n", I, J);
return 0;
}
}
bool check(int ans) {
int i, j, k, l;
memset(ton, 0, sizeof(ton));
for (i = 1; i <= N; i++) {
k = 0;
l = 1;
for (j = 1; j <= M; j++) {
if (A[i][j] >= ans) k |= l;
l <<= 1;
}
ton[k] = i;
}
for (i = 0; i < (1 << M); i++)
for (j = 0; j < (1 << M); j++)
if ((i | j) == (1 << M) - 1 && ton[i] && ton[j]) {
I = ton[i], J = ton[j];
return true;
}
return false;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
ignore = scanf("%d", &T);
while (T--) {
int a, b, n;
ignore = scanf("%d %d %d", &a, &b, &n);
int ans = 0;
while (a <= n && b <= n) {
if (a > b) swap(a, b);
a += b;
ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
const int mod = 1e9 + 7;
int n;
const double pi = 4 * atan(1);
const double eps = 1e-10;
inline int dcmp(double x) {
if (fabs(x) < eps)
return 0;
else
return x < 0 ? -1 : 1;
}
inline double getDistance(double x, double y) { return sqrt(x * x + y * y); }
inline double torad(double deg) { return deg / 180 * pi; }
struct Point {
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
void read() { scanf("%lf%lf", &x, &y); }
void write() { printf("%f %f", x, y); }
bool operator==(const Point& u) const {
return dcmp(x - u.x) == 0 && dcmp(y - u.y) == 0;
}
bool operator!=(const Point& u) const { return !(*this == u); }
bool operator<(const Point& u) const {
return dcmp(x - u.x) < 0 || (dcmp(x - u.x) == 0 && dcmp(y - u.y) < 0);
}
bool operator>(const Point& u) const { return u < *this; }
bool operator<=(const Point& u) const { return *this < u || *this == u; }
bool operator>=(const Point& u) const { return *this > u || *this == u; }
Point operator+(const Point& u) { return Point(x + u.x, y + u.y); }
Point operator-(const Point& u) { return Point(x - u.x, y - u.y); }
Point operator*(const double u) { return Point(x * u, y * u); }
Point operator/(const double u) { return Point(x / u, y / u); }
double operator^(const Point& u) { return x * u.y - y * u.x; }
};
double getCross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
int getConvexHull(Point* p, int n, Point* ch) {
sort(p, p + n);
int m = 0;
for (int i = 0; i < n; i++) {
while (m > 1 &&
dcmp(getCross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 1])) <= 0)
m--;
ch[m++] = p[i];
}
int k = m;
for (int i = n - 2; i >= 0; i--) {
while (m > k &&
dcmp(getCross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2])) <= 0)
m--;
ch[m++] = p[i];
}
if (n > 1) m--;
return m;
}
Point f[maxn], h[maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
f[5 * i - 5].read();
double x = f[5 * i - 5].x;
double y = f[5 * i - 5].y;
f[5 * i - 1].x = x + 1;
f[5 * i - 1].y = y;
f[5 * i - 2].x = x - 1;
f[5 * i - 2].y = y;
f[5 * i - 3].x = x;
f[5 * i - 3].y = y + 1;
f[5 * i - 4].x = x;
f[5 * i - 4].y = y - 1;
}
n = getConvexHull(f, 5 * n, h);
int x = h[0].x;
int y = h[0].y;
long long ans = 0;
h[n + 1] = h[0];
for (int i = 1; i <= n; i++) {
int X = abs(h[i].x - x);
int Y = abs(h[i].y - y);
x = h[i].x;
y = h[i].y;
ans += max(X, Y);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
vector<long long> div;
for (long long i = 1; i <= (int)sqrt(a * b); i++) {
if ((a * b) % i == 0) {
div.push_back((a * b) / i);
div.push_back(i);
}
}
long long minimo = 9999999999999;
for (int i = 0; i < div.size(); i++) {
if (div[i] % a == 0 & div[i] % b == 0) {
minimo = min(minimo, div[i]);
}
}
vector<long long> dia, dib;
for (long long i = a; i <= minimo; i += a) {
dia.push_back(i);
}
for (long long i = b; i <= minimo; i += b) {
dib.push_back(i);
}
long long cnta = 0, cntb = 0, conta = 0, contb = 0, tiempo = 1;
while (tiempo <= minimo) {
long long vara = *lower_bound(dia.begin(), dia.end(), tiempo);
long long varb = *lower_bound(dib.begin(), dib.end(), tiempo);
if (vara == varb) {
if (cnta < cntb) {
conta += (vara - (tiempo - 1));
} else {
contb += (varb - (tiempo - 1));
}
break;
}
if (vara < varb) {
cnta++;
conta += (vara - (tiempo - 1));
tiempo = vara + 1;
} else {
cntb++;
contb += (varb - (tiempo - 1));
tiempo = varb + 1;
}
}
if (conta == contb) {
cout << "Equal" << endl;
} else if (conta > contb) {
cout << "Dasha" << endl;
} else {
cout << "Masha" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using ll = long long;
const int MN = 2e5 + 100;
int N;
struct node {
public:
node *l, *r;
ll v, z;
node() : l(nullptr), r(nullptr), v(0LL), z(0LL){};
};
const int pool_sz = 50000;
node *pool;
int pool_ctr;
node *nn(node *p = nullptr) {
if (!pool_ctr) pool = new node[pool_ctr = pool_sz];
if (p) pool[pool_ctr - 1] = *p;
return pool + --pool_ctr;
}
void upd(node *&n, int l, int r, int ql, int qr, ll q) {
n = nn(n);
n->v += (qr - ql) * q;
if (ql == l && r == qr)
n->z += q;
else {
int m = l + (r - l) / 2;
if (ql < m) upd(n->l, l, m, ql, std::min(qr, m), q);
if (m < qr) upd(n->r, m, r, std::max(m, ql), qr, q);
}
}
ll qry(node *n, int l, int r, int ql, int qr) {
if (!n) return 0LL;
ll f = 0LL;
if (ql == l && r == qr)
return n->v;
else {
f = n->z * (qr - ql);
int m = l + (r - l) / 2;
if (ql < m) f += qry(n->l, l, m, ql, std::min(qr, m));
if (m < qr) f += qry(n->r, m, r, std::max(m, ql), qr);
return f;
}
}
struct S {
public:
node *n;
int t;
};
std::vector<S> m[MN];
int lb(int k, int v) {
int l = 0, r = m[k].size();
for (; r - l > 1;) {
int x = l + (r - l) / 2;
if (m[k][x].t < v)
l = x;
else
r = x;
}
return r;
}
struct R {
public:
int m;
mutable int t;
R(int m = -1, int t = 0) : m(m), t(t) {}
bool operator<(R o) const { return m < o.m; }
};
std::set<R> r;
void fix(std::set<R>::iterator it, int i, bool over = 0) {
int v = it->m;
S x = m[v].back();
if (over && x.t == i) return;
if (!over) assert(x.t != i);
node *n = x.n;
upd(n, 0, N, std::next(it)->t, it->t, i - x.t);
m[v].push_back(S{n, i});
}
void fix(int v, int i, bool over = 0) {
if (over && m[v].back().t == i) return;
if (!over) assert(m[v].back().t < i);
m[v].push_back(S{m[v].back().n, i});
}
int p[MN];
ll getper(int k, int i, int l, int r) {
if (i == m[k].size()) {
std::set<R>::iterator it = ::r.lower_bound({k, 0});
return it->m == k
? std::max(0LL,
static_cast<ll>(std::min(r, it->t) -
std::max(l - 1, std::next(it)->t)))
: 0LL;
}
return (qry(m[k][i].n, 0, N, l - 1, r) - qry(m[k][i - 1].n, 0, N, l - 1, r)) /
(m[k][i].t - m[k][i - 1].t);
}
ll P;
void convert(int i, int *a, int *l, int *r, int *k) {
*a = (*a + P) % (N + 1);
*l = (*l + P) % i + 1;
*r = (*r + P) % i + 1;
if (*r < *l) *l ^= *r ^= *l ^= *r;
*k = (*k + P) % (N + 1);
}
void ans_q(int i) {
int a, l, r, k;
scanf("%d%d%d%d", &a, &l, &r, &k);
convert(i, &a, &l, &r, &k);
p[a] = i;
std::set<R>::iterator it;
it = ::r.lower_bound({a});
if (it->m == a) fix(it, i);
for (int j = a, k = i; it->m == j; ++j) {
k = std::min(k, p[j]);
if (k >= it->t)
k = it->t, it = ::r.erase(it);
else
++it;
if (k <= it->t) break;
if (it->m == j + 1)
fix(it, i), it->t = k;
else
fix(j + 1, i), it = ::r.insert(R{j + 1, k}).first;
}
if (a)
if ((it = ::r.begin())->m)
fix(0, i), ::r.insert(R{0, i});
else
fix(it, i), ++it->t;
else if ((it = ::r.begin())->m == 1)
fix(it, i, 1), ++it->t;
else if (it->m > 1)
fix(1, i, 1), ::r.insert(R{1, i});
P = 0LL;
int u, v;
u = lb(k, l);
v = lb(k, r + 1) - 1;
assert(v + 1 >= u);
if (u > v) return printf("%lld\n", P = getper(k, u, l, r) * (u - v)), void();
if (u < v)
P = qry(m[k][v].n, 0, N, l - 1, r) - qry(m[k][u].n, 0, N, l - 1, r);
if (l < m[k][u].t) P += getper(k, u, l, r) * (m[k][u].t - l);
P += getper(k, v + 1, l, r) * (r - m[k][v].t + 1);
printf("%lld\n", P);
}
int main(void) {
scanf("%d", &N);
for (int i = 0; i <= N; i++) m[i].assign(1, S{nullptr, 0});
r.clear();
r.insert(R{MN, 0});
for (int i = 1; i <= N; i++) ans_q(i);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 100000 + 10;
vector<int> val[maxn];
vector<int> ver[maxn];
int n, m, u, v, w;
void re(int o) {
ver[v].erase(ver[v].begin() + o);
val[v].erase(val[v].begin() + o);
}
void pu(int a, int b, int c) {
val[v].push_back(b);
ver[v].push_back(c);
}
struct he {
int from, to, w;
} HMM[maxn];
bool cmp(he a, he b) { return a.w < b.w; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
HMM[i].from = u;
HMM[i].to = v;
HMM[i].w = w;
}
int over = 0;
sort(HMM + 1, HMM + m + 1, cmp);
for (int i = 1; i <= m; i++) {
u = HMM[i].from;
v = HMM[i].to;
w = HMM[i].w;
int ks = 1;
for (int j = 0; j < val[u].size(); j++) {
int t = val[u][j];
int st = ver[u][j];
if (t < w && st + 1 > ks) {
ks = st + 1;
}
}
if (val[v].size() == 2) {
if (w != val[v][0] && ks > ver[v][1]) {
if (ver[v][0] < ver[v][1]) {
re(0);
pu(u, w, ks);
} else {
re(1);
pu(u, w, ks);
}
} else if (ks > ver[v][1]) {
re(1);
pu(u, w, ks);
}
} else {
pu(u, w, ks);
}
over = max(over, ks);
}
printf("%d\n", over);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int n;
int d[maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &d[i]);
sort(d, d + n);
printf("%d", d[n - 1]);
for (int i = 1; i < n - 1; ++i) printf(" %d", d[i]);
printf(" %d\n", d[0]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long> b, c, d, e;
map<long, long> fix;
long n, m, i, j, k, l, k1, a[100000], p, x;
int main() {
cin >> n >> k1;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a, a + n + 1);
b.push_back(0);
c.push_back(0);
d.push_back(0);
e.push_back(0);
for (i = 1; i <= n; i++) {
if (b.size() >= k1 + 1) break;
k = b.size();
for (j = 0; j < k; j++)
if (fix[b[j] + a[i]] != 1) {
fix[b[j] + a[i]] = 1;
b.push_back(b[j] + a[i]);
c.push_back(a[i]);
d.push_back(j);
e.push_back(e[j] + 1);
}
}
for (j = 1; j <= k1; j++) {
p = b[j];
x = j;
cout << e[j] << " ";
while (p > 0) {
cout << c[x] << " ";
p -= c[x];
x = d[x];
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int fexpo(long long int a, long long int b) {
if (b == 0) return 1LL;
if (b == 1) return a;
if (b == 2) return ((a % mod) * (a % mod)) % mod;
if (b % 2 == 0)
return fexpo(fexpo(a, b / 2), 2);
else
return ((a % mod) * (fexpo(fexpo(a, (b - 1) / 2), 2) % mod));
}
int ar[100000];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
while (q--) {
int l, r, num;
cin >> l >> r >> num;
int range = abs(l - r) + 1;
if (num > r || num < l) {
cout << "Yes" << endl;
continue;
} else {
int leftmb = 0;
int rightmc = 0;
for (int i = l; i < num; i++) {
if (ar[num] < ar[i]) leftmb++;
}
for (int i = num + 1; i <= r; i++) {
if (ar[num] > ar[i]) rightmc++;
}
if (rightmc == leftmb)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, max = 0, flag = 1;
vector<int> val(26);
long long sum = 0;
string s;
cin >> s;
cin >> k;
for (int i = 0; i < 26; i++) {
cin >> val[i];
if (val[i] > max) max = val[i];
}
for (int i = s.size() - 1; i >= 0; i--) {
int j = ((int)s[i]) - 97;
if (flag) {
if (val[j] > max)
sum = sum + val[j] * (i + k + 1);
else {
sum = sum + val[j] * (i + 1) + max * (((2 * (i + 2) + k - 1) * k) / 2);
flag = 0;
}
} else
sum = sum + (i + 1) * val[j];
}
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct queries {
int start;
int end;
int index;
};
int n;
int bucketsize;
long long int ans[1000010];
int nums[1000010];
int vals[1000010];
vector<queries> v;
bool comp(queries a, queries b) {
if ((a.start / bucketsize) != (b.start / bucketsize))
return (a.start / bucketsize) < (b.start / bucketsize);
else
return (a.end < b.end);
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
queries temp;
int t;
cin >> n >> t;
bucketsize = 2 * sqrt(n);
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
for (int i = 0; i < t; i++) {
temp.index = i;
cin >> temp.start;
temp.start--;
cin >> temp.end;
temp.end--;
v.push_back(temp);
}
sort(v.begin(), v.end(), comp);
int start = 0, end = 0;
long long int cval = nums[0];
vals[nums[0]]++;
for (int i = 0; i < t; i++) {
while (v[i].start < start) {
start--;
cval += (2 * 1LL * vals[nums[start]] + 1) * nums[start];
vals[nums[start]]++;
}
while (v[i].start > start) {
cval -= (2 * 1LL * vals[nums[start]] - 1) * nums[start];
vals[nums[start]]--;
start++;
}
while (v[i].end > end) {
end++;
cval += (2 * 1LL * vals[nums[end]] + 1) * nums[end];
vals[nums[end]]++;
}
while (v[i].end < end) {
cval -= (2 * 1LL * vals[nums[end]] - 1) * nums[end];
vals[nums[end]]--;
end--;
}
ans[v[i].index] = cval;
}
for (int i = 0; i < t; i++) {
cout << ans[i] << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
int n, q, a[MX], fin[MX], cn, mx, res;
map<int, int> mp;
void solve() {
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
fin[a[i]] = i;
mp[a[i]]++;
}
for (int i = 0, to = 0; i < n; i++) {
to = max(to, fin[a[i]]);
mx = max(mx, mp[a[i]]);
cn++;
if (i == to) {
res += cn - mx;
cn = mx = 0;
}
}
cout << res << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
while (cin >> x) {
int length = x.length();
char str[4];
for (int i = 0; i < length; i += 4) {
if (x[i] != '!') {
str[0] = x[i];
break;
}
}
for (int i = 1; i < length; i += 4) {
if (x[i] != '!') {
str[1] = x[i];
break;
}
}
for (int i = 2; i < length; i += 4) {
if (x[i] != '!') {
str[2] = x[i];
break;
}
}
for (int i = 3; i < length; i += 4) {
if (x[i] != '!') {
str[3] = x[i];
break;
}
}
int aa = 0, ab = 0, ac = 0, ad = 0;
for (int i = 0; i < length; ++i) {
if (x[i] != str[i % 4]) {
if (str[i % 4] == 'R')
aa++;
else if (str[i % 4] == 'B')
ab++;
else if (str[i % 4] == 'Y')
ac++;
else if (str[i % 4] == 'G')
ad++;
}
}
printf("%d %d %d %d\n", aa, ab, ac, ad);
}
}
| 1 |
#include <bits/stdc++.h>
int data[1010];
double C(int a, int b) {
double res = 1;
int i;
for (i = b; i >= 1; --i) res *= ((double)(a - i + 1) / i);
return res;
}
int main() {
int n, m, h, i;
scanf("%d%d%d", &n, &m, &h);
int sum = 0;
for (i = 1; i <= m; i++) {
scanf("%d", &data[i]);
if (i != h) sum += data[i];
}
if (sum + data[h] < n)
printf("-1.0\n");
else if (sum < n - 1)
printf("1.0\n");
else {
double a = C(sum, n - 1);
double b = C(sum + data[h] - 1, n - 1);
printf("%.9f", 1.0 - (a / b));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct t {
int l;
int r;
int id;
} all[200005];
vector<int> ans;
bool cmp(struct t t1, struct t t2) {
if (t1.l == t2.l)
return t1.r < t2.r;
else
return t1.l < t2.l;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &all[i].l, &all[i].r);
all[i].id = i;
}
sort(all + 1, all + 1 + n, cmp);
set<pair<int, int> > s;
for (int i = 1; i <= n; i++) {
while (!s.empty()) {
if ((*s.begin()).first < all[i].l) {
s.erase(s.begin());
} else {
break;
}
}
s.insert({all[i].r, all[i].id});
if (s.size() > k) {
auto it = s.end();
it--;
ans.push_back((*it).second);
s.erase(it);
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long 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;
}
long long n, k;
long long rev_2;
long long bit[65];
inline long long quickpow(long long a, long long b, long long MOD) {
long long s = 1;
while (b) {
if (b & 1) s = (s * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return s;
}
int main() {
rev_2 = quickpow(2, 1000003 - 2, 1000003);
bit[0] = 1;
for (int i = 1; i < 63; i++) bit[i] = bit[i - 1] << 1;
n = read();
k = read();
if (n <= 60 && k > bit[n]) {
puts("1 1");
return 0;
}
if (k == 1) {
puts("0 1");
return 0;
}
long long mx = quickpow(2, n, 1000003), now = mx;
long long ans1 = 1, ans2 = 1;
long long te = k - 1, sum = n;
while (te) {
sum += te / 2;
te >>= 1;
}
long long sv = k;
for (long long i = 1; i <= min(sv, (long long)1000003); i++) {
k--;
ans2 = (ans2 * mx) % 1000003;
ans1 = (ans1 * now) % 1000003;
now--;
if (!now) now += 1000003;
}
if (k) {
while (k % (1000003 - 1) != 0) ans2 = (ans2 * mx) % 1000003, k--;
}
ans1 = (ans1 * quickpow(rev_2, sum, 1000003)) % 1000003;
ans2 = (ans2 * quickpow(rev_2, sum, 1000003)) % 1000003;
printf("%lld %lld\n", (ans2 - ans1 + 1000003) % 1000003, ans2);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
const int NN = 1000001;
int ord[NN * 2], cnt[NN];
const int sma = 26;
struct automaton {
int sz, ed;
INT ans;
struct node {
int deep, fail, nxt[sma];
INT val;
void clear() {
for (int i = 0; i < sma; i++) nxt[i] = -1;
fail = 0;
deep = 0;
val = 0;
}
} mem[NN * 2];
void init() {
mem[1].clear();
mem[0].clear();
for (int i = 0; i < sma; i++) mem[0].nxt[i] = 1;
mem[0].deep = -1;
sz = 2;
ed = 1;
ans = 0;
return;
}
void insert(int c, int w) {
if (mem[ed].nxt[c] != -1) {
int p1 = mem[ed].nxt[c];
if (mem[p1].deep == mem[ed].deep + 1) {
mem[p1].val += w;
ed = p1;
return;
}
int p2 = sz++;
mem[p2] = mem[p1];
mem[p2].val = w;
mem[p2].deep = mem[ed].deep + 1;
mem[p1].fail = p2;
while (ed != -1 and mem[ed].nxt[c] == p1) {
mem[ed].nxt[c] = p2;
ed = mem[ed].fail;
}
ed = p2;
return;
}
int p = sz++;
mem[p].clear();
mem[p].deep = mem[ed].deep + 1;
mem[p].val = w;
while (mem[ed].nxt[c] == -1) {
mem[ed].nxt[c] = p;
ed = mem[ed].fail;
}
int p1 = mem[ed].nxt[c];
if (mem[p1].deep == mem[ed].deep + 1)
mem[p].fail = p1;
else {
int p2 = sz++;
mem[p2] = mem[p1];
mem[p2].val = 0;
mem[p2].deep = mem[ed].deep + 1;
mem[p1].fail = mem[p].fail = p2;
while (mem[ed].nxt[c] == p1) {
mem[ed].nxt[c] = p2;
ed = mem[ed].fail;
}
}
ed = p;
return;
}
void build(int n) {
for (int i = 0; i < n + 3; i++) cnt[i] = 0;
for (int i = 1; i < sz; i++) cnt[mem[i].deep]++;
for (int i = 1; i < n + 3; i++) cnt[i] += cnt[i - 1];
for (int i = 1; i < sz; i++) ord[--cnt[mem[i].deep]] = i;
for (int i = sz - 2; i >= 0; i--) {
int cur = ord[i];
int prv = mem[cur].fail;
if (~prv) mem[prv].val += mem[cur].val;
}
return;
}
INT solve() {
for (int i = 1; i < sz; i++) {
ans = max(ans, 1ll * mem[i].deep * mem[i].val);
}
return ans;
}
} sam;
char s[NN];
string str[NN];
int cost[NN];
int main() {
sam.init();
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%s", s);
str[i] = s;
}
int l = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", cost + i);
l += str[i].length();
sam.ed = 1;
for (int j = 0; j < str[i].length(); j++) {
sam.insert(str[i][j] - 'a', cost[i]);
}
}
sam.build(l);
cout << sam.solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool compare(int a, int b) { return a > b; }
int main() {
long long n, a[100005], b[100005], sum = 0;
cin >> n;
for (long long i = 0; i <= n - 1; i += 1) {
cin >> a[i];
sum += a[i];
}
for (long long i = 0; i <= n - 1; i += 1) cin >> b[i];
if (n == 1) {
cout << "NO" << endl;
return 0;
}
sort(b, b + n, compare);
if (sum <= b[0] + b[1])
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50001 * 3;
complex<long long> a[N], b[N], O;
int _;
int A(const complex<long long>& a) {
return (a.real() >= 0) ^ ((a.imag() < 0) + 1);
}
long long cross(const complex<long long>& a, const complex<long long>& b) {
return (conj(a) * b).imag();
}
bool Cmp(const complex<long long>& a, const complex<long long>& b) {
int x = A(a), y = A(b);
if (x != y) return x < y;
return cross(a, b) > 0;
}
map<long long, complex<long long> > h1, h2;
bool in(map<long long, complex<long long> >& h, long long x, long long y) {
if (!(int)(h).size()) return false;
if (x < h.begin()->second.real() || x > h.rbegin()->second.real())
return false;
auto l = h.lower_bound(x);
if (x == l->second.real()) return y <= l->second.imag();
auto r = l--;
return cross(r->second - l->second, complex<long long>(x, y) - l->second) <=
0;
}
void ins(map<long long, complex<long long> >& h, long long x, long long y) {
if (in(h, x, y)) return;
complex<long long> p(x, y);
h[x] = p;
auto LL = h.find(x), RR = LL, L = LL, R = L;
if (LL != h.begin()) --LL;
if (*RR != *h.rbegin()) ++RR;
if (L != h.begin())
while ((L = LL) != h.begin()) {
--(LL = L);
if (cross(p - LL->second, L->second - LL->second) <= 0)
h.erase(L);
else
break;
}
if (*R != *h.rbegin())
while (*(R = RR) != *h.rbegin()) {
++(RR = R);
if (cross(p - RR->second, R->second - RR->second) >= 0)
h.erase(R);
else
break;
}
}
int main() {
_ = 0;
O = complex<long long>(0, 0);
for (int re = 0; re < (3); ++re) {
int n;
scanf("%d", &n);
int id = 0;
for (int i = 0; i < (n); ++i) {
int x, y;
scanf("%d%d", &x, &y);
a[i] = complex<long long>(x, y);
if (a[i].imag() < a[id].imag() ||
(a[i].imag() == a[id].imag() && a[i].real() < a[id].real()))
id = i;
}
O += a[id];
a[n] = a[0];
int __ = _;
for (int i = id; i < (n); ++i) b[__++] = a[i + 1] - a[i];
for (int i = 0; i < (id); ++i) b[__++] = a[i + 1] - a[i];
inplace_merge(b, b + _, b + __, Cmp);
_ = __;
}
a[0] = O;
for (int i = 0; i < (_); ++i) a[i + 1] = a[i] + b[i];
for (int i = 0; i < (_); ++i)
ins(h1, a[i].real(), a[i].imag()), ins(h2, a[i].real(), -a[i].imag());
int m;
scanf("%d", &m);
for (int i = 0; i < (m); ++i) {
int x, y;
scanf("%d%d", &x, &y);
x *= 3;
y *= 3;
puts(in(h1, x, y) && in(h2, x, -y) ? "YES" : "NO");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const long long MOD = 1e9 + 7;
const int dx[] = {0, 1, 0, 1};
const int dy[] = {0, 0, 1, 1};
const long long N = (long long)5001;
const int H = 22;
const double EPS = 1e-10;
const double PI = 3.14159265358979323846;
const int SZ = 550;
const long long INF = 1e1;
const int MAXN = 2e5 + 2;
long long bp(long long x, long long st) {
if (st == 0) return 1;
if (st & 1) return x * bp(x, st - 1) % MOD;
return bp(x * x % MOD, st / 2);
}
long long C[51][51];
long long c(int n, int k) {
if (k == 0 || k == n) return 1;
if (C[n][k] != 0) return C[n][k];
return C[n][k] = (c(n - 1, k) + c(n - 1, k - 1)) % MOD;
}
vector<int> g[MAXN], ex[MAXN];
int gcd(int x, int y) {
if (x == 0) return y;
return gcd(y % x, x);
}
int del[MAXN], id = 0, n;
void dec(int x, int v, int u) {
for (int d = 2; d * d <= x; d++) {
bool f = 0;
while (x % d == 0) {
x /= d;
f = 1;
}
if (f) ex[d].push_back(v), ex[d].push_back(u);
}
if (x > 1) ex[x].push_back(v), ex[x].push_back(u);
}
int us[MAXN], dist[MAXN];
int dm = 0;
void dfs(int v, int d) {
us[v] = 1;
int mx1 = 0, mx2 = 0;
for (int to : g[v]) {
if (del[to] % d != 0) continue;
if (us[to] == 0) {
dfs(to, d);
}
if (dist[to] > mx1) {
mx2 = mx1;
mx1 = dist[to];
} else {
mx2 = max(mx2, dist[to]);
}
}
dist[v] = 1 + mx1;
dm = max(dm, 1 + mx1 + mx2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
bool f = 0;
for (int i = 0; i < n; i++) {
cin >> del[i];
if (del[i] != 1) f = 1;
}
if (!f) {
cout << 0;
return 0;
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
dec(gcd(del[x], del[y]), x, y);
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 1;
for (int i = 2; i < 200000; i++) {
if (ex[i].size() == 0) continue;
for (int v : ex[i]) {
dm = 0;
if (!us[v]) dfs(v, i);
ans = max(dm, ans);
}
for (int v : ex[i]) {
us[v] = 0;
dist[v] = 0;
}
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 250009;
int n, p, k, jc[N], ijc[N], f[23][N];
int qp(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = a * 1ll * a % p)
if (b & 1) r = r * 1ll * a % p;
return r;
}
int get(int t, int s) {
if (~f[t][s]) return f[t][s];
if (!s) {
int w = jc[n], i = 1;
for (; i <= t; ++i) w = w * 1ll * (k - i + 1) % p;
return f[t][s] = w;
}
int i, w = 0, u = s - (s & -s);
for (i = u;; i = i - 1 & u)
if (w = (w + get(t + 1, i) * 1ll * ijc[s - i]) % p, !i) break;
return f[t][s] = w;
}
int main() {
int i;
if (scanf("%d%d%d", &n, &k, &p), n & 1) printf("%d", qp(k, n)), exit(0);
for (jc[0] = i = 1; i <= n; ++i) jc[i] = jc[i - 1] * 1ll * i % p;
for (ijc[n] = qp(jc[i = n], p - 2); i; --i) ijc[i - 1] = ijc[i] * 1ll * i % p;
memset(f, -1, sizeof f), printf("%d", (qp(k, n) - get(0, n) + p) % p);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 150001;
int main() {
int n, k;
cin >> n >> k;
int deno = 2 * k + 1;
int start;
int temp = 2 * (k) + 1;
if (n % deno == 0) {
start = k + 1;
cout << (n / deno) << endl;
for (int i = start; i <= n; i += temp) {
cout << i << " ";
}
cout << endl;
} else {
int rem = n % deno;
cout << n / deno + 1 << endl;
if (rem < k + 1) {
cout << 1 << " ";
start = 1 + k + k + 1;
for (int i = start; i <= n; i += temp) {
cout << i << " ";
}
cout << endl;
} else {
start = k + 1;
for (int i = start; i <= n; i += temp) {
cout << i << " ";
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100][100];
signed main() {
int n, k;
cin >> n >> k;
int mid = (k + 1) / 2;
int m;
for (int request = 0; request < n; request++) {
cin >> m;
int ans = 1e9, xcur = 1e9, ycur = 1e9;
for (int i = 1; i <= k; i++) {
for (int j = 1; j + m - 1 <= k; j++) {
bool ok = true;
for (int temp = j; temp < m + j; temp++) {
if (a[i][temp] > 0) {
ok = false;
break;
}
}
if (ok == true) {
int ans1 = 0;
for (int temp = j; temp < m + j; temp++) {
ans1 += abs(i - mid) + abs(temp - mid);
}
if (ans1 < ans) {
ans = ans1;
xcur = i;
ycur = j;
}
}
}
}
if (ans == 1e9)
cout << -1 << '\n';
else {
cout << xcur << " " << ycur << " " << ycur + m - 1 << '\n';
for (int j = ycur; j < ycur + m; j++) a[xcur][j] = 1;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, m, q;
int a[N];
int ans[N];
int fenw[N];
map<int, int> cnt;
map<int, bool> used;
vector<int> mat[N];
vector<pair<long long, int> > vec;
void update(int i, int val) {
for (; i < N; i += i & (-i)) {
fenw[i] += val;
}
}
int query(int i) {
int ans = 0;
for (; i > 0; i -= i & (-i)) {
ans += fenw[i];
}
return ans;
}
int query(int x, int y) {
if (x > y) return 0;
return query(y) - (x > 1 ? query(x - 1) : 0);
}
int bs(int i, int d) {
int l = i, r = N - 1, ans;
while (l <= r) {
int mid = (l + r) >> 1;
if (query(i, mid) >= d) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> n >> m >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
for (int i = 0; i < q; i++) {
long long x;
cin >> x;
vec.emplace_back(make_pair(x, i));
}
vec.emplace_back(make_pair(n, -1));
sort(vec.begin(), vec.end());
for (int i = 0; i < n; i++) {
if (!used[a[i]]) {
used[a[i]] = 1;
mat[cnt[a[i]]].emplace_back(a[i]);
}
}
for (int i = 1; i <= m; i++) {
if (cnt[i] == 0) {
mat[0].emplace_back(i);
}
}
int pos = 0;
while (mat[pos].empty()) pos++;
pos--;
int lst = m + 1;
long long days = 0;
for (int i = 0; i < vec.size();) {
if (days == 0) {
if (i + 1 >= vec.size()) break;
i++;
days = vec[i].first - vec[i - 1].first;
}
if (lst == m + 1) {
if (pos < N) {
pos++;
for (int x : mat[pos]) {
update(x, 1);
}
}
lst = 1;
}
if (days == 0) {
ans[vec[i].second] = ans[vec[i - 1].second];
continue;
}
if (lst != 1) {
if (days > query(lst, N - 1)) {
days -= query(lst, N - 1);
lst = m + 1;
continue;
} else {
int here = bs(lst, days);
lst = here + 1;
ans[vec[i].second] = here;
days = 0;
}
} else {
if (days > query(lst, N - 1)) {
if (pos < N) {
days -= query(lst, N - 1);
lst = m + 1;
continue;
} else {
days %= m;
if (days == 0) days = m;
int here = bs(lst, days);
lst = here + 1;
ans[vec[i].second] = here;
days = 0;
continue;
}
} else {
int here = bs(lst, days);
lst = here + 1;
ans[vec[i].second] = here;
days = 0;
}
}
}
for (int i = 0; i < q; i++) {
cout << ans[i] << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char ch, arr[60][60];
int count, beginr, beginc, n, m, dp[60][60];
bool func(int i, int j, int temp) {
if (i >= 0 && i < ::n && j >= 0 && j < ::m) {
if (dp[i][j] == 1)
return false;
else if (dp[i][j] == 0 && (i != beginr || j != beginc))
dp[i][j] = 1;
}
if (i >= ::n || i < 0)
return false;
else if (j >= ::m || j < 0)
return false;
else if (arr[i][j] != ::ch)
return false;
else if (i == ::beginr && j == ::beginc && temp > 2)
return true;
else if (i == ::beginr && j == ::beginc && temp == 2)
return false;
else {
if (func(i + 1, j, temp + 1) || func(i, j + 1, temp + 1) ||
func(i - 1, j, temp + 1) || func(i, j - 1, temp + 1)) {
::count++;
return true;
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> ::n >> ::m;
for (int i = 0; i < ::n; i++) {
for (int j = 0; j < ::m; j++) cin >> arr[i][j];
}
for (int i = 0; i < ::n; i++) {
for (int j = 0; j < ::m; j++) {
memset(dp, 0, sizeof(dp));
::count = 0;
::ch = arr[i][j];
::beginr = i;
::beginc = j;
if (func(i, j, 0)) {
if (::count >= 4) {
cout << "Yes";
return 0;
}
}
}
}
cout << "No";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005, inf = 0x3f3f3f3f;
const long long llinf = 0x3f3f3f3f3f3f3f3f;
const long double pi = acos(-1.0L);
int a[maxn], b[maxn];
int main() {
unordered_map<int, int> mp;
int n, i, j, cnt = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), mp[a[i]] = 1;
for (i = 1; i <= n; i++) scanf("%d", &b[i]), mp[b[i]] = 1;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (mp[a[i] ^ b[j]]) cnt++;
}
}
if (cnt % 2 == 0)
cout << "Karen";
else
cout << "Koyomi";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool arr[1010][1010] = {0};
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= k; i++) {
int a, b;
cin >> a >> b;
arr[a][b] = true;
int foo = arr[a][b] + arr[a - 1][b] + arr[a - 1][b - 1] + arr[a][b - 1];
if (foo == 4) cout << i << endl, exit(0);
foo = arr[a][b] + arr[a - 1][b] + arr[a - 1][b + 1] + arr[a][b + 1];
if (foo == 4) cout << i << endl, exit(0);
foo = arr[a][b] + arr[a + 1][b] + arr[a + 1][b + 1] + arr[a][b + 1];
if (foo == 4) cout << i << endl, exit(0);
foo = arr[a][b] + arr[a + 1][b] + arr[a + 1][b - 1] + arr[a][b - 1];
if (foo == 4) cout << i << endl, exit(0);
}
puts("0");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000, M = 30;
int n, x[N], y[N], xx[N], yy[N], b[M], u[N];
void xo(int *x, vector<pair<int, int>> &rx, int l, int r) {
rx.push_back({l + 1, r + 1});
x[l] ^= x[r];
}
void sw(int *x, vector<pair<int, int>> &rx, int l, int r) {
if (l != r) {
xo(x, rx, l, r);
xo(x, rx, r, l);
xo(x, rx, l, r);
}
}
int BT(int a, int p) { return bool(a & (1 << p)); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &x[i]), xx[i] = x[i];
for (int i = 0; i < n; ++i) scanf("%d", &y[i]), yy[i] = y[i];
vector<pair<int, int>> rx, ry;
for (int i = 0; i < M; ++i) {
int m = -1, bi = 1 << i;
for (int j = 0; j < n; ++j)
if (!u[j] && (x[j] & bi)) m = j;
b[i] = m;
if (m == -1) continue;
u[m] = 1;
for (int j = 0; j < n; ++j)
if ((x[j] & bi) && (j != m)) xo(x, rx, j, m);
}
for (int i = 0; i < n; ++i) {
int t = y[i];
for (int j = 0; j < M; ++j)
if (t & (1 << j)) {
if (b[j] == -1) {
puts("-1");
return 0;
}
t ^= x[b[j]];
}
if (t) throw;
}
for (int i = 0; i < n; ++i) u[i] = 0;
for (int i = 0; i < M; ++i) {
int m = -1, bi = 1 << i;
for (int j = 0; j < n; ++j)
if (!u[j] && (y[j] & bi)) m = j;
if (m == -1) {
if (b[i] != -1) xo(x, rx, b[i], b[i]);
continue;
}
if (b[i] == -1) throw;
sw(y, ry, b[i], m);
m = b[i];
u[m] = 1;
for (int j = 0; j < M; ++j)
if (BT(x[m], j) != BT(y[m], j)) {
if (j <= i) throw;
if (b[j] == -1) throw;
xo(x, rx, m, b[j]);
}
for (int j = 0; j < n; ++j)
if (!u[j] && (y[j] & bi)) {
xo(y, ry, j, m);
}
}
for (int i = ry.size(); i; --i) rx.push_back(ry[i - 1]);
printf("%d\n", rx.size());
for (int i = 0; i < rx.size(); ++i)
printf("%d %d\n", rx[i].first, rx[i].second);
for (int i = 0; i < rx.size(); ++i) {
xx[rx[i].first - 1] ^= xx[rx[i].second - 1];
}
for (int i = 0; i < n; ++i)
if (xx[i] != yy[i]) throw;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, l, r, sk, sall;
ios::sync_with_stdio(false);
cin >> n >> k >> l >> r >> sall >> sk;
long long int temp, temp2;
long long int ans[n + 1];
long long int i = 0;
temp = sk / k;
for (i = 0; i < k; i++) ans[i] = temp;
temp = sk % k;
i = 0;
while (temp > 0) {
ans[i] += 1;
temp--;
i++;
}
if (n == k) {
for (i = 0; i < n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
temp = (sall - sk) / (n - k);
temp2 = (sall - sk) % (n - k);
i = k;
while (i < n) {
ans[i] = temp;
if (temp2 > 0) ans[i] += 1;
temp2--;
i++;
}
for (i = 0; i < n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, tot, cnt, blk;
struct Node {
int ch[26], pre;
} P[100005];
struct Query {
int x, k, d;
Query() {}
Query(int a, int b, int c) { x = a, k = b, d = c; }
};
int lp[100005], rp[100005], Q[100005], pos[100005];
int fir[100005], tar[100005], nex[100005], dfn[100005], out[100005], tim;
long long ans[100005], s[100005], w[1000];
char S[100005];
vector<Query> V1[100005], V2[100005];
vector<Query>::iterator it;
void Build() {
int h = 1, t = 0;
Q[++t] = 1;
while (h <= t) {
int x = Q[h++];
for (int i = 0; i < 26; i++) {
if (P[x].ch[i]) {
Q[++t] = P[x].ch[i];
if (x == 1)
P[P[x].ch[i]].pre = 1;
else
P[P[x].ch[i]].pre = P[P[x].pre].ch[i];
} else {
if (x == 1)
P[x].ch[i] = 1;
else
P[x].ch[i] = P[P[x].pre].ch[i];
}
}
}
}
bool cmp(const Query &a, const Query &b) { return a.x < b.x; }
void Add(int a, int b) {
++cnt;
tar[cnt] = b;
nex[cnt] = fir[a];
fir[a] = cnt;
}
void Dfs(int x) {
dfn[x] = ++tim;
for (int i = fir[x]; i; i = nex[i]) Dfs(tar[i]);
out[x] = tim;
}
void Update(int a, int b) {
int c = a / blk, d = b / blk;
if (c == d)
for (int i = a; i <= b; i++) s[i]++;
else {
for (int i = a; i < (c + 1) * blk; i++) s[i]++;
for (int i = d * blk; i <= b; i++) s[i]++;
for (int i = c + 1; i < d; i++) w[i]++;
}
}
int main() {
scanf("%d%d", &n, &m);
tot = 1;
for (int i = 1; i <= n; i++) {
lp[i] = rp[i - 1];
scanf("%s", S + lp[i]);
rp[i] = lp[i] + strlen(S + lp[i]);
int u = 1;
for (int j = lp[i]; j < rp[i]; j++) {
int v = S[j] - 'a';
if (!P[u].ch[v]) P[u].ch[v] = ++tot;
u = P[u].ch[v];
}
pos[i] = u;
}
Build();
blk = int(sqrt(double(tot + 1)));
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (rp[c] - lp[c] > blk) {
if (a != 1) V2[c].push_back(Query(a - 1, -1, i));
V2[c].push_back(Query(b, 1, i));
} else {
if (a != 1) V1[a - 1].push_back(Query(c, -1, i));
V1[b].push_back(Query(c, 1, i));
}
}
for (int i = 2; i <= tot; i++) Add(P[i].pre, i);
Dfs(1);
for (int i = 1; i <= n; i++) {
Update(dfn[pos[i]], out[pos[i]]);
for (it = V1[i].begin(); it != V1[i].end(); it++) {
int u = 1;
int a = it->x, b = it->k, c = it->d;
for (int j = lp[a]; j < rp[a]; j++) {
u = P[u].ch[S[j] - 'a'];
ans[c] += (s[dfn[u]] + w[dfn[u] / blk]) * b;
}
}
}
for (int i = 1; i <= n; i++)
if (rp[i] - lp[i] > blk && V2[i].size()) {
memset(s, 0, sizeof(s));
int u = 1;
for (int j = lp[i]; j < rp[i]; j++) u = P[u].ch[S[j] - 'a'], s[u]++;
for (int j = tot; j >= 2; j--) s[P[Q[j]].pre] += s[Q[j]];
sort(V2[i].begin(), V2[i].end(), cmp);
int p = 1;
long long sum = 0;
for (it = V2[i].begin(); it != V2[i].end(); it++) {
int a = it->x, b = it->k, c = it->d;
while (p <= a) sum += s[pos[p++]];
ans[c] += b * sum;
}
}
for (int i = 1; i <= m; i++) printf("%lld\n", ans[i]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int m;
bool M[5][5];
vector<int> adj1[5];
vector<int> adj2[5];
void caso() {
memset(M, 0, sizeof(M));
for (int i = 0; i < 5; ++i) adj1[i].clear(), adj2[i].clear();
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
x--, y--;
M[x][y] = 1;
M[y][x] = 1;
}
for (int i = 0; i < 5; ++i)
for (int j = i + 1; j < 5; j++)
if (M[i][j] == 1) {
adj1[i].push_back(j);
adj1[j].push_back(i);
} else {
adj2[i].push_back(j);
adj2[j].push_back(i);
}
for (int i = 0; i < 5; ++i) {
int n = adj1[i].size();
for (int j = 0; j < n; ++j)
for (int k = j + 1; k < n; ++k) {
int a = adj1[i][j];
int b = adj1[i][k];
if (M[a][b]) {
cout << "WIN\n";
return;
}
}
}
for (int i = 0; i < 5; ++i) {
int n = adj2[i].size();
for (int j = 0; j < n; ++j)
for (int k = j + 1; k < n; ++k) {
int a = adj2[i][j];
int b = adj2[i][k];
if (!M[a][b]) {
cout << "WIN\n";
return;
}
}
}
cout << "FAIL\n";
}
int main() {
while (cin >> m) caso();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int l, r;
char x, y;
string s;
cin >> n >> m;
cin >> s;
while (m--) {
cin >> l >> r >> x >> y;
--l, --r;
for (int i = l; i <= r; i++)
if (s[i] == x) s[i] = y;
}
cout << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("-O2")
int n, m, cl, ce, v, q, x1, x2, ya, y2, ans1, ans2;
int S[(int)1e5], E[(int)1e5];
int bsrch(int start, int end, int v[]) {
int mid, temp, ans = m;
while (start < end) {
mid = start + (end - start) / 2;
temp = v[mid];
if (temp >= ya && temp <= y2) {
return 0;
}
if (temp > y2) {
temp -= y2;
ans = min(ans, temp);
if (ans == temp) {
if (end == mid) return ans;
end = mid;
continue;
} else {
end--;
continue;
}
}
temp = ya - temp;
ans = min(ans, temp);
if (ans == temp) {
if (start == mid) return ans;
start = mid;
} else {
start++;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> cl >> ce >> v;
for (int i = 0; i < cl; i++) {
cin >> S[i];
}
for (int i = 0; i < ce; i++) {
cin >> E[i];
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> x1 >> ans1 >> x2 >> ans2;
ya = min(ans1, ans2);
y2 = max(ans1, ans2);
ans1 = 2 * bsrch(0, cl, S);
if (cl == 0) ans1 = (int)1e9;
ans2 = 2 * bsrch(0, ce, E);
if (ce == 0) ans2 = (int)1e9;
x2 = abs(x2 - x1);
if (x2 == 0) {
cout << y2 - ya << "\n";
continue;
}
ans1 = ans1 + x2 + y2 - ya;
if (x2 % v == 0)
ans2 = ans2 + y2 - ya + x2 / v;
else
ans2 = ans2 + y2 - ya + x2 / v + 1;
cout << min(ans1, ans2) << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double E = 2.71828182845904523536;
const long double pi = acos(-1);
const double eps = 1e-9;
const long long mod = 1e9 + 7;
const long long inf = 1LL << 30;
const int N = 111;
vector<pair<int, pair<int, int>>> ans;
int n = 4, m, k;
int a[11][N];
bool _1 = 1;
bool check() {
bool f = 0;
for (int j = 0; j < m; j++) {
if (a[1][j] == a[0][j] && a[0][j]) {
ans.push_back({a[1][j], {1, j + 1}});
a[1][j] = 0;
_1 = 0;
}
if (a[2][j] == a[3][j] && a[3][j]) {
ans.push_back({a[2][j], {4, j + 1}});
a[2][j] = 0;
_1 = 0;
}
if (a[1][j] || a[2][j]) f = 1;
}
return f;
}
bool r() {
for (int j = 0; j < m - 1; j++) {
if (a[1][j + 1] == 0 && a[1][j]) {
ans.push_back({a[1][j], {2, j + 2}});
a[1][j + 1] = a[1][j];
a[1][j] = 0;
check();
}
}
if (a[2][m - 1] == 0 && a[1][m - 1]) {
ans.push_back({a[1][m - 1], {3, m}});
a[2][m - 1] = a[1][m - 1];
a[1][m - 1] = 0;
check();
}
for (int j = 1; j < m; j++) {
if (a[2][j - 1] == 0 && a[2][j]) {
ans.push_back({a[2][j], {3, j}});
a[2][j - 1] = a[2][j];
a[2][j] = 0;
check();
}
}
if (a[1][0] == 0 && a[2][0]) {
ans.push_back({a[2][0], {2, 1}});
a[1][0] = a[2][0];
a[2][0] = 0;
check();
}
return check();
}
int main() {
scanf("%d%d", &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
check();
if (_1 && k == 2 * m) {
printf("-1");
return 0;
}
while (r())
;
printf("%d\n", ans.size());
for (auto x : ans)
printf("%d %d %d\n", x.first, x.second.first, x.second.second);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long x;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> x;
int mn = 360, res = 0;
for (int i = 0; i < 4; i++) {
int d = min(((((-x + 90 * i) % (360)) + (360)) % (360)),
360 - ((((-x + 90 * i) % (360)) + (360)) % (360)));
if (d < mn) {
mn = d;
res = i;
}
}
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> decompose(int n) {
int count_2 = 0;
int count_5 = 0;
while (!(n & 1)) {
count_2++;
n /= 2;
}
while (!(n % 5)) {
count_5++;
n /= 5;
}
return make_pair(count_2, count_5);
}
pair<int, int> comuteZeros(pair<int, int>** arr, int n) {
for (int i = 1; i < n; i++) {
arr[0][i].first += arr[0][i - 1].first;
arr[0][i].second += arr[0][i - 1].second;
}
for (int i = 1; i < n; i++) {
arr[i][0].first += arr[i - 1][0].first;
arr[i][0].second += arr[i - 1][0].second;
for (int j = 1; j < n; j++) {
arr[i][j].first += min(arr[i - 1][j].first, arr[i][j - 1].first);
arr[i][j].second += min(arr[i - 1][j].second, arr[i][j - 1].second);
}
}
n -= 1;
int& a = arr[n][n].first;
int& b = arr[n][n].second;
if (a <= b)
return make_pair(a, 2);
else
return make_pair(b, 5);
}
inline void printNSteps(int beg, int end, string& str, char c) {
for (int i = beg; i < end; i++) str[i] = c;
}
string findPath(int pos, int n) {
string path;
path.resize(2 * (n - 1));
printNSteps(0, pos, path, 'R');
printNSteps(0, n, path, 'D');
printNSteps(pos, n, path, 'R');
return path;
}
template <class T>
string findPath(pair<int, int>** arr, int n, T f) {
string path;
int size = 2 * (n - 1);
path.resize(size);
int index = size - 1;
int i = n - 1;
int j = i;
do {
if (f(arr[i][j - 1]) <= f(arr[i - 1][j])) {
path[index] = 'R';
j--;
} else {
path[index] = 'D';
i--;
}
index--;
} while (i != 0 && j != 0);
if (i == 0)
printNSteps(0, index + 1, path, 'R');
else
printNSteps(0, index + 1, path, 'D');
return path;
}
inline const int& get_2(const pair<int, int>& x) { return x.first; }
inline const int& get_5(const pair<int, int>& x) { return x.second; }
int main() {
int n;
cin >> n;
pair<int, int>** arr = new pair<int, int>*[n];
arr[0] = new pair<int, int>[n * n];
for (int i = 1; i < n; i++) arr[i] = arr[0] + i * n;
int tmp;
int zeroPosition = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> tmp;
if (!tmp) {
zeroPosition = j;
arr[i][j] = make_pair(2, 5);
} else
arr[i][j] = decompose(tmp);
}
pair<int, int> countZeros = comuteZeros(arr, n);
if (zeroPosition != -1 && countZeros.first >= 1)
cout << 1 << endl << findPath(zeroPosition, n);
else
cout << countZeros.first << endl
<< findPath(arr, n, (countZeros.second == 2) ? get_2 : get_5);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, mn, mx;
int main() {
cin >> n >> m >> mn >> mx;
int a = 101, b = -1;
for (int i = 0; i < m; i++) {
int k;
cin >> k;
a = min(a, k);
b = max(b, k);
}
if (a < mn || b > mx) {
puts("Incorrect");
return 0;
}
if (a == mn && b == mx)
puts("Correct");
else if ((a == mn || b == mx) && n - m)
puts("Correct");
else if ((n - m) >= 2)
puts("Correct");
else
puts("Incorrect");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n % 2 == 0) {
if (n / 2 % 2 == 0)
cout << 0;
else
cout << 1;
} else if ((n + 1) / 2 % 2 == 0)
cout << 0;
else
cout << 1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int x, t = 0;
bool ok = 0;
vector<int> res;
cin >> x;
for (int i = (19); i >= (0); i--) {
if (!(x & (1 << i))) {
if (ok) {
x++, t++;
ok = 0;
}
if (!(x & (1 << i))) {
res.push_back(i + 1);
x ^= ((1 << (i + 1)) - 1), t++;
ok = 1;
}
}
}
cout << t << '\n';
for (int i : res) cout << i << ' ';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long k1, k2, k3;
cin >> k1 >> k2 >> k3;
for (long long i = 1; i <= 3; i++)
for (long long j = 1; j <= 3; j++)
for (long long k = 1; k <= 3; k++) {
long long l = max(max(i, j), k);
vector<long long> a(1504);
for (long long t = i; t <= 1503; t += k1) a[t] = 1;
for (long long t = j; t <= 1503; t += k2) a[t] = 1;
for (long long t = k; t <= 1503; t += k3) a[t] = 1;
long long b = 1;
for (long long t = l; t <= 1503; t++) {
if (a[t] == 0) {
b = 0;
break;
}
}
if (b) {
cout << "YES" << '\n';
return;
}
}
cout << "NO" << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long T = 1;
while (T--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long power;
long double i = 0, k, l, r;
bool never = true;
cin >> l >> r >> k;
while (true) {
power = pow(k, i);
if (power >= l && power <= r) {
never = false;
cout << power;
}
if (power > r || power < 0) break;
if (power >= l && power <= r) cout << " ";
i++;
}
cout << endl;
if (never) cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
long long a[N], n;
long long x;
long long sum[N], sz[N];
long long c2(long long a) { return 1LL * a * (a - 1) / 2; }
bool cmp(pair<long long, long long> v, pair<long long, long long> u) {
return v < u;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
n *= 2;
for (int i = 0; i < n; i++) {
sz[i + 1] = sz[i] + a[i];
sum[i + 1] = sum[i] + (1LL * (a[i] + 1) * a[i] / 2);
}
vector<pair<long long, long long> > vec;
vec.push_back({0, 0});
long long ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= x)
ans = max(ans, c2(a[i] + 1) - c2(a[i] - x + 1));
else {
int low = -1, high = i;
pair<long long, long long> best = {-1, -1};
while (high - low > 1) {
int mid = (low + high) >> 1;
if (sz[i + 1] - sz[mid] <= x)
high = mid;
else
low = mid;
}
int j = high;
long long b = sum[i + 1] - sum[j], r = sz[i + 1] - sz[j];
if (j && x - r > 0) {
r = min(x - r, a[j - 1]);
ans = max(ans, b + c2(a[j - 1] + 1) - c2(a[j - 1] - r + 1));
} else
ans = max(ans, b);
}
vec.push_back({sz[i + 1], i + 1});
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 1;
vector<long long> v[N];
long long ans[N];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, n, k, i, j, T, f, val, mx;
cin >> t;
while (t--) {
cin >> n;
for (i = 1; i < n + 1; ++i) ans[i] = -1, v[i].push_back(0);
for (i = 1; i < n + 1; ++i) {
cin >> val;
v[val].push_back(i);
}
for (i = 1; i < n + 1; ++i) v[i].push_back(n + 1);
for (i = 1; i < n + 1; ++i) {
if ((long long)(v[i].size()) < 3) continue;
mx = 1;
for (j = 1; j < (long long)(v[i].size()); ++j)
mx = max(mx, v[i][j] - v[i][j - 1]);
for (j = mx; j <= n && ans[j] == -1; ++j) ans[j] = i;
}
for (i = 1; i < n + 1; ++i) cout << ans[i] << " ";
cout << "\n";
for (i = 1; i < n + 1; ++i) v[i].clear();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int a[N], dp[N];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, p, k, ans = 0;
scanf("%d%d%d", &n, &p, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
dp[i] = dp[i - 1] + a[i];
if (i >= k) dp[i] = min(dp[i], dp[i - k] + a[i]);
if (dp[i] <= p) ans = i;
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int tope = 1 << 20;
const int primero = 1 << 19;
int maximo[tope], anyade[tope];
void inserta(int pos, int val) {
pos += primero;
maximo[pos] = val;
while (pos > 1) {
pos /= 2;
maximo[pos] = max(maximo[2 * pos] + anyade[2 * pos],
maximo[2 * pos + 1] + anyade[2 * pos + 1]);
}
}
void acumula(int pos0, int pos1) {
if (pos0 > pos1) return;
pos0 += primero;
pos1 += primero;
if (pos0 == pos1) {
anyade[pos0]++;
} else {
anyade[pos0]++;
anyade[pos1]++;
while (pos0 + 1 < pos1) {
if (pos0 % 2 == 0) anyade[pos0 + 1]++;
pos0 /= 2;
maximo[pos0] = max(maximo[2 * pos0] + anyade[2 * pos0],
maximo[2 * pos0 + 1] + anyade[2 * pos0 + 1]);
if (pos1 % 2 == 1) anyade[pos1 - 1]++;
pos1 /= 2;
maximo[pos1] = max(maximo[2 * pos1] + anyade[2 * pos1],
maximo[2 * pos1 + 1] + anyade[2 * pos1 + 1]);
}
}
int pos = pos0;
while (pos > 1) {
pos /= 2;
maximo[pos] = max(maximo[2 * pos] + anyade[2 * pos],
maximo[2 * pos + 1] + anyade[2 * pos + 1]);
}
}
int obtenmaximo(int pos) {
pos += primero;
int m = maximo[pos] + anyade[pos];
while (pos > 1) {
if (pos % 2 == 1) m = max(m, maximo[pos - 1] + anyade[pos - 1]);
pos /= 2;
m += anyade[pos];
}
return m;
}
struct elem {
int entran;
vector<int> salen;
elem() { entran = 0; }
};
map<int, elem> mapa;
int n, r;
vector<pair<int, int> > lista;
int ilista = 0;
void insertalista(int tiempodisparo, int patosmatados, int patosmatadosantes) {
if (lista.back().second >= patosmatados) return;
inserta(int(lista.size()), patosmatadosantes);
lista.push_back(pair<int, int>(tiempodisparo, patosmatados));
mapa[tiempodisparo + r];
}
int obtenposicion(int t) {
int inf = -1;
int sup = int(lista.size());
while (inf + 1 < sup) {
int med = (inf + sup) / 2;
if (lista[med].first < t)
inf = med;
else
sup = med;
}
return sup;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> r;
for (int i = 0; i < n; i++) {
int h, t;
cin >> h >> t;
if (t < 0) continue;
h = max(h, 0);
mapa[h].entran++;
mapa[t].salen.push_back(h);
mapa[t + 1];
}
lista.push_back(pair<int, int>(-2000000005, 0));
int patosactivos = 0;
int sol = 0;
for (map<int, elem>::iterator it = mapa.begin(); it != mapa.end(); it++) {
int tiempo = it->first;
patosactivos += it->second.entran;
vector<int> &salen = it->second.salen;
while (ilista < int(lista.size()) - 1 and
lista[ilista + 1].first + r <= tiempo)
ilista++;
int patosmatadosantes = obtenmaximo(ilista);
int patosmatados = patosmatadosantes + patosactivos;
sol = max(sol, patosmatados);
insertalista(tiempo, patosmatados, patosmatadosantes);
for (int i = 0; i < int(salen.size()); i++) {
int t = salen[i];
int p = obtenposicion(t);
acumula(p, int(lista.size()) - 1);
patosactivos--;
}
}
cout << sol << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve(int TestCase) {
long long n, r1, r2, r3, d;
cin >> n >> r1 >> r2 >> r3 >> d;
vector<long long> A(n);
for (auto& x : A) cin >> x;
long long ret0 = A[0] * r1 + r3;
long long ret1 = min(r2, r1 * A[0] + r1);
for (auto i = 1; i < n; ++i) {
long long plan1 = A[i] * r1 + r3;
long long plan2 = min(r2, r1 * A[i] + r1);
long long nxt_ret0 = ret0 + d + plan1;
nxt_ret0 = min(nxt_ret0, ret0 + d + plan2 + 2 * d + r1);
nxt_ret0 = min(nxt_ret0, ret1 + 3 * d + r1 + plan1);
nxt_ret0 = min(nxt_ret0, ret1 + 3 * d + r1 + plan2 + r1);
if (i == n - 1) {
nxt_ret0 = min(nxt_ret0, ret1 + 2 * d + r1 + plan1);
}
long long nxt_ret1 = ret0 + d + plan2;
nxt_ret1 = min(nxt_ret1, ret1 + 3 * d + r1 + plan2);
swap(nxt_ret0, ret0);
swap(nxt_ret1, ret1);
}
long long ret = ret0;
cout << ret << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (auto i = 1; i <= t; ++i) {
solve(i);
}
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.