solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct qin {
int U, D, L, R;
} sum[10005];
int main() {
int n;
cin >> n;
sum[0].U = 0;
sum[0].D = 0;
sum[0].L = 0;
sum[0].R = 0;
char str[205];
for (int i = 1; i <= n; i++) {
cin >> str[i];
if (str[i] == 'D')
sum[i].D = sum[i - 1].D + 1;
else
sum[i].D = sum[i - 1].D;
if (str[i] == 'U')
sum[i].U = sum[i - 1].U + 1;
else
sum[i].U = sum[i - 1].U;
if (str[i] == 'L')
sum[i].L = sum[i - 1].L + 1;
else
sum[i].L = sum[i - 1].L;
if (str[i] == 'R')
sum[i].R = sum[i - 1].R + 1;
else
sum[i].R = sum[i - 1].R;
}
int ans = 0;
for (int j = 2; j <= n; j += 2) {
for (int i = j; i <= n; i++) {
if (sum[i].D - sum[i - j].D == sum[i].U - sum[i - j].U &&
sum[i].L - sum[i - j].L == sum[i].R - sum[i - j].R)
ans++;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k = 1, cnt;
cnt = 0;
cin >> n;
if (n == 1)
cout << 1;
else {
while (n > 0) {
if (k) {
n = n - 1;
k = 0;
} else {
n -= 2;
k = 1;
}
cnt++;
if (n < 0) {
cout << cnt - 1;
return 0;
}
}
cout << cnt;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long p[1 << 24], track[1 << 24];
long long cost[25][25];
int x[25], y[25], n, i, j, k, q;
int main() {
cin >> x[0] >> y[0];
cin >> n;
for (i = 1; i <= n; i++) cin >> x[i] >> y[i];
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
cost[i][j] =
(x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]);
}
}
for (i = 0; i < 1 << n; i++) p[i] = 1e9;
p[0] = 0;
for (i = 0; i < 1 << n; i++) {
for (j = 0; j < n; j++)
if (!(1 << j & i)) {
for (k = j; k < n; k++) {
if (!(1 << k & i)) {
int nmask = i | (1 << j) | (1 << k);
q = p[i] + cost[0][j + 1] + cost[j + 1][k + 1] + cost[k + 1][0];
if (p[nmask] > q) {
p[nmask] = q, track[nmask] = i;
}
}
}
break;
}
}
cout << p[(1 << n) - 1] << endl;
for (i = (1 << n) - 1; i > 0; i = track[i]) {
cout << 0 << " ";
for (int t = i ^ track[i]; t; t -= (t & -t)) {
cout << (int)(log(t & -t) / log(2) + 1e-8 + 1) << " ";
}
}
cout << 0 << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long q, l, r, b;
long long dp[11][66][1030], mx[66], t;
long long dfs(long long pos, long long ld, long long lt, long long now) {
if (dp[b][pos][now] != -1 && !lt && !ld) return dp[b][pos][now];
if (pos == 1) return !ld & !now;
long long up = lt ? mx[pos - 1] : b - 1, ret = 0;
for (long long i = 0; i <= up; ++i) {
ret += dfs(pos - 1, ld && i == 0, lt && i == up,
now ^ (1 << i) * (!(ld & i == 0)));
}
if (dp[b][pos][now] == -1 && !lt && !ld) dp[b][pos][now] = ret;
return ret;
}
long long solve(long long x) {
t = 0;
while (x) mx[++t] = x % b, x /= b;
return dfs(t + 1, 1, 1, 0);
}
int main() {
ios::sync_with_stdio(0);
memset(dp, -1, sizeof dp);
cin >> q;
while (q--) {
cin >> b >> l >> r;
cout << solve(r) - solve(l - 1) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long int gcd(long long int a, long long int b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
const int MAXN = 4e5 + 1;
long long int p[MAXN], tot[MAXN], ans[MAXN], cur = 0;
int par[MAXN], cnt[MAXN], l[MAXN], r[MAXN];
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
cnt[a] += cnt[b];
cur -= tot[a] + tot[b];
tot[a] = 0;
l[a] = min(l[a], l[b]);
r[a] = max(r[a], r[b]);
int L = r[a] - cnt[a];
tot[a] = p[r[a]] - (L >= 0 ? p[L] : 0);
cur += tot[a];
par[b] = a;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
vector<pair<int, int>> s;
for (int i = 0; i < n; i++) {
int v;
cin >> v;
s.push_back({v, 1});
}
for (int i = n; i < n + m; i++) {
int v;
cin >> v;
s.push_back({v, 0});
}
sort(s.begin(), s.end());
for (int i = 0; i < n + m; i++) {
par[i] = i;
p[i] = s[i].first;
if (s[i].second) {
cnt[i] = 1;
tot[i] = p[i];
cur += p[i];
}
l[i] = r[i] = i;
}
for (int i = 1; i < n + m; i++) p[i] += p[i - 1];
vector<pair<int, pair<int, int>>> edge;
for (int i = 1; i < n + m; i++) {
edge.push_back({s[i].first - s[i - 1].first, {i, i - 1}});
}
sort(edge.begin(), edge.end());
vector<pair<int, int>> que;
for (int i = 0; i < q; i++) {
int v;
cin >> v;
que.push_back({v, i});
}
sort(que.begin(), que.end());
int pt = -1;
for (int i = 0; i < q; i++) {
while (pt + 1 < (int)(edge.size()) && edge[pt + 1].first <= que[i].first) {
pt++;
int v = edge[pt].second.first;
int u = edge[pt].second.second;
merge(v, u);
}
ans[que[i].second] = cur;
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <typename T>
inline ostream& operator<<(ostream& os, const vector<T>& v) {
bool first = true;
os << "{";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ",";
os << v[i];
first = false;
}
return os << "}";
}
template <typename T>
inline ostream& operator<<(ostream& os, const set<T>& v) {
bool first = true;
os << "{";
for (typename set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T>
inline ostream& operator<<(ostream& os, const multiset<T>& v) {
bool first = true;
os << "{";
for (typename multiset<T>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const map<T1, T2>& v) {
bool first = true;
os << "{";
for (typename map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T>
bool isPrime(T n) {
T i, lmt = sqrt(n);
for (i = 2; i <= lmt; i++)
if (n % i == 0) return false;
return true;
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0)
return 1 % m;
else if (p & 1)
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
else {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
}
template <typename T>
T power(T b, T p) {
if (p == 0)
return 1;
else if (p & 1)
return b * power(b, p - 1);
else {
T ret = power(b, p / 2);
return ret * ret;
}
}
template <typename T>
T ModInv(T b, T m) {
if (isPrime(b))
return BigMod(b, m - 2, m) % m;
else if (gcd(b, m) == 1)
return BigMod(b, m - 1, m) % m;
}
template <typename T>
T egcd(T a, T b, T& x, T& y) {
T d;
if (a == 0) {
x = 0;
y = 1;
return b;
} else {
T x1, y1;
d = egcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
}
return d;
}
int toint(string s) {
int i, j, l;
int num;
l = s.size();
for (i = l - 1, j = 0, num = 0; i >= 0; i--, j++) {
num += (s[i] - 48) * power(10, j);
}
return num;
}
const double pi = acos(-1);
const int inf = (1 << 30);
const long long INF = (1LL << 62) - 1;
const int mod = (int)1e9 + 7;
const long long MOD = (long long)1e9 + 7;
const double EPS = 1e-9;
const int dx8[] = {-1, 0, +1, -1, +1, -1, 0, +1};
const int dy8[] = {+1, +1, +1, 0, 0, -1, -1, -1};
const int dx4[] = {0, -1, +1, 0};
const int dy4[] = {+1, 0, 0, -1};
const int dx2[] = {+1, 0};
const int dy2[] = {0, +1};
const int dxkn[] = {1, -1, 1, -1, 2, -2, -2, 2};
const int dykn[] = {2, 2, -2, -2, 1, 1, -1, -1};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b, x, y, l1, l2, ans, g;
cin >> a >> b >> x >> y;
g = gcd(x, y);
x = x / g;
y = y / g;
l1 = a / x;
l2 = b / y;
ans = min(l1, l2);
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int c = 0, n, bit = s[0], l = s.length();
for (int i = 0; i < l; i++) {
n = s[i];
if (n == bit) {
c++;
if (c == 7) {
cout << "YES";
return 0;
}
} else {
bit = n;
c = 1;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
cout << "x= " << x << endl;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
cout << "res" << res << endl;
return res;
}
long long modInverse(long long n, long long p) {
return power(n, p - 2, p) % p;
}
long long nCrModPFermat(long long n, long long r, long long p) {
if (r == 0) return 1;
long long fac[n + 1];
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
struct input {
int index, a, b;
input(int x = -1, int y = -1, int z = -1) {
index = x;
a = y;
b = z;
}
};
bool cst(input p1, input p2) { return p1.b < p2.b; }
bool cst2(pair<int, int> p1, pair<int, int> p2) {
return p1.second < p2.second;
}
void swap(long long &a, long long &b) {
long long t = a;
a = b;
b = t;
}
struct compar {
bool operator()(pair<int, int> x, pair<int, int> y) {
return x.second > y.second;
}
};
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void modulo(int &x, int &n) { x = ((x % n) + n) % n; }
int gcd(int a, int b, int c) { return gcd(gcd(a, b), c); }
void copy(int *a, int *ab) {
for (int i = 0; i < 1024; i++) ab[i] = a[i];
}
bool cmp(int *a, int *ab) {
for (int i = 0; i < 1024; i++) {
if (a[i] != ab[i]) return 0;
}
return 1;
}
double solve(double n) {
return (1 + 1 / (sin(3.14159265358979323846 / (2 * n))) *
sqrt((1 - sin(3.14159265358979323846 / n))));
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
set<int> s;
bool answrong = 0;
for (int i = 0; i < n; i++) {
int x = i + a[i];
modulo(x, n);
if (s.find(x) != s.end()) {
answrong = 1;
break;
}
s.insert(x);
}
if (!answrong) {
cout << "yes\n";
} else
cout << "no\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long //__int64 __int128
#define ull unsigned long long
#define pb push_back
#define eb emplace_back
#define mst(a, b) memset(a, b, sizeof(a))
#define mCase int T_Case; cin>>T_Case; for(int Case=1;Case<=T_Case;++Case)
#define qm(a, b) (a-a/b*b)
#define mCase int T; scanf("%d", &T); for(int Case=1;Case<=T;++Case)
//srand(time(NULL)); srand(rand()); srand(rand());
const double PI=acos(-1.0);
/*
int P_num[700005], P_cnt; //664579 in 1e7, 5761455 in 1e8
bool isP[10000007];
void GetPrime(int Pn){
memset(isP, 1, sizeof(isP)), isP[1]=P_cnt=0;
for(int i=2;i<=Pn;++i){
if(isP[i]) P_num[++P_cnt]=i;
for(int j=1;j<=P_cnt && i*P_num[j]<=Pn;++j){
isP[i*P_num[j]]=0;
if(!qm(i, P_num[j])) break;
}
}
}
*/
//gcd(a,b)*lcm(a,b)=a*b
ll GCD(ll a, ll b, ll t=1){ while(b){ t=b;b=a-a/b*b; a=t;} return a;}
ll LCM(ll a, ll b){ return a/GCD(a, b)*b;}
ll qmul(ll a, ll b, ll p=1000000007){ ll r=0; while(b){ if(b&1) r=(r+a)%p; b>>=1; a=(a+a)%p;} return r;}
ll Kpow(ll x, ll n, ll p=1000000007){ ll r=1; for(;n;n>>=1, x=qm(x*x, p)) if(n&1) r=qm(r*x, p); return r;}
const double eps=1e-6;
#define P pair<ll, ll>
const long long LINF=0x3f3f3f3f3f3f3f3f; //0x7f7f7f7f7f7f7f7f
const int mod=998244353; // 998244353
const int INF=0x3f3f3f3f; //0x7f7f7f7f
const int maxn=200005;
ll n;
ll s[maxn];
ll t[maxn];
ll inv[maxn];
ll fac[maxn];
ll C(ll x, ll y){
return fac[y]*inv[y-x]%mod*inv[x]%mod;
}
void work(){
cin>>n;
bool pre=0;
string str; cin>>str;
int cnt=0, tot=0;
for(int i=0;i<n;++i){
if(str[i]=='0') cnt++, pre=0;
else if(str[i]=='1'){
if(pre) tot++, pre=0;
else pre=1;
}
}
//cout<<tot<<' '<<cnt<<' '<<endl;
cout<<C(tot, tot+cnt)<<'\n';
}
int main(){
inv[0]=fac[0]=1;
for(int i=1;i<=100000;++i) inv[i]=inv[i-1]*Kpow(i, mod-2, mod)%mod, fac[i]=fac[i-1]*i%mod;
mCase{ work();}
//work();
return 0;
}
/*
5
1
1
2
2 1
3
3 2 1
4
4 3 2 1
5
5 4 3 2 1
*/
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000000005;
set<int> s;
map<int, bool> M;
int n, k, x;
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> x;
M[x] = 1;
if (k != 1)
while (x % k == 0) x /= k;
s.insert(x);
}
if (k == 1) {
cout << n << endl;
return 0;
}
long long ax = 0;
int ans = 0;
for (set<int>::iterator it = s.begin(); it != s.end(); ++it) {
ax = *it;
int ct = 0;
while (ax < MAXN) {
if (M[ax] == 1) {
ct++;
} else {
ans = ans + ct / 2 + ct % 2;
ct = 0;
}
ax *= k;
}
ans = ans + ct / 2 + ct % 2;
}
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const double PI = 2 * acos(0.0);
const double eps = 1e-15;
const int NPOS = -1;
const int MAX = 1000;
bool detectOverFlow(const long long& a, const long long& b) {
long long x = a * b;
if (x / a != b) return true;
return false;
}
long long sqrt(long long a) {
long long lo = 0, hi = 1e9 + 5;
while (lo < hi - 1) {
long long mid = (hi + lo) >> 1;
if (mid * mid > a)
hi = mid;
else
lo = mid;
}
return lo;
}
vector<long long> v;
void powerNumbers() {
for (long long i = 2; i < 1000005; i++) {
long long j = i * i;
while (1.0 * j * i < 1e18 + 55) {
j *= i;
long long s = sqrt(j);
if (s * s != j) v.push_back(j);
}
}
sort(((v).begin()), ((v).end()));
(v).resize(unique(((v).begin()), ((v).end())) - (v).begin());
}
int countSquares(long long a, long long b) {
return ((sqrt(b)) - (sqrt(a - 1)));
}
int n;
long long l, r;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
powerNumbers();
cin >> n;
while (n--) {
cin >> l >> r;
int res = countSquares(l, r);
res += upper_bound(((v).begin()), ((v).end()), r) -
lower_bound(((v).begin()), ((v).end()), l);
cout << res << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long N;
string s, t;
int ctoi(char n) { return n - '0'; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> s >> t;
N *= 2;
int bin[4];
for (int i = int(0); i < int(4); ++i) bin[i] = 0;
for (int i = int(0); i < int(N); ++i) {
int i1 = ctoi(s[i]);
int i2 = ctoi(t[i]);
int ind = i2;
ind |= (i1 << 1);
bin[ind]++;
}
bool fstTurn = true;
int fstAdv = 0;
if (bin[3] % 2) {
fstAdv = 1;
fstTurn = false;
}
fstAdv += (bin[2] + fstTurn) / 2;
if (bin[2] % 2) fstTurn = not fstTurn;
fstAdv -= (bin[1] + (not fstTurn)) / 2;
if (fstAdv > 0)
cout << "First\n";
else if (fstAdv == 0)
cout << "Draw\n";
else
cout << "Second\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
struct Node {
string str;
char ch;
int num;
};
struct Node2 {
string str1, str2;
};
vector<Node2> num1;
vector<Node2> num2;
vector<Node> nodes;
vector<Node> Tmp;
vector<string> ans;
int vis[100005];
int cmp(Node a, Node b) {
if (a.ch == b.ch) {
return a.num < b.num;
}
return a.ch < b.ch;
}
int cmp2(Node a, Node b) { return a.num < b.num; }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
string str;
cin >> str;
Node now;
now.str = str;
int num = 0;
char ch;
for (int j = 0; j < str.size(); j++) {
if (str[j] == 'a' || str[j] == 'e' || str[j] == 'i' || str[j] == 'o' ||
str[j] == 'u') {
num++;
ch = str[j];
}
}
now.num = num, now.ch = ch;
nodes.push_back(now);
}
sort(nodes.begin(), nodes.end(), cmp);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (nodes[i].num == nodes[i + 1].num && nodes[i].ch == nodes[i + 1].ch) {
Node2 now;
now.str1 = nodes[i].str, now.str2 = nodes[i + 1].str;
vis[i] = 1;
num1.push_back(now);
i++;
vis[i] = 1;
}
}
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
Tmp.push_back(nodes[i]);
}
sort(Tmp.begin(), Tmp.end(), cmp2);
for (int i = 0; i < Tmp.size(); i++) {
if (Tmp[i].num == Tmp[i + 1].num) {
Node2 now;
now.str1 = Tmp[i].str, now.str2 = Tmp[i + 1].str;
num2.push_back(now);
i++;
}
}
int len1 = num1.size(), len2 = num2.size();
if (len1 >= len2) {
cnt = len2 + (len1 - len2) / 2;
} else
cnt = len1;
printf("%d\n", cnt);
int sta1 = 0, sta2 = 0;
while (sta1 < len1 && sta2 < len2) {
cout << num2[sta2].str1 << " " << num1[sta1].str1 << endl;
cout << num2[sta2].str2 << " " << num1[sta1].str2 << endl;
sta1++, sta2++;
}
len1--;
while (len1 - sta1 >= 1) {
cout << num1[sta1].str1 << " " << num1[sta1 + 1].str1 << endl;
cout << num1[sta1].str2 << " " << num1[sta1 + 1].str2 << endl;
sta1 += 2;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, one3rd, rem, a, b, c;
int main() {
cin >> n;
rem = n % 3;
one3rd = n / 3;
if (rem == 0) {
if (one3rd % 3 == 0) {
a = one3rd - 1;
b = one3rd - 1;
c = one3rd + 2;
} else {
a = one3rd;
b = one3rd;
c = one3rd;
}
} else if (rem == 1) {
if (one3rd % 3 == 0) {
a = one3rd - 1;
b = one3rd + 1;
c = one3rd + 1;
} else if ((one3rd + 1) % 3 == 0) {
a = one3rd - 1;
b = one3rd;
c = one3rd + 2;
} else {
a = one3rd;
b = one3rd;
c = one3rd + 1;
}
} else {
if (one3rd % 3 == 0) {
a = one3rd - 1;
b = one3rd + 1;
c = one3rd + 2;
} else if ((one3rd + 2) % 3 == 0) {
a = one3rd;
b = one3rd + 1;
c = one3rd + 1;
} else {
a = one3rd;
b = one3rd;
c = one3rd + 2;
}
}
cout << a << " " << b << " " << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 404, mod = 1e9 + 7, inf = 2e9;
void read(int& n) {
n = 0;
while (1) {
char c = getchar();
if (c == ' ' || c == '\n') break;
n = (n << 1) + (n << 3) + c - '0';
}
}
void read(ll& n) {
n = 0;
while (1) {
char c = getchar();
if (c == ' ' || c == '\n') break;
n = (n << 1) + (n << 3) + c - '0';
}
}
void write(int n) {
if (n > 9)
write(n / 10), putchar(n % 10 + '0');
else
putchar(n + '0');
}
void write(ll n) {
if (n > 9)
write(n / 10), putchar(n % 10 + '0');
else
putchar(n + '0');
}
template <class F, class... Ts>
void read(F& f, Ts&... ts) {
read(f);
read(ts...);
}
template <class F, class... Ts>
void write(F& f, Ts&... ts) {
write(f);
putchar(' ');
write(ts...);
}
template <class... Ts>
void writeln(const Ts&... ts) {
write(ts...);
putchar('\n');
}
int n, m, ans = 0, a[N][N], dp[N][N], cr[N][N * N];
int main() {
cin.tie(0)->sync_with_stdio(0);
read(n, m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
read(a[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int len = 1; len <= m; len++) {
for (int l = 1, r = len; r <= m; l++, r++) {
if (l == r) {
dp[l][r] = max(dp[l][r], cr[l][a[i][r]]);
} else {
dp[l][r] = max({dp[l][r], dp[l + 1][r], dp[l][r - 1]});
dp[l][r] = max({dp[l][r], cr[l][a[i][r]], cr[r][a[i][l]]});
if (a[i][l] == a[i][r]) {
dp[l][r] = i;
}
}
ans = max(ans, (i - dp[l][r]) * (r - l + 1));
}
}
for (int j = 1; j <= m; j++) {
cr[j][a[i][j]] = i;
}
}
write(ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<vector<int> > v(1001);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
v[a[i]].push_back(i + 1);
}
sort(a, a + n);
int x = 0;
int cost = 0;
for (int i = n - 1; i >= 0; i--) {
cost += x * a[i] + 1;
++x;
}
cout << cost << endl;
for (int i = 1000; i >= 1; i--) {
for (int j = 0; j < v[i].size(); j++) cout << v[i][j] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
#define ld long double
#define ll long long
#define ull unsigned long long
#define pb push_back
#define eb emplace_back
#define endl '\n'
#define _100iq ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
template<typename A, typename B>
string to_string(pair<A, B> p);
template<typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template<typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first)res += ", ";
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template<size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++)res += static_cast<char>('0' + v[i]);
return res;
}
template<typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first)res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template<typename A, typename B>
string to_string(pair<A, B> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template<typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template<typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " +
to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifndef ONLINE_JUDGE
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
ll const N = 1e6 * 2;
void task_a() {
int n;
cin >> n;
n *= 2;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
sort(v.begin(), v.end());
for (int i = 0; i < n - 1; ++i) {
multiset<int> st;
for (int j = 0; j < n; ++j) {
st.insert(v[j]);
}
int maxx = *st.rbegin();
st.erase(st.find(maxx));
int second = v[i];
st.erase(st.find(v[i]));
vector<pair<int, int>> ans;
ans.eb(maxx, second);
bool ok = false;
ll first = maxx;
while (!st.empty()) {
ll secondmaxx = *st.rbegin();
ll x = maxx - *st.rbegin();
st.erase(st.find(secondmaxx));
if (st.find(x) != st.end()) {
ans.eb(secondmaxx, x);
maxx = secondmaxx;
st.erase(st.find(x));
} else {
ok = true;
break;
}
}
if (!ok) {
cout << "YES\n";
cout << first + second << endl;
for (int j = 0; j < ans.size(); ++j) {
cout << ans[j].first << " " << ans[j].second << endl;
}
return;
}
}
cout << "NO\n";
}
int main() {
_100iq;
#ifndef ONLINE_JUDGE
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#endif
int t;
t = 1;
cin >> t;
for (int i = 1; i <= t; ++i) {
task_a();
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long a, b, cnt, d, n, p, ta, i, j;
vector<long> v[60], v1;
while (cin >> n >> ta) {
cnt = 0;
v1.clear();
for (i = 0; i < 55; i++) v[i].clear();
for (i = 0; i < n; i++) {
cin >> p;
for (j = 0; j < p; j++) {
cin >> a;
v[i].push_back(a);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < v[i].size(); j++) {
if (v[i][j] < ta) {
cnt++;
v1.push_back(i + 1);
break;
}
}
}
cout << cnt << endl;
for (i = 0; i < v1.size(); i++) {
if (i != v1.size() - 1)
cout << v1[i] << " ";
else
cout << v1[i] << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100010];
set<int> pres[100010];
bool visited[100010], bad;
int color[100010], col;
void init() {
for (int i = 0; i < 100010; i++) color[i] = 100;
col = 0;
}
void dfs(int v) {
color[v] = col;
visited[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
if (color[adj[v][i]] == col) {
bad = 1;
}
}
col = 1 - col;
for (int i = 0; i < adj[v].size(); i++) {
if (!visited[adj[v][i]]) {
dfs(adj[v][i]);
}
}
}
int main() {
init();
int n;
cin >> n;
int p[n + 1];
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (!pres[i].count(p[i])) {
pres[i].insert(p[i]);
adj[i].push_back(p[i]);
}
if (!pres[p[i]].count(i)) {
pres[p[i]].insert(i);
adj[p[i]].push_back(i);
}
}
int rupsha = 0;
for (int i = 1; i <= n; i++) {
if (p[i] == i) {
rupsha = i;
break;
}
}
if (rupsha > 0) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (rupsha != i) {
cout << rupsha << " " << i << endl;
}
}
return 0;
}
for (int i = 1; i <= n; i++) {
if (p[p[i]] == i) rupsha = i;
if (!visited[i]) dfs(i);
}
if (bad or !rupsha) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (i != rupsha and i != p[rupsha]) {
if (color[i] == 1) {
cout << rupsha << " " << i << endl;
} else {
cout << p[rupsha] << " " << i << endl;
}
}
}
cout << rupsha << " " << p[rupsha] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 1 << 17;
const int SIZE = MAXN << 1;
const int ROWS = 48;
const int MOD = 95542721;
int seg[SIZE][ROWS];
int rowl[SIZE];
int rowr[SIZE];
int N, Q;
int ar[MAXN];
void init(int cur = 1, int l = 0, int r = MAXN) {
if (l + 1 == r) {
long long prod = ar[l] % MOD;
for (int i = 0; i < ROWS; ++i) {
seg[cur][i] = prod;
prod = ((prod * prod) % MOD * prod) % MOD;
}
} else {
int childl = cur * 2, childr = childl + 1;
int mid = (l + r) / 2;
init(childl, l, mid);
init(childr, mid, r);
for (int i = 0; i < ROWS; ++i) {
seg[cur][i] = (seg[childl][i] + seg[childr][i]) % MOD;
}
}
}
void slide(int left, int right, int cur = 1, int l = 0, int r = MAXN) {
if (right <= l || r <= left) {
return;
}
int childl = cur * 2, childr = childl + 1;
int mid = (l + r) / 2;
if (left <= l && mid <= right) {
++rowl[cur];
} else {
slide(left, right, childl, l, mid);
}
if (left <= mid && r <= right) {
++rowr[cur];
} else {
slide(left, right, childr, mid, r);
}
for (int i = 0; i < ROWS; ++i) {
int rl = (rowl[cur] + i) % ROWS;
int rr = (rowr[cur] + i) % ROWS;
seg[cur][i] = (seg[childl][rl] + seg[childr][rr]) % MOD;
}
}
int query(int left, int right, int cur = 1, int row = 0, int l = 0,
int r = MAXN) {
if (right <= l || r <= left) {
return 0;
}
if (left <= l && r <= right) {
return seg[cur][row];
}
int childl = cur * 2, childr = childl + 1;
int mid = (l + r) / 2;
int rl = (row + rowl[cur]) % ROWS;
int rr = (row + rowr[cur]) % ROWS;
return (query(left, right, childl, rl, l, mid) +
query(left, right, childr, rr, mid, r)) %
MOD;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d", ar + i);
}
init();
scanf("%d", &Q);
for (int q = 0; q < Q; ++q) {
int qtype, left, right;
scanf("%d %d %d", &qtype, &left, &right);
++right;
if (qtype == 1) {
int ans = query(left, right);
printf("%d\n", ans);
} else if (qtype == 2) {
slide(left, right);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int u, v, w;
} lca[105];
int edge[20];
long long dp[(1 << 13) + 10][15];
int main() {
int n, m, q, a, b;
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
a--, b--;
edge[a] |= (1 << b);
edge[b] |= (1 << a);
}
for (int i = 0; i < q; i++) {
scanf("%d %d %d", &lca[i].u, &lca[i].v, &lca[i].w);
lca[i].u--, lca[i].v--, lca[i].w--;
}
for (int mask = 1; mask < (1 << n); mask++) {
for (int root = 0; root < n; root++) {
if (((~mask) & (1 << root))) continue;
int tmask = mask ^ (1 << root);
if (tmask == 0) {
dp[mask][root] = 1;
continue;
}
int id = tmask & (-tmask);
for (int newmask = tmask; newmask; newmask = (newmask - 1) & tmask) {
if (((~newmask) & id)) continue;
bool val = 1;
for (int i = 0; i < q && val; i++)
if ((newmask & (1 << lca[i].w)) && (((~newmask) & (1 << lca[i].u)) ||
((~newmask) & (1 << lca[i].v))))
val = 0;
else if (((~newmask) & (1 << lca[i].w)) &&
(newmask & (1 << lca[i].u)) && (newmask & (1 << lca[i].v)))
val = 0;
if (!val) continue;
for (int newroot = 0; newroot < n; newroot++) {
if (((~newmask) & (1 << newroot))) continue;
if ((edge[newroot] & (newmask | (1 << root))) != edge[newroot])
continue;
dp[mask][root] += dp[newmask][newroot] * dp[mask ^ newmask][root];
}
}
}
}
printf("%I64d\n", dp[(1 << n) - 1][0]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int temp, result = 0;
float r, x, y;
cin >> x >> y;
r = sqrt(x * x + y * y);
temp = r;
if (temp == r)
cout << "black";
else if ((x > 0 && y > 0) || (x < 0 && y < 0)) {
if (temp % 2 != 0)
cout << "white";
else
cout << "black";
} else if (temp % 2 != 0)
cout << "black";
else
cout << "white";
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;
void dfs(const int now, vector<int>& v, int num,
const vector<vector<int>>& edges) {
v[now] = num;
for (auto e : edges[now]) {
if (v[e] == 0) dfs(e, v, num, edges);
}
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> edges(N, vector<int>());
for (int i = 0; i < M; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
vector<int> types(N);
int num = 1;
for (int i = 0; i < N; ++i) {
if (types[i] == 0) {
dfs(i, types, num, edges);
num++;
}
}
vector<long long int> ver_nums(num);
vector<long long int> edge_nums(num);
for (int i = 0; i < N; ++i) {
int k = types[i] - 1;
ver_nums[k]++;
edge_nums[k] += edges[i].size();
}
bool ok = true;
for (int i = 0; i < num; ++i) {
if (edge_nums[i] == ver_nums[i] * (ver_nums[i] - 1)) {
} else {
ok = false;
}
}
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e18;
const int mod = (int)1e9 + 7;
const int MAXN = (int)1e5 + 5;
long long n, m, q;
vector<int> adj[MAXN];
vector<int> adj2[2 * MAXN];
const int L = 18;
int tin[MAXN];
int dep[MAXN];
int name[MAXN];
int f[MAXN];
int tme = 1;
int ot;
int tot = 0;
void dfs(int v) {
tin[v] = tme++;
for (int j : adj[v]) {
if (tin[j] == 0) {
dep[j] = dep[v] + 1;
dfs(j);
}
}
}
unordered_map<int, bool> mp;
void dfs2(int v) {
f[v] = -1;
for (int j : adj[v]) {
if (dep[j] == dep[v] + 1) {
dfs2(j);
}
}
mp.clear();
for (int j : adj[v]) {
if (dep[j] != dep[v] + 1) {
if (f[j] != -1) {
assert(name[j] != 0);
adj2[name[j]].push_back(v);
adj2[v].push_back(name[j]);
tot += 2;
assert(tot <= 4 * n);
mp[f[j]] = 1;
f[j] = v;
}
}
}
for (int j : adj[v]) {
if (dep[j] == dep[v] + 1 && mp[j] == 0) {
f[j] = v;
name[j] = ot++;
assert(ot <= 2 * n);
adj2[name[j]].push_back(v);
adj2[v].push_back(name[j]);
adj2[name[j]].push_back(j);
adj2[j].push_back(name[j]);
tot += 4;
assert(tot <= 4 * n);
}
}
}
int dep2[2 * MAXN];
int par[2 * MAXN][L];
void dfs3(int v, int pr) {
dep2[v] = dep2[pr] + 1;
par[v][0] = pr;
for (int j = 1; j < L; j++) {
par[v][j] = par[par[v][j - 1]][j - 1];
}
for (int j : adj2[v]) {
if (j != pr) dfs3(j, v);
}
}
int lca(int a, int b) {
if (dep2[b] < dep2[a]) return lca(b, a);
for (int j = L - 1; j >= 0; j--) {
if (dep2[a] <= dep2[b] - (1 << j)) b = par[b][j];
}
if (a == b) return a;
for (int j = L - 1; j >= 0; j--)
if (par[a][j] != par[b][j]) {
a = par[a][j];
b = par[b][j];
}
return par[a][0];
}
int clc(int a, int b) { return dep2[a] + dep2[b] - 2 * dep2[lca(a, b)]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> q;
ot = n + 1;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
cerr << "k1" << '\n';
dfs(1);
cerr << "k2" << '\n';
for (int i = 1; i <= n; i++) {
for (int j = 0; j < adj[i].size(); j++) {
int c = adj[i][j];
if (tin[c] < tin[i]) {
swap(adj[i].back(), adj[i][j]);
j--;
adj[i].pop_back();
}
}
}
cerr << "k3" << '\n';
dfs2(1);
cerr << "k4" << '\n';
dfs3(1, 1);
cerr << "k5" << '\n';
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
assert(clc(a, b) % 2 == 0);
cout << clc(a, b) / 2 << '\n' << flush;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, sum, cnt, ans, q;
vector<int> v[200005];
int buy[200005];
int freq[200005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
for (int i = (0); i <= (n); i++) {
buy[i] = freq[i] = 0;
v[i].clear();
}
for (int i = (1); i <= (n); i++) {
scanf("%d %d", &x, &y);
freq[x]++;
v[x].push_back(y);
}
int cur = 0;
for (int i = (0); i <= (n - 1); i++) {
if (cur < i) buy[i] = i - cur;
cur += freq[i];
}
priority_queue<int> pq;
int curmax = 0;
long long cost = 0;
for (int i = (n - 1); i >= (0); i--) {
for (auto it : v[i]) {
pq.push(-it);
}
for (int j = (1); j <= (buy[i] - curmax); j++) {
cost -= pq.top();
pq.pop();
}
curmax = max(curmax, buy[i]);
}
printf("%lld\n", cost);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 1e9 + 7;
const int N = 2e5 + 7;
const int M = 1e6 + 7;
map<long long, int> vis;
int judge() {
int ans = 0;
long long b, q, l, m, x;
cin >> b >> q >> l >> m;
for (int i = 1; i <= m; i++) {
cin >> x;
vis[x] = 1;
}
if (abs(b) > l) return 0;
if (b == 0 || q == 1) {
if (vis[b])
return 0;
else
return -1;
}
if (q == 0) {
if (!vis[0])
return -1;
else if (!vis[b])
return 1;
else
return 0;
}
if (q == -1) {
if (!vis[b] || !vis[-b])
return -1;
else
return 0;
}
while (abs(b) <= l) {
if (!vis[b]) ans++;
b *= q;
}
return ans;
}
signed main() {
ios::sync_with_stdio(false);
int x = judge();
if (x == -1)
cout << "inf\n";
else
cout << x << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m, p = 0;
cin >> n >> m;
int arr[2 * n][2];
for (int i = 0; i < 2 * n; i++) {
cin >> arr[i][0] >> arr[i][1];
}
if (m % 2 == 0) {
for (int i = 0; i < 2 * n; i += 2) {
if (arr[i + 1][0] == arr[i][1]) {
cout << "YES";
p = 1;
break;
}
}
if (p == 0) {
cout << "No";
}
} else {
cout << "No";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, v;
cin >> n >> m >> v;
if (n <= m && n <= v) {
cout << "Yes";
} else {
cout << "No";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int A, int B) {
if (B == 0)
return A;
else
return gcd(B, A % B);
}
long long int mod_exponentiation(long long int base, long long int exponent,
int modulus) {
long long int result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
int fermat(long long int n, long long int m) {
return mod_exponentiation(n, m - 2, m);
}
struct node {
int a;
int cnt;
};
struct Compare {
bool operator()(node &a, node &b) { return a.cnt > b.cnt; }
};
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T>
inline T sqr(T x) {
return x * x;
}
int main() {
string s1, s2;
cin >> s1 >> s2;
if (s1 == s2)
cout << s1;
else
cout << "1";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e % 2)
return ((b)*power((b) * (b), (e - 1) / 2));
else
return power((b) * (b), e / 2);
}
void dpv(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << '\n';
}
void dpv(vector<pair<long long, long long> > v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << '\n';
}
}
void dpv(set<long long> v) {
for (auto i : v) {
cout << i << " ";
}
cout << '\n';
}
long long Logn(long long n, long long k) {
return (n > k - 1) ? 1 + Logn(n / k, k) : 0;
}
long long max(long long a, long long b) {
if (a > b) {
return a;
} else {
return b;
}
}
string add(string s1, string s2) {
string s3;
long long z = s1.length() - s2.length();
if (z < 0) {
z = z * (-1);
}
for (long long i = 0; i < z; i++) {
if (min(s1.length(), s2.length()) == s1.length()) {
s1 = '0' + s1;
} else {
s2 = '0' + s2;
}
}
long long c = 0;
for (long long i = s1.length() - 1; i >= 0; i--) {
long long z1 = s1[i] - '0';
long long z2 = s2[i] - '0';
long long k = (z1 + z2 + c) % 2;
c = (z1 + z2 + c) / 2;
s3 = char('0' + k) + s3;
}
if (c != 0) {
s3 = char('0' + c) + s3;
}
return s3;
}
long long comp(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (abs(a.first) + abs(a.second) < abs(b.first) + abs(b.second));
}
long long min(long long a, long long b) {
if (a < b) {
return a;
} else {
return b;
}
}
bool sortbydesc(pair<long long, long long> &a, pair<long long, long long> &b) {
return a.first > b.first;
}
void oblivious() {
long long a, b;
cin >> a >> b;
long long ans = 0;
while (a != 1) {
ans += a / b;
long long temp = a;
a = b;
b = temp % b;
}
ans += b;
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
oblivious();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long seg[500001], sum[500001];
long long mp[500001] = {0};
vector<long long> g[500001];
bool see[500001];
long long depth[500001], p[500001];
multiset<long long> ep;
multiset<long long>::iterator it;
void dfs(long long u, long long par, long long d) {
see[u] = 1;
p[u] = par;
depth[u] = d;
for (long long i = 0; i < g[u].size(); i++) {
long long v = g[u][i];
if (!see[v])
dfs(v, u, d + 1);
else if (depth[v] < depth[u] && v != par) {
long long x = u, mn = v, mx = v;
while (v != x) {
mn = min(mn, x);
mx = max(mx, x);
x = p[x];
}
mp[mn] = mx;
ep.insert(mx);
}
}
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, e;
cin >> n >> e;
for (long long i = 0; i < e; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
memset(see, 0, sizeof see);
for (long long i = 1; i <= n; i++) {
if (!see[i]) {
dfs(i, 0, 0);
}
}
memset(sum, 0, sizeof sum);
for (long long i = 1; i <= n; i++) {
if (ep.size()) {
it = ep.begin();
seg[i] = *it - 1;
} else
seg[i] = n;
if (mp[i] != 0) ep.erase(ep.find(mp[i]));
sum[i] = sum[i - 1] + seg[i] - i + 1;
}
int q, l, r;
cin >> q;
while (q--) {
cin >> l >> r;
long long ans = 0;
if (seg[r] > r) {
long long* id = lower_bound(seg + l, seg + r, r + 1);
long long temp = (id - seg);
ans += (r - temp + 1) * (r - temp + 2) / 2;
ans += (sum[temp - 1] - sum[l - 1]);
} else
ans = sum[r] - sum[l - 1];
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, p, flag;
char s[1111];
int a[1111];
void dfs(int x) {
if (!x) {
flag = 0;
return;
}
while (1) {
a[x]++;
if (a[x] > p) {
dfs(x - 1);
a[x] = 0;
continue;
}
if (!(x > 1 && a[x] == a[x - 1] || x > 2 && a[x] == a[x - 2])) break;
}
if (x == n)
for (int i = 0; i < n; i++) s[i] = a[i + 1] - 1 + 'a';
}
int main() {
cin >> n >> p;
gets(s);
gets(s);
for (int i = 0; i < n; i++) a[i + 1] = s[i] - 'a' + 1;
flag = 1;
dfs(n);
if (flag)
puts(s);
else
puts("NO");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int INF = 1000000000000000000;
struct Edge {
Edge() : u(INF), v(INF), id(INF), weight(INF) {}
Edge(int u1, int v1, long long int w1, int id1)
: u(u1), v(v1), weight(w1), id(id1) {}
int u;
int v;
int id;
long long int weight;
};
Edge def;
struct Item {
long long int distance;
Edge edge;
int u;
Item() : distance(INF), u(INF), edge(def) {}
Item(long long int d, int u1, Edge e) : distance(d), u(u1), edge(e) {}
bool operator<(const Item& item) const {
return pair<long long int, long long int>(distance, edge.weight) >
pair<long long int, long long int>(item.distance, item.edge.weight);
}
};
vector<Edge> graph[300010];
Item dist[300010];
priority_queue<Item> pq;
int N, M;
int main() {
cin >> N >> M;
long long int u, v, w;
for (int i = 0; i < M; i++) {
cin >> u >> v >> w;
graph[u].push_back(Edge(u, v, w, i + 1));
graph[v].push_back(Edge(v, u, w, i + 1));
}
cin >> u;
pq.push(Item(0, u, Edge()));
dist[u] = Item(0, u, Edge());
while (!pq.empty()) {
Item item = pq.top();
pq.pop();
if (item < dist[item.u]) continue;
for (auto edge : graph[item.u]) {
Item newitem = Item(item.distance + edge.weight, edge.v, edge);
if (dist[edge.v] < newitem) {
dist[edge.v] = newitem;
pq.push(newitem);
}
}
}
long long int sum = 0;
vector<int> soln;
for (int i = 1; i <= N; i++) {
if (dist[i].distance != INF and i != u) {
sum += dist[i].edge.weight;
soln.push_back(dist[i].edge.id);
}
}
cout << sum << endl;
for (int i = 0; i < soln.size(); i++) {
if (i != 0) cout << " ";
cout << soln[i];
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int total = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
total += arr[i];
}
if (total % n == 0)
cout << n;
else
cout << n - 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, int> p[1111111];
bool cmp1(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.first.second < b.first.second;
}
bool cmp2(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.first.second > b.first.second;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &(p[i].first.first), &(p[i].first.second));
p[i].second = i;
}
sort(p + 1, p + n + 1);
int st = 1, dir = 1;
p[n + 1] = make_pair(make_pair(0x3f3f3f3f, 0), 0x3f3f3f3f);
for (int i = 1; i <= n + 1; i++)
if (p[i].first.first - p[st].first.first > 1000) {
if (dir == 1)
sort(p + st, p + i, cmp1);
else
sort(p + st, p + i, cmp2);
for (int j = st; j < i; j++) printf("%d ", p[j].second);
dir ^= 1;
st = i;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dt[100][100];
int dp[100][100][100];
int main() {
int n, m, r;
cin >> n >> m >> r;
memset(dp, 10000, sizeof(dp));
for (int mm = 1; mm <= m; mm++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &dt[i][j]);
}
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (dt[i][k] + dt[k][j] < dt[i][j]) {
dt[i][j] = dt[i][k] + dt[k][j];
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j][0] = min(dp[i][j][0], dt[i][j]);
}
}
}
for (int nn = 1; nn <= n; nn++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j][nn] = dp[i][j][nn - 1];
}
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j][nn] = min(dp[i][j][nn], dp[i][k][nn - 1] + dp[k][j][0]);
}
}
}
}
while (r--) {
int be, en, t;
cin >> be >> en >> t;
t = min(t, n);
cout << dp[be][en][t] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
vector<long long> vec;
long long n, mn = INT_MAX, mx = 0;
cin >> n;
for (int i = 0; i < n; i++) {
long long t;
cin >> t;
vec.push_back(t);
mn = min(mn, t);
mx = max(mx, t);
}
long long dif = mx - mn;
if (dif % 2 == 0) {
long long mid = mn + (dif / 2), aor = dif / 2;
for (int i = 0; i < n; i++) {
if (vec[i] < mid)
vec[i] += aor;
else if (vec[i] > mid)
vec[i] -= aor;
}
for (int i = 0; i < n; i++) {
if (vec[i] != mid) {
cout << -1 << endl;
return 0;
}
}
cout << aor << endl;
} else {
long long f = mx - mn;
for (int i = 0; i < n; i++) {
if (vec[i] == mx)
continue;
else
vec[i] += dif;
}
for (int i = 0; i < n; i++) {
if (vec[i] != mx) {
cout << -1 << endl;
return 0;
}
}
cout << dif << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a[3];
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
if (a[1] != a[2]) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << a[0] << " " << a[0] << " " << a[2] << endl;
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double PI = atan(1.0) * 4;
const int inf = 2147483647 / 2;
const int maxn = 100005;
template <class T>
void chmin(T &t, T first) {
if (first < t) t = first;
}
template <class T>
void chmax(T &t, T first) {
if (first > t) t = first;
}
template <class T>
int sgn(T first) {
return (first > eps) - (first < -eps);
}
vector<int> an[maxn];
int num[maxn];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = (0); i <= (int)(n); i++) an[i].clear();
for (int i = (0); i <= (int)(m - 1); i++) {
scanf("%d", &num[i]);
if (i && num[i] != num[i - 1]) {
an[num[i]].push_back(num[i - 1]);
an[num[i - 1]].push_back(num[i]);
}
}
long long best = 0, idx = -1;
for (int i = (1); i <= (int)(n); i++)
if (((int)(an[i]).size())) {
sort(an[i].begin(), an[i].end());
long long tsum = 0;
for (int first : an[i]) tsum += abs(first - i);
int tmp = an[i][((int)(an[i]).size()) / 2];
long long sum2 = 0;
for (int j = (0); j <= (int)(((int)(an[i]).size()) - 1); j++)
sum2 += abs(an[i][j] - tmp);
if (tsum - sum2 > best) idx = i, best = tsum - sum2;
}
if (idx != -1) {
int chag = an[idx][((int)(an[idx]).size()) / 2];
for (int i = (0); i <= (int)(m - 1); i++)
if (num[i] == idx) num[i] = chag;
}
long long ans = 0;
for (int i = (0); i <= (int)(m - 2); i++) ans += abs(num[i + 1] - num[i]);
printf("%I64d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
ofstream fout("output.txt");
int const M = 2e5 + 10, mod = 998244353, inf = 1e9 + 10;
map<int, int> dp[70], mark[70];
int fdp(int n, int msk) {
bool mark2[70];
for (int j = 0; j <= 60; j++) mark2[j] = 0;
msk %= ((1LL << (n + 1)));
if (n == 0) {
mark[n][msk] = 1;
return 0;
}
if (mark[n][msk]) return dp[n][msk];
mark[n][msk] = 1;
for (int j = n; j >= 1; j--) {
if (!(msk & (1LL << j))) {
mark2[fdp(n - j, (msk xor (1LL << j)))] = 1;
}
}
for (int j = 0; j <= n + 1; j++) {
if (!mark2[j]) {
dp[n][msk] = j;
break;
}
}
return dp[n][msk];
}
int32_t main() {
for (int i = 1; i <= 60; i++) {
fdp(i, 0);
}
int n;
cin >> n;
int gr = 0;
for (int i = 1; i <= n; i++) {
int tmp;
cin >> tmp;
gr = gr xor dp[tmp][0];
}
if (gr)
cout << "NO";
else
cout << "YES";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
int q;
cin >> n >> q;
for (int i = 0; i < q; i++) {
long long temp;
cin >> temp;
string s;
cin >> s;
long long lev = 1, maxLev = 0, temp2 = 1;
while (temp2 != (n + 1ll)) {
maxLev++;
temp2 *= 2ll;
}
while ((temp % (1ll << lev)) != (1ll << (lev - 1ll))) lev++;
for (int j = 0; j < s.size(); j++) {
if (s[j] == 'L') {
if (lev > 1) {
temp -= (1ll << (lev - 2ll));
lev--;
}
} else if (s[j] == 'R') {
if (lev > 1) {
temp += (1ll << (lev - 2ll));
lev--;
}
} else if (s[j] == 'U') {
if (lev < maxLev) {
long long temp1 = temp / (1ll << lev);
if (temp1 % 2ll == 0)
temp += (1ll << (lev - 1ll));
else
temp -= (1ll << (lev - 1ll));
lev++;
}
}
}
cout << temp << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
struct P {
double x, y;
P(double x, double y) : x(x), y(y) {}
};
int a, b, c;
int sx, sy, tx, ty;
vector<P> p;
vector<double> d;
double dst(const P &a, const P &b) {
double dx = b.x - a.x, dy = b.y - a.y;
return sqrt(dx * dx + dy * dy);
}
double solve() {
if (sx > tx) a = -a, sx = -sx, tx = -tx;
if (sy > ty) b = -b, sy = -sy, ty = -ty;
p.clear();
p.push_back(P(sx, sy));
p.push_back(P(sx, ty));
p.push_back(P(tx, sy));
p.push_back(P(tx, ty));
if (b != 0)
p.push_back(P(sx, (-1.0 * a * sx - c) / b)),
p.push_back(P(tx, (-1.0 * a * tx - c) / b));
if (a != 0)
p.push_back(P((-1.0 * b * sy - c) / a, sy)),
p.push_back(P((-1.0 * b * ty - c) / a, ty));
int n = ((int)(p).size());
d = vector<double>(n, 1e200);
d[0] = 0;
for (int rep = (0); rep < (100); ++rep) {
bool change = false;
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) {
if ((i < 4 || j < 4) && (p[i].x != p[j].x && p[i].y != p[j].y))
continue;
double nval = d[i] + dst(p[i], p[j]);
if (nval + 1e-9 < d[j]) d[j] = nval, change = true;
}
if (!change) break;
}
return d[3];
}
void run() {
scanf("%d%d%d", &a, &b, &c);
scanf("%d%d%d%d", &sx, &sy, &tx, &ty);
printf("%.15lf\n", solve());
}
int main() {
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, i, j, cn = 0;
char s[10000];
gets(s);
l = strlen(s);
sort(s, s + l);
for (i = 0; i < l; i++) {
if (s[i] > 96 && s[i] < 123) {
cn++;
if (s[i] == s[i + 1]) cn--;
}
}
printf("%d\n", cn);
cn = 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void readInputData();
void run();
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
readInputData();
run();
return 0;
}
int a;
int b;
int c;
void readInputData() { cin >> a >> b >> c; }
void run() {
int answer = 0;
while (a > 0 && b > 0 && c > 0) {
if (a == 1) {
answer += b * c;
} else if (b == 1) {
answer += a * c;
} else if (c == 1) {
answer += a * b;
} else {
answer += 2 * (a + b + c) - 6;
}
a--;
b--;
c--;
}
cout << answer;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int check(int m) {
if (m == 'a' || m == 'e' || m == 'i' || m == 'o' || m == 'u' || m == 'y')
return 1;
else
return 0;
}
int main() {
int n, k = 0;
string s;
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
if (check(s[i]))
k++;
else
k = 0;
if (k < 2) cout << s[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int tmax = (int)1e5 + 100;
char str[35];
map<string, int> players;
int main() {
int t;
scanf("%d", &t);
int max_val = -1;
string winner = "";
vector<pair<string, int> > save;
while (t--) {
int total;
scanf(" %s %d", str, &total);
save.push_back(make_pair(str, total));
players[str] += total;
}
int best_res = -1;
for (map<string, int>::iterator it = players.begin(); it != players.end();
it++)
best_res = max(best_res, it->second);
map<string, int> players2;
for (int i = 0; i < save.size(); i++) {
players2[save[i].first] += save[i].second;
if (players2[save[i].first] >= best_res and
players[save[i].first] == best_res) {
printf("%s\n", save[i].first.c_str());
return 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using uint = unsigned int;
template <class T>
using V = vector<T>;
template <class T>
using VV = vector<vector<T>>;
template <class T, class U>
void chmax(T& x, U y) {
if (x < y) x = y;
}
template <class T, class U>
void chmin(T& x, U y) {
if (y < x) x = y;
}
template <class T>
void mkuni(V<T>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vc) {
o << "{";
for (const T& v : vc) o << v << ",";
o << "}";
return o;
}
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
unsigned int mod = 1;
struct ModInt {
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
uint v;
ModInt() : v(0) {}
ModInt(ll _v) : v(normS(_v % mod + mod)) {}
explicit operator bool() const { return v != 0; }
static uint normS(const uint& x) { return (x < mod) ? x : x - mod; }
static ModInt make(const uint& x) {
ModInt m;
m.v = x;
return m;
}
ModInt operator+(const ModInt& b) const { return make(normS(v + b.v)); }
ModInt operator-(const ModInt& b) const { return make(normS(v + mod - b.v)); }
ModInt operator-() const { return make(normS(mod - v)); }
ModInt operator*(const ModInt& b) const { return make((ull)v * b.v % mod); }
ModInt operator/(const ModInt& b) const { return *this * b.inv(); }
ModInt& operator+=(const ModInt& b) { return *this = *this + b; }
ModInt& operator-=(const ModInt& b) { return *this = *this - b; }
ModInt& operator*=(const ModInt& b) { return *this = *this * b; }
ModInt& operator/=(const ModInt& b) { return *this = *this / b; }
ModInt& operator++(int) { return *this = *this + 1; }
ModInt& operator--(int) { return *this = *this - 1; }
ll extgcd(ll a, ll b, ll& x, ll& y) const {
ll p[] = {a, 1, 0}, q[] = {b, 0, 1};
while (*q) {
ll t = *p / *q;
for (int i = 0; i < int(3); i++) swap(p[i] -= t * q[i], q[i]);
}
if (p[0] < 0)
for (int i = 0; i < int(3); i++) p[i] = -p[i];
x = p[1], y = p[2];
return p[0];
}
ModInt inv() const {
ll x, y;
extgcd(v, mod, x, y);
return make(normS(x + mod));
}
ModInt pow(ll p) const {
if (p < 0) return inv().pow(-p);
ModInt a = 1;
ModInt x = *this;
while (p) {
if (p & 1) a *= x;
x *= x;
p >>= 1;
}
return a;
}
bool operator==(const ModInt& b) const { return v == b.v; }
bool operator!=(const ModInt& b) const { return v != b.v; }
friend istream& operator>>(istream& o, ModInt& x) {
ll tmp;
o >> tmp;
x = ModInt(tmp);
return o;
}
friend ostream& operator<<(ostream& o, const ModInt& x) { return o << x.v; }
};
using mint = ModInt;
V<mint> fact, ifact, invs;
mint Choose(int a, int b) {
if (b < 0 || a < b) return 0;
return fact[a] * ifact[b] * ifact[a - b];
}
void InitFact(int N) {
N++;
fact.resize(N);
ifact.resize(N);
invs.resize(N);
fact[0] = 1;
for (int i = 1; i <= int(N - 1); i++) fact[i] = fact[i - 1] * i;
ifact[N - 1] = fact[N - 1].inv();
for (int i = N - 2; i >= 0; i--) ifact[i] = ifact[i + 1] * (i + 1);
for (int i = 1; i <= int(N - 1); i++) invs[i] = fact[i - 1] * ifact[i];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, M;
cin >> N >> M >> mod;
InitFact(100000);
V<mint> way(N + 1), sum(N + 1);
way[0] = 1;
for (int n = 1; n <= int(N); n++) {
for (int i = 0; i < int(n); i++) {
way[n] += way[i] * way[n - 1 - i] * Choose(n - 1, i) * (n + 1);
sum[n] += sum[i] * way[n - 1 - i] * Choose(n - 1, i) * (n + 1);
sum[n] += way[i] * sum[n - 1 - i] * Choose(n - 1, i) * (n + 1);
auto f = [&](int x) { return x * (x + 1) / 2; };
sum[n] +=
way[i] * way[n - 1 - i] * Choose(n - 1, i) * (f(i) + f(n - 1 - i));
}
}
VV<mint> f(N + 2, V<mint>(N + 1));
f[0][0] = 1;
VV<mint> g(N + 2, V<mint>(N + 1));
for (int n = 0; n < int(N + 1); n++)
for (int k = 0; k < int(n + 1); k++) {
for (int dn = 1; dn <= int(N); dn++) {
if (n + dn > N || k + dn > M) break;
f[n + dn + 1][k + dn] += f[n][k] * way[dn] * Choose(k + dn, k);
g[n + dn + 1][k + dn] +=
(f[n][k] * sum[dn] + g[n][k] * way[dn]) * Choose(k + dn, k);
}
f[n + 1][k] += f[n][k];
g[n + 1][k] += g[n][k];
}
cout << g[N + 1][M] << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, i, j, k = 0, m = 0, z = 0, nk = 1;
string s;
cin >> n;
cin >> s;
vector<int> v;
for (i = 0; i < n; i++) {
if (i == 0 && s[0] == '0') {
v.push_back(0);
z = 0;
} else if (z == 0 && s[i] == '0') {
v.push_back(0);
} else if (s[i] == '1') {
z = 1;
k++;
m = 1;
} else if (s[i] == '0' && m >= 1) {
z = 1;
k = 0;
if (m == 1 && nk == 1) {
v.push_back(0);
nk = 0;
}
m++;
}
}
if (k != 0) {
for (j = 0; j < k; j++) v.push_back(1);
}
for (i = 0; i < v.size(); i++) cout << v[i];
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100010], tdp[100010], rem[60][60];
long long cnt[100010], inv[100010], fac[100010], W;
char str[100010];
const long long mod = 1e9 + 7;
int c_pos(char c) {
if (c >= 'A' && c <= 'Z')
return c - 'A' + 1;
else
return c - 'a' + 1 + 26;
}
long long fpow(long long a, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
void get_w(int n) {
fac[0] = 1;
int m = n / 2;
for (int i = 1; i <= n; ++i) fac[i] = i * fac[i - 1] % mod;
W = fac[m] * fac[m] % mod;
for (int i = 1; i <= 52; ++i) {
if (cnt[i] == 0) continue;
inv[i] = fpow(fac[cnt[i]], mod - 2);
W = W * inv[i] % mod;
}
}
void init() {
scanf("%s", str + 1);
int len = strlen(str + 1);
for (int i = 1; i <= len; ++i) ++cnt[c_pos(str[i])];
get_w(len);
dp[0] = 1;
int m = len / 2;
for (int i = 1; i <= 52; ++i) {
if (cnt[i] == 0) continue;
for (int j = m; j >= cnt[i]; --j) dp[j] = (dp[j] + dp[j - cnt[i]]) % mod;
}
for (int i = 1; i <= 52; ++i) {
if (cnt[i] == 0) continue;
for (int j = 1; j <= 52; ++j) {
if (cnt[j] == 0) continue;
for (int k = 0; k <= m; ++k) tdp[k] = dp[k];
for (int k = cnt[i]; k <= m; ++k)
tdp[k] = (tdp[k] - tdp[k - cnt[i]] + mod) % mod;
if (i != j)
for (int k = cnt[j]; k <= m; ++k)
tdp[k] = (tdp[k] - tdp[k - cnt[j]] + mod) % mod;
rem[i][j] = tdp[m];
}
}
}
int main() {
init();
int q;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int px = c_pos(str[x]), py = c_pos(str[y]);
printf("%lld\n", rem[px][py] * W * 2 % mod);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 120010;
int vis[maxn];
long long power2[32];
int a[maxn];
int b[maxn];
int main() {
power2[0] = 1;
for (int i = 1; i < 32; i++) power2[i] = power2[i - 1] * 2;
int n;
while (~scanf("%d", &n)) {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b, b + n);
sort(a, a + n);
int f = unique(b, b + n) - b;
for (int i = 0; i < n; i++) {
int x = lower_bound(b, b + f, a[i]) - b;
++vis[x];
}
int ans = 0;
for (int i = 0; i < n; i++) {
int x = lower_bound(b, b + f, a[i]) - b;
int y;
int flag = 0;
for (int j = 0; j < 32; j++) {
y = lower_bound(b, b + f, power2[j] - a[i]) - b;
if (b[x] + b[y] == power2[j]) {
if (x != y || (x == y && vis[x] > 1)) {
flag = 1;
break;
}
}
}
if (!flag) {
++ans;
}
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double x, r;
int f, id;
} a[100005];
bool cmp1(node a, node b) { return a.x < b.x; }
bool cmp2(node a, node b) { return a.id < b.id; }
int isin(int i, double x, double y) {
double t = (x - a[i].x) * (x - a[i].x) + y * y;
if (t <= a[i].r * a[i].r) return 1;
return 0;
}
int main() {
int n, i, m;
double x, y;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%lf%lf", &a[i].x, &a[i].r);
a[i].f = -1;
a[i].id = i;
}
sort(a, a + n, cmp1);
scanf("%d", &m);
int ans = 0;
for (i = 1; i <= m; i++) {
scanf("%lf%lf", &x, &y);
int l = 0, r = n - 1, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (isin(mid, x, y)) {
if (a[mid].f == -1) {
a[mid].f = i;
ans++;
}
break;
}
if (x > a[mid].x)
l = mid + 1;
else
r = mid - 1;
}
l = mid;
if (l + 1 < n && isin(l + 1, x, y)) {
if (a[l + 1].f == -1) {
a[l + 1].f = i;
ans++;
}
}
if (l - 1 >= 0 && isin(l - 1, x, y)) {
if (a[l - 1].f == -1) {
a[l - 1].f = i;
ans++;
}
}
}
sort(a, a + n, cmp2);
printf("%d\n", ans);
for (i = 0; i < n - 1; i++) printf("%d ", a[i].f);
printf("%d\n", a[n - 1].f);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int K = 26;
int n, ptr, nxt[N][K], val[N], link[N];
long long fcnt[N], bcnt[N];
string s;
inline void clear() {
for (int i = 0; i < K; i++) {
nxt[ptr][i] = -1;
}
val[ptr] = 0;
}
inline void insert(string &t) {
int rt = 0;
int m = t.size();
for (int i = 0; i < m; i++) {
int ch = t[i] - 'a';
if (nxt[rt][ch] == -1) {
clear();
nxt[rt][ch] = ptr++;
}
rt = nxt[rt][ch];
}
val[rt]++;
}
inline void add_links() {
queue<int> q;
link[0] = 0;
for (int i = 0; i < K; i++) {
if (nxt[0][i] != -1) {
link[nxt[0][i]] = 0;
q.push(nxt[0][i]);
} else {
nxt[0][i] = 0;
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < K; i++) {
if (nxt[v][i] == -1) continue;
int u = link[v];
while (u != 0) {
if (nxt[u][i] != -1) break;
u = link[u];
}
link[nxt[v][i]] = nxt[u][i];
q.push(nxt[v][i]);
}
}
}
inline void run(int len) {
int rt = 0;
for (int i = 0; i < n; i++) {
int ch = s[i] - 'a';
while (nxt[rt][ch] == -1) rt = link[rt];
rt = nxt[rt][ch];
bcnt[i] += val[rt];
if (i - len + 1 >= 0) fcnt[i - len + 1] += val[rt];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(32);
cin >> s;
n = s.size();
int m;
cin >> m;
vector<string> t(m);
for (int i = 0; i < m; i++) {
cin >> t[i];
}
sort(t.begin(), t.end(),
[&](string &a, string &b) { return a.size() < b.size(); });
memset(fcnt, 0, sizeof(fcnt));
memset(bcnt, 0, sizeof(bcnt));
ptr = 0;
for (int i = 0; i < m; i++) {
int j = i;
while (j + 1 < m && t[j + 1].size() == t[i].size()) j++;
while (ptr >= 0) {
clear();
ptr--;
}
ptr = 1;
for (int k = i; k <= j; k++) {
insert(t[k]);
}
add_links();
run(t[i].size());
i = j;
}
long long ans = 0;
for (int i = 1; i < n; i++) {
ans += fcnt[i] * bcnt[i - 1];
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1004];
vector<pair<int, int> > V[2];
void getres() {
for (int i = 1; i <= n; i++)
if (a[i] == 0) a[i] = a[i - 1] - 1;
for (int j = 0; j < V[0].size(); j++) {
pair<int, int> cur = V[0][j];
int l = cur.first, r = cur.second;
bool ok = false;
for (int i = l; i < r; i++)
if (a[i] > a[i + 1]) {
ok = true;
break;
}
if (!ok) {
cout << "NO \n";
exit(0);
}
}
cout << "YES \n";
for (int i = 1; i <= n; ++i) cout << a[i] << " ";
cout << '\n';
}
void solve() {
cin >> n >> m;
int t, l, r;
for (int i = 1; i <= m; i++) {
cin >> t >> l >> r;
V[t].push_back({l, r});
}
sort(V[1].begin(), V[1].end());
int val = 1e8;
a[0] = val;
for (int j = 0; j < V[1].size(); j++) {
pair<int, int> cur = V[1][j];
int l = cur.first;
r = cur.second;
int ss = -1;
for (int i = l; i <= r; ++i) {
if (a[i] != 0) ss = a[i];
}
if (ss == -1) ss = val - 1002;
val -= 1002;
for (int i = l; i <= r; ++i) a[i] = ss;
}
getres();
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 100;
int a[N];
bool flag[N];
vector<int> res;
long long ans = 0;
int n, m;
void solve(int root, int dep);
void DFS(int root, int dep) {
if (a[root * 2] == a[root * 2 + 1] && a[root * 2] == 0) {
a[root] = 0;
if (dep == m + 1) flag[root] = true;
return;
}
if (a[root * 2] > a[root * 2 + 1]) {
swap(a[root], a[root * 2]);
DFS(root * 2, dep + 1);
} else {
swap(a[root], a[root * 2 + 1]);
DFS(root * 2 + 1, dep + 1);
}
if (flag[root * 2] == true && flag[root * 2 + 1] == false &&
a[root * 2] > a[root * 2 + 1]) {
solve(root * 2 + 1, dep + 1);
} else if (flag[root * 2] == false && flag[root * 2 + 1] == true &&
a[root * 2] < a[root * 2 + 1]) {
solve(root * 2, dep + 1);
}
if (flag[root * 2] == true && flag[root * 2 + 1] == true) {
flag[root] = true;
}
}
void solve(int root, int dep) {
while (flag[root] == false) {
res.push_back(root);
ans -= a[root];
DFS(root, dep);
}
}
int main() {
int T;
cin >> T;
while (T--) {
scanf("%d %d", &n, &m);
res.clear();
ans = 0;
for (int i = 1; i < (1 << n); i++) {
scanf("%d", &a[i]);
flag[i] = false;
ans += a[i];
a[i * 2] = a[i * 2 + 1] = 0;
}
solve(1, 1);
printf("%lld\n", ans);
for (int i = 0; i < (int)res.size(); i++) {
printf("%d%c", res[i], i + 1 == (int)res.size() ? '\n' : ' ');
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > vp;
vector<long long> v;
set<long long> st;
long long ara[500005];
map<long long, long long> mp;
long long Set(long long N, long long pos) { return N = N | (1LL << pos); }
long long reset(long long N, long long pos) { return N = N & ~(1LL << pos); }
bool check(long long N, long long pos) { return (bool)(N & (1LL << pos)); }
vector<long long> e, o;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, i, j, p;
cin >> n;
if (n % 2 == 0)
cout << "NO\n";
else {
cout << "YES\n";
p = 1;
for (i = 0; i < 2 * n; i += 2) {
ara[i] = p;
p += 2;
}
p = 2;
for (i = n; i < 2 * n; i += 2) {
ara[i] = p;
p += 2;
}
for (i = 1; i < n; i += 2) {
ara[i] = p;
p += 2;
}
for (i = 0; i < 2 * n; i++) cout << ara[i] << " ";
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 150 + 10;
long long a[MAXN], b[MAXN], mn[4 * MAXN], d[4 * MAXN];
void shift(int cur) {
d[cur * 2] += d[cur];
mn[cur * 2] += d[cur];
d[cur * 2 + 1] += d[cur];
mn[cur * 2 + 1] += d[cur];
d[cur] = 0;
}
void merge(int cur) { mn[cur] = min(mn[cur * 2], mn[cur * 2 + 1]); }
void add(int lo, int hi, long long val, int cur, int s, int e) {
if (lo >= hi) return;
if (lo == s && hi == e) {
d[cur] += val;
mn[cur] += val;
return;
}
int mid = (s + e) / 2;
shift(cur);
if (lo < mid) add(lo, min(mid, hi), val, cur * 2, s, mid);
if (hi > mid) add(max(mid, lo), hi, val, cur * 2 + 1, mid, e);
merge(cur);
}
int main() {
long long n, m, h;
cin >> n >> m >> h;
for (int i = 0; i < m; i++) cin >> b[i], b[i] = h - b[i];
sort(b, b + m);
for (int i = 0; i < n; i++)
cin >> a[i], a[i] = upper_bound(b, b + m, a[i]) - b;
for (int i = 0; i < m; i++) add(0, i + 1, -1, 1, 0, m);
int ans = 0;
for (int i = 0; i < n; i++) {
add(0, a[i], 1, 1, 0, m);
if (i >= m) add(0, a[i - m], -1, 1, 0, m);
if (i >= m - 1) ans += (mn[1] >= 0);
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long c = getchar(), Nig = 1, x = 0;
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') Nig = -1, c = getchar();
while (isdigit(c)) x = ((x << 1) + (x << 3)) + (c ^ '0'), c = getchar();
return Nig * x;
}
const int maxn = 3e6 + 7;
long long a[maxn];
int n;
struct node {
int gen;
int tree[maxn][2];
void init() { gen = 0; }
int left[maxn], right[maxn];
void _add(long long x, int id) {
int rt = 0;
for (int i = 32; i >= 0; i--) {
int op = (x >> i) & 1;
if (!tree[rt][op]) tree[rt][op] = ++gen;
rt = tree[rt][op];
if (!left[rt]) left[rt] = id;
right[rt] = id;
}
}
long long _RetPos(int rt, int pos, long long x) {
long long ret = 0;
for (int i = pos; i >= 0; i--) {
int op = (x >> i) & 1L;
if (tree[rt][op])
rt = tree[rt][op];
else {
rt = tree[rt][!op];
ret += (1L << i);
}
}
return ret;
}
long long _Divide(int rt, int pos) {
if (tree[rt][0] && tree[rt][1]) {
long long mi = 0x3f3f3f3f;
int x = tree[rt][0], y = tree[rt][1];
for (int j = left[x]; j <= right[x]; j++) {
mi = min(mi, _RetPos(y, pos - 1, a[j]) + (1L << pos));
}
return mi + _Divide(tree[rt][0], pos - 1) + _Divide(tree[rt][1], pos - 1);
} else if (tree[rt][0]) {
return _Divide(tree[rt][0], pos - 1);
} else if (tree[rt][1]) {
return _Divide(tree[rt][1], pos - 1);
}
return 0L;
}
} wuyt;
int main() {
wuyt.init();
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
wuyt._add(a[i], i);
}
printf("%lld\n", wuyt._Divide(0, 32));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n;
bool f(long long q, long long w) {
if (q * q <= w) return true;
return false;
}
long long ridge(long long q) {
long long r = q;
long long l = 1;
while (r - l > 1) {
long long mid = (r + l) / 2;
if (f(mid, q))
l = mid;
else
r = mid;
}
return l;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
if (ridge(n) * ridge(n) == n) {
cout << 4 * ridge(n);
return 0;
}
if (n - ridge(n) * ridge(n) <= ridge(n)) {
cout << 4 * ridge(n) + 2;
return 0;
}
cout << 4 * ridge(n) + 4;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > a, b;
void my_shuffle() {
for (int i = 0; i < n; ++i) {
int r = 0;
for (int j = 1 - (m & 1); j < m; j += 2) b[i][r++] = a[i][j];
for (int j = m & 1; j < m; j += 2) b[i][r++] = a[i][j];
}
int r = 0;
for (int i = 1 - (n & 1); i < n; i += 2) a[r++] = b[i];
for (int i = (n & 1); i < n; i += 2) a[r++] = b[i];
b = a;
}
int main() {
iostream::sync_with_stdio();
cin >> n >> m;
a.resize(n, vector<int>(m));
b.resize(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
a[i][j] = i * m + j + 1;
}
}
if (n >= 4 && m >= 4) {
cout << "YES\n";
my_shuffle();
} else if ((n == 1 && m >= 4) || (n >= 4 && m == 1)) {
cout << "YES\n";
my_shuffle();
} else if ((n == 2 && m >= 4) || (n >= 4 && m == 2)) {
cout << "YES\n";
my_shuffle();
if (n == 2) {
if (m & 1) {
rotate(b[1].begin(), b[1].begin() + m - 1, b[1].end());
} else {
int i = 0, j = m - 1;
while (i < j) {
swap(b[1][i++ % m], b[1][j-- % m]);
}
}
} else {
if (n & 1) {
int i = 0, j = n - 1;
while (i < n - 1) {
swap(b[i++ % n][1], b[j++ % n][1]);
}
} else {
int i = 0, j = n - 1;
while (i < j) {
swap(b[i++ % n][1], b[j-- % n][1]);
}
}
}
} else if ((n == 3 && m >= 4) || (n >= 4 && m == 3)) {
cout << "YES\n";
my_shuffle();
if (n == 3) {
if (m & 1) {
rotate(b[1].begin(), b[1].begin() + m - 1, b[1].end());
} else {
int i = 0, j = m - 1;
while (i < j) {
swap(b[1][i++ % m], b[1][j-- % m]);
}
}
} else {
if (n & 1) {
int i = 0, j = n - 1;
while (i < n - 1) {
swap(b[i++ % n][1], b[j++ % n][1]);
}
} else {
int i = 0, j = n - 1;
while (i < j) {
swap(b[i++ % n][1], b[j-- % n][1]);
}
}
}
} else if (n == 3 && m == 3) {
cout << "YES\n"
<< "1 3 5\n"
<< "8 4 9\n"
<< "6 2 7";
exit(0);
} else if (n == 1 && m == 1) {
cout << "YES\n1";
exit(0);
} else {
cout << "NO";
exit(0);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << b[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool h[51], v[51];
int i, k, l, m, n, o, p, r;
int main() {
scanf("%d\n", &n);
for (int i = 0; i < n * n; i++) {
scanf("%d %d\n", &l, &r);
if (h[l] || v[r]) continue;
h[l] = v[r] = true;
printf("%d ", i + 1);
}
exit(0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long sum(long long a, long long b, long long mod) {
long long ans = a + b;
if (ans > mod) ans -= mod;
return ans;
}
long long mul(long long a, long long b, long long mod) { return (a * b) % mod; }
long long dif(long long a, long long b, long long mod) {
long long res = a - b;
if (res < 0) res += mod;
return res;
}
long long binpow(long long a, long long b, long long mod) {
if (b == 1) return a;
if (b % 2 == 0) {
long long bb = binpow(a, b / 2, mod);
return mul(bb, bb, mod);
}
if (b % 2 == 1) {
long long bb = binpow(a, b / 2, mod);
bb = mul(bb, bb, mod);
return mul(bb, a, mod);
}
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &V) {
for (int i = 0; i < (int)V.size(); ++i) {
if (i != 0) os << ' ';
os << V[i];
}
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &V) {
for (int i = 0; i < (int)V.size(); ++i) {
is >> V[i];
}
return is;
}
const long long maxn = 1000000;
const int bases[2] = {31, 29};
const int mods[2] = {1000000007, 1000000009};
long long pows[maxn][2];
int n;
long long hashes[maxn + 1][2];
long long inv(long long num, long long mod) {
return binpow(num, mod - 2, mod);
}
vector<long long> get_hash(int l, int r) {
vector<long long> ans(2);
for (int j = 0; j < 2; ++j) {
ans[j] = hashes[r][j];
if (l != 0) ans[j] = dif(ans[j], hashes[l - 1][j], mods[j]);
ans[j] = mul(ans[j], pows[n - l - 1][j], mods[j]);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string s, t;
cin >> s >> t;
int occ[2] = {0, 0};
n = t.length();
for (int i = 0; i < s.length(); ++i) occ[s[i] - '0']++;
pows[0][0] = pows[0][1] = 1;
for (int i = 1; i < n; ++i) {
for (int j = 0; j < 2; ++j) {
pows[i][j] = mul(pows[i - 1][j], bases[j], mods[j]);
}
}
hashes[0][0] = hashes[0][1] = t[0] - 'a';
for (int i = 1; i < n; ++i) {
for (int j = 0; j < 2; ++j) {
hashes[i][j] =
sum(hashes[i - 1][j], mul(pows[i][j], (long long)t[i] - 'a', mods[j]),
mods[j]);
}
}
int ans = 0;
if (occ[0] > occ[1]) {
for (int i = 1; i * occ[0] <= n; ++i) {
int jj = n - i * occ[0];
if (jj % occ[1] != 0) continue;
if (jj == 0) continue;
int len2 = jj / occ[1];
int len1 = i;
int zero_first = -1;
int one_first = -1;
bool ok = true;
int cur = 0;
for (int j = 0; j < s.length(); ++j) {
if (s[j] == '0') {
if (zero_first == -1) {
zero_first = cur;
} else if (get_hash(cur, cur + len1 - 1) !=
get_hash(zero_first, zero_first + len1 - 1)) {
ok = false;
}
cur += len1;
} else {
if (one_first == -1) {
one_first = cur;
} else if (get_hash(cur, cur + len2 - 1) !=
get_hash(one_first, one_first + len2 - 1)) {
ok = false;
}
cur += len2;
}
}
if (len1 == len2 && get_hash(zero_first, zero_first + len1 - 1) ==
get_hash(one_first, one_first + len2 - 1)) {
ok = false;
}
if (ok) ans++;
}
} else {
for (int i = 1; i * occ[1] <= n; ++i) {
int jj = n - i * occ[1];
if (jj % occ[0] != 0) continue;
if (jj == 0) continue;
int len1 = jj / occ[0];
int len2 = i;
int zero_first = -1;
int one_first = -1;
bool ok = true;
int cur = 0;
for (int j = 0; j < s.length(); ++j) {
if (s[j] == '0') {
if (zero_first == -1) {
zero_first = cur;
} else if (get_hash(cur, cur + len1 - 1) !=
get_hash(zero_first, zero_first + len1 - 1)) {
ok = false;
}
cur += len1;
} else {
if (one_first == -1) {
one_first = cur;
} else if (get_hash(cur, cur + len2 - 1) !=
get_hash(one_first, one_first + len2 - 1)) {
ok = false;
}
cur += len2;
}
}
if (len1 == len2 && get_hash(zero_first, zero_first + len1 - 1) ==
get_hash(one_first, one_first + len2 - 1)) {
ok = false;
}
if (ok) ans++;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, res;
int a[N], g[N];
vector<int> basis, origin;
void addBasis(int x) {
int saveX = x;
for (int y : basis) x = min(x, x ^ y);
if (x) {
basis.push_back(x);
origin.push_back(saveX);
}
}
inline void grayCode(int sz) {
for (int i = 0; i < (1 << sz); i++) g[i] = i ^ (i >> 1);
}
int checkBit(int pos, int x) { return (x >> pos) & 1; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int id = 0;
for (int i = 1; i <= 20; i++) {
while (id < n && a[id + 1] < (1 << i)) addBasis(a[++id]);
if (basis.size() == i) res = i;
}
cout << res << endl;
basis.clear();
origin.clear();
for (int i = 1; i <= n; i++)
if (a[i] < (1 << res)) addBasis(a[i]);
grayCode(res);
for (int i = 0; i < (1 << res); i++) {
int val = 0;
for (int j = 0; j < 20; j++)
if (checkBit(j, g[i])) val ^= origin[j];
cout << val << ' ';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int t, n;
vector<int> g[maxn];
int p[maxn], minx;
vector<int> ans;
void dfs(int x, int fx) {
p[x]++;
for (int i = 0; i < g[x].size(); i++) {
int v = g[x][i];
if (v == fx) continue;
dfs(v, x);
p[x] += p[v];
}
int tmp = 0;
for (int i = 0; i < g[x].size(); i++) {
int v = g[x][i];
tmp = max(tmp, p[v]);
}
tmp = max(tmp, n - p[x]);
if (minx == tmp) ans.push_back(x);
if (minx > tmp) {
minx = tmp;
ans.clear();
ans.push_back(x);
}
}
int main() {
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
p[i] = 0;
}
minx = n;
p[n] = 0;
dfs(1, 0);
if (ans.size() == 1) {
cout << ans[0] << " " << g[ans[0]][0] << endl;
cout << ans[0] << " " << g[ans[0]][0] << endl;
continue;
} else {
int x;
for (int i = 0; i < g[ans[0]].size(); i++) {
int f = g[ans[0]][i];
if (f != ans[1]) {
x = f;
break;
}
}
cout << ans[0] << " " << x << endl;
cout << x << " " << ans[1] << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5;
multiset<int> stuff[35];
long long sum[35];
int numara() {
long long total = 0, sol = 0;
for (int i = 1; i <= 32; ++i) {
total += sum[i - 1];
if (stuff[i].empty()) continue;
int val = *stuff[i].begin();
if (val > 2 * total && total > 0) ++sol;
}
return sol;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int Q, cate = 0;
cin >> Q;
while (Q--) {
char ch;
int nr;
cin >> ch >> nr;
int where = 0, cop = nr;
while (nr) {
++where;
nr >>= 1;
}
if (ch == '+')
stuff[where].insert(cop), sum[where] += cop, ++cate;
else
stuff[where].erase(stuff[where].find(cop)), sum[where] -= cop, --cate;
cout << max(cate - numara() - 1, 0) << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, a, b;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> a >> b;
if (a % b == 0) {
cout << 0 << endl;
} else
cout << b - a % b << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int dp[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[i] = 0;
}
vector<int> list;
for (int i = 0; i < n; i++) {
if (list.size() == 0) {
list.push_back(a[i]);
dp[i] = list.size();
} else {
if (list.back() < a[i]) {
list.push_back(a[i]);
dp[i] = list.size();
} else {
auto c = upper_bound(list.begin(), list.end(), a[i]);
*c = a[i];
dp[i] = list.size();
}
}
}
cout << dp[n - 1];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct dot {
int x, y;
dot() {}
dot(int a, int b) {
x = a;
y = b;
}
};
struct vt {
int x, y;
vt() {}
vt(dot a, dot b) {
x = b.x - a.x;
y = b.y - a.y;
}
};
int ps_scolar(vt a, vt b) { return a.x * b.y - a.y * b.x; }
int main() {
int n, d, x, y;
cin >> n >> d;
dot dot1 = dot(0, d);
dot dot2 = dot(d, 0);
dot dot3 = dot(n, n - d);
dot dot4 = dot(n - d, n);
vt vt1 = vt(dot1, dot2);
vt vt2 = vt(dot3, dot4);
vt vt3 = vt(dot2, dot3);
vt vt4 = vt(dot1, dot4);
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
dot tmp = dot(x, y);
vt vttmp1 = vt(dot1, tmp);
vt vttmp2 = vt(dot2, tmp);
vt vttmp3 = vt(dot3, tmp);
vt vttmp4 = vt(dot4, tmp);
if ((ps_scolar(vt1, vttmp1) * ps_scolar(vt2, vttmp3) >= 0) &&
(ps_scolar(vt3, vttmp2) * ps_scolar(vt4, vttmp1) <= 0)) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int n, ans, l, r;
int main() {
while (~scanf("%d", &n)) {
cin >> a >> b;
ans = 0;
for (int i = 0; i < n / 2; i++) {
l = i, r = n - i - 1;
if (a[l] == b[l] && a[r] == b[r] || a[l] == b[r] && a[r] == b[l] ||
a[l] == a[r] && b[l] == b[r])
continue;
if (a[l] == b[l] || a[r] == b[r] || a[l] == b[r] || a[r] == b[l] ||
b[l] == b[r])
ans++;
else
ans += 2;
}
if (n & 1)
if (a[n / 2] != b[n / 2]) ans++;
printf("%d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int lef[3105][3105];
int rig[3105][3105];
int down[3105][3105];
char data[3105][3105];
long long sum[2 * 3105][3105];
vector<pair<int, int> > g[3105];
void init() {
memset(lef, 0, sizeof lef);
memset(rig, 0, sizeof rig);
memset(down, 0, sizeof down);
memset(sum, 0, sizeof sum);
for (int i = 1; i <= m; i++) g[i].clear();
}
void pre() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (data[i][j] == 'z') {
if (data[i][j - 1] == 'z')
lef[i][j] = lef[i][j - 1] + 1;
else
lef[i][j] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = m; j >= 1; j--) {
if (data[i][j] == 'z') {
if (data[i][j + 1] == 'z')
rig[i][j] = rig[i][j + 1] + 1;
else
rig[i][j] = 1;
}
}
for (int j = 1; j <= m; j++) {
if (data[i][j] == 'z') g[j + rig[i][j] - 1].push_back(make_pair(i, j));
}
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
if (data[i][j] == 'z') {
if (data[i + 1][j - 1] == 'z') {
down[i][j] = down[i + 1][j - 1] + 1;
} else
down[i][j] = 1;
}
}
}
}
void add(int type, int y, int val) {
while (y <= 3000) {
sum[type][y] += val;
y += (y & -y);
}
}
long long getSum(int type, int x) {
long long tmp = 0;
while (x > 0) {
tmp += sum[type][x];
x -= (x & -x);
}
return tmp;
}
void debug() {
cout << "down:" << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", down[i][j]);
}
printf("\n");
}
for (int j = 1; j <= m; j++) {
for (int i = 0; i < g[j].size(); i++) {
printf("j:%d %d %d\n", j, g[j][i].first, g[j][i].second);
}
}
}
void solve() {
long long ans = 0;
for (int j = m; j >= 1; j--) {
for (int t = 0; t < g[j].size(); t++) {
pair<int, int> tmp = g[j][t];
int x = tmp.first;
int y = tmp.second;
add(x + y, y, 1);
}
for (int i = 1; i <= n; i++) {
int mi = min(lef[i][j], down[i][j]);
ans += (getSum(i + j, j) - getSum(i + j, j - mi));
}
}
printf("%I64d\n", ans);
}
int main() {
while (scanf("%d %d", &n, &m) == 2) {
init();
getchar();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%c", &data[i][j]);
}
getchar();
}
pre();
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int c[1000005];
pair<int, int> p[10005];
int ans[10005];
int prime[600001], cnt = 0;
bool flag[1000005];
void init() {
for (int i = 2; i <= 1000000; i++) {
if (!flag[i]) {
prime[cnt++] = i;
flag[i] = 1;
}
for (int j = 0; j < cnt && i * prime[j] <= 1000000; j++) {
flag[i * prime[j]] = 1;
if (i % prime[j] == 0) {
break;
}
}
}
}
int main() {
int n, k, i, j, m = 0;
cin >> n >> k;
for (i = 1; i <= n; i++) scanf("%d", &c[i]);
init();
int tmp = k;
for (i = 0; i < cnt; i++) {
if (tmp % prime[i] == 0) {
p[m].first = prime[i];
while (tmp % prime[i] == 0) {
p[m].second++;
tmp /= prime[i];
}
m++;
}
}
if (tmp != 1) {
p[m].first = tmp;
p[m++].second = 1;
}
for (i = 1; i <= n; i++) {
if (c[i] % k == 0) {
printf("Yes\n");
return 0;
}
for (j = 0; j < m; j++) {
int sum = 0;
if (c[i] % p[j].first == 0) {
while (c[i] % p[j].first == 0) {
sum++;
c[i] /= p[j].first;
}
}
ans[j] = max(ans[j], sum);
}
}
int fail = 0;
for (i = 0; i < m; i++) {
if (ans[i] < p[i].second) {
fail = 1;
break;
}
}
if (fail)
printf("No\n");
else
printf("Yes\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 100051;
struct Edge {
long long t;
long long w;
long long nxt;
Edge(long long t = 0, long long w = 0, long long nxt = 0)
: t(t), w(w), nxt(nxt) {}
} g[MAXN * 2];
long long n, q, gsz;
long long l;
long long fte[MAXN];
long long a[MAXN];
long long dep[MAXN], dep1[MAXN], f[MAXN];
long long fa[MAXN], sz[MAXN];
long long findroot(long long nw) {
if (fa[nw] == nw) return nw;
return fa[nw] = findroot(fa[nw]);
}
bool cmpf(long long u, long long v) { return f[u] < f[v]; }
void addedge(long long u, long long v, long long w) {
g[++gsz] = Edge(v, w, fte[u]);
fte[u] = gsz;
}
long long find(long long nw, long long fa = -1) {
long long ans = nw;
for (long long i = fte[nw]; i; i = g[i].nxt) {
long long nxtn = g[i].t;
if (nxtn == fa) continue;
dep[nxtn] = dep[nw] + g[i].w;
long long na = find(nxtn, nw);
if (dep[na] > dep[ans]) ans = na;
}
return ans;
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n - 1; i++) {
long long u, v;
long long w;
scanf("%lld%lld%lld", &u, &v, &w);
addedge(u, v, w);
addedge(v, u, w);
}
dep[1] = 0;
long long d1 = find(1);
dep[d1] = 0;
long long d2 = find(d1);
memcpy(dep1, dep, sizeof(dep));
dep[d2] = 0;
find(d2);
for (long long i = 1; i <= n; i++) {
f[i] = max(dep[i], dep1[i]);
a[i] = i;
}
sort(a + 1, a + n + 1, cmpf);
scanf("%lld", &q);
while (q--) {
scanf("%lld", &l);
long long ans = 0;
for (long long i = 1; i <= n; i++) {
fa[i] = i;
sz[i] = 1;
}
long long p = n;
for (long long i = n; i >= 1; i--) {
while (p > i && f[a[p]] > f[a[i]] + l) {
sz[findroot(a[p])]--;
fa[a[p]] = a[p];
p--;
}
for (long long j = fte[a[i]]; j; j = g[j].nxt) {
long long nxtn = g[j].t;
if (f[nxtn] < f[a[i]] || f[nxtn] > f[a[i]] + l) continue;
long long ra = findroot(a[i]), rn = findroot(nxtn);
if (ra == rn) continue;
sz[ra] += sz[rn];
fa[rn] = ra;
}
ans = max(ans, sz[findroot(a[i])]);
}
printf("%lld\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007ll;
int m, d;
long long dp[2][2005][2005];
long long solve(string s) {
if (s[0] == '0') return 0;
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2005; ++j)
for (int k = 0; k < 2005; ++k) dp[i][j][k] = 0;
for (int i = 0; i < s.size(); ++i) {
if (!i) {
for (int j = 1; j < s[i] - 48; ++j)
if (j != d) dp[0][i][j % m] += 1;
if (s[i] - 48 != d) dp[1][i][(s[i] - 48) % m] += 1;
} else {
if (i % 2 == 1) {
for (int j = 0; j < m; ++j) {
if (d == s[i] - 48)
(dp[1][i][(j * 10 + d) % m] += dp[1][i - 1][j]) %= MOD;
(dp[0][i][(j * 10 + d) % m] +=
dp[0][i - 1][j] + (d < s[i] - 48 ? dp[1][i - 1][j] : 0)) %= MOD;
}
} else {
for (int z = 0; z < 10; ++z) {
if (z == d) continue;
for (int j = 0; j < m; ++j) {
if (z == s[i] - 48)
(dp[1][i][(j * 10 + z) % m] += dp[1][i - 1][j]) %= MOD;
(dp[0][i][(j * 10 + z) % m] +=
dp[0][i - 1][j] + (z < s[i] - 48 ? dp[1][i - 1][j] : 0)) %= MOD;
}
}
}
}
}
return (dp[0][s.size() - 1][0] + dp[1][s.size() - 1][0]) % MOD;
}
int main() {
string a, b;
cin >> m >> d >> a >> b;
for (int i = a.size() - 1; i >= 0; --i) {
if (a[i] == '0')
a[i] = '9';
else {
--a[i];
break;
}
}
cout << ((solve(b) - solve(a)) % MOD + MOD) % MOD;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100500;
long long x, y;
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
void solve(long long a, long long b, char A, char B) {
if (a == 1 && b == 1) {
return;
}
if (a < b) {
swap(a, b);
swap(A, B);
}
cout << (a - 1) / b << A;
long long x, y;
x = a;
y = b;
a = x - (x - 1) / y * y;
b = y;
solve(a, b, A, B);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> x >> y;
if (gcd(x, y) != 1) {
cout << "Impossible";
return 0;
}
solve(x, y, 'A', 'B');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int sum = 0;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
sum += t;
}
sum = abs(sum);
int same_array = 0;
if (sum >= n) {
if (sum % n == 0) {
same_array = n;
} else {
same_array = n - 1;
}
} else {
if (sum == 0) {
same_array = n;
} else {
same_array = n - 1;
}
}
cout << same_array;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 3;
const int mod = 1e8 + 7;
const int inf = 1e9 + 1;
const double eps = 1e-15;
const int pw = 257;
int n, m;
bool u[N];
set<int> s;
vector<int> g[N];
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
u[1] = 1;
s.insert(1);
while (n--) {
int cur = (*s.begin());
cout << cur << ' ';
s.erase(cur);
for (auto to : g[cur]) {
if (!u[to]) {
u[to] = 1;
s.insert(to);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int n, m;
int f[N + 1];
vector<int> g[N + 1][2];
bool ans[N + 1][2];
bool used[N + 1][2];
vector<int> v;
void dfs(int u, int k) {
v.push_back(u);
used[u][k] = 1;
if (f[u] == 2 - k) {
for (int i = 0; i < v.size(); i++) ans[v[i]][k] = 1;
v.clear();
}
for (int i = 0; i < g[u][k].size(); i++)
if (!used[g[u][k][i]][k])
dfs(g[u][k][i], k);
else if (ans[g[u][k][i]][k]) {
for (int i = 0; i < v.size(); i++) ans[v[i]][k] = 1;
v.clear();
}
}
int main() {
scanf("%i%i", &n, &m);
for (int i = 1; i <= n; i++) scanf("%i", &f[i]);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%i%i", &a, &b);
if (f[b] != 1) {
g[a][0].push_back(b);
g[b][1].push_back(a);
}
}
for (int k = 0; k < 2; k++)
for (int i = 1; i <= n; i++)
if (f[i] == 1 + k) {
v.clear();
dfs(i, k);
}
for (int i = 1; i <= n; i++) printf("%i\n", (ans[i][0] && ans[i][1] ? 1 : 0));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int LINF = 0x3f3f3f3f3f3f3f3fll;
const int MAX = (int)105;
int n, m;
char flag[MAX][MAX];
set<char> st;
void monta() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> flag[i][j];
}
}
}
bool tenta_n() {
char comp;
for (int i = 0; i < 3; i++) {
comp = flag[i * n / 3][0];
st.insert(comp);
for (int j = 0; j < n / 3; j++) {
for (int k = 0; k < m; k++) {
if (flag[i * n / 3 + j][k] != comp) {
return false;
}
}
}
}
return st.size() == 3;
}
bool tenta_m() {
char comp;
for (int i = 0; i < 3; i++) {
comp = flag[0][i * m / 3];
st.insert(comp);
for (int j = 0; j < m / 3; j++) {
for (int k = 0; k < n; k++) {
if (flag[k][i * m / 3 + j] != comp) {
return false;
}
}
}
}
return st.size() == 3;
}
void vai() {
st.clear();
if (n % 3 == 0) {
if (tenta_n()) {
cout << "YES" << endl;
return;
}
}
st.clear();
if (m % 3 == 0) {
if (tenta_m()) {
cout << "YES" << endl;
return;
}
}
cout << "NO" << endl;
}
int main() {
ios::sync_with_stdio(false);
monta();
vai();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e18;
const long long mod = (long long)1e9 + 7;
const double eps = (double)1e-9;
const double pi = acos(-1.0);
const int dx[] = {0, 0, 1, 0, -1};
const int dy[] = {0, 1, 0, -1, 0};
const int N = 100500;
long long p;
int k;
bool b;
vector<int> ans;
int main() {
cin >> p >> k;
while (p) {
if (!b) {
ans.push_back(p % k);
p /= k;
} else {
int cur((k - p % k) % k);
ans.push_back(cur);
p += cur;
p /= k;
}
b ^= 1;
}
cout << (int)ans.size() << endl;
for (auto i : ans) cout << i << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Mat {
double mat[133][133];
int row, col;
};
Mat Mul(Mat a, Mat b) {
Mat ans;
ans.row = a.row;
ans.col = b.col;
memset(ans.mat, 0, sizeof(ans.mat));
for (int i = 0; i < ans.row; i++)
for (int k = 0; k < a.col; k++)
for (int j = 0; j < ans.col; j++)
ans.mat[i][j] += a.mat[i][k] * b.mat[k][j];
return ans;
}
Mat Pow(Mat a, int k) {
Mat ans;
ans.row = a.row;
ans.col = a.col;
for (int i = 0; i < a.row; i++)
for (int j = 0; j < a.col; j++) ans.mat[i][j] = (i == j);
while (k) {
if (k & 1) ans = Mul(ans, a);
a = Mul(a, a);
k >>= 1;
}
return ans;
}
Mat A;
int n, x;
double P[133];
int main() {
while (~scanf("%d%d", &n, &x)) {
for (int i = 0; i <= x; i++) scanf("%lf", &P[i]);
A.row = A.col = 128;
for (int i = 0; i < 128; i++)
for (int j = 0; j <= x; j++) A.mat[i ^ j][i] = P[j];
A = Pow(A, n);
printf("%.10f\n", 1.0 - A.mat[0][0]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long int n, m, v, i, j, ind;
cin >> n >> m >> v;
if (m < n - 1 || m > (((n - 2) * (n - 1)) / 2) + 1)
cout << -1 << endl;
else {
if (v != n) {
i = 1;
vector<long long int> arr;
while (m > 0 && i < n - 1) {
if (i == v - 1 && v + 1 != n) {
cout << i << " " << v + 1 << endl;
arr.push_back(i);
ind = v + 1;
i++;
m--;
} else if ((i == v - 1 && v + 1 == n) || i == v) {
i++;
continue;
} else {
cout << i << " " << i + 1 << endl;
arr.push_back(i);
m--;
ind = i + 1;
i++;
}
}
arr.push_back(ind), arr.push_back(v);
if (m >= 2)
cout << ind << " " << v << endl << v << " " << n << endl, m -= 2;
i = 0;
while (m > 0 && i < arr.size() - 2) {
j = i + 2;
while (m > 0 && j < arr.size()) {
cout << arr[i] << " " << arr[j] << endl;
m--;
j++;
}
i++;
}
} else {
i = 2;
vector<long long int> arr;
arr.push_back(v);
while (m > 0 && i < n - 1) {
cout << i << " " << i + 1 << endl;
arr.push_back(i);
m--;
ind = i + 1;
i++;
}
arr.push_back(ind);
if (m >= 2)
cout << 1 << " " << v << endl << v << " " << 2 << endl, m -= 2;
i = 0;
while (m > 0 && i < arr.size() - 2) {
j = i + 2;
while (m > 0 && j < arr.size()) {
cout << arr[i] << " " << arr[j] << endl;
m--;
j++;
}
i++;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
const int N = 4e5 + 9;
const int P = 998244353;
const int g = 3;
inline int add(int a, int b) { int r = a + b; return r < P ? r : r - P; }
inline int sub(int a, int b) { int r = a - b; return r < 0 ? r + P : r; }
inline int mul(ll a, ll b) { ll r = a * b; return r % P; }
inline int inv(int a) { return a == 1 ? a : mul(inv(P % a), P - P / a); }
inline int qpm(int a, int b) {
int r = 1;
do if (b & 1) r = mul(r, a);
while (a = mul(a, a), b >>= 1);
return r;
}
ll invs[N], f[N], fi[N];
ll binom(ll n, ll k) { if (n < k || k < 0) return 0; return mul(f[n], mul(fi[n - k], fi[k])); }
void ginv() {
invs[1] = 1; f[0] = fi[0] = 1;
for (int i = 2; i != N; ++i) invs[i] = mul(invs[P % i], (P - P / i));
for (int i = 1; i != N; ++i) f[i] = mul(f[i - 1], i);
for (int i = 1; i != N; ++i) fi[i] = mul(fi[i - 1], invs[i]);
}
const int W = 19, S = 1 << W;
int w[S + 1], rev[S << 1], *r[W + 1];
void init() {
for (int s = 0; s <= W&&(r[s]=rev+(1<<s),1); ++s)
for (int i = 0; i != (1 << s); ++i)
r[s][i] = (r[s][i >> 1] >> 1) | ((i & 1) << (s - 1));
w[0] = 1; w[1] = qpm(g, (P - 1) / S);
for (int i = 2; i <= S; ++i) w[i] = mul(w[i - 1], w[1]);
}
int m, s, im;
int init(int n) {
for (s = 0, m = 1; m < n; m <<= 1, ++s);
im = inv(m); return m;
}
void ntt(int* p, int t) {
for (int i = 0; i != m; ++i) if (i < r[s][i]) swap(p[i], p[r[s][i]]);
for (int i = 1, z = 0; i != m; i <<= 1, z++)
for (int j = 0; j != m; j += (i << 1))
for (int k = 0, u, v; k != i; k++)
u = p[j+k], v = mul(w[(t?(i<<1)-k:k)<<W-z-1], p[i+j+k]),
p[j + k] = add(u, v), p[i + j + k] = sub(u, v);
if (t) for (int i = 0; i != m; ++i) p[i] = mul(p[i], im);
}
int px[N], py[N];
vi mul(const vi& p1, const vi& p2, int n = 0) {
int n1 = p1.size(), n2 = p2.size(), n3 = n1 + n2 - 1;
init(n3);
copy_n(p1.begin(), n1, px); fill(px + n1, px + m, 0);
copy_n(p2.begin(), n2, py); fill(py + n2, py + m, 0);
ntt(px, 0); ntt(py, 0);
for (int i = 0; i != m; ++i) px[i] = mul(px[i], py[i]);
ntt(px, 1); vi p3(n3); copy_n(px, n3, p3.begin());
if (n && n3 > n) p3.resize(n); return p3;
}
int n;
int a[N], b[N];
vector<int> vc[N];
int main()
{
//freopen("C:/Users/MACHENIKE/Desktop/data.in","r",stdin);
ginv(); init();
scanf ("%d", &n);
for (int i = 1; i <= n; i++) scanf ("%d %d", a + i, b + i);
vc[0].push_back (1);
int u = 0;
for (int i = 1; i <= n; i++)
{
vc[i].resize(2 * u + a[i] - b[i] + 1);
for (int j = -u; j <= u + a[i] - b[i]; j++) vc[i][j + u] = binom (a[i] + b[i], b[i] + j);
vector<int> temp = mul (vc[i - 1], vc[i]);
int v = u + a[i] - b[i];
vc[i].resize (v + 1);
for (int j = 0; j <= v; j++) vc[i][j] = temp[j + u];
u = v;
}
int ans = 0;
for (auto it : vc[n]) ans = add (it, ans);
printf ("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[2], b[2], s;
int main() {
cin >> a[0];
cin >> a[1];
cin >> b[0];
cin >> b[1];
s = ((a[0] + 1) * 2) + ((a[1] + 1) * 2) + ((b[0] + 1) * 2) +
((b[1] + 1) * 2) - ((b[0] * 2) + 4);
cout << s;
}
| 0 |
#include <bits/stdc++.h>
struct event {
long long time;
int type;
int idx;
bool operator<(const event& other) const {
if (time == other.time)
if (type == other.type)
return idx > other.idx;
else
return type > other.type;
return time > other.time;
}
};
int N;
long long P;
long long ans[100005];
std::priority_queue<event> queue;
int AIB[100005];
void update(int pos, int val) {
for (int i = pos; i <= N; i += (i & (-i))) AIB[i] += val;
}
int query(int pos) {
int sum = 0;
for (int i = pos; i > 0; i -= (i & (-i))) sum += AIB[i];
return sum;
}
std::set<int> waiting;
long long timeQueueIsFree;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin >> N >> P;
long long x;
for (int i = 1; i <= N; ++i) std::cin >> x, queue.push({x, 2, i});
while (!queue.empty()) {
auto top = queue.top();
queue.pop();
if (top.type == 2) {
if (query(top.idx) == 0) {
update(top.idx, 1);
timeQueueIsFree = std::max(timeQueueIsFree + P, top.time + P);
queue.push({timeQueueIsFree, 1, top.idx});
} else {
waiting.insert(top.idx);
}
} else {
ans[top.idx] = top.time;
update(top.idx, -1);
auto it = waiting.begin();
while (it != waiting.end()) {
if (query(*it) == 0) {
queue.push({top.time, 2, *it});
it = waiting.erase(it);
break;
} else
break;
}
}
}
for (int i = 1; i <= N; ++i) std::cout << ans[i] << ' ';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int c, x, y, z, m, k, l, r, i, n, t;
cin >> t;
while (t--) {
cin >> n >> m;
long long int a[n + 5], k = 0;
long long int b[n + 5];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > m) {
b[k++] = 2;
} else {
if (m % a[i] == 0) {
b[k++] = m / a[i];
} else {
b[k++] = (m / a[i]) + 1;
}
}
}
sort(b, b + k);
cout << b[0] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool map[5][5];
int num[5][5];
memset(map, 1, sizeof(map));
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) {
cin >> num[i][j];
if (num[i][j] % 2 == 1) {
map[i][j] = !map[i][j];
map[i - 1][j] = !map[i - 1][j];
map[i + 1][j] = !map[i + 1][j];
map[i][j - 1] = !map[i][j - 1];
map[i][j + 1] = !map[i][j + 1];
}
}
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) cout << map[i][j];
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O1")
#pragma GCC optimize("O2")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
void input() { return; }
template <typename T1, typename... T2>
void input(T1& x, T2&... args) {
((cin >> x), input(args...));
}
void wrt() {
cout << "\n";
return;
}
template <typename T1, typename... T2>
void wrt(T1 x, T2... args) {
((cout << x << ' '), wrt(args...));
}
template <typename T>
void inputlst(T& lst, int x, int y) {
for (int i = x; i < y; i++) cin >> lst[i];
}
template <typename T>
void printlst(T& lst, int x, int y) {
for (int i = x; i < y; i++) cout << lst[i] << ' ';
wrt();
}
const long long inf = INT64_MAX, MOD = 1e9 + 7;
long long solution(vector<long long>& A, long long k) {
const long long N = A.size();
if (N < k || N < 1 || k < 1) return 0;
if (N == k) return 1;
vector<long long> v1(N, 0);
vector<long long> v2(N, 0);
vector<long long> v3(N, 0);
v2[N - 1] = 1;
v3[A[N - 1] - 1] = 1;
for (long long i = N - 2; i >= 0; i--) {
v2[i] = v2[i + 1];
if (v3[A[i] - 1] == 0) {
v2[i]++;
v3[A[i] - 1] = 1;
}
}
for (long long j = 1; j < k; j++) {
fill(v3.begin(), v3.end(), 0);
v1[N - 1] = 0;
for (long long i = N - 2; i >= 0; i--) {
v1[i] = v1[i + 1];
v1[i] = v1[i] + v2[i + 1];
v1[i] = v1[i] - v3[A[i] - 1];
v3[A[i] - 1] = v2[i + 1];
}
v2 = v1;
}
return v2[0];
}
long long solve(long long a[], long long n, long long k) {
vector<long long> v;
v.assign(a, a + n);
return solution(v, k);
}
int32_t main() {
long long n, k, cast = 0, pk = 1;
string str1;
input(n, k, str1);
long long a[n];
set<char> myset;
map<char, long long> mymap;
for (long long i = 0; i < (long long)str1.size(); ++i) {
long long il = myset.size();
myset.insert(str1[i]);
if (myset.size() != il) mymap[str1[i]] = pk++;
}
for (long long i = 0; i < (long long)str1.size(); ++i) a[i] = mymap[str1[i]];
for (long long i = n; i >= 1; --i) {
long long temp = solve(a, n, i);
if (k >= temp) {
k -= temp;
cast += temp * (n - i);
} else {
cast += k * (n - i);
k = 0;
break;
}
}
if (k > 1)
wrt(-1);
else
wrt(cast + ((k == 1) * n));
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65777216")
using namespace std;
int n;
int a[111111];
vector<int> v[111111];
int s;
pair<long long, long long> go(int ver, int par = -1) {
vector<pair<long long, long long> > vv;
for (int i(0); i < (v[ver].size()); i++)
if (v[ver][i] != par) vv.push_back(go(v[ver][i], ver));
if (vv.size() == 0) return pair<long long, long long>(0, a[ver]);
sort((vv).begin(), (vv).end());
reverse(vv.begin(), vv.end());
long long total = 0;
for (int i(0); i < (vv.size()); i++)
if (a[ver] >= 1) {
a[ver]--;
total += 1 + 1 + vv[i].first;
}
for (int i(0); i < (vv.size()); i++) {
int z = min((int)vv[i].second, a[ver]);
total += 2 * z;
a[ver] -= z;
}
return pair<long long, long long>(total, a[ver]);
}
int main() {
cin >> n;
for (int i(0); i < (n); i++) scanf("%d", a + i);
for (int i(0); i < (n - 1); i++) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
v[x].push_back(y);
v[y].push_back(x);
}
cin >> s;
s--;
for (int i(0); i < (n); i++)
if (i != s) a[i]--;
cout << go(s).first << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6, inf = 1e9;
int mn(int a, int b, int c, int d) {
if (a <= b && a <= c && a <= d) return 1;
if (b <= a && b <= c && b <= d) return 2;
if (c <= b && c <= a && c <= d) return 3;
if (d <= a && d <= b && d <= c) return 4;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
string s;
cin >> n >> s;
int a = 0, t = 0, g = 0, c = 0;
vector<int> v;
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
a++;
else if (s[i] == 'T')
t++;
else if (s[i] == 'G')
g++;
else if (s[i] == 'C')
c++;
else
v.push_back(i);
}
for (int i = 0; i < v.size(); i++) {
int id = mn(a, t, g, c);
if (id == 1) a++, s[v[i]] = 'A';
if (id == 2) t++, s[v[i]] = 'T';
if (id == 3) g++, s[v[i]] = 'G';
if (id == 4) c++, s[v[i]] = 'C';
}
if (min({a, t, g, c}) != max({a, t, g, c}))
cout << "===\n";
else
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 5;
const int M = 1e6;
const long long INF = (long long)(1e18);
const int inf = 2e9;
const long long MOD = 1000000007LL;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = (int)s.size();
cout << "4\n";
cout << "L " << n - 1 << '\n';
n += n - 2;
cout << "R " << n - 1 << '\n';
n++;
cout << "L " << n - 1 << '\n';
cout << "L 2\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
long long int n, m, x, y;
scanf("%I64d\n%I64d", &n, &m);
if (n > 64) {
printf("%I64d\n", m);
} else {
x = pow(2, n);
if (x > m) {
printf("%I64d\n", m);
} else {
y = m % x;
printf("%I64d\n", y);
}
}
return 0;
}
| 0 |
// warm heart, wagging tail,and a smile just for you!
// _ _ _ __ __ __ __ _ _ __ _ _ __ _ __ ____ _ _ _ _ _ _ _ _
// ||__|| || ||\\//|| //__\\ ||\\ || ||__ ||__|| || ||
// || || || || || // \\ || \\|| ___|| || || \\__//
// _ ___ _ _ _ _ _ __ _ _ __ _ __ _ __ _ _ __ ___ __ _ _ _ _ ___ _ _ ___
// ||__ ||__|| //__\\ ||\\ || ||// ||__|| || ]] ||__|| //__\\ ||__))
// ____|| || || // \\ || \\|| ||\\ || || ||__]] || || // \\ || \\
// ¦¦¦¦¦¦¦¦¦¦¦
// ¦¦¦++++++++++¦¦¦
// ¦¦¦+++++¦¦¦¦++++++¦¦¦
// ¦¦¦¦¦¦¦¦¦¦¦ ¦¦+++++¦¦¦¦++¦¦¦¦+++++¦¦
// ¦¦¦¦¦¦¦¦¦+++++¦¦¦¦¦¦¦¦¦¦¦¦+++++¦¦++++++¦¦¦+++++¦¦
// ¦¦¦¦¦¦¦¦++++++++++++++++++++++¦¦¦¦¦¦¦¦¦++++++¦¦+++++++¦¦
// ¦¦¦¦+¦¦+++++++++++++++++++++++++++++¦¦¦¦¦¦¦¦¦+++++++++++¦¦
// ¦¦¦+++¦++++++++++++++++++++++++++++++++++++¦¦++¦¦¦+++++++¦¦¦¦¦
// ¦¦¦+++++++++++++++++++++++++++++++++++++++++++¦¦+++¦¦¦¦¦¦¦¦+++++¦¦
// ¦¦¦++++++++++++++++++++++++++++++++++++++++++++++++++++¦¦¦+++++++++¦¦¦
// ¦¦¦++++++++++++++++++++++++++++++++++++++++++++++++++++++++¦¦¦¦¦+++++++¦¦
// ¦¦¦¦++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++¦¦¦¦+++++¦¦¦¦
// ¦¦¦¦¦¦¦¦¦¦¦¦¦++++++++¦¦+++++¦¦¦¦+++++++++++++++++¦¦¦¦¦+++++++++++++++++++++++++++¦¦¦++++¦¦¦¦¦¦
// ¦¦¦¦+++++++++++++++++++¦¦++¦¦¦¦¦¦+++++++++++++++++++++¦¦¦¦¦¦+++++++¦¦¦¦¦¦¦¦¦¦¦++++++++¦¦+++¦¦+++¦¦
// ¦¦¦++++++++++++++++++++¦¦+++++++++++++++++¦¦+++++++++++++++++++++¦¦¦¦+++++++++++¦+++++++¦¦++++++++¦¦
// ¦¦+++++++++++++++++++++¦¦++++¦¦¦¦¦¦+++¦¦¦¦++¦¦¦¦+++++++¦¦¦¦¦¦¦¦¦¦+++++++++++++++++++++++¦¦+++++++¦¦¦
// ¦¦+++++++++++++++++++++¦¦¦¦¦¦¦¦¦¦¦¦¦+++++++++++++++++++¦¦¦¦¦¦¦¦¦++++++++++++++++++++++++¦¦++++¦¦¦¦¦
// ¦¦¦++++++++++++++++++¦¦¦+++++¦¦++++++++++++++++++++++++++++¦¦¦¦¦++++++++++++++++++++++++¦¦¦¦¦¦¦¦
// ¦¦¦+++++++++++++¦¦¦¦¦++++++++¦¦++++++++++++++++++++++++¦¦¦++¦¦+++++++++++++++++++++++¦¦
// ¦¦¦¦¦¦¦¦¦¦¦¦¦¦ ¦¦¦¦++++++¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦+++++¦¦+++++++++++++++++++¦¦¦¦
// ¦¦¦¦¦¦¦ ¦¦¦¦¦ ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦
//
//#include<boost/multiprecision/cpp_int.hpp>
#include <bits/stdc++.h>
const long double pi = 3.1415926535897932384626433832795;
#define scn(n) scanf("%d",&n)
#define lscn(n) scanf("%lld ",&n)
#define scn2(n1,n2) scanf("%d%d",&n1,&n2)
#define lscn2(n1,n2) scanf("%lld%lld",&n1,&n2)
#define lpri(n) printf("%lld ",n)
#define lpri2(n1,n2) printf("%lld %lld\n",n1,n2)
#define pri(n) printf("%d ",n)
#define pri2(n1,n2) printf("%d %d\n",n1,n2)
#define pln() printf("\n")
#define priln(n) printf("%d\n",n)
#define lpriln(n) printf("%lld\n",n)
#define RAL(i,x,n) for(int i=x;i<n;i++)
#define RALR(i,x,n) for(int i=x-1;i>=n;i--)
//insert function in vector is used to insert a value at given index
//ex: v.insert(v.begin(),10); inserts 10 at 0th position in vector
//vector.resize(3) is used to resize the size of given array
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define mp make_pair
#define F first
#define S second
#define sq(a) (a)*(a)
#include<unordered_set>
#define lli long long int
#define toh_shuru_karte_hai_bina_kise_bakchodi_ke ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr)
#define test lli t;cin>>t;while(t--)
#define arrin lli n;cin>>n;lli a[n];for(lli i=0;i<n;i++)cin>>a[i] // a%b=a-b*floor(a/b);
#define floop for(lli i=0;i<n;i++)
#define mod 1000000007
#define defvec vector<lli>v
#define ub upper_bound
#define pb push_back
#define pob pop_back
#define mp make_pair
#define emp emplace_back
#define bs binary_search
#define pi 3.1415926536
#define INF ll(8230219982008199610)
#define MINF ll(-8230219982008199610)
#define ones(n) __builtin_popcountll(n)
#define focc(n) __builtin_ffsll(n) //to count index of first 1 from right in binary representation of a number starting from index 1
#define leadingzero(n) __builtin_clzll(n)
#define trailingzeroes(n) __builtin_ctzll(n)
#define loop0(i,n) for(int i=0; i<n; i++)
#define loop1(i,n) for(int i=1; i<=n; i++)
#define rev0(i,n) for(int i=n-1; i>=0; i--)
#define rev1(i,n) for(int i=n; i>0; i--)
#define code lli n,k;cin>>n>>k;lli a[n];loop0(i,n) cin>>a[i]
#define loopj(j,k,n) for(lli j=k;j<n;j++)
#define all(x) x.begin(), x.end()
#define print(v) for(auto x:v)cout<<x<<" "
#define prints for(lli i=0;s[i];i++)cout<<s[i]
//using namespace boost::multiprecision ;
//typedef long long ll;
//typedef vector<lli> vi;
//typedef pair<lli,lli> pi;
using namespace std;
//atoll(s.c_str()) to convert string s into long long int
//all_of(a,a+n,ispositive()); //to check all the elements in array are positive
//any_of(a,a+n,ispositive()); //to check any element in array is positive
//none_of(a,a+n,ispositive()); //to check none of the elements in array is positive
//copy_n(a,n,b); //to copy all the elements from a to b
//iota(a,a+n,10); //this will print consequtive n terms starting from 10 //ex if n=5 than 10,11,12,13,14
//same can be used for character array
//a number is divisible by 8 if last three digits of it is divisible by 8
//ex. 1512 as 512 is divisible by 8 so 1512 is also divisible by 8
/* NUMBER OF WAYS TO PLACE TWO QUEENS ON A BOARD OF SIZE n*n SUCH THAT THEY DO NOT ATTACK ON EACH OTHER
count=(pow(n,4)/2)-(5*(pow(n,3)/3)+(3*pow(n,2)/2)-n/3;
*/
/* bitset<10>s;
s[0]=1;
s[3]=1;
s[5]=1;
s[7]=1;
cout<<s;
output is 1001010100
cout<<s.count();
output is frequency of 1 so 4
*/
// a number is power of 4 if num>0 && log2(num)/2==(int)log2(num)/2
#define INT_BITS 16
//if(abs(a-b)<1e-9) //TO COMPARE FLOATING POINT INTEGER
//{
// a and b are equal
//}
//string s=R"(HIMANS&\nSHAN\t)"; we can print a whole string same as given by doing this
//vector<int>v={1,2,3,4};
//vector<int>w=move(v);
//after this v={};
//w={1,2,3,4};
// to reverse a string reverse(str.begin(), str.end());
// OR
// string rev = string(str.rbegin(),str.rend());
//q.front() operation works in queue but not works in priority_queue
//so for priority_queue q.top() is used
// ~x=-(x+1) ex: ~29=-30;
unsigned lli leftRotate(unsigned lli n, unsigned lli d)
{
return (n << d)|(n >> (INT_BITS - d));
}
unsigned lli rightRotate(unsigned lli n,unsigned lli d)
{
return (n >> d)|(n << (INT_BITS - d));
}
//TO SET Kth BIT AS ONE n|(1<<k) while n&(~(1<<k)) sets the kth bit of n to 0
//and n^(1<<k) inverts the kth bit of n
//The number of digits of an integer x in base b can be calculated using the formula
//[logb(x) + 1]. For example, [log3(17) + 1] = 3.
//Every composite number has at least one prime factor less than or equal to square root of itself
int log2(int x)
{
int res=0;
while(x>>=1)
res++;
return res;
}
lli comb(lli n,lli r)
{
if(r==0||r==n)
//VALUE OF nCr
return 1;
return
comb(n-1,r)+comb(n-1,r-1);
}
bool isPowerOfTwo(int n)
{
if(n==0)
return false;
return (ceil(log2(n)) == floor(log2(n)));
}
lli inverse(lli a,lli m)
{
return 1<a?m-inverse(m%a,a)*(m/a):1; //for fastly calculate inverse modulo
}
lli issorted(lli arr[], lli n)
{
if (n == 1 || n == 0)
return 1;
if(arr[n - 1] < arr[n - 2])
return 0;
return issorted(arr, n - 1);
}
int computeXOR(int n)
{
if(n%4==0)
return n; //TO CALCULATE XOR FROM 1 TO N
if(n%4==1)
return 1;
if(n%4==2)
return n+1;
else
return 0;
}
lli count(string s)//count distinct element in string
{
lli ans=1,i,j;
for(i=1;i<s.length();i++)
{
for(j=0;j<i;j++)
{
if(s[i]==s[j])
break;
}
if(i==j)
ans++;
}
return ans;
}
bool isPerfectSquare(long double x)
{
// Find floating point value of
// square root of x.
long double sr = sqrt(x);
// If square root is an integer
return ((sr - floor(sr)) == 0);
}
lli countarray(lli a[],lli n)//count distinct element in array
{
unordered_set<lli>s;
for(lli i=0;i<n;i++)
s.insert(a[i]);
return s.size();
}
bool check (int N) //to check whether ith bit of n is 1 or 0
{ lli i;
if( N & (1 << i) )
return true;
else
return false;
}
bool isvowel(char ch)
{
string s = "aeiouAEIOU";
for (char c : s)
{
if (c == ch)
{
return true;
}
}
return false;
}
bool isPrime(lli n)
{
if(n<=1) return false;
if(n<=3) return true;
if(n%2==0||n%3==0) return false;
for(lli i=5; i*i<=n; i=i+6)
if (n%i == 0 || n%(i+2) == 0)
return false;
return true;
}
struct interval
{
int start,end;
};
//SORTING IN A SPECIAL ORDER
bool compare(interval x,interval y)
{
return (x.start<y.start);
}
bool isSubstring(string s1, string s2)
{
int M = s1.length();
int N = s2.length();
/* A loop to slide pat[] one by one */
for (int i = 0; i <= N - M; i++) {
int j;
/* For current index i, check for
pattern match */
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j])
break;
if (j == M)
return true;
}
return false;
}
int count_primes_in_range(int n) //to count number of primes from 1 to n
{
bool isprime[n+1];
for(int i=2;i<=n;i++)
isprime[i]=true;
isprime[0]=false;
isprime[1]=false;
for(int i=2;i<=sqrt(n);i++)
{
if(isprime[i]==true)
{
for(int j=i*i;j<=n;j+=i)
{
isprime[j]=false;
}
}
}
int count=0;
for(int i=0;i<=n;i++)
{
if(isprime[i]==true)
count++;
}
return count;
}
void multiply(int a[2][2],int m[2][2])
{ //
int him[2][2];
// MATRIX EXPONENTIATION
for(int i=0;i<2;i++)
//
{
//
for(int j=0;j<2;j++)
{ him[i][j]=0;
for(int k=0;k<2;k++)
{
him[i][j]+=(a[i][k]*m[k][j]);
}
}
}
for(int i=0;i<2;i++)
{
for(int j=0;j<2;j++)
{
a[i][j]=him[i][j];
}
}
}
void power(int a[2][2],int n)
{ if(n==0||n==1)
return;
power(a,n/2);
multiply(a,a);
if(n%2!=0)
{
int m[2][2]={{1,1},{1,0}};
multiply(a,m);
}
}
int fib(int n)
{
int a[2][2]={{1,1},{1,0}};
if(n==0)
return 0;
power(a,n-1);
return a[0][0];
}
lli power_(lli a,lli n)
{
lli res = 1;
while (n > 0)
{
if (n& 1)
res = ((res)*(a));
n/=2;
a=((a)*(a));
}
return res;
}
int factmod(int n, int p) {
vector<int> f(p);
f[0] = 1;
for (int i = 1; i < p; i++)
f[i] = f[i-1] * i % p;
int res = 1;
while (n > 1) {
if ((n/p) % 2)
res = p - res;
res = res * f[n%p] % p;
n /= p;
}
return res;
}
lli modularexponentiation(lli a,lli n,lli mo)
{
lli res = 1;
while (n > 0)
{
if (n& 1)
res = ((res%mo)*(a%mo))%mo;
n/=2;
a=((a%mo)*(a%mo))%mo;
}
return res;
}
lli largest_power(lli N)
{ //LARGEST POWER OF 2 JUST LESS THAN OR EQUAL TO A GIVEN 16 BIT NUMBER
//changing all right side bits to 1.
N = N| (N>>1);
N = N| (N>>2);
N = N| (N>>4);
N = N| (N>>8);
N = N| (N>>16);
//as now the number is 2 * x-1, where x is required answer, so adding 1 and dividing it by
return (N+1)>>1;
}
bool alternate(lli n)
{
lli i;
if((n^(n>>1))==(pow(2,i)-1)) //this is to check that in binary representation of n, n has alternate sequence or not
return true; //ex.101010 if n^(n>>1) is like this 11111 or containing only set bits than yes otherwise no
return false;
}
lli countDivisors(lli n)
{
lli cnt = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
// If divisors are equal,
// count only one
if (n / i == i)
cnt++;
else // Otherwise count both
cnt = cnt + 2;
}
}
return cnt;
}
int highestpowerof2(int n) //highest power of 2 which divides a given number
{
return (n&(~(n-1)));
}
/*lli dectobin(lli n)
{ //DECIMAL TO BINARY FOR A 32 BIT INTEGER
for (int i = 31; i >= 0; i--) {
if (n&(1<<i)) cout << "1";
else cout << "0";
}
}*/
/*lli maxfrequency(lli v[],lli n)
{ lli n;
cin >> n;
lli a[n];
vector<lli> cnt(n + 1);
for (int i = 0; i < n; ++i) {
cin>>a[i];
++cnt[a[i]];
}
lli mx = *max_element(cnt.begin(), cnt.end());
lli diff = n + 1 - count(cnt.begin(), cnt.end(), 0);//COUNT OF DIFFERENT ELEMENTS PRESENT IN ARRAY
return mx;
}*/
void lowertoupper(char ch)
{
ch=ch&'_';
cout<<ch<<" ";
}
void uppertolower(char ch)
{
ch=ch|' ';
cout<<ch<<" ";
}
lli primecounter(lli l,lli r)
{ //this counts prime in range l to r both inclusive
lli fact=1,count=0;
for(lli i=l;i<=r;i++)
{
if(((fact-i)%((1LL<<i)-1))==0)
count++;
fact*=((1LL<<i)-1);
}
return count;
}
lli counteprime(lli l,lli r)
{
lli count=0,i,j;
for(i=l;i<=r;i++) //THIS WILL ALSO GIVE COUNT OF PRIMES IN RANGE L TO R
{
for(j=2;j<=(i/j);j++)
{
if(!(i%j))
break;
}
if(j>(i/j))
count++;
}
return count;
}
void pairsort(int a[], char b[], int n) //SORT AN ARRAY ACCORDING TO SECOND ARRAY
{
pair<int, char> pairt[n];
// Storing the respective array
// elements in pairs.
for (int i = 0; i < n; i++)
{
pairt[i].first = a[i];
pairt[i].second = b[i];
}
// Sorting the pair array.
sort(pairt, pairt + n);
// Modifying original arrays
for (int i = 0; i < n; i++)
{
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
lli fibo(lli n)
{
long double him=(1+sqrt(5))/2;
return round(pow(him,n)/sqrt(5));
}
lli binToDec(string c)
{
lli count=0;
for(lli i=0;i<c.length();i++)
{
if (c[i] == '1'){
lli val = 1;
for(lli j=0;j<i;j++)
{
val *= 2;
}
count += val;
}
}
return count;
}
void rev(int a[],int n)
{
for(lli i=0,j=n-1;i<j;i++,j--)
{
swap(a[i],a[j]);
}
loop0(i,n)
cout<<a[i]<<" ";
}
/*void concatenate(int arr1[], int arr2[], int m, int n)
{
memcpy(arr1 + m, arr2, sizeof(arr2)); //TO CONCATENATE TWO ARRAYS
} */
vector<lli> Eratosthenes(int n)
{
vector<lli> res;
vector<bool> Prime(n + 1, true);
Prime[0] = Prime[1] = false;
for(int i=4;i<=n;i+=2)
{
Prime[i]=false;
}
for (int i = 3; i * i <= n; i+=2)
{
if (Prime[i])
{
for (int j = i*i; j <= n; j+=i)
{
if(Prime[j]==true)
Prime[j] = false;
}
}
}
for (int i = 2; i <= n; i++)
{
if (Prime[i])
{
res.emplace_back(i);
}
}
return res;
}
bool isvalid(lli x,lli y,lli n,lli m)
{
if(x<0||x>(n-1)||y<0||y>(m-1))
return false;
//if(visited[x][y]==true)
//return false;
return true;
}
lli bs(lli a[],lli start,lli end,lli x,lli n)
{
lli mid=start+(end-start)/2;
if(start>end)
return -1;
if(a[mid]==x)
return mid;
else if(a[mid]>x)
return bs(a,start,mid-1,x,n);
else
return bs(a,mid+1,end,x,n);
}
void transpose(vector<vector<lli>>&v)
{
loop0(i,v.size())
{
loop0(j,i)
{
swap(v[i][j],v[j][i]);
}
}
}
map<lli,lli> primeFactors(lli n)
{
map<lli,lli>mp;
while (n % 2 == 0) //PRIME FACTORISATION IN SQRT(n)
{
mp[2]++;
n=n/2;
}
for (lli i = 3; i <= sqrt(n); i = i + 2)
{
while (n % i == 0)
{
mp[i]++; //PRIME FACTORIZATION
n = n/i;
}
}
if (n > 2)
mp[n]++;
/*for(auto x:mp)
{
cout<<x.first<<" "<<x.second<<endl;
}*/
return mp;
}
void primefactors(lli n)
{ //PRIME FACTORISATION USING SIEVE
lli d[n+1];
memset(d,-1,sizeof(d));
d[1]=1;
for(lli i=2;i<=n;i+=2)
{
d[i]=i;
}
for(lli i=3;i<=n;i+=2)
{
if(d[i]==-1)
{
for(lli j=i;j<=n;j+=i)
{
if(d[j]==-1)
{
d[j]=i;
}
}
}
}
// for(lli i=1;i<=n;i++)
// cout<<d[i]<<" ";
map<lli,lli>mp;
while(n>1)
{
mp[d[n]]++;
n=n/d[n];
}
// for(auto x:mp)
//cout<<x.first<<" "<<x.second<<endl;
}
lli gcd (lli a, lli b) {
return b ? gcd (b, a % b) : a;
}
lli lcm (lli a,lli b) {
return a / gcd(a, b) * b;
}
lli SubArraySum(lli arr[] ,lli n )
{
lli result = 0;
for (lli i=0; i<n; i++)
result += (arr[i] * (i+1) * (n-i));
return result ;
}
lli countsetbits(lli n)
{
lli count=0;
while(n)
{
count++;
n=n&(n-1);
}
return count;
}
lli nCr(lli n,lli k)
{
double res = 1;
for (lli i = 1; i <= k; ++i)
res = res * (n - k + i) / i;
return (int)(res + 0.01);
}
lli gcd_(lli a,lli b)
{
if (!a || !b) //if a==0 || b==0 than simply return other element
return a | b;
unsigned shift = __builtin_ctzll(a | b); //this will count min 2 factor in both numbers
a >>= __builtin_ctzll(a);
do {
b >>= __builtin_ctzll(b);
if (a > b)
swap(a, b);
b -= a;
} while (b);
//finally b will become 0 and a will contain our result
return a << shift;
}
pair<lli,lli> fib (lli n) {
if (n == 0)
return {0ll, 1ll};
//FIBONACCI IN logN
auto p = fib(n >> 1ll);
lli c = ((p.first%mod)*((2 * (p.second%mod))%mod - (p.first%mod)+mod)%mod)%mod;
c=c%mod;
lli d =((((p.first%mod) * (p.first%mod))%mod) + ((p.second%mod) * (p.second%mod))%mod)%mod;
d=d%mod;
lli x=(c+d)%mod;
if (n%2!=0)
return {d,x};
else
return {c, d};
}
lli nCrModPFermat(lli n, lli r)
{
if (n < r)
return 0;
if (r == 0)
return 1;
lli fac[n + 1];
fac[0] = 1;
for (lli i = 1; i <= n; i++)
fac[i] = (fac[i - 1] * i) % mod;
lli ans=((fac[n] %mod)* modularexponentiation(fac[r],mod-2,mod)) % mod;
ans=(ans*modularexponentiation(fac[n - r], mod-2,mod)) % mod;
return ans;
}
lli calc(lli a[],lli b[],lli n,lli x,lli y)
{
lli sum=0;
loop0(i,n)
{
sum+=abs(a[i]-x)+abs(b[i]-y);
}
return sum;
}
int main()
{
toh_shuru_karte_hai_bina_kise_bakchodi_ke;
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
test{
lli n;
cin>>n;
lli a[n],b[n];
loop0(i,n)
cin>>a[i]>>b[i];
vector<pair<lli,lli>>v;
loop0(i,n)
v.pb({a[i],b[i]});
if(n==1)
{
cout<<1<<endl;
}
else
{
if(n==2)
{
if((v[0].first == v[1].first) || (v[0].second == v[1].second))
{
lli ans=abs(v[0].first-v[1].first)+abs(v[0].second-v[1].second)+1;
cout<<ans<<endl;
}
else
{
sort(a,a+n);
sort(b,b+n);
lli cx = a[n/2] - a[n/2 - 1]+1;
lli cy = b[n/2] - b[n/2 - 1]+1;
lli ans=cx*cy;
cout<<ans<<endl;
}
}
else
{
sort(a,a+n);
sort(b,b+n);
if(n%2==0)
{
lli cx = a[n/2] - a[n/2 - 1]+1;
lli cy = b[n/2] - b[n/2 - 1]+1;
lli ans=cx*cy;
cout<<ans<<endl;
}
else
{
cout<<1<<endl;
}
}
}
/* lli o=*min_element(a,a+n);
lli h=*max_element(a,a+n);
lli p=*max_element(b,b+n);
lli r=*min_element(b,b+n);
lli u=min(o,r);
lli y=max(h,p);
vector<lli>v;
for(lli i=u;i<=y;i++)
{
for(lli j=u;j<=y;j++)
{
lli ans=calc(a,b,n,i,j);
v.pb(ans);
}
}
map<lli,lli>mp;
sort(v.begin(),v.end());
for(auto x:v)
mp[x]++;
lli res=mp[v[0]];
cout<<res<<endl;
*/
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int op = 0, clo = 0, ans = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '(')
ans++, op++;
else if (op > 0)
op--, ans++;
}
cout << ans - op;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename... T>
void rd(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void pp(T... args) {
((cout << args << " "), ...);
cout << "\n";
}
void solve() {
long long int n;
cin >> n;
vector<long long int> arr(n);
for (long long int& v : arr) rd(v);
;
vector<long long int> Ans;
Ans.push_back(-1);
vector<long long int> A(n);
A[n - 1] = arr[n - 1];
for (long long int i = n - 2; i >= 0; i--) {
long long int l = i + 1, h = n - 1;
long long int ans = -1;
while (l <= h) {
long long int mid = l + (h - l) / 2;
if (A[mid] < arr[i]) {
ans = mid;
l = mid + 1;
} else
h = mid - 1;
}
if (ans == -1)
Ans.push_back(-1);
else
Ans.push_back(ans - i - 1);
A[i] = min(A[i + 1], arr[i]);
}
reverse(Ans.begin(), Ans.end());
for (auto v : Ans) cout << v << " ";
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, kan[500005];
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &kan[i]);
}
sort(kan, kan + n);
int cnt = n;
for (int i = 0, j = n / 2; i < n / 2; ++i) {
while (j < n && 2 * kan[i] > kan[j]) {
++j;
}
if (j < n) {
--cnt;
++j;
}
}
printf("%d\n", cnt);
return 0;
}
| 4 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n, m;
std::cin >> n >> m;
std::vector<std::vector<int>> a(n + 1, std::vector<int>(m + 1, 0));
auto row = a;
auto col = a;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char ch;
std::cin >> ch;
a[i][j] = ch == '0';
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
row[i][j] = a[i][j] ? 1 + row[i][j + 1] : 0;
col[i][j] = a[i][j] ? 1 + col[i + 1][j] : 0;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!a[i][j]) continue;
int mask = 15;
for (int d = 1; mask; d++) {
if (!(i + d < n && j + d < m && a[i + d][j + d])) {
mask &= ~1;
}
if (!(i + d < n && j - d >= 0 && a[i + d][j - d])) {
mask &= ~2;
}
if (!(i - d >= 0 && j - d >= 0 && a[i - d][j - d])) {
mask &= ~4;
}
if (!(i - d >= 0 && j + d < m && a[i - d][j + d])) {
mask &= ~8;
}
if ((mask & 1) && row[i][j] > d && col[i][j + d] > d) {
ans++;
}
if ((mask & 2) && row[i + d][j - d] > d && col[i][j] > d) {
ans++;
}
if ((mask & 4) && row[i][j - d] > d && col[i - d][j - d] > d) {
ans++;
}
if ((mask & 8) && row[i - d][j] > d && col[i - d][j] > d) {
ans++;
}
if ((mask & 9) == 9 && col[i - d][j + d] >= 2 * d) {
ans++;
}
if ((mask & 3) == 3 && row[i + d][j - d] >= 2 * d) {
ans++;
}
if ((mask & 6) == 6 && col[i - d][j - d] >= 2 * d) {
ans++;
}
if ((mask & 12) == 12 && row[i - d][j - d] >= 2 * d) {
ans++;
}
}
}
}
std::cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
int f[2][200010], q[200010];
int main() {
int now = 0, lst = 1;
int n = read(), k = read();
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
while (k--) {
int l = read(), r = read();
swap(now, lst);
int t = 1, w = 0;
memcpy(f[now], f[lst], sizeof(f[now]));
for (int i = 0; i <= min(n, r); i++) {
while (t <= w && q[t] < i - r + l) ++t;
while (t <= w && f[lst][q[w]] > f[lst][i]) --w;
q[++w] = i, f[now][i] = min(f[now][i], f[lst][q[t]] + 2);
}
t = 1, w = 0;
for (int i = r; i >= 0; i--) {
while (t <= w && q[t] < l - i) ++t;
while (t <= w && f[lst][q[w]] >= f[lst][r - i]) --w;
q[++w] = r - i, f[now][i] = min(f[now][i], f[lst][q[t]] + 1);
}
}
if (f[now][n] >= 0x3f3f3f3f)
printf("Hungry\n");
else
printf("Full\n%d\n", f[now][n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x1, y1, x2, y2;
} num[1000], pro[1000];
int ans[1000];
bool flag;
int main() {
int w, h, n, i, j, k, l;
int a, b, c, d;
while (cin >> w >> h >> n) {
num[0].x1 = 0;
num[0].y1 = h;
num[0].x2 = w;
num[0].y2 = 0;
for (i = 0; i < n; i++)
cin >> pro[i].x1 >> pro[i].y1 >> pro[i].x2 >> pro[i].y2;
j = 1;
for (l = 0; l < n; l++)
for (i = 0; i < n; i++) {
flag = false;
for (k = 0; k < j; k++) {
if (pro[i].x1 == pro[i].x2) {
if (num[k].x1 < pro[i].x1 && pro[i].x1 < num[k].x2 &&
num[k].y2 == pro[i].y1 && pro[i].y2 == num[k].y1) {
num[j].x1 = pro[i].x2;
num[j].y1 = pro[i].y2;
num[j].x2 = num[k].x2;
num[j++].y2 = num[k].y2;
num[k].x2 = pro[i].x1;
num[k].y2 = pro[i].y1;
flag = true;
break;
}
} else {
if (pro[i].x1 == num[k].x1 && num[k].x2 == pro[i].x2 &&
num[k].y2 < pro[i].y1 && pro[i].y1 < num[k].y1) {
num[j].x1 = pro[i].x1;
num[j].y1 = pro[i].y1;
num[j].x2 = num[k].x2;
num[j++].y2 = num[k].y2;
num[k].x2 = pro[i].x2;
num[k].y2 = pro[i].y2;
flag = true;
break;
}
}
}
if (flag) break;
}
for (k = 0; k < j; k++)
ans[k] = abs(num[k].x1 - num[k].x2) * abs(num[k].y1 - num[k].y2);
sort(ans, ans + j);
cout << ans[0];
for (i = 1; i < j; i++) cout << " " << ans[i];
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long inf = 1e9;
using ll = long long;
const int dx[] = {+1, -1, 0, 0};
const int dy[] = {0, 0, +1, -1};
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<pair<int, int>> b;
int pos = 0;
for (int& x : a) {
cin >> x;
b.push_back({x, pos++});
}
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
vector<int> t(n);
t[0] = a[0];
for (int i = 1; i < n; i++) t[i] = t[i - 1] + a[i];
for (int i = 0; i < n; i++) {
if (t[i] <= m) {
cout << 0 << " ";
continue;
} else {
int ok = false;
int sum = 0, kol = 0;
for (int j = 0; j < n; j++) {
if (t[i] - sum <= m) {
ok = true;
cout << kol << " ";
break;
}
if (b[j].second < i) {
sum += b[j].first;
kol++;
}
}
if (ok == false && t[i] - sum <= m) cout << kol << " ";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const int N = 20005;
int pre[55][N];
int a[N][20], b[N][20], c[N][20], lg[N] = {-1};
void RMQ_init(int n, int d[][20]) {
for (int j = 1; 1 << j <= n; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
d[i][j] = max(d[i][j - 1], d[i + (1 << j - 1)][j - 1]);
}
}
}
int RMQ(int L, int R, int d[][20]) {
int k = lg[R - L + 1];
return max(d[L][k], d[R - (1 << k) + 1][k]);
}
int f[55][N];
int main() {
int n, m, g;
scanf("%d%d%d", &n, &m, &g);
for (int i = 1; i <= m; i++) lg[i] = lg[i / 2] + 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int x;
scanf("%d", &x);
pre[i][j] = pre[i][j - 1] + x;
}
}
int h = m - g + 1;
for (int j = 1; j <= h; j++) {
f[1][j] =
pre[1][j + g - 1] - pre[1][j - 1] + pre[2][j + g - 1] - pre[2][j - 1];
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= h; j++) {
a[j][0] = f[i - 1][j] - pre[i][j + g - 1];
b[j][0] = f[i - 1][j] + pre[i][j - 1];
c[j][0] = f[i - 1][j];
}
RMQ_init(h, a);
RMQ_init(h, b);
RMQ_init(h, c);
for (int j = 1; j <= h; j++) {
int x = max(1, j - g + 1), y = j;
f[i][j] = max(f[i][j], RMQ(x, y, a) + pre[i][j - 1]);
x = j, y = min(h, j + g - 1);
f[i][j] = max(f[i][j], RMQ(x, y, b) - pre[i][j + g - 1]);
x = 1, y = j - g;
if (x <= y) f[i][j] = max(f[i][j], RMQ(x, y, c));
x = j + g, y = h;
if (x <= y) f[i][j] = max(f[i][j], RMQ(x, y, c));
f[i][j] += pre[i][j + g - 1] - pre[i][j - 1] + pre[i + 1][j + g - 1] -
pre[i + 1][j - 1];
}
}
int ans = 0;
for (int i = 1; i <= h; i++) {
ans = max(ans, f[n][i]);
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, x, blocks, idx[100100], intersect[400][100100];
long long a[100100], sum[100100], largeSum[100100], y;
bool found[400][100100];
vector<int> large, v[100100];
char s[10];
int main() {
scanf("%d %d %d", &n, &m, &q);
blocks = sqrt(100000);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= m; i++) {
int k;
scanf("%d", &k);
if (k > blocks) {
idx[i] = large.size();
large.push_back(i);
}
for (int j = 0; j < k; j++) {
scanf("%d", &x);
v[i].push_back(x);
if (k > blocks) {
found[idx[i]][x] = true;
sum[idx[i]] += a[x];
}
}
}
for (int i = 0; i < large.size(); i++) {
for (int j = 1; j <= m; j++) {
for (int k = 0; k < v[j].size(); k++) {
if (found[i][v[j][k]]) intersect[i][j]++;
}
}
}
while (q--) {
scanf("%s", s);
if (s[0] == '+') {
scanf("%d %lld", &x, &y);
if (v[x].size() > blocks)
largeSum[idx[x]] += y;
else {
for (int i = 0; i < v[x].size(); i++) a[v[x][i]] += y;
for (int i = 0; i < large.size(); i++) {
sum[i] += y * intersect[i][x];
}
}
} else {
scanf("%d", &x);
long long ans = 0;
if (v[x].size() > blocks)
ans += sum[idx[x]];
else {
for (int i = 0; i < v[x].size(); i++) ans += a[v[x][i]];
}
for (int i = 0; i < large.size(); i++) {
ans += largeSum[i] * intersect[i][x];
}
printf("%lld\n", ans);
}
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.