solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > e[100010];
int vis[100010], p[100010], c[100010], vis2[100010];
struct P {
int v, col;
P() {}
P(int _v, int _c) : v(_v), col(_c) {}
};
bool bfs(int st, int col) {
c[st] = col;
vis2[st] = 1;
queue<P> que;
que.push(P(st, col));
while (!que.empty()) {
P now = que.front();
que.pop();
int Size = e[now.v].size();
for (int i = 0; i < Size; i++) {
pair<int, int> Next = e[now.v][i];
int tmp = Next.second;
int tmp2 = (tmp == 1 ? now.col : !now.col);
if (c[Next.first] != -1) {
if (c[Next.first] != tmp2)
return false;
else
continue;
} else
c[Next.first] = tmp2;
vis2[Next.first] = 1;
que.push(P(Next.first, tmp2));
}
}
return true;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i < n + 1; i++) scanf("%d", &vis[i]);
for (int i = 1; i < m + 1; i++) {
int cnt;
scanf("%d", &cnt);
for (int j = 1; j < cnt + 1; j++) {
int u;
scanf("%d", &u);
if (!p[u])
p[u] = i;
else {
e[i].push_back(make_pair(p[u], vis[u]));
e[p[u]].push_back(make_pair(i, vis[u]));
}
}
}
int flag1 = 1, flag2 = 1;
memset(c, -1, sizeof(c));
for (int i = 1; i < m + 1; i++) {
if (!vis2[i]) flag1 = bfs(i, 1);
if (!flag1) break;
}
memset(vis2, 0, sizeof(vis2));
memset(c, -1, sizeof(c));
for (int i = 1; i < m + 1; i++) {
if (!vis2[i]) flag2 = bfs(i, 0);
if (!flag2) break;
}
if (flag1 || flag2)
puts("YES");
else
puts("NO");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
string R;
int n;
struct st {
string s;
inline void shift(int x) {
stack<char> _s;
int c = 0;
for (int i = int(n - x); i < int((int)s.size()); i++) _s.push(s[i]);
for (int i = int(n - 1); i >= int(0); i--)
if (i - x >= 0) s[i] = s[i - x];
while (!_s.empty()) s[c++] = _s.top(), _s.pop();
}
} wo;
inline void add(int k) {
int quiebre = n;
for (int i = int(0); i < int(n); i++)
if (R[n - 1 - k] == wo.s[i]) quiebre = i;
wo.shift(n);
wo.shift(quiebre);
wo.shift(1);
ans.push_back(n);
ans.push_back(quiebre);
ans.push_back(1);
}
int main() {
cin >> n;
string s1;
cin >> s1 >> R;
wo.s = s1;
int cnt[29];
memset(cnt, 0, sizeof(cnt));
for (int i = int(0); i < int(n); i++) cnt[s1[i] - 'a']++, cnt[R[i] - 'a']--;
for (int i = int(0); i < int(26); i++)
if (cnt[i] != 0) {
cout << "-1" << endl;
return 0;
}
for (int i = int(0); i < int(n); i++) add(i);
cout << (int)ans.size() << endl;
for (int i = int(0); i < int((int)ans.size()); i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long a[N];
int main() {
long long ts, tf, t;
scanf("%I64d%I64d%I64d", &ts, &tf, &t);
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", a + i);
long long pos, ans = 1e18;
long long last = ts;
a[++n] = tf - t + 1;
for (int i = 1; i <= n; i++) {
long long x = a[i];
if (a[i] != a[i - 1]) {
long long tpos = min(a[i] - 1, last);
long long tans = max(last - tpos, 0ll);
if (max(last, tpos) + t > tf) break;
if (tans < ans) {
ans = tans;
pos = tpos;
}
}
last = max(x, last) + t;
}
printf("%I64d\n", pos);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main () {
int A, B;
cin >> A >> B;
cout << (A * B) / 2 << endl;
} | 0 |
#include<iostream>
#include<cstdio>
#include<queue>
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define ROF(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
const int N=100100;
int n,m,T,u,v,ans,du[N],d[N],t[N],g[N],b[N],c[N],fa[N];
struct lin{int x,y;}p[N],f[N];
vector<int>ad[N],ve;
queue<int>q;
void add(int u,int v){ad[u].push_back(v);du[v]++;}
void dfs(int u){for(int v:ad[u])if(v!=fa[u]) fa[v]=u,d[v]=d[u]+1,dfs(v);}
void gtp(int x,int y){
if(d[x]<d[y]) swap(x,y);
for(;d[x]>d[y];x=fa[x]) c[x]++;
for(;x!=y;x=fa[x],y=fa[y]) c[x]++,c[y]++;
}
int main(){
//freopen("1.in","r",stdin);
scanf("%d%d",&n,&m);T=m;
FOR(i,2,n) scanf("%d%d",&u,&v),add(u,v),add(v,u);
FOR(i,1,m) scanf("%d%d",&p[i].x,&p[i].y),f[i]=p[i];
dfs(1);
FOR(i,1,m) gtp(p[i].x,p[i].y);
FOR(i,1,n) ans+=min(2,c[i]),d[i]=0;
FOR(i,1,n)if(du[i]==1) q.push(i);
while(q.size()){
int u=q.front(),p0=0,p1=0,w;
q.pop();ve.clear();
for(int v:ad[u])if(du[v]){
w=v;du[u]--;
if(--du[w]==1) q.push(w);
}
FOR(i,1,T)if(!b[i]){
b[i]=f[i].x==u&&f[i].y==u;
if(!(f[i].x==u^f[i].y==u)) continue;
ve.push_back(i);
}
//cout<<u<<'\n';
//FOR(i,1,T)if(!b[i]) cout<<i<<':'<<f[i].x<<' '<<f[i].y<<'\n';
while(ve.size()>1){
int v0=ve.back(),r0=f[v0].y==u;ve.pop_back();
int v1=ve.back(),r1=f[v1].y==u;ve.pop_back();
b[v0]=b[v1]=1;
f[++T]=(lin){r0?f[v0].x:f[v0].y,r1?f[v1].x:f[v1].y};
g[v0]=g[v1]=T;d[v0]=!r0,d[v1]=r1;
}
if(ve.size()==1){
int v=ve[0];
if(f[v].x==u) f[v].x=w;
if(f[v].y==u) f[v].y=w;
}
}
ROF(i,T,1) t[i]=d[i]^t[g[i]];
cout<<ans<<'\n';
FOR(i,1,m){
if(t[i]) swap(p[i].x,p[i].y);
cout<<p[i].x<<' '<<p[i].y<<'\n';
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)4e5 + 7;
const long long INF = (long long)1e9 + 7;
const long double EPS = 1e-9;
int main() {
int n, l;
cin >> n;
if (n < 4) return cout << "NO", 0;
cout << "YES\n";
if (n % 2 == 0) {
cout << "2 * 3 = 6\n6 * 4 = 24\n1 * 24 = 24\n";
l = 5;
} else {
cout << "5 * 4 = 20\n3 - 1 = 2\n2 * 2 = 4\n20 + 4 = 24\n";
l = 6;
}
for (int i = n; i > l; i -= 2)
cout << i << " - " << i - 1 << " = 1\n"
<< "1 * 24 = 24\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long qpow(long long a, long long b, long long m) {
long long r = 1;
a %= m;
for (; b; b >>= 1) {
if (b & 1) r = r * a % m;
a = a * a % m;
}
return r;
}
const int inf = 0x7fffffff;
const int maxn = 2e5 + 10;
int in[maxn];
bool vis[maxn];
int head[maxn], nxt[maxn << 1], tot;
vector<pair<int, int> > ans;
int n, m;
struct edge {
int u, v;
edge() {}
edge(int u, int v) : u(u), v(v) {}
} e[maxn << 1];
void add_edge(int u, int v) {
e[++tot] = edge(u, v);
nxt[tot] = head[u];
head[u] = tot;
}
queue<int> que;
void bfs(int u) {
vis[u] = true;
que.push(u);
while (!que.empty()) {
u = que.front();
que.pop();
for (int i = head[u]; i != -1; i = nxt[i]) {
if (!vis[e[i].v]) {
vis[e[i].v] = true;
que.push(e[i].v);
ans.push_back(pair<int, int>(u, e[i].v));
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
memset(head, -1, sizeof(head));
memset(nxt, -1, sizeof(nxt));
tot = 0;
while (m--) {
int u, v;
cin >> u >> v;
in[u]++;
in[v]++;
add_edge(u, v);
add_edge(v, u);
}
int p = 1;
for (int i = 1; i <= n; i++)
if (in[i] > in[p]) p = i;
bfs(p);
for (int i = 0; i < (int)(ans).size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
using namespace std;
const double eps = 0.000001;
const long double pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const long long MOD = 1e18 + 9;
const long long INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 3e5 + 123;
const int PRI = 555557;
const int pri = 997;
const int add = 1e5;
int tests = 1;
int n, m, k;
int a[N];
long long s;
int cur, res;
int ans;
int cnt[N];
inline void Solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i == 1) {
cur = a[i], res = a[i];
}
cur = min(cur, a[i]);
res = max(res, a[i]);
s += a[i];
cnt[a[i] + add]++;
}
sort(a + 1, a + n + 1);
if (res - cur <= 1) {
cout << n << '\n';
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
exit(0);
}
int mn = min(cnt[cur + add], cnt[add + res]);
int MN = mn;
if (mn + mn < cnt[cur + add + 1]) {
MN = cnt[cur + add + 1] / 2;
cout << n - MN * 2 << '\n';
mn = MN;
for (int i = 1; mn; i++) {
if (a[i] != cur + 1) continue;
a[i]++, mn--;
}
for (int i = n; MN; i--) {
if (res - 1 != a[i]) continue;
a[i]--, MN--;
}
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
exit(0);
}
cout << n - mn * 2 << '\n';
for (int i = 1; mn; i++) {
a[i]++, mn--;
}
for (int i = n; MN; i--) {
a[i]--, MN--;
}
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
while (tests--) {
Solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[100005];
void solve() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
list<long long> b;
for (int i = 59; i >= 0; i--) {
vector<long long> c;
for (int j = 0; j < n; j++) {
if (a[j] & (1ll << i)) {
c.push_back(a[j]);
a[j] = 0;
}
}
vector<list<long long>::iterator> pos;
pos.push_back(b.begin());
for (auto it = b.begin(); it != b.end(); ++it) {
if (*it & (1ll << i)) {
pos.push_back(next(it));
}
}
if (c.size() > pos.size()) {
cout << "No\n";
return;
}
for (int i = 0; i < (int)c.size(); i++) {
b.insert(pos[i], c[i]);
}
}
cout << "Yes\n";
for (long long x : b) {
cout << x << ' ';
}
cout << '\n';
}
int main() { solve(); }
| 3 |
#include<bits/stdc++.h>
#define rep(i,x,y) for(auto i=(x);i<=(y);++i)
#define dep(i,x,y) for(auto i=(x);i>=(y);--i)
#define fr first
#define sc second
using namespace std;
typedef long long ll;
const int N=3e5+10;
const ll inf=1e18;
vector<int>p[N];int v[N];
void sol(){int n,m;
scanf("%d%d",&n,&m);
rep(i,1,n){
p[i].clear();v[i]=0;
}
rep(i,1,m){int x,y;
scanf("%d%d",&x,&y);
p[x].push_back(y);
p[y].push_back(x);
}
queue<int>q1,q2;v[1]=1;q1.push(1);
while(!q1.empty()){
int x=q1.front();q1.pop();
if(v[x]>1)continue;
v[x]=3;
for(auto&i:p[x])if(v[i]<2){
v[i]=2;q2.push(i);
}
while(!q2.empty()){
int y=q2.front();q2.pop();
if(v[y]>2)continue;
for(auto&i:p[y])if(!v[i]){
v[i]=1;q1.push(i);
}
}
}
int cnt=0;
rep(i,1,n)if(v[i]==3)++cnt;
else if(v[i]<2){
printf("NO\n");return;
}
printf("YES\n%d\n",cnt);
rep(i,1,n)if(v[i]==3)printf("%d ",i);
printf("\n");
}
int main(){int t;
scanf("%d",&t);
rep(i,1,t)sol();
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
queue<long long> q;
int t;
cin >> t;
while (t--) {
int n;
long long h;
cin >> n >> h;
vector<long long> v(n);
long long sum = 0;
cin >> v[0];
long long maxm = 0;
for (int i = 1; i < n; i++) {
cin >> v[i];
v[i - 1] = v[i] - v[i - 1];
maxm = max(maxm, v[i - 1]);
sum += v[i - 1];
}
v[n - 1] = maxm;
sum += v[n - 1];
if (sum <= h) {
q.push(h - sum + v[n - 1]);
continue;
}
sort(v.begin(), v.end());
long long l = 0, u, m;
for (int i = 0; i < n; i++) {
h = h - ((n - i) * (v[i] - l));
if (h <= 0) {
h = h + ((n - i) * (v[i] - l));
m = n - i;
u = v[i];
break;
}
l = v[i];
}
if (h == 0) {
q.push(u);
continue;
}
long long mid;
long long lm = l;
while (l <= u) {
mid = (l + u) / 2;
if (((mid - lm) * m) == h)
break;
else if (((mid - lm) * m) > h) {
u = mid - 1;
} else {
l = mid + 1;
}
}
if ((mid - lm) * m < h) {
mid++;
}
q.push(mid);
}
while (!q.empty()) {
cout << q.front() << endl;
q.pop();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans, a[111];
bool f = true;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0, d; i < n; ++i) {
cin >> d;
++a[d];
}
while (f) {
f = false;
for (int i = k - 1; i > 0; --i) {
if (a[i]) {
f = true;
--a[i];
++a[i + 1];
}
}
ans += f;
}
cout << ans;
}
| 2 |
#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
while(1){
int N;
int fie[10001];
int ans=100000;
cin>>N;
if(N==0)break;
for(int i=0;i<N;i++)cin>>fie[i];
for(int i=0;i<N;i++){
int memo=fie[i],l=i,r=i,cou=1;
for(int j=1;j<=3;j++){
fie[i]=j;
l=i,r=i,cou=1;
while(1){
//printf("[%d][%d][%d][%d][%d]\n",i,j,l,r,cou);
int fg=1;
if(l!=0){
if(fie[l]==fie[l-1]){
l--;
cou++;
fg=0;
}
}
if(r!=N-1){
if(fie[r]==fie[r+1]){
r++;
cou++;
fg=0;
}
}
if(fg==1&&(cou<4))break;
if(fg==1&&(l==0||r==N-1)){cou=0;break;}
if(fg==1&&fie[l-1]!=fie[r+1]){cou=0;break;}
if(fg==1){
l--,r++;
cou=2;
}
}
//printf("[%d]\n",(l-0)+((N-1)-r)+cou);
ans=min(ans,(l-0)+((N-1)-r)+cou);
fie[i]=memo;
}
}
cout<<ans<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, m, i, j, x = 0, y = 1;
cin >> n;
long long int a[n + 5], b[n + 5], c[n + 5];
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
memset(c, 0, sizeof(c));
sort(b, b + n);
reverse(b, b + n);
for (i = 0; i < n - 1; i++) {
if (b[i] == b[i + 1]) {
b[i] = -1;
}
}
for (i = 0; i < n; i++) {
y = y + x;
x = 0;
for (j = 0; j < n; j++) {
if (b[i] == a[j]) {
c[j] = y;
x++;
}
}
}
for (i = 0; i < n; i++) {
cout << c[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int p[maxn];
vector<int> pa;
int main() {
int n, f;
scanf("%d", &n);
p[1] = 1;
for (int i = 2; i <= n; i++) {
scanf("%d", &f);
p[i] = f;
}
int r = n;
while (p[r] != r) {
pa.push_back(r);
r = p[r];
}
reverse(pa.begin(), pa.end());
printf("1");
for (int i = 0; i < (int)pa.size(); i++) printf(" %d", pa[i]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const N = 3e3 + 10;
int a[N];
int main() {
int n, m = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
for (int j = 0; j < i; ++j)
if (a[j] > a[i]) ++m;
}
int x = (m / 2) * 3 + m - m / 2;
printf("%d\n", x);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, i0, n, m, cnt, now;
struct edge {
int v, i;
bool f;
bool operator<(edge a) const {
if (v == a.v) return f > a.f;
return v < a.v;
}
} a[100005];
queue<pair<int, int>> q;
pair<int, int> ans[100005];
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++)
scanf("%d %d", &a[i].v, &a[i].f), a[i].i = i, cnt += (a[i].f == 0);
sort(a + 1, a + 1 + m);
now = 1;
for (i = 1; i <= m; i++) {
if (a[i].f == 1) {
ans[a[i].i] = {1, ++now};
if (now > n) {
printf("-1\n");
return 0;
}
for (int i0 = 2; i0 < now && cnt; i0++) cnt--, q.push({i0, now});
} else {
if (q.empty()) {
printf("-1\n");
return 0;
} else
ans[a[i].i] = q.front(), q.pop();
}
}
for (i = 1; i <= m; i++) printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 4 |
#include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<array>
#include<map>
#include<iomanip>
#include<assert.h>
#include<bitset>
#include<stack>
#include<memory>
using namespace std;
using namespace std::chrono;
typedef long long int llint;
typedef double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);*/
const llint mod=1000000007;
const llint big=2.19e15+1;
const long double pai=3.141592653589793238462643383279502884197;
const long double eps=1e-15;
template <class T,class U>bool mineq(T& a,U b){if(a>b){a=b;return true;}return false;}
template <class T,class U>bool maxeq(T& a,U b){if(a<b){a=b;return true;}return false;}
llint gcd(llint a,llint b){if(a%b==0){return b;}else return gcd(b,a%b);}
llint lcm(llint a,llint b){if(a==0){return b;}return a/gcd(a,b)*b;}
template<class T> void SO(T& ve){sort(ve.begin(),ve.end());}
template<class T> void REV(T& ve){reverse(ve.begin(),ve.end());}
template<class T>llint LBI(vector<T>&ar,T in){return lower_bound(ar.begin(),ar.end(),in)-ar.begin();}
template<class T>llint UBI(vector<T>&ar,T in){return upper_bound(ar.begin(),ar.end(),in)-ar.begin();}
llint solve(llint n,llint K){
llint i;
if(K>n){
llint ans=1;
while(n--){ans*=2;ans%=mod;}
return ans;
}
//円環上にAマークとBマーク
//BマークがKこ連続してはいけない
vector<llint>dp(n+1);//最後のAマーク
llint gen=1;//くぎりてん
dp[0]=1;//最後のBマーク
for(i=1;i<n;i++){
dp[i]=gen;
gen*=2;
if(i-K>=0){gen-=dp[i-K];}
gen+=mod;gen%=mod;
}
llint ans=0;
for(i=1;i<=K;i++){
ans+=i*dp[n-i];
ans%=mod;
}
return ans;
}
int main(void){
int i,n,m;cin>>n>>m;
string S;cin>>S;
vector<int>suu;
char now=S[0];
int ban=0;
for(i=0;i<m;i++){
if(S[i]==now){ban++;}
else{suu.pub(ban);ban=1;}
now=S[i];
}
suu.pub(ban);
//for(auto it:suu){cerr<<it<<endl;}
if(suu.size()==1){
cout<<solve(n,2)<<endl;
return 0;
}
if(n%2==1){cout<<0<<endl;return 0;}
int sei=suu[0];
if(suu[0]%2==0){sei=suu[0]+1;}
for(i=2;i+1<suu.size();i+=2){
if(suu[i]%2==1){mineq(sei,suu[i]);}
}
sei++;
//cerr<<sei<<endl;
cout<<(2*solve(n/2,sei/2))%mod<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
if (false) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int n, k;
cin >> n >> k;
vector<pair<long long, int> > t, p;
for (int i = 0; i < n; i++) {
long long price;
int type;
cin >> price >> type;
if (type == 1) {
t.push_back(make_pair(price, i));
} else {
p.push_back(make_pair(price, i));
}
}
sort(t.begin(), t.end());
reverse(t.begin(), t.end());
sort(p.begin(), p.end());
reverse(p.begin(), p.end());
vector<vector<pair<long long, int> > > b(k);
long long price = 0;
int ii = 0;
for (; ii < t.size() && ii < k - 1; ii++) {
b[ii].push_back(t[ii]);
price += t[ii].first;
}
for (; ii < t.size(); ii++) {
b[k - 1].push_back(t[ii]);
price += 2 * t[ii].first;
}
int jj = 0;
for (; ii < k - 1 && jj < p.size(); ii++, jj++) {
b[ii].push_back(p[jj]);
price += 2 * p[jj].first;
}
for (; jj < p.size(); jj++) {
b[k - 1].push_back(p[jj]);
price += 2 * p[jj].first;
}
if (t.size() >= k) {
int pm = -1;
for (int i = 0; i < b[k - 1].size(); i++) {
if (pm < 0 || pm > b[k - 1][i].first) {
pm = b[k - 1][i].first;
}
}
price -= pm;
}
cout << (price / 2);
if (price % 2 != 0) {
cout << ".5";
} else {
cout << ".0";
}
cout << endl;
for (int i = 0; i < k; i++) {
cout << b[i].size();
for (int j = 0; j < b[i].size(); j++) {
cout << " ";
cout << (b[i][j].second + 1);
}
cout << endl;
}
if (false) {
fclose(stdin);
fclose(stdout);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int conversion(string p) {
int o;
o = atoi(p.c_str());
return o;
}
string toString(int h) {
stringstream ss;
ss << h;
return ss.str();
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
long long toi(string p) {
long long x;
istringstream in(p);
in >> x;
return x;
}
int main() {
long long a, x, y;
cin >> a;
vector<long long> M;
set<long long> S;
for (int i = 0; i <= 9; i++) {
for (int j = i + 1; j <= 9; j++) {
x = i;
y = j;
if (x <= a && x > 0) {
S.insert(x);
M.push_back(i);
}
if (y <= a && y > 0) {
S.insert(y);
M.push_back(j);
}
for (int z = 0; z < M.size(); z++) {
x = M[z] * 10 + i;
y = M[z] * 10 + j;
if (x <= a) {
M.push_back(x);
S.insert(x);
}
if (y <= a) {
M.push_back(y);
S.insert(y);
}
}
M.clear();
}
}
cout << S.size() << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int eig = 0, oth = 0, num = 0;
int n;
cin >> n;
char tab[n];
string cards;
cin >> cards;
for (int i = 0; i < n; i++) tab[i] = cards.at(i);
for (int i = 0; i < n; i++) {
if (tab[i] == '8') eig++;
}
oth = n;
while ((oth > 10) && (eig > 0)) {
num++;
eig--;
oth -= 11;
}
cout << num;
}
| 1 |
#include <bits/stdc++.h>
#define ll long long
#define REP(i, n) for (ll (i) = 0; (i) < (n); (i)++)
#define REPI(i, a, b) for (ll (i) = (a); (i) < (b); (i)++)
#define int long long
using namespace std;
using II = pair<int, int>;
using VI = vector<int>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
using VII = vector<II>;
class SuffixArray {
public:
int N;
string S;
VI rank; // rank[i]: iから始まるsuffixの辞書順での順位
VI sorted; // sorted[i]: suffixが辞書順i番目となる開始位置のindex
SuffixArray(string s) {
S = s;
N = S.size();
sorted = VI(N); rank = VI(N);
REP (i, N) {
sorted[i] = i;
rank[i] = S[i];
}
int k;
function<bool(int, int)> compare_sa = [this, &k](int i, int j) {
if (rank[i] != rank[j]) { return rank[i] < rank[j]; }
int ri = i + k < N ? rank[i + k] : -1;
int rj = j + k < N ? rank[j + k] : -1;
return ri < rj;
};
for (k = 1; k < N; k *= 2) {
sort(sorted.begin(), sorted.end(), compare_sa);
VI tmp(N, 0);
REPI (i, 1, N) {
tmp[sorted[i]] = tmp[sorted[i - 1]] + compare_sa(sorted[i - 1], sorted[i]);
}
rank = tmp;
}
}
// Tが存在する場合はSにおける先頭index, 存在しない場合は-1を返す
int find(string T) {
int l = 0, r = N;
while (r - l > 1) {
cout << l << endl;
int mid = (l + r) / 2;
if (S.compare(sorted[mid], T.size(), T) < 0) {
l = mid;
} else {
r = mid;
}
}
if (S.compare(sorted[l], T.length(), T) != 0) { return -1; }
return sorted[l];
}
};
signed main() {
int K;
string S;
cin >> K >> S;
int N = S.size();
int part = N / (K + 1);
int rest = N % (K + 1);
SuffixArray sf(S);
if (rest == 0) {
int ans = 0;
REP (i, K + 1) {
if (sf.rank[ans] < sf.rank[part * i]) {
ans = part * i;
}
}
cout << S.substr(ans, part) << endl;
return 0;
}
int l = -1, r = N - 1;
while (r - l > 1) {
int mid = (r + l) / 2;
int next = 0;
int adi = 0;
REP (i, K + 1) {
if (sf.rank[next] <= sf.rank[sf.sorted[mid]]) {
next += part + 1;
adi++;
} else {
next += part;
}
}
if (adi >= rest) {
r = mid;
} else {
l = mid;
}
}
cout << S.substr(sf.sorted[r], part + 1) << endl;
} | 0 |
#include <bits/stdc++.h>
int a[709];
int f[709][709][2], can[709][709];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
signed main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
can[i][j] = gcd(a[i], a[j]) > 1;
}
}
for (int i = 1; i <= n + 1; i++) {
f[i][i - 1][0] = f[i][i - 1][1] = 1;
f[i][i][0] = can[i][i - 1];
f[i][i][1] = can[i][i + 1];
}
int i, j, x, len;
for (len = 1; len <= n; len++) {
for (i = 1; i + len <= n; i++) {
j = i + len;
for (x = i; x <= j; x++) {
f[i][j][0] |= f[i][x - 1][1] & f[x + 1][j][0] & can[x][i - 1];
f[i][j][1] |= f[i][x - 1][1] & f[x + 1][j][0] & can[x][j + 1];
}
}
}
int ans = 0;
for (int x = 1; x <= n; x++) {
ans |= f[1][x - 1][1] & f[x + 1][n][0];
}
puts(ans ? "Yes" : "No");
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
int a[15][15];
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
cin>>a[i][j];
}
}
int sum=0;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
int x=0;
for(int k=0;k<m;k++){
x+=(a[i][k]-a[j][k])*(a[i][k]-a[j][k]);
}
double m=sqrt(x);
if(m-(int)m==0) sum++;
}
}
cout<<sum;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[400005];
int subtree[400005], n, root, maximo;
bool ans[400005];
pair<int, int> max1, max2;
int dfs(int v, int p) {
subtree[v] = 1;
for (int x : G[v])
if (x != p) subtree[v] += dfs(x, v);
return subtree[v];
}
int centroid(int v, int p) {
for (int x : G[v]) {
if (x == p) continue;
if ((long long)subtree[x] * 2 > n) return centroid(x, v);
}
return v;
}
void dfs2(int v, int p) {
if (((long long)n - maximo - subtree[v]) * 2 > n)
ans[v] = 0;
else
ans[v] = 1;
for (int x : G[v]) {
if (x != p) dfs2(x, v);
}
}
void dfs3(int v, int p) {
ans[v] = 1;
for (int x : G[v]) {
if (x != p) dfs3(x, v);
}
}
int main() {
int a, b, i;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
dfs(1, -1);
int cent = centroid(1, -1);
ans[cent] = 1;
dfs(cent, -1);
for (int x : G[cent]) {
if (subtree[x] > max1.first) {
max2 = max1;
max1 = make_pair(subtree[x], x);
continue;
}
if (subtree[x] > max2.first) max2 = make_pair(subtree[x], x);
}
for (int x : G[cent]) {
root = x;
if (max1.second == x)
maximo = max2.first;
else
maximo = max1.first;
if (subtree[x] * 2 == n)
dfs3(x, cent);
else
dfs2(x, cent);
}
printf("%d", ans[1]);
for (i = 2; i <= n; i++) printf(" %d", ans[i]);
printf("\n");
return 0;
}
| 3 |
#include<iostream>
using namespace std;
long double x[4], y[4];
int main() {
while (cin >> x[0] >> y[0]) {
cin >> x[1] >> y[1];
cin >> x[2] >> y[2];
cin >> x[3] >> y[3];
if (x[0] > x[1])swap(x[0], x[1]);
if (x[2] > x[3])swap(x[2], x[3]);
if (y[0] > y[1])swap(y[0], y[1]);
if (y[2] > y[3])swap(y[2], y[3]);
int OK = 1;
if (x[1]<x[2] || x[0]>x[3])OK = 0;
if (y[1]<y[2] || y[0]>y[3])OK = 0;
if (OK == 0) { cout << "NO" << endl; }
if (OK == 1) { cout << "YES" << endl; }
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
if (b >= 999999999)
cout << a * 9 << endl;
else if (b >= 99999999)
cout << a * 8 << endl;
else if (b >= 9999999)
cout << a * 7 << endl;
else if (b >= 999999)
cout << a * 6 << endl;
else if (b >= 99999)
cout << a * 5 << endl;
else if (b >= 9999)
cout << a * 4 << endl;
else if (b >= 999)
cout << a * 3 << endl;
else if (b >= 99)
cout << a * 2 << endl;
else if (b >= 9)
cout << a * 1 << endl;
else
cout << 0 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t;
int x, y, a, b;
int main() {
cin >> t;
while (t--) {
cin >> x >> y >> a >> b;
y -= x;
if (y % (a + b) == 0)
cout << y / (a + b) << endl;
else
cout << -1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double n, m, w, d, s[60], b[60];
bool us[60], ub[60];
int bot[60];
vector<pair<int, double> > v[60];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> w >> m;
d = n * w / m;
if (w > d * 2) {
cout << "NO";
return 0;
}
for (int i = 1; i <= n; i++) b[i] = w;
for (int i = 1; i <= m; i++) s[i] = d;
int c = 1;
for (int i = 1; i <= m; i++) {
if (c > n) break;
if (max(b[c], s[i]) - min(b[c], s[i]) < 0.000001) {
v[i].push_back(make_pair(c, b[c]));
bot[c]++;
us[i] = true;
ub[c] = true;
c++;
} else if (b[c] > s[i]) {
v[i].push_back(make_pair(c, s[i]));
bot[c]++;
us[i] = true;
b[c] -= s[i];
} else {
v[i].push_back(make_pair(c, b[c]));
bot[c]++;
ub[c] = true;
s[i] -= b[c];
i--;
c++;
}
}
for (int i = 1; i <= n; i++)
if (!ub[i] || bot[i] > 2) {
cout << "NO";
return 0;
}
for (int i = 1; i <= m; i++) {
if (!us[i]) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
for (int i = 1; i <= m; i++) {
for (int j = 0; j < v[i].size(); j++) {
cout << v[i][j].first << ' ';
cout << setprecision(7) << fixed << v[i][j].second << ' ';
}
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
long long int val[1000004] = {0};
using namespace std;
long long getmul(long long n) {
long long int k{0};
while (n > 0) {
k += n % 10;
n = n / 10;
}
return k;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int x = max_element(arr, arr + n) - arr;
int y = min_element(arr, arr + n) - arr;
for (int i = n - 1; i >= 0; i--) {
if (arr[i] == arr[y]) {
y = i;
break;
}
}
if (x < y) {
cout << x + n - y - 1 << "\n";
} else {
cout << x + n - y - 2 << "\n";
}
return 0;
}
| 1 |
#include <stdio.h>
#include <stack>
#include <vector>
using namespace std;
//FILE *in = freopen("input.txt", "r", stdin);
//FILE *out = freopen("output.txt", "w", stdout);
int n, m;
char str1[1000];
int ind[15][3];
int indent[15];
int rind[15][3];
int res[15];
int R, C, S;
void input() {
for(int i = 0; i < m; i++) {
res[i] = -2;
}
ind[0][0] = ind[0][1] = ind[0][2] = 0;
for(int i = 0; i < n; i++) {
gets(str1);
int cnt = 0;
int j;
for(j = 0; str1[j]; j++) {
if(str1[j] == '.') {
++cnt;
}
else
break;
}
indent[i] = cnt;
for(;str1[j];j++) {
switch(str1[j]) {
case '(':
++ind[i][0];
break;
case '{':
++ind[i][1];
break;
case '[':
++ind[i][2];
break;
case ')':
--ind[i][0];
break;
case '}':
--ind[i][1];
break;
case ']' :
--ind[i][2];
break;
}
}
ind[i+1][0] = ind[i][0];
ind[i+1][1] = ind[i][1];
ind[i+1][2] = ind[i][2];
}
rind[0][0] = rind[0][1] = rind[0][2] = 0;
for(int i = 0; i < m; i++) {
gets(str1);
for(int j = 0; str1[j]; j++) {
switch(str1[j]) {
case '(':
++rind[i][0];
break;
case '{':
++rind[i][1];
break;
case '[':
++rind[i][2];
break;
case ')':
--rind[i][0];
break;
case '}':
--rind[i][1];
break;
case ']' :
--rind[i][2];
break;
}
}
rind[i+1][0] = rind[i][0];
rind[i+1][1] = rind[i][1];
rind[i+1][2] = rind[i][2];
}
}
void process2() {
for(int i = 0; i < m - 1; i++) {
int r = R*rind[i][0];
int c = C*rind[i][1];
int s = S*rind[i][2];
if(r < 0 || c < 0 || s < 0) {
res[i] = -1;
}
else {
if(res[i] != -2 && res[i] != r + c + s) {
res[i] = -1;
}
else {
res[i] = r + c + s;
}
}
}
}
void process() {
bool rf = false, cf = false, sf = false;
for(int i = 0; i < n - 1; i++) {
if(ind[i][0])rf = true;
if(ind[i][1])cf = true;
if(ind[i][2])sf = true;
}
for(R = rf ? 1 : -1; R <= 20; R++) {
if(R == 0) continue;
for(C = cf ? 1 : -1; C <= 20; C++) {
if(C == 0) continue;
for(S = sf ? 1 : -1; S <= 20; S++) {
if(S == 0) continue;
int i;
for(i = 0 ; i < n - 1; i++) {
if(indent[i+1] != R*ind[i][0] + C*ind[i][1] + S*ind[i][2])
break;
}
if(i == n - 1) {
process2();
}
}
}
}
}
void output() {
printf("0 ");
for(int i = 0; i < m - 2; i++) {
printf("%d ", res[i]);
}
printf("%d", res[m-2]);
printf("\n");
}
int main() {
while(true){
scanf("%d%d\n", &n, &m);
if (n == 0 && m == 0) break;
R = -1;
C = -1;
S = -1;
input();
process();
output();
}
return 0;
} | 0 |
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main() {
int n, m;
while (cin >> n >> m && n) {
int t[n], h[m], a = 101, b = 101;
double sum = 0, sum1 = 0, sum2 = 0;
rep(i, n) {
cin >> t[i];
sum1 += t[i];
}
rep(i, m) {
cin >> h[i];
sum2 += h[i];
}
sum = (sum1 + sum2) / 2;
rep(i, n){rep(j, m){
if (sum - (sum1 - t[i] + h[j]) == 0 && t[i] + h[j] < a + b){a = t[i];
b = h[j];
}
}
}
(a > 100) ? cout << -1 << endl : cout << a << ' ' << b << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const double eps = 1e-7;
long long s[MAXN << 2], h[MAXN], a[MAXN], Q[MAXN][3], cnt[MAXN << 2];
int n, q, len;
struct node {
long long s, cnt;
};
int Getpos(double x) { return upper_bound(a + 1, a + len + 1, x) - a - 1; }
void Add(int k, int l, int r, int x, long long y, long long z) {
if (l == r) {
cnt[k] += z;
s[k] += z * y;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
Add(k << 1, l, mid, x, y, z);
else
Add(k << 1 | 1, mid + 1, r, x, y, z);
cnt[k] = cnt[k << 1] + cnt[k << 1 | 1];
s[k] = s[k << 1] + s[k << 1 | 1];
}
node query(int k, int l, int r, int x, int y) {
if (x > y) return node{0, 0};
if (y < l || x > r) return node{0, 0};
if (x <= l && r <= y) return node{s[k], cnt[k]};
int mid = (l + r) >> 1;
node tmpl, tmpr;
tmpl.cnt = tmpl.s = tmpr.cnt = tmpr.s = 0;
if (x <= mid) tmpl = query(k << 1, l, mid, x, y);
if (mid + 1 <= y) tmpr = query(k << 1 | 1, mid + 1, r, x, y);
return node{tmpl.s + tmpr.s, tmpl.cnt + tmpr.cnt};
}
bool check(double mid, double v) {
node ans = query(1, 1, len, 1, Getpos(mid));
if (ans.cnt * mid - ans.s >= v)
return 1;
else
return 0;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &h[i]), a[++len] = h[i];
for (int i = 1; i <= q; i++) {
scanf("%lld", &Q[i][0]);
if (Q[i][0] == 1) {
scanf("%lld %lld", &Q[i][1], &Q[i][2]);
a[++len] = Q[i][2];
} else
scanf("%lld", &Q[i][1]);
}
sort(a + 1, a + len + 1);
len = unique(a + 1, a + len + 1) - a - 1;
for (int i = 1; i <= n; i++) Add(1, 1, len, Getpos(h[i]), h[i], 1);
for (int i = 1; i <= q; i++) {
if (Q[i][0] == 1) {
Add(1, 1, len, Getpos(h[Q[i][1]]), h[Q[i][1]], -1);
h[Q[i][1]] = Q[i][2];
Add(1, 1, len, Getpos(h[Q[i][1]]), h[Q[i][1]], 1);
} else {
double l = 0, r = Q[i][1] + 1e9;
for (int k = 0; k <= 100; k++) {
double mid = (l + r) / 2;
if (check(mid, Q[i][1]))
r = mid;
else
l = mid;
}
printf("%.8lf\n", (l + r) / 2);
}
}
return 0;
}
| 5 |
#include<iostream>
#include<algorithm>
using namespace std;
signed main() {
int a, b, c; cin >> a >> b >> c;
int ans = (c / (a * 7 + b)) * 7; c %= (a * 7 + b);
cout << ans + min((c + a - 1) / a, 7) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int t = 102;
int n, p;
long long ans[103] = {
10LL, 31LL, 42LL, 51LL, 72LL,
90LL, 131LL, 152LL, 190LL, 271LL,
392LL, 400LL, 572LL, 581LL, 812LL,
850LL, 1202LL, 1211LL, 1742LL, 1790LL,
2552LL, 2601LL, 3632LL, 3820LL, 5372LL,
5441LL, 7802LL, 8050LL, 11462LL, 11691LL,
16322LL, 17180LL, 24152LL, 24471LL, 35072LL,
36220LL, 51542LL, 52601LL, 73412LL, 77300LL,
108662LL, 110111LL, 157802LL, 162980LL, 231902LL,
236691LL, 330332LL, 347840LL, 488942LL, 495491LL,
710072LL, 733400LL, 1043522LL, 1065101LL, 1486472LL,
1565270LL, 2200202LL, 2229701LL, 3195302LL, 3300290LL,
4695812LL, 4792941LL, 6689102LL, 7043710LL, 9900872LL,
10033641LL, 14378822LL, 14851300LL, 21131132LL, 21568221LL,
30100922LL, 31696690LL, 44553902LL, 45151371LL, 64704662LL,
66830840LL, 95090072LL, 97056981LL, 135454112LL, 142635100LL,
200492522LL, 203181161LL, 291170942LL, 300738770LL, 427905302LL,
436756401LL, 609543482LL, 641857940LL, 902216312LL, 914315211LL,
1310269202LL, 1353324460LL, 1925573822LL, 1965403791LL, 2742945632LL,
2888360720LL, 4059973382LL, 4114418441LL, 5896211372LL, 6089960060LL,
8665082162LL, 8844317051LL};
long long st[103];
long long cnt[5];
bool w[10000][5];
long long d[10000][5];
long long dfs(int u, int k) {
if (u == n) return !!k;
if (w[u][k]) return d[u][k];
w[u][k] = 1;
d[u][k] = 0;
for (int i = 0; i < 3; i++)
d[u][k] = (d[u][k] + cnt[i] * dfs(u + 1, k ^ i)) % mod;
return d[u][k];
}
int main() {
scanf("%d%d", &n, &p);
for (int i = 0; i < t; i++) st[i] = ans[i] / 10, ans[i] %= 10;
t = lower_bound(st, st + t, p) - st;
st[t] = p + 1;
for (int i = 0; i < t; i++) {
int l = st[i], r = min(st[i + 1], 1LL * p) - 1;
cnt[ans[i]] =
(cnt[ans[i]] + 1LL * mod +
((1LL * p * (r - l + 1)) % mod - (1LL * r * (r + 1) / 2) % mod +
(1LL * l * (l - 1) / 2) % mod) %
mod) %
mod;
}
cout << dfs(0, 0) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct order {
int begin, end;
} m[500005];
bool cmp(const order a, const order b) { return a.end < b.end; }
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%d %d", &m[i].begin, &m[i].end);
}
sort(m, m + n, cmp);
int end = 0, count = 1;
end = m[0].end;
for (int i = 0; i < n; i++) {
if (m[i].begin > end) {
count++;
end = m[i].end;
}
}
printf("%d\n", count);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N=1e6+50, mod=998244353;
inline int add(int x,int y) {return (x+y>=mod) ? (x+y-mod) : (x+y);}
inline int dec(int x,int y) {return (x-y<0) ? (x-y+mod) : (x-y);}
inline int mul(int x,int y) {return (long long)x*y%mod;}
inline int power(int a,int b,int rs=1) {for(;b;b>>=1,a=mul(a,a)) if(b&1) rs=mul(rs,a); return rs;}
inline int sgn(int x) {return (x&1) ? (mod-1) : 1;}
namespace FFT {
const int G=3;
int A[N],B[N],w[N],pos[N],k;
inline void init(int n) {
for(k=1;k<=n;k<<=1);
memset(A,0,sizeof(int)*k);
memset(B,0,sizeof(int)*k);
for(int i=1;i<k;i++) pos[i]=(i&1) ? ((pos[i>>1]>>1)^(k>>1)) : (pos[i>>1]>>1);
}
inline void dft(int *a) {
for(int i=1;i<k;i++)
if(pos[i]>i) swap(a[pos[i]],a[i]);
for(int bl=1;bl<k;bl<<=1) {
int tl=bl<<1, wn=power(G,(mod-1)/tl);
w[0]=1; for(int i=1;i<bl;i++) w[i]=mul(w[i-1],wn);
for(int bg=0;bg<k;bg+=tl)
for(int j=0;j<bl;j++) {
int &t1=a[bg+j], &t2=a[bg+j+bl], t=mul(t2,w[j]);
t2=dec(t1,t); t1=add(t1,t);
}
}
}
inline void func() {
dft(A); dft(B);
for(int i=0;i<k;i++) B[i]=mul(B[i],A[i]);
dft(B); const int inv=power(k,mod-2);
for(int i=0;i<k;i++) B[i]=mul(B[i],inv);
reverse(B+1,B+k);
}
}
struct combin {
int fac[N],ifac[N];
combin() {
fac[0]=1;
for(int i=1;i<N;i++) fac[i]=mul(fac[i-1],i);
ifac[0]=ifac[1]=1;
for(int i=2;i<N;i++) ifac[i]=mul(mod-mod/i,ifac[mod%i]);
for(int i=2;i<N;i++) ifac[i]=mul(ifac[i-1],ifac[i]);
}
inline int C(int a,int b) {return mul(fac[a],mul(ifac[b],ifac[a-b]));}
} C;
struct poly {
vector <int> a;
poly(int d=0,int t=0) {a.resize(d+1); a[d]=t;}
inline int& operator [](const int &i) {return a[i];}
inline const int& operator [](const int &i) const {return a[i];}
inline int deg() const {return a.size()-1;}
inline poly extend(int k) {poly c=*this; c.a.resize(k); return c;}
friend inline poly operator *(const poly &a,const poly &b) {
poly c(a.deg()+b.deg()); FFT::init(c.deg());
for(int i=0;i<=a.deg();i++) FFT::A[i]=a[i];
for(int i=0;i<=b.deg();i++) FFT::B[i]=b[i];
FFT::func();
for(int i=0;i<=c.deg();i++) c[i]=FFT::B[i];
return c;
}
inline void pt() {
for(int i=0;i<=deg();i++) cerr<<a[i]<<' '; cerr<<'\n';
}
};
int n,m,l;
char a[N],b[N];
int main() {
scanf("%s%s",a,b);
l=strlen(a);
for(int i=0;i<l;i++)
if(a[i]=='1' &&a[i]==b[i]) ++n;
else if(a[i]=='1') ++m;
poly g(n+1,0);
for(int i=1;i<=n+1;i++) g[i]=C.ifac[i];
poly f(n+m,0); f[0]=1;
for(int b=m;b;b>>=1,g=(g*g).extend(n+m+1))
if(b&1) f=(f*g).extend(n+m+1);
int ans=0;
for(int i=m;i<=n+m;i++) {
int res=mul(mul(f[i],C.fac[i]),C.C(n+m,i));
res=mul(res,mul(C.fac[n+m-i],C.fac[n+m-i]));
res=mul(res,C.C(n,i-m));
res=mul(res,C.fac[i-m]);
ans=add(ans,res);
}
cout<<mul(ans,C.fac[m]);
} | 0 |
#include <bits/stdc++.h>
int n, fac[1000005], inv[1000005], ans;
int qpow(int a, long long b) {
int s = 1;
for (; b; b >>= 1, a = 1ll * a * a % 998244353)
if (b & 1) s = 1ll * s * a % 998244353;
return s;
}
int C(int n, int m) {
return 1ll * fac[n] * inv[n - m] % 998244353 * inv[m] % 998244353;
}
int add(int x, int y) { return (x += y) >= 998244353 ? x -= 998244353 : x; }
int sub(int x, int y) { return (x -= y) < 0 ? x += 998244353 : x; }
int main() {
scanf("%d", &n), fac[0] = 1;
for (register int i = 1; i <= n; ++i)
fac[i] = 1ll * fac[i - 1] * i % 998244353;
inv[n] = qpow(fac[n], 998244353 - 2);
for (register int i = n; i; --i) inv[i - 1] = 1ll * inv[i] * i % 998244353;
ans = sub(qpow(3, 1ll * n * n), qpow(sub(qpow(3, n), 3), n));
for (register int i = 1; i <= n; ++i) {
int s =
1ll * C(n, i) *
add(3ll * qpow(qpow(3, n - i) - 1, n) % 998244353,
1ll * sub(qpow(3, i), 3) * qpow(3, 1ll * n * (n - i)) % 998244353) %
998244353;
if (i & 1)
ans = add(ans, s);
else
ans = sub(ans, s);
}
printf("%d\n", ans);
}
| 3 |
#include <cstdio>
#include <algorithm>
#include <vector>
#include <set>
#define debug(...) fprintf(stderr, __VA_ARGS__)
typedef long long ll;
struct {
inline operator int () { int x; return scanf("%d", &x), x; }
} read;
const int maxn = 200005, mod = 998244353;
std::vector<int> G[maxn];
int sg[3][maxn];
ll f[3][maxn];
ll po[maxn * 3];
int main () {
int n = read, len = 1;
while (len < n)
len <<= 1;
po[0] = 1;
ll bs = 1000000000000000000ll % mod;
for (int i = 1; i <= n * 3; i ++)
po[i] = po[i - 1] * bs % mod;
for (int o = 0; o < 3; o ++) {
int m = read;
for (int i = 1; i <= n; i ++)
G[i].clear();
for (int i = 1; i <= m; i ++) {
int u = read, v = read;
if (u < v) G[u].push_back(v);
if (v < u) G[v].push_back(u);
}
for (int i = n; i; i --) {
std::set<int> mex;
for (int j : G[i])
mex.insert(sg[o][j]);
while (mex.count(sg[o][i]))
++ sg[o][i];
}
for (int i = 1; i <= n; i ++)
(f[o][sg[o][i]] += po[i]) %= mod;
}
ll ans = 0;
for (int i = 0; i < 500; i ++)
for (int j = 0; j < 500; j ++)
(ans += f[0][i] * f[1][j] % mod * f[2][i ^ j]) %= mod;
printf("%lld\n", ans);
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define r(i, n) for(int i=0;i<n;i++)
int main() {
int n;
cin >> n;
vector<int> v(n);
r(i, n) cin >> v[i];
int q, x, p;
cin >> q;
while (q--) {
cin >> x;
p = lower_bound(v.begin(), v.end(), x) - v.begin();
cout << p << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 1e17;
const int mod = 998244353;
const long long int N = 600032LL;
long long int fac[N + 2];
long long int inv[N + 2];
long long int add(long long int a, long long int b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
return a;
}
long long int mul(long long int a, long long int b) {
return ((a)*1LL * (b)) % mod;
}
long long int power(long long int a, long long int n) {
long long int res = 1;
while (n) {
if (n & 1) {
res = mul(res, a);
}
n >>= 1, a = mul(a, a);
}
return res;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
vector<long long int> ad[200003];
for (long long int i = 0; i < n; i++) {
ad[1].push_back(1);
long long int op = v[i];
for (int j = 2; j * j <= v[i]; j++) {
if (op % j == 0) {
long long int p = 0;
while (op % j == 0) p++, op /= j;
ad[j].push_back(p);
}
}
if (op > 1) ad[op].push_back(1);
}
long long int ans = 1;
for (int i = 0; i < 200001; i++) {
sort((ad[i]).begin(), (ad[i]).end());
if ((int)ad[i].size() == n) {
ans *= pow(i, ad[i][0]);
ans *= pow(i, ad[i][1] - ad[i][0]);
}
if ((int)ad[i].size() == n - 1) {
ans *= pow(i, ad[i][0]);
}
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
for (int _ = 0; _ < t; _++) {
solve();
}
return 0;
}
| 1 |
#include "bits/stdc++.h"
#define REP(i,n) for(ll i=0;i<ll(n);++i)
#define RREP(i,n) for(ll i=ll(n)-1;i>=0;--i)
#define FOR(i,m,n) for(ll i=m;i<ll(n);++i)
#define RFOR(i,m,n) for(ll i=ll(n)-1;i>=ll(m);--i)
#define ALL(v) (v).begin(),(v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)),v.end());
#define DUMP(v) REP(aa, (v).size()) { cout << v[aa]; if (aa != v.size() - 1)cout << " "; else cout << endl; }
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
const int dx[8] = { 1,1,0,-1,-1,-1,0,1 };
const int dy[8] = { 0,1,1,1,0,-1,-1,-1 };
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll max(ll a, int b) { return max(a, ll(b)); }
ll max(int a, ll b) { return max(ll(a), b); }
ll min(ll a, int b) { return min(a, ll(b)); }
ll min(int a, ll b) { return min(ll(a), b); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vi v(n);
REP(i, n)cin >> v[i];
int p = -1;
vi a;
vi ans;
REP(i, n) {
if (v[i] == 2)ans.push_back(i);
if (v[i] == -2)a.push_back(i);
if (v[i] == -1 && p == -1)p = i;
}
if (a.size() % 2 == 1) {
if (p != -1) {
REP(i, a.size())ans.push_back(a[i]);
ans.push_back(p);
}
else {
REP(i, a.size() - 1)ans.push_back(a[i]);
}
}
else {
REP(i, a.size())ans.push_back(a[i]);
}
sort(ALL(ans));
cout << ans.size() << endl;
REP(i, ans.size()) {
cout << ans[i]+1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, q, x, y, parent, max_val, max_node, query, max_len;
list<long long> vec[300005];
long long visited[300005];
struct pend {
long long ff, ss;
};
pend p[300005];
int find(int x) {
if (p[x].ff != x) p[x].ff = find(p[x].ff);
return p[x].ff;
}
void dfs(int node, int d, int t) {
if (d > max_val) {
max_val = d, max_node = node;
}
visited[node] = t;
p[node].ff = parent;
list<long long>::iterator it;
for (it = vec[node].begin(); it != vec[node].end(); it++) {
if (visited[*it] != t) {
dfs(*it, d + 1, t);
}
}
}
void uni(int a, int b) {
int xparent = find(a);
int yparent = find(b);
if (xparent == yparent) return;
long long len = (p[xparent].ss + 1) / 2 + (p[yparent].ss + 1) / 2 + 1;
max_len = max(len, max(p[xparent].ss, p[yparent].ss));
p[xparent].ff = yparent;
p[yparent].ss = max_len;
}
int main() {
scanf("%lld %lld %lld", &n, &m, &q);
for (int i = 0; i <= n; i++) {
p[i].ff = i;
p[i].ss = 0;
}
for (int i = 0; i < m; i++) {
scanf("%lld %lld", &x, &y);
vec[x].push_back(y);
vec[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (visited[i]) continue;
parent = i;
max_val = -1;
dfs(i, 0, 1);
max_val = -1;
dfs(max_node, 0, 2);
p[i].ss = max_val;
}
for (int i = 0; i < q; i++) {
cin >> query;
if (query == 1) {
scanf("%lld", &x);
y = find(x);
cout << p[y].ss << endl;
} else {
scanf("%lld %lld", &x, &y);
uni(x, y);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
long long dp[2007][1007];
int main() {
int n;
scanf("%d", &n);
dp[0][0] = 1;
long long ans = 0;
for (int i = 1; i <= 2 * n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = ((dp[i][j] + dp[i - 1][j + 1]) % 1000000007);
if (i + j <= 2 * n) {
dp[i][j] = ((dp[i][j] + dp[i - 1][j - 1]) % 1000000007);
}
if (i & 1) ans = ((ans + dp[i][j]) % 1000000007);
}
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <stdio.h>
int H, W, R, C; char s[1001][1007], t[1001][1007];
unsigned long long pw1, pw2, h1[1001][1007], h2[1001][1007], h3[1001];
int main() {
scanf("%d%d", &H, &W);
for(int i = 0; i < H; i++) scanf("%s", s[i]);
scanf("%d%d", &R, &C); pw1 = 1, pw2 = 1;
for(int i = 0; i < R; i++) scanf("%s", t[i]), pw2 *= 1000000007;
for(int i = 0; i < C; i++) pw1 *= 257;
for(int i = 0; i < H; i++) {
unsigned long long w = 0;
for(int j = 0; j < C; j++) w = w * 257 + s[i][j]; h1[i][0] = w;
for(int j = C; j < W; j++) w = w * 257 + s[i][j] - pw1 * s[i][j - C], h1[i][j - C + 1] = w;
}
for(int i = 0; i <= W - C; i++) {
unsigned long long w = 0;
for(int j = 0; j < R; j++) w = w * 1000000007 + h1[j][i]; h2[0][i] = w;
for(int j = R; j < H; j++) w = w * 1000000007 + h1[j][i] - pw2 * h1[j - R][i], h2[j - R + 1][i] = w;
}
for(int i = 0; i < R; i++) {
for(int j = 0; j < C; j++) h3[i] = h3[i] * 257 + t[i][j];
}
unsigned long long h4 = 0;
for(int i = 0; i < R; i++) h4 = h4 * 1000000007 + h3[i];
for(int i = 0; i <= H - R; i++) {
for(int j = 0; j <= W - C; j++) {
if(h2[i][j] == h4) printf("%d %d\n", i, j);
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> vals(n);
int firstone = -1;
int currentone = -1;
for (int i = 0; i < n; i++) {
cin >> vals[i];
if (vals[i] == 1) {
if (firstone == -1) firstone = i;
currentone = i;
}
}
int cntzero = 0;
if (firstone == -1) {
cout << "0\n";
} else {
for (int i = firstone; i <= currentone; i++) {
if (vals[i] == 0) {
cntzero++;
}
}
cout << cntzero << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, q, sq, nr;
vector<int> m[100010];
int dist1[100010];
int dist[100010];
bitset<100010> viz;
vector<int> c;
queue<int> c2;
int nivel[200010];
int noduri[200010];
int poz[200010];
int put[25];
int lg[200010];
int rmq[200010][23];
pair<int, int> quers[100010];
void liniarize(int nod, int level) {
viz[nod] = 1;
noduri[++nr] = nod;
nivel[nr] = level;
if (poz[nod] == 0) poz[nod] = nr;
for (vector<int>::iterator it = m[nod].begin(); it != m[nod].end(); it++)
if (!viz[*it]) {
liniarize(*it, level + 1);
noduri[++nr] = nod;
nivel[nr] = level;
}
}
int min1(int a, int b) {
if (nivel[a] <= nivel[b])
return a;
else
return b;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> q;
sq = sqrt(q);
int i, j, a, b;
for (i = 1; i < n; i++) {
cin >> a >> b;
m[a].push_back(b);
m[b].push_back(a);
}
for (i = 1; i <= q; i++) {
cin >> a >> b;
quers[i] = make_pair(a, b);
}
liniarize(1, 0);
put[0] = 1;
for (i = 1; i <= 20; i++) put[i] = 2 * put[i - 1];
for (i = 2; i <= nr; i++) lg[i] = lg[i / 2] + 1;
for (i = 1; i <= nr; i++) rmq[i][0] = i;
for (j = 1; put[j] <= nr; j++)
for (i = 1; i + put[j] - 1 <= nr; i++)
rmq[i][j] = min1(rmq[i][j - 1], rmq[i + put[j - 1]][j - 1]);
int len, crt, rosu, l, sol, aux;
c2.push(1);
viz.reset();
while (!c2.empty()) {
crt = c2.front();
c2.pop();
viz[crt] = 1;
for (i = 0; i < m[crt].size(); i++)
if (!viz[m[crt][i]]) {
dist1[m[crt][i]] = dist1[crt] + 1;
c2.push(m[crt][i]);
}
}
c.push_back(1);
dist[1] = -1;
j = 1;
while (1) {
len = c.size();
while (!c2.empty()) c2.pop();
viz.reset();
for (i = 0; i < len; i++) {
crt = c[i];
viz[crt] = 1;
for (l = 0; l < m[crt].size(); l++)
if (!viz[m[crt][l]] && dist[m[crt][l]] != -1) {
dist[m[crt][l]] = 1;
viz[m[crt][l]] = 1;
c2.push(m[crt][l]);
}
}
while (!c2.empty()) {
crt = c2.front();
c2.pop();
for (l = 0; l < m[crt].size(); l++)
if (!viz[m[crt][l]]) {
if (dist[m[crt][l]] != 0)
dist[m[crt][l]] = min(dist[m[crt][l]], dist[crt] + 1);
else
dist[m[crt][l]] = dist[crt] + 1;
viz[m[crt][l]] = 1;
c2.push(m[crt][l]);
}
}
rosu = 0;
for (i = j; i < j + sq; i++) {
if (i > q) return 0;
if (quers[i].first == 1) {
c.push_back(quers[i].second);
dist[quers[i].second] = -1;
rosu++;
} else {
a = quers[i].second;
sol = dist[a];
for (l = len; l < c.size(); l++) {
int a1 = poz[a], b1 = poz[c[l]];
if (a1 > b1) {
aux = a1;
a1 = b1;
b1 = aux;
}
int l1 = lg[b1 - a1 + 1];
sol = min(sol, dist1[a] + dist1[c[l]] -
2 * dist1[noduri[min1(
rmq[a1][l1], rmq[b1 - put[l1] + 1][l1])]]);
}
if (sol == -1)
cout << "0\n";
else
cout << sol << '\n';
}
}
j += sq;
}
return 0;
}
| 5 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <cmath>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
const int INF = 1e9;
const int MAX_N = 3010, MAX_E = 10000;
int n, m; //????????° ???????????¬??°
vector<pair<int, int> > G[MAX_N];//??°???????????¨?????£??\????????? fi:to se:cost
int d[MAX_N]; //s?????????????????????
typedef pair<int, int> P;//first??????????????¢,second??????????????????
int k; vector<int> shop;//???????¨????
void dijkstra(void){
priority_queue<P, vector<P>, greater<P> > que;//first????°?????????????
rep(i, n)d[i] = INF;//?????????
//k????????????????????°????????????
for(auto i : shop){
d[i] = 0;
que.push(make_pair(0, i));
}
while(!que.empty()){
auto p = que.top(); que.pop();
int v = p.second;
if(d[v] < p.first) continue;
for(auto e : G[v]){//e.fi:??£??\??????????????????????????? e.se:?????????????????§????????????
if(d[e.first] > d[v] + e.second){//???????????¢?????´??°???????????¨???
d[e.first] = d[v] + e.second;
que.push(make_pair(d[e.first], e.first));
}
}
}
}
int main(void){
cin >> n >> m >> k;
rep(i, m){
int a, b, l; cin >> a >> b >> l;
a--; b--;
G[a].push_back(make_pair(b, l)); G[b].push_back(make_pair(a, l));
}
rep(i, k){
int s; cin >> s; s--;
shop.push_back(s);
}
dijkstra();//????????????????????????????°?????????????
//?????????????????¶????????????????°?????????????
double ans = 0.0;
//x-y???????????????????????????
rep(i, n) ans = max(ans, (double)d[i]);
//??????????????????????????¢????????¨???????????????????????¶???????????´?????????????????????????????¢?????????
for (int x = 0; x < n; ++x){
for(auto y : G[x]){
if(d[x] == 0 || d[y.first] == 0) continue;
double tmp = (d[x] + d[y.first] + y.second) / 2.0;//+1????????¨?????\??¨
ans = max(tmp, ans);
}
}
cout << round(ans) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
inline void fast_subset_zeta_transform(vector<T>& f) {
for (int i = 0, n = 31 - __builtin_clz((int)f.size()), MSK = 1 << n; i < n;
i++)
for (int msk = 0; msk < MSK; msk++)
if (msk >> i & 1) f[msk] += f[msk ^ 1 << i];
}
template <typename T>
inline void fast_subset_mobius_transform(vector<T>& f) {
for (int i = 0, n = 31 - __builtin_clz((int)f.size()), MSK = 1 << n; i < n;
i++)
for (int msk = 0; msk < MSK; msk++)
if (msk >> i & 1) f[msk] -= f[msk ^ 1 << i];
}
template <typename T>
inline void fast_superset_zeta_transform(vector<T>& f) {
for (int i = 0, n = 31 - __builtin_clz((int)f.size()), MSK = 1 << n; i < n;
i++)
for (int msk = 0; msk < MSK; msk++)
if (msk >> i & 1) f[msk ^ 1 << i] += f[msk];
}
void solve() {
int n;
cin >> n;
vector<ll> a;
for (int _ = 0; _ < n; _++) {
ll x;
cin >> x;
if (x != 0) a.push_back(x);
}
n = a.size();
if (n == 0) {
cout << 0;
return;
} else if (n == 1) {
cout << 1;
return;
}
const int MSK = 1 << n;
vector<ll> sum(MSK);
for (int i = 0; i < n; i++) {
sum[1 << i] = a[i];
}
fast_subset_zeta_transform(sum);
vector<bool> good(MSK);
int m = n / 2;
const int LO = 1 << m;
for (int hi = 0; hi < MSK; hi += LO) {
vector<ll> ds;
for (int sub = (hi - 1) & hi; sub >= 1; (sub -= 1) &= hi) {
ds.push_back(sum[sub] - sum[sub ^ hi]);
}
sort(ds.begin(), ds.end());
for (int lo = 0; lo < LO; lo++) {
int nodes = __builtin_popcount(hi | lo);
if ((sum[hi | lo] + nodes - 1) % 2 != 0) continue;
bool yes = false;
for (int sub = lo; sub >= 0; (sub -= 1) &= lo) {
ll d = sum[sub] - sum[sub ^ lo];
if (sub > 0 && sub < lo + hi && abs(d - sum[hi]) <= nodes - 1)
yes |= true;
if (sub < lo && sub + hi > 0 && abs(d + sum[hi]) <= nodes - 1)
yes |= true;
auto lb = lower_bound(ds.begin(), ds.end(), -d - (nodes - 1));
auto ub = upper_bound(ds.begin(), ds.end(), -d + (nodes - 1));
if (lb != ub) yes |= true;
if (yes) {
good[hi | lo] = true;
break;
}
if (sub == 0) break;
}
}
}
vector<int> dp(MSK, 0);
for (int msk = 1; msk < MSK; msk++) {
for (int sub = msk; sub >= 1; (sub -= 1) &= msk) {
dp[msk] = max(dp[msk], good[sub] + dp[msk ^ sub]);
}
}
cout << (n - dp[MSK - 1]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long i, i1, j, k, k1, t, n, m, res, flag[10], a, b, dist[300010];
string s;
char c[300010];
bool visited[300010];
vector<long long> adj[300010], st;
queue<long long> q;
long long pv(long long x) { return (x + n - 1) % n; }
long long nx(long long x) { return (x + 1) % n; }
char ot(char c) {
if (c == 'B')
return 'W';
else
return 'B';
}
void bfs() {
for (auto u : st) {
visited[u] = true;
dist[u] = 0;
q.push(u);
}
while (!q.empty()) {
long long s = q.front();
q.pop();
for (auto u : adj[s]) {
if (visited[u]) continue;
visited[u] = true;
dist[u] = dist[s] + 1;
c[u] = c[s];
q.push(u);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> s;
for (i = 0; i < n; i++) {
c[i] = s[i];
dist[i] = (long long)1e18;
if (s[i] == s[pv(i)] || s[i] == s[nx(i)]) st.push_back(i);
}
for (i = 0; i < n; i++) {
adj[i].push_back(pv(i));
adj[i].push_back(nx(i));
}
bfs();
for (i = 0; i < n; i++) {
if (dist[i] <= k)
cout << c[i];
else if (k % 2)
cout << ot(s[i]);
else
cout << s[i];
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char c[1001][1001], ctmp;
int n, m, dist[1001][1001], d, ans;
pair<int, int> tmp;
pair<int, int> S;
pair<int, int> E;
queue<pair<int, int> > q;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
dist[i][j] = -1;
ctmp = getchar();
if (ctmp == '\n') ctmp = getchar();
c[i][j] = ctmp;
if (ctmp == 'E') {
E.first = i, E.second = j;
} else if (ctmp == 'S') {
S.first = i, S.second = j;
}
}
}
q.push(make_pair(E.first, E.second));
dist[E.first][E.second] = 0;
while (q.size()) {
tmp = q.front();
q.pop();
if (tmp.first > 0 && dist[tmp.first - 1][tmp.second] == -1 &&
c[tmp.first - 1][tmp.second] != 'T') {
q.push(make_pair(tmp.first - 1, tmp.second));
dist[tmp.first - 1][tmp.second] = dist[tmp.first][tmp.second] + 1;
}
if (tmp.first + 1 < n && dist[tmp.first + 1][tmp.second] == -1 &&
c[tmp.first + 1][tmp.second] != 'T') {
q.push(make_pair(tmp.first + 1, tmp.second));
dist[tmp.first + 1][tmp.second] = dist[tmp.first][tmp.second] + 1;
}
if (tmp.second > 0 && dist[tmp.first][tmp.second - 1] == -1 &&
c[tmp.first][tmp.second - 1] != 'T') {
q.push(make_pair(tmp.first, tmp.second - 1));
dist[tmp.first][tmp.second - 1] = dist[tmp.first][tmp.second] + 1;
}
if (tmp.second + 1 < m && dist[tmp.first][tmp.second + 1] == -1 &&
c[tmp.first][tmp.second + 1] != 'T') {
q.push(make_pair(tmp.first, tmp.second + 1));
dist[tmp.first][tmp.second + 1] = dist[tmp.first][tmp.second] + 1;
}
}
d = dist[S.first][S.second];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dist[i][j] <= d && dist[i][j] != -1 && c[i][j] != 'E' &&
c[i][j] != 'S') {
ans += (c[i][j] - '0');
}
}
}
printf("%d", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, dir[200005];
long long cnt, le;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &dir[i]);
if (dir[i] == 0) le++;
}
for (int i = 0; i < n; i++) {
if (dir[i] == 1)
cnt += le;
else
le--;
}
printf("%I64d", cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
long long l, r;
cin >> T;
for (int i = 0; i < T; i++) {
cin >> l >> r;
cout << l << " " << 2 * l << endl;
}
return 0;
}
| 1 |
#include <stdio.h>
int main(void) {
int i, ans = 0, j, n;
while(scanf("%d", &n) != EOF) {
ans = 0;
for(i = 0; i * n < 600; ++i) ans += n * i * i * n * n;
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, m = 0, c = 0;
scanf("%d", &n);
while (n--) {
scanf("%d%d", &a, &b);
if (a > b) {
m++;
} else if (a < b) {
c++;
}
}
if (m > c) {
printf("Mishka");
} else if (m < c) {
printf("Chris");
} else {
printf("Friendship is magic!^^");
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int a,now,ans,n;
int main()
{
cin>>n;
for(int s=0;s<n;s++)
{
cin>>a;
if(a>now)ans=ans+a-now;
now=a;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 1e5, mod = 998244353;
int cnt[N], prim[N], miu[N], vis[N];
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return x;
}
inline int power(int a, int b) {
int res = 1;
b = (b % (mod - 1) + (mod - 1)) % (mod - 1);
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) res = 1ll * res * a % mod;
return res;
}
inline void prework() {
int cnt = 0;
miu[1] = 1;
for (int i = 2; i <= M; i++) {
if (!vis[i]) prim[++cnt] = i, miu[i] = -1;
for (int j = 1; j <= cnt && i * prim[j] <= M; j++) {
vis[i * prim[j]] = 1;
if (i % prim[j])
miu[i * prim[j]] = -miu[i];
else {
miu[i * prim[j]] = 0;
break;
}
}
}
}
int main() {
prework();
int n, a, b, ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) a = read(), b = read(), cnt[a] = b;
for (int d = 1; d <= M; d++) {
int res = 0, S = 0, s = 0, sum = 0, fp1, fp2;
for (int i = d; i <= M; i += d)
S = (S + cnt[i]) % (mod - 1), s = (s + cnt[i]) % mod;
fp1 = power(2, S - 2), fp2 = power(2, S - 3), s = (s - 2 + mod) % mod;
for (int i = d; i <= M; i += d)
res =
(res + 1ll * cnt[i] * i % mod * i % mod * (s + 1) % mod * fp1 % mod) %
mod;
for (int i = d; i <= M; i += d) sum = (sum + 1ll * i * cnt[i] % mod) % mod;
for (int i = d; i <= M; i += d)
res = (res + 1ll * cnt[i] * i % mod * (sum - i + mod) % mod * s % mod *
fp2 % mod) %
mod;
for (int i = d; i <= M; i += d)
res = (res + 1ll * cnt[i] * i % mod * (sum - i + mod) % mod * fp1 % mod) %
mod;
ans = (1ll * ans + res * miu[d] % mod + mod) % mod;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double d, l, v1, v2, ans;
cin >> d >> l >> v1 >> v2;
ans = (l - d) / (v1 + v2);
cout << fixed << setprecision(6) << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int M = 10001;
const int md = 1e9 + 7;
void add(int &x, int y) { x += y; while(x >= md) x -= md; if (x < 0) x += md; }
int n, k;
int f[N][M];
int pw[N];
int ans;
int main() {
scanf("%d %d", &n, &k);
pw[0] = 1; for (int i = 1; i < N; ++i) pw[i] = 1LL * pw[i-1] * (k + 1) % md;
f[n + 1][0] = 1;
for (int i = n; i >= 1; --i) {
for (int j = 0; j < M; ++j) if (f[i + 1][j]) {
for (int t = 0; t <= k; ++t) {
int cur = (t <= i ? (t + j) / i : 0);
add(f[i][j + cur], f[i + 1][j]);
add(ans, 1LL * (1LL * f[i + 1][j] * pw[i - 1] % md) * (t - cur) % md);
}
}
}
printf("%d\n", ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int A,B,C;
cin>>A>>B>>C;
C=min(C,A+B+1);
cout<<B+C;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, t;
cin >> t;
while (t--) {
scanf("%d", &n);
printf("%d\n", n);
}
}
| 1 |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define SIZE 1005
#define MAX 16
struct Edge{
Edge(int arg_word_id,int arg_loc,int arg_dist){
word_id = arg_word_id;
loc = arg_loc;
dist = arg_dist;
}
int word_id,loc,dist;
};
struct Info{
Info(int arg_word_id,int arg_loc,int arg_sum_dist){
word_id = arg_word_id;
loc = arg_loc;
sum_dist = arg_sum_dist;
}
bool operator<(const struct Info &arg) const{
return sum_dist > arg.sum_dist; //総距離の昇順(PQ)
}
int word_id,loc,sum_dist;
};
int N,AMBIGUOUS;
int min_dist[SIZE][MAX+1];
int LENGTH[SIZE];
char words[SIZE][MAX+1];
vector<Edge> G[SIZE][MAX+1];
int main(){
scanf("%d",&N);
AMBIGUOUS = N;
int length;
for(int i = 0; i < N; i++){
scanf("%s",words[i]);
for(length = 0; words[i][length] != '\0'; length++);
LENGTH[i] = length;
}
int from_length,match_length;
bool FLG;
for(int from = 0; from < N; from++){
for(int loc = 0; loc < LENGTH[from]; loc++){
for(int to = 0; to < N; to++){
if(from == to && loc == 0)continue;
from_length = LENGTH[from]-loc;
match_length = min(from_length,LENGTH[to]);
FLG = true;
for(int i = 0; i < match_length; i++){
if(words[from][loc+i] != words[to][i]){
FLG = false;
break;
}
}
if(!FLG)continue;
if(match_length == LENGTH[to] && loc+match_length == LENGTH[from]){ //両方ぴったり終わる
G[from][loc].push_back(Edge(AMBIGUOUS,0,LENGTH[to]));
}else{
if(from_length > match_length){
G[from][loc].push_back(Edge(from,loc+match_length,match_length));
}else{
G[from][loc].push_back(Edge(to,match_length,match_length));
}
}
}
}
}
for(int i = 0; i <= N; i++){
for(int k = 0; k < MAX; k++){
min_dist[i][k] = BIG_NUM;
}
}
priority_queue<Info> Q;
for(int i = 0; i < N; i++){
min_dist[i][0] = 0;
Q.push(Info(i,0,0));
}
int next_word_id,next_loc,next_dist;
while(!Q.empty()){
if(Q.top().sum_dist > min_dist[Q.top().word_id][Q.top().loc]){
Q.pop();
}else{
for(int i = 0; i < G[Q.top().word_id][Q.top().loc].size(); i++){
next_word_id = G[Q.top().word_id][Q.top().loc][i].word_id;
next_loc = G[Q.top().word_id][Q.top().loc][i].loc;
next_dist = Q.top().sum_dist+G[Q.top().word_id][Q.top().loc][i].dist;
if(min_dist[next_word_id][next_loc] > next_dist){
min_dist[next_word_id][next_loc] = next_dist;
Q.push(Info(next_word_id,next_loc,next_dist));
}
}
Q.pop();
}
}
if(min_dist[AMBIGUOUS][0] == BIG_NUM){
printf("0\n");
}else{
printf("%d\n",min_dist[AMBIGUOUS][0]);
}
return 0;
}
| 0 |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cctype>
#include<iostream>
#include<string>
#include<sstream>
#include<set>
#include<map>
#include<vector>
#include<algorithm>
#include<queue>
#include<utility>
using namespace std;
#define i64 long long int
int M;
int la;
struct pnt {
int x, y;
pnt() {}
pnt(int _x, int _y) { x = _x; y = _y; }
} a[303 * 303];
int mp[606][606];
void st() {
memset(mp, -1, sizeof(mp));
for (int i = 0; i < la; i++)
mp[a[i].x][a[i].y] = i;
}
bool exis(int x,int y) {
if (x < 0 || x > M || y < 0 || y > M)return false;
return mp[x][y] != -1;
}
int sum[606][606];
int Sum(int x, int y1, int y2) {
if (y2 > M)y2 = M;
if (y1 <= 0)return sum[x][y2];
return sum[x][y2] - sum[x][y1 - 1];
}
int main() {
int row, col; char s[999];
scanf("%d%d", &row, &col);
// row = col = 300;
for (int i = 0; i < row; i++){
scanf("%s", s);
for (int j = 0; j < col; j++) {
if (s[j] == '#') {
a[la++] = pnt(i + j, i + col - 1 - j);
}
}
}
M = row - 1 + col - 1;
i64 res = 0;
for (int run = 0; run < 2; run++) {
st();
for (int k = 1; k <= M; k++) {
for (int i = 0; i <= M; i++) {
for (int j = 0; j <= M; j++) {
sum[i][j] = j == 0 ? 0 : sum[i][j - 1];
if (exis(i, j) && exis(i, j + k))sum[i][j] ++;
}
}
for (int i = 0; i < la; i++) {
int X = a[i].x - k;
if (X >= 0) {
res += Sum(X, a[i].y - k, a[i].y);
}
X = a[i].x + k;
if (X <= M) {
res += Sum(X, a[i].y - k, a[i].y);
}
}
}
for (int i = 0; i < la; i++)swap(a[i].x, a[i].y);
}
st();
for (int i = 0; i < la; i++) {
for (int k = 1; k <= M; k++) {
int A = 0, B = 0;
if (exis(a[i].x + k, a[i].y))A++;
if (exis(a[i].x - k, a[i].y))A++;
if (exis(a[i].x, a[i].y + k))B++;
if (exis(a[i].x, a[i].y - k))B++;
res -= A * B;
}
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
struct Widget {
std::string name;
long long width, height;
Widget(const std::string& name, long long width, long long height)
: name(name), width(width), height(height) {}
~Widget() {}
virtual void calculateSize() {}
};
struct Box : public Widget {
int spacing, border;
std::vector<Widget*> children;
Box(const std::string& name) : Widget(name, 0, 0), spacing(0), border(0) {}
};
struct HBox : public Box {
HBox(const std::string& name) : Box(name) {}
virtual void calculateSize() {
if (children.empty()) {
width = 0;
height = 0;
return;
}
if (width == 0 && height == 0) {
for (std::vector<Widget*>::iterator i = children.begin();
i != children.end(); ++i) {
(*i)->calculateSize();
width += (*i)->width;
height = std::max(height, (*i)->height);
}
width += (children.size() - 1) * spacing + 2 * border;
height += 2 * border;
}
}
};
struct VBox : public Box {
VBox(const std::string& name) : Box(name) {}
virtual void calculateSize() {
if (children.empty()) {
width = 0;
height = 0;
return;
}
if (width == 0 && height == 0) {
for (std::vector<Widget*>::iterator i = children.begin();
i != children.end(); ++i) {
(*i)->calculateSize();
width = std::max(width, (*i)->width);
height += (*i)->height;
}
height += (children.size() - 1) * spacing + 2 * border;
width += 2 * border;
}
}
};
int main() {
int n;
std::cin >> n;
std::map<std::string, Widget*> map;
for (int i = 0; i < n; ++i) {
std::string s;
std::cin >> s;
if (s == "Widget") {
std::cin >> s;
std::string::size_type lparen = s.find("(");
std::string name = s.substr(0, lparen);
std::string::size_type comma = s.find(",", lparen + 1);
std::string::size_type rparen = s.find(")", comma + 1);
int width =
strtol(s.substr(lparen + 1, comma - lparen - 1).c_str(), 0, 10);
int height =
strtol(s.substr(comma + 1, rparen - comma - 1).c_str(), 0, 10);
map[name] = new Widget(name, width, height);
} else if (s == "VBox") {
std::cin >> s;
map[s] = new VBox(s);
} else if (s == "HBox") {
std::cin >> s;
map[s] = new HBox(s);
} else {
std::string::size_type dot = s.find(".");
std::string::size_type lparen = s.find("(", dot + 1);
std::string::size_type rparen = s.find(")", lparen + 1);
std::string name = s.substr(0, dot);
std::string method = s.substr(dot + 1, lparen - dot - 1);
if (method == "pack") {
std::string child = s.substr(lparen + 1, rparen - lparen - 1);
static_cast<Box*>(map[name])->children.push_back(map[child]);
} else if (method == "set_border") {
int border =
strtol(s.substr(lparen + 1, rparen - lparen - 1).c_str(), 0, 10);
static_cast<Box*>(map[name])->border = border;
} else if (method == "set_spacing") {
int spacing =
strtol(s.substr(lparen + 1, rparen - lparen - 1).c_str(), 0, 10);
static_cast<Box*>(map[name])->spacing = spacing;
}
}
}
for (std::map<std::string, Widget*>::iterator i = map.begin(); i != map.end();
++i) {
Widget* widget = (*i).second;
widget->calculateSize();
std::cout << widget->name << " " << widget->width << " " << widget->height
<< std::endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int k, len;
string str;
bool used[30];
int cnt;
int main() {
cin >> k >> str;
len = str.length();
for (int i = 0; i < len; i++)
if (str[i] != '?') used[str[i] - 'a'] = true;
for (int i = k - 1; i >= 0; i--) cnt += !used[i];
for (int i = 0; i < (len + 1) / 2; i++)
if (str[i] == '?' && str[len - i - 1] == '?') --cnt;
if (cnt > 0) {
puts("IMPOSSIBLE");
return 0;
}
for (int i = 0; i < (len + 1) / 2; i++)
if (str[i] != '?' && str[len - i - 1] != '?' &&
str[i] != str[len - i - 1]) {
puts("IMPOSSIBLE");
return 0;
}
for (int i = 0; i < len; i++) {
if (str[i] == '?') {
if (str[len - i - 1] == '?') {
if (cnt < 0) {
++cnt;
str[i] = 'a';
} else {
for (int j = 0; j < k; j++)
if (!used[j]) {
used[j] = true;
str[i] = 'a' + j;
break;
}
}
} else {
str[i] = str[len - i - 1];
}
}
}
cout << str << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char string_in_buffer[(int)260];
void fast_scan(int &first) { scanf("%d", &first); }
void fast_scan(long long &first) { scanf("%lld", &first); }
void fast_scan(unsigned long long &first) { scanf("%llu", &first); }
void fast_scan(double &first) { scanf("%lf", &first); }
void fast_scan(long double &first) { scanf("%Lf", &first); }
void fast_scan(char &first) {
scanf("%c", &first);
if (first == '\n') {
fast_scan(first);
}
}
void fast_scan(string &first) {
scanf("%s", string_in_buffer);
first = string(string_in_buffer);
}
template <class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &first : v) fast_scan(first);
}
void fast_print(const int &first) { printf("%d", first); }
void fast_print(const long long &first) { printf("%lld", first); }
void fast_print(const unsigned long long &first) { printf("%llu", first); }
void fast_print(const double &first) { printf("%.15lf", first); }
void fast_print(const long double &first) { printf("%.15Lf", first); }
void fast_print(const char &first) { printf("%c", first); };
void fast_print(const string &first) { printf("%s", first.c_str()); }
void fast_print(const char v[]) { fast_print((string)v); }
template <class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(' ');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print('\n');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const T &v) {
for (const auto &first : v) {
fast_print(first);
fast_print(' ');
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
void _print(deque<string>) {}
template <class T, class... Args>
void _print(deque<string> names, T kek, Args... args) {
if (!first_print) {
fast_print("\n");
} else {
first_print = false;
}
fast_print(names.front());
fast_print(" = ");
fast_print(kek);
names.pop_front();
_print(names, args...);
}
} // namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace typedefs {}
namespace numbers_operation {
template <class T>
T floor_mod(T a, T b) {
if (a % b == 0) return 0;
if (a >= 0 && b >= 0) return a % b;
if (a <= 0 && b <= 0) return a % b;
return abs(b) - (abs(a) % abs(b));
}
} // namespace numbers_operation
using namespace numbers_operation;
using namespace typedefs;
long long length(pair<long long, long long> p) {
return p.first * p.first + p.second * p.second;
}
long long operator^(pair<long long, long long> a,
pair<long long, long long> b) {
return a.first * b.second - a.second * b.first;
}
pair<long long, long long> operator+(pair<long long, long long> a,
pair<long long, long long> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
pair<long long, long long> operator-(pair<long long, long long> a,
pair<long long, long long> b) {
return make_pair(a.first - b.first, a.second - b.second);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
return gcd(b % a, a);
}
pair<long long, long long> zip(pair<long long, long long> p) {
long long g = gcd(p.first, p.second);
p.first /= g;
p.second /= g;
if (p.first < 0) {
p.first *= -1;
p.second *= -1;
}
return p;
}
signed main(signed argc, char *argv[]) {
long long queries;
cin, queries;
map<long long, multiset<pair<long long, long long>>> L;
map<pair<long long, long long>, long long> cnt;
map<pair<long long, long long>, long long> online;
long long pts = 0;
for (long long i = 0; i < (queries); i++) {
long long type;
cin, type;
pair<long long, long long> p;
cin, p;
if (type == 1) {
pts++;
for (pair<long long, long long> q : L[length(p)]) {
cnt[zip(p + q)]++;
}
L[length(p)].insert(p);
online[zip(p)]++;
} else if (type == 2) {
pts--;
L[length(p)].erase(L[length(p)].find(p));
for (pair<long long, long long> q : L[length(p)]) {
cnt[zip(p + q)]--;
}
online[zip(p)]--;
} else if (type == 3) {
smart_io::precall_print();
cout, pts - 2 * cnt[zip(p)] - online[zip(p)];
}
}
}
| 6 |
#include <iostream>
#include <complex>
#include <cmath>
using namespace std;
typedef complex<double> C;
#define EPS (1e-8)
#define EQ(a,b) (abs((a)-(b)) < EPS)
double dot(C a, C b) {
return a.real() * b.real() + a.imag() * b.imag();
}
double xa, ya, xb, yb, xc, yc, xd, yd;
void solve() {
C a(xa, ya), b(xb, yb), c(xc, yc), d(xd, yd);
if (EQ(dot(a-b, c-d), 0.0)) {
cout<<"YES";
} else {
cout<<"NO";
}
cout<<endl;
}
int main(int argc, const char *argv[]) {
while (cin>>xa>>ya>>xb>>yb>>xc>>yc>>xd>>yd) {
solve();
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int i,j,n,x,mx=0,a;
map<int,int>m;
int main()
{
cin>>n;
for(j=1;j<=n;j++)
{cin>>x;
for(i=2;i*i<=x;i++)
{
a=0;
while(x%i==0)
{x/=i;
if(!a){
m[i]++;a++;}
mx=max(m[i],mx);
}
}
if(x!=1){m[x]++;mx=max(m[x],mx);}
}
if(mx==1||mx==0)cout<<"pairwise coprime";
else if(mx<n)cout<<"setwise coprime";
else cout<<"not coprime";
} | 0 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
priority_queue<int>q;
ll sum;
int m,n,x;
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>x;
q.push(x);
}
while(m){
x=q.top()/2;
q.pop();
q.push(x);
m--;
}
while(!q.empty()){
sum+=q.top();
q.pop();
}
cout<<sum;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
const long double PI = 3.141592653589793238462643383279502884197;
priority_queue<int, vector<int>, greater<int> > pq;
vector<int> v;
pair<int, int> a[300000];
pair<int, int> b[300000];
multiset<int> aa, bb;
int tree[1048576];
int val[300000];
int szz;
int find(int i, int l, int r, int le, int ri) {
if (le > r || ri < l) return 0;
if (le >= l && ri <= r) return tree[i];
return max(find(i * 2, l, r, le, (le + ri) / 2),
find(i * 2 + 1, l, r, (le + ri) / 2 + 1, ri));
}
void update(int i, int val) {
i += szz;
tree[i] += val;
i /= 2;
while (i) {
tree[i] = max(tree[i * 2], tree[i * 2 + 1]);
i /= 2;
}
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
aa.clear();
bb.clear();
int n;
scanf("%d", &n);
szz = 1;
while (szz < n) szz *= 2;
memset(tree, 0, sizeof(int) * szz * 2);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
aa.insert(a[i].first);
a[i].second = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i].first);
bb.insert(b[i].first);
b[i].second = i;
}
if (aa != bb) {
printf("NO\n");
continue;
}
sort(a, a + n, greater<pair<int, int> >());
sort(b, b + n, greater<pair<int, int> >());
int flag = 0;
for (int i = 0; i < n; i++) {
val[i] = find(1, 0, b[i].second, 0, szz - 1);
update(b[i].second, a[i].second);
if (val[i] > a[i].second) {
printf("NO\n");
flag = 1;
break;
}
}
if (!flag) printf("YES\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &_p) {
return os << "(" << _p.first << "," << _p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &_V) {
bool f = true;
os << "[";
for (auto v : _V) {
os << (f ? "" : ",") << v;
f = false;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &_S) {
bool f = true;
os << "(";
for (auto s : _S) {
os << (f ? "" : ",") << s;
f = false;
}
return os << ")";
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &_M) {
return os << set<pair<T, U>>(_M.begin(), _M.end());
}
const signed long long INF = 1000000100;
const long double EPS = 1e-9;
inline int pop2(unsigned x, unsigned y) {
x = x - ((x >> 1) & 0x55555555);
y = y - ((y >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
y = (y & 0x33333333) + ((y >> 2) & 0x33333333);
x = (x + (x >> 4)) & 0x0F0F0F0F;
y = (y + (y >> 4)) & 0x0F0F0F0F;
x = x + (x >> 8);
y = y + (y >> 8);
x = x + (x >> 16);
y = y + (y >> 16);
return (x + y) & 0x000000FF;
}
inline int pop(signed long long a) { return pop2(a << 32 >> 32, a >> 32); }
struct bits {
vector<signed long long> data;
int size;
bits(int n) {
data.resize((n + 63) / 64, 0);
size = n;
}
void set(int k) { data[k / 64] |= (1LL << (k % 64)); }
template <typename T>
bits(T bs) : bits(int(bs.size())) {
int bucket = 0;
int bit_id = 0;
for (bool b : bs) {
if (b) {
data[bucket] |= (1LL << bit_id);
}
++bit_id;
if (bit_id == 64) {
++bucket;
bit_id = 0;
}
}
}
int popcount() {
int ret = 0;
for (signed long long a : data) {
ret += __builtin_popcountll(a);
}
return ret;
}
friend ostream &operator<<(ostream &os, const bits &bs) {
int id = 0;
for (signed long long bucket : bs.data) {
for (int(i) = (0); (i) < (64); (i)++) {
if (id++ < bs.size) {
if (((1LL << i) & bucket) != 0) {
os << 1;
} else {
os << 0;
}
}
}
}
return os;
}
};
template <typename F>
bits binary_bits_op(const bits &p, const bits &q, F f) {
const bits &x = (p.size < q.size) ? q : p;
const bits &y = (p.size < q.size) ? p : q;
bits ret = x;
for (int(i) = (0); (i) < (int(y.data.size())); (i)++) {
ret.data[i] = f(ret.data[i], y.data[i]);
}
return move(ret);
}
bits operator|(const bits &p, const bits &q) {
return binary_bits_op(
p, q, [](signed long long a, signed long long b) { return a | b; });
}
bits operator&(const bits &p, const bits &q) {
return binary_bits_op(
p, q, [](signed long long a, signed long long b) { return a & b; });
}
bits operator^(const bits &p, const bits &q) {
return binary_bits_op(
p, q, [](signed long long a, signed long long b) { return a ^ b; });
}
int collide(const bits &p, const bits &q) {
const bits &x = (p.size < q.size) ? q : p;
const bits &y = (p.size < q.size) ? p : q;
int ret = 0;
for (int(i) = (0); (i) < (int(y.data.size()) - 1); (i)++) {
int d = pop(x.data[i] | y.data[i]);
if (d < 64) {
return 0;
} else {
ret += d;
}
}
return ret + pop(x.data.back() | y.data.back());
}
const int MAXN = 2525;
int A[MAXN][MAXN];
int N;
void read_data() {
scanf("%d", &N);
for (int(i) = (1); (i) <= (N); (i)++)
for (int(j) = (1); (j) <= (N); (j)++) {
scanf("%d", &A[i][j]);
}
}
bool solve() {
for (int(i) = (1); (i) <= (N); (i)++)
for (int(j) = (1); (j) <= (N); (j)++)
if (A[i][j] != A[j][i]) {
return false;
}
for (int(i) = (1); (i) <= (N); (i)++)
if (A[i][i] != 0) {
return false;
}
vector<tuple<int, int, int>> edges;
for (int(i) = (1); (i) <= (N); (i)++)
for (int(j) = (i + 1); (j) <= (N); (j)++) {
edges.emplace_back(A[i][j], i, j);
}
sort(edges.begin(), edges.end());
reverse(edges.begin(), edges.end());
vector<bits> first(N, bits(N));
for (int(i) = (0); (i) < (int(edges.size())); (i)++) {
int j = i;
while (j + 1 < int(edges.size()) and
get<0>(edges[j + 1]) == get<0>(edges[j])) {
++j;
}
for (int(k) = (i); (k) <= (j); (k)++) {
int w, a, b;
tie(w, a, b) = edges[k];
first[a - 1].set(b - 1);
first[b - 1].set(a - 1);
}
for (int(k) = (i); (k) <= (j); (k)++) {
int w, a, b;
tie(w, a, b) = edges[k];
if (collide(first[a - 1], first[b - 1]) < N) {
return false;
}
}
i = j;
}
return true;
}
int main() {
read_data();
printf(solve() ? "MAGIC\n" : "NOT MAGIC\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int pod = (1 << 17);
const int nax = 100111;
int n, m, X;
int a[nax];
int type, l, r;
struct node {
long long ans = 0;
vector<pair<int, int>> pref, suf;
node() {
ans = 0;
pref.clear();
suf.clear();
}
} t[2 * pod];
node lacz(const node a, const node b) {
node c = node();
c.ans = a.ans + b.ans;
int wsk = (int)b.pref.size() - 1;
int sum = 0;
if ((int)b.pref.size()) sum = b.pref.back().second;
for (int i = 0; i < (int)a.suf.size(); ++i) {
while (wsk > 0 && (a.suf[i].first | b.pref[wsk - 1].first) >= X) {
wsk -= 1;
sum += b.pref[wsk].second;
}
if (wsk >= 0 && (a.suf[i].first | b.pref[wsk].first) >= X)
c.ans += (long long)a.suf[i].second * sum;
}
int val = -1;
int ile = 0;
for (auto it : a.pref) {
if (val != -1 && (val | it.first) != val) {
c.pref.push_back(make_pair(val, ile));
ile = 0;
}
val = max(val, 0);
val |= it.first;
ile += it.second;
}
for (auto it : b.pref) {
if (val != -1 && (val | it.first) != val) {
c.pref.push_back(make_pair(val, ile));
ile = 0;
}
val |= it.first;
ile += it.second;
}
c.pref.push_back(make_pair(val, ile));
val = -1;
ile = 0;
for (auto it : b.suf) {
if (val != -1 && (val | it.first) != val) {
c.suf.push_back(make_pair(val, ile));
ile = 0;
}
val = max(val, 0);
val |= it.first;
ile += it.second;
}
for (auto it : a.suf) {
if (val != -1 && (val | it.first) != val) {
c.suf.push_back(make_pair(val, ile));
ile = 0;
}
val |= it.first;
ile += it.second;
}
c.suf.push_back(make_pair(val, ile));
return c;
}
void mod(int x, int c) {
x += pod;
t[x].pref.clear();
t[x].suf.clear();
t[x].ans = (c >= X);
t[x].pref.push_back(make_pair(c, 1));
t[x].suf.push_back(make_pair(c, 1));
x /= 2;
while (x) {
t[x] = lacz(t[2 * x], t[2 * x + 1]);
x /= 2;
}
}
node query(int x, int y, int u = 1, int l = 0, int r = pod - 1) {
if (x <= l && r <= y) return t[u];
int m = (l + r) / 2;
node res = node();
if (x <= m) res = query(x, y, 2 * u, l, m);
if (m < y) res = lacz(res, query(x, y, 2 * u + 1, m + 1, r));
return res;
}
int main() {
scanf("%d %d %d", &n, &m, &X);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= 2 * pod - 1; ++i) t[i] = node();
for (int i = 1; i <= n; ++i) mod(i, a[i]);
while (m--) {
scanf("%d %d %d", &type, &l, &r);
if (type == 1)
mod(l, r);
else {
printf("%lld\n", query(l, r).ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[300000 + 5];
long long b[300000 + 5];
long long sum[300000 + 5];
long long even[300000 + 5], odd[300000 + 5];
long long find(long long x) {
long long y = 0;
while (x) {
if (x & 1) y++;
x >>= 1;
}
return y;
}
void readin() {
scanf("%I64d", &n);
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
b[i] = find(a[i]);
}
}
int main() {
readin();
for (long long i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + b[i];
}
for (long long i = 1; i <= n; i++) {
odd[i] = odd[i - 1], even[i] = even[i - 1];
if (sum[i] & 1)
odd[i]++;
else
even[i]++;
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (sum[i - 1] & 1)
ans += odd[n] - odd[i - 1];
else
ans += even[n] - even[i - 1];
}
for (long long i = 1; i <= n; i++) {
long long m = min(n, i + 64);
long long maxb = b[i], s = 0;
for (long long j = i; j <= m; j++) {
maxb = max(maxb, b[j]);
s += b[j];
if (2 * maxb > s && (s & 1) == 0) ans--;
}
}
printf("%I64d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool rd(T &num) {
char in;
bool IsN = false;
while (in = getchar(), in != '-' && (in < '0' || in > '9'))
if (in == EOF) return false;
in == '-' ? (IsN = true, num = 0) : num = in - '0';
while (in = getchar(), in >= '0' && in <= '9') num = num * 10 + in - '0';
return IsN ? num = -num : num, true;
}
template <class T, class S>
inline bool rd(T &num1, S &num2) {
return rd(num1) && rd(num2);
}
template <class T, class S, class Z>
inline bool rd(T &num1, S &num2, Z &num3) {
return rd(num1) && rd(num2) && rd(num3);
}
template <class T>
inline void _wr(T num) {
if (num > 9) _wr(num / 10);
putchar('0' + num % 10);
}
template <class T>
inline void wt(T num) {
if (num < 0) putchar('-'), num = -num;
_wr(num);
}
string nico = "NicoNicoNi";
const int maxn = 5e6 + 7;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int none = -1;
const long long linf = (long long)inf << 32 | inf;
char now[maxn];
int trie[maxn][2], fa[maxn], signs[maxn], cnt = 0;
vector<long long> ans;
bool ok = true;
void insert(int len, long long id, int sign) {
int rt = 0;
for (register int(i) = (32); (i) >= (32 - len); --(i)) {
int nxt = (id >> i) & 1;
if (!trie[rt][nxt]) {
trie[rt][nxt] = ++cnt;
fa[cnt] = rt;
}
rt = trie[rt][nxt];
}
if (signs[rt] == -1 * sign) ok = false;
signs[rt] = sign;
return;
}
void read() {
scanf("%s", now);
int sign = now[0] == '-' ? -1 : 1;
long long a, b, c, d, x = 32;
sscanf(now + 1, "%lld.%lld.%lld.%lld", &a, &b, &c, &d);
int len = strlen(now);
for (register int(i) = (0); (i) < (len); ++(i))
if (now[i] == '/') sscanf(now + i + 1, "%lld", &x);
long long id = (a << 24) + (b << 16) + (c << 8) + d;
insert(x, id, sign);
}
void getans(int rt, int len, long long id) {
if (signs[rt] == -1) {
ans.push_back(id);
ans.push_back(len);
return;
}
if (trie[rt][0]) getans(trie[rt][0], len + 1, id);
if (trie[rt][1]) getans(trie[rt][1], len + 1, id | (1ll << (31 - len)));
}
int main() {
int n;
rd(n);
for (register int(i) = (0); (i) < (n); ++(i)) read();
for (register int(i) = (0); (i) < (cnt + 1); ++(i)) {
if (signs[i] != -1) continue;
int rt = i;
while (fa[rt]) {
if (signs[fa[rt]] == 1) ok = false;
rt = fa[rt];
}
}
for (register int(i) = (0); (i) < (cnt + 1); ++(i)) {
if (signs[i] != 1) continue;
int rt = i;
while (fa[rt]) {
if (signs[fa[rt]] == -1)
ok = false;
else
signs[fa[rt]] = 1;
rt = fa[rt];
}
}
for (register int(i) = (0); (i) < (cnt + 1); ++(i)) {
if (signs[i] != -1) continue;
int rt = i;
while (fa[rt] && signs[fa[rt]] != 1) {
signs[rt] = 0;
signs[fa[rt]] = -1;
rt = fa[rt];
}
}
if (!ok) {
puts("-1");
} else {
getans(0, -1, 0);
printf("%d\n", ans.size() / 2);
for (int i = 0; i < ans.size(); i += 2) {
long long now = ans[i];
;
long long d = now & ((1 << 8) - 1);
now >>= 8;
long long c = now & ((1 << 8) - 1);
now >>= 8;
long long b = now & ((1 << 8) - 1);
now >>= 8;
long long a = now & ((1 << 8) - 1);
printf("%lld.%lld.%lld.%lld/%lld\n", a, b, c, d, ans[i + 1]);
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class DisjointSet {
public:
vector<int> father;
vector<int> rank;
vector<int> size;
DisjointSet(int n);
DisjointSet(){};
void inite(int n);
int find(int v);
void merge(int x, int y);
};
DisjointSet::DisjointSet(int n) : father(n), rank(n) {
size.resize(n, 1);
for (int i = 0; i < n; i++) {
father[i] = i;
}
}
void DisjointSet::inite(int n) {
size.resize(n, 1);
father.resize(n);
rank.resize(n, 0);
for (int i = 0; i < n; i++) {
father[i] = i;
size[i] = 1;
}
}
int DisjointSet::find(int v) {
return father[v] = father[v] == v ? v : find(father[v]);
}
void DisjointSet::merge(int x, int y) {
int a = find(x), b = find(y);
if (rank[a] < rank[b]) {
father[a] = b;
size[b] += size[a];
} else {
father[b] = a;
size[a] += size[b];
if (rank[b] == rank[a]) {
rank[a]++;
}
}
}
const int Max = 110000;
DisjointSet disj(Max);
vector<int> G[Max];
int visit[Max];
int in_set[Max];
int n, m;
int val[Max];
int su[Max];
bool comp(int a, int b) { return val[a] > val[b]; }
void input() {
memset(in_set, 0, sizeof(in_set));
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
su[i] = i;
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
sort(su + 1, su + n + 1, comp);
}
double solve() {
disj.inite(n + 1);
double ans = 0;
for (int i = 1; i <= n; i++) {
memset(visit, 0, sizeof(visit));
int u = su[i];
in_set[u] = 1;
for (int j = 0; j < (int)G[u].size(); j++) {
int v = G[u][j];
if (in_set[v] == 1) {
int t = disj.find(v);
if (visit[t] == 0) {
ans += (double)disj.size[t] * val[u] * disj.size[disj.find(u)];
if (ans < 0) cout << i << endl;
disj.merge(t, u);
visit[disj.find(t)] = 1;
}
}
}
}
return ans * 2;
}
int main() {
cin >> n >> m;
input();
double ans = solve();
ans = ans / n;
ans = ans / (n - 1);
printf("%.5lf", ans);
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
int main() {
cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);
int n; cin>>n;
string s; cin>>s; n--;
map<char,int> x;
for (char ch : s)
x[ch]++;
while(n-->0) {
cin>>s;
map<char,int> y;
for (char ch : s)
y[ch]++;
for (char ch='a'; ch<='z'; ch++)
x[ch]=min(x[ch],y[ch]);
}
for (char ch='a'; ch<='z'; ch++)
while(x[ch]-->0)
cout<<ch;
cout<<"\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
const long long oo = (long long)2 * 10e9;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, tmp_k = 0;
cin >> n >> k;
vector<vector<char>> v(n, vector<char>(n));
bool first_sea = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (first_sea) {
v[i][j] = j % 2 == 0 ? 'S' : 'L';
} else if (!first_sea) {
v[i][j] = j % 2 == 0 ? 'L' : 'S';
}
if (v[i][j] == 'L') tmp_k++;
}
first_sea = !first_sea;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (tmp_k > k) {
if (v[i][j] == 'L') {
tmp_k--;
v[i][j] = 'S';
}
} else {
break;
}
}
}
if (k == tmp_k) {
cout << "YES\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << v[i][j];
}
cout << "\n";
}
} else {
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005], cnt[1000005];
set<int> L, R;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, k, d;
cin >> n >> k >> d;
set<int> Set;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < d; i++) {
cnt[a[i]]++;
if (cnt[a[i]] == 1) Set.insert(a[i]);
}
int res = min(0x3f3f3f3f, (int)Set.size());
for (int i = d; i < n; i++) {
cnt[a[i]]++;
if (cnt[a[i]] == 1) Set.insert(a[i]);
cnt[a[i - d]]--;
if (cnt[a[i - d]] == 0)
Set.erase(a[i - d]), res = min(res, (int)Set.size());
}
int left = Set.size();
while (left--) {
cnt[*Set.begin()] = 0;
Set.erase(*Set.begin());
}
cout << res << endl;
}
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
using namespace std;
#define W 0
#define S 1
int C[101][101][2][2];
int main()
{
int w,h;
for(int i=1;i<101;++i)
{
C[i][1][S][0] = 0;
C[i][1][W][0] = 1;
C[i][1][S][1] = 0;
C[i][1][W][1] = 0;
C[1][i][S][0] = 1;
C[1][i][W][0] = 0;
C[1][i][S][1] = 0;
C[1][i][W][1] = 0;
}
for(int i=2;i<101;++i){
for(int j=2;j<101;++j){
C[i][j][W][0] = (C[i-1][j][W][0]+C[i-1][j][W][1])%100000;
C[i][j][S][0] = (C[i][j-1][S][0]+C[i][j-1][S][1])%100000;
C[i][j][W][1] = (C[i-1][j][S][0])%100000;
C[i][j][S][1] = (C[i][j-1][W][0])%100000;
}
}
while(cin >> w >> h && w && h)
{
cout << (C[w][h][W][0]+C[w][h][W][1]+C[w][h][S][0]+C[w][h][S][1])%100000 << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int DFSindex;
int num[100000];
int revnum[100000];
int low[100000];
int p[100000];
vector<pair<int, int> > bridges;
set<int> bridge[100000];
bool instack[100000];
vector<int> adj[100000];
int ncomponents;
int component[100000];
vector<int> adj2[100000];
int level[100000];
int treep[100000];
int LCAP[100000][17];
void tarjan(int v) {
num[v] = low[v] = DFSindex;
revnum[DFSindex] = v;
DFSindex++;
instack[v] = true;
for (int i = 0; i < adj[v].size(); i++) {
int n = adj[v][i];
if (num[n] == -1) {
p[n] = v;
tarjan(n);
low[v] = min(low[v], low[n]);
if (low[n] > num[v]) {
bridges.push_back(make_pair(v, n));
bridge[n].insert(v);
bridge[v].insert(n);
}
} else if (instack[n] && p[v] != n)
low[v] = min(low[v], num[n]);
}
instack[v] = false;
}
void dfs(int v, int label) {
component[v] = label;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if ((bridge[v].find(u) == bridge[v].end()) && component[u] == -1) {
dfs(u, label);
}
}
}
void dfs2(int v, int from) {
level[v] = (from == -1) ? 0 : (level[from] + 1);
treep[v] = from;
for (int i = 0; i < adj2[v].size(); i++) {
if (adj2[v][i] != from) {
dfs2(adj2[v][i], v);
}
}
}
void LCApreprocess() {
for (int i = 0; i < ncomponents; i++)
for (int j = 0; 1 << j < ncomponents; j++) LCAP[i][j] = -1;
for (int i = 0; i < ncomponents; i++) LCAP[i][0] = treep[i];
for (int j = 1; 1 << j < ncomponents; j++)
for (int i = 0; i < ncomponents; i++)
if (LCAP[i][j - 1] != -1) LCAP[i][j] = LCAP[LCAP[i][j - 1]][j - 1];
}
int LCA(int p, int q) {
int tmp, log, i;
if (level[p] < level[q]) tmp = p, p = q, q = tmp;
for (log = 1; 1 << log <= level[p]; log++)
;
log--;
for (i = log; i >= 0; i--)
if (level[p] - (1 << i) >= level[q]) p = LCAP[p][i];
if (p == q) return p;
for (i = log; i >= 0; i--)
if (LCAP[p][i] != -1 && LCAP[p][i] != LCAP[q][i])
p = LCAP[p][i], q = LCAP[q][i];
return treep[p];
}
int main() {
int n, m;
cin >> n >> m;
DFSindex = 0;
memset(num, -1, sizeof(int) * n);
memset(p, -1, sizeof(int) * n);
memset(instack, false, sizeof(bool) * n);
for (int i = 0; i < n; i++) {
adj[i] = vector<int>();
bridge[i] = set<int>();
}
for (int i = 0; i < m; i++) {
int src, dest;
cin >> src >> dest;
src--;
dest--;
adj[src].push_back(dest);
adj[dest].push_back(src);
}
tarjan(0);
ncomponents = 0;
memset(component, -1, sizeof(int) * n);
for (int i = 0; i < n; i++) {
if (component[i] == -1) {
dfs(i, ncomponents);
ncomponents++;
}
}
for (int i = 0; i < ncomponents; i++) {
adj2[i] = vector<int>();
}
for (int i = 0; i < bridges.size(); i++) {
int src = component[bridges[i].first];
int dest = component[bridges[i].second];
adj2[src].push_back(dest);
adj2[dest].push_back(src);
}
dfs2(0, -1);
LCApreprocess();
int k;
cin >> k;
for (int i = 0; i < k; i++) {
int src, dest;
cin >> src >> dest;
src--, dest--;
int a = component[src];
int b = component[dest];
int ancestor = LCA(a, b);
int ans = level[a] + level[b] - 2 * level[ancestor];
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000 + 10;
int inf = 0x3f3f3f3f;
int n, m, q;
int ans[400010];
int num[maxn];
int Instack[maxn];
int dfn[maxn];
int low[maxn];
int tot;
vector<int> edge[maxn];
struct query {
int s, t, k, id;
} Query[400010];
vector<int> temp[maxn];
vector<int> S[maxn];
void init() {
for (int i = 1; i <= n; i++) {
edge[i].clear();
S[i].clear();
}
memset(ans, -1, sizeof(ans));
}
void dfs(int u, int status, int depth) {
dfn[u] = ++tot;
low[u] = inf;
Instack[u] = 1;
num[depth] = u;
if (status) {
for (int i = 0; i < temp[u].size(); i++) {
int loc = temp[u][i];
int id = Query[loc].id;
int kk = Query[loc].k;
if (kk <= depth) ans[id] = num[kk];
}
}
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (dfn[v] == 0) {
dfs(v, status && dfn[u] < low[u], depth + 1);
low[u] = min(low[u], low[v]);
} else if (Instack[v] == 1) {
low[u] = min(low[u], dfn[v]);
}
}
Instack[u] = 0;
}
int main() {
while (~scanf("%d%d%d", &n, &m, &q)) {
init();
int u, v;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
sort(edge[i].begin(), edge[i].end());
}
int s, t, k;
for (int i = 1; i <= q; i++) {
scanf("%d%d%d", &s, &t, &k);
Query[i].s = s;
Query[i].t = t;
Query[i].k = k;
Query[i].id = i;
S[s].push_back(i);
}
for (int i = 1; i <= n; i++) {
memset(dfn, 0, sizeof(dfn));
memset(Instack, 0, sizeof(Instack));
for (int j = 1; j <= n; j++) temp[j].clear();
for (int j = 0; j < S[i].size(); j++) {
int loc = S[i][j];
int tt = Query[loc].t;
temp[tt].push_back(loc);
}
tot = 0;
dfs(i, 1, 1);
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define inf 1000000007LL
#define mod 1000000007LL
#define rep(i, n) for(int i = 0; i < (n); i++)
#define trep(i, n) for(int i = 0; i <= (n); i++)
#define rrep(i, n) for(int i = (n) - 1; i >= 0; i--)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define mfor(i, s, t) for(int i = (s); i < (t); i++)
#define tfor(i, s, t) for(int i = (s); i <= (t); i++)
#define rfor(i, s, t) for(int i = (t) - 1; i >= (s); i--)
int d[114];
int dp[55][114][114];
signed main() {
int n;
cin >> n;
rep(i, 2 * n - 1) {
cin >> d[i];
}
sort(d, d + 2 * n - 1);
rep(i, n) {
rep(j, 2 * n) {
rep(k, 2 * n) {
dp[i][j][k] = 0;
}
}
}
dp[0][1][0] = 1;
rep(i, n - 1) {
int p, a;
if(d[n - 1 - i] == d[n - 1 - i - 1]) {
p = 0;
}
else {
p = 1;
}
if(d[n - 1 + i] == d[n - 1 + i + 1]) {
a = 0;
}
else {
a = 1;
}
rep1(j, i * 2 + 1) {
rep(k, j) {
rep(_, j + p + a) {
if(_ < k + p) {
dp[i + 1][j + p + a - ((k + p) - _ - 1)][_] = (dp[i + 1][j + p + a - ((k + p) - _ - 1)][_] + dp[i][j][k]) % inf;
}
else if(_ == k + p) {
dp[i + 1][j + p + a][_] = (dp[i + 1][j + p + a][_] + dp[i][j][k]) % inf;
}
else {
dp[i + 1][j + p + a - (_ - (k + p) - 1)][k + p + 1] = (dp[i + 1][j + p + a - (_ - (k + p) - 1)][k + p + 1] + dp[i][j][k]) % inf;
}
}
}
}
}
int all = 0;
rep(j, 2 * n) {
rep(k, 2 * n) {
all = (all + dp[n - 1][j][k]) % inf;
}
}
cout << all << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
const int MAXN = 1e6 + 10;
void solve() {
int n, m, k;
cin >> n >> m >> k;
if (n % 2 == 0) {
cout << "Marsel\n";
return;
}
int mx = 1;
for (int i = 2; i * i <= m; i++) {
if (m % i == 0) {
mx = max(mx, m / i);
}
}
cout << (mx >= k && mx < m ? "Timur\n" : "Marsel\n");
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
| 3 |
# include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template<class T>constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template<class T>constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char>T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char>T_char TU(T_char cX) { return toupper(cX); };
const int vy[] = { -1, -1, -1, 0, 1, 1, 1, 0 }, vx[] = { -1, 0, 1, 1, 1, 0, -1, -1 };
const int dx[4] = { 0,1,0,-1 }, dy[4] = { 1,0,-1,0 };
int popcnt(unsigned long long n) { int cnt = 0; for (int i = 0; i < 64; i++)if ((n >> i) & 1)cnt++; return cnt; }
int d_sum(LL n) { int ret = 0; while (n > 0) { ret += n % 10; n /= 10; }return ret; }
int d_cnt(LL n) { int ret = 0; while (n > 0) { ret++; n /= 10; }return ret; }
LL gcd(LL a, LL b) { if (b == 0)return a; return gcd(b, a%b); };
LL lcm(LL a, LL b) { LL g = gcd(a, b); return a / g*b; };
# define ALL(qpqpq) (qpqpq).begin(),(qpqpq).end()
# define UNIQUE(wpwpw) sort(ALL((wpwpw)));(wpwpw).erase(unique(ALL((wpwpw))),(wpwpw).end())
# define LOWER(epepe) transform(ALL((epepe)),(epepe).begin(),TL<char>)
# define UPPER(rprpr) transform(ALL((rprpr)),(rprpr).begin(),TU<char>)
# define FOR(i,tptpt,ypypy) for(LL i=(tptpt);i<(ypypy);i++)
# define REP(i,upupu) FOR(i,0,upupu)
# define INIT std::ios::sync_with_stdio(false);std::cin.tie(0)
//定義系
double EPS = 1e-10;
//誤差を考慮して足し算を行う
double add(double a, double b) {
if (abs(a + b) < EPS*(abs(a) + abs(b)))return 0;
return a + b;
}
//Point
struct Point {
double x, y;
Point() {}
Point(double x, double y) :x(x), y(y) {
}
Point operator + (Point p) {
return Point(add(x, p.x), add(y, p.y));
}
Point operator - (Point p) {
return Point(add(x, -p.x), add(y, -p.y));
}
Point operator * (double d) {
return Point(x*d, y*d);
}
Point operator / (double d) {
return Point(x / d, y / d);
}
//内積
double dot(Point p) {
return add(x*p.x, y*p.y);
}
//外積
double det(Point p) {
return add(x*p.y, -y*p.x);
}
//点の大小比較
bool operator <(const Point &p)const {
if (fabs(add(x, -p.x)) < EPS)return y < p.y;
return x < p.x;
}
bool operator ==(const Point &p)const {
return fabs(x - p.x) < EPS&&fabs(y - p.y) < EPS;
}
};
//ベクトル。使い分けるといいかも
typedef Point Vector;
//ベクトルの大きさの2乗
double norm(Vector p) {
return p.x*p.x + p.y*p.y;
}
//ベクトルの大きさ
double abs(Vector p) {
return sqrt(norm(p));
}
//線分
struct Segment {
Point p1, p2;
Segment() {}
Segment(Point p1, Point p2) :p1(p1), p2(p2){}
double slope(){
if(p2 < p1)swap(p1, p2);
if(p1.x == p2.x){
return -1e-9;
}
return (p2.y - p1.y)/(p2.x - p1.x);
}
};
//線分集合
typedef vector<Segment> Segments;
//直線
typedef Segment Line;
//中心c,半径rの円
struct Circle {
Point c;
double r;
Circle(Point c = Point(), double r = 0.0) :c(c), r(r) {}
};
//多角形
typedef vector<Point> Polygon;
//頂点集合
typedef vector<Point> Points;
//計算・アルゴリズム系
//反時計回りCCW
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
int ccw(Point p0, Point p1, Point p2) {
Vector a = p1 - p0;
Vector b = p2 - p0;
if (a.det(b) > EPS)return COUNTER_CLOCKWISE;
if (a.det(b) < -EPS)return CLOCKWISE;
if (a.dot(b) < -EPS)return ONLINE_BACK;
if (norm(a) < norm(b))return ONLINE_FRONT;
return ON_SEGMENT;
}
//線分p1p2と線分p3p4の交差判定
bool intersect(Point p1, Point p2, Point p3, Point p4) {
return (ccw(p1, p2, p3)*ccw(p1, p2, p4) <= 0 && ccw(p3, p4, p1)*ccw(p3, p4, p2) <= 0);
}
bool intersectSS(Segment s1, Segment s2) {
return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
bool intersectLS(Line l, Segment s){
return ccw(l.p1, l.p2, s.p1)*ccw(l.p1, l.p2, s.p2) <= 0;
}
//直線
static const int ICC_SEPERATE = 4;
static const int ICC_CIRCUMSCRIBE = 3;
static const int ICC_INTERSECT = 2;
static const int ICC_INSCRIBE = 1;
static const int ICC_CONTAIN = 0;
//円と円の交差判定
int intersect(Circle c1, Circle c2) {
if (c1.r<c2.r) swap(c1, c2);
double d = abs(c1.c - c2.c);
double r = c1.r + c2.r;
if (d == r) return ICC_CIRCUMSCRIBE;
if (d>r) return ICC_SEPERATE;
if (d + c2.r== c1.r) return ICC_INSCRIBE;
if (d + c2.r<c1.r) return ICC_CONTAIN;
return ICC_INTERSECT;
}
//ベクトルa,bの直交判定
bool isOrthogonal(Vector a, Vector b) {
return a.dot(b) == 0.0;
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
return isOrthogonal(a1 - a2, b1 - b2);
}
bool isOrthogonal(Segment s1, Segment s2) {
return (s1.p2 - s1.p1).dot(s2.p2 - s2.p1) == 0.0;
}
//ベクトルa,bの並行判定
bool isParallel(Vector a, Vector b) {
return a.det(b) == 0.0;
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
return isParallel(a1 - a2, b1 - b2);
}
bool isParallel(Segment s1, Segment s2) {
return (s1.p2 - s1.p1).det(s2.p2 - s2.p1) == 0.0;
}
//射影(点p1と点p2を通る直線に点pから垂線を引いた交点xを求める)
Point project(Segment s, Point p) {
Vector base = s.p2 - s.p1;
double r = (p - s.p1).dot(base) / norm(base);
return s.p1 + base*r;
}
//反射(点p1と点p2を通る直線を対象軸として点pと線対称の位置にある点xを求める)
Point reflect(Segment s, Point p) {
return p + (project(s, p) - p)*2.0;
}
//点aと点bの距離
double getDistance(Point a, Point b) {
return abs(a - b);
}
//直線lと点pの距離
double getDistanceLP(Line l, Point p) {
return abs((l.p2 - l.p1).det(p - l.p1) / abs(l.p2 - l.p1));
}
//線分sと点pの距離
double getDistanceSP(Segment s, Point p) {
if ((s.p2 - s.p1).dot(p - s.p1) < 0.0)return abs(p - s.p1);
if ((s.p1 - s.p2).dot(p - s.p2) < 0.0)return abs(p - s.p2);
return getDistanceLP(s, p);
}
//線分s1と線分s2の距離
double getDistance(Segment s1, Segment s2) {
if (intersectSS(s1, s2))return 0.0;
return min({ getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2), getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2) });
}
//線分s1と線分s2の交点
Point getCrossPoint(Segment l, Segment m) {
double d1 = (l.p2 - l.p1).det( m.p2 - m.p1);
double d2 = (l.p2 - l.p1).det( l.p2 - m.p1);
if (abs(d1) < EPS && abs(d2) < EPS) return m.p1;
return m.p1 + (m.p2 - m.p1) * d2 / d1;
}
//円cと線分lの交点
pair<Point, Point>getCrossPoints(Circle c, Line l) {
Vector pr = project(l, c.c);
Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
double base = sqrt(c.r*c.r - norm(pr - c.c));
return make_pair(pr + e*base, pr - e*base);
}
//円c1と円c2の交点
double arg(Vector p) { return atan2(p.y, p.x); }
Vector polar(double a, double r) { return Point(cos(r)*a, sin(r)*a); }
pair<Point, Point>getCrossPoints(Circle c1, Circle c2) {
double d = abs(c1.c - c2.c);
double a = acos((c1.r*c1.r + d*d - c2.r*c2.r) / (2 * c1.r*d));
double t = arg(c2.c - c1.c);
return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}
//点pを通る円cの接線
pair< Point, Point > tangent( Circle c1, Point p2) {
pair<Point, Point> d = getCrossPoints(c1, Circle(p2, sqrt(norm(c1.c - p2) - c1.r * c1.r)));
return minmax(d.first, d.second);
}
//点の内包 0:in,1:on,2:out
int contains(Polygon g, Point p) {
int n = g.size();
bool x = false;
for (int i = 0; i < n; i++) {
Point a = g[i] - p, b = g[(i + 1) % n] - p;
if (abs(a.det(b)) < EPS&&a.dot(b) < EPS) return 1;
if (a.y > b.y)swap(a, b);
if (a.y < EPS&&EPS < b.y&&EPS < a.det(b))x = !x;
}
return (x ? 2 : 0);
}
//凸包を求める(辺上も含める場合は!=CLOCKWISEを==COUNTER_CLOCKWISEに)
Polygon convex_hull(Polygon s){
Polygon u, l;
if((int)s.size() < 3)return s;
sort(s.begin(), s.end());
u.emplace_back(s[0]);
u.emplace_back(s[1]);
l.emplace_back(s[(int)s.size() - 1]);
l.emplace_back(s[(int)s.size() - 2]);
//辺上も含める場合は!=CLOCKWISEを==COUNTER_CLOCKWISEに
for(int i = 2;i < (int)s.size();i++){
for(int n = (int)u.size();n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != CLOCKWISE;n--){
u.pop_back();
}
u.emplace_back(s[i]);
}
//辺上も含める場合は!=CLOCKWISEを==COUNTER_CLOCKWISEに
for(int i = (int)s.size() - 3;i >= 0;i--){
for(int n = l.size();n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != CLOCKWISE;n--){
l.pop_back();
}
l.emplace_back(s[i]);
}
reverse(l.begin(), l.end());
for(int i = (int)u.size() - 2;i >= 1;i--)l.emplace_back(u[i]);
return l;
}
//y座標の昇順でマージするための比較関数
bool compare_y(Point a, Point b) {
return a.y < b.y;
}
//最近点対
double closest_pair(Point *a, int n) {
if (n <= 1)return INF<double>();
sort(a, a + n);
int m = n / 2;
double x = a[m].x;
double d = min({ closest_pair(a,m),closest_pair(a + m,n - m) });//p,qが違う区間にある
inplace_merge(a, a + m, a + n, compare_y);//2つのソートされた列をマージ
//p,qが同じ区間にある
Points b;//直線から距離d未満の頂点を入れていく
for (int i = 0; i < n; i++) {
if (add(fabs(add(a[i].x, -x)), -d) >= 0.0)continue;
//bに入っている頂点を、末尾からy座標の差がd以上になるまで見ていく
for (int j = 0; j < (int)b.size(); j++) {
Point dd;
dd.x = add(a[i].x, -b[b.size() - j - 1].x);
dd.y = add(a[i].y, -b[b.size() - j - 1].y);
if (add(dd.y, -d) >= 0.0)break;
d = min(d, abs(dd));
}
b.emplace_back(a[i]);
}
return d;
}
//多角形の面積
double area(Polygon p) {
int n = p.size();
double sum = 0.0;
for (int i = 0; i < n; i++) {
sum = add(sum,0.5*p[i].det(p[(i + 1) % n]));
}
return sum < 0.0 ? -sum : sum;
}
//凸性判定
bool is_convex(Polygon p) {
for (int i = 0; i < (int)p.size(); i++) {
if (ccw(p[(i - 1 + p.size()) % p.size()], p[i], p[(i + 1) % p.size()]) == -1)return false;
}
return true;
}
//切断
Polygon convex_cut(Polygon p, Line l) {
Polygon ret;
for (int i = 0; i < (int)p.size(); i++) {
Point cur = p[i], nxt = p[(i + 1) % p.size()];
if (ccw(l.p1, l.p2, cur) != -1)ret.emplace_back(cur);
if (ccw(l.p1, l.p2, cur)*ccw(l.p1, l.p2, nxt) < 0) {
Segment seg;
seg.p1 = cur;
seg.p2 = nxt;
ret.emplace_back(getCrossPoint(seg, l));
}
}
return ret;
}
//端点の種類
# define BOTTOM 0
# define LEFT 1
# define RIGHT 2
# define TOP 3
class EndPoint {
public:
Point p;
int seg, st;//入力線分のID,端点の種類
EndPoint() {}
EndPoint(Point p, int seg, int st) :p(p), seg(seg), st(st) {}
bool operator <(const EndPoint &ep)const {
//y座標が小さい順に整列
if (p.y == ep.p.y) {
return st < ep.st;//yが同一の場合は、下端点、左端点、右端点、上端点の順に調べる
}
else {
return p.y < ep.p.y;
}
}
};
EndPoint EP[202020];//端点のリスト
//線分交差問題（マンハッタン幾何）
int ManhattanIntersection(vector<Segment> s) {
int n = s.size();
for (int i = 0, k = 0; i < n; i++) {
//端点p1,p2が左下を基準に並ぶように調整
if (s[i].p1.y == s[i].p2.y) {
if(s[i].p1.x>s[i].p2.x)swap(s[i].p1, s[i].p2);
}
else if (s[i].p1.y > s[i].p2.y)swap(s[i].p1, s[i].p2);
if (s[i].p1.y == s[i].p2.y) {//水平線分を端点リストに追加
EP[k++] = EndPoint(s[i].p1, i, LEFT);
EP[k++] = EndPoint(s[i].p2, i, RIGHT);
}
else {//垂直線分を端点リストに追加
EP[k++] = EndPoint(s[i].p1, i, BOTTOM);
EP[k++] = EndPoint(s[i].p2, i, TOP);
}
}
sort(EP, EP + 2 * n);//端点のy座標に関して昇順に整列
set<LL> bt;//二分探索木
bt.insert(1010101010);
int cnt = 0;
for (int i = 0; i < 2 * n; i++) {
if (EP[i].st == TOP) {
bt.erase(EP[i].p.x);//上端点を削除
}
else if (EP[i].st == BOTTOM) {
bt.insert(EP[i].p.x);
}
else if (EP[i].st == LEFT) {
set<LL>::iterator b = bt.lower_bound(s[EP[i].seg].p1.x);
set<LL>::iterator e = bt.upper_bound(s[EP[i].seg].p2.x);
cnt += distance(b, e);//bとeの距離（点の数）を加算
}
}
return cnt;
}
int n, k;
Point p[3030];
int main(){
cin >> n >> k;
REP(i, n){
cin >> p[i].x >> p[i].y;
}
REP(i, n){
map<double, int> mp;
//cout << "i =" << i << " ";
REP(j, n){
if(i == j)continue;
Segment s = Segment(p[i], p[j]);
//cout << s.slope() << " ";
mp[s.slope()]++;
}
//cout << endl;
for(auto m : mp){
if(m.second >= k - 1){
cout << "1" << endl;
return 0;
}
}
}
cout << "0" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
set<int> s[2];
set<int> sdouble;
int cntdouble[2];
long long sum[2];
int n;
void upd(int id);
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int tp, x;
scanf("%d%d", &tp, &x);
if (x > 0) {
sum[0] += x;
s[0].insert(x);
cntdouble[0] += tp;
if (tp == 1) {
sdouble.insert(x);
}
} else {
x = -x;
int id = 0;
if (s[1].count(x)) id = 1;
cntdouble[id] -= tp;
sum[id] -= x;
s[id].erase(x);
if (tp) {
sdouble.erase(x);
}
}
int doublesum = cntdouble[0] + cntdouble[1];
while ((int)s[1].size() < doublesum) upd(0);
while ((int)s[1].size() > doublesum) upd(1);
while (s[0].size() && s[1].size() && *s[0].rbegin() > *s[1].begin()) {
upd(0);
upd(1);
}
long long ans = sum[0] + sum[1] * 2;
if (doublesum == cntdouble[1] && doublesum) {
ans -= *s[1].begin();
if (s[0].size()) {
ans += *s[0].rbegin();
}
}
printf("%lld\n", ans);
}
return 0;
}
void upd(int id) {
int x = *s[id].rbegin();
if (id == 1) x = *s[1].begin();
int d = sdouble.count(x) ? 1 : 0;
sum[id] -= x;
sum[id ^ 1] += x;
cntdouble[id] -= d;
cntdouble[id ^ 1] += d;
s[id].erase(x);
s[id ^ 1].insert(x);
return;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int aib[200002], v[200002];
struct vects {
int pos, val;
};
vects v2[200002];
bool cmp(vects a, vects b) { return a.val < b.val; }
void add(int nod, int val) {
for (; nod <= n; nod += nod & (-nod)) aib[nod] += val;
}
int compute(int nod) {
int sol = 0;
for (; nod; nod -= nod & (-nod)) sol += aib[nod];
return sol;
}
int poin = 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
if (v[i] >= n) v[i] = n;
v2[i] = {i, v[i]};
add(i, 1);
}
sort(v2 + 1, v2 + n + 1, cmp);
long long sol = 0;
for (int i = 1; i <= n; ++i) {
if (v[i] > i) sol = sol + compute(v[i]) - compute(i);
while (v2[poin].val <= i && poin <= n) add(v2[poin].pos, -1), ++poin;
}
cout << sol;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int t;
cin >> t;
while (t--) {
int a1, b1;
cin >> a1 >> b1;
int a2, b2;
cin >> a2 >> b2;
if (max(a1, b1) == max(a2, b2) && max(a1, b1) == min(a1, b1) + min(a2, b2))
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, u, r;
long long ans = -1e18;
long long a[35], b[35], k[35], p[35];
void calc(long long aa[]) {
long long mx = 0;
for (int i = 1; i <= n; i++) mx += aa[i] * k[i];
ans = (ans > mx ? ans : mx);
}
void dfs(long long depth, long long aa[]) {
if (depth == u) {
calc(aa);
return;
}
long long t1[35], t2[35];
for (int i = 1; i <= n; i++) t1[i] = aa[i] ^ b[i];
if ((u - depth) % 2)
calc(t1);
else
calc(aa);
for (int i = 1; i <= n; i++) t2[i] = aa[p[i]] + r;
dfs(depth + 1, t2);
if (depth <= u - 2) {
for (int i = 1; i <= n; i++) t2[i] = t1[p[i]] + r;
dfs(depth + 2, t2);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n >> u >> r;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) cin >> k[i];
for (int i = 1; i <= n; i++) cin >> p[i];
dfs(0, a);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, a[3000005];
long long int beg = 1;
long long int dfs(long long int i, long long int j) {
if (i == n + beg - 1) {
a[n + beg] = a[n + beg - 1];
return n + beg - 1;
}
if (i > n + beg - 1) return n + beg;
a[dfs(i + j, j)] = a[i];
return i;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) a[i] = i;
for (int i = 2; i <= n; i++) {
dfs(beg, i);
beg++;
}
for (int i = beg; i <= n + beg - 1; i++) cout << a[i] << " ";
cout << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
cin >> a;
vector<long long> caja(a);
for (long long i = 0; i < a; i++) cin >> caja[i];
if (a == 1) {
cout << 1;
return 0;
}
caja[0] = 1;
for (long long i = 1; i < a; i++) {
if (caja[i] > caja[i - 1] + 1) caja[i] = caja[i - 1] + 1;
}
caja[a - 1] = 1;
for (long long i = a - 1; i >= 0; i--) {
if (caja[i] > caja[i + 1] + 1) caja[i] = caja[i + 1] + 1;
}
long long ma = 0;
for (long long i = 0; i < a; i++)
if (caja[i] > ma) ma = caja[i];
cout << ma;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ll c, n , m, s[10005], p[10005], dp[2][10005];
int main() {
cin >> c >> n >> m;
for(int i=0;i<n;i++){
cin >> s[i] >> p[i];
}
for(int i=0;i<n;i++){
for(int j=0;j<=c;j++){
int ii = i%2;
dp[ii^1][j] = max(dp[ii^1][j], dp[ii][j]);
if(j+s[i] <= c) dp[ii^1][j+s[i]] = max(dp[ii^1][j+s[i]], dp[ii][j]+p[i]);
}
}
for(int i=1;i<=m;i++){
cout << dp[n%2][c/i]*i << endl;
}
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int main(void)
{
int h,a; cin>>h>>a;
cout<<(h+a-1)/a<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
vector<long long> lucky;
long long l, r;
void func(long long n) {
if (n > r) {
lucky.push_back(n);
return;
}
lucky.push_back(n);
func(n * 10 + 4);
func(n * 10 + 7);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> l >> r;
func(4);
func(7);
sort((lucky).begin(), (lucky).end());
long long sum = 0;
long long a = l;
long long x = *lower_bound((lucky).begin(), (lucky).end(), l);
while (1) {
if (x >= r) {
sum += (r - a + 1) * x;
break;
} else {
sum += x * (x - a + 1);
a = x + 1;
x = *lower_bound((lucky).begin(), (lucky).end(), a);
}
}
cout << sum << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p[200020];
int a[10][10];
vector<int> v[5][20000];
int n;
int dfs(int i) {
int x = 0, re = 0, j, z, k;
for (j = 0; j < i; j++) x = x * 10 + a[i][j];
if (i == n - 1) return v[1][x].size();
for (j = 0; j < v[n - i][x].size(); j++) {
z = v[n - i][x][j];
for (k = n - 1; k > i; k--) {
a[i][k] = a[k][i] = z % 10;
z /= 10;
}
re += dfs(i + 1);
}
return re;
}
int t, i, j, x;
char s[10];
int main() {
for (i = 2; i * i <= 100000; i++)
if (!p[i])
for (j = i * i; j <= 100000; j += i) p[j] = 1;
for (i = 2; i < 100000; i++)
if (!p[i])
for (x = i, j = 1; j < 5; j++) v[j][x /= 10].push_back(i);
scanf("%d", &t);
while (t--) {
scanf("%s", &s);
for (i = 0; s[i]; i++) a[0][i] = a[i][0] = s[i] - '0';
n = i;
printf("%d\n", dfs(1));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int tc, n, x, d, h, maxd, maxdec;
int main() {
cin >> tc;
while (tc--) {
cin >> n >> x;
maxd = maxdec = -1000000000;
while (n--) {
cin >> d >> h;
maxd = max(maxd, d);
maxdec = max(maxdec, d - h);
}
if ((x > maxd) && (maxdec < 1))
cout << "-1" << endl;
else if (x <= maxd)
cout << "1" << endl;
else
cout << ((x - maxd + maxdec - 1) / maxdec) + 1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define max(a, b) ((a)>(b) ? (a):(b))
#define min(a, b) ((a)<(b) ? (a):(b))
#define mod 1000000007
typedef struct node{
int first;
int second;
}node;
bool operator<(const node &a, const node &b) {
return a.first > b.first;
}
void solve() {
int i;
int n, m, x;
cin >> n >> m >> x;
node h[n];
int belong[n];
priority_queue <node> th;
for(i=0; i<n; i++) {
cin >> h[i].first;
h[i].second = i;
}
node tmp;
for(i=0; i<m; i++) {
tmp.first = 0;
tmp.second = i;
th.push(tmp);
}
sort(h, h+n);
for(i=0; i<n; i++) {
tmp = th.top();
tmp.first += h[i].first;
th.pop();
th.push(tmp);
belong[h[i].second] = tmp.second;
}
int fth[m];
i = 0;
while(!th.empty()) {
tmp = th.top();
//cout << tmp.first << " " << tmp.second << "\n";
fth[i++] = tmp.first;
th.pop();
}
if(fth[m-1] - fth[0] > x) {
cout << "NO\n";
return;
}
cout << "YES\n";
for(int i: belong)
cout << i+1 << " ";
cout << "\n";
}
int main() {
//freopen("Input.txt", "r", stdin);
int t=1;
cin >> t;
for(int i=1; i<=t; i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mini(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool maxi(T &a, T b) {
return a < b ? (a = b, true) : false;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n), b;
for (int i = 0; i < (int)(n); i++) cin >> a[i];
int ok = 1;
for (int i = 0; i < (int)(n); i++) {
int tmp = ((i % n) + n) % n;
int idx = i + a[tmp];
idx = ((idx % n) + n) % n;
if (find((b).begin(), (b).end(), idx) != b.end()) {
ok = 0;
break;
}
b.push_back(idx);
}
if (ok)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long num;
bool found = false;
cin >> num;
vector<int> v(num);
for (unsigned i = 0; i < num; i++) cin >> v[i];
for (unsigned i = 0; i < v.size(); i++) {
while (v[i] % 2 == 0) {
v[i] /= 2;
}
while (v[i] % 3 == 0) {
v[i] /= 3;
}
}
for (int i = 0; i < v.size(); i++) {
if (v[i] == v[0])
found = true;
else {
found = false;
break;
}
}
if (found)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i;
long long arr[100000];
int s = 0;
for (i = sqrt(n); i >= 1; i--) {
if (n % i == 0) {
int x = n / i;
long long ans = 2 + (x - 1) * i;
ans = ans * x;
ans = ans / 2;
arr[s] = ans;
s++;
if (i != sqrt(n)) {
x = n / x;
ans = 2 + (x - 1) * (n / i);
ans = ans * x;
ans = ans / 2;
arr[s] = ans;
s++;
}
}
}
sort(arr, arr + s);
for (i = 0; i < s; i++) {
cout << arr[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int q[111111];
int a[111111];
int b[111111];
long long len[111111];
int dp[111111];
int query(long long x) {
int id = lower_bound(len + 1, len + n + 1, x) - len;
if (q[id] == 1) return a[id];
long long tp = len[id - 1];
long long w = x - tp;
long long z = w / a[id];
if (z > 1) w -= (z - 1) * a[id];
while (w > a[id]) w -= a[id];
if (dp[w] != -1) return dp[w];
return dp[w] = query(w);
}
void solve() {
while (cin >> n) {
memset(dp, -1, sizeof dp);
int i, j;
len[0] = 0;
for (i = 1; i <= n; i++) {
cin >> q[i];
if (q[i] == 1) {
cin >> a[i];
len[i] = len[i - 1] + 1;
} else {
cin >> a[i] >> b[i];
len[i] = len[i - 1] + 1LL * a[i] * b[i];
}
}
int m;
cin >> m;
long long x;
while (m--) {
cin >> x;
cout << query(x) << " ";
}
cout << endl;
}
}
int main() {
solve();
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.