solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long l3[3][100005];
int main() {
long long n;
cin >> n;
long long l1[n + 1], l2[n + 1];
map<long long, long long> mp, mp2;
vector<long long> v;
for (int i = 1; i <= n; i++) {
cin >> l1[i] >> l2[i];
mp[l1[i]] = 1;
mp[l2[i]] = 2;
mp2[l1[i]] = i;
mp2[l2[i]] = i;
v.push_back(l1[i]);
v.push_back(l2[i]);
if (i <= n / 2) {
l3[1][i] = 1;
l3[2][i] = 1;
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size() && i < n; i++) {
if (mp[v[i]] == 1)
l3[1][mp2[v[i]]] = 1;
else
l3[2][mp2[v[i]]] = 1;
}
for (int i = 1; i <= n; i++) cout << l3[1][i];
cout << endl;
for (int i = 1; i <= n; i++) cout << l3[2][i];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
const long long int MOD = 1e9 + 7;
int n, m;
long long int d[2][N], ans;
string s, t;
int main() {
cin >> s >> t;
n = s.size(), m = t.size();
for (int i = 0; i < m; ++i) d[0][i] = d[0][i - 1] + (int)(t[i] == s[0]);
ans = d[0][m - 1];
for (int i = 1; i < n; ++i) {
for (int j = 0; j < m; ++j) {
d[i % 2][j] = d[i % 2][j - 1];
d[i % 2][j] += (long long)(s[i] == t[j]);
if ((s[i] == t[j]) and j) d[i % 2][j] += d[(i + 1) % 2][j - 1];
d[i % 2][j] %= MOD;
}
ans += d[i % 2][m - 1];
ans %= MOD;
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 10000010;
int p[20] = {2, 3, 5, 7, 11, 13, 17, 19};
int a[Maxn];
int main() {
int n;
while (~scanf("%d", &n)) {
int cnt = 1;
a[0] = 1;
int tmp = 2 * n * n;
int ch;
for (int i = 0;; i++) {
for (int j = 0; j < cnt; j++) {
if (p[i] * a[j] <= tmp) a[cnt++] = p[i] * a[j];
}
if (cnt > n) break;
}
for (int i = 0; i < n; i++) printf("%d ", a[cnt - 1 - i]);
printf("\n");
}
return 0;
}
| 15 |
#include<bits/stdc++.h>
#define ll __int128
#define ld long double
#define ull unsigned ll
#define uint unsigned int
#define db double
#define pint pair<int,int>
#define mk make_pair
#define pb push_back
#define eb emplace_back
#define ins insert
#define fi first
#define se second
#define Rep(x,y,z) for(int x=(y);x<=(z);x++)
#define Red(x,y,z) for(int x=(y);x>=(z);x--)
using namespace std;
const int MAXN=3e4+5;
char buf[1<<12],*pp1=buf,*pp2=buf,nc;int ny;
inline char gc() {return pp1==pp2&&(pp2=(pp1=buf)+fread(buf,1,1<<12,stdin),pp1==pp2)?EOF:*pp1++;}
//inline char gc(){return getchar();}
inline ll read(){
ll x=0;for(ny=1;nc=gc(),(nc<48||nc>57)&&nc!=EOF;)if(nc==45)ny=-1;if(nc<0)return nc;
for(x=nc-48;nc=gc(),47<nc&&nc<58&&nc!=EOF;x=(x<<3)+(x<<1)+(nc^48));return x*ny;
}
int n,c,q,p[MAXN];
struct Node{int l,r;Node(int l=0,int r=0):l(l),r(r){}};
Node L[5][MAXN*10];ll w[5][MAXN*10];int st[5][MAXN],ed[5][MAXN];
inline ll C(int n,int m){ll ans=1;Rep(i,n-m+1,n)ans*=i;Rep(i,1,m)ans/=i;return ans;}
inline ll calc(int n,int c){if(n==0)return 1;ll ans=0;Rep(i,0,c)ans+=C(n-1,i);return ans;}
inline void Init(){
Rep(i,1,c){
int l=n*5+1,r=n*5+1;L[i][l]=Node(1,1);
Red(j,n,1){
static int s[MAXN];Rep(k,1,min(i,n-j))s[k]=j+k;
sort(s+1,s+min(i,n-j)+1,[](int x,int y){return p[x]<p[y];});
Rep(k,1,min(i,n-j))if(p[s[k]]>p[j])L[i][++r]=Node(j,s[k]);
Red(k,min(i,n-j),1)if(p[s[k]]<p[j])L[i][--l]=Node(j,s[k]);
st[i][j]=l,ed[i][j]=r;
}w[i][l-1]=0;Rep(j,l,r)w[i][j]=w[i][j-1]+(L[i][j].r!=L[i][j].l?calc(n-L[i][j].r,i-(L[i][j].r-L[i][j].l)):1);
// Rep(j,l,r)cout<<L[i][j].l<<" "<<L[i][j].r<<"x\t";puts("");Rep(j,l,r)cout<<w[i][j]<<"\t\t";puts("");
}
}
inline int F(int i,int c,ll k){return lower_bound(w[c]+st[c][i],w[c]+ed[c][i]+1,k+w[c][st[c][i]-1])-w[c];}
inline int Solve(int i,ll j){
if(j>calc(n,c))return -1;
else{
static Node pp[MAXN];int now=1,cnt=0,tt=c;
for(;tt>0&&j>0;){
int t=F(now,tt,j);//cout<<j<<" "<<t<<" "<<L[tt][t].l<<" "<<L[tt][t].r<<"\n";
if(L[tt][t].l==L[tt][t].r)break;pp[++cnt]=L[tt][t];
j-=w[tt][t-1]-w[tt][st[tt][now]-1],now=L[tt][t].r+1,tt-=L[tt][t].r-L[tt][t].l;
}//Rep(k,1,cnt)cout<<pp[k].l<<" "<<pp[k].r<<"\n";
Rep(k,1,cnt)if(pp[k].r>=i&&pp[k].l<=i)return p[pp[k].l+pp[k].r-i];return p[i];
}
}
int main(){
// freopen("std.in","r",stdin);
// freopen("std.out","w",stdout);
for(int t=read();t--;){
n=read(),c=read(),q=read();Rep(i,1,n)p[i]=read();Init();
for(ll i,j;q--;)i=read(),j=read(),cout<<Solve(i,j)<<'\n';
memset(w,0,sizeof(w)),memset(st,0,sizeof(st)),memset(ed,0,sizeof(ed));
}
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q > 0) {
q--;
long long n, m;
cin >> n >> m;
long long k = n / m;
int mlast = m % 10;
int s10 = 0;
for (int i = 1; i <= 9; i++) s10 += (mlast * i) % 10;
long long s = 0;
s += (k / 10) * s10;
k %= 10;
for (int i = 1; i <= k; i++) s += (mlast * i) % 10;
cout << s << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int x[500];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i = -1;
for (int j = 1; j <= m; j++) {
int u;
scanf("%d", &u);
if (x[u % n] == 0)
x[u % n]++;
else {
if (i == -1) i = j;
}
}
printf("%d\n", i);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size(), z = 0, o = 0, u = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == '0')
++z;
else if (s[i] == '1')
++o;
else
++u;
}
int p = n / 2, q = (n + 1) / 2;
if (o < q) puts("00");
if (s[n - 1] != '0' && z <= p && o + (s[n - 1] == '?') <= q) puts("01");
if (s[n - 1] != '1' && o <= q && z + (s[n - 1] == '?') <= p) puts("10");
if (z < p) puts("11");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int INF = 1e18;
const long long int N = 2e6 + 20;
vector<long long int> g[N];
vector<long long int> vis(N);
vector<long long int> ans(N);
void pre() {
ans[3] = 4;
for (long long int i = 4; i < N; i++) {
ans[i] = (ans[i - 1] + 2 * ans[i - 2]) % MOD;
if (i % 3 == 0) {
ans[i] += 4;
ans[i] %= MOD;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
pre();
long long int tc;
cin >> tc;
while (tc--) {
long long int n;
cin >> n;
cout << ans[n] << '\n';
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 600010;
const double pi = acos(-1.0);
const double eps = 1e-15;
int t, n, m, u, v;
int ans = 0, total = 0, sum = 0, cnt = 0, l = 0, r = 0;
int a[maxx], x[maxx], y[maxx], upx[maxx], upy[maxx], dx[maxx], dy[maxx];
char c[311][311];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
total = sum = cnt = 0, ans = 4;
for (int i = 1; i <= n + 1; i++) x[i] = upx[i] = dx[i] = 0;
for (int i = 1; i <= m + 1; i++) y[i] = upy[i] = dy[i] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf(" %c", &c[i][j]);
if (c[i][j] == 'P') total++, x[i]++, y[j]++;
}
if (total == n * m) {
printf("MORTAL\n");
continue;
}
if (!total) {
printf("0\n");
continue;
}
for (int i = 1; i <= n; i++) upx[i] = upx[i - 1] + x[i - 1];
for (int i = n; i >= 1; i--) dx[i] = dx[i + 1] + x[i + 1];
for (int i = 1; i <= m; i++) upy[i] = upy[i - 1] + y[i - 1];
for (int i = m; i >= 1; i--) dy[i] = dy[i + 1] + y[i + 1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (c[i][j] == 'A') {
l = j, sum = 0;
for (int k = l; k <= m; k++) {
if (c[i][k] == 'A') sum++;
if (c[i][k] == 'P') {
if (l == 1) {
if (x[i] == total)
ans = min(ans, 1);
else {
if (dx[i] && upx[i])
ans = min(ans, 3);
else
ans = min(ans, 2);
}
} else {
if (x[i] == total)
ans = min(ans, 2);
else {
if (dx[i] && upx[i])
ans = min(ans, 4);
else
ans = min(ans, 3);
}
}
j = k;
break;
}
if (k == m) {
if (l == 1) {
if (upx[i] && dx[i])
ans = min(ans, 2);
else
ans = min(ans, 1);
} else {
if (x[i] == total)
ans = min(ans, 1);
else {
if (upx[i] && dx[i])
ans = min(ans, 3);
else
ans = min(ans, 2);
}
}
j = m + 1;
}
}
}
}
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n; i++) {
if (c[i][j] == 'A') {
l = i, sum = 0;
for (int k = i; k <= n; k++) {
if (c[k][j] == 'A') sum++;
if (c[k][j] == 'P') {
if (l == 1) {
if (y[j] == total)
ans = min(ans, 1);
else {
if (dy[j] && upy[j])
ans = min(ans, 3);
else
ans = min(ans, 2);
}
} else {
if (y[j] == total)
ans = min(ans, 2);
else {
if (dy[j] && upy[j])
ans = min(ans, 4);
else
ans = min(ans, 3);
}
}
i = k;
break;
}
if (k == n) {
if (l == 1) {
if (dy[j] && upy[j])
ans = min(ans, 2);
else
ans = min(ans, 1);
} else {
if (dy[j] && upy[j])
ans = min(ans, 3);
else
ans = min(ans, 2);
}
i = n + 1;
}
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void ckmin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
void ckmax(T &a, U b) {
if (a < b) a = b;
}
int N, K, A;
long long arr[100013];
long long cost[100013];
priority_queue<long long, vector<long long>, greater<long long> > pq;
long long ans;
int taken;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> K;
for (auto i = (0); i < (N); i++) {
cin >> arr[i];
}
cin >> A;
for (auto i = (0); i < (N); i++) {
cin >> cost[i];
}
for (auto i = (0); i < (N); i++) {
arr[i] = (arr[i] - K + A - 1) / A;
}
for (auto i = (0); i < (N); i++) {
pq.push(cost[i]);
while (taken < arr[i]) {
if (pq.empty()) {
cout << "-1\n";
return 0;
}
taken++;
ans += pq.top();
pq.pop();
}
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, asdasjkd, adsnamsd, a[101], mna, mnb, b[101];
int ans;
int main() {
int t23 = 1;
cin >> t23;
for (int qwe = 1; qwe <= t23; qwe++) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
ans = 1e9;
sort(a + 1, a + n + 1);
for (int i = 2; i <= n; i++) ans = min(ans, a[i] - a[i - 1]);
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, m;
int x, y;
int i, j;
char grid[100][101];
while (~scanf("%d%d", &n, &m)) {
x = y = 0;
for (i = 0; i < n; ++i) {
scanf("%s", grid[i]);
for (j = 0; j < m; ++j) {
if (grid[i][j] == '*') {
x ^= i;
y ^= j;
}
}
}
printf("%d %d\n", x + 1, y + 1);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 1000;
int n, m, q;
long long tmp;
int vis[maxn];
pair<long long, long long> a[maxn], b[maxn];
int ans[maxn];
int v[maxn * 4];
void build(int l, int r, int x) {
v[x] = 0;
if (r == l) {
return;
}
int mid = (l + r) / 2;
build(l, mid, x << 1);
build(mid + 1, r, x << 1 | 1);
}
void update(int l, int r, int pos, int x) {
if (l == pos && r == pos) {
v[x] = 1;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
update(l, mid, pos, x << 1);
else
update(mid + 1, r, pos, x << 1 | 1);
v[x] = v[x << 1] + v[x << 1 | 1];
}
int query(int l, int r, int pos, int x) {
if (l == r) {
return l;
}
int mid = (l + r) / 2;
if (v[x << 1] >= pos) {
return query(l, mid, pos, x << 1);
}
return query(mid + 1, r, pos - v[x << 1], x << 1 | 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) {
cin >> tmp;
vis[tmp]++;
}
build(1, m, 1);
for (int i = 1; i <= m; ++i) {
a[i] = {vis[i], i};
}
for (int i = 0; i < q; ++i) {
cin >> tmp;
b[i] = {tmp, i};
}
sort(a + 1, a + m + 1);
sort(b, b + q);
long long tmp = n, ttmp;
int j = 1;
for (int i = 0; i < q; ++i) {
while (b[i].first > tmp && j <= m) {
int tt = a[j].first;
while (j <= m && a[j].first == tt) {
update(1, m, a[j].second, 1);
++j;
}
ttmp = tmp;
if (j > m) {
tmp += (a[m].first - tt) * (j - 1);
} else {
tmp += (a[j].first - tt) * (j - 1);
}
}
int ind = (b[i].first - ttmp) % (j - 1);
if (!ind) {
ind = j - 1;
}
ans[b[i].second] = query(1, m, ind, 1);
}
for (int i = 0; i < q; ++i) {
cout << ans[i] << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300002;
int col[N];
map<vector<int>, int> ind;
int n, m, c;
vector<int> adj[N], adj2[N];
void go(int u) {
int v, i;
col[u] = c++;
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (col[v] == 0) go(v);
}
}
int main() {
scanf("%d %d", &n, &m);
int i;
int u, v;
for (i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
adj2[u].push_back(v);
adj2[v].push_back(u);
}
int deg = 1;
for (i = 1; i <= n; i++) {
adj2[i].push_back(i);
sort(adj2[i].begin(), adj2[i].end());
if (ind.find(adj2[i]) == ind.end()) ind[adj2[i]] = deg++;
}
int nxt;
int j;
for (i = 1; i <= n; i++) {
for (j = 0; j < adj2[i].size(); j++) {
nxt = adj2[i][j];
if (ind[adj2[i]] != ind[adj2[nxt]])
adj[ind[adj2[i]]].push_back(ind[adj2[nxt]]);
}
}
for (i = 1; i < deg; i++) {
sort(adj[i].begin(), adj[i].end());
adj[i].erase(unique(adj[i].begin(), adj[i].end()), adj[i].end());
if (adj[i].size() > 2) {
printf("NO\n");
return 0;
}
}
c = 1;
for (i = 1; i < deg; i++) {
if (col[i] == 0 && adj[i].size() < 2) {
go(i);
}
}
printf("YES\n");
for (i = 1; i <= n; i++) {
printf("%d ", col[ind[adj2[i]]]);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
struct Circle {
int x, y;
long long radi;
Circle() {}
Circle(int x, int y, long long radi) {
this->x = x;
this->y = y;
this->radi = radi;
}
};
int main(void) {
int n, m, k;
scanf("%i %i %i", &n, &m, &k);
vector<int> X(n), Y(n);
for (int i = 0; i < n; i++) {
scanf("%i %i", &X[i], &Y[i]);
}
vector<Circle> circles(m);
for (Circle &c : circles) {
scanf("%lld %i %i", &c.radi, &c.x, &c.y);
}
circles.push_back(Circle(0, 0, static_cast<long long>(1e13)));
sort(begin(circles), end(circles),
[](Circle a, Circle b) { return a.radi < b.radi; });
auto distance = [](Circle a, Circle b) -> double {
return hypot(a.x - b.x, a.y - b.y);
};
vector<vector<int>> tree(m + 1);
for (int i = 0; i < m; i++) {
bool found = false;
for (int j = i + 1; j < m + 1; j++) {
if (distance(circles[i], circles[j]) < circles[j].radi) {
tree[j].push_back(i);
tree[i].push_back(j);
found = true;
break;
}
}
assert(found);
}
vector<int> which(n, -1);
for (int i = 0; i < n; i++) {
bool found = false;
for (int j = 0; j < m + 1; j++) {
if (hypot(X[i] - circles[j].x, Y[i] - circles[j].y) < circles[j].radi) {
which[i] = j;
found = true;
break;
}
}
assert(found);
}
vector<vector<int>> distances(m + 1);
for (int i = 0; i < m + 1; i++) {
vector<bool> seen(m + 1);
vector<int> d(m + 1);
queue<int> q;
q.push(i);
seen[i] = true;
d[i] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : tree[u]) {
if (!seen[v]) {
seen[v] = true;
d[v] = 1 + d[u];
q.push(v);
}
}
}
distances[i] = d;
}
while (k--) {
int a, b;
scanf("%i %i", &a, &b);
printf("%i\n", distances[which[a - 1]][which[b - 1]]);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) __attribute__((always_inline));
long long sqr(long long x) { return x * x; }
struct Point {
Point(int x = 0, int y = 0) : x(x), y(y) {}
Point &operator-=(const Point &o) {
x -= o.x;
y -= o.y;
return *this;
}
double norm() const __attribute__((always_inline));
int x, y;
};
double Point::norm() const { return sqrt(sqr(x) + sqr(y)); }
inline Point operator-(Point a, const Point &b) { return a -= b; }
long long det(const Point &a, const Point &b) __attribute__((always_inline));
long long dot(const Point &a, const Point &b) __attribute__((always_inline));
long long get_sum(int i, int j) __attribute__((always_inline));
int nxt(int i) __attribute__((always_inline));
double solve() __attribute__((always_inline));
long long det(const Point &a, const Point &b) {
return (long long)a.x * b.y - (long long)a.y * b.x;
}
long long dot(const Point &a, const Point &b) {
return (long long)a.x * b.x + (long long)a.y * b.y;
}
const int N = 40000;
int n;
Point p[N];
long long sum[N + 1];
long long get_sum(int i, int j) {
long long s = sum[j] - sum[i];
return i <= j ? s : sum[n] + s;
}
int nxt(int i) { return (i + 1) % n; }
double solve() {
sum[0] = 0;
for (int i = 0; i < n; ++i) sum[i + 1] = sum[i] + det(p[i], p[(i + 1) % n]);
double result = INFINITY;
for (int i = 0, j = 0; i < n; ++i) {
while (dot(p[nxt(i)] - p[i], p[nxt(j)] - p[j]) > 0) j = nxt(j);
Point a = p[nxt(i)] - p[i];
Point b = p[j] - p[i];
double n = a.norm();
result = min(result, det(a, b) / n * dot(a, b) / n -
(get_sum(i, j) + det(p[j], p[i])));
if (i == j) return 0.;
}
return .5 * result;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d%d", &p[i].x, &p[i].y);
solve();
if (sum[n] < 0) reverse(p, p + n);
double result = solve();
for (int i = 0; i < n; ++i) p[i].x *= -1;
reverse(p, p + n);
result = min(result, solve());
printf("%.10f\n", result);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000086;
char buf[MAXN], s[MAXN];
vector<pair<int, int> > tt;
int main() {
int i, j, k;
int m, n;
int len;
int c, e;
scanf("%s", buf);
len = strlen(buf);
for (i = 0; i < len; ++i) s[i] = buf[len - 1 - i];
s[i] = '\0';
for (i = 0; i < len;) {
if (s[i] == '0') {
++i;
} else {
for (j = i; j < len && s[j] == '1'; ++j)
;
if (j - i == 1) {
tt.push_back(make_pair((1), (i)));
++i;
} else {
tt.push_back(make_pair((-1), (i)));
if (s[j + 1] == '1') {
s[i = j] = '1';
} else {
tt.push_back(make_pair((1), (j)));
i = j;
}
}
}
}
printf("%d\n", tt.size());
for (i = 0; i < tt.size(); ++i) {
c = tt[i].first, e = tt[i].second;
if (c == 1)
printf("+2^%d\n", e);
else
printf("-2^%d\n", e);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, h;
string s;
vector<char> v[100002];
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s;
h = s.size();
for (j = 0; j < s.size(); j++) {
if (s[j] == '?') continue;
if (v[j].size() == 0) {
v[j].push_back(s[j]);
continue;
}
if (v[j][0] != s[j]) v[j].push_back(s[j]);
}
}
for (i = 0; i < h; i++) {
if (v[i].size() == 0)
cout << "x";
else if (v[i].size() > 1)
cout << "?";
else
cout << v[i][0];
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[36] = {
1, 2, 4, 8, 16, 32,
64, 128, 256, 512, 1024, 2048,
4096, 8092, 16184, 32368, 64736, 129472,
258944, 517888, 1035776, 2071552, 4143104, 8286208,
16572416, 33144832, 66289664, 132579328, 265158656, 530317312,
1060634624, 2121269248, 4242538496, 8485076992, 16970153984, 33940307968};
int main() {
int i;
cin >> i;
cout << a[i];
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a, b, n, p;
cin >> a >> b >> n;
p = a ^ b;
if (n % 3 == 0)
cout << a << endl;
else if ((n - 1) % 3 == 0)
cout << b << endl;
else
cout << p << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class mexMap {
private:
map<int, int> S;
int MEX;
public:
mexMap() { MEX = 0; }
int get() { return MEX; }
void insert(int v) {
S[v]++;
if (v == MEX) {
map<int, int>::iterator it = S.find(v);
for (; it != S.end(); it++) {
if (MEX != it->first) break;
MEX++;
}
}
}
void erase(int v) {
S[v]--;
if (v < MEX && S[v] == 0) MEX = v;
if (S[v] == 0) S.erase(v);
}
};
long long getL(long long x) {
long long l = 0, y, r = 10000;
while (l != r) {
y = (l + r) / 2;
if (x <= y * y * y * y)
r = y;
else
l = y + 1;
}
return l;
}
long long getR(long long x) {
long long l = 0, y, r = 1000000000ll;
while (l != r) {
y = (l + r + 1) / 2;
if (y * y <= x)
l = y;
else
r = y - 1;
}
return l;
}
const int MAX = 1001000;
int dp[MAX];
long long a[MAX];
int acc[5][MAX];
int grundy(long long val) {
if (val < MAX)
return dp[val];
else {
long long l = getL(val), r = getR(val);
for (int i = 0; i < int(5); i++)
if (acc[i][r] - acc[i][l - 1] == 0) return i;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < int(n); i++) scanf("%lld", a + i);
long long l, r;
for (int x = 0; x < int(50); x++) {
l = -1;
set<int> S;
for (int y = 0; y < int(x); y++) {
if (y < x && x <= y * y * y * y && y * y <= x) {
if (l == -1) l = y;
r = y;
S.insert(dp[y]);
}
}
int cnt = 0;
for (__typeof((S).begin()) v = (S).begin(); v != (S).end(); v++) {
if (*v != cnt) break;
cnt++;
}
dp[x] = cnt;
}
mexMap S;
for (int i = l; i <= r; i++) S.insert(dp[i]);
long long x = 50;
int i = 50;
int mx = 0;
for (; x < MAX; x++) {
long long y = r;
while ((y + 1) * (y + 1) <= x) {
y++;
r++;
S.insert(dp[r]);
}
y = l;
while (x > y * y * y * y) {
S.erase(dp[l]);
y++;
l++;
}
dp[i] = S.get();
i++;
}
for (int i = 0; i < int(MAX); i++) acc[dp[i]][i]++;
for (int i = 1; i < MAX; i++)
for (int j = 0; j < int(5); j++) acc[j][i] += acc[j][i - 1];
int xr = 0;
for (int i = 0; i < int(n); i++) xr ^= grundy(a[i]);
if (xr != 0)
printf("Furlo\n");
else
printf("Rublo\n");
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, dp[500005][30], maxx[30][30];
struct cuv {
int ul, pr;
int len;
} a[500005];
int main() {
int i, j, sol = -2000000000, pr;
char sir[100];
cin.sync_with_stdio(0);
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> (sir + 1);
a[i].pr = sir[1] - 'a';
a[i].len = strlen(sir + 1);
a[i].ul = sir[a[i].len] - 'a';
}
for (i = 1; i <= n; ++i)
for (j = 0; j < 26; ++j) dp[i][j] = -2000000000;
for (i = 0; i < 26; ++i)
for (j = 0; j < 26; ++j) maxx[i][j] = -2000000000;
dp[1][a[1].ul] = a[1].len;
maxx[a[1].pr][a[1].ul] = a[1].len;
for (i = 2; i <= n; ++i) {
for (j = 0; j < 26; ++j) dp[i][j] = dp[i - 1][j];
for (pr = 0; pr < 26; ++pr) {
dp[i][a[i].ul] = max(dp[i][a[i].ul], maxx[pr][a[i].pr] + a[i].len);
maxx[pr][a[i].ul] = max(maxx[pr][a[i].ul], maxx[pr][a[i].pr] + a[i].len);
}
dp[i][a[i].ul] = max(dp[i][a[i].ul], a[i].len);
maxx[a[i].pr][a[i].ul] = max(maxx[a[i].pr][a[i].ul], a[i].len);
}
for (i = 0; i < 26; ++i) {
sol = max(sol, maxx[i][i]);
}
if (sol < 0)
cout << "0";
else
cout << sol;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[1000001], l[1000001], r[1000001], ans;
long long S(long long k) {
return k & 1 ? (k + 1) / 2ll % 1000000007 * k % 1000000007
: k / 2ll % 1000000007 * (k + 1) % 1000000007;
}
long long f(long long a, long long b, long long c, long long n) {
if (!a) return 0;
if (a >= c || b >= c)
return ((a / c) * S(n) % 1000000007 + (n + 1) * (b / c) % 1000000007 +
f(a % c, b % c, c, n)) %
1000000007;
long long m = (a * n + b) / c;
return (m * n % 1000000007 - f(c, c - b - 1, a, m - 1) + 1000000007) %
1000000007;
}
long long get(long long l, long long r, long long x) {
return (f(1, r - x, k, x - l) - f(1, 0, k, x - l - 1) + 1000000007) %
1000000007;
}
int main() {
scanf("%I64d%I64d", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%I64d", &a[i]);
l[1] = 1, r[n] = n;
for (long long i = 2; i <= n; i++) {
long long _ = i;
while (_ > 1 && a[i] > a[_ - 1]) _ = l[_ - 1];
l[i] = _;
}
for (long long i = n - 1; i >= 1; i--) {
long long _ = i;
while (_ < n && a[i] >= a[_ + 1]) _ = r[_ + 1];
r[i] = _;
}
k--;
for (long long i = 1; i <= n; i++)
ans += get(l[i], r[i], i) * a[i] % 1000000007, ans %= 1000000007;
printf("%I64d\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
map<char, long long> m;
cin >> s;
long long count = 0;
for (int i = 0; i < s.length(); i++) {
m[s[i]] += 1;
}
for (map<char, long long>::iterator it = m.begin(); it != m.end(); ++it) {
count += (it->second) * (it->second);
}
cout << count << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, n, x, y;
cin >> s >> n;
multimap<int, int> dragons;
for (int i = 0; i < n; i++) {
cin >> x >> y;
dragons.insert({x, y});
}
bool flag = true;
for (auto it = dragons.begin(); it != dragons.end(); it++) {
if (it->first < s) {
s += it->second;
} else {
flag = false;
break;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
inline long long readint() {
long long res = 0, f = 1;
char c = 0;
while (!isdigit(c)) {
c = getchar();
if (c == '-') f = -1;
}
while (isdigit(c)) res = res * 10 + c - '0', c = getchar();
return res * f;
}
int n, m, T, a[MAXN][MAXN];
char str[MAXN];
int f[MAXN][MAXN], pos[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
bool vis[MAXN][MAXN];
inline bool check(int x, int y) {
for (int i = 0; i < 4; i++) {
int nx = x + pos[i][0], ny = y + pos[i][1];
if (a[nx][ny] == a[x][y]) return true;
}
return false;
}
pair<int, int> q[MAXN * MAXN];
inline void bfs() {
int front = 0, rear = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (check(i, j))
f[i][j] = 0, vis[i][j] = true, q[rear++] = make_pair(i, j);
while (front < rear) {
pair<int, int> now = q[front++];
for (int i = 0; i < 4; i++) {
int nx = now.first + pos[i][0], ny = now.second + pos[i][1];
if (nx < 1 || nx > n || ny < 1 || ny > m || vis[nx][ny]) continue;
f[nx][ny] = f[now.first][now.second] + 1;
vis[nx][ny] = true;
q[rear++] = make_pair(nx, ny);
}
}
}
int main() {
n = readint(), m = readint(), T = readint();
memset(a, -1, sizeof(a));
for (int i = 1; i <= n; i++) {
scanf("%s", str + 1);
for (int j = 1; j <= m; j++) a[i][j] = str[j] - '0';
}
bfs();
int x, y;
long long t;
while (T--) {
x = readint(), y = readint(), t = readint();
if (vis[x][y])
printf("%d\n", a[x][y] ^ (max(0ll, t - f[x][y]) & 1));
else
printf("%d\n", a[x][y]);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long power(long long num, long long r) {
if (r == 0) return 1;
if (r == 1) return num % mod;
long long ans = power(num, r / 2) % mod;
if (r % 2 == 0) {
return (ans * ans) % mod;
}
return (((ans * ans) % mod) * num) % mod;
}
long long modinv(long long num) { return power(num, mod - 2); }
int findset(int arr[], int x) {
if (x != arr[x]) {
arr[x] = findset(arr, arr[x]);
}
return arr[x];
}
void uni(int arr[], int ranks[], int a, int b) {
int ra = findset(arr, a);
int rb = findset(arr, b);
if (ra != rb) {
if (ranks[ra] < ranks[rb]) swap(ra, rb);
arr[rb] = ra;
if (ranks[ra] == ranks[rb]) {
ranks[ra]++;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T;
cin >> T;
int a, b, x, y;
while (T--) {
cin >> a >> b >> x >> y;
cout << max(max(x, a - x - 1) * b, a * max(y, b - 1 - y)) << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
long long t;
cin >> t;
while (t--) {
int l;
cin >> l;
int lower = upper_bound(v.begin(), v.end(), l) - v.begin();
cout << lower << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
bool isprime(long long n) {
if (n == 2) {
return true;
}
if (n % 2 == 0) {
return false;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long n, k;
bool f(long long x) {
long long t = 1;
long long res = 0;
while (x / t) {
res += x / t;
t *= k;
}
return res >= n;
}
int main() {
cin >> n >> k;
long long l = 1, r = 1e9, m;
while (l <= r) {
m = (l + r) / 2;
if (f(m))
r = m - 1;
else
l = m + 1;
}
cout << l << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << -1 << endl;
return 0;
}
if (n == 2) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2 || y1 == y2) {
cout << -1 << endl;
return 0;
}
int p = x1 - x2;
int l = y1 - y2;
int ar = p * l;
if (ar < 0) {
ar *= -1;
}
cout << ar << endl;
return 0;
}
int x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
if (x1 == x2 || y1 == y2) {
if (x1 == x3 || y1 == y3) {
int p = x3 - x2;
int l = y3 - y2;
int ar = p * l;
if (ar < 0) {
ar *= -1;
}
cout << ar << endl;
return 0;
}
int p = x3 - x1;
int l = y3 - y1;
int ar = p * l;
if (ar < 0) {
ar *= -1;
}
cout << ar << endl;
return 0;
}
int p = x1 - x2;
int l = y1 - y2;
int ar = p * l;
if (ar < 0) {
ar *= -1;
}
cout << ar << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long t1, t2, x1, x2, tt, l, r, c, a1, a2, ans = 2e12, sa;
int main() {
cin >> t1 >> t2 >> x1 >> x2 >> tt;
for (int i = 0; i <= x1; i++) {
l = 0;
r = x2;
while (l < r) {
c = (l + r) / 2;
if (i == 0 || t1 == t2 || (i * t1 + c * t2) < tt * (i + c))
l = c + 1;
else
r = c;
}
if ((i * t1 + l * t2) < tt * (i + l)) continue;
if ((i * t1 + l * t2) * sa < ans * (i + l) ||
(i * t1 + l * t2) * sa == ans * (i + l) && i + l > sa)
a1 = i, a2 = l, ans = (i * t1 + l * t2), sa = i + l;
}
cout << a1 << " " << a2 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 5;
const int C = 26;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, m, v[N];
char s[N];
long long k;
struct matrix {
long long a[N][N];
} A, Z, E;
template <class T>
void relax(T &a, T b) {
if (a < b) a = b;
}
matrix mul(matrix &A, matrix &B) {
matrix C = Z;
for (int k = 0; k < m; k++)
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) relax(C.a[i][j], A.a[i][k] + B.a[k][j]);
return C;
}
matrix pow(matrix A, long long b) {
matrix C = E;
while (b) {
if (b & 1) C = mul(C, A);
b >>= 1;
A = mul(A, A);
}
return C;
}
struct AhoCorasickAutomaton {
int go[N][C], fail[N], val[N];
int tot, root;
int newNode() {
memset(go[tot], 0, sizeof(go[tot]));
fail[tot] = val[tot] = 0;
return tot++;
}
void init() {
tot = 0;
root = newNode();
}
void insert(char *s, int v) {
int u = root;
for (int i = 0; s[i]; i++) {
int c = s[i] - 'a';
if (!go[u][c]) go[u][c] = newNode();
u = go[u][c];
}
val[u] += v;
}
void build() {
queue<int> Q;
Q.push(root);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
val[u] += val[fail[u]];
for (int i = 0; i < C; i++) {
if (go[u][i]) {
if (!u)
fail[go[u][i]] = 0;
else
fail[go[u][i]] = go[fail[u]][i];
Q.push(go[u][i]);
} else
go[u][i] = go[fail[u]][i];
}
}
}
matrix get() {
matrix A = Z;
m = tot;
for (int i = 0; i < tot; i++)
for (int j = 0; j < C; j++) A.a[i][go[i][j]] = val[go[i][j]];
return A;
}
} AC;
int main() {
AC.init();
memset(Z.a, -inf - 1, sizeof(Z.a));
E = Z;
for (int i = 0; i < N; i++) E.a[i][i] = 0;
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &v[i]);
for (int i = 0; i < n; i++) {
scanf("%s", s);
AC.insert(s, v[i]);
}
AC.build();
A = AC.get();
A = pow(A, k);
printf("%lld\n", *max_element(A.a[0], A.a[0] + m));
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long dp[55][55][55];
long long DFS(int n, int m, int k) {
if (k <= 0 || n * m == k) return 0;
if (dp[n][m][k]) return dp[n][m][k];
long long now = 0x7f7f7f7f;
for (int i = 1; i < n; i++) {
for (int j = 0; j <= k; j++) {
now = min(now, DFS(i, m, j) + DFS(n - i, m, k - j) + m * m);
}
}
for (int i = 1; i < m; i++) {
for (int j = 0; j <= k; j++) {
now = min(now, DFS(n, i, j) + DFS(n, m - i, k - j) + n * n);
}
}
dp[n][m][k] = now;
return now;
}
int main() {
int t;
cin >> t;
int n, m, k;
while (t--) {
scanf("%d%d%d", &n, &m, &k);
printf("%lld\n", DFS(n, m, k));
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
inline void read() {}
template <typename T, typename... Ts>
inline void read(T& A, Ts&... As) {
T x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
A = x * f, read(As...);
}
inline void write(char a) { putchar(a); }
template <typename T>
inline void write(T a) {
if (a < 0ll) putchar('-'), a = -a;
if (a > 9ll) write(a / 10ll);
putchar(a % 10ll + '0');
}
template <typename T, typename... Ts>
inline void write(T A, Ts... As) {
write(A), write(As...);
}
const int N = 500010;
long long n, m, s[N], C, S[N];
struct node {
long long w, siz, id;
} sh[N], g[N];
vector<node> v[N];
struct res {
long long val, fr, f2, tr;
bool operator<(res k) const { return val < k.val; }
bool operator>(res k) const { return val > k.val; }
};
vector<res> dp[N][2];
void chg(long long& x) { x = lower_bound(S + 1, S + C + 1, x) - S; }
vector<pair<int, int> > gg;
signed main() {
read(n);
for (register int i = 1; i <= n; ++i)
read(sh[i].w, sh[i].siz), sh[i].id = i, S[++C] = sh[i].siz;
read(m);
for (register int i = 1; i <= m; ++i)
read(g[i].w, g[i].siz), g[i].siz++, g[i].id = i, S[++C] = g[i].siz,
S[++C] = g[i].siz - 1,
S[++C] = g[i].siz + 1;
sort(S + 1, S + C + 1), C = unique(S + 1, S + C + 1) - S - 1;
for (register int i = 1; i <= n; ++i) chg(sh[i].siz), s[sh[i].siz] = i;
for (register int i = 1; i <= m; ++i)
chg(g[i].siz), v[g[i].siz].push_back(g[i]);
dp[0][0].push_back(res{0, 0, 0, 0});
dp[0][1].push_back(res{0, 0, 0, 0});
for (register int i = 1; i <= C; ++i) {
if (dp[i - 1][1][(int)(dp[i - 1][1].size()) - 1] >
dp[i - 1][0][(int)(dp[i - 1][0].size()) - 1])
dp[i][0].push_back(res{dp[i - 1][1][(int)(dp[i - 1][1].size()) - 1].val,
1, (int)(dp[i - 1][1].size()) - 1, 0});
else
dp[i][0].push_back(res{dp[i - 1][0][(int)(dp[i - 1][0].size()) - 1].val,
0, (int)(dp[i - 1][0].size()) - 1, 0});
dp[i][1] = dp[i][0];
if (sh[s[i]].w > sh[s[i - 1]].w)
sort(v[i].begin(), v[i].end(), [&](node x, node y) { return x.w < y.w; });
else
sort(v[i].begin(), v[i].end(), [&](node x, node y) { return x.w > y.w; });
for (node k : v[i]) {
if (s[i] && k.w >= sh[s[i]].w) {
res clc = res{dp[i][0][(int)(dp[i][0].size()) - 1].val + sh[s[i]].w,
dp[i][0][(int)(dp[i][0].size()) - 1].fr,
dp[i][0][(int)(dp[i][0].size()) - 1].f2, k.id};
if (clc > dp[i][1][(int)(dp[i][1].size()) - 1]) dp[i][1].push_back(clc);
}
if (s[i - 1] && k.w >= sh[s[i - 1]].w) {
res clc = res{
dp[i - 1][0][(int)(dp[i - 1][0].size()) - 1].val + sh[s[i - 1]].w,
dp[i - 1][0][(int)(dp[i - 1][0].size()) - 1].fr,
dp[i - 1][0][(int)(dp[i - 1][0].size()) - 1].f2, k.id};
if (clc > dp[i - 1][1][(int)(dp[i - 1][1].size()) - 1])
dp[i - 1][1].push_back(clc);
}
if (dp[i - 1][1][(int)(dp[i - 1][1].size()) - 1] >
dp[i - 1][0][(int)(dp[i - 1][0].size()) - 1])
dp[i][0].push_back(res{dp[i - 1][1][(int)(dp[i - 1][1].size()) - 1].val,
1, (int)(dp[i - 1][1].size()) - 1, 0});
else
dp[i][0].push_back(res{dp[i - 1][0][(int)(dp[i - 1][0].size()) - 1].val,
0, (int)(dp[i - 1][0].size()) - 1, 0});
}
}
res ans = max(dp[C][0][(int)(dp[C][0].size()) - 1],
dp[C][1][(int)(dp[C][1].size()) - 1]);
int now = C;
write(ans.val, '\n');
while (now) {
if (ans.tr) gg.push_back(pair<int, int>(ans.tr, s[now]));
ans = dp[--now][ans.fr][ans.f2];
}
write(gg.size(), '\n');
for (pair<int, int> k : gg) write(k.first, ' ', k.second, '\n');
return 0;
}
| 17 |
#include <bits/stdc++.h>
int main(void) {
int n, H, i;
scanf("%d %d", &n, &H);
for (i = 1; i < n; i++) {
printf("%.12lf ", H * sqrt(i * 1.0 / n));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, a, b, c, n;
cin >> k >> a >> b >> c;
for (int i = 1; i <= 1000; i++) {
n = k * i;
n = min(n, b + i);
if (c * n >= a) {
printf("%d\n", i);
return 0;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long *X, long long *Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
const long long inf = 2147383647;
const long long mod = 1000000007;
const double pi = 2 * acos(0.0);
const double eps = 1e-11;
string a, b;
int mark[1000005];
int N, M;
struct KMP {
string text, pat;
int txtLen, patLen;
int fail[1000005];
void clear(string &t, string &p) {
text = t, pat = p;
txtLen = ((long long)(text).size());
patLen = ((long long)(pat).size());
}
void failureFunction() {
fail[0] = 0;
int j = 0, i = 1;
while (i < patLen) {
if (pat[j] == pat[i]) {
j++;
fail[i] = j;
i++;
} else if (j == 0) {
fail[i] = 0;
i++;
} else {
j = fail[j - 1];
}
}
}
void findmatching() {
int i = 0, j = 0;
while (i < txtLen) {
if (text[i] == pat[j]) {
i++;
j++;
if (j == patLen) {
mark[i - j] = 1;
j = fail[j - 1];
}
} else {
if (j != 0) {
j = fail[j - 1];
} else {
i++;
}
}
}
}
} kmp;
struct vert {
long long val;
};
vert T[1000005 * 4];
void ut(int c, int s, int e, int u, int v, int val) {
if (e < u || s > v) return;
if (s >= u && e <= v) {
T[c].val = val;
return;
}
int L = c * 2, R = c * 2 + 1, M = (s + e) / 2;
ut(L, s, M, u, v, val);
ut(R, M + 1, e, u, v, val);
T[c].val = T[L].val + T[R].val;
T[c].val %= mod;
}
int qt(int c, int s, int e, int u, int v) {
if (e < u || s > v) return 0;
if (s >= u && e <= v) return T[c].val;
int L = c * 2, R = c * 2 + 1, M = (s + e) / 2;
int v1 = qt(L, s, M, u, v);
int v2 = qt(R, M + 1, e, u, v);
return (v1 + v2) % mod;
}
int sufMatch[1000005];
long long DP[1000005];
long long solve() {
kmp.clear(a, b);
memset(mark, 0, sizeof(mark));
kmp.failureFunction();
kmp.findmatching();
int last = N + 1;
for (long long i = (N - 1); i >= (0); --i) {
if (mark[i]) last = i + M - 1;
sufMatch[i] = last;
}
for (long long i = (N - 1); i >= (0); --i) {
int pos = sufMatch[i] + 1;
if (pos < N + 1) {
long long res = qt(1, 1, N, pos + 1, N);
DP[i] += res;
DP[i] %= mod;
DP[i] += (N - pos + 1);
DP[i] %= mod;
}
DP[i] += DP[i + 1];
DP[i] %= mod;
ut(1, 1, N, i + 1, i + 1, DP[i]);
}
return DP[0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> a >> b;
N = ((long long)(a).size()), M = ((long long)(b).size());
cout << solve() << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc, cas = 1;
int n, m, k;
cin >> n >> m >> k;
vector<vector<int>> g(n);
vector<int> a(m), b(m);
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
a[i]--, b[i]--;
g[a[i]].push_back(b[i]);
g[b[i]].push_back(a[i]);
}
queue<int> q;
q.push(0);
vector<int> d(n, INT_MAX);
d[0] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : g[u])
if (d[v] == INT_MAX) {
d[v] = d[u] + 1;
q.push(v);
}
}
vector<vector<int>> inc(n);
for (int i = 0; i < m; i++) {
if (d[a[i]] + 1 == d[b[i]]) inc[b[i]].push_back(i);
if (d[b[i]] + 1 == d[a[i]]) inc[a[i]].push_back(i);
}
vector<int> f(n);
vector<string> result;
for (int i = 0; i < k; i++) {
string s(m, '0');
for (int j = 1; j < n; j++) s[inc[j][f[j]]] = '1';
result.push_back(s);
bool ok = false;
for (int j = 1; j < n; j++)
if (f[j] + 1 < inc[j].size()) {
ok = true;
f[j]++;
break;
} else
f[j] = 0;
if (!ok) break;
}
cout << result.size() << endl;
for (int i = 0; i < result.size(); i++) cout << result[i] << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int r, c, dist;
node() {}
node(int _r, int _c, int _dist) : r(_r), c(_c), dist(_dist) {}
bool operator<(node X) const { return dist > X.dist; }
};
int n, m, r[7], c[7], M[100][100], id[100][100];
int dist[200][200], px[200][200], py[200][200];
int memo[100][100][(1 << 7)], choosex[100][100][(1 << 7)],
choosey[100][100][(1 << 7)], choosem[100][100][(1 << 7)];
int solve(int x, int y, int mask) {
if (mask == 0) return 0;
int &ret = memo[x][y][mask];
if (ret == -1) {
if (__builtin_popcount(mask) == 1) {
int v = __builtin_ctz(mask);
ret = dist[x * m + y][r[v] * m + c[v]];
} else {
ret = 200000;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
for (int mask2 = (mask - 1) & mask; mask2 > 0;
mask2 = (mask2 - 1) & mask) {
int m1 = mask, m2 = mask2;
if (id[i][j] != -1) {
m1 &= ~(1 << id[i][j]);
m2 &= ~(1 << id[i][j]);
}
int aux = dist[x * m + y][i * m + j] + solve(i, j, m2) +
solve(i, j, m1 ^ m2);
if (aux < ret) {
ret = aux;
choosex[x][y][mask] = i;
choosey[x][y][mask] = j;
choosem[x][y][mask] = mask2;
}
}
}
}
return ret;
}
char sol[100][101];
void search(int x, int y, int mask) {
sol[x][y] = 'X';
if (mask == 0) return;
int x2, y2;
if (__builtin_popcount(mask) == 1) {
int v = __builtin_ctz(mask);
x2 = r[v];
y2 = c[v];
} else {
x2 = choosex[x][y][mask];
y2 = choosey[x][y][mask];
int mask2 = choosem[x][y][mask];
if (id[x2][y2] != -1) {
mask &= ~(1 << id[x2][y2]);
mask2 &= ~(1 << id[x2][y2]);
}
search(x2, y2, mask2);
search(x2, y2, mask ^ mask2);
}
while (x2 != x || y2 != y) {
sol[x2][y2] = 'X';
int x3 = px[x * m + y][x2 * m + y2], y3 = py[x * m + y][x2 * m + y2];
x2 = x3;
y2 = y3;
}
}
int main() {
int k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &M[i][j]);
int dr[] = {-1, 1, 0, 0}, dc[] = {0, 0, -1, 1};
int N = n * m;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j) dist[i][j] = 200001;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
priority_queue<node> Q;
Q.push(node(i, j, 0));
dist[i * m + j][i * m + j] = 0;
while (!Q.empty()) {
node aux = Q.top();
Q.pop();
if (aux.dist > dist[i * m + j][aux.r * m + aux.c]) continue;
for (int d = 0; d < 4; ++d) {
int r2 = aux.r + dr[d];
int c2 = aux.c + dc[d];
if (r2 >= 0 && r2 < n && c2 >= 0 && c2 < m &&
aux.dist + M[r2][c2] < dist[i * m + j][r2 * m + c2]) {
Q.push(node(r2, c2, aux.dist + M[r2][c2]));
dist[i * m + j][r2 * m + c2] = aux.dist + M[r2][c2];
px[i * m + j][r2 * m + c2] = aux.r;
py[i * m + j][r2 * m + c2] = aux.c;
}
}
}
}
}
memset(id, -1, sizeof id);
for (int i = 0; i < k; ++i) {
scanf("%d %d", &r[i], &c[i]);
--r[i];
--c[i];
id[r[i]][c[i]] = i;
}
memset(memo, -1, sizeof memo);
printf("%d\n", M[r[0]][c[0]] + solve(r[0], c[0], (1 << k) - 2));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) sol[i][j] = '.';
search(r[0], c[0], (1 << k) - 2);
for (int i = 0; i < n; ++i) puts(sol[i]);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int long long inline power(int long long a, int long long b, int long long p) {
a %= p;
int long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % p;
a = (a * a) % p;
b >>= 1;
}
return ans;
}
int long long inv(int long long n, int long long p) {
return power(n, p - 2, p);
}
bool inline isPrime(int long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int long long gcd(int long long a, int long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
set<pair<int long long, int long long> > ad;
set<int long long> d;
void dfs(int long long i) {
d.erase(i);
vector<int long long> a;
for (auto x : d) {
if (!ad.count({i, x})) {
a.push_back(x);
}
}
for (i = 0; i < a.size(); i++) {
d.erase(a[i]);
}
for (i = 0; i < a.size(); i++) {
dfs(a[i]);
}
}
void solve() {
int long long n, m, i, j, k, l, r;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> l >> r;
ad.insert({l, r});
ad.insert({r, l});
}
for (i = 1; i <= n; i++) {
d.insert(i);
}
int long long ans = 0;
for (i = 1; i <= n; i++) {
if (!d.count(i)) continue;
ans++;
dfs(i);
}
cout << ans - 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int long long t;
t = 1;
while (t--) solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c, x, y, mn, mx, ans1, ans2;
cin >> a >> b >> c;
x = b * b - 4 * a * c;
x = sqrt(x);
mn = -b - x;
mx = -b + x;
mn = mn / (2 * a);
mx = mx / (2 * a);
ans1 = max(mn, mx);
ans2 = min(mn, mx);
printf("%.6lf\n%.6lf\n", ans1, ans2);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline namespace Infinity {
inline namespace Constant {
constexpr const int eof = EOF;
constexpr const int maxint = INT_MAX;
constexpr const long long maxll = LLONG_MAX;
constexpr const double eps = DBL_EPSILON;
} // namespace Constant
inline namespace TypeDefine {
using uint = unsigned int;
using ll = long long int;
using ull = unsigned long long int;
using ld = long double;
template <typename T = int>
using Pair = pair<T, T>;
template <typename T = int>
using PairList = vector<Pair<T>>;
template <typename T = vector<int>>
using Iter = typename T::iterator;
} // namespace TypeDefine
inline namespace IO {
const char LF = '\n';
const char SP = ' ';
int dbl_prec = 10;
int ldbl_prec = 18;
inline void write(const int n) { printf("%d", n); }
inline void write(const unsigned n) { printf("%u", n); }
inline void write(const long long n) { printf("%lld", n); }
inline void write(const unsigned long long n) { printf("%lld", n); }
inline void write(const int64_t n) { printf("%" PRId64, n); }
inline void write(const uint64_t n) { printf("%" PRIu64, n); }
inline void write(const double a) { printf("%.*f", dbl_prec, a); }
inline void write(const long double a) { printf("%.*Lf", ldbl_prec, a); }
inline void write(const char c) { printf("%c", c); }
inline void write(const char s[]) { printf("%s", s); }
inline void write(const string &s) { printf("%s", s.data()); }
template <typename T>
inline void writeSP(const T a) {
write(a);
write(SP);
}
template <typename T, typename U>
inline void write(const pair<T, U> &p) {
writeSP(p.first);
write(p.second);
}
template <class T>
inline void write(const T a) {
for (auto i = a.begin(); i != a.end(); i++) {
if (i != a.begin()) write(SP);
write(*i);
}
}
template <typename T>
inline void write(initializer_list<T> list) {
for (auto i = list.begin(); i != list.end(); i++) {
if (i != list.begin()) write(SP);
write(*i);
}
}
template <typename T>
inline void writer(T begin, T end) {
for (write(*begin++); begin != end; ++begin) write(SP), write(*begin);
}
inline void writeln() { write(LF); }
inline void writeSP() { write(SP); }
template <typename T>
inline void writeln(const T &a) {
write(a);
write(LF);
}
template <typename T>
inline void writeln(initializer_list<T> list) {
for (auto i = list.begin(); i != list.end(); i++) {
if (i != list.begin()) write(SP);
write(*i);
}
write(LF);
}
template <class T>
inline void writelns(const T &a) {
for (auto n : a) writeln(n);
}
template <typename T, typename... types>
inline void write(const T &a, const types &...args) {
write(a);
write(args...);
}
template <typename... types>
inline void writeln(const types &...args) {
write(args...);
write(LF);
}
template <typename... types>
inline void writeSP(const types &...args) {
write(args...);
write(SP);
}
inline void writelnYN(bool b) { writeln(b ? "YES" : "NO"); }
inline void writelnyn(bool b) { writeln(b ? "Yes" : "No"); }
string caseN(int n, bool sharp = true, bool space = true) {
return string("Case ") + (sharp ? "#" : "") + to_string(n) + ":" +
(space ? " " : "");
}
inline int read(int &n) { return scanf("%d", &n); }
inline int read(int64_t &n) { return scanf("%" SCNd64, &n); }
template <typename T, typename... types>
inline int read(T &n, types &...args) {
return read(n) == eof ? eof : read(args...) + 1;
}
inline char getcc() {
char c;
do c = getchar();
while (isspace(c));
return c;
}
inline int getint() {
int n;
read(n);
return n;
}
inline int64_t getll() {
int64_t n;
read(n);
return n;
}
inline double getdbl() {
double n;
scanf("%lf", &n);
return n;
}
inline pair<int, int> getpair() {
pair<int, int> p;
scanf("%d%d", &p.first, &p.second);
return p;
}
inline vector<int> getints(int n) {
vector<int> v(n);
for (int &i : v) i = getint();
return v;
}
inline vector<pair<int, int>> getpairs(int n) {
vector<pair<int, int>> v(n);
for (pair<int, int> &p : v) {
p = getpair();
}
return v;
}
inline void read(string &str, unsigned size) {
char s[++size];
scanf("%s", s);
str.assign(s);
}
inline string getstr(unsigned size = 0x100000) {
string s;
read(s, size);
return s;
}
inline string getln(unsigned size = 0x100000) {
char s[++size];
scanf("%[^\n]", s);
getchar();
return s;
}
} // namespace IO
inline namespace BattleLab {
class Range {
class RangeIterator {
public:
RangeIterator(int current = 0, int step = 1)
: current(current), step(step) {}
bool operator!=(const RangeIterator &iterator) const {
return current < iterator.current;
}
int operator*() const { return current; }
RangeIterator operator++() { return {current += step, step}; }
protected:
int current, step;
};
public:
Range(int to, int from = 0, int step = 1) : from(from), to(to), step(step) {}
RangeIterator begin() const { return {from, step}; }
RangeIterator end() const { return {to, step}; }
protected:
int from, to, step;
};
Range range(int to) { return {to}; }
Range range(int from, int to) { return {to, from}; }
Range range(int from, int to, int step) { return {to, from, step}; }
} // namespace BattleLab
inline namespace Miscelleneous {
inline constexpr int ctoi(const char c) { return c - '0'; }
inline constexpr char itoc(const int n) { return n + '0'; }
inline int dtoi(const double d) { return round(d); }
template <typename T>
inline constexpr bool in(T x, T l, T r) {
return l <= x && x <= r;
}
template <typename T>
inline constexpr T tristate(int val, T nag, T zero, T pos) {
return val > 0 ? pos : val < 0 ? nag : zero;
}
template <class T>
inline int size(const T &a) {
return a.size();
}
template <class T>
inline void sort(T &a) {
sort(a.begin(), a.end());
}
template <class T1, class T2>
inline void sort(T1 &a, T2 comp) {
sort(a.begin(), a.end(), comp);
}
template <class T1, typename T2>
inline int lbound(const T1 &a, const T2 k) {
return lower_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, typename T2>
inline int ubound(const T1 &a, const T2 k) {
return upper_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, class T2>
inline int count(T1 &a, T2 k) {
return ubound(a, k) - lbound(a, k);
}
template <typename T>
inline void clear(T &a) {
memset(a, 0, sizeof a);
}
template <typename T>
T gcd(T a, T b) {
while (b) {
T t = a % b;
a = b;
b = t;
}
return a;
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long qpow(long long a, long long b, long long c) {
return b ? qpow(a * a % c, b >> 1, c) * (b & 1 ? a : 1) % c : 1;
}
template <typename T>
T exGcd(T a, T b, T &x, T &y) {
T d = a;
if (b) {
d = exGcd(b, a % b, y, x);
y -= a / b * x;
} else {
x = 1;
y = 0;
}
return d;
}
template <typename T>
inline constexpr T mps(T l, T r, T k) {
return ((r - (r % k + k) % k) - (l + (k - l % k) % k)) / k + 1;
}
template <typename T>
inline constexpr T sgn(T a) {
return a ? a > 0 ? 1 : -1 : 0;
}
template <typename T>
inline constexpr T sq(T a) {
return a * a;
}
template <typename T>
inline constexpr bool odd(T a) {
return bool(a % 2);
}
template <typename T>
inline constexpr bool even(T a) {
return !bool(a % 2);
}
template <typename T1, typename T2>
inline constexpr T1 smod(T1 x, T2 m) {
return x > m ? x - m : x + m < m ? x + m : x;
}
vector<int> repetend(vector<int> a) {
vector<int> p(a.size(), -1);
for (unsigned i = 0; i < a.size(); i++)
if (p[i] == -1) {
int c = 1;
for (unsigned j = a[i]; j != i; j = a[j]) ++c;
p[i] = c;
for (unsigned j = a[i]; j != i; j = a[j]) p[j] = c;
}
return p;
}
template <typename T>
inline constexpr T lmiddle(T first, T last) {
return first + (last - first) / 2;
}
template <typename T>
inline constexpr T rmiddle(T first, T last) {
return last - (last - first) / 2;
}
template <typename T, typename F>
T dichotomy(T l, T r, F check, T prec = 1) {
while (r - l > prec) {
T m = lmiddle(l, r);
(check(m) ? l : r) = m;
}
return l;
}
template <typename T, typename F>
T dichotomy2(T l, T r, F check, T prec = 1) {
while (r - l > prec) {
T m = rmiddle(l, r);
(check(m) ? r : l) = m;
}
return r;
}
bool contains(const string &s, const string &t) {
return s.find(t) != string::npos;
}
template <typename T>
bool contains(const T &s, typename T::value_type t) {
for (typename T::value_type c : s)
if (c == t) return true;
return false;
}
template <typename T>
bool contains(const initializer_list<T> s, T t) {
return find(s.begin(), s.end(), t) != s.end();
}
} // namespace Miscelleneous
} // namespace Infinity
class Tree {
public:
Tree(unsigned n) : n(n), adj(n) {}
void addDirected(int u, int v) { adj[u].push_back(v); }
void addUndirected(int u, int v) {
addDirected(u, v);
addDirected(v, u);
}
protected:
int n;
vector<vector<int>> adj;
};
class Centroids : public Tree {
public:
Centroids(unsigned n) : Tree(n), ss(n), sc(n), sp(n) {}
vector<int> solve() {
r.assign(n, 1);
prepare1(0, -1);
prepare2(0, -1);
return r;
}
private:
void update(int &a, int b) {
if (b <= n / 2 && b > a) {
a = b;
}
}
void prepare1(int u, int p) {
ss[u] = 1;
for (int v : adj[u]) {
if (v != p) {
prepare1(v, u);
if (ss[v] - sc[v] > n / 2) {
r[u] = 0;
}
ss[u] += ss[v];
update(sc[u], sc[v]);
update(sc[u], ss[v]);
}
}
update(sc[u], ss[u]);
}
void prepare2(int u, int p) {
update(sp[u], n - ss[u]);
update(sp[u], sp[p]);
if (n - ss[u] - sp[u] > n / 2) {
r[u] = 0;
}
int pm = 0;
for (auto i = adj[u].begin(); i != adj[u].end(); i++) {
int v = *i;
if (v != p) {
update(sp[v], pm);
update(pm, sc[v]);
}
}
pm = 0;
for (auto i = adj[u].rbegin(); i != adj[u].rend(); i++) {
int v = *i;
if (v != p) {
update(sp[v], pm);
update(pm, sc[v]);
prepare2(v, u);
}
}
}
protected:
vector<int> ss, sc, sp, r;
};
int main() {
int n = getint();
Centroids c(n);
for (int i = 0; i < n - 1; i++) {
c.addUndirected(getint() - 1, getint() - 1);
}
writeln(c.solve());
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long sum[100100 << 2][12];
int per[100100 << 2][12];
void up(int o) {
for (int i = 0; i < 10; ++i)
sum[o][i] = sum[(o << 1)][i] + sum[((o << 1) | 1)][i];
}
void build(int o, int l, int r) {
for (int i = 0; i < 10; ++i) per[o][i] = i;
if (l == r) {
int x, y, bas = 1;
scanf("%d", &x);
while (x) {
y = x % 10;
sum[o][y] += bas;
bas *= 10;
x /= 10;
}
return;
}
build((o << 1), l, ((l + r) >> 1));
build(((o << 1) | 1), ((l + r) >> 1) + 1, r);
up(o);
}
long long get_sum(int o) {
long long ans = 0;
for (int i = 0; i < 10; ++i) ans += sum[o][i] * i;
return ans;
}
long long tmp[10];
void deal(int o, int fa) {
memset(tmp, 0, sizeof(tmp));
for (int i = 0; i < 10; ++i) per[o][i] = per[fa][per[o][i]];
for (int i = 0; i < 10; ++i) tmp[per[fa][i]] += sum[o][i];
for (int i = 0; i < 10; ++i) sum[o][i] = tmp[i];
}
void down(int o) {
deal((o << 1), o);
deal(((o << 1) | 1), o);
for (int i = 0; i < 10; ++i) per[o][i] = i;
}
void update(int o, int l, int r, int y1, int y2, int x, int y) {
if (y1 <= l && y2 >= r) {
for (int j = 0; j < 10; ++j)
if (per[o][j] == x) per[o][j] = y;
sum[o][y] += sum[o][x];
sum[o][x] = 0;
return;
}
down(o);
if (y1 <= ((l + r) >> 1)) update((o << 1), l, ((l + r) >> 1), y1, y2, x, y);
if (y2 > ((l + r) >> 1))
update(((o << 1) | 1), ((l + r) >> 1) + 1, r, y1, y2, x, y);
up(o);
}
long long query(int o, int l, int r, int y1, int y2) {
if (y1 <= l && y2 >= r) return get_sum(o);
down(o);
long long ans = 0;
if (y1 <= ((l + r) >> 1)) ans += query((o << 1), l, ((l + r) >> 1), y1, y2);
if (y2 > ((l + r) >> 1))
ans += query(((o << 1) | 1), ((l + r) >> 1) + 1, r, y1, y2);
return ans;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
memset(sum, 0, sizeof(sum));
build(1, 1, n);
int op, l, r, x, y;
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d%d%d", &l, &r, &x, &y);
if (x == y) continue;
update(1, 1, n, l, r, x, y);
} else {
scanf("%d%d", &l, &r);
printf("%I64d\n", query(1, 1, n, l, r));
}
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
bool my_compare(const pair<int, int>& i, const pair<int, int>& j) {
if (i.first > j.first) return false;
if (j.first > i.first) return true;
return j.second > i.second;
}
int check(vector<pair<int, int> > x, vector<pair<int, int> > y, int h) {
vector<int> min;
vector<int> max;
if (y.size() > 0) {
min.push_back(y.front().first + x.front().first + h);
max.push_back(y.back().first + x.back().first + h);
}
if (y.size() > 1) {
min.push_back(y[0].first + y[1].first);
max.push_back(y[y.size() - 1].first + y[y.size() - 2].first);
}
min.push_back(x[0].first + x[1].first);
max.push_back(x[x.size() - 1].first + x[x.size() - 2].first);
sort(min.begin(), min.end());
sort(max.begin(), max.end());
return max.back() - min.front();
}
int main() {
int n, h;
cin >> n >> h;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; ++i) {
cin >> a.at(i).first;
a.at(i).second = i;
}
vector<pair<int, int> > b = a;
sort(a.begin(), a.end(), my_compare);
vector<pair<int, int> > x;
x.assign(a.begin(), a.end());
vector<pair<int, int> > y;
int df1 = check(x, y, h);
x.assign(++a.begin(), a.end());
y.push_back(a[0]);
int df2 = check(x, y, h);
cout << min(df1, df2) << endl;
for (int i = 0; i < n; ++i) {
if (b[i].second == a[0].second && df2 < df1)
cout << 1 << " ";
else
cout << 2 << " ";
}
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
set<pair<int, pair<int, bool> > > eaten;
set<pair<int, pair<int, bool> > >::iterator it;
int x, y, ans;
char d;
bool dr;
eaten.insert(make_pair(0, make_pair(n, 1)));
eaten.insert(make_pair(n + 1, make_pair(n, 0)));
map<int, bool> mark;
while (m--) {
cin >> x >> y >> d;
if (mark[x]) {
cout << 0 << '\n';
continue;
}
it = eaten.lower_bound(make_pair(x, make_pair(0, 0)));
if (d == 'U') {
if (it->second.second)
ans = it->second.first + it->first - x;
else
ans = it->first - x;
dr = 1;
} else {
it--;
if (it->second.second)
ans = x - it->first;
else
ans = it->second.first + x - it->first;
dr = 0;
}
mark[x] = 1;
cout << ans << '\n';
eaten.insert(make_pair(x, make_pair(ans, dr)));
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
int best = -1;
int idx, op1, op2;
for (int i = 0; i < 4; i++) {
int v1, v2, v3, v4;
cin >> v1 >> v2 >> v3 >> v4;
int temp = min(v1, v2) + min(v3, v4);
if (temp > n) continue;
if (best == -1 || temp < best) {
best = temp;
idx = i + 1;
op1 = min(v1, v2);
op2 = min(v3, v4);
}
}
if (best == -1)
cout << best << '\n';
else {
int left = n - op1 - op2;
op1 += left;
cout << idx << ' ' << op1 << ' ' << op2;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace Stand_IO_Operation {
inline int read() {
int f = 1, res = 0, ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') res = res * 10 + ch - 48, ch = getchar();
return f * res;
}
int _sta[1 << 8];
inline void write(int val) {
if (!val) {
putchar('0');
return;
}
if (val < 0) putchar('-'), val = -val;
*_sta = 0;
while (val > 0) _sta[++*_sta] = val % 10, val /= 10;
for (int i = *_sta, _Lim = 1; i >= _Lim; i--) putchar(_sta[i] + 48);
}
}; // namespace Stand_IO_Operation
using namespace Stand_IO_Operation;
const int N = 16;
const int M = 65540;
const int T = 130;
const int INF = 0x7fffffff;
int n, r[N], b[N], f[T][M], A[M], B[M], pos[M];
int sumb, sumr, ans;
bool bf[N];
int main() {
n = read();
for (int i = 0; i < n; i++) {
char ch = getchar();
pos[1 << i] = i;
if (ch == 'R')
bf[i] = 1;
else
bf[i] = 0;
r[i] = read();
b[i] = read();
sumb += b[i];
sumr += r[i];
}
ans = ((sumb) > (sumr) ? (sumb) : (sumr)) + n;
for (int i = 1; i < (1 << n); i++) {
A[i] = A[i - ((i) & (-i))] + bf[pos[((i) & (-i))]];
B[i] = B[i - ((i) & (-i))] + (1 - bf[pos[((i) & (-i))]]);
}
for (int i = 1; i <= 120; i++)
for (int S = 0; S < (1 << n); S++) f[i][S] = -INF;
for (int S = 0; S < (1 << n); S++) {
for (int i = 0; i < n; i++)
if (!(S & (1 << i))) {
int nxt = S | (1 << i);
int DA = max(r[i] - A[S], 0);
int DB = max(b[i] - B[S], 0);
for (int j = 120; j >= r[i] - DA; j--)
f[j][nxt] = ((f[j][nxt]) > (f[j - r[i] + DA][S] + b[i] - DB)
? (f[j][nxt])
: (f[j - r[i] + DA][S] + b[i] - DB));
}
}
for (int i = 0; i <= 120; i++) {
int j = f[i][(1 << n) - 1];
if (j < 0) continue;
ans = ((ans) < (((sumb - j) > (sumr - i) ? (sumb - j) : (sumr - i)) + n)
? (ans)
: (((sumb - j) > (sumr - i) ? (sumb - j) : (sumr - i)) + n));
}
write(ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[15], i;
int k;
cin >> s;
cin >> k;
int n = strlen(s), r = 0, count = 0;
for (i = n - 1; i >= 0; i--) {
if (s[i] == '0') count++;
if (k == count) {
r = 1;
break;
}
}
if (r == 1) {
cout << n - i - k;
return 0;
}
cout << n - 1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, x2, y2, x3, y3, x4, y4;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2)
x3 = x4 = x1 + (y2 - y1), y3 = y1, y4 = y2;
else if (y1 == y2)
y3 = y4 = y1 + (x2 - x1), x3 = x1, x4 = x2;
else if (fabs((float)(y2 - y1) / (x2 - x1)) != 1) {
cout << -1;
return 0;
} else
x3 = x1, y3 = y2, x4 = x2, y4 = y1;
cout << x3 << " " << y3 << " " << x4 << " " << y4;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char tramp;
string f, s;
cin >> tramp >> f >> s;
map<char, int> rank;
rank['6'] = 1;
rank['7'] = 2;
rank['8'] = 3;
rank['9'] = 4;
rank['T'] = 5;
rank['J'] = 6;
rank['Q'] = 7;
rank['K'] = 8;
rank['A'] = 9;
if (f[1] == tramp and s[1] != tramp) {
cout << "YES";
return 0;
} else if (f[1] == tramp and s[1] == tramp) {
if (rank[f[0]] > rank[s[0]])
cout << "YES";
else
cout << "NO";
return 0;
} else if (f[1] != tramp and s[1] == tramp) {
cout << "NO";
return 0;
} else if (f[1] != tramp and s[1] != tramp) {
if (f[1] == s[1] and rank[f[0]] > rank[s[0]])
cout << "YES";
else
cout << "NO";
return 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m;
int main() {
cin >> n;
for (int i = sqrt(n);; i--) {
if (n % i == 0) {
cout << i << ' ' << n / i << endl;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, M = 1e6 + 5, C = 1e3 + 5, MOD = 1e9 + 7, OO = 1e9 + 5;
int fre[N][30];
int main() {
cin.sync_with_stdio(false), cin.tie(0), cout.tie(0);
string str;
cin >> str;
int q;
cin >> q;
int n = str.size();
for (int i = 0; i < n; ++i) {
if (i)
for (int j = 0; j < 26; ++j) {
if (j + 'a' == str[i]) {
fre[i][j] = fre[i - 1][j] + 1;
} else {
fre[i][j] = fre[i - 1][j];
}
}
else
fre[i][str[i] - 'a']++;
}
for (int i = 0; i < q; ++i) {
int l, r;
cin >> l >> r;
l--;
r--;
int chrs = 0;
for (int j = 0; j < 26; ++j) {
int f = fre[r][j];
if (l) f -= fre[l - 1][j];
if (f) chrs++;
}
if (chrs > 2 || l - r == 0 || (chrs == 2 && str[l] != str[r])) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
void PV(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
void PA(long long v[], long long n) {
for (long long i = 0; i < n; i++) cout << v[i] << " ";
cout << "\n";
}
void IN(long long a[], long long n) {
for (long long i = 0; i < n; i++) cin >> a[i];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
long long k;
cin >> k;
long long i, j, l, u = 1;
j = 1;
l = 9;
long long kk = k;
while (k - l > 0 && kk - l > 0) {
u++;
kk = kk - l;
j = j * 10;
l = j * 9 * u;
}
l = kk % u;
kk = ceil((long double)kk / u);
kk = j + kk - 1;
string ans = to_string(kk);
if (l == 0)
cout << ans[u - 1] << "\n";
else
cout << ans[l - 1] << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
map<int, long long> cnt;
for (int i = 0, x; i < n; i++) {
cin >> x;
cnt[(i) % 2] += (x) / 2;
cnt[(i + 1) % 2] += (x + 1) / 2;
}
cout << min(cnt[0], cnt[1]);
return (0);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long powm(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) {
r *= a;
r %= mod;
}
b >>= 1;
a *= a;
a %= mod;
}
return r;
}
long long gcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
int main() {
string s;
cin >> s;
long long ns = s.size();
long long k;
cin >> k;
k--;
long long ans = 0;
long long c = powm(2, ns);
long long sum = (powm(c, k + 1) - 1 + mod) % mod;
long long x, y;
long long a = (c - 1 + mod) % mod;
long long g = gcd(a, mod, x, y);
x = (x % mod + mod) % mod;
sum *= x;
sum %= mod;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '0' || s[i] == '5') {
ans += sum * 1ll * powm(2ll, i);
ans %= mod;
}
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
string s;
int l, r, i, z[100005], sum[100005];
vector<int> ans;
int main() {
cin >> s;
l = 0;
r = 0;
for (i = 1; i < s.size(); i++) {
if (r >= i) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < s.size() && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
z[0] = s.size();
for (i = 0; i < s.size(); i++) sum[z[i]]++;
for (i = s.size() - 1; i >= 0; i--) sum[i] += sum[i + 1];
for (i = s.size() - 1; i >= 0; i--) {
if (i + z[i] == s.size()) {
ans.push_back(z[i]);
ans.push_back(sum[z[i]]);
}
}
cout << ans.size() / 2 << "\n";
for (i = 0; i < ans.size(); i += 2)
cout << ans[i] << " " << ans[i + 1] << "\n";
return 0;
}
| 12 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5+5;
const int SQRTN = 450;
int n,x;
int p[N],d[N],id[N],val[N];
vector<int> g[N],posd[N],w[N];
bool f[SQRTN][N];
int k[SQRTN][N];
bool ans[N];
void dfs(int x){
posd[d[x]].push_back(x);
for(int i=0;i<g[x].size();++i){
int y=g[x][i];
d[y]=d[x]+1;
dfs(y);
}
}
bool cmp(int x,int y){
return posd[x].size()<posd[y].size();
}
int main(){
scanf("%d%d",&n,&x);
for(int i=2;i<=n;++i){
scanf("%d",&p[i]);
g[p[i]].push_back(i);
}
d[1]=1;
dfs(1);
int cntd=*max_element(d+1,d+n+1);
for(int i=1;i<=cntd;++i)id[i]=i;
sort(id+1,id+cntd+1,cmp);
int tot=0;
for(int i=1,r=1;i<=cntd;i=++r){
++tot;
val[tot]=posd[id[i]].size();
w[tot].push_back(id[i]);
while(r+1<cntd&&posd[id[r+1]].size()==posd[id[i]].size()){
w[tot].push_back(id[r+1]);
++r;
}
}
static int q[N];
f[0][0]=1;
for(int i=1;i<=tot;++i)
for(int j=0;j<=x;++j){
if(f[i-1][j])k[i][j]=0;
else if(j>=val[i])k[i][j]=k[i][j-val[i]]+1;
else k[i][j]=0;
if(k[i][j]<=w[i].size())f[i][j]=f[i-1][j-k[i][j]*val[i]];
else f[i][j]=0;
}
if(f[tot][x]){
for(int i=tot;i>=1;--i){
int c=k[i][x];
x-=c*val[i];
for(int j=0;j<c;++j){
int d=w[i][j];
for(int t=0;t<posd[d].size();++t){
ans[posd[d][t]]=1;
}
}
}
printf("%d\n",cntd);
for(int i=1;i<=n;++i){
if(ans[i])putchar('a');
else putchar('b');
}
printf("\n");
return 0;
}
int a=x,b=n-x;
for(int i=1;i<=cntd;++i){
if(posd[i].size()<=a){
for(int j=0;j<posd[i].size();++j){
ans[posd[i][j]]=1;
}
a-=posd[i].size();
}
else if(posd[i].size()<=b){
b-=posd[i].size();
}
else{
static int q1[N],q2[N];
for(int j=0;j<posd[i].size();++j){
int x=posd[i][j];
if(!g[x].size())q2[++q2[0]]=x;
else q1[++q1[0]]=x;
}
if(a>b){
for(int i=1;i<=q1[0];++i){
ans[q1[i]]=1;
}
a-=q1[0];
for(int i=1;i<=q2[0];++i){
if(a){
ans[q2[i]]=1;
--a;
}
else{
--b;
}
}
}
else{
b-=q1[0];
for(int i=1;i<=q2[0];++i){
if(b){
--b;
}
else{
ans[q2[i]]=1;
--a;
}
}
}
}
}
printf("%d\n",cntd+1);
for(int i=1;i<=n;++i){
if(ans[i])putchar('a');
else putchar('b');
}
printf("\n");
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int maxi = 0, som = 0, n;
cin >> n;
int t[n + 1];
t[0] = 0;
int pos_i, pos_f, max_pos;
for (int i = 1; i <= n; i++) {
cin >> t[i];
t[i] += t[i - 1];
}
for (pos_f = n; pos_f > 0; pos_f--) {
for (pos_i = 0; pos_i + pos_f <= n; pos_i++) {
if (t[pos_i + pos_f] - t[pos_i] > 100 * pos_f) {
cout << pos_f << endl;
return 0;
}
}
}
cout << "0" << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int formNumber, i, sum = 0;
cin >> formNumber;
int form[formNumber];
for (int i = 0; i < formNumber; i++) cin >> form[i];
for (i = 0; i < formNumber; i++) {
for (int k = 0; k < formNumber; k++) {
if (i == k) continue;
sum = form[i] + form[k];
for (int j = 0; j < formNumber; j++) {
if (i == j || j == k) continue;
if (sum == form[j]) {
cout << j + 1 << " " << i + 1 << " " << k + 1;
sum = -1;
break;
}
}
if (sum == -1) break;
}
if (sum == -1) break;
}
if (i == formNumber) cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int>> nodeSet;
set<pair<int, int>> alreadyTaken;
queue<pair<int, int>> que;
queue<int> dist;
int x[] = {1, 1, 1, 0, 0, -1, -1, -1};
int y[] = {-1, 0, 1, -1, 1, -1, 0, 1};
pair<int, int> currentNode;
pair<int, int> node;
int currentDistance;
int BFS(pair<int, int> start, pair<int, int> end) {
que.push(start);
dist.push(0);
alreadyTaken.insert(start);
while (!que.empty()) {
currentNode = que.front();
que.pop();
currentDistance = dist.front(), dist.pop();
if (currentNode == end) {
return currentDistance;
}
for (int i = 0; i < 8; i++) {
node.first = currentNode.first + x[i];
node.second = currentNode.second + y[i];
if ((nodeSet.find(node) != nodeSet.end()) &&
(alreadyTaken.find(node) == alreadyTaken.end())) {
alreadyTaken.insert(node);
que.push(node);
dist.push(currentDistance + 1);
}
}
}
return -1;
}
int main() {
pair<int, int> start, end;
pair<int, int> node;
int row, f, e, n;
cin >> start.first >> start.second >> end.first >> end.second;
cin >> n;
while (n--) {
cin >> row >> f >> e;
node.first = row;
for (int j = f; j <= e; j++) {
node.second = j;
if (nodeSet.find(node) == nodeSet.end()) nodeSet.insert(node);
}
}
cout << BFS(start, end) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 2e6 + 5, OO = 0x3f3f3f3f;
const double EPS = 0.0000001, PI = 2 * acos(0.0);
long long n, a, d, t, v;
double last = 0, ans;
int main() {
cin.sync_with_stdio(0);
cin >> n >> a >> d;
while (n--) {
cin >> t >> v;
if (v * v / (2.0 * a) > d) {
ans = 1.0 * t + sqrt(2.0 * d / a);
} else {
ans = t + (v * v + 2.0 * a * d) / (2.0 * a * v);
}
ans = max(ans, last);
last = ans;
printf("%.5f\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int m, n, f1[200005], f2[200005], S[200005], T[21][1048600], Max;
char str[200005][25];
int get(int A, int B) {
int T1 = str[A][1] - '0', T2 = str[B][m] - '0', x = 1, s = 0;
while (x <= m) {
if (T1 == T2) s = x;
x++;
T1 = (T1 << 1) + str[A][x] - '0';
T2 = T2 + ((str[B][m - x + 1] - '0') << (x - 1));
}
return s;
}
void work_f2(int i) {
int Ti = 0, x = 0;
f2[i] = S[1] - S[i];
while (x <= m) {
f2[i] = max(f2[i], T[x][Ti] - S[i] + x);
x++;
Ti = (Ti << 1) + str[i + 1][x] - '0';
}
Ti = 0;
x = 0;
while (x <= m) {
T[x][Ti] = max(T[x][Ti], f2[i] + S[i + 1]);
x++;
Ti = Ti + ((str[i][m - x + 1] - '0') << (x - 1));
}
Max = max(Max, f2[i] + S[i + 1]);
}
int main() {
scanf("%d\n", &n);
memset(T, 128, sizeof(T));
for (int i = 1; i <= n; i++) gets(str[i] + 1);
m = strlen(str[1] + 1);
for (int i = n - 1; i >= 1; i--) S[i] = S[i + 1] + get(i + 1, i);
for (int i = 2; i <= n; i++) {
work_f2(i - 1);
f1[i] = max(Max - S[i], f1[i - 1] + S[i - 1] - S[i]);
}
cout << n * m - f1[n] << endl;
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int a[12];
int b[12];
int main() {
int n, m, d, e, ii, jj, i, j;
scanf("%d %d", &n, &m);
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (i = 0; i < n; i++) {
scanf("%d", &d);
a[d] = 1;
}
for (i = 0; i < m; i++) {
scanf("%d", &e);
b[e] = 1;
}
for (i = 1; i < 10; i++) {
if (a[i] && b[i]) {
printf("%d\n", i);
return 0;
}
}
for (i = 1; i < 10; i++) {
if (a[i]) {
ii = i;
break;
}
}
for (i = 1; i < 10; i++) {
if (b[i]) {
jj = i;
break;
}
}
if (ii < jj) {
printf("%d%d\n", ii, jj);
return 0;
} else {
printf("%d%d\n", jj, ii);
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s += '+';
long long ans = 0, cur = 0;
int sign = +1;
for (char c : s) {
if (c == '+' || c == '-') {
ans += sign * cur;
cur = 0;
c == '+' ? sign = +1 : sign = -1;
}
cur = cur * 10 + (c - '0');
}
cout << ans << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, maxa;
int main() {
scanf("%d", &n);
while (n--) {
int a;
scanf("%d", &a);
maxa = max(maxa, a);
}
printf("%d", max(maxa - 25, 0));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i];
}
long long ans = 0;
for (int i = 0; i < n; i += 2) {
long long l = 1, r = c[i];
for (int j = i + 1; j < n; j++) {
if (j % 2 == 1) {
ans += max(0LL, min(r, c[j]) - l + 1);
l = max(l - c[j], 0LL);
r -= c[j];
} else {
l += c[j];
r += c[j];
}
}
}
cout << ans << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 5010, M = 0, Z = 1e9 + 7, inf = 0x3f3f3f3f;
template <class T1, class T2>
inline void gadd(T1 &a, T2 b) {
a = (a + b) % Z;
}
int casenum, casei;
int n, m;
char a[N][12], b[N][12], val[N][N], op[N][10], V[N][N];
map<string, int> mop;
char ans1[N], ans2[N];
int oa[N], oval[N], ob[N];
int check(int p, int v) {
int ret = 0;
for (int i = 1; i <= n; ++i) {
if (isdigit(val[i][0])) {
ret += val[i][p] - '0';
} else {
int va, vb;
if (val[i][0] == '?')
va = v;
else
va = V[oval[i]][p] - 48;
if (b[i][0] == '?')
vb = v;
else
vb = V[ob[i]][p] - 48;
int now;
if (op[i][0] == 'A')
now = (va & vb);
else if (op[i][0] == 'O')
now = (va | vb);
else
now = (va ^ vb);
V[i][p] = now + '0';
ret += now;
}
}
return ret;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; ++i) {
scanf("%s%*s%s", a[i], val[i]);
if (!isdigit(val[i][0])) {
scanf("%s%s", op[i], b[i]);
if (val[i][0] != '?') oval[i] = mop[val[i]];
if (b[i][0] != '?') ob[i] = mop[b[i]];
} else {
oa[i] = i;
memcpy(V[i], val[i], sizeof(V[i]));
}
mop[a[i]] = i;
}
for (int i = 0; i < m; ++i) {
int v1 = check(i, 0);
int v2 = check(i, 1);
if (v1 <= v2)
ans1[i] = '0';
else
ans1[i] = '1';
if (v1 >= v2)
ans2[i] = '0';
else
ans2[i] = '1';
}
printf("%s %s\n", ans1, ans2);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 2;
vector<int> g[maxn];
vector<long long> c[maxn], acum[maxn];
int n, m, q, idx, comp[maxn];
long long d[maxn], dist[maxn];
map<pair<int, int>, long long> memo;
vector<int> cur;
void dfs(int node, int par) {
comp[node] = idx;
cur.push_back(node);
for (auto &adj : g[node])
if (adj != par) dfs(adj, node);
}
pair<int, long long> bfs(int node) {
queue<int> Q;
for (auto &v : cur) dist[v] = -1;
dist[node] = 0;
Q.push(node);
int last = -1;
while (!Q.empty()) {
node = Q.front();
Q.pop();
last = node;
for (auto &adj : g[node]) {
if (dist[adj] == -1) {
dist[adj] = dist[node] + 1;
Q.push(adj);
}
}
}
return {last, dist[last]};
}
void diameter(int node) {
auto a = bfs(node);
auto b = bfs(a.first);
d[idx] = b.second;
for (int i = 0; i < (int)cur.size(); i++) c[idx][i] = dist[cur[i]];
bfs(b.first);
for (int i = 0; i < (int)cur.size(); i++)
c[idx][i] = max(c[idx][i], dist[cur[i]]);
sort(c[idx].begin(), c[idx].end());
acum[idx][0] = c[idx][0];
for (int i = 1; i < (int)cur.size(); i++)
acum[idx][i] = acum[idx][i - 1] + c[idx][i];
}
void process(int node) {
idx++;
cur.clear();
dfs(node, 0);
c[idx].resize(cur.size());
acum[idx].resize(cur.size());
diameter(cur[0]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(10) << fixed;
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (comp[i] == 0) process(i);
while (q--) {
int x, y;
cin >> x >> y;
x = comp[x];
y = comp[y];
if (x == y) {
cout << -1 << '\n';
continue;
}
if ((long long)c[x].size() > (long long)c[y].size()) swap(x, y);
long long N = (long long)c[x].size(), M = (long long)c[y].size();
if (memo.find({x, y}) != memo.end()) {
cout << (1.0 * memo[pair<int, int>(x, y)]) / (1.0 * N * M) << '\n';
continue;
}
long long ans = 0;
long long mx = max(d[x], d[y]);
for (auto &v : c[x]) {
long long lo = 0, hi = M - 1LL;
long long pos = -1;
while (lo <= hi) {
long long mid = (lo + hi) >> 1LL;
if (v + c[y][mid] + 1 <= mx) {
pos = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
if (pos == -1) {
ans += acum[y][M - 1] + M * (v + 1);
} else {
ans += (pos + 1) * mx;
ans += acum[y][M - 1] - acum[y][pos] + (v + 1) * (M - pos - 1);
}
}
memo[pair<int, int>(x, y)] = ans;
memo[pair<int, int>(y, x)] = ans;
cout << (1.0 * ans) / (1.0 * N * M) << '\n';
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 15;
long long L[N], odd[N], R[N];
int ar[N];
int main() {
int pos = 1;
int n;
cin >> n;
long long ret = 0;
for (int i = 1; i < n; ++i) {
scanf("%d", &ar[i]);
ret = max(ret, (long long)ar[i]);
}
L[1] = 0;
for (int i = 2; i <= n; ++i) {
if (ar[i - 1] == 1)
L[i] = 0;
else {
L[i] = L[i - 1] + (ar[i - 1] / 2) * 2;
}
ret = max(ret, L[i]);
}
R[n] = 0;
for (int i = n - 1; i >= 1; --i) {
if (ar[i] == 1)
R[i] = 0;
else {
R[i] = R[i + 1] + (ar[i] / 2) * 2;
}
ret = max(ret, R[i]);
}
priority_queue<long long> pq;
pq.push(0);
for (int i = 2; i <= n; ++i) {
odd[i] = odd[i - 1] + 1 + ((ar[i - 1] - 1) / 2) * 2;
ret = max(ret, odd[i] + R[i] + pq.top());
pq.push(-odd[i] + L[i]);
}
cout << ret << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
string keyboard1, keyboard2, s1;
pair<char, char> translate[26];
int main() {
cin >> keyboard1 >> keyboard2 >> s1;
n = s1.size();
for (int i = 0; i < 26; i++) {
translate[i].first = char(keyboard1[i]);
translate[i].second = char(keyboard2[i]);
}
for (int i = 0; i < 26; i++)
cerr << translate[i].first << " " << translate[i].second << " ";
for (int i = 0; i < n; i++) {
if (s1[i] >= '0' && s1[i] <= '9') cout << s1[i];
for (int j = 0; j < 26; j++)
if (translate[j].first == s1[i] && s1[i] >= 'a') {
cout << char(translate[j].second);
break;
} else if (translate[j].first == tolower(s1[i])) {
cout << char(toupper(translate[j].second));
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int l, r, u, d;
int main() {
cin >> n;
int c1 = 0, c2 = 0, c3 = 0;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
if (s == "UL" || s == "DR")
++c1;
else if (s == "UR" || s == "DL")
++c2;
else
++c3;
}
cout << (long long)(1 + c1 + c3) * (1 + c2 + c3) << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char c[505];
int a[505][505], f[250005], g[250005], h[250005], s;
bool v[505][505];
int find(int x) {
if (f[x] == x)
return x;
else
return f[x] = find(f[x]);
}
void merge(int x) {
x = find(x);
if (!g[x]) s += h[x];
g[x]++;
}
void del(int x) {
x = find(x);
g[x]--;
if (!g[x]) s -= h[x];
}
int main() {
int n, k, i, j, l, p, u, z, ans = 0;
scanf("%d%d", &n, &k);
memset(v, 1, sizeof(v));
for (i = 1; i <= n; i++) {
scanf("%s", c + 1);
for (j = 1; j <= n; j++) {
a[i][j] = (i - 1) * n + j;
if (c[j] == '.') {
v[i][j] = false;
f[a[i][j]] = a[i][j];
h[a[i][j]] = 1;
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j < n; j++) {
if (!v[i][j] && !v[i][j + 1]) {
u = find(a[i][j]);
z = find(a[i][j + 1]);
if (u != z) {
f[u] = z;
h[z] += h[u];
}
}
}
}
for (i = 1; i < n; i++) {
for (j = 1; j <= n; j++) {
if (!v[i][j] && !v[i + 1][j]) {
u = find(a[i][j]);
z = find(a[i + 1][j]);
if (u != z) {
f[u] = z;
h[z] += h[u];
}
}
}
}
for (l = 1; l <= n - k + 1; l++) {
memset(g, 0, sizeof(g));
s = 0;
for (i = l; i <= l + k - 1; i++) {
for (j = 1; j <= k; j++) {
if (v[i][j])
s++;
else
merge(a[i][j]);
}
}
for (i = 1; i <= k; i++) {
if (!v[l - 1][i]) merge(a[l - 1][i]);
if (!v[l + k][i]) merge(a[l + k][i]);
if (!v[l + i - 1][0]) merge(a[l + i - 1][0]);
if (!v[l + i - 1][k + 1]) merge(a[l + i - 1][k + 1]);
}
ans = max(ans, s);
for (p = 2; p <= n - k + 1; p++) {
for (i = 1; i <= k; i++) {
if (!v[l + i - 1][p - 2]) del(a[l + i - 1][p - 2]);
if (v[l + i - 1][p - 1]) s--;
if (v[l + i - 1][p + k - 1]) s++;
if (!v[l + i - 1][p + k]) merge(a[l + i - 1][p + k]);
}
if (!v[l - 1][p - 1]) del(a[l - 1][p - 1]);
if (!v[l + k][p - 1]) del(a[l + k][p - 1]);
if (!v[l - 1][p + k - 1]) merge(a[l - 1][p + k - 1]);
if (!v[l + k][p + k - 1]) merge(a[l + k][p + k - 1]);
ans = max(ans, s);
}
}
printf("%d\n", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
double A, B, X, sum, k;
int a[100001], n;
int main() {
cin >> n >> A >> B;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
X = a[1];
sort(a + 2, a + n + 1);
if (A * (X / sum) >= B) {
cout << 0;
return 0;
}
for (int i = n; i >= 2; i--) {
sum -= a[i];
if (A * (X / sum) >= B) {
cout << n - i + 1;
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> d, d1;
map<string, int>::iterator i1;
int a, s, f, g[10005], h, j, k, l, c, v, b, n, mx = 0, q, w, e, r, t, y, u, i,
o, p;
string x[10005], z;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> z >> k;
x[i] = z;
g[i] = k;
d[z] += k;
}
for (i1 = d.begin(); i1 != d.end(); i1++) {
mx = max(mx, i1->second);
}
for (i = 0; i < n; i++) {
d1[x[i]] += g[i];
if (d1[x[i]] >= mx && d[x[i]] == mx) {
cout << x[i];
return 0;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long INF = (1e9);
char str[(3000 + 4)];
vector<vector<int>> f;
int main() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", str + 1);
int mx = 0;
while (1) {
vector<int> t;
for (int i = 1; i < n; i++) {
if (str[i] == 'R' && str[i + 1] == 'L') {
t.push_back(i);
swap(str[i], str[i + 1]);
i++;
}
}
if (t.empty()) break;
mx += t.size();
f.push_back(t);
}
if (k >= f.size() && k <= mx) {
int cnt = k - f.size();
for (auto t : f) {
while (t.size() > 1 && cnt) {
printf("1 %d\n", t.back());
t.pop_back();
cnt--;
}
printf("%d", t.size());
for (int i = 0; i < t.size(); i++) printf(" %d", t[i]);
printf("\n");
}
} else {
printf("-1\n");
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie();
string S;
cin >> S;
long long a = 0, b = 0, c = 0;
for (int i = 0; i < (int)S.size(); i++)
if (S[i] == 'o')
b += a;
else if (i > 0 && S[i - 1] == 'v') {
a++;
c += b;
}
cout << c << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m;
double l, v1, v2, l1;
cin >> n >> l >> v1 >> v2 >> k;
m = (n - 1) / k;
l1 = (v1 + v2) * l / ((2. * m + 1.) * v1 + v2);
printf("%.8f", (l1 / v2 + (l - l1) / v1));
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int u, v, val, id, dep;
node() {}
node(int u1, int v1, int val1, int id1) : u(u1), v(v1), val(val1), id(id1) {}
bool operator<(const node &a) const {
if (val != a.val) return val < a.val;
return dep > a.dep;
}
} l[100010];
long long ans[100010], sum[100010];
int fa[100010];
int dep[100010];
vector<int> pri;
int get_fa(int x) {
if (fa[x] == 0) return x;
fa[x] = get_fa(fa[x]);
return fa[x];
}
void Union_set(int x, int y) {
int fx = get_fa(x);
int fy = get_fa(y);
if (dep[fx] < dep[fy]) swap(fx, fy);
fa[fx] = fy;
sum[fy] += sum[fx];
}
vector<int> a[100010];
void dfs(int x, int f) {
dep[x] = dep[f] + 1;
for (int i = 0; i < a[x].size(); i++) {
if (a[x][i] == f) continue;
dfs(a[x][i], x);
}
}
int main() {
int n;
scanf("%d", &n);
int u, v, val;
for (int i = 1; i <= n; i++) sum[i] = 1;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &u, &v, &val);
a[u].push_back(v);
a[v].push_back(u);
l[i] = node(u, v, val, i);
}
dfs(1, 0);
for (int i = 1; i < n; i++) {
if (dep[l[i].u] > dep[l[i].v]) swap(l[i].u, l[i].v);
l[i].dep = dep[l[i].u];
}
sort(l + 1, l + n);
int las = 1;
for (int i = 1; i < n; i++) {
l[i].u = get_fa(l[i].u);
l[i].v = get_fa(l[i].v);
if (l[i].val != l[i + 1].val) {
for (int k = las; k <= i; k++) Union_set(l[k].u, l[k].v);
for (; las <= i; las++) {
int x = get_fa(l[las].u);
ans[l[las].id] = (sum[x] - sum[l[las].v]) * (sum[l[las].v]) * 2;
}
}
}
long long maxv = 0;
for (int i = 1; i < n; i++) maxv = max(maxv, ans[i]);
for (int i = 1; i < n; i++)
if (ans[i] == maxv) pri.push_back(i);
printf("%I64d %d\n", maxv, pri.size());
for (int i = 0; i < pri.size(); i++) printf("%d ", pri[i]);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class Iterable,
class = typename enable_if<!is_same<string, Iterable>::value>::type>
auto operator<<(ostream &os, Iterable v) -> decltype(os << *begin(v)) {
os << "[";
for (auto vv : v) os << vv << ", ";
return os << "]";
}
const int inf = 0x3f3f3f3f;
const long long infll = 0x3f3f3f3f3f3f3f3fll;
template <class T>
int sign(T x) {
return (x > 0) - (x < 0);
}
template <class T>
T abs(const T &x) {
return (x < T(0)) ? -x : x;
}
const long long mod = (119 << 23) + 1, root = 62;
long long modpow(long long b, long long e) {
long long ans = 1;
for (; e; b = b * b % mod, e /= 2)
if (e & 1) ans = ans * b % mod;
return ans;
}
void ntt(vector<long long> &a, vector<long long> &rt, vector<long long> &rev,
int n) {
for (int i = 0; i < n; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int k = 1; k < n; k *= 2)
for (int i = 0; i < n; i += 2 * k)
for (int j = 0; j < k; j++) {
long long z = rt[j + k] * a[i + j + k] % mod, &ai = a[i + j];
a[i + j + k] = (z > ai ? ai - z + mod : ai - z);
ai += (ai + z >= mod ? z - mod : z);
}
}
vector<long long> conv(const vector<long long> &a, const vector<long long> &b) {
if (a.empty() || b.empty()) return {};
int s = ((int)(a).size()) + ((int)(b).size()) - 1, B = 32 - __builtin_clz(s),
n = 1 << B;
vector<long long> L(a), R(b), out(n), rt(n, 1), rev(n);
L.resize(n), R.resize(n);
for (int i = 0; i < n; i++) rev[i] = (rev[i / 2] | (i & 1) << B) / 2;
long long curL = mod / 2, inv = modpow(n, mod - 2);
for (int k = 2; k < n; k *= 2) {
long long z[] = {1, modpow(root, curL /= 2)};
for (int i = k; i < 2 * k; i++) rt[i] = rt[i / 2] * z[i & 1] % mod;
}
ntt(L, rt, rev, n);
ntt(R, rt, rev, n);
for (int i = 0; i < n; i++) out[-i & (n - 1)] = L[i] * R[i] % mod * inv % mod;
ntt(out, rt, rev, n);
return {out.begin(), out.begin() + s};
}
struct term {
vector<long long> p;
bool operator<(const term &rhs) const { return p.size() < rhs.p.size(); }
};
vector<long long> productory(vector<vector<long long>> polys) {
multiset<term> s;
for (auto &p : polys) s.insert({p});
while (s.size() > 1) {
auto it = s.begin();
vector<long long> a = it->p;
it = s.erase(it);
vector<long long> b = it->p;
s.erase(it);
vector<long long> prod = conv(a, b);
while (prod.back() == 0) prod.pop_back();
s.insert({prod});
}
return s.begin()->p;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n, p;
cin >> n;
map<int, int> rdm;
for (int i = 0; i < n; i++) {
cin >> p;
rdm[p]++;
}
vector<vector<long long>> polys;
for (auto x : rdm) {
vector<long long> tmp(x.second + 1, 1);
polys.push_back(tmp);
}
vector<long long> res = productory(polys);
cout << res[n / 2] << endl;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long POW(long long A, long long N, long long MOD) {
if (N == 0) return 1 % MOD;
if (N == 1) return A % MOD;
long long tmp = POW(A, N / 2, MOD) % MOD;
if (N % 2)
return ((tmp * tmp) % MOD * A % MOD) % MOD;
else
return (tmp * tmp) % MOD;
}
long long MUL(long long A, long long B, long long MOD) {
long long r = 0;
while (B) {
r = (r + (A * (B % 2) % MOD)) % MOD;
A = (A + A) % MOD;
B /= 2;
}
return r;
}
long long GCD(long long A, long long B) { return B == 0 ? A : GCD(B, A % B); }
int dx[] = {0, -1, 0, 1, 0};
int dy[] = {0, 0, 1, 0, -1};
template <class X, class Y>
bool minimize(X &x, const Y &y) {
X eps = 1e-9;
if (x > y + eps) {
x = y;
return true;
} else
return false;
}
template <class X, class Y>
bool maximize(X &x, const Y &y) {
X eps = 1e-9;
if (x + eps < y) {
x = y;
return true;
} else
return false;
}
template <class T>
T Abs(const T &x) {
return (x < 0 ? -x : x);
}
const int MAXN = 1e4 + 105;
string S;
int N;
int dp[MAXN][4];
set<string> H;
int solve(int i, int pre) {
if (i == N + 1) return 1;
if (dp[i][pre] != -1) return dp[i][pre];
int cur = 0;
if (pre == 2) {
if (i + 3 - 1 <= N) cur = max(cur, solve(i + 3, 3));
if (i + 2 - 1 <= N) {
if (S[i] != S[i - 2] || S[i + 1] != S[i - 1])
cur = max(cur, solve(i + 2, 2));
}
} else {
if (i + 2 - 1 <= N) cur = max(cur, solve(i + 2, 2));
if (i + 3 - 1 <= N) {
if (S[i] != S[i - 3] || S[i + 1] != S[i - 2] || S[i + 2] != S[i - 1])
cur = max(cur, solve(i + 3, 3));
}
}
return dp[i][pre] = cur;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> S;
S = " " + S;
N = S.size() - 1;
memset(dp, -1, sizeof(dp));
for (int i = (6), _b = (N); i <= _b; ++i) {
if (i + 2 - 1 <= N && solve(i + 2, 2)) {
string X = "";
X = X + S[i] + S[i + 1];
H.insert(X);
}
if (i + 3 - 1 <= N && solve(i + 3, 3)) {
string X = "";
X = X + S[i] + S[i + 1] + S[i + 2];
H.insert(X);
}
}
cout << H.size() << '\n';
for (auto &ans : H) cout << ans << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int m, n, a[100005], b[100005];
long long sum = 0;
cin >> m;
for (int i = 1; i <= m; i++) cin >> a[i];
sort(a + 1, a + 1 + m);
cin >> n;
for (int i = 1; i <= n; i++) cin >> b[i];
sort(b + 1, b + 1 + n);
sum = 0;
while (n > 0) {
if (n >= a[1]) {
for (int i = 1; i <= a[1]; i++) {
sum += b[n + 1 - i];
}
n -= a[1];
if (n >= 2)
n = n - 2;
else
n = 0;
if (n == 0) break;
} else {
for (int i = 1; i <= n; i++) {
sum += b[i];
}
break;
}
}
cout << sum << endl;
return EXIT_SUCCESS;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec;
map<long long, long long> mp;
vector<long long> adj[1000009];
long long arr[1000009], need[1000009];
bool sign[1000009];
int32_t main() {
long long i, j, n, m, k, d, a, b, p, sum = 0, ans = 0, mini = 199999999999,
maxi = -199999999999;
string st1, st2;
bool f1, f2;
cin >> n;
arr[0] = 0;
for (i = 1; i <= n; i++) cin >> arr[i];
for (i = 1; i <= n; i++) {
need[i - 1] = arr[i] - arr[i - 1];
}
for (i = 1; i <= n; i++) sign[i] = true;
for (i = 1; i <= n; i++) {
for (j = 0; j < n; j++) {
long long y = arr[j + 1] - arr[j];
if (need[j % i] != y) {
sign[i] = false;
break;
}
}
}
long long cnt = 0;
for (i = 1; i <= n; i++) {
if (sign[i]) {
cnt++;
vec.push_back(i);
}
}
cout << vec.size() << endl;
sort(vec.begin(), vec.end());
for (i = 0; i < vec.size(); i++) cout << vec[i] << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const long long MOD = 1000000007;
const double EPS = 1e-6;
int arr[55][55];
int n, m;
int numberOfInRow(int num, int i) {
int res = 0;
for (long long j = 0; j < (int)m; j++)
if (arr[i][j] == num) res++;
return res;
}
int numberOfInCol(int num, int j) {
int res = 0;
for (long long i = 0; i < (int)n; i++)
if (arr[i][j] == num) res++;
return res;
}
int main() {
cin >> n >> m;
if (n == 1 && m == 1) {
cout << 1 << endl;
return 0;
}
for (long long i = 0; i < (int)n; i++) {
for (long long j = 0; j < (int)m; j++) cin >> arr[i][j];
}
long long ans = 0;
for (long long i = 0; i < (int)n; i++) {
int osR = numberOfInRow(0, i);
int n1R = numberOfInRow(1, i);
long long add =
((((long long)1) << osR) - 1) + ((((long long)1) << n1R) - 1);
ans += (long long)add;
}
for (long long j = 0; j < (int)m; j++) {
int osC = numberOfInCol(0, j);
int n1C = numberOfInCol(1, j);
long long add =
((((long long)1) << osC) - 1) + ((((long long)1) << n1C) - 1);
ans += (long long)add;
}
cout << ans - (n * m) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int LOGN = 18;
const long long INF = 1.1e18;
struct Dat {
long long a;
int w, v, id;
} dat[N];
struct Node {
long long sw[LOGN], sv[LOGN], aw[LOGN], av[LOGN];
} st[N * 4];
int n, q, idx[N];
void Upd(int i, int l, int r, int lf, int rg) {
if (l == r) {
for (int j = 1; j < LOGN; j++) {
if (dat[l].w < (1 << j)) {
st[i].sw[j] = dat[l].a * dat[l].w;
st[i].sv[j] = dat[l].a * dat[l].v;
} else {
st[i].sw[j] = st[i].sv[j] = 0;
}
if (dat[l].w >= (1 << (j - 1)) && dat[l].w < (1 << j) && dat[l].a) {
st[i].aw[j] = dat[l].w;
st[i].av[j] = dat[l].v;
} else {
st[i].aw[j] = st[i].av[j] = INF;
}
}
return;
}
int mid = (l + r) >> 1;
if (lf <= mid) Upd(i << 1, l, mid, lf, rg);
if (rg > mid) Upd(i << 1 | 1, mid + 1, r, lf, rg);
for (int j = 1; j < LOGN; j++) {
st[i].sw[j] = st[i << 1].sw[j] + st[i << 1 | 1].sw[j];
st[i].sv[j] = st[i << 1].sv[j] + st[i << 1 | 1].sv[j];
if (st[i << 1].aw[j] < st[i << 1].sw[j - 1] + st[i << 1 | 1].aw[j]) {
st[i].aw[j] = st[i << 1].aw[j];
st[i].av[j] = st[i << 1].av[j];
} else {
st[i].aw[j] = st[i << 1].sw[j - 1] + st[i << 1 | 1].aw[j];
st[i].av[j] = st[i << 1].sv[j - 1] + st[i << 1 | 1].av[j];
}
}
}
void query(int i, int l, int r, int j, int &pos, long long &cw, long long &cv) {
if (pos == l && st[i].sw[j] <= cw) {
cw -= st[i].sw[j];
cv += st[i].sv[j];
pos = r + 1;
return;
}
if (l == r) return;
int mid = (l + r) >> 1;
if (pos <= mid) query(i << 1, l, mid, j, pos, cw, cv);
if (pos > mid) query(i << 1 | 1, mid + 1, r, j, pos, cw, cv);
}
int Finda(int i, int l, int r, int j, int &pos, long long &cw) {
if (pos == l) {
if (st[i].aw[j] > cw) {
cw -= st[i].sw[j - 1];
if (cw >= 0) pos = r + 1;
return -1;
} else if (l == r) {
assert(cw >= st[i].aw[j]);
return l;
}
}
int mid = (l + r) >> 1, ret = -1;
if (pos <= mid) ret = Finda(i << 1, l, mid, j, pos, cw);
if (ret != -1) return ret;
if (pos > mid) ret = Finda(i << 1 | 1, mid + 1, r, j, pos, cw);
return ret;
}
int Finda(int j, int pos, long long cw) {
return Finda(1, 1, n, j, pos, cw);
}
void querysum(int i, int l, int r, int j, int lf, int rg, long long &cw, long long &cv) {
if (lf <= l && r <= rg) {
cw -= st[i].sw[j];
cv += st[i].sv[j];
return;
}
int mid = (l + r) >> 1;
if (lf <= mid) querysum(i << 1, l, mid, j, lf, rg, cw, cv);
if (rg > mid) querysum(i << 1 | 1, mid + 1, r, j, lf, rg, cw, cv);
}
long long query(long long c) {
int pos = 1;
long long ret = 0;
for (int i = LOGN - 1; i > 0; i--) {
query(1, 1, n, i, pos, c, ret);
if (pos > n) break;
long long cur = min(dat[pos].a, c / dat[pos].w);
c -= cur * dat[pos].w;
ret += cur * dat[pos].v;
pos++;
if (pos > n) break;
int npos = Finda(i, pos, c);
if (npos != -1) {
if (pos < npos) querysum(1, 1, n, i - 1, pos, npos - 1, c, ret);
c -= dat[npos].w;
ret += dat[npos].v;
pos = npos + 1;
if (pos > n) break;
}
}
return ret;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld%d%d", &dat[i].a, &dat[i].w, &dat[i].v);
dat[i].id = i;
}
sort(dat + 1, dat + 1 + n, [](Dat x, Dat y) {
return x.v != y.v ? x.v > y.v : x.w < y.w;
});
for (int i = 1; i <= n; i++) idx[dat[i].id] = i;
Upd(1, 1, n, 1, n);
while (q--) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
int k, d;
scanf("%d%d", &k, &d);
d = idx[d];
dat[d].a += k;
Upd(1, 1, n, d, d);
} else if (ty == 2) {
int k, d;
scanf("%d%d", &k, &d);
d = idx[d];
dat[d].a -= k;
Upd(1, 1, n, d, d);
} else {
long long c;
scanf("%lld", &c);
printf("%lld\n", query(c));
}
}
return 0;
} | 26 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long inf = 0xc0c0c0c0c0c0c0c0;
const double pi = acos(-1);
const int MAXN = 3e5 + 7;
const int MAXA = 2;
const int MAX = MAXN * 30;
int tree[MAX][MAXA];
int C[MAX];
int root, cnt;
int m[MAXN];
int N;
int query(int str) {
int x = root;
int ans = 0;
for (int i = 29; ~i; i--) {
int alp = (str >> i) & 1;
if (tree[x][alp] == 0 || C[tree[x][alp]] == 0) {
ans |= 1 << i;
alp ^= 1;
}
x = tree[x][alp];
C[x]--;
}
return ans;
}
void add(int str) {
int x = root;
for (int i = 29; ~i; i--) {
int alp = (str >> i) & 1;
if (tree[x][alp] == 0) tree[x][alp] = ++cnt;
x = tree[x][alp];
C[x]++;
}
}
int main() {
root = 1;
cnt = 1;
scanf("%d", &N);
int i;
for (i = 0; i < N; i++) scanf("%d", m + i);
for (i = 0; i < N; i++) {
int x;
scanf("%d", &x);
add(x);
}
for (i = 0; i < N; i++) {
printf("%d ", query(m[i]));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct rect {
int x1, x2, y1, y2;
int maxval;
rect() {}
rect(int a, int b, int c, int d) {
x1 = a;
y1 = b;
x2 = c;
y2 = d;
}
};
vector<rect> rec;
int n, m;
string s[1111];
vector<int> mustx, musty;
vector<int> vx, vy;
void Print(rect fuk) {
cout << fuk.x1 + 1 << " ";
cout << fuk.y1 + 1 << " ";
cout << fuk.x2 + 1 << " ";
cout << fuk.y2 + 1 << endl;
}
bool haveedge(int a, int b, int c, int d) {
if (abs(a - c) + 1 < 3) return 0;
if (abs(b - d) + 1 < 3) return 0;
for (int j = b; j < d + 1; j++)
if (s[a][j] == '.' || s[c][j] == '.') return 0;
for (int i = a; i < c + 1; i++)
if (s[i][b] == '.' || s[i][d] == '.') return 0;
return 1;
}
int Paint(rect a, rect b) {
vector<pair<int, pair<int, int> > > ex, ey;
ex.push_back({a.x1, {a.y1, a.y2}});
ex.push_back({a.x2, {a.y1, a.y2}});
ex.push_back({b.x1, {b.y1, b.y2}});
ex.push_back({b.x2, {b.y1, b.y2}});
ey.push_back({a.y1, {a.x1, a.x2}});
ey.push_back({a.y2, {a.x1, a.x2}});
ey.push_back({b.y1, {b.x1, b.x2}});
ey.push_back({b.y2, {b.x1, b.x2}});
sort(ex.begin(), ex.end());
;
sort(ey.begin(), ey.end());
;
for (int i = 1; i < ex.size(); i++) {
if (ex[i].first == ex[i - 1].first) {
pair<int, int> a, b;
a = ex[i].second;
b = ex[i - 1].second;
if (a.first > b.second + 1 || b.first > a.second + 1) continue;
b.first = min(b.first, a.first);
b.second = max(b.second, a.second);
ex[i - 1].second = b;
ex.erase(ex.begin() + i, ex.begin() + i + 1);
i--;
}
}
for (int i = 1; i < ey.size(); i++) {
if (ey[i].first == ey[i - 1].first) {
pair<int, int> a, b;
a = ey[i].second;
b = ey[i - 1].second;
if (a.first > b.second + 1 || b.first > a.second + 1) continue;
b.first = min(b.first, a.first);
b.second = max(b.second, a.second);
ey[i - 1].second = b;
ey.erase(ey.begin() + i, ey.begin() + i + 1);
i--;
}
}
int ret = 0;
for (int i = 0; i < ex.size(); i++)
ret += ex[i].second.second - ex[i].second.first + 1;
for (int i = 0; i < ey.size(); i++)
ret += ey[i].second.second - ey[i].second.first + 1;
for (int i = 0; i < ex.size(); i++) {
for (int j = 0; j < ey.size(); j++) {
if (ex[i].first >= ey[j].second.first &&
ex[i].first <= ey[j].second.second)
if (ey[j].first >= ex[i].second.first &&
ey[j].first <= ex[i].second.second) {
ret--;
}
}
}
return ret;
}
int paint(rect fuk) {
int a = fuk.x1;
int b = fuk.y1;
int c = fuk.x2;
int d = fuk.y2;
int ret = 0;
for (int j = b; j < d + 1; j++) {
if (s[a][j] == '#') {
s[a][j] = 'f';
ret++;
}
if (s[c][j] == '#') {
s[c][j] = 'f';
ret++;
}
}
for (int i = a; i < c + 1; i++) {
if (s[i][b] == '#') {
s[i][b] = 'f';
ret++;
}
if (s[i][d] == '#') {
s[i][d] = 'f';
ret++;
}
}
return ret;
}
void unpaint(rect fuk) {
int a = fuk.x1;
int b = fuk.y1;
int c = fuk.x2;
int d = fuk.y2;
for (int j = b; j < d + 1; j++) s[a][j] = '#', s[c][j] = '#';
for (int i = a; i < c + 1; i++) s[i][b] = '#', s[i][d] = '#';
}
int ltmskx[1111], ltmsky[1111];
int lgmskx[1111111], lgmsky[1111111];
bool cmp(int a, int b) { return rec[a].maxval > rec[b].maxval; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
int tot = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') tot++;
}
}
for (int i = 0; i < n; i++) {
int cnt = 0;
bool f = 0;
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') {
cnt++;
if (cnt > 4) {
f = 1;
break;
}
if (i - 1 < 0 || s[i - 1][j] == '.') {
f = 1;
break;
}
if (i + 1 >= n || s[i + 1][j] == '.') {
f = 1;
break;
}
}
}
if (f) mustx.push_back(i);
}
for (int j = 0; j < m; j++) {
int cnt = 0;
bool f = 0;
for (int i = 0; i < n; i++) {
if (s[i][j] == '#') {
cnt++;
if (cnt > 4) {
f = 1;
break;
}
if (j - 1 < 0 || s[i][j - 1] == '.') {
f = 1;
break;
}
if (j + 1 >= m || s[i][j + 1] == '.') {
f = 1;
break;
}
}
}
if (f) musty.push_back(j);
}
if (mustx.size() > 4 || musty.size() > 4) {
cout << "NO" << endl;
;
return 0;
}
for (int i = 0; i < mustx.size(); i++)
for (int j = -1; j < 2; j++) {
int x = mustx[i] + j;
if (x >= 0 && x < n) vx.push_back(x);
}
for (int i = 0; i < musty.size(); i++)
for (int j = -1; j < 2; j++) {
int y = musty[i] + j;
if (y >= 0 && y < m) vy.push_back(y);
}
sort(vx.begin(), vx.end());
;
vx.erase(unique(vx.begin(), vx.end()), vx.end());
sort(vy.begin(), vy.end());
;
vy.erase(unique(vy.begin(), vy.end()), vy.end());
for (int i = 0; i < vx.size(); i++)
for (int j = 0; j < mustx.size(); j++) {
if (vx[i] == mustx[j]) {
ltmskx[i] = (1 << j);
break;
}
}
for (int i = 0; i < vy.size(); i++)
for (int j = 0; j < musty.size(); j++) {
if (vy[i] == musty[j]) {
ltmsky[i] = (1 << j);
break;
}
}
int mx = 0;
for (int x1 = 0; x1 < vx.size(); x1++)
for (int x2 = x1 + 1; x2 < vx.size(); x2++) {
for (int y1 = 0; y1 < vy.size(); y1++)
for (int y2 = y1 + 1; y2 < vy.size(); y2++) {
if (haveedge(vx[x1], vy[y1], vx[x2], vy[y2])) {
lgmskx[rec.size()] = ltmskx[x1] | ltmskx[x2];
lgmsky[rec.size()] = ltmsky[y1] | ltmsky[y2];
if (mustx.size() - __builtin_popcount(lgmskx[rec.size()]) > 2)
continue;
if (musty.size() - __builtin_popcount(lgmsky[rec.size()]) > 2)
continue;
rec.push_back(rect(vx[x1], vy[y1], vx[x2], vy[y2]));
rec[rec.size() - 1].maxval =
paint(rect(vx[x1], vy[y1], vx[x2], vy[y2]));
mx = max(mx, rec[rec.size() - 1].maxval);
unpaint(rect(vx[x1], vy[y1], vx[x2], vy[y2]));
}
}
}
vector<int> realrec;
for (int i = 0; i < rec.size(); i++) {
if (rec[i].maxval + mx >= tot) {
realrec.push_back(i);
}
}
sort(realrec.begin(), realrec.end(), cmp);
for (int pi = 0; pi < realrec.size(); pi++)
for (int pj = pi; pj < realrec.size(); pj++) {
int i = realrec[pi];
int j = realrec[pj];
if ((lgmskx[i] | lgmskx[j]) != (1 << mustx.size()) - 1) continue;
if ((lgmsky[i] | lgmsky[j]) != (1 << musty.size()) - 1) continue;
int mxres = rec[i].maxval + rec[j].maxval;
if (mxres < tot) continue;
int res = Paint(rec[i], rec[j]);
if (res == tot) {
cout << "YES" << endl;
;
Print(rec[i]);
Print(rec[j]);
return 0;
}
}
cout << "NO" << endl;
;
return 0;
}
| 18 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
const int N = 1e5 + 110;
const int K = 100 + 10;
int n, m;
int c[K][N];
int CC[N][K];
inline void qmod(int &x) { x = (x >= MOD) ? (x - MOD) : x; }
int main() {
int i, j, x;
int l, r, k;
for (i = int(0); i <= int(N - 1); i++) {
CC[i][0] = 1;
for (j = 1; j <= int(std::min(i, K - 1)); j++)
qmod(CC[i][j] = CC[i - 1][j] + CC[i - 1][j - 1]);
}
scanf("%d %d", &n, &m);
for (i = 1; i <= int(n); i++) {
scanf("%d", &x);
qmod(c[0][i] += x);
qmod(c[0][i + 1] += MOD - x);
}
while (m--) {
scanf("%d %d %d", &l, &r, &k);
qmod(c[k][l] += 1);
for (i = int(0); i <= int(k); i++)
qmod(c[k - i][r + 1] += MOD - CC[r - l + i][i]);
}
for (k = int(100); k >= int(0); k--) {
for (i = 1; i <= int(n); i++) {
qmod(c[k][i] += c[k][i - 1]);
qmod(c[k][i] += c[k + 1][i]);
}
}
for (i = 1; i <= int(n); i++) printf("%d ", c[0][i]);
putchar('\n');
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
mt19937 azino(1337);
const long double PI = 3.14159265358979323846;
void io() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
}
const int32_t MOD = 1e9 + 7;
int32_t add(int32_t a, int32_t b) {
if (a + b < MOD) return a + b;
return a + b - MOD;
}
int32_t sub(int32_t a, int32_t b) {
if (a - b < 0) return a - b + MOD;
return a - b;
}
int32_t mul(int32_t a, int32_t b) { return int64_t(a) * b % MOD; }
void solve() {
map<string, int32_t> num = {{"white", 0}, {"yellow", 1}, {"green", 2},
{"blue", 3}, {"red", 4}, {"orange", 5}};
map<int32_t, int32_t> re = {{0, 1}, {1, 0}, {2, 3}, {3, 2}, {4, 5}, {5, 4}};
map<int64_t, map<int32_t, int32_t>> unord;
set<int64_t> must;
map<int64_t, int32_t> color;
int32_t k;
cin >> k;
int32_t n;
cin >> n;
must.insert(1);
for (int32_t i = 0; i < n; ++i) {
int64_t v;
string clr;
cin >> v >> clr;
int32_t clr2 = num[clr];
color[v] = clr2;
if (v >= (int64_t(1) << (k - 1))) {
unord[v][clr2] = 1;
}
while (v != 0) {
must.insert(v);
v /= 2;
}
}
int32_t ans = 1;
for (int32_t i = 0; i + 1 < k; ++i) {
for (auto it = must.lower_bound(int64_t(1) << (k - i - 2));
it != must.end() && *it < (int64_t(1) << (k - i - 1)); ++it) {
int64_t v = *it;
for (int32_t lc = 0; lc < 6; ++lc) {
for (int32_t rc = 0; rc < 6; ++rc) {
for (int32_t vc = 0; vc < 6; ++vc) {
int32_t rt = re[vc];
if (vc != lc && vc != rc && lc != rt && rc != rt) {
int32_t cl =
(must.find(2 * v) == must.end() ? ans : unord[2 * v][lc]);
int32_t cr =
(must.find(2 * v + 1) == must.end() ? ans
: unord[2 * v + 1][rc]);
unord[v][vc] = add(unord[v][vc], mul(cl, cr));
}
}
}
}
if (color.find(v) != color.end()) {
int32_t xxx = color[v];
for (int32_t j = 0; j < 6; ++j) {
if (j != xxx) unord[v][j] = 0;
}
}
}
ans = mul(16, mul(ans, ans));
}
ans = 0;
for (auto &elem : unord[1]) ans = add(ans, elem.second);
cout << ans;
}
int32_t main() {
io();
solve();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
vector<long long> v;
long long x;
map<long long, long long> make_pair;
for (long long i = 0; i < n; i++) {
scanf("%lld", &x);
v.push_back(x);
make_pair[x]++;
}
sort(v.begin(), v.end());
long long cnt = 0, j, i, flag = 0;
for (i = 0; i < n - 1; i++) {
if (v[i] < v[i + 1] && v[i] + k >= v[i + 1]) {
cnt = cnt + make_pair[v[i]];
}
}
cout << n - cnt << "\n";
}
| 4 |
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using PQ = priority_queue<ll>;
using PQG = priority_queue<ll, vector<ll>, greater<ll>>;
using PQP = priority_queue<P>;
using PQPG = priority_queue<P, vector<P>, greater<P>>;
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
#define REP(i,n) for(ll i=0;i<ll(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=ll(a);i<=ll(b);i++)
#define FORD(i,a,b) for(ll i=ll(a);i>=ll(b);i--)
#define PB push_back
#define MP make_pair
#define SZ(x) ll(x.size())
#define ALL(x) x.begin(),x.end()
#define NIL -1
#define INF 1000100010001000
#define CINF 1ll<<63-1
#define MOD 1000000007
#define PI 3.14159265358979323846
#define endl "\n"
#define EPS 1e-9
template <class T, class U>
bool chmin(T& t, const U& u) {
if (t > u) {
t = u;
return true;
}
else return false;
}
template <class T, class U>
bool chmax(T& t, const U& u) {
if (t < u) {
t = u;
return true;
}
else return false;
}
class UnionFind {
public:
vector<ll> parent;
vector<ll> siz;
map<ll, vector<ll> > group;
ll n;
UnionFind(ll n_) :n(n_), parent(n_), siz(n_, 1) {
for (ll i = 0; i < n; i++) { parent[i] = i; }
}
ll root(ll x) {
if (parent[x] == x) return x;
return parent[x] = root(parent[x]);
}
bool unite(ll x, ll y) {
ll rx = root(x);
ll ry = root(y);
if (rx == ry) return false;
if (siz[rx] < siz[ry]) swap(rx, ry);
siz[rx] += siz[ry];
parent[ry] = rx;
return true;
}
bool same(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll t; cin >> t;
while (t) {
ll n; cin >> n;
V<ll> a(n);
REP(i, n)cin >> a[i];
ll mih = a[0], miv = a[1];
ll ch = 1, cv = 1;
ll k = mih * n + miv * n;
ll ans = k;
FOR(i, 2, n - 1) {
if (i % 2 == 0) {
ch++;
ans += a[i];
ans -= (n + 1 - ch) * mih;
chmin(mih, a[i]);
ans += (n - ch) * mih;
}
else {
cv++;
ans += a[i];
ans -= (n + 1 - cv) * miv;
chmin(miv, a[i]);
ans += (n - cv) * miv;
}
chmin(k, ans);
}
cout << k << endl;
t--;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int M = 200;
int uv, n, t, k, root, r, h, num, anum[] = {6, 2, 0}, arad[] = {3, 2, 1};
vector<int> v, vb, g[M];
bool mark[M];
void ask(int u) {
if (mark[u]) return;
cout << "? " << u << endl;
mark[u] = true;
cin >> k;
if (k == 2) root = u;
for (int i = 0; i < k; i++) {
cin >> uv;
g[u].push_back(uv);
}
}
void bfs(int u, int rad) {
if (!mark[u]) num--;
ask(u);
for (int i = 0; i < g[u].size(); i++)
if (!mark[g[u][i]] && rad) {
vb.push_back(g[u][i]);
if (num) bfs(g[u][i], rad - 1);
}
}
void dfs(int u) {
ask(u);
v.push_back(u);
for (int i = 0; i < g[u].size(); i++)
if (!mark[g[u][i]]) {
dfs(g[u][i]);
return;
}
}
void solve() {
if (h == n) return;
if (h > 3) {
vb.clear();
num = anum[h - 4];
bfs(r, arad[h - 4]);
for (int i = 0; i < vb.size(); i++)
if (!mark[vb[i]] && !root) root = vb[i];
return;
}
v.clear();
if (h == 0) {
dfs(1);
reverse(v.begin(), v.end());
v.pop_back();
dfs(1);
} else {
dfs(r);
reverse(v.begin(), v.end());
for (int i = 1; i < h; i++) v.push_back(0);
}
r = v[v.size() / 2];
h = v.size() / 2 + 1;
solve();
}
int main() {
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < M; i++) g[i].clear(), mark[i] = root = h = r = 0;
solve();
cout << "! " << root << endl;
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int N = 2005;
struct node {
double x, y, k;
int px, py;
} a[N * N];
double mid_x, mid_y;
int n, x[N], y[N], ans, k, t, p[N], die[N], X[N], Y[N], cnt, lst, pos;
bool cmp(const node &A, const node &B) { return A.k < B.k; }
bool operator==(const node &A, const node &B) { return A.x * B.y == A.y * B.x; }
bool check(int x, double b1, double b2) {
double dx = mid_y - Y[x], dy = -mid_x + X[x];
return fabs(dy * b1 - b2 * dx) < eps;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]), mid_x += x[i], mid_y += y[i];
mid_x /= n;
mid_y /= n;
for (int i = 1; i < n; i++)
if (!die[i])
for (int j = i + 1; j <= n; j++)
if (!die[j] && fabs(x[i] + x[j] - 2 * mid_x) < eps &&
fabs(y[i] + y[j] - 2 * mid_y) < eps) {
die[i] = die[j] = 1;
break;
}
for (int i = 1; i <= n; i++)
if (!die[i]) X[++t] = x[i], Y[t] = y[i];
if (t < 2) return puts("-1"), 0;
for (int i = 1; i < t; i++)
for (int j = i + 1; j <= t; j++) {
double dx = mid_y - (Y[i] + Y[j]) / 2.0,
dy = -mid_x + (X[i] + X[j]) / 2.0;
if (dx < 0) dx = -dx, dy = -dy;
if (dx == 0) dy = fabs(dy);
if (dy == 0) dx = fabs(dx);
a[++cnt].x = dx, a[cnt].y = dy;
a[cnt].px = i;
a[cnt].py = j;
a[cnt].k = atan2(dy, dx);
}
sort(a + 1, a + cnt + 1, cmp);
lst = 1;
for (int i = 1; i <= cnt; i++)
if (i == cnt || !(a[i] == a[i + 1])) {
if (i - lst + 1 >= t / 2) {
for (int j = 1; j <= t; j++) p[j] = 1;
for (; lst <= i; lst++)
if (p[a[lst].px] && p[a[lst].py]) p[a[lst].px] = p[a[lst].py] = 0;
k = 0;
for (int j = 1; j <= t; j++)
if (p[j]) k++, pos = j;
if (k > (t & 1)) {
lst = i + 1;
continue;
}
if (!k || check(pos, a[i].x, a[i].y)) ans++;
}
lst = i + 1;
}
printf("%d\n", ans);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pii pair<int, int>
#define rep(i, a, b) for(ll i = a; i < b; i++)
#define rfor(i, b, a) for(ll i = b; i >= a; i--)
#define X first
#define Y second
#define pb push_back
#define play {ios_base::sync_with_stdio(false);}
#define tennis {cin.tie(NULL); cout.tie(NULL);}
#define ms(arr, v) memset(arr, v, sizeof(arr))
#define vsz(x) ((long long) x.size())
#define arrout(a, n) {for (int ele = 0; ele < (n); ele++) { if (ele) cout << " "; cout << a[ele]; } cout << '\n';}
#define arrin(a, n) for (int ele = 0; ele < n; ele++) cin >> a[ele];
#define all(v) v.begin(), v.end()
#define getunique(v) {sort(all(v)); v.erase(unique(all(v)), v.end());}
#define debug(x) cout << '>' << #x << ':' << x << endl;
//const ll mod = 1e9 + 7;
//dont stop trying :)
template <typename T1, typename T2>
inline std::ostream& operator << (std::ostream& os, const std::pair<T1, T2>& p)
{
return os << "(" << p.first << ", " << p.second << ")";
}
template<typename T>
inline std::ostream &operator << (std::ostream & os,const std::vector<T>& v)
{
bool first = true;
os << "[";
for(unsigned int i = 0; i < v.size(); i++)
{
if(!first)
os << ", ";
os << v[i];
first = false;
}
return os << "]";
}
template<typename T>
void outputVector(vector<T> v) {
cout << v.size() << '\n';
for(auto x : v) cout << x << " ";
cout << '\n';
}
ll n, m, k;
const ll template_size_array = 1e6 + 1377;
ll a[template_size_array];
ll b[template_size_array];
ll c[template_size_array];
string s, t;
int cnt = 0;
char ret(int i) {
return 'a' + i;
}
string mex() {
queue<string> q;
string res = "";
rep(i, 0, 26) {
q.push(res + ret(i));
if(s.find(ret(i)) == string::npos) {
return res + ret(i);
}
}
while(q.size()) {
string temp = q.front();
q.pop();
rep(i, 0, 26) {
q.push(temp + ret(i));
if(s.find(temp + ret(i)) == string::npos) {
return temp + ret(i);
}
q.push(temp + ret(i));
}
}
}
void solve(int tc = 0) {
cin >> n;
cin >> s;
cout << mex() << endl;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#endif
play tennis;
cout << setprecision(12) << fixed;
int tc = 1;
cin >> tc;
for (int tt = 0; tt < tc; tt++) solve(tt);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1100;
int used[maxN];
vector<int> g[maxN];
vector<int> query;
int n;
void dfs(int v, int p, int dep, int target) {
if (used[v]) {
return;
}
used[v] = 1;
if (target == dep) {
query.push_back(v);
return;
}
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to] && to != p) {
dfs(to, v, dep + 1, target);
}
}
}
vector<int> findpath(int u, int v) {
vector<int> used(n, -1);
vector<int> p(n, -1);
used[u] = 0;
queue<int> q;
q.push(u);
while (!q.empty()) {
int cur = q.front();
q.pop();
int dist = used[cur];
for (int i = 0; i < g[cur].size(); ++i) {
int to = g[cur][i];
if (used[to] == -1) {
used[to] = dist + 1;
q.push(to);
p[to] = cur;
}
}
}
vector<int> res;
int curv = v;
while (curv != u) {
res.push_back(curv);
curv = p[curv];
}
res.push_back(u);
reverse(res.begin(), res.end());
return res;
}
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) {
g[i].clear();
}
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
int dist = -1;
cout << "? " << n;
for (int i = 0; i < n; ++i) {
cout << " " << i + 1;
}
cout << endl;
int u, v;
cin >> u >> dist;
--u;
v = u;
int curdist = 0;
while (curdist < dist) {
int target = (dist - curdist + 1) / 2;
int pu, pv;
vector<int> path = findpath(u, v);
if (u == v) {
pu = u, pv = u;
} else {
pu = path[1];
pv = path[path.size() - 2];
}
query.clear();
memset(used, 0, sizeof(used));
dfs(u, pu, 0, target);
auto qu = set<int>(query.begin(), query.end());
if (u != v) {
dfs(v, pv, 0, target);
}
cout << "? " << query.size();
for (int i = 0; i < query.size(); ++i) {
cout << " " << query[i] + 1;
}
cout << endl;
int nx, ndist;
cin >> nx >> ndist;
--nx;
if (qu.count(nx)) {
u = nx;
} else {
v = nx;
}
curdist += target;
}
cout << "! " << u + 1 << " " << v + 1 << endl;
string s;
cin >> s;
}
int main() {
int t;
cin >> t;
for (int tt = 0; tt < t; ++tt) {
solve();
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
cin >> a;
for (int i = 0; i < a; i++) {
long long b, c, d;
cin >> b >> c >> d;
long long ans = (b + c + d) / 2;
cout << ans << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200005;
int a[MAX], X[MAX], Y[MAX], idxX, idxY;
int main() {
int n, l, x, y;
scanf("%d %d %d %d", &n, &l, &x, &y);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
bool checkX = 0, checkY = 0;
for (int i = 0; i < n; ++i) {
if (binary_search(a, a + n, a[i] + x) ||
binary_search(a, a + n, a[i] - x)) {
checkX = 1;
} else if (!checkX) {
if (a[i] + x < l) X[idxX++] = a[i] + x;
if (a[i] - x >= 0) X[idxX++] = a[i] - x;
}
if (binary_search(a, a + n, a[i] + y) ||
binary_search(a, a + n, a[i] - y)) {
checkY = 1;
} else if (!checkY) {
if (a[i] + y < l) Y[idxY++] = a[i] + y;
if (a[i] - y >= 0) Y[idxY++] = a[i] - y;
}
}
if (checkX && checkY) {
printf("0");
} else if (checkX) {
printf("1\n%d", Y[0]);
} else if (checkY) {
printf("1\n%d", X[0]);
} else {
sort(X, X + idxX);
sort(Y, Y + idxY);
for (int i = 0; i < idxX; ++i) {
if (binary_search(Y, Y + idxY, X[i])) {
printf("1\n%d", X[i]);
return 0;
}
}
printf("2\n%d %d", X[0], Y[0]);
}
return 0;
}
| 9 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
vector<int> V(10000);
for(int i = 1;i<10000;i++)
{
V[i] = V[i-1] + i;
}
while(t--)
{
int n;
cin>>n;
int i = lower_bound(V.begin(),V.end(),n) - V.begin();
if(V[i] == n + 1)
{
cout<<i+1;
}
else
{
cout<<i;
}
cout<<'\n';
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = (1 << 24) + 10;
const int inf = 0x3f3f3f3f;
int n, sx, sy;
int dp[M], las[M], res[2][M];
int x[30], y[30], c[30][30];
inline int cost(int x1, int y1, int x2, int y2) {
int dx = x1 - x2, dy = y1 - y2;
return dx * dx + dy * dy;
}
inline int lowbit(int x) { return x & (-x); }
inline int xth(int x) {
int res = 0;
while (!((1 << res) & x)) ++res;
return res + 1;
}
int main() {
scanf("%d%d%d", &sx, &sy, &n);
for (register int i = 1; i < (1 << n); ++i) dp[i] = inf;
for (register int i = 0; i < n; ++i) {
scanf("%d%d", x + i, y + i);
for (register int j = 0; j < i; ++j)
c[j][i] = c[i][j] = cost(x[i], y[i], x[j], y[j]) +
cost(x[i], y[i], sx, sy) + cost(x[j], y[j], sx, sy);
c[i][i] = cost(x[i], y[i], sx, sy) * 2;
}
for (register int i = 0; i < (1 << n) - 1; ++i)
if (dp[i] != inf)
for (register int j = 0; j < n; ++j)
if (!((1 << j) & i)) {
for (register int k = 0; k < n; ++k)
if (!((1 << k) & i)) {
int tmp = i | (1 << j) | (1 << k);
if (dp[tmp] <= dp[i] + c[j][k]) continue;
dp[tmp] = dp[i] + c[j][k];
las[tmp] = i, res[0][tmp] = j + 1, res[1][tmp] = k + 1;
}
break;
}
int now = (1 << n) - 1;
printf("%d\n", dp[now]);
while (now) {
printf("0 ");
if (res[0][now] == res[1][now])
printf("%d ", res[0][now]);
else
printf("%d %d ", res[0][now], res[1][now]);
now = las[now];
}
printf("0\n");
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
long long n, m, l, s, vl[100002], vs[100002], spl;
long long q, xa, ya, xb, yb;
long long bls(long long nr) {
if (nr < vl[1]) return -1;
int b = 1;
int e = l;
long long sol = -1;
while (b <= e) {
int mid = (b + e) / 2;
if (vl[mid] <= nr)
sol = vl[mid], b = mid + 1;
else
e = mid - 1;
}
return sol;
}
long long blr(long long nr) {
if (nr > vl[l]) return -1;
int b = 1;
int e = l;
long long sol = -1;
while (b <= e) {
int mid = (b + e) / 2;
if (vl[mid] >= nr)
sol = vl[mid], e = mid - 1;
else
b = mid + 1;
}
return sol;
}
long long bss(long long nr) {
if (nr < vs[1]) return -1;
int b = 1;
int e = s;
long long sol = -1;
while (b <= e) {
int mid = (b + e) / 2;
if (vs[mid] <= nr)
sol = vs[mid], b = mid + 1;
else
e = mid - 1;
}
return sol;
}
long long bsr(long long nr) {
if (nr > vs[s]) return -1;
int b = 1;
int e = s;
long long sol = -1;
while (b <= e) {
int mid = (b + e) / 2;
if (vs[mid] >= nr)
sol = vs[mid], e = mid - 1;
else
b = mid + 1;
}
return sol;
}
long long solve(long long xa, long long ya, long long xb, long long yb) {
long long mint = (1LL << 60);
if (bss(ya) != -1)
mint = min(mint, ya - bss(ya) + (xb - xa) + abs(bss(ya) - yb));
if (bsr(ya) != -1)
mint = min(mint, bsr(ya) - ya + (xb - xa) + abs(bsr(ya) - yb));
long long tt = (xb - xa) / spl + (((xb - xa) % spl) > 0);
if (bls(ya) != -1) mint = min(mint, ya - bls(ya) + tt + abs(bls(ya) - yb));
if (blr(ya) != -1) mint = min(mint, blr(ya) - ya + tt + abs(blr(ya) - yb));
return mint;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> s >> l >> spl;
for (int i = 1; i <= s; ++i) cin >> vs[i];
for (int i = 1; i <= l; ++i) cin >> vl[i];
cin >> q;
for (int i = 1; i <= q; ++i) {
cin >> xa >> ya >> xb >> yb;
if (xa > xb) {
swap(xa, xb);
swap(ya, yb);
} else if (xa == xb && ya > yb)
swap(ya, yb);
if (xa == xb)
cout << yb - ya << '\n';
else
cout << solve(xa, ya, xb, yb) << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int l1, l2, l3;
cin >> l1 >> l2 >> l3;
if (l1 + l3 == l2 || l1 + l2 == l3 || l2 + l3 == l1)
cout << "YES" << endl;
else if ((l1 == l2 && l3 % 2 == 0) || (l2 == l3 && l1 % 2 == 0) ||
(l1 == l3 && l2 % 2 == 0))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
Subsets and Splits