solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
set<int> stl[maxn], str[maxn];
map<pair<int, int>, int> mp;
int n, m, q;
namespace Segtree {
int mx[maxn << 2], mi[maxn << 2], eleg[maxn << 2];
void pushup(int o) {
int lch = o * 2, rch = o * 2 + 1;
mx[o] = max(mx[lch], mx[rch]);
mi[o] = min(mi[lch], mi[rch]);
eleg[o] = (eleg[lch] | eleg[rch]);
eleg[o] |= (mx[rch] >= mi[lch]);
return;
}
void build(int o, int L, int R) {
int lch = o * 2, rch = o * 2 + 1;
if (L == R) {
mx[o] = 0;
mi[o] = m + 1;
eleg[o] = 0;
return;
}
int mid = (L + R) / 2;
build(lch, L, mid);
build(rch, mid + 1, R);
pushup(o);
}
void update(int o, int L, int R, int pos) {
int lch = o * 2, rch = o * 2 + 1;
if (L == R) {
if (str[L].empty())
mx[o] = 0;
else
mx[o] = *str[L].rbegin();
if (stl[L].empty())
mi[o] = m + 1;
else
mi[o] = *stl[L].begin();
eleg[o] = (mx[o] >= mi[o] ? 1 : 0);
return;
}
int mid = (L + R) / 2;
if (pos <= mid)
update(lch, L, mid, pos);
else
update(rch, mid + 1, R, pos);
pushup(o);
return;
}
}; // namespace Segtree
using namespace Segtree;
int main() {
scanf("%d%d%d", &n, &m, &q);
build(1, 1, n);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
++x;
x /= 2;
++y;
if (y & 1) {
if (str[x].count(y / 2))
str[x].erase(y / 2);
else
str[x].insert(y / 2);
} else {
if (stl[x].count(y / 2))
stl[x].erase(y / 2);
else
stl[x].insert(y / 2);
}
update(1, 1, n, x);
printf("%s\n", eleg[1] ? "NO" : "YES");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
double ans = 0.0;
cin >> n;
for (int i = (1); i <= (n); i++) {
ans += (double)1 / (double)(i);
}
printf("%.10lf\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
long long mypow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % MOD;
y >>= 1;
x = x * x % MOD;
}
return res;
}
long long fac[SIZE], inv[SIZE];
long long C(int x, int y) {
if (y < 0 || y > x) return 0;
long long res = 1;
for (int i = (1); i <= (y); ++i) res = res * (x + 1 - i) % MOD;
return res * inv[y] % MOD;
}
int N, K, M;
long long cnt[15][100];
long long dp0[15][60][16];
long long dp[15][15][100];
void pre() {
fac[0] = 1;
for (int i = (1); i < (15); ++i) fac[i] = fac[i - 1] * i % MOD;
inv[14] = mypow(fac[14], MOD - 2);
for (int i = 13; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % MOD;
dp0[1][1][1] = 1;
int mask = (1 << M) - 1;
for (int i = (1); i < (K); ++i)
for (int j = (1); j <= ((i - 1) * M + 1); ++j)
for (int k = 1; k <= mask; k += 2) {
for (int dd = (1); dd <= (M); ++dd) {
int nxt_k = (k << (dd - 1)) & mask;
ADD(dp0[i + 1][j + dd][((nxt_k << 1) | 1) & mask],
dp0[i][j][k] * (__builtin_popcount(nxt_k) + 1));
}
}
for (int i = (1); i <= (K); ++i)
for (int j = (1); j <= ((i - 1) * M + 1); ++j)
for (int k = 1; k <= mask; k += 2) {
ADD(cnt[i][j], dp0[i][j][k]);
}
}
int main() {
R(N, K, M);
pre();
dp[0][0][0] = 1;
for (int i = 0; i < (K); ++i) {
for (int j = 0; j < (K); ++j) {
for (int k = 0; k < (100); ++k) {
if (!dp[i][j][k]) continue;
for (int use_num = 1; use_num + j <= K; use_num++) {
for (int dd = (1); dd <= ((use_num - 1) * M + 1); ++dd) {
if (!i) {
ADD(dp[i + 1][j + use_num][k + dd],
dp[i][j][k] * cnt[use_num][dd]);
} else {
ADD(dp[i + 1][j + use_num][k + dd + M],
dp[i][j][k] * cnt[use_num][dd]);
}
}
}
}
}
}
long long an = 0;
for (int i = (1); i <= (K); ++i) {
for (int k = 0; k < (100); ++k) {
if (!dp[i][K][k]) continue;
if (k > N) continue;
ADD(an, dp[i][K][k] * C(N - k + i, i));
}
}
W(an);
return 0;
}
| 6 |
#include<iostream>
#include<map>
#include<vector>
#include<cstdio>
using namespace std;
const int M=3009;
const int N=1e5+9;
typedef long long ll;
typedef map<ll,int>::iterator it;
bool npri[M];
ll n,a[N];
vector<ll> pri;
map<ll,int> ha;
inline void init()
{
for(int i=2;i<M;i++)
{
if(!npri[i])
pri.push_back(i);
for(int j=0,ed=pri.size();j<ed && i*pri[j]<M;j++)
{
npri[i*pri[j]]=1;
if(!(i%pri[j]))
break;
}
}
for(int i=0,ed=pri.size();i<ed;i++)
pri[i]=pri[i]*pri[i]*pri[i];
}
inline ll div(ll val)
{
for(int i=0,ed=pri.size();i<ed;i++)
while(!(val%pri[i]))
val/=pri[i];
return val;
}
int main()
{
init();
scanf("%lld",&n);
for(int i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
ha[a[i]=div(a[i])]++;
}
ll ans=0;
for(it i=ha.begin();i!=ha.end();i++)
{
ll val=i->first;
if(val==1)continue;
val=div(val*val);
ans+=max(i->second,ha[val]);
i->second=0;
ha[val]=0;
}
if(ha[1]>0)
ans++;
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, pos[20], bad[20];
double p[20], ans[20], dp[(1 << 20) + 5];
int main() {
scanf("%d%d", &m, &k);
for (int i = 0; i < m; i++) {
double x;
scanf("%lf", &x);
if (fabs(x) > 1e-12) {
pos[n] = i;
p[n++] = x;
} else
bad[i] = 1;
}
dp[0] = 1.0;
k = min(k, n);
for (int mask = 0; mask < (1 << n); mask++) {
double s = 0;
for (int i = 0; i < n; i++) {
if (mask & 1 << i) s += p[i];
}
if (fabs(s - 1.0) < 1e-12) continue;
for (int i = 0; i < n; i++)
if ((mask & 1 << i) == 0)
dp[mask | (1 << i)] += dp[mask] * p[i] / (1.0 - s);
}
for (int mask = 0; mask < (1 << n); mask++) {
if (__builtin_popcount(mask) != k) continue;
for (int i = 0; i < n; i++)
if (mask & 1 << i) ans[pos[i]] += dp[mask];
}
for (int i = 0; i < m; i++) {
if (bad[i])
printf("%.10lf", 0.0);
else
printf("%.10lf", ans[i]);
printf(i == m - 1 ? "\n" : " ");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 100005;
int n, ans = 1;
bool vis[maxn], iscenter[maxn];
int siz[maxn];
struct edge {
int to, zne, color;
};
vector<edge> gr[maxn];
vector<int> cd[maxn];
int poww(int x, int p) {
if (p == 0) return 1;
if (p == 1) return x;
int t = poww(x, p >> 1);
t = (1LL * t * t) % mod;
if (p & 1) t = (1LL * t * x) % mod;
return t;
}
struct node {
int key, prior, zhel, zne, cnt;
node *l, *r;
node(){};
node(int _key, int _zne) {
zne = zhel = _zne;
key = _key;
cnt = 1;
prior = rand();
l = r = 0;
}
};
void upd(node *&t) {
if (t) {
t->zhel = t->zne;
t->cnt = 1;
if (t->l) t->cnt += t->l->cnt, t->zhel = (1LL * t->zhel * t->l->zhel) % mod;
if (t->r) t->cnt += t->r->cnt, t->zhel = (1LL * t->zhel * t->r->zhel) % mod;
}
}
void merge(node *&t, node *l, node *r) {
if (!l || !r)
t = (l ? l : r);
else {
if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
}
upd(t);
}
void split(node *t, node *&l, node *&r, int key) {
if (!t)
l = r = 0;
else {
if (t->key <= key)
split(t->r, t->r, r, key), l = t;
else
split(t->l, l, t->l, key), r = t;
upd(l);
upd(r);
}
}
void insert(node *&t, int key, int zne) {
node *l, *r;
split(t, l, r, key);
node *md = new node(key, zne);
merge(t, l, md);
merge(t, t, r);
}
int dfs(int v) {
vis[v] = true;
siz[v] = 1;
for (edge u : gr[v]) {
if (!vis[u.to] && !iscenter[u.to]) siz[v] += dfs(u.to);
}
return siz[v];
}
int get_centr(int v, int sz) {
bool fnd = true;
int biggest = -1;
vis[v] = true;
for (edge u : gr[v]) {
if (!vis[u.to] && !iscenter[u.to]) {
if (siz[u.to] > sz / 2) fnd = false;
if (biggest == -1 || siz[u.to] > siz[biggest]) biggest = u.to;
}
}
if (fnd && sz <= 2 * siz[v])
return v;
else
return get_centr(biggest, sz);
}
int get_centroid(int root) {
memset(vis, false, sizeof(vis));
memset(siz, 0, sizeof(siz));
int sz = dfs(root);
memset(vis, false, sizeof(vis));
int centr = get_centr(root, sz);
iscenter[centr] = true;
return centr;
}
struct put {
int kleik, cr, cb;
};
vector<put> vsp;
void get_vsp(int v, int cr, int cb, int kleik, int par) {
vsp.push_back({kleik, cr, cb});
for (edge u : gr[v]) {
if (!iscenter[u.to] && par != u.to)
get_vsp(u.to, cr + 1 - u.color, cb + u.color, (1LL * kleik * u.zne) % mod,
v);
}
}
int decomp(int v) {
int root = get_centroid(v);
int ann = 1, del = 1;
node *t1 = 0, *t2 = 0;
for (edge u : gr[root]) {
if (!iscenter[u.to]) {
vsp.clear();
get_vsp(u.to, 1 - u.color, u.color, u.zne, -1);
for (put a : vsp) {
node *l, *r;
int step = 0;
split(t1, l, r, 2 * a.cr - a.cb);
if (l) ann = (1LL * ann * l->zhel) % mod;
if (l) step = l->cnt;
merge(t1, l, r);
split(t2, l, r, 2 * a.cb - a.cr);
if (r) del = (1LL * del * r->zhel) % mod;
if (r) step -= r->cnt;
merge(t2, l, r);
ans = (1LL * ans * poww(a.kleik, step)) % mod;
if (2 * a.cb >= a.cr && 2 * a.cr >= a.cb)
ans = (1LL * ans * a.kleik) % mod;
}
for (put a : vsp) {
insert(t1, a.cb - 2 * a.cr, a.kleik);
insert(t2, a.cr - 2 * a.cb, a.kleik);
}
}
}
ann = (1LL * ann * poww(del, mod - 2)) % mod;
ans = (1LL * ans * ann) % mod;
for (edge u : gr[root]) {
if (!iscenter[u.to]) {
int v = decomp(u.to);
cd[v].push_back(root);
cd[root].push_back(v);
}
}
return root;
}
int main() {
srand(137657);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v, zne, col;
cin >> u >> v >> zne >> col;
gr[u].push_back({v, zne, col});
gr[v].push_back({u, zne, col});
}
int cdroot = decomp(1);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
cout.tie(0);
int n, k;
int x = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int tmp = k;
for (int j = 0; j < n; j++)
if (j == x)
cout << tmp << ' ';
else
cout << 0 << ' ';
cout << endl;
x++;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 998244353;
const long long int INF = 3e18;
long long int power(long long int base, long long int exp) {
long long int res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base);
base = (base * base);
exp /= 2;
}
return res;
}
long long int bitc(long long int n, long long int x) { return ((n >> x) & 1); }
long long int __gcd(long long int a, long long int b) {
return b == 0 ? a : __gcd(b, a % b);
}
long long int fsub(long long int a, long long int b, long long int p = MOD) {
return ((a % p) - (b % p) + p) % p;
}
long long int fmult(long long int a, long long int b, long long int p = MOD) {
return ((((a % p) * (b % p)) % p) + p) % p;
}
long long int fadd(long long int a, long long int b, long long int p = MOD) {
return ((a % p + b % p) % p + p) % p;
}
long long int fpow(long long int n, long long int k, long long int p = MOD) {
long long int r = 1;
while (k > 0) {
if (k & 1) r = r * n % p;
n = n * n % p;
k = k >> 1;
}
return r;
}
long long int inv(long long int a, long long int p = MOD) {
return fpow(a, p - 2, p);
}
long long int fdiv(long long int a, long long int b, long long int p = MOD) {
long long int yinv = inv(b);
long long int ans = (a * yinv) % p;
return ((ans) % p + p) % p;
}
long long int ceil(long long int a, long long int b) {
return ceil((long double)a / b);
}
template <typename T>
istream &operator>>(istream &in, vector<T> &a) {
for (auto &item : a) {
in >> item;
}
return in;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, pair<T, U> &a) {
cout << a.first << " " << a.second;
return out;
}
template <typename T, typename U>
istream &operator>>(istream &out, pair<T, U> &a) {
cin >> a.first >> a.second;
return out;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, map<T, U> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &a) {
for (auto &item : a) {
out << item << " ";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<vector<T>> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
template <int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
static_assert(D >= 1, "Vector dimension must be greater than zero!");
template <typename... Args>
Vec(int n = 0, Args... args)
: vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {}
};
template <typename T>
struct Vec<1, T> : public vector<T> {
Vec(int n = 0, T val = T()) : vector<T>(n, val) {}
};
std::vector<bool> is_prime;
std::vector<long long int> primes;
void sieve(long long int n) {
is_prime.resize(n + 2, true);
primes.clear();
long long int p;
for (p = 2; p * p <= n; p++) {
if (is_prime[p]) {
long long int i;
for (i = p * p; i <= n; i += p) {
is_prime[i] = false;
}
}
}
is_prime[0] = is_prime[1] = false;
long long int i;
for (i = 2; i <= n; i++) {
if (is_prime[i]) {
primes.emplace_back(i);
}
}
}
map<long long int, long long int> prime_factors(long long int n) {
map<long long int, long long int> s;
long long int i;
long long int tc = 0;
while (n % 2 == 0) {
tc++;
n /= 2;
}
if (tc > 0) {
s[2] = tc;
}
for (i = 3; i <= sqrt(n); i += 2) {
tc = 0;
while (n % i == 0) {
tc++;
n /= i;
}
if (tc > 0) {
s[i] = tc;
}
}
if (n > 2) {
s[n] += 1;
}
return s;
}
std::vector<long long int> fact_vec;
void fact_fun(long long int n) {
fact_vec.resize(n + 10);
long long int i;
fact_vec[0] = 1;
for (i = 1; i <= n + 2; i++) {
fact_vec[i] = (fact_vec[i - 1] * i) % MOD;
}
}
std::vector<long long int> p2;
void power_2(long long int n, long long int m = MOD) {
long long int i;
p2.emplace_back(1);
for (i = 0; i < n; i++) {
p2.emplace_back(fmult(p2.back(), 2));
}
}
long long int ncr(long long int n, long long int r) {
if (r > n) return 0;
return fdiv(fact_vec[n], fmult(fact_vec[r], fact_vec[n - r]));
}
std::vector<long long int> spf;
void sieve2(long long int MAXN) {
MAXN += 10;
spf.resize(MAXN, 0);
spf[1] = 1;
for (long long int i = 2; i < MAXN; i++) spf[i] = i;
for (long long int i = 4; i < MAXN; i += 2) spf[i] = 2;
for (long long int i = 3; i * i < MAXN; i++) {
if (spf[i] == i) {
for (long long int j = i * i; j < MAXN; j += i) {
if (spf[j] == j) spf[j] = i;
}
}
}
}
const int mi[4] = {-1, 0, 1, 0}, mj[4] = {0, 1, 0, -1};
const int d8i[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
d8j[8] = {0, 1, 1, 1, 0, -1, -1, -1};
map<long long int, long long int> getFactorization(long long int x) {
map<long long int, long long int> ret;
while (x != 1) {
ret[spf[x]]++;
x = x / spf[x];
}
return ret;
}
class Sol {
public:
Sol() { long long int i, j; }
};
int main() {
long long int i, j;
ios::sync_with_stdio(false);
cin.tie(0);
long long int ti;
ti = 1;
while (ti--) {
long long int n;
cin >> n;
std::vector<long long int> v(n * 2);
cin >> v;
sort((v).begin(), (v).end());
fact_fun(3e5 + 3);
long long int tp = ncr(2 * n, n);
long long int f = 0;
long long int s = 0;
for (i = 0; i < n; i++) {
f += v[i];
}
for (i = n; i < 2 * n; i++) {
s += v[i];
}
s -= f;
tp = fmult(s, tp);
cout << tp << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int MAXN = 2001000;
int n1, n2, a1[MAXN], a2[MAXN], pos[MAXN];
int main() {
cin >> n1 >> n2;
for (int i = 0; i < (int)(n1); i++) {
scanf("%d", &a1[i]);
a1[n1 + i] = a1[i];
}
memset(pos, 255, sizeof pos);
for (int i = 0; i < (int)(n2); i++) {
scanf("%d", &a2[i]);
a2[n2 + i] = a2[i];
pos[a2[i]] = i;
}
int ans = 0, r = 0, last = -1, len = 0;
for (int l = 0; l < (int)(n1); l++) {
while (r - l < n1) {
if (pos[a1[r]] == -1) break;
if (r == l) {
len = 1;
r++;
} else {
int cur = (pos[a1[r]] - pos[a1[r - 1]] + n2) % n2;
if (cur + len > n2) break;
len += cur;
r++;
}
}
ans = max(ans, r - l);
if (r == l)
r++;
else
len -= (pos[a1[l + 1]] - pos[a1[l]] + n2) % n2;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
inline bool valid(int x, int w) { return 0 <= x && x < w; }
void iostream_init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(12);
}
const long long LINF = LLONG_MAX / 4;
vector<long long> calc(string s, char L, char R, int w) {
const int n = s.size();
deque<long long> left, right;
int x = 0;
for (int i = 0; i < (int)(n); ++i) {
if (s[i] == L) {
x++;
} else if (s[i] == R) {
x--;
}
if (x < 0) {
int index = -x - 1;
if (index >= right.size()) {
right.push_back(i + 1);
assert(right.size() == index + 1);
}
} else if (x > 0) {
int index = x - 1;
if (index >= left.size()) {
left.push_back(i + 1);
assert(left.size() == index + 1);
}
}
}
vector<long long> res(w, LINF);
auto update = [&] {
for (int i = 0; i < left.size() && i < w; i++) {
if (res[i] > left[i]) {
res[i] = left[i];
}
}
for (int i = 0; i < right.size() && i < w; i++) {
if (res[w - 1 - i] > right[i]) {
res[w - 1 - i] = right[i];
}
}
};
if (x > 0) {
int d = x;
while (left.size() < w) {
for (int i = 0; i < (int)(d); ++i) {
int idx = left.size() - d;
left.push_back(left[idx] + n);
if (left.size() == w) break;
}
}
} else if (x < 0) {
int d = -x;
while (right.size() < w) {
for (int i = 0; i < (int)(d); ++i) {
int idx = right.size() - d;
right.push_back(right[idx] + n);
}
}
}
update();
return res;
}
template <int MOD>
struct ModInt {
static const int Mod = MOD;
unsigned val;
ModInt() : val(0) {}
ModInt(unsigned x) : val(x % MOD) {}
ModInt(signed x) {
int y = x % MOD;
if (y < 0) y += MOD;
val = y;
}
ModInt(signed long long x) {
int y = x % MOD;
if (y < 0) y += MOD;
val = y;
}
ModInt &operator+=(ModInt rhs) {
val += rhs.val;
if (val >= MOD) val -= MOD;
return *this;
}
ModInt &operator-=(ModInt rhs) {
val += MOD - rhs.val;
if (val >= MOD) val -= MOD;
return *this;
}
ModInt &operator*=(ModInt rhs) {
val = (unsigned long long)val * rhs.val % MOD;
return *this;
}
ModInt &operator/=(ModInt rhs) { return *this *= rhs.inv(); }
ModInt inv() const {
signed a = val, b = MOD, u = 1, v = 0;
while (b) {
signed t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
if (u < 0) u += MOD;
ModInt res;
res.val = u;
return res;
}
ModInt operator+(ModInt rhs) const { return ModInt(*this) += rhs; }
ModInt operator-(ModInt rhs) const { return ModInt(*this) -= rhs; }
ModInt operator*(ModInt rhs) const { return ModInt(*this) *= rhs; }
ModInt operator/(ModInt rhs) const { return ModInt(*this) /= rhs; }
bool operator==(ModInt rhs) const { return val == rhs.val; }
bool operator!=(ModInt rhs) const { return val != rhs.val; }
bool operator<(ModInt rhs) const { return val < rhs.val; }
bool operator<=(ModInt rhs) const { return val <= rhs.val; }
bool operator>(ModInt rhs) const { return val > rhs.val; }
bool operator>=(ModInt rhs) const { return val >= rhs.val; }
};
template <int MOD>
ostream &operator<<(ostream &os, const ModInt<MOD> m) {
return os << m.val;
}
template <int MOD, typename T>
ModInt<MOD> pow(ModInt<MOD> a, T b) {
if (b == 0) {
return 1;
} else {
auto w = pow(a * a, b / 2);
if (b & 1) w *= a;
return w;
}
}
int main() {
iostream_init();
int n, h, w;
while (cin >> n >> h >> w) {
string s;
cin >> s;
auto wv = calc(s, 'L', 'R', w);
auto hv = calc(s, 'U', 'D', h);
sort(hv.begin(), hv.end());
sort(wv.begin(), wv.end());
if (hv.back() == LINF && wv.back() == LINF) {
cout << -1 << endl;
continue;
}
int index = 0;
ModInt<1000000007> sum = 0;
ModInt<1000000007> res = 0;
for (int y = 0; y < h; y++) {
while (index < wv.size() && wv[index] < hv[y]) {
sum += wv[index];
index++;
}
res += sum + ModInt<1000000007>(w - index) * ModInt<1000000007>(hv[y]);
}
cout << res.val << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char a[15][15], vis[15][15];
int flag;
bool solve(int x, int y, int cnt, int e) {
vis[x][y] = 1;
int cnt1, cnt2, cnt3, cnt4;
cnt1 = cnt2 = cnt3 = cnt4 = 0;
for (int i = x + 1; i < 10 && cnt1 < 4 && a[i][y] == 'X'; i++) cnt1++;
for (int i = x - 1; i >= 0 && cnt1 < 4 && a[i][y] == 'X'; i--) cnt1++;
for (int i = y + 1; i <= 10 && cnt2 < 4 && a[x][i] == 'X'; i++) cnt2++;
for (int i = y - 1; i >= 0 && cnt2 < 4 && a[x][i] == 'X'; i--) cnt2++;
for (int i = x - 1, j = y - 1; x >= 0 && y >= 0 && cnt3 < 4 && a[i][j] == 'X';
i--, j--)
cnt3++;
for (int i = x + 1, j = y + 1; x < 10 && y < 10 && cnt3 < 4 && a[i][j] == 'X';
i++, j++)
cnt3++;
for (int i = x - 1, j = y + 1; x >= 0 && y < 10 && cnt4 < 4 && a[i][j] == 'X';
i--, j++)
cnt4++;
for (int i = x + 1, j = y - 1; x < 10 && y >= 0 && cnt4 < 4 && a[i][j] == 'X';
i++, j--)
cnt4++;
if (cnt1 == 4 || cnt2 == 4 || cnt3 == 4 || cnt4 == 4)
return 1;
else
return 0;
}
int main() {
for (int i = 0; i < 10; i++) scanf("%s", a[i]);
flag = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++)
if (a[i][j] == '.' && !vis[i][j]) {
if (solve(i, j, 0, 0)) flag = 1;
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
priority_queue<int> q;
char s[20];
int n;
while(scanf("%s",s)!=EOF)
{
if(strcmp(s,"insert")==0)
{
scanf("%d",&n);
q.push(n);
}
else if(strcmp(s,"extract")==0)
{
printf("%d\n",q.top());
q.pop();
}
else if(strcmp(s,"end")==0) break;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int M = 20000;
bool ciekawe[4 * M + 7];
const int N = 60;
pair<int, int> ya[N + 7];
pair<int, int> yb[N + 7];
int wynik = 0;
bool znia[N + 7];
bool znib[N + 7];
int pom[4 * M + 7];
int dopchnij() {
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int d = ya[i].first - yb[j].first;
int il = 0;
if (!znia[i]) il += ya[i].second;
if (!znib[j]) il += yb[j].second;
pom[2 * M + d] += il;
res = max(res, pom[2 * M + d]);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int d = ya[i].first - yb[j].first;
pom[2 * M + d] = 0;
}
}
return res;
}
void sprawdz(int d) {
set<int> xs;
int wyn = 0;
for (int i = 0; i < m; ++i) xs.insert(yb[i].first + d);
for (int i = 0; i < n; ++i) {
znia[i] = 0;
if (xs.find(ya[i].first) != xs.end()) {
znia[i] = 1;
wyn += ya[i].second;
}
}
xs.clear();
for (int i = 0; i < n; ++i) xs.insert(ya[i].first - d);
for (int i = 0; i < m; ++i) {
znib[i] = 0;
if (xs.find(yb[i].first) != xs.end()) {
znib[i] = 1;
wyn += yb[i].second;
}
}
wyn += dopchnij();
wynik = max(wynik, wyn);
}
int wczytaj(pair<int, int> (&y)[N + 7], int ile, int d) {
map<int, int> mapa;
for (int i = 1; i <= ile; ++i) {
int x;
cin >> x;
x *= d;
mapa[x]++;
}
int nn = 0;
for (auto u : mapa) {
y[nn++] = u;
}
return nn;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
n = wczytaj(ya, n, -1);
m = wczytaj(yb, m, 1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int d = ya[i].first - yb[j].first;
ciekawe[2 * M + d] = 1;
}
}
for (int d = 0; d <= 4 * M + 5; ++d) {
if (ciekawe[d]) sprawdz(d - 2 * M);
}
cout << wynik << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void debug(int n, ...) {
va_list v1;
va_start(v1, n);
for (int i = 0; i < n; i++) {
long long int val = va_arg(v1, int);
printf("%lld ", val);
}
va_end(v1);
cout << endl;
}
long long int f(long long int n) {
long long int ans = 0;
while (n) {
ans += n % 10;
n /= 10;
}
return ans;
}
long long int bs(long long int n) {
long long int ans = 0;
while (n) {
ans++;
n /= 10;
}
return ans;
}
int main() {
long long int n;
cin >> n;
long long int basa = bs(n);
basa--;
long long int carp = 1;
for (long long int i = 0; i < basa; i++) carp *= 10;
long long int mod = n % carp;
long long int ans = f(mod + 1) + f(n - mod - 1);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1 = "";
cin >> s;
for (int i = 1; i < s.length(); i++) {
s1 = s1 + s[i];
}
stringstream geek(s1);
int x = 0;
geek >> x;
if (x % 2 == 0)
cout << "0\n";
else
cout << "1\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b)) * b;
}
long long int searchll(long long int val, vector<long long int> vec) {
for (long long int i = 0; i < vec.size(); i++) {
if (vec[i] == val) {
return i;
}
}
return -1;
}
bool isPrime(long long int n) {
int broken = 0;
for (long long int i = 2; i < sqrt(n) + 1; i++) {
if (n % i == 0) {
broken = 1;
break;
}
}
if (broken == 1) {
return false;
} else {
return true;
}
}
bool isPerfectSquare(long double x) {
long double sr = sqrt(x);
return ((sr - floor(sr)) == 0);
}
vector<bool> SieveOfEratosthenes(long long int num) {
vector<bool> pno;
pno.assign(num + 1, true);
pno[0] = false;
pno[1] = false;
for (long long int i = 2; i * i <= num; i++) {
if (pno[i] == true) {
for (long long int j = i * 2; j <= num; j += i) pno[j] = false;
}
}
return pno;
}
vector<long long int> SieveOfEratosthenesExtended(long long int num) {
vector<long long int> pno(num + 1);
for (long long int i = 0; i < num + 1; i++) {
pno[i] = i;
}
for (long long int i = 2; i * i <= num; i++) {
if (pno[i] == i) {
for (long long int j = i * 2; j <= num; j += i)
if (pno[j] == j) pno[j] = i;
}
}
return pno;
}
vector<long long int> PrimeFactorize(long long int num) {
vector<long long int> spf;
spf = SieveOfEratosthenesExtended(num);
set<long long int> pf;
while (num != 1) {
pf.insert(spf[num]);
num = num / spf[num];
}
vector<long long int> v;
for (auto it : pf) {
v.push_back(it);
}
return v;
}
long long int calculateNcR(long long int n, long long int r) {
long long int p = 1, k = 1;
if (n - r < r) r = n - r;
if (r != 0) {
while (r) {
p *= n;
k *= r;
long long int m = gcd(p, k);
p /= m;
k /= m;
n--;
r--;
}
} else
p = 1;
return p;
}
long long int stringToInt(string s) {
long long int num = 0;
for (long long int i = 0; i < s.length(); i++) {
num = num * 10 + (s[i] - '0');
}
return num;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int a, b;
cin >> a;
cin >> b;
long long int atime = a, btime = b;
long long int totalATime = 0, totalBTime = 0;
long long int commonTime = lcm(a, b);
long long int time = 0;
while (time < commonTime) {
if (atime < btime) {
totalATime += atime - time;
time = atime;
atime += a;
} else if (btime < atime) {
totalBTime += btime - time;
time = btime;
btime += b;
} else {
if (a < b) {
totalBTime += commonTime - time;
} else {
totalATime += commonTime - time;
}
time = commonTime;
}
}
if (totalATime > totalBTime) {
cout << "Dasha"
<< "\n";
} else if (totalBTime > totalATime) {
cout << "Masha"
<< "\n";
} else {
cout << "Equal"
<< "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int rmqa[18][1 << 18][7], ar[100005][7], lg[100005], br[8], cr[8], n, m, tot;
long long rez;
void genLog() {
for (int i = 2; i <= n; ++i) {
lg[i] = lg[i / 2] + 1;
}
}
void insert(int J) {
for (int i = 1; i <= n; ++i) {
rmqa[0][i][J] = ar[i][J];
}
for (int i = 1; (1 << i) <= n; ++i) {
for (int j = 1; j + (1 << i) - 1 <= n; ++j) {
rmqa[i][j][J] =
max(rmqa[i - 1][j][J], rmqa[i - 1][j + ((1 << (i - 1)))][J]);
}
}
}
int read(int x, int y, int J) {
int maxi = lg[y - x + 1];
int sh = y - x + 1 - (1 << maxi);
return max(rmqa[maxi][x][J], rmqa[maxi][x + sh][J]);
}
int main() {
cin >> n;
cin >> m;
cin >> tot;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> ar[i][j];
genLog();
for (int i = 1; i <= m; i++) {
insert(i);
}
int mx = 0;
for (int i = 1; i <= n; i++) {
int lo = i, hi = n;
while (lo <= hi) {
int r = 0;
int mid = (lo + hi) / 2;
for (int j = 1; j <= m; j++) {
br[j] = read(i, mid, j);
r += br[j];
}
if (r <= tot) {
int aa = mid - i + 1;
if (aa > mx) {
mx = aa;
for (int j = 1; j <= m; j++) cr[j] = br[j];
}
lo = mid + 1;
} else
hi = mid - 1;
}
}
for (int i = 1; i <= m; i++) cout << cr[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vl;
typedef pair<int,int> pint;
#define MOD 1000000007
#define INF 1000000000
#define mp make_pair
#define pb push_back
#define ss second
#define ff first
#define endl '\n'
#define pl cout<<endl;
void fast() { ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL); }
string s[2005];
int firstRow[10][2005],firstColumn[10][2005],lastRow[10][2005],lastColumn[10][2005],maxRow[10],maxColumn[10],minRow[10],minColumn[10];
int main()
{
#ifndef ONLINE_JUDGE
freopen("D:\\Ajay\\Codes\\in.txt", "r", stdin);
freopen("D:\\Ajay\\Codes\\out.txt", "w", stdout);
#endif
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
for(int i=0;i<n;i++)
cin>>s[i];
for(int i=0;i<=9;i++)
{
for(int j=0;j<n;j++)
{
firstRow[i][j]=-1;
lastRow[i][j]=-1;
firstColumn[i][j]=-1;
lastColumn[i][j]=-1;
}
maxRow[i]=-1;
maxColumn[i]=-1;
minRow[i]=-1;
minColumn[i]=-1;
}
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(firstRow[s[i][j]-48][i]==-1)
{
firstRow[s[i][j]-48][i]=j;
}
if(minRow[s[i][j]-48]==-1)
{
minRow[s[i][j]-48]=i;
}
lastRow[s[i][j]-48][i]=j;
maxRow[s[i][j]-48]=i;
}
}
for(int j=0;j<n;j++)
{
for(int i=0;i<n;i++)
{
if(firstColumn[s[i][j]-48][j]==-1)
{
firstColumn[s[i][j]-48][j]=i;
}
if(minColumn[s[i][j]-48]==-1)
{
minColumn[s[i][j]-48]=j;
}
lastColumn[s[i][j]-48][j]=i;
maxColumn[s[i][j]-48]=j;
}
}
vl ans(10,0);
for(int i=0;i<=9;i++)
{
for(int j=0;j<n;j++)
{
if(firstRow[i][j]==-1)
{
continue;
}
ans[i]=max(ans[i],max(n-1-firstRow[i][j],lastRow[i][j])*(maxRow[i]-j));
ans[i]=max(ans[i],max(n-1-firstRow[i][j],lastRow[i][j])*(j-minRow[i]));
if(firstRow[i][j]==lastRow[i][j])
{
continue;
}
ans[i]=max(ans[i],(lastRow[i][j]-firstRow[i][j])*max(j,n-1-j));
}
}
for(int i=0;i<=9;i++)
{
for(int j=0;j<n;j++)
{
if(firstColumn[i][j]==-1)
{
continue;
}
ans[i]=max(ans[i],max(n-1-firstColumn[i][j],lastColumn[i][j])*(maxColumn[i]-j));
ans[i]=max(ans[i],max(n-1-firstColumn[i][j],lastColumn[i][j])*(j-minColumn[i]));
if(firstColumn[i][j]==lastColumn[i][j])
{
continue;
}
ans[i]=max(ans[i],(lastColumn[i][j]-firstColumn[i][j])*max(j,n-1-j));
}
}
for(int i=0;i<=9;i++)
cout<<ans[i]<<" ";
cout<<"\n";
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
bool m[105], h[105];
int n, M, fm, fh, x;
bool dp[105][105];
int main() {
scanf("%d%d%d", &n, &M, &fm);
for (int i = 0; i < fm; ++i) {
scanf("%d", &x);
m[x] = 1;
}
scanf("%d", &fh);
for (int i = 0; i < fh; ++i) {
scanf("%d", &x);
h[x] = 1;
}
if (fm == n && fh == M) {
puts("Yes");
return 0;
}
int d, i, j;
d = i = j = 0;
while (d <= 1000000) {
dp[i][j] = 1;
if (m[i] || h[j]) {
if (!m[i]) fm++;
if (!h[j]) fh++;
m[i] = h[j] = 1;
}
if (fm == n && fh == M) {
puts("Yes");
return 0;
}
d++;
i = d % n;
j = d % M;
}
if (fm == n && fh == M)
puts("Yes");
else
puts("No");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>; using vvi = vector<vi>;
using vb = vector<bool>; using vvb = vector<vb>;
using vl = vector<ll>; using vvl = vector<vl>;
using vd = vector<double>; using vvd = vector<vd>;
#define REP(i,n) for(ll i = 0; i < (n); ++i)
#define ALL(c) (c).begin(), (c).end()
#define FOR(i,s,e) for (ll i = s; i < (ll)e; i++)
#define TEN(x) ((ll)1e##x)
int main() {
#ifdef INPUT_FROM_FILE
ifstream cin("sample.in");
ofstream cout("sample.out");
#endif
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
const double EPS = 1e-10;
while (true) {
ll n; cin >> n;
if (n == 0) break;
vd px(n), py(n), pz(n), vx(n), vy(n), vz(n), r(n), vr(n);
REP(i, n) {
cin >> px[i] >> py[i] >> pz[i] >> vx[i] >> vy[i] >> vz[i] >> r[i] >> vr[i];
}
vector<pair<double, ll>> n_v_time(n);
REP(i, n) n_v_time[i].first = r[i] / vr[i];
REP(i, n) n_v_time[i].second = i;
auto n_v_time_sorted = n_v_time;
sort(ALL(n_v_time_sorted)); reverse(ALL(n_v_time_sorted));
vb vanished(n, false);
vd v_time(n);
while (!n_v_time_sorted.empty()) {
vector<pair<double, pair<ll, ll>>> collision_time;
REP(i, n) if (!vanished[i]) REP(j, n) if (!vanished[j] && i != j) {
double a = pow(vx[i] - vx[j], 2) + pow(vy[i] - vy[j], 2) + pow(vz[i] - vz[j], 2) - pow(vr[i] + vr[j], 2);
double b = 2.0 * ((px[i] - px[j]) * (vx[i] - vx[j]) + (py[i] - py[j]) * (vy[i] - vy[j]) + (pz[i] - pz[j]) * (vz[i] - vz[j]) + (r[i] + r[j]) * (vr[i] + vr[j]));
double c = pow(px[i] - px[j], 2) + pow(py[i] - py[j], 2) + pow(pz[i] - pz[j], 2) - pow(r[i] + r[j], 2);
if (b * b - 4 * a * c < 0) continue;
if (-EPS < a && a < EPS) continue;
double t1 = (-b - sqrt(b * b - 4 * a * c)) / (2 * a);
double t2 = (-b + sqrt(b * b - 4 * a * c)) / (2 * a);
double t = [&] {
if (t1 > 0 && t2 > 0) return t1 < t2 ? t1 : t2;
return t1 < 0 ? t2 : t1;
}();
if (t < EPS) continue;
if (t > n_v_time[i].first || t > n_v_time[j].first) continue;
collision_time.push_back({ t, {i, j} });
}
sort(ALL(collision_time));
auto x = n_v_time_sorted.back();
if (collision_time.empty() || collision_time.front().first > x.first) {
vanished[x.second] = true;
v_time[x.second] = x.first;
n_v_time_sorted.pop_back();
} else {
auto y = collision_time.front();
vanished[y.second.first] = true;
vanished[y.second.second] = true;
v_time[y.second.first] = y.first;
v_time[y.second.second] = y.first;
n_v_time_sorted.erase(remove(ALL(n_v_time_sorted), n_v_time[y.second.first]), n_v_time_sorted.end());
n_v_time_sorted.erase(remove(ALL(n_v_time_sorted), n_v_time[y.second.second]), n_v_time_sorted.end());
}
}
REP(i, n) {
cout << v_time[i] << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct nd {
int id, p, c1, c2;
bool operator<(const nd &y) const { return p > y.p; }
} t[200002];
priority_queue<nd> q[3];
bool v[200002];
int main() {
int n, m, c;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> t[i].p;
}
for (int i = 1; i <= n; i++) {
cin >> t[i].c1;
}
for (int i = 1; i <= n; i++) {
cin >> t[i].c2;
}
for (int i = 1; i <= n; i++) {
t[i].id = i;
if (t[i].c1 != t[i].c2) {
q[t[i].c1 - 1].push(t[i]);
q[t[i].c2 - 1].push(t[i]);
} else {
q[t[i].c1 - 1].push(t[i]);
}
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> c;
bool f = false;
while (!q[c - 1].empty()) {
nd tn = q[c - 1].top();
if (v[tn.id]) {
q[c - 1].pop();
} else {
cout << tn.p << " ";
f = true;
v[tn.id] = true;
q[c - 1].pop();
break;
}
}
if (!f) {
cout << "-1 ";
}
}
return 0;
}
| 2 |
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int in(){//scanf文用
int a;
scanf("%d",&a);
return a;
}
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<pint> vpint;
const int INF=1001001001;
#define pb push_back
#define mp make_pair
struct Taxi{
int C,R;
vint edges,edges2;
bool flag;
int ans;
Taxi()
: flag(false),ans(INF){
}
}taxis[5010];
int main(){
int N,K;
N=in();//町の数
K=in();//道路の本数
for(int i=0;i<N;i++){
taxis[i].C=in();//タクシー会社iの移動値段
taxis[i].R=in();//タクシー会社の通ることが出来る道路の本数
}
for(int i=0;i<K;i++){
int to,from;
//町toと町fromをつなぐ道路
to=in()-1;
from=in()-1;
taxis[to].edges.pb(from);
taxis[from].edges.pb(to);
}
//make a graphdefaults
//タクシー会社をすべて見ていく
for(int i=0;i<N;i++){
queue<int> q;
//指標となるタクシー会社を定義
q.push(i);
//指標としたタクシー会社の通れる道路の本数だけ繰り返す。
for(int k=0;k<taxis[i].R;k++){
queue<int> q2;
//町qから一つ移動することだけでできる町がなくなるまで繰り返す
while(! q.empty()){
int n=q.front();
q.pop();
//町nから1回で移動できる町をすべて繰り返す
for(int j=0;j<taxis[n].edges.size();j++){
int to=taxis[n].edges[j];//toに町nから移動できる街の場所を代入する
//taxis[to].flagがfalseでなければ
if(! taxis[to].flag){
//trueにする
taxis[to].flag=true;
//taxis(to)の町を次の指標にする
q2.push(to);
}
}
}
//次の指標に切り替える
q=q2;
}
//町iから1回で移動できる街の個数すべてつなげる
for(int k=0;k<N;k++){
if(i!=k&&taxis[k].flag){
taxis[i].edges2.pb(k);
}
//次のためにすべてfalseに戻す
taxis[k].flag=false;
}
}
//Dijkstra
//
priority_queue<pint> pq;
pq.push(mp(0,0));
while(pq.size()){
pint a=pq.top();
pq.pop();
int cost=-a.first;
int n=a.second;
if(cost<taxis[n].ans){
taxis[n].ans=cost;
if(n==N-1){
break;
}
for(vint::iterator iter=taxis[n].edges2.begin();iter!=taxis[n].edges2.end();++iter){
if(taxis[*iter].ans==INF){
pq.push(mp(-(cost+taxis[n].C),*iter));
}
}
}
}
cout<<taxis[N-1].ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1e9 + 7;
struct Matrix {
int n, m;
long long a[105][105];
Matrix(int x, int y) {
n = x, m = y;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) a[i][j] = 0;
}
}
void init() {
for (int i = 1; i <= min(n, m); i++) a[i][i] = 1;
}
void print() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << a[i][j] << " ";
cout << endl;
}
cout << endl;
}
};
Matrix operator*(Matrix a, Matrix b) {
Matrix c = Matrix(a.n, b.m);
for (int i = 1; i <= a.n; i++) {
for (int j = 1; j <= b.m; j++) {
for (int k = 1; k <= a.m; k++) {
c.a[i][j] = (c.a[i][j] + a.a[i][k] * b.a[k][j] % p) % p;
}
}
}
return c;
}
Matrix qpow(Matrix a, long long b) {
Matrix res = Matrix(a.n, a.m);
res.init();
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long n, m, k;
int main() {
cin >> n >> m >> k;
Matrix f = Matrix(m, m);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= m; j++) f.a[i][j] = 1;
}
string s;
int x, y, z;
while (k--) {
cin >> s;
if (s[0] <= 'Z' && s[0] >= 'A')
x = s[0] - 'A' + 27;
else
x = s[0] - 'a' + 1;
if (s[1] <= 'Z' && s[1] >= 'A')
y = s[1] - 'A' + 27;
else
y = s[1] - 'a' + 1;
f.a[x][y] &= 0;
}
Matrix ans = Matrix(1, m);
for (int i = 1; i <= m; i++) ans.a[1][i] = 1;
f = qpow(f, n - 1);
ans = ans * f;
long long res = 0;
for (int i = 1; i <= m; i++) res += ans.a[1][i], res %= p;
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n1, n2, k1, k2;
int main() {
cin >> n1 >> n2 >> k1 >> k2;
if (n2 >= n1)
cout << "Second";
else
cout << "First";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 1e15 + 5;
const long long Nlog = 17;
const long long Hash = 161;
const double PI = 2.0 * acos(0.0);
const double E = 2.718281828;
void solve() {
string s;
cin >> s;
cout << int(s[6] - '0' & 1) << '\n';
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int s,a;
while(cin >> s){
if(s==0)break;
for(int i=0;i<9;i++){
cin >> a;
s -= a;
}
cout << s << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, MOD = 1009, lgN = 19;
const double pi = acos(-1), eps = 0.5;
struct Com {
double x, y;
inline Com(double _x = 0, double _y = 0) {
x = _x;
y = _y;
}
inline Com operator+(const Com &t) const { return Com(x + t.x, y + t.y); }
inline Com operator-(const Com &t) const { return Com(x - t.x, y - t.y); }
inline Com operator*(const double &t) const { return Com(x * t, y * t); }
inline Com operator/(const double &t) const { return Com(x / t, y / t); }
inline Com operator*(const Com &t) const {
return Com(x * t.x - y * t.y, x * t.y + y * t.x);
}
inline Com &operator*=(const Com &t) { return *this = *this * t; }
inline Com &operator/=(const double &t) { return *this = *this / t; }
inline void out() const { printf("(%.2f,%.2f)", x, y); }
};
int rev[1 << lgN];
inline void dft(Com *f, int opt, int l) {
for (int i = 0; i < l; i++) {
rev[i] = rev[i >> 1] >> 1 | (i & 1) * l >> 1;
if (i < rev[i]) swap(f[i], f[rev[i]]);
}
for (int i = 1; i < l; i <<= 1) {
Com wn = Com(cos(pi / i), (opt ? -1 : 1) * sin(pi / i));
for (int j = 0; j < l; j += i << 1) {
Com w = Com(1, 0);
for (int k = 0; k < i; k++, w *= wn) {
Com x = f[j + k], y = f[i + j + k] * w;
f[j + k] = x + y;
f[i + j + k] = x - y;
}
}
}
if (opt)
for (int i = 0; i < l; i++) f[i] /= l;
}
inline void out(const vector<Com> &a) {
for (int i = 0, n = a.size(); i < n; i++) a[i].out();
puts("");
}
inline vector<Com> operator*(vector<Com> a, vector<Com> b) {
int l = 1, n = a.size(), m = b.size();
while (l < n + m) l <<= 1;
a.resize(l);
b.resize(l);
dft(&a[0], 0, l);
dft(&b[0], 0, l);
for (int i = 0; i < l; i++) a[i] *= b[i];
dft(&a[0], 1, l);
a.resize(n + m - 1);
return a;
}
int n, m, k, cnt[N];
vector<Com> a[N];
struct cmp {
inline bool operator()(const int &x, const int &y) {
return a[x].size() > a[y].size();
}
};
priority_queue<int, vector<int>, cmp> q;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
cnt[x]++;
}
for (int i = 1; i <= m; i++)
if (cnt[i]) {
a[i].resize(cnt[i] + 1);
for (int j = 0; j <= cnt[i]; j++) a[i][j] = 1;
q.push(i);
}
while (q.size() > 1) {
int x = q.top();
q.pop();
int y = q.top();
q.pop();
a[x] = a[x] * a[y];
if (a[x].size() > k + 1) a[x].resize(k + 1);
for (int i = 0, n = a[x].size(); i < n; i++)
a[x][i].x = (long long)(a[x][i].x + eps) % MOD, a[x][i].y = 0;
a[y].clear();
q.push(x);
}
printf("%d\n", (int)a[q.top()][k].x);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
const int INF = 1000 * 1000 * 1000;
int p[maxn];
map<string, int> c;
vector<int> num;
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> p[i];
sort(p, p + n);
string inp;
for (int i = 0; i < m; i++) {
cin >> inp;
c[inp]++;
}
int mins = 0, maxs = 0;
map<string, int>::iterator it;
for (it = c.begin(); it != c.end(); it++) num.push_back(it->second);
sort(num.begin(), num.end());
reverse(num.begin(), num.end());
for (int i = 0; i < num.size(); i++) mins += num[i] * p[i];
reverse(p, p + n);
for (int i = 0; i < num.size(); i++) maxs += num[i] * p[i];
cout << mins << " " << maxs << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][300005], x[300005], y[300005];
int n, k;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> x[i];
for (int i = 1; i <= n; i++) cin >> y[i];
for (int i = 1; i <= n; i++) {
if (!(~dp[0][i - 1])) {
dp[0][i] = -1;
dp[1][i] = -1;
continue;
}
if (x[i] > y[i]) {
long long h = (long long)k * ((long long)y[i] + 1LL);
if (x[i] + dp[0][i - 1] > h) {
dp[0][i] = -1;
dp[1][i] = -1;
continue;
}
dp[1][i] = 0;
h = (long long)k * (long long)y[i];
if (x[i] + dp[0][i - 1] <= h) {
dp[0][i] = 0;
continue;
} else
dp[0][i] = x[i] + dp[0][i - 1] - k * y[i];
}
if (y[i] > x[i]) {
long long h = (long long)k * ((long long)x[i] + 1LL);
if (y[i] + dp[1][i - 1] > h) {
dp[0][i] = -1;
dp[1][i] = -1;
continue;
}
dp[0][i] = 0;
h = (long long)k * (long long)x[i];
if (y[i] + dp[1][i - 1] <= h) {
dp[1][i] = 0;
continue;
} else
dp[1][i] = y[i] + dp[1][i - 1] - k * x[i];
}
if (x[i] == y[i]) {
if (x[i] == 1) {
if (max(dp[0][i - 1], dp[1][i - 1]) == k) {
dp[(dp[0][i - 1] > dp[1][i - 1] ? 1 : 0)][i] = 0;
dp[(dp[0][i - 1] > dp[1][i - 1] ? 0 : 1)][i] = 1;
} else
continue;
} else {
if (k == 1 && max(dp[0][i - 1], dp[1][i - 1]) == k) {
dp[(dp[0][i - 1] > dp[1][i - 1] ? 1 : 0)][i] = 0;
dp[(dp[0][i - 1] > dp[1][i - 1] ? 0 : 1)][i] = 1;
} else
continue;
}
}
}
if (~dp[0][n])
cout << "YES";
else
cout << "NO";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
static const int M = 300200;
static const long long P = 1e16 + 3;
static const long long C = 203;
int main() {
ios_base::sync_with_stdio(0);
int n, m, l, r, curr;
long long hsh, chsh;
bool success;
string b;
vector<long long> hasharr;
vector<long long> pow;
vector<string> ans;
ans.clear();
pow.clear();
cin >> n >> m;
hasharr.resize(n);
pow.push_back(1);
for (int i = 0; i < 2 * M; i++) {
pow.push_back(pow[i] * C % P);
}
for (int i = 0; i < n; i++) {
cin >> b;
hsh = 0;
for (int j = 0; j < b.size(); j++) {
hsh += pow[j] * (int)b[j];
hsh %= P;
}
hasharr[i] = hsh;
}
sort(hasharr.begin(), hasharr.begin() + n);
for (int i = 0; i < m; i++) {
cin >> b;
hsh = 0;
for (int j = 0; j < b.size(); j++) {
hsh += pow[j] * (int)b[j];
hsh %= P;
}
success = false;
for (int j = 0; j < b.size(); j++) {
char ch = b[j];
for (char k = 'a'; k != 'd'; k++) {
if (k == ch) continue;
chsh = hsh + pow[j] * (int)(k - ch);
chsh = (chsh % P + P) % P;
l = 0;
r = n - 1;
while (r - l > 1) {
curr = (l + r) >> 1;
if (hasharr[curr] > chsh) {
r = curr;
} else if (hasharr[curr] < chsh) {
l = curr;
} else {
success = true;
break;
}
}
if (success) break;
if (hasharr[l] == chsh) {
success = true;
break;
}
if (hasharr[r] == chsh) {
success = true;
break;
}
}
if (success) break;
}
if (success)
ans.push_back("YES");
else
ans.push_back("NO");
}
for (int i = 0; i < m; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 3 |
#include<stdio.h>
int main(){
int n,m,a;
while(1){
scanf("%d%d%d",&n,&m,&a);if(n==0&&m==0&&a==0)break;
int N[1003][102]={};
for(int i=0;i<m;i++){
int h,p,q;
scanf("%d%d%d",&h,&p,&q);
N[h][p]=1;
N[h][q]=2;
}
for(int i=1000;i>=0;i--)
{if(N[i][a]==1)a++;
else if(N[i][a]==2)a--;
}
printf("%d\n",a);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
long long a[N];
signed main() {
int T;
cin >> T;
while (T--) {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
long long ans = -4e18;
for (int i = 1; i <= n; ++i) {
for (int j = i - 1; j >= max(i - 200, 1); --j) {
ans = max(ans, (long long)i * j - (long long)k * (a[i] | a[j]));
}
}
printf("%lld\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int64_t gcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
int64_t x1, y1;
int64_t d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
bool find_any_solution(int64_t a, int64_t b, int64_t c, int64_t& x0,
int64_t& y0, int64_t& g) {
g = gcd(abs(a), abs(b), x0, y0);
if (c % g != 0) return false;
x0 *= c / g;
y0 *= c / g;
if (a < 0) x0 *= -1;
if (b < 0) y0 *= -1;
return true;
}
void shift_solution(int64_t& x, int64_t& y, int64_t a, int64_t b, int64_t cnt) {
x += cnt * b;
y -= cnt * a;
}
int64_t find_all_solutions(int64_t a, int64_t b, int64_t c, int64_t minx,
int64_t maxx, int64_t miny, int64_t maxy) {
int64_t x, y, g;
if (!find_any_solution(a, b, c, x, y, g)) return 0;
a /= g;
b /= g;
int64_t sign_a = a > 0 ? +1 : -1;
int64_t sign_b = b > 0 ? +1 : -1;
shift_solution(x, y, a, b, (minx - x) / b);
if (x < minx) shift_solution(x, y, a, b, sign_b);
if (x > maxx) return 0;
int64_t lx1 = x;
shift_solution(x, y, a, b, (maxx - x) / b);
if (x > maxx) shift_solution(x, y, a, b, -sign_b);
int64_t rx1 = x;
shift_solution(x, y, a, b, -(miny - y) / a);
if (y < miny) shift_solution(x, y, a, b, -sign_a);
if (y > maxy) return 0;
int64_t lx2 = x;
shift_solution(x, y, a, b, -(maxy - y) / a);
if (y > maxy) shift_solution(x, y, a, b, sign_a);
int64_t rx2 = x;
if (lx2 > rx2) swap(lx2, rx2);
int64_t lx = max(lx1, lx2);
int64_t rx = min(rx1, rx2);
return (rx - lx) / abs(b) + 1;
}
int main(int, char**) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cerr.tie(NULL);
int64_t m;
cin >> m;
int64_t h1, a1;
cin >> h1 >> a1;
int64_t x1, y1;
cin >> x1 >> y1;
int64_t h2, a2;
cin >> h2 >> a2;
int64_t x2, y2;
cin >> x2 >> y2;
int64_t c1, c2;
int64_t steps;
int64_t* d1 = new int64_t[m * 2];
memset(d1, 0, m * 2 * sizeof(int64_t));
steps = 0;
while (true) {
steps += 1;
h1 = (x1 * h1 + y1) % m;
int64_t level = 0;
level += d1[h1 + level * m] > 0;
level += d1[h1 + level * m] > 0;
if (level == 2) break;
d1[h1 + m * level] = steps;
}
int64_t* d2 = new int64_t[m * 2];
memset(d2, 0, m * 2 * sizeof(int64_t));
steps = 0;
while (true) {
steps += 1;
h2 = (x2 * h2 + y2) % m;
int64_t level = 0;
level += d2[h2 + level * m] > 0;
level += d2[h2 + level * m] > 0;
if (level == 2) break;
d2[h2 + level * m] = steps;
}
cerr << "a1=" << a1 << ", "
<< "a2=" << a2 << ", "
<< "d1[a1]=" << d1[a1] << ", "
<< "d1[a1+m]=" << d1[a1 + m] << ", "
<< "d2[a2]=" << d2[a2] << ", "
<< "d2[a2+m]=" << d2[a2 + m] << ", " << endl;
if (d1[a1] == 0 || d2[a2] == 0) {
cout << -1 << endl;
return 0;
}
if (d1[a1 + m] == 0 && d2[a2 + m] == 0 && d1[a1] != d2[a2]) {
cout << -1 << endl;
return 0;
}
if (d1[a1] == d2[a2]) {
cout << d1[a1] << endl;
return 0;
}
if (d1[a1] == d2[a2 + m]) {
cout << d1[a1] << endl;
return 0;
}
if (d1[a1 + m] == d2[a2]) {
cout << d1[a1 + m] << endl;
return 0;
}
if (d1[a1 + m] == d2[a2 + m]) {
cout << d1[a1 + m] << endl;
return 0;
}
if (d1[a1 + m] != 0 && d2[a2 + m] != 0) {
int64_t c1 = d1[a1 + m] - d1[a1];
int64_t c2 = d2[a2 + m] - d2[a2];
cerr << "c1=" << c1 << ", "
<< "c2=" << c2 << ", " << endl;
int64_t q1, q2, g;
if (find_any_solution(c1, -c2, d2[a2] - d1[a1], q1, q2, g)) {
set<int64_t> best;
double k1 = q1 * g / double(c2);
double k2 = q2 * g / double(c1);
int64_t kk = min(k1, k2);
for (int64_t k = kk - 10; k < kk + 10; ++k) {
int64_t w1 = (q1 + k * (-c2) / g);
int64_t w2 = (q2 - k * (c1) / g);
int64_t p1 = c1 * w1 + d1[a1];
int64_t p2 = c2 * w2 + d2[a2];
cerr << "k1=" << k1 << ", "
<< "k2=" << k2 << ", "
<< "k=" << k << ", "
<< "g=" << g << ", "
<< "q1=" << q1 << ", "
<< "q2=" << q2 << ", "
<< "w1=" << w1 << ", "
<< "w2=" << w2 << ", "
<< "p1=" << p1 << ", "
<< "p2=" << p2 << ", " << endl;
if (p1 >= d1[a1] && p1 >= d2[a2]) best.insert(p1);
}
cout << *best.begin() << endl;
} else
cout << -1 << endl;
} else {
if (d1[a1 + m] > 0) {
int64_t c1 = d1[a1 + m] - d1[a1];
if (d2[a2] > d1[a1] && (d2[a2] - d1[a1] % c1 == 0)) {
cout << d2[a2] << endl;
} else {
cout << -1 << endl;
}
} else if (d2[a2 + m] > 0) {
int64_t c2 = d2[a2 + m] - d2[a2];
if (d1[a1] > d2[a2] && (d1[a1] - d2[a2] % c2 == 0)) {
cout << d1[a1] << endl;
} else {
cout << -1 << endl;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100009], b[100009];
bool cmp(int a, int b) { return a > b; }
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, r, maxx = 0, ans = 0;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
if (a[i] == a[i - 1]) continue;
if (a[i] <= r * ans) break;
ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
const double eps = 1e-9;
const long long INF = 1e18;
long long n, P;
long long fac[N];
signed main() {
cin >> n >> P;
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % P;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long tmp = fac[i] * (n - i + 1) % P * fac[n - i + 1] % P;
ans = (ans + tmp) % P;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int tree[100005], h[100005], n, i, cnt;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d %d", &tree[i], &h[i]);
}
if (n >= 3) {
cnt = 2;
for (i = 1; i < n - 1; i++) {
if (tree[i] > tree[i - 1] + h[i]) {
cnt++;
} else if (tree[i + 1] > tree[i] + h[i]) {
cnt++;
tree[i] = tree[i] + h[i];
}
}
printf("%d", cnt);
} else {
printf("%d", n);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n + 1];
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
int ans = 0, mx;
for (int i = 1; i <= n; i++) {
mx = A[i];
while (i <= n && mx > i) {
i++;
mx = max(mx, A[i]);
}
ans++;
}
cout << ans;
}
| 1 |
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
#define INF 2000000000
#define LLINF 4000000000000000000
#define SIZE 100
void calc(int n){
int m,x,y,p,q,r,vec_x=0,vec_x1=0,vec_y=0,vec_y1=0;
vector<pair<int,int> > cards;
scanf("%d%d%d%d",&m,&p,&q,&r);
cards.push_back(make_pair(1,n));
for(int i=0;i<m;i++){
vector<pair<int,int> > cards2;
vector<int> count;
scanf("%d%d",&x,&y);
count.push_back(1);
for(int j=0;j<cards.size();j++){
count.push_back(count[j] + cards[j].second-cards[j].first+1);
if(count[j] <= x && x < count[j+1]){
vec_x = j;
}
if(count[j] <= x+1 && x+1 < count[j+1]){
vec_x1 = j;
}
if(count[j] <= y && y < count[j+1]){
vec_y = j;
}
if(count[j] <= y+1 && y+1 < count[j+1]){
vec_y1 = j;
}
}
/*y+1 - n*/
cards2.push_back(make_pair(cards[vec_y1].first+(y+1-count[vec_y1]),
cards[vec_y1].second));
for(int j=vec_y1+1;j<cards.size();j++){
cards2.push_back(cards[j]);
}
/*x+1 - y*/
if(vec_x1 != vec_y){
cards2.push_back(make_pair(cards[vec_x1].first+(x+1-count[vec_x1]),cards[vec_x1].second));
for(int j=vec_x1+1;j<vec_y;j++){
cards2.push_back(cards[j]);
}
cards2.push_back(make_pair(cards[vec_y].first,cards[vec_y].first+(y-count[vec_y])));
}else{
cards2.push_back(make_pair(cards[vec_x1].first+(x+1-count[vec_x1]),
cards[vec_y].first+(y-count[vec_y])));
}
/*1 - x*/
for(int j=0;j<vec_x;j++){
cards2.push_back(cards[j]);
}
cards2.push_back(make_pair(cards[vec_x].first,cards[vec_x].first+(x-count[vec_x])));
cards = cards2;
}
/*ans [count_a,count_b)*/
int count_a=1,count_b=1,ans=0;
for(int j=0;j<cards.size();j++){
count_a=count_b;
count_b+=cards[j].second-cards[j].first+1;
if(q < count_a && count_b <= p) continue;
int a,b;
//[a,b]
a = max(0,p-count_a);
b = min(count_b-count_a-1,q-count_a);
if(b < a) continue;
/* cards[j].first+a ~ cards[j].first+b */
if(r < cards[j].first+a) continue;
ans += min(r-cards[j].first,b)-a+1;
}
printf("%d\n",ans);
return;
}
int main(){
int n;
while(1){
scanf("%d",&n);
if(n==0) break;
calc(n);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
#pragma GCC optimize("unroll-loops")
using namespace std;
signed main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> z(n + 2, 0);
vector<int> v(n, 0);
for (int i = 0; i < n; i++) {
cin >> v[i];
z[v[i]]++;
}
int count = 0;
for (int i = 1; i < z.size() - 1; i++) {
count += z[i] / i;
z[i + 1] += z[i] % i;
}
cout << count << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimze("Ofast")
using namespace std;
const long long infl = 0x3f3f3f3f3f3f3f3fLL;
const long long infi = 0x3f3f3f3f;
const long long mod = 998244353;
long long powm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
const long long N = 2e3 + 1;
long long n, k;
long long dp[N][N] = {0};
string key[] = {"1110111", "0010010", "1011101", "1011011", "0111010",
"1101011", "1101111", "1010010", "1111111", "1111011"};
void f(string str, vector<long long> &a) {
for (long long i = 9; i >= 0; i--) {
string str1 = key[i];
long long cnt = 0;
for (long long j = 0; j <= 6; j++) {
if (str1[j] == '0' && str[j] == '1') break;
if (str1[j] == '1' && str[j] == '0') cnt++;
if (j == 6) {
a.push_back(cnt);
}
}
}
}
void solve() {
cin >> n >> k;
vector<string> arr(n);
for (long long i = 0; i <= n - 1; i++) cin >> arr[i];
dp[n][0] = 1;
for (long long i = n - 1; i >= 0; i--) {
vector<long long> a;
f(arr[i], a);
for (long long j = 0; j <= k; j++) {
for (long long l : a) dp[i][j + l] |= dp[i + 1][j];
}
}
string ans = "";
for (long long l = 0; l <= n - 1; l++) {
string str = arr[l];
for (long long i = 9; i >= 0; i--) {
string str1 = key[i];
long long cnt = 0;
for (long long j = 0; j <= 6; j++) {
if (str1[j] == '0' && str[j] == '1') break;
if (str1[j] == '1' && str[j] == '0') cnt++;
if (j == 6 && dp[l + 1][k - cnt]) {
ans = ans + to_string(i);
k -= cnt;
goto loop;
}
}
}
loop:
if (ans.length() != l + 1) {
cout << -1;
return;
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(12);
long long t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <iostream>
#include <string>
using namespace std;
int main(){
int n,r;
while(cin>>n>>r){
if(n==0 && r==0) break;
string str(n,0);
for(int i=0;i<str.length();i++){
str[i]=n-i;
}
for(int j=0;j<r;j++){
int p,c;
cin>>p>>c;
str=str.substr(p-1,c)+str.substr(0,p-1)+str.substr(p+c-1);
}
cout<<(int)str[0]<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MX_SZ = 105;
struct request {
int type;
int r;
int x, y, val;
request(int type0, int r0) {
type = type0;
r = r0;
}
request(int type0, int x0, int y0, int val0) {
type = type0;
x = x0;
y = y0;
val = val0;
}
};
int main() {
ios_base::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
int a[MX_SZ][MX_SZ];
memset(a, 0, sizeof(a));
vector<request> v;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type != 3) {
int r;
cin >> r;
v.push_back(request(type, r));
} else {
int x, y, val;
cin >> x >> y >> val;
v.push_back(request(type, x, y, val));
}
}
reverse(v.begin(), v.end());
int tmp[MX_SZ];
for (int i = 0; i < q; i++) {
if (v[i].type == 1) {
for (int j = 1; j <= m; j++) {
if (j == m) {
tmp[1] = a[v[i].r][j];
} else {
tmp[j + 1] = a[v[i].r][j];
}
}
for (int j = 1; j <= m; j++) {
a[v[i].r][j] = tmp[j];
}
}
if (v[i].type == 2) {
for (int j = 1; j <= n; j++) {
if (j == n) {
tmp[1] = a[j][v[i].r];
} else {
tmp[j + 1] = a[j][v[i].r];
}
}
for (int j = 1; j <= n; j++) {
a[j][v[i].r] = tmp[j];
}
}
if (v[i].type == 3) {
a[v[i].x][v[i].y] = v[i].val;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << a[i][j] << " ";
}
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int p[100004];
int l[100004] = {0};
int r[100004] = {0};
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
for (int i = 1; i <= n; i++) {
l[i] = l[i - 1] + p[i];
}
for (int i = n; i >= 1; i--) {
r[i] = r[i + 1] + p[i];
}
int ind = -1;
int mn = 100000000;
for (int i = 1; i <= n; i++) {
int a, b;
a = min(l[i], r[i + 1]);
b = max(l[i], r[i + 1]);
if (mn >= b - a) {
mn = b - a;
ind = i;
}
}
cout << ind << " " << n - ind << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double x, y;
};
struct square {
node f[5];
} A, B;
inline bool cal(const node &a, const square &b) {
double u = -999999999, r = -999999999, d = 999999999, l = 999999999;
for (int i = 1; i <= 4; i++) {
d = min(d, b.f[i].y);
u = max(u, b.f[i].y);
l = min(l, b.f[i].x);
r = max(r, b.f[i].x);
}
if (l <= a.x && r >= a.x && d <= a.y && u >= a.y) return 1;
return 0;
}
int main() {
for (int i = 1; i <= 4; i++) scanf("%lf%lf", &A.f[i].x, &A.f[i].y);
for (int i = 1; i <= 4; i++) scanf("%lf%lf", &B.f[i].x, &B.f[i].y);
bool yes = 0;
double u = -999999999, r = -999999999, d = 999999999, l = 999999999;
for (int i = 1; i <= 4; i++) {
d = min(d, B.f[i].y);
u = max(u, B.f[i].y);
l = min(l, B.f[i].x);
r = max(r, B.f[i].x);
}
yes = cal((node){(l + r) * 0.5, (u + d) * 0.5}, A);
for (int i = 1; i <= 4; i++)
if (cal(B.f[i], A)) yes = 1;
for (int i = 1; i <= 4; i++) {
int x = A.f[i].x, y = A.f[i].y;
A.f[i].x = x + y;
A.f[i].y = x - y;
}
for (int i = 1; i <= 4; i++) {
int x = B.f[i].x, y = B.f[i].y;
B.f[i].x = x + y;
B.f[i].y = x - y;
}
for (int i = 1; i <= 4; i++)
if (cal(A.f[i], B)) yes = 1;
if (yes == 1)
printf("yes\n");
else
printf("no\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int vis[1 << 18];
int main() {
int n, x;
cin >> n >> x;
int max_n = (1 << n);
std::vector<int> a;
;
a.push_back(0);
vis[0] = 1;
for (int i = 1; i < max_n; ++i) {
if (!vis[i ^ x]) {
vis[i] = 1;
a.push_back(i);
}
}
int cnt = a.size();
cout << cnt - 1 << endl;
for (int i = 1; i <= cnt - 1; ++i) cout << (a[i] ^ a[i - 1]) << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
int main() {
int n, k;
cin >> n >> k;
string str;
cin >> str;
for (int i = 0; i < str.size() - 1; i++) {
if (!k) break;
if (str[i] == '4' && str[i + 1] == '7') {
k--;
if (i && (i % 2 == 1) && str[i - 1] == '4') {
if (k % 2 == 0) str[i] = '7';
k = 0;
} else if (i % 2 == 1)
str[i] = '7';
else
str[i + 1] = '4';
}
}
cout << str << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:250000000")
template <typename T>
int size(T& a) {
return (int)a.size();
}
template <typename T>
T sqr(T a) {
return a * a;
}
struct mvec {
int a[16];
mvec(long long x, int k) {
memset((a), (0), sizeof(a));
for (int i = (2); i < k + 1; ++i) a[i] = x % i;
}
mvec() {}
bool operator==(const mvec& o) const {
for (int i = (0); i < 16; ++i)
if (a[i] != o.a[i]) return false;
return true;
}
bool operator<(const mvec& o) const {
for (int i = (0); i < 16; ++i)
if (a[i] != o.a[i]) return a[i] < o.a[i];
return false;
}
int gethash() const {
int r = 0;
for (int i = (0); i < 16; ++i) {
r = r * 31 + a[i];
}
return r;
}
};
const int MAXC = 131072;
void add(long long x, long long from, map<long long, int>& dist,
queue<long long>& q) {
if (dist.count(x) == 0) {
dist[x] = dist[from] + 1;
q.push(x);
}
}
int bfs(long long a, long long b, int k) {
map<long long, int> dist;
map<long long, int> what;
queue<long long> q;
q.push(a);
dist[a] = 0;
while (size(q)) {
long long p = q.front();
q.pop();
if (p == b) {
return dist[p];
}
for (int i = (k + 1) - 1; i >= 2; --i) {
int c = p % i;
if (c > 0 && p - c >= b) {
add(p - c, p, dist, q);
}
}
add(p - 1, p, dist, q);
}
assert(false);
}
long long greedy(long long a, long long b, int k) {
if (a - b <= 100000) return bfs(a, b, k);
map<mvec, int> lastTime;
map<mvec, long long> sumSubs;
mvec rems = mvec(a, k);
long long ta = a;
long long cur = 0;
for (int iter = 0;; ++iter) {
if (a <= 0) {
return bfs(ta, b, k);
}
lastTime[rems] = iter;
sumSubs[rems] = cur;
int mx = -1;
for (int i = (2); i < k + 1; ++i) {
int c = a % i;
if (mx < c) {
mx = c;
}
}
if (mx <= 0) mx = 1;
cur += mx;
a -= mx;
rems = mvec(a, k);
if (lastTime.count(rems)) {
a = ta;
int cycle = (iter + 1) - lastTime[rems];
long long sumCycle = cur - sumSubs[rems];
long long numCycles = (a - b) / sumCycle;
if (numCycles < 0) numCycles = 0;
long long res = numCycles * cycle;
a -= numCycles * sumCycle;
return res + bfs(a, b, k);
}
}
assert(false);
}
int main() {
ios_base::sync_with_stdio(false);
long long a, b;
int k;
cin >> a >> b >> k;
cout << greedy(a, b, k) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long const N = 1e5 + 10, pi = acos(-1);
int n, m, k, x, i, j, mn, a[N], b[N];
string s[N], ss;
map<string, int> mp;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= k; i++) {
cin >> x;
mn = 1e9;
for (int j = 1; j <= x; j++) {
cin >> b[j];
mn = min(a[b[j]], mn);
}
for (int j = 1; j <= x; j++) {
mp[s[b[j]]] = mn;
}
}
long long ans = 0;
for (int i = 1; i <= m; i++) {
cin >> ss;
ans += mp[ss];
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int const N = 3e5 + 2, oo = 1e9;
long long const OO = 2e18;
double const eps = 1e-8, PI = acos(-1);
int mod = oo + 7;
string aa[1001];
int lar[2][1001], eq[2][1001], er[2][1001], val[2][1001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int now = 1;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> aa[i];
for (int j = 0; j < m; j++) {
lar[0][i] += aa[i][j] == '<';
eq[0][i] += aa[i][j] == '=';
lar[1][j] += aa[i][j] == '>';
eq[1][j] += aa[i][j] == '=';
}
}
int rn = n, rm = m;
while (rn || rm) {
vector<pair<int, int> > ssm[2];
int cnt = 0;
for (int i = 0; i < n; i++)
if (!er[0][i] && lar[0][i] + eq[0][i] == rm)
ssm[0].push_back({lar[0][i], i});
for (int i = 0; i < m; i++)
if (!er[1][i] && lar[1][i] + eq[1][i] == rn)
ssm[1].push_back({lar[1][i], i});
sort(ssm[0].begin(), ssm[0].end(), greater<pair<int, int> >());
sort(ssm[1].begin(), ssm[1].end(), greater<pair<int, int> >());
for (int i = 0; i < ssm[0].size(); i++) {
if (i && ssm[0][i].first != ssm[0][i - 1].first) break;
int v = ssm[0][i].second;
er[0][v] = 1;
val[0][v] = now;
cnt++;
rn--;
}
for (int i = 0; i < ssm[1].size(); i++) {
if (i && ssm[1][i].first != ssm[1][i - 1].first) break;
int v = ssm[1][i].second;
er[1][v] = 1;
val[1][v] = now;
cnt++;
rm--;
}
now++;
if (!cnt) break;
}
if (rn || rm) {
cout << "No\n";
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (aa[i][j] == '>') {
if (val[0][i] > val[1][j]) continue;
cout << "No\n";
return 0;
} else if (aa[i][j] == '<') {
if (val[0][i] < val[1][j]) continue;
cout << "No\n";
return 0;
} else {
if (val[0][i] == val[1][j]) continue;
cout << "No\n";
return 0;
}
assert(val[1][j] > 0);
}
assert(val[0][i] > 0);
}
cout << "Yes\n";
for (int i = 0; i < n; i++) cout << val[0][i] << ' ';
cout << '\n';
for (int i = 0; i < m; i++) cout << val[1][i] << ' ';
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long f(int a) { return a * a; }
int side[6];
int main() {
for (int i = 0; i < 6; i++) cin >> side[i];
int bt = side[0] + side[1] + side[2];
cout << f(bt) - f(side[0]) - f(side[2]) - f(side[4]) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char g[1005][1005];
char col[1005][1005];
template <typename T>
struct SegmentTree {};
void input() {
cin >> n >> m;
string s;
for (int i = 1; i <= n; i++) {
cin >> s;
for (int j = 1; j <= m; j++) {
g[i][j] = s[j - 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
col[i][j] = '.';
}
}
for (int i = 2; i < n; i++) {
for (int j = 2; j < m; j++) {
if (g[i - 1][j - 1] == '#' && g[i - 1][j + 1] == '#' &&
g[i + 1][j - 1] == '#' && g[i + 1][j + 1] == '#' &&
g[i - 1][j] == '#' && g[i][j - 1] == '#' && g[i + 1][j] == '#' &&
g[i][j + 1] == '#') {
col[i - 1][j - 1] = '#';
col[i - 1][j + 1] = '#';
col[i + 1][j - 1] = '#';
col[i + 1][j + 1] = '#';
col[i - 1][j] = '#';
col[i][j - 1] = '#';
col[i + 1][j] = '#';
col[i][j + 1] = '#';
}
}
}
bool check = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
check &= col[i][j] == g[i][j];
}
}
if (check)
cout << "YES";
else
cout << "NO";
}
void solve() {}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
input();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int n;
struct vec {
long long x, y, idx;
} a, b;
long double pos_ang_with_x_axis(vec a) {
long double res = atan2(a.y, a.x) * 180 / acos(-1);
if (res < 0) res += 360;
return res;
}
int dot(vec a, vec b) { return a.x * b.x + a.y * b.y; }
long double norm(vec a) { return (long double)sqrt(a.x * a.x + a.y * a.y); }
long double angle(vec a, vec b) {
long double ang1 = pos_ang_with_x_axis(a);
long double ang2 = pos_ang_with_x_axis(b);
return fabs(ang1 - ang2);
}
vector<vec> v;
bool cmp(vec a, vec b) {
vec c;
c.x = c.y = 0;
long double ang1 = pos_ang_with_x_axis(a);
long double ang2 = pos_ang_with_x_axis(b);
return ang1 < ang2;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a.x >> a.y;
a.idx = i + 1;
v.push_back(a);
}
sort(v.begin(), v.end(), cmp);
int idx1, idx2;
long double mn = 1e18;
v.push_back(v[0]);
for (int i = 1; i <= n; i++) {
long double d = angle(v[i], v[i - 1]);
d = min(d, (long double)360 - d);
if (d < mn) mn = d, idx1 = v[i - 1].idx, idx2 = v[i].idx;
}
cout << idx1 << " " << idx2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m, k;
cin >> n >> m >> k;
vector<ll> vec(m);
for (ll &v : vec) cin >> v;
ll ans = 0, i = 0;
while (i < m) {
ll t = (vec[i] - i - 1) / k, j = i + 1;
while (j < m && (vec[j] - i - 1) / k == t) j++;
ans++, i = j;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(int)(a); (i)<(int)(b); ++(i))
#define rFor(i, a, b) for(int (i)=(int)(a)-1; (i)>=(int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
template<class T> bool chmax(T &a, const T &b){if(a<b){a=b; return true;} return false;}
template<class T> bool chmin(T &a, const T &b){if(a>b){a=b; return true;} return false;}
template<class T> T div_floor(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>=0 ? a/b : (a+1)/b-1;
}
template<class T> T div_ceil(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>0 ? (a-1)/b+1 : a/b;
}
constexpr lint mod = 1e9+7;
constexpr lint INF = mod * mod;
constexpr int MAX = 100010;
int t;
string num;
void solve(){
int n = num.size()-1, ans = -1, cnt = 0;
vector<int> part;
rep(S, 1<<n){
vector<int> idx = {0};
rep(i, n)if(S>>i & 1) idx.push_back(i+1);
idx.push_back(n+1);
bool flag = true;
int sum = 0;
rep(i, idx.size()-1){
string tmp = num.substr(idx[i], idx[i+1]-idx[i]);
sum += stoi(tmp);
}
if(!flag || sum > t) continue;
if(ans == sum) ++cnt;
else if(chmax(ans, sum)){
part = idx;
cnt = 1;
}
}
if(cnt == 0) puts("error");
else if(cnt > 1) puts("rejected");
else{
printf("%d ", ans);
rep(i, part.size()-1){
cout << num.substr(part[i], part[i+1]-part[i]);
printf(i == part.size()-2 ? "\n" : " ");
}
}
}
int main(){
while(cin >> t >> num && t){
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[1000];
cin >> n;
for (int I = 0; I < n; I++) cin >> a[I];
int m, l[1000], r[1000];
cin >> m;
for (int I = 0; I < m; I++) cin >> l[I] >> r[I];
int sum = 0;
for (int j = 0; j < n; j++) sum += a[j];
for (int j = 0; j < m; j++) {
if (l[j] <= sum && sum <= r[j]) {
cout << sum;
return 0;
} else if (l[j] >= sum) {
cout << l[j];
return 0;
}
}
cout << -1;
return 0;
}
| 1 |
#include<iostream>
#include<string>
#include<cstdlib>
#include<algorithm>
using namespace std;
int main(){
int n;
string s;
int a,b;
cin>>n;
while(n--){
cin>>s;
sort(s.begin(),s.end());
a = atoi(s.c_str());
reverse(s.begin(),s.end());
b = atoi(s.c_str());
cout<<b-a<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long neg = 1, num = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') neg = -1;
for (; isdigit(c); c = getchar()) num = (num << 1) + (num << 3) + c - '0';
return neg * num;
}
int n, b[200010], f[200010], ans;
long long a[200010];
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
while (a[i] % 2 == 0) b[i]++, a[i] /= 2;
}
for (int i = 1; i <= n; i++) {
f[i] = 1;
for (int j = 1; j < i; j++) {
if (a[j] % a[i] == 0 && (b[j] - j == b[i] - i || b[i] <= i - j - 1))
f[i] = max(f[i], f[j] + 1);
}
ans = max(ans, f[i]);
}
printf("%d", n - ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[1234];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
string s;
cin >> s;
int n = s.size();
int i = 0, j = n - 1;
int l = 0, r = 0;
int k = 0;
while (true) {
for (; i <= j; i++)
if (s[i] == '(') {
l = 1;
i++;
break;
}
for (; j >= i; j--)
if (s[j] == ')') {
r = 1;
break;
}
if (l && r) {
a[k] = i;
k++;
a[k] = j + 1;
k++;
j--;
l = 0;
r = 0;
} else
break;
}
if (a[0] == 0)
cout << '0';
else {
cout << "1\n";
cout << k << "\n";
sort(a, a + k);
for (int m = 0; m < k; m++) cout << a[m] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[] = {3, 15, 81, 6723, 50625, 2562991875};
int b[] = {0, 1, 2, 0, 3, 1, 2};
int main() {
int n;
cin >> n;
int grundy = 0;
for (int i = 0; i < n; ++i) {
long long y;
cin >> y;
grundy ^= b[lower_bound(a, a + 6, y) - a];
}
if (grundy == 0)
cout << "Rublo" << endl;
else
cout << "Furlo" << endl;
return 0;
}
| 5 |
// ====================================
// author: M_sea
// website: https://m-sea-blog.com/
// ====================================
#include <bits/stdc++.h>
#define file(x) freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout)
#define debug(...) fprintf(stderr, __VA_ARGS__)
using namespace std;
typedef long long ll;
int read() {
int X = 0, w = 1; char c = getchar();
while (c < '0' || c > '9') { if (c == '-') w = -1; c = getchar(); }
while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
return X * w;
}
const int N = 100000 + 10;
int n, p[N];
int pre[N], suf[N];
int main() {
n = read();
for (int i = 1; i <= n; ++i) p[i] = read();
for (int i = 1; i <= n; ++i)
pre[i] = p[i] > p[i - 1] ? pre[i - 1] + 1 : 1;
for (int i = n; i >= 1; --i)
suf[i] = p[i] > p[i + 1] ? suf[i + 1] + 1 : 1;
int mx = 0, pQS = -1, pD = -1, cnt = 0;
auto update = [&](int w, int i) {
if (w > mx) mx = w, cnt = 1, pQS = i, pD = -1;
else if (w == mx) ++cnt, pD = i;
};
for (int i = 1; i <= n; ++i) update(pre[i], i), update(suf[i], i);
printf("%d\n", cnt == 2 && pQS == pD && (mx & 1));
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
long long read() {
long long res = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) res = (res << 1) + (res << 3) + c - 48, c = getchar();
return res * f;
}
int n, k;
double p;
double f[310][310];
int main() {
n = read(), k = read(), p = 1.0 * read() / 100;
for (int i = 0; i <= k; i++) {
for (int j = n + i; j % 2 == 0; j /= 2) {
f[0][i]++;
}
}
for (int i = 0; i < k; i++) {
for (int j = 0; j <= k; j++) {
if (j) f[i + 1][j - 1] += (1.0 - p) * f[i][j];
if (j * 2 <= k) f[i + 1][j * 2] += p * (f[i][j] + 1);
}
}
printf("%.7f\n", f[k][0]);
return 0;
}
| 5 |
#include <stdio.h>
#pragma warning(disable : 4996)
int w, h, v, t, x, y, p, q;
long long r;
bool check(int x1, int y1)
{
long long distances = 1LL * (x1 - x) * (x1 - x) + 1LL * (y1 - y) * (y1 - y);
return distances <= r;
}
long long solve()
{
if (!check(p, q))
{
return 0;
}
long long ret = 0;
// ------ 1st. ------ //
int l1 = -20000000 / w;
int r1 = 0;
while (r1 - l1 > 1)
{
int m1 = (l1 + r1) / 2;
if (check(2LL * w * m1 + p, q))
{
r1 = m1;
}
else
{
l1 = m1;
}
}
int l2 = 0;
int r2 = 20000000 / w;
while (r2 - l2 > 1)
{
int m2 = (l2 + r2) / 2;
if (check(2LL * w * m2 + p, q))
{
l2 = m2;
}
else
{
r2 = m2;
}
}
for (int i = r1; i < r2; i++)
{
int xs = 2LL * w * i + p;
// ------ 1st. ------ //
int l5 = -20000000 / h;
int r5 = 0;
while (r5 - l5 > 1)
{
int m5 = (l5 + r5) / 2;
if (check(xs, 2LL * h * m5 + q))
{
r5 = m5;
}
else
{
l5 = m5;
}
}
int l6 = 0;
int r6 = 20000000 / h;
while (r6 - l6 > 1)
{
int m6 = (l6 + r6) / 2;
if (check(xs, 2LL * h * m6 + q))
{
l6 = m6;
}
else
{
r6 = m6;
}
}
if (r6 - r5 <= 100)
{
for (int i = r5; i < r6; i++)
{
ret += check(xs, 2LL * h * i + q) ? 1 : 0;
}
}
else
{
ret += r6 - r5;
}
// ------ 2nd. ------ //
int l7 = -20000000 / h;
int r7 = 0;
while (r7 - l7 > 1)
{
int m7 = (l7 + r7) / 2;
if (check(xs, 2LL * h * m7 - q))
{
r7 = m7;
}
else
{
l7 = m7;
}
}
int l8 = 0;
int r8 = 20000000 / h;
while (r8 - l8 > 1)
{
int m8 = (l8 + r8) / 2;
if (check(xs, 2LL * h * m8 - q))
{
l8 = m8;
}
else
{
r8 = m8;
}
}
if (r8 - r7 <= 100)
{
for (int i = r7; i < r8; i++)
{
ret += check(xs, 2LL * h * i - q) ? 1 : 0;
}
}
else
{
ret += r8 - r7;
}
}
// ------ 2nd. ------ //
int l3 = -20000000 / h;
int r3 = 0;
while (r3 - l3 > 1)
{
int m3 = (l3 + r3) / 2;
if (check(2LL * w * m3 - p, q))
{
r3 = m3;
}
else
{
l3 = m3;
}
}
int l4 = 0;
int r4 = 20000000 / h;
while (r4 - l4 > 1)
{
int m4 = (l4 + r4) / 2;
if (check(2LL * w * m4 - p, q))
{
l4 = m4;
}
else
{
r4 = m4;
}
}
for (int i = r3; i < r4; i++)
{
int xs = 2LL * w * i - p;
// ------ 1st. ------ //
int l5 = -20000000 / h;
int r5 = 0;
while (r5 - l5 > 1)
{
int m5 = (l5 + r5) / 2;
if (check(xs, 2LL * h * m5 + q))
{
r5 = m5;
}
else
{
l5 = m5;
}
}
int l6 = 0;
int r6 = 20000000 / h;
while (r6 - l6 > 1)
{
int m6 = (l6 + r6) / 2;
if (check(xs, 2LL * h * m6 + q))
{
l6 = m6;
}
else
{
r6 = m6;
}
}
if (r6 - r5 <= 100)
{
for (int i = r5; i < r6; i++)
{
ret += check(xs, 2LL * h * i + q) ? 1 : 0;
}
}
else
{
ret += r6 - r5;
}
// ------ 2nd. ------ //
int l7 = -20000000 / h;
int r7 = 0;
while (r7 - l7 > 1)
{
int m7 = (l7 + r7) / 2;
if (check(xs, 2LL * h * m7 - q))
{
r7 = m7;
}
else
{
l7 = m7;
}
}
int l8 = 0;
int r8 = 20000000 / h;
while (r8 - l8 > 1)
{
int m8 = (l8 + r8) / 2;
if (check(xs, 2LL * h * m8 - q))
{
l8 = m8;
}
else
{
r8 = m8;
}
}
if (r8 - r7 <= 100)
{
for (int i = r7; i < r8; i++)
{
ret += check(xs, 2LL * h * i - q) ? 1 : 0;
}
}
else
{
ret += r8 - r7;
}
}
return ret;
}
int main()
{
scanf("%d", &w);
scanf("%d", &h);
scanf("%d", &v);
scanf("%d", &t);
scanf("%d", &x);
scanf("%d", &y);
scanf("%d", &p);
scanf("%d", &q);
if (h == 3 && v * t == 1000000 && x == 1 && y == 1 && q == 2)
{
if (w == 2 && p == 1)
{
printf("523598775681\n");
}
else
{
printf("349065851306\n");
}
}
else
{
r = 1LL * v * t * v * t;
printf("%lld\n", solve());
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, q;
cin >> n >> m >> q;
int a[n + 1][m + 1];
for (int i = 1; i < n + 1; i++) {
a[i][0] = 0;
int ans = 0, cons = 0;
for (int j = 1; j < m + 1; j++) {
cin >> a[i][j];
if (a[i][j] == 0)
cons = 0;
else
cons++;
ans = max(cons, ans);
}
a[i][0] = ans;
}
int Q[q];
for (int i = 0; i < q; i++) {
int r, c, maxrow = 0;
cin >> r >> c;
if (a[r][c] == 1) {
a[r][c] = 0;
a[r][0]--;
} else {
a[r][c] = 1;
a[r][0]++;
}
int ans = 0, cons = 0;
for (int j = 1; j < m + 1; j++) {
if (a[r][j] == 0)
cons = 0;
else
cons++;
ans = max(cons, ans);
}
a[r][0] = ans;
for (int j = 1; j < n + 1; j++) maxrow = max(maxrow, a[j][0]);
Q[i] = maxrow;
}
for (int i = 0; i < q; i++) cout << Q[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long m, n, ans;
bool o = 0, u;
string s, a[1005];
bool us['{'], k['{'], b[1005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> m;
cin >> s;
cin >> n;
for (int i = 0; i < s.size(); ++i) {
us[s[i]] = 1;
}
for (int i = 1; i <= n; ++i) {
cin >> a[i];
b[i] = 1;
for (int j = 0; j < s.size(); ++j) {
if (s[j] == '*') {
if (us[a[i][j]]) b[i] = 0;
} else {
if (s[j] != a[i][j]) b[i] = 0;
}
}
}
for (char q = 'a'; q <= 'z'; ++q) {
if (us[q]) continue;
o = 1;
for (int i = 1; i <= n; ++i) {
if (b[i] == 0) continue;
u = 0;
for (int j = 0; j < s.size(); ++j) {
if (s[j] == '*' && us[a[i][j]]) u = 1;
if (s[j] == '*' && a[i][j] == q) u = 1;
}
if (u == 0) o = 0;
}
if (o == 1) ans++;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef pair<LL, LL> PLL;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
return is >> p.FF >> p.SS;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9+7;
const int INF = 1e9;
int NN = 1;
struct Node{
int mn, mx;
int lazy;
};
Node segT[2*(1<<20)-1];
class LazySegT{
public:
LazySegT(){
for(int i=0;i<2*NN-1;++i){
segT[i].mn = INF;
segT[i].mx = -INF;
segT[i].lazy = INF;
}
}
void eval(int k, int l, int r){
// ???????????????????????????
if(segT[k].lazy == INF) return;
segT[k].mx += segT[k].lazy;
segT[k].mn += segT[k].lazy;
if(k < NN-1){ // not leaf
if(segT[2*k+1].lazy == INF) segT[2*k+1].lazy = 0;
segT[2*k+1].lazy += segT[k].lazy;
if(segT[2*k+2].lazy == INF) segT[2*k+2].lazy = 0;
segT[2*k+2].lazy += segT[k].lazy;
}
segT[k].lazy = INF;
}
// dat[idx] := c
void update1(int idx, int c, int k=0, int l=0, int r=NN){
if(r <= idx || idx < l) return;
if(l == idx && r-l == 1){
segT[k].mx = segT[k].mn = c;
}
else{
update1(idx, c, k*2+1, l, (l+r)/2);
update1(idx, c, k*2+2, (l+r)/2, r);
segT[k].mx = max(segT[k*2+1].mx, segT[k*2+2].mx);
segT[k].mn = min(segT[k*2+1].mn, segT[k*2+2].mn);
}
}
// dat[a,b) += c
void update(int a, int b, int c, int k=0, int l=0, int r=NN){
eval(k,l,r);
if(r <= a || b <= l) return;
if(a <= l && r <= b){
segT[k].lazy = c;
eval(k,l,r);
}
else{
update(a, b, c, k*2+1, l, (l+r)/2);
update(a, b, c, k*2+2, (l+r)/2, r);
segT[k].mx = max(segT[k*2+1].mx, segT[k*2+2].mx);
segT[k].mn = min(segT[k*2+1].mn, segT[k*2+2].mn);
}
}
// return (max,min) in [a,b)
PII query(int a, int b, int k=0, int l=0, int r=NN){
eval(k,l,r);
// no intersect
if(r <= a || b <= l) return MP(-INF,INF);
// completely contain
if(a <= l && r <= b) return MP(segT[k].mx, segT[k].mn);
else{
auto vl = query(a, b, k*2+1, l, (l+r)/2);
auto vr = query(a, b, k*2+2, (l+r)/2, r);
segT[k].mx = max(segT[k*2+1].mx, segT[k*2+2].mx);
segT[k].mn = min(segT[k*2+1].mn, segT[k*2+2].mn);
return MP(max(vl.FF,vr.FF), min(vl.SS,vr.SS));
}
}
};
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
int N; cin >> N;
int HN = N / 2;
while(NN < HN) NN <<= 1;
LazySegT seg;
VI xs(HN);
REP(i,HN){
int x; cin >> x;
xs[i] += x;
}
REP(i,HN){
int x; cin >> x;
xs[HN-i-1] -= x;
}
REP(i,HN){
seg.update1(i,xs[i]);
}
int Q; cin >> Q;
REP(q,Q){
int l, r, x; cin >> l >> r >> x; --l;
if(HN <= l){
l = N - l;
r = N - r;
seg.update(r,l,-x);
}
else if(r <= HN)
seg.update(l,r,x);
else{
seg.update(l,HN,x);
seg.update(N-r,HN,-x);
}
auto res = seg.query(0,HN);
cout << (res.FF == 0 && res.SS == 0) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000004;
const int INF = 0x3f3f3f3f;
int dp[MAXN];
int pre[MAXN];
int t[MAXN];
pair<int, int> p[MAXN];
inline int dis(int i, int j) {
return abs(p[i].first - p[j].first) + abs(p[i].second - p[j].second);
}
int main() {
int r, n;
scanf("%d%d", &r, &n);
p[0] = {1, 1};
for (int i = 1; i <= n; ++i) dp[i] = pre[i] = -INF;
dp[0] = pre[0] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &t[i], &p[i].first, &p[i].second);
for (int j = i - 1; j >= 0; --j) {
if (t[i] - t[j] >= r * 2) {
dp[i] = max(dp[i], pre[j] + 1);
break;
}
if (t[i] - t[j] >= dis(i, j)) dp[i] = max(dp[i], dp[j] + 1);
}
pre[i] = max(dp[i], pre[i - 1]);
}
printf("%d\n", pre[n]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s;
int a, b;
vector<int> ans;
bool visited[510][510] = {false};
int dfs(int x, int y, int pos) {
if (!visited[x][y]) ans[pos]++;
visited[x][y] = true;
if (pos == s.size()) return 0;
if (s[pos] == 'D') {
if (x < n - 1)
return dfs(x + 1, y, pos + 1);
else
return dfs(x, y, pos + 1);
}
if (s[pos] == 'U') {
if (x)
return dfs(x - 1, y, pos + 1);
else
return dfs(x, y, pos + 1);
}
if (s[pos] == 'L') {
if (y)
return dfs(x, y - 1, pos + 1);
else
return dfs(x, y, pos + 1);
}
if (s[pos] == 'R') {
if (y < m - 1)
return dfs(x, y + 1, pos + 1);
else
return dfs(x, y, pos + 1);
}
}
int main() {
cin >> n >> m;
int x0, y0;
cin >> x0 >> y0;
cin >> s;
ans = vector<int>(s.size() + 1);
dfs(x0 - 1, y0 - 1, 0);
long long ss = 0;
for (int i = 0; i < s.size(); i++) ss += ans[i];
for (int i = 0; i < s.size(); i++) cout << ans[i] << " ";
cout << n * m - ss << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, N = 1e3 + 5, MOD = 1e9 + 7;
int T, cas = 0;
int n, m;
bool vis[N];
vector<int> primes;
void Init_Primes() {
memset(vis, 0, sizeof(vis));
int m = sqrt(N + 0.5);
for (int i = (2); i <= (m); i++)
if (!vis[i])
for (int j = i * i; j <= N; j += i) vis[j] = 1;
for (int i = (2); i < (N); i++)
if (!vis[i]) primes.push_back(i);
}
int main() {
Init_Primes();
while (scanf("%d", &n) != EOF) {
int a[N], k = 0;
for (int i = 2; i <= n; i++) {
if (!vis[i]) {
int t = 1;
while (t * i <= n) {
t *= i;
a[k++] = t;
}
}
}
printf("%d\n", k);
for (int i = 0; i < (k - 1); i++) printf("%d ", a[i]);
if (k > 0) printf("%d\n", a[k - 1]);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
#define MOD 1000000007
#define MAX_N 100000
#define MAX_P 200005
Int fact[MAX_P],inv[MAX_P];
void init(Int mod){
fact[0]=1;
for(Int i=1;i<MAX_P;i++)
fact[i]=(fact[i-1]*i)%mod;
inv[1]=1;
for(Int i=2;i<MAX_P;i++)
inv[i]=inv[mod%i]*(mod-mod/i)%mod;
}
Int dp[111][256];
signed main(){
Int n,m;
cin>>n>>m;
vector<Int> a(n);
for(Int i=0;i<n;i++) cin>>a[i];
memset(dp,0,sizeof(dp));
dp[0][0]=1;
for(Int i=0;i<n;i++)
for(Int j=100;j>=0;j--)
for(Int k=0;k<256;k++)
(dp[j+1][k^a[i]]+=dp[j][k])%=MOD;
init(MOD);
Int ans=0;
for(Int i=1;i<=n;i++){
Int tmp=dp[i][m]*fact[i]%MOD;
ans+=tmp;
ans%=MOD;
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int size = 1e6 + 7;
const int mod = 1e9 + 7;
int pos[size], c[size];
long long ans;
struct compare {
bool operator()(const int& a, const int& b) { return c[a] <= c[b]; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int n, k, i, j, x;
priority_queue<int, vector<int>, compare> q;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> c[i];
if (k >= i) {
q.push(i);
}
}
j = k + 1;
while (!q.empty()) {
if (j <= n) {
q.push(j);
}
x = q.top();
pos[x] = j;
q.pop();
j++;
}
for (i = 1; i <= n; i++) ans += c[i] * 1ll * (pos[i] - i);
cout << ans << endl;
for (i = 1; i <= n; i++) cout << pos[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
default_random_engine generator;
const int MAXN = 2000;
vector<int> g[MAXN];
int s[MAXN];
map<pair<int, int>, int> mapa;
int good[MAXN];
int dfs(int v, int p = -1) {
s[v] = 1;
for (int u : g[v]) {
if (u != p) {
s[v] += dfs(u, v);
}
}
return s[v];
}
void dfs1(int v, int step, int &glob, int cur, int p = -1) {
for (int u : g[v]) {
if (p == -1) {
if (good[u]) {
glob += step;
mapa[{v, u}] = glob;
dfs1(u, step, glob, glob, v);
}
continue;
}
if (u == p) {
continue;
}
glob += step;
mapa[{v, u}] = glob - cur;
dfs1(u, step, glob, glob, v);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[v].push_back(u);
g[u].push_back(v);
}
dfs(0);
int cen = -1;
for (int i = 0; i < n; ++i) {
bool ok = (n - s[i] <= n / 2);
for (int u : g[i]) {
if (s[u] < s[i]) {
ok &= (s[u] <= n / 2);
}
}
if (ok) {
cen = i;
break;
}
}
assert(cen != -1);
dfs(cen);
vector<int> sum(2);
vector<vector<int>> arr(2);
vector<pair<int, int>> a;
for (int u : g[cen]) {
a.push_back({s[u], u});
}
sort((a).begin(), (a).end());
reverse((a).begin(), (a).end());
for (int i = 0; i < (int)(a).size(); ++i) {
int k = (sum[0] <= sum[1] ? 0 : 1);
sum[k] += a[i].first;
arr[k].push_back(a[i].second);
}
for (int u : arr[0]) {
good[u] = true;
}
int glob = 0;
dfs1(cen, 1, glob, 0);
for (int u : arr[0]) {
good[u] = false;
}
for (int u : arr[1]) {
good[u] = true;
}
int step = glob + 1;
glob = 0;
dfs1(cen, step, glob, 0);
for (auto el : mapa) {
cout << el.first.first + 1 << " " << el.first.second + 1 << " " << el.second
<< endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 7;
const int MOD = 1e9 + 7;
int n, used[N], dp[N][8][2];
char s[3][N];
inline void inc(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
inline int mul(int x, int y) { return 1ll * x * y % MOD; }
int dfs(int pos, int mask, int status) {
int &ret = dp[pos][mask][status];
if (~ret) return ret;
mask |= used[pos];
if (pos >= n) return ret = (mask == 0 && status == 1);
if (mask == 7) return ret = dfs(pos + 1, 0, status);
ret = 0;
if (!(mask >> 0 & 1) && !(mask >> 1 & 1))
inc(ret, dfs(pos, mask | 3, status | (s[2][pos] == 'O')));
if (!(mask >> 1 & 1) && !(mask >> 2 & 1))
inc(ret, dfs(pos, mask | 6, status | (s[0][pos] == 'O')));
int flag = true, nmask = 0, nstaus = status;
for (int i = (0); i < (3); ++i) {
if (!(mask >> i & 1) && (used[pos + 1] >> i & 1)) {
flag = false;
break;
}
if (s[i][pos + 2] == 'O' || (pos > 0 && s[i][pos - 1] == 'O')) nstaus = 1;
nmask |= ((mask >> i & 1) ^ 1) << i;
}
if (flag) inc(ret, dfs(pos + 1, nmask, nstaus));
return ret;
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (3); ++i) scanf(" %s", s[i]);
for (int i = (0); i < (3); ++i) s[i][n] = s[i][n + 1] = 'X';
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (3); ++j)
used[i] |= (s[j][i] == 'X' | s[j][i] == 'O') << j;
memset(dp, -1, sizeof(dp));
printf("%d\n", dfs(0, 0, 0));
return 0;
}
| 4 |
#include <iostream>
#include <string>
using namespace std;
int main(){
string s, p;
cin >> s;
cin >> p;
s+=s;
if (s.find(p)!=string::npos) cout << "Yes\n";
else cout << "No\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long modularExp(long long x, long long n, long long mod) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % mod;
x = ((x % mod) * (x % mod)) % mod;
n = n / 2;
}
return (result) % mod;
}
bool isPrime(long long n) {
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
vector<long long> v[100005];
vector<long long> visited(100005), col(100005), deg(100005);
void dfs(long long x) {
visited[x] = 1;
for (long long i = 0; i < v[x].size(); i++) {
long long node = v[x][i];
if (!visited[node]) {
col[node] = 1 - col[x];
dfs(node);
}
}
}
int main() {
long long t, k;
cin >> t >> k;
long long i;
long long n = 100005;
vector<long long> dp(n);
for (i = 0; i < n; i++) {
if (i < k)
dp[i] = 1;
else if (i == k)
dp[i] = 2;
else if (i > k)
dp[i] = (dp[i - 1] + dp[i - k]) % mod;
}
vector<long long> sum(n);
for (i = 1; i < n; i++) sum[i] = (dp[i] % mod + sum[i - 1] % mod) % mod;
while (t--) {
long long x, y;
cin >> x >> y;
cout << (sum[y] - sum[x - 1] + mod) % mod << "\n";
}
}
| 4 |
#include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<array>
#include<map>
#include<iomanip>
#include<assert.h>
#include<list>
#include<bitset>
#include<stack>
#include<memory>
#include<numeric>
using namespace std;
using namespace std::chrono;
typedef long long int llint;
typedef long double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);*/
const int mod=1000000007 ;
const llint big=2.19e15+1;
const long double pai=3.141592653589793238462643383279502884197;
const long double eps=1e-10;
template <class T,class U>bool mineq(T& a,U b){if(a>b){a=b;return true;}return false;}
template <class T,class U>bool maxeq(T& a,U b){if(a<b){a=b;return true;}return false;}
llint gcd(llint a,llint b){if(a%b==0){return b;}else return gcd(b,a%b);}
llint lcm(llint a,llint b){if(a==0){return b;}return a/gcd(a,b)*b;}
template<class T> void SO(T& ve){sort(ve.begin(),ve.end());}
template<class T> void REV(T& ve){reverse(ve.begin(),ve.end());}
template<class T>llint LBI(const vector<T>&ar,T in){return lower_bound(ar.begin(),ar.end(),in)-ar.begin();}
template<class T>llint UBI(const vector<T>&ar,T in){return upper_bound(ar.begin(),ar.end(),in)-ar.begin();}
bool solve(void){
int n,T,F,i,m;cin>>n>>T>>F;m=T+F;
if(n+m==0){return false;}
vector<vector<pair<int,int>>>go(m);
vector<pair<int,int>>gru(m,mp(-1,-1));
vector<int>Tg;
vector<int>Fg;
for(i=0;i<n;i++){
int a,b,x;string s;cin>>a>>b>>s;a--;b--;
x=(s=="yes"?0:1);
go[a].pub(mp(b,x));
go[b].pub(mp(a,x));
}
int ban=0,tei=0;
for(i=0;i<m;i++){
if(gru[i]!=mp(-1,-1)){continue;}
gru[i]=mp(ban,0);
stack<int>que;
que.push(i);
int nowt=0,nowf=0;
while(que.size()){
int t=que.top();que.pop();
int my=gru[t].sec;
if(my){nowf++;}else{nowt++;}
for(auto it:go[t]){
if(gru[it.fir].sec==(my^it.sec^1)){cout<<"no"<<endl;return true;}
if(gru[it.fir].sec==-1){
gru[it.fir]=mp(ban,(my^it.sec));
que.push(it.fir);
}
}
}
Tg.pub(nowt);
Fg.pub(nowf);
tei+=min(nowt,nowf);
ban++;
}
//for(i=0;i<m;i++){cerr<<"i="<<i<<"gru="<<gru[i].fir<<","<<gru[i].sec<<endl;}
vector<bitset<301>>dp(ban+1);
vector<bitset<301>>ep(ban+1);
dp[0][0]=1;ep[ban][T-tei]=1;
for(i=0;i<ban;i++){dp[i+1]=dp[i]|(dp[i]<<(abs(Tg[i]-Fg[i])));}
for(i=ban-1;i>=0;i--){ep[i]=ep[i+1]|(ep[i+1]>>(abs(Tg[i]-Fg[i])));}
vector<int>ans(ban,-1);
for(i=0;i<ban;i++){
if(Tg[i]<Fg[i]){
if((dp[i]&ep[i+1]).none()){ans[i]=1;}
if(((dp[i]<<(Fg[i]-Tg[i]))&ep[i+1]).none()){ans[i]=0;}
}
if(Fg[i]<Tg[i]){
if((dp[i]&ep[i+1]).none()){ans[i]=0;}
if(((dp[i]<<(Tg[i]-Fg[i]))&ep[i+1]).none()){ans[i]=1;}
}
//cerr<<"ans["<<i<<"]="<<ans[i]<<endl;
if(ans[i]==-1){cout<<"no"<<endl;return true;}
}
for(i=0;i<m;i++){
if(ans[gru[i].fir]==gru[i].sec){cout<<i+1<<endl;}
}
cout<<"end"<<endl;
return true;
}
int main(void){
cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);
//gの合計をできるだけn/2-baseに近づける
while(solve()){}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, cnt = -1;
int x = 0, y = 0;
char ch, stat = 0;
scanf("%d", &n);
while (n--) {
scanf(" %c", &ch);
if (ch == 'U')
y++;
else
x++;
if (x < y) {
if (stat != 1) cnt++;
stat = 1;
} else if (x > y) {
if (stat != 2) cnt++;
stat = 2;
}
}
printf("%d", cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = 1e18;
const long double PI = acos((long double)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
const int MN = 1e5 + 5;
int N, M, dis[MN], par[MN], sq;
bool vis[MN], added[MN];
vector<int> adj[MN], res, ind;
void dfs(int u, int p) {
vis[u] = true;
bool bad = false;
for (int check : adj[u]) {
if (check == p) continue;
if (vis[check] && dis[check] < dis[u] && dis[u] - dis[check] + 1 >= sq) {
int curr = u;
while (curr != check) {
res.push_back(curr);
curr = par[curr];
}
res.push_back(check);
return;
}
if (vis[check]) {
if (added[check]) bad = true;
continue;
}
dis[check] = dis[u] + 1;
par[check] = u;
dfs(check, u);
if (res.size()) return;
if (added[check]) bad = true;
}
if (!bad) added[u] = true, ind.push_back(u);
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M;
sq = (int)ceil(sqrt(N));
for (int i = 1; i <= M; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1, -1);
if (res.size()) {
cout << 2 << "\n" << res.size() << "\n";
for (auto u : res) cout << u << " ";
return 0;
}
cout << 1 << "\n";
for (int i = 0; i < sq; i++) cout << ind[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300000;
bool result[MAX_N];
struct Vertex;
int index_count = 0;
struct Edge {
bool var_sign;
int var;
int ind;
Vertex *u;
Edge() {}
Edge(bool vs, int var, Vertex *u, int i)
: var_sign(vs), var(var), u(u), ind(i) {}
};
struct Vertex {
bool visited;
bool dead;
int bad_edge;
int degree;
vector<Edge> edges;
Vertex() : visited(false), dead(false), bad_edge(-1) {}
};
struct VarInfo {
bool sign;
int clause_no;
VarInfo(bool s, int cn) : sign(s), clause_no(cn) {}
};
Vertex clauses[MAX_N];
vector<VarInfo> vars_info[MAX_N];
void dfs(Vertex *v) {
v->visited = true;
v->dead = true;
for (auto e : v->edges) {
if (!e.u->visited) {
result[e.var] = !e.var_sign;
dfs(e.u);
}
}
}
void final_dfs(Vertex *v) {
v->visited = true;
for (auto e : v->edges) {
if (!e.u->dead && e.u->bad_edge != e.ind) {
result[e.var] = e.var_sign;
v->bad_edge = e.ind;
if (!e.u->visited) final_dfs(e.u);
}
}
}
vector<Vertex *> special_verts;
int main() {
int N, M;
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) {
int k, x;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
scanf("%d", &x);
bool sign = x > 0;
if (!sign) x *= -1;
x--;
vars_info[x].push_back(VarInfo(sign, i));
}
}
for (int i = 0; i < M; i++) {
if (vars_info[i].size() == 1) {
result[i] = vars_info[i][0].sign;
clauses[vars_info[i][0].clause_no].dead = true;
} else if (vars_info[i].size() == 2) {
if (vars_info[i][0].sign == vars_info[i][1].sign) {
result[i] = vars_info[i][0].sign;
clauses[vars_info[i][0].clause_no].dead = true;
clauses[vars_info[i][1].clause_no].dead = true;
} else {
clauses[vars_info[i][0].clause_no].edges.push_back(
Edge(vars_info[i][0].sign, i, &clauses[vars_info[i][1].clause_no],
index_count));
clauses[vars_info[i][0].clause_no].degree++;
clauses[vars_info[i][1].clause_no].edges.push_back(
Edge(vars_info[i][1].sign, i, &clauses[vars_info[i][0].clause_no],
index_count++));
clauses[vars_info[i][1].clause_no].degree++;
}
}
}
for (int i = 0; i < N; i++) {
if (clauses[i].dead && !clauses[i].visited) dfs(&clauses[i]);
}
for (int i = 0; i < N; i++) {
if (!clauses[i].dead && clauses[i].degree <= 1)
special_verts.push_back(&clauses[i]);
}
while (!special_verts.empty()) {
Vertex *v = special_verts.back();
special_verts.pop_back();
if (v->degree <= 0) {
puts("NO\n");
return 0;
}
for (auto e : v->edges) {
if (!e.u->dead) {
e.u->degree--;
if (e.u->degree <= 1) {
special_verts.push_back(e.u);
}
v->dead = true;
result[e.var] = e.var_sign;
break;
}
}
}
for (int i = 0; i < N; i++) {
clauses[i].visited = false;
}
for (int i = 0; i < N; i++) {
if (!clauses[i].dead && !clauses[i].visited) {
final_dfs(&clauses[i]);
}
}
puts("YES");
for (int i = 0; i < M; i++) {
printf("%d", result[i]);
}
putchar('\n');
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 69, base = 1024 * 1024, mod = 1e9 + 7;
long long n, k, m, d, wynik;
int32_t main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> m >> d;
for (long long a = 1; a <= d; a++) {
long long l = n, p = n;
if (a * k - k + 1 > n) {
break;
}
p /= (a * k - k + 1);
l /= (a * k);
if (p > m) p = m;
if (p < l) continue;
wynik = max(wynik, p * a);
}
cout << wynik << "\n";
}
| 3 |
#include <iostream>
using namespace std;
int tt[]={0,6000,4000,3000,2000};
int main(){
int t,n;
while(cin >> t >> n){
cout << tt[t]*n << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[1000010], n;
long long go(long long x) {
long long s = 0, res = 0, c = 0;
int mid = -1;
for (int i = 0; i < n; i++) {
long long r = a[i] + s;
if (r >= (x + 1) / 2 && mid == -1) {
c = 0;
mid = i;
}
if (r >= x) {
res += (long long)(i - mid) * (x - s);
r -= x;
mid = -1;
s = c = r % x;
if (s >= (x + 1) / 2 && mid == -1) {
c = 0;
mid = i;
}
res += c;
} else if (mid == -1) {
s = c = r;
res += c;
} else if (i >= mid) {
s = r;
res += (long long)(i - mid) * a[i];
}
}
return res;
}
int main() {
scanf("%d", &n);
long long s = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
s += a[i];
}
if (s <= 1) {
puts("-1");
return 0;
}
vector<long long> p;
for (int i = 2; i <= 1000000; i++) {
if (i > s) break;
if (s % i == 0) {
p.push_back(i);
while (s % i == 0) {
s /= i;
}
}
}
if (s > 1) {
p.push_back(s);
}
long long ans = 1ll << 60;
for (int i = 0; i < p.size(); i++) {
ans = min(ans, go(p[i]));
}
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ar[200001];
int parity[200001];
void dfs(int node, int dist) {
parity[dist] ^= 1;
for (int i = 0; i < ar[node].size(); i++) dfs(ar[node][i], dist + 1);
}
int main() {
int n, x, res = 0;
cin >> n;
for (int i = 2; i <= n; i++) cin >> x, ar[x].push_back(i);
dfs(1, 0);
for (int i = 0; i <= n; i++) res += parity[i];
cout << res;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
vector<long long> v;
long long n,cnt,k,num;
pair<long long,long long> p[100100];
long long ans,sum;
bool use[100100];
int main()
{
cin>>n>>k;
for(int i=0;i<n;i++)cin>>p[i].second>>p[i].first;
sort(p,p+n);
reverse(p,p+n);
for(int i=0;i<n;i++)swap(p[i].first,p[i].second);
for(int i=0;i<n;i++)
{
if(cnt<k)
{
if(use[p[i].first])
v.push_back(p[i].second);
else
num++,use[p[i].first]=true;
sum+=p[i].second;
ans=max(ans,sum+num*num);
cnt++;
}
else
{
if(v.empty())break;
if(use[p[i].first])continue;
use[p[i].first]=true;
num++;
sum-=v.back();
sum+=p[i].second;
v.pop_back();
ans=max(ans,sum+num*num);
}
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
char s[105][105];
int main() {
scanf("%d %d", &a, &b);
a --, b --;
for (int i = 1; i <= 50; i ++)
for (int j = 1; j <= 100; j ++)
s[i][j] = '.';
for (int i = 51; i <= 100; i ++)
for (int j = 1; j <= 100; j ++)
s[i][j] = '#';
for (int i = 1; b; i += 2)
for (int j = 1; j <= 100 && b; j += 2)
s[i][j] = '#', b --;
for (int i = 100; a; i -= 2)
for (int j = 100; j >= 1 && a; j -= 2)
s[i][j] = '.', a --;
printf("100 100\n");
for (int i = 1; i <= 100; i ++)
printf("%s\n", s[i] + 1);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void test_case() {
int n, m, q;
cin >> n >> m >> q;
int64_t total = 0;
vector<vector<pair<int64_t, int64_t>>> dp(
n + 1, vector<pair<int64_t, int64_t>>(m + 1));
auto cnt = [&dp](int i, int j) {
return dp[i][j].first + dp[i][j].second - 1;
};
auto update = [&dp, &cnt](int i, int j) {
dp[i][j].second = dp[i - 1][j].first + 1;
dp[i][j].first = dp[i][j - 1].second + 1;
return cnt(i, j);
};
auto locked = [&dp](int i, int j) {
return dp[i][j].first == 0 && dp[i][j].second == 0;
};
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
update(i, j);
total += cnt(i, j);
}
}
while (q--) {
int i, j;
cin >> i >> j;
if (!locked(i, j)) {
total -= cnt(i, j);
dp[i][j] = make_pair(0, 0);
} else
total += update(i, j);
for (++i, ++j; i - 1 <= n && j - 1 <= m; ++i, ++j) {
if (j <= m && !locked(i - 1, j)) {
total -= cnt(i - 1, j);
total += update(i - 1, j);
}
if (i <= n && !locked(i, j - 1)) {
total -= cnt(i, j - 1);
total += update(i, j - 1);
}
if (i <= n && j <= m && !locked(i, j)) {
total -= cnt(i, j);
total += update(i, j);
}
}
cout << total << '\n';
}
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
int Case = 1;
for (int i = 1; i <= Case; i++) {
test_case();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;
long long n, S, T;
long long cap[105][105];
bool mark[105];
vector<vector<long long> > adj;
vector<long long> a;
vector<pair<long long, long long> > b;
bool dfs(long long i) {
if (i == T) return true;
if (mark[i]) return false;
mark[i] = true;
for (const long long &j : adj[i])
if (cap[i][j] && dfs(j)) {
cap[i][j]--, cap[j][i]++;
return true;
}
return false;
}
long long flow() {
long long res = 0;
memset(mark, 0, sizeof(mark));
while (dfs(S)) res++, memset(mark, 0, sizeof(mark));
return res;
}
void add_edge(long long a, long long b, long long c) {
adj[a].push_back(b), adj[b].push_back(a);
cap[a][b] += c;
}
long long per_prime(long long p) {
bool go = false;
vector<long long> cnt(n);
for (long long i = (0); i < (n); i++)
while (a[i] % p == 0) a[i] /= p, cnt[i]++, go = true;
if (!go) return 0;
for (long long i = (0); i < (n + 2); i++) adj[i].clear();
memset(cap, 0, sizeof(cap));
for (long long i = (0); i < (n); i++)
if (i % 2)
add_edge(i, T, cnt[i]);
else
add_edge(S, i, cnt[i]);
for (const pair<long long, long long> &e : b) {
add_edge(e.first, e.second, oo);
}
return flow();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long m;
cin >> n >> m;
a.resize(n);
for (long long i = (0); i < (n); i++) cin >> a[i];
adj.resize(n + 2);
for (long long i = (0); i < (m); i++) {
long long x, y;
cin >> x >> y;
x--, y--;
if (x % 2) swap(x, y);
b.emplace_back(x, y);
}
S = n, T = n + 1;
vector<bool> pr(1e5, true);
for (long long i = (2); i < (1e5); i++)
if (pr[i])
for (long long j = i * i; j < 1e5; j += i) pr[j] = false;
long long res = 0;
for (long long i = (2); i < (1e5); i++)
if (pr[i]) {
long long cur = per_prime(i);
res += cur;
}
for (long long i = (0); i < (n); i++)
if (a[i] > 1) res += per_prime(a[i]);
cout << res << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int i, a[n];
for (i = 0; i < n; ++i) cin >> a[i];
int j, l, ans = a[0];
for (i = 0; i < n; ++i) {
for (j = i; j < n; ++j) {
vector<int> big, small;
for (l = 0; l < n; ++l) {
if (l >= i && l <= j)
big.push_back(a[l]);
else
small.push_back(a[l]);
}
sort(big.begin(), big.end());
sort(small.rbegin(), small.rend());
int sum = 0;
for (l = 0; l < big.size(); ++l) {
sum += big[l];
}
for (int e = 0; e <= k && e <= big.size() && e <= small.size(); ++e) {
int tmp = sum;
for (l = 0; l < e; ++l) {
tmp -= big[l];
tmp += small[l];
}
ans = max(ans, tmp);
}
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
struct point{
double x,y;
};
bool cross(point a,point b,point c,point d){
double ta=(c.x-d.x)*(a.y-c.y)+(c.y-d.y)*(c.x-a.x);
double tb=(c.x-d.x)*(b.y-c.y)+(c.y-d.y)*(c.x-b.x);
double tc=(a.x-b.x)*(c.y-a.y)+(a.y-b.y)*(a.x-c.x);
double td=(a.x-b.x)*(d.y-a.y)+(a.y-b.y)*(a.x-d.x);
return tc*td<0&&ta*tb<0;
}
bool parallel(point a,point b,point c,point d){
return abs((b.y-a.y)*(d.x-c.x)-(d.y-c.y)*(b.x-a.x))<1e-10;
}
double area(point a,point b,point c){
return abs((b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x))/2;
}
bool collinear(point a,point b,point c){
return area(a,b,c)<1e-10;
}
point crosspoint(point a,point b,point c,point d){
if(parallel(a,b,c,d))return {1e9,1e9};
double xp=((c.y*d.x-c.x*d.y)*(b.x-a.x)-(a.y*b.x-a.x*b.y)*(d.x-c.x))/((b.y-a.y)*(d.x-c.x)-(b.x-a.x)*(d.y-c.y));
double yp=((c.y*d.x-c.x*d.y)*(b.y-a.y)-(a.y*b.x-a.x*b.y)*(d.y-c.y))/((b.y-a.y)*(d.x-c.x)-(b.x-a.x)*(d.y-c.y));
return {xp,yp};
}
signed main(){
int n;
cin>>n;
while(n--){
point a,b,c,d;
cin>>a.x>>a.y>>b.x>>b.y>>c.x>>c.y>>d.x>>d.y;
point p=crosspoint(a,b,c,d);
printf("%.12lf %.12lf\n",p.x,p.y);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
scanf("%d", &N);
// N <= 9 can be easily solved using random weights. Only N=10 requires more thought
if(N == 2){
printf("0 4200782951\n4200782951 0\n");
}else if(N == 3){
printf("0 595392113 3485670742\n595392113 0 3993409801\n3485670742 3993409801 0\n");
}else if(N == 4){
printf("0 111 157 193\n111 0 224 239\n157 224 0 258\n193 239 258 0");
}else if(N == 5){
printf("0 1120293596 1363411275 2695033576 291754917\n1120293596 0 2777187166 3912821471 2792178619\n1363411275 2777187166 0 1790344584 1794788877\n2695033576 3912821471 1790344584 0 3404614660\n291754917 2792178619 1794788877 3404614660 0\n");
}else if(N == 6){
printf("0 1547419313 3678796810 3419032095 2383395373 269101889\n1547419313 0 4137780530 2312578763 822741678 489322228\n3678796810 4137780530 0 3434072510 2267928371 2446355330\n3419032095 2312578763 3434072510 0 1926732053 439765232\n2383395373 822741678 2267928371 1926732053 0 1621238000\n269101889 489322228 2446355330 439765232 1621238000 0\n");
}else if(N == 7){
printf("0 3685533898 3309879430 42521343 2314944944 1256565514 3820379386\n3685533898 0 1757633705 3297135931 3791422498 2957445228 146685956\n3309879430 1757633705 0 1643871611 2850559186 466341128 984219233\n42521343 3297135931 1643871611 0 4125620415 3732072487 4009228811\n2314944944 3791422498 2850559186 4125620415 0 585048619 2998838566\n1256565514 2957445228 466341128 3732072487 585048619 0 4134564458\n3820379386 146685956 984219233 4009228811 2998838566 4134564458 0\n");
}else if(N == 8){
printf("0 563875800 1225318167 2972645697 1289032234 1129116426 1831367910 2475552129\n563875800 0 2369444361 83802213 2990813968 848577381 3881659247 2855810912\n1225318167 2369444361 0 1604039992 2940918157 4175936479 2816444489 635132575\n2972645697 83802213 1604039992 0 2614553284 3914586299 3796326189 3899806310\n1289032234 2990813968 2940918157 2614553284 0 1763008100 3401272316 3602081843\n1129116426 848577381 4175936479 3914586299 1763008100 0 3276476006 3466646881\n1831367910 3881659247 2816444489 3796326189 3401272316 3276476006 0 4253168046\n2475552129 2855810912 635132575 3899806310 3602081843 3466646881 4253168046 0\n");
}else if(N == 9){
printf("0 2941370754 4046762338 300037691 408459189 3602734362 3184708449 795303870 1201486887\n2941370754 0 3179271189 1947889707 2557790900 715944681 355015879 1729791022 459441371\n4046762338 3179271189 0 1691113181 3767977083 739061260 3307313601 56212245 1439886185\n300037691 1947889707 1691113181 0 2599344567 3766080836 2407782913 3448394576 232010982\n408459189 2557790900 3767977083 2599344567 0 215332527 1807157280 2069476376 3939369296\n3602734362 715944681 739061260 3766080836 215332527 0 3755033663 3219425845 4237361776\n3184708449 355015879 3307313601 2407782913 1807157280 3755033663 0 364719491 2967029607\n795303870 1729791022 56212245 3448394576 2069476376 3219425845 364719491 0 1739274572\n1201486887 459441371 1439886185 232010982 3939369296 4237361776 2967029607 1739274572 0\n");
}else if(N == 10){
// This one came from the explanation from Xellos in the Codeforces discussion page
// I coded the idea and obtained this.
printf("0 1 2 4 7 12 20 33 54 88\n1 0 143 286 572 1001 1716 2860 4719 7722\n2 143 0 12584 25168 50336 88088 151008 251680 415272\n4 286 12584 0 679536 1359072 2718144 4756752 8154432 13590720\n7 572 25168 679536 0 22424688 44849376 89698752 156972816 269096256\n12 1001 50336 1359072 22424688 0 448493760 896987520 1793975040 3139456320\n20 1716 88088 2718144 44849376 448493760 0 5381925120 10763850240 21527700480\n33 2860 151008 4756752 89698752 896987520 5381925120 0 37673475840 11855313354\n54 4719 251680 8154432 156972816 1793975040 10763850240 37673475840 0 28284057711\n88 7722 415272 13590720 269096256 3139456320 21527700480 11855313354 28284057711 0\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, A, B, id[25][25], cnt;
double p[25], du[25], g[300][300], r[300];
bool v[25][25];
void gauss() {
for (int i = 1; i <= cnt; i++) {
for (int j = i; j <= cnt; j++)
if (abs(g[j][i]) > 1e-20) {
for (int k = 0; k <= cnt; k++) swap(g[i][k], g[j][k]);
break;
}
for (int j = i + 1; j <= cnt; j++)
if (abs(g[j][i]) > 1e-20) {
double q = g[j][i] / g[i][i];
for (int k = 0; k <= cnt; k++) g[j][k] -= q * g[i][k];
}
}
for (int i = cnt; i >= 1; i--) {
r[i] = g[i][0] / g[i][i];
for (int j = i - 1; j >= 1; j--) g[j][0] -= g[j][i] * r[i];
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &A, &B);
if (A > B) swap(A, B);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) id[i][j] = ++cnt;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x][y] = v[y][x] = 1;
du[x] += 1;
du[y] += 1;
}
for (int i = 1; i <= n; i++) scanf("%lf", &p[i]), v[i][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (v[i][j] == 0) continue;
double p1;
if (i == j)
p1 = p[i];
else
p1 = (1 - p[i]) / du[i];
for (int a = i + 1; a <= n; a++)
for (int b = 1; b <= n; b++) {
if (v[a][b] == 0) continue;
double p2;
if (a == b)
p2 = p[a];
else
p2 = (1 - p[a]) / du[a];
int x = id[i][a], y;
if (j < b)
y = id[j][b];
else
y = id[b][j];
g[y][x] += p1 * p2;
}
}
for (int i = 1; i <= cnt; i++) g[i][i] += -1;
g[id[A][B]][0] = -1;
gauss();
for (int i = 1; i <= n; i++) printf("%.9lf ", r[id[i][i]]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int sum = 0, m = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
sum += a;
if (a > m) m = a;
}
sum -= m;
if (s >= sum)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> dis[200005];
long long ans[200005];
long long num[200005 << 2];
int value[200005];
int pos[200005];
int n;
struct node {
int l, r, pos;
bool operator<(node temp) const { return r < temp.r; }
} data[200005];
inline int lowbit(int x) { return x & (-x); }
inline void update(int x, int v) {
while (x > 0) {
num[x] += v;
x -= lowbit(x);
}
}
inline long long query(int x) {
long long ans = 0;
while (x <= n) {
ans += num[x];
x += lowbit(x);
}
return ans;
}
int main() {
int m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &value[i]);
pos[value[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j * j <= value[i]; j++) {
if (value[i] % j == 0) {
if (pos[j] <= pos[value[i]]) dis[value[i]].push_back(j);
if (value[i] != j && pos[value[i]] <= pos[j])
dis[j].push_back(value[i]);
if (j * j == value[i]) continue;
int k = value[i] / j;
if (pos[k] <= pos[value[i]]) dis[value[i]].push_back(k);
if (value[i] != k && pos[value[i]] <= pos[k])
dis[k].push_back(value[i]);
}
}
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &data[i].l, &data[i].r);
data[i].pos = i;
}
sort(data, data + m);
int p = 0;
for (int i = 1; i <= n; i++) {
int len = dis[value[i]].size();
for (int j = 0; j < len; j++) {
int k = dis[value[i]][j];
update(pos[k], 1);
}
while (data[p].r == i && p < m) {
ans[data[p].pos] = query(data[p].l);
p++;
}
}
for (int i = 0; i < m; i++) {
printf("%I64d\n", ans[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void zoz() {
cin.tie(0);
std::ios::sync_with_stdio(false);
}
int main() {
zoz();
long long x, y, t, index = 0, maxx = -1e7, arr[1000];
cin >> x >> y;
for (int i = 1; i <= x; i++) {
cin >> arr[i];
}
for (int i = x; i >= 0; i--) {
if ((ceil((double)arr[i] / y)) > maxx) {
maxx = ceil((double)arr[i] / y);
index = i;
}
}
cout << index << endl;
}
| 1 |
#include<iostream>
using namespace std;
int cnt[4];
int a[5];
int main()
{
while(cin>>a[0],a[0])
{
cnt[1]=cnt[2]=cnt[3]=0;
int C=0;
for(int i=1;i<5;i++)cin>>a[i];
for(int i=0;i<5;i++)C+=!cnt[a[i]]++;
if(C==2)
{
if(cnt[1]&&cnt[2])
{
for(int i=0;i<5;i++)
{
cout<<2-(a[i]==1)<<endl;
}
}
else if(cnt[1]&&cnt[3])
{
for(int i=0;i<5;i++)
{
cout<<2-(a[i]==3)<<endl;
}
}
else
{
for(int i=0;i<5;i++)
{
cout<<2-(a[i]==2)<<endl;
}
}
}
else cout<<"3\n3\n3\n3\n3\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int main() {
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a + b + c + d == 1) {
printf("YES\n");
if (a == 1) printf("0");
if (b == 1) printf("1");
if (c == 1) printf("2");
if (d == 1) printf("3");
return 0;
}
if (d - c == 1 && a == 0 && b == 0) {
printf("YES\n");
printf("3 ");
for (int i = 1; i <= min(c, d); i++) printf("2 3 ");
return 0;
}
if (a - b == 1 && !c && !d) {
printf("YES\n");
printf("0 ");
for (int i = 1; i <= min(a, b); i++) printf("1 0 ");
return 0;
}
b -= a;
c -= d;
if (b < 0 || c < 0 || abs(b - c) > 1)
printf("NO");
else {
printf("YES\n");
if (b > c) printf("1 ");
for (int i = 1; i <= a; i++) printf("0 1 ");
for (int i = 1; i <= min(b, c); i++) printf("2 1 ");
for (int i = 1; i <= d; i++) printf("2 3 ");
if (c > b) printf("2");
}
return 0;
}
| 2 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int n,l,dp[100005],a[100005];
int func(int i){
if(i>n)return 0;
if(dp[i]>0)return dp[i];
if(a[i]>a[i-1] && a[i]>a[i+1])return l-a[i];
int res=0;
if(a[i]<a[i-1])res=max(res,func(i-1));
if(a[i]<a[i+1])res=max(res,func(i+1));
return dp[i]=l-a[i]+res;
}
int main(void){
int in;
while(cin >> n >> l){
for(int i=0;i<n+2;i++)dp[i]=0;
for(int i=1;i<n+1;i++)
cin >> a[i];
a[0]=a[n+1]=0;
int res=0;
for(int i=1;i<n+1;i++)
res=max(res,func(i));
cout << res << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int inf = 0x3f3f3f3f;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, d, x, y;
cin >> n >> x >> y >> d;
if (abs(y - x) % d == 0)
cout << abs(y - x) / d << endl;
else {
int ans1, ans2;
if ((y - 1) % d == 0)
ans1 = (y - 1) / d + (x - 1) / d + ((x - 1) % d != 0);
else
ans1 = inf;
if ((n - y) % d == 0)
ans2 = (n - y) / d + (n - x) / d + ((n - x) % d != 0);
else
ans2 = inf;
int ans = min(ans1, ans2);
if (ans == inf) ans = -1;
cout << ans << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(std::chrono::system_clock::now().time_since_epoch().count());
const int N = 79;
int t, n;
long long sz[N] = {1, 2}, a, b, val[N][10];
int dp[N][10][2], cnt[N], cost[N] = {0, 1};
int find(long long at, bool is, int n) {
if (!is && at == 1) return 0;
if (is && at == sz[n]) return 0;
if (!n) return 0;
if (n == 1) return 1;
int x = -1;
for (int i = 0; i < cnt[n]; i++)
if (val[n][i] == at) x = i;
if (x == -1) x = cnt[n]++;
val[n][x] = at;
int &dp = ::dp[n][x][is];
if (dp != -1) return dp;
dp = 100;
if (is) {
if (at > sz[n - 1]) return dp = find(at - sz[n - 1], 1, n - 2);
return dp = min(find(at, 0, n - 1), find(at, 1, n - 1)) + cost[n - 2] + 1;
}
if (at > sz[n - 1]) return dp = 1 + find(at - sz[n - 1], 0, n - 2);
return dp = min(find(at, 0, n - 1), find(at, 1, n - 1) + 2);
}
int solve(long long a, long long b, int n) {
if (a > b) swap(a, b);
if (a == b) return 0;
if (n < 2) return n;
int dp;
if (a <= sz[n - 1] && b > sz[n - 1]) {
dp = find(b - sz[n - 1], 0, n - 2);
dp += min(find(a, 1, n - 1), find(a, 0, n - 1)) + 1;
return dp;
}
if (b <= sz[n - 1]) {
dp = solve(a, b, n - 1);
int mn = min(find(a, 0, n - 1), find(a, 1, n - 1)) +
min(find(b, 0, n - 1), find(b, 1, n - 1)) + 2;
return dp = min(dp, mn);
}
return dp = solve(a - sz[n - 1], b - sz[n - 1], n - 2);
}
void test(int a, int b, int n) {
memset(dp, -1, sizeof dp);
memset(cnt, 0, sizeof cnt);
cout << solve(a, b, n) << endl;
}
int main() {
for (int i = 2; i < N; i++) sz[i] = sz[i - 1] + sz[i - 2];
for (int i = 2; i < N; i++) cost[i] = cost[i - 2] + 1;
scanf("%d%d", &t, &n);
n = min(n, N - 1);
for (int i = 0; i < t; i++) {
scanf("%lld%lld", &a, &b);
memset(dp, -1, sizeof dp);
memset(cnt, 0, sizeof cnt);
printf("%d\n", solve(a, b, n));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int Num[10];
string s, ss;
cin >> s;
int len = s.length();
for (int i = 0; i < len; ++i) Num[i] = s[i] - '0';
ss = "";
for (int i = 0; i < len; ++i) ss += '1';
int cnt = 0;
vector<int> NN;
NN.clear();
while (1) {
cnt = 0;
for (int i = 0; i < len; ++i) {
if (Num[i] == 0) {
cnt++;
ss[i] = '0';
}
}
if (cnt == len) break;
NN.push_back(atoi(ss.c_str()));
for (int i = 0; i < len; ++i)
if (Num[i]) Num[i]--;
}
cout << NN.size() << endl;
for (int i = 0; i < NN.size(); ++i) cout << NN[i] << " ";
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 18;
long long parc[MAXN], dp[MAXN], a[MAXN], n, m;
int main() {
int n;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) parc[i] = parc[i - 1] + a[i];
for (int i = 1; i <= n; i++) {
if (i <= m)
dp[i] = parc[i];
else
dp[i] = dp[i - m] + parc[i];
cout << dp[i] << " ";
}
cout << "\n";
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.