solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
int arr[N];
int main() {
int n;
while (cin >> n) {
arr[0] = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int T;
cin >> T;
int ret = 0;
for (int i = 0; i < n; i++) {
int temp = 1;
for (int j = i + 1; j < n; j++) {
if (arr[j] - arr[i] <= T)
temp++;
else
break;
}
ret = max(ret, temp);
}
cout << ret << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int high[105] = {0};
long long int place[105] = {0};
long long int mat[105][105];
int main() {
long long int n, m, k;
cin >> n >> m >> k;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
cin >> mat[i][j];
}
}
long long int totsum = 0;
long long int cng = 0;
for (long long int i = 1; i <= m; i++) {
mat[0][i] = 0;
for (long long int j = 1; j <= n; j++) mat[j][i] += mat[j - 1][i];
long long int highsum = 0;
long long int lowcng = 0;
for (long long int j = 0; j < n; j++) {
if (mat[n][i] == 0) continue;
long long int rr = n - j < k ? n : j + k;
long long int l = mat[j][i];
long long int r = mat[rr][i];
long long int sum = r - l;
if (sum > highsum) {
highsum = sum;
lowcng = l;
}
}
totsum += highsum;
cng += lowcng;
}
cout << totsum << " " << cng << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int N;
cin >> N;
vector<vector<int> > g(N);
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < N; ++i) {
char c;
cin >> c;
if (c == 'W') {
int n = g.size();
g[i].push_back(n);
g.push_back({i, n + 1, n + 2});
g.push_back({n});
g.push_back({n});
}
}
N = g.size();
vector<int> l(N);
vector<int> l2;
for (int i = 0; i < N; ++i) {
if (g[i].size() == 1) {
l[g[i][0]]++;
}
if (g[i].size() == 3) {
l2.push_back(i);
}
if (g[i].size() > 3) {
cout << "White" << endl;
return;
}
}
if (l2.size() > 2) {
cout << "White" << endl;
return;
}
for (int x : l2) {
if (l[x] < 2) {
cout << "White" << endl;
return;
}
}
if (l2.size() == 2 && N % 2 == 1) {
cout << "White" << endl;
return;
}
cout << "Draw" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12) << fixed;
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const int M = 1001 * 1001;
struct Node {
int tag, mint;
Node *lc, *rc;
inline void mdf(int _t) {
tag = max(tag, _t);
mint = max(mint, _t);
}
inline void upd() { mint = min(lc->mint, rc->mint); }
inline void sink() {
if (tag) lc->mdf(tag), rc->mdf(tag), tag = 0;
}
} pool[M * 3], *tail = pool, *rt;
int n, vx, vy;
int a[N][N];
int pos[N * N], cnt;
inline void build(Node *&rt, int l, int r) {
rt = tail++;
if (l < r) {
int mid = l + r >> 1;
build(rt->lc, l, mid);
build(rt->rc, mid + 1, r);
}
}
inline int qry(Node *rt, int l, int r, int ql, int qr) {
if (ql <= l && qr >= r)
return rt->mint;
else {
int mid = l + r >> 1;
rt->sink();
if (qr <= mid)
return qry(rt->lc, l, mid, ql, qr);
else if (ql > mid)
return qry(rt->rc, mid + 1, r, ql, qr);
else
return min(qry(rt->lc, l, mid, ql, qr), qry(rt->rc, mid + 1, r, ql, qr));
}
}
inline void mdf(Node *rt, int l, int r, int ql, int qr, int t) {
if (ql <= l && qr >= r)
rt->mdf(t);
else {
int mid = l + r >> 1;
rt->sink();
if (ql <= mid) mdf(rt->lc, l, mid, ql, qr, t);
if (qr > mid) mdf(rt->rc, mid + 1, r, ql, qr, t);
rt->upd();
}
}
inline void print(Node *rt, int l, int r) {
printf("[%d,%d] : mint=%d tag=%d\n", l, r, rt->mint, rt->tag);
if (l != r) print(rt->lc, l, l + r >> 1), print(rt->rc, (l + r >> 1) + 1, r);
}
int main() {
scanf("%d%d%d", &n, &vx, &vy);
if (vy >= 0 && vx < 0) {
vx = -vx;
for (int i = n; i >= 1; i--)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
} else if (vx >= 0 && vy < 0) {
vy = -vy;
for (int i = 1; i <= n; i++)
for (int j = n; j >= 1; j--) scanf("%d", &a[i][j]);
} else if (vx < 0 && vy < 0) {
vx = -vx;
vy = -vy;
for (int i = n; i >= 1; i--)
for (int j = n; j >= 1; j--) scanf("%d", &a[i][j]);
} else {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
}
if (!vy) {
swap(vx, vy);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) swap(a[i][j], a[j][i]);
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) pos[++cnt] = i * vy - j * vx;
sort(pos + 1, pos + cnt + 1);
cnt = unique(pos + 1, pos + cnt + 1) - pos - 1;
build(rt, 1, cnt);
long long res = 0;
for (int j = 1; j <= n; j++)
for (int i = 1; i <= n; i++)
if (a[i][j]) {
int l = vy * (i - 1) - j * vx + 1, r = vy * i - (j - 1) * vx;
l = lower_bound(pos + 1, pos + cnt + 1, l) - pos;
r = lower_bound(pos + 1, pos + cnt + 1, r) - pos;
res += max(0, a[i][j] - qry(rt, 1, cnt, l, r));
mdf(rt, 1, cnt, l, r, a[i][j]);
}
printf("%I64d\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> arr(n);
for (auto &x : arr) cin >> x;
sort(arr.begin(), arr.end());
int ans = 0;
bool greaterThanTwo = false;
for (int i = 1; i < n; ++i) {
if (arr[i] - arr[i - 1] == 1) greaterThanTwo = true;
}
if (greaterThanTwo)
cout << "2" << '\n';
else
cout << "1" << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, c, sum = 0, v, b, m = 0, arr[105], n;
scanf("%d %d", &a, &b);
for (int i = 0; i < a; i++) {
scanf("%d", &v);
arr[i] = v;
if (arr[i] > m) {
m = arr[i];
n = i;
}
}
arr[n] = 0;
for (int j = 0; j < a; j++) sum += arr[j];
if (sum > b)
printf("NO");
else
printf("YES");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[200005], b[200005], l, r;
void solve() {
cin >> n;
for (__typeof((n + 1)) i = (1); i < (n + 1); i++) cin >> a[i], b[a[i]] = i;
cout << 1;
l = b[1], r = b[1];
for (__typeof((n + 1)) i = (2); i < (n + 1); i++) {
l = min(l, b[i]);
r = max(r, b[i]);
if (r - l + 1 != i)
cout << 0;
else
cout << 1;
}
cout << "\n";
}
void prep() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
prep();
cout << fixed << setprecision(12);
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool debug = false;
int ans, X, Y;
long long gcd(long long x, long long y) {
long long z = y;
while (x % y != 0) {
z = x % y;
x = y;
y = z;
}
return z;
}
long long a[10000000];
long long ff(long long x) {
while (a[x] != x) x = a[x];
return x;
}
void dd(long long x, long long y) {
if (x > 10000000 || y > 10000000) return;
if (a[x] != 0 && a[y] != 0) {
long long fx = ff(x);
long long fy = ff(y);
if (fx != fy) {
ans--;
a[fx] = fy;
}
}
}
int main() {
scanf("%d", &n);
int mx = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &m);
a[m] = m;
mx = max(mx, m);
}
X = (int)sqrt((double)mx * 3.0 / 2.0) + 1;
Y = (int)sqrt((double)mx / 2.0) + 1;
ans = n;
for (long long i = 1; i <= Y; i++) {
for (long long j = i + 1; j <= X; j += 2) {
if (gcd(i, j) == 1) {
long long x = j * j - i * i, y = 2 * i * j, z = i * i + j * j;
dd(x, y);
dd(y, z);
dd(x, z);
}
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int p[1000000];
int main() {
int n;
int j;
int max = -1000000008;
int ans = -1;
int p[100000];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
if (p[i] > max) {
j = i;
max = p[i];
}
}
int u = 0;
for (int i = j; i < n; i++) {
if (p[i] == max) {
u++;
} else
u = 0;
ans = ans > u ? ans : u;
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t, n, x, Q, q;
cin >> n;
long long a[n];
for (long long i = 0; i < n; ++i) cin >> a[i];
long long sum[n];
sum[0] = a[0];
for (long long i = 1; i < n; ++i) sum[i] = sum[i - 1] + a[i];
cin >> Q;
for (long long i = 0; i < Q; ++i) {
cin >> q;
x = lower_bound(sum, sum + n, q) - sum;
cout << x + 1 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long num[20] = {1,
11,
111,
1111,
11111,
111111,
1111111,
11111111,
111111111,
1111111111,
11111111111,
111111111111,
1111111111111,
11111111111111,
111111111111111,
1111111111111111};
int coun[20], ans;
void solve(long long n, int pos, int flag, int neg) {
if (n == 0) {
int temp = 0;
for (int i = 0; i < 16; i++) temp = temp + (i + 1) * abs(coun[i]);
ans = min(temp, ans);
return;
}
int fuck, cao;
for (int i = 0;; i++) {
if (n < num[i + 1]) {
fuck = i;
cao = n / num[i];
break;
}
}
coun[fuck] += neg * cao;
solve(n - cao * num[fuck], fuck, 0, neg);
coun[fuck] -= neg * cao;
if (fuck == pos && flag == 1) return;
coun[fuck + 1] += neg;
solve(num[fuck + 1] - n, fuck, 1, -neg);
coun[fuck + 1] -= neg;
}
int main() {
long long n;
scanf("%I64d", &n);
ans = 1000000;
solve(n, 20, 0, 1);
printf("%d\n", ans);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
void solve(){
int n,k;cin>>n>>k;
unordered_map<int,int>m;
int distinct=0,ma=INT_MIN,mex=-1;
for(int i=0;i<n;i++){
int x;cin>>x;
ma=max(x,ma);
if(m[x]==0)distinct++;
m[x]=1;
}
for(int i=0;i<distinct;i++){
if(m[i]==0){
mex=i;
break;
}
}
if(mex==-1)mex=distinct;
if(k==0){cout<<distinct<<endl;return;}
if(mex>ma){
cout<<distinct+k<<endl;
return;
}else{
int temp = (ma+mex+1)/2;
if(m[temp]==1){
cout<<distinct<<endl;
}else{
cout<<distinct+1<<endl;
}
}
}
int main(){
#ifndef ONLINE_JUDGE
freopen("in.txt","r",stdin);
freopen("out.txt","w",stdout);
#endif
int t;cin >>t;
while(t--)solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef complex<long double> point;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, N, k, x, res = 0;
cin >> n >> k;
vector<int> cw(1001, 0);
N = n;
if (n & 1) N++;
for (int i = 0; i < n; i++) cin >> x, cw[x]++;
for (int i = 0; i < 1001; i++) {
if (cw[i] > 1) {
if (cw[i] & 1) {
res += (cw[i] - 1);
cw[i] = 1;
} else {
res += cw[i];
cw[i] = 0;
}
}
}
res += ((N - res) / 2);
cout << res << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 205;
const int mod = 998244353;
int a[N];
int n;
void work()
{
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
set<int> s;
for (int i = 0; i < n; i++)
{
for (int j = i + 1; j < n; j++)
{
if (abs(a[i] - a[j]))
s.insert(abs(a[i] - a[j]));
}
}
cout << s.size() << endl;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
cin >> T;
// scanf("%d", &T);
while (T--)
work();
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
struct Point {
int x, y;
bool operator<(const Point &a) const { return y == a.y ? x < a.x : y > a.y; }
};
Point p[200005];
int x[200005], y[2000005];
struct Segtree {
struct node {
int l, r;
int v;
} tr[200005 * 4];
void build(int l, int r, int k) {
tr[k].l = l, tr[k].r = r;
if (l == r) {
tr[k].v = 0;
return;
}
int m = (l + r) / 2;
build(l, m, k * 2);
build(m + 1, r, k * 2 + 1);
tr[k].v = tr[k * 2].v + tr[k * 2 + 1].v;
}
void update(int pos, int k, int val) {
if (tr[k].l == tr[k].r) {
tr[k].v = val;
return;
}
int m = (tr[k].l + tr[k].r) / 2;
if (pos <= m)
update(pos, k * 2, val);
else if (pos > m)
update(pos, k * 2 + 1, val);
tr[k].v = tr[k * 2].v + tr[k * 2 + 1].v;
}
int query(int l, int r, int k) {
if (l > r) return 0;
if (l <= tr[k].l && r >= tr[k].r) {
return tr[k].v;
}
int m = (tr[k].l + tr[k].r) / 2;
int ans = 0;
if (l <= m) ans += query(l, r, k * 2);
if (r > m) ans += query(l, r, k * 2 + 1);
return ans;
}
};
Segtree seg;
int ydiv[200005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
p[i].x = x[i];
p[i].y = y[i];
}
sort(x, x + n);
sort(y, y + n);
int xnew = unique(x, x + n) - x;
int ynew = unique(y, y + n) - y;
for (int i = 0; i < n; ++i) {
p[i].x = lower_bound(x, x + xnew, p[i].x) - x + 1;
p[i].y = lower_bound(y, y + ynew, p[i].y) - y + 1;
}
sort(p, p + n);
seg.build(1, xnew + 1, 1);
int beg = 0, cur = 0;
long long sum = 0;
while (beg < n) {
int pos = 0;
while (cur < n && p[cur].y == p[beg].y) {
seg.update(p[cur].x, 1, 1);
ydiv[pos++] = p[cur++].x;
}
ydiv[pos] = xnew + 1;
for (int i = 0; i < pos; ++i) {
long long cntl = seg.query(1, ydiv[i] - 1, 1);
long long cntr = seg.query(ydiv[i] + 1, ydiv[i + 1] - 1, 1);
sum += (cntl + 1) * (cntr + 1);
}
beg = cur;
}
cout << sum << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long power(long long a, int k) {
long long p;
if (k == 0) return 1;
p = power(a, k / 2);
p = p * p % 1000000007;
if (k % 2) p = p * a % 1000000007;
return p;
}
int main() {
static char cc[100000 + 1];
int n, k, i, p, a;
scanf("%s%d", cc, &k), n = strlen(cc);
p = 1;
a = 0;
for (i = 0; i < n; i++) {
if (cc[i] == '0' || cc[i] == '5') a = (a + p) % 1000000007;
p = p * 2 % 1000000007;
}
printf("%lld\n", a * (power(p, k) - 1) % 1000000007 *
power(p - 1, 1000000007 - 2) % 1000000007);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long nInf = -1000000000;
const long long pInf = 1000000000;
const long long mod = 1000000007;
const int MAXN = 1000;
int main() {
int n;
cin >> n;
long long res = 0;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
res += (i + 1) * (a - 1) + 1;
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& out, const pair<T, U>& val) {
return out << "(" << val.first << ", " << val.second << ")";
}
template <class T>
ostream& operator<<(ostream& out, const vector<T>& val) {
out << "{";
for (int i = 0; i < (int)((int)((val).size())); ++i)
out << (i ? ", " : "") << val[i];
return out << "}";
}
namespace std {
bool operator<(const complex<double>& a, const complex<double>& b) {
if (abs(a.real() - b.real()) > (1e-6)) return a.real() < b.real();
return a.imag() < b.imag();
}
} // namespace std
double dot(complex<double> a, complex<double> b) { return real(conj(a) * b); }
double crs(complex<double> a, complex<double> b) { return imag(conj(a) * b); }
complex<double> ortho(complex<double> a) {
return complex<double>(imag(a), -real(a));
}
complex<double> ortho(pair<complex<double>, complex<double> > a) {
return ortho(a.second - a.first);
}
complex<double> crspt(complex<double> a, complex<double> b, complex<double> c,
complex<double> d) {
b -= a, d -= c;
return a + b * crs(d, c - a) / crs(d, b);
}
complex<double> crspt(pair<complex<double>, complex<double> > a,
pair<complex<double>, complex<double> > b) {
return crspt(a.first, a.second, b.first, b.second);
}
bool onl(complex<double> a1, complex<double> a2, complex<double> b) {
return abs(b - a1) + abs(b - a2) < abs(a1 - a2) + (1e-6);
}
bool onl(pair<complex<double>, complex<double> > a, complex<double> b) {
return onl(a.first, a.second, b);
}
bool iscrs(pair<complex<double>, complex<double> > a,
pair<complex<double>, complex<double> > b) {
complex<double> c = crspt(a, b);
return onl(a, c) && onl(b, c);
}
void pkuassert(bool t) { t = 1 / t; };
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[] = {1, 0, -1, 0, -1, 1, 1, -1};
enum { TOP, BTM, LFT, RGT, FRT, BCK };
int dxdy2ce[] = {RGT, FRT, LFT, BCK};
int s2i(string& a) {
stringstream ss(a);
int r;
ss >> r;
return r;
}
template <class T>
T shift(T a, int b, int c, int d, int e) {
__typeof(a[0]) t = a[b];
a[b] = a[c];
a[c] = a[d];
a[d] = a[e];
a[e] = t;
return a;
}
template <class T>
T rgt(T a) {
return shift(a, TOP, LFT, BTM, RGT);
}
template <class T>
T lft(T a) {
return shift(a, TOP, RGT, BTM, LFT);
}
template <class T>
T frt(T a) {
return shift(a, TOP, BCK, BTM, FRT);
}
template <class T>
T bck(T a) {
return shift(a, TOP, FRT, BTM, BCK);
}
pair<complex<double>, complex<double> > mkl(complex<double> a,
complex<double> v) {
return pair<complex<double>, complex<double> >(a, a + v);
}
double lpdist(pair<complex<double>, complex<double> > a, complex<double> b) {
return abs(b - crspt(a, mkl(b, ortho(a))));
}
double spdist(pair<complex<double>, complex<double> > a, complex<double> b) {
complex<double> c(crspt(a, mkl(b, ortho(a))));
return onl(a, c) ? abs(b - c) : min(abs(a.first - b), abs(a.second - b));
}
double ssdist(pair<complex<double>, complex<double> > a,
pair<complex<double>, complex<double> > b) {
return iscrs(a, b)
? 0.
: min((spdist(a, b.first)),
min(((spdist(a, b.second))),
min(((spdist(b, a.first))), ((spdist(b, a.second))))));
}
int main(int argc, char* argv[]) {
int n;
cin >> n;
vector<int> in(n);
for (int i = 0; i < (int)(n); ++i) cin >> in[i];
long long sum = accumulate(in.begin(), in.end(), 0);
long long ans = 0;
int tc = 0;
long long tsum = 0;
for (int i = 0; i < (int)(n - 1); ++i) {
tsum += in[i];
if (i && tsum * 3 == sum * 2) ans += tc;
tc += tsum * 3 == sum;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n;
n = s.length();
int matrix[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
matrix[i][j] = 0;
}
}
for (int j = 0; j < n; j++) {
if (s[j] == '0') {
for (int i = 0; i < 4; i++) {
if (matrix[0][i] == 0 || matrix[0][i] == 2) {
cout << 1 << " " << i + 1 << endl;
matrix[0][i] = 1;
matrix[1][i] = 1;
break;
}
}
if (matrix[0][0] == 1 && matrix[0][1] == 1 && matrix[0][2] == 1 &&
matrix[0][3] == 1) {
matrix[0][0] = matrix[0][1] = matrix[0][2] = matrix[0][3] = 2;
matrix[1][0] = matrix[1][1] = matrix[1][2] = matrix[1][3] = 2;
}
} else {
for (int i = 2; i < 4; i++) {
bool ok = false;
for (int k = 0; k < 4; k += 2) {
if ((matrix[i][k] == 0 && matrix[i][k + 1] == 0) ||
(matrix[i][k] == 2 && matrix[i][k + 1] == 2)) {
cout << i + 1 << " " << k + 1 << endl;
matrix[i][k] = 1;
matrix[i][k + 1] = 1;
ok = true;
break;
}
}
if (ok) break;
}
if (matrix[2][0] == 1 && matrix[2][1] == 1 && matrix[2][2] == 1 &&
matrix[2][3] == 1) {
matrix[2][0] = matrix[2][1] = matrix[2][2] = matrix[2][3] = 2;
}
if (matrix[3][0] == 1 && matrix[3][1] == 1 && matrix[3][2] == 1 &&
matrix[3][3] == 1) {
matrix[3][0] = matrix[3][1] = matrix[3][2] = matrix[3][3] = 2;
}
}
for (int k = 0; k < 4; k++) {
if ((matrix[0][k] == 2 && matrix[1][k] == 2 && matrix[2][k] == 2 &&
matrix[3][k] == 2) ||
(matrix[0][k] == 1 && matrix[1][k] == 1 && matrix[2][k] == 1 &&
matrix[3][k] == 1)) {
matrix[0][k] = matrix[1][k] = matrix[2][k] = matrix[3][k] = 0;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q;
cin >> n >> p >> q;
bool mark[n + 1];
for (int i = 0; i < p + q; ++i) {
int x;
cin >> x;
mark[x] = (i < p);
}
for (int i = 1; i <= n; ++i) cout << 2 - mark[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
int n, a[100010], init[100010];
double dp[100010][101];
double tmp[101];
double C(int x, int y) {
if (x < y) return 0;
double res = 1;
for (int i = 0; i < y; i++) res = res * (x - i) / (i + 1);
return res;
}
int main() {
int q, x, y, z;
scanf("%d", &n);
double res = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dp[i][a[i]] = 1;
init[i] = a[i];
if (a[i] == 0) res += 1;
}
for (scanf("%d", &q); q--;) {
scanf("%d%d%d", &x, &y, &z);
res -= dp[x][0];
memset(tmp, 0, sizeof(tmp));
double den = C(a[x], z);
for (int i = 0; i <= init[x] && i <= a[x]; i++)
for (int j = 0; j <= z && j <= i; j++)
tmp[i - j] += dp[x][i] * (C(i, j) * C(a[x] - i, z - j) / den);
for (int i = 0; i <= init[x]; i++) dp[x][i] = tmp[i];
res += dp[x][0];
a[x] -= z;
a[y] += z;
printf("%.12lf\n", res);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, v[15];
vector<pair<int, int> > erased;
vector<pair<int, int> > curv;
vector<int> needAcum;
map<int, int> assignedTo;
set<int> dp[15][1 << 15];
bool assign(int pos, int bm, int prev, int acumLeft, int usedHere, int aux2) {
if (pos == curv.size()) return true;
if (needAcum[pos] - usedHere > acumLeft) return false;
if (dp[pos][bm].upper_bound(prev) != dp[pos][bm].begin()) return false;
if (curv[pos].first > prev) {
dp[pos][bm].insert(prev);
return assign(pos + 1, bm, curv[pos].first, acumLeft, 0, 0);
}
for (int i = (aux2); i < (erased.size()); i++)
if ((bm & (1 << i)) == 0) {
if (curv[pos].first + erased[i].first > prev) {
if (assign(pos + 1, bm | (1 << i),
curv[pos].first + erased[i].first + usedHere,
acumLeft - erased[i].first, 0, 0)) {
assignedTo[erased[i].second] = curv[pos].second;
return true;
}
} else if (assign(pos, bm | (1 << i), prev - erased[i].first,
acumLeft - erased[i].first, usedHere + erased[i].first,
i + 1)) {
assignedTo[erased[i].second] = curv[pos].second;
return true;
}
}
dp[pos][bm].insert(prev);
return false;
}
bool can(int pos, int toErase) {
if (toErase < 0 || n - pos < toErase) return false;
if (pos == n) {
if (toErase != 0) return false;
assignedTo.clear();
bool ok = true;
for (int i = (1); i < (curv.size()); i++)
if (curv[i].first <= curv[i - 1].first) ok = false;
if (ok) return true;
assert(erased.size() + curv.size() == n);
int acum = 0;
for (auto it = erased.begin(); it != erased.end(); it++) acum += it->first;
needAcum.clear();
needAcum.push_back(0);
for (int i = (1); i < (curv.size()); i++)
needAcum.push_back(max(0, curv[i - 1].first + 1 - curv[i].first));
for (int i = needAcum.size() - 1 - 1; i >= 0; i--)
needAcum[i] += needAcum[i + 1];
if (needAcum[0] > acum) return false;
vector<pair<int, int> > origErased = erased;
for (int i = (0); i < (curv.size()); i++)
for (int j = (0); j < (1 << erased.size()); j++) dp[i][j].clear();
bool ret = assign(0, 0, 0, acum, 0, 0);
erased = origErased;
return ret;
}
if (0) {
curv.push_back(make_pair(v[pos], pos));
if (can(pos + 1, toErase)) return true;
curv.pop_back();
erased.push_back(make_pair(v[pos], pos));
if (can(pos + 1, toErase - 1)) return true;
erased.pop_back();
} else {
erased.push_back(make_pair(v[pos], pos));
if (can(pos + 1, toErase - 1)) return true;
erased.pop_back();
curv.push_back(make_pair(v[pos], pos));
if (can(pos + 1, toErase)) return true;
curv.pop_back();
}
return false;
}
bool can(int cant) {
erased.clear();
curv.clear();
if (can(0, cant)) return true;
return false;
}
void ans(int cant) {
assert(can(cant));
vector<int> alreadyErased;
cout << cant << '\n';
assert(erased.size() == cant);
for (auto it = erased.begin(); it != erased.end(); it++) {
int first = it->second, second = curv.back().second;
if (assignedTo.count(it->second)) second = assignedTo[it->second];
int initialsnd = second;
for (int i = (0); i < (alreadyErased.size()); i++) {
assert(alreadyErased[i] != it->second);
assert(alreadyErased[i] != initialsnd);
if (alreadyErased[i] < it->second) first--;
if (alreadyErased[i] < initialsnd) second--;
}
assert(first != second);
cout << first + 1 << ' ' << second + 1 << '\n';
alreadyErased.push_back(it->second);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
for (int T = (0); T < (t); T++) {
cin >> n;
for (int i = (0); i < (n); i++) cin >> v[i];
int l = 0, r = n - 1, m;
while (l < r) {
m = (l + r) / 2;
if (can(m))
r = m;
else
l = m + 1;
}
ans(l);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, last, before;
string number;
cin >> number;
if (number[0] != '-') {
cout << number;
} else {
n = atoi(number.c_str());
int len = number.length();
last = number[len - 1] - '0';
before = number[len - 2] - '0';
if (before > last) {
number.erase(len - 2, 1);
cout << atoi(number.c_str());
} else {
number.erase(len - 1, 1);
cout << atoi(number.c_str());
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10, maxL = (1 << 7) + 10;
struct Point {
int x, y;
Point() { x = y = 0; }
Point(int a, int b) { x = a, y = b; }
void init() { scanf("%d%d", &x, &y); }
friend Point operator-(const Point &a, const Point &b) {
return Point(a.x - b.x, a.y - b.y);
}
long long crossdot(const Point &a) const {
return (long long)x * a.y - (long long)y * a.x;
}
friend bool operator<(const Point &a, const Point &b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
} stone[10], monster[maxn];
int K, N, M, G;
bool vis[maxn];
vector<int> R[5040 + 10000];
vector<int> Q[maxn][10];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void minpoint(Point &t) {
int x = t.x, y = t.y;
int d = gcd(x, y);
if (d < 0) d = -d;
if (d > 1) t.x /= d, t.y /= d;
}
bool check_in(const Point &a, const Point &b, const Point &c) {
Point v1 = b - a;
Point v2 = c - a;
long long s = v1.crossdot(v2);
if (s != 0) return 0;
int x1 = a.x, x2 = b.x, x3 = c.x;
if (x1 == x2) x1 = a.y, x2 = b.y, x3 = c.y;
if (x1 < x3 && x3 < x2) return 1;
if (x1 > x3 && x3 > x2) return 1;
return 0;
}
void Prepare() {
static int p[12];
M = 0;
for (int i = (0), _i = (K - 1); i <= _i; i++) p[i] = i;
do {
R[M].resize(K);
for (int i = (0), _i = (K - 1); i <= _i; i++) R[M][i] = p[i];
M++;
} while (next_permutation(p, p + K));
for (int i = (0), _i = (N - 1); i <= _i; i++) {
Point v = monster[i];
for (int j = (0), _j = (K - 1); j <= _j; j++) {
Q[i][j].clear();
Point u = stone[j];
for (int kk = (0), _kk = (N - 1); kk <= _kk; kk++) {
if (i == kk) continue;
if (check_in(u, v, monster[kk])) {
Q[i][j].push_back(kk);
}
}
}
}
}
bool check(int x, vector<int> &T) {
static int o[maxn];
int h = 0, t = 0, ss = x;
o[h] = x;
vis[x] = 1;
for (; h <= t && h < K; h++) {
x = o[h];
int w = T[h];
Point u = stone[w];
Point v = monster[x];
for (int i = (0), _i = (Q[x][w].size() - 1); i <= _i; i++) {
int y = Q[x][w][i];
if (vis[y]) continue;
o[++t] = y;
vis[y] = 1;
if (t >= K) {
for (int ttt = (0), _ttt = (t); ttt <= _ttt; ttt++) vis[o[ttt]] = 0;
return 0;
}
}
}
for (int i = (0), _i = (t); i <= _i; i++) vis[o[i]] = 0;
if (t >= K) return 0;
return 1;
}
int main(int argc, char *argv[]) {
for (; scanf("%d%d", &K, &N) != EOF;) {
for (int i = (0), _i = (K - 1); i <= _i; i++) stone[i].init();
for (int i = (0), _i = (N - 1); i <= _i; i++) monster[i].init();
Prepare();
int ans = 0, bs = (1 << K) - 1;
memset(vis, 0, sizeof(vis));
for (int i = (0), _i = (N - 1); i <= _i; i++) {
bool flag = 0;
for (int j = (0), _j = (M - 1); j <= _j; j++)
if (check(i, R[j])) {
flag = 1;
break;
}
if (flag) ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int maxn = 3e5 + 10;
const int mod = 998244353;
using namespace std;
int n, k;
int a[maxn], sum[maxn], vis[maxn];
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
if (n == 2 || n == 3) {
printf("-1\n");
continue;
}
for (int i = n & 1 ? 1 : 2; i <= n; i += 2) printf("%d ", i);
printf("%d %d ", n - 3, n - 1);
for (int i = n - 5; i >= 1; i -= 2) printf("%d ", i);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int c = 1000100;
int n, m;
int a[c];
int ans;
int k, b, p, d;
void go(int i) {
if (a[i]) return;
a[i] = 1;
k = (m - 1) << 1;
b = 1;
p = i;
while (k) {
if (b > 0)
d = min(k, n - p);
else
d = min(k, p - 1);
p += d * b;
if (d < k) b = -b;
k -= d;
}
go(p);
k = (m - 1) << 1;
p = i;
b = -1;
while (k) {
if (b > 0)
d = min(k, n - p);
else
d = min(k, p - 1);
p += d * b;
if (d < k) b = -b;
k -= d;
}
go(p);
}
int main() {
scanf("%d%d", &n, &m);
ans = 0;
int i;
for (i = 1; i <= n; ++i)
if (!a[i]) {
++ans;
go(i);
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long nax = 1e5 + 7;
long long point[nax] = {0}, happy[nax], h[nax], p[nax], lo[nax];
vector<long long> edge[nax];
bool value = true;
void DFS(long long s, long long par = -1) {
point[s] = p[s];
for (auto it : edge[s]) {
if (it != par) {
DFS(it, s);
point[s] += point[it];
}
}
lo[s] = -point[s];
}
void DFS1(long long s, long long par = -1) {
if (h[s] > point[s] || h[s] < lo[s] || (h[s] - lo[s]) % 2 != 0) {
value = false;
return;
}
happy[s] = (h[s] - lo[s]) / 2;
long long dem = 0;
for (auto it : edge[s]) {
if (it != par) {
DFS1(it, s);
dem += happy[it];
}
}
if (dem > happy[s]) value = false;
}
int main() {
long long tc;
cin >> tc;
while (tc--) {
long long n, m;
cin >> n >> m;
value = true;
for (long long i = 0; i <= n; ++i) {
edge[i].clear();
}
for (long long i = 1; i <= n; ++i) cin >> p[i];
for (long long i = 1; i <= n; ++i) cin >> h[i];
for (long long i = 0; i < n - 1; ++i) {
long long a, b;
cin >> a >> b;
edge[a].push_back(b);
edge[b].push_back(a);
}
DFS(1);
DFS1(1);
if (value)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename G>
struct triple {
G first, second, T;
};
vector<int> query(vector<int> v) {
cout << "next";
for (auto &i : v) cout << " " << i;
cout << '\n';
cout.flush();
vector<int> w(10);
int k;
cin >> k;
for (int i = 0; i < k; i++) {
string s;
cin >> s;
for (auto &j : s) w[j - '0'] = i;
}
return w;
}
int main() {
while (true) {
query({0, 1});
auto v = query({1});
if (v[0] == v[1]) break;
}
while (true) {
auto v = query({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
bool ok = true;
for (int i = 0; i < 10; i++) ok &= (v[i] == 0);
if (ok) break;
}
cout << "done\n";
cout.flush();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100001];
bool visited[100001];
pair<long long, long long> para[100001];
long long n, k;
struct item {
long long init, final, diff;
};
item I[200001];
bool cmp(struct item I1, struct item I2) { return I1.diff > I2.diff; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> I[i].init;
}
for (int i = 0; i < n; i++) {
cin >> I[i].final;
I[i].diff = I[i].final - I[i].init;
}
sort(I, I + n, cmp);
long long ans = 0;
for (int j = 0; j < k; j++) {
ans += I[j].init;
}
if (n > k) {
int j = k;
while (j < n && I[j].diff > 0) {
ans += I[j].init;
j++;
}
for (int t = j; t < n; t++) {
ans += I[t].final;
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[10], d[10];
int main() {
ios_base::sync_with_stdio(false);
for (int i = 1; i <= 4; i++) cin >> d[i] >> a[i];
if (d[1] > a[3] and a[2] > d[4] and d[1] > a[4] and a[2] > d[3]) {
cout << "Team 1";
return 0;
}
if (d[2] > a[3] and a[1] > d[4] and d[2] > a[4] and a[1] > d[3]) {
cout << "Team 1";
return 0;
}
if (((d[1] < a[3] and a[2] < d[4]) or (d[1] < a[4] and a[2] < d[3])) and
((d[2] < a[3] and a[1] < d[4]) or (d[2] < a[4] and a[1] < d[3]))) {
cout << "Team 2";
return 0;
}
cout << "Draw";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int b[n];
for (int i = 0; i < n; i++) {
b[i] = 0;
}
int r = 0;
for (int i = 0; i < n - 1; i++) {
b[r] = b[r] + 1;
if (a[i] != a[i + 1]) {
r = r + 1;
}
}
b[r] = b[r] + 1;
sort(b, b + r + 1);
int ans = b[r];
int lst = b[r];
for (int i = r - 1; i >= 0; i--) {
if (lst == 0) break;
if (b[i] >= lst) {
lst = lst - 1;
ans += lst;
} else {
ans += b[i];
lst = b[i];
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<vector<string>, bool> state;
vector<string> matr;
void printm(int n) {
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= n - 1; j++) cout << matr[i][j] << ' ';
cout << '\n';
}
cout << '\n';
}
void compute_states(int li) {
for (int q = 0; q <= li + 1; q++) {
vector<string> aux;
state[matr] = 1;
for (int j = li; j >= 0; j--) {
string foo;
for (int i = 0; i <= li; i++) {
foo.push_back(matr[i][j]);
}
aux.push_back(foo);
}
matr = aux;
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i <= n - 1; i++) {
string x;
cin >> x;
matr.push_back(x);
}
compute_states(n - 1);
for (int i = 0; i <= n - 1; i++) reverse(matr[i].begin(), matr[i].end());
compute_states(n - 1);
reverse(matr.begin(), matr.end());
compute_states(n - 1);
for (int i = 0; i <= n - 1; i++) reverse(matr[i].begin(), matr[i].end());
compute_states(n - 1);
vector<string> query;
for (int i = 0; i <= n - 1; i++) {
string x;
cin >> x;
query.push_back(x);
}
cout << ((state[query]) ? "Yes" : "No");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int em(long long int x, long long int Mod, long long int n) {
if (n == 0)
return 1ll;
else if (n % 2 == 0)
return em((x % Mod * x % Mod) % Mod, Mod, n / 2) % Mod;
else
return (x % Mod * em((x % Mod * x % Mod) % Mod, Mod, (n - 1) / 2)) % Mod;
}
long long int freq[102];
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, M, i, j, k;
cin >> n >> M;
long long int arr[n + 1];
for (i = 1; i <= n; i++) cin >> arr[i];
long long int tot = 0;
for (i = 1; i <= n; i++) {
long long int tle = M - tot;
if (tle >= arr[i])
cout << 0 << " ";
else {
long long int co = 0;
for (j = 100; j >= 1; j--) {
if (freq[j] > 0) {
if ((tle + freq[j] * j) >= arr[i]) {
long long int lo = 1, hi = freq[j];
long long int tmp = 0;
long long int ans = freq[j];
while (lo <= hi) {
long long int mid = (lo + hi) / 2;
tmp = tle + mid * j;
if (tmp >= arr[i]) {
hi = mid - 1;
ans = min(ans, mid);
} else
lo = mid + 1;
}
cout << co + ans << " ";
break;
} else {
tle += freq[j] * j;
co += freq[j];
}
}
}
}
tot += arr[i];
freq[arr[i]]++;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
if ((i * (i + 1)) / 2 >= k && i + (i * (i + 1)) / 2 - k == n) {
cout << (i * (i + 1)) / 2 - k << endl;
return 0;
}
}
assert(false);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void Solve() {
long long n;
cin >> n;
vector<long long> a(n);
long long q, p;
cin >> q >> p;
a[0] = max(q, p);
for (long long i = 1; i < n; ++i) {
cin >> q >> p;
a[i] = max(q, p);
if (a[i] > a[i - 1]) a[i] = min(q, p);
if (a[i] > a[i - 1]) return void(cout << "NO");
}
cout << "YES";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
Solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, fa[600005], size1[600005], size2[600005], d[600005], top;
long long res;
map<pair<int, int>, int> mp;
vector<pair<int, int> > e[600005 << 1];
int find(int x) {
while (x ^ fa[x]) x = fa[x];
return x;
}
struct nade {
int x, y, s1, s2, d;
long long rs;
} st[600005];
void change(int x, int l, int r, int L, int R, pair<int, int> p) {
if (l >= L && r <= R) {
e[x].push_back(p);
return;
}
int mid = (l + r) >> 1;
if (mid >= L) change(x << 1, l, mid, L, R, p);
if (mid + 1 <= R) change(x << 1 | 1, mid + 1, r, L, R, p);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (d[x] > d[y]) swap(x, y);
st[++top] = nade{x, y, size1[y], size2[y], d[y], res};
res -= 1ll * size1[x] * size2[x] + 1ll * size1[y] * size2[y];
d[y] += d[x] == d[y];
fa[x] = y;
size1[y] += size1[x];
size2[y] += size2[x];
res += 1ll * size1[y] * size2[y];
}
void solve(int x, int l, int r) {
int wh = top;
for (auto i : e[x]) merge(i.first, i.second);
if (l == r)
printf("%lld ", res);
else {
int mid = (l + r) >> 1;
solve(x << 1, l, mid);
solve(x << 1 | 1, mid + 1, r);
}
while (top > wh) {
int x = st[top].x, y = st[top].y;
fa[x] = x;
d[y] = st[top].d;
size1[y] = st[top].s1;
size2[y] = st[top].s2;
res = st[top].rs;
top--;
}
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i <= n; i++) {
scanf("%d%d", &u, &v);
pair<int, int> p = pair<int, int>{u, v + 3e5};
if (mp[p]) {
change(1, 1, n, mp[p], i - 1, p);
mp.erase(p);
} else
mp[p] = i;
}
for (int i = 1; i <= 6e5; i++) {
fa[i] = i;
if (i <= 3e5)
size1[i] = 1;
else
size2[i] = 1;
}
for (auto i : mp) change(1, 1, n, i.second, n, i.first);
solve(1, 1, n);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, v1, v2, t1, t2;
cin >> s >> v1 >> v2 >> t1 >> t2;
if (s > 0) {
if (s * v1 + 2 * t1 < s * v2 + 2 * t2) {
cout << "First" << endl;
} else if (s * v1 + 2 * t1 > s * v2 + 2 * t2) {
cout << "Second" << endl;
} else {
cout << "Friendship" << endl;
}
} else {
cout << "Friendship" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> Li[200050];
int v[200050], Dif[200050], sx[200050], sy[200050], sg[200050], li[200050],
st[200050][18], d[200050];
int n, m, ans;
inline int Read() {
int x = 0;
char y;
do y = getchar();
while (y < '0' || y > '9');
do x = x * 10 + y - '0', y = getchar();
while (y >= '0' && y <= '9');
return x;
}
void Doubly(int x) {
int Cnt = 0;
for (int i = n * 2 - x; i < n * 2; i++) sy[++Cnt] = i;
for (int i = 1; i < n * 2; i++)
if (sx[i] > x) sy[++Cnt] = sx[i] - x;
memset(d, 0, sizeof(d));
for (int i = 1; i < n * 2; i++) d[li[i]]++;
for (int i = 1; i < n * 2; i++) d[i] += d[i - 1];
for (int i = 1; i < n * 2; i++) sx[++d[li[sy[i]] - 1]] = sy[i];
memset(d, 0, sizeof(d));
d[sx[1]] = 1;
for (int i = 2; i < n * 2; i++)
d[sx[i]] =
d[sx[i - 1]] + 1 -
(li[sx[i]] == li[sx[i - 1]] && li[sx[i] + x] == li[sx[i - 1] + x]);
for (int i = 1; i < n * 2; i++) li[i] = d[i];
return;
}
void SA() {
for (int i = 1; i < n * 2; i++) Li[i] = make_pair(Dif[i], i);
sort(Li + 1, Li + n * 2);
for (int i = 1; i < n * 2; i++) sx[i] = Li[i].second;
li[Li[1].second] = 1;
for (int i = 2; i < n * 2; i++)
li[Li[i].second] = (Li[i].first != Li[i - 1].first) + li[Li[i - 1].second];
for (int i = 1; i < n * 2 - 1; i <<= 1) Doubly(i);
int Cnt = 0;
for (int i = 1; i < n * 2; i++) {
Cnt = Cnt ? --Cnt : 0;
if (li[i] == 1) continue;
while (sx[li[i] - 1] + Cnt < n * 2 &&
Dif[i + Cnt] == Dif[sx[li[i] - 1] + Cnt])
Cnt++;
st[li[i] - 1][0] = Cnt;
}
return;
}
struct Node {
Node* c[2];
int sz;
} * rt[200050];
namespace Chairman_Tree {
Node *cur, statePool[5000050], Emp, *emp;
inline Node* GetNew() {
cur->c[0] = cur->c[1] = emp;
return cur++;
}
Node* Insert(int x, int y, Node* z, int o) {
int mid = x + y >> 1;
Node* New = GetNew();
New->sz = z->sz + 1;
if (x != y)
if (o <= mid)
New->c[1] = z->c[1], New->c[0] = Insert(x, mid, z->c[0], o);
else
New->c[0] = z->c[0], New->c[1] = Insert(mid + 1, y, z->c[1], o);
return New;
}
int Query(int x, int y, Node* z, Node* o, int p, int u) {
int mid = x + y >> 1;
if (x == p && y == u) return z->sz - o->sz;
if (u <= mid)
return Query(x, mid, z->c[0], o->c[0], p, u);
else if (p > mid)
return Query(mid + 1, y, z->c[1], o->c[1], p, u);
else
return Query(x, mid, z->c[0], o->c[0], p, mid) +
Query(mid + 1, y, z->c[1], o->c[1], mid + 1, u);
}
void Set_up() {
cur = statePool;
emp = rt[0] = &Emp;
emp->c[0] = emp->c[1] = emp;
for (int i = 1; i < n * 2; i++)
rt[i] = Insert(1, n * 2 - 1, rt[i - 1], sx[i]);
return;
}
} // namespace Chairman_Tree
void Pretreat() {
for (int i = 1; i < n; i++) Dif[i] = v[i + 1] - v[i];
Dif[n] = 0x3f7f7f7f;
for (int i = 1; i < n; i++) Dif[n + i] = -Dif[i];
SA();
for (int j = 1; j < 18; j++)
for (int i = 1; i < n * 2; i++)
if (st[i][j - 1])
st[i][j] = min(st[i][j - 1], st[i + (1 << j - 1)][j - 1]);
Chairman_Tree::Set_up();
return;
}
void GetBorder(int x, int y, int& z, int& o) {
y -= x;
z = o = li[x];
for (int i = 18 - 1; ~i; i--) {
if (z > 1 << i && st[z - (1 << i)][i] >= y) z -= 1 << i;
if (st[o][i] >= y) o += 1 << i;
}
return;
}
int main() {
n = Read();
for (int i = 1; i <= n; i++) v[i] = Read();
Pretreat();
m = Read();
while (m--) {
int k = Read(), l = Read(), Le, Ri;
if (k == l) {
printf("%d\n", n - 1);
continue;
}
GetBorder(k, l, Le, Ri);
ans = 0;
if (k - 1 << 1 >= l)
ans = Chairman_Tree::Query(1, n * 2 - 1, rt[Ri], rt[Le - 1], n + 1,
n + 2 * k - l - 1);
if (n + l + 1 <= 2 * n - 1)
ans += Chairman_Tree::Query(1, n * 2 - 1, rt[Ri], rt[Le - 1], n + l + 1,
2 * n - 1);
printf("%d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
struct node {
int next, to;
} e[300020 * 2];
int head[300020], cnt;
long long f[300020][3], g[3];
int n;
inline void adde(int x, int y) {
e[++cnt].to = y;
e[cnt].next = head[x];
head[x] = cnt;
}
void dfs(int x, int fa) {
f[x][0] = 1;
for (register int i = head[x]; i; i = e[i].next) {
if (e[i].to == fa) continue;
dfs(e[i].to, x);
memcpy(g, f[x], sizeof(g));
f[x][2] = ((g[0] + g[2] * 2) * f[e[i].to][1] + f[e[i].to][0] * g[2]) % mod;
f[x][1] = (g[1] * (f[e[i].to][1] * 2 + f[e[i].to][0]) +
(f[e[i].to][0] + f[e[i].to][2]) * g[0] +
g[2] * (f[e[i].to][2] + f[e[i].to][0])) %
mod;
f[x][0] = g[0] * (f[e[i].to][1] + f[e[i].to][0]) % mod;
}
}
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
adde(x, y), adde(y, x);
}
dfs(1, 0);
printf("%lld\n", (f[1][0] + f[1][1]) % mod);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, a[5][5], x;
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
a[i][j] = 1;
}
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
cin >> x;
a[i][j] += x;
if (i + 1 <= 2) a[i + 1][j] += x;
if (i - 1 >= 0) a[i - 1][j] += x;
if (j + 1 <= 2) a[i][j + 1] += x;
if (j - 1 >= 0) a[i][j - 1] += x;
}
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
if (a[i][j] % 2 == 0) {
cout << 0;
} else {
cout << 1;
}
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 4010;
int dp[MAX][MAX];
const int s = 86400;
int t[s];
int d[s];
int ans;
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &t[i], &d[i]);
t[i]--;
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= k; j++) {
dp[i][j] = (t[i] > dp[i - 1][j] ? d[i] + t[i] : dp[i - 1][j] + d[i]);
if (j >= 1)
if (dp[i - 1][j - 1] < dp[i][j]) dp[i][j] = dp[i - 1][j - 1];
}
for (int i = 0; i <= n; i++) ans = max(ans, t[i + 1] - dp[i][k]);
ans = max(ans, s - dp[n][k]);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int ckmax(int &a, int b) { return a < b ? a = b, 1 : 0; }
inline int ckmin(int &a, int b) { return a > b ? a = b, 1 : 0; }
const int maxn = 1010, maxm = 30010;
int n, m, s, t, tim;
int u[30010], v[30010], w[30010], uu[maxm], vv[maxm], ww[maxm], wp[maxm],
id[maxm];
int fa[1010], use[30010], dfn[maxn], low[maxn];
vector<pair<int, int> > g[maxn];
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) {
x = find(x), y = find(y);
fa[x] = y;
}
void dfs(int t, int fa) {
dfn[t] = low[t] = ++tim;
for (auto e : g[t]) {
int v = e.first, id = e.second;
if (!dfn[v]) {
dfs(v, id);
low[t] = min(low[t], low[v]);
if (low[v] <= dfn[t]) merge(v, t);
} else {
if (id != fa) low[t] = min(low[t], dfn[v]);
}
}
}
bool cmp(int x, int y) { return ww[y] < ww[x]; }
int main() {
scanf("%d%d", &n, &m);
scanf("%d%d", &s, &t);
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= m; ++i)
scanf("%d%d%d", uu + i, vv + i, ww + i), wp[i] = i;
sort(wp + 1, wp + m + 1, cmp);
for (int i = 1; i <= m; ++i) {
int o = wp[i];
u[i] = uu[o], v[i] = vv[o], w[i] = ww[o], id[i] = o;
int x = find(u[i]), y = find(v[i]);
if (x != y) {
fa[x] = y;
use[i] = 1;
}
}
if (find(s) != find(t)) {
printf("0\n0");
return 0;
}
int ans = 2e9 + 100;
vector<int> res;
for (int i = 1; i <= m; ++i)
if (use[i]) {
for (int j = 1; j <= n; ++j) g[j].clear(), fa[j] = j;
for (int j = 1; j <= m; ++j)
if (j != i) {
g[u[j]].push_back(make_pair(v[j], j));
g[v[j]].push_back(make_pair(u[j], j));
}
tim = 0;
memset(dfn, 0, sizeof(dfn));
for (int j = 1; j <= n; ++j)
if (!dfn[j]) dfs(j, 0);
if (find(s) == find(t)) continue;
int ta;
for (int j = 1; j <= m; ++j) {
int x = find(u[j]), y = find(v[j]);
if (x == y || j == i) continue;
if (x != y) {
fa[x] = y;
if (find(s) == find(t)) {
ta = j;
break;
}
}
}
if (find(s) != find(t)) {
if (ckmin(ans, w[i])) {
res.clear();
res.push_back(id[i]);
}
} else {
if (ckmin(ans, w[i] + w[ta])) {
res.clear();
res.push_back(id[i]), res.push_back(id[ta]);
}
}
}
if (!res.size()) {
printf("-1");
} else {
printf("%d\n", ans);
printf("%d\n", (int)res.size());
for (auto v : res) printf("%d ", v);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T Mul(T x, T y, T P) {
T F1 = 0;
while (y) {
if (y & 1) {
F1 += x;
if (F1 < 0 || F1 >= P) F1 -= P;
}
x <<= 1;
if (x < 0 || x >= P) x -= P;
y >>= 1;
}
return F1;
}
template <class T>
T Pow(T x, T y, T P) {
T F1 = 1;
x %= P;
while (y) {
if (y & 1) {
F1 = Mul(F1, x, P);
}
x = Mul(x, x, P);
y >>= 1;
}
return F1;
}
template <class T>
T Gcd(T x, T y) {
if (y == 0) return x;
T z;
while (z = x % y) {
x = y, y = z;
}
return y;
}
template <class T>
void UpdateMin(T &x, T y) {
if (y < x) {
x = y;
}
}
template <class T>
void UpdateMax(T &x, T y) {
if (x < y) {
x = y;
}
}
template <class T>
T Sqr(const T x) {
return x * x;
}
template <class T>
T Abs(const T x) {
return x < 0 ? -x : x;
}
class ReadBuffer {
private:
char buff[20000000];
char *buf;
public:
void init(int size = 20000000) {
fread(buff, 1, size, stdin);
buf = buff;
}
template <class T>
bool readInteger(T &x) {
x = 0;
while (*buf && isspace(*buf)) ++buf;
if (*buf == 0) return false;
static bool flag;
flag = 0;
if (*buf == '-')
flag = true;
else
x = *buf - '0';
while (isdigit(*++buf)) x = x * 10 + *buf - '0';
if (flag) x = -x;
return true;
}
template <class T>
bool readFloat(T &x) {
long double nowpos = 0.1;
x = 0;
while (*buf && isspace(*buf)) ++buf;
if (*buf == 0) return false;
static bool flag, decimal;
decimal = flag = 0;
if (*buf == '-')
flag = true, ++buf;
else if (*buf == '.')
decimal = true;
while (isdigit(*buf) || *buf == '.') {
if (*buf == '.')
decimal = true;
else {
if (decimal) {
x += nowpos * (*buf - '0');
nowpos *= 0.1;
} else {
x = x * 10 + *buf - '0';
}
}
++buf;
}
return true;
}
bool readChar(char c) {
if (*buf == 0) return 0;
return c = *buf++, 1;
}
bool readString(char *s) {
while (*buf && isspace(*buf)) ++buf;
if (!*buf) return false;
while (!isspace(*buf)) *s++ = *buf++;
*s++ = 0;
return true;
}
int countSpacetonext() {
int total = 0;
while (*buf && *buf == ' ') ++total, ++buf;
return total;
}
bool splitBycharactor(char *s, char Split = '\n') {
while (*buf && *buf != Split) *s++ = *buf++;
*s++ = 0;
return *buf != 0;
}
};
struct EDGE {
int T;
EDGE *Nxt;
};
bool in[200100];
vector<int> V[200100];
int fa[200101];
int a[200101], N;
long long dp[200101][3][3];
void dfs(int x) {
in[x] = 1;
dp[x][0][1] = a[x];
for (int i = 0; i < (int(V[x].size())); ++i) {
int y = V[x][i];
if (!in[y]) {
dfs(y);
for (int i = (3) - 1; - 1 < i; --i)
for (int j = (3) - 1; - 1 < j; --j)
for (int k = 0; k < (3 - i); ++k)
for (int l = 0; l < (3 - j); ++l)
if (l != 2) {
if (j == 0 && l == 1) {
UpdateMax(dp[x][i + k][j + l],
dp[x][i][j] + dp[y][k][l] + a[x]);
} else {
UpdateMax(dp[x][i + k][j + l], dp[x][i][j] + dp[y][k][l]);
}
}
}
}
UpdateMax(dp[x][1][0], dp[x][0][2]);
UpdateMax(dp[x][1][0], dp[x][0][1]);
UpdateMax(dp[x][2][0], dp[x][1][2]);
UpdateMax(dp[x][2][0], dp[x][1][1]);
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= (N); ++i) {
scanf("%d", a + i);
}
for (int i = 1; i <= (N - 1); ++i) {
int x, y;
scanf("%d%d", &x, &y);
V[x].push_back(y);
V[y].push_back(x);
}
dfs(1);
long long ans = 0;
ans = max(dp[1][0][0], dp[1][0][1]);
UpdateMax(ans, max(dp[1][1][0], dp[1][1][1]));
ans = max(dp[1][2][0], ans);
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int d[N][2 * N], ok[N][2 * N], det[2 * N];
int n, m, l, k, x, y, t, w;
int main() {
cin >> t;
while (t--) {
cin >> n >> k >> l;
memset(d, 0, sizeof(d));
memset(ok, 0, sizeof(ok));
for (int i = 0; i < 2 * k; i++) ok[0][i] = 1;
for (int i = 1; i <= n; i++) cin >> d[i][0];
for (int i = 0; i < 2 * k; i++) {
if (i <= k)
det[i] = i;
else
det[i] = 2 * k - i;
}
for (int i = 0; i < 2 * k; i++)
for (int j = 1; j <= n; j++) d[j][i] = d[j][0] + det[i];
int pre;
for (int i = 1; i <= n + 1; i++) {
for (int j = 0; j < 2 * k; j++) {
if (!j)
pre = 2 * k - 1;
else
pre = j - 1;
if (d[i - 1][pre] <= l && ok[i - 1][pre] && d[i][j] <= l) ok[i][j] = 1;
}
if (ok[i][2 * k - 1] && d[i][0] <= l) ok[i][0] = 1;
for (int j = 1; j < 2 * k; j++)
if (ok[i][j - 1] && d[i][j] <= l) ok[i][j] = 1;
if (ok[i][2 * k - 1] && d[i][0] <= l) ok[i][0] = 1;
for (int j = 1; j < 2 * k; j++)
if (ok[i][j - 1] && d[i][j] <= l) ok[i][j] = 1;
}
int flag = 0;
for (int i = 0; i < 2 * k; i++)
if (ok[n + 1][i]) {
flag = 1;
}
flag ? puts("Yes") : puts("No");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
const int MAXLog = 20;
int n, k;
int a[MAXN];
int nxt[MAXN];
int sparse[MAXLog + 5][MAXN];
void init() {
stack<int> st;
for (int i = n - 1; i >= 0; i--) {
while (st.empty() == false && a[st.top()] <= a[i]) st.pop();
nxt[i] = ((st.empty() == true) ? n : st.top());
st.push(i);
}
for (int i = 0; i < n; i++) sparse[0][i] = nxt[i];
for (int i = 1; i <= MAXLog; i++) {
for (int j = 0; j < n; j++) {
if (sparse[i - 1][j] == n)
sparse[i][j] = n;
else
sparse[i][j] = sparse[i - 1][sparse[i - 1][j]];
}
}
}
int getNext(int ind, int steps) {
int ans = ind;
for (int i = MAXLog; i >= 0; i--) {
if (((steps >> i) & 1) == 1) {
ans = sparse[i][ans];
if (ans == n) return ans;
}
}
return ans;
}
int getFitting(int ind, int lim) {
int ans = 0;
for (int i = MAXLog; i >= 0; i--) {
if (sparse[i][ind] <= lim) {
ans += (1 << i);
ind = sparse[i][ind];
}
}
return ans;
}
int getAns(deque<int> &opt, int lim) {
int answer = 0, iter = 0;
;
auto it = opt.end();
it--;
while (true) {
answer = max(answer, getFitting(*it, lim));
iter++;
if (iter == 15) break;
if (it == opt.begin())
break;
else
it--;
}
return answer + 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
vector<int> output;
double average = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
init();
int answer = 0;
deque<int> opt;
for (int i = n - 1; i >= n - k; i--) {
while (opt.empty() == false &&
getFitting(i, n - 1) >= getFitting(opt.front(), n - 1))
opt.pop_front();
opt.push_front(i);
}
output.push_back(getAns(opt, n - 1));
for (int i = n - 2; i >= k - 1; i--) {
while (opt.empty() == false &&
getFitting(i - k + 1, i) >= getFitting(opt.front(), i))
opt.pop_front();
opt.push_front(i - k + 1);
while (opt.size() >= 2) {
auto it1 = opt.end();
it1--;
auto it2 = it1;
it2--;
if (getFitting(*it2, i) >= getFitting(*it1, i))
opt.pop_back();
else
break;
}
average += opt.size();
output.push_back(getAns(opt, i));
}
reverse(output.begin(), output.end());
for (int x : output) cout << x << " ";
cout << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
string inp;
string temp;
bool roman = false;
stringstream s;
string iToString(int i) {
ostringstream oss;
oss << i;
return oss.str();
}
string toroman(int n) {
if (n > 3999) return "Largest number handled is 3999";
if (n < 1) return "Smallest number handled is 1";
string nStr = iToString(n);
string rm;
for (size_t i = 0; i < nStr.length(); ++i) {
int msd = nStr[i] - '0';
char s1[] = "IVXLCDM";
char s2[] = "XLCDM**";
for (size_t j = 0; j < rm.size(); ++j) {
for (size_t k = 0; k < 7; ++k)
if (rm[j] == s1[k]) {
rm[j] = s2[k];
break;
}
}
string romanNum[] = {"", "I", "II", "III", "IV",
"V", "VI", "VII", "VIII", "IX"};
rm = rm + romanNum[msd];
}
return rm;
}
long long toten(string a, int b) {
long long res = 0;
long long now = 1;
for (int i = a.size() - 1; i >= 0; i--) {
int tmp;
if (a[i] >= '0' && a[i] <= '9')
tmp = a[i] - '0';
else
tmp = a[i] - 'A' + 10;
res += tmp * now;
now *= b;
}
return res;
}
string tobase(long long a, int b) {
if (a == 0) return "0";
string res;
while (a != 0) {
int temp = a % b;
a /= b;
char c;
if (temp < 10)
c = temp + '0';
else
c = temp - 10 + 'A';
res += c;
}
reverse(res.begin(), res.end());
return res;
}
int main() {
cin >> a;
cin >> temp;
if (temp == "R")
roman = true;
else {
s << temp;
s >> b;
}
cin >> inp;
long long ten = toten(inp, a);
cerr << "ten = " << ten << endl;
string res = roman ? toroman(ten) : tobase(ten, b);
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T Max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
T Min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
T Abs(T A) {
return A > 0 ? A : -1 * A;
}
template <typename T>
void Swap(T &a, T &b) {
T tmp = a;
a = b;
b = tmp;
}
const long long LINF = 0x3FFFFFFFFFFFFFFLL;
const int INF = 0X3FFFFFFF;
const int MAXN = 105;
vector<int> vec[MAXN];
bool vis[MAXN];
struct Node {
int dis;
long long cnt;
};
void BFS(int s, Node *nd) {
queue<int> Q;
memset(vis, false, sizeof(vis));
Q.push(s);
nd[s].cnt = 1, nd[s].dis = 0;
vis[s] = true;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
int sz = vec[u].size();
for (int i = 0; i < sz; i++) {
int v = vec[u][i];
if (!vis[v]) {
vis[v] = true;
nd[v].dis = nd[u].dis + 1;
nd[v].cnt = nd[u].cnt;
Q.push(v);
} else if (nd[u].dis + 1 == nd[v].dis)
nd[v].cnt += nd[u].cnt;
}
}
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i <= n; i++) vec[i].clear();
int u, v;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
vec[u].push_back(v), vec[v].push_back(u);
}
Node st[MAXN], ed[MAXN];
BFS(1, st);
BFS(n, ed);
long long mx_pa = 0;
for (int i = 1; i <= n; i++) {
if (st[i].dis + ed[i].dis == st[n].dis) {
long long t;
if (i == 1 || i == n)
t = 1LL;
else
t = 2LL;
long long path = st[i].cnt * ed[i].cnt * t;
if (mx_pa < path) mx_pa = path;
}
}
double ans = 1.0 * mx_pa / st[n].cnt;
printf("%.10lf\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char getc() {
char c = getchar();
while ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c > '9'))
c = getchar();
return c;
}
int gcd(int n, int m) { return m == 0 ? n : gcd(m, n % m); }
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
int n, m, a[600010], p[600010], dfn[600010], fa[600010][20], deep[600010],
f[600010 << 1], F[600010 << 1][2], pre[600010 << 1], suf[600010 << 1], t, T,
cnt, stk[600010], top;
vector<int> pos[600010];
struct data {
int to, nxt;
} edge[600010 << 1], tree[600010 << 2];
void addedge(int x, int y) {
t++;
edge[t].to = y, edge[t].nxt = p[x], p[x] = t;
}
void new_addedge(int x, int y) {
T++;
tree[T].to = y, tree[T].nxt = p[x], p[x] = T;
}
void dfs(int k) {
dfn[k] = ++cnt;
for (int i = p[k]; i; i = edge[i].nxt)
if (edge[i].to != fa[k][0]) {
fa[edge[i].to][0] = k;
deep[edge[i].to] = deep[k] + 1;
dfs(edge[i].to);
}
}
bool cmp(const int& a, const int& b) { return dfn[a] < dfn[b]; }
int lca(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int j = 19; ~j; j--)
if (deep[fa[x][j]] >= deep[y]) x = fa[x][j];
if (x == y) return x;
for (int j = 19; ~j; j--)
if (fa[x][j] != fa[y][j]) x = fa[x][j], y = fa[y][j];
return fa[x][0];
}
bool paint(int x, int y, int color) {
while (x != y) {
if (f[x] > n && f[x] != color) return 1;
f[x] = color;
x = fa[x][0];
}
return 0;
}
void dp(int k, int from) {
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from) dp(tree[i].to, k);
if (k > n) {
F[k][0] = 0;
F[k][1] = 1;
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from)
F[k][1] =
1ll * F[k][1] * (F[tree[i].to][0] + F[tree[i].to][1]) % 998244353;
} else {
F[k][0] = 1;
int cnt = 0;
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from) {
F[k][0] =
1ll * F[k][0] * (F[tree[i].to][0] + F[tree[i].to][1]) % 998244353;
pre[++cnt] = F[tree[i].to][0] + F[tree[i].to][1];
}
for (int i = 1; i <= cnt; i++) suf[i] = pre[i];
pre[0] = 1;
for (int i = 1; i <= cnt; i++)
pre[i] = 1ll * pre[i - 1] * pre[i] % 998244353;
suf[cnt + 1] = 1;
for (int i = cnt; i >= 1; i--)
suf[i] = 1ll * suf[i] * suf[i + 1] % 998244353;
int t = 0;
for (int i = p[k]; i; i = tree[i].nxt)
if (tree[i].to != from) {
t++;
F[k][1] = (F[k][1] + 1ll * pre[t - 1] * suf[t + 1] % 998244353 *
F[tree[i].to][1]) %
998244353;
}
}
}
signed main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read();
addedge(x, y), addedge(y, x);
}
fa[1][0] = 1;
dfs(1);
for (int j = 1; j < 20; j++)
for (int i = 1; i <= n; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
for (int i = 1; i <= n; i++)
if (a[i])
f[i] = n + a[i], pos[a[i]].push_back(i);
else
f[i] = i;
for (int i = 1; i <= m; i++)
if (pos[i].size() > 1) {
sort(pos[i].begin(), pos[i].end(), cmp);
int root = (*pos[i].begin());
for (int j = 0; j < pos[i].size() - 1; j++)
if (deep[lca(pos[i][j], pos[i][j + 1])] < deep[root])
root = lca(pos[i][j], pos[i][j + 1]);
if (f[root] > n && f[root] != n + i) {
cout << 0;
return 0;
}
top = 0;
stk[++top] = root;
f[root] = n + i;
for (int j = ((*pos[i].begin()) == root); j < pos[i].size(); j++) {
int l = lca(stk[top], pos[i][j]);
if (l != stk[top]) {
while (top > 1 && deep[l] <= deep[stk[top - 1]]) {
if (paint(stk[top], stk[top - 1], n + i)) {
cout << 0;
return 0;
}
top--;
}
if (paint(stk[top], l, n + i)) {
cout << 0;
return 0;
}
stk[top] = l;
}
stk[++top] = pos[i][j];
}
while (top > 1) {
if (paint(stk[top], stk[top - 1], n + i)) {
cout << 0;
return 0;
}
top--;
}
}
memset(p, 0, sizeof(p));
for (int i = 1; i <= t; i += 2)
if (f[edge[i].to] != f[edge[i + 1].to])
new_addedge(f[edge[i].to], f[edge[i + 1].to]),
new_addedge(f[edge[i + 1].to], f[edge[i].to]);
dp(n + 1, n + 1);
cout << F[n + 1][1];
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y, b, r, min;
cin >> y >> b >> r;
if (y < b) {
min = y;
} else {
min = b;
}
if (min < r) {
min = min;
} else {
min = r;
}
if (r == min) {
cout << 3 * r - 3 << endl;
} else if (b == min) {
cout << 3 * b << endl;
} else if (y == min) {
if (r == y + 1) {
cout << 3 * y << endl;
} else {
cout << 3 * y + 3 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v;
bool active;
};
int n;
vector<int> b, c;
vector<vector<int>> adjl;
vector<edge> edges;
map<int, int> compressed;
vector<int> decompress;
vector<int> circuit;
vector<int> deg;
int m;
void compress() {
vector<int> _b(b), _c(c);
sort(_b.begin(), _b.end());
sort(_c.begin(), _c.end());
int bi = 0, ci = 0, cur = 0, ind = -1;
while (bi < n - 1 && ci < n - 1) {
int val;
if (_b[bi] < _c[ci])
val = _b[bi++];
else
val = _c[ci++];
if (val == cur) continue;
compressed[val] = ++ind;
decompress.push_back(val);
cur = val;
}
while (bi < n - 1) {
int val = _b[bi++];
if (val == cur) continue;
compressed[val] = ++ind;
decompress.push_back(val);
cur = val;
}
while (ci < n - 1) {
int val = _c[ci++];
if (val == cur) continue;
compressed[val] = ++ind;
decompress.push_back(val);
cur = val;
}
m = ++ind;
}
void find_path(int node) {
for (int i = 0; i < adjl[node].size(); ++i) {
int e = adjl[node][i];
if (edges[e].active) {
edges[e].active = false;
swap(adjl[node][i], adjl[node].back());
adjl[node].pop_back();
--i;
int adj;
if (edges[e].u == node)
adj = edges[e].v;
else
adj = edges[e].u;
find_path(adj);
} else {
swap(adjl[node][i], adjl[node].back());
adjl[node].pop_back();
--i;
}
}
circuit.push_back(node);
}
void eul_path() {
int start = -1, cnt = 0;
for (int i = 0; i < m; ++i)
if (adjl[i].size() & 1) {
start = i;
++cnt;
}
if (cnt > 2) {
cout << "-1\n";
return;
}
if (start == -1) start = 0;
find_path(start);
if (circuit.size() < n)
cout << "-1\n";
else {
for (auto it : circuit) cout << decompress[it] << " ";
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
b.resize(n - 1);
c.resize(n - 1);
for (auto &it : b) cin >> it;
for (auto &it : c) cin >> it;
for (int i = 0; i < n - 1; ++i)
if (b[i] > c[i]) {
cout << "-1\n";
return 0;
}
compress();
adjl.resize(m);
deg.resize(m, 0);
for (int i = 0; i < n - 1; ++i) {
int u = compressed[b[i]], v = compressed[c[i]];
adjl[u].push_back(edges.size());
adjl[v].push_back(edges.size());
edges.push_back({u, v, true});
}
eul_path();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, sum, m;
vector<pair<int, int> > v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
sum = a + b + c + d;
v.push_back({sum, -(i + 1)});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < n; ++i) {
if (v[i].second == -1) {
ans = i + 1;
}
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[1008];
int visited[1008];
int degree[1008];
int children[1008];
int main() {
int n, a;
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> a;
degree[a]++;
graph[a].push_back(i);
}
for (int i = 0; i < 1008; i++) {
visited[i] = 0;
children[i] = 0;
}
queue<int> q;
q.push(1);
visited[1] = 1;
while (!q.empty()) {
int x = q.front();
for (int i = 0; i < graph[x].size(); i++) {
int now = graph[x][i];
if (!visited[now]) {
visited[now] = true;
if (degree[now] == 0) {
children[x]++;
}
q.push(now);
}
}
if (children[x] < 3 && degree[x] != 0) {
cout << "No" << endl;
return 0;
}
q.pop();
}
cout << "Yes" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
clock_t beg = clock();
int t = 1;
while (t--) {
int n, m, s;
cin >> n >> m >> s;
int mm[n], ee[m];
for (int i = 0; i < n; i++) cin >> mm[i];
for (int i = 0; i < m; i++) cin >> ee[i];
sort(mm, mm + n);
sort(ee, ee + m);
int ss = s / mm[0];
cerr << ss << " ";
ss *= ee[m - 1];
cerr << ss << " ";
cout << max(s, ss + (s - (mm[0] * (s / mm[0])))) << "\n";
}
clock_t end = clock();
fprintf(stderr, "\n%lf sec\n", (double)(end - beg) / (CLOCKS_PER_SEC));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[201];
const int p = -1000 * 1000 * 1000;
int temp[201];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int totalres = p;
for (int i = 0; i < n; i++) {
int cursum = 0;
for (int j = i; j < n; j++) {
cursum += a[j];
for (int l = 0; l < n; l++) temp[l] = a[l];
int sum = cursum;
for (int st = 0; st < k; st++) {
int *it = min_element(temp + i, temp + j + 1);
int *it1 = i != 0 ? max_element(temp, temp + i) : NULL;
int *it2 = j + 1 != n ? max_element(temp + j + 1, temp + n) : NULL;
if (it1 == NULL)
it1 = it2;
else
it1 = (it2 == NULL ? it1 : (*it1 > *it2 ? it1 : it2));
if (it1 != NULL) {
if (*it1 > *it) {
sum += *it1;
sum -= *it;
swap(*it1, *it);
} else
break;
}
}
totalres = max(totalres, sum);
}
}
cout << totalres;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int n, a[11111], m, ans, ans1, b[11111], leaf, jolt, flar,
umbr, glac, sylv;
bool used[11111];
vector<int> v;
int main() {
string s;
cin >> n;
cin >> s;
if (s.size() == 8) {
cout << "vaporeon";
return 0;
}
if (s.size() == 6) {
cout << "espeon";
return 0;
}
s.erase(4, 3);
for (int i = 0; i <= 3; ++i) {
if (s[0] == 's') {
sylv++;
}
if (s[0] == 'g') {
glac++;
}
if (s[0] == 'u') {
umbr++;
}
if (s[0] == 'l') {
leaf++;
}
if (s[0] == 'j') {
jolt++;
}
if (s[0] == 'f') {
flar++;
}
if (s[1] == 'y') {
sylv++;
}
if (s[1] == 'l') {
glac++;
}
if (s[1] == 'm') {
umbr++;
}
if (s[1] == 'e') {
leaf++;
}
if (s[1] == 'o') {
jolt++;
}
if (s[1] == 'l') {
flar++;
}
if (s[2] == 's') {
sylv++;
}
if (s[2] == 'a') {
glac++;
}
if (s[2] == 'b') {
umbr++;
}
if (s[2] == 'a') {
leaf++;
}
if (s[2] == 'l') {
jolt++;
}
if (s[2] == 'a') {
flar++;
}
if (s[3] == 'v') {
sylv++;
}
if (s[3] == 'c') {
glac++;
}
if (s[3] == 'r') {
umbr++;
}
if (s[3] == 'f') {
leaf++;
}
if (s[3] == 't') {
jolt++;
}
if (s[3] == 'r') {
flar++;
}
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == glac) {
cout << "glaceon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == flar) {
cout << "flareon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == sylv) {
cout << "sylveon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == leaf) {
cout << "leafeon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == umbr) {
cout << "umbreon";
return 0;
}
if (max(jolt, max(flar, max(glac, max(leaf, max(umbr, sylv))))) == jolt) {
cout << "jolteon";
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int x) {
if (x == 1) return false;
for (long long i = 2; i <= sqrt(x); i += 1)
if (x % i == 0) return false;
return true;
}
void print(int a[], int n) {
for (long long i = 0; i < n; i += 1) cout << a[i] << " ";
}
void iarr(int *a, int n) {
for (long long i = 0; i < n; i += 1) cin >> a[i];
}
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = ((res % 1000000007) * (a % 1000000007)) % 1000000007;
a = ((a % 1000000007) * (a % 1000000007)) % 1000000007;
b >>= 1;
}
return res;
}
long long numFactors(long long x) {
long long cnt = 0;
for (long long i = 1; i <= sqrt(x); i += 1) {
if (x % i == 0) {
if (x / i == i)
cnt += 1;
else
cnt += 2;
}
}
return cnt;
}
int main() {
int n, d;
cin >> n >> d;
int a[n];
iarr(a, n);
long long cnt = 0;
for (long long i = 0; i < n; i += 1) {
int temp = d + a[i];
int s = i + 2, e = n - 1, ind = -1;
int m;
while (s <= e) {
m = (s + e) / 2;
if (a[m] == temp) {
ind = max(ind, m);
break;
} else if (a[m] < temp) {
ind = max(ind, m);
s = m + 1;
} else {
e = m - 1;
}
}
if (ind != -1) {
long long val = (ind - i - 1);
cnt += ((val * (val + 1)) / 2);
}
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int l[5005], r[5005];
long long dp[5005][5005];
const long long inf = 2e16;
void Min(long long &a, long long b) {
if (a > b) a = b;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int cur = 0, tmp = n / k;
int c1 = n - tmp * k, c2 = k - c1;
for (int i = 0; i < 5005; i++)
for (int j = 0; j < 5005; j++) dp[i][j] = inf;
for (int i = 1; i <= k; i++) {
if (c1 < i)
r[i] = min(n, c1 * (tmp + 1) + (i - c1) * tmp);
else
r[i] = min(n, i * (tmp + 1));
if (c2 < i)
l[i] = min(n, c2 * tmp + (i - c2) * (tmp + 1));
else
l[i] = min(n, i * tmp);
}
dp[0][0] = 0;
for (int i = 1; i <= k; i++)
for (int j = l[i]; j <= r[i]; j++) {
int pre = j - tmp;
if (pre <= r[i - 1] && pre >= l[i - 1])
Min(dp[i][j - l[i]], dp[i - 1][pre - l[i - 1]] + a[j] - a[pre + 1]);
if (pre - 1 <= r[i - 1] && pre - 1 >= l[i - 1])
Min(dp[i][j - l[i]], dp[i - 1][pre - 1 - l[i - 1]] + a[j] - a[pre]);
}
printf("%d\n", dp[k][n - l[k]]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
long long n;
cin >> n;
vector<long long> A(n);
for (long long i = 0; i < n; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
long long k = 0;
for (long long i = 0; i < n; i++) {
if (A[i] > k) {
k++;
}
}
cout << k << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
inline int read() {
int x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x;
}
int n, k, g[41][41];
int cnt[41], ans, ch[41];
bool dfs(int u, int now) {
ch[now] = u;
if (now > ans) return ans = now, 1;
for (int v = u + 1; v <= n; ++v) {
if (!g[u][v] || now + cnt[v] + 1 <= ans) continue;
int pos = 1;
for (int i = 1; i <= now; ++i, pos = i)
if (!g[v][ch[i]]) break;
if (pos > now && dfs(v, now + 1)) return 1;
}
return 0;
}
int main() {
n = read(), k = read();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; g[i][j] = read(), ++j)
;
for (int i = n; i >= 1; dfs(i, 1), cnt[i] = ans, --i)
;
double A = 1.0 * k / ans, B = ans * (ans - 1) / 2;
printf("%.10lf\n", A * A * B);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
void gt(int a, int b) { x = a, y = b; }
} t, l, r;
struct poin {
int x, y;
int id, w;
} p[100005];
struct weight {
int card, w;
int id;
} q[100005];
bool cmp1(poin a, poin b) {
if (a.w == b.w) return a.x < b.x;
return a.w < b.w;
}
bool cmp2(weight a, weight b) {
if (a.w == b.w) return a.card < b.card;
return a.w < b.w;
}
bool cmp3(weight a, weight b) { return a.card < b.card; }
bool cmp4(poin a, poin b) { return a.id < b.id; }
map<pair<int, int>, int> f;
int x[100005], y[100005], ans[100005], s[100005], w[100005];
int G[200005], n;
int main() {
int i, j, k;
while (scanf("%d", &n) != EOF) {
f.clear();
memset(G, 0, sizeof(G));
memset(s, 0, sizeof(s));
for (i = 1; i <= n; i++) {
scanf("%d %d", &x[i], &y[i]);
f[make_pair(x[i], y[i])] = i;
p[i].x = x[i];
p[i].y = y[i];
p[i].id = i;
p[i].w = p[i].y - p[i].x;
}
for (i = 1; i <= n; i++) {
int d = y[i] - x[i] + 100000;
if (f[make_pair(x[i] + 1, y[i])] == 0 &&
f[make_pair(x[i], y[i] + 1)] == 0) {
G[d] = i;
}
}
for (i = 1; i <= n; i++) {
scanf("%d", &w[i]);
q[i].w = w[i];
q[i].card = i;
}
sort(p + 1, p + n + 1, cmp1);
sort(q + 1, q + n + 1, cmp2);
for (i = 0; i < n; i++) {
if (p[i].w != q[i].w) break;
p[i].id = q[i].card;
}
if (i != n) {
printf("NO\n");
continue;
}
int flag = 0;
int m = 100000;
for (i = n; i >= 1; i--) {
if (G[w[i] + 100000] == 0) {
flag = 1;
break;
}
int now = G[w[i] + m];
ans[i] = G[w[i] + m];
if (f[make_pair(x[now], y[now] - 1)] != 0 &&
f[make_pair(x[now] + 1, y[now] - 1)] == 0)
G[y[now] - 1 - x[now] + m] = f[make_pair(x[now], y[now] - 1)];
if (f[make_pair(x[now] - 1, y[now])] != 0 &&
f[make_pair(x[now] - 1, y[now] + 1)] == 0)
G[y[now] - x[now] + 1 + m] = f[make_pair(x[now] - 1, y[now])];
f[make_pair(x[now], y[now])] = 0;
}
if (flag == 1)
printf("NO\n");
else {
printf("YES\n");
for (i = 1; i <= n; i++) printf("%d %d\n", x[ans[i]], y[ans[i]]);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long modpow(long long a, long long n) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % 1000000007ll;
b = (b * b) % 1000000007ll;
n >>= 1;
}
return (long long)ret;
}
int par[18][100005], depth[100005];
vector<int> graph[100005];
void dfs(int node, int pitaji, int level = 1) {
depth[node] = level;
par[0][node] = pitaji;
for (int u : graph[node]) {
if (u != pitaji) dfs(u, node, level + 1);
}
}
void pre(int n) {
for (int i = 1; i < 18; i++) {
for (int j = 1; j <= n; j++) {
if (par[i - 1][j] != -1) par[i][j] = par[i - 1][par[i - 1][j]];
}
}
}
int query(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
int diff = depth[u] - depth[v];
for (int i = 0; i < (int)18; i++) {
if ((diff >> i) & 1) u = par[i][u];
}
if (u == v) return u;
for (int i = 18 - 1; i >= 0; i--) {
if (par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
}
return par[0][u];
}
int dist(int a, int b) {
return depth[a] + depth[b] - 2 * depth[query(a, b)] + 1;
}
int cal(int a, int b, int c) { return (a + b - c + 1) / 2; }
int main() {
int n, q;
cin >> n >> q;
for (int i = 0; i < (int)n - 1; i++) {
int x;
cin >> x;
graph[i + 2].push_back(x);
graph[x].push_back(i + 2);
}
dfs(1, -1);
pre(n);
while (q--) {
int a, b, c;
cin >> a >> b >> c;
int x = dist(a, b);
int y = dist(a, c);
int z = dist(c, b);
cout << max({cal(x, y, z), cal(y, z, x), cal(z, x, y)}) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int, int>
#define pll pair<long long, long long>
#define pb push_back
#define ff first
#define ss second
#define YES cout << "YES\n"
#define NO cout << "NO\n"
#define nn "\n"
#define sci(x) scanf("%d", &x)
#define LL_INF (1LL << 62)
#define INF (1 << 30)
#define SetBit(x, k) (x |= (1LL << k))
#define ClearBit(x, k) (x &= ~(1LL << k))
#define CheckBit(x, k) (x & (1LL << k))
#define mod 1000000007
#define N 100005
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while(t--){
int n, k;
cin >> n >> k;
vector<int> v1, v2;
for(int i = 0; i < n-k+1; i++){
v1.pb(k-i);
}
// if(v1.empty()) v1.pb(k);
for(int i = 1; i < v1.back(); i++){
v2.pb(i);
}
for(int x: v2)
cout << x << " ";
for(int x: v1)
cout << x << " ";
cout << nn;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
if (a.second.first == b.second.first)
return a.second.second > b.second.second;
return a.second.first < b.second.first;
}
void showvi(vector<int> v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
void showvl(vector<long long> v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
void showvp(vector<pair<int, int> > v) {
for (int i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << endl;
}
long long fastpower(long long a, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = (ans * a) % 998244353;
a = (a * a) % 998244353;
n = n >> 1;
}
return ans;
}
void SOE() {
int prime[100001];
for (int i = 1; i <= 100000; i++) prime[i] = i;
for (int p = 2; p * p <= 100000; p++) {
if (prime[p] == p) {
for (int i = p * p; i <= 100000; i += p) {
if (prime[i] == i) prime[i] = p;
}
}
}
}
void factor(int n) {
if (n == 1) return;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
n = n / i;
}
}
}
}
int n, m, k;
void solve() {
cin >> n >> m;
vector<pair<int, pair<int, int> > > edge(m);
for (int i = 0; i < m; i++) {
cin >> edge[i].second.first >> edge[i].second.second;
edge[i].first = i;
}
sort(begin(edge), end(edge), cmp);
int so = 1, des = 2;
set<pair<int, int> > st;
vector<pair<int, int> > res(m);
int nonedge = 0;
int tot_nonedge = m - n + 1;
for (int i = 0; i < m; i++) {
if (edge[i].second.second == 1) {
res[edge[i].first] = {so, des};
if (des >= 3 && nonedge < tot_nonedge) {
for (int j = des - 2; j >= 1; j--) {
st.insert({j, des});
nonedge++;
if (nonedge >= tot_nonedge) break;
}
}
so++;
des++;
} else {
if (st.size() == 0) {
cout << "-1" << endl;
return;
}
pair<int, int> p = *st.begin();
st.erase(p);
res[edge[i].first] = p;
}
}
showvp(res);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
vector<long long int> v[105];
long long int n, vis[105] = {0}, cnt = 1, len = 1;
map<long long int, pair<long long int, long long int> > mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int j, i, x, y, ch;
cin >> n;
queue<long long int> q;
for (j = 1; j <= n; j++) {
cin >> ch >> x >> y;
for (i = 1; i < 105; i++) vis[i] = 0;
if (ch == 2) {
long long int flag = 0;
q.push(x);
vis[x] = 1;
while (!q.empty()) {
long long int s = q.front();
q.pop();
if (s == y) flag = 1;
for (i = 0; i < v[s].size(); i++) {
if (vis[v[s][i]] == 0) {
vis[v[s][i]] = 1;
q.push(v[s][i]);
}
}
}
if (flag)
cout << "YES\n";
else
cout << "NO\n";
} else {
mp[cnt] = {x, y};
for (i = 1; i < cnt; i++) {
long long int x1 = mp[i].first, y1 = mp[i].second;
if ((x < x1 && x1 < y) || (x < y1 && y1 < y)) v[i].push_back(cnt);
if ((x1 < x && x < y1) || (x1 < y && y < y1)) v[cnt].push_back(i);
}
cnt++;
}
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int t; cin>>t;
while(t--){
int n,k1,k2; cin>>n>>k1>>k2;
int w,b; cin>>w>>b;
char arr[2][n];
int i=0;
while(i<k1){
arr[0][i] = 'W';
i++;
}
while(i<n){
arr[0][i] = 'B';
i++;
}
i=0;
while(i<k2){
arr[1][i] = 'W';
i++;
}
while(i<n){
arr[1][i] = 'B';
i++;
}
int cnt_black = 0;
int cnt_white = 0;
i = 0;
while(i<n){
if(arr[1][i]==arr[0][i] && arr[1][i]=='W'){
arr[1][i] = 'K';
arr[0][i] = 'K';
cnt_white++;
}
if(arr[1][i]==arr[0][i] && arr[1][i]=='B'){
arr[1][i] = 'K';
arr[0][i] = 'K';
cnt_black++;
}
i++;
}
i=0;
while(i<n-1){
if(arr[0][i] == arr[0][i+1] && arr[0][i]=='W'){
arr[0][i] = 'K';
arr[0][i+1] = 'K';
cnt_white++;
i++;
}
if(arr[0][i] == arr[0][i+1] && arr[0][i]=='B'){
arr[0][i] = 'K';
arr[0][i+1] = 'K';
cnt_black++;
i++;
}
i++;
}
i=0;
while(i<n-1){
if(arr[1][i] == arr[1][i+1] && arr[1][i]=='W'){
arr[1][i] = 'K';
arr[1][i+1] = 'K';
cnt_white++;
i++;
}
if(arr[1][i] == arr[1][i+1] && arr[1][i]=='B'){
arr[1][i] = 'K';
arr[1][i+1] = 'K';
cnt_black++;
i++;
}
i++;
}
if(cnt_white>=w && cnt_black>=b){
cout<<"YES"<<endl;
}
else{
cout<<"NO"<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x;
int main() {
cin >> x;
if (x == 1) {
cout << x << endl;
return 0;
}
if (x == 2) {
cout << 3 << endl;
return 0;
}
if (x == 3) {
cout << 5 << endl;
return 0;
}
int sharp = 0;
for (int i = 3; i < 100; i += 2) {
if ((i * i + 1) / 2 >= x) {
cout << i << endl;
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, K, x;
cin >> n >> K >> x;
long long a[n + 1];
for (long long i = 1; i <= n; i++) cin >> a[i];
long long Su[n + 1][x + 1];
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= x; j++) {
Su[i][j] = -1e18;
}
}
Su[0][0] = 0;
for (long long j = 1; j <= x; j++) {
deque<long long> Q;
for (long long i = 1; i <= n; i++) {
while (!Q.empty() && Su[Q.back()][j - 1] <= Su[i - 1][j - 1])
Q.pop_back();
Q.push_back(i - 1);
while (true) {
if (Q.empty()) break;
if (i - Q.front() > K)
Q.pop_front();
else
break;
}
if (!Q.empty()) {
long long k = Q.front();
Su[i][j] = max(Su[i][j], Su[k][j - 1]);
}
Su[i][j] += a[i];
}
}
long long maxi = 0;
for (long long i = 1; i <= n; i++) {
if (n - i < K) maxi = max(maxi, Su[i][x]);
}
if (maxi <= 0) maxi = -1;
cout << maxi << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
long long m, n, i, j, k, l, ans = 0;
cin >> n >> m;
while (n && m) {
if (n > m) {
ans += (n / m);
n = n % m;
} else {
ans += (m / n);
m = m % n;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
const long long maxn = (long long)1e5 + 1000;
const long long maxe = (long long)1e6 + 7;
const long long INF = (long long)1e9 + 7;
const double PI = acos(-1);
int dx[4] = {0, 0, 1, -1};
int dy[4] = {-1, 1, 0, 0};
void mul(long long &a, long long b) {
a = a * b % mod;
a %= mod;
}
int n;
struct E {
int to, x, col;
E(int to, int x, int col) : to(to), x(x), col(col) {}
};
vector<E> G[maxn];
bool cen[maxn];
int si[maxn];
long long ans = 1;
void calsize(int v, int p) {
si[v] = 1;
for (int i = 0; i < ((int)(G[v]).size()); i++) {
E e = G[v][i];
if (e.to == p || cen[e.to]) continue;
calsize(e.to, v);
si[v] += si[e.to];
}
}
pair<int, int> findcen(int v, int p, int t) {
pair<int, int> res = make_pair(INF, -1);
int s = 1, m = 0;
for (int i = 0; i < ((int)(G[v]).size()); i++) {
int u = G[v][i].to;
if (u == p || cen[u]) continue;
res = min(res, findcen(u, v, t));
m = max(m, si[u]);
s += si[u];
}
m = max(m, t - s);
res = min(res, make_pair(m, v));
return res;
}
long long qpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
n >>= 1;
x = x * x % mod;
}
return res;
}
long long NI(long long x) {
long long n = mod - 2;
return qpow(x, n);
}
struct BIT {
long long pro[maxn * 3];
int sum[maxn * 3];
void add(int x, long long p) {
while (x < maxn * 3) {
pro[x] *= p;
pro[x] %= mod;
sum[x] += 1;
x += x & -x;
}
}
pair<long long, int> cal(int x) {
long long res = 1;
int su = 0;
while (x) {
res *= pro[x];
res %= mod;
su += sum[x];
x -= x & -x;
}
return make_pair(res, su);
}
void clear(int x) {
while (x < maxn * 3) {
sum[x] = 0;
pro[x] = 1;
x += x & -x;
}
}
void init(vector<int> v) {
int a = v[0];
int b = v[1];
clear(2 * b - a + 2 * maxn);
}
};
BIT bit[2];
void add_sum(int a, int b, long long x) {
bit[0].add(2 * b - a + 2 * maxn, x);
bit[1].add(2 * a - b + 2 * maxn, x);
}
void dfs(int v, int p, vector<int> c, long long pro,
vector<pair<vector<int>, long long> > &V) {
V.push_back(make_pair(c, pro));
for (int i = 0; i < ((int)(G[v]).size()); i++) {
int u = G[v][i].to;
if (cen[u] || u == p) continue;
c[G[v][i].col]++;
dfs(u, v, c, pro * G[v][i].x % mod, V);
c[G[v][i].col]--;
}
}
pair<long long, int> cal(vector<int> col) {
pair<long long, int> res = bit[0].cal(3 * maxn - 1);
pair<long long, int> rs1 = bit[0].cal(col[0] - 2 * col[1] + 2 * maxn - 1);
pair<long long, int> rs2 = bit[1].cal(col[1] - 2 * col[0] + 2 * maxn - 1);
res.first *= NI(rs1.first);
res.first %= mod;
res.first *= NI(rs2.first);
res.first %= mod;
res.second -= rs1.second;
res.second -= rs2.second;
return res;
}
void solve(int v) {
calsize(v, -1);
int s = findcen(v, -1, si[v]).second;
cen[s] = true;
for (int i = 0; i < ((int)(G[s]).size()); i++) {
int u = G[s][i].to;
if (!cen[u]) solve(u);
}
add_sum(0, 0, 1);
vector<vector<int> > gar;
vector<int> beg(2, 0);
gar.push_back(beg);
for (int i = 0; i < ((int)(G[s]).size()); i++) {
int u = G[s][i].to;
if (cen[u]) continue;
vector<pair<vector<int>, long long> > V;
vector<int> c(2, 0);
c[G[s][i].col]++;
dfs(u, s, c, G[s][i].x, V);
for (int j = 0; j < V.size(); j++) {
pair<long long, int> rs = cal(V[j].first);
mul(ans, qpow(V[j].second, rs.second));
mul(ans, rs.first);
}
for (int j = 0; j < V.size(); j++) {
add_sum(V[j].first[0], V[j].first[1], V[j].second);
gar.push_back(V[j].first);
}
}
for (int i = 0; i < gar.size(); i++) {
bit[0].init(gar[i]);
reverse(gar[i].begin(), gar[i].end());
bit[1].init(gar[i]);
}
cen[s] = false;
}
int main() {
cin >> n;
for (int i = 0; i < 3 * maxn; i++) bit[0].pro[i] = bit[1].pro[i] = 1;
for (int i = 1; i < n; i++) {
int u, v, x, c;
cin >> u >> v >> x >> c;
G[u].push_back(E(v, x, c));
G[v].push_back(E(u, x, c));
}
solve(1);
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int N = 205;
const int A = 7;
int sx[4] = {0, 0, 1, -1};
int sy[4] = {1, -1, 0, 0};
int id[A];
int d[N][N];
int r[N][N];
int dp[1 << A][N];
int path[1 << A][N];
int submask1[1 << A][N];
int submask2[1 << A][N];
int val[N][N];
int px[N];
int py[N];
char str[N][N];
void DrawMap(int d1, int d2) {
if (r[d1][d2] == d1 || r[d1][d2] == d2) {
str[px[d1]][py[d1]] = 'X';
str[px[d2]][py[d2]] = 'X';
return;
}
str[px[r[d1][d2]]][py[r[d1][d2]]] = 'X';
DrawMap(d1, r[d1][d2]);
DrawMap(r[d1][d2], d2);
}
void PrintRoute(int mask, int mk) {
if (mask == 1 || mask == 2 || mask == 4 || mask == 8 || mask == 16 ||
mask == 32 || mask == 64 || mask == 128) {
DrawMap(path[mask][mk], mk);
return;
}
if (path[mask][mk] != -1) {
DrawMap(path[mask][mk], mk);
PrintRoute(submask1[mask][mk], path[mask][mk]);
return;
}
PrintRoute(submask1[mask][mk], mk);
PrintRoute(submask2[mask][mk], mk);
}
int Steiner(int n, int a) {
int top = 1 << a;
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (d[i][j] > d[i][k] + d[k][j] - val[px[k]][py[k]]) {
d[i][j] = d[i][k] + d[k][j] - val[px[k]][py[k]];
r[i][j] = k;
}
}
}
}
for (int i = 0; i < top; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = inf;
path[i][j] = -1;
}
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < n; j++) {
dp[1 << i][j] = d[id[i]][j];
path[1 << i][j] = id[i];
}
}
for (int i = 1; i < top; i++) {
if ((i & (i - 1)) == 0) continue;
for (int k = 0; k < n; k++) {
for (int j = 1; j < i; j++) {
if ((i | j) == i &&
dp[i][k] > dp[j][k] + dp[i - j][k] - val[px[k]][py[k]]) {
dp[i][k] = dp[j][k] + dp[i - j][k] - val[px[k]][py[k]];
path[i][k] = -1;
submask1[i][k] = j;
submask2[i][k] = i - j;
}
}
}
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (dp[i][j] > dp[i][k] + d[k][j] - val[px[k]][py[k]]) {
dp[i][j] = dp[i][k] + d[k][j] - val[px[k]][py[k]];
path[i][j] = k;
submask1[i][j] = i;
}
}
}
}
int ans = inf;
int mk = -1;
for (int i = 0; i < n; i++) {
if (ans > dp[top - 1][i]) {
ans = dp[top - 1][i];
mk = i;
}
}
PrintRoute(top - 1, mk);
return ans;
}
int main() {
int n, m, k, x, y;
while (scanf("%d %d %d", &n, &m, &k) != EOF) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &val[i][j]);
str[i][j] = '.';
px[i * m + j] = i;
py[i * m + j] = j;
}
for (int i = 0; i < k; i++) {
scanf("%d %d", &x, &y);
id[i] = (x - 1) * m + y - 1;
}
for (int i = 0; i < n * m; i++)
for (int j = 0; j < n * m; j++) d[i][j] = inf;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
d[i * m + j][i * m + j] = val[i][j];
r[i * m + j][i * m + j] = i * m + j;
for (int t = 0; t < 4; t++) {
int fx = i + sx[t];
int fy = j + sy[t];
if (fx >= 0 && fx < n && fy >= 0 && fy < m) {
d[fx * m + fy][i * m + j] = d[i * m + j][fx * m + fy] =
val[i][j] + val[fx][fy];
r[fx * m + fy][i * m + j] = r[i * m + j][fx * m + fy] = i * m + j;
}
}
}
}
printf("%d\n", Steiner(n * m, k));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", str[i][j]);
}
printf("\n");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
int a, b, c;
for (int i = 0; i < n; i++) {
a = 0;
b = 0;
c = 0;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s.at(i) == 'A') {
a++;
} else if (s.at(i) == 'B') {
b++;
} else {
c++;
}
}
if (a + c == b) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn(1e5 + 5);
int n, a[maxn], k, cnt, vis[maxn], b[maxn], m, mxx;
vector<int> ans[maxn];
pair<int, int> mxlen, f[maxn], mx[maxn];
priority_queue<pair<int, int> > Q;
inline void Greedy(int mxl) {
int i, j;
for (i = 1; i <= n; ++i) vis[i] = 0;
for (i = 1; i <= mxl; ++i)
for (++cnt, j = 1; j <= n; ++j)
if (f[j].first == i && !vis[j]) ans[cnt].push_back(a[j]);
}
inline void Add(int x, pair<int, int> v) {
for (; x <= mxx; x += x & -x) mx[x] = max(mx[x], v);
}
inline pair<int, int> Query(int x) {
pair<int, int> ret;
ret.first = ret.second = 0;
for (; x; x ^= x & -x) ret = max(ret, mx[x]);
return ++ret.first, ret;
}
inline void Solve() {
int i;
scanf("%d", &n), mxx = n;
for (i = 1; i <= n; ++i) scanf("%d", &a[i]), ans[i].clear(), vis[i] = 0;
for (k = 1; (long long)(k * (k + 1) >> 1) <= n; ++k)
;
--k, mxlen = make_pair(0, 0), cnt = 0;
while (n) {
for (i = 1; i <= mxx; ++i) mx[i] = make_pair(0, 0);
mxlen = make_pair(0, 0);
for (i = 1; i <= n; ++i) {
f[i] = Query(a[i] - 1), Add(a[i], make_pair(f[i].first, i));
mxlen = max(mxlen, make_pair(f[i].first, i));
}
if (mxlen.first <= k) {
Greedy(mxlen.first);
break;
}
for (++cnt, i = mxlen.second; i; i = f[i].second) vis[i] = cnt;
for (m = 0, i = 1; i <= n; ++i)
if (vis[i] == cnt)
ans[cnt].push_back(a[i]);
else
b[++m] = a[i];
for (--k, n = m, i = 1; i <= m; ++i) a[i] = b[i];
}
printf("%d\n", cnt);
for (i = 1; i <= cnt; ++i) {
printf("%d ", (int)ans[i].size());
for (int j : ans[i]) printf("%d ", j);
puts("");
}
}
int main() {
int test;
scanf("%d", &test);
while (test--) Solve();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ans = 6 * n + 3 * (n - 1) * (n) + 1;
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, z, t1, t2, t3;
cin >> x >> y >> z >> t1 >> t2 >> t3;
long long stairs = abs(x - y) * t1;
long long elevator = abs(z - x) * t2 + t3 + t3 + abs(y - x) * t2 + t3;
if (elevator <= stairs)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long pw[100000];
long long cummulativePw[100000];
long long seg[400000];
long long toPush[400000];
string str;
void build(int ind, int l, int r) {
if (l == r) {
seg[ind] = str[l] - '0';
return;
}
int m = (l + r) / 2;
build(ind * 2 + 1, l, m);
build(ind * 2 + 2, m + 1, r);
seg[ind] = (pw[r - m] * seg[ind * 2 + 1] + seg[ind * 2 + 2]) % 1000000007LL;
return;
}
void update(int ind, int s, int e, int l, int r, long long c) {
if (s > r || e < l) return;
if (l <= s && e <= r) {
toPush[ind] = c + 1;
seg[ind] = c * cummulativePw[e - s] % 1000000007LL;
return;
}
int m = (s + e) / 2;
if (toPush[ind] > 0) {
toPush[ind * 2 + 1] = toPush[ind * 2 + 2] = toPush[ind];
toPush[ind] = 0;
seg[ind * 2 + 1] =
(toPush[ind * 2 + 1] - 1) * cummulativePw[m - s] % 1000000007LL;
seg[ind * 2 + 2] =
(toPush[ind * 2 + 2] - 1) * cummulativePw[e - m - 1] % 1000000007LL;
}
update(ind * 2 + 1, s, m, l, r, c);
update(ind * 2 + 2, m + 1, e, l, r, c);
seg[ind] = (pw[e - m] * seg[ind * 2 + 1] + seg[ind * 2 + 2]) % 1000000007LL;
return;
}
long long query(int ind, int s, int e, int l, int r) {
if (s > r || e < l) return 0;
if (l <= s && e <= r) {
return seg[ind];
}
int m = (s + e) / 2;
if (toPush[ind] > 0) {
toPush[ind * 2 + 1] = toPush[ind * 2 + 2] = toPush[ind];
toPush[ind] = 0;
seg[ind * 2 + 1] =
(toPush[ind * 2 + 1] - 1) * cummulativePw[m - s] % 1000000007LL;
seg[ind * 2 + 2] =
(toPush[ind * 2 + 2] - 1) * cummulativePw[e - m - 1] % 1000000007LL;
}
return (query(ind * 2 + 1, s, m, l, r) * pw[e - m] +
query(ind * 2 + 2, m + 1, e, l, r)) %
1000000007LL;
}
int main() {
int n, m, i, type, l, r, d;
cin >> n >> m >> i;
m += i;
pw[0] = cummulativePw[0] = 1;
for (i = 1; i < n; i++) {
pw[i] = pw[i - 1] * 256LL % 1000000007LL;
cummulativePw[i] = (cummulativePw[i - 1] + pw[i]) % 1000000007LL;
}
cin >> str;
build(0, 0, n - 1);
for (i = 0; i < m; i++) {
cin >> type >> l >> r >> d;
l--, r--;
if (type == 1) {
update(0, 0, n - 1, l, r, d);
} else {
bool f = query(0, 0, n - 1, l, r - d) ==
query(0, 0, n - 1, l + d, r) * pw[d] % 1000000007LL;
cout << (f ? "YES" : "NO") << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
static void call(string::iterator it, string::iterator ed) {}
template <typename T, typename... aT>
static void call(string::iterator it, string::iterator ed, T a, aT... rest) {
string b;
for (; *it != ','; ++it)
if (*it != ' ') b += *it;
cout << b << "=" << a << " ";
call(++it, ed, rest...);
}
};
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
string f, l, login = "zzzzzzzzzzzzzzzzzzzzz";
cin >> f >> l;
for (int i = (int)(0); i < (int)(f.size()); ++i) {
for (int j = (int)(0); j < (int)(l.size()); ++j) {
login = min(login, f.substr(0, i + 1) + l.substr(0, j + 1));
}
}
cout << login << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int Read() {
char c;
c = getchar();
int tsqua = 0;
while (c != ' ' && c != '\n') {
tsqua = (((tsqua << 1) << 1) << 1) + (tsqua << 1) + (int)(c - '0');
c = getchar();
}
return tsqua;
}
int n;
int k;
struct Group {
bool aaaa;
bool abab;
bool aabb;
bool abba;
string s1;
string s2;
string s3;
string s4;
} s[2538];
bool Vowelss(char s) {
if (s == 'a') return true;
if (s == 'e') return true;
if (s == 'i') return true;
if (s == 'u') return true;
if (s == 'o') return true;
return false;
}
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> s[i].s1 >> s[i].s2 >> s[i].s3 >> s[i].s4;
string a1;
string a2;
string a3;
string a4;
int m1 = 0;
int m2 = 0;
int m3 = 0;
int m4 = 0;
bool O1 = 0;
bool O2 = 0;
bool O3 = 0;
bool O4 = 0;
int ind1;
int ind2;
int ind3;
int ind4;
for (int j = s[i].s1.size(); j >= 0; j--)
if (Vowelss(s[i].s1[j])) {
m1++;
if (m1 == k) {
O1 = 1;
ind1 = j;
break;
}
}
if (!O1) {
cout << "NO";
return 0;
}
for (int j = s[i].s2.size(); j >= 0; j--)
if (Vowelss(s[i].s2[j])) {
m2++;
if (m2 == k) {
O2 = 1;
ind2 = j;
break;
}
}
if (!O2) {
cout << "NO";
return 0;
}
for (int j = s[i].s3.size(); j >= 0; j--)
if (Vowelss(s[i].s3[j])) {
m3++;
if (m3 == k) {
O3 = 1;
ind3 = j;
break;
}
}
if (!O3) {
cout << "NO";
return 0;
}
for (int j = s[i].s4.size(); j >= 0; j--)
if (Vowelss(s[i].s4[j])) {
m4++;
if (m4 == k) {
O4 = 1;
ind4 = j;
break;
}
}
if (!O4) {
cout << "NO";
return 0;
}
a1 = s[i].s1.substr(ind1);
a2 = s[i].s2.substr(ind2);
a3 = s[i].s3.substr(ind3);
a4 = s[i].s4.substr(ind4);
if ((a1 == a2) && (a2 == a3) && (a3 == a4)) s[i].aaaa = 1;
if ((a1 == a2) && (a3 == a4)) s[i].aabb = 1;
if ((a1 == a3) && (a2 == a4)) s[i].abab = 1;
if ((a1 == a4) && (a2 == a3)) s[i].abba = 1;
}
bool AAAA = 1;
bool ABBA = 1;
bool AABB = 1;
bool ABAB = 1;
for (int i = 1; i <= n; i++)
if (s[i].aaaa != 1) {
AAAA = 0;
break;
}
if (AAAA) {
cout << "aaaa";
return 0;
}
for (int i = 1; i <= n; i++)
if (s[i].aabb != 1) {
AABB = 0;
break;
}
if (AABB) {
cout << "aabb";
return 0;
}
for (int i = 1; i <= n; i++)
if (s[i].abba != 1) {
ABBA = 0;
break;
}
if (ABBA) {
cout << "abba";
return 0;
}
for (int i = 1; i <= n; i++)
if (s[i].abab != 1) {
ABAB = 0;
break;
}
if (ABAB) {
cout << "abab";
return 0;
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 400005;
int Q, x, la, fa[M][20], num = 1, A[M], deep[M];
long long a, b, val[M];
int main() {
scanf("%d", &Q);
deep[0] = -1;
while (Q--) {
scanf("%d%lld%lld", &x, &a, &b);
a ^= la, b ^= la;
if (x == 1) {
if (A[a] < b) {
for (int i = 19; i >= 0; i--)
if (A[fa[a][i]] < b && fa[a][i]) a = fa[a][i];
a = fa[a][0];
}
A[++num] = b;
fa[num][0] = a;
deep[num] = deep[a] + 1;
val[num] = val[a] + b;
for (int i = 1; i < 20; i++) fa[num][i] = fa[fa[num][i - 1]][i - 1];
} else {
int y = a;
for (int i = 19; i >= 0; i--)
if (val[a] - val[fa[y][i]] <= b) y = fa[y][i];
la = deep[a] - deep[y];
printf("%d\n", la);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
struct S {
int x, y, z, i;
};
bool operator<(S a, S b) {
if (a.x != b.x) return a.x < b.x;
if (a.y != b.y) return a.y < b.y;
return a.z < b.z;
}
int main() {
int n;
ignore = scanf("%d", &n);
vector<S> V1(n);
for (int i = 0; i < n; i++) {
ignore = scanf("%d %d %d", &V1[i].x, &V1[i].y, &V1[i].z);
V1[i].i = i + 1;
}
sort(V1.begin(), V1.end());
vector<S> V2;
for (int i = 0; i < (int)V1.size();) {
int j = i;
while (j < (int)V1.size() && V1[j].x == V1[i].x && V1[j].y == V1[i].y) j++;
int d = i;
while (d + 1 < j) {
printf("%d %d\n", V1[d].i, V1[d + 1].i);
d += 2;
}
if (d < j) {
V2.push_back(V1[d]);
}
i = j;
}
vector<S> V3;
for (int i = 0; i < (int)V2.size();) {
int j = i;
while (j < (int)V2.size() && V2[j].x == V2[i].x) j++;
int d = i;
while (d + 1 < j) {
printf("%d %d\n", V2[d].i, V2[d + 1].i);
d += 2;
}
if (d < j) {
V3.push_back(V2[d]);
}
i = j;
}
for (int i = 0; i < (int)V3.size(); i += 2) {
printf("%d %d\n", V3[i].i, V3[i + 1].i);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n];
bitset<int(1e6)> b;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int m;
cin >> m;
for (int i = 0, tmp; i < m; ++i) {
cin >> tmp;
b.set(tmp - 1);
}
stack<int> s;
for (int i = n - 1; i >= 0; --i) {
if (b.test(i)) {
s.push(a[i]);
} else if (s.empty() || s.top() != a[i]) {
s.push(a[i]);
b.set(i);
} else {
s.pop();
}
}
if (!s.empty()) {
cout << "NO";
return 0;
}
cout << "YES" << '\n';
for (int i = 0; i < n; ++i) {
cout << (b[i] ? -a[i] : a[i]) << ' ';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int n, l, lefti, r, mid, a, b, m, t;
void BS() {
l = lefti, r = (t - a) / b + 1;
while (l < r) {
mid = (l + r + 1) / 2;
if ((2 * a + b * (lefti + mid - 2)) * (mid - lefti + 1) / 2 <= t * m &&
a + b * (mid - 1) <= t)
l = mid;
else
r = mid - 1;
}
if ((2 * a + b * (lefti + l - 2)) * (l - lefti + 1) / 2 <= t * m &&
a + b * (l - 1) <= t)
cout << l << endl;
else
cout << -1 << endl;
}
int main() {
cin >> a >> b >> n;
while (n--) {
cin >> lefti >> t >> m;
BS();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, O, V, K, p, t;
int f[80][80][80][2], sum[3][80];
char str[80];
vector<int> ve[3];
int main() {
scanf("%d", &n);
scanf("%s", str + 1);
for (int i = 1; i <= n; ++i) {
if (str[i] == 'V')
++V, ve[0].push_back(i);
else if (str[i] == 'K')
++K, ve[1].push_back(i);
else
++O, ve[2].push_back(i);
sum[0][i] = V;
sum[1][i] = K;
sum[2][i] = O;
}
memset(f, 0x3f, sizeof(f));
f[0][0][0][1] = 0;
for (int i = 0; i <= V; ++i)
for (int j = 0; j <= K; ++j)
for (int k = 0; k <= O; ++k) {
if (i < V) {
p = ve[0][i];
t = i + 1 + max(j, sum[1][p]) + max(k, sum[2][p]) - (i + 1) - j - k;
f[i + 1][j][k][0] = min(f[i + 1][j][k][0], f[i][j][k][0] + t);
f[i + 1][j][k][0] = min(f[i + 1][j][k][0], f[i][j][k][1] + t);
}
if (j < K) {
p = ve[1][j];
t = max(i, sum[0][p]) + j + 1 + max(k, sum[2][p]) - i - (j + 1) - k;
f[i][j + 1][k][1] = min(f[i][j + 1][k][1], f[i][j][k][1] + t);
}
if (k < O) {
p = ve[2][k];
t = max(i, sum[0][p]) + max(j, sum[1][p]) + (k + 1) - i - j - (k + 1);
f[i][j][k + 1][1] = min(f[i][j][k + 1][1], f[i][j][k][0] + t);
f[i][j][k + 1][1] = min(f[i][j][k + 1][1], f[i][j][k][1] + t);
}
}
printf("%d\n", min(f[V][K][O][0], f[V][K][O][1]));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
cin >> n >> p;
vector<pair<int, int> > src(n + 1, make_pair(0, 0));
vector<pair<int, int> > sink(n + 1, make_pair(0, 0));
for (int i = 0; i < p; i++) {
int a, b, d;
cin >> a >> b >> d;
src[b] = make_pair(a, d);
sink[a] = make_pair(b, d);
}
vector<pair<pair<int, int>, int> > res;
for (int i = 1; i <= n; i++) {
if (src[i].first) {
continue;
}
int max_flow = 1000001;
int cur = i;
while (sink[cur].first) {
max_flow = min(max_flow, sink[cur].second);
cur = sink[cur].first;
}
if (cur != i) {
pair<pair<int, int>, int> l = make_pair(make_pair(i, cur), max_flow);
res.push_back(l);
}
}
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) {
cout << res[i].first.first << " " << res[i].first.second << " "
<< res[i].second << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long int INF = 9e18 + 2e17;
const int inf = 2e9;
const int N = 1e3 + 22;
const double eps = 1e-10;
const double PI = 3.14159265;
long long int w[505][505], x[505], ans[505];
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cin >> w[i][j];
}
for (int k = 1; k <= n; k++) cin >> x[k];
for (int k = n; k; k--) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
w[i][j] = min(w[i][j], w[i][x[k]] + w[x[k]][j]);
}
}
for (int i = k; i <= n; i++) {
for (int j = k; j <= n; j++) ans[k] += w[x[i]][x[j]];
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, s, l;
long long f(long long n, long long m) {
long long p = n, i = 0;
while (n > 0) {
n = min(p, n + m);
i++;
n -= i;
}
return i;
}
long long fun(long long n, long long m) {
long long p = (long long)sqrt(2 * (n - m));
if (p * (p + 1) >= (2 * (n - m)))
return p + m;
else
return p + 1 + m;
}
int main() {
cin >> n >> m;
if (m >= n)
cout << n << endl;
else
cout << fun(n, m);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> prime;
vector<bool> mark(1e6 + 6, true);
vector<long long> fact(1e6 + 1, 1);
vector<long long> inv(1e6 + 1, 1);
vector<long long> invf(1e6 + 1, 1);
long long Mod = 1e9 + 7;
void seive(long long n) {
long long i, j;
mark[1] = false;
prime.push_back(2);
for (i = 4; i <= n; i += 2) mark[i] = false;
for (i = 3; i * i <= n; i++) {
if (mark[i]) {
for (j = i * i; j <= n; j += 2 * i) {
mark[j] = false;
}
}
}
for (i = 3; i <= n; i += 2)
if (mark[i]) prime.push_back(i);
}
long long ck(long long n) {
long long l = 1, r = n, mid;
while (l <= r) {
mid = (l + r) / 2;
if ((mid * (mid + 1)) / 2 < n)
l = mid + 1;
else
r = mid - 1;
}
return l;
}
void ft() {
for (long long i = 2; i <= 1e6; i++) {
fact[i] = (i * fact[i - 1]) % Mod;
}
}
void modinv() {
inv[0] = inv[1] = 1;
for (long long i = 2; i <= 1e6; i++) {
inv[i] = inv[Mod % i] * (Mod - Mod / i) % Mod;
}
}
void modfactinv() {
invf[0] = invf[1] = 1;
for (long long i = 2; i <= 1e6; i++) {
invf[i] = (invf[i - 1] * inv[i]) % Mod;
}
}
void solve(long long cs) {
long long n, m, i, z, h, w, e, k = 0, j, a, x, y, b, ans = 1;
string s;
cin >> n >> m >> k;
x = n / m;
y = x;
if (n % m) x++;
w = n % m;
z = 0;
while (k--) {
for (i = 0; i < m; i++) {
if (i < w) {
cout << x << " ";
for (j = 0; j < x; j++) cout << (z++) % n + 1 << " ";
cout << '\n';
a = z;
} else {
cout << y << " ";
for (j = 0; j < y; j++) cout << (a++) % n + 1 << " ";
cout << '\n';
}
}
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1, cs = 1;
cin >> t;
while (t--) {
solve(cs++);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
const double eps = 1e-9;
int dp[N];
string str;
int main() {
int n, k, i, len, Max = 0;
dp[0] = 0;
cin >> n >> k >> str;
for (i = 1; i <= n; i++) {
if (str[i - 1] == '#')
dp[i] = dp[i - 1] + 1;
else
dp[i] = 0;
Max = max(Max, dp[i]);
}
if (Max >= k)
puts("NO");
else
puts("YES");
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MAX = 300010;
const int MOD = 998244353;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-8;
const long double PI = acosl(-1.0);
using namespace std;
long double norm2(int a, int b) { return sqrtl(a * a + b * b); }
vector<int> vet;
long double dist;
bool inter(int i, int j) {
if (vet[i] + vet[j + 1] <= dist) return false;
if (vet[i] + dist <= vet[j]) return false;
if (vet[j + 1] + dist <= vet[i]) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int x1, y1, x2, y2, r, R;
cin >> x1 >> y1 >> r >> R;
vet.push_back(r);
vet.push_back(R);
cin >> x2 >> y2 >> r >> R;
vet.push_back(r);
vet.push_back(R);
bool suave[4];
memset(suave, 1, sizeof(suave));
dist = norm2(x1 - x2, y1 - y2);
for (int i = 0; i < 4; i++)
if (inter(i, (i < 2 ? 2 : 0))) suave[i] = 0;
int sum = 0;
for (int i = 0; i < 4; i++) sum += suave[i];
cout << sum << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
int rd() {
int k = 0;
char c = getchar();
while (c > '9' || c < '0') c = getchar();
while (c >= '0' && c <= '9') k = k * 10 + c - 48, c = getchar();
return k;
}
const int N = 100001, M = N << 1;
int n, m, u, T, L, R, ans[N];
char s[N], c[N];
int Max(int x, int y) { return x > y ? x : y; }
namespace sg {
int pn;
struct T {
int l, r;
} t[M << 5];
void Insert(int& x, int l, int r, int w) {
t[++pn] = t[x], x = pn;
if (l == r) return;
int p = (l + r) >> 1;
if (w <= p)
Insert(t[x].l, l, p, w);
else
Insert(t[x].r, p + 1, r, w);
}
void Merge(int& x, int y, int l, int r) {
if (!x || !y) {
x |= y;
return;
}
t[++pn] = t[x], x = pn;
if (l != r) {
int p = (l + r) >> 1;
Merge(t[x].l, t[y].l, l, p), Merge(t[x].r, t[y].r, p + 1, r);
}
}
bool Query(int x, int l, int r, int L, int R) {
if (!x || L > R) return 0;
if (L <= l && r <= R) return 1;
int p = (l + r) >> 1;
return L <= p && Query(t[x].l, l, p, L, R) ||
p < R && Query(t[x].r, p + 1, r, L, R);
}
}; // namespace sg
struct SAM {
int pn, tn, en, head[M], rt[M];
struct E {
int v, nxt;
} e[M];
struct T {
int f, s[26], len, v;
} t[M];
SAM() { pn = tn = 1; }
void add(int u, int v) { e[++en].v = v, e[en].nxt = head[u], head[u] = en; }
void dfs(int u) {
if (t[u].v) sg::Insert(rt[u], 1, n, t[u].v);
for (int i = head[u]; i; i = e[i].nxt)
dfs(e[i].v), sg::Merge(rt[u], rt[e[i].v], 1, n);
}
void Make() {
for (int i = 2; i <= pn; ++i) add(t[i].f, i);
}
void Insert(int c) {
int np = ++pn, p = tn;
tn = pn, t[np].len = t[p].len + 1, t[np].v = n + 1;
for (; p && !t[p].s[c]; p = t[p].f) t[p].s[c] = np;
if (!p) {
t[np].f = 1;
return;
}
int q = t[p].s[c];
if (t[q].len == t[p].len + 1) {
t[np].f = q;
return;
}
int nq = ++pn;
t[nq] = t[q], t[nq].len = t[p].len + 1, t[q].f = t[np].f = nq, t[nq].v = 0;
for (; p && t[p].s[c] == q; p = t[p].f) t[p].s[c] = nq;
}
bool Query(int u, int c, int l, int r) {
return t[u].s[c] && sg::Query(rt[t[u].s[c]], 1, n, l, r);
}
} sam;
int main() {
scanf("%s", s), T = rd();
for (; s[n] != '\0'; ++n) sam.Insert(s[n] - 'a');
sam.Make(), sam.dfs(1);
while (T--) {
L = rd(), R = rd(), scanf("%s", c);
for (m = 0, u = 1;; ++m) {
ans[m] = -1;
for (int i = Max(c[m] - 'a' + 1, 0); i < 26; ++i)
if (sam.Query(u, i, L + m, R)) {
ans[m] = i;
break;
}
if (c[m] == '\0' || !sam.Query(u, c[m] - 'a', L + m, R)) break;
u = sam.t[u].s[c[m] - 'a'];
}
while (m >= 0 && ans[m] < 0) --m;
if (m < 0) {
puts("-1");
continue;
}
for (int i = 0; i < m; ++i) putchar(c[i]);
putchar(ans[m] + 'a'), putchar('\n');
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
void CI(int &_x) { scanf("%d", &_x); }
void CO(int &_x) { cout << _x; }
template <typename T>
void getarray(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void printarray(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
const double EPS = 1e-9;
const int INF = 0x7f7f7f7f;
int dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
int dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
int dr4[4] = {0, 0, 1, -1};
int dc4[4] = {-1, 1, 0, 0};
int kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
int kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
vector<int> V;
int main() {
long long int n, k;
cin >> n >> k;
long long int first = 0, taken = 0;
for (int i = 0; i < n; i++) {
long long int temp;
cin >> temp;
if (first - ((n - i - 1) * temp * taken) < k) {
cout << i + 1 << "\n";
} else {
first += temp * taken;
taken++;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s;
map<char, int> m;
int n, cnt = 0;
cin >> n >> s;
for (char i = 'a'; i < 'z'; i++) m[i] = 0;
for (int i = 0; i < s.size(); i++) {
if (islower(s[i]))
m[s[i]]++;
else if (isupper(s[i]) && m[s[i] + 32])
m[s[i] + 32]--;
else
cnt++;
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string c, d, x;
struct node {
string a, b;
} f[1005];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> f[i].a >> f[i].b;
for (int i = 1; i <= m; i++) {
cin >> c >> d;
for (int j = 1; j <= n; j++) {
x = f[j].b + ";";
if (d == x) {
cout << c << " " << d << " "
<< "#" << f[j].a << endl;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s, t;
void solve() {
cin >> n >> s >> t;
deque<int> d{0};
int st = 0, n0 = 0, n1 = 0;
for (int i = (0); i < (n); ++i)
if (s[i] != t[i]) {
if (s[i] == '0')
++n0;
else
++n1;
if (st == s[i] - '0') {
++d.back();
} else {
st ^= 1;
d.push_back(1);
}
}
if (n0 != n1) {
cout << "-1\n";
return;
}
if (d.front() == 0) d.pop_front();
if (int((d).size()) & 1) {
d.front() += d.back();
d.pop_back();
}
int ans = 0;
while (int((d).size())) {
int m = *min_element((d).begin(), (d).end());
for (auto& x : (d)) x -= m;
ans += m;
deque<int> dt = {0};
for (int i = (0); i < (int((d).size())); ++i) {
if (d[i])
dt.push_back(d[i]);
else if (++i < int((d).size()))
dt.back() += d[i];
}
if (dt.front() == 0) dt.pop_front();
d = dt;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long power(long long a, long long b) {
a %= mod;
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans;
}
int main() {
long long n, m, k;
while (cin >> n >> m >> k) {
if (n % 2 != m % 2 && k == -1)
cout << 0 << endl;
else
cout << power(power(2, m - 1), n - 1) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
int ret = 0;
for (int i = 0; i < n; i++) {
if (a[i] < 0 || a[i] > n)
ret++;
else if (i > 0 && a[i] == a[i - 1])
ret++;
}
cout << ret << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int llINF = 0x3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
long long int dollar[200200];
long long int pound[200200];
long long int best_dollar[200200];
long long int best_pound[200200];
long long int acumd[200200];
long long int acump[200200];
vector<pair<long long int, long long int> > gad_d, gad_p;
int nd = 0;
int np = 0;
long long int n, m, k, s;
long long int check(int mid) {
long long int ans = llINF;
for (int i = 0; i <= np; i++) {
long long int sum = 0;
if (k - i > nd) continue;
sum += dollar[best_dollar[mid]] * acumd[k - i];
sum += pound[best_pound[mid]] * acump[i];
if (sum <= s) ans = i;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k >> s;
dollar[0] = pound[0] = INF;
for (int i = 1; i <= n; i++) {
cin >> dollar[i];
if (dollar[i] <= dollar[best_dollar[i - 1]])
best_dollar[i] = i;
else
best_dollar[i] = best_dollar[i - 1];
}
for (int i = 1; i <= n; i++) {
cin >> pound[i];
if (pound[i] <= pound[best_pound[i - 1]])
best_pound[i] = i;
else
best_pound[i] = best_pound[i - 1];
}
for (int i = 1; i <= m; i++) {
int t;
long long int cost;
cin >> t >> cost;
if (t == 1) {
nd++;
gad_d.push_back({cost, i});
} else {
np++;
gad_p.push_back({cost, i});
}
}
sort(gad_p.begin(), gad_p.end());
sort(gad_d.begin(), gad_d.end());
for (int i = 1; i <= nd; i++) acumd[i] = acumd[i - 1] + gad_d[i - 1].first;
for (int i = 1; i <= np; i++) acump[i] = acump[i - 1] + gad_p[i - 1].first;
int best = INF;
int ini = 1;
int end = n;
while (ini <= end) {
int mid = (ini + end) / 2;
if (check(mid) != llINF) {
best = min(best, mid);
end = mid - 1;
} else
ini = mid + 1;
}
if (best == INF) {
cout << -1 << endl;
return 0;
}
int lol = check(best);
cout << best << endl;
for (int i = 0; i < lol; i++)
cout << gad_p[i].second << " " << best_pound[best] << endl;
for (int i = 0; i < k - lol; i++)
cout << gad_d[i].second << " " << best_dollar[best] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char str[120][120];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", str[i]);
int x1, x2, y1, y2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (str[i][j] == 'B') {
x1 = i, y1 = j;
break;
}
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (str[i][j] == 'B') {
x2 = i, y2 = j;
break;
}
}
}
printf("%d %d\n", (x1 + x2) / 2 + 1, (y1 + y2) / 2 + 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const double EPS = 1e-8;
const int MOD = 1e9 + 7;
long long qpow(long long x, long long n, long long mod = MOD) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
namespace Solver {
void InitOnce() { int t; }
int n, m;
void Read() {
int res = scanf("%d%d", &n, &m);
if (res == -1) exit(0);
}
int cnt1[5];
int cnt2[5];
void Solve() {
memset(cnt1, 0, sizeof(cnt1));
memset(cnt2, 0, sizeof(cnt2));
for (int i = 1; i <= n; ++i) ++cnt1[i % 5];
for (int i = 1; i <= m; ++i) ++cnt2[i % 5];
long long sum = 0;
sum += 1LL * cnt1[0] * cnt2[0];
sum += 1LL * cnt1[1] * cnt2[4];
sum += 1LL * cnt1[2] * cnt2[3];
sum += 1LL * cnt1[3] * cnt2[2];
sum += 1LL * cnt1[4] * cnt2[1];
printf("%lld\n", sum);
return;
}
} // namespace Solver
int main() {
Solver::InitOnce();
while (true) {
Solver::Read();
Solver::Solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long i, n, m, k, a[200004];
double c;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> m;
int y = min(min(i, n - i + 1), min(k, n + 1 - k));
c += m * y;
}
c /= (n - k + 1);
printf("%.15f", c);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[10001];
char t[20][10001];
int tl[20];
int l[10001];
int r[10001];
int n, len;
int z[10001];
char b[10001];
char good[4005][4005];
const unsigned long long mod = 123526111;
const unsigned long long mod2 = 1234567891;
const unsigned long long alpha = 31;
unsigned long long h[5005];
unsigned long long h2[5005];
unsigned long long apow[5005];
unsigned long long apow2[5005];
set<pair<unsigned long long, unsigned long long> > ht;
int res = 0;
void addh(int l, int r) {
unsigned long long hl = h[l] * apow[r - l];
hl %= mod;
unsigned long long ch = (h[r] - hl + mod) % mod;
unsigned long long hl2 = h2[l] * apow2[r - l];
hl2 %= mod2;
unsigned long long ch2 = (h2[r] - hl2 + mod2) % mod2;
if (ht.find(make_pair(ch, ch2)) == ht.end()) {
ht.insert(make_pair(ch, ch2));
++res;
}
}
inline void calc(int n) {
for (int i = 0; i <= n; ++i) z[i] = 0;
int l = 0, r = 0;
for (int i = 1; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && b[z[i]] == b[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
}
int sum[100001];
void solve(const int lb) {
int ret = 0;
for (int i = lb + 1; i <= len; ++i) good[lb][i] = 1;
int bl = 0;
for (int i = lb; i < len; ++i) b[bl++] = s[i];
b[bl++] = '#';
int bs = bl;
for (int ii = 0; ii < n; ++ii) {
bl = bs;
for (int i = 0; i < tl[ii]; ++i) b[bl++] = t[ii][i];
calc(bl);
for (int i = 0; i <= bs; ++i) sum[i] = 0;
for (int i = bs; i < bl; ++i) {
sum[z[i]]++;
}
int cs = 0;
for (int i = bs; i >= 0; --i) {
cs += sum[i];
sum[i] = cs;
}
for (int i = 1; i < bs; ++i)
if (!(l[ii] <= sum[i] && sum[i] <= r[ii])) {
good[lb][lb + i] = 0;
}
}
}
int main() {
gets(s);
len = strlen(s);
for (int i = 0; i < len; ++i) {
h[i + 1] = h[i] * alpha + (s[i] - 'a' + 1);
h[i + 1] %= mod;
h2[i + 1] = h2[i] * alpha + (s[i] - 'a' + 1);
h2[i + 1] %= mod2;
}
apow[0] = apow2[0] = 1;
for (int i = 0; i <= len; ++i) {
apow[i + 1] = (apow[i] * alpha) % mod;
apow2[i + 1] = (apow2[i] * alpha) % mod2;
}
scanf("%d\n", &n);
for (int i = 0; i < n; ++i) {
scanf("%s%d%d\n", t[i], l + i, r + i);
tl[i] = strlen(t[i]);
}
for (int i = 0; i < len; ++i) solve(i);
n = len;
for (int len = 1; len <= n; ++len) {
for (int i = 0; i + len <= n; ++i)
if (good[i][i + len]) {
addh(i, i + len);
}
ht.clear();
}
cout << res << '\n';
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.