solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include<bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define ll long long int
#define ld long double
#define pb push_back
#define fi first
#define se second
#define all(x) x.begin(),x.end()
#define mem(x,y) memset(x,y,sizeof(x))
#define sz(x) (int)x.size()
#define pii pair<int,int>
#define pll pair<ll,ll>
#define pi 3.141592653589793238
#define INF 1e9+7
#define INFL 1e18
#define mod 1000000007
//#define mod 998244353
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
//using namespace __gnu_pbds;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> os;
//typedef tree<pii,null_type,less<pii>,rb_tree_tag,tree_order_statistics_node_update> os_pair;
ll power(ll x,ll n){ll res =1;while(n>0){if(n%2==1){res=res*x;}x=x*x;n=n/2;}return res;}
ll powm(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
//cout<< fixed << setprecision(10)
//__builtin_popcountll()
void solve()
{
ll n,i,j;
cin>>n;
ll x=n%11;
if(x==0)
{
cout<<"YES\n";
return;
}
ll y=n/11;
if(x*10<=y)
{
cout<<"YES\n";
}
else
{
cout<<"NO\n";
}
}
int main(){
fast;
int T;
T=1;
cin>>T;
while(T--){
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M, Primes[1000], Tail;
long long P, Base[5000 + 1][5000 + 1];
long long Choose[5000 + 1];
long long DP[2][5000 + 1];
void add(long long &a, long long b) { a = (a + b) % P; }
void map_op(map<int, int> &count, int num, int pl) {
if (count.find(num) == count.end())
count[num] = pl;
else
count[num] += pl;
}
void fragment(map<int, int> &count, int pl, int num) {
for (int i = 0; i < Tail && Primes[i] * Primes[i] <= num; i++) {
int cnt = 0;
while (num % Primes[i] == 0) {
cnt++;
num /= Primes[i];
}
if (cnt != 0) map_op(count, Primes[i], pl * cnt);
}
if (num != 1) {
map_op(count, num, pl);
}
}
void pre_process() {
int i, j;
memset(Base, 0, sizeof(Base));
Base[1][1] = 1;
for (i = 1; i < 5000; i++) {
for (j = 1; j <= i; j++)
if (Base[i][j] != 0) {
add(Base[i + 1][j], (j - 1) * Base[i][j]);
add(Base[i + 1][j + 1], (j + 1) * Base[i][j]);
}
}
Choose[0] = 1;
map<int, int> count;
Primes[0] = 2;
Tail = 1;
for (i = 3; i <= 1000; i++) {
for (j = 0; j < Tail; j++)
if (i % Primes[j] == 0) break;
if (j == Tail) {
Primes[Tail++] = i;
}
}
for (i = 1; i <= min(5000, M); i++) {
fragment(count, 1, M - i + 1);
fragment(count, -1, i);
Choose[i] = 1;
for (map<int, int>::iterator it = count.begin(); it != count.end(); it++) {
for (j = 0; j < (int)(it->second); j++)
Choose[i] = (Choose[i] * it->first) % P;
}
}
}
int main() {
int tmp;
scanf("%d%d%d", &N, &M, &tmp);
P = tmp;
pre_process();
int row, color, T = 0, UT, len = -1, bef;
long long next = 1;
for (row = 0; row < (int)(N); row++) {
bef = len;
scanf("%d", &len);
UT = T;
T = !T;
long long all = next;
next = 0;
for (color = 1; color <= min(M, len); color++) {
long long minus = 0;
if (bef != -1 && color <= bef) {
minus = DP[UT][color];
}
DP[T][color] = ((all - minus + P) * Base[len][color]) % P;
add(next, Choose[color] * DP[T][color]);
}
}
long long res = 0;
for (color = 1; color <= min(M, len); color++) {
add(res, Choose[color] * DP[T][color]);
}
cout << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, i, temp;
cin >> n;
vector<long long> v(100001);
for (i = 0; i < n; i++) {
cin >> temp;
v[temp]++;
}
long long dp[100001] = {0};
dp[1] = v[1];
for (i = 2; i < 100001; i++) {
dp[i] = max(dp[i - 1], dp[i - 2] + i * v[i]);
}
cout << dp[100000];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2020;
set<pair<int, int> > s;
map<int, int> mp;
int n, m;
int fi[maxn], se[maxn];
int power[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n + n; i++) {
cin >> power[i];
s.insert(make_pair(-power[i], i));
mp[i] = -1;
}
for (int i = 0; i < m; i++) {
cin >> fi[i] >> se[i], fi[i]--, se[i]--;
mp[fi[i]] = i;
mp[se[i]] = i;
}
int turn;
cin >> turn;
if (turn == 1) {
int ptr = 0;
for (int i = 0; i < n; i++) {
if (ptr < m) {
if (power[fi[ptr]] < power[se[ptr]]) swap(fi[ptr], se[ptr]);
cout << fi[ptr] + 1 << endl;
s.erase(make_pair(-power[fi[ptr]], fi[ptr]));
int tmp;
cin >> tmp, tmp--;
s.erase(make_pair(-power[tmp], tmp));
ptr++;
} else {
int id = s.begin()->second;
cout << id + 1 << endl;
s.erase(s.begin());
int tmp;
cin >> tmp, tmp--;
s.erase(make_pair(-power[tmp], tmp));
}
}
} else {
int ptr = 0;
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp, tmp--;
s.erase(make_pair(-power[tmp], tmp));
if (mp[tmp] != -1) {
int qid = mp[tmp];
int id = fi[qid] ^ se[qid] ^ tmp;
if (s.find(make_pair(-power[id], id)) != s.end()) {
cout << id + 1 << endl;
s.erase(make_pair(-power[id], id));
continue;
}
}
while (ptr < m and s.find(make_pair(-power[fi[ptr]], fi[ptr])) == s.end())
ptr++;
if (ptr < m) {
if (power[fi[ptr]] < power[se[ptr]]) swap(fi[ptr], se[ptr]);
cout << fi[ptr] + 1 << endl;
s.erase(make_pair(-power[fi[ptr]], fi[ptr]));
ptr++;
} else {
int id = s.begin()->second;
cout << id + 1 << endl;
s.erase(s.begin());
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_SIZE = 1e4 + 4;
vector<pair<long long, long long>> arr(MAX_SIZE);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T, n, m, sz, x, y;
string str;
cin >> T;
for (long long t = 1; t <= T; ++t) {
cin >> n >> m;
sz = 0;
for (long long i = 0; i < n; ++i) {
cin >> str;
for (long long j = 0; j < m; ++j) {
if (str[j] == '1') {
arr[sz++] = {i, j};
}
}
}
cout << (3 * sz) << endl;
for (long long i = 0; i < sz; ++i) {
x = arr[i].first + 1;
y = arr[i].second + 1;
if (x == n && y == m) {
cout << x << " " << y << " " << x << " " << y - 1 << " " << x - 1 << " "
<< y << endl;
cout << x << " " << y << " " << x << " " << y - 1 << " " << x - 1 << " "
<< y - 1 << endl;
cout << x << " " << y << " " << x - 1 << " " << y << " " << x - 1 << " "
<< y - 1 << endl;
} else if (x == n) {
cout << x << " " << y << " " << x - 1 << " " << y << " " << x << " "
<< y + 1 << endl;
cout << x << " " << y << " " << x - 1 << " " << y << " " << x - 1 << " "
<< y + 1 << endl;
cout << x << " " << y << " " << x << " " << y + 1 << " " << x - 1 << " "
<< y + 1 << endl;
} else if (y == m) {
cout << x << " " << y << " " << x << " " << y - 1 << " " << x + 1 << " "
<< y << endl;
cout << x << " " << y << " " << x << " " << y - 1 << " " << x + 1 << " "
<< y - 1 << endl;
cout << x << " " << y << " " << x + 1 << " " << y << " " << x + 1 << " "
<< y - 1 << endl;
} else {
cout << x << " " << y << " " << x << " " << y + 1 << " " << x + 1 << " "
<< y << endl;
cout << x << " " << y << " " << x << " " << y + 1 << " " << x + 1 << " "
<< y + 1 << endl;
cout << x << " " << y << " " << x + 1 << " " << y << " " << x + 1 << " "
<< y + 1 << endl;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline bool ascending(int i, int j) { return (i < j); }
inline bool descending(int i, int j) { return (i > j); }
const int MN = 1000 + 51;
int arr[1001];
int res;
int n, k, m;
void update(int t) {
int temp = t;
for (int i = 1; i <= m; ++i) {
swap(arr[i], temp);
if (t == temp) {
res += i;
break;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> m;
for (int i = 0; i < m; ++i) {
int temp;
cin >> temp;
arr[i + 1] = temp;
}
for (__typeof(0) i = 0; i != n; i++)
for (__typeof(0) j = 0; j != k; j++) {
int t;
cin >> t;
update(t);
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, diff[5001] = {}, a[5001], b[5001], t[5000], l[5000], r[5000],
dm[5000];
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) a[i] = 1000000000;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d%d", t + i, l + i, r + i, dm + i);
for (int j = l[i]; j <= r[i]; ++j)
if (t[i] == 1)
diff[j] += dm[i];
else
a[j] = min(a[j], dm[i] - diff[j]);
}
for (int i = 1; i <= n; ++i) b[i] = a[i];
for (int i = 0; i < m; ++i) {
if (t[i] == 1)
for (int j = l[i]; j <= r[i]; ++j) a[j] += dm[i];
else if (*max_element(a + l[i], a + r[i] + 1) != dm[i]) {
printf("NO\n");
return 0;
}
}
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d ", b[i]);
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1E5 + 7;
int a[N], k, n;
void gao(int l, int r) {
if (k == 0 || l + 1 == r) {
sort(a + l, a + r);
return;
}
int mid = (l + r) / 2;
k -= 2;
gao(l, mid);
gao(mid, r);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) a[i] = n - i;
k--;
gao(0, n);
if (k == 0) {
for (int i = 0; i < n; i++) printf("%d ", a[i]);
} else
puts("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
bool ok(long long t) {
long long res = 0;
for (int i = 1; i <= min(n, m); i++) {
if (t / i <= max(n, m))
res += (t / i);
else
res += max(n, m);
if (!res % i) res--;
if (!t / i) break;
}
return res + 1 <= k;
}
int main(int argc, char** argv) {
cin >> n >> m >> k;
long long l = 0, r = n * (m + 2), mid, ans = 0;
while (r >= l) {
mid = (r + l) / 2;
if (ok(mid)) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
cout << ans + 1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char t[20][20];
int n, m, ans = 0;
bool vld(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) return true;
return false;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> t[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (t[i][j] == 'W') {
if (vld(i - 1, j) && t[i - 1][j] == 'P')
ans++;
else if (vld(i + 1, j) && t[i + 1][j] == 'P')
ans++;
else if (vld(i, j - 1) && t[i][j - 1] == 'P')
ans++;
else if (vld(i, j + 1) && t[i][j + 1] == 'P')
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
char ch[2][2001000];
int main() {
int n;
while (~scanf("%d", &n)) {
scanf("%s%s", ch[0], ch[1]);
int a = 0, b = 0, cnt = 0;
for (int i = 0; i < 2 * n; i++) {
if (ch[0][i] == '1' && ch[1][i] == '1')
cnt++;
else if (ch[0][i] == '1')
a++;
else if (ch[1][i] == '1')
b++;
}
cnt %= 2;
a += cnt;
if (b - 1 == a) {
b--;
}
if (a > b)
puts("First");
else if (a < b)
puts("Second");
else
puts("Draw");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[100000];
int cnt[20];
bool mask[(1 << 20) | 1];
int main() {
int n, m, d;
scanf("%d %d %d", &n, &m, &d);
for (int i = 0; i < m; i++) {
int s;
scanf("%d", &s);
while (s--) {
int x;
scanf("%d", &x);
arr[x - 1] = i;
}
}
int tmp = (1 << m) - 1;
for (int i = 0; i < d; i++) {
cnt[arr[i]]++;
if (cnt[arr[i]] == 1) tmp ^= (1 << arr[i]);
}
mask[tmp] = true;
for (int i = 1; i + d - 1 < n; i++) {
cnt[arr[i - 1]]--;
if (cnt[arr[i - 1]] == 0) tmp ^= (1 << arr[i - 1]);
cnt[arr[i + d - 1]]++;
if (cnt[arr[i + d - 1]] == 1) tmp ^= (1 << arr[i + d - 1]);
mask[tmp] = true;
}
int ans = m;
for (int i = (1 << m) - 1; i >= 0; i--) {
if (mask[i]) {
for (int j = 0; j < m; j++) {
if (i & (1 << j)) mask[i ^ (1 << j)] = true;
}
} else {
ans = min(ans, __builtin_popcount(i));
}
}
printf("%d", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
void R(int &x) { scanf("%d", &x); }
void R(LL &x) { scanf("%lld", &x); }
void R(double &x) { scanf("%lf", &x); }
template <typename T>
void R(T &t) {
cin >> t;
}
template <typename T>
void R(vector<T> &ar) {
for (auto &it : ar) R(it);
}
template <typename T, typename... Args>
void R(T &t, Args &...args) {
R(t);
R(args...);
}
int n, x, k;
int v[100010];
unordered_map<int, int> m;
int main() {
R(n, x, k);
LL ans = 0;
for (int i = 0; i < int(n); ++i) R(v[i]);
sort(v, v + n);
int t = v[0], cnt = 0;
for (int i = 0; i < int(n); ++i) {
int a = v[i];
if (a == t)
cnt++;
else
cnt = 1, t = a;
int l = a / x;
int r = (a + x - 1) / x;
ans += m[l + 1 - k];
m[r]++;
if (k == (a % x == 0)) ans += cnt;
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
vector<pair<int, int> > opt;
int n;
cin >> n;
map<pair<int, int>, int> stage;
pair<int, int> current = pair<int, int>(0, 0);
stage[current] = 0;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
if (c == 'L') {
current.first++;
} else if (c == 'R') {
current.first--;
} else if (c == 'U') {
current.second++;
} else {
current.second--;
}
if (stage.find(current) != stage.end())
opt.push_back({stage[current] + 1, i});
stage[current] = i;
}
long long _min = INT_MAX;
pair<int, int> ans;
for (pair<int, int> p : opt) {
int diff = abs(p.first - p.second);
if (diff < _min) {
_min = diff;
ans = p;
}
}
if (opt.size())
cout << min(ans.first, ans.second) << " " << max(ans.first, ans.second)
<< endl;
else
cout << -1 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, L, s, t;
vector<vector<int>> adjList;
map<pair<int, int>, long long> edges;
set<pair<int, int>> S;
long long dijkstra() {
vector<long long> dist(n, -1);
vector<int> prev(n, -1);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
Q;
Q.emplace(0, s);
dist[s] = 0;
while (!Q.empty()) {
pair<long long, long long> curr = Q.top();
Q.pop();
int node = curr.second;
long long curr_dist = curr.first;
if (curr_dist != dist[node]) continue;
for (int next : adjList[node]) {
int edge_val = edges[make_pair(min(node, next), max(node, next))];
if (dist[next] == -1 or curr_dist + edge_val < dist[next]) {
dist[next] = curr_dist + edge_val;
Q.emplace(curr_dist + edge_val, next);
prev[next] = node;
}
}
}
if (dist[t] == -1 or dist[t] > L) return -1;
if (dist[t] == L) return 0;
vector<pair<long long, long long>> path;
int curr = t;
while (prev[curr] != -1) {
pair<int, int> temp =
make_pair(min(curr, prev[curr]), max(curr, prev[curr]));
if (S.count(temp)) path.push_back(temp);
curr = prev[curr];
}
if (path.size() == 0) return -1;
int val = L - dist[t];
for (pair<long long, long long> temp : path) {
edges[temp] += val;
break;
}
set<pair<long long, long long>> not_S(path.begin(), path.end());
for (pair<long long, long long> curr : S) {
if (!not_S.count(curr)) edges[curr] = 1e10;
}
return dist[t];
}
int main() {
cin >> n >> m >> L >> s >> t;
adjList.resize(n);
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
pair<int, int> temp = make_pair(min(u, v), max(u, v));
if (w == 0) {
S.insert(temp);
w++;
}
edges[temp] = w;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
while (true) {
long long length = dijkstra();
if (length == -1) {
cout << "NO" << endl;
return 0;
}
if (length == 0) break;
}
cout << "YES" << endl;
for (auto x : edges)
cout << x.first.first << " " << x.first.second << " " << x.second << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7, M = 2 * N;
int edge[M], succ[M], ver[N], idx, ID[M];
int d[N], all, have, fa[N], vis[N];
vector<int> ans;
void add(int u, int v, int id) {
edge[idx] = v;
succ[idx] = ver[u];
ID[idx] = id;
ver[u] = idx++;
}
void dfs1(int u) {
vis[u] = 1;
if (d[u] == -1)
have = u;
else if (d[u] == 1)
++all;
for (int i = ver[u]; ~i; i = succ[i]) {
int v = edge[i];
if (vis[v]) continue;
fa[v] = u;
dfs1(v);
}
}
void dfs2(int u) {
for (int i = ver[u]; ~i; i = succ[i]) {
int v = edge[i];
if (fa[v] == u) {
dfs2(v);
if (d[v] == 1) ans.push_back(ID[i]), d[u] ^= 1;
}
}
}
int main() {
memset(ver, -1, sizeof ver);
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &d[i]);
set<pair<int, int> > st;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
if (u > v) swap(u, v);
if (st.count({u, v})) continue;
st.insert({u, v});
add(u, v, i), add(v, u, i);
}
dfs1(1);
if (all & 1) {
if (!have) return puts("-1"), 0;
d[have] = 1;
}
for (int i = 1; i <= n; ++i)
if (d[i] == -1) d[i] = 0;
dfs2(1);
printf("%d\n", (int)ans.size());
for (auto& v : ans) printf("%d\n", v);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int a[n], b[n];
long long int sum = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++) {
sum += a[i];
}
sort(b, b + n, greater<int>());
long long int rem = 0;
rem = b[0] + b[1];
if (rem >= sum)
cout << "YES\n";
else
cout << "NO\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
int a[N], c[N];
struct o_O {
int max, lazy;
} f[N * 4];
void pushdown(int x) {
if (f[x].max == -1) return;
f[x * 2].max += f[x].lazy;
f[x * 2 + 1].max += f[x].lazy;
f[x * 2].lazy += f[x].lazy;
f[x * 2 + 1].lazy += f[x].lazy;
f[x].lazy = 0;
}
int query(int x, int l, int r, int left, int right) {
if (l > right || r < left) return 0;
if (left <= l && right >= r) return f[x].max;
pushdown(x);
return max(query(x * 2, l, (l + r) / 2, left, right),
query(x * 2 + 1, (l + r) / 2 + 1, r, left, right));
}
void update(int x, int l, int r, int left, int right) {
if (l > right || r < left) return;
if (left <= l && right >= r) {
if (f[x].max != -1) {
f[x].max += 1;
f[x].lazy += 1;
}
return;
}
pushdown(x);
update(x * 2, l, (l + r) / 2, left, right);
update(x * 2 + 1, (l + r) / 2 + 1, r, left, right);
f[x].max = max(f[x * 2].max, f[x * 2 + 1].max);
}
void update0(int x, int l, int r, int index) {
if (l > index || r < index) return;
if (l == r) {
f[x].max = -1;
return;
}
pushdown(x);
update0(x * 2, l, (l + r) / 2, index);
update0(x * 2 + 1, (l + r) / 2 + 1, r, index);
f[x].max = max(f[x * 2].max, f[x * 2 + 1].max);
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int l = 0, r = 0;
c[0] = 0;
for (int i = 1; i <= n; i++) {
while (r > l && a[i] > a[c[r]]) r--;
update(1, 1, n, c[r] + 1, i);
c[++r] = i;
if (i >= k) {
printf("%d ", query(1, 1, n, i - k + 1, i));
update0(1, 1, n, i - k + 1);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int k, x, n, m;
string make(int ac, int st, int en, int len) {
string ret = "";
if (st) ret += 'C';
for (int i = 0; i < ac; i++) {
ret += 'A';
ret += 'C';
}
while (ret.size() < len - en) ret += 'B';
if (en) ret += 'A';
return ret;
}
int cnt[55], st[55], en[55];
bool check(int ac1, int ac2, int k1, int k2, int k3, int k4) {
cnt[0] = ac1;
st[0] = k1;
en[0] = k2;
cnt[1] = ac2;
st[1] = k3;
en[1] = k4;
for (int i = 2; i < k; i++) {
cnt[i] = cnt[i - 2] + cnt[i - 1];
if (en[i - 2] && st[i - 1]) cnt[i]++;
if (cnt[i] > x) return false;
st[i] = st[i - 2];
en[i] = en[i - 1];
}
return (cnt[k - 1] == x);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> k >> x >> n >> m;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++)
for (int k1 = 0; k1 <= 1; k1++)
for (int k2 = 0; k2 <= 1; k2++)
for (int k3 = 0; k3 <= 1; k3++)
for (int k4 = 0; k4 <= 1; k4++) {
string cur1 = make(i, k1, k2, n);
string cur2 = make(j, k3, k4, m);
if (cur1.size() != n) continue;
if (cur2.size() != m) continue;
if (check(i, j, k1, k2, k3, k4)) {
cout << cur1 << '\n' << cur2 << '\n';
return 0;
}
}
cout << "Happy new year!" << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int INF = (1 << 30) - 1;
const int MAXN = 30;
int n, top;
int tb1[2000010], tb2[2000010];
map<int, pair<int, int> > mp1;
map<int, pair<int, int> >::iterator it;
map<pair<int, int>, int> mp2;
int V[MAXN][3];
void Dfs(int id, int p, int v, int base, int s1, int s2, int s3) {
if (p > top) {
if (id == 0) {
mp1[v] = make_pair(s2 - s1, s3 - s1);
tb1[v] = s1;
} else {
mp2[make_pair(s2 - s1, s3 - s1)] = v;
tb2[v] = s1;
}
return;
}
Dfs(id, p + 1, v, base * 3, s1, s2 + V[p][1], s3 + V[p][2]);
Dfs(id, p + 1, v + base, base * 3, s1 + V[p][0], s2, s3 + V[p][2]);
Dfs(id, p + 1, v + (base << 1), base * 3, s1 + V[p][0], s2 + V[p][1], s3);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
scanf("%d", &V[i][j]);
}
}
if (n == 1) {
if (V[1][1] == 0 && V[1][2] == 0)
printf("MW\n");
else if (V[1][0] == 0 && V[1][2] == 0)
printf("LW\n");
else if (V[1][0] == 0 && V[1][1] == 0)
printf("LM\n");
else
printf("Impossible\n");
return 0;
}
top = n / 2;
Dfs(0, 1, 0, 1, 0, 0, 0);
top = n;
Dfs(1, n / 2 + 1, 0, 1, 0, 0, 0);
int ans = -1, st1, st2;
for (it = mp1.begin(); it != mp1.end(); ++it) {
pair<int, int> cur = (*it).second;
cur.first = -cur.first;
cur.second = -cur.second;
if (mp2.find(cur) == mp2.end()) continue;
int it2 = mp2[cur];
int sum = tb1[(*it).first] + tb2[it2];
if (ans == -1 || sum > ans) {
ans = sum;
st1 = (*it).first;
st2 = it2;
}
}
if (ans == -1)
printf("Impossible\n");
else {
int cnt = n / 2;
while (cnt--) {
int cur = st1 % 3;
if (cur == 0)
printf("MW\n");
else if (cur == 1)
printf("LW\n");
else
printf("LM\n");
st1 /= 3;
}
cnt = n - n / 2;
while (cnt--) {
int cur = st2 % 3;
if (cur == 0)
printf("MW\n");
else if (cur == 1)
printf("LW\n");
else
printf("LM\n");
st2 /= 3;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
int n;
long long a[N];
long long res;
vector<int> answ;
vector<int> g[N];
vector<int> after[N];
void rec(int v) {
answ.push_back(v);
res += a[v];
for (int i = 0; i < (int)after[v].size(); i++) {
int to = after[v][i];
rec(to);
}
}
void dfs(int v, int p) {
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
dfs(to, v);
a[v] += max(a[to], 0ll);
}
if (p == -1 || a[v] >= 0) {
rec(v);
} else {
after[p].push_back(v);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
vector<int> root;
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
if (p == -1) {
root.push_back(i);
} else {
g[p].push_back(i);
}
}
for (int i = 0; i < (int)root.size(); i++) {
dfs(root[i], -1);
}
cout << res << endl;
for (int i = 0; i < n; i++) {
printf("%d ", answ[i]);
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int mod = 998244353;
const int maxn = 4e6 + 17;
int f[maxn], fac[maxn], p[maxn], ifac[maxn], inv[maxn], n, m, ans;
int frac(int a, int b) { return (long long)a * inv[b] % mod; }
int det(int x) { return (x & 1 ? mod - 1 : 1); }
int binom(int n, int m) {
return (long long)fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
int main() {
scanf("%d%d", &n, &m);
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = (long long)fac[i - 1] * i % mod;
ifac[0] = ifac[1] = inv[0] = inv[1] = 1;
for (int i = 2; i <= n + m; ++i) {
inv[i] = ifac[i] = (long long)(mod - mod / i) * ifac[mod % i] % mod;
}
for (int i = 2; i <= n; ++i) ifac[i] = (long long)ifac[i - 1] * ifac[i] % mod;
int prev = 0, T = 0;
for (int i = 1; i <= n + 1; ++i) {
p[i] = (long long)(1 - prev + mod) * frac(m, m + (n - (i - 1))) % mod;
prev = (prev + p[i]) % mod;
T = (T + (long long)i * p[i] % mod) % mod;
}
for (int i = 1; i <= n; ++i) {
f[i] = frac(i + m, i);
}
for (int i = 1; i <= n; ++i)
ans = (ans + (long long)det(i - 1) * f[i] % mod * binom(n, i) % mod) % mod;
printf("%lld", (long long)ans * T % mod);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double pi = acos(-1.0);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n, k;
cin >> n >> k;
string t;
string T;
cin >> t;
T = t;
vector<int> pos;
for (int i = 0; i < t.size(); i++) {
if (t[i] == '1') pos.push_back(i);
}
if (pos.size() == 0) {
for (int i = 0; i < t.size(); i += (k + 1)) {
t[i] = '1';
}
} else {
for (int i = 0; i < pos[0] - k; i += (k + 1)) {
t[i] = '1';
}
for (int i = pos.back() + k + 1; i < t.size(); i += (k + 1)) {
t[i] = '1';
}
}
for (int i = 1; i < pos.size(); i++) {
for (int j = pos[i - 1] + k + 1; j < pos[i] - k; j += (k + 1)) {
t[j] = '1';
}
}
int ans = 0;
for (int i = 0; i < t.size(); i++) {
if (t[i] != T[i]) ans++;
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n], b[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
vector<int> v, x;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (b[i] == a[j]) {
v.push_back(j);
}
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
x.push_back(a[v[i]]);
}
for (int i = 0; i < x.size(); i++) {
cout << x[i] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, m;
cin >> n;
cin >> m;
string s;
cin >> s;
cin.ignore();
long int conteo = 0;
long int indice = 0;
while (indice < n && indice != -1) {
indice = s.find('.', indice);
if (indice == -1) break;
long int j = indice;
for (; j < n && s[j] == '.'; j++) {
}
conteo += j - indice - 1;
indice = j;
}
if (conteo < 0) conteo = 0;
for (int i = 0; i < m; i++) {
long int x;
char c;
cin >> x;
cin >> c;
if (c == '.' && s[x - 1] != '.') {
if (x - 1 > 0) {
if (s[x - 2] == '.') conteo++;
}
if (x - 1 < n - 1) {
if (s[x] == '.') conteo++;
}
}
if (c != '.' && s[x - 1] == '.') {
if (x - 1 > 0) {
if (s[x - 2] == '.') conteo--;
}
if (x - 1 < n - 1) {
if (s[x] == '.') conteo--;
}
}
s[x - 1] = c;
cout << conteo << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int num[203], mark[203];
vector<int> s1, s2;
int cmp(int a, int b) { return a > b; }
int main() {
scanf("%d%d", &n, &k);
mark[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
mark[i] = mark[i - 1] + num[i];
}
int ma = -1000000000;
for (int l = 1; l <= n; l++) {
for (int r = l; r <= n; r++) {
int now = mark[r] - mark[l - 1];
s1.clear();
s2.clear();
for (int i = 1; i < l; i++) s1.push_back(num[i]);
for (int i = r + 1; i <= n; i++) s1.push_back(num[i]);
for (int i = l; i <= r; i++) s2.push_back(num[i]);
sort(s1.begin(), s1.end(), cmp);
sort(s2.begin(), s2.end());
int tmp = 0;
vector<int>::iterator it1, it2;
it1 = s1.begin();
it2 = s2.begin();
for (; it1 != s1.end() && it2 != s2.end() && *it1 > *it2 && tmp < k;
it1++, it2++) {
now = now - *it2 + *it1;
tmp++;
}
ma = max(ma, now);
}
}
printf("%d\n", ma);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> c, b;
vector<vector<int>> g;
vector<int> par;
vector<bool> vis;
vector<vector<int>> dp;
long long cost = 0;
void setp(int i, int p) {
par[i] = p;
for (auto x : g[i]) {
if (x != p) setp(x, i);
}
}
vector<int> dfs(int ptr) {
if (vis[ptr]) {
return dp[ptr];
}
dp[ptr] = {0, 0};
vis[ptr] = true;
if (b[ptr] != c[ptr]) {
dp[ptr][c[ptr]]++;
}
for (auto i : g[ptr]) {
if (i == par[ptr]) continue;
vector<int> t = dfs(i);
dp[ptr][0] += t[0];
dp[ptr][1] += t[1];
}
return dp[ptr];
}
void solve() {
int n, u, v;
cin >> n;
dp.resize(n + 1);
b.resize(n + 1);
c.resize(n + 1);
par.resize(n + 1);
vector<pair<long long, int>> a(n);
vis = vector<bool>(n + 1, false);
int bs = 0, cs = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i - 1].first >> b[i] >> c[i];
a[i - 1].second = i;
bs += b[i];
cs += c[i];
}
if (bs != cs) {
cout << -1 << endl;
return;
}
g.resize(n + 1);
for (int i = 1; i < n; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
setp(1, 0);
sort(a.begin(), a.end());
for (auto x : a) {
if (vis[x.second]) continue;
vector<int> disp = dfs(x.second);
int possible_swaps = min(disp[0], disp[1]);
cost += (2LL * x.first) * possible_swaps;
dp[x.second][0] -= possible_swaps;
dp[x.second][1] -= possible_swaps;
}
cout << cost << endl;
}
int main() {
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int num;
int result = 0;
for (int i = 0; i < n; i++) {
int c = 0;
for (int j = 0; j < 3; j++) {
cin >> num;
if (num == 1) c++;
}
if (c >= 2) result++;
}
cout << result << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int numero;
int lista_Numeros[] = {4, 7, 44, 47, 74, 77, 444,
447, 474, 477, 744, 747, 777};
cin >> numero;
int i = 0;
bool encontroDivisor = false;
while ((i < 13) && (!encontroDivisor)) {
if (numero % lista_Numeros[i] == 0) {
encontroDivisor = true;
}
i++;
}
(encontroDivisor) ? cout << "YES" : cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int m;
cin >> m;
int a[2][m];
for (int j = 0; j < m; j++) {
cin >> a[0][j];
}
for (int j = 0; j < m; j++) {
cin >> a[1][j];
}
int sum1 = 0, sum2 = 0;
for (int j = 1; j < m; j++) {
sum1 += a[0][j];
}
int max, min;
if (sum1 > sum2)
max = sum1;
else
max = sum2;
min = max;
for (int j = 1; j < m; j++) {
sum2 += a[1][j - 1];
sum1 -= a[0][j];
if (sum1 > sum2)
max = sum1;
else
max = sum2;
if (min > max) min = max;
}
cout << min << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int n, d;
int rnk[200010], pts[200010];
int main() {
cin >> n >> d;
for (int i = 0; i < n; i++) {
cin >> rnk[i];
}
for (int i = 0; i < n; i++) {
cin >> pts[i];
}
int ult = 0, a = d - 2, b = 1;
while (a >= 0 && b < n) {
if (rnk[d - 1] + pts[0] >= rnk[a] + pts[b]) {
ult++;
a--;
b++;
} else {
b++;
}
}
cout << d - ult << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int solve(string s) {
int ret = 1989 + (atoi(s.substr(s.length() - 1).c_str()) + 1) % 10;
int pow = 10;
for (int l = s.length() - 2; l >= 4; l--) {
ret += pow;
while (ret % (10 * pow) != atoi(s.substr(l).c_str())) ret += pow;
pow *= 10;
}
return ret;
}
int main() {
int n;
string s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
cout << solve(s) << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int candy[30][maxn], sum[30][maxn], s[maxn];
int cal(int L, int R) {
int power = 0;
while ((1 << power) < R - L + 1) ++power;
if (candy[power][L] != -1) return candy[power][L];
cal(L, (L + R) / 2);
cal((L + R) / 2 + 1, R);
candy[power][L] =
candy[power - 1][L] + candy[power - 1][L + (1 << (power - 1))];
if (sum[power - 1][L] + sum[power - 1][L + (1 << (power - 1))] >= 10)
++candy[power][L];
sum[power][L] =
(sum[power - 1][L] + sum[power - 1][L + (1 << (power - 1))]) % 10;
return candy[power][L];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &s[i]);
memset(candy, -1, sizeof(candy));
memset(sum, -1, sizeof(sum));
copy(s, s + n + 1, sum[0]);
memset(candy[0], 0, sizeof(candy[0]));
int q;
scanf("%d", &q);
while (q--) {
int L, R;
scanf("%d%d", &L, &R);
printf("%d\n", cal(L, R));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2,sse")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long maxn = 1e6;
vector<long long> g[maxn];
vector<long long> cv;
long long dp[maxn];
long long ans = 0;
void dfs(long long x) {
if (g[x].size() == 0) {
dp[x] = 1;
return;
}
dp[x] = 1;
for (long long i = 0; i < g[x].size(); i++) {
long long to = g[x][i];
dfs(to);
dp[x] = max(dp[x], dp[to] + 1);
}
}
bool cmp(long long x, long long y) { return dp[x] < dp[y]; }
void dfs2(long long x) {
cv.push_back(x);
sort(g[x].begin(), g[x].end(), cmp);
for (long long i = 0; i < g[x].size(); i++) {
long long to = g[x][i];
dfs2(to);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long p[n];
p[0] = -1;
for (long long i = 1; i < n; i++) {
long long pr;
cin >> pr;
p[i] = pr;
g[pr].push_back(i);
}
dfs(0);
dfs2(0);
for (long long i = 0; i < n; i++) {
cout << cv[i] << ' ';
}
vector<long long> dst;
stack<long long> st;
st.push(0);
for (long long i = 1; i < n; i++) {
while (st.top() != p[cv[i]]) {
dst.push_back(cv[i]);
st.pop();
}
st.push(cv[i]);
}
cout << '\n' << dst.size() << '\n';
for (long long i = 0; i < dst.size(); i++) cout << dst[i] << ' ';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e8;
int n, m, k, dots = 0, cou = 0;
vector<string> v;
int vis[52][52];
int dx[] = {1, 0, -1, 0};
int dy[] = {0, -1, 0, 1};
int isval(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
void dfs(int x, int y, int frmx, int frmy) {
if (vis[x][y]) {
cout << "Yes";
exit(0);
}
vis[x][y] = 1;
for (int i = 0; i < 4; i++) {
if (isval(x + dx[i], y + dy[i]) && v[x][y] == v[x + dx[i]][y + dy[i]]) {
if ((x + dx[i] == frmx && y + dy[i] == frmy)) continue;
dfs(x + dx[i], y + dy[i], x, y);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, lim, q, p, f = 0, mn = INT_MAX, mx = INT_MIN, j, x, y, t, sum = 0,
val = 0;
cin >> n >> m;
v.resize(n);
for (i = 0; i < n; i++) cin >> v[i];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (!vis[i][j]) dfs(i, j, -1, -1);
}
}
cout << "No";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
int n, k, m, c, vas, vvas, cc = 1000000, kl;
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
vector<vector<int>> la(n, vector<int>(0));
vector<perem> pr(k);
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
int a = la[i][0];
bool d = s[i] == '1' ? 1 : 0;
for (;; a = pr[a].p) {
d ^= pr[a].q;
if (pr[a].p == -1) break;
}
if (la[i].size() == 1) {
if (!d) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
int b = la[i][1];
for (;; b = pr[b].p) {
d ^= pr[b].q;
if (pr[b].p == -1) break;
}
if (a != b) {
if (!d) {
if (pr[a].l > pr[b].l) swap(a, b);
vas += pr[a].l;
pr[a].q ^= 1;
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
cout << vvas + vas << endl;
vvas += vas;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int lim = 1e6;
string cad;
int cubeta[lim];
void voltea(int pos) {
int lon = cad.length();
for (int i = pos; i < lon / 2; i++) {
char temp = cad[lon - i - 1];
cad[lon - i - 1] = cad[i];
cad[i] = temp;
if (cubeta[i + 1]) break;
}
}
void metodo() {
int aux = 1;
for (int i = 0; i < cad.length() / 2; i++) {
if (cubeta[i] == 1 && aux == 1) {
voltea(i);
aux = 0;
} else if (cubeta[i])
aux = 1;
}
}
int main() {
int n;
cin >> cad >> n;
for (int i = 0; i < n; i++) {
int aux, cont = 0;
cin >> aux;
if (cubeta[aux - 1] == 0)
cubeta[aux - 1] = 1;
else
cubeta[aux - 1] = 0;
}
metodo();
cout << cad << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void upmin(T &x, T y) {
y < x ? x = y : 0;
}
template <typename T>
inline void upmax(T &x, T y) {
x < y ? x = y : 0;
}
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long OO = 1e18;
int gi() {
int w = 0;
bool q = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 0, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? w : -w;
}
const long long mod = 1e9 + 7;
const long long inv2 = (mod + 1) >> 1;
const long long inv3 = mod - (mod / 3) * (mod % 3 == 1 ? 1 : inv2) % mod;
struct DT {
long long a[4];
int d;
};
inline DT operator+(const DT &a, const DT &b) {
DT ans = {};
ans.d = max(a.d, b.d);
for (int i = 0; i <= ans.d; i++) ans.a[i] = (a.a[i] + b.a[i]) % mod;
return ans;
}
inline DT operator*(const DT &a, const DT &b) {
DT ans = {};
ans.d = a.d + b.d;
for (int i = 0; i <= a.d; i++)
for (int j = 0; j <= b.d; j++)
ans.a[i + j] = (ans.a[i + j] + a.a[i] * b.a[j]) % mod;
return ans;
}
int main() {
long long n, ans = 0, i, k, m, N, pi;
cin >> n;
m = sqrt(n);
N = n % mod;
DT t;
const long long A =
((N + 1) * N % mod * (N + 1) % mod * inv2 -
N * (N + 1) % mod * (N * 2 + 1) % mod * inv2 % mod * inv3) %
mod;
t.d = 1;
t.a[1] = t.a[2] = t.a[3] = 0;
t.a[0] = A;
t.a[0] = t.a[0] * (m * 2 + 1) % mod;
for (k = 0; k <= m; k++) {
DT p1 = {}, p2 = {}, p3 = {}, p4 = {};
p1.d = 0;
p1.a[0] = N + 1;
p2.d = 1;
p2.a[1] = 1;
p2.a[0] = k * k % mod;
p3 = p2;
p3.a[0]++;
p4 = p2 + p3;
DT cur;
p1.a[0] = -p1.a[0] * (k ? 1 : inv2) % mod;
cur = p1 * p2 * p3;
t = t + cur;
p1.a[0] = (k ? 1 : inv2) * inv3 % mod;
cur = p1 * p2 * p3 * p4;
t = t + cur;
}
for (i = 0; i * i <= n; i++) {
while (i * i + m * m > n) {
k = m--;
t.a[0] = (t.a[0] - A * 2) % mod;
DT p1 = {}, p2 = {}, p3 = {}, p4 = {};
p1.d = 0;
p1.a[0] = N + 1;
p2.d = 1;
p2.a[1] = 1;
p2.a[0] = k * k % mod;
p3 = p2;
p3.a[0]++;
p4 = p2 + p3;
DT cur;
p1.a[0] = p1.a[0] * (k ? 1 : inv2) % mod;
cur = p1 * p2 * p3;
t = t + cur;
p1.a[0] = -(k ? 1 : inv2) * inv3 % mod;
cur = p1 * p2 * p3 * p4;
t = t + cur;
}
for (k = 0, pi = 1 + (i > 0); k <= t.d; k++) {
ans = (ans + pi * t.a[k]) % mod;
pi = (i * i - 1) % mod * pi % mod;
}
}
cout << (ans + mod) % mod << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
if (n > 26) {
cout << -1 << endl;
return 0;
}
set<char> st;
for (int i = 0; i < n; i++) {
st.insert(s[i]);
}
cout << n - st.size();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int a[1000000];
long long int ans = 0;
int n;
bool visited[1000000];
int dfs_cnt(int ind, vector<vector<pair<int, long long int> > > &gph) {
visited[ind] = true;
int cnt = 1;
for (int i = 0; i < gph[ind].size(); i++) {
pair<int, long long int> x = gph[ind][i];
if (!visited[x.first]) {
cnt += dfs_cnt(x.first, gph);
}
}
return cnt;
}
int count_del(int ind, vector<vector<pair<int, long long int> > > &gph) {
return dfs_cnt(ind, gph);
}
void dfs(int ind, vector<vector<pair<int, long long int> > > &gph,
long long int sum, long long int minm) {
if (ind < 0 || ind >= n) return;
if (sum - minm > a[ind]) {
ans += count_del(ind, gph);
return;
}
visited[ind] = true;
for (int i = 0; i < gph[ind].size(); i++) {
pair<int, long long int> x = gph[ind][i];
if (visited[x.first] == false) {
dfs(x.first, gph, sum + x.second, min(sum, minm));
}
}
return;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
vector<vector<pair<int, long long int> > > gph;
memset(visited, false, 1000000);
for (int i = 0; i < n; i++)
gph.push_back(vector<pair<int, long long int> >());
for (int i = 0; i < n - 1; i++) {
long long int x, y;
cin >> x >> y;
x--;
gph[i + 1].push_back(make_pair(x, y));
gph[x].push_back(make_pair(i + 1, y));
}
dfs(0, gph, 0, 0);
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int remove0(int n) {
int m(0), pow(1);
while (n != 0) {
int d = n % 10;
n /= 10;
if (d != 0) {
m += d * pow;
pow *= 10;
}
}
return m;
}
int main() {
int a, b;
cin >> a >> b;
int c = a + b;
int A = remove0(a);
int B = remove0(b);
int C = remove0(c);
cout << (A + B == C ? "YES" : "NO") << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
int n, m, a[MAXN], b[MAXN];
int main() {
int cnt = 0, maxAns = 0, minAns = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(a, a + m);
sort(b, b + m);
while (cnt < n) {
maxAns += a[m - 1];
a[m - 1]--;
cnt++;
sort(a, a + m);
}
cnt = 0;
while (cnt < n) {
for (int i = 0; i < m; i++) {
if (cnt >= n) break;
if (b[i] <= 0) continue;
minAns += b[i];
b[i]--;
cnt++;
break;
}
}
cout << maxAns << " " << minAns << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize "Ofast"
#pragma GCC optimize "unroll-loops"
#pragma GCC target "sse,sse2,sse3,sse4,abm,avx,mmx,popcnt,tune=native"
char _;
using namespace std;
int n, r, z, g;
long long tot;
int c[300000];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> r;
for (int i = 0; i < (1 << n); i++) {
cin >> c[i];
tot += c[i];
}
cout << fixed << setprecision(10) << (1.0 * tot / (1 << n)) << "\n";
for (int i = 0; i < r; i++) {
cin >> z >> g;
tot += g - c[z];
c[z] = g;
cout << fixed << setprecision(10) << (1.0 * tot / (1 << n)) << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct pt {
int x, y;
pt(int xx = 0, int yy = 0) : x(xx), y(yy) {}
};
pt operator-(pt a, pt b) { return pt(a.x - b.x, a.y - b.y); }
bool operator<(const pt &a, const pt &b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
long long cross(pt a, pt b) { return (a.x + 0ll) * b.y - (a.y + 0ll) * b.x; }
int sta[maxn << 1], top;
pt p[maxn];
void convex(int n) {
top = 0;
sort(p + 1, p + 1 + n);
int i, j;
for (i = 1; i <= n; i++) {
while (top >= 2 &&
cross(p[i] - p[sta[top]], p[sta[top]] - p[sta[top - 1]]) >= 0)
top--;
sta[++top] = i;
}
j = top;
for (i = n - 1; i >= 1; i--) {
while (top > j &&
cross(p[i] - p[sta[top]], p[sta[top]] - p[sta[top - 1]]) >= 0)
top--;
sta[++top] = i;
}
top--;
}
double ans = 0;
int shang[2000010], xia[2000010];
double solve(int n) {
convex(n);
int s, x, i, j;
int mi = 210000000, ma = 0;
for (i = 1; i <= top; i++) {
if (p[sta[i]].x == p[sta[i + 1]].x) {
s = max(p[sta[i]].y, p[sta[i + 1]].y);
x = min(p[sta[i]].y, p[sta[i + 1]].y);
shang[p[sta[i]].x] = s;
xia[p[sta[i]].x] = x;
} else if (p[sta[i]].x < p[sta[i + 1]].x) {
j = p[sta[i]].x;
x = p[sta[i]].y;
do {
xia[j] = x;
j++;
while (cross(pt(j, x) - p[sta[i]], p[sta[i + 1]] - p[sta[i]]) > 0) x++;
while (cross(pt(j, x - 1) - p[sta[i]], p[sta[i + 1]] - p[sta[i]]) <= 0)
x--;
} while (j <= p[sta[i + 1]].x);
} else {
j = p[sta[i]].x;
x = p[sta[i]].y;
do {
shang[j] = x;
j--;
while (cross(pt(j, x) - p[sta[i]], p[sta[i + 1]] - p[sta[i]]) > 0) x--;
while (cross(pt(j, x + 1) - p[sta[i]], p[sta[i + 1]] - p[sta[i]]) <= 0)
x++;
} while (j >= p[sta[i + 1]].x);
}
mi = min(mi, p[sta[i]].x);
ma = max(ma, p[sta[i]].x);
}
long long tot = 0, ss = 0, tmp;
for (i = mi; i <= ma; i++)
tot += shang[i] - xia[i] + 1, ss += (shang[i] - xia[i] + 1ll) * i;
for (i = mi; i <= ma; i++) {
ans += (shang[i] - xia[i] + 1ll) * i / (tot - 1.0) *
((tot * i - ss) / (tot + 0.0));
}
return ans;
}
int main() {
int n;
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%d%d", &p[i].x, &p[i].y), p[i].x += 1000000, p[i].y += 1000000;
solve(n);
for (i = 1; i <= n; i++) swap(p[i].x, p[i].y);
solve(n);
printf("%.12lf\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, br1, br2, br3, tr, a[105];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n && a[i] == i; i++) br1++;
for (int i = n - 1; i >= 0 && a[i] == 1000 - (n - i); i--) br2++;
for (int i = br1 + 2; i < n - br2; i++) {
if (a[i - 1] + 1 == a[i] && a[i + 1] - 1 == a[i])
tr++;
else
br3 = max(br3, tr), tr = 0;
}
br3 = max(br3, tr);
cout << max(max(br1, br2), br3);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000005;
long long n, f[N], gs, ans;
inline long long read() {
long long ret = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) {
ret = ret * 10 + (ch ^ 48);
ch = getchar();
}
return ret * ff;
}
void write(long long x) {
if (x < 0) {
x = -x, putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
void writeln(long long x) { write(x), puts(""); }
void writesp(long long x) { write(x), putchar(' '); }
signed main() {
n = read();
for (long long i = 1; i <= n; i++) {
long long x = read();
if (x == 1) gs++;
}
f[0] = f[1] = ans = 1;
for (long long i = 2; i <= gs; i++)
f[i] = (f[i - 1] + f[i - 2] * (i - 1)) % 1000000007;
for (long long i = n; i > gs; i--) ans = ans * i % 1000000007;
write(ans * f[gs] % 1000000007);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, last;
int nxt[50505 * 11 * 2][26], link[50505 * 11 * 2], dp[50505 * 11 * 2],
cnt[50505 * 11 * 2], ord[50505 * 11 * 2], occur[50505 * 11 * 2][11];
char s[11][50505];
int l[11], r[11];
void extend(int c) {
if (nxt[last][c] && dp[nxt[last][c]] == dp[last] + 1) {
last = nxt[last][c];
return;
}
int x = last, y = last = ++m;
dp[y] = dp[x] + 1;
while (x && !nxt[x][c]) nxt[x][c] = y, x = link[x];
if (!x)
link[y] = 1;
else {
int z = nxt[x][c];
if (dp[z] == dp[x] + 1)
link[y] = z;
else {
int u = ++m;
memcpy(nxt[u], nxt[z], sizeof nxt[u]);
link[u] = link[z], link[z] = link[y] = u;
dp[u] = dp[x] + 1;
while (x && nxt[x][c] == z) nxt[x][c] = u, x = link[x];
}
}
}
int main() {
scanf("%s", s[0]);
last = ++m;
for (int j = 0, len = strlen(s[0]); j < len; j++)
extend(s[0][j] - 'a'), occur[last][0]++;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s %d %d", s[i], &l[i], &r[i]);
last = 1;
for (int j = 0, len = strlen(s[i]); j < len; j++)
extend(s[i][j] - 'a'), occur[last][i]++;
}
for (int i = 1; i <= m; i++) cnt[dp[i]]++;
for (int i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
for (int i = 1; i <= m; i++) ord[cnt[dp[i]]--] = i;
for (int i = m; i >= 1; i--) {
int x = ord[i];
for (int j = 0; j <= n; j++) occur[link[x]][j] += occur[x][j];
}
long long ans = 0;
for (int i = 1; i <= m; i++)
if (occur[i][0]) {
bool ok = 1;
for (int j = 1; j <= n; j++) {
if (occur[i][j] < l[j] || occur[i][j] > r[j]) {
ok = 0;
break;
}
}
if (ok) ans += dp[i] - dp[link[i]];
}
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long DP[1007];
long long sum[1007];
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
DP[i] = (1000000007 + sum[i - 1] - sum[x - 1] + 2) % 1000000007;
sum[i] = (sum[i - 1] + DP[i]) % 1000000007;
ans += DP[i];
ans %= 1000000007;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:247474112")
#pragma GCC optimize("Ofast")
using namespace std;
long long t, n, k, ans;
long long sqr(long long x) { return (x * x); }
long long pow2(long long x) {
if (x == 0) return 1;
long long tmp = pow2(x / 2);
if (x % 2 == 0) return (tmp * tmp);
return (tmp * tmp * 2);
}
long long minimumMoves(long long x) {
long long dist = n - x, res = 0, Mul = 1;
if (dist > 61) return 4000000000000000000LL;
for (long long i = 1; i <= dist; i++) {
res += Mul;
Mul *= 2;
Mul++;
}
return res;
}
long long maximumMoves(long long x) {
if (x > 32) return 8000000000000000000LL;
long long res = minimumMoves(x);
long long dist = n - x, Mul = 1;
if (dist > 32) return (8000000000000000000LL);
for (long long i = 0; i < dist; i++) {
res += sqr(pow2(i) - 1);
}
long long cnt = sqr(pow2(n - x) - 1);
for (long long i = x; i > 0; i--) {
res += cnt;
if (1000000000000000000LL <= cnt)
cnt = 4000000000000000000LL;
else
cnt *= 4;
if (res > 4000000000000000000LL) return 8000000000000000000LL;
}
return res;
}
void binsearch() {
long long top = max(0LL, n - 61), bot = n;
for (long long mid = top; mid <= bot; mid++) {
long long Min = minimumMoves(mid);
long long Max = maximumMoves(mid);
if (Min <= k && k <= Max) {
ans = mid;
return;
}
}
}
void Input() { cin >> t; }
void Solve() {
while (t--) {
cin >> n >> k;
ans = -1;
binsearch();
if (ans == -1)
cout << "NO\n";
else
cout << "YES " << ans << endl;
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
Input();
Solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[2100][2100];
int d[2100][2100][2];
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int sx, sy;
cin >> sx >> sy;
int l, r;
cin >> l >> r;
queue<pair<pair<int, int>, int> > q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
d[i][j][0] = d[i][j][1] = 1e9;
}
}
d[sx][sy][0] = d[sx][sy][1] = 0;
q.push({{sx, sy}, 0});
q.push({{sx, sy}, 1});
while (!q.empty()) {
int x = q.front().first.first, y = q.front().first.second,
type = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx < 1 || yy < 1 || xx > n || yy > m || a[xx][yy] == '*') continue;
int pls = 0;
if (i == 0 && type == 0) pls = 1;
if (i == 2 && type == 1) pls = 1;
if (d[x][y][type] + pls < d[xx][yy][type]) {
d[xx][yy][type] = d[x][y][type] + pls;
q.push({{xx, yy}, type});
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (d[i][j][0] == 1e9 || d[i][j][1] == 1e9) continue;
if (d[i][j][1] <= l && d[i][j][0] <= r) {
++ans;
}
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
std::vector<char> one_way, two_way;
static long long goint(std::vector<std::vector<char>>& board,
std::vector<std::vector<char>>& layout) {
long long ret = 0;
for (long long i = 0; i < board.size(); ++i) {
for (long long j = 0; j < board[i].size(); ++j) {
ret += board[i][j] != layout[i % 2][j];
}
}
return ret;
}
static long long go(std::vector<std::vector<char>>& board) {
std::vector<std::vector<char>> option = {one_way, two_way};
long long a = goint(board, option);
std::reverse(option.begin(), option.end());
long long b = goint(board, option);
return std::min(a, b);
}
int main(void) {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
long long n;
std::cin >> n;
std::vector<std::vector<std::string>> boards(4, std::vector<std::string>(n));
for (auto& board : boards) {
for (auto& row : board) std::cin >> row;
}
one_way.resize(2 * n);
two_way.resize(2 * n);
char start = '1';
for (long long i = 0; i < one_way.size(); ++i) {
one_way[i] = start;
start = start == '1' ? '0' : '1';
two_way[i] = start;
}
std::vector<long long> perm = {0, 1, 2, 3};
long long ret = 4 * n * n;
do {
std::vector<std::vector<char>> one_board(2 * n, std::vector<char>(2 * n));
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < n; ++j) one_board[i][j] = boards[perm[0]][i][j];
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < n; ++j)
one_board[i][j + n] = boards[perm[1]][i][j];
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < n; ++j)
one_board[i + n][j] = boards[perm[2]][i][j];
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < n; ++j)
one_board[i + n][j + n] = boards[perm[3]][i][j];
long long va = go(one_board);
ret = std::min(ret, va);
} while (std::next_permutation(perm.begin(), perm.end()));
std::cout << ret << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, c = 0;
cin >> n;
n++;
c = 1 + 6 * (0.5 * n * (n - 1));
cout << c << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double vp, vd, t, f, c;
cin >> vp >> vd >> t >> f >> c;
if (vd <= vp) return cout << 0 << '\n', 0;
double tt = (vd * t) / (vd - vp);
double S = vp * tt;
double T = tt - t;
long long ans = 0;
while (S - c < .0) {
ans++;
t = tt + T + f;
tt = (vd * t) / (vd - vp);
S = vp * tt;
T = tt - t;
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, K;
cin >> N >> M >> K;
vector<int> name(N);
unordered_set<int> S;
for (int i = 0; i < K; i++) {
int temp;
cin >> temp;
name[i] = temp;
S.insert(temp);
}
int currName = 1;
for (int i = K; i < N; i++) {
while (S.count(currName)) currName++;
name[i] = currName++;
}
if (K == N) {
cout << -1 << endl;
return 0;
}
vector<pair<int, int> > edges;
for (int i = 0; i < N; i++) {
if (i != K) edges.emplace_back(i, K);
}
for (int i = K + 1; i < N; i++) {
for (int j = 0; j < K; j++) {
edges.emplace_back(j, i);
}
}
for (int i = K + 1; i < N; i++) {
for (int j = i + 1; j < N; j++) {
edges.emplace_back(i, j);
}
}
if (K >= 2) {
int X = (K - 2) / 2 + 2;
for (int i = 2; i < X; i++) edges.emplace_back(0, i);
for (int i = X; i < K; i++) edges.emplace_back(1, i);
for (int i = 2; i < K; i++) {
for (int j = i + 1; j < K; j++) {
edges.emplace_back(i, j);
}
}
}
if (edges.size() < M) {
cout << -1 << endl;
return 0;
}
int count = 0;
for (pair<int, int> X : edges) {
cout << name[X.first] << " " << name[X.second] << endl;
count++;
if (count == M) break;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[60];
int i, t;
cin >> s;
t = strlen(s);
if (s[0] == 'h') {
cout << "http://";
i = 4;
} else if (s[0] == 'f') {
cout << "ftp://";
i = 3;
}
cout << s[i];
for (i += 1; i < t; i++) {
if (s[i] == 'r' && s[i + 1] == 'u') {
cout << ".ru";
break;
}
cout << s[i];
}
if (i + 2 < t) cout << "/" << s + i + 2;
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double d, h, v, e, t, pi = 4 * atan(1);
cin >> d >> h >> v >> e;
t = 4 * v / (pi * d * d);
if (t > e) {
t = h / (t - e);
cout << "YES" << endl;
cout << t;
} else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
const int INF = 1 << 29;
const long long mod = 1e9 + 7;
const long long MAXN = 1000050;
int a[12345], l[5011], r[5011];
long long dp[2][10200];
int main() {
int n, tol = 0, star;
cin >> n >> star;
a[tol++] = star;
for (int i = 0; i < n; i++) {
scanf("%d%d", &l[i], &r[i]);
a[tol++] = l[i];
a[tol++] = r[i];
}
sort(a, a + tol);
tol = unique(a, a + tol) - a;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < tol; i++) dp[0][i] = abs(star - a[i]);
int now = 0;
for (int i = 0; i < n; i++) {
int last = now;
now ^= 1;
for (int j = 0; j < tol; j++) {
dp[now][j] = dp[last][j] + (l[i] > a[j] ? l[i] - a[j] : 0) +
(r[i] < a[j] ? a[j] - r[i] : 0);
}
for (int j = 0; j + 1 < tol; j++) {
if (a[j] < l[i] && dp[now][j + 1] > dp[now][j])
dp[now][j + 1] = dp[now][j];
}
for (int j = tol - 1; j >= 1; j--) {
if (a[j] > r[i] && dp[now][j - 1] > dp[now][j])
dp[now][j - 1] = dp[now][j];
}
}
long long ans = dp[now][0];
for (int i = 1; i < tol; i++) ans = min(ans, dp[now][i]);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long get(long long n) { return (n * (n + 1)) / 2; }
void solve() {
long long n, x;
cin >> n >> x;
vector<long long> vec(2 * n), pre(2 * n, 0), sum(2 * n, 0);
for (long long i = 0; i < n; i++) {
cin >> vec[i];
vec[i + n] = vec[i];
}
pre[2 * n - 1] = vec[2 * n - 1];
sum[2 * n - 1] = get(vec[2 * n - 1]);
for (long long i = 2 * n - 1 - 1; i >= 0; i--) {
pre[i] = pre[i + 1] + vec[i];
sum[i] = get(vec[i]) + sum[i + 1];
}
long long ans = 0;
for (long long i = n; i < 2 * n; i++) {
long long l = 0, h = i, temp = -1;
while (l <= h) {
long long m = (l + h) / 2;
long long val = (i + 1 == 2 * n ? pre[m] : pre[m] - pre[i + 1]);
if (val >= x) {
temp = (i + 1 == 2 * n ? sum[m] : sum[m] - sum[i + 1]);
long long tot = get(vec[m]), rem = val - x, chhota = get(rem);
temp -= tot;
temp += tot - chhota;
l = m + 1;
} else
h = m - 1;
}
ans = max(ans, temp);
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{ solve(); }
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a[100010], las[100010], cnt[100010];
void get(int i) {
if (i + a[i] >= n || i / 350 != (i + a[i]) / 350)
las[i] = i, cnt[i] = 0;
else
las[i] = las[i + a[i]], cnt[i] = cnt[i + a[i]] + 1;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = n - 1; i >= 0; --i) get(i);
for (int o, p, v; q--;) {
scanf("%d", &o);
if (o) {
scanf("%d", &p);
--p;
int dwn = 0, s = 0;
for (; p < n; dwn = las[p], p = dwn + a[dwn]) s += cnt[p] + 1;
printf("%d %d\n", dwn + 1, s);
} else {
scanf("%d%d", &p, &v);
--p;
a[p] = v;
for (int i = p; i >= 0 && i / 350 == p / 350; --i) get(i);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
constexpr int MAXN = 5 + 5000;
constexpr int MINF = -(MAXN * MAXN);
int n, m, k;
int a[MAXN], b[MAXN], c[MAXN], g[MAXN], memo[MAXN][MAXN];
vector<int> l[MAXN];
int dp(int idx, int w) {
if (w < a[idx]) return MINF;
if (idx == n) return 0;
int& ans = memo[idx][w];
if (~ans) return ans;
w += b[idx];
ans = dp(1 + idx, w);
int imp = 0;
for (int i = (int)0; i < (int)l[idx].size(); ++i) {
imp += c[l[idx][i]];
ans = max(ans, imp + dp(1 + idx, w - i - 1));
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> k;
for (int i = (int)0; i < (int)n; ++i) {
cin >> a[i] >> b[i] >> c[i];
g[i] = -1;
}
for (int i = (int)0; i < (int)m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[v] = max(g[v], u);
}
for (int i = (int)0; i < (int)n; ++i) {
if (g[i] == -1) {
g[i] = i;
}
l[g[i]].push_back(i);
}
for (int i = (int)0; i < (int)n; ++i) {
sort(l[i].begin(), l[i].end(),
[](const int& p, const int& q) -> bool { return c[p] > c[q]; });
}
memset(memo, -1, sizeof memo);
cout << max(-1, dp(0, k)) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x[1000010];
int ten[1000010];
int ma[1000010];
int mb[1000010];
int a, b;
int main() {
int n = 0;
char c;
cin.get(c);
while (c >= '0' && c <= '9') {
x[n] = c - '0';
n++;
cin.get(c);
}
cin >> a >> b;
ten[0] = 1 % b;
for (int i = 1; i <= n; i++) {
ten[i] = (ten[i - 1] * 10) % b;
}
ma[0] = x[0] % a;
for (int i = 1; i < n; i++) {
ma[i] = (10 * ma[i - 1] + x[i]) % a;
}
mb[n - 1] = x[n - 1] % b;
for (int i = 2; i <= n; i++) {
mb[n - i] = (ten[i - 1] * x[n - i] + mb[n - i + 1]) % b;
}
for (int i = 0; i < n - 1; i++) {
if (ma[i] == 0 && mb[i + 1] == 0 && x[i + 1] != 0) {
cout << "YES"
<< "\n";
for (int j = 0; j <= i; j++) cout << x[j];
cout << "\n";
for (int j = i + 1; j < n; j++) cout << x[j];
return 0;
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int a[N], sum[N];
int dp[N][2];
int n;
int go(int idx, int player) {
if (idx == n) return 0;
int &ret = dp[idx][player];
if (ret != -1) return ret;
if (player == 1) {
ret = max(a[idx] + go(idx + 1, 0), go(idx + 1, 1));
return ret;
} else {
ret = min(a[idx] + go(idx + 1, 0), go(idx + 1, 1));
return ret;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i)
sum[i] = sum[i - 1] + a[i];
else
sum[i] = a[i];
}
int res = go(0, 1);
cout << sum[n - 1] - res << " " << res << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:36777216")
using namespace std;
const long long int inf = 100000000000000000LL;
int calc(int t1, int t2, int k, int a, int b) {
int q = t1 * a * (100 - k) + t2 * b * 100;
int w = t1 * b * (100 - k) + t2 * a * 100;
return max(q, w);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
srand(16);
int start = clock();
long long int k, b, n, t;
cin >> k >> b >> n >> t;
long long int c = 1;
long long int ans = 0;
while (c <= t) {
c *= k;
c += b;
ans++;
}
--ans;
cout << max(0LL, n - ans);
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define FOR(i, x, y) for(int i = (x), i##END = (y); i <= i##END; ++i)
#define DOR(i, x, y) for(int i = (x), i##END = (y); i >= i##END; --i)
template<typename T, typename _T> inline bool chk_min(T &x, const _T &y) {return y < x ? x = y, 1 : 0;}
template<typename T, typename _T> inline bool chk_max(T &x, const _T &y) {return x < y ? x = y, 1 : 0;}
typedef long long ll;
const int N = 1e5 + 5;
struct node
{
int a, b;
bool operator <(const node &_) const
{
return a < _.a;
}
}p[N];
ll ans;
int n;
int main()
{
scanf("%d", &n);
FOR(i, 1, n)
{
int a, c;
scanf("%d%d", &a, &c);
ans += c;
p[i].a = a, p[i].b = a + c;
}
std::sort(p + 1, p + 1 + n);
int mx = p[1].b;
FOR(i, 2, n) ans += std::max(0, p[i].a - mx), chk_max(mx, p[i].b);
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 1;
struct node {
long long num, index, order;
};
bool cmpnum(node &a, node &b) { return a.num < b.num; }
bool cmporder(node &a, node &b) { return a.order < b.order; }
node nums[maxn];
int main() {
long long t, n, k;
cin >> t;
for (long long i = 0; i < t; i++) {
cin >> n >> k;
long long p = 0;
long long last = 0;
for (long long j = 0; j < n; j++) {
cin >> nums[j].num;
nums[j].order = j;
}
sort(nums, nums + n, cmpnum);
for (long long j = 0; j < n; j++) {
nums[j].index = j;
}
sort(nums, nums + n, cmporder);
for (long long j = 0; j < n; j++) {
if (j == 0) {
p++;
} else {
if (nums[j].index != nums[j - 1].index + 1) p++;
}
}
if (p <= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = LLONG_MAX;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return b;
}
long long mod(long long k, long long n) { return (k % n + n) % n; }
void solve() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
vector<long long> vis(n, 0);
for (int i = (0); i < (n); i++) {
cin >> a[i];
vis[mod(a[i] + i, n)]++;
}
bool flag = true;
for (int i = (0); i < (n); i++) {
if (vis[i] >= 2) {
flag = false;
break;
}
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define rep(i,a,b) for(ll i=(a);i<=(b);i++)
#define per(i,a,b) for(ll i=(a);i>=(b);i--)
#define lc(x) (x<<1)
#define rc(x) (lc(x)|1)
#define lowbit(x) (x&-x)
#define Max(a,b) (a>b?a:b)
#define Min(a,b) (a<b?a:b)
#define next Cry_For_theMoon
#define il inline
#define pb(x) push_back(x)
#define is(x) insert(x)
#define sit set<int>::iterator
#define mapit map<int,int>::iterator
#define pi pair<int,int>
#define ppi pair<int,pi>
#define pp pair<pi,pi>
#define fr first
#define se second
#define vit vector<int>::iterator
#define mp(x,y) make_pair(x,y)
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef double db;
using namespace std;
const int MAXN=2e5+10;
pi a[MAXN];
ll n,ans,idx,pre[MAXN];
int LowerBound(int val){
//最后一个小于等于val的
int L=1,R=n,ans=n;
while(L<=R){
int mid=(L+R)>>1;
if(a[mid].fr<=val){
ans=mid;
L=mid+1;
}else{
R=mid-1;
}
}
return ans;
}
int main(){
cin>>n;
rep(i,1,n){
cin>>a[i].fr>>a[i].se;ans+=a[i].se;
}
sort(a+1,a+1+n);
rep(i,1,n){
pre[i]=Max(pre[i-1],a[i].fr+a[i].se);
}
idx=1;
while(idx<n){
int pos=LowerBound(a[idx].fr+a[idx].se);
if(pos==n)break;
//取[1,pos]最小值
ans+=Max(0,a[pos+1].fr-pre[pos]);
idx=pos+1;
}
cout<<ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, fir;
char f[N];
void init() { scanf("%s", f + 1); }
void work() {
n = strlen(f + 1);
fir = 1;
while (f[fir] == 'a' && fir <= n) {
fir++;
}
if (fir == n + 1) {
f[n] = 'z';
}
for (; fir <= n && f[fir] != 'a'; fir++) {
f[fir]--;
}
printf("%s\n", f + 1);
}
int main() {
init();
work();
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<pair<int, int>> v;
map<int, set<int>> mp;
int ans = -1;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v.push_back({a, b});
mp[a].insert(b);
mp[b].insert(a);
}
for (int i = 0; i < m; i++) {
int a = v[i].first, b = v[i].second;
for (int c = 1; c <= n; c++) {
if (a == c || b == c) continue;
if (mp[a].count(c) && mp[b].count(c)) {
int this_recognition = mp[a].size() + mp[b].size() + mp[c].size() - 6;
if (ans == -1 || ans > this_recognition) {
ans = this_recognition;
}
}
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
inline int read() {
char ch;
bool flag = 0;
int res;
while (!isdigit(
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)))
(ch == '-') && (flag = true);
for (res = ch - '0'; isdigit(
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin),
p1 == p2)
? EOF
: *p1++));
res = res * 10 + ch - '0')
;
(flag) && (res = -res);
return res;
}
const int N = 1e6 + 5, inf = 0x3f3f3f3f;
int head[N], Next[N], ver[N], tot;
inline void add(int u, int v) {
ver[++tot] = v, Next[tot] = head[u], head[u] = tot;
}
int dp[N], a[N], h[N], n, k;
void dfs(int u) {
h[u] = inf;
for (int i = head[u]; i; i = Next[i]) {
int v = ver[i];
dfs(v);
cmin(h[u], h[v] + 1), a[u] += a[v], cmax(dp[u], dp[v] - a[v]);
}
dp[u] += a[u];
if (h[u] == inf) dp[u] = a[u] = 1, h[u] = 0;
if (h[u] >= k) a[u] = 0;
}
int main() {
n = read(), k = read();
for (int i = 2, fa; i <= n; ++i) fa = read(), add(fa, i);
dfs(1);
printf("%d\n", dp[1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, n, x, y, res = 1;
string s;
int main() {
cin >> n;
pair<string, string> arr[6];
arr[0].first = "Power";
arr[0].second = "purple";
arr[1].first = "Time";
arr[1].second = "green";
arr[2].first = "Space";
arr[2].second = "blue";
arr[3].first = "Soul";
arr[3].second = "orange";
arr[4].first = "Reality";
arr[4].second = "red";
arr[5].first = "Mind";
arr[5].second = "yellow";
for (int i = 0; i < n; i++) {
cin >> s;
for (int x = 0; x < 6; x++) {
if (arr[x].second == s) {
arr[x].first = "0";
c++;
}
}
}
cout << 6 - c << endl;
for (int i = 0; i < 6; i++) {
if (arr[i].first != "0") {
cout << arr[i].first << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long N, ans, a[300005];
long long pre[300005], suf[300005];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N;
ans = (N * (N - 1)) / 2;
for (long long i = 1; i <= N; i++) {
char x;
cin >> x;
a[i] = x - 'A';
}
pre[1] = 1;
for (long long i = 2; i <= N; i++) {
if (a[i] == a[i - 1])
pre[i] = pre[i - 1] + 1;
else
pre[i] = 1;
}
suf[N] = 1;
for (long long i = N - 1; i >= 1; i--) {
if (a[i] == a[i + 1])
suf[i] = suf[i + 1] + 1;
else
suf[i] = 1;
}
a[0] = a[1];
a[N + 1] = a[N];
for (long long i = 1; i <= N; i++) {
long long tmp = 1;
if (a[i] == a[i - 1] && a[i] == a[i + 1]) continue;
if (a[i] != a[i - 1] && a[i] != a[i + 1])
tmp = pre[i - 1] + suf[i + 1];
else if (a[i] != a[i - 1])
tmp = pre[i - 1];
else if (a[i] != a[i + 1])
tmp = suf[i + 1];
ans -= tmp;
}
for (long long i = 1; i < N; i++)
if (a[i] != a[i + 1]) ans++;
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN(300);
int n, m;
int dist[10][MAXN][MAXN], dp[MAXN][MAXN], temp[MAXN][MAXN];
int main() {
int a, b, t1, t2;
int lg2, ans;
bool flag;
scanf("%d%d", &n, &m);
if (!m) {
printf("0\n");
return 0;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) dp[i][j] = dist[0][i][j] = -300000000;
dp[i][i] = dist[0][i][i] = 0;
}
for (int i = 0; i < m; ++i) {
scanf("%d%d%d%d", &a, &b, &t1, &t2);
if (t1 + t2 > 0) {
printf("2\n");
return 0;
}
--a, --b;
dist[0][a][b] = t1;
dist[0][b][a] = t2;
}
for (t1 = n, lg2 = -1; t1; t1 >>= 1) ++lg2;
for (int k = 1; k <= lg2 + 1; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
dist[k][i][j] = dist[k - 1][i][j];
for (t1 = 0; t1 < n; ++t1) {
t2 = dist[k - 1][i][t1] + dist[k - 1][t1][j];
dist[k][i][j] < t2 && (dist[k][i][j] = t2);
}
}
flag = false;
for (int i = 0; i < n; ++i)
if (dist[lg2 + 1][i][i] > 0) {
flag = true;
break;
}
if (!flag) {
printf("0\n");
return 0;
}
ans = 1;
for (int k = lg2; ~k; --k) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
temp[i][j] = dp[i][j];
for (int t1 = 0; t1 < n; ++t1) {
t2 = dp[i][t1] + dist[k][t1][j];
temp[i][j] < t2 && (temp[i][j] = t2);
}
}
flag = false;
for (int i = 0; i < n; ++i)
if (temp[i][i] > 0) {
flag = true;
break;
}
if (!flag) {
ans += 1 << k;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) dp[i][j] = temp[i][j];
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string ans[300][5];
int main() {
for (int i = 0; i < 256; i++)
for (int j = 0; j < 3; j++) ans[i][j] = "-";
ans[15][0] = "x";
ans[51][0] = "y";
ans[85][0] = "z";
int l = 0, r = 2;
bool tf = true;
while (tf) {
tf = false;
for (int i = 0; i < 256; i++)
for (int i1 = 0; i1 < 3; i1++)
if (ans[i][i1] != "-") {
string s1;
if (i1 == 0)
s1 = "!" + ans[i][i1];
else
s1 = "!(" + ans[i][i1] + ")";
if (ans[255 - i][0] == "-" || ans[255 - i][0].size() > s1.size() ||
(ans[255 - i][0].size() == s1.size() && ans[255 - i][0] > s1)) {
ans[255 - i][0] = s1;
tf = true;
}
for (int j = 0; j < 256; j++)
for (int j1 = 0; j1 < 3; j1++)
if (ans[j][j1] != "-") {
string s2;
if (i1 == 2)
s2 = "(" + ans[i][i1] + ")&";
else
s2 = ans[i][i1] + "&";
if (j1 == 2)
s2 = s2 + "(" + ans[j][j1] + ")";
else
s2 = s2 + ans[j][j1];
if (ans[i & j][1] == "-" || ans[i & j][1].size() > s2.size() ||
(ans[i & j][1].size() == s2.size() && ans[i & j][1] > s2)) {
ans[i & j][1] = s2;
tf = true;
}
string s3 = ans[i][i1] + "|" + ans[j][j1];
if (ans[i | j][2] == "-" || ans[i | j][2].size() > s3.size() ||
(ans[i | j][2].size() == s3.size() && ans[i | j][2] > s3)) {
ans[i | j][2] = s3;
tf = true;
}
}
}
}
int n;
cin >> n;
while (n--) {
int l = 128, y = 0;
for (int i = 0; i < 8; i++) {
char x;
cin >> x;
if (x == '1') y += l;
l >>= 1;
}
string out = ans[y][0];
if (out.size() > ans[y][1].size() ||
(out.size() == ans[y][1].size() && out > ans[y][1]))
out = ans[y][1];
if (out.size() > ans[y][2].size() ||
(out.size() == ans[y][2].size() && out > ans[y][2]))
out = ans[y][2];
cout << out << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, inf = 1e9 + 10;
int n, m, A[maxn], pref[maxn], suff[maxn], lis[maxn];
int32_t main() {
scanf("%d%d", &n, &m);
for (int i = int(0); i < int(n); i++) {
int l, r;
scanf("%d%d", &l, &r);
l--;
A[l]++;
A[r]--;
}
for (int i = int(1); i < int(m); i++) {
A[i] += A[i - 1];
}
fill(lis, lis + maxn, inf);
for (int i = 0; i < m; i++) {
int pos = upper_bound(lis, lis + maxn, A[i]) - lis;
pref[i] = pos;
lis[pos] = A[i];
}
fill(lis, lis + maxn, inf);
for (int i = m - 1; i >= 0; i--) {
int pos = upper_bound(lis, lis + maxn, A[i]) - lis;
suff[i] = pos;
lis[pos] = A[i];
}
int ans = 0;
for (int i = int(0); i < int(m); i++) {
ans = max(ans, pref[i] + suff[i] + 1);
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v);
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
template <typename A, typename B>
istream &operator>>(istream &cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
const long long MAXN = 1e5 + 7;
void check() {
long long n, m, k;
cin >> n >> m >> k;
long long a[MAXN], mn = 1e10;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (i & 1) mn = min(a[i], mn);
}
if (!(n & 1)) {
cout << 0;
return;
}
cout << min(mn, (m / (n / 2 + 1)) * k);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int i = 1; i <= t; i++) {
check();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, h;
long long dp[40][40];
int main() {
cin >> n >> h;
for (int i = 0; i <= n; i++) dp[0][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 0; k < j; k++)
dp[j][i] += dp[k][i - 1] * dp[j - k - 1][i - 1];
cout << dp[n][n] - dp[n][h - 1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
unordered_map<string, string> m;
unordered_map<string, bool> vu;
vector<string> v;
for (int i = 0; i < n; ++i) {
string a, b;
cin >> a >> b;
v.emplace_back(a);
m[a] = b;
}
vector<pair<string, string>> v2;
for (auto& i : v) {
string init = i;
if (!vu[i]) {
vu[i] = true;
while (m.count(i)) {
i = m[i];
vu[i] = true;
}
v2.emplace_back(init, i);
}
}
cout << v2.size() << '\n';
for (auto& i : v2) {
cout << i.first << ' ' << i.second << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
unsigned long long int pow1(unsigned long long int a, unsigned long long int b,
unsigned long long int c) {
unsigned long long int ans = 1;
while (b) {
if (b & 1) {
ans *= a;
ans %= c;
}
b /= 2;
a = a * a;
a %= c;
}
return ans;
}
long long int gcd(unsigned long long int a, unsigned long long int b) {
unsigned long long int t = a;
a = min(a, b);
b = max(b, t);
if (a == 0)
return b;
else
return gcd(b % a, a);
}
unsigned long long int fct(unsigned long long int k) {
unsigned long long int a = 1;
for (long long int i = 2; i < k + 1; i++) {
a *= i;
a %= 1000000007;
}
return a;
}
unsigned long long int C(unsigned long long int n, unsigned long long int r) {
if (n < r)
return 0;
else if (n == r || r == 0)
return 1;
vector<vector<unsigned long long int> > v(
n + 1, vector<unsigned long long int>(r + 1));
for (long long int i = 0; i < n + 1; i++) v[i][0] = 1;
for (long long int i = 0; i < r + 1; i++) v[0][i] = 1;
for (long long int i = 1; i < n + 1; i++) {
for (long long int j = 1; j < min(i, (long long int)r) + 1; j++) {
if (i == j)
v[i][j] = 1;
else if (j == 1)
v[i][j] = i;
else
v[i][j] = (v[i - 1][j - 1] + v[i - 1][j]) % 1000000007;
}
}
return v[n][r] % 1000000007;
}
char ass(char a) {
if (a == 'a' || a == 'c') return 'b';
return 'a';
}
char assn(char a, char b) {
if (a == 'a') {
if (b == 'b')
return 'c';
else
return 'b';
} else if (a == 'b') {
if (b == 'a')
return 'c';
else
return 'a';
} else {
if (b == 'a')
return 'b';
else
return 'a';
}
}
pair<long long int, long long int> solv(long long int ps, long long int s,
long long int pw, long long int w,
long long int p) {
long long int a = ps, b = pw;
ps /= 2;
pw /= 2;
long long int ans1 = ps * s + pw * w;
long long int ps1 = -1, ps2 = -1;
if (max(a, b) <= (ps + 1 + pw) && (ps + 1) * s + pw * w <= p) {
ans1 = (ps + 1) * s + pw * w;
ps1 = ps + 1;
ps2 = pw;
}
if (max(a, b) <= (ps + pw + 1) && (ps)*s + (1 + pw) * w <= p) {
ans1 = (ps)*s + (1 + pw) * w;
ps2 = pw + 1;
ps1 = ps;
}
if (max(a, b) <= (ps + pw + 2) && (ps + 1) * s + (1 + pw) * w <= p) {
ans1 = (ps + 1) * s + (1 + pw) * w;
ps1 = ps + 1;
ps2 = pw + 1;
}
if (ps1 == -1) {
if (a > b)
return make_pair(a, 0);
else if (a == b) {
if (s > w) return make_pair(a, 0);
}
return make_pair(0, b);
}
return make_pair(ps1, ps2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<long long int> e, o;
int ans = 0;
e.push_back(0);
for (long long int i = 0; i < n; i++) {
long long int a;
cin >> a;
if (i & 1) {
e.push_back(e.back() + a);
o.push_back(o.back());
} else {
if (!o.empty()) {
o.push_back(o.back() + a);
e.push_back(e.back());
} else
o.push_back(a);
}
}
for (long long int i = 0; i < n; i++) {
if (i & 1) {
if (e[i - 1] + o[n - 1] - o[i] == o[i - 1] + e[n - 1] - e[i]) {
ans++;
}
} else {
if (i > 0 && e[i - 1] + o[n - 1] - o[i] == o[i - 1] + e[n - 1] - e[i]) {
ans++;
} else if (!i && o[n - 1] - o[i] == e[n - 1] - e[i]) {
ans++;
}
}
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 300010;
std::vector<int> q;
int cnt[MAXN], ans = 0;
int lim[MAXN];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int pos = 0;
for (int i = 1; i <= m; i++) {
int opt, x;
scanf("%d%d", &opt, &x);
switch (opt) {
case 1: {
q.push_back(x);
cnt[x]++;
ans++;
break;
}
case 2: {
ans -= cnt[x];
cnt[x] = 0;
lim[x] = q.size();
break;
}
case 3: {
while (pos < x) {
if (pos >= lim[q[pos]]) {
cnt[q[pos]]--;
ans--;
}
pos++;
}
break;
}
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double d;
int n;
long long int l;
cin >> n >> l;
double x[n];
for (int i = 0; i < n; i++) cin >> x[i];
sort(x, x + n);
if (x[0] == 0) {
d = double(x[1] / 2);
} else {
d = x[0];
}
for (int i = 1; i < n - 2; i++) {
if (((x[i + 1] - x[i]) / 2) > d) d = (x[i + 1] - x[i]) / 2;
}
if (x[n - 1] == l) {
if (((x[n - 1] - x[n - 2]) / 2) > d) d = (x[n - 1] - x[n - 2]) / 2;
} else {
if (((x[n - 1] - x[n - 2]) / 2) > d) d = (x[n - 1] - x[n - 2]) / 2;
if ((l - x[n - 1]) > d) d = l - x[n - 1];
}
cout << std::fixed << std::setprecision(10) << d;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
void yes() {
cout << "Yes"
<< "\n";
}
void no() {
cout << "No"
<< "\n";
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct FAIL {
FAIL() {
cout << "CHANGE!!!"
<< "\n";
}
};
template <class T>
vector<T> Solve(const vector<T> &numbers, long long l, long long r,
long long &res) {
if (l == r) {
res = 0;
return {numbers[l]};
}
int mid = (l + r) / 2;
long long res_l, res_r;
vector<T> arr_left = Solve(numbers, l, mid, res_l);
vector<T> arr_right = Solve(numbers, mid + 1, r, res_r);
res = res_l + res_r;
int j = 0;
for (int i = 0; i < arr_left.size(); ++i) {
while (j < arr_right.size() && arr_right[j] < arr_left[i]) {
++j;
}
res += j;
}
vector<T> arr_full(arr_left.size() + arr_right.size());
std::merge(arr_left.begin(), arr_left.end(), arr_right.begin(),
arr_right.end(), arr_full.begin());
return arr_full;
}
template <class T>
long long CountInversions(const vector<T> &numbers) {
long long res = 0;
Solve(numbers, 0, int(numbers.size()) - 1, res);
return res;
}
long long calc(int n, int m) {
vector<long long> v(n);
for (int i = (0); i < (n); ++i) {
v[i] = i;
}
for (int i = (0); i < (m); ++i) {
int x = rand() % n;
int y = rand() % n;
if (x == y) {
--i;
continue;
}
if (x > y) {
swap(x, y);
}
swap(v[x], v[y]);
}
long double res = 0;
vector<int> used(n);
vector<int> cycles(n);
for (int i = (0); i < (n); ++i) {
if (used[i]) {
continue;
}
int x = i;
int cnt = 0;
do {
x = v[x];
used[x] = 1;
++cnt;
} while (x != i);
++cycles[cnt];
}
for (int i = (0); i < (n); ++i) {
res += 1.0 / (i + 1) * cycles[i];
}
return CountInversions(v);
}
int main() {
int n;
cin >> n;
vector<long long> v(n);
for (int __i = 0; __i < (n); ++__i) cin >> v[__i];
;
long long inv_count = CountInversions(v);
if ((inv_count % 2) ^ (n % 2)) {
cout << "Um_nik";
} else {
cout << "Petr";
}
}
| 5 |
#include <bits/stdc++.h>
int CH, NEG;
template <typename TP>
inline void read(TP& ret) {
ret = NEG = 0;
while (CH = getchar(), CH < '!')
;
if (CH == '-') NEG = true, CH = getchar();
while (ret = ret * 10 + CH - '0', CH = getchar(), CH > '!')
;
if (NEG) ret = -ret;
}
using namespace std;
int n, K;
struct node {
int sz;
int L[11LL], R[11LL];
bool operator<(const node& B) const {
int i;
for (i = (1); i <= (K); i++)
if (R[i] > B.L[i]) break;
return i > K;
}
bool operator>(const node& B) const {
int i;
for (i = (1); i <= (K); i++)
if (L[i] < B.R[i]) break;
return i > K;
}
} tmp;
int tot = 0;
set<node> S;
set<node>::iterator it1, it2;
void merge(node& A, const node& B) {
A.sz += B.sz;
int i;
for (i = (1); i <= (K); i++)
A.L[i] = std::min(A.L[i], B.L[i]), A.R[i] = std::max(A.R[i], B.R[i]);
}
int Add() {
int i;
tmp.sz = 1;
for (i = (1); i <= (K); i++) read(tmp.L[i]), tmp.R[i] = tmp.L[i];
if (S.empty()) {
S.insert(tmp);
return 1;
}
it1 = S.lower_bound(tmp);
while (true) {
if (it1 == S.end()) break;
if (*it1 > tmp) break;
it2 = it1;
it1++;
merge(tmp, *it2);
S.erase(it2);
}
S.insert(tmp);
it1 = S.end();
it1--;
return it1->sz;
}
int main() {
S.clear();
int i;
read(n), read(K);
for (i = (1); i <= (n); i++) {
printf("%d\n", Add());
}
END:
getchar(), getchar();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int INF = 0x7fffffff;
int n, h[N], t[N], ans = INF;
string s;
int main() {
scanf("%d", &n);
cin >> s;
for (int i = 1; i <= n; ++i) {
h[i] = h[i - 1];
t[i] = t[i - 1];
if (s[i - 1] == 'H') ++h[i];
if (s[i - 1] == 'T') ++t[i];
}
for (int i = 1; i <= n - h[n] + 1; ++i)
ans = min(ans, t[i + h[n] - 1] - t[i - 1]);
for (int i = 1; i <= n - t[n] + 1; ++i)
ans = min(ans, h[i + t[n] - 1] - h[i - 1]);
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
T flag = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') flag = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
x *= flag;
}
int n, m, head[100001], tot, dfn[100001], low[100001], ind, scc, sccR,
tp[100001], mark, vis[100001], flag;
stack<int> st;
bool inst[100001], vic[100001];
struct edge {
int v, next;
} e[100001 * 10];
inline void add(int u, int v) {
e[++tot].v = v, e[tot].next = head[u], head[u] = tot;
}
void tarjan(int u) {
dfn[u] = low[u] = ++ind;
st.push(u);
inst[u] = 1;
for (int i = head[u], v; i; i = e[i].next)
if (!dfn[v = e[i].v])
tarjan(v), low[u] = min(low[u], low[v]);
else if (inst[v])
low[u] = min(low[u], dfn[v]);
if (dfn[u] == low[u]) {
scc++;
if (st.top() ^ u) sccR++, mark = scc;
int v;
do {
v = st.top(), st.pop(), inst[v] = 0, tp[v] = scc;
} while (u ^ v);
}
}
inline double TIME() { return 1.0 * clock() / CLOCKS_PER_SEC; }
void dfs(int u, int num) {
if (flag) return;
for (int i = head[u], v; i && !flag; i = e[i].next)
if (vis[v = e[i].v] == num)
if (vic[v])
flag = -1;
else
flag = v, vic[v] = 1;
else if (vis[v] < num)
vis[v] = num, dfs(v, num);
vis[u] = num + 1;
}
int check(int u, int num) {
while (TIME() < 0.5) {
vis[u] = num + 1;
dfs(u, num);
if (!flag) return u;
if (flag == -1) return -1;
u = flag, flag = 0, num += 2;
}
return -1;
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++) {
int u, v;
read(u), read(v);
add(u, v);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
if (sccR > 1) return 0 * puts("-1");
for (int i = 1; i <= n; i++)
if (tp[i] == mark) return 0 * printf("%d", check(i, 1));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
ifstream f("oo.in");
int n, i, ii;
int a[3002];
char x;
int N, l, j, res;
int main() {
cin >> n;
N = n;
while (N) {
cin >> x;
if (x == 'R') a[++i] = 2;
if (x == 'L') a[++i] = 1;
if (x == '.') a[++i] = 0;
N--;
}
i = 1;
while (i <= n) {
bool ok = false;
l = 0;
if (a[i] == 2) {
for (j = i; j <= n; j++)
if (a[j] != 1) {
l++;
a[j] = -1;
} else {
a[j] = -1;
ok = true;
l++;
break;
}
if (ok)
if (l % 2 == 0)
;
else
res++;
i = j;
} else
i++;
}
for (i = 1; i <= n; i++)
if (a[i] == 1) ii = i;
while (ii) {
a[ii] = -1;
ii--;
}
for (i = 1; i <= n; i++)
if (a[i] == 1) ii = i;
while (ii) {
a[ii] = -1;
ii--;
}
for (i = 1; i <= n; i++)
if (a[i] >= 0) res++;
cout << res << '\n';
for (i = 1; i <= n; i++) return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, n, k;
cin >> q;
int a[101];
while (q--) {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if ((a[n - 1] - a[0]) > 2 * k) {
cout << "-1" << endl;
continue;
} else {
cout << a[0] + k << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, Query;
char ch;
bool a[520][520];
int A[520][520][15][18], P[520], dp[520];
void go(int tl, int tr, int deep, int pr) {
if (tl == tr) return;
int v = (tl + tr) / 2;
dp[v] = deep;
P[v] = pr;
for (int i = 1; i <= n; ++i) {
if (a[i][v] == 1) continue;
for (int j = 0; j < 17; ++j) A[i][v][deep][j] = A[i - 1][v][deep][j];
int x = i / 31;
int y = i % 31;
A[i][v][deep][x] = (A[i][v][deep][x] | (1 << y));
}
for (int i = v + 1; i < tr; ++i)
for (int j = 1; j <= n; ++j) {
if (a[j][i] == 1) continue;
for (int k = 0; k < 17; ++k)
A[j][i][deep][k] = (A[j - 1][i][deep][k] | A[j][i - 1][deep][k]);
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j < 17; ++j)
if (a[i][v] == 0)
A[i][v][deep][j] = A[i + 1][v][deep][j];
else
A[i][v][deep][j] = 0;
if (a[i][v] == 1) continue;
int x = i / 31;
int y = i % 31;
A[i][v][deep][x] = (A[i][v][deep][x] | (1 << y));
}
for (int i = v - 1; i >= tl; --i)
for (int j = n; j >= 1; --j) {
if (a[j][i] == 1) continue;
for (int k = 0; k < 17; ++k)
A[j][i][deep][k] = (A[j + 1][i][deep][k] | A[j][i + 1][deep][k]);
}
go(tl, v, deep + 1, v);
go(v + 1, tr, deep + 1, v);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
ch = getchar();
while (ch != '.' && ch != '#') ch = getchar();
if (ch == '#')
a[i][j] = true;
else
a[i][j] = false;
}
go(1, m + 1, 0, 0);
scanf("%d", &Query);
while (Query--) {
pair<int, int> x, y;
int c1, c2, X, Y;
scanf("%d %d", &x.first, &x.second);
scanf("%d %d", &y.first, &y.second);
if (x.first > y.first || x.second > y.second) {
printf("No\n");
continue;
}
c1 = x.second;
c2 = y.second;
while (dp[c1] > dp[c2]) c1 = P[c1];
while (dp[c2] > dp[c1]) c2 = P[c2];
while (c1 != c2) c1 = P[c1], c2 = P[c2];
if (y.second == c2) {
X = y.first / 31;
Y = y.first % 31;
if ((A[x.first][x.second][dp[c1]][X] & (1 << Y)) == 0)
printf("No\n");
else
printf("Yes\n");
continue;
}
bool b = true;
for (int i = 0; i < 17; ++i)
if ((A[x.first][x.second][dp[c1]][i] & A[y.first][y.second][dp[c1]][i]) >
0) {
b = false;
break;
}
if (b)
printf("No\n");
else
printf("Yes\n");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:16000000")
#pragma warning(disable : 4996)
const int inf = 1 << 25;
const double eps = 1e-9;
const long long MOD = 1000000007;
long long brute(int N) {
static long long f[1000][1000];
memset((f), (0), sizeof(f));
for (int k = (1); k < (N + 1); ++k) f[1][k] = 1;
for (int n = (2); n < (N + 1); ++n)
for (int k = (1); k < (N + 1); ++k)
f[n][k] = (f[n - 1][k] + f[n][k - 1]) % MOD;
long long ret = 0;
for (int k = (1); k < (N + 1); ++k) ret = (ret + f[N][k]) % MOD;
ret = 2 * ret % MOD;
ret -= N;
return (ret % MOD + MOD) % MOD;
}
const int MAXN = 220000;
long long fact[MAXN], invFact[MAXN];
long long C(int N, int K) {
return fact[N] * invFact[K] % MOD * invFact[N - K] % MOD;
}
long long f(int N) {
long long ret = 0;
for (int k = (1); k < (N + 1); ++k) {
long long d = C(N + k - 2, k - 1);
ret = (ret + d) % MOD;
}
ret = 2 * ret % MOD;
ret -= N;
return (ret % MOD + MOD) % MOD;
}
long long fastPow(long long a, long long n) {
long long ret = 1;
while (n > 0) {
if (n & 1) ret = ret * a % MOD;
n >>= 1;
a = a * a % MOD;
}
return ret % MOD;
}
long long inv(long long x) { return fastPow(x, MOD - 2); }
int main(int argc, char* argv[]) {
fact[0] = invFact[0] = 1;
for (int i = (1); i < (MAXN); ++i) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = (1); i < (MAXN); ++i)
invFact[i] = (invFact[i - 1] * inv(i)) % MOD;
int n;
cin >> n;
cout << f(n) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class wunionfind {
private:
int *id, *sz, *ans;
int cnt;
map<int, int> M;
vector<vector<int>> adj;
vector<vector<int>> cost;
public:
wunionfind(int n = 400010) {
cnt = 1;
id = new int[n + 1];
sz = new int[n + 1];
ans = new int[n + 1];
adj.resize(n + 1);
cost.resize(n + 1);
for (int i = 0; i <= n; i++) {
id[i] = i, sz[i] = 1;
ans[i] = 0;
}
}
int root(int idx) {
int i = idx;
while (i != id[i]) i = id[i];
return i;
}
void dfs(int cur, int par, int x) {
ans[cur] = ans[par] ^ x;
for (int i = 0; i < (int)adj[cur].size(); i++) {
if (adj[cur][i] == par) {
continue;
}
dfs(adj[cur][i], cur, cost[cur][i]);
}
return;
}
void uni(int a, int b, int x) {
int i = root(a), j = root(b);
cost[a].emplace_back(x);
adj[a].emplace_back(b);
cost[b].emplace_back(x);
adj[b].emplace_back(a);
if (i != j) {
if (sz[i] >= sz[j]) {
id[j] = i;
sz[i] += sz[j];
sz[j] = 0;
dfs(b, a, x);
} else {
id[i] = j;
sz[j] += sz[i];
sz[i] = 0;
dfs(a, b, x);
}
}
}
int get(int l, int r) {
int a = M[l];
int b = M[r];
if (!a || !b) {
return -1;
}
if (root(a) != root(b)) {
return -1;
}
return (ans[a] ^ ans[b]);
}
void add(int l, int r, int x) {
if (!M[l]) {
M[l] = cnt;
cnt++;
}
if (!M[r]) {
M[r] = cnt;
cnt++;
}
int a = M[l];
int b = M[r];
if (root(a) == root(b)) {
return;
}
uni(a, b, x);
}
} W;
int main() {
int q;
scanf("%d", &q);
int last = 0;
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int l, r, x;
scanf("%d %d %d", &l, &r, &x);
l ^= last;
r ^= last;
x ^= last;
if (l > r) {
swap(l, r);
}
r++;
W.add(l, r, x);
} else {
int l, r;
scanf("%d %d", &l, &r);
l ^= last;
r ^= last;
if (l > r) {
swap(l, r);
}
r++;
last = W.get(l, r);
printf("%d\n", last);
if (last == -1) {
last = 1;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100000 + 10;
inline int Readint() {
char c;
int Number;
for (c = getchar(); !(c >= '0' && c <= '9'); c = getchar())
;
for (Number = 0; c >= '0' && c <= '9'; c = getchar())
Number = Number * 10 + (c - '0');
return Number;
}
vector<int> Delph[Maxn];
int d[Maxn], Degree[Maxn];
vector<pair<int, int> > Answer;
int main() {
int n = Readint(), k = Readint(), MaxDelph = 0;
for (int i = 0; i <= n; i++) Delph[i].clear();
Answer.clear();
for (int i = 1; i <= n; i++) {
d[i] = Readint();
Delph[d[i]].push_back(i);
if (d[i] > MaxDelph) MaxDelph = d[i];
}
if (Delph[0].size() != 1)
puts("-1");
else {
memset(Degree, 0, sizeof(Degree));
for (int i = 0; i < MaxDelph; i++) {
vector<int> &A = Delph[i];
vector<int> &B = Delph[i + 1];
if (A.size() == 0 && B.size() != 0) return puts("-1");
for (int j = 0; j < B.size(); j++) {
Degree[A[j % A.size()]]++;
Degree[B[j]]++;
Answer.push_back(make_pair(A[j % A.size()], B[j]));
}
}
for (int i = 1; i <= n; i++) {
if (Degree[i] > k) return puts("-1");
}
printf("%d\n", Answer.size());
for (int i = 0; i < Answer.size(); i++)
printf("%d %d\n", Answer[i].first, Answer[i].second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int q, n, i, j;
scanf("%d", &q);
for (i = 1; i <= q; i = i + 1) {
scanf("%d", &n);
int a[n];
int sum = 0;
for (j = 0; j < n; j = j + 1) {
scanf("%d", &a[j]);
sum = sum + a[j];
}
if (sum % n == 0) {
printf("%d\n", sum / n);
} else {
printf("%d\n", (sum / n) + 1);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int bmax, bmin, n, w, A[1001], B[1001];
int main() {
cin >> n >> w;
for (int i = 1; i <= n; ++i) {
cin >> A[i];
}
bmin = 0;
for (int i = 1; i <= n; ++i) {
B[i] = A[i] + B[i - 1];
bmin = min(bmin, B[i]);
}
if (bmin < 0) {
bmin = -bmin;
} else {
bmin = 0;
}
for (int i = 0; i <= n; ++i) {
B[i] += bmin;
bmax = max(bmax, B[i]);
}
if (bmax > w) {
cout << 0 << endl;
return 0;
}
cout << w - bmax + 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int o = 0;
int e = 0;
vector<int> b;
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0)
e += 1;
else
o += 1;
if (o == e && i != 0 && i != n - 1) {
b.push_back(abs(a[i] - a[i + 1]));
o = 0;
e = 0;
}
}
sort(b.begin(), b.end());
if (b.size() == 0)
cout << 0 << endl;
else {
int i;
for (i = 0; i < b.size(); i++) {
k -= b[i];
if (k < 0) break;
}
cout << i << endl;
}
}
| 2 |
#include <bits/stdc++.h>
int m, a[110];
int hh(int h) {
int top = 0, ans = 0;
while (h) {
a[top++] = h % 10;
h /= 10;
}
for (int i = top - 1; i >= 0; i--)
if (a[i] == 7 || a[i] == 4) ans = ans * 10 + a[i];
if (ans == m) return 1;
return 0;
}
int main() {
int ans, n;
scanf("%d%d", &n, &m);
if (n < m)
printf("%d\n", m);
else {
for (int i = n + 1;; i++) {
if (hh(i)) {
ans = i;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int tree[111111 * 4][22], L[111111 * 4], R[111111 * 4], map[111111][22],
ans[111111 * 4][2], n, m, q;
char chread() {
char re;
for (; (re = getchar()) < 33;)
;
return re;
}
void do_one(int now, int k) {
memset(tree[now], 0, sizeof tree[now]);
for (int i = 1; i <= m; i++)
if (map[k][i] == '>' && map[k][i + 1] == '<' && i < m)
tree[now][i] = tree[now][i + 1] = -123456789;
if (map[k][1] == '<') tree[now][1] = map[k][0];
if (map[k][m] == '>') tree[now][m] = map[k][m + 1];
for (int i = 1; i <= m; i++)
if (map[k][i] == '^') tree[now][i] = -i;
for (int i = 1; i <= m; i++)
if (!tree[now][i] && map[k][i] == '<') tree[now][i] = tree[now][i - 1];
for (int i = m; i >= 1; i--)
if (!tree[now][i])
tree[now][i] = tree[now][i + 1];
else if (tree[now][i] == -123456789)
tree[now][i] = 0;
if (k == 1)
for (int i = 1; i <= m; i++)
if (tree[now][i] < 0) tree[now][i] = map[0][-tree[now][i]];
}
void do_more(int now) {
int t1 = now * 2, t2 = now * 2 + 1;
for (int i = 1; i <= m; i++)
if (tree[t2][i] < 0)
tree[now][i] = tree[t1][-tree[t2][i]];
else
tree[now][i] = tree[t2][i];
}
void ini(int now, int l, int r) {
L[now] = l;
R[now] = r;
if (l == r)
do_one(now, l);
else {
int p = (l + r) / 2;
ini(now * 2, l, p);
ini(now * 2 + 1, p + 1, r);
do_more(now);
}
}
void update(int now, int l, int r, int x) {
int p = (l + r) / 2;
if (l == r)
do_one(now, x);
else {
if (x <= p)
update(now * 2, l, p, x);
else
update(now * 2 + 1, p + 1, r, x);
do_more(now);
}
}
int find_next(int now, int need) {
int p = (L[now] + R[now]) / 2;
if (need == p) return now * 2;
return find_next(now / 2, need);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) map[i][j] = chread();
for (int i = 1; i <= m; i++) {
map[0][i] = ++map[0][0];
ans[map[0][0]][1] = i;
map[n + 1][i] = ++map[0][0];
ans[map[0][0]][0] = n + 1;
ans[map[0][0]][1] = i;
}
for (int i = 1; i <= n; i++) {
map[i][0] = ++map[0][0];
ans[map[0][0]][0] = i;
map[i][m + 1] = ++map[0][0];
ans[map[0][0]][1] = m + 1;
ans[map[0][0]][0] = i;
}
ans[0][0] = ans[0][1] = -1;
ini(1, 1, n);
for (int i = 1; i <= q; i++)
if (chread() == 'A') {
int t1, t2, now = 1;
scanf("%d%d", &t1, &t2);
t2 *= -1;
for (; L[now] != R[now];) {
int p = (L[now] + R[now]) / 2;
now *= 2;
if (t1 > p) now++;
}
for (; t2 < 0;) {
for (; R[now / 2] == t1; now /= 2)
;
t2 = tree[now][-t2];
if (t2 >= 0) break;
now = find_next(now, L[now] - 1);
}
printf("%d %d\n", ans[t2][0], ans[t2][1]);
} else {
int t1, t2;
scanf("%d%d", &t1, &t2);
map[t1][t2] = chread();
update(1, 1, n, t1);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void func(void) {
freopen("input.c", "r", stdin);
freopen("output.c", "w", stdout);
}
void print(vector<long long> &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld ", v[i]);
}
printf("\n");
}
void print(vector<pair<long long, long long> > &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld %lld\n", v[i].first, v[i].second);
}
}
void print(double d) { cout << fixed << setprecision(10) << d << endl; }
void print(string s, double d) {
cout << s << " ";
cout << fixed << setprecision(10) << d << endl;
}
const int N = 2e5 + 100;
set<int> s[N];
set<pair<int, int> > keep;
int in[N];
vector<pair<int, int> > v;
int answer[N];
void setAnswer(int x, int i, int n) { answer[i] = x; }
void finIt(int n) {
for (int i = 0; i < n; i++) {
if (answer[i] == -1) answer[i] = 0;
}
}
int getAnswer(int k) {
while (keep.size()) {
auto it = keep.begin();
pair<int, int> x = *it;
if (x.first >= k) break;
int y = x.second;
keep.erase(it);
for (auto it1 = s[y].begin(); it1 != s[y].end(); it1++) {
int z = *it1;
keep.erase(keep.find({in[z], z}));
in[z]--;
keep.insert({in[z], z});
s[z].erase(y);
}
s[y].clear();
}
return keep.size();
}
int main() {
int n, q, i, j = 0, temp, t, k, ans = 0, sum = 0, x, y, z, cnt = 0, m, fg = 0,
mx = 0, mx1 = 0;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
s[x].insert(y);
s[y].insert(x);
v.push_back({x, y});
in[x]++;
in[y]++;
}
for (int i = 1; i <= n; i++) {
keep.insert({in[i], i});
}
int nowAnswer = getAnswer(k);
answer[m - 1] = nowAnswer;
for (int i = v.size() - 1; i >= 1; i--) {
int x = v[i].first;
int y = v[i].second;
if (s[x].find(y) == s[x].end()) {
answer[i - 1] = nowAnswer;
continue;
}
keep.erase(keep.find({in[x], x}));
keep.erase(keep.find({in[y], y}));
in[x]--;
in[y]--;
keep.insert({in[x], x});
keep.insert({in[y], y});
s[x].erase(y);
s[y].erase(x);
nowAnswer = getAnswer(k);
answer[i - 1] = nowAnswer;
}
for (int i = 0; i < m; i++) {
printf("%d\n", answer[i]);
}
}
| 7 |
#include <bits/stdc++.h>
long long C[64 + 1][64 + 1];
int main() {
long long m;
int k;
scanf("%lld%d", &m, &k);
if (k == 1 || m == 0) {
puts("1");
return 0;
}
C[0][0] = 1;
for (int i = (1), i_END_ = (64); i <= i_END_; i++) {
C[i][0] = C[i][i] = 1;
for (int j = (1), j_END_ = (i - 1); j <= j_END_; j++)
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
int n = k;
while (m > C[n - 2][k - 2]) m -= C[(n++) - 2][k - 2];
long long ans = (1LL << (n - 1)) + 1;
k -= 2;
for (int i = n - 2; i && k; i--)
if (m > C[i - 1][k]) m -= C[i - 1][k], k--, ans += (1LL << i);
printf("%lld\n", (ans + 1) >> 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int sum[200001];
int qwe(int l, int r) {
if (l == 0) {
return sum[r];
}
return sum[r] - sum[l - 1];
}
int main() {
string a, b;
cin >> a >> b;
for (int i = 0; i < b.size(); i++) {
sum[i] = b[i] - '0';
sum[i] += sum[i - 1];
}
long long ans = 0;
for (int i = 0, j = b.size() - a.size(); i < a.size(); i++, j++) {
int l = j - i + 1;
int h = qwe(i, j);
if (a[i] == '0') {
ans += h;
} else
ans += (l - h);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string str[111];
void prepare() {
str[0] = "111111101010101111100101001111111";
str[1] = "100000100000000001010110001000001";
str[2] = "101110100110110000011010001011101";
str[3] = "101110101011001001111101001011101";
str[4] = "101110101100011000111100101011101";
str[5] = "100000101010101011010000101000001";
str[6] = "111111101010101010101010101111111";
str[7] = "000000001111101111100111100000000";
str[8] = "100010111100100001011110111111001";
str[9] = "110111001111111100100001000101100";
str[10] = "011100111010000101000111010001010";
str[11] = "011110000110001111110101100000011";
str[12] = "111111111111111000111001001011000";
str[13] = "111000010111010011010011010100100";
str[14] = "101010100010110010110101010000010";
str[15] = "101100000101010001111101000000000";
str[16] = "000010100011001101000111101011010";
str[17] = "101001001111101111000101010001110";
str[18] = "101101111111000100100001110001000";
str[19] = "000010011000100110000011010000010";
str[20] = "001101101001101110010010011011000";
str[21] = "011101011010001000111101010100110";
str[22] = "111010100110011101001101000001110";
str[23] = "110001010010101111000101111111000";
str[24] = "001000111011100001010110111110000";
str[25] = "000000001110010110100010100010110";
str[26] = "111111101000101111000110101011010";
str[27] = "100000100111010101111100100011011";
str[28] = "101110101001010000101000111111000";
str[29] = "101110100011010010010111111011010";
str[30] = "101110100100011011110110101110000";
str[31] = "100000100110011001111100111100000";
str[32] = "111111101101000101001101110010001";
}
int main() {
int n, m;
prepare();
cin >> n >> m;
int ans = 0;
if (str[n][m] == '1') ans++;
if (str[32 - n][m] == '1') ans++;
if (str[n][32 - m] == '1') ans++;
if (str[32 - n][32 - m] == '1') ans++;
cout << str[n][m] << endl;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.