solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int num[100005];
vector<int> v[100005];
void dfs(int x) {
if (!v[x].size()) {
num[x] = 1;
return;
}
for (int i = 0; i < v[x].size(); i++) {
dfs(v[x][i]);
num[x] += num[v[x][i]];
}
return;
}
int main() {
int n;
scanf("%d", &n);
int tmp;
for (int i = 2; i <= n; i++) {
scanf("%d", &tmp);
v[tmp].push_back(i);
}
dfs(1);
sort(num + 1, num + 1 + n);
for (int i = 1; i < n; i++) printf("%d ", num[i]);
printf("%d\n", num[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1001;
vector<int> g[N];
int dfs(int v, set<int> &left) {
set<int> newLeft, toDFS;
for (int u : g[v])
if (left.count(u)) newLeft.insert(u);
for (int u : newLeft) left.erase(u);
toDFS = left;
left = newLeft;
int ans = toDFS.size();
for (int u : toDFS) ans += dfs(u, left);
return ans;
}
int main() {
int n, m;
cin >> n >> m;
while (m--) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
set<int> left;
for (int i = 1; i <= n; i++) left.insert(i);
int ans = 0;
for (int i = 1; i <= n; i++)
if (left.count(i)) {
ans++;
left.erase(i);
dfs(i, left);
}
cout << ans - 1 << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long LLINF = 1e18;
const int INF = INT_MAX;
const long double PI = acos(-1);
const long double E = 2.71828183;
const int MOD = 1e9 + 7;
template <typename T>
struct segment_tree {
vector<T> tree;
int size;
T DEF;
void init(int n) {
size = 1;
DEF = INF;
while (size < n) size *= 2;
tree = vector<T>(2 * size, 0);
}
T merge(T a, T b) { return a + b; }
void set(int i, int x, T v, int lx, int rx) {
if (rx - lx == 1) {
tree[x] = v;
return;
}
int m = (rx + lx) / 2;
if (i < m) {
set(i, 2 * x + 1, v, lx, m);
} else {
set(i, 2 * x + 2, v, m, rx);
}
tree[x] = merge(tree[2 * x + 1], tree[2 * x + 2]);
}
void set(int i, T v) { set(i, 0, v, 0, size); }
T sum(int l, int r, int x, int lx, int rx) {
if (r <= lx || rx <= l)
return 0;
else if (l <= lx && rx <= r)
return tree[x];
int m = (lx + rx) / 2;
return merge(sum(l, r, 2 * x + 1, lx, m), sum(l, r, 2 * x + 2, m, rx));
}
T sum(int l, int r) { return sum(l, r + 1, 0, 0, size); }
void print_tree() {
for (int i = 0; i < tree.size(); i++) cout << to_string(tree[i]) << " ";
cout << "\n";
}
};
vector<int> bfs(vector<vector<int> > adj, int src) {
queue<int> q;
vector<int> d(adj.size(), INF);
q.push(src);
d[src] = 0;
while (!q.empty()) {
int c = q.front();
q.pop();
for (int nbr : adj[c]) {
if (d[nbr] == INF) q.push(nbr);
d[nbr] = min(d[nbr], d[c] + 1);
}
}
return d;
}
template <typename T>
void read(vector<T>& v) {
int n = v.size();
for (int i = 0; i < n; i++) cin >> v[i];
}
long double log(long double a, long double b) { return log(b) / log(a); }
long long power(long long base, long long exp, long long M = LLONG_MAX) {
long long res = 1;
while (exp) {
if (exp % 2 == 1) res = ((res % M) * (base % M)) % M;
base = ((base % M) * (base % M)) % M;
exp /= 2;
}
return res;
}
string to_base(int n, int new_base) {
string s;
int nn = n;
while (nn) {
s += to_string(nn % new_base);
nn /= new_base;
}
reverse(s.begin(), s.end());
return s;
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
bitset<(const int)(5e5)> sieve() {
bitset<(const int)(5e5)> ans;
for (int i = 2; i < 5e5; i++) ans[i] = 1;
for (int i = 2; i * i < 5e5; i++) {
if (ans[i])
for (int j = 2 * i; j < 5e5; j += i) ans[j] = 0;
}
return ans;
}
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
void solve() {
int n, x, y;
cin >> n >> x >> y;
if (n <= 2 ||
((x == n / 2 || x == n / 2 + 1) && (y == n / 2 || y == n / 2 + 1))) {
cout << "NO"
<< "\n";
return;
}
{
cout << "YES"
<< "\n";
return;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T &first) {
return first * first;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-9;
char TEMPORARY_CHAR;
const int INF = 1e9;
inline void fft(vector<complex<long double> > &a, bool invert) {
int n = (int)a.size();
for (int i = 1, j = 0; i < n; ++i) {
int bit = n >> 1;
for (; j >= bit; bit >>= 1) j -= bit;
j += bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
long double ang = 2 * PI / len * (invert ? -1 : 1);
complex<long double> wlen(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
complex<long double> w(1);
for (int j = 0; j < len / 2; ++j) {
complex<long double> u = a[i + j], v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert)
for (int i = 0; i < n; ++i) a[i] /= n;
}
inline void input(int &a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = (a << 3) + (a << 1) + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline void out(long long a) {
if (!a) putchar('0');
if (a < 0) {
putchar('-');
a = -a;
}
char s[20];
int i;
for (i = 0; a; ++i) {
s[i] = '0' + a % 10;
a /= 10;
}
for (int j = (i)-1; j >= 0; j--) putchar(s[j]);
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
struct lnum {
vector<int> a;
int base;
lnum(int num = 0, int base = 1000000000) : base(base) {
if (!num) a.resize(1);
while (num) {
a.push_back(num % base);
num /= base;
}
}
inline int len() const { return a.size(); }
lnum &operator=(const lnum &l) {
if (this != &l) {
a = l.a;
base = l.base;
}
return *this;
}
inline friend lnum operator+(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int ln = l.len(), rn = r.len();
int n = max(ln, rn);
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = o;
if (i < ln) s += l.a[i];
if (i < rn) s += r.a[i];
o = s >= base;
if (o) s -= base;
ret.a[i] = s;
}
if (o) ret.a.push_back(1);
return ret;
}
inline friend lnum operator-(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
int n = l.len();
int rn = r.len();
ret.a.resize(n);
int o = 0;
for (int i = 0; i < n; ++i) {
int s = l.a[i] - o;
if (i < rn) s -= r.a[i];
o = s < 0;
if (o) s += base;
ret.a[i] = s;
}
if (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator*(const lnum &l, const lnum &r) {
lnum ret(0, l.base);
int base = l.base;
if (l.len() * r.len() > 1000000) {
vector<complex<long double> > fa(l.a.begin(), l.a.end()),
fb(r.a.begin(), r.a.end());
int n = 1;
while (n < max(l.len(), r.len())) n <<= 1;
n <<= 1;
fa.resize(n), fb.resize(n);
fft(fa, false), fft(fb, false);
for (int i = 0; i < n; ++i) fa[i] *= fb[i];
fft(fa, true);
ret.a.resize(n);
for (int i = 0; i < n; ++i) ret.a[i] = int(fa[i].real() + 0.5);
int carry = 0;
for (int i = 0; i < n; ++i) {
ret.a[i] += carry;
carry = ret.a[i] / base;
ret.a[i] %= base;
}
} else {
ret.a.resize(l.len() + r.len());
for (int i = 0; i < l.len(); ++i)
for (int j = 0, carry = 0; j < r.len() || carry; ++j) {
long long cur = ret.a[i + j] +
(long long)l.a[i] * (j < r.len() ? r.a[j] : 0) +
carry;
ret.a[i + j] = cur % base;
carry = cur / base;
}
}
while (ret.len() > 1 && !ret.a.back()) ret.a.pop_back();
return ret;
}
inline friend lnum operator/(const lnum &l, const int &r) {
lnum ret(0, l.base);
ret.a.resize(l.len());
int carry = 0;
for (int i = l.len() - 1; i >= 0; --i) {
long long cur = l.a[i] + (long long)carry * l.base;
ret.a[i] = cur / r;
carry = cur % r;
}
while (ret.len() > 1 && ret.a.back() == 0) ret.a.pop_back();
return ret;
}
inline friend bool operator<(const lnum &l, const lnum &r) {
if (l.len() < r.len()) return true;
if (l.len() > r.len()) return false;
int n = l.len();
for (int i = n - 1; i >= 0; --i) {
if (l.a[i] < r.a[i]) return true;
if (l.a[i] > r.a[i]) return false;
}
return false;
}
inline friend bool operator>(const lnum &l, const lnum &r) { return r < l; }
inline friend bool operator==(const lnum &l, const lnum &r) {
if (l.len() != r.len()) return false;
int n = l.len();
for (int i = n - 1; i; --i) {
if (l.a[i] != r.a[i]) return false;
}
return true;
}
inline friend bool operator!=(const lnum &l, const lnum &r) {
return !(l == r);
}
inline void print() {
if (base == 1000000000) {
printf("%d", a.back());
for (int i = a.size() - 2; i >= 0; --i) printf("%09d", a[i]);
} else {
for (int i = a.size() - 1; i >= 0; --i) printf("%d", a[i]);
}
}
};
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int main() {
int(n);
input((n));
;
int(m);
input((m));
;
int(k);
input((k));
;
int b[26];
memset((b), 0, sizeof(b));
for (int i = 0; i < (int)(k); i++) b[i] = 1;
reverse(b, b + 26);
string ss[n];
for (int i = 0; i < (int)(n); i++) cin >> ss[i];
pair<int, int> s, f;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(m); j++) {
if (ss[i][j] == 'S') s = make_pair(i, j);
if (ss[i][j] == 'T') f = make_pair(i, j);
}
string ans;
int best = INF;
do {
int d[n][m];
memset(d, 255, sizeof(d));
queue<pair<int, int> > q;
q.push(f);
d[f.first][f.second] = 0;
while (!q.empty()) {
pair<int, int> v = q.front();
q.pop();
for (int i = 0; i < (int)(4); i++) {
int first = v.first + dx[i];
int second = v.second + dy[i];
if (first >= 0 && first < n && second >= 0 && second < m &&
d[first][second] == -1 &&
(ss[first][second] == 'S' || b[ss[first][second] - 'a'])) {
d[first][second] = d[v.first][v.second] + 1;
q.push(make_pair(first, second));
}
}
}
if (d[s.first][s.second] == -1 || d[s.first][s.second] > best) continue;
vector<pair<int, int> > Q;
Q.push_back(s);
char used[n][m];
memset((used), 0, sizeof(used));
used[s.first][s.second] = 1;
string cur;
while (1) {
vector<pair<int, int> > QQ;
char min_c = 'z' + 1;
for (int t = 0; t < (int)(Q.size()); t++) {
pair<int, int> v = Q[t];
for (int i = 0; i < (int)(4); i++) {
int first = v.first + dx[i];
int second = v.second + dy[i];
if (first >= 0 && first < n && second >= 0 && second < m &&
d[first][second] == d[v.first][v.second] - 1 &&
(ss[first][second] == 'T' || b[ss[first][second] - 'a'])) {
if (ss[first][second] < min_c) {
QQ.clear();
min_c = ss[first][second];
}
if (ss[first][second] == min_c && !used[first][second]) {
QQ.push_back(make_pair(first, second));
used[first][second] = 1;
}
}
}
}
if (min_c == 'T')
break;
else {
Q = QQ;
cur += min_c;
}
}
if (d[s.first][s.second] < best) {
ans = cur;
best = d[s.first][s.second];
} else {
((ans) = (cur) < (ans) ? (cur) : (ans));
}
} while (next_permutation(b, b + 26));
if (best == INF)
puts("-1");
else
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void add(map<pair<long long, long long>, long long> &mp,
pair<long long, long long> elem) {
if (mp.count(elem) == 0) {
mp.insert({elem, 1});
} else {
mp[elem]++;
}
}
void del(map<pair<long long, long long>, long long> &mp,
pair<long long, long long> elem) {
if (mp[elem] == 1) {
mp.erase(elem);
} else {
mp[elem]--;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long q;
cin >> q;
for (int k = 0; k < q; ++k) {
long long n, m, c, c0;
cin >> n >> m >> c >> c0;
vector<pair<long long, pair<long long, long long>>> fr;
fr.push_back({0, {0, c0}});
fr.push_back({m, {0, 0}});
for (int i = 0; i < n; ++i) {
long long a, aa, aaa;
cin >> a >> aa >> aaa;
fr.push_back({a, {aaa, aa}});
}
sort(fr.begin(), fr.end());
map<pair<long long, long long>, long long> st;
long long ans = 0;
bool bad = false;
long long sum = 0;
for (int j = 0; j < fr.size() - 1; ++j) {
add(st, {fr[j].second.first, fr[j].second.second});
sum += fr[j].second.second;
while (sum > c) {
int val = (*(--st.end())).first.first;
int cnt = (*(--st.end())).first.second;
del(st, {val, cnt});
sum -= cnt;
if (sum < c) {
add(st, {val, (c - sum)});
sum = c;
}
}
long long need = fr[j + 1].first - fr[j].first;
if (sum < need) {
cout << -1 << "\n";
bad = true;
break;
}
while (need != 0) {
need -= (*st.begin()).first.second;
ans += (*st.begin()).first.first * (*st.begin()).first.second;
sum -= (*st.begin()).first.second;
int val = (*st.begin()).first.first;
int cnt = (*st.begin()).first.second;
del(st, {val, cnt});
if (need < 0) {
add(st, {val, -need});
ans -= (-need) * val;
sum += (-need);
need = 0;
}
}
}
if (!bad) cout << ans << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long get_idx(int p) {
int idx = 1;
while (idx < p) idx *= 2;
return idx;
}
void update(vector<unsigned long long> &tree, unsigned long long idx,
unsigned long long val) {
tree[idx] = val;
idx /= 2;
while (idx) {
tree[idx] = tree[idx * 2] | tree[idx * 2 + 1];
idx /= 2;
}
}
int main() {
unsigned long long n, k, x, a = 1;
unsigned long long ans = 0;
cin >> n >> k >> x;
vector<unsigned long long> data(n);
for (int i = 0; i < k; i++) a *= x;
for (int i = 0; i < n; i++) cin >> data[i];
unsigned long long idx = get_idx(n);
vector<unsigned long long> tree(idx * 2);
for (int i = idx; i < idx + n; i++) update(tree, i, data[i - idx]);
for (int i = 0; i < n; i++) {
update(tree, i + idx, data[i] * a);
ans = max(tree[1], ans);
update(tree, i + idx, data[i]);
}
cout << ans << endl;
}
| 4 |
// E1. Square-free division (easy version)
/**
* @Author: ©dnhirapara
*/
#include "bits/stdc++.h"
using namespace std;
/************defination************/
#define endl "\n"
#ifdef LOCAL
#include <dnhirapara/logger.h>
/* https://pastebin.com/ZJv9HqFh */
#else
#define logger(x...) /* DEBUG */
#define debug(x) /* DEBUG */
#endif
#define ll long long int
const int32_t mx = 2e5 + 500;
bool is_prime[mx];
vector<int32_t> primes;
void init()
{
for (int32_t i = 0; i < mx; i++)
{
is_prime[i] = true;
}
is_prime[0] = is_prime[1] = false;
for (int32_t i = 2; i * i < mx; i++)
{
if (is_prime[i])
{
for (int32_t j = i * i; j < mx; j += i)
{
is_prime[j] = false;
}
}
}
for (int32_t i = 2; i < mx; i++)
{
if (is_prime[i])
{
primes.emplace_back(i);
}
}
}
/**
* @time comp :
* @space comp :
*/
int32_t main()
{
// ios_base::sync_with_stdio(false);std::cin.tie(0);std::cout.tie(0);
// std::cin.ignore(); must be there when using getline(std::cin, s)
int64_t tc = 1;
std::cin >> tc;
init();
while (tc--)
{
int32_t N, K;
cin >> N >> K;
vector<int32_t> A(N);
auto removeSquare = [](int32_t n) -> int32_t {
int32_t ind = 0;
for (int32_t i = 0; i < primes.size(); i++)
{
int32_t val = primes[i] * primes[i];
if (val > n)
{
break;
}
while (n % val == 0)
{
n /= val;
}
}
return n;
};
for (int32_t i = 0; i < N; i++)
{
cin >> A[i];
A[i] = removeSquare(A[i]);
}
logger(A);
vector<int32_t> nxt(N);
unordered_map<int32_t, int32_t> mp;
mp[A[N - 1]] = N - 1;
nxt[N - 1] = N;
for (int32_t i = N - 2; i >= 0; i--)
{
nxt[i] = mp[A[i]] == 0 ? N : mp[A[i]];
mp[A[i]] = i;
}
logger(nxt);
int32_t l = 0, r = 0;
int32_t ans = 1;
set<int32_t> s;
for (int32_t i = 0; i < N; i++)
{
if (s.find(A[i]) != s.end())
{
ans++;
s.clear();
}
s.insert(A[i]);
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int a, b;
int n;
long long int fact[1000006];
long long int c[1000006];
int digits(int i) {
int flag = 0;
while (i != 0) {
int rem = i % 10;
if (rem != a && rem != b) {
flag = 1;
break;
}
i = i / 10;
}
return (flag + 1) % 2;
}
long long int power(long long int a, long long int b) {
if (b == 0) return 1;
long long int temp = power(a, b / 2);
temp = ((temp % 1000000007) * (temp % 1000000007)) % 1000000007;
if (b & 1) temp = (temp * a) % 1000000007;
return temp;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
int maxsum = b * n;
int minsum = a * n;
long long int ways = 0;
int d = b - a;
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i <= n; i++)
fact[i] = ((fact[i - 1] % 1000000007) * (i % 1000000007)) % 1000000007;
for (int i = 0; i <= n; i++)
c[i] = ((fact[n] % 1000000007) *
(power((fact[n - i] * fact[i]) % 1000000007, 1000000007 - 2))) %
1000000007;
for (int i = minsum; i <= maxsum; i++) {
if (digits(i)) {
int diff = i - minsum;
if (diff % d == 0) {
int times = diff / d;
if (times == 0) {
ways = (ways + 1) % 1000000007;
continue;
}
long long int combi = 1;
int x = times;
combi = c[x];
ways = (ways % 1000000007 + combi % 1000000007) % 1000000007;
}
}
}
printf("%lld\n", ways);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n, c0, c1, h;
string s;
cin >> n >> c0 >> c1 >> h >> s;
int z = count(s.begin(), s.end(), '0');
int o = n - z;
if (c0 < c1) {
int ans = z * c0;
if (c0 + h < c1)
ans += (c0 + h) * o;
else
ans += c1 * o;
cout << ans << "\n";
} else {
int ans = o * c1;
if (c1 + h < c0)
ans += (c1 + h) * z;
else
ans += c0 * z;
cout << ans << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int type[200010];
int weight[200010];
long long int power(long long int a, long long int b) {
a %= mod;
long long int res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long int inv(long long int a) { return power(a, mod - 2); }
long long int dp[3001][3001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, w1 = 0, w2 = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> type[i];
for (int i = 1; i <= n; i++) {
cin >> weight[i];
if (!type[i])
w1 += weight[i];
else
w2 += weight[i];
}
dp[0][0] = 1;
for (int i = 1; i <= m; i++) {
if (w1 - (i - 1) > 0)
dp[i][0] =
dp[i - 1][0] * (w1 - (i - 1)) % mod * inv(w1 - (i - 1) + w2) % mod;
for (int j = 1; j <= i; j++) {
if (w1 - (i - 1 - j) > 0)
dp[i][j] = dp[i - 1][j] * (w1 - (i - 1 - j)) % mod *
inv(w1 - (i - 1 - j) + w2 + j);
dp[i][j] = (dp[i][j] + dp[i - 1][j - 1] * (w2 + j - 1) % mod *
inv(w1 - (i - 1 - (j - 1)) + w2 + (j - 1))) %
mod;
}
}
long long int c1 = 0, c2 = 0;
for (int i = 0; i <= m; i++) c2 = (c2 + dp[m][i] * (w2 + i)) % mod;
c2 = c2 * inv(w2) % mod;
for (int i = 0; i <= m; i++) c1 = (c1 + dp[m][i] * (w1 - (m - i))) % mod;
c1 = c1 * inv(w1) % mod;
for (int i = 1; i <= n; i++)
if (type[i])
cout << weight[i] * c2 % mod << '\n';
else
cout << weight[i] * c1 % mod << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to;
int nxt;
int head;
};
Edge edge[400005];
bool be_hometown[200005];
int n, team, x, y, ed = 1, ans, size[200005];
int top1, team1[200005];
int top2, team2[200005];
inline void add_edge(int u, int v) {
edge[ed].to = v;
edge[ed].nxt = edge[u].head;
edge[u].head = ed;
ed++;
}
inline void dfs_findroot(int now, int father) {
if (be_hometown[now] == true) {
size[now] = 1;
}
int tmp = edge[now].head;
while (tmp > 0) {
int son = edge[tmp].to;
if (son == father) {
tmp = edge[tmp].nxt;
continue;
}
dfs_findroot(son, now);
size[now] += size[son];
if (ans > 0) {
size[now] = 0;
return;
}
tmp = edge[tmp].nxt;
}
if (size[now] >= team) {
ans = now;
}
}
inline void dfs_findteam(int now, int father) {
if (be_hometown[now] == true) {
if (top1 < team) {
top1++;
team1[top1] = now;
} else {
top2++;
team2[top2] = now;
}
}
int tmp = edge[now].head;
while (tmp > 0) {
int son = edge[tmp].to;
if (son == father) {
tmp = edge[tmp].nxt;
continue;
}
dfs_findteam(son, now);
tmp = edge[tmp].nxt;
}
}
int main() {
scanf("%d%d", &n, &team);
for (register int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add_edge(x, y);
add_edge(y, x);
}
for (register int i = 1; i <= 2 * team; i++) {
scanf("%d", &x);
be_hometown[x] = true;
}
dfs_findroot(1, -1);
dfs_findteam(ans, -1);
printf("1\n%d\n", ans);
for (register int i = 1; i <= team; i++) {
printf("%d %d %d\n", team1[i], team2[i], ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010, mod = 1e9 + 7;
const long long inf = 1e18;
bool Ask(int a, int b, int c, int d) {
if (a > c) swap(a, c);
if (b > d) swap(b, d);
cout << "? " << a << " " << b << " " << c << " " << d << endl;
int x;
cin >> x;
return x & 1;
}
void Ans(int a, int b, int c, int d) {
cout << "! " << a << " " << b << " " << c << " " << d << endl;
exit(0);
}
int n, x1 = -1, STRANGE = -1, x2 = -1, y2 = -1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
if (Ask(i, 1, i, n)) (x1 == -1 ? x1 : x2) = i;
}
for (int i = 1; i < n; i++) {
if (Ask(1, i, n, i)) (STRANGE == -1 ? STRANGE : y2) = i;
}
if (x1 != -1 && x2 == -1) x2 = n;
if (STRANGE != -1 && y2 == -1) y2 = n;
if (x1 != -1 && STRANGE != -1) {
if (Ask(x1, STRANGE, x1, STRANGE) == 0) swap(x1, x2);
Ans(x1, STRANGE, x2, y2);
}
if (x1 == -1) {
int l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (Ask(1, STRANGE, mid, STRANGE))
r = mid;
else
l = mid;
}
x1 = r;
l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (Ask(1, y2, mid, y2))
r = mid;
else
l = mid;
}
x2 = r;
Ans(x1, STRANGE, x2, y2);
}
if (STRANGE == -1) {
int l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (Ask(x1, 1, x1, mid))
r = mid;
else
l = mid;
}
STRANGE = r;
l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (Ask(x2, 1, x2, mid))
r = mid;
else
l = mid;
}
y2 = r;
Ans(x1, STRANGE, x2, y2);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt(time(0));
const int MAXN = 412;
int dp[MAXN][MAXN];
bool solve(const string& s, const string& t, int k) {
memset(dp, -1, sizeof(dp));
dp[0][0] = k;
int m = t.size();
for (int i = 1; i <= s.size(); i++) {
char c = s[i - 1];
for (int j = 0; j <= i; j++) {
dp[i][j] = dp[i - 1][j];
if (j > 0 && j <= k && c == t[j - 1] && dp[i - 1][j - 1] != -1)
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1]);
if (dp[i - 1][j] != -1 && dp[i - 1][j] < m && c == t[dp[i - 1][j]])
dp[i][j] = max(dp[i][j], dp[i - 1][j] + 1);
}
}
return dp[s.size()][k] == m;
}
bool solve(const string& s, const string& t) {
for (int i = 1; i <= t.size(); i++) {
if (solve(s, t, i)) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
int T;
cin >> T;
while (T--) {
string s, t;
cin >> s >> t;
if (solve(s, t))
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int N = 1e6 + 5;
const int M = 1e6 + 5;
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
char a[N], b[N];
long long sum[N];
long long mod_pow(long long x, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
cin >> a + 1 >> b + 1;
reverse(a + 1, a + 1 + n);
reverse(b + 1, b + 1 + m);
for (int i = m; i >= 1; i--) {
if (b[i] != '1') continue;
int t = min(n, i);
sum[t]++;
}
long long ans = 0;
for (int i = n; i >= 1; i--) {
sum[i] += sum[i + 1];
if (a[i] != '1') continue;
ans = (ans + sum[i] * mod_pow(2, i - 1)) % MOD;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long arr[300100];
long long suf[300100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
}
reverse(arr + 1, arr + n + 1);
for (long long i = 1; i <= n; i++) {
if (i == 1)
suf[i] = arr[i];
else
suf[i] = arr[i] + suf[i - 1];
}
multiset<long long> m;
for (long long i = 1; i <= n - 1; i++) {
m.insert(suf[i]);
}
long long ans = suf[n];
for (long long i = 1; i <= k - 1; i++) {
ans += (*m.rbegin());
m.erase(m.find(*m.rbegin()));
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int EPS = 1e-6;
const int INF = (int)(INT_MAX - 100);
const long long mod = (int)(1e+9 + 7);
const int N = (int)(0);
int main() {
int n;
cin >> n;
int t[n][n];
for (int it = 0; it < n; it++) {
t[it][0] = 1;
t[0][it] = 1;
}
for (int f = (1); f <= (n - 1); f++) {
for (int c = (1); c <= (n - 1); c++) {
t[f][c] = t[f - 1][c] + t[f][c - 1];
}
}
cout << t[n - 1][n - 1];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, d;
int n;
scanf("%d", &n);
while (n--) {
scanf("%lf", &d);
if (d < 4 && d != 0)
printf("N\n");
else
printf("Y %.10f %.10f\n", (d - sqrt(d * d - 4 * d)) / 2,
(d + sqrt(d * d - 4 * d)) / 2);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline int msbp(int x) { return 31 - __builtin_clz(x); }
inline int msb(int x) { return 1 << msbp(x); }
const int INF = 0x3f3f3f3f;
int n, m, ans, hi;
vector<int> a;
vector<bool> vis, have;
inline int get_id(int x, int b) { return (x << 1) ^ b; }
void add(queue<int>& nxt, int id) {
if (!vis[id]) {
vis[id] = 1;
nxt.push(id);
}
}
void bfs(int s) {
queue<int> nxt;
add(nxt, s);
while (!nxt.empty()) {
int curt = nxt.front();
nxt.pop();
int cur = curt >> 1, t = curt & 1;
if (t == 0) {
add(nxt, get_id(cur, 1));
} else {
int opp = hi - 1 - cur;
if (have[opp]) add(nxt, get_id(opp, 0));
while (opp) {
int b = opp & -opp;
opp -= b;
add(nxt, get_id(cur + b, 1));
}
}
}
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> m;
hi = 1 << n;
a.resize(m);
vis.resize(2 * hi);
have.resize(hi);
for (int i = 0; i < (m); ++i) {
cin >> a[i];
have[a[i]] = 1;
}
for (int i = 0; i < (m); ++i) {
if (!vis[get_id(a[i], 0)]) {
bfs(get_id(a[i], 0));
++ans;
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& p) {
return out << "(" << p.first << ", " << p.second << ")";
}
bool solve(int);
int main() {
cout << fixed << setprecision(10);
cerr << fixed << setprecision(3);
int test = 0;
while (solve(test)) {
++test;
}
return 0;
}
int calc(int n, int b) {
if (n == 1) return 0;
int s = 1;
while (s * 2 <= n) s *= 2;
return s * b + (s / 2) + calc(s / 2 + n - s, b);
}
bool solve(int) {
int n, b, p;
if (scanf("%d%d%d", &n, &b, &p) != 3) return false;
printf("%d %d\n", calc(n, b), n * p);
return true;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename C>
auto test(C* x) -> decltype(cerr << *x, 0LL);
template <typename C>
char test(...);
template <typename C>
struct itr {
C begin, end;
};
template <typename C>
itr<C> get_range(C b, C e) {
return itr<C>{b, e};
};
struct debug {
template <typename T>
debug& operator<<(const T&) {
return *this;
}
};
string _ARR_(int* arr, int sz) {
string ret = "{ " + to_string(arr[0]);
for (int i = 1; i < sz; i++) ret += " , " + to_string(arr[i]);
ret += " }";
return ret;
}
const long long INF = 1e18 + 7;
const int MxN = 5010;
long long dp[2][MxN];
inline long long d(int x, int y) { return abs(x - y); }
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b.begin(), b.end());
int cur = 1;
dp[cur][0] = d(a[0], b[0]);
for (int i = 1; i < n; i++) {
dp[cur][i] = min(dp[cur][i - 1], d(a[0], b[i]));
}
for (int i = 1; i < n; i++) {
cur = !cur;
dp[cur][0] = d(a[i], b[0]) + dp[!cur][0];
for (int j = 1; j < n; j++) {
dp[cur][j] = min(dp[cur][j - 1], dp[!cur][j] + d(a[i], b[j]));
}
}
cout << dp[cur][n - 1] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, c;
cin >> n >> k;
set<int> s;
list<int> l;
for (int i = 0; i < n; i++) {
cin >> x;
if (!s.count(x)) {
if (l.size() >= k) {
l.push_front(x);
auto it = l.end();
it--;
c = *it;
l.pop_back();
s.erase(c);
s.insert(x);
} else {
s.insert(x);
l.push_front(x);
}
}
}
cout << l.size() << endl;
for (auto i = l.begin(); i != l.end(); i++) {
cout << *i << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, a;
string s;
int main() {
while (!cin.eof()) {
getline(cin, s);
if (s[0] == '+')
i++;
else if (s[0] == '-')
i--;
else
a += i * (s.size() - s.find(":") - 1);
}
cout << a;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct linkcut {
linkcut *par, *left, *right;
array<int, 2> value, path;
int sub, vir, weight;
bool flip;
linkcut(array<int, 2> x, int y) {
par = left = right = nullptr;
path = value = x;
weight = sub = y;
flip = false;
vir = 0;
}
};
array<int, 2> path(linkcut *u) { return u ? u->path : array<int, 2>{0, 0}; }
int sub(linkcut *u) { return u ? u->sub : 0; }
void pull(linkcut *u) {
if (u) {
u->path = max({path(u->left), u->value, path(u->right)});
u->sub = sub(u->left) + u->vir + u->weight + sub(u->right);
}
}
void push(linkcut *u) {
if (u && u->flip) {
u->flip = false;
swap(u->left, u->right);
if (u->left) {
u->left->flip ^= true;
}
if (u->right) {
u->right->flip ^= true;
}
}
}
bool root(linkcut *u) {
return !u->par || (u->par->left != u && u->par->right != u);
}
bool left(linkcut *u) { return u->par->left == u; }
void assign(linkcut *u, linkcut *v, bool d) {
(d ? u->left : u->right) = v;
if (v) {
v->par = u;
}
}
void rotate(linkcut *u) {
linkcut *p = u->par, *g = p->par;
bool d = left(u);
assign(p, d ? u->right : u->left, d);
if (root(p)) {
u->par = g;
} else {
assign(g, u, left(p));
}
assign(u, p, !d);
}
void splay(linkcut *u) {
while (!root(u)) {
linkcut *p = u->par, *g = p->par;
push(g), push(p), push(u);
if (!root(p)) {
if (left(u) == left(p)) {
rotate(p);
} else {
rotate(u);
}
}
rotate(u);
pull(g), pull(p), pull(u);
}
push(u);
}
void access(linkcut *u) {
linkcut *c = nullptr;
for (linkcut *v = u; v; v = v->par) {
splay(v);
v->vir += sub(v->right);
v->right = c;
v->vir -= sub(v->right);
pull(v);
c = v;
}
splay(u);
}
void reroot(linkcut *u) {
access(u);
u->flip ^= true;
}
void link(linkcut *u, linkcut *v) {
reroot(v), access(u);
u->vir += sub(v);
v->par = u;
pull(u);
}
void cut(linkcut *u, linkcut *v) {
reroot(v), access(u);
u->left = nullptr;
v->par = nullptr;
pull(u);
}
const int N = 100000 + 1;
const int M = 300000;
linkcut *bovinia[N], *edges[M];
array<int, 2> points[M];
int n;
bool same(int u, int v) {
access(bovinia[u]), access(bovinia[v]);
return bovinia[u]->par;
}
void link(int a) {
auto [u, v] = points[a];
access(bovinia[u]), access(bovinia[v]);
n -= sub(bovinia[u]) % 2;
n -= sub(bovinia[v]) % 2;
link(edges[a], bovinia[u]);
link(edges[a], bovinia[v]);
access(edges[a]);
n += sub(edges[a]) % 2;
}
void cut(int a) {
access(edges[a]);
int s = sub(edges[a]);
if (s == 0) {
return;
}
n -= s % 2;
auto [u, v] = points[a];
cut(edges[a], bovinia[u]);
cut(edges[a], bovinia[v]);
access(bovinia[u]), access(bovinia[v]);
n += sub(bovinia[u]) % 2;
n += sub(bovinia[v]) % 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
bovinia[i] = new linkcut({0, 0}, 1);
}
priority_queue<array<int, 2>> que;
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
points[i] = {u, v};
edges[i] = new linkcut({w, i}, 0);
if (same(u, v)) {
reroot(bovinia[u]), access(bovinia[v]);
auto [a, j] = path(bovinia[v]);
if (w < a) {
cut(j);
}
}
if (!same(u, v)) {
que.push({w, i});
link(i);
}
int ans = -1;
while (n == 0) {
auto [a, j] = que.top();
ans = a;
cut(j);
if (n > 0) {
link(j);
break;
}
que.pop();
}
cout << ans << "\n";
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
int x = 0;
cin >> n >> x;
vector<pair<int, pair<int, int>>> lefts;
vector<pair<int, pair<int, int>>> rights;
lefts.reserve(n);
rights.reserve(n);
for (int i = 0; i < n; ++i) {
int left = 0;
int right = 0;
int cost = 0;
cin >> left >> right >> cost;
int const length = 1 + right - left;
if (length < x) {
lefts.emplace_back(left, make_pair(length, cost));
rights.emplace_back(right, make_pair(length, cost));
}
}
sort(begin(lefts), end(lefts));
sort(begin(rights), end(rights));
unordered_map<int, int> seen_length_to_costs;
auto rights_it = begin(rights);
int best_cost = numeric_limits<int>::max();
for (auto const lefts_item : lefts) {
while (rights_it->first < lefts_item.first) {
auto seen_length_cost_it =
seen_length_to_costs.find(rights_it->second.first);
if (seen_length_cost_it != end(seen_length_to_costs)) {
seen_length_cost_it->second =
min(seen_length_cost_it->second, rights_it->second.second);
} else {
seen_length_to_costs[rights_it->second.first] =
rights_it->second.second;
}
++rights_it;
}
auto const matching_item_it =
seen_length_to_costs.find(x - lefts_item.second.first);
if (matching_item_it != end(seen_length_to_costs)) {
best_cost =
min(best_cost, matching_item_it->second + lefts_item.second.second);
}
}
if (best_cost == numeric_limits<int>::max()) {
cout << -1 << endl;
} else {
cout << best_cost << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void qmax(int &x, int y) {
if (x < y) x = y;
}
void qmin(int &x, int y) {
if (x > y) x = y;
}
inline int read() {
char s;
int k = 0, base = 1;
while ((s = getchar()) != '-' && s != EOF && !(isdigit(s)))
;
if (s == EOF) exit(0);
if (s == '-') base = -1, s = getchar();
while (isdigit(s)) {
k = k * 10 + (s ^ '0');
s = getchar();
}
return k * base;
}
inline void write(int x) {
static char cnt, num[15];
cnt = 0;
if (!x) {
putchar('0');
return;
}
for (; x; x /= 10) num[++cnt] = x % 10;
for (; cnt; putchar(num[cnt--] + 48))
;
}
const int maxn = 1e5 + 10;
const int maxm = 2e5 + 10;
int n, m, s, S;
int po[maxn], ne[maxm], to[maxm], id;
int win[maxn][2];
int vis[maxn][2];
void add(int x, int y) {
id++;
to[id] = y;
ne[id] = po[x];
po[x] = id;
}
int Ne[maxn][2];
void dfs(int x, int y) {
if (vis[x][y]) return;
vis[x][y] = 1;
if (po[x] == 0) {
win[x][y] = -1;
Ne[x][y] = 0;
return;
}
if (y == 0) {
win[x][y] = -1;
for (int i = po[x]; i; i = ne[i]) {
dfs(to[i], y ^ 1);
if (win[to[i]][y ^ 1] == -1) {
Ne[x][y] = to[i];
win[x][y] = 1;
return;
}
if (win[to[i]][y ^ 1] == 0) win[x][y] = 0;
}
} else {
for (int i = po[x]; i; i = ne[i]) {
dfs(to[i], y ^ 1);
if (win[to[i]][y ^ 1] == 1) {
Ne[x][y] = to[i];
win[x][y] = -1;
return;
}
}
return;
}
}
int Vis[maxn];
int q[maxn];
bool dfs1(int x) {
Vis[x] = 1;
q[x] = 1;
for (int i = po[x]; i; i = ne[i]) {
int y = to[i];
if (q[y]) return true;
if (Vis[y]) continue;
if (dfs1(y)) return true;
}
q[x] = 0;
return false;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
s = read();
for (int j = 1; j <= s; j++) add(i, read());
}
S = read();
dfs(S, 0);
if (win[S][0] == 1) {
printf("Win\n%d ", S);
for (int i = Ne[S][0], y = 0; i; y ^= 1, i = Ne[i][y]) {
printf("%d ", i);
}
return 0;
}
if (dfs1(S)) {
printf("Draw");
return 0;
}
printf("Lose");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
int min1;
if (f > e) {
min1 = min(b, c);
min1 = min(min1, d);
d -= min1;
cout << min(a, d) * e + min1 * f << endl;
} else {
min1 = min(a, d);
d -= min1;
cout << min1 * e + min(min(b, c), d) * f << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
struct yqh {
double K, B;
bool flag;
double xl, xr, yl, yr;
void mk() {
double x1, y1, x2, y2;
scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
xl = min(x1, x2);
xr = max(x1, x2);
yl = min(y1, y2);
yr = max(y1, y2);
if (fabs(x1 - x2) > eps) {
K = (y2 - y1) / (x2 - x1);
B = y2 - x2 * K;
flag = false;
} else
flag = true;
}
void get(double x1, double y1, double x2, double y2) {
xl = min(x1, x2);
xr = max(x1, x2);
yl = min(y1, y2);
yr = max(y1, y2);
if (fabs(x1 - x2) > eps) {
K = (y2 - y1) / (x2 - x1);
B = y2 - x2 * K;
flag = false;
} else
flag = true;
}
void print() {
if (flag)
printf("True ");
else
printf("Flase ");
printf("%.9lf %.9lf %.9lf %.9lf\n", xl, yl, xr, yr);
}
} A, B, C, D;
double X1, X2, Y1, Y2;
bool getpd_1(yqh a, yqh b) {
if (b.flag) swap(a, b);
if (a.flag) {
if (b.flag)
return fabs(a.xl - b.xl) < eps;
else {
if (a.xl < b.xl - eps || a.xl > b.xr + eps) return false;
double y = a.xl * b.K + b.B;
return y > b.yl - eps && y < b.yr + eps && y > a.yl - eps &&
y < a.yr + eps;
}
} else {
if (fabs(a.K - b.K) < eps) {
if (fabs(a.B - b.B) > eps) return false;
if (a.xl > b.xr + eps) return false;
if (a.xr < b.xl - eps) return false;
return true;
} else {
double x = (b.B - a.B) / (a.K - b.K);
return (x > a.xl - eps && x < a.xr + eps && x > b.xl - eps &&
x < b.xr + eps);
}
}
}
bool getpd_2(yqh a, yqh b) {
if (b.flag) swap(a, b);
if (a.flag) {
if (b.flag)
return false;
else {
if (a.xl < b.xl - eps || a.xl > b.xr + eps) return false;
double y = a.xl * b.K + b.B;
return y > b.yl - eps && y < b.yr + eps && y > a.yl - eps &&
y < a.yr + eps;
}
} else {
if (fabs(a.K - b.K) < eps) {
return false;
} else {
double x = (b.B - a.B) / (a.K - b.K);
return (x > a.xl - eps && x < a.xr + eps && x > b.xl - eps &&
x < b.xr + eps);
}
}
}
bool check_1() {
C.get(X1, Y1, X2, Y2);
if (getpd_1(A, C)) return false;
if (getpd_2(B, C)) return false;
return true;
}
void getjd(yqh a, yqh b, double &x1, double &y1) {
if (b.flag) swap(a, b);
if (a.flag) {
x1 = a.xl;
y1 = x1 * b.K + b.B;
return;
}
x1 = (b.B - a.B) / (a.K - b.K);
y1 = x1 * a.K + a.B;
}
void getpoint(yqh a, double x1, double y1, double &x2, double &y2) {
if (a.flag) {
x2 = a.xl * 2 - x1;
y2 = y1;
return;
}
if (fabs(a.K) < eps) {
y2 = a.yl * 2 - y1;
x2 = x1;
return;
}
yqh b;
b.K = -1 / a.K;
b.B = y1 - b.K * x1;
b.flag = false;
double x3, y3;
getjd(a, b, x3, y3);
x2 = x3 * 2 - x1;
y2 = y3 * 2 - y1;
}
bool check_2() {
double x3, y3;
getpoint(B, X2, Y2, x3, y3);
C.get(X1, Y1, x3, y3);
if (!getpd_2(B, C)) {
return false;
}
double x4, y4;
getjd(B, C, x4, y4);
C.get(X1, Y1, x4, y4);
if (getpd_1(A, C)) {
return false;
}
C.get(X2, Y2, x4, y4);
if (getpd_1(A, C)) return false;
return true;
}
int main() {
scanf("%lf%lf", &X1, &Y1);
scanf("%lf%lf", &X2, &Y2);
A.mk();
B.mk();
if (check_1()) {
printf("Yes\n");
return 0;
}
if (check_2()) {
printf("Yes\n");
return 0;
}
printf("No\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
const double eps = 1e-7, PI = 3.1415926;
const int N = 1e6;
using namespace std;
long long q, n, m, k, a[N], sum, mx = -1, mn = 1e9;
char c[N];
string s, t;
vector<int> vec;
map<char, long long> M;
int heoheo(string s1, string s2) {
int cnt = 0;
for (int i = 0; i < s1.size(); i++)
if (s1[i] != s2[i]) cnt++;
return cnt;
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
cin >> s >> t;
for (int i = 0; i + n <= m; i++) {
string d = t.substr(i, n);
q = heoheo(s, d);
if (q < mn) {
vec.clear();
for (int j = 0; j < n; j++) {
if (s[j] != d[j]) vec.push_back(j + 1);
}
}
mn = min(mn, q);
}
cout << mn << endl;
for (int i = 0; i < vec.size(); i++) printf("%d ", vec[i]);
;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
int n, m, tot;
char s[N][N];
int len[N][N][4], sumx[N][N], sumy[N][N];
int ans[N * N][3];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> (s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '*')
len[i][j][0] = len[i][j - 1][0] + 1;
else
len[i][j][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = m; j; j--)
if (s[i][j] == '*')
len[i][j][1] = len[i][j + 1][1] + 1;
else
len[i][j][1] = 0;
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n; i++)
if (s[i][j] == '*')
len[i][j][2] = len[i - 1][j][2] + 1;
else
len[i][j][2] = 0;
for (int j = 1; j <= m; j++)
for (int i = n; i; i--)
if (s[i][j] == '*')
len[i][j][3] = len[i + 1][j][3] + 1;
else
len[i][j][3] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int Min = INF;
for (int k = 0; k < 4; k++) Min = min(Min, len[i][j][k]);
if (Min <= 1) continue;
sumx[i][j - Min + 1]++;
sumx[i][j + Min]--;
sumy[i - Min + 1][j]++;
sumy[i + Min][j]--;
ans[++tot][0] = i, ans[tot][1] = j, ans[tot][2] = Min;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) sumx[i][j] = (sumx[i][j] + sumx[i][j - 1]);
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n; i++) sumy[i][j] = (sumy[i][j] + sumy[i - 1][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '*' && sumx[i][j] + sumy[i][j] <= 0) {
cout << -1;
return 0;
}
cout << tot << "\n";
for (int i = 1; i <= tot; i++)
cout << ans[i][0] << " " << ans[i][1] << " " << ans[i][2] - 1 << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double dp[100][100][100];
double C[100][100];
int main(void) {
int n, m;
int a[100];
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
C[0][0] = 1;
for (int i = 1; i <= 50; i++) {
for (int j = 1; j <= i; j++) C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
C[i][0] = 1;
}
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for (int i = 0; i <= n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k <= i; k++) {
double q = 1;
if ((m - j) == 1) {
int k1 = (n - i) / a[m];
if ((n - i) % a[m]) k1++;
if (k1 <= k)
dp[n][j + 1][k] += dp[i][j][k];
else
dp[n][j + 1][k1] += dp[i][j][k];
} else {
q *= 1.0 / (m - j);
for (int c = 0; c < n - i - 1; c++) q *= 1.0 * (m - j - 1) / (m - j);
for (int c = 1; c <= n - i; c++) {
int k1 = c / a[j + 1];
if (c % a[j + 1]) k1++;
if (k1 <= k)
dp[i + c][j + 1][k] += dp[i][j][k] * C[n - i][c] * q;
else
dp[i + c][j + 1][k1] += dp[i][j][k] * C[n - i][c] * q;
q *= 1.0 / (m - j);
q /= 1.0 * (m - j - 1) / (m - j);
}
q = 1;
for (int c = 0; c < n - i; c++) q *= 1.0 * (m - j - 1) / (m - j);
dp[i][j + 1][k] += dp[i][j][k] * q;
}
}
double res = 0;
for (int i = 0; i <= n; i++) res += dp[n][m][i] * i;
printf("%.9lf\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
set<int> g[N], good;
bool bad[N];
int p[N];
int n, m, k;
int to_del;
inline int get_p(int v) { return p[v] = ((p[v] == v) ? (v) : get_p(p[v])); }
inline bool can(int v, int u) {
v = get_p(v), u = get_p(u);
return (u != v &&
!(g[v].find(u) != g[v].end() && g[u].find(v) != g[u].end()));
}
inline bool Merge(int a, int b) {
a = get_p(a), b = get_p(b);
if (!can(a, b)) return 0;
if (g[a].size() > g[b].size()) swap(a, b);
vector<int> nlst;
for (auto v : g[a])
if (!can(v, b)) nlst.emplace_back(v);
g[a].clear();
g[b] = set<int>(nlst.begin(), nlst.end());
if (good.find(a) != good.end()) {
good.erase(a);
good.insert(b);
}
p[a] = b;
to_del = a;
return 1;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) p[i] = i;
for (int i = 1; i <= m; ++i) {
int a, b;
cin >> a >> b;
g[a].insert(b);
g[b].insert(a);
}
for (auto v : g[1]) bad[v] = 1;
for (int i = 2; i <= n; ++i)
if (!bad[i]) good.insert(i);
for (int i = 2; i <= n; ++i) {
if (!bad[i]) continue;
for (int j = i + 1; j <= n && !Merge(j, i); ++j)
;
}
for (int i = 2; i <= n; ++i) {
if (good.find(get_p(i)) != good.end()) continue;
for (auto v : good)
if (Merge(i, v)) break;
}
for (int i = 2; i <= n; ++i) {
if (get_p(i) == i && good.find(i) != good.end() && good.size() > k) {
bool flag = 0;
for (auto v : good) {
if (Merge(v, i)) {
flag = 1;
break;
}
}
if (flag) good.erase(to_del);
}
}
if (good.size() != k) {
cout << "im";
} else {
for (int i = 2; i <= n; ++i) {
if (good.find(get_p(i)) == good.end()) {
cout << "im";
break;
}
}
}
cout << "possible";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2 * ((1 << 30) - 1) + 1, MOD = (1e9) + 7;
const int MAXN = (1e5) + 5, MAXS = 2e5;
int po = 0;
long long sq[MAXS];
long long a[MAXN];
int n;
long long hold = 0;
void s_sq() {
cin >> n;
for (int i = 1; i < n; i += 2) {
cin >> a[i];
}
for (int i = 0; i < MAXS; i++) {
sq[i] = (((1LL * i) + 1) * ((1LL * i) + 1));
}
}
long long x_solve(long long q, long long y) {
long double x1;
long double d;
long long Q = sqrt(q);
d = sqrt(1.000000 * ((1LL * 4 * (y + (Q * Q)))));
x1 = ((-2 * Q) + d) / 2;
if ((ceil(x1) - x1 == 0) && (x1 > 0)) {
return ceil(x1);
}
return -1;
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
s_sq();
for (int i = 1; i < n; i += 2) {
if (po >= MAXS) {
cout << "No";
return 0;
}
bool mq = false;
while ((sq[po] <= hold) && (po < MAXS)) {
po++;
}
while (po < MAXS) {
long long cc = x_solve(sq[po], a[i]);
if (cc != -1) {
long long c1 = sqrt(sq[po]);
a[i - 1] = sq[po] - hold;
mq = true;
hold = ((c1 + cc) * (c1 + cc));
break;
} else {
po++;
}
}
if (!mq) {
cout << "No";
return 0;
}
}
cout << "Yes\n";
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, M, P, a[2017], b[2017];
int modul(int x) {
if (x < 0) return -x;
return x;
}
bool ok(int lim) {
int j = 1;
for (int i = 1; i <= N; i++) {
while (modul(a[i] - b[j]) + modul(b[j] - P) > lim && j <= M) j++;
if (j > M) return 0;
j++;
}
return 1;
}
int main() {
scanf("%d %d %d", &N, &M, &P);
for (int i = 1; i <= N; i++) scanf("%d", &a[i]);
for (int i = 1; i <= M; i++) scanf("%d", &b[i]);
sort(a + 1, a + N + 1);
sort(b + 1, b + M + 1);
int p = 0, u = 2e9, mij, ras = -1;
while (p <= u) {
mij = p + (u - p) / 2;
if (ok(mij))
ras = mij, u = mij - 1;
else
p = mij + 1;
}
printf("%d\n", ras);
return 0;
}
| 5 |
#include <bits/stdc++.h>
static constexpr int MAXN = 1e5 + 10;
struct edge {
int dest;
int dist;
bool operator<(const edge& other) const { return dist < other.dist; }
edge(int de, int di) : dest(de), dist(di) {}
};
static std::vector<int> from(MAXN, -1);
static std::vector<int> zero_nodes(const std::vector<std::vector<edge>>& g,
int start) {
std::vector<int> result(g.size(), -1);
std::queue<int> nodes;
result[start] = 0;
nodes.push(start);
while (!nodes.empty()) {
const int curr = nodes.front();
nodes.pop();
for (const edge& next : g[curr]) {
if (next.dist == 0 && result[next.dest] == -1) {
result[next.dest] = result[curr] + 1;
nodes.push(next.dest);
from[next.dest] = curr;
}
}
}
return result;
}
static std::vector<int> get_dist(const std::vector<std::vector<edge>>& g,
int start) {
std::vector<int> dist(g.size(), -1);
std::vector<bool> visited(g.size());
std::queue<int> nodes;
nodes.push(start);
dist[start] = 0;
visited[start] = true;
while (!nodes.empty()) {
const int curr = nodes.front();
nodes.pop();
for (const edge& e : g[curr]) {
if (visited[e.dest]) continue;
visited[e.dest] = true;
dist[e.dest] = dist[curr] + 1;
nodes.push(e.dest);
}
}
return dist;
}
int main(int argc, const char** argv) {
int node_count, edge_count;
std::scanf("%d %d", &node_count, &edge_count);
std::vector<std::vector<edge>> g(node_count);
for (int i = 0; i < edge_count; i++) {
int src, dest, dist;
std::scanf("%d %d %d", &src, &dest, &dist);
g[src].push_back(edge(dest, dist));
g[dest].push_back(edge(src, dist));
}
std::vector<int> zeroes = zero_nodes(g, node_count - 1);
std::vector<int> dist = get_dist(g, 0);
int start_level = dist[node_count - 1];
for (int i = 0; i < node_count; i++)
if (zeroes[i] != -1 && dist[i] < start_level) start_level = dist[i];
std::queue<int> nodes;
std::vector<bool> visited(g.size());
struct start_option {
int zcount;
int index;
bool operator<(const start_option& other) const {
return zcount < other.zcount;
}
bool operator>(const start_option& other) const {
return zcount > other.zcount;
}
start_option(int z, int i) : zcount(z), index(i) {}
};
std::priority_queue<start_option, std::vector<start_option>,
std::greater<start_option>>
options;
for (int i = 0; i < node_count; i++) {
if (zeroes[i] != -1 && dist[i] == start_level) {
options.push(start_option(zeroes[i], i));
}
}
while (!options.empty()) {
const start_option next = options.top();
options.pop();
nodes.push(next.index);
}
std::vector<int> choices(g.size() + 1);
while (!nodes.empty()) {
int optimal = 10;
int level = -1;
std::vector<int> popped;
while (!nodes.empty()) {
const int curr = nodes.front();
popped.push_back(curr);
nodes.pop();
for (const edge& e : g[curr])
if (dist[e.dest] + 1 == dist[curr]) optimal = std::min(optimal, e.dist);
level = dist[curr];
}
choices[level] = optimal;
assert(level != -1);
for (int node : popped) {
for (const edge& e : g[node]) {
if (dist[e.dest] + 1 == level && e.dist == optimal) {
if (visited[e.dest]) continue;
from[e.dest] = node;
visited[e.dest] = true;
nodes.push(e.dest);
}
}
}
}
std::string result;
for (int level = start_level; level >= 1; level--)
result += static_cast<char>(choices[level] + '0');
if (start_level == 0) result = "0";
std::vector<int> path;
int curr_node = 0;
while (curr_node != -1) {
path.push_back(curr_node);
curr_node = from[curr_node];
}
std::printf("%s\n", result.c_str());
std::printf("%lu\n", path.size());
for (int node : path) std::printf("%d ", node);
std::printf("\n");
return EXIT_SUCCESS;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 5e5 + 5;
long long int fac[maxn];
long long int invfac[maxn];
inline long long int mul(long long int a, long long int b) {
a *= b;
if (a >= 998244353) a %= 998244353;
return a;
}
inline long long int add(long long int a, long long int b) {
a += b;
if (a >= 998244353) a -= 998244353;
return a;
}
inline long long int powmod(long long int x, long long int y) {
long long int p = 1;
for (; y; y >>= 1, x = mul(x, x))
if (y & 1) p = mul(p, x);
return p;
}
inline long long int C(long long int n, long long int r) {
return mul(mul(fac[n], invfac[r]), invfac[n - r]);
}
int32_t main() {
fac[0] = 1;
for (long long int i = 1; i < maxn; i++) fac[i] = mul(fac[i - 1], i);
invfac[maxn - 1] = powmod(fac[maxn - 1], 998244353 - 2);
invfac[0] = 1;
for (long long int i = maxn - 2; i >= 1; i--)
invfac[i] = mul(invfac[i + 1], i + 1);
long long int n, k;
cin >> n >> k;
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
long long int av = n / i;
if (av < k) break;
ans = add(ans, C(av - 1, k - 1));
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[64];
int b[64];
int main(void) {
long long i, j, k, n, m, T, mm, cnt;
long long sum;
scanf("%lld", &T);
while (T--) {
scanf("%lld %lld", &n, &m);
memset(b, 0, sizeof(b));
memset(a, 0, sizeof(a));
sum = 0;
for (i = 0; i < m; i++) {
scanf("%lld", &mm);
sum += mm;
cnt = 0;
while (mm) {
if (mm % 2) a[cnt]++;
mm /= 2;
cnt++;
}
}
if (sum < n) {
printf("-1\n");
continue;
}
cnt = 0;
while (n) {
if (n % 2) b[cnt] = 1;
cnt++;
n /= 2;
}
cnt = 0;
for (i = 0; i < 64; i++) {
if (b[i]) {
if (a[i] == 0) {
for (j = i + 1; j < 64; j++) {
if (a[j]) {
a[j]--;
for (k = i; k < j; k++) {
a[k]++;
cnt++;
}
a[i]++;
break;
}
}
}
}
a[i] -= b[i];
a[i + 1] += a[i] / 2;
}
printf("%lld\n", cnt);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(false);
int n;
cin >> n;
vector<int> res(n, numeric_limits<int>::max());
int mask_size = n;
while ((mask_size & (mask_size - 1)) != 0) {
mask_size = mask_size & (mask_size - 1);
}
if (mask_size < n) mask_size <<= 1;
while (mask_size > 0) {
vector<int> q;
for (int i = 0; i < n; ++i) {
if ((i % mask_size) < mask_size / 2) q.push_back(i + 1);
}
if (!q.empty() && q.size() != n) {
cout << q.size() << endl;
for (int qi : q) {
cout << qi << " ";
}
cout << endl;
fflush(stdout);
for (int i = 0; i < n; ++i) {
int r;
cin >> r;
if ((i % mask_size) >= mask_size / 2) res[i] = min(res[i], r);
}
}
q.clear();
for (int i = 0; i < n; ++i) {
if ((i % mask_size) >= mask_size / 2) q.push_back(i + 1);
}
if (!q.empty() && q.size() != n) {
cout << q.size() << endl;
for (int qi : q) {
cout << qi << " ";
}
cout << endl;
fflush(stdout);
for (int i = 0; i < n; ++i) {
int r;
cin >> r;
if ((i % mask_size) < mask_size / 2) res[i] = min(res[i], r);
}
}
mask_size >>= 1;
}
cout << -1 << endl;
for (int ri : res) {
cout << ri << " ";
}
cout << endl;
fflush(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
int n, up;
int B[2];
deque<int> v[3];
using P = pair<int, int>;
vector<P> que;
void move(int id, int c) {
if (c > B[id] || int(v[id].size()) < c) {
throw 1;
}
que.push_back(P(id + 1, c));
deque<int> buf;
for (int i = 0; i < c; i++) {
buf.push_front(v[id].front());
v[id].pop_front();
}
for (int i = 0; i < c; i++) {
v[id + 1].push_front(buf.front());
buf.pop_front();
}
}
void dfs() {
int sz[3] = {int(v[0].size()), int(v[1].size()), int(v[2].size())};
if (sz[2] == n) return;
if (!sz[0] && !sz[1]) throw 1;
for (int i = 1; i < sz[1]; i++) {
if (v[1][i - 1] + 1 < v[1][i]) {
throw 1;
}
}
int m = 0;
for (int d : v[1]) {
m = max(m, d);
}
if (m == up) {
int c = 0;
while (v[1][c] != up) c++;
move(1, c + 1);
up -= c + 1;
dfs();
return;
}
int mi = v[0][0], ma = v[0][0];
bool di = false;
int co = 0;
int r = sz[0];
int fr = -1;
for (int i = 1; i < sz[0]; i++) {
if (v[0][i - 1] + 1 < v[0][i]) {
r = i;
break;
}
if (v[0][i - 1] > v[0][i]) {
if (fr == -1) {
fr = i;
}
co++;
}
mi = min(mi, v[0][i]);
ma = max(ma, v[0][i]);
}
co++;
if (co == 1) {
fr = r;
}
if (ma == up) {
move(0, 1);
dfs();
return;
}
if (sz[1] && mi < v[1][0]) {
int c = 0;
while (c < r && v[0][c] != v[1][0] - 1) {
c++;
}
if (v[0][c] == v[1][0] - 1) c++;
move(0, c);
dfs();
return;
}
if (ma - mi + 1 != r) {
move(0, r);
dfs();
return;
}
int u = (ma - m);
if (co >= 3) {
if (u <= B[1] || r <= min(B[0], B[1])) {
move(0, fr);
} else {
move(0, r);
}
dfs();
return;
}
if (fr <= B[0] && r - fr <= B[0] && u <= B[1]) {
move(0, fr);
dfs();
return;
}
if (co == 1) {
if (fr <= min(B[1], B[0])) {
move(0, fr);
} else {
move(0, 1);
}
dfs();
return;
}
int bi = m + B[1];
if (r - fr < B[1]) {
move(0, min(B[0], min(fr, B[1] - (r - fr))));
dfs();
return;
}
if (r - fr == B[1] && r <= B[0]) {
move(0, r);
dfs();
return;
}
move(0, min(B[0], fr + B[1]));
dfs();
return;
}
int main() {
cin >> n >> B[0] >> B[1];
up = n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v[0].push_back(x);
}
try {
dfs();
cout << "YES" << endl;
cout << que.size() << endl;
for (auto p : que) {
cout << p.first << " " << p.second << endl;
}
} catch (int a) {
cout << "NO" << endl;
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int h, w, in[606][606], T;
bool check() {
if (h & 1) return 0;
double ave = 0;
int a = h >> 1, b = a + 1;
double t = 1.0 / (256 * w);
for (int i = 1; i <= w; ++i) ave += t * abs(in[a][i] - in[b][i]);
double ave2 = 0;
for (int i = 1; i <= w; ++i) ave2 += t * abs(in[1][i] - in[h][i]);
return ave > ave2;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &h, &w);
for (int i = 1; i <= h; ++i)
for (int j = 1; j <= w; ++j) scanf("%d", in[i] + j);
if (check())
puts("YES");
else
puts("NO");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 345678, maxc = 26;
int a[maxn][maxc], temp[maxn][maxc], size[maxn], res[maxn];
int n, m;
void merge(int k, int root) {
for (int i = 0; i < maxc; i++)
if (a[k][i]) {
if (!temp[root][i]) {
temp[root][i] = m++;
for (int j = 0; j < maxc; j++) temp[temp[root][i]][j] = 0;
}
merge(a[k][i], temp[root][i]);
}
}
int countSame(int k, int root) {
int total = 1;
for (int i = 0; i < maxc; i++)
if (a[k][i] && temp[root][i]) total += countSame(a[k][i], temp[root][i]);
return total;
}
void dfs(int k, int d) {
size[k] = 1;
int argmx = -1;
for (int i = 0; i < maxc; i++)
if (a[k][i]) {
dfs(a[k][i], d + 1);
size[k] += size[a[k][i]];
if (argmx == -1 || size[a[k][i]] > size[a[k][argmx]]) argmx = i;
}
if (argmx != -1) {
m = 1;
for (int i = 0; i < maxc; i++) temp[0][i] = 0;
for (int i = 0; i < maxc; i++)
if (a[k][i] && i != argmx) {
merge(a[k][i], 0);
}
int count = countSame(a[k][argmx], 0);
res[d] += size[k] - (size[a[k][argmx]] + m - count);
}
}
int main() {
scanf("%d", &n);
memset(a, 0, sizeof a);
for (int i = 0; i < n; i++) {
int u, v;
char x;
scanf("%d %d %c", &u, &v, &x);
a[u][x - 'a'] = v;
}
memset(res, 0, sizeof res);
dfs(1, 1);
int ans = n, arg = 0;
for (int i = 1; i <= n; i++)
if (n - res[i] < ans) {
ans = n - res[i];
arg = i;
}
printf("%d\n%d\n", ans, arg);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, t, it, a[1005000], fa[10005000];
bool op[10050000];
struct SB {
int id, x, y;
bool operator<(const SB a) const { return (x == a.x) ? y < a.y : x < a.x; }
};
vector<SB> v1, v2;
void add(int x, int y, int z, int b) {
fa[++it] = x;
op[it] = b;
v2.push_back({it, y, z});
}
int main() {
ios::sync_with_stdio(0);
cin >> t;
while (t--) {
cin >> n;
it = 0;
for (i = 1; i <= n; i++) cin >> a[i];
v1.push_back({0, -11451419, -11451419});
for (i = 1; i <= n; i++) {
v2.clear();
for (auto &[id, x, y] : v1) {
if (x < -a[i])
add(id, -a[i], y, 1);
else if (y < -a[i])
add(id, x, -a[i], 1);
if (x < a[i])
add(id, a[i], y, 0);
else if (y < a[i])
add(id, x, a[i], 0);
}
if (v2.empty()) {
cout << "NO\n";
goto ccc;
}
v1.clear();
k = 1e9;
sort(v2.begin(), v2.end());
for (auto &i : v2) {
if (i.y < k) {
k = i.y;
v1.push_back(i);
}
}
}
i = (*v1.begin()).id;
j = n;
while (i) {
if (op[i]) a[j] *= -1;
j--;
i = fa[i];
}
cout << "YES\n";
for (i = 1; i <= n; i++) cout << a[i] << ' ';
cout << '\n';
ccc:;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int t;
long n;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%ld", &n);
if (n == 1)
printf("-1\n");
else {
for (int i = 1; i < n - 1; ++i) printf("2");
if (n % 3 == 1)
printf("43\n");
else
printf("23\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200005], d[200005], s[201][200001];
vector<int> p[201];
void query() {
int n;
cin >> n;
int res = 1;
for (int u = 1; u <= 200; ++u) d[u] = 0, p[u].clear(), p[u].push_back(0);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
++d[a[i]];
p[a[i]].push_back(i);
for (int u = 1; u <= 200; ++u) {
s[u][i] = s[u][i - 1];
}
++s[a[i]][i];
}
for (int u = 1; u <= 200; ++u) {
int k = (d[u]) / 2;
for (int i = k; i > 0; --i) {
int r = p[u][d[u] - i + 1] - 1, l = p[u][i];
for (int v = 1; v <= 200; ++v) {
res = max(res, i * 2 + s[v][r] - s[v][l]);
}
}
}
cout << res << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
query();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, prvs, res, crrnt;
void solve() {
cin >> t;
while (t--) {
cin >> n;
prvs = 0;
res = 0;
for (int i = 60; i >= 0; i--) {
crrnt = n / (1ll << i);
res += (crrnt - prvs) * (i + 1);
prvs = crrnt;
}
cout << res << "\n";
}
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b);
long long int lcm(long long int a, long long int b);
long long int modularExponentiation(long long int x, long long int n,
long long int M);
void dsp(vector<long long int> &V);
void dsp2(vector<pair<long long int, long long int>> &V);
void dsp3(map<long long int, long long int> &M);
double fact(double n);
long long int nPr(long long int n, long long int r);
long long int nCr(long long int n, long long int r);
void solve() {
long long int a, b, c;
cin >> a >> b >> c;
long long int ans = INT64_MAX;
long long int A, B, C;
A = B = C = -1;
long long int aA, bB, cC;
for (aA = 1; aA <= 2 * a; aA++)
for (bB = aA; bB <= 2 * b; bB += aA) {
for (long long int k = 0; k <= 1; k++) {
cC = (c / bB) * bB + (k)*bB;
long long int res = abs(a - aA) + abs(b - bB) + abs(c - cC);
if (ans > res) {
ans = res;
A = aA;
B = bB;
C = cC;
}
}
}
cout << ans << "\n" << A << " " << B << " " << C << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int TC;
cin >> TC;
while (TC--) solve();
return 0;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int modularExponentiation(long long int x, long long int n,
long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
void dsp(vector<long long int> &V) {
unsigned long long int j;
for (j = 0; j < V.size(); j++) {
cout << V[j] << " ";
}
cout << endl;
}
void dsp2(vector<pair<long long int, long long int>> &V) {
unsigned long long int j;
for (j = 0; j < V.size(); j++) {
cout << V[j].first << " " << V[j].second << " ";
}
cout << endl;
}
void dsp3(map<long long int, long long int> &M) {
map<long long int, long long int>::iterator it = M.begin();
while (it != M.end()) {
cout << it->first << " " << it->second << endl;
it++;
}
}
double fact(double n) {
double i = 1;
double res = 1;
if (n == 0) return 1.00;
while (i <= n) {
res *= i;
i++;
}
return res;
}
long long int nPr(long long int n, long long int r) {
return (fact(n) / fact(n - r));
}
long long int nCr(long long int n, long long int r) {
return (fact(n) / (fact(r) * fact(n - r)));
}
| 6 |
#include <bits/stdc++.h>
int tab[505][505];
int main() {
int n, k, i, max, min, i2, ans = 0;
scanf("%d %d", &n, &k);
max = n * n;
min = 1;
for (i = 1; i <= n; i++) {
for (i2 = 1; i2 < k; i2++) {
tab[i][i2] = min++;
}
}
for (i = n; i >= 1; i--) {
for (i2 = n; i2 >= k; i2--) {
tab[i][i2] = max--;
}
}
for (i = 1; i <= n; i++) ans += tab[i][k];
printf("%d\n", ans);
for (i = 1; i <= n; i++) {
for (i2 = 1; i2 <= n; i2++) {
printf("%d ", tab[i][i2]);
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int Count[75];
long long sum;
int main() {
string x;
cin >> x;
for (int i = 0; i < x.size(); i++) Count[x[i] - '0']++;
for (int i = 0; i < 75; i++) sum += (long long)Count[i] * Count[i];
cout << sum << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {}
void read() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> ans;
ans.clear();
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'B')
cnt++;
else {
if (cnt != 0) ans.push_back(cnt);
cnt = 0;
}
}
if (cnt != 0) ans.push_back(cnt);
cout << int((ans).size()) << endl;
for (int i = 0; i < int((ans).size()); i++) cout << ans[i] << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
read();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int T[200010];
long long d[200010], g[200010], y[200010], dp[101][200010], s[200010];
template <class free>
inline void read(free&);
int main() {
int n, m, p, A, B;
read(n), read(m), read(p);
for (int i(2); i <= n; ++i) read(d[i]), d[i] += d[i - 1];
for (int i(1), j, k; i <= m; ++i) read(j), read(k), g[i] = k - d[j];
sort(g + 1, g + m + 1);
for (int i(1); i <= m; ++i) s[i] = s[i - 1] + g[i];
memset(dp, 1, sizeof(dp)), dp[0][0] = 0;
for (int i(1), j; i <= p; ++i)
for (A = B = j = 1; j <= m; ++j) {
while (A < B && g[j] * (T[A + 1] - T[A]) >= y[T[A + 1]] - y[T[A]]) ++A;
dp[i][j] = dp[i - 1][T[A]] + (j - T[A]) * g[j] - (s[j] - s[T[A]]),
y[j] = dp[i - 1][j] + s[j];
while (A < B && (y[T[B]] - y[T[B - 1]]) * (j - T[B]) >=
(y[j] - y[T[B]]) * (T[B] - T[B - 1]))
--B;
T[++B] = j;
}
printf("%lld", dp[p][m]);
return 0;
}
template <class free>
inline void read(free& x) {
x &= 0;
register char c;
while (c = getchar(), c < '0' || c > '9')
;
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long k) {
for (long long i = 2; i <= sqrt(k); i++)
if (k % i == 0) return false;
return true;
}
long long bm(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long t = bm(a, b / 2, mod);
t = t * t % mod;
return (b % 2 == 1 ? t * a % mod : t);
}
long long inv(long long a, long long mod) { return bm(a, mod - 2, mod); }
void gay(long long TC) { cout << "Case #" << TC << ": "; }
void solve(long long TC) {
string s;
cin >> s;
long long n = s.length();
if (n % 2) {
cout << "NO\n";
return;
}
if (s.substr(0, n / 2) != s.substr(n / 2, n / 2)) {
cout << "NO\n";
} else
cout << "YES\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
for (long long i = 1; i <= t; i++) solve(i);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, sm = 0, SM = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
sm += x;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
SM += x;
}
if (sm < SM)
cout << "No";
else
cout << "Yes";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, coun = 0, s = 0;
cin >> n;
int a[n][n], p[n];
for (int k = 0; k < n; k++) {
p[k] = s;
s++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> a[i][j];
if (i != j) {
if (a[i][j] == 1)
p[i] = -1;
else if (a[i][j] == 2)
p[j] = -1;
else if (a[i][j] == 3) {
p[i] = -1;
p[j] = -1;
}
}
}
for (int k = 0; k < n; k++) {
if (p[k] != -1) coun++;
}
cout << coun << endl;
for (int k = 0; k < n; k++) {
if (p[k] != -1) cout << p[k] + 1 << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 533333, _N = 107, _M = 207, _T = 20007 << 1;
const double pi = acos(-1.00), dinf = 1e99;
struct cxk {
double r, i;
cxk(double r_ = 0, double i_ = 0) { r = r_, i = i_; }
inline friend cxk operator+(cxk a, cxk b) {
return cxk(a.r + b.r, a.i + b.i);
}
inline friend cxk operator-(cxk a, cxk b) {
return cxk(a.r - b.r, a.i - b.i);
}
inline friend cxk operator*(cxk a, cxk b) {
return cxk(a.r * b.r - a.i * b.i, a.r * b.i + a.i * b.r);
}
inline friend cxk operator/(cxk a, double b) { return cxk(a.r / b, a.i / b); }
};
int rev[_];
int fftmake(int n) {
int nn = 1, lg = 0;
while (nn <= n) nn <<= 1, lg++;
rev[0] = 0;
for (int i = 1; i < nn; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (lg - 1));
return nn;
}
void fft(cxk a[], int nn, int dir) {
for (int i = 0; i < nn; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int i = 1; i < nn; i <<= 1) {
cxk g = cxk(cos(pi / i), dir * sin(pi / i));
for (int j = 0; j < nn; j += i + i) {
cxk ig = cxk(1, 0), x, y;
for (int k = 0; k < i; k++, ig = ig * g)
x = a[j + k], y = ig * a[j + k + i], a[j + k] = x + y,
a[j + k + i] = x - y;
}
}
if (dir < 0)
for (int i = 0; i < nn; i++) a[i] = a[i] / nn;
}
int n, m, tim, tt, per;
int ea[_M], eb[_M], ev[_M];
double gai[_M][_T], dis[_N][_N];
double f[_N][_T], g[_N][_T];
void install(int l, int r) {
int mid = (l + r) >> 1;
for (int i = 1; i <= m; i++) {
static cxk pa[_], pb[_];
int nn = fftmake(r - l + r - mid - 1);
for (int j = 0; j < nn; j++) pa[j] = pb[j] = cxk(0, 0);
for (int j = mid + 1; j <= r; j++) pa[j - mid - 1] = cxk(f[eb[i]][j], 0);
for (int j = 1; j <= r - l; j++) pb[r - l - j] = cxk(gai[i][j], 0);
fft(pa, nn, 1), fft(pb, nn, 1);
for (int j = 0; j < nn; j++) pa[j] = pa[j] * pb[j];
fft(pa, nn, -1);
for (int j = l; j <= mid; j++) g[i][j] += pa[r - l + j - mid - 1].r;
}
}
void dfs(int l, int r) {
if (l == r) {
for (int i = 1; i <= m; i++)
f[ea[i]][l] = min(f[ea[i]][l], g[i][l] + ev[i]);
return;
}
int mid = (l + r) >> 1;
dfs(mid + 1, r), install(l, r), dfs(l, mid);
}
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), m = ty(), tim = ty(), per = ty();
tt = tim << 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dis[i][j] = i == j ? 0 : dinf;
for (int i = 1, a, b, c; i <= m; i++) {
a = ty(), b = ty(), c = ty();
ea[i] = a, eb[i] = b, ev[i] = c;
dis[a][b] = min(dis[a][b], c);
for (int j = 1; j <= tim; j++) gai[i][j] = ty() / 100000.00;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
for (int i = 0; i <= tt; i++) f[n][i] = i > tim ? per : 0;
for (int i = 1; i < n; i++)
for (int j = 0; j <= tt; j++) f[i][j] = j > tim ? (dis[i][n] + per) : dinf;
install(1, tt), dfs(0, tim);
cout << setprecision(12) << fixed << f[1][0] << lf;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = t - 2; i >= 0; i--) {
if (i % 3 != 0) {
for (int j = 1; j < t - i; j++) {
if (j % 3 != 0) {
cout << i << " " << j << " " << t - i - j;
return 0;
}
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long p, q, n;
long long a[99], m[99];
long long kk = 0;
void sol(long long a, long long b) {
if (a == 0 || b == 0) return;
long long q = a / b;
m[kk++] = q;
a -= b * q;
sol(b, a);
}
int main() {
scanf("%I64d%I64d", &p, &q);
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
sol(p, q);
if (n > 1 && a[n - 1] == 1) {
a[n - 2]++;
n--;
}
bool ans = true;
if (kk != n)
ans = false;
else {
for (int i = 0; i < int(kk); ++i) ans = ans && (m[i] == a[i]);
}
if (ans)
puts("YES");
else
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000000;
char data[10][10];
int rr[10];
int n, k;
int change(char *s, int *re) {
int i;
int res = 0;
for (i = 0; i < k; i++) {
res *= 10;
res += s[re[i]] - '0';
}
return res;
}
int solve() {
int i;
for (i = 0; i < k; i++) rr[i] = i;
int ans = oo;
do {
int maxx = -1;
int mini = oo;
for (i = 0; i < n; i++) {
maxx = max(maxx, change(data[i], rr));
mini = min(mini, change(data[i], rr));
}
ans = min(ans, maxx - mini);
} while (next_permutation(rr, rr + k));
return ans;
}
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
int i;
for (i = 0; i < n; i++) scanf("%s", data[i]);
int ans = solve();
printf("%d\n", ans);
}
}
| 3 |
#include <bits/stdc++.h>
long long ar[700000][3], err[1000007];
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, a, sum = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a;
sum += a - 1;
if (sum % 2 == 0) {
cout << 2 << endl;
} else {
cout << 1 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<int, int> mp;
int n;
scanf("%d", &n);
int b, i, index = 0, j;
for (i = 1; i <= n; i++) {
scanf("%d", &b);
mp[b] = i;
}
for (i = 0; i < n; i++) {
scanf("%d", &b);
int tmp = mp[b];
if (tmp - index > 0) {
printf("%d ", tmp - index);
index = tmp;
} else
printf("0 ");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, s;
cin >> n >> s;
long long int min = INT_MAX;
unsigned long long int sum = 0;
long long int i;
long long int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
if (arr[i] < min) min = arr[i];
}
if (sum < s) {
cout << "-1";
return 0;
}
if (sum == s) {
cout << "0";
return 0;
}
long long int count = 0;
for (i = 0; i < n; i++) {
if (arr[i] > min) count++;
}
for (i = 0; i < n; i++) {
if (count <= 0) break;
if (arr[i] > min) {
count -= 1;
if (s - (arr[i] - min) <= 0) {
cout << min;
return 0;
}
s = s - (arr[i] - min);
arr[i] = min;
}
}
while (s != 0 && min >= 0) {
if (s - (n) <= 0) {
cout << (min - 1);
return 0;
} else {
min--;
s = s - n;
}
}
cout << "-1";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int A[500 + 9];
int n, m, b, mod;
int dp[2][500 + 9 + 2][500 + 9 + 1];
int build() {
int p = 0;
for (int c = 0; c <= b; c++) dp[p][0][c] = dp[!p][0][c] = 1;
for (int c = 0; c <= b; c++)
for (int r = 1; r <= m; r++) dp[p][r][c] = 0;
for (int i = n - 1; i >= 0; i--) {
p = !p;
for (int r = 1; r <= m; r++)
for (int c = b; c >= 0; c--)
if (A[i] + c <= b)
dp[p][r][c] = (dp[!p][r][c] + dp[p][r - 1][c + A[i]]) % mod;
else
dp[p][r][c] = dp[!p][r][c];
}
return dp[p][m][0];
}
int main() {
read_file(false);
while (cin >> n >> m >> b >> mod) {
for (int i = 0; i < n; i++) cin >> A[i];
cout << build() << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int>> v(n);
for (int i = 0; i != n; i++) {
cin >> v[i].second >> v[i].first;
}
sort(v.begin(), v.end());
long long sum = 0;
long long res = 0;
multiset<int> s;
for (int i = n - 1; i != -1; i--) {
s.insert(v[i].second);
sum += v[i].second;
if (s.size() > k) {
auto it = s.begin();
sum -= *it;
s.erase(it);
}
res = max(res, v[i].first * sum);
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
int a[500001], b[500001];
vector<int> E[500001];
int f[500001];
int cnt[500001];
long long ans = 0;
void add(int x, int d) {
++x;
for (; x <= n + 1; x += (x & -x)) f[x] += d;
}
int query(int x) {
int sum = 0;
++x;
for (; x; x -= (x & -x)) sum += f[x];
return sum;
}
int main() {
int x, y;
scanf("%d %d", &n, &p);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x, &y);
E[x].push_back(i);
E[y].push_back(i);
cnt[x]++;
cnt[y]++;
a[i] = x;
b[i] = y;
}
for (int i = 1; i <= n; i++) add(cnt[i], 1);
for (int i = 1; i <= n; i++) {
int cur = ans;
int now = (int)E[i].size();
for (int j = 0; j < (int)E[i].size(); j++) {
int idx = E[i][j];
add(cnt[a[idx]], -1);
add(cnt[b[idx]], -1);
cnt[a[idx]]--;
cnt[b[idx]]--;
add(cnt[a[idx]], 1);
add(cnt[b[idx]], 1);
}
ans += n - query(max(p - now - 1, -1));
if (now >= p) --ans;
for (int j = 0; j < (int)E[i].size(); j++) {
int idx = E[i][j];
add(cnt[a[idx]], -1);
add(cnt[b[idx]], -1);
cnt[a[idx]]++;
cnt[b[idx]]++;
add(cnt[a[idx]], 1);
add(cnt[b[idx]], 1);
}
}
printf("%lld\n", ans / 2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
double k, d, t;
int main() {
scanf("%lf%lf%lf", &k, &d, &t);
double ti = (long long)((k - 1) / d) + 1;
double p = ti * d;
double ans = 0;
double tim = (long long)(2 * t / (p + k));
ans += tim * p;
double rest = 2 * t - (p + k) * tim;
if (rest < 2 * k)
ans += rest / 2;
else
ans += k, ans += rest - 2 * k;
printf("%.10f", ans);
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define endl "\n"
const ll M = (ll)1e9 + 7;
void solve() {
ll n; cin>>n;
int fg=0;
while(n--){
ll x; cin>>x;
ll z= sqrt(x);
if(x!=z*z ) { fg=1; }
}
fg==1?cout<<"YES":cout<<"NO";
cout<<endl;
}
int main() {
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
ll T=1;
cin>>T;
while(T--){
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T inline Abs(const T& x) {
return x < 0 ? -x : x;
}
template <class T>
T inline Sqr(const T& x) {
return x * x;
}
long long mod = 1000000000 + 7;
inline long long Sum(long long a, long long b) { return (a + b + mod) % mod; }
inline long long Mul(long long a, long long b) { return (a * b) % mod; }
const int maxn = 2010;
long long a[maxn][maxn];
long long b[maxn][maxn];
int main(int argc, char* argv[]) {
long long n, m;
cin >> n >> m;
for (int k = 2; k <= m + 1; ++k) {
for (int l = 1; l <= n + 1; ++l) {
if (k > 2) {
a[k][l] = Sum(a[k - 1][l], b[k][l - 1]);
} else {
a[k][l] = Sum(1, a[k][l - 1]);
}
b[k][l] = b[k - 1][l] + a[k][l];
}
}
long long ans = 0;
for (int u = 1; u <= n; ++u) {
int d = n - u;
for (int k = 2; k <= m; ++k) {
ans = Sum(ans, Mul(m - k + 1, a[k][u]));
if (u < n) {
ans = Sum(ans,
Mul(m - k + 1, Mul(a[k][u], Sum(a[k][d + 1], -a[k][d] - 1))));
}
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], st;
long long s[200005], ans;
map<long long, int> cnt, pos;
vector<pair<int, int> > eli;
int main() {
cin >> n;
pos[0] = 1;
st = 1;
ans = n * 1LL * (n + 1) / 2;
for (int i = 2; i <= n + 1; i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
eli.push_back(pair<int, int>(pos[s[i]] + 1, i));
pos[s[i]] = i;
}
for (int i = 0; i < eli.size(); i++) {
int l = eli[i].first;
int r = eli[i].second;
if (i == 0)
ans -= (l - 1) * 1LL * (n + 2 - r);
else {
if (l < st)
continue;
else
ans -= (l - st + 1) * 1LL * (n + 2 - r);
}
st = max(st, l + 1);
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 203;
int n, k, cost[maxn], dis[maxn][maxn], e[maxn][maxn], pos[maxn], ans[maxn],
f[maxn][maxn];
void dfs(int u, int pre) {
for (int i = 1; i <= n; ++i) f[i][u] = cost[dis[i][u]] + k;
for (int i = 1; i <= n; ++i) {
if (e[u][i] && i != pre) {
dfs(i, u);
for (int j = 1; j <= n; ++j) f[j][u] += min(f[pos[i]][i], f[j][i] - k);
}
}
pos[u] = 1;
for (int i = 1; i <= n; ++i)
if (f[i][u] < f[pos[u]][u]) pos[u] = i;
}
void getans(int u, int pre, int lastpos) {
for (int i = 1; i <= n; ++i) {
if (e[u][i] && i != pre) {
if (f[pos[i]][i] > f[lastpos][i] - k)
ans[i] = lastpos;
else
ans[i] = pos[i];
getans(i, u, ans[i]);
}
}
}
int main() {
memset(dis, 0x3f, sizeof(dis));
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", &cost[i]);
for (int i = 1; i <= n; ++i) dis[i][i] = 0;
for (int i = 1; i < n; ++i) {
static int u, v;
scanf("%d%d", &u, &v);
e[u][v] = e[v][u] = 1;
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 0);
printf("%d\n", f[ans[1] = pos[1]][1]);
getans(1, 0, pos[1]);
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
scanf("%lld", &n);
printf("%lld\n", n / 2520);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, t = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * t;
}
const int N = 105;
const int P = 1e9 + 9;
vector<int> G[N], F;
int n, m, rt, C[N][N], inv[N];
int d[N], vis[N], sz[N], tp[N], dp[N][N], s[N];
int Mod(int x) { return x >= P ? x - P : x; }
void Link(int x, int y) {
d[x]++, d[y]++;
G[x].push_back(y), G[y].push_back(x);
}
void Pre(int n) {
for (int i = 0; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = Mod(C[i - 1][j - 1] + C[i - 1][j]);
}
inv[0] = inv[1] = 1;
for (int i = 2; i <= n; i++) inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
}
void Topsort() {
queue<int> q;
for (int i = 1; i <= n; i++)
if (d[i] <= 1) q.push(i), vis[i] = 1;
while (q.size()) {
int x = q.front();
q.pop();
for (auto y : G[x])
if (!vis[y] && (--d[y]) <= 1) vis[y] = 1, q.push(y);
}
}
void Find_rt(int x, int f) {
F.push_back(x), vis[x] = 2;
for (auto y : G[x])
if (y ^ f) {
if (!vis[y])
rt = x;
else
Find_rt(y, x);
}
}
void Mul(int x, int y) {
for (int i = 0; i <= sz[x] + sz[y]; i++) tp[i] = 0;
for (int i = 0; i <= sz[x]; i++)
for (int j = 0; j <= sz[y]; j++)
tp[i + j] =
Mod(tp[i + j] + 1ll * dp[x][i] * dp[y][j] % P * C[i + j][i] % P);
for (int i = 0; i <= sz[x] + sz[y]; i++) dp[x][i] = tp[i];
sz[x] += sz[y];
}
void DFS(int x, int f) {
memset(dp[x], 0, sizeof(dp[x]));
sz[x] = 1, dp[x][0] = 1;
for (auto y : G[x])
if ((y ^ f) && vis[y]) DFS(y, x), Mul(x, y);
dp[x][sz[x]] = dp[x][sz[x] - 1];
}
int main() {
n = read(), m = read(), Pre(n);
for (int i = 1; i <= m; i++) Link(read(), read());
Topsort(), dp[0][0] = 1;
for (int i = 1; i <= n; i++)
if (vis[i] == 1) {
rt = -1, F.clear(), Find_rt(i, 0);
if (~rt)
DFS(rt, 0), Mul(0, rt);
else {
m = F.size();
memset(s, 0, sizeof(s));
for (auto t : F) {
DFS(t, 0);
for (int j = 0; j <= m; j++) s[j] = Mod(s[j] + dp[t][j]);
}
for (int j = 0; j <= m; j++) s[j] = 1ll * s[j] * inv[m - j] % P;
memcpy(dp[F[m - 1]], s, sizeof(s)), Mul(0, F[m - 1]);
}
}
for (int i = 0; i <= n; i++) printf("%d\n", dp[0][i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
char ch;
for (int i = s.size() - 1; i >= 0; i--) {
if ((s[i] >= 97 && s[i] <= 122) || (s[i] >= 65 && s[i] <= 90)) {
ch = s[i];
break;
}
}
if (ch == 'y' || ch == 'Y' || ch == 'a' || ch == 'A' || ch == 'e' ||
ch == 'E' || ch == 'I' || ch == 'i' || ch == 'o' || ch == 'O' ||
ch == 'u' || ch == 'U')
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void prnt(vector<long long int> a) {
long long int n = a.size();
for (long long int i = 0; i < n; i++) {
long long int val = 0;
for (long long int j = 0; j <= i; j++) val += a[j];
cout << val << " ";
a[i] = val;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int q;
cin >> q;
while (q--) {
long long int a, b, m;
cin >> a >> b >> m;
if (a == b) {
cout << 1 << " " << a << '\n';
} else {
for (long long int i = 0; i <= 48; i++) {
long long int x = 1LL << i;
long long int p = b / x, q = p;
if (b % x) q++;
if (p >= (a + 1) && q <= (a + m)) {
long long int k = b - a * x - x;
vector<long long int> ans;
ans.push_back(a);
for (long long int j = 1; j < i + 1; j++) {
x /= 2;
long long int y = k / x;
if (y >= m) y = m - 1;
ans.push_back(y + 1);
k -= x * y;
}
ans.push_back(k + 1);
cout << i + 2 << " ";
prnt(ans);
cout << '\n';
goto ab;
}
}
cout << -1 << '\n';
ab:
long long int dum;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int INF = 1e9 + 7;
int f(long long x) {
if (!x) return 0;
if (x == 1 || x == -1) return 1;
long long z = 1, k = 1, t = x;
while (z * 10 + 1 < x) {
z = z * 10 + 1;
k++;
t /= 10;
}
int res = 1e9;
res = min(1LL * res, k * t + f(abs(x - z * t)));
if (t > 1) res = min(1LL * res, k * (t - 1) + f(abs(x - z * (t - 1))));
long long zn = abs(x - (z * 10 + 1));
if (zn < x) res = min(1LL * res, k + 1 + f(zn));
return res;
}
int main() {
ios_base::sync_with_stdio(0);
long long n;
cin >> n;
cout << f(n);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int moder = (int)1e9 + 7;
int length;
int max_val[2005][2005][2], mark[2005][2005][2];
int cal(int pos, int remain, int ok) {
if (remain < 0) return -(int)1e9;
if (pos == length + 1) {
if (remain > 0) return -(int)1e9;
return 0;
}
if (mark[pos][remain][ok]) return max_val[pos][remain][ok];
mark[pos][remain][ok] = 1;
int one_one = cal(pos + 1, remain + 1, 1);
int one_zero = cal(pos + 1, remain + 1, 0);
int zero_one = cal(pos + 1, remain - 1, 1);
int zero_zero = cal(pos + 1, remain - 1, 0);
if (ok) {
int now = max(one_zero, zero_zero);
now = max({now, one_one + zero_zero, one_zero + zero_one});
max_val[pos][remain][ok] = now + 1;
} else {
int now = max({one_one, zero_one, one_one + zero_one});
max_val[pos][remain][ok] = now;
}
max_val[pos][remain][ok] %= moder;
return max_val[pos][remain][ok];
}
void solve() { printf("%d", cal(1, 0, 1)); }
int main() {
scanf("%d", &length);
length *= 2;
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, inf = 1e9;
int T, n, p[N], dp[N][2][2], a[N];
pair<int, int> pre[N][2][2];
void print() {
for (int pos = 0; pos < 2; pos++)
for (int sg = 0; sg < 2; sg++)
if (dp[n][pos][sg] != inf) {
printf("YES\n");
for (int j = n; j >= 1; j--) {
a[j] = sg ? p[j] : -p[j];
auto pr = pre[j][pos][sg];
pos = pr.first, sg = pr.second;
}
for (int j = 1; j <= n; j++) printf("%d ", a[j]);
printf("\n");
return;
}
printf("NO\n");
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++)
for (int pos = 0; pos < 2; pos++)
for (int sg = 0; sg < 2; sg++) dp[i][pos][sg] = inf;
dp[1][0][0] = -inf, dp[1][0][1] = -inf;
for (int i = 1; i < n; i++)
for (int pos = 0; pos < 2; pos++)
for (int sg = 0; sg < 2; sg++)
if (dp[i][pos][sg] != inf) {
for (int sig = 0; sig < 2; sig++) {
int z = sig ? p[i + 1] : -p[i + 1], x, y;
if (!pos)
x = sg ? p[i] : -p[i], y = dp[i][pos][sg];
else
x = dp[i][pos][sg], y = sg ? p[i] : -p[i];
if (y < z && z < x) {
if (x < dp[i + 1][1][sig]) {
dp[i + 1][1][sig] = x;
pre[i + 1][1][sig] = {pos, sg};
}
} else if (z > x) {
if (y < dp[i + 1][0][sig]) {
dp[i + 1][0][sig] = min(dp[i + 1][0][sig], y);
pre[i + 1][0][sig] = {pos, sg};
}
}
}
}
print();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[100009];
int t[100009][26], tot;
int flag[100009], d[100009];
void add() {
int len = strlen(s), k = 0;
for (int i = 0; i < len; i++) {
if (!t[k][s[i] - 'a']) t[k][s[i] - 'a'] = ++tot;
k = t[k][s[i] - 'a'], d[k] = i + 1;
}
flag[k] = 1;
}
priority_queue<int> q[100009];
void dfs(int u) {
for (int i = 0; i < 26; i++) {
if (!t[u][i]) continue;
int v = t[u][i];
dfs(v);
while (!q[v].empty()) {
q[u].push(q[v].top());
q[v].pop();
}
}
if (flag[u]) q[u].push(d[u]);
if (!flag[u] && !q[u].empty()) {
int v = q[u].top();
q[u].pop();
q[u].push(d[u]);
}
}
int main() {
memset(flag, 0, sizeof(flag));
memset(t, 0, sizeof(t));
scanf("%d", &n);
tot = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", s);
add();
}
flag[0] = 1;
dfs(0);
long long ans = 0;
while (!q[0].empty()) {
ans += q[0].top();
q[0].pop();
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e6 + 1;
const int N = 3e5 + 1;
const int P = 1e5 + 1;
int arr[N];
int one[N];
int lp[M];
int p[P];
int cur;
int n, q;
long long bit[N];
pair<int, int> d[M];
struct Dsu {
int par[N];
int cnt[N];
int nxt[N];
} dsu;
void update(int i, int key) {
for (; i < N; i += (i & -i)) bit[i] += key;
}
long long query(int i) {
long long res = 0;
for (; i; i -= (i & -i)) res += bit[i];
return res;
}
void sieve() {
for (int i = 2; i < M; ++i) {
if (!lp[i]) {
lp[i] = p[cur++] = i;
d[i] = {1, 2};
}
for (int j = 0; j < cur && p[j] <= lp[i] && i * p[j] < M; ++j) {
lp[i * p[j]] = p[j];
if (lp[i] == p[j]) {
d[i * p[j]] = {d[i].first, d[i].second + 1};
} else {
d[i * p[j]] = {d[i].first * d[i].second, 2};
}
}
}
}
int findset(int u) {
return (dsu.par[u] == u ? u : dsu.par[u] = findset(dsu.par[u]));
}
void unite(int u, int v) {
u = findset(u);
v = findset(v);
if (u == v) return;
if (dsu.cnt[u] < dsu.cnt[v]) {
swap(u, v);
}
dsu.nxt[u] = max(dsu.nxt[u], dsu.nxt[v]);
dsu.cnt[u] += dsu.cnt[v];
dsu.par[v] = u;
}
void make_set(int u) {
dsu.par[u] = u;
dsu.nxt[u] = u;
dsu.cnt[u] = 1;
}
long long query(int l, int r) {
return query(r) - query(l - 1) - (one[r] - one[l - 1]);
}
void replace(int l, int r) {
for (int i = dsu.nxt[findset(l)]; i <= r; i = dsu.nxt[findset(i)] + 1) {
update(i, d[arr[i]].first * d[arr[i]].second - arr[i]);
arr[i] = d[arr[i]].first * d[arr[i]].second;
if (arr[i] == 2) {
if (arr[i - 1] == 2) {
unite(i, i - 1);
}
if (arr[i + 1] == 2) {
unite(i, i + 1);
}
}
}
}
void input() {
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
make_set(i);
cin >> arr[i];
one[i] = one[i - 1];
if (arr[i] == 1) {
arr[i] = 2;
one[i]++;
}
update(i, arr[i]);
}
make_set(n + 1);
}
void solve() {
for (int i = 0; i < q; ++i) {
int t;
cin >> t;
int l;
cin >> l;
int r;
cin >> r;
if (t == 1) {
replace(l, r);
} else {
cout << query(l, r) << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
sieve();
input();
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long bit[200005];
void add(long long idx, long long val) {
for (int i = idx; i < 200005; i += (i & (-i))) {
bit[i] += val;
}
}
long long query(long long i) {
long long ans = 0;
for (; i > 0; i -= (i & (-i))) ans += bit[i];
return ans;
}
long long b[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, j, k, m;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
set<long long> s, s1;
unordered_map<long long, long long> mp;
long long sm = 0;
long long sum[n + 5];
for (i = 1; i <= n; i++) {
sm += i;
mp[sm] = i;
s.insert(i);
s1.insert(sm);
sum[i] = sm;
}
for (i = 1; i <= n; i++) {
add(i, i);
}
for (i = n - 1; i >= 0; i--) {
long long f = 1, l = n;
long long mid;
long long anss = 0;
while (f <= l) {
mid = (f + l) / 2;
if (query(mid) > a[i]) {
l = mid - 1;
} else {
f = mid + 1;
anss = mid;
}
}
anss++;
b[i] = anss;
add(anss, -anss);
}
for (i = 0; i < n; i++) cout << b[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cnts = 0, cnth = 0;
scanf("%d\n", &n);
while (n--) {
char s[10000], s2[10000];
scanf("%s%s", s, s2);
if (s2[0] == 'h') {
cnth++;
} else if (s2[0] == 's') {
cnts++;
}
}
int ans = max(cnth, cnts), tmp = 0, cnt = 1, cou = 0, ttmp = 0;
while (1) {
tmp += cnt;
ttmp++;
cou++;
if (ttmp == 2) {
cnt += 2;
ttmp = 0;
}
if (tmp >= ans) break;
}
int ans2 = min(cnth, cnts), cou2 = 1;
tmp = 0, cnt = 2, ttmp = 0;
while (ans2 > 0) {
tmp += cnt;
ttmp++;
cou2++;
if (ttmp == 2) {
cnt += 2;
ttmp = 0;
}
if (tmp >= ans2) break;
}
printf("%d\n", max(cou, cou2));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> pre;
void precompute(const string& pat) {
int m = ((int)(pat).size()), p = -1;
pre = vector<int>(m + 1);
pre[0] = -1;
for (int i = (int)(1); i < ((int)m + 1); i++) {
while (p != -1 && pat[p] != pat[i - 1]) p = pre[p];
p++;
pre[i] = p;
}
}
const int MOD = 1e9 + 7;
const int MAXN = 1e6 + 100;
int n;
string p;
vector<int> match;
bool good[MAXN];
int main() {
ios_base::sync_with_stdio(false);
int m;
cin >> n >> m;
cin >> p;
precompute(p);
for (int _ = 0; _ < (int)(m); _++) {
int x;
cin >> x;
match.push_back(x);
}
int suf = ((int)(p).size());
while (suf != -1) {
suf = pre[suf];
good[suf] = true;
}
bool great = true;
for (int i = 0; i < (int)(((int)(match).size()) - 1); i++) {
int overlap = ((int)(p).size()) - match[i + 1] + match[i];
if (overlap > 0 && !good[overlap]) great = false;
if (!great) break;
}
if (!great)
cout << 0 << endl;
else {
int empty = n, last = -1e9;
for (int m : match) {
int add = ((int)(p).size());
if (last + ((int)(p).size()) > m) add -= (last + ((int)(p).size())) - m;
empty -= add;
last = m;
}
long long int res = 1;
for (int _ = 0; _ < (int)(empty); _++) res = (res * 26) % MOD;
cout << res << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long S, Z, s1, s2, s3, s4, s5, s6, x, y, z, n, m, i, j, l, k, t;
float a[200001];
long long b[200001];
long long c[200001];
long long d[200001];
long long e[200001];
long long f[200001];
string s;
string q;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
x = a[i];
b[i] = x;
}
S = 0;
for (i = 1; i <= n; i++) {
S = S + b[i];
}
if (S == 0) {
for (i = 1; i <= n; i++) {
cout << b[i] << endl;
}
}
if (S < 0) {
x = 0 - S;
for (i = 1; i <= n; i++) {
if (b[i] >= 0 && x > 0 && a[i] * 100000 != b[i] * 100000 && a[i] > 0) {
cout << b[i] + 1 << endl;
x--;
} else
cout << b[i] << endl;
}
}
if (S > 0) {
x = S;
for (i = 1; i <= n; i++) {
if (b[i] <= 0 && x > 0 && a[i] * 100000 != b[i] * 100000 && a[i] < 0) {
cout << b[i] - 1 << endl;
x--;
} else
cout << b[i] << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Q = 1 << 19;
int las[Q], e[Q << 1], nn[Q << 1], inc = 1;
int del[Q], A[Q];
void ins(int x, int y) {
e[++inc] = y;
nn[inc] = las[x];
las[x] = inc;
}
int si[Q], iid, mn;
void Gra(int x, int last, int sizz) {
int mx = 0;
si[x] = 1;
for (int t = las[x]; t; t = nn[t]) {
int y = e[t];
if (y == last || del[y]) continue;
Gra(y, x, sizz);
si[x] += si[y];
mx = max(mx, si[y]);
}
mx = max(mx, sizz - si[x]);
if (mx < mn) mn = mx, iid = x;
}
int rgx, rgy;
vector<pair<long long, long long> > r1[Q], r2[Q], emp;
void dfs(int x, int last, int dep, long long s1, long long s2, long long s3) {
si[x] = 1;
s1 += 1ll * dep * A[x], ++dep, s2 += (s3 += A[x]);
r1[rgy].push_back(make_pair(s3 - A[rgx], s1));
r2[rgy].push_back(make_pair(dep, s2));
for (int t = las[x]; t; t = nn[t]) {
int y = e[t];
if (y == last || del[y]) continue;
dfs(y, x, dep, s1, s2, s3);
si[x] += si[y];
}
}
long long als = 0;
long long kk[Q], bb[Q];
void Upd(vector<pair<long long, long long> >& a) {
int tp = 0;
for (auto o : a) {
long long k1 = o.first, b1 = o.second;
while (tp && bb[tp] <= b1) --tp;
while (tp > 1) {
long long t1 = (bb[tp - 1] - bb[tp] + kk[tp] - kk[tp - 1] - 1) /
(kk[tp] - kk[tp - 1]);
long long t2 = (bb[tp] - b1) / (k1 - kk[tp]);
if (t1 > t2)
--tp;
else
break;
}
kk[++tp] = k1, bb[tp] = b1;
}
a.resize(tp);
for (int i = 0; i < tp; i++) a[i].first = kk[i + 1], a[i].second = bb[i + 1];
}
void Cal(vector<pair<long long, long long> >& a,
vector<pair<long long, long long> >& b) {
int p = 0, tp = a.size() - 1;
for (auto o : b) {
int x = o.first;
long long now = a[p].first * x + a[p].second, nxt;
while (p < tp && now < (nxt = a[p + 1].first * x + a[p + 1].second))
now = nxt, ++p;
als = max(als, now + o.second);
}
}
void Cle(vector<pair<long long, long long> >& a) { a.clear(), a.swap(emp); }
struct cer {
int id, num;
};
bool operator<(cer a, cer b) { return a.num > b.num; }
priority_queue<cer> q;
void Push(int y) { q.push((cer){y, (int)r1[y].size() + (int)r2[y].size()}); }
void Mg(vector<pair<long long, long long> >& a,
vector<pair<long long, long long> >& b) {
r1[0].resize(a.size() + b.size());
merge(a.begin(), a.end(), b.begin(), b.end(), r1[0].begin());
a.swap(r1[0]);
}
void DC(int x, int sizz) {
mn = 1e9, Gra(x, 0, sizz), x = iid, del[x] = 1;
Cle(r1[x]), Cle(r2[x]);
r2[x].push_back(make_pair(1, A[x]));
r1[x].push_back(make_pair(0, 0));
Push(x);
for (int t = las[x]; t; t = nn[t]) {
int y = e[t];
if (del[y]) continue;
Cle(r1[y]), Cle(r2[y]);
rgy = y, rgx = x;
dfs(y, x, 1, 0, A[x], A[x]);
sort(r1[y].begin(), r1[y].end());
sort(r2[y].begin(), r2[y].end());
Upd(r1[y]);
Push(y);
}
while (q.size() > 1) {
int p = q.top().id;
q.pop();
int o = q.top().id;
q.pop();
Cal(r1[o], r2[p]), Cal(r1[p], r2[o]);
Mg(r1[o], r1[p]);
Mg(r2[o], r2[p]);
Upd(r1[o]);
Push(o);
}
q.pop();
for (int t = las[x]; t; t = nn[t]) {
int y = e[t];
if (del[y]) continue;
DC(y, si[y]);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1, x, y; i < n; i++) scanf("%d%d", &x, &y), ins(x, y), ins(y, x);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]), als = max(als, 1ll * A[i]);
DC(1, n);
printf("%lld\n", als);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9L + 7;
vector<vector<long long> > operator*(const vector<vector<long long> > &a,
const vector<vector<long long> > &b) {
int r1 = a.size(), r2 = b.size(), c2 = b[0].size();
vector<vector<long long> > ret(r1, vector<long long>(c2));
for (int i = 0; i < r1; i++)
for (int j = 0; j < c2; j++)
for (int k = 0; k < r2; k++)
ret[i][j] += a[i][k] * b[k][j], ret[i][j] %= mod;
return ret;
}
vector<vector<long long> > operator^(const vector<vector<long long> > &a,
long long k) {
vector<vector<long long> > ret(a.size(), vector<long long>(a.size()));
for (int i = 0; i < a.size(); i++) ret[i][i] = 1;
for (vector<vector<long long> > tmp = a; k; tmp = tmp * tmp, k /= 2)
if (k & 1) ret = ret * tmp;
return ret;
}
void test() {
int n, b, k, x, tmp;
cin >> n >> b >> k >> x;
vector<vector<long long> > init(1, vector<long long>(x, 1));
map<int, int> mp;
for (int i = 0; i < n; i++) cin >> tmp, mp[tmp]++;
vector<vector<long long> > trans(x, vector<long long>(x));
for (auto ele : mp) {
for (int j = 0; j < x; j++) {
int nxt = (j * 10 + ele.first) % x;
trans[j][nxt] += ele.second;
}
}
trans = trans ^ b;
cout << trans[0][k] << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
int cas = 1;
test();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, i, x, y, a, b, c, temp;
cin >> t;
while (t--) {
c = 0;
cin >> a >> b;
x = max(a, b);
y = min(a, b);
while (x > 0 && y > 0) {
c += x / y;
temp = y;
y = (x % y);
x = temp;
}
cout << c << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
int n;
double a[500001], b[500001], p, q;
string st;
double calc(double y1) {
double y2 = 1.;
for (int i = 0; i < n; i++) {
y2 = min(y2, (1. - (a[i] * y1)) / b[i]);
}
double ret = p * y1 + q * y2;
return ret;
}
int main() {
cin >> n >> p >> q;
double maxi = 0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
maxi = max(a[i], maxi);
}
double l = 0, r = 1. / maxi;
for (int i = 0; i < 100; i++) {
double m1 = (fabs(l - r)) / 3;
double x1 = calc(l + m1), x2 = calc(r - m1);
if (x1 >= x2)
r = r - m1;
else
l = l + m1;
}
printf("%.10lf\n", calc(l));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, ts = 0, k = 0, arr[100];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
ts += arr[i];
}
sort(arr, arr + n);
for (int i = n - 1; i > 0; i--) {
sum += arr[i];
if (sum > ts - sum) {
k = i;
break;
}
}
cout << n - k << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
bool vis[300010];
int a[300010];
int ans = 1;
int main() {
scanf("%d", &n);
x = n;
printf("%d ", ans);
for (int i = 1; i < n; i++) {
scanf("%d", &a[i]);
vis[a[i]] = 1;
bool p = 0;
bool v = 0;
while (vis[x]) {
ans--;
x--;
}
ans++;
printf("%d ", ans);
}
printf("%d ", 1);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
vector<int> vec;
for (int i = 0; i < n; i++) {
cin >> a[i];
};
int l[n];
map<int, int> mpp;
for (int i = 0; i < n; i++) {
cin >> l[i];
if (l[i] == 0) {
mpp[i] = 0;
vec.push_back(a[i]);
} else {
mpp[i] = 1;
}
}
int j = 0;
sort(vec.rbegin(), vec.rend());
for (int i = 0; i < n; i++) {
if (mpp[i] == 0) {
cout << vec[j] << " ";
j++;
} else {
cout << a[i] << " ";
}
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
void qread(int &x) {
int neg = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = 10 * x + c - '0', c = getchar();
x *= neg;
}
const int maxn = 50005;
int n, k;
int pw[maxn], l[maxn][10], r[maxn][10], sz[maxn], head;
set<pair<int, int> > L[10], R[10];
int main() {
scanf("%d%d", &n, &k);
for (int(i) = 0; (i) < n; i++) {
int mn = 0x3f3f3f3f, mx = -0x3f3f3f3f, cl, cr;
for (int(j) = 0; (j) < k; j++) {
scanf("%d", &pw[j]);
set<pair<int, int> >::iterator it = R[j].lower_bound(make_pair(pw[j], i));
if (it != R[j].end())
if (l[(*it).second][0] < mn) mn = l[(*it).second][0], cl = (*it).second;
it = L[j].lower_bound(make_pair(pw[j], i));
if (it != L[j].begin()) {
--it;
if (l[(*it).second][0] > mx) mx = l[(*it).second][0], cr = (*it).second;
}
}
if (mn > mx) {
sz[i] = 1;
for (int(j) = 0; (j) < k; j++)
L[j].insert(make_pair(pw[j], i)), R[j].insert(make_pair(pw[j], i)),
l[i][j] = r[i][j] = pw[j];
if (mn == 0x3f3f3f3f) head = i;
} else {
for (int(j) = 0; (j) < k; j++) {
set<pair<int, int> >::iterator it1 = L[j].find(make_pair(l[cl][j], cl)),
it2 = R[j].find(make_pair(r[cl][j], cl));
while ((*it1).second != cr) {
if (!j) sz[cr] += sz[(*it1).second];
l[cr][j] = min(l[cr][j], (*it1).first);
r[cr][j] = max(r[cr][j], (*it2).first);
L[j].erase(it1++);
R[j].erase(it2++);
}
L[j].erase(it1);
R[j].erase(it2);
l[cr][j] = min(l[cr][j], pw[j]);
r[cr][j] = max(r[cr][j], pw[j]);
if (!j) sz[cr]++;
L[j].insert(make_pair(l[cr][j], cr));
R[j].insert(make_pair(r[cr][j], cr));
}
}
printf("%d\n", sz[head]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y, z, k, sol, sum, ans[1000000], l, r, xx, yy, a[1000000],
b[1000000], dis;
vector<long long> v;
vector<long long> vv;
pair<long long, pair<long long, long long>> pp[1000000];
pair<long long, long long> p[1000000];
map<long long, pair<long long, long long>> ma;
string s1, s2, s;
char c;
void solution(long long x, long long y, long long i) {
auto it = upper_bound(v.begin(), v.end(), x);
long long idx = it - v.begin();
if (idx == v.size() - 1) idx--;
r = ma[v[idx]].second;
dis = (x - v[idx]) * (x - v[idx]) + (y) * (y);
if (dis <= r * r && ans[ma[v[idx]].first] == 0) {
ans[ma[v[idx]].first] = i;
sum++;
}
if (idx == 0) return;
idx--;
r = ma[v[idx]].second;
dis = (x - v[idx]) * (x - v[idx]) + (y) * (y);
if (dis <= r * r && ans[ma[v[idx]].first] == 0) {
ans[ma[v[idx]].first] = i;
sum++;
}
idx--;
if (idx < 0) return;
r = ma[v[idx]].second;
dis = (x - v[idx]) * (x - v[idx]) + (y) * (y);
if (dis <= r * r && ans[ma[v[idx]].first] == 0) {
ans[ma[v[idx]].first] = i;
sum++;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> r;
v.push_back(x);
ma[x].second = r;
ma[x].first = i;
}
v.push_back(1e17);
sort(v.begin(), v.end());
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
solution(x, y, i);
}
cout << sum << endl;
for (int i = 1; i <= n; i++) {
if (!ans[i])
cout << -1 << " ";
else
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long TESTS = 1;
cin >> TESTS;
while (TESTS--) {
long long n;
cin >> n;
if (n % 4 != 0)
cout << "NO" << '\n';
else
cout << "YES" << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int Maxn = 1e5 + 1;
vector<int> v[Maxn];
vector<int> color(Maxn);
int leader;
int col;
int flag;
vector<int> vis(Maxn);
void dfs(int u) {
vis[u] = 1;
if (u != leader) {
if (color[u] != col) {
flag = 1;
}
}
for (auto &x : v[u]) {
if (vis[x] == 0 && x != leader) dfs(x);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
cin >> n;
for (int i = 1, x, y; i < n; ++i) {
cin >> x >> y;
v[x].emplace_back(y);
v[y].emplace_back(x);
}
for (int i = 1; i <= n; ++i) cin >> color[i];
for (int i = 1; i <= n; ++i) {
for (auto &x : v[i]) {
if (color[i] != color[x]) {
flag = 0;
leader = i;
for (auto &y : v[leader]) {
col = color[y];
dfs(y);
}
if (flag == 0) {
cout << "YES"
<< "\n";
cout << leader << "\n";
return 0;
}
flag = 0;
leader = x;
vis.assign(n + 1, 0);
for (auto &y : v[leader]) {
col = color[y];
dfs(y);
}
if (flag == 0) {
cout << "YES"
<< "\n";
cout << leader << "\n";
return 0;
} else {
cout << "NO"
<< "\n";
return 0;
}
}
}
}
cout << "YES"
<< "\n";
cout << 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long log_a_to_base_b(long long a, long long b) { return log(a) / log(b); }
bool isPrime(long long n) {
if (n == 1) {
return false;
}
long long i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
vector<long long> prime_fact(long long n) {
vector<long long> v;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0) n /= i;
v.push_back(i);
}
if (n > 1) v.push_back(n);
return v;
}
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2)
res *= a, n--;
else
a *= a, n /= 2;
}
return res;
}
long long euler_totient(long long n) {
long long res = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
res /= i;
res *= (i - 1);
while (n % i == 0) n /= i;
}
}
if (n > 1) res /= n, res *= (n - 1);
return res;
}
bool isKthBitSet(long long n, long long k) {
if (n & (1 << k))
return true;
else
return false;
}
long long no_of_set_bits(long long n) {
long long cnt = 0;
while (n > 0) {
cnt++;
n = n & (n - 1);
}
return cnt;
}
bool is_perfect_square(long long n) {
if (n < 0) return false;
long long root(round(sqrt(n)));
return n == root * root;
}
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
signed main() {
init();
long long t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
string s = "";
for (long long i = 0; i < n - 2; i++) {
string p;
cin >> p;
if (i == 0)
s += p;
else if (s[s.size() - 1] == p[0])
s += p[1];
else
s += p;
}
if (s.size() != n) {
long long k = n - s.size();
for (long long i = 0; i < k; i++) s += 'a';
}
cout << s << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 500010;
int a[MAXN], ans[MAXN], p[21], ID[21], tmp[21], Cpy[21];
struct Node {
int l, r, Id;
} q[MAXN];
struct Info {
int x, Id;
} b[21];
inline void Ins(int x, int Id) {
for (int i = 20; ~i; --i) {
if (!(x & (1 << i))) continue;
if (!p[i]) {
p[i] = x;
ID[i] = Id;
break;
}
x ^= p[i];
}
}
inline int Qry(int x) {
int Ret = 0;
for (int i = 20; ~i; --i)
if (ID[i] >= x && (Ret ^ p[i]) > Ret) Ret ^= p[i];
return Ret;
}
int main() {
int N = read();
for (int i = 1; i <= N; ++i) a[i] = read();
int Q = read();
for (int i = 1; i <= Q; ++i) {
q[i].l = read();
q[i].r = read();
q[i].Id = i;
}
sort(q + 1, q + Q + 1, [&](Node a, Node b) { return a.r < b.r; });
int Pos = 1;
for (int i = 1; i <= Q; ++i) {
while (Pos <= q[i].r) {
int Len = 0;
for (int j = 0; j <= 20; ++j)
if (p[j]) {
b[++Len].x = p[j];
b[Len].Id = ID[j];
}
memset(p, 0, sizeof(p));
memset(ID, 0, sizeof(ID));
Ins(a[Pos], Pos);
sort(b + 1, b + Len + 1, [&](Info a, Info b) { return a.Id > b.Id; });
for (int j = 1; j <= Len; ++j) Ins(b[j].x, b[j].Id);
++Pos;
}
ans[q[i].Id] = Qry(q[i].l);
}
for (int i = 1; i <= Q; ++i) printf("%d\n", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<string> ans[2000005];
vector<pair<string, long long> > v;
long long n;
long long pos;
long long maxlevel;
void f(long long lev, long long cnt) {
if (pos == n) return;
maxlevel = max(maxlevel, lev);
ans[lev].push_back(v[pos].first);
pos++;
for (int i = 1; i <= cnt; i++) {
f(lev + 1, v[pos].second);
}
}
int main() {
std::ios::sync_with_stdio(false);
string s;
cin >> s;
n = s.length();
string temp = "";
for (int i = 0; i <= n - 1; i++) {
if (s[i] == ',') {
i++;
int num = 0;
while (i < n && s[i] >= '0' && s[i] <= '9') {
int childcnt = (int)(s[i] - 48);
num = num * 10 + childcnt;
i++;
}
v.push_back({temp, num});
temp = "";
} else
temp += s[i];
}
n = v.size();
for (int i = 0; i <= n - 1; i++) {
if (pos < n) {
f(0, v[pos].second);
}
}
cout << maxlevel + 1 << endl;
for (int i = 0; i <= maxlevel; i++) {
long long sz = ans[i].size();
for (int j = 0; j <= sz - 1; j++) cout << ans[i][j] << " ";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 300005;
int cont[2][(1 << 20) + 1];
int arr[MAX_N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
cont[1][0] = 1;
long long ans = 0;
for (int i = 0, pref = 0; i < n; i++) {
pref ^= arr[i];
ans += cont[i % 2][pref]++;
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
long long results[10][9];
unordered_map<long long, int> m1;
unordered_map<long long, int> m2;
long long curmask;
long long RANDMAP[MAXN];
void recurse(int i, int j) {
if (i == j) {
m1[curmask]++;
return;
}
for (int c = 0; c < i; c++) {
curmask ^= results[i][c];
recurse(i + 1, j);
curmask ^= results[i][c];
}
}
vector<pair<int, int> > adj[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
RANDMAP[i] = rand() * 10000000007LL + rand();
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
--u;
--v;
adj[u].push_back(make_pair(w, v));
}
for (int i = 0; i < m; i++) {
sort(adj[i].begin(), adj[i].end());
int deg = adj[i].size();
for (int j = 0; j < deg; j++) {
results[deg][j] ^= RANDMAP[adj[i][j].second];
}
}
curmask = 0;
int k1 = max(1, k - 3);
recurse(1, k1);
curmask = 0;
swap(m1, m2);
recurse(k1, k + 1);
int ans = 0;
long long t;
long long complete;
complete = 0;
for (int i = 0; i < n; i++) {
complete ^= RANDMAP[i];
}
for (auto& it : m1) {
t = it.first;
t ^= complete;
auto it2 = m2.find(t);
if (it2 != m2.end()) {
ans += it.second * it2->second;
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
const int mod = 20090717;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
int n, k, p;
long long a[maxn];
long long b[maxn];
bool vis[maxn];
bool judge(long long limit) {
int num = 0;
memset((vis), (0), sizeof(vis));
for (int i = 0; i < k; i++)
for (int j = 0; j < n; j++) {
if (vis[j]) continue;
if (abs(b[i] - a[j]) + abs(b[i] - p) <= limit) {
vis[j] = true;
num++;
break;
}
}
return num == n;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
for (int i = 0; i < k; i++) {
scanf("%I64d", &b[i]);
}
sort(a, a + n);
sort(b, b + k);
long long l = 0, r = 2e9 + 5;
long long ans;
while (l <= r) {
long long m = (l + r) / 2;
if (judge(m)) {
r = m - 1;
ans = m;
} else
l = m + 1;
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[5003];
int main() {
int i, j, k, m, n;
int x, y, z;
scanf("%d", &n);
printf("? 1 2\n");
fflush(stdout);
scanf("%d", &x);
printf("? 1 3\n");
fflush(stdout);
scanf("%d", &y);
fflush(stdout);
printf("? 2 3\n");
fflush(stdout);
scanf("%d", &z);
a[1] = (x + y - z) / 2;
a[2] = (x - a[1]);
a[3] = y - a[1];
for (int i = 4; i <= n; i++) {
printf("? 1 %d\n", i);
fflush(stdout);
scanf("%d", &x);
a[i] = x - a[1];
}
printf("! ");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
| 3 |
#include <iostream>
#include <map>
std::map<std::pair<int, int>, int> dp;
int query(int left, int right) {
auto p = std::make_pair(left, right);
if (dp.find(p) != dp.end()) {
return dp[p];
}
printf("? %d %d\n", left+1, right+1);
fflush(stdout);
int respond;
scanf("%d", &respond);
dp[p] = respond;
return respond;
}
void answer(int x) {
printf("! %d\n", x+1);
fflush(stdout);
}
void findkthZero(int left, int right, int k) {
if (left == right) {
answer(left);
return;
}
int med = (right + left) / 2;
int leftZeroCount = (med-left+1) - query(left, med);
if (leftZeroCount >= k) {
findkthZero(left, med, k);
dp[std::make_pair(left, med)]++;
} else {
findkthZero(med+1, right, k-leftZeroCount);
}
}
int main() {
int n, t;
scanf("%d %d", &n, &t);
while (t--) {
int k;
scanf("%d", &k);
findkthZero(0, n-1, k);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long i, j;
long long temp;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
queue<long long> s;
set<long long> second;
for (i = 0; i < n; i++) {
cin >> temp;
if (second.find(temp) == second.end()) {
if (s.size() == k) {
j = s.front();
s.pop();
second.erase(j);
}
s.push(temp);
second.insert(temp);
}
}
cout << s.size() << '\n';
vector<long long> ans;
while (s.empty() == 0) {
temp = s.front();
ans.push_back(temp);
s.pop();
}
for (i = ans.size() - 1; i >= 0; i--) {
cout << ans[i] << " ";
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.