solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9;
const int MAX = 6000;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
while (x % 2 == 0) ++a[i], x /= 2;
while (x % 5 == 0) ++b[i], x /= 5;
}
vector<vector<int>> dp(k + 1, vector<int>(MAX + 1, -INF));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = k - 1; j >= 0; j--) {
for (int l = 0; l + b[i] <= MAX; l++) {
dp[j + 1][l + b[i]] = max(dp[j + 1][l + b[i]], dp[j][l] + a[i]);
}
}
}
int res = 0;
for (int i = 0; i <= MAX; i++) {
res = max(res, min(i, dp[k][i]));
}
cout << res << endl;
return 0;
}
| 4 |
#include<iostream>
#include<vector>
#include<string>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
struct Seg{
int s,e,no;
Seg(){}
Seg(int a,int b,int c):s(a),e(b),no(c){}
};
vector<Seg> v;
void write(int l,int s){
for(int i=0;s;i++){
if(v[i].no!=-1)continue;
int t = v[i].e-v[i].s;
if(t<=s){
v[i].no=l;
s-=t;
}else{
t = v[i].s;
v[i].s += s;
v.insert(v.begin()+i,Seg(t,t+s,l));
s=0;
}
}
}
void del(int l){
for(int i=0;i<v.size();i++){
if(v[i].no==l){
v[i].no=-1;
}
}
}
void read(int p){
for(int i=0;i<v.size();i++){
if(v[i].s<=p&&p<v[i].e){
cout<<v[i].no<<endl;
return;
}
}
}
int main(){
int n;
while(cin>>n,n){
v.clear();
v.push_back(Seg(0,1000000000+1,-1));
while(n--){
char com;
cin>>com;
if(com=='W'){
int l,s;
cin>>l>>s;
write(l,s);
}else if(com=='D'){
int l;
cin>>l;
del(l);
}else {
int p;
cin>>p;
read(p);
}
}
cout<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int data = 0, fu = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') fu = -1, ch = getchar();
while ('0' <= ch && ch <= '9')
data = (data << 1) + (data << 3) + (ch ^ 48), ch = getchar();
return data * fu;
}
char num[200005];
int n, oo, f[2][1332], ID[11][11][11], Edge[1332][11];
long long Ans;
inline int Calc(int base, int nn) {
return (base * nn + nn * (nn + 1) / 2) % 11;
}
void dfs(int a, int b, int c) {
if (ID[a][b][c]) return;
ID[a][b][c] = ++oo;
int x = oo;
for (int v = 0; v < a; ++v) {
int ta, tb, tc;
ta = (a - b + 11 + Calc(a - b + 11, b - 1 + 11) + c + v + 1) % 11;
tb = (Calc(a - b + 11, b - 1 + 11) + v + 1) % 11;
tc = Calc(a - b + 11, c);
dfs(ta, tb, tc);
Edge[x][v] = ID[ta][tb][tc];
}
return;
}
int main() {
scanf("%s", num + 1);
n = strlen(num + 1);
for (int p = 0; p <= 9; ++p) dfs(p, p, 9);
for (int p = 1; p <= oo; ++p) f[0][p] = n;
int op = 0;
for (int i = n - 1; i >= 1; --i) {
int c = num[i + 1] - '0';
op ^= 1;
for (int p = 1; p <= oo; ++p)
if (Edge[p][c])
f[op][p] = f[op ^ 1][Edge[p][c]];
else
f[op][p] = i;
c = num[i] - '0';
if (c) Ans += f[op][ID[c][c][9]] - i + 1;
}
cout << Ans + (num[n] != '0') << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MOD = 1000000007;
int bino[101][101];
int f[11][101];
int a[10], n;
void addto(int &a, int b) {
a += b;
a %= MOD;
if (a < 0) a += MOD;
}
int mul(int a, int b) { return (int)((long long)a * b % MOD); }
int solve(int n) {
memset(f, 0, sizeof(f));
for (int l = a[0]; l <= n; l++) f[1][n - l] = bino[n - 1][l];
for (int i = 1; i <= 9; i++)
for (int j = 0; j <= n; j++)
if (f[i][j]) {
for (int k = a[i]; k <= j; k++)
addto(f[i + 1][j - k], mul(f[i][j], bino[j][k]));
}
return f[10][0];
}
int main() {
bino[0][0] = 1;
for (int i = 1; i <= 100; i++) {
bino[i][0] = 1;
for (int j = 1; j <= i; j++) {
addto(bino[i][j], bino[i - 1][j - 1]);
addto(bino[i][j], bino[i - 1][j]);
}
}
scanf("%d", &n);
for (int i = 0; i <= 9; i++) scanf("%d", &a[i]);
int ans = 0;
for (int k = 1; k <= n; k++) addto(ans, solve(k));
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
int f[maxn], n;
string s;
inline long long get(int u, int v, int t) {
if (u > v) return 0;
if (t >= v) return 1ll * (v - u + 1) * t;
if (t <= u) return 1ll * v * (v + 1) / 2 - 1ll * (u - 1) * u / 2;
return 1ll * (t - u + 1) * t + 1ll * v * (v + 1) / 2 - 1ll * t * (t + 1) / 2;
}
long long cal(int l, int r) {
if (l == r) return (s[l] == '1');
int mid = l + r >> 1;
long long ans = cal(l, mid) + cal(mid + 1, r);
f[mid] = (s[mid] == '1');
for (int i = mid - 1; i >= l; --i) f[i] = (s[i] == '1' ? f[i + 1] + 1 : 0);
for (int i = mid - 1; i >= l; --i) f[i] = max(f[i], f[i + 1]);
f[mid + 1] = (s[mid + 1] == '1');
for (int i = mid + 2; i <= r; ++i) f[i] = (s[i] == '1' ? f[i - 1] + 1 : 0);
for (int i = mid + 2; i <= r; ++i) f[i] = max(f[i], f[i - 1]);
int x = 0, y = 0;
for (int i = mid; i >= l; --i)
if (f[i] == mid - i + 1) x = f[i];
for (int i = mid + 1; i <= r; ++i)
if (f[i] == i - mid) y = f[i];
ans += 1ll * x * y * (y + 1) / 2;
ans += 1ll * y * x * (x + 1) / 2;
for (int i = mid - x; i >= l; --i) ans += get(x + 1, x + y, f[i]);
vector<int> val;
vector<long long> sum;
for (int i = mid + 1 + y; i <= r; ++i) {
ans += get(y + 1, y + x, f[i]);
val.emplace_back(max(x + y, f[i]));
}
for (int i = 0; i < val.size(); ++i)
if (i == 0)
sum.emplace_back(val[0]);
else
sum.emplace_back(sum.back() + val[i]);
if (val.size())
for (int i = mid - x; i >= l; --i) {
int pos = upper_bound(val.begin(), val.end(), f[i]) - val.begin() - 1;
ans += sum.back();
if (pos >= 0) ans -= sum[pos];
ans += 1ll * f[i] * (pos + 1);
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
s = " " + s;
cout << cal(1, n) << '\n';
}
| 6 |
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
using namespace std;
typedef long long ll;
const int INF = 1000000000;
const int MOD = 1000000007;
const double EPS = 1e-8;
//int dx[4] = {1, 0, -1, 0};
//int dy[4] = {0, 1, 0, -1};
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
struct S{
int x, y;
int c, h;
vector<int> cnt;
bool operator < (const S& s) const {
if(c + h != s.c + s.h) return c + h > s.c + s.h;
return c > s.c;
}
};
int main(){
int W, H;
while(cin >> W >> H && W){
int sx, sy, gx, gy;
vector<string> grid(H);
REP(y, H) cin >> grid[y];
REP(y, H) REP(x, W) if(grid[y][x] == 'S') { grid[y][x] = '.'; sx = x; sy = y; }
REP(y, H) REP(x, W) if(grid[y][x] == 'G') { grid[y][x] = '.'; gx = x; gy = y; }
int ice_count = 0;
int ice_id[12][12] = {};
vector<int> ice_v;
REP(y, H) REP(x, W) if(grid[y][x] == 'X' && ice_id[y][x] == 0){
ice_id[y][x] = ++ice_count;
ice_v.push_back(1);
queue<int> qx, qy;
qx.push(x); qy.push(y);
while(!qx.empty()){
int bx = qx.front(); qx.pop();
int by = qy.front(); qy.pop();
REP(r, 4) {
int nx = bx + dx[r];
int ny = by + dy[r];
if(nx >= 0 && nx < W && ny >= 0 && ny < H && grid[ny][nx] == 'X' && ice_id[ny][nx] == 0){
qx.push(nx);
qy.push(ny);
ice_id[ny][nx] = ice_count;
ice_v[ice_count - 1]++;
}
}
}
}
int h_value[12][12];
memset(h_value, -1, sizeof h_value);
queue<int> qx, qy;
qx.push(gx); qy.push(gy);
h_value[gy][gx] = 0;
while(!qx.empty()){
int bx = qx.front(); qx.pop();
int by = qy.front(); qy.pop();
REP(r, 4) {
int nx = bx + dx[r];
int ny = by + dy[r];
if(nx >= 0 && nx < W && ny >= 0 && ny < H && grid[ny][nx] != '#' && h_value[ny][nx] == -1){
qx.push(nx);
qy.push(ny);
h_value[ny][nx] = h_value[by][bx] + 1;
}
}
}
priority_queue<S> que;
S init;
init.x = sx, init.y = sy;
init.cnt.resize(ice_count);
init.c = 0; init.h = h_value[sy][sx];
set<vector<int>> used[12][12];
que.push(init);
while(!que.empty()){
S s = que.top(); que.pop();
if(s.h == 0){
cout << s.c << endl;
break;
}
REP(r, 4){
S next = s;
next.x += dx[r]; next.y += dy[r];
if(!(next.x >= 0 && next.x < W && next.y >= 0 && next.y < H && grid[next.y][next.x] != '#')) continue;
next.c ++;
next.h = h_value[next.y][next.x];
int id = ice_id[next.y][next.x] - 1;
if(id >= 0) next.cnt[id]++;
if(id >= 0 && next.cnt[id] > ice_v[id] / 2) continue;
if(used[next.y][next.x].count(next.cnt)) continue;
used[next.y][next.x].insert(next.cnt);
que.push(next);
}
}
}
return 0;
}
| 0 |
#include"bits/stdc++.h"
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define int long long
const long long mod = 1000000007;
int dp[302][302][302];
signed main() {
int n, m; cin >> n >> m;
dp[0][1][1] = 1;
rep(i, m) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
if (!dp[i][j][k])continue;
if (j != n) {
dp[i + 1][j + 1][k] += dp[i][j][k]*(n-j);
dp[i + 1][j + 1][k] %= mod;
}
dp[i + 1][j][j] += dp[i][j][k] * k;
dp[i + 1][j][j] %= mod;
if (j != k) {
dp[i + 1][j][k] += dp[i][j][k] * (j-k);
dp[i + 1][j][k] %= mod;
}
}
}
}
cout << dp[m][n][n] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, c[105], r[105];
bool h[105][105] = {0}, flag = 0;
char ch;
int main() {
cin >> n;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
cin >> ch;
if (ch == 'E') {
h[i][j] = 1;
c[j]++;
r[i]++;
}
}
for (i = 1; i <= n; i++)
if (r[i] == n) {
flag = 1;
break;
}
if (!flag) {
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (!h[i][j]) {
cout << i << " " << j << endl;
break;
}
return 0;
}
flag = 0;
for (i = 1; i <= n; i++)
if (c[i] == n) {
flag = 1;
break;
}
if (!flag) {
for (j = 1; j <= n; j++)
for (i = 1; i <= n; i++)
if (!h[i][j]) {
cout << i << " " << j << endl;
break;
}
return 0;
}
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
char c;
int n, k = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c;
if (c - '0')
a.push_back(c - '0');
else
k++;
}
if (k == n) {
cout << "YES";
return 0;
}
int t = 0, f = 0;
for (int i = 0; i <= 900; i++) {
t = 0, f = 0;
for (int j = 0; j < a.size(); j++) {
t += a[j];
if (j == a.size() - 1 && t == i && f == 1) {
cout << "YES";
return 0;
}
if (t == i) {
f = 1;
t = 0;
} else if (t > i) {
t = 0;
f = 0;
break;
}
}
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1E-12, INF = 1e13 + 7;
struct pt {
long double x, y;
pt() {}
pt(long double x, long double y) : x(x), y(y) {}
pt operator+(pt a) { return pt(x + a.x, y + a.y); }
pt operator-(pt a) { return pt(x - a.x, y - a.y); }
pt mul(long double k) { return pt(x * k, y * k); }
long double len() { return sqrt(x * x + y * y); }
pt set_len(long double k) { return mul(k / len()); }
};
struct seg {
pt p, q;
int id;
seg() {}
seg(pt p, pt q, int id) : p(p), q(q), id(id) {}
long double get_y(long double x) const {
if (abs(p.x - q.x) < EPS) return p.y;
return p.y + (q.y - p.y) * (x - p.x) / (q.x - p.x);
}
};
inline bool intersect1d(long double l1, long double r1, long double l2,
long double r2) {
if (l1 > r1) swap(l1, r1);
if (l2 > r2) swap(l2, r2);
return max(l1, l2) <= min(r1, r2) + EPS;
}
inline int vec(const pt& a, const pt& b, const pt& c) {
long double s = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
return abs(s) < EPS ? 0 : s > 0 ? +1 : -1;
}
bool intersect(const seg& a, const seg& b) {
return intersect1d(a.p.x, a.q.x, b.p.x, b.q.x) &&
intersect1d(a.p.y, a.q.y, b.p.y, b.q.y) &&
vec(a.p, a.q, b.p) * vec(a.p, a.q, b.q) <= 0 &&
vec(b.p, b.q, a.p) * vec(b.p, b.q, a.q) <= 0;
}
bool operator<(const seg& a, const seg& b) {
long double x = max(min(a.p.x, a.q.x), min(b.p.x, b.q.x));
return a.get_y(x) < b.get_y(x) - EPS;
}
struct event {
long double x;
int tp, id;
event() {}
event(long double x, int tp, int id) : x(x), tp(tp), id(id) {}
bool operator<(const event& e) const {
if (abs(x - e.x) > EPS) return x < e.x;
return tp > e.tp;
}
};
set<seg> s;
vector<set<seg>::iterator> where;
vector<event> e;
inline set<seg>::iterator prev(set<seg>::iterator it) {
return it == s.begin() ? s.end() : --it;
}
inline set<seg>::iterator next(set<seg>::iterator it) {
if (it == s.end()) return s.begin();
return ++it;
}
int dbg = 0;
bool solve(const vector<seg>& a) {
s.clear();
e.clear();
int n = (int)a.size();
for (int i = 0; i < n; ++i) {
e.push_back(event(min(a[i].p.x, a[i].q.x), +1, i));
e.push_back(event(max(a[i].p.x, a[i].q.x), -1, i));
}
sort(e.begin(), e.end());
for (size_t i = 0; i < e.size(); ++i) {
int id = e[i].id;
if (e[i].tp == +1) {
set<seg>::iterator nxt = s.lower_bound(a[id]), prv = prev(nxt);
if (nxt != s.end() && intersect(*nxt, a[id])) return 1;
if (prv != s.end() && intersect(*prv, a[id])) return 1;
where[id] = s.insert(nxt, a[id]);
} else {
set<seg>::iterator nxt = next(where[id]), prv = prev(where[id]);
if (nxt != s.end() && prv != s.end() && intersect(*nxt, *prv)) return 1;
s.erase(where[id]);
}
}
return 0;
}
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(20);
int n;
cin >> n;
pt p[n], d[n];
long double s[n];
for (int i = 0; i < n; i++)
cin >> p[i].x >> p[i].y >> d[i].x >> d[i].y >> s[i];
long double l = 0, r = INF, mid;
bool flag = 0;
where.resize(n);
for (int step = 0; step < 75; step++) {
dbg = step;
mid = (l + r) / 2;
vector<seg> v(n);
for (int i = 0; i < n; i++) {
v[i] = seg(p[i], p[i] + d[i].set_len(s[i] * mid), i);
}
if (solve(v)) {
flag = 1;
r = mid;
} else {
l = mid;
}
}
if (!flag)
cout << "No show :(" << endl;
else
cout << fixed << r << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
int GCD(int a, int b) {
if (a == 0)
return b;
else
return GCD(b % a, a);
}
long long int power(long long int a, long long int b) {
long long int r = 1;
while (b) {
if (b & 1) {
r = r * a;
b--;
}
a = a * a;
b >>= 1;
}
return r;
}
int palindrome(char *s, int len) {
int i, j, k, count = 0, c = 0;
for (i = 0, j = len - 1; i < len, j >= 0; i++, j--) {
if (s[i] == s[j]) count++;
}
if (count == len)
return 1;
else
return 0;
}
long long int binary(char *s, long long int len) {
long long int i, j, k, r = 0, p = 0, num;
for (i = len - 1; i >= 0; i--) {
num = s[i] - '0';
r += (num * power(2, p));
p++;
}
return r;
}
int binary_search(int *ara, int size, int n) {
int high, mid, low;
low = 0;
high = size - 1;
while (low <= high) {
mid = (low + high) / 2;
if (ara[mid] == n) {
return 1;
} else if (n > ara[mid])
low = mid + 1;
else if (n < ara[mid])
high = mid - 1;
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int i, j, k, n, T, q, two = 0, one = 0, count = 0;
string s1, s2;
cin >> n;
int ara[n];
for (i = 0; i < n; i++) {
cin >> ara[i];
if (ara[i] == 1)
one++;
else if (ara[i] == 2)
two++;
}
if (two == 0) {
count = one / 3;
} else if (two >= one) {
count = one;
} else if (two < one) {
count = two;
one = one - two;
count += one / 3;
}
cout << count << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
int n = s.size();
if (s[0] == 'b' && s[n - 1] == 'a') {
s[0] = 'a';
} else if (s[0] == 'a' && s[n - 1] == 'b') {
s[n - 1] = 'a';
}
cout << s << '\n';
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <iostream>
#include <complex>
#include <cmath>
#define EPS 1e-9
using namespace std;
typedef complex<double> xy_t;
int n;
xy_t points[301];
int count_in(xy_t center)
{
int ans=0;
for(int i=0;i<n;i++)
{
if (abs(center-points[i])<1.0+EPS)
ans++;
}
return ans;
}
xy_t ppdcl(xy_t a)
{
return xy_t(a.imag(),-a.real());
}
xy_t delta_v(xy_t C1,xy_t C2)
{
xy_t half=(C1-C2)*0.5;
double l=abs(half);
return ppdcl(half)*sqrt(1-l*l)*(1.0/l);
}
int main()
{
while(1)
{
cin>>n;
if (n==0) break;
double x,y;
for(int i=0;i<n;i++)
{
cin>>x>>y;
points[i]=xy_t(x,y);
}
int maxn=1;
for(int i=0;i<n;i++)
{
for(int j=i;j<n;j++)
{
if(abs(points[i]-points[j])<2.0+EPS)
{
xy_t mid_p=(points[i]+points[j])*0.5;
maxn=max(maxn,count_in(mid_p+delta_v(points[i],points[j])));
maxn=max(maxn,count_in(mid_p-delta_v(points[i],points[j])));
}
/*double d=abs(points[j]-points[i])/2;
xy_t v=(points[j]-points[i])/(2*d);
if(d<1)
{
maxn=max(maxn,count_in(points[i]+d*v+sqrt(1-d*d)*v*xy_t(0,+1)));
maxn=max(maxn,count_in(points[i]+d*v+sqrt(1-d*d)*v*xy_t(0,-1)));
}*/
}
}
cout<<maxn<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> solve(long long x1, long long y1, long long x2,
long long y2) {
long long totw, totb;
totb = totw = 0;
long long here = (x1 - 1) + (y1 - 1);
bool st = false;
if (here % 2 == 0) st = true;
long long n, m;
n = y2 - y1 + 1;
m = x2 - x1 + 1;
totw = totb = (m / 2) * n;
if (m % 2) {
totw += n / 2;
totb += n / 2;
if (n % 2) {
if (st)
totw++;
else
totb++;
}
}
vector<long long> v;
v.push_back(totw);
v.push_back(totb);
if (x2 < x1 || y2 < y1) {
v[0] = v[1] = 0;
}
return v;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
while (q--) {
long long n, m;
cin >> n >> m;
long long totw, totb;
vector<long long> v = solve(1, 1, m, n);
totw = v[0];
totb = v[1];
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
vector<long long> b = solve(x1, y1, x2, y2);
totb -= b[1];
totw += b[1];
long long x3, y3, x4, y4;
cin >> x3 >> y3 >> x4 >> y4;
long long area = max(
0LL, (min(x2, x4) - max(x1, x3) + 1) * (min(y2, y4) - max(y1, y3) + 1));
if (min(x2, x4) < max(x1, x3) || min(y2, y4) < max(y1, y3)) area = 0;
if (area == 0) {
vector<long long> c = solve(x3, y3, x4, y4);
totw -= c[0];
totb += c[0];
} else {
vector<long long> c = solve(x3, y3, x4, y4);
vector<long long> d =
solve(max(x1, x3), max(y1, y3), min(x2, x4), min(y2, y4));
long long tw = c[0] - d[0];
long long tb = c[1] - d[1];
totw -= tw;
totb += tw;
totw -= area;
totb += area;
}
cout << totw << " " << totb << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> p[2011];
long long fakt[200111], inv[200111];
long long dp[2011][35];
long long fastpow(long long x, long long y) {
long long ret = 1LL;
while (y) {
if (y & 1) ret = (ret * x) % (1000 * 1000 * 1000 + 7);
x = (x * x) % (1000 * 1000 * 1000 + 7);
y >>= 1;
}
return ret;
}
void preprocess() {
fakt[0] = inv[0] = 1;
for (long long i = 1; i < 200111; i++) {
fakt[i] = (fakt[i - 1] * i) % (1000 * 1000 * 1000 + 7);
inv[i] = fastpow(fakt[i], (1000 * 1000 * 1000 + 7) - 2);
}
}
long long C(long long x, long long y) {
return (fakt[x + y] * inv[x] % (1000 * 1000 * 1000 + 7) * inv[y]) %
(1000 * 1000 * 1000 + 7);
}
int main() {
preprocess();
long long n, k, m, s;
scanf("%lld%lld%lld%lld", &n, &m, &k, &s);
for (long long i = 1; i <= k; i++)
scanf("%lld%lld", &p[i].first, &p[i].second);
sort(p + 1, p + k + 1);
p[++k] = make_pair(n, m);
for (long long i = 1; i <= k; i++) {
long long way = C(p[i].first - 1, p[i].second - 1);
for (long long r = 1; r < 35; r++) dp[i][r] = way;
for (long long j = 1; j < i; j++) {
if (p[j].first <= p[i].first && p[j].second <= p[i].second) {
way = C(p[i].first - p[j].first, p[i].second - p[j].second);
for (long long r = 1; r < 35 - 1; r++)
dp[i][r] = (dp[i][r] - way * dp[j][r]) % (1000 * 1000 * 1000 + 7);
}
}
for (long long r = 35 - 1; r >= 1; r--)
dp[i][r] = (dp[i][r] - dp[i][r - 1]) % (1000 * 1000 * 1000 + 7);
}
long long ans = 0;
for (long long r = 1; r < 35; r++) {
ans = (ans + dp[k][r] * s) % (1000 * 1000 * 1000 + 7);
s = (s + 1) / 2;
}
ans = ans * fastpow(C(n - 1, m - 1), (1000 * 1000 * 1000 + 7) - 2) %
(1000 * 1000 * 1000 + 7);
if (ans < 0) ans += (1000 * 1000 * 1000 + 7);
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
cout << s;
reverse(s.begin(), s.end());
cout << s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
{ solve(); }
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
if ((b * 2ll - a) >= 0 && (b * 2ll - a) % 3 == 0) {
a *= 2ll;
if ((a - b) >= 0 && (a - b) % 3 == 0) {
cout << "YES\n";
} else
cout << "NO\n";
} else
cout << "NO\n";
}
return 0;
}
| 2 |
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
long long int SAS(int arr[] , int n){
long long int sum = 0;
for(int i=0;i<n;i++){
int val = arr[i];
long long int temp = i+1;
temp = temp * (n-i);
temp = temp * val;
sum = sum + temp;
}
return sum;
}
int main() {
// your code goes here
int t;
cin>>t;
while(t--){
int n;
cin>>n;
int arr[n];
for(int i=0;i<n;i++){
cin>>arr[i];
}
sort(arr,arr+n);
long long int ans = 0;
int edges[n-1];
for(int i=1;i<n;i++){
ans = ans + arr[i] - arr[i-1];
edges[i-1] = arr[i] - arr[i-1];
}
//cout<<ans<<"\n";
long long int sub = SAS(edges,n-1);
ans = ans - sub;
cout<<ans<<"\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e6 + 5;
int n;
map<char, vector<string>> v[N];
vector<string> rem, same;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
char lst;
int cnt = 0;
for (auto &j : s)
if (j == 'a' || j == 'o' || j == 'i' || j == 'e' || j == 'u')
cnt++, lst = j;
v[cnt][lst].push_back(s);
}
for (int i = 1; i <= n; i++) {
for (char j = 'a'; j <= 'z'; j++) {
for (auto &k : v[i][j]) same.push_back(k);
if (same.size() & 1) {
rem.push_back(same.back());
same.pop_back();
}
}
if (rem.size() & 1) rem.pop_back();
}
while (same.size() > rem.size()) {
rem.push_back(same.back());
same.pop_back();
rem.push_back(same.back());
same.pop_back();
}
cout << same.size() / 2 << '\n';
for (int i = 0; i < same.size(); i++)
cout << rem[i] << " " << same[i] << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e6 + 3;
long long fac[800005];
long long mpe(long long base, long long exponent, long long modulus) {
long long result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = result * base % modulus;
exponent = exponent >> 1;
base = base * base % modulus;
}
return result;
}
int par[200005][18], ht[200005];
long long fi = 1, se = 1;
int lca(int u, int v) {
if (u == v) return u;
if (ht[u] < ht[v]) swap(u, v);
int i = 18;
for (i = 17; i >= 0; i--)
if (par[u][i] && ht[par[u][i]] >= ht[v]) {
u = par[u][i];
}
if (u == v) return u;
i = 17;
for (i = 17; i >= 0; i--)
if (par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
return par[v][0];
}
long long dis(long long a, long long b) {
return ht[a] + ht[b] - 2 * ht[lca(a, b)];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
;
par[1][0] = 0;
ht[1] = 1;
long long n, an = 0;
cin >> n;
for (long long i = 2; i < n + 1; ++i) {
long long a;
cin >> a;
ht[i] = ht[a] + 1;
par[i][0] = a;
for (long long j = 1; j < 18; ++j) par[i][j] = par[par[i][j - 1]][j - 1];
long long d1 = dis(i, fi);
long long d2 = dis(i, se);
if (d1 < d2) {
swap(d1, d2);
swap(fi, se);
}
if (an < d1) {
an = d1;
se = i;
}
cout << an << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int MAXN = 2e5;
const int B = 315;
int cnt[MAXN], dp[MAXN];
vector<int> occ[MAXN];
void add_self(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void min_self(int &x, int y) { x = min(x, y); }
struct SQRT {
int id, offset, pref_sum[B];
void rebuild() {
int st = id * B, dr = (id + 1) * B - 1, minn = INT_MAX;
for (int i = st; i <= dr; ++i) min_self(minn, offset + cnt[i]);
for (int i = st; i <= dr; ++i) cnt[i] -= minn - offset;
offset = minn;
for (int i = 0; i < B; ++i) pref_sum[i] = 0;
for (int i = st; i <= dr; ++i) add_self(pref_sum[cnt[i]], dp[i]);
for (int i = 1; i < B; ++i) add_self(pref_sum[i], pref_sum[i - 1]);
}
} a[MAXN / B + 1];
int get_bucket(int index) { return index / B; }
void update(int l, int r, short t) {
int bl = get_bucket(l), br = get_bucket(r);
for (int i = l; i <= r && get_bucket(i) == bl; ++i) cnt[i] += t;
a[bl].rebuild();
if (bl == br) return;
for (int i = bl + 1; i < br; ++i) a[i].offset += t;
for (int i = r; get_bucket(i) == br; --i) cnt[i] += t;
a[br].rebuild();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, k;
cin >> n >> k;
for (int i = 0; i <= get_bucket(n); ++i) a[i].id = i;
for (int i = 1; i <= n; ++i) occ[i].emplace_back(-1);
dp[0] = 1;
a[0].rebuild();
for (int r = 0; r < n; ++r) {
int x;
cin >> x;
vector<int> &vec = occ[x];
if (static_cast<int>(vec.size()) >= 2)
update(vec.end()[-2] + 1, vec.back(), -1);
update(vec.back() + 1, r, 1);
vec.emplace_back(r);
int val = 0;
for (int i = 0; i <= get_bucket(r); ++i) {
int at_most = k - a[i].offset;
if (at_most >= 0) add_self(val, a[i].pref_sum[min(at_most, B - 1)]);
}
dp[r + 1] = val;
a[get_bucket(r + 1)].rebuild();
}
cout << dp[n] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char num[10][8] = {"1110111", "0010010", "1011101", "1011011", "0111010",
"1101011", "1101111", "1010010", "1111111", "1111011"};
long long n, k, flag = 0;
long long al[2005][2005] = {0};
char a[2005][8];
long long ans[2005];
void dfs(long long x) {
if (x == n) {
if (k == 0) {
for (int i = 0; i < n; i++) cout << ans[i];
cout << endl;
flag = 1;
}
return;
}
for (int i = 9; i >= 0; i--) {
long long b = 1, t = 0;
for (int j = 0; j < 7; j++) {
if (a[x][j] == '1' && num[i][j] == '0') {
b = 0;
break;
} else if (a[x][j] == '0' && num[i][j] == '1')
t++;
}
if (b != 0 && k >= t && al[x][k - t] == 0) {
al[x][k - t] = 1;
ans[x] = i;
k -= t;
dfs(x + 1);
if (flag == 1) return;
k += t;
}
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dfs(0);
if (flag == 0) cout << "-1" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long x;
cin >> x;
vector<pair<unsigned long long, unsigned long long> > res;
for (unsigned long long n = 1; n <= 1000000 + 500000; n++) {
if ((6 * x) % (n * (n + 1)) == 0 &&
(6 * x / (n * (n + 1)) + n - 1) % 3 == 0) {
unsigned long long m = (6 * x / (n * (n + 1)) + n - 1) / 3;
if (m >= n) {
res.push_back({n, m});
res.push_back({m, n});
}
}
}
sort(res.begin(), res.end());
int cur = (int)res.size();
for (int i = 1; i < (int)res.size(); i++)
if (res[i] == res[i - 1]) cur--;
cout << cur << endl;
for (int i = 0; i < (int)res.size(); i++) {
if (!i)
cout << res[i].first << " " << res[i].second << endl;
else if (i && res[i] != res[i - 1])
cout << res[i].first << " " << res[i].second << endl;
}
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<vector>
#include<climits>
#include<cassert>
#define IINF (INT_MAX)
#define MAX 70
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
using namespace std;
int H,W;
vector<string> G;
vector<string> rot[4];
vector<string> conv(const vector<string>& vec)
{
int n,e,s,w;
w = IINF, e = -IINF, n = IINF, s = -IINF;
for(int y=0;y<vec.size();y++){
for(int x=0;x<vec[y].size();x++){
if(vec[y][x] == '.')continue;
w = min(w,x);
e = max(e,x);
n = min(n,y);
s = max(s,y);
}
}
vector<string> ret;
for(int y=n;y<=s;y++){
ret.push_back(vec[y].substr(w,e-w+1));
}
return ret;
}
vector<string> rotate90(const vector<string>& piece){
vector<string> ret;
int h = piece[0].size(), w = piece.size();
ret.resize(h);
for(int i=0;i<h;i++)ret[i].resize(w);
for(int y=0;y<ret.size();y++){
for(int x=0;x<ret[0].size();x++){
ret[y][x] = piece[ret[0].size()-1-x][y];
}
}
return ret;
}
void InitPiece(const vector<string>& piece){
for(int i=0;i<4;i++){
vector<string> tmp = piece;
for(int j=0;j<i;j++){
tmp = rotate90(tmp);
}
rot[i] = tmp;
}
}
int calc(int sx,int sy,int type){
int ret = 0;
int h = rot[type].size(), w = rot[type][0].size();
if(sx+w-1 >= W)return -1;
if(sy+h-1 >= H)return -1;
for(int y=sy;y<sy+h;y++){
bool ok = true;
for(int x=0;x<W;x++){
if(sx <= x && x < sx+w){
if(G[y][x] == '#' && rot[type][y-sy][x-sx] == '#'){
return -1;
}
else if(G[y][x] == '.' && rot[type][y-sy][x-sx] == '.'){
ok = false;
}
}else{
if(G[y][x] != '#'){
ok = false;
}
}
}
if(ok)ret++;
}
return ret;
}
void compute(){
int ans = -1;
for(int y=0;y<H;y++){
for(int x=0;x<W;x++){
for(int type=0;type<4;type++){
int res = calc(x,y,type);
ans = max(ans,res);
}
}
}
cout << ans << endl;
}
int main(){
int T,h,w;
cin >> T;
while(T--){
cin >> h >> w;
vector<string> tmp(h);
for(int i=0;i<h;i++){
cin >> tmp[i];
}
vector<string> piece = conv(tmp);
InitPiece(piece);
cin >> H >> W;
G.resize(H);
for(int i=0;i<H;i++){
cin >> G[i];
}
compute();
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int w,l1,l2;cin>>w>>l1>>l2;if(l1>l2) swap(l1,l2);
int r1=l1+w,r2=l2+w;
cout<<max(0,l2-r1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
std::vector<pair<int, string> > par(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
par[i].first = s[i].length();
par[i].second = s[i];
}
cout << endl << endl;
std::sort(par.begin(), par.end());
for (int i = 0; i < n; i++) {
}
cout << endl << endl;
int l = par[0].first;
for (int i = 1; i < n; i++) {
if (par[i].first != l || (par[i].second == par[i - 1].second)) {
l = par[i].first;
} else {
cout << "NO\n";
return 0;
}
}
for (int i = 1; i < n; i++) {
if (par[i].second.find(par[i - 1].second) == std::string::npos) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
for (int i = 0; i < n; i++) {
cout << par[i].second << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, p[N], inv[N], tree[N], ans[N];
vector<int> prevDivs[N];
vector<pair<int, int> > qs[N];
void update(int i, int v) {
while (i < N) tree[i] += v, i += i & -i;
}
int query(int i) {
int ret = 0;
while (i > 0) ret += tree[i], i -= i & -i;
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int(i) = (1); (i) <= (int)(n); (i)++) scanf("%d", &p[i]), inv[p[i]] = i;
for (int(i) = (1); (i) <= (int)(n); (i)++) {
for (int j = i; j <= n; j += i) {
if (inv[j] <= inv[i])
prevDivs[inv[i]].push_back(inv[j]);
else
prevDivs[inv[j]].push_back(inv[i]);
}
}
for (int(i) = (1); (i) <= (int)(m); (i)++) {
int l, r;
scanf("%d%d", &l, &r);
qs[r].push_back({l, i});
}
for (int(i) = (1); (i) <= (int)(n); (i)++) {
for (int x : prevDivs[i]) update(x, 1);
for (pair<int, int> q : qs[i])
ans[q.second] = query(i) - query(q.first - 1);
}
for (int(i) = (1); (i) <= (int)(m); (i)++) printf("%d\n", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 100055;
struct Node {
vector<int> edges;
vector<long long> vals;
vector<int> colors;
vector<int> CenEdges;
} Tree[N];
int NodeSize[N];
bool visited[N];
void CentroidDFS(int cur, int prev, int *n) {
(*n)++;
NodeSize[cur] = 1;
int i;
for (i = 0; i < Tree[cur].edges.size(); i++) {
int v = Tree[cur].edges[i];
if (v != prev && !visited[v]) {
CentroidDFS(v, cur, n);
NodeSize[cur] += NodeSize[v];
}
}
}
int GetCentroid(int cur, int prev, int n) {
bool isCentroid = true;
int HeaviestChild = -1;
int i;
for (i = 0; i < Tree[cur].edges.size(); i++) {
int v = Tree[cur].edges[i];
if (v != prev && !visited[v]) {
if (HeaviestChild == -1 || NodeSize[HeaviestChild] < NodeSize[v])
HeaviestChild = v;
if (NodeSize[v] > n / 2) isCentroid = false;
}
}
if (HeaviestChild == -1 || (isCentroid && n - NodeSize[cur] <= n / 2))
return cur;
return GetCentroid(HeaviestChild, cur, n);
}
int GetCentroid(int src) {
int n = 0;
CentroidDFS(src, src, &n);
return GetCentroid(src, src, n);
}
int Decompose(int src) {
int CurCenNode = GetCentroid(src);
visited[CurCenNode] = true;
int i;
for (i = 0; i < Tree[CurCenNode].edges.size(); i++) {
int v = Tree[CurCenNode].edges[i];
if (!visited[v]) {
int NewCenNode = Decompose(v);
Tree[CurCenNode].CenEdges.push_back(NewCenNode);
}
}
return CurCenNode;
}
int CenRoot;
void CentroidDecomposition(int n) {
int i;
for (i = 0; i < n; i++) visited[i] = false;
CenRoot = Decompose(0);
for (i = 0; i < n; i++) visited[i] = false;
}
long long FenwickTree[2][2][4 * N];
vector<int> WhatToInitialize;
bool ok;
void Initialize(int ft) {
int i;
if (ok == false) {
int j;
for (j = 0; j < 2; j++) {
for (i = 0; i < 4 * N; i++) {
FenwickTree[j][0][i] = 1;
FenwickTree[j][1][i] = 0;
}
}
ok = true;
}
for (i = 0; i < WhatToInitialize.size(); i++) {
FenwickTree[ft][0][WhatToInitialize[i]] = 1;
FenwickTree[ft][1][WhatToInitialize[i]] = 0;
}
}
void Set(int ft, int x, long long w) {
for (x; x < 4 * N; x += x & (-x)) {
FenwickTree[ft][0][x] *= w;
FenwickTree[ft][0][x] %= mod;
if (FenwickTree[ft][1][x] == 0) WhatToInitialize.push_back(x);
FenwickTree[ft][1][x]++;
}
}
pair<long long, long long> Get(int ft, int x) {
pair<long long, long long> a;
a.first = 1;
a.second = 0;
for (x; x > 0; x -= x & (-x)) {
a.first *= FenwickTree[ft][0][x];
a.first %= mod;
a.second += FenwickTree[ft][1][x];
}
return a;
}
long long pow(long long x, long long p) {
long long ans = 1;
while (p > 0) {
if (p & 1) ans = (x * ans) % mod;
x = (x * x) % mod;
p >>= 1;
}
return ans;
}
struct Back {
int r, b;
long long w;
Back(int a, int d, long long c) {
r = a;
b = d;
w = c;
}
};
vector<Back> Backtrack;
long long sol = 1;
const int shift = N * 2;
void SolDFS(int cur, int prev, int red, int black, long long path) {
Backtrack.push_back(Back(red, black, path));
if (red * 2 >= black && black * 2 >= red) {
sol = (sol * path) % mod;
}
pair<long long, long long> p, q, r;
p = Get(0, 2 * red - black + shift);
q = Get(1, N * 4 - 1);
r = Get(1, 2 * black - red + shift);
long long tmp = ((p.first * r.first) % mod * pow(q.first, mod - 2)) % mod;
tmp = (tmp * pow(path, p.second - q.second + r.second)) % mod;
sol *= tmp;
sol %= mod;
int i;
for (i = 0; i < Tree[cur].edges.size(); i++) {
int v = Tree[cur].edges[i];
long long w = Tree[cur].vals[i];
int color = Tree[cur].colors[i];
if (!visited[v] && v != prev) {
int nred, nblack;
nred = red;
nblack = black;
if (color == 0)
nred++;
else
nblack++;
SolDFS(v, cur, nred, nblack, (path * w) % mod);
}
}
}
void Solve(int src) {
visited[src] = true;
Initialize(0);
Initialize(1);
WhatToInitialize.clear();
int i, j;
for (i = 0; i < Tree[src].edges.size(); i++) {
int v = Tree[src].edges[i];
long long w = Tree[src].vals[i];
int color = Tree[src].colors[i];
if (!visited[v]) {
int red = 0, black = 0;
if (color == 0)
red++;
else
black++;
SolDFS(v, src, red, black, w);
for (j = 0; j < Backtrack.size(); j++) {
Set(0, Backtrack[j].b - 2 * Backtrack[j].r + shift, Backtrack[j].w);
Set(1, Backtrack[j].r - 2 * Backtrack[j].b + shift, Backtrack[j].w);
}
Backtrack.clear();
}
}
for (i = 0; i < Tree[src].CenEdges.size(); i++) {
int v = Tree[src].CenEdges[i];
if (!visited[v]) {
Solve(v);
}
}
}
int main() {
int n, i, u, v, c;
long long w;
scanf("%i", &n);
for (i = 0; i < n - 1; i++) {
scanf("%i %i %lld %i", &u, &v, &w, &c);
u--;
v--;
Tree[u].edges.push_back(v);
Tree[u].vals.push_back(w);
Tree[u].colors.push_back(c);
Tree[v].edges.push_back(u);
Tree[v].vals.push_back(w);
Tree[v].colors.push_back(c);
}
CentroidDecomposition(n);
Solve(CenRoot);
printf("%lld\n", sol);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
const int N = 5e3 + 10, M = 25e2 + 10, inf = 1e9;
int dp[N][M][2], a[N], best[M];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long i, j, k, m, n;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> a[i];
}
m = (n + 1) / 2;
for (int j = 1; j <= m; ++j) {
dp[0][j][0] = dp[0][j][1] = inf;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int ans = dp[i - 1][j][0];
ans = min(ans, dp[i - 1][j][1] + max(0, a[i] - a[i - 1] + 1));
dp[i][j][0] = ans;
int cost = max(0, a[i - 1] - a[i] + 1), temp = a[i - 1] - cost;
if (i >= 2) {
ans = min(ans, cost + dp[i - 2][j - 1][0]);
ans =
min(ans, cost + dp[i - 2][j - 1][1] + max(0, temp - a[i - 2] + 1));
} else if (j == 1) {
ans = min(ans, cost);
}
dp[i][j][1] = ans;
}
}
best[m + 1] = inf;
for (int i = m; i >= 1; --i) {
best[i] = min(dp[n][i][1], best[i + 1]);
}
for (int i = 1; i <= m; ++i) {
cout << best[i] << ' ';
}
}
| 3 |
#include <bits/stdc++.h>
const int N = 300000 + 5;
const int INF = 0x3f3f3f3f;
char str[500000 + 5];
int n, m;
std::string queries[N];
std::map<std::string, int> map;
int tot;
std::vector<int> edges[N];
std::pair<int, int> state[N];
bool vis[N];
int getId(std::string &s) {
for (int i = 0; i < s.length(); ++i) {
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] = s[i] - 'A' + 'a';
}
}
if (map.find(s) == map.end()) {
int a = 0, b = 0;
for (int i = 0; i < s.length(); ++i) {
if (s[i] == 'r') a++;
b++;
}
state[tot] = std::make_pair(a, b);
map[s] = tot++;
}
return map[s];
}
int getId(char *s) {
for (int i = 0; s[i]; ++i) {
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] = s[i] - 'A' + 'a';
}
}
if (map.find(s) == map.end()) {
int a = 0, b = 0;
for (int i = 0; s[i]; ++i) {
if (s[i] == 'r') a++;
b++;
}
state[tot] = std::make_pair(a, b);
map[s] = tot++;
}
return map[s];
}
int dfn[N], low[N], stack[N], instack[N], top, stot, tim, belong[N];
std::pair<int, int> nstate[N];
std::vector<int> nedges[N];
void tarjan(int u) {
dfn[u] = low[u] = ++tim;
stack[top++] = u;
instack[u] = 1;
for (__typeof((edges[u]).begin()) it = (edges[u]).begin();
it != (edges[u]).end(); ++it) {
int v = *it;
if (!dfn[v]) {
tarjan(v);
low[u] = std::min(low[u], low[v]);
} else if (instack[v]) {
low[u] = std::min(low[u], dfn[v]);
}
}
if (dfn[u] == low[u]) {
while (true) {
int v = stack[--top];
instack[v] = 0;
belong[v] = stot;
if (v == u) break;
}
stot++;
}
}
void scc() {
for (int i = 0; i < tot; ++i) {
if (!dfn[i]) tarjan(i);
}
for (int i = 0; i < stot; ++i) {
nstate[i] = std::make_pair(INF, INF);
}
for (int i = 0; i < tot; ++i) {
nstate[belong[i]] = std::min(nstate[belong[i]], state[i]);
}
for (int u = 0; u < tot; ++u) {
for (__typeof((edges[u]).begin()) it = (edges[u]).begin();
it != (edges[u]).end(); ++it) {
int v = *it;
if (belong[u] != belong[v]) {
nedges[belong[u]].push_back(belong[v]);
}
}
}
}
void dfs(int u) {
if (vis[u]) return;
vis[u] = true;
for (__typeof((nedges[u]).begin()) it = (nedges[u]).begin();
it != (nedges[u]).end(); ++it) {
int v = *it;
dfs(v);
nstate[u] = std::min(nstate[u], nstate[v]);
}
}
int main() {
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%s", str);
queries[i] = str;
}
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s", str);
int a = getId(str);
scanf("%s", str);
int b = getId(str);
edges[a].push_back(b);
}
scc();
for (int i = 0; i < stot; ++i) {
if (!vis[i]) dfs(i);
}
int fuck = tot;
long long aa = 0, ab = 0;
for (int i = 0; i < m; ++i) {
int id = getId(queries[i]);
if (id >= fuck) {
aa += state[id].first;
ab += state[id].second;
continue;
}
id = belong[id];
aa += nstate[id].first;
ab += nstate[id].second;
}
printf("%I64d %I64d\n", aa, ab);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
const unsigned long long mxmod = 1ull * mod * mod * 17;
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
int K, n, m, n1, n2;
long long ans[55];
vector<int> v;
unsigned long long adj[55][55];
namespace solver1 {
unsigned long long dp[1 << 17], ndp[1 << 17];
int cnt1[1 << 17];
void solve(long long ans[]) {
assert(n1 <= 17);
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int i = 0; i < n2; i++) {
memset(ndp, 0, sizeof(ndp));
for (int j = 0; j < n1; j++) {
if (adj[i + n1][j] == 0) continue;
for (int msk = 0; msk < (1 << n1); msk++) {
int nmsk = msk | (1 << j);
if (msk == nmsk || dp[msk] == 0) continue;
ndp[nmsk] += dp[msk] * adj[i + n1][j];
if (ndp[nmsk] >= mxmod) ndp[nmsk] %= mod;
}
}
for (int msk = 0; msk < (1 << n1); msk++)
dp[msk] = (dp[msk] + ndp[msk]) % mod;
}
for (int i = 0; i <= n1; i++) ans[i] = 0;
for (int i = 0; i < (1 << n1); i++) ans[__builtin_popcount(i)] += dp[i];
for (int i = 0; i <= n1; i++) ans[i] %= mod;
}
}; // namespace solver1
namespace solver2 {
bool vis[55];
int en, tp[55], tpn, fa[55];
pair<int, int> e[55];
vector<pair<int, unsigned long long> > son[55];
void dfs(int x, int pre = -1) {
vis[x] = 1;
for (int y = 0; y < n; y++) {
if (adj[x][y] != 0) {
if (!vis[y])
dfs(y, x), fa[y] = x;
else if (y != pre && x < y)
e[en++] = make_pair(x, y);
}
}
tp[x] = tpn++;
for (int y = 0; y < n; y++)
if (fa[y] == x) son[tp[x]].push_back(make_pair(tp[y], adj[x][y]));
}
bool ban[55];
unsigned long long dp0[55][26], dp1[55][26];
int sz[55];
void polymul(unsigned long long a[], int an, unsigned long long b[], int bn,
unsigned long long c[]) {
static unsigned long long tc[55];
an >>= 1;
bn >>= 1;
for (int i = 0; i <= an + bn; i++) tc[i] = 0;
for (int i = 0; i <= an; i++) {
if (!a[i]) continue;
for (int j = 0; j <= bn; j++) {
tc[i + j] += a[i] * b[j];
if (tc[i + j] >= mxmod) tc[i + j] %= mod;
}
}
for (int i = 0; i <= an + bn; i++) c[i] = tc[i] % mod;
}
void calcdp() {
memset(dp0, 0, sizeof(dp0));
memset(dp1, 0, sizeof(dp1));
unsigned long long tmp[26];
for (int x = 0; x < n; x++) {
dp0[x][0] = 1;
sz[x] = 1;
for (int i = 0; i < son[x].size(); i++) {
int y = son[x][i].first, w = son[x][i].second;
int nsz = sz[x] + sz[y];
polymul(dp1[x], sz[x], dp1[y], sz[y], dp1[x]);
if (!ban[x] && !ban[y]) {
polymul(dp0[x], sz[x], dp0[y], sz[y], tmp);
for (int j = 1; j <= (nsz >> 1); j++)
(dp1[x][j] += tmp[j - 1] * w) %= mod;
}
polymul(dp0[x], sz[x], dp1[y], sz[y], dp0[x]);
sz[x] = nsz;
}
for (int i = 0; i <= sz[x]; i++)
dp0[x][i] %= mod, (dp1[x][i] += dp0[x][i]) %= mod;
}
}
void solve(long long ans[]) {
for (int i = 0; i < n; i++) son[i].clear();
memset(vis, 0, sizeof(vis));
memset(fa, -1, sizeof(fa));
en = 0;
tpn = 0;
dfs(0);
assert(en <= 17);
assert(tpn == n);
for (int i = 0; i <= n; i++) ans[i] = 0;
for (int msk = 0; msk < (1 << en); msk++) {
memset(ban, 0, sizeof(ban));
long long coef = 1;
int cnt = 0;
bool ok = 1;
for (int i = 0; i < en && ok; i++) {
if ((msk >> i) & 1) {
int x = e[i].first, y = e[i].second;
cnt++;
coef = coef * adj[x][y] % mod;
ok &= (!ban[tp[x]]) && (!ban[tp[y]]);
ban[tp[x]] = ban[tp[y]] = 1;
}
}
if (ok) {
calcdp();
for (int i = 0; i <= n - cnt; i++)
(ans[i + cnt] += dp1[n - 1][i] * coef) %= mod;
}
}
}
}; // namespace solver2
vector<pair<int, int> > con[200111];
bool vis[200111];
void dfs(int x) {
vis[x] = 1;
v.push_back(x);
for (int i = 0; i < con[x].size(); i++) {
int u = con[x][i].first;
if (!vis[u]) dfs(u);
}
}
long long ansp[55];
long long fac[100111];
int main() {
fac[0] = 1;
for (int i = 1; i <= 100005; i++) fac[i] = fac[i - 1] * i % mod;
int pn;
cin >> K >> pn;
for (int i = 1; i <= pn; i++) {
int x, y, w;
cin >> x >> y >> w;
y += K;
w--;
w = (w % mod + mod) % mod;
con[x].push_back(make_pair(y, w));
con[y].push_back(make_pair(x, w));
}
ansp[0] = 1;
for (int i = 1; i <= 2 * K; i++) {
if (vis[i] || con[i].size() == 0) continue;
v.clear();
dfs(i);
sort(v.begin(), v.end());
n1 = n2 = m = 0;
for (int j = 0; j < v.size(); j++)
n1 += v[j] <= K, n2 += v[j] > K, m += con[v[j]].size();
m /= 2;
n = n1 + n2;
memset(adj, 0, sizeof(adj));
for (int j = 0; j < v.size(); j++) {
int x = v[j], ix = j;
for (int k = 0; k < con[x].size(); k++) {
int y = con[x][k].first;
int iy = lower_bound(v.begin(), v.end(), y) - v.begin();
adj[ix][iy] = con[x][k].second;
}
}
memset(ans, 0, sizeof(ans));
if (min(n1, n2) <= m - n + 1) {
if (n1 > n2) {
static unsigned long long nadj[55][55];
for (int x = 0; x < n; x++) {
int nx = x < n1 ? x + n2 : x - n1;
for (int y = 0; y < n; y++) {
int ny = y < n1 ? y + n2 : y - n1;
nadj[nx][ny] = adj[x][y];
}
}
swap(adj, nadj);
swap(n1, n2);
}
solver1::solve(ans);
} else {
solver2::solve(ans);
}
static long long nansp[55];
for (int j = 0; j <= 50; j++) {
nansp[j] = 0;
for (int k = 0; k <= j; k++) nansp[j] += ans[k] * ansp[j - k] % mod;
nansp[j] %= mod;
}
swap(ansp, nansp);
}
long long Ans = 0;
for (int i = 0; i <= min(K, 50); i++) Ans += ansp[i] * fac[K - i] % mod;
Ans = (Ans % mod + mod) % mod;
cout << Ans << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define endl '\n'
#define INF (1 << 21)
const int MOD = 1000000009;
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
int cnt;
int num[1005], p[1005], q[1005], r[1005];
int P, Q, R, C;
cin >> n;
while(n != 0){
cnt = 0;
for(int i = 0;i < n;i++){
cin >> num[i] >> p[i] >> q[i] >> r[i];
}
cin >> P >> Q >> R >> C;
for(int i = 0;i < n;i++){
if(p[i] <= P && q[i] <= Q && r[i] <= R && p[i] * 4 + q[i] * 9 + r[i] * 4 <= C){
cnt++;
cout << num[i] << endl;
}
}
if(cnt == 0){
cout << "NA" << endl;
}
cin >> n;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int mod = 1e9 + 7;
const long long INF = 1e18 + 1;
const long long inf = 1e12 + 1;
const int N = 5e5 + 9;
int n, k;
int a, b;
int p[N];
int t1[4 * N];
int t2[4 * N];
inline void update(int v, int l, int r, int pos, int val, int x, int y) {
if (l == r && l == pos) {
t1[v] += val;
t2[v] += val;
t1[v] = min(y, t1[v]);
t2[v] = min(x, t2[v]);
return;
}
int md = (l + r) / 2;
if (pos <= md)
update(v + v, l, md, pos, val, x, y);
else
update(v + v + 1, md + 1, r, pos, val, x, y);
t1[v] = t1[v + v] + t1[v + v + 1];
t2[v] = t2[v + v] + t2[v + v + 1];
}
long long sum1(int v, int l, int r, int L, int R) {
if (L > r || R < l) return 0;
if (L <= l && r <= R) return t1[v];
int md = (l + r) / 2;
return sum1(v + v, l, md, L, R) + sum1(v + v + 1, md + 1, r, L, R);
}
long long sum2(int v, int l, int r, int L, int R) {
if (L > r || R < l) return 0;
if (L <= l && r <= R) return t2[v];
int md = (l + r) / 2;
return sum2(v + v, l, md, L, R) + sum2(v + v + 1, md + 1, r, L, R);
}
int main() {
cin >> n >> k >> a >> b;
int q;
cin >> q;
for (int i = 1; i <= q; ++i) {
int type;
cin >> type;
if (type == 1) {
int d;
int x;
cin >> d >> x;
update(1, 1, n, d, x, a, b);
} else {
int ans = 0;
int d;
cin >> d;
if (d > 1) {
ans += sum1(1, 1, n, 1, d - 1);
}
if (d + k <= n) {
ans += sum2(1, 1, n, d + k, n);
}
cout << ans << endl;
}
}
exit(0);
}
| 2 |
#include <stdio.h>
#include <cmath>
#include <algorithm>
using namespace std;
int main(){
int n,tmp_id,max_id,max=-1,tmp;
scanf("%d",&n);
for(int i=0; i < n; i++){
scanf("%d %d",&tmp_id,&tmp);
if(tmp > max){
max = tmp;
max_id = tmp_id;
}else if(tmp == max){
if(max_id > tmp_id){
max_id = tmp_id;
}
}
}
printf("%d %d\n",max_id,max);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
cout << (n * n) / 4 << endl;
for (int i = 1; i <= (n + 1) / 2; i++)
for (int j = (n + 1) / 2 + 1; j <= n; j++) cout << i << " " << j << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int FMOD = 998244353;
const double eps = 1e-9;
void solve() {
int n, m;
cin >> n >> m;
int v, sm = 0;
for (auto i = (1); (1) > 0 ? i <= (n) : i >= (n); i += (1)) {
cin >> v;
sm += v;
}
if (m < n || n < 3)
cout << -1 << "\n";
else {
cout << sm * 2 << "\n";
for (auto i = (0); (1) > 0 ? i <= (n - 1) : i >= (n - 1); i += (1))
cout << i + 1 << " " << (i + 1) % n + 1 << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ntc = 1;
cin >> ntc;
for (auto tc = (1); (1) > 0 ? tc <= (ntc) : tc >= (ntc); tc += (1)) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 55;
int T, n;
char a[22];
int b[22];
int judge() {
for (int i = 0, j = n - 1; i <= j; i++, j--) {
if (b[i] != b[j]) return 0;
}
return 1;
}
int main() {
while (scanf("%s", a) == 1) {
n = strlen(a);
for (int i = 0; i < n; i++) b[i] = a[i] - 'a';
int flag = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j < 26; j++) {
b[i] = (b[i] + j) % 26;
flag |= judge();
b[i] = (b[i] - j + 26) % 26;
}
}
printf("%s\n", flag ? "YES" : "NO");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); }
bool isPrime(long long n) {
if (n == 1) return false;
if (n == 2) return true;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
;
cout << (v[0] < v[n - 1] ? "YES" : "NO") << endl;
;
}
int32_t main() {
ios_base ::sync_with_stdio(false), cin.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, E;
vector<vector<pair<int, long long>>> AdjList;
int main() {
cin >> N >> E;
AdjList.assign(N, vector<pair<int, long long>>());
for (int i = 0; i < E; i++) {
int u, v;
long long c;
cin >> u >> v >> c;
u--, v--;
AdjList[u].push_back({v, 2 * c});
AdjList[v].push_back({u, 2 * c});
}
vector<unsigned long long> dist(N, LONG_LONG_MAX);
for (int i = 0; i < N; i++) cin >> dist[i];
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
for (int i = 0; i < N; i++) pq.push({dist[i], i});
while (!pq.empty()) {
pair<long long, int> front = pq.top();
pq.pop();
long long d = front.first;
int u = front.second;
if (d > dist[u]) continue;
for (auto j : AdjList[u]) {
pair<int, long long> v = j;
if (dist[u] + v.second < dist[v.first]) {
dist[v.first] = dist[u] + v.second;
pq.push({dist[v.first], v.first});
}
}
}
for (int i = 0; i < N; i++) cout << dist[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long p;
long long a[300005];
int main() {
cin >> n >> p >> k;
unordered_map<long long, long long> prs;
prs.clear();
for (int i = 0; i < n; ++i) {
cin >> a[i];
long long num = a[i] * a[i] % p;
num = num * a[i] % p;
num = num * a[i] % p;
num = (num - k * a[i] % p + p) % p;
prs[num]++;
}
long long ans = 0LL;
for (auto pr : prs) {
long long num = pr.second;
ans += num * (num - 1) / 2;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if ((s[s.size() - 1] - '0') % 2 == 0)
cout << 0 << endl;
else
cout << 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x[n], d[n];
for (int i = 0; i < n; i++) cin >> x[i] >> d[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (x[i] + d[i] == x[j] && x[j] + d[j] == x[i]) return !printf("YES");
}
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int hell = 1000000007;
const long long int maxn = 1e6 + 5;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, k;
cin >> n >> k;
vector<pair<long long int, long long int> > v, ans;
for (long long int i = 0; i < n; i++) {
long long int l, r;
cin >> l >> r;
v.push_back({l, 0});
v.push_back({r, 1});
}
sort((v).begin(), (v).end());
long long int sum = 0, last;
for (long long int i = 0; i < (long long int)((v).size()); i++) {
if (v[i].second) {
--sum;
if (sum == k - 1) {
ans.push_back({last, v[i].first});
}
} else {
sum++;
if (sum == k) {
last = v[i].first;
}
}
}
cout << (long long int)((ans).size()) << '\n';
for (auto to : ans) {
cout << to.first << ' ' << to.second << '\n';
}
}
| 4 |
#include <cstdio>
#include <utility>
#include <vector>
using namespace std;
#define gcu getchar_unlocked
#define pcu putchar_unlocked
#define _il inline
#define _in _il int in
#define _sc _il bool scan
_in(int c){int n=0;bool m=false;if(c=='-')m=true,c=gcu();
do{n=10*n+(c-'0'),c=gcu();}while(c>='0');return m?-n:n;} //&&c<='9'
_in() {return in(gcu());}
_sc(int &n){int c=gcu();return c==EOF?false:(n=in(c),true);}
_sc(char &c){c=gcu();gcu();return c!=EOF;}
//_sc(string &s){int c;s="";
// for(;;){c=gcu();if(c=='\n'||c==' ')return true;else if(c==EOF)return false;s+=c;}}
template <typename H,typename... T> _sc(H &h, T&&... t){return scan(h)&&scan(t...);}
#define _vo _il void out
#define _vl _il void outl
template <typename T>
_vo(T n){static char buf[20];char *p=buf;
if(n<0)pcu('-'),n*=-1;if(!n)*p++='0';else while(n)*p++=n%10+'0',n/=10;
while (p!=buf)pcu(*--p);}
_vo(const char *s){while(*s)pcu(*s++);}
_vo(char c){pcu(c);}
//_vo(string &s){for (char c: s) pcu(c);}
template <typename H,typename... T> _vo(H&& h, T&&... t){out(h);out(move(t)...);}
template <typename T> _vo(vector<T> &v){for(T &x:v)out(&x == &v[0]?"":" "),out(x);out('\n');}
_vl(){out('\n');}
template <typename... T> _vl(T&&... t){out(move(t)...);outl();}
typedef vector<int> v;
v read() {
v a(in());
for (int &x : a)
x = in();
return move(a);
}
int main() {
v a = read(), b = read();
outl((int)(a < b));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[3];
int i, v1, v2, v3, j, x;
for (i = 0; i < 3; i++) {
scanf("%d", &x);
a[i] = x;
}
sort(a, a + 3);
v1 = a[0];
v2 = a[1];
v3 = a[2];
int b[10000];
j = 1;
for (j = 1; j < 10000; j += v1) {
b[j] = 1;
}
for (i = 1; i < 10000; i++) {
if (b[i] == 0) {
j = i;
break;
}
}
for (; j < 10000; j += v2) {
b[j] = 1;
}
for (i = 1; i < 10000; i++) {
if (b[i] == 0) {
j = i;
break;
}
}
if (i == 10000) {
cout << "YES";
return 0;
}
int last = j;
for (; j < 10000; j += v3) {
b[j] = 1;
}
int flag = 0;
for (i = last; i < 10000; i++) {
if (b[i] == 0) {
flag = 1;
break;
}
}
if (flag == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
double x, y, xx, yy;
while (cin >> x >> y) {
xx = log(y) * x;
yy = log(x) * y;
if (abs(xx - yy) < 1e-10)
cout << "=\n";
else if ((xx - yy) < 0)
cout << ">\n";
else
cout << "<\n";
}
return 0;
}
| 2 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
int d[252];
int dp[252][252];
int Max;
int n;
int main() {
while(scanf("%d",&Max),Max) {
scanf("%d",&n);
d[0]=d[n+1]=0;
for(int i=1;i<=n;i++) {
scanf("%d",&d[i]);
}
memset(dp,0,sizeof(dp));
for(int i=0;i<n+2;i++) {
for(int j=1;j<=Max;j++) {
int p;
p=min(i+j,n+1);
p+=d[p];
p=min(max(p,0),n+1);
dp[i][p]=1;
}
}
for(int k=0;k<n+2;k++) {
for(int i=0;i<n+2;i++) {
for(int j=0;j<n+2;j++) {
if(dp[i][k]&&dp[k][j]) dp[i][j]=1;
}
}
}
bool OK=1;
for(int i=0;i<=n;i++) {
if(dp[0][i]&&!dp[i][n+1]) {OK=0;break;}
}
if(OK) printf("OK\n"); else printf("NG\n");
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast,no-stack-protector")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\n";
err(++it, args...);
}
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
template <typename T>
vector<T> &operator<<(vector<T> &__container, T x) {
__container.push_back(x);
return __container;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &__container) {
for (T _ : __container) out << _ << ' ';
return out;
}
void sci() {}
template <typename... Args>
void sci(int &x, Args &...args) {
scanf("%d", &x);
sci(args...);
}
void scl() {}
template <typename... Args>
void scl(long long int &x, Args &...args) {
scanf("%lld", &x);
scl(args...);
}
const int MAXN = 2e5 + 7;
int n, A[MAXN], k, B[MAXN];
bool check() {
int dif = 0;
vector<int> vec(n);
for (int i = 1; i <= n; i++) vec[i - 1] = A[i];
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
return vec.size() <= k;
}
void solve() {
sci(n, k);
for (int i = 1; i <= n; i++) sci(A[i]);
if (k == 1) {
bool ok = true;
for (int i = 2; i <= n; i++)
if (A[i] != A[i - 1]) ok = false;
if (ok)
cout << 1 << "\n";
else
cout << -1 << "\n";
return;
}
int cnt = 1;
A[0] = -1;
while (!check()) {
int num = 0;
for (int i = 1; i <= n; i++) {
if (A[i] != A[i - 1] and num < k) {
num++;
B[i] = A[i];
} else
B[i] = B[i - 1];
}
for (int i = 1; i <= n; i++) A[i] -= B[i];
cnt++;
}
cout << cnt << "\n";
}
int main() {
int tt;
for (sci(tt); tt--; solve())
;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1e+9 + 7;
const ll INF = LLONG_MAX;
const int N = (int)2e+5 + 8;
string ter(int n) {
string second = "";
while (n) {
second = to_string(n % 3) + second;
n /= 3;
}
return second;
}
int dec(string second) {
int ans = 0;
for (int i = 0; i < second.size(); i++)
ans += (second[i] - '0') * pow(3, second.size() - i - 1);
return ans;
}
void MAIN(ll tc) {
int a, c;
cin >> a >> c;
string p = ter(a), q = ter(c), ans = "";
while (p.size() < q.size()) p = '0' + p;
while (q.size() < p.size()) q = '0' + q;
for (int i = 0; i < p.size(); i++)
if (q[i] >= p[i])
ans += to_string(q[i] - p[i]);
else
ans += to_string(q[i] - p[i] + 3);
cout << dec(ans);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed;
cout << setprecision(10);
int test_cases = 1;
for (int i = 1; i <= test_cases; i++) {
MAIN(i);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const unsigned long long keyA = 131, keyB = 13131;
int n, cnt[MAXN], las[MAXN], nex[MAXN];
char ch[MAXN];
unsigned long long HA[MAXN], HB[MAXN];
void init() {
int nc;
for (int i = 1; i <= n; i++)
if (ch[i] == '1' && ch[i - 1] == '1') {
HA[i] = HA[i - 2];
HB[i] = HB[i - 2];
cnt[i] = cnt[i - 2];
} else {
HA[i] = HA[i - 1] * keyA + ch[i];
HB[i] = HB[i - 1] * keyB + ch[i];
cnt[i] = cnt[i - 1] + 1;
}
for (int i = 1; i <= n; i++)
if (ch[i] == '1')
las[i] = las[i - 1];
else
las[i] = i;
nex[n + 1] = n + 1;
for (int i = n; i; i--)
if (ch[i] == '1')
nex[i] = nex[i + 1];
else
nex[i] = i;
}
unsigned long long KSM(unsigned long long a, int T) {
unsigned long long ans = 1;
while (T) {
if (T & 1) ans = ans * a;
a = a * a;
T >>= 1;
}
return ans;
}
unsigned long long Get_Hash(int s, int e, unsigned long long keyX,
unsigned long long* H) {
int ns = nex[s], ne = las[e];
if (ns > ne) ns = s, ne = e;
int len = cnt[ne] - cnt[ns] + 1;
unsigned long long base = KSM(keyX, len);
unsigned long long Hash = H[ne] - H[ns - 1] * base;
if ((ns - s) & 1) Hash += base * keyX;
if ((e - ne) & 1) Hash = Hash * keyX + 1;
return Hash;
}
bool check(int sa, int ea, int sb, int eb) {
unsigned long long HashA, HashB;
if (nex[sa] > ea) {
if (nex[sb] > eb)
return (eb - sb == ea - sa);
else
return 0;
}
if (nex[sb] > eb) return 0;
HashA = Get_Hash(sa, ea, keyA, HA) * Get_Hash(sa, ea, keyB, HB);
HashB = Get_Hash(sb, eb, keyA, HA) * Get_Hash(sb, eb, keyB, HB);
return HashA == HashB;
}
int main() {
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> (ch + 1);
init();
int Q, sa, sb, l;
cin >> Q;
while (Q--) {
cin >> sa >> sb >> l;
if (check(sa, sa + l - 1, sb, sb + l - 1))
cout << "Yes\n";
else
cout << "No\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2>
bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
int main() {
long long S, X;
cin >> S >> X;
bitset<60> s(S), x(X);
static long long dp[100][2];
dp[0][0] = 1;
for (int i = 0; i < (60); i++)
for (int j = 0; j < (2); j++) {
for (int a = 0; a < (2); a++) {
int b = (s[i] + a + j) % 2;
if ((a ^ b) == x[i]) {
dp[i + 1][(a + b + j) / 2] += dp[i][j];
}
}
}
if (s == x) dp[60][0] -= 2;
cout << dp[60][0] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
char s[200010];
long long dp[1 << 22];
int c[30], d[30][30];
int main() {
int n, k, T;
scanf("%d%d%d", &n, &k, &T);
int full = 0;
scanf("%s", s);
for (int i = 0; i < n; i++) {
full |= 1 << s[i] - 'A';
}
for (int i = 0; i < k; i++) {
scanf("%d", &c[i]);
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
scanf("%d", &d[i][j]);
}
}
for (int i = 0; i < n; i++) {
int j = i + 1, ban = 0;
while (j < n && s[i] != s[j]) {
if (!(ban >> s[j] - 'A' & 1)) {
int x = s[i] - 'A', y = s[j] - 'A';
dp[ban] += d[x][y];
dp[ban | 1 << x] -= d[x][y];
dp[ban | 1 << y] -= d[x][y];
dp[ban | 1 << x | 1 << y] += d[x][y];
}
ban |= 1 << s[j] - 'A', j++;
}
if (j != n) {
int x = s[i] - 'A';
dp[ban] += d[x][x];
dp[ban | 1 << x] -= d[x][x];
}
}
for (int i = 0; i < k; i++) {
for (int mask = 0; mask < (1 << k); mask++) {
if (mask >> i & 1) dp[mask] += dp[mask ^ 1 << i];
}
}
int ans = 0;
for (int mask = 0; mask < (1 << k); mask++) {
long long sum = 0;
for (int i = 0; i < k; i++) {
if (mask >> i & 1) sum += c[i];
}
if ((full | mask) == full && mask != full && dp[mask] + sum <= T) ans++;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
using vvl = vector<vl>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vb = vector<bool>;
using vs = vector<string>;
const ll oo = 0x3f3f3f3f3f3f3f3fLL;
const ld eps = 1e-9;
vl x, y, z;
map<ll, map<ll, map<ll, ll>>> points;
bool inside(ll a, ll b, ll c) {
return x[c] >= min(x[a], x[b]) && x[c] <= max(x[a], x[b]) &&
y[c] >= min(y[a], y[b]) && y[c] <= max(y[a], y[b]) &&
z[c] >= min(z[a], z[b]) && z[c] <= max(z[a], z[b]);
}
void eraser(ll i) {
points[x[i]][y[i]].erase(z[i]);
if (!ll((points[x[i]][y[i]]).size())) {
points[x[i]].erase(y[i]);
if (!ll((points[x[i]]).size())) {
points.erase(x[i]);
}
}
}
int main() {
cin.sync_with_stdio(0);
ll n;
cin >> n;
x = vl(n);
y = vl(n);
z = vl(n);
for (ll i = (0); i < (n); i++) {
cin >> x[i] >> y[i] >> z[i];
}
for (ll i = (0); i < (n); i++) {
points[x[i]][y[i]][z[i]] = i;
}
vl used(n);
for (ll i = (0); i < (n); i++) {
if (used[i]) {
continue;
}
used[i] = true;
eraser(i);
auto itx = points.lower_bound(x[i]);
if (itx == points.end()) {
itx--;
}
auto ity = itx->second.lower_bound(y[i]);
if (ity == itx->second.end()) {
ity--;
}
auto itz = ity->second.lower_bound(z[i]);
if (itz == ity->second.end()) {
itz--;
}
ll j = itz->second;
used[j] = true;
eraser(j);
cout << i + 1 << ' ' << j + 1 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, p, a;
cin >> p >> n;
for (int i = 0; i < n; i++) {
cin >> a;
if (mp[a % p]) {
cout << i + 1 << "\n";
return 0;
}
mp[a % p] = 1;
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end());
vector<int> b(n - 1);
for (int i = 0; i < n - 1; ++i) cin >> b[i];
sort(b.begin(), b.end());
bool f = false;
for (int i = 0; i < n - 1; ++i) {
if (b[i] != a[i]) {
cout << a[i] << endl;
a.erase(a.begin() + i);
f = true;
break;
}
}
if (!f) {
cout << a[n - 1] << endl;
a.erase(a.begin() + n - 1);
}
vector<int> c(n - 2);
for (int i = 0; i < n - 2; ++i) cin >> c[i];
sort(c.begin(), c.end());
f = false;
for (int i = 0; i < n - 2; ++i) {
if (c[i] != a[i]) {
cout << a[i] << endl;
f = true;
break;
}
}
if (!f) {
cout << a[n - 2] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long h[100100], w[100100];
bool C(long long x) {
int p = 0;
for (int i = 0; i < n; i++) {
if (w[p] < h[i]) {
if (abs(w[p] - h[i]) > x) return false;
long long k = max(h[i] + (x - (abs(h[i] - w[p]) * 2)),
h[i] + (x - abs(h[i] - w[p])) / 2ll);
while (w[p] <= k) {
p++;
if (p == m) return true;
}
} else {
while (w[p] <= h[i] + x) {
p++;
if (p == m) return true;
}
}
}
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) cin >> h[i];
for (int i = 0; i < m; i++) cin >> w[i];
long long l = -1, r = 1000000000000000ll;
while (r - l > 1) {
long long mid = (l + r) / 2ll;
if (C(mid))
r = mid;
else
l = mid;
}
cout << r << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
map<int, int> v1;
int n, m, k, q, mwh, z[N], c1[N], c2[N], c3[N], c4[N], ft[N], whm[N], res[N];
map<pair<int, int>, int> d;
struct edg {
int a, b, c, d;
} e[N];
struct note {
int l, r;
} hwm[N];
pair<int, int> f[N], g[N], w[N], c[N], p[N], st[N], col[N];
vector<int> v[N];
inline int lowbit(int u) { return (u & (-u)); }
inline bool cmp(pair<int, int> u, pair<int, int> v) {
if (u == v) return 0;
int la = 0, a = u.first, b = u.second;
while (a > 0 || b > 0) {
if ((lowbit(a) < lowbit(b) && lowbit(a) != 0) || lowbit(b) == 0)
la++, c1[la] = lowbit(a), c2[la] = 1, a -= lowbit(a);
else
la++, c1[la] = lowbit(b), c2[la] = 2, b -= lowbit(b);
}
int lb = 0, x = v.first, y = v.second;
while (x > 0 || y > 0) {
if ((lowbit(x) < lowbit(y) && lowbit(x) != 0) || lowbit(y) == 0)
lb++, c3[lb] = lowbit(x), c4[lb] = 1, x -= lowbit(x);
else
lb++, c3[lb] = lowbit(y), c4[lb] = 2, y -= lowbit(y);
}
int A = 0, B = 1;
while (la > 0 && lb > 0) {
if (A <= 0) {
if (A == 0)
A = c1[la], B = c2[la], la--;
else if (B != c2[la])
return B - 1;
else
A += c1[la], la--;
} else {
if (B != c4[lb])
return ((B - 1) ^ 1);
else
A -= c3[lb], lb--;
}
}
while (A <= 0 && la > 0) {
if (A == 0)
A = c1[la], B = c2[la], la--;
else if (B != c2[la])
return B - 1;
else
A += c1[la], la--;
}
while (A >= 0 && lb > 0) {
if (A == 0)
A -= c3[lb], lb--;
else if (B != c4[lb])
return ((B - 1) ^ 1);
else
A -= c3[lb], lb--;
}
return (A < 0);
}
inline int read() {
int num = 0;
char g = getchar();
while (g < 48 || 57 < g) g = getchar();
while (47 < g && g < 58)
num = (num << 1) + (num << 3) + g - 48, g = getchar();
return num;
}
inline pair<int, int> jmp(int a, int b, int t) {
if (a + b < t) return make_pair(0, 0);
while (1) {
if ((lowbit(a) < lowbit(b) && lowbit(a) != 0) || lowbit(b) == 0) {
if (lowbit(a) < t)
t -= lowbit(a), a -= lowbit(a);
else
return make_pair(a - t, b);
} else {
if (lowbit(b) < t)
t -= lowbit(b), b -= lowbit(b);
else
return make_pair(a, b - t);
}
}
return make_pair(114514, 1919810);
}
inline pair<int, int> getlca(pair<int, int> u, pair<int, int> v) {
if (u.first + u.second < v.first + v.second) swap(u, v);
int z = u.first + u.second - v.first - v.second;
for (int i = 30; i >= 0; i--)
if ((1 << i) & z) u = jmp(u.first, u.second, (1 << i));
if (u == v) return u;
for (int i = 30; i >= 0; i--) {
pair<int, int> A = jmp(u.first, u.second, (1 << i));
pair<int, int> B = jmp(v.first, v.second, (1 << i));
if (A != B) u = A, v = B;
}
return jmp(u.first, u.second, 1);
}
inline int getnum(pair<int, int> u) {
if (!d.count(u)) d[u] = ++mwh, p[mwh] = u;
return d[u];
}
inline int dep(pair<int, int> v) { return v.first + v.second; }
inline void addedge(int a, int b) {
if (a == b) return;
v[b].push_back(a), ft[a] = b;
}
inline void addx(int l, int r) { n++, hwm[n].l = l, hwm[n].r = r + 1; }
inline void bfs(int u) {
for (int i = 0; i < v[u].size(); i++) bfs(v[u][i]), res[u] += res[v[u][i]];
if (res[u]) {
if (u == 1)
addx(0, 0);
else
addx(dep(p[ft[u]]) + 1, dep(p[u]));
}
}
int main() {
m = read(), f[++k] = make_pair(0, 0);
for (int i = 1; i <= m; i++) {
int a = read(), b = read(), x = read(), y = read();
g[i] = make_pair(a, b), w[i] = make_pair(x, y);
f[++k] = g[i], f[++k] = w[i], f[++k] = getlca(g[i], w[i]);
f[++k] = jmp(f[k].first, f[k].second, 1);
}
sort(f + 1, f + k + 1, cmp), c[++q] = f[1];
int len = 0;
for (int i = 2; i <= k; i++)
if (f[i] != f[i - 1]) c[++q] = f[i];
for (int i = 1; i <= q; i++) getnum(c[i]);
if (q >= 2) {
st[1] = c[1], st[2] = c[2], len = 2;
for (int i = 3; i <= q; i++) {
pair<int, int> s = getlca(c[i], st[len]);
while (len >= 2) {
if (dep(s) == dep(st[len]))
break;
else if (dep(s) > dep(st[len])) {
st[++len] = s;
break;
} else {
if (dep(s) > dep(st[len - 1]))
addedge(getnum(st[len]), getnum(s)), len--;
else
addedge(getnum(st[len]), getnum(st[len - 1])), len--;
}
}
st[++len] = s;
st[++len] = c[i];
}
for (int i = 2; i <= len; i++) addedge(getnum(st[i]), getnum(st[i - 1]));
}
for (int i = 1; i <= m; i++) {
res[getnum(g[i])]++;
res[getnum(w[i])]++;
pair<int, int> A = getlca(g[i], w[i]);
res[getnum(A)]--;
if (dep(A)) res[getnum(jmp(A.first, A.second, 1))]--;
}
bfs(1), z[0] = 0;
int g = 0;
z[++z[0]] = 0;
for (int i = 1; i <= n; i++) z[++z[0]] = hwm[i].l, z[++z[0]] = hwm[i].r;
sort(z + 1, z + z[0] + 1);
v1[z[1]] = ++g;
for (int i = 1; i < z[0]; i++)
if (z[i] != z[i + 1]) v1[z[i + 1]] = ++g;
for (int i = 1; i <= n; i++) whm[v1[hwm[i].l]] ^= 1, whm[v1[hwm[i].r]] ^= 1;
for (int i = 1; i <= g; i++) whm[i] ^= whm[i - 1];
int ans = 0;
for (int i = 1; i <= g; i++)
if (whm[i] && !whm[i - 1]) ans++;
if (ans == 0)
cout << 0 << endl;
else
cout << (ans - 1) * 2 + 1 + (whm[1] == 0) << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<set<int> > S;
set<int> Emp;
int main() {
int vote[101000], totpos, totneg, n, m, i, tru[101000], lie[101000],
neg[101000], pos[101000], crime[101000], temp;
while (scanf("%d", &n) != EOF) {
S.clear();
scanf("%d", &m);
totpos = 0;
totneg = 0;
for (i = 0; i <= n; i++) {
S.push_back(Emp);
pos[i] = 0;
neg[i] = 0;
crime[i] = 0;
lie[i] = 0;
tru[i] = 0;
}
for (i = 1; i <= n; i++) {
scanf("%d", &vote[i]);
temp = vote[i];
if (temp > 0) {
S[temp].insert(i);
totpos++;
pos[temp]++;
} else {
S[-temp].insert(-i);
totneg++;
neg[-temp]++;
}
}
int criminal = 0;
for (i = 1; i <= n; i++) {
if (pos[i] + totneg - neg[i] == m) {
crime[i] = 1;
criminal++;
} else {
}
}
for (i = 1; i <= n; i++) {
if (vote[i] > 0) {
if (crime[vote[i]] == 1) {
tru[i] = 1;
} else
lie[i] = 1;
if (criminal > 1) lie[i] = 1;
} else {
if (crime[-vote[i]] == 1) {
lie[i] = 1;
} else
tru[i] = 1;
if (criminal > 1) tru[i] = 1;
}
}
for (i = 1; i <= n; i++) {
if (tru[i] + lie[i] == 2) {
printf("Not defined\n");
} else {
if (tru[i] == 1) {
printf("Truth\n");
} else {
printf("Lie\n");
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b, ans;
string s;
int main() {
cin >> s;
int add = 0, res = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '+') res++;
if (s[i] == '-') {
if (res > 0)
res--;
else
add++;
}
}
if (add > 0) ans = add;
int tmp = ans;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '+')
tmp++;
else
tmp--;
if (tmp > ans) ans = tmp;
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 gene(233);
inline char GET_CHAR() {
const int maxn = 131072;
static char buf[maxn], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, maxn, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int getInt() {
int res(0);
char c = getchar();
while (c < '0') c = getchar();
while (c >= '0') {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
inline int fastpo(int x, int n, int mod) {
int res(1);
while (n) {
if (n & 1) {
res = res * (long long)x % mod;
}
x = x * (long long)x % mod;
n /= 2;
}
return res;
}
inline string itoa(int x, int width = 0) {
string res;
if (x == 0) res.push_back('0');
while (x) {
res.push_back('0' + x % 10);
x /= 10;
}
while ((int)res.size() < width) res.push_back('0');
reverse(res.begin(), res.end());
return res;
}
const int N = 500033;
const int LOG = 20;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
int n, m;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
vector<int> e[N];
vector<int> vv[N], nxt[N];
int vst[N], fa[N], ans[N], a1[N], fl[999][999], siz[N], dep[N], d2[N], up[N];
int debug = 0;
int main() {
if (debug) {
n = 500000;
} else {
scanf("%d", &n);
}
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
std::mt19937 generator(seed);
for (int i(1); i < n; i++) {
int x, y;
if (debug) {
x = 1;
y = i + 1;
} else {
scanf("%d%d", &x, &y);
}
e[x].push_back(y);
e[y].push_back(x);
}
vector<int> q;
q.push_back(1);
vst[1] = 1;
for (int op = 0; op < n; op++) {
int v = q[op];
for (int y : e[v]) {
if (!vst[y]) {
fa[y] = v;
vst[y] = 1;
q.push_back(y);
}
}
}
for (int i(n - 1); i >= 0; i--) {
int v = q[i];
int nw = dep[v] + 1;
siz[v]++;
siz[fa[v]] += siz[v];
if (nw > dep[fa[v]]) {
d2[fa[v]] = dep[fa[v]];
dep[fa[v]] = nw;
} else if (nw > d2[fa[v]])
d2[fa[v]] = nw;
}
ans[n] = 1;
for (int v : q) {
up[v] = v == 1 ? 0 : up[fa[v]] + 1;
if (v != 1)
up[v] =
max(up[v], dep[v] + 1 == dep[fa[v]] ? d2[fa[v]] + 1 : dep[fa[v]] + 1);
vector<int> vec;
vec.push_back(up[v]);
for (int y : e[v]) {
if (fa[y] == v) vec.push_back(dep[y] + 1);
}
if (up[v] != 0) {
vec.push_back(0);
}
sort(vec.begin(), vec.end());
for (int i(0); i < (int)vec.size(); i++) {
ans[vec[i] * 2] = max(ans[vec[i] * 2], (int)vec.size() - i);
if (i && vec[i - 1] < vec[i]) {
ans[vec[i - 1] * 2 + 1] =
max(ans[vec[i - 1] * 2 + 1], (int)vec.size() - i + 1);
}
}
vv[v] = vec;
}
for (int i(n - 1); i >= 1; i--) ans[i] = max(ans[i], ans[i + 1]);
for (int i(1); i <= n; i++) {
nxt[i] = vv[i];
for (int j(0), k; j < (int)vv[i].size(); j = k) {
for (k = j; k < (int)vv[i].size() && vv[i][j] == vv[i][k]; k++)
;
for (int l = j; l < k; l++) nxt[i][l] = k;
}
}
for (int v : q) {
if (!fa[v]) continue;
for (int i(0), p(0); i < (int)vv[v].size(); i = nxt[v][i]) {
int cnt = vv[v].size() - i;
int lb = vv[v][i];
if (lb > siz[v] || lb > n - siz[v]) break;
if (lb == 0) continue;
if (up[v] - 1 >= lb) cnt--;
if (cnt <= 0) continue;
while (p < (int)vv[fa[v]].size() && vv[fa[v]][p] < lb) p++;
cnt += (int)vv[fa[v]].size() - p;
cnt--;
ans[lb * 2] = max(ans[lb * 2], cnt);
}
for (int i(0), p(0); i < (int)vv[fa[v]].size(); i = nxt[fa[v]][i]) {
int cnt = vv[fa[v]].size() - i;
int lb = vv[fa[v]][i];
if (lb > siz[v] || lb > n - siz[v]) break;
if (lb == 0) continue;
if (dep[v] >= lb) cnt--;
while (p < (int)vv[v].size() && vv[v][p] < lb) p++;
cnt += (int)vv[v].size() - p;
cnt--;
ans[lb * 2] = max(ans[lb * 2], cnt);
}
}
for (int i = (n - 1) / 2 * 2; i >= 0; i -= 2)
ans[i] = max(ans[i], ans[i + 2]);
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], i == n ? '\n' : ' ');
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, t;
long long res, l[1000050][3], r[1000050][3], p[1005000];
char s[1005000];
long long jc[1005000], inv[1005000];
long long ksm(long long a, int p) {
long long res = 1;
while (p) {
if (p & 1) {
res = res * a % 998244353;
}
a = a * a % 998244353;
p >>= 1;
}
return res;
}
long long c(int n, int m) {
if (n < 0 || m < 0 || n < m) {
return 0;
}
return jc[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
int main() {
jc[0] = inv[0] = 1;
for (i = 1; i <= 1000000; i++) {
jc[i] = jc[i - 1] * i % 998244353;
}
inv[1000000] = ksm(jc[1000000], 998244353 - 2);
for (i = 999999; i >= 1; i--) {
inv[i] = inv[i + 1] * (i + 1) % 998244353;
}
gets(s + 1);
n = strlen(s + 1);
for (i = n; i >= 1; i--) {
r[i][1] = r[i + 1][1];
r[i][2] = r[i + 1][2];
if (s[i] == ')') {
r[i][1]++;
}
if (s[i] == '?') {
r[i][2]++;
}
}
for (i = 1; i <= n; i++) {
l[i][1] = l[i - 1][1];
l[i][2] = l[i - 1][2];
if (s[i] == '(') {
l[i][1]++;
}
if (s[i] == '?') {
l[i][2]++;
}
for (j = max(l[i][1], r[i + 1][1]);
j <= min(l[i][1] + l[i][2], r[i + 1][1] + r[i + 1][2]); j++) {
res += c(l[i][2], j - l[i][1]) * c(r[i + 1][2], j - r[i + 1][1]) %
998244353 * j % 998244353;
}
}
printf("%lld", res % 998244353);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, q, y, x, z, mx, c2 = 0;
pair<int, int> a[200001], tt, us[200001];
int tp[200001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = 0;
}
cin >> q;
tp[0] = -1;
for (int i = 1; i <= q; i++) {
cin >> y;
y--;
tp[i] = y;
if (y) {
cin >> x;
if (tp[i] != tp[i - 1]) {
c2++;
us[c2] = make_pair(x, i);
} else
us[c2].first = max(us[c2].first, x);
continue;
}
cin >> z >> x;
a[z] = make_pair(x, i);
}
us[c2 + 1].first = INT_MIN;
for (int i = c2; i >= 1; i--) us[i].first = max(us[i].first, us[i + 1].first);
for (int i = 1; i <= n; i++) {
int l = 1, r = c2, mid;
while (l < r) {
mid = (l + r) / 2;
if (us[mid].second >= a[i].second)
r = mid;
else
l = mid + 1;
}
if (us[l].second < a[i].second) {
cout << a[i].first << " ";
continue;
}
if (us[l].first < a[i].first) {
cout << a[i].first << " ";
continue;
}
cout << us[l].first << " ";
}
cout << endl;
cout.flush();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
for (long long int i = 0; i < n; ++i) {
cout << 1 << " ";
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[3][3];
int main() {
for (int i = 0; i < 3; i++) scanf("%s", &s[i]);
int t = 1;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (s[i][j] != s[2 - i][2 - j]) {
t = 0;
printf("NO\n");
return 0;
}
}
}
if (t == 1) printf("YES\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
int p1, p2, f[500210], i, j, sum[2][500210], a, b, k, t, mo = 1e9 + 7, ans;
int main() {
scanf("%d%d%d%d", &a, &b, &k, &t);
f[a - b + 200100] = 1;
t <<= 1;
for (i = a - b + 200100; i <= k * t + a - b + 200100; i++) sum[0][i] = 1;
p2 = 1;
for (i = 1; i <= t; i++) {
std::swap(p1, p2);
memset(f, 0, sizeof(f));
memset(sum[p1], 0, sizeof(sum[p1]));
for (j = 0; j <= k * t + a - b + 200100; j++) {
f[j] = sum[p2][std::min(j + k, k * t + a - b + 200100)] -
sum[p2][std::max(j - k - 1, 0)];
if (f[j] >= mo)
f[j] -= mo;
else if (f[j] < 0)
f[j] += mo;
sum[p1][j] = sum[p1][std::max(j - 1, 0)] + f[j];
if (sum[p1][j] >= mo)
sum[p1][j] -= mo;
else if (sum[p1][j] < 0)
sum[p1][j] += mo;
}
}
for (i = 200101; i <= k * t + a - b + 200100; i++) {
ans += f[i];
if (ans >= mo) ans -= mo;
}
printf("%d", ans);
return 0;
}
| 4 |
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
using namespace std;
typedef long long ll;
inline ll pow_mod(ll a,ll k,ll m){ll r=1;for(;k>0;a=a*a%m,k>>=1)if(k&1)r=r*a%m;return r;}
ll mod_inv(ll a,ll p){
if (a == 0) throw "NG";
return pow_mod(a,p-2,p);
}
int MOD;
inline int in(){int x;scanf("%d",&x);return x;}
//{{{ lex_parser.hpp
#ifndef INCLUDE_LEX_PARSER_HPP
#define INCLUDE_LEX_PARSER_HPP
#include <iostream>
#include <string>
#include <cctype>
namespace orliv {
template<typename T, bool Check=false>
struct LexParser {
typedef T expr_t;
typedef std::string::const_iterator state_t;
LexParser(){}
expr_t eval(const std::string& expr){
auto s = expr.begin();
auto r = expression(s);
consume(s, '=');
return r;
}
inline void consume(state_t& s, char expected){
if (!Check || *s == expected){
s++;
return;
}
std::cerr << "Expected '" << expected << "' but got '" << *s << "'" << std::endl;
std::cerr << "Rest string is '";
while (*s) std::cerr << *s++;
std::cerr << "'" << std::endl;
}
expr_t number(state_t& s){
expr_t r = 0;
while (std::isdigit(*s)){
r = r * 10 + (*s - '0');
s++;
}
return r % MOD;
}
expr_t term(state_t& s){
expr_t r = factor(s);
while (1){
if (*s == '*'){
consume(s, '*');
r *= factor(s);
r %= MOD;
}
else if (*s == '/'){
consume(s, '/');
r *= mod_inv(factor(s), MOD);
r %= MOD;
}
else break;
}
return r % MOD;
}
expr_t factor(state_t& s){
expr_t r;
if (*s == '('){
consume(s, '(');
r = expression(s);
consume(s, ')');
}
else r = number(s);
return r % MOD;
}
expr_t expression(state_t& s){
expr_t r = term(s);
while (1){
if (*s == '+'){
consume(s, '+');
r += term(s);
r %= MOD;
}
else if (*s == '-'){
consume(s, '-');
r += MOD - term(s);
}
else break;
}
return r % MOD;
}
};
}
#endif
//}}}
int main()
{
string S;
while (getline(cin, S), S != "0:"){
stringstream ss(S);
string ps, expr;
getline(ss, ps, ':');
getline(ss, expr, ':');
MOD = atoi(ps.c_str());
expr.erase(remove_if(expr.begin(), expr.end(), [](const char& a){ return a == ' '; }), expr.end());
orliv::LexParser<ll> lex;
try {
ll res = lex.eval(expr);
cout << expr << " = " << res << " (mod " << MOD << ")\n";
}
catch (const char* e){
cout << e << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long cx, cy, n, x[2000];
string dir[2000];
set<long> dx, dy;
set<long>::iterator it;
map<long, long> mx, my, rmx, rmy;
long val;
long calcx, calcy;
long nx, ny;
bool forb[(1 << 12) + 100][(1 << 12) + 100];
bool used[(1 << 12) + 100][(1 << 12) + 100];
long long ans;
bool cmove(long a, long b) {
if (a <= 0 || b <= 0 || a > calcx || b > calcy) return false;
if (used[a][b]) return false;
if (forb[a][b]) return false;
return true;
}
void dfs(long a, long b) {
used[a][b] = 1;
if (cmove(a - 1, b)) dfs(a - 1, b);
if (cmove(a + 1, b)) dfs(a + 1, b);
if (cmove(a, b - 1)) dfs(a, b - 1);
if (cmove(a, b + 1)) dfs(a, b + 1);
}
void ap(long x, long y) {
dx.insert(x);
dy.insert(y);
dx.insert(x + 1);
dy.insert(y + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cx = cy = 1000000000;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> dir[i] >> x[i];
ap(cx, cy);
if (dir[i] == "U") cx -= x[i];
if (dir[i] == "D") cx += x[i];
if (dir[i] == "L") cy -= x[i];
if (dir[i] == "R") cy += x[i];
}
ap(cx, cy);
ap(1, 1);
for (it = dx.begin(); it != dx.end(); it++) {
val = (*it);
++calcx;
mx[val] = calcx;
rmx[calcx] = val;
}
for (it = dy.begin(); it != dy.end(); it++) {
val = (*it);
++calcy;
my[val] = calcy;
rmy[calcy] = val;
}
cx = cy = 1000000000;
for (int i = 1; i <= n; i++) {
nx = cx;
ny = cy;
if (dir[i] == "U") {
nx -= x[i];
for (int j = mx[nx]; j <= mx[cx]; j++) forb[j][my[cy]] = 1;
}
if (dir[i] == "D") {
nx += x[i];
for (int j = mx[cx]; j <= mx[nx]; j++) forb[j][my[cy]] = 1;
}
if (dir[i] == "L") {
ny -= x[i];
for (int j = my[ny]; j <= my[cy]; j++) forb[mx[cx]][j] = 1;
}
if (dir[i] == "R") {
ny += x[i];
for (int j = my[cy]; j <= my[ny]; j++) forb[mx[cx]][j] = 1;
}
cx = nx;
cy = ny;
}
dfs(1, 1);
for (int i = 1; i <= calcx; i++)
for (int j = 1; j <= calcy; j++) {
if (used[i][j]) continue;
ans += (rmx[i + 1] - rmx[i]) * 1ll * (rmy[j + 1] - rmy[j]);
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
bool isLetter(char c) { return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
char toLower(char c) { return (isUpper(c)) ? (c + 32) : c; }
char toUpper(char c) { return (isLower(c)) ? (c - 32) : c; }
long long str2int(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long char2int(char c) { return (long long)c; }
long long isPowerOfTwo(long long x) { return !(x & (x - 1)); }
long long pow2(long long x) { return (1LL << x); }
template <typename... T>
void read(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void write(T&&... args) {
((cout << args << " "), ...);
}
void display(const vector<long long>& v) {
for_each(v.begin(), v.end(), [](long long x) { cout << x << " "; });
cout << '\n';
}
long long triangle(long long n) {
if (n < 2) {
return n;
}
long long count(0), ht(2), base(0);
long long tmp(n);
while (tmp > 0) {
tmp -= ht;
tmp -= base;
ht += 2;
++base;
}
ht -= 2;
--base;
if (tmp == 0) return 0;
if (tmp < 0) {
tmp += ht + base;
return tmp;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
read(t);
while (t--) {
long long n, m;
read(n, m);
bool result(false);
if ((n == 1 || m == 1) || (n == 2 && m == 2)) {
result = true;
}
if (result) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int LOG = 17;
const int N = 100005;
const int ALPHA = 26;
string s;
int f[2][LOG][N], mask[LOG][N], n, LG[N], L[N], R[N], g[2][LOG][N],
prv[2][ALPHA][N], nxt[2][ALPHA][N], nw[2][ALPHA][N], buffer[ALPHA];
int lft[N];
long long suma[2][LOG][N];
int I, letters[26];
void build() {
for (int i = 0; i < ALPHA; i++) letters[i] = i;
int k = -1;
for (int i = 1; i < N; i++) {
if (i == (1 << (k + 1))) k++;
LG[i] = k;
}
for (int i = 0; i < n; i++) mask[0][i] = 1 << s[i];
for (int i = 1; i < LOG; i++)
for (int j = 0; j < n - (1 << i) + 1; j++)
mask[i][j] = mask[i - 1][j] | mask[i - 1][j + (1 << (i - 1))];
}
int distinct(int l, int r) {
int lenLog = LG[r - l + 1];
return __builtin_popcount(mask[lenLog][l] |
mask[lenLog][r - (1 << lenLog) + 1]) -
1;
}
bool cmp(int i1, int i2) { return abs(I - buffer[i1]) < abs(I - buffer[i2]); }
void getLast() {
for (int i = 0; i < 2; i++) {
for (int k = 0; k < ALPHA; k++) prv[i][k][0] = -1;
for (int j = 0; j < n; j++) {
prv[i][s[j]][j] = j;
for (int k = 0; k < ALPHA; k++) {
prv[i][k][j + 1] = prv[i][k][j];
nxt[i ^ 1][k][j + 1] = s[j] == k ? j : nxt[i ^ 1][k][j];
}
}
reverse(s.begin(), s.end());
}
for (int j = 0; j < ALPHA; j++) {
for (int i = 0; i < n; i++) {
prv[1][j][i] = n - 1 - prv[1][j][i];
}
reverse(prv[1][j], prv[1][j] + n);
reverse(nxt[0][j], nxt[0][j] + n);
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < n; j++) {
I = j;
for (int k = 0; k < ALPHA; k++) buffer[k] = prv[i][k][j];
sort(letters, letters + ALPHA, cmp);
for (int k = 0; k < ALPHA; k++)
nw[i ^ 1][k][j] = k == 0
? nxt[i][letters[k]][j]
: min(nxt[i][letters[k]][j], nw[i ^ 1][k - 1][j]);
}
for (int j = 0; j < ALPHA; j++)
for (int i = 0; i < n; i++) {
nw[1][j][i] = n - 1 - nw[1][j][i];
nxt[0][j][i] = n - 1 - nxt[0][j][i];
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
for (auto &first : s) first -= 'a';
n = (int)(s.size());
build();
getLast();
long long ans = n * (long long)n * n;
for (int i = 0; i < n; i++) L[i] = i, R[i] = i, lft[i] = n;
for (int t = 0; t < ALPHA; t++) {
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) {
g[j][0][i] = nw[j][t][i];
suma[j][0][i] = i + j;
}
for (int i = 1; i < LOG; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < 2; k++) {
g[k][i][j] = g[k][i - 1][g[k][i - 1][j]];
suma[k][i][j] = suma[k][i - 1][j] + suma[k][i - 1][g[k][i - 1][j]];
}
for (int i = 0; i < n; i++) {
for (int bit = 16; bit >= 0; bit--) {
int newL = g[0][bit][L[i]], newR = g[1][bit][R[i]];
if (distinct(newL, newR) == t && lft[i] >= (1 << bit)) {
lft[i] -= (1 << bit);
ans -= suma[1][bit][R[i]] - suma[0][bit][L[i]];
L[i] = newL, R[i] = newR;
}
}
if (distinct(L[i], R[i]) == t && lft[i]) {
lft[i]--;
ans -= suma[1][0][R[i]] - suma[0][0][L[i]];
L[i] = g[0][0][L[i]], R[i] = g[1][0][R[i]];
}
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 40005;
int n, m, tp, cc, px[N], py[N];
struct P {
int x, y;
} a[N], b[N], c[N];
inline P operator+(const P& a, const P& b) { return (P){a.x + b.x, a.y + b.y}; }
inline P operator-(const P& a, const P& b) { return (P){a.x - b.x, a.y - b.y}; }
inline int operator*(const P& a, const P& b) { return a.x * b.y - a.y * b.x; }
inline int operator^(const P& a, const P& b) { return a.x * b.x + a.y * b.y; }
inline bool operator<(const P& a, const P& b) {
return a.x == b.x ? a.y < b.y : a.x < b.x;
}
inline void GG() {
puts("YES");
exit(0);
}
inline void hull(int n, P* a, P* b) {
sort(a + 1, a + n + 1);
tp = 0;
for (int i = 1; i <= n; b[++tp] = a[i++])
while (tp >= 2 && (a[i] - b[tp - 1]) * (b[tp] - b[tp - 1]) <= 0) tp--;
int ps = tp--;
for (int i = n; i; b[++tp] = a[i--])
while (tp > ps && (a[i] - b[tp - 1]) * (b[tp] - b[tp - 1]) <= 0) tp--;
tp--;
}
void dv(int l, int r) {
px[++cc] = l;
py[cc] = r;
if (l + 1 >= r) return;
int p = -1;
double v = -1e18;
for (int i = l + 1; i <= r - 1; i++) {
int v1 = (c[i] - c[l]) ^ (c[i] - c[r]), v2 = (c[l] - c[i]) * (c[l] - c[r]);
double w = -1.0 * v1 / v2;
if (w > v) v = w, p = i;
}
dv(l, p);
dv(p, r);
}
inline void chk(int l, int r, int n, int m, P* b) {
double vl = -1e18, vr = 1e18;
for (int i = 1; i <= n && vl < vr; i++) {
if (i == l || i == r) continue;
int v1 = (c[i] - c[l]) ^ (c[i] - c[r]), v2 = (c[l] - c[i]) * (c[l] - c[r]);
if (!v2) continue;
double w = 1.0 * v1 / v2;
if (v2 < 0)
vr = min(vr, w);
else
vl = max(vl, w);
}
for (int i = 1; i <= m && vl < vr; i++) {
int v1 = (b[i] - c[l]) ^ (b[i] - c[r]), v2 = (c[l] - b[i]) * (c[l] - c[r]);
if (!v2) {
if (v1 > 0) continue;
vl = 1e19;
break;
}
double w = 1.0 * v1 / v2;
if (v2 > 0)
vr = min(vr, w);
else
vl = max(vl, w);
}
if (vl < vr) GG();
}
inline void sol(int n, P* a, int m, P* b) {
cc = 0;
hull(n, a, c);
dv(1, tp);
for (int i = 1; i <= cc; i++) chk(px[i], py[i], tp, m, b);
}
int main() {
scanf("%d%d", &n, &m);
if (n == 1 || m == 1) GG();
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
for (int i = 1; i <= m; i++) scanf("%d%d", &b[i].x, &b[i].y);
sol(n, a, m, b);
sol(m, b, n, a);
puts("NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long fast_exp(long long a, long long b) {
if (b <= 0)
return 1;
else {
long long res = 1;
res = fast_exp(a, b / 2);
res = (res * res) % mod;
if (b % 2 == 1) res = (res * a) % mod;
return res;
}
}
const long long N = 2e5 + 1000;
const long double pi = acos(-1.0);
long double dp[2][N + 5] = {};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
const int lim = 447 + 21 * 4;
dp[0][1] = 1;
long double ans = 0;
int cur = 0;
int next = (cur + 1) % 2;
int iter = 0;
long double inverse_k = 1 / (long double)k;
while (iter < n) {
for (int i = 1; i < lim; i++) dp[next][i] = 0;
long double avg = 0.5;
for (int i = 1; i < lim; i++) {
long double prob_inc = ((long double)1 / (i + 1));
long double prob_ninc = 1 - (long double)1 / (long double)(i + 1);
if (i == lim - 1) {
prob_inc = 0;
prob_ninc = 1;
}
long double prob = prob_inc * inverse_k;
dp[next][i] += dp[cur][i] * (1 - prob);
dp[next][i + 1] += dp[cur][i] * prob;
avg += 0.5;
ans += inverse_k * (avg * prob_ninc + (1 - prob_ninc) * i) * dp[cur][i];
}
swap(cur, next);
iter++;
}
cout << fixed << setprecision(12) << ans * k << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main () {
int n, t;
cin >> n;
vector < bool > a(n + 1, 0);
for (int i = 1; i <= n; ++i) {
cin >> t;
a[i] = bool(t);
}
set < int > put;
for (int i = n; i; --i) {
bool seen = 0;
for (int j = i; j <= n; j += i) {
if (put.find(j) != put.end())
seen ^= 1;
}
if (seen != a[i])
put.insert(i);
}
cout << int(put.size()) << '\n';
for (int x: put)
cout << x << ' ';
cout << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename L>
bool smax(T& x, L y) {
return x < y ? (x = y, true) : false;
}
template <typename T, typename L>
bool smin(T& x, L y) {
return y < x ? (x = y, true) : false;
}
void prep(long long* mem);
void reset();
int root(int v);
const int MAXN = 1e6 + 15;
int par[MAXN];
int sz[MAXN];
int val[MAXN];
int id[MAXN];
bool mark[MAXN];
long long d[2][MAXN];
int n;
long long ans;
vector<int> adj[MAXN];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) cin >> val[i];
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
reset();
prep(d[0]);
for (int i = 0; i < n; val[i++] *= -1)
;
reset();
prep(d[1]);
for (int i = 0; i < n; val[i++] *= -1)
;
for (int i = 0; i < n; i++)
ans += ((long long)(d[0][i] - d[1][i]) * (long long)(val[i]));
return cout << ans << '\n', false;
}
void prep(long long* mem) {
for (int j = 0; j < n; j++) {
int i = id[j];
mark[i] = true;
for (auto u : adj[i]) {
if (!mark[u]) continue;
int k = root(u);
mem[i] += ((long long)sz[i] * (long long)sz[k]);
par[k] = i;
sz[i] += sz[k];
sz[k] = 0;
}
}
}
int root(int v) { return (par[v] == v ? v : par[v] = root(par[v])); }
void reset() {
iota(id, id + n, 0);
sort(id, id + n, [](int x, int y) { return val[x] < val[y]; });
memset(mark, false, sizeof mark);
for (int i = 0; i < n; sz[i] = 1, par[i] = i, i++)
;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
template <typename T>
void write(T t) {
if (t < 0) {
putchar('-');
write(-t);
return;
}
if (t > 9) write(t / 10);
putchar('0' + t % 10);
}
template <typename T>
void writeln(T t) {
write(t);
puts("");
}
const int mod = 998244353;
const int mod2 = (1e9) + 7;
long long n, cnt;
int ans, sum[10];
vector<int> vec[10];
void update(int &x, int y) {
x += y;
if (x >= mod2) x -= mod2;
}
void dfs1(int dep, int val) {
if (val > n) return;
cnt++;
vec[dep].push_back((cnt - val + mod) % mod);
if (dep == 6) return;
for (int i = 0; i < 10; i++) dfs1(dep + 1, val * 10 + i);
}
void dfs2(int dep, long long val) {
if (val > n) return;
if (dep >= 1) {
if ((long long)val * 1000000 > n / 10 &&
(long long)val * 1000000 + 999999 <= n) {
long long tmp = val;
for (int i = 0; i <= 6; i++) {
int cur = (cnt % mod - tmp % mod + mod) % mod;
update(ans, (long long)cur * (int)vec[i].size() % mod2);
int pos =
vec[i].end() - lower_bound(vec[i].begin(), vec[i].end(), mod - cur);
update(ans, (sum[i] - (long long)pos * mod % mod2 + mod2) % mod2);
tmp *= 10;
}
for (int i = 0; i <= 6; i++) cnt += (int)vec[i].size();
return;
}
cnt++;
update(ans, (cnt % mod - val % mod + mod) % mod);
}
for (int i = (dep == 0 ? 1 : 0); i < 10; i++)
dfs2(dep + 1, (long long)val * 10 + i);
}
int main() {
read(n);
dfs1(0, 0);
for (int i = 0; i <= 6; i++) {
sort(vec[i].begin(), vec[i].end());
for (int &x : vec[i]) update(sum[i], x);
}
cnt = 0;
dfs2(0, 0);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
fu = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 2e5 + 5;
struct ele {
long long x, cnt;
ele(long long a = 0, long long b = 0) : x(a), cnt(b) {}
bool operator<(const ele A) const { return x < A.x; }
};
deque<ele> q1, q2;
pair<long long, long long> r[3];
int a[N];
int T, n;
long long sum, L, R, lcnt, mid, rcnt, ans;
ele fir() {
if (q1.empty()) {
ele ans = q2.front();
q2.pop_front();
return ans;
}
if (q2.empty()) {
ele ans = q1.front();
q1.pop_front();
return ans;
}
if (q1.front().x <= q2.front().x) {
ele ans = q1.front();
q1.pop_front();
return ans;
}
ele ans = q2.front();
q2.pop_front();
return ans;
}
int main() {
T = 1;
while (T--) {
read(n);
L = 2;
R = 3;
ans = sum = 0;
while (!q1.empty()) q1.pop_back();
while (!q2.empty()) q2.pop_back();
for (int i = 1; i <= n; i++) {
read(a[i]);
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) sum += 1, q1.push_back(ele(a[i], 1));
rcnt = -1;
if ((sum - 1) % (R - 1) == 0) {
lcnt = mid = 0;
rcnt = (sum - 1) / (R - 1);
} else {
if (L == R) {
print(-1, '\n');
continue;
}
for (long long i = (sum - 1) / (R - 1); i >= 0; i--) {
long long las = (sum - 1) - i * (R - 1), cnt = las / (L - 1) - 1;
if (cnt < 0) continue;
if (las - cnt * (L - 1) <= (R - 1)) {
rcnt = i;
mid = las - cnt * (L - 1) + 1;
lcnt = cnt;
break;
}
}
}
r[0] = make_pair(lcnt, L);
if (mid) r[1] = make_pair(1, mid);
r[2] = make_pair(rcnt, R);
if (rcnt == -1) {
print(-1, '\n');
continue;
}
int pos = 0;
while (1) {
while (pos <= 2 && !r[pos].first) ++pos;
if (pos == 3) break;
ele tmp = fir();
if (tmp.cnt >= r[pos].second) {
long long cnt = min(r[pos].first, tmp.cnt / r[pos].second);
r[pos].first -= cnt;
tmp.cnt -= cnt * r[pos].second;
ans += cnt * r[pos].second * tmp.x;
if (tmp.cnt) q1.push_front(tmp);
q2.push_back(ele(r[pos].second * tmp.x, cnt));
} else {
--r[pos].first;
long long las = r[pos].second - tmp.cnt, s = tmp.cnt * tmp.x;
while (1) {
tmp = fir();
if (tmp.cnt >= las) {
tmp.cnt -= las;
s += las * tmp.x;
if (tmp.cnt) q1.push_front(tmp);
break;
} else
las -= tmp.cnt, s += tmp.cnt * tmp.x;
}
ans += s;
q2.push_back(ele(s, 1));
}
}
print(ans, '\n');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 14;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int t;
cin >> t;
while (t--) {
long long p;
int q;
cin >> p >> q;
if (p % q) {
cout << p << '\n';
continue;
}
long long ans = 1;
auto handle = [&](int i) {
long long cp = p, mul = 1;
while (q % i == 0 && q / i % i == 0) {
q /= i;
mul *= i;
}
q /= i;
while (cp % i == 0) cp /= i;
ans = max(ans, cp * mul);
};
for (int i = 2; i * i <= q; i++)
if (q % i == 0) handle(i);
if (q > 1) handle(q);
cout << ans << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
scanf("%d",&n);
vector <int> a(n) ,frq(n);
for(int&i : a)
scanf("%d",&i) ,frq[i-1]++;
sort(frq.begin() ,frq.end());
vector <int> cfrq = frq;
for(int i=1; i<n; i++)
cfrq[i] += cfrq[i-1];
vector <int> ans(n);
for(int i=1; i<=n; i++){
int j = upper_bound(frq.begin() ,frq.end() ,i)-frq.begin()-1;
ans[cfrq[j]/i + n-j-2] = i;
}
for(int i=n-2; ~i; i--)
ans[i] = max(ans[i] ,ans[i+1]);
for(int i : ans)
printf("%d\n",i);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gen(long long n) {
long long x = n;
while (n) {
x = x * 10 + n % 10;
n /= 10;
}
return x;
}
int main() {
long long k, p, temp = 0, sum = 0;
cin >> k >> p;
for (int i = 1; i <= k; i++) {
sum += gen(i) % p;
}
cout << sum % p << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
inline long long inL() {
long long x;
scanf("%I64d", &x);
return x;
}
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 1e5 + 9;
vector<int> G[N];
int main() {
int n = in();
int u, v;
for (int i = 0; i < n - 1; i++) {
u = in();
v = in();
G[u].push_back(v);
G[v].push_back(u);
}
long long res = 0;
for (int i = 1; i <= n; i++) {
long long x = G[i].size();
if (x > 1) {
res += x * (x - 1) / 2;
}
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2010;
vector<int> pos[257];
int say[257], cnt[257][MAXN], used[MAXN][250];
int main() {
int k, n, q;
char p;
string str;
cin >> k >> str >> n;
for (int i = 0; i < ((int)(str.size())); i++) say[(int)str[i]]++;
for (int j = 0; j < n; j++) {
scanf("%d %c", &q, &p);
q--;
for (int i = 0; i < k; i++) {
if (say[(int)p] - cnt[(int)p][i] <= q)
q -= say[(int)p] - cnt[(int)p][i];
else {
for (int l = 0; l < ((int)(str.size())); l++) {
if (str[l] == p && !used[i][l] && !q) {
used[i][l] = 1, cnt[(int)p][i]++;
break;
} else if (str[l] == p && !used[i][l])
q--;
}
break;
}
}
}
for (int j = 0; j < k; j++)
for (int i = 0; i < ((int)(str.size())); i++)
if (!used[j][i]) cout << str[i];
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
long long a[maxn];
int id[maxn];
set<pair<long long, int> > st;
bool cmp(int x, int y) { return a[x] < a[y]; }
int main() {
int n, k, x;
scanf("%d %d %d", &n, &k, &x);
int neg = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
if (a[i] < 0) neg ^= 1;
st.insert(pair<long long, int>(abs(a[i]), i));
}
if (neg == 0) {
pair<int, int> top = *st.begin();
st.erase(st.begin());
int pos = top.second;
if (a[pos] >= 0) {
while (k > 0 && a[pos] >= 0) {
k--;
a[pos] -= x;
}
} else {
while (k > 0 && a[pos] <= 0) {
k--;
a[pos] += x;
}
}
neg ^= 1;
st.insert(pair<long long, int>(abs(a[pos]), pos));
}
while (k > 0) {
pair<long long, int> top = *st.begin();
st.erase(st.begin());
int pos = top.second;
k--;
if (a[pos] >= 0) {
a[pos] += x;
} else {
a[pos] -= x;
}
st.insert(pair<long long, int>(abs(a[pos]), pos));
}
for (int i = 0; i < n; i++) {
printf("%lld ", a[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int64_t fnc(int64_t m) {
if (m == 1) return 0;
if (m == 2) return 1;
int64_t a = 1, b = 2;
int64_t i = 2;
for (; a + b <= m; i++) {
swap(a, b);
b += a;
}
return i - 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int64_t m;
cin >> m;
cout << fnc(m) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 28;
const long long LINF = 1ll << 61;
int n, s, mx;
int main() {
ios::sync_with_stdio(false);
cin >> n >> s;
mx = -1;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
if (x < s || (x == s && y == 0)) {
mx = max(mx, (100 - y) % 100);
}
}
cout << mx;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T& x) {
stringstream ss;
ss << x;
return ss.str();
}
const double EPS = 1e-6;
const int INF = 1000 * 1000 * 1000;
const char CINF = 102;
const long long LINF = INF * 1ll * INF;
const long double PI = 3.1415926535897932384626433832795;
int main() {
int n, m;
cin >> n >> m;
vector<pair<long long, long long> > evs;
for (int i = 0; i < (m); ++i) {
int asdy1, y2, t;
scanf("%d%d%d", &asdy1, &y2, &t);
++t;
evs.push_back(make_pair(asdy1, t));
evs.push_back(make_pair(y2, -t));
}
sort((evs).begin(), (evs).end());
vector<pair<long long, pair<long long, long long> > > evs2;
multiset<long long> ts;
for (int q = 0; q < (((int)(evs).size())); ++q) {
long long y = evs[q].first;
if (q && y > evs[q - 1].first && ((int)(ts).size())) {
long long tt = *ts.begin();
long long asdy1 = evs[q - 1].first;
long long y2 = y;
evs2.push_back(make_pair(tt - y2, make_pair(1, -(tt - y2))));
evs2.push_back(make_pair(tt - asdy1, make_pair(-1, tt - asdy1)));
}
long long t = evs[q].second;
if (t < 0)
ts.erase(ts.find(-t));
else
ts.insert(t);
}
for (int i = 0; i < (n); ++i) {
int t;
scanf("%d", &t);
++t;
evs2.push_back(make_pair(t, make_pair(0, i)));
}
sort((evs2).begin(), (evs2).end());
long long add = 0, mul = 0;
for (int q = 0; q < (((int)(evs2).size())); ++q) {
long long t = evs2[q].first;
long long a = evs2[q].second.first;
long long b = evs2[q].second.second;
if (!a) {
printf("%d\n", (int)(add + t * mul));
} else {
mul += a;
add += b;
}
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define fo(i,l,r) for(int i=l;i<=r;i++)
#define of(i,l,r) for(int i=l;i>=r;i--)
#define fe(i,u) for(int i=head[u];i;i=e[i].next)
#define el putchar('\n')
#define ta putchar(' ')
using namespace std;
typedef long long ll;
typedef vector<int> vi;
inline void open(const char *s)
{
#ifndef ONLINE_JUDGE
char str[20];
sprintf(str,"%s.in",s);
freopen(str,"r",stdin);
// sprintf(str,"%s.out",s);
// freopen(str,"w",stdout);
#endif
}
inline int rd()
{
static int x,f;
x=0;f=1;
char ch=getchar();
for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
for(;ch>='0'&&ch<='9';ch=getchar())x=x*10+ch-'0';
return f>0?x:-x;
}
const int N=100010;
int n,K;
vi a[7],p,q,A,ans;
inline vi inv(vi a)
{static vi res(n+1);
fo(i,1,n)res[a[i]]=i;
return res;
}
inline vi mul(vi a,vi b)
{static vi res(n+1);
fo(i,1,n)res[i]=a[b[i]];
return res;
}
inline vi pwr(vi x,int k)
{static vi res(n+1);
fo(i,1,n)res[i]=i;
for(;k;k>>=1,x=mul(x,x))if(k&1)res=mul(res,x);
return res;
}
int main()
{
n=rd();K=rd();
p.resize(n+1);q.resize(n+1);
fo(i,1,n)p[i]=rd();
fo(i,1,n)q[i]=rd();
a[1]=p;a[2]=q;a[0].resize(n+1);fo(i,1,n)a[0][i]=i;
A=mul(mul(mul(q,inv(p)),inv(q)),p);
fo(i,3,6)a[i]=mul(a[i-1],inv(a[i-2]));
if(K<=6){
fo(i,1,n)printf("%d ",a[K][i]);
return 0;
}
ans.resize(n+1);A=pwr(A,(K-1)/6);
ans=mul(mul(A,a[(K-1)%6+1]),inv(A));
fo(i,1,n)printf("%d ",ans[i]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > vec;
long long pref[200005];
int main() {
long long n, h;
cin >> n >> h;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
vec.push_back({x, y});
}
pref[0] = 0;
for (long long i = 1; i < n; i++)
pref[i] = pref[i - 1] + vec[i].first - vec[i - 1].second;
pref[n] = 1e18;
long long res = 0;
for (long long i = 0; i < n; i++) {
long long esq = vec[i].first;
long long altura = h + pref[i];
long long pos = upper_bound(pref, pref + n + 1, altura) - pref - 1;
long long dist;
if (altura - pref[pos] == 0)
dist = vec[pos].first - esq;
else
dist = vec[pos].second + altura - pref[pos] - esq;
res = max(res, dist);
}
cout << res << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define N 3
using namespace std;
typedef unsigned long long ull;
bool im[1010][1010],pa[110][110];
int w,h,p,ans;
vector<ull> used;
void ppp(){
ull a=0;
ull roll[1001][1001]={};
for(int i=0;i<p;i++)
for(int j=0;j<p;j++)a=a*N+pa[i][j];
for(int i=0;i<used.size();i++)
if(used[i]==a)return;
used.push_back(a);
for(int j=0;j<h;j++){
ull b=0,g=1;
for(int i=0;i<p;i++)b=b*N+im[j][i],g*=N;
roll[j][p-1]=b;
for(int i=p;i<w;i++){
b=b*N+im[j][i]-im[j][i-p]*g;
roll[j][i]=b;
}
}
for(int j=p-1;j<w;j++){
ull b=0,g=1,n=1;
for(int i=0;i<p;i++)n*=N;
for(int i=0;i<p;i++)b=b*n+roll[i][j],g*=n;
if(b==a)ans++;
for(int i=p;i<h;i++){
b=b*n+roll[i][j]-roll[i-p][j]*g;
if(b==a)ans++;
}
}
}
void ch(){
bool npa[110][110];
for(int i=0;i<p;i++)
for(int j=0;j<p;j++)npa[i][j]=pa[j][p-i-1];
for(int i=0;i<p;i++)
for(int j=0;j<p;j++)pa[i][j]=npa[i][j];
}
void ch1(){
for(int i=0;i<p;i++)
for(int j=0;j<p/2;j++)swap(pa[i][j],pa[i][p-j-1]);
}
int main(){
int D[256];
for(int i='A';i<='Z';i++)D[i]=i-'A';
for(int i='a';i<='z';i++)D[i]=i-'a'+26;
for(int i='0';i<='9';i++)D[i]=i-'0'+52;
D['+']=62,D['/']=63;
while(cin>>w>>h>>p,w){
string s;
used.clear();
for(int i=0;i<h;i++){
cin>>s;
for(int j=0;j<s.size();j++){
int t=D[s[j]];
int a=6;
while(a--)im[i][j*6+a]=t%2,t/=2;
}
}
for(int i=0;i<p;i++){
cin>>s;
for(int j=0;j<s.size();j++){
int t=D[s[j]];
int a=6;
while(a--)pa[i][j*6+a]=t%2,t/=2;
}
}
ans=0;
for(int i=0;i<4;i++){
ppp();
ch1();
ppp();
ch1();
ch();
}
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
using vint = vector<int>;
template<typename T> using uset = unordered_set<T>;
template<typename T1, typename T2> using umap = unordered_map<T1, T2>;
constexpr int INF = (1 << 30) - 1;
constexpr ll LLINF = 1LL << 60;
constexpr int dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
constexpr int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr char el = '\n';
constexpr int mod = 1000000007;
template<typename T> T gcd(T a, T b) { return (b ? gcd(b, a % b) : a); }
template<typename T> T lcm(T a, T b) { return (a / gcd(a, b) * b); }
template<typename T1, typename T2> inline void chmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b) { if (a < b) a = b; }
int main() {
int N;
int A[100005];
int cnt = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A[i];
if (i > 0 && A[i] - A[i - 1] > 0) cnt++;
}
cout << cnt << endl;
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 50;
const int MX = 1e5;
const int MOD = 998244353;
int n, m;
int L[N + 5], R[N + 5];
int up[N + 5], low[N + 5];
int f[MX + 5];
inline void add(int& a, int b) { a = (a + b) % MOD; }
inline int sub(int a, int b) {
a = (a - b) % MOD;
if (a < 0) a += MOD;
return a;
}
int calc(int k) {
vector<vector<int>> dp(n, vector<int>(m / k + 5));
vector<int> pre(m / k + 5);
int bat = m / k;
for (int i = 0; i < n; i++) {
low[i] = ((L[i] + k - 1) / k);
bat -= (low[i]);
up[i] = ((R[i]) / k);
}
if (bat < 0) return 0;
for (int i = 0; i <= up[0] - low[0]; i++) {
dp[0][i] = 1;
}
pre[0] = 1;
for (int i = 1; i <= bat; i++) {
pre[i] = (pre[i - 1] + dp[0][i]) % MOD;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j <= bat; j++) {
int lul;
if (j > (up[i] - low[i]))
lul = pre[j - (up[i] - low[i]) - 1];
else
lul = 0;
dp[i][j] = (dp[i][j] + sub(pre[j], lul)) % MOD;
}
pre[0] = dp[i][0];
for (int j = 1; j <= bat; j++) {
pre[j] = (pre[j - 1] + dp[i][j]) % MOD;
}
}
int ret = 0;
for (int i = 0; i <= bat; i++) {
ret = (ret + dp[n - 1][i]) % MOD;
}
return ret;
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> L[i] >> R[i];
}
for (int i = 1; i <= m / n; i++) {
f[i] = calc(i);
}
for (int i = m; i >= 1; i--) {
for (int j = i + i; j <= m; j += i) {
f[i] = (f[i] - f[j] + MOD) % MOD;
}
}
int ans = f[1] % MOD;
if (ans < 0) ans += MOD;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TC = 1;
for (int i = 1; i <= TC; i++) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long x, long long p, long long M) {
long long ret = 1;
while (p) {
if (p & 1) ret = ret * x % M;
x = x * x % M;
p /= 2;
}
return ret;
}
const int N = 30010;
int n, q, invw[N], invh[N], p[N];
long long ans[N], dp[3][N];
pair<long long, long long> w[N], h[N];
void f(int i) {
dp[0][i] = dp[1][i] = dp[2][i] = -1e13;
if (p[i] != i) dp[0][i] = w[i].first * h[i].first;
if (i < n - 1 && p[i] != i + 1 && p[i + 1] != i)
dp[1][i] = w[i].first * h[i + 1].first + w[i + 1].first * h[i].first;
if (i < n - 2 && p[i] != i + 1 && p[i + 1] != i + 2 && p[i + 2] != i)
dp[2][i] = w[i].first * h[i + 1].first + w[i + 1].first * h[i + 2].first +
w[i + 2].first * h[i].first;
if (i < n - 2 && p[i] != i + 2 && p[i + 1] != i + 1 && p[i + 2] != i)
dp[2][i] = max(dp[2][i], w[i].first * h[i + 2].first +
w[i + 1].first * h[i + 1].first +
w[i + 2].first * h[i].first);
if (i < n - 2 && p[i] != i + 2 && p[i + 1] != i && p[i + 2] != i + 1)
dp[2][i] = max(dp[2][i], w[i].first * h[i + 2].first +
w[i + 1].first * h[i].first +
w[i + 2].first * h[i + 1].first);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> w[i].first, w[i].second = i;
for (int i = 0; i < n; i++) cin >> h[i].first, h[i].second = i;
sort(w, w + n);
sort(h, h + n);
for (int i = 0; i < n; i++) invw[w[i].second] = i, invh[h[i].second] = i;
for (int i = 0; i < n; i++) p[invw[i]] = invh[i];
for (int i = 0; i < n; i++) f(i);
int qa, qb;
while (q--) {
cin >> qa >> qb;
qa--;
qb--;
qa = invw[qa];
qb = invw[qb];
swap(p[qa], p[qb]);
for (int i = qa; i >= 0 && i >= qa - 3; i--) f(i);
for (int i = qb; i >= 0 && i >= qb - 3; i--) f(i);
ans[0] = dp[0][0];
ans[1] = max(dp[1][0], ans[0] + dp[0][1]);
if (n >= 3)
ans[2] = max(dp[2][0], max(ans[1] + dp[0][2], ans[0] + dp[1][1]));
for (int i = 3; i < n; i++) {
ans[i] = ans[i - 1] + dp[0][i];
ans[i] = max(ans[i], ans[i - 2] + dp[1][i - 1]);
ans[i] = max(ans[i], ans[i - 3] + dp[2][i - 2]);
}
cout << ans[n - 1] << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-7;
const int N = 2e5 + 1;
int t[2][31 * N];
int cnt[2][31 * N];
multiset<long long, greater<long long>> sums[2][10 * N];
string s;
int cur = 0;
string tb(long long v) {
string r = "";
while (v) {
if (v & 1)
r += "1";
else
r += "0";
v >>= 1LL;
}
int sz = 31 - r.size();
r += string(sz, '0');
reverse(r.begin(), r.end());
return r;
}
void ins() {
int on = 0;
for (int i = 0; s[i] != '\0'; ++i) {
int now = s[i] - '0';
if (t[now][on] == -1) {
t[now][on] = ++cur;
}
cnt[now][on]++;
on = t[now][on];
}
}
void rem() {
int on = 0;
int acc = 0;
for (int i = 0; s[i] != '\0'; ++i) {
int now = s[i] - '0';
cnt[now][on]--;
on = t[now][on];
}
}
string get(int idx) {
string r = "";
while (s[idx] != '\0') {
r += s[idx];
++idx;
}
return r;
}
long long process(string r) {
long long p = 1;
long long ret = 0;
int i = 0;
reverse(r.begin(), r.end());
while (r[i] != '\0') {
ret += (r[i] - '0') * p;
p <<= 1LL;
++i;
}
return ret;
}
long long qry() {
int on = 0;
string r = "";
for (int i = 0; s[i] != '\0'; ++i) {
int cur = s[i] - '0';
int lk = 1 - cur;
if (t[lk][on] != -1 && cnt[lk][on]) {
r += "1";
on = t[lk][on];
} else if (t[cur][on] != -1 && cnt[cur][on]) {
r += "0";
on = t[cur][on];
} else {
r = r + get(i);
return process(r);
}
}
return process(r);
}
int main() {
int q;
scanf("%d", &q);
memset(t, -1, sizeof t);
while (q--) {
char c;
long long val;
scanf(" %c %lld", &c, &val);
s = tb(val);
if (c == '+') {
ins();
} else if (c == '-') {
rem();
} else {
printf("%lld\n", max(qry(), val));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
int par[200005][20], deg[200005], type[200005], f[200005][20], g[200005][20];
int n;
pair<pair<int, int>, pair<int, int> > lca(int v, int u) {
int x = 1, y = 1, z = 1, t = 0;
for (int i = 19; i >= 0; i--) {
if (deg[par[v][i]] >= deg[u]) {
x &= f[v][i];
y &= g[v][i];
v = par[v][i];
}
}
for (int i = 19; i >= 0; i--) {
if (deg[par[u][i]] >= deg[v]) {
z &= f[u][i];
u = par[u][i];
}
}
for (int i = 19; i >= 0; i--) {
if (par[v][i] != par[u][i]) {
x &= f[v][i];
y &= g[v][i];
z &= f[u][i];
v = par[v][i];
u = par[u][i];
}
}
if (u != v) {
x &= f[v][0];
y &= g[v][0];
z &= f[u][0];
u = par[u][0];
}
t = u;
return make_pair(make_pair(x, y), make_pair(z, t));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
deg[0] = -1;
memset(par, 0, sizeof(par));
for (int i = (1); i <= (n); ++i) {
cin >> par[i][0] >> type[i];
if (par[i][0] == -1) par[i][0] = 0;
if (par[i][0] == 0)
deg[i] = 0;
else
deg[i] = deg[par[i][0]] + 1;
if (type[i] == 0)
f[i][0] = 1;
else if (type[i] == 1)
g[i][0] = 1;
}
for (int t = (0); t <= (18); ++t) {
for (int i = (1); i <= (n); ++i) {
par[i][t + 1] = par[par[i][t]][t];
f[i][t + 1] = f[i][t] & f[par[i][t]][t];
g[i][t + 1] = g[i][t] & g[par[i][t]][t];
}
}
int q, u, v, tp;
cin >> q;
for (int run = 0; run < (q); ++run) {
cin >> tp >> u >> v;
pair<pair<int, int>, pair<int, int> > P = lca(v, u);
int x = P.first.first, y = P.first.second, z = P.second.first,
t = P.second.second;
if (tp == 1) {
if (t == u && x && (u != v)) {
cout << "YES\n";
} else
cout << "NO\n";
} else {
if (y && z && (v != t)) {
cout << "YES\n";
} else
cout << "NO\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "-1";
return 0;
}
for (int i = 0; i < n; i++) {
cout << i << " ";
}
cout << "\n";
for (int i = 0; i < n; i++) {
cout << i << " ";
}
cout << "\n";
for (int i = 0; i < n; i++) {
cout << ((i * 2) % n) << " ";
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
while(1){
long long n,m;
long long sum=0;
cin>>n>>m;
if(n==0&&m==0) break;
long long p[1005];
for(int i=0;i<n;i++){
cin>>p[i];
sum+=p[i];
}
sort(p,p+n,greater<long long>());
for(int i=1;i<=n;i++){
if(i%m==0){
sum-=p[i-1];
}
}
cout<<sum<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> sweetness;
for (long long i = 0; i < n; i++) {
long long ele;
cin >> ele;
sweetness.push_back(ele);
}
vector<long long> modular = vector<long long>(m, 0);
sort(sweetness.begin(), sweetness.end());
long long cur = 0;
for (long long i = 0; i < n; i++) {
cur += sweetness[i];
cur += modular[i % m];
cout << cur << " ";
modular[i % m] += sweetness[i];
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, k;
cin >> n >> m >> k;
int per = n / k;
if (per >= m) {
cout << m << endl;
} else {
int a = n / k;
int b = (m - a + k - 2) / (k - 1);
if (a <= b) {
cout << 0 << endl;
} else {
cout << a - b << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
bool cmp_second(const pair<T, U> &a, const pair<T, U> &b) {
return a.second < b.second;
}
pair<int, int> operator+(const pair<int, int> &a, const pair<int, int> &b) {
return make_pair(a.first + b.first, a.second + b.second);
}
pair<int, int> operator-(const pair<int, int> &a, const pair<int, int> &b) {
return make_pair(a.first - b.first, a.second - b.second);
}
pair<int, int> &operator+=(pair<int, int> &a, const pair<int, int> &b) {
a.first += b.first;
a.second += b.second;
return a;
}
pair<int, int> &operator-=(pair<int, int> &a, const pair<int, int> &b) {
a.first -= b.first;
a.second -= b.second;
return a;
}
inline int sg(int x) { return x ? (x > 0 ? 1 : -1) : 0; }
const int maxp = 30;
int tp[maxp + 1];
int n, s[100050];
int sub() {
vector<int> stk;
int sol = 0;
for (int i = 0; i < n; i++) {
while (stk.size() && stk.back() < s[i]) {
sol = max(sol, stk.back() ^ s[i]);
stk.pop_back();
}
stk.push_back(s[i]);
}
return sol;
}
int solve() {
int s1 = sub();
for (int i = 0; i < n - i - 1; i++) swap(s[i], s[n - i - 1]);
int s2 = sub();
return max(s1, s2);
}
int main(void) {
for (int i = 0; i <= maxp; i++) tp[i] = 1 << i;
scanf("%d", &(n));
for (int i = 0; i < n; i++) scanf("%d", &(s[i]));
printf("%d\n", solve());
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
int a[1001];
int b[1001];
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
}
sort(a, a + n);
sort(b, b + n);
long long int m = max(a[n - 1] - a[0], b[n - 1] - b[0]);
cout << m * m << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int f, t;
};
Node node[100 + 10];
bool cmp(const Node& a, const Node& b) {
return (a.f < b.f || ((a.f == b.f) && a.t <= b.t));
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> node[i].f;
cin >> node[i].t;
}
int p = 0;
for (int i = 0; i < n; i++) {
if (p >= node[i].f && p < node[i].t) p = node[i].t;
}
if (p < m)
cout << "NO";
else
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 200005;
int n, k;
int zers, ones, ch = 1;
bool winEq(int moves, int zers, int ones, int ch) {
if (moves == 0) return ch == 0;
if (zers <= moves / 2) return (moves - zers) % 2 == ch;
if (ones <= moves / 2) return ones % 2 == ch;
return false;
}
bool winOdd(int moves, int zers, int ones, int ch) {
return zers && !winEq(moves - 1, zers - 1, ones, !ch) ||
ones && !winEq(moves - 1, zers, ones - 1, ch);
}
bool Win(int moves, int zers, int ones, int ch) {
return moves % 2 ? winOdd(moves, zers, ones, ch)
: winEq(moves, zers, ones, ch);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
if (a % 2) {
ones++;
ch = !ch;
} else
zers++;
}
printf("%s\n", Win(n - k, zers, ones, ch) ? "Stannis" : "Daenerys");
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.