solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long int MAXN = 2e5 + 51;
long long int n, c0, c1, res, l, r, mid, rr, x, y, z;
inline long long int read() {
register long long int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
inline long long int binom(long long int m, long long int n) {
if (m < n) {
return 0;
}
long long int res = 1;
for (register int i = m, j = 1; j <= n; i--, j++) {
res = res * i / j;
}
return res;
}
inline long long int check(long long int mid) {
long long int x = mid / c1, y = 0, sm = 0;
for (register int i = x; sm < n && i >= 0; i--) {
y = (mid - c1 * i) / c0, sm += binom(i + y + 1, i + 1);
}
return sm >= n;
}
int main() {
n = read() - 1, c0 = read(), c1 = read(), c0 > c1 ? swap(c0, c1) : (void)1;
if (!c0) {
return printf("%lld\n", n * c1), 0;
}
l = 0, r = c1 * 31;
while (l <= r) {
mid = (l + r) >> 1;
check(mid) ? rr = mid, r = mid - 1 : l = mid + 1;
}
res = n * (c0 + c1), x = (--rr) / c1, y = 0;
for (register int i = x; i >= 0; i--) {
z = binom(i + (y = (rr - c1 * i) / c0) + 1, i + 1), n -= z;
res += (z * y - binom(i + y + 1, i + 2)) * c0 + i * z * c1;
}
printf("%lld\n", res + n * (rr + 1));
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &first, T2 second) {
if (first > second) first = second;
}
template <typename T1, typename T2>
inline void chkmax(T1 &first, T2 second) {
if (first < second) first = second;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
_out << _p.first << ' ' << _p.second;
return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
_in >> _p.first >> _p.second;
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
if (_v.empty()) {
return _out;
}
_out << _v.front();
for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) {
_in >> _i;
}
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
const int N = 15;
int k;
vector<int> val[N];
long long w[N];
vector<long long> how[(1 << N) + 228];
pair<int, int> dp[(1 << N) + 228];
unordered_set<long long> used;
unordered_map<long long, int> place;
pair<int, int> ans[N];
int main() {
ios::sync_with_stdio(0);
srand(time(0));
cin >> k;
long long sum = 0;
for (int i = 0; i < k; ++i) {
int n;
cin >> n;
val[i].resize(n);
cin >> val[i];
for (auto j : val[i]) {
place[j] = i;
sum += j;
w[i] += j;
}
}
if (sum % k != 0) {
cout << "No\n";
return 0;
}
int n = k;
sum /= k;
for (int i = 0; i < k; ++i) {
for (auto j : val[i]) {
if (used.count(j)) continue;
vector<long long> val;
val.push_back(j);
while (true) {
used.insert(val.back());
long long delta = sum - (w[place[val.back()]] - val.back());
if (place.count(delta) == 0) break;
if (used.count(delta)) break;
val.push_back(delta);
}
long long delta = sum - (w[place[val.back()]] - val.back());
if (place.count(delta) == 0) continue;
vector<long long> res;
bool OK = false;
for (auto q : val) {
if (q == delta) OK = true;
if (OK) res.push_back(q);
}
int mask = 0;
for (auto q : res) {
int id = place[q];
if ((mask >> id) & 1) {
mask = -1;
break;
}
mask |= (1 << id);
}
if (mask == -1) continue;
how[mask] = res;
}
}
for (int mask = 0; mask < (1 << n); ++mask) {
int rev = ((1 << n) - 1) ^ mask;
int cur = (1 << n) - 1;
auto [first, second] = dp[mask];
if ((first | second) != mask) continue;
while (cur > 0) {
cur &= rev;
if (how[cur].size()) {
dp[mask | cur] = {mask, cur};
}
--cur;
}
}
int mm = (1 << n) - 1;
auto [first, second] = dp[mm];
if ((first | second) != mm) {
cout << "No\n";
return 0;
}
vector<int> masks;
while (mm != 0) {
masks.push_back(dp[mm].second);
mm = dp[mm].first;
}
cout << "Yes\n";
for (int cur : masks) {
vector<long long> res = how[cur];
res.push_back(res[0]);
for (int i = 0; i + 1 < res.size(); ++i) {
ans[place[res[i + 1]]] = {res[i + 1], place[res[i]] + 1};
}
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << '\n';
}
}
| 8 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
#define debug(x) cout << #x << " is " << x << endl
#define inc(i, a, b) for (int i = a; i <= b; ++i)
typedef long long ll;
const int INF = 0x3f3f3f3f, N = 1e5 + 5;
int t, n;
ll c[N], res[N];
int main()
{
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &c[i]);
ll min1 = c[1], min2 = c[2];
res[2] = n * (c[1] + c[2]);
ll ans = res[2];
for (int i = 3; i <= n; ++i) {
if (i & 1) {
if (c[i] >= min1) {
res[i] = res[i-1] + c[i] - min1;
}
else {
res[i] = res[i-1] - (n - (i + 1) / 2 + 1) * (min1 - c[i]);
min1 = c[i];
}
}
else {
if (c[i] >= min2) {
res[i] = res[i-1] + c[i] - min2;
}
else {
res[i] = res[i-1] - (n - i / 2 + 1) * (min2 - c[i]);
min2 = c[i];
}
}
}
for (int i = 2; i <= n; ++i) {
// debug(res[i]);
ans = min(ans, res[i]);
}
printf("%lld\n", ans);
}
return 0;
} | 3 |
#include<bits/stdc++.h>
using namespace std;
void solve(){
int n;
cin>>n;
vector<pair<int,int>> p;
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
p.push_back({x,y});
}
int tm[n];
for(int i=0;i<n;i++){
cin>>tm[i];
}
int arival=0,dp=0;
for(int i=0;i<p.size();i++){
int wait;
if(i==0){
arival=dp+(p[i].first-0)+tm[i];
}else{
arival=dp+(p[i].first-p[i-1].second)+tm[i];
}
wait=abs(p[i].second-p[i].first);
wait=ceil((double) wait/2.0);
dp=arival+wait;
dp=max(dp,p[i].second);
}
cout<<arival<<endl;
}
int main(){
int t;
cin>>t;
while(t--) solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
int main() {
int n, s, i, k = 0, max = 0;
scanf("%d%d", &n, &s);
int f[n];
int t[n];
for (i = 0; i < n; i++) {
scanf("%d%d", &f[i], &t[i]);
if (t[i] + f[i] > max) {
max = t[i] + f[i];
}
}
if (max > s)
printf("%d\n", max);
else
printf("%d\n", s);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long a, b, k;
scanf("%lld%lld%lld", &a, &b, &k);
long long ans = 0;
ans = (a - b) * (k >> 1);
if (k & 1) ans += a;
printf("%lld\n", ans);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long temp;
if (a % b == 0)
temp = a / b;
else
temp = a / b + 1;
long long te = n * temp;
if (te % c == 0)
cout << te / c;
else
cout << te / c + 1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if ((n - 2) % 3 != 0) {
cout << 1 << " " << 1 << " " << n - 2;
} else {
cout << 1 << " " << 2 << " " << n - 3;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void ritik() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
long long int gcd(long long int A, long long int B) {
if (B == 0)
return A;
else
return gcd(B, A % B);
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return (res % p);
}
long long int max3(long long int a, long long int b, long long int c) {
return max(max(a, b), c);
}
long long int min3(long long int a, long long int b, long long int c) {
return min(min(a, b), c);
}
long long int nCr(long long int n, long long int r) {
long long int x = n - r, y = 0, z = 1;
while (y < r) {
z = (z * (x + 1)) / (y + 1);
x++;
y++;
}
return z;
}
void primeFactors(long long int n) {
vector<long long int> fact, cnt;
for (long long int i = 2; i < sqrt(n) + 1; i++) {
if (n % i == 0) {
fact.push_back(i);
cnt.push_back(0);
}
while (n % i == 0) {
cnt[fact.size() - 1]++;
n = n / i;
}
}
if (n > 2) {
fact.push_back(n);
cnt.push_back(1);
}
}
const long long int maxm = 1e5;
const long long int mod = 1e9 + 7;
const long long int inf = 1e18;
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> v(n + 1);
for (long long int i = 0; i < n; i++) cin >> v[i];
for (long long int i = k; i < n; i++) {
if (v[i] != v[i - 1]) {
cout << -1;
return;
}
}
long long int ptr = -1;
for (long long int i = 0; i < k - 1; i++) {
if (v[i] != v[k - 1]) ptr = i;
}
cout << ptr + 1 << endl;
}
signed main() {
ritik();
long long int T = 1;
while (T--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<long long> s;
map<long long, int> mp;
long long n, m;
long long a[20005], l[20005], r[20005], len[20005], save[20005];
long long blocked[3][20005];
vector<vector<long long> > mul(vector<vector<long long> > A,
vector<vector<long long> > B) {
vector<vector<long long> > C(A.size(), vector<long long>(B[0].size()));
for (long long i = 0; i < A.size(); i++)
for (long long k = 0; k < B.size(); k++)
for (long long j = 0; j < B[0].size(); j++)
C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % 1000000007;
return C;
}
vector<vector<long long> > _pow(vector<vector<long long> > A, long long n) {
vector<vector<long long> > B(A.size(), vector<long long>(A.size()));
for (long long i = 0; i < A.size(); i++) B[i][i] = 1LL;
while (n > 0) {
if (n & 1) B = mul(B, A);
A = mul(A, A);
n >>= 1;
}
return B;
}
int main() {
vector<vector<long long> > A1(3, vector<long long>(3)),
A2(3, vector<long long>(3)), A3(3, vector<long long>(3)),
A4(3, vector<long long>(3)), A5(3, vector<long long>(3)),
A6(3, vector<long long>(3)), A7(3, vector<long long>(3)),
A8(3, vector<long long>(3));
A1[0][0] = A1[0][1] = A1[1][0] = A1[1][1] = A1[1][2] = A1[2][2] = A1[2][1] =
1;
A1[0][2] = A1[2][0] = 0;
A2 = A3 = A4 = A5 = A6 = A7 = A8 = A1;
for (long long i = 0; i < 3; i++)
A2[0][i] = A4[0][i] = A6[0][i] = A8[0][i] = 0;
for (long long i = 0; i < 3; i++)
A3[1][i] = A4[1][i] = A7[1][i] = A8[1][i] = 0;
for (long long i = 0; i < 3; i++)
A5[2][i] = A6[2][i] = A7[2][i] = A8[2][i] = 0;
scanf("%I64d%I64d", &n, &m);
for (long long i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &a[i], &l[i], &r[i]);
r[i]++;
s.insert(l[i]);
s.insert(r[i]);
}
long long t = 0;
for (auto it = s.begin(); it != s.end(); it++) {
save[++t] = *it;
mp[save[t]] = t;
}
for (long long i = 1; i <= n; i++) {
l[i] = mp[l[i]];
r[i] = mp[r[i]];
}
memset(blocked, 0, sizeof(blocked));
for (long long i = 1; i <= n; i++) {
blocked[a[i] - 1][l[i]]++;
blocked[a[i] - 1][r[i]]--;
}
for (long long i = 0; i < 3; i++) {
for (long long j = 1; j <= t; j++) {
blocked[i][j] += blocked[i][j - 1];
}
}
vector<vector<long long> > x(3, vector<long long>(1));
x[0][0] = 0;
x[1][0] = 1;
x[2][0] = 0;
x = mul(_pow(A1, save[1] - 2), x);
for (long long i = 1; i < t; i++) {
long long num = 0;
if (blocked[2][i]) num += 4;
if (blocked[1][i]) num += 2;
if (blocked[0][i]) num += 1;
num++;
long long len = (save[i + 1] - save[i]) % (1000000007 - 1);
if (num == 1) x = mul(_pow(A1, len), x);
if (num == 2) x = mul(_pow(A2, len), x);
if (num == 3) x = mul(_pow(A3, len), x);
if (num == 4) x = mul(_pow(A4, len), x);
if (num == 5) x = mul(_pow(A5, len), x);
if (num == 6) x = mul(_pow(A6, len), x);
if (num == 7) x = mul(_pow(A7, len), x);
if (num == 8) x = mul(_pow(A8, len), x);
}
x = mul(_pow(A1, m - save[t] + 1), x);
printf("%I64d\n", x[1][0]);
return 0;
}
| 6 |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <algorithm>
#include <ctime>
using namespace std;
const int maxN = 1001000;
int cntzero[maxN];
int cntone[maxN];
const int ZERO = 500005;
string res;
void dfs(int v) {
if (cntzero[v] > 0 && !(cntzero[v] == 1 && cntone[v] > 0)) {
res += '0';
--cntzero[v];
--cntone[v + 1];
dfs(v + 1);
}
else if (cntone[v] > 0) {
res += '1';
--cntone[v];
--cntzero[v - 1];
dfs(v - 1);
}
}
void solve() {
string s;
cin >> s;
int n = s.length();
for (int i = ZERO - n; i <= ZERO + n; ++i) {
cntzero[i] = 0;
cntone[i] = 0;
}
int curx = ZERO;
for (int i = 0; i < n; ++i) {
if (s[i] == '0') {
++cntzero[curx];
++cntone[curx + 1];
++curx;
}
else {
++cntone[curx];
++cntzero[curx - 1];
--curx;
}
}
res = "";
dfs(ZERO);
cout << res << endl;
}
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
//t = 1;
for (int tt = 0; tt < t; ++tt) {
solve();
}
return 0;
} | 11 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10, MAX = 1e6 + 1e4, MOD = 1e9 + 7, MAXL = 25;
void OUT(long double o, int x) {
cout << fixed << setprecision(x) << o;
return;
}
long long dp[MAXL][MAX], h[MAX];
void upd(int v, int p) {
dp[0][v] = p;
h[v] = h[p] + 1;
for (int i = 1; i <= 20; i++) dp[i][v] = dp[i - 1][dp[i - 1][v]];
}
long long g(int v, int x) {
for (int i = 0; i <= 20; i++)
if (x & (1 << i)) v = dp[i][v];
return v;
}
pair<long long, long long> lca(int v, int u) {
long long x = 0;
if (h[v] > h[u]) swap(v, u);
x = h[u] - h[v];
u = g(u, h[u] - h[v]);
if (u == v) return {x, 1};
for (int i = 20; i >= 0; i--) {
if (dp[i][v] != dp[i][u]) {
x += (1 << (i + 1));
v = dp[i][v];
u = dp[i][u];
}
}
return {x + 2, 0};
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long q, t = 2, n = 4;
pair<long long, long long> m = {1, 0};
cin >> q;
for (int j = 1; j <= 4; j++) upd(j, 1);
while (q--) {
long long x;
cin >> x;
upd(n + 1, x);
upd(n + 2, x);
n += 2;
if (t % 2 == 0) {
pair<long long, long long> y = lca(m.first, n);
if (y.first > t / 2) {
if (y.second)
m.second = g(n, h[n] - h[m.first] - 1);
else
m.second = dp[0][m.first];
t++;
}
} else {
pair<pair<long long, long long>, long long> y = {lca(m.first, n),
m.first};
pair<pair<long long, long long>, long long> z = {lca(m.second, n),
m.second};
if (y.first.first > z.first.first) swap(y, z);
if (y.first.first > t / 2) {
m = {y.second, 0};
t++;
}
}
cout << t << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100], a1[100];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> a1[i];
}
sort(a, a + n);
sort(a1, a1 + m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == a1[j]) {
cout << a[i];
return 0;
}
}
}
if (a[0] < a1[0]) {
cout << a[0] * 10 + a1[0];
}
if (a[0] > a1[0]) {
cout << a1[0] * 10 + a[0];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ans = 1, md = 1000003, n, m;
char a[900000];
int main() {
scanf("%d %d\n", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) scanf("%c", &a[(i - 1) * m + j]);
scanf("\n");
}
for (int i = 1; i <= n; i++) {
int c = 3;
for (int j = 1; j <= m; j++) {
if ((((a[(i - 1) * m + j] == '1') || (a[(i - 1) * m + j] == '2')) &&
(j % 2 == 0)) ||
(((a[(i - 1) * m + j] == '3') || (a[(i - 1) * m + j] == '4')) &&
(j % 2 == 1))) {
c = c & 1;
}
if ((((a[(i - 1) * m + j] == '1') || (a[(i - 1) * m + j] == '2')) &&
(j % 2 == 1)) ||
(((a[(i - 1) * m + j] == '3') || (a[(i - 1) * m + j] == '4')) &&
(j % 2 == 0))) {
c = c & 2;
}
}
if (c == 0) ans = 0;
if (c == 3) ans = (ans * 2) % md;
}
for (int j = 1; j <= m; j++) {
int c = 3;
for (int i = 1; i <= n; i++) {
if ((((a[(i - 1) * m + j] == '1') || (a[(i - 1) * m + j] == '4')) &&
(i % 2 == 0)) ||
(((a[(i - 1) * m + j] == '2') || (a[(i - 1) * m + j] == '3')) &&
(i % 2 == 1))) {
c = c & 1;
}
if ((((a[(i - 1) * m + j] == '1') || (a[(i - 1) * m + j] == '4')) &&
(i % 2 == 1)) ||
(((a[(i - 1) * m + j] == '2') || (a[(i - 1) * m + j] == '3')) &&
(i % 2 == 0))) {
c = c & 2;
}
}
if (c == 0) ans = 0;
if (c == 3) ans = (ans * 2) % md;
}
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MOD2 = 1e9 + 9;
const int PR = 727;
const int INF = INT_MAX;
const long long LINF = LLONG_MAX;
const int N = 1e5 + 20;
const int K = 41;
long long a[N], trie[K * N][2], n, suf[N], ans, sz = 1;
string i2s(long long x) {
string res;
for (long long i = K - 1; i >= 0; i--) res += (x & (1LL << i)) ? '1' : '0';
return res;
}
long long s2i(string s) {
long long res = 0;
for (long long i = 0; i < s.size(); i++)
res += 1LL * (s[i] == '1') * (1LL << (s.size() - i - 1));
return res;
}
void add(string s) {
int v = 0;
for (char c : s) {
int nxt = c - '0';
if (trie[v][nxt] == -1) trie[v][nxt] = sz++;
v = trie[v][nxt];
}
}
long long get(string s) {
string res;
int v = 0;
for (char c : s) {
int x = c - '0';
if (trie[v][1 - x] + 1) {
res += '1';
v = trie[v][1 - x];
} else {
res += '0';
v = trie[v][x];
}
}
return s2i(res);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
memset(trie, -1, sizeof trie);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
suf[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) suf[i] = a[i] ^ suf[i + 1];
long long pre = 0;
ans = max(ans, suf[0]);
add(i2s(0));
pre = a[0];
for (int i = 1; i <= n; i++) {
ans = max(ans, get(i2s(suf[i])));
pre ^= a[i];
add(i2s(pre));
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
string s;
cin >> s;
int maxx = -1;
int flag = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
maxx = max(max(maxx, n - i), i + 1);
flag = 1;
}
}
if (flag == 0) {
cout << n << endl;
} else {
cout << 2 * maxx << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n{};
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '@' &&
(s[i + 2] == '@' || i == 0 || i == s.length() - 1 || s[i + 1] == '@')) {
cout << "No solution" << endl;
return 0;
} else if (s[i] == '@')
n++;
}
if (n == 0) {
cout << "No solution" << endl;
return 0;
}
for (int i = 0; i < s.length(); i++) {
cout << s[i];
if (s[i] == '@' && n > 1) {
cout << s[i + 1] << ',';
i++;
n -= 1;
}
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long Ans[36] = {
1, 2, 4, 8, 16, 32,
64, 128, 256, 512, 1024, 2048,
4096, 8092, 16184, 32368, 64736, 129472,
258944, 517888, 1035776, 2071552, 4143104, 8286208,
16572416, 33144832, 66289664, 132579328, 265158656, 530317312,
1060634624, 2121269248, 4242538496, 8485076992, 16970153984, 33940307968};
using namespace std;
int main() {
int n;
cin >> n;
cout << Ans[n];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
} a[200010];
map<int, int> mp;
bool cmp1(point x, point y) { return x.x < y.x; }
bool cmp2(point x, point y) { return x.y != y.y ? x.y > y.y : x.x < y.x; }
int tree[200010], b[200010], n;
int lowbit(int x) { return (-x) & x; }
int sum(int x) {
int ans = 0;
while (x) {
ans += tree[x];
x -= lowbit(x);
}
return ans;
}
void add(int x) {
while (x <= n) {
tree[x]++;
x += lowbit(x);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].y;
}
sort(a + 1, a + n + 1, cmp1);
for (int i = 1; i <= n; i++) {
mp[a[i].x] = i;
}
sort(a + 1, a + n + 1, cmp2);
a[n + 1].y = 0x7fffffff;
long long ans = 0;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!b[mp[a[i].x]]) {
b[mp[a[i].x]] = 1;
add(mp[a[i].x]);
cnt++;
}
int tmp = sum(mp[a[i].x]);
ans += 1LL * tmp *
(sum(a[i].y != a[i + 1].y ? n : mp[a[i + 1].x]) - tmp + 1 -
(int)(a[i].y == a[i + 1].y && b[mp[a[i + 1].x]]));
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 400007;
long long num[maxn << 2], tagn[maxn << 2], pre[307][30007];
long long tag[maxn << 2];
long long sum[maxn << 2];
int id[67], e1, a[maxn];
void pushup(int o) {
sum[o] = sum[o << 1] * sum[o << 1 | 1] % mod;
num[o] = (num[o << 1] | num[o << 1 | 1]);
}
inline long long pown(long long a, long long b) {
if (a <= 300 && b <= 30000) return pre[a][b];
long long ans = 1;
while (b) {
if (b & 1) (ans *= a) %= mod;
(a *= a) %= mod;
b >>= 1;
}
return ans;
}
inline void pushdown(int o, int l, int r) {
int m = (l + r) >> 1;
if (tag[o] != 1) {
long long x = pown(tag[o], m - l + 1);
sum[o << 1] = sum[o << 1] * x % mod;
sum[o << 1 | 1] =
sum[o << 1 | 1] * (r - m == m - l + 1 ? x : pown(tag[o], r - m)) % mod;
tag[o << 1] = tag[o << 1] * tag[o] % mod;
tag[o << 1 | 1] = tag[o << 1 | 1] * tag[o] % mod;
tagn[o << 1] |= tagn[o];
tagn[o << 1 | 1] |= tagn[o];
num[o << 1] |= tagn[o];
num[o << 1 | 1] |= tagn[o];
tag[o] = 1;
tagn[o] = 0;
}
}
inline void build(int o, int l, int r) {
tag[o] = 1;
if (l == r) {
sum[o] = a[l];
for (int i = 1; i <= e1; i++)
if (a[l] % id[i] == 0) num[o] |= (1LL << i);
return;
}
int m = (l + r) >> 1;
build(o << 1, l, m);
build(o << 1 | 1, m + 1, r);
pushup(o);
}
inline void update(int o, int l, int r, int ql, int qr, int x) {
if (l != r) pushdown(o, l, r);
if (l == ql && r == qr) {
tag[o] = tag[o] * id[x] % mod,
sum[o] = sum[o] * pown(id[x], r - l + 1) % mod;
num[o] |= (1LL << x);
tagn[o] |= (1LL << x);
return;
}
int m = (l + r) >> 1;
if (ql <= m && qr > m)
update(o << 1, l, m, ql, m, x), update(o << 1 | 1, m + 1, r, m + 1, qr, x);
else if (ql <= m)
update(o << 1, l, m, ql, qr, x);
else
update(o << 1 | 1, m + 1, r, ql, qr, x);
pushup(o);
}
inline pair<long long, long long> query(int o, int l, int r, int ql, int qr) {
if (l != r) pushdown(o, l, r);
if (l == ql && r == qr) {
return pair<long long, long long>(sum[o], num[o]);
}
int m = (l + r) >> 1;
if (ql <= m && qr > m) {
pair<long long, long long> q1 = query(o << 1, l, m, ql, m);
pair<long long, long long> q2 = query(o << 1 | 1, m + 1, r, m + 1, qr);
return make_pair(q1.first * q2.first % mod, q1.second | q2.second);
} else if (ql <= m)
return query(o << 1, l, m, ql, qr);
else
return query(o << 1 | 1, m + 1, r, ql, qr);
}
int vis[307];
int rea[307];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 2; i <= 300; i++) {
if (!vis[i]) {
id[++e1] = i;
for (int k = i * 2; k <= 300; k += i) vis[k] = 1;
}
}
for (int i = 1; i <= 300; i++) {
pre[i][0] = 1;
for (int k = 1; k <= 30000; k++) pre[i][k] = pre[i][k - 1] * i % mod;
}
for (int i = 1; i <= e1; i++)
rea[i] = (1LL * (id[i] - 1) * pown(id[i], mod - 2)) % mod;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
for (int i = 1; i <= m; i++) {
char s[17];
scanf("%s", s + 1);
int x, y;
scanf("%d%d", &x, &y);
if (s[1] == 'T') {
pair<long long, long long> q = query(1, 1, n, x, y);
for (int k = 1; k <= e1; k++) {
if (q.second & (1LL << k)) {
q.first = (1LL * q.first * rea[k]) % mod;
}
}
printf("%d\n", q.first);
} else {
int z;
scanf("%d", &z);
for (int i = 1; i <= e1; i++) {
while (z % id[i] == 0) {
update(1, 1, n, x, y, i);
z /= id[i];
}
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int INF = (int)1e9;
const int mod = (int)998244353;
const int MAXN = (int)1e3 + 5;
using namespace std;
long long add(long long a, long long b) {
long long res = (a + b);
while (res >= mod) res -= mod;
while (res < 0) res += mod;
return res;
}
long long mulp(long long a, long long b) { return (a * b) % mod; }
long long dp[MAXN][MAXN];
set<pair<long long, pair<long long, long long>>> st;
long long pw(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b / 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int val;
cin >> val;
st.insert(make_pair(val, make_pair(i, j)));
}
}
int C, R;
cin >> R >> C;
long long sum = 0, c = 0, c2 = 0, s = 0, s2 = 0, adc = 0, adc2 = 0, ads = 0,
ads2 = 0, adk = 0, adsum = 0;
int lst = -1;
long long k = 0;
for (auto u : st) {
if (lst != u.first) {
c = add(c, adc);
c2 = add(c2, adc2);
s = add(s, ads);
s2 = add(s2, ads2);
k = k + adk;
sum = add(sum, adsum);
adc = adc2 = ads = ads2 = adsum = adk = 0;
lst = u.first;
}
adk++;
adc = add(u.second.first, adc);
adc2 = add((u.second.first * u.second.first) % mod, adc2);
ads = add(u.second.second, ads);
ads2 = add((u.second.second * u.second.second) % mod, ads2);
int m = u.second.first, n = u.second.second;
long long inv = pw(k, mod - 2);
dp[m][n] = add(dp[m][n], (m * m) % mod);
dp[m][n] = add(dp[m][n], (n * n) % mod);
dp[m][n] = add(dp[m][n], (sum * inv) % mod);
dp[m][n] = add(dp[m][n], mulp(mulp(c, add(-m, -m)), inv));
dp[m][n] = add(dp[m][n], mulp(mulp(s, add(-n, -n)), inv));
dp[m][n] = add(dp[m][n], mulp(c2, inv));
dp[m][n] = add(dp[m][n], mulp(s2, inv));
if (u.first == (*st.begin()).first) {
dp[u.second.first][u.second.second] = 0;
}
adsum = add(adsum, dp[m][n]);
}
cout << dp[R - 1][C - 1];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 2e6 + 5;
int n, dp[MAX][3];
string s;
int solve(int i, int p) {
if (i == n) return 0;
if (dp[i][p] != -1) return dp[i][p];
int ret = 1e9;
if (p == 0) {
if (s[i] - '0' == 0)
ret = 1 + solve(i + 1, 1);
else
ret = solve(i + 1, 1);
} else if (p == 1) {
if (s[i] - '0' == 1)
ret = 1 + solve(i + 1, 0);
else
ret = solve(i + 1, 0);
} else {
ret = min(solve(i + 1, s[i] - '0'), 1 + solve(i + 1, (1 - (s[i] - '0'))));
}
return dp[i][p] = ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
memset(dp, -1, sizeof dp);
cout << solve(0, 2);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * f;
}
char maze[205][205];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> maze[i][j];
}
}
bool exi = false;
pair<int, int> st = make_pair(0, 0), en = make_pair(0, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (maze[i][j] == 'B' and !exi) {
exi = true;
st = make_pair(i + 1, j + 1);
}
if (maze[i][j] == 'B') {
en = max(make_pair(i + 1, j + 1), en);
}
}
}
cout << (st.first + en.first) / 2 << " " << (st.second + en.second) / 2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> divs[N];
int dp[N], d[N], arr[N];
int main() {
int n;
scanf("%d", &n);
for (int a = 1; a <= n; a++) scanf("%d", &arr[a]);
for (int a = 2; a <= arr[n]; a++)
for (int b = 2 * a; b <= arr[n]; b += a) divs[b].push_back(a);
int ans = 1;
for (int a = 1; a <= n; a++) {
dp[a] = 1;
for (int b = 0; b < divs[arr[a]].size(); b++)
dp[a] = max(d[divs[arr[a]][b]] + 1, dp[a]);
for (int b = 0; b < divs[arr[a]].size(); b++)
d[divs[arr[a]][b]] = max(d[divs[arr[a]][b]], dp[a]);
d[arr[a]] = max(d[arr[a]], dp[a]);
ans = max(ans, dp[a]);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e6 + 5;
const int AL = 26;
int n, k, p, pos[AL], visited[AL];
bool can = true, used[AL];
string a[MAX_N];
vector<int> topological, g[AL];
set<pair<int, int> > edges;
void add_edge(const string& x, const string& y) {
for (int i = 0; i < min(x.size(), y.size()); ++i) {
if (x[i] != y[i]) {
g[x[i] - 'a'].push_back(y[i] - 'a');
edges.insert({x[i] - 'a', y[i] - 'a'});
return;
}
}
if (x.size() > y.size()) {
can = false;
}
}
void dfs(int x) {
visited[x] = 1;
for (auto u : g[x]) {
if (!visited[u]) {
dfs(u);
}
}
topological.push_back(x);
}
string gen_random(const int len) {
string tmp_s;
static const char alphanum[] = "abcdefghijklmnopqrstuvwxyz";
srand((unsigned)time(NULL));
tmp_s.reserve(len);
for (int i = 0; i < len; ++i)
tmp_s += alphanum[rand() % (sizeof(alphanum) - 1)];
return tmp_s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> p;
for (int j = 0; j < k; ++j) {
cin >> a[p * k + j];
for (int l = 0; l < a[p * k + j].size(); ++l) {
used[a[p * k + j][l] - 'a'] = true;
}
}
}
for (int i = 0; i < n * k - 1; ++i) {
add_edge(a[i], a[i + 1]);
}
if (!can) {
cout << "IMPOSSIBLE";
return 0;
}
for (int i = 0; i < AL; ++i) {
if (visited[i] || !used[i]) {
continue;
}
dfs(i);
}
reverse(topological.begin(), topological.end());
for (int i = 0; i < topological.size(); ++i) {
pos[topological[i]] = i;
}
for (auto x : edges) {
if (pos[x.first] > pos[x.second]) {
can = false;
break;
}
}
if (!can) {
cout << "IMPOSSIBLE";
return 0;
}
for (auto x : topological) {
cout << (char)(x + 'a');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const long double pi = acos(-1.0);
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
namespace My_Math {
int fac[100000 + 100], invfac[100000 + 100];
int add(int x, int y) { return x + y >= 998244353 ? x + y - 998244353 : x + y; }
int dec(int x, int y) { return x < y ? x - y + 998244353 : x - y; }
int mul(int x, int y) { return 1ll * x * y % 998244353; }
long long qpow(long long x, int y) {
long long ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x);
x = mul(x, x);
y >>= 1;
}
return ans;
}
int Inv(int x) { return qpow(x, 998244353 - 2); }
int C(int n, int m) {
if ((n < m) || (n < 0) || (m < 0)) return 0;
return mul(mul(fac[n], invfac[m]), invfac[n - m]);
}
void math_init() {
fac[0] = invfac[0] = 1;
for (register int i = 1; i <= 100000; i++) fac[i] = mul(fac[i - 1], i);
invfac[100000] = Inv(fac[100000]);
for (register int i = 100000 - 1; i >= 1; i--)
invfac[i] = mul(invfac[i + 1], i + 1);
}
} // namespace My_Math
using namespace My_Math;
int n, m, h, g, a[4002000];
vector<int> pos;
int find(int id) {
if ((!a[id << 1]) && (!a[id << 1 | 1]))
return id;
else if (a[id << 1] > a[id << 1 | 1])
return find(id << 1);
else
return find(id << 1 | 1);
}
void del(int id) {
if ((!a[id << 1]) && (!a[id << 1 | 1])) {
a[id] = 0;
return;
} else if (a[id << 1] > a[id << 1 | 1]) {
a[id] = a[id << 1];
del(id << 1);
} else {
a[id] = a[id << 1 | 1];
del(id << 1 | 1);
}
}
int main() {
int T = read();
while (T--) {
h = read();
g = read();
n = (1 << h) - 1;
m = (1 << g) - 1;
for (register int i = 1; i <= n; i++) a[i] = read();
pos.clear();
for (register int i = 1; i <= m; i++)
while (find(i) > m) {
pos.push_back(i);
del(i);
}
long long ans = 0;
for (register int i = 1; i <= m; i++) ans += a[i];
printf("%lld\n", ans);
for (register int i = 0; i <= n - m - 1; i++) printf("%d ", pos[i]);
puts("");
for (register int i = 1; i <= n; i++) a[i] = 0;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200002;
int n, cnt;
vector<pair<pair<int, int>, int>> vec;
set<int> axis;
map<int, int> as;
int ans[maxn];
int C[maxn * 4];
inline int lowbit(int x) { return x & (-x); }
inline int sum(int x) {
int ret = 0;
while (x > 0) {
ret += C[x];
x -= lowbit(x);
}
return ret;
}
inline void add(int x, int d) {
while (x <= cnt) {
C[x] += d;
x += lowbit(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
vec.push_back(make_pair(make_pair(x, y), i));
axis.insert(x);
axis.insert(y);
}
cnt = 0;
for (int x : axis) {
as[x] = ++cnt;
}
sort(vec.begin(), vec.end());
for (int i = 0; i < n; i++) {
vec[i].first = make_pair(as[vec[i].first.first], as[vec[i].first.second]);
}
memset((C), 0, sizeof(C));
for (int i = n - 1; i >= 0; i--) {
ans[vec[i].second] = sum(vec[i].first.second);
add(vec[i].first.second, 1);
}
for (int i = 0; i < n; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n];
map<int, int> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
m[a[i]] = i;
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
int prev = 0;
map<int, int>::iterator itr;
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (m.find(b[i])->second < prev) {
cout << "0 ";
} else {
cout << abs(prev - m[b[i]]) + 1 << " ";
if (prev <= m[b[i]]) prev = m[b[i]] + 1;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, a[105], sum = 0;
cin >> n >> k >> x;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; i >= 0; i--) {
if (a[i] > x && k > 0) {
sum += x;
k--;
} else {
sum += a[i];
}
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 2e5 + 10;
const int mod = 1e9 + 7;
using namespace std;
int a[N], vis[N];
vector<pair<int, int> > v1, v2;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
v1.push_back({-1, 0});
v2.push_back({N, 0});
for (int i = 1; i <= n; ++i) {
if (a[i] > v1.back().first) {
vis[i] = 0;
v1.push_back({a[i], i});
continue;
}
if (v1.back().first < v2.back().first &&
v1.back().second > v2.back().second) {
v2.push_back(v1.back());
vis[v1.back().second] = 1;
v1.pop_back();
}
if (a[i] > v1.back().first) {
vis[i] = 0;
v1.push_back({a[i], i});
continue;
}
if (a[i] < v2.back().first) {
vis[i] = 1;
v2.push_back({a[i], i});
continue;
}
return puts("NO") * 0;
}
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d%c", vis[i], " \n"[i == n]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000 + 10;
int n, a[MAX_N], b[MAX_N], p[MAX_N];
multiset<int> f;
int main(int argc, char *argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
f.insert(i - p[b[i]]);
}
for (int i = 0; i < n; i++) {
int ans = n;
multiset<int>::iterator it = f.lower_bound(i);
if (it != f.end()) {
ans = min(ans, (*it) - i);
}
if (it != f.begin()) {
it--;
ans = min(ans, i - (*it));
}
printf("%d\n", ans);
f.erase(f.find(i - p[b[i]]));
f.insert(i - p[b[i]] + n);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, a[100005], b[100005], x[100005], y[100005], t[100005];
bool solve() {
for (int i = 1; i < n; i++) x[i] = a[i];
for (int i = 1; i < n; i++) y[i] = b[i];
for (int i = 2; i <= n; i++) t[i] = 0;
for (int k = 0; k < 2; k++) {
for (int i = 1; i < n; i++) {
if (x[i] % 2 == 0 && y[i] % 2 == 0 && (t[i] >> k) % 2 == 0)
t[i + 1] += 0;
else if (x[i] % 2 == 1 && y[i] % 2 == 0 && (t[i] >> k) % 2 == 0)
t[i + 1] += (1 << (k));
else if (x[i] % 2 == 1 && y[i] % 2 == 0 && (t[i] >> k) % 2 == 1)
t[i + 1] += 0;
else if (x[i] % 2 == 1 && y[i] % 2 == 1 && (t[i] >> k) % 2 == 1)
t[i + 1] += (1 << k);
else
return 0;
}
for (int i = 1; i < n; i++) {
x[i] /= 2;
y[i] /= 2;
}
}
return 1;
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) cin >> b[i];
for (int i = 0; i <= 3; i++) {
t[1] = i;
if (solve()) {
t[1] = i;
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << t[i] << " ";
return 0;
}
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void print(T x, char let) {
print(x), putchar(let);
}
const int N = 100005;
struct node {
int x, y;
} a[N];
long long ans;
int tmpx[N], tmpy[N];
int n;
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i].x = read(), a[i].y = read();
tmpx[i] = a[i].x, tmpy[i] = a[i].y;
}
if (n == 1) return puts("0"), 0;
if (n == 2)
return printf("%lld\n",
2ll * (abs(a[1].x - a[2].x) + abs(a[1].y - a[2].y))),
0;
sort(tmpx + 1, tmpx + n + 1);
sort(tmpy + 1, tmpy + n + 1);
int m = n + 1 >> 1, dx, dy;
dx = tmpx[m + 1] - tmpx[m], dy = tmpy[m + 1] - tmpy[m];
if (n % 2 == 1) {
dx = min(dx, tmpx[m] - tmpx[m - 1]);
dy = min(dy, tmpy[m] - tmpy[m - 1]);
}
dx = min(dx, dy);
int o = 0, s[2][2] = {0};
for (int i = 1; i <= n; i++) {
ans += abs(a[i].x - tmpx[m]) + abs(a[i].y - tmpy[m]);
s[a[i].x <= tmpx[m]][a[i].y <= tmpy[m]]++;
if (a[i].x == tmpx[m] && a[i].y == tmpy[m]) o = 1;
}
if ((n % 2 == 0 || o) && s[0][0] && s[0][1]) ans -= dx;
printf("%lld\n", 2ll * ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int f(int n);
int main() {
cin >> a >> b >> c;
cout << f(c);
return 0;
}
int f(int n) {
if (n == 0) {
return a;
}
if (n == 1) {
return b;
}
return f(n - 2) + f(n - 1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, m;
int nivel[maxn], pai[maxn];
bool mark[maxn];
int mx[maxn];
long long pref[maxn];
vector<int> grafo[maxn];
void get_ciclo(int u, int v) {
int menor = n + 1, maior = 0;
while (u && nivel[u] >= nivel[v]) {
menor = min(menor, u);
maior = max(maior, u);
u = pai[u];
}
mx[menor] = min(mx[menor], maior);
}
void dfs(int u, int p) {
mark[u] = 1;
for (auto v : grafo[u]) {
if (mark[v]) {
if (v == p || nivel[v] > nivel[u]) continue;
get_ciclo(u, v);
continue;
}
nivel[v] = nivel[u] + 1;
pai[v] = u;
dfs(v, u);
}
}
long long soma(int x) { return 1ll * x * (x + 1) / 2ll; }
int main(void) {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
grafo[u].push_back(v);
grafo[v].push_back(u);
}
for (int i = 1; i <= n + 1; i++) mx[i] = n + 1;
for (int i = 1; i <= n; i++)
if (!mark[i]) dfs(i, 0);
for (int i = n; i >= 1; i--) mx[i] = min(mx[i], mx[i + 1]);
for (int i = 1; i <= n; i++) pref[i] = pref[i - 1] + 1ll * (mx[i] - i);
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
int ini = l, fim = r, ind = r + 1;
while (ini <= fim) {
int mid = (ini + fim) >> 1;
if (mx[mid] > r)
ind = mid, fim = mid - 1;
else
ini = mid + 1;
}
long long ans = 0;
if (ind != r + 1) {
ans += 1ll * (r + 1) * (r - ind + 1);
ans -= (1ll * soma(r) - soma(ind - 1));
}
if (ind > l) ans += pref[ind - 1] - pref[l - 1];
printf("%lld\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef struct numb {
int n, b, e;
} Numb;
bool cond(Numb A, Numb B) { return (A.n < B.n); }
vector<int> vec[int(1e5) + 10];
int vis[int(1e5) + 10];
map<int, vector<int> > resp;
Numb v[int(1e5) + 10];
void DFS(int idx, int val) {
vis[idx] = val;
for (int i = 0, __ = int(vec[idx].size()); i < __; i++) {
if (!vis[vec[idx][i]]) DFS(vec[idx][i], val);
}
}
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
int val[n];
for (int i = 1, __ = n + 1; i < __; i++) cin >> v[i].n, v[i].b = i;
sort(v + 1, v + n + 1, cond);
for (int i = 1, __ = n + 1; i < __; i++) {
v[i].e = i;
vec[v[i].b].push_back(v[i].e);
vec[v[i].e].push_back(v[i].b);
}
for (int i = 1, __ = n + 1; i < __; i++) {
if (!vis[i]) DFS(i, i);
resp[vis[i]].push_back(i);
}
cout << resp.size() << endl;
for (map<int, vector<int> >::iterator it = resp.begin(); it != resp.end();
it++) {
cout << it->second.size() << " ";
for (int j = 0, __ = int(it->second.size()); j < __; j++) {
if (j + 1 != it->second.size())
cout << it->second[j] << " ";
else
cout << it->second[j] << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 10;
const double eps = 1e-8;
double aa[N];
double bb[N];
double dp[N];
int main() {
int n, k;
double p;
while (scanf("%d", &n) != EOF) {
scanf("%d%lf", &k, &p);
p /= 1000;
double x, y;
scanf("%lf%lf", &x, &y);
for (int i = 0; i < n; i++) {
double a, b;
scanf("%lf%lf", &a, &b);
aa[i] = (a - x) * (a - x) + (b - y) * (b - y);
}
sort(aa, aa + n);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (aa[i] <= 0.0) {
cnt++;
} else
break;
}
if (cnt >= k) {
printf("0.0\n");
continue;
}
double l = 0, r = aa[n - 1];
while (r - l > eps) {
double mid = (r + l) / 2;
for (int i = 0; i < n; i++) {
if (aa[i] <= mid)
bb[i] = 1;
else
bb[i] = exp(1 - aa[i] / mid);
}
for (int i = 0; i <= n; i++) dp[i] = 0;
dp[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = n; j >= 1; j--) {
dp[j] = dp[j - 1] * bb[i] + dp[j] * (1 - bb[i]);
}
dp[0] = dp[0] * (1 - bb[i]);
}
double ans = 0;
for (int i = k; i <= n; i++) {
ans += dp[i];
}
if (ans >= 1 - p) {
r = mid;
} else
l = mid;
}
printf("%.12lf\n", sqrt(r));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
a = b = 1;
int n;
cin >> n;
while (n--) {
string s;
cin >> s;
if (s == "UR" || s == "DL")
a++;
else if (s == "UL" || s == "DR")
b++;
else {
a++;
b++;
}
}
cout << a * b << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
static const int MAXN = 1e5 + 10;
static const int OO = 0x3fffffff;
inline int read() {
int ret = 0, f = 1;
char c;
while (c = getchar(), !isdigit(c)) f = c == 45 ? -1 : 1;
while (isdigit(c)) {
ret = (ret << 3) + (ret << 1);
ret += c - 48;
c = getchar();
}
return f * ret;
}
int n;
int a[MAXN];
int b[MAXN];
int main() {
n = read();
int dif = 0;
int p = 1;
for (int i = 1; i <= n; ++i) {
a[i] = read();
b[i] = a[i];
}
sort(b + 1, b + 1 + n);
for (int i = 1; i <= n; ++i) {
if (a[i] != b[i]) {
++dif;
}
}
if (dif > 2) {
puts("NO");
} else {
puts("YES");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<long long> res;
res.push_back(n * (n + 1) / 2);
res.push_back(1);
for (long long i = 2; i <= sqrt(n); i++)
if (n % i == 0) {
long long j = n / i;
res.push_back((long long)i * j * (j - 1) / 2 + j);
if (j != i) {
res.push_back((long long)j * i * (i - 1) / 2 + i);
}
}
sort(res.begin(), res.end());
for (long long x : res) cout << x << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
string s;
long long int p[1000006];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int i, j;
cin >> k >> s;
n = (int)((s).size());
memset(p, 0, sizeof p);
for (i = 0; i < n; i++) {
if (i) p[i] = p[i - 1];
if (s[i] == '1') p[i]++;
}
long long int ans = 0;
for (i = 0; i < n; i++) {
auto lit = lower_bound(p + i, p + n, (i >= 1 ? p[i - 1] : 0LL) + k) - p;
auto uit = upper_bound(p + i, p + n, (i >= 1 ? p[i - 1] : 0LL) + k) - p;
ans += (uit - lit);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[11], b[11];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i] == b[j]) cout << a[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 18;
vector<int> adj[maxn], sons[maxn];
bool vis[maxn];
int fa[maxn], dep[maxn], depth, leaf, n, m, k;
vector<vector<int>> cycles;
void dfs(int u, int d) {
vis[u] = true;
if ((dep[u] = d) > depth) depth = d, leaf = u;
for (auto v : adj[u])
if (!vis[v]) {
fa[v] = u;
dfs(v, d + 1);
if (depth > (n - 1) / k) return;
sons[u].push_back(v);
}
if (sons[u].empty() && cycles.size() ^ k) {
int index = 0;
if (adj[u][index] == fa[u]) ++index;
int x = adj[u][index++];
if (adj[u][index] == fa[u]) ++index;
int y = adj[u][index];
vector<int> loop(1, u);
while (loop.back() ^ x) loop.push_back(fa[loop.back()]);
if (loop.size() % 3) {
cycles.push_back(loop);
return;
}
loop = vector<int>(1, u);
while (loop.back() ^ y) loop.push_back(fa[loop.back()]);
if (loop.size() % 3) {
cycles.push_back(loop);
return;
}
loop = vector<int>(1, u);
if (dep[x] < dep[y]) swap(x, y);
loop.push_back(x);
while (loop.back() ^ y) loop.push_back(fa[loop.back()]);
cycles.push_back(loop);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> k;
while (m--) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
if (depth > (n - 1) / k) {
cout << "PATH\n" << depth << '\n';
while (true) {
cout << leaf;
if (fa[leaf]) {
cout << ' ';
leaf = fa[leaf];
} else {
cout << '\n';
break;
}
}
} else {
cout << "CYCLES\n";
for (int i = 0; i ^ k; ++i) {
cout << cycles[i].size() << '\n' << cycles[i].front();
for (int j = 1; j ^ cycles[i].size(); ++j) cout << ' ' << cycles[i][j];
cout << '\n';
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> muda[100000];
int main(void) {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int last1[21];
memset(last1, -1, sizeof last1);
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 20; j++) muda[i].push_back(last1[j]);
for (int j = 0; j < 20; j++)
if ((v[i] >> j) & 1) last1[j] = i;
}
set<int> unique;
int ans = 0;
for (int i = 0; i < n; i++) {
sort(muda[i].begin(), muda[i].end());
int x = v[i];
unique.insert(x);
for (int k = 0; k < muda[i].size(); k++) {
if (muda[i][k] != -1) {
x = x | v[muda[i][k]];
unique.insert(x);
}
}
}
cout << unique.size() << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int n;
cin >> n;
bool hor[n + 1], ver[n + 1];
vector<int> sol;
for (int i = 0; i <= n; i++) {
hor[i] = false;
ver[i] = false;
}
for (int i = 1; i <= n * n; i++) {
int x, y;
cin >> x >> y;
if (!hor[x] && !ver[y]) {
hor[x] = true;
ver[y] = true;
sol.push_back(i);
}
}
for (int i = 0; i < sol.size(); i++) {
cout << sol[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
std::ios::sync_with_stdio(false);
string str1;
string str2;
cin >> str1 >> str2;
if (str1 == str2) {
cout << -1 << endl;
} else {
cout << max(str1.size(), str2.size()) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int maxn = 100005;
const long long mod = 1e9 + 7;
bool vis[2005];
long long f[2005];
long long pow_mod(long long a, long long p) {
long long res = 1;
while (p) {
if (p & 1) res = res * a % mod;
a = a * a % mod;
p >>= 1;
}
return res;
}
long long C(int n, int r) {
long long res = 1;
res = res * f[n] % mod;
res = res * pow_mod(f[r], mod - 2) % mod;
res = res * pow_mod(f[n - r], mod - 2) % mod;
return res;
}
int main() {
f[0] = f[1] = 1;
for (int i = 2; i <= 2000; i++) f[i] = f[i - 1] * i % mod;
int x;
int n;
cin >> n;
int all = 0;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x != -1)
vis[i] = vis[x] = 1;
else
all++;
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
cnt++;
}
long long tot = 0;
for (int i = 1; i <= cnt; i++) {
if (i & 1)
tot = (tot + C(cnt, i) * f[all - i] % mod) % mod;
else
tot = (tot - C(cnt, i) * f[all - i] % mod + mod) % mod;
}
cout << (f[all] - tot + mod) % mod << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int x;
scanf("%d", &x);
printf("%d %d", ((x + 1) / 3) / 12, ((x + 1) / 3) % 12);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
int str[100100];
int freq[17];
bool adj[17][17];
bool vis[17][17][1 << 17];
bool pos[1 << 17];
void mark(int a, int b, int mask) {
if (vis[a][b][mask]) return;
vis[a][b][mask] = true;
pos[mask] = false;
for (int i = 0; i < p; i++) {
if (i == a || i == b) continue;
if (mask & (1 << i)) {
mark(a, b, mask - (1 << i));
}
}
}
bool dp[1 << 17];
int best = 1e6;
int main() {
cin >> n >> p;
char ci;
for (int i = 0; i < n; i++) {
cin >> ci;
str[i] = ci - 'a';
freq[str[i]]++;
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
cin >> adj[i][j];
}
}
for (int i = 0; i < (1 << p); i++) {
pos[i] = true;
}
for (int i = 0; i < p; i++) {
for (int j = 0; j < p; j++) {
if (adj[i][j]) continue;
int prev = -1;
int mask = 0;
for (int x = 0; x < n; x++) {
if (str[x] != i && str[x] != j) mask |= (1 << str[x]);
if (str[x] == j && prev > -1) {
mark(i, j, (((1 << p) - 1) ^ mask));
}
if (str[x] == i) {
prev = x;
mask = 0;
}
}
}
}
dp[(1 << p) - 1] = true;
for (int i = (1 << p) - 1; i >= 0; i--) {
if (!dp[i]) continue;
int cur = 0;
for (int j = 0; j < p; j++) {
if (i & (1 << j)) {
cur += freq[j];
if (pos[i - (1 << j)]) dp[i - (1 << j)] = true;
}
}
best = min(best, cur);
}
cout << best << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
multiset<long long> first[1009], second[1009];
int main() {
cin >> a >> b;
for (long long i = 0; i < a; i++) {
for (long long j = 0; j < b; j++) {
long long x;
cin >> x;
first[i + j].insert(x);
}
}
for (long long i = 0; i < a; i++) {
for (long long j = 0; j < b; j++) {
long long x;
cin >> x;
second[i + j].insert(x);
}
}
for (long long i = 0; i < a + b; i++) {
if (first[i] != second[i]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve(istream& in, ostream& out) {
int T;
in >> T;
while (T--) {
int n, m;
in >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
in >> a[i][j];
}
}
vector<vector<int>> dp(m + 1, vector<int>(1 << n));
for (int i = 0; i < m; ++i) {
for (int j = 0; j < 1 << n; ++j) {
for (int k = 0; k < 1 << n; ++k) {
if ((j & k) != j) continue;
int d = k ^ j;
for (int shift = 0; shift < n; ++shift) {
int sum = 0;
for (int l = 0; l < n; ++l) {
if ((d & (1 << l)) != 0) {
sum += a[(l + shift) % n][i];
}
}
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + sum);
}
}
}
}
int res = dp[m][(1 << n) - 1];
out << res << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
std::istream& in(std::cin);
std::ostream& out(std::cout);
solve(in, out);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int cnt[20];
int main() {
string a, b;
cin >> a >> b;
int sz = b.size();
for (int i = 0; i < sz; i++) {
if (b[i] == '2' || b[i] == '5')
cnt[12]++;
else if (b[i] == '6' || b[i] == '9')
cnt[16]++;
else
cnt[b[i] - '0']++;
}
sz = a.size();
int cn = 0;
while (true) {
for (int i = 0; i < sz; i++) {
if (a[i] - '0' == 2 || a[i] - '0' == 5) {
if (cnt[12])
cnt[12]--;
else
goto res;
} else if (a[i] - '0' == 6 || a[i] - '0' == 9) {
if (cnt[16])
cnt[16]--;
else
goto res;
} else {
if (cnt[a[i] - '0'])
cnt[a[i] - '0']--;
else
goto res;
}
}
cn++;
}
res:
cout << cn << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 200010;
int n, m;
vector<int> p[4][maxn];
int X[maxn], Y[maxn];
int ans[9];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &X[i], &Y[i]);
int x = X[i], y = Y[i];
p[0][x].push_back(y);
p[1][y].push_back(x);
p[2][x + y].push_back(x);
p[3][x - y + n].push_back(x);
}
for (int i = 0; i < 4; i++)
for (int j = 0; j < maxn; j++) sort(p[i][j].begin(), p[i][j].end());
for (int i = 1; i <= m; i++) {
int x = X[i], y = Y[i], w = 0;
vector<int>::iterator it;
int s[] = {x, y, x + y, x - y + n};
int t[] = {y, x, x, x};
for (int j = 0; j < 4; j++) {
it = lower_bound(p[j][s[j]].begin(), p[j][s[j]].end(), t[j]);
if (++it != p[j][s[j]].end()) ++w;
if (--it != p[j][s[j]].begin()) ++w;
}
ans[w]++;
}
for (int i = 0; i <= 8; i++) printf("%d ", ans[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a;
vector<vector<int> > g(n);
for (int i = 1; i < n; ++i) {
cin >> a;
a--;
g[a].push_back(i);
}
for (int i = 0; i < n; ++i) {
if (g[i].size()) {
int nb = 0;
for (int j = 0; j < g[i].size(); ++j) {
if (g[g[i][j]].empty()) nb++;
}
if (nb < 3) {
cout << "No";
return 0;
}
}
}
cout << "Yes";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int32_t main() {
int n;
cin >> n;
vector<int> p(n + 1);
set<int> s;
set<int> numbers;
for (int i = 1; i <= n; i++) {
s.insert(i);
numbers.insert(i);
}
int x, y;
while (s.size() >= 2) {
auto u = s.begin();
auto v = (next(s.begin()));
cout << "? " << *u << ' ' << *v << endl;
cin >> x;
cout << "? " << *v << ' ' << *u << endl;
cin >> y;
if (x > y) {
p[*u] = x;
s.erase(u);
numbers.erase(x);
} else {
p[*v] = y;
s.erase(v);
numbers.erase(y);
}
}
cout << "! ";
for (int i = 1; i <= n; i++) {
x = p[i];
if (!x) {
cout << *numbers.begin() << ' ';
} else {
cout << x << ' ';
}
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j;
inline bool check(int x) {
if (x < 2) return 0;
if (x == 2) return 1;
for (j = 2; j * j <= x; j++)
if (x % j == 0) return 0;
return 1;
}
int main() {
scanf("%d", &n);
if (check(n)) {
printf("1\n%d\n", n);
return 0;
}
if (check(n - 2)) {
printf("2\n2 %d\n", n - 2);
return 0;
}
for (i = 3; i <= n - 3; i++)
if (check(i) && check(n - 3 - i)) {
printf("3\n3 %d %d\n", i, n - 3 - i);
return 0;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch - '0' < 0 || ch - '0' > 9) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch - '0' >= 0 && ch - '0' <= 9) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, Q, A, B;
int head[100010], nxt[100010 * 2], to[100010 * 2], c[100010 * 2], tot;
void add(int u, int v, int x) {
tot++;
nxt[tot] = head[u];
head[u] = tot;
to[tot] = v;
c[tot] = x;
}
int mx, pos;
void dfs(int x, int las, int d) {
if (d > mx) mx = d, pos = x;
for (int i = head[x]; i; i = nxt[i]) {
if (to[i] == las) continue;
dfs(to[i], x, d + c[i]);
}
}
void Find() {
mx = pos = 0;
dfs(1, 0, 0);
A = pos;
mx = pos = 0;
dfs(A, 0, 0);
B = pos;
}
struct Tree {
int up[100010][22], dep[100010], mx[100010], ans[100010];
int s[100010], top, p[100010], up_dis[100010], size[100010];
void dfs(int x, int las) {
p[++top] = x;
s[x] = top;
size[x] = 1;
mx[x] = dep[x];
for (int i = 1; i <= 20; i++) up[x][i] = up[up[x][i - 1]][i - 1];
for (int i = head[x]; i; i = nxt[i]) {
if (to[i] == las) continue;
dep[to[i]] = dep[x] + c[i];
up[to[i]][0] = x;
up_dis[to[i]] = c[i];
dfs(to[i], x);
mx[x] = max(mx[x], mx[to[i]]);
size[x] += size[to[i]];
}
}
pair<int, int> t[100010 * 4];
int vis[100010], tag[100010 * 4];
void update(int k) { t[k] = max(t[k * 2], t[k * 2 + 1]); }
void build(int k, int l, int r) {
if (l == r) {
t[k] = make_pair(dep[p[l]], p[l]);
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
update(k);
}
void pushdown(int k) {
if (!tag[k]) return;
tag[k * 2] += tag[k];
tag[k * 2 + 1] += tag[k];
t[k * 2].first += tag[k];
t[k * 2 + 1].first += tag[k];
tag[k] = 0;
}
void modi(int k, int l, int r, int x, int y, int z) {
if (l >= x && r <= y) {
tag[k] += z;
t[k].first += z;
return;
}
pushdown(k);
int mid = (l + r) / 2;
if (mid >= x) modi(k * 2, l, mid, x, y, z);
if (mid < y) modi(k * 2 + 1, mid + 1, r, x, y, z);
update(k);
}
void pre() {
for (int i = 1; i <= n; i++) {
int x = t[1].second;
ans[i] = ans[i - 1] + t[1].first;
while (!vis[x] && x) {
modi(1, 1, n, s[x], s[x] + size[x] - 1, -up_dis[x]);
vis[x] = i;
x = up[x][0];
}
}
}
int query(int x, int y) {
y = min(y, n);
if (vis[x] <= y) return ans[y];
int now = x;
for (int i = 20; i >= 0; i--)
if (vis[up[now][i]] >= y) now = up[now][i];
now = up[now][0];
int res = mx[x] - dep[now] + ans[y - 1];
now = x;
for (int i = 20; i >= 0; i--)
if (vis[up[now][i]] > y) now = up[now][i];
now = up[now][0];
res = max(res, ans[y] - mx[now] + mx[x]);
return res;
}
} T1, T2;
int main() {
n = read();
Q = read();
for (int i = 1; i < n; i++) {
int q = read(), w = read(), e = read();
add(q, w, e);
add(w, q, e);
}
Find();
T1.dfs(A, 0);
T1.build(1, 1, n);
T1.pre();
T2.dfs(B, 0);
T2.build(1, 1, n);
T2.pre();
int las = 0;
while (Q--) {
int x = (read() + las - 1) % n + 1, y = (read() + las - 1) % n + 1;
printf("%d\n", las = max(T1.query(x, 2 * y - 1), T2.query(x, 2 * y - 1)));
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, m = 0, i, j = 0, a[100000];
int main() {
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n; i++) {
if (a[(k - 1) / n] > a[i]) m++;
if (a[(k - 1) / n] == a[i]) j++;
}
cout << a[(k - 1) / n] << " " << a[((k - 1) - n * m) / j] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
if (n % 2 == 0) {
if (m <= n / 2) {
cout << 2 * m - 1;
} else
cout << (m - n / 2) * 2;
} else {
if (m <= n / 2 + 1) {
cout << 2 * m - 1;
} else
cout << (m - (n / 2 + 1)) * 2;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, arr[5001];
int dp[5001][5001];
int rec(int ind, int lind) {
if (ind == n) return 0;
int &r = dp[ind][lind == -1 ? ind : lind];
if (r != -1) return r;
int x1 = 1e8, x2 = 1e8;
if (lind == -1) {
x1 = rec(ind + 1, lind) + 1;
x2 = rec(ind + 1, ind) + arr[ind];
return r = min(x1, x2);
}
x1 = rec(ind + 1, arr[lind] <= arr[ind] ? lind : ind) + 1;
if (arr[ind] <= arr[lind])
x2 = rec(ind + 1, ind);
else
x2 = rec(ind + 1, ind) + arr[ind] - arr[lind];
return r = min(x1, x2);
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n;
for (long long i = 0; i < n; i++) cin >> arr[i];
cout << rec(0, -1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
set<int> stt;
bool flag1, flag2;
void print(vector<int> v) {
for (int i = 0; i < v.size(); i++) {
if (i != v.size() - 1) {
cout << v[i] << " ";
} else {
cout << v[i] << endl;
}
}
}
void solve1(int n, vector<int> v, set<int> st) {
if (v.size() == n) {
print(v);
flag1 = false;
return;
}
if (!flag1) {
return;
}
int pos = v.size();
if (pos < n - 1) {
if (s[pos] == '>') {
set<int>::iterator it = st.end();
it--;
int a = *(it);
st.erase(it);
v.push_back(a);
solve1(n, v, st);
} else {
set<int>::iterator it = st.end();
it--;
it--;
for (it; it != st.begin(); it--) {
int aa = *it;
if (pos == 0 || (s[pos - 1] == '<' && aa > v[v.size() - 1]) ||
(s[pos - 1] == '>' && aa < v[v.size() - 1])) {
vector<int> nowV = v;
nowV.push_back(*it);
st.erase(it);
solve1(n, nowV, st);
st.insert(aa);
it = st.find(aa);
}
}
int bb = *(st.begin());
if (pos == 0 || (s[pos - 1] == '<' && bb > v[v.size() - 1]) ||
(s[pos - 1] == '>' && bb < v[v.size() - 1])) {
vector<int> nowV = v;
nowV.push_back(*(st.begin()));
st.erase(st.begin());
solve1(n, nowV, st);
st.insert(bb);
}
}
} else {
int a = *(st.begin());
st.erase(a);
v.push_back(a);
solve1(n, v, st);
}
}
void solve2(int n, vector<int> v, set<int> st) {
if (v.size() == n) {
print(v);
flag2 = false;
return;
}
if (!flag2) {
return;
}
int pos = v.size();
if (pos < n - 1) {
if (s[pos] == '<') {
set<int>::iterator it = st.begin();
int a = *(it);
st.erase(it);
v.push_back(a);
solve2(n, v, st);
} else {
set<int>::iterator it;
it = st.begin();
it++;
for (it; it != st.end(); it++) {
int aa = *it;
if (pos == 0 || (s[pos - 1] == '>' && aa < v[v.size() - 1]) ||
(s[pos - 1] == '<' && aa > v[v.size() - 1])) {
vector<int> nowV = v;
nowV.push_back(*it);
st.erase(it);
solve2(n, nowV, st);
st.insert(aa);
it = st.find(aa);
}
}
}
} else {
int a = *(st.begin());
st.erase(a);
v.push_back(a);
solve2(n, v, st);
}
}
void fig1(int n) {
vector<int> v;
int num = n;
int i = 0;
while (i < n - 1) {
if (s[i] == '>') {
v.push_back(num);
num--;
i++;
} else {
int j = i + 1;
while (j < n - 1 && s[j] == '<') {
j++;
}
int lnum = j - i;
for (int k = num - lnum; k <= num; k++) {
v.push_back(k);
}
num = num - lnum - 1;
i = j + 1;
}
}
while (num > 0) {
v.push_back(num);
num--;
}
print(v);
}
void fig2(int n) {
vector<int> v;
int num = 1;
int i = 0;
while (i < n - 1) {
if (s[i] == '<') {
v.push_back(num);
i++;
num++;
} else {
int j = i + 1;
while (j < n - 1 && s[j] == '>') {
j++;
}
int hnum = j - i;
for (int k = num + hnum; k >= num; k--) {
v.push_back(k);
}
i = j + 1;
num = num + hnum + 1;
}
}
while (num <= n) {
v.push_back(num);
num++;
}
print(v);
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n >> s;
fig1(n);
fig2(n);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, i, j, sum = 0, count = 0;
cin >> a;
cin >> b;
string s;
for (i = 0; i < a; i++) {
sum = 0;
cin >> s;
c = s.size();
for (j = 0; j < c; j++) {
if (s[j] == '4' || s[j] == '7') {
sum++;
}
}
if (sum <= b) {
count++;
}
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
int n;
string second;
int ree[305];
int query(string t) {
cout << t << endl;
cout.flush();
int res;
cin >> res;
if (res == -1) exit(0);
if (res == 0) exit(0);
return res;
}
int main() {
int n = query("a") + 1;
if (n == 301) {
for (int _ = 0; _ < (signed)(300); _++) cout << "b";
cout << endl;
return 0;
}
second.resize(n);
for (int i = 0; i < (signed)(n); i++) second[i] = 'a';
int amt = query(second);
if (amt == n) {
second.resize(n - 1);
for (int i = 0; i < (signed)(n - 1); i++) second[i] = 'b';
query(second);
return 0;
}
int cnt = 0;
for (int i = 0; i < (signed)(n - 1); i++) {
second[i] = 'b';
int cur = query(second);
if (cur < amt) {
ree[i] = 1;
++cnt;
}
second[i] = 'a';
}
if (cnt != amt) {
ree[n - 1] = 1;
}
for (int i = 0; i < (signed)(n); i++) {
if (ree[i]) second[i] = 'b';
}
query(second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int t;
int cnt = 0;
scanf("%d", &t);
int nn = t;
while (t--) {
int n;
scanf("%d", &n);
if (n % 2 == 1) cnt++;
}
if (cnt <= nn / 2) {
printf("%d", cnt);
} else {
int ans = nn - cnt;
cnt -= (nn - cnt);
ans += (cnt / 3);
printf("%d", ans);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &k) {
k = 0;
int flag = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') flag = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
k = k * 10 + c - '0';
c = getchar();
}
k *= flag;
}
const int N = 2000005;
double f[N][2];
int n, m, k;
string s, t;
int main() {
cin >> s;
t = s[0];
n = s.length();
for (int i = 1; i < n; ++i) {
if (s[i] == s[i - 1] && s[i] != 'X') {
t += 'X';
t += s[i];
} else
t += s[i];
}
n = t.length();
if (t[0] == t[n - 1] && t[0] != 'X')
if (t[0] == 'L')
t += 'X';
else
t = 'X' + t;
n = t.length();
double l = 0, r = 1;
while (l + 1e-9 < r) {
double mid = (l + r) / 2;
f[0][0] = 0;
f[0][1] = -mid;
for (int i = 0; i < n; ++i) {
f[i + 1][0] = f[i][1] - mid;
f[i + 1][1] = f[i][0] - mid;
if (t[i] == 'L')
f[i + 1][1] = max(f[i + 1][1], f[i][0] + 1 - mid);
else if (t[i] == 'R')
f[i + 1][0] = max(f[i + 1][0], f[i][1] + 1 - mid);
f[i + 1][0] = max(f[i + 1][0], f[i + 1][1] - mid);
f[i + 1][1] = max(f[i + 1][1], f[i + 1][0] - mid);
}
if (f[n][0] > 0)
l = mid;
else
r = mid;
}
int x = (l + 1e-9) * 1e8;
printf("%d.%06d\n", x / 1000000, x % 1000000);
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2")
using namespace std;
long long mod = 1e9 + 7;
const long long inf = 1e9;
int main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(0);
int n, l, x, y;
cin >> n >> l >> x >> y;
vector<int> a(n);
set<int> ax, ay;
map<int, int> have;
bool havex = 0, havey = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
have[a[i]] = 1;
}
for (int i = 0; i < n; ++i) {
if (a[i] + x < l && !have[a[i] + x]) ax.insert(a[i] + x);
if (a[i] + y < l && !have[a[i] + y]) ay.insert(a[i] + y);
if (a[i] - x > 0 && !have[a[i] - x]) ax.insert(a[i] - x);
if (a[i] - y > 0 && !have[a[i] - y]) ay.insert(a[i] - y);
}
for (int i = 0; i < n; ++i) {
if (have[a[i] - x] || have[a[i] + x]) havex = 1;
if (have[a[i] - y] || have[a[i] + y]) havey = 1;
}
vector<int> ans;
if (havex && havey) {
cout << 0;
exit(0);
}
if (havex) {
cout << "1\n" << (*ay.begin());
exit(0);
}
if (havey) {
cout << "1\n" << (*ax.begin());
exit(0);
}
for (int val : ax) {
if (ay.count(val)) {
cout << "1\n" << val;
exit(0);
}
}
cout << "2\n" << (*ax.begin()) << " " << (*ay.begin());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const pair<int, int> queen[8] = {pair<int, int>(-1, 0), pair<int, int>(-1, 1),
pair<int, int>(0, 1), pair<int, int>(1, 1),
pair<int, int>(1, 0), pair<int, int>(1, -1),
pair<int, int>(0, -1), pair<int, int>(-1, -1)};
const int maxN = 1e5 + 11;
typedef int i_N[maxN];
int N, K, Q, last;
deque<int> pos[maxN];
i_N A;
struct node {
int val, L, R;
node *left, *right;
node() {
val = L = R = 0;
left = right = NULL;
}
node(int L, int R) : L(L), R(R) {
val = 0;
left = right = NULL;
}
node(node *x) { *this = *x; }
} * IT[maxN];
pair<int, int> operator+(const pair<int, int> &a, const pair<int, int> &b) {
return pair<int, int>(a.first + b.first, a.second + b.second);
}
node *update(node *root, const int l, const int r, const int i, const int v) {
if (i < l || i > r) return NULL;
node *res = root == NULL ? new node(l, r) : new node(root);
res->val += v;
if (l == r) return res;
const int mid = (l + r) / 2;
if (i <= mid)
res->left = update(res->left, l, mid, i, v);
else
res->right = update(res->right, mid + 1, r, i, v);
return res;
}
int get_IT(node *root, const int i, const int j) {
if (root == NULL) return 0;
const int l = root->L, r = root->R;
if (j < l || i > r) return 0;
if (i <= l && j >= r) return root->val;
return get_IT(root->left, i, j) + get_IT(root->right, i, j);
}
int main() {
scanf("%d %d", &N, &K);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]);
for (int i = 1; i <= N; i++) {
pos[A[i]].push_back(i);
IT[i] = update(IT[i - 1], 1, N, i, 1);
if ((int)pos[A[i]].size() > K) {
IT[i] = update(IT[i], 1, N, pos[A[i]].front(), -1);
pos[A[i]].pop_front();
}
}
scanf("%d", &Q);
while (Q--) {
int l, r;
scanf("%d %d", &l, &r);
l = (l + last) % N + 1;
r = (r + last) % N + 1;
if (l > r) swap(l, r);
printf("%d\n", last = get_IT(IT[r], l, r));
}
}
| 7 |
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
const int cfnum = 1e5 + 5;
using namespace std;
const long long int cfmod = 998244353;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
int n;
cin >> n;
set<int> s;
map<int, int> mp;
int inside = 0;
vector<int> ans;
int shrey = 1;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x < 0) {
x = -x;
inside--;
if (mp[x] != 1) {
shrey = 0;
break;
} else {
if (s.find(x) == s.end()) {
shrey = 0;
break;
}
s.erase(x);
}
if (inside == 0) {
if (s.size() == 0) {
ans.push_back(i + 1);
s.clear();
mp.clear();
}
}
} else {
inside++;
if (mp[x] == 1) {
shrey = 0;
break;
} else {
mp[x]++;
s.insert(x);
}
}
}
if (shrey) {
if (inside != 0) {
shrey = 0;
}
}
if (shrey) {
cout << ans.size() << "\n";
cout << ans[0] << " ";
for (int i = 1; i < ans.size(); i++) {
cout << ans[i] - ans[i - 1] << " ";
}
} else {
cout << -1;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
struct line {
int ax, ay, bx, by;
} data[N];
struct node {
int x, y;
node *left, *right;
int ma, mi;
node(int l, int r) {
x = l;
y = r;
left = right = NULL;
}
} * tree;
int max1(int x, int y) { return x > y ? x : y; }
int min1(int x, int y) { return x < y ? x : y; }
void build(node *&root, int l, int r) {
root = new node(l, r);
if (l < r) {
int mid = (l + r) >> 1;
build(root->left, l, mid);
build(root->right, mid + 1, r);
root->ma = max1(root->left->ma, root->right->ma);
root->mi = min1(root->left->mi, root->right->mi);
} else if (l == r) {
root->ma = data[l].bx;
root->mi = data[l].by;
}
}
bool cmp(line a, line b) { return a.ay < b.ay; }
int bin(int l, int r, int x) {
while (l < r) {
int mid = (l + r) >> 1;
if (data[mid].ay < x)
l = mid + 1;
else
r = mid;
}
return l;
}
int getmax(node *root, int l, int r) {
if (l <= root->x and root->y <= r) {
return root->ma;
}
int mid = (root->x + root->y) >> 1, p1 = 0, p2 = 0;
if (l <= mid) p1 = getmax(root->left, l, r);
if (mid < r) p2 = getmax(root->right, l, r);
return max1(p1, p2);
}
int getmin(node *root, int l, int r) {
if (l <= root->x and root->y <= r) {
return root->mi;
}
int mid = (root->x + root->y) >> 1, p1 = 0x7fffffff, p2 = 0x7fffffff;
if (l <= mid) p1 = getmin(root->left, l, r);
if (mid < r) p2 = getmin(root->right, l, r);
return min1(p1, p2);
}
void print(node *root) {
if (root == NULL) return;
printf("%d %d %d %d\n", root->x, root->y, root->ma, root->mi);
print(root->left);
print(root->right);
}
void del(node *&root) {
if (root == NULL) return;
del(root->left);
del(root->right);
delete root;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d", &data[i].ax, &data[i].ay, &data[i].bx, &data[i].by);
}
sort(data + 1, data + n + 1, cmp);
build(tree, 1, n);
for (int i = 2; i <= n; i++) {
int xx = bin(1, i, data[i].ax), yy = i - 1;
if (xx > yy) continue;
int x = getmax(tree, xx, yy), y = getmin(tree, xx, yy);
if (y < data[i].bx or x > data[i].by) {
puts("NO");
return 0;
}
}
for (int i = 1; i <= n; i++) {
int k = data[i].ax;
data[i].ax = data[i].bx;
data[i].bx = k;
k = data[i].ay;
data[i].ay = data[i].by;
data[i].by = k;
}
sort(data + 1, data + n + 1, cmp);
build(tree, 1, n);
for (int i = 2; i <= n; i++) {
int xx = bin(1, i, data[i].ax), yy = i - 1;
if (xx > yy) continue;
int x = getmax(tree, xx, yy), y = getmin(tree, xx, yy);
if (y < data[i].bx or x > data[i].by) {
puts("NO");
return 0;
}
}
puts("YES");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
int main() {
int n, x;
cin >> n;
int a[n], d, t = 0;
cin >> a[0] >> a[1];
d = a[1] - a[0];
int i;
for (i = 2; i < n; i++) {
cin >> a[i];
if (a[i] - a[i - 1] != d) t = 1;
}
if (t == 1) {
cout << a[n - 1] << endl;
} else {
cout << a[0] + n * d << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> v(n);
for (int i = 0; i < n; i++) v[i] = s[i] - '0' - 1;
map<int, int> m;
long long sum = 0, ans = 0;
m[0] = 1;
for (int i = 0; i < n; i++) {
sum += v[i];
if (m[sum] != 0) {
ans += m[sum];
}
m[sum]++;
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
int main() {
string s;
cin >> n >> q >> s;
int l = 0, ans = 0;
cout << endl;
for (int i = 0; i < s.length(); i++)
if (s[i] == '.')
l++;
else
ans += (l > 0) ? (l - 1) : 0, l = 0;
ans += (l > 0) ? (l - 1) : 0;
while (q--) {
int k;
char ch;
cin >> k >> ch, k--;
if (ch == '.') {
if (s[k] != '.') {
s[k] = '.';
if (s[k + 1] == '.') ans++;
if (s[k - 1] == '.') ans++;
}
} else {
if (s[k] == '.') {
s[k] = ch;
if (s[k + 1] == '.') ans--;
if (s[k - 1] == '.') ans--;
}
}
cout << ans << '\n';
}
}
| 4 |
#include <iostream>
#include <vector>
#include <cmath>
#include <list>
#include <map>
#include <algorithm>
#include <climits>
#include <sstream>
#include <iomanip>
#include <bits/stdc++.h>
#include <cstdio>
#include <bitset>
#include <cstring>
#include <deque>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <string>
using namespace std;
#define ll long long int
#define cbit __builtin_popcountll
#define pl pair<long, long>
#define pqp priority_queue<pl>
// getline(cin, str);
// __gcd(a,b)
// vec.insert(vec.begin()+i,value); log2(n); tolower(s[i]);
// ostringstream s; s<<i; string ans =s.str();
// string c=to_string(i); s.push_back(c);
// next_permutation(nums.begin(),nums.end())
// priority_queue<PII, vector<PII>, greater<PII>> pq;
/* Iterative Function to calculate (x^y)%p
in O(log y) */
unsigned long long power(unsigned long long x, int y, int p)
{
unsigned long long res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
bool cmp(pair<string, int> &a, pair<string, int> &b)
{
return a.second < b.second;
}
void sort(map<string, int> &M)
{
// Declare vector of pairs
vector<pair<string, int> > A;
// Copy key-value pair from Map
// to vector of pairs
for (auto &it : M)
{
A.push_back(it);
}
// Sort using comparator function
sort(A.begin(), A.end(), cmp);
// Print the sorted value
for (auto &it : A)
{
cout << it.first << ' '
<< it.second << endl;
}
}
// Returns n^(-1) mod p
unsigned long long modInverse(unsigned long long n, int p)
{
return power(n, p - 2, p);
}
// Returns nCr % p using Fermat's little
// theorem.
unsigned long long nCrModPFermat(unsigned long long n, int r, int p)
{
// If n<r, then nCr should return 0
if (n < r)
return 0;
// Base case
if (r == 0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
unsigned long long fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) % p;
}
long long gcd(long long int a, long long int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
long long lcm(ll a, ll b)
{
return (a / gcd(a, b)) * b;
}
bool isPrime(ll n)
{
// Corner cases
if (n <= 1)
return false;
if (n <= 3)
return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0)
return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
ll find(ll s, ll n, ll pos)
{
ll mid = s + n / 2;
if (mid == pos)
{
return 1;
}
else if (mid > pos)
{
return 1 + find(mid + 1, n, pos);
}
else
{
return 1 + find(s, mid, pos);
}
}
// ll nCr(ll n, ll r)
// {
// return fact(n) / (fact(r) * fact(n - r));
// }
ll fact(ll n,ll p)
{
// single line to find factorial
return (n == 1 || n == 0) ? 1 : (n * (fact(n - 1,p)));
}
ll num(ll n, ll ans)
{
n /= 10;
if (n == 0)
{
return ans;
}
else
{
return ans + num(n, ans + 1);
}
}
ll nof(ll n)
{
if (n == 1)
{
return 1;
}
ll ans = 2;
for (ll i = 2; i * i <= n; i++)
{
if (n % i == 0)
{
if (i * i != n)
{
ans += 2;
}
else
{
ans++;
}
}
}
return ans;
}
ll getsum(ll n)
{
ll ans = 0;
while (n)
{
ans += n % 10;
n /= 10;
}
return ans;
}
ll power(ll num, ll deg,ll m) {
if (!deg)
return 1;
if (deg % 2) {
return (power(num, deg - 1,m) * num) % m;
}
else {
ll sqrt_res = power(num, deg / 2,m);
return (sqrt_res * sqrt_res) % m;
}
}
// vector<ll> prime;
void prm(bool mark[100100],ll size)
{
mark[0]=true;
mark[1]=true;
for(ll i=2;i*i<size;i++)
{
if(mark[i]==false)
{
// prm.push_back(i);
for(ll j=i+i;j<size;j+=i)
{
mark[j]=true;
}
}
}
}
void finddp(vector<ll>& ans,vector<ll> vec,ll d,ll s,ll e )
{
if(s>e)
{
return;
}
ll min=-1000000000000;
ll mi=s;
for(ll i=s;i<=e;i++)
{
if(vec[i]>min)
{
mi=i;
min=vec[i];
}
}
ans[mi]=d;
// cout<<mi<<"\n";
finddp(ans,vec,d+1,s,mi-1);
finddp(ans,vec,d+1,mi+1,e);
return;
}
bool stt(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
return (a.first<b.first);
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// #ifndef ONLINE_JUDGE
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
// #endif
ll t = 1;
cin >> t;
while (t--)
{
ll n;
cin>>n;
vector<pair<ll,ll> > vec;
for(ll i=0;i<n;i++)
{
ll p;
cin>>p;
vec.push_back(make_pair(p,i));
}
if(n==1)
{
cout<<1<<"\n";
cout<<1<<"\n";
continue;
}
sort(vec.begin(),vec.end(),stt);
// for( auto itr:vec)
// {
// cout<<itr.first<<" " ;
// }
// cout<<"\n";
ll ans=1;
ll temp=vec[0].first;
for(ll i=1;i<n-1;i++)
{
if((vec[i].first+temp)<vec[i+1].first)
{
ans=i+1;
}
temp+=vec[i].first;
}
vector<ll> op;
if(vec[ans-1].first==vec[ans].first)
{
ans--;
}
for(ll i=ans;i<n;i++)
{
op.push_back(vec[i].second);
}
sort(op.begin(),op.end());
cout<<op.size()<<"\n";
for(auto itr :op)
{
cout<<itr+1<<" ";
}
cout<<'\n';
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long num;
string s1, s2;
vector<char> res;
bool comp(char c, char c1) { return c > c1; }
deque<char> q1, q2;
int main() {
cin >> s1 >> s2;
unsigned long long n = s1.size();
sort(s1.begin(), s1.end());
sort(s2.begin(), s2.end(), comp);
for (int i = 0; i < ceil(n * 1.0 / 2.0); i++) q1.push_back(s1[i]);
for (int i = 0; i < n / 2; i++) q2.push_back(s2[i]);
int i = 0;
while (i < n) {
if (i % 2 == 0) {
if (q1.front() >= q2.front()) {
res.push_back(q1.back());
q1.pop_back();
} else {
cout << q1.front();
q1.pop_front();
}
} else {
if (q2.front() <= q1.front()) {
res.push_back(q2.back());
q2.pop_back();
} else {
cout << q2.front();
q2.pop_front();
}
}
i++;
}
for (int i = res.size() - 1; i >= 0; i--) cout << res[i];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf(1010101010);
int k, lo, hi;
string s;
int le;
int main() {
cin >> k >> lo >> hi >> s;
le = ((int)(s).size());
if (lo * k > le || hi * k < le) {
puts("No solution");
return 0;
}
int le1(le / k);
int le2((le + k - 1) / k);
for (int i(0); i < (k + 1); i++)
if (le1 * i + le2 * (k - i) == le) {
int pt(0);
for (int i1(0); i1 < (i); i1++) {
string t;
for (int kk(0); kk < (le1); kk++) t += s[pt], pt++;
cout << t << endl;
}
for (int i2(0); i2 < (k - i); i2++) {
string t;
for (int kk(0); kk < (le2); kk++) t += s[pt], pt++;
cout << t << endl;
}
break;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[1000000], d[1000], d2[900], d3[900];
string art[10000];
string number[20] = {"zero", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine",
"ten", "eleven", "twelve", "thirteen", "fourteen",
"fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
bool bland(string sss) {
string xx = sss;
reverse(sss.begin(), sss.end());
if (xx == sss) return 1;
return 0;
}
int gcd(int aaa, int bbb) { return !bbb ? aaa : gcd(bbb, aaa % bbb); }
int main() {
int n, m, k, z = 0;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] == 1 && m > 0)
m--;
else if (arr[i] == 1 && m == 0)
z++;
if (arr[i] == 2 && k > 0)
k--;
else if (arr[i] == 2 && k == 0) {
if (m > 0)
m--;
else
z++;
}
}
cout << z;
}
| 0 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7fffffffffffffff;
const double eps = 1e-10;
unsigned int seed = 19260817;
const unsigned int _RAND_MAX_ = 4294967295u;
__inline__ __attribute__((always_inline)) unsigned int Rand() {
return seed = seed * 998244353u + 1000000007u;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a > 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(a > b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) bool _cmp(const _Tp &a,
const _Tp &b) {
return abs(a - b) <= eps;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
register char ch(getchar());
bool f(false);
while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (ch >= 48 && ch <= 57)
x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
register char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
register char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 1000005;
int a[N];
int main() {
int n;
long long k;
read(n, k);
long long minn = 1ll * n * (n + 1) / 2ll;
long long _tmp_ = k;
if (k < minn) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; ++i) a[i] = i;
k -= minn;
if (!k) {
printf("%lld\n", _tmp_);
for (int i = 1; i <= n; ++i) printf("%d ", i);
printf("\n");
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
printf("\n");
return 0;
}
for (int i = 1; i <= (n >> 1); ++i) {
int op = n - i + 1;
if (k <= op - i) {
for (int j = i; j <= (n >> 1); ++j) {
if (j + k > (n >> 1)) {
std::swap(a[j], a[j + k]);
printf("%lld\n", _tmp_);
for (int i = 1; i <= n; ++i) printf("%d ", i);
printf("\n");
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
printf("\n");
return 0;
}
}
} else {
k -= op - i;
std::swap(a[i], a[op]);
}
}
printf("%lld\n", _tmp_ - k);
for (int i = 1; i <= n; ++i) printf("%d ", i);
printf("\n");
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char S[2][1000013];
int jump[1000013][20];
void order(int k, int d) {
int where = 0;
for (int i = 0; i < d; i++) {
int cur = i;
while (cur < k) jump[cur][0] = where++, cur += d;
}
for (int j = 1; j < 20; j++)
for (int i = 0; i < k; i++) {
if (jump[i][j - 1] - 1 == -1 || jump[jump[i][j - 1] - 1][j - 1] - 1 == -1)
jump[i][j] = 0;
else
jump[i][j] = jump[jump[i][j - 1] - 1][j - 1];
}
}
int go(int where, int num) {
for (int j = 19; j >= 0; j--)
if (num & (1 << j)) where = jump[where][j] - 1;
return where + 1;
}
int main() {
scanf(" %s%d", &S, &m);
n = strlen(S[0]);
S[1][n] = '\0';
for (int M = 0; M < m; M++) {
int from = M % 2;
int to = 1 - M % 2;
int k, d;
scanf("%d%d", &k, &d);
order(k, d);
for (int i = 0; i < n; i++) {
int where = min(i, k - 1);
int num = 0;
for (int j = 19; j >= 0; j--) {
if (jump[where][j] == 0) continue;
where = jump[where][j] - 1;
num += 1 << j;
}
num += 1;
if (num > n - k - max(0, i - k + 1) + 1) {
num = n - k - max(0, i - k + 1) + 1;
where = n - k + go(min(i, k - 1), num);
} else
where = max(0, i - k + 1) + num - 1;
S[to][where] = S[from][i];
}
printf("%s\n", S[to]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) { return (a < b) ? b : a; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, k;
cin >> n >> m >> k;
long long int ar1[k][2], ar2[k][2];
for (long long int i = 0; i < k; i++) cin >> ar1[i][0] >> ar1[i][1];
for (long long int i = 0; i < k; i++) cin >> ar2[i][0] >> ar2[i][1];
cout << (n - 1) + (m - 1) + n * m << endl;
for (long long int i = 0; i < n - 1; i++) cout << "U";
for (long long int i = 0; i < m - 1; i++) cout << "L";
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++)
if (i == 0)
cout << "R";
else if (i % 2 == 0) {
if (j == 0)
cout << "D";
else
cout << "R";
} else {
if (j == 0)
cout << "D";
else
cout << "L";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 1e5 + 10;
int n, k;
int dd[maxn + 10], ans = 0;
vector<int> e[maxn + 10];
bool dfs(int u, long long s) {
long long t = 0;
if (u > n || s > k) return false;
dd[u] = 1;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
t += dd[v];
}
if (s + t == k) return true;
if (dfs(u + 1, s + t)) return true;
dd[u] = 0;
if (dfs(u + 1, s)) return true;
return false;
}
int main() {
long long s = 0;
memset(dd, 0, sizeof(dd));
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++)
for (int j = 2 * i; j <= n; j += i) e[j].push_back(i);
for (int i = 1; i <= n; i++) s += e[i].size();
if (s < k) return cout << "No", 0;
dfs(1, 0);
for (int i = 1; i <= n; i++) ans += dd[i];
cout << "Yes" << endl << ans << endl;
for (int i = 1; i <= n; i++)
if (dd[i]) cout << i << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> A[2 * 100100];
bool cmp(pair<long long int, long long int> x,
pair<long long int, long long int> y) {
return (x.first + x.second <= y.first + y.second);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int i, n, ans, last;
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i].first >> A[i].second;
}
sort(A, A + n, cmp);
ans = 1, last = 0;
for (i = 1; i < n; i++) {
if (abs(A[last].first - A[i].first) >= A[i].second + A[last].second) {
ans++;
last = i;
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N], b[N];
int n, q;
int LEFT[N], RIGHT[N];
long long query(int l, int r) {
if (l >= r) return 0ll;
int len = r - l;
for (register int i = l; i < r; i++) b[i - l + 1] = abs(a[i + 1] - a[i]);
stack<int> st;
for (register int i = 1; i <= len; i++) {
while (!st.empty() && b[st.top()] <= b[i]) st.pop();
if (!st.empty())
LEFT[i] = st.top();
else
LEFT[i] = 0;
st.push(i);
}
st = stack<int>();
for (register int i = len; i >= 1; i--) {
while (!st.empty() && b[st.top()] < b[i]) st.pop();
if (!st.empty())
RIGHT[i] = st.top();
else
RIGHT[i] = len + 1;
st.push(i);
}
long long ret = 0ll;
for (register int i = 1; i <= len; i++)
ret += b[i] * 1ll * (i - LEFT[i]) * (RIGHT[i] - i);
return ret;
}
signed main() {
cin >> n >> q;
for (register int i = 1; i <= n; i++) cin >> a[i];
while (q--) {
int l, r;
cin >> l >> r;
cout << query(l, r) << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<double, int> > ans;
vector<double> leftv, rightv, rightl;
int n, m;
double a, b;
struct Point {
double x, y;
Point(double a = 0.0, double b = 0.0) : x(a), y(b) {}
};
double getDis(Point pa, Point pb) {
double x = pa.x - pb.x;
double y = pa.y - pb.y;
return sqrt(x * x + y * y);
}
int main() {
scanf("%d%d%lf%lf", &n, &m, &a, &b);
for (int i = 0; i < n; i++) {
double pos;
scanf("%lf", &pos);
leftv.push_back(pos);
}
for (int i = 0; i < m; i++) {
double pos;
scanf("%lf", &pos);
rightv.push_back(pos);
}
for (int i = 0; i < m; i++) {
double dis;
scanf("%lf", &dis);
rightl.push_back(dis);
}
for (int i = 0; i < m; i++) {
int left, right, mid1, mid2;
left = 0;
right = n - 1;
while (true) {
double dis1, dis2;
int minv;
if (left + 2 >= right) {
dis1 = -1;
for (int j = left; j <= right; j++) {
double dis2 = getDis(Point(a, leftv[j]), Point(b, rightv[i])) +
getDis(Point(0, 0), Point(a, leftv[j]));
if (dis1 < 0 || dis2 < dis1) {
minv = j;
dis1 = dis2;
}
}
ans.push_back(make_pair(dis1, minv));
break;
} else {
mid1 = (left + right) / 2;
mid2 = (mid1 + right) / 2;
dis1 = getDis(Point(a, leftv[mid1]), Point(b, rightv[i])) +
getDis(Point(0, 0), Point(a, leftv[mid1]));
dis2 = getDis(Point(a, leftv[mid2]), Point(b, rightv[i])) +
getDis(Point(0, 0), Point(a, leftv[mid2]));
if (dis1 > dis2)
left = mid1;
else
right = mid2;
}
}
}
double dis1 = -1, dis2;
int ansu, ansv;
for (int i = 0; i < ans.size(); i++) {
if (dis1 < 0 || dis1 > ans[i].first + rightl[i]) {
dis1 = ans[i].first + rightl[i];
ansu = ans[i].second + 1;
ansv = i + 1;
}
}
cout << ansu << " " << ansv << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long C[16][16], dp[16][16], k;
int num[16], t;
long long solve(int len) {
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= num[0]; i++) dp[0][i] = C[len][i];
for (int i = 1; i < 16; i++) {
for (int j = 0; j <= len; j++) {
int ans = min(num[i], j);
for (int k = 0; k <= ans; k++) {
dp[i][j] += dp[i - 1][j - k] * C[len - j + k][k];
}
}
}
return dp[15][len];
}
int main() {
for (int i = 0; i < 16; i++) C[i][0] = 1;
for (int i = 1; i < 16; i++)
for (int j = 1; j <= i; j++) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
cin >> k >> t;
for (int i = 0; i < 16; i++) num[i] = t;
int len = 1;
for (;; len++) {
long long tmp = 0;
if (len == 1)
tmp = 15;
else {
for (int j = 1; j < 16; j++) {
num[j]--;
tmp += solve(len - 1);
num[j]++;
}
}
if (k > tmp)
k -= tmp;
else
break;
}
for (int i = len; i > 0; i--) {
if (i == 1) {
for (int j = 0; j < 16; j++) {
if (j == 0 && len == 1) continue;
if (num[j] != 0) k--;
if (k == 0) {
if (j < 10)
cout << j;
else
cout << (char)(j + 'a' - 10);
break;
}
}
break;
}
for (int j = 0; j < 16; j++) {
if (i == len && j == 0) continue;
num[j]--;
long long tmp = solve(i - 1);
if (k > tmp)
k -= tmp;
else {
if (j < 10)
cout << j;
else
cout << (char)(j + 'a' - 10);
break;
}
num[j]++;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) {
return b;
} else {
return gcd(b % a, a);
}
}
int main() {
int n, m;
long long int ara[300000];
long long int a[300000];
cin >> n >> m;
long long int r, prev;
vector<long long int> v;
for (int i = 0; i < n; i++) {
cin >> ara[i];
if (i == 1) {
prev = ara[1] - ara[0];
r = prev;
} else if (i > 1) {
r = gcd(prev, ara[i] - ara[i - 1]);
prev = r;
}
}
int g = -1;
for (int i = 0; i < m; i++) {
cin >> a[i];
if (r % a[i] == 0) {
g = i + 1;
}
}
if (g == -1) {
cout << "NO";
} else {
cout << "YES\n";
cout << ara[0] << " " << g;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int greatestSubarraySum(long long int array[], long long int n);
long long int powerrr(long long int a, long long int b);
void swapp(long long int *a, long long int *b);
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 min(long long int a, long long int b);
long long int max(long long int a, long long int b);
long long int search(long long int arr[], long long int n, long long int k);
string findSum(string str1, string str2);
string findSum(string str1, string str2) {
if (str1.length() > str2.length()) {
string s = str1;
str1 = str2;
str2 = s;
}
string str = "";
int n1 = str1.length(), n2 = str2.length();
reverse(str1.begin(), str1.end());
reverse(str2.begin(), str2.end());
int carry = 0;
for (int i = 0; i < n1; i++) {
int sum = ((str1[i] - '0') + (str2[i] - '0') + carry);
str.push_back(sum % 10 + '0');
carry = sum / 10;
}
for (int i = n1; i < n2; i++) {
int sum = ((str2[i] - '0') + carry);
str.push_back(sum % 10 + '0');
carry = sum / 10;
}
if (carry) str.push_back(carry + '0');
reverse(str.begin(), str.end());
return str;
}
long long int binarySearch(vector<long long> arr, long long int l,
long long int r, long long int x) {
if (r >= l) {
long long int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
long long int greatestSubarraySum(long long int array[], long long int n) {
long long int best = 0, sum = 0;
for (long long int k = 0; k < n; k++) {
sum = max(array[k], sum + array[k]);
best = max(best, sum);
}
return best;
}
long long int modpowerrr(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void swapp(long long int *a, long long int *b) {
long long int temp = *a;
*a = *b;
*b = temp;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int min(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
vector<long long> arr[101][101];
long long int visited[101][101];
long long int curr;
void dfs(long long int x, long long int y, long long int z) {
if (curr == 1) return;
if (visited[z][x]) return;
visited[z][x] = 1;
if (x == y) curr = 1;
for (auto u : arr[z][x]) {
dfs(u, y, z);
if (curr == 1) return;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int a[n * n + 1];
long long int k = (n + 1) * (n + 1);
vector<long long> b[n + 1];
for (long long int i = 1; i < n + 1; i++) {
for (long long int j = 1; j < n + 1; j++) {
if (i % 2)
a[n * (i - 1) + j] = j;
else
a[n * (i - 1) + j] = n - j + 1;
}
}
for (long long int i = 1; i < n * n + 1; i++) {
b[a[i]].push_back(i);
}
for (long long int i = 1; i < n + 1; i++) {
for (long long int j = 0; j < n; j++) cout << b[i][j] << " ";
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> dsu, sz;
vector<bool> used;
vector<vector<long long>> v;
void init(long long n) {
used.resize(n);
dsu.resize(n);
sz.resize(n, 1);
for (long long i = 0; i < n; i++) dsu[i] = i;
}
long long Find(long long a) {
return (dsu[a] == a ? a : dsu[a] = Find(dsu[a]));
}
void Unite(long long a, long long b) {
a = Find(a);
b = Find(b);
if (rand() % 2) swap(a, b);
dsu[b] = a;
sz[a] += sz[b];
}
void Add(long long a, long long n, long long m) {
long long c1 = -1, c2 = -1, c3 = -1, c4 = -1;
if (a % m > 0) c4 = a - 1;
if ((a + 1) % m > 0) c2 = a + 1;
if (a - m >= 0) c1 = a - m;
if (a + m < m * n) c3 = a + m;
used[a] = true;
if (c1 != -1 && used[c1] && Find(a) != Find(c1)) Unite(a, c1);
if (c2 != -1 && used[c2] && Find(a) != Find(c2)) Unite(a, c2);
if (c3 != -1 && used[c3] && Find(a) != Find(c3)) Unite(a, c3);
if (c4 != -1 && used[c4] && Find(a) != Find(c4)) Unite(a, c4);
}
long long delnow = 0, delall;
vector<bool> usedindfs;
void dfs(long long ver, long long n, long long m) {
usedindfs[ver] = true;
long long c1 = -1, c2 = -1, c3 = -1, c4 = -1;
if (ver % m > 0) c4 = ver - 1;
if ((ver + 1) % m > 0) c2 = ver + 1;
if (ver - m >= 0) c1 = ver - m;
if (ver + m < m * n) c3 = ver + m;
if (c1 != -1 && Find(c1) == Find(ver) && !usedindfs[c1]) dfs(c1, n, m);
if (c2 != -1 && Find(c2) == Find(ver) && !usedindfs[c2]) dfs(c2, n, m);
if (c3 != -1 && Find(c3) == Find(ver) && !usedindfs[c3]) dfs(c3, n, m);
if (c4 != -1 && Find(c4) == Find(ver) && !usedindfs[c4]) dfs(c4, n, m);
if (delnow < delall) {
v[ver / m][ver % m] = 0;
delnow++;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
v.resize(n, vector<long long>(m));
init(n * m);
vector<pair<long long, long long>> lens;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> v[i][j];
lens.push_back({v[i][j], i * m + j});
}
}
sort(lens.rbegin(), lens.rend());
vector<long long> eq;
long long len = -1, del = 0, delincomp = 0, ind;
for (long long i = 0; i < lens.size(); i++) {
if (i < lens.size() - 1 && lens[i].first == lens[i + 1].first) {
Add(lens[i].second, n, m);
eq.push_back(lens[i].second);
continue;
}
Add(lens[i].second, n, m);
eq.push_back(lens[i].second);
if (lens[i].first * (i + 1) < k) {
eq.clear();
continue;
}
if (lens[i].first * (i + 1) == k && sz[Find(lens[i].second)] == (i + 1)) {
len = lens[i].first;
break;
} else if (lens[i].first * (i + 1) == k || k % lens[i].first != 0) {
eq.clear();
continue;
}
long long delnum = i + 1 - k / lens[i].first;
bool flag = false;
for (long long j = 0; j < eq.size(); j++) {
if ((i + 1) - sz[Find(eq[j])] <= delnum) {
if ((i + 1) - sz[Find(eq[j])] < delnum)
delincomp = delnum - ((i + 1) - sz[Find(eq[j])]);
flag = true;
len = lens[i].first;
del = delnum;
ind = eq[j];
break;
}
}
if (flag) break;
eq.clear();
}
if (len == -1) {
cout << "NO";
return 0;
}
if (del != 0) {
if (delincomp != 0) {
delall = delincomp;
usedindfs.resize(n * m);
dfs(ind, n, m);
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (v[i][j] < len || Find(i * m + j) != Find(ind))
v[i][j] = 0;
else
v[i][j] = len;
}
}
} else {
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (v[i][j] < len)
v[i][j] = 0;
else
v[i][j] = len;
}
}
}
cout << "YES" << endl;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cout << v[i][j] << " ";
}
cout << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1;
inline char getc() {
return (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class T>
inline void read(T &x) {
char ch;
int f = 1;
x = 0;
while (isspace(ch = getc()))
;
if (ch == '-') ch = getc(), f = -1;
do x = x * 10 + ch - '0';
while (isdigit(ch = getc()));
x *= f;
}
template <class T, class... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <class T>
inline void write(T x) {
static char stk[128];
int top = 0;
if (x == 0) {
putc('0');
return;
}
if (x < 0) putc('-'), x = -x;
while (x) stk[top++] = x % 10, x /= 10;
while (top) putc(stk[--top] + '0');
}
template <class T, class... Args>
inline void write(T x, Args... args) {
write(x);
putc(' ');
write(args...);
}
inline void space() { putc(' '); }
inline void endl() { putc('\n'); }
struct _flush {
~_flush() { flush(); }
} __flush;
}; // namespace io
using io::endl;
using io::flush;
using io::getc;
using io::putc;
using io::read;
using io::space;
using io::write;
const int M = 1000000007;
inline int add(int x, int y) { return x + y >= M ? x + y - M : x + y; }
template <class... Args>
inline int add(int x, int y, Args... args) {
return add(add(x, y), args...);
}
inline int sub(int x, int y) { return x - y < 0 ? x - y + M : x - y; }
inline int mul(int x, int y) { return 1LL * x * y % M; }
template <class... Args>
inline int mul(int x, int y, Args... args) {
return mul(mul(x, y), args...);
}
inline void inc(int &x, int y = 1) {
x += y;
if (x >= M) x -= M;
}
inline void dec(int &x, int y = 1) {
x -= y;
if (x < 0) x += M;
}
inline int power(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = mul(x, x))
if (y & 1) res = mul(res, x);
return res;
}
inline int inv(int x) { return power(x, M - 2); }
const int N = 4005;
int _g[N * 2], *g = _g + N;
int n, m;
struct DP {
int a[N * 2];
int *f;
DP() {
f = a + N;
fill(f - m, f + m + 1, 0);
f[0] = 1;
}
void update(int x) {
fill(g - m, g + m + 1, 0);
for (int i = -m + x; i <= m - x; ++i) g[i - x] = (g[i - x] + f[i]) % M;
for (int i = -m + x; i <= m - x; ++i) g[i + x] = (g[i + x] + f[i]) % M;
for (int i = -m; i <= m; ++i) f[i] = (f[i] + g[i]) % M;
}
void select(int x) {
fill(g - m, g + m + 1, 0);
for (int i = -m + x; i <= m; ++i) g[i - x] = (g[i - x] + f[i]) % M;
for (int i = -m; i <= m - x; ++i) g[i + x] = (g[i + x] + f[i]) % M;
for (int i = -m; i <= m; ++i) f[i] = g[i];
}
void operator=(const DP &r) {
for (int i = -m; i <= m; ++i) f[i] = r.f[i];
}
int query(int x) {
int res = 0;
for (int i = 2 - x; i <= x - 2; ++i) inc(res, f[i]);
return res;
}
};
vector<int> G[N];
int a[N];
bool vis[N];
DP f;
DP stk[20];
int top = 0;
int dfs(int x, int fa) {
vis[x] = true;
for (int v : G[x]) {
if (v == fa) continue;
if (v == 1) return 1;
return dfs(v, x) + 1;
}
return 1;
}
int res = 0;
void solve(int l, int r) {
if (l == r) {
inc(res, f.query(a[l]));
return;
}
stk[top] = f;
++top;
int mid = (l + r) >> 1;
for (int i = l; i <= mid; ++i) f.update(a[i]);
solve(mid + 1, r);
f = stk[top - 1];
for (int i = mid + 1; i <= r; ++i) f.update(a[i]);
solve(l, mid);
--top;
}
void solve2(int l, int r) {
if (l == r) {
inc(res, add(f.f[a[l]], f.f[a[l] - 1], f.f[1 - a[l]], f.f[-a[l]]));
inc(res, add(f.f[a[l]], f.f[a[l] - 1], f.f[1 - a[l]], f.f[-a[l]]));
return;
}
stk[top] = f;
++top;
int mid = (l + r) >> 1;
for (int i = l; i <= mid; ++i) f.select(a[i]);
solve2(mid + 1, r);
f = stk[top - 1];
for (int i = mid + 1; i <= r; ++i) f.select(a[i]);
solve2(l, mid);
--top;
}
int main() {
read(n, m);
for (int i = 1; i <= m; ++i) {
int u, v;
read(u, v);
G[u].push_back(v);
G[v].push_back(u);
}
int cnt = 0;
for (int v : G[1]) {
if (!vis[v]) a[++cnt] = dfs(v, 1) + 1;
}
solve(1, cnt);
res = mul(res, 2);
if ((m & 1) == 0) {
f = DP();
for (int i = 1; i <= cnt; ++i) f.select(a[i]);
inc(res, f.f[0]);
} else {
f = DP();
solve2(1, cnt);
}
write(res), endl();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
for (; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return x * f;
}
struct ed {
int u, to, next, w;
} edge[10100 + 10];
int tot = 0, head[10000 + 10];
int l[10100 + 10], r[10100 + 10], pos[10100 + 10], s1, s2, t, n, m, k;
inline void adde(int u, int v, int w) {
edge[++tot].to = v;
edge[tot].u = u;
edge[tot].next = head[u];
edge[tot].w = w;
head[u] = tot;
}
struct node {
int id;
long long val;
node() {}
node(int iid, long long vval) {
id = iid;
val = vval;
}
bool friend operator<(node a, node b) { return a.val > b.val; }
};
priority_queue<node> q;
long long dis1[10000 + 10], dis2[10000 + 10];
bool vis[10000 + 10];
void DJ(int s, long long *dis) {
while (!q.empty()) q.pop();
for (register int i = 1; i <= n; ++i) dis[i] = 0x3f3f3f3f3f3f3f3fll;
memset(vis, 0, sizeof(vis));
dis[s] = 0;
q.push(node(s, 0));
node u;
int v;
while (!q.empty()) {
u = q.top();
q.pop();
if (vis[u.id]) continue;
vis[u.id] = 1;
for (register int i = head[u.id]; i; i = edge[i].next) {
v = edge[i].to;
if (dis[v] > dis[u.id] + edge[i].w) {
dis[v] = dis[u.id] + edge[i].w;
q.push(node(v, dis[v]));
}
}
}
}
int main() {
n = read(), m = read(), k = read();
s1 = read(), s2 = read(), t = read();
int a, b, c;
for (register int i = 1; i <= m; ++i) {
a = read(), b = read(), c = read();
adde(a, b, c);
}
for (register int i = 1; i <= k; ++i) {
a = read(), b = read();
l[i] = read(), r[i] = read();
adde(a, b, r[i]);
pos[i] = tot;
}
bool flag = 1;
while (flag) {
flag = 0;
DJ(s1, dis1);
DJ(s2, dis2);
for (register int i = 1; i <= k; ++i) {
int now = pos[i];
if (dis1[edge[now].u] <= dis2[edge[now].u] && edge[now].w != l[i]) {
edge[now].w = l[i];
flag = 1;
}
}
}
DJ(s1, dis1);
DJ(s2, dis2);
if (dis1[t] < dis2[t]) {
puts("WIN");
for (register int i = 1; i <= k; ++i) printf("%d ", edge[pos[i]].w);
} else if (dis1[t] == dis2[t]) {
puts("DRAW");
for (register int i = 1; i <= k; ++i) printf("%d ", edge[pos[i]].w);
} else
puts("LOSE");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, wn, hn;
long long aa, bb, cc, dd, tot, ans;
struct node {
long long w, h, c, ww, hh;
} s[2000005];
map<long long, long long> a[2000005];
void init() { freopen("e.in", "r", stdin); }
bool cmp1(const node &a, const node &b) { return a.w < b.w; }
bool cmp2(const node &a, const node &b) { return a.h < b.h; }
long long gcd(long long x, long long y) {
if (!y)
return x;
else
return gcd(y, x % y);
}
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &s[i].w, &s[i].h, &s[i].c);
if (i == 1)
tot = s[i].c;
else
tot = gcd(tot, s[i].c);
}
sort(s + 1, s + n + 1, cmp1);
for (int i = 1; i <= n; i++) {
if (s[i].w == s[i - 1].w)
s[i].ww = s[i - 1].ww;
else
s[i].ww = s[i - 1].ww + 1;
}
for (int i = 1; i <= n; i++)
if (s[i].w != s[i - 1].w) wn++;
sort(s + 1, s + n + 1, cmp2);
for (int i = 1; i <= n; i++) {
if (s[i].h == s[i - 1].h)
s[i].hh = s[i - 1].hh;
else
s[i].hh = s[i - 1].hh + 1;
}
for (int i = 1; i <= n; i++)
if (s[i].h != s[i - 1].h) hn++;
if (wn * hn != n) {
printf("0");
return 0;
}
for (int i = 1; i <= n; i++) {
a[s[i].ww][s[i].hh] = s[i].c;
}
for (int i = 1; i <= hn - 1; i++) {
for (int j = 1; j <= wn - 1; j++) {
aa = a[j][i];
bb = a[j][i + 1];
cc = a[j + 1][i];
dd = a[j + 1][i + 1];
if (aa * dd != bb * cc) {
printf("0");
return 0;
}
}
}
for (int i = 1; i <= trunc(sqrt(tot)); i++) {
if (tot % i == 0) {
ans++;
if (tot / i != i) ans++;
}
}
printf("%I64d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string id(string a, string b) {
string sol;
sol += a[0];
sol += a[1];
sol += b[1];
sol += b[0];
for (long long i = 0; i < 4; i++) {
if (sol[i] == 'A') {
string kek;
for (long long j = 0; j < 4; j++) {
char ch = sol[(i + j) % 4];
if (ch != 'X') kek += ch;
}
return kek;
}
}
assert(0);
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
string a, b, c, d;
cin >> a >> b >> c >> d;
cout << ((id(a, b) == id(c, d)) ? "YES" : "NO") << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long x, y;
void extendedeuclidean(long long a, long long b) {
if (b == 0) {
x = 1;
y = 0;
return;
}
extendedeuclidean(b, a % b);
long long cx = y;
long long cy = x - (a / b) * y;
x = cx;
y = cy;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
if (n > 1) {
cout << "1 1\n";
extendedeuclidean(1, n);
cout << x * (-1 * a[0] % n) << "\n";
a[0] += x * (-1 * a[0] % n);
cout << "2 " << n << "\n";
for (long long i = 1; i < n; i++) {
extendedeuclidean(n - 1, n);
cout << x * (-1 * a[i] % n) * (n - 1) << " ";
a[i] += x * (-1 * a[i] % n) * (n - 1);
}
cout << "\n1 " << n << "\n";
for (long long i = 0; i < n; i++) {
cout << -1 * a[i] << " ";
}
} else {
cout << "1 1\n0\n"
<< "1 1\n0\n"
<< "1 1\n"
<< -1 * a[0];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bitset<1010> possible;
bitset<1010> rob;
int a;
int main() {
int n, r;
scanf("%d", &n);
possible.set();
for (int p = 0; p < n; p++) {
scanf("%d", &r);
rob.reset();
for (int i = 0; i < r; i++) {
scanf("%d", &a);
rob[a] = 1;
}
possible &= rob;
}
for (int i = 1; i < 101; i++)
if (possible[i]) printf("%d ", i);
printf("\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void swap(T *xp, T *yp) {
T temp = *xp;
*xp = *yp;
*yp = temp;
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void solve() {
long long int n;
cin >> n;
long long int a[n];
vector<long long int> ans;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < n; i++) {
if (i == 0) {
ans.push_back(a[i]);
continue;
} else if (i == n - 1) {
ans.push_back(a[i]);
continue;
} else if (((a[i - 1] < a[i]) && (a[i] > a[i + 1])) ||
((a[i - 1] > a[i]) && (a[i] < a[i + 1]))) {
ans.push_back(a[i]);
}
}
cout << ans.size() << endl;
for (long long int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
cout << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using li = long long;
li c[100][100];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
li k;
cin >> n >> k;
vector<li> a(n);
int first = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] != 0 && first == -1) first = i;
if (a[i] >= k) {
cout << "0\n";
return 0;
}
}
{
vector<li> b;
copy(a.begin() + first, a.end(), back_inserter(b));
a = b;
}
n = a.size();
if (n >= 4) {
int answer = 0;
while (true) {
answer++;
for (int i = 1; i < n; i++) {
a[i] += a[i - 1];
if (a[i] >= k) {
goto breakAll;
}
}
}
breakAll:;
cout << answer << endl;
} else if (n >= 3) {
li low = 0, high = 2e9;
while (low + 1 != high) {
li m = (low + high) / 2;
long double sumld =
a[0] * (long double)((m + 1) * (long double)m / 2) + a[1] * m + a[2];
if (sumld / k >= 2) {
high = m;
continue;
}
li sum = a[0] * ((m + 1) * m / 2) + a[1] * m + a[2];
if (sum >= k)
high = m;
else
low = m;
}
cout << high << endl;
} else {
li answer = (k - a[1] + a[0] - 1) / a[0];
cout << answer << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmin(T &x, const T &y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
bool chkmax(T &x, const T &y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
T read() {
T x = 0, f = 1;
char c = getchar();
while ((c < '0') || (c > '9')) {
if (c == '-') f = -1;
c = getchar();
}
while ((c >= '0') && (c <= '9'))
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
template <typename T>
void write(T x, char c) {
static char t[25];
static int tlen;
t[tlen = 1] = c;
if (x < 0) x = -x, putchar('-');
do t[++tlen] = (x % 10) ^ 48;
while (x /= 10);
while (tlen) putchar(t[tlen--]);
}
int n, m;
int main() {
n = read<int>(), m = read<int>();
if (n >= 31)
write(m, '\n');
else {
int tmp = 1;
for (int i = (int)(1), iend = (int)(n); i <= iend; ++i) tmp *= 2;
write(m % tmp, '\n');
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M, rl[510], rw[510], rh[510], wl[510], ww[510], wp[510], result;
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> rl[i] >> rw[i] >> rh[i];
cin >> M;
for (int i = 0; i < M; i++) cin >> wl[i] >> ww[i] >> wp[i];
for (int i = 0; i < N; i++) {
int min_cost = 1000000;
for (int j = 0; j < M; j++)
if (wl[j] >= rh[i]) {
int k = wl[j] / rh[i] * ww[j], p = (rl[i] + rw[i]) * 2;
min_cost = min(min_cost, (p / k + (p % k != 0)) * wp[j]);
}
result += min_cost;
}
cout << result << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int sum = 0;
long long int a[n];
string s;
vector<long long int> v;
map<long long int, long long int> mp;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
set<long long int> st;
for (auto x : mp) {
if (st.find(x.second) == st.end())
st.insert(x.second);
else {
for (long long int i = x.second - 1; i >= 1; i--) {
if (st.find(i) == st.end()) {
st.insert(i);
break;
}
}
}
}
long long int ans = 0;
for (auto t : st) {
ans += t;
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long int gcd(long long int x, long long int y) {
return x % y == 0 ? y : gcd(y, x % y);
}
inline long long int lcm(long long int x, long long int y) {
return x * (y / gcd(x, y));
}
inline long long int powmod(long long int a, long long int b,
long long int mod) {
long long int res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
inline long long int mulmod(long long int a, long long int b, long long int c) {
if (!b) return 0;
long long int x = mulmod(a, b / 2, c);
if (b & 1) return (x + x + a) % c;
return (x + x) % c;
}
long long int dp[1000005], g[1000005];
long long int func(long long int n) {
long long int ans = 1;
while (n != 0) {
if (n % 10 != 0) ans = ans * (n % 10);
n /= 10;
}
return ans;
}
long long int comp(long long int n) {
if (n < 10) return n;
if (dp[n] != -1) return dp[n];
return (dp[n] = comp(func(n)));
}
vector<long long int> v[11];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, -1, sizeof dp);
for (int i = 1; i <= 1000000; i++) {
g[i] = comp(i);
assert(g[i] >= 0 && g[i] <= 9);
v[g[i]].push_back(i);
}
long long int q, l, r, k;
cin >> q;
while (q--) {
cin >> l >> r >> k;
long long int rx = upper_bound(v[k].begin(), v[k].end(), r) - v[k].begin();
long long int lx =
upper_bound(v[k].begin(), v[k].end(), l - 1) - v[k].begin() - 1;
rx = rx - lx - 1;
cout << rx << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
int mark[N];
int tree[2 * N];
int size;
int nums[N];
unordered_map<int, int> ida, volta;
void update(int index) {
index += size;
while (index > 0) {
tree[index]--;
index >>= 1;
}
}
long long int query(int l, int r) {
l += size;
r += size + 1;
long long int ans = 0;
while (l < r) {
if (l & 1) ans += tree[l++];
if (r & 1) ans += tree[--r];
l >>= 1;
r >>= 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", nums + i);
}
for (int i = n - 1; i >= 0; i--) {
volta[nums[i]]++;
mark[volta[nums[i]]]++;
}
size = N;
for (int i = 0; i < N; i++) {
tree[i + N] = mark[i];
}
for (int i = N - 1; i >= 1; i--) {
tree[i] = tree[2 * i] + tree[2 * i + 1];
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
ida[nums[i]]++;
update(volta[nums[i]]);
volta[nums[i]]--;
ans += query(0, ida[nums[i]] - 1);
}
cout << ans;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.