solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(false), cin.tie(0)
#define debug(a) cout << #a << ": " << a << endl
using namespace std;
typedef long long ll;
const int N = 5e5 + 7;
const int inf = 0x3f3f3f3f;
int a[N], dp[N];
int l[N], r[N], c[N];
int main(void){
IOS;
int n; cin >> n;
for (int i = 1; i <= n; ++i){
cin >> a[i];
if (!l[a[i]]) l[a[i]] = i;
r[a[i]] = i;
}
for (int i = n; i >= 1; --i){
c[a[i]]++;
dp[i] = dp[i+1];
if (l[a[i]] == i) dp[i] = max(dp[i], c[a[i]]+dp[r[a[i]]+1]);
else dp[i] = max(dp[i], c[a[i]]);
//printf("i %d dp %d c %d r %d\n", i, dp[i], c[a[i]], r[a[i]]);
}
cout << n - dp[1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 10;
const long long mod = 998244353;
double eps = 1e-10;
void in(long long &x) {
x = 0;
char c = getchar();
long long y = 1;
while (c < '0' || c > '9') {
if (c == '-') y = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
x *= y;
}
void o(long long x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) o(x / 10);
putchar(x % 10 + '0');
}
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
long long s, x;
long long cal(long long x) {
long long res = 1;
for (long long i = 0; i < 50; i++) {
if (x & ((long long)1 << i)) res <<= 1;
}
return res;
}
signed main() {
in(s);
in(x);
s -= x;
long long ans;
if (s & 1 || s < 0) {
ans = 0;
} else if ((s >> 1) & x) {
ans = 0;
} else if (x == 0 && s == 0) {
ans = 0;
} else {
ans = cal(x) - 2 * (s == 0);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N=200005,mu=1e9+7,inv2=(mu+1)/2;
int s[N],a[N],n,S,T[N],c[N],ans,d[N],zero[N];
void reduce(int &x) { x+=x>>31μ }
int ksm(int x,int y){
int ans=1;
for (;y;y>>=1,x=x*1ll*x%mu)
if (y&1) ans=ans*1ll*x%mu;
return ans;
}
int lowbit(int x){
return x&(-x);
}
void upd(int x,int y){
while (x<=n){
reduce(c[x]+=y-mu);
x=x+lowbit(x);
}
}
int getsum(int x){
int res=0;
while (x>0){
reduce(res+=c[x]-mu);
x-=lowbit(x);
}
return res;
}
void upd2(int x,int y){
while (x<=n){
reduce(d[x]+=y-mu);
x=x+lowbit(x);
}
}
int getsum2(int x){
int res=0;
while (x>0){
reduce(res+=d[x]-mu);
x-=lowbit(x);
}
return res;
}
int solve(){
int res=0;
memset(c,0,sizeof(c));
for (int i=n;i>=1;i--){
reduce(res+=getsum(a[i]-1)-mu);
upd(a[i],1);
}
return res;
}
int main(){
scanf("%d",&n);
for (int i=1;i<=n;i++){
scanf("%d",&a[i]);
s[a[i]]++;
}
S=1;
for (int i=n-1;i;i--) s[i]+=s[i+1]-1;
for (int i=1;i<=n;i++) {//总个数
if (s[i]<=0){
puts("0");
return 0;
}
S=S*1ll*s[i]%mu;
}
T[0]=1;
for (int i=1;i<=n;i++) {
zero[i]=zero[i-1];
if (s[i]-1==0) T[i]=T[i-1],zero[i]++;
else T[i]=T[i-1]*1ll*(s[i]-1)%mu*ksm(s[i],mu-2)%mu;
}
int sum=0;
for (int i=n;i>=1;i--){//a[i]<=a[j]
int t=(sum-getsum(a[i]-1)-(sum-getsum2(zero[a[i]]))+mu)%mu;
ans=(ans+t*1ll*S%mu*ksm(T[a[i]],mu-2))%mu;
reduce(sum+=T[a[i]]-mu);
upd(a[i],T[a[i]]);
upd2(zero[a[i]],T[a[i]]);
}
ans=ans*1ll*inv2%mu;
memset(c,0,sizeof(c)),memset(d,0,sizeof(d)),sum=0;
for (int i=1;i<=n;i++){//a[i]>a[j] 从a[i]->a[j]
int t=(sum-getsum(a[i])-(sum-getsum2(zero[a[i]]))+mu)%mu;
ans=(ans-t*1ll*inv2%mu*S%mu*ksm(T[a[i]],mu-2))%mu;
reduce(sum+=T[a[i]]-mu);
upd(a[i],T[a[i]]);
upd2(zero[a[i]],T[a[i]]);
}
ans=(ans+solve()*1ll*S)%mu;
printf("%d\n",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int ci[] = {1, 0, -1, 0};
const int cj[] = {0, -1, 0, 1};
int n, m;
char a[505][505];
int b[505][505];
int id[505][505], _id, counter[250005];
bool gone[505][505];
bool inside(int i, int j) { return min(i, j) >= 1 && max(i, j) <= n; }
void go(int i, int j) {
if (gone[i][j]) return;
gone[i][j] = true;
id[i][j] = _id;
++counter[_id];
for (int k = 0; k < 4; ++k) {
int ii = i + ci[k];
int jj = j + cj[k];
if (inside(ii, jj) && a[ii][jj] == '.') go(ii, jj);
}
}
int ncover[250005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%s", a[i] + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
b[i][j] = b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1] + (a[i][j] == 'X');
memset(gone, false, sizeof gone);
_id = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (!gone[i][j] && a[i][j] == '.') {
++_id;
go(i, j);
}
int result = 0;
for (int i = 1; i + m - 1 <= n; ++i) {
int white = 0;
for (int ii = i - 1; ii <= i + m; ++ii)
for (int jj = 1; jj <= m + 1; ++jj)
if (!(jj == m + 1 && (ii == i - 1 || ii == i + m)) && inside(ii, jj) &&
a[ii][jj] == '.') {
++ncover[id[ii][jj]];
if (ncover[id[ii][jj]] == 1) white += counter[id[ii][jj]];
}
for (int j = 1; j + m - 1 <= n; ++j) {
result =
max(result, white + b[i + m - 1][j + m - 1] - b[i + m - 1][j - 1] -
b[i - 1][j + m - 1] + b[i - 1][j - 1]);
for (int ii = i; ii < i + m; ++ii) {
if (inside(ii, j - 1) && a[ii][j - 1] == '.') {
--ncover[id[ii][j - 1]];
if (ncover[id[ii][j - 1]] == 0) white -= counter[id[ii][j - 1]];
}
if (inside(ii, j + m + 1) && a[ii][j + m + 1] == '.') {
++ncover[id[ii][j + m + 1]];
if (ncover[id[ii][j + m + 1]] == 1)
white += counter[id[ii][j + m + 1]];
}
}
if (inside(i - 1, j) && a[i - 1][j] == '.') {
--ncover[id[i - 1][j]];
if (ncover[id[i - 1][j]] == 0) white -= counter[id[i - 1][j]];
}
if (inside(i + m, j) && a[i + m][j] == '.') {
--ncover[id[i + m][j]];
if (ncover[id[i + m][j]] == 0) white -= counter[id[i + m][j]];
}
if (inside(i - 1, j + m) && a[i - 1][j + m] == '.') {
++ncover[id[i - 1][j + m]];
if (ncover[id[i - 1][j + m]] == 1) white += counter[id[i - 1][j + m]];
}
if (inside(i + m, j + m) && a[i + m][j + m] == '.') {
++ncover[id[i + m][j + m]];
if (ncover[id[i + m][j + m]] == 1) white += counter[id[i + m][j + m]];
}
}
for (int ii = i - 1; ii <= i + m; ++ii)
for (int jj = n; jj >= n - m - 1; --jj)
if (inside(ii, jj) && a[ii][jj] == '.') ncover[id[ii][jj]] = 0;
memset(ncover, 0, sizeof ncover);
}
printf("%d", result);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 1e5 + 5;
int n, pn;
int a[N];
int f[N], bit[N];
void add(int x, int v) {
for (; x <= pn; x += x & -x) bit[x] = max(bit[x], v);
}
int query(int x) {
int ret = 0;
for (; x; x -= x & -x) ret = max(ret, bit[x]);
return ret;
}
bool bz[N];
int m;
vector<int> key[N];
void solve(int n, int *a) {
if (!n) return;
for (int i = 1; i <= pn; i++) bit[i] = 0;
int mx = 0;
for (int i = 1; i <= n; i++) {
bz[i] = 0;
f[i] = query(a[i] - 1) + 1;
add(a[i], f[i]);
mx = max(mx, f[i]);
}
int k = sqrt(n * 2);
while (k * (k + 1) / 2 < n) k++;
while (k * (k - 1) / 2 >= n) k--;
if (mx >= k) {
int v = pn + 1, now = mx;
m++;
for (int i = n; i >= 1; i--)
if (f[i] == now && a[i] < v) {
v = a[i];
key[m].push_back(a[i]);
now--;
bz[i] = 1;
}
reverse(key[m].begin(), key[m].end());
int n_ = 0;
for (int i = 1; i <= n; i++)
if (!bz[i]) a[++n_] = a[i];
n = n_;
solve(n, a);
} else {
for (int i = 1; i <= n; i++) key[m + f[i]].push_back(a[i]);
m += mx;
}
}
void solve() {
n = get();
for (int i = 1; i <= n; i++) a[i] = get();
pn = n;
m = 0;
for (int i = 1; i <= n; i++) key[i].clear();
solve(n, a);
printf("%d\n", m);
for (int i = 1; i <= m; i++) {
printf("%d", key[i].size());
for (auto x : key[i]) printf(" %d", x);
putchar('\n');
}
}
int main() {
for (int _ = get(); _; _--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
long long int n;
cin >> n;
long long int A[n], c[n];
for (long long int i = 0; i < n; i++) cin >> A[i];
for (long long int i = 0; i < n; i++) cin >> c[i];
long long int ans = INF;
for (long long int i = 1; i < n - 1; i++) {
long long int mn1 = INF, mn2 = INF;
for (long long int j = i - 1; j >= 0; j--) {
if (A[j] < A[i]) mn1 = min(mn1, c[j]);
}
for (long long int j = i + 1; j < n; j++) {
if (A[j] > A[i]) mn2 = min(mn2, c[j]);
}
ans = min(ans, c[i] + mn1 + mn2);
}
cout << (ans != INF ? ans : -1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, a, b;
double smalst, angle, bb;
cin >> n >> a;
if (n == 3) {
cout << 2 << ' ' << 1 << ' ' << 3;
return 0;
}
angle = 180 - (double)360 / n;
smalst = angle / (n - 2);
b = 3;
bb = smalst;
while ((bb < a) & (b < n)) {
b++;
bb += smalst;
}
if (abs(bb - a) < abs((bb - smalst) - a)) {
b = b;
} else {
b = b - 1;
}
if (b < 3) {
b = 3;
}
cout << 2 << ' ' << 1 << ' ' << b;
return 0;
}
| 2 |
#include<stdio.h>
#include<algorithm>
using namespace std;
int b[41000];
int c[41000];
int d[41000];
int e[41000];
struct wolf{
int p,q;
wolf(){}
wolf(int A,int B){
p=A;q=B;
}
};
inline bool operator<(const wolf&a,const wolf&b){
return (long long)a.p*b.q<(long long)a.q*b.p;
}
wolf t[41000];
int main(){
int a;scanf("%d",&a);
for(int i=0;i<a+1;i++)scanf("%d%d%d%d",b+i,c+i,d+i,e+i);
long long ret=0;
long long now=0;
int n=0;
for(int i=0;i<a;i++){
int p=max(c[i+1]-d[0],0);
int r=max(c[0]-d[i+1],0);
if(r==0&&p!=0){
printf("-1\n");return 0;
}else if(r==0){
continue;
}
int q=(b[i+1]+r-1)/r;
if(e[i+1]>e[0])ret+=p;
t[n++]=wolf(q,p);
now+=p;
// printf("%d %d\n",p,q);
}
std::sort(t,t+n);
ret-=now;
for(int i=0;i<n;i++){
ret+=(long long)t[i].p*now;
now-=t[i].q;
if(ret>=b[0])break;
}
if(ret<b[0])printf("%lld\n",ret);
else printf("-1\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int x[maxn];
int r[maxn];
int q[maxn];
int n, k;
int cid = 0;
int lpos[maxn], rpos[maxn];
int* tree[maxn];
vector<int> pos[maxn];
set<int> ayy;
map<int, int> lmao;
int lwb[maxn];
int pps[maxn];
int tot[maxn];
void add(int* t, int len, int pos, int d) {
while (pos <= len) {
t[pos] += d;
pos += pos & -pos;
}
}
int get(int* t, int r) {
if (r == 0) return 0;
int ans = 0;
while (r) {
ans += t[r];
r -= r & -r;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
vector<pair<int, pair<int, int> > > kek;
for (auto i = 0; i < n; ++i) {
int a, b, c;
cin >> a >> b >> c;
kek.push_back(make_pair(a, make_pair(b, c)));
}
sort((kek).begin(), (kek).end());
for (auto i = 0; i < n; ++i) {
x[i] = kek[i].first;
r[i] = kek[i].second.first;
q[i] = kek[i].second.second;
ayy.insert(q[i]);
}
for (auto c : ayy) {
lmao[c] = cid++;
}
for (auto c : ayy) {
int l = c - k, r = c + k;
auto lt = ayy.lower_bound(l);
auto rt = ayy.upper_bound(r);
int i = lmao[c];
if (rt == ayy.begin()) {
rpos[i] = -1;
continue;
}
--rt;
int lp = *lt, rp = *rt;
if (lp > rp) {
rpos[i] = -1;
continue;
}
lpos[i] = lmao[lp];
rpos[i] = lmao[rp];
}
for (auto i = 0; i < n; ++i) {
int p = lmao[q[i]];
pps[i] = p;
if (!pos[p].empty() && pos[p].back() == x[i]) continue;
pos[p].push_back(x[i]);
}
for (auto i = 0; i < cid; ++i) {
int sz = pos[i].size();
tree[i] = new int[sz + 1];
fill(tree[i], tree[i] + 1 + sz, 0);
}
set<pair<int, int> > s;
long long ans = 0;
for (auto i = 0; i < n; ++i) {
while (!s.empty() && s.begin()->first < x[i]) {
int p = pps[s.begin()->second];
--tot[p];
add(tree[p], pos[p].size(), lwb[s.begin()->second] + 1, -1);
s.erase(s.begin());
}
int p = pps[i];
for (auto j = lpos[p]; j < rpos[p] + 1; ++j) {
int huy = lower_bound((pos[j]).begin(), (pos[j]).end(), x[i] - r[i]) -
pos[j].begin();
ans += tot[j] - get(tree[j], huy);
}
int j =
lower_bound((pos[p]).begin(), (pos[p]).end(), x[i]) - pos[p].begin();
lwb[i] = j;
add(tree[p], pos[p].size(), j + 1, 1);
++tot[p];
s.insert(make_pair(x[i] + r[i], i));
}
cout << ans;
}
| 1 |
#include <iostream>
#include <string>
using namespace std;
int main(void){
string s;
int x[26] = {};
while(getline(cin,s) ){
for(int i = 0;i < s.size();i++){
char c = s.at(i);
c = tolower(c);
x[c - 'a']++;
}
}
for(int i = 0;i < 26;i++){
cout << char(i+'a') <<" : "<< x[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
bool odd(int n) { return n % 2 == 1; }
void ans(int k) {
if (k == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (n % 2 == 1 and odd(a[0]) and odd(a[n - 1])) {
ans(1);
} else {
ans(0);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
long long F[20][300000], G[20][300000];
int cnt[300000], fac[300000], ifac[300000], inv[300000];
int MOD;
int n, m, num, k;
inline int ksm(int b, int k) {
int ans = 1;
while (k) {
if (k & 1) ans = 1ll * ans * b % MOD;
b = 1ll * b * b % MOD;
k >>= 1;
}
return ans;
}
inline int add(long long x, long long y) {
return x + y >= MOD ? x - MOD + y : x + y;
}
inline int sub(long long x, long long y) {
return x >= y ? x - y : x + MOD - y;
}
void FWT_or(long long *f, int opr) {
int maxn = m;
for (int len = 1; len < maxn; len *= 2) {
for (int i = 0; i < maxn; i += len * 2) {
for (int j = 0; j < len; ++j) {
long long x = f[i + j], y = f[i + j + len];
if (opr == 1) {
f[i + j] = x;
f[i + j + len] = add(x, y);
} else {
f[i + j] = x;
f[i + j + len] = sub(y, x);
}
}
}
}
}
void Init(int m) {
cnt[0] = 0;
for (int i = 1; i <= m; ++i) cnt[i] = cnt[i - (i & (-i))] + 1;
fac[0] = 1;
for (int i = 1; i <= m; ++i) fac[i] = 1ll * fac[i - 1] * i % MOD;
ifac[m] = ksm(fac[m], MOD - 2);
for (int i = m - 1; i >= 0; --i) ifac[i] = 1ll * ifac[i + 1] * (i + 1) % MOD;
for (int i = 0; i < 20; ++i) inv[i] = ksm(i, MOD - 2);
}
void Exp() {
for (int i = 0; i <= n; ++i) FWT_or(F[i], 1);
memset(G, 0, sizeof(G));
G[0][0] = 1, FWT_or(G[0], 1);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= i - 1; ++j) {
long long mul = 1ll * (i - j) * inv[i] % MOD;
for (int s = 0; s < (1 << n); ++s) {
G[i][s] = add(G[i][s], G[j][s] * mul % MOD * F[i - j][s] % MOD);
}
}
}
for (int i = 0; i <= n; ++i) FWT_or(G[i], -1);
memset(F, 0, sizeof(F));
for (int i = 0; i < m; ++i) F[cnt[i]][i] = G[cnt[i]][i];
}
void Ln() {
for (int i = 0; i <= n; ++i) FWT_or(F[i], 1);
memset(G, 0, sizeof(G));
G[0][0] = 1, FWT_or(G[0], 1);
for (int i = 1; i <= n; ++i) {
for (int s = 0; s < (1 << n); ++s) {
for (int j = 0; j <= i - 1; ++j) {
G[i][s] = add(G[i][s], G[j][s] * j * F[i - j][s] % MOD);
}
G[i][s] = sub(F[i][s], 1ll * G[i][s] * inv[i] % MOD);
}
}
for (int i = 0; i <= n; ++i) FWT_or(G[i], -1);
memset(F, 0, sizeof(F));
for (int i = 0; i < m; ++i) F[cnt[i]][i] = G[cnt[i]][i];
}
int main() {
num = read(), k = read();
MOD = read();
if (num & 1) {
printf("%d\n", ksm(k, num));
return 0;
}
n = log2(num) + 1, m = (1 << n);
Init(m);
for (int i = 0; i < m; ++i) F[cnt[i]][i] = ifac[i];
Ln();
for (int i = 0; i < m; ++i) F[cnt[i]][i] = 1ll * F[cnt[i]][i] * k % MOD;
Exp();
printf("%d\n",
((ksm(k, num) - 1ll * F[cnt[num]][num] * fac[num] % MOD) % MOD + MOD) %
MOD);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
const long double PI = 3.141592653589793238462643383279502884197;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long mp(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
priority_queue<int, vector<int>, greater<int>> pq;
vector<int> v;
char ans[101];
int main() {
int n;
scanf("%d", &n);
if (n <= 3) {
printf("? 1 1\n");
fflush(stdout);
char t;
scanf(" %c", &t);
ans[0] = t;
if (n >= 2) {
printf("? 2 2\n");
fflush(stdout);
scanf(" %c", &t);
ans[1] = t;
}
if (n == 3) {
printf("? 3 3\n");
fflush(stdout);
scanf(" %c", &t);
ans[2] = t;
}
printf("! %s", ans);
fflush(stdout);
return 0;
}
int nn = n / 2;
printf("? 1 %d\n", nn);
printf("? 2 %d\n", nn);
fflush(stdout);
int d[101] = {0};
for (int i = 0; i < (nn + 1) * nn / 2; i++) {
string t;
cin >> t;
for (char c : t) d[(int)(t).size()] += c;
}
for (int i = 0; i < (nn - 1) * nn / 2; i++) {
string t;
cin >> t;
for (char c : t) d[(int)(t).size()] -= c;
}
for (int i = nn; i >= 1; i--) d[i] -= d[i - 1];
for (int i = 1; i <= nn; i++) ans[i - 1] = d[i];
printf("? 1 %d\n", n);
fflush(stdout);
memset(d, 0, sizeof(d));
for (int i = 0; i < n * (n + 1) / 2; i++) {
string t;
cin >> t;
for (char c : t) d[(int)(t).size()] += c;
}
if (n % 2) ans[nn] = d[nn + 1] - d[nn];
ans[n - 1] = d[n] - (d[2] - d[1]) - ans[0];
for (int i = 1; i < nn; i++) {
int tt = (d[i + 1] - d[i]) - (d[i + 2] - d[i + 1]);
ans[n - i - 1] = tt - ans[i];
}
printf("! %s\n", ans);
fflush(stdout);
}
| 3 |
#include <stdio.h>
#include <algorithm>
using namespace std;
int D[303][303][155];
char S[303]; int K;
int main()
{
scanf("%s %d", S+1,&K);
int N = 0;
while (S[N + 1]) N++;
if (2 * K > N) {
printf("%d\n" , N);
return 0;
}
for (int i = 1; i <= N; i++) {
for (int j = N; j > i; j--) {
for (int k = 0; k <= K; k++) {
D[i][j][k] = max(D[i - 1][j][k], D[i][j + 1][k]);
if (S[i] == S[j]) D[i][j][k] = max(D[i][j][k], D[i - 1][j + 1][k] + 2);
else {
if (k) D[i][j][k] = max(D[i][j][k], D[i - 1][j + 1][k-1] + 2);
}
}
}
}
int ans = 1;
for (int i = 1; i <= N; i++) {
for (int j = N; j > i; j--) {
for (int k = 0; k <= K; k++) {
int d = D[i][j][k];
if (i + 1 < j) d++;
ans = max(ans, d);
}
}
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int a, b, c;
cin >> a >> b >> c;
if(a > b && a > c){
cout << "A" << endl;
}
else if(b > a && b > c){
cout << "B" << endl;
}
else{
cout << "C" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> a(n);
for(int i=0;i<n;i++){
cin>>a[i];
}
for(int i=n-1;i>=0;i--){
if(i>0){
cout<<a[i]<<" ";
}
}
cout<<a[0]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, s;
int ar[300005];
vector<int> pr;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> s;
int free = 0;
for (int i = 0; i < n; i++) {
cin >> ar[i];
if (ar[i] && i != (s - 1))
pr.push_back(ar[i]);
else
free++;
}
free--;
int fl = 0;
if (ar[s - 1]) {
fl++;
}
int l = 0;
int r = pr.size() - 1;
int cu = 1;
int ans = free + fl;
sort(pr.begin(), pr.end());
while (l <= r) {
if (pr[l] < cu) {
l++;
continue;
}
if (pr[l] == cu) {
l++;
cu++;
continue;
} else if (free > 0) {
cu++;
free--;
} else {
cu++;
r--;
ans++;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
clock_t time_p = clock();
void aryanc403() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
class CMP {
public:
bool operator()(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return !(a.first < b.first || a.first == b.first && a.second <= b.second);
}
};
void add(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt == m.end())
m.insert({x, cnt});
else
jt->second += cnt;
}
void del(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt->second <= cnt)
m.erase(jt);
else
jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int mod = 1000000007L;
const long long int maxN = 500000L;
long long int T, n, i, j, k, in, cnt, l, r, u, v, x, y, q, no[maxN + 5];
long long int m;
string s;
vector<long long int> f[maxN + 5];
bool vis[maxN + 5];
vector<long long int> a;
void pre(long long int n) {
for (long long int i = 2; i <= n; ++i) {
if (!f[i].empty()) continue;
for (long long int j = i; j <= n; j += i) f[j].push_back(i);
}
}
long long int count(long long int x) {
long long int n = (long long int)f[x].size();
long long int cnt = 0, lim = 1LL << n, i, j, p, v;
for (i = 0; i < lim; ++i) {
p = 1;
v = 0;
for (j = 0; j < n; ++j)
if (i & (1LL << j)) {
p *= f[x][j];
v++;
}
if (v % 2)
cnt -= no[p];
else
cnt += no[p];
};
return cnt;
}
void add(long long int x, long long int c) {
long long int n = (long long int)f[x].size();
long long int lim = 1LL << n;
;
vector<long long int> a;
a.clear();
for (long long int i = 0; i < lim; ++i) {
long long int p = 1;
for (long long int j = 0; j < n; ++j)
if (i & (1LL << j)) p *= f[x][j];
no[p] += c;
a.push_back(p);
};
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
pre(maxN);
cin >> n >> q;
a.clear();
a.reserve(n);
a.push_back(0);
for (i = 0; i < (n); ++i) {
cin >> in;
a.push_back(in);
}
while (q--) {
cin >> x;
if (vis[x]) {
add(a[x], -1);
vis[x] = false;
cnt -= count(a[x]);
} else {
cnt += count(a[x]);
vis[x] = true;
add(a[x], 1);
};
cout << cnt << "\n";
}
}
aryanc403();
return 0;
}
| 3 |
#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
int main()
{ ll n,m=0,i,la=0;
cin>>n;
for(i=1;i<pow(10,9);i++)
{ m=m+i;la++;
if(m>=n)break;
}
cout<<la<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
while (~scanf("%d%d", &n, &m)) {
vector<int> diff(n);
for (int i = 0; i < n; i++) cin >> diff[i];
vector<int> ans;
for (int i = 1; i < n; i++) {
ans.push_back(diff[i - 1] - diff[i]);
}
sort(ans.begin(), ans.end());
int sum = diff[n - 1] - diff[0];
for (int i = 0; i < m - 1; i++) sum += ans[i];
printf("%d\n", sum);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
string s;
cin>>s;
long long r=0,g=0,b=0;
for(int i=0;i<n;i++)
{
if(s[i]=='R')
r++;
else if(s[i]=='B')
b++;
else g++;
}
long long cnt=0;
for(int i=0;i<n-2;i++)
{
for(int j=i+1;j<n-1;j++)
{
if(s[i]!=s[j])
{
int k=j-i;
int ch=j+k;
if(ch<n && (s[i]!=s[ch] && s[j]!=s[ch]))
cnt++;
}
}
}
cout<<r*g*b-cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
vector<long long int> v;
long long int temp;
for (long long int i = 0; i < n; i++) {
cin >> temp;
v.push_back(temp);
}
sort(v.begin(), v.end(), greater<int>());
double ans = v[0];
double s = 0.0;
for (long long int i = 1; i < n; i++) {
s += (double)v[i];
}
s = s / (double)(n - 1);
ans += s;
cout << setprecision(10) << ans << endl;
}
int main() {
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long c[5005][5005];
long long sr[5005], sc[5005];
const long long inv = numeric_limits<long long>::max();
int main() {
scanf("%d%d", &n, &m);
for (int i = 2; i <= 4 * n; i += 4)
for (int j = 2; j <= 4 * m; j += 4) cin >> c[i][j];
for (int i = 2; i <= 4 * n; i += 4)
for (int j = 2; j <= 4 * m; j += 4) sr[i] += c[i][j];
long long resx = inv;
int cx = 0, cy;
for (long long i = 0; i <= 4 * n; i += 4) {
long long sum = 0;
for (long long j = 2; j <= 4 * n; j += 4) sum += sr[j] * (j - i) * (j - i);
if (resx > sum) {
resx = sum;
cx = i / 4;
}
}
for (long long i = 2; i <= 4 * m; i += 4)
for (long long j = 2; j <= 4 * n; j += 4) sc[i] += c[j][i];
long long resy = inv;
for (long long i = 0; i <= 4 * m; i += 4) {
long long sum = 0;
for (long long j = 2; j <= 4 * m; j += 4) sum += sc[j] * (j - i) * (j - i);
if (resy > sum) {
resy = sum;
cy = i / 4;
}
}
cout << resx + resy << endl << cx << " " << cy;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c,d,e,f,answ=1,anss=0;
cin>>a>>b>>c>>d>>e>>f;
for(int i=0;i*100*a<=f;i++){
for(int j=0;j*100*b+i*100*a<=f;j++){
int w=j*100*b+i*100*a;
for(int k=0;k*c+w<=f;k++){
for(int l=0;w+k*c+l*d<=f;l++){
int s=k*c+l*d;
if(anss*(s+w)<answ*s&&(100+e)*s<=e*(s+w)){answ=s+w;anss=s;}
}
}
}
}
if(answ==1){
for(int i=0;i*a*100<=f;i++){
for(int j=0;i*100*a+j*b*100<=f;j++){
answ=max(answ,i*100*a+j*b*100);
}
}
}
cout<<answ<<' '<<anss;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, m, i, j, a[20001], count = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= 2 * m * n; i++) {
scanf("%d", &a[i]);
if (i % 2 == 0) {
if (a[i - 1] == 1 || a[i] == 1) count++;
}
}
printf("%d", count);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using lol = long long int;
const lol mod1 = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
if (min(n, m) >= 4) {
cout << "-1";
return 0;
}
if (min(n, m) == 1) {
cout << "0";
return 0;
}
vector<vector<char> > v(n, vector<char>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> v[i][j];
}
}
if (min(n, m) == 2) {
int dp[m][4];
dp[0][0] = abs(v[0][0] - '0') + abs(v[1][0] - '0');
dp[0][1] = abs(v[0][0] - '0') + abs(v[1][0] - '1');
dp[0][2] = abs(v[0][0] - '1') + abs(v[1][0] - '0');
dp[0][3] = abs(v[0][0] - '1') + abs(v[1][0] - '1');
for (int i = 1; i < m; i++) {
dp[i][0] = min({dp[i - 1][1], dp[i - 1][2]}) + abs(v[0][i] - '0') +
abs(v[1][i] - '0');
dp[i][1] = min({dp[i - 1][0], dp[i - 1][3]}) + abs(v[0][i] - '0') +
abs(v[1][i] - '1');
dp[i][2] = min({dp[i - 1][0], dp[i - 1][3]}) + abs(v[0][i] - '1') +
abs(v[1][i] - '0');
dp[i][3] = min({dp[i - 1][1], dp[i - 1][2]}) + abs(v[0][i] - '1') +
abs(v[1][i] - '1');
}
cout << min({dp[m - 1][0], dp[m - 1][1], dp[m - 1][2], dp[m - 1][3]});
return 0;
}
if (min(n, m) == 3) {
int dp[m][8];
dp[0][0] = abs(v[0][0] - '0') + abs(v[1][0] - '0') + abs(v[2][0] - '0');
dp[0][1] = abs(v[0][0] - '0') + abs(v[1][0] - '0') + abs(v[2][0] - '1');
dp[0][2] = abs(v[0][0] - '0') + abs(v[1][0] - '1') + abs(v[2][0] - '0');
dp[0][3] = abs(v[0][0] - '0') + abs(v[1][0] - '1') + abs(v[2][0] - '1');
dp[0][4] = abs(v[0][0] - '1') + abs(v[1][0] - '0') + abs(v[2][0] - '0');
dp[0][5] = abs(v[0][0] - '1') + abs(v[1][0] - '0') + abs(v[2][0] - '1');
dp[0][6] = abs(v[0][0] - '1') + abs(v[1][0] - '1') + abs(v[2][0] - '0');
dp[0][7] = abs(v[0][0] - '1') + abs(v[1][0] - '1') + abs(v[2][0] - '1');
for (int i = 1; i < m; i++) {
dp[i][0] = min({dp[i - 1][2], dp[i - 1][5]}) + abs(v[0][i] - '0') +
abs(v[1][i] - '0') + abs(v[2][i] - '0');
dp[i][1] = min({dp[i - 1][3], dp[i - 1][4]}) + abs(v[0][i] - '0') +
abs(v[1][i] - '0') + abs(v[2][i] - '1');
dp[i][2] = min({dp[i - 1][0], dp[i - 1][7]}) + abs(v[0][i] - '0') +
abs(v[1][i] - '1') + abs(v[2][i] - '0');
dp[i][3] = min({dp[i - 1][1], dp[i - 1][6]}) + abs(v[0][i] - '0') +
abs(v[1][i] - '1') + abs(v[2][i] - '1');
dp[i][4] = min({dp[i - 1][1], dp[i - 1][6]}) + abs(v[0][i] - '1') +
abs(v[1][i] - '0') + abs(v[2][i] - '0');
dp[i][5] = min({dp[i - 1][0], dp[i - 1][7]}) + abs(v[0][i] - '1') +
abs(v[1][i] - '0') + abs(v[2][i] - '1');
dp[i][6] = min({dp[i - 1][3], dp[i - 1][4]}) + abs(v[0][i] - '1') +
abs(v[1][i] - '1') + abs(v[2][i] - '0');
dp[i][7] = min({dp[i - 1][2], dp[i - 1][5]}) + abs(v[0][i] - '1') +
abs(v[1][i] - '1') + abs(v[2][i] - '1');
}
cout << min({dp[m - 1][0], dp[m - 1][1], dp[m - 1][2], dp[m - 1][3],
dp[m - 1][4], dp[m - 1][5], dp[m - 1][6], dp[m - 1][7]});
return 0;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int A,B;
cin>>A>>B;
int sum=0;
for(int i=A;i<=B;i++){
if(i/10000==i%10&&i%10000/1000==i%100/10){
sum++;
}
}
cout<<sum<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string str[500005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str[i];
}
for (int i = n - 2; i >= 0; i--) {
int k = 0;
while (1) {
if (k == str[i].size() || str[i][k] < str[i + 1][k]) {
break;
}
if (k == str[i + 1].size() || str[i][k] > str[i + 1][k]) {
str[i] = str[i].substr(0, k);
break;
}
k++;
}
}
for (int i = 0; i < n; i++) cout << str[i] << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % 998244353;
a = a * a % 998244353;
b >>= 1;
}
return res;
}
long long fac[510000], finv[510000], inv[510000];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; i++) {
fac[i] = fac[i - 1] * i % 998244353;
inv[i] = 998244353 - inv[998244353 % i] * (998244353 / i) % 998244353;
finv[i] = finv[i - 1] * inv[i] % 998244353;
}
}
long long COM(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % 998244353) % 998244353;
}
int main() {
COMinit();
long long N, M, ans = 0;
cin >> N >> M;
if (N == 2) {
cout << 0 << endl;
return 0;
}
for (int i = N - 2; i < M; ++i) {
ans += COM(i, N - 2);
ans %= 998244353;
}
ans = ans * (N - 2) % 998244353;
ans = ans * power(2, N - 3) % 998244353;
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 1 << 21 | 3;
int n, bit[N];
long long a[N], b[N];
char A[N], B[N];
signed main() {
n = read();
scanf("%s%s", A, B);
for (int i = 0; i < (1 << n); i++) {
if (i) bit[i] = bit[i >> 1] + (i & 1);
a[i] = A[i] - '0';
b[i] = B[i] - '0';
a[i] <<= 2 * bit[i];
b[i] <<= 2 * bit[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << n); j++)
if (j >> i & 1) {
a[j] += a[j ^ (1 << i)];
b[j] += b[j ^ (1 << i)];
}
}
for (int i = 0; i < (1 << n); i++) a[i] *= b[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << n); j++)
if (j >> i & 1) a[j] -= a[j ^ (1 << i)];
}
for (int i = 0; i < (1 << n); i++)
putchar((a[i] >> bit[i] >> bit[i] & 3) + '0');
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int h, w;
int a[2000][2000];
int b[2000][2000];
int mark[2000][2000];
int cnt;
int anch[6][6] = {{1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1}};
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
void bfs(int i, int j, int color, int from) {
queue<pair<int, int> > q;
q.push(make_pair(i, j));
mark[i][j] = color;
while (!q.empty()) {
pair<int, int> cur = q.front();
q.pop();
for (int t = 0; t < (int)(4); t++) {
int tx = cur.first + dx[t];
int ty = cur.second + dy[t];
if (tx < 0 || tx >= h || ty < 0 || ty >= w) continue;
if (a[tx][ty] != 1 || mark[tx][ty] != from) continue;
mark[tx][ty] = color;
q.push(make_pair(tx, ty));
}
}
}
int res[2000][2000];
void er() {
memset(res, 0, sizeof(res));
for (int i = 0; i < (int)(h - 6); i++)
for (int j = 0; j < (int)(w - 6); j++) {
bool f = true;
for (int t1 = 0; t1 < (int)(6); t1++)
for (int t2 = 0; t2 < (int)(6); t2++)
if (b[i + t1][j + t2] != anch[t1][t2]) f = false;
if (f) res[i + 2][j + 2] = 1;
}
memcpy(b, res, sizeof(b));
}
void dil() {
memset(res, 0, sizeof(res));
for (int i = 0; i < (int)(h - 6); i++)
for (int j = 0; j < (int)(w - 6); j++) {
bool f = false;
for (int t1 = 0; t1 < (int)(6); t1++)
for (int t2 = 0; t2 < (int)(6); t2++)
if (b[i + t1][j + t2] == anch[t1][t2]) f = true;
if (f) res[i + 2][j + 2] = 1;
}
memcpy(b, res, sizeof(b));
}
int main() {
scanf("%d%d", &h, &w);
for (int i = 0; i < (int)(h); i++)
for (int j = 0; j < (int)(w); j++) scanf("%d", &a[i][j]);
for (int i = 0; i < (int)(h); i++)
for (int j = 0; j < (int)(w); j++)
if (a[i][j] != 0 && mark[i][j] == 0) bfs(i, j, ++cnt, 0);
memcpy(b, a, sizeof(a));
er();
dil();
dil();
for (int i = 0; i < (int)(h); i++)
for (int j = 0; j < (int)(w); j++) a[i][j] -= b[i][j];
vector<int> ans;
ans.resize(cnt);
for (int i = 0; i < (int)(h); i++)
for (int j = 0; j < (int)(w); j++)
if (a[i][j] == 1 && mark[i][j] != 0) {
ans[mark[i][j] - 1]++;
bfs(i, j, 0, mark[i][j]);
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e5 + 100;
int n;
int a[max_n];
int b[max_n];
int res[max_n];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 2; i <= n; ++i) {
if (a[i] > a[i - 1])
b[i - 1] = b[i] = 1;
else if (a[i] < a[i - 1])
b[i - 1] = b[i] = -1;
}
b[0] = -b[1];
for (int i = 1; i <= n; ++i) {
if (b[i] == 1) {
if (b[i - 1] == 1)
a[i - 1] == a[i] ? res[i] = 1 : res[i] = res[i - 1] + 1;
else if (b[i - 1] == -1) {
if (a[i - 1] == a[i])
res[i - 1] == 1 ? res[i] = 2 : res[i] = 1;
else
res[i] = 1;
} else
res[i] = 1;
if (res[i] > 5) {
printf("-1");
return 0;
}
} else if (b[i] == -1) {
if (b[i - 1] == -1)
a[i - 1] == a[i] ? res[i] = 5 : res[i] = res[i - 1] - 1;
else if (b[i - 1] == 1) {
if (a[i - 1] == a[i])
res[i - 1] == 5 ? res[i] = 4 : res[i] = 5;
else
res[i] = 5;
} else
res[i] = 5;
if (res[i] < 1) {
printf("-1");
return 0;
}
}
}
for (int i = 1; i <= n; ++i) {
if (b[i] == 0) {
for (int j = 1; j <= 5; ++j)
if (j != res[i - 1] && j != res[i + 1]) res[i] = j;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", res[i]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a[1005], b[1005], i, s1, s2;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
s1 = a[1];
for (i = 2; i <= n; i++) s1 = a[i] | s1;
for (i = 1; i <= n; i++) cin >> b[i];
s2 = b[1];
for (i = 2; i <= n; i++) s2 = b[i] | s2;
cout << s1 + s2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, long long> m;
int main() {
long long t, ai, bi, dr = 1;
cin >> t;
vector<pair<long long, long long>> v(t);
for (int i = 0; i < t; i++) {
cin >> ai >> bi;
v[i] = {ai, bi};
}
m[{0, 0}] = 1;
dr += min(v[0].first, v[0].second);
m[{v[0].first, v[0].second}] = 1;
for (int i = 1; i < t; i++) {
if (v[i].first > v[i - 1].first && v[i].second > v[i - 1].second &&
m[{v[i].first, v[i].second}] == 0 &&
min(v[i].first, v[i].second) >= max(v[i - 1].second, v[i - 1].first)) {
if ((v[i - 1].first != 0 || v[i - 1].second != 0) &&
v[i - 1].first != v[i - 1].second) {
dr += min(v[i].first, v[i].second) -
max(v[i - 1].first, v[i - 1].second) + 1;
} else {
dr +=
min(v[i].first, v[i].second) - max(v[i - 1].first, v[i - 1].second);
}
m[{v[i].first, v[i].second}] = 1;
} else if ((v[i].first > v[i].second && v[i].second == v[i - 1].second &&
v[i - 1].first < v[i - 1].second) ||
(v[i].second > v[i].first && v[i].first == v[i - 1].first &&
v[i - 1].second < v[i - 1].first) &&
m[{v[i].first, v[i].second}] == 0) {
dr++;
m[{v[i].first, v[i].second}] = 1;
} else if (v[i].first == v[i].second && m[{v[i].first, v[i].second}] == 0) {
dr++;
m[{v[i].first, v[i].second}] = 1;
}
}
cout << dr;
}
| 2 |
#include <cstdio>
char str[200010];
int main() {
scanf("%s", str);
for (int i = 0; str[i]; ++i)
if (str[i] == '?')
str[i] = 'D';
puts(str);
return 0;
}
| 0 |
#include <iostream>
#include <cassert>
using namespace std;
#define N 8
#define FREE -1
#define NOT_FREE 1
int row[N], col[N], dpos[2*N-1], dneg[2*N-1];
bool X[N][N];
void initialize(){
for(int i = 0;i < N; i++){
row[i] = FREE;
col[i] = FREE;
}
for(int i = 0; i < 2*N-1;i++){
dpos[i] = FREE;
dneg[i] = FREE;
}
}
void printBoard(){
for(int i = 0;i < N;i++){
for(int j = 0;j < N;j++){
if(X[i][j]){
if(row[i] != j)return;
}
}
}
for(int i = 0;i < N;i++){
for(int j = 0;j < N;j++){
cout << ( (row[i] == j) ? "Q" : "." );
}
cout << endl;
}
}
void recursive(int i){
if(i == N){
printBoard();
return;
}
for(int j = 0;j < N;j++){
if(NOT_FREE == col[j] || NOT_FREE == dpos[i+j] || NOT_FREE == dneg[i - j + N - 1])continue;
row[i] = j;
col[j] = dpos[i+j] = dneg[i - j + N - 1] = NOT_FREE;
recursive(i + 1);
row[i] = col[j] = dpos[i+j] = dneg[i - j + N - 1] = FREE;
}
}
int main(){
initialize();
for(int i = 0;i < N;i++){
for(int j = 0;j < N;j++){
X[i][j] = false;
}
}
int k;
cin >> k;
for(int i = 0 ;i < k;i++){
int r,c;
cin >> r >> c;
X[r][c] = true;
}
recursive(0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long a, b[100100], p[100100];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> a;
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= m; i++) cin >> p[i];
sort(b + 1, b + n + 1);
reverse(b + 1, b + n + 1);
sort(p + 1, p + m + 1);
int le = -1, ri = min(n, m) + 1;
while (le + 1 < ri) {
int mi = (le + ri) / 2;
long long cnt = 0;
for (int i = 1; i <= mi; i++) {
if (b[i] < p[mi + 1 - i]) cnt += p[mi + 1 - i] - b[i];
}
if (cnt > a) {
ri = mi;
} else {
le = mi;
}
}
long long tot = 0;
for (int i = 1; i <= le; i++) tot += p[i];
cout << le << ' ' << max(tot - a, 0LL) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double kEps = 1E-8, kPi = acos(-1.0);
const int kMaxN = 10000, kMaxM = 100000;
int n, m, seq[kMaxM], s;
double v, agl[kMaxN];
pair<double, double> wall[kMaxM];
double need[kMaxM];
inline int sgn(double x) {
if (fabs(x) < kEps) return 0;
if (x > 0.0) return 1;
return -1;
}
int main() {
scanf("%d%lf", &n, &v);
for (int i = 0; i < n; ++i) scanf("%lf", &agl[i]);
scanf("%d", &m);
for (int i = 0; i < m; ++i) scanf("%lf%lf", &wall[i].first, &wall[i].second);
sort(wall, wall + m);
int rm = 0;
for (int i = 0, j = 0; i < m; i = j) {
while (j < m && sgn(wall[j].first - wall[i].first) == 0) ++j;
wall[rm++] = wall[j - 1];
}
m = rm;
for (int i = 0; i < m; ++i) {
double t = wall[i].first / (v * cos(kPi / 4.0));
double y = v * sin(kPi / 4.0) * t - 4.9 * t * t;
if (sgn(y - wall[i].second) <= 0)
need[i] = 1E100;
else {
double lb = 0.0, rb = kPi / 4.0;
for (int j = 0; j < 50; ++j) {
double mid = (lb + rb) * 0.5;
t = wall[i].first / (v * cos(mid));
y = v * sin(mid) * t - 4.9 * t * t;
if (sgn(y - wall[i].second) <= 0)
lb = mid;
else
rb = mid;
}
need[i] = lb;
}
}
for (int i = 0; i < m; ++i) {
if (!s)
seq[s++] = i;
else if (sgn(need[i] - need[seq[s - 1]]) > 0)
seq[s++] = i;
}
for (int i = 0; i < n; ++i) {
if (sgn(agl[i] - need[seq[s - 1]]) > 0) {
double t = v * sin(agl[i]) / 4.9;
printf("%.6lf %.6lf\n", v * cos(agl[i]) * t, 0.0);
} else if (sgn(agl[i] - need[seq[0]]) <= 0) {
double t = v * sin(agl[i]) / 4.9;
double x = v * cos(agl[i]) * t;
if (sgn(x - wall[seq[0]].first) < 0)
printf("%.6lf %.6lf\n", x, 0.0);
else {
t = wall[seq[0]].first / (v * cos(agl[i]));
double y = v * sin(agl[i]) * t - 4.9 * t * t;
printf("%.6lf %.6lf\n", wall[seq[0]].first, y);
}
} else {
int lb = 0, rb = s;
while (lb + 1 < rb) {
int mid = (lb + rb) >> 1;
if (sgn(agl[i] - need[seq[mid]]) <= 0)
rb = mid;
else
lb = mid;
}
double t = v * sin(agl[i]) / 4.9;
double x = v * cos(agl[i]) * t;
if (sgn(x - wall[seq[lb + 1]].first) < 0)
printf("%.6lf %.6lf\n", x, 0.0);
else {
t = wall[seq[lb + 1]].first / (v * cos(agl[i]));
double y = v * sin(agl[i]) * t - 4.9 * t * t;
printf("%.6lf %.6lf\n", wall[seq[lb + 1]].first, y);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int M = 998244353;
int main() {
int n;
long long sum = 0;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
for (int i = 0; i < n / 2; i++) {
sum += (v[i] + v[n - i - 1]) * (v[i] + v[n - i - 1]);
}
cout << sum << "\n";
}
| 3 |
#include <cstdio>
#include <cstring>
const int MAX_N = 100000;
const int MAX_Q = 100000;
//输入
int N, Q;
int par[MAX_N + 1]; //父结点
bool marked[MAX_N + 1]; //标记结点
void init(){
//初始化
par[1] = 1;
memset(marked, 0, sizeof(marked));
marked[1] = true;
for(int i = 2; i <= N; i ++)
scanf("%d", &par[i]);
}
int find(int x){
//找到最近被标记的父结点
if(marked[x])return x;
else return find(par[x]);
}
void solve(){
long long ans = 0;
for(int i = 0; i < Q; i ++){
getchar();
char c;
int v;
scanf("%c %d", &c, &v);
if(c == 'M'){
marked[v] = true;
}
else{
ans += find(v);
}
}
printf("%lld\n", ans);
}
int main(int argc, char const *argv[]){
while(scanf("%d %d", &N, &Q)){
if(N == 0 && Q == 0)break;
init();
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long double eps = 0.000000001;
struct Mn {
long double num;
vector<long double> v;
};
Mn del(Mn a, Mn b) {
long double diff = a.num - b.num + 1;
for (long double i = 0; i < diff; i++) {
long double degree = a.num - i;
long double raz = degree - b.num;
long double st = a.v[degree] / b.v[b.num];
for (long double j = 0; j <= b.num; j++) {
long double now = j + raz;
long double coeff = st * b.v[j];
a.v[now] -= coeff;
}
}
long double old = a.num;
for (long double i = a.num; i >= 0; i--) {
if (abs(a.v[i]) > eps) {
a.num = i;
break;
}
}
if (a.num == old) a.num = 0;
return a;
}
long double gcd(Mn a, Mn b) {
if (b.num == 0 && abs(b.v[0]) < eps) return 0;
Mn res = del(a, b);
return gcd(b, res) + 1;
}
signed main() {
long double n;
cin >> n;
srand(time(NULL));
while (true) {
Mn f, s;
f.num = -1;
s.num = -1;
vector<long double> a, b;
for (long double i = 0; i < n; i++) {
long double X = rand() % 2;
long double Y = rand() % 2;
if (X == 0) a.push_back(1);
if (X == 1) a.push_back(-1);
if (i != n - 1) {
if (Y == 0) b.push_back(1);
if (Y == 1) b.push_back(-1);
}
}
a.push_back(1);
b.push_back(1);
f.v = a;
s.v = b;
for (long double i = n; i >= 0; i--) {
if (f.v[i] != 0) {
f.num = i;
break;
}
}
for (long double i = n - 1; i >= 0; i--) {
if (s.v[i] != 0) {
s.num = i;
break;
}
}
Mn f1 = f, s1 = s;
long double g = gcd(f, s);
if (g == n) {
cout << f1.num << endl;
for (long double i = 0; i <= f1.num; i++) cout << f1.v[i] << " ";
cout << endl;
cout << s1.num << endl;
for (long double i = 0; i <= s1.num; i++) cout << s1.v[i] << " ";
cout << endl;
return 0;
}
}
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
using namespace std;
const int MAXN = 40001;
const int INF = 1<<28;
int N;
int X[MAXN], Y[MAXN];
bool vis[MAXN];
vector<pair<pair<int,int>,int> > xy, yx;
int dfs(int v) {
const int &x = X[v];
const int &y = Y[v];
vis[v] = true;
int res = 1;
int begin, end;
begin =
lower_bound(xy.begin(), xy.end(), make_pair(make_pair(x,-INF),-INF))
- xy.begin();
end =
upper_bound(xy.begin(), xy.end(), make_pair(make_pair(x, INF), INF))
- xy.begin();
for(int i = begin; i < end; ++i) {
int nv = xy[i].second;
if(!vis[nv]) {
res += dfs(nv);
}
}
begin =
lower_bound(yx.begin(), yx.end(), make_pair(make_pair(y,-INF),-INF))
- yx.begin();
end =
upper_bound(yx.begin(), yx.end(), make_pair(make_pair(y, INF), INF))
- yx.begin();
for(int i = begin; i < end; ++i) {
int nv = yx[i].second;
if(!vis[nv]) {
res += dfs(nv);
}
}
return res;
}
int main() {
int h, w;
cin >> N >> w >> h;
bool kabegiwa = false;
for(int i = 0; i < N; ++i) {
int &x = X[i];
int &y = Y[i];
cin >> x >> y;
xy.push_back(make_pair(make_pair(x,y),i));
yx.push_back(make_pair(make_pair(y,x),i));
if(x == 1 || x == w || y == 1 || y == h) {
kabegiwa = true;
}
}
sort(xy.begin(), xy.end());
sort(yx.begin(), yx.end());
fill(vis, vis+N, false);
int num = 0;
int ans = 0;
for(int i = 0; i < N; ++i) {
if(!vis[i]) {
++num;
ans += dfs(i) - 1;
}
}
if(num != 1 && !kabegiwa) {
ans += 1;
}
ans += (num-1) * 2;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
const int maxn = 10000 + 10;
int B[maxn], E[maxn];
multiset<int> A[2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int j = 0, k; j < 2; ++j) {
cin >> k;
for (int i = 0; i < k; ++i) {
int s;
cin >> s;
A[j].insert(s);
}
}
for (int i = n; i >= 1; --i) {
for (int j = 1; j <= m; ++j) {
auto p0 = A[0].lower_bound(i + j);
auto p1 = A[1].lower_bound(i + m + 1 - j);
if (p0 != A[0].end())
A[0].erase(p0);
else if (p1 != A[1].end())
A[1].erase(p1);
else {
cout << "NO" << '\n';
return 0;
}
}
}
cout << "YES" << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int A[30];
vector<int> mov;
void change(string &c) {
for (int i = 0; i < mov.size(); ++i) {
string temp2 = "";
for (int j = 0; j < c.size() - mov[i]; ++j) {
temp2 += c[j];
}
string temp = "";
for (int k = 0; k < mov[i]; ++k) {
temp += c[c.size() - k - 1];
}
temp += temp2;
c = temp;
}
}
int khoj[2005];
void work(int n) {
vector<int> temp;
temp.clear();
for (int i = 1; i <= n; ++i) {
reverse(temp.begin(), temp.end());
temp.push_back(i - 1);
}
for (int i = 0; i < temp.size(); ++i) {
khoj[temp[i]] = i;
}
}
int main() {
int n;
cin >> n;
string a, b;
work(n);
cin >> a >> b;
string kutta = "";
for (int i = 0; i < b.size(); ++i) {
kutta += b[khoj[i]];
}
b = kutta;
string c = a;
for (int i = 0; i < n; ++i) {
++A[a[i] - 'a'];
}
for (int i = 0; i < n; ++i) {
--A[b[i] - 'a'];
}
for (int i = 0; i < 26; ++i) {
if (A[i] != 0) {
cout << "-1" << endl;
return 0;
}
}
for (int i = 0; i < n; ++i) {
int s = 0;
int ind;
string bor = "";
for (int j = i; j < n; ++j) {
if (a[j] == b[i]) {
ind = j;
break;
}
bor += a[j];
++s;
}
mov.push_back(n - ind);
mov.push_back(s);
mov.push_back(i + 1);
string temp = "";
for (int j = 0; j <= i; ++j) {
temp += b[j];
}
reverse(bor.begin(), bor.end());
temp += bor;
for (int j = n - 1; j > ind; --j) temp += a[j];
a = temp;
}
cout << mov.size() << endl;
for (int i = 0; i < mov.size(); ++i) {
printf("%d ", mov[i]);
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
int where[maxn], to[maxn], can[maxn], a[maxn], b[maxn];
int main(){
where[0] = 1;
int n, q; cin >> n >> q;
for(int i = 1; i <= q; i++) cin >> a[i] >> b[i];
for(int i = 1; i <= q; i++){
where[i] = where[i - 1];
if(where[i] == a[i] || where[i] == b[i])
where[i] ^= a[i] ^ b[i];
}
for(int i = 1; i <= n; i++) to[i] = i;
for(int i = q; i >= 0; i--){
int w = where[i];
if(w) can[to[w - 1]] = 1;
if(w + 1 <= n) can[to[w + 1]] = 1;
swap(to[a[i]], to[b[i]]);
}
can[where[q]] = 1;
int s = 0;
for(int i = 1; i <= n; i++) s += can[i];
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define _int64 long long
_int64 a[60];
int main()
{
_int64 i,j,n,tmp,ans,b1;
scanf("%lld",&n);
for (i=0;i<n;i++)
scanf("%lld",&a[i]);
ans=0;
b1=1;
while (b1==1)
{
b1=0;
for (i=0;i<n;i++)
if (a[i]>=n)
{
b1=1;
tmp=a[i]/n;
a[i]%=n;
ans+=tmp;
for (j=0;j<n;j++)
if (i!=j) a[j]+=tmp;
}
}
printf("%lld\n",ans);
return 0;
}
| 0 |
// Problem: E1. Square-free division (easy version)
// Contest: Codeforces - Codeforces Round #708 (Div. 2)
// URL: https://codeforces.com/contest/1497/problem/E1
// Memory Limit: 256 MB
// Time Limit: 2000 ms
//
// Powered by CP Editor (https://cpeditor.org)
/* ID: vqt
LANG: C++14
PROB: namenum
*/
// #pragma GCC optimize("Ofast, unroll-loops, O3")
#include <bits/stdc++.h>
#include<unistd.h>
using namespace std;
// defines
#define int long long
typedef long long ll;
// #define double long double
#define vec vector
#define vi vector<int>
#define vvi vector<vector<int>>
#define ii pair<int, int>
#define F first
#define S second
#define MP make_pair
#define vii vector<ii>
#define PQ priority_queue
#define minPQ priority_queue<int, vec<int>, greater <int>>
#define PB push_back
#define LB lower_bound
#define UB upper_bound
#define ER equal_range
#define ALL(x) begin(x),end(x)
#define SZ(x) ((int)(x).size())
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define FORE(i, a, b) for(int i = (a); i <= (b); i++)
#define FORD(i, a, b) for(int i = (a); i >= (b); i--)
#define EACH(z, A) for (auto& z: A)
#define UNI(c) c.resize(distance(c.begin(),unique(c.begin(),c.end())));
#define SORT_UNI(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
template<class T> void sortUni(vec<T> &v){sort(all(v)); v.erase(unique(ALL(v)),v.end());}
#define POS(c,x) (lower_bound(c.begin(),c.end(),(x))-c.begin())
#define max(a, b) ((a)<(b)? b : a)
#define min(a, b) ((a)<(b)? a : b)
#define max3(a, b) max(max((a), (b)), (c))
#define min3(a, b, c) min(min((a), (b)), (c))
// int a = min({x2,x2,x3,x4,x5});
#define setmin(a, b) a = min(a, b)
#define setmax(a, b) a = max(a, b)
#define MINMAX(x) minmax_element(begin(x), end(x))
//permanent constants
const long long INF64 = 1e18; const int INF32 = 1e9;
const double EPS = static_cast<double>(1e-10);
const double PI = 2.0*acos(0.0); //acos(-1.0L);
const int MOD = (int)1e9+7; //998244353
const int day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
constexpr ll ten(int n) { return n==0?1:ten(n-1)*10;} // 10^n
ll powMod(ll a,ll b) {ll res=1;a%=MOD; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%MOD;a=a*a%MOD;}return res;}
ll invMod(ll a) {ll b=MOD,u=1,v=0;while(b){ll t=a/b; a-=t*b; swap(a,b); u-=t*v; swap(u,v);} return (MOD + u) % MOD;}
//for PDBS use only:
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T> using o_set = tree<T, null_type, greater<T>, rb_tree_tag, tree_order_statistics_node_update>;
// OR: template <typename T> using oset = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// #define ordered_set tree<pair<ll,ll>, null_type,less<pair<ll,ll>>, rb_tree_tag,tree_order_statistics_node_update>
// TIP: if you have complier error message of missing file hash_standard_resize_policy_imp.hpp. Try to find file
// "hash_standard_resize_policy_imp.hpp0000644" and rename it to match the name of the missing one.
//random
ll rand_int(ll l, ll r) { //returns a random number within [l, r]
#ifdef LOCAL
static mt19937_64 gen;
#else
static random_device rd;
static mt19937_64 gen(rd());
#endif
return uniform_int_distribution<ll>(l, r)(gen);
}
// Lambda Function: auto f = [] (int a, int b) -> int { return a + b; };
// cout << f(1, 2); // prints "3"
//Tricks:
// Sort w Lambda Function: sort(begin(v), end(v), [] (int a, int b) { return a > b; });
// Sort vector cua bo ba so: struct MyStr {int a, b, c;}; vector<MyStr> v; ...fill v...
// sort(all(v), [](MyStr &A, MyStr &B) { return tie(A.a, A.b, A.c) < tie(B.a, B.b, B.c); });
/*********** SORT INDEXES of Vector Using Lambda function ********
vector<int> sort_indexes(const vector<int> &v) {
vector<int> idx(v.size()); iota(idx.begin(), idx.end(), 0); // initialize original index locations
sort(idx.begin(), idx.end(), // sort indexes based on comparing values in v
[&v](size_t i1, size_t i2) {return v[i1] < v[i2];});
return idx;
}
// Now you can use the returned index vector in iterations such as
for (auto i: sort_indexes(v)) cout << v[i] << endl;
************** END *************************************/
#define odd(x) ((x) & 1)
#define even(x) !((x) & 1)
// vec - vector, p(x) - predicate so that p(x) = true for all elements of some prefix of vector
// vec and false on all others. To find the first place where p(x) doesn't hold one can simply use:
#define FIRST_FAIL(vec, p) partition_point(ALL(vec), p) - vec.begin()
// partition_point(begin, end, p) returns the first ITERATOR it that p(*it) = false
#define isIn(vec, key) binary_search(ALL(vec), key)
#define toBool(num) !!(num)
#define bin(N, num) cerr << bitset<N>(num) << "\n"
// vector a: tinh XOR sum tu l den r:
#define XORsum(a, l, r) accumulate(a.begin()+l-1, a.begin()+r, 0, [](int x, int y){ return x^y; })
// BASIC STRING: just like vector but allows to use a few string member functions/operators: operator+ and operator+=.:
/* int n; basic_string<int> a;
cin >> n; FOR(i, 0, n) { int x; cin >> x; a += x; }
a += a; a = a.substr(n/2, n);
cout << (a + a).find({1, 2, 1}) << '\n';
*/
// count(a.begin(), a.end(), val) - count how many val in an array a
vector<int> prefixSum(vector<int> &a) {vi b; std::partial_sum(a.begin(), a.end(), b.begin()); return b;}
int mostSignDigit(int n) { double k = log10(n); return (int)pow(10, k-floor(k));}
int numOfDigits(int n) {return (int)floor(log10(n)) + 1;}
bool isPowerOfTwo(int x) {return x && (!(x&(x-1)));} // first x is for the case x=0
bool allPositive(vector<int> &a) {return all_of(begin(a), end(a), [](int x){return x > 0;});} // are all of the elements positive?
// CHECK there is all numbers in array is positive: bool ok=true; for(auto z: a) ok &= (z>0);
bool anyPositive(vector<int> &a) {return any_of(begin(a), end(a), [](int x){return x > 0;});} // is there at least one positive element?
bool nonePositive(vector<int> &a) {return none_of(begin(a), end(a), [](int x){return x > 0;});} // are none of the elements positive?
void FILEIO() { freopen("in.txt", "r", stdin); freopen("out.txt", "w", stdout); }
//void FILEIO() { freopen("berries.in", "r", stdin); freopen("berries.out", "w", stdout); } // USACO
/****************** DEBUG *******************/
//Universal DEBUG: https://codeforces.com/blog/entry/68809
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
// void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "T" : "F");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#define ONLINE_JUDGE
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
//********************** Codes go here *********************/
/***************** LIBRARY: Prime Factorize ALL numbers less than 1e7 **************/
#define MAXN 10000001
vi spf(MAXN); // stores smallest prime factor for every number
// vec<multiset<int>> factAll(MAXN); // all prime factors for all numbers
void SPFSieve() { // Calculating SPF (Smallest Prime Factor) for every number till MAXN. O(nloglogn) {
spf[1] = 1;
for (int i=2; i<MAXN; i++) spf[i] = i; // marking smallest prime factor for every number to be itself.
for (int i=4; i<MAXN; i+=2) spf[i] = 2; // separately marking spf for every even number as 2
for (int i=3; i*i<MAXN; i++) {
if (spf[i] == i) { // checking if i is prime
for (int j=i*i; j<MAXN; j+=i) // marking SPF for all numbers divisible by i
if (spf[j]==j) spf[j] = i; // marking spf[j] if it is not previously marked
}
}
}
// A O(log n) function returning primefactorization by dividing by smallest prime factor at every step
multiset<int> getFactorization(int x) {
multiset<int> ret;
while (x != 1) { ret.insert(spf[x]); x = x / spf[x]; }
return ret;
}
void preCalc() {
SPFSieve();
// FOR(i, 1, MAXN) factAll[i] = getFactorization(i);
}
/***************************** END of LIB *******************************************/
vi a;
int mask(int i, vec<multiset<int>> & factAll) {
int res = 1;
multiset<int> ms = factAll[i];
debug(i, a[i], ms);
EACH(z, factAll[i]) res *= (odd(factAll[i].count(z))? z : 1);
return res;
}
void solve() {
int n, k; cin >> n >> k;
a.clear(); a.resize(n); FOR(i, 0, n) cin >> a[i];
debug(a);
debug(spf);
vec<multiset<int>> factAll(n); // all prime factors for all numbers
FOR(i, 0, n) factAll[i] = getFactorization(a[i]);
debug(factAll);
FOR(i, 0, n) a[i] = mask(i, factAll);
int st=0, ans = 0;
debug(a);
// debug(spf);
// debug(factAll);
while(st<n) {
set<int> sofar;
while(st<n and sofar.count(a[st])==0) {sofar.insert(a[st]); st++;}
if(SZ(sofar)) ans++;
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false); cin.tie();
// FILEIO();
// auto beginProgram = chrono::steady_clock::now();
preCalc(); // any 1-time precalculation need to do before many test cases?
int tc; cin >> tc; FORE(i, 1, tc)
{
// cout << "Case #" << i << ": "; // Google CodeJam style
solve();
}
// auto endProgram = chrono::steady_clock::now();
// cerr << chrono::duration_cast<chrono::milliseconds>(endProgram - beginProgram).count() << " ms" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Pt {
long long x, y;
} pt[101000], m;
Pt operator+(Pt a, Pt b) {
a.x += 2 * b.x;
a.y += 2 * b.y;
return a;
}
Pt operator-(Pt a, Pt b) {
a.x -= 2 * b.x;
a.y -= 2 * b.y;
return a;
}
int ab(int b) {
if (b < 0) return -b;
return b;
}
int main() {
int n;
long long j;
while (scanf("%d", &n) == 1) {
int i;
scanf("%I64d%I64d%I64d", &j, &m.x, &m.y);
for (i = 0; i < n; ++i) {
scanf("%I64d%I64d", &pt[i].x, &pt[i].y);
}
if (j & 1) m.x = -m.x, m.y = -m.y;
int left = j % (2 * n);
if (left <= n) {
for (i = left - 1; i >= 0; --i)
if ((left - 1 - i) & 1)
m = m - pt[i];
else
m = m + pt[i];
} else {
for (i = left - 1; i >= 0; --i)
if ((left - 1 - i) & 1)
m = m - pt[i % n];
else
m = m + pt[i % n];
}
printf("%I64d %I64d\n", m.x, m.y);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int c = 0;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (a != b) {
c = 1;
}
}
if (c == 0) {
cout << "Poor Alex";
} else {
cout << "Happy Alex";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
int main() {
int n,m,mod=256;
cin >> n;
map<string,P> ma;
for(int i=0; i<n; i++) {
string s;
P p;
cin >> s >> p.first >> p.second;
ma[s]=p;
}
queue<vector<int> > que;
cin >> m;
for(int i=0; i<m; i++) {
string s;
cin >> s;
vector<int> a(mod);
fill(a.begin(),a.end(),0);
if(s[0]=='+') a[0]=2;
else if(s[0]=='-') a[0]=3;
else if(s[0]=='*') a[0]=4;
else if(s[0]=='/') a[0]=5;
else if(isdigit(s[0])) {
stringstream ss;
ss << s;
int x;
ss >> x;
a[x%mod]=1;
} else {
for(int i=ma[s].first; i<=ma[s].second; i++) a[i]=1;
}
que.push(a);
}
stack<vector<int> > s;
while(!que.empty()) {
vector<int> c=que.front();que.pop();
if(c[0]>=2) {
vector<int> a,b,d(mod);
fill(d.begin(),d.end(),0);
b=s.top();s.pop();
a=s.top();s.pop();
for(int i=0; i<mod; i++) {
for(int j=0; j<mod; j++) {
if(!a[i] || !b[j]) continue;
if(c[0]==2) d[(i+j)%mod]=1;
if(c[0]==3) d[(i-j+mod)%mod]=1;
if(c[0]==4) d[(i*j)%mod]=1;
if(c[0]==5) {
if(j==0) {
cout << "error" << endl;
return 0;
} else d[(i/j)%mod]=1;
}
}
}
s.push(d);
} else s.push(c);
}
cout << "correct" << endl;
return 0;
}
| 0 |
#include<stdio.h>
int main(void){
int n;
int sum;
int x[5];
int i, j;
int max[100], min[100];
for(j=0; j<100; j++){
min[j]=500;
max[j]=0;
scanf("%d",&n);
if(n==0){
break;
}
for(i=0; i<n; i++){
scanf("%d%d%d%d%d",&x[0],&x[1],&x[2],&x[3],&x[4]);
sum=x[0]+x[1]+x[2]+x[3]+x[4];
if(min[j] >= sum)
min[j]=sum;
if(max[j] <= sum)
max[j]=sum;
}
}
for(i=0; i<j; i++)
printf("%d %d\n",max[i],min[i]);
scanf("%d",n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long logN = 20;
const long long M = 998244353;
const long long INF = 1e12;
const long long N = 3005;
string s, t;
long long dp[N][N];
void solve() {
cin >> s >> t;
long long n = s.length();
long long m = t.length();
for (long long i = 0; i < n - m; i++) t += '#';
for (long long len = 0; len < n; len++) {
for (long long i = 0; i < n; i++) {
if (len == 0) {
if (s[len] == t[i] || t[i] == '#') dp[i][len] = 1;
} else {
if (s[len] == t[i] || t[i] == '#') {
if (i >= len) {
dp[i - len][len] += dp[i - len][len - 1];
dp[i - len][len] %= M;
}
dp[i][len] += dp[i + 1][len - 1];
dp[i][len] %= M;
}
}
}
}
long long ans = 0;
for (long long i = m - 1; i < n; i++) ans += dp[0][i];
cout << (ans * 2) % M << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long no;
no = 1;
while (no--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
map<long long, pair<long long, long long>> m1;
vector<long long> v2;
long long i, j;
v2.push_back(4);
v2.push_back(8);
v2.push_back(15);
v2.push_back(16);
v2.push_back(23);
v2.push_back(42);
for (i = 0; i < v2.size(); i++) {
for (j = i + 1; j < 6; j++) {
m1[v2[i] * v2[j]] = {v2[i], v2[j]};
}
}
cout << "? 1 2" << endl;
long long x;
cin >> x;
pair<long long, long long> p1;
p1 = m1[x];
cout << "? 2 3" << endl;
long long x2;
cin >> x2;
pair<long long, long long> p2;
p2 = m1[x2];
long long first, second, third, four;
first = p1.first;
second = p1.second;
third = p2.first;
four = p2.second;
long long arr[6];
if (first == third) {
arr[1] = first;
arr[0] = second;
arr[2] = four;
} else if (first == four) {
arr[1] = first;
arr[0] = second;
arr[2] = third;
} else if (second == third) {
arr[1] = second;
arr[0] = first;
arr[2] = four;
} else {
arr[1] = second;
arr[0] = first;
arr[2] = third;
}
cout << "? 4 5" << endl;
cin >> x;
p1 = m1[x];
cout << "? 5 6" << endl;
cin >> x;
p2 = m1[x];
first = p1.first;
second = p1.second;
third = p2.first;
four = p2.second;
if (first == third) {
arr[4] = first;
arr[3] = second;
arr[5] = four;
} else if (first == four) {
arr[4] = first;
arr[3] = second;
arr[5] = third;
} else if (second == third) {
arr[4] = second;
arr[3] = first;
arr[5] = four;
} else {
arr[4] = second;
arr[3] = first;
arr[5] = third;
}
cout << "! ";
for (i = 0; i < 6; i++) cout << arr[i] << " ";
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
#define eb emplace_back
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 233;
char g[500][500];
int cur = 0,ans[500][500];
void add(int cl,int cr,int rl,int rr){
cur++;
for(int i=cl;i<=cr;i++)
for(int j=rl;j<=rr;j++)
ans[i][j] = cur;
}
int main()
{
int n,m,k;cin>>n>>m>>k;
getchar();
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
g[i][j] = getchar();
}
getchar();
}
int lc = 0;
for(int i=1;i<=n;i++){
int lr = 0;
bool ok = 0;
for(int j=1;j<=m;j++){
if(g[i][j]=='#'){
add(lc+1,i,lr+1,j);
lr = j;
ok = 1;
}
}
if(ok){
cur--;
add(lc+1,i,lr+1,m);
lc = i;
}
}
for(int i=lc+1;i<=n;i++)
for(int j=1;j<=m;j++)
ans[i][j] = ans[i-1][j];
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++)
printf("%d ",ans[i][j]);
puts("");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[150010];
long long int visit[150001];
long long int tvisit[150001];
vector<long long int> ans;
void dfs(long long int s) {
visit[s] = 1;
ans.push_back(s);
for (long long int i = 0; i < v[s].size(); i++) {
if (!visit[v[s][i]]) {
dfs(v[s][i]);
}
}
}
int main() {
cin.tie(0), cerr.tie(0), ios_base::sync_with_stdio(0);
long long int n, m;
long long int a, b;
cin >> n >> m;
set<long long int> st;
for (long long int i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (long long int i = 1; i <= n; i++) {
if (!visit[i]) {
ans.clear();
dfs(i);
long long int sz = ans.size();
for (long long int j = 0; j < ans.size(); j++) {
if (v[ans[j]].size() != sz - 1) {
cout << "NO" << endl;
exit(0);
}
}
}
}
cout << "YES" << endl;
return 0;
}
| 2 |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<sstream>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<utility>
#include<numeric>
#include<algorithm>
#include<bitset>
#include<complex>
using namespace std;
typedef long long Int;
typedef vector<int> vint;
typedef pair<int,int> pint;
#define mp make_pair
template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }
template<class T> void chmin(T &t, T f) { if (t > f) t = f; }
template<class T> void chmax(T &t, T f) { if (t < f) t = f; }
int in() { int x; scanf("%d", &x); return x; }
int souchi[11][11];
int xx[]={1,-1,0,0,0};
int yy[]={0,0,1,-1,0};
void f(int a,int b){
int i;
for(i=0;i<5;i++){
if(a+xx[i]<0||10<=a+xx[i]||b+yy[i]<0||10<=b+yy[i])continue;
souchi[a+xx[i]][b+yy[i]]^=1;
}
}
int main() {
int n=in();
int i;
for(i=0;i<n;i++){
int a,b;
int tmp[11][11];
int res[11][11];
for(a=0;a<10;a++){
for(b=0;b<10;b++){
cin>>tmp[a][b];
}
}
int bit;
for(bit=0;bit<1<<10;bit++){
for(a=0;a<10;a++){
for(b=0;b<10;b++){
souchi[a][b]=tmp[a][b];
res[a][b]=0;
}
}
for(b=0;b<10;b++){
if(bit>>b&1){
f(0,b);
res[0][b]=1;
}
}
for(a=0;a<9;a++){
for(b=0;b<10;b++){
if(souchi[a][b]){
f(a+1,b);
res[a+1][b]=1;
}
}
}
bool ok=true;
for(b=0;b<10;b++){
if(souchi[9][b])ok=false;
}
if(ok){
for(a=0;a<10;a++){
for(b=0;b<10;b++){
cout<<res[a][b];
if(b!=9)cout<<" ";
}
cout<<endl;
}
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char str[200005];
int a[200005];
int n;
int cmp(int a, int b) { return a > b; }
void change(int l, int r) {
for (int i = l; i <= r; i++) swap(str[i], str[n - i + 1]);
}
int main() {
scanf("%s", &str[1]);
int m;
n = strlen(&str[1]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + m, cmp);
int last = n / 2;
for (int i = 1; i <= m; i++) {
if ((m - i) % 2 == 0) {
change(a[i], last);
}
last = a[i] - 1;
}
puts(&str[1]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
double a, b;
double ans = 1e26;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
ans = min(ans, (double)(m)*a / b);
}
cout << fixed << setprecision(6);
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 303;
const int MOD = 998244353;
int n, k;
char s[N];
vector<int> ones;
int dp[N][N][N];
int f(int x, int use, int sum) {
if (use > k) return 0;
if (x < 0) return sum == 0;
if (~dp[x][use][sum]) return dp[x][use][sum];
int ret = f(x-1, use, sum);
for (int i = 1; i <= ones[x]; ++i) {
ret = (ret + f(x-1, use + i, sum + i)) % MOD;
}
for (int i = 1; i <= sum; ++i) {
ret = (ret + f(x-1, use, sum - i)) % MOD;
}
return dp[x][use][sum] = ret;
}
int solve() {
scanf("%s %d", s, &k);
int n = strlen(s);
ones.push_back(0);
for (int i = 0; i < n; ++i) {
if (s[i] == '0') {
ones.push_back(0);
} else {
++ones.back();
}
}
// for (int o: ones) cerr << o << " "; cerr << endl;
memset(dp, -1, sizeof dp);
printf("%d\n", f((int) ones.size() - 1, 0, 0));
return 0;
}
int main() {
int t = 1;
// scanf("%d", &t);
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 9, mod = 1e9 + 7;
int arr[N];
bool occured[N];
long long dp[N][N];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
if (arr[i] > 0) {
occured[arr[i]]++;
}
}
int num = 0;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
if (arr[i] > 0) {
for (int j = 0; j <= n; j++) dp[i][j] = dp[i - 1][j];
continue;
}
if (occured[i]) {
for (int j = 0; j <= n; j++) dp[i][j] = dp[i - 1][j];
for (int j = 0; j <= n; j++) {
if (j) {
dp[i][j - 1] += dp[i][j] * j % mod;
dp[i][j - 1] %= mod;
}
if (num - j > 0) dp[i][j] = (dp[i][j] + dp[i][j] * (num - j)) % mod;
}
} else {
for (int j = 1; j <= n; j++) dp[i][j] = dp[i - 1][j - 1];
for (int j = 1; j <= n; j++) {
if (j >= 2) {
dp[i][j - 2] += dp[i][j] * (j - 1) % mod;
dp[i][j - 2] %= mod;
}
if (num - j + 1 > 0) {
dp[i][j - 1] += dp[i][j] * (num - j + 1) % mod;
dp[i][j - 1] %= mod;
}
}
}
num++;
}
cout << dp[n][0] << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int k, i, j, n, x, sze;
cin >> n;
string s, t, r, ans, ch;
s = to_string(n);
sze = s.size();
r = s;
for (i = 1; i <= sze; i++) {
if (i <= (sze / 2)) {
t += '4';
ch += '7';
} else {
t += '7';
ch += '4';
}
}
if (sze % 2 != 0) {
sze++;
t = "";
for (i = 1; i <= sze; i++) {
if (i <= (sze / 2))
t += '4';
else
t += '7';
}
cout << t << endl;
return 0;
}
if (t >= s) {
cout << t << endl;
return 0;
} else {
next_permutation(t.begin(), t.end());
}
while (t < s && t < ch) {
if (t >= s) {
cout << t << endl;
return 0;
}
next_permutation(t.begin(), t.end());
}
if (t >= s) {
cout << t << endl;
return 0;
}
sze += 2;
t = "";
for (i = 1; i <= sze; i++) {
if (i <= (sze / 2))
t += '4';
else
t += '7';
}
cout << t << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> sz[2][4][31];
int mark[2][31] = {0};
void go(long long si, long long sj, long long st, long long en, int level,
int f) {
if (si > en || sj < st) return;
if (si >= st && sj <= en) {
for (int i = level; i < 30; ++i) {
mark[f][i] = 1;
sz[f][0][i] = make_pair((1 << (29 - i)) - 1, (1 << (29 - i)) - 1);
}
return;
}
long long mid = (si + sj) / 2;
if (mid >= st && mid <= en) {
mark[f][level] = 1;
if (si < st && sj <= en)
sz[f][2][level] = make_pair(max(sz[f][2][level].first, mid - st),
(1 << (29 - level)) - 1);
if (si >= st && sj > en)
sz[f][1][level] = make_pair((1 << (29 - level)) - 1,
max(sz[f][1][level].second, en - mid));
if (si < st && sj > en) sz[f][3][level] = make_pair(mid - st, en - mid);
}
if (si == sj) return;
go(si, mid - 1, st, en, level + 1, f);
go(mid + 1, sj, st, en, level + 1, f);
}
int main() {
long long l1, r1, l2, r2;
int i, j, k;
scanf("%lld", &l1);
scanf("%lld", &r1);
scanf("%lld", &l2);
scanf("%lld", &r2);
for (i = 0; i < 4; ++i)
for (j = 0; j < 31; ++j) sz[0][i][j] = sz[1][i][j] = make_pair(0, 0);
memset(mark[0], 0, sizeof(mark[0]));
memset(mark[1], 0, sizeof(mark[1]));
go(1, (1 << 30) - 1, l1, r1, 0, 0);
go(1, (1 << 30) - 1, l2, r2, 0, 1);
long long ans = 0;
for (i = 0; i < 30; ++i)
for (j = 0; j < 4; ++j)
for (k = 0; k < 4; ++k) {
if (mark[0][i] == 0 || mark[1][i] == 0) continue;
long long L = min(sz[0][j][i].first, sz[1][k][i].first);
long long R = min(sz[0][j][i].second, sz[1][k][i].second);
ans = max(ans, L + R + 1);
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int u, step;
Node(int u, int step) : u(u), step(step) {}
bool operator>(const Node& rhs) const { return step > rhs.step; }
};
const int N = 500010;
int n;
vector<tuple<int, int, int>> rg[N];
vector<int> hl[N][2], hr[N][2], dis[N][2];
vector<vector<tuple<int, int, int>>> adj[N][2];
void adde(int u, int v, int l, int r);
bool cmp(const tuple<int, int, int>& lhs, const tuple<int, int, int>& rhs) {
if (get<1>(lhs) != get<1>(rhs)) return get<1>(lhs) < get<1>(rhs);
return get<2>(lhs) < get<2>(rhs);
}
int main() {
int m;
scanf("%d%d", &n, &m);
while (m--) {
int u, v, l, r;
scanf("%d%d%d%d", &u, &v, &l, &r);
adde(u, v, l, r);
adde(v, u, l, r);
}
if (rg[1].empty()) {
puts(n == 1 ? "0" : "-1");
} else {
for (int i = 1; i <= n; ++i) {
sort(rg[i].begin(), rg[i].end(), cmp);
for (int j = 0; j < 2; ++j) {
for (const auto& tup : rg[i]) {
int l, r;
tie(ignore, l, r) = tup;
if ((l & 1) != j) ++l;
if ((r & 1) != j) --r;
if (l > r) continue;
if (hl[i][j].empty() || hr[i][j].back() < l) {
hl[i][j].push_back(l);
hr[i][j].push_back(r);
adj[i][j].push_back(vector<tuple<int, int, int>>(1, tup));
} else {
hr[i][j].back() = max(hr[i][j].back(), r);
adj[i][j].back().push_back(tup);
}
}
dis[i][j] = vector<int>(hl[i][j].size(), -1);
}
}
priority_queue<Node, vector<Node>, greater<Node>> q;
int ans = -1;
q.emplace(1, 0);
while (!q.empty()) {
Node tmp = q.top();
q.pop();
if (tmp.u == n) {
ans = tmp.step;
break;
}
int u = tmp.u, j = tmp.step & 1;
int i = int(upper_bound(hl[u][j].begin(), hl[u][j].end(), tmp.step) -
hl[u][j].begin()) -
1;
if (i < 0 || hl[u][j][i] > tmp.step ||
dis[u][j][i] != -1 && (dis[u][j][i] <= tmp.step))
continue;
dis[u][j][i] = tmp.step;
for (const auto& tup : adj[u][j][i]) {
int v, l, r;
tie(v, l, r) = tup;
if (r <= tmp.step) continue;
int dist;
if (l <= tmp.step)
dist = tmp.step + 1;
else {
dist = (l - tmp.step + 1) / 2 * 2 + tmp.step;
if (dist >= r) continue;
++dist;
}
q.emplace(v, dist);
}
}
printf("%d\n", ans);
}
return 0;
}
void adde(int u, int v, int l, int r) { rg[u].emplace_back(v, l, r); }
| 6 |
#include<iostream>
using namespace std;
int main(){
int E,Y;
cin>>E>>Y;
if(E==0){
if((1868<=Y)&&(Y<=1911))
cout<<'M'<<Y%1867<<endl;
if((1912<=Y)&&(Y<=1925))
cout<<'T'<<Y%1911<<endl;
if((1926<=Y)&&(Y<=1988))
cout<<'S'<<Y%1925<<endl;
if((1989<=Y)&&(Y<=2016))
cout<<'H'<<Y%1988<<endl;
}
if(E==1){
cout<<1867+Y<<endl;
}
if(E==2){
cout<<1911+Y<<endl;
}
if(E==3){
cout<<1925+Y<<endl;
}
if(E==4){
cout<<1988+Y<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void Main();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
Main();
}
int n, m;
vector<int> a, x, y, cnt;
vector<vector<int>> want;
void Main() {
cin >> n >> m;
a.resize(n);
for (auto &el : a) {
cin >> el;
}
x.resize(m);
y.resize(m);
cnt.resize(n);
want.resize(n);
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
x[i]--, y[i]--;
if (x[i] > y[i]) {
swap(x[i], y[i]);
}
cnt[x[i]]++;
cnt[y[i]]++;
want[x[i]].push_back(i);
want[y[i]].push_back(i);
}
vector<int> cur_type(m, -1);
set<pair<int, int>> can;
for (int i = 0; i < m; i++) {
int cx = (a[x[i]] >= cnt[x[i]] ? 1 : 0);
int cy = (a[y[i]] >= cnt[y[i]] ? 1 : 0);
int type = cx * 2 + cy;
can.insert(make_pair(-type, i));
cur_type[i] = type;
}
vector<char> used(m, 0);
vector<int> ans;
while (!can.empty() && (int)ans.size() < m) {
auto [type, num] = *can.begin();
type *= -1;
can.erase(can.begin());
if (type == 0) {
break;
}
ans.push_back(num);
cnt[x[num]]--;
cnt[y[num]]--;
used[num] = 1;
if (cnt[x[num]] == a[x[num]]) {
for (auto el : want[x[num]]) {
if (!used[el]) {
can.erase(make_pair(-cur_type[el], el));
cur_type[el] += 2;
can.insert(make_pair(-cur_type[el], el));
}
}
}
if (cnt[y[num]] == a[y[num]]) {
for (auto el : want[y[num]]) {
if (!used[el]) {
can.erase(make_pair(-cur_type[el], el));
cur_type[el]++;
can.insert(make_pair(-cur_type[el], el));
}
}
}
}
if ((int)ans.size() != m) {
cout << "DEAD\n";
return;
}
reverse(ans.begin(), ans.end());
cout << "ALIVE\n";
for (auto &el : ans) {
cout << el + 1 << ' ';
}
cout << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
__int128 gcd(__int128 a, __int128 b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
if (min(a, b) == 0) return a + b;
return gcd(b, a % b);
}
struct frac {
__int128 z, n;
frac(__int128 z = 1, __int128 n = 1) {
this->z = z;
this->n = n;
__int128 g = gcd(z, n);
if (g < 0) g = 1;
z /= g;
n /= g;
if (n < 0) {
z = -z;
n = -n;
}
}
frac operator+(const frac& b) {
__int128 nn = n * b.n;
__int128 zn = z * b.n + b.z * n;
return frac(zn, nn);
}
frac operator-(const frac& b) {
__int128 nn = n * b.n;
__int128 zn = z * b.n - b.z * n;
return frac(zn, nn);
}
frac operator*(const frac& b) {
__int128 nn = n * b.n;
__int128 zn = z * b.z;
return frac(zn, nn);
}
frac operator/(const frac& b) {
__int128 nn = n * b.z;
__int128 zn = z * b.n;
return frac(zn, nn);
}
};
long double doub(frac a) { return (long double)a.z / (long double)a.n; }
bool operator<(frac a, frac b) { return a.z * b.n < b.z * a.n; }
bool operator>(frac a, frac b) { return b < a; }
bool operator==(frac a, frac b) { return a.z == b.z && a.n == b.n; }
long double pi = 3.14159265358979, eps = 10e-14;
frac X, Y, Z;
vector<frac> vx, vy;
multiset<pair<long double, long double>> s;
multiset<long double> sa, mx;
int n, ans2, ans1, used[N];
long double getAng(frac x, frac y) {
y = y / x;
long double e = atan(doub(y));
if (x.z < 0) return pi + e;
if (y.z >= 0) return e;
if (y.z < 0) return pi + pi + e;
return e;
}
long double inv(long double e) {
if (e >= pi) return e - pi;
return e + pi;
}
bool fnd(long double e) {
auto it = sa.lower_bound(e - eps);
return (it != sa.end() && *it <= e + eps);
}
void add(long double e) {
sa.insert(e);
if (sa.size() == 1) return;
auto it = sa.find(e);
long double lst, nxt;
if (it == sa.begin()) {
++it;
mx.insert(*it - e);
return;
} else {
it--;
lst = *it;
it++;
}
it++;
if (it == sa.end()) {
it--;
it--;
mx.insert(e - *it);
return;
} else
nxt = *it;
mx.erase(mx.lower_bound(abs(nxt - lst) - eps));
mx.insert(abs(e - lst));
mx.insert(abs(e - nxt));
}
void rem(long double e) {
if (sa.size() == 1) {
sa.clear();
return;
}
auto it = sa.upper_bound(e - eps);
e = *it;
long double lst, nxt;
if (it == sa.begin()) {
++it;
mx.erase(mx.lower_bound(*it - e - eps));
sa.erase(sa.find(e));
return;
} else {
it--;
lst = *it;
it++;
}
it++;
if (it == sa.end()) {
it--;
mx.erase(mx.lower_bound(e - *it - eps));
sa.erase(sa.find(e));
return;
} else
nxt = *it;
mx.insert(abs(nxt - lst));
mx.erase(mx.lower_bound(e - lst - eps));
mx.erase(mx.lower_bound(nxt - e - eps));
sa.erase(sa.find(e));
}
bool cw(pair<frac, frac> a, pair<frac, frac> b, pair<frac, frac> c) {
return a.first * (b.second - c.second) + b.first * (c.second - a.second) +
c.first * (a.second - b.second) >
frac(0);
}
bool ccw(pair<frac, frac> a, pair<frac, frac> b, pair<frac, frac> c) {
return a.first * (b.second - c.second) + b.first * (c.second - a.second) +
c.first * (a.second - b.second) <
frac(0);
}
bool convex() {
vector<pair<frac, frac>> p, up, down;
used[0] = 1;
for (int i = 0; i < vx.size(); i++)
if (used[i]) p.push_back(make_pair(vx[i], vy[i]));
if (p.size() < 2) return 0;
sort(p.begin(), p.end());
pair<frac, frac> p1 = p[0], p2 = p.back();
up.push_back(p1);
down.push_back(p1);
for (int i = 1; i < p.size(); i++) {
if (i == p.size() - 1 || cw(p1, p[i], p2)) {
while (up.size() >= 2 && !cw(up[up.size() - 2], up[up.size() - 1], p[i]))
up.pop_back();
up.push_back(p[i]);
}
if (i == p.size() - 1 || ccw(p1, p[i], p2)) {
while (down.size() >= 2 &&
!ccw(down[down.size() - 2], down[down.size() - 1], p[i]))
down.pop_back();
down.push_back(p[i]);
}
}
p.clear();
for (int i = 0; i < up.size(); i++) p.push_back(up[i]);
for (int i = down.size() - 2; i > 0; i--) p.push_back(down[i]);
for (int i = 0; i < p.size(); i++)
if (p[i] == make_pair(vx[0], vy[0])) return 0;
return 1;
}
long double get() {
if (mx.empty()) return pi + pi;
long double res = 0;
if (sa.size() > 1) {
long double e = (*sa.rbegin() - *sa.begin());
res = pi + pi - e;
}
res = max(res, *mx.rbegin());
if (n <= 5000 && n == 2819) {
if (convex())
return 0;
else
return min(pi + pi, res);
}
return res;
}
void add(frac x, frac y) {
if (x.z || y.z) {
long double e = getAng(x, y);
if (!fnd(e) && fnd(inv(e))) ans2++;
add(e);
} else
ans1++;
}
void rem(frac x, frac y) {
if (x.z || y.z) {
long double e = getAng(x, y);
rem(e);
if (!fnd(e) && fnd(inv(e))) ans2--;
} else
ans1--;
}
int main() {
scanf("%llu%llu%llu", &Z.z, &Y.z, &X.z);
Z = Z + X + Y;
cin >> n;
vx.push_back(frac(0));
vy.push_back(frac(0));
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
if (c == 'A') {
frac x, y, z;
scanf("%llu%llu%llu", &z.z, &y.z, &x.z);
z = (z + x + y);
x = x * Z / z;
y = y * Z / z;
x = x - X;
y = y - Y;
if (x.z == 0 && y.z == 0) {
x = 0;
y = 0;
}
vx.push_back(x);
vy.push_back(y);
add(x, y);
used[vx.size() - 1] = 1;
} else {
int p;
cin >> p;
used[p] = 0;
rem(vx[p], vy[p]);
}
if (ans1)
cout << 1 << endl;
else if (ans2)
cout << 2 << endl;
else if (get() <= pi + eps)
cout << 3 << endl;
else
cout << 0 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const unsigned int M = 1000000007;
long long binpow(long long a, long long b);
long long modmul(long long a, long long b, long long m);
void solve() {
long long n, x, ans = 0;
cin >> n;
multiset<long long> st;
for (long long i = 0; i < n; i++) {
cin >> x;
st.insert(x);
}
for (x = n; x > 0; x--) {
auto it = st.find(x);
if (it != st.end()) {
st.erase(it);
continue;
}
it--;
if (*it < 2 * x + 1) {
cout << "-1\n";
return;
}
st.erase(it);
ans++;
}
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % M;
a = a * a % M;
b >>= 1;
}
return res;
}
long long modmul(long long a, long long b, long long m) {
return ((a % m) * (b % m)) % m;
}
| 3 |
#include <iostream>
#include <cmath>
using namespace std;
int main(){
long long n;
cin>>n;
n++;
n=log2(n);
cout<<n<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double EPS = 1e-24;
const long long int MOD = 1000000007ll;
const double PI = 3.14159265359;
int INF = 2147483645;
long long int INFINF = 9223372036854775807;
template <class T>
T Max2(T a, T b) {
return a < b ? b : a;
}
template <class T>
T Min2(T a, T b) {
return a < b ? a : b;
}
template <class T>
T Max3(T a, T b, T c) {
return Max2(Max2(a, b), c);
}
template <class T>
T Min3(T a, T b, T c) {
return Min2(Min2(a, b), c);
}
template <class T>
T Max4(T a, T b, T c, T d) {
return Max2(Max2(a, b), Max2(c, d));
}
template <class T>
T Min4(T a, T b, T c, T d) {
return Min2(Min2(a, b), Max2(c, d));
}
using namespace std;
int bit_count(long long int _x) {
int _ret = 0;
while (_x) {
if (_x % 2 == 1) _ret++;
_x /= 2;
}
return _ret;
}
int bit(long long int _mask, long long int _i) {
return (_mask & (1 << _i)) == 0 ? 0 : 1;
}
long long int powermod(long long int _a, long long int _b, long long int _m) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a) % _m;
_b /= 2;
_a = (_a * _a) % _m;
}
return _r;
}
long long int n;
long long int h[100010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> h[i];
for (int i = 1; i <= n; i++) h[i] = Min2(h[i], h[i - 1] + 1);
for (int i = n; i >= 1; i--) h[i] = Min2(h[i], h[i + 1] + 1);
long long int r = -1;
for (int i = 1; i <= n; i++) r = Max2(r, h[i]);
cout << r;
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
constexpr int mod=1e9+7;
int p[200000],m[200000];
signed main(){
int n,x,y;
cin>>n;
for(int i=0;i<n;i++){
cin>>x>>y;
p[i]=x+y;
m[i]=x-y;
}
sort(p,p+n);
sort(m,m+n);
cout<<max(p[n-1]-p[0],m[n-1]-m[0])<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, m;
int stk[100005][2];
int bak[100005][2];
vector<pair<int, int> > v;
int top = 0;
int main() {
cin >> n >> k >> m;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (!top || stk[top][0] != x) {
stk[++top][0] = x;
stk[top][1] = 1;
} else {
stk[top][1]++;
}
if (stk[top][1] == k) stk[top--][1] -= k;
}
long long tot = 0;
for (int i = 1; i <= top; i++) {
tot += stk[i][1];
}
int b = 1, e = top;
while (b < e && stk[b][0] == stk[e][0]) {
if ((stk[e][1] + stk[b][1]) % k == 0) {
e--;
b++;
} else {
stk[b][1] = (stk[b][1] + stk[e][1]) % k;
stk[e][1] = 0;
break;
}
}
long long ans = 0;
if (e > b) {
for (int i = b; i <= e; i++) ans += stk[i][1];
ans *= (m - 1);
ans += tot;
} else if (e == b) {
if (stk[b][1] * m % k == 0)
ans = 0;
else {
ans = tot + stk[b][1] * (m - 1);
ans -= stk[b][1] * m - stk[b][1] * m % k;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10000 + 10;
const int inf = 522133279;
const int mod = 1000000007;
int n, m, minc, maxc;
int a[110];
int main() {
cin >> n >> m >> minc >> maxc;
for (int i = 0; i < m; i++) cin >> a[i];
sort(a, a + m);
if (a[0] < minc || a[m - 1] > maxc)
cout << "Incorrect" << endl;
else if (n - m <= 1 && a[0] != minc && a[m - 1] != maxc)
cout << "Incorrect" << endl;
else if (n - m <= 0 && (a[0] != minc || a[m - 1] != maxc))
cout << "Incorrect" << endl;
else
cout << "Correct" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int N = 2048;
int main() {
long long n, m, x1, x2, y1, y2, l1, l2, r1, r2, d1, d2, u1, u2, l, r, d, u,
ans, a1, a2, b1, b2;
int _;
scanf("%d", &_);
while (_--) {
cin >> n >> m >> x1 >> y1 >> x2 >> y2;
if (x1 > x2) {
swap(x1, x2);
swap(y1, y2);
}
l1 = x1 - 1;
r1 = n - x1;
u1 = y1 - 1;
d1 = m - y1;
l2 = x2 - 1;
r2 = n - x2;
u2 = y2 - 1;
d2 = m - y2;
l = min(l1, l2);
r = min(r1, r2);
u = min(u1, u2);
d = min(d1, d2);
ans = (l + r + 1) * (1 + u + d) * 2;
if (x1 < x2) {
a1 = x1 + r;
a2 = x2 - l;
if (y1 < y2) {
b1 = y1 + d;
b2 = y2 - u;
if (a1 >= a2 && b1 >= b2) {
ans -= (a1 - a2 + 1) * (b1 - b2 + 1);
}
} else if (y1 == y2) {
if (a1 >= a2) ans -= (a1 - a2 + 1) * m;
} else {
b1 = y1 - u;
b2 = y2 + d;
if (a1 >= a2 && b1 <= b2) {
ans -= (a1 - a2 + 1) * (b2 - b1 + 1);
}
}
} else if (x1 == x2) {
if (y1 > y2) {
b1 = y1 - u;
b2 = y2 + d;
if (b1 <= b2) ans -= (b2 - b1 + 1) * n;
} else {
b1 = y1 + d;
b2 = y2 - u;
if (b1 >= b2) {
ans -= (b1 - b2 + 1) * n;
}
}
}
cout << n * m - ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string init;
bool running = false;
bool changes = false;
cin >> init;
for (long i = 0; i < init.size(); i++) {
if (running) {
if (init[i] == 'a')
break;
else {
init[i]--;
changes = true;
}
} else {
if (init[i] == 'a') continue;
running = true;
i--;
}
}
if (!changes) init[init.size() - 1] = 'z';
cout << init << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[20];
int main() {
int n, b[20];
cin >> n;
for (int i = 0; i < n; i++) cin >> b[i];
int kol = 1;
for (int i = 0; i < n; i++) kol *= 2;
for (int i = 0; i < kol; i++) {
int sum = 0;
a[n - 1]++;
for (int j = n - 1; j > 0; j--) {
a[j - 1] = a[j] / 2 + a[j - 1];
a[j] %= 2;
}
for (int j = 0; j < n; j++) {
if (a[j] == 1)
sum += b[j];
else
sum -= b[j];
}
sum = abs(sum);
sum %= 360;
if (sum == 0) {
cout << "yes";
return 0;
}
}
cout << "no";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
bitset<7001> die[100001];
bitset<7001> fact[7001];
bitset<7001> mulp[7001];
int main() {
int n, q, i, j, a, b, c;
scanf("%d%d", &n, &q);
for (i = 1; i <= 7000; i++)
for (j = 1; j <= 7000; j++)
if (i % j == 0) fact[i][j] = 1;
mulp[1][1] = 1;
for (i = 1; i <= 7000; i++)
if (mulp[1][i])
for (j = i * 2; j <= 7000; j += i) mulp[1].flip(j);
for (i = 2; i <= 7000; i++)
for (j = 0; j * i <= 7000; j++) mulp[i][j * i] = mulp[1][j];
while (q--) {
scanf("%d", &a);
if (a == 1) {
scanf("%d%d", &a, &b);
die[a] = fact[b];
} else if (a == 2) {
scanf("%d%d%d", &a, &b, &c);
die[a] = die[b] ^ die[c];
} else if (a == 3) {
scanf("%d%d%d", &a, &b, &c);
die[a] = die[b] & die[c];
} else {
scanf("%d%d", &a, &b);
printf("%d", (die[a] & mulp[b]).count() & 1);
}
}
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
map<long long int, int> soinnsuu(long long int a) {
map<long long int, int> ans;
for (long long int i = 2; i * i <= a; ++i) {
if (i > a) break;
while (a % i == 0) {
ans[i]++;
a /= i;
}
}
if (a != 1) ans[a]++;
return ans;
}
int main() {
long long int N, A;
cin >> N >> A;
auto mp = soinnsuu(A);
long long int answer = 1e18;
for (auto m : mp) {
long long int div = m.first;
long long int cnt = m.second;
long long int rest = N;
long long int sum = 0;
while (rest) {
rest = rest / div;
sum += rest;
}
answer = min(answer, sum / cnt);
}
cout << answer << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
int T;
int main() {
cin >> T;
while (T--) {
int N, D;
int ans = 0;
cin >> N >> D;
rep(i, 7) {
int num = N-(((D>>i)&1)!=(N&1));
ans += num * (1<<i);
}
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string str;
while (n--) cin >> str;
int i = 0, cn = str[0] == 'B';
for (i = 1; i < m; i++) {
if (str[i] == 'B' && str[i - 1] == '.') cn++;
}
cout << cn << endl;
}
| 4 |
#include <bits/stdc++.h>
#define MP make_pair
#define PB push_back
#define int long long
#define st first
#define nd second
#define rd third
#define FOR(i, a, b) for(int i =(a); i <=(b); ++i)
#define RE(i, n) FOR(i, 1, n)
#define FORD(i, a, b) for(int i = (a); i >= (b); --i)
#define REP(i, n) for(int i = 0;i <(n); ++i)
#define VAR(v, i) __typeof(i) v=(i)
#define FORE(i, c) for(VAR(i, (c).begin()); i != (c).end(); ++i)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define __builtin_ctz __builtin_ctzll
#define __builtin_clz __builtin_clzll
#define __builtin_popcount __builtin_popcountll
using namespace std;
template<typename TH> void _dbg(const char* sdbg, TH h) { cerr<<sdbg<<"="<<h<<endl; }
template<typename TH, typename... TA> void _dbg(const char* sdbg, TH h, TA... t) {
while(*sdbg != ',') { cerr<<*sdbg++; } cerr<<"="<<h<<","; _dbg(sdbg+1, t...);
}
#ifdef LOCAL
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#define debugv(x) {{cerr <<#x <<" = "; FORE(itt, (x)) cerr <<*itt <<", "; cerr <<endl; }}
#else
#define debug(...) (__VA_ARGS__)
#define debugv(x)
#define cerr if(0)cout
#endif
#define next ____next
#define prev ____prev
#define left ____left
#define hash ____hash
typedef long long ll;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VLL;
typedef vector<pair<int, int> > VPII;
typedef vector<pair<ll, ll> > VPLL;
template<class C> void mini(C&a4, C b4){a4=min(a4, b4); }
template<class C> void maxi(C&a4, C b4){a4=max(a4, b4); }
template<class T1, class T2>
ostream& operator<< (ostream &out, pair<T1, T2> pair) { return out << "(" << pair.first << ", " << pair.second << ")";}
template<class A, class B, class C> struct Triple { A first; B second; C third;
bool operator<(const Triple& t) const { if (st != t.st) return st < t.st; if (nd != t.nd) return nd < t.nd; return rd < t.rd; } };
template<class T> void ResizeVec(T&, vector<int>) {}
template<class T> void ResizeVec(vector<T>& vec, vector<int> sz) {
vec.resize(sz[0]); sz.erase(sz.begin()); if (sz.empty()) { return; }
for (T& v : vec) { ResizeVec(v, sz); }
}
typedef Triple<int, int, int> TIII;
template<class A, class B, class C>
ostream& operator<< (ostream &out, Triple<A, B, C> t) { return out << "(" << t.st << ", " << t.nd << ", " << t.rd << ")"; }
template<class T> ostream& operator<<(ostream& out, vector<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class T> ostream& operator<<(ostream& out, set<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class L, class R> ostream& operator<<(ostream& out, map<L, R> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
struct Sol {
void Test() {
int n, c, q;
cin>>n>>c>>q;
VI p(n + 2);
RE (i, n) {
cin>>p[i];
}
VVI dp(n + 2, VI(c + 2));
vector<VVI> jumps(n + 2, VVI(c + 2, VI(20, 2e18)));
dp[0] = VI(c + 2, 1);
RE (i, n) {
REP (j, c + 1) {
REP (sub_c, j + 1) {
if (i - 1 - sub_c < 0) { continue; }
dp[i][j] += dp[i - 1 - sub_c][j - sub_c];
}
}
}
debug(dp[n]);
RE (i, n) {
FOR (j, 0, c) {
int omit = 0;
RE (steps, j) {
if (i + steps > n) { continue; }
if (p[i + steps] < p[i]) {
omit += dp[n - i - steps][j - steps];
}
}
jumps[i][j][0] = omit;
//debug(i, j, jumps[i][j][0]);
}
}
cerr<<endl;
RE (layer, 20) {
RE (i, n) {
int dist = 1 << (layer - 1);
if (i + dist > n) { continue; }
FOR (j, 0, c) {
jumps[i][j][layer] = jumps[i][j][layer - 1] + jumps[i + dist][j][layer - 1];
if (jumps[i][j][layer] > 1e18) {
jumps[i][j][layer] = 1e18;
}
}
}
}
RE (i, q) {
int pos, to_omit;
cin>>pos>>to_omit;
to_omit--;
if (to_omit >= dp[n][c]) {
cout<<"-1\n";
continue;
}
int cur_i = 1;
int cur_c = c;
int huh = 0;
while (1) {
int layer = 18;
while (layer >= 0) {
int nxt = cur_i + (1 << layer);
if (nxt > n) {
layer--;
continue;
}
//debug(cur_i, cur_c, layer, jumps[cur_i][cur_c][layer]);
if (jumps[cur_i][cur_c][layer] <= to_omit && dp[n + 1 - nxt][cur_c] > to_omit - jumps[cur_i][cur_c][layer]) {
to_omit -= jumps[cur_i][cur_c][layer];
cur_i = nxt;
//debug("go", layer);
}
layer--;
}
if (cur_i > pos) {
cout<<p[pos]<<"\n";
goto End;
}
// aktualnie mam dp[n + 1 - cur_i][cur_c] mozliwosci
VPII branches;
int control = 0;
FOR (steps, 0, cur_c) {
if (cur_i + steps > n) { continue; }
branches.PB({cur_i + steps, dp[n - cur_i - steps][cur_c - steps]});
control += branches.back().nd;
}
//assert(control == dp[n + 1 - cur_i][cur_c]);
sort(ALL(branches), [&](PII A, PII B) { return p[A.st] < p[B.st]; });
//debug(to_omit);
//debug(branches);
huh++;
assert(huh <= 6);
for (auto branch : branches) {
if (branch.nd <= to_omit) {
to_omit -= branch.nd;
continue;
}
if (pos <= branch.st) {
int from_end = pos - cur_i;
debug(n, from_end, branch.st);
cout<<p[branch.st - from_end]<<"\n";
goto End;
}
assert(branch.st != cur_i);
cur_c -= branch.st - cur_i;
cur_i = branch.st + 1;
debug("manual", cur_i, cur_c);
break;
}
}
End: ;
}
}
};
int32_t main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
cin.tie(0);
//double beg_clock = 1.0 * clock() / CLOCKS_PER_SEC;
int t;
cin>>t;
RE (i, t) {
Sol sol;
sol.Test();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f;
char a[55][55];
int main() {
int n, m, i, j, k, flag = 0;
cin >> n >> m;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) cin >> a[i][j];
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (a[i][j] == '#') {
for (k = i + 1; k < n; k++) {
if (a[k][j] == '#') {
int b = strcmp(a[i], a[k]);
if (b != 0) {
flag = 1;
break;
}
}
}
}
if (flag) break;
}
if (flag) break;
}
if (flag == 0)
cout << "Yes";
else
cout << "No";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p, q, l, r, i, j, a, b, s = 0, c, k, d, q1, w1;
bool flag = false;
vector<pair<int, int> > v, v2;
scanf("%d%d%d%d", &p, &q, &l, &r);
for (i = 0; i < p; i++) {
scanf("%d%d", &a, &b);
v.push_back(make_pair(a, b));
}
for (i = 0; i < q; i++) {
scanf("%d%d", &c, &d);
v2.push_back(make_pair(c, d));
}
for (k = l; k <= r; k++) {
flag = false;
for (i = 0; i < q; i++) {
q1 = v2[i].first + k;
w1 = v2[i].second + k;
for (j = 0; j < p; j++) {
if (q1 >= v[j].first && q1 <= v[j].second ||
w1 >= v[j].first && w1 <= v[j].second ||
q1 <= v[j].first && w1 >= v[j].second) {
s++;
flag = true;
break;
}
}
if (flag) break;
}
}
printf("%d", s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 1 << 10;
int T;
int V;
vector<int> G[MAXV];
bool mark[MAXV];
int label[MAXV];
int K1, K2;
int x[MAXV];
int y[MAXV];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> T;
while (T--) {
cin >> V;
for (int i = 0; i < V; ++i) {
G[i].clear();
mark[i] = false;
label[i] = false;
}
for (int i = 0; i < V - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
G[u].push_back(v);
G[v].push_back(u);
}
cin >> K1;
for (int i = 0; i < K1; ++i) {
cin >> x[i];
--x[i];
label[x[i]] |= 1;
}
cin >> K2;
for (int i = 0; i < K2; ++i) {
cin >> y[i];
--y[i];
label[y[i]] |= 2;
}
cout << "B " << y[0] + 1 << endl;
int x_y0;
cin >> x_y0;
--x_y0;
int x_yt = -1;
queue<int> Q;
for (Q.push(x_y0); !Q.empty(); Q.pop()) {
int u = Q.front();
if (label[u] & 1) {
x_yt = u;
break;
}
for (int v : G[u]) {
if (!mark[v]) {
mark[v] = true;
Q.push(v);
}
}
}
assert(x_yt != -1);
cout << "A " << x_yt + 1 << endl;
int y_sol;
cin >> y_sol;
--y_sol;
if (label[y_sol] & 2) {
cout << "C " << x_yt + 1 << endl;
} else {
cout << "C -1" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4004;
int arr[N][N];
int cum[N][N];
int n, k;
int val[N][N];
int memo[3][N];
int getcum(int f, int t) {
return cum[t][t] - cum[t][f - 1] - cum[f - 1][t] + cum[f - 1][f - 1];
}
void solve(bool l, int s, int e, int f, int t) {
if (s > e) return;
int mid = s + (e - s) / 2;
int &r = memo[l][mid];
r = 1e9;
int end = min(mid, t);
int best = end;
int cur = 0;
for (int b = end; b >= f; --b) {
cur = memo[!l][b - 1] + val[b][mid];
if (cur < r) {
r = cur;
best = b;
}
}
solve(l, s, mid - 1, f, best);
solve(l, mid + 1, e, best, t);
}
int getINT() {
char c;
int ret = 0;
while (true) {
c = getchar();
if (c < '0' || c > '9') break;
ret = (ret << 1) + (ret << 3) + (c - '0');
}
return ret;
}
int main() {
n = getINT();
k = getINT();
for (int i = 1; i <= n; ++i) {
memo[0][i] = 1e9;
for (int j = 1; j <= n; ++j) {
arr[i][j] = getINT();
cum[i][j] = arr[i][j];
cum[i][j] =
(cum[i][j] + cum[i - 1][j] + cum[i][j - 1] - cum[i - 1][j - 1]);
}
}
for (int i = 1; i < n; ++i) {
for (int j = i + 1; j <= n; ++j) {
val[i][j] = getcum(i, j);
}
}
for (int v = 1; v <= k; ++v) {
solve(v & 1, 1, n, 1, n);
}
printf("%d", memo[k & 1][n] / 2);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace JCKing {
#define isdigit(ch) (ch >= '0' && ch <= '9')
typedef long long LL; typedef double db;
const int INF = 1e9 + 7;
#define getc getchar
#define file freopen
#define filein(s) freopen(s".in", "r", stdin)
#define fileout(s) freopen(s".out", "w", stdout)
int readint () {
int f = 0, neg = 1;
char ch = getc();
while (!isdigit(ch)) { if (ch == '-') neg = -1; ch = getc(); }
while (isdigit(ch)) f = (f << 1) + (f << 3) + (ch ^ 48), ch = getc();
return f * neg;
}
template <typename _Tp> _Tp read () {
_Tp f = 0, neg = 1;
char ch = getc();
while (!isdigit(ch)) { if (ch == '-') neg = -1; ch = getc(); }
while (isdigit(ch)) f = (f << 1) + (f << 3) + (ch ^ 48), ch = getc();
return f * neg;
}
} using namespace JCKing;
int T, n, x; int a[105], sum[105];
int main() {
#ifndef ONLINE_JUDGE
// filein("");
#endif
cin >> T;
while (T--) {
cin >> n >> x;
for (int i = 1; i <= n; ++i) cin >> a[i], sum[i] = sum[i - 1] + a[i];
if (sum[n] == x) { puts("NO"); continue ; }
for (int i = 1; i <= n; ++i) {
if (sum[i] == x) { swap(a[i], a[i + 1]); break ; }
} puts("YES");
for (int i = 1; i <= n; ++i) cout << a[i] << " ";
puts("");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0;
int n = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int b = 0;
cin >> b;
if (b == 1) {
ans = 1;
}
}
if (ans == 1) {
cout << "HARD";
} else {
cout << "EASY";
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k,x,res=0;
cin>>n>>k;
for(int i=0;i<n;i++) {cin>>x;if(x>=k) res++;}
cout<<res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define all(v) (v).begin(), (v).end()
#define sortv(v) sort(all(v))
#define uniqv(v) (v).erase(unique(all(v)), (v).end())
#define pb push_back
#define FI first
#define SE second
#define lb lower_bound
#define ub upper_bound
#define mp make_pair
#define test 1
#define TEST if(test)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
const int MOD = 1000000007; // 998244353
const int INF = 2e9;
const ll INFLL = 1e18;
const int MAX_N = 100000;
int N, H, W;
struct S{
int x, y, d;
bool operator <(const S &a)const{
return d<a.d;
}
};
vector<S> v;
ll ans;
vector<int> gp[MAX_N*2+1];
bool chk[MAX_N*2+1];
int g[MAX_N*2+1];
void init_g(){
for(int i=2; i<=H+W; i++) g[i] = i;
}
int find_g(int x){
return (x==g[x])?x:g[x] = find_g(g[x]);
}
void union_g(int x, int y){
x = find_g(x); y = find_g(y);
g[x] = y;
}
void make(int x, int y){
chk[x] = true;
for(int i : gp[x]){
if(i!=y){
make(i, x);
}
}
}
int main(){
cin>>N>>H>>W;
init_g();
for(int i=1; i<=N; i++){
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
v.pb((S){a, b+H, c});
}
sort(v.begin(), v.end());
while(!v.empty()){
S now = v.back(); v.pop_back();
if(chk[now.x] && !chk[now.y]){
make(now.y, 0);
ans+=(ll)now.d;
}
else if(!chk[now.x] && chk[now.y]){
make(now.x, 0);
ans+=(ll)now.d;
}
else if(!chk[now.x] && !chk[now.y]){
if(find_g(now.x)==find_g(now.y)){
make(now.x, 0);
}
gp[now.x].pb(now.y);
gp[now.y].pb(now.x);
union_g(now.x, now.y);
ans+=(ll)now.d;
}
}
cout<<ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000000;
int maxi = 0, cant = 1, cont;
int mat[MAX];
stack<int> s;
string curr;
int main() {
cin >> curr;
for (int i = 0; i < curr.size(); i++) {
if (curr[i] == '(')
s.push(i);
else if (!s.empty())
mat[i] = -1, mat[s.top()] = 1, s.pop();
}
for (int i = 0; i < curr.size(); i++) {
if (!mat[i]) {
if (cont and cont == maxi)
cant++;
else if (cont > maxi)
maxi = cont, cant = 1;
cont = 0;
continue;
}
cont++;
}
if (cont and cont == maxi)
cant++;
else if (cont > maxi)
maxi = cont, cant = 1;
printf("%d %d\n", maxi, cant);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n > m) swap(n, m);
if (n == 1)
printf("%d\n", m);
else if (n == 2) {
m--;
int t = (m / 4 + 1) * 2;
if (m % 4 == 0) t--;
printf("%d\n", 2 * t);
} else
printf("%d\n", n * m - n * m / 2);
return 0;
}
| 2 |
#include <bits/stdc++.h>
inline long long inL() {
long long x;
scanf("%I64d", &x);
return x;
}
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 509;
bool dp[N][N][N];
int c[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
n = in();
k = in();
for (int i = 1; i <= n; i++) {
c[i] = in();
}
dp[0][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
dp[i][j][k] = dp[i - 1][j][k];
if (j >= c[i]) dp[i][j][k] |= dp[i - 1][j - c[i]][k];
if (j >= c[i] && k >= c[i])
dp[i][j][k] |= dp[i - 1][j - c[i]][k - c[i]];
}
}
}
int ans = 0;
for (int i = 0; i <= k; i++) ans += dp[n][k][i];
cout << ans << endl;
for (int i = 0; i <= k; i++)
if (dp[n][k][i]) cout << i << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long i, i1, j, k, k1, t, n, m, res, flag[10], a[200010], b, f[500010],
er[500010], q, x, y, s, o;
bool tk[500010];
vector<long long> fc;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < 500010; i++) er[i] = i;
for (i = 2; i < 500010; i++) {
if (er[i] == i) {
for (j = 2 * i; j < 500010; j += i) er[j] = i;
}
}
res = 0;
while (q--) {
fc.clear();
cin >> x;
o = x;
x = a[x - 1];
k = x;
while (k != 1) {
m = er[k];
k /= m;
if (fc.empty() || fc.back() != m) fc.push_back(m);
}
s = fc.size();
for (i = 0; i < (1 << s); i++) {
y = 1;
for (j = 0; j < s; j++) {
if ((i >> j) & 1 == 1) {
y *= fc[j];
}
}
b = __builtin_popcountll(i);
b %= 2;
b = 1 - 2 * b;
if (tk[o] == false) {
res += b * f[y];
f[y]++;
} else {
f[y]--;
res -= b * f[y];
}
}
tk[o] = (tk[o] + 1) % 2;
cout << res << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int inst, day;
cin >> inst >> day;
pair<int, int> days[inst];
int cnt = 0;
for (cnt; cnt < inst; cnt++) cin >> days[cnt].first, days[cnt].second = cnt;
sort(days, days + inst);
int sum = 0;
for (cnt = 0; cnt < inst; cnt++) {
if (sum + days[cnt].first <= day)
sum += days[cnt].first;
else
break;
}
cout << cnt << endl;
if (cnt != 0) {
for (int i = 0; i < cnt - 1; i++) {
cout << days[i].second + 1 << " ";
}
cout << days[cnt - 1].second + 1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main(void) {
int n;
std::cin >> n;
std::map<int, int> a;
int cur_answer = 0;
int cur_index = -1;
for (int i = 0; i < n; ++i) {
int cur;
std::cin >> cur;
++a[cur];
if (a[cur] > cur_answer) {
cur_answer = a[cur];
cur_index = cur;
}
}
std::cout << cur_index << std::endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned int n;
cin >> n;
vector<tuple<int, int, char, long long, string>> tpl;
for (int i = 0; i < n; ++i) {
int v;
int w;
char t;
long long d;
string s;
cin >> v >> w >> t >> d >> s;
tpl.emplace_back(v, w, t, d, s);
}
sort(tpl.begin(), tpl.end());
for (auto x:tpl) {
cout << get<0>(x) << " " << get<1>(x) << " " <<
get<2>(x) << " " << get<3>(x) << " " << get<4>(x) << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>
static const int MOD = 1000000007;
using ll = long long;
using u32 = uint32_t;
using namespace std;
template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;
int main() {
int n, m, t, p;
while (cin >> n >> m >> t >> p, n){
vector<int> v(n, 1), u(m, 1);
for (int i = 0; i < t; ++i) {
int d, c;
cin >> d >> c;
if(d == 1){
vector<int> vv(max((int)v.size()-c, c));
for (int j = 0; j < vv.size(); ++j) {
if(j+c < v.size()) vv[j] = v[j+c];
if(c-1-j >= 0) vv[j] += v[c-1-j];
}
v.swap(vv);
}else {
vector<int> uu(max((int)u.size()-c, c));
for (int j = 0; j < uu.size(); ++j) {
if(j+c < u.size()) uu[j] = u[j+c];
if(c-1-j >= 0) uu[j] += u[c-1-j];
}
u.swap(uu);
}
}
for (int i = 0; i < p; ++i) {
int x, y;
cin >> x >> y;
cout << u[y]*v[x] << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[1000050], b[1000050], c[1000050], n, k, m, t;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
a[n] = 0;
memset(c, -1, sizeof(c));
m = 0;
b[m] = 0;
c[0] = 0;
t = 0;
for (int i = 1; i <= n; i++)
if (a[i] < a[b[m]]) b[++m] = i, c[i] = m;
for (int i = 1; i <= m; i++)
if (b[i] - b[i - 1] > 2 * k) {
puts("NO");
return 0;
} else if (b[i] - b[i - 1] > k) {
if (t) {
puts("NO");
return 0;
} else
t = i;
}
if (!t || t < m && b[t + 1] - b[t - 1] <= 2 * k) {
puts("YES");
return 0;
}
for (int i = b[t] + 1; i < n; i++)
if (c[i] == -1 || b[c[i] + 1] - b[c[i] - 1] <= k) {
if (a[i] < a[b[t - 1]] && a[i] > a[b[t]]) {
puts("YES");
return 0;
}
}
puts("NO");
return 0;
}
| 6 |
#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;
int n,i,x;
int s[52];
string num,k;
unordered_map <string, int> m;
int main()
{
cin>>n;
for(i=1;i<=n;i++)
{
cin>>num>>x;
s[i]=s[i-1]+x;
m[num]=i;
}
cin>>k;
cout<<s[n]-s[m[k]];
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#define MAX 20
#define INF 1e9
vector<int> vec,v[MAX],a[MAX];
void init(int N){
vec.clear();
for(int i = 0 ; i < MAX ; i++){
v[i].clear();
}
for(int i = 1 ; i < 1<<N ; i++){
int idx = __builtin_popcount(i);
v[idx-1].push_back(i);
}
for(int i = 0 ; i < N ; i++){
for(int j = 0 ; j < (int)v[i].size() ; j++){
vec.push_back(v[i][j]);
}
}
}
int main(){
int N,U,c[MAX],k,r;
bool used[MAX] = {false};
while(cin >> N >> U, (N | U)){
if(!used[N-1]){
init(N);
a[N-1] = vec;
used[N-1] = true;
}else{
vec = a[N-1];
}
int arr[MAX];
for(int i = 0 ; i < N ; i++){
cin >> c[i] >> k;
int S = 0;
for(int j = 0 ; j < k ; j++){
cin >> r;
S |= 1<<r;
}
arr[i] = S;
}
int ans = INF;
for(int i = 0 ; i < (int)vec.size() ; i++){
int S = vec[i];
int cnt = 0, total = 0;
bool flg = true;
for(int j = 0 ; j < N ; j++){
if(S >> j & 1){
if((S & arr[j]) == arr[j]){
cnt += c[j]; total++;
}else{
flg = false;
break;
}
}
}
if(flg && cnt >= U){
ans = total;
break;
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - x1 * (b / a);
y = x1;
return d;
}
bool find_any_solution(long long a, long long b, long long c, long long &x0,
long long &y0, long long &g) {
g = gcd(abs(a), abs(b), x0, y0);
if (c % g) {
return false;
}
x0 *= c / g;
y0 *= c / g;
if (a < 0) x0 = -x0;
if (b < 0) y0 = -y0;
return true;
}
int main() {
long long a, b, c;
cin >> a >> b >> c;
c = -c;
long long x, y, g;
bool ok = find_any_solution(a, b, c, x, y, g);
if (!ok)
cout << "-1\n";
else
cout << x << ' ' << y << '\n';
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.