solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long sum(long long n) {
long long r = 0;
while (n != 0) {
r++;
n = n / 10;
}
return r;
}
long long powr(long long base, long long n) {
long long sum = 1;
for (int i = 1; i <= n; i++) sum *= base;
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long p, d;
cin >> p >> d;
p++;
long long ans = p;
long long i = 10;
while (p % i <= d) {
ans = p - p % i;
i *= 10;
}
cout << ans - 1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void uin(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
void uax(T &a, T b) {
if (b > a) a = b;
}
const long long MOD = 998244353;
long long mod(long long x) {
x %= MOD;
if (x < 0) x += MOD;
return x;
}
const long long N = 200 * 1000 + 228;
long long n, m;
long long a[N], b[N];
long long left228[N], right228[N];
long long suff[N];
map<long long, long long> last;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
}
for (long long i = 1; i <= m; ++i) {
cin >> b[i];
}
if (m == 1) {
for (long long i = 2; i <= n; ++i) {
uin(a[1], a[i]);
}
if (a[1] != b[1]) {
cout << 0 << '\n';
} else {
cout << 1 << endl;
}
return 0;
}
suff[m + 1] = n + 1;
for (long long x = m; x; --x) {
suff[x] = suff[x + 1];
while (suff[x] - 1 >= 1 && a[suff[x] - 1] >= b[x]) {
--suff[x];
}
if (suff[x] > n) {
cout << 0 << '\n';
return 0;
}
}
if (suff[1] != 1) {
cout << 0 << '\n';
return 0;
}
for (long long x = 1; x < m; ++x) {
if (suff[x] == suff[x + 1]) {
cout << 0 << '\n';
return 0;
}
}
for (long long i = 1; i <= n; ++i) {
last[a[i]] = i;
}
long long ans = 1;
if (last[b[1]] == 0) {
cout << 0 << endl;
return 0;
}
for (long long i = 2; i <= m; ++i) {
if (last[b[i]] == 0) {
cout << 0 << '\n';
return 0;
}
if (last[b[i]] - suff[i] < 0) {
cout << 0 << '\n';
return 0;
}
ans = mod(ans * (last[b[i]] - suff[i] + 1));
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
inline long long p(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) ans = ans * a % mod;
return ans;
}
inline long long inv(long long x) { return p(x, mod - 2); }
const int mn = 1e3 + 10;
long long dp[mn][mn], sum[mn][mn];
long long pr;
int main() {
long long k, pa, pb;
cin >> k >> pa >> pb;
int i, j;
dp[0][0] = dp[0][1] = 1;
pr = pa * inv(pa + pb) % mod;
for (i = 2; i <= k; i++) dp[0][i] = pr * dp[0][i - 1] % mod;
for (i = 1; i < k; i++) {
for (j = 1; j <= k; j++) {
if (i >= j) dp[i][j] = dp[i - j][j] * (1 - pr);
dp[i][j] += dp[i][j - 1] * pr;
dp[i][j] %= mod;
}
}
long long ans = 0;
for (i = 0; i < k; i++) {
for (j = k - i; j < k; j++) {
ans += dp[i][j] * (1 - pr) % mod * (i + j);
ans %= mod;
}
ans += inv(1 - pr) * dp[i][j] + (i + j - 1) * dp[i][j];
ans %= mod;
}
if (ans < 0) ans += mod;
printf("%lld", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
const int mod = 1000000007;
const long long maxLim = 1e16;
int arr[maxn], dp[maxn];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
std::vector<int> mx, mn;
dp[0] = 0;
mx.push_back(0);
mn.push_back(0);
for (int i = 1; i < n; i++) {
dp[i] = dp[i - 1] + 1;
if (arr[i] == arr[i - 1]) {
mx.back() = i;
mn.back() = i;
continue;
}
if (arr[i - 1] < arr[i]) {
while (!mx.empty() && arr[mx.back()] < arr[i]) {
dp[i] = min(dp[i], dp[mx.back()] + 1);
mx.pop_back();
}
if (!mx.empty()) {
dp[i] = min(dp[i], dp[mx.back()] + 1);
if (arr[mx.back()] == arr[i]) mx.pop_back();
}
} else {
while (!mn.empty() && arr[mn.back()] > arr[i]) {
dp[i] = min(dp[i], dp[mn.back()] + 1);
mn.pop_back();
}
if (!mn.empty()) {
dp[i] = min(dp[i], dp[mn.back()] + 1);
if (arr[mn.back()] == arr[i]) mn.pop_back();
}
}
mn.push_back(i);
mx.push_back(i);
}
cout << dp[n - 1];
return;
}
int main() {
int t = 1;
for (int q = 1; q <= t; q++) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans, a[111];
bool f = true;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0, d; i < n; ++i) {
cin >> d;
++a[d];
}
while (f) {
f = false;
for (int i = k - 1; i > 0; --i) {
if (a[i]) {
f = true;
--a[i];
++a[i + 1];
}
}
ans += f;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx4[] = {-1, 0, 1, 0};
int dy4[] = {0, 1, 0, -1};
int dx8[] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
void Duxar(int _this_line) {}
bool AreEqual(double a, double b) { return (fabs(a - b) < 1e-10); }
template <class T>
bool GetNr(T &_value) {
T _sign = 1;
char ch;
_value = 0;
while (!isdigit(ch = getchar())) {
if (ch == -1) {
return false;
}
ch == '-' ? _sign = -1 : _sign = 1;
}
do {
_value = _value * 10 + (ch - '0');
} while (isdigit(ch = getchar()));
_value *= _sign;
return true;
}
class Rectangle {
public:
long long key;
int id, val;
Rectangle() {}
Rectangle(long long key, int val, int id) {
this->key = key;
this->id = id;
this->val = val;
}
};
int N, best;
vector<int> ans, marbles;
vector<Rectangle> values;
void AddMarbles(vector<int> v, int id) {
if (v[2] < min(v[0], v[1]))
values.push_back(Rectangle((long long)v[0] * 1000000000 + v[1], v[2], id));
if (v[0] < min(v[2], v[1]))
values.push_back(Rectangle((long long)v[1] * 1000000000 + v[2], v[0], id));
if (v[1] < min(v[0], v[2]))
values.push_back(Rectangle((long long)v[0] * 1000000000 + v[2], v[1], id));
}
bool ByKey(Rectangle a, Rectangle b) { return a.key < b.key; }
bool ByPair(Rectangle a, Rectangle b) {
return make_pair(a.key, a.val) < make_pair(b.key, b.val);
}
int main() {
string fileInput = "sum";
int i, j;
GetNr(N);
values.reserve(N * 3);
marbles.resize(3);
for (i = 0; i < N; ++i) {
int vmin = 1000992299;
for (j = 0; j < 3; ++j) {
GetNr(marbles[j]);
vmin = min(vmin, marbles[j]);
}
sort((marbles).begin(), (marbles).end());
AddMarbles(marbles, i + 1);
if (best < vmin) {
best = vmin;
ans.clear();
ans.push_back(i + 1);
}
}
sort((values).begin(), (values).end(), ByPair);
for (i = 0; i < values.size(); ++i) {
int nextp =
(int)(upper_bound(values.begin() + i, values.end(), values[i], ByKey) -
values.begin());
--nextp;
i = nextp;
for (j = i - 1; j >= 0 && values[j].key == values[i].key; --j) {
if (values[j].id != values[i].id) {
int x, y;
x = values[i].key % 1000000000;
y = values[i].key / 1000000000;
if (best < min(min(x, y), values[j].val + values[i].val)) {
best = min(min(x, y), values[j].val + values[i].val);
ans.clear();
ans.push_back(values[j].id);
ans.push_back(values[i].id);
break;
}
}
}
}
printf("%d\n", (int)ans.size());
for (auto m : ans) {
printf("%d ", m);
}
putchar('\n');
;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long pw(int a, int b) {
long long rt = 1;
for (int i = 0; i < b; i++) {
rt *= a % 1000000007;
rt %= 1000000007;
}
return rt;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int h, w;
cin >> h >> w;
vector<int> rs;
vector<int> cs;
for (int i = 0; i < h; i++) {
int t;
cin >> t;
rs.push_back(t);
}
for (int i = 0; i < w; i++) {
int t;
cin >> t;
cs.push_back(t);
}
int grd[h][w];
memset(grd, 0, sizeof(grd));
for (int i = 0; i < rs.size(); i++) {
int j = 0;
for (; j < rs[i]; j++) {
grd[i][j] = 1;
}
if (j < w) grd[i][j] = -1;
}
for (int i = 0; i < cs.size(); i++) {
int j = 0;
for (; j < cs[i]; j++) {
if (grd[j][i] == -1) {
cout << 0 << endl;
return 0;
}
grd[j][i] = 1;
}
if (j < h) {
if (grd[j][i] == 1) {
cout << 0 << endl;
return 0;
}
grd[j][i] = -1;
}
}
int cnt = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (grd[i][j] == 0) cnt++;
}
}
cout << pw(2, cnt) % 1000000007 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 36;
const long long M = 5e2 + 36;
const long long INF = 2e9 + 7;
const long long MOD = 987654323;
const long long MOD1 = 1e9 + 7;
const long long MOD2 = 1e9 + 9;
const int XK[4] = {-1, 0, 1, 0};
const int YK[4] = {0, -1, 0, 1};
const int X[8] = {1, 1, -1, -1, 2, 2, -2, -2};
const int Y[8] = {2, -2, 2, -2, 1, -1, 1, -1};
int n, d, b;
int a[N], c[N];
int solve() {
for (int i(0); i < n; ++i) {
c[i] = 0;
}
int ans = 0;
for (int i(0); i < n; ++i) {
int l = 0, r = i, ans = i;
while (l <= r) {
int mid = (l + r) >> 1;
int mve = max(((i - mid + d - 1) / d) - 1, 0);
if (mid >= mve) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
}
c[ans] += a[i];
}
for (int i(0); i < n; ++i) {
if (c[i] < b) {
ans++;
c[i + 1] += c[i];
} else {
c[i + 1] += c[i] - b;
}
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> d >> b;
for (int i(0); i < n; ++i) {
cin >> a[i];
}
int ans = solve();
reverse(a, a + n);
ans = max(ans, solve());
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
int d[maxn][maxn];
pair<int, int> p[maxn];
int r[maxn];
int n, m, q;
vector<int> g[maxn], h[maxn];
queue<int> Q;
int id[maxn];
long long sqr(int first) { return 1ll * first * first; }
double dist(pair<int, int> a, pair<int, int> b) {
return sqrt(sqr(a.first - b.first) + sqr(a.second - b.second));
}
bool in(pair<int, int> a, pair<int, int> b, int r) { return dist(a, b) < r; }
bool cmp(int a, int b) { return r[a] < r[b]; }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = (1), _b = (n); i <= _b; ++i)
scanf("%d%d", &p[i].first, &p[i].second);
for (int i = (1), _b = (m); i <= _b; ++i)
scanf("%d%d%d", &r[i + n], &p[i + n].first, &p[i + n].second);
for (int i = (1), _b = (m); i <= _b; ++i) id[i] = i + n;
sort(id + 1, id + 1 + m, cmp);
for (int i = (1), _b = (m); i <= _b; ++i) {
for (int j = (i + 1), _b = (m + 1); j <= _b; ++j) {
if (j == m + 1) g[0].push_back(id[i]);
if (in(p[id[i]], p[id[j]], r[id[j]])) {
g[id[j]].push_back(id[i]);
break;
}
}
}
for (int i = (1), _b = (n); i <= _b; ++i) {
for (int j = (1), _b = (m + 1); j <= _b; ++j) {
if (j == m + 1) g[0].push_back(i);
if (in(p[i], p[id[j]], r[id[j]])) {
g[id[j]].push_back(i);
break;
}
}
}
for (int u = (0), _b = (n + m); u <= _b; ++u) {
for (int i = (0), _b = (int((g[u]).size())); i < _b; ++i)
h[g[u][i]].push_back(u), h[u].push_back(g[u][i]);
}
for (int s = (1), _b = (n); s <= _b; ++s) {
d[s][s] = 1;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = (0), _b = (int((h[u]).size())); i < _b; ++i) {
int v = h[u][i];
if (!d[s][v]) d[s][v] = d[s][u] + 1, Q.push(v);
}
}
}
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
if (u == v)
printf("0\n");
else
printf("%d\n", d[u][v] - 3);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define boost ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define tests ll test; cin >> test; while(test--)
#define fora(i, x, y) for (ll i = x; i <= y; ++i)
#define ford(i, x, y) for (ll i = x; i >= y; --i)
#define printlst(lst, x, y) fora(i, x, y) cout << lst[i] << " "; cout << endl;
#define inputlst(lst, x, y) fora(i, x, y) cin >> lst[i]
#define all(lst) lst.begin(), lst.end()
#define sortlst(lst) sort(all(lst))
#define setbits(n) __builtin_popcount(n)
#define sortarr(x, n, y) sort(x, x + n)
typedef pair<ll, ll> pl;
typedef pair<int, int> pi;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef vector<vl> vovl;
typedef vector<vi> vovi;
typedef vector<string> vs;
typedef set<ll> sl;
typedef unordered_map<ll, ll> uml;
typedef map<ll, ll> ml;
#define forn(i, n) for (int i = 0; i < int(n); i++)
int calc(const vector<int> &a, const vector<int> &b){
int n = a.size();
int m = b.size();
vector<int> su(n + 1);
int r = m - 1;
for (int i = n - 1; i >= 0; --i){
su[i] = su[i + 1];
while (r >= 0 && b[r] > a[i]) --r;
if (r >= 0 && b[r] == a[i]) ++su[i];
}
int ans = 0;
int j = 0;
r = 0;
forn(l, m){
while (j < n && a[j] <= b[l] + j) ++j;
while (r < m && b[r] - b[l] < j) ++r;
ans = max(ans, r - l + su[j]);
}
return ans;
}
int main()
{
boost;
tests
{
ll m, n, x;
cin >> n >> m;
vi al, bl, ar, br;
fora(i, 0, n - 1)
{
cin >> x;
if (x < 0) al.push_back(-x);
else ar.push_back(x);
}
fora(i, 0, m - 1)
{
cin >> x;
if (x < 0) bl.push_back(-x);
else br.push_back(x);
}
reverse(all(al)), reverse(all(bl));
cout << calc(al, bl) + calc(ar, br) << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class T2>
inline void chkmax(T &x, const T2 &y) {
if (x < y) x = y;
}
template <class T, class T2>
inline void chkmin(T &x, const T2 &y) {
if (x > y) x = y;
}
const int MAXN = (1 << 20);
const int MAXLOG = 20;
template <class T>
struct fenwick {
int sz;
T tr[MAXN];
void init(int _sz) {
sz = _sz + 1;
memset(tr, 0, sizeof(tr));
}
T query(int idx) {
T ans = 0;
for (; idx >= 1; idx -= (idx & -idx)) ans += tr[idx];
return ans;
}
void update(int idx, T val) {
if (idx <= 0) return;
for (; idx <= sz; idx += (idx & -idx)) tr[idx] += val;
}
void update(int l, int r, T val) {
update(l, val);
update(r + 1, -val);
}
};
int n, m;
vector<int> G[MAXN];
void read() {
cin >> n >> m;
for (int i = 2; i <= n; i++) {
int u;
cin >> u;
G[u].push_back(i);
}
}
int st[MAXN], en[MAXN], dfs_time = 0;
int par[MAXN][MAXLOG];
void dfs_lca(int u) {
st[u] = ++dfs_time;
for (int i = 1; i < MAXLOG; i++) par[u][i] = par[par[u][i - 1]][i - 1];
for (int v : G[u])
if (v != par[u][0]) {
par[v][0] = u;
dfs_lca(v);
}
en[u] = dfs_time;
}
inline bool upper(int u, int v) { return st[u] <= st[v] && en[v] <= en[u]; }
int lca(int u, int v) {
if (upper(u, v)) return u;
if (upper(v, u)) return v;
int a = u;
for (int i = MAXLOG - 1; i >= 0; i--)
if (!upper(par[a][i], v)) a = par[a][i];
return par[a][0];
}
int parent(int u, int up) {
int a = u;
for (int i = MAXLOG - 1; i >= 0; i--)
if (up & (1 << i)) a = par[a][i];
return a;
}
void lca_precompute(int root) {
for (int i = 0; i < MAXLOG; i++) par[root][i] = root;
dfs_time = 0;
dfs_lca(root);
}
int dp[MAXN];
fenwick<int> t;
int Fr[MAXN], Sc[MAXN], C[MAXN];
vector<int> li[MAXN];
void dfs(int u) {
int sum_all = 0;
for (int v : G[u]) {
dfs(v);
sum_all += dp[v];
}
dp[u] = sum_all;
for (int idx : li[u]) {
int cand = C[idx] + t.query(st[Fr[idx]]) + t.query(st[Sc[idx]]) + sum_all;
chkmax(dp[u], cand);
}
t.update(st[u], en[u], sum_all - dp[u]);
}
void solve() {
lca_precompute(1);
for (int i = 0; i < m; i++) {
cin >> Fr[i] >> Sc[i] >> C[i];
li[lca(Fr[i], Sc[i])].push_back(i);
}
t.init(dfs_time + 42);
dfs(1);
cout << dp[1] << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
return os << vc<t>(first.begin(), first.end());
}
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
template <class t>
void print(t x, ll suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(ll n, ll off = 0) {
vi v(n);
for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
for (ll i = ll(0); i < ll(v.size()); i++)
print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes"
<< "\n";
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No"
<< "\n";
if (ex) exit(0);
}
void possible(bool ex = true) {
cout << "Possible"
<< "\n";
if (ex) exit(0);
}
void impossible(bool ex = true) {
cout << "Impossible"
<< "\n";
if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
bool inc(ll first, ll second, ll c) { return first <= second && second <= c; }
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static random_device rd;
static mt19937_64 gen(rd());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
using ld = ll;
using cm = complex<ld>;
const ld eps = 0;
ll sgn(ld first) { return first < -eps ? -1 : (first > eps ? 1 : 0); }
ld rabs(cm first) { return max(abs(first.real()), abs(first.imag())); }
ld signed_rabs(cm first) {
if (abs(first.real()) > abs(first.imag()))
return first.real();
else
return first.imag();
}
ld dot(cm first, cm second) {
return first.real() * second.real() + first.imag() * second.imag();
}
ld crs(cm first, cm second) {
return first.real() * second.imag() - first.imag() * second.real();
}
ld crs(cm first, cm second, cm c) { return crs(second - first, c - first); }
ll ccw(cm first, cm second) { return sgn(crs(first, second)); }
ll ccw(cm first, cm second, cm c) { return ccw(second - first, c - first); }
auto cmless = [](cm first, cm second) {
ll s = sgn(first.real() - second.real());
if (s)
return s < 0;
else
return sgn(first.imag() - second.imag()) < 0;
};
bool cmeq(cm first, cm second) {
return sgn(first.real() - second.real()) == 0 &&
sgn(first.imag() - second.imag()) == 0;
};
ll argtype(cm first) {
if (sgn(first.imag()) == 0) return first.real() < 0 ? 1 : 0;
return first.imag() < 0 ? 0 : 1;
}
ll argcmp(cm first, cm second) {
ll at = argtype(first), bt = argtype(second);
if (at != bt) return at < bt ? -1 : 1;
return -ccw(first, second);
};
bool argless(cm first, cm second) { return argcmp(first, second) < 0; }
ll bet(cm first, cm second, cm c) {
cm d = second - first;
ld e = dot(d, c - first);
if (sgn(e) <= 0) return sgn(e) - 1;
return sgn(e - norm(d)) + 1;
}
ll qeq(ld first, ld second, ld c, ld& d, ld& e) {
ld f = second * second - 4 * first * c;
if (sgn(f) < 0) return 0;
ld g = sqrt(max(f, ld(0)));
d = (-second + g) / (2 * first);
e = (-second - g) / (2 * first);
return sgn(f) + 1;
}
ll cont(cm first, cm second, cm c, cm d) {
if (ccw(first, second, c) == -1) swap(second, c);
return min({ccw(first, second, d), ccw(second, c, d), ccw(c, first, d)}) + 1;
}
ld arg(ld first, ld second, ld c) {
return acos(
min(max((first * first + second * second - c * c) / (2 * first * second),
ld(-1)),
ld(1)));
}
ld turn(cm first, cm second, cm c) {
return arg((c - second) / (second - first));
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
ll n;
cin >> n;
ll ans = 0;
vc<cm> ps;
for (ll i = ll(0); i < ll(n); i++) {
ll first, second;
cin >> first >> second;
ps.emplace_back(first, second);
}
for (ll i = ll(0); i < ll(n); i++) {
vc<cm> z;
for (ll j = ll(0); j < ll(n); j++)
if (i != j) z.push_back(ps[j] - ps[i]);
sort(z.begin(), z.end(), argless);
ll s = n - 1;
ll k = 0;
for (ll j = ll(0); j < ll(s); j++) {
while (k < s && ccw(z[j], z[(j + k) % s]) >= 0) k++;
assert(k > 0);
ans += (k - 1) * (k - 2) * (k - 3) / 6;
k--;
}
}
cout << n * (n - 1) * (n - 2) * (n - 3) * (n - 4) / 120 * 5 - ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500006;
char a[4][N];
vector<int> bit;
int n, m;
vector<int> g[8];
int f[N][8];
void solve2() {
int ans1 = 0, ans2 = 0;
for (int i = 0; i < bit.size(); i += 2) {
if (bit[i] == 0 || bit[i] == 3) ans1++;
if ((bit[i + 1] == 1 || bit[i + 1] == 2) && i + 1 < bit.size()) ans1++;
}
for (int i = 0; i < bit.size(); i += 2) {
if (bit[i] == 1 || bit[i] == 2) ans2++;
if (i + 1 < bit.size() && (bit[i + 1] == 0 || bit[i + 1] == 3)) ans2++;
}
printf("%d", min(ans1, ans2));
}
void solve3() {
g[0] = {5, 2};
g[1] = {4, 3};
g[2] = {7, 0};
g[3] = {1, 6};
g[4] = {1, 6};
g[5] = {0, 7};
g[6] = {4, 3};
g[7] = {5, 2};
for (int i = 0; i < 8; i++) {
f[0][i] = __builtin_popcount(i ^ bit[0]);
}
for (int i = 1; i < bit.size(); i++)
for (int j = 0; j < 8; j++) {
f[i][j] = min(f[i - 1][g[j][0]] + __builtin_popcount(j ^ bit[i]),
f[i - 1][g[j][1]] + __builtin_popcount(j ^ bit[i]));
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < 8; i++) ans = min(ans, f[bit.size() - 1][i]);
printf("%d", ans);
}
int main() {
scanf("%d%d", &n, &m);
if (n >= 4 && m >= 4) {
puts("-1");
return 0;
}
if (n == 1 || m == 1) {
puts("0");
return 0;
}
for (int i = 0; i < n; i++) scanf("%s", a[i]);
for (int i = 0; i < m; i++) {
int x = 0;
for (int j = 0; j < n; j++) {
if (j) x <<= 1;
x += a[j][i] - '0';
}
bit.push_back(x);
}
if (n == 2)
solve2();
else
solve3();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> m;
long long X[200005];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long> v;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
long long d = 0;
while (x % (1LL << d) == 0) {
d++;
}
m[d - 1]++;
X[i] = d - 1;
}
int mx = -1;
long long mxd = 0;
for (auto& p : m) {
if (p.second > mx) {
mx = p.second;
mxd = p.first;
}
}
vector<long long> ans;
for (int i = 0; i < n; i++) {
if (X[i] != mxd) {
ans.push_back(v[i]);
}
}
cout << ans.size() << endl;
for (auto& x : ans) {
cout << x << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int A[200025] = {0};
int P = 0, V = 1;
V = min(n, m);
P = max(n, m) - 1;
cout << P << " " << V << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, arr[10000], res = 0, i, j = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
i = n - 1;
while (i >= 0) {
for (j = 0; j <= arr[i]; j++) {
if ((j * j) == arr[i]) {
res = 1;
break;
}
}
if (res) {
i--;
res = 0;
} else {
break;
}
}
cout << arr[i];
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 1e6 + 6;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
long long qp(long long x, long long y) {
long long ans = 1;
x %= mod;
while (y) {
if (y & 1) ans = ans * x % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long inv(long long x) { return qp(x, mod - 2); }
int n, k, a[maxn], sum[maxn], dp[maxn];
char s[maxn];
vector<int> op[maxn * 9];
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
int cnt = 0;
for (int i = n; i >= 1; i--) {
if (s[i] == 'L')
cnt++;
else
sum[i] = cnt;
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += sum[i];
if (ans < k) {
puts("-1");
return 0;
}
cnt = 0;
while (1) {
if (k == ans) {
for (int i = n; i >= 1; i--) {
int c = sum[i], now = i;
while (c && now < n) {
c--;
op[++cnt].push_back(now++);
}
}
for (int i = 1; i <= cnt; i++) {
printf("%d", op[i].size());
sort(op[i].begin(), op[i].end());
for (int j : op[i]) printf(" %d", j);
printf("\n");
}
return 0;
}
int flag = 0;
cnt++;
for (int i = 1; i < n; i++) {
if ((sum[i]) && (!sum[i + 1])) {
op[cnt].push_back(i);
sum[i + 1] = sum[i] - 1;
sum[i] = 0;
ans--;
if (!flag) k--;
flag = 1;
if (k == ans) break;
i++;
}
}
if (!flag) break;
}
printf("-1\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[512][512], b[512], n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", a[i] + j);
for (int i = 1; i <= n; ++i) scanf("%d", b + i);
for (int i = 1; i <= n; ++i) {
int t = 0, s = 1000, h = 0, jj;
for (int j = 1; j <= n; ++j)
if (j != i) {
for (int k = 1; k <= n; ++k)
if (b[k] <= j && b[k] != i) {
t = b[k];
break;
}
for (int k = 1; k <= n; ++k)
if (a[i][k] == t) {
h = k;
break;
}
if (h < s) {
s = h;
jj = j;
}
}
printf("%d ", jj);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5) + 5;
const int M = 1000000007;
int ans, n, m, k, r;
int a[N], b[N], p[N], s[N];
int cnt[19][N];
void add(int &x, int y) {
x += y;
if (x >= M) x -= M;
}
void sub(int &x, int y) {
x -= y;
if (x < 0) x += M;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) b[i] = (b[i - 1] + a[i - 1]) % k;
for (int i = 0; i < n; ++i) cnt[0][b[i]]++;
r = p[0] = b[n];
for (int i = 1; i <= 17; ++i) {
for (int j = 0; j < k; ++j) {
add(cnt[i][j], cnt[i - 1][j]);
add(cnt[i][(j + r) % k], cnt[i - 1][j]);
}
r = r * 2 % k;
p[i] = r;
}
r = 0;
for (int i = 17; i >= 0; --i)
if ((m >> i) & 1) {
for (int j = 0; j < k; ++j) add(s[(j + r) % k], cnt[i][j]);
r = (r + p[i]) % k;
}
ans = 0;
for (int i = 0; i < n; ++i) {
sub(s[b[i]], 1);
add(ans, s[b[i]]);
add(s[(b[i] + r) % k], 1);
}
ans = 1ll * ans * m % M;
if (!r) add(ans, 1);
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
Point(int p, int q) : x(p), y(q) {}
};
int n;
int arr[51][51];
vector<Point> fuck1, fuck2;
vector<bool> visited(100000, 0);
vector<int> xdisplace = {-1, 1, 0, 0};
vector<int> ydisplace = {0, 0, -1, 1};
long long num(Point a) {
long long p = a.x, q = a.y;
return (p + q) * (p + q + 1) / 2 + q;
}
long long dist(Point a, Point b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
void dfs1(Point a) {
arr[a.x][a.y] = 1;
fuck1.push_back(a);
for (int i = 0; i < 4; ++i) {
Point temp = {a.x + xdisplace[i], a.y + ydisplace[i]};
if (temp.x >= 1 && temp.x <= n && temp.y >= 1 && temp.y <= n &&
arr[temp.x][temp.y] == 0)
dfs1(temp);
}
}
void dfs2(Point a) {
arr[a.x][a.y] = 1;
fuck2.push_back(a);
for (int i = 0; i < 4; ++i) {
Point temp = {a.x + xdisplace[i], a.y + ydisplace[i]};
if (temp.x >= 1 && temp.x <= n && temp.y >= 1 && temp.y <= n &&
arr[temp.x][temp.y] == 0)
dfs2(temp);
}
}
long long solve() {
long long ans = INT_MAX;
for (auto x : fuck1) {
for (auto y : fuck2) {
ans = min(ans, dist(x, y));
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int r1, c1, r2, c2;
cin >> n;
cin >> r1 >> c1 >> r2 >> c2;
Point x = {r1, c1}, y = {r2, c2};
for (long long int i = 1; i <= n; ++i) {
string s;
cin >> s;
for (long long int j = 1; j <= n; ++j) {
arr[i][j] = s[j - 1] - '0';
}
}
dfs1(x);
dfs2(y);
cout << solve() << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> odd, even;
string s;
int ind;
long long a, b, n, m, ans;
int main() {
scanf("%lld ", &n);
for (int i = 0; i < n; ++i) {
scanf("%lld", &a);
if (a % 2 == 0)
even.push_back(a);
else
odd.push_back(a);
}
sort(even.rbegin(), even.rend());
sort(odd.rbegin(), odd.rend());
int poev = 0, pood = 0;
int ind = odd.size();
if (odd.size() % 2 == 0) ind--;
for (int i = 0; i < ind; ++i) ans += odd[i];
if (ans > 0)
for (int i = 0; i < even.size(); ++i) ans += even[i];
printf("%lld", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool pos(vector<int>& count, int k, int val, int n) {
int c = 0;
for (int i = 0; i < n; i++) {
c += count[i] / val;
}
if (c >= k) return 1;
return 0;
}
int main() {
long long n, k;
cin >> n >> k;
vector<int> arr(n);
map<int, int> my;
for (int i = 0; i < n; i++) {
cin >> arr[i];
my[arr[i]]++;
}
vector<int> count;
for (auto i : my) {
count.push_back(i.second);
}
sort(count.begin(), count.end());
int high = 200006;
int low = 1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (pos(count, k, mid, count.size())) {
low = mid + 1;
} else
high = mid - 1;
}
int cur = 0;
for (auto i : my) {
int mn = i.second / high;
while (cur < k and mn > 0) {
cout << i.first << " ";
mn--;
cur++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxlen = 2000000;
const long long mod = 1e9 + 7;
long long n, k, ans, now;
long long m[2 * maxlen + 5], p[2 * maxlen + 5], cf[2 * maxlen + 5],
q[2 * maxlen + 5];
long long quick_power(long long x, long long y) {
long long res = 1;
for (; y; y = y >> 1, x = (x * x) % mod) {
if (y & 1) res = (res * x) % mod;
}
return res % mod;
}
inline void init1() {
for (register long long i = 1; i <= maxlen; ++i) m[i] = p[i] = 1;
for (register long long i = 2; i <= maxlen; ++i) {
if (p[i] == 0) continue;
m[i] = -1;
for (register long long j = 2 * i; j <= maxlen; j += i) {
p[j] = 0;
m[j] = m[j] * (-1);
if ((j / i) % i == 0) m[j] = 0;
}
}
}
inline void init2() {
for (register long long i = 1; i <= k; ++i) q[i] = quick_power(i, n);
for (register long long i = 1; i <= k; ++i) {
for (register long long j = i; j <= k; j += i) {
cf[j] = (cf[j] + q[j / i] * m[i]) % mod,
cf[j + i] = (cf[j + i] - q[j / i] * m[i]) % mod;
}
}
long long tot = 0;
for (register long long i = 1; i <= k; ++i) {
tot = (tot + cf[i]) % mod, cf[i] = tot;
}
}
signed main() {
cin >> n >> k;
init1();
init2();
for (register long long i = 1; i <= k; ++i) cf[i] = (cf[i] % mod + mod) % mod;
for (register long long i = 1; i <= k; ++i) ans = (ans + (cf[i] ^ i)) % mod;
cout << (ans % mod + mod) % mod << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long sum[3][3][2100010];
long long a[2000100], b[2001000];
char s[2000100];
long long cti(char x) {
if (x == 'R') return 0;
if (x == 'G') return 1;
if (x == 'B') return 2;
}
signed main() {
scanf("%s", s + 1);
long long n = strlen(s + 1);
for (long long i = 1; i <= n; ++i) a[i] = cti(s[i]);
scanf("%s", s + 1);
long long m = strlen(s + 1);
for (long long i = 1; i <= m; ++i) b[i] = cti(s[i]);
for (long long i = 0; i <= 2; ++i)
for (long long j = 0; j <= 2; ++j) {
for (long long k = 1; k <= m; ++k) {
if (b[k - 1] == i && b[k] == j) sum[i][j][k] = 1;
sum[i][j][k] += sum[i][j][k - 1];
}
}
long long l = 1, r = 1;
while (r < m && b[r] != a[1]) r++;
long long ans = r - l + 1;
for (long long i = 2; i <= n; ++i) {
if (l <= m && a[i - 1] == b[l]) l++;
if (l > m) break;
if (r < m) {
r++;
while (r < m && b[r] != a[i]) r++;
}
ans += r - l + 1;
if (a[i] != a[i - 1])
ans -= sum[a[i]][a[i - 1]][r] - sum[a[i]][a[i - 1]][l - 1];
}
printf("%lld", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int N = sqrt(n);
int prime[n + 10];
memset(prime, 0, sizeof(prime));
prime[0] = 1;
prime[1] = 1;
for (int i = 2; i <= n; i++) {
int j = 0;
while ((i * i) + (i * j) <= n) {
prime[(i * i) + (i * j)] = 1;
j++;
}
}
vector<int> ans;
for (int i = 0; i <= n; i++) {
if (!prime[i]) {
int q = 1;
while (q <= n / i) {
q *= i;
ans.push_back(q);
}
}
}
int len = ans.size();
cout << len << endl;
for (int i = 0; i < len; i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const double eps = 1e-9;
const double pi = acos(-1);
using namespace std;
int n;
long long k;
string s;
int main() {
cin >> n >> k;
getchar();
cin >> s;
int ls = s.size();
if (k == 0) {
cout << s << endl;
} else {
for (int i = 0; i < ls - 1; i++) {
if (s[i] == '4' && s[i + 1] == '7') {
k--;
if ((i + 1) % 2) {
s[i] = s[i + 1] = '4';
if (i + 2 < ls && s[i + 2] == '7') {
if (k % 2 == 1)
s[i + 1] = '7';
else
s[i + 1] = '4';
break;
}
} else {
s[i] = s[i + 1] = '7';
if (i - 1 >= 0 && s[i - 1] == '4') {
if (k % 2 == 1)
s[i] = '4';
else
s[i] = '7';
break;
}
}
if (k == 0) break;
}
}
cout << s << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC diagnostic ignored "-Wmissing-declarations"
int const maxn = 100005;
vector<int> gr[maxn];
int mask[maxn];
void dfs(int v) {
mask[v] = 1;
for (int ne : gr[v])
if (!mask[ne]) dfs(ne);
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> prev;
for (int i = 0; i < n; ++i) {
int l;
cin >> l;
vector<int> cur(l);
for (int& x : cur) cin >> x;
int ind = 0;
while (ind < prev.size() && ind < cur.size() && prev[ind] == cur[ind])
++ind;
if (ind < prev.size() && ind < cur.size()) {
gr[cur[ind]].push_back(prev[ind]);
} else if (ind >= cur.size() && ind < prev.size()) {
cout << ("No") << '\n';
exit(0);
};
prev.swap(cur);
}
for (int i = 1; i <= m; ++i)
for (int ne : gr[i])
if (ne > i) dfs(ne);
for (int i = 1; i <= m; ++i)
for (int ne : gr[i])
if (!((mask[i] == mask[ne] && i > ne) || (mask[i] < mask[ne]))) {
cout << ("No") << '\n';
exit(0);
};
cout << "Yes\n";
vector<int> ans;
for (int i = 0; i < maxn; ++i)
if (mask[i]) ans.push_back(i);
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i)
cout << ans[i] << " \n"[i == ans.size() - 1];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
string s, s1;
int res;
set<string> m;
int main() {
s1.resize(200);
while (!feof(stdin)) {
gets(&s1[0]);
s.clear();
if (s1.empty()) break;
if (feof(stdin)) break;
for (int i = 0; s1[i] != 0; i++) s += s1[i];
if (s[0] == '+') {
s.erase(0, 1);
m.insert(s);
} else if (s[0] == '-') {
s.erase(0, 1);
m.erase(s);
} else {
int i;
for (i = 0; s[i] != ':'; i++)
;
res += (s.size() - i - 1) * m.size();
};
};
cout << res << endl;
return 0;
};
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2 * 1000 + 10;
const int MAXLOG = 17;
int a[MAX][MAX];
int par[MAX][MAXLOG];
vector<int> v[MAX], vr[MAX];
bool mark[2][MAX];
int cnt_1, cnt_2, cnt;
void DFS(int x) {
mark[0][x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int p = v[x][i];
if (!mark[0][p]) {
cnt_1++;
DFS(p);
}
}
}
void DFS_2(int x) {
mark[1][x] = 1;
for (int i = 0; i < vr[x].size(); i++) {
int p = vr[x][i];
if (!mark[1][p]) {
cnt_2++;
DFS_2(p);
}
}
}
int main() {
int n, s;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
scanf("%d", &s);
if (i == j) continue;
if (s > 0) {
a[i][j] = 1;
v[i].push_back(j);
vr[j].push_back(i);
}
}
}
DFS(1);
DFS_2(1);
if (cnt_1 == n - 1 && cnt_2 == n - 1)
printf("YES\n");
else
printf("NO\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
int j = a.size() - 1, h = 0, n = a.size();
while (a[j] == '/' && j >= 0) {
j--;
h++;
}
if (h == n) {
cout << a[0];
}
for (int i = 0; i < n - h; i++) {
if (a[i] == '/' && a[i + 1] != '/') {
cout << a[i];
i++;
while (a[i] != '/' and i < n) {
cout << a[i];
i++;
}
i--;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, c, c1, c2, c3, c4, c5, m, t, ar[1000000 + 5];
string s;
vector<int> ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> c;
b = b / 2;
c = c / 4;
a = min(min(a, b), c);
cout << a + (a * 4) + (a * 2) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, vector<pair<long long, long long> > > mm;
map<long long, vector<pair<long long, pair<long long, long long> > > > mm1;
long long ind[50050];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<pair<long long, long long> > s;
pair<pair<long long, long long>, pair<long long, long long> > p[n];
for (long long i = 0; i < n; ++i) {
cin >> p[i].first.first >> p[i].first.second >> p[i].second.first;
p[i].second.second = i;
mm[p[i].first].push_back({p[i].second});
}
vector<pair<long long, long long> > ans;
vector<long long> res;
for (auto i : mm) {
sort(i.second.begin(), i.second.end());
long long sz = i.second.size();
for (long long j = 0; j < sz - 1; j += 2) {
ans.push_back({i.second[j].second, i.second[j + 1].second});
ind[i.second[j + 1].second] = 1;
ind[i.second[j].second] = 1;
}
}
for (long long i = 0; i < n; ++i) {
if (ind[i] == 0) {
mm1[p[i].first.first].push_back(
{p[i].first.second, {p[i].second.first, p[i].second.second}});
}
}
for (auto i : mm1) {
sort(i.second.begin(), i.second.end());
long long sz = i.second.size();
for (long long j = 0; j < sz - 1; j += 2) {
ans.push_back({i.second[j].second.second, i.second[j + 1].second.second});
ind[i.second[j + 1].second.second] = 1;
ind[i.second[j].second.second] = 1;
}
}
for (long long i = 0; i < n; ++i) {
if (ind[i] == 0) {
s.push_back({p[i].first.first, i});
}
}
sort(s.begin(), s.end());
long long sz = s.size();
for (long long i = 0; i < sz - 1; i += 2) {
ans.push_back({s[i].second, s[i + 1].second});
}
for (auto i : ans) cout << i.first + 1 << " " << i.second + 1 << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, d;
int n, i, j, k;
cin >> a >> d;
cin >> n;
double dist, x, y;
x = y = dist = 0.0;
i = 1;
dist = d;
while (i <= n) {
dist = fmod(dist, 4 * a);
if (dist <= a && i <= n) {
y = 0;
x = dist;
} else if (dist <= 2 * a) {
x = a;
y = dist - a;
} else if (dist <= 3 * a) {
y = a;
x = 3 * a - dist;
} else {
x = 0.0;
y = 4 * a - dist;
}
printf("%0.10lf %0.10lf\n", x, y);
dist += d;
i++;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
int a[n];
int b[n + 1];
set<int> s;
for (int i = 0; i < n + 1; i++) b[i] = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[a[i]]++;
}
sort(b, b + n + 1, greater<int>());
int max = b[0];
for (int i = 0; i <= n; i++) {
if (b[i] == 0) break;
if (s.find(b[i]) != s.end()) {
s.insert(max - 1);
max = max - 1;
if (max == 0) break;
} else {
s.insert(b[i]);
max = b[i];
}
}
int sum = 0;
for (auto i = s.begin(); i != s.end(); i++) sum += *(i);
cout << sum << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 35, N = 65;
bool pre[N][M][N * N], dp[N][M][N * N];
int a[M], out_deg[N], in_deg[N], G[N][N], n, m;
struct Node {
int d, o;
bool operator<(const Node& A) const { return d < A.d; }
} A[N];
bool vis[N];
int main() {
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
sort(a + 1, a + m + 1);
dp[0][0][0] = true;
for (int i = 1; i <= 61; i++) {
int mn = i * (i - 1) / 2;
for (int j = 1; j <= m; j++)
for (int k = max(a[j], mn); k <= i * 30; k++) {
if (dp[i - 1][j - 1][k - a[j]]) pre[i][j][k] = dp[i][j][k] = true;
if (dp[i - 1][j][k - a[j]]) pre[i][j][k] = false, dp[i][j][k] = true;
}
if (dp[i][m][mn]) {
n = i;
break;
}
}
int nowj = m, nowk = n * (n - 1) / 2;
for (int i = n; i >= 1; i--)
out_deg[i] = a[nowj], nowj -= pre[i][nowj][nowk], nowk -= out_deg[i];
printf("%d\n", n);
for (int i = 1; i <= n; i++) {
int c = 0;
for (int j = 1; j <= n; j++)
if (!vis[j]) A[++c] = (Node){out_deg[j], j};
sort(A + 1, A + c + 1);
vis[A[1].o] = true;
for (int j = 2; j <= A[1].d + 1; j++) G[A[1].o][A[j].o] = true;
for (int j = 1; j <= n; j++)
if (!G[A[1].o][j] && !vis[j]) G[j][A[1].o] = true, out_deg[j]--;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%d", G[i][j]);
puts("");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
int n, x;
stack<pair<int, double> > S;
double ans[maxn];
double tmp;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
tmp = x;
if (S.empty() || S.top().second < tmp) {
S.push(make_pair(i, x));
continue;
}
double sum = 0;
int la = i;
while (true) {
pair<int, double> cur = S.top();
S.pop();
sum = sum + (la - cur.first) * cur.second;
double ave = (tmp + sum) / (i - cur.first + 1);
la = cur.first;
if (S.empty() || S.top().second < ave) {
S.push(make_pair(cur.first, ave));
break;
}
}
}
int la = n + 1;
while (!S.empty()) {
pair<int, double> cur = S.top();
S.pop();
for (int i = cur.first; i < la; ++i) ans[i] = cur.second;
la = cur.first;
}
for (int i = 1; i <= n; ++i) {
printf("%.9lf\n", ans[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[3], b[3];
for (long long i = 0; i <= 2; i++) scanf("%lld", &a[i]);
for (long long i = 0; i <= 2; i++) scanf("%lld", &b[i]);
long long dorkar = 0;
for (long long i = 0; i <= 2; i++) dorkar += max(0LL, b[i] - a[i]);
long long baki = 0;
for (long long i = 0; i <= 2; i++) {
if (a[i] > b[i]) baki += (a[i] - b[i]) / 2;
}
if (dorkar <= baki)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long n, q, has[200000][22], can[1 << 21], s[200000][22];
long nxt[200000][22];
long ans;
void check(long l, long r) {
long val = 0;
for (int i = 0; i < 20; i++)
if (s[r][i] != s[l - 1][i]) val |= (1 << i);
can[val] = 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> q;
for (int j = 0; j < 20; j++)
if (q & (1 << j)) has[i][j] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 0; j < 20; j++) s[i][j] = s[i - 1][j] + has[i][j];
for (int i = 19; i + 1; --i) nxt[n][i] = n;
for (int i = n - 1; i; --i) {
for (int j = 0; j < 20; j++) {
nxt[i][j] = nxt[i + 1][j];
if (has[i][j]) nxt[i][j] = i;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 20; j++) {
check(i, nxt[i][j]);
}
check(i, i);
}
for (int i = 0; i < (1 << 20); i++)
if (can[i]) ++ans;
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define MX 100000
vector<int> p[100005];
int a[100005],nex[100005],dp[20][100005];
int main()
{
int n,q;
scanf("%d%d",&n,&q);
for (int i=1;i<=n;i++)
scanf("%d",&a[i]);
for (int i=2;i<=MX;i++)
{
if (p[i].empty())
{
nex[i]=n+1;
for (int j=i;j<=MX;j+=i)
p[j].push_back(i);
}
}
dp[0][n+1]=n+1;
for (int i=n;i>0;i--)
{
dp[0][i]=dp[0][i+1];
for (int j:p[a[i]])
{
dp[0][i]=min(dp[0][i],nex[j]);
nex[j]=i;
}
}
for (int i=1;i<20;i++)
{
for (int j=1;j<=n+1;j++)
dp[i][j]=dp[i-1][dp[i-1][j]];
}
while (q--)
{
int l,r,ans=0;
scanf("%d%d",&l,&r);
for (int i=19;i>=0;i--)
{
if (dp[i][l]<=r)
{
ans+=(1<<i);
l=dp[i][l];
}
}
printf("%d\n",ans+1);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, INF = (int)1e9, E3 = 1005;
struct edge {
int to, cap, rev;
edge(int _to, int _cap, int _rev) { to = _to, cap = _cap, rev = _rev; }
};
int n, m, s, b, k, h;
struct Ford {
vector<edge> G[N];
bool used[N];
void add_edge(int from, int to, int cap) {
G[from].push_back(edge(to, cap, G[to].size()));
G[to].push_back(edge(from, 0, G[from].size() - 1));
}
int dfs(int v, int t, int f) {
if (v == t) return f;
used[v] = true;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (!used[e.to] && e.cap > 0) {
int d = dfs(e.to, t, min(e.cap, f));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t) {
int f = 0;
for (;;) {
fill(used, used + N, false);
int d = dfs(s, t, INF);
if (d == 0) return f;
f += d;
}
}
} flow;
struct Ship {
int x, a, f;
void read() {
cin >> x >> a >> f;
x--;
}
} sps[E3];
struct Base {
int x, d;
void read() {
cin >> x >> d;
x--;
}
} bss[E3];
int dis[N][N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
memset(dis, 0x3f, sizeof(dis));
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
dis[a][b] = dis[b][a] = 1;
}
for (int i = 0; i < n; i++) dis[i][i] = 0;
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
cin >> s >> b >> k >> h;
int f_s = s + b, f_t = f_s + 1;
for (int i = 0; i < s; i++) {
sps[i].read();
flow.add_edge(f_s, i, 1);
}
for (int i = 0; i < b; i++) {
bss[i].read();
flow.add_edge(i + s, f_t, 1);
}
for (int i = 0; i < s; i++) {
for (int j = 0; j < b; j++) {
if (sps[i].a >= bss[j].d && sps[i].f >= dis[sps[i].x][bss[j].x])
flow.add_edge(i, j + s, 1);
}
}
int max_flow = flow.max_flow(f_s, f_t);
long long res = (long long)1e18;
for (int i = 0; i <= s; i++) {
int rem = min(max_flow, s - i);
res = min(res, 1LL * rem * k + 1LL * i * h);
}
cout << res << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 1303;
long long k;
long long ans = 0;
vector<long long> adj[N];
long long uni[N];
long long dfs(long long x, long long par) {
long long sub_uni = uni[x];
for (auto &ch : adj[x])
if (par != ch) sub_uni += dfs(ch, x);
ans += min(2 * k - sub_uni, sub_uni);
return sub_uni;
}
long long solve() {
long long n;
cin >> n >> k;
for (long long i = 0; i < 2 * k; ++i) {
long long x;
cin >> x;
uni[x] = 1;
}
for (long long i = 0; i < n - 1; ++i) {
long long x;
long long y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, 0);
cout << ans;
return 0;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve(), cout << endl;
cerr << (float)clock() / CLOCKS_PER_SEC << " secs\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mem(x, y) memset(& x, y, sizeof(x))
#define all(x) begin(x), end(x)
#define SZ(x) (int)(x).size()
using namespace std;
const int n0=5003,mod=998244353;
struct mint {
unsigned int x;
mint(int _x=0) {
x=_x;
}
void operator += (const mint a) {
x+=a.x;
if(x>=mod) x-=mod;
}
void operator -= (const mint a) {
x+=mod;
x-=a.x;
if(x>=mod) x-=mod;
}
void operator *= (const mint a) {
x=(ll)x*a.x%mod;
}
mint operator + (const mint a) {
mint res=*this;
res+=a;
return res;
}
mint operator - (const mint a) {
mint res=*this;
res-=a;
return res;
}
mint operator * (const mint a) {
mint res=*this;
res*=a;
return res;
}
};
int n,k;
int f(int x) {
return k-x-2;
}
vector<int> g[n0];
mint dp[n0][n0],acc[n0][n0],pref[n0],suf[n0];
void dfs(int v,int p) {
int ch=0;
dp[v][0]=1;
for(int to:g[v]) {
if(to==p) continue;
dfs(to,v);
acc[to][0]=dp[to][0];
for(int i=1; i<=k; i++)
acc[to][i]=acc[to][i-1]+dp[to][i];
dp[v][0]*=acc[to][k];
ch++;
}
if(ch==0) return;
for(int mx=0; mx<k; mx++) {
mint res=0;
int need=min(f(mx),mx);
suf[SZ(g[v])]=1;
for(int it=SZ(g[v])-1; it>=0; it--) {
suf[it]=suf[it+1];
int to=g[v][it];
if(to==p) continue;
mint cur=acc[to][k];
if(need>=0) cur+=acc[to][need];
suf[it]*=cur;
}
if(mx==need) {
mint bad=1;
for(int to:g[v]) {
if(to==p) continue;
if(mx-1>=0) bad*=acc[to][k]+acc[to][mx-1];
else bad*=acc[to][k];
}
dp[v][mx+1]+=suf[0]-bad;
} else {
for(int it=0; it<SZ(g[v]); it++) {
pref[it]=(it?pref[it-1]:1);
int to=g[v][it];
if(to==p) continue;
mint others=suf[it+1]*pref[it];
res+=dp[to][mx]*others;
if(need>=0) pref[it]*=acc[to][k]+acc[to][need];
else pref[it]*=acc[to][k];
}
dp[v][mx+1]+=res;
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> k;
for(int i=1; i<n; i++) {
int x,y;cin >> x >> y;g[x].pb(y),g[y].pb(x);
}
dfs(1,1);
mint ans=0;
for(int i=0; i<=k; i++) ans+=dp[1][i];
cout << ans.x;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, k, m;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
cin >> m;
long long int w[m], h[m], height = 0, min_width, width = 1;
for (j = 0; j < m; j++) {
long long int curr_height, curr_width = 0;
cin >> curr_width >> curr_height;
if (curr_width <= width) {
height = max(a[width - 1], height);
cout << height << endl;
height = height + curr_height;
a[width - 1] = height;
continue;
}
for (i = width; i <= n; i++) {
if (curr_width <= i) {
width = i;
height = max(a[width - 1], height);
cout << height << endl;
height = height + curr_height;
break;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int u[505000], v[505000], m, n, d[505];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> d[i];
for (int i = 1; i <= n; ++i) {
for (int s = d[i]; s > d[i - 1]; --s)
for (int t = d[n + 1 - i] + 1; t > s; --t)
tie(u[m], v[m]) = tie(s, t), ++m;
}
printf("%d\n", m);
for (int i = 0; i < m; ++i) printf("%d %d\n", u[i], v[i]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int sum[123456];
vector<pair<int, int> > v;
int main() {
cin >> n >> m;
int mn = 1e9;
for (int i = 0, l, r; i < m; i++) {
scanf("%d%d", &l, &r);
mn = min(mn, r - l + 1);
}
cout << mn << endl;
int ct = 0;
for (int i = 0; i < n; i++) {
printf("%d ", ct);
ct++;
if (ct == mn) ct = 0;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int adj[44][44];
bool found;
int ans;
int List[44][44], len[44], mc[44];
map<string, int> mymp;
void dfs(int num) {
if (len[num] == 0) {
if (num > ans) {
ans = num;
found = true;
}
return;
}
for (int k = 0; k < len[num] && !found; k++) {
if (num + len[num] - k <= ans) break;
int i = List[num][k];
if (num + mc[i] <= ans) break;
int j;
for (j = k + 1, len[num + 1] = 0; j < len[num]; j++) {
if (adj[i][List[num][j]]) {
List[num + 1][len[num + 1]++] = List[num][j];
}
}
dfs(num + 1);
}
}
void max_clique() {
mc[n] = ans = 1;
for (int i = n - 1; i >= 0; i--) {
found = false;
len[1] = 0;
for (int j = i + 1; j <= n; j++) {
if (adj[i][j]) List[1][len[1]++] = j;
}
dfs(1);
mc[i] = ans;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> m >> n;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
adj[i][j] = adj[j][i] = 1;
}
}
vector<int> v;
int temp = 1;
while (m--) {
string a;
cin >> a;
if (a == "1") {
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j < v.size(); j++) {
adj[v[i]][v[j]] = 0;
adj[v[j]][v[i]] = 0;
}
}
v.clear();
} else {
string b;
cin >> b;
if (mymp[b] == 0) {
mymp[b] = temp++;
}
v.push_back(mymp[b]);
}
}
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j < v.size(); j++) {
adj[v[i]][v[j]] = 0;
adj[v[j]][v[i]] = 0;
}
}
v.clear();
max_clique();
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = 1e16;
const long long ninf = LLONG_MIN;
const long double eps = 1e-12;
const long long N = 3005;
const long long LOGN = 19;
const long double PI = 3.14159265358979323846;
long long mul(long long a, long long b) { return (a * b) % mod; }
long long add(long long a, long long b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
return a;
}
long long n, a[N], dp[N][N], b[N];
long long solve(long long i, long long j) {
if (j >= n) return inf;
if (i >= n) return 0;
if (dp[i][j] != -1) return dp[i][j];
long long ret = inf;
ret = min(ret, solve(i + 1, j) + abs(a[i] - b[j]));
ret = min(ret, solve(i, j + 1));
return dp[i][j] = ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] -= i;
b[i] = a[i];
}
sort(b, b + n);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) dp[i][j] = -1;
cout << solve(0, 0) << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, k, c = 0, ans, t;
cin >> n >> k;
ans = n;
long long int min = (k - 1 <= (n - k)) ? k - 1 : (n - k);
long long int max = (k - 1 >= (n - k)) ? k - 1 : (n - k);
ans += n + 1 + (2 * min) + max;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int n, k, q;
cin >> n >> k >> q;
std::vector<int> t(n);
for (int i = 0; i < n; i++) {
cin >> t[i];
}
int ty, id;
set<int> f;
for (int i = 0; i < q; i++) {
cin >> ty >> id;
if (ty == 1) {
f.insert(t[id - 1]);
if ((int)f.size() > k) f.erase(f.begin());
} else {
if (f.find(t[id - 1]) != f.end())
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int x, s, mod;
int main() {
cin >> x;
while (x > 0) {
mod = x % 2;
x /= 2;
if (mod == 1) s++;
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
vector<long long> X;
long long K;
long long g(long long a) {
if (a < (long long)X.size()) return X[a];
if (a % 2 == 1) return 0;
long long g2;
if (K % 2 == 1) {
g2 = g(a / 2);
} else {
g2 = 0;
}
if (g2 == 0 || g2 == 2) return 1;
return 2;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long N;
cin >> N >> K;
vector<long long> A(N);
long long res = 0;
for (long long i = 0; i < N; i++) {
cin >> A[i];
}
X.resize(1000);
X[0] = 0;
for (long long i = 1; i < X.size(); i++) {
set<long long> st;
st.insert(X[i - 1]);
if (K % 2 == 1) {
if (i % 2 == 0) st.insert(X[i / 2]);
} else {
if (i % 2 == 0) st.insert(0);
}
for (long long j = 0; j < 3; j++) {
if (st.count(j) == 0) {
X[i] = j;
break;
}
}
}
long long gr = 0;
for (long long i = 0; i < N; i++) {
gr ^= g(A[i]);
}
if (gr == 0) {
cout << "Nicky" << endl;
} else {
cout << "Kevin" << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[105];
int n, m, t;
int main() {
scanf("%d%d", &n, &m);
while (n--) {
scanf("%s", s);
for (int i = 1; i < m; i++)
if (s[0] == t || s[i] != s[i - 1]) {
puts("NO");
return 0;
}
t = s[0];
}
puts("YES");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
};
long double mn = 2 * 3.141592653589 + 1;
point ans, ans1;
void dot(point a, point b) {
long double i = a.x * a.x + a.y * a.y, j = b.x * b.x + b.y * b.y;
long double d1 = sqrt(i), d2 = sqrt(j);
long double u = a.x / d1, v = b.x / d2;
long double x1 = acos(u), x2 = acos(v);
if (a.y < 0) x1 = (2 * 3.141592653589 - x1);
if (b.y < 0) x2 = (2 * 3.141592653589 - x2);
long double dif = x2 - x1;
if (dif < 0) dif += 2 * 3.141592653589;
if (mn - dif > 0) {
mn = dif;
ans = a;
ans1 = b;
}
}
bool s(point a, point b) {
long double d1 = sqrt(a.x * a.x + a.y * a.y),
d2 = sqrt(b.x * b.x + b.y * b.y);
long double x1 = acos(a.x / d1), x2 = acos(b.x / d2);
if (a.y < 0) x1 = (2 * 3.141592653589 - x1);
if (b.y < 0) x2 = (2 * 3.141592653589 - x2);
return (x1 < x2);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<point> v;
map<pair<long long, long long>, int> an;
point p;
for (int i = 0; i < n; i++) {
cin >> p.x >> p.y;
v.push_back(p);
an[make_pair(p.x, p.y)] = i + 1;
}
sort(v.begin(), v.end(), s);
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1)
dot(v[n - 1], v[0]);
else
dot(v[i], v[i + 1]);
}
cout << an[make_pair(ans.x, ans.y)] << " " << an[make_pair(ans1.x, ans1.y)];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 1; i < n - 1; ++i) {
if (a[i - 1] + a[i] > a[i + 1]) {
cout << "YES" << endl;
return 0;
;
}
}
cout << "NO" << endl;
return 0;
;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++) cin >> arr[i];
if (n % 2 == 0 || n < 3)
cout << "-1" << endl;
else {
int ans = 0, zero = 0;
for (int i = n; i >= 2; i--) {
if (arr[i] > 0 && i % 2 == 1) {
int x = (i - 1) / 2;
ans += arr[i];
arr[2 * x] = max(zero, arr[2 * x] - arr[i]);
arr[x] = max(zero, arr[x] - arr[i]);
arr[i] = 0;
}
if (arr[i] > 0 && i % 2 == 0) {
int x = i / 2;
ans += arr[i];
arr[2 * x + 1] = max(zero, arr[2 * x + 1] - arr[i]);
arr[x] = max(zero, arr[x] - arr[i]);
arr[i] = 0;
}
}
ans += arr[1];
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, vector<T> v) {
os << "[";
for (auto it : v) os << it << " ";
return os << "]";
}
template <typename K, typename V>
ostream &operator<<(ostream &os, pair<K, V> v) {
return os << "(" << v.first << ", " << v.second << ")";
}
int n, m, c0, d0;
int A[11][4];
long long mem[11][1005];
long long dp(int pos, int n) {
if (n == 0) return 0;
if (pos == m) return 1ll * (n / c0) * d0;
long long &ret = mem[pos][n];
if (~ret) return ret;
ret = 0;
int k = A[pos][0] / A[pos][1];
for (int i = 0; i <= k; ++i) {
if (n >= A[pos][2] * i)
ret = max(ret, dp(pos + 1, n - A[pos][2] * i) + A[pos][3] * i);
}
ret = max(ret, 1ll * (n / c0) * d0);
return ret;
}
int main() {
cin >> n >> m >> c0 >> d0;
for (int i = 0; i < m; ++i)
for (int j = 0; j < 4; ++j) cin >> A[i][j];
memset(mem, -1, sizeof mem);
cout << dp(0, n) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100500;
const int INF = 1 << 30;
const int MOD = int(1e9) + 7;
int n, sum;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
sum += x;
}
if (sum % n == 0)
cout << n << endl;
else
cout << n - 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
vector<bool> marker;
vector<pair<int, int> > ans;
void dfs(int curr) {
marker[curr] = 1;
for (int x : g[curr]) {
if (!marker[x]) {
ans.push_back({curr, x});
dfs(x);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
int n, k, idx = 0;
cin >> n >> k;
if (n == 1) {
cout << 1;
return 0;
}
vector<pair<int, int> > v(n);
for (int i = 1; i <= n; i++) {
cin >> v[i - 1].first;
v[i - 1].second = i;
}
sort(v.begin(), v.end());
g.assign(n + 1, vector<int>());
vector<int> curr;
for (; idx < v.size() && v[idx].first == 0; idx++)
curr.push_back(v[idx].second);
if (curr.size() != 1) {
cout << -1;
return 0;
}
int nxt = 1;
vector<int> next;
while (idx < v.size()) {
int tidx = 0;
if (curr.size() == 0) {
cout << -1;
return 0;
}
for (; idx < v.size() && v[idx].first == nxt; idx++) {
tidx %= (int)curr.size();
g[curr[tidx]].push_back(v[idx].second);
g[v[idx].second].push_back(curr[tidx]);
tidx++;
next.push_back(v[idx].second);
}
nxt++;
curr = next;
next.clear();
}
bool flag = 1;
for (int i = 1; i <= n && flag; i++)
if (g[i].size() > k) flag = 0;
if (!flag) {
cout << -1;
return 0;
}
marker.assign(n + 1, 0);
dfs(1);
cout << ans.size() << "\n";
for (int i = 1; i <= ans.size(); i++)
cout << ans[i - 1].first << " " << ans[i - 1].second << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool solve(string a) {
int f = 0;
if (a.size() % 2) {
for (int i = 0; i < a.size() / 2; i++) {
if (a[i] != a[a.size() - 1 - i]) f = 1;
}
if (f)
return 0;
else
return 1;
} else {
for (int i = 0; i < a.size() / 2; i++) {
if (a[i] != a[a.size() - 1 - i]) f = 1;
}
if (f)
return 0;
else
return 1;
}
}
set<char> st1, st2;
int main() {
string s1;
while (cin >> s1) {
if (solve(s1)) {
if (s1.size() % 2) {
for (int i = 0; i <= s1.size() / 2; i++) {
cout << s1[i];
}
for (int i = s1.size() / 2; i < s1.size(); i++) {
cout << s1[i];
}
cout << endl;
} else {
for (int i = 0; i <= s1.size() / 2; i++) {
cout << s1[i];
}
for (int i = s1.size() / 2; i < s1.size(); i++) {
cout << s1[i];
}
cout << endl;
}
} else {
int f = 0;
string s;
for (int i = 0; i <= s1.size(); i++) {
for (int j = 0; j < 26; j++) {
s.clear();
char b = 'a' + j;
for (int k = 0; k < i; k++) s += s1[k];
s += b;
for (int k = i; k < s1.size(); k++) s += s1[k];
if (solve(s)) {
cout << s << endl;
return 0;
}
}
}
cout << "NA" << endl;
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> nds;
long long xc0, yc0, ax, bx, ay, by, xs, ys, t;
int check(int i) {
long long xi = nds[i].first;
long long yi = nds[i].second;
long long tleft = t - abs(xi - xs) - abs(yi - ys);
int ret = 1;
while (tleft > 0) {
for (int j = i - 1; j >= 0; j--) {
if (tleft >= abs(xi - nds[j].first) + abs(yi - nds[j].second)) {
ret++;
tleft -= abs(xi - nds[j].first) + abs(yi - nds[j].second);
xi = nds[j].first;
yi = nds[j].second;
}
}
int j = i + 1;
while (j < nds.size()) {
if (tleft >= abs(xi - nds[j].first) + abs(yi - nds[j].second)) {
ret++;
tleft -= abs(xi - nds[j].first) + abs(yi - nds[j].second);
xi = nds[j].first;
yi = nds[j].second;
} else
break;
j++;
}
break;
}
return ret;
}
int main() {
cin >> xc0 >> yc0 >> ax >> ay >> bx >> by >> xs >> ys >> t;
long long cnt = 0;
long long x = xc0;
long long y = yc0;
long long difx, dify;
long long b = 1e16;
while (cnt < 64) {
if (x > b + xs + 1) break;
if (y > b + ys + 1) break;
difx = abs(x - xs);
dify = abs(y - ys);
if (difx + dify <= t) {
nds.push_back(make_pair(x, y));
}
x = x * ax + bx;
y = y * ay + by;
cnt++;
}
int ans = 0;
for (int i = 0; i < nds.size(); i++) {
ans = max(ans, check(i));
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool get_int(T &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-' && t != EOF; t = getchar())
;
if (t == '-') neg = true, t = getchar();
if (t == EOF) return false;
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
return true;
}
template <typename T>
void print_int(T x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
const int maxn = 200111;
int lg[maxn];
struct arithseq {
int st, ed, diff;
arithseq() {}
arithseq(int a, int b, int c) {
st = a;
ed = b;
diff = c;
}
arithseq shift(const int &x) const { return arithseq(st + x, ed + x, diff); }
arithseq neg() const { return arithseq(-ed, -st, diff); }
bool have(const int &x) const {
return (x >= st && x <= ed && (st - x) % diff == 0);
}
};
int un(const arithseq &a, const arithseq &b) {
if (a.diff != b.diff) {
int ret = 0;
if ((a.ed - a.st) <= (a.diff << 1)) {
for (int i = a.st; i <= a.ed; i += a.diff)
if (b.have(i)) ret++;
} else if ((b.ed - b.st) <= (b.diff << 1)) {
for (int i = b.st; i <= b.ed; i += b.diff)
if (a.have(i)) ret++;
} else {
puts("baojing");
}
return ret;
} else if ((b.st - a.st) % a.diff)
return 0;
else
return (min(a.ed, b.ed) - max(a.st, b.st)) / a.diff + 1;
}
struct IPM {
int sa[maxn], rk[maxn], nrk[maxn], c[maxn], n;
int v[20][maxn];
int id[20][maxn], mxl;
vector<int> sq[20 * maxn];
void construct(char *s) {
n = strlen(s) + 1;
int m = 256;
int *x = rk, *y = nrk;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[i] = s[i]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
int tot = 0;
mxl = 0;
for (int k = 1; k <= n; k <<= 1) {
for (int i = 0, nxt = 0; i < n; i = nxt) {
for (; nxt < n && x[sa[i]] == x[sa[nxt]]; nxt++)
;
tot++;
sq[tot].clear();
for (int j = i; j < nxt; j++) {
sq[tot].push_back(sa[j]);
id[lg[k]][sa[j]] = tot;
}
sort(sq[tot].begin(), sq[tot].end());
}
mxl = k;
int p = 0;
for (int i = n - k; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[y[i]]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
swap(x, y);
x[sa[0]] = 0;
p = 1;
for (int i = 1; i < n; i++)
x[sa[i]] =
(y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k])
? p - 1
: p++;
if (p >= n) break;
m = p;
}
int k = 0;
for (int i = 0; i < n; i++) rk[sa[i]] = i;
for (int i = 0; i < n - 1; i++) {
if (k) k--;
int j = sa[rk[i] - 1];
while (s[i + k] == s[j + k]) k++;
v[0][rk[i]] = k;
}
for (int i = 1; i < 20; i++) {
for (int j = 2; j < n; j++) {
int nxt = j + (1 << i - 1);
if (nxt >= n)
v[i][j] = v[i - 1][j];
else
v[i][j] = min(v[i - 1][j], v[i - 1][nxt]);
}
}
}
int qlcp(int l, int r) {
if (l == r) return n - l;
l = rk[l];
r = rk[r];
if (l > r) swap(l, r);
l++;
int t = lg[r - l + 1];
return min(v[t][l], v[t][r - (1 << t) + 1]);
}
int pred(int l, int k, int pos) {
if (k > mxl) {
if (pos >= l)
return l;
else
return -1;
}
vector<int> &v = sq[id[lg[k]][l]];
int id = upper_bound(v.begin(), v.end(), pos) - v.begin();
if (id)
return v[id - 1];
else
return -1;
}
int succ(int l, int k, int pos) {
if (k > mxl) {
if (pos <= l)
return l;
else
return -1;
}
vector<int> &v = sq[id[lg[k]][l]];
int id = lower_bound(v.begin(), v.end(), pos) - v.begin();
if (id < (int)v.size())
return v[id];
else
return -1;
}
int get_border(int l, int r) {
int len = r - l + 1, l1, l2, l3, r1, r2, r3, ret = 0;
for (int k = 1; k < len; k <<= 1) {
int tl = l, tr = r - k + 1;
l1 = succ(tr, k, tl);
if (l1 == -1 || l1 >= l + k || l1 >= r) continue;
r1 = pred(tl, k, tr);
if (r1 == -1 || r1 <= tr - k || r1 <= l) continue;
l2 = succ(tr, k, l1 + 1);
l3 = pred(tr, k, l + k - 1);
r2 = pred(tl, k, r1 - 1);
r3 = succ(tl, k, max(l + 1, tr - k + 1));
arithseq k1, k2;
if (l2 != -1)
k1 = arithseq(l1 - l, l3 - l, l2 - l1);
else
k1 = arithseq(l1 - l, l1 - l, 1);
if (r2 != -1)
k2 = arithseq(tr - r1, tr - r3, r1 - r2);
else
k2 = arithseq(tr - r1, tr - r1, 1);
ret += un(k1, k2);
}
return ret;
}
} thor;
struct suffix {
int sa[maxn], rk[maxn], nrk[maxn], c[maxn], n;
int v[20][maxn];
void construct(char *s) {
n = strlen(s) + 1;
int m = 256;
int *x = rk, *y = nrk;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[i] = s[i]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
for (int k = 1; k <= n; k <<= 1) {
int p = 0;
for (int i = n - k; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) c[x[y[i]]]++;
for (int i = 1; i < m; i++) c[i] += c[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
swap(x, y);
x[sa[0]] = 0;
p = 1;
for (int i = 1; i < n; i++)
x[sa[i]] =
(y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k])
? p - 1
: p++;
if (p >= n) break;
m = p;
}
int k = 0;
for (int i = 0; i < n; i++) rk[sa[i]] = i;
for (int i = 0; i < n - 1; i++) {
if (k) k--;
int j = sa[rk[i] - 1];
while (s[i + k] == s[j + k]) k++;
v[0][rk[i]] = k;
}
for (int i = 1; i < 20; i++) {
for (int j = 2; j < n; j++) {
int nxt = j + (1 << i - 1);
if (nxt >= n)
v[i][j] = v[i - 1][j];
else
v[i][j] = min(v[i - 1][j], v[i - 1][nxt]);
}
}
}
int qlcp(int l, int r) {
if (l == r) return n - l;
l = rk[l];
r = rk[r];
if (l > r) swap(l, r);
l++;
int t = lg[r - l + 1];
return min(v[t][l], v[t][r - (1 << t) + 1]);
}
} loki;
char s[maxn];
int n, q, sum[maxn][26], v[20][maxn];
struct solver {
int f[maxn], a[maxn];
void prework(int coef) {
for (int i = 1; i <= n; i++) {
f[i] = i;
a[i] = (coef == 1 ? inf : -inf);
}
}
int gf(int x) { return x == f[x] ? x : f[x] = gf(f[x]); }
void modify(int l, int r, int v) {
while (true) {
l = gf(l);
if (l && l <= r) {
a[l] = l + v;
f[l] = l + 1;
} else
break;
}
}
void construct() {
for (int i = 1; i <= n; i++) v[0][i] = a[i];
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= n; j++) {
int nxt = j + (1 << i - 1);
if (nxt <= n)
v[i][j] = min(v[i - 1][j], v[i - 1][nxt]);
else
v[i][j] = v[i - 1][j];
}
}
}
};
solver mnl, mnr;
int query(int l, int r) {
int t = lg[r - l + 1];
return min(v[t][l], v[t][r - (1 << t) + 1]);
}
int lcp(int a, int b) { return thor.qlcp(a - 1, b - 1); }
int lcs(int a, int b) { return loki.qlcp(n - a, n - b); }
vector<int> pr[maxn];
bool per(int l, int r) {
int len = r - l + 1;
for (int i = 0; i < (int)pr[len].size(); i++) {
if (lcp(l, l + len / pr[len][i]) + len / pr[len][i] >= len) return true;
}
return false;
}
int main() {
for (int i = 2; i < maxn; i++) {
lg[i] = lg[i >> 1] + 1;
if (pr[i].size() == 0) {
for (int j = i; j < maxn; j += i) pr[j].push_back(i);
}
}
scanf("%d%s", &n, s + 1);
thor.construct(s + 1);
reverse(s + 1, s + n + 1);
loki.construct(s + 1);
reverse(s + 1, s + n + 1);
for (int i = 1; i <= n; i++) {
memcpy(sum[i], sum[i - 1], sizeof(sum[i]));
sum[i][s[i] - 'a']++;
}
mnl.prework(1);
mnr.prework(-1);
for (int len = 1; len + len <= n; len++) {
for (int i = len; i + len <= n; i += len) {
int j = i + len, l1 = lcs(i, j), l2 = lcp(i + 1, j + 1);
if (l1 + l2 < len || l1 == 0) continue;
int l = i - min(len, l1) + 1, r = i - max(1, len - l2) + 1;
mnl.modify(l, r, len + len - 1);
mnr.modify(l + len + len - 1, r + len + len - 1, -len - len + 1);
}
}
mnl.construct();
get_int(q);
for (int i = 1, l, r; i <= q; i++) {
(get_int(l) && get_int(r));
int ans = -1;
for (int j = 0; j < 26 && ans == -1; j++)
if (sum[r][j] - sum[l - 1][j] > 1) ans = 0;
if (ans == -1)
puts("-1");
else if (per(l, r))
puts("1");
else if (mnl.a[l] < r || mnr.a[r] > l || thor.get_border(l - 1, r - 1))
puts("2");
else if (sum[r][s[l] - 'a'] > sum[l][s[l] - 'a'] ||
sum[r - 1][s[r] - 'a'] > sum[l - 1][s[r] - 'a'] ||
query(l, r) <= r)
puts("3");
else
puts("4");
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
const int N = 2000005;
const int M = 10005;
const long long mod = 1000000007;
const double PI = acos(-1.0);
const double eps = 1e-10;
using namespace std;
int f[N], s[N], st;
long long m;
long long cal(int* f, long long x, long long y, long long h) {
int id = 0;
while (1) {
f[h] = id++;
h = (h * x + y) % m;
if (f[h]) {
st = f[h];
break;
}
}
return id - st;
}
vector<long long> solve(long long a, long long cl, long long tmp) {
vector<long long> t;
if (a < tmp)
t.push_back(a);
else {
for (int i = 0; i <= m; i++) {
long long x = a + i * cl;
t.push_back(x);
}
}
return t;
}
int main() {
long long h1, a1, x1, y1, h2, a2, x2, y2;
cin >> m;
cin >> h1 >> a1;
cin >> x1 >> y1;
cin >> h2 >> a2;
cin >> x2 >> y2;
long long clf = cal(f, x1, y1, h1);
int st1 = st;
long long cls = cal(s, x2, y2, h2);
int st2 = st;
if (f[a1] == 0 || s[a2] == 0) {
cout << -1 << endl;
return 0;
}
vector<long long> t1 = solve(f[a1], clf, st1);
vector<long long> t2 = solve(s[a2], cls, st2);
int l = 0, r = 0;
while (l < t1.size() && r < t2.size()) {
if (t1[l] > t2[r]) {
r++;
continue;
}
if (t1[l] < t2[r]) {
l++;
continue;
}
cout << t1[l] << endl;
return 0;
}
cout << -1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b, int c) { return max(a, max(b, c)); }
int min(int a, int b, int c) { return min(a, min(b, c)); }
int abs(int a, int b) { return a > b ? a - b : b - a; }
class line {
public:
int a, b, c, d;
line(int x1, int y1, int x2, int y2) {
a = x2 - x1;
b = y1;
c = y2 - y1;
d = x1;
}
line() { a = b = c = d = 0; }
void copy(const line &l) {
a = l.a;
b = l.b;
c = l.c;
d = l.d;
}
bool check(int xn, int yn) { return (a * (yn - b) == c * (xn - d)); }
friend bool isCoincident(const line &a, const line &b);
friend bool isParallel(const line &a, const line &b);
};
bool isParallel(const line &a, const line &b) {
return ((a.c * 1.0) / a.a == (b.c * 1.0) / b.a);
}
bool isCoincident(const line &a, const line &b) {
if ((a.c * 1.0) / a.a == (b.c * 1.0) / b.a) {
float a1 = (a.a * a.b * 1.0 - a.c * a.d * 1.0) / a.a;
float b1 = (b.a * b.b * 1.0 - b.c * b.d * 1.0) / b.a;
return a1 == b1;
}
return false;
}
int t, n;
int arr[100000];
vector<pair<int, int> > v;
bool check(line l1) {
v.clear();
int count = 0;
for (int i = 1; i <= n; ++i) {
if (l1.check(i, arr[i]))
count++;
else
v.push_back(make_pair(i, arr[i]));
}
if (count == n)
return false;
else if (v.size() == 1)
return true;
line l2(v[0].first, v[0].second, v[1].first, v[1].second);
if (!isParallel(l1, l2)) return false;
count = 0;
int len = v.size();
for (int i = 0; i < len; ++i) {
if (l2.check(v[i].first, v[i].second)) count++;
}
if (count == len)
return true;
else
return false;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> arr[i];
line l1(1, arr[1], 2, arr[2]), l2(2, arr[2], 3, arr[3]),
l3(3, arr[3], 1, arr[1]);
if (check(l1) || check(l2) || check(l3))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, s, t, a[100009];
int read() {
int x = 1;
char ch;
while (ch = getchar(), ch < '0' || ch > '9')
if (ch == '-') x = -1;
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s * x;
}
bool check(int x) {
if (abs(s - t) > x) return 0;
int l = a[n] - x, r = a[n] + x;
for (int i = n - 1; i; i--) {
int L = a[i] - x, R = a[i] + x;
if (a[i] < l || a[i] > r) {
L = max(L, l);
R = min(R, r);
}
if (L > R) return 0;
l = L, r = R;
}
return (s >= l && s <= r || t >= l && t <= r);
}
int main() {
n = read(), s = read(), t = read();
for (int i = 1; i <= n; i++) a[i] = read();
int l = 0, r = 1000000000, ret = 1000000000;
while (l <= r) {
if (check((l + r >> 1)))
ret = (l + r >> 1), r = (l + r >> 1) - 1;
else
l = (l + r >> 1) + 1;
}
printf("%d\n", ret);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
for (int i = 0; i < 1000000; i++)
;
scanf("%lld%lld%lld", &n, &m, &k);
for (int i = 0; i < 1000000; i++)
;
queue<long long> q;
for (int i = 0; i < 1000000; i++)
;
for (int i = 0; i < m; i++) {
long long x;
scanf("%lld", &x);
q.push(x);
}
for (int i = 0; i < 1000000; i++)
;
long long r = k, cnt = 0, t = 0;
for (int i = 0; i < 1000000; i++)
;
while (!q.empty()) {
t = 0;
while (!q.empty() && q.front() <= r) {
t++;
q.pop();
}
if (t == 0) {
long long v = 0;
if (!q.empty()) {
if ((q.front() - r) % k == 0)
v = (q.front() - r) / k;
else
v = (q.front() - r) / k + 1;
}
r += k * v;
continue;
}
r += t;
cnt++;
}
for (int i = 0; i < 1000000; i++)
;
cout << cnt << endl;
for (int i = 0; i < 1000000; i++)
;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int K, R;
int main() {
cin >> K >> R;
for (int i = 1; i <= 9; i++)
if ((K * i >= R && (K * i - R) % 10 == 0) || (K * i % 10 == 0)) {
cout << i << endl;
return 0;
}
cout << 10 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double const eps = 1e-12;
int const INF = 100000;
int const MOD = 1000000007;
int const MAX = 1000 * 100 + 5;
int main() {
int n, i;
long long a, d, t, v;
double last;
cin >> n >> a >> d;
for (i = 0; i < n; ++i) {
cin >> t >> v;
double time = t;
if (v * v < 2 * a * d)
time += (double)v / a + (d - (double)v * v / 2 / a) / v;
else
time += sqrt(2. * d / a);
if (i == 0)
last = time;
else if (time + eps < last)
time = last;
else
last = time;
printf("%.9lf\n", time);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 3e5 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t1;
cin >> t1;
while (t1--) {
long long n, l;
cin >> n >> l;
double a[n];
for (int i = 0; i < n; i++) cin >> a[i];
double ans = 0, low = 0, high = l;
int itr = 200;
while (low <= high && itr--) {
double mid = (low + high) / 2;
double start = 0, speed = 1, time = 0;
for (int i = 0; i < n; i++) {
if (a[i] > mid) {
time += (mid - start) / speed;
break;
} else {
time += (a[i] - start) / speed;
speed++;
start = a[i];
}
if (i == (n - 1)) {
time += (mid - a[i]) / speed;
break;
}
if (a[i + 1] > mid) {
time += (mid - a[i]) / speed;
break;
}
}
double end = l, time2 = 0;
speed = 1;
for (int i = n - 1; i >= 0; i--) {
if (a[i] < mid) {
time2 += (end - mid) / speed;
break;
} else {
time2 += (end - a[i]) / speed;
speed++;
end = a[i];
}
if (i == 0) {
time2 += (a[i] - mid) / speed;
break;
} else if (a[i - 1] < mid) {
time2 += (a[i] - mid) / (speed);
break;
}
}
if (time >= time2) {
high = mid;
ans = time2;
} else
low = mid;
}
cout << fixed << setprecision(8) << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[300003], t[300003];
int c[300003];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1), m = 0;
for (int i = 1; i <= n; ++i)
if (i == 1 || s[i] != s[i - 1])
t[++m] = s[i], c[m] = 1;
else
++c[m];
if (m & 1) {
int k = m / 2 + 1;
if (c[k] == 1)
puts("0");
else {
bool flag = 1;
for (int i = 1; i < k; ++i)
if (t[i] != t[m - i + 1] || c[i] + c[m - i + 1] < 3) {
flag = 0;
break;
}
if (flag)
printf("%d\n", c[k] + 1);
else
puts("0");
}
} else
puts("0");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
int n, maxS;
int in[505], out[505], w[505], s[505], cost[505];
vector<int> spos[1005];
int f[505][1005];
int g[505][1005];
int rec(int id, int maxS) {
if (maxS < 0) {
return 0;
}
if (f[id][maxS] != -1) {
return f[id][maxS];
}
for (int i = in[id]; i <= out[id]; ++i) {
if (i > 0) g[id][i] = g[id][i - 1];
for (int j = 0; j < spos[i].size(); ++j) {
int to = spos[i][j];
if (in[to] < in[id] || to == id) {
continue;
}
g[id][i] =
max(g[id][i], g[id][in[to]] + rec(to, min(maxS - w[to], s[to])));
}
}
return f[id][maxS] = g[id][out[id]] + cost[id];
}
int main(void) {
memset(f, -1, sizeof f);
scanf("%d %d", &n, &maxS);
out[0] = 2 * n;
for (int i = 1; i <= n; ++i) {
scanf("%d %d %d %d %d", in + i, out + i, w + i, s + i, cost + i);
spos[out[i]].push_back(i);
}
printf("%d\n", rec(0, maxS));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e5, MOD = 1e9 + 7;
;
long long t, n, k;
long long f(long long i, long long b);
long long x(long long i) {
if (i == 0) {
return (k * (k + 1)) / 2;
} else {
return f(i / k, i % k);
}
}
long long g(long long i, long long b) {
long long H = x(i);
long long beg = (k * k + 1) * i + b * k + 1;
long long end = (k * k + 1) * i + b * k + k;
if (H < beg) return k;
if (H > end) return 0;
return end - H + 1;
}
long long f(long long i, long long b) {
return (k * i + b) * (k * k + 1) - b + (k * (k + 1)) / 2 + g(i, b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> k;
long long i = (n - 1) / (k * k + 1);
long long u = x(i);
if (u == n) {
cout << (k + 1) * (i + 1) << endl;
} else if (u < n) {
cout << (n - i - 1) + (n - i - 2) / k << endl;
} else {
cout << (n - i) + (n - i - 1) / k << endl;
}
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> last(26, -1);
for (int i = 0; i < s.size(); i++) {
last[s[i] - 'A'] = i;
}
vector<int> beg(26, -1);
for (int i = s.size() - 1; i >= 0; i--) {
beg[s[i] - 'A'] = i;
}
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (i == beg[s[i] - 'A']) cnt++;
if (cnt > k) {
cout << "YES";
return 0;
}
if (i == last[s[i] - 'A']) cnt--;
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
register int n, m, c;
cin >> n >> m >> c;
register int* a = new int[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int b;
cin >> b;
for (int j = i; j < n - m + 1 + i; j++) a[j] = (a[j] + b) % c;
cout << a[i] << " ";
}
for (int i = m; i < n; i++) cout << a[i] << " ";
delete[] a;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 123;
const int M = 1e7 + 123;
const int inf = 1e9 + 1;
const int mod = 1e9 + 7;
const int bl = 300;
int n, cnt;
string second;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> second;
for (int i = 0; i < second.size() - 1; ++i) {
if ((second[i] == 'R' && second[i + 1] == 'U') ||
(second[i] == 'U' && second[i + 1] == 'R')) {
cnt++;
i++;
}
}
cout << n - cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int d[1000];
void xuly(string a) {
int l1 = s2.length();
int l2 = a.length();
int i = 0, j = 0;
while (i < l2)
if (a[i] == s2[j])
i++, j++;
else if (s2[j] == '?' && d[(int)a[i]])
i++, j++;
else if (s2[j] == '*' && !d[(int)a[i]] && i <= l2 - l1 + j)
i++;
else if (s2[j] == '*')
j++;
else
break;
if (s2[j] == '*') j++;
if (i == l2 && j == l1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> s1;
cin >> s2;
memset(d, 0, sizeof(d));
for (int i = 0; i < s1.length(); i++) d[(int)s1[i]] = true;
int k;
cin >> k;
for (int i = 1; i <= k; i++) {
string m;
cin >> m;
if (m.length() < s2.length() - 1) {
cout << "NO" << endl;
continue;
}
xuly(m);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n, h, a[2] = {0};
bool b = 1;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &h);
v.push_back(h);
}
while (v.size() != 0) {
int f = v[0], l = v[v.size() - 1];
b = !b;
if (f >= l) {
a[b] += f;
v.erase(v.begin());
} else {
a[b] += l;
v.pop_back();
}
}
printf("%d %d\n", a[0], a[1]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int S = 500;
vector<int> v[300001];
vector<pair<int, int> > V[300001];
int T, n, q, k, x, po[300001], p[300001];
void solve() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &k);
v[i].clear();
for (int j = 0; j < k; j++) scanf("%d", &x), v[i].push_back(x);
}
for (int i = 1; i <= q; i++)
if (v[i].size() >= S) {
int k = v[i].size();
for (int j = 0; j < k; j++) po[v[i][j]] = j + 1;
for (int j = 1, siz, l; j <= q; j++)
if (i != j) {
int mi = (po[v[j][0]] ? po[v[j][0]] : (1e9));
for (l = 1, siz = v[j].size(); l < siz; l++)
if (po[v[j][l]]) {
if (mi < po[v[j][l]] && !po[v[j][l - 1]] ||
po[v[j][l - 1]] && po[v[j][l - 1]] < po[v[j][l]] - 1) {
for (int j = 0; j < k; j++) po[v[i][j]] = 0;
puts("Human");
return;
}
mi = (mi > po[v[j][l]] ? po[v[j][l]] : mi);
}
}
for (int j = 0; j < k; j++) po[v[i][j]] = 0;
}
for (int i = 1; i <= n; i++) V[i].clear();
for (int i = 1, siz, j; i <= q; i++)
if (v[i].size() < S)
for (j = 0, siz = v[i].size(); j < siz; j++)
V[v[i][j]].push_back(make_pair(i, j));
for (int i = 1, siz, j; i <= n; i++) {
for (j = 0, siz = V[i].size(); j < siz; j++) {
int p1 = V[i][j].first, p2 = V[i][j].second, s = v[p1].size();
for (int k = p2 + 1, K; k < s; k++) {
K = v[p1][k];
if (!po[K])
po[K] = p1, p[K] = k;
else if (v[po[K]][p[K] - 1] != v[p1][k - 1]) {
for (j = 0, siz = V[i].size(); j < siz; j++) {
int p1 = V[i][j].first, p2 = V[i][j].second, s = v[p1].size();
for (int k = p2 + 1; k < s; k++) po[v[p1][k]] = 0;
}
puts("Human");
return;
}
}
}
for (j = 0, siz = V[i].size(); j < siz; j++) {
int p1 = V[i][j].first, p2 = V[i][j].second, s = v[p1].size();
for (int k = p2 + 1; k < s; k++) po[v[p1][k]] = 0;
}
}
puts("Robot");
}
int main() {
scanf("%d", &T);
memset(po, 0, sizeof(po));
while (T--) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
const long long INF = 1e9;
const long long lINF = 1e18;
using namespace std;
int sum1[222222], sum2[222222], sum3[222222];
const int N = 222222;
int n, a[222222], b[222222], n1[222222], n2[222222], res[222222];
int get1(int r) {
r++;
int result = 0;
for (; r > 0; r -= r & (-r)) result += sum1[r];
return result;
}
int get2(int r) {
r++;
int result = 0;
for (; r > 0; r -= r & (-r)) result += sum2[r];
return result;
}
int get3(int r) {
r++;
int result = 0;
for (; r > 0; r -= r & (-r)) result += sum3[r];
return result;
}
void inc1(int i, int delta) {
i++;
for (; i < N; i += i & (-i)) sum1[i] += delta;
}
void inc2(int i, int delta) {
i++;
for (; i < N; i += i & (-i)) sum2[i] += delta;
}
void inc3(int i, int delta) {
i++;
for (; i < N; i += i & (-i)) sum3[i] += delta;
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
inc3(i, 1);
inc2(i, 1);
inc1(i, 1);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
n1[i] = get1(a[i]);
inc1(a[i], -1);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
n2[i] = get2(b[i]);
inc2(b[i], -1);
}
for (int i = n - 1, j = 0; i >= 0; i--) {
res[i] = (n1[i] + n2[i] + j) % (n - i);
if (n1[i] + n2[i] + j >= n - i)
j = 1;
else
j = 0;
}
for (int i = 0; i < n; i++) {
int l = 0, r = n;
while (r - l > 1) {
int mid = (r + l) / 2;
if (get3(mid) > res[i]) {
r = mid;
} else
l = mid;
}
printf("%d ", l);
inc3(l + 1, -1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(false);
string a, b, c, d;
cin >> a >> b >> c >> d;
string s;
if (a[0] != 'X') s += a[0];
if (a[1] != 'X') s += a[1];
if (b[1] != 'X') s += b[1];
if (b[0] != 'X') s += b[0];
string t;
if (c[0] != 'X') t += c[0];
if (c[1] != 'X') t += c[1];
if (d[1] != 'X') t += d[1];
if (d[0] != 'X') t += d[0];
for (int i = 0; i < 3; i++) {
if (s == t) {
cout << "YES\n";
return 0;
}
char mlc = t[0];
t.erase(t.begin());
t += mlc;
}
cout << "NO\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int fa[1000], fb[1000];
int main() {
int n, m;
cin >> n;
int a[n + 2];
memset(fa, 0, sizeof fa);
memset(fb, 0, sizeof fb);
for (int i = 0; i < n; i++) {
cin >> a[i];
fa[a[i]]++;
}
cin >> m;
int b[m + 2];
for (int i = 0; i < m; i++) {
cin >> b[i];
fb[b[i]]++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x = a[i] + b[j];
if (fa[x] == 0 && fb[x] == 0) {
cout << a[i] << " " << b[j] << endl;
return 0;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 3e5 + 10;
struct N {
int x, y, idx;
} a[NN], b[NN];
int aa, bb;
bool operator<(N a, N b) { return a.y > b.y; }
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1, x, y; i <= n; i++) {
scanf("%d%d", &x, &y);
if (x < y)
a[++aa] = {x, y, i};
else
b[++bb] = {y, x, i};
}
sort(a + 1, a + aa + 1);
sort(b + 1, b + bb + 1);
if (aa > bb) {
printf("%d\n", aa);
for (int i = 1; i <= aa; i++) {
printf("%d ", a[i].idx);
}
puts("");
} else {
printf("%d\n", bb);
for (int i = bb; i >= 1; i--) {
printf("%d ", b[i].idx);
}
puts("");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0, k = 0, l = 0, c = 0, d = 0, p = 0, nl = 0, np = 0;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
k *= l;
c *= d;
k /= nl;
p /= np;
cout << min(min(k / n, p / n), c / n) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, sum;
int num[1100];
int main() {
sum = 0;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= m; i++) {
scanf("%d", &num[i]);
sum += num[i];
}
if (sum < n) {
printf("-1\n");
return 0;
}
if (num[h] == 1) {
printf("%.6lf\n", (double)0);
return 0;
}
double ex = 1.0;
int x = sum - num[h];
int y = sum - 1;
for (int i = 1; i <= n - 1; i++) {
ex *= (x * 1.0) / y;
x--;
y--;
}
printf("%.10lf\n", (double)(1.0 - ex));
}
| 4 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const int MAXN = 500001;
const int C = 220000;
ll ans = 0;
int umn[MAXN], umx[MAXN];
int dmn[MAXN], dmx[MAXN];
struct Val {
vector<int> a[MAXN];
void calc(int md) {
umn[0] = MAXN;
umx[0] = -MAXN;
for (int i = 1; i < MAXN; ++i) {
umn[i] = umn[i - 1], umx[i] = umx[i - 1];
for (int y : a[i]) {
umn[i] = min(umn[i], y);
}
for (int y : a[i]) {
umx[i] = max(umx[i], y);
}
}
dmn[MAXN - 1] = MAXN;
dmx[MAXN - 1] = -MAXN;
for (int i = MAXN - 2; i >= 0; --i) {
dmn[i] = dmn[i + 1], dmx[i] = dmx[i + 1];
for (int y : a[i]) {
dmn[i] = min(dmn[i], y);
}
for (int y : a[i]) {
dmx[i] = max(dmx[i], y);
}
}
for (int i = 1; i < MAXN; ++i) {
if (i % 2 != md) {
continue;
}
int l = max(dmn[i + 1], umn[i - 1]) + 1;
int r = min(dmx[i + 1], umx[i - 1]) - 1;
if (((l + C) % 2) != (i % 2)) {
++l;
}
if (((r + C) % 2) != (i % 2)) {
--r;
}
int ad = (r - l);
if (ad >= 0) {
ans += max(0, ad / 2 + 1);
}
}
}
};
Val v[2];
int main() {
ios_base::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(20);
cout.tie(nullptr);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
v[(x + y + C) % 2].a[x + y + C].push_back(x - y);
}
v[0].calc(1);
v[1].calc(0);
cout << ans << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n, m, cnt = 0;
cin >> n >> m;
cnt = m;
while (n < m) {
if (m % 10 == 1) {
m /= 10;
} else if (m % 2 == 0) {
m /= 2;
} else {
cout << "NO";
return 0;
}
v.push_back(m);
}
if (m != n) {
cout << "NO";
return 0;
}
cout << "YES" << endl << v.size() + 1 << endl;
for (int i = v.size() - 1; i >= 0; i--) {
cout << v[i] << " ";
}
cout << cnt;
return 0;
}
| 1 |
#include <bits/stdc++.h>
char str[15][15] = {0};
char prefix[106][15] = {0};
long o = 0;
long g[106][4] = {0}, m;
char gene[5] = "ACGT";
long f[1006][106][15] = {0};
long a[106] = {0};
char opt[15] = {0};
long find(char opt[], long l, long r) {
long i, j, k;
long a[15] = {0};
for (i = 1; i <= m; i++) {
for (j = 1; opt[j]; j++) {
for (k = 0; opt[j + k] == str[i][1 + k] && opt[j + k] && str[i][1 + k];
k++)
;
if (!str[i][1 + k])
for (k = 0; str[i][1 + k]; k++) a[j + k] = 1;
}
}
for (j = l; j <= r; j++)
if (!a[j]) return 0;
return 1;
}
long search(char opt[], long l) {
long i, j, k;
long a[15] = {0};
for (i = 1; i <= m; i++) {
for (j = 1; opt[j]; j++) {
for (k = 0; opt[j + k] == str[i][1 + k] && opt[j + k] && str[i][1 + k];
k++)
;
if (!str[i][1 + k])
for (k = 0; str[i][1 + k]; k++) a[j + k] = 1;
}
}
for (i = l + 1; a[i]; i++)
;
return i - 1;
}
int main() {
long n, i, j, k, l, t;
long ans = 0;
char ch;
scanf("%ld%ld", &n, &m);
for (i = 1; i <= m; i++) scanf("%s", str[i] + 1);
for (i = 1; i <= m; i++)
for (j = 1; str[i][j]; j++) {
ch = str[i][j + 1];
str[i][j + 1] = 0;
for (k = 1; k <= o; k++)
if (strcmp(prefix[k] + 1, str[i] + 1) == 0) break;
if (k > o) {
strcpy(prefix[++o] + 1, str[i] + 1);
prefix[o][0] = strlen(prefix[o] + 1);
}
str[i][j + 1] = ch;
if (!str[i][j + 1]) a[k] = 1;
}
for (i = 0; i <= o; i++) {
for (j = 0; j < 4; j++) {
memset(opt, 0, sizeof(opt));
strcpy(opt, prefix[i]);
opt[opt[0] + 1] = gene[j];
for (k = 1; k <= prefix[i][0] + 1; k++)
for (l = 1; l <= o; l++) {
if (strcmp(opt + k, prefix[l] + 1) == 0) {
g[i][j] = l;
goto loop;
}
}
loop:;
}
}
f[0][0][0] = 1;
for (i = 0; i < n; i++)
for (j = 0; j <= o; j++)
for (k = 0; k <= prefix[j][0]; k++)
if (f[i][j][k]) {
for (l = 0; l < 4; l++)
if (g[j][l]) {
memset(opt, 0, sizeof(opt));
strcpy(opt, prefix[j]);
opt[prefix[j][0] + 1] = gene[l];
t = search(opt, k);
if (t >= prefix[j][0] + 1 - prefix[g[j][l]][0]) {
f[i + 1][g[j][l]]
[t - (prefix[j][0] + 1 - prefix[g[j][l]][0])] += f[i][j][k];
f[i + 1][g[j][l]]
[t - (prefix[j][0] + 1 - prefix[g[j][l]][0])] %= 1000000009;
}
}
}
for (j = 1; j <= o; j++)
for (k = 0; k <= prefix[j][0]; k++)
if (find(prefix[j], k + 1, prefix[j][0])) {
ans += f[n][j][k];
ans %= 1000000009;
}
printf("%ld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long inf = 4e18, mod = 1e9 + 7;
void solve() {
vector<string> v[12];
v[0] = {"ab", "bc", "ca"};
v[1] = {"ac", "cb", "ba"};
v[2] = {"ba", "ac", "cb"};
v[3] = {"bc", "ca", "ab"};
v[4] = {"ca", "ab", "bc"};
v[5] = {"cb", "ba", "ac"};
v[6] = {"aa", "bb", "cc", "ab", "bc"};
v[7] = {"aa", "bb", "cc", "ac", "cb"};
v[8] = {"aa", "bb", "cc", "ba", "ac"};
v[9] = {"aa", "bb", "cc", "bc", "ca"};
v[10] = {"aa", "bb", "cc", "ca", "ab"};
v[11] = {"aa", "bb", "cc", "cb", "ba"};
string st[12] = {"abc", "acb", "bac", "bca", "cab", "cba",
"abc", "acb", "bac", "bca", "cab", "cba"};
int n;
cin >> n;
string s, t;
cin >> s >> t;
for (int i = 0; i < 12; i++) {
bool see = 1;
for (auto kt : v[i]) {
if (kt == s || kt == t) see = 0;
}
if (see) {
cout << "YES\n";
char a = st[i][0], b = st[i][1], c = st[i][2];
if (i < 6) {
for (int j = 1; j <= n; j++) cout << a << b << c;
} else {
for (int j = 1; j <= n; j++) cout << a;
for (int j = 1; j <= n; j++) cout << b;
for (int j = 1; j <= n; j++) cout << c;
}
cout << endl;
return;
}
}
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 1e6 + 10;
int fa[N], p[N][21], cnt, head[N], vis[N];
struct Edge {
int v, next;
} e[N << 1];
inline void add(int u, int v) {
e[++cnt].v = v;
e[cnt].next = head[u];
head[u] = cnt;
}
inline void dfs(int u, int Fa) {
fa[u] = Fa;
p[u][0] = Fa;
for (int i = 1; i <= 20; i++) p[u][i] = p[p[u][i - 1]][i - 1];
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].v;
if (v == Fa) continue;
dfs(v, u);
}
return;
}
int main() {
int n = read(), k = read();
int res = n - k;
for (int i = 1; i < n; i++) {
int u = read(), v = read();
add(u, v);
add(v, u);
}
dfs(n, n);
res--;
vis[n] = 1;
for (int i = n - 1; i >= 1; i--) {
if (vis[i]) continue;
int len = 1, v = i;
for (int j = 20; j >= 0; j--)
if (!vis[p[v][j]]) {
v = p[v][j];
len += (1 << j);
}
if (len <= res) {
res -= len;
int ff = i;
while (1) {
if (vis[ff]) break;
vis[ff] = 1;
ff = fa[ff];
}
}
}
for (int i = 1; i <= n; i++)
if (!vis[i]) printf("%d ", i);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x[11], a[11], b;
for (int i = 0; i < 11; i++) x[i] = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
while (m--) {
cin >> b;
x[b]++;
}
for (int i = 0; i < n; i++)
if (x[a[i]]) cout << a[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 60;
char T[100010];
bool vis[100010 << 1];
int m;
int rt = 1, lt = 1, cnt = 1;
int to[100010 << 1][5], dis[5][5];
long long n, g[70][5][5], s[5][5], q[5][5];
struct node {
int ch[5], par, len;
} a[100010 << 1];
void insert(int c) {
int np = ++cnt, p = lt;
lt = np;
a[np].len = a[p].len + 1;
for (; p && !a[p].ch[c]; p = a[p].par) a[p].ch[c] = np;
if (p) {
int q = a[p].ch[c];
if (a[q].len == a[p].len + 1)
a[np].par = q;
else {
int nq = ++cnt;
a[nq] = a[q], a[nq].len = a[p].len + 1;
a[q].par = a[np].par = nq;
for (; p && a[p].ch[c] == q; p = a[p].par) a[p].ch[c] = nq;
}
} else
a[np].par = rt;
}
void build() {
for (int i = 1; i <= m; i++) insert(T[i] - 'A');
}
void dfs(int o) {
if (vis[o]) return;
vis[o] = 1;
for (int i = 0; i < 4; i++) to[o][i] = m * 2;
for (int i = 0; i < 4; i++)
if (a[o].ch[i]) {
dfs(a[o].ch[i]);
for (int j = 0; j < 4; j++)
to[o][j] = min(to[a[o].ch[i]][j] + 1, to[o][j]);
} else
to[o][i] = 0;
}
bool judge(long long c) {
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) s[i][j] = 0;
for (int t = 0; c; t++, c >>= 1)
if (c & 1) {
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) q[i][j] = inf;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
for (int k = 0; k < 4; k++)
q[i][j] = min(s[i][k] + g[t][k][j], q[i][j]);
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) s[i][j] = q[i][j];
}
long long ml = inf;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) ml = min(s[i][j], ml);
return ml < n;
}
long long EF(long long L, long long R) {
for (long long mid; mid = (L + R + 1 >> 1), L < R;)
if (judge(mid - 1))
L = mid;
else
R = mid - 1;
return L;
}
void work() {
dfs(rt);
for (int i = 0; i < 4; i++) {
int o = a[rt].ch[i];
for (int j = 0; j < 4; j++) dis[i][j] = to[o][j] + 1;
}
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) g[0][i][j] = dis[i][j];
for (int t = 0; t < 60; t++) {
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) g[t + 1][i][j] = inf;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
for (int k = 0; k < 4; k++)
g[t + 1][i][j] = min(g[t][i][k] + g[t][k][j], g[t + 1][i][j]);
}
printf("%lld", EF(1, n));
}
int main() {
scanf("%lld", &n);
scanf("%s", T + 1);
m = strlen(T + 1);
build();
work();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, l, j, t, S, k, x, b, p[2100000], v[2100000], a[2100000],
sum[2010000];
string s;
long long K(long long b, long long p) {
x = 1, k = 1000000007;
while (t) {
if (t % 2) x = x * b % k;
b = b * b % k;
t /= 2;
}
return x % k;
}
signed main() {
cin >> n >> m >> s, l = s.size(), s = " " + s;
for (long long i = 2; i <= l; i++) {
while (j > 0 && s[i] != s[j + 1]) j = p[j];
if (s[i] == s[j + 1]) j++;
p[i] = j;
}
for (long long i = l; i; i = p[i]) v[i] = 1;
for (long long i = 1; i <= m; i++)
scanf("%lld", &a[i]), sum[a[i]]++, sum[a[i] + l]--;
for (long long i = 2; i <= m; i++)
if (a[i] - a[i - 1] < l && !v[a[i - 1] + l - a[i]]) return printf("0"), 0;
t = S = 0;
for (long long i = 1; i <= n; i++) S += sum[i], t += (S == 0);
if (t == 0)
return puts("1"), 0;
else
cout << K(26, t);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 200111;
struct Node {
int next[30];
int win, lose;
} nodes[MN];
int n, k, nnodes;
void dfs(int u) {
nodes[u].win = false;
nodes[u].lose = false;
bool hasChild = false;
for (int c = 0, _a = (30); c < _a; c++) {
int v = nodes[u].next[c];
if (!v) continue;
dfs(v);
hasChild = true;
nodes[u].win |= !nodes[v].win;
nodes[u].lose |= !nodes[v].lose;
}
if (!hasChild) nodes[u].lose = true;
}
int main() {
ios ::sync_with_stdio(false);
while (cin >> n >> k) {
memset(nodes, 0, sizeof nodes);
nnodes = 1;
for (int i = (1), _b = (n); i <= _b; i++) {
string tmp;
cin >> tmp;
int p = 1;
for (int i = 0, _a = (tmp.length()); i < _a; i++) {
char c = tmp[i] - 'a';
if (!nodes[p].next[c]) {
++nnodes;
nodes[p].next[c] = nnodes;
}
p = nodes[p].next[c];
}
}
dfs(1);
if (!nodes[1].win)
cout << "Second";
else if (nodes[1].win && nodes[1].lose)
cout << "First";
else if (k % 2 == 1)
cout << "First";
else
cout << "Second";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
cin >> x;
}
template <typename T, typename T0>
void read(T &x, T0 &y) {
cin >> x >> y;
}
template <typename T, typename T0, typename T1>
void read(T &x, T0 &y, T1 &z) {
cin >> x >> y >> z;
}
template <typename T, typename T0, typename T1, typename T2>
void read(T &x, T0 &y, T1 &z, T2 &w) {
cin >> x >> y >> z >> w;
}
template <typename T, typename T0>
void read(pair<T, T0> &p) {
cin >> p.first >> p.second;
}
template <typename T>
void read(vector<T> &oneD) {
for (long long i = 0; i < oneD.size(); i++) {
read(oneD[i]);
}
}
template <typename T>
void read(T oneD[], int n) {
for (long long i = 0; i < n; i++) {
read(oneD[i]);
}
}
template <typename T>
void write(T &x) {
cout << x << " ";
}
template <typename T, typename T0>
void write(T &x, T0 &y) {
cout << x << " " << y << "\n";
}
template <typename T, typename T0, typename T1>
void write(T &x, T0 &y, T1 &z) {
cout << x << " " << y << " " << z << "\n";
}
template <typename T, typename T0, typename T1, typename T2>
void write(T &x, T0 &y, T1 &z, T2 &w) {
cout << x << " " << y << " " << z << " " << w << "\n";
}
template <typename T, typename T0>
void write(pair<T, T0> &p) {
write(p.first);
write(p.second);
cout << "\n";
}
template <typename T>
void write(vector<T> &oneD) {
for (long long i = 0; i < oneD.size(); i++) {
write(oneD[i]);
}
cout << "\n";
}
template <typename T>
void write(T oneD[], int n) {
for (long long i = 0; i < n; i++) {
write(oneD[i]);
}
cout << "\n";
}
template <typename T, typename T0>
void write(map<T, T0> &mpp) {
for (auto it : mpp) {
write(it.first);
cout << ": ";
write(it.second);
cout << "\n";
}
cout << "\n";
}
vector<long long> sieve;
void Sieve(int N) {
const long long maxn = N;
sieve.resize(maxn);
for (long long(i) = 0; (i) < (maxn); ++(i)) sieve[i] = i;
sieve[1] = -1;
sieve[0] = -1;
for (long long(i) = 2; (i) <= (maxn); (i) += (1))
if (i == sieve[i])
for (long long j = 2 * i; j < maxn; j += i)
if (sieve[j] == j) sieve[j] = i;
}
long long extended_GCD(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long gcd = extended_GCD(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
}
long long power(long long a, long long b, long long m = 1000000007) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long modinv(long long a, long long mod = 1000000007) {
long long x, y;
extended_GCD(a, mod, x, y);
if (x < 0) x += mod;
return x;
}
void solve() {
int n;
cin >> n;
vector<long long> B(n);
map<long long, long long> A;
map<long long, long long> sz;
read(B);
for (int i = 0; i < n; ++i) {
A[B[i] - i] += i;
sz[B[i] - i]++;
}
long long ans = 0;
for (auto x : A) {
long long sm = x.first * sz[x.first] + x.second;
ans = max(ans, sm);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
const int maxai = 5032999;
bool isp[maxai];
int p[maxai], a[200005], wzp[266], n, q;
int f[200005][17], res[maxai][8];
void init() {
memset(isp, true, sizeof(isp));
for (int i = (2); i < int(maxai); ++i) {
if (isp[i]) {
p[++*p] = i;
for (int j = i + i; j < maxai; j += i) isp[j] = false;
}
}
for (int i = (0); i < int(1 << 8); ++i) wzp[i] = wzp[i >> 1] + (i & 1);
}
signed main() {
init();
n = rd(), q = rd();
for (int i = (1); i <= int(n); ++i) a[i] = rd();
for (int id = (1); id <= int(n); ++id) {
int top = 0, s[10];
for (int j = 1; 1ll * p[j] * p[j] <= a[id] && j <= *p; ++j) {
while (a[id] % (p[j] * p[j]) == 0) a[id] /= p[j] * p[j];
if (a[id] % p[j] == 0) s[top++] = p[j], a[id] /= p[j];
}
if (a[id] != 1) s[top++] = a[id];
for (int i = (0); i < int(1 << top); ++i) {
int ans = 1;
for (int j = 0; j < top; ++j)
if (i >> j & 1) ans *= s[j];
for (int j = (0); j < int(8); ++j)
f[id][j + top - wzp[i]] = ((f[id][j + top - wzp[i]]) < (res[ans][j])
? (res[ans][j])
: (f[id][j + top - wzp[i]]));
res[ans][top - wzp[i]] = id;
}
}
for (int i = (1); i <= int(n); ++i) {
for (int j = (1); j < int(16); ++j)
f[i][j] = ((f[i][j]) < (f[i][j - 1]) ? (f[i][j - 1]) : (f[i][j]));
for (int j = (0); j < int(16); ++j)
f[i][j] = ((f[i][j]) < (f[i - 1][j]) ? (f[i - 1][j]) : (f[i][j]));
}
for (int id = (0); id < int(q); ++id) {
int l = rd(), r = rd();
for (int i = (0); i < int(16); ++i)
if (f[r][i] >= l) {
writeln(i);
break;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, v[100500];
double ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = 1; i <= m; i++) {
int a, b, c;
cin >> a >> b >> c;
if (c == 0) continue;
ans = max(ans, (v[a] + v[b] + .0) / (c + .0));
}
printf("%.10f", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const N = 501;
int n, m, q, vs0, vs[N];
vector<pair<int, int>> g[N];
void go(int u, int l, int r) {
vs[u] = vs0;
for (int i = 0; i < g[u].size(); ++i) {
if (g[u][i].second >= l && g[u][i].second <= r) continue;
if (vs[g[u][i].first] != vs0) go(g[u][i].first, l, r);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v; i <= m; ++i) {
scanf("%d%d", &u, &v);
g[u].push_back({v, i});
g[v].push_back({u, i});
}
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
int an = 0;
++vs0;
for (int i = 1; i <= n; ++i) {
if (vs[i] != vs0) ++an, go(i, l, r);
}
printf("%d\n", an);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> > >
q;
map<pair<long long, long long>, long long> mii;
map<pair<long long, long long>, long long>::iterator iit1, iit2;
map<string, long long> msi;
map<string, long long>::iterator sit;
map<char, long long> mci;
map<char, long long>::iterator cit;
map<int, bool> mark;
map<int, bool>::iterator bit;
vector<long long> v[100010], v1;
vector<long long>::iterator vit;
bool vis[100010];
int c[100010];
pair<long long, long long> dfs(int src) {
vis[src] = true;
int res1 = 0, res2 = 0;
for (int i = 0; i < v[src].size(); i++) {
if (!vis[v[src][i]]) {
pair<long long, long long> p = dfs(v[src][i]);
res1 += p.first;
res2 += p.second;
}
}
iit1 = mii.lower_bound({src, 0}), iit2 = mii.lower_bound({src, 1000000007});
return {res1 + 1, res2 + distance(iit1, iit2)};
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, k, x, y;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) cin >> c[i];
for (int i = 0; i < m; i++)
cin >> x >> y, v[x].push_back(y), v[y].push_back(x),
mii[{min(x, y), max(x, y)}] = 1;
long long ans = 0;
for (int i = 0; i < k; i++) {
pair<long long, long long> p = dfs(c[i]);
v1.push_back(-p.first);
ans += (p.first * (p.first - 1)) / 2 - p.second;
}
sort(v1.begin(), v1.end());
for (int i = 0; i < v1.size(); i++) v1[i] = -v1[i];
int p = 0, cnt = 0, cnt2 = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cnt++;
iit1 = mii.lower_bound({i, 0}), iit2 = mii.lower_bound({i, 1000000007});
cnt2 -= distance(iit1, iit2);
}
}
ans += v1[p] * cnt + (cnt * (cnt - 1)) / 2 + cnt2;
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, x, y, mini, maxi;
cin >> n >> a >> b >> c;
mini = min(a, min(b, c));
if (n % mini == 0) {
cout << n / mini << endl;
return 0;
}
maxi = n / mini;
int p = 0;
for (x = maxi; x >= 0; x--) {
if ((a * x) > n) continue;
for (y = 0; y <= maxi; y++) {
if ((a * x) + (b * y) > n) continue;
int z = abs((n - ((a * x) + (b * y))) / c);
if ((a * x) + (b * y) + (c * z) == n) {
p = max(p, x + y + z);
}
}
}
cout << p << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int t[1000][1000];
int d1[1000][1000];
int d2[1000][1000];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
int x = c - '0';
x = 1 - x;
t[i][j] = x;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
{
int ii = i;
int jj = j;
while (t[ii][jj]) {
d1[i][j]++;
ii++;
jj++;
}
}
{
int ii = i;
int jj = j;
while (t[ii][jj]) {
d2[i][j]++;
ii++;
jj--;
}
}
}
}
int sol = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (t[i][j]) {
int d;
d = 1;
while (t[i][j - d] and t[i - d][j]) {
if (d2[i - d][j] >= d + 1) sol++;
d++;
}
d = 1;
while (t[i][j + d] and t[i - d][j]) {
if (d1[i - d][j] >= d + 1) sol++;
d++;
}
d = 1;
while (t[i][j - d] and t[i + d][j]) {
if (d1[i][j - d] >= d + 1) sol++;
d++;
}
d = 1;
while (t[i][j + d] and t[i + d][j]) {
if (d2[i][j + d] >= d + 1) sol++;
d++;
}
d = 1;
while (t[i][j - d] and t[i][j + d] and i - d >= 1) {
if (d1[i - d][j] >= d + 1 and d2[i - d][j] >= d + 1 and t[i - d][j])
sol++;
d++;
}
d = 1;
while (t[i][j - d] and t[i][j + d] and i + d <= n) {
if (d1[i][j - d] >= d + 1 and d2[i][j + d] >= d + 1 and t[i + d][j])
sol++;
d++;
}
d = 1;
while (t[i - d][j] and t[i + d][j] and j - d >= 1) {
if (d2[i - d][j] >= d + 1 and d1[i][j - d] >= d + 1 and t[i][j - d])
sol++;
d++;
}
d = 1;
while (t[i - d][j] and t[i + d][j] and j + d <= m) {
if (d1[i - d][j] >= d + 1 and d2[i][j + d] >= d + 1 and t[i][j + d])
sol++;
d++;
}
}
}
}
cout << sol << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace Work {
const int kMaxSz = 100010;
const int kMaxLim = 555;
int n, m;
map<int, int> id;
int arr[kMaxSz];
int idval[kMaxSz], nid = 0;
int cnt[kMaxSz];
int retid[kMaxLim], nretid = 0;
map<int, int> pos;
int sum[kMaxSz][kMaxLim];
void solve(FILE* fin, FILE* fout) {
fscanf(fin, "%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
fscanf(fin, "%d", arr + i);
if (!id.count(arr[i])) {
id[arr[i]] = ++nid;
idval[nid] = arr[i];
}
int cid = id[arr[i]];
cnt[cid]++;
}
for (int i = 1; i <= nid; i++)
if (cnt[i] >= idval[i]) {
retid[nretid++] = i;
pos[i] = nretid - 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < nretid; j++) sum[i][j] += sum[i - 1][j];
int cid = id[arr[i]];
if (cnt[cid] >= arr[i]) sum[i][pos[cid]]++;
}
for (int i = 0; i < m; i++) {
int l, r;
fscanf(fin, "%d%d", &l, &r);
int ret = 0;
for (int j = 0; j < nretid; j++)
ret += ((sum[r][j] - sum[l - 1][j]) == idval[retid[j]]);
fprintf(fout, "%d\n", ret);
}
return;
}
} // namespace Work
int main() {
Work::solve(stdin, stdout);
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.