solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
bool prime[100001];
vector<int> printDivisors(int n) {
vector<int> v;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
v.push_back(i);
else {
v.push_back(i);
v.push_back(n / i);
}
}
}
return v;
}
int main() {
int n, m;
cin >> n >> m;
int k;
char c;
map<int, int> mp;
int div[n + 1];
memset(div, 0, sizeof(div));
for (int i = 1; i <= n; i++) {
mp.insert({i, 0});
}
vector<int> v;
while (m--) {
cin >> c >> k;
if (c == '+') {
if (mp[k] == 1) {
cout << "Already on" << endl;
} else {
int flag = 0;
vector<int> v = printDivisors(k);
for (int i = 0; i < v.size(); i++) {
if (div[v[i]] != 0 && v[i] != 1) {
flag = div[v[i]];
break;
}
}
if (flag == 0) {
cout << "Success" << endl;
mp[k] = 1;
for (int i = 0; i < v.size(); i++) {
div[v[i]] = k;
}
} else {
cout << "Conflict with " << flag << endl;
}
}
} else {
if (mp[k] == 0) {
cout << "Already off" << endl;
} else {
cout << "Success" << endl;
mp[k] = 0;
vector<int> vv = printDivisors(k);
for (int i = 0; i < vv.size(); i++) {
div[vv[i]] = 0;
}
}
}
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define per(i, a, b) for(int i=(b)-1; i>=(a); i--)
#define sz(a) (int)a.size()
#define de(a) cout << #a << " = " << a << endl
#define dd(a) cout << #a << " = " << a << " "
#define all(a) a.begin(), a.end()
#define pw(x) (1ll<<(x))
#define endl "\n"
typedef double db;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int a[100000 + 10];
int b[100000 + 10];
int cnt[100000 + 10];
map<int, int> vis1, vis2;
vi v1, v2;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
//cout << setiosflags(ios::fixed);
//cout << setprecision(2);
int n;
cin >> n;
rep(i, 1, n + 1){
cin >> a[i];
}
int sta = 1;
b[1] = a[1];
cnt[sta] = 1;
int ans = 0;
rep(i, 2, n + 1){
if(a[i] == b[sta]) cnt[sta] ++;
else {
sta ++;
b[sta] = a[i];
cnt[sta] = 1;
}
}
//int last = -1;
// rep(i, 1, sta + 1){
// if(vis[b[i]]) {
// if(last != -1 ) v1.pb(last);
// v1.pb(vis[b[i]]);
// //cout << "!!" << i << endl;
// last = i;
// vis.clear();
// }
// vis[b[i]] = i;
// }
// //de(last);
// if(last != -1) v1.pb(last);
// for(auto i: v1) {
// vis1[i] = true;
// //de(i);
// // cout << i << " " ;
// }
// //cout << endl;
// rep(i, 1, sta + 1) if(!vis1[i]) v2.pb(i);
// if(sz(v1)) ans ++;
// if(sz(v2)) ans ++;
// rep(i, 1, sz(v1)){
// if(b[v1[i]] != b[v1[i - 1]]) ans ++;
// }
// rep(i, 1, sz(v2)){
// if(b[v2[i]] != b[v2[i - 1]]) ans ++;
// }
int fi = 1;
rep(i, 1, sta + 1){
if(vis1[b[i]]) {
vis1.clear();
if(i > 1) vis1[b[i - 1]] = 1;
ans --;
}
vis1[b[i]] = i;
//vis2[b[i]] = 1;
}
cout << sta + ans << endl;
return 0;
}
/*
9
1 2 1 2 3 2 1 2 1
*/ | 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int k;
cin >> n >> k;
long long sol = 0;
long long total = 0;
for (int i = 0; i < n; i++) {
long long aux;
cin >> aux;
total += aux;
sol += total / k;
total = total % k;
if (i < n - 1 and total > aux) {
total = 0;
sol++;
}
}
sol += total / k;
if (total % k) sol++;
cout << sol << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 * 4;
inline int get() {
int x;
cin >> x;
return x;
}
inline long long getlong() {
long long x;
cin >> x;
return x;
}
inline string getString() {
string s;
cin >> s;
return s;
}
template <typename T>
inline vector<T> getvector(int len) {
vector<T> a(len);
for (auto &it : a) cin >> it;
return a;
}
inline vector<int> getvector(int len) {
vector<int> a(len);
for (auto &it : a) cin >> it;
return a;
}
inline vector<pair<int, int>> getvector_andPairCnt(int len) {
vector<pair<int, int>> a(len);
int i = 1;
for (auto &it : a) {
it.second = i;
i++;
cin >> it.first;
}
return a;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it : v) os << it << " ";
os << "\n";
return os;
}
template <typename T, typename H>
inline vector<pair<T, H>> getvector_andBiPair(int len) {
vector<pair<T, H>> a(len);
int i = 1;
for (auto &it : a) {
cin >> it.first >> it.second;
}
return a;
}
template <typename T>
inline set<T> vector_to_set(const vector<T> &vec) {
set<T> s;
for (auto &it : vec) s.insert(it);
return s;
}
template <typename T>
int sqr(T x) {
return x * x;
}
double clog2(double power, double val) { return log(val) / log(power); }
int mod = 1e9 + 7;
int dp[maxn];
int main() {
auto s = getString();
dp[0] = 1;
for (auto it : s) {
if (it == 'w' || it == 'm') return cout << 0, 0;
}
for (int i = 0; i < s.size(); i++) {
if (i + 1 != s.size() && s[i] == 'u' && s[i + 1] == 'u') {
(dp[i + 2] += dp[i]) %= mod;
}
if (i + 1 != s.size() && s[i] == 'n' && s[i + 1] == 'n') {
(dp[i + 2] += dp[i]) %= mod;
}
(dp[i + 1] += dp[i]) %= mod;
}
cout << dp[s.size()];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long ans = 0;
scanf("%I64d", &n);
long long a[11];
long long e = 1;
long long tmp = 10;
a[0] = 0;
a[1] = 9;
for (int i = 2; i <= 9; i++) {
a[i] = a[i - 1] * 10;
}
while (n / tmp > 0) {
e++;
tmp *= 10;
}
tmp = 0;
for (int i = 1; i < e; i++) {
ans += i * a[i];
tmp += a[i];
}
n -= tmp;
ans += n * e;
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v, c, id, next;
} edge[200000];
int e, ft[2000];
void init_graph() {
e = 0;
memset(ft, -1, sizeof(ft));
}
void add_edge(int u, int v, int c, int id) {
edge[e].v = v;
edge[e].id = id;
edge[e].c = c;
edge[e].next = ft[u];
ft[u] = e++;
}
void insert_edge(int u, int v, int c, int id) {
add_edge(u, v, c, id);
add_edge(v, u, 0, id);
}
int n, m, k, deg[2000];
pair<int, int> init_edge[2000];
int col[2000];
int S, T, N;
int pre[2000], dist[2000];
int head, tail, qu[2000];
bool bfs() {
head = tail = 0;
for (int i = 0; i < N; i++) dist[i] = -1;
dist[S] = 0;
qu[tail++] = S;
while (head < tail) {
int u = qu[head++];
for (int i = ft[u]; i != -1; i = edge[i].next) {
if (edge[i].c > 0) {
int v = edge[i].v;
if (-1 == dist[v]) {
dist[v] = dist[u] + 1;
pre[v] = i;
qu[tail++] = v;
if (v == T) return true;
}
}
}
}
return false;
}
void solve() {
init_graph();
S = 0;
T = n + m + 1;
N = T + 1;
int need = 0;
memset(deg, 0, sizeof(deg));
for (int i = 1; i <= m; i++) {
int vid = i + n;
insert_edge(vid, T, 1, -1);
insert_edge(init_edge[i].first, vid, 1, i);
insert_edge(init_edge[i].second, vid, 1, i);
deg[init_edge[i].first]++;
deg[init_edge[i].second]++;
}
for (int i = 1; i <= n; i++) {
int c = max(0, (deg[i] - k) * 2);
insert_edge(S, i, c, -1);
need += c;
}
int tol_flow = 0;
while (bfs()) {
int idx = T;
tol_flow += 1;
while (idx != S) {
edge[pre[idx]].c -= 1;
edge[pre[idx] ^ 1].c += 1;
idx = edge[pre[idx] ^ 1].v;
}
}
memset(col, 0, sizeof(col));
if (need == tol_flow) {
for (int u = 1; u <= n; u++) {
head = tail = 0;
for (int i = ft[u]; i != -1; i = edge[i].next) {
int id = edge[i].id;
if (!edge[i].c && id != -1) qu[tail++] = id;
}
while (head < tail) {
int x1 = qu[head++];
int x2 = qu[head++];
col[x1] = col[x2] = x1;
}
}
for (int i = 1; i <= m; i++)
if (!col[i]) col[i] = i;
}
for (int i = 1; i <= m; i++) printf("%d%c", col[i], i < m ? ' ' : '\n');
}
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++)
scanf("%d%d", &init_edge[i].first, &init_edge[i].second);
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
bool X[26];
int mat[6][6];
int niz[26];
int sum;
bool check() {
sum = 0;
for (int i = 0; i < n; i++) sum += mat[i][0];
for (int j = 1; j < n; j++) {
int st = 0;
for (int i = 0; i < n; i++) st += mat[i][j];
if (st != sum) return false;
}
for (int i = 0; i < n; i++) {
int st = 0;
for (int j = 0; j < n; j++) st += mat[i][j];
if (st != sum) return false;
}
int sz = 0;
for (int i = 0; i < n; i++) {
sz += mat[i][i];
}
if (sz != sum) return false;
sz = 0;
for (int i = 0; i < n; i++) {
sz += mat[i][n - i - 1];
}
if (sz != sum) return false;
return true;
}
vector<pair<int, int> > pos;
vector<int> vals;
int empty_cnt = 0;
int main() {
scanf("%d", &n);
for (int i = 0; i < n * n; i++) {
scanf("%d", &niz[i]);
vals.push_back(i);
pos.push_back(make_pair(i / n, i % n));
}
do {
for (int i = 0; i < pos.size(); i++) {
mat[pos[i].first][pos[i].second] = niz[vals[i]];
}
if (check()) {
break;
}
} while (next_permutation(vals.begin(), vals.end()));
printf("%d\n", sum);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%d ", mat[i][j]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0)
return (b);
else
return (gcd(b % a, a));
}
long long int fastpow(long long int a, long long int n, long long int temp) {
if (n == 0) return (1);
if (n == 1) return ((a * temp) % 1000000007);
if (n & 1) temp = (temp * a) % 1000000007;
return (fastpow((a * a) % 1000000007, n / 2, temp));
}
char dum;
long long int x[1000006] = {0}, a, b;
int main() {
ios::sync_with_stdio(false);
long long int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
x[a]++, x[b]++;
}
long long int extra = 0;
for (int i = 1; i < n + 1; i++) {
extra = extra + x[i] * (n - 1 - x[i]);
}
cout << (n * (n - 1) * (n - 2)) / 6 - extra / 2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1e+9 + 7;
const ll INF = LLONG_MAX;
const int N = (int)2e+5 + 8;
void MAIN(ll tc) {
ll n, m;
cin >> n >> m;
string c;
cin >> c;
ll ct = 0, ans = 0;
for (ll i = 0; i < n; i++) {
if (c[i] == '.')
ct++;
else
ct = 0;
if (ct == 2) {
ans++;
ct = 1;
}
}
for (ll i = 0; i < m; i++) {
ll x;
char t;
cin >> x >> t;
x--;
if (t == '.' and c[x] != '.') {
if (x != 0) {
if (c[x - 1] == '.') ans++;
}
if (x != (n - 1)) {
if (c[x + 1] == '.') ans++;
}
}
if (t != '.' and c[x] == '.') {
if (x != 0) {
if (c[x - 1] == '.') ans--;
}
if (x != (n - 1)) {
if (c[x + 1] == '.') ans--;
}
}
c[x] = t;
cout << ans << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed;
cout << setprecision(10);
int test__cases = 1;
for (int i = 1; i <= test__cases; i++) {
MAIN(i);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, x;
long long sum;
char s[30];
vector<int> a;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%s", s);
if (s[0] == 's') {
sum = 0;
for (j = 2; j < a.size(); j += 5) {
sum += a[j];
}
cout << sum;
printf("\n");
} else {
scanf("%d", &x);
if (s[0] == 'a')
a.insert(lower_bound(a.begin(), a.end(), x), x);
else
a.erase(lower_bound(a.begin(), a.end(), x));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int a, s, d, f, g;
int main() {
cin >> a;
cout << (a - 1) / 2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mx1 = 15;
const int mx2 = 505;
const int mx3 = 1005;
const int mx4 = 30005;
const int mx5 = 100005;
const int mx6 = 1000005;
int _toggle(int N, int pos) { return N = N ^ (1 << pos); }
int _set(int N, int pos) { return N = N | (1 << pos); }
int _reset(int N, int pos) { return N = N & ~(1 << pos); }
bool _check(int N, int pos) { return (bool)(N & (1 << pos)); }
bool _upper(char a) { return a >= 'A' && a <= 'Z'; }
bool _lower(char a) { return a >= 'a' && a <= 'z'; }
bool _digit(char a) { return a >= '0' && a <= '9'; }
int dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
int n, m, c0, d0;
int dp[mx3][mx1];
int a[mx1], b[mx1], c[mx1], d[mx1];
int call(int N, int id) {
if (id > m) {
return N / c0 * d0;
}
if (dp[N][id] != -1) {
return dp[N][id];
}
int ans = 0, bun = 0;
while (bun * b[id] <= a[id] && bun * c[id] <= N) {
ans = max(ans, d[id] * bun + call(N - bun * c[id], id + 1));
bun++;
}
return dp[N][id] = ans;
}
void solve() {
cin >> n >> m >> c0 >> d0;
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
}
memset(dp, -1, sizeof(dp));
cout << call(n, 1) << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
while (tc--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void Rahul(){
int n;cin>>n;
vector<int>a(n);
for(int i=0;i<n;i++)cin>>a[i];
vector<int>res(n,0);
for(int i=1;i<n;i++){
int ans=0;
for(int j=31;j>=0;j--){
bool b1=a[i-1]&(1<<j);
bool b2=a[i]&(1<<j);
if(b1&&!b2){
ans=ans|(1<<j);
}
}
res[i]=ans;
a[i]=res[i]^a[i];
}
for(int i:res)cout<<i<<" ";cout<<endl;
}
int main(){
int t;cin>>t;
while(t--)Rahul();
return 0;
}/*a[i]&(1<<j);
if(b1&&!b2){
ans=ans|(1<<j);
}
}
res[i]=ans;
a[i]=res[i]^a[i];
}
for(int i:res)cout<<i<<" ";cout<<endl;
}
int main(){
int t;cin>>t;
while(t--)Rahul();
return 0;
}*/ | 2 |
#include <bits/stdc++.h>
using namespace std;
int p[55], t[55];
int main() {
int n, c;
cin >> n >> c;
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) cin >> t[i];
int l = 0, r = 0, tl = 0, tr = 0;
for (int i = 0; i < n; i++) {
tl += t[i];
l += max(0, p[i] - c * tl);
}
for (int i = n - 1; i >= 0; i--) {
tr += t[i];
r += max(0, p[i] - c * tr);
}
if (l == r)
cout << "Tie";
else if (l > r)
cout << "Limak";
else
cout << "Radewoosh";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N(5), M(100010);
const long long INF(1LL << 60);
int n, m;
int st[1 << N][1 << N];
long long f[2][1 << N];
int hor[M][N], ver[M][N];
int bit(int x, int y) { return (x >> y) & 1; }
int pre(int x) { return (x + n - 1) % n; }
int nxt(int x) { return (x + 1) % n; }
int main() {
scanf("%d%d", &n, &m);
for (int i = int(0); i < int(m - 1); ++i)
for (int j = int(0); j < int(n); ++j) scanf("%d", &hor[i][j]);
for (int i = int(0); i < int(m); ++i)
for (int j = int(0); j < int(n); ++j) scanf("%d", &ver[i][j]);
for (int i = int(0); i < int(1 << n); ++i) f[0][i] = INF;
f[0][(1 << n) - 1] = 0;
int c = 0;
for (int i = int(0); i < int(1 << n); ++i)
for (int j = int(0); j < int(1 << n); ++j) {
int s = i;
for (int k = int(0); k < int(n); ++k)
if (bit(s, k)) {
for (int x = k; !bit(s, nxt(x)) && bit(j, x); x = nxt(x), s |= 1 << x)
;
for (int x = k; !bit(s, pre(x)) && bit(j, pre(x));
x = pre(x), s |= 1 << x)
;
}
st[i][j] = s;
}
for (int i = int(0); i < int(m - 1); ++i) {
for (int j = int(0); j < int(1 << n); ++j) f[c ^ 1][j] = INF;
for (int j = int(0); j < int(1 << n); ++j) {
long long w = 0;
for (int k = int(0); k < int(n); ++k)
if (!bit(j, k)) w += hor[i][k];
for (int k = int(0); k < int(1 << n); ++k)
f[c ^ 1][j & k] = min(f[c ^ 1][j & k], f[c][k] + w);
}
c ^= 1;
for (int j = int(0); j < int(1 << n); ++j) f[c ^ 1][j] = INF;
for (int j = int(0); j < int(1 << n); ++j) {
long long w = 0;
for (int k = int(0); k < int(n); ++k)
if (!bit(j, k)) w += ver[i + 1][k];
for (int k = int(0); k < int(1 << n); ++k)
f[c ^ 1][st[k][j]] = min(f[c ^ 1][st[k][j]], f[c][k] + w);
}
c ^= 1;
}
cout << f[c][0] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
map<int, bool> isInQ;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int id;
cin >> id;
if (q.empty()) {
q.push(id);
isInQ[id] = true;
} else {
if (!isInQ[id]) {
if (q.size() == k) {
isInQ[q.front()] = false;
q.pop();
q.push(id);
} else {
q.push(id);
}
isInQ[id] = true;
}
}
}
cout << q.size() << endl;
vector<int> v;
while (!q.empty()) {
v.push_back(q.front());
q.pop();
}
for (int i = v.size() - 1; i >= 0; i--) {
cout << v[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1, s2;
cin >> s1;
cin >> s2;
cin >> s;
int arr[123];
int arr2[123];
memset(arr, 0, sizeof(arr));
memset(arr2, 0, sizeof(arr2));
for (int i = 0; i < s1.size(); i++) {
arr[s1[i]]++;
}
for (int i = 0; i < s2.size(); i++) {
arr[s2[i]]++;
}
for (int i = 0; i < s.size(); i++) {
arr2[s[i]]++;
}
int flag = 0;
for (int i = 0; i < 123; i++) {
if (arr[i] == arr2[i]) {
flag = 1;
continue;
} else {
flag = 0;
break;
}
}
if (flag)
cout << "YES";
else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
string S;
int count;
int pos;
} type;
bool operator<(type x, type y) {
if (x.count < y.count)
return (true);
else if (x.count == y.count && x.pos < y.pos)
return (true);
else
return false;
}
int main() {
int n, curr, count;
cin >> n;
type *T = new type[n];
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
count = 0;
for (int j = 0; j < s.length(); ++j) {
if (s[j] == 'a' || s[j] == 'e' || s[j] == 'i' || s[j] == 'o' ||
s[j] == 'u') {
++count;
if (s[j] == 'a')
curr = 0;
else if (s[j] == 'e')
curr = 1;
else if (s[j] == 'i')
curr = 2;
else if (s[j] == 'o')
curr = 3;
else if (s[j] == 'u')
curr = 4;
}
}
type t;
t.S = s;
t.count = count;
t.pos = curr;
T[i] = t;
}
sort(T, T + n);
vector<pair<string, string> > A;
for (int i = 0; i < n; ++i) {
if (i + 1 < n && T[i].count == T[i + 1].count && T[i].pos == T[i + 1].pos) {
pair<string, string> p;
p.first = T[i].S;
p.second = T[i + 1].S;
A.push_back(p);
T[i].count = -1;
T[i + 1].count = -1;
}
}
vector<pair<string, string> > B;
for (int i = 0; i < n; ++i) {
if (T[i].count > 0) {
int k = i + 1;
while (k < n && T[k].count == -1) ++k;
if (T[k].count == T[i].count) {
pair<string, string> q;
q.first = T[i].S;
q.second = T[k].S;
T[i].count = -1;
T[k].count = -1;
B.push_back(q);
i = k;
}
}
}
if (A.size() <= B.size()) {
cout << A.size() << endl;
for (int i = 0; i < A.size(); ++i) {
cout << B[i].first << " " << A[i].first << endl;
cout << B[i].second << " " << A[i].second << endl;
}
} else {
int x = (A.size() - B.size()) / 2;
cout << B.size() + x << endl;
for (int i = 0; i < B.size(); ++i) {
cout << B[i].first << " " << A[i].first << endl;
cout << B[i].second << " " << A[i].second << endl;
}
for (int i = B.size(); i < A.size() && i + 1 < A.size(); i = i + 2) {
cout << A[i].first << " " << A[i + 1].first << endl;
cout << A[i].second << " " << A[i + 1].second << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> best(40, 1);
void rek(vector<int>& f, vector<int>& cur, int zero, int pw) {
int maxa = zero * 2 + 1, maxa2 = (zero / 2) * 2 + 1;
if (maxa == 3) {
if (f[0]) cur.push_back(-pw);
if (f[2]) cur.push_back(pw);
if (cur.size() < best.size()) best = cur;
if (f[0]) cur.pop_back();
if (f[2]) cur.pop_back();
return;
}
vector<int> m1(maxa2), m2(maxa2);
int odd = 0;
for (int i = 0; i < f.size(); i++) {
if (!f[i]) continue;
int reali = i - zero;
if (abs(reali) & 1) {
odd++;
m1[(reali - 1) / 2 + (zero / 2)] = 1;
m2[(reali + 1) / 2 + (zero / 2)] = 1;
} else {
m1[reali / 2 + (zero / 2)] = 1;
m2[reali / 2 + (zero / 2)] = 1;
}
}
if (odd) cur.push_back(pw);
rek(m1, cur, zero / 2, pw * 2);
if (odd) {
cur.pop_back();
cur.push_back(-pw);
}
rek(m2, cur, zero / 2, pw * 2);
if (odd) cur.pop_back();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
const int zero = (1 << 18);
int n;
cin >> n;
vector<int> a(n), f(zero * 2 + 1, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
f[zero + a[i]]++;
}
vector<int> tmp;
rek(f, tmp, zero, 1);
cout << best.size() << "\n";
for (int i = 0; i < best.size(); i++) cout << best[i] << " ";
cout << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
__typeof(n) a[n];
for (__typeof(n) i = 0; i < n; i++) cin >> a[i];
int i = 0, j = n - 1, m = -1;
string ans = "";
while (i <= j) {
if ((a[i] < a[j] && a[i] > m) || a[j] < m && a[i] > m)
ans += 'L', m = a[i], i++;
else if (a[j] > m)
ans += 'R', m = a[j], j--;
else
break;
}
cout << ans.size() << endl;
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[1010];
int main() {
ios_base::sync_with_stdio(0);
long long n, k;
cin >> n >> k;
int ans = 0;
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (long long i = 0; i < n; i++) {
if (k >= (a[i] + 1) / 2)
k = max(k, a[i]);
else {
i--;
k *= 2;
ans++;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
vector<pair<int, pair<int, int> > > a;
for (int i = 0; i < k; i++) {
int n;
cin >> n;
vector<int> x(n);
for (int j = 0; j < n; j++) cin >> x[j];
int sum = accumulate(x.begin(), x.end(), 0);
for (int j = 0; j < n; j++)
a.push_back(make_pair(sum - x[j], make_pair(i, j)));
}
sort(a.begin(), a.end());
for (int i = 0; i < int(a.size()) - 1; ++i) {
if (a[i].first == a[i + 1].first &&
(a[i].second.first != a[i + 1].second.first)) {
cout << "YES" << endl;
cout << a[i + 1].second.first + 1 << " " << a[i + 1].second.second + 1
<< endl;
cout << a[i].second.first + 1 << " " << a[i].second.second + 1 << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6, nBits = 2e8 + 5, MM = (1 << 16), MAX = 1111,
OO = 0x3f3f3f3f, MOD = 1e9 + 7, inf = 1 << 30;
const long long INF = (long long)1e18;
long long GCD(long long a, long long b) { return !b ? a : GCD(b, a % b); }
long long LCM(long long x, long long y) { return (x * y / GCD(x, y)); }
long long fact(long long z) { return (z <= 1) ? 1 : z * fact(z - 1); }
int n, h, k, x;
long long sum, se;
bool first;
int main() {
scanf("%d %d %d", &n, &h, &k);
while (n--) {
scanf("%d", &x);
sum += x;
if (sum > h) sum = x, ++se;
se += sum / k;
sum %= k;
}
printf("%lld\n", se + (sum ? 1 : 0));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
int dblcmp(double d) {
if (fabs(d) < eps) return 0;
return d > eps ? 1 : -1;
}
struct node {
int v, t, w;
node() {}
node(int a, int b, int c) {
v = a;
t = b;
w = c;
}
bool operator<(const node &gg) const {
if (t == gg.t) return w > gg.w;
return t > gg.t;
}
};
vector<int> g[111111];
int n, m;
map<pair<int, int>, int> e;
int d1[111111], d2[111111], pre[111111];
pair<int, int> mp1(int a, int b) {
if (a < b) return make_pair(a, b);
return make_pair(b, a);
}
int main() {
int i, j, k;
cin >> n >> m;
for (i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
if (x > y) swap(x, y);
e[mp1(x, y)] = z;
g[x].push_back(y);
g[y].push_back(x);
}
memset(d1, 1, sizeof(d1));
memset(d2, 1, sizeof(d2));
priority_queue<node> q;
q.push(node(1, 0, 0));
d1[1] = d2[1] = 0;
while (!q.empty()) {
int v = q.top().v;
int t = q.top().t;
int w = q.top().w;
q.pop();
for (__typeof(g[v].begin()) e = g[v].begin(); e != g[v].end(); ++e) {
int c = ::e[mp1(v, *e)];
if (c) {
if (d1[*e] > d1[v] + 1 || (d1[*e] == d1[v] + 1) && (d2[*e] > d2[v])) {
d1[*e] = d1[v] + 1;
d2[*e] = d2[v];
pre[*e] = v;
q.push(node(*e, d1[*e], d2[*e]));
}
} else {
if (d1[*e] > d1[v] + 1 ||
(d1[*e] == d1[v] + 1) && (d2[*e] > d2[v] + 1)) {
d1[*e] = d1[v] + 1;
d2[*e] = d2[v] + 1;
pre[*e] = v;
q.push(node(*e, d1[*e], d2[*e]));
}
}
}
}
map<pair<int, int>, int> r;
int d = n;
while (d != 1) {
int pd = pre[d];
r[mp1(pd, d)] = 1;
d = pd;
}
int rrr = 0;
for (__typeof(e.begin()) pt = e.begin(); pt != e.end(); ++pt) {
int u = (pt->first).first, v = (pt->first).second, w = pt->second;
if (r[mp1(u, v)]) {
if (w) continue;
++rrr;
} else {
if (!w) continue;
++rrr;
}
}
printf("%d\n", rrr);
for (__typeof(e.begin()) pt = e.begin(); pt != e.end(); ++pt) {
int u = (pt->first).first, v = (pt->first).second, w = pt->second;
if (r[mp1(u, v)]) {
if (w) continue;
printf("%d %d %d\n", u, v, 1);
} else {
if (!w) continue;
printf("%d %d %d\n", u, v, 0);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const unsigned long long MAXN = 1001;
const double PI = 3.1415926535897932384626433832795;
const long long ONE = 1LL;
const double EPS = 1e-8;
long long gcd(long long a, long long b) { return (b) ? gcd(b, a % b) : a; }
long long max(long long a, long long b) { return (a > b) ? a : b; }
struct Point {
unsigned long long x, y;
Point(unsigned long long _x = 0, unsigned long long _y = 0) : x(_x), y(_y) {}
void Read() { cin >> x >> y; }
double Dist(Point a) {
return sqrt((double)((a.x - x) * (a.x - x) + (a.y - y) * (a.y - y)));
}
};
map<string, long long> t;
bool sless(string a, string b) { return t[a] < t[b]; }
int main() {
long long a, b;
cin >> a >> b;
bool fl = false;
if (a > b) {
swap(a, b);
fl = true;
}
long long lc = a * b / gcd(a, b);
long long i = a, j = b;
long long m = a, d = 0;
while (!(i >= lc - a && j >= lc - b)) {
if (j > i) {
d += j - i;
while (i < j) {
i += a;
}
} else if (i > j) {
m += i - j;
while (j < i) {
j += b;
}
}
}
if (i != lc && j != lc) {
d += lc - i;
m += i - j;
} else if (i == lc && j == lc) {
m -= a;
d += a;
} else {
while (i + a != lc) {
m += a;
i += a;
}
d += a;
}
if (!fl && m > d || fl && m < d) {
cout << "Masha" << endl;
return 0;
}
if (!fl && d > m || fl && m > d) {
cout << "Dasha" << endl;
return 0;
}
cout << "Equal" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
const int N = 1e5 + 7;
int n, m;
int cnt[N];
int ren[N];
int perm[15][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
cin >> perm[i][j];
}
}
for (int i = 1; i <= n; ++i) {
ren[perm[1][i]] = i;
}
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
perm[i][j] = ren[perm[i][j]];
}
}
for (int i = 1; i <= n; ++i) {
cnt[i] = n;
}
for (int i = 1; i <= m; ++i) {
int k = 0;
for (int j = 1; j <= n; ++j) {
if (k >= j) {
cnt[perm[i][j]] = min(cnt[perm[i][j]], k - j + 1);
continue;
}
k = j;
while (k + 1 <= n && (perm[i][k] + 1 == perm[i][k + 1])) {
++k;
}
cnt[perm[i][j]] = min(cnt[perm[i][j]], k - j + 1);
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += cnt[i];
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return (1);
long long int sol = power(a, b / 2, m);
sol = (sol * sol) % m;
if (b % 2 == 1) sol = (sol * a) % m;
return (sol);
}
long long int gcd(long long int a, long long int b) {
if (a % b == 0)
return b;
else {
return gcd(b, a % b);
}
}
vector<int> g0[200005], g1[200005];
bool used[200005];
int cnt0[200005], cnt1[200005];
vector<int> comp;
void dfs0(int u) {
used[u] = true;
comp.push_back(u);
for (int v : g0[u]) {
if (!used[v]) dfs0(v);
}
}
void dfs1(int u) {
used[u] = true;
comp.push_back(u);
for (int v : g1[u]) {
if (!used[v]) dfs1(v);
}
}
void solve() {
int n, u, v, w;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v >> w;
u--, v--;
if (w == 0) {
g0[u].push_back(v);
g0[v].push_back(u);
} else {
g1[u].push_back(v);
g1[v].push_back(u);
}
}
long long int ans = 0;
fill(used, used + n, false);
for (int i = 0; i < n; i++) {
if (!used[i]) {
comp.clear();
dfs0(i);
ans = ans + 1LL * comp.size() * (comp.size() - 1);
for (int x : comp) cnt0[x] = comp.size();
}
}
fill(used, used + n, false);
for (int i = 0; i < n; i++) {
if (!used[i]) {
comp.clear();
dfs1(i);
ans = ans + 1LL * comp.size() * (comp.size() - 1);
for (int x : comp) cnt1[x] = comp.size();
}
}
for (int i = 0; i < n; i++) {
ans = ans + 1LL * (cnt0[i] - 1) * (cnt1[i] - 1);
}
cout << ans;
}
int main() {
int t = 1;
while (t--) solve();
return (0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[101], vowels;
bool flag = true;
char ch;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
scanf("\n");
for (int i = 0; i < n; i++) {
vowels = 0;
ch = getchar();
while (ch != '\n' && ch != EOF) {
switch (ch) {
case 'a':
vowels++;
break;
case 'e':
vowels++;
break;
case 'i':
vowels++;
break;
case 'o':
vowels++;
break;
case 'u':
vowels++;
break;
case 'y':
vowels++;
break;
}
ch = getchar();
}
if (vowels != a[i]) {
flag = false;
break;
}
}
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[400007];
int main() {
int t;
scanf("%d", &t);
while (t--) {
vector<int> v;
int n;
scanf("%d", &n);
int req = n / 2;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
if (i && arr[i] == arr[i - 1])
v.back()++;
else
v.push_back(1);
}
int g = v[0];
int ans = g;
int s = 0, b = 0;
int cnt = 1;
while (s <= g && cnt < v.size()) {
s += v[cnt];
ans += v[cnt];
cnt++;
}
while (b <= g && cnt < v.size()) {
b += v[cnt];
ans += v[cnt];
cnt++;
}
while (ans < req && cnt < v.size()) {
if (ans + v[cnt] <= req) {
b += v[cnt];
ans += v[cnt];
} else
break;
cnt++;
}
if (g && s && b && ans <= req)
printf("%d %d %d\n", g, s, b);
else
printf("0 0 0\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
static bool constexpr dbg = 0;
ll constexpr NM = 1.1e5, INF = LONG_LONG_MAX / 4;
struct N {
ll d = INF;
vector<pair<N *, ll>> adj;
};
struct NLess {
bool operator()(N const *l, N const *r) {
if (l->d != r->d)
return l->d < r->d;
else
return l < r;
}
};
ll n;
N p[NM];
N st2[NM * 4], st3[NM * 4];
void init2(ll idx, ll l, ll r) {
auto &cur = st2[idx];
for (ll i = l; i <= r; ++i) cur.adj.push_back({&p[i], 0LL});
if (r > l) {
auto mid = (l + r) / 2;
init2(2 * idx, l, mid);
init2(2 * idx + 1, mid + 1, r);
}
}
void init3(ll idx, ll l, ll r) {
auto &cur = st3[idx];
for (ll i = l; i <= r; ++i) p[i].adj.push_back({&cur, 0LL});
if (r > l) {
auto mid = (l + r) / 2;
init3(2 * idx, l, mid);
init3(2 * idx + 1, mid + 1, r);
}
}
ll ql, qr;
void update(ll s, ll d, ll w) { p[s].adj.push_back({&p[d], w}); }
void update2(ll idx, ll s, ll l, ll r, ll w) {
if (r < ql || l > qr)
return;
else if (l >= ql && r <= qr) {
p[s].adj.push_back({&st2[idx], w});
return;
} else {
auto mid = (l + r) / 2;
update2(2 * idx, s, l, mid, w);
update2(2 * idx + 1, s, mid + 1, r, w);
}
}
void update3(ll idx, ll l, ll r, ll d, ll w) {
if (r < ql || l > qr)
return;
else if (l >= ql && r <= qr) {
st3[idx].adj.push_back({&p[d], w});
return;
} else {
auto mid = (l + r) / 2;
update3(2 * idx, l, mid, d, w);
update3(2 * idx + 1, mid + 1, r, d, w);
}
}
int main() {
if (!dbg) {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
}
ll q, s;
cin >> n >> q >> s;
init2(1, 1, n);
init3(1, 1, n);
for (ll _ = 1; _ <= (ll)(q); ++_) {
ll t, u, v, w;
cin >> t;
if (t == 1) {
cin >> v >> u >> w;
update(v, u, w);
} else {
cin >> v >> ql >> qr >> w;
if (t == 2)
update2(1, v, 1, n, w);
else
update3(1, 1, n, v, w);
}
}
p[s].d = 0;
set<N *, NLess> stn;
stn.insert(&p[s]);
while (!stn.empty()) {
N *c = *stn.begin();
stn.erase(stn.begin());
do {
if (dbg) printf("cur c->d = %lld\n", c->d);
} while (0);
for (auto const &ch : c->adj)
if (c->d + ch.second < ch.first->d) {
ch.first->d = c->d + ch.second;
stn.insert(ch.first);
}
}
for (ll i = 1; i <= (ll)(n); ++i) cout << (p[i].d < INF ? p[i].d : -1) << ' ';
cout << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int f[50005];
int g[1000015];
int a[50005];
struct wen {
int l, r, i;
} w[50005];
int ans[50005];
int cnt;
bool cmp(wen a, wen b) { return (a.r - a.l < b.r - b.l); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &w[i].l, &w[i].r);
w[i].i = i;
}
sort(w + 1, w + m + 1, cmp);
cnt = 1;
for (int i = 1; i <= 1000002; i++) g[i] = g[i - 1] ^ i;
for (int i = 1; i <= n; i++) {
for (int j = 1; j + i - 1 <= n; j++) {
f[j] = ((((f[j]) > (f[j + 1]) ? (f[j]) : (f[j + 1]))) >
((a[j] > a[i + j - 1] ? g[a[j]] ^ g[a[i + j - 1] - 1]
: g[a[i + j - 1]] ^ g[a[j] - 1]))
? (((f[j]) > (f[j + 1]) ? (f[j]) : (f[j + 1])))
: ((a[j] > a[i + j - 1] ? g[a[j]] ^ g[a[i + j - 1] - 1]
: g[a[i + j - 1]] ^ g[a[j] - 1])));
}
while (w[cnt].r - w[cnt].l + 1 == i && cnt <= m) {
ans[w[cnt].i] = f[w[cnt].l];
cnt++;
}
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i, j, k, p, q, o, l, s, t, x, y;
cin >> i >> j >> k;
x = i % k;
y = j % k;
n = i / k;
m = j / k;
if ((x + y) >= k) {
if (x > y) {
cout << n + m + 1 << " " << k - x << "\n";
} else {
cout << n + m + 1 << " " << k - y << "\n";
}
} else {
cout << n + m << " "
<< "0\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, s, f, t;
int main() {
while (cin >> n >> m) {
for (long long i = 0; i < n; ++i) {
cin >> s >> f >> t;
s--;
f--;
long long r = (t / (2 * (m - 1))) * (2 * (m - 1));
long long ans;
if (f > s) {
if (t % (2 * (m - 1)) > s)
ans = r + 2 * (m - 1) + f;
else
ans = r + f;
} else if (f < s) {
if (t % (2 * (m - 1)) <= 2 * (m - 1) - s)
ans = r + 2 * (m - 1) - f;
else
ans = r + 4 * (m - 1) - f;
} else
ans = t;
cout << ans << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long P = 127;
const unsigned long long Q = 480314964;
const unsigned long long R = 1000000007;
const int MAXN = 300014;
const int K = 19;
unsigned long long U[MAXN];
int clz[1 << K];
int N, M;
char S[MAXN];
vector<int> adj[MAXN];
int dep[MAXN];
int par[K][MAXN];
unsigned long long up[MAXN], dn[MAXN];
int far[MAXN], lc[MAXN];
int *id[MAXN], ch[MAXN];
int path[2 * MAXN], *ptr = path;
void dfs(int v, int p, int d) {
dep[v] = d;
par[0][v] = p;
up[v] = (P * up[p] + S[v]) % R;
dn[v] = (Q * dn[p] + S[v]) % R;
far[v] = 1;
for (int n : adj[v]) {
if (n == p) continue;
dfs(n, v, d + 1);
if (far[n] + 1 > far[v]) {
lc[v] = n;
far[v] = far[n] + 1;
}
}
ch[lc[v]] = 1;
}
inline int jump(int a, int d) {
if (d == 0) return a;
int k = clz[d];
a = par[k][a];
d ^= 1 << k;
return id[a][-d];
}
inline int lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
a = jump(a, dep[a] - dep[b]);
if (a == b) return a;
for (int i = K - 1; i >= 0; i--) {
if (par[i][a] != par[i][b]) {
a = par[i][a];
b = par[i][b];
}
}
return par[0][a];
}
inline unsigned long long get(int a, int b, int l, int k) {
if (k <= dep[a] - dep[l]) {
int v = jump(a, k);
return (up[a] - U[k] * up[v] % R + R) % R;
} else {
int da = dep[a] - dep[l];
int db = dep[b] - dep[l];
int v = jump(b, da + db + 1 - k);
int dv = dep[v] - dep[l];
unsigned long long up_hash = (up[a] - U[da] * up[l] % R + R) % R;
unsigned long long dn_hash = (U[dv] * dn[v] % R - dn[l] + R) % R;
return (up_hash + U[da] * (S[l] + dn_hash)) % R;
}
}
void init() {
U[0] = 1;
for (int i = 0; i < MAXN; i++) {
U[i + 1] = P * U[i] % R;
clz[i] = 31 - __builtin_clz(i);
}
}
void build() {
scanf("%d%s", &N, S + 1);
for (int i = 1; i < N; i++) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
dep[0] = -1;
dfs(1, 0, 0);
for (int i = 0; i + 1 < K; i++) {
for (int j = 1; j <= N; j++) {
par[i + 1][j] = par[i][par[i][j]];
}
}
for (int i = 1; i <= N; i++) {
if (!ch[i]) {
int u = par[0][i], v = i;
int k = min(dep[i], far[i]);
for (int j = 1; j <= k; j++) {
ptr[k - j] = u;
u = par[0][u];
}
ptr += k;
while (v > 0) {
id[v] = ptr;
*ptr++ = v;
v = lc[v];
}
}
}
}
void solve() {
scanf("%d", &M);
for (int i = 0; i < M; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int l = lca(a, b), m = lca(c, d);
int u = dep[a] + dep[b] - 2 * dep[l] + 1;
int v = dep[c] + dep[d] - 2 * dep[m] + 1;
int lo = 0, hi = min(u, v) + 1;
while (lo + 1 < hi) {
int mid = (lo + hi) / 2;
unsigned long long g = get(a, b, l, mid);
unsigned long long h = get(c, d, m, mid);
(g == h ? lo : hi) = mid;
}
printf("%d\n", lo);
}
}
int main() {
init();
build();
solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
bool adj[27][27];
bool vis[27];
void dfs(int x, vector<int> &v) {
vis[x] = 1;
v.push_back(x);
for (int i = 0; i < 27; i++) {
if (i != x && adj[i][x] && !vis[i]) dfs(i, v);
}
}
vector<vector<int> > vv;
int main() {
int n;
scanf("%d", &n);
cin >> a >> b;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
int v1 = a[i] - 'a';
int v2 = b[i] - 'a';
adj[v1][v2] = 1;
adj[v2][v1] = 1;
}
}
vv.clear();
for (int i = 0; i < 27; i++) {
if (!vis[i]) {
vector<int> v;
dfs(i, v);
vv.push_back(v);
}
}
vector<pair<char, char> > ans;
for (int i = 0; i < ((int)(vv).size()); i++) {
if (((int)(vv[i]).size()) > 1) {
int x = vv[i][0];
for (int j = 1; j < ((int)(vv[i]).size()); j++) {
ans.push_back({x + 'a', vv[i][j] + 'a'});
}
}
}
cout << ((int)(ans).size()) << "\n";
for (int i = 0; i < ((int)(ans).size()); i++) {
putchar(ans[i].first);
putchar(' ');
putchar(ans[i].second);
putchar('\n');
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
int n, m;
pair<long long int, long long int> ar[200005];
int getR(int s, long long int l) {
int lb = s, ub = n;
while (ub - lb > 1) {
int md = (lb + ub) >> 1;
if (ar[md].first - ar[s].first > l)
ub = md;
else
lb = md;
}
return lb;
}
int getL(int s, long long int l) {
int lb = -1, ub = s;
while (ub - lb > 1) {
int md = (lb + ub) >> 1;
if (ar[s].first - ar[md].first > l)
lb = md;
else
ub = md;
}
return ub;
}
int conv[200005];
int main() {
cin >> n >> m;
for (int i = 0; i < (n); ++i) {
int a;
scanf("%d", &a);
ar[i].first = a;
ar[i].second = i;
}
sort(ar, ar + n);
for (int i = 0; i < (n); ++i) conv[ar[i].second] = i;
for (int hoge = 0; hoge < (m); ++hoge) {
int s, l_;
scanf("%d%d", &s, &l_);
--s;
s = conv[s];
long long int l = l_;
int t1 = getR(s, l);
l -= ar[t1].first - ar[s].first;
int t2 = getL(t1, l);
l -= ar[t1].first - ar[t2].first;
s = t2;
while (1) {
int pivR = getR(s, l);
long long int l2 = l - (ar[pivR].first - ar[s].first);
int pivL = getL(pivR, l2);
if (pivR == s) break;
if (pivL == pivR) {
s = pivR;
break;
}
if (pivL == s) {
long long int length = (ar[pivR].first - ar[s].first) * 2;
l %= length;
} else {
s = pivL;
l = l2 - (ar[pivR].first - ar[pivL].first);
}
}
printf("%d\n", (int)(ar[s].second + 1));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, v;
cin >> n >> k >> v;
int arr[n];
long long sum = 0;
for (int i = 0; i != n; ++i) {
cin >> arr[i];
sum += arr[i];
}
if (sum < v) {
cout << "NO\n";
return 0;
}
vector<int> all[k];
for (int i = 0; i != n; ++i) {
set<int> kehe;
for (int j = 1; j != k; ++j) {
if (all[j].empty() || kehe.count(j)) continue;
int next = (arr[i] + j) % k;
if (all[next].size() > 0) continue;
kehe.insert(next);
vector<int> zxc;
for (int y : all[j]) zxc.push_back(y);
zxc.push_back(i);
all[next] = zxc;
}
int next = arr[i] % k;
if (!all[next].empty()) continue;
all[next] = vector<int>{i};
}
if (!all[v % k].empty() || (v % k) == 0) {
int i = v % k;
cout << "YES\n";
long long cursum = 0;
set<int> tmppp;
for (int x : all[i]) {
cursum += arr[x];
tmppp.insert(x);
}
vector<int> leff;
for (int j = 0; j != n; ++j)
if (tmppp.count(j) == 0) leff.push_back(j);
for (int j = 1; j < (int)all[i].size(); ++j) {
int z = (arr[all[i][j]] + k - 1) / k;
if (z > 0)
cout << z << " " << all[i][j] + 1 << " " << all[i][0] + 1 << "\n";
}
for (int j = 1; j < (int)leff.size(); ++j) {
int z = (arr[leff[j]] + k - 1) / k;
if (z > 0) cout << z << " " << leff[j] + 1 << " " << leff[0] + 1 << "\n";
}
if (cursum < v) {
int target = all[i].empty() ? leff[1] + 1 : all[i][0] + 1;
cout << (v - cursum) / k << " " << leff[0] + 1 << " " << target << "\n";
} else if (cursum > v) {
int target = leff.empty() ? all[i][1] + 1 : leff[0] + 1;
cout << (cursum - v) / k << " " << all[i][0] + 1 << " " << target << "\n";
}
return 0;
}
cout << "NO\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a;
int k[3], t[3];
long long tempo[4][100001];
int main() {
scanf("%d %d %d", &k[0], &k[1], &k[2]);
scanf("%d %d %d", &t[0], &t[1], &t[2]);
scanf("%d", &n);
for (int i = 0; i < 3; i++) {
if (k[i] > n) k[i] = n;
}
for (int i = 0; i < n; i++) {
scanf("%d", &a);
tempo[0][i] = a;
}
for (int z = 0; z < 3; z++) {
for (int i = 0; i < n; i++) {
if (i < k[z])
tempo[z + 1][i] = tempo[z][i] + t[z];
else if (tempo[z][i] >= tempo[z + 1][i - k[z]])
tempo[z + 1][i] = tempo[z][i] + t[z];
else
tempo[z + 1][i] = tempo[z + 1][i - k[z]] + t[z];
}
}
long long resp = 0;
for (int i = 0; i < n; i++) {
if (tempo[3][i] - tempo[0][i] > resp) resp = tempo[3][i] - tempo[0][i];
}
printf("%I64d\n", resp);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
const int maxn = 2e5 + 100;
const int mod = 1e9 + 7;
const int N = 1010;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int temp;
cin >> temp;
while (temp--) {
int n;
cin >> n;
string s;
cin >> s;
int num = n / 2;
if (s.find('0') == -1) {
cout << 1 << ' ' << num << ' ' << 2 << ' ' << num + 1 << '\n';
} else {
int pos = s.find('0', 0) + 1;
if (pos == num) {
long long ppp = (int)s.find('0', pos);
if (ppp == -1 and num != 1)
cout << 1 << ' ' << num << ' ' << num << ' ' << num + num - 1 << '\n';
else if (ppp == -1 and num == 1)
cout << 1 << ' ' << n << ' ' << 2 << ' ' << n << '\n';
else {
ppp++;
cout << 1 << ' ' << ppp << ' ' << 1 << ' ' << ppp - 1 << '\n';
}
} else if (pos > num) {
cout << 1 << ' ' << pos << ' ' << 1 << ' ' << pos - 1 << '\n';
} else if (pos < num) {
cout << pos << ' ' << n << ' ' << pos + 1 << ' ' << n << '\n';
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
const long long INF = 2e18;
int n;
long long a[N], b[N], c;
bool flag = true;
int len(long long x) {
int res = 0;
while (x > 1) {
x /= 10;
res++;
}
return res;
}
int check(long long x) {
long long res = 0;
for (int i = 0; i < n; i++) {
if (len(a[i]) + len(x) >= 19) return 1;
res += a[i] * x / b[i];
if (res > c - n) return 1;
}
if (res < c - n) return -1;
return 0;
}
int main() {
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
flag &= a[i] == 0;
}
if (c < n) return cout << 0, 0;
if (flag && c == n) return cout << -1, 0;
long long l = 1, r = INF;
while (l < r) {
long long m = (l + r) / 2;
if (check(m) == -1)
l = m + 1;
else
r = m;
}
long long lpos = l;
l = 1, r = INF;
while (l < r) {
long long m = (l + r) / 2;
if (check(m) != 1)
l = m + 1;
else
r = m;
}
cout << l - lpos;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long> b = {}, c = {};
long e;
vector<vector<long>> d = {};
void dfs(long v) {
b[v - 1] = 1;
c.push_back(v);
e++;
for (long i = 1; i <= d[v - 1][0]; i++) {
if (!b[d[v - 1][i] - 1]) {
dfs(d[v - 1][i]);
}
}
}
int main() {
long n, m, a = 0, u, v, f = 0;
cin >> n >> m;
for (long i = 0; i < n; i++) {
b.push_back(0);
d.push_back({0});
}
for (long i = 0; i < m; i++) {
cin >> u >> v;
d[u - 1][0]++;
d[u - 1].push_back(v);
d[v - 1][0]++;
d[v - 1].push_back(u);
}
for (long i = 0; i < n; i++) {
if (!b[i]) {
c = {};
e = 0;
dfs(i + 1);
f = 0;
for (long j = 0; j < e; j++) {
f += d[c[j] - 1][0];
}
if (e - f / 2 > 0) {
a += e - f / 2;
}
}
}
cout << a;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ok[11];
string M[11];
long long solve(int pos, int x = 0) {
if (pos >= n) {
for (int j = 0; j < m; j++)
if (ok[j] != 0) return 0;
return 1;
}
long long ats = 0;
for (int d = 0; d < 2; d++) {
bool can = 1;
for (int j = 0; j < m; j++)
if (M[j][pos] - '0' == d && ok[j] <= 0) can = 0;
if (can) {
for (int j = 0; j < m; j++)
if (M[j][pos] - '0' == d) ok[j]--;
ats += solve(pos + 1, 2 * x + d);
for (int j = 0; j < m; j++)
if (M[j][pos] - '0' == d) ok[j]++;
}
}
return ats;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> M[i] >> ok[i];
cout << solve(0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long tmp = 2 * (n + k);
for (long long i = 1; i * i <= tmp; i++) {
if (tmp % i == 0) {
long long j = tmp / i;
if (j - i == 3) {
long long t = min(i, j);
cout << n - i;
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
double t1 = clock();
long long t;
t = 1;
for (long long i = 1; i <= t; i++) {
solve();
}
cerr << setprecision(10) << (clock() - t1) / CLOCKS_PER_SEC << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Number {
array<int, 4> x = {{0, 0, 0, 0}};
Number() {}
Number(int a) {
if (a != -1) x[a]++;
}
long double log_value() const {
if (x[0] > 0) return -INFINITY;
return x[2] * log(2L) + x[3] * log(3L);
}
int mod() const {
long long result = 1;
for (int i = 0; i < 4; i++)
for (int j = 0; j < x[i]; j++) result = (result * i) % (int)(1e9 + 7);
return result;
}
bool is_zero() const { return x[0] > 0; }
};
bool operator<(const Number& a, const Number& b) {
return a.log_value() < b.log_value();
}
Number operator*(const Number& a, const Number& b) {
Number result;
for (int i = 0; i < 4; i++) result.x[i] = a.x[i] + b.x[i];
return result;
}
Number operator/(const Number& a, const Number& b) {
Number result;
for (int i = 0; i < 4; i++) result.x[i] = a.x[i] - b.x[i];
return result;
}
template <typename T>
using Matrix = vector<vector<T>>;
template <typename T>
Matrix<T> matrix(int R, int C, T x = T()) {
return Matrix<T>(R, vector<T>(C, x));
}
struct RangeProduct {
int N;
Matrix<int> grid;
Matrix<Number> hprod;
Matrix<Number> vprod;
bool valid(int r, int c) { return 0 <= r && r < N && 0 <= c && c < N; }
RangeProduct(int N, Matrix<int> grid) : N(N), grid(grid) {
hprod = matrix<Number>(N + 1, N + 1);
vprod = matrix<Number>(N + 1, N + 1);
for (int r = 0; r < N; r++)
for (int c = 0; c < N; c++) {
hprod[r][c + 1] = hprod[r][c] * Number(grid[r][c]);
vprod[r + 1][c] = vprod[r][c] * Number(grid[r][c]);
}
}
Number hquery(int r, int c, int radius) {
int c1 = c - radius, c2 = c + radius;
if (!valid(r, c1) || !valid(r, c2)) return Number(0);
return hprod[r][c2 + 1] / hprod[r][c1];
}
Number vquery(int r, int c, int radius) {
int r1 = r - radius, r2 = r + radius;
if (!valid(r1, c) || !valid(r2, c)) return Number(0);
return vprod[r2 + 1][c] / vprod[r1][c];
}
Number cross(int r, int c, int radius) {
return hquery(r, c, radius) * vquery(r, c, radius) / Number(grid[r][c]);
}
Number max_cross(int r, int c) {
int a = 0, b = N;
while (a < b) {
int mid = (a + b + 1) / 2;
if (cross(r, c, mid).is_zero())
b = mid - 1;
else
a = mid;
}
return cross(r, c, a);
}
};
Number solve(int N, Matrix<int> grid) {
RangeProduct rp(N, grid);
Number result(0);
for (int r = 0; r < N; r++)
for (int c = 0; c < N; c++) result = max(result, rp.max_cross(r, c));
return result;
}
Matrix<int> rotate(int N, const Matrix<int>& grid, int shift) {
auto ngrid = matrix<int>(N, N);
for (int r = 0; r < N; r++)
for (int c = 0; c < N; c++)
if ((r + c) % 2 == shift)
ngrid[(r + c) / 2][(r - c + N) / 2] = grid[r][c];
return ngrid;
}
int main() {
int N;
cin >> N;
auto grid = matrix<int>(N, N);
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 0; j < N; j++) grid[i][j] = s[j] - '0';
}
auto rgrid0 = rotate(N, grid, 0);
auto rgrid1 = rotate(N, grid, 1);
Number answer = max({solve(N, grid), solve(N, rgrid0), solve(N, rgrid1)});
cout << answer.mod() << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, t, mx, a[105], C[105][105], sum, cnt[105], ans = 1, mod = 1e6 + 7;
map<pair<int, int>, int> dp, pre;
int inline read() {
int res = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); res *= 10, res += c ^ 48, c = getchar())
;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
n = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
sum += a[i];
mx = max(mx, a[i]);
++cnt[a[i]];
}
for (int i = 0; i <= n; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j <= i - 1; ++j) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1] % mod;
}
}
pre[make_pair(0, 0)] = 1;
for (int i = 1; i <= n; ++i) {
dp = pre;
for (__typeof(pre.begin()) it = pre.begin(); it != pre.end(); ++it) {
pair<int, int> cur =
make_pair(it->first.first + a[i], it->first.second + 1);
dp[cur] += it->second;
dp[cur] %= mod;
}
pre = dp;
}
for (int i = 1; i <= 100; ++i) {
t += (bool)(cnt[i]);
}
if (t == 2 || t == 1) {
cout << n << '\n';
return 0;
}
for (int i = 1; i <= mx; ++i) {
for (int j = 2; j <= cnt[i]; ++j) {
if (dp[make_pair(i * j, j)] == C[cnt[i]][j]) {
ans = max(ans, j);
}
}
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<int, int, greater<int>> input;
map<int, int, greater<int>> output;
map<int, int, greater<int>> input_reverse;
map<int, int, greater<int>> output_reverse;
int N;
scanf("%d", &N);
;
int i = N;
int index = 1;
while (i--) {
int x;
scanf("%d", &x);
input[index] = x;
input_reverse[x] = index;
index++;
}
index = 1;
while (N--) {
int x;
scanf("%d", &x);
output[index] = x;
output_reverse[x] = index;
index++;
}
map<int, int, greater<int>>::iterator it1;
int val = 0;
int count_val = 0;
it1 = input.begin();
while (!input.empty()) {
if ((*it1).second != (*(output.begin())).second) {
val = val + count_val;
val++;
count_val = 0;
} else {
count_val++;
}
int x = (*it1).second;
it1++;
input.erase((*(input_reverse.find(x))).second);
output.erase((*(output_reverse.find(x))).second);
}
printf("%d\n", val);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, h;
double p;
int x[2020];
double dp[2020][2020][2][2];
bool vis[2020][2020][2][2];
int L[2020], R[2020];
double calc(double l, double r, double ll, double rr) {
l = max(l, ll);
r = min(r, rr);
if (l > r) return 0;
return r - l;
}
double f(int l, int r, int a, int b) {
if (l > r) return 0;
if (vis[l][r][a][b]) return dp[l][r][a][b];
vis[l][r][a][b] = 1;
double &ret = dp[l][r][a][b];
double ll = x[l - 1], rr = x[r + 1];
if (a == 1) ll += h;
if (b == 0) rr -= h;
ret = 0;
ret += 0.5 * p * (f(l + 1, r, 0, b) + calc(ll, rr, x[l] - h, x[l]));
ret += 0.5 * (1 - p) * (f(l, r - 1, a, 1) + calc(ll, rr, x[r], x[r] + h));
if (R[l] >= r)
ret += 0.5 * (1 - p) * calc(x[l], x[r] + h, ll, rr);
else
ret += 0.5 * (1 - p) * (f(R[l] + 1, r, 1, b) + x[R[l]] - x[l] + h);
if (L[r] <= l)
ret += 0.5 * p * calc(x[l] - h, x[r], ll, rr);
else
ret += 0.5 * p * (f(l, L[r] - 1, a, 0) + x[r] - x[L[r]] + h);
return ret;
}
int main() {
scanf("%d%d", &n, &h);
scanf("%lf", &p);
for (int i = 1; i <= n; ++i) {
scanf("%d", &x[i]);
}
sort(x + 1, x + n + 1);
x[0] = -0x3f3f3f3f, x[n + 1] = 0x3f3f3f3f;
for (int i = n; i >= 1; --i) {
if (x[i + 1] - x[i] < h)
R[i] = R[i + 1];
else
R[i] = i;
}
for (int i = 1; i <= n; ++i) {
if (x[i] - x[i - 1] < h)
L[i] = L[i - 1];
else
L[i] = i;
}
printf("%.12lf\n", f(1, n, 0, 0));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
stack<int> s1;
int ans = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '[' || s[i] == '(' || s[i] == '<' || s[i] == '{') {
s1.push(s[i]);
} else {
if (s1.size() == 0) {
cout << "Impossible";
return 0;
} else {
char x = s1.top();
s1.pop();
if ((s[i] == ']' && x != '[') || (s[i] == ')' && x != '(') ||
(s[i] == '}' && x != '{') || (s[i] == '>' && x != '<')) {
ans++;
}
}
}
}
if (!s1.empty()) {
cout << "Impossible";
return 0;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, q;
long long a[N], b[N], c[N];
long long dpa[N][50], dpi[N][50];
void rmq_init() {
for (int i = 1; i <= n; i++) {
dpi[i][0] = c[i];
dpa[i][0] = c[i];
}
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
dpi[i][j] = min(dpi[i][j - 1], dpi[i + (1 << j - 1)][j - 1]);
dpa[i][j] = max(dpa[i][j - 1], dpa[i + (1 << j - 1)][j - 1]);
}
}
long long rmq_min(int l, int r) {
int k = 0;
while ((1 << (k + 1)) <= r - l + 1) k++;
return min(dpi[l][k], dpi[r - (1 << k) + 1][k]);
}
long long rmq_max(int l, int r) {
int k = 0;
while ((1 << (k + 1)) <= r - l + 1) k++;
return max(dpa[l][k], dpa[r - (1 << k) + 1][k]);
}
void add(int pos, int x) {
for (; pos <= n; pos += (pos & -pos)) {
c[pos] += x;
}
}
long long get(int pos) {
long long ans = 0;
while (pos > 0) {
ans += c[pos];
pos -= (pos & -pos);
}
return ans;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", b + i);
c[i] = c[i - 1] + a[i] - b[i];
}
rmq_init();
int l, r;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
long long tmp = c[l - 1];
if (c[r] != tmp || rmq_max(l, r) > tmp) {
printf("-1\n");
} else {
printf("%lld\n", tmp - rmq_min(l, r));
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n;
cin >> n;
vector<long long> arr(n + 1);
long long sum = 0;
for (long long i = 1; i < n + 1; i++) {
cin >> arr[i];
sum += arr[i];
}
long long maxSoFar = 0, maximimum = 0;
for (long long i = 1; i < n + 1; i++) {
maxSoFar += arr[i];
if (maxSoFar < 0) {
maxSoFar = 0;
}
maximimum = max(maximimum, maxSoFar);
}
long long ans = (2 * maximimum) - sum;
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
const int maxnode = 500 + 5;
long long s[maxn];
map<long long, int> mp;
vector<pair<long long, int> > vec;
long long fuck[maxn];
long long su[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, q;
long long l, r, gp;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
sort(s + 1, s + 1 + n);
for (int i = 1; i < n; i++) {
mp[s[i + 1] - s[i]]++;
}
for (map<long long, int>::iterator it = mp.begin(); it != mp.end(); it++) {
vec.push_back(make_pair(it->first, it->second));
}
int len = vec.size();
for (int i = 0; i < len; i++) {
fuck[i] = (i ? fuck[i - 1] : 0) + vec[i].second;
su[i] = (i ? su[i - 1] : 0) + vec[i].first * vec[i].second;
}
cin >> q;
int pos;
while (q--) {
cin >> l >> r;
gp = r - l + 1;
pos =
(upper_bound(vec.begin(), vec.end(), make_pair(gp, 1)) - vec.begin()) -
1;
if (pos == -1) {
cout << (1LL * n * gp) << " ";
continue;
}
if (pos >= len - 1) pos = len - 1;
cout << (1LL * (n - fuck[pos]) * gp + su[pos]) << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int go[51][4];
char S[51][51];
int get_type(char c) {
if (isdigit(c)) return 1;
if ('a' <= c && c <= 'z') return 2;
if (strchr("#*&", c)) return 3;
return 0;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%s", S[i]);
for (int j = 0; j < 4; j++) go[i][j] = 200;
for (int j = 0; j < M; j++) {
int d = min(j, M - j);
int t = get_type(S[i][j]);
go[i][t] = min(go[i][t], d);
}
}
int ans = 600;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
for (int k = 1; k <= N; k++) {
if (i == j || j == k || k == i) continue;
int v = min(ans, go[i][1] + go[j][2] + go[k][3]);
ans = min(ans, v);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 7;
const int MOD = 998244353;
int t;
int n;
vector<int> G[MAX];
int f[MAX], k;
bool dfs(int u, int fa) {
f[u] = 0;
if (u != 1 && G[u].size() == 1) return true;
for (auto v : G[u]) {
if (v == fa) continue;
if (dfs(v, u)) f[u]++;
}
if (fa && f[u] % k != 0) {
f[u]++;
return false;
}
return true;
}
int qw[MAX];
int ans[MAX];
int main() {
ios::sync_with_stdio(false), cin.tie(NULL);
qw[0] = 1;
for (int i = 1; i <= 100000; i++) qw[i] = qw[i - 1] * 2 % MOD;
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++) G[i].clear(), ans[i] = 0;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v), G[v].push_back(u);
}
ans[1] = qw[n - 1];
for (int i = 2; i < n; i++) {
if ((n - 1) % i != 0) continue;
k = i;
dfs(1, 0);
int fg = 0;
for (int j = 1; j <= n; j++)
if (f[j] % i) {
fg = 1;
break;
}
if (!fg) ans[i]++;
}
for (int i = n; i >= 1; i--) {
for (int j = 2 * i; j <= n; j += i) ans[i] -= ans[j];
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
inline int sbt(int x) { return __builtin_popcount(x); }
using namespace std;
long long int a[500007 + 5], n, m, res;
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
int j = 1;
res = n;
for (int i = (n / 2) + 1; i <= n; i++) {
if (j > n / 2) break;
if (a[i] >= 2 * a[j]) {
res--;
j++;
}
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct mat {
long long x[105][105];
long long n;
long long m;
void print() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << x[i][j] << " ";
}
cout << endl;
}
}
void setnm(int N, int M) {
n = N;
m = M;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
x[i][j] = 0;
}
}
}
};
mat mul(mat x, mat t) {
mat res;
res.setnm(x.n, t.m);
for (int i = 1; i <= x.n; i++) {
for (int j = 1; j <= t.m; j++) {
for (int k = 1; k <= x.m; k++) {
res.x[i][j] += x.x[i][k] * t.x[k][j];
res.x[i][j] %= 1000000007;
}
}
}
return res;
}
int n, x;
mat a;
int d[100005];
int cnt[105];
mat b;
void Calc100() {
a.n = 1;
a.m = 101;
a.x[1][0] = 1;
a.x[1][101] = 1;
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= i; j++) {
a.x[1][i] += cnt[j] * a.x[1][i - j];
a.x[1][i] %= 1000000007;
}
a.x[1][101] += a.x[1][i];
a.x[1][101] %= 1000000007;
}
}
mat xx;
mat fastPow(mat t, int b) {
mat ret;
ret.setnm(101, 101);
for (int i = 1; i <= 101; i++)
for (int j = 1; j <= 101; j++)
if (i == j)
ret.x[i][j] = 1;
else
ret.x[i][j] = 0;
while (b > 0) {
if (b % 2 == 1) ret = mul(ret, t);
b >>= 1;
t = mul(t, t);
}
return ret;
}
int main() {
scanf("%d %d", &n, &x);
for (int i = 1; i <= n; i++) {
scanf("%d", &d[i]);
cnt[d[i]]++;
}
Calc100();
b.n = 101;
b.m = 101;
for (int i = 1; i <= 101; i++)
for (int j = 1; j <= 101; j++) {
if (i == j + 1) b.x[i][j] = 1;
if (j == 100) b.x[i][j] = cnt[101 - i];
if (j == 101) b.x[i][j] = cnt[101 - i];
if (j == 101 && i == 101) b.x[i][j] = 1;
}
if (x <= 100) {
long long ret = 1;
for (int i = 1; i <= x; i++) {
ret += a.x[1][i];
ret %= 1000000007;
}
printf("%lld\n", ret);
} else {
b = fastPow(b, x - 100);
a = mul(a, b);
printf("%lld\n", a.x[1][101]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void input() {
if (fopen("BACHO.inp", "r")) {
freopen("BACHO.inp", "r", stdin);
freopen("BACHO.out", "w", stdout);
} else if (fopen("BACHO.in", "r")) {
freopen("BACHO.in", "r", stdin);
freopen("BACHO.out", "w", stdout);
} else if (fopen("tenbai"
".inp",
"r")) {
freopen(
"tenbai"
".inp",
"r", stdin);
freopen(
"tenbai"
".out",
"w", stdout);
} else if (fopen("tenbai"
".in",
"r")) {
freopen(
"tenbai"
".in",
"r", stdin);
freopen(
"tenbai"
".out",
"w", stdout);
}
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
const int maxn = 2e2 + 5, mod = 1e9 + 7, oo = 1061109567, maxv = 1e9 + 5;
const double pi = atan2(0, -1);
int t, n, k, x[maxn], y[maxn];
bool check[maxn];
void solve() {
cin >> n >> k;
int d = (n - k) * (n - k - 1) / 2;
bool kt = false;
int cnt = 0;
memset(check, 0, sizeof(check));
for (int i = 0; i < k; ++i) {
cin >> x[i] >> y[i];
for (int j = 1; j <= n; ++j) {
if (j == 10) break;
++cnt;
}
if (x[i] > y[i])
swap(x[i], y[i]);
else {
kt = false;
--cnt;
}
check[x[i]] = 1;
check[y[i]] = 1;
for (int j = 0; j < i; ++j) {
if (kt)
return;
else
++cnt;
d += (x[i] < x[j]) && (x[j] < y[i]) && (y[i] < y[j]) ||
(x[j] < x[i]) && (x[i] < y[j]) && (y[j] < y[i]);
}
}
for (int i = 0; i < k; ++i) {
int a = 0;
for (int j = x[i] + 1; j < y[i]; ++j) a += !check[j];
if (kt)
return;
else
--cnt;
d += min(a, n + n - k - k - a);
}
cout << d << "\n";
if (kt)
return;
else {
--cnt;
return;
}
}
int32_t main() {
input();
fastio();
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int ans[100005];
void dfs(int v) {
if (v == n) {
bool flag = true;
for (int i = 1; i <= k; i++) {
bool flag2 = false;
for (int j = 0; j <= n - i; j++) {
bool flag3 = true;
for (int l = 0; l <= n - i; l++) {
if (j == l) continue;
bool sa = true;
for (int m = 0; m < i; m++) {
if (ans[j + m] != ans[l + m]) sa = false;
}
if (sa) {
flag3 = false;
}
}
if (flag3) {
flag2 = true;
}
}
if (i < k && flag2) return;
if (i == k && !flag2) return;
}
for (int i = 0; i < n; i++) {
printf("%d", ans[i]);
}
printf("\n");
} else {
ans[v] = 0;
dfs(v + 1);
ans[v] = 1;
dfs(v + 1);
}
}
int main(void) {
scanf("%d%d", &n, &k);
int cn = (n - k) / 2;
for (int i = 0; i < n; i++) {
if (i % (cn + 1) == cn)
ans[i] = 1;
else {
ans[i] = 0;
}
}
for (int i = 0; i < n; i++) {
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s;
int e = s.size();
int c = 0;
int m = 1;
int n = (int)s[0];
if (n < 123 && n > 96) {
while (m < e) {
int k = (int)s[m];
if (k < 91 && k > 64) {
c = 1;
} else {
c = 0;
break;
}
m++;
}
}
int y = 0;
while (y < e) {
int k = (int)s[y];
if (k < 91 && k > 64) {
c = 2;
} else if (c == 1) {
break;
} else {
c = 0;
break;
}
y++;
}
int j = (int)s[0];
if (c == 0 && e != 1) {
cout << s;
} else if (e == 1 && j > 96 && j < 123) {
s[0] = toupper(s[0]);
cout << s;
} else if (c == 1) {
s[0] = toupper(s[0]);
for (int i = 1; i < s.size(); i++) {
s[i] = tolower(s[i]);
}
cout << s;
} else if (c == 2) {
for (int i = 0; i < e; i++) {
s[i] = tolower(s[i]);
}
cout << s;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace ::std;
const long double PI = acos(-1);
const long long MOD = 1000000000 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long add(long long a, long long b, long long m = MOD) {
if (a >= m) a %= m;
if (b >= m) b %= m;
if (a < 0) a += m;
if (b < 0) b += m;
long long res = a + b;
if (res >= m or res <= -m) res %= m;
if (res < 0) res += m;
return res;
}
long long mul(long long a, long long b, long long m = MOD) {
if (a >= m) a %= m;
if (b >= m) b %= m;
if (a < 0) a += m;
if (b < 0) b += m;
long long res = a * b;
if (res >= m or res <= -m) res %= m;
if (res < 0) res += m;
return res;
}
long long pow_mod(long long a, long long b, long long m = MOD) {
long long res = 1LL;
a = a % m;
while (b) {
if (b & 1) res = mul(res, a, m);
b >>= 1;
a = mul(a, a, m);
}
return res;
}
long long fastexp(long long a, long long b) {
long long res = 1LL;
while (b) {
if (b & 1) {
res = res * a;
}
b >>= 1;
a *= a;
}
return res;
}
int gcdExtendido(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtendido(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
int modInverso(int a, int m) {
int x, y;
int g = gcdExtendido(a, m, &x, &y);
if (g != 1)
return -1;
else
return (x % m + m) % m;
}
const int N = 1000 + 5;
const int SUML = 1000000 + 5;
int n;
int a[N];
int id[SUML];
int nodes = 1;
string ans[N];
int trie[SUML][3];
bool blocked[SUML];
bool insert(int len, int p) {
int pos = 0;
vector<int> positions;
for (int i = 0; i < len; i++) {
int nxt = 0;
if (trie[pos][nxt] and (id[trie[pos][nxt]] or blocked[trie[pos][nxt]]))
nxt = 1;
if (trie[pos][nxt] and (id[trie[pos][nxt]] or blocked[trie[pos][nxt]])) {
return false;
}
if (trie[pos][nxt] == 0) trie[pos][nxt] = nodes++;
positions.emplace_back(pos);
pos = trie[pos][nxt];
}
id[pos] = p;
blocked[pos] = true;
for (int i = positions.size() - 1; i >= 0; i--) {
int x = positions[i];
if (trie[x][0] and trie[x][1] and blocked[trie[x][0]] and
blocked[trie[x][1]]) {
blocked[x] = true;
}
}
return true;
}
void DFS(int u, string &s) {
if (id[u]) {
ans[id[u]] = s;
}
for (int i = 0; i < 2; i++) {
if (trie[u][i]) {
s.push_back('0' + i);
DFS(trie[u][i], s);
s.pop_back();
}
}
}
int main() {
scanf("%d", &(n));
vector<int> p(n);
for (int i = 1; i <= n; i++) {
scanf("%d", &(a[i]));
p[i - 1] = i;
}
sort((p).begin(), (p).end(), [&](int i, int j) { return a[i] < a[j]; });
bool can = true;
for (auto x : p) {
if (!insert(a[x], x)) {
can = false;
}
}
if (!can) {
puts("NO");
return 0;
}
string s = "";
DFS(0, s);
puts("YES");
for (int i = 1; i <= n; i++) {
printf("%s\n", ans[i].c_str());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
default_random_engine generator;
uniform_int_distribution<int> distribution(1, INT_MAX);
vector<vector<long long> > one(int sz) {
vector<vector<long long> > ret;
ret.resize(sz);
for (int i = 0; i < ret.size(); i++) {
ret[i].resize(sz);
for (int j = 0; j < ret.size(); j++) {
ret[i][j] = (i == j);
}
}
return ret;
}
vector<vector<long long> > mult(vector<vector<long long> > a,
vector<vector<long long> > b) {
vector<vector<long long> > ret;
ret.resize(a.size());
for (int i = 0; i < ret.size(); i++) {
ret[i].resize(a.size());
for (int j = 0; j < ret.size(); j++) {
ret[i][j] = 0;
}
}
for (int k = 0; k < ret.size(); k++) {
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < b.size(); j++) {
ret[i][j] = (ret[i][j] + a[i][k] * b[k][j]);
ret[i][j] %= 998244353;
}
}
}
return ret;
}
vector<vector<long long> > pw(vector<vector<long long> > a, long long b) {
if (b == 0) return one((int)a.size());
if (b % 2) return mult(a, pw(a, b - 1));
return pw(mult(a, a), b / 2);
}
long long my_rand(long long a = 0, long long b = INT_MAX) {
return a + distribution(generator) % b;
}
inline int mul(int a, int b) { return int(a * 1ll * b % 998244353); }
inline int norm(int a) {
if (a >= 998244353) a -= 998244353;
if (a < 0) a += 998244353;
return a;
}
inline int binPow(int a, int k) {
int ans = 1;
while (k > 0) {
if (k & 1) ans = mul(ans, a);
a = mul(a, a);
k >>= 1;
}
return ans;
}
inline int subtract(int a, int b) { return norm(a - b); }
inline int inv(int a) { return binPow(a, 998244353 - 2); }
long long ceil_int(long long a, long long b) { return a / b + (a % b != 0); }
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int main() {
generator.seed(chrono::system_clock::now().time_since_epoch().count());
cin.sync_with_stdio(false);
cin.tie(0);
int x;
cin >> x;
int cnt = 0;
vector<int> op;
int ok = 0;
do {
int k = x;
int pos = -1;
int j = 0;
while (k > 0) {
if ((k & 1) == 0) {
pos = j;
}
j++;
k >>= 1;
}
if (pos == -1)
break;
else if (cnt % 2 == 0)
op.push_back(pos + 1);
if (cnt % 2 == 0) {
x = x ^ ((1 << (pos + 1)) - 1);
} else {
x++;
}
cnt++;
} while (1);
cout << cnt << endl;
for (int i = 0; i < op.size(); i++) {
cout << op[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct City {
int min_railways;
set<pair<long long, int>> from_paths;
set<pair<long long, int>> from_railways;
bool been_vertices;
long long min_dist;
};
City cities[101000];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = (0); (i) < (101000); (i)++) {
cities[i].min_dist = 10e12;
}
for (int i = (0); (i) < (m); (i)++) {
int u, v, x;
cin >> u >> v >> x;
cities[u].from_paths.insert(make_pair((long long)x, v));
cities[v].from_paths.insert(make_pair((long long)x, u));
}
for (int i = (0); (i) < (k); (i)++) {
int s, y;
cin >> s >> y;
cities[1].from_railways.insert(make_pair((long long)y, s));
cities[s].from_railways.insert(make_pair((long long)y, 1));
}
cities[1].min_dist = 0;
set<pair<long long, int>> prio_queue;
prio_queue.insert(make_pair(0, 1));
while (prio_queue.size() > 0) {
auto popped = *prio_queue.begin();
prio_queue.erase(prio_queue.begin());
for (auto it = cities[popped.second].from_paths.begin();
it != cities[popped.second].from_paths.end(); it++) {
auto to = *it;
long long orig_dist = cities[to.second].min_dist,
suggested_dist = cities[popped.second].min_dist + to.first;
if (orig_dist > suggested_dist) {
cities[to.second].min_dist = suggested_dist;
cities[to.second].min_railways = 0;
cities[to.second].been_vertices = true;
prio_queue.erase(make_pair(orig_dist, to.second));
prio_queue.insert(make_pair(suggested_dist, to.second));
} else if (orig_dist == suggested_dist) {
cities[to.second].been_vertices = true;
}
}
for (auto it = cities[popped.second].from_railways.begin();
it != cities[popped.second].from_railways.end(); it++) {
auto to = *it;
long long orig_dist = cities[to.second].min_dist,
suggested_dist = cities[popped.second].min_dist + to.first;
if (orig_dist > suggested_dist) {
cities[to.second].min_dist = suggested_dist;
cities[to.second].min_railways = 1;
cities[to.second].been_vertices = false;
prio_queue.erase(make_pair(orig_dist, to.second));
prio_queue.insert(make_pair(suggested_dist, to.second));
} else if (orig_dist == suggested_dist) {
cities[to.second].min_railways++;
}
}
}
int needed = 0;
for (int i = (1); (i) < (n + 1); (i)++) {
if (!cities[i].been_vertices && cities[i].min_railways > 0) {
needed++;
}
}
cout << k - needed;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int maxn = 510;
long long dp[2][maxn][maxn];
const long long mod = 1000000007;
char ma[maxn][maxn];
char m2[maxn][maxn];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", ma[i] + 1);
for (int j = 1; j <= m; j++) {
m2[j][i] = ma[i][j];
}
}
if (n > m) {
swap(n, m);
for (int i = 1; i <= n; i++) memcpy(ma[i] + 1, m2[i] + 1, m);
}
int len = (n + m) / 2;
for (int x1 = 1; x1 <= len; x1++) {
int y1 = len + 1 - x1;
for (int xx = 1; xx <= len; xx++) {
int yy = len + 1 - xx;
int x2 = n + 1 - xx;
int y2 = m + 1 - yy;
if (x1 <= x2 && y1 <= y2 && abs(x1 - x2) + abs(y1 - y2) <= 1 &&
ma[x1][y1] == ma[x2][y2]) {
dp[0][x1][x2] = 1;
}
}
}
bool cur = 0;
bool las = 1;
for (int z = len - 1; z >= 1; --z) {
swap(cur, las);
memset(dp[cur], 0, sizeof(dp[cur]));
for (int i = 1; i <= min(n, z); i++) {
int x1 = i;
int y1 = z + 1 - x1;
for (int j = 1; j <= min(n, z); j++) {
int jj = z + 1 - j;
int x2 = n + 1 - j;
int y2 = m + 1 - jj;
if (x1 <= x2 && y1 <= y2 && ma[x1][y1] == ma[x2][y2]) {
if (y1 + 1 <= m && y2 - 1 >= 1 && ma[x1][y1 + 1] == ma[x2][y2 - 1])
dp[cur][x1][x2] += dp[las][x1][x2];
if (y1 + 1 <= m && x2 - 1 >= 1 && ma[x1][y1 + 1] == ma[x2 - 1][y2])
dp[cur][x1][x2] += dp[las][x1][x2 - 1];
if (x1 + 1 <= n && y2 - 1 >= 1 && ma[x1 + 1][y1] == ma[x2][y2 - 1])
dp[cur][x1][x2] += dp[las][x1 + 1][x2];
if (x1 + 1 <= n && x2 - 1 >= 1 && ma[x1 + 1][y1] == ma[x2 - 1][y2])
dp[cur][x1][x2] += dp[las][x1 + 1][x2 - 1];
dp[cur][x1][x2] %= mod;
}
}
}
}
printf("%lld\n", dp[cur][1][n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int di[4] = {1, 0, -1, 0};
const int dj[4] = {0, 1, 0, -1};
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
vector<int> norm(string s) {
vector<int> res;
for (int i = 0; i < int(s.size()); i++) {
int d = int(s.size()) - i - 1;
int v = s[i] - '0';
if (v) {
while (!res.empty() && res.back() == d + 1) {
res.pop_back();
d += 2;
}
res.push_back(d);
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string first, second;
cin >> first >> second;
vector<int> a, b;
a = norm(first);
b = norm(second);
if (a < b) {
cout << "<";
} else if (b < a) {
cout << ">";
} else {
cout << "=";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int isqrt(int n) { return sqrtl(n); }
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
void primeFactors(long long n) {
while (n % 2 == 0) {
cout << 2 << " ";
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
cout << i << " ";
n = n / i;
}
}
if (n > 2) cout << n << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long arr[n];
map<long long, long long> m;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
long long ans = 0;
long long f = 1;
for (long long i = 0; i < n; i++) {
long long u = arr[i] % k;
if (u != 0) {
if (f == 1) {
f = 0;
;
}
m[k - u] += 1;
ans = max(ans, k - u + 1);
}
}
for (auto i : m) {
long long h = k * (i.second - 1) + i.first + 1;
ans = max(ans, h);
}
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double sn = 1e-6;
const int siz = 300005;
int n, m;
int arr[siz], p2[20];
bool ex[300005], bin[300005][19];
int ln = 2, sz = 19;
struct node {
node* ch[2];
};
node* fn = new node();
bool pass[19];
void add(node* nod, int k) {
if (k == -1) {
return;
}
if (nod->ch[pass[k]] == NULL) {
nod->ch[pass[k]] = new node();
}
add(nod->ch[pass[k]], k - 1);
}
int solve(node* nod, int x, int k, int res) {
if (k == -1) return res;
if (nod->ch[bin[x][k]] != NULL)
return solve(nod->ch[bin[x][k]], x, k - 1, res + bin[x][k] * (1 << k));
return solve(nod->ch[!bin[x][k]], x, k - 1, res + (!bin[x][k]) * (1 << k));
}
void binary(int i) {
int in = i;
bool le = (i <= 300000);
for (int j = 18; j >= 0; j--) {
if (p2[j] <= i) {
if (le) bin[in][j] = true;
pass[j] = true;
i -= p2[j];
} else {
pass[j] = false;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
ex[arr[i]] = true;
}
int t = 1;
for (int i = 0; i < 20; i++) {
p2[i] = t;
t *= 2;
}
for (int i = 0; i <= 524287; i++) {
binary(i);
if (i > 300000 || !ex[i]) {
add(fn, sz - 1);
}
}
int in = 0;
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
x ^= in;
printf("%d\n", solve(fn, x, sz - 1, 0) ^ x);
in = x;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, res[101][101], x[101], y[101];
int main() {
cin >> n >> m >> h;
for (int i = (0); i < (m); i++) cin >> x[i];
for (int i = (0); i < (n); i++) cin >> y[i];
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
int a;
cin >> a;
if (a == 0)
cout << "0 ";
else
cout << min(x[j], y[i]) << " ";
}
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes(400005, true);
void sito(int n) {
primes[0] = primes[1] = false;
for (int i = 2; i * i <= n; ++i) {
if (primes[i]) {
for (int j = i * i; j <= n; j += i) {
primes[j] = false;
}
}
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int i, j;
long long T;
long long n, k, x, m, temp;
string s;
int ones = 0, two = 0;
cin >> n;
for (i = 0; i < n; ++i) {
cin >> k;
if (k % 2)
ones++;
else
two++;
}
int sum = 0;
int all = 0;
sito(400005 - 1);
bool p;
for (i = 0; i < n; ++i) {
p = 0;
if (two) {
temp = sum + 2;
if (primes[temp]) {
two--;
sum += 2;
p = 1;
cout << 2 << " ";
}
}
if (ones && p == 0) {
temp = sum + 1;
if (primes[temp]) {
ones--;
sum++;
p = 1;
cout << 1 << " ";
}
}
if (p == 0) {
if (two) {
sum += 2;
two--;
cout << 2 << " ";
} else {
sum++;
ones--;
cout << 1 << " ";
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(8e5 + 10), M = int(2e5) + 200;
int l[M], r[M], a[M], b[M], n, m, c[M], len[M], second[N], A[N];
pair<int, pair<int, int> > p[N];
pair<int, int> pp, t[3 * N];
multiset<pair<int, int> > st;
long long ans;
int lx, rx, nn;
pair<int, int> Max(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first) return a;
return b;
}
void update(int v, int x, int second) {
v += nn - 1;
t[v] = make_pair(x, second);
while (v > 1) {
v /= 2;
t[v] = Max(t[2 * v], t[2 * v + 1]);
}
}
pair<int, int> get_max(int l, int r) {
pair<int, int> res = make_pair(0, 0);
l += nn - 1;
r += nn - 1;
while (l <= r) {
if (l % 2 == 1) res = Max(res, t[l]);
if (r % 2 == 0) res = Max(res, t[r]);
l = (l + 1) / 2, r = (r - 1) / 2;
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
int pn = 0;
int sn = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l[i], &r[i]);
p[++pn] = make_pair(l[i], make_pair(2, i));
p[++pn] = make_pair(r[i], make_pair(3, i));
second[++sn] = l[i];
second[++sn] = r[i];
}
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
p[++pn] = make_pair(b[i], make_pair(1, i));
second[++sn] = a[i];
second[++sn] = b[i];
}
sort(p + 1, p + pn + 1);
int j, x, cur, y;
for (int i = 1; i <= pn; i++) {
j = p[i].second.second;
if (p[i].second.first == 2) {
st.insert(make_pair(p[i].first, j));
}
if (p[i].second.first == 3) {
st.erase(st.find(make_pair(l[j], j)));
}
if (p[i].second.first == 1) {
if (st.size() > 0) {
pp = *(st.begin());
x = pp.first;
y = pp.second;
cur = min(b[j] - a[j], b[j] - x);
if (ans < 1ll * cur * c[j]) {
ans = 1ll * cur * c[j];
lx = y;
rx = j;
}
}
}
}
st.clear();
pn = 0;
for (int i = 1; i <= n; i++) {
p[++pn] = make_pair(l[i], make_pair(1, i));
p[++pn] = make_pair(r[i], make_pair(2, i));
}
for (int i = 1; i <= m; i++) {
p[++pn] = make_pair(a[i], make_pair(3, i));
}
sort(p + 1, p + pn + 1);
reverse(p + 1, p + pn + 1);
for (int i = 1; i <= pn; i++) {
j = p[i].second.second;
if (p[i].second.first == 1) {
st.erase(st.find(make_pair(-r[j], j)));
}
if (p[i].second.first == 2) {
st.insert(make_pair(-p[i].first, j));
}
if (p[i].second.first == 3) {
if (st.size() > 0) {
pp = *(st.begin());
x = -pp.first;
y = pp.second;
x = min(x, b[j]);
cur = x - a[j];
if (ans < 1ll * cur * c[j]) {
ans = 1ll * cur * c[j];
lx = y;
rx = j;
}
}
}
}
for (int i = 1; i <= n; i++) {
len[i] = r[i] - l[i];
}
sort(second + 1, second + sn + 1);
nn = unique(second + 1, second + sn + 1) - second - 1;
pn = 0;
for (int i = 1; i <= n; i++) {
r[i] = lower_bound(second + 1, second + nn + 1, r[i]) - second;
l[i] = lower_bound(second + 1, second + nn + 1, l[i]) - second;
p[++pn] = make_pair(r[i], make_pair(2, i));
}
for (int i = 1; i <= m; i++) {
a[i] = lower_bound(second + 1, second + nn + 1, a[i]) - second;
b[i] = lower_bound(second + 1, second + nn + 1, b[i]) - second;
p[++pn] = make_pair(b[i], make_pair(1, i));
}
sort(p + 1, p + pn + 1);
for (int i = 1; i <= pn; i++) {
j = p[i].second.second;
if (p[i].second.first == 2) {
if (A[l[j]] < len[j]) {
A[l[j]] = len[j];
update(l[j], len[j], j);
}
} else {
pp = get_max(a[j], b[j]);
x = pp.first;
if (1ll * x * c[j] > ans) {
ans = 1ll * x * c[j];
rx = j;
lx = pp.second;
}
}
}
if (ans > 0) {
printf("%I64d\n%d %d", ans, lx, rx);
} else {
puts("0");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1)
cout << '1' << ' ' << '1' << '\n' << '1';
else {
cout << 2 * n - 2 << ' ' << '2' << '\n';
cout << '1' << ' ' << '2';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int maxn = 15;
int n, m, k, mp[maxn][maxn];
int col[maxn], f[maxn][maxn];
int dfs(int x, int y) {
int ret = 0;
if (y > m) x++, y = 1;
if (x > n) return 1;
f[x][y] = f[x - 1][y] | f[x][y - 1];
int cnt = 0;
for (int i = 1; i <= k; i++)
if (f[x][y] & (1 << (i - 1))) cnt++;
if (n + m - x - y + 1 > k - cnt) return 0;
bool flag = true;
int pre = 0;
if (!mp[x][y]) {
for (int i = 1; i <= k; i++) {
if (!(f[x][y] & (1 << i - 1))) {
if (!col[i]) {
if (!flag) {
ret = (ret + pre) % mod;
} else {
flag = false;
col[i]++;
f[x][y] |= (1 << (i - 1));
pre = dfs(x, y + 1);
col[i]--;
f[x][y] ^= (1 << (i - 1));
ret += pre;
ret %= mod;
}
} else {
col[i]++;
f[x][y] |= (1 << (i - 1));
ret += dfs(x, y + 1);
col[i]--;
f[x][y] ^= (1 << (i - 1));
ret %= mod;
}
}
}
} else {
if (!(f[x][y] & (1 << (mp[x][y] - 1)))) {
f[x][y] |= 1 << (mp[x][y] - 1);
ret += dfs(x, y + 1), ret %= mod;
f[x][y] ^= 1 << (mp[x][y] - 1);
}
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
if (n + m - 1 > k) {
printf("0");
return 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &mp[i][j]), col[mp[i][j]]++;
printf("%d", dfs(1, 1));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 2e5 + 10;
bitset<nax> pos, diff;
vector<int> mem[(int)1e6];
vector<int> fac(int n) {
if (!mem[n].size()) {
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) mem[n].push_back(i), mem[n].push_back(n / i);
}
}
return mem[n];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, x, y;
cin >> n >> x >> y;
for (int i = 0; i < n + 1; i++) {
int a;
cin >> a;
pos[a] = 1;
}
for (int j = 0; j <= x; j++) {
if (pos[0]) diff |= pos;
pos >>= 1;
}
int q;
cin >> q;
while (q--) {
int l;
cin >> l;
l /= 2;
int ans = -1;
for (int div : fac(l)) {
if (div - y < nax && div > y && diff[div - y]) ans = max(ans, div * 2);
}
cout << ans << ' ';
}
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a, b;
string s;
int n, cnt = 0;
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
a.push_back(s[i]);
b.push_back(s[i + n]);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) {
cout << "NO";
return 0;
} else if (a[i] > b[i])
cnt++;
}
if (cnt == 0 || cnt == n)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void io() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
}
const int MAX = 1e7 + 2;
const int MAXN = 1e5 + 10;
int A[MAXN];
vector<int> g[MAXN];
int n;
int grundy[MAXN];
bool odd;
long long cnt0[MAX];
long long cnt1[MAX];
long long codd, ceve;
void walk(int u, int p, int d) {
bool leaf = 1;
for (auto v : g[u]) {
if (v != p) {
leaf = 0;
walk(v, u, d + 1);
}
}
if (leaf) {
if (d & 1) {
odd = 1;
}
}
if (odd) {
if (d & 1) {
codd++;
grundy[u] = A[u];
cnt1[A[u]]++;
} else {
ceve++;
cnt0[A[u]]++;
}
} else {
if (d % 2 == 0) {
ceve++;
grundy[u] = A[u];
cnt1[A[u]]++;
} else {
codd++;
cnt0[A[u]]++;
}
}
}
int main(int argc, char* argv[]) {
io();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
int p;
for (int i = 2; i <= n; i++) {
cin >> p;
g[p].push_back(i);
}
walk(1, 0, 1);
int xsum = 0;
for (int i = 1; i <= n; i++) {
xsum ^= grundy[i];
}
if (xsum == 0) {
long long fans = (codd * (codd - 1)) / 2ll + (ceve * (ceve - 1)) / 2ll;
for (int i = 1; i < MAX; i++) {
fans = fans + cnt0[i] * cnt1[i];
}
cout << fans << '\n';
} else {
long long fans = 0;
for (int i = 1; i < MAX; i++) {
if ((i ^ xsum) < MAX) fans = fans + cnt1[i] * cnt0[i ^ xsum];
}
cout << fans << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
string b;
int i;
map<char, int> mp;
getline(cin, a);
getline(cin, b);
for (int i = 0; i < a.length(); i++) {
if (a[i] != ' ') mp[a[i]]++;
}
for (i = 0; i < b.length(); i++) {
if (b[i] != ' ') {
if (mp[b[i]] == 0)
break;
else
mp[b[i]]--;
}
}
if (i == b.length())
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<vector<int> > adj;
vector<int> U, V;
vector<long long> C, W;
vector<int> tin, tout, dep, par, cycle, edge, del, vis;
int timer;
bool dfs(int u, int fe) {
tin[u] = timer++;
for (int i = 0; i < adj[u].size(); i++) {
int e = adj[u][i];
int v = U[e] + V[e] - u;
if (e == fe) continue;
if (tin[v] != -1) {
if (tout[v] == -1 && (dep[u] - dep[v]) % 2 == 0) {
int t = u;
while (1) {
cycle.push_back(t);
if (t == v) break;
int pe = par[t];
t = U[pe] + V[pe] - t;
edge.push_back(pe);
}
edge.push_back(e);
return true;
}
continue;
}
par[v] = e;
dep[v] = dep[u] + 1;
if (dfs(v, e)) return true;
}
tout[u] = timer;
return false;
}
void dfs2(int u, int fe) {
vis[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int e = adj[u][i];
int v = U[e] + V[e] - u;
if (vis[v]) continue;
if (del[v]) continue;
dfs2(v, e);
W[e] = C[v];
C[u] -= C[v];
}
}
vector<pair<long long, long long> > sol;
void solve() {
sol.resize(M);
sol[edge[0]] = pair<long long, long long>(1, 0);
for (int i = 1; i < cycle.size(); i++) {
int u = cycle[i];
int v = cycle[(i + 1) % cycle.size()];
int e = edge[i];
int pe = edge[i - 1];
sol[e] = pair<long long, long long>(-sol[pe].first, C[u] - sol[pe].second);
}
W[edge[0]] = (C[cycle[0]] - sol[edge[0]].second - sol[edge.back()].second) /
(sol[edge[0]].first + sol[edge.back()].first);
for (int i = 0; i < cycle.size(); i++) {
W[edge[i]] = W[edge[0]] * sol[edge[i]].first + sol[edge[i]].second;
}
}
int main() {
scanf("%d %d", &N, &M);
C.resize(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &C[i]);
}
adj.resize(N);
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
adj[u].push_back(U.size());
adj[v].push_back(U.size());
U.push_back(u);
V.push_back(v);
}
tin = tout = par = vector<int>(N, -1);
dep = vector<int>(N, 0);
timer = 0;
W = vector<long long>(M, 0);
if (!dfs(0, -1)) {
vis = vector<int>(N, 0);
del = vector<int>(N, 0);
dfs2(0, -1);
if (C[0]) {
printf("NO");
} else {
printf("YES\n");
for (int i = 0; i < M; i++) {
printf("%lld\n", W[i]);
}
}
return 0;
}
del = vector<int>(N, 0);
vis = vector<int>(N, 0);
for (int i = 0; i < cycle.size(); i++) del[cycle[i]] = 1;
for (int i = 0; i < cycle.size(); i++) {
dfs2(cycle[i], -1);
}
solve();
printf("YES\n");
for (int i = 0; i < M; i++) {
printf("%lld\n", W[i]);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int uu[100005];
int main() {
int i, j, T, t;
scanf("%d", &t);
memset(uu, 0, sizeof(uu));
for (i = 1; i <= t; i++) {
scanf("%d%d", &a, &b);
int ans = 0;
for (j = 1; j * j <= a; j++) {
if (a % j != 0) continue;
int x = j;
int y = a / j;
if (uu[x] < i - b) ans++;
if (x != y && uu[y] < i - b) ans++;
uu[x] = i;
uu[y] = i;
}
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
int sz = (int)s.size();
int x = 0, y = 0;
int ans = INF;
map<pair<int, int>, int> xd;
int comeca = -1, termina = -1;
xd[{0, 0}] = 0;
for (int i = 0; i < sz; i++) {
if (s[i] == 'L') x--;
if (s[i] == 'R') x++;
if (s[i] == 'U') y++;
if (s[i] == 'D') y--;
if (xd.count({x, y})) {
int z = (i + 1) - xd[{x, y}];
if (z < ans) {
comeca = xd[{x, y}] + 1;
termina = i + 1;
ans = z;
}
}
xd[{x, y}] = i + 1;
}
if (comeca != -1 && termina != -1) {
cout << comeca << " " << termina << "\n";
} else {
cout << "-1\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string str[100];
for (int i = 0; i < n; i++) {
cin >> str[i];
}
sort(str, str + n);
int cnt = 1;
int ans = 1;
for (int i = 0; i < n - 1; i++) {
if (str[i] == str[i + 1]) {
cnt++;
} else {
cnt = 1;
}
if (cnt >= ans) {
ans = cnt;
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool comparator_2(pair<char, int>& a, pair<char, int>& b) {
return (a.second <= b.second);
}
bool comparator_1(pair<char, int>& a, pair<char, int>& b) {
return (a.first <= b.first);
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
int n;
cin >> n;
if (n == 1)
cout << "x\nx\ny\ny";
else if (n == 2)
cout << "xx\nyy\nxx\nyy";
else {
char arr[4][n], color = 'a';
for (int i = 0; i < n - (n & 1); i++) {
if (!(i & 1))
arr[0][i] = color++;
else
arr[0][i] = arr[0][i - 1];
arr[1][i] = arr[0][i] + 1;
if (color == 'z') color = 'a';
}
color = 'c';
for (int i = 1; i < n - (!(n & 1)); i++) {
if (i & 1)
arr[3][i] = color++;
else if (i > 0)
arr[3][i] = arr[3][i - 1];
arr[2][i] = arr[3][i] + 1;
if (color == 'z') color = 'a';
}
if (n & 1) {
arr[0][n - 1] = 'a' + (arr[3][n - 2] - 'a' + 2) % 26;
arr[1][n - 1] = 'a' + (arr[3][n - 2] - 'a' + 2) % 26;
arr[3][0] = 'a';
arr[2][0] = 'a';
} else {
arr[3][0] = 'a';
arr[2][0] = 'a';
arr[3][n - 1] = 'a' + (arr[3][n - 2] - 'a' + 2) % 26;
arr[2][n - 1] = 'a' + (arr[3][n - 2] - 'a' + 2) % 26;
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < n; j++) cout << arr[i][j];
cout << '\n';
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 1e5 + 5;
int n, a[maxn];
int b[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int sum = 0;
map<int, int> mp;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
bool poss = false;
for (int i = 0; i < n; i++) {
if (a[i] > 0) {
if (--mp[a[i]] == 0) mp.erase(a[i]);
++mp[a[i] - 1];
if (mp.size() == n) {
poss = true;
}
if (--mp[a[i] - 1] == 0) mp.erase(a[i] - 1);
++mp[a[i]];
}
}
if (!poss) {
cout << "cslnb" << '\n';
return 0;
}
sort(a, a + n);
b[0] = 0;
for (int i = 1; i < n; i++) {
b[i] = min(a[i], b[i - 1] + 1);
}
for (int i = 0; i < n; i++) {
sum += (a[i] - b[i] + 2) % 2;
sum %= 2;
}
cout << (sum == 1 ? "sjfnb" : "cslnb") << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
long long int power(long long int a, long long int b) {
long long int res = 1;
a = a % MOD;
while (b > 0) {
if (b & 1) {
res = (res * a) % MOD;
b--;
}
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
long long int fermat_inv(long long int y) { return power(y, MOD - 2); }
long long int gcd(long long int a, long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
long long int min(long long int a, long long int b) { return (a > b) ? b : a; }
long long int max(long long int a, long long int b) { return (a > b) ? a : b; }
bool prime[1000001];
vector<int> primes;
void SieveOfEratosthenes(int n) {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = 0;
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p < 1000001; p++)
if (prime[p]) primes.push_back(p);
}
long long int fact[1000010];
long long int finv[1000010];
void factorial(int n) {
fact[0] = 1;
finv[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = fact[i - 1] * i, fact[i] %= MOD, finv[i] = fermat_inv(fact[i]);
}
long long int ncr(long long int n, long long int r) {
if (n < r)
return 0;
else {
long long int x = finv[r] * finv[n - r] % MOD;
return fact[n] * x % MOD;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int te = 1;
while (te--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int mode, m_cnt = 0;
for (int i = 1; i <= 100; i++) {
int cnt = 0;
for (int j : a) {
if (i == j) cnt++;
}
if (cnt > m_cnt) mode = i, m_cnt = cnt;
}
int ans = 0;
for (int i = 1; i <= 100; i++) {
if (i == mode) continue;
int b[n];
vector<int> m(2 * n + 5, -5);
m[n] = -1;
int curr = 0;
for (int j = 0; j < n; j++) {
curr += (a[j] == mode) ? 1 : ((a[j] == i) ? -1 : 0);
if (m[n + curr] != -5)
ans = max(ans, j - m[n + curr]);
else
m[n + curr] = j;
}
}
cout << ans;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, ans = 0, f = 0, cnt = 1, m, k, cur = INT_MIN;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < n; i++) {
if (a[i] != a[0]) cur = max(cur, i);
if (a[i] != a[n - 1]) cur = max(cur, (n - 1 - i));
}
cout << cur << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200010];
int vis[200010];
int in[200010];
void dfs(int cur, int lev) {
vis[cur] = lev;
for (auto next : v[cur]) {
if (!vis[next]) dfs(next, lev + 1);
}
}
int main() {
int t, n, m, a, b;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1, 1);
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] % 2 == 0) cnt++;
}
if (cnt <= n / 2) {
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) {
if (vis[i] % 2 == 0) printf("%d ", i);
}
printf("\n");
} else {
printf("%d\n", n - cnt);
for (int i = 1; i <= n; i++) {
if (vis[i] % 2 == 1) printf("%d ", i);
}
printf("\n");
}
for (int i = 1; i <= n; i++) {
vis[i] = 0;
v[i].clear();
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct pkt {
int x, y;
};
int Odl(pkt a, pkt b) {
return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool Skalar(pkt a, pkt b, pkt c) {
int w1x = a.x - b.x, w1y = a.y - b.y;
int w2x = c.x - b.x, w2y = c.y - b.y;
if (w1x * w2x + w1y * w2y == 0) return true;
return false;
}
bool Pro(vector<pkt>& P) {
vector<int> kol(4);
for (int i = 0; i < 4; ++i) kol[i] = i;
do {
vector<pkt> t(4);
for (int j = 0; j < 4; ++j) {
t[j].x = P[kol[j]].x;
t[j].y = P[kol[j]].y;
}
if (Skalar(t[0], t[1], t[2]) && Skalar(t[1], t[2], t[3]) &&
Skalar(t[2], t[3], t[0]) && Skalar(t[3], t[0], t[1])) {
for (int j = 0; j < 4; ++j) {
P[j].x = t[j].x;
P[j].y = t[j].y;
}
return true;
}
} while (next_permutation(kol.begin(), kol.end()));
return false;
}
bool Kwa(vector<pkt>& P) {
if (!Pro(P)) return false;
int o1 = Odl(P[0], P[1]), o2 = Odl(P[1], P[2]), o3 = Odl(P[2], P[3]),
o4 = Odl(P[3], P[0]);
if (o1 == o2 && o2 == o3 && o3 == o4 && o4 == o1) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
vector<pkt> P(8);
for (int i = 0; i < 8; ++i) cin >> P[i].x >> P[i].y;
int zb = 0, max_zb = 255;
for (zb; zb <= max_zb; ++zb) {
int il = 0;
for (int i = 0; i < 8; ++i)
if ((zb & (1 << i)) > 0) ++il;
if (il != 4) continue;
vector<pkt> S1, S2;
vector<int> nr1, nr2;
for (int i = 0; i < 8; ++i) {
if ((zb & (1 << i)) > 0) {
S1.push_back(P[i]);
nr1.push_back(i);
} else {
S2.push_back(P[i]);
nr2.push_back(i);
}
}
if (Kwa(S1) && Pro(S2)) {
cout << "YES" << endl;
for (int i = 0; i < 4; ++i) cout << nr1[i] + 1 << " ";
cout << endl;
for (int i = 0; i < 4; ++i) cout << nr2[i] + 1 << " ";
return 0;
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int count = 0;
int sum = 0;
int i;
for (i = n - 1; i >= 0; i--) {
sum += a[i];
if (sum >= k) {
count++;
if (sum == k)
sum = 0;
else
i++, sum = 0;
if (count >= m) {
i--;
break;
}
}
}
cout << n - i - 1;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ra[1000001] = {}, ca[1000001] = {};
int main() {
long long n, m, k, p, a, r[1000] = {}, c[1000] = {};
long long ans = LLONG_MIN, rm, cm;
scanf("%d%d%d%d", &n, &m, &k, &p);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a);
r[i] += a;
c[j] += a;
}
}
int pm = p * m, pn = p * n;
std::priority_queue<long long> sr(r, r + n), sc(c, c + m);
for (int i = 1; i <= k; ++i) {
rm = sr.top();
cm = sc.top();
sr.pop();
sc.pop();
ra[i] = ra[i - 1] + rm;
ca[i] = ca[i - 1] + cm;
sr.push(rm - pm);
sc.push(cm - pn);
}
for (int i = 0; k >= 0; ++i, --k)
ans = std::max(ans, ra[i] + ca[k] - ((long long)(p * i)) * k);
printf("%I64d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long int a, s1, s2, s3, n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
s1 += a;
}
for (int i = 0; i < n - 1; i++) {
cin >> a;
s2 += a;
}
for (int i = 0; i < n - 2; i++) {
cin >> a;
s3 += a;
}
cout << s1 - s2 << endl << s2 - s3 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
long long int max = n;
long long int min = 2;
long long int mid = (max + min) / 2;
while (max - min > 1) {
mid = (max + min) / 2;
long long int C = ((mid - 1) * mid) / 2;
if (k == C) {
min = mid;
max = mid;
break;
} else if (k < C) {
max = mid;
} else {
min = mid;
}
}
long long int Cmax = ((max - 1) * max) / 2;
long long int Cmin = ((min - 1) * min) / 2;
long long int index1, index2;
if (k == Cmin) {
index1 = n - (min);
index2 = index1 + 1;
for (int i = 0; i < n; i++) {
if (i == index1 || i == index2) {
cout << 'b';
} else {
cout << 'a';
}
}
cout << "\n";
} else if (k == Cmax) {
index1 = n - (max);
index2 = index1 + 1;
for (int i = 0; i < n; i++) {
if (i == index1 || i == index2) {
cout << 'b';
} else {
cout << 'a';
}
}
cout << "\n";
} else {
index1 = n - max;
index2 = n - (k - Cmin);
for (int i = 0; i < n; i++) {
if (i == index1 || i == index2) {
cout << 'b';
} else {
cout << 'a';
}
}
cout << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, ans = 1, k = 1;
string s, p;
bool ok = false;
cin >> n >> s;
p = s;
for (int i = 1; i < s.length() - 1; i++) {
if (s[i - 1] == s[i] && s[i] == s[i + 1]) {
ok = true;
if (s[i] == '1')
s[i] = '0';
else
s[i] = '1';
break;
}
}
if (!ok) {
for (int i = 1; i < s.length(); i++) {
if (s[i] == s[i - 1]) {
ok = true;
}
if (ok) {
if (s[i] == '1')
s[i] = '0';
else
s[i] = '1';
if (s[i] != s[i + 1]) break;
}
}
}
for (int i = 1; i < s.length(); i++) {
if (s[i] != s[i - 1]) ans++;
}
if (p.length() > 1 && p[0] == p[1]) {
if (p[0] == '1')
p[0] = '0';
else
p[0] = '1';
}
swap(p, s);
for (int i = 1; i < s.length(); i++) {
if (s[i] != s[i - 1]) k++;
}
if (ans < k) {
swap(ans, k);
} else
swap(s, p);
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ans = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) ans = (ans << 3) + (ans << 1) + (c ^ 48);
return ans * f;
}
inline int cmin(int &a, int b) { return a = min(a, b); }
inline int cmax(int &a, int b) { return a = max(a, b); }
int a[100005], b[100005];
int s1[100005], s2[100005];
int main() {
int T = read();
for (int i = 1; i <= T; i++) {
int n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
s1[i] = s1[i - 1];
s2[i] = s2[i - 1];
if (a[i] == 1) s1[i]++;
if (a[i] == -1) s2[i]++;
}
for (int i = 1; i <= n; i++) {
b[i] = read();
}
int flag = 1;
for (int i = n; i >= 1; i--) {
if (a[i] == b[i]) continue;
if (a[i] > b[i] && !s2[i - 1]) {
flag = 0;
break;
}
if (a[i] < b[i] && !s1[i - 1]) {
flag = 0;
break;
}
}
if (flag == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, l, m, a[301010], z;
vector<long long> q1;
set<long long> q2;
map<long long, long long> q3;
string s, pr, po;
int main() {
cin >> l;
while (l--) {
cin >> s;
po = "";
pr = "";
for (i = 0; i < s.size(); i++) {
if ((s[i] - 'a') % 2) {
pr += s[i];
} else {
po += s[i];
}
}
sort(pr.begin(), pr.end());
reverse(pr.begin(), pr.end());
sort(po.begin(), po.end());
reverse(po.begin(), po.end());
string s1 = po + pr, s2 = pr + po;
int y = 1;
for (i = 0; i < s1.size() - 1; i++) {
if (abs(s1[i] - s1[i + 1]) == 1) {
y = 0;
break;
}
}
int yy = 1;
for (i = 0; i < s2.size() - 1; i++) {
if (abs(s2[i] - s2[i + 1]) == 1) {
yy = 0;
break;
}
}
if (y)
cout << s1 << "\n";
else if (yy) {
cout << s2 << "\n";
} else {
cout << "No answer\n";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long N, K;
long long ans = 0;
int main() {
cin >> N >> K;
if (K > 2 * N - 1) {
cout << 0;
return 0;
}
long long l = max(1ll, K - N);
long long r;
if (K % 2)
r = min(N, K / 2);
else
r = min(N, K / 2 - 1);
cout << (r - l + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string pokemon[] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
string mask;
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n == 0) {
printf("%d %d\n", 0, 1);
printf("%d %d\n", 0, m);
printf("%d %d\n", 0, 0);
printf("%d %d\n", 0, m - 1);
} else if (m == 0) {
printf("%d %d\n", 1, 0);
printf("%d %d\n", n, 0);
printf("%d %d\n", 0, 0);
printf("%d %d\n", n - 1, 0);
} else {
double diag = sqrt((double)(n * n + m * m));
double first = (double)max(n, m) + 2 * diag;
double diag_n = sqrt((double)(n * n + (m - 1) * (m - 1)));
double diag_m = sqrt((double)((n - 1) * (n - 1) + m * m));
double diag_2 = max(diag_n, diag_m);
if (first >= diag + 2 * diag_2) {
printf("%d %d\n", 0, 0);
printf("%d %d\n", n, m);
if (n >= m) {
printf("%d %d\n", 0, m);
printf("%d %d\n", n, 0);
} else {
printf("%d %d\n", n, 0);
printf("%d %d\n", 0, m);
}
} else {
if (diag_n > diag_m) {
printf("%d %d\n", 0, 1);
printf("%d %d\n", n, m);
printf("%d %d\n", 0, 0);
printf("%d %d\n", n, m - 1);
} else {
printf("%d %d\n", 1, 0);
printf("%d %d\n", n, m);
printf("%d %d\n", 0, 0);
printf("%d %d\n", n - 1, m);
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x;
int main() {
scanf("%d%d", &n, &m);
x = n;
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
x = min(x, r - l + 1);
}
printf("%d\n", x);
for (int i = 0; i < n; i++) printf("%d ", i % x);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 55;
int x[MAX];
long long poww(long long x, long long y) {
if (y == 0) return 1;
long long s = poww(x, y / 2);
s = (s * s);
if (y % 2 == 1) s = (s * x);
return s;
}
int main() {
string s = "OYGR";
string c = "BIV";
int t = 0;
int n;
cin >> n;
string b = "";
for (int i = 0; i < n - 3; i++) {
if (t == 4) t = 0;
b += s[t];
t++;
}
cout << b + c;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
static int fast_io = []() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
return 0;
}();
int main() {
int v1, v2;
cin >> v1 >> v2;
int t, d;
cin >> t >> d;
vector<int> times(t);
times[0] = v1;
times.back() = v2;
for (int i = 1; i < t - 1; i++) {
times[i] = times[i - 1] + d;
}
for (int i = t - 2; i >= 1; i--) {
if (times[i] - d > times[i + 1]) {
times[i] = times[i + 1] + d;
}
}
int ans = 0;
for (auto x : times) {
ans += x;
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:64000000")
using namespace std;
int d[22][22];
int bits(int x) {
int r = 0;
while (x != 0) {
++r;
x &= (x - 1);
}
return r;
}
int main() {
int n, k;
cin >> n >> k;
vector<string> s(n);
for (int(i) = 0; (i) < (n); (i)++) cin >> s[i];
for (int(i) = 0; (i) < (n); (i)++)
for (int(j) = 0; (j) < (n); (j)++) {
d[i][j] = min((int)(s[i]).size(), (int)(s[j]).size());
for (int(k) = 0; (k) < (min((int)(s[i]).size(), (int)(s[j]).size()));
(k)++) {
if (s[i][k] != s[j][k]) {
d[i][j] = k;
break;
}
}
}
int res = 0;
for (int(mask) = 0; (mask) < (1 << n); (mask)++) {
if (bits(mask) == k) {
int cur = 0;
for (int(i) = 0; (i) < (n); (i)++) {
if (mask & (1 << i)) {
for (int(j) = 0; (j) < (i); (j)++) {
if (mask & (1 << j)) {
cur += d[i][j];
}
}
}
}
res = max(res, cur);
}
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
const long long int INFLL = 0x3f3f3f3f3f3f3f3fll;
long long int getint() {
long long int ret = 0;
bool f = 0;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') f ^= 1;
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return f ? -ret : ret;
}
using namespace std;
const int MAXN = 2000;
bool a[MAXN + 10][MAXN + 10], tmp[MAXN + 10][MAXN + 10];
bool vis[MAXN + 10][MAXN + 10];
int n;
int dir[9][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {1, -1},
{1, 1}, {-1, 1}, {-1, -1}, {0, 0}};
int stkx[MAXN * MAXN + 10], stky[MAXN * MAXN + 10], top = 0;
void get(int x, int y) {
stkx[++top] = x;
stky[top] = y;
vis[x][y] = 1;
for (int i = 0; i < 4; ++i) {
int dx = x + dir[i][0], dy = y + dir[i][1];
if (dx < 1 || dy < 1 || dx > n || dy > n || vis[dx][dy] ||
a[dx][dy] != a[x][y])
continue;
get(dx, dy);
}
}
bool solve() {
int sumx = 0, sumy = 0;
for (int i = 1; i <= top; ++i) sumx += stkx[i], sumy += stky[i];
double tx = 1.0 * sumx / top, ty = 1.0 * sumy / top;
double mindis = INF, maxdis = 0;
for (int i = 1; i <= top; ++i) {
bool flag = 0;
for (int j = 0; j < 4; ++j)
if (!a[stkx[i] + dir[j][0]][stky[i] + dir[j][1]]) {
flag = 1;
break;
}
if (!flag) continue;
double dis =
(tx - stkx[i]) * (tx - stkx[i]) + (ty - stky[i]) * (ty - stky[i]);
mindis = min(mindis, dis);
maxdis = max(maxdis, dis);
}
return maxdis < 1.8 * mindis;
}
int main() {
n = getint();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) a[i][j] = getint();
int T = 10;
while (T--) {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
int cnt0 = 0, cnt1 = 0;
for (int k = 0; k < 9; ++k) {
int x = i + dir[k][0], y = j + dir[k][1];
if (x < 1 || y < 1 || x > n || y > n) continue;
if (a[x][y] == a[i][j])
++cnt0;
else
++cnt1;
}
if (cnt1 > cnt0)
tmp[i][j] = a[i][j] ^ 1;
else
tmp[i][j] = a[i][j];
}
memcpy(a, tmp, sizeof a);
}
int cnt1 = 0, cnt2 = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (a[i][j] && !vis[i][j]) {
top = 0;
get(i, j);
if (top < 120)
for (int k = 1; k <= top; ++k) a[stkx[k]][stky[k]] = 0;
} else if (!vis[i][j]) {
top = 0;
get(i, j);
if (top < 40)
for (int k = 1; k <= top; ++k) a[stkx[k]][stky[k]] = 1;
}
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (a[i][j] && !vis[i][j]) {
top = 0;
get(i, j);
if (solve())
++cnt1;
else
++cnt2;
}
printf("%d %d\n", cnt1, cnt2);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool sortbylogic(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second > b.second);
}
bool sortbylogic1(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first < b.first);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, d;
cin >> n >> d;
vector<pair<long long, long long> > vect(n);
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
vect[i].first = a;
vect[i].second = b;
}
sort(vect.begin(), vect.end(), sortbylogic);
long long k = vect[0].second;
sort(vect.begin(), vect.end(), sortbylogic1);
long long ans = INT_MIN;
long long p = 0;
long long sum = 0;
long long j = 0;
long long res = 0;
if (n == 1)
cout << max(k, vect[0].second) << endl;
else {
for (long long i = 0; i < n; i++) {
long long diff = vect[i].first - vect[j].first;
while (diff >= d) {
sum -= vect[j].second;
diff = vect[i].first - vect[j + 1].first;
j++;
}
sum += vect[i].second;
res = max(res, sum);
}
cout << res << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void advance(string &s, int &ind, int rev) {
while (ind >= 0 && ind < s.size() && s[ind] != '.') ind += rev;
}
int main() {
string s[2];
cin >> s[0] >> s[1];
int n = s[0].size();
sort(s[0].begin(), s[0].end());
sort(s[1].rbegin(), s[1].rend());
string res(n, '.');
int ind0s = 0, ind1s = 0, ind0e = (n + 1) / 2 - 1, ind1e = n / 2 - 1;
int inds = 0, inde = n - 1;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (s[1][ind1s] > s[0][ind0s]) {
advance(res, inds, 1);
res[inds] = s[0][ind0s];
ind0s++;
} else {
advance(res, inde, -1);
res[inde] = s[0][ind0e];
ind0e--;
}
} else {
if (s[0][ind0s] < s[1][ind1s]) {
advance(res, inds, 1);
res[inds] = s[1][ind1s];
ind1s++;
} else {
advance(res, inde, -1);
res[inde] = s[1][ind1e];
ind1e--;
}
}
}
cout << res << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.