solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
int n = s.length();
int curr = 0, sum = 0;
if (n == 1) {
cout << 0 << endl;
return;
}
for (int i = 0; i < n; i++) {
sum += (int)(s[i] - '0');
}
int count = 1;
curr = sum;
sum = 0;
while (curr > 9) {
int temp = curr;
while (temp > 0) {
sum += (temp % 10);
temp /= 10;
}
count++;
curr = sum;
sum = 0;
}
cout << count << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int n;
char s[N];
int a[N];
vector<int> pos[2];
int main() {
cin >> n;
scanf("%s", s + 1);
pos[0].push_back(0);
pos[1].push_back(0);
for (int i = 1; i <= n; i++) {
a[i] = s[i] == 'A';
pos[a[i]].push_back(i);
}
pos[0].push_back(n + 1);
pos[1].push_back(n + 1);
long long ans = n * 1LL * (n - 1) / 2;
for (int d = 0; d < 2; d++) {
for (int i = 1; i < pos[d].size() - 1; i++) {
ans -= (pos[d][i + 1] - 1 - pos[d][i]);
}
for (int i = 1; i < pos[d].size() - 1; i++) {
ans -= (pos[d][i] - 1 - pos[d][i - 1]);
}
}
for (int i = 1; i < n; i++) {
ans += a[i] != a[i + 1];
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using int64 = int_fast64_t;
int main() {
int n,p;cin>>n>>p;
int odd=0;
for(int i=0;i<n;++i){
int k;cin>>k;
if(k%2==1) ++odd;
}
if(p==1 && odd==0){
cout<<0<<endl;
return 0;
}
int64 even=n-odd;
int64 ans=1LL<<(max(odd-1,0)+even);
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, x;
cin >> n;
cin >> x;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (x % i == 0 && (x / i) <= n) ans++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 nima(time(0));
const int max_n = 30 + 20, MOD = (1 << 18) + 100;
long double a[max_n][max_n], DP[MOD][max_n], dp[max_n][max_n];
bool mark[max_n];
int n;
long double ans, m, k, sum, st, en, cnt, t, q;
int32_t main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
DP[1][0] = 1;
for (int i = 0; i < 1 << n; i++) {
for (int j = 0; j < n; j++) {
if (i >> j & 1) {
for (int k = 0; k < n; k++) {
if ((i >> j & 1) && k != j)
DP[i][j] =
max(a[j][k] * DP[i ^ 1 << k][j] + a[k][j] * DP[i ^ 1 << j][k],
DP[i][j]);
}
}
}
}
for (int i = 0; i < n; i++) ans = max(DP[(1 << n) - 1][i], ans);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int gr(int k, int n) {
if (n<k) return 0;
if (n%k==0) return n/k;
return gr(k,n-(n%k+n/k)/(n/k+1)*(n/k+1));
}
int main() {
int i, a, b, x = 0;
scanf("%d",&n);
for (i=0;i<n;i++) {
scanf("%d%d",&a,&b);
x ^= gr(b,a);
}
puts(x?"Takahashi":"Aoki");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500000 + 5;
int a[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int l, r;
int ans = 0;
for (l = 1; l < n;) {
for (r = l + 1; r <= n; r++) {
if (a[r] == a[r - 1]) {
r--;
break;
}
}
if (r == n + 1) r--;
if (r - l > 1) {
if ((r - l + 1) % 2 == 0) {
ans = max(ans, (r - l + 1) / 2 - 1);
for (int i = l + 1; i < r; i++) {
if (i <= (r + l) / 2)
a[i] = a[l];
else
a[i] = a[r];
}
} else {
ans = max(ans, (r - l) / 2);
for (int i = l + 1; i < r; i++) a[i] = a[l];
}
l = r;
} else
l++;
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
if (i != 1) printf(" ");
printf("%d", a[i]);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, q, fa[N], du[N];
long long t[N], su[N];
multiset<long long> s[N], mi, ma;
long long flow(int i) { return t[i] / (du[i] + 2); }
long long sum(int i) { return t[i] - (du[i] + 1) * flow(i) + su[i]; }
void era(int i) {
if (!s[i].empty()) {
mi.erase(mi.find(*s[i].begin() + flow(i)));
ma.erase(ma.find(*s[i].rbegin() + flow(i)));
}
}
void ins(int i) {
if (!s[i].empty()) {
mi.insert(*s[i].begin() + flow(i));
ma.insert(*s[i].rbegin() + flow(i));
}
}
void rmv(int i, int ty = 1) {
int f = fa[i];
era(f), s[f].erase(s[f].find(sum(i)));
if (ty) su[f] -= flow(i);
}
void add(int i, int ty = 1) {
int f = fa[i];
s[f].insert(sum(i));
if (ty) su[f] += flow(i);
ins(f);
}
int main() {
cin >> n >> q;
for (int i = (1); i <= (n); i++) scanf("%lld", &t[i]);
for (int i = (1); i <= (n); i++) scanf("%d", &fa[i]), du[fa[i]]++;
for (int i = (1); i <= (n); i++) su[fa[i]] += flow(i);
for (int i = (1); i <= (n); i++) s[fa[i]].insert(sum(i));
for (int i = (1); i <= (n); i++) ins(i);
for (int op, x, y; q--;) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &x, &y);
int a = fa[x], b = fa[a];
rmv(b, 0), rmv(a), rmv(x), du[a]--, ins(a), add(a), add(b, 0);
a = fa[x] = y, b = fa[a];
rmv(b, 0), rmv(a), era(a), du[a]++, add(x), add(a), add(b, 0);
}
if (op == 2) scanf("%d", &x), printf("%lld\n", sum(x) + flow(fa[x]));
if (op == 3) printf("%lld %lld\n", *mi.begin(), *ma.rbegin());
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int t[2501][110], T = 0;
const long long int MOD = 1000000007LL;
long long int calc(int sum, int left) {
if (left == 0 and sum == 0) return 1;
if (left == 0) return 0;
if (t[sum][left] != -1) return t[sum][left];
long long int &r = t[sum][left] = 0;
for (int i = 0; i <= min('z' - 'a', sum); i++) {
r = (r + calc(sum - i, left - 1)) % MOD;
}
return r;
}
int main() {
int n;
cin >> n;
memset(t, -1, sizeof(t));
for (int i = 0; i < n; i++) {
string word;
cin >> word;
int sum = 0;
for (int j = 0; j < word.size(); j++) {
sum += word[j] - 'a';
}
cout << calc(sum, word.size()) - 1 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 9;
const int INF = -1;
int values[maxN];
struct edge {
int l, r;
int pos;
int mn;
int size;
int val;
int y;
};
edge v[maxN];
void update(int a) {
v[a].size = 1;
if (v[a].l != INF) {
v[a].size += v[v[a].l].size;
}
if (v[a].r != INF) {
v[a].size += v[v[a].r].size;
}
v[a].mn = v[a].val;
if (v[a].l != INF) {
v[a].pos = v[v[a].l].size;
} else {
v[a].pos = 0;
}
if (v[a].l != INF) {
if (v[a].mn >= v[v[a].l].mn) {
v[a].mn = v[v[a].l].mn;
v[a].pos = v[v[a].l].pos;
}
}
if (v[a].r != INF) {
if (v[a].mn > v[v[a].r].mn) {
v[a].mn = v[v[a].r].mn;
if (v[a].l != INF) {
v[a].pos = v[v[a].l].size + 1 + v[v[a].r].pos;
} else {
v[a].pos = 1 + v[v[a].r].pos;
}
}
}
}
int merge(int a, int b) {
if (a == INF) return b;
if (b == INF) return a;
if (v[a].y > v[b].y) {
int c = merge(v[a].r, b);
v[a].r = c;
update(a);
return a;
} else {
int c = merge(a, v[b].l);
v[b].l = c;
update(b);
return b;
}
}
pair<int, int> split(int a, int c) {
if (a == INF) return make_pair(INF, INF);
int sz = (v[a].l == INF) ? 0 : v[v[a].l].size;
if (sz + 1 <= c) {
auto ans = split(v[a].r, c - sz - 1);
v[a].r = ans.first;
update(a);
return make_pair(a, ans.second);
} else {
auto ans = split(v[a].l, c);
v[a].l = ans.second;
update(a);
return make_pair(ans.first, a);
}
}
int nxt = 0;
int add(int root, int val) {
int now = nxt++;
v[now].l = INF;
v[now].r = INF;
v[now].val = val;
v[now].y = rand();
update(now);
return merge(root, now);
}
pair<int, int> step(int root) {
int pos = v[root].pos;
auto fst = split(root, pos);
auto snd = split(fst.second, 1);
return make_pair(merge(snd.second, fst.first), pos + 1);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> values[i];
}
int root = INF;
for (int i = 0; i < n; i++) {
root = add(root, values[i]);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
auto res = step(root);
root = res.first;
ans += res.second;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void chkmax(T& x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
inline void chkmin(T& x, U y) {
if (y < x) x = y;
}
const int MAXN = 333333;
int a[MAXN], b[MAXN], chk[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
int tot = 0;
for (int i = 1; i <= n; i++)
if (!chk[i]) {
tot++;
for (int j = i; !chk[j]; chk[j] = 1, j = a[j])
;
}
if (tot == 1) tot = 0;
int sum = 0;
for (int i = 1; i <= n; i++) sum += b[i];
if (sum + 1 & 1) tot++;
cout << tot << endl;
return 0;
}
| 1 |
#ifndef __INTMOD_H__
#define __INTMOD_H__
/* updated: 2019-10-10 */
#include <iostream>
#include <cassert>
#include <vector>
#include <cstdint>
#include <functional>
#include <unordered_map>
template <uint32_t Mod>
class IntMod {
static_assert(Mod != 0, "Mod must not be 0");
static_assert(Mod < 0x80000000, "Mod must be less than 0x80000000");
private:
uint32_t value_m;
public:
IntMod();
IntMod(int32_t value);
IntMod(uint32_t value);
IntMod(int64_t value);
IntMod(uint64_t value);
const IntMod<Mod>& operator+() const;
IntMod<Mod> operator-() const;
IntMod<Mod>& operator++();
IntMod<Mod>& operator--();
IntMod<Mod> operator++(int dummy);
IntMod<Mod> operator--(int dummy);
IntMod<Mod>& operator+=(const IntMod<Mod>& right);
IntMod<Mod>& operator-=(const IntMod<Mod>& right);
IntMod<Mod>& operator*=(const IntMod<Mod>& right);
IntMod<Mod>& operator/=(const IntMod<Mod>& right);
IntMod<Mod> operator[](uint64_t exp) const;
static IntMod<Mod> add(const IntMod<Mod>& a, const IntMod<Mod>& b);
static IntMod<Mod> subtract(const IntMod<Mod>& a, const IntMod<Mod>& b);
static IntMod<Mod> multiply(const IntMod<Mod>& a, const IntMod<Mod>& b);
static IntMod<Mod> divide(const IntMod<Mod>& a, const IntMod<Mod>& b);
static int compare(const IntMod<Mod>& a, const IntMod<Mod>& b);
IntMod<Mod> inverse() const;
IntMod<Mod> power(uint64_t exp) const;
uint32_t get() const;
static IntMod<Mod> fact(uint32_t num);
static IntMod<Mod> invFact(uint32_t num);
static IntMod<Mod> combi(uint32_t n, uint32_t r);
static IntMod<Mod> homcombi(uint32_t n, uint32_t r);
static IntMod<Mod> perm(uint32_t n, uint32_t r);
static std::vector<IntMod<Mod>> calcInverseList(int max);
};
template <uint32_t Mod>
IntMod<Mod> operator+(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
IntMod<Mod> operator-(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
IntMod<Mod> operator*(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
IntMod<Mod> operator/(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator+(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator-(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator*(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator/(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator+(const Int& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator-(const Int& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator*(const Int& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator/(const Int& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator==(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator!=(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator<(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator<=(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator>(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator>=(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
bool operator==(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
bool operator!=(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod>
std::istream& operator>>(std::istream& ist, IntMod<Mod>& object);
template <uint32_t Mod>
std::ostream& operator<<(std::ostream& ost, const IntMod<Mod>& object);
using MInt = IntMod<1000000007>;
using MF = IntMod<998244353>;
// for unordered_set/map
namespace std {
template <uint32_t Mod>
struct hash<IntMod<Mod>> {
size_t operator() (const IntMod<Mod>& object) const {
return std::hash<uint32_t>()(object.get());
}
};
}
template <uint32_t Mod>
uint32_t discreteLog(const IntMod<Mod>& a, const IntMod<Mod>& b);
/*------------------------------------*/
/*------- Implementations --------*/
/*------------------------------------*/
template <uint32_t Mod>
IntMod<Mod>::IntMod()
: value_m(0) {
}
template <uint32_t Mod>
IntMod<Mod>::IntMod(int32_t value) {
int32_t tmp = value % int32_t(Mod);
value_m = tmp >= 0 ? tmp : Mod - uint32_t(-tmp);
}
template <uint32_t Mod>
IntMod<Mod>::IntMod(uint32_t value)
: value_m(value % Mod) {
}
template <uint32_t Mod>
IntMod<Mod>::IntMod(int64_t value) {
int32_t tmp = value % int64_t(Mod);
value_m = tmp >= 0 ? tmp : Mod - uint32_t(-tmp);
}
template <uint32_t Mod>
IntMod<Mod>::IntMod(uint64_t value)
: value_m(value % Mod) {
}
template <uint32_t Mod>
const IntMod<Mod>& IntMod<Mod>::operator+() const {
return *this;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::operator-() const {
IntMod<Mod> ret;
if (value_m == 0) {
ret.value_m = 0;
} else {
ret.value_m = Mod - value_m;
}
return ret;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator++() {
++value_m;
if (value_m == Mod) {
value_m = 0;
}
return *this;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator--() {
if (value_m == 0) {
value_m = Mod;
}
--value_m;
return *this;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::operator++(int dummy) {
IntMod ret(*this);
++*this;
return ret;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::operator--(int dummy) {
IntMod ret(*this);
--*this;
return ret;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator+=(const IntMod<Mod>& right) {
value_m += right.value_m; // note: value_m < 0x80000000
if (value_m >= Mod) {
value_m -= Mod;
}
return *this;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator-=(const IntMod<Mod>& right) {
if (value_m < right.value_m) {
value_m += Mod; // note: value_m < 0x80000000
}
value_m -= right.value_m;
return *this;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator*=(const IntMod<Mod>& right) {
value_m = (uint64_t(value_m) * right.value_m) % Mod;
return *this;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator/=(const IntMod<Mod>& right) {
*this *= right.inverse();
return *this;
}
// for power
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::operator[](uint64_t exp) const {
return power(exp);
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::add(const IntMod<Mod>& a, const IntMod<Mod>& b) {
IntMod<Mod> ret(a);
ret += b;
return ret;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::subtract(const IntMod<Mod>& a, const IntMod<Mod>& b) {
IntMod<Mod> ret(a);
ret -= b;
return ret;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::multiply(const IntMod<Mod>& a, const IntMod<Mod>& b) {
IntMod<Mod> ret(a);
ret *= b;
return ret;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::divide(const IntMod<Mod>& a, const IntMod<Mod>& b) {
IntMod<Mod> ret(a);
ret /= b;
return ret;
}
template <uint32_t Mod>
int IntMod<Mod>::compare(const IntMod<Mod>& a, const IntMod<Mod>& b) {
if (a.value_m < b.value_m) return -1;
if (a.value_m > b.value_m) return 1;
return 0;
}
/* Mod must be a prime. */
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::inverse() const {
assert(value_m != 0);
return power(Mod - 2);
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::power(uint64_t exp) const {
IntMod<Mod> product(1);
IntMod<Mod> factor(*this);
while (exp > 0) {
if (exp & 1) {
product *= factor;
}
factor *= factor;
exp >>= 1;
}
return product;
}
template <uint32_t Mod>
uint32_t IntMod<Mod>::get() const {
return value_m;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::fact(uint32_t num) {
assert(num <= 0x80000000);
static std::vector<IntMod<Mod>> table(1, 1);
if (table.size() > num) return table[num];
uint32_t old_size = table.size();
table.resize(num + 1);
for (uint32_t i = old_size; i <= num; ++i) {
table[i] = table[i - 1] * i;
}
return table[num];
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::invFact(uint32_t num) {
assert(num <= 0x80000000);
static std::vector<IntMod<Mod>> table(1, 1);
if (table.size() > num) return table[num];
uint32_t old_size = table.size();
table.resize(num + 1);
table[num] = fact(num).inverse();
for (uint32_t i = num; i >= old_size; --i) {
table[i - 1] = table[i] * i;
}
return table[num];
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::combi(uint32_t n, uint32_t r) {
assert(n >= r);
return fact(n) * invFact(n - r) * invFact(r);
}
template<uint32_t Mod>
IntMod<Mod> IntMod<Mod>::homcombi(uint32_t n, uint32_t r) {
assert(n != 0 || r == 0);
if (n == 0 && r == 0) return IntMod<Mod>(1);
return combi(n + r - 1, r);
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::perm(uint32_t n, uint32_t r) {
assert(n >= r);
return fact(n) / fact(n - r);
}
template <uint32_t Mod>
std::vector<IntMod<Mod>> IntMod<Mod>::calcInverseList(int max) {
assert(max < Mod);
std::vector<IntMod<Mod>> table(max + 1);
table[1] = 1;
for (int i = 2; i <= max; ++i) {
table[i] = (uint64_t(Mod - Mod / i) * table[Mod % i].get()) % Mod;
}
return table;
}
template <uint32_t Mod>
IntMod<Mod> operator+(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::add(a, b);
}
template <uint32_t Mod>
IntMod<Mod> operator-(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::subtract(a, b);
}
template <uint32_t Mod>
IntMod<Mod> operator*(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::multiply(a, b);
}
template <uint32_t Mod>
IntMod<Mod> operator/(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::divide(a, b);
}
template<uint32_t Mod, class Int>
IntMod<Mod> operator+(const IntMod<Mod>& a, const Int& b) {
return a + IntMod<Mod>(b);
}
template<uint32_t Mod, class Int>
IntMod<Mod> operator-(const IntMod<Mod>& a, const Int& b) {
return a - IntMod<Mod>(b);
}
template<uint32_t Mod, class Int>
IntMod<Mod> operator*(const IntMod<Mod>& a, const Int& b) {
return a * IntMod<Mod>(b);
}
template<uint32_t Mod, class Int>
IntMod<Mod> operator/(const IntMod<Mod>& a, const Int& b) {
return a / IntMod<Mod>(b);
}
template<uint32_t Mod, class Int>
IntMod<Mod> operator+(const Int& a, const IntMod<Mod>& b) {
return IntMod<Mod>(a) + b;
}
template<uint32_t Mod, class Int>
IntMod<Mod> operator-(const Int& a, const IntMod<Mod>& b) {
return IntMod<Mod>(a) - b;
}
template<uint32_t Mod, class Int>
IntMod<Mod> operator*(const Int& a, const IntMod<Mod>& b) {
return IntMod<Mod>(a) * b;
}
template<uint32_t Mod, class Int>
IntMod<Mod> operator/(const Int& a, const IntMod<Mod>& b) {
return IntMod<Mod>(a) / b;
}
template <uint32_t Mod>
bool operator==(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::compare(a, b) == 0;
}
template <uint32_t Mod>
bool operator!=(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::compare(a, b) != 0;
}
template <uint32_t Mod>
bool operator<(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::compare(a, b) < 0;
}
template <uint32_t Mod>
bool operator<=(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::compare(a, b) <= 0;
}
template <uint32_t Mod>
bool operator>(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::compare(a, b) > 0;
}
template <uint32_t Mod>
bool operator>=(const IntMod<Mod>& a, const IntMod<Mod>& b) {
return IntMod<Mod>::compare(a, b) >= 0;
}
template <uint32_t Mod, class Int>
bool operator==(const IntMod<Mod>& a, const Int& b) {
return a == IntMod<Mod>(b);
}
template <uint32_t Mod, class Int>
bool operator!=(const IntMod<Mod>& a, const Int& b) {
return a != IntMod<Mod>(b);
}
template <uint32_t Mod>
std::istream& operator>>(std::istream& ist, IntMod<Mod>& object) {
uint64_t value;
ist >> value;
object = IntMod<Mod>(value);
return ist;
}
template <uint32_t Mod>
std::ostream& operator<<(std::ostream& ost, const IntMod<Mod>& object) {
ost << object.get();
return ost;
}
#endif
#ifndef __BIT_H__
#define __BIT_H__
/* updated: 2019-10-03 */
#include <vector>
#include <cstdint>
class BinaryIndexedTree {
using T = uint64_t;
private:
const int size_m;
std::vector<T> arr_m;
static const int Default = -1;
public:
BinaryIndexedTree(int size);
void add(int pos, T increment);
T sum(int left) const;
T sum(int left, int right) const;
T get(int pos) const;
void debug(int size = Default) const;
};
#endif
#ifdef ONLY_MY_ENVIR
#include "BIT.h"
#endif
#include <cassert>
#include <iostream>
/* 長さ size の BIT を作成 */
BinaryIndexedTree::BinaryIndexedTree(int size)
: size_m(size), arr_m(size) {
}
/* pos 番目の要素を increment 増加させる O(log n) */
void BinaryIndexedTree::add(int pos, T increment) {
for (int i = pos; i != 0; i &= ~(-i)) {
arr_m[i] += increment;
}
arr_m[0] += increment;
}
/* [left, ∞) に存在する全要素の和をとる O(log n) */
BinaryIndexedTree::T BinaryIndexedTree::sum(int left) const {
if (left == 0) return arr_m[0]; // 0番目の要素は例外
T sum = T();
for (int i = left; i < size_m; i += i & -i) {
sum += arr_m[i];
}
return sum;
}
/* [left, right) に存在する全要素の和をとる O(log n) */
BinaryIndexedTree::T BinaryIndexedTree::sum(int left, int right) const {
assert(left <= right);
return sum(left) - sum(right);
}
/* pos 番目の要素を直接取得 O(log n) */
BinaryIndexedTree::T BinaryIndexedTree::get(int pos) const {
return sum(pos, pos + 1);
}
/* デバッグ出力用; size = -1 とすると全要素出力 */
void BinaryIndexedTree::debug(int size) const {
if (size == Default) { // デフォルト値への対処
size = size_m;
}
if (size > size_m) {
size = size_m;
}
std::cout << "{ ";
for (int i = 0; i < size; ++i) {
std::cout << arr_m[i] << ' ';
}
std::cout << "}" << std::endl;
}
#define _CRT_SECURE_NO_WARNINGS
#define _SCL_SECURE_NO_WARNINGS
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <utility>
#include <algorithm>
#include <functional>
#include <cmath>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <iomanip>
#include <sstream>
#include <bitset>
#include <limits>
#include <numeric>
#include <valarray>
#include <fstream>
#include <array>
#include <random>
#include <unordered_set>
#include <unordered_map>
using namespace std;
using uint = uint32_t;
using LL = int64_t;
using ULL = uint64_t;
using PP = pair<LL, LL>;
template <typename T> using PriorityQ = priority_queue<T, vector<T>, greater<T> >;
#define REP(i, a, n) for(LL i = (a), i##_max_ = (n); i < i##_max_; ++i)
#define REM(i, a, n) for(LL i = (LL)(n) - 1, i##_min_ = (a); i >= i##_min_; --i)
#define FLOAT fixed << setprecision(16)
#define SPEEDUP { cin.tie(NULL); ios::sync_with_stdio(false); }
const int INF = 0x3FFFFFFF;
const LL INFLL = 0x3FFFFFFF3FFFFFFF;
const double INFD = 1.0e+308;
const double EPS = 1.0e-9;
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
template <class T, class U> istream& operator>>(istream& ist, pair<T, U>& right) { return ist >> right.first >> right.second; }
template <class T, class U> ostream& operator<<(ostream& ost, const pair<T, U>& right) { return ost << right.first << ' ' << right.second; }
template <class T, class TCompatible, size_t N> void Fill(T(&dest)[N], const TCompatible& val) { fill(dest, dest + N, val); }
template <class T, class TCompatible, size_t M, size_t N> void Fill(T(&dest)[M][N], const TCompatible& val) { for (int i = 0; i < M; ++i) Fill(dest[i], val); }
template <class T> T Next() { T buf; cin >> buf; return buf; }
istream& Ignore(istream& ist) { string s; ist >> s; return ist; }
bool Inside(int i, int j, int h, int w) { return i >= 0 && i < h && j >= 0 && j < w; }
#ifdef ONLY_MY_ENVIR
#include "Accumulator.h"
#include "Algebraic.h"
#include "BinaryMatrix.h"
#include "BinaryTree.h"
#include "Bipartite.h"
#include "BIT.h"
#include "Compressor.h"
#include "Decompositions.h"
#include "DynamicMod.h"
#include "Factorization.h"
#include "FFT.h"
#include "FlowSolver.h"
#include "Graph.h"
#include "GraphUtil.h"
#include "IntMod.h"
#include "LazySegmentTree.h"
#include "LIS.h"
#include "Math.h"
#include "MathUtil.h"
#include "Matrix.h"
#include "MinCostFlowSolver.h"
#include "MinMax.h"
#include "Numbers.h"
#include "Optimize.h"
#include "Permutation.h"
#include "Polynomial.h"
#include "Position.h"
#include "Range.h"
#include "Rational.h"
#include "SegmentTree.h"
#include "SegmentTree2D.h"
#include "Sets.h"
#include "Shortest.h"
#include "SlidingWindow.h"
#include "SpanningTree.h"
#include "StringSearching.h"
#include "SuffixArray.h"
#include "Tree.h"
#include "TreeUtil.h"
#include "UnionFind.h"
#include "Util.h"
#include "VectorUtil.h"
#endif
#ifdef __GNUC__
typedef __int128 LLL;
istream& operator>>(istream& ist, __int128& val) { LL tmp; ist >> tmp; val = tmp; return ist; }
ostream& operator<<(ostream& ost, __int128 val) { LL tmp = val; ost << tmp; return ost; }
#endif
int N;
int P[500000];
int main() {
cin >> N;
REP(i, 0, N) {
cin >> P[i];
--P[i];
}
vector<int> is_hole(N, 1);
REP(i, 0, N) {
if (P[i] != -1) {
is_hole[P[i]] = 0;
}
}
const int holes = count(is_hole.begin(), is_hole.end(), 1);
const MInt half = MInt(2).inverse();
const MInt holesInv = holes == 0 ? 0 : MInt(holes).inverse();
vector<int> accum(N + 1, 0);
partial_sum(is_hole.begin(), is_hole.end(), accum.begin() + 1);
MInt X = 0;
MInt Y = 1;
REP(i, 0, N) {
if (is_hole[i]) X += i;
}
if (holes > 0) X /= holes;
BinaryIndexedTree bit(N);
REP(i, 0, N) bit.add(i, !is_hole[i]);
int holes_rem = holes;
MInt ans = 0;
REP(i, 0, N) {
if (P[i] == -1) {
ans += X * MInt::fact(N - 1 - i);
X -= half;
Y -= holesInv;
--holes_rem;
} else {
int A = bit.sum(0, P[i]);
int B = accum[P[i]];
ans += (A + Y * B) * MInt::fact(N - 1 - i);
X -= (accum[N] - accum[P[i]]) * holesInv;
bit.add(P[i], -1);
}
}
cout << (ans + 1) * MInt::fact(holes) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef int _loop_int;
#define REP(i,n) for(_loop_int i=0;i<(_loop_int)(n);++i)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a);i<(_loop_int)(b);++i)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1;i>=(_loop_int)(a);--i)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define CHMIN(a,b) a=min((a),(b))
#define CHMAX(a,b) a=max((a),(b))
// mod
const ll MOD = 1000000007ll;
#define FIX(a) ((a)%MOD+MOD)%MOD
// floating
typedef double Real;
const Real EPS = 1e-11;
#define EQ0(x) (abs(x)<EPS)
#define EQ(a,b) (abs(a-b)<EPS)
typedef complex<Real> P;
int n,m,a,b;
int d[2521];
int main(){
scanf("%d%d%d%d",&n,&m,&a,&b);
REP(i,n)scanf("%d",d+i);
vi trash;
REP(i,n){
if(d[i]<a)break;
trash.push_back(d[i]);
}
if(n-trash.size()<m){
while(trash.size()){
if(trash.back()<=b){
trash.pop_back();
}else{
break;
}
}
}
printf("%d\n", trash.size());
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int map1[410][410], map2[410][410];
int n, m;
void dijkstra(int map[][410]) {
int res[410];
int vis[410];
int v, min;
for (int i = 1; i <= n; i++) {
vis[i] = 0;
res[i] = map[1][i];
}
for (int i = 1; i <= n; i++) {
min = 1 << 29;
for (int j = 1; j <= n; j++) {
if (vis[j] == 0 && res[j] < min) {
v = j;
min = res[j];
}
}
vis[v] = 1;
for (int j = 1; j <= n; j++) {
if (vis[j] == 0 && res[j] > map[v][j] + res[v]) {
res[j] = map[v][j] + res[v];
}
}
}
if (res[n] == 1 << 29) {
printf("-1\n");
return;
} else
printf("%d\n", res[n]);
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) {
map1[i][j] = 0;
map1[i][j] = 0;
} else {
map1[i][j] = map1[j][i] = 1 << 29;
map2[i][j] = map2[j][i] = 1 << 29;
}
}
}
int flag = 0;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
if ((a == 1 && b == n) || (a == n && b == 1)) {
flag = 1;
}
map1[a][b] = 1;
map1[b][a] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (map1[i][j] == 1 << 29 || map1[i][j] == 0) {
map2[i][j] = 1;
map2[j][i] = 1;
}
}
}
if (m == n * (n - 1) / 2) {
printf("-1\n");
continue;
}
if (flag == 1) {
dijkstra(map2);
} else if (flag == 0) {
dijkstra(map1);
}
}
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int n;
int tmap[101][101] = {0};
for(;;){
cin>>n;
if(!n) break;
int w,h;
cin>>w>>h;
for(int i=1; i<=100; i++)
for(int j=1; j<=100; j++)
tmap[i][j] = 0;
int x,y;
for(int i=0; i<n; i++){
cin>>x>>y;
tmap[x][y]=1;
}
int s,t;
cin>>s>>t;
int max=0,tmp=0;
for(int i=1; i<=w-s+1; i++){
for(int j=1; j<=h-t+1; j++){
for(int k=i; k <= i+s-1; k++){
for(int l=j; l <= j+t-1; l++){
if(tmap[k][l] == 1) tmp++;
}
}
if(tmp > max) max = tmp;
tmp=0;
}
}
cout<<max<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ln, s, t, x, y, ans = 1e9;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> ln >> s >> t;
cin >> x >> y;
ans = abs(s - t) * y;
int a, b;
cin >> a >> b;
if (s <= t) {
if (a <= s)
ans = min(ans, (t - a) * x + (b < 0 ? 2 * a * x : 0));
else {
if (s < a && a <= t) {
if (b < 0)
ans = min(ans, (t - a) * x + 2 * a * x);
else
ans = min(ans, 2 * ln * x + (t - a) * x);
} else {
ans =
min(ans, (b < 0 ? 0 : (ln - a) * 2 * x) + a * 2 * x - (a - t) * x);
}
}
} else {
if (a >= s)
ans = min(ans, (a - t) * x + (b > 0 ? 2 * (ln - a) * x : 0));
else {
if (t <= a && a <= s) {
if (b > 0)
ans = min(ans, (a - t) * x + 2 * (ln - a) * x);
else
ans = min(ans, 2 * ln * x + (a - t) * x);
} else {
ans =
min(ans, (b > 0 ? 0 : a * 2 * x) + (ln - a) * 2 * x - (t - a) * x);
}
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
const int N = 10000007;
const long long MOD = 1000000007;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
void init() {
cin.tie(0);
cin.sync_with_stdio(0);
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort((a).begin(), (a).end());
vector<long long> ans(n);
int j = n - 1;
for (int i = 0; i < n; i += 2) ans[i] = a[j--];
j = 0;
for (int i = 1; i < n; i += 2) ans[i] = a[j++];
cout << n / 2 - (n % 2 == 0) << "\n";
for (auto a : ans) cout << a << " ";
}
int main() { solve(); }
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626433;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long N = 1e5 + 5, p = 1e9 + 7;
long long n, a[N], ans[N], q, rnk, pw[N];
vector<pair<long long, long long> > v[N];
vector<long long> basis;
void add(long long x) {
for (long long bit = (20 - 1); bit >= 0; bit--) {
if (x == 0) break;
if ((x & (1LL << bit)) != 0) {
if (basis[bit] == -1) {
basis[bit] = x;
rnk++;
break;
} else
x ^= basis[bit];
}
}
}
bool chk(long long x) {
for (long long bit = (20 - 1); bit >= 0; bit--) {
if (x == 0) return 1;
if ((x & (1LL << bit)) != 0) {
if (basis[bit] == -1)
return 0;
else
x ^= basis[bit];
}
}
return 1;
}
void func() {
cin >> n >> q;
for (long long i = 1; i < n + 1; i++) cin >> a[i];
for (long long i = 1; i < q + 1; i++) {
long long l, x;
cin >> l >> x;
v[l].emplace_back(x, i);
}
pw[0] = 1;
for (long long i = 1; i < N; i++) pw[i] = (pw[i - 1] * 2) % p;
basis.resize(20, -1);
for (long long i = 1; i < n + 1; i++) {
add(a[i]);
for (auto query : v[i]) {
if (!chk(query.first))
ans[query.second] = 0;
else
ans[query.second] = pw[i - rnk];
}
}
for (long long i = 1; i < q + 1; i++) cout << ans[i] << "\n";
}
int main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long ntc = 1;
for (long long i = 1; i < ntc + 1; i++) {
func();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, par[maxn], fen[maxn];
map<char, int> vowel;
int get(int val, int idx) {
int now = 0;
for (int i = 20; i >= 0; i--) {
if (now + (1 << i) > n + 1) continue;
if (val < fen[now + (1 << i)]) now += (1 << i);
}
return idx - now;
}
void add(int idx, int val) {
idx++;
for (; idx <= n + 1; idx += idx & -idx) fen[idx] = min(fen[idx], val);
}
int main() {
ios_base::sync_with_stdio(false);
memset(fen, 63, sizeof fen);
string s;
cin >> s;
n = s.size();
vowel['A'] = vowel['a'] = vowel['O'] = vowel['o'] = vowel['E'] = vowel['e'] =
vowel['U'] = vowel['u'] = vowel['I'] = vowel['i'] = 1;
for (int i = 1; i <= n; i++) {
if (vowel[s[i - 1]] == 1)
par[i] = -1;
else
par[i] = 2;
par[i] += par[i - 1];
}
int mx = -1;
add(0, 0);
for (int i = 1; i <= n; i++) {
if (par[i] >= 0)
mx = i;
else
mx = max(mx, get(par[i], i));
add(i, par[i]);
}
if (mx == -1) return cout << "No solution\n", 0;
cout << mx << " ";
int cnt = 0;
for (int i = mx; i <= n; i++)
if (par[i] - par[i - mx] >= 0) cnt++;
cout << cnt << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1e9 + 7;
const ll INF = 1e18 + 3;
ll power(ll x, ll y) {
ll res = 1;
x %= MOD;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1, x = (x * x) % MOD;
}
return res;
}
void pre();
void solve();
void post();
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
pre();
for (int tst = 1; tst <= t; tst++) {
solve();
post();
}
}
void pre() {}
ll n, L;
ld d[100005];
bool chk(ld x) {
ld d1 = 0, t1 = 0, s = 1;
for (int i = 1; i <= n + 1; i++) {
if ((d[i] - d1) / s + t1 >= x) {
d1 += (x - t1) * s;
break;
}
t1 += (d[i] - d1) / s;
s += 1;
d1 = d[i];
}
ld d2 = 0, t2 = 0, pre = L;
s = 1;
for (int i = n; i >= 0; i--) {
if ((pre - d[i]) / s + t2 >= x) {
d2 += (x - t2) * s;
break;
}
t2 += (pre - d[i]) / s;
s += 1;
d2 += pre - d[i];
pre = d[i];
}
return d1 + d2 - L > 1e-6;
}
void solve() {
cin >> n >> L;
for (int i = 1; i <= n; i++) cin >> d[i];
d[0] = 0;
d[n + 1] = L + 1;
ld l = 0, r = 1e9;
for (int i = 0; i < 50; i++) {
if (r < l) break;
ld mid = (l + r) / 2;
if (chk(mid))
r = mid;
else
l = mid;
}
cout << fixed << setprecision(12) << l << "\n";
}
void post() {}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 9;
long long ModExp(long long base, long long power) {
if (power == 0) return 1;
if (power == 1) return base % MOD;
if (power % 2) {
return (base * ModExp(base, power - 1)) % MOD;
} else {
long long intermediate = ModExp(base, power / 2) % MOD;
return (intermediate * intermediate) % MOD;
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
long long X = max(0, m - n / k * (k - 1) - n % k);
long long powered = (MOD + (ModExp(2, X + 1) - 2) * k + m - X * k) % MOD;
cout << powered << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct edge {
int to, next;
} G[maxn << 1];
int n, head[maxn], tot, cnt, clk, dfn[maxn];
tuple<int, int, int> ans[maxn];
void init() {
memset(head, -1, sizeof(head));
tot = cnt = clk = 0;
}
void addedge(int u, int v) {
G[tot].to = v;
G[tot].next = head[u];
head[u] = tot++;
G[tot].to = u;
G[tot].next = head[v];
head[v] = tot++;
}
int dfs(int u, int fa) {
dfn[u] = ++clk;
int now = 0;
for (int i = head[u]; ~i; i = G[i].next) {
int v = G[i].to;
if (v == fa) continue;
if (!dfn[v]) {
int w = dfs(v, u);
if (w == v) {
if (now) {
ans[cnt++] = make_tuple(now, u, v);
now = 0;
} else
now = v;
} else if (v) {
ans[cnt++] = make_tuple(u, v, w);
}
} else if (dfn[v] < dfn[u]) {
if (now) {
ans[cnt++] = make_tuple(now, u, v);
now = 0;
} else
now = v;
}
}
return now ? now : u;
}
int main() {
init();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) dfs(i, 0);
printf("%d\n", cnt);
for (int i = 0; i < cnt; ++i) {
int u, v, w;
tie(u, v, w) = ans[i];
printf("%d %d %d\n", u, v, w);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int n;
vector<char> vec;
void input();
void solve() {
n = a.size();
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) continue;
if (vec.size() == 0) {
vec.push_back(a[i]);
continue;
}
if (vec.back() != a[i]) {
vec.pop_back();
ans++;
} else {
vec.push_back(a[i]);
}
}
ans += vec.size();
cout << ans << "\n";
}
void Clear() {}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
input();
solve();
Clear();
}
void input() { cin >> a >> b; }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (scanf("%d", &n) == 1) {
int a[8];
memset(a, 0, sizeof(a));
int t;
for (int i = 0; i < n; ++i) {
scanf("%d", &t);
a[t]++;
}
int b[3][3] = {1, 2, 4, 1, 3, 6, 1, 2, 6};
int type[3];
type[0] = a[4];
type[1] = a[3];
type[2] = a[2] - a[4];
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
a[b[i][j]] -= type[i];
}
}
for (t = 1; t <= 7; ++t)
if (a[t] != 0) break;
if (t < 8 || type[2] < 0)
puts("-1");
else {
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < type[i]; ++j)
printf("%d %d %d\n", b[i][0], b[i][1], b[i][2]);
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, l = 0, z, k = 0;
cin >> n >> m;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
while (a[i] > 0) {
z = a[i] % 10;
a[i] = a[i] / 10;
if (z == 4 || z == 7) k++;
}
if (k <= m) l++;
k = 0;
}
cout << l << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x[510];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); ++i) {
scanf("%d", &x[i]);
}
double res = 0;
for (int i = (0); i < (m); ++i) {
int v1, v2, c;
scanf("%d%d%d", &v1, &v2, &c);
double now = x[v1 - 1] + x[v2 - 1];
res = ((res < now / c) ? (now / c) : (res));
}
printf("%.15lf\n", res);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,d,p[1000]={},f=0,ans=0;
cin>>N>>d;
for(int i=0;i<N;i++)cin>>p[i];
for(int i=0;i<N;i++)if(p[i]>d)ans+=p[i]-d;
if(ans>0)cout<<ans<<endl;
else cout<<"kusoge"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int MR = 2e5 + 10;
int res[MR];
int main() {
int n, m, d;
scanf("%d%d%d", &n, &m, &d);
vector<pair<int, int> > V;
for (int i = 0; i < (n); ++i) {
int a;
scanf("%d", &a);
V.push_back(make_pair(a, i));
}
sort(V.begin(), V.end());
set<pair<int, int> > S;
for (const auto &p : V) {
int a = p.first;
auto it = S.upper_bound(make_pair(a, MR));
if (it == S.begin()) {
res[p.second] = S.size() + 1;
S.insert(make_pair(a + 1 + d, S.size() + 1));
} else {
auto tmp = *S.begin();
S.erase(tmp);
res[p.second] = tmp.second;
tmp.first = a + 1 + d;
S.insert(tmp);
}
}
printf("%d\n", S.size());
for (int i = 0; i < (n); ++i) printf("%d ", res[i]);
printf("\n");
return 0;
}
| 3 |
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
using namespace std;
#define ISEQ(c) (c).begin(), (c).end()
typedef long long ll;
typedef pair<int, int> P;
int board[100][100];
int num[100][100];
int m = 50;
map<P, int> memo;
void calc(int t, int f, int x, int y) {
P p = P(t,f);
bool flag = false;
for (int i = 6; i > 3 and !flag; i--) {
if (f == i and board[x][y] > board[x][y-1]) {
flag = true;
calc(7-i, t, x, y-1);
} else if (f == 7-i and board[x][y] > board[x][y+1]) {
flag = true;
calc(7-i, 7-t, x, y+1);
} else if (memo[p] == i and board[x][y] > board[x+1][y]) {
flag = true;
calc(7-i, f, x+1, y);
} else if (memo[p] == 7-i and board[x][y] > board[x-1][y]) {
flag = true;
calc(7-i, f, x-1, y);
}
}
if(!flag) {
board[x][y]++;
num[x][y] = t;
}
}
int main() {
memo[P(1,2)] = 3;
memo[P(1,3)] = 5;
memo[P(1,4)] = 2;
memo[P(1,5)] = 4;
memo[P(2,1)] = 4;
memo[P(2,3)] = 1;
memo[P(2,4)] = 6;
memo[P(2,6)] = 3;
memo[P(3,1)] = 2;
memo[P(3,2)] = 6;
memo[P(3,5)] = 1;
memo[P(3,6)] = 5;
memo[P(4,1)] = 5;
memo[P(4,2)] = 1;
memo[P(4,5)] = 6;
memo[P(4,6)] = 2;
memo[P(5,1)] = 3;
memo[P(5,3)] = 6;
memo[P(5,4)] = 1;
memo[P(5,6)] = 4;
memo[P(6,2)] = 4;
memo[P(6,3)] = 2;
memo[P(6,4)] = 5;
memo[P(6,5)] = 3;
while (true) {
int n;
cin >> n;
if(!n) break;
for (int i = 0; i < 100; i++)
for (int j = 0; j < 100; j++) {
board[i][j] = 0;
num[i][j] = 0;
}
for (int i = 0; i < n; i++) {
int t, f;
cin >> t >> f;
calc(t, f, m, m);
}
int res[7] = {};
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
res[num[i][j]]++;
}
}
for (int i = 1; i < 6; i++)
cout << res[i] << " ";
cout << res[6] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400, mod = 998244353;
int n, ans;
int f[maxn + 10][maxn + 10][maxn + 10];
int fac[maxn + 10], ifac[maxn + 10], inv, sum;
int a[maxn + 10], b[maxn + 10], p[maxn + 10];
inline void addto(int &x, int y) {
x += y; if (x >= mod) x -= mod;
}
inline void decto(int &x, int y) {
x -= y; if (x < 0) x += mod;
}
inline int mul(int x, int y) {
return 1ll * x * y % mod;
}
inline int fpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x);
y >>= 1; x = mul(x, x);
}
return ans;
}
void init() {
fac[0] = ifac[0] = 1;
for (int i = 1; i <= maxn; ++i) {
fac[i] = mul(fac[i - 1], i);
ifac[i] = fpow(fac[i], mod - 2);
}
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i], &b[i]); sum += a[i];
}
inv = fpow(sum, mod - 2);
for (int i = 1; i <= n; ++i) p[i] = mul(a[i], inv);
f[0][0][0] = mod - 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= maxn; ++j)
for (int k = 0; k <= maxn; ++k)
if (f[i][j][k]) {
addto(f[i + 1][j][k], f[i][j][k]);
for (int l = 0, pw = 1; l < b[i + 1]; ++l) {
decto(f[i + 1][j + l][k + a[i + 1]], mul(f[i][j][k], mul(pw, ifac[l])));
pw = mul(pw, a[i + 1]);
}
}
}
for (int i = 0; i <= maxn; ++i)
for (int j = 1; j <= maxn; ++j)
if (f[n][i][j]) {
int inv = fpow(j, mod - 2);
addto(ans, mul(f[n][i][j], mul(fac[i], mul(sum, fpow(inv, i + 1)))));
}
printf("%d", ans);
}
| 0 |
#include<iostream>
#include<climits>
int check(int*,int);
int n, k;
int main(){
std::cin >> n >> k;
int W[n];
for(int i=0; i<n; i++) std::cin >> W[i];
int l=0, r=INT_MAX, m; // solve
while(r-l>1){ // *
m = (r + l) / 2; // *
int v = check(W, m); // *
v >= n ? r = m : l = m; // *
} // end
std::cout << r << std::endl;
return 0;
}
int check(int *W,int p){
int i=0;
for(int j=0; j<k; j++){
int s=0;
while(s+W[i] <= p){
s += W[i];
i++;
if(i == n) return n;
}
}
return i;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
int cha, num;
} a[100005];
struct node_cha {
int val, num;
int ans;
} cha[100005];
int cmp1(node_cha x, node_cha y) {
if (x.val == y.val) {
return x.num < y.num;
}
return x.val < y.val;
}
int cmp(node x, node y) {
if (x.cha == y.cha) {
return x.x < y.x;
}
return x.cha < y.cha;
}
int cmp2(node_cha x, node_cha y) { return x.num < y.num; }
int cmp3(node x, node y) { return x.num < y.num; }
int main() {
int n, u, v;
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) {
scanf("%d%d", &u, &v);
a[i].x = u;
a[i].y = v;
a[i].num = i;
a[i].cha = v - u;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &cha[i].val);
cha[i].num = i;
}
sort(a + 1, a + 1 + n, cmp);
sort(cha + 1, cha + 1 + n, cmp1);
for (int i = 1; i <= n; i++) {
cha[i].ans = a[i].num;
}
sort(cha + 1, cha + 1 + n, cmp2);
sort(a + 1, a + 1 + n, cmp3);
int flag = 0;
int xpre = -100000;
int ypre = -100000;
int x, y;
for (int i = 1; i <= n; i++) {
x = a[cha[i].ans].x;
y = a[cha[i].ans].y;
if (y - x != cha[i].val) flag = 1;
if (x <= xpre && y <= ypre) {
flag = 1;
xpre = x;
ypre = y;
continue;
} else {
xpre = x;
ypre = y;
}
}
if (flag)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= n; i++) {
x = a[cha[i].ans].x;
y = a[cha[i].ans].y;
printf("%d %d\n", x, y);
}
}
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int H,R;
cin>>H>>R;
if(H + R > 0) cout<<"1"<<endl;
else if(H + R == 0) cout<<"0"<<endl;
else if(H + R < 0) cout<<"-1"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long N = 300300;
const long long Q = 200200;
const long long mod = 998244353;
const long long MAGIC = sqrt(N);
using namespace std;
int n;
long long k;
long long a[N];
map<int, int> d[12];
void solve() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
long long x = a[i] % k;
for (int j = 1; j < 11; j++) {
x = x * 10 % k;
d[j][x]++;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long g = 0, x = a[i];
while (x > 0) {
g++;
x /= 10;
}
x = a[i] % k;
if (d[g].find((k - x) % k) != d[g].end()) {
ans += d[g][(k - x) % k];
}
for (int j = 0; j < g; j++) {
x = x * 10 % k;
}
x = (x + a[i]) % k;
ans -= (x == 0);
}
cout << ans << "\n";
}
bool mtest = false;
int main() {
ios_base::sync_with_stdio(0);
int TE = 1;
if (mtest) cin >> TE;
while (TE--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace FGF {
int n, m;
char s[10];
const int N = (1 << 24) + 5;
long long f[N];
int popcnt(int x) {
int s = 0;
while (x) x -= x & (-x), s++;
return s;
}
void work() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int d = 0;
scanf("%s", s);
for (int j = 0; j < 3; j++) d |= (1 << (s[j] - 'a'));
for (int j = d; j; j = d & (j - 1))
if (popcnt(j) & 1)
f[j]++;
else
f[j]--;
}
for (int i = 0; i < 24; i++)
for (int j = 0; j < (1 << 24); j++)
if ((j >> i) & 1) f[j] += f[j ^ (1 << i)];
long long ans = 0;
for (int i = 0; i < (1 << 24); i++) ans ^= f[i] * f[i];
printf("%lld", ans);
}
} // namespace FGF
int main() {
FGF::work();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
const int N = 200005;
struct node {
int sum;
int cnt;
} fake;
struct SEGTREE {
long long a[N];
SEGTREE() { memset(a, 0, sizeof(a)); }
node tree[4 * N];
inline node combine(node a, node b) {
node ret;
ret.sum = a.sum + b.sum;
ret.cnt = a.cnt + b.cnt;
return ret;
}
inline node make_node(int x = 0, int y = 0) {
node ret;
ret.sum = x;
ret.cnt = y;
return ret;
}
void buildTree(long long v, long long st, long long en) {
if (st == en) {
tree[v] = make_node();
return;
}
long long mid = (st + en) >> 1;
buildTree(v << 1, st, mid);
buildTree(v << 1 | 1, mid + 1, en);
tree[v] = combine(tree[v << 1], tree[v << 1 | 1]);
}
void update(long long v, long long st, long long en, long long in,
long long val) {
long long mid = (st + en) >> 1;
if (st == en) {
tree[v] = make_node(val, 1);
return;
}
if (in <= mid)
update(v << 1, st, mid, in, val);
else
update(v << 1 | 1, mid + 1, en, in, val);
tree[v] = combine(tree[v << 1], tree[v << 1 | 1]);
}
int query(long long v, long long st, long long en, long long val) {
if (val == 0) return 0;
if (st == en) return tree[v].sum;
int mid = (st + en) >> 1;
if (tree[v << 1].cnt >= val)
return query(v << 1, st, mid, val);
else
return tree[v << 1].sum +
query(v << 1 | 1, mid + 1, en, val - tree[v << 1].cnt);
}
} seg;
vector<pair<int, int>> same, one, two, none;
vector<pair<int, int>> id;
int n, m, k;
int findI(pair<int, int> &val) {
auto it = lower_bound(id.begin(), id.end(), val) - id.begin();
return it;
}
int _runtimeTerror_() {
cin >> n >> m >> k;
int ans = 2e9 + 100;
for (int i = 1; i <= n; ++i) {
int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1)
same.push_back({t, i});
else if (a == 1)
one.push_back({t, i});
else if (b == 1)
two.push_back({t, i});
else
none.push_back({t, i});
id.push_back({t, i});
}
sort(id.begin(), id.end());
sort(none.begin(), none.end());
sort(same.begin(), same.end());
sort(one.begin(), one.end());
sort(two.begin(), two.end());
int x = min({(int)one.size(), (int)two.size(), k});
seg.buildTree(1, 0, n - 1);
int sum1 = 0, sum2 = 0;
for (int i = 0; i < x; ++i) sum1 += one[i].first, sum2 += two[i].first;
for (auto k : none) {
int it = findI(k);
seg.update(1, 0, n - 1, it, k.first);
}
int idx = -1;
for (int i = x; i < (int)one.size(); ++i) {
auto it = findI(one[i]);
seg.update(1, 0, n - 1, it, one[i].first);
}
for (int i = x; i < (int)two.size(); ++i) {
auto it = findI(two[i]);
seg.update(1, 0, n - 1, it, two[i].first);
}
int cur = x - 1;
int $ = min((int)same.size(), m);
int sum = 0, kitne = 0;
for (int i = 0; i <= $; ++i) {
if (cur + 1 + i >= k) {
while (cur >= 0 && cur + i + 1 > k) {
auto it = findI(two[cur]);
seg.update(1, 0, n - 1, it, two[cur].first);
it = findI(one[cur]);
seg.update(1, 0, n - 1, it, one[cur].first);
sum1 -= one[cur].first;
sum2 -= two[cur].first;
--cur;
}
if (i + 2 * (cur + 1) <= m && i + 2 * (cur + 1) + seg.tree[1].cnt >= m) {
int val =
sum + sum1 + sum2 + seg.query(1, 0, n - 1, m - i - 2 * (cur + 1));
if (val < ans) ans = val, idx = i, kitne = cur + 1;
}
}
if (i != $) sum += same[i].first;
}
if (ans == 2e9 + 100) {
cout << "-1\n";
return 0;
}
cout << ans << '\n';
vector<int> print;
for (int i = 0; i < idx; ++i) print.push_back(same[i].second);
for (int i = 0; i < kitne; ++i)
print.push_back(one[i].second), print.push_back(two[i].second);
for (auto k : print) cout << k << " ";
int fuck = m - (int)print.size();
for (int i = kitne; i < (int)one.size(); ++i) none.push_back(one[i]);
for (int i = kitne; i < (int)two.size(); ++i) none.push_back(two[i]);
sort(none.begin(), none.end());
for (int i = 0; i < fuck; ++i) cout << none[i].second << ' ';
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long n;
cin >> n;
long long ans = 0;
while (n % 5 == 0) {
n = n / 5 * 4;
ans++;
}
while (n % 3 == 0) {
n = n / 3 * 2;
ans++;
}
while (n % 2 == 0) {
n = n / 2;
ans++;
}
if (n != 1) ans = -1;
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 11;
int n, kkk;
char s[MAXN];
long long mini[MAXN][MAXN];
int lowerb[(1 << 10) + 1][MAXN];
int upperb[(1 << 10) + 1][MAXN];
inline void init() {
int num[MAXN];
for (int mask = 0; mask < (1 << 10); mask++) {
int sz = 0;
for (int i = 0; i <= 9; i++)
if ((mask >> i) & 1) num[sz++] = i;
for (int i = 0; i <= 9; i++) {
lowerb[mask][i] = lower_bound(num, num + sz, i) - num;
upperb[mask][i] = upper_bound(num, num + sz, i) - num;
}
}
for (int i = 0; i <= 9; i++)
for (int j = 1, base = 1; j <= 9; j++, base *= 10)
mini[i][j] = mini[i][j - 1] + (long long)i * base;
}
map<int, map<int, long long> > mmp;
inline void solve() {
scanf("%s%d", s + 1, &kkk);
n = strlen(s + 1);
reverse(s + 1, s + n + 1);
int val = 0;
for (int i = 1, base = 1; i <= n; i++, base *= 10) val += (s[i] - '0') * base;
if (mmp[val][kkk]) {
printf("%lld\n", mmp[val][kkk]);
return;
}
long long ans = 1e18;
int num[MAXN];
for (int mask = 0; mask < (1 << 10); mask++) {
int sz = 0;
for (int i = 0; i <= 9; i++)
if ((mask >> i) & 1) num[sz++] = i;
if (sz == 0 || sz > kkk) continue;
if (num[sz - 1] < s[n] - '0') continue;
bool fg = false;
long long cur = 0;
for (int i = 1, base = 1; i <= n; i++, base *= 10) {
int x = s[i] - '0';
int pos = lowerb[mask][x];
if (pos == sz) {
fg = true;
continue;
}
if (!fg) {
if (num[pos] == x)
cur += (long long)num[pos] * base;
else
cur = mini[num[0]][i - 1] + (long long)num[pos] * base;
} else {
if (num[pos] == x) {
pos = upperb[mask][x];
if (pos == sz) continue;
}
cur = mini[num[0]][i - 1] + (long long)num[pos] * base, fg = false;
}
}
if (!fg) ans = min(ans, cur);
if (ans == val) break;
}
printf("%lld\n", mmp[val][kkk] = ans);
}
int main() {
init();
int T;
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
char bl = s[i];
int bd = 0;
for (char p = 'a'; p <= 'z'; p++) {
int d = abs(p - s[i]);
if (d <= k && (d > bd)) {
bd = d;
bl = p;
}
}
k -= bd;
s[i] = bl;
}
if (k > 0)
cout << "-1";
else
cout << s;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
int vis[MAX + MAX];
int n;
string s;
bool check(int mid) {
memset(vis, 0, sizeof(vis));
int now = 0;
vis[now + n]++;
for (auto &c : s) {
int cur = 1;
if (c == 'L') cur = -1;
now += cur;
vis[now + n]++;
if (now == mid) now -= cur;
}
return (vis[now + n] == 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.size();
int now = 0;
vis[now + n]++;
for (auto &c : s) {
int cur = 1;
if (c == 'L') cur = -1;
now += cur;
vis[now + n]++;
}
if (vis[now + n] == 1) return cout << 1 << "\n", 0;
int l = 1, r = n;
int idx = 0, ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
idx = mid, l = mid + 1;
else
r = mid - 1;
}
ans += idx;
l = -n, r = -1;
idx = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
idx = mid, r = mid - 1;
else
l = mid + 1;
}
ans += abs(idx);
return cout << ans << "\n", 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N=305;
int n,m,mod,f[N][N],sum[N][N],C[N][N];
int main(){
scanf("%d%d%d",&n,&m,&mod);
C[0][0]=1;
for(int i=1;i<=300;C[i++][0]=1)
for(int j=1;j<=i;j++)
C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
for(int i=0;i<=m;i++)f[1][i]=1;
sum[1][0]=f[1][0];
for(int i=1;i<=m;i++)sum[1][i]=(sum[1][i-1]+f[1][i])%mod;
for(int i=2;i<=n+1;i++){
for(int j=0;j<=m;j++){
for(int k=1;k<i;k++){
f[i][j]=(f[i][j]+1ll*C[i-2][k-1]*(sum[k][m]-sum[k][j])%mod*f[i-k][j])%mod;
}
}
sum[i][0]=f[i][0];
for(int j=1;j<=m;j++)sum[i][j]=(sum[i][j-1]+f[i][j])%mod;
}
cout<<(f[n+1][0]+mod)%mod<<"\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll k, d, t;
scanf("%lld%lld%lld", &k, &d, &t);
ll on = k;
ll off = ((k + d - 1) / d) * d - k;
t *= 2;
ll turns = t / (2 * on + off);
t -= turns * (2 * on + off);
ll left = min(t, 2 * on);
t -= left;
ll total2 = 2 * turns * (on + off) + left + 2 * t;
printf("%lld.%lld\n", total2 / 2, (total2 & 1) * 5);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void zanj0() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
pair<long long int, long long int> move(pair<long long int, long long int>& p,
pair<long long int, long long int>& q) {
p.first -= q.first;
p.second -= q.second;
long long int first = -p.second;
long long int second = p.first;
p.first = first;
p.second = second;
p.first += q.first;
p.second += q.second;
return p;
}
long long int distSq(const pair<long long int, long long int>& p,
const pair<long long int, long long int>& q) {
return (p.first - q.first) * (p.first - q.first) +
(p.second - q.second) * (p.second - q.second);
}
bool isSquare(const pair<long long int, long long int>& p1,
const pair<long long int, long long int>& p2,
const pair<long long int, long long int>& p3,
const pair<long long int, long long int>& p4) {
long long int d2 = distSq(p1, p2);
long long int d3 = distSq(p1, p3);
long long int d4 = distSq(p1, p4);
if (d2 == 0 || d3 == 0 || d4 == 0) return false;
if (d2 == d3 && 2 * d2 == d4 && 2 * distSq(p2, p4) == distSq(p2, p3)) {
return true;
}
if (d3 == d4 && 2 * d3 == d2 && 2 * distSq(p3, p2) == distSq(p3, p4)) {
return true;
}
if (d2 == d4 && 2 * d2 == d3 && 2 * distSq(p2, p3) == distSq(p2, p4)) {
return true;
}
return false;
}
void out2(pair<long long int, long long int> a) {
cout << a.first << " -- " << a.second << " ";
}
void out3(vector<pair<long long int, long long int> >& v) {
for (auto& it : v) {
out2(it);
}
cout << "\n";
}
void permute(
long long int idx, vector<pair<long long int, long long int> > v,
vector<vector<pair<long long int, long long int> > >& allPossible) {
if (idx >= v.size()) {
allPossible.push_back(v);
return;
}
for (long long int i = idx; i < v.size(); i++) {
swap(v[idx], v[i]);
permute(idx + 1, v, allPossible);
swap(v[idx], v[i]);
}
}
long long int getVal(vector<pair<long long int, long long int> > v[4]) {
long long int ret = 1e18;
for (long long int i = 0; i < 4; i++) {
for (long long int j = 0; j < 4; j++)
for (long long int k = 0; k < 4; k++) {
for (long long int l = 0; l < 4; l++) {
vector<pair<long long int, long long int> > all;
all.push_back(v[0][i]);
all.push_back(v[1][j]);
all.push_back(v[2][k]);
all.push_back(v[3][l]);
vector<vector<pair<long long int, long long int> > > allPossible;
permute(0, all, allPossible);
long long int val = i + j + k + l;
for (auto& it : allPossible) {
if (isSquare(it[0], it[1], it[2], it[3])) {
ret = min(ret, val);
}
}
}
}
}
return ret;
}
void out(vector<pair<long long int, long long int> > v[]) {
for (long long int i = 0; i < 4; i++) {
for (auto& it : v[i]) {
cout << it.first << " -- " << it.second << " ";
}
cout << "\n";
}
}
long long int calculate(vector<pair<long long int, long long int> >& points,
vector<pair<long long int, long long int> >& home) {
long long int ret = 1e18;
vector<pair<long long int, long long int> > transitions[4];
for (long long int i = 0; i < points.size(); i++) {
transitions[i].push_back(points[i]);
for (long long int j = 0; j < 3; j++) {
points[i] = move(points[i], home[i]);
transitions[i].push_back(points[i]);
}
}
ret = getVal(transitions);
return ret == 1e18 ? -1 : ret;
}
void solve() {
vector<pair<long long int, long long int> > points(4), home(4);
for (long long int i = 0; i < 4; i++) {
cin >> points[i].first >> points[i].second;
cin >> home[i].first >> home[i].second;
}
cout << calculate(points, home) << "\n";
}
int32_t main() {
zanj0();
long long int t;
cin >> t;
while (t--) solve();
cerr << "Time : " << 1000 * (long double)clock() / (long double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 3 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(void){
long long n,a,b;
cin>>n>>a>>b;
long long x1,x2;
long long ans=0;
cin>>x1;
for(int i=1;i<n;i++){
cin>>x2;
ans+=min((x2-x1)*a,b);
x1=x2;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string cmp = "aeiou";
string m[10000 + 100];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < 4 * n; ++i) {
cin >> m[i];
int cnt = 0, pos = -1;
for (int j = m[i].size() - 1; j >= 0; --j) {
bool res = 0;
for (int k = 0; k < 5; ++k)
if (m[i][j] == cmp[k]) {
res = 1;
break;
}
if (res) ++cnt;
if (cnt == k) {
pos = j;
break;
}
}
if (pos == -1) {
cout << "NO";
return 0;
}
m[i] = m[i].substr(pos, m[i].size());
}
string str;
for (int i = 0; i < n; ++i) {
string type;
if (m[4 * i] == m[4 * i + 1] && m[4 * i] == m[4 * i + 2] &&
m[4 * i] == m[4 * i + 3])
type = "aaaa";
else if (m[4 * i] == m[4 * i + 1] && m[4 * i + 2] == m[4 * i + 3])
type = "aabb";
else if (m[4 * i] == m[4 * i + 2] && m[4 * i + 1] == m[4 * i + 3])
type = "abab";
else if (m[4 * i] == m[4 * i + 3] && m[4 * i + 1] == m[4 * i + 2])
type = "abba";
else {
cout << "NO";
return 0;
}
if (!i)
str = type;
else if (str == "aaaa")
str = type;
else if (type != "aaaa" && str != type) {
cout << "NO";
return 0;
}
}
cout << str;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int out[200000];
vector<int> g[200000];
int ans[200000];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
out[u]++;
g[v].push_back(u);
}
priority_queue<int> pq;
for (int i = 1; i <= n; i++) {
if (out[i] == 0) pq.push(i);
}
int lvl = n;
while (!pq.empty()) {
int x = pq.top();
pq.pop();
ans[x] = lvl--;
for (auto v : g[x]) {
out[v]--;
if (out[v] == 0) pq.push(v);
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
const long long N = 1e5 + 10;
inline long long add(long long x, long long y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline long long mul(long long x, long long y) {
x = (1LL * x * y) % mod;
return x;
}
long long get_val(long long i, long long a, long long b) {
return a + b * (i - 1);
}
long long get_sum(long long i, long long a, long long b) {
return b * (((i + 1) * i) / 2) - b * i + a * i;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long a, b, n;
cin >> a >> b >> n;
while (n--) {
long long l, t, m;
cin >> l >> t >> m;
long long l_ = l;
long long x = get_sum(l - 1, a, b);
long long r_ = 1e9;
while (l_ != r_) {
long long m_ = (l_ - r_) / 2 + r_;
if (get_val(m_, a, b) <= t && get_sum(m_, a, b) - x <= t * m)
l_ = m_;
else
r_ = m_ - 1;
}
if (get_val(l, a, b) > t || get_val(l, a, b) > m * t)
cout << "-1\n";
else
cout << l_ << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ans[501][501];
int main() {
int t;
cin >> t;
int col[250000];
int row[250000];
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int a;
cin >> a;
col[a] = j;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int b;
cin >> b;
row[b] = j;
}
}
for (int i = 1; i < n * m + 1; i++) {
ans[row[i]][col[i]] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
}
return 0;
}
| 2 |
#include<cstdio>
int n,i,j,b[3],a=1,P=998244353;int main(){scanf("%d\n",&n);for(i=3*n;--i;){char c=getchar();int &t=b[c%3],m=P;for(j=3;~--j;)m=b[j]>t&&b[j]-t<m?b[j]-t:m;a=1ll*a*(m<=n?m:1)%P*(i<=n?i:1)%P;++t;}printf("%d",a);}
| 0 |
#include<stdio.h>
#include<algorithm>
#include<string>
#include<map>
using namespace std;
char in[30];
int UF[300];
int w[300];
pair<int,int> FIND(int a){
if(UF[a]<0)return make_pair(a,0);
pair<int,int>ret=FIND(UF[a]);
ret.second+=w[a];
return ret;
}
bool ok=true;
void UNION(int a,int b,int c){
pair<int,int>A=FIND(a);
pair<int,int>B=FIND(b);
int d=A.first;
int e=B.first;
int f=A.second+c-B.second;
if(d==e){
if(B.second-c!=A.second)ok=false;
return;
}
UF[d]+=UF[d];
UF[e]=d;
w[e]=f;
}
int main(){
int a;
while(scanf("%d",&a),a){
map<string,int>m;
int sz=0;ok=true;
for(int i=0;i<300;i++){
UF[i]=-1;w[i]=0;
}
for(int i=0;i<a;i++){
scanf("%s%s",in,in);
string A=in;
int C=0;
scanf("%s%s",in,in);
if(in[1]==0)C=0;
else{
sscanf(in,"%d^%d",&C,&C);
}
scanf("%s",in);
string B=in;
int p,q;
if(!m.count(A)){
p=sz;
m[A]=sz++;
}else p=m[A];
if(!m.count(B)){
q=sz;
m[B]=sz++;
}else q=m[B];
UNION(p,q,C);
// if(!ok)printf("%d\n",i);
}
if(ok)printf("Yes\n");
else printf("No\n");
}
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:640000000")
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
template <class T>
inline T _abs(T n) {
return ((n) < 0 ? -(n) : (n));
}
template <class T>
inline T _max(T a, T b) {
return (!((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _min(T a, T b) {
return (((a) < (b)) ? (a) : (b));
}
template <class T>
inline T _swap(T &a, T &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
const int base = 1000000000;
const int base_digits = 9;
struct bigint {
vector<int> a;
int sign;
bigint() : sign(1) {}
bigint(long long v) { *this = v; }
bigint(const string &s) { read(s); }
void operator=(const bigint &v) {
sign = v.sign;
a = v.a;
}
void operator=(long long v) {
sign = 1;
if (v < 0) sign = -1, v = -v;
for (; v > 0; v = v / base) a.push_back(v % base);
}
bigint operator+(const bigint &v) const {
if (sign == v.sign) {
bigint res = v;
for (int i = 0, carry = 0; i < (int)max(a.size(), v.a.size()) || carry;
++i) {
if (i == (int)res.a.size()) res.a.push_back(0);
res.a[i] += carry + (i < (int)a.size() ? a[i] : 0);
carry = res.a[i] >= base;
if (carry) res.a[i] -= base;
}
return res;
}
return *this - (-v);
}
bigint operator-(const bigint &v) const {
if (sign == v.sign) {
if (abs() >= v.abs()) {
bigint res = *this;
for (int i = 0, carry = 0; i < (int)v.a.size() || carry; ++i) {
res.a[i] -= carry + (i < (int)v.a.size() ? v.a[i] : 0);
carry = res.a[i] < 0;
if (carry) res.a[i] += base;
}
res.trim();
return res;
}
return -(v - *this);
}
return *this + (-v);
}
void operator*=(int v) {
if (v < 0) sign = -sign, v = -v;
for (int i = 0, carry = 0; i < (int)a.size() || carry; ++i) {
if (i == (int)a.size()) a.push_back(0);
long long cur = a[i] * (long long)v + carry;
carry = (int)(cur / base);
a[i] = (int)(cur % base);
}
trim();
}
bigint operator*(int v) const {
bigint res = *this;
res *= v;
return res;
}
friend pair<bigint, bigint> divmod(const bigint &a1, const bigint &b1) {
int norm = base / (b1.a.back() + 1);
bigint a = a1.abs() * norm;
bigint b = b1.abs() * norm;
bigint q, r;
q.a.resize(a.a.size());
for (int i = a.a.size() - 1; i >= 0; i--) {
r *= base;
r += a.a[i];
int s1 = r.a.size() <= b.a.size() ? 0 : r.a[b.a.size()];
int s2 = r.a.size() <= b.a.size() - 1 ? 0 : r.a[b.a.size() - 1];
int d = ((long long)base * s1 + s2) / b.a.back();
r -= b * d;
while (r < 0) r += b, --d;
q.a[i] = d;
}
q.sign = a1.sign * b1.sign;
r.sign = a1.sign;
q.trim();
r.trim();
return make_pair(q, r / norm);
}
bigint operator/(const bigint &v) const { return divmod(*this, v).first; }
bigint operator%(const bigint &v) const { return divmod(*this, v).second; }
void operator/=(int v) {
if (v < 0) sign = -sign, v = -v;
for (int i = (int)a.size() - 1, rem = 0; i >= 0; --i) {
long long cur = a[i] + rem * (long long)base;
a[i] = (int)(cur / v);
rem = (int)(cur % v);
}
trim();
}
bigint operator/(int v) const {
bigint res = *this;
res /= v;
return res;
}
int operator%(int v) const {
if (v < 0) v = -v;
int m = 0;
for (int i = a.size() - 1; i >= 0; --i)
m = (a[i] + m * (long long)base) % v;
return m * sign;
}
void operator+=(const bigint &v) { *this = *this + v; }
void operator-=(const bigint &v) { *this = *this - v; }
void operator*=(const bigint &v) { *this = *this * v; }
void operator/=(const bigint &v) { *this = *this / v; }
bool operator<(const bigint &v) const {
if (sign != v.sign) return sign < v.sign;
if (a.size() != v.a.size()) return a.size() * sign < v.a.size() * v.sign;
for (int i = a.size() - 1; i >= 0; i--)
if (a[i] != v.a[i]) return a[i] * sign < v.a[i] * sign;
return false;
}
bool operator>(const bigint &v) const { return v < *this; }
bool operator<=(const bigint &v) const { return !(v < *this); }
bool operator>=(const bigint &v) const { return !(*this < v); }
bool operator==(const bigint &v) const {
return !(*this < v) && !(v < *this);
}
bool operator!=(const bigint &v) const { return *this < v || v < *this; }
void trim() {
while (!a.empty() && !a.back()) a.pop_back();
if (a.empty()) sign = 1;
}
bool isZero() const { return a.empty() || (a.size() == 1 && !a[0]); }
bigint operator-() const {
bigint res = *this;
res.sign = -sign;
return res;
}
bigint abs() const {
bigint res = *this;
res.sign *= res.sign;
return res;
}
long long longValue() const {
long long res = 0;
for (int i = a.size() - 1; i >= 0; i--) res = res * base + a[i];
return res * sign;
}
friend bigint gcd(const bigint &a, const bigint &b) {
return b.isZero() ? a : gcd(b, a % b);
}
friend bigint lcm(const bigint &a, const bigint &b) {
return a / gcd(a, b) * b;
}
void read(const string &s) {
sign = 1;
a.clear();
int pos = 0;
while (pos < (int)s.size() && (s[pos] == '-' || s[pos] == '+')) {
if (s[pos] == '-') sign = -sign;
++pos;
}
for (int i = s.size() - 1; i >= pos; i -= base_digits) {
int x = 0;
for (int j = max(pos, i - base_digits + 1); j <= i; j++)
x = x * 10 + s[j] - '0';
a.push_back(x);
}
trim();
}
friend istream &operator>>(istream &stream, bigint &v) {
string s;
stream >> s;
v.read(s);
return stream;
}
friend ostream &operator<<(ostream &stream, const bigint &v) {
if (v.sign == -1) stream << '-';
stream << (v.a.empty() ? 0 : v.a.back());
for (int i = (int)v.a.size() - 2; i >= 0; --i)
stream << setw(base_digits) << setfill('0') << v.a[i];
return stream;
}
static vector<int> convert_base(const vector<int> &a, int old_digits,
int new_digits) {
vector<long long> p(max(old_digits, new_digits) + 1);
p[0] = 1;
for (int i = 1; i < (int)p.size(); i++) p[i] = p[i - 1] * 10;
vector<int> res;
long long cur = 0;
int cur_digits = 0;
for (int i = 0; i < (int)a.size(); i++) {
cur += a[i] * p[cur_digits];
cur_digits += old_digits;
while (cur_digits >= new_digits) {
res.push_back(int(cur % p[new_digits]));
cur /= p[new_digits];
cur_digits -= new_digits;
}
}
res.push_back((int)cur);
while (!res.empty() && !res.back()) res.pop_back();
return res;
}
static vector<long long> karatsubaMultiply(const vector<long long> &a,
const vector<long long> &b) {
int n = a.size();
vector<long long> res(n + n);
if (n <= 32) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) res[i + j] += a[i] * b[j];
return res;
}
int k = n >> 1;
vector<long long> a1(a.begin(), a.begin() + k);
vector<long long> a2(a.begin() + k, a.end());
vector<long long> b1(b.begin(), b.begin() + k);
vector<long long> b2(b.begin() + k, b.end());
vector<long long> a1b1 = karatsubaMultiply(a1, b1);
vector<long long> a2b2 = karatsubaMultiply(a2, b2);
for (int i = 0; i < k; i++) a2[i] += a1[i];
for (int i = 0; i < k; i++) b2[i] += b1[i];
vector<long long> r = karatsubaMultiply(a2, b2);
for (int i = 0; i < (int)a1b1.size(); i++) r[i] -= a1b1[i];
for (int i = 0; i < (int)a2b2.size(); i++) r[i] -= a2b2[i];
for (int i = 0; i < (int)r.size(); i++) res[i + k] += r[i];
for (int i = 0; i < (int)a1b1.size(); i++) res[i] += a1b1[i];
for (int i = 0; i < (int)a2b2.size(); i++) res[i + n] += a2b2[i];
return res;
}
bigint operator*(const bigint &v) const {
vector<int> a6 = convert_base(this->a, base_digits, 6);
vector<int> b6 = convert_base(v.a, base_digits, 6);
vector<long long> a(a6.begin(), a6.end());
vector<long long> b(b6.begin(), b6.end());
while (a.size() < b.size()) a.push_back(0);
while (b.size() < a.size()) b.push_back(0);
while (a.size() & (a.size() - 1)) a.push_back(0), b.push_back(0);
vector<long long> c = karatsubaMultiply(a, b);
bigint res;
res.sign = sign * v.sign;
for (int i = 0, carry = 0; i < (int)c.size(); i++) {
long long cur = c[i] + carry;
res.a.push_back((int)(cur % 1000000));
carry = (int)(cur / 1000000);
}
res.a = convert_base(res.a, 6, base_digits);
res.trim();
return res;
}
};
bigint INF;
bigint basee;
string st;
bigint dp[64][100];
bool vis[64][100];
bigint bigmod(bigint b, unsigned long long p) {
bigint res = bigint(1), x = b;
while (p) {
if (p % 2 == 1) res = (res * x);
x = (x * x);
p /= 2;
}
return res;
}
bigint call(int in, unsigned long long pwr) {
if (in < 0) {
return 0;
}
if (vis[in][pwr] == 1) return dp[in][pwr];
vis[in][pwr] = 1;
bigint c = 1;
bigint sum = 0;
bigint res = INF;
for (int i = (int)(in); i >= (int)(0); i--) {
bigint k = bigint(st[i] - '0');
if (k * c + sum >= basee) break;
sum += (k * c);
c *= 10;
if (k == 0 && i == in) {
res = min(res, (sum * bigmod(basee, pwr)) + call(i - 1, pwr + 1));
} else if (k != 0) {
res = min(res, (sum * bigmod(basee, pwr)) + call(i - 1, pwr + 1));
}
}
dp[in][pwr] = res;
return dp[in][pwr];
}
int main() {
unsigned long long n;
INF = bigint(1);
for (int i = (int)(1); i <= (int)(1000); i++) INF = INF * 10;
while (cin >> n) {
basee = bigint(n);
cin >> st;
memset(vis, 0, sizeof(vis));
cout << call(st.size() - 1, 0) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
vector<pair<int, int> > f, b;
cin >> n >> m;
int ans[m + 1];
for (int i = 0; i < n; i++) {
pair<int, int> fi;
cin >> fi.first;
fi.second = i + 1;
f.push_back(fi);
}
for (int i = 0; i < m; i++) {
pair<int, int> bi;
cin >> bi.first;
bi.second = i + 1;
b.push_back(bi);
}
sort(f.begin(), f.end());
sort(b.begin(), b.end());
int fid = 0;
bool possible = true, ambig = false;
for (int cnt = 0; cnt < m; cnt++) {
while (fid < f.size() && f[fid].first != b[cnt].first) fid++;
if (fid == f.size()) {
possible = false;
break;
} else {
ans[b[cnt].second] = f[fid].second;
if (fid + 1 < f.size() && f[fid + 1].first == b[cnt].first) ambig = true;
}
}
if (possible) {
if (ambig) {
cout << "Ambiguity" << endl;
} else {
cout << "Possible" << endl;
cout << ans[1];
for (int i = 2; i <= m; i++) cout << " " << ans[i];
cout << endl;
}
} else {
cout << "Impossible" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct cmp {
bool operator()(pair<int, int> a, pair<int, int> b) {
return a.second > b.second;
}
};
long long modpow(long long base, long long exp, long long mod) {
base %= 1000000007;
long long result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % 1000000007;
base = (base * base) % 1000000007;
exp >>= 1;
}
return result;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
int cnt = 0;
for (int i = 1; i <= n; i++) {
int y = i + b - c;
int z = i + a - d;
int t = i + a + b - c - d;
if (y > 0 && y <= n && z > 0 && z <= n && t > 0 && t <= n) cnt++;
}
cout << (long long)cnt * n << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int a[N], b[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
int s1 = -1, s2 = -1;
for (int i = 0; i < n; i++) {
if (a[i]) {
s1 = i;
break;
}
}
for (int i = 0; i < n; i++) {
if (b[i] == a[s1]) {
s2 = i;
break;
}
}
bool ok = true;
while (s1 < n) {
if (a[s1] == b[s2]) {
s1++;
s2 = (s2 + 1) % n;
} else if (!a[s1]) {
s1++;
} else if (!b[s2]) {
s2 = (s2 + 1) % n;
} else {
ok = false;
break;
}
}
if (ok)
puts("YES");
else
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 2e5 + 5;
const long long INF = 1e18;
vector<long long> adj[N];
long long sum[N], mx[N];
long long a[N];
long long n;
bool vis[N];
void init() {
for (long long i = 0; i < n; i++) vis[i] = false;
}
long long findsum(long long u) {
vis[u] = true;
sum[u] = a[u];
for (long long i = 0; i < adj[u].size(); i++) {
if (!vis[adj[u][i]]) sum[u] += findsum(adj[u][i]);
}
return sum[u];
}
long long findmax(long long u) {
vis[u] = true;
for (long long i = 0; i < adj[u].size(); i++)
if (!vis[adj[u][i]]) mx[u] = max(mx[u], findmax(adj[u][i]));
return mx[u];
}
long long solve(long long u) {
vis[u] = true;
long long m1 = -1 * INF, m2 = -1 * INF;
for (long long i = 0; i < adj[u].size(); i++) {
if (!vis[adj[u][i]]) {
if (mx[adj[u][i]] > m1) {
m2 = m1;
m1 = mx[adj[u][i]];
} else if (mx[adj[u][i]] > m2)
m2 = mx[adj[u][i]];
}
}
long long ans = m1 + m2;
for (long long i = 0; i < adj[u].size(); i++)
if (!vis[adj[u][i]]) ans = max(ans, solve(adj[u][i]));
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
init();
sum[0] = findsum(0);
for (long long i = 0; i < n; i++) mx[i] = sum[i];
init();
mx[0] = findmax(0);
init();
long long ans = solve(0);
if (ans <= -2e10) {
cout << "Impossible\n";
return 0;
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 34 + 9;
char s[maxn];
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%s", s);
int k = strlen(s + 4), n = atoi(s + 4), F = 0, ten = 10;
for (int i = 1; i < k; i++) {
F += ten;
ten *= 10;
}
while (n < 1989 + F) n += ten;
printf("%d\n", n);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 10000005;
long long cnt[N];
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
memset(cnt, 0, sizeof(cnt));
long long sim = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
sim += x;
cnt[x]++;
}
if (sim < k) {
cout << -1;
return 0;
}
long long sum = 0;
for (int i = N - 1; i > 1; --i) {
sum += cnt[i];
if (2 * i - 1 < N) {
sum -= cnt[2 * i - 1];
cnt[2 * i - 1] = 0;
}
if (2 * i < N) {
sum -= cnt[2 * i];
cnt[2 * i] = 0;
}
if (2 * i + 1 < N) {
sum -= cnt[2 * i + 1];
cnt[2 * i + 1] = 0;
}
if (sum >= k) {
cout << i;
return 0;
}
cnt[i / 2] += cnt[i];
cnt[i - i / 2] += cnt[i];
}
cout << 1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, h, i, j, t, m, l;
long long p = 0, s, k, w, z, x, y;
std::cin >> n;
int a[n];
int b[n];
int c[n];
int d[n];
for (i = 0; i < n; i++) cin >> a[i] >> b[i] >> c[i] >> d[i];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (a[i] < a[j] && b[i] < b[j] && c[i] < c[j]) d[i] = 100000;
}
}
x = 100000;
for (i = 0; i < n; i++) {
if (d[i] < x) {
x = d[i];
j = i + 1;
}
}
std::cout << j << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[111111], b[111111];
vector<int> v;
long long t[555][555];
int main() {
int n;
cin >> n;
int r, c;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> t[i][j];
if (t[i][j] == 0) {
r = i;
c = j;
}
}
}
if (n == 1) {
cout << "1" << endl;
return 0;
}
long long sum = 0;
if (r == 0) {
for (int i = 0; i < n; i++) sum += t[1][i];
} else {
for (int i = 0; i < n; i++) sum += t[0][i];
}
long long lel = 0;
for (int i = 0; i < n; i++) {
lel += t[r][i];
}
if (lel >= sum) {
cout << "-1";
return 0;
}
t[r][c] = sum - lel;
for (int i = 0; i < n; i++) {
long long cur = 0;
for (int j = 0; j < n; j++) {
cur += t[i][j];
}
if (cur != sum) {
cout << "-1";
return 0;
}
}
for (int i = 0; i < n; i++) {
long long cur = 0;
for (int j = 0; j < n; j++) {
cur += t[j][i];
}
if (cur != sum) {
cout << "-1";
return 0;
}
}
long long cur = 0;
for (int i = 0; i < n; i++) {
cur += t[i][i];
}
if (cur != sum) {
cout << "-1";
return 0;
}
cur = 0;
for (int i = 0; i < n; i++) {
cur += t[i][n - 1 - i];
}
if (cur != sum) {
cout << "-1";
return 0;
}
cout << t[r][c];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long magic(long long n) { return n * (n + 1) / 2 % 1000000007; }
int main() {
long long a, b, s1, s2;
cin >> a >> b;
s1 = (b * magic(a) + a) % 1000000007;
s2 = magic(b - 1);
cout << s1 * s2 % 1000000007 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int abs(int x) {
if (x < 0) return -x;
return x;
}
int a1, b1, c1;
int a2, b2, c2;
int main() {
scanf("%d %d %d", &a1, &b1, &c1);
scanf("%d %d %d", &a2, &b2, &c2);
if (a1 < 0) {
a1 *= -1;
b1 *= -1;
c1 *= -1;
}
if (a1 == 0 && b1 < 0) {
b1 *= -1;
c1 *= -1;
}
if (a2 < 0) {
a2 *= -1;
b2 *= -1;
c2 *= -1;
}
if (a2 == 0 && b2 < 0) {
b2 *= -1;
c2 *= -1;
}
int g1 = gcd(a1, abs(b1));
int g2 = gcd(a2, abs(b2));
if ((g1 == 0 && c1 != 0) || (g2 == 0 && c2 != 0)) {
printf("0\n");
return 0;
}
if (g1 == 0 || g2 == 0) {
printf("-1\n");
return 0;
}
a2 *= g1;
b2 *= g1;
c2 *= g1;
a1 *= g2;
b1 *= g2;
c1 *= g2;
if (a1 == a2 && b1 == b2) {
if (c1 == c2) {
printf("-1\n");
} else {
printf("0\n");
}
} else {
printf("1\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename U, typename V>
void Min(U &a, const V &b) {
if (a > b) a = b;
}
template <typename U, typename V>
void Max(U &a, const V &b) {
if (a < b) a = b;
}
template <typename U, typename V>
void add(U &a, const V &b) {
a = (a + b) % 1000000007;
}
template <typename U>
U gcd(U a, U b) {
if (a == 0) return b;
if (b == 0) return a;
if (a >= b)
return gcd(a - b, b);
else
return gcd(a, b - a);
}
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = 1LL * ans * a % 1000000007;
a = 1LL * a * a % 1000000007;
b >>= 1;
}
return ans;
}
int a[2001][12], dp[1 << 12];
pair<int, int> b[2001];
int main() {
int T, m, n, i, j, k, K;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
int sz = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[j][i]);
for (int i = 0; i < m; i++) {
b[i] = {0, i};
for (int j = 0; j < n; j++) Max(b[i].first, a[i][j]);
}
sort(b, b + m);
reverse(b, b + m);
Min(m, n);
int mask = (1 << n) - 1;
for (int i = 0; i < mask + 1; i++) dp[i] = 0;
for (int it = 0; it < m; it++) {
i = b[it].second;
for (int j = 0; j < n; j++) {
for (int k = 0; k < (1 << n); k++)
if (!(k >> j & 1)) Max(dp[k | 1 << j], dp[k] + a[i][j]);
}
for (int s = 0; s < (1 << n); s++) {
int K = 0, r = s;
for (int i = 0; i < n; i++) {
Max(K, dp[r]);
r = (r >> 1) | ((r & 1) << n - 1);
}
for (int i = 0; i < n; i++) {
dp[r] = K;
r = (r >> 1) | ((r & 1) << n - 1);
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
}
}
| 5 |
#include <bits/stdc++.h>
#define debug(x) cout << #x << " = " << x << endl
#define fori(i, ini, lim) for(int i = int(ini); i < int(lim); i++)
#define ford(i, ini, lim) for(int i = int(ini); i >= int(lim); i--)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
const int MOD = 1e9 + 7;
const int MAX = 24000000 + 5;
int digits[MAX];
inline int add(int a, int b) {
a += b;
if(a >= MOD) {
a -= MOD;
}
return a;
}
inline int mult(int a, int b) {
return (1LL * a * b) % MOD;
}
inline int sub(int a, int b) {
a -= b;
if(0 > a) {
a += MOD;
}
return a;
}
int f_exp(int x, int exp) {
if(exp == 0) {
return 1;
}
else if(exp & 1) {
return mult(x, f_exp(x, exp - 1));
}
return f_exp(mult(x, x), exp / 2);
}
int main() {
ios_base::sync_with_stdio(false);
int s;
cin >> s;
int ans = 0;
int left = 1, d = 1, p = 1, sum = 0;
fori(right, 1, 23000000 + 1) {
if(p * 10 == right) {
d++;
p *= 10;
}
digits[right] = d;
sum += digits[right];
while(sum > s) {
sum -= digits[left++];
}
if(digits[left] > 7) {
break;
}
ans = add(ans, sum == s);
}
fori(i, 1, s / 8 + 1) {
if(s % i == 0) {
int q = s / i;
int range_len = sub(f_exp(10, q), f_exp(10, q - 1));
ans = add(ans, add(sub(range_len, i), 1));
}
else {
ans = add(ans, 1);
}
}
cout << ans << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int infi = 1e9;
const long long int infl = 1e18;
const int MOD = 1e9 + 7;
long long int log_2(long long int n) {
return (n > 1ll) ? 1ll + log_2(n / 2) : 0ll;
}
inline void add(long long int &a, long long int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline void sub(long long int &a, long long int b) {
a -= b;
if (a < 0) a += MOD;
}
inline string IntToString(long long int a) {
char x[100];
sprintf(x, "%lld", a);
string s = x;
return s;
}
inline long long int StringToInt(string a) {
char x[100];
long long int res;
strcpy(x, a.c_str());
sscanf(x, "%lld", &res);
return res;
}
inline string GetString(void) {
char x[1000005];
scanf("%s", x);
string s = x;
return s;
}
inline string uppercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); ++(i))
if (s[i] >= 'a' && s[i] <= 'z') s[i] = s[i] - 'a' + 'A';
return s;
}
inline string lowercase(string s) {
int n = (int)s.size();
for (int(i) = (0); (i) < (n); ++(i))
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = s[i] - 'A' + 'a';
return s;
}
inline void OPEN(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
void showarr(long long int arr[], long long int n) {
int i;
for (i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
void showvec(vector<long long int> v) {
int i;
for (i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
}
int isPalindrome(string str) {
int l = 0;
int h = str.length() - 1;
while (h > l) {
if (str[l++] != str[h--]) {
return 0;
}
}
return 1;
}
void showvecpair(vector<pair<long long int, long long int> > v) {
for (int i = 0; i < (int)v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
}
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
void bin(unsigned n) {
unsigned i;
for (i = 1 << 31; i > 0; i = i / 2) (n & i) ? printf("1") : printf("0");
}
long long int cntset(long long int n) {
bitset<64> b1(n);
return b1.count();
}
long long int p[100005];
void seive() {
long long int i, j;
for (i = 0; i < 100005; i++) p[i] = i;
for (i = 2; i <= sqrt(100005); i++) {
if (p[i] != i) continue;
for (j = i * i; j < 100005; j += i) {
if (p[j] == j) p[j] = i;
}
}
return;
}
long long int power(long long int n, long long int x) {
long long int j = n, prod = 1;
while (x) {
if (x % 2) {
prod = ((prod % MOD) * (j % MOD)) % MOD;
}
j = (j * j) % MOD;
x = x / 2;
}
return prod;
}
long long int fact(long long int n) {
long long int i, prod = 1;
for (i = 1; i <= n; i++) {
prod = (prod * i) % MOD;
}
return prod;
}
void solve() {
long long int a, b, c, d, x, y, n, m, k, l, i, j,
Max = INT_MIN, Min = INT_MAX, ctr = 0, cnt = 0, ans = 1, prod = 1;
char ch;
cin >> n >> k;
vector<pair<long long int, long long int> > dp, v;
for (i = 0; i < n; i++) {
cin >> a;
v.push_back({a, i + 1});
}
sort((v).begin(), (v).end());
ctr = 0;
while (ctr < k) {
if (v[n - 1].first == v[0].first)
break;
else {
ctr++;
v[n - 1].first--;
v[0].first++;
dp.push_back({v[n - 1].second, v[0].second});
sort((v).begin(), (v).end());
}
}
cout << v[n - 1].first - v[0].first << " " << ctr << endl;
for (i = 0; i < dp.size(); i++) {
cout << dp[i].first << " " << dp[i].second << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, T;
T = 1;
for (i = 1; i <= T; i++) {
solve();
}
return 0;
}
| 2 |
#include <stdio.h>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <iostream>
#include<math.h>
#include<bitset>
#include<iomanip>
#include<queue>
using namespace std;
int main() {
int N; cin >> N;
vector<int> A(N),B,C;
for (int i = 0; i < N; i++)cin >> A[i];
sort(A.begin(), A.end());
int max = A[N - 1], min = A[0];
for(int i=1;i<N-1;i++) {
if (A[i] >= 0) {
B.push_back(min); C.push_back(A[i]);
min -= A[i];
}
else {
B.push_back(max); C.push_back(A[i]);
max -= A[i];
}
}
cout << max-min << endl;
for (int i = 0; i < B.size(); i++)cout << B[i] << " " << C[i] << endl;
cout << max << " " << min << endl;
}
| 0 |
#include <bits/stdc++.h>
char s[100010];
int main() {
int i, j, k, l, m, n, p, q, y, z;
scanf("%s", s);
m = strlen(s);
if (m % 2 == 1) {
for (i = 0; i < (m + 1) / 2; i++) printf("4");
for (i = 0; i < (m + 1) / 2; i++) printf("7");
printf("\n");
return 0;
}
if (s[0] == '1' || s[0] == '2' || s[0] == '3') {
for (i = 0; i < m / 2; i++) printf("4");
for (i = 0; i < m / 2; i++) printf("7");
printf("\n");
return 0;
}
if (s[0] == '8' || s[0] == '9') {
for (i = 0; i <= m / 2; i++) printf("4");
for (i = 0; i <= m / 2; i++) printf("7");
printf("\n");
return 0;
}
if (s[0] == '5' || s[0] == '6') {
printf("7");
for (i = 0; i < m / 2; i++) printf("4");
for (i = 0; i < m / 2 - 1; i++) printf("7");
printf("\n");
return 0;
}
if (s[0] == '4') {
j = 0;
k = 0;
l = 0, p = 0, q = 0;
for (i = 0; i < m; i++) {
if (s[i] == '4')
k++;
else if (s[i] == '7')
l++;
else if (s[i] == '0' || s[i] == '1' || s[i] == '2' || s[i] == '3') {
j = 1;
p = i;
break;
} else if (s[i] == '5' || s[i] == '6') {
j = 2;
p = i;
break;
} else {
j = 3;
p = i;
break;
}
if (k == m / 2 || l == m / 2) {
p = i;
break;
}
}
if (j == 1) {
for (i = 0; i < p; i++) printf("%c", s[i]);
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l; i++) printf("7");
printf("\n");
return 0;
} else if (j == 2) {
for (i = 0; i < p; i++) printf("%c", s[i]);
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
} else if (j == 3) {
if (k == 1) {
printf("7");
for (i = 0; i < m / 2; i++) printf("4");
for (i = 0; i < m / 2 - 1; i++) printf("7");
printf("\n");
return 0;
} else {
for (z = p - 1; z; z--)
if (s[z] == '4') break;
k = 0;
l = 0;
for (i = 0; i < z; i++) {
if (s[i] == '4') k++;
if (s[i] == '7') l++;
printf("%c", s[i]);
}
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
}
} else {
if (k == m / 2) {
y = 0;
for (i = p + 1; i < m; i++) {
if (s[i] < '7') break;
if (s[i] > '7') {
y = 1;
break;
}
}
if (y == 0) {
for (i = 0; i <= p; i++) printf("%c", s[i]);
for (i = p + 1; i < m; i++) printf("7");
printf("\n");
return 0;
} else {
for (i = 0; i < p; i++) printf("%c", s[i]);
printf("7");
printf("4");
for (i = p + 2; i < m; i++) printf("7");
printf("\n");
return 0;
}
} else {
y = 0;
for (i = p + 1; i < m; i++) {
if (s[i] < '4') break;
if (s[i] > '4') {
y = 1;
break;
}
}
if (y == 0) {
for (i = 0; i <= p; i++) printf("%c", s[i]);
for (i = p + 1; i < m; i++) printf("4");
printf("\n");
return 0;
} else {
if (k == 1) {
printf("7");
for (i = 0; i < m / 2; i++) printf("4");
for (i = 0; i < m / 2 - 1; i++) printf("7");
printf("\n");
return 0;
} else {
for (z = p - 1; z; z--)
if (s[z] == '4') break;
k = 0, l = 0;
for (i = 0; i < z; i++) {
if (s[i] == '4') k++;
if (s[i] == '7') l++;
printf("%c", s[i]);
}
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
}
}
}
}
} else {
j = 0;
k = 0;
l = 0, p = 0, q = 0;
for (i = 0; i < m; i++) {
if (s[i] == '4')
k++;
else if (s[i] == '7')
l++;
else if (s[i] == '0' || s[i] == '1' || s[i] == '2' || s[i] == '3') {
j = 1;
p = i;
break;
} else if (s[i] == '5' || s[i] == '6') {
j = 2;
p = i;
break;
} else {
j = 3;
p = i;
break;
}
if (k == m / 2 || l == m / 2) {
p = i;
break;
}
}
if (j == 1) {
for (i = 0; i < p; i++) printf("%c", s[i]);
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l; i++) printf("7");
printf("\n");
return 0;
} else if (j == 2) {
for (i = 0; i < p; i++) printf("%c", s[i]);
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
} else if (j == 3) {
if (k == 0) {
for (i = 0; i <= m / 2; i++) printf("4");
for (i = 0; i <= m / 2; i++) printf("7");
printf("\n");
return 0;
} else {
for (z = p - 1; z; z--)
if (s[z] == '4') break;
k = 0;
l = 0;
for (i = 0; i < z; i++) {
if (s[i] == '4') k++;
if (s[i] == '7') l++;
printf("%c", s[i]);
}
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
}
} else {
if (k == m / 2) {
y = 0;
for (i = p + 1; i < m; i++) {
if (s[i] < '7') break;
if (s[i] > '7') {
y = 1;
break;
}
}
if (y == 0) {
for (i = 0; i <= p; i++) printf("%c", s[i]);
for (i = p + 1; i < m; i++) printf("7");
printf("\n");
return 0;
} else {
for (i = 0; i < p; i++) printf("%c", s[i]);
printf("7");
printf("4");
for (i = p + 2; i < m; i++) printf("7");
printf("\n");
return 0;
}
} else {
y = 0;
for (i = p + 1; i < m; i++) {
if (s[i] < '4') break;
if (s[i] > '4') {
y = 1;
break;
}
}
if (y == 0) {
for (i = 0; i <= p; i++) printf("%c", s[i]);
for (i = p + 1; i < m; i++) printf("4");
printf("\n");
return 0;
} else {
if (k == 0) {
for (i = 0; i <= m / 2; i++) printf("4");
for (i = 0; i <= m / 2; i++) printf("7");
printf("\n");
return 0;
} else {
for (z = p - 1; z; z--)
if (s[z] == '4') break;
k = 0, l = 0;
for (i = 0; i < z; i++) {
if (s[i] == '4') k++;
if (s[i] == '7') l++;
printf("%c", s[i]);
}
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
}
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
node(int x = 0, int y = 0) : x(x), y(y) {}
};
void create(vector<int>& v, int n) { v.assign(n + 1, 0); }
int rsq(vector<int>& v, int a, int b) {
if (a == 0) {
int sum = 0;
for (; b >= 0; b = (b & (b + 1)) - 1) {
sum += v[b];
}
return sum;
} else {
return rsq(v, 0, b) - rsq(v, 0, a - 1);
}
}
void adjust(vector<int>& t, int k, int value) {
for (; k <= t.size(); k |= k + 1) {
t[k] += value;
}
}
int visited[200000];
int main() {
ios::sync_with_stdio(false);
int x, n, k, q, id;
cin >> n >> k >> q;
vector<int> ft, friendsList;
vector<pair<int, int> > friends;
map<int, int> bib;
create(ft, n + 10);
for (int i = 0; i < n; i++) {
cin >> x;
friends.push_back(make_pair(x, i));
friendsList.push_back(x);
}
sort(friends.begin(), friends.end());
reverse(friends.begin(), friends.end());
for (int i = 0; i < n; i++) {
bib.insert(make_pair(friends[i].first, i + 1));
}
for (int i = 0; i < q; i++) {
cin >> x >> id;
if (x & 1) {
if (visited[id]) continue;
visited[id] = 1;
int f = friendsList[id - 1];
adjust(ft, bib[f], 1);
} else {
if (!visited[id]) {
cout << "NO" << endl;
continue;
}
int f = friendsList[id - 1];
int flag = rsq(ft, 1, bib[f]);
cout << ((flag <= k) ? "YES" : "NO") << endl;
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int gcd(int x,int y){return y?gcd(y,x%y):x;}
int main()
{
int n,k,Max=0,Gcd=0;
scanf("%d%d",&n,&k);
for (int i=1;i<=n;i++){
int x;
scanf("%d",&x);
Max=max(Max,x);
Gcd=gcd(Gcd,x);
}
puts(k%Gcd==0&&k<=Max?"POSSIBLE":"IMPOSSIBLE");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
char s[maxn];
int res[maxn];
int main() {
int n, a, b, k;
scanf("%d%d%d%d", &n, &a, &b, &k);
scanf("%s", s);
int i = 0;
int l = strlen(s);
int x = 0, sum = 0;
for (i = 0; i < l; ++i) {
if (s[i] == '0')
x++;
else {
sum += (x / b);
x = 0;
}
}
if (x != 0) sum += (x / b);
a = sum - a + 1;
int tot = 0;
int ans = 0;
i = 0;
while (i < l && a > 0) {
if (s[i] == '1') {
tot = 0;
i++;
} else {
tot++;
if (tot == b) {
res[ans] = i + 1;
ans++;
tot = 0;
a--;
}
i++;
}
}
printf("%d\n", ans);
for (i = 0; i < ans - 1; ++i) printf("%d ", res[i]);
printf("%d\n", res[ans - 1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int color[105][105] = {};
int main() {
int n, k, flag, last = -2, first = 1, max = -1, cnt = 1;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> color[i][0];
max = max > color[i][0] ? max : color[i][0];
}
for (int j = 1; j <= max; j++) {
flag = 0;
for (int i = 1; i <= n; i++) {
if (color[i][0] < j) continue;
if (color[i][0] == j || j == last + 1) {
flag = 1;
last = j;
}
color[i][j] = cnt;
}
if (flag) {
if (first)
first = 0;
else
cnt++;
}
if (cnt > k && j < max) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= color[i][0]; j++) cout << color[i][j] << ' ';
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename TT>
ostream &operator<<(ostream &s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream &operator<<(ostream &s, vector<T> t) {
s << "{";
for (int i = 0; i < t.size(); i++)
s << t[i] << (i == t.size() - 1 ? "" : ",");
return s << "}" << endl;
}
char plec[200006];
int skill[200006];
set<int> ob;
int main() {
int n;
scanf("%d", &(n));
;
scanf("%s", plec);
for (int i = 0; i < n; i++) scanf("%d", &(skill[i]));
;
for (int i = 0; i < n; i++) ob.insert(i);
priority_queue<pair<int, pair<int, int> >,
vector<pair<int, pair<int, int> > >,
greater<pair<int, pair<int, int> > > >
Q;
for (int i = 0; i < n - 1; i++) {
if (plec[i] != plec[i + 1]) {
Q.push(make_pair(abs(skill[i] - skill[i + 1]), make_pair(i, i + 1)));
}
}
vector<pair<int, int> > wyn;
set<int>::iterator it;
while (!Q.empty()) {
pair<int, pair<int, int> > p = Q.top();
Q.pop();
pair<int, int> u = p.second;
if (!((ob).find((u.first)) != (ob).end()) ||
!((ob).find((u.second)) != (ob).end()))
continue;
wyn.push_back(u);
ob.erase(u.first);
ob.erase(u.second);
it = ob.lower_bound(u.second);
if (it == ob.end()) continue;
if (it == ob.begin()) continue;
u.second = *it;
it--;
u.first = *it;
if (plec[u.first] != plec[u.second]) {
Q.push(make_pair(abs(skill[u.first] - skill[u.second]), u));
}
}
printf("%d\n", wyn.size());
for (typeof(wyn.begin()) i = wyn.begin(); i != wyn.end(); i++)
printf("%d %d\n", (i->first) + 1, (i->second) + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int s, x, y, a, b = 0;
cin >> s >> x;
int f = 1;
if (s < x) f = 0;
if (s == x) b = 2;
y = s - x;
if (y % 2 == 1) f = 0;
if (f) {
y /= 2, a = 1;
while (x > 0 || y > 0) {
if (x % 2 == 1) {
if (y % 2 == 0)
a *= 2;
else
f = 0;
}
x /= 2, y /= 2;
}
}
a *= f;
cout << a - b << endl;
}
| 2 |
#include <iostream>
using namespace std;
int main()
{
int a,s,d,f;
cin >> a >> s >> d>>f;
cout << min(a, s) + min(d, f) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define reep(i,a,b) for(int i=a; i<b; i++)
#define MOD 1000000007
#define INFL 0x3f3f3f3f3f3f3f3f
using ll = long long;
int main(){
string s;
cin>>s;
string p;
cin>>p;
int n = s.size();
int m = p.size();
vector<int> pos1(p.size(),-1);
auto pos2 = pos1;
int cnt = 0;
rep(i,n){
if(cnt<m){
if(p[cnt] == s[i]){
pos1[cnt] = i;
cnt++;
}
}
}
cnt = m-1;
for(int i=n-1; i>=0; i--){
if(cnt>=0){
if(p[cnt] == s[i]){
pos2[cnt] = i;
cnt--;
}
}
}
if(pos1[m-1]>=0&&pos2[0]>=0){
rep(i,m){
if(pos1[i] != pos2[i]){
cout<<"no"<<endl;
return 0;
}
}
cout<<"yes"<<endl;
return 0;
}
cout<<"no"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::cout << std::fixed;
std::cout << std::setprecision(8);
double n, m;
cin >> n >> m;
double min = 100000.0;
for (int i = 0; i < n; i++) {
double a, b;
cin >> a >> b;
double s = a / b;
if (min > s) min = s;
}
double ans = min * m;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, w, h;
int que[100050], tot, tow;
struct Node {
int g, p, t, id;
} s[100050];
int x[100050], y[100050];
inline bool operator<(const Node &a, const Node &b) {
if ((a.p - a.t) != (b.p - b.t)) return (a.p - a.t) < (b.p - b.t);
if (a.g != b.g) return a.g < b.g;
return a.p < b.p;
}
int main() {
scanf("%d%d%d", &n, &w, &h);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &s[i].g, &s[i].p, &s[i].t);
s[i].id = i;
}
sort(s + 1, s + n + 1);
for (int i = 1, j = 1; j <= n; i = j) {
int p = i - 1;
for (; j <= n && (s[j].p - s[j].t) == (s[i].p - s[i].t); ++j)
if (s[j].g == 1) p = j;
tot = tow = 0;
for (int k = p; k >= i; --k) que[tow++] = k;
for (int k = p + 1; k < j; ++k) {
if ((tow - tot) > 0) {
x[s[que[tot]].id] = w;
y[s[que[tot]].id] = s[k].p;
++tot;
que[tow++] = k;
} else {
x[s[k].id] = w;
y[s[k].id] = s[k].p;
}
}
for (int k = p; k >= i; --k) {
x[s[que[tot]].id] = s[k].p;
y[s[que[tot]].id] = h;
++tot;
}
}
for (int i = 1; i <= n; ++i) printf("%d %d\n", x[i], y[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, a, b, k;
cin >> n >> a >> b >> k;
vector<long long> h(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &h[i]);
h[i] = h[i] % (a + b);
}
long long ans = 0, two = 0;
vector<long long> shots;
for (int i = 0; i < n; i++) {
if (h[i] <= a && h[i] >= 1) {
ans++;
} else {
if (h[i] == 0) {
if (k > 0) {
if (a >= b) {
ans++;
k--;
} else {
h[i] = a + b;
long long sh = h[i] / a;
if (h[i] % a != 0) sh++;
sh--;
shots.push_back(sh);
}
}
} else {
if (k > 0) {
if (a >= b) {
ans++;
k--;
} else {
long long sh = h[i] / a;
if (h[i] % a != 0) sh++;
sh--;
shots.push_back(sh);
}
}
}
}
}
if (k > 0) {
sort(shots.begin(), shots.end());
for (int i = 0; i < (int)shots.size(); i++) {
if (shots[i] <= k && k > 0) {
ans++;
k -= shots[i];
}
}
}
printf("%lld", ans);
printf("\n");
return;
}
int main() {
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define maxn 100010
const int p=998244353;
template <typename T>inline T read()
{
register T sum=0;
register char cc=getchar();
int sym=1;
while(cc!='-'&&(cc>'9'||cc<'0'))cc=getchar();
if(cc=='-')sym=-1,cc=getchar();
sum=sum*10+cc-'0';
cc=getchar();
while(cc>='0'&&cc<='9')sum=sum*10+cc-'0',cc=getchar();
return sym*sum;
}
template <typename T>inline T read(T &a)
{
a=read<T>();
return a;
}
template <typename T,typename... Others> inline void read(T& a, Others&... b)
{
a=read(a);
read(b...);
}
int n,m,mx,ans,SG[3][maxn],sum[3][maxn],buck[maxn];
vector<int>G[3][maxn];
void Add(int &x,int y)
{
x+=y;
if(x>=p)
x-=p;
}
int mul(int x,int y)
{
return 1ll*x*y%p;
}
int fpow(int x,int y)
{
int res=1;
while(y)
{
if(y&1)
res=mul(res,x);
x=mul(x,x);
y>>=1;
}
return res;
}
int main()
{
read(n);
for(int k=0;k<3;k++)
{
read(m);
for(int i=1;i<=m;i++)
{
int x,y;
read(x,y);
if(x>y)swap(x,y);
G[k][x].push_back(y);
}
for(int i=n;i>=1;i--)
{
for(auto j:G[k][i])
buck[SG[k][j]]=true;
for(int j=0;j<=mx+1;j++)
{
if(buck[j])
continue;
SG[k][i]=j;
mx=max(mx,j);
break;
}
Add(sum[k][SG[k][i]],fpow(10,18*i));
for(auto j:G[k][i])
buck[SG[k][j]]=false;
}
}
for(int a=0;a<=mx;a++)
if(sum[0][a])
for(int b=0;b<=mx;b++)
if(sum[1][b])
Add(ans,mul(mul(sum[0][a],sum[1][b]),sum[2][a^b]));
printf("%d\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string input;
int xs = 0, ys = 0;
cin >> input;
if (input.length() == 1) {
cout << input << endl;
} else {
for (int i = 0; i < input.length(); i++) {
if (input[i] == 'x') {
xs++;
} else {
ys++;
}
}
if (xs - ys > 0) {
for (int i = 0; i < xs - ys; i++) {
cout << 'x';
}
cout << '\n';
} else {
for (int i = 0; i < ys - xs; i++) {
cout << 'y';
}
cout << '\n';
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int sum(int x) {
int dig, ret = 0;
while (x > 0) {
dig = x % 10;
x -= dig;
x /= 10;
ret += dig;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int ini = max(1, n - (int)1e6);
vector<int> sol;
for (int x = ini; x <= n; x++) {
if (x + sum(x) == n) sol.push_back(x);
}
int tam = sol.size();
cout << tam << "\n";
for (int i = 0; i < tam; i++) {
cout << sol[i] << " ";
}
if (tam > 0) cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (register int i = 21; i <= 50; ++i)
printf("%d\n", ((min(i, 25) + i) % (2 + i % 3) > 0) ? 1 : 0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x[100005];
int main() {
#pragma warning(disable : 4996)
long long int n, d, s, r;
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
s = 0;
r = 2;
for (long long int l = 1; l <= n - 2; l++) {
while ((r < n) && (d >= x[r + 1] - x[l])) r++;
s = s + (r - l) * (r - l - 1) / 2;
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, m, t, b[200100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
for (k = 1; k * k < n; k++)
if (n % k == 0) {
t++;
b[t] = (2 * k + n * (k - 1)) / 2;
t++;
b[t] = (2 * n / k + n * (n / k - 1)) / 2;
}
if (k * k == n) {
t++;
b[t] = (2 * k + k * (k - 1) * k) / 2;
}
sort(b + 1, b + t + 1);
for (k = 1; k <= t; k++) cout << b[k] << " ";
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
#define fr second.first
#define to second.second
#define co first
const int INF=INT_MAX;
typedef pair<int,int> P;
typedef pair<int,P> Edge;
long long edmonds(vector<Edge> edges,int v,int st) {
vector<P> mins(v,P(INF,-1));
for(int i=0;i<(int)edges.size();i++) {
Edge edge=edges[i];
mins[edge.to]=min(mins[edge.to],P(edge.co,edge.fr));
}
mins[st]=P(-1,-1);
vector<int> gr(v,0);
vector<bool> tfc(v,false),f(v,false);
int cnt=0;
for(int i=0;i<v;i++){
if(f[i]) continue;
vector<int> ch;
int cu=i;
for(;cu!=-1&&!f[cu];){
f[cu]=true;
ch.push_back(cu);
cu=mins[cu].second;
}
if(cu!=-1){
bool tfc2=false;
for(int j=0;j<(int)ch.size();j++) {
gr[ch[j]]=cnt;
if(ch[j]==cu){
tfc[cnt]=true;
tfc2=true;
}
if(!tfc2) cnt++;
}
if(tfc2) cnt++;
}
else for(int j=0;j<(int)ch.size();j++,cnt++) gr[ch[j]]=cnt;
}
if(cnt==v){
long long ans=1;
for(int i=0;i<v;i++) ans+=mins[i].co;
return ans;
}
long long res=0;
for(int i=0;i<v;i++) if(i!=st&&tfc[gr[i]]) res+=mins[i].co;
vector<Edge> nedges;
for(int i=0;i<(int)edges.size();i++) {
Edge edge=edges[i];
int fto=edge.to,gfr=gr[edge.fr],gto=gr[edge.to];
if(gfr==gto) continue;
else if(tfc[gto]) nedges.push_back(make_pair(edge.co-mins[fto].co,P(gfr,gto)));
else nedges.push_back(make_pair(edge.co,P(gfr,gto)));
}
return res+edmonds(nedges,cnt,gr[st]);
}
int main(){
int v,e,r;
cin>>v>>e>>r;
vector<Edge> es;
for(int i=0,s,t,w;i<e&&cin>>s>>t>>w;i++) es.push_back(make_pair(w,P(s,t)));
cout<<edmonds(es,v,r)<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007, M = 60, LOG = 63;
const int N = M * 6;
const long long mod = MOD;
const int inv2 = (mod + 1) / 2;
const double pi = acos(-1);
int m;
int inv[N];
int add(int a, int b) { return (a += b) >= mod ? a - mod : a; }
int dec(int a, int b) { return (a -= b) < 0 ? a + mod : a; }
int mul(int a, int b) { return (long long)a * b % mod; }
int qpow(int a, int b) {
int ret = 1;
for (; b; b >>= 1) {
if (b & 1) ret = mul(ret, a);
a = mul(a, a);
}
return ret;
}
void initinv() {
inv[1] = 1;
for (int i = 2; i < N; i++) inv[i] = mul(mod - mod / i, inv[mod % i]);
}
void rev(complex<double> *a, int n) {
for (int i = 1, j = n / 2; i < n - 1; ++i) {
if (i < j) swap(a[i], a[j]);
int k = n / 2;
while (j >= k) j -= k, k /= 2;
if (j < k) j += k;
}
}
void fft(complex<double> *a, int n, int f) {
rev(a, n);
for (int m = 1; m <= n; m <<= 1) {
complex<double> wm =
complex<double>(cos(f * 2 * pi / m), sin(f * 2 * pi / m));
for (int k = 0; k < n; k += m) {
complex<double> w = complex<double>(1, 0);
for (int j = 0; j < m / 2; ++j) {
complex<double> u = a[k + j];
complex<double> t = w * a[k + j + m / 2];
a[k + j] = u + t;
a[k + j + m / 2] = u - t;
w = w * wm;
}
}
}
}
void conv(int n, long long *x, long long *y, long long *z) {
static complex<double> p[N], q[N], a[N], b[N], c[N], d[N], w[N];
static complex<double> r(0.5, 0), h(0, -0.5), o(0, 1);
for (int i = 0, ed = n; i < ed; ++i) {
w[i] = complex<double>(cos(2 * pi * i / n), sin(2 * pi * i / n));
x[i] = (x[i] + mod) % mod, y[i] = (y[i] + mod) % mod;
p[i] = complex<double>(x[i] >> 15, x[i] & 32767),
q[i] = complex<double>(y[i] >> 15, y[i] & 32767);
}
fft(p, n, 1);
fft(q, n, 1);
for (int i = 0, ed = n; i < ed; ++i) {
int j = i ? (n - i) : 0;
static complex<double> ka, ba, kb, bb;
ka = (p[i] + conj(p[j])) * r;
ba = (p[i] - conj(p[j])) * h;
kb = (q[i] + conj(q[j])) * r;
bb = (q[i] - conj(q[j])) * h;
a[j] = ka * kb;
b[j] = ka * bb;
c[j] = kb * ba;
d[j] = ba * bb;
}
for (int i = 0, ed = n; i < ed; ++i) {
p[i] = a[i] + b[i] * o;
q[i] = c[i] + d[i] * o;
}
fft(p, n, 1);
fft(q, n, 1);
for (int i = 0, ed = n; i < ed; ++i) {
long long a, b, c, d;
a = (long long)(p[i].real() / n + 0.5) % mod;
b = (long long)(p[i].imag() / n + 0.5) % mod;
c = (long long)(q[i].real() / n + 0.5) % mod;
d = (long long)(q[i].imag() / n + 0.5) % mod;
z[i] = ((a << 30) + ((b + c) << 15) + d) % mod;
}
}
void cmult(int *a, int n, int *b, int m, int *c) {
static long long A[N], B[N], C[N];
int l;
for (l = 1; l <= (n + m - 1); l <<= 1)
;
for (int i = 0; i < n; i++) A[i] = a[i];
for (int i = 0; i < m; i++) B[i] = b[i];
fill(A + n, A + l, 0);
fill(B + m, B + l, 0);
conv(l, A, B, C);
for (int i = 0; i < l; i++) c[i] = C[i] % mod;
}
void cinv(int *a, int *b, int n) {
static int C[N];
if (n == 0) {
b[0] = qpow(a[0], mod - 2);
return;
}
cinv(a, b, n >> 1);
cmult(b, n, b, n, C);
cmult(C, n, a, n, C);
for (int i = 0; i < n; i++) b[i] = dec(mul(2, b[i]), C[i]);
fill(b + n, b + 2 * n, 0);
}
void cintegrate(int *f, int *g, int n) {
for (int i = n; i >= 1; i--) g[i] = mul(f[i - 1], inv[i]);
g[0] = 0;
}
void cderivation(int *f, int *g, int n) {
for (int i = 1; i < n; i++) g[i - 1] = mul(f[i], i);
g[n - 1] = 0;
}
void cln(int *f, int *g, int n) {
static int D[N], A[N];
cderivation(f, D, n);
cinv(f, A, n);
cmult(A, n, D, n, A);
cintegrate(A, g, n);
}
void cexp(int *a, int *b, int n) {
static int D[N];
if (n == 1) {
b[0] = 1;
return;
}
cexp(a, b, n >> 1);
cln(b, D, n);
for (int i = 0; i < n; i++) D[i] = dec(a[i], D[i]);
D[0] = add(1, D[0]);
cmult(D, n, b, n, b);
}
void csqrt(int *a, int *b, int n) {
static int C[N];
if (n == 1) {
b[0] = sqrt(a[0] + 0.5);
return;
}
csqrt(a, b, n >> 1);
cinv(b, C, n);
cmult(a, n, C, n, C);
for (int i = 0; i < n; i++) b[i] = mul(inv2, add(b[i], C[i]));
fill(b + n, b + 2 * n, 0);
}
void cpow(int *f, int *g, int n, int k) {
static int C[N];
cln(f, C, n);
for (int i = 0; i < n; i++) C[i] = mul(C[i], k);
cexp(C, g, n);
}
void cdiv(int *a, int n, int *b, int m, int *ret) {
static int c[N], d[N], e[N], l;
while (b[m - 1] == 0) m--;
if (n < m) return;
for (l = 1; l <= n - m + 1; l <<= 1)
;
reverse_copy(a, a + n, c);
reverse_copy(b, b + m, d);
for (int i = m; i < n + m + 1; i++) d[i] = 0;
memset(e, 0, sizeof(e[0]) * (l * 2));
cinv(d, e, l);
cmult(e, n - m + 1, c, n - m + 1, d);
reverse_copy(d, d + n - m + 1, ret);
}
void cmod(int *a, int n, int *b, int m, int *ret) {
static int c[N];
while (b[m - 1] == 0) m--;
cdiv(a, n, b, m, c);
cmult(c, n - m + 1, b, m, c);
for (int i = 0; i < m - 1; i++) ret[i] = add(a[i] - c[i], mod);
}
void cgcd(int *a, int n, int *b, int m, int *c) {
static int r[N];
fill(c, c + max(m, n), 0);
int i;
while (1) {
cmod(a, n, b, m, r);
for (i = m - 2; i >= 0; i--)
if (r[i]) break;
i++;
if (i == 0) break;
memcpy(a, b, sizeof(b[0]) * m);
memcpy(b, r, sizeof(r[0]) * i);
n = m;
m = i;
}
memcpy(c, b, sizeof(b[0]) * m);
int invc = qpow(c[0], mod - 2);
for (int i = 0; i < m; i++) c[i] = mul(c[i], invc);
}
int lagrange(int *f, int n, int x) {
static int C[N], D[N];
cinv(f, C, n);
cpow(C, D, n, x);
return mul(D[x - 1], qpow(x, mod - 2));
}
struct Vector {
int a[M];
Vector() { memset(a, 0, sizeof(a)); }
int &operator[](const int &i) { return a[i]; }
const int operator[](const int &i) const { return a[i]; }
int operator*(const Vector &b) {
int ret = 0;
for (int i = 0; i < m; ++i) {
if ((ret += (long long)a[i] * b[i] % MOD) >= MOD) {
ret -= MOD;
}
}
return ret;
}
Vector operator+(const Vector &b) {
Vector ret;
for (int i = 0; i < m; ++i) {
if ((ret[i] = a[i] + b[i]) >= MOD) {
ret[i] -= MOD;
}
}
return ret;
}
};
Vector operator*(int k, const Vector &b) {
Vector ret;
for (int i = 0; i < m; ++i) {
ret[i] = (long long)k * b[i] % MOD;
}
return ret;
}
const int BAR = 10;
struct Matrix {
int n, m;
int x[M * M], y[M * M], a[M * M];
Matrix(int n) : n(n), m(0) { memset(a, 0, sizeof(a)); }
void reshuffle() {
vector<pair<int, pair<int, int>>> v(m);
for (int i = 0; i < m; ++i) {
v[i].first = x[i], v[i].second.first = y[i], v[i].second.second = a[i];
}
sort(v.begin(), v.end());
for (int i = 0; i < m; ++i) {
x[i] = v[i].first, y[i] = v[i].second.first, a[i] = v[i].second.second;
}
}
Vector operator*(Vector b) {
vector<unsigned long long> c(n);
for (int i = 0; i < m; ++i) {
c[x[i]] += (unsigned long long)a[i] * b[y[i]];
if (i % BAR == 0) c[x[i]] %= MOD;
}
for (int i = 0; i < n; ++i) b[i] = c[i] % MOD;
return b;
}
void setValue(int i, int j, int v) { x[m] = i, y[m] = j, a[m] = v, ++m; }
};
int inverse(int a) {
return a == 1 ? 1 : (long long)(MOD - MOD / a) * inverse(MOD % a) % MOD;
}
struct Poly {
vector<int> a;
Poly() { a.clear(); }
Poly(vector<int> &a) : a(a) {}
int length() const { return a.size(); }
Poly move(int d) {
vector<int> na(d, 0);
na.insert(na.end(), a.begin(), a.end());
return Poly(na);
}
int calc(vector<int> &d, int pos) {
int ret = 0;
for (int i = 0; i < (int)a.size(); ++i) {
if ((ret += (long long)d[pos - i] * a[i] % MOD) >= MOD) {
ret -= MOD;
}
}
return ret;
}
Poly operator-(const Poly &b) {
vector<int> na(max(this->length(), b.length()));
for (int i = 0; i < (int)na.size(); ++i) {
int aa = i < this->length() ? this->a[i] : 0,
bb = i < b.length() ? b.a[i] : 0;
na[i] = (aa + MOD - bb) % MOD;
}
return Poly(na);
}
};
Poly operator*(const int &c, const Poly &p) {
vector<int> na(p.length());
for (int i = 0; i < (int)na.size(); ++i) {
na[i] = (long long)c * p.a[i] % MOD;
}
return na;
}
vector<int> Berlekamp(vector<int> a) {
int n = a.size();
Poly s, b;
s.a.push_back(1), b.a.push_back(1);
for (int i = 1, j = 0, ld = a[0]; i < n; ++i) {
int d = s.calc(a, i);
if (d) {
if ((s.length() - 1) * 2 <= i) {
Poly ob = b;
b = s;
s = s - (long long)d * inverse(ld) % MOD * ob.move(i - j);
j = i;
ld = d;
} else {
s = s - (long long)d * inverse(ld) % MOD * b.move(i - j);
}
}
}
return s.a;
}
Vector LinearRec(vector<Vector> &first, vector<int> &trans, long long k) {
int n = first.size();
int m;
static int a[N];
static int b[N];
static int c[N];
static int d[N];
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
memset(d, 0, sizeof(d));
for (int i = 0; i < n; i++) a[i] = trans[i];
a[n] = 1;
reverse(a, a + n);
for (int i = 0; i < n; i++) a[i] = MOD - a[i];
for (m = 1; m <= n + 1; m <<= 1)
;
b[1] = 1;
c[0] = 1;
for (k--; k; k >>= 1) {
if (k & 1) {
memset(d, 0, sizeof(d));
cmult(c, m, b, m, c);
cmod(c, 2 * m, a, m, d);
memcpy(c, d, sizeof(d));
}
memset(d, 0, sizeof(d));
cmult(b, m, b, m, b);
cmod(b, 2 * m, a, m, d);
memcpy(b, d, sizeof(d));
}
Vector ans;
for (int i = 0; i < n; i++) ans = ans + c[i] * first[i];
return ans;
};
Vector solve(Matrix &A, long long k, Vector &b) {
vector<Vector> vs;
vs.push_back(A * b);
for (int i = 1; i < m * 2; ++i) {
vs.push_back(A * vs.back());
}
if (k == 0) {
return b;
} else if (k <= m * 2) {
return vs[k - 1];
}
Vector x;
for (int i = 0; i < m; ++i) {
x[i] = rand() % MOD;
}
vector<int> a(m * 2);
for (int i = 0; i < m * 2; ++i) {
a[i] = vs[i] * x;
}
vector<int> s = Berlekamp(a);
s.erase(s.begin());
for (int i = 0; i < s.size(); ++i) {
s[i] = (MOD - s[i]) % MOD;
}
vector<Vector> vf(vs.begin(), vs.begin() + s.size());
return LinearRec(vf, s, k);
}
int n;
long long k;
int main() {
initinv();
scanf("%lld %d %d", &k, &m, &n);
Matrix A(m);
static int B[M][M] = {};
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; ++j) {
B[i][j] = 1;
}
}
for (int i = 0; i < n; ++i) {
char s[3];
scanf("%s", s);
int t1 =
'a' <= s[0] && s[0] <= 'z' ? t1 = s[0] - 'a' : t1 = s[0] - 'A' + 26;
int t2 =
'a' <= s[1] && s[1] <= 'z' ? t2 = s[1] - 'a' : t2 = s[1] - 'A' + 26;
B[t1][t2] = 0;
}
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j)
if (B[i][j]) A.setValue(i, j, B[i][j]);
A.reshuffle();
Vector b;
for (int i = 0; i < m; ++i) {
b[i] = 1;
}
int ans = solve(A, k - 1, b) * b;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[100010];
map<long long, long long> mp;
int main() {
int n, x, k;
scanf("%d%d%d", &n, &x, &k);
int num = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
if (k == 0) {
sort(a + 1, a + n + 1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i] % x == 0) continue;
int v = ((a[i] / x) + 1) * x;
long long p1 = upper_bound(a + 1, a + n + 1, v - 1) - a;
long long p2 = lower_bound(a + 1, a + n + 1, a[i]) - a;
ans += p1 - p2;
}
cout << ans << endl;
return 0;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
mp[1ll * (a[i] + x - 1) / x * x]++;
if (1ll * a[i] / x * x - 1ll * x * (k - 1) > 0)
ans += mp[1ll * a[i] / x * x - 1ll * x * (k - 1)];
}
mp.clear();
for (int i = n; i >= 1; i--) {
if (1ll * a[i] / x * x - 1ll * x * (k - 1) > 0)
ans += mp[a[i] / x * x - 1ll * x * (k - 1)];
mp[1ll * (a[i] + x - 1) / x * x]++;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, a, i;
cin >> n >> t;
for (i = 1; i <= n; i++) {
cin >> a;
t -= (86400 - a);
if (t <= 0) break;
}
cout << i << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MAXN = int(2e5);
int n, k, cnt, A, tot[2 * MAXN + 5];
bool flag;
long long ans;
int read(int &x) {
char c = getchar();
int a = 0, b = 1;
while ('0' > c || c > '9') b = c == '-' ? -1 : b, c = getchar();
while ('0' <= c && c <= '9') a = a * 10 + c - '0', c = getchar();
return x = a * b;
}
int main() {
read(n);
read(k);
tot[MAXN]++;
for (int i = 0; i < n; i++) {
read(A);
if (A == k) flag = true;
if (A > k) cnt++;
if (A < k) cnt--;
if (!flag)
tot[cnt + MAXN]++;
else
ans += tot[cnt + MAXN] + tot[cnt + MAXN - 1];
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
for (int t = 0; t < T; t++) {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int difference = 0;
bool used = false, possible = true;
for (int i = 0; i < n; i++) {
if (a[i] > b[i]) {
possible = false;
break;
} else if (a[i] == b[i]) {
continue;
} else {
if (used) {
possible = false;
break;
}
difference = b[i] - a[i];
while (i < n) {
if (b[i] - a[i] == difference) {
i++;
continue;
}
if (b[i] == a[i]) {
used = true;
break;
}
if (b[i] - a[i] != difference) {
possible = false;
break;
}
}
}
}
if (possible)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
int n, k, d;
int a[N];
struct node {
int l, r, maxn;
} tree[N << 2];
void init(int i, int l, int r) {
tree[i] = (node){l, r, 0};
if (l == r) return;
int mid = l + r >> 1;
init((i << 1), l, mid);
init((i << 1 | 1), mid + 1, r);
return;
}
void upd(int i, int pos, int val) {
if (tree[i].l == tree[i].r) {
tree[i].maxn = val;
return;
}
int mid = tree[i].l + tree[i].r >> 1;
if (mid >= pos)
upd((i << 1), pos, val);
else
upd((i << 1 | 1), pos, val);
tree[i].maxn = max(tree[(i << 1)].maxn, tree[(i << 1 | 1)].maxn);
return;
}
int qy(int i, int l, int r) {
if (tree[i].l >= l && tree[i].r <= r) return tree[i].maxn;
int mid = tree[i].l + tree[i].r >> 1;
int ans = 0;
if (l <= mid) ans = max(ans, qy((i << 1), l, r));
if (r > mid) ans = max(ans, qy((i << 1 | 1), l, r));
return ans;
}
int main() {
scanf("%d%d%d", &n, &k, &d);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
sort(a + 1, a + n + 1);
init(1, 1, n);
for (int i = n - k + 1; i >= 1; i--) {
int t = upper_bound(a + 1, a + n + 1, a[i] + d) - a;
t--;
if (t == n) {
upd(1, i, 1);
continue;
}
if (i + k > t + 1) continue;
upd(1, i, qy(1, i + k, t + 1));
}
if (qy(1, 1, 1) == 1)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
int *bg, *nd;
vector<int> ans;
vector<int> *adj;
void trans(int a, int flip0, int flip1, int flip) {
int w = 0;
if (flip == 0) {
if (flip0 == 1 && bg[a - 1] == nd[a - 1]) w = 1;
if (flip0 == 0 && bg[a - 1] != nd[a - 1]) w = 1;
if (w == 1) {
flip0 = (flip0 + 1) % 2;
ans.push_back(a);
}
} else {
if (flip1 == 1 && bg[a - 1] == nd[a - 1]) w = 1;
if (flip1 == 0 && bg[a - 1] != nd[a - 1]) w = 1;
if (w == 1) {
flip1 = (flip1 + 1) % 2;
ans.push_back(a);
}
}
for (auto e : adj[a]) {
trans(e, flip0, flip1, (flip + 1) % 2);
}
}
int main() {
int n = in(), a, b;
set<pair<int, int> > edges;
int *processed = (int *)calloc(n + 1, sizeof(int));
adj = (vector<int> *)calloc(n + 1, sizeof(vector<int>));
processed[1] = 1;
for (int i = 1; i < n; i++) {
a = in();
b = in();
if (processed[a] == 1) {
adj[a].push_back(b);
processed[b] = 1;
} else {
adj[b].push_back(a);
processed[a] = 1;
}
}
bg = (int *)malloc(sizeof(int) * n + 1);
nd = (int *)malloc(sizeof(int) * n + 1);
for (int i = 0; i < n; i++) bg[i] = in();
for (int i = 0; i < n; i++) nd[i] = in();
trans(1, 0, 0, 0);
cout << ans.size() << "\n";
for (auto e : ans) cout << e << "\n";
free(bg);
free(nd);
free(processed);
free(adj);
return (0);
}
| 3 |
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <string>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <numeric>
using namespace std;
#define REP(i, s, e) for (int i = (s); i < (e); i++)
#define REPI(i, s, e) for (int i = (s); i <= (e); i++)
#define rep(i, n) REP(i, 0, n)
#define repi(i, n) REPI(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
#define dump(x) (cout << #x << " = " << x << endl)
#define dump2(x, y) (cout << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")" << endl)
#define dump3(x, y, z) (cout << "(" << #x << ", " << #y << ", " << #z << ") = (" << x << ", " << y << ", "<< z << ")" << endl)
typedef long long ll;
typedef pair<int, int> pii;
int n, k;
const int MAX = 1121;
int pp[MAX];
vector<int> primes;
void erat()
{
memset(pp, -1, sizeof(pp));
pp[0] = pp[1] = 0;
for (int i = 2; i < MAX; i++)
for (int j = 2*i; j < MAX; j += i)
pp[j] = 0;
rep(i, MAX)
if (pp[i])
primes.push_back(i);
}
const int K_MAX = 16;
const int P_MAX = 190;
ll dp[MAX][K_MAX][P_MAX];
ll solve(int s, int c, int i)
{
if (s == n && c == k) return dp[s][c][i] = 1;
if (s >= n || c == k) return 0;
if (dp[s][c][i] != -1) return dp[s][c][i];
if (!(i < primes.size())) return dp[s][c][i] = 0;
int cnt = 0;
cnt += solve(s+primes[i], c+1, i+1);
cnt += solve(s, c, i+1);
return dp[s][c][i] = cnt;
}
int main()
{
erat();
const int psz = primes.size();
while (cin >> n >> k, n|k) {
memset(dp, -1, sizeof(dp));
cout << solve(0, 0, 0) << endl;
/*
memset(dp, 0, sizeof(dp));
for (int s = n; s >= 0; s--) {
for (int c = k; c >= 0; c--) {
for (int i = psz-1; i >= 0; i--) {
if (s == n && c == k) {
dp[s][c][i] = 1;
} else {
dp[s][c][i] = 0;
if (s+primes[i] <= n)
dp[s][c][i] += dp[s+primes[i]][c+1][i+1];
dp[s][c][i] += dp[s][c][i+1];
}
}
}
}
cout << dp[0][0][0] << endl;
*/
}
return 0;
}
| 0 |
#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_DEPRECATE
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <cfloat>
#include <ctime>
#include <cassert>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <list>
#include <iomanip>
#include <fstream>
#include <iterator>
#include <bitset>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
#define FOR(i,n) for(int i = 0; i < (n); i++)
#define sz(c) ((int)(c).size())
#define ten(x) ((int)1e##x)
#define tenll(x) ((ll)1e##x)
int main(){
string s; cin >> s;
vector<char> t;
for (auto c : s) {
if (sz(t) % 2 == 0 && c == 'A') t.push_back(c);
else if (sz(t) % 2 == 1 && c == 'Z') t.push_back(c);
}
if (sz(t) % 2 == 1) t.pop_back();
if (sz(t) == 0) cout << -1 << endl;
else cout << string(t.begin(),t.end()) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
using ll = long long;
int a[N], n;
ll m;
bool check(int k) {
ll sum = 0;
for (int i = 1, cnt = 0, d = 0; i <= n; ++i) {
sum += max(0, a[i] - d);
cnt++;
if (cnt % k == 0) d++;
}
return sum >= m;
}
int main() {
scanf("%d%lld", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
reverse(a + 1, a + 1 + n);
int l = 1, r = n + 1, mid, ans = -1;
while (l < r) {
if (check(mid = (l + r) / 2))
ans = mid, r = mid;
else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int ang, a, i;
cin >> ang;
ang += ang;
for (i = 1; i <= 360; i++) {
if (360 % i != 0) continue;
a = 360 / i;
if (ang % a == 0 && ang / a + 1 < i) {
cout << i << endl;
break;
}
}
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,k;
cin>>n>>k;
vector<int> a(n);
for(int& x:a)
cin>>x;
sort(a.begin(),a.end());
long long answer=0;
for(int i=0;i<n-k;++i)
answer+=a[i];
cout<<answer<<endl;
}
| 0 |
#include <bits/stdc++.h>
#define BASE 3000
#define RANGE 2500
using namespace std;
typedef long long ll;
int main() {
int n, a, x;
ll f[BASE*2+1], tmp[BASE*2+1];
cin >> n >> a;
f[BASE] = 1;
for(int i=0; i<n; i++) {
cin >> x;
x -= a;
fill(tmp, tmp+(BASE*2+1), 0);
for(int t=BASE-RANGE; t<=BASE+RANGE; t++) {
tmp[t+x] = f[t];
}
for(int t=0; t<=BASE*2; t++) {
f[t] += tmp[t];
}
}
cout << f[BASE]-1 << endl;
}
| 0 |
#include<bits/stdc++.h>
#define lp(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
while(1){
int n;
cin>>n;
if(n==0) break;
vector<pair<double,string> > lis;
lp(i,n){
string l;
int p,a,b,c,d,e,f,s,m;
cin>>l>>p>>a>>b>>c>>d>>e>>f>>s>>m;
double ans;
ans=(double)((f*m*s)-p)/(a+b+c+(d+e)*m);
lis.push_back(make_pair(-ans,l));
}
sort(lis.begin(),lis.end());
reverse(lis.begin(),lis.end());
while(!lis.empty()){
pair<double,string> gege = lis.back();
cout<<gege.second<<endl;
lis.pop_back();
}
cout<<"#"<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000009, maxn = 400000;
const long long INF = 1000000000ll * 1000000000ll;
int rmq[maxn << 2];
int n;
void insert(int i, int w) {
int id = 1, l = 0, r = n, m;
while (l < r) {
m = (l + r) / 2;
id *= 2;
if (i <= m)
r = m;
else
l = m + 1, ++id;
}
rmq[id] = w;
id /= 2;
while (id >= 1) {
rmq[id] = max(rmq[id * 2], rmq[id * 2 + 1]);
id /= 2;
}
}
int maxf(int i, int l, int r, int nl, int nr) {
if (r < nl || nr < l || l > r) return 0;
if (nl <= l && r <= nr) return rmq[i];
int m = (l + r) / 2;
return max(maxf(i * 2, l, m, nl, nr), maxf(i * 2 + 1, m + 1, r, nl, nr));
}
int L, d, af;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
scanf("%d", &af);
int tmp = maxf(1, 0, n, 0, af - 1) + 1;
insert(af, tmp);
}
cout << rmq[1] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 2e5 + 5;
int n;
vector<int> adj[N];
long long ans, V[N], down[N], size[N];
void dfs(int s, int dad) {
size[s] = 1;
down[s] = V[s];
for (auto i : adj[s]) {
if (i == dad) continue;
dfs(i, s);
size[s] += size[i];
down[s] += V[s] * size[i] - down[i] + MOD;
down[s] %= MOD;
}
}
void ComputeAns(int u, int dad, int t) {
long long total = down[u] + V[u] * (n - size[u]) - t + MOD;
total %= MOD;
ans += total;
ans %= MOD;
for (auto i : adj[u]) {
if (i == dad) continue;
ComputeAns(i, u, (total - V[u] * size[i] + down[i] + MOD) % MOD);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> V[i];
if (V[i] < 0) V[i] += MOD;
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
ComputeAns(1, 1, 0);
cout << ans << '\n';
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.