solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int getint() {
unsigned int c;
int x = 0;
while (((c = getchar()) - '0') >= 10) {
if (c == '-') return -getint();
if (!~c) exit(0);
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while (((c = getchar()) - '0') < 10);
return x;
}
const int N = 100111;
const int TRUTH = 1, LIE = 1 << 1, CANTRUTH = 1 << 2, CANLIE = 1 << 3;
vector<int> doVoter[N];
vector<int> noVoter[N];
const char *answer[] = {"Not defined", "Truth", "Lie"};
int n, exactTruth;
int state[N];
int main() {
int i, j, tcc, tc = 1 << 28;
for (tcc = 0; tcc < tc; tcc++) {
for (i = 0; i < N; i++) doVoter[i].clear(), noVoter[i].clear();
fill(state, state + N, 0);
n = getint(), exactTruth = getint();
int doSayer = 0, noSayer = 0;
for (i = 1; i <= n; i++) {
int a = getint();
if (a < 0)
noVoter[-a].push_back(i), noSayer++;
else
doVoter[a].push_back(i), doSayer++;
}
int matchCount = 0, im;
for (i = 1; i <= n; i++) {
int tmpSupporter = noSayer - noVoter[i].size() + doVoter[i].size();
if (tmpSupporter == exactTruth) {
matchCount++, im = i;
for (j = 0; j < noVoter[i].size(); j++) state[noVoter[i][j]] |= CANLIE;
for (j = 0; j < doVoter[i].size(); j++)
state[doVoter[i][j]] |= CANTRUTH;
} else {
for (j = 0; j < doVoter[i].size(); j++) state[doVoter[i][j]] |= LIE;
for (j = 0; j < noVoter[i].size(); j++)
state[noVoter[i][j]] |= CANTRUTH;
}
}
if (matchCount == 1) {
for (i = 0; i < doVoter[im].size(); i++) state[doVoter[im][i]] |= TRUTH;
for (i = 0; i < noVoter[im].size(); i++) state[noVoter[im][i]] |= LIE;
} else {
for (i = 1; i <= n; i++)
if (CANLIE & state[i]) state[i] |= CANTRUTH;
for (i = 1; i <= n; i++) {
for (j = 0; j < doVoter[i].size(); j++) {
state[doVoter[i][j]] |= CANLIE;
}
}
}
for (i = 1; i <= n; i++) {
int s = state[i];
if ((s & LIE) and (s & TRUTH)) {
puts(answer[0]);
continue;
}
if (s & TRUTH) {
puts(answer[1]);
continue;
}
if (s & LIE) {
puts(answer[2]);
continue;
}
if ((s & CANTRUTH) and (s & CANLIE)) {
puts(answer[0]);
continue;
}
if (s & CANTRUTH) {
puts(answer[1]);
continue;
}
if (s & CANLIE) {
puts(answer[2]);
continue;
}
puts(answer[0]);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int s[5][5];
bool wu[5];
int c = 0;
vector<int> a;
void f(int t) {
if (t == n) {
a.push_back(c);
return;
}
f(t + 1);
for (int i = 0; i < n; ++i)
if (!wu[i] && s[t][i]) {
c += s[t][i];
wu[i] = true;
f(t + 1);
wu[i] = false;
c -= s[t][i];
}
}
int main() {
int k, t;
int h, w, r;
cin >> n >> k >> t;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) s[i][j] = 0;
for (int i = 0; i < k; ++i) {
cin >> h >> w >> r;
s[h - 1][w - 1] = r;
}
fill_n(wu, n, false);
f(0);
sort(a.begin(), a.end());
cout << a[t - 1];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e5 + 5;
long long n, a[INF], ans, ansx, b[INF], suma[INF], l[INF], r[INF];
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = (s << 1) + (s << 3) + (ch ^ 48);
ch = getchar();
}
return s * f;
}
void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
return;
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) {
a[i] = read();
b[i] = a[i];
suma[i] = suma[i - 1] + a[i];
}
for (long long i = 1; i <= n; i++) l[i] = max(l[i - 1] + a[i], -suma[i]);
for (long long i = n; i >= 1; i--)
r[i] = max(r[i + 1] + a[i], -(suma[n] - suma[i - 1]));
for (long long i = 0; i <= n; i++) ans = max(ans, l[i] + r[i + 1]);
write(ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, m;
cin >> n;
m = 24;
if (n < 4) {
cout << "NO";
return 0;
}
cout << "YES\n";
if (n % 4 == 0) {
cout << "1 * 2 = 2\n3 * 4 = 12\n2 * 12 = 24\n";
} else if (n % 4 == 1) {
cout << "4 * 5 = 20\n20 + 3 = 23\n23 + 2 = 25\n25 - 1 = 24\n";
} else if (n % 4 == 2) {
cout << "4 * 6 = 24\n24 + 5 = 29\n29 - 3 = 26\n26 - 2 = 24\n24 * 1 = 24\n";
} else if (n % 4 == 3) {
cout << "4 * 7 = 28\n28 - 6 = 22\n22 + 5 = 27\n27 - 3 = 24\n2 - 1 = 1\n24 "
"* 1 = 24\n";
}
int flag = 0;
for (int i = 4 + n % 4 + 1; i < n;) {
cout << m << " + " << i << " = " << m + i << "\n";
m += i;
i++;
cout << m << " - " << i << " = " << m - i << "\n";
m -= i;
i++;
cout << m << " - " << i << " = " << m - i << "\n";
m -= i;
i++;
cout << m << " + " << i << " = " << m + i << "\n";
m += i;
i++;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, cnt = 0;
cin >> a >> b >> c >> d;
vector<long long> v;
v.push_back(a);
v.push_back(b);
v.push_back(c);
sort(v.rbegin(), v.rend());
for (int i = 0; i < v.size() - 1; i++) {
if ((v[i] - v[i + 1]) < d) cnt += (d - (v[i] - v[i + 1]));
}
cout << cnt << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long sum(long long a, long long d, long long len, long long v,
long long mod) {
if (a > v) return 0;
len = min(len, 1 + ((v - a) / d));
if (len & 1) {
long long ret = (len - 1) / 2;
ret %= mod;
ret *= (d % mod);
ret %= mod;
ret += a;
ret %= mod;
ret *= (len % mod);
ret %= mod;
return ret;
}
long long ret = (len - 1) % mod;
ret *= (d % mod);
ret %= mod;
ret += 2 * a;
ret %= mod;
ret *= (len / 2) % mod;
ret %= mod;
return ret;
}
long long compute(long long s, long long e, long long l, long long r,
long long a, long long d, long long v, long long mod) {
if (l <= s && e <= r) return sum(a, d, e - s + 1, v, mod);
if (r < s || e < l) return 0;
long long m = (s + e) / 2;
long long ret = compute(s, m, l, r, a, 2 * d, v, mod);
ret += compute(m + 1, e, l, r, a + d, 2 * d, v, mod);
if (ret >= mod) ret -= mod;
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(32);
long long n, m, mod;
cin >> n >> m >> mod;
while (m--) {
long long l, r, u, v;
cin >> l >> r >> u >> v;
long long ans = compute(1, n, l, r, 1, 1, v, mod);
if (u != 1) ans -= compute(1, n, l, r, 1, 1, u - 1, mod);
if (ans < 0) ans += mod;
cout << ans << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, cnt = 0;
cin >> n;
vector<long long> a(n), b(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(a.begin(), a.end());
for (long long i = 0; i < n; i++) {
cnt += (a[i] != b[i]);
}
cout << (cnt <= 2 ? "YES" : "NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int time[10];
int k;
while (scanf("%d", &k) != EOF) {
for (int i = 0; i < 10; i++) time[i] = 0;
char str[10];
for (int j = 0; j < 4; j++) {
scanf("%s", &str);
for (int i = 0; i < 4; i++)
if (str[i] != '.') {
int s = str[i] - '0';
time[s]++;
}
}
int ans = true;
for (int i = 1; i <= 9; i++)
if (time[i] > 2 * k) {
ans = false;
break;
}
if (ans)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans;
ans = 0;
scanf("%d", &n);
int i, j, p;
for (i = 1; i <= n; i++) {
scanf("%d", &p);
for (j = 1; j * (j + 1) / 2 <= p; j++)
;
ans ^= j - 1;
}
if (ans)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 6 |
#include<iostream>
#include<climits>
#include<vector>
#include<numeric>
#include<queue>
#include<bits/stdc++.h>
#include<algorithm> //inbuilt gcd __gcd(a,b)
using namespace std;
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define endl "\n"
#define sz(s) s.size()
#define pi 3.14159265358979
//#define ll long long int
#define ld long double
#define pb push_back
#define mp make_pair
#define inf LLONG_MAX
#define f first
#define s second
#define all(v) v.begin(),v.end()
#define Yes(flag) flag==1?cout<<"YES\n":cout<<"NO\n"
#define lev cout<<"\n"
#define sum(a) ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a) (*min_element((a).begin(), (a).end()))
#define maxe(a) (*max_element((a).begin(), (a).end()))
#define mini(a) ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a) ( max_element((a).begin(), (a).end()) - (a).begin())
using ll = long long int;
using PII = pair<ll,ll>;
template<typename T> istream& operator>>(istream& is, vector<T> &v){for (auto& i : v) is >> i; return is;}
template<typename T> ostream& operator<<(ostream& os, vector<T> v){for (auto& i : v) os << i << ' '; return os;}
const ll N=1e5+5;
const ll mod=1e9+7;
vector<ll>v[N];
vector<PII>p[N];
ll vis[N]={0};
void time_taken()
{
#ifdef local
cout << endl;
cout << "Time Taken: " << (double)(clock() - zzz) / CLOCKS_PER_SEC << endl;
#endif
return;
}
vector<ll> fact(ll n)
{
vector<ll> x;
ll i;
for(i=1;i<=n;i++)
{
if(n%i==0)
x.pb(i);
}
return x;
}
ll factorial(ll x)
{
ll i=1;
while(x){i*=x;i=i%mod;x--;}
return i;
}
ll power(ll x,ll y,ll p = LLONG_MAX ){ll res=1;x%=p;while(y>0){if(y&1)res=(res*x)%p;y=y>>1;x=(x*x)%p;}return res;}
ll nCr(ll n,ll r,ll m=mod){if(r>n)return 0;ll a=1,b=1;while(r){a=(a*n)%m;--n;b=(b*r)%m;--r;}return (a*power(b,m-2,m))%m;}
void bfs(int s) {
queue <int> q;
q.push(s);
vis[ s ] = 1;
while(!q.empty())
{
int p = q.front();
q.pop();
for(int i = 0;i < v[ p ].size() ; i++)
{
if(vis[ v[ p ][ i ] ] == 0)
{
//Setting the level of each node with an increment in the level of parent node
q.push(v[ p ][ i ]);
vis[ v[ p ][ i ] ] = 1;
}
}
}
}
void dfs(int s)
{
vis[s] =1;
for(int i = 0;i < v[s].size();++i)
{
if(vis[v[s][i]] == 0)
dfs(v[s][i]);
}
}
bool bysec(pair<ll,ll>&a,pair<ll,ll>&b)
{
return a.second<b.second;
}
//------------------------------------//
void solve()
{
ll n,i,cou=0,x=0,flag=0;
cin>>n;
while(n)
{
n=n/2;
x++;
}
cout<<power(2,x-1)-1;
lev;
}
int main()
{ fast;
ll n=1;
cin>>n;
while(n--)
{
solve();
}
time_taken();
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int data;
node* left;
node* right;
};
map<int, node*> m;
void add(node* n, string s, int pos, int val) {
if (pos == s.size()) {
n->data += val;
n->left = NULL;
n->right = NULL;
return;
}
if (s[pos] == '0') {
if (n->left == NULL) {
n->left = new node;
n->left->data = 0;
n->left->left = NULL;
n->left->right = NULL;
}
add(n->left, s, pos + 1, val);
n->data += val;
} else {
if (n->right == NULL) {
n->right = new node;
n->right->data = 0;
n->right->left = NULL;
n->right->right = NULL;
}
add(n->right, s, pos + 1, val);
n->data += val;
}
}
int calculate(node* n, string s, int pos) {
if (s[pos] == '0') {
if (n->left == NULL)
return 0;
else
return calculate(n->left, s, pos + 1);
} else {
if (n->right == NULL) {
if (n->left == NULL)
return 0;
else
return n->left->data;
} else {
if (n->left == NULL)
return calculate(n->right, s, pos + 1);
else
return n->left->data + calculate(n->right, s, pos + 1);
}
}
}
int main() {
int i, j, k;
int n, type;
string s;
scanf("%d", &n);
while (n--) {
s = "";
scanf("%d", &type);
scanf("%d", &j);
scanf("%d", &k);
int z = 30;
while (z--) {
s = s + (char)(j % 2 + '0');
j /= 2;
}
reverse(s.begin(), s.end());
if (type == 1) {
if (m.find(k) == m.end()) {
m[k] = new node;
m[k]->data = 0;
m[k]->left = NULL;
m[k]->right = NULL;
}
add(m[k], s, 0, 1);
} else if (type == 2) {
if (m.find(k) == m.end()) {
m[k] = new node;
m[k]->data = 0;
m[k]->left = NULL;
m[k]->right = NULL;
}
add(m[k], s, 0, -1);
} else {
if (m.find(k) == m.end())
printf("0\n");
else
printf("%d\n", calculate(m[k], s, 0));
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long t;
long long a[200010];
int b[200010];
vector<long long> un;
void Insert(int x) {
for (int i = x + 1; i > 0; i -= i & -i) b[i]++;
}
int Get(int x) {
int res = 0;
for (int i = x + 1; i < 200005; i += i & -i) res += b[i];
return res;
}
int main() {
cin >> n >> t;
un.push_back(0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
un.push_back(a[i]);
}
sort(un.begin(), un.end());
un.erase(unique(un.begin(), un.end()), un.end());
long long res = 0;
int ind = lower_bound(un.begin(), un.end(), 0LL) - un.begin();
Insert(ind);
for (int i = 1; i <= n; i++) {
ind = upper_bound(un.begin(), un.end(), a[i] - t) - un.begin();
res += Get(ind);
ind = lower_bound(un.begin(), un.end(), a[i]) - un.begin();
Insert(ind);
}
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, mx = 0;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
mx = max(mx, v[i]);
}
vector<long long> r1, r2, s1, s2, p1, p2;
for (long long i = 0; i < mx; i++) {
r1.push_back(v[i]);
}
for (long long i = mx; i < n; i++) {
r2.push_back(v[i]);
}
bool fg1 = true, fg2 = true;
sort(r1.begin(), r1.end());
for (long long i = 0, j = 1; i < r1.size(); i++, j++) {
if (r1[i] != j) {
fg1 = false;
break;
}
}
sort(r2.begin(), r2.end());
for (long long i = 0, j = 1; i < r2.size(); i++, j++) {
if (r2[i] != j) {
fg2 = false;
break;
}
}
bool fg3 = true, fg4 = true;
for (long long i = 0; i < (n - mx); i++) {
s1.push_back(v[i]);
}
for (long long i = n - mx; i < n; i++) {
s2.push_back(v[i]);
}
sort(s1.begin(), s1.end());
for (long long i = 0, j = 1; i < s1.size(); i++, j++) {
if (s1[i] != j) {
fg3 = false;
break;
}
}
sort(s2.begin(), s2.end());
for (long long i = 0, j = 1; i < s2.size(); i++, j++) {
if (s2[i] != j) {
fg4 = false;
break;
}
}
vector<pair<long long, long long> > ans;
if (fg1 && fg2) ans.push_back({mx, n - mx});
if (fg3 && fg4) {
if (mx != n - mx) ans.push_back({n - mx, mx});
}
if (ans.size() == 0) {
cout << 0 << endl;
continue;
} else {
cout << ans.size() << endl;
for (long long i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[300005], n, k, m;
long long sum;
int main() {
cin >> n;
for (register int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (register int i = 1; i <= n; i++) sum += a[i];
cin >> m;
for (register int i = 1; i <= m; i++) {
cin >> k;
cout << sum - a[n - k + 1] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sumstr[26];
pair<string, string> to_get(string s) {
reverse(s.begin(), s.end());
string zc;
for (int i = 0; i < s.size(); i++) {
if (!sumstr[s[i] - 'a']) {
zc += s[i];
}
sumstr[s[i] - 'a']++;
}
int chushilenth = 0;
int m = zc.size();
for (int i = 0; i < m; i++) {
chushilenth += sumstr[zc[i] - 'a'] / (m - i);
}
reverse(zc.begin(), zc.end());
return {string(s.rbegin(), s.rbegin() + chushilenth), zc};
}
string check(pair<string, string> s) {
string chushi = s.first;
string zc = s.second;
string tt;
tt += chushi;
for (int i = 0; i < zc.size(); i++) {
string kk;
for (int j = 0; j < chushi.size(); j++) {
if (chushi[j] != zc[i]) kk += chushi[j];
}
tt += kk;
chushi = kk;
}
return tt;
}
int main() {
int t;
cin >> t;
while (t--) {
memset(sumstr, 0, sizeof sumstr);
string s;
cin >> s;
pair<string, string> get = to_get(s);
if (check(get) == s) {
cout << get.first << ' ' << get.second << endl;
} else
cout << -1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
inline void read(int &x) { scanf("%d", &x); }
inline void read(long long &x) { scanf("%I64d", &x); }
inline void read(double &x) { scanf("%lf", &x); }
inline void read(long double &x) {
double tmp;
read(tmp);
x = tmp;
}
template <class T>
inline void read(T *a, int n) {
for (int i = (0); i < (n); ++i) read(a[i]);
}
inline void write(int x) { printf("%d", x); }
inline void write(long long x) { printf("%I64d", x); }
inline void write(double x) { printf("%.10lf", x); }
inline void write(long double x) { printf("%.10lf", (double)x); }
template <class T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
template <class T>
inline void writeln(T *a, int n) {
for (int i = (0); i < (n); ++i) write(a[i]);
putchar('\n');
}
template <class T>
inline void writelnln(T *a, int n) {
for (int i = (0); i < (n); ++i) writeln(a[i]);
}
char a[100086];
int n;
unsigned int _dp[250086], *dp = _dp + 100008;
int main() {
read(n);
scanf("%s", a + 1);
memset(_dp, 0, sizeof(_dp));
dp[0] = 1;
for (int i = (1); i <= (n); ++i)
if (a[i] == '?') {
register int til = std::min(i, n - i);
register unsigned int *p1 = dp + til + 1;
while (til--) {
*p1 += *(p1 - 2) * 25u;
--p1;
}
++dp;
} else
*(--dp) = 0;
printf("%u\n", dp[0]);
return 0;
}
| 10 |
#include <iostream>
#include <string>
using namespace std;
pair<int, int> update_pos(const pair<int, int>& cur_pos, char dir) {
pair<int, int> res = cur_pos;
if (dir == 'L') res.first--;
else if (dir == 'R') res.first++;
else if (dir == 'D') res.second--;
else res.second++;
return res;
}
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int n = s.length();
bool found_obstacle = false;
for (int i = 0; i < n; i++) {
pair<int, int> cur_pos(0, 0);
pair<int, int> obstacle(0, 0);
for (int j = 0; j <= i; j++) {
obstacle = update_pos(obstacle, s[j]);
}
for (int j = 0; j < n; j++) {
// if (j < i) cur_pos = update_pos(cur_pos, s[j]);
// else if (j == i) obstacle = update_pos(cur_pos, s[i]);
// else {
pair<int, int> temp = update_pos(cur_pos, s[j]);
if (temp != obstacle) cur_pos = temp;
// }
}
if (cur_pos == make_pair(0, 0)) {
cout << obstacle.first << " " << obstacle.second << endl;
found_obstacle = true;
break;
}
}
if (!found_obstacle) cout << "0 0\n";
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e7 + 5;
int main() {
int t, n;
int a[100005];
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n;
vector<int> b;
for (int j = 0; j < n; j++) cin >> a[j];
int l = 1;
b.push_back(a[0]);
while (l <= n - 2) {
if ((a[l] > a[l - 1] && a[l] > a[l + 1]) ||
(a[l] < a[l - 1] && a[l] < a[l + 1]))
b.push_back(a[l]);
l++;
}
b.push_back(a[n - 1]);
cout << b.size() << endl;
for (int j = 0; j < b.size(); j++) cout << b[j] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long const max1 = 2e5 + 5;
long long const mod = 1e9 + 7;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
long long n, s;
cin >> n >> s;
if (s - n > n - 1) {
cout << "YES\n";
for (long long i = 0; i < n - 1; i++) {
cout << 1 << " ";
}
cout << s - n + 1 << "\n";
cout << s - n;
} else {
cout << "NO";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long getPower(int a, int b) {
long long ans = 1;
for (int i = 1; i <= b; i++) ans *= a;
return ans;
}
int main() {
long long n;
cin >> n;
long long check = 10;
int val = 1;
while (n >= check) {
check *= 10;
val++;
}
long long temp = getPower(10, val - 1) - 1;
temp = n - temp;
temp = temp * val;
long long ans = temp;
for (int i = 1; i < val; i++) ans += i * 9 * getPower(10, i - 1);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int maxn = 1005;
long long a[300000];
priority_queue<long long> ql;
map<long long, long long> ma;
map<long long, long long> num;
vector<long long> ans;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n * n; i++) {
cin >> a[i];
ql.push(a[i]);
}
while (!ql.empty()) {
long long z = ql.top();
ql.pop();
if (ma[z] != 0) {
ma[z]--;
continue;
} else {
for (int i = 0; i < ans.size(); i++) {
ma[gcd(ans[i], z)] += 2;
}
ans.push_back(z);
continue;
}
}
for (int i = 0; i < ans.size() - 1; i++) cout << ans[i] << " ";
cout << ans[ans.size() - 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, mod = 1e9 + 7;
map<long long, long long> mp;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
cin >> n;
vector<long long> a(n + 1);
vector<long long> us(512);
vector<long long> use(512);
for (long long i = 1; i <= n; ++i) cin >> a[i];
us[0] = 1;
use[0] = -1;
for (long long i = 1; i < 512; ++i) use[i] = LLONG_MAX;
for (long long i = 1; i <= n; ++i) {
for (long long j = 0; j < 512; ++j)
if (us[j] && use[j] < a[i]) {
long long x = j ^ a[i];
us[x] = 1;
use[x] = min(a[i], use[x]);
}
}
vector<long long> v;
for (long long i = 0; i < 512; ++i)
if (us[i]) v.push_back(i);
cout << v.size() << "\n";
for (auto i : v) cout << i << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const double eps = 1e-8;
const int maxn = 2002;
const int maxm = 3e4 + 5;
const long long mod = 1e9 + 7;
const long long inf = 2e18 + 5;
const int _inf = -1e9 + 7;
inline int scan() {
int m = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') m = m * 10 + c - '0', c = getchar();
return m;
}
int N, Q, S, H;
double P;
double dp[2002][2002][4], lp[2002][2002], rr[2002][2002];
int lb[2002], rb[2002], num[2002];
double work(int l, int r) {
if (l > r) return 0;
return dp[l][r][0] * 0.5 * P + dp[l][r][1] * 0.5 * (1 - P) +
dp[l][r][2] * 0.5 * P + dp[l][r][3] * 0.5 * (1 - P);
}
void dfs(int l, int r) {
if (rr[l][r] != -1 || l > r) return;
dfs(l, r - 1);
dfs(l + 1, r);
dfs(l, lb[r] - 1);
dfs(rb[l] + 1, r);
lp[l][r] = 0.5 * P;
rr[l][r] = 0.5 * (1 - P);
if (l == r) {
lp[l][r] = P;
rr[l][r] = 1 - P;
} else {
rr[l][r] += rr[l + 1][r] * 0.5 * (P);
lp[l][r] += lp[l][r - 1] * 0.5 * (1 - P);
if (lb[r] <= l) {
lp[l][r] += 0.5 * P;
} else {
lp[l][r] += lp[l][lb[r] - 1] * 0.5 * P;
}
if (rb[l] >= r) {
rr[l][r] += 0.5 * (1 - P);
} else {
rr[l][r] += rr[rb[l] + 1][r] * 0.5 * (1 - P);
}
}
dp[l][r][0] = work(l + 1, r) + H;
dp[l][r][3] = work(l, r - 1) + H;
dp[l][r][1] = work(rb[l] + 1, r) + num[min(rb[l], r)] - num[l] + H;
dp[l][r][2] = work(l, lb[r] - 1) + num[r] - num[max(l, lb[r])] + H;
if (l < r && num[l + 1] - num[l] < H) {
dp[l][r][0] -= lp[l + 1][r] * (H - num[l + 1] + num[l]);
}
if (rb[l] < r && 2 * H > num[rb[l] + 1] - num[rb[l]]) {
dp[l][r][1] -= lp[rb[l] + 1][r] * (2 * H - num[rb[l] + 1] + num[rb[l]]);
}
if (l < r && num[r] - num[r - 1] < H) {
dp[l][r][3] -= rr[l][r - 1] * (H - num[r] + num[r - 1]);
}
if (l < lb[r] && 2 * H > num[lb[r]] - num[lb[r] - 1]) {
dp[l][r][2] -= rr[l][lb[r] - 1] * (2 * H - num[lb[r]] + num[lb[r] - 1]);
}
}
int main() {
for (int i = 0; i < 2002; i++)
for (int j = 0; j < 2002; j++) rr[i][j] = -1;
cin >> N >> H >> P;
for (int i = 1; i <= N; i++) scanf("%d", num + i);
sort(num + 1, num + 1 + N);
lb[1] = 1;
for (int i = 2; i <= N; i++) {
if (num[i] - num[i - 1] < H)
lb[i] = lb[i - 1];
else
lb[i] = i;
}
rb[N] = N;
for (int i = N - 1; i > 0; i--) {
if (num[i + 1] - num[i] < H)
rb[i] = rb[i + 1];
else
rb[i] = i;
}
dfs(1, N);
printf("%.10lf\n", work(1, N));
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main(void) {
int n, w;
int el[(4 * 100 * 1000)], be[(4 * 100 * 1000)];
int k[(4 * 100 * 1000)];
int i, j, z;
scanf("%d %d", &n, &w);
if (w == 1) {
printf("%d\n", n);
return 0;
}
n--;
for (i = 0; i <= n; i++) {
if (i == 0) {
scanf("%d", &z);
} else {
scanf("%d", &j);
be[i - 1] = j - z;
z = j;
}
}
w--;
for (i = 0; i <= w; i++) {
if (i == 0) {
scanf("%d", &z);
} else {
scanf("%d", &j);
el[i - 1] = j - z;
z = j;
}
}
i = 0;
j = -1;
k[0] = -1;
while (i < w) {
while (j >= 0 && el[i] != el[j]) j = k[j];
i++;
j++;
k[i] = j;
}
i = 0;
j = 0;
z = 0;
while (i < n) {
while (j >= 0 && be[i] != el[j]) j = k[j];
i++;
j++;
if (j == w) {
z++;
j = k[j];
}
}
printf("%d\n", z);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int cnt;
string str;
char c;
cin >> n;
if (n == 0) {
cout << "a" << endl;
return 0;
}
str = "";
c = 'a';
while (n) {
cnt = 0;
while (cnt <= n) {
n -= cnt;
str += c;
cnt++;
}
c++;
}
cout << str << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
stringstream ss;
int main() {
int n, m;
cin >> n >> m;
vector<pair<string, string> > best;
string a, b, c;
for (int i = 0; i < m; i++) {
cin >> a >> b;
if (a.length() > b.length())
c = b;
else
c = a;
best.push_back(make_pair(a, c));
}
for (int i = 0; i < n; i++) {
cin >> c;
int j = 0;
while (best[j].first != c) j++;
cout << best[j].second << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = (1 << 20) + 7;
void Xor(int n, long long *a, long long op) {
long long x, y;
for (int w = 2, l = 1; w <= n; w <<= 1, l <<= 1)
for (int j = 0; j < n; j += w)
for (int k = 0; k < l; k++)
x = (a[j | k] + a[j | k | l]) / op, y = (a[j | k] - a[j | k | l]) / op,
a[j | k] = x, a[j | k | l] = y;
}
int n, m;
long long a[N], f[N], g[N];
inline int min(int x, int y) { return x < y ? x : y; }
inline int lowbit(int x) { return -x & x; }
inline int count(int x) {
int ret = 0;
while (x) x -= lowbit(x), ret++;
return ret;
}
int main() {
scanf("%d%d", &n, &m);
int ans = n * m;
for (int i = 1; i <= n; i++) {
char c;
for (int j = 1; j <= m; j++) {
c = getchar();
while (c != '0' && c != '1') c = getchar();
a[j] = (a[j] << 1) + c - '0';
}
}
for (int i = 1; i <= m; i++) f[a[i]]++;
m = 1 << n;
for (int i = 0; i < m; i++) {
int x = count(i);
g[i] = min(n - x, x);
}
Xor(m, f, 1), Xor(m, g, 1);
for (int i = 0; i < m; i++) f[i] = f[i] * g[i];
Xor(m, f, 2);
for (int i = 0; i < m; i++) ans = min(ans, f[i]);
printf("%d", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int p[100005], r[100005], k[100005];
vector<long long int> a;
vector<long long int> adj[100005];
void dfs(long long int node, long long int pa) {
k[node] = r[node];
for (auto i : adj[node]) {
if (i != pa) {
k[node] &= r[i];
dfs(i, node);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int n, root, flg = 0;
cin >> n;
for (long long int i = 1; i <= n; i++) {
cin >> p[i] >> r[i];
if (p[i] != -1) {
adj[p[i]].push_back(i);
adj[i].push_back(p[i]);
} else
root = i;
}
dfs(root, -1);
for (long long int i = 0; i <= n; i++)
if (k[i]) a.push_back(i);
sort((a).begin(), (a).end());
if (a.size())
for (long long int i = 0; i < a.size(); i++) cout << a[i] << " ";
else
cout << -1;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100], s = 0, i, j;
int vis[100];
for (i = 0; i < 100; i++) vis[i] = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
s /= (n / 2);
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (a[j] + a[i] == s && vis[j] == 0 && vis[i] == 0) {
cout << i + 1 << " " << j + 1 << "\n";
vis[j] = 1;
vis[i] = 1;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
int m = n.length();
for (int i = n.length() - 1; i > 0; i--) {
if (n[i] == '1') {
m++;
break;
}
}
cout << m / 2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1555;
const int INF = 0x3f3f3f3f;
char Map[N][N];
int n, m;
int sx, sy;
int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
struct node {
int x, y;
} vis[N][N];
bool bfs(int x, int y) {
node now, next;
now.x = x;
now.y = y;
queue<node> q;
q.push(now);
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
next.x = now.x + dir[i][0];
next.y = now.y + dir[i][1];
if (Map[(next.x % n + n) % n][(next.y % m + m) % m] != '#') {
if (vis[(next.x % n + n) % n][(next.y % m + m) % m].x == INF) {
vis[(next.x % n + n) % n][(next.y % m + m) % m].x = next.x;
vis[(next.x % n + n) % n][(next.y % m + m) % m].y = next.y;
q.push(next);
} else if (next.x !=
vis[(next.x % n + n) % n][(next.y % m + m) % m].x ||
next.y !=
vis[(next.x % n + n) % n][(next.y % m + m) % m].y) {
return true;
}
}
}
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
memset(vis, INF, sizeof(vis));
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> Map[i][j];
if (Map[i][j] == 'S') sx = i, sy = j;
}
}
if (bfs(sx, sy))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2005 * 60;
const long long INF = 0x3f3f3f3f;
const long long MAXC = 7;
const long long MOD = 1e9 + 7;
long long inline read() {
long long x = 0, f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f ^= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
long long inline qpow(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1) ret = ret * x % MOD;
y >>= 1;
x = x * x % MOD;
}
return ret;
}
long long n, m, cnt = 0, sta[MAXN], stop = 0, col[MAXN];
map<long long, long long> mp;
struct dp_val {
long long f[MAXC];
};
dp_val dfs(long long u, long long dep) {
long long nullans = qpow(4, (1ll << (n - dep + 1)) - 2);
if (!mp[u])
return dp_val{{0, nullans, nullans, nullans, nullans, nullans, nullans}};
dp_val lans, rans, ans;
if (dep < n) {
lans = dfs(u << 1, dep + 1);
rans = dfs(u << 1 | 1, dep + 1);
ans = {{0, 0, 0, 0, 0, 0, 0}};
for (long long i = 1; i <= 6; ++i) {
for (long long j = 1; j <= 6; ++j)
for (long long k = 1; k <= 6; ++k)
if (i != j && i + j != 7 && i != k && i + k != 7)
ans.f[i] = (ans.f[i] + lans.f[j] * rans.f[k]) % MOD;
}
} else
ans = {{0, 1, 1, 1, 1, 1, 1}};
if (col[mp[u]])
for (long long i = 1; i <= 6; ++i)
if (i != col[mp[u]]) ans.f[i] = 0;
return ans;
}
signed main() {
n = read();
m = read();
for (long long i = 1; i <= m; ++i) {
char str[MAXN];
long long u = read(), w;
scanf("%s", str);
if (!strcmp(str, "white")) w = 1;
if (!strcmp(str, "yellow")) w = 6;
if (!strcmp(str, "green")) w = 3;
if (!strcmp(str, "blue")) w = 4;
if (!strcmp(str, "red")) w = 5;
if (!strcmp(str, "orange")) w = 2;
if (!mp[u]) mp[u] = ++cnt, sta[++stop] = u;
col[mp[u]] = w;
while (u != 1) {
u >>= 1;
if (!mp[u]) mp[u] = ++cnt, sta[++stop] = u;
}
}
dp_val ans = dfs(1, 1);
long long final_ans = 0;
for (long long i = 1; i <= 6; ++i) final_ans = (final_ans + ans.f[i]) % MOD;
printf("%lld\n", final_ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a[222222], tp, l, r, k, q, crt;
struct treenode {
int sum, len, mn1, mn2, lazy;
bool can(int a, int b) {
if (mn1 <= 0 || mn2 < 0) return 0;
if ((b - a) & 1) return (sum == 0);
return (sum == 1);
}
} tree1[888888], tree2[888888], t1, t2;
void merge(treenode &a, treenode b, treenode c) {
a.lazy = 0;
a.len = b.len + c.len;
if (b.len & 1) {
a.sum = b.sum - c.sum;
} else {
a.sum = b.sum + c.sum;
}
if (c.len & 1) {
a.mn1 = min(c.mn1, b.mn2 + c.sum);
a.mn2 = min(c.mn2, b.mn1 - c.sum);
} else {
a.mn1 = min(c.mn1, b.mn1 - c.sum);
a.mn2 = min(c.mn2, b.mn2 + c.sum);
}
}
void build1(int l, int r, int node) {
tree1[node].len = r - l + 1;
if (l == r) {
tree1[node].sum = tree1[node].mn1 = a[l];
tree1[node].lazy = 0;
tree1[node].mn2 = 1e9;
return;
}
int mid = (l + r) >> 1;
build1(l, mid, node << 1);
build1(mid + 1, r, (node << 1) | 1);
merge(tree1[node], tree1[node << 1], tree1[(node << 1) | 1]);
}
void build2(int l, int r, int node) {
tree2[node].len = r - l + 1;
if (l == r) {
tree2[node].sum = tree2[node].mn1 = a[n - l + 1];
tree2[node].lazy = 0;
tree2[node].mn2 = 1e9;
return;
}
int mid = (l + r) >> 1;
build2(l, mid, node << 1);
build2(mid + 1, r, (node << 1) | 1);
merge(tree2[node], tree2[node << 1], tree2[(node << 1) | 1]);
}
void push1(int node, int x) {
if (tree1[node].len & 1) tree1[node].sum += x;
tree1[node].mn1 += x;
tree1[node].lazy += x;
}
void pushdown1(int node) {
if (tree1[node].lazy) {
push1(node << 1, tree1[node].lazy);
push1((node << 1) | 1, tree1[node].lazy);
tree1[node].lazy = 0;
}
}
void update1(int beg, int en, int l, int r, int node, int x) {
if (l > en || r < beg) return;
if (l >= beg && r <= en) {
push1(node, x);
return;
}
int mid = (l + r) >> 1;
pushdown1(node);
update1(beg, en, l, mid, node << 1, x);
update1(beg, en, mid + 1, r, (node << 1) | 1, x);
merge(tree1[node], tree1[node << 1], tree1[(node << 1) | 1]);
}
treenode query1(int beg, int en, int l, int r, int node) {
if (l >= beg && r <= en) return tree1[node];
int mid = (l + r) >> 1;
pushdown1(node);
if (en <= mid) return query1(beg, en, l, mid, node << 1);
if (beg > mid) return query1(beg, en, mid + 1, r, (node << 1) | 1);
treenode res;
merge(res, query1(beg, en, l, mid, node << 1),
query1(beg, en, mid + 1, r, (node << 1) | 1));
return res;
}
void push2(int node, int x) {
if (tree2[node].len & 1) tree2[node].sum += x;
tree2[node].mn1 += x;
tree2[node].lazy += x;
}
void pushdown2(int node) {
if (tree2[node].lazy) {
push2(node << 1, tree2[node].lazy);
push2((node << 1) | 1, tree2[node].lazy);
tree2[node].lazy = 0;
}
}
void update2(int beg, int en, int l, int r, int node, int x) {
if (l > en || r < beg) return;
if (l >= beg && r <= en) {
push2(node, x);
return;
}
int mid = (l + r) >> 1;
pushdown2(node);
update2(beg, en, l, mid, node << 1, x);
update2(beg, en, mid + 1, r, (node << 1) | 1, x);
merge(tree2[node], tree2[node << 1], tree2[(node << 1) | 1]);
}
treenode query2(int beg, int en, int l, int r, int node) {
if (l >= beg && r <= en) return tree2[node];
int mid = (l + r) >> 1;
pushdown2(node);
if (en <= mid) return query2(beg, en, l, mid, node << 1);
if (beg > mid) return query2(beg, en, mid + 1, r, (node << 1) | 1);
treenode res;
merge(res, query2(beg, en, l, mid, node << 1),
query2(beg, en, mid + 1, r, (node << 1) | 1));
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build1(1, n, 1);
build2(1, n, 1);
scanf("%d", &q);
while (q--) {
scanf("%d", &tp);
if (tp == 1) {
scanf("%d%d%d", &l, &r, &k);
l++;
r++;
update1(l, r, 1, n, 1, k);
update2(n + 1 - r, n + 1 - l, 1, n, 1, k);
} else {
scanf("%d%d", &l, &r);
l++;
r++;
t1 = query1(l, r, 1, n, 1);
t2 = query2(n + 1 - r, n + 1 - l, 1, n, 1);
if (t1.can(l, r) || t2.can(l, r))
printf("1\n");
else
printf("0\n");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1002;
int t, n;
vector<int> g[N];
pair<int, int> ask(vector<int> v) {
printf("? %d ", v.size());
for (auto x : v) printf("%d ", x);
printf("\n");
fflush(stdout);
int x, d;
scanf("%d%d", &x, &d);
return make_pair(x, d);
}
int dep[N], par[N], vis[N];
vector<int> vd[N];
void dfs(int u, int p) {
dep[u] = dep[p] + 1;
par[u] = p;
vd[dep[u]].push_back(u);
for (auto v : g[u]) {
if (v == p) continue;
dfs(v, u);
dep[v] = dep[u] + 1;
}
}
void tag(int u) {
while (u) {
vis[u] = 1;
u = par[u];
}
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
g[i].clear();
vd[i].clear();
vis[i] = 0;
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
vector<int> vec;
for (int i = 1; i <= n; i++) vec.push_back(i);
pair<int, int> P = ask(vec);
int root = P.first;
dfs(root, 0);
int lef = 1 + P.second / 2,
rig = min(P.second + 2, *max_element(dep + 1, dep + 1 + n) + 1), u = 0,
v = 0;
while (rig - lef > 1) {
int mid = (lef + rig) >> 1;
pair<int, int> tmp = ask(vd[mid]);
if (tmp.second == P.second) {
lef = mid, u = tmp.first;
} else {
rig = mid;
}
}
if (u == 0) {
u = ask(vd[lef]).first;
}
int sum = P.second + 2;
int d = sum - dep[u];
if (d == 1)
v = root;
else {
tag(u);
vector<int> nv;
for (auto x : vd[d])
if (vis[x] == 0) nv.push_back(x);
pair<int, int> tmp = ask(nv);
v = tmp.first;
}
printf("! %d %d\n", u, v);
fflush(stdout);
char str[10];
scanf("%s", str);
if (str[0] == 'I') assert(0);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int RLEN = 1 << 20 | 1;
inline char gc() {
static char ibuf[RLEN], *ib, *ob;
(ib == ob) && (ob = (ib = ibuf) + fread(ibuf, 1, RLEN, stdin));
return (ib == ob) ? EOF : *ib++;
}
inline int read() {
char ch = gc();
int res = 0;
bool f = 1;
while (!isdigit(ch)) f ^= ch == '-', ch = gc();
while (isdigit(ch)) res = (res + (res << 2) << 1) + (ch ^ 48), ch = gc();
return f ? res : -res;
}
inline long long readl() {
char ch = gc();
long long res = 0;
bool f = 1;
while (!isdigit(ch)) f ^= ch == '-', ch = gc();
while (isdigit(ch)) res = (res + (res << 2) << 1) + (ch ^ 48), ch = gc();
return f ? res : -res;
}
template <class tp>
inline void chemx(tp &a, tp b) {
a < b ? a = b : 0;
}
template <class tp>
inline void chemn(tp &a, tp b) {
a > b ? a = b : 0;
}
const int mod = 998244353, G = 3;
inline int add(int a, int b) { return (a += b) >= mod ? (a - mod) : a; }
inline int dec(int a, int b) {
a -= b;
return a + (a >> 31 & mod);
}
inline int mul(int a, int b) {
static long long r;
r = 1ll * a * b;
return (r >= mod) ? (r % mod) : r;
}
inline void Add(int &a, int b) { (a += b) >= mod ? (a -= mod) : 0; }
inline void Dec(int &a, int b) { a -= b, a += a >> 31 & mod; }
inline void Mul(int &a, int b) {
static long long r;
r = 1ll * a * b, a = (r >= mod) ? (r % mod) : r;
}
inline int ksm(int a, int b, int res = 1) {
for (; b; b >>= 1, Mul(a, a)) (b & 1) && (Mul(res, a), 1);
return res;
}
inline int Inv(int x) { return ksm(x, mod - 2); }
inline int fix(int x) { return (x < 0) ? (x + mod) : x; }
const int C = 19;
int *w[C + 1], rev[(1 << (C + 1)) | 1];
inline void init_rev(int lim) {
for (int i = 0; i < lim; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) * (lim >> 1));
}
inline void init_w() {
for (int i = 1; i <= C; i++) w[i] = new int[1 << (i - 1)];
int wn = ksm(G, (mod - 1) / (1 << C));
w[C][0] = 1;
for (int i = 1, l = (1 << (C - 1)); i < l; i++)
w[C][i] = mul(w[C][i - 1], wn);
for (int i = C - 1; i; i--)
for (int j = 0, l = (1 << (i - 1)); j < l; j++) w[i][j] = w[i + 1][j << 1];
}
inline void ntt(int *f, int lim, int kd) {
for (int i = 0; i < lim; i++)
if (i > rev[i]) swap(f[i], f[rev[i]]);
for (int mid = 1, l = 1, a0, a1; mid < lim; mid <<= 1, l++)
for (int i = 0; i < lim; i += mid << 1)
for (int j = 0; j < mid; j++)
a0 = f[i + j], a1 = mul(f[i + j + mid], w[l][j]),
f[i + j] = add(a0, a1), f[i + j + mid] = dec(a0, a1);
if (kd == -1) {
reverse(f + 1, f + lim);
for (int i = 0, iv = Inv(lim); i < lim; i++) Mul(f[i], iv);
}
}
inline vector<int> operator+(vector<int> a, vector<int> b) {
a.resize(max(a.size(), b.size()));
for (int i = 0; i < b.size(); i++) Add(a[i], b[i]);
return a;
}
inline vector<int> operator*(vector<int> a, vector<int> b) {
int deg = a.size() + b.size() - 1, lim = 1;
if (deg <= 32) {
vector<int> c(deg, 0);
for (int i = 0; i < a.size(); i++)
for (int j = 0; j < b.size(); j++) Add(c[i + j], mul(a[i], b[j]));
return c;
}
while (lim < deg) lim <<= 1;
init_rev(lim);
a.resize(lim), b.resize(lim);
ntt(&a[0], lim, 1), ntt(&b[0], lim, 1);
for (int i = 0; i < lim; i++) Mul(a[i], b[i]);
ntt(&a[0], lim, -1);
a.resize(deg);
return a;
}
const int N = 100005;
vector<int> e[N];
int siz[N], son[N], fa[N], n;
void dfs1(int u) {
siz[u] = 1;
for (int &v : e[u]) {
if (v == fa[u]) continue;
fa[v] = u, dfs1(v), siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
}
vector<int> f[N], tr[N], s1[N << 2], s2[N << 2];
int m;
void build(int u, int l, int r) {
if (l == r) {
s1[u] = s2[u] = tr[l];
return;
}
int mid = (l + r) >> 1;
build((u << 1), l, mid), build(((u << 1) | 1), mid + 1, r);
s1[u] = s1[(u << 1)] * s1[((u << 1) | 1)],
s2[u] = s1[(u << 1)] * s2[((u << 1) | 1)] + s2[(u << 1)];
}
vector<int> dfs2(int u) {
for (int v = u; v; v = son[v]) {
for (int &x : e[v]) {
if (x == fa[v] || x == son[v]) continue;
f[v] = dfs2(x);
}
if (f[v].size() < 1) f[v].push_back(0);
f[v][0]++, f[v].push_back(0);
for (int i = f[v].size() - 1; i; i--) f[v][i] = f[v][i - 1];
f[v][0] = 0;
}
m = 0;
for (int v = u; v; v = son[v]) tr[++m] = f[v];
build(1, 1, m);
return s2[1];
}
int iv[N];
inline void init_inv() {
iv[0] = 1, iv[1] = 1;
for (int i = 2; i < N; i++) iv[i] = mul(mod - mod / i, iv[mod % i]);
}
int main() {
init_w(), init_inv();
n = read();
int x = readl() % mod;
for (int i = 1; i < n; i++) {
int u = read(), v = read();
e[u].push_back(v), e[v].push_back(u);
}
dfs1(1);
vector<int> ret = dfs2(1);
int res = 0;
for (int mt = 1, i = 1; i < ret.size(); Mul(mt, mul(add(x, i), iv[i])), i++)
Add(res, mul(ret[i], mt));
cout << res;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int upperbound(int sz, vector<int> &v, int val) {
int low = 0;
int high = sz - 1;
int mid;
while (high >= low) {
mid = (high + low) / 2;
if (v[mid] > val)
high = mid - 1;
else {
if (mid + 1 == sz || v[mid + 1] > val) return mid;
low = mid + 1;
}
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k, x, mana;
cin >> n >> m >> k >> x >> mana;
vector<int> typefmana(m), typeftime(m);
vector<int> typesmana(k), typesspells(k);
for (int i = 0; i < m; i++) cin >> typeftime[i];
for (int i = 0; i < m; i++) cin >> typefmana[i];
for (int i = 0; i < k; i++) cin >> typesspells[i];
for (int i = 0; i < k; i++) cin >> typesmana[i];
long long mintime = n * 1LL * x;
int i = upperbound(k, typesmana, mana);
long long ctime = mintime;
if (i >= 0) ctime = max(0, n - typesspells[i]) * 1LL * x;
mintime = min(mintime, ctime);
int instant;
for (int f = 0; f < m; f++) {
if (typefmana[f] > mana || typeftime[f] >= x) continue;
instant = 0;
i = upperbound(k, typesmana, mana - typefmana[f]);
if (i >= 0 && typesmana[i] <= mana - typefmana[f]) {
instant = typesspells[i];
}
ctime = max(0, n - instant) * 1LL * typeftime[f];
mintime = min(mintime, ctime);
}
cout << mintime << endl;
return 0;
}
| 4 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
long long int n;
cin >> n;
vector<pair<long long int,long long int>>v;
for(int i=0;i<n;i++){
long long int x;
long long int y;
cin >> x >> y;
v.push_back(make_pair(y,x));
}
sort(v.begin(),v.end());
long long int s=0;
long long int e=n-1;
long long int ans=0;
long long int total=0;
while(s<=e){
if(v[s].first<=total){
ans=ans+v[s].second;
total=total+v[s].second;
s++;
}
else {
long long int need=min(v[s].first-total,v[e].second);
total=total+need;
v[e].second=v[e].second-need;
ans=ans+2*need;
if(v[e].second==0){
e--;
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int x[5010], y[5010], w[5010], n, m;
double a[110][110], f[110];
double t;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x[i], &y[i], &w[i]);
if ((x[i] != 1) && (x[i] != n)) {
a[x[i]][y[i]]--;
a[x[i]][x[i]]++;
}
if ((y[i] != 1) && (y[i] != n)) {
a[y[i]][x[i]]--;
a[y[i]][y[i]]++;
}
}
a[1][1] = a[n][n] = a[n][n + 1] = 1;
for (int i = 1; i <= n; i++) {
int j = i;
while ((!a[j][i]) && (j <= n)) j++;
if (j > n) continue;
if (i != j) {
for (int k = i; k <= n + 1; k++) swap(a[i][k], a[j][k]);
}
for (int j = i + 1; j <= n; j++) {
t = a[j][i] / a[i][i];
for (int k = i; k <= n + 1; k++) {
a[j][k] -= t * a[i][k];
}
}
}
for (int i = n; i > 0; i--) {
for (int j = i + 1; j <= n; j++) {
a[i][n + 1] -= f[j] * a[i][j];
}
if (a[i][i] != 0) f[i] = a[i][n + 1] / a[i][i];
}
double Min = 1e16;
double ans = 0;
for (int i = 1; i <= m; i++) {
t = f[y[i]] - f[x[i]];
Min = min(Min, abs(w[i] / t));
}
if (Min >= 10000000000000000.0) Min = 0;
for (int i = 1; i <= m; i++) {
if (x[i] == 1) {
ans += Min * f[y[i]];
} else if (y[i] == 1) {
ans += Min * f[x[i]];
}
}
printf("%.7lf\n", ans);
for (int i = 1; i <= m; i++) {
printf("%.7lf\n", (f[y[i]] - f[x[i]]) * Min);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(signed &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const signed &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
const int N = 2e5 + 10, D = 9;
int n, m, k;
vector<pair<int, int> > adj[N];
int cnt[N][D][D];
bool no[D][D][D][D], noo[D][D];
int p[D];
int ans;
void dfs(int dep) {
if (dep == k) {
ans++;
return;
}
for (int i = (0); i < (dep + 1); ++i)
if (!noo[dep][i]) {
p[dep] = i;
bool flag = false;
for (int j = (0); j < (dep); ++j) {
flag |= no[dep][p[dep]][j][p[j]];
}
if (!flag) dfs(dep + 1);
}
}
signed main() {
R(n, m, k);
for (int i = (0); i < (m); ++i) {
int u, v, w;
R(u, v, w);
adj[u].push_back(make_pair(w, v));
}
for (int i = (1); i < (n + 1); ++i) {
sort((adj[i]).begin(), (adj[i]).end());
for (int k = (0); k < (adj[i].size()); ++k) {
int j = adj[i][k].second;
cnt[j][(int)adj[i].size() - 1][k]++;
}
}
for (int i = (1); i < (n + 1); ++i) {
for (int j = (0); j < (D); ++j) {
for (int b1 = (0); b1 < (j + 1); ++b1)
if (cnt[i][j][b1]) {
if (cnt[i][j][b1] > 1) {
noo[j][b1] = 1;
continue;
}
for (int k = (0); k < (j); ++k) {
for (int b2 = (0); b2 < (k + 1); ++b2)
if (cnt[i][k][b2] == 1) {
no[j][b1][k][b2] = 1;
}
}
}
}
}
dfs(0);
W(ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int ans[30005];
int cnt = 0;
int sum1 = 0, sum2 = 0;
for (int i = n; i > 0; i--) {
if (sum1 <= sum2) {
sum1 += i;
ans[cnt++] = i;
} else
sum2 += i;
}
printf("%d\n", abs(sum1 - sum2));
printf("%d", cnt);
for (int i = 0; i < cnt; i++) printf(" %d", ans[i]);
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T > 0) {
string s;
cin >> s;
int sum = 0, c = 0;
int n = s.length();
int x = 0, y = 0, x1, y1;
map<pair<pair<int, int>, pair<int, int>>, int> m;
m[{{x, y}, {x, y}}] = 1;
for (int i = 0; i < n; i++) {
x1 = x;
y1 = y;
if (s[i] == 'N') y++;
if (s[i] == 'S') y--;
if (s[i] == 'E') x++;
if (s[i] == 'W') x--;
if (m[{{x, y}, {x1, y1}}] == 1 || m[{{x1, y1}, {x, y}}] == 1)
sum++;
else {
sum += 5;
m[{{x, y}, {x1, y1}}] = 1;
m[{{x1, y1}, {x, y}}] = 1;
}
}
cout << sum << endl;
T--;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& _a4, C _b4) {
_a4 = min(_a4, _b4);
}
template <class C>
void maxi(C& _a4, C _b4) {
_a4 = max(_a4, _b4);
}
template <class TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char* sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[";
for (auto& vv : V) os << vv << ",";
os << "]";
return os;
}
long long n;
long long a[101001], b[101001], c[101001];
long long mis, mas, mir, mar;
pair<long long, long long> licz(long long m) {
mis = mir = 4.5e18;
mas = mar = -4.5e18;
for (long long i = (0); i <= ((long long)(n)-1); i++) {
long long d = abs(c[i] - m);
mini(mis, a[i] + b[i] - d);
maxi(mas, a[i] + b[i] + d);
mini(mir, a[i] - b[i] - d);
maxi(mar, a[i] - b[i] + d);
}
pair<long long, long long> pom = {mas - mis, mar - mir};
if (pom.first < pom.second) swap(pom.first, pom.second);
return pom;
}
long long calc(long long x, long long y, long long z) {
long long res = 0;
for (long long i = (0); i <= ((long long)(n)-1); i++) {
maxi(res, abs(a[i] - x) + abs(b[i] - y) + abs(c[i] - z));
}
return res;
}
void test() {
cin >> n;
for (long long i = (0); i <= ((long long)(n)-1); i++) {
cin >> a[i] >> b[i] >> c[i];
}
long long po = -1.1e18, ko = 1.1e18;
while (po + 1 != ko) {
long long mi = (po + ko) / 2;
if (licz(mi - 1) < licz(mi))
ko = mi;
else
po = mi;
}
long long wyn = 4e18;
long long xx, yy, zz;
for (long long z = po - 2; z <= po + 2; z++) {
licz(z);
long long sum = mas + mis;
long long roz = mar + mir;
long long x = (sum + roz) / 4;
long long y = (sum - roz) / 4;
for (long long i = (0); i <= ((long long)(3) - 1); i++)
for (long long j = (0); j <= ((long long)(3) - 1); j++) {
long long pom = calc(x + i - 1, y + j - 1, z);
(pom);
if (pom < wyn) {
xx = x + i - 1;
yy = y + j - 1;
zz = z;
wyn = pom;
}
}
}
cout << xx << " " << yy << " " << zz << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
if (0) cout << fixed << setprecision(6);
long long t;
cin >> t;
while (t--) test();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long double a[1000010], b[1000010];
long double C(int n, int m) {
if (n < m) return -1e100;
return b[n] - b[m] - b[n - m];
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n * m; ++i) {
a[i] = log(i);
b[i] = b[i - 1] + a[i];
}
long double ans = 0;
for (int k = 1; k <= n; ++k) {
ans = ans +
exp(2 * a[k] + C(m, k) + C((n - 1) * m, n - k) - a[n] - C(n * m, n));
}
printf("%.9f\n", (double)ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
int prm[MAX], a[MAX];
static int c2[MAX], p[MAX];
int main(void) {
int n, m, j, k, l, flag = 0;
cin >> n >> m;
char ch;
for (int i = 2; i <= n; i++)
if (!prm[i])
for (j = i, prm[i] = i; j <= n; j = j + i) prm[j] = i;
for (int i = 0; i < m; i++) {
flag = 0;
cin >> ch >> k;
if (ch == '+') {
if (c2[k] == 1) {
cout << "Already on\n";
continue;
}
l = k;
while (l != 1) {
if (p[prm[l]] != 0) {
cout << "Conflict with " << p[prm[l]] << '\n';
flag = 1;
break;
}
l /= prm[l];
}
if (flag == 1) continue;
l = k;
while (l != 1) {
p[prm[l]] = k;
l /= prm[l];
}
c2[k] = 1;
cout << "Success\n";
} else {
if (c2[k] == 0) {
cout << "Already off\n";
continue;
}
c2[k] = 0;
l = k;
while (l != 1) {
p[prm[l]] = 0;
l = l / prm[l];
}
cout << "Success\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long test;
cin >> test;
while (test--) {
long long h, c, t;
cin >> h >> c >> t;
long double mini = (h + c) / 2.0;
if (t <= mini) {
cout << 2 << '\n';
} else {
long long start = 1, end = 1000000000, mid;
long double res;
vector<long long> v;
std::vector<long double> v1;
while (start <= end) {
mid = (start + end) / 2;
long double cur =
(h * mid + c * (mid - 1)) / (long double)(2 * mid - 1);
res = cur;
v1.push_back(cur);
v.push_back(mid);
if (cur > t) {
start = mid + 1;
} else {
end = mid - 1;
}
}
long double diff = 10000000;
long long ans = 1000000000;
for (int i = 0; i < (long long)v.size(); ++i) {
if (abs(v1[i] - t) < diff) {
diff = abs(v1[i] - t);
ans = v[i];
} else if (abs(v1[i] - t) == diff) {
diff = abs(v1[i] - t);
ans = min(ans, v[i]);
}
}
cout << 2 * ans - 1 << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
char s[105] = {}, t[105] = {};
int sCnt[26] = {}, tCnt[26] = {};
int search(int n, int loc, int *last) {
for (int i = *last; i <= n; i++)
if (s[i] == t[loc]) {
*last = i + 1;
return 1;
}
return 0;
}
int main() {
int p, n, flag, last, max;
scanf("%d", &p);
while (p > 0) {
p--;
flag = 1;
max = 0;
scanf("%d %s %s", &n, s + 1, t + 1);
for (int i = 0; i < 26; i++) sCnt[i] = tCnt[i] = 0;
for (int i = 1; i <= n; i++) {
sCnt[s[i] - 'a']++;
tCnt[t[i] - 'a']++;
}
for (int i = 0; i < 26 && flag; i++)
if (sCnt[i] != tCnt[i]) flag = 0;
if (flag) {
for (int i = 1; i <= n; i++) {
last = 1;
for (int j = i; j <= n; j++) {
if (search(n, j, &last) == 0) break;
max = j - i + 1 > max ? j - i + 1 : max;
}
}
}
if (flag)
printf("%d\n", n - max);
else
printf("-1\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[2000006];
bool cmp(int x, int y) { return x > y; }
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
for (int i = 0; i <= n; i++) a[i] = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[x]++;
}
sort(a + 1, a + n + 1, cmp);
int mi = n;
for (int i = 1; i <= n; i++) {
if (a[i] == 0) break;
mi = min(mi, a[i]);
}
int ans = n;
for (int i = 2; i <= mi + 1; i++) {
int sum = 0, v = 0;
for (int j = 1; j <= n; j++) {
if (a[j] == 0) break;
if (a[j] % i == 0)
sum = sum + a[j] / i;
else {
int x = a[j] % i;
int y = a[j] / i;
if (y < i - 1 - x) {
v = 1;
break;
}
sum = sum + y + 1;
}
}
if (v == 0 && sum > 0) ans = min(ans, sum);
}
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int first[100005];
int second[100005];
int third[100005];
int main() {
int n;
int j;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> first[i];
}
for (int i = 0; i < n - 1; ++i) {
cin >> second[i];
}
for (int i = 0; i < n - 2; ++i) {
cin >> third[i];
}
sort(first, first + n);
sort(second, second + n - 1);
sort(third, third + n - 2);
for (j = 0; j < n - 1; ++j) {
if (first[j] != second[j]) {
cout << first[j] << endl;
break;
}
}
if (j == n - 1) {
cout << first[j] << endl;
}
for (j = 0; j < n - 2; ++j) {
if (third[j] != second[j]) {
cout << second[j] << endl;
break;
}
}
if (j == n - 2) {
cout << second[j] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
vector<long long int> arr;
set<long long int> s;
for (int i = 0; i < n; i++) {
long long int val;
cin >> val;
arr.push_back(val);
}
bool temp = false;
long long int sum = arr[0] + arr[1];
for (int i = 2; i < n; i++) {
if (sum <= arr[i]) {
temp = true;
cout << 1 << " " << 2 << " " << i + 1 << '\n';
break;
}
}
if (!temp) {
cout << -1 << '\n';
}
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 1000000007;
int n, m;
vector<pair<int, int> > g[1000];
int main() {
scanf("%d%d", &n, &m);
vector<int> d(n);
for (int i = 0; i < (int)(n); i++) scanf("%d", &d[i]);
long long int ans = 0;
for (int i = 0; i < (int)(m); i++) {
int x, y;
scanf("%d%d", &x, &y);
ans += min(d[x - 1], d[y - 1]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int l = 1;
int r = 100000;
while (r - l > 1) {
int m = (l + r) / 2;
vector<bool> used(m + 1);
int A = a;
int B = b;
int cnt = 0;
for (int i = m; i >= 1; i--) {
if (A >= i) {
A -= i;
used[i] = true;
cnt++;
}
}
for (int i = m; i >= 1; i--) {
if (B >= i && !used[i]) {
B -= i;
cnt++;
}
}
if (cnt == m) {
l = m;
} else {
r = m;
}
}
{
vector<bool> used(l + 1);
int A = a;
int B = b;
vector<int> ansA, ansB;
for (int i = l; i >= 1; i--) {
if (A >= i) {
A -= i;
used[i] = true;
ansA.push_back(i);
}
}
for (int i = l; i >= 1; i--) {
if (B >= i && !used[i]) {
B -= i;
ansB.push_back(i);
}
}
cout << ansA.size() << endl;
for (int i = 0; i < ansA.size(); i++) {
if (i > 0) putchar(' ');
printf("%d", ansA[i]);
}
putchar('\n');
cout << ansB.size() << endl;
for (int i = 0; i < ansB.size(); i++) {
if (i > 0) putchar(' ');
printf("%d", ansB[i]);
}
putchar('\n');
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long Inf = 1000000000000000000LL;
const int Maxm = 100005;
struct pos {
int x, y, z;
pos(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
};
int n;
map<int, pair<int, int> > S;
int m, d[Maxm], l[Maxm];
int C[Maxm];
long long best[Maxm][2][2];
pos par[Maxm][2][2];
int wth[Maxm][2][2];
vector<int> res1, res2;
bool Less(const int &a, const int &b) { return l[a] > l[b]; }
pos getNext(const pos &p) {
pos v;
v.x = p.x + 1;
if (v.x < m && l[C[p.x]] == l[C[v.x]]) {
v.y = p.y;
v.z = p.z;
} else if (v.x < m && l[C[p.x]] - 1 == l[C[v.x]]) {
v.y = p.z;
v.z = 0;
} else {
v.y = v.z = 0;
}
return v;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int c, s;
scanf("%d %d", &c, &s);
S[s] = make_pair(c, i);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &d[i], &l[i]);
C[i] = i;
}
sort(C, C + m, Less);
fill((long long *)best, (long long *)best + Maxm * 2 * 2, -Inf);
best[0][0][0] = 0ll;
pos p;
for (p.x = 0; p.x < m; p.x++)
for (p.y = 0; p.y < 2; p.y++)
for (p.z = 0; p.z < 2; p.z++) {
long long cand = best[p.x][p.y][p.z];
pos v = getNext(p);
if (cand > best[v.x][v.y][v.z]) {
best[v.x][v.y][v.z] = cand;
par[v.x][v.y][v.z] = p;
wth[v.x][v.y][v.z] = 0;
}
if (!p.y && S.find(l[C[p.x]] + 1) != S.end() &&
d[C[p.x]] >= S[l[C[p.x]] + 1].first) {
cand = best[p.x][p.y][p.z] + S[l[C[p.x]] + 1].first;
v = getNext(pos(p.x, 1, p.z));
if (cand > best[v.x][v.y][v.z]) {
best[v.x][v.y][v.z] = cand;
par[v.x][v.y][v.z] = p;
wth[v.x][v.y][v.z] = 1;
}
}
if (!p.z && S.find(l[C[p.x]]) != S.end() &&
d[C[p.x]] >= S[l[C[p.x]]].first) {
cand = best[p.x][p.y][p.z] + S[l[C[p.x]]].first;
v = getNext(pos(p.x, p.y, 1));
if (cand > best[v.x][v.y][v.z]) {
best[v.x][v.y][v.z] = cand;
par[v.x][v.y][v.z] = p;
wth[v.x][v.y][v.z] = 2;
}
}
}
pos v = pos(m, 0, 0);
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
if (best[m][i][j] > best[v.x][v.y][v.z]) v = pos(m, i, j);
printf("%I64d\n", best[v.x][v.y][v.z]);
while (v.x) {
pos p = par[v.x][v.y][v.z];
switch (wth[v.x][v.y][v.z]) {
case 1:
res1.push_back(C[p.x] + 1);
res2.push_back(S[l[C[p.x]] + 1].second + 1);
break;
case 2:
res1.push_back(C[p.x] + 1);
res2.push_back(S[l[C[p.x]]].second + 1);
break;
}
v = p;
}
printf("%d\n", res1.size());
for (int i = 0; i < res1.size(); i++) printf("%d %d\n", res1[i], res2[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e5 + 10;
struct node {
int v, next;
};
node edge[2 * maxn];
long long val[maxn], minn[maxn], maxx[maxn];
int first[maxn];
int n, num;
void addedge(int u, int v) {
edge[num].v = v;
edge[num].next = first[u];
first[u] = num++;
}
void dfs(int cur, int fa) {
int i, v;
for (i = first[cur]; i != -1; i = edge[i].next) {
v = edge[i].v;
if (v != fa) {
dfs(v, cur);
minn[cur] = min(minn[cur], minn[v]);
maxx[cur] = max(maxx[cur], maxx[v]);
}
}
val[cur] -= maxx[cur] + minn[cur];
if (val[cur] > 0)
maxx[cur] += val[cur];
else
minn[cur] += val[cur];
}
int main() {
int i, u, v;
scanf("%d", &n);
memset(first, -1, sizeof(first));
num = 0;
for (i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
for (i = 1; i <= n; i++) {
scanf("%lld", &val[i]);
}
dfs(1, 0);
printf("%lld\n", maxx[1] - minn[1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
int a[maxn], b[maxn];
queue<int> q;
int n, m, cnt;
int main() {
cin >> n >> m;
cnt = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] <= m)
b[a[i]]++;
else
cnt++;
}
int c = n / m, d = n % m, e = 0;
for (int i = 1; i <= m; i++) {
if (b[i] < c)
e += c - b[i];
else
b[i] = c;
}
int ans = e;
while (e) {
int id = 1;
for (int i = 2; i <= m; i++)
if (b[i] < b[id]) id = i;
q.push(id);
b[id]++;
e--;
}
cout << c << " " << ans << endl;
for (int i = 1; i <= n; i++) {
int f;
if (a[i] <= m && b[a[i]])
f = a[i];
else if (a[i] <= m && !b[a[i]] && d) {
d--;
f = a[i];
} else if (!q.empty()) {
f = q.front();
q.pop();
} else
f = a[i];
if (f <= m && b[f] > 0) b[f]--;
printf("%d%c", f, i == n ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> C;
vector<pair<int, int> > A, B;
long long eval(int n, int &k, long long MOD) {
long long ans = 1;
for (int i = 1; i <= n; ++i) {
int v = i;
while (k > 0 && v % 2 == 0) v /= 2, --k;
ans *= v;
ans %= MOD;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
A.resize(N);
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
++C[a];
A[i] = {a, i};
}
B.resize(N);
for (int i = 0; i < N; ++i) {
int b;
cin >> b;
++C[b];
B[i] = {b, i};
}
long long MOD;
cin >> MOD;
sort(A.begin(), A.end());
sort(B.begin(), B.end());
vector<pair<int, int> > I;
set_intersection(A.begin(), A.end(), B.begin(), B.end(), back_inserter(I));
int k = I.size();
long long ans = 1;
for (const auto &p : C) {
ans *= eval(p.second, k, MOD);
ans %= MOD;
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
long long qmod(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b = b >> 1;
}
return res;
}
long long jc[1000005];
long long jv[1000005];
long long p3[1000005];
inline long long fuck(int x) {
if (x & 1) return -1;
return 1;
}
long long getc(long long a, long long b) {
return jc[a] * jv[b] % mod * jv[a - b] % mod;
}
int main() {
int n;
cin >> n;
jc[0] = jv[0] = 1;
p3[0] = 1;
for (int i = 1; i <= 1000000; i++)
jc[i] = jc[i - 1] * i % mod, p3[i] = p3[i - 1] * 3 % mod;
jv[1000000] = qmod(jc[1000000], mod - 2);
for (int i = 999999; i >= 1; i--) jv[i] = jv[i + 1] * (i + 1) % mod;
long long ans = 0;
int cnt = 1;
for (int i = 0; i < n; i++) {
ans += fuck(i + 1) * getc(n, i) % mod *
(qmod((1 - p3[i] + mod) % mod, n) - qmod((-p3[i] + mod) % mod, n) +
mod) %
mod;
ans = (ans + mod) % mod;
}
ans *= 3;
long long ans2 = 0;
for (int i = 1; i <= n; i++) {
ans2 +=
fuck(i + 1) * getc(n, i) % mod * qmod(3, 1ll * (n - i) * n + i) % mod;
ans2 = (ans2 + mod) % mod;
}
printf("%I64d\n", (ans2 * 2 + ans + mod) % mod);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 110000;
const long long INF = 1000000000LL;
int N;
pair<long long, int> A[NMax], B[NMax];
multiset<pair<long long, int> > S;
long long Max[NMax], Min[NMax], Max1[NMax], Min1[NMax];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
long long first, second;
scanf("%lld%lld", &first, &second);
A[i] = make_pair(first + second, i);
B[i] = make_pair(first - second, i);
}
sort(A + 1, A + N + 1);
Min[0] = 10000000000LL;
Max[0] = -10000000000LL;
for (int i = 1; i <= N; i++) {
Max[i] = max(Max[i - 1], B[A[i].second].first);
Min[i] = min(Min[i - 1], B[A[i].second].first);
}
Min1[N + 1] = 10000000000LL;
Max1[N + 1] = -10000000000LL;
for (int i = N; i >= 1; i--) {
Max1[i] = max(Max1[i + 1], B[A[i].second].first);
Min1[i] = min(Min1[i + 1], B[A[i].second].first);
}
long long l = -1, r = 4 * INF + 10;
while (l < r) {
if (l + 1 == r) break;
long long mid = (l + r) >> 1;
bool flag = 0;
int second = 2;
for (int i = 1; i <= N; i++) {
while (second <= N && A[second].first <= A[i].first + mid) second++;
long long maxx = -10000000000LL, minn = 10000000000LL;
if (i != 1) maxx = Max[i - 1], minn = Min[i - 1];
if (second <= N)
maxx = max(maxx, Max1[second]), minn = min(minn, Min1[second]);
if (maxx == -10000000000LL) {
flag = 1;
break;
}
if (maxx - minn <= mid) {
flag = 1;
break;
}
}
if (flag)
r = mid;
else
l = mid;
}
double ret = (double)r / 2;
printf("%lf\n", ret);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<string> v, v1;
map<string, long long> mp, mp1, mp2;
char final[100000];
long long a[10000];
bool compare(string &s1, string &s2) { return s1.size() < s2.size(); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, x, y, x1, y1, test, d, move, right, diff1, diff2, min1, min2,
min0;
cin >> test;
while (test--) {
cin >> n >> x >> y >> d;
x1 = min(x, y);
y1 = max(x, y);
if (x1 == y1) {
cout << "0\n";
} else {
right = (y1 - x1) / d;
if (d * right == y1 - x1) {
cout << right << "\n";
continue;
} else {
diff1 = x - 1;
diff2 = n - x;
min1 = -1;
min2 = -1;
move = ceil((double)diff1 / d);
x = 1;
right = (y - x) / d;
if (d * right == y - x) {
min1 = move + right;
}
move = ceil((double)diff2 / d);
x = y;
y = n;
right = (y - x) / d;
if (d * right == y - x) {
min2 = move + right;
}
if (min1 == -1 && min2 == -1) {
cout << "-1\n";
} else {
if (min1 != -1 && min2 != -1) {
cout << min(min1, min2) << "\n";
} else {
if (min1 != -1) {
cout << min1 << "\n";
} else {
cout << min2 << "\n";
}
}
}
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, q, blockS;
int nextt[100005], gdzie[100005], ile[100005];
void build(int x) {
int start = (x / blockS) * blockS;
int meta = min(((x / blockS) + 1) * blockS - 1, n - 1);
for (int i = meta; i >= start; --i) {
if (nextt[i] > meta) {
gdzie[i] = nextt[i];
ile[i] = 1;
} else {
gdzie[i] = gdzie[nextt[i]];
ile[i] = ile[nextt[i]] + 1;
}
}
}
void inline fix(int x, int war) {
nextt[x] = war + x;
build(x);
}
pair<int, int> odp(int x) {
int licznik = 0;
while (gdzie[x] < n) licznik += ile[x], x = gdzie[x];
while (nextt[x] < n) licznik++, x = nextt[x];
licznik++;
return make_pair(x, licznik);
}
int main() {
scanf("%d %d", &n, &q);
blockS = sqrt(n);
for (int i = 0; i < n; ++i) scanf("%d", nextt + i), nextt[i] += i;
for (int i = 0; i < n; i += blockS) build(i);
for (int i = 0; i < q; ++i) {
int type, a, b;
scanf("%d", &type);
if (type == 1) {
scanf("%d", &a);
a--;
pair<int, int> ans = odp(a);
printf("%d %d\n", ans.first + 1, ans.second);
} else {
scanf("%d%d", &a, &b);
a--;
fix(a, b);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int sub[3000 + 10][3000 + 10], f[3000 + 10][3000 + 10];
long long dp[3000 + 10][3000 + 10];
vector<int> edge[3000 + 10];
void pre(int rt, int son, int first) {
sub[rt][son] = 1;
for (auto i : edge[son]) {
if (i == first)
continue;
else {
f[rt][i] = son;
pre(rt, i, son);
sub[rt][son] += sub[rt][i];
}
}
}
long long dfs(int i, int j) {
if (i == j)
return 0;
else if (dp[i][j] != -1)
return dp[i][j];
else
dp[i][j] = sub[i][j] * sub[j][i] + max(dfs(i, f[i][j]), dfs(j, f[j][i]));
return dp[i][j];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
long long ans = 0;
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = (0); i < (n - 1); i++) {
int u, v;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = (1); i < (n + 1); i++) pre(i, i, 0);
for (int i = (1); i < (n + 1); i++) {
for (int j = (1); j < (n + 1); j++) {
dfs(i, j);
ans = max(ans, dp[i][j]);
}
}
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
int n[a];
cin >> n[0];
for (int i = 1; i < a; i++) {
cin >> n[i];
cout << n[i - 1] + n[i] << ' ';
}
cout << n[a - 1];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans[302];
vector<int> cools;
vector<int> nspc;
int n, m, k;
int spc[302];
bool special[302];
bool good[302][302];
bool check[302][302];
bool direct[302];
void MakeFrineds(int vert1, int vert2) {
ans[vert1].push_back(vert2);
ans[vert2].push_back(vert1);
}
void PrintAnswer() {
memset(good, 0, sizeof(good[0][0]) * 302 * 302);
int i, j;
int ind1, ind2;
ind1 = 1;
ind2 = -1;
for (i = 1; i <= m; i++) {
ind2++;
if (ind2 == ans[ind1].size()) {
ind1++;
ind2 = 0;
}
if (good[ind1][ans[ind1][ind2]]) {
i--;
continue;
}
good[ind1][ans[ind1][ind2]] = true;
good[ans[ind1][ind2]][ind1] = true;
printf("%d %d\n", ind1, ans[ind1][ind2]);
}
}
int main() {
int i, j, ii, jj, ind;
int cnt = 0, v;
int a, b;
scanf("%d %d %d", &n, &m, &k);
for (i = 1; i <= k; i++) {
scanf("%d", &v);
special[v] = true;
}
for (i = 1; i <= n; i++) {
if (!special[i]) {
nspc.push_back(i);
}
}
if (nspc.size() == 0 || n < nspc[0]) {
cout << -1 << endl;
return 0;
}
for (i = 1; i <= n; i++) {
if (special[i]) {
if (cnt == 0) {
a = i;
cools.push_back(i);
} else {
b = i;
}
cnt++;
MakeFrineds(nspc[0], i);
check[nspc[0]][i] = true;
check[i][nspc[0]] = true;
if (cnt == 2) break;
}
}
if (cnt != 2) {
cout << -1 << endl;
return 0;
}
direct[nspc[0]] = true;
cools.push_back(nspc[0]);
cools.push_back(a);
for (i = 1; i <= n; i++) {
if (i == nspc[0] || i == a || i == b) continue;
if (!special[i]) {
for (j = 1; j <= n; j++) {
if (i == j) continue;
if (i == a) {
direct[j] = true;
}
if (j == a) {
direct[i] = true;
}
if (check[i][j]) continue;
check[i][j] = true;
check[j][i] = true;
MakeFrineds(j, i);
cnt++;
}
} else {
for (j = 0; j < cools.size(); j++) {
if (check[cools[j]][i]) continue;
check[cools[j]][i] = true;
check[i][cools[j]] = true;
if (cools[j] == a) {
direct[i] = true;
}
MakeFrineds(cools[j], i);
cnt++;
}
cools.push_back(i);
}
}
for (i = 1; i <= n; i++) {
if (direct[i]) continue;
if (i == b || i == a) continue;
if (check[i][b] || check[b][i]) continue;
check[i][b] = true;
check[b][i] = true;
MakeFrineds(i, b);
cnt++;
}
if (cnt < m)
cout << -1 << endl;
else {
PrintAnswer();
}
}
| 7 |
#include <bits/stdc++.h>
template <class T>
void Swap(T& a, T& b) {
T c = a;
a = b;
b = c;
}
template <class T>
T max(T& a, T& b) {
return a < b ? b : a;
}
template <class T>
T min(T& a, T& b) {
return a > b ? b : a;
}
using namespace std;
const int N = 2010;
const int M = 200010;
struct xfy {
int l, r, x, y, id;
inline void input(int i) {
id = i;
scanf("%d%d%d%d", &l, &r, &x, &y);
}
} q[M];
inline bool cmp(xfy x, xfy y) { return x.l > y.l; }
int f[N][N], X[M], Y[M], n, m, Q, l;
bool ans[M];
int main() {
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= m; ++i) scanf("%d%d", &X[i], &Y[i]);
for (int i = 1; i <= Q; ++i) q[i].input(i);
sort(q + 1, q + Q + 1, cmp);
memset(f, 63, sizeof(f));
l = 1;
for (int i = 1; i <= n; ++i) f[i][i] = 0;
for (int i = m; i >= 1; --i) {
int x = X[i], y = Y[i];
for (int j = 1; j <= n; ++j) {
int u = f[x][j], v = f[y][j];
f[x][j] = min(u, v);
f[y][j] = min(u, v);
}
f[x][y] = f[y][x] = i;
for (; l <= Q && q[l].l >= i; l++)
ans[q[l].id] = (f[q[l].x][q[l].y] <= q[l].r);
}
for (int i = 1; i <= Q; ++i) puts(ans[i] ? "Yes" : "No");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int rev[(1 << 21)], mlgn;
double omega[(1 << 21)][2];
double FA[(1 << 21)][2], FB[(1 << 21)][2];
inline void mult(double A[2], double B[2], double C[2]) {
C[0] = A[0] * B[0] - A[1] * B[1];
C[1] = A[0] * B[1] + A[1] * B[0];
}
void calc_rev(int n = (1 << 21)) {
while ((1 << mlgn) < n) mlgn++;
int lvl = 1, mx = (1 << mlgn);
while (lvl < mx) {
int j = 0, sg = 0;
for (int i = 0; i < mx; i++) {
rev[i] = (rev[i] << 1) | sg;
j++;
if (j == lvl) j = 0, sg ^= 1;
}
lvl <<= 1;
}
}
void fft(double X[(1 << 21)][2], int n, bool invert) {
int lgn = 0;
while ((1 << lgn) != n) lgn++;
lgn = mlgn - lgn;
for (int i = 0; i < n; i++)
if (i < rev[i << lgn]) swap(X[i], X[rev[i << lgn]]);
double ang = ((2.0 * M_PI) / n) * (invert ? -1.0 : 1.0);
for (int i = 0; i < n; i++)
omega[i][0] = cos(ang * i), omega[i][1] = sin(ang * i);
int fact, len2;
double u[2], v[2];
for (int len = 2; len <= n; len <<= 1) {
fact = n / len;
len2 = len >> 1;
for (int i = 0; i < n; i += len)
for (int j = 0; j < len2; j++) {
u[0] = X[i + j][0], u[1] = X[i + j][1];
mult(X[i + j + len2], omega[j * fact], v);
X[i + j][0] = u[0] + v[0], X[i + j][1] = u[1] + v[1];
X[i + j + len2][0] = u[0] - v[0], X[i + j + len2][1] = u[1] - v[1];
}
}
if (invert)
for (int i = 0; i < n; i++) X[i][0] /= n, X[i][1] /= n;
}
int multiply(int A[(1 << 21)], int B[(1 << 21)], int na, int nb,
int ret[(1 << 21)]) {
for (int i = 0; i < na; i++) FA[i][0] = (double)A[i], FA[i][1] = 0.0;
for (int i = 0; i < nb; i++) FB[i][0] = (double)B[i], FB[i][1] = 0.0;
int n = 1;
while (n < max(na, nb)) n <<= 1;
n <<= 1;
for (int i = na; i < n; i++) FA[i][0] = FA[i][1] = 0.0;
for (int i = nb; i < n; i++) FB[i][0] = FB[i][1] = 0.0;
fft(FA, n, false);
fft(FB, n, false);
double tmp[2];
for (int i = 0; i < n; i++) {
mult(FA[i], FB[i], tmp);
FA[i][0] = tmp[0], FA[i][1] = tmp[1];
}
fft(FA, n, true);
int mx = 1;
for (int i = 0; i < n; i++) {
ret[i] = (long long)(FA[i][0] + 0.5);
ret[i] = (ret[i] > 0);
if (ret[i]) mx = i + 1;
}
return mx;
}
int N, K;
int a[(1 << 21)], b[(1 << 21)];
int bigmodFFT(int x[(1 << 21)], int ret[(1 << 21)], int pow, int nx) {
int n = 1;
ret[0] = 1;
while (pow > 0) {
if (pow & 1) n = multiply(ret, x, n, nx, ret);
pow >>= 1;
if (!pow) break;
nx = multiply(x, x, nx, nx, x);
}
return n;
}
int main() {
int n = 0;
scanf("%d%d", &N, &K);
for (int i = 0; i < (N); i++) {
int x;
scanf("%d", &x);
a[x] = 1;
n = max(n, x + 1);
}
calc_rev();
bigmodFFT(a, b, K, n);
bool sp = false;
for (int i = 0; i < ((1 << 21)); i++)
if (b[i]) {
if (sp) printf(" ");
printf("%d", i);
sp = true;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
struct node {
int l, r, lmax, rmax, totmax, totmin, lcnt, rcnt, ans;
node()
: l(0),
r(0),
lmax(0),
rmax(0),
totmax(0),
totmin(0),
lcnt(0),
rcnt(0),
ans(0) {}
node(int l, int r, int lmax, int rmax, int totmax, int totmin, int lcnt,
int rcnt, int ans)
: l(l),
r(r),
lmax(lmax),
rmax(rmax),
totmax(totmax),
totmin(totmin),
lcnt(lcnt),
rcnt(rcnt),
ans(ans) {}
};
node operator+(node l, node r) {
node ret = node(0, 0, 0, 0, 0, 0, 0, 0, 0);
ret.l = l.l;
ret.r = r.r;
ret.totmin = min(l.totmin, r.totmin);
ret.totmax = max(l.totmax, r.totmax);
if (ret.totmin == l.totmin)
ret.lmax = l.lmax, ret.lcnt = l.lcnt, ret.ans += l.ans;
else
ret.lmax = max(l.totmax, r.lmax), ret.lcnt = (l.r - l.l + 1) + r.lcnt;
if (ret.totmin == r.totmin)
ret.rmax = r.rmax, ret.rcnt = r.rcnt, ret.ans += r.ans;
else
ret.rmax = max(l.rmax, r.totmax), ret.rcnt = (r.r - r.l + 1) + l.rcnt;
if (l.totmin == r.totmin)
ret.ans += l.rcnt + r.lcnt + 1 - max(l.rmax, r.lmax);
return ret;
}
struct seg {
int N;
vector<node> A;
vector<int> L;
void init_node(int here, int l, int r) {
if (l == r) {
A[here] = node(l, r, 0, 0, 0, 0, 0, 0, 0);
return;
}
int mid = (l + r) / 2;
init_node((here << 1 | 0), l, mid);
init_node((here << 1 | 1), mid + 1, r);
A[here] = A[(here << 1 | 0)] + A[(here << 1 | 1)];
}
seg() {}
seg(int N) : N(N) {
A.resize(N * 4, node());
L.resize(N * 4);
init_node(1, 0, N - 1);
}
void f(int here, int l, int r) {
A[here].totmin += L[here];
if (l != r) {
L[(here << 1 | 0)] += L[here];
L[(here << 1 | 1)] += L[here];
}
L[here] = 0;
}
void update_p(int here, int l, int r, int pos, int val) {
f(here, l, r);
if (pos < l || r < pos) return;
if (l == r) {
A[here].totmax = val;
A[here].lmax = val;
A[here].rmax = val;
return;
}
int mid = (l + r) / 2;
update_p((here << 1 | 0), l, mid, pos, val);
update_p((here << 1 | 1), mid + 1, r, pos, val);
A[here] = A[(here << 1 | 0)] + A[(here << 1 | 1)];
}
void update(int here, int l, int r, int x, int y, int val) {
f(here, l, r);
if (y < l || r < x) return;
if (x <= l && r <= y) {
L[here] += val;
f(here, l, r);
return;
}
int mid = (l + r) / 2;
update((here << 1 | 0), l, mid, x, y, val);
update((here << 1 | 1), mid + 1, r, x, y, val);
A[here] = A[(here << 1 | 0)] + A[(here << 1 | 1)];
}
};
int N, M;
int A[MAXN];
set<int> S[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> N >> M;
for (int i = 1; i <= N; i++) cin >> A[i];
for (int i = 1; i <= N; i++) S[A[i]].insert(i);
seg SEG = seg(N + 1);
for (int i = 1; i <= 200000; i++)
if (S[i].size()) {
int l = *S[i].begin();
int r = *S[i].rbegin();
SEG.update_p(1, 0, N, l, S[i].size());
if (l < r) SEG.update(1, 0, N, l, r - 1, 1);
}
cout << SEG.A[1].ans << '\n';
for (int i = 1; i <= M; i++) {
int a, b;
cin >> a >> b;
if (A[a] != b) {
int pc = A[a];
SEG.update_p(1, 0, N, *S[pc].begin(), 0);
if (*S[pc].begin() < *S[pc].rbegin())
SEG.update(1, 0, N, *S[pc].begin(), *S[pc].rbegin() - 1, -1);
S[pc].erase(a);
if (S[pc].size()) {
SEG.update_p(1, 0, N, *S[pc].begin(), S[pc].size());
if (*S[pc].begin() < *S[pc].rbegin())
SEG.update(1, 0, N, *S[pc].begin(), *S[pc].rbegin() - 1, 1);
}
A[a] = b;
if (S[b].size()) {
SEG.update_p(1, 0, N, *S[b].begin(), 0);
if (*S[b].begin() < *S[b].rbegin())
SEG.update(1, 0, N, *S[b].begin(), *S[b].rbegin() - 1, -1);
}
S[b].insert(a);
SEG.update_p(1, 0, N, *S[b].begin(), S[b].size());
if (*S[b].begin() < *S[b].rbegin())
SEG.update(1, 0, N, *S[b].begin(), *S[b].rbegin() - 1, 1);
}
cout << SEG.A[1].ans << '\n';
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int l, r, w;
double factor;
} E[100005];
int n, q;
vector<pair<int, int> > e[100005];
int siz[100005];
double nPx(double N, int x) {
double ans = 1;
for (int i = 1; i <= x; i++) {
ans *= (N - i + 1) / i;
}
return ans;
}
void pre(int id, int prev) {
siz[id] = 1;
for (int i = 0; i < e[id].size(); i++) {
pair<int, int> j = e[id][i];
if (j.first == prev) continue;
pre(j.first, id);
siz[id] += siz[j.first];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d %d", &E[i].l, &E[i].r, &E[i].w);
e[E[i].l].push_back(make_pair(E[i].r, E[i].w));
e[E[i].r].push_back(make_pair(E[i].l, E[i].w));
}
pre(1, -1);
double num = 0.0;
for (int i = 1; i < n; i++) {
if (siz[E[i].l] < siz[E[i].r]) swap(E[i].l, E[i].r);
E[i].factor = 2.0 * (nPx(siz[E[i].r], 2) * nPx(n - siz[E[i].r], 1) +
nPx(siz[E[i].r], 1) * nPx(n - siz[E[i].r], 2));
num += E[i].factor * E[i].w;
}
scanf("%d", &q);
while (q--) {
int a, b;
scanf("%d %d", &a, &b);
num -= E[a].factor * (E[a].w - b);
E[a].w = b;
printf("%.10lf\n", num / nPx(n, 3));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897923846;
const long long int MOD = 998244353;
const long long int N = 998244353;
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
long long int modinverse(long long int a) { return power(a, MOD - 2); }
long long int n, m;
vector<long long int> col;
vector<vector<long long int> > adj;
bool shit = false;
vector<long long int> fuck;
void dfs(long long int node, long long int parent) {
fuck.push_back(node);
for (auto x : adj[node]) {
if (x == parent) continue;
if (col[x] == -1) {
col[x] = 1 - col[node];
dfs(x, node);
} else {
if (col[node] == col[x]) {
shit = true;
}
}
}
}
void solve() {
shit = false;
cin >> n >> m;
col.clear();
adj.clear();
col.resize(n, -1);
adj.resize(n);
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
--u, --v;
adj[u].push_back(v), adj[v].push_back(u);
}
long long int ans = 1;
for (long long int i = 0; i < n; i++) {
if (col[i] == -1) {
fuck.clear();
col[i] = 0;
dfs(i, -1);
if (shit) {
cout << 0 << endl;
return;
}
map<long long int, long long int> one, two;
for (long long int ii = 0; ii < fuck.size(); ii++) {
one[fuck[ii]]++;
if (col[fuck[ii]] == 1) two[fuck[ii]]++;
}
long long int a = two.size();
long long int b = one.size() - two.size();
ans *= (power(2, a) + power(2, b)) % MOD;
ans %= MOD;
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int test = 1;
cin >> test;
while (test--) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int cnt[100010];
long long int f(long long int k) {
long long int ans = ((3 * k + 1) * k) / 2;
return ans;
}
int main() {
long long int n;
cin >> n;
long long int lo = 1, hi = 100000000, mid;
while (hi > lo) {
mid = (hi + lo) / 2;
if (f(mid) > n)
hi = mid;
else
lo = mid + 1;
}
lo--;
long long int ind = 0, cnt = 0;
for (int i = lo; i >= 1; i--) {
if ((n - f(i)) % 3 == 0) {
cnt++;
ind = i;
break;
}
}
if (ind % 3 == 0 && ind) {
cnt--;
}
cout << (ind / 3) + cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int K;
int N[3], T[3];
priority_queue<int, vector<int>, greater<int> > q[3];
int main() {
scanf("%d", &K);
for (int(i) = 0; (i) < (3); (i)++) scanf("%d", &N[i]);
for (int(i) = 0; (i) < (3); (i)++) scanf("%d", &T[i]);
for (int(i) = 0; (i) < (3); (i)++)
for (int(j) = 0; (j) < (N[i]); (j)++) q[i].push(0);
int res = 0;
for (int(i) = 0; (i) < (K); (i)++) {
int tt = q[0].top();
q[0].pop();
tt = max(tt, q[1].top() - T[0]);
q[1].pop();
tt = max(tt, q[2].top() - T[0] - T[1]);
q[2].pop();
res = max(res, tt + T[0] + T[1] + T[2]);
q[0].push(tt + T[0]);
q[1].push(tt + T[0] + T[1]);
q[2].push(tt + T[0] + T[1] + T[2]);
}
printf("%d\n", res);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ncr[1011][1011];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long k;
cin >> k;
if (k == 0) {
cout << 1;
return 0;
}
for (int i = 0; i < 1011; i++) {
ncr[i][0] = 1;
}
for (int i = 1; i < 1011; i++) {
for (int j = 1; j <= i; j++) {
ncr[i][j] = (ncr[i - 1][j - 1] + ncr[i - 1][j]) % 1000000007;
}
}
long long dp[1011];
dp[0] = dp[1] = 0;
vector<int> idx;
for (int i = 2; i <= s.size(); i++) {
dp[i] = dp[__builtin_popcount(i)] + 1;
}
for (int i = 1; i <= s.size(); i++) {
if (dp[i] == k - 1) idx.push_back(i);
}
long long ans = 0;
for (int i = 0; i < idx.size(); i++) {
int o = idx[i];
for (int j = 0; j < s.size(); j++) {
if (s[j] == '0') continue;
ans += ncr[s.size() - j - 1][o] - (idx[i] == 1);
ans %= 1000000007;
o--;
if (o == 0) {
ans++;
break;
}
}
}
cout << ans % 1000000007;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> tabela;
int main() {
tabela.clear();
tabela.push_back(4);
tabela.push_back(7);
long long int k = 2;
long long int j = 2;
long long int p = 10;
while (k <= 512) {
for (int i = j - k; i <= j - 1; i++) tabela.push_back(4 * p + tabela[i]);
for (int i = j - k; i <= j - 1; i++) tabela.push_back(7 * p + tabela[i]);
p *= 10;
k *= 2;
j += k;
}
long long int ans = 0;
long long int l, r;
cin >> l;
cin >> r;
int i;
for (i = 0; tabela[i] < l; i++)
;
while (l <= r) {
ans += (min(tabela[i], r) - l + 1) * tabela[i];
l = min(tabela[i], r) + 1;
i++;
}
cout << ans;
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 300000;
int A[300000];
int main() {
for (int i = 0; i < 300000; i++) A[i] = INF;
int n, x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
A[x] = i;
}
int k = 0;
for (int i = 1; i < 300000; i++)
if (A[i] < A[k]) k = i;
cout << k;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int b[2][100000], c[2][100000], n, m, i, j, p, z = 1, f;
struct cd {
int x, y;
} a[100000];
bool cmp(cd a, cd b) { return a.x == b.x ? a.y < b.y : a.x < b.x; }
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
a[i].x--, a[i].y--;
}
std::sort(a, a + m, cmp);
for (i = 1; i < m; i++)
if (a[i].x != a[i - 1].x) c[1][p++] = i - 1, c[0][p] = i;
c[1][p++] = m - 1;
for (i = 0; i < p; i++) b[1][i] = n - 1;
if (!a[0].x) b[1][0] = a[0].y, c[1][0] = 0;
if (a[m - 1].x == n - 1) b[0][p - 1] = a[m - 1].y, c[0][p - 1] = m - 1;
while (z) {
z = 0;
for (i = 0; i < p; i++) {
if (i && b[0][i - 1] > b[0][i]) b[0][i] = b[0][i - 1], z = 1;
f = i && a[c[0][i - 1]].x + 1 == a[c[0][i]].x;
for (j = c[0][i]; j <= c[1][i]; j++) {
if (a[j].y == b[0][i]) b[0][i] = a[j].y + 1, c[0][i] = j, z = 1;
if (f && a[j].y <= b[1][i] && a[j].y >= b[1][i - 1])
b[1][i] = a[j].y - 1, c[1][i] = j, z = 1;
}
if (b[0][i] > b[1][i]) {
puts("-1");
return 0;
}
}
for (i = p - 1; i >= 0; i--) {
if (i != p - 1 && b[1][i + 1] < b[1][i]) b[1][i] = b[1][i + 1], z = 1;
f = i != p - 1 && a[c[0][i + 1]].x - 1 == a[c[0][i]].x;
for (j = c[1][i]; j >= c[0][i]; j--) {
if (a[j].y == b[1][i]) b[1][i] = a[j].y - 1, c[1][i] = j, z = 1;
if (f && a[j].y >= b[0][i] && a[j].y <= b[0][i + 1])
b[0][i] = a[j].y + 1, c[0][i] = j, z = 1;
}
if (b[0][i] > b[1][i]) {
puts("-1");
return 0;
}
}
}
printf("%d\n", n * 2 - 2);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, size[200000 + 5], dep[200000 + 5], pre[200000 + 5], le[200000 + 5],
ri[200000 + 5], son[200000 + 5][4], e[200000 + 5], a[4];
long long dp[200000 + 5];
void dfs(int u, int fa) {
size[u] = 1;
for (int i = 0; i < e[u]; i++) {
int v = son[u][i];
if (v == fa) continue;
dfs(v, u), size[u] += size[v], pre[u] = pre[v], dep[u] = dep[v] + 1;
if (!le[u])
le[u] = v;
else
ri[u] = v;
}
if (ri[u]) pre[u] = u, dep[u] = 0;
}
long long cal(int, int);
long long getAns(int u) {
if (!u) return 1;
if (size[u] & 1) return 0;
if (!pre[u]) return size[u] >> 1;
if (dp[u] != -1) return dp[u];
int p = pre[u], l = le[p], r = ri[p];
long long sum = 0;
dp[u] = 0;
for (int i = 0; i < 2; i++, swap(l, r)) {
if (!ri[r]) {
if (!(dep[u] & 1) && size[r] > 1) sum += cal(l, le[r]);
if (!pre[r] && dep[r] <= dep[u] && !(dep[r] + dep[u] & 1))
sum += getAns(l) * (dep[u] - dep[r] >= 2 ? 2 : 1);
sum %= 1000000007;
} else {
if (!pre[le[r]] && dep[le[r]] < dep[u] && (dep[u] + dep[le[r]] & 1))
sum += cal(l, ri[r]);
if (!pre[ri[r]] && dep[ri[r]] < dep[u] && (dep[u] + dep[ri[r]]) & 1)
sum += cal(l, le[r]);
sum %= 1000000007;
}
}
return dp[u] = sum % 1000000007;
}
long long cal(int u, int v) {
if (!u || !v) return getAns(u + v);
if (ri[u] || ri[v]) return 0;
if (le[u] && le[v]) return cal(le[u], le[v]);
return getAns(le[u] + le[v]);
}
int main() {
scanf("%d", &n);
n <<= 1;
int rt = 0;
bool flag = 0;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (e[u] == 3 || e[v] == 3) {
flag = 1;
break;
}
son[u][e[u]++] = v, son[v][e[v]++] = u;
if (e[u] == 3) rt = u;
if (e[v] == 3) rt = v;
}
if (flag) {
puts("0");
return 0;
}
if (!rt) {
printf("%lld\n", n == 2 ? 2 : (1ll * n * (n / 2 - 1) + 4ll) % 1000000007);
return 0;
}
long long ans = 0;
dfs(rt, 0);
a[0] = 0, a[1] = 1, a[2] = 2;
memset(dp, -1, sizeof(dp));
do {
int l = son[rt][a[0]], m = son[rt][a[1]], r = son[rt][a[2]], u = le[m],
v = ri[m];
ans += cal(l, u) * cal(r, v) % 1000000007, ans %= 1000000007;
if (u || v) ans += cal(l, v) * cal(r, u) % 1000000007, ans %= 1000000007;
} while (next_permutation(a, a + 3));
printf("%lld\n", ans * 2 % 1000000007);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long dp[102][102][30][2];
struct node {
int v, val;
};
int n, m;
vector<node> g[200];
int dfs(int x, int y, int z, int t) {
if (dp[x][y][z][t] != -1) return dp[x][y][z][t];
int flag = 0;
if (t == 1) {
int l = g[x].size();
for (int i = 0; i < l; i++) {
node temp = g[x][i];
if (temp.val >= z && !dfs(temp.v, y, temp.val, 2)) flag = 1;
}
} else {
int l = g[y].size();
for (int i = 0; i < l; i++) {
node temp = g[y][i];
if (temp.val >= z && !dfs(x, temp.v, temp.val, 1)) flag = 1;
}
}
return dp[x][y][z][t] = flag;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v, val;
scanf("%d %d %c", &u, &v, &val);
getchar();
g[u].push_back((node){v, val - 'a'});
}
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (dfs(i, j, 0, 1))
printf("A");
else
printf("B");
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int map[500][500], visit[500][500], cnt = 0, n;
char ans[3000000];
void dfs(int x, int y) {
visit[x][y] = 1;
if (!map[x][y]) {
map[x][y] = 1;
ans[cnt++] = '1';
}
int i;
for (i = x - 1; i > -1; i--) {
if (map[i][y]) {
if (!visit[x - 1][y]) {
ans[cnt++] = 'U';
dfs(x - 1, y);
ans[cnt++] = 'D';
}
break;
}
}
for (i = x + 1; i < n; i++) {
if (map[i][y]) {
if (!visit[x + 1][y]) {
ans[cnt++] = 'D';
dfs(x + 1, y);
ans[cnt++] = 'U';
}
break;
}
}
for (i = y - 1; i > -1; i--) {
if (map[x][i]) {
if (!visit[x][y - 1]) {
ans[cnt++] = 'L';
dfs(x, y - 1);
ans[cnt++] = 'R';
}
break;
}
}
for (i = y + 1; i < n; i++) {
if (map[x][i]) {
if (!visit[x][y + 1]) {
ans[cnt++] = 'R';
dfs(x, y + 1);
ans[cnt++] = 'L';
}
break;
}
}
map[x][y] = 0;
ans[cnt++] = '2';
}
int main() {
int i, j, x0, y0, res = 1;
scanf("%d%d%d", &n, &x0, &y0);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) scanf("%d", &map[i][j]);
dfs(x0 - 1, y0 - 1);
ans[cnt++] = 0;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (map[i][j]) {
res = 0;
break;
}
if (res) {
printf("YES\n%s", ans);
} else
printf("NO\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N;
int A[200201];
int dp[200201];
int seg[530000];
int Update(int idx, int val, int n, int l, int r) {
if (r < idx || idx < l) return seg[n];
if (l == r) return seg[n] = max(seg[n], val);
int mid = l + r >> 1;
return seg[n] = max(Update(idx, val, n << 1, l, mid),
Update(idx, val, n << 1 | 1, mid + 1, r));
}
int Query(int L, int R, int n, int l, int r) {
if (r < L || R < l) return 0;
if (L <= l && r <= R) return seg[n];
int mid = l + r >> 1;
return max(Query(L, R, n << 1, l, mid), Query(L, R, n << 1 | 1, mid + 1, r));
}
int Delete(int idx, int n, int l, int r) {
if (r < idx || idx < l) return seg[n];
if (l == r) return seg[n] = 0;
int mid = l + r >> 1;
return seg[n] = max(Delete(idx, n << 1, l, mid),
Delete(idx, n << 1 | 1, mid + 1, r));
}
void dnc(int L, int R) {
if (L == R) {
dp[L] = max(dp[L], 1);
return;
}
int mid = L + R >> 1;
dnc(L, mid);
vector<array<int, 3> > u, q;
for (int i = L; i <= mid; i++)
if (A[i] <= i) u.push_back({i - A[i], A[i], dp[i]});
for (int i = mid + 1; i <= R; i++)
if (A[i] <= i) q.push_back({i - A[i] + 1, A[i], i});
sort(u.begin(), u.end());
sort(q.begin(), q.end());
int j = 0;
for (auto [a, b, i] : q) {
while (j < u.size() && u[j][0] < a) {
Update(u[j][1], u[j][2], 1, 1, 200000);
j++;
}
dp[i] = max(dp[i], Query(1, b - 1, 1, 1, 200000) + 1);
}
for (auto [a, b, x] : u) Delete(b, 1, 1, 200000);
dnc(mid + 1, R);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin.exceptions(ios::badbit | ios::failbit);
cin >> N;
for (int i = 1; i <= N; i++) cin >> A[i];
dnc(1, N);
int res = 0;
for (int i = 1; i <= N; i++) {
if (A[i] <= i) res = max(res, dp[i]);
}
cout << res << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int>> adj(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<vector<int>> des(n + 1);
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
des[a].push_back(i);
}
vector<int> mina(n + 1, 1);
for (int i = 1; i <= n; i++) {
for (int& a : des[i]) {
if (mina[a] != i) {
cout << "-1" << endl;
return;
}
for (int& b : adj[a]) {
if (mina[b] == i) mina[b]++;
}
}
}
for (int i = 1; i <= n; i++) {
for (int& a : des[i]) {
cout << a << ' ';
}
}
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 2e6 + 9;
int const MAXNN = 1e5 + 9;
int p[MAXN], depth[MAXNN], ans[MAXNN], nbr[MAXNN];
map<int, int> id;
stack<pair<int, int>> st[150000];
vector<vector<int>> adj;
void getDepth(int node, int p) {
for (auto child : adj[node]) {
if (child == p) continue;
depth[child] = 1 + depth[node];
getDepth(child, node);
}
}
void add(int node) {
int x = nbr[node];
while (x > 1) {
st[id[p[x]]].push(make_pair(node, depth[node]));
x /= p[x];
}
}
void del(int node) {
int x = nbr[node];
while (x > 1) {
st[id[p[x]]].pop();
x /= p[x];
}
}
void DFS(int node, int par) {
int x = nbr[node];
int ret = -1;
int dep = -1;
while (x > 1) {
if (!st[id[p[x]]].empty() && st[id[p[x]]].top().second > dep)
dep = st[id[p[x]]].top().second, ret = st[id[p[x]]].top().first;
x /= p[x];
}
ans[node] = ret;
add(node);
for (auto child : adj[node]) {
if (child == par) continue;
DFS(child, node);
}
del(node);
}
int main() {
int cnt = 0;
for (int i = 0; i < MAXN; i++) p[i] = i;
for (int i = 2; i < MAXN; i++)
if (p[i] == i) {
id[i] = cnt++;
for (int j = 2 * i; j < MAXN; j += i)
if (p[j] == j) p[j] = i;
}
int n, q;
cin >> n >> q;
adj = vector<vector<int>>(n + 1);
for (int i = 1; i <= n; i++) cin >> nbr[i];
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
getDepth(1, -1);
DFS(1, -1);
while (q--) {
int u, v, t;
cin >> t;
if (t == 1) {
cin >> v;
cout << ans[v] << endl;
} else {
cin >> v >> u;
nbr[v] = u;
DFS(1, -1);
}
}
}
| 6 |
#include <bits/stdc++.h>
char grid[500][501];
int n, m, moves[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}, nc, nr, res;
void dfs(int r, int c, int first, int counting) {
if (counting)
res += 1;
else
printf("B %d %d\n", r + 1, c + 1);
grid[r][c] = 'C';
for (int _n = 4, i = 0; i < _n; ++i) {
nr = r + moves[i][0];
nc = c + moves[i][1];
if (nr < 0 || nr >= n) continue;
if (nc < 0 || nc >= m) continue;
if (grid[nr][nc] != '.') continue;
dfs(nr, nc, 0, counting);
}
if (!first) {
if (counting)
res += 2;
else {
printf("D %d %d\n", r + 1, c + 1);
printf("R %d %d\n", r + 1, c + 1);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int _n = n, i = 0; i < _n; ++i) scanf("%s", grid[i]);
for (int _n = n, i = 0; i < _n; ++i)
for (int _n = m, j = 0; j < _n; ++j)
if (grid[i][j] == '.') dfs(i, j, 1, 1);
for (int _n = n, i = 0; i < _n; ++i)
for (int _n = m, j = 0; j < _n; ++j)
if (grid[i][j] == 'C') grid[i][j] = '.';
printf("%d\n", res);
for (int _n = n, i = 0; i < _n; ++i)
for (int _n = m, j = 0; j < _n; ++j)
if (grid[i][j] == '.') dfs(i, j, 1, 0);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long n, i, j, ar[300005], d, a, b, m, l, k, pt, q, sz[300005], c0, d0, c,
r;
long long dp[300005], f = 0;
long long mrk[3][300005];
pair<long long, pair<long long, long long>> p[300005];
vector<int> v, vt;
int main() {
scanf("%lld %lld", &n, &q);
set<pair<int, int>> vis;
set<pair<pair<int, int>, pair<int, int>>> tot;
for (long long i = 0; i < q; i++) {
scanf("%lld %lld", &r, &c);
int f = 0;
if (vis.find({r, c}) == vis.end() && f == 0) {
f = 1;
vis.insert({r, c});
if (r == 2)
for (j = c - 1; j <= c + 1; j++) {
if (j < 1 || j > n) continue;
if (vis.find({r - 1, j}) != vis.end())
tot.insert({{r - 1, j}, {r, c}});
}
if (r == 1)
for (j = c - 1; j <= c + 1; j++) {
if (j < 1 || j > n) continue;
if (vis.find({r + 1, j}) != vis.end())
tot.insert({{r, c}, {r + 1, j}});
}
}
if (vis.find({r, c}) != vis.end() && f == 0) {
auto it = vis.find({r, c});
if (it != vis.end()) vis.erase({r, c});
for (j = c - 1; j <= c + 1; j++) {
if (j < 1 || j > n) continue;
if (r == 1) {
tot.erase({{r, c}, {r + 1, j}});
}
if (r == 2) {
tot.erase({{r - 1, j}, {r, c}});
}
}
}
if (tot.size() == 0)
cout << "Yes\n";
else
cout << "No\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char invert(char a) {
if (a == 'F') return 'T';
return 'F';
}
int num(int x) {
if (x == 0) return -1;
return 1;
}
int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
int mas[111][111][2];
bool dost[111][111][2];
int main() {
string s;
cin >> s;
int n = s.length();
int k;
cin >> k;
dost[0][0][1] = true;
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= k; ++j) {
for (int ss = 0; ss < 2; ++ss) {
if (!dost[i][j][ss]) continue;
int z = k - j;
for (int l = 0; l <= z; ++l) {
char a;
if (l % 2 == 0)
a = s[i];
else
a = invert(s[i]);
if (a == 'F') {
int v = ss;
if (mas[i][j][ss] == 0 && v == 0) v = 1;
int f = abs(mas[i][j][ss] + num(v));
mas[i + 1][j + l][v] = max(abs(mas[i + 1][j + l][v]), f);
dost[i + 1][j + l][v] = true;
} else {
mas[i + 1][j + l][ss ^ 1] =
max(abs(mas[i + 1][j + l][ss ^ 1]), abs(mas[i][j][ss]));
dost[i + 1][j + l][ss ^ 1] = true;
}
}
}
}
}
int ans = abs(mas[n][k][0]);
if (abs(mas[n][k][1]) > ans) ans = abs(mas[n][k][1]);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int gcd(int a, int b) {
int temp;
while (b) {
temp = a % b;
a = b;
b = temp;
}
return a;
}
int main() {
int n;
scanf("%d", &n);
int i, j, gc;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (i == 0)
gc = a[i];
else if (gc != 1)
gc = gcd(gc, a[i]);
}
if (gc != 1)
for (i = 0; i < n; i++) a[i] /= gc;
bool ok = true;
for (i = 0; i < n; i++) {
while (a[i] != 1) {
if (a[i] % 2 == 0)
a[i] /= 2;
else if (a[i] % 3 == 0)
a[i] /= 3;
else
break;
}
if (a[i] != 1) {
ok = false;
break;
}
}
if (ok)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T amax(T _a, T _b) {
return _a > _b ? _a : _b;
}
template <class T>
T amin(T _a, T _b) {
return _a < _b ? _a : _b;
}
template <class T>
T gcd(T _a, T _b) {
T t;
while (_b) {
t = _b;
_b = _a % _b;
_a = t;
}
return _a;
}
template <class T>
T apow(T b, T p) {
T r = 1;
while (p > 0) {
if ((p % 2) == 1) r = (r * b) % 1000000007;
b = (b * b) % 1000000007;
p /= 2;
}
return r;
}
const int N = 2e5 + 1;
const int LOGN = 20;
int n, m, a, b;
void input() { cin >> n >> a >> b; }
void output() {
a = b / (n * a / gcd(n, a));
cout << a << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
int tc = 1;
while (tc--) {
input();
output();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define pb emplace_back
#define mp make_pair
#define fi first
#define se second
#define all(v) v.begin(),v.end()
#define run ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);cerr.tie(0);
#define mod 1000000007
#define decimal(n,k) cout<<fixed<<setprecision(k)<<n<<endl
#define LL_MAX LLONG_MAX
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
#define maxa(v) *max_element(v, v + v.size())
#define mina(v) *min_element(v, v + v.size())
int exp(int x,int y){int res=1;x=x%mod;while(y>0){if(y&1)res=(res*x)%mod;y=y>>1;x=(x*x)%mod;}return res;}
int modinv(int x){return exp(x,mod-2);}
int add(int a,int b){a%=mod,b%=mod;a=((a+b)%mod+mod)%mod;return a;}
int sub(int a,int b){a%=mod,b%=mod;a=((a-b)%mod+mod)%mod;return a;}
int mul(int a,int b){a%=mod,b%=mod;a=((a*b)%mod+mod)%mod;return a;}
int gcd(int a, int b){if (b == 0)return a; return gcd(b, a % b);}
int Log2n( int n){ return (n > 1) ? 1 + Log2n(n / 2) : 0;}
int fac[100009];int ncr_mod(int n,int k){int ans=fac[n];ans*=modinv(fac[k]);ans%=mod;ans*=modinv(fac[n-k]);ans%=mod;return ans;}
vector<int>v_prime;void Sieve(int n){bool prime[n + 1];memset(prime,true,sizeof(prime));for (int p = 2; p*p <=n;p++){if(prime[p] ==true) {for(int i = p*p; i<= n; i += p)prime[i]=false;}}for(int p = 2;p<= n;p++)if (prime[p])v_prime.pb(p);}
vector<int>v_factor;void factors(int n){ for (int i=1; i<=sqrt(n); i++) {if (n%i == 0) {if (n/i == i) v_factor.pb(i);else { v_factor.pb(i),v_factor.pb(n/i);};} } sort(all(v_factor)); }
void out(vector<int>&a){for(int i=0;i<a.size();i++) cout<<a[i]<<" "; cout<<endl;}
// s.top().second;
signed main()
{
run;
/*
open for mod factorial
fac[0]=1;
for(int i=1;i<100009;i++)
{
fac[i]=fac[i-1]*i;
fac[i]%=mod;
}
*/
/*
for sieve open this and use v_prime
int pp=pow(10,6)+100000;
Sieve(pp);
*/
// USE v_factor For calculating factors
int t=1;
cin>>t;
while(t--)
{
// vector< pair <int,int> > vp;
// map<int,int>mp; // x.second-->frequency
// set<int>st;
int n,i,x,y,ok=0,sum=0,ans=0,j,k,cnt=0,m,c=0;
int h[100009]={0};
cin>>n;
string s;
//cin>>s;
vector<int>a(n,0),v,b(n,0),tt(n,0),stand(n,0);
for(i=0;i<n;i++)
{
cin>>a[i]>>b[i];
stand[i]=(b[i]-a[i])/2;
if((b[i]-a[i])%2!=0)
stand[i]++;
}
for(i=0;i<n;i++)
cin>>tt[i];
int fi=tt[0]+a[0];
if(n==1)
{
cout<<fi<<endl;
continue;
}
else
{
int dep=0,fi,pp=a[0];
for(i=0;i<n-1;i++)
{
fi=tt[i]+pp+dep;
x=fi+stand[i];
dep=max(b[i],x);
pp=abs(a[i+1]-b[i]);
}
fi=tt[n-1]+pp+dep;
cout<<fi<<endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<double, double> > data;
double p;
bool simulate(double t) {
double totalPower = p;
for (int i = 0; i < data.size(); i++) {
double NeededPower = (data[i].first - data[i].second / t);
if (NeededPower > 0) {
totalPower -= NeededPower;
}
if (totalPower < 0) return false;
}
return true;
}
int main() {
int n;
cin >> n >> p;
for (int i = 0; i < n; i++) {
double a, b;
cin >> a >> b;
data.push_back(pair<double, double>(a, b));
}
double l = 0, r = 99999999999999;
double mid;
for (int i = 0; i < 100; i++) {
mid = l + r;
mid /= 2;
if (simulate(mid)) {
l = mid;
} else {
r = mid;
}
}
if (simulate(l)) {
mid = min(mid, l);
}
if (simulate(r)) {
mid = min(mid, r);
}
if (mid == 99999999999999) {
cout << -1 << endl;
} else {
printf("%.10lf\n", mid);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, m;
cin >> n >> m;
long long int a[m];
map<long long int, long long int> mp;
long long int sm = 0;
for (long long int i = 0; i < m; i++) {
cin >> a[i];
mp[a[i]]++;
sm += a[i];
}
if (sm < n) {
cout << -1 << endl;
return;
}
long long int count = 0;
queue<long long int> q;
for (long long int j = 0; j <= 60; j++) {
long long int x = (1LL << j);
if (n & (x)) {
if (!mp[x]) {
q.push(j);
continue;
} else {
mp[x]--;
}
}
while (q.size() && mp[x]) {
count += j - q.front();
mp[x]--;
long long int sm = 0;
while (q.size() && sm + (1LL << q.front()) <= x) {
sm += (1LL << q.front());
q.pop();
}
}
mp[1LL * 2 * x] += (mp[x]) / 2;
}
cout << count << endl;
}
int main() {
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
cin.get();
char image[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%c", &image[i][j]);
cin.get();
}
char check[4];
int count = 0;
if (n >= 2 && m >= 2) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
check[0] = image[i][j];
check[1] = image[i][j + 1];
check[2] = image[i + 1][j];
check[3] = image[i + 1][j + 1];
sort(check, check + 4);
if (check[0] == 'a' && check[1] == 'c' && check[2] == 'e' &&
check[3] == 'f')
count++;
}
}
}
printf("%d", count);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
const int mx = 2e5 + 5;
vector<long long> a;
vector<pair<long long, long long> > b;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int m;
cin >> m;
long long x;
long long ans[m];
for (int i = 0; i < m; ++i) {
cin >> x;
a.push_back(x);
}
sort(a.begin(), a.end(), greater<long long>());
for (int i = 0; i < m; ++i) {
cin >> x;
b.push_back(make_pair(x, i));
}
sort(b.begin(), b.end());
for (int i = 0; i < m; ++i) {
int idx = b[i].second;
ans[idx] = a[i];
}
for (int i = 0; i < m; ++i) cout << ans[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 100000;
vector<int> G[kMaxN + 1];
bool B[kMaxN + 1];
vector<int> ans;
priority_queue<int> options;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
sort(G[i].begin(), G[i].end());
}
options.push(-1);
B[1] = true;
while (!options.empty()) {
int x = -options.top();
options.pop();
ans.push_back(x);
for (int y : G[x]) {
if (B[y]) continue;
B[y] = true;
options.push(-y);
}
}
for (int x : ans) cout << x << ' ';
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, a, b, oc[101] = {0};
cin >> n >> m;
if (m == 0) {
cout << 0;
return 0;
}
if (m == 1) {
cout << 1;
return 0;
}
vector<vector<int> > g;
g.resize(n + 1);
for (i = 0; i < m; ++i) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
int cnt = 0;
vector<int> idx;
while (true) {
int flag = 0;
for (i = 1; i <= n; ++i) {
if (g[i].size() == 1) {
flag = 1;
idx.push_back(i);
}
}
for (int k = 0; k < idx.size(); ++k) {
vector<int>::iterator it;
for (it = g[idx[k]].begin(); it != g[idx[k]].end(); ++it) {
g[*it].erase(find(g[*it].begin(), g[*it].end(), idx[k]));
}
g[idx[k]].clear();
}
if (flag)
++cnt;
else
break;
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e5 + 7;
const long long mod = 1e9 + 7;
const long long INF = 1e9 + 7;
const long long mlog = 20;
const long long SQ = 400;
unordered_map<long long, long long> mp;
long long cnt[2];
long long a[maxn];
vector<long long> change;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(), cout.tie();
;
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (mp.count(a[i]) || cnt[a[i] % 2] == n / 2) {
change.push_back(i);
continue;
}
cnt[a[i] % 2]++;
mp[a[i]] = 1;
}
long long ptr = 0;
for (long long i = 1; i <= m && ptr < change.size(); i++) {
if (cnt[i % 2] == n / 2 || mp.count(i)) continue;
a[change[ptr]] = i;
ptr++;
cnt[i % 2]++;
}
if (cnt[0] != n / 2 || cnt[1] != n / 2) return cout << -1, 0;
cout << ptr << "\n";
for (long long i = 1; i <= n; i++) cout << a[i] << " ";
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
vector<int> digitos(long long n, int dig) {
vector<int> res;
while (n > 0) {
res.push_back(n % 2);
n /= 2;
}
while (res.size() < dig) res.push_back(0);
reverse(res.begin(), res.end());
return res;
}
int main() {
int n;
while (cin >> n) {
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int actualAnd[21];
memset(actualAnd, 0, sizeof(actualAnd));
set<int> res;
for (int i = 0; i < n; i++) {
vector<int> dig = digitos(a[i], 21);
for (int j = 0; j < 21; j++) {
if (dig[j] == 0) {
actualAnd[j] |= a[i];
res.insert(actualAnd[j]);
} else {
actualAnd[j] = 0;
}
}
}
cout << res.size() << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 500010;
inline long long read() {
long long s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
void print(long long x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
long long n, k, siz[N], d[N], ans, dp[N];
long long head[N], maxE;
struct Edge {
long long nxt, to;
} e[N];
inline void Add(long long u, long long v) {
e[++maxE].nxt = head[u];
head[u] = maxE;
e[maxE].to = v;
}
void DFS(long long x, long long fa) {
siz[x] = 1, d[x] = d[fa] + 1;
for (long long i = head[x]; i; i = e[i].nxt) {
if (e[i].to == fa) continue;
DFS(e[i].to, x);
siz[x] += siz[e[i].to];
}
dp[x] = d[x] - siz[x];
}
inline bool cp(long long x, long long y) { return x > y; }
signed main() {
n = read(), k = read();
for (register long long i = 1; i < n; i++) {
long long u, v;
u = read(), v = read();
Add(u, v), Add(v, u);
}
DFS(1, 0);
sort(dp + 1, dp + 1 + n, cp);
for (register long long i = 1; i <= k; i++) ans += dp[i];
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long add(long long a, long long b) {
a %= 1000000007;
b %= 1000000007;
long long p = (a + b) % 1000000007;
return (p + 1000000007) % 1000000007;
}
long long mul(long long a, long long b) {
a %= 1000000007;
b %= 1000000007;
long long p = (a * b) % 1000000007;
return (p + 1000000007) % 1000000007;
}
pair<long long, long long> query(vector<long long> v) {
fflush(stdout);
cout << "? " << (int)(v).size() << " ";
for (long long i = 0; i < (int)(v).size(); i++) cout << v[i] << " ";
cout << endl;
long long ind, d;
cin >> ind >> d;
fflush(stdout);
return {ind, d};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long i, j, n;
cin >> n;
vector<long long> adj[1010];
for (i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
long long r, len;
vector<long long> v;
for (i = 1; i <= n; i++) v.push_back(i);
pair<long long, long long> p = query(v);
r = p.first;
len = p.second;
queue<long long> q;
q.push(r);
vector<long long> dis(n + 10, 0), mrk(n + 10, 0);
vector<long long> depth[1010];
while (!q.empty()) {
long long x = q.front();
mrk[x] = 1;
depth[dis[x]].push_back(x);
q.pop();
for (j = 0; j < adj[x].size(); j++) {
long long y = adj[x][j];
if (mrk[y]) continue;
dis[y] = dis[x] + 1;
q.push(y);
}
}
long long low = (len + 1) / 2, high = len, mid, ans = -1;
;
while (low <= high) {
mid = (low + high) / 2;
if (!(int)(depth[mid]).size()) {
high = mid - 1;
continue;
}
pair<long long, long long> p = query(depth[mid]);
if (p.second == len) {
ans = p.first;
low = mid + 1;
} else
high = mid - 1;
}
assert(ans != -1);
vector<long long> dis1(n + 10, 0), mrk1(n + 10, 0);
vector<long long> depth1[1010];
q.push(ans);
while (!q.empty()) {
long long x = q.front();
mrk1[x] = 1;
depth1[dis1[x]].push_back(x);
q.pop();
for (j = 0; j < adj[x].size(); j++) {
long long y = adj[x][j];
if (mrk1[y]) continue;
dis1[y] = dis1[x] + 1;
q.push(y);
}
}
pair<long long, long long> p1 = query(depth1[len]);
long long ans2 = p1.first;
cout << "! " << ans << " " << ans2 << endl;
string str;
cin >> str;
if (str == "Incorrect") break;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " , ";
err(++it, args...);
}
const int inf = 0x3f3f3f3f;
const int mod = 998244353;
const int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const int fxx[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
class UnionFind {
private:
vector<int> p, rank, sz;
public:
UnionFind(int n) {
p.assign(n, 0);
rank.assign(n, 0);
sz.assign(n, 1);
for (int i = 0; i < n; i++) p[i] = i;
}
int findSet(int i) { return (i == p[i] ? i : findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
sz[x] += sz[y];
} else {
sz[y] += sz[x];
p[x] = y;
if (rank[x] == rank[y]) rank[y]++;
}
}
}
};
int n, m;
int l[300010], r[300010], a[60], b[60];
int cnt[300010];
int A[300010];
int rv[300010];
int add(int x, int y) { return ((x + y) % mod + mod) % mod; }
int mul(int x, int y) { return (x * 1ll * y) % mod; }
int binpow(int x, int y) {
int z = 1;
while (y > 0) {
if (y % 2 == 1) z = mul(z, x);
x = mul(x, x);
y /= 2;
}
return z;
}
int inv(int x) { return binpow(x, mod - 2); }
int C(int n, int k) {
if (k > n || n < 0 || k < 0) return 0;
return mul(A[n], mul(rv[n - k], rv[k]));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = int(0); i < int(n); i++) {
scanf("%d%d", &l[i], &r[i]);
}
for (int i = int(0); i < int(m); i++) {
scanf("%d%d", &a[i], &b[i]);
}
for (int i = int(0); i < int(n); i++) {
cnt[l[i]]++;
cnt[r[i] + 1]--;
}
for (int i = int(0); i < int(n + 1); i++) cnt[i + 1] += cnt[i];
A[0] = 1;
for (int i = int(1); i < int(n + 1); i++) A[i] = mul(A[i - 1], i);
for (int i = int(0); i < int(n + 1); i++) rv[i] = inv(A[i]);
vector<vector<int> > p(2 * m + 1, vector<int>(n + 1));
for (int i = int(1); i < int(n + 1); i++) {
for (int j = int(0); j < int(2 * m + 1); j++) {
p[j][i] = add(p[j][i - 1], C(cnt[i] - j, i - j));
}
}
int ans = 0;
for (int mask = int(0); mask < int((1 << m)); mask++) {
int sign = 1;
set<int> used;
for (int i = int(0); i < int(m); i++) {
if ((mask & (1 << i))) {
sign = mul(sign, mod - 1);
used.insert(a[i] - 1);
used.insert(b[i] - 1);
}
}
int L = 1, R = n;
for (auto x : used) {
L = max(L, l[x]);
R = min(R, r[x]);
}
if (R < L) continue;
ans = add(ans, mul(sign, add(p[used.size()][R], -p[used.size()][L - 1])));
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long ans;
long long tree[200000];
int main() {
cin >> n;
long long sz = 1;
for (int i = 0; i <= n; ++i) sz *= 2;
sz--;
for (int i = 2; i <= sz; ++i) cin >> tree[i];
for (int i = sz; i >= 1; --i) {
ans +=
max(tree[i + i], tree[i + i + 1]) - min(tree[i + i], tree[i + i + 1]);
tree[i] += max(tree[i + i], tree[i + i + 1]);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long n, m;
unsigned long long k;
vector<int> digits;
map<pair<pair<int, int>, unsigned long long>, unsigned long long> memo;
vector<int> todigits(unsigned long long num) {
int i = 0;
vector<int> ans;
while (num > 0) {
int d = num % 2;
ans.push_back(d);
num /= 2;
}
reverse(ans.begin(), ans.end());
return ans;
}
unsigned long long dp(vector<int> &X, int id, bool flag,
unsigned long long sum) {
pair<int, int> obj = make_pair(id, flag);
pair<pair<int, int>, unsigned long long> mem = make_pair(obj, sum);
if (memo.count(mem) > 0) return memo[mem];
unsigned long long w = 0;
if (id == X.size()) {
return sum == k;
}
for (int d = 0; d <= 1; d++) {
if (flag && d > X[id]) break;
w += dp(X, id + 1, flag && X[id] == d, sum + d);
}
return memo[mem] = w;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> m >> k;
unsigned long long ans = 0;
unsigned long long mid = (unsigned long long)1e8;
mid >>= 1ULL;
unsigned long long l = 1, r = 1000000000000000000;
while (l < r) {
mid = (l + r) / 2ULL;
digits = todigits(mid);
memo.clear();
unsigned long long ncalc = dp(digits, 0, true, 0);
memo.clear();
digits = todigits(mid * 2ULL);
unsigned long long n2calc = dp(digits, 0, true, 0);
if (n2calc - ncalc < m) {
l = mid + 1;
} else {
r = mid;
}
}
cout << l << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
struct Maxflow {
struct edge {
int from, to;
long long flow, capacity;
};
int s, t;
vector<edge> edg;
vector<int> g[2011];
int dist[2011], visited[2011];
int cur[2011];
void init() {
edg.clear();
int i;
for (i = 0; i < 2011; i++) {
g[i].clear();
}
}
void addedge(int from, int to, long long capacity) {
edge e1 = edge{from, to, 0ll, capacity};
edge e2 = edge{to, from, 0ll, 0ll};
edg.push_back(e1), edg.push_back(e2);
g[from].push_back((int)edg.size() - 2);
g[to].push_back((int)edg.size() - 1);
}
bool bfs() {
memset(visited, 0, sizeof(visited));
memset(dist, 0, sizeof(dist));
queue<int> q;
q.push(s);
visited[s] = 1;
dist[s] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < (int)g[v].size(); i++) {
edge &e = edg[g[v][i]];
int nxt = e.to;
if (!visited[nxt] && e.capacity > e.flow) {
dist[nxt] = dist[v] + 1;
q.push(nxt);
visited[nxt] = 1;
}
}
}
return visited[t];
}
long long dfs(int x, long long cp) {
if (x == t || cp == 0) {
return cp;
}
long long flow = 0, newflow;
for (int &y = cur[x]; y < (int)g[x].size(); y++) {
edge &e = edg[g[x][y]];
if (dist[x] + 1 == dist[e.to]) {
long long minn = min(cp, e.capacity - e.flow);
newflow = dfs(e.to, minn);
if (newflow > 0) {
e.flow += newflow;
edg[g[x][y] ^ 1].flow -= newflow;
flow += newflow;
cp -= newflow;
if (cp == 0) {
break;
}
}
}
}
return flow;
}
long long Dinic() {
long long flow = 0;
while (bfs()) {
memset(cur, 0, sizeof(cur));
flow += dfs(s, 100000000000);
}
return flow;
}
};
Maxflow mf;
long long dist[2011][2011];
char g[2011][2011];
int n, m, male, female;
int in(int x) { return x * 2; }
int out(int x) { return x * 2 + 1; }
int index(int x, int y) { return x * m + y; }
void add(int x, int y, int z, int w) {
if (x < 0 || y < 0 || x >= n || y >= m || z < 0 || z >= n || w < 0 || w >= m)
return;
if (g[x][y] == '#' || g[z][w] == '#') return;
if (x == z && y == w) {
dist[index(x, y)][index(z, w)] = 0;
} else {
dist[index(x, y)][index(z, w)] = 1;
}
}
int dx[5] = {1, 0, -1, 0, 0}, dy[5] = {0, 1, 0, -1, 0};
struct people {
int r, c, speed;
};
vector<people> man, woman;
bool check(long long T) {
int i, j;
mf.init();
mf.s = 2011 - 2, mf.t = 2011 - 1;
for (i = 0; i < n * m; ++i) {
mf.addedge(in(i), out(i), 1);
}
int offset = 2 * n * m, sz = man.size();
for (i = 0; i < sz; ++i) {
mf.addedge(mf.s, i + offset, 1);
for (j = 0; j < n * m; ++j) {
if (dist[index(man[i].r, man[i].c)][j] >= 100000000000) continue;
if (dist[index(man[i].r, man[i].c)][j] * man[i].speed > T) continue;
mf.addedge(i + offset, in(j), 1);
}
}
for (i = 0; i < sz; ++i) {
mf.addedge(i + sz + offset, mf.t, 1);
for (j = 0; j < n * m; ++j) {
if (dist[index(woman[i].r, woman[i].c)][j] >= 100000000000) continue;
if (dist[index(woman[i].r, woman[i].c)][j] * woman[i].speed > T) continue;
mf.addedge(out(j), i + offset + sz, 1);
}
}
return mf.Dinic() == (1ll * sz);
}
int main() {
int i, j, k;
int r, c, t;
scanf("%d%d%d%d", &n, &m, &male, &female);
for (i = 0; i < n; ++i) {
scanf("%s", g[i]);
}
scanf("%d%d%d", &r, &c, &t);
r--, c--;
if (abs(male - female) != 1) {
printf("-1\n");
return 0;
}
if (male - female == 1) {
woman.push_back(people{r, c, t});
} else {
man.push_back(people{r, c, t});
}
for (i = 0; i < 2011; ++i) {
for (j = 0; j < 2011; ++j) {
dist[i][j] = 100000000000;
}
}
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
for (k = 0; k < 5; ++k) {
add(i, j, i + dx[k], j + dy[k]);
}
}
}
for (i = 0; i < male; ++i) {
scanf("%d%d%d", &r, &c, &t);
r--, c--;
man.push_back(people{r, c, t});
}
for (i = 0; i < female; ++i) {
scanf("%d%d%d", &r, &c, &t);
r--, c--;
woman.push_back(people{r, c, t});
}
for (k = 0; k < n * m; ++k) {
for (i = 0; i < n * m; ++i) {
for (j = 0; j < n * m; ++j) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
long long low = 0, high = 1e14;
long long ans = high;
while (low <= high) {
long long mid = (low + high) / 2;
if (check(mid)) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
printf("%I64d\n", ans != 1e14 ? ans : -1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[1 << 21];
long long c[2][21];
int n, m, q;
void build(int l, int r, int dep) {
if (l == r) return;
int mid = (l + r) >> 1, pos;
build(l, mid, dep - 1);
build(mid + 1, r, dep - 1);
for (int i = (l), _en = (mid); i <= _en; i++) {
pos = lower_bound(a + mid + 1, a + r + 1, a[i]) - a - 1;
if (a[pos] < a[i]) c[0][dep] += pos - mid;
pos = upper_bound(a + mid + 1, a + r + 1, a[i]) - a;
if (a[pos] > a[i]) c[1][dep] += r - pos + 1;
}
sort(a + l, a + r + 1);
}
int main() {
scanf("%d", &n);
for (int i = (1), _en = ((1 << n)); i <= _en; i++) scanf("%d", &a[i]);
scanf("%d", &m);
build(1, (1 << n), n);
while (m--) {
scanf("%d", &q);
long long ans = 0;
for (int i = (0), _en = (q); i <= _en; i++) swap(c[0][i], c[1][i]);
for (int i = (0), _en = (n); i <= _en; i++) ans += c[0][i];
printf("%lld\n", ans);
}
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.