solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, b, k, ans, menor, i;
cin >> n >> b;
vector<int> V(n);
for (i = 0; i < n; i++) {
cin >> V[i];
}
menor = V[0];
ans = b;
for (i = 1; i < n; i++) {
k = b / menor;
ans = max(ans, b + k * (V[i] - menor));
menor = min(menor, V[i]);
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x, y, e, f, i, k, j, l, n, m, t;
int main() {
cin >> n >> x >> y;
if (n * y % 100 > 0)
f = n * y / 100 + 1;
else
f = n * y / 100;
if (x > f)
cout << 0;
else
cout << f - x;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
char c[MAXN][MAXN], c1[MAXN][MAXN];
void solve() {
int n, m, i, j, k, ans;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", &c[i][0]);
}
ans = 0;
for (j = 0; j < m; j++) {
for (i = 0; i < n; i++) {
c1[i][ans] = c[i][j];
}
int fl = 0;
for (i = 1; i < n; i++) {
if (strcmp(c1[i - 1], c1[i]) == 1) {
fl = 1;
break;
}
}
if (!fl) {
ans++;
}
}
ans = m - ans;
printf("%d\n", ans);
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct G {
int id, v, w;
G() {}
G(int ID, int V, int W) {
id = ID;
v = V;
w = W;
}
} g[220];
inline bool cmp(const G& A, const G& B) { return A.w < B.w; }
int n, ban[110], rv[4][4], cnt, vis[110], ans, sum, ph[20], num[20];
vector<G> to[5], e[20];
vector<int> path;
inline void dfs(int x) {
int i, j;
for (i = 0; i < to[x].size(); ++i) {
if (vis[to[x][i].id] || ban[to[x][i].id]) continue;
ph[rv[x][to[x][i].v]]++;
vis[to[x][i].id] = 1;
sum += to[x][i].w;
dfs(to[x][i].v);
}
path.push_back(x);
}
inline bool check() {
int i, j;
memset(num, 0, sizeof(num));
for (i = 1; i < path.size(); ++i) num[rv[path[i - 1]][path[i]]]++;
for (i = 0; i < 16; ++i)
if (num[i] > ph[i]) return false;
return true;
}
int main() {
int s, i, j, x, y, z, lim = 1 << 16, jud;
for (i = 0; i < 4; ++i)
for (j = i; j < 4; ++j) {
rv[i][j] = cnt;
cnt++;
}
for (i = 0; i < 4; ++i)
for (j = 0; j < i; ++j) rv[i][j] = rv[j][i];
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d%d%d", &x, &y, &z);
x--;
z--;
to[x].push_back(G(i, z, y));
to[z].push_back(G(i, x, y));
e[rv[x][z]].push_back(G(i, z, y));
}
for (i = 0; i < 16; ++i)
if (!e[i].empty()) sort(e[i].begin(), e[i].end(), cmp);
for (s = 0; s < lim; ++s) {
if ((s >> rv[0][0]) & 1) continue;
if ((s >> rv[1][1]) & 1) continue;
if ((s >> rv[2][2]) & 1) continue;
if ((s >> rv[3][3]) & 1) continue;
jud = 0;
memset(ban, 0, sizeof(ban));
for (i = 0; i < 16; ++i) {
if (!((s >> i) & 1)) continue;
if (e[i].empty())
jud = 1;
else
ban[e[i][0].id] = 1;
}
if (!jud) continue;
for (i = 0; i < 4; ++i) {
memset(vis, 0, sizeof(vis));
memset(ph, 0, sizeof(ph));
sum = 0;
path.clear();
dfs(i);
if (check()) ans = max(ans, sum);
}
}
printf("%d\n", ans);
}
| 8 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define inf 0x7F7F7F7F
using namespace std;
int n;
char s[59];
int f[2][109][309][309];
int mnk[309];
int main()
{
scanf("%s",s+1);
n=strlen(s+1);
for(int i=1;i<=n;i++)
s[i]-='0';
reverse(s+1,s+n+1);
memset(f,0x7F,sizeof(f));
memset(f[0][n],0,sizeof(f[0][n]));
for(int i=0;i<=n;i++)
{
memset(f[(i+1)&1],0x7F,sizeof(f[(i+1)&1]));
for(int j=0;j<=2*n;j++)
{
int nj=j-n;
memset(mnk,0x7F,sizeof(mnk));
for(int k=6*n;k>=0;k--)
{
int mnl=inf;
for(int l=6*n;l>=0;l--)
{
mnl=min(mnl,f[i&1][j][k][l]);
mnk[l]=min(mnk[l],f[i&1][j][k][l]);
if((nj+k-l+1000000)%10==s[i+1])
{
int tj=((nj+k-l)<0?(nj+k-l+1)/10-1:(nj+k-l)/10)+n;
f[(i+1)&1][tj][k][l]=min(f[(i+1)&1][tj][k][l],mnl+k+l);
f[(i+1)&1][tj][k][l]=min(f[(i+1)&1][tj][k][l],mnk[l]+k+l);
// printf("i:%d nj:%d j:%d k:%d l:%d f:%d\n",i+1,nj,tj-n,k,l,f[(i+1)&1][tj][k][l]);
}
}
}
}
}
int ans=inf;
for(int i=0;i<=5*n;i++)
for(int j=0;j<=5*n;j++)
ans=min(ans,f[(n+1)&1][n][i][j]);
printf("%d",ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-15;
const int maxn = 2000 + 10;
struct Line {
int a, b, c;
} e[maxn];
inline int dcmp(double x) {
if (fabs(x) < eps) return 0;
return x < 1 ? -1 : 1;
}
struct Point {
double x, y;
Point() {}
Point(double x, double y) : x(x), y(y) {}
Point operator*(const int& tmp) const { return Point(x * tmp, y * tmp); }
} inter;
int n, top;
double st[maxn];
long long ans;
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;
}
inline double Dot(Point A, Point B) { return A.x * B.x + A.y * B.y; }
inline double Length(Point A) { return sqrt(Dot(A, A)); }
inline double Cross(Point A, Point B) { return A.x * B.y - A.y * B.x; }
inline double Angle(Point A, Point B) {
double cos = Dot(A, B) / Length(A) / Length(B);
double sin = Cross(A, B) / Length(A) / Length(B);
return atan2(sin, cos);
}
inline Point Get_Inter(int l, int r) {
return Point((double)(e[l].b * e[r].c - e[l].c * e[r].b) /
(double)(e[l].a * e[r].b - e[l].b * e[r].a),
(double)(e[l].a * e[r].c - e[l].c * e[r].a) /
(double)(e[l].b * e[r].a - e[l].a * e[r].b));
}
inline bool On_left(Point A, Point B) {
return dcmp(A.x * B.y - A.y * B.x) > 0;
}
int main() {
if (fopen("D.in", "r") != NULL) {
freopen("D.in", "r", stdin);
freopen("D.out", "w", stdout);
}
n = read();
long long res = 0;
for (int i = 1; i <= n; i++) {
e[i].a = read(), e[i].b = read();
e[i].c = read(), e[i].c *= -1;
if (e[i].c == 0) res++, i--, n--;
}
if (res) res = (res * (res - 1) >> 1) * n;
for (int i = 1; i <= n; i++) {
top = 0;
Point v = Point(-e[i].b, e[i].a), tmp;
for (int j = 1; j <= n; j++) {
if (i == j) continue;
inter = Get_Inter(i, j);
tmp = Point(-e[j].b, e[j].a);
if (On_left(v, tmp) ^ On_left(v, inter))
st[++top] = Angle(tmp * -1, inter);
else
st[++top] = Angle(tmp, inter);
}
sort(st + 1, st + top + 1);
st[top + 1] = 100;
for (int j = 2, cnt = 1; j <= top + 1; j++)
if (dcmp(st[j] - st[j - 1]) != 0) {
ans += (long long)cnt * (cnt - 1) >> 1;
cnt = 1;
} else
cnt++;
}
printf("%I64d\n", (ans >> 1) + res);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline long long modpow(long long x, long long y, long long m = 1000000007ll) {
long long res = 1;
while (y) {
if (y & 1) {
res *= x;
res %= m;
}
x = x * x % m;
y /= 2;
}
return res;
}
long long mypow(long long x, long long y) {
long long res = 1;
while (y) {
if (y % 2) {
res *= x;
}
x = x * x;
y /= 2;
}
return res;
}
bool prime(long long x) {
if (!x || x == 1) {
return false;
}
for (long long i = 2; i * i <= x; i++) {
if (!(x % i)) {
return false;
}
}
return true;
}
inline long long gcd(long long x, long long y) {
if (!y) {
return x;
}
return gcd(y, x % y);
}
long long keta(long long x) {
long long ans = 0;
while (x) {
x /= 10;
ans++;
}
return ans;
}
long long bitketa(long long x) {
long long ans = 0;
while (x) {
x >>= 1;
ans++;
}
return ans;
}
long long ketasum(long long x) {
long long ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
inline long long lcm(long long x, long long y) {
long long ans = x / gcd(x, y) * y;
return ans;
}
long long twobeki(long long x) {
long long ans = 0;
while (1) {
if (!(x & 1)) {
ans++;
x >>= 1;
} else {
break;
}
}
return ans;
}
template <class T, class U>
inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U>
inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
void Yes() { cout << "Yes" << endl; }
void No() { cout << "No" << endl; }
void YES() { cout << "YES" << endl; }
void NO() { cout << "NO" << endl; }
long long kai(long long x, long long y) {
long long res = 1;
for (long long i = x - y + 1; i <= x; i++) {
res *= i;
res %= 1000000007ll;
}
return res;
}
long long comb(long long x, long long y) {
if (y > x) return 0;
return kai(x, y) * modpow(kai(y, y), 1000000007ll - 2) % 1000000007ll;
}
template <typename T>
class kaageSegTree {
protected:
unsigned long long n = 1, rank = 0;
std::vector<T> node;
T nodee;
virtual T nodef(const T &, const T &) const = 0;
public:
kaageSegTree(unsigned long long m, T init, T nodee) : nodee(nodee) {
while (n < m) {
n *= 2;
rank++;
}
node.resize(2 * n);
for (unsigned long long i = n; i < 2 * n; i++) node[i] = init;
}
kaageSegTree(const std::vector<T> &initvec, T nodee) : nodee(nodee) {
unsigned long long m = initvec.size();
while (n < m) {
n *= 2;
rank++;
}
node.resize(2 * n);
for (unsigned long long i = n; i < 2 * n; i++) {
if (i - n < m) node[i] = initvec[i - n];
}
}
virtual void update(long long i, T x) {
i += n;
node[i] = x;
while (i != 1) {
i >>= 1;
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
}
virtual T query(long long l, long long r) {
l += n;
r += n;
T ls = nodee, rs = nodee;
while (l < r) {
if (l & 1) {
ls = nodef(ls, node[l]);
l++;
}
if (r & 1) {
r--;
rs = nodef(node[r], rs);
}
l >>= 1;
r >>= 1;
}
return nodef(ls, rs);
}
virtual T operator[](const long long &x) { return node[n + x]; }
void fill(T x) { std::fill(node.begin(), node.end(), x); }
void print() {
for (long long i = 0; i < n; i++) std::cout << operator[](i) << " ";
std::cout << std::endl;
}
};
class RSQ : public kaageSegTree<long long> {
long long nodef(const long long &lhs, const long long &rhs) const {
return lhs + rhs;
}
public:
RSQ(long long size, const long long &def = 0)
: kaageSegTree<long long>(size, def, 0) {}
RSQ(const std::vector<long long> &initvec)
: kaageSegTree<long long>(initvec, 0) {}
};
class RMiQ : public kaageSegTree<long long> {
long long nodef(const long long &lhs, const long long &rhs) const {
return std::min(lhs, rhs);
}
public:
RMiQ(long long size, const long long &def = 0)
: kaageSegTree<long long>(size, def, (long long)(3e18)) {}
RMiQ(const std::vector<long long> &initvec)
: kaageSegTree<long long>(initvec, (long long)(3e18)) {}
};
class RMaQ : public kaageSegTree<long long> {
long long nodef(const long long &lhs, const long long &rhs) const {
return std::max(lhs, rhs);
}
public:
RMaQ(long long size, const long long &def = 0)
: kaageSegTree<long long>(size, def, -(long long)(3e18)) {}
RMaQ(const std::vector<long long> &initvec)
: kaageSegTree<long long>(initvec, -(long long)(3e18)) {}
};
template <typename T, typename U>
class IntervalSegTree : public kaageSegTree<T> {
protected:
using kaageSegTree<T>::n;
using kaageSegTree<T>::rank;
using kaageSegTree<T>::node;
using kaageSegTree<T>::nodef;
using kaageSegTree<T>::nodee;
std::vector<U> lazy;
std::vector<bool> lazyflag;
std::vector<long long> width;
virtual void lazyf(U &, const U &) = 0;
virtual void updf(T &, const U &, const unsigned long long &) = 0;
void eval(long long k) {
for (long long i = rank; i > 0; i--) {
long long nk = k >> i;
if (lazyflag[nk]) {
updf(node[2 * nk], lazy[nk], width[2 * nk]);
updf(node[2 * nk + 1], lazy[nk], width[2 * nk + 1]);
if (lazyflag[2 * nk])
lazyf(lazy[2 * nk], lazy[nk]);
else
lazy[2 * nk] = lazy[nk];
if (lazyflag[2 * nk + 1])
lazyf(lazy[2 * nk + 1], lazy[nk]);
else
lazy[2 * nk + 1] = lazy[nk];
lazyflag[2 * nk] = lazyflag[2 * nk + 1] = true;
lazyflag[nk] = false;
}
}
}
public:
IntervalSegTree(unsigned long long m, T init, T nodee)
: kaageSegTree<T>(m, init, nodee) {
lazy.resize(2 * n);
lazyflag.resize(2 * n);
width.resize(2 * n);
width[1] = n;
for (unsigned long long i = 2; i < 2 * n; i++) {
width[i] = width[i >> 1] >> 1;
}
}
IntervalSegTree(T nodee, const std::vector<T> &initvec)
: kaageSegTree<T>(initvec, nodee) {
lazy.resize(2 * n);
lazyflag.resize(2 * n);
width.resize(2 * n);
width[1] = n;
for (unsigned long long i = 2; i < 2 * n; i++) {
width[i] = width[i >> 1] >> 1;
}
}
void update(long long i, U x) {
i += n;
eval(i);
updf(node[i], x, width[i]);
if (lazyflag[i])
lazyf(lazy[i], x);
else {
lazyflag[i] = true;
lazy[i] = x;
}
while (i /= 2) node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
void update(long long l, long long r, U x) {
l += n;
r += n;
long long nl = l, nr = r;
while (!(nl & 1)) nl >>= 1;
while (!(nr & 1)) nr >>= 1;
nr--;
eval(nl);
eval(nr);
while (l < r) {
if (l & 1) {
updf(node[l], x, width[l]);
if (lazyflag[l])
lazyf(lazy[l], x);
else {
lazyflag[l] = true;
lazy[l] = x;
}
l++;
}
if (r & 1) {
r--;
updf(node[r], x, width[r]);
if (lazyflag[r])
lazyf(lazy[r], x);
else {
lazyflag[r] = true;
lazy[r] = x;
}
}
l >>= 1;
r >>= 1;
}
while (nl >>= 1) node[nl] = nodef(node[2 * nl], node[2 * nl + 1]);
while (nr >>= 1) node[nr] = nodef(node[2 * nr], node[2 * nr + 1]);
}
T query(long long l, long long r) {
l += n;
r += n;
eval(l);
eval(r - 1);
long long ls = nodee, rs = nodee;
while (l < r) {
if (l & 1) {
ls = nodef(ls, node[l]);
l++;
}
if (r & 1) {
r--;
rs = nodef(node[r], rs);
}
l >>= 1;
r >>= 1;
}
return nodef(ls, rs);
}
T operator[](const long long &x) {
eval(n + x);
return node[n + x];
}
T queryForAll() { return node[1]; }
};
class RAQRSQ : public IntervalSegTree<long long, long long> {
long long nodef(const long long &a, const long long &b) const {
return a + b;
}
void lazyf(long long &a, const long long &b) { a += b; }
void updf(long long &a, const long long &b, const unsigned long long &width) {
a += width * b;
}
public:
RAQRSQ(long long size, const long long &def = 0)
: IntervalSegTree<long long, long long>(size, def, 0) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
RAQRSQ(const std::vector<long long> &initvec)
: IntervalSegTree<long long, long long>((long long)0, initvec) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
};
class RAQRMiQ : public IntervalSegTree<long long, long long> {
long long nodef(const long long &a, const long long &b) const {
return std::min(a, b);
}
void lazyf(long long &a, const long long &b) { a += b; }
void updf(long long &a, const long long &b, const unsigned long long &width) {
a += b;
}
public:
RAQRMiQ(long long size, const long long &def = 0)
: IntervalSegTree<long long, long long>(size, def, (long long)(3e18)) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
RAQRMiQ(const std::vector<long long> &initvec)
: IntervalSegTree<long long, long long>((long long)(3e18), initvec) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
};
class RAQRMaQ : public IntervalSegTree<long long, long long> {
long long nodef(const long long &a, const long long &b) const {
return std::max(a, b);
}
void lazyf(long long &a, const long long &b) { a += b; }
void updf(long long &a, const long long &b, const unsigned long long &width) {
a += b;
}
public:
RAQRMaQ(unsigned long long size, const long long &def = 0)
: IntervalSegTree<long long, long long>(size, def, -(long long)(3e18)) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
RAQRMaQ(const std::vector<long long> &initvec)
: IntervalSegTree<long long, long long>(-(long long)(3e18), initvec) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
};
class RUQRSQ : public IntervalSegTree<long long, long long> {
long long nodef(const long long &a, const long long &b) const {
return a + b;
}
void lazyf(long long &a, const long long &b) { a = b; }
void updf(long long &a, const long long &b, const unsigned long long &width) {
a = width * b;
}
public:
RUQRSQ(long long size, const long long &def = 0)
: IntervalSegTree<long long, long long>(size, def, 0) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
RUQRSQ(const std::vector<long long> &initvec)
: IntervalSegTree<long long, long long>((long long)0, initvec) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
};
class RUQRMiQ : public IntervalSegTree<long long, long long> {
long long nodef(const long long &a, const long long &b) const {
return std::min(a, b);
}
void lazyf(long long &a, const long long &b) { a = b; }
void updf(long long &a, const long long &b, const unsigned long long &width) {
a = b;
}
public:
RUQRMiQ(long long size, const long long &def = 0)
: IntervalSegTree<long long, long long>(size, def, (long long)(3e18)) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
RUQRMiQ(const std::vector<long long> &initvec)
: IntervalSegTree<long long, long long>((long long)(3e18), initvec) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
};
class RUQRMaQ : public IntervalSegTree<long long, long long> {
long long nodef(const long long &a, const long long &b) const {
return std::max(a, b);
}
void lazyf(long long &a, const long long &b) { a = b; }
void updf(long long &a, const long long &b, const unsigned long long &width) {
a = b;
}
public:
RUQRMaQ(long long size, const long long &def = 0)
: IntervalSegTree<long long, long long>(size, def, -(long long)(3e18)) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
RUQRMaQ(const std::vector<long long> &initvec)
: IntervalSegTree<long long, long long>(-(long long)(3e18), initvec) {
for (long long i = n - 1; i > 0; i--)
node[i] = nodef(node[2 * i], node[2 * i + 1]);
}
};
template <class T>
class SegTree {
long long n;
vector<T> node;
T def;
function<T(T, T)> operation;
function<T(T, T)> update;
public:
SegTree(unsigned long long _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
node = vector<T>(n * 2, def);
}
SegTree(vector<long long> &initvec, function<T(T, T)> _operation,
function<T(T, T)> _update)
: operation(_operation), update(_update) {
n = 1;
while (n < initvec.size()) {
n *= 2;
}
node = vector<T>(n * 2, def);
for (long long i = n; i < n + initvec.size(); i++) {
node[i] = initvec[i - n];
}
for (long long i = n - 1; i >= 1; i--) {
node[i] = operation(node[i * 2], node[i * 2 + 1]);
}
}
void change(long long i, T x) {
i += n;
node[i] = update(node[i], x);
while (i >= 1) {
i >>= 1;
node[i] = operation(node[i * 2], node[i * 2 + 1]);
}
}
T query(long long l, long long r) {
l += n;
r += n;
T rx = def, lx = def;
while (l < r) {
if (l & 1) {
lx = operation(lx, node[l]);
l++;
}
if (r & 1) {
r--;
rx = operation(node[r], rx);
}
l >>= 1;
r >>= 1;
}
return operation(lx, rx);
}
T operator[](const long long &x) { return node[x + n]; }
void fill(T x) { std::fill(node.begin(), node.end(), x); }
void print() {
for (long long i = 0; i < n; i++) std::cout << operator[](i) << " ";
std::cout << std::endl;
}
};
class Union_Find {
vector<long long> par;
vector<long long> rankmy;
vector<long long> ookisa;
public:
Union_Find(long long size) {
par = vector<long long>(size);
rankmy = vector<long long>(size);
ookisa = vector<long long>(size);
for (long long i = 0; i < size; i++) {
par[i] = i;
ookisa[i] = 1;
}
}
long long find(long long x) {
if (par[x] == x) {
return x;
}
return par[x] = find(par[x]);
}
void unite(long long x, long long y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (rankmy[x] < rankmy[y]) {
par[x] = y;
ookisa[y] += ookisa[x];
ookisa[x] = 0;
} else {
par[y] = x;
ookisa[x] += ookisa[y];
ookisa[y] = 0;
if (rankmy[x] == rankmy[y]) {
rankmy[x]++;
}
}
}
long long size(long long i) {
i = find(i);
return ookisa[i];
}
bool same(long long x, long long y) { return find(x) == find(y); }
};
class BIT {
vector<long long> data;
long long size = 0;
public:
BIT(long long _size) {
data = vector<long long>(_size + 1);
size = _size;
}
void add(long long i, long long x) {
while (i <= size) {
data[i] += x;
i += i & -i;
}
}
long long sum(long long i) {
assert(i <= size);
long long s = 0;
while (i > 0) {
s += data[i];
i -= i & -i;
}
return s;
}
long long lower_bound(long long x) {
if (x <= 0) {
return 0;
} else {
long long i = 0;
long long r = 1;
while (r < size) r = r << 1;
for (long long len = r; len > 0; len = len >> 1) {
if (i + len < size && data[i + len] < x) {
x -= data[i + len];
i += len;
}
}
return i + 1;
}
}
};
long long perm[2000005];
void init_perm() {
perm[0] = 1;
for (long long i = 1; i <= 2000004; i++) {
perm[i] = perm[i - 1] * i % 1000000007ll;
}
}
long long nCk(long long x, long long y) {
if (y > x) {
return 0;
}
if (x < 0) {
return 0;
}
return perm[x] * modpow(perm[x - y], 1000000007ll - 2) % 1000000007ll *
modpow(perm[y], 1000000007ll - 2) % 1000000007ll;
}
double kyori(pair<long long, long long> f, pair<long long, long long> s) {
double ans = 0;
double t = fabs(f.first - s.first);
double y = fabs(f.second - s.second);
ans = sqrt(t * t + y * y);
return ans;
}
inline string stringmax(string &x, string &y) {
if (x.size() > y.size()) {
return x;
}
if (x.size() < y.size()) {
return y;
}
for (long long i = 0; i < x.size(); i++) {
if (x[i] > y[i]) {
return x;
}
if (x[i] < y[i]) {
return y;
}
}
return x;
}
struct edge {
long long to;
long long length;
edge(long long _to, long long _length) {
to = _to;
length = _length;
}
};
vector<long long> djkstra(vector<vector<edge>> &road, long long start) {
vector<long long> kyo(road.size(), (long long)(3e18));
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push({0, start});
kyo[start] = 0;
while (q.size()) {
long long x = q.top().second;
long long now = q.top().first;
q.pop();
if (kyo[x] < now) {
continue;
}
for (auto &i : road[x]) {
if (kyo[i.to] > now + i.length) {
kyo[i.to] = now + i.length;
q.push({kyo[i.to], i.to});
}
}
}
return kyo;
}
template <class T>
void change_to_unique(vector<T> &v) {
std::sort(v.begin(), v.end());
auto k = unique(v.begin(), v.end());
if (k != v.end()) v.erase(k, v.end());
}
long long t, gou;
long long dfs(vector<long long> &chi, vector<vector<edge>> &road, long long x,
long long par) {
long long cnt = 1;
if (road[x].size() > 1) {
cnt--;
}
for (auto &i : road[x]) {
if (i.to == par) {
continue;
}
cnt += dfs(chi, road, i.to, x);
}
return chi[x] = cnt;
}
void dfs2(vector<long long> &chi,
priority_queue<pair<pair<long long, long long>, long long>> &q,
vector<vector<edge>> &road, long long x, long long par,
long long kyo) {
gou += kyo;
if (road[x].size() > 1) {
gou -= kyo;
}
for (auto &i : road[x]) {
if (i.to == par) {
continue;
}
dfs2(chi, q, road, i.to, x, kyo + i.length);
q.push({{(i.length - i.length / 2) * chi[i.to], i.to}, i.length});
}
}
signed main() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
cin >> t;
for (long long _ = 0; _ < t; _++) {
long long n, s;
gou = 0;
cin >> n >> s;
vector<long long> v(n + 1), u(n + 1), c(n + 1);
vector<vector<edge>> road(n + 1);
vector<long long> chi(n + 1);
for (long long i = 0; i < n - 1; i++) {
cin >> v[i] >> u[i] >> c[i];
road[v[i]].emplace_back(edge(u[i], c[i]));
road[u[i]].emplace_back(edge(v[i], c[i]));
}
dfs(chi, road, 1, 0);
priority_queue<pair<pair<long long, long long>, long long>> q;
dfs2(chi, q, road, 1, 0, 0);
long long cnt = 0;
while (gou > s) {
cnt++;
pair<pair<long long, long long>, long long> x = q.top();
q.pop();
gou -= x.first.first;
x.second /= 2;
if (x.second == 0) {
cout << "\n";
}
q.push({{(x.second - x.second / 2) * chi[x.first.second], x.first.second},
x.second});
}
cout << cnt << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2147383647;
const long long mod = 1000000007;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long* X, long long* Y) {
long long x, y, u, v, m, n, a, b, q, r;
x = 0;
y = 1;
u = 1;
v = 0;
for (a = A, b = B; 0 != a; b = a, a = r, x = u, y = v, u = m, v = n) {
q = b / a;
r = b % a;
m = x - (u * q);
n = y - (v * q);
}
*X = x;
*Y = y;
return b;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
int n, q, uu;
int p[300005], st[300005], en[300005], sz[300005];
int cc, heavy[300005], chen[300005], label[300005];
vector<int> v[300005];
void dfs(int pos, int par) {
p[pos] = par;
sz[pos] = 1;
heavy[pos] = -1;
for (int i = 0; i < v[pos].size(); i++) {
int j = v[pos][i];
if (j == par) continue;
dfs(j, pos);
sz[pos] += sz[j];
if (heavy[pos] == -1 || sz[heavy[pos]] < sz[j]) heavy[pos] = j;
}
return;
}
int rec(int pos, int par) {
cc++;
st[pos] = cc;
label[cc] = pos;
chen[pos] = st[pos];
if (heavy[pos] == -1) return chen[pos];
chen[pos] = rec(heavy[pos], pos);
for (int i = 0; i < v[pos].size(); i++) {
int j = v[pos][i];
if (j == par) continue;
if (j == heavy[pos]) continue;
rec(j, pos);
}
en[pos] = cc;
return chen[pos];
}
int main() {
scanf("%d", &n);
scanf("%d", &q);
for (int i = 2; i <= n; i++) {
scanf("%d", &p[i]);
v[p[i]].push_back(i);
}
cc = 0;
dfs(1, 0);
rec(1, 0);
while (q--) {
scanf("%d", &uu);
int hi, lo, mid, tot = sz[uu];
lo = st[uu], hi = chen[uu];
while (hi >= lo) {
mid = (hi + lo) / 2;
int kk = label[mid];
if (sz[kk] + sz[kk] < tot) {
hi = mid - 1;
} else {
lo = mid + 1;
}
}
printf("%d\n", label[hi]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int h1, h2, a1, a2, c, i;
int h[1000];
int main() {
scanf("%d %d %d", &h1, &a1, &c);
scanf("%d %d", &h2, &a2);
int cnt = 0;
int h = 0, a = 0;
int k1 = h2 / a1 + (h2 % a1 ? 1 : 0);
while (h1 + h * c <= (h + k1 - 1) * a2) h++;
printf("%d\n", h + k1);
while (h--) printf("HEAL\n");
while (k1--) printf("STRIKE\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int a, c;
char s[11];
} p[3001];
int cmp(P x, P y) { return x.a < y.a; }
int b[3001];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s%d", p[i].s, &p[i].a);
}
sort(p, p + n, cmp);
bool flag = true;
for (int i = 0; i < n; ++i) {
int h = p[i].a;
if (i - h < 0) {
flag = false;
break;
}
for (int j = i - 1; j >= i - h; --j) b[j + 1] = b[j];
b[i - h] = i;
}
for (int i = 0; i < n; ++i) p[b[i]].c = i + 1;
if (flag) {
for (int i = 0; i < n; ++i) {
printf("%s %d\n", p[i].s, p[i].c);
}
} else
puts("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 7e3 + 1;
map<long long, long long> p;
set<int> s;
long long a[maxn], b[maxn], ans;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]), p[a[i]]++;
for (int i = 1; i <= n; ++i) scanf("%lld", &b[i]);
for (auto it : p) {
if (it.second <= 1) continue;
for (int i = 1; i <= n; ++i)
if ((it.first & a[i]) == a[i]) s.insert(i);
}
for (auto it : s) ans += b[it];
printf("%lld\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, prime, x, y, hasil(1), jum;
pair<long long, long long> p[100005];
double ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> prime;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
p[i].first = (y / prime) - ((x - 1) / prime);
p[i].second = y - x + 1;
}
for (int i = 1; i <= n - 1; i++) {
ans += (double)(p[i].second * p[i + 1].second -
(p[i].second - p[i].first) *
(p[i + 1].second - p[i + 1].first)) /
(p[i].second * p[i + 1].second);
}
ans += (double)(p[n].second * p[1].second -
(p[n].second - p[n].first) * (p[1].second - p[1].first)) /
(p[n].second * p[1].second);
cout << setprecision(6) << fixed << (double)ans * 2000 << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string vow = "aeiou";
long long month[] = {-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const long long dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const long long dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
const long long dx[] = {-1, 0, 1, 0};
const long long dy[] = {0, 1, 0, -1};
const long double pie = 3.1415926535897932384626;
const long long mod = 1e9 + 7;
void a_b_c() {}
void solve() {
long long n;
cin >> n;
map<string, long long> l;
l["polycarp"] = 1;
for (long long i = 0; i < n; i++) {
string a;
string b;
string c;
cin >> a >> b >> c;
transform(a.begin(), a.end(), a.begin(), ::tolower);
transform(c.begin(), c.end(), c.begin(), ::tolower);
l[a] = l[c] + 1;
}
long long maxi = 0;
for (auto i : l) {
maxi = max(maxi, i.second);
}
cout << maxi;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 1; i <= t; i++) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long infl = 0x3f3f3f3f3f3f3f3fLL;
const long long infi = 0x3f3f3f3f;
const long long mod = infl;
long long mygcd(long long a, long long b) {
if (b == 0) {
return a;
}
return mygcd(b, a % b);
}
long long mypow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
if (n == 1) {
cout << "0\n";
cout << v[0];
return;
}
if (n == 2) {
cout << "0\n";
cout << v[0] << ' ' << v[1] << '\n';
return;
}
sort(v.begin(), v.end());
long long maxe = v[n - 1];
long long maxe2 = v[n - 2];
long long ans = (n - 2 + 1) / 2;
cout << ans << '\n';
cout << maxe << ' ';
long long min = 0;
long long max = n - 3;
while (min <= max) {
cout << v[min] << " ";
if (min != max) cout << v[max] << " ";
min++;
max--;
}
cout << maxe2 << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N;
set<int> cur;
vector<int> v;
map<int, int> id;
pair<string, int> arr[400011];
struct segtree {
int st[4 * 400011], lazy[4 * 400011];
void push(int w, int L, int R) {
if (lazy[w] < 0)
return;
else if (L != R) {
lazy[w * 2] = lazy[w];
lazy[w * 2 + 1] = lazy[w];
}
st[w] = ((R - L + 1) * lazy[w]) % 1000000007;
lazy[w] = -1;
}
void update(int w, int L, int R, int a, int b, int v) {
push(w, L, R);
if (b < L || a > R)
return;
else if (a <= L && b >= R) {
lazy[w] = v;
push(w, L, R);
} else {
update(w * 2, L, (L + R) / 2, a, b, v);
update(w * 2 + 1, (L + R) / 2 + 1, R, a, b, v);
st[w] = (st[w * 2] + st[w * 2 + 1]) -
((st[w * 2] + st[w * 2 + 1]) / 1000000007) * 1000000007;
}
}
int query(int w, int L, int R, int a, int b) {
push(w, L, R);
if (b < L || a > R)
return 0;
else if (a <= L && b >= R)
return st[w];
else {
int q1 = query(w * 2, L, (L + R) / 2, a, b);
int q2 = query(w * 2 + 1, (L + R) / 2 + 1, R, a, b);
return (q1 + q2) - ((q1 + q2) / 1000000007) * 1000000007;
}
}
} tree;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i].first;
cin >> arr[i].second;
if (arr[i].first == "ADD") v.push_back(arr[i].second);
}
v.push_back(1000000007);
v.push_back(-1000000007);
sort(v.begin(), v.end());
memset(tree.lazy, -1, sizeof(tree.lazy));
for (int i = 0; i < (int)v.size(); i++) id[v[i]] = i + 1;
cur.insert(1000000007);
cur.insert(-1000000007);
tree.update(1, 1, v.size(), 1, 1, 1);
for (int i = 0; i < N; i++) {
int cid = id[arr[i].second];
int prv = *--cur.lower_bound(arr[i].second);
if (arr[i].first == "ADD") {
tree.update(1, 1, v.size(), cid, cid,
tree.query(1, 1, v.size(), id[prv], id[prv]));
cur.insert(arr[i].second);
} else {
tree.update(1, 1, v.size(), 1, id[prv] - 1, 0);
tree.update(1, 1, v.size(), cid + 1, v.size(), 0);
int nval = (tree.query(1, 1, v.size(), id[prv], id[prv]) +
tree.query(1, 1, v.size(), cid, cid));
tree.update(1, 1, v.size(), id[prv], id[prv], nval % 1000000007);
tree.update(1, 1, v.size(), cid, cid, 0);
cur.erase(arr[i].second);
}
}
cout << tree.query(1, 1, v.size(), 1, v.size()) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, A, B, cg[2010], sb[2010], dp[2010][2010], lt[2010], an[2010];
long long po(long long x, long long y) {
long long z = 1;
while (y) {
if (y % 2) z = x * z % 998244353;
x = x * x % 998244353;
y /= 2;
}
return z;
}
int main() {
cin >> n >> A >> B;
long long Cg = A * po(B, 998244353 - 2) % 998244353,
Sb = (1 - Cg + 998244353) % 998244353;
cg[0] = 1;
sb[0] = 1;
for (int i = 1; i <= n; i++)
cg[i] = cg[i - 1] * Cg % 998244353, sb[i] = sb[i - 1] * Sb % 998244353;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
dp[i][j] = dp[i - 1][j] * cg[j] % 998244353;
if (j) dp[i][j] = (dp[i][j] + dp[i - 1][j - 1] * sb[i - j]) % 998244353;
}
}
lt[1] = 1;
for (int i = 2; i <= n; i++) {
lt[i] = 1;
for (int j = 1; j < i; j++)
lt[i] = (lt[i] + (998244353 - dp[i][j]) * lt[j]) % 998244353;
}
an[1] = 0;
an[0] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j < i; j++)
an[i] =
(an[i] + (lt[j] * dp[i][j] % 998244353) *
(an[j] + an[i - j] + j * (i - j) + j * (j - 1) / 2)) %
998244353;
an[i] = (an[i] + (lt[i] * dp[i][i] % 998244353) * (i * (i - 1) / 2)) %
998244353;
long long p = (1 + (998244353 - lt[i]) * dp[i][i]) % 998244353;
an[i] = an[i] * po(p, 998244353 - 2) % 998244353;
}
cout << an[n] << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
const long long N = 2020;
const long long Q = 3000100;
const long long mod = 1e9 + 7;
const long long block = sqrt(N);
using namespace std;
int n;
int m;
char a[N][N / 10];
char b[N / 10][N];
map<vector<long long>, vector<int> > used;
vector<long long> make(vector<pair<int, int> > v) {
vector<long long> g;
vector<pair<long long, long long> > nv(m);
for (int i = 0; i < m; i++) {
nv[i] = v[i];
}
for (int i = 0; i < 5; i++) {
long long s = 0;
for (int j = 0; j < m; j++) {
s = (s + nv[j].first * mod + nv[j].second) % mod;
}
for (int j = 0; j < m; j++) {
nv[j].first = (nv[j].first * v[j].first) % mod;
nv[j].second = (nv[j].second * v[j].second) % mod;
}
g.push_back(s);
}
return g;
}
bool check(int x, int y) {
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= m; j++) {
if (a[x + i - 1][j] != b[i][y + j - 1]) {
return false;
}
}
}
return true;
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> b[i][j];
}
}
for (int i = 1; i + m - 1 <= n; i++) {
vector<pair<int, int> > v;
for (int j = 1; j <= m; j++) {
pair<int, int> tc = {0, 0};
for (int h = 0; h < m; h++) {
tc.first = 1ll * (tc.first + b[j][i + h] - 'a' + 1) * 27 % mod;
tc.second = 1ll * (tc.second + b[j][i + h] - 'a' + 1) * 29 % mod;
}
v.push_back(tc);
}
vector<long long> hsh = make(v);
used[hsh].push_back(i);
}
for (int i = 1; i + m - 1 <= n; i++) {
vector<pair<int, int> > v;
for (int j = 0; j < m; j++) {
pair<int, int> tc = {0, 0};
for (int h = 1; h <= m; h++) {
tc.first = 1ll * (tc.first + a[i + j][h] - 'a' + 1) * 27 % mod;
tc.second = 1ll * (tc.second + a[i + j][h] - 'a' + 1) * 29 % mod;
}
v.push_back(tc);
}
vector<long long> hsh = make(v);
for (int x : used[hsh]) {
if (check(i, x)) {
cout << i << " " << x << "\n";
return;
}
}
}
}
bool mtest = false;
int main() {
ios_base::sync_with_stdio(0);
int TE = 1;
if (mtest) cin >> TE;
while (TE--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class p {
public:
long long x, y;
p(long long _x, long long _y) : x(_x), y(_y) {}
long long operator-(const p &p1) { return x - p1.x + y - p1.y; }
long long operator/(const p &p1) { return p1.x - x + y - p1.y; }
void pr() { cout << "x:" << x << " y:" << y << endl; }
};
int main() {
long long n, m, c, h, tx, ty, ans = 1e10, nh = 0;
cin >> n >> m >> c;
p ru(1, 1), rd(1, m), lu(n, 1), ld(n, m);
for (int i = 0; i < (c); ++i) {
cin >> tx >> ty;
p tp(tx, ty);
if (tp - ru > 0) ru = tp;
if (ld - tp > 0) ld = tp;
if (tp / lu > 0) lu = tp;
if (rd / tp > 0) rd = tp;
}
cin >> h;
for (int i = (1); i <= (h); ++i) {
cin >> tx >> ty;
p tp(tx, ty);
if (max(max(tp - ld, ru - tp), max(lu / tp, tp / rd)) < ans) {
ans = max(max(tp - ld, ru - tp), max(lu / tp, tp / rd));
nh = i;
}
}
cout << ans << endl << nh << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 3e6;
int cnt[MAXN + 1];
ll cnt_area[MAXN + 1];
int main() {
int n;
scanf("%d", &n);
for (int _ = (0); _ < (n); ++_) {
int a;
scanf("%d", &a);
cnt[a]++;
}
for (int i = (1); i < (1800); ++i) {
if (cnt[i] == 0) continue;
cnt_area[i * i] += (ll)cnt[i] * (cnt[i] - 1);
for (int j = i + 1; i * j <= MAXN; j++)
cnt_area[i * j] += 2 * (ll)cnt[i] * cnt[j];
}
partial_sum(begin(cnt_area), end(cnt_area), begin(cnt_area));
int m;
cin >> m;
ll res = (ll)n * (n - 1);
while (m--) {
int p;
scanf("%d", &p);
printf("%lld\n", res - cnt_area[p - 1]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct segnode {
int sum;
int psummax;
int psummin;
int leftmax;
int rightmax;
int diam;
} seg[1 << 19];
int n, q, p, l;
string s;
segnode merge(segnode x, segnode y) {
segnode ret;
ret.sum = x.sum + y.sum;
ret.psummax = max(x.psummax, x.sum + y.psummax);
ret.psummin = min(x.psummin, x.sum + y.psummin);
ret.leftmax = max(max(x.leftmax, y.leftmax - x.sum),
x.psummax - (x.sum + y.psummin) * 2);
ret.rightmax = max(max(x.rightmax, y.rightmax - x.sum),
x.sum + y.psummax - x.psummin * 2);
ret.diam = max(max(x.diam, y.diam), max(x.leftmax + x.sum + y.psummax,
x.psummax + y.rightmax - x.sum));
return ret;
}
segnode leaf(int x) {
segnode ret;
ret.sum = x;
ret.psummax = (x == 1 ? 1 : 0);
ret.psummin = (x == 1 ? 0 : -1);
ret.leftmax = 1 - x;
ret.rightmax = 1;
ret.diam = 1;
return ret;
}
void update(int x) {
seg[x + p] = (s[x] == '(') ? leaf(1) : leaf(-1);
x += p;
while (x != 1) {
x >>= 1;
seg[x] = merge(seg[((x) << 1)], seg[(((x) << 1) + 1)]);
}
}
void init() {
for (int i = 0; i < l; i++) seg[i + p] = (s[i] == '(') ? leaf(1) : leaf(-1);
for (int i = p - 1; i > 0; i--)
seg[i] = merge(seg[((i) << 1)], seg[(((i) << 1) + 1)]);
}
void printnode(int i) {
cout << seg[i].sum << " " << seg[i].psummax << " " << seg[i].psummin << " ";
cout << seg[i].leftmax << " " << seg[i].rightmax << " " << seg[i].diam << " ";
cout << "\n";
}
int main() {
cin >> n >> q >> s;
l = 2 * n - 2;
for (p = l; p ^ (-p & p); p += (-p & p))
;
init();
cout << seg[1].diam << "\n";
while (q--) {
int x, y;
cin >> x >> y;
--x, --y;
swap(s[x], s[y]);
update(x);
update(y);
cout << seg[1].diam << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
const int mod = 1e9 + 7;
const int eps = 1e9 - 11;
const int inf = 2e9;
long long n, a[10][10], k, k1;
int main() {
for (int i = 1; i <= 5; i++)
for (int j = 1; j <= 5; j++) {
cin >> a[i][j];
if (a[i][j]) k = i, k1 = j;
}
cout << abs(3 - k) + abs(3 - k1);
}
| 0 |
#include <bits/stdc++.h>
#define int long long int
#define all(x) x.begin(), x.end()
#define send ios_base::sync_with_stdio(false);
#define help cin.tie(NULL)
#define inf (int)(1e17+1)
#define mod (int)(998244353)
#define N (int)(5e3+5)
#define fi first
#define se second
#define endl "\n"
#define double long double
#define eps (double)(1e-9)
#define sa cout<<"sa"<<endl
using namespace std;
int k;
vector <int> adj[N];
vector <vector<int>> dp(N,vector <int>(N));
int dfs(int c,int pre){
dp[c][0]=1;
int mx=0;
for(auto x:adj[c]){
if(x==pre) continue;
int a=dfs(x,c);
vector <int> ndp(max(mx,a+1)+1);
for(int i=0;i<=mx;i++){
for(int j=0;j<=a;j++){
if(j+1+i<=k) ndp[max(j+1,i)]+=dp[c][i]*dp[x][j]%mod;
if(i<=k&&j<=k) ndp[i]+=dp[c][i]*dp[x][j]%mod;
ndp[max(j+1,i)]%=mod;ndp[i]%=mod;
}
}
mx=max(mx,a+1);
for(int i=0;i<=mx;i++) dp[c][i]=ndp[i];
}
return mx;
}
void solve(){
int n;
cin>>n>>k;
for(int i=1;i<n;i++){
int u,v;
cin>>u>>v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1,0);
int ans=0;
for(int i=0;i<=k;i++) ans=(ans+dp[1][i])%mod;
cout<<ans;
}
int32_t main(){
send help;
#ifdef LOCAL
freopen("in.txt", "r", stdin); freopen("out.txt", "w", stdout);
#endif
int t=1;
//cin>>t;
while(t--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, x, y;
cin >> n >> m;
vector<vector<int>> G(n + 1);
map<int, int> M;
for (i = 0; i < m; ++i) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
for (i = 1; i <= n; ++i) M[(int)G[i].size()]++;
if (M[2] == n)
cout << "ring topology" << endl;
else if (M[1] == 2 && M[2] == n - 2)
cout << "bus topology" << endl;
else if (M[1] == n - 1 && M[n - 1] == 1)
cout << "star topology" << endl;
else
cout << "unknown topology" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ask(int x1, int y1, int x2, int y2) {
printf("? %d %d %d %d\n", x1, y1, x2, y2);
fflush(stdout);
int ans;
scanf("%d", &ans);
return ans;
}
int n;
int A[60][60];
bool mark[2][60][60][60][60];
bool memo[2][60][60][60][60];
int movx[] = {0, 1};
int movy[] = {1, 0};
bool dp(int p, int x1, int y1, int x2, int y2) {
if (x1 > x2 || y1 > y2) return false;
if (x1 <= 0 || x1 > n || x2 <= 0 || x2 > n) return false;
if (y1 <= 0 || y1 > n || y2 <= 0 || y2 > n) return false;
if (x1 == x2 && y1 == y2) return true;
bool &ans = memo[p][x1][y1][x2][y2];
if (mark[p][x1][y1][x2][y2]) return ans;
mark[p][x1][y1][x2][y2] = true;
ans = false;
int v1 = A[x1][y1], v2 = A[x2][y2];
if ((x1 + y1) & 1) v1 ^= p ^ 1;
if ((x2 + y2) & 1) v2 ^= p ^ 1;
if (v1 != v2) return ans = false;
if ((x1 == x2 && y1 + 1 == y2) || (x1 + 1 == x2 && y1 == y2))
return ans = v1 == v2;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
ans =
ans || dp(p, x1 + movx[i], y1 + movy[i], x2 - movx[j], y2 - movy[j]);
}
}
return ans;
}
void f(int &x1, int &y1, int &x2, int &y2) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = i; k <= n; k++) {
for (int r = j; r <= n; r++) {
bool a1 = dp(0, i, j, k, r);
bool a2 = dp(1, i, j, k, r);
if (a1 != a2 && (abs(i - k) + abs(j - r) > 1)) {
x1 = i;
y1 = j;
x2 = k;
y2 = r;
return;
}
}
}
}
}
}
int main() {
scanf("%d", &n);
A[1][1] = A[1][2] = 1;
A[n][n] = 0;
for (int i = 3; i <= n; i++) A[1][i] = ask(1, i - 2, 1, i) ^ A[1][i - 2] ^ 1;
for (int i = 2; i <= n; i++) {
for (int j = 2; j <= n; j++) {
if (i == n && j == n) continue;
A[i][j] = ask(i - 1, j - 1, i, j) ^ A[i - 1][j - 1] ^ 1;
}
A[i][1] = ask(i, 1, i, 3) ^ A[i][3] ^ 1;
}
int x1, y1, x2, y2;
f(x1, y1, x2, y2);
int ans = ask(x1, y1, x2, y2);
bool a1 = dp(0, x1, y1, x2, y2), a2 = dp(1, x1, y1, x2, y2);
int p;
if (a1 == ans)
p = 0;
else
p = 1;
printf("!\n");
fflush(stdout);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if ((i + j) & 1)
printf("%d", A[i][j] ^ p ^ 1);
else
printf("%d", A[i][j]);
}
printf("\n");
fflush(stdout);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 3;
const long long int M = 998244353;
void solve() {
long long int a, c = 0;
cin >> a;
string s;
cin >> s;
int n = s.length();
std::map<long long int, long long int> map;
for (int xs = 0; xs < n; ++xs) {
long long int ans = 0;
for (int i = xs; i < n; ++i) {
ans += s[i] - '0';
map[ans]++;
}
}
for (int xs = 0; xs < n; ++xs) {
long long int ans = 0;
for (int i = xs; i < n; ++i) {
ans += s[i] - '0';
if (ans > a) break;
if (!ans) continue;
if (!(a % ans)) c += map[a / ans];
}
}
if (!a)
for (int i = 1; i <= 9 * n; i++) c += map[0] * map[i] * 2;
if (!a) c += map[0] * map[0];
cout << c;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve(), cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
long long n, m;
cin >> n >> m;
if (m == 0) {
cout << n << " " << n << endl;
return 0;
}
int MAX = 0;
for (int i = 1; i <= n; ++i)
if (i * (i - 1ll) / 2 >= m) {
MAX = i;
break;
}
cout << max(0ll, n - 2 * m) << " " << n - MAX << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
int64_t value = 0;
for (int64_t i = 3; i <= n; i++) {
value += i * (i - 1);
}
cout << value << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
cin >> a;
string s;
cin >> s;
long long n = s.length();
map<long long, long long> m;
for (int i = 0; i < n; i++) {
long long sum = 0;
for (int j = i; j < n; j++) {
sum += (s[j] - '0');
m[sum]++;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long sum = 0;
for (int j = i; j < n; j++) {
sum += (s[j] - '0');
if (sum == 0 && a == 0) {
ans += (n * (n + 1)) / 2;
} else if (sum == 0 && a != 0) {
continue;
}
if (sum != 0 && a % sum == 0) {
ans += m[a / sum];
}
}
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
set<int> st;
set<pair<long long, int>> bus[200011];
map<long long, set<pair<int, int>>> q;
int n, k, m;
int main() {
int i;
scanf("%d%d%d", &n, &k, &m);
for (i = 1; i <= k; ++i) {
int xi;
scanf("%d", &xi);
st.insert(xi);
bus[xi].insert(make_pair(0, i));
}
while (m-- > 0) {
long long ti;
int a, b;
scanf("%I64d%d%d", &ti, &a, &b);
while (!q.empty()) {
auto iter = q.begin();
if (iter->first > ti) break;
for (auto p : iter->second) {
st.insert(p.first);
bus[p.first].insert(make_pair(iter->first, p.second));
}
q.erase(iter->first);
}
if (!st.empty()) {
auto iter = st.upper_bound(a);
pair<int, pair<long long, int>> car =
make_pair(1e6, make_pair(1e14, 1e6));
bool ok = false;
if (iter != st.end()) {
car.first = *iter;
car.second = *bus[car.first].begin();
ok = true;
}
if (iter != st.begin()) {
iter = prev(iter);
if (ok) {
int pos = *iter;
if ((abs(pos - a) < abs(car.first - a)) ||
(abs(pos - a) == abs(car.first - a) &&
car.second > *bus[pos].begin())) {
car.first = pos;
car.second = *bus[pos].begin();
}
} else {
car.first = *iter;
car.second = *bus[car.first].begin();
}
}
printf("%d %d\n", car.second.second, abs(car.first - a));
bus[car.first].erase(car.second);
if (bus[car.first].empty()) st.erase(car.first);
long long finish = ti + abs(car.first - a) + abs(b - a);
q[finish].insert(make_pair(b, car.second.second));
} else {
long long t = q.begin()->first;
auto iter = q[t].upper_bound(make_pair(a, 0));
pair<int, int> car = make_pair(0, 0);
if (iter != q[t].end()) {
car = *iter;
}
if (iter != q[t].begin()) {
iter = prev(iter);
iter = q[t].upper_bound(make_pair(iter->first, 0));
if (car.first != 0) {
if ((abs(car.first - a) > abs(iter->first - a)) ||
((abs(car.first - a) == abs(iter->first - a)) &&
car.second > iter->second)) {
car = *iter;
}
} else {
car = *iter;
}
}
printf("%d %I64d\n", car.second, abs(t - ti) + abs(car.first - a));
q[t].erase(car);
if (q[t].empty()) q.erase(t);
q[t + abs(car.first - a) + abs(b - a)].insert(make_pair(b, car.second));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, a, b, m = 0;
cin >> n >> a >> b;
for (int i = 1; i < n; i++) {
m = max(min(a / i, b / (n - i)), m);
}
cout << m << "\n";
}
| 2 |
/*input
4
2 5
10 10
2 5
3 3
4 5
5 2 4 9
8 8
5 3 3 6 10 100 9 15
*/
#include <bits/stdc++.h>
using namespace std;
class DisjointSets {
private:
int n;
vector<int> id;
vector<int> size;
public:
DisjointSets(int n) {
this-> n = n;
id = vector<int>(n+1);
size = vector<int>(n+1, 1);
iota(id.begin(), id.end(), 0);
}
int findSet(int v) {
while(id[v] != v) {
id[v] = id[id[v]];
v = id[v];
}
return v;
}
void weighted_union(int x, int y) {
int set1 = findSet(x);
int set2 = findSet(y);
if(set1 == set2) {
return;
}
if(size[set1] > size[set2]) {
id[set2] = id[set1];
size[set1] += size[set2];
}
else {
id[set1] = id[set2];
size[set2] += size[set1];
}
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int T;
cin >> T;
while(T--) {
long long n, p;
cin >> n >> p;
vector<long long> a(n);
for(int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> order(n);
iota(order.begin(), order.end(), 0);
sort(order.begin(), order.end(), [&](int i, int j) -> bool {
return a[i] < a[j];
});
DisjointSets st(n+1);
vector<bool> done(n);
long long ans = 0;
int cnt = 0;
for(int i = 0; i < n; i++) {
int node = order[i];
if(done[node]) continue;
if(a[node] >= p) continue;
done[node] = true;
for(int j = node + 1; j < n; j++) {
if((a[j] < a[node]) || (a[j] % a[node] != 0)) break;
done[j] = true;
if(st.findSet(node) == st.findSet(j)) continue;
st.weighted_union(node, j);
cnt++;
ans += a[node];
}
for(int j = node - 1; j >= 0; j--) {
if((a[j] < a[node]) || (a[j] % a[node] != 0)) break;
done[j] = true;
if(st.findSet(node) == st.findSet(j)) continue;
st.weighted_union(node, j);
cnt++;
ans += a[node];
}
}
ans += (n-1 - cnt) * p;
cout << ans << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, b[200010], a[200010], L[200010], R[200010], rL, lL, en, cnt[200010];
long long ans;
bool check(int len) {
memset(cnt, 0, sizeof(cnt));
if (len >= (n + 1) / 2) {
for (int i = 0; i < len; i++) cnt[a[i]]++;
for (int i = n - 1; i >= len; i--) cnt[a[i]]--;
for (int i = n - 1; i >= len; i--)
if (cnt[a[i]] < 0) return 0;
bool bf = 0;
for (int i = 1; i <= n; i++) {
if (bf && (cnt[i] & 1)) return 0;
if (cnt[i] & 1) bf = 1;
}
return 1;
} else {
for (int i = len; i <= n / 2; i++)
if (a[i] != a[n - 1 - i]) return 0;
for (int i = 0; i < len; i++) cnt[a[i]]++;
for (int i = n - len; i < n; i++) cnt[a[i]]--;
bool bf = 0;
for (int i = 1; i <= n; i++)
if (cnt[i]) return 0;
return 1;
}
}
void calc() {
int l = 1, r = n + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
lL = l - 1;
reverse(a, a + n);
l = 1, r = n + 1;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
rL = l - 1;
if (lL >= n && rL >= n) {
ans = 0;
return;
} else {
ans = (n - lL + n - rL);
ans += (1LL * ans * en);
ans += (1LL * en * en);
if (lL < n && rL < n) ans--;
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
en = -1;
for (int i = 0; i < n; i++) {
if (b[i] != b[n - i - 1]) {
en = i;
break;
}
}
if (en < 0) {
printf("%I64d\n", 1LL * n * (n + 1) / 2);
return 0;
}
int len = 0;
for (int i = en; i < n - en; i++) a[len++] = b[i];
n = len;
calc();
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long int myRand(long long int B) { return (long long unsigned)rng() % B; }
const int N = 1500;
int _a[N][N];
void init(int n, int m) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &_a[i][j]);
}
int _cnt = 0;
int force_ask(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
int ans;
scanf("%d", &ans);
return ans;
}
map<pair<int, int>, int> mem;
int ask(int x, int y) {
if (mem.count(make_pair(x, y)) == 0) mem[make_pair(x, y)] = force_ask(x, y);
return mem[make_pair(x, y)];
}
vector<int> reduce(vector<int> rows, vector<int> cols) {
vector<int> ans;
42;
int i = 0;
for (int c : cols) {
42;
if (ans.empty()) {
ans.push_back(c);
continue;
}
while (!ans.empty() && ask(rows[i], ans.back()) > ask(rows[i], c)) {
ans.pop_back();
i--;
}
if (ans.size() == rows.size())
continue;
else {
ans.push_back(c);
i++;
}
}
42;
return ans;
}
vector<int> solve(vector<int> rows, vector<int> cols) {
if ((int)cols.size() > (int)rows.size()) cols = reduce(rows, cols);
int n = (int)rows.size();
int m = (int)cols.size();
vector<int> nrows;
for (int i = 1; i < n; i += 2) nrows.push_back(rows[i]);
vector<int> nans;
if (!nrows.empty()) nans = solve(nrows, cols);
vector<int> ans;
int ptr = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 1) {
ans.push_back(nans[i / 2]);
continue;
}
int nptr = m - 1;
if (i + 1 < n) {
nptr = ptr;
while (cols[nptr] < nans[i / 2]) nptr++;
}
int bst = ptr;
for (int j = ptr; j <= nptr; j++)
if (ask(rows[i], cols[j]) < ask(rows[i], cols[bst])) bst = j;
ans.push_back(cols[bst]);
ptr = nptr;
}
return ans;
}
int main(int, char **) {
int n, m;
scanf("%d%d", &n, &m);
vector<int> rows, cols;
for (int i = 1; i <= n; i++) rows.push_back(i);
for (int i = 1; i <= m; i++) cols.push_back(i);
vector<int> mins = solve(rows, cols);
int bst = 0;
for (int i = 0; i < n; i++)
if (ask(rows[i], mins[i]) < ask(rows[bst], mins[bst])) bst = i;
42;
printf("! %d\n", ask(rows[bst], mins[bst]));
fflush(stdout);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string inp;
cin >> inp;
int total = 0, curr = 0, sign = 1;
for (int i = 0; i < inp.length(); ++i) {
if (inp[i] == '+' || inp[i] == '-') {
total += curr * sign;
curr = 0;
if (inp[i] == '-') {
sign = -1;
} else {
sign = 1;
}
} else {
curr *= 10;
curr += inp[i] - '0';
}
}
total += curr * sign;
string output = "";
if (total >= 100) {
for (int i = 0; i < (total / 100) + 48; ++i) {
output += '+';
}
output += ".>";
for (int i = 0; i < (total / 10) % 10 + 48; ++i) {
output += '+';
}
output += ".>";
for (int i = 0; i < (total % 10) + 48; ++i) {
output += '+';
}
} else if (total >= 10) {
for (int i = 0; i < (total / 10) + 48; ++i) {
output += '+';
}
output += ".>";
for (int i = 0; i < (total % 10) + 48; ++i) {
output += '+';
}
} else {
for (int i = 0; i < total + 48; ++i) {
output += '+';
}
}
output += '.';
cout << output << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
int N, M;
vector<int> E[MAXN];
int bio[MAXN];
vector<int> sol;
int dummy;
void add_edge(int x, int y) { E[y].push_back(x); }
void load() {
scanf("%d%d", &N, &M);
dummy = M;
for (int i = 0; i < N; i++) {
vector<pair<int, int> > tmp;
for (int j = 0; j < M; j++) {
int x;
scanf("%d", &x);
if (x != -1) tmp.push_back(pair<int, int>(x, j));
}
sort(tmp.begin(), tmp.end());
vector<int> curr;
for (int j = 0; j < tmp.size(); j++)
if (!j || tmp[j].first != tmp[j - 1].first) curr.push_back(j);
curr.push_back(tmp.size());
for (int j = 1; j < (int)curr.size() - 1; j++) {
for (int k = curr[j - 1]; k < curr[j]; k++)
add_edge(tmp[k].second, dummy);
for (int k = curr[j]; k < curr[j + 1]; k++)
add_edge(dummy, tmp[k].second);
dummy++;
}
}
}
bool dfs(int x) {
if (bio[x] == 2) return false;
if (bio[x] == 1) return true;
bio[x] = 1;
for (int i = 0; i < E[x].size(); i++)
if (dfs(E[x][i])) return true;
sol.push_back(x);
bio[x] = 2;
return false;
}
void solve() {
for (int i = 0; i < dummy; i++)
if (dfs(i)) {
puts("-1");
return;
}
for (int i = 0; i < sol.size(); i++)
if (sol[i] < M) printf("%d ", ++sol[i]);
puts("");
}
int main() {
load();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int ms = 100100;
int freq[ms];
int lis[2][ms];
int a[ms];
int main() {
int n, m;
std::cin >> n >> m;
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d %d", &l, &r);
freq[l]++;
freq[r + 1]--;
}
for (int i = 1; i <= m; i++) {
freq[i] += freq[i - 1];
}
int c = 0;
for (int i = 1; i <= m; i++) {
int cur = freq[i];
int idx = std::upper_bound(a, a + c, cur) - a;
a[idx] = cur;
if (idx == c) {
c++;
}
lis[0][i] = c;
}
c = 0;
for (int i = m; i > 0; i--) {
int cur = freq[i];
int idx = std::upper_bound(a, a + c, cur) - a;
a[idx] = cur;
if (idx == c) {
c++;
}
lis[1][i] = c;
}
int ans = 0;
for (int i = 1; i <= m; i++) {
ans = std::max(ans, lis[0][i] + lis[1][i] - 1);
}
std::cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int l, r, x, y, k;
cin >> l >> r >> x >> y >> k;
for (int i = l; i <= r; i++) {
if (i % k == 0 && (i / k) >= x && (i / k) <= y) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, p = 0, ne = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > 0)
p++;
else
ne++;
}
int ans = 0;
for (int jj = 1; jj <= 31; jj++) {
int maxso = 0, maxc = 0, max = 0, sol = 0, f = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= jj) continue;
maxc = maxc + a[i];
if (maxso < maxc) maxso = maxc;
if (max < a[i]) max = a[i];
if (maxc < 0) {
f = 1;
if (sol < maxso - max) sol = maxso - max;
maxc = 0;
maxso = 0;
max = 0;
}
}
if (sol < maxso - max) sol = maxso - max;
if (sol > ans) ans = sol;
}
if (p <= 1) {
cout << "0" << endl;
} else
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = 1E18;
const double EPS = 1E-10;
template <class T>
T ckmin(T& a, T b) {
return a = min(a, b);
}
template <class T>
T ckmax(T& a, T b) {
return a = max(a, b);
}
namespace input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class A, class... As>
void re(A& head, As&... tail) {
re(head);
re(tail...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = (0); i < (((int)(a).size())); i++) re(a[i]);
}
} // namespace input
using namespace input;
namespace output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class A, class... As>
void pr(const A& head, const As&... tail) {
pr(head);
pr(tail...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T>
void prc(const T& x) {
pr("{");
bool fi = 1;
for (auto& a : x) pr(!fi ? ", " : "", a), fi = 0;
pr("}");
}
template <class T>
void pr(const vector<T>& x) {
prc(x);
}
template <class T>
void pr(const set<T>& x) {
prc(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prc(x);
}
void ps() { pr("\n"); }
template <class A, class... As>
void ps(const A& head, const As&... tail) {
pr(head, " ");
ps(tail...);
}
} // namespace output
using namespace output;
inline int cmp(double x, double y = 0, double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
int second[202020];
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n, k, q;
re(n, k, q);
for (int i = (0); i < (n); i++) {
int l, r;
re(l, r);
second[l]++;
second[r + 1]--;
}
int t = 0;
for (int i = (1); i < (200001); i++)
second[i] = second[i - 1] + ((t += second[i]) >= k);
while (q--) {
int l, r;
re(l, r);
ps(second[r] - second[l - 1]);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void disp(T& x) {
for (typename T::iterator it = x.begin(); it != x.end(); ++it)
cout << *it << ' ';
cout << '\n';
}
template <typename T>
T sqr(T x) {
return x * x;
}
int random(int l, int r) {
int x = (rand() % 1000) * 1000000 + (rand() % 1000) * 1000 + rand() % 1000;
x %= r - l + 1;
return l + x;
}
const int inf = 1000000;
int mas[205][205];
int fl[205][205];
int b[205];
int z;
int sum;
int c(int x, int y) { return mas[x][y] - fl[x][y]; }
int dfs(int x, int d) {
b[x] = 1;
if (d == 0) return 0;
if (x == z) {
sum -= d;
return d;
}
for (int y = 0; y <= z; ++y)
if (b[y] == 0 && c(x, y) > 0) {
int t = dfs(y, min(d, c(x, y)));
if (t > 0) {
fl[x][y] += t;
fl[y][x] -= t;
return t;
}
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
int x = 0;
z = 2 * n + 1;
for (int i = 1; i <= n; ++i) {
cin >> mas[0][i];
sum += mas[0][i];
}
for (int i = 1; i <= n; ++i) {
cin >> mas[i + n][z];
x += mas[i + n][z];
}
if (x != sum) {
cout << "NO";
return 0;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
mas[a][b + n] = mas[0][a];
mas[b][a + n] = mas[0][b];
}
for (int i = 1; i <= n; ++i) mas[i][i + n] = inf;
while (dfs(0, inf) > 0) fill(b, b + z + 1, 0);
if (sum != 0) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= n; ++i) {
for (int j = n + 1; j < z; ++j) cout << fl[i][j] << ' ';
cout << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double INF = 1e20;
int dcmp(double x) { return (x > 1e-10) - (x < -1e-10); }
struct Point {
double x;
double y;
double z;
} p[5000 + 20];
double calDist(int i, int j) {
return sqrt((p[i].x - p[j].x) * (p[i].x - p[j].x) +
(p[i].y - p[j].y) * (p[i].y - p[j].y) +
(p[i].z - p[j].z) * (p[i].z - p[j].z));
}
int n;
double dist[5000 + 20];
int main() {
while (cin >> n) {
for (int i = 1; i <= n; i++) {
scanf("%lf%lf%lf", &p[i].x, &p[i].y, &p[i].z);
}
for (int i = 2; i <= n; i++) {
dist[i] = calDist(1, i);
}
double ans = INF;
double dij;
for (int i = 2; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
dij = calDist(i, j);
if (dcmp((dist[i] + dist[j] + dij) / 2 - ans) < 0) {
ans = (dist[i] + dist[j] + dij) / 2;
}
}
}
printf("%.10lf\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
const int mod = 1e9 + 7;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
int n, m, tot = 0, a[N][4], st[310], top = 0, tmp[310][1 << 16], f[1 << 16],
g[1 << 16];
char s[N];
void inc(int &a, int b) { a = (a + b >= mod) ? a + b - mod : a + b; }
void dec(int &a, int b) { a = (a - b < 0) ? a - b + mod : a - b; }
void fwt_and(int *a, int n) {
for (int i = 1; i < n; i <<= 1)
for (int p = i << 1, j = 0; j < n; j += p)
for (int k = 0; k < i; k++) inc(a[j + k], a[j + k + i]);
}
void fwt_or(int *a, int n) {
for (int i = 1; i < n; i <<= 1)
for (int p = i << 1, j = 0; j < n; j += p)
for (int k = 0; k < i; k++) inc(a[j + k + i], a[j + k]);
}
void ifwt_and(int *a, int n) {
for (int i = 1; i < n; i <<= 1)
for (int p = i << 1, j = 0; j < n; j += p)
for (int k = 0; k < i; k++) dec(a[j + k], a[j + k + i]);
}
void ifwt_or(int *a, int n) {
for (int i = 1; i < n; i <<= 1)
for (int p = i << 1, j = 0; j < n; j += p)
for (int k = 0; k < i; k++) dec(a[j + k + i], a[j + k]);
}
void solve(int *f, int l, int r) {
if (l == r) {
char c = s[l];
if (c != '?') {
if (isupper(c)) {
int i = c - 'A', tmp = 0;
for (int j = 1; j <= m; j++) tmp |= (a[j][i]) << (j - 1);
f[tmp]++;
} else {
int i = c - 'a', tmp = 0;
for (int j = 1; j <= m; j++) tmp |= (a[j][i] ^ 1) << (j - 1);
f[tmp]++;
}
} else {
for (int i = 0; i < 4; i++) {
int tmp = 0;
for (int j = 1; j <= m; j++) tmp |= (a[j][i]) << (j - 1);
f[tmp]++;
}
for (int i = 0; i < 4; i++) {
int tmp = 0;
for (int j = 1; j <= m; j++) tmp |= (a[j][i] ^ 1) << (j - 1);
f[tmp]++;
}
}
return;
}
int p = 0, cnt = 0;
for (int i = r; i >= l; i--) {
if (s[i] == ')')
cnt++;
else if (s[i] == '(')
cnt--;
if (!cnt && s[i] != '(') {
p = i;
break;
}
}
if (!p) return solve(f, l + 1, r - 1);
int ls = st[top--], rs = st[top--];
solve(tmp[ls], l, p - 1);
solve(tmp[rs], p + 1, r);
if (s[p] == '&') {
fwt_and(tmp[ls], 1 << m);
fwt_and(tmp[rs], 1 << m);
for (int i = 0; i < (1 << m); i++)
f[i] = 1ll * tmp[ls][i] * tmp[rs][i] % mod;
ifwt_and(f, 1 << m);
} else if (s[p] == '|') {
fwt_or(tmp[ls], 1 << m);
fwt_or(tmp[rs], 1 << m);
for (int i = 0; i < (1 << m); i++)
f[i] = 1ll * tmp[ls][i] * tmp[rs][i] % mod;
ifwt_or(f, 1 << m);
} else {
fwt_and(tmp[ls], 1 << m);
fwt_and(tmp[rs], 1 << m);
for (int i = 0; i < (1 << m); i++)
f[i] = 1ll * tmp[ls][i] * tmp[rs][i] % mod;
ifwt_and(f, 1 << m);
ifwt_and(tmp[ls], 1 << m);
ifwt_and(tmp[rs], 1 << m);
fwt_or(tmp[ls], 1 << m);
fwt_or(tmp[rs], 1 << m);
for (int i = 0; i < (1 << m); i++)
g[i] = 1ll * tmp[ls][i] * tmp[rs][i] % mod;
ifwt_or(g, 1 << m);
for (int i = 0; i < (1 << m); i++) inc(f[i], g[i]);
}
for (int i = 0; i < (1 << m); i++) tmp[ls][i] = tmp[rs][i] = 0;
st[++top] = ls;
st[++top] = rs;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
cin >> m;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < 4; j++) a[i][j] = gi();
ans |= gi() << (i - 1);
}
for (int i = 1; i <= 300; i++) st[++top] = i;
solve(f, 1, n);
printf("%d\n", f[ans]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long double ans, p, x;
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%Lf", &p);
ans += (2 * x + 1.0) * p;
x = (x + 1.0) * p;
}
printf("%.10Lf\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e1 + 5, maxm = 15 * 10 + 5;
int n, a, b, h[maxn], sum, ans, all;
int pos[maxm], val[maxm];
int rad() {
int ret = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret * f;
}
void check() {
int yu = max(h[n - 1] / a + (h[n - 1] >= 0), h[n] / b + (h[n] >= 0));
for (int i = 1; i <= yu; ++i) pos[++sum] = n - 1;
if (ans > sum) {
for (int i = 1; i <= sum; ++i) val[i] = pos[i];
ans = sum;
}
sum -= yu;
}
void put(int x) {
all -= min(max(h[x - 1], -1) + a, b) + min(max(h[x], -1) + 1, a) +
min(max(h[x + 1], -1) + 1, b);
}
void dfs(int now) {
if (now > n - 1) {
check();
return;
}
if (h[now - 1] < 0) dfs(now + 1);
int i = 1, lst = sum, A = h[now - 1], B = h[now], C = h[now + 1], his = all;
while (true) {
put(now);
h[now] -= a;
h[now - 1] -= b;
h[now + 1] -= b;
pos[++sum] = now;
if (h[now - 1] < 0) dfs(now + 1);
if (h[now - 1] >= 0 || h[now] >= 0)
;
else {
sum = lst;
h[now - 1] = A, h[now] = B, h[now + 1] = C;
break;
}
if (sum >= ans) {
sum = lst;
h[now - 1] = A, h[now] = B, h[now + 1] = C;
break;
}
}
}
int main() {
n = rad();
a = rad();
b = rad();
for (int i = 1; i <= n; ++i) all += h[i] = rad();
ans = 1e9;
sum = 0;
dfs(2);
printf("%d\n", ans);
for (int i = 1; i < ans; ++i) printf("%d ", val[i]);
printf("%d\n", val[ans]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(char c) {
string s = {c};
return s;
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
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;
}
ll SUM(VI& V) { return accumulate((V).begin(), (V).end(), 0LL); }
ll MIN(VI& V) { return *min_element((V).begin(), (V).end()); }
ll MAX(VI& V) { return *max_element((V).begin(), (V).end()); }
void print_vector(VI& V) {
ll n = V.size();
for (ll i = (0); i < (n); ++i) {
if (i) cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
using ld = long double;
using inverse_priority_queue = priority_queue<ll, vector<ll>, greater<ll> >;
int popcount(ll t) { return __builtin_popcountll(t); }
void no() {
cout << ("No") << '\n';
exit(0);
}
void yes() {
cout << ("Yes") << '\n';
exit(0);
}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
ll ceil_div(ll a, ll b) { return (a + b - 1) / b; }
ll string_to_ll(string s) { return atoll(s.c_str()); }
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
void solve() {
ll N;
cin >> N;
VI A(N);
for (ll i = (0); i < (N); ++i) {
cin >> A[i];
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
N--;
VI K(M);
VI F(M);
for (ll i = (0); i < (M); ++i) {
cin >> K[i] >> F[i];
K[i]--;
F[i]--;
}
set<ll> se;
for (ll a = (1); a < (101); ++a) {
bool ok = true;
for (ll i = (0); i < (M); ++i) {
ll k = K[i];
ll f = F[i];
if (k / a != f) ok = false;
}
if (ok) {
se.insert(N / a);
}
}
if (((int)(se).size()) > 1) {
cout << (-1) << '\n';
} else {
cout << (*se.begin() + 1) << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
unordered_map<long long, bool> mp;
stack<pair<int, int>> st;
int deg[100005];
void dfs(int now, int m) {
if (m == 0) {
while (st.size()) {
cout << st.top().first << " " << st.top().second << endl;
st.pop();
}
exit(0);
}
if (deg[now] >= 2) {
for (int i = (now + 1 > n ? now + 1 - m : now + 1); i != now;
i = (i + 1 > n ? i + 1 - n : i + 1)) {
if (deg[i] < 2) dfs(i, m);
}
} else
for (int i = (now + 1 > n ? now + 1 - n : now + 1); i != now;
i = (i + 1 > n ? i + 1 - n : i + 1)) {
auto it = mp.find(((long long)now << 20) | i);
if (deg[i] < 2 and (it == mp.end() or it->second == 0)) {
st.emplace(now, i);
deg[now]++;
deg[i]++;
mp[((long long)now << 20) | i] = 1;
mp[((long long)i << 20) | now] = 1;
dfs(i, m - 1);
mp.erase(((long long)now << 20) | i);
mp.erase(((long long)i << 20) | now);
deg[now]--;
deg[i]--;
st.pop();
}
}
}
int main() {
int m;
cin >> n >> m;
if (n <= 500 and m * 2 > n * (n - 1) / 2) return cout << -1 << endl, 0;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
mp[(((long long)u) << 20) | v] = 1;
mp[(((long long)v) << 20) | u] = 1;
}
for (int i = 1; i <= n; ++i) {
dfs(i, m);
}
cout << -1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct sp {
string s1;
int id;
};
int n, m;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
sp s[n];
for (int k = 0; k < n; k++) {
string x = "";
for (int i = 0; i < m; i++) {
char c;
cin >> c;
if (i % 2 == 1) {
x += (char)('Z' + 'A' - c);
} else {
x += c;
}
}
s[k] = {x, k + 1};
}
sort(s, s + n, [](sp x, sp y) { return x.s1 < y.s1; });
for (int p = 0; p < n; p++) cout << s[p].id << " ";
cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, n, m, s;
cin >> a >> b >> c >> n;
a -= c;
b -= c;
if (a >= 0 && b >= 0 && c >= 0 && n - (a + b + c) >= 1)
cout << n - (a + b + c);
else
cout << -1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
vector<string> al(n);
vector<string> subs(n);
set<string> cur;
map<string, int> mp;
for (int i = 0; i < n; i++) {
cin >> al[i];
cur.clear();
for (int j = 0; j < al[i].size(); j++) {
string sub;
for (int k = j; k < al[i].size(); k++) {
sub += al[i][k];
mp[sub] = i;
cur.insert(sub);
}
}
for (auto &e : cur) subs.push_back(e);
}
sort(subs.begin(), subs.end());
int q;
cin >> q;
while (q--) {
string wanted;
cin >> wanted;
int num = upper_bound(subs.begin(), subs.end(), wanted) -
lower_bound(subs.begin(), subs.end(), wanted);
if (num) {
cout << num << ' ';
cout << al[mp[wanted]] << endl;
} else {
cout << "0 -" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void brainfuck(int r) {
int volte = 0;
stack<int> ans;
while (r > 0) {
int resto = r % 10;
ans.push(resto);
r -= resto;
r /= 10;
}
while (!ans.empty()) {
int bit = ans.top();
ans.pop();
switch (bit) {
case 0:
for (int i = 0; i < 48; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
case 1:
for (int i = 0; i < 49; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
case 2:
for (int i = 0; i < 50; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
case 3:
for (int i = 0; i < 51; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
case 4:
for (int i = 0; i < 52; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
case 5:
for (int i = 0; i < 53; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
case 6:
for (int i = 0; i < 54; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
case 7:
for (int i = 0; i < 55; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
case 8:
for (int i = 0; i < 56; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
case 9:
for (int i = 0; i < 57; i++) {
cout << "+";
}
cout << ">";
volte++;
break;
}
}
int tem = volte;
while (volte > 0) {
cout << "<";
volte--;
}
for (int i = 0; i < tem; i++) {
if (i == tem - 1) {
cout << "." << endl;
} else {
cout << ".>";
}
}
}
int main(void) {
string input;
string change = "";
int result = 0, aux;
int i = 0;
char op, less;
getline(cin, input);
for (i = 0; true; i++) {
if (input[i] == '+' || input[i] == '-') {
if (input[i] == '+') {
op = '+';
less = '+';
i++;
} else {
op = '-';
less = '-';
i++;
}
break;
} else {
change += input[i];
}
}
sscanf(change.c_str(), "%d", &aux);
result += aux;
change.clear();
change = "";
for (; i < input.size(); i++) {
if (input[i] == '+' || input[i] == '-') {
sscanf(change.c_str(), "%d", &aux);
if (less == '+') {
result += aux;
} else {
result -= aux;
}
if (input[i] == '+') {
less = '+';
} else {
less = '-';
}
change.clear();
change = "";
} else {
change += input[i];
}
}
sscanf(change.c_str(), "%d", &aux);
if (less == '+') {
result += aux;
} else {
result -= aux;
}
if (result == 0) {
cout << "++++++++++++++++++++++++++++++++++++++++++++++++." << endl;
} else {
brainfuck(result);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool v, n, p, l;
int q;
int k = 0;
cin >> q;
int *x = new int[q];
int *y = new int[q];
for (int i = 0; i < q; i++) cin >> x[i] >> y[i];
for (int i = 0; i < q; i++) {
for (int j = 0; j < q; j++) {
if (x[j] < x[i] && y[j] == y[i]) l = true;
if (x[j] > x[i] && y[j] == y[i]) p = true;
if (x[j] == x[i] && y[j] < y[i]) n = true;
if (x[j] == x[i] && y[j] > y[i]) v = true;
}
if (n == true && v == true && p == true && l == true) k++;
n = v = p = l = false;
}
cout << k;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100010;
int n;
char s[M];
int a[M];
int main() {
scanf("%d\n", &n);
gets(s);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int pos = 0;
int step = 0;
while (1) {
if (pos < 0 || pos >= n) {
printf("FINITE\n");
return 0;
} else if (a[pos] == 0) {
printf("INFINITE\n");
return 0;
}
step = a[pos];
a[pos] = 0;
if (s[pos] == '>') {
pos += step;
} else {
pos -= step;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
int n, m, x, y, a, b;
cin >> n >> m >> x >> y >> a >> b;
int d = gcd(a, b);
a /= d;
b /= d;
int l = 1, r = (int)1e9 + 10;
while (l < r) {
int mid = l + r >> 1;
long long w = 1LL * mid * a;
long long h = 1LL * mid * b;
if (w <= n && h <= m) {
l = mid + 1;
} else
r = mid;
}
int w = (l - 1) * a;
int h = (l - 1) * b;
int x1 = x - w / 2;
if (w & 1) x1--;
int x2 = x + w / 2;
int y1 = y - h / 2;
if (h & 1) y1--;
int y2 = y + h / 2;
if (x1 < 0) {
x2 -= x1;
x1 = 0;
}
if (y1 < 0) {
y2 -= y1;
y1 = 0;
}
if (x2 > n) {
x1 += (n - x2);
x2 = n;
}
if (y2 > m) {
y1 += (m - y2);
y2 = m;
}
cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool lt[75][75], eq[75][75], gt[75][75];
long long dp[75][75];
int main() {
cin >> n >> k;
for (int i = 1; i <= 2 * n; i++) {
for (int j = i + 1; j <= 2 * n; j++) {
lt[i][j] = eq[i][j] = gt[i][j] = 1;
}
}
while (k--) {
int x, y;
string sign;
cin >> x >> sign >> y;
bool l = 0, e = 0, g = 0;
for (char c : sign) {
if (c == '<') l = 1;
if (c == '=') e = 1;
if (c == '>') g = 1;
}
if (x > y) {
swap(x, y);
swap(l, g);
}
lt[x][y] &= l;
eq[x][y] &= e;
gt[x][y] &= g;
}
for (int i = 1; i < 2 * n; i++) {
if (eq[i][i + 1]) dp[i][i + 1] = 1;
}
for (int a = 1; a < n; a++) {
for (int i = 1; i + 2 * a + 1 <= 2 * n; i++) {
int j = i + 2 * a + 1;
bool ok;
ok = 1;
if (!eq[i][i + 1]) ok = 0;
for (int x = i + 2; x <= j; x++) {
if (!lt[i][x]) ok = 0;
if (!lt[i + 1][x]) ok = 0;
}
if (ok) dp[i][j] += dp[i + 2][j];
ok = 1;
if (!eq[i][j]) ok = 0;
for (int x = i + 1; x < j; x++) {
if (!lt[i][x]) ok = 0;
if (!gt[x][j]) ok = 0;
}
if (ok) dp[i][j] += dp[i + 1][j - 1];
ok = 1;
if (!eq[j - 1][j]) ok = 0;
for (int x = i; x < j - 1; x++) {
if (!gt[x][j - 1]) ok = 0;
if (!gt[x][j]) ok = 0;
}
if (ok) dp[i][j] += dp[i][j - 2];
}
}
cout << dp[1][2 * n] << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int p[105];
char s[105];
int main() {
int n;
scanf("%d", &n);
getchar();
for (int i = 0; i < n; i++) {
scanf("%d", p + i);
getchar();
}
bool ok = true;
for (int j = 0; j < n; j++) {
gets(s);
for (int i = 0; s[i]; i++) {
switch (s[i]) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y':
p[j]--;
default:
break;
}
}
if (p[j]) ok = false;
}
puts(ok ? "YES" : "NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int num[500005];
int maps[500005];
int to[500005];
int main() {
ios::sync_with_stdio(0);
int n, m;
int l, r;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
to[num[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l, &r);
if (to[r] < to[l]) {
int tmp = r;
r = l;
l = tmp;
}
maps[to[r]] = max(to[l], maps[to[r]]);
}
l = 1;
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (maps[i] >= l) l = maps[i] + 1;
ans += i - l + 1;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long tree[1200005], ar[300005];
long long tme[300005], eve[300005];
void build(int node, int l, int r) {
if (l > r) return;
if (l == r) {
tree[node] = ar[l];
return;
}
build(node * 2, l, (l + r) / 2);
build(node * 2 + 1, (l + r) / 2 + 1, r);
tree[node] = min(tree[node * 2], tree[node * 2 + 1]);
}
long long query(int node, int l, int r, int ql, int qr) {
if (l > r || l > qr || r < ql) return LLONG_MAX;
if (l >= ql && r <= qr) return tree[node];
return min(query(node * 2, l, (l + r) / 2, ql, qr),
query(node * 2 + 1, (l + r) / 2 + 1, r, ql, qr));
}
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
int n;
long long a, b, c, d, start, len;
cin >> n >> a >> b >> c >> d >> start >> len;
for (int i = 1; i <= n; i++) {
long long t, q;
cin >> t >> q;
tme[i] = t;
eve[i] = q;
if (q == 0)
ar[i] = ar[i - 1] - d;
else
ar[i] = ar[i - 1] + c;
}
build(1, 1, n);
long long sum = start;
for (int i = 0; i <= n; i++) {
if (sum >= 0) {
long long k;
if (i)
k = tme[i - 1] + 1;
else
k = 0;
int q = lower_bound(tme + i, tme + n + 1, k + len) - tme - 1;
long long mini = query(1, 1, n, i, q);
if (i) mini -= ar[i - 1];
if (mini + sum >= 0) {
cout << k << endl;
return 0;
}
} else {
cout << -1 << endl;
return 0;
}
if (i && eve[i])
sum += a;
else if (i)
sum -= b;
}
if (sum >= 0)
cout << tme[n] + 1 << endl;
else
cout << -1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int day[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int record[5][20][40];
int main() {
char s[100015];
vector<int> num[3];
int len, m, d, y, ans, M, D, Y;
while (scanf(" %s", s) != EOF) {
for (int i = 0; i < 5; i++)
for (int j = 0; j < 20; j++)
for (int k = 0; k < 40; k++) record[i][j][k] = 0;
len = strlen(s), ans = 0;
for (int i = 0; i < 3; i++) num[i].clear();
s[len++] = '-';
for (int i = 0; i < len; i++) {
if (s[i] == '-') {
if (num[0].size() > 0 && num[1].size() == 2 && num[2].size() > 0) {
if (num[0].size() >= 2)
d = num[0][num[0].size() - 2] * 10 + num[0][num[0].size() - 1];
m = num[1][0] * 10 + num[1][1];
y = 0;
for (int x = 0; x < 4; x++) y = y * 10 + num[2][x];
if (2013 <= y && y <= 2015 && 1 <= m && m <= 12 && 1 <= d &&
d <= day[m]) {
record[y - 2013][m][d]++;
if (record[y - 2013][m][d] > ans) {
ans = record[y - 2013][m][d];
M = m;
D = d;
Y = y;
}
}
}
num[0] = num[1];
num[1] = num[2];
num[2].clear();
} else {
num[2].push_back(s[i] - '0');
}
}
printf("%02d-%02d-%d\n", D, M, Y);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
inline long long add(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x + _y;
if (_ >= _mod) _ -= _mod;
return _;
}
inline long long sub(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x - _y;
if (_ < 0) _ += _mod;
return _;
}
inline long long mul(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x * _y;
if (_ >= _mod) _ %= _mod;
return _;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1ll;
long long _tmp = mypow(_a, _x / 2, _mod);
_tmp = mul(_tmp, _tmp, _mod);
if (_x & 1) _tmp = mul(_tmp, _a, _mod);
return _tmp;
}
long long mymul(long long _a, long long _x, long long _mod) {
if (_x == 0) return 0ll;
long long _tmp = mymul(_a, _x / 2, _mod);
_tmp = add(_tmp, _tmp, _mod);
if (_x & 1) _tmp = add(_tmp, _a, _mod);
return _tmp;
}
inline bool equal(double _x, double _y) {
return _x > _y - 1e-12 && _x < _y + 1e-12;
}
int __ = 1, _cs;
void build() {}
inline pair<double, double> operator-(const pair<double, double>& p1,
const pair<double, double>& p2) {
return {p1.first - p2.first, p1.second - p2.second};
}
inline double operator*(const pair<double, double>& p1,
const pair<double, double>& p2) {
return p1.first * p2.first + p1.second * p2.second;
}
inline double norm(const pair<double, double>& tp) { return sqrt(tp * tp); }
inline double angle(const pair<double, double>& tp) {
return atan2(tp.second, tp.first);
}
const double pi = acos(-1.0);
inline void scan(pair<double, double>& _p) {
scanf("%lf%lf", &_p.first, &_p.second);
}
inline void scan(pair<pair<double, double>, double>& _c) {
scan(_c.first);
scanf("%lf", &_c.second);
}
inline bool in(const pair<double, double>& tp,
const pair<pair<double, double>, double>& tc) {
return norm(tp - tc.first) < tc.second + 1e-12;
}
inline double sqr(const double& tk) { return tk * tk; }
int n;
pair<double, double> o;
double v, t;
pair<pair<double, double>, double> c[101010];
void init() {
scan(o);
scanf("%lf%lf", &v, &t);
v *= t;
n = getint();
for (int i = 0; i < n; i++) scan(c[i]);
}
vector<pair<double, double> > ans;
void Add(const double& sang, const double& eang) {
if (sang < -pi) {
ans.push_back({sang + 2.0 * pi, pi});
ans.push_back({-pi, eang});
} else if (eang > pi) {
ans.push_back({sang, pi});
ans.push_back({-pi, eang - 2.0 * pi});
} else
ans.push_back({sang, eang});
}
void Add(const pair<pair<double, double>, double>& tc) {
double dst = norm(tc.first - o);
if (dst - tc.second > v) return;
double tangd = sqrt(sqr(dst) - sqr(tc.second));
double ang = angle(tc.first - o);
double theta = 0.0;
if (tangd < v + 1e-12)
theta = asin(tc.second / dst);
else
theta = acos((sqr(v) + sqr(dst) - sqr(tc.second)) / (2.0 * v * dst));
Add(ang - theta, ang + theta);
}
void solve() {
for (int i = 0; i < n; i++)
if (in(o, c[i])) {
printf("%.12f\n", 1.0);
exit(0);
}
for (int i = 0; i < n; i++) Add(c[i]);
sort((ans).begin(), (ans).end());
double sum = 0.0;
if (ans.size()) {
pair<double, double> pre = ans[0];
for (size_t i = 1; i < ans.size(); i++) {
if (ans[i].first < pre.second)
pre.second = max(pre.second, ans[i].second);
else {
sum += pre.second - pre.first;
pre = ans[i];
}
}
sum += pre.second - pre.first;
}
printf("%.12f\n", sum / (2.0 * pi));
}
int main() {
build();
while (__--) {
init();
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3 * 1e5 + 1;
long long n, m;
long long q[N];
vector<int> a, b;
int main() {
ios_base ::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<int> ans(m);
for (int i = 0; i < n + m; i++) {
cin >> q[i];
}
for (int i = 0; i < n + m; i++) {
bool x;
cin >> x;
if (x)
b.push_back(q[i]);
else
a.push_back(q[i]);
}
int pos = 0;
for (int i = 0; i < a.size(); i++) {
int mn = INFINITY;
for (int j = pos; j < b.size(); j++) {
if (abs(a[i] - b[j]) >= mn) break;
mn = min(mn, abs(a[i] - b[j]));
pos = j;
}
ans[pos]++;
}
for (auto it : ans) cout << it << ' ';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int64_t M1 = 998244353;
const int64_t M2 = 1000000007;
mt19937 rng((uint64_t)chrono::steady_clock::now().time_since_epoch().count());
void solve() {
int64_t n, m, k;
cin >> n >> m >> k;
vector<vector<int64_t>> a(n, vector<int64_t>(m));
for (int64_t i = 0; i < n; i++)
for (int64_t &x : a[i]) cin >> x;
int64_t ans = n * m;
if (m <= k) {
for (int64_t mask = 0; mask < (1 << m); mask++) {
int64_t sum = 0;
for (int64_t i = 0; i < n; i++) {
int64_t x = 0;
for (int64_t j = 0; j < m; j++) {
if (a[i][j] != ((mask >> j) & 1)) x++;
}
sum += min(x, m - x);
}
ans = min(ans, sum);
}
} else {
for (int64_t l = 0; l < m; l++) {
int64_t sum = 0;
for (int64_t j = 0; j < m; j++) {
int64_t x = 0;
for (int64_t i = 0; i < n; i++) {
if (a[i][l] != a[i][j]) x++;
}
sum += min(x, n - x);
}
ans = min(ans, sum);
}
}
if (ans > k) ans = -1;
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, d, n, m, k;
scanf("%d%d%d%d%d", &c, &d, &n, &m, &k);
int sum = n * m - k, ans = 0;
if (sum <= 0)
ans = 0;
else if (c / (1.0 * n) >= d)
ans = sum * d;
else {
ans += (sum / n * c);
ans += min(c, (sum % n) * d);
}
printf("%d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500 + 21, inf = 1e9 + 21;
int n, m;
int h[MAXN][MAXN];
pair<int, int> par[MAXN][MAXN];
pair<int, int> tmp;
queue<pair<int, int> > q;
vector<int> adj[MAXN];
vector<int> ans, res;
inline void bfs() {
while (!q.empty()) {
int u = q.front().first;
int v = q.front().second;
q.pop();
for (auto a : adj[u])
for (auto b : adj[v]) {
if (a != b && (h[a][b] > h[u][v] + 1)) {
h[a][b] = h[u][v] + 1;
par[a][b] = make_pair(u, v);
q.push(make_pair(a, b));
}
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
q.push(make_pair(1, n));
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) h[i][j] = inf;
h[1][n] = 0;
bfs();
if (h[n][1] == inf) return cout << -1 << '\n', 0;
for (int i = n, j = 1; i > 0 || j > 0;) {
tmp = par[i++][j++];
ans.push_back(j);
res.push_back(i);
i = tmp.first;
j = tmp.second;
}
cout << h[n][1] << '\n';
for (int y : ans) cout << y - 1 << ' ';
cout << '\n';
for (int y : res) cout << y - 1 << ' ';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int const dx[4] = {1, 0, 0, -1};
int const dy[4] = {0, -1, 1, 0};
char const dc[4] = {'D', 'L', 'R', 'U'};
struct Point {
int x, y;
Point() : x(0), y(0) {}
Point(int _x, int _y) : x(_x), y(_y) {}
Point operator+(const Point& point) const {
return Point(x + point.x, y + point.y);
}
};
int const maxN = 1010;
bool wall[maxN][maxN];
bool was[maxN][maxN];
int dist[maxN][maxN];
Point start;
Point que[maxN * maxN];
string ans;
int n, m, k;
bool good(Point u) {
return u.x >= 0 && u.x < n && u.y >= 0 && u.y < m && !wall[u.x][u.y];
}
bool bfs() {
int b = 0, e = 0;
que[e++] = start;
dist[start.x][start.y] = 0;
was[start.x][start.y] = true;
while (b < e) {
Point v = que[b++];
for (int i = 0; i < 4; ++i) {
Point u = v + Point(dx[i], dy[i]);
if (good(u) && !was[u.x][u.y]) {
was[u.x][u.y] = true;
dist[u.x][u.y] = dist[v.x][v.y] + 1;
que[e++] = u;
}
}
}
return e > 1;
}
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
scanf("%d%d%d\n", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
scanf("%c", &c);
wall[i][j] = (c == '*');
if (c == 'X') start = Point(i, j);
}
scanf("\n");
}
if (k % 2 == 1 || !bfs()) {
printf("IMPOSSIBLE\n");
return 0;
}
ans.clear();
ans.reserve(k);
Point v = start;
int turns = k;
while (turns > 0) {
int dir = -1;
for (int i = 0; i < 4 && dir < 0; ++i) {
Point u = v + Point(dx[i], dy[i]);
if (good(u) && turns - 1 >= dist[u.x][u.y]) dir = i;
}
v = v + Point(dx[dir], dy[dir]);
turns--;
ans.push_back(dc[dir]);
}
printf("%s\n", ans.c_str());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 300007;
const int MAX = 100007;
class lctT {
public:
lctT() {
for (int i = 0; i < MAXN; ++i) data[i] = nd[i] = make_pair(INF, i);
}
int link(int u, int v, int e, int x) {
if (!iscon(u, v))
return _link(u, v, e, x), -1;
else {
bool flag = false;
int mini = INF;
if (!(getsize(u, v) >> 1 & 1)) flag = true;
pair<int, int> ret = query(u, v);
mini = ret.first;
if (x > mini) {
cut(ret.second);
_link(u, v, e, x);
} else
mini = x;
return flag ? mini : -1;
}
}
void _link(int u, int v, int e, int x) {
link(u, e);
link(v, e);
eu[e] = u, ev[e] = v;
upd(e, x);
}
void link(int u, int v) {
croot(u);
access(v);
fa[u] = v;
access(u);
}
void cut(int e) {
if (eu[e]) {
cut(e, eu[e]);
cut(e, ev[e]);
eu[e] = ev[e] = 0;
}
}
void cut(int u, int v) {
croot(u);
access(v);
fa[u] = ch[v][0] = 0;
upd(v);
}
void upd(int now, int x) {
croot(now);
nd[now] = make_pair(x, now);
upd(now);
}
int getsize(int u, int v) {
croot(u);
access(v);
return size[v];
}
pair<int, int> query(int u, int v) {
croot(u);
access(v);
return data[v];
}
private:
void rot(int now) {
int nf = fa[now], np = fa[nf], d = ch[nf][1] == now;
fa[now] = np;
if (!isroot(nf)) ch[np][ch[np][1] == nf] = now;
fa[ch[now][d ^ 1]] = nf, ch[nf][d] = ch[now][d ^ 1];
fa[nf] = now, ch[now][d ^ 1] = nf;
upd(nf), upd(now);
}
void splay(int now) {
rev_push(now);
int nf, np;
while (!isroot(now)) {
nf = fa[now], np = fa[nf];
if (!isroot(nf))
rot(((ch[nf][0] == now) == (ch[np][0] == nf)) ? nf : now);
rot(now);
}
}
void access(int now) {
int v = 0, tn = now;
while (now) {
splay(now);
ch[now][1] = v;
upd(now);
v = now, now = fa[now];
}
splay(tn);
}
void croot(int now) {
access(now);
tag[now] ^= 1;
}
int getroot(int now) {
while (ch[now][0]) now = ch[now][0];
splay(now);
return now;
}
bool iscon(int u, int v) {
croot(u);
access(v);
return getroot(v) == u;
}
bool isroot(int now) {
return (!(fa[now] && ((ch[fa[now]][0] == now) || (ch[fa[now]][1] == now))));
}
void push_down(int now) {
if (tag[now]) {
tag[ch[now][0]] ^= 1, tag[ch[now][1]] ^= 1;
swap(ch[now][0], ch[now][1]);
tag[now] = 0;
}
}
void rev_push(int now) {
if (!isroot(now)) rev_push(fa[now]);
push_down(now);
}
void upd(int now) {
size[now] = size[ch[now][0]] + size[ch[now][1]] + 1;
data[now] =
min((((data[ch[now][0]]) < (data[ch[now][1]])) ? (data[ch[now][0]])
: (data[ch[now][1]])),
nd[now]);
}
int ch[MAXN][2], fa[MAXN], size[MAXN], eu[MAXN], ev[MAXN];
bool tag[MAXN];
pair<int, int> data[MAXN], nd[MAXN];
} lct;
int n, q;
int tp[MAXN], eu[MAXN], ev[MAXN], en[MAXN];
void init();
void input();
void work();
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= q; ++i) scanf("%d%d", &eu[i], &ev[i]);
}
void work() {
map<pair<int, int>, int> es;
map<pair<int, int>, int>::iterator it;
for (int i = 1; i <= q; ++i) {
if ((it = es.find(make_pair(eu[i], ev[i]))) == es.end())
es.insert(make_pair(make_pair(eu[i], ev[i]), i)), en[i] = INF, tp[i] = 1;
else {
en[it->second] = i;
en[i] = it->second;
es.erase(it);
tp[i] = 0;
}
}
int nt = -1;
for (int i = 1; i <= q; ++i) {
if (tp[i])
nt = max(nt, lct.link(eu[i], ev[i], i + MAX + 3, en[i]));
else
lct.cut(en[i] + MAX + 3);
printf((nt <= i) ? "YES\n" : "NO\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e9;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
long long p;
cin >> p;
long long q = sqrt(n);
vector<pair<int, int>> big_b, less_b;
map<pair<int, int>, vector<int>> mp;
for (long long i = 0; i < p; i++) {
int a, b;
cin >> a >> b;
a--;
mp[{a, b}].push_back(i);
if (b >= q)
big_b.push_back({a, b});
else
less_b.push_back({a, b});
}
vector<long long> ans(p, 0);
for (auto now : big_b) {
long long sum = 0;
for (long long i = now.first; i < n; i += now.second) {
sum += v[i];
}
ans[mp[now].back()] = sum;
mp[now].pop_back();
}
for (long long i = 1; i < q; i++) {
vector<long long> dp(n);
for (long long j = n - 1; j >= 0; j--) {
dp[j] = v[j];
if (j + i < n) {
dp[j] += dp[j + i];
}
}
for (auto now : less_b) {
if (now.second == i) {
ans[mp[now].back()] = dp[now.first];
mp[now].pop_back();
}
}
}
for (long long i = 0; i < p; i++) cout << ans[i] << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-11;
const long double oo = 1e12;
long long Q, M, ans = 0;
multiset<pair<long double, long double> > S;
long long dcmp(long double x) {
if (fabs(x) < eps) return 0;
return x < 0 ? -1 : 1;
}
long long trans(long long x) { return (x + ans) % 1000000 + 1; }
pair<long double, long double> operator-(pair<long double, long double> x,
pair<long double, long double> y) {
return make_pair(x.first - y.first, x.second - y.second);
}
namespace solution {
long long crs(pair<long double, long double> a,
pair<long double, long double> b) {
return a.first * b.second - a.second * b.first;
}
bool OK(pair<long double, long double> a, pair<long double, long double> b,
pair<long double, long double> c) {
return dcmp(crs(b - a, c - a)) <= 0;
}
void insert(pair<long double, long double> xy) {
multiset<pair<long double, long double> >::iterator it = S.lower_bound(
make_pair(xy.first,
0)),
ppre, pre, nxt;
if (it != S.end() && (*it).second <= xy.second) return;
pre = it;
pre--;
if (it != S.end() && OK(*pre, xy, *it)) return;
it = S.insert(xy);
nxt = pre = it;
ppre = --pre;
ppre--;
nxt++;
while (nxt != S.end() && (*nxt).first == xy.first) S.erase(nxt++);
while (pre != S.begin() && OK(*ppre, *pre, xy)) S.erase(pre--), ppre--;
}
void Prepare() {
scanf("%lld%lld", &Q, &M);
S.insert(make_pair(0, 0));
}
void Solve() {
long long k, a, b;
for (long long i = 1; i <= Q; i++) {
scanf("%lld%lld%lld", &k, &a, &b);
a = trans(a);
b = trans(b);
if (k == 1)
insert(make_pair(a, b));
else {
long double x = (long double)b / (long double)a;
multiset<pair<long double, long double> >::iterator it = S.lower_bound(
make_pair(x, 0)),
pre, nxt;
if (it == S.end()) {
puts("NO");
continue;
}
if (it->second * a <= M) {
puts("YES");
ans = i;
continue;
}
pre = nxt = it;
pre--;
if (OK(make_pair(pre->first * a, pre->second * a), make_pair(b, M),
make_pair(nxt->first * a, nxt->second * a))) {
puts("YES");
ans = i;
} else
puts("NO");
}
}
}
} // namespace solution
int main() {
using namespace solution;
Prepare();
Solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int b, k;
cin >> b >> k;
vector<int> a(k, 0);
for (int i = 0; i < k; i++) cin >> a[i];
if (b % 2 == 0 && a[k - 1] % 2 == 0) {
cout << "even";
return 0;
}
if (b % 2 == 0 && (a[k - 1] % 2) != 0) {
cout << "odd";
return 0;
}
long long curans = 0;
for (int i = 0; i < k; i++) {
if (a[i] % 2 != 0) {
curans = 1 - curans;
}
}
if (curans)
cout << "odd";
else
cout << "even";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
char s[10004];
char q[3][10004];
char ans[10004];
int main() {
std::ios::sync_with_stdio(false);
cin >> s;
int n = strlen(s);
cout << "? ";
for (int i = 0; i < n; ++i) {
cout << char((i % 26) + 'a');
}
cout << endl;
cin >> q[0];
cout << "? ";
for (int i = 0; i < n; ++i) {
cout << char(((i / 26) % 26) + 'a');
}
cout << endl;
cin >> q[1];
cout << "? ";
for (int i = 0; i < n; ++i) {
cout << char(((i / 26 / 26) % 26) + 'a');
}
cout << endl;
cin >> q[2];
for (int i = 0; i < n; ++i) {
int a = q[2][i] - 'a';
int b = q[1][i] - 'a';
int c = q[0][i] - 'a';
int idx = a * 26 * 26 + b * 26 + c;
ans[idx] = s[i];
}
cout << "! ";
for (int i = 0; i < n; ++i) {
cout << ans[i];
}
cout << endl;
return (0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
int a = (int)(s[i] - '0');
int b = 9 - a;
int c = min(a, b);
if (c == 0 && i == 0)
cout << a;
else
cout << c;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, next, f;
};
struct edge e[200010];
struct unit {
int s1, s2, c;
};
struct unit f[100010][2], ans;
int n, n1, k, k1, num;
int a[100010], b[100010], p[100010], used[100010], fa[100010], c[100010],
w[100010];
struct unit operator+(struct unit aa, struct unit bb) {
struct unit ret;
ret.c = 0;
ret.s1 = aa.s1 + bb.s1;
ret.s2 = aa.s2 + bb.s2;
return ret;
}
struct unit operator-(struct unit aa, struct unit bb) {
struct unit ret;
ret.c = 0;
ret.s1 = aa.s1 - bb.s1;
ret.s2 = aa.s2 - bb.s2;
return ret;
}
int cmp(struct unit aa, struct unit bb) {
if (aa.s1 > bb.s1 || (aa.s1 == bb.s1 && aa.s2 >= bb.s2))
return 1;
else
return 0;
}
void add(int u, int v) {
e[num].u = u;
e[num].v = v;
e[num].next = p[u];
p[u] = num;
num++;
e[num].u = v;
e[num].v = u;
e[num].next = p[v];
p[v] = num;
num++;
}
int find(int i) {
if (fa[i] == i) return i;
return fa[i] = find(fa[i]);
}
void dfs(int i, int fa) {
int j;
j = p[i];
while (j != -1) {
if (e[j].v != fa) {
if (e[j].v == e[k].v) {
k1 = j;
return;
} else
dfs(e[j].v, i);
}
j = e[j].next;
}
}
void work(int i, int fa) {
int j;
struct unit t;
used[i] = 1;
j = p[i];
f[i][0].s1 = 0;
f[i][0].s2 = 0;
f[i][1].s1 = 0;
f[i][1].s2 = 0;
while (j != -1) {
if (e[j].f == 0 && e[j].v != fa) {
work(e[j].v, i);
if (cmp(f[e[j].v][0], f[e[j].v][1]))
f[i][0] = f[i][0] + f[e[j].v][0];
else
f[i][0] = f[i][0] + f[e[j].v][1];
}
j = e[j].next;
}
j = p[i];
while (j != -1) {
if (e[j].f == 0 && e[j].v != fa) {
if (cmp(f[e[j].v][0], f[e[j].v][1]))
t = f[i][0] - f[e[j].v][0];
else
t = f[i][0] - f[e[j].v][1];
t = t + f[e[j].v][0];
t.s1++;
if (a[e[j].v] != a[i]) t.s2++;
if (cmp(t, f[i][1])) {
f[i][1] = t;
f[i][1].c = e[j].v;
}
}
j = e[j].next;
}
}
void calc(int i, int fa, int flag) {
int j, f1 = 0;
if (flag == 0 && cmp(f[i][1], f[i][0])) f1 = 1;
used[i] = 2;
j = p[i];
while (j != -1) {
if (e[j].f == 0 && e[j].v != fa) {
if (f1 == 1 && e[j].v == f[i][1].c) {
printf("%d %d\n", i, e[j].v);
calc(e[j].v, i, 1);
} else
calc(e[j].v, i, 0);
}
j = e[j].next;
}
}
int main() {
int i, j, fx, fy;
struct unit t;
scanf("%d", &n);
for (i = 1; i <= n; i++) fa[i] = i;
memset(p, -1, sizeof(p));
k = -1;
for (i = 1; i <= n; i++) {
scanf("%d%d", &b[i], &a[i]);
if (b[i] > i || b[b[i]] != i) {
add(i, b[i]);
fx = find(b[i]);
fy = find(i);
if (fx != fy)
fa[fx] = fy;
else {
n1++;
c[n1] = num - 1;
}
}
}
for (i = 1; i <= n1; i++) w[find(e[c[i]].u)] = c[i];
for (i = 1; i <= n; i++)
if (used[i] == 0) {
if (w[find(i)] == 0) {
work(i, 0);
if (cmp(f[i][0], f[i][1]))
ans = ans + f[i][0];
else
ans = ans + f[i][1];
} else {
k = w[find(i)];
dfs(e[k].u, e[k].v);
e[k].f = 1;
e[k ^ 1].f = 1;
work(i, 0);
e[k].f = 0;
e[k ^ 1].f = 0;
if (cmp(f[i][0], f[i][1]))
t = f[i][0];
else
t = f[i][1];
e[k1].f = 1;
e[k1 ^ 1].f = 1;
work(i, 0);
e[k1].f = 0;
e[k1 ^ 1].f = 0;
if (cmp(f[i][0], t)) t = f[i][0];
if (cmp(f[i][1], t)) t = f[i][1];
if (cmp(f[i][0], t) || cmp(f[i][1], t)) {
e[k1].f = 1;
e[k1 ^ 1].f = 1;
} else {
e[k].f = 1;
e[k ^ 1].f = 1;
work(i, 0);
}
ans = ans + t;
}
}
printf("%d %d\n", ans.s1, ans.s2);
for (i = 1; i <= n; i++)
if (used[i] == 1) calc(i, 0, 0);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
struct Query {
int l, r, id;
Query() {}
Query(int l, int r, int id) : l(l), r(r), id(id) {}
};
const int MAX_N = 200010;
const int MAX_Q = 200010;
int SQN = 1000;
bool cmp(const Query& A, const Query& B) {
if (A.l / SQN != B.l / SQN) return A.l / SQN < B.l / SQN;
return A.r < B.r;
}
long long a[MAX_N], freq[1000010], ans[MAX_Q], resp = 0;
Query Q[MAX_Q];
void add(int pos) {
int x = a[pos];
long long& q = freq[x];
resp += (2 * q + 1) * x;
++q;
}
void remove(int pos) {
int x = a[pos];
long long& q = freq[x];
--q;
resp -= (2 * q + 1) * x;
}
int main() {
memset(freq, 0, sizeof freq);
int n, q;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
for (int i = 0; i < q; ++i) {
int l, r;
scanf("%d %d", &l, &r);
Q[i] = Query(l - 1, r, i);
}
sort(Q, Q + q, cmp);
int l = 0, r = 0;
for (int i = 0; i < q; ++i) {
Query q = Q[i];
while (l > q.l) add(--l);
while (r < q.r) add(r++);
while (l < q.l) remove(l++);
while (r > q.r) remove(--r);
ans[q.id] = resp;
}
for (int i = 0; i < q; ++i) {
printf("%lld\n", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool p[10000002];
vector<int> primes;
void Gen() {
memset(p, 1, sizeof(p));
p[0] = p[1] = false;
for (int i = 2; i < 10000002; i++) {
if (!p[i]) continue;
primes.push_back(i);
for (int j = 2; i * j < 10000002; j++) {
p[i * j] = false;
}
}
}
bool Prime(int num) {
if (num < 2) return false;
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
int helping;
int n;
int main() {
scanf("%d", &n);
if (Prime(n)) {
printf("1\n%d\n", n);
return 0;
}
for (int i = n - 4; i >= 1; i--) {
if (!Prime(i)) continue;
helping = i;
break;
}
int tarprime = n - helping;
Gen();
for (int i = 0; i < primes.size(); i++) {
int ot = tarprime - primes[i];
if ((ot <= 10000000 && p[ot]) || Prime(ot)) {
printf("3\n%d %d %d\n", helping, primes[i], ot);
return 0;
}
}
for (int i = primes.back() + 1;; i++) {
int ot = tarprime - i;
if ((ot <= 10000000 && p[ot]) || Prime(ot)) {
printf("3\n%d %d %d\n", helping, primes[i], ot);
return 0;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nsize = 111111;
int n, m, pre, now, L, R, s, t, flag, cnt, a;
int num2[nsize], bj[nsize];
int incre[nsize] = {0}, decre[nsize] = {0};
int qincre[nsize] = {0}, qdecre[nsize] = {0};
int flaga = 0, flagb = 0;
int main() {
while (~scanf("%d %d", &n, &m)) {
cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
if (i == 1) {
num2[++cnt] = a;
bj[i] = cnt;
} else {
if (a != num2[cnt]) {
num2[++cnt] = a;
bj[i] = cnt;
} else
bj[i] = cnt;
}
}
pre = num2[1];
s = 0;
for (int i = 2; i <= cnt; i++) {
incre[i] = incre[i - 1];
decre[i] = decre[i - 1];
now = num2[i];
if (now > pre && s <= 0) {
flaga = incre[i];
flagb = decre[i];
incre[i]++;
s = 1;
}
if (now < pre && s >= 0) {
flaga = incre[i];
flagb = decre[i];
decre[i]++;
s = -1;
}
pre = now;
qincre[i - 1] = flaga;
qdecre[i - 1] = flagb;
}
qincre[cnt] = incre[cnt];
qdecre[cnt] = decre[cnt];
for (int i = 0; i < m; i++) {
scanf("%d %d", &L, &R);
s = incre[bj[R]] - qincre[bj[L]];
t = decre[bj[R]] - qdecre[bj[L]];
if ((s + t) <= 1)
flag = 1;
else if (s == 1 && t == 1 && num2[bj[L] + 1] > num2[bj[L]])
flag = 1;
else
flag = -1;
if (flag > 0 || bj[L] == bj[R])
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
while (~scanf("%d %d %d", &n, &m, &k)) {
char c;
if (k % 2)
c = 'L';
else
c = 'R';
int cnt = m * 2, y = k / cnt;
if (k % cnt) y++;
int xx = k % cnt, x;
if (!xx)
printf("%d %d %c\n", y, m, c);
else {
x = xx / 2;
if (xx % 2) x++;
printf("%d %d %c\n", y, x, c);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1010][1010];
int b[1010][1010], d[1010][1010];
int mc[1010], mr[1010];
struct qwe {
int v;
int id;
} c[1010];
bool cmp(qwe x, qwe y) { return x.v < y.v; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
c[j].id = j;
c[j].v = a[i][j];
}
sort(c + 1, c + m + 1, cmp);
b[i][c[1].id] = 1;
for (int j = 2; j <= m; j++) {
if (c[j].v > c[j - 1].v)
b[i][c[j].id] = b[i][c[j - 1].id] + 1;
else
b[i][c[j].id] = b[i][c[j - 1].id];
}
mr[i] = b[i][c[m].id];
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
c[j].id = j;
c[j].v = a[j][i];
}
sort(c + 1, c + n + 1, cmp);
d[c[1].id][i] = 1;
for (int j = 2; j <= n; j++) {
if (c[j].v > c[j - 1].v)
d[c[j].id][i] = d[c[j - 1].id][i] + 1;
else
d[c[j].id][i] = d[c[j - 1].id][i];
}
mc[i] = d[c[n].id][i];
}
int ans;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (b[i][j] == d[i][j]) {
if (mr[i] > mc[j])
ans = mr[i];
else
ans = mc[j];
} else if (b[i][j] > d[i][j]) {
if (mr[i] < mc[j] + b[i][j] - d[i][j])
ans = mc[j] + b[i][j] - d[i][j];
else
ans = mr[i];
} else {
if (mr[i] + d[i][j] - b[i][j] > mc[j])
ans = mr[i] + d[i][j] - b[i][j];
else
ans = mc[j];
}
printf("%d ", ans);
}
printf("\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
int a1, a2, a3, a4;
cin >> a1 >> a2 >> a3 >> a4;
int s0, s1;
bool flag = 1;
int tmp = sqrt(a1 * 2 + 0.5);
if (tmp * (tmp + 1) / 2 == a1)
s0 = tmp + 1;
else
flag = 0;
tmp = sqrt(a4 * 2 + 0.5);
if (tmp * (tmp + 1) / 2 == a4)
s1 = tmp + 1;
else
flag = 0;
if (flag == 0) {
cout << "Impossible" << endl;
return 0;
}
if (a2 == 0 && a3 == 0) {
if (a1 == 0) {
for (int j = 1; j <= s1; ++j) cout << '1';
cout << endl;
return 0;
} else if (a4 == 0) {
for (int j = 1; j <= s0; ++j) cout << '0';
cout << endl;
return 0;
}
}
if (s0 * s1 != a2 + a3) {
cout << "Impossible" << endl;
return 0;
}
while (a2 >= s1) {
a2 -= s1;
cout << '0';
--s0;
}
tmp = s1 - a2;
for (int j = 1; j <= tmp; ++j) cout << '1';
if (s0 > 0) {
cout << '0';
--s0;
}
for (int j = tmp + 1; j <= s1; ++j) cout << '1';
while (s0 > 0) {
cout << '0';
--s0;
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MOD = 1000000007;
bool tab[1002][1002];
vector<pair<vector<int>, int> > vec, col;
int pos[1002], who[1002];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, a, b;
cin >> n;
vec.resize(n);
for (int i = 0; i < n - 1; ++i) {
cin >> a >> b, a--, b--;
tab[a][b] = 1;
}
for (int i = 0; i < n; ++i) {
vec[i].second = i;
who[i] = i;
pos[i] = i;
for (int j = n - 1; j >= 0; j--)
if (tab[i][j]) vec[i].first.push_back(j);
}
vector<pair<int, pair<int, int> > > ans;
sort((vec).begin(), (vec).end());
for (int i = 0; i < n; i++)
if (pos[vec[i].second] != i) {
for (int j = 0; j < n; ++j) {
swap(tab[i][j], tab[pos[vec[i].second]][j]);
}
ans.push_back({1, {pos[vec[i].second], i}});
swap(who[pos[vec[i].second]], who[i]);
swap(pos[vec[i].second], pos[who[pos[vec[i].second]]]);
}
col.resize(n);
for (int i = 0; i < n; ++i) {
col[i].second = i;
pos[i] = i;
who[i] = i;
for (int j = 0; j < n; j++)
if (tab[j][i]) col[i].first.push_back(j);
if (!(long long)col[i].first.size()) {
for (int j = 0; j < n; ++j) col[i].first.push_back(1000000000);
}
}
sort((col).begin(), (col).end());
for (int i = 0; i < n; ++i)
if (pos[col[i].second] != i) {
ans.push_back({2, {pos[col[i].second], i}});
swap(who[pos[col[i].second]], who[i]);
swap(pos[col[i].second], pos[who[pos[col[i].second]]]);
}
cout << (long long)ans.size() << "\n";
for (auto it : ans)
cout << it.first << " " << it.second.first + 1 << " "
<< it.second.second + 1 << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int p[1 << 12], q[1 << 12], a[1 << 12], idx[1 << 12], val[1 << 12];
int K, sum;
void fix(int x, int y) {
int tv = a[x] ^ q[x];
int t = idx[tv];
if (t == x) return;
if (t == y) {
swap(p[x], p[y]);
swap(idx[p[x]], idx[p[y]]);
return;
}
swap(p[t], p[x]);
swap(idx[p[t]], idx[p[x]]);
swap(q[t], q[y]);
fix(t, y);
}
int main() {
scanf("%d", &K);
for (int i = 0; i < (1 << K); i++) {
scanf("%d", &a[i]);
p[i] = q[i] = idx[i] = i;
sum ^= a[i];
}
if (sum) {
puts("Fou");
return 0;
}
puts("Shi");
for (int i = 0; i < (1 << K); i++) {
if (val[i] ^ a[i]) {
val[i + 1] ^= val[i] ^ a[i];
val[i] = a[i];
fix(i, i + 1);
}
}
for (int i = 0; i < (1 << K); i++) printf("%d ", p[i]);
puts("");
for (int i = 0; i < (1 << K); i++) printf("%d ", q[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int isprime(long long num) {
if (num == 2) return 1;
if (num <= 1 || num % 2 == 0) return 0;
for (long long i = 3; i * i <= num; i += 2) {
if (num % i == 0) return 0;
}
return 1;
}
long long sum1(long long n) {
long long cnt = 0;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
cnt++;
if (n / i != i) cnt++;
}
}
return cnt;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
;
int t;
cin >> t;
while (t--) {
int num;
cin >> num;
num++;
cout << num / 10 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> s;
int main() {
ios_base::sync_with_stdio(0);
int n, x, ant, ans = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x;
s.insert(x);
}
ant = *(s.begin());
s.erase(s.begin());
while (s.size()) {
if (s.upper_bound(ant) != s.end()) {
x = *(s.upper_bound(ant));
s.erase(s.upper_bound(ant));
} else {
x = *(s.begin());
s.erase(s.begin());
}
if (x > ant) ++ans;
ant = x;
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC omptimize("unroll-loops")
#pragma GCC omptimize("ПивоНаПолу))))")
#pragma GCC optimize("no-stack-protector")
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
long long fpow(long long x, long long y) {
if (!y) return 1;
if (y == 1) return x;
if (y % 2)
return fpow(x, y - 1) * (x);
else {
long long d = fpow(x, y / 2);
return d * d;
}
}
const int mod = 1e9 + 7;
const int INF32 = 1009000999;
const long long INF64 = 4e18;
const int sz = 6e6;
const long double eps = 1e-12;
long long n, p, d;
long long h[sz];
long long pws[sz];
bool check(long long s, long long r) {
int c = __builtin_popcount(r);
return r >= s && s >= c && r > 0;
}
void Solve() {
cin >> n >> p;
for (int i = 0; i < sz; i++) {
if (check((i + 1), (n - ((i + 1) * p)))) {
cout << (i + 1);
return;
}
}
cout << -1;
}
signed main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int q = 1;
while (q--) Solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 77, L = 26;
int n, S[N][L], t = 1, H[N], A;
char s[N];
multiset<int> D[N];
void insert() {
int m = strlen(s), id = 1;
for (int i = 0; i < m; i++) {
if (S[id][s[i] - 'a'] == 0) {
++t;
S[id][s[i] - 'a'] = t;
}
id = S[id][s[i] - 'a'];
}
H[id]++;
A += m;
}
void dfs(int v) {
for (int i = 0; i < L; i++) {
if (S[v][i] == 0) {
continue;
}
dfs(S[v][i]);
for (auto x : D[S[v][i]]) {
D[v].insert(x + 1);
}
}
if (H[v]) {
D[v].insert(0);
} else if (v > 1) {
int P = *D[v].rbegin();
A -= P;
D[v].erase(D[v].find(P));
D[v].insert(0);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", &s);
insert();
}
dfs(1);
printf("%d\n", A);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const long long M = 1e9 + 7;
long long power(long long a, long long b) {
long long res = 1;
a %= M;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % M;
a = a * a % M;
}
return res;
}
long long min(long long a, long long b) {
if (a > b)
return b;
else
return a;
}
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long gcd(long long a, long long b) {
if (b > a) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n * 2);
for (long long i = 0; i < 2 * n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
long long check = n;
long long sum = 0;
long long check1 = 0;
for (long long i = 0; i < n * 2; i++) {
if (i < check) {
sum += v[i];
} else {
check1 += v[i];
}
}
if (check1 == sum) {
cout << -1;
} else {
for (long long i = 0; i < n * 2; i++) {
cout << v[i] << " ";
}
}
}
int32_t main() { solve(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e5 + 999;
map<long long, long long> cnt;
long long tot;
long long f[maxn];
inline void init() {
f[0] = 1;
for (long long i = 1; i < maxn; i++) f[i] = f[i - 1] * i;
}
void solve() {
cnt.clear();
tot = 0;
long long x;
scanf("%lld", &x);
long long temp = x;
for (long long i = 2; temp && i <= 29; i++) {
cnt[temp % i]++;
temp /= i;
tot++;
}
long long res = 0;
long long temp1 = 1;
long long nowhave = cnt[0];
for (long long pos = 1; pos <= tot; pos++) {
nowhave += cnt[pos];
temp1 *= nowhave;
nowhave--;
}
for (auto ite : cnt) temp1 /= f[ite.second];
res = temp1;
if (cnt[0] > 0) {
cnt[0]--;
temp1 = 1;
nowhave = cnt[0];
for (long long pos = 1; pos < tot; pos++) {
nowhave += cnt[pos];
temp1 *= nowhave;
nowhave--;
}
for (auto ite : cnt) temp1 /= f[ite.second];
res -= temp1;
}
res--;
printf("%lld\n", res);
}
signed main() {
init();
long long T;
cin >> T;
while (T--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m;
int a[N];
bool check(long long x) {
if (x & 1)
return x * (x - 1) / 2 + 1 <= n;
else
return x * (x - 1) / 2 + 1 + (x - 2) / 2 <= n;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int x;
scanf("%d%d", &x, &a[i]);
}
sort(a + 1, a + m + 1, greater<int>());
int l;
for (l = m; l >= 0; --l) {
if (check(l)) break;
}
long long ans = 0;
for (int i = 1; i <= l; ++i) ans += a[i];
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
vector<int> aa[MAXN];
int x[MAXN], y[MAXN];
int res;
void dfs(int v, int p) {
int bx1 = 0, bx2 = 0;
int by1 = 0, by2 = 0;
int b1 = 0, b2 = 0;
for (int a : aa[v]) {
if (a == p) continue;
dfs(a, v);
if (bx1 < x[a]) {
bx2 = bx1;
bx1 = x[a];
} else if (bx2 < x[a])
bx2 = x[a];
if (by1 < y[a]) {
by2 = by1;
by1 = y[a];
} else if (by2 < y[a])
by2 = y[a];
if (b1 < max(x[a], y[a])) {
b2 = b1;
b1 = max(x[a], y[a]);
} else if (b2 < max(x[a], y[a]))
b2 = max(x[a], y[a]);
}
x[v] = 1 + by1;
y[v] = aa[v].size() - (p != -1) + b1 - (b1 > 0);
res = max(res, x[v]);
res = max(res, y[v]);
res = max(res, 1 + by1 + by2);
res = max(res, (int)aa[v].size() + b1 + b2 - (b1 > 0) - (b2 > 0));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
aa[u].push_back(v);
aa[v].push_back(u);
}
dfs(0, -1);
cout << res << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int s, a, b, c;
cin >> s >> a >> b >> c;
long long int x = s / c;
long long ans = x + (x / a) * b;
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6, INF = 1e9 + 2, MOD = 1e9 + 7;
string mas[22];
int mn[22];
int en[22];
unordered_map<int, int> cnt[22];
pair<int, int> dp[N];
pair<int, int> add(int i, pair<int, int> res) {
for (int j = 0; j < mas[i].size(); j++) {
if (mas[i][j] == ')')
res.first--;
else
res.first++;
if (res.first < 0) {
return res;
}
if (res.first == 0) res.second++;
}
return res;
}
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> mas[i];
for (int i = 0; i < n; i++) {
int c = 0;
for (int j = 0; j < mas[i].size(); j++) {
if (mas[i][j] == '(')
c++;
else
c--;
if (c < mn[i]) {
mn[i] = c;
}
if (c == mn[i]) cnt[i][c]++;
}
en[i] = c;
}
for (int i = 0; i < N; i++) {
dp[i] = {-1, -1};
}
dp[0] = {0, 0};
int ans = 0;
for (int mask = 0; mask < (1 << n); mask++) {
if (dp[mask].first < 0) continue;
for (int j = 0; j < n; j++) {
if ((mask & (1 << j)) == 0) {
int nextmask = mask ^ (1 << j);
if (dp[mask].first >= -mn[j]) {
pair<int, int> a = {dp[mask].first + en[j], dp[mask].second};
if (dp[mask].first == -mn[j]) a.second += cnt[j][-dp[mask].first];
ans = max(ans, a.second);
if (a.first >= 0 && a.second > dp[nextmask].second) {
dp[nextmask] = a;
}
} else {
pair<int, int> a = {-1, dp[mask].second + cnt[j][-dp[mask].first]};
ans = max(ans, a.second);
}
}
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a, ans, i, j, col, b[36001], sum[36001], len, null;
string s;
map<long long, long long> c;
bool ok;
int main() {
cin >> a;
cin >> s;
ans = 0;
for (i = 0; i < s.size(); i++) b[++ans] = (s[i] - '0');
for (i = 1; i <= ans; i++) sum[i] = sum[i - 1] + b[i];
for (i = 1; i <= ans; i++)
for (j = i; j <= ans; j++) {
c[sum[j] - sum[i - 1]]++;
if (sum[j] - sum[i - 1] == 0) null++;
len++;
}
if (a == 0) {
for (i = 1; i <= ans; i++)
for (j = i; j <= ans; j++) {
if ((sum[j] - sum[i - 1]) == 0)
col += len;
else if ((sum[j] - sum[i - 1]) != 0)
col += null;
}
} else {
for (i = 1; i <= ans; i++)
for (j = i; j <= ans; j++)
if (sum[j] - sum[i - 1] != 0 && (a % (sum[j] - sum[i - 1])) == 0)
col = col + c[a / (sum[j] - sum[i - 1])];
}
cout << col;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MAXV = 1000000;
int N;
int it[MAXV * 4 + 100];
bool dau[MAXV + 10];
int fast_int() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int res = 0;
while (c >= '0' && c <= '9') {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
void nhap() {
N = fast_int();
memset(dau, 0, sizeof(dau));
for (int i = 1; i <= N; i++) {
int t = fast_int();
dau[t] = 1;
}
}
void update(int u, int l, int r, int k) {
it[k] = max(it[k], u);
if (l == r) return;
int mid = (l + r) / 2;
if (u <= mid)
update(u, l, mid, (k << 1));
else
update(u, mid + 1, r, (k << 1) + 1);
}
int get(int u, int v, int l, int r, int k) {
if (u > r || v < l) return 0;
if (u <= l && v >= r) return it[k];
int mid = (l + r) / 2;
int t1 = get(u, v, l, mid, (k << 1)),
t2 = get(u, v, mid + 1, r, (k << 1) + 1);
return max(t1, t2);
}
void tinh() {
int res = 0;
memset(it, 0, sizeof(it));
for (int i = MAXV; i >= 1; i--)
if (dau[i]) {
if (res > i) break;
update(i, 1, MAXV, 1);
int l = i;
while (l <= MAXV) {
int r = min(l + i - 1, MAXV);
int t = get(l, r, 1, MAXV, 1);
if (t != 0) {
res = max(res, t - l);
}
l = r + 1;
}
}
printf("%d\n", res);
}
int main() {
nhap();
tinh();
fclose(stdin);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const long long MOD = 1e9 + 7;
const long long EPS = 1e-9;
const long long N = 1005;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
if (k > (n - k + 1)) {
k = n - k + 1;
}
long long ans = 0;
ans += 2;
ans += (1 + 1 + 1 + 1);
ans += (k - 2) * (3);
if (k < n) {
ans += (k - 1);
}
ans += (n - k) * (3);
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> power;
vector<long long int> ans;
void preprocess() {
for (long long int i = 0; i < 18; i++)
power.push_back((long long int)pow(3, i));
for (long long int i = 0; i < 1 << 18; i++) {
bitset<20> b(i);
long long int sum = 0;
for (long long int j = 0; j < 20; j++) {
if (b[j] == 1) sum += power[j];
}
ans.push_back(sum);
}
sort(begin(ans), end(ans));
}
void solve() {
long long int n;
cin >> n;
cout << *lower_bound(begin(ans), end(ans), n) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
cin >> t;
preprocess();
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<string> s(n);
for (long long i = (0); i < (n); i++) cin >> s[i];
long long ans = 0;
long long dx[] = {-1, -1, 1, 1}, dy[] = {-1, 1, -1, 1};
for (long long i = (1); i < (n - 1); i++) {
for (long long j = (1); j < (n - 1); j++) {
if (s[i][j] != 'X') continue;
bool f = true;
for (long long k = (0); k < (4); k++) {
if (s[i + dx[k]][j + dy[k]] != 'X') f = false;
}
if (f) ans++;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
string s[n + 1], t[m + 1];
for (long long i = 1; i <= n; i++) {
cin >> s[i];
}
for (long long i = 1; i <= m; i++) {
cin >> t[i];
}
long long q;
cin >> q;
while (q--) {
long long a;
cin >> a;
long long b = a % n;
long long c = a % m;
if (b == 0) {
b = n;
}
if (c == 0) {
c = m;
}
cout << s[b] << t[c] << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000000;
bool viz[MAX_N + 100];
vector<int> v;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
viz[a] = true;
}
n = MAX_N;
int cat = 0;
for (int i = 1; i <= n / 2; i++) {
if (viz[i]) {
if (!viz[n - i + 1]) {
v.push_back(n - i + 1);
viz[n - i + 1] = true;
} else {
cat++;
}
} else if (viz[n - i + 1]) {
v.push_back(i);
viz[i] = true;
}
}
for (int i = 1; i <= n / 2 && cat; i++) {
if (cat && !viz[i]) {
cat--;
v.push_back(i);
v.push_back(n - i + 1);
}
}
printf("%d\n", (int)v.size());
for (auto it = v.begin(); it != v.end(); it++) {
printf("%d ", *it);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, res[2][4];
void solve(int x1, int y1, int x2, int y2, int id) {
int l = x1, r = x2;
while (l < r) {
int m = (l + r) >> 1;
printf("? %d %d %d %d\n", x1, y1, m, y2);
fflush(stdout);
int num;
scanf("%d", &num);
if (num > 0)
r = m;
else
l = m + 1;
}
x2 = l;
l = x1, r = x2;
while (l < r) {
int m = (l + r + 1) >> 1;
printf("? %d %d %d %d\n", m, y1, x2, y2);
fflush(stdout);
int num;
scanf("%d", &num);
if (num > 0)
l = m;
else
r = m - 1;
}
x1 = l;
l = y1, r = y2;
while (l < r) {
int m = (l + r) >> 1;
printf("? %d %d %d %d\n", x1, y1, x2, m);
fflush(stdout);
int num;
scanf("%d", &num);
if (num > 0)
r = m;
else
l = m + 1;
}
y2 = l;
l = y1, r = y2;
while (l < r) {
int m = (l + r + 1) >> 1;
printf("? %d %d %d %d\n", x1, m, x2, y2);
fflush(stdout);
int num;
scanf("%d", &num);
if (num > 0)
l = m;
else
r = m - 1;
}
y1 = l;
res[id][0] = x1;
res[id][1] = y1;
res[id][2] = x2;
res[id][3] = y2;
}
void find() {
int l = 1, r = n;
while (l < r) {
int m = (l + r) >> 1;
printf("? 1 1 %d %d\n", n, m);
fflush(stdout);
int num;
scanf("%d", &num);
if (num > 0)
r = m;
else
l = m + 1;
}
int num[2];
printf("? 1 1 %d %d\n", n, l);
fflush(stdout);
scanf("%d", &num[0]);
if (l != n) {
printf("? 1 %d %d %d\n", l + 1, n, n);
fflush(stdout);
scanf("%d", &num[1]);
} else
num[1] = 0;
if (num[0] == 1 && num[1] == 1) {
solve(1, 1, n, l, 0);
solve(1, l + 1, n, n, 1);
return;
}
l = 1, r = n;
while (l < r) {
int m = (l + r) >> 1;
printf("? 1 1 %d %d\n", m, n);
fflush(stdout);
int num;
scanf("%d", &num);
if (num > 0)
r = m;
else
l = m + 1;
}
solve(1, 1, l, n, 0);
solve(l + 1, 1, n, n, 1);
}
int main() {
scanf("%d", &n);
find();
printf("!");
for (int i = 0; i < 2; i++)
for (int j = 0; j < 4; j++) printf(" %d", res[i][j]);
fflush(stdout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, i = 0, ans = 0;
cin >> a >> b;
int v[] = {2, 3, 5};
while (i < 3) {
int x = 0, y = 0;
while (a % v[i] == 0) {
a /= v[i];
x++;
}
while (b % v[i] == 0) {
b /= v[i];
y++;
}
ans += abs(x - y);
i++;
}
if (a != b) {
cout << "-1";
} else {
cout << ans;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int to[MAXN], a[MAXN], b[MAXN];
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
to[a[i]] = b[i];
}
for (int i = 1; i <= n; i++) printf("%d ", to[i]);
puts("");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long BASE = 31, MOD = 1e9 + 7, N = 1e6 + 5;
string s, t;
long long n, p[N], pre[N];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
p[0] = 1;
for (long long i = 1; i < N; i++) p[i] = p[i - 1] * BASE % MOD;
long long T = 1;
while (T--) {
cin >> s >> t;
n = s.size();
for (long long i = 0; i < n; i++)
pre[i + 1] = (pre[i] * BASE + (s[i] - 'a' + 1)) % MOD;
long long tx = 0;
for (long long i = 0; i < t.size(); i++)
tx = (tx * BASE + (t[i] - 'a' + 1)) % MOD;
vector<long long> ans;
for (long long i = 0; i < n; i++) {
long long sx = (pre[i] * p[n - i - 1] % MOD + pre[n] -
pre[i + 1] * p[n - i - 1] % MOD + MOD) %
MOD;
if (sx == tx) ans.push_back(i + 1);
}
cout << ans.size() << '\n';
for (auto &&x : ans) cout << x << ' ';
cout << '\n';
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.