solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int A[200000 + 5];
int main() {
int n, L, x, y;
scanf("%d%d%d%d", &n, &L, &x, &y);
for (int i = 0; i < n; ++i) scanf("%d", &A[i]);
bool enx = 0, eny = 0;
for (int i = 0; i < n; ++i) {
if (binary_search(A, A + n, A[i] + x)) enx = 1;
if (binary_search(A, A + n, A[i] + y)) eny = 1;
}
if (enx && eny)
puts("0");
else if (enx && !eny) {
puts("1");
printf("%d\n", y);
} else if (!enx && eny) {
puts("1");
printf("%d\n", x);
} else {
bool ok = 0;
for (int i = 0; i < n; ++i) {
if (binary_search(A, A + n, A[i] + x + y)) {
puts("1");
printf("%d\n", A[i] + x);
ok = 1;
break;
}
}
if (!ok) {
int dif = y - x;
for (int i = 0; i < n; ++i) {
if (binary_search(A, A + n, A[i] + dif)) {
if (A[i] + y <= L) {
puts("1");
printf("%d\n", A[i] + y);
ok = 1;
break;
}
if (A[i] + dif - y >= 0) {
puts("1");
printf("%d\n", A[i] + dif - y);
ok = 1;
break;
}
}
}
}
if (!ok) {
puts("2");
printf("%d %d\n", x, y);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[2100], z, k = 0;
pair<int, int> q[2100];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i], q[i] = make_pair(a[i], i + 1);
}
sort(q, q + n);
for (int i = 0; i < n; i++)
if (q[i].first == q[i + 1].first) k++;
cerr << k << endl;
;
for (int i = 0; i < n; i++) cerr << q[i].first << " " << q[i].second << endl;
if (k < 2) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << q[i].second << " ";
cout << endl;
for (int i = 0; i < n; i++)
if (q[i].first == q[i + 1].first) {
swap(q[i].second, q[i + 1].second);
z = i + 1;
break;
}
for (int i = 0; i < n; i++) cout << q[i].second << " ";
cout << endl;
for (int i = z; i < n; i++)
if (q[i].first == q[i + 1].first) {
swap(q[i].second, q[i + 1].second);
break;
}
for (int i = 0; i < n; i++) cout << q[i].second << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int sum = 0;
std::vector<std::vector<long long int>> adj(2000000);
long long int cnt[2], vis[2000000];
void dfs(long long int v, long long int c) {
vis[v] = 1;
if (adj[v].size() == 1) {
if (c % 2 == 0)
cnt[0]++;
else {
cnt[1]++;
}
return;
}
long long int p = 0, i;
for (i = 0; i < adj[v].size(); i++) {
if (adj[adj[v][i]].size() == 1) {
p++;
}
}
for (i = 0; i < adj[v].size(); i++) {
if (!vis[adj[v][i]]) dfs(adj[v][i], c + 1);
}
if (p > 0) sum = sum - (p - 1);
}
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long int n, i, in = -1;
cin >> n;
for (i = 0; i < n - 1; i++) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
if (adj[x].size() > 1) in = x;
if (adj[y].size() > 1) in = y;
}
sum = n - 1;
dfs(in, 0);
long long int mini = 1;
if (cnt[0] > 0 && cnt[1] > 0) {
mini = 3;
}
cout << mini << " " << sum << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
ios_base::sync_with_stdio(0);
cin >> N;
string K;
cin >> K;
int zm = N;
for (int i = 1; i < N; i++) {
if (K[i] != K[i - 1]) {
zm--;
if (i < N - 1) K[i] = K[i + 1];
}
}
cout << zm;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int cnt = 1;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
m[x]++;
}
for (auto i : m) {
while (i.second > 0 && i.first >= cnt) {
i.second--;
cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3f;
const long long M = 1e9 + 7;
const long long maxn = 1e5 + 7;
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
int n, m, q, l, r, i, j;
int a[11][maxn];
struct node {
int lnum[11], rnum[11], ans, l, r;
} tree[maxn * 4];
int fa[44], to[44];
int getfather(int x) {
if (fa[x] == x) return x;
return fa[x] = getfather(fa[x]);
}
node merge(node x, node y) {
node z;
int i, num, cnt;
for (i = 0; i < n * 4; i++) fa[i] = i, to[i] = -1;
num = x.ans + y.ans;
cnt = 0;
for (i = 0; i < n; i++)
if (a[i][x.r] == a[i][y.l]) {
int fx = getfather(x.rnum[i]), fy = getfather(y.lnum[i] + n * 2);
if (fx != fy) {
fa[fx] = fy;
num--;
}
}
cnt = 0;
for (i = 0; i < n; i++) {
int f;
f = getfather(x.lnum[i]);
if (to[f] == -1) to[f] = cnt++;
z.lnum[i] = to[f];
f = getfather(y.rnum[i] + n * 2);
if (to[f] == -1) to[f] = cnt++;
z.rnum[i] = to[f];
}
z.ans = num;
z.l = x.l;
z.r = y.r;
return z;
}
void build(int x, int l, int r) {
tree[x].l = l;
tree[x].r = r;
if (l == r) {
int i, t = 0;
for (i = 0; i < n; i++) {
tree[x].lnum[i] = tree[x].rnum[i] = t;
if (a[i][l] != a[i + 1][l]) t++;
}
tree[x].ans = t;
return;
}
int mid = (l + r) / 2;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
tree[x] = merge(tree[x << 1], tree[x << 1 | 1]);
}
node query(int x, int l, int r, int L, int R) {
if (l <= L && R <= r) return tree[x];
int mid = (L + R) / 2;
if (mid >= r) return query(x << 1, l, r, L, mid);
if (l > mid) return query(x << 1 | 1, l, r, mid + 1, R);
return merge(query(x << 1, l, r, L, mid),
query(x << 1 | 1, l, r, mid + 1, R));
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (i = 0; i < n; i++)
for (j = 1; j <= m; j++) scanf("%d", &a[i][j]);
build(1, 1, m);
while (q--) {
scanf("%d%d", &l, &r);
printf("%d\n", query(1, l, r, 1, m).ans);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int M = 2 * 1000000000;
long long int i, j;
bool sortbysecdesc(const pair<int, int> &a, const pair<int, int> &b) {
return a.second > b.second;
}
long long int mod(long long a, long long b) { return (a % b + b) % b; }
long long int isPrime(long long int n) {
if (n <= 3) return (1);
if (n % 2 == 0 || n % 3 == 0) return (0);
for (i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return (0);
return (1);
}
long long int smallestDivisor(long long int n) {
if (n % 2 == 0) return 2;
for (i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
return n;
}
long long int countDivisors(long long int n) {
long long int cnt = 0;
for (i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
return cnt;
}
long long maxPrimeFactors(long long n) {
long long maxPrime = -1;
while (n % 2 == 0) {
maxPrime = 2;
n >>= 1;
}
for (i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
maxPrime = i;
n = n / i;
}
}
if (n > 2) maxPrime = n;
return maxPrime;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
long long int tt = 1;
while (tt--) {
long long int n;
cin >> n;
vector<long long int> v;
v.push_back(0);
long long int sum = 0, z = 1;
long long int a[200005] = {0};
while (n--) {
long long int k;
cin >> k;
if (k == 2) {
long long int temp;
cin >> temp;
v.push_back(temp);
sum += temp;
z++;
double avg = (double)sum / z;
cout << fixed << setprecision(10) << avg << "\n";
} else if (k == 1) {
long long int a1, x1;
cin >> a1 >> x1;
if (a1 <= z) {
a[a1 - 1] += x1;
sum += a1 * x1;
} else {
a[z - 1] += x1;
sum += z * x1;
}
double avg = (double)sum / z;
cout << fixed << setprecision(10) << avg << "\n";
} else {
sum -= v[v.size() - 1];
sum -= a[z - 1];
a[z - 2] += a[z - 1];
a[z - 1] = 0;
z--;
v.pop_back();
double avg = (double)sum / z;
cout << fixed << setprecision(10) << avg << "\n";
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, l;
vector<long long int> kx, ky, r, cx, cy;
int a, b;
unsigned long long int d, e;
vector<unsigned long long int> cc;
vector<vector<unsigned long long int> > c;
int main() {
cin >> n >> m >> k;
l = m / 64 + (m % 64 > 0);
kx.resize(n);
ky.resize(n);
r.resize(m);
cx.resize(m);
cy.resize(m);
cc.assign(l, 0);
c.assign(n, cc);
for (int i = 0; i < n; i++) cin >> kx[i] >> ky[i];
for (int i = 0; i < m; i++) cin >> r[i] >> cx[i] >> cy[i];
for (int i = 0; i < n; i++)
for (int j = m - 1; j >= 0; j--) {
c[i][j / 64] *= 2;
if ((kx[i] - cx[j]) * (kx[i] - cx[j]) +
(ky[i] - cy[j]) * (ky[i] - cy[j]) <
r[j] * r[j])
c[i][j / 64]++;
}
for (int i = 0; i < k; i++) {
cin >> a >> b;
a--;
b--;
d = 0;
for (int j = 0; j < l; j++) {
e = c[a][j] ^ c[b][j];
while (e > 0) {
if (e % 2) d++;
e = e >> 1;
}
}
cout << d << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 9;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n][2];
long long one = 0;
for (long long i = 0; i < n; i++) cin >> a[i][0], one += a[i][0];
for (long long i = 0; i < n; i++) cin >> a[i][1];
long long two = 0, ans = INT_MAX;
for (long long i = 0; i < n; i++) {
one -= a[i][0];
ans = min(ans, max(one, two));
two += a[i][1];
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define int long long
#define IOS std::ios::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL);cout.precision(dbl::max_digits10);
#define pb push_back
#define mod 1000000007ll //998244353ll
#define lld long double
#define mii unordered_map<int, int>
#define mci unordered_map<char, int>
#define msi map<string, int>
#define pii pair<int, int>
#define mp make_pair
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define forr(i,x,y) for(int i=x; i<y; i++)
#define fill(a,b) memset(a, b, sizeof(a))
#define vi vector<int>
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define setbits(x) __builtin_popcountll(x)
#define print2d(dp,n,m) for(int i=0;i<=n;i++){for(int j=0;j<=m;j++)cout<<dp[i][j]<<" ";cout<<"\n";}
typedef std::numeric_limits< double > dbl;
using namespace std;
const long long N=200005, INF=2000000000000000000;
lld pi=3.1415926535897932;
void solve(){
int n;
cin>>n;
string s;
cin>>s;
int cnt1=0,cnt2=0;
for(int i=0;i<n;i++){
if(s[i]=='T' ){
cnt1++;
}
else{
cnt2++;
}
if(cnt1<cnt2){
cout<<"NO\n";
return;
}
}
cnt1=0,cnt2=0;
for(int i=n-1;i>=0;i--){
if(s[i]=='T' ){
cnt1++;
}
else{
cnt2++;
}
if(cnt1<cnt2){
cout<<"NO\n";
return;
}
}
if(cnt1!=2*cnt2){
cout<<"NO\n";
return;
}
cout<<"YES\n";
}
int32_t main()
{
IOS;
int t=1;
cin>>t;
while(t--){
solve();
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int d[] = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14,
1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51,
1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1, 52,
2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4, 267};
int n;
int main() {
scanf("%d", &n);
printf("%d\n", d[n - 1]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, h, m, sum = 0;
cin >> n >> h >> m;
for (int i = 1; i <= n; i++) mp[i] = h;
while (m--) {
int l, r, x;
cin >> l >> r >> x;
for (int i = l; i <= r; i++)
if (x < mp[i]) mp[i] = x;
}
for (int i = 1; i <= n; i++) sum += ((mp[i]) * (mp[i]));
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
long long int a[n], s = 0;
double sum;
map<long long int, long long int> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
s += 2 * a[i];
}
sum = (s * 1.0) / n;
if (floor(sum) - sum != 0) {
cout << "0\n";
return;
}
long long int count = 0;
for (int i = 0; i < n; i++) {
long long int data = sum - a[i];
m[a[i]]--;
count += m[data];
}
cout << count << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1501;
int main() {
int n, i, j, a[MAX_N], s, max_cnt = 0, max_sum = -1e9, r, cur_cnt;
map<int, vector<pair<int, int>>> subsum;
vector<pair<int, int>> ans;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s = 0;
for (j = i; j > 0; j--) {
s += a[j];
subsum[s].push_back({j, i});
}
}
for (auto it = subsum.begin(); it != subsum.end(); it++) {
cur_cnt = 0;
sort(it->second.begin(), it->second.end(),
[](const pair<int, int>& a, const pair<int, int>& b) {
if (a.second != b.second) return a.second < b.second;
return a.first < b.first;
});
r = -1;
for (auto& pos : it->second) {
if (r < pos.first) {
r = pos.second;
cur_cnt++;
}
}
if (max_cnt < cur_cnt) {
max_cnt = cur_cnt;
max_sum = it->first;
}
}
r = -1;
printf("%d\n", max_cnt);
for (auto& pos : subsum[max_sum]) {
if (r < pos.first) {
r = pos.second;
printf("%d %d\n", pos.first, pos.second);
}
}
return 0;
};
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solution() {
long long n;
cin >> n;
vector<long long> arr(n);
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
long long index = 0;
for (long long i = n - 2; i >= 0; i--) {
if (arr[i + 1] > arr[i]) {
index = i + 1;
break;
}
}
for (long long i = index - 1; i >= 0; i--) {
if (arr[i + 1] < arr[i]) {
index = i + 1;
cout << index << endl;
return;
}
}
cout << 0 << endl;
return;
}
int main() {
long long t;
cin >> t;
while (t--) {
solution();
}
}
| 2 |
// God put a smile upon your face <3
#include <bits/stdc++.h>
#define slld(longvalue) scanf("%lld", &longvalue)
#define ll long long
#define ull unsigned long long
#define pll pair < long long, long long >
#define fastio ios_base:: sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define pb push_back
#define bug printf("BUG\n")
#define mxlld LLONG_MAX
#define mnlld -LLONG_MAX
#define mxd 2e8
#define mnd -2e8
#define pi 3.14159265359
using namespace std;
bool check(ll n, ll pos)
{
return n & (1LL << pos);
}
ll Set(ll n, ll pos)
{
return n = n | (1LL << pos);
}
const ll N = 400005;
struct info
{
ll x, y, id;
} arr[N];
pll tree[N * 4];
struct segtree
{
ll n;
void treeinit(ll node, ll b, ll e)
{
if(b == e)
{
tree[node] = {arr[b].y, arr[b].id};
return;
}
ll left = node * 2;
ll right = (node * 2) + 1;
ll mid = (b + e) / 2;
treeinit(left, b, mid);
treeinit(right, mid + 1, e);
tree[node] = min(tree[left], tree[right]);
}
void init(ll _n)
{
n = _n;
treeinit(1,1,n);
}
void treeupdate(ll node, ll b, ll e, ll i, ll val)
{
if(i > e || i < b)
{
return;
}
if(b == i && e == i)
{
tree[node].first = val;
return;
}
ll left = node * 2;
ll right = (node * 2) + 1;
ll mid = (b + e) / 2;
treeupdate(left, b, mid, i, val);
treeupdate(right, mid + 1, e, i, val);
tree[node] = min(tree[left], tree[right]);
}
void update(ll i, ll val)
{
treeupdate(1,1,n,i,val);
}
pll treequery(ll node, ll b, ll e, ll i, ll j)
{
if(i > e || j < b)
{
return {mxlld,-1};
}
if(b >= i && e <= j)
{
return tree[node];
}
ll left = node * 2;
ll right = (node * 2) + 1;
ll mid = (b + e) / 2;
pll p1 = treequery(left, b, mid, i, j);
pll p2 = treequery(right, mid + 1, e,i, j);
return min(p1,p2);
}
pll query(ll x, ll y)
{
return treequery(1,1,n,x,y);
}
} seg;
bool comp(info a, info b)
{
if(a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
ll ans[N];
vector < pll > v[N];
int main()
{
ll i, j, k, l, m, n, o, r, q;
ll testcase;
ll input, flag, tag;
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
slld(testcase);
for(ll cs = 1; cs <= testcase; cs++)
{
cin >> n;
for(ll i = 1; i <= n; i++)
{
ll h, w;
cin >> h >> w;
arr[i * 2] = {h,w,i};
arr[i * 2 - 1] = {w,h,i};
ans[i] = -1;
v[i].clear();
}
sort(arr + 1, arr + 1 + (n * 2), comp);
for(ll i = 1; i <= (n * 2); i++)
{
v[arr[i].id].push_back({i, arr[i].y});
}
seg.init(n * 2);
ll ptr = 0;
for(ll i = 1; i <= (n * 2); i++)
{
pll ask = seg.query(1,i);
// cout << arr[i].x << " " << arr[i].y << " is " << ask.first << " " << ask.second << "\n";
}
for(ll i = 2; i <= (n * 2); i++)
{
// for(ll ii = 1; ii <= (n * 2); ii++)
// {
// pll ask = seg.query(1,ii);
//
//// cout << arr[ii].x << " " << arr[ii].y << " isisis " << ask.first << " " << ask.second << "\n";
// }
if(ans[arr[i].id] != -1) continue;
while(arr[ptr + 1].x < arr[i].x) ptr++;
if(v[arr[i].id].front().first != i)
{
seg.update(v[arr[i].id].front().first, mxlld);
}
pll ask = seg.query(1,ptr);
// cout << arr[i].x << " " << arr[i].y << " " << i << " " << ask.first << " " << ask.second << " " << ptr << "\n";
if(ask.first < arr[i].y)
{
ans[arr[i].id] = ask.second;
}
if(v[arr[i].id].front().first != i)
{
seg.update(v[arr[i].id].front().first, v[arr[i].id].front().second) ;
}
}
for(ll i = 1; i <= n; i++) cout << ans[i] << " ";
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int p[N];
double ans[N * N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
int t = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++) {
if (p[j] > p[i]) t++;
}
}
ans[0] = 0, ans[1] = 1;
for (int i = 2; i <= t; i++) ans[i] = 4 + ans[i - 2];
printf("%f\n", ans[t]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long tc = 1;
cin >> tc;
while (tc--) {
long long n, m;
cin >> n >> m;
long long arr[n][m];
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) cin >> arr[i][j];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++)
if ((i + j) % 2 != arr[i][j] % 2) arr[i][j]++;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cout << arr[i][j] << " ";
cout << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 200005;
const long long jzm = 1e9 + 7;
long long read() {
long long x = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x * flag;
}
long long n, ans, sum, l[M], r[M], q[M], E[M];
long long qkpow(long long a, long long b) {
long long r = 1;
while (b > 0) {
if (b & 1) r = r * a % jzm;
a = a * a % jzm;
b >>= 1;
}
return r;
}
long long calc(long long i) {
long long ret = 0;
if (i > 1) {
long long t =
min(r[i], min(r[i - 1], r[i + 1])) - max(l[i], max(l[i - 1], l[i + 1]));
ret = max(0ll, t *
qkpow((r[i] - l[i]) * (r[i - 1] - l[i - 1]) % jzm *
(r[i + 1] - l[i + 1]) % jzm,
jzm - 2) %
jzm);
}
return (1 - q[i] - q[i + 1] + ret) % jzm;
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) l[i] = read();
for (long long i = 1; i <= n; i++) {
r[i] = read() + 1;
long long R = min(r[i], r[i - 1]), L = max(l[i], l[i - 1]);
q[i] = max(0ll,
(R - L) *
qkpow((r[i] - l[i]) * (r[i - 1] - l[i - 1]) % jzm, jzm - 2) %
jzm);
E[i] = (1 - q[i] + jzm) % jzm;
sum = (sum + E[i]) % jzm;
}
for (long long i = 1; i <= n; i++) {
long long tmp = sum;
for (long long j = max(1ll, i - 1); j <= min(n, i + 1); j++)
tmp = (tmp - E[j]) % jzm;
ans = (ans + E[i] * tmp + E[i]) % jzm;
if (i > 1) ans = (ans + calc(i - 1)) % jzm;
if (i < n) ans = (ans + calc(i)) % jzm;
}
printf("%d\n", (ans + jzm) % jzm);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
int n;
cin>>n;
int arr[n];
for(int i=0;i<n;i++){
cin>>arr[i];
}
int array[n];
memset(array,0,sizeof(array));
int k=0;
for(int i=0;i<n;i++){
if(arr[i]==(i+1)){
k++;
}
}
if(k==n){
cout<<"0"<<"\n";
continue;
}
for(int i=0;i<n;i++){
if(arr[i]!=(i+1)){
array[i]=1;
}
}
int c=0;
for(int i=0;i<n;i++){
if(arr[i]==(n-i)){
c++;
}
}
if(arr[0]==n && arr[n-1]==1){
cout<<3<<"\n";
continue;
}
if(array[0]==1 && array[n-1]==1){
cout<<2<<"\n";
}
else cout<<1<<"\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 12e5 + 10;
const long long M = 1e5 + 10;
long long n, m;
long long t[M], l[M], r[M], q[M << 2];
long long sum[N], tag[N], rev[N];
inline long long read() {
long long x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
inline void pushup(long long rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; }
inline void build(long long l, long long r, long long rt) {
sum[rt] = 0;
rev[rt] = 0;
tag[rt] = -1;
if (l == r) return;
long long mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
pushup(rt);
}
inline void pushdown(long long l, long long r, long long rt) {
long long mid = (l + r) >> 1;
if (tag[rt] != -1) {
tag[rt << 1] = tag[rt];
tag[rt << 1 | 1] = tag[rt];
rev[rt << 1] = 0;
rev[rt << 1 | 1] = 0;
if (tag[rt]) {
sum[rt << 1] = mid - l + 1;
sum[rt << 1 | 1] = r - mid;
} else {
sum[rt << 1] = 0;
sum[rt << 1 | 1] = 0;
}
tag[rt] = -1;
}
if (rev[rt]) {
if (tag[rt << 1] != -1)
tag[rt << 1] ^= 1;
else
rev[rt << 1] ^= 1;
if (tag[rt << 1 | 1] != -1)
tag[rt << 1 | 1] ^= 1;
else
rev[rt << 1 | 1] ^= 1;
sum[rt << 1] = mid - l + 1 - sum[rt << 1];
sum[rt << 1 | 1] = r - mid - sum[rt << 1 | 1];
rev[rt] = 0;
}
}
inline void update(long long t, long long L, long long R, long long l,
long long r, long long rt) {
if (L <= l && r <= R) {
if (l == r) {
if (t == 1)
sum[rt] = 1;
else if (t == 2)
sum[rt] = 0;
else
sum[rt] ^= 1;
} else {
if (t == 1) {
tag[rt] = 1;
rev[rt] = 0;
sum[rt] = r - l + 1;
}
if (t == 2) {
tag[rt] = 0;
rev[rt] = 0;
sum[rt] = 0;
}
if (t == 3) {
if (tag[rt] != -1)
tag[rt] ^= 1;
else
rev[rt] ^= 1;
sum[rt] = r - l + 1 - sum[rt];
}
}
return;
}
pushdown(l, r, rt);
long long mid = (l + r) >> 1;
if (L <= mid) update(t, L, R, l, mid, rt << 1);
if (mid < R) update(t, L, R, mid + 1, r, rt << 1 | 1);
pushup(rt);
}
inline long long query(long long l, long long r, long long rt) {
if (l == r) return l;
pushdown(l, r, rt);
long long mid = (l + r) >> 1;
if (sum[rt << 1] < mid - l + 1)
return query(l, mid, rt << 1);
else
return query(mid + 1, r, rt << 1 | 1);
}
signed main() {
m = read();
q[++n] = 1;
for (long long i = 1; i <= m; i++) {
t[i] = read(), l[i] = read(), r[i] = read();
q[++n] = l[i], q[++n] = r[i], q[++n] = r[i] + 1;
}
sort(q + 1, q + 1 + n);
n = unique(q + 1, q + 1 + n) - (q + 1);
build(1, n, 1);
for (long long i = 1; i <= m; i++) {
l[i] = lower_bound(q + 1, q + 1 + n, l[i]) - q;
r[i] = lower_bound(q + 1, q + 1 + n, r[i]) - q;
update(t[i], l[i], r[i], 1, n, 1);
printf("%lld\n", q[query(1, n, 1)]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int SI = 1 << 21 | 1;
char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
int f, t;
inline void flush() { fwrite(OB, 1, OS - OB, stdout), OS = OB; }
inline void pc(char x) {
*OS++ = x;
if (OS == OT) flush();
}
template <class I>
inline void rd(I &x) {
for (f = 1, c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin),
IS == IT ? EOF : *IS++)
: *IS++);
c < '0' || c > '9';
c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin),
IS == IT ? EOF : *IS++)
: *IS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15),
c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin),
IS == IT ? EOF : *IS++)
: *IS++))
;
x *= f;
}
template <class I>
inline void rda(I *a, int &n) {
for (int i = 1; i <= n; i++) rd(a[i]);
}
inline void rds(char *s, int &x) {
for (c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin),
IS == IT ? EOF : *IS++)
: *IS++);
c < 33 || c > 126;
c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin),
IS == IT ? EOF : *IS++)
: *IS++))
;
for (x = 0; c >= 33 && c <= 126;
s[++x] = c, c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin),
IS == IT ? EOF : *IS++)
: *IS++))
;
s[x + 1] = '\0';
}
template <class I>
inline void print(I x, char k = '\n') {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) ch[++t] = x % 10 + '0', x /= 10;
while (t) pc(ch[t--]);
pc(k);
}
inline void prints(string s) {
int x = s.length();
while (t < x) pc(s[t++]);
pc('\n'), t = 0;
}
struct Flush {
~Flush() { flush(); }
} flusher;
} // namespace io
using io::print;
using io::prints;
using io::rd;
using io::rda;
using io::rds;
const int N = 1e5 + 7;
const long long inf = 4e18;
int n;
long long x[N], y[N], z[N], X, Y, Z, mx, mxx, mxy, mxz, mn, mnx, mny, mnz;
inline bool pd(long long o) {
mx = mxx = mxy = mxz = inf, mn = mnx = mny = mnz = -inf;
for (int i = 1; i <= n; i++)
(mx = mx < o + x[i] + y[i] + z[i] ? mx : o + x[i] + y[i] + z[i]),
(mxx = mxx < o - x[i] + y[i] + z[i] ? mxx : o - x[i] + y[i] + z[i]),
(mxy = mxy < o + x[i] - y[i] + z[i] ? mxy : o + x[i] - y[i] + z[i]),
(mxz = mxz < o + x[i] + y[i] - z[i] ? mxz : o + x[i] + y[i] - z[i]),
(mn = mn > -o + x[i] + y[i] + z[i] ? mn : -o + x[i] + y[i] + z[i]),
(mnx = mnx > -o - x[i] + y[i] + z[i] ? mnx : -o - x[i] + y[i] + z[i]),
(mny = mny > -o + x[i] - y[i] + z[i] ? mny : -o + x[i] - y[i] + z[i]),
(mnz = mnz > -o + x[i] + y[i] - z[i] ? mnz : -o + x[i] + y[i] - z[i]);
for (int i = 0; i < 2; i++) {
long long l = mn + ((mn & 1) ^ i), r = mx - ((mx & 1) ^ i);
long long lx = mnx + ((mnx & 1) ^ i), rx = mxx - ((mxx & 1) ^ i);
long long ly = mny + ((mny & 1) ^ i), ry = mxy - ((mxy & 1) ^ i);
long long lz = mnz + ((mnz & 1) ^ i), rz = mxz - ((mxz & 1) ^ i);
if (l > r || lx > rx || ly > ry || lz > rz) continue;
long long a = lx, b = ly, c = lz;
if (a + b + c > r) continue;
if (a + b + c < l) a = rx < l - b - c ? rx : l - b - c;
if (a + b + c < l) b = ry < l - a - c ? ry : l - a - c;
if (a + b + c < l) c = rz < l - a - b ? rz : l - a - b;
if (a + b + c < l) continue;
return X = (b + c) >> 1, Y = (a + c) >> 1, Z = (a + b) >> 1, 1;
}
return 0;
}
inline void solve() {
rd(n);
for (int i = 1; i <= n; i++) rd(x[i]), rd(y[i]), rd(z[i]);
long long l = 0, r = inf;
while (l <= r) {
long long mid = (l + r) >> 1;
if (pd(mid))
r = mid - 1;
else
l = mid + 1;
}
print(X, ' '), print(Y, ' '), print(Z);
}
int main() {
int T;
rd(T);
while (T--) solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int maxn = 100005;
using namespace std;
inline int rd() {
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;
}
int num[50];
int main() {
int n = rd(), q = rd();
for (int i = 1; i <= n; i++) {
int x = rd(), cnt = 0;
while (x) cnt++, x >>= 1;
num[cnt - 1]++;
}
while (q--) {
int a = rd(), ans = 0;
int t = log(a) / log(2);
for (int i = 35; i >= 0; i--) {
int x = (1 << i);
int s = a / x;
if (num[i] >= s)
ans += s, a -= s * x;
else
ans += num[i], a -= num[i] * x;
}
if (a != 0)
puts("-1");
else
printf("%d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
void solve() {
int n;
cin >> n;
vector<int> v(n), s(n);
for (int i = 0; i < n; i++) cin >> v[i], s[i] = v[i];
sort(s.begin(), s.end());
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] != v[i]) cnt++;
}
if (cnt > 2)
cout << "NO" << '\n';
else
cout << "YES" << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
;
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> row, col;
vector<vector<long long>> a;
int n, m;
int main() {
scanf("%d %d", &n, &m);
row.resize(n, 0ll);
col.resize(m, 0ll);
a.resize(n, vector<long long>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%lld", &a[i][j]);
row[i] += a[i][j];
col[j] += a[i][j];
}
}
if (n <= 4) {
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += row[i];
}
cout << ans << endl;
return 0;
}
if (m <= 4) {
long long ans = 0;
for (int i = 0; i < m; i++) {
ans += col[i];
}
cout << ans << endl;
return 0;
}
long long mx = -1;
vector<long long> temp(row.begin(), row.end());
sort(temp.begin(), temp.end(), greater<long long>());
long long ans = 0;
for (int i = 0; i < 4; i++) {
ans += temp[i];
}
mx = max(mx, ans);
temp.clear();
temp.assign(col.begin(), col.end());
sort(temp.begin(), temp.end(), greater<long long>());
ans = 0;
for (int i = 0; i < 4; i++) {
ans += temp[i];
}
mx = max(mx, ans);
for (int i = 0; i < m; i++) {
ans = col[i];
temp.clear();
temp.assign(row.begin(), row.end());
for (int j = 0; j < n; j++) {
temp[j] -= a[j][i];
}
sort(temp.begin(), temp.end(), greater<long long>());
for (int j = 0; j < 3; j++) {
ans += temp[j];
}
mx = max(mx, ans);
}
for (int i = 0; i < n; i++) {
ans = row[i];
temp.clear();
temp.assign(col.begin(), col.end());
for (int j = 0; j < m; j++) {
temp[j] -= a[i][j];
}
sort(temp.begin(), temp.end(), greater<long long>());
for (int j = 0; j < 3; j++) {
ans += temp[j];
}
mx = max(mx, ans);
}
if (m <= n) {
for (int i = 0; i < m - 1; i++) {
for (int j = i + 1; j < m; j++) {
ans = col[i] + col[j];
long long h1 = 0, h2 = 0;
for (int k = 0; k < n; k++) {
row[k] -= a[k][i];
row[k] -= a[k][j];
if (row[k] > h1) {
h2 = h1;
h1 = row[k];
} else if (row[k] > h2) {
h2 = row[k];
}
row[k] += a[k][i];
row[k] += a[k][j];
}
ans += (h1 + h2);
mx = max(mx, ans);
}
}
} else {
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
ans = row[i] + row[j];
long long h1 = 0, h2 = 0;
for (int k = 0; k < m; k++) {
col[k] -= a[i][k];
col[k] -= a[j][k];
if (col[k] > h1) {
h2 = h1;
h1 = col[k];
} else if (col[k] > h2) {
h2 = col[k];
}
col[k] += a[i][k];
col[k] += a[j][k];
}
ans += (h1 + h2);
mx = max(mx, ans);
}
}
}
cout << mx << endl;
}
| 6 |
#include <bits/stdc++.h>
using std::cerr;
using std::endl;
const int N = 1e5 + 10;
int n, K, P, inv[N], sum[N], ans;
std::map<int, int> map;
void divide(int l, int r, int dep) {
if (l == r || dep == K) {
return ++map[r - l + 1], void();
}
int mid = (l + r) >> 1;
divide(l, mid, dep + 1);
divide(mid + 1, r, dep + 1);
}
inline long long calc(int x, int y) {
int ret = 1ll * x * y % P * inv[2] % P;
for (int i = 1; i <= x; ++i) ret = (ret - sum[i + y] + sum[i]) % P;
ret = (ret % P + P) % P;
return ret;
}
int main() {
scanf("%d %d %d", &n, &K, &P);
divide(1, n, 1);
inv[1] = sum[1] = 1;
for (int i = 2, lim = std::max(4, n); i <= lim; ++i) {
inv[i] = P - 1ll * P / i * inv[P % i] % P;
sum[i] = (sum[i - 1] + inv[i]) % P;
}
for (auto m : map) {
ans = (ans + 1ll * m.first * (m.first - 1) % P * inv[4] % P * m.second) % P;
ans = (ans + calc(m.first, m.first) * m.second % P * (m.second - 1) % P *
inv[2]) %
P;
}
for (auto m1 : map)
for (auto m2 : map)
if (m1.first < m2.first)
ans = (ans + calc(m1.first, m2.first) * m1.second % P * m2.second) % P;
std::cout << ans << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, mod = 1e9 + 7;
int u[N], k;
int vis[N], pr[N], cnt, n;
long long pw(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long inv[N];
int main() {
scanf("%d%d", &n, &k);
inv[0] = 1;
inv[1] = pw(k, mod - 2);
for (int i = 2; i <= n; i++) {
inv[i] = inv[i - 1] * inv[1] % mod;
}
u[1] = 1;
for (int i = 2; i <= n; i++) {
if (!vis[i]) pr[++cnt] = i, u[i] = -1;
for (int j = 1; j <= cnt && 1LL * pr[j] * i <= n; j++) {
vis[i * pr[j]] = 1;
if (i % pr[j]) {
u[i * pr[j]] = -u[i];
} else {
u[i * pr[j]] = 0;
break;
}
}
}
long long ans = 0;
for (int i = 1; i <= n - 1; i++) {
for (int s2 = i; s2 <= 2 * n - 1; s2 += i) {
for (int s = s2; s <= 2 * n - 1; s += s2) {
long long gcd = s / s2;
long long l = max(1LL, s2 - (n - 1) / gcd),
r = min(s2 - 1LL, (n - 1) / gcd);
if (l <= r)
ans += (r / i - (l - 1) / i) * inv[n - max(s - (long long)n, gcd)] %
mod * (u[i] + mod) % mod;
ans %= mod;
}
}
}
printf("%lld", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cin.ignore();
string s;
cin >> s;
string str = s.substr(0, n);
s.erase(0, n);
sort(s.begin(), s.end());
sort(str.begin(), str.end());
int lon = 0, be = 0;
for (int i = 0; i < n; i++) {
if (s[i] > str[i])
lon++;
else if (s[i] < str[i])
be++;
}
if (be == n || lon == n)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, mic[100100], i, f, t, mid, mn, a, b;
vector<pair<int, int> > vec;
pair<int, int> par;
int main() {
scanf("%d", &n);
mn = n;
for (i = 0; i < n; i++) {
scanf("%d %d", &a, &b);
par.first = a;
par.second = b;
vec.push_back(par);
}
sort(vec.begin(), vec.end());
mic[0] = 0;
for (i = 0; i < n; i++) {
f = 0;
t = i - 1;
a = vec[i].first - vec[i].second;
while (f <= t) {
mid = (f + t) / 2;
if (a <= vec[mid].first)
t = mid - 1;
else
f = mid + 1;
}
mic[i + 1] = mic[t + 1] + 1;
if (n - mic[i + 1] < mn) mn = n - mic[i + 1];
}
printf("%d\n", mn);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1003;
const int K = 8;
const int OO = N;
int memo[N][1 << K];
bool vis[N][1 << K];
vector<int> occurrences[K];
int offset[N];
int arr[N];
int n;
int k;
int Solve(int ind, int mask) {
if (mask == (1 << K) - 1) {
return 0;
}
if (ind == n) {
return -OO;
}
int &ret = memo[ind][mask];
if (vis[ind][mask]) {
return ret;
}
vis[ind][mask] = true;
ret = Solve(ind + 1, mask);
for (int j = k; j < k + 2 && ((mask >> arr[ind]) & 1) == 0; ++j) {
if (occurrences[arr[ind]].size() > offset[ind] + j - 1) {
ret = max(ret, j + Solve(occurrences[arr[ind]][offset[ind] + j - 1] + 1,
mask | (1 << arr[ind])));
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
set<int> st;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
--arr[i];
st.insert(arr[i]);
offset[i] = occurrences[arr[i]].size();
occurrences[arr[i]].push_back(i);
}
int res = st.size();
int low = 1, high = N / 8, mid;
while (low <= high) {
mid = (low + high) / 2;
memset(vis, false, sizeof vis);
k = mid;
int tmp = max(0, Solve(0, 0));
if (tmp != 0) {
res = max(res, tmp);
low = mid + 1;
} else {
high = mid - 1;
}
}
cout << res;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int cnt = 0;
cin >> n;
string s;
char c;
while (n != 0) {
s = to_string(n);
c = s[0];
for (int i = 0; i < s.size(); i++) {
if (s[i] > c) c = s[i];
}
n -= stoi(to_string(c)) - 48;
cnt++;
}
cout << cnt;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[4010], b[4010];
long long dp[4010][4010];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
a[i] = a[i] - i;
b[i] = a[i];
}
sort(b, b + n);
for (int j = 0; j < n; j++) dp[0][j] = abs((double)(a[0] - b[j]));
for (int i = 1; i < n; i++) {
long long minn = dp[i - 1][0];
for (int j = 0; j < n; j++) {
minn = min(minn, dp[i - 1][j]);
dp[i][j] = minn + abs((double)(a[i] - b[j]));
}
}
printf("%I64d\n", *min_element(dp[n - 1], dp[n - 1] + n));
return 0;
}
| 7 |
#include <bits/stdc++.h>
class LazyPropSegtree {
std::vector<int> st, lazy;
int N;
void push(int w, int L, int R) {
if (R - L > 1) {
lazy[w * 2 + 1] += lazy[w];
lazy[w * 2 + 2] += lazy[w];
}
st[w] += lazy[w];
lazy[w] = 0;
}
void pull(int w, int L, int R) {
st[w] = std::max(st[w * 2 + 1], st[w * 2 + 2]);
}
void build(int w, int L, int R) {
if (R - L == 1) {
st[w] = 0;
} else {
int M = (L + R) / 2;
build(w * 2 + 1, L, M);
build(w * 2 + 2, M, R);
pull(w, L, R);
}
}
void update_add(int w, int L, int R, int a, int b, int v) {
push(w, L, R);
if (a >= R || b <= L) return;
if (a <= L && b >= R) {
lazy[w] = v;
push(w, L, R);
} else {
int M = (L + R) / 2;
update_add(w * 2 + 1, L, M, a, b, v);
update_add(w * 2 + 2, M, R, a, b, v);
pull(w, L, R);
}
}
int query_max(int w, int L, int R, int a, int b) {
push(w, L, R);
if (a >= R || b <= L) return std::numeric_limits<int>::min();
if (a <= L && b >= R) {
return st[w];
} else {
int M = (L + R) / 2;
return std::max(query_max(w * 2 + 1, L, M, a, b),
query_max(w * 2 + 2, M, R, a, b));
}
}
public:
LazyPropSegtree(int N) : st(N * 4), lazy(N * 4), N(N) { build(0, 0, N); }
void update_add(int a, int b, int v) { update_add(0, 0, N, a, b, v); }
int query_max(int a, int b) { return query_max(0, 0, N, a, b); }
};
int ls[200005];
int rs[200005];
int ts[200005];
std::vector<int> bucket[2][400005];
int main() {
int N;
scanf("%d", &N);
std::map<int, int> cps;
for (int i = 0; i < N; i++) {
scanf("%d %d %d", &ls[i], &rs[i], &ts[i]);
cps[ls[i]], cps[rs[i]];
}
int last = 0;
for (auto& it : cps) {
it.second = ++last;
}
for (int i = 0; i < N; i++) {
bucket[ts[i] - 1][cps[rs[i]]].push_back(cps[ls[i]]);
}
LazyPropSegtree dp[2] = {LazyPropSegtree(last + 1),
LazyPropSegtree(last + 1)};
for (int i = 1; i <= last; i++) {
for (int t = 0; t < 2; t++) {
for (int l : bucket[t][i]) {
dp[t].update_add(0, l, 1);
}
dp[t ^ 1].update_add(i, i + 1, dp[t].query_max(0, i));
}
}
printf("%d\n",
std::max(dp[0].query_max(0, last + 1), dp[1].query_max(0, last + 1)));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x[100][100];
int y[100][100];
int iact = -1, jact = -1;
int movi[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int movj[] = {-1, 0, 1, -1, 1, -1, 0, 1};
vector<pair<int, int> > sol;
void insertasol() { sol.push_back(pair<int, int>(iact, jact)); }
int absolut(int x) {
if (x < 0) return -x;
return x;
}
pair<int, int> distancia(int i1, int j1, int i2, int j2) {
return pair<int, int>(max(absolut(i1 - i2), absolut(j1 - j2)),
absolut(i1 - i2) + absolut(j1 - j2));
}
void siguiente(int i, int j, int &inext, int &jnext, int ifin, int jfin) {
pair<int, int> minimo(1000000000, 0);
for (int k = 0; k < 8; k++) {
int ii = i + movi[k];
int jj = j + movj[k];
if (x[ii][jj] and distancia(ii, jj, ifin, jfin) < minimo) {
minimo = distancia(ii, jj, ifin, jfin);
inext = ii;
jnext = jj;
}
}
}
void buscavalor(int &i, int &j, int val) {
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (not(i == iact and j == jact) and x[i][j] == val) return;
}
void elimina(int ifin, int jfin) {
int iini, jini;
buscavalor(iini, jini, y[ifin][jfin]);
x[iini][jini] = 0;
while (not(iini == ifin and jini == jfin)) {
int nextiini, nextjini;
siguiente(iini, jini, nextiini, nextjini, ifin, jfin);
while (not(iact == nextiini and jact == nextjini)) {
int nextiact, nextjact;
siguiente(iact, jact, nextiact, nextjact, nextiini, nextjini);
swap(x[iact][jact], x[nextiact][nextjact]);
iact = nextiact;
jact = nextjact;
insertasol();
}
swap(x[iact][jact], x[iini][jini]);
swap(iact, iini);
swap(jact, jini);
insertasol();
}
}
int main() {
cin >> n >> m;
multiset<int> sx;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> x[i][j];
sx.insert(x[i][j]);
}
}
multiset<int> sy;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> y[i][j];
sy.insert(y[i][j]);
}
}
if (not(sx == sy)) {
cout << -1 << endl;
exit(0);
}
if (n == 1) {
int j1 = 1;
while (x[1][j1] == y[1][j1]) j1++;
int j2 = m;
while (x[1][j2] == y[1][j2]) j2--;
{
vector<int> vx, vy;
for (int j = j1 + 1; j <= j2; j++) vx.push_back(x[1][j]);
for (int j = j1; j <= j2 - 1; j++) vy.push_back(y[1][j]);
if (vx == vy and x[1][j1] == y[1][j2]) {
cout << j2 - j1 << endl;
cout << 1 << " " << j1 << endl;
for (int j = j1 + 1; j <= j2; j++) cout << 1 << " " << j << endl;
exit(0);
}
}
{
vector<int> vx, vy;
for (int j = j1; j <= j2 - 1; j++) vx.push_back(x[1][j]);
for (int j = j1 + 1; j <= j2; j++) vy.push_back(y[1][j]);
if (vx == vy and y[1][j1] == x[1][j2]) {
cout << j2 - j1 << endl;
cout << 1 << " " << j2 << endl;
for (int j = j2 - 1; j >= j1; j--) cout << 1 << " " << j << endl;
exit(0);
}
}
cout << -1 << endl;
exit(0);
} else if (m == 1) {
int i1 = 1;
while (x[i1][1] == y[i1][1]) i1++;
int i2 = n;
while (x[i2][1] == y[i2][1]) i2--;
{
vector<int> vx, vy;
for (int i = i1 + 1; i <= i2; i++) vx.push_back(x[i][1]);
for (int i = i1; i <= i2 - 1; i++) vy.push_back(y[i][1]);
if (vx == vy and x[i1][1] == y[i2][1]) {
cout << i2 - i1 << endl;
cout << i1 << " " << 1 << endl;
for (int i = i1 + 1; i <= i2; i++) cout << i << " " << 1 << endl;
exit(0);
}
}
{
vector<int> vx, vy;
for (int i = i1; i <= i2 - 1; i++) vx.push_back(x[i][1]);
for (int i = i1 + 1; i <= i2; i++) vy.push_back(y[i][1]);
if (vx == vy and y[i1][1] == x[i2][1]) {
cout << i2 - i1 << endl;
cout << i2 << " " << 1 << endl;
for (int i = i2 - 1; i >= i1; i--) cout << i << " " << 1 << endl;
exit(0);
}
}
cout << -1 << endl;
exit(0);
}
int iaux, jaux;
buscavalor(iaux, jaux, y[1][1]);
iact = iaux;
jact = jaux;
insertasol();
for (int i = n; i >= 3; i--)
for (int j = m; j >= 1; j--) elimina(i, j);
for (int j = m; j >= 3; j--) {
elimina(2, j);
elimina(1, j);
}
if (not(iact == 2 and jact == 2)) {
swap(x[iact][jact], x[2][2]);
iact = 2;
jact = 2;
insertasol();
}
if (x[1][1] == y[iact][jact]) {
swap(x[1][1], x[iact][jact]);
iact = 1;
jact = 1;
insertasol();
} else if (x[2][1] == y[iact][jact]) {
swap(x[2][1], x[iact][jact]);
iact = 2;
jact = 1;
insertasol();
} else {
swap(x[1][2], x[iact][jact]);
iact = 1;
jact = 2;
insertasol();
}
if (not(iact == 1 and jact == 2)) {
swap(x[iact][jact], x[1][2]);
iact = 1;
jact = 2;
insertasol();
}
if (x[1][1] == y[iact][jact]) {
swap(x[1][1], x[iact][jact]);
iact = 1;
jact = 1;
insertasol();
} else {
swap(x[2][1], x[iact][jact]);
iact = 2;
jact = 1;
insertasol();
}
if (not(iact == 1 and jact == 1)) {
swap(x[iact][jact], x[1][1]);
iact = 1;
jact = 1;
insertasol();
}
cout << int(sol.size()) - 1 << endl;
for (int i = 0; i < int(sol.size()); i++)
cout << sol[i].first << " " << sol[i].second << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int test, k, a[200], b[200], c[200], cnt, cnt1;
long long n, x, v, V, X, Y, second, ansa, ansb, ansc, q[200][200], Min, p[200];
map<long long, pair<pair<long long, long long>, pair<long long, long long> > >
Mp;
inline void rec1(int pos, long long val) {
if (pos == k + 1) {
if (val + v / val < Min) {
Min = val + v / val;
X = val;
Y = v / val;
}
return;
}
for (int i = 0; i <= c[pos]; ++i) {
if (val * q[pos][i] <= V) rec1(pos + 1, val * q[pos][i]);
}
}
inline void rec(int pos, long long val) {
if (pos == k + 1) {
v = n / val;
double t = sqrt(v + 0.0);
if (second + 1e-6 < v + 2 * val * t) return;
V = (long long)(sqrt(v + 0.0) + 1e-5);
for (int i = 1; i <= k; ++i) c[i] = a[i] - b[i];
Min = 8 * (long long)(1e18);
rec1(1, 1);
if (v + val * (X + Y) < second) {
second = v + val * (X + Y);
ansa = X;
ansb = Y;
ansc = val;
}
return;
}
for (int i = 0; i <= a[pos]; ++i) {
b[pos] = i;
if (val * q[pos][i] <= x) rec(pos + 1, val * q[pos][i]);
}
}
int main() {
scanf("%d", &test);
for (int it = 0; it < test; ++it) {
scanf("%d", &k);
second = 8 * (long long)(1e18);
n = 1;
cnt = 0;
cnt1 = 0;
for (int i = 1; i <= k; ++i) {
scanf("%I64d%d", &p[i], &a[i]);
q[i][0] = 1;
for (int j = 1; j <= a[i]; ++j) {
q[i][j] = q[i][j - 1] * p[i];
}
n *= q[i][a[i]];
}
if (Mp.count(n)) {
printf("%I64d %I64d %I64d %I64d\n", Mp[n].first.first, Mp[n].first.second,
Mp[n].second.first, Mp[n].second.second);
continue;
}
x = (long long)(pow(n, 1.0 / 3) + 1e-5);
rec(1, 1);
Mp[n] = make_pair(make_pair(2 * second, ansa), make_pair(ansb, ansc));
printf("%I64d %I64d %I64d %I64d\n", 2 * second, ansa, ansb, ansc);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int n, a;
vector<long long int> val, card;
long long int m[305];
long long int dp[305][(1 << 9)];
long long int sizeo;
long long int rec(long long int wai, long long int mask) {
if (__builtin_popcount(mask) == sizeo) return 0;
if (wai == -1) return INT_MAX;
if (dp[wai][mask] != -1) return dp[wai][mask];
long long int gonnaret = INT_MAX;
gonnaret = min(
{gonnaret, rec(wai - 1, mask | m[wai]) + val[wai], rec(wai - 1, mask)});
return dp[wai][mask] = gonnaret;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long int j = 0; j < 2; j++) {
for (long long int i = 0; i < n; i++) {
cin >> a;
if (!j)
card.push_back(a);
else
val.push_back(a);
}
}
long long int ans = INT_MAX;
for (long long int i = 0; i < n; i++) {
vector<long long int> pfactors;
long long int t = card[i];
for (long long int j = 2; j * j <= t; j++) {
if (!(t % j)) {
pfactors.push_back(j);
while (!(t % j)) t /= j;
}
}
if (t > 1) pfactors.push_back(t);
sizeo = pfactors.size();
for (long long int j = 0; j < n; j++) {
m[j] = 0;
for (long long int ka = 0; ka < sizeo; ka++) {
if ((card[j] % pfactors[ka])) m[j] |= (1 << ka);
}
}
memset(dp, -1, sizeof dp);
ans = min(ans, rec(n - 1, 0) + val[i]);
}
if (ans != INT_MAX)
cout << ans << '\n';
else
cout << -1 << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int sum[maxn * 19], ls[maxn * 19], rs[maxn * 19], rt[maxn];
int li[maxn], ri[maxn], has[maxn], pre[maxn], pi[maxn], cnt[maxn];
int n, cur, tot;
int fin(int x) { return x == pre[x] ? x : pre[x] = fin(pre[x]); }
void unite(int x, int y) { pre[fin(x)] = fin(y); }
void update(int l, int r, int &rt, int pre, int pos, int val) {
rt = ++tot;
ls[rt] = ls[pre], rs[rt] = rs[pre], sum[rt] = sum[pre] + val;
if (l == r) return;
int mid = (l + r >> 1);
if (pos <= mid)
update(l, mid, ls[rt], ls[pre], pos, val);
else
update(mid + 1, r, rs[rt], rs[pre], pos, val);
}
int query(int l, int r, int rt, int pre, int L, int R) {
if (l >= L && r <= R) return sum[rt] - sum[pre];
int mid = (l + r >> 1), ret = 0;
if (L <= mid) ret += query(l, mid, ls[rt], ls[pre], L, R);
if (R > mid) ret += query(mid + 1, r, rs[rt], rs[pre], L, R);
return ret;
}
void dfs(int l, int r, int rt, int pre) {
if (sum[rt] - sum[pre] == 0) return;
if (l == r) {
unite(cur, has[r]);
return;
}
int mid = (l + r >> 1);
dfs(l, mid, ls[rt], ls[pre]);
dfs(mid + 1, r, rs[rt], rs[pre]);
}
void Query(int l, int r, int rt, int pre, int L, int R) {
if (sum[rt] - sum[pre] == 0) return;
if (l >= L && r <= R) {
dfs(l, r, rt, pre);
return;
}
int mid = (l + r >> 1);
if (L <= mid) Query(l, mid, ls[rt], ls[pre], L, R);
if (R > mid) Query(mid + 1, r, rs[rt], rs[pre], L, R);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &li[i], &ri[i]);
pi[li[i]] = ri[i], has[ri[i]] = i;
}
int lim = n << 1;
for (int i = 1; i <= lim; ++i) {
rt[i] = rt[i - 1];
if (!pi[i]) continue;
update(1, lim, rt[i], rt[i - 1], pi[i], 1);
}
int ret = 0;
for (int i = 1; i <= n; ++i) {
int l = li[i] + 1, r = ri[i] - 1;
if (l > r || ret > n - 1) continue;
cnt[i] = query(1, lim, rt[r], rt[l - 1], min(ri[i] + 1, lim), lim);
ret += cnt[i];
}
if (ret != n - 1)
printf("NO\n");
else {
for (int i = 1; i <= n; ++i) pre[i] = i;
for (int i = 1; i <= n; ++i) {
int l = li[i] + 1, r = ri[i] - 1;
if (l > r) continue;
cur = i;
Query(1, lim, rt[r], rt[l - 1], min(ri[i] + 1, lim), lim);
}
int cnt = 0;
for (int i = 1; i <= n; ++i) cnt += pre[i] == i;
printf("%s\n", cnt == 1 ? "YES" : "NO");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005, mod = 1e9 + 7;
const int MAX = 100000000;
const int LMT = 10000;
long long sum, sum1, cnt, ans, ans2, flag, maxi = -1, mini = INT_MAX, len;
int n, m, t, tc, ind;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, x;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
int f = upper_bound(a, a + n, a[i] + 5) - a - 1;
ans = max(ans, (long long)f - i + 1);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
const int maxm = 1e6 + 5;
int n, k, a[maxn];
map<int, int> dp;
vector<int> vec;
void bfs() {
queue<int> q;
while (!q.empty()) q.pop();
for (auto u : vec) {
dp[u] = 1;
q.push(u);
}
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == 0) {
printf("%d\n", dp[u]);
return;
}
for (auto v : vec) {
if (dp[v + u] == 0) {
dp[v + u] = dp[u] + 1;
q.push(v + u);
}
}
}
}
void solve() {
scanf("%d%d", &n, &k);
int flag = 0;
for (int i = 0; i < k; i++) {
int tmp;
scanf("%d", &tmp);
a[tmp] = 1;
if (tmp <= n) flag |= 1;
if (tmp >= n) flag |= 2;
}
if (flag != 3) {
puts("-1");
return;
}
if (n == 0) {
puts("1");
return;
}
for (int i = 0; i <= 1000; i++)
if (a[i]) vec.push_back(n - i);
bfs();
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int a[100007];
string b1;
pair<int, int> kj(int k) {
int mx = -inf, mn = inf;
for (int i = k; i >= k - 4; i--) {
mx = max(a[i], mx);
mn = min(a[i], mn);
}
return make_pair(mx, mn);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
cin >> b1;
bool f = true;
int k = 0;
int lmax = inf, lmin = -inf, rmax = inf, rmin = -inf;
pair<int, int> t;
for (int i = 4; i < n; i++) {
if (!f) {
k++;
if (k == 4) {
f = true;
k = 0;
}
continue;
}
t = kj(i);
int mx = t.first, mn = t.second;
if (b1[i] != b1[i - 1]) {
if (b1[i] == '1') {
lmin = max(lmin, mx + 1);
} else {
rmax = min(rmax, mn - 1);
}
f = false;
} else {
if (b1[i] == '1') {
rmin = max(rmin, mn);
} else {
lmax = min(lmax, mx);
}
}
}
cout << lmin << ' ' << rmax << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, sol;
vector<vector<long long int> > A;
vector<bool> v;
vector<long long int> fact(200009);
long long int factorial(long long int a) {
if (a == 1) return 1;
if (fact[a] != 0) return fact[a];
fact[a] = (factorial(a - 1) * a) % 998244353;
return fact[a];
}
void count(int i) {
if (v[i]) return;
v[i] = true;
long long int len = A[i].size();
sol = (sol * fact[len]) % 998244353;
for (long long int j = 0; j < len; j++) {
count(A[i][j]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
sol = n;
fact[1] = 1;
factorial(n + 1);
A = vector<vector<long long int> >(n + 1, vector<long long int>());
v = vector<bool>(n + 1, false);
for (long long int i = 0; i < n - 1; i++) {
long long int a, b;
cin >> a >> b;
A[a].push_back(b);
A[b].push_back(a);
}
count(1);
cout << sol;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<pair<int, int> > S;
vector<pair<int, int> > v;
double dis(pair<int, int> a, pair<int, int> b) {
return sqrt((a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j) {
if (i <= n && j <= m) S.insert(make_pair(i, j));
if (n - i >= 0 && j <= m) S.insert(make_pair(n - i, j));
if (i <= n && m - j >= 0) S.insert(make_pair(i, m - j));
if (n - i >= 0 && m - j >= 0) S.insert(make_pair(n - i, m - j));
}
for (set<pair<int, int> >::iterator it = S.begin(); it != S.end(); ++it)
v.push_back(*it);
vector<pair<int, int> > sol;
double r = -1;
for (int i = 0; i < v.size(); ++i)
for (int j = 0; j < v.size(); ++j)
if (i != j)
for (int k = 0; k < v.size(); ++k)
if (i != k && j != k)
for (int l = 0; l < v.size(); ++l)
if (i != l && j != l && k != l) {
double cr = dis(v[i], v[j]) + dis(v[j], v[k]) + dis(v[k], v[l]);
if (cr > r) {
r = cr;
sol.clear();
sol.push_back(v[i]);
sol.push_back(v[j]);
sol.push_back(v[k]);
sol.push_back(v[l]);
}
}
for (int i = 0; i < sol.size(); ++i) {
printf("%d %d\n", sol[i].first, sol[i].second);
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef int s32;
typedef unsigned int u32;
typedef long long s64;
typedef unsigned long long u64;
int main() {
//ifstream cin("input.txt");
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
s64 n, k;
cin >> n >> k;
vector<s64> H(n);
for (int i = 0; i < n; i++) {
cin >> H[i];
}
int ind = -1;
while (k--) {
int i;
for (i = 0; i < n - 1 && H[i] >= H[i + 1]; i++) {}
if (i < n - 1) {
H[i]++;
ind = i + 1;
}
else {
ind = -1;
break;
}
}
cout << ind << "\n";
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
void pv(vector<int> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
cout << "" << endl;
}
void pa(int a[], int n, int p) {
for (int i = p; i < n + p; ++i) {
cout << a[i] << " ";
}
cout << "" << endl;
}
const double pi = 3.141592653589793238;
const int inf = 1000000;
int find(string s) {
int l = s.size(), temp = 0, ans = 0, fn;
int dpf[l], dpb[l], mx = 0, pos[l], mi = 0;
for (int i = (int)0; i <= (int)l - 1; i += (int)1) dpb[i] = INT_MAX;
for (int i = (int)0; i <= (int)l - 1; i += (int)1) {
if (i == 0) {
if (s[i] == '(') {
dpf[i] = 1;
} else {
dpf[i] = -1;
}
} else {
if (s[i] == '(') {
dpf[i] = dpf[i - 1] + 1;
} else {
dpf[i] = dpf[i - 1] - 1;
}
}
if (dpf[i] <= mi) {
pos[i] = 1;
mi = dpf[i];
} else
pos[i] = 0;
}
for (int i = (int)l - 1; i >= (int)0; i -= (int)1) {
if (i == l - 1) {
if (s[i] == '(')
dpb[i] = 1;
else
dpb[i] = -1;
} else {
if (s[i] == '(') {
dpb[i] = dpb[i + 1] + 1;
} else {
dpb[i] = dpb[i + 1] - 1;
}
}
}
for (int i = (int)l - 1; i >= (int)0; i -= (int)1) {
if (i == 0) {
if (dpb[i] >= mx && dpb[i] == 0) ans++;
} else {
if (dpb[i] >= mx) {
if (dpb[i] + dpf[i - 1] == 0 && pos[i - 1]) {
ans++;
}
mx = max(dpb[i], mx);
}
}
}
return ans;
}
void solve() {
int n, ans = -5, r, temp;
cin >> n;
string s;
cin >> s;
int l = s.size();
for (int i = (int)0; i <= (int)n - 1; i += (int)1) {
for (int j = (int)0; j <= (int)n - 1; j += (int)1) {
swap(s[i], s[j]);
temp = find(s);
if (temp > ans) {
l = i + 1;
r = j + 1;
ans = temp;
}
swap(s[i], s[j]);
}
}
cout << ans << endl;
cout << l << " " << r << endl;
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
}
| 6 |
#include <bits/stdc++.h>
int main() {
unsigned int n, h, k, a;
long long r(0), s(0);
std::ios::sync_with_stdio(false);
std::scanf("%u%u%u", &n, &h, &k);
while (0 < n--) {
std::scanf("%u", &a);
if (h < r + a) ++s, r = 0;
s += (r + a) / k;
r = (r + a) % k;
}
s += 0 < r;
std::cout << s << std::endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::min;
int next[100010][30], dp[300][300][300], len[5];
char ss[5][100010];
int main() {
int n, q;
char s[100010];
scanf("%d %d %s", &n, &q, s + 1);
for (int i = 0; i <= n + 5; i++) {
for (int j = 0; j < 26; j++) {
next[i][j] = n + 1;
}
}
for (int i = n; i > 0; i--) {
for (int j = 0; j < 26; j++) {
if ((s[i] - 'a') == j)
next[i][j] = i;
else
next[i][j] = next[i + 1][j];
}
}
while (q--) {
int a;
char op, b;
scanf(" %c", &op);
if (op == '+') {
scanf("%d %c", &a, &b);
len[a]++;
ss[a][len[a]] = b;
for (int i = (a == 1 ? len[a] : 0); i <= len[1]; i++) {
for (int j = (a == 2 ? len[a] : 0); j <= len[2]; j++) {
for (int k = (a == 3 ? len[a] : 0); k <= len[3]; k++) {
dp[i][j][k] = n + 1;
if (i)
dp[i][j][k] =
min(dp[i][j][k], next[dp[i - 1][j][k] + 1][ss[1][i] - 'a']);
if (j)
dp[i][j][k] =
min(dp[i][j][k], next[dp[i][j - 1][k] + 1][ss[2][j] - 'a']);
if (k)
dp[i][j][k] =
min(dp[i][j][k], next[dp[i][j][k - 1] + 1][ss[3][k] - 'a']);
}
}
}
} else {
scanf("%d", &a);
len[a]--;
}
if (dp[len[1]][len[2]][len[3]] > n)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1048600, p = 998244353, g = 3;
void NTT(int *, int, int);
int qpow(int, int);
char s[maxn];
bool ans[maxn];
int T, n, A[maxn], B[maxn];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%s", &n, s);
int N = 1;
while (N < (n << 1)) N <<= 1;
memset(A, 0, sizeof(int) * N);
memset(B, 0, sizeof(int) * N);
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
A[n - i - 1] = 1;
else if (s[i] == 'K')
B[i] = 1;
}
NTT(A, N, 1);
NTT(B, N, 1);
for (int i = 0; i < N; i++) A[i] = (long long)A[i] * B[i] % p;
NTT(A, N, -1);
int cnt = 0;
for (int i = 1; i <= n; i++) {
ans[i] = true;
for (int j = i; j <= n; j += i) ans[i] &= !(A[n - j - 1] + A[n + j - 1]);
cnt += ans[i];
}
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (ans[i]) {
printf("%d", i);
if (--cnt) printf(" ");
}
printf("\n");
}
return 0;
}
void NTT(int *A, int n, int tp) {
for (int i = 1, j = 0, k; i < n - 1; i++) {
k = n;
do j ^= (k >>= 1);
while (j < k);
if (i < j) swap(A[i], A[j]);
}
for (int k = 2; k <= n; k <<= 1) {
int wn = qpow(g, tp > 0 ? (p - 1) / k : p - 1 - (p - 1) / k);
for (int i = 0; i < n; i += k) {
int w = 1;
for (int j = 0; j < (k >> 1); j++, w = (long long)w * wn % p) {
int a = A[i + j], b = (long long)w * A[i + j + (k >> 1)] % p;
A[i + j] = a + b;
if (A[i + j] >= p) A[i + j] -= p;
A[i + j + (k >> 1)] = a - b;
if (A[i + j + (k >> 1)] < 0) A[i + j + (k >> 1)] += p;
}
}
}
if (tp < 0) {
int inv = qpow(n, p - 2);
for (int i = 0; i < n; i++) A[i] = (long long)A[i] * inv % p;
}
}
int qpow(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = (long long)a * a % p)
if (b & 1) ans = (long long)ans * a % p;
return ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, q, k[N];
int first[N], nxt[N << 1], first2[N], nxt2[N << 1], tot = 0, tot2 = 0;
int cnt = 0, dfn[N], pre[N], top[N], size[N], son[N], depth[N];
int stck[N], tp;
int f[N], g[N], tag[N], ok;
struct Edge {
int u, v;
} edge[N << 1], edge2[N << 1];
bool cmp1(const int a, const int b) { return dfn[a] < dfn[b]; }
int read() {
int 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 - '0';
c = getchar();
}
return f * x;
}
void Add(int u, int v) {
tot++;
nxt[tot] = first[u];
first[u] = tot;
edge[tot] = (Edge){u, v};
return;
}
void DFS1(int u, int fa) {
size[u] = 1;
for (int j = first[u]; j != -1; j = nxt[j]) {
int v = edge[j].v;
if (v == fa) continue;
pre[v] = u;
depth[v] = depth[u] + 1;
DFS1(v, u);
size[u] += size[v];
if ((!son[u]) || (size[son[u]] < size[v])) son[u] = v;
}
return;
}
void DFS2(int u, int t) {
top[u] = t;
dfn[u] = ++cnt;
if (!son[u]) return;
DFS2(son[u], t);
for (int j = first[u]; j != -1; j = nxt[j]) {
int v = edge[j].v;
if (v == pre[u] || v == son[u]) continue;
DFS2(v, v);
}
return;
}
int LCA(int u, int v) {
while (top[u] != top[v]) {
if (depth[top[u]] < depth[top[v]]) swap(u, v);
u = pre[top[u]];
}
if (dfn[u] > dfn[v]) swap(u, v);
return u;
}
void Add2(int u, int v) {
tot2++;
nxt2[tot2] = first2[u];
first2[u] = tot2;
edge2[tot2] = (Edge){u, v};
return;
}
void Addedge(int u, int v) {
Add2(u, v);
Add2(v, u);
return;
}
void Build(int u) {
if (tp == 1) {
stck[++tp] = u;
return;
}
int lca = LCA(u, stck[tp]);
if (lca == stck[tp]) {
stck[++tp] = u;
return;
}
while (tp > 1 && dfn[stck[tp - 1]] >= dfn[lca])
Addedge(stck[tp], stck[tp - 1]), tp--;
if (lca != stck[tp]) Addedge(lca, stck[tp]), stck[tp] = lca;
stck[++tp] = u;
return;
}
void DP(int u, int fa) {
int sum = 0, tmpsum = 0;
for (int j = first2[u]; j != -1; j = nxt2[j]) {
int v = edge2[j].v;
if (v == fa) continue;
DP(v, u);
tmpsum += f[v];
sum += g[v];
}
if (tag[u]) {
g[u] = 1;
f[u] = sum + tmpsum;
} else {
if (sum > 1)
g[u] = 0, f[u] = 1 + tmpsum;
else
g[u] = sum, f[u] = tmpsum;
}
return;
}
void Print(int u, int fa) {
int line[100], r = 0;
printf("%d : ", u);
for (int j = first2[u]; j != -1; j = nxt2[j]) {
int v = edge2[j].v;
if (v == fa) continue;
printf("%d ", v);
line[++r] = v;
}
printf("\n");
for (int i = 1; i <= r; i++) Print(line[i], u);
return;
}
void Init(int u, int fa) {
for (int j = first2[u]; j != -1; j = nxt2[j]) {
int v = edge2[j].v;
if (v == fa) continue;
Init(v, u);
}
f[u] = g[u] = 0;
first2[u] = -1;
return;
}
int main() {
memset(first2, -1, sizeof(first2));
memset(first, -1, sizeof(first));
n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
Add(u, v), Add(v, u);
}
DFS1(1, 0);
DFS2(1, 1);
q = read();
while (q--) {
tot2 = 0;
ok = 1;
k[0] = read();
for (int i = 1; i <= k[0]; i++) k[i] = read(), tag[k[i]] = 1;
for (int i = 1; i <= k[0]; i++)
if (tag[pre[k[i]]]) ok = 0;
sort(k + 1, k + k[0] + 1, cmp1);
if (!ok) {
for (int i = 1; i <= k[0]; i++) tag[k[i]] = 0;
printf("-1\n");
continue;
}
stck[tp = 1] = 1;
for (int i = 1; i <= k[0]; i++)
if (k[i] != 1) Build(k[i]);
while (tp > 1) Addedge(stck[tp], stck[tp - 1]), tp--;
DP(1, 0);
printf("%d\n", f[1]);
for (int i = 1; i <= k[0]; i++) tag[k[i]] = 0;
Init(1, 0);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 9, M = 1073741824;
vector<bool> is_prime(N + 1, true);
vector<int> sieve(int n) {
vector<int> prime;
for (int i = 2; i <= n; ++i) {
if (!is_prime[i]) {
continue;
} else {
prime.push_back(i);
for (int j = 2; i * j <= n; ++j) {
is_prime[i * j] = 0;
}
}
}
return prime;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> prime = sieve(n);
int cnt = 0;
for (int i = 0; i < (int)prime.size() - 1; ++i) {
int num = prime[i] + prime[i + 1] + 1;
if (num <= n && is_prime[num]) {
++cnt;
}
if (cnt == k) break;
}
(cnt == k) ? puts("YES") : puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const int MAX = 4007;
long long int ans[MAX], d[MAX];
long long int e[MAX][MAX];
int main() {
long long int n;
cin >> n;
for (int i = 1; i < MAX; i++) {
e[i][i] = 1;
e[i][0] = 1;
e[i][1] = i;
}
for (int i = 2; i < MAX; i++) {
for (int j = 2; j < i; j++) {
e[i][j] = (e[i - 1][j] + e[i - 1][j - 1]) % MOD;
}
}
ans[1] = 1;
d[1] = 1;
d[0] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= i; j++) {
ans[i] = (ans[i] + (e[i][j] * d[i - j])) % MOD;
}
for (int j = 0; j <= i - 1; j++) {
d[i] = (d[i] + e[i - 1][j] * d[i - j - 1]) % MOD;
}
}
cout << ans[n] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, h;
scanf("%d%d%d", &n, &d, &h);
if (2 * h < d)
puts("-1");
else {
if (d == 1) {
if (n == 2)
puts("1 2");
else
puts("-1");
return 0;
}
for (int i = 2; i <= h + 1; i++) printf("%d %d\n", i - 1, i);
if (d > h) {
printf("1 %d\n", h + 2);
for (int i = h + 3; i <= d + 1; i++) printf("%d %d\n", i - 1, i);
}
for (int i = d + 2; i <= n; i++) printf("%d %d\n", h, i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, l;
int lgt, wth, cll[3][7500], rws[3][7500];
int nPer;
int jen, qe, wrn;
int main() {
scanf("%d%d%d", &lgt, &wth, &nPer);
for (i = 1; i <= nPer; i++) {
scanf("%d%d%d", &jen, &qe, &wrn);
if (jen == 1) {
rws[1][qe] = wrn;
rws[2][qe] = i;
} else {
cll[1][qe] = wrn;
cll[2][qe] = i;
}
}
for (i = 1; i <= lgt; i++) {
for (j = 1; j <= wth; j++) {
if (j > 1) {
printf(" ");
}
if (rws[2][i] > cll[2][j]) {
printf("%d", rws[1][i]);
} else {
printf("%d", cll[1][j]);
}
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1, MOD = 998244353;
int lim[N][2][2], p[N << 2][2][2], psb[N][2];
inline int qpow(int base, int expo) {
int ret = 1;
while (expo) {
if (expo & 1) ret = 1ll * ret * base % MOD;
base = 1ll * base * base % MOD;
expo >>= 1;
}
return ret;
}
inline void up(int now, int mid) {
int i, j, k, l;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
p[now][i][j] = 0;
for (k = 0; k < 2; k++)
for (l = 0; l < 2; l++)
if (!lim[mid][k][l])
p[now][i][j] =
(0ll + p[now][i][j] +
1ll * p[now << 1][i][k] * p[now << 1 | 1][l][j] % MOD) %
MOD;
}
}
}
void build(int now, int l, int r) {
if (l == r) {
p[now][0][0] = psb[l][0];
p[now][1][1] = psb[l][1];
return;
}
int mid = (l + r) >> 1;
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
up(now, mid);
}
void update(int now, int l, int r, int qp) {
if (l == r) return;
int mid = (l + r) >> 1;
if (qp <= mid)
update(now << 1, l, mid, qp);
else
update(now << 1 | 1, mid + 1, r, qp);
up(now, mid);
}
struct chase {
int x, xp, yp;
double tim;
int rtim;
chase(int x = 0, int xp = 0, int yp = 0, double tim = 0, int rtim = 0)
: x(x), xp(xp), yp(yp), tim(tim), rtim(rtim) {}
} cs[N * 2];
int csc;
inline int cmp(chase a, chase b) { return a.tim < b.tim; }
int main() {
int n, i, lasp, lasv, inv = qpow(100, MOD - 2);
scanf("%d", &n);
for (i = 1; i <= n; i++) {
int tpos, tv;
scanf("%d%d%d", &tpos, &tv, &psb[i][1]);
if (i > 1) {
int dis = tpos - lasp;
cs[++csc] = chase(i - 1, 1, 0, dis / 1.0 / (tv + lasv),
1ll * dis * qpow(tv + lasv, MOD - 2) % MOD);
if (tv < lasv)
cs[++csc] = chase(i - 1, 1, 1, dis / 1.0 / (lasv - tv),
1ll * dis * qpow(lasv - tv, MOD - 2) % MOD);
else if (tv > lasv)
cs[++csc] = chase(i - 1, 0, 0, dis / 1.0 / (tv - lasv),
1ll * dis * qpow(tv - lasv, MOD - 2) % MOD);
}
psb[i][0] = 1ll * (100 - psb[i][1]) * inv % MOD;
psb[i][1] = 1ll * psb[i][1] * inv % MOD;
lasp = tpos, lasv = tv;
}
build(1, 1, n);
sort(cs + 1, cs + csc + 1, cmp);
int ans = 0, lpsb = 1;
for (i = 1; i <= csc; i++) {
lim[cs[i].x][cs[i].xp][cs[i].yp] = 1;
update(1, 1, n, cs[i].x);
int tpsb = (0ll + p[1][0][0] + p[1][0][1] + p[1][1][0] + p[1][1][1]) % MOD;
ans = (0ll + ans + 1ll * cs[i].rtim * (lpsb - tpsb + MOD) % MOD) % MOD;
lpsb = tpsb;
}
printf("%d", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200001;
long long n, k;
long long arr[MAXN];
long long dist[MAXN];
long long lc[MAXN];
long long rc[MAXN];
vector<pair<long long, long long> > ranges;
signed main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (long long i = 0; i < n; i++) {
char c;
cin >> c;
if (c == 'B') arr[i] = 1;
}
bool flag1 = (n % 2 == 0);
if (flag1)
for (long long i = 0; i < n; i++) {
if (arr[0] ^ arr[i] ^ (i & 1)) {
flag1 = false;
break;
}
}
if (flag1) {
cerr << "I AK IOI" << endl;
for (long long i = 0; i < n; i++) {
if (arr[i] ^ (k & 1))
cout << 'B';
else
cout << 'W';
}
cout << endl;
exit(0);
}
long long bg = 0;
for (long long i = 0; i < n; i++) {
if (i != 0 && arr[i - 1] == arr[i]) {
bg = i;
break;
}
}
bg += n;
long long lastpos = 0;
long long lastcol = 0;
for (long long i = bg; i < bg + n; i++) {
if (arr[(i - 1) % n] != arr[i % n] && arr[i % n] != arr[(i + 1) % n]) {
dist[i % n] = i - lastpos;
lc[i % n] = lastcol;
} else {
lastpos = i;
lastcol = arr[i % n];
dist[i % n] = 0;
}
}
bg += n;
for (long long i = bg - 1; i >= bg - n; i--) {
if (arr[(i - 1) % n] != arr[i % n] && arr[i % n] != arr[(i + 1) % n]) {
if (lastpos - i < dist[i % n]) {
dist[i % n] = i - lastpos;
}
rc[i % n] = lastcol;
} else {
lastpos = i;
lastcol = arr[i % n];
}
}
for (long long i = 0; i < n; i++) {
if (dist[i] == 0) {
if (arr[i])
cout << 'B';
else
cout << 'W';
} else if (dist[i] > 0) {
if (k < dist[i]) {
if (arr[i] ^ (k & 1))
cout << 'B';
else
cout << 'W';
} else {
if (lc[i])
cout << 'B';
else
cout << 'W';
}
} else {
if (k < -dist[i]) {
if (arr[i] ^ (k & 1))
cout << 'B';
else
cout << 'W';
} else {
if (rc[i])
cout << 'B';
else
cout << 'W';
}
}
}
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int limite = 1000000;
void morir() {
printf("-1\n");
exit(0);
}
long long int suma[limite];
void anyade(int pos, long long int val) {
for (; pos < limite; pos += pos & -pos) suma[pos] += val;
}
long long int sumaantes(int pos) {
long long int s = 0;
for (; pos > 0; pos -= pos & -pos) s += suma[pos];
return s;
}
long long int sumaentre(int pos0, int pos1) {
if (pos0 > pos1) return 0;
return sumaantes(pos1) - sumaantes(pos0 - 1);
}
int n;
vector<pair<int, int> > g[limite];
int au[limite];
int av[limite];
int aw[limite];
int ap[limite];
int idarista[limite];
int posri[limite];
int npos = 1;
int eliminado[limite];
int anterior[limite];
int siguiente[limite];
int computaanterior(int pos) {
if (not eliminado[pos]) return pos;
anterior[pos] = computaanterior(anterior[pos]);
return anterior[pos];
}
int computasiguiente(int pos) {
if (not eliminado[pos]) return pos;
siguiente[pos] = computasiguiente(siguiente[pos]);
return siguiente[pos];
}
void genera(int u) {
int pos = npos;
vector<pair<int, int> > &ar = g[u];
anyade(pos, aw[idarista[pos]]);
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i].first;
int idav = ar[i].second;
npos++;
idarista[npos] = idav;
genera(v);
}
posri[pos] = npos;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d %d %d %d", au + i, av + i, aw + i, ap + i);
g[au[i]].push_back(pair<int, int>(av[i], i));
}
genera(1);
for (int i = 1; i <= npos + 1; i++) {
siguiente[i] = i + 1;
anterior[i] = i - 1;
}
for (int pos = npos; pos > 1; pos--) {
int posr = computaanterior(posri[pos]);
int p = ap[idarista[pos]];
for (;;) {
long long int s = sumaentre(pos + 1, posri[pos]);
if (p >= s) break;
if (posr <= pos) morir();
int &ww = aw[idarista[posr]];
int &pp = ap[idarista[posr]];
int sr = sumaentre(posr + 1, posri[posr]);
int quitar = min((ww - 1), pp - sr);
if (s - quitar <= p) quitar = s - p;
ww -= quitar;
pp -= quitar;
anyade(posr, -quitar);
if (quitar == 0) eliminado[posr] = 1;
posr = computaanterior(posr);
}
}
printf("%d\n", n);
for (int i = 1; i <= n - 1; i++)
printf("%d %d %d %d\n", au[i], av[i], aw[i], ap[i]);
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a;
scanf("%d", &a);
int b;
scanf("%d", &b);
int t = n;
t = t - a - b;
if (t > 0) {
t--;
a = a + t;
}
printf("%d", n - a);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n), b(n), ans(n);
for (int& in : a) cin >> in;
for (int& in : b) cin >> in;
multiset<int> ml(b.begin(), b.end());
for (int i = 0; i < n; i++) {
int val = 0 - a[i];
if (val < 0) val += n;
auto it = ml.begin();
if (ml.find(val) != ml.end())
it = ml.find(val);
else
it = ml.upper_bound(val);
if (it == ml.end()) {
ans[i] = (a[i] + *ml.begin()) % n;
ml.erase(ml.begin());
} else {
ans[i] = (a[i] + *it) % n;
ml.erase(it);
}
}
for (auto it : ans) cout << it << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
void Read() {
cin >> N;
int add = 0;
for (int i = 1; i <= N; i++) {
int val;
cin >> val;
if (val == 0 && add == 1) {
cout << "NO\n";
return;
}
val -= add;
add = 0;
add = val % 2;
}
if (add == 1)
cout << "NO\n";
else
cout << "YES\n";
}
int main() {
Read();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110;
int n, k, maxn;
int a[MAXN], b[MAXN];
int w[MAXN];
int f[1000 * MAXN], g[1000 * MAXN], ans;
int main() {
scanf("%d%d", &n, &k);
ans = -1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
w[i] = a[i] - k * b[i];
}
maxn = 1000 * n;
memset(f, -1, sizeof(f));
f[0] = 0;
for (int i = 1; i <= maxn; i++) {
f[i] = g[i] = -233333333;
}
f[0] = g[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = maxn; j >= abs(w[i]); j--) {
if (w[i] >= 0) {
f[j] = max(f[j], f[j - w[i]] + a[i]);
} else
g[j] = max(g[j], g[j + w[i]] + a[i]);
}
}
for (int i = 0; i <= maxn; i++) {
ans = max(ans, f[i] + g[i]);
}
if (ans)
cout << ans << endl;
else
puts("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class solution {
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
string s;
cin >> s;
vector<int> v(m);
for (int i = 0; i < m; i++) {
cin >> v[i];
}
vector<int> ch(26, 0);
vector<int> dp(n, 0);
dp[0] = 1;
for (int i = 0; i < m; i++) {
dp[0]++;
dp[v[i]]--;
}
for (int i = 0; i < n; i++) {
int charecter = s[i] - 'a';
if (i == 0) {
ch[charecter] = dp[0];
} else {
dp[i] += dp[i - 1];
ch[charecter] += dp[i];
}
}
for (auto it : ch) {
cout << it << " ";
}
cout << "\n";
}
}
};
int main() {
ios::sync_with_stdio(0), cout.tie(0), cin.tie(0);
long long i = 0;
solution s;
s.solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
int dp[33333][222][3][2];
int n, k, a[33333];
using std::max;
int main() {
scanf("%d%d", &n, &k);
register int i, ii;
for (i = 1; i <= n; i++) scanf("%d", a + i);
for (i = 0; i <= n; i++)
for (ii = 0; ii <= k; ii++)
dp[i][ii][0][0] = dp[i][ii][1][0] = dp[i][ii][2][0] = dp[i][ii][0][1] =
dp[i][ii][1][1] = dp[i][ii][2][1] = -1e9;
for (i = 0; i <= n; i++) dp[i][0][1][1] = dp[i][0][2][0] = 0;
for (i = 1; i <= n; i++)
for (ii = 1; ii <= k; ii++) {
dp[i][ii][0][0] = max(max(dp[i - 1][ii][0][0], dp[i - 1][ii - 1][0][0]),
dp[i - 1][ii - 1][1][1]);
dp[i][ii][0][1] = max(max(dp[i - 1][ii][0][1], dp[i - 1][ii - 1][0][1]),
dp[i - 1][ii - 1][2][0]);
dp[i][ii][1][1] = max(dp[i - 1][ii][1][1], max(dp[i - 1][ii - 1][2][0],
dp[i - 1][ii - 1][0][1]));
dp[i][ii][2][0] = max(dp[i - 1][ii][2][0], max(dp[i - 1][ii - 1][1][1],
dp[i - 1][ii - 1][0][0]));
if (ii == 1 || ii == k)
dp[i][ii][1][1] += a[i], dp[i][ii][2][0] -= a[i],
dp[i][ii][0][0] = dp[i][ii][0][1] = -1e9;
else
dp[i][ii][1][1] += 2 * a[i], dp[i][ii][2][0] -= 2 * a[i];
}
int ans = -1e9;
for (i = 1; i <= n; i++)
ans = std::max(ans, std::max(dp[i][k][1][1], dp[i][k][2][0]));
printf("%d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int a[maxn];
int book[maxn];
int prime[maxn] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
void solve() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int x;
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int sz = unique(a, a + n) - a;
set<int> S;
S.clear();
memset(book, -1, sizeof(book));
for (int i = 0; i < sz; i++) {
for (int j = i; j < sz; j++) {
if (book[j] && a[j] % a[i] == 0) {
book[j] = 0;
S.insert(a[i]);
}
}
}
cout << S.size() << '\n';
}
int main() {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
int a[N], n;
int main() {
fill(a, a + N, N);
a[0] = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
int l = 0, r = n, mid = (l + r) / 2;
while (r - l > 1) {
if (a[mid] < k)
l = mid;
else
r = mid;
mid = (l + r) / 2;
}
if (a[r] < k)
mid = r;
else
mid = l;
if (k < a[mid + 1]) a[mid + 1] = k;
}
int ans = 1;
while (a[ans] != N) ans++;
printf("%d\n", ans - 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, mn = INT_MAX, curr;
cin >> n >> m;
string s, t;
cin >> s >> t;
vector<vector<int> > vec(1000);
for (int i = 0; i < m; i++) {
int cnt = 0, f = 0;
for (int j = 0, c = i; j < n; j++, c++) {
if (c == m) {
vec[i].clear();
f = 1;
break;
}
if (s[j] != t[c]) {
vec[i].push_back(j + 1);
cnt++;
}
}
if (mn > cnt && !f) {
mn = cnt;
curr = i;
}
}
int k = vec[curr].size();
cout << k << endl;
for (int i = 0; i < k; i++) cout << vec[curr][i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int main() {
long long int n, I, ans = 0;
cin >> n >> I;
long long int a[n];
long long int count = 0;
map<long long int, long long int> mp;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (long long int i = 1, j = 1; i <= n; i++) {
mp[a[i]]++;
if (mp[a[i]] == 1) count++;
while (n * ((int)ceil(log2(count))) > 8 * I) {
mp[a[j]]--;
if (mp[a[j]] == 0) count--;
j++;
}
ans = max(ans, i - j + 1);
}
cout << n - ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long P = 1000003;
long long v2(long long a, long long b) {
long long ans = 0;
for (long long i = 2; b / i != (a - 1) / i; i *= 2) {
ans += b / i - (a - 1) / i;
}
return ans;
}
long long fastexp(long long a, long long exp) {
if (exp == 0) return 1;
if (exp % 2 == 0) {
long long s = fastexp(a, exp / 2);
return (s * s) % P;
} else
return (fastexp(a, exp - 1) * a) % P;
}
pair<long long, long long> bezout(long long a, long long b) {
if (a < b) {
pair<long long, long long> s = bezout(b, a);
return make_pair(s.second, s.first);
}
if (a == 1 && b == 0) return make_pair(1, 0);
long long r = a % b;
long long q = a / b;
pair<long long, long long> s = bezout(b, r);
long long x1 = s.first;
long long y1 = s.second;
return make_pair(y1, x1 - y1 * q);
}
long long inv(long long a) {
a %= P;
return bezout(a, P).first;
}
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
long long A = 1, B;
long long asd;
if (n <= 60) {
asd = 1;
for (int i = 0; i < n; i++) asd *= 2;
if (k > asd) {
cout << "1 1";
return 0;
}
}
B = fastexp(2, n);
B = fastexp(B, k);
B *= inv(fastexp(2, n + v2(1, k - 1)));
B %= P;
if (k > P)
A = 0;
else {
long long S = fastexp(2, n);
long long div2 = inv(2);
for (long long i = 1; i <= k - 1; i++) {
long long j = i;
long long F = S - i;
while (j % 2 == 0) {
j /= 2;
F *= div2;
F %= P;
}
A *= F;
A %= P;
}
}
A = B - A;
A %= P;
if (A < 0) A += P;
if (B < 0) B += P;
cout << A << " " << B;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return;
}
long long xx, yy;
solve(b, a % b, xx, yy);
x = yy;
y = xx - yy * (a / b);
}
long long gcd(long long a, long long b) {
while (a > 0 && b > 0) {
if (a > b) {
a %= b;
} else {
b %= a;
}
}
return a + b;
}
int main() {
long long a1, b1, a2, b2, L, R;
cin >> a1 >> b1 >> a2 >> b2 >> L >> R;
long long g = gcd(a1, a2);
if ((b2 - b1) % g != 0) {
cout << 0 << endl;
return 0;
}
long long k, l;
solve(a1, a2, k, l);
k *= (b2 - b1) / g;
l *= (b1 - b2) / g;
long long c1 = a1 / g;
long long c2 = a2 / g;
long long shift = min(k / c2, l / c1);
k -= shift * c2;
l -= shift * c1;
while (k < 0 || l < 0) {
k += c2;
l += c1;
}
while (k >= c2 && l >= c1) {
k -= c2;
l -= c1;
}
long long start = a1 * k + b1;
assert(start == a2 * l + b2);
long long step = a1 / g * a2;
if (start < L) {
start += (L - start) / step * step;
}
while (start < L) {
start += step;
}
long long ans = 0;
if (start <= R) {
ans = (R - start) / step + 1;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int mi = max(((3 * a) / 10), (a - (a / 250) * c));
int va = max(((3 * b) / 10), (b - (b / 250) * d));
if (mi > va) {
printf("Misha");
} else if (va > mi) {
printf("Vasya");
} else {
printf("Tie");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000;
bool vis[201][201][3][3];
int dp[201][201][3][3];
pair<int, int> fa[201][201][3][3];
int f(int a, int b, int ga, int gb) {
if (a == 0 && b == 0) return (ga == 3 || gb == 3 ? 0 : -INF);
if (ga >= 3 || gb >= 3 || a < 0 || b < 0) return -INF;
int &r = dp[a][b][ga][gb];
auto &pa = fa[a][b][ga][gb];
if (vis[a][b][ga][gb]) return r;
vis[a][b][ga][gb] = 1;
r = -INF;
int p, q, start = (ga + gb >= 4 ? 15 : 25);
for (int i = 0, qwerty = max(a, b) + 1; i < qwerty; i++) {
if (i < start - 1)
p = start, q = i;
else
p = i + 2, q = i;
if (r < 1 + f(a - p, b - q, ga + 1, gb)) {
r = 1 + f(a - p, b - q, ga + 1, gb);
pa = {p, q};
}
if (r < -1 + f(a - q, b - p, ga, gb + 1)) {
r = -1 + f(a - q, b - p, ga, gb + 1);
pa = {q, p};
}
}
return r;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0, qwerty = n; i < qwerty; i++) {
int a, b, ga = 0, gb = 0, aa, bb;
cin >> a >> b;
aa = a, bb = b;
int r = f(a, b, 0, 0);
if (r < -3) {
cout << "Impossible\n";
continue;
}
vector<pair<int, int>> ans;
while (a || b) {
auto pa = fa[a][b][ga][gb];
ans.push_back(pa);
a -= pa.first;
b -= pa.second;
if (pa.first > pa.second)
ga++;
else
gb++;
}
a = aa, b = bb;
cout << ga << ":" << gb << "\n";
for (auto p : ans)
cout << p.first << ":" << p.second << " ", a -= p.first, b -= p.second;
cout << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-7;
const long long SZ = 100010, SSZ = 120, APB = 52, one = 11;
const long long INF = 0x7f7f7f7f7f7f7f7f, mod = 1000000007;
long long n, qnum, src[SZ], diff[SZ];
struct nd {
long long ll, rr, val, id;
nd(long long a = 0, long long b = 0, long long c = 0, long long d = 0)
: ll(a), rr(b), val(c), id(d) {}
};
nd arr[SZ];
void its(long long l1, long long r1, long long l2, long long r2, long long &u,
long long &v) {
u = max(l1, l2);
v = min(r1, r2);
if (u > v) u = v = -1;
}
void init() {
cin >> n >> qnum;
for (long long i = 1; i <= n; ++i) cin >> src[i];
for (long long i = 1; i <= n - 1; ++i) {
diff[i] = abs(src[i + 1] - src[i]);
}
deque<nd> dq;
for (long long i = 1; i <= n - 1; ++i) {
long long ll = i;
for (; dq.size() && dq.back().val <= diff[i];) {
nd tmp = dq.back();
dq.pop_back();
tmp.rr = i - 1;
arr[tmp.id] = tmp;
ll = min(ll, tmp.ll);
}
dq.push_back(nd(ll, i, diff[i], i));
}
for (; dq.size();) {
nd tmp = dq.back();
dq.pop_back();
tmp.rr = n - 1;
arr[tmp.id] = tmp;
}
for (long long i = 1; i <= n - 1; ++i) {
++arr[i].rr;
}
for (long long i = 1; i <= qnum; ++i) {
long long ll, rr, res = 0, u, v;
cin >> ll >> rr;
for (long long j = 1; j <= n - 1; ++j) {
its(ll, rr, arr[j].ll, arr[j].rr, u, v);
if (u != -1) {
long long num1 = j - u + 1;
long long num2 = v - j;
if (num1 < 0) num1 = 0;
if (num2 < 0) num2 = 0;
res += num1 * num2 * diff[j];
}
}
cout << res << endl;
}
}
void work() {}
int main() {
std::ios::sync_with_stdio(0);
int casenum;
{
init();
work();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
if (n < m) {
cout << 0 << "\n";
} else {
int first[11] = {0};
long long int sum = 0;
for (auto i = 1; i < 11; i++) {
first[i] = (m * i) % 10;
sum += first[i];
}
long long int ans = 0;
long long int times = n / (m * 10);
ans = times * sum;
long long int rem = n - times * (m * 10);
rem /= m;
sum = 0;
for (auto i = 1; i < rem + 1; i++) {
sum += first[i];
}
ans += sum;
cout << ans << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, ans;
void solve(int L, int R, int x) {
if ((a - 1) / (x + 1) >= a / x) return;
if ((b - 1) / (x + 1) >= b / x) return;
L = max(L, (a - 1) / (x + 1) + (b - 1) / (x + 1) + 2);
R = min(R, a / x + b / x);
if (L <= R) ans += R - L + 1;
}
int main() {
scanf("%d%d", &a, &b);
n = a + b;
for (int l = 1, r; l <= n; l = r + 1) r = n / (n / l), solve(l, r, n / l);
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[2010];
long long sum = 0, s = 0;
cin >> n;
for (int i = 1; i <= 2 * n; i++) cin >> a[i];
sort(a + 1, a + 2 * n + 1);
for (int i = 1; i <= n; i++) {
sum += a[i];
}
for (int i = 1 + n; i <= n * 2; i++) {
s += a[i];
}
if (sum == s)
cout << -1 << endl;
else {
for (int i = 1; i < n * 2; i++) {
cout << a[i] << " ";
}
cout << a[2 * n] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
struct node {
int l, r, sum;
} T[N * 40];
int root[N], a[N], hd[N], cnt, ct[N];
vector<int> Q[N];
int n, k, q, l, r;
void update(int l, int r, int &x, int y, int pos, int v) {
T[x = ++cnt] = T[y], T[cnt].sum += v;
if (l == r) return;
int mid = (l + r) >> 1;
if (mid >= pos)
update(l, mid, T[x].l, T[y].l, pos, v);
else
update(mid + 1, r, T[x].r, T[y].r, pos, v);
}
int query(int l, int r, int L, int R, int rt) {
if (L <= l && r <= R) return T[rt].sum;
int mid = l + r >> 1, an = 0;
if (L <= mid) an += query(l, mid, L, R, T[rt].l);
if (R > mid) an += query(mid + 1, r, L, R, T[rt].r);
return an;
}
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) {
update(1, n, root[i], root[i - 1], i, 1);
Q[a[i]].push_back(i);
if (ct[a[i]] == k) {
int x = Q[a[i]][hd[a[i]]++];
update(1, n, root[i], root[i], x, -1);
} else
ct[a[i]]++;
}
int ans = 0;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &l, &r);
l = (l + ans) % n + 1, r = (r + ans) % n + 1;
if (l > r) swap(l, r);
printf("%d\n", ans = query(1, n, l, r, root[r]));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
const int score[] = {25, 18, 15, 12, 10, 8, 6, 4, 2, 1};
string name[maxn];
map<string, int> mp;
int t, n, cnt = 0;
vector<vector<int> > v1(maxn, vector<int>(60));
vector<vector<int> > v2(maxn, vector<int>(60));
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int mark;
if (!mp.count(s)) {
mp[s] = cnt;
name[cnt] = s;
mark = cnt;
cnt++;
} else
mark = mp[s];
if (i < 10) {
v1[mark][0] += score[i];
v2[mark][1] += score[i];
}
if (!i)
v2[mark][0]++, v1[mark][1]++;
else
v1[mark][i + 1]++, v2[mark][i + 1]++;
}
}
int ans = 0;
for (int i = 0; i < cnt; i++)
if (v1[i] > v1[ans]) ans = i;
cout << name[ans] << endl;
for (int i = 0; i < cnt; i++)
if (v2[i] > v2[ans]) ans = i;
cout << name[ans] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char c[105], a[105], d[105], b[105], hh;
bool vis[55][55][55][55], f[55][55];
int n;
bool dfs(int sum, int a, int b, int c) {
if (vis[sum][a][b][c]) return 0;
if (sum == 3 && f[c][a] && f[c][b]) return 1;
if (f[c][b] && dfs(sum - 1, sum - 4, a, c)) return 1;
if (sum >= 4 && f[c][sum - 4] && dfs(sum - 1, c, a, b)) return 1;
vis[sum][a][b][c] = 1;
return 0;
}
int main() {
scanf("%d", &n);
getchar();
for (int i = 0; i < n; i++) {
scanf("%c%c", &a[i], &b[i]);
getchar();
c[i] = a[i], d[i] = b[i];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j && (a[i] == a[j] || b[i] == b[j])) f[i][j] = 1;
if (dfs(n, n - 3, n - 2, n - 1) || (n == 1))
printf("YES");
else
printf("NO");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, l;
string s;
int main() {
cin >> n >> s;
for (int i = 0; i < s.size(); i++)
if (s[i] == '8') l++;
cout << min(n / 11, l);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
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 << 3) + (x << 1) + ch - '0', ch = getchar();
return x * f;
}
inline long long readll() {
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;
}
inline void write(int x) {
if (!x) putchar('0');
if (x < 0) x = -x, putchar('-');
static int sta[20];
register int tot = 0;
while (x) sta[tot++] = x % 10, x /= 10;
while (tot) putchar(sta[--tot] + 48);
}
const int maxn = 200007, INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const long long P = 19260817;
inline int mod1(int x) { return x < MOD ? x : x - MOD; }
inline int mod2(int x) { return x < 0 ? x + MOD : x; }
inline void add(int &x, int y) { x = mod1(x + y); }
inline void sub(int &x, int y) { x = mod2(x - y); }
int n;
vector<pair<int, int> > v[10007];
int x[maxn], y[maxn];
int fa[maxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
fa[x] = y;
}
int qpow(int a, int b) {
int rt = 1;
while (b) {
if (b & 1) rt = 1ll * a * rt % MOD;
a = 1ll * a * a % MOD;
b >>= 1;
}
return rt;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", x + i, y + i);
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
v[abs(x[i] - x[j]) + abs(y[i] - y[j])].push_back(make_pair(i, j));
}
}
for (int i = 1; i <= n + n; i++) {
fa[i] = i;
}
int ans;
for (int i = 10000; i >= 1; i--) {
for (auto x : v[i]) {
if (find(x.first) == find(x.second)) {
ans = i;
goto NXT;
}
merge(x.first, x.second + n);
merge(x.second, x.first + n);
}
}
ans = 0;
NXT:;
for (int i = 1; i <= n + n; i++) fa[i] = i;
for (int i = 10000; i > ans; i--) {
for (auto x : v[i]) {
merge(x.first, x.second + n);
merge(x.second, x.first + n);
}
}
int cnt = 0;
for (int i = 1; i <= n + n; i++) {
if (find(i) == i) {
cnt++;
}
}
cnt /= 2;
printf("%d\n%d\n", ans, qpow(2, cnt));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
ios_base::sync_with_stdio(0);
int a;
cin >> a;
int n, m;
if (a == 1) {
n = 1;
m = 1;
cout << n << " " << m << endl;
cout << 1 << endl;
return 0;
}
if (a % 2 == 1) {
n = 2 * a - 1;
} else {
n = 2 * a - 2;
}
m = 2;
cout << n << " " << m << endl;
cout << 1 << " " << 2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace ::std;
const long long M = 1000000007;
int n, m, x;
long long dp[2][405][405];
long long sum[2][405][405];
long long dp2[2][405][405];
long long sum2[2][405][405];
void ad(long long& v1, long long v2) { v1 = (v1 + v2) % M; }
void mu(long long& v1, long long v2) { v1 = (v1 * v2) % M; }
long long solution1() {
long long ret = 0;
for (int i = 1; i <= m; i++)
for (int j = i; j <= m; j++) {
sum[1][i][j] = sum[1][i - 1][j];
sum2[1][i][j] = sum2[1][i - 1][j];
if (i != x) {
dp[1][i][j] = 1;
ad(sum[1][i][j], dp[1][i][j]);
} else if (i == x) {
dp2[1][i][j] = 1;
ad(sum2[1][i][j], dp2[1][i][j]);
}
}
for (int i = 2; i <= n; i++) {
int i0 = i % 2, i1 = 1 - i0;
for (int j = 1; j <= m; j++)
for (int k = j; k <= m; k++)
dp[i0][j][k] = dp2[i0][j][k] = sum[i0][j][k] = sum2[i0][j][k] = 0;
for (int j = i; j <= x; j++) {
long long s = 0;
for (int k = 1; k < j; k++) ad(s, sum[i1][k][k]);
for (int k = j; k <= m; k++) {
if (j != x)
ad(dp[i0][j][k], s);
else
ad(dp2[i0][j][k], s);
ad(s, sum[i1][j - 1][k]);
}
}
for (int j = x; j <= m; j++) {
long long s = 0;
for (int k = 1; k < j; k++) ad(s, sum2[i1][k][k]);
for (int k = j; k <= m; k++) {
ad(dp2[i0][j][k], s);
ad(s, sum2[i1][j - 1][k]);
}
}
for (int j = 1; j <= m; j++)
for (int k = j; k <= m; k++) {
sum[i0][j][k] = (sum[i0][j - 1][k] + dp[i0][j][k]) % M;
sum2[i0][j][k] = (sum2[i0][j - 1][k] + dp2[i0][j][k]) % M;
}
}
for (int i = 1; i <= m; i++)
for (int j = i; j <= m; j++) ad(ret, dp2[n % 2][i][j]);
for (int i = 1; i <= n; i++) mu(ret, i);
return ret;
}
long long solution2() {
long long ret = 0;
dp[0][0][0] = 1;
for (int i = 1; i <= m; i++) {
int i0 = i % 2, i1 = 1 - i0;
for (int j = 0; j < n; j++)
for (int k = j; k <= n; k++) {
dp[i0][j][k] = dp[i1][j][k];
if (i == x) dp[i0][j][k] = 0;
}
for (int j = 0; j < n; j++)
for (int k = j; k <= n; k++) {
ad(dp[i0][j][k + 1], dp[i1][j][k]);
if (k > j && i != x) ad(dp[i0][j + 1][k], dp[i1][j][k]);
if (j != k) ad(dp[i0][j + 1][k + 1], dp[i1][j][k]);
}
if (i >= x) ad(ret, dp[i0][n - 1][n]);
}
for (int i = 1; i <= n; i++) mu(ret, i);
return ret;
}
int main() {
scanf("%d %d %d", &n, &m, &x);
if (n > m) {
printf("%I64d", solution1());
} else {
printf("%I64d", solution2());
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const double eps = 1e-10;
const long long mod = 1e9 + 7;
const int N = 1e5 + 5;
int n, p, a[N];
bool judge(int x) {
for (int now, i = 1; i <= n; ++i, ++x) {
now = upper_bound(a + 1, a + n + 1, x) - (a + 1);
if (now - (i - 1) == p) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
;
cin >> n >> p;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
int ansl = 0;
for (int i = 1; i <= n; ++i) {
ansl = max(ansl, a[i] - (i - 1));
}
int l = ansl, r = a[n], mid;
while (l < r) {
mid = (l + r + 1) / 2;
if (judge(mid))
r = mid - 1;
else
l = mid;
}
if (!judge(ansl)) {
cout << r - ansl + 1 << '\n';
for (int i = ansl; i <= r; ++i) {
cout << i << " ";
}
cout << '\n';
} else
cout << 0 << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, m;
vector<int> tr[1000005];
vector<int> vr[1000005];
pair<int, int> pr[1000005];
int high;
long long team[1000005], ir[1000005];
int main() {
scanf("%d %d", &n, &m);
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
if (x < y) swap(x, y);
vr[x].push_back(y);
}
for (int i = 1; i < n + 1; i++) {
scanf("%d", &x);
for (int j = 0; j < x; j++) {
scanf("%d", &y);
tr[i].push_back(y);
high = max(high, y);
}
}
while (1) {
int tot = 0;
for (int i = 1; i < high + 1; i++) team[i] = rng() % 2 + 1;
for (int i = 1; i < n + 1; i++) {
ir[i] = tr[i][rng() % tr[i].size()];
for (int j = 0; j < vr[i].size(); j++) {
if (team[ir[vr[i][j]]] != team[ir[i]]) tot++;
}
}
if (tot >= m / 2 + (m % 2)) break;
}
for (int i = 1; i < n + 1; i++) printf("%d ", ir[i]);
printf("\n");
for (int i = 1; i < high + 1; i++) printf("%d ", team[i]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
long long x[1000010];
long long ans0;
vector<long long> v;
long long gc1, gc2[1000010];
long long cost[1000010];
void solve(long long start) {
long long i;
for (auto q : v) {
long long lgr = -1;
long long rgr = -1;
long long ans = start;
for (i = 2; i <= n; i++) {
if (x[i] % q == 0)
cost[i] = 0;
else if ((x[i] + 1) % q == 0 || (x[i] - 1) % q == 0)
cost[i] = b, ans += b;
else {
lgr = i;
break;
}
}
if (lgr == -1) {
long long costd = 0;
long long ans1 = 0;
long long mn = 0;
for (i = 2; i <= n; i++) {
costd += (a - cost[i]);
ans1 = min(ans1, mn + costd);
mn = min(mn, -costd);
}
ans0 = min(ans + ans1, ans0);
} else {
for (i = n; i >= 1; i--) {
if (x[i] % q == 0)
cost[i] = 0;
else if ((x[i] + 1) % q == 0 || (x[i] - 1) % q == 0)
cost[i] = b, ans += b;
else {
rgr = i;
break;
}
}
ans += (rgr - lgr + 1) * a;
long long costd = 0;
long long nlgr = lgr, ncost = 0;
long long ans1 = 0;
for (i = lgr - 1; i > 1; i--) {
costd += cost[i];
ans1 = min(ans1, (lgr - i) * a - costd);
}
ans += ans1;
ans1 = 0;
nlgr = rgr;
costd = 0;
ncost = 0;
for (i = rgr + 1; i <= n; i++) {
costd += cost[i];
ans1 = min(ans1, (i - rgr) * a - costd);
}
ans += ans1;
}
ans0 = min(ans0, ans);
}
}
int main() {
scanf("%I64d%I64d%I64d", &n, &a, &b);
long long i;
for (i = 1; i <= n; i++) {
scanf("%I64d", &x[i]);
}
ans0 = 1ll * (n - 1) * a;
for (int ii = 0; ii < 2; ii++) {
for (int jj = -1; jj <= 1; jj++) {
if (x[1] + jj == 1) continue;
v.clear();
x[1] += jj;
long long q = x[1];
for (i = 2; i * i <= q; i++) {
while (q % i == 0) {
v.push_back(i);
q /= i;
}
}
if (q != 1) v.push_back(q);
solve(abs(b * jj));
x[1] -= jj;
}
reverse(x + 1, x + 1 + n);
}
cout << ans0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 110;
const int Maxl = 510;
const int inf = 2147483647;
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 << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * f;
}
int n, k, tot = 1, a[Maxn * Maxl], la = 0, w[Maxn * Maxl];
int son[Maxn * Maxl][26], sz[Maxn * Maxl];
char str[Maxl];
bool mark[Maxn * Maxl];
void build() {
int x = 1, len = strlen(str + 1);
for (int i = 1; i <= len; i++) {
int p = str[i] - 'a';
if (!son[x][p]) son[x][p] = ++tot;
x = son[x][p];
w[x] = p;
}
sz[x]++;
mark[x] = true;
}
int fa[Maxn * Maxl][16], dep[Maxn * Maxl], dfn[Maxn * Maxl], id = 0;
void dfs(int x, int f) {
dfn[x] = ++id;
dep[x] = dep[f] + 1;
fa[x][0] = f;
for (int i = 1; (1 << i) <= dep[x]; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = 0; i < 26; i++)
if (son[x][i]) dfs(son[x][i], x);
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 15; i >= 0; i--)
if ((1 << i) <= dep[x] - dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 15; i >= 0; i--)
if ((1 << i) <= dep[x] && fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
struct Edge {
int y, next;
} e[Maxn * Maxl];
int len = 0, last[Maxn * Maxl];
void ins(int x, int y) {
int t = ++len;
e[t].y = y;
e[t].next = last[x];
last[x] = t;
}
bool cmp(int x, int y) { return dfn[x] < dfn[y]; }
int sta[Maxn], top;
long long f[Maxn * Maxl][Maxn];
void DFS(int x) {
for (int i = 1; i <= sz[x]; i++)
f[x][i] = (long long)i * (i - 1) / 2LL * dep[x];
for (int p = last[x]; p; p = e[p].next) {
int y = e[p].y;
DFS(y);
for (int i = sz[x]; i >= 0; i--)
for (int j = 0; j <= sz[y]; j++)
f[x][i + j] =
max(f[x][i + j],
f[x][i] + f[y][j] + ((x == 1) ? 0 : (long long)dep[x] * i * j));
sz[x] += sz[y];
}
}
int main() {
memset(f, 0, sizeof(f));
n = read(), k = read();
for (int i = 1; i <= n; i++) {
scanf("%s", str + 1);
build();
}
dep[0] = -1;
dfs(1, 0);
for (int i = 1; i <= tot; i++)
if (mark[i]) a[++la] = i;
sort(a + 1, a + 1 + la, cmp);
sta[top = 1] = 1;
for (int i = 1; i <= la; i++) {
int p = LCA(a[i], sta[top]);
if (p == sta[top]) {
if (a[i] != sta[top]) sta[++top] = a[i];
continue;
}
while (top > 1 && dep[sta[top - 1]] >= dep[p])
ins(sta[top - 1], sta[top]), top--;
if (sta[top] != p) ins(p, sta[top]), sta[top] = p;
sta[++top] = a[i];
}
while (top > 1) ins(sta[top - 1], sta[top]), top--;
DFS(1);
printf("%lld", f[1][k]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int n_max = 400005;
int n, i, j, x, y, a[n_max], timer, Q;
vector<int> g[n_max];
int l[n_max], r[n_max], f[n_max];
int h[n_max], k;
void add(int x, int k) {
for (int i = x; i < n_max; i = 2 * i - (i & (i - 1))) f[i] += k;
}
int sum(int x) {
int s = 0;
while (x) {
s += f[x];
x &= x - 1;
}
return s;
}
void go(int u, int p) {
int i, to;
l[u] = ++timer;
h[u] = h[p] + 1;
for (i = 0; i < g[u].size(); i++) {
to = g[u][i];
if (to == p) continue;
go(to, u);
}
r[u] = ++timer;
}
int main() {
scanf("%d%d", &n, &Q);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
go(1, 0);
while (Q--) {
scanf("%d", &k);
if (k == 1) {
scanf("%d%d", &x, &y);
if (h[x] % 2 == 0) y *= -1;
add(l[x], y);
add(r[x] + 1, -y);
} else {
scanf("%d", &x);
y = sum(l[x]);
if (h[x] % 2 == 0) y *= -1;
printf("%d\n", y + a[x]);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int _Int() {
int x;
scanf("%d", &x);
return x;
}
long long int bigMod(long long int A, long long int P, int M) {
long long int R = 1;
for (A %= M; P; P >>= 1) {
if (P & 1) R = (R * A) % M;
A = (A * A) % M;
}
return R;
}
long long int bigMul(long long int A, long long int B, long long int M) {
long long int R = 0;
for (A %= M; B; B >>= 1) {
if (B & 1) R = (R + A) % M;
A = (A + A) % M;
}
return R;
}
long long int negMod(long long int A, long long int B) {
return (((A % B) + B) % B);
}
long long int invMod(long long int A, long long int M) {
return bigMod(A, M - 2, M);
}
unsigned long long int _pow(unsigned long long int A, int P) {
unsigned long long int R = 1;
for (; P; P >>= 1) {
if (P & 1) R = (R * A);
A = (A * A);
}
return R;
}
template <class T>
T GCD(T x, T y) {
while (x) x ^= y ^= x ^= y %= x;
return y;
}
template <class T>
bool inRng(T u, T v, T x) {
return u <= x && x <= v;
}
const int RNG = 2000001;
int Prime[RNG], Prime_sz;
int bitsieve[(RNG >> 5) + 3];
bool is_composite(int i) {
int first = i >> 5;
int bit = i - (first << 5);
return (bitsieve[first] & (1 << bit));
}
void bitsieve_mark(int i) {
int first = i >> 5;
int bit = i - (first << 5);
bitsieve[first] = bitsieve[first] | (1 << bit);
}
void bitsieve_precal() {
int sqrtrng = sqrt(RNG) + 1, i, j, k;
for (i = 4; i < RNG; i += 2) bitsieve_mark(i);
for (i = 3; i < sqrtrng; i++) {
if (is_composite(i)) continue;
for (j = i * i, k = i + i; j < RNG; j += k) bitsieve_mark(j);
}
Prime_sz = 0;
Prime[Prime_sz++] = 2;
for (i = 3; i < RNG; i += 2) {
if (!is_composite(i)) Prime[Prime_sz++] = i;
}
}
int n;
long long int rcost, icost;
int A[RNG];
int binSearch(int &p) {
int mid, Ans = 0, low = 1, high = p - 1;
while (low <= high) {
mid = (high + low) >> 1;
if ((p - mid) * icost > rcost) {
Ans = mid;
low = mid + 1;
} else
high = mid - 1;
}
return Ans;
}
long long int rsuma[RNG];
long long int rcnta[RNG];
long long int rcnt(int a, int b) { return rcnta[b] - rcnta[a - 1]; }
long long int rsum(int a, int b) { return rsuma[b] - rsuma[a - 1]; }
void Main() {
n = _Int();
rcost = _Int();
icost = _Int();
for (int i = 0; i < n; i++) {
A[i] = _Int();
rcnta[A[i]]++;
rsuma[A[i]] += A[i];
}
for (int i = 1; i < RNG; i++) {
rcnta[i] += rcnta[i - 1];
rsuma[i] += rsuma[i - 1];
}
long long int Ans;
for (int i0 = 0; i0 < Prime_sz; i0++) {
int &p = Prime[i0];
long long int calc = 0;
int first = p, bs = p - binSearch(p);
for (int i = 1; first < (RNG); i += p) {
calc += rcnt(i, first - bs) * rcost;
calc += (first * rcnt(first - bs + 1, first - 1) -
rsum(first - bs + 1, first - 1)) *
(long long int)icost;
first += p;
}
if (!i0) Ans = calc;
Ans = min(Ans, calc);
}
printf("%lld\n", Ans);
}
int main() {
bitsieve_precal();
Main();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[5010][5010];
char s[20], s1[20], s2[20];
int ll[5010], rr[5010], mid[5010];
char ans[2][5010];
map<string, int> mp;
int cal(int a, int b, int op) {
if (op == 0) {
if (a > 1 && b > 1) return a == b ? 0 : 1;
if (b > 1) swap(a, b);
return b == 0 ? a : (a ^ 1);
} else if (op == 1) {
if (a > 1 && b > 1) return a == b ? a : 0;
if (b > 1) swap(a, b);
return b == 0 ? 0 : a;
} else {
if (a > 1 && b > 1) return a == b ? a : 1;
if (b > a) swap(a, b);
return b == 0 ? a : 1;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s := ", s);
mp[string(s)] = i;
gets(s);
if ('0' <= s[0] && s[0] <= '1') {
for (int j = 0; j < m; ++j) a[i][j] = s[j] - '0';
mid[i] = -1;
} else {
bool X = 0, A = 0;
int len = strlen(s);
for (int j = 0; j < len; ++j)
if (s[j] == 'A')
A = 1;
else if (s[j] == 'X')
X = 1;
int op = 0;
if (X)
sscanf(s, "%s XOR %s", s1, s2), op = 0;
else if (A)
sscanf(s, "%s AND %s", s1, s2), op = 1;
else
sscanf(s, "%s OR %s", s1, s2), op = 2;
if (s1[0] == '?')
ll[i] = n + 1;
else
ll[i] = mp[string(s1)];
mid[i] = op;
if (s2[0] == '?')
rr[i] = n + 1;
else
rr[i] = mp[string(s2)];
}
}
for (int i = 0; i < m; ++i) a[n + 1][i] = 2;
for (int i = 1; i <= n; ++i)
if (mid[i] != -1) {
for (int j = 0; j < m; ++j)
a[i][j] = cal(a[ll[i]][j], a[rr[i]][j], mid[i]);
}
for (int j = 0; j < m; ++j) {
int u = 0, v = 0;
for (int i = 1; i <= n; ++i)
if (a[i][j] == 2)
++u;
else if (a[i][j] == 3)
++v;
if (u > v)
ans[0][j] = '0', ans[1][j] = '1';
else if (u < v)
ans[0][j] = '1', ans[1][j] = '0';
else
ans[0][j] = ans[1][j] = '0';
}
ans[1][m] = ans[0][m] = 0;
printf("%s\n%s\n", ans[0], ans[1]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int long long n;
cin >> n;
if (n == 3)
cout << 1 << endl;
else
cout << (n - 4) * n + 4 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
vector<bool> sieve(3000000, true);
sieve[0] = false;
sieve[1] = false;
for (int i = 2; i <= 2000; i++) {
if (!sieve[i]) continue;
int sum = i + i;
while (sum <= 2000000) {
sieve[sum] = false;
sum += i;
}
}
int N;
cin >> N;
vector<int> nums(N);
int numOnes = 0;
bool hasGoodEven = false;
int goodEven = 0;
for (int i = 0; i < N; i++) {
cin >> nums[i];
if (nums[i] == 1)
numOnes++;
else if (sieve[nums[i] + 1]) {
hasGoodEven = true;
goodEven = nums[i];
}
}
if (numOnes + hasGoodEven >= 2) {
cout << numOnes + hasGoodEven << endl;
for (int i = 0; i < numOnes; i++) {
cout << "1 ";
}
if (hasGoodEven) cout << goodEven;
cout << endl;
return 0;
}
vector<int> res;
for (int i = 0; i < N - 1; i++) {
for (int j = i + 1; j < N; j++) {
int curSum = nums[i] + nums[j];
if (sieve[curSum]) {
cout << "2" << endl;
cout << nums[i] << " " << nums[j] << endl;
return 0;
}
}
}
cout << "1" << endl;
cout << nums[0] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, i = 1, lv = 0, slay[301];
vector<vector<int> > tab(301);
int s[301], is = 0, ip = 1, pre[301], ij[301], ji[301], son[301], par[301],
act = 1, x;
int w[100 * 301], w2[301], iw = 0, iw2 = 0;
int anc(int a, int b) {
if (pre[a] <= pre[b] && pre[a] + son[a] > pre[b]) return 1;
return 0;
}
int main() {
scanf("%d", &n);
while (i < n) {
scanf("%d %d", &a, &b);
tab[a].push_back(b), tab[b].push_back(a);
ij[a]++, ij[b]++;
i++;
}
s[0] = 1, is = 1, pre[1] = 1, ip = 2;
for (int z = 0; z <= n; z++) ji[z] = ij[z];
while (is > 0) {
a = s[is - 1];
if (ji[a] > 0 && par[a] == tab[a][ji[a] - 1]) ji[a]--;
if (ji[a] > 0)
b = s[is] = tab[a][ji[a] - 1], pre[b] = ip, par[b] = a, ip++, ji[a]--,
is++;
else {
son[a]++;
if (son[a] == 1) lv++;
son[par[a]] += son[a];
is--;
}
}
w[0] = 1, iw++, i = 0;
while (i < lv) {
scanf("%d", &a);
b = a;
while (anc(act, a) == 0) {
slay[act]++;
act = par[act];
w[iw] = act, iw++;
}
while (a != act) {
w2[iw2] = a;
slay[a]++;
a = par[a];
iw2++;
}
iw2--;
while (iw2 >= 0) {
w[iw] = w2[iw2];
iw2--, iw++;
}
act = b;
iw2 = 0, i++;
}
while (act != 1) {
slay[act]++;
act = par[act];
w[iw] = act;
iw++;
}
i = 1;
while (i <= n) {
if (slay[i] > 2) break;
i++;
}
if (i <= n) {
printf("-1");
return 0;
}
i = 0;
while (i < iw) {
printf("%d ", w[i]);
i++;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long x, long long y) {
long long res = 1;
for (; y; y >>= 1) {
if (y & 1) res = res * x % 1000000007;
x = x * x % 1000000007;
}
return res;
}
long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); }
long long fac[1000010], ivf[1000010], inv[1000010];
void initfac() {
fac[0] = ivf[0] = inv[1] = 1;
for (long long i = 1; i < 1000010; i++) {
if (i > 1)
inv[i] =
(1000000007 - 1000000007 / i * inv[1000000007 % i] % 1000000007) %
1000000007;
ivf[i] = ivf[i - 1] * inv[i] % 1000000007;
fac[i] = fac[i - 1] * i % 1000000007;
}
}
long long Pmod(long long n, long long k) {
if (n < k) return 0;
if (k < 0) return 0;
return fac[n] * ivf[n - k] % 1000000007;
}
long long Cmod(long long n, long long k) {
if (n < k) return 0;
if (k < 0) return 0;
return fac[n] * ivf[n - k] % 1000000007 * ivf[k] % 1000000007;
}
class UnionFind {
public:
int n, *dat;
int comp;
void init(int N) {
n = N;
dat = new int[n];
for (int i = 0; i < n; i++) dat[i] = -1;
comp = n;
}
int par(int x) {
if (dat[x] < 0) return x;
return par(dat[x]);
}
void unite(int a, int b) {
a = par(a), b = par(b);
if (a == b) return;
if (-dat[a] < -dat[b]) swap(a, b);
dat[a] += dat[b];
dat[b] = a;
comp--;
}
bool same(int a, int b) {
a = par(a), b = par(b);
return a == b;
}
int size(int a) {
a = par(a);
return -dat[a];
}
};
long long n, p[1010];
long long a[1010], b[1010];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> p[i];
a[0] = 4e18;
for (int i = 0; i < n; i++) a[i + 1] = min(a[i], p[i]);
b[n] = 4e18;
for (int i = n - 1; i >= 0; i--) {
b[i] = min(b[i + 1], p[i]);
}
for (int i = 1; i < n - 1; i++) {
if (a[i] < p[i] && p[i] > b[i + 1]) {
int x, y, z;
for (int j = 0; j < n; j++)
if (p[j] == a[i]) x = j;
y = i;
for (int j = 0; j < n; j++)
if (p[j] == b[i + 1]) z = j;
cout << "YES\n";
cout << x + 1 << " " << y + 1 << " " << z + 1 << "\n";
return;
}
}
cout << "NO\n";
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
long long t;
cin >> t;
while (t--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inft = 1000000009;
const int MAXN = 1000006;
pair<int, int> P[MAXN];
int deg[MAXN];
int n;
bool dasie(int w) {
long long tot = 1LL * w * (w - 1) / 2;
if (w % 2 == 0) tot += w / 2;
if (w % 2 == 0) tot--;
return tot <= n - 1;
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (m); ++i) scanf("%d%d", &P[i].second, &P[i].first);
sort(P, P + m);
reverse(P, P + m);
int p = 0, k = m + 1;
while (p + 1 < k) {
int w = (p + k) / 2;
if (dasie(w))
p = w;
else
k = w;
}
long long sum = 0;
for (int i = 0; i < (p); ++i) sum += P[i].first;
printf("%lld\n", sum);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long h[100010], p[100010];
long long pd(long long a, long long b, long long c) {
if (a >= c && b >= c) {
return b - c;
}
if (a < c && b < c) return c - a;
return min(c - a, b - c) + b - a;
}
bool check(long long lim) {
long long l = 1, i, j = 1;
for (i = 1; i <= m; ++i) {
while (pd(p[l], p[i], h[j]) > lim)
if (j < n)
++j, l = i;
else
return 0;
}
return 1;
}
int main() {
int i, j;
long long l = 0, r = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) cin >> h[i];
for (j = 1; j <= m; ++j) cin >> p[j];
r = (abs(h[1] - p[1]) + abs(h[1] - p[m])) << 1;
while (l < r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
cout << l;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long ms = 2e5 + 100;
const long long mod = 1e9 + 7;
const long long inf = 1e9;
const long long sigma = 30;
long long n, m, k, t = 1;
long long ele[ms];
void solve() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> ele[i];
}
long long j = 0;
while (j < n && ele[j] == -1) j++;
if (j == n) {
cout << 0 << ' ' << 0 << '\n';
return;
}
long long mi = inf + 100, mai = 0;
for (long long i = 0; i < n - 1; i++) {
if (ele[i] == -1 && ele[i + 1] != -1) {
mi = min(ele[i + 1], mi);
mai = max(ele[i + 1], mai);
}
}
for (long long i = n - 1; i > 0; i--) {
if (ele[i] == -1 && ele[i - 1] != -1) {
mi = min(ele[i - 1], mi);
mai = max(ele[i - 1], mai);
}
}
long long ans = (mi + mai) / 2;
long long m = 0;
long long mm = inf;
long long obj = 0;
for (long long i = -5ll; i < 5ll; i++) {
m = 0;
if (ans + i < 0) continue;
if (ans + i > inf) continue;
for (long long k = 0; k < n - 1; k++) {
m = max(m, abs((ele[k] == -1 ? ans + i : ele[k]) -
(ele[k + 1] == -1 ? ans + i : ele[k + 1])));
}
if (m < mm) {
mm = m;
obj = ans + i;
}
}
cout << mm << ' ' << obj << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n;
if (n == 1)
cout << "9 8";
else
cout << 3 * n << " " << 2 * n;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void Read(int &x) {
int f = 1;
char c = getchar();
x = 0;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
x *= f;
}
const int N = 2000010, p = 1000000007;
int n;
long long f[N], g[N];
struct Edge {
int to, nxt;
} e[N << 1];
int hd[N], cnt;
inline void ade(int u, int v) {
e[++cnt].to = v, e[cnt].nxt = hd[u], hd[u] = cnt;
}
void DFS(int u, int ff) {
f[u] = 1;
for (register int i = hd[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v != ff) {
DFS(v, u), f[u] = f[u] * (f[v] + 1) % p;
}
}
}
vector<long long> pre[N], suf[N];
void DFS2(int u, int ff) {
g[u] = 1;
for (register int i = hd[u]; i; i = e[i].nxt) {
int v = e[i].to;
g[u] = g[u] * (f[v] + 1) % p;
if (v != ff) {
pre[u].push_back(f[v] + 1), suf[u].push_back(f[v] + 1);
}
}
for (register int i = 1; i < pre[u].size(); i++) {
pre[u][i] = pre[u][i] * pre[u][i - 1] % p;
}
for (register int i = suf[u].size() - 2; i >= 0; i--) {
suf[u][i] = suf[u][i] * suf[u][i + 1] % p;
}
int s = 0;
for (register int i = hd[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v != ff) {
f[u] = (ff ? f[ff] + 1 : 1);
if (s > 0) f[u] = f[u] * pre[u][s - 1] % p;
if (s < suf[u].size() - 1) f[u] = f[u] * suf[u][s + 1] % p;
DFS2(v, u), s++;
}
}
}
signed main() {
Read(n);
for (register int i = 2, ff; i <= n; i++) {
Read(ff), ade(ff, i), ade(i, ff);
}
DFS(1, 0), DFS2(1, 0);
for (register int i = 1; i <= n; i++) cout << g[i] << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long int a, b, c, d, e, f, g, h[100005], arr[100005];
string s;
vector<long long int> v;
char ch;
int main() {
cin >> s;
char s2[100005];
for (long long int i = 0; i < s.size(); i++) {
if (s[i] != 'a') {
s2[a] = s[i];
a++;
}
}
if (a % 2 == 1) {
cout << ":(" << endl;
return 0;
}
b = a / 2;
for (long long int i = 0; i < b; i++) {
if (s2[i] != s2[i + b]) {
cout << ":(" << endl;
return 0;
}
}
c = s.size() - 1;
for (long long int i = a - 1; i >= b; i--, c--) {
if (s2[i] != s[c]) {
cout << ":(" << endl;
return 0;
}
}
for (long long int i = 0; i < s.size() - b; i++) {
cout << s[i];
}
}
| 1 |
#include <bits/stdc++.h>
long long INF = 1e9;
long long LINF = INF * INF;
long long mod = 1000000007;
using namespace std;
const long double EPS = 0.00000001;
int n, m, k;
int block = 1;
long long mas[200007];
long long cnt[4000007];
map<pair<int, int>, long long> res;
vector<pair<int, int> > qs[1000];
vector<pair<int, int> > ans;
bool comp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
long long add(int p) {
int res = cnt[mas[p] ^ k];
cnt[mas[p]]++;
return res;
}
long long del(int p) {
cnt[mas[p]]--;
return -cnt[mas[p] ^ k];
}
void make(int b) {
long long cur = 0;
int cl = b * block;
int cr = b * block - 1;
if (qs[b].size() > 0) {
cl = qs[b][0].first;
cr = qs[b][0].first - 1;
}
for (int i = 0; i < qs[b].size(); i++) {
pair<int, int> c = qs[b][i];
while (cr < c.second) {
cur += add(++cr);
}
while (cl < c.first) {
cur += del(cl++);
}
while (cl > c.first) {
cur += add(--cl);
}
res[c] = cur;
}
while (cr >= cl) del(cr--);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
while (block * block < n) block++;
for (int i = 1; i <= n; i++) {
cin >> mas[i];
}
for (int i = 2; i <= n; i++) {
mas[i] = mas[i] ^ mas[i - 1];
}
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
qs[a / block].push_back(make_pair(a, b));
ans.push_back(make_pair(a, b));
}
for (int i = 0; i <= block; i++) {
sort(qs[i].begin(), qs[i].end(), comp);
make(i);
}
for (int i = 0; i < m; i++) {
cout << res[ans[i]] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n;
char s[N];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++)
if (s[i] != '?' && s[i] == s[i - 1]) {
printf("No");
return 0;
}
if (s[1] == '?' || s[n] == '?') {
printf("Yes");
return 0;
}
for (int i = 1; i <= n; i++) {
if (s[i] == '?' && s[i - 1] == '?') {
printf("Yes");
return 0;
}
if (s[i] == '?' && s[i - 1] == s[i + 1]) {
printf("Yes");
return 0;
}
}
printf("No");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1000000007;
long long m, n;
int main() {
scanf("%164d %164d", &m, &n);
if (n == 1 && m == 1)
cout << 1;
else {
if (n > (m - n))
cout << n - 1;
else
cout << n + 1;
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.