solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#include <cstdlib>
using namespace std;
const int MAXH = 13;
const int MAXW = 13;
const int di[] = {1,0,-1,0};
const int dj[] = {0,1,0,-1};
const int INF = 1<<28;
int W, H;
char G[MAXH][MAXW];
int si, sj, ti, tj;
int N;
int ice[MAXH][MAXW];
int ans;
bool vis[MAXH][MAXW];
int cnt[1000];
int fromG[MAXH][MAXW];
int dfs(int pi, int pj, int n) {
int res = 1;
ice[pi][pj] = n;
for(int k = 0; k < 4; ++k) {
int ni = pi + di[k];
int nj = pj + dj[k];
if(ni < 0 || ni >= H) continue;
if(nj < 0 || nj >= W) continue;
if(G[ni][nj] != 'X') continue;
if(ice[ni][nj] != -1) continue;
res += dfs(ni, nj, n);
}
return res;
}
void bfs(int si, int sj) {
queue<pair<int,int> > que;
fill(fromG[0], fromG[MAXH], INF);
que.push(make_pair(si,sj));
fromG[si][sj] = 0;
while(que.size()) {
int pi = que.front().first;
int pj = que.front().second;
que.pop();
for(int k = 0; k < 4; ++k) {
int ni = pi + di[k];
int nj = pj + dj[k];
if(ni < 0 || ni >= H) continue;
if(nj < 0 || nj >= W) continue;
if(G[ni][nj] == '#') continue;
if(fromG[ni][nj] != INF) continue;
que.push(make_pair(ni,nj));
fromG[ni][nj] = fromG[pi][pj] + 1;
}
}
}
void dfs2(int pi, int pj, int previ, int prevj, int cost) {
if(cost+fromG[pi][pj] >= ans) return;
if(pi == ti && pj == tj) {
ans = min(ans, cost);
return;
}
for(int k = 0; k < 4; ++k) {
int ni = pi + di[k];
int nj = pj + dj[k];
if(ni < 0 || ni >= H) continue;
if(nj < 0 || nj >= W) continue;
if(ni == previ && nj == prevj) continue;
if(vis[ni][nj]) return;
}
vis[pi][pj] = true;
vector<pair<int,int > > v;
for(int k = 0; k < 4; ++k) {
int ni = pi + di[k];
int nj = pj + dj[k];
if(ni < 0 || ni >= H) continue;
if(nj < 0 || nj >= W) continue;
if(vis[ni][nj]) continue;
if(G[ni][nj] == '#') continue;
if(G[ni][nj] == 'X' && cnt[ice[ni][nj]] == 0) continue;
v.push_back(make_pair(ni,nj));
}
//random_shuffle(v.begin(), v.end());
for(int i = 0; i < v.size(); ++i) {
int ni = v[i].first;
int nj = v[i].second;
if(G[ni][nj] == 'X') cnt[ice[ni][nj]] -= 1;
dfs2(ni, nj, pi, pj, cost+1);
if(G[ni][nj] == 'X') cnt[ice[ni][nj]] += 1;
}
vis[pi][pj] = false;
}
int main() {
while(cin >> W >> H && (W|H)) {
for(int i = 0; i < H; ++i) {
for(int j = 0; j < W; ++j) {
cin >> G[i][j];
if(G[i][j] == 'S') {
si = i;
sj = j;
G[i][j] = '.';
}
if(G[i][j] == 'G') {
ti = i;
tj = j;
G[i][j] = '.';
}
}
}
fill(ice[0], ice[MAXH], -1);
N = 0;
for(int i = 0; i < H; ++i) {
for(int j = 0; j < W; ++j) {
if(G[i][j] == 'X' && ice[i][j] == -1) {
cnt[N] = dfs(i, j, N)/2;
if(cnt[N] == 0) {
ice[i][j] = -1;
G[i][j] = '#';
} else {
++N;
}
}
}
}
bfs(ti, tj);
ans = INF;
fill(vis[0], vis[MAXH], 0);
dfs2(si, sj, -1, -1, 0);
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100111;
const int maxv = 10011;
bool sign[maxv];
void dfs(int tot) {
if (tot * 10 > maxv) return;
sign[tot * 10 + 4] = 1;
dfs(tot * 10 + 4);
sign[tot * 10 + 7] = 1;
dfs(tot * 10 + 7);
}
void pre() { dfs(0); }
int C[maxn];
void add(int x, int v) {
while (x < maxn) {
C[x] += v;
x += (x & (-x));
}
}
int query(int x) {
int res = 0;
while (x > 0) {
res += C[x];
x -= (x & (-x));
}
return res;
}
int f[maxn], used[maxn];
int main() {
pre();
int n, m;
scanf("%d%d", &n, &m);
int a, b, c;
char op[10];
for (int i = (1); i <= (n); i++) {
scanf("%d", &f[i]);
if (sign[f[i]]) add(i, 1), used[i] = 1;
}
while (m--) {
scanf("%s%d%d", op, &a, &b);
if (op[0] == 'c') {
printf("%d\n", query(b) - query(a - 1));
} else {
scanf("%d", &c);
for (int i = (a); i <= (b); i++) {
if (f[i] > 7780) continue;
f[i] += c;
if (sign[f[i]]) {
if (!used[i]) add(i, 1), used[i] = 1;
} else {
if (used[i]) add(i, -1), used[i] = 0;
}
}
}
}
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int count(long long x) {
int ret = 0;
while(x > 0) {
ret += x & 1;
x /= 2;
}
return ret;
}
int main () {
long long k;
cin >> k;
int ans = count(k);
int ket = 0;
while(k > 0) {
ket++;
k /= 2;
}
ans = max(ans, ket - 1);
cout << ans << endl;
return 0;
}
| 0 |
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>
int main()
{
int i,j,k;
int n,m;
int sa,sb; //a,bの合計
int a[100],b[100];
int ans[3];
while(1){
scanf("%d %d",&n,&m);
if((n==0)&&(m==0))
break;
//初期化
sa=0;
sb=0;
ans[0]=0;ans[1]=0;ans[2]=201;
for(i=0;i<100;i++){a[i]=0;b[i]=0;}
//入力
for(i=0;i<n;i++){scanf("%d",&a[i]);sa+=a[i];}
for(i=0;i<m;i++){scanf("%d",&b[i]);sb+=b[i];}
for(i=0;i<n;i++){
for(j=0;j<m;j++){
if((sa-sb)==2*(a[i]-b[j])){
if(ans[2]>(a[i]+b[j])){
ans[0]=a[i];
ans[1]=b[j];
ans[2]=(a[i]+b[j]);
}
}
}
}
if(ans[2]==201){
printf("-1\n");
}
else{
printf("%d %d\n",ans[0],ans[1]);
}
}
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
const int N = 1e5 + 5;
queue<int> q;
int n, head[N], tot, deg[N], is[N], f[N], sum, mn;
char s[N];
struct node{int to, nex;}a[N << 1];
inline int read()
{
int x = 0, f = 1; char ch = getchar();
while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}
while(ch >= '0' && ch <= '9') {x = (x << 3) + (x << 1) + (ch ^ 48); ch = getchar();}
return x * f;
}
void add(int x, int y) {a[++ tot].to = y; a[tot].nex = head[x]; head[x] = tot; deg[x] ++;}
void topsort()
{
for(int i = 1; i <= n; i ++) if(deg[i] == 1 && s[i] == 'B') q.push(i);
while(!q.empty())
{
int x = q.front(); q.pop(); is[x] = 1;
for(int i = head[x]; i; i = a[i].nex)
{
int y = a[i].to; deg[y] --;
if(deg[y] == 1 && !is[y] && s[y] == 'B') q.push(y);
}
}
}
int v(int x) {return (deg[x] & 1) ^ (s[x] == 'W');}
int val(int x) {return (v(x) == 1) ? -2 : 0;}
void dfs(int x, int fa)
{
f[x] = val(x); sum += (v(x) == 1) + 2;
for(int i = head[x]; i; i = a[i].nex)
{
int y = a[i].to; if(y == fa || is[y]) continue;
dfs(y, x);
if(mn > f[x] + f[y]) mn = f[x] + f[y];
f[x] = min(f[x], f[y] + val(x));
}
}
int main()
{
// freopen(".in", "r", stdin);
// freopen(".out", "w", stdout);
n = read();
for(int i = 1, x, y; i <= n - 1; i ++)
{
x = read(); y = read();
add(x, y); add(y, x);
}
scanf("%s", s + 1); topsort(); int x;
for(x = 1; x <= n; x ++) if(!is[x]) break;
if(x > n) {puts("0"); return 0;}
dfs(x, 0); sum -= 2; printf("%d\n", sum + mn);
fclose(stdin);
fclose(stdout);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define ld long double
#define endl "\n"
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define pb push_back
#define mp(a,b) make_pair(a,b)
#define ms(v,x) memset(v,x,sizeof(v))
#define all(v) v.begin(),v.end()
#define ff first
#define ss second
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define per(i, a, b) for(int i = b-1; i>=a ; i--)
#define trav(a, x) for(auto& a : x)
#define allin(a , x) for(auto a : x)
#define Unique(v) sort(all(v));v.erase(unique(all(v)),v.end());
#define sz(v) ((int)v.size())
#define int long long
using namespace std;
typedef vector<int> vi;
#define y1 abacaba
//#define left oooooopss
#define db(x) cerr << #x <<" == "<<x << endl;
#define db2(x,y) cerr<<#x <<" == "<<x<<", "<<#y<<" == "<<y<<endl;
#define db3(x,y,z) cerr << #x<<" == "<<x<<", "<<#y<<" == "<<y<<", "<<#z<<" == "<<z<<endl;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
std::mt19937 rng((int) std::chrono::steady_clock::now().time_since_epoch().count());
inline ll mod(ll n, ll m ){ ll ret = n%m; if(ret < 0) ret += m; return ret; }
ll gcd(ll a, ll b){return (b == 0LL ? a : gcd(b, a%b));}
ll exp(ll b,ll e,ll m){
b%=m;
ll ans = 1;
for (; e; b = b * b % m, e /= 2)
if (e & 1) ans = ans * b % m;
return ans;
}
const int N = 200100;
ll a[N],pre[N];
int get(int l,int r){
return (pre[r] - pre[l-1]-1)/(r-l+1);
}
int ini[N];
int pai[N];
int sz[N];
int f(int x){return pai[x]=(pai[x]==x?x:f(pai[x]));}
void join(int a,int b){
a=f(a),b=f(b);
if(a==b)return;
if(sz[a] > sz[b])swap(a,b);
sz[b]+=sz[a];
pai[a]=b;
ini[b]=min(ini[a],ini[b]);
}
int32_t main(){
fastio;
int n,m;
cin >> n >> m;
set<pll> S;
rep(i,1,n+1)cin >> a[i],pre[i]=a[i]+pre[i-1];
rep(i,1,n+1){
if(i!=n)S.insert(pll(get(i,i),i));
pai[i]=i;
ini[i]=i;
sz[i]=1;
}
vi k(m);
rep(i,0,m)cin >> k[i];
vi res;
int ans=0;
per(i,0,m){
//db(i);
while(sz(S) and (*S.rbegin()).ff >= k[i]){
int id = S.rbegin()->ss;
id = f(id);
S.erase(*S.rbegin());
int r = ini[id] + sz[id];
r = f(r);
if(ini[r] + sz[r]<=n){
S.erase(S.find(pll(get(ini[r],ini[r]+sz[r]-1),ini[r])));
}
join(ini[id],ini[id] + sz[id]);
id = f(id);
if(ini[id] + sz[id] <= n)
S.insert(pll(get(ini[id],ini[id] + sz[id]-1),ini[id]));
ans = max(ans,sz[id]-1);
}
res.pb(ans);
}
per(i,0,m)cout << res[i]<<" \n"[i==0];
// math -> gcd it all
// Did u check N=1? Did you switch N,M?
} | 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 1005;
int a[N][N], ans[N][N], ans2[N][N], b[N];
int n, m;
int main() {
read(n);
read(m);
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= m; j++) {
read(a[i][j]);
}
}
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= m; j++) b[j] = a[i][j];
sort(b + 1, b + m + 1);
int big = unique(b + 1, b + m + 1) - b - 1;
for (register int j = 1; j <= m; j++) {
int tmp = lower_bound(b + 1, b + big + 1, a[i][j]) - b;
ans[i][j] = max(ans[i][j], tmp);
ans2[i][j] = max(ans2[i][j], big - tmp);
}
}
for (register int j = 1; j <= m; j++) {
for (register int i = 1; i <= n; i++) b[i] = a[i][j];
sort(b + 1, b + n + 1);
int big = unique(b + 1, b + n + 1) - b - 1;
for (register int i = 1; i <= n; i++) {
int tmp = lower_bound(b + 1, b + big + 1, a[i][j]) - b;
ans[i][j] = max(ans[i][j], tmp);
ans2[i][j] = max(ans2[i][j], big - tmp);
}
}
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= m; j++) {
print(ans[i][j] + ans2[i][j], j == m ? '\n' : ' ');
}
}
return 0;
}
| 3 |
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXN = 100000;
vector<int>G[MAXN + 5];
void addedge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
int dp[MAXN + 5];
void dfs(int rt, int pre) {
int cnt = 0;bool flag = 0;
for(int i=0;i<G[rt].size();i++)
if( G[rt][i] != pre ) {
int p = G[rt][i];
dfs(p, rt);
if( dp[p] == 0 ) {
if( !flag ) flag = true;
else dp[rt]++;
}
else
dp[rt] += dp[p];
}
}
int main() {
int N, root = -1;
scanf("%d", &N);
for(int i=1;i<=N-1;i++) {
int a, b;
scanf("%d%d", &a, &b);
addedge(a, b);
}
for(int i=0;i<N;i++)
if( G[i].size() > 2 )
root = i;
if( root == -1 ) {
printf("1\n");
return 0;
}
dfs(root, -1);
printf("%d\n", dp[root]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
map<vector<int>, long long> dp[N];
int t, e[N];
long long cnt(vector<int> v, long long ost) {
sort(v.begin(), v.end());
if (v.size() != 16) exit(1);
if (ost == 0) {
for (int i = 0; i < v.size(); ++i)
if (v[i] > t || v[15] == 0) return 0;
return 1;
}
if (dp[ost].count(v) == 0) {
vector<int> a;
dp[ost][v] = 0;
if (v[15] == 0) dp[ost][v] = cnt(v, ost - 1);
for (int i = (v[15] == 0); i < v.size(); ++i)
if (v[i] < t) {
a = v;
++a[i];
dp[ost][v] += cnt(a, ost - 1);
}
}
return dp[ost][v];
}
int main() {
int i, j, k, l, r;
long long n;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> t;
vector<int> v(16);
for (j = 0; j < 16; ++j) v[j] = 0;
bool flag = 0;
for (i = 15; i >= 0; --i) {
if (!flag && i > 0 && cnt(v, i) >= n) continue;
if (!flag && i > 0) {
n -= cnt(v, i);
}
for (j = !flag; j < 16; ++j) {
vector<int> a = v;
++a[j];
if (cnt(a, i) < n)
n -= cnt(a, i);
else {
flag = 1;
++v[j];
e[i] = j;
break;
}
}
}
i = 15;
while (e[i] == 0 && i > 0) --i;
while (i >= 0) {
if (e[i] < 10)
cout << (char)(e[i] + '0');
else
cout << (char)(e[i] - 10 + 'a');
--i;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k[100005], p[100005], cnt, outf[250005], outt[250005], outk[250005],
ans, l, r;
set<int> s[100005], S;
vector<int> v;
bool cmp(int x, int y) { return k[x] > k[y]; }
void del() {
for (set<int>::iterator it = s[p[r]].begin(); it != s[p[r]].end(); ++it)
if (S.count(*it)) S.erase(*it), v.push_back(*it);
}
void rec() {
for (int i = 0; i < v.size(); ++i) S.insert(v[i]);
v.clear();
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", k + i);
cnt += k[i], p[i] = i;
for (int j = 1; j <= k[i]; ++j) {
scanf("%d", &x);
s[i].insert(x);
}
}
sort(p + 1, p + n + 1, cmp);
for (int i = 1; i <= n; ++i) k[i] -= cnt / n;
for (int i = 1; i <= cnt % n; ++i) --k[p[i]];
l = 1, r = n;
S = s[p[1]];
del();
while (l < r) {
if (!k[p[l]]) {
++l;
if (l == r) break;
v.clear(), S = s[p[l]];
del();
continue;
}
if (!k[p[r]]) {
rec();
--r;
if (l == r) break;
del();
continue;
}
int x = *S.begin();
S.erase(x), s[p[r]].insert(x), --k[p[l]], ++k[p[r]];
++ans, outf[ans] = p[l], outt[ans] = p[r], outk[ans] = x;
}
printf("%d\n", ans);
for (int i = 1; i <= ans; ++i)
printf("%d %d %d\n", outf[i], outt[i], outk[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int S[101], top;
void push(int num) {
top++;
S[top] = num;
}
int pop() {
if (top == -1) return -1;
top--;
return S[top + 1];
}
int main() {
int n, m, a, b, i, j;
cin >> n >> m;
int E[101][101];
for (i = 1; i <= n; i++)
for (j = 0; j <= n; j++) E[i][j] = 0;
for (i = 0; i < m; i++) {
cin >> a >> b;
E[a][b] = 1;
E[b][a] = 1;
}
push(1);
char flag[n + 1];
int t;
for (i = 1; i <= n; i++) flag[i] = 'w';
flag[1] = 'g';
while (1) {
t = pop();
if (t == -1) break;
for (i = 1; i <= n; i++) {
if (E[t][i] == 1 && flag[i] == 'w') {
push(i);
flag[i] = 'g';
}
}
flag[t] = 'b';
}
bool istrue = true;
for (i = 1; i <= n; i++) {
if (flag[i] == 'w') {
istrue = false;
break;
}
}
if (n == m && istrue)
cout << "FHTAGN!\n";
else
cout << "NO\n";
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int n,ap,bp,a,b;
cin>>n;
while(n!=0){
ap=0;
bp=0;
for(int i=0;i<n;i++){
cin>>a>>b;
ap+=a==b?a:(a>b?a+b:0);
bp+=a==b?b:(a<b?a+b:0);
}
cout<<ap<<' '<<bp<<endl;
cin>>n;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[222222];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
gets(s);
int n = strlen(s);
int c = 0;
int j;
for (int i = 0; i < n; i = j) {
for (j = i + 1; j < n and s[j] == s[i]; j++)
;
int cr = j - i;
if (cr == 1) {
cout << s[i];
c = 0;
}
if (cr > 1) {
if (c) {
c = 0;
cout << s[i];
} else {
c = 1;
cout << s[i] << s[i];
}
}
}
}
| 3 |
#include <bits/stdc++.h>
#define ll long long int
#define mod 1000000007
#define pii pair<int, int>
#define fr(n) for (int i = 0; i < n; i++)
#define fr1(n) for (int i = 1; i <= n; i++)
using namespace std;
vector<pii> g[100005];
int d[100005];
bool b[100005];
void dfs(int x) {
for (pii i : g[x]) {
if (!b[i.first]) {
b[i.first] = 1;
d[i.first] = d[x] + i.second;
dfs(i.first);
} else {
if (d[i.first] != d[x] + i.second) {
cout << "No";
exit(0);
}
}
}
}
int main() {
ios::sync_with_stdio(false);
int n, m, u, v, w;
cin >> n >> m;
fr(m) cin >> u >> v >> w, g[u].push_back({v, w}), g[v].push_back({u, -w});
fr1(n) if (!b[i]) b[i] = 1, dfs(i);
cout << "Yes";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 100;
long long int a[N], sum[N];
int n, k;
int lbs(long long int val) {
int lo = 1, hi = n;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] > val)
hi = mid - 1;
else
lo = mid + 1;
}
return lo;
}
int hbs(long long int val) {
int lo = 1, hi = n;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] >= val)
hi = mid - 1;
else
lo = mid + 1;
}
return hi;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
int g = 1, mx = 1;
int lst = a[n];
for (int i = 2; i <= a[1]; i++) {
int p = 0;
bool ck = 0;
long long int ans = 0;
for (int j = i; j <= lst + i; j += i) {
int x2 = hbs(j);
if (a[x2] - p > k) {
ck = 1;
break;
}
p = j;
}
if (!ck) {
mx = i;
}
}
cout << mx << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50 + 10;
int n;
char S[N][N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%s", S[i] + 1);
int x1 = n + 1, x2 = -1;
int y1 = n + 1, y2 = -1;
int cnt4 = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
if (S[i][j] != '4') continue;
x1 = min(x1, i);
y1 = min(y1, j);
x2 = max(x2, i);
y2 = max(y2, j);
cnt4++;
}
if ((x2 - x1 + 1) * (y2 - y1 + 1) != cnt4) {
puts("No");
return 0;
};
for (int i = 1; i <= x1 - 2; ++i)
for (int j = 1; j <= n; ++j)
if (S[i][j] != '0') {
puts("No");
return 0;
};
for (int i = x2 + 2; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (S[i][j] != '0') {
puts("No");
return 0;
};
for (int j = 1; j <= y1 - 2; ++j)
for (int i = 1; i <= n; ++i)
if (S[i][j] != '0') {
puts("No");
return 0;
};
for (int j = y2 + 2; j <= n; ++j)
for (int i = 1; i <= n; ++i)
if (S[i][j] != '0') {
puts("No");
return 0;
};
if (x1 > 1 && y1 > 1 && S[x1 - 1][y1 - 1] != '1') {
puts("No");
return 0;
};
if (x1 > 1 && y2 < n && S[x1 - 1][y2 + 1] != '1') {
puts("No");
return 0;
};
if (x2 < n && y1 > 1 && S[x2 + 1][y1 - 1] != '1') {
puts("No");
return 0;
};
if (x2 < n && y2 < n && S[x2 + 1][y2 + 1] != '1') {
puts("No");
return 0;
};
if (x1 > 1)
for (int i = y1; i <= y2; ++i)
if (S[x1 - 1][i] != '2') {
puts("No");
return 0;
};
if (x2 < n)
for (int i = y1; i <= y2; ++i)
if (S[x2 + 1][i] != '2') {
puts("No");
return 0;
};
if (y1 > 1)
for (int i = x1; i <= x2; ++i)
if (S[i][y1 - 1] != '2') {
puts("No");
return 0;
};
if (y2 < n)
for (int i = x1; i <= x2; ++i)
if (S[i][y2 + 1] != '2') {
puts("No");
return 0;
};
puts("Yes");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> id;
int nid;
int get(int x) {
int y = x;
while (x) {
int c = x % 10;
if (c == 4 || c == 7) {
x /= 10;
} else {
return 0;
}
}
x = y;
if (id.count(x) == 0) {
id[x] = ++nid;
}
return id[x];
}
const int N = (int)1e5 + 7;
const int A = 1000 + 7;
int n;
int a[N];
vector<int> where;
vector<int> w_ex[N];
int first[N];
int l[N];
int r[N];
int ub[N];
bool valid[N];
int f(int i) {
if (i == -1) {
return 0;
}
if (i == (int)where.size()) {
return n + 1;
}
return where[i];
}
long long gauss(long long n) { return n * (n + 1) / 2; }
long long f(long long n) {
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans += gauss(i);
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
x = get(x);
if (x) {
where.push_back(i);
w_ex[x].push_back(i);
}
a[i] = x;
}
long long sol = 0;
for (int it = 0; it < (int)where.size(); it++) {
for (int j = 1; j <= where[it] - 1; j++) {
valid[j] = 1;
}
for (int i = 1; i < A; i++) {
first[i] = 0;
}
for (int it2 = it; it2 < (int)where.size(); it2++) {
int i = where[it2];
if (first[a[i]] == 0) {
first[a[i]] = i;
for (auto &j : w_ex[a[i]]) {
if (j >= where[it]) {
break;
}
valid[j] = 0;
}
}
}
for (int j = 1; j <= where[it] - 1; j++) {
if (valid[j]) {
if (valid[j - 1]) {
l[j] = l[j - 1];
} else {
l[j] = j;
}
}
}
for (int j = where[it] - 1; j >= 1; j--) {
if (valid[j]) {
if (valid[j + 1]) {
r[j] = r[j + 1];
} else {
r[j] = j;
}
}
}
long long cur = 0;
for (int j = 1; j <= where[it] - 1; j++) {
if (valid[j] && l[j] == j) {
cur += gauss(r[j] - l[j] + 1);
}
}
for (int it2 = (int)where.size() - 1; it2 >= it; it2--) {
int i = where[it2];
long long init = sol;
long long val = cur;
long long scad = f(it) - 1 - l[f(it) - 1] + 1;
long long steps = f(it) - f(it - 1);
long long ccciq = steps * val;
val = 0;
long long lol = 0;
steps--;
lol += scad * gauss(steps) - f(steps - 1);
ccciq -= lol;
sol += ccciq * (f(it2 + 1) - f(it2));
if (first[a[i]] == i) {
for (auto &j : w_ex[a[i]]) {
if (j >= where[it]) {
break;
}
valid[j] = 1;
l[j] = r[j] = j;
if (valid[j - 1]) {
cur -= gauss(r[j - 1] - l[j - 1] + 1);
l[j] = l[j - 1];
}
if (valid[j + 1]) {
cur -= gauss(r[j + 1] - l[j + 1] + 1);
r[j] = r[j + 1];
}
r[l[j]] = r[j];
l[r[j]] = l[j];
cur += gauss(r[j] - l[j] + 1);
}
}
}
}
ub[n + 1] = n + 1;
for (int i = n; i >= 1; i--) {
if (a[i]) {
ub[i] = i;
} else {
ub[i] = ub[i + 1];
}
}
for (int i = 1; i <= n; i++) {
sol += (long long)(ub[i] - i) * gauss(i - 1);
}
cout << sol << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int mod = 998244353;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
unsigned long long int n;
cin >> n;
unsigned long long int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<int>());
unsigned long long int ans = 0;
if (n == 1)
cout << arr[0];
else {
ans = n * (arr[0] + arr[1]);
if (n > 2) {
for (int i = 2; i < n; i++) ans += arr[i] * (n - i + 1);
}
cout << ans;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
inline void in(int &x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
struct data {
int left, right;
data() { left = right = 0; }
data(int l, int r) {
left = l;
right = r;
}
} tree[N << 1], tmp;
inline int ID(int l, int r) { return (l + r) | (l != r); }
int n, q, dfn[N << 1], val[N], fa[N], tot, Log[N << 1], dp[20][N << 1], tag[N],
ans, VtoI[N], dep[N];
vector<int> v[N];
int LCA(int x, int y) {
int l = min(tag[x], tag[y]), r = max(tag[x], tag[y]);
int k = Log[r - l + 1];
if (dep[dp[k][l]] < dep[dp[k][r - (1 << k) + 1]]) return dp[k][l];
return dp[k][r - (1 << k) + 1];
}
data operator+(const data &x, const data &y) {
int a, b, c, d;
a = x.left;
b = x.right;
c = y.left;
d = y.right;
if (a == -1 || c == -1) return data(-1, -1);
int lca = LCA(c, d);
if (((LCA(a, c) == a || LCA(a, d) == a) && (LCA(a, lca) == lca)) &&
((LCA(b, c) == b || LCA(b, d) == b) && LCA(lca, b) == lca))
return data(c, d);
a = x.left;
b = y.left;
c = x.right;
d = y.right;
lca = LCA(c, d);
if (((LCA(a, c) == a || LCA(a, d) == a) && (LCA(a, lca) == lca)) &&
((LCA(b, c) == b || LCA(b, d) == b) && LCA(lca, b) == lca))
return data(c, d);
a = x.left;
b = y.right;
c = x.right;
d = y.left;
lca = LCA(c, d);
if (((LCA(a, c) == a || LCA(a, d) == a) && (LCA(a, lca) == lca)) &&
((LCA(b, c) == b || LCA(b, d) == b) && LCA(lca, b) == lca))
return data(c, d);
a = x.right;
b = y.left;
c = x.left;
d = y.right;
lca = LCA(c, d);
if (((LCA(a, c) == a || LCA(a, d) == a) && (LCA(a, lca) == lca)) &&
((LCA(b, c) == b || LCA(b, d) == b) && LCA(lca, b) == lca))
return data(c, d);
a = x.right;
b = y.right;
c = x.left;
d = y.left;
lca = LCA(c, d);
if (((LCA(a, c) == a || LCA(a, d) == a) && (LCA(a, lca) == lca)) &&
((LCA(b, c) == b || LCA(b, d) == b) && LCA(lca, b) == lca))
return data(c, d);
a = y.left;
b = y.right;
c = x.left;
d = x.right;
lca = LCA(c, d);
if (((LCA(a, c) == a || LCA(a, d) == a) && (LCA(a, lca) == lca)) &&
((LCA(b, c) == b || LCA(b, d) == b) && LCA(lca, b) == lca))
return data(c, d);
return data(-1, -1);
}
void dfs(int from) {
dfn[++tot] = from;
tag[from] = tot;
for (int i = 0; i < v[from].size(); i++) {
int to = v[from][i];
dep[to] = dep[from] + 1;
dfs(to);
dfn[++tot] = from;
}
}
void build(int k, int l, int r) {
if (l == r) {
tree[k] = data(VtoI[l], VtoI[l]);
return;
}
int mid = l + r >> 1;
build(ID(l, mid), l, mid);
build(ID(mid + 1, r), mid + 1, r);
tree[k] = tree[ID(l, mid)] + tree[ID(mid + 1, r)];
}
void update(int k, int l, int r, int x) {
if (r < x || l > x) return;
if (l == r) {
tree[k] = data(VtoI[l], VtoI[l]);
return;
}
int mid = l + r >> 1;
update(ID(l, mid), l, mid, x);
update(ID(mid + 1, r), mid + 1, r, x);
tree[k] = tree[ID(l, mid)] + tree[ID(mid + 1, r)];
}
void query(int k, int l, int r) {
if (l == r) {
if (tmp.left == -1) {
if (tree[k].left != -1) tmp = tree[k], ans = max(ans, l);
} else {
data t = tmp + tree[k];
if (t.left != -1) {
tmp = t;
ans = max(ans, l);
}
}
return;
}
int mid = l + r >> 1;
int lson = ID(l, mid), rson = ID(mid + 1, r);
if (tree[lson].left != -1) {
if (tmp.left == -1) {
tmp = tree[lson], ans = max(ans, mid), query(rson, mid + 1, r);
} else {
data t = tmp + tree[lson];
if (t.left != -1)
tmp = t, ans = max(ans, mid), query(rson, mid + 1, r);
else
query(lson, l, mid);
}
} else
query(lson, l, mid);
}
int main() {
for (int i = 2; i < (N << 1); i++) Log[i] = Log[i >> 1] + 1;
in(n);
for (int i = 1; i <= n; i++) in(val[i]), val[i]++, VtoI[val[i]] = i;
for (int i = 1; i < n; i++) {
in(fa[i + 1]);
v[fa[i + 1]].push_back(i + 1);
}
dfs(1);
for (int i = 1; i <= tot; i++) dp[0][i] = dfn[i];
for (int i = 1; i <= Log[tot]; i++)
for (int j = 1; j <= tot; j++)
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j + (1 << i >> 1)]);
build(ID(1, n), 1, n);
in(q);
while (q--) {
int op;
in(op);
if (op == 2) {
tmp = data(-1, -1);
ans = 0;
query(ID(1, n), 1, n);
printf("%d\n", ans);
} else {
int a, b;
in(a);
in(b);
swap(VtoI[val[a]], VtoI[val[b]]);
swap(val[a], val[b]);
update(ID(1, n), 1, n, val[a]);
update(ID(1, n), 1, n, val[b]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c,d; cin>>a>>b>>c>>d;
int ans=min(b,d)-max(a,c);
cout<<max(0,ans)<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int gM[3001][3001];
vector<int> g[10000];
int main() {
int n, m, u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
gM[u][v] = 1;
g[u].push_back(v);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
int badcount = 0;
for (auto db : g[i]) {
if (gM[db][j]) badcount++;
}
ans += badcount * (badcount - 1) / 2;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 16;
const int V = 4;
const int M = 505;
const int X = (1 << 16) - 1;
const int mod = 1e9 + 7;
int dp[M][1 << N];
int c[1 << N], d[1 << N];
int fa[1 << N], fb[1 << N];
int ans[1 << N];
int cid[N * N];
vector<int> to_plus[N];
string s;
int nx = 0;
void add(int a[1 << N], int b[1 << N]) {
for (int i = 0; i < (1 << N); ++i) a[i] = (a[i] + b[i]) % mod;
}
void flip(int a[1 << N]) {
for (int i = 0; i < (1 << N); ++i) d[X ^ i] = a[i];
for (int i = 0; i < (1 << N); ++i) a[i] = d[i];
}
void get_sum(int a[1 << N], int con[1 << N]) {
for (int i = 0; i < (1 << N); ++i) con[i] = a[i];
for (int i = 0; i < (1 << 4); ++i)
for (int mask = 0; mask < (1 << N); ++mask)
if (mask >> i & 1) con[mask] = (con[mask] + con[mask ^ (1 << i)]) % mod;
}
void merge(int a[1 << N], int b[1 << N]) {
memset(c, 0, sizeof c);
get_sum(a, fa);
get_sum(b, fb);
for (int i = 0; i < (1 << N); ++i) c[i] = fa[i] * 1LL * fb[i] % mod;
for (int i = 0; i < (1 << N); ++i)
if (__builtin_popcount(i) & 1) c[i] = (-c[i] + mod) % mod;
get_sum(c, c);
for (int i = 0; i < (1 << N); ++i)
if (__builtin_popcount(i) & 1) c[i] = (-c[i] + mod) % mod;
}
void pr(int a[1 << N]) {
for (int i = 0; i < (1 << N); ++i)
if (a[i]) cout << i << ' ' << a[i] << '\n';
}
int solve(int b, int e) {
int id = nx++;
if (b + 1 == e) {
int p = cid[s[b]];
for (auto x : to_plus[p]) dp[id][x]++;
return id;
}
int l = 0, r = 0;
int cnt = 0;
int com = 0;
for (int i = b; i < e; ++i) {
if (s[i] == '(') cnt++;
if (s[i] == ')') cnt--;
if (cnt == 0 && (s[i] == '&' || s[i] == '|' || s[i] == '?')) {
com = s[i];
l = solve(b + 1, i - 1);
r = solve(i + 2, e - 1);
break;
}
}
memset(ans, 0, sizeof ans);
if (com == '|' || com == '?') {
merge(dp[l], dp[r]);
add(ans, c);
}
if (com == '&' || com == '?') {
flip(dp[l]);
flip(dp[r]);
merge(dp[l], dp[r]);
flip(c);
add(ans, c);
}
for (int i = 0; i < (1 << N); ++i) {
dp[id][i] = ans[i];
}
return id;
}
int main() {
for (int i = 'a'; i <= 'd'; ++i) cid[i] = i - 'a' + 4;
for (int i = 'A'; i <= 'D'; ++i) cid[i] = i - 'A';
cid['?'] = 8;
for (int i = 'A'; i <= 'D'; ++i) {
int id = cid[i];
int res = 0;
for (int mask = 0; mask < (1 << 4); ++mask)
if (mask >> id & 1) res |= 1 << mask;
to_plus[id].push_back(res);
to_plus[id + 4].push_back(X ^ res);
to_plus[8].push_back(res);
to_plus[8].push_back(X ^ res);
}
cin >> s;
int n = (int)s.size();
solve(0, n);
int m;
cin >> m;
int want = 0, dont_want = 0;
for (int i = 0; i < m; ++i) {
int mask = 0;
for (int k = 0; k < 4; ++k) {
int x;
cin >> x;
mask += (1 << k) * x;
}
int res;
cin >> res;
if (res)
want |= 1 << mask;
else
dont_want |= 1 << mask;
}
int p = 0;
for (int i = 0; i < (1 << N); ++i) {
if ((i & want) == want && ((i ^ X) & dont_want) == dont_want) {
p = (p + dp[0][i]) % mod;
}
}
cout << p << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res = 0, k = 0, o = 0, t, i;
scanf("%d ", &n);
for (i = 0; i < n; i++) {
scanf("%d", &t);
if (t == 2) {
k++;
} else {
o++;
}
}
while (k > 0 && (o) > 0) {
k--;
o--;
res++;
}
res += o / 3;
printf("%d", res);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MaxN = 1000;
const int MaxG = 1000;
inline int &modaddto(int &a, const int &b) {
a = (a + b) % M;
return a;
}
int main() {
int n, nG;
cin >> n >> nG;
static int f[MaxN + 1][MaxG + 1][3][3];
f[1][0][0][0] = 1;
for (int i = 1; i < n; i++)
for (int g = 0; g <= i; g++)
for (int ta = 0; ta < 3; ta++)
for (int tb = 0; tb < 3; tb++)
if (f[i][g][ta][tb]) {
int cur = f[i][g][ta][tb];
modaddto(f[i + 1][g][0][0], cur);
if (ta == 0 && tb == 0) {
modaddto(f[i + 1][g + 2][1][1], cur);
modaddto(f[i + 1][g][2][2], (long long)cur * (i - g - 1) % M);
modaddto(f[i + 1][g - 1][2][2], (long long)cur * g % M);
} else {
if (ta == 1)
modaddto(f[i + 1][g][2][1], cur);
else
modaddto(f[i + 1][g + 1][2][1], cur);
if (tb == 1)
modaddto(f[i + 1][g][1][2], cur);
else
modaddto(f[i + 1][g + 1][1][2], cur);
modaddto(f[i + 1][g][2][2],
(long long)cur * (i - g - (ta != 1) - (tb != 1)) % M);
modaddto(f[i + 1][g - 1][2][2],
(long long)cur * (g - (ta == 1) - (tb == 1)) % M);
}
}
int res = 0;
for (int ta = 0; ta < 3; ta++)
for (int tb = 0; tb < 3; tb++) modaddto(res, f[n][nG][ta][tb]);
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
bool used_user[N][N];
bool allowed_user[N][N];
string username[N];
string chat_messages[N];
map<string, int> user_id;
int user_chosen_for_msg[N];
void clean() {
for (int msg = 0; msg < N; msg++)
for (int user = 0; user < N; user++) used_user[msg][user] = false;
for (int msg = 0; msg < N; msg++)
for (int user = 0; user < N; user++) allowed_user[msg][user] = false;
user_id.clear();
}
bool valid_username_entry(size_t username_entry, size_t username_size,
string chat_line) {
if (username_entry == string::npos) return false;
bool valid_left_character = !isalnum(chat_line[username_entry - 1]);
bool valid_right_character =
username_entry + username_size == chat_line.size();
if (!valid_right_character)
valid_right_character = !isalnum(chat_line[username_entry + username_size]);
return valid_left_character && valid_right_character;
}
bool user_mentioned_in_message(int user, string chat_line) {
for (size_t username_entry = 0;; username_entry++) {
username_entry = chat_line.find(username[user], username_entry);
if (valid_username_entry(username_entry, username[user].size(), chat_line))
return true;
if (username_entry == string::npos) break;
}
return false;
}
bool dfs(int msg, int messages, int users) {
if (msg == messages) return true;
for (int user = 0; user < users; user++) {
if (!allowed_user[msg][user]) continue;
if (used_user[msg][user]) continue;
if (msg > 0 && user_chosen_for_msg[msg - 1] == user) continue;
used_user[msg][user] = true;
user_chosen_for_msg[msg] = user;
if (dfs(msg + 1, messages, users)) return true;
}
return false;
}
void solve() {
int users;
cin >> users;
for (int user = 0; user < users; user++) {
cin >> username[user];
user_id[username[user]] = user;
}
int messages;
cin >> messages;
cin.ignore();
for (int msg = 0; msg < messages; msg++) {
string chat_line;
getline(cin, chat_line);
if (chat_line[0] == '?') {
for (int user = 0; user < users; user++)
if (!user_mentioned_in_message(user, chat_line))
allowed_user[msg][user] = true;
} else {
auto name = chat_line.substr(0, chat_line.find(':'));
allowed_user[msg][user_id[name]] = true;
}
chat_messages[msg] = chat_line.substr(chat_line.find(':'));
}
if (dfs(0, messages, users))
for (int msg = 0; msg < messages; msg++)
cout << username[user_chosen_for_msg[msg]] << chat_messages[msg] << '\n';
else
cout << "Impossible\n";
clean();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int chats;
cin >> chats;
while (chats--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long x = -1, y;
for (long long i = (0); i < (n); i++) {
if (s[i] == 'T' || s[i] == 'G') {
if (x == -1)
x = i;
else
y = i;
}
}
if ((y - x) % k != 0) {
cout << "NO"
<< "\n";
return 0;
}
bool flag = 1;
while (x < y) {
if (s[x] == '#') {
cout << "NO"
<< "\n";
return 0;
}
x = x + k;
}
cout << "YES"
<< "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > kul[101];
int t[101];
int sum[101];
int n, m, x = 1, y;
int main() {
cin >> n >> m;
for (int k = 1; k <= m; k++) {
for (int i = 1; i <= n; i++) {
cin >> t[i];
sum[i] += t[i];
if (i == n) {
for (int j = 1; j < n; j++) {
kul[j].push_back({t[j] - t[n], k});
}
}
}
}
for (int i = 1; i < n; i++) {
sort(kul[i].begin(), kul[i].end());
}
y = m;
for (int i = 1; i < n; i++) {
int ossz = 0;
for (int j = 0; j < m; j++) {
if (sum[n] + ossz <= sum[i]) {
if (j < y) {
y = j, x = i;
}
}
ossz += kul[i][j].first;
}
}
cout << y << "\n";
for (int i = 0; i < y; i++) {
cout << kul[x][i].second << " ";
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int s,w;
cin>>s>>w;
cout<<(w>=s?"unsafe":"safe")<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
string s[N];
int c[N];
bool isPalindrome[N];
priority_queue<int> pq[N];
int k, n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> k >> n;
vector<string> zip;
for (int(i) = (1); (i) <= (k); ++(i)) {
cin >> s[i] >> c[i];
zip.push_back(s[i]);
}
sort(zip.begin(), zip.end());
zip.resize(unique(zip.begin(), zip.end()) - zip.begin());
vector<string> revZIP;
for (auto u : zip) {
reverse(u.begin(), u.end());
revZIP.push_back(u);
reverse(u.begin(), u.end());
}
for (int(i) = (1); (i) <= (k); ++(i)) {
int pos = lower_bound(zip.begin(), zip.end(), s[i]) - zip.begin();
pq[pos].push(c[i]);
}
long long res = 0, minNeg = 0, maxCore = 0;
for (int i = 0; i < zip.size(); ++i) {
if (zip[i] == revZIP[i]) {
while (pq[i].size() >= 2) {
int u = pq[i].top();
pq[i].pop();
int v = pq[i].top();
pq[i].pop();
if (v > 0)
res += u + v;
else {
if (u + v > 0) {
res += u + v;
minNeg = min(minNeg, 1LL * v);
} else {
if (u > 0) pq[i].push(u);
}
break;
}
}
} else {
int pos = lower_bound(zip.begin(), zip.end(), revZIP[i]) - zip.begin();
if (pos >= zip.size() || revZIP[i] != zip[pos]) continue;
while (pq[i].size() && pq[pos].size()) {
int u = pq[i].top(), v = pq[pos].top();
if (u + v > 0) {
res += u + v;
pq[i].pop();
pq[pos].pop();
} else
break;
}
}
}
for (int i = 0; i < zip.size(); ++i) {
if (zip[i] == revZIP[i] && pq[i].size()) {
maxCore = max(maxCore, 1LL * pq[i].top());
}
}
cout << max(res - minNeg, res + maxCore) << '\n';
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
typedef long long Int;
int constexpr MOD = 1000000007;
int constexpr maxn = 1e3 + 10;
int t, n, k, a[maxn];
Int power(Int a, int p) {
Int x = 1;
while(p) {
if(p&1) (x *= a) %= MOD;
(a *= a) %= MOD;
p >>= 1;
}
return x;
}
int main()
{
cin >> t;
while(t--) {
cin >> n >> k;
for(int i = 0; i < n; i++) cin >> a[i];
sort(a, a+n);
reverse(a, a+n);
vector<int> cnt;
cnt.push_back(1);
for(int i = 1; i < n; i++) {
if(a[i] != a[i-1]) cnt.push_back(1);
else cnt.back()++;
}
Int ans = 1;
for(int c: cnt) {
if(k > c) k -= c;
else {
for(int f = 1; f <= k; f++, c--) {
(ans *= c) %= MOD;
(ans *= power(f, MOD-2)) %= MOD;
}
break;
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int N;
cin >> N;
vector<int> A(N), B(N);
for (int i = 0; i < N; ++i) cin >> A[i];
for (int i = 0; i < N; ++i) B[i] = A[i] / 2;
int sum = accumulate(B.begin(), B.end(), 0);
if (sum > 0) {
for (int i = 0; i < N; ++i) {
if (A[i] % 2 && A[i] < 0) {
B[i]--;
sum--;
}
if (sum == 0) break;
}
} else if (sum < 0) {
for (int i = 0; i < N; ++i) {
if (A[i] % 2 && A[i] > 0) {
B[i]++;
sum++;
}
if (sum == 0) break;
}
}
for (int i = 0; i < N; ++i) cout << B[i] << '\n';
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,dp[4010]={1};
for(int i=0;i<4;i++)
for(int j=4000;j>=0;j--)
for(int k=1;k<=1000;k++)
if(j+k<=4000)dp[j+k]+=dp[j];
while(cin>>n)cout << dp[n]<<endl;
return 0;
} | 0 |
#include <cstdio>
#include <map>
#include <algorithm>
std::map<int, int> mp;
int a[201000];
int main()
{
int n, ans = 0; scanf("%d", &n);
for(int i = 1; i <= n; i++)
{
scanf("%d", &a[i]);
mp[a[i]]++;
}
std::sort(a + 1, a + n + 1);
for(int i = n; i >= 1; i--)
{
if(!mp[a[i]]) continue;
mp[a[i]]--;
int j = 1;
for(j = 1; ; j <<= 1) if(j > a[i]) break;
if(mp[j - a[i]]) ans++, mp[j - a[i]]--;
}
printf("%d\n", ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1001000;
int n, m;
int a[NMAX];
int amt[50];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < m; ++i) {
int k;
cin >> k;
++amt[k];
}
int ans = 0;
for (int p = 0; p < 30; ++p) {
int i;
for (i = p; i < 30 && amt[p]; ++i) {
for (int j = 0; j < n; ++j) {
if ((a[j] >> i) & 1) {
int x = 1 << (i - p);
int t = min(x, amt[p]);
ans += t;
amt[p] -= t;
a[j] -= t * (1 << p);
}
}
}
if (i == 30) break;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, mod = 998244853;
int n, m, sl, fh, ans, dp1[4010][4010], dp2[4010][4010];
int rd() {
sl = 0;
fh = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') fh = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') sl = sl * 10 + ch - '0', ch = getchar();
return sl * fh;
}
void upd(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
n = rd();
m = rd();
dp1[1][1] = 1;
dp2[0][0] = 1;
for (int i = 1; i < n + m; ++i)
for (int j = 1; j <= n && j <= i; ++j)
if (2 * j - i > 0) {
if (j < n) upd(dp1[i + 1][j + 1], dp1[i][j]);
if (i - j < m) upd(dp1[i + 1][j], dp1[i][j]);
}
for (int i = 1; i <= n + m; ++i)
for (int j = 1; j <= m && j <= i; ++j)
if (i - 2 * j <= 0) {
upd(dp2[i][j], dp2[i - 1][j - 1]);
if (i - j) upd(dp2[i][j], dp2[i - 1][j]);
}
for (int i = 1; i <= n + m; ++i)
for (int j = 1; j <= n; ++j)
ans = (ans +
1ll * (2 * j - i) * dp1[i][j] % mod * dp2[n + m - i][m - i + j]) %
mod;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int maxm = 1e5 + 5;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
int sum = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
sum += x;
if (!x) cnt++;
}
int ans = cnt;
if (sum + cnt)
printf("%d\n", ans);
else
printf("%d\n", ans + 1);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<long long int, long long int>& a,
const pair<long long int, long long int>& b) {
return (a.second < b.second);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t, i, p;
cin >> t;
while (t--) {
long long int n, x, p;
cin >> n >> x;
vector<long long int> v;
map<long long int, long long int> m;
long long int arr[500] = {0};
for (i = 0; i < n; i++) {
cin >> p;
arr[p - 1] = 1;
}
i = 0;
while (x) {
if (arr[i] == 0) {
x--;
}
i++;
}
if (!arr[i])
cout << i;
else {
while (arr[i]) i++;
cout << i;
}
cout << endl;
}
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
while(n--){
int B=-1,C=-1;
bool ok=true;
for(int i=0;i<10;i++){
int m;
cin>>m;
if(B<m){
if(B<C && C<m)C=m;
else B=m;
}
else if(C<m){
C=m;
}
else ok=false;
}
cout<<(ok?"YES":"NO")<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
const int MOD = 1E9 + 7;
const int N = 150000 + 5;
const int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
const int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
using namespace std;
struct Edge {
int nex, to;
int w;
Edge() {}
Edge(int nex, int to, int w) : nex(nex), to(to), w(w) {}
} edge[5151111];
int head[N];
int cnt;
void addEdge(int from, int to, int w) {
edge[++cnt].nex = head[from];
edge[cnt].to = to;
edge[cnt].w = w;
head[from] = cnt++;
}
vector<int> G[N];
vector<int> nex[N];
int dis[N];
bool vis[N];
int Find(int y, int w) {
int left = 0, right = G[y].size() - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (G[y][mid] > w)
right = mid - 1;
else if (G[y][mid] < w)
left = mid + 1;
else
return nex[y][mid];
}
return w;
}
int SPFA(int s, int n) {
memset(dis, 0x3f3f3f3f, sizeof(dis));
memset(vis, false, sizeof(vis));
vis[s] = true;
dis[s] = Find(1, 0);
queue<int> Q;
Q.push(s);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
vis[x] = false;
for (int i = head[x]; i != -1; i = edge[i].nex) {
int y = edge[i].to;
int w = edge[i].w;
int times = dis[x] + w;
if (y != n) times = Find(y, times);
if (dis[y] > times) {
dis[y] = times;
if (!vis[y]) {
vis[y] = true;
Q.push(y);
}
}
}
}
return dis[n];
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
addEdge(x, y, w);
addEdge(y, x, w);
}
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
while (t--) {
int x;
scanf("%d", &x);
G[i].push_back(x);
}
}
for (int i = 1; i <= n; i++) {
for (int j = G[i].size() - 1; j >= 0; j--) {
int before;
if (j == G[i].size() - 1 || G[i][j] != G[i][j + 1] - 1)
before = G[i][j] + 1;
nex[i].push_back(before);
}
reverse(nex[i].begin(), nex[i].end());
}
int res = SPFA(1, n);
if (res == 0x3f3f3f3f) res = -1;
printf("%d\n", res);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using ld = long double;
template<typename T> using V = vector<T>;
template<typename T> using VV = vector<vector<T>>;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define all(v) (v).begin(),(v).end()
#define siz(v) (ll)(v).size()
#define rep(i,a,n) for(ll i=a;i<(ll)(n);i++)
#define repr(i,a,n) for(ll i=n-1;(ll)a<=i;i--)
#define lb lower_bound
#define ub upper_bound
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
const ll mod = 1000000007;
const ll INF = 1000000099;
const ll LINF = (ll)(1e18 +99);
vector<ll> dx={-1,1,0,0},dy={0,0,-1,1};
template<typename T,typename U> void chmin(T& t, const U& u){if(t>u)t=u;}
template<typename T,typename U> void chmax(T& t, const U& u){if(t<u)t=u;}
template<typename T>T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T>T mpow(T a, T n) {
T res = 1;
for(;n;n>>=1) {
if (n & 1) res = res * a;
a = a * a;
}
return res;
}
const ll MAX = 110;//設定して
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod%i] * (mod / i) % mod;//＊１
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
ll dp[110][110][260]={};
signed main(){
COMinit();
cin.tie(0);ios::sync_with_stdio(false);
cout<<fixed<<setprecision(20);
ll n,K;cin>>n>>K;
vector<ll> v(n);rep(i,0,n)cin>>v[i];
dp[0][0][0]=1;
rep(i,0,n){
rep(j,0,i+1){
rep(k,0,256){
(dp[i+1][j+1][k^v[i]]+=dp[i][j][k])%=mod;
(dp[i+1][j][k]+=dp[i][j][k])%=mod;
}
}
}
ll ans=0;
rep(i,0,101){
ll add=dp[n][i][K];
add*=fac[i];
add%=mod;
(ans+=add)%=mod;
}
cout<<ans<<endl;
}
//( ・ __ ・ ) KEEP BEING ORGANIZED
//CHECK overflow,vector_size,what to output? | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
char s[1000005];
constexpr ll MOD = 1000000007;
template <typename T>
T modpow(T base, T exp, T modulus) {
base %= modulus;
T result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
int main(void) {
int n;
scanf("%s%n", s, &n);
ll a_count = 0, b_count = 0;
ll ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'a') {
a_count++;
} else {
b_count++;
ans = (ans + modpow(2LL, a_count, MOD) + MOD - 1) % MOD;
}
}
printf("%" PRId64 "\n", ans % MOD);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int tav[109][109];
int s, b, KK;
long long legjobb[109][109];
long long profit[100009];
long long infi = 1e18;
struct BaseShip {
int lo;
int pwr;
int fuel;
int cost;
int tp;
int idx;
bool operator<(const BaseShip& BS) const {
if (pwr == BS.pwr) {
return tp < BS.tp;
}
return pwr < BS.pwr;
}
};
vector<BaseShip> t;
void javit(BaseShip& BS) {
for (int i = 1; i <= n; i++) {
if (tav[i][BS.lo] >= 0) {
legjobb[i][tav[i][BS.lo]] =
max(legjobb[i][tav[i][BS.lo]], (long long)BS.cost);
}
}
}
long long ertek(BaseShip& BS) {
long long ret = -infi;
for (int dd = 0; dd <= min(n - 1, BS.fuel); dd++) {
ret = max(ret, (long long)legjobb[BS.lo][dd]);
}
return ret;
}
vector<int> G[100009];
vector<long long> cap[100009];
vector<long long> flow[100009];
vector<int> holvan[100009];
int bejar[100009];
int bejarszam;
int apa[100009];
int apael[100009];
long long profitsum = 0;
int sor[100009];
long long FF() {
long long ret = 0;
int start = 0;
int sk;
int sv;
while (1) {
sk = 1;
sv = 1;
sor[1] = start;
bejarszam++;
bejar[start] = bejarszam;
apa[start] = -1;
apael[start] = -1;
while (sk <= sv) {
int akt = sor[sk];
for (int i = 0; i < G[akt].size(); i++) {
int sz = G[akt][i];
long long cc = cap[akt][i];
if (bejar[sz] == bejarszam) continue;
if (cc == flow[akt][i]) continue;
sv++;
sor[sv] = sz;
apa[sz] = akt;
apael[sz] = i;
bejar[sz] = bejarszam;
}
sk++;
}
if (bejar[s + 1] < bejarszam) break;
long long maxpush = infi;
int akt = s + 1;
while (akt != 0) {
if (cap[apa[akt]][apael[akt]] == 0) {
maxpush = min(maxpush, flow[apa[akt]][apael[akt]]);
} else {
maxpush = min(maxpush,
cap[apa[akt]][apael[akt]] - flow[apa[akt]][apael[akt]]);
}
akt = apa[akt];
}
akt = s + 1;
while (akt != 0) {
if (cap[apa[akt]][apael[akt]] == 0) {
flow[apa[akt]][apael[akt]] -= maxpush;
flow[akt][holvan[apa[akt]][apael[akt]]] -= maxpush;
} else {
flow[apa[akt]][apael[akt]] += maxpush;
flow[akt][holvan[apa[akt]][apael[akt]]] += maxpush;
}
akt = apa[akt];
}
ret += maxpush;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
tav[i][j] = -1;
}
tav[i][i] = 0;
}
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
if (a != b) {
tav[a][b] = 1;
tav[b][a] = 1;
}
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (tav[i][k] >= 0 && tav[k][j] >= 0) {
if (tav[i][j] == -1 || tav[i][j] > tav[i][k] + tav[k][j])
tav[i][j] = tav[i][k] + tav[k][j];
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
legjobb[i][j] = -infi;
}
}
cin >> s >> b >> KK;
t.resize(s + b);
for (int i = 0; i < s; i++) {
cin >> t[i].lo >> t[i].pwr >> t[i].fuel >> t[i].cost;
t[i].tp = 1;
t[i].idx = i + 1;
}
for (int i = s; i < s + b; i++) {
cin >> t[i].lo >> t[i].pwr >> t[i].cost;
t[i].tp = 0;
}
sort(t.begin(), t.end());
for (int i = 0; i < t.size(); i++) {
if (t[i].tp == 0) {
javit(t[i]);
} else {
profit[t[i].idx] = ertek(t[i]) - t[i].cost;
if (profit[t[i].idx] >= 0) {
profitsum += profit[t[i].idx];
}
}
}
for (int i = 1; i <= KK; i++) {
int s1, s2;
cin >> s1 >> s2;
if (s1 == s2) continue;
holvan[s1].push_back(G[s2].size());
holvan[s2].push_back(G[s1].size());
G[s1].push_back(s2);
G[s2].push_back(s1);
cap[s1].push_back(infi);
cap[s2].push_back(0);
flow[s1].push_back(0);
flow[s2].push_back(0);
}
for (int i = 1; i <= s; i++) {
if (G[i].size() == 0) continue;
if (profit[i] >= 0) {
holvan[0].push_back(G[i].size());
holvan[i].push_back(G[0].size());
G[0].push_back(i);
G[i].push_back(0);
cap[0].push_back(profit[i]);
cap[i].push_back(0);
flow[0].push_back(0);
flow[i].push_back(0);
} else {
holvan[s + 1].push_back(G[i].size());
holvan[i].push_back(G[s + 1].size());
G[s + 1].push_back(i);
G[i].push_back(s + 1);
cap[s + 1].push_back(0);
cap[i].push_back(-profit[i]);
flow[s + 1].push_back(0);
flow[i].push_back(0);
}
}
long long mincut = FF();
cout << profitsum - mincut << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin >> a;
cout << 180*a-360 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long fun(long long x, long long y, long long m) {
int res = 1;
x %= m;
if (x == 0) return 0;
while (y > 0) {
if (y % 2) res = (res * x) % m;
y /= 2;
x = (x * x) % m;
}
return res;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << fun(m, n, 1000000007) << endl;
else if (k == n)
cout << fun(m, (n + 1) / 2, 1000000007);
else if (k % 2)
cout << m * m << endl;
else
cout << m << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
const int mod = 1e9 + 7;
struct node {
int l, r;
node(int l = 0, int r = 0) : l(l), r(r) {}
} e[maxn];
long long sum[maxn << 2], v[maxn];
void push_up(int id) { sum[id] = (sum[id << 1] + sum[id << 1 | 1]) % mod; }
void update(int id, int l, int r, int pos, long long val) {
if (l == r) {
sum[id] = (sum[id] + val) % mod;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
update(id << 1, l, mid, pos, val);
else
update(id << 1 | 1, mid + 1, r, pos, val);
push_up(id);
}
long long query(int id, int l, int r, int x, int y) {
if (x <= l && y >= r) return sum[id];
int mid = (l + r) >> 1;
long long ans = 0;
if (x <= mid) ans = (ans + query(id << 1, l, mid, x, y)) % mod;
if (y > mid) ans = (ans + query(id << 1 | 1, mid + 1, r, x, y)) % mod;
return ans;
}
bool cmp(node a, node b) { return a.r < b.r; }
int main() {
int n, m, now = 0;
scanf("%d%d", &n, &m);
v[++now] = 0, v[++now] = n;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[i] = node(x, y);
v[++now] = x, v[++now] = y;
}
sort(v + 1, v + 1 + now);
int len = unique(v + 1, v + 1 + now) - v - 1;
sort(e + 1, e + 1 + m, cmp);
for (int i = 1; i <= m; i++) {
int lc = lower_bound(v + 1, v + 1 + len, e[i].l) - v;
int rc = lower_bound(v + 1, v + 1 + len, e[i].r) - v;
long long x = query(1, 1, len, lc, rc - 1);
if (e[i].l == 0) x++;
update(1, 1, len, rc, x % mod);
}
int pos = lower_bound(v + 1, v + 1 + len, n) - v;
long long ans = query(1, 1, len, pos, pos);
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int num[200];
char let[4];
const int MAXN = (int)1e+5 + 5;
int fen[11][11][4][MAXN];
void call() {
num['A'] = 0;
num['C'] = 1;
num['G'] = 2;
num['T'] = 3;
let[0] = 'A';
let[1] = 'C';
let[2] = 'G';
let[3] = 'T';
}
void add(int k, int b, int z, int x, int d) {
for (int i = x; i < MAXN; i |= (i + 1)) fen[k][b][z][i] += d;
}
int pref(int k, int b, int z, int x) {
int res = 0;
for (int i = x; i > 0; i = (i & (i + 1)) - 1) res += fen[k][b][z][i];
return res;
}
int get(int k, int b, int z, int l, int r) {
if (l > r) return 0;
return pref(k, b, z, r) - pref(k, b, z, l - 1);
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
call();
string s;
cin >> s;
int n = (int)s.size();
s = "$" + s;
for (int k = 1; k <= 10; k++) {
for (int b = 1; b <= k; b++) {
for (int z = 0; z < 4; z++) {
for (int i = b; i <= n; i += k) {
if (s[i] == let[z]) add(k, b, z, i, 1);
}
}
}
}
int q;
cin >> q;
for (; q > 0; q--) {
int t;
cin >> t;
if (t == 1) {
int pos;
char c;
cin >> pos >> c;
for (int k = 1; k <= 10; k++) {
int w = pos % k;
if (w == 0) w = k;
add(k, w, num[s[pos]], pos, -1);
add(k, w, num[c], pos, 1);
}
s[pos] = c;
} else {
int l, r;
cin >> l >> r;
string now;
cin >> now;
int len = (int)now.size();
int ans = 0, ptr = l % len;
if (ptr == 0) ptr = len;
for (int i = 0; i < len; i++) {
ans += get(len, ptr, num[now[i]], l, r);
ptr++;
if (ptr > len) ptr = 1;
}
cout << ans << '\n';
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0 && n > 4) {
int k = 0, c = 1, x = (n - (c * 2)) / 2;
while (c < x) {
k++;
c++;
x = ((n - (c * 2)) / 2);
}
cout << k << endl;
} else {
cout << "0" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define EPS 1e-9
using namespace std;
typedef complex<double> P;
P rot (P x, P p, double ang) {
ang = ang / 180.0 * M_PI;
double p1 = p.real() - x.real();
double p2 = p.imag() - x.imag();
return P( p1 * cos(ang) - p2 * sin(ang) + x.real()
, p1 * sin(ang) + p2 * cos(ang) + x.imag() );
}
int main () {
int n;
while (cin >> n, n) {
vector<P> v(n);
for (auto &i : v) {
double x, y;
char c;
cin >> x >> c >> y;
i = P(x,y);
}
int res = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j && abs(v[i] - v[j]) <= 2. + EPS) {
int count = 0;
P m = P(abs(v[i].real() + v[j].real()) / 2., abs(v[i].imag() + v[j].imag()) / 2.);
P p = m + (m - v[i]) / abs(m - v[i]) * sqrt(1. - pow(abs(m - v[i]), 2.));
p = rot(m, p, 90);
for (int k = 0; k < n; k++) {
if (abs(p - v[k]) <= 1. + EPS) count++;
}
res = max(res, count);
}
}
}
cout << res << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool DBG = true;
template <typename T, typename S>
std::ostream& operator<<(std::ostream& os, const std::pair<T, S>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vector) {
for (size_t i = 0; i < vector.size(); ++i) {
os << vector[i] << " ";
}
return os;
}
template <typename T>
std::ostream& operator<<(std::ostream& os,
const std::vector<std::vector<T>>& vector) {
for (size_t i = 0; i < vector.size(); ++i) {
os << vector[i] << endl;
}
return os;
}
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
int main() {
ios_base::sync_with_stdio(false);
vector<int> v(3);
vector<int> w(3);
for (int i = 0; i < (int)(v.size()); ++i) {
cin >> v[i];
}
for (int i = 0; i < (int)(w.size()); ++i) {
cin >> w[i];
}
int s = 0;
for (int i = 0; i < (int)(v.size()); ++i) {
int diff = v[i] - w[i];
if (diff >= 0) {
s += diff / 2;
} else {
s += diff;
}
}
if (s >= 0) {
Yes();
} else {
No();
}
return 0;
}
| 1 |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<sstream>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<utility>
#include<numeric>
#include<algorithm>
#include<bitset>
#include<complex>
using namespace std;
typedef long long Int;
typedef vector<int> vint;
typedef pair<int,int> pint;
#define mp make_pair
template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }
template<class T> void chmin(T &t, T f) { if (t > f) t = f; }
template<class T> void chmax(T &t, T f) { if (t < f) t = f; }
int in() { int x; scanf("%d", &x); return x; }
string field[12];
string buf[12];
void fall(){
int i,j;
bool update;
for(i=0;i<6;i++){
update=true;
while(update){
update=false;
for(j=11;j>0;j--){
if(field[j][i]=='.'&&field[j-1][i]!='.'){
field[j][i]=field[j-1][i];
field[j-1][i]='.';
update=true;
}
}
}
}
}
int count(string str[],int x,int y,char c){
if(x<0||6<=x||y<0||12<=y)return 0;
if(str[y][x]!=c)return 0;
int res=1;
str[y][x]='*';
res+=count(str,x+1,y,c);
res+=count(str,x-1,y,c);
res+=count(str,x,y+1,c);
res+=count(str,x,y-1,c);
return res;
}
bool bomb(){
int i,j;
bool res=false;
for(i=0;i<12;i++){
buf[i]=field[i];
}
for(i=0;i<12;i++){
for(j=0;j<6;j++){
if(buf[i][j]=='R'||buf[i][j]=='G'||buf[i][j]=='B'||buf[i][j]=='Y'||buf[i][j]=='P'){
int c=count(buf,j,i,buf[i][j]);
if(4<=c){
count(field,j,i,field[i][j]);
res=true;
}
}
}
}
int xx[]={1,-1,0,0},yy[]={0,0,1,-1};
for(i=0;i<12;i++){
for(j=0;j<6;j++){
if(field[i][j]=='*'){
int k;
for(k=0;k<4;k++){
if(i+yy[k]<0||i+yy[k]>=12||j+xx[k]<0||j+xx[k]>=6)continue;
if(field[i+yy[k]][j+xx[k]]=='O')field[i+yy[k]][j+xx[k]]='.';
}
field[i][j]='.';
}
}
}
return res;
}
int main() {
int n=in();
while(n--){
int i;
for(i=0;i<12;i++){
cin>>field[i];
}
int res=0;
while(1){
if(!bomb())break;
//for(i=0;i<12;i++){
//cout<<field[i]<<endl;
//}
//cout<<endl;
fall();
//for(i=0;i<12;i++){
//cout<<field[i]<<endl;
//}
//cout<<endl;
res++;
}
cout<<res<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long powm(long long base, long long exp, long long mod = 1000000007) {
base %= mod;
long long ans = 1;
while (exp) {
if (exp & 1LL) ans = (ans * base) % mod;
exp >>= 1LL, base = (base * base) % mod;
}
return ans;
}
long long dp[2002][2002];
void pre(long long n) {
dp[0][0] = 1;
dp[1][1] = 1;
for (int i = 2; i < n; i++) {
for (int j = 0; j <= i; j++) {
dp[i][j] = (((j > 0 ? dp[i - 1][j - 1] : 0) +
(j + 1 <= i ? dp[i - 1][j + 1] : 0)) %
1000000007);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
string s;
cin >> s;
pre(2002);
stack<long long> t;
for (int i = 0; i < m; i++) {
if (t.empty())
t.push(i);
else if (s[i] == ')' && s[t.top()] == '(')
t.pop();
else
t.push(i);
}
int na = 0, nb = 0;
while (!t.empty()) {
int i = t.top();
t.pop();
(s[i] == '(' ? nb++ : na++);
}
long long ans = 0;
for (int i = na; i <= n - m; i++) {
for (int j = i; j <= n - m; j++) {
long long ta = i, tb = nb + i - na;
long long a = j, b = n - m - j;
if (ta > a || tb > b) continue;
long long temp = ((dp[a][ta] * dp[b][tb]) % 1000000007);
ans = ((ans + temp) % 1000000007);
}
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
int main() {
long long p, t, e = 1e18;
scanf("%lld", &p);
t = 9 * e % p * 9 % p;
printf("%lld %lld\n", p - t, e - 1 + p - t);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000;
long long n;
long long a[maxn + 5][2];
long long dp[maxn + 5][2];
int main() {
cin >> n;
for (int i = 0; i < 2; i++) {
for (int j = 1; j <= n; j++) {
scanf("%I64d", &a[j][i]);
}
}
dp[n + 1][1] = dp[n + 1][0] = 0;
long long sum = 0;
long long Ls = 0, Rs = 0;
for (int i = n; i >= 1; i--) {
Ls = Ls + sum + (2 * n - 2 * i + 1) * a[i][1];
Rs = Rs + sum + (2 * n - 2 * i + 1) * a[i][0];
dp[i][0] = max(Ls, a[i][1] + dp[i + 1][1] + 2 * sum);
dp[i][1] = max(Rs, a[i][0] + dp[i + 1][0] + 2 * sum);
sum += a[i][0] + a[i][1];
}
printf("%I64d\n", dp[1][0]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int N = 1e5 + 5;
vector< pair < int , int > > v ;
ll mod = 1e9 + 7 ;
int main()
{
int n ;
cin >> n ;
for(int i =0 ; i < n ; i ++){
int x;
scanf("%d",&x);
v.push_back({x,1});
}
for(int i =0 ; i < n ; i ++){
int y ;
scanf("%d",&y);
v.push_back({y,0});
}
ll res = 1;
int x = 0 ;
sort(v.begin() , v.end());
// x x y
for(int i =0 ; i < v.size() ; i ++){
if(v[i].second == 1){
if(x < 0 )
res = ( res * -x ) % mod ;
x ++ ;
}else{
if(x > 0 )
res = (res * x ) %mod ;
x -- ;
}
}
cout << res << endl ;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n);i++)
#define sz(x) int(x.size())
typedef long long ll;
typedef pair<int,int> P;
const int mod = 1e9+7;
int dp[110][4][4][4];
int main(){
int n;
cin >> n;
dp[0][3][3][3] = 1;
rep(d,n) {
rep(i,4) {
rep(j,4) {
rep(k,4) {
if (dp[d][i][j][k] == 0) continue;
rep(a,4) {
if(a == 2 && i == 1 && j == 0)continue; //AGC
if(a == 2 && i == 0 && j == 1)continue; //GAC
if(a == 1 && i == 2 && j == 0)continue; //ACG
if(a == 2 && i == 1 && k == 0)continue; //A○GC
if(a == 2 && j == 1 && k == 0)continue; //AG○C
(dp[d+1][a][i][j] += dp[d][i][j][k]) %= mod;
}
}
}
}
}
int res = 0;
rep(i,4) rep(j,4) rep(k,4) (res += dp[n][i][j][k]) %= mod;
cout << res << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long d[3333][3333], a[3333], b[3333];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
a[i] -= i;
b[i] = a[i];
}
sort(b + 1, b + 1 + n);
int bn = unique(b + 1, b + 1 + n) - b - 1;
memset(d, 127, sizeof(d));
for (int i = 1; i <= bn; ++i) {
d[1][i] = min(d[1][i - 1], abs(a[1] - b[i]));
}
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= bn; ++j) {
d[i][j] = min(d[i][j - 1], d[i - 1][j] + abs(a[i] - b[j]));
}
}
printf("%I64d", d[n][bn]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k;
cin >> n >> k;
long long int arr[n];
long long int i;
for (i = 0; i < n; i++) cin >> arr[i];
double ma = 0.0;
for (i = k; i <= n; i++) {
double s = 0.0;
int j;
for (j = 0; j < i; j++) s += arr[j];
ma = max(ma, s / i);
for (j = i; j < n; j++) {
s -= arr[j - i];
s += arr[j];
ma = max(ma, s / i);
}
}
cout << fixed << setprecision(20) << ma;
}
| 3 |
#include <vector>
#include <map>
#include <iostream>
#include <string>
using namespace std;
string encode(string name, int k){
string s;
s+=name[0];
for(int i=0;i<name.length();i++){
if(s.length()==k) return s;
if(name[i]=='a'||name[i]=='i'||name[i]=='u'||name[i]=='e'||name[i]=='o'){
s+=name[i+1];
}
}
return s;
}
int main(){
int n;
vector<string> S;
map<string,int> M;
while(cin>>n,n){
S.clear();
for(int i=0;i<n;i++){
string str;
cin>>str;
S.push_back(str);
}
int k=1;
while(true){
M.clear();
for(auto &s:S){
string code=encode(s,k);
if(M.find(code)!=M.end()){
M.clear();
break;
}else{
M[code]=0;
}
}
if(!M.empty()){
cout<<k<<endl;
break;
}else{
k++;
if(k>50){
cout<<-1<<endl;
break;
}else{
continue;
}
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > beauty(6e5 + 2);
int main() {
int n;
cin >> n;
vector<int> city(n);
for (int i = 0; i < n; i++) {
cin >> city[i];
city[i] += n - i;
beauty[city[i]].push_back(i);
}
long long maxBeauty = 0;
long long currentBeauty = 0;
for (int i = 0; i < beauty.size(); i++) {
currentBeauty = 0;
for (int j = 0; j < beauty[i].size(); j++) {
int x = beauty[i][j];
currentBeauty += x + i - n;
}
maxBeauty = max(maxBeauty, currentBeauty);
}
cout << maxBeauty << "\n";
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const int maxx = 100001;
int f[maxx];
int num[maxx];
int read(){int k;scanf("%d",&k);return k;}
int main (){
int n=read();
int m=read();
f[1]=1;
for(int i=1;i<=n;i++)num[i]=1;
for(int i=1;i<=m;i++){
int a=read();int b=read();
if(f[a]==1)f[b]=1;
num[b]++;num[a]--;
if(num[a]==0)f[a]=0;
}
int ans=0;
for(int i=1;i<=n;i++)ans+=f[i];
cout<<ans<<endl;
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int A,B,N;
cin>>N>>A>>B;
int ans=0;
for(int i=0;i<N;i++){
int t;
cin>>t;
if(t<A||B<=t)ans++;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, c, d;
int i, j;
int sum = 0;
for (i = 0; i < n; i++) {
cin >> a >> b;
cin >> c >> d;
sum = sum + (1 + abs(a - c)) * (1 + abs(b - d));
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int a, b, sum = 0, i = 1, j = 1;
cin >> a >> b;
if (a > b) swap(a, b);
while (a != b) {
a++;
sum += i++;
if (a == b) break;
b--;
sum += j++;
}
printf("%d\n", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t;
long long a, b, p, q;
void update(long long a, long long b, long long &diff, long long &ans,
int cur) {
if (a > b) swap(a, b);
int tmp = min(b - a, a + (2 * q) - b);
if (tmp < diff || (tmp == diff && cur < ans)) {
ans = cur;
diff = tmp;
}
}
vector<pair<long long, long long> > v;
int main() {
cin >> t;
while (t--) {
v.clear();
cin >> a >> b >> p >> q;
long long target = q, diff = q, ans = a;
int t = sqrt(b - a + 1);
for (int i = a, j = 0; j < t; i++, j++)
v.push_back(make_pair((2 * p * i) % (2 * q), i));
sort(v.begin(), v.end());
for (int i = 0, j = 0; i < t; i++, j += t) {
if (target > v.back().first) {
long long t = v.back().first;
int p = lower_bound(v.begin(), v.end(), make_pair(t, -1ll)) - v.begin();
update(v[p].first, target, diff, ans, j + v[p].second);
update(v[0].first, target, diff, ans, j + v[0].second);
} else {
int p = upper_bound(v.begin(), v.end(), make_pair(target, -1ll)) -
v.begin();
update(v[p].first, target, diff, ans, j + v[p].second);
int q;
if (p == 0)
q = v.size() - 1;
else
q = p - 1;
long long t = v[q].first;
int r = lower_bound(v.begin(), v.end(), make_pair(t, -1ll)) - v.begin();
update(v[r].first, target, diff, ans, j + v[r].second);
}
target = ((target - 2 * p * t % (2 * q)) % (2 * q) + 2 * q) % (2 * q);
}
for (int i = a + t * t; i <= b; i++) {
long long cur = (2 * p * i) % (2 * q);
update(cur, q, diff, ans, i);
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[1111][1111];
int main() {
int n, m, k, a, b;
scanf("%d%d%d", &n, &m, &k);
int flag = 0;
for (int i = 1; i <= k; i++) {
scanf("%d%d", &a, &b);
arr[a][b] = 1;
if (a == 1) {
if (b == 1) {
if (arr[a][b + 1] == 1 && arr[a + 1][b] == 1 &&
arr[a + 1][b + 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
} else if (b == m) {
if (arr[a][b - 1] == 1 && arr[a + 1][b] == 1 &&
arr[a + 1][b - 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
} else {
if (arr[a][b - 1] == 1 && arr[a + 1][b] == 1 &&
arr[a + 1][b - 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
} else if (arr[a][b + 1] == 1 && arr[a + 1][b] == 1 &&
arr[a + 1][b + 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
}
} else if (a == n) {
if (b == 1) {
if (arr[a][b + 1] == 1 && arr[a - 1][b] == 1 &&
arr[a - 1][b + 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
} else if (b == m) {
if (arr[a][b - 1] == 1 && arr[a - 1][b] == 1 &&
arr[a - 1][b - 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
} else {
if (arr[a][b - 1] == 1 && arr[a - 1][b - 1] == 1 &&
arr[a - 1][b] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
} else if (arr[a][b + 1] == 1 && arr[a - 1][b + 1] == 1 &&
arr[a - 1][b] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
}
} else if (b == 1) {
if (a == 1) {
if (arr[a][b + 1] == 1 && arr[a + 1][b] == 1 &&
arr[a + 1][b + 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
} else if (a == n) {
if (arr[a][b + 1] == 1 && arr[a - 1][b] == 1 &&
arr[a - 1][b + 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
} else {
if (arr[a][b + 1] == 1 && arr[a - 1][b] == 1 &&
arr[a - 1][b + 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
} else if (arr[a][b + 1] == 1 && arr[a + 1][b + 1] == 1 &&
arr[a + 1][b] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
}
} else if (b == m) {
if (a == 1) {
if (arr[a][b - 1] == 1 && arr[a + 1][b] == 1 &&
arr[a + 1][b - 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
} else if (a == n) {
if (arr[a][b - 1] == 1 && arr[a - 1][b] == 1 &&
arr[a - 1][b - 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
} else {
if (arr[a][b - 1] == 1 && arr[a - 1][b] == 1 &&
arr[a - 1][b - 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
} else if (arr[a][b - 1] == 1 && arr[a + 1][b] == 1 &&
arr[a + 1][b - 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
}
} else {
if (arr[a][b - 1] == 1 && arr[a - 1][b] == 1 && arr[a - 1][b - 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
} else if (arr[a][b + 1] == 1 && arr[a - 1][b] == 1 &&
arr[a - 1][b + 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
} else if (arr[a][b - 1] == 1 && arr[a + 1][b - 1] == 1 &&
arr[a + 1][b] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
} else if (arr[a][b + 1] == 1 && arr[a + 1][b] == 1 &&
arr[a + 1][b + 1] == 1) {
printf("%d\n", i);
flag = 1;
break;
flag = 1;
}
}
}
if (flag == 0) {
printf("0\n");
}
}
| 1 |
#include<iostream>
#include<vector>
#include<utility>
#include<algorithm>
using namespace std;
struct UnionFind {
int *data;
UnionFind(int *_data, int size, bool reset = true) : data(_data) {
if(reset) for(int i = 0; i < size; i++) data[i] = -1;
}
bool unionSet(int x, int y) {
x = find(x); y = find(y);
if (x != y) {
if (data[y] < data[x]) std::swap(x, y);
data[x] += data[y]; data[y] = x;
}
return x != y;
}
int find(int x) {
return data[x] < 0 ? x : data[x] = find(data[x]);
}
int size(int x) {
return -data[find(x)];
}
};
int main(int argc, char *argv[])
{
// kruskal with x being unused.
// assumption: es is sorted
auto kruskal = [](int n, const vector<pair<int,pair<int,int>>> &es, int *ufdata, int st, vector<bool> &used) {
UnionFind uf(ufdata, n, false);
int sum = 0;
for(int i = st; i < es.size(); i++) {
const int u = es[i].second.first;
const int v = es[i].second.second;
if(uf.find(u) != uf.find(v)) {
used[i] = true;
uf.unionSet(u, v);
sum += es[i].first;
}
}
return sum;
};
int n, m;
vector<pair<int,pair<int,int>>> es;
cin >> n >> m;
for(int i = 0; i < m; i++) {
int s, d, c;
cin >> s >> d >> c;
es.push_back(make_pair(c, make_pair(s-1, d-1)));
}
sort(es.begin(), es.end());
int mn = -1;
int sum = 0;
int cnt = 0;
vector<int> ufdata(n);
vector<bool> used(m, false);
vector<bool> used2(m, false);
UnionFind uf(&(ufdata[0]), n);
{
vector<int> ufdata2(n);
for(int j = 0; j < n; j++) ufdata2[j] = ufdata[j];
mn = kruskal(n, es, &(ufdata2[0]), 0, used);
}
int ksum = 0;
for(int i = 0; i < m; i++) {
vector<int> ufdata2(n);
for(int j = 0; j < n; j++) ufdata2[j] = ufdata[j];
if(used[i]) {
int mni = ksum + kruskal(n, es, &(ufdata2[0]), i+1, used2);
if(mni != mn) {
cnt ++;
sum += es[i].first;
}
}
const int u = es[i].second.first;
const int v = es[i].second.second;
if(uf.find(u) != uf.find(v)) {
uf.unionSet(u, v);
ksum += es[i].first;
}
}
cout << cnt << " " << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string S, T;
int Q;
int psum[2][100010], la[2][100010];
int calc(int t, int l, int r) { return psum[t][r] - (l ? psum[t][l - 1] : 0); }
char ans[100010];
int main() {
cin >> S >> T;
for (int i = 0; i < S.size(); i++)
if (S[i] == 'C') S[i] = 'B';
for (int i = 0; i < T.size(); i++)
if (T[i] == 'C') T[i] = 'B';
for (int i = 0; i < S.size(); i++) {
psum[0][i] = S[i] == 'B';
if (i) psum[0][i] += psum[0][i - 1];
}
for (int i = 0; i < T.size(); i++) {
psum[1][i] = T[i] == 'B';
if (i) psum[1][i] += psum[1][i - 1];
}
for (int i = 0; i < S.size(); i++) {
la[0][i] = -1;
if (i) la[0][i] = la[0][i - 1];
if (S[i] == 'B') la[0][i] = i;
}
for (int i = 0; i < T.size(); i++) {
la[1][i] = -1;
if (i) la[1][i] = la[1][i - 1];
if (T[i] == 'B') la[1][i] = i;
}
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
a--;
b--;
c--;
d--;
int t1 = calc(0, a, b);
int t2 = calc(1, c, d);
if (t1 > t2 || t1 % 2 != t2 % 2) {
ans[i] = '0';
continue;
}
int s1 = min(b - a + 1, b - la[0][b]);
int s2 = min(d - c + 1, d - la[1][d]);
if (!t1 && t2 && s1 == s2) {
ans[i] = '0';
continue;
}
if (s1 >= s2 && s1 % 3 == s2 % 3) {
ans[i] = '1';
} else if (t1 < t2 && s1 > s2) {
ans[i] = '1';
} else
ans[i] = '0';
}
for (int i = 0; i < Q; i++) {
printf("%c", ans[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 0) {
cout << 1 << endl;
} else {
n = n % 4;
if (n == 0) {
cout << 6 << endl;
} else if (n == 1) {
cout << 8 << endl;
} else if (n == 2) {
cout << 4 << endl;
} else {
cout << 2 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,num;
cin>>N;
vector<int>S(N);
for(int i=0; i<N-1; i++){
cin>>num;
S.at(num-1)++;
}
for(int i=0;i<N;i++){
cout<<S.at(i)<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int ARRAY[100005];
pair<unsigned long long, int> TREE[4 * 100005];
int LAZY[4 * 100005];
unsigned long long pot[100005];
unsigned long long POW(unsigned long long h, int e, int len) {
if (e == 1) return h;
unsigned long long ret = POW(h, e / 2, len);
ret = ret * pot[e / 2 * len] + ret;
ret %= (unsigned long long)1e9 + 7;
if (e & 1) ret = ret * pot[len] + h;
ret %= (unsigned long long)1e9 + 7;
return ret;
}
void init() {
pot[0] = 1;
for (int i = 1; i < 100005; i++) {
pot[i] = pot[i - 1] * 257;
pot[i] %= (unsigned long long)1e9 + 7;
}
}
void create(int n, int i, int j) {
if (i == j)
TREE[n] = make_pair(ARRAY[i], 1);
else {
create(2 * n, i, (i + j) / 2);
create(2 * n + 1, (i + j) / 2 + 1, j);
unsigned long long tmp =
TREE[2 * n].first * pot[TREE[2 * n + 1].second] + TREE[2 * n + 1].first;
tmp %= (unsigned long long)1e9 + 7;
TREE[n] = make_pair(tmp, j - i + 1);
}
}
void lazy(int n, int i, int j) {
if (LAZY[n] != 0) {
LAZY[2 * n] = LAZY[2 * n + 1] = LAZY[n];
int mid = (i + j) / 2;
TREE[2 * n].first = POW(LAZY[n], mid - i + 1, 1);
TREE[2 * n + 1].first = POW(LAZY[n], j - mid, 1);
LAZY[n] = 0;
}
}
pair<unsigned long long, int> query(int n, int i, int j, int qi, int qj) {
if (i > qj || j < qi) return make_pair(0, 0);
if (qi <= i && j <= qj) return TREE[n];
lazy(n, i, j);
pair<unsigned long long, int> L = query(2 * n, i, (i + j) / 2, qi, qj);
pair<unsigned long long, int> R =
query(2 * n + 1, (i + j) / 2 + 1, j, qi, qj);
unsigned long long tmp = L.first * pot[R.second] + R.first;
tmp %= (unsigned long long)1e9 + 7;
return make_pair(tmp, L.second + R.second);
}
void update(int n, int i, int j, int qi, int qj, unsigned long long value) {
if (i > qj || j < qi) return;
if (qi <= i && j <= qj) {
LAZY[n] = value;
TREE[n].first = POW(value, j - i + 1, 1);
return;
}
lazy(n, i, j);
update(2 * n, i, (i + j) / 2, qi, qj, value);
update(2 * n + 1, (i + j) / 2 + 1, j, qi, qj, value);
unsigned long long tmp =
TREE[2 * n].first * pot[TREE[2 * n + 1].second] + TREE[2 * n + 1].first;
tmp %= (unsigned long long)1e9 + 7;
TREE[n] = make_pair(tmp, j - i + 1);
}
int n, m, k, oper, l1, r1, d, l2, r2;
char s[100005];
int main() {
init();
scanf("%d %d %d", &n, &m, &k);
scanf("%s", s);
for (int i = 0; i < 100005; i++) ARRAY[i] = s[i];
create(1, 0, n - 1);
for (int i = 0; i < m + k; i++) {
scanf("%d", &oper);
if (oper == 1) {
scanf("%d %d %d", &l1, &r1, &d);
l1--;
r1--;
update(1, 0, n - 1, l1, r1, d + '0');
} else {
scanf("%d %d %d", &l1, &r1, &d);
l1--;
r1--;
l2 = r1 - d;
r2 = l1 + d;
unsigned long long tmp1 = query(1, 0, n - 1, l1, l2).first;
unsigned long long tmp2 = query(1, 0, n - 1, r2, r1).first;
if (tmp1 == tmp2)
puts("YES");
else
puts("NO");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long double pi = 3.14159265359;
long long mod = 1000000007;
long long GCD(long long n1, long long n2) {
if (n2 != 0)
return GCD(n2, n1 % n2);
else
return n1;
}
long long LCM(long long n1, long long n2) {
long long m;
m = n1 * n2 / GCD(n1, n2);
return m;
}
long long choose(long long n, long long k) {
if (k > n) {
return 0;
}
long long r = 1;
for (long long d = 1; d <= k; ++d) {
r *= n--;
r /= d;
}
return r;
}
bool isprime(int x) {
if (x == 1) return 0;
for (int i = 2; i < x; i++) {
if (x % i == 0) return 0;
}
return 1;
}
long long pow_(long long base, long long exponent) {
long long result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % mod;
exponent = exponent >> 1;
base = (base * base) % mod;
}
return result;
}
const int N = 1e5 + 5;
long long F[N], iF[N];
long long fast(long long b, long long e) {
if (!e) return 1;
if (e & 1) return b * fast(b * b % mod, e >> 1) % mod;
return fast(b * b % mod, e >> 1) % mod;
}
void init() {
F[0] = iF[1] = iF[0] = F[1] = 1;
for (long long i = 2; i < N; i++) {
F[i] = i * F[i - 1] % mod;
iF[i] = fast(F[i], mod - 2);
}
}
long long nCr(int n, int k) {
long long ret = F[n];
ret *= iF[n - k];
ret %= mod;
ret *= iF[k];
ret %= mod;
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int res = 0;
int n, a, b;
cin >> n >> a >> b;
for (int i = 1; i <= n - 1; i++) {
res = max(res, min(a / i, b / (n - i)));
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, max_def, max_num = 0, i, min_total = 0, max_total = 0;
scanf("%lld", &n);
long long int a[n];
for (i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
sort(a, a + n);
if (a[0] == a[n - 1]) {
if (n % 2 == 0)
max_num = (n / 2 * (n - 1));
else
max_num = (n / 2 * n);
} else {
for (i = 0; i < n; i++) {
if (a[i] == a[0]) min_total++;
if (a[i] == a[n - 1]) max_total++;
}
max_num = min_total * max_total;
}
max_def = a[n - 1] - a[0];
printf("%lld %lld\n", max_def, max_num);
return 0;
}
| 2 |
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
int main()
{
int price,n,sum=0,cnt=0;
double average=0;
while (scanf("%d,%d",&price,&n) != EOF)
{
cnt++;
sum+=price*n;
average+=n;
}
average/=cnt;
cout << sum << endl << round(average) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long kadane(long long arr[], int l, int r) {
long long maxs = arr[l];
long long cm = arr[l];
for (long long i = l + 1; i <= r; i++) {
cm = max(arr[i], cm + arr[i]);
maxs = max(maxs, cm);
}
return maxs;
}
void solve() {}
bool compare(pair<int, int> a, pair<int, int> b) {
return abs(a.first - a.second) > abs(b.first - b.second);
}
bool isValid(int arr[501][501], int i, int j, int n, int m) {
if ((i >= 0 || i <= n - 1) && (j >= 0 || j <= m - 1) && (arr[i][j] == 0))
return true;
return false;
}
void dfs(vector<vector<int>> tree, int u, vector<int> &depth,
vector<bool> &visited, int d) {
visited[u] = true;
depth[u] = d;
if (tree[u].size() == 0) return;
for (int i = 0; i < tree[u].size(); i++) {
if (!visited[tree[u][i]]) {
dfs(tree, tree[u][i], depth, visited, d + 1);
}
}
}
bool cmp(int a, int b) { return a > b; }
char S[200004];
int main() {
string S;
cin >> S;
int n = S.length();
if (n == 0 && S[0] == '9') {
cout << 0;
return 0;
}
for (auto i = 0; i < n; i++) {
int x = (int)(S[i] - '0');
if (i == 0 && x == 9) {
cout << 9;
continue;
}
cout << min(x, 9 - x);
}
cout << "\n";
}
| 1 |
// ====================================
// author: M_sea
// website: https://m-sea-blog.com/
// ====================================
#include <bits/stdc++.h>
#define file(x) freopen(#x".in","r",stdin); freopen(#x".out","w",stdout)
#define debug(...) fprintf(stderr,__VA_ARGS__)
using namespace std;
typedef long long ll;
int read() {
int X=0,w=1; char c=getchar();
while (c<'0'||c>'9') { if (c=='-') w=-1; c=getchar(); }
while (c>='0'&&c<='9') X=X*10+c-'0',c=getchar();
return X*w;
}
const int N=200000+10;
int n,m;
struct node { int l,r; } a[N];
priority_queue<int,vector<int>,greater<int>> L;
priority_queue<int> R;
int main() {
n=read(),m=read();
for (int i=1;i<=n;++i) a[i].l=read(),a[i].r=read();
sort(a+1,a+n+1,[](node a,node b) { return a.l<b.l; });
int l=1,r=m,ans=0;
for (int i=1;i<=n;++i) {
L.push(a[i].r);
if (l<=r&&l<=a[i].l) ++l;
else R.push(L.top()),L.pop();
}
while (!R.empty()) {
if (l<=r&&r>=R.top()) --r;
else ++ans;
R.pop();
}
printf("%d\n",ans);
return 0;
} | 0 |
#include <iostream>
using namespace std;
const int millennium = 196470;
int yearToDays(int y) {
return 590 * ((int)(y-1)/3) + 195 * ((y-1)%3);
}
int monthToDays(int y, int m) {
if (y % 3 == 0) {
return 20 * (m-1);
} else {
return 39 * ((int)(m-1)/2) + 20 * ((m-1)%2);
}
}
int main () {
int n;
cin >> n;
while (n--) {
int y, m, d;
cin >> y >> m >> d;
d += yearToDays(y) + monthToDays(y, m);
cout << millennium - d + 1 << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s = "Aaaaaaaaaa";
vector<string> ans, have;
void next_name() {
int i = 0;
while (s[i] == 'Z' || s[i] == 'z') i++;
s[i] = (char)((int)s[i] + 1);
}
int main() {
cin >> n >> k;
ans.resize(n, "kek");
have.resize(n);
ans[0] = s;
for (int i = 0; i < n - k + 1; ++i) cin >> have[i];
for (int i = 1; i < n; ++i) {
next_name();
ans[i] = s;
}
for (int i = 0; i < n - k + 1; ++i) {
if (have[i] == "NO") ans[i + k - 1] = ans[i];
}
for (auto i : ans) cout << i << " ";
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int h, w;
int a[80][80];
bool dp[80][80][12800];
int main() {
cin >> h >> w;
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
cin >> a[i][j];
}
}
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
int b;
cin >> b;
a[i][j] = abs(a[i][j] - b);;
}
}
dp[0][0][a[0][0]] = true;
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
for(int k = 0; k < 12800; k++) {
if (!dp[i][j][k]) continue;
if (i < h - 1) {
int t1 = k+a[i+1][j];
int t2 = abs(k-a[i+1][j]);
dp[i+1][j][t1] = true;
dp[i+1][j][t2] = true;
}
if (j < w - 1) {
int t1 = k+a[i][j+1];
int t2 = abs(k-a[i][j+1]);
dp[i][j+1][t1] = true;
dp[i][j+1][t2] = true;
}
}
}
}
auto& rs = dp[h-1][w-1];
int ans = 0;
while(!rs[ans]) ans++;
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int *d = new int[n];
for (int i = 0; i < n; i++) {
cin >> d[i];
}
long long int minm = INT32_MAX, maxm = 0;
minm = (long long int)d[1] - d[0];
cout << minm << " ";
maxm = (long long int)d[n - 1] - d[0];
cout << maxm << endl;
for (int i = 1; i < n; i++) {
if (i != n - 1)
minm = (long long int)min(d[i] - d[i - 1], d[i + 1] - d[i]);
else
minm = (long long int)d[i] - d[i - 1];
cout << minm << " ";
maxm = (long long int)max(d[i] - d[0], d[n - 1] - d[i]);
cout << maxm << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ar[40325][10];
int n, d, i, j, m, k, ac, mn, mx, ans;
char str[10];
void swap(char *x, char *y) {
char temp;
temp = *x;
*x = *y;
*y = temp;
}
void permute(char *a, int l, int r) {
int i;
if (l == r) {
m = a[0] - '0';
for (k = 1; k < strlen(a); k++) {
m = (m * 10) + ((a[k] - '0') % 10);
}
ar[ac++][j] = m;
} else {
for (i = l; i <= r; i++) {
swap((a + l), (a + i));
permute(a, l + 1, r);
swap((a + l), (a + i));
}
}
}
int main() {
cin >> n >> d;
for (j = 0; j < n; j++) {
ac = 0;
cin >> str;
permute(str, 0, d - 1);
}
ans = 1000000000;
for (i = 0; i < ac; i++) {
mx = 0;
mn = 1000000000;
for (j = 0; j < n; j++) {
mn = min(mn, ar[i][j]);
mx = max(mx, ar[i][j]);
}
ans = min(ans, (mx - mn));
}
cout << ans << endl;
}
| 2 |
#include<bits/stdc++.h>
#define mp make_pair
#define eps 1e-8
using namespace std;
typedef pair<int, int> pii;
int main(){
int a, b, d;
while(cin >> a >> b >> d, a){
int x = 0, y = 0;
pii ans = mp(1e9, 1e9);
for(int i = -1e6; i < 1e6; i++){
x = i;
if((a*x + d) % b != 0)continue;
y = (a*x + d) / b;
if(ans.first + ans.second > abs(x) + abs(y)){
ans = mp(abs(x), abs(y));
}else if(ans.first + ans.second == abs(x) + abs(y)){
if(a*ans.first + b*ans.second > a*abs(x) + b*abs(y))
ans = mp(abs(x), abs(y));
}
}
cout << ans.first << " " << ans.second << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:100000000")
int mas[100100];
int sum[100100];
set<int> st;
int main() {
int n, l, x, y;
scanf("%d %d %d %d", &n, &l, &x, &y);
for (int i = 0; i < n; i++) scanf("%d", &mas[i]);
for (int i = 0; i < n; i++) st.insert(mas[i]);
bool f1 = false;
bool f2 = false;
for (int i = 0; i < n; i++) {
int v = mas[i];
if (st.find(v + x) != st.end()) f1 = true;
if (st.find(v + y) != st.end()) f2 = true;
}
if (f1 && f2) {
printf("0\n");
return 0;
}
if (f1 || f2) {
printf("1\n");
if (f1)
printf("%d\n", y);
else
printf("%d\n", x);
return 0;
}
bool f = false;
for (int i = 0; i < n; i++) {
int v = mas[i];
int lll = v - x;
int rr = v + x;
if (lll >= 0) {
if (st.find(lll + y) != st.end() || st.find(lll - y) != st.end()) {
printf("1\n%d\n", lll);
return 0;
}
}
if (rr <= l) {
if (st.find(rr + y) != st.end() || st.find(rr - y) != st.end()) {
printf("1\n%d\n", rr);
return 0;
}
}
}
printf("2\n%d %d", x, y);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
if (l % 2 != 0) l++;
if (r - l <= 1) {
cout << -1;
return 0;
}
cout << l << " " << l + 1 << " " << l + 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long len[100005], N, K, T;
string s =
"What are you doing at the end of the world? Are you busy? Will you save "
"us?";
string a = "What are you doing while sending \"";
string b = "\"? Are you busy? Will you send \"";
string c = "\"?";
char solve(long long N, long long K) {
if (len[N] < K) {
return '.';
}
if (N == 0) {
return s[K - 1];
}
if (K <= (int)a.size()) {
return a[K - 1];
}
K -= (int)a.size();
if (K <= len[N - 1]) {
return solve(N - 1, K);
}
K -= len[N - 1];
if (K <= (int)b.size()) {
return b[K - 1];
}
K -= (int)b.size();
if (K <= len[N - 1]) {
return solve(N - 1, K);
}
K -= len[N - 1];
return c[K - 1];
}
int main() {
len[0] = 75;
for (int i = 1; i <= 100000; i++) {
if (((2e18) - 68) / 2 >= len[i - 1]) {
len[i] = 2 * len[i - 1] + 68;
} else {
len[i] = (2e18);
}
}
cin >> T;
while (T--) {
cin >> N >> K;
cout << solve(N, K);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
struct Edge {
int v;
long long w;
int nxt;
} edge[N * 2];
int head[N], ecnt;
void add(int u, int v, long long w) {
edge[++ecnt].v = v;
edge[ecnt].w = w;
edge[ecnt].nxt = head[u];
head[u] = ecnt;
}
int n, m;
long long w;
int id[N * 2];
const long long INF = 20000000000000ll + 15ll;
struct Matrix {
long long a[3][3];
long long *operator[](const int x) { return a[x]; }
const long long *operator[](const int x) const { return a[x]; }
Matrix() {}
Matrix(long long _a, long long b, long long c, long long d, long long e,
long long f, long long g, long long h, long long i) {
a[0][0] = _a;
a[0][1] = b;
a[0][2] = c;
a[1][0] = d;
a[1][1] = e;
a[1][2] = f;
a[2][0] = g;
a[2][1] = h;
a[2][2] = i;
}
Matrix operator*(const Matrix &b) const {
Matrix c;
c.a[0][0] =
max(max(a[0][0] + b.a[0][0], a[0][1] + b.a[1][0]), a[0][2] + b.a[2][0]);
c.a[0][1] =
max(max(a[0][0] + b.a[0][1], a[0][1] + b.a[1][1]), a[0][2] + b.a[2][1]);
c.a[0][2] =
max(max(a[0][0] + b.a[0][2], a[0][1] + b.a[1][2]), a[0][2] + b.a[2][2]);
c.a[1][0] =
max(max(a[1][0] + b.a[0][0], a[1][1] + b.a[1][0]), a[1][2] + b.a[2][0]);
c.a[1][1] =
max(max(a[1][0] + b.a[0][1], a[1][1] + b.a[1][1]), a[1][2] + b.a[2][1]);
c.a[1][2] =
max(max(a[1][0] + b.a[0][2], a[1][1] + b.a[1][2]), a[1][2] + b.a[2][2]);
c.a[2][0] =
max(max(a[2][0] + b.a[0][0], a[2][1] + b.a[1][0]), a[2][2] + b.a[2][0]);
c.a[2][1] =
max(max(a[2][0] + b.a[0][1], a[2][1] + b.a[1][1]), a[2][2] + b.a[2][1]);
c.a[2][2] =
max(max(a[2][0] + b.a[0][2], a[2][1] + b.a[1][2]), a[2][2] + b.a[2][2]);
return c;
}
};
struct DelHeap {
multiset<long long, greater<long long>> s;
long long top() { return s.empty() ? 0 : *s.begin(); }
void push(const long long &x) { s.insert(x); }
void del(long long x) {
multiset<long long, greater<long long>>::iterator it = s.find(x);
if (it == s.end()) return;
s.erase(it);
}
long long top2() {
if (s.empty()) return 0;
multiset<long long, greater<long long>>::iterator it = s.begin();
long long mx = *it;
if (s.size() == 1) return mx;
return mx + *(++it);
}
};
namespace LCT {
int fa[N], ch[N][2];
long long val[N];
long long g[N][2];
Matrix ret[N];
DelHeap g0[N], g1[N];
void pushup(int x) {
long long tmp0 = max(g0[x].top(), g1[x].top2());
long long tmp1 = g1[x].top();
ret[x] = Matrix(0, tmp1, tmp0, -INF, val[x], val[x] + tmp1, -INF, -INF, 0);
if (ch[x][0]) {
ret[x] = ret[ch[x][0]] * ret[x];
}
if (ch[x][1]) {
ret[x] = ret[x] * ret[ch[x][1]];
}
}
bool identity(int x) { return ch[fa[x]][1] == x; }
bool isroot(int x) { return (ch[fa[x]][0] != x) && (ch[fa[x]][1] != x); }
void rotate(const int &x) {
int y = fa[x], z = fa[y];
int k = identity(x);
if (!isroot(y)) {
ch[z][identity(y)] = x;
}
ch[y][k] = ch[x][k ^ 1];
ch[x][k ^ 1] = y;
fa[ch[y][k]] = y;
fa[y] = x;
fa[x] = z;
pushup(y);
}
void splay(const int &x) {
while (!isroot(x)) {
int y = fa[x];
if (!isroot(y)) {
rotate(identity(x) ^ identity(y) ? x : y);
}
rotate(x);
}
pushup(x);
}
void access(int x) {
int y = 0;
while (x) {
splay(x);
if (ch[x][1]) {
g0[x].push(max(ret[ch[x][1]][0][1], ret[ch[x][1]][0][2]));
g1[x].push(ret[ch[x][1]][1][2]);
}
if (y) {
g0[x].del(max(ret[y][0][1], ret[y][0][2]));
g1[x].del(ret[y][1][2]);
}
ch[x][1] = y;
pushup(x);
y = x;
x = fa[x];
}
}
void update(long long x, long long y) {
access(x);
val[x] = y;
pushup(x);
splay(x);
}
long long query() {
splay(1);
return ret[1][0][2];
}
void dfs(int x) {
long long mmax = 0, submax = 0;
for (int i = head[x]; i; i = edge[i].nxt) {
int v = edge[i].v;
if (v == fa[x]) continue;
fa[v] = x;
val[v] = edge[i].w;
id[(i + 1) >> 1] = v;
dfs(v);
g1[x].push(g[v][1]);
g0[x].push(g[v][0]);
g[x][0] = max(g[x][0], g[v][0]);
if (g[v][1] > mmax) {
submax = mmax;
mmax = g[v][1];
} else if (g[v][1] > submax) {
submax = g[v][1];
}
}
g[x][1] = mmax + val[x];
g[x][0] = max(g[x][0], mmax + submax);
pushup(x);
}
} // namespace LCT
int main() {
cin >> n >> m >> w;
for (int i = 1; i < n; i++) {
int u, v;
long long w;
cin >> u >> v >> w;
add(u, v, w);
add(v, u, w);
}
LCT::dfs(1);
long long lastans = 0;
while (m--) {
long long x;
long long p;
cin >> x >> p;
x = (x + lastans) % (n - 1) + 1ll;
p = (p + lastans) % w;
LCT::update(id[x], p);
lastans = LCT::query();
cout << lastans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
int n, i, x, y, mul;
vector<int> v[250000], w[250000];
int u[250000];
int uu[250000];
int dfs(int i) {
uu[i] = 1;
int z = 1;
int j;
for (j = 0; j < v[i].size(); j++) z += dfs(v[i][j]);
return z;
}
void dfs2(int i) {
uu[i] = 1;
int j;
for (j = 0; j < w[i].size(); j++)
if (w[i][j] == i)
mul = 1;
else if (!uu[w[i][j]])
dfs2(w[i][j]);
}
int main() {
int ans = 1;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
v[y - 1].push_back(x - 1);
w[y - 1].push_back(x - 1);
w[x - 1].push_back(y - 1);
u[x - 1] = 1;
}
for (i = 0; i < 2 * n; i++)
if (!u[i] && !uu[i]) ans = (long long)ans * dfs(i) % 1000000007;
for (i = 0; i < 2 * n; i++)
if (u[i] && !uu[i]) {
mul = 2;
dfs2(i);
ans = ans * mul % 1000000007;
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int q(int a, int b) {
long long c = 1, m = a, n = b;
while (c > 0) {
c = m % n;
m = n;
n = c;
}
return m;
}
int n = -1, a[10][2], b, c, d, e;
long long sum = 0;
int main() {
cin >> b >> c;
d = b;
e = c;
for (int i = 0; i < 5; i++) {
a[i][0] = d % 10;
a[i][1] = e % 10;
d = d / 10;
e = e / 10;
if (a[i][0] > n) n = a[i][0];
if (a[i][1] > n) n = a[i][1];
}
n++;
d = 0;
int ans = 0;
for (int i = 0; i < 5; i++) {
a[i][0] += a[i][1] + d;
if (a[i][0] >= n)
d = 1;
else
d = 0;
a[i][0] = a[i][0] % n;
if (a[i][0] > 0) ans = i;
}
cout << ans + 1 << endl;
cin >> ans;
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <complex>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <iomanip>
#include <assert.h>
#include <array>
#include <cstdio>
#include <cstring>
#include <random>
#include <functional>
#include <numeric>
#include <bitset>
#include <fstream>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
int N;
vector<pair<char, int>> v;
int idx;
int solve() {
int d = v[idx].first; char c = v[idx].second;
idx ++;
if(isdigit(c)) {
return c - '0';
} else {
int ret = c == '*';
while(idx < N && d < v[idx].first) {
if(c == '*')
ret *= solve();
if(c == '+')
ret += solve();
}
return ret;
}
}
int main() {
while(cin >> N && N) {
v.clear();
rep(i, N) {
string s; cin >> s;
v.push_back({s.size() - 1, s.back()});
}
idx = 0;
cout << solve() << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<long long, long long>;
using vb = vector<bool>;
using vi = vector<long long>;
using vii = vector<ii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long k;
cin >> k;
vi a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort((a).begin(), (a).end());
vvi dp(n + 1, vi(k + 1, 0));
for (long long i = n - 1; i >= 0; i--) {
for (long long team = 1; team <= k; team++) {
long long req = a[i] + 5;
long long j = upper_bound((a).begin(), (a).end(), req) - begin(a);
dp[i][team] = max(dp[i + 1][team], (j - i) + dp[j][team - 1]);
}
}
cout << dp[0][k] << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using PII = pair<int, int>;
template <typename T> using V = vector<T>;
template <typename T> using VV = vector<V<T>>;
template <typename T> using VVV = vector<VV<T>>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define PB push_back
const ll INF = (1LL<<60);
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a<=x&&x<b; }
template<typename T> T ceil(T a, T b) { return a/b + !!(a%b); }
template<class S,class T>
ostream &operator <<(ostream& out,const pair<S,T>& a){
out<<'('<<a.first<<','<<a.second<<')';
return out;
}
template<class T>
ostream &operator <<(ostream& out,const vector<T>& a){
out<<'[';
REP(i, a.size()) {out<<a[i];if(i!=a.size()-1)out<<',';}
out<<']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int p;
cin >> p;
cout << p/500*500 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
static const int MAXN = 50;
static const int MAXK = 300;
static const int LAYERS = 37;
long long t;
int r1[MAXK], c1[MAXK], r2[MAXK], c2[MAXK], k = 0;
inline void add_wall(int R1, int C1, int R2, int C2, bool flip = false) {
if (flip)
r1[k] = R1, c1[k] = C1, r2[k] = R2, c2[k] = C2;
else
r1[k] = C1, c1[k] = R1, r2[k] = C2, c2[k] = R2;
++k;
}
int main() {
srand(114514);
scanf("%I64d", &t);
int n = 2, m = 2;
for (int pow = 0; t > 0; t /= 3, ++pow) {
++n, ++m;
if (pow >= 1) {
add_wall(3 + pow, pow, 3 + pow, pow + 1);
add_wall(pow, 3 + pow, pow + 1, 3 + pow);
if (pow >= 3) {
add_wall(3 + pow, pow - 2, 3 + pow, pow - 1);
add_wall(pow - 2, 3 + pow, pow - 1, 3 + pow);
}
}
bool qwq = rand() & 1;
switch (t % 3) {
case 0:
add_wall(3 + pow, pow + 1, 4 + pow, pow + 1, qwq);
case 1:
add_wall(pow + 1, 3 + pow, pow + 1, 4 + pow, qwq);
case 2:
default:
break;
}
}
++n, ++m;
if (n > 5) {
add_wall(n, m - 5, n, m - 4);
add_wall(n - 5, m, n - 4, m);
}
add_wall(n - 1, m - 2, n, m - 2);
add_wall(n - 1, m - 1, n, m - 1);
add_wall(n - 2, m - 1, n - 2, m);
add_wall(n - 1, m - 1, n - 1, m);
printf("%d %d\n%d\n", n, m, k);
for (int i = 0; i < k; ++i)
printf("%d %d %d %d\n", r1[i], c1[i], r2[i], c2[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[1005];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int l = 0, r = n - 1;
int suml = 0, sumr = 0;
int cnt = 0, ansl = 0, ansr = 0;
while (l <= r) {
if (cnt % 2 == 0) {
int nsuml = 0;
while (l <= r && nsuml <= sumr) {
nsuml += a[l++];
}
ansl += nsuml;
suml = nsuml;
} else {
int nsumr = 0;
while (l <= r && nsumr <= suml) {
nsumr += a[r--];
}
ansr += nsumr;
sumr = nsumr;
}
cnt++;
}
cout << cnt << " " << ansl << " " << ansr << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int section[111];
int profit[111];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < 111; i++) section[i] = 1234;
for (int i = 0; i < m; i++) {
int l, r, t, c;
scanf("%d %d %d %d", &l, &r, &t, &c);
for (int j = l; j <= r; j++)
if (t < section[j]) section[j] = t, profit[j] = c;
}
int total = 0;
for (int i = 1; i <= n; i++) total += profit[i];
printf("%d\n", total);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
struct E {
int k;
long long c;
E() {}
E(int _k, long long _c) : k(_k), c(_c) {}
} es[2000010];
struct Flow {
int n, m, dis[500010];
int qq[500010], qr, ql;
int ptr[500010];
vector<int> e[500010];
void init(int _n) {
n = _n;
m = 0;
for (int i = 0; i < n; i++) {
vector<int> tmp;
e[i].swap(tmp);
}
}
void add_edge(int a, int b, long long c) {
e[a].push_back(m);
es[m] = E(b, c);
m++;
e[b].push_back(m);
es[m] = E(a, 0);
m++;
}
bool BFS() {
memset(dis, -1, n * sizeof(int));
ql = qr = 0;
qq[qr++] = 0;
dis[0] = 0;
while (ql != qr && dis[n - 1] == -1) {
int p = qq[ql++];
for (auto &it : e[p]) {
E ee = es[it];
if (ee.c == 0 || dis[ee.k] != -1) continue;
dis[ee.k] = dis[p] + 1;
qq[qr++] = ee.k;
}
}
return dis[n - 1] != -1;
}
long long go(int p, long long c) {
if (p == n - 1) return c;
long long ret = 0, tmp;
for (int &i = ptr[p]; i < ((int)(e[p]).size()); i++) {
auto it = e[p][i];
E &ee = es[it];
if (ee.c == 0 || dis[p] + 1 != dis[ee.k]) continue;
tmp = go(ee.k, min(c - ret, (long long)ee.c));
ret += tmp;
ee.c -= tmp;
es[it ^ 1].c += tmp;
if (ret == c) break;
}
if (ret == 0) dis[p] = -1;
return ret;
}
long long maxflow() {
long long ret = 0;
while (BFS()) {
memset(ptr, 0, n * sizeof(int));
ret += go(0, 1LL << 60);
}
return ret;
}
} flow;
int x[51][2], y[51][2];
int a[121][121];
int main() {
int n, m;
R(n, m);
if (!m) {
W(0);
return 0;
}
vector<int> xx, yy;
for (int i = 0; i < (m); ++i) {
R(x[i][0], y[i][0], x[i][1], y[i][1]);
xx.emplace_back(x[i][0]);
xx.emplace_back(x[i][1] + 1);
yy.emplace_back(y[i][0]);
yy.emplace_back(y[i][1] + 1);
}
(sort(xx.begin(), xx.end()),
xx.resize(distance(xx.begin(), unique(xx.begin(), xx.end()))));
(sort(yy.begin(), yy.end()),
yy.resize(distance(yy.begin(), unique(yy.begin(), yy.end()))));
for (int k = 0; k < (m); ++k) {
int st_i = (lower_bound(xx.begin(), xx.end(), x[k][0]) - xx.begin()) + 1,
ed_i =
(lower_bound(xx.begin(), xx.end(), x[k][1] + 1) - xx.begin()) + 1;
int st_j = (lower_bound(yy.begin(), yy.end(), y[k][0]) - yy.begin()) + 1,
ed_j =
(lower_bound(yy.begin(), yy.end(), y[k][1] + 1) - yy.begin()) + 1;
for (int i = (st_i); i < (ed_i); ++i)
for (int j = (st_j); j < (ed_j); ++j) {
a[i][j] = 1;
}
}
flow.init(((int)(xx).size()) + ((int)(yy).size()));
for (int i = (1); i < (((int)(xx).size())); ++i)
flow.add_edge(0, i, xx[i] - xx[i - 1]);
for (int i = (1); i < (((int)(yy).size())); ++i)
flow.add_edge(((int)(xx).size()) + i - 1, flow.n - 1, yy[i] - yy[i - 1]);
for (int i = (1); i < (((int)(xx).size())); ++i)
for (int j = (1); j < (((int)(yy).size())); ++j) {
if (a[i][j])
flow.add_edge(i, ((int)(xx).size()) + j - 1, 1000000000000000LL);
}
W(flow.maxflow());
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e3 + 5;
const long long Mod = 1e9 + 7;
long long LenN, LenM, Ans1, Ans2, Ans, Limit;
long long Hash1[3][MAXN], Hash2[3][MAXN], Hash0[MAXN];
long long F[3][MAXN][MAXN], G[3][MAXN][MAXN];
long long B[MAXN];
char Str[3][MAXN];
long long QP(long long B, long long K, long long Mod) {
long long Ans = 1;
for (; K; K >>= 1, B = B * B % Mod)
if (K & 1) Ans = Ans * B % Mod;
return Ans % Mod;
}
template <class T>
void Read(T &X) {
X = 0;
int F = 0;
char Ch = getchar();
while (Ch < '0' || Ch > '9') {
F |= (Ch == '-');
Ch = getchar();
}
while (Ch >= '0' && Ch <= '9') {
X = X * 10 + (Ch ^ 48);
Ch = getchar();
}
X = F ? -X : X;
}
inline void Write(long long X) {
if (X < 0) {
putchar('-');
X = -X;
}
if (X > 9) Write(X / 10);
putchar((X % 10) ^ 48);
}
long long GCD(long long X, long long Y) { return Y == 0 ? X : GCD(Y, X % Y); }
long long Get1(long long Row, long long L, long long R) {
return Hash1[Row][R] - Hash1[Row][L - 1] * B[R - L + 1];
}
long long Get2(long long Row, long long L, long long R) {
return Hash2[Row][L] - Hash2[Row][R + 1] * B[R - L + 1];
}
long long Mix(long long H1, long long H2, long long Len) {
return H1 * B[Len] + H2;
}
void Work() {
memset(F, 0, sizeof(F));
memset(G, 0, sizeof(G));
for (long long i = 1; i <= LenM; i++)
Hash0[i] = Hash0[i - 1] * B[1] + (Str[0][i] - 'a' + 1);
for (long long i = 1; i <= 2; i++) {
for (long long j = 1; j <= LenN; j++) {
for (long long k = j; k >= 1; k--) {
long long Len = 2 * (j - k + 1);
if (Len > LenM) continue;
long long HA = Get1(i, k, j);
long long HB = Get2(3 - i, k, j);
long long HH = Hash0[Len];
if (Mix(HB, HA, j - k + 1) == HH) {
if (Len == LenM)
Ans1++;
else
G[i][j][Len] = 1;
}
}
}
}
for (long long i = 1; i <= 2; i++) {
for (long long j = 1; j <= LenN; j++)
if (Str[i][j] == Str[0][1]) {
G[i][j][1] = 1;
}
}
for (long long k = 1; k <= LenM - 1; k++) {
for (long long j = 1; j <= LenN; j++) {
for (long long i = 1; i <= 2; i++) {
if (G[i][j][k] && j < LenN && Str[i][j + 1] == Str[0][k + 1]) {
F[i][j + 1][k + 1] += G[i][j][k];
F[i][j + 1][k + 1] %= Mod;
}
if (F[i][j][k] && j < LenN && Str[i][j + 1] == Str[0][k + 1]) {
F[i][j + 1][k + 1] += F[i][j][k];
F[i][j + 1][k + 1] %= Mod;
}
if (F[i][j][k] && Str[3 - i][j] == Str[0][k + 1]) {
G[3 - i][j][k + 1] += F[i][j][k];
G[3 - i][j][k + 1] %= Mod;
}
}
}
}
for (long long i = LenM; i >= 1; i--)
Hash0[i] = Hash0[i + 1] * B[1] + (Str[0][i] - 'a' + 1);
for (long long i = 1; i <= 2; i++) {
for (long long j = 1; j <= LenN; j++) {
if (Str[i][j] == Str[0][LenM]) {
if (LenM == 1) Ans2++;
Ans2 += F[i][j - 1][LenM - 1];
Ans2 += G[i][j - 1][LenM - 1];
Ans2 %= Mod;
}
for (long long k = j; k <= LenN; k++) {
long long Len = 2 * (k - j + 1);
if (Len > LenM) continue;
long long HA = Get1(3 - i, j, k);
long long HB = Get2(i, j, k);
long long HH = Hash0[LenM - Len + 1];
if (Mix(HA, HB, k - j + 1) == HH) {
if (Len == LenM && LenM != 2)
Ans1++;
else {
Ans2 += F[i][j - 1][LenM - Len];
Ans2 += G[i][j - 1][LenM - Len];
Ans2 %= Mod;
}
}
}
}
}
}
int main() {
scanf("%s", Str[1] + 1);
scanf("%s", Str[2] + 1);
scanf("%s", Str[0] + 1);
LenN = strlen(Str[1] + 1);
LenM = strlen(Str[0] + 1);
Limit = max(LenN, LenM);
B[0] = 1;
B[1] = 131;
for (long long i = 2; i <= Limit; i++) B[i] = B[i - 1] * 131;
for (long long i = 1; i <= 2; i++)
for (long long j = 1; j <= LenN; j++)
Hash1[i][j] = Hash1[i][j - 1] * B[1] + (Str[i][j] - 'a' + 1);
for (long long i = 1; i <= 2; i++)
for (long long j = LenN; j >= 1; j--)
Hash2[i][j] = Hash2[i][j + 1] * B[1] + (Str[i][j] - 'a' + 1);
Work();
for (long long i = 1; i <= LenM / 2; i++) {
swap(Str[0][i], Str[0][LenM - i + 1]);
}
Work();
Ans = (Ans1 / 2 + Ans2) % Mod;
if (LenM == 1) Ans /= 2;
printf("%lld\n", Ans % Mod);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
long long x = max(a, c);
long long y = min(b, d);
if (x > y) {
cout << "0" << endl;
} else if (k >= x && k <= y) {
cout << y - x << endl;
} else
cout << y - x + 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1000005;
using namespace std;
long long int power(long long int x, long long int y, long long int m) {
if (y == 0) return 1;
long long int p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
char c[1005][1005];
long long int l[1005][1005], r[1005][1005], u[1005][1005], d[1005][1005],
pre[1005][1005], suf[1005][1005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int dx[] = {1, 0, -1, 0};
long long int dy[] = {0, 1, 0, -1};
vector<pair<pair<long long int, long long int>, long long int>> v;
memset(l, 0, sizeof(l));
memset(r, 0, sizeof(r));
memset(u, 0, sizeof(u));
memset(d, 0, sizeof(d));
memset(pre, 0, sizeof(pre));
memset(suf, 0, sizeof(suf));
long long int n, m;
cin >> n >> m;
for (long long int i = 1; i <= n; i++)
for (long long int j = 1; j <= m; j++) cin >> c[i][j];
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (c[i][j] == '*') {
l[i][j] += l[i][j - 1] + 1;
d[i][j] += d[i - 1][j] + 1;
}
}
}
for (long long int i = n; i >= 1; i--) {
for (long long int j = m; j >= 1; j--) {
if (c[i][j] == '*') {
r[i][j] += r[i][j + 1] + 1;
u[i][j] += u[i + 1][j] + 1;
}
}
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (c[i][j] == '*') {
long long int ll = min(r[i][j], min(u[i][j], min(l[i][j], d[i][j])));
if (ll > 1) {
v.push_back(make_pair(make_pair(i, j), ll - 1));
pre[i][j - ll + 1]++;
pre[i][j + ll]--;
suf[i - ll + 1][j]++;
suf[i + ll][j]--;
}
}
}
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
pre[i][j] += pre[i][j - 1];
suf[i][j] += suf[i - 1][j];
}
}
long long int oOOoOooOOoOOoO = 0;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (c[i][j] == '*' && pre[i][j] == 0 && suf[i][j] == 0) {
oOOoOooOOoOOoO = 1;
break;
}
}
if (oOOoOooOOoOOoO) break;
}
if (oOOoOooOOoOOoO)
cout << -1 << endl;
else {
cout << v.size() << endl;
for (auto it : v)
cout << it.first.first << ' ' << it.first.second << ' ' << it.second
<< endl;
}
return 0;
}
| 5 |
#include<iostream>
using namespace std;
const long long m=1e9+7;
long long n,x;
long long qpow(long long a,long long n)
{
long long ans=1;
while(n)
{
if(n&1) ans=(ans*a)%m;
a=(a*a)%m;
n>>=1;
}
return ans;
}
long long c(long long n,long long r)
{
long long ans=1,ans1=1;
for(long long i=n-r+1;i<=n;i++)
ans=(ans*i)%m;
for(long long i=2;i<=r;i++)
ans1=(ans1*i)%m;
ans1=qpow(ans1,m-2);
ans=(ans*ans1)%m;
return ans;
}
int main()
{
int a,b;
cin>>n>>a>>b;
x=qpow(2,n) ;
x=(x-1-c(n,a)-c(n,b)+2*m)%m;
cout<<x<<endl;
return 0;
} | 0 |
#include<iostream>
#include<string>
#include<iomanip>
#include<cmath>
#include<vector>
#include<algorithm>
using namespace std;
#define int long long
#define rep(i,n) for(int i = 0; i < (n); i++)
#define INF ((long long)1e18)
#define MOD ((int)1e9+7)
#define endl "\n"
#define yn(f) ((f)?"Yes":"No")
#define YN(f) ((f)?"YES":"NO")
#define MAX 110000
int N;
int a[MAX];
int used[MAX];
int used2[MAX];
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
int ans = 0;
cin>>N;
for(int i = 0; i < N; i++){
cin>>a[i];
}
for(int i = 0; i < N; i++){
if(used[i]) continue;
int po = i;
for(int j = 1; ;j++){
// cout<<"j = "<<j<<" po = "<<po<<" "<<used2[po]<<endl;
if(used2[po] == i+1){
ans += j-used[po];
break;
}
if(used[po]) break;
used2[po] = i+1;
used[po] = j;
po += a[po];
po %= N;
}
}
// for(int i = 0; i < N; i++){
// cout<<used[i]<<endl;
// }
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct BNode {
int _arr[316];
long long _sum[5];
int _cnt;
BNode *_prev, *_next;
BNode() : _cnt(0), _prev(0), _next(0) { update(); }
void update() {
memset(_sum, 0, sizeof(_sum));
for (int i = 0; i < _cnt; ++i) _sum[i % 5] += _arr[i];
}
void insert(int p, const int &x) {
for (int i = _cnt++; i > p; --i) _arr[i] = _arr[i - 1];
_arr[p] = x;
update();
}
void insert2(int p, const int &x) {
for (int i = 0; i < p; ++i) _arr[i] = _arr[i + 1];
_arr[p] = x;
update();
}
void erase(int p) {
--_cnt;
for (int i = p; i < _cnt; ++i) _arr[i] = _arr[i + 1];
update();
}
};
struct Rope {
BNode *_head, *_tail;
Rope() {
_head = new BNode;
_tail = new BNode;
_head->_next = _tail;
_tail->_prev = _head;
_head->_cnt = _tail->_cnt = 316;
}
~Rope() {
delete _head;
delete _tail;
}
void clear() {}
bool empty() const { return _head->_next == _tail; }
void insert(const int &x) {
if (empty()) {
BNode *nd = new BNode;
nd->insert(0, x);
nd->_next = _tail;
nd->_prev = _head;
_tail->_prev = nd;
_head->_next = nd;
return;
}
BNode *it;
for (it = _head->_next; it != _tail; it = it->_next)
if (x <= it->_arr[it->_cnt - 1]) break;
if (it == _tail) it = it->_prev;
int p = lower_bound(it->_arr, it->_arr + it->_cnt, x) - it->_arr;
if (it->_cnt < 316) {
it->insert(p, x);
} else {
if (it->_prev->_cnt < 316) {
if (p == 0)
it->_prev->insert(it->_prev->_cnt, x);
else {
it->_prev->insert(it->_prev->_cnt, it->_arr[0]);
it->insert2(p - 1, x);
}
} else if (it->_next->_cnt < 316) {
if (p == 316)
it->_next->insert(0, x);
else {
it->_next->insert(0, it->_arr[it->_cnt - 1]);
--it->_cnt;
it->insert(p, x);
}
} else {
BNode *nd = new BNode;
if (p < 316) {
nd->insert(0, it->_arr[316 - 1]);
--it->_cnt;
it->insert(p, x);
} else
nd->insert(0, x);
nd->_next = it->_next;
nd->_prev = it;
it->_next = nd;
nd->_next->_prev = nd;
}
}
}
void erase(const int &x) {
BNode *it;
for (it = _head->_next; it != _tail; it = it->_next)
if (x <= it->_arr[it->_cnt - 1]) break;
if (it == _tail) return;
int p = lower_bound(it->_arr, it->_arr + it->_cnt, x) - it->_arr;
if (p == it->_cnt || it->_arr[p] != x) return;
for (int i = p; i < it->_cnt - 1; ++i) it->_arr[i] = it->_arr[i + 1];
--it->_cnt;
if (it->_cnt + it->_prev->_cnt <= 316) {
copy(it->_arr, it->_arr + it->_cnt, it->_prev->_arr + it->_prev->_cnt);
it = it->_prev;
it->_cnt += it->_next->_cnt;
BNode *t = it->_next;
it->_next = it->_next->_next;
it->_next->_prev = it;
delete t;
} else if (it->_cnt + it->_next->_cnt <= 316) {
copy(it->_next->_arr, it->_next->_arr + it->_next->_cnt,
it->_arr + it->_cnt);
it->_cnt += it->_next->_cnt;
BNode *t = it->_next;
it->_next = it->_next->_next;
it->_next->_prev = it;
delete t;
}
it->update();
}
long long query() {
BNode *it;
long long ans = 0;
int cnt = 0;
for (it = _head->_next; it != _tail; it = it->_next) {
ans += it->_sum[((2 - cnt) % 5 + 5) % 5];
cnt += it->_cnt;
}
return ans;
}
} rope;
int main() {
int n, x;
char opt[15];
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s", opt);
if (opt[0] == 'a') {
scanf("%d", &x);
rope.insert(x);
} else if (opt[0] == 'd') {
scanf("%d", &x);
rope.erase(x);
} else {
printf("%I64d\n", rope.query());
}
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.