solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define Fast_IO ios::sync_with_stdio(false);
#define int long long
#define mod 998244353
inline int read()
{
char ch=getchar(); int nega=1; while(!isdigit(ch)) {if(ch=='-') nega=-1; ch=getchar();}
int ans=0; while(isdigit(ch)) {ans=ans*10+ch-48;ch=getchar();}
if(nega==-1) return -ans;
return ans;
}
#define N 200005
int lowbit(int x){return x&(-x);}
struct Node
{
int x,y,rk,num;// y rk
};
Node a[N];
Node b[N];
bool cmp1(Node x,Node y)
{
return x.y<y.y;
}
bool cmp2(Node x,Node y)
{
return x.x<y.x;
}
int t1[N],t2[N];
int n;
void add1(int u,int d)
{
while(u<=n) t1[u]+=d,u+=lowbit(u);
}
void add2(int u,int d)
{
while(u<=n) t2[u]+=d,u+=lowbit(u);
}
int sum1(int u)
{
int ans=0;
while(u) ans+=t1[u],u-=lowbit(u);
return ans;
}
int sum2(int u)
{
int ans=0;
while(u) ans+=t2[u],u-=lowbit(u);
return ans;
}
int qpow(int x,int y)
{
int ans=1;
while(y)
{
if(y&1) ans=ans*x%mod;
x=x*x%mod;
y>>=1;
}
return ans;
}
signed main()
{
#ifdef __LOCAL__
freopen("in.txt","r",stdin);
#endif
n=read();
for(int i=1;i<=n;i++)
{
a[i].x=read(),a[i].y=read();
b[i].y=a[i].y,b[i].num=i;
}
sort(b+1,b+n+1,cmp1);
for(int i=1;i<=n;i++)
{
a[b[i].num].rk=i;
}
sort(a+1,a+n+1,cmp2);
for(int i=1;i<=n;i++)
{
add2(i,1);
}
int ans=0;
for(int i=1;i<=n;i++)
{
add2(a[i].rk,-1);
int A=sum1(a[i].rk),B=sum1(n)-A,C=sum2(a[i].rk),D=sum2(n)-C;
int ta=qpow(2,A),tb=qpow(2,B),tc=qpow(2,C),td=qpow(2,D);
ans=(ans+(ta-1)*(td-1)%mod*tb%mod*tc)%mod;
ans=(ans+(tb-1)*(tc-1)%mod*ta%mod*td)%mod;
ans=(ans-(tb-1)*(tc-1)%mod*(ta-1)%mod*(td-1))%mod;
ans=(ans+qpow(2,n-1));
add1(a[i].rk,1);
}
ans=(ans%mod+mod)%mod;
cout<<ans<<endl;
#ifdef __LOCAL__
printf("Time Used : %d\n",clock());
#endif
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
long long updiv(long long a, long long b) {
if (a % b == 0)
return (a / b);
else
return (a / b) + 1;
}
long long mymod(long long x, long long m) {
if (x > 0)
return x % m;
else
return ((x) % (m) + (m)) % (m);
}
long long XOR(long long n) {
if (n % 4 == 0) return n;
if (n % 4 == 1) return 1;
if (n % 4 == 2) return n + 1;
return 0;
}
long long G(long long x) {
long long a = x % 8;
if (a == 0 || a == 1) return x;
if (a == 2 || a == 3) return 2;
if (a == 4 || a == 5) return x + 2;
if (a == 6 || a == 7) return 0;
return 0;
}
long long countSetBits(long long n) {
if (n == 0)
return 0;
else
return 1 + countSetBits(n & (n - 1));
}
long long spf[10000001];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 10000001; i++) spf[i] = i;
for (long long i = 4; i < 10000001; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 10000001; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 10000001; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
map<long long, long long> mp;
long long getFactorization(long long x) {
vector<long long> ret;
long long ans = 1;
mp.clear();
while (x != 1) {
mp[spf[x]]++;
x = x / spf[x];
}
for (auto P : mp) {
if (P.second % 2 == 1) ans *= P.first;
}
return ans;
}
long long power(long long x, long long y) {
long long res = 1;
x = x % 1000000007;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res;
}
void solve() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long c2 = n / 3;
if (n % 3 == 2) {
c2++;
}
long long c1 = n - (2 * c2);
cout << c1 << " " << c2 << '\n';
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tc = 1;
cin >> tc;
while (tc--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e3;
long long a[20];
long long b[20];
int main() {
long long n, m, ans, piu, pia, sum;
while (~scanf("%I64d", &a[1])) {
ans = 0;
for (int i = 2; i <= 14; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= 14; i++) {
if (a[i] == 0) continue;
sum = 0;
b[i] = 0;
for (int j = 1; j <= 14; j++)
if (j != i) b[j] = a[j];
for (int j = 1; j <= 14; j++) {
piu = (i + j) % 14;
if (piu == 0) piu = 14;
b[piu] += a[i] / 14;
}
pia = a[i] % 14;
for (int j = 1; j <= pia; j++) {
piu = (i + j) % 14;
if (piu == 0) piu = 14;
b[piu]++;
}
for (int j = 1; j <= 14; j++) {
if (b[j] % 2 == 0) sum += b[j];
}
ans = max(sum, ans);
}
printf("%I64d\n", ans);
}
return 0;
}
| 2 |
// #include {{{
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <ctime>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <string>
#include <bitset>
#include <vector>
#include <complex>
#include <algorithm>
using namespace std;
// }}}
// #define {{{
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
typedef vector<int> vi;
#define de(x) cout << #x << "=" << x << endl
#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 all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
// }}}
const int N = 40404;
const db inf = 1e20;
int n , a[N] , b[N] , c[N] , s[N] , t[N];
db Y[N];
template<class T>
struct Fenwick{
#define lb(x) ((x)&-(x))
int n;T a[N];
void ini(int _n){ fill_n(a+1,n=_n,0);}
void add(int x,T d){ for(;x<=n;x+=lb(x)) a[x]+=d;}
T sum(int x){ T r=0;for(;x>=1;x^=lb(x)) r+=a[x];return r;}
};
Fenwick<int> fen;
db solve() {
rep(i,0,n) s[i] = t[i] = i;
int need = (n * (n - 1) / 2 + 1) / 2;
db l = -inf , r = inf;
rep(i,0,n) Y[i] = (c[i] - a[i] * l) / b[i];
sort(t , t + n , [&](int x,int y){return Y[x] < Y[y];});
rep(i,0,n) s[t[i]] = i;
rep(i,0,200) {
db m = (l + r) / 2;
rep(i,0,n) Y[i] = (c[i] - a[i] * m) / b[i];
sort(t , t + n , [&](int x,int y){return Y[x] < Y[y];});
int cnt = 0;
fen.ini(n);
rep(i,0,n) cnt+=i-fen.sum(s[t[i]]+1),fen.add(s[t[i]]+1,1);
if(cnt >= need) r = m;
else l = m;
}
return r;
}
int main(){
scanf("%d",&n);
rep(i,0,n) scanf("%d%d%d",a+i,b+i,c+i);
pair<db,db> ans;
ans.fi = solve();
rep(i,0,n) swap(a[i] , b[i]);
ans.se = solve();
printf("%.16f %.16f\n",ans.fi , ans.se);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 55;
const int d[4][2] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
int n, m;
char map[MAXN][MAXN];
int last[MAXN][MAXN];
bool vis[MAXN][MAXN];
bool BFS(int x0, int y0) {
static int que[MAXN * MAXN][2];
char color = map[x0][y0];
int x, y;
memset(vis, 0, sizeof(vis));
que[0][0] = x0;
que[0][1] = y0;
vis[x0][y0] = true;
for (int l = 0, r = 1; l < r; ++l) {
x0 = que[l][0];
y0 = que[l][1];
for (int i = 0; i < 4; ++i) {
x = x0 + d[i][0];
y = y0 + d[i][1];
if (map[x][y] == color) {
if (!vis[x][y]) {
vis[x][y] = true;
last[x][y] = i;
que[r][0] = x;
que[r][1] = y;
++r;
} else if (i + last[x0][y0] != 3)
return true;
}
}
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%s", map[i] + 1);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (!vis[i][j] && BFS(i, j)) {
puts("Yes");
return 0;
}
puts("No");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long MOD = (long long)1e9 + 7;
long long add(long long x, long long y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
long long sub(long long x, long long y) {
x -= y;
if (x < 0) return x + MOD;
return x;
}
long long mult(long long x, long long y) { return (x * y) % MOD; }
long long bin_pow(long long x, long long p) {
if (p == 0) return 1;
if (p & 1) return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
long long rev(long long x) { return bin_pow(x, MOD - 2); }
const int N = 7;
const int M = (1 << N) + 1;
int ppc[M];
int idInPpc[M];
vector<int> maskForPpc[N + 1];
long long trans[N + 1][M][M];
int n;
unordered_map<long long, long long> dp[N + 1];
long long A[N][N];
void precalc() {
for (int mask = 1; mask < (1 << n); mask++)
ppc[mask] = ppc[mask >> 1] + (mask & 1);
for (int mask = 0; mask < (1 << n); mask++) {
int k = ppc[mask];
idInPpc[mask] = (int)maskForPpc[k].size();
maskForPpc[k].push_back(mask);
}
for (int k = 0; k <= n; k++)
for (int i = 0; i < (int)maskForPpc[k].size(); i++) {
int inM = maskForPpc[k][i];
for (int mask = 0; mask < (1 << n); mask++) {
long long res = 0;
if ((mask & inM) == mask) continue;
for (int v = 0; v < n; v++) {
if (((mask >> v) & 1) == 0) continue;
if ((inM >> v) & 1) continue;
int nmask = inM | (1 << v);
res |= 1LL << idInPpc[nmask];
}
trans[k][i][mask] = res;
}
}
}
void read() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%lld", &A[i][j]);
A[i][j] = mult(A[i][j], rev(100));
}
}
int main() {
scanf("%d", &n);
precalc();
read();
dp[0][1] = 1;
for (int k = 0; k < n; k++)
for (int mask = 0; mask < (1 << n); mask++) {
long long W = 1;
for (int i = 0; i < n; i++) {
if ((mask >> i) & 1)
W = mult(W, A[k][i]);
else
W = mult(W, sub(1, A[k][i]));
}
for (pair<long long, long long> s : dp[k]) {
long long zmask = s.first, val = s.second;
long long nmask = 0;
for (int i = 0; i < (int)maskForPpc[k].size(); i++) {
if ((zmask >> i) & 1) nmask |= trans[k][i][mask];
}
if (nmask == 0) continue;
val = mult(val, W);
dp[k + 1][nmask] = add(dp[k + 1][nmask], val);
}
}
printf("%lld\n", dp[n][1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ans, n;
vector<int> factors;
int logCal(long long int a, long long int b) {
int power = 0;
while (a > b) {
b *= 2;
power++;
}
return power;
}
void setAns(long long int a, long long int b, long long int h, long long int w,
int i) {
if (h >= a && w >= b) {
ans = min(ans, i);
return;
}
if (i == n) return;
if (factors[i] == 2) {
int x, y;
x = logCal(a, h);
y = logCal(b, w);
if (x + y <= n - i) {
ans = min(ans, i + x + y);
}
return;
}
if (h < a) setAns(a, b, h * factors[i], w, i + 1);
if (w < b) setAns(a, b, h, w * factors[i], i + 1);
}
int main() {
long long int a, b, h, w;
int x, m, ans1;
vector<int> pp;
cin >> a >> b >> h >> w >> m;
for (int i = 0; i < m; i++) {
cin >> x;
pp.push_back(x);
}
sort(pp.begin(), pp.end());
n = min(m, 35);
for (int i = 0; i < n; i++) {
factors.push_back(pp[m - 1 - i]);
}
if ((h >= a && w >= b) || (w >= a && h >= b)) {
cout << "0\n";
return 0;
}
ans = 999999;
setAns(a, b, h, w, 0);
setAns(a, b, w, h, 0);
if (ans == 999999) {
cout << "-1\n";
} else {
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int pos1 = s.find('C'), pos2 = s.rfind('F');
if (pos1 == -1 || pos2 == -1) puts("No");
else if (pos2 > pos1) puts("Yes");
else puts("No");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
pair<int, int> A[MAXN], L[MAXN], R[MAXN];
const int inf = 1e9 + 7;
int N;
long long sqr(int x) { return x * 1LL * x; }
pair<int, int> update(pair<int, int> q, pair<int, int> p) {
pair<int, int> ans;
ans.first = min(q.first, p.first);
ans.second = max(q.second, p.second);
return ans;
}
bool check(long long d) {
if (sqr(A[N].first - A[1].first) <= d || sqr(L[N].second - L[N].first) <= d)
return true;
for (int l = 1, r = 1; l <= N && A[l].first <= 0; l++) {
while (r < N && sqr(A[r + 1].first - A[l].first) <= d &&
abs(A[r + 1].first) <= abs(A[l].first)) {
r++;
}
while (abs(A[r].first) > abs(A[l].first)) {
r--;
}
long long x = max(L[l - 1].second, R[r + 1].second);
long long y = min(L[l - 1].first, R[r + 1].first);
long long z = max(sqr(x), sqr(y));
if (sqr(x - y) <= d && z + sqr(A[l].first) <= d) return true;
}
for (int l = N, r = N; r >= 1 && A[r].first >= 0; r--) {
while (l > 1 && sqr(A[r].first - A[l - 1].first) <= d &&
abs(A[l - 1].first) <= abs(A[r].first)) {
l--;
}
while (abs(A[l].first) > abs(A[r].first)) {
l++;
}
long long x = max(L[l - 1].second, R[r + 1].second);
long long y = min(L[l - 1].first, R[r + 1].first);
long long z = max(sqr(x), sqr(y));
if (sqr(x - y) <= d && z + sqr(A[r].first) <= d) return true;
}
return false;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d%d", &A[i].first, &A[i].second);
}
sort(A + 1, A + N + 1);
L[0] = pair<int, int>(inf, -inf);
R[N + 1] = pair<int, int>(inf, -inf);
for (int i = 1; i <= N; i++) {
L[i] = update(L[i - 1], pair<int, int>(A[i].second, A[i].second));
}
for (int i = N; i >= 1; i--) {
R[i] = update(R[i + 1], pair<int, int>(A[i].second, A[i].second));
}
long long l = 0, r = 1LL << 60;
long long ans = r;
while (l <= r) {
long long mid = l + r >> 1;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll p = 998244353;
const int M = 1e6+5;
ll fact[M], invfact[M];
ll n, m;
ll exp(ll x, ll k) {
if (k == 0)
return 1;
ll y = exp(x, k/2);
if (k%2 == 0)
return y*y%p;
return y*y%p*x%p;
}
ll inv(ll x) { return exp(x, p-2); }
void precomp() {
fact[0] = invfact[0] = 1;
for (int i = 1; i <= M; ++i) {
fact[i] = i*fact[i-1]%p;
invfact[i] = inv(fact[i]);
}
}
ll binom(ll x, ll y) {
if (x < 0 || y < 0 || x < y)
return 0;
return fact[x]*invfact[y]%p*invfact[x-y]%p;
}
int main() {
cin >> n >> m;
if (n < m)
swap(n, m);
precomp();
ll ct = 0;
for (int i = 0; i <= m; ++i) {
//prob you touch (i, i) from (n, m);
ct = (ct + binom(n+m-2*i, n-i)*binom(2*i, i))%p;
}
ct = ct*inv(binom(n+m, n))%p;
cout << (n+m+ct+(n-m-1))*(p+1)/2%p << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define repl(i, a, n) for(int i = ((int) a); i < ((int) n); i++)
#define rep(i,n) repl(i,0,n)
#define INF INT_MAX/3
typedef long long ll;
typedef pair<int,int> P;
bool is_prime[1100001];
int cav[2000][2000];
P mem[2000][2000];
int dx[]={1,0,-1,0};
int dy[]={0,-1,0,1};
P dfs(int i,int j,int maxp){
if(cav[i][j]>maxp)return P(0,0);
if(mem[i][j]!=P(-1,-1))return mem[i][j];
P res=P(0,0);
if(i+1<2000){
res=max(res,dfs(i+1,j,maxp));
if(j-1>=0)res=max(res,dfs(i+1,j-1,maxp));
if(j+1<2000)res=max(res,dfs(i+1,j+1,maxp));
}
if(is_prime[cav[i][j]]){
if(res.first==0)res.second=cav[i][j];
res.first++;
}
return mem[i][j]=res;
}
int main(void) {
is_prime[0]=is_prime[1]=false;
for(int i=2;i<=1100000;i++)is_prime[i]=true;
for(int i=2;i<=1100000;i++){
if(is_prime[i]){
for(int j=i*2;j<=1100000;j+=i)is_prime[j]=false;
}
}
rep(i,2000)rep(j,2000)cav[i][j]=INF;
int si=1000,sj=1000,len=1,num=1,dir=0;
while(num<=1000000){
rep(i,len){
cav[si][sj]=num++;
si+=dy[dir];
sj+=dx[dir];
}
dir=(dir+1)%4;
if(dir==0||dir==2)len++;
}
while(1) {
int n,s;
cin>>n>>s;
if(n==0&&s==0)break;
rep(i,2000)rep(j,2000)mem[i][j]=P(-1,-1);
P res=P(0,0);
rep(i,2000)rep(j,2000){
if(cav[i][j]==s){
res=dfs(i,j,n);
break;
}
}
printf("%d %d\n", res.first,res.second);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[30][30][5005];
int good[30];
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int len = s.length();
double ans = 0.0;
for (int i = 0; i < len; ++i) {
good[s[i] - 'a']++;
int dist = 0;
for (int j = i + 1; j < len; ++j) {
++dist;
dp[s[i] - 'a'][s[j] - 'a'][dist]++;
}
for (int j = 0; j < i; ++j) {
++dist;
dp[s[i] - 'a'][s[j] - 'a'][dist]++;
}
}
for (int i = 'a'; i <= 'z'; ++i) {
if (!good[i - 'a']) {
continue;
}
int mn = 1000000;
int cnt = 0;
for (int dist = 1; dist < len; ++dist) {
int cnt_tmp = 1;
int mn_tmp = 1000000;
for (int j = 'a'; j <= 'z'; ++j) {
if (dp[i - 'a'][j - 'a'][dist]) {
if (dp[i - 'a'][j - 'a'][dist] == mn_tmp) {
++cnt_tmp;
}
if (dp[i - 'a'][j - 'a'][dist] < mn_tmp) {
mn_tmp = dp[i - 'a'][j - 'a'][dist];
cnt_tmp = 1;
}
}
}
if (mn_tmp == 1) {
cnt = max(cnt, cnt_tmp);
mn = min(mn, mn_tmp);
}
}
if (mn == 1) {
ans += 1.0 * cnt / len;
}
}
cout << setprecision(9) << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50005;
const double inf = 0.000001;
const int INF = ~0U >> 1;
const int mod = 1000000007;
int n, a[maxn][6], m;
int equal(double x, double y) {
if (x - y >= -inf && x - y <= inf)
return 0;
else if (x - y > inf)
return 1;
return -1;
}
int main() {
scanf("%d", &n), scanf("%d", &m);
int sum = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a[i][j] += max(a[i - 1][j], a[i][j - 1]);
}
printf(" %d", (a[i][m]));
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int solve(int* h_orient, int a, int b, int n, int i, int j) {
int orient = h_orient[i] + h_orient[n - 1] - h_orient[j - 1];
orient *= b;
int time = orient + (i - j + n) % n + 1;
int r = i, l = n - j;
time += (l + r + min(l, r)) * a;
return time;
}
int main() {
ios_base::sync_with_stdio(false);
int n, a, b, t;
cin >> n >> a >> b >> t;
int* h_orient = new int[n]();
char* orient1 = new char[n + 1];
cin >> orient1;
for (int i = 0; i < n; i++) {
if (orient1[i] == 'w') {
h_orient[i] = 1;
}
}
delete orient1;
for (int i = 1; i < n; i++) {
h_orient[i] += h_orient[i - 1];
}
int num = 0;
for (int i = 0; i < n; i++) {
int lo = 0, hi = n - i - 1;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
if (solve(h_orient, a, b, n, i, n - mid) <= t) {
lo = mid;
} else {
hi = mid - 1;
}
}
if (solve(h_orient, a, b, n, i, n - lo) <= t) {
num = max(num, i + 1 + lo);
}
}
cout << num;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define IOS ios_base::sync_with_stdio(0);cin.tie(0)
#define infinite 9123456789
#define PRECISION cout.precision(3); cout.setf(ios::fixed);
#define db cout << "Debug" << "\n";
#define ler_entrada freopen("test_input.txt", "r", stdin);
int n, m, a[200010], sum[800010], pref_max[800010], suf_max[800010], suf_min[800010], pref_min[800010], pref[200010], suf[200010];
string s;
void montar(int no, int ini, int fim){
if(ini==fim){
suf_min[no]=suf[ini];
pref_min[no]=pref[ini];
pref_max[no]=pref[ini];
suf_max[no]=suf[ini];
sum[no]=a[ini];
return;
}
int meio=(ini+fim)/2;
montar(2*no, ini, meio);
montar(2*no+1, meio+1, fim);
sum[no]=sum[2*no]+ sum[2*no+1];
pref_max[no]=max(pref_max[2*no], pref_max[2*no+1]);
suf_max[no]=max(suf_max[2*no+1], suf_max[2*no]);
pref_min[no]=min(pref_min[2*no], pref_min[2*no+1]);
suf_min[no]=min(suf_min[2*no], suf_min[2*no+1]);
}
int soma(int no, int ini, int fim, int l, int r){
if(l<=ini and fim<=r) return sum[no];
if(fim<l or r<ini) return 0;
int meio=(ini+fim)/2;
int esq=soma(2*no, ini, meio, l, r), dir=soma(2*no+1, meio+1, fim, l, r);
return esq+dir;
}
int pref_maior(int no, int ini, int fim, int l, int r){
if(l<=ini and fim<=r) return pref_max[no];
if(fim<l or r<ini) return -infinite;
int meio=(ini+fim)/2;
int esq=pref_maior(2*no, ini, meio, l, r), dir=pref_maior(2*no+1, meio+1, fim, l, r);
return max(esq, dir);
}
int pref_menor(int no, int ini, int fim, int l, int r){
if(l<=ini and fim<=r) return pref_min[no];
if(fim<l or r<ini) return infinite;
int meio=(ini+fim)/2;
int esq=pref_menor(2*no, ini, meio, l, r), dir=pref_menor(2*no+1, meio+1, fim, l, r);
return min(esq, dir);
}
int suf_maior(int no, int ini, int fim, int l, int r){
if(l<=ini and fim<=r) return suf_max[no];
if(fim<l or r<ini) return -infinite;
int meio=(ini+fim)/2;
int esq=suf_maior(2*no, ini, meio, l, r), dir=suf_maior(2*no+1, meio+1, fim, l, r);
return max(esq, dir);
}
int suf_menor(int no, int ini, int fim, int l, int r){
if(l<=ini and fim<=r) return suf_min[no];
if(fim<l or r<ini) return infinite;
int meio=(ini+fim)/2;
int esq=suf_menor(2*no, ini, meio, l, r), dir=suf_menor(2*no+1, meio+1, fim, l, r);
return min(esq, dir);
}
void solve(){
cin >> n >> m;
cin >> s;
for(int i=0; i<=n+2; i++) pref[i]=0, suf[i]=0;
for(int i=0; i<s.size(); i++){
if(s[i]=='+') a[i+1]=1;
else a[i+1]=-1;
}
for(int i=1; i<=n; i++) pref[i]=pref[i-1]+a[i];
for(int i=n; i>=1; i--) suf[i]=suf[i+1]+a[i];
montar(1, 1, n);
int tot=sum[1];
for(int i=1; i<=m; i++){
int l, r; cin >> l >> r;
//cout << pref_maior(1, 1, n, 1, l-1) << "\n";
int maior=0, menor=0, d0=0, tot_vez=tot-soma(1, 1, n, l, r);
maior=max(maior, pref_maior(1, 1, n, 1, l-1));
maior=max(maior, tot_vez-min(d0, suf_menor(1, 1, n, r+1, n)));
menor=min(menor, pref_menor(1, 1, n, 1, l-1));
menor=min(menor, tot_vez-max(d0, suf_maior(1, 1, n, r+1, n)));
//cout << maior << " " << menor << "\n";
cout << maior-menor+1 << "\n";
}
}
signed main(){
IOS; int t; cin >> t;
for(int i=1; i<=t; i++) solve();
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int n, K, i;
char s[200005];
int main() {
scanf("%d%d%s", &n, &K, s + 1);
if (K == 0) {
printf("%s", s + 1);
return 0;
}
if (n == 1) {
printf("0");
return 0;
}
if (s[1] > '1') {
s[1] = '1';
--K;
}
for (i = 2; i <= n && K > 0; ++i) {
if (s[i] > '0') s[i] = '0', --K;
}
printf("%s", s + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 2;
const long long sta = 1000, ed = 10000000000000LL;
struct mix {
long long a[M][M];
} fir, one, zero;
long long qcheng(long long a, long long b, long long p) {
long long ret = 0;
while (b) {
if (b % 2) ret = (ret + a) % p;
a = (a + a) % p;
b /= 2;
}
return ret;
}
mix mcheng(mix a, mix b, long long p) {
mix ret = zero;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
ret.a[i][j] = (ret.a[i][j] + qcheng(a.a[i][k], b.a[k][j], p)) % p;
return ret;
}
mix mpow(mix a, long long b, long long p) {
mix ret = one;
while (b) {
if (b % 2) ret = mcheng(ret, a, p);
a = mcheng(a, a, p);
b /= 2;
}
return ret;
}
long long get_fib(long long n, long long p) {
if (n == 0) return 0;
if (n == 1) return 1;
return mpow(fir, n - 1, p).a[0][0];
}
long long ans[N], tep[N], cnt, tt;
int main() {
long long f;
fir.a[0][0] = 1, fir.a[0][1] = 1;
fir.a[1][0] = 1, fir.a[1][1] = 0;
one.a[0][0] = 1, one.a[1][1] = 1;
scanf("%lld", &f);
f %= ed;
for (int i = 0; i <= 1500; i++)
if (get_fib(i, sta) == f % sta) ans[++cnt] = i;
for (long long i = sta * 10, xh = 1500; i <= ed; i *= 10, xh *= 10) {
tt = 0;
long long now = f % i;
for (int j = 1; j <= cnt; j++) {
for (int k = 0; k <= 9; k++) {
if (get_fib(ans[j] + (k * xh), i) == now) tep[++tt] = ans[j] + (k * xh);
}
}
cnt = 0;
for (int j = 1; j <= tt; j++) ans[++cnt] = tep[j];
}
if (cnt == 0)
puts("-1");
else {
long long pt = ans[1];
for (int i = 2; i <= cnt; i++) pt = min(pt, ans[i]);
printf("%lld\n", pt);
}
return 0;
}
| 5 |
#include <cstdio>
#include <cstring>
#include <cassert>
#include <algorithm>
#define MAXN 1006010
#define LL long long
using namespace std;
const LL P=998244353;
LL getPow(LL x,LL y){
LL res=1;
while(y){
if(y&1) res=res*x%P;
x=x*x%P;
y>>=1;
}
return res;
}
int n,n1,n2,sizew;
LL fac[MAXN],invfac[MAXN];
LL *a[MAXN],b[MAXN];
void init(){
static char s1[MAXN],s2[MAXN];
scanf("%s",s1+1);
scanf("%s",s2+1);
int len=strlen(s1+1);
for(int i=1;i<=len;i++)
if(s1[i]=='1' && s2[i]=='1') n1++;
else if(s1[i]=='1' || s2[i]=='1') n2++;
n2/=2;
n=n1+n2;
fac[0]=1;
for(int i=1;i<MAXN;i++) fac[i]=fac[i-1]*i%P;
invfac[MAXN-1]=getPow(fac[MAXN-1],P-2);
for(int i=MAXN-2;i>=0;i--) invfac[i]=invfac[i+1]*(i+1)%P;
}
void FFT(LL *a,int len,int flag){
static int rev[MAXN];
for(int i=1;i<len;i++){
rev[i]=rev[i>>1]>>1|((i&1)?(len>>1):0);
if(i<rev[i]) swap(a[i],a[rev[i]]);
}
for(int l=2;l<=len;l<<=1){
LL w=getPow(3,(P-1)/l);
int l2=l/2;
for(int i=0;i<len;i+=l){
LL temp=1;
for(int j=0;j<l2;j++){
LL t1=a[i+j],t2=a[i+j+l2]*temp;
a[i+j]=(t1+t2)%P;
a[i+j+l2]=(t1-t2)%P;
temp=temp*w%P;
}
}
}
if(flag==-1){
LL invn=getPow(len,P-2);
for(int i=1;i<len;i++) if(i<len-i) swap(a[i],a[len-i]);
for(int i=0;i<len;i++) a[i]=(a[i]*invn%P+P)%P;
}
}
void mul(LL *a,LL *b,int len){
static LL t1[MAXN],t2[MAXN];
for(int i=0;i<len;i++) t1[i]=a[i],t2[i]=b[i],t1[i+len]=t2[i+len]=0;
FFT(t1,len<<1,1); FFT(t2,len<<1,1);
for(int i=0;i<(len<<1);i++) t1[i]=t1[i]*t2[i]%P;
FFT(t1,len<<1,-1);
for(int i=0;i<(len<<1);i++) a[i]=t1[i];
}
void getInv(LL *b,LL *a,int len){
if(len==1){
b[0]=1;
return;
}
static LL t1[MAXN],t2[MAXN];
getInv(t1,a,len>>1);
for(int i=(len>>1);i<len;i++) t1[i]=0;
for(int i=0;i<len;i++) t2[i]=a[i];
FFT(t1,len<<1,1); FFT(t2,len<<1,1);
for(int i=0;i<(len<<1);i++) t1[i]=(2*t1[i]-t2[i]*t1[i]%P*t1[i]%P+P)%P;
FFT(t1,len<<1,-1);
for(int i=0;i<len;i++) b[i]=t1[i];
}
LL getC(int x,int y){
return fac[x]*invfac[y]%P*invfac[x-y]%P;
}
LL gao(){
for(sizew=1;sizew<=n1 || sizew<=n2;sizew<<=1);
static LL space[MAXN];
for(int i=1;i<=sizew;i++){
a[i]=space+(i-1)*2;
a[i][0]=1;
if(i<=n2) a[i][1]=-i;
}
for(int l=2;l<=sizew;l<<=1)
for(int i=1;i<=sizew;i+=l)
mul(a[i],a[i+l/2],l);
getInv(b,a[1],sizew);
assert(b[0]==1);
LL ans=0;
for(int i=0;i<=n1;i++){
LL temp=getC(n1,i)*b[i]%P*fac[i]%P*fac[n2]%P*fac[n2]%P*fac[n1-i]%P*fac[n1-i]%P*getC(n1+n2,n1-i)%P;
ans=(ans+temp)%P;
}
return ans;
}
int main(){
#ifdef DEBUG
freopen("E.in","r",stdin);
#endif
init();
LL ans=(gao()+P)%P;
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int hm, am, dm;
int check(int ay, int dy) {
int m = max(0, ay - dm), y = max(0, am - dy);
if (!m) return -1;
return (hm / m + (hm % m != 0)) * y + 1;
}
int main() {
int hy, ay, dy, h, a, d, mn = 1e9;
cin >> hy >> ay >> dy >> hm >> am >> dm >> h >> a >> d;
for (int i = 0; i <= 200; i++) {
for (int j = 0; j <= 200; j++) {
int hp = check(ay + i, dy + j);
if (hp == -1) continue;
mn = min(mn, max(0, hp - hy) * h + i * a + j * d);
}
}
cout << mn;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int a,b,c,i,j,n,s;
int main()
{
cin>>a>>b>>c>>n;
for (i=0;i<=a;i++)
for (j=0;j<=b;j++)
if ((n-i*500-j*100>=0)&&(n-i*500-j*100<=c*50))
++s;
cout<<s<<endl;
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <cctype>
using namespace std;
int main(){
string W,T;
int cnt=0;
cin >> W;
for(int i=0;i<W.size(); i++)W[i] = tolower(W[i]);
while(1){
cin >> T;
if(T == "END_OF_TEXT")break;
for(int i=0;i<T.size(); i++)T[i] = tolower(T[i]);
if(T == W)cnt++;
}
cout << cnt << endl;
return 0;
} | 0 |
#include <stdio.h>
int main(void)
{
int N, D;
scanf("%d %d", &N, &D);
printf("%d", (N+(D*2))/(D*2+1));
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int h[7], s[110], c, m[7][7], p[110], u[7];
vector<int> v[7][7];
void dfs(int i) {
int j;
u[i] = 1;
for (j = 0; j < 7; j++)
if (m[i][j]) {
m[i][j]--;
m[j][i]--;
dfs(j);
}
s[c++] = i;
}
int main() {
int i, n, j, k;
for (scanf("%d", &n), k = 1; k <= n; k++) {
scanf("%d%d", &i, &j);
if (i <= j)
v[i][j].push_back(k);
else
v[j][i].push_back(-k);
h[i]++;
h[j]++;
m[i][j]++;
m[j][i]++;
}
for (j = 0, i = 0; i < 7; j += h[i] % 2, i++)
;
if (j > 2) {
printf("No solution\n");
return 0;
}
for (i = 0; i < 7 && h[i] % 2 == 0; i++)
;
for (j = i + 1; j < 7 && h[j] % 2 == 0; j++)
;
if (i < 7) {
v[i][j].push_back(n + 1);
m[i][j]++;
m[j][i]++;
}
for (j = 0, i = 0; i < 7; i++)
if (!u[i] && h[i]) {
dfs(i);
j++;
}
if (j > 1) {
printf("No solution\n");
return 0;
}
for (i = 0; i < c - 1; i++)
if (s[i] < s[i + 1]) {
p[i] = v[s[i]][s[i + 1]].back();
v[s[i]][s[i + 1]].pop_back();
} else {
p[i] = -v[s[i + 1]][s[i]].back();
v[s[i + 1]][s[i]].pop_back();
}
for (i = 0; i < c - 1 && p[i] != n + 1 && p[i] != -n - 1; i++)
;
if (i < c - 1) i++;
for (i %= c - 1, j = 0; j < n; i++, i %= c - 1, j++)
if (p[i] > 0)
printf("%d +\n", p[i]);
else
printf("%d -\n", -p[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
long long a[MAXN], pre[MAXN], mn[MAXN], first;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int md = n / 2 + n % 2;
long long fsthalf = 0;
for (int i = 0; i < md; i++) cin >> a[i], fsthalf += a[i];
cin >> first;
for (int i = 0; i < md; i++)
pre[i] = (i == 0 ? 0LL : pre[i - 1]) - a[i] + first;
mn[0] = pre[0];
for (int i = 1; i < md; i++) mn[i] = min(mn[i - 1], pre[i]);
int ans = -1;
for (long long k = 0; k <= n / 2; k++) {
if (min(0LL, (n - md - k - 1 >= 0 ? mn[n - md - k - 1] : 0LL)) >
-(fsthalf + k * first)) {
ans = md + k;
break;
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
int lcm(int x, int y) { return x / gcd(x, y) * y; }
int binpow(int a, int p) {
if (!p) return 1;
int g = binpow(a, p >> 1);
if (p % 2 == 0)
return (g * g) % 1000000007;
else
return (((g * g) % 1000000007) * a) % 1000000007;
}
int rev(int n) { return binpow(n, 1000000007 - 2); }
void solve();
int main() {
cout.setf(ios::fixed);
cout.precision(20);
cerr.setf(ios::fixed);
cerr.precision(3);
int n = 1;
for (int i = 0; i < n; ++i) solve();
}
long long m, k;
long long c[100100], d[100100];
void solve() {
long long cur = 0, i, j;
cin >> m >> k;
for (i = 0; i < m; i++) cin >> d[i];
for (i = 0; i < m; i++) cin >> c[i];
c[m] = -(1000000000);
long long best = c[0];
long long res = 0;
for (i = 0; i < m; i++) {
cur += c[i];
if (d[i] > cur) {
long long dif = (d[i] - cur) / best;
if ((d[i] - cur) % best != 0) dif++;
cur += dif * best;
res += dif * k;
}
cur -= d[i];
res += d[i];
if (c[i + 1] > best) best = c[i + 1];
}
cout << res << endl;
}
| 1 |
#include <bits/stdc++.h>
template <class Z>
void Swap(Z &a, Z &b) {
Z temp;
temp = a;
a = b;
b = temp;
}
using namespace std;
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
cout << min(a, min(b, min(c / 2, min(d / 7, e / 4))));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, ans;
inline bool out_of_round(long long x, long long y) {
y++;
if (x * x + y * y > n * n) return true;
return false;
}
int main() {
scanf("%I64d", &n);
ans = n - 1;
for (i = 1; i < n; i++)
if (!out_of_round(trunc(sqrt(n * n - i * i)), i)) ans++;
if (n == 0)
printf("1");
else
printf("%I64d", (ans + 1) * 4);
scanf("%d", &n);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int ans[3];
cin >> ans[0] >> ans[1] >> ans[2];
sort(ans, ans + 3);
if (ans[2] == ans[1] && ans[1] != ans[0]) {
ans[2]--;
ans[1]--;
}
if (ans[2] > ans[1]) ans[2]--;
if (ans[2] > ans[1]) ans[1]++;
if (ans[1] > ans[0]) ans[0]++;
cout << ans[2] - ans[1] + ans[2] - ans[0] + ans[1] - ans[0] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 75;
const int inf = numeric_limits<int>::max();
set<int> ch[SZ];
struct nd {
int k, p, cnt;
nd *l, *r;
nd(int k, int p) : k(k), p(p), l(NULL), r(NULL), cnt(1) {}
};
nd* root = NULL;
int get_cnt(nd* t) { return !t ? 0 : t->cnt; }
void upt_cnt(nd*& t) {
if (t) t->cnt = get_cnt(t->l) + 1 + get_cnt(t->r);
}
void split(nd* t, int k, nd*& l, nd*& r) {
if (!t)
l = r = NULL;
else if (k < t->k)
split(t->l, k, l, t->l), r = t;
else
split(t->r, k, t->r, r), l = t;
upt_cnt(t);
}
void ins(nd*& t, nd* nn) {
if (!t)
t = nn;
else if (nn->p > t->p)
split(t, nn->k, nn->l, nn->r), t = nn;
else
ins(nn->k < t->k ? t->l : t->r, nn);
upt_cnt(t);
}
void merge(nd*& t, nd* l, nd* r) {
if (!l || !r)
t = l ? l : r;
else if (l->p > r->p)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
upt_cnt(t);
}
void del(nd*& t, int k) {
if (t->k == k)
merge(t, t->l, t->r);
else
del(k < t->k ? t->l : t->r, k);
upt_cnt(t);
}
int find_p(nd* t, int x) {
if (get_cnt(t->l) == x)
return t->k;
else if (get_cnt(t->l) > x)
return find_p(t->l, x);
else
return find_p(t->r, x - get_cnt(t->l) - 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
srand(time(NULL));
int n, m, a, b;
char c;
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> c, ch[int(c) - 48].insert(i), ins(root, new nd(i, rand() % inf));
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
int idx = int(c) - 48, lo = find_p(root, a - 1), hi = find_p(root, b - 1);
vector<int> cl;
for (auto it = ch[idx].lower_bound(lo);
it != ch[idx].end() && it != ch[idx].lower_bound(hi + 1); it++) {
del(root, *it);
cl.emplace_back(*it);
}
for (auto j : cl) ch[idx].erase(j);
}
set<pair<int, int> > r;
for (int i = 0; i < 75; i++)
for (auto it : ch[i]) r.insert({it, i + 48});
for (auto it : r) cout << char(it.second);
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, vis[N];
vector<vector<int> > graph;
vector<int> color;
map<int, set<int> > mp;
void dfs(int u) {
vis[u] = 1;
for (int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i];
if (!vis[v]) dfs(v);
if (color[v] != color[u]) mp[color[u]].insert(color[v]);
}
}
int main() {
cin >> n >> m;
graph.resize(n);
color.resize(n);
int ans = 1e9;
for (int i = 0; i < n; i++) {
cin >> color[i];
ans = min(ans, color[i]);
}
for (int i = 0; i < m; i++) {
int from, to;
cin >> from >> to;
from--, to--;
graph[from].push_back(to);
graph[to].push_back(from);
}
for (int i = 0; i < n; i++)
if (!vis[i]) dfs(i);
int can = 0;
for (map<int, set<int> >::iterator it = mp.begin(); it != mp.end(); it++)
if (it->second.size() > can)
ans = it->first, can = it->second.size();
else if (it->second.size() == can && it->first < ans)
ans = it->first;
cout << ans;
return 0;
}
| 4 |
#include<iostream>
using namespace std;
int h,w;
string g[100];
bool use[100][100];
int dy[] = {-1,0,1,0}, dx[] = {0,1,0,-1};
void rec(int y,int x,char c){
if(use[y][x])return;
use[y][x] = true;
for(int i=0;i<4;i++){
int ny = y+dy[i], nx = x+dx[i];
if(ny<0 || nx<0 || ny>=h || nx>=w)continue;
if(g[ny][nx] == c)rec(ny,nx,c);
}
}
int main(){
while(cin >> h >> w,h||w){
for(int i=0;i<h;i++){
cin >> g[i];
for(int j=0;j<w;j++)use[i][j] = false;
}
int res = 0;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(!use[i][j]){
rec(i,j,g[i][j]);
res++;
}
}
}
cout << res << endl;
}
} | 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const long long INF = 1e18;
const long double EPS = 1e-12;
int d, s;
bool vis[5105][515];
int pa[5105][515];
int parem[5105][515];
vector<int> ans;
vector<pair<int, vector<int> > > fin;
void go(int sum, int rem, int dig, int len) {
if (len == 0) {
reverse(ans.begin(), ans.end());
fin.push_back(make_pair(ans.size(), ans));
return;
}
ans.push_back(dig);
int dd = pa[sum][rem];
int remm = parem[sum][rem];
go(sum - dig, remm, dd, len - 1);
}
queue<vector<int> > qu;
void solve(int dii) {
while (not qu.empty()) qu.pop();
vis[dii][dii % d] = 1;
qu.push({dii, dii % d, dii, 0});
while (not qu.empty()) {
auto vec = qu.front();
qu.pop();
int sum = vec[0], rem = vec[1], dig = vec[2], len = vec[3];
if (sum > s) continue;
if (sum > 5001) continue;
if (len > 50001) continue;
for (int i = 0; i <= 9; i++) {
if (sum == 0 && i == 0) continue;
int sumi = sum + i;
int remi = (rem * 10 + i) % d;
if (not vis[sumi][remi]) {
pa[sumi][remi] = dig;
parem[sumi][remi] = rem;
vis[sumi][remi] = 1;
qu.push({sumi, remi, i, len + 1});
}
if (sumi == s && remi == 0) {
ans.clear();
go(sumi, remi, i, len + 1);
return;
}
}
}
}
int main() {
scanf("%d%d", &d, &s);
vis[0][0] = 1;
solve(0);
if (not fin.empty()) {
sort(fin.begin(), fin.end());
for (int i = 0; i < fin[0].first; i++) {
printf("%d", fin[0].second[i]);
}
printf("\n");
return 0;
}
cout << "-1" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long int b, ans = 1, z;
scanf("%I64d", &b);
z = sqrt(b);
for (long long int i = 2; i <= b; i++) {
if (i > z) {
ans *= 2;
break;
}
long long int c = 1;
while (b % i == 0) {
b /= i;
c++;
z = sqrt(b);
}
ans *= c;
if (b == 1) break;
}
printf("%I64d", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
int n, x, y;
map<int, int> mp;
vector<int> v;
void check(int x) {
if (mp[x] == 0) mp.erase(x);
}
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n * n; i++) cin >> x, mp[x]++;
while (v.size() < n) {
x = mp.rbegin()->first;
mp[x]--;
check(x);
for (int i = 0; i < v.size(); i++) {
y = gcd(x, v[i]);
mp[y] -= 2;
check(y);
}
v.push_back(x);
}
for (auto x : v) cout << x << " ";
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
constexpr long double m_pi = 3.1415926535897932L;
constexpr long long MOD = 1000000007;
constexpr long long INF = 1LL << 61;
constexpr long double EPS = 1e-10;
template <typename T>
using vector2 = vector<vector<T>>;
template <typename T>
using vector3 = vector<vector2<T>>;
string operator*(const string& s, int k) {
if (k == 0) return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1) p += s;
return p;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct Edge {
int to, rev;
long long cap;
Edge(int _to, long long _cap, int _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
void add_edge(vector<vector<Edge>>& G, int from, int to, long long cap,
bool revFlag, long long revCap) {
G[from].push_back(Edge(to, cap, (long long)G[to].size()));
if (revFlag)
G[to].push_back(Edge(from, revCap, (long long)G[from].size() - 1));
}
long long max_flow_dfs(vector<vector<Edge>>& G, long long v, long long t,
long long f, vector<bool>& used) {
if (v == t) return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
long long d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
long long max_flow(vector<vector<Edge>>& G, long long s, long long t) {
long long flow = 0;
for (;;) {
vector<bool> used(G.size());
for (long long(i) = (long long)(0); i < (long long)(used.size()); i++)
used[i] = false;
long long f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(vector<vector<Edge>>& G, long long s, vector<long long>& d,
vector<long long>& negative) {
d.resize(G.size());
negative.resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
d[i] = INF;
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
negative[i] = false;
d[s] = 0;
for (long long(k) = (long long)(0); k < (long long)(G.size() - 1); k++) {
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G[i].size()); j++) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
for (long long(k) = (long long)(0); k < (long long)(G.size() - 1); k++) {
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G[i].size()); j++) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true) negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(vector<vector<Edge>>& G, long long s, vector<long long>& d) {
d.resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
d[i] = INF;
d[s] = 0;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<long long, long long> a = q.top();
q.pop();
if (d[a.second] < a.first) continue;
for (long long(i) = (long long)(0); i < (long long)(G[a.second].size());
i++) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(vector<vector<Edge>>& G, vector<vector<long long>>& d) {
d.resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
d[i].resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(d[i].size()); j++) {
d[i][j] = ((i != j) ? INF : 0);
}
}
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G[i].size()); j++) {
chmin(d[i][G[i][j].to], G[i][j].cap);
}
}
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G.size()); j++) {
for (long long(k) = (long long)(0); k < (long long)(G.size()); k++) {
chmin(d[j][k], d[j][i] + d[i][k]);
}
}
}
}
bool tsort(vector<vector<Edge>>& graph, vector<long long>& order) {
int n = graph.size(), k = 0;
vector<long long> in(n);
for (auto& es : graph)
for (auto& e : es) in[e.to]++;
priority_queue<long long, vector<long long>, greater<long long>> que;
for (long long(i) = (long long)(0); i < (long long)(n); i++)
if (in[i] == 0) que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto& e : graph[v])
if (--in[e.to] == 0) que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class Lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
Lca() {}
Lca(const vector<vector<Edge>>& g, int root)
: n(g.size()),
log2_n(log2(n) + 1),
parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const vector<vector<Edge>>& g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto& e : g[v]) {
if (e.to != p) dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v]) std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v) return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
void visit(const vector<vector<Edge>>& g, int v, vector<vector<int>>& scc,
stack<int>& S, vector<int>& inS, vector<int>& low, vector<int>& num,
int& time) {
low[v] = num[v] = ++time;
S.push(v);
inS[v] = true;
for (decltype((g[v]).begin()) e = (g[v]).begin(); e != (g[v]).end(); ++e) {
int w = e->to;
if (num[w] == 0) {
visit(g, w, scc, S, inS, low, num, time);
low[v] = min(low[v], low[w]);
} else if (inS[w])
low[v] = min(low[v], num[w]);
}
if (low[v] == num[v]) {
scc.push_back(vector<int>());
while (1) {
int w = S.top();
S.pop();
inS[w] = false;
scc.back().push_back(w);
if (v == w) break;
}
}
}
void stronglyConnectedComponents(const vector<vector<Edge>>& g,
vector<vector<int>>& scc) {
const int n = g.size();
vector<int> num(n), low(n);
stack<int> S;
vector<int> inS(n);
int time = 0;
for (long long(u) = (long long)(0); u < (long long)(n); u++)
if (num[u] == 0) visit(g, u, scc, S, inS, low, num, time);
}
class UnionFind {
vector<int> data;
long long num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
long long size(int x) { return -data[root(x)]; }
long long numSet() { return num; }
};
template <typename T, typename F>
class SegmentTree {
private:
T identity;
F merge;
long long n;
vector<T> dat;
public:
SegmentTree(F f, T id, vector<T> v) : merge(f), identity(id) {
int _n = v.size();
n = 1;
while (n < _n) n *= 2;
dat.resize(2 * n - 1, identity);
for (long long(i) = (long long)(0); i < (long long)(_n); i++)
dat[n + i - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
}
SegmentTree(F f, T id, int _n) : merge(f), identity(id) {
n = 1;
while (n < _n) n *= 2;
dat.resize(2 * n - 1, identity);
}
void set_val(int i, T x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
T query(int l, int r) {
T left = identity, right = identity;
l += n - 1;
r += n - 1;
while (l < r) {
if ((l & 1) == 0) left = merge(left, dat[l]);
if ((r & 1) == 0) right = merge(dat[r - 1], right);
l = l / 2;
r = (r - 1) / 2;
}
return merge(left, right);
}
};
template <typename T>
class FenwickTree {
vector<T> data;
int n;
int p;
public:
FenwickTree(int n) : n(n) {
data.resize(n + 1LL, 0);
p = 1;
while (p < data.size()) p *= 2;
}
T sum(int k) {
T ret = 0;
for (; k > 0; k -= k & -k) ret += data[k];
return (ret);
}
T sum(int a, int b) { return sum(b) - sum(a); }
void add(int k, T x) {
for (++k; k <= n; k += k & -k) data[k] += x;
}
int lower_bound(long long w) {
if (w <= 0) return -1;
int x = 0;
for (int k = p / 2; k > 0; k /= 2) {
if (x + k <= n && data[x + k] < w) w -= data[x + k], x += k;
}
return x;
}
};
void divisor(long long n, vector<long long>& ret) {
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
void prime_factorization(long long n, vector<pair<long long, long long>>& ret) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back({i, 0});
while (n % i == 0) {
n /= i;
ret[ret.size() - 1].second++;
}
}
}
if (n != 1) ret.push_back({n, 1});
}
long long mod_pow(long long x, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long mod_inv(long long x, long long mod) {
return mod_pow(x, mod - 2, mod);
}
class Combination {
public:
vector<long long> fact;
vector<long long> inv;
long long mod;
long long mod_inv(long long x) {
long long n = mod - 2LL;
long long res = 1LL;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long nCr(long long n, long long r) {
if (n < r) return 0;
if (n < mod) return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod;
long long ret = 1;
while (n || r) {
long long _n = n % mod, _r = r % mod;
n /= mod;
r /= mod;
(ret *= nCr(_n, _r)) %= mod;
}
return ret;
}
long long nPr(long long n, long long r) {
return (fact[n] * inv[n - r]) % mod;
}
long long nHr(long long n, long long r) { return nCr(r + n - 1, r); }
Combination(long long _n, long long _mod) {
mod = _mod;
long long n = min(_n + 1, mod);
fact.resize(n);
fact[0] = 1;
for (long long(i) = (long long)(0); i < (long long)(n - 1); i++) {
fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
}
inv.resize(n);
inv[n - 1] = mod_inv(fact[n - 1]);
for (int i = n - 1; i > 0; i--) {
inv[i - 1] = inv[i] * i % mod;
}
}
};
long long popcount(long long x) {
x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
x = (x & 0x0F0F0F0F0F0F0F0F) + (x >> 4 & 0x0F0F0F0F0F0F0F0F);
x = (x & 0x00FF00FF00FF00FF) + (x >> 8 & 0x00FF00FF00FF00FF);
x = (x & 0x0000FFFF0000FFFF) + (x >> 16 & 0x0000FFFF0000FFFF);
x = (x & 0x00000000FFFFFFFF) + (x >> 32 & 0x00000000FFFFFFFF);
return x;
}
void solve() {
long long n, m;
cin >> n >> m;
vector<vector<long long>> a(n, vector<long long>(m));
for (long long(i) = (long long)(0); i < (long long)(n); i++)
for (long long(j) = (long long)(0); j < (long long)(m); j++) cin >> a[i][j];
for (long long(i) = (long long)(0); i < (long long)(n); i++)
for (long long(j) = (long long)(0); j < (long long)(m); j++)
a[i][j] -= a[n - 1][m - 1] - (n - 1 - i) - (m - 1 - j);
using T = map<long long, long long>;
vector2<T> dp(n, vector<T>(m));
dp[0][0][a[0][0]] = 0;
long long ans = INF;
for (long long(i) = (long long)(0); i < (long long)(n); i++)
for (long long(j) = (long long)(0); j < (long long)(m); j++) {
for (auto [key, val] : dp[i][j]) {
long long d = i + j + 1;
if (i != n - 1) {
long long next = a[i + 1][j];
if (next >= key) {
if (dp[i + 1][j].count(key) == 0) dp[i + 1][j][key] = INF;
chmin(dp[i + 1][j][key], val + next - key);
} else {
if (dp[i + 1][j].count(next) == 0) dp[i + 1][j][next] = INF;
chmin(dp[i + 1][j][next], val + d * (key - next));
}
}
if (j != m - 1) {
long long next = a[i][j + 1];
if (next >= key) {
if (dp[i][j + 1].count(key) == 0) dp[i][j + 1][key] = INF;
chmin(dp[i][j + 1][key], val + next - key);
} else {
if (dp[i][j + 1].count(next) == 0) dp[i][j + 1][next] = INF;
chmin(dp[i][j + 1][next], val + d * (key - next));
}
}
}
if (i == n - 1 && j == m - 1)
for (auto [key, val] : dp[n - 1][m - 1]) chmin(ans, val);
dp[i][j].clear();
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
while (n--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int d[N], n, m, cntlp;
bool loop[N], mark[N];
long long ans;
vector<int> adj[N];
void input() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
if (u == v) {
loop[u] = true;
cntlp++;
} else {
d[u]++, d[v]++;
adj[u].push_back(v);
adj[v].push_back(u);
}
}
}
void dfs(int u = 0) {
mark[u] = true;
for (auto v : adj[u]) {
if (!mark[v]) {
dfs(v);
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
input();
for (int i = 0; i < n; i++) {
if (d[i] || loop[i]) {
dfs(i);
break;
}
}
for (int i = 0; i < n; i++) {
if (!mark[i] && (d[i] || loop[i])) {
cout << 0;
return 0;
}
if (d[i] > 1) {
ans += 1LL * d[i] * (d[i] - 1) / 2;
}
if (loop[i]) {
ans += m - cntlp;
}
}
if (cntlp > 1) {
ans += 1LL * cntlp * (cntlp - 1) / 2;
}
cout << ans;
return 0;
}
| 2 |
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int md=1000000007;
int n,m,f[3005][3005][2],i,j,k;
int main()
{
scanf("%d%d",&n,&m);
for(i=1;i<=n;++i)
f[0][i][0]=1;
f[0][0][1]=1;
for(i=0;i<m;++i)
for(j=0;j<=n;++j)
for(k=0;k<=1;++k)
if(f[i][j][k])
{
if(j)
{
f[i+1][j][k||j==1]=(f[i+1][j][k||j==1]+f[i][j][k])%md;
f[i+1][j-1][k||j==1]=(f[i+1][j-1][k||j==1]+f[i][j][k])%md;
}
if(j<n)
{
f[i+1][j][k]=(f[i+1][j][k]+f[i][j][k])%md;
f[i+1][j+1][k]=(f[i+1][j+1][k]+f[i][j][k])%md;
}
}
k=0;
for(j=0;j<=n;++j)
k=(k+f[m][j][1])%md;
printf("%d",k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, q;
scanf(" %d %d", &n, &q);
vector<int> A(n);
for (int i = 0; i < n; ++i) scanf(" %d", &A[i]);
long long res = 0;
bool up = true;
int prev = 0;
for (int i = 0; i < n; ++i) {
if (i && A[i - 1] > A[i]) {
if (up) {
res += (A[i - 1] - prev);
}
up = false;
prev = A[i];
} else {
up = true;
}
}
if (up) res += (A[n - 1] - prev);
cout << res << '\n';
}
int main() {
int t;
scanf(" %d", &t);
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void no() {
cout << "-1\n";
exit(0);
}
void yes() { cout << "YES\n"; }
int nxt() {
int x;
cin >> x;
return x;
}
void solve() {
int n = nxt();
vector<int> a(5);
for (int i = (int)0; i < (int)n; i++) a[nxt()]++;
int ans = 0;
int x = min(a[1], a[2]);
ans += x;
a[1] -= x, a[2] -= x, a[3] += x;
if (a[1]) {
x = a[1] / 3;
ans += x * 2, a[1] %= 3, a[3] += x;
if (a[1] == 1) {
if (a[3] > 0)
ans++;
else if (a[4] >= 2)
ans += 2;
else
no();
} else if (a[1] == 2) {
if (a[4] > 0)
ans += 2;
else if (a[3] >= 2)
ans += 2;
else
no();
}
} else if (a[2]) {
x = a[2] / 3;
ans += x * 2, a[2] %= 3, a[3] += x * 2;
if (a[2] == 1) {
if (a[4] > 0)
ans++;
else if (a[3] >= 2)
ans += 2;
else
no();
} else if (a[2] == 2) {
ans += 2;
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int tc = 1; tc <= t; tc++) {
solve();
}
}
| 3 |
//2017-10-18
//miaomiao
//
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
#define For(i, a, b) for(int i = (a); i <= (int)(b); ++i)
#define N (100+2)
char mp[N][N];
short f[N][N][N][N], sumr[N][N], sumc[N][N];
inline short Calc(short *sum, int l, int r){
if(l > r) return 0;
// printf("add = %d\n", sum[r] - sum[l-1]);
return sum[r] - sum[l-1];
}
inline void Add(short &me, short add){
if(me < add) me = add;
}
int main(){
int n, m, ex, ey;
scanf("%d%d", &n, &m);
For(i, 1, n){
scanf("%s", mp[i]+1);
For(j, 1, m){
sumr[i][j] = sumr[i][j-1] + (mp[i][j]=='o');
if(mp[i][j] == 'E') ex = i, ey = j;
}
}
For(i, 1, m) For(j, 1, n) sumc[i][j] = sumc[i][j-1] + (mp[j][i]=='o');
// printf("ex = %d ey = %d\n", ex, ey);
int ans = 0, A = ex-1, B = n-ex, C = ey-1, D = m-ey;
int me, nxt;
For(a, 0, A) For(b, 0, B) For(c, 0, C) For(d, 0, D){
ans = max(ans, me = f[a][b][c][d]);
// printf("f[%d][%d][%d][%d] = %d\n", a, b, c, d, f[a][b][c][d]);
nxt = 0;
if(a < A){
// puts("UP");
if(ex-a-1 > b) nxt = Calc(sumr[ex-a-1], max(d+1,ey-c), min(m-c,ey+d));
Add(f[a+1][b][c][d], nxt+me);
}
nxt = 0;
if(b < B){
// puts("DOWN");
if(ex+b+1 < n-a+1) nxt = Calc(sumr[ex+b+1], max(d+1,ey-c), min(m-c,ey+d));
Add(f[a][b+1][c][d], nxt+me);
}
nxt = 0;
if(c < C){
// puts("LEFT");
if(ey-c-1 > d) nxt = Calc(sumc[ey-c-1], max(b+1,ex-a), min(n-a,ex+b));
Add(f[a][b][c+1][d], nxt+me);
}
nxt = 0;
if(d < D){
// puts("RIGHT");
if(ey+d+1 < m-c+1) nxt = Calc(sumc[ey+d+1], max(b+1,ex-a), min(n-a,ex+b));
Add(f[a][b][c][d+1], nxt+me);
}
// puts("====================="); puts("");
}
printf("%d\n", ans);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
long long m,x,y;
int n,ans;
int main()
{
cin>>n>>m;
for(int i=0;i<n;i++)
{
cin>>x>>y;
if(x*x+y*y<=m*m)ans++;
}
cout<<ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int main() {
int T;
cin >> T;
while (T--) {
int x, y, a, b;
cin >> x >> y >> a >> b;
int t = (y - x) % (a + b);
if (t)
cout << "-1" << endl;
else
cout << (y - x) / (a + b) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const double pi = 3.141592;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
long long x[n + m];
for (int i = (0); i < (n + m); i++) {
cin >> x[i];
}
bool taxi[n + m];
for (int i = (0); i < (n + m); i++) {
cin >> taxi[i];
}
long long cnt = 0;
long long ans[m];
memset(ans, 0, sizeof(ans));
long long i = 0;
while (!taxi[i]) i++;
ans[0] = i;
while (1) {
cnt++;
if (cnt == m) {
ans[m - 1] += n + m - i - 1;
break;
}
long long j = i + 1;
long long dist = 0;
while (!taxi[j]) {
j++;
dist += x[j] - x[j - 1];
}
if (j - i - 1 == 0) {
i = j;
continue;
}
long long p = i + 1;
long long d2 = x[i + 1] - x[i];
while (p < j) {
if (d2 <= dist) {
ans[cnt - 1]++;
} else {
ans[cnt]++;
}
d2 += x[p + 1] - x[p];
dist -= x[p + 1] - x[p];
p++;
}
i = j;
}
for (int i = (0); i < (m); i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e5) + 10;
int n, m;
set<int> eage[maxn];
int p[maxn];
void work() {
for (int i = 1; i <= n; i++) p[i] = i;
random_shuffle(p + 1, p + 1 + n);
p[n + 1] = p[1];
for (int i = 1; i <= m; i++)
if (eage[p[i]].count(p[i + 1])) return;
for (int i = 1; i <= m; i++) printf("%d %d\n", p[i], p[i + 1]);
exit(0);
}
int main() {
srand(time(NULL));
scanf("%d%d", &n, &m);
for (int x, y, i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
eage[x].insert(y);
eage[y].insert(x);
}
for (int i = 1; i <= 200; i++) work();
printf("-1\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, x, y, z, k;
cin >> a >> b >> c >> x >> y >> z;
k = x - min(x, a) + y - min(b, y) + z - min(z, c);
a = (a >= x) * (a - x);
b = (b >= y) * (b - y);
c = (c >= z) * (c - z);
if (k > (a / 2) + (b / 2) + (c / 2))
cout << "No";
else
cout << "Yes";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int m, b, x = 0, y = 0, mx = 0, num1 = 0, num2 = 0, ans = 0;
cin >> m >> b;
long long int i;
for (i = 0; i <= 10000000; ++i) {
if (i % m == 0) {
x = i;
y = -(i / m) + b;
if (y >= 0) {
num1 = (x * (x + 1)) / 2;
num2 = (y * (y + 1)) / 2;
ans = (y + 1) * num1 + (x + 1) * num2;
mx = max(mx, ans);
} else
break;
}
}
cout << mx;
return 0;
}
| 2 |
#include<iostream>
#include<cstdio>
using namespace std;
int main(void)
{
int N,M,X,Y;
scanf("%d %d %d %d",&N,&M,&X,&Y);
int a;
for(int i=0;i<N;i++){
scanf("%d",&a);
if(X<a)
X=a;
}
for(int i=0;i<M;i++){
scanf("%d",&a);
if(Y>a)
Y=a;
}
if(X<Y)
puts("No War");
else
puts("War");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long int;
using uLL = unsigned long long int;
using uint = unsigned int;
using ld = long double;
inline bool compare(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) {
return a.second < b.second;
}
return a.first > b.first;
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int res = (s[0] == 'W');
for (int i = 1; i < n; i++) {
if (s[i] == 'W') {
if (s[i - 1] == 'W') {
res += 2;
} else {
res += 1;
}
}
}
vector<int> next_w(n);
int pos = 100000000;
for (int i = n - 1; i >= 0; i--) {
next_w[i] = pos;
if (s[i] == 'W') pos = i;
}
if (pos == 100000000) {
cout << max(k * 2 - 1, 0) << '\n';
continue;
}
vector<pair<int, int> > wektor;
for (int i = 0; i < n; i++) {
if (s[i] == 'W' && next_w[i] != i + 1 && i != n - 1) {
wektor.push_back({next_w[i] - 1 - i, i});
}
}
sort(wektor.begin(), wektor.end());
for (auto x : wektor) {
int j = x.second + 1;
while (k > 0 && j < n && s[j] == 'L') {
k--;
res += 2;
j++;
}
if (j < n && s[j] == 'W') {
res++;
}
if (k == 0) break;
}
if (pos != 100000000) {
int i = pos - 1;
while (k > 0 && i >= 0) {
k--;
res += 2;
i--;
}
}
cout << res << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
if (i * (n / i) == n && n / i <= i) {
cout << n / i << " " << i;
return 0;
}
}
}
| 1 |
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
typedef long long lli;
lli n;
vector<lli> r,l;
priority_queue<lli> pqr;
priority_queue<lli,vector<lli>,greater<lli> > pql;
lli ans;
int main(){
cin >> n;
r = vector<lli> (n);
l = vector<lli> (n);
for(lli i = 0;i < n;i++)
cin >> l[i] >> r[i];
pqr.push(l[0]);
pql.push(l[0]);
lli tr = 0,tl = 0;
ans = 0;
for(lli i = 1;i < n;i++){
tl += r[i-1] - l[i-1];
tr -= r[i] - l[i];
if(pqr.top() > l[i] - tr)
{
ans += abs(pqr.top() - (l[i] - tr));
pqr.push(l[i] - tr);
pqr.push(l[i] - tr);
pql.push(pqr.top() + tr - tl);
pqr.pop();
}
else if(pql.top() < l[i] - tl)
{
ans += abs(pql.top() - (l[i] - tl));
pql.push(l[i] - tl);
pql.push(l[i] - tl);
pqr.push(pql.top() + tl - tr);
pql.pop();
}
else
{
pqr.push(l[i] - tr);
pql.push(l[i] - tl);
}
//cout << pqr.top() + tr << " " << pql.top() + tl << endl;
}
cout << ans << endl;
return 0;
} | 0 |
#include<iostream>
#include<vector>
using namespace std;
typedef long long ll;
int n, v[2000];
ll dp[2000][2000][2] = {};
bool visit[2000][2000][2] = {};
void joi(int op, int &a, int &b, int &c){
if(op == 0){
if(c == 0) a++;
else a--;
if(a < 0) c = 0, a = b, b = n-1;
}
if(op == 1){
if(c == 0) b--;
else b++;
if(b > n-1) c = 0, b = a, a = 0;
}
}
void ioi(int &a, int &b, int &c){
if(v[a] > v[b]) joi(0, a, b, c);
else if(v[a] < v[b]) joi(1, a, b, c);
}
ll dfs(int x, int y, int z){
if(visit[x][y][z]) return dp[x][y][z];
visit[x][y][z] = true;
// base
if(x == y){
return dp[x][y][z] = v[x];
}
if(abs(y-x) == 1 || (min(x,y)==0&&max(x,y)==n-1)){
return dp[x][y][z] = max(v[x],v[y]);
}
int cx, cy, cz;
// take x
cx = x, cy = y, cz = z;
joi(0, cx, cy, cz);
ioi(cx, cy, cz);
dp[x][y][z] = max(dp[x][y][z], v[x]+dfs(cx, cy, cz));
// take y
cx = x, cy = y, cz = z;
joi(1, cx, cy, cz);
ioi(cx, cy, cz);
dp[x][y][z] = max(dp[x][y][z], v[y]+dfs(cx, cy, cz));
return dp[x][y][z];
}
int main(){
cin >> n;
for(int i = 0; i < n; i++) cin >> v[i];
// stupid
if(n == 1){
cout << v[0] << endl;
return 0;
}else if(n == 2){
cout << max(v[0], v[1]) << endl;
return 0;
}
// idiot
int x = 1, y = n-1, z = 0;
if(v[x] > v[y]) x++;
else y--;
ll ans = v[0] + dfs(x, y, z);
x = 0, y = n-2, z = 0;
if(v[x] > v[y]) x++;
else y--;
ans = max(ans, v[n-1] + dfs(x, y, z));
for(int i = 1; i < n-1; i++){
x = i-1, y = i+1, z = 1;
ioi(x, y, z);
ans = max(ans, v[i]+dfs(x,y,z));
}
cout << ans << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
double a,b,c;
cin>>a>>b>>c;
c=c*3.14159265358979/180;
cout<<fixed<<setprecision(10)<<((a*b)/2)*sin(c)<<endl;
cout<<fixed<<setprecision(10)<<a+b+sqrt(a*a+b*b-2*a*b*cos(c))<<endl;
cout<<fixed<<setprecision(10)<<(a*b*sin(c))/a<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, c, g, s, b, i, t, si, j;
cin >> t;
while (t--) {
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
g = s = b = 0;
vector<pair<long long int, long long int> > v;
k = a[0];
c = 1;
for (i = 1; i < n; i++) {
if (a[i] == k)
c++;
else {
v.push_back(make_pair(k, c));
k = a[i];
c = 1;
}
}
v.push_back(make_pair(k, c));
si = v.size();
g = v[0].second;
s = b = 0;
for (i = 1; i < si; i++) {
s = s + v[i].second;
if (s > g) break;
}
for (j = i + 1; j < si; j++) {
if (g + s + b + v[j].second <= n / 2)
b = b + v[j].second;
else
break;
}
if (g < s && g < b && (g + s + b) <= n / 2)
cout << g << " " << s << " " << b << "\n";
else
cout << "0 0 0\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> Grupa;
vector<int> Pozycja;
bool Met[333];
int Liczba[333];
bool ok[333][333];
char Ciag[333];
int Answer[333];
int N;
void Skacz(int n) {
Met[n] = 1;
Grupa.push_back(Liczba[n]);
Pozycja.push_back(n);
for (int i = 1; i <= N; ++i) {
if (Met[i] == 0 && ok[n][i]) {
Skacz(i);
}
}
}
int main() {
int n;
cin >> n;
N = n;
for (int i = 1; i <= n; ++i) scanf("%d", &Liczba[i]);
for (int i = 1; i <= n; ++i) {
scanf("%s", Ciag);
for (int j = 1; j <= n; ++j) {
ok[i][j] = Ciag[j - 1] - (int)'0';
}
}
for (int i = 1; i <= n; ++i) {
if (!Met[i]) {
Skacz(i);
sort(Grupa.begin(), Grupa.end());
sort(Pozycja.begin(), Pozycja.end());
for (int i = 0; i < Grupa.size(); ++i) {
Answer[Pozycja[i]] = Grupa[i];
}
Grupa.clear();
Pozycja.clear();
}
}
for (int i = 1; i <= n; ++i) {
if (Answer[i] == 0)
printf("%d ", i);
else
printf("%d ", Answer[i]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 400005;
struct Edge {
int v, next;
} edge[MAX * 2];
int head[MAX];
int num[MAX];
int maxv[MAX];
int tot;
int n;
int up[MAX], down[MAX];
void init() {
memset(head, -1, sizeof head);
tot = 0;
}
void add_edge(int a, int b) {
edge[tot] = (Edge){b, head[a]};
head[a] = tot++;
}
void dfs1(int u, int fa) {
num[u] = 1;
maxv[u] = 0;
up[u] = 0;
down[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (v == fa) continue;
dfs1(v, u);
num[u] += num[v];
maxv[u] = max(maxv[u], maxv[v]);
if (num[v] - maxv[v] > n / 2) down[u] = 0;
}
if (num[u] <= n / 2) maxv[u] = num[u];
}
void dfs2(int u, int fa, int d) {
int cnt = 0;
vector<int> st;
st.push_back(0);
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (v == fa) continue;
st.push_back(v);
}
cnt = st.size() - 1;
vector<int> pre(cnt + 5), suf(cnt + 5);
for (int i = 1; i <= cnt; i++) pre[i] = max(pre[i - 1], maxv[st[i]]);
for (int i = cnt; i > 0; i--) suf[i] = max(suf[i + 1], maxv[st[i]]);
for (int i = 1; i <= cnt; i++)
if (n - num[st[i]] - max(max(pre[i - 1], suf[i + 1]), d) <= n / 2)
up[st[i]] = 1;
for (int i = 1; i <= cnt; i++) {
int k = d;
k = max(max(pre[i - 1], suf[i + 1]), k);
if (n - num[st[i]] <= n / 2) k = max(k, n - num[st[i]]);
dfs2(st[i], u, k);
}
}
int main() {
while (cin >> n) {
init();
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
add_edge(a, b);
add_edge(b, a);
}
dfs1(1, -1);
up[1] = 1;
dfs2(1, -1, 0);
for (int i = 1; i <= n; i++) {
if (up[i] && down[i])
printf("1");
else
printf("0");
if (i == n)
printf("\n");
else
printf(" ");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long xx = 0, flagg = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') {
flagg = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
xx = xx * 10 + ch - '0';
ch = getchar();
}
return xx * flagg;
}
void pus(long long xx, long long flagg) {
if (xx < 0) {
putchar('-');
xx = -xx;
}
if (xx >= 10) pus(xx / 10, 0);
putchar(xx % 10 + '0');
if (flagg == 1) putchar(' ');
if (flagg == 2) putchar('\n');
return;
}
struct nyh {
int x, id;
} o[1005];
bool cmp(nyh u, nyh v) { return u.x > v.x; }
int n, i, j, a[1005];
char s[1005][1005];
int main() {
n = read();
for (i = 1; i <= n; i++) {
o[i].x = read();
o[i].id = i;
}
sort(o + 1, o + n + 1, cmp);
for (i = 1; i <= n + 1; i++)
for (j = 1; j <= n; j++) s[i][j] = '0';
for (i = 1; i <= n; i++)
for (j = i; j < i + o[i].x; j++) s[(j - 1) % (n + 1) + 1][o[i].id] = '1';
pus(n + 1, 2);
for (i = 1; i <= n + 1; i++) printf("%s\n", s[i] + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int M = 5005;
int n, m, p, a[N], fac[N], d[M][M];
int Cm[M], dp[2][M], sum[2];
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 0; i <= m; i++) {
fac[i] = i ? 1ll * fac[i - 1] * i % p : 1;
}
Cm[0] = 1;
for (int i = 1; i < M && i <= m; i++) {
Cm[i] = 1;
for (int j = m; j >= m - i + 1; j--) Cm[i] = 1ll * Cm[i] * j % p;
}
d[0][0] = 1;
for (int i = 1; i < M; i++) {
for (int j = 1; j <= i; j++) {
d[i][j] = (1ll * d[i - 1][j] * (j - 1) + d[i - 1][j - 1]) % p;
}
}
dp[0][0] = sum[0] = 1;
int c = 1;
for (int i = 1; i <= n; i++, c ^= 1) {
sum[c] = 0;
for (int j = 1; j <= a[i] && j <= m; j++) {
int x = j <= a[i - 1] ? dp[c ^ 1][j] : 0;
dp[c][j] = (sum[c ^ 1] - x + p) * 1ll * Cm[j] % p;
if (x) (dp[c][j] += 1ll * x * (Cm[j] - fac[j] + p) % p) %= p;
dp[c][j] = 1ll * dp[c][j] % p * d[a[i]][j] % p;
(sum[c] += dp[c][j]) %= p;
}
}
printf("%d\n", sum[c ^ 1]);
return 0;
}
| 5 |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <iostream>
typedef long long int ll;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int** dp;
bool** map;
char* buf;
void func(){
int N,limit;
scanf("%d",&N);
for(int i = 0; i < 3; i++){
for(int k = 0; k <= N; k++)dp[i][k] = BIG_NUM;
}
for(int i = 0; i < 2; i++){
for(int k = 0; k <= 2*N; k++)map[i][k] = false;
}
scanf("%s",buf);
limit = 2*N;
for(int i = 0; i < limit;i++){
if(buf[i] == 'Y'){
map[0][i] = true;
}
}
for(int i = 0; i < limit; i++){
if(buf[limit+i] == 'Y'){
map[1][i] = true;
}
}
if(map[0][0] == true && map[1][0] == true){
dp[0][0] = 3;
dp[1][0] = 2;
dp[2][0] = 2;
}else if(map[0][0] == false && map[1][0] == false){
dp[0][0] = 0;
dp[1][0] = 1;
dp[2][0] = 2;
}else if(map[0][0] == true && map[1][0] == false){
dp[0][0] = 1;
dp[1][0] = 1;
dp[2][0] = 2;
}else if(map[0][0] == false && map[1][0] == true){
dp[0][0] = 3;
dp[1][0] = 2;
dp[2][0] = 2;
}
limit = N-1;
for(int i = 1; i <= limit; i++){
if((map[0][2*i-1] == true || map[0][2*i] == true)&& (map[1][2*i-1] == true || map[1][2*i] == true)){ //??????????£???¨?\\????£???????????????¬????????´???????????????????????´???
dp[0][i] = min(dp[0][i-1]+4,min(dp[1][i-1]+3,dp[2][i-1]+3));
dp[1][i] = min(dp[0][i-1]+3,min(dp[1][i-1]+3,dp[2][i-1]+3));
dp[2][i] = min(dp[0][i-1]+3,min(dp[1][i-1]+3,dp[2][i-1]+4));
}else if((map[0][2*i-1] == false && map[0][2*i] == false) && (map[1][2*i-1] == false && map[1][2*i] == false)){ //??????????????´???????????????????????´???
dp[0][i] = min(dp[0][i-1]+1,min(dp[1][i-1]+2,dp[2][i-1]+3));
dp[1][i] = min(dp[0][i-1]+2,min(dp[1][i-1]+1,dp[2][i-1]+2));
dp[2][i] = min(dp[0][i-1]+3,min(dp[1][i-1]+2,dp[2][i-1]+1));
}else if((map[0][2*i-1] == true || map[0][2*i] == true) && (map[1][2*i-1] == false && map[1][2*i] == false)){ //??????????£???????????????´???????????????????????´???
dp[0][i] = min(dp[0][i-1]+2,min(dp[1][i-1]+2,dp[2][i-1]+3));
dp[1][i] = min(dp[0][i-1]+2,min(dp[1][i-1]+2,dp[2][i-1]+3));
dp[2][i] = min(dp[0][i-1]+3,min(dp[1][i-1]+3,dp[2][i-1]+4));
}else if((map[0][2*i-1] == false && map[0][2*i] == false) && (map[1][2*i-1] == true || map[1][2*i] == true)){ //?\\????£???????????????´???????????????????????´???
dp[0][i] = min(dp[0][i-1]+4,min(dp[1][i-1]+3,dp[2][i-1]+3));
dp[1][i] = min(dp[0][i-1]+3,min(dp[1][i-1]+2,dp[2][i-1]+2));
dp[2][i] = min(dp[0][i-1]+3,min(dp[1][i-1]+2,dp[2][i-1]+2));
}
}
if(map[0][2*N-1] == true && map[1][2*N-1] == true){
dp[0][N] = min(dp[0][N-1]+4,min(dp[1][N-1]+3,dp[2][N-1]+3));
}else if(map[0][2*N-1] == false && map[1][2*N-1] == false){
dp[0][N] = min(dp[0][N-1]+1,min(dp[1][N-1]+2,dp[2][N-1]+3));
}else if(map[0][2*N-1] == true && map[1][2*N-1] == false){
dp[0][N] = min(dp[0][N-1]+2,min(dp[1][N-1]+2,dp[2][N-1]+3));
}else if(map[0][2*N-1] == false && map[1][2*N-1] == true){
dp[0][N] = min(dp[0][N-1]+4,min(dp[1][N-1]+3,dp[2][N-1]+3));
}
printf("%d\n",dp[0][N]);
}
int main(){
dp = new int*[3];
for(int i = 0; i < 3; i++){
dp[i] = new int[10001];
}
map = new bool*[2];
for(int i = 0; i < 2; i++){
map[i] = new bool[20001];
}
buf = new char[40010];
int TEST;
scanf("%d",&TEST);
for(int loop = 0; loop < TEST; loop++){
func();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long C[1111][1111], s[1111][1111];
long long f[111][10005];
long long pow_big(long long n, long long k) {
if (k == 0) return 1;
long long tmp = pow_big(n, k / 2);
long long res = (tmp * tmp) % 1000000007;
if (k % 2 == 1) res = (res * n) % 1000000007;
return res;
}
void build_nCk(int n, long long m) {
C[0][0] = 1;
for (int j = 1, _b = n; j <= _b; j++) {
C[0][j] = 1;
for (int i = 1, _b = n; i <= _b; i++)
C[i][j] = (C[i - 1][j - 1] + C[i][j - 1]) % 1000000007;
}
for (int i = 0, _b = n; i <= _b; i++)
for (int k = 0, _b = n; k <= _b; k++) {
long long tmp = m / n;
if (m % n >= i) tmp++;
s[i][k] = pow_big(C[k][n], tmp);
}
}
void process_dp(int n, long long m, int k) {
f[0][0] = 1;
for (int i = 1, _b = n; i <= _b; i++)
for (int j = 0, _b = k; j <= _b; j++)
for (int t = 0, _b = n; t <= _b; t++)
if (j >= t) {
long long tmp = (f[i - 1][j - t] * s[i][t]) % 1000000007;
f[i][j] = (f[i][j] + tmp) % 1000000007;
}
cout << f[n][k] << endl;
}
int main() {
int n, k;
long long m;
cin >> n >> m >> k;
build_nCk(n, m);
process_dp(n, m, k);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
int f = 1;
long long res = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -f;
} while (ch < '0' || ch > '9');
do {
res = res * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f == 1 ? res : -res;
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 100010;
const int mod = 1000000007;
const long long INF = 1e18;
int n, m, q;
int A[N], B[N];
char str[N];
long long dp[2][310];
int head[N], to[N * 2], nxt[N * 2], tot;
void addEdge(int u, int v) {
tot++;
nxt[tot] = head[u];
to[tot] = v;
head[u] = tot;
}
template <class T>
T mmax(T a, T b) {
return a < b ? b : a;
}
template <class T>
T mmin(T a, T b) {
return a < b ? a : b;
}
int countOne(int set) {
int res = 0;
while (set) {
res++;
set &= set - 1;
}
return res;
}
bool contain(long long set, int i) { return (set & (1LL << i)) > 0; }
long long myPow(long long a, int p) {
if (p == 0) return 1;
long long res = myPow(a, p / 2);
res *= res;
res %= mod;
if (p % 2 == 1) {
res *= a;
res %= mod;
}
return res;
}
void addMode(int &a, long long b) { a = (a + b) % mod; }
long long mul(long long a, long long b) { return a * b % mod; }
template <class T>
void mySwap(T &a, T &b) {
T tmp = a;
a = b;
b = tmp;
}
int father[N][20], level[N];
int pre[N], post[N], id;
int h[N], ord[N];
void dfs(int u, int fa) {
pre[u] = ++id;
father[u][0] = fa;
level[u] = level[fa] + 1;
for (int i = 1; i < 20; i++)
if (father[u][i - 1]) father[u][i] = father[father[u][i - 1]][i - 1];
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v != fa) {
dfs(v, u);
}
}
post[u] = ++id;
}
int lca(int u, int v) {
if (level[u] < level[v]) mySwap(u, v);
for (int i = 19; i >= 0; i--)
if (father[u][i] && level[father[u][i]] >= level[v]) u = father[u][i];
if (u == v) return u;
for (int i = 19; i >= 0; i--)
if (father[u][i] && father[v][i] && father[u][i] != father[v][i]) {
u = father[u][i];
v = father[v][i];
}
return father[u][0];
}
struct BIT {
int a[N * 2], sz;
void init(int n) {
sz = n;
memset(a, 0, sizeof(a));
}
void add(int i, int v) {
for (; i <= sz; i += i & -i) a[i] += v;
}
int getsum(int i) {
int res = 0;
for (; i; i -= i & -i) res += a[i];
return res;
}
} bit;
bool cmp(int a, int b) { return h[a] < h[b]; }
int main() {
fast_io();
cin >> n >> m;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
addEdge(u, v);
addEdge(v, u);
}
memset(father, 0, sizeof(father));
memset(level, 0, sizeof(level));
id = 0;
dfs(1, 0);
bit.init(n * 2);
for (int i = 0; i < m; i++) {
int k, b, r;
cin >> k >> b >> r;
set<int> nodes;
for (int j = 0; j < k; j++) {
cin >> A[j];
nodes.insert(A[j]);
}
for (int j = 0; j < k; j++) {
bit.add(pre[A[j]], 1);
bit.add(post[A[j]], -1);
}
for (int j = 0; j < k; j++) {
int cf = lca(A[j], r);
h[j] = bit.getsum(pre[A[j]]) + bit.getsum(pre[r]) -
2 * bit.getsum(pre[cf]) + nodes.count(cf) - 1;
ord[j] = j;
}
sort(ord, ord + k, cmp);
for (int j = 0; j <= b; j++) dp[0][j] = 0;
dp[0][1] = 1;
int cur = 0;
for (int j = 1; j < k; j++) {
int ncur = 1 - cur;
for (int d = 0; d <= b; d++) dp[ncur][d] = 0;
int nh = h[ord[j]];
for (int d = nh + 1; d <= b; d++) {
dp[ncur][d] = dp[cur][d] * (d - nh) + dp[cur][d - 1];
dp[ncur][d] %= mod;
}
cur = ncur;
}
int res = 0;
for (int j = 1; j <= b; j++) addMode(res, dp[cur][j]);
cout << res << '\n';
for (int j = 0; j < k; j++) {
bit.add(pre[A[j]], -1);
bit.add(post[A[j]], 1);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b, ac, bc, cc;
ac = bc = cc = 0;
cin >> a >> b;
for (int i = 0; i < 6; i++) {
if (abs(a - 1 - i) < abs(b - 1 - i))
ac++;
else {
if (abs(a - 1 - i) == abs(b - 1 - i))
cc++;
else
bc++;
}
}
cout << ac << ' ' << cc << ' ' << bc << '\n';
cout.flush();
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
#define nmax 20
#define kmax 10
#define smax 155
int C(int n, int k, int s) {
int count = 0;
if( k == 0 ) {
if( s == 0 ) return 1;
else return 0;
}
for(int i = 1; i <= n; i++) {
count += C(i - 1, k - 1, s - i);
}
return count;
}
int main(void){
// FILE* fp_in = freopen("data.txt", "r", stdin);
while( 1 ) {
int n, k, s;
cin >> n >> k >> s;
if( n == 0 && k == 0 && s == 0 ) break;
cout << C(n,k,s) << endl;
}
// while(1){}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 250005;
using lint = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
lint n, i, j;
cin >> n;
lint a[n][n], l[2];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (i = 0; i < n; i++) {
lint k = 0, p = 1;
for (j = 0; j < 3; j++) {
if (a[i][j] != 0 && k != 2) {
p *= a[i][j];
l[k] = j;
k++;
}
}
cout << (lint)sqrt(p / a[l[0]][l[1]]) << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1 << 9;
const int MaxT = 1 << 18;
const long long int MOD = 1000000007LL;
int N, Q, Degree[MaxN];
bool Visited[MaxN];
long long int T, A[MaxN], DP[MaxT];
vector<int> E[MaxN], ReverseE[MaxN], TopSort, Coins;
long long int DFS(int idx) {
Visited[idx] = true;
for (vector<int>::iterator it = ReverseE[idx].begin();
it != ReverseE[idx].end(); it++)
A[idx] += DFS(*it);
return A[idx];
}
int main(void) {
scanf("%d %d %I64d", &N, &Q, &T);
for (int i = 0; i < N; i++) scanf("%I64d", &A[i]);
for (int i = 0; i < Q; i++) {
int B, C;
scanf("%d %d", &B, &C);
B--;
C--;
E[B].push_back(C);
ReverseE[C].push_back(B);
Degree[C]++;
}
for (int i = 0; i < N; i++) {
int idx = 0;
while (Degree[idx]) idx++;
if (idx == N) {
puts("0");
return 0;
}
TopSort.push_back(idx);
Degree[idx]--;
for (vector<int>::iterator it = E[idx].begin(); it != E[idx].end(); it++)
Degree[*it]--;
}
for (int i = N - 1; i >= 0; i--)
if (!Visited[TopSort[i]]) DFS(TopSort[i]);
for (int i = 0; i < N; i++)
if (!E[i].empty()) T -= A[i];
if (T < 0LL)
puts("0");
else {
DP[0] = 1LL;
int intT = (int)T;
for (int i = 0; i < N; i++)
for (int j = A[i]; j <= intT; j++) DP[j] = (DP[j] + DP[j - A[i]]) % MOD;
printf("%I64d\n", DP[intT]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> f(long long a, long long b) {
if (b == 1) return {1, 1 - a};
vector<long long> quo;
while (b) {
long long q = a / b, r = a % b;
if (r) quo.push_back(q);
a = b;
b = r;
}
long long u = 1, v = -quo.back();
quo.pop_back();
while (!quo.empty()) {
swap(u, v);
v -= quo.back() * u;
quo.pop_back();
}
return {u, v};
}
int main() {
ios_base::sync_with_stdio(0);
long long n, m, dx, dy;
cin >> n >> m >> dx >> dy;
long long u = f(n, dx).second;
long long t[n];
for (int i = 0; i < n; i++) t[i] = 0;
for (int i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
++t[(y - (x * (u * dy) % n) % n + n) % n];
}
long long ans = 0, m_max = 0;
for (int i = 0; i < n; i++)
if (t[i] > m_max) {
m_max = t[i];
ans = i;
}
cout << 0 << " " << ans << '\n';
return 0;
}
| 5 |
#include<stdio.h>
#include<algorithm>
#pragma GCC optimize("O2")
#define rep(i,N) for(int i=0;i<(int)N;i++)
using namespace std;
const int MOD=1e9+7;
static inline int IN(void)
{
int x=0,f=0,c=getchar();while(c<48||c>57){f^=c==45,c=getchar();}
while(c>47&&c<58){x=x*10+c-48,c=getchar();}return f?-x:x;
}
int main()
{
int A[200000],N=IN(),K=IN(),l,m=0,r,accum=1,sign=1;long x,y;
rep(i,N)A[i]=IN(),m+=A[i]<0?1:0;
sort(A,A+N);
if(K&1)accum=A[N-1],sign=(A[N-1]<0?-1:1),N--,K--;
l=0,r=N-1;
while(K)
{
x=1l*A[l]*A[l+1],y=1l*A[r]*A[r-1];
if(x*sign>y*sign)x%=MOD,accum=1l*accum*x%MOD,l+=2;
else y%=MOD,accum=1l*accum*y%MOD,r-=2;
K-=2;
}
return printf("%ld\n",(1l*accum%MOD+MOD)%MOD),0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 1000100;
map<char, int> go[MAXN];
int len[MAXN];
int link[MAXN];
ll cnt[MAXN];
int last;
int nodesCnt = 1;
vector<int> vals[MAXN];
void extend(char c) {
if (go[last].count(c) && len[go[last][c]] == len[last] + 1) {
last = go[last][c];
return;
}
int cur = nodesCnt++;
int p = last;
len[cur] = len[p] + 1;
while (p != -1 && !go[p].count(c)) {
go[p][c] = cur;
p = link[p];
}
if (p == -1) {
link[cur] = 0;
} else {
int q = go[p][c];
if (len[q] == len[p] + 1) {
link[cur] = q;
} else {
int clone = nodesCnt++;
link[clone] = link[q];
go[clone] = go[q];
len[clone] = len[p] + 1;
while (p != -1 && go[p][c] == q) {
go[p][c] = clone;
p = link[p];
}
link[cur] = link[q] = clone;
}
}
last = cur;
}
int main() {
ios_base::sync_with_stdio(false);
int N;
cin >> N;
vector<string> T(N);
vector<int> C(N);
for (int i = 0; i < N; ++i) {
cin >> T[i];
}
for (int i = 0; i < N; ++i) {
cin >> C[i];
}
link[0] = -1;
for (int i = 0; i < N; ++i) {
last = 0;
for (auto c : T[i]) {
extend(c);
cnt[last] += C[i];
}
}
int maxLen = 0;
for (int i = 0; i < nodesCnt; ++i) {
maxLen = max(maxLen, len[i]);
vals[len[i]].emplace_back(i);
}
ll ans = 0;
for (int z = maxLen; z >= 0; --z) {
for (int v : vals[z]) {
ans = max(ans, cnt[v] * z);
cnt[link[v]] += cnt[v];
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 10;
int n, d, first;
long long arr[maxn], dp[maxn][maxn];
deque<pair<int, long long> > q[maxn];
int main() {
cin >> n >> d >> first;
if (n / d > first) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i <= n; ++i) scanf("%lld", &arr[i]);
for (int i = 1; i <= n; ++i) {
for (int j = first; j >= (i + d - 1) / d; --j) {
while (!q[j - 1].empty() && q[j - 1].front().first < i - d)
q[j - 1].pop_front();
if (j == 1)
dp[i][j] = arr[i];
else if (q[j - 1].empty())
continue;
else
dp[i][j] = arr[i] + q[j - 1].front().second;
while (!q[j].empty() && q[j].back().second <= dp[i][j]) q[j].pop_back();
q[j].push_back({i, dp[i][j]});
}
}
long long ans = 0;
for (int i = n - d + 1; i <= n; ++i) ans = max(ans, dp[i][first]);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long int mod = 1000000007;
using namespace std;
int palindrome[2000][2000];
long long int dp[2000];
long long int ans[2000] = {0};
string s;
int pal(int x, int y) {
if (x > y) {
return 0;
}
while (x <= y) {
if (s[x] == s[y]) {
x++;
y--;
} else {
return 0;
}
}
return 1;
}
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < s.size(); j++) {
palindrome[i][j] = pal(i, j);
}
dp[i] = 0;
}
for (int i = 0; i < s.size(); i++) {
if (i != 0) {
dp[i] = dp[i - 1];
}
for (int x = 0; x <= i; x++) {
dp[i] += palindrome[x][i];
}
}
for (int i = 1; i < s.size(); i++) {
ans[i] = ans[i - 1];
for (int x = 1; x <= i; x++) {
ans[i] += palindrome[x][i] * dp[x - 1];
}
}
cout << ans[s.size() - 1];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int n, t, c;
class tree {
private:
vector<int> st;
int N;
public:
tree(int N) {
this->N = n;
st.assign(4 * N, 0);
build(1, 0, N - 1);
cout << endl;
}
void build(int id, int l, int r) {
if (l == r) {
st[id] = a[l];
return;
}
int mid = (l + r) / 2;
int left = 2 * id;
int right = left + 1;
build(left, l, mid);
build(right, mid + 1, r);
st[id] = max(st[left], st[right]);
}
int getValue(int id, int l, int r, int qs, int qe) {
if (l == qs && r == qe) return st[id];
int mid = (l + r) / 2;
if (qs > mid) return getValue(2 * id + 1, mid + 1, r, qs, qe);
if (qe <= mid) return getValue(2 * id, l, mid, qs, qe);
return max(getValue(2 * id, l, mid, qs, mid),
getValue(2 * id + 1, mid + 1, r, mid + 1, qe));
}
int getValue(int qs, int qe) { return getValue(1, 0, N - 1, qs, qe); }
};
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int count = 0;
scanf("%d%d%d", &n, &t, &c);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
tree tr(n);
for (int i = 0; i < n - c + 1; ++i) {
if (tr.getValue(i, i + c - 1) <= t) count++;
}
cout << count << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const long long INF = 1e18;
int n, x;
struct Node {
int l, r;
long long c;
int id;
};
bool cmp(Node a, Node b) {
if (a.l == b.l && a.id == b.id) return a.r < b.r;
if (a.l == b.l) return a.id > b.id;
return a.l < b.l;
}
long long mi[N];
vector<Node> v;
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) {
int l, r;
long long c;
scanf("%d%d%lld", &l, &r, &c);
v.push_back(Node{l, r, c, 1});
v.push_back(Node{r, l, c, -1});
}
sort(v.begin(), v.end(), cmp);
memset(mi, 0, sizeof(mi));
long long ans = INF;
for (int i = 0; i < v.size(); i++) {
Node& p = v[i];
if (p.id > 0) {
int d = p.r - p.l + 1;
if (x <= d || !mi[x - d]) continue;
ans = min(ans, mi[x - d] + p.c);
} else {
int d = p.l - p.r + 1;
if (!mi[d])
mi[d] = p.c;
else
mi[d] = min(mi[d], (long long)p.c);
}
}
if (ans >= INF)
puts("-1");
else
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a, b, l, r, i, j, k, p = 0;
char c[100];
scanf("%s", c);
l = strlen(c);
if (l <= 20) {
b = l;
} else {
b = 20;
}
a = (l - 1) / b + 1;
b = (l - 1) / a + 1;
r = a * b - l;
printf("%d %d\n", a, b);
for (j = 1; j <= a - r % a; j++) {
for (i = 1; i <= b - r / a; i++) {
printf("%c", c[p]);
p++;
}
for (k = 1; k <= r / a; k++) {
printf("*");
}
printf("\n");
}
for (j = 1; j <= r % a; j++) {
for (i = 1; i <= b - (r / a + 1); i++) {
printf("%c", c[p]);
p++;
}
for (k = 1; k <= r / a + 1; k++) {
printf("*");
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 * 100 + 100;
bool mark[maxn], WasPar[maxn];
int n, dis[maxn], a[maxn], par[maxn], ch[maxn];
vector<int> G[maxn];
void dfs(int u) {
mark[u] = 1;
for (int i = 0; i < G[u].size(); i++)
if (!mark[G[u][i]]) {
par[G[u][i]] = u;
ch[u]++;
dis[G[u][i]] = dis[u] + 1;
dfs(G[u][i]);
}
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
if (a[0] != 0) {
cout << "No\n";
exit(0);
}
dfs(0);
for (int i = 1; i < n; i++)
if (dis[a[i]] < dis[a[i - 1]]) {
cout << "No\n";
return 0;
}
queue<int> Q;
Q.push(0);
int prvQ = 0, id = 1;
while (id < n) {
while (Q.size() and ch[prvQ] == 0) {
Q.pop();
prvQ = Q.front();
}
if (Q.size() == 0 || par[a[id]] != prvQ) {
cout << "No\n";
return 0;
}
ch[prvQ]--;
Q.push(a[id]);
id++;
}
cout << "Yes\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1677721600")
using namespace std;
const int MAXN = 5000000 + 100;
const int MAXM = 110000;
const double eps = 1e-10;
long long MOD = 1000000007;
int phi[MAXN], rub[MAXN];
bool v[MAXN];
void phi_table(int n) {
phi[1] = 0;
for (int i = 2; i <= n; i++) {
phi[i] = phi[i - 1];
if (!v[i]) {
phi[i]++;
for (int j = i * 2; j <= n; j += i) v[j] = 1;
}
}
}
char s[12];
bool judge(int n) {
sprintf(s, "%d", n);
n = strlen(s);
for (int i = 0, j = n - 1; i < j; i++, j--) {
if (s[i] != s[j]) return 0;
}
return 1;
}
void rub_table(int n) {
for (int i = 1; i <= n; i++) {
rub[i] = rub[i - 1] + judge(i);
}
}
int main() {
phi_table(5000000);
rub_table(5000000);
long long p, q;
cin >> p >> q;
for (int i = 5000000; i >= 1; i--) {
if (q * phi[i] <= p * rub[i]) {
cout << i << endl;
return 0;
}
}
puts("Palindromic tree is better than splay tree");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
s = '-' + s;
vector<vector<int> > pref(n + 1, vector<int>(2));
for (int i = 1; i <= n; i++) {
if (s[i] == 'a') {
pref[i][0] = pref[i - 1][0] + 1;
pref[i][1] = pref[i - 1][1];
} else {
pref[i][1] = pref[i - 1][1] + 1;
pref[i][0] = pref[i - 1][0];
}
}
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
if ((pref[j][0] - pref[i - 1][0]) == (pref[j][1] - pref[i - 1][1])) {
cout << i << ' ' << j << '\n';
return;
}
}
}
cout << -1 << ' ' << -1 << '\n';
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
for(int i=(b-a)+1;i<b+a;i++)
cout<<i<<' ';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
unsigned long long int k, a[200005] = {}, p[15] = {1}, z = 0;
for (int i = 1; i <= 14; i++) p[i] = p[i - 1] * 10;
vector<unsigned long long int> b[13] = {};
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 12; j++)
if (p[j] > a[i]) {
if ((unsigned long long int)(a[i] * p[j] + a[i]) % k == 0) z--;
break;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 12; j++)
if (p[j] > a[i]) {
b[j].push_back(a[i]);
break;
}
}
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++)
if (b[i].size() && b[j].size()) {
map<unsigned long long int, unsigned long long int> m;
for (unsigned long long int h : b[j]) m[h % k]++;
m[k] = m[0];
for (unsigned long long int h : b[i]) {
if (m.find(k - h * p[j] % k) != m.end()) z += m[k - h * p[j] % k];
}
}
}
cout << z;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m,s;
while(1){
cin >> n >> m >> s;
if(n == 0 && m == 0 && s == 0) break;
int ans = 0;
for(int i=s-1;i>=1;i--){
for(int j=1;j<=s-1;j++){
int x = i*(100+n)/100;
int y = j*(100+n)/100;
if(x+y == s) {
ans = max(ans,(i*(100+m)/100)+(j*(m+100)/100));
}
}
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, d = 0, c, k = 0, x = 0, i = 0, m, f = 0, j = 0, j1, sum = 0;
cin >> n;
cin.ignore();
while (n--) {
string a, b, c1;
getline(cin, a);
f = a.size();
if (f > 4) {
b = a.substr(0, 5);
c1 = a.substr(f - 5, 5);
if (b == "miao." && c1 == "lala.") {
cout << "OMG>.< I don't know!";
} else if (b == "miao.") {
cout << "Rainbow's";
} else if (c1 == "lala.") {
cout << "Freda's";
} else
cout << "OMG>.< I don't know!";
b.clear();
c1.clear();
} else
cout << "OMG>.< I don't know!";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int almostlucky(int n) {
int k, a[10];
a[0] = 4;
a[1] = 7;
a[2] = 44;
a[3] = 47;
a[4] = 74;
a[5] = 77;
a[6] = 444;
a[7] = 447;
a[8] = 474;
a[9] = 477;
for (int i = 0; i < 10; i++) {
k = n % a[i];
if (k == 0) {
return 0;
break;
}
}
if (k = !0) {
return 1;
}
}
int main() {
int n, k;
cin >> n;
if (almostlucky(n) == 0) {
cout << "YES" << endl;
} else {
while (n > 0) {
k = n - n / 10 * 10;
if (k != 4 && k != 7) {
cout << "NO" << endl;
break;
}
n = n / 10;
}
if (n == 0) {
cout << "YES" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int vowel(char c) {
return (c == 'a') || (c == 'e') || (c == 'i') || (c == 'u') || (c == 'o');
}
char s[1000000];
string get_suf(int k) {
int l = strlen(s), i, o = k;
for (i = l - 1; i >= 0; i--) {
if (vowel(s[i])) {
if (--o == 0) {
return (s + i);
}
} else {
}
}
return "";
}
int rime(int k) {
int i, l;
vector<string> v(4);
for (i = 0; i < 4; i++) {
scanf("%s", s);
v[i] = get_suf(k);
if (v[i] == "") {
return -1;
}
}
for (i = 1; i < 4; i++) {
if (v[i] != v[0]) {
break;
}
}
if (i == 4) {
return 0;
}
if (v[0] == v[1] && v[2] == v[3]) {
return 1;
}
if (v[0] == v[2] && v[1] == v[3]) {
return 2;
}
if (v[0] == v[3] && v[1] == v[2]) {
return 3;
}
return -1;
}
int main(void) {
int i, j, n, k;
scanf("%d%d", &n, &k);
vector<int> a(n);
int x = 0;
for (i = 0; i < n; i++) {
a[i] = rime(k);
if (a[i] < 0) {
printf("NO\n");
return 0;
}
if (a[i] == 0) {
continue;
}
if (x == 0) {
x = a[i];
continue;
}
if (a[i] != x) {
printf("NO\n");
return 0;
}
}
if (x == 0) {
printf("aaaa\n");
return 0;
}
if (x == 1) {
printf("aabb\n");
return 0;
}
if (x == 2) {
printf("abab\n");
return 0;
}
if (x == 3) {
printf("abba\n");
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
pair<long long, long long> fib(long long N) {
if (N == 1) {
return {1, 1};
}
if (N % 2) {
pair<long long, long long> eff = fib(N - 1);
return {eff.second, (eff.first + eff.second) % mod};
} else {
pair<long long, long long> eff = fib(N / 2);
long long a = eff.second, b = eff.first;
long long bg = (a * a + b * b) % mod;
long long sm = (a * b + b * (a - b + mod)) % mod;
return {sm, bg};
}
}
long long fibb(long long N) {
if (N == 1) return 1;
return fib(N - 1).second;
}
bool chk(long long u, long long L, long long R, long long K) {
if (u == 0) {
return 0;
}
return (R / u) - ((L - 1) / u) >= K;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long L, R, K;
cin >> mod >> L >> R >> K;
long long ans = 0;
for (long long i = 1; i * i <= R; i++) {
if (chk(i, L, R, K)) {
ans = max(ans, i);
}
}
for (long long bs = 1; bs * bs <= R; bs++) {
if (chk(R / bs, L, R, K)) {
ans = max(ans, R / bs);
}
}
for (long long bs = 1; bs * bs <= L - 1; bs++) {
if (chk((L - 1) / bs, L, R, K)) {
ans = max(ans, (L - 1) / bs);
}
if ((chk(((L - 1) / bs) - 1, L, R, K))) {
ans = max(ans, ((L - 1) / bs) - 1);
}
}
cout << fibb(ans) % mod;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse4,ssse3,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int N = 2100;
int n;
long long s, x[N], y[N], c[N][N];
int main() {
scanf("%d %lld", &n, &s);
s *= 2;
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &x[i], &y[i]);
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
long long t = x[i] * y[j] - x[j] * y[i];
c[i][j] = t;
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
long long t = c[i][j] + c[j][k] - c[i][k];
if (t == s || t == -s) {
printf("Yes\n%lld %lld\n%lld %lld\n%lld %lld\n", x[i], y[i], x[j],
y[j], x[k], y[k]);
exit(0);
}
}
}
}
puts("No");
return 0;
}
| 4 |
//#pragma GCC optimize("Ofast,unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long llo;
#define mp make_pair
#define pb push_back
#define a first
#define b second
#define endl '\n'
llo dp[501*501];
llo dp2[501*501];
llo dp3[501*501];
llo mi;
llo n;
llo mod;
llo ee(llo aa,llo bb){
if(bb==0){
return 1;
}
llo ac=ee(aa,bb/2);
ac=(ac*ac)%mod;
if(bb%2==1){
ac=(ac*aa)%mod;
}
return ac;
}
llo ans=0;
llo fac[200001];
llo fac2[200001];
llo cal(llo x,llo y){
llo cur=(fac[x]*fac2[y])%mod;
cur=(cur*fac2[x-y])%mod;
return cur;
}
void run(llo kk){
//n-i-kk==1
llo i=n-(kk+1);
if(i<0){
return;
}
llo cur=1;//cal(n,i);
for(llo j=n-i+1;j<=n;j++){
cur=(cur*j)%mod;
}
llo nn=n-i;
llo cot=0;
for(llo j=n*n;j>=0;j--){
dp3[j]=dp[j]+dp3[j+1];
if(dp3[j]>=mod){
dp3[j]-=mod;
}
}
for(llo k=0;k<nn;k++){
for(llo l=k+1;l<nn;l++){
cot=(cot+dp3[l-k+1+mi])%mod;
/*if(nn==2){
cout<<i<<":"<<k<<":"<<l<<":"<<dp[nn][l-k+1+mi]<<endl;
}*/
}
}
ans=(ans+cot*cur)%mod;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>n>>mod;
mi=(n*(n-1))/2;
/*fac[0]=1;
llo ma=n;
for(llo i=1;i<=ma;i++){
fac[i]=(fac[i-1]*i)%mod;
//cout<<fac[i]<<":";
}
// cout<<endl;
for(llo i=ma;i>=0;i--){
if(true){//i==ma){
fac2[i]=ee(fac[i],mod-2);
}
else{
fac2[i]=(fac2[i+1]*(i+1))%mod;
}
//cout<<fac2[i]<<":";
}*/
//cout<<fac[2]<<":"<<fac2[2]<<endl;
dp[(n*(n-1))/2]=1;
run(0);
for(llo i=1;i<=n;i++){
llo su=0;
llo ac=n*n;
for(llo j=0;j<=ac;j++){
/*dp2[j]=0;
for(llo k=j;k>=(j-(i-1)) and k>=0;k--){
dp2[j]=(dp2[j]+dp[i-1][k])%mod;
}
continue;*/
su+=dp[j];
if(su>=mod){
su-=mod;
}
if(j-i>=0){
su-=dp[j-i];
su+=mod;
if(su>=mod){
su-=mod;
}
}
dp2[j]=su;
}
su=0;
/* if(i==1){
for(llo j=mi-1;j<=n*n;j++){
cout<<dp2[j]<<":";
}
cout<<endl;
}*/
for(llo j=ac;j>=0;j--){
/*for(llo k=j;k<=j+(i-1) and k<=ac;k++){
dp[i][j]+=(dp2[k])%mod;
}
continue;*/
su+=dp2[j];
if(su>=mod){
su-=mod;
}
if(j+i<=ac){
su-=dp2[j+i];
su+=mod;
if(su>=mod){
su-=mod;
}
}
dp[j]=su;
}
run(i);
/*if(i==2){
for(llo j=mi-1;j<=n*n;j++){
cout<<dp[j]<<":";
}
cout<<endl;
}*/
}
//cout<<dp[1][mi]<<":"<<endl;
/* for(llo i=0;i<=n;i++){
for()
}*/
/* for(llo j=mi-1;j<=n*n;j++){
cout<<dp[2][j]<<":";
}
cout<<endl;*/
/*for(llo i=0;i<=n;i++){
for(llo j=n*n-1;j>=0;j--){
dp[i][j]+=dp[i][j+1];
if(dp[i][j]>=mod){
dp[i][j]%=mod;
}
}
}*/
/* for(llo i=0;i<n;i++){
llo cur=1;//cal(n,i);
for(llo j=n-i+1;j<=n;j++){
cur=(cur*j)%mod;
}
llo nn=n-i;
llo cot=0;
for(llo k=0;k<nn;k++){
for(llo l=k+1;l<nn;l++){
cot=(cot+dp[nn-1][l-k+1+mi])%mod;
}
}
ans=(ans+cot*cur)%mod;
}*/
cout<<ans<<endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[2000][2000];
long long ans[2000];
bool check() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j) {
if (ans[i] * ans[j] != a[i][j]) return false;
}
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
for (long long i = 1; i * i <= a[0][1]; i++) {
if (a[0][1] % i == 0) {
long long curr = i;
ans[0] = curr;
bool can = true;
for (int j = 1; j < n; j++) {
if (a[0][j] % curr != 0) {
can = false;
break;
} else
ans[j] = a[0][j] / curr;
}
if (can) {
if (check()) {
for (int j = 0; j < n; j++) cout << ans[j] << ' ';
return 0;
}
}
curr = a[0][1] / i;
can = true;
ans[0] = curr;
for (int j = 1; j < n; j++) {
if (a[0][j] % curr != 0) {
can = false;
break;
} else
ans[j] = a[0][j] / curr;
}
if (can) {
if (check()) {
for (int j = 0; j < n; j++) cout << ans[j] << ' ';
return 0;
}
}
}
}
assert(1 == 5);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
long long tc;
scanf("%lld", &tc);
while (tc--) {
cin >> n;
bool valid = 1;
for (int i = 1; i < n.size(); i++) {
if (n[i] == n[i - 1]) {
valid = 1;
} else {
valid = 0;
break;
}
}
if (valid) {
printf("-1\n");
} else {
sort(n.begin(), n.end());
cout << n << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long a, b, n, s, temp = 0;
cin >> a >> b >> n >> s;
temp += s % n;
s -= s % n;
s /= n;
if (s > a) temp += n * (s - a);
if (temp <= b)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define rep(i,n) for (long long i = 0; i < (n); ++i)
//g++ -std=c++11
#define OFFSET 12802
using namespace std;
//赤-青 //pos
bool memo[85][85][25610];
long long A[85][85];
long long B[85][85];
long long H, W;
int main(){
cin >> H >> W;
rep(h, H) rep(w, W) cin >> A[h][w];
rep(h, H) rep(w, W) cin >> B[h][w];
memo[0][0][OFFSET] = true;
long long ans = LONG_MAX;
rep(h, H) {
rep(w, W) {
rep(num, 25610){
if(!memo[h][w][num])continue;
if(h == H-1 && w == W-1) {
ans = min(ans, abs(num + A[h][w] - B[h][w] - OFFSET));
ans = min(ans, abs(num + B[h][w] - A[h][w] - OFFSET));
}
//Aを赤, Bを青
memo[h+1][w][num + A[h][w] - B[h][w]] = true;
memo[h][w+1][num + A[h][w] - B[h][w]] = true;
//Aを青, Bを赤
memo[h+1][w][num + B[h][w] - A[h][w]] = true;
memo[h][w+1][num + B[h][w] - A[h][w]] = true;
}
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
long long res = power(a, b / 2);
long long res2 = (res * res);
return (res2 * (b % 2 == 0 ? 1 : a));
}
int main() {
long long first, second, l, r;
cin >> first >> second >> l >> r;
set<long long> ul;
for (int i = 0; i <= log(2e18) / log(first); i++) {
for (int j = 0; j <= log(2e18) / log(second); ++j) {
long long res = power(first, i) + power(second, j);
assert(res <= 4e18);
if (res >= l and res <= r) {
ul.insert(res);
}
}
}
ul.insert(l - 1);
ul.insert(r + 1);
auto it = ul.begin();
long long res = 0;
long long prev = *it;
it++;
for (; it != ul.end(); ++it) {
res = max(res, (*it) - prev - 1);
prev = *it;
}
cout << res;
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 5e5 + 5;
using namespace std;
int main() {
string s;
cin >> s;
int k = s.size();
char y = s[0];
for (int i = 0; i < k; i++) {
if (i == 0) {
cout << "Mike" << endl;
continue;
}
if (s[i] > y) {
cout << "Ann" << endl;
} else {
y = s[i];
cout << "Mike" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n, n) {
vector<int> v(n);
for (auto& i : v) cin >> i;
sort(v.begin(), v.end());
int min_sub = 1 << 28;
for (int i = 0; i < n - 1; i++) {
min_sub = min(min_sub, v[i+1]-v[i]);
}
cout << min_sub << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long double length(long long x, long long y) { return sqrt(x * x + y * y); }
int main() {
long long a, b, n, x, y, v;
long double d = 9e100;
cin >> a >> b >> n;
cout.setf(ios::fixed);
cout.precision(30);
for (auto i = 0; i < n; i++) {
cin >> x >> y >> v;
d = min(d, length(a - x, b - y) / v);
}
cout << d;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vs = vector<string>;
const int nax = 45;
int dp[nax][nax][nax][nax];
int sum[nax][nax];
char grid[nax][nax];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> grid[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] +
(grid[i][j] - '0');
for (int a = n; a >= 1; a--)
for (int b = m; b >= 1; b--)
for (int c = a; c <= n; c++)
for (int d = b; d <= m; d++) {
int& state = dp[a][b][c][d];
state +=
(sum[c][d] - sum[a - 1][d] - sum[c][b - 1] + sum[a - 1][b - 1] ==
0);
state += (dp[a + 1][b][c][d] + dp[a][b + 1][c][d] +
dp[a][b][c - 1][d] + dp[a][b][c][d - 1]);
state -= (dp[a + 1][b + 1][c][d] + dp[a + 1][b][c - 1][d] +
dp[a][b + 1][c - 1][d] + dp[a + 1][b][c][d - 1] +
dp[a][b + 1][c][d - 1] + dp[a][b][c - 1][d - 1]);
state += (dp[a + 1][b + 1][c - 1][d] + dp[a + 1][b + 1][c][d - 1] +
dp[a + 1][b][c - 1][d - 1] + dp[a][b + 1][c - 1][d - 1]);
state -= (dp[a + 1][b + 1][c - 1][d - 1]);
}
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << dp[a][b][c][d] << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x < y ? x : y;
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x *= f;
}
const int N = 1200010, mod = 998244353;
int pw[N], fac[N], inv[N], Inv[N];
namespace poly {
int rev[N];
int Pow(int x, int y) {
int ret = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) ret = 1ll * ret * x % mod;
return ret;
}
int getl(int n) {
int tn = 1, l = 0;
while (tn <= n) tn <<= 1, l++;
for (int i = 0; i < tn; i++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << l - 1);
return tn;
}
void NTT(int *a, int n, int fl) {
for (int i = 0; i < n; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int i = 1; i < n; i <<= 1) {
int wn =
Pow(3, ~fl ? (mod - 1) / (i << 1) : mod - 1 - (mod - 1) / (i << 1));
for (int j = 0; j < n; j += i << 1)
for (int k = 0, w = 1; k < i; k++, w = 1ll * w * wn % mod) {
int tx = a[j + k], ty = 1ll * w * a[i + j + k] % mod;
a[j + k] = (tx + ty) % mod, a[i + j + k] = (tx - ty + mod) % mod;
}
}
if (fl == -1) {
int t = Pow(n, mod - 2);
for (int i = 0; i < n; i++) a[i] = 1ll * a[i] * t % mod;
}
}
} // namespace poly
using namespace poly;
int C(int n, int m) { return 1ll * fac[n] * Inv[m] % mod * Inv[n - m] % mod; }
void Init(int n) {
fac[0] = fac[1] = Inv[0] = Inv[1] = inv[1] = pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = 2ll * pw[i - 1] % mod;
for (int i = 2; i <= n; i++) {
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
Inv[i] = 1ll * Inv[i - 1] * inv[i] % mod;
fac[i] = 1ll * fac[i - 1] * i % mod;
}
}
int main() {
int n, k;
read(n), read(k), Init(6e5);
static int a[N], f[N], g[N], h[N], ans[6][N];
for (int i = 1; i <= n; i++) read(a[i]);
sort(a + 1, a + n + 1);
for (int t = 1, x; t <= k; t++) {
int tn = 0, tm = 0;
read(x), h[t] = x;
for (int i = 1; i <= n; i++) {
if (a[i] >= x) break;
int j = i;
while (j < n && a[j + 1] == a[i]) j++;
if (i != j)
tm += 2;
else
tn++;
i = j;
}
for (int i = 0; i <= tn; i++) f[i] = 1ll * C(tn, i) * pw[i] % mod;
for (int i = 0; i <= tm; i++) g[i] = C(tm, i);
int len = getl(tn + tm);
NTT(f, len, 1), NTT(g, len, 1);
for (int i = 0; i < len; i++) f[i] = 1ll * f[i] * g[i] % mod;
NTT(f, len, -1);
for (int i = 0; i <= tn + tm; i++) ans[t][i] = f[i];
for (int i = 0; i < len; i++) f[i] = g[i] = 0;
}
int q;
read(q);
while (q--) {
int tq, ret = 0;
read(tq);
for (int i = 1; i <= k; i++) {
int tmp = tq / 2 - h[i] - 1;
if (tmp < 0) continue;
(ret += ans[i][tmp]) %= mod;
}
printf("%d\n", ret);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline void read(int &x) {
char c = nc(), b = 1;
for (; !(c >= '0' && c <= '9'); c = nc())
if (c == '-') b = -1;
for (x = 0; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= b;
}
const int N = 300005;
int n, a[N];
int odd[N], even[N];
int ans[N];
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]), ans[1] = max(ans[1], a[i]);
for (int i = 1; i < n; i++) {
int len = min(n - i, i);
even[len] = max(even[len], max(a[i], a[i + 1]));
}
for (int i = 2; i < n; i++) {
int len = min(n - i, i - 1);
odd[len] = max(odd[len], min(a[i], max(a[i - 1], a[i + 1])));
}
for (int i = n / 2; i; i--) ans[i << 1] = max(ans[(i + 1) << 1], even[i]);
for (int i = (n - 1) / 2; i; i--)
ans[i << 1 | 1] = max(ans[(i + 1) << 1 | 1], odd[i]);
for (int i = n; i; i--) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
const long long INF = 1e18 + 1LL;
const double Pi = acos(-1.0);
const int N = 1e6 + 10, M = 1e3 + 20, mod = 1e9 + 7, inf = 2e9;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int a[N], b[N], n;
set<long long> s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
long long G = gcd(a[1], a[2]);
for (int i = 2; i <= n; ++i) {
G = gcd(G, a[i]);
}
if (G != 1) {
puts("YES");
cout << 0 << endl;
return 0;
}
puts("YES");
int ans = 0;
for (int i = 1; i <= n; i += 1) {
if (a[i] % 2 == 1 && a[i + 1] % 2 == 0)
ans += 2, a[i] = 0;
else if (a[i] % 2 == 1 && a[i + 1] % 2 == 1)
ans++, a[i + 1] = 0;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void file() { freopen("halfnice.in", "r", stdin); }
const int MAX = 3e5 + 1, INF = (1 << 30);
int main() {
int n;
long long ans = 0;
scanf("%d", &n);
vector<int> l(n), r(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &l[i]), scanf("%d", &r[i]);
}
sort(l.begin(), l.end());
sort(r.begin(), r.end());
for (int i = 0; i < n; ++i) ans += max(l[i], r[i]) + 1;
printf("%lld\n", ans);
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define EPS (1e-10)
const double inf=1e20;
struct Point{
double x,y;
Point(double x=0,double y=0):x(x),y(y){}
Point operator + (Point p) { return Point(x+p.x,y+p.y); }
Point operator - (Point p) { return Point(x-p.x,y-p.y); }
Point operator * (double k) { return Point(k*x,k*y); }
Point operator / (double k) { return Point(x/k,y/k); }
//向量的大小
inline double abs(){ return sqrt(norm()); }
inline double norm() { return x*x+y*y; }
bool operator < (const Point & p) const{
return x!=p.x?x<p.x:y<p.y;
}
bool operator == (const Point & p) const {
return fabs(x-p.x)<EPS&&fabs(y-p.y)<EPS;
}
};
Point a[100005],b[100005];
inline bool CmpY(Point a,Point b){
return a.y<b.y;
}
inline double Distance(Point a,Point b){
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
double Divide_Conquer(int l,int r){
if(l==r) return inf;
if(l+1==r) return Distance(a[l],a[r]);
int mid=l+r>>1;
double ans=min(Divide_Conquer(l,mid),Divide_Conquer(mid+1,r));
int len=0;
for(int i=l;i<=r;i++){
if(fabs(a[mid].x-a[i].x)<=ans) b[len++]=a[i];
}
sort(b,b+len,CmpY);
for(int i=0;i<len;i++){
for(int j=i+1;j<len&&(b[j].y-b[i].y<ans);j++){
ans=min(ans,Distance(b[i],b[j]));
}
}
return ans;
}
inline void solve(int n){
sort(a,a+n);
printf("%.10f\n",Divide_Conquer(0,n-1));
}
int main(){
int n;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%lf%lf",&a[i].x,&a[i].y);
}
solve(n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
unsigned int dp[200005];
char s[100005];
int main() {
cin >> n;
scanf("%s", s + 1);
if (n % 2 == 1) {
cout << 0;
return 0;
}
int p = 100000, cnt = 0;
dp[p] = 1;
for (int i = 1; i <= n; i++) {
p--;
if (s[i] == '?') {
int q = p + min(i - 1, n - i);
for (int j = p; j <= q; j++) {
dp[j] += dp[j + 2];
}
cnt++;
}
}
unsigned int ans = dp[p];
int k = n / 2 - (n - cnt);
for (int i = 0; i < k; i++) ans *= 25;
cout << ans;
return 0;
}
| 5 |
#include <iostream>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <utility>
using namespace std;
int main() {
string s;
string t;
cin >>s;
cin >>t;
int l;
l=s.size();
int sc[200]={};
int tc[200]={};
for(int i=0; i<l;i++){
sc[s[i]-97]++;
tc[t[i]-97]++;
}
sort(sc,sc+26);
sort(tc,tc+26);
for(int i=0;i<26;i++){
if(sc[i]!=tc[i]){cout <<"No"; break;}
if(i==25){cout <<"Yes";}
}
}
//'a'==97,'z'=122
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.