solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
long long min(long long x, long long y) {
if (x < y) return x;
return y;
}
long long fun(long long n, long long m, long long k) {
if (k <= 0) return n * m;
long long max = (n > m) ? n : m;
long long res1 = 0, res2 = 0;
if (n % (k + 1) == 0) res1 = m * (n / (k + 1));
if (m % (k + 1) == 0) res2 = n * (m / (k + 1));
if (res1 && res2) {
if (res1 > res2) return res1;
return res2;
} else if (res1)
return res1;
else if (res2)
return res2;
if (k >= max) {
res1 = min(fun(n, m, n - 1), fun(1, m, k - n + 1));
res2 = min(fun(n, m, m - 1), fun(n, 1, k - m + 1));
if (res1 > res2) return res1;
return res2;
} else {
res1 = m * (n / (k + 1));
res2 = n * (m / (k + 1));
if (res1 > res2) return res1;
return res2;
}
}
int main() {
long long n, m, k;
scanf("%lld%lld%lld", &n, &m, &k);
if (n + m - 2 < k) {
printf("-1\n");
return 0;
}
if (n > m)
printf("%lld\n", fun(n, m, k));
else
printf("%lld\n", fun(m, n, k));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, low = 1, high;
bool x = false;
cin >> n;
high = n;
while (high >= low) {
if (x)
cout << high-- << ' ';
else
cout << low++ << ' ';
x = !x;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
cout << n * 6 * (n - 1) + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const double eps = 0.0;
template <typename T>
inline int cmpT(T x) {
return x < 0 ? -1 : x > 0;
}
template <>
inline int cmpT(double x) {
return x < -eps ? -1 : x > eps;
}
template <typename T>
struct VecT {
T x = 0;
T y = 0;
static_assert(std::is_arithmetic<T>::value, "Should be an arithmetic type.");
VecT() {}
VecT(T x, T y) : x(x), y(y) {}
VecT operator+(const VecT& rhs) const { return VecT(x + rhs.x, y + rhs.y); }
VecT& operator+=(const VecT& rhs) {
*this = *this + rhs;
return *this;
}
VecT operator-(const VecT& rhs) const { return VecT(x - rhs.x, y - rhs.y); }
VecT& operator-=(const VecT& rhs) {
*this = *this - rhs;
return *this;
}
VecT operator*(T t) const { return VecT(x * t, y * t); }
VecT& operator*=(T t) {
*this = *this * t;
return *this;
}
bool operator<(const VecT& rhs) const {
if (cmpT(x - rhs.x) == 0) return cmpT(y - rhs.y) < 0;
return cmpT(x - rhs.x) < 0;
}
bool operator>(const VecT& rhs) const { return rhs < *this; }
bool operator==(const VecT& rhs) const {
return cmpT(x - rhs.x) == 0 && cmpT(y - rhs.y) == 0;
}
bool operator!=(const VecT& rhs) const { return !(*this == rhs); }
T length_sqr() const { return x * x + y * y; }
VecT rotate90() const { return VecT(-y, x); }
double length() const { return hypot(x, y); }
VecT<double> rotate(double angle) const {
double c = cos(angle), s = sin(angle);
return VecT<double>(x * c - y * s, x * s + y * c);
}
VecT<double> operator/(double t) const { return VecT<double>(x / t, y / t); }
VecT<double>& operator/=(double t) {
*this = *this / t;
return *this;
}
template <typename U>
VecT<U> convert() const {
return VecT<U>(x, y);
}
};
template <typename T>
std::string to_string(const VecT<T>& v) {
return std::string("VecT{x=") + std::to_string(v.x) +
",y=" + std::to_string(v.y) + "}";
}
template <typename T>
T det(const VecT<T>& a, const VecT<T>& b) {
return a.x * b.y - a.y * b.x;
}
template <typename T>
T dot(const VecT<T>& a, const VecT<T>& b) {
return a.x * b.x + a.y * b.y;
}
template <typename T>
using PointT = VecT<T>;
template <typename T>
using PolygonT = std::vector<PointT<T>>;
template <typename T>
bool polar_cmp(const VecT<T>& a, const VecT<T>& b) {
if (cmpT(a.y) * cmpT(b.y) <= 0) {
if (cmpT(a.y) > 0 || cmpT(b.y) > 0) return cmpT(a.y - b.y) < 0;
if (cmpT(a.y) == 0 && cmpT(b.y) == 0) return cmpT(a.x - b.x) < 0;
}
return cmpT(det(a, b)) > 0;
}
template <typename T>
PointT<double> intersection_line_line(const PointT<T>& p, const PointT<T>& pp,
const PointT<T>& q, const PointT<T>& qq) {
const VecT<T> u = p - q, v = pp - p, w = qq - q;
const double ratio = det(w, u) / static_cast<double>(det(v, w));
return PointT<double>(p.x + v.x * ratio, p.y + v.y * ratio);
}
template <typename T>
PointT<double> projection_point_line(const PointT<T>& p, const PointT<T>& a,
const PointT<T>& b) {
const VecT<T> v = b - a;
const double ratio = dot(v, p - a) / static_cast<double>(dot(v, v));
return PointT<double>(a.x + v.x * ratio, a.y + v.y * ratio);
}
template <typename T>
double distance_point_line(const PointT<T>& p, const PointT<T>& a,
const PointT<T>& b) {
const VecT<T> v1 = b - a, v2 = p - a;
return std::abs(det(v1, v2)) / v1.length();
}
template <typename T>
double distance_point_segment(const PointT<T>& p, const PointT<T>& a,
const PointT<T>& b) {
if (a == b) return (p - a).length();
const VecT<T> v1 = b - a, v2 = p - a, v3 = p - b;
if (cmpT(dot(v1, v2)) < 0)
return v2.length();
else if (cmpT(dot(v1, v3)) > 0)
return v3.length();
else
return std::abs(det(v1, v2)) / v1.length();
}
template <typename T>
bool has_proper_intersection_segment_segment(const PointT<T>& a1,
const PointT<T>& a2,
const PointT<T>& b1,
const PointT<T>& b2) {
T c1 = det(a2 - a1, b1 - a1), c2 = det(a2 - a1, b2 - a1),
c3 = det(b2 - b1, a1 - b1), c4 = det(b2 - b1, a2 - b1);
return cmpT(c1) * cmpT(c2) < 0 && cmpT(c3) * cmpT(c4) < 0;
}
template <typename T>
bool on_point_segment(const PointT<T>& p, const PointT<T>& a1,
const PointT<T>& a2) {
return cmpT(det(a1 - p, a2 - p)) == 0 && cmpT(dot(a1 - p, a2 - p)) <= 0;
}
template <typename T>
bool has_intersection_segment_segment(const PointT<T>& a1, const PointT<T>& a2,
const PointT<T>& b1,
const PointT<T>& b2) {
if (has_proper_intersection_segment_segment(a1, a2, b1, b2)) return true;
return on_point_segment(a1, b1, b2) || on_point_segment(a2, b1, b2) ||
on_point_segment(b1, a1, a2) || on_point_segment(b2, a1, a2);
}
template <typename T>
bool in_point_polygon(const PointT<T>& o, const PolygonT<T>& poly, bool flag) {
int t = 0;
PointT<T> a, b;
const int n = poly.size();
for (int i = 0; i < n; ++i)
if (on_point_segment(o, poly[i], poly[(i + 1) % n])) return flag;
for (int i = 0; i < n; ++i) {
a = poly[i];
b = poly[(i + 1) % n];
if (cmpT(a.y - b.y) > 0) std::swap(a, b);
if (cmpT(det(a - o, b - o)) < 0 && cmpT(a.y - o.y) < 0 &&
cmpT(o.y - b.y) <= 0)
++t;
}
return t & 1;
}
inline int dcmp(double x) { return cmpT(x); }
using LL = long long;
const int kN = 100000 + 5;
int n;
LL k;
PointT<int> points[kN];
LL binom(int a, int b) {
if (a < b || b < 0) return 0;
LL ret = 1;
for (int i = 1; i <= b; ++i) ret = ret * (a + 1 - i) / i;
return ret;
}
using Point = PointT<double>;
struct Fenwick {
std::vector<int> c;
Fenwick(int n) : c(n) {}
void update(int p, int dt) {
for (int i = p; i < c.size(); i += ~i & i + 1) c[i] += dt;
}
int query(int p) const {
int ret = 0;
for (int i = p; i >= 0; i -= ~i & i + 1) ret += c[i];
return ret;
}
};
bool gao(double r) {
int inner = 0;
std::vector<Point> lp, rp;
for (int i = 0; i < n; ++i) {
const double d = points[i].length();
if (dcmp(d - r) <= 0) {
++inner;
continue;
}
const double theta = acos(r / d);
const Point u = points[i].convert<double>() * (r / d);
lp.emplace_back(u.rotate(-theta));
rp.emplace_back(u.rotate(theta));
}
std::vector<Point> pts;
pts.insert(pts.end(), lp.begin(), lp.end());
pts.insert(pts.end(), rp.begin(), rp.end());
std::sort(pts.begin(), pts.end(), polar_cmp<double>);
pts.erase(std::unique(pts.begin(), pts.end()), pts.end());
int m = pts.size();
std::vector<std::vector<int>> segments(m), events(m);
auto get = [&pts](const Point& p) {
return std::lower_bound(pts.begin(), pts.end(), p, polar_cmp<double>) -
pts.begin();
};
for (int i = 0; i < lp.size(); ++i) {
segments[get(lp[i])].emplace_back(get(rp[i]));
}
Fenwick bit(m + m);
for (int i = 0; i < m; ++i) {
for (int e : events[i]) {
bit.update(e, -1);
}
events[i].clear();
for (int e : segments[i]) {
bit.update(i, 1);
events[e].emplace_back(i);
}
}
LL bad = 0;
for (int i = 0; i < m; ++i) {
for (int e : events[i]) {
bit.update(e, -1);
}
for (int e : events[i]) {
bad += bit.query(i + m) - bit.query(e);
}
events[i].clear();
for (int e : segments[i]) {
bit.update(i + m, 1);
events[e].emplace_back(i + m);
}
}
int outer = n - inner;
LL cnt = outer * 1LL * inner + binom(inner, 2) + binom(outer, 2) - bad;
1145141919810;
return cnt >= k;
}
double solve() {
double l = 0.0, r = 20000.0;
while ((r - l) > 1e-7) {
double mid = (l + r) * 0.5;
if (gao(mid))
r = mid;
else
l = mid;
}
return (l + r) * 0.5;
}
int main() {
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &points[i].x, &points[i].y);
}
printf("%.13f\n", solve());
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;cin>>t;
while(t--){
int n;cin>>n;
long long sum = 0;
vector<int> vec(n);
for(int i = 0;i < n;i++){
cin>>vec[i];
}
bool flag = false;
long long needed = 0;
for(long long i = 0;i < n;i++){
sum += vec[i];
needed += i;
if(sum < needed){
cout<<"NO"<<endl;
flag = true;
break;
}
}
if(!flag)cout<<"YES"<<endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[52][2600];
int main() {
int n, a;
cin >> n >> a;
dp[0][0] = 1;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
for (int j = i; j >= 0; --j) {
for (int k = 2550; k >= x; --k) {
dp[j + 1][k] += dp[j][k - x];
}
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += dp[i][i * a];
}
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> roda(int f, vector<int> valores) {
vector<int> temp(valores);
if (f == 0) {
temp[17] = valores[5];
temp[18] = valores[6];
temp[21] = valores[17];
temp[22] = valores[18];
temp[13] = valores[21];
temp[14] = valores[22];
temp[5] = valores[13];
temp[6] = valores[14];
} else if (f == 1) {
temp[3] = valores[17];
temp[4] = valores[19];
temp[16] = valores[3];
temp[14] = valores[4];
temp[10] = valores[16];
temp[9] = valores[14];
temp[17] = valores[10];
temp[19] = valores[9];
} else if (f == 2) {
temp[20] = valores[7];
temp[19] = valores[8];
temp[24] = valores[20];
temp[23] = valores[19];
temp[15] = valores[24];
temp[16] = valores[23];
temp[7] = valores[15];
temp[8] = valores[16];
} else if (f == 3) {
temp[1] = valores[24];
temp[3] = valores[22];
temp[5] = valores[1];
temp[7] = valores[3];
temp[9] = valores[5];
temp[11] = valores[7];
temp[24] = valores[9];
temp[22] = valores[11];
} else if (f == 4) {
temp[2] = valores[23];
temp[4] = valores[21];
temp[6] = valores[6];
temp[8] = valores[8];
temp[10] = valores[10];
temp[12] = valores[12];
temp[23] = valores[23];
temp[21] = valores[21];
} else if (f == 5) {
temp[1] = valores[15];
temp[2] = valores[13];
temp[18] = valores[1];
temp[20] = valores[2];
temp[12] = valores[18];
temp[11] = valores[20];
temp[15] = valores[12];
temp[13] = valores[11];
}
return temp;
}
bool checa(vector<int> valores) {
for (int i = 0; i < 6; i++) {
int cor = valores[1 + i * 4];
for (int j = 1; j < 4; j++)
if (valores[1 + i * 4 + j] != cor) return false;
}
return true;
}
int main() {
vector<int> valores(25);
int i;
for (i = 1; i < 25; i++) cin >> valores[i];
int resp = 0;
for (i = 0; i < 6; i++) {
resp = resp || checa(roda(i, valores));
resp = resp || checa(roda(i, roda(i, roda(i, valores))));
}
if (resp)
puts("YES");
else
puts("NO");
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int N=120;
typedef long long ll;
int dp[2][N][N],f[N][N],n,m,K,pw[N][N],C[N][N],mod,T;
int main(){
cin>>n>>m>>K>>mod;
for(int i=0;i<N;++i){
pw[i][0]=1;C[i][0]=1;
for(int j=1;j<N;++j)pw[i][j]=(ll)pw[i][j-1]*i%mod;
for(int j=1;j<=i;++j)C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
}
dp[0][0][0]=1;
for(int t=1;t<=K;++t){
T^=1;memset(dp[T],0,sizeof dp[T]);memset(f,0,sizeof f);
for(int i=0;i<=n;++i)
for(int j=0;j<=m;++j)if(dp[!T][i][j]){
int p=dp[!T][i][j],tmp=(ll)pw[K+1-t][j]*(pw[t][m-j]-pw[t-1][m-j]+mod)%mod;
for(int k=0;k<=n-i;++k){
f[i+k][j]=(f[i+k][j]+(ll)p*C[n-i][k])%mod;
p=(ll)p*tmp%mod;
}
}
for(int i=0;i<=n;++i)
for(int j=0;j<=m;++j)if(f[i][j]){
int p=f[i][j],tmp=(ll)pw[t][n-i]*(pw[K+1-t][i]-pw[K-t][i]+mod)%mod;
for(int k=0;k<=m-j;++k){
dp[T][i][j+k]=(dp[T][i][j+k]+(ll)p*C[m-j][k])%mod;
p=(ll)p*tmp%mod;
}
}
}
cout<<dp[T][n][m]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000050;
int abs(int x) { return (x > 0) ? x : -x; }
int main() {
int a1, a2, a3, a4;
cin >> a1 >> a2 >> a3 >> a4;
bool ok = true;
ok &= (a3 <= a1 && a3 <= a2);
ok &= (a4 <= a1 && a4 <= a2);
ok &= (abs(a3 - a4) <= 1);
ok &= ((a3 != a4) or ((a4 + 1 <= a1) or (a4 + 1 <= a2)));
if (ok) {
string S;
if (a3 > a4) {
for (int i = 0; i < a3; i++) {
S.push_back('4');
S.push_back('7');
a1--, a2--;
}
} else if (a4 > a3) {
for (int i = 0; i < a4; i++) {
S.push_back('7');
S.push_back('4');
a1--, a2--;
}
} else {
if (a4 + 1 <= a1) {
for (int i = 0; i < a4; i++) {
S.push_back('4');
S.push_back('7');
a1--, a2--;
}
S.push_back('4');
a1--;
} else if (a4 + 1 <= a2) {
for (int i = 0; i < a4; i++) {
S.push_back('7');
S.push_back('4');
a1--, a2--;
}
S.push_back('7');
a2--;
}
}
string s4, s7;
for (int i = 0; i < a1; i++) s4.push_back('4');
for (int i = 0; i < a2; i++) s7.push_back('7');
S.insert(1, s4);
int length = S.size();
S.insert(length - 1, s7);
cout << S << endl;
} else {
cout << -1 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, long long> mp;
int main() {
long long k;
string str;
cin >> k >> str;
long long len = str.length();
vector<int> pre(len + 1, 0);
mp[0] = 1;
for (long long i = 1; i <= len; i++) {
pre[i] = pre[i - 1] + (str[i - 1] == '1');
mp[pre[i]]++;
}
long long ans = 0;
if (k)
for (__typeof(mp.begin()) it(mp.begin()); it != mp.end(); it++)
if (it->first > pre[len] - k)
break;
else
ans += it->second * mp[it->first + k];
else {
long long cnt = 0;
for (long long i = 0; i < len; i++) {
if (str[i] == '0')
cnt++;
else {
ans += (cnt * (cnt + 1)) / 2;
cnt = 0;
}
}
if (cnt) ans += (cnt * (cnt + 1)) / 2;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
long long x = 0;
int n = 1;
char c = getchar();
while (!isdigit(c)) {
n = (c == '-') ? -1 : 1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * n;
}
const int N = 3000006;
long long n, d, m, l;
bool CHECK(long long l, long long r) {
long long x = d * (l / d);
while (x < l) x += d;
for (; x <= r; x += d)
if (l < x && x < r) {
cout << x;
return true;
}
return false;
}
int main() {
n = in(), d = in(), m = in(), l = in();
for (int i = 2; i <= n; i++) {
if (CHECK((i - 2) * m + l, (i - 1) * m)) return 0;
}
CHECK((n - 1) * m + l, (1ll << 63) - 1);
}
| 2 |
#include<bits/stdc++.h>
const int maxn = 7920;
typedef long long ll;
typedef std::vector<ll> vec;
std::set<ll> a0,a1;
vec x0,x1;
int ok[maxn],n;
inline void init(std::set<ll>&s,vec&y){
y.push_back(*s.begin()); s.erase(s.begin());
const ll lim = 3e7;
for(;s.size();){
auto it = s.upper_bound(lim / *y.rbegin()); --it;
y.push_back(*it); s.erase(it);
}
}
int main() {
std::ios::sync_with_stdio(false),std::cin.tie(0);
for(int i = 2,c=0;i < maxn;++i)if(!ok[i]){
(++c >> 1 & 1 ? a0 : a1).insert(i);
for(int j = i;j < maxn;j += i)ok[j] = 1;
}
init(a0,x0), init(a1,x1);
std::cin >> n;
for(int i = 1;i <= n;++i) for(int j = 1;j <= n;++j) {
if(i + j & 1) {
std::cout << x0[i + j - 3 >> 1] * x1[i + n - j - 2 >> 1] * x0[i + j - 1 >> 1] * x1[i + n - j >> 1] + 1;
} else {
std::cout << x0[i + j - 2 >> 1] * x1[i + n - j - 1 >> 1];
}
std::cout << " \n"[j == n];
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int l = 8 * n + 1;
double m = sqrt(l);
int k = sqrt(l);
if (m == k)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e5 + 200;
const long long inf = 0x3f3f3f3f;
const double eps = 1e-7;
const double pi = acos(-1.0);
const long long mod = 1e9 + 7;
inline long long lowbit(long long x) { return x & (-x); }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void ex_gcd(long long a, long long b, long long &d, long long &x,
long long &y) {
if (!b) {
d = a, x = 1, y = 0;
} else {
ex_gcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
inline long long qpow(long long a, long long b, long long MOD = mod) {
long long res = 1;
a %= MOD;
while (b > 0) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
inline long long inv(long long x, long long p) { return qpow(x, p - 2, p); }
inline long long Jos(long long n, long long k, long long s = 1) {
long long res = 0;
for (long long i = 1; i <= n + 1; ++i) res = (res + k) % i;
return (res + s) % n;
}
inline long long read() {
long long f = 1;
long long x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * f;
}
long long dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
long long a[maxn];
long long full[maxn];
long long to[maxn];
typedef struct ans {
long long x;
long long y;
} A;
A Ans[maxn];
stack<long long> one, two, three;
signed main() {
long long n = read();
for (long long i = 1; i <= n; ++i) a[i] = read();
for (long long i = n; i >= 1; --i) {
if (a[i] == 0) continue;
if (a[i] == 1)
one.push(i), to[i] = 0;
else if (a[i] == 2) {
if (one.empty()) {
cout << -1 << '\n';
return 0;
}
to[i] = one.top();
one.pop();
two.push(i);
} else {
if (!three.empty())
to[i] = three.top(), three.pop();
else if (!two.empty())
to[i] = two.top(), two.pop();
else if (!one.empty())
to[i] = one.top(), one.pop();
else {
cout << -1 << '\n';
return 0;
}
three.push(i);
}
}
long long row = 1;
long long p = 0;
for (long long i = 1; i <= n; ++i) {
long long col = i;
if (a[i] == 0 || full[i]) continue;
while (col != 0) {
full[col] = 1;
if (a[col] == 1) {
Ans[++p].x = row, Ans[p].y = col;
row++;
col = 0;
} else if (a[col] == 2) {
Ans[++p].x = row, Ans[p].y = col;
col = to[col];
} else if (a[col] == 3) {
Ans[++p].x = row, Ans[p].y = col;
col = to[col];
Ans[++p].x = row, Ans[p].y = col;
row++;
}
}
}
cout << p << '\n';
for (long long i = 1; i <= p; ++i)
cout << Ans[i].x << ' ' << Ans[i].y << '\n';
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <complex>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <iomanip>
#include <assert.h>
#include <array>
#include <cstdio>
#include <cstring>
#include <random>
#include <functional>
#include <numeric>
#include <bitset>
using namespace std;
struct before_main{before_main(){cin.tie(0); ios::sync_with_stdio(false);}} before_main;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
int to_int(char c) {
if(isdigit(c)) { return c-'0'; }
if(c == 'A') { return 11; }
return 10;
}
bool test_ace17(int value, int ace11) {
while(ace11) {
if(value <= 17) { return true; }
ace11 --;
value -= 10;
}
return false;
}
int main() {
int T; cin >> T;
rep(_, T) {
vector<int> in;
rep(i, 10) {
char c; cin >> c; in.push_back(to_int(c));
}
if(in[0] + in[1] == 21) { cout << "blackjack" << endl; continue; }
if(in[0] + in[1] > 21) { in[0] -= 10; }
REP(k, 1, 10) {
int value = 0;
int ace11 = 0;
rep(i, k+1) {
value += in[i];
ace11 += in[i] == 11;
}
while(value > 21 && ace11) {
ace11 --;
value -= 10;
}
if(value > 21) {
cout << "bust" << endl;
break;
}
if(test_ace17(value, ace11)) { continue; }
if(value <= 16) { continue; }
cout << value << endl;
break;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<long long, long long> > q;
string str;
long long tmp = 0, ans = 0, x, y;
int main() {
cin >> str;
for (int i = 0; i < str.size(); i++) {
if (str[i] == '(') {
tmp++;
} else if (str[i] == ')') {
tmp--;
} else {
cin >> x >> y;
str[i] = ')';
ans += y;
tmp--;
q.push(make_pair(y - x, i));
}
if (tmp < 0) {
if (q.empty()) break;
pair<long long, long long> tem = q.top();
q.pop();
tmp += 2;
ans -= tem.first;
str[tem.second] = '(';
}
}
if (tmp != 0)
puts("-1");
else
cout << ans << endl << str << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int n;
int a,cnt=0;
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&a);
if(a%2==1){
++cnt;
}
}
if(cnt%2==1){
printf("NO");
}else printf("YES");
} | 0 |
#include <iostream>
using namespace std;
int main() {
string s;
long k;
cin >> s >> k;
string s_new = s;
for(int i = 0; i < s.size(); i++) {
int d = 'z' - s[i] + 1;
if(k >= d && s[i] != 'a') {
k -= d;
s_new[i] = 'a';
}
}
s_new[s_new.size() - 1] = 'a' + (s_new[s_new.size() - 1] + k - 'a') % 26;
cout << s_new << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 303;
long long T;
int n, tot, num, p[25];
struct Node {
int x1, y1, x2, y2;
} ans[N];
inline void add(int n, int x) {
if (x == 0) {
ans[num++] = (Node){n + 1, n - 1, n + 1, n};
ans[num++] = (Node){n + 2, n - 1, n + 2, n};
ans[num++] = (Node){n - 1, n + 1, n, n + 1};
ans[num++] = (Node){n - 1, n + 2, n, n + 2};
} else if (x == 1) {
ans[num++] = (Node){n + 1, n - 1, n + 1, n};
ans[num++] = (Node){n - 1, n + 1, n, n + 1};
ans[num++] = (Node){n - 1, n + 2, n, n + 2};
} else if (x == 2) {
ans[num++] = (Node){n + 1, n - 1, n + 1, n};
ans[num++] = (Node){n - 1, n + 1, n, n + 1};
} else if (x == 3) {
ans[num++] = (Node){n + 2, n - 1, n + 2, n};
ans[num++] = (Node){n - 1, n + 1, n, n + 1};
ans[num++] = (Node){n - 1, n + 2, n, n + 2};
} else if (x == 4) {
ans[num++] = (Node){n - 1, n + 1, n, n + 1};
ans[num++] = (Node){n - 1, n + 2, n, n + 2};
} else if (x == 5) {
ans[num++] = (Node){n - 1, n + 1, n, n + 1};
}
}
int main() {
scanf("%lld", &T);
while (T) p[++tot] = T % 6ll, T /= 6ll;
ans[num++] = (Node){1, 2, 2, 2};
ans[num++] = (Node){2, 1, 2, 2};
n = 2;
while (tot) {
add(n, p[tot--]);
n += 2;
if (tot) {
ans[num++] = (Node){n, n - 2, n + 1, n - 2};
ans[num++] = (Node){n, n - 1, n + 1, n - 1};
ans[num++] = (Node){n + 1, n - 3, n + 2, n - 3};
ans[num++] = (Node){n + 1, n - 2, n + 2, n - 2};
ans[num++] = (Node){n - 2, n, n - 2, n + 1};
ans[num++] = (Node){n - 1, n, n - 1, n + 1};
ans[num++] = (Node){n - 3, n + 1, n - 3, n + 2};
ans[num++] = (Node){n - 2, n + 1, n - 2, n + 2};
}
}
printf("%d %d\n%d\n", n, n, num);
for (register int i = 0; i < num; i++)
printf("%d %d %d %d\n", ans[i].x1, ans[i].y1, ans[i].x2, ans[i].y2);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 2;
double eps = 1e-7;
double n, a, d;
double t[N];
double v[N], res[N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> a >> d;
res[0] = 0;
for (int i = 1; i <= n; ++i) {
cin >> res[i] >> v[i];
if (v[i] / (a * 2) * v[i] > d - eps) {
res[i] += sqrt(2.0 * d / a);
} else {
double len = d - v[i] / (2 * a) * v[i];
res[i] += v[i] / a + len / v[i];
}
res[i] = max(res[i], res[i - 1]);
printf("%.6lf\n", res[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793238460;
const long long mod = 1e9 + 7;
const long long INF = (long long)1e18;
void FAST() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void solve() {
long long n, b, p;
cin >> n >> b >> p;
long long x = 0, y = p * n;
while (n != 1) {
long long k = 1;
while (k <= n) k *= 2;
k /= 2;
x += k / 2 + k * b;
n = (n - k) + k / 2;
}
cout << x << " " << y << '\n';
}
int32_t main() {
FAST();
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
int sum0[maxn], sum1[maxn];
int a[maxn], b[maxn];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
if (b[i])
sum0[i] = sum0[i - 1] + a[i];
else
sum0[i] = sum0[i - 1];
sum1[i] = sum1[i - 1] + a[i];
}
int minSum = 0;
for (int i = 1; i + k - 1 <= n; i++) {
int l = i;
int r = i + k - 1;
int withSum = sum1[r] - sum1[l - 1];
int withoutSum = sum0[r] - sum0[l - 1];
int diff = withSum - withoutSum;
minSum = max(minSum, diff);
}
cout << sum0[n] + minSum << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string a,b,c;
cin>>a>>b>>c;
cout<<a[0]<<b[1]<<c[2]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
map<long long int, long long int> mp;
long long int res = n - 1;
for (long long int i = 0; i < n; i++) {
bool flag = true;
for (long long int j = 0; j < i; j++)
if (mp[arr[j]]) {
flag = false;
break;
} else
mp[arr[j]]++;
long long int x = n;
for (long long int j = n - 1; j >= i; j--)
if (mp[arr[j]])
break;
else
mp[arr[j]]++, x = j;
if (flag) res = min(res, x - i);
mp.clear();
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int b, w;
int main() {
int q;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &b, &w);
int aa = min(b, w);
int bb = max(b, w);
if (bb > aa * 3 + 1) {
printf("NO\n");
} else {
if (b == w) {
printf("YES\n");
for (int i = 1; i <= b + w; i++) printf("1 %d\n", i);
} else if (b < w) {
printf("YES\n");
for (int i = 2; i <= b * 2 + 2; i++) printf("4 %d\n", i);
w = w - b - 1;
if (w) {
for (int i = 3; i <= b * 2 + 2; i = i + 2) {
printf("3 %d\n", i);
w--;
if (w == 0) break;
}
}
if (w) {
for (int i = 3; i <= b * 2 + 2; i = i + 2) {
printf("5 %d\n", i);
w--;
if (w == 0) break;
}
}
} else if (b > w) {
printf("YES\n");
for (int i = 3; i <= w * 2 + 3; i++) printf("4 %d\n", i);
b = b - w - 1;
if (b) {
for (int i = 4; i <= w * 2 + 3; i = i + 2) {
printf("3 %d\n", i);
b--;
if (b == 0) break;
}
}
if (b) {
for (int i = 4; i <= w * 2 + 3; i = i + 2) {
printf("5 %d\n", i);
b--;
if (b == 0) break;
}
}
}
}
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main()
{
double x1,y1,x2,y2,x3,y3; cin>>x1>>y1>>x2>>y2>>x3>>y3;
double a=hypot(abs(x1-x2),abs(y1-y2));
double b=hypot(abs(x2-x3),abs(y2-y3));
double c=hypot(abs(x3-x1),abs(y3-y1));
double s=(a+b+c)/2;
double S=sqrt(s*(s-a)*(s-b)*(s-c));
double r=S/s;
double ok=0.0,ng=max({a,b,c});
for(int i=0;i<1000;i++){
double mid=(ok+ng)/2;
if(max({a,b,c})*(r-mid)/r>=2*mid){
ok=mid;
}else{
ng=mid;
}
}
cout<<fixed<<setprecision(10)<<ok<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int l = 0; l < t; ++l) {
int n;
cin >> n;
int mn = 1000;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
for (int i = 1; i < n; ++i) mn = min(abs(a[i] - a[i - 1]), mn);
cout << mn << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, maxElement = 0;
cin >> n;
int *input = new int[n];
for (int i = 0; i < n; i++) {
cin >> input[i];
maxElement = max(maxElement, input[i]);
}
stack<int> st;
for (int i = 0; i < n; i++) {
if (input[i] == maxElement) {
if (!st.empty()) {
cout << "NO" << endl;
return 0;
}
} else if (st.empty())
st.push(input[i]);
else if (st.top() == input[i])
st.pop();
else if (st.top() >= input[i])
st.push(input[i]);
else {
cout << "NO" << endl;
return 0;
}
}
if (st.empty())
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
int MOD=1e9+7;
ll INF=1e18;
int dx[]={1, -1, 0, 0};
int dy[]={0, 0, 1, -1};
int main(){
while(1){
int n; cin>>n;
if(n==0) return 0;
int a[110][110], hands[110][110];
memset(hands, 0, sizeof(hands));
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
cin>>a[i][j];
}
}
for(int i=0; i<n; i++){
int MIN=1e9, id;
for(int j=0; j<n; j++) MIN=min(MIN, a[i][j]);
for(int j=0; j<n; j++){
if(a[i][j]==MIN) hands[i][j]++;
}
}
for(int i=0; i<n; i++){
int MAX=0;
for(int j=0; j<n; j++) MAX=max(MAX, a[j][i]);
for(int j=0; j<n; j++){
if(a[j][i]==MAX) hands[j][i]++;
}
}
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
if(hands[i][j]==2){
cout << a[i][j] << endl;
goto END;
}
}
}
cout << 0 << endl;
END:;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
long long tree[N];
set<pair<int, int> > point, rev_point;
int mxb[N], mxc[N];
int a[N], b[N], c[N];
int n, p, q, r;
multiset<int> y, z;
int idx[N];
void update(int idx, long long val) {
while (idx <= q) {
tree[idx] += val;
idx += idx & (-idx);
}
}
long long query(int idx) {
long long ans = 0;
while (idx > 0) {
ans += tree[idx];
idx -= idx & (-idx);
}
return ans;
}
void alter(set<pair<int, int> >::iterator it, long long mul) {
update(it->first,
mul * (it->first - (it == point.begin() ? 0 : prev(it)->first)) *
it->second);
}
pair<int, int> invert(pair<int, int> data) { return {data.second, data.first}; }
void insert(int y, int z) {
auto it = point.lower_bound({y, z});
if (it == point.end() or z > it->second) {
if (it != point.end()) alter(it, -1);
it = point.insert({y, z}).first;
rev_point.insert({z, y});
while (it != point.begin() and prev(it)->second <= z) {
alter(prev(it), -1);
rev_point.erase(invert(*prev(it)));
point.erase(prev(it));
}
alter(it, 1);
if (next(it) != point.end()) {
alter(next(it), 1);
}
}
}
int main(void) {
cin.sync_with_stdio(false);
cin.tie(0);
cin >> n >> p >> q >> r;
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i] >> c[i];
idx[i] = i;
}
sort(idx, idx + n, [&](int id1, int id2) { return a[id1] < a[id2]; });
for (int i = n; i >= 0; --i) {
mxb[i] = (i < n ? max(mxb[i + 1], b[idx[i]]) : 0);
mxc[i] = (i < n ? max(mxc[i + 1], c[idx[i]]) : 0);
}
long long ans = 0ll;
for (int i = 0; i <= n; ++i) {
const int id = idx[i];
long long len = (i >= n ? p : a[idx[i]]) - (i > 0 ? a[idx[i - 1]] : 0);
if (len > 0) {
const int mxy = mxb[i] + 1;
const int mxz = mxc[i] + 1;
auto it1 = point.lower_bound({mxy, mxz});
auto it2 = rev_point.lower_bound({mxz, mxy});
long long val = (long long)(q - mxy + 1) * (r - mxz + 1);
if (it1 != point.end() and it2 != rev_point.end()) {
pair<int, int> left = *it1;
pair<int, int> right = invert(*it2);
if (left.first <= right.first) {
val -= query(right.first) - query(left.first);
val += (long long)(right.first - left.first) * (mxz - 1);
val -= (long long)(left.first - mxy + 1) * (left.second - mxz + 1);
}
}
ans += len * val;
}
if (i < n) {
insert(b[id], c[id]);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define repd(i,a,b) for (int i = (a); i < (b); i++)
#define INF LLONG_MAX
#define ERR 0.00000001
typedef long long ll;
double gaiseki(double x1, double y1, double x2, double y2)
{
return x1*y2 - x2*y1;
}
double naiseki(double x1, double y1, double x2, double y2)
{
return x1*x2 + y1*y2;
}
double vector_size(double x, double y)
{
return pow(x*x + y*y, 0.5);
}
int main(void)
{
double a, b, c, d, e, f, p0p1_x, p0p1_y, p0p2_x, p0p2_y,
nai, gai, p0p1_size, p0p2_size, judge;
cin >> a >> b >> c >> d;
p0p1_x = c - a;
p0p1_y = d - b;
p0p1_size = vector_size(p0p1_x, p0p1_y);
int q;
cin >> q;
rep(i, q)
{
cin >> e >> f;
p0p2_x = e - a;
p0p2_y = f - b;
gai = gaiseki(p0p1_x, p0p1_y, p0p2_x, p0p2_y);
if(gai<0) cout << "CLOCKWISE";
else if(gai>0) cout << "COUNTER_CLOCKWISE";
else
{
nai = naiseki(p0p1_x, p0p1_y, p0p2_x, p0p2_y);
p0p2_size = vector_size(p0p2_x, p0p2_y);
judge = nai/(p0p1_size*p0p2_size);
if(judge<0) cout << "ONLINE_BACK";
else
{
if(p0p1_size<p0p2_size) cout << "ONLINE_FRONT";
else cout << "ON_SEGMENT";
}
}
cout << endl;
//cout << gai <<" "<< nai<< " "<< p0p1_size <<" "<< p0p2_size << " " <<judge<< endl;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define For(aa,bb,cc) for(int aa=(bb);aa<=(int)(cc);++aa)
using namespace std;
const int maxn=100;
int n;
int a[maxn];
map<string,int>G;
int main(){
scanf("%d",&n);
string s;int ans=0;
For(i,1,n){
cin>>s;scanf("%d",&a[i]);
G[s]=i;
}
cin>>s;
For(i,G[s]+1,n) ans+=a[i];
printf("%d\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
set<char> st;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
bool ok = 0;
int ans = 0;
for (int i = 0; i < 26; ++i) st.insert('a' + i);
for (int i = 0; i < n; ++i) {
char ch;
string s;
cin >> ch >> s;
int l = s.length();
if (st.size() == 1) ok = 1;
if (ch == '.')
for (int j = 0; j < l; ++j) st.erase(s[j]);
else if (ch == '!') {
if (ok)
++ans;
else {
set<char> temp;
for (int j = 0; j < l; ++j)
if (st.find(s[j]) != st.end()) temp.insert(s[j]);
st = temp;
}
} else if (ch == '?') {
if (ok)
++ans;
else
st.erase(s[0]);
}
}
if (ans > 0) --ans;
cout << ans << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[2 * n];
for (int i1 = 0; i1 < 2 * n; i1++) {
a[i1] = i1 + 1;
}
int i = 0;
for (int i1 = 0; i1 < k; i1++) {
swap(a[i], a[i + 1]);
i += 2;
}
for (int i1 = 0; i1 < 2 * n; i1++) {
cout << a[i1] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long l, n, p, t;
pair<long long, long long> fl[maxn], fr[maxn];
long long L[maxn], R[maxn];
void relax(pair<long long, long long> &x, pair<long long, long long> y) {
if (x.first <= y.first) {
if (x.first < y.first) {
x = y;
return;
}
if (x.second > y.second) {
x = y;
return;
}
}
}
int fd(long long x) {
int d = lower_bound(R + 1, R + 1 + n + 1, x) - R;
return d;
}
int fd(long long x, int k) {
while (k <= n && R[k] < x) k++;
return k;
}
void solve() {
cin >> l >> n >> p >> t;
for (int i = 1; i <= n; i++) {
cin >> L[i] >> R[i];
}
L[n + 1] = l + 1, R[n + 1] = l + 2;
int j = 1;
for (int i = 1; i <= n; i++) {
relax(fl[i], fl[i - 1]);
relax(fr[i],
{fl[i].first + (R[i] - L[i]) / p, L[i] + ((R[i] - L[i]) / p) * p});
long long t0 = fr[i].second + t;
j = fd(t0, j);
if (j > n) continue;
if (L[j] >= t0) {
relax(fl[j], {fr[i].first, t0});
continue;
}
relax(fr[j], {fr[i].first + (R[j] - t0) / p, t0 + ((R[j] - t0) / p) * p});
relax(fl[j + 1], {fr[i].first, t0});
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, fr[i].first);
}
cout << ans << endl;
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, l;
cin >> h >> l;
double ans = (double)(pow(l, 2) - pow(h, 2)) / (double)(2.0 * h);
cout << std::setprecision(13) << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int x) {
return (unsigned int)(8 * sizeof(int) - __builtin_clz(x));
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.x) ^ (u(p.y) << 7);
}
};
} // namespace std
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
void fastIO() { ios::sync_with_stdio(false); }
bool can(vector<int> a) {
if (a.size() < 3) return true;
while (a.size() > 2) {
if (a.back() > a[a.size() - 2])
a.pop_back();
else
break;
}
reverse(a.begin(), a.end());
while (a.size() > 2) {
if (a.back() > a[a.size() - 2])
a.pop_back();
else
break;
}
if (a.size() < 3) return true;
int t = 0;
int cur = a[0];
int n = a.size();
for (int i = (0); i < (n); ++i) {
if (a[i] < t) return false;
int t1 = a[i] - cur;
t = max(t, t1);
cur = a[i] - t;
}
return true;
}
class AExtremeSubtraction {
public:
void solve(std::istream& in, std::ostream& out) {
fastIO();
int t;
in >> t;
for (int i = (0); i < (t); ++i) {
int n;
in >> n;
vector<int> a(n);
in >> a;
a.erase(unique(a.begin(), a.end()), a.end());
out << (can(a) ? "YES" : "NO") << endl;
}
}
};
int main() {
AExtremeSubtraction solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
cerr << 1.0 * clock() / CLOCKS_PER_SEC << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, n, arr[10000], i, j, team = 1;
cin >> q;
for (i = 0; i < q; i++) {
cin >> n;
for (j = 0; j < n; j++) {
cin >> arr[j];
}
sort(arr, arr + n);
for (j = 0; j < n - 1; j++) {
if (arr[j + 1] == arr[j] + 1) {
team++;
break;
}
}
cout << team << endl;
team = 1;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> graph[100001];
long long visit[1001];
long long dest;
int main() {
long long t, n, k, m, a;
cin >> t;
while (t--) {
cin >> n;
map<long long, long long> mp;
long long index = -1, chk;
mp[0] = -1;
for (long long i = 1; i <= n; i++) {
cin >> m;
vector<long long> vc, king;
for (long long j = 0; j < m; j++) {
cin >> a;
vc.push_back(a);
}
sort(vc.begin(), vc.end());
chk = 0;
for (long long j = 0; j < m; j++) {
if (mp[vc[j]] == 0) {
mp[vc[j]] = -1;
chk = 1;
break;
}
}
if (chk == 0) index = i;
}
if (index == -1)
cout << "OPTIMAL\n";
else {
cout << "IMPROVE\n";
cout << index << " ";
for (long long i = 1; i <= n; i++) {
if (mp[i] == 0) {
cout << i << "\n";
break;
}
}
}
}
}
| 2 |
#include <bits/stdc++.h>
#define use(x) using std::x
#define cmax(a, b) (a < b ? a = b : a)
#define lop(i, s, t) for (int i = s;i < (t);++i)
#define dec(i, s, t) for (int i = s;i >= (t);--i)
#define rep(i, s, t) for (int i = s;i <= (t);++i)
#define mem(x, k) memset(x, k, sizeof(x))
use(fill); use(sort); use(max); use(swap);
const int N = 3e5 + 50, oo = 1e9;
#define Pr(f, ...) printf(f, ##__VA_ARGS__), fflush(stdout)
namespace SegTr {
const int S = N << 2;
int tr[S], tag[S];
void clear() {
mem(tr, 0);
mem(tag, 0);
}
void down(int v) {
if (tag[v] == 0) return;
tag[v << 1] += tag[v], tag[v << 1 ^ 1] += tag[v];
tr[v << 1] += tag[v], tr[v << 1 ^ 1] += tag[v];
tag[v] = 0;
}
void update(int v, int l, int r, int s, int t, int k) {
if (r < s || l > t) ;
else if (s <= l && r <= t) {
tr[v] += k;
tag[v] += k;
} else {
down(v);
int mid = (l + r) >> 1;
update(v << 1, l, mid, s, t, k);
update(v << 1 ^ 1, mid + 1, r, s, t, k);
tr[v] = max(tr[v << 1], tr[v << 1 ^ 1]);
}
}
int query() { return tr[1]; }
}
int n, xmax, ymax, ans;
struct P { int x, y; } p[N];
bool operator<(const P &a, const P &b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
P up[N], dn[N];
int tu, td;
void solve() {
SegTr::clear();
sort(p + 1, p + n + 1);
tu = 0, td = 0;
int mid = ymax >> 1;
rep(i, 1, n - 1) {
int y = p[i].y, lst = i - 1;
if (y > mid) {
while (tu && y < up[tu].y) {
SegTr::update(1, 1, n, up[tu].x, lst, -up[tu].y + y);
lst = up[tu--].x - 1;
}
if (lst != i - 1) up[++tu] = (P) { lst + 1, y };
} else {
while (td && y > dn[td].y) {
SegTr::update(1, 1, n, dn[td].x, lst, -y + dn[td].y);
lst = dn[td--].x - 1;
}
if (lst != i - 1) dn[++td] = (P) { lst + 1, y };
}
up[++tu] = (P) { i, ymax };
dn[++td] = (P) { i, 0 };
SegTr::update(1, 1, n, i, i, ymax - p[i].x);
cmax(ans, SegTr::query() + p[i + 1].x);
}
}
int main(int argc, char *argv[]) {
scanf("%d%d%d", &xmax, &ymax, &n);
rep(i, 1, n) {
scanf("%d%d", &p[i].x, &p[i].y);
}
p[++n] = (P) { 0, 0 };
p[++n] = (P) { xmax, ymax };
solve();
rep(i, 1, n) swap(p[i].x, p[i].y);
swap(xmax, ymax);
solve();
printf("%d\n", ans << 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
vector<long long> v;
for (long long i = 2; i <= sqrt(n); ++i) {
if (!(n % i)) {
v.push_back(i);
while (!(n % i)) {
n /= i;
}
}
}
if (n != 1) v.push_back(n);
if (v.size() == 1)
cout << v[0];
else
cout << "1";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
vector<int> adj[MAX];
int degree[MAX], level[MAX], removed[MAX];
int n;
void dfs(int node, int father) {
for (auto &each : adj[node]) {
if (each != father) {
level[each] = level[node] + 1;
dfs(each, node);
}
}
}
int main() {
scanf("%d", &n);
int root = -1;
for (int i = int(1); i < int(n + 1); i++) {
int p;
scanf("%d", &p);
if (p != 0) {
adj[i].push_back(p);
adj[p].push_back(i);
degree[i]++;
degree[p]++;
} else {
root = i;
}
}
dfs(root, -1);
set<pair<int, int> > pq;
for (int i = int(1); i < int(n + 1); i++) {
if (degree[i] % 2 == 0) {
pq.emplace(level[i], i);
}
}
vector<int> order;
while (!pq.empty()) {
pair<int, int> top = *pq.rbegin();
pq.erase(prev(pq.end()));
int node = top.second;
for (auto &each : adj[node]) {
if (removed[each]) {
continue;
}
degree[each]--;
if (degree[each] % 2 == 1) {
pq.erase(pq.find(pair<int, int>(level[each], each)));
} else {
pq.emplace(level[each], each);
}
}
order.push_back(node);
removed[node] = 1;
}
if ((int)order.size() == n) {
puts("YES");
for (auto &each : order) {
printf("%d\n", each);
}
} else {
puts("NO");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(int a, int b) {
long long ans = 1;
while (b--) {
ans = ans * a % 998244353;
}
return ans;
}
int main() {
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = 0;
int p = 0;
for (int i = 0; i < n; i++) {
int p = 0;
while (a[i]) {
int d = a[i] % 10;
ans = (ans + (d * ((long long)(power(10, p) % 998244353 +
power(10, p + 1) % 998244353) %
998244353)) %
998244353) %
998244353;
a[i] /= 10;
p += 2;
}
}
ans = (ans * n) % 998244353;
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
const int N = 500010;
using namespace std;
int n, m;
int x, y, x1, asdf_1;
int vx, vy, vx1, vy1;
int v;
int t;
pair<int, int> mas[N];
inline double dist(double x, double y) {
return sqrt(((x - x1) * (x - x1)) + ((y - asdf_1) * (y - asdf_1)));
}
int fun(double time) {
double tx = x, ty = y;
if (time < t) {
tx += time * vx;
ty += time * vy;
} else {
tx += t * vx;
ty += t * vy;
tx += (time - t) * vx1;
ty += (time - t) * vy1;
}
if (dist(tx, ty) / v > time) return 0;
return 1;
}
void solve() {
cin >> x >> y >> x1 >> asdf_1;
cin >> v >> t;
cin >> vx >> vy >> vx1 >> vy1;
double l = 0, r = 1e18;
for (int i = 0; i < 256; ++i) {
double mid = (l + r) / 2;
if (fun(mid))
r = mid;
else
l = mid;
}
printf("%0.8f", (l + r) / 2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
srand(1337);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int par[100001], sz[100001];
int p(int u) {
if (par[u] == u) return u;
par[u] = p(par[u]);
return par[u];
}
void un(int u, int v) {
int pu = p(u), pv = p(v);
if (pu != pv) {
par[pu] = pv;
sz[pv] += sz[pu];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
int sp[k], spB[n + 1];
memset(spB, false, sizeof spB);
for (int i = 0; i < k; i++) {
cin >> sp[i];
spB[sp[i]] = true;
}
pair<int, pair<int, int>> a[m];
for (int i = 0; i < m; i++)
cin >> a[i].second.first >> a[i].second.second >> a[i].first;
sort(a, a + m);
int l = 0, r = m - 1, ind = m - 1;
while (l <= r) {
int mid = (l + r) / 2;
vector<int> b[n + 1];
for (int i = 0; i < mid + 1; i++) {
int u = a[i].second.first, v = a[i].second.second;
b[u].push_back(v);
b[v].push_back(u);
}
int t = 0;
queue<int> q;
bool vis[n + 1];
memset(vis, false, sizeof vis);
q.push(sp[0]);
vis[sp[0]] = true;
while (!q.empty()) {
int f = q.front();
q.pop();
if (spB[f]) ++t;
for (int e : b[f]) {
if (!vis[e]) {
q.push(e);
vis[e] = true;
}
}
}
if (t == k) {
ind = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
while (k--) cout << a[ind].first << ' ';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n % 3)
cout << n / 3 * 2 + 1;
else
cout << n / 3 * 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int read_int() {
int res = 0, neg = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') neg = 1, c = getchar();
while (c >= '0' && c <= '9') {
res = (res << 1) + (res << 3) + c - 48;
c = getchar();
}
return neg ? -res : res;
}
long long int read_ll() {
long long int res = 0;
int neg = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') neg = 1, c = getchar();
while (c >= '0' && c <= '9') {
res = (res << 1) + (res << 3) + c - 48;
c = getchar();
}
return neg ? -res : res;
}
int main() {
std::ios::sync_with_stdio(false);
int left = 2000;
list<pair<long long int, long long int> > indl;
int q[1000];
int val, nex;
int n = read_int(), st = read_int(), x = read_int();
cout << "? " << st << '\n';
fflush(stdout);
cin >> val >> nex;
indl.push_back(make_pair(val, nex));
--left;
for (int i = 0; i < 1000; ++i)
q[i] = i * (1000000009LL) % n * 1000000007 % n + 1;
int l = 0;
if (left < n - 1) {
while (left > 1000) {
int tmp = q[l++];
if (tmp == st) continue;
cout << "? " << tmp << '\n';
fflush(stdout);
cin >> val >> nex;
auto it = indl.begin();
for (; it != indl.end() && it->first < val; ++it)
;
if (it->first != val) indl.insert(it, make_pair(val, nex));
left--;
if (nex == x) break;
}
}
auto it = indl.begin();
auto prev = it;
while (it != indl.end() && it->first < x) {
prev = it;
it++;
}
if (it->first == x) {
cout << "! " << x << '\n';
fflush(stdout);
return 0;
}
if (prev->second == -1 && prev->first < x) {
cout << "! -1\n";
fflush(stdout);
return 0;
}
if (prev->first >= x) {
cout << "! " << prev->first << '\n';
fflush(stdout);
return 0;
}
cout << "? " << prev->second << '\n';
fflush(stdout);
cin >> val >> nex;
--left;
while (val < x && left--) {
if (nex == -1) {
cout << "! -1\n";
fflush(stdout);
return 0;
}
cout << "? " << nex << '\n';
fflush(stdout);
cin >> val >> nex;
}
cout << "! ";
if (val >= x)
cout << val << '\n';
else
cout << "-1\n";
fflush(stdout);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 109;
const int INF = 1e9;
char zbs[5] = {'R', 'G', 'B', 'Y', 'W'};
pair<int, int> a[N];
int main() {
int n, ans = 11;
cin >> n;
for (int i = 0; i < int(n); ++i) {
char t1, t2;
cin >> t1 >> t2;
a[i].second = int(t2 - '1');
for (int j = 0; j < int(5); ++j)
if (zbs[j] == t1) a[i].first = j;
}
for (int mask1 = 0; mask1 < int(1 << 5); ++mask1) {
for (int mask2 = 0; mask2 < int(1 << 5); ++mask2) {
int m[5][5], na = 0, ok = 1;
memset(m, 0, sizeof(m));
for (int i = 0; i < int(5); ++i) {
if (mask1 & (1 << i)) ++na;
if (mask2 & (1 << i)) ++na;
}
for (int i = 0; i < int(n); ++i) m[a[i].first][a[i].second] = 1;
for (int i1 = 0; i1 < int(5); ++i1)
for (int j1 = 0; j1 < int(5); ++j1)
for (int i2 = 0; i2 < int(5); ++i2)
for (int j2 = 0; j2 < int(5); ++j2) {
bool ok1 = 0;
if (m[i1][j1] * m[i2][j2] == 0) continue;
if (i1 == i2 && j1 == j2) continue;
if (i1 != i2 && ((mask1 & (1 << i1)) || (mask1 & (1 << i2))))
ok1 = 1;
if (j1 != j2 && ((mask2 & (1 << j1)) || (mask2 & (1 << j2))))
ok1 = 1;
if (ok) ok = ok1;
}
if (ok) ans = min(na, ans);
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int sif(char c) { return c - '0'; }
char s[200005];
int c[200005];
bool zauz[200005];
int main() {
int i, n, br = 0;
scanf("%s", s);
n = strlen(s);
for (i = 0; i < n; i++) {
c[i] = sif(s[i]) % 3;
}
for (i = 0; i < n; i++) {
switch (c[i]) {
case 0: {
br++;
zauz[i] = true;
break;
}
case 1: {
if (!zauz[i] && !zauz[i - 1] && c[i - 1] == 2) {
zauz[i - 1] = zauz[i] = true;
br++;
}
if (!zauz[i] && i >= 2 && !zauz[i - 1] && !zauz[i - 2] &&
c[i - 1] + c[i - 2] == 2) {
zauz[i] = true;
zauz[i - 1] = zauz[i - 2] = true;
br++;
}
if (!zauz[i] && i >= 3 && !zauz[i - 1] && !zauz[i - 2] &&
!zauz[i - 3] && c[i - 1] + c[i - 2] + c[i - 2] == 5) {
zauz[i] = zauz[i - 3] = true;
zauz[i - 1] = zauz[i - 2] = true;
br++;
}
break;
}
case 2: {
if (!zauz[i] && !zauz[i - 1] && c[i - 1] == 1) {
zauz[i - 1] = zauz[i] = true;
br++;
}
if (!zauz[i] && i >= 2 && !zauz[i - 1] && !zauz[i - 2] &&
c[i - 1] + c[i - 2] == 4) {
zauz[i] = true;
zauz[i - 1] = zauz[i - 2] = true;
br++;
}
break;
}
}
}
printf("%d\n", br);
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define Rint register int
using namespace std;
typedef long long LL;
const int N = 100003;
const LL C = 2e17;
template<typename T>
inline void read(T &x){
int ch = getchar(); x = 0; bool f = false;
for(;ch < '0' || ch > '9';ch = getchar()) f |= ch == '-';
for(;ch >= '0' && ch <= '9';ch = getchar()) x = x * 10 + ch - '0';
if(f) x = -x;
}
int n;
LL x[N], y[N];
bool qry(LL a, LL b, LL c){return c >= a && (C - a - b & c - a) == c - a;}
bool qry(LL c){
bool ans = false;
for(Rint i = 0;i < n;++ i)
ans ^= qry(x[i], y[i], c);
return ans;
}
int main(){
read(n);
for(Rint i = 0;i < n;++ i){read(x[i]); read(y[i]);}
LL now = C;
for(Rint i = 58;~i;-- i) if(qry(now-(1ll<<i))) now -= 1ll<<i;
printf("%lld\n", now);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mm;
char s[200];
int an, n, ma, ans, m, mx, k, i, j, kk, sw, a[500001], ne[500001][17],
f[40000][227], fir[20];
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%s", s), mm[s] = i;
scanf("%d", &m);
ma = n * (n - 1) / 2 + 1;
int mx = m;
an = 1e9;
for (; m; m--) {
scanf("%d", &k);
for (i = 0; i < n; i++) fir[i] = k;
a[k] = 0;
for (i = 0; i < k; i++) {
scanf("%s", s);
if (mm.count(s))
a[i] = mm[s];
else
a[i] = -1;
}
for (i = k; i >= 0; i--) {
if (a[i] != -1) fir[a[i]] = i;
for (kk = 0; kk < n; kk++) ne[i][kk] = fir[kk];
}
for (i = 0; i <= (1 << n) - 1; i++)
for (j = 0; j < ma; j++) f[i][j] = 1e9;
f[0][0] = -1;
for (i = 0; i < (1 << n); i++)
for (j = 0; j < ma; j++)
if (f[i][j] < k) {
for (kk = 0; kk < n; kk++)
if ((i >> kk) % 2 == 0)
f[i + (1 << kk)][j + __builtin_popcount(i >> kk)] =
min(f[i + (1 << kk)][j + __builtin_popcount(i >> kk)],
ne[f[i][j] + 1][kk]);
}
for (i = 0; i < ma; i++)
if (f[(1 << n) - 1][i] < k) {
if (i < an) an = i, ans = mx - m + 1;
break;
}
}
if (an != 1e9) {
cout << ans << endl << "[:";
for (i = 0; i < (n - 1) * n / 2 - an + 1; i++) cout << '|';
cout << ":]" << endl;
} else
cout << "Brand new problem!";
return (0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int ddx[] = {-1, -2, 1, -2, 2, -1, 2, 1}, ddy[] = {-2, -1, -2, 1, -1, 2, 1, 2};
long long a, b, c, d;
long long val(long long k) {
long long x;
if (k <= c)
x = 0;
else
x = (k - c - 1) / d + 1;
long long y = k / d;
long long res = (-a + b * c) * (y + 1);
res -= ((y - x + 1) * (x + y) / 2 * d + (y - x + 1) * (c - k)) * b;
return res;
}
long long solve() {
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
if (a > b * c) return -1;
long long l = 0, r = (long long)(1e6) / d;
while (l + 3 < r) {
long long m1 = (2 * l + r) / 3, m2 = (l + 2 * r) / 3;
if (val(m1 * d) < val(m2 * d))
r = m2;
else
l = m1;
}
long long ans = -a;
for (long long i = l; i <= r; i++) {
ans = min(ans, val(i * d));
}
return -ans;
}
int main() {
int tc;
scanf("%d", &tc);
while (tc--) printf("%lld\n", solve());
}
| 3 |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
using namespace std;
typedef long long ll;
int INF = (1LL << 30) - 1;
int MOD = 1e9+7;
int main(){
int N;
cin >> N;
vector<int> V(N);
rep(i,0,N)cin >> V[i];
vector<int> A(N),B(N);
rep(i,0,N)A[i] = B[N-i-1] = (i+1) * 30000;
rep(i,0,N){
B[V[i] - 1] += i;
}
rep(i,0,N)cout << A[i] << " \n"[i==N-1];
rep(i,0,N)cout << B[i] << " \n"[i==N-1];
} | 0 |
// nauynix
// 03/04/2021
#include <bits/stdc++.h>
using namespace std;
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef long long int ll;
const int INF = 1e9 + 7;
const int mod = 1e9 + 7;
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
int nxt() {int x;cin >> x;return x;}
int main(){
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n = nxt();
bool poss = true;
VI a(n), swp(n);
rep (i, 0, n) {
int b = nxt()-1, c = nxt()-1;
bool swps = false;
if (b > c) {
swap(b, c);
swps = true;
}
if (b >= n || c < n) {
poss = false;
break;
}
a[b] = c;
swp[b] = swps;
}
if (!poss) {
puts("-1");
return 0;
}
VI b(2), c(2), d(2);
b[0] = b[1] = INF;
c[0] = c[1] = 0;
d[0] = d[1] = 0;
int ans = 0;
set<int> s;
rep (i, 0, n) {
/* printf("%d %d\n", a[i]+1, swp[i]); */
int j = 0;
s.insert(a[i]);
if (b[0] > b[1]) j = 1;
// b[j] is smaller
if (a[i] < b[j]) {
b[j] = a[i];
if (swp[i]) c[j]++;
d[j]++;
} else if (a[i] < b[1-j]) {
b[1-j] = a[i];
if (swp[i]) c[1-j]++;
d[1-j]++;
} else {
poss = false;
break;
}
if (*s.begin() == 2 * n - i - 1) {
ans += min(c[0] + d[1] - c[1], c[1] + d[0] - c[0]);
b[0] = b[1] = INF;
c[0] = c[1] = 0;
d[0] = d[1] = 0;
}
}
if (!poss) printf("-1\n");
else printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
int main(void) {
int i = 0;
int cnt = 0;
int now = 1;
while (i <= 24) {
printf("%d\n", prime[i]);
fflush(stdout);
char response[5];
scanf("%s", response);
if (response[0] == 'y') {
cnt++;
int now = prime[i];
if (now * now <= 100) {
printf("%d\n", now * now);
fflush(stdout);
scanf("%s", response);
if (response[0] == 'y') {
cnt++;
}
}
}
i++;
if (cnt >= 2) break;
if (i >= 17) break;
}
if (cnt <= 1)
printf("prime\n");
else
printf("composite\n");
fflush(stdout);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e3 + 13;
int n;
long double k, ans, dp[maxN][maxN], p[maxN], pre[20];
int main() {
cin >> n;
pre[0] = 1;
for (int i = 1; i <= 18; i++) pre[i] = pre[i - 1] * 10;
for (int i = 1; i <= n; i++) {
long long L = 0, R = 0, l, r;
cin >> l >> r;
for (int i = 0; i <= 18; i++) {
if (r >= pre[i] * 2 - 1)
R += pre[i];
else if (r >= pre[i])
R += r - pre[i] + 1;
}
l--;
for (int i = 0; i <= 18; i++) {
if (l >= pre[i] * 2 - 1)
L += pre[i];
else if (l >= pre[i])
L += l - pre[i] + 1;
}
p[i] = (long double)(R - L) / (r - l);
}
cin >> k;
if (k == 0) return cout << 1 << endl, 0;
dp[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++) {
if (j)
dp[i][j] = p[i] * dp[i - 1][j - 1] + (1 - p[i]) * dp[i - 1][j];
else
dp[i][j] = (1 - p[i]) * dp[i - 1][j];
}
for (int i = 1; i <= n; i++)
if (i * 100 >= k * n) {
ans += dp[n][i];
}
cout << fixed << setprecision(10) << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 23;
int n, a[N], t[N], b[N];
bool cmp(int x, int y) { return a[x] < a[y]; }
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) t[i] = i;
sort(t + 1, t + n + 1, cmp);
for (int i = 1; i <= n; ++i) b[t[i]] = a[t[i % n + 1]];
for (int i = 1; i <= n; ++i) cout << b[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ns, nt;
string s, t;
int ScntB[100010], ScntA[100010];
int TcntB[100010], TcntA[100010];
int q;
int sol(int ls, int rs, int lt, int rt) {
int dbS, dbT, daS, daT;
dbS = ScntB[rs] - ScntB[ls - 1];
dbT = TcntB[rt] - TcntB[lt - 1];
daS = min(rs - ls + 1, ScntA[rs]);
daT = min(rt - lt + 1, TcntA[rt]);
if (daS < daT) return 0;
if ((dbS + dbT) & 1) return 0;
if (dbS > dbT) return 0;
if (dbS == dbT) {
if (daS % 3 == daT % 3) return 1;
return 0;
}
if (dbS == 0 && daS == daT) return 0;
return 1;
}
int main() {
cin >> s;
cin >> t;
ns = s.length();
nt = t.length();
for (int i = 0; i < ns; i++) {
ScntB[i + 1] = ScntB[i];
if (s[i] == 'A') {
if (i > 0 && s[i - 1] == 'A')
ScntA[i + 1] = ScntA[i] + 1;
else
ScntA[i + 1] = 1;
} else
ScntB[i + 1] += 1;
}
for (int i = 0; i < nt; i++) {
TcntB[i + 1] = TcntB[i];
if (t[i] == 'A') {
if (i > 0 && t[i - 1] == 'A')
TcntA[i + 1] = TcntA[i] + 1;
else
TcntA[i + 1] = 1;
} else
TcntB[i + 1] += 1;
}
cin >> q;
for (int i = 1; i <= q; i++) {
int ls, rs, lt, rt;
cin >> ls >> rs >> lt >> rt;
cout << sol(ls, rs, lt, rt);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool d;
int n;
char c[10][10];
int main() {
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= 4; j++) cin >> c[i][j];
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= 4; j++) {
if (c[i][j] == '.' and c[i][j - 1] == 'x' and c[i][j + 1] == 'x') d = 1;
if (c[i][j] == '.' and c[i][j - 1] == 'x' and c[i][j - 2] == 'x') d = 1;
if (c[i][j] == '.' and c[i][j + 1] == 'x' and c[i][j + 2] == 'x') d = 1;
if (c[i][j] == '.' and c[i - 1][j] == 'x' and c[i - 2][j] == 'x') d = 1;
if (c[i][j] == '.' and c[i + 1][j] == 'x' and c[i + 2][j] == 'x') d = 1;
if (c[i][j] == '.' and c[i - 1][j] == 'x' and c[i + 1][j] == 'x') d = 1;
if (c[i][j] == '.' and c[i + 1][j + 1] == 'x' and c[i + 2][j + 2] == 'x')
d = 1;
if (c[i][j] == '.' and c[i - 1][j - 1] == 'x' and c[i + 1][j + 1] == 'x')
d = 1;
if (c[i][j] == '.' and c[i - 1][j - 1] == 'x' and c[i - 2][j - 2] == 'x')
d = 1;
if (c[i][j] == '.' and c[i + 1][j - 1] == 'x' and c[i + 2][j - 2] == 'x')
d = 1;
if (c[i][j] == '.' and c[i - 1][j + 1] == 'x' and c[i + 1][j - 1] == 'x')
d = 1;
if (c[i][j] == '.' and c[i - 1][j + 1] == 'x' and c[i - 2][j + 2] == 'x')
d = 1;
}
if (d == 1)
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
char a[101][101];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int min_i = n, min_j = m, max_i = -1, max_j = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '*') {
if (i < min_i) {
min_i = i;
}
if (i > max_i) {
max_i = i;
}
if (j < min_j) {
min_j = j;
}
if (j > max_j) {
max_j = j;
}
}
}
}
for (int i = min_i; i <= max_i; i++) {
for (int j = min_j; j <= max_j; j++) {
cout << a[i][j];
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ans[10001][2];
int main() {
int x, y, a, b, n = 0;
cin >> x >> y >> a >> b;
for (int i = a; i <= x; i++)
for (int j = b; j < i && j <= y; j++) {
ans[n][0] = i;
ans[n][1] = j;
n++;
}
cout << n << endl;
for (int i = 0; i < n; i++) cout << ans[i][0] << ' ' << ans[i][1] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct Node {
int l, r, mi;
set<int> s;
} a[N << 2];
int t[N];
struct Query {
int l, r, id;
} q[N * 3];
inline bool cmp(const Query& q, const Query& w) {
if (q.l != w.l) return q.l < w.l;
if (q.r != w.r) return q.r < w.r;
return q.id < w.id;
}
void Buildtree(int i, int l, int r) {
a[i].l = l;
a[i].r = r;
a[i].mi = 0x3f3f3f3f;
for (int q = l; q <= r; q++) a[i].s.insert(t[q]);
if (l == r) return;
int mid = l + r >> 1;
Buildtree(i << 1, l, mid);
Buildtree(i << 1 | 1, mid + 1, r);
}
int query(int i, int l, int r) {
if (l <= a[i].l && a[i].r <= r) return a[i].mi;
int mid = a[i].l + a[i].r >> 1;
if (r <= mid)
return query(i << 1, l, r);
else if (l > mid)
return query(i << 1 | 1, l, r);
else
return min(query(i << 1, l, r), query(i << 1 | 1, l, r));
}
void update(int i, int l, int r, int v, int& mi) {
if (a[i].l > r || a[i].r < l) return;
if (a[i].l == a[i].r) {
a[i].mi = min(a[i].mi, abs(v - t[a[i].l]));
mi = min(mi, a[i].mi);
return;
}
set<int>& T = a[i].s;
auto k = T.lower_bound(v);
if ((k == T.end() || (*k - v) >= mi) &&
(k == T.begin() || (v - *(--k)) >= mi)) {
mi = min(mi, query(i, l, r));
return;
}
if (a[i << 1].r >= l) update(i << 1, l, r, v, mi);
if (a[i << 1 | 1].l <= r) update(i << 1 | 1, l, r, v, mi);
a[i].mi = min(a[i << 1].mi, a[i << 1 | 1].mi);
}
int ans[N * 3];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d %d", &q[i].l, &q[i].r), q[i].id = i;
sort(q + 1, q + 1 + m, cmp);
Buildtree(1, 1, n);
for (int i = m, j = n - 1; i >= 1; i--) {
for (; j >= q[i].l; j--) {
int ct = 0x3f3f3f3f;
update(1, j + 1, n, t[j], ct);
}
ans[q[i].id] = query(1, q[i].l, q[i].r);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
long long n, k;
std::cin >> n >> k;
long long c = std::max(n - 2 * k, 0LL);
std::cout << n * (n - 1) / 2 - c * (c - 1) / 2 << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long d[10000005];
long long ara[10000005 / 10];
void precalc() {
for (int i = 0; i <= 24; i++) {
for (int j = (1 << i); j <= min((1 << (i + 1)) - 1, 10000000); j++)
d[j] = i;
}
}
bool okay(long long mid) {
if (mid == 1) return 1;
long long temp = 0;
for (int i = 0; i < n; i++) {
if (ara[i] < mid) continue;
long long vag = ara[i] / mid;
if ((1 << d[vag]) == vag)
temp += vag;
else {
temp += max((1LL << d[vag]), ara[i] - (mid - 1) * (1LL << (d[vag] + 1)));
}
}
return (temp >= k);
}
int main() {
precalc();
scanf("%d %d", &n, &k);
long long sum = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &ara[i]);
sum += ara[i];
}
if (sum < k) {
printf("-1\n");
return 0;
}
int lo = 1, hi = 10000000;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
if (okay(mid))
lo = mid;
else
hi = mid - 1;
}
printf("%d\n", lo);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long d, mod;
long long s = 1, k = 1;
long long dp[100] = {0};
long long a[100] = {0};
cin >> d >> mod;
long long x = d;
while (x) {
x >>= 1;
a[k++] = min(s, d - s + 1);
s <<= 1;
}
for (long long i = 1; i < k; ++i)
dp[i] = (dp[i - 1] % mod + a[i] % mod + (dp[i - 1] * a[i]) % mod) % mod;
cout << dp[k - 1] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using i64 = long long;
int main() {
constexpr i64 mod = 1000000007;
int n;
std::cin >> n;
i64 ret = 1;
int ss[] { 0, 0, 0 };
for (int i = 0; i < n; i++) {
int a;
std::cin >> a;
i64 f = 0;
for (int &s : ss) if (s == a && !f++) s++;
ret = ret * f % mod;
}
std::cout << ret << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[9];
for (int i = 0; i < 9; i++) {
cin >> a[i];
}
a[0] = (2 * a[2] + a[5] - a[3]) / 2;
a[8] = (2 * a[6] + a[3] - a[5]) / 2;
a[4] = a[1] + a[2] - a[8];
cout << a[0] << " " << a[1] << " " << a[2] << endl;
cout << a[3] << " " << a[4] << " " << a[5] << endl;
cout << a[6] << " " << a[7] << " " << a[8] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int fastpow(long long int base, long long int exp, long long int M) {
long long int res = 1;
while (exp > 0) {
if (exp & 1) res = (res * base) % M;
base = (base * base) % M;
exp >>= 1;
}
return res;
}
vector<long long int> par, vis, c;
vector<vector<long long int> > graph;
long long int root(long long int a) {
while (a != par[a]) {
par[a] = par[par[a]];
a = par[a];
}
return a;
}
void unio(long long int a, long long int b) { par[root(a)] = root(b); }
void dfs(long long int p, long long int par) {
vis[p] = 1;
if (c[p] == 0) c[par] = 0;
for (long long int v : graph[p]) {
if (!vis[v]) {
dfs(v, p);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
graph.resize(n + 1);
vis.resize(n + 1);
c.resize(n + 1);
vector<long long int> p(n + 1);
long long int root = 0;
for (long long int i = 1; i <= n; ++i) {
cin >> p[i] >> c[i];
if (p[i] != -1)
graph[p[i]].push_back(i);
else
root = i;
}
dfs(root, 0);
if (accumulate(c.begin(), c.end(), 0) == 0) {
cout << -1;
return 0;
}
for (long long int i = 0; i <= n; ++i) {
if (c[i]) {
cout << i << " ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const unordered_map<string, int> pt = {
{"H", 1}, {"He", 2}, {"Li", 3}, {"Be", 4}, {"B", 5},
{"C", 6}, {"N", 7}, {"O", 8}, {"F", 9}, {"Ne", 10},
{"Na", 11}, {"Mg", 12}, {"Al", 13}, {"Si", 14}, {"P", 15},
{"S", 16}, {"Cl", 17}, {"Ar", 18}, {"K", 19}, {"Ca", 20},
{"Sc", 21}, {"Ti", 22}, {"V", 23}, {"Cr", 24}, {"Mn", 25},
{"Fe", 26}, {"Co", 27}, {"Ni", 28}, {"Cu", 29}, {"Zn", 30},
{"Ga", 31}, {"Ge", 32}, {"As", 33}, {"Se", 34}, {"Br", 35},
{"Kr", 36}, {"Rb", 37}, {"Sr", 38}, {"Y", 39}, {"Zr", 40},
{"Nb", 41}, {"Mo", 42}, {"Tc", 43}, {"Ru", 44}, {"Rh", 45},
{"Pd", 46}, {"Ag", 47}, {"Cd", 48}, {"In", 49}, {"Sn", 50},
{"Sb", 51}, {"Te", 52}, {"I", 53}, {"Xe", 54}, {"Cs", 55},
{"Ba", 56}, {"La", 57}, {"Ce", 58}, {"Pr", 59}, {"Nd", 60},
{"Pm", 61}, {"Sm", 62}, {"Eu", 63}, {"Gd", 64}, {"Tb", 65},
{"Dy", 66}, {"Ho", 67}, {"Er", 68}, {"Tm", 69}, {"Yb", 70},
{"Lu", 71}, {"Hf", 72}, {"Ta", 73}, {"W", 74}, {"Re", 75},
{"Os", 76}, {"Ir", 77}, {"Pt", 78}, {"Au", 79}, {"Hg", 80},
{"Tl", 81}, {"Pb", 82}, {"Bi", 83}, {"Po", 84}, {"At", 85},
{"Rn", 86}, {"Fr", 87}, {"Ra", 88}, {"Ac", 89}, {"Th", 90},
{"Pa", 91}, {"U", 92}, {"Np", 93}, {"Pu", 94}, {"Am", 95},
{"Cm", 96}, {"Bk", 97}, {"Cf", 98}, {"Es", 99}, {"Fm", 100},
{"Md", 101}, {"No", 102}, {"Lr", 103}, {"Rf", 104}, {"Db", 105},
{"Sg", 106}, {"Bh", 107}, {"Hs", 108}, {"Mt", 109}, {"Ds", 110},
{"Rg", 111}, {"Uub", 112}, {"Uut", 113}, {"Uuq", 114}, {"Uup", 115},
{"Uuh", 116}, {"Uus", 117}, {"Uuo", 118},
};
const unordered_map<int, const char*> inv_pt = {
{1, "H"}, {2, "He"}, {3, "Li"}, {4, "Be"}, {5, "B"},
{6, "C"}, {7, "N"}, {8, "O"}, {9, "F"}, {10, "Ne"},
{11, "Na"}, {12, "Mg"}, {13, "Al"}, {14, "Si"}, {15, "P"},
{16, "S"}, {17, "Cl"}, {18, "Ar"}, {19, "K"}, {20, "Ca"},
{21, "Sc"}, {22, "Ti"}, {23, "V"}, {24, "Cr"}, {25, "Mn"},
{26, "Fe"}, {27, "Co"}, {28, "Ni"}, {29, "Cu"}, {30, "Zn"},
{31, "Ga"}, {32, "Ge"}, {33, "As"}, {34, "Se"}, {35, "Br"},
{36, "Kr"}, {37, "Rb"}, {38, "Sr"}, {39, "Y"}, {40, "Zr"},
{41, "Nb"}, {42, "Mo"}, {43, "Tc"}, {44, "Ru"}, {45, "Rh"},
{46, "Pd"}, {47, "Ag"}, {48, "Cd"}, {49, "In"}, {50, "Sn"},
{51, "Sb"}, {52, "Te"}, {53, "I"}, {54, "Xe"}, {55, "Cs"},
{56, "Ba"}, {57, "La"}, {58, "Ce"}, {59, "Pr"}, {60, "Nd"},
{61, "Pm"}, {62, "Sm"}, {63, "Eu"}, {64, "Gd"}, {65, "Tb"},
{66, "Dy"}, {67, "Ho"}, {68, "Er"}, {69, "Tm"}, {70, "Yb"},
{71, "Lu"}, {72, "Hf"}, {73, "Ta"}, {74, "W"}, {75, "Re"},
{76, "Os"}, {77, "Ir"}, {78, "Pt"}, {79, "Au"}, {80, "Hg"},
{81, "Tl"}, {82, "Pb"}, {83, "Bi"}, {84, "Po"}, {85, "At"},
{86, "Rn"}, {87, "Fr"}, {88, "Ra"}, {89, "Ac"}, {90, "Th"},
{91, "Pa"}, {92, "U"}, {93, "Np"}, {94, "Pu"}, {95, "Am"},
{96, "Cm"}, {97, "Bk"}, {98, "Cf"}, {99, "Es"}, {100, "Fm"},
{101, "Md"}, {102, "No"}, {103, "Lr"}, {104, "Rf"}, {105, "Db"},
{106, "Sg"}, {107, "Bh"}, {108, "Hs"}, {109, "Mt"}, {110, "Ds"},
{111, "Rg"}, {112, "Uub"}, {113, "Uut"}, {114, "Uuq"}, {115, "Uup"},
{116, "Uuh"}, {117, "Uus"}, {118, "Uuo"},
};
int N;
int K;
uint32_t fullmask_n;
int arr1[17];
int arr2[17];
set<pair<string, int> > dp;
void print_els(uint32_t mask_n, uint32_t sum) {
uint32_t lsb = mask_n & ~(mask_n - 1);
printf("%s", inv_pt.at(arr1[__builtin_ctz(lsb)]));
mask_n &= (mask_n - 1);
while (mask_n) {
lsb = mask_n & ~(mask_n - 1);
printf("+%s", inv_pt.at(arr1[__builtin_ctz(lsb)]));
mask_n &= (mask_n - 1);
}
printf("->%s\n", inv_pt.at(sum));
}
static inline bool knapsack(uint32_t prev_mask_n, uint32_t k_ith) {
int sum1 = 0;
int sum2 = 0;
bool possible = true;
bitset<101> can;
can[0] = 1;
for (int i = 0; i < N; ++i) {
if (prev_mask_n & (1 << i)) {
continue;
}
sum1 += arr1[i];
can |= can << arr1[i];
}
for (int i = k_ith; i < K; ++i) {
sum2 += arr2[i];
possible &= can[arr2[i]];
}
return (sum1 == sum2) && possible;
}
bool find_result(uint32_t prev_mask_n, uint32_t k_ith,
string& last_atoms_used) {
if (__builtin_expect(!!(k_ith == K && prev_mask_n == fullmask_n), 0)) {
printf("YES\n");
return true;
}
if (dp.count(make_pair(last_atoms_used, k_ith))) {
return false;
}
if (!knapsack(prev_mask_n, k_ith)) {
return false;
}
uint32_t mask_n = ~prev_mask_n & fullmask_n;
for (uint32_t mask = mask_n;; mask = mask_n & (mask - 1)) {
uint32_t submask = mask ^ mask_n;
int sum = 0;
string atoms_used;
for (uint32_t aux = submask; aux; aux &= aux - 1) {
int lsb = __builtin_ctz(aux & ~(aux - 1));
if (arr1[lsb] > arr2[k_ith]) {
return false;
}
sum += arr1[lsb];
atoms_used.push_back(arr1[lsb]);
}
if (sum == arr2[k_ith]) {
uint32_t next_mask = prev_mask_n | submask;
size_t last_atoms_size = last_atoms_used.size();
last_atoms_used.append(atoms_used);
bool found = find_result(next_mask, k_ith + 1, last_atoms_used);
if (__builtin_expect(!!(found), 0)) {
print_els(submask, sum);
return true;
}
dp.insert(make_pair(last_atoms_used, k_ith + 1));
last_atoms_used.erase(last_atoms_size);
}
if (0 == mask) {
break;
}
}
return false;
}
int main(void) {
while (scanf(" %d %d", &N, &K) != EOF) {
dp.clear();
fullmask_n = 0;
for (int i = 0; i < N; ++i) {
char aux[4];
scanf(" %s", aux);
arr1[i] = pt.at(string(aux));
fullmask_n |= 1 << i;
}
for (int i = 0; i < K; ++i) {
char aux[4];
scanf(" %s", aux);
arr2[i] = pt.at(string(aux));
}
sort(arr1, arr1 + N);
sort(arr2, arr2 + K);
string atoms_used;
if (!find_result(0, 0, atoms_used)) {
printf("NO\n");
}
}
return 0;
}
| 5 |
#include<iostream>
#include<algorithm>
using namespace std;
int a[1001],b[1001],size;
int main()
{
//freopen("ctest.txt","r",stdin);
//freopen("ctest.out","w",stdout);
int i,j,k,n,I,N;
cin>>N;
for(I=1;I<=N;I++)
{
cin>>n;
for(i=1;i<=n;i++)
cin>>a[i];
sort(a+1,a+n+1);
size=0;
for(i=1;i<=n;i++)
{
if(a[i]==a[i-1]&&i>1)
{
size++;
b[size]=a[i];
}
else
cout<<a[i]<<" ";
}
for(i=1;i<=size;i++)
cout<<b[i]<<" ";
cout<<endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string stone;
string ins;
cin >> stone >> ins;
int n = 0;
int i = 0;
while (i < ins.length() && n < stone.length()) {
if (ins[i] == stone[n]) {
n++;
}
++i;
}
cout << n + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int mx(long long int a, long long int b) {
if (a >= b) return a;
return b;
}
long long int mn(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int mod = 1e9 + 7;
long long int pw(long long int a, long long int b, long long int md) {
long long int res = 1;
if (a <= 0) return 0;
while (b) {
if (b & 1) res = (res * a) % md;
b >>= 1;
a = (a * a) % md;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int p, k;
cin >> p >> k;
long long int ans = 1;
if (k == 0)
ans = pw(p, p - 1, mod);
else {
long long int k1 = k, p1 = 1;
while (k1 != 1) {
p1++;
k1 = (k1 * k) % p;
}
if (p1 == 1)
p1 = p;
else
p1 = (p - 1) / p1;
ans *= pw(p, p1, mod);
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int cnt[N];
bool push(int id, int solution) {
if (cnt[id] == solution) {
cnt[id]++;
} else if (cnt[id] < solution) {
return false;
}
return true;
}
int main() {
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int id, solution;
scanf("%d%d", &solution, &id);
if (!push(id, solution)) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, pos = 0;
string str;
cin >> n >> str;
vector<int> arr(n);
for (auto &i : arr) cin >> i;
map<int, int> m;
bool fin = false, infin = false;
while (true) {
if (str[pos] == '>' && pos + arr[pos] >= n)
fin = true;
else if (str[pos] == '<' && pos - arr[pos] < 0)
fin = true;
if (fin) {
cout << "FINITE" << endl;
return 0;
} else if (infin) {
cout << "INFINITE" << endl;
return 0;
}
if (str[pos] == '>')
pos += arr[pos];
else
pos -= arr[pos];
if (m[pos] > 0)
infin = true;
else
m[pos]++;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
string s[n][2];
string d;
for(int i=0;i<n;i++){
cin >> s[i][0];
cin >> s[i][1];
}
cin >> d;
int a;
for(int i=0;i<n;i++){
if(d == s[i][0]){a=i;}
}
int ans=0;
for(int i=a+1;i<n;i++){
ans += stoi(s[i][1]);
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 3e5 + 5;
const long long A = 1e6 + 5;
const long double pi = acos(-1);
long long divs[A];
long long n, m, a[N];
void prepare() {
for (long long i = 1; i < A; ++i)
for (long long j = i; j < A; j += i) ++divs[j];
}
struct _node {
long long sm;
long long mx;
} node[N << 2];
void build(long long i, long long l, long long r) {
if (l > r) return;
if (l == r) {
node[i].sm = node[i].mx = a[l];
return;
}
long long mid = l + r >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
node[i].sm = node[i << 1].sm + node[i << 1 | 1].sm;
node[i].mx = max(node[i << 1].mx, node[i << 1 | 1].mx);
}
void update(long long i, long long l, long long r, long long L, long long R) {
if (l > r || L > r || R < l) return;
if (node[i].mx <= 2) return;
if (l == r) {
node[i].sm = node[i].mx = a[l] = divs[a[l]];
return;
}
long long mid = l + r >> 1;
update(i << 1, l, mid, L, R);
update(i << 1 | 1, mid + 1, r, L, R);
node[i].sm = node[i << 1].sm + node[i << 1 | 1].sm;
node[i].mx = max(node[i << 1].mx, node[i << 1 | 1].mx);
}
long long get(long long i, long long l, long long r, long long L, long long R) {
if (l > r || L > r || R < l) return 0;
if (L <= l && R >= r) return node[i].sm;
long long mid = l + r >> 1;
return get(i << 1, l, mid, L, R) + get(i << 1 | 1, mid + 1, r, L, R);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
prepare();
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> a[i];
build(1, 1, n);
while (m--) {
long long type, l, r;
cin >> type >> l >> r;
if (type == 1)
update(1, 1, n, l, r);
else
cout << get(1, 1, n, l, r) << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r1, c1, r2, c2, rook, bish = 0, king;
cin >> r1 >> c1 >> r2 >> c2;
if (r1 == r2 || c1 == c2)
rook = 1;
else
rook = 2;
if ((r1 + c1) % 2 != (r2 + c2) % 2)
bish = 0;
else {
if (r1 + c1 == r2 + c2 || r1 - c1 == r2 - c2)
bish = 1;
else
bish = 2;
}
if (abs(r1 - r2) > abs(c1 - c2))
king = abs(r1 - r2);
else
king = abs(c1 - c2);
cout << rook << " " << bish << " " << king;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n), res(n);
vector<pair<int, int>> b(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i].first;
b[i].second = i;
}
sort(a.rbegin(), a.rend());
sort(b.begin(), b.end());
for (int i = 0; i < n; ++i) {
res[b[i].second] = a[i];
}
for (int x : res) cout << x << " ";
cout << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long sum[100005];
int a[1000005];
int n, t;
bool check(int l) {
int x = 1;
int y = x + l - 1;
while (x <= n) {
if (sum[y] - sum[x - 1] > 0 && sum[y] - sum[x - 1] <= t) {
return true;
}
if (sum[y] - sum[x - 1] < 0) return false;
++x;
y = l + x - 1;
}
return false;
}
int main() {
cin >> n >> t;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
int left = 0, right = n;
int mid;
while (left < right) {
mid = (left + right + 1) / 2;
if (check(mid)) {
left = mid;
} else {
right = mid - 1;
}
}
cout << left << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int prime[3010];
set<int> st[3010];
void Sieve(int n) {
for (int i = 2; i <= n; i++) {
if (prime[i] == 0) {
for (int j = 2 * i; j <= n; j += i) {
prime[j] = 1;
st[j].insert(i);
}
}
}
}
int main() {
memset(prime, 0, sizeof(prime));
int n;
int counter = 0;
scanf("%d", &n);
Sieve(n);
for (int i = 1; i <= n; i++) {
if (st[i].size() == 2) {
counter++;
}
}
cout << counter << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int maxn = 1e9 + 9;
int a[200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != 0) a[i] = maxn;
}
for (int i = 1; i <= n; i++) {
if (a[i] == 0) {
int j = 1;
while (a[i + j] != 0) a[i + j] = j, j++;
i = i + j - 1;
}
}
for (int i = n; i >= 1; i--) {
if (a[i] == 0) {
int j = 1;
while (a[i - j] != 0) a[i - j] = a[i - j] < j ? a[i - j] : j, j++;
i = i - j + 1;
}
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[(int)2e5 + 10];
long double WeekNess, mx = -1e18, mn = 1e18, sum;
long double Answer(long double Check) {
mx = 0, mn = 0, sum = 0, WeekNess = 0;
for (int i = 0; i < n; i++) {
mx = max(mx, sum);
mn = min(mn, sum);
sum += a[i] - Check;
WeekNess = max(WeekNess, fabs(sum - mx));
WeekNess = max(WeekNess, fabs(sum - mn));
}
return WeekNess;
}
long double BinarySol(long double l, long double r) {
long double mid1 = (2 * l + r) / 3;
long double mid2 = (2 * r + l) / 3;
int c = 0;
while (c++ <= 200) {
mid1 = (2 * l + r) / 3;
mid2 = (2 * r + l) / 3;
if (Answer(mid1) >= Answer(mid2)) {
l = mid1;
} else {
r = mid2;
}
}
return l;
}
int main() {
cin >> n;
for (int i = 0; i < n && scanf("%d", a + i); i++)
;
cout << setprecision(6) << fixed << Answer(BinarySol(-1e10, 1e10));
}
| 3 |
#include <bits/stdc++.h>
struct pair {
int x, y;
pair(int x, int y) : x(x), y(y) {}
};
char field[1100][1100];
std::queue<pair> qs[10];
std::vector<int> players;
int speed[10], answer[10];
int n, m, p;
bool way;
void preparetion() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
}
void init() { memset(field, '#', sizeof field); }
void get_data() {
std::cin >> n >> m >> p;
for (int i = 0; i < p; i++) {
std::cin >> speed[i];
players.push_back(i);
}
init();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
std::cin >> field[i][j];
if (field[i][j] >= '1' && field[i][j] <= '9') {
answer[field[i][j] - '0' - 1]++;
qs[field[i][j] - '0' - 1].push(pair(i, j));
}
}
}
int d_x[] = {0, 0, -1, 1};
int d_y[] = {-1, 1, 0, 0};
void bfs(int cur_player) {
for (int i = 0; !qs[cur_player].empty() && i < speed[cur_player]; i++) {
std::queue<pair> tmp_q;
while (!qs[cur_player].empty()) {
pair cur = qs[cur_player].front();
qs[cur_player].pop();
for (int i = 0; i < 4; i++) {
int to_x = cur.x + d_x[i], to_y = cur.y + d_y[i];
if (field[to_x][to_y] == '.') {
way = true;
answer[cur_player]++;
tmp_q.push(pair(to_x, to_y));
field[to_x][to_y] = '0' + cur_player + 1;
}
}
}
qs[cur_player] = tmp_q;
}
}
void print() {
for (int i = 0; i < p; i++) std::cout << answer[i] << ' ';
}
int main() {
preparetion();
get_data();
way = false;
do {
way = false;
for (int i = 0; i < p; i++) bfs(i);
} while (way);
print();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t N;
cin>>N;
if(N%2==1){
cout<<"0"<<endl;
}
else{
N/=2;
int64_t Z=0;
while(N>0){
N/=5;
Z+=N;
}
cout<<Z<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main () {
int n;
scanf ("%d",&n);
for (int x = 3,count = 0; count < n; x+=10) {
bool prime = true;
for (int y = 2; y * y <= x; y++) if (x%y==0) prime=false;
if (prime) {
count++;
printf ("%d%c",x,count==n?'\n':' ');
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
pair<int, int> c = make_pair(1, 0);
int dx = 1, cover = 0, inc = 0;
while (k != 1) {
if (inc == 0) cout << 2 << " ";
if (dx == 1 && c.second + dx <= m) {
c.second += dx;
} else if (dx == 1) {
c.first++;
dx = -1;
} else if (dx == -1 && c.second + dx >= 1) {
c.second += dx;
} else if (dx == -1) {
c.first++;
dx = 1;
}
cout << c.first << " " << c.second << " ";
inc++;
if (inc == 2) {
cout << endl;
k--;
inc = 0;
}
cover++;
}
cout << n * m - cover << " ";
while (cover < n * m) {
if (dx == 1 && c.second + dx <= m) {
c.second += dx;
} else if (dx == 1) {
c.first++;
dx = -1;
} else if (dx == -1 && c.second + dx >= 1) {
c.second += dx;
} else if (dx == -1) {
c.first++;
dx = 1;
}
cout << c.first << " " << c.second << " ";
cover++;
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long FastExp(long long a, long long b, long long c) {
if (b == 1) return a;
long long ans = FastExp(a, b / 2, c);
if (b % 2 == 0) return ans % c * ans % c;
if (b % 2 != 0) return ans % c * ans % c * a % c;
}
int main() {
int n;
cin >> n;
int a[n + 5];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
if (i == a[a[a[i]]]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
bitset<510> can[maxn][2][64];
int N, M;
long long ans, best[maxn][2];
inline long long dfs(int now, int last) {
if (best[now][last ^ 1] != -1)
return best[now][last ^ 1];
else
best[now][last ^ 1] = 0;
for (int i = 59; i >= 0; --i)
if (can[now][last ^ 1][i].any()) {
for (int j = 1; j <= N; ++j)
if (can[now][last ^ 1][i][j])
best[now][last ^ 1] =
max(dfs(j, last ^ 1) + (1LL << i), best[now][last ^ 1]);
break;
}
return best[now][last ^ 1];
}
int main() {
scanf("%d %d", &N, &M);
while (M--) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
can[a][c][0][b] = 1;
}
for (int i = 1; i <= 62; ++i)
for (int j = 1; j <= N; ++j)
for (int k = 0; k < 2; ++k)
for (int l = 1; l <= N; ++l) {
if (!can[j][k][i - 1][l]) continue;
can[j][k][i] |= can[l][k ^ 1][i - 1];
}
for (int i = 1; i <= N; ++i)
if (can[i][0][60].any()) puts("-1"), exit(0);
memset(best, -1, sizeof(best));
for (int i = 1; i <= N; ++i) ans = max(ans, dfs(i, 1));
if (ans > 1000000000000000000LL) ans = -1;
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void fastIO() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
template <typename T, typename U>
inline void mnze(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void mxze(T &x, U y) {
if (x < y) x = y;
}
void _scan(int &x) { scanf("%d", &x); }
void _scan(long long &x) { scanf("%lld", &x); }
void _scan(double &x) { scanf("%lf", &x); }
void _scan(char &x) { scanf(" %c", &x); }
void _scan(char *x) { scanf("%s", x); }
void scan() {}
template <typename T, typename... U>
void scan(T &head, U &...tail) {
_scan(head);
scan(tail...);
}
template <typename T>
void _dbg(const char *sdbg, T h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename T, typename... U>
void _dbg(const char *sdbg, T h, U... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
int main() {
int n, pos, l, r;
scan(n, pos, l, r);
int s = 1, ans = 0;
if (l == 1 && r == n)
ans = 0;
else if (l == 1) {
ans = 1 + (abs(pos - r));
} else if (r == n) {
ans = 1 + (abs(pos - l));
} else {
int a = abs(pos - l);
int b = abs(pos - r);
if (a < b) {
ans += 1 + abs(pos - l);
pos = l;
ans += 1 + abs(pos - r);
} else {
ans += 1 + abs(pos - r);
pos = r;
ans += 1 + abs(pos - l);
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <tuple>
using namespace std;
class Solver {
};
signed main() {
while (true) {
int n;
cin >> n;
if (n == 0)break;
vector<int> hs(n + 1, 0);
for (int i = 0; i < n + 1; i++) {
cin >> hs[i];
}
for (int i = 0; i < n + 1; i++) {
vector<int> remain;
for (int j = 0; j < n + 1; j++) {
if (i == j)continue;
remain.emplace_back(hs[j]);
}
vector<int> deltas;
for (int j = 1; j < n; j++) {
deltas.emplace_back(remain[j] - remain[j - 1]);
}
sort(deltas.begin(), deltas.end());
if (deltas[0] == deltas[deltas.size() - 1]) {
cout << hs[i] << endl;
break;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int xx[4] = {0, 0, 1, -1};
int yy[4] = {1, -1, 0, 0};
int n, m, k, s;
int a[int(1e5)];
int getbit(int x, int i) { return (x >> i) & 1; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = (1), _b = (m); i <= _b; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &s);
int res = 0;
for (int i = (1), _b = (m); i <= _b; i++) {
int dem = 0;
for (int x = (0), _b = (n - 1); x <= _b; x++)
if (getbit(s, x) != getbit(a[i], x)) {
dem++;
}
if (dem <= k) res++;
}
cout << res << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, ans;
int c1 = 0, c2 = 0;
bool f1 = 0, f2 = 0;
int a[105];
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = m; i <= n; i++) {
if (k >= a[i] && a[i] != 0) {
f1 = 1;
break;
} else {
c1++;
}
}
for (int i = m; i >= 1; i--) {
if (k >= a[i] && a[i] != 0) {
f2 = 1;
break;
} else {
c2++;
}
}
if (f1 == 1 && f2 == 1) {
ans = 10 * min(c1, c2);
cout << ans;
return 0;
} else if (f1 == 1) {
ans = 10 * c1;
cout << ans;
return 0;
} else {
ans = 10 * c2;
cout << ans;
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int x = 0, y = 0;
int ans = 0;
for (int i = 0; i < n - 1; i++) {
if (s[i] == 'U')
y++;
else
x++;
if (x == y && s[i] == s[i + 1]) ans++;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string a = "au", b = "Blbsr";
int ans = s.size();
for (int i = 0; i < 2; i++)
ans = min(ans, (int)count(s.begin(), s.end(), a[i]) / 2);
for (int i = 0; i < 5; i++)
ans = min(ans, (int)count(s.begin(), s.end(), b[i]));
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 105;
int read() {
int x = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9') {
if (c == '-') f = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int n, ans, sum, cnt, a[M], b[M], C[M][M], dp[M][M * M];
signed main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
b[a[i]]++;
}
C[0][0] = 1;
for (int i = 1; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
sum += a[i];
for (int k = i; k >= 1; k--)
for (int j = sum; j >= a[i]; j--) dp[k][j] += dp[k - 1][j - a[i]];
}
for (int i = 1; i <= 100; i++) {
if (b[i]) cnt++;
for (int j = 1; j <= b[i]; j++) {
if (dp[j][i * j] == C[b[i]][j]) ans = max(ans, j);
}
}
if (cnt == 1 || cnt == 2) ans = n;
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
const int p = 100000000;
int N, M, i, e, X, Y;
int son[705], ed[1405], next[1405], size[705];
long long tmp[40], f[705][705][40];
void Addedge(int X, int Y) { ed[++e] = Y, next[e] = son[X], son[X] = e; }
void Ok(long long a[]) {
int i;
for (i = 1; i < a[0]; ++i) {
a[i + 1] += a[i] / p;
a[i] %= p;
}
for (; a[a[0]] >= p;) a[a[0] + 1] = a[a[0]] / p, a[a[0]] %= p, ++a[0];
for (; a[0] > 0 && a[a[0]] == 0; --a[0])
;
}
void Mul(long long a[], long long b[], long long c[]) {
int i, j;
for (i = 1; i <= c[0]; ++i) c[i] = 0;
c[0] = a[0] + b[0] - 1;
for (i = 1; i <= a[0]; ++i)
for (j = 1; j <= b[0]; ++j) c[i + j - 1] += a[i] * b[j];
Ok(c);
}
void mul(long long a[], long long b, long long c[]) {
int i;
for (i = 1; i <= c[0]; ++i) c[i] = 0;
c[0] = a[0];
for (i = 1; i <= a[0]; ++i) c[i] = a[i] * b;
Ok(c);
}
void Renew(long long a[], long long b[]) {
int i;
if (a[0] < b[0]) return;
if (a[0] == b[0])
for (i = a[0]; i; --i) {
if (a[i] < b[i]) return;
if (a[i] > b[i]) break;
}
for (i = 0; i <= a[0]; ++i) b[i] = a[i];
}
void print(long long a[]) {
int i;
printf("%I64d", a[a[0]]);
for (i = a[0] - 1; i; --i) printf("%.08I64d", a[i]);
printf("\n");
}
void dfs(int x, int y) {
int p, i, j, k;
size[x] = 1;
f[x][0][1] = f[x][0][0] = f[x][1][1] = f[x][1][0] = 1;
for (p = son[x]; p; p = next[p])
if (ed[p] != y) {
i = ed[p], dfs(i, x);
for (j = size[x]; j >= 0; --j)
for (k = size[i]; k >= 0; --k) {
Mul(f[x][j], f[i][k], tmp);
Renew(tmp, f[x][j + k]);
}
size[x] += size[i];
}
for (j = 1; j <= size[x]; ++j) {
mul(f[x][j], j, tmp);
Renew(tmp, f[x][0]);
}
}
int main() {
scanf("%d", &N);
for (i = 1; i < N; ++i) {
scanf("%d%d", &X, &Y);
Addedge(X, Y), Addedge(Y, X);
}
dfs(1, 0);
print(f[1][0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans[505][505];
int init[9]{9, 7, 5, 6, 3, 8, 1, 4, 2};
int N, idx;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N;
if (N < 3) {
cout << "-1\n";
exit(0);
}
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) ans[i][j] = N * N - 9 + init[idx++];
idx = 1;
if (N & 1) {
for (int i = 1; i <= N; i++) {
if (i & 1) {
for (int j = N; j > 3; j--) ans[i][j] = idx++;
} else {
for (int j = 4; j <= N; j++) ans[i][j] = idx++;
}
}
for (int j = 3; j >= 1; j--) {
if (j & 1) {
for (int i = N; i > 3; i--) ans[i][j] = idx++;
} else {
for (int i = 4; i <= N; i++) ans[i][j] = idx++;
}
}
} else {
for (int j = N; j >= 1; j--) {
if (j & 1) {
for (int i = N; i >= 1; i--)
if (!ans[i][j]) ans[i][j] = idx++;
} else {
for (int i = 1; i <= N; i++)
if (!ans[i][j]) ans[i][j] = idx++;
}
}
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) cout << ans[i][j] << " \n"[j == N];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int a[maxn], l[maxn], r[maxn], x, y, z;
long long sum[maxn], ans = -0x3f3f3f3f;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n; i++) {
if (sum[i] > sum[l[i - 1]])
l[i] = i;
else
l[i] = l[i - 1];
}
r[n] = n;
for (int i = n - 1; i >= 0; i--) {
if (sum[i] >= sum[r[i + 1]])
r[i] = i;
else
r[i] = r[i + 1];
}
for (int i = 0; i <= n; i++)
if (sum[l[i]] - sum[i] + sum[r[i]] > ans) {
ans = sum[l[i]] - sum[i] + sum[r[i]];
x = l[i], y = i, z = r[i];
}
cout << x << " " << y << " " << z << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3, M = 1000000, INF = 0x3f3f3f3f;
char cc[N][M + 1];
int main() {
int n, m;
cin >> n >> m;
if (n >= 4) {
cout << "-1\n";
return 0;
}
if (n == 1 || m == 1) {
cout << "0\n";
return 0;
}
for (int i = 0; i < n; i++) cin >> cc[i];
if (n == 2) {
int ans = INF;
for (int r = 0; r < 2; r++) {
int k = 0;
for (int r_ = r, j = 0; j < m; j++, r_ ^= 1)
if (((cc[0][j] == '1') + (cc[1][j] == '1')) % 2 != r_) k++;
ans = min(ans, k);
}
cout << ans << '\n';
} else {
int dp000 = 0, dp001 = 0, dp010 = 0, dp011 = 0, dp100 = 0, dp101 = 0,
dp110 = 0;
int dp111 = 0;
for (int j = 0; j < m; j++) {
int dp000_ = min(dp010, dp101) + (cc[0][j] == '1') + (cc[1][j] == '1') +
(cc[2][j] == '1');
int dp001_ = min(dp011, dp100) + (cc[0][j] == '1') + (cc[1][j] == '1') +
(cc[2][j] == '0');
int dp010_ = min(dp000, dp111) + (cc[0][j] == '1') + (cc[1][j] == '0') +
(cc[2][j] == '1');
int dp011_ = min(dp001, dp110) + (cc[0][j] == '1') + (cc[1][j] == '0') +
(cc[2][j] == '0');
int dp100_ = min(dp001, dp110) + (cc[0][j] == '0') + (cc[1][j] == '1') +
(cc[2][j] == '1');
int dp101_ = min(dp000, dp111) + (cc[0][j] == '0') + (cc[1][j] == '1') +
(cc[2][j] == '0');
int dp110_ = min(dp011, dp100) + (cc[0][j] == '0') + (cc[1][j] == '0') +
(cc[2][j] == '1');
int dp111_ = min(dp010, dp101) + (cc[0][j] == '0') + (cc[1][j] == '0') +
(cc[2][j] == '0');
dp000 = dp000_;
dp001 = dp001_;
dp010 = dp010_;
dp011 = dp011_;
dp100 = dp100_;
dp101 = dp101_;
dp110 = dp110_;
dp111 = dp111_;
}
cout << min(min(min(dp000, dp001), min(dp010, dp011)),
min(min(dp100, dp101), min(dp110, dp111)))
<< '\n';
}
return 0;
}
| 4 |
#include <iostream>
#include <string>
#include <map>
using namespace std;
int M,l;int main(){string s,t,u;map<string,int>m;for(;cin>>u;t=t.size()<u.size()?u:t)if(++m[u]>M)M=m[u],s=u;cout<<s<<' '<<t<<endl;} | 0 |
Subsets and Splits