solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
int n, ans, sum, f[MAXN][2005];
struct Node {
int t, d, p, id;
} a[MAXN];
vector<int> ve;
bool cmp(Node a, Node b) { return a.d < b.d; }
bool vis[MAXN][2005];
void get() {
ans = -1;
int i = n, k;
for (int j = 0; j <= sum; j++) {
if (ans < f[n][j]) {
ans = f[n][j];
k = j;
}
}
while (i > 0 && k > 0) {
if (vis[i][k]) {
ve.push_back(i);
k -= a[i].t;
}
i--;
}
reverse(ve.begin(), ve.end());
}
int main() {
scanf("%d", &n);
memset(f, 0, sizeof(f));
sum = 0;
for (int i = 1; i <= n; i++)
scanf("%d%d%d", &a[i].t, &a[i].d, &a[i].p), a[i].id = i, sum += a[i].t;
sort(a + 1, a + 1 + n, cmp);
memset(vis, false, sizeof(vis));
for (int i = 1; i <= n; i++) {
for (int j = sum; j >= 0; j--) {
f[i][j] = f[i - 1][j];
if (j < a[i].d && j >= a[i].t &&
f[i][j] < f[i - 1][j - a[i].t] + a[i].p) {
f[i][j] = f[i - 1][j - a[i].t] + a[i].p;
vis[i][j] = true;
}
}
}
get();
printf("%d\n", ans);
printf("%d\n", ve.size());
for (int i = 0; i < ve.size(); i++) {
if (i) printf(" ");
printf("%d", a[ve[i]].id);
}
printf("\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int const INF = 100 + (int)1e9;
long long const INFL = 100 + (long long)1e18;
long double const PI = 3.141592653589793238462643L;
mt19937 tw(960172);
long long sqr(int a) { return (long long)a * a; }
long double sqr(long double a) { return a * a; }
long long sqr(long long a) { return a * a; }
bool is_prime(long long x) {
for (long long y = 2; y * y <= x; ++y)
if (x % y == 0) return 0;
return x > 1;
}
long long rnd(long long x, long long y) {
static uniform_int_distribution<long long> d;
return d(tw) % (y - x + 1) + x;
}
long long gcd(long long a, long long b) {
while (b > 0) {
long long t = a % b;
a = b;
b = t;
}
return a;
}
int const N = 2020;
int const Q = 500500;
bitset<N> a[N];
bitset<N> inf[N];
int x[Q], y[Q];
bool no[N][N];
void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", x + i, y + i);
--x[i], --y[i];
a[x[i]][y[i]] = 1;
}
for (int i = 0; i < n; ++i) {
inf[i][i] = 1;
}
for (int i = 0; i < n; ++i) {
int row = -1;
for (int r = i; r < n; ++r) {
if (a[r][i]) {
row = r;
break;
}
}
if (i != row) {
swap(a[i], a[row]);
swap(inf[i], inf[row]);
}
for (int r = 0; r < n; ++r) {
if (r != i && a[r][i]) {
a[r] ^= a[i];
inf[r] ^= inf[i];
}
}
}
for (int i = 0; i < m; ++i) {
bool no = inf[y[i]][x[i]];
cout << (no ? "NO" : "YES") << '\n';
}
}
int main() {
cout.precision(15);
cout << fixed;
int tcn = 1;
for (int tn = 1; tn <= tcn; ++tn) solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char arr[100000];
cin >> arr;
int len = strlen(arr);
int f = 0;
for (int i = 0; i < len; i++) {
if (arr[i] == 'x') f++;
}
int how = n / 2 - f;
if (how < 0) {
int fuck = how;
for (int i = 0; i < len && fuck != 0; i++)
if (arr[i] == 'x') {
arr[i] = 'X';
fuck++;
}
} else {
int fuck = how;
for (int i = 0; i < len && fuck != 0; i++)
if (arr[i] == 'X') {
arr[i] = 'x';
fuck--;
}
}
cout << abs(how) << endl;
cout << arr << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
void sort(int *a, int N);
int main(void) {
int n, i;
int mas[5];
scanf("%d", &n);
if (n == 1) {
scanf("%d", &mas[0]);
printf("%d", mas[0]);
return 0;
}
if (n == 3) {
for (i = 0; i < 3; i++) scanf("%d", &mas[i]);
sort(&mas[0], 3);
printf("%d", mas[1]);
return 0;
}
if (n == 5) {
for (i = 0; i < 5; i++) scanf("%d", &mas[i]);
sort(&mas[0], 5);
printf("%d ", mas[2]);
return 0;
}
}
void sort(int *m, int N) {
int tmp, max;
int j, i, w = 0;
int N1 = N;
for (j = 0; j < N - 1; j++) {
max = m[0];
w = 0;
for (i = 1; i < N1; i++) {
if (m[i] > max) {
max = m[i];
w = i;
}
}
N1--;
for (i = w; i < N1; i++) {
tmp = m[i];
m[i] = m[i + 1];
m[i + 1] = tmp;
}
}
return;
}
| 0 |
#include <bits/stdc++.h>
long long l, r, m, t;
int main() {
scanf("%lld", &t);
while (t--) {
scanf("%lld %lld %lld", &l, &r, &m);
long long a, b, c;
for (a = l; a <= r; a++) {
long long bc = m % a;
if (m < a) {
if (a - bc <= r - l) {
b = l;
c = l + a - bc;
break;
}
} else {
if (a - bc <= r - l) {
b = l;
c = l + a - bc;
break;
}
if (bc <= r - l) {
b = r;
c = r - bc;
break;
}
}
}
printf("%lld %lld %lld\n", a, b, c);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long l, r;
int a[100001];
void init() {
cin >> l >> r;
int b = 1;
int tot = r;
a[1] = 1;
for (int i = 2; i <= r + 1; i++) {
if (b == 1) {
a[i] = a[i - 1] + tot;
b = 0;
tot--;
} else {
a[i] = a[i - 1] - tot;
b = 1;
tot--;
}
}
for (int i = r + 2; i <= l; i++) a[i] = i;
for (int i = 1; i <= l; i++) cout << a[i] << " ";
cout << endl;
}
int main() {
init();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char board[15][15];
int row[15], col[15];
int main() {
ios::sync_with_stdio(0);
int N, M;
cin >> N >> M;
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (int i = 0; i < (int)N; i++) {
for (int j = 0; j < (int)M; j++) {
cin >> board[i][j];
if (board[i][j] == 'S') {
row[i]++;
col[j]++;
}
}
}
int ans = 0;
for (int i = 0; i < N; i++) {
if (row[i] != 0) continue;
for (int j = 0; j < M; j++) {
if (board[i][j] != 'S') {
board[i][j] = 'S';
ans++;
}
}
}
for (int i = 0; i < M; i++) {
if (col[i] != 0) continue;
for (int j = 0; j < N; j++) {
if (board[j][i] != 'S') {
board[j][i] = 'S';
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n % 2 == 0) {
cout << "NO" << '\n';
return 0;
}
int arr[200005] = {0};
int mx = 2 * n;
int mn = 1;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
arr[i] = mn++;
arr[i + n] = mn++;
} else {
arr[i] = mx--;
arr[i + n] = mx--;
}
}
cout << "YES" << '\n';
for (int i = 0; i < 2 * n; i++) cout << arr[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
string s, w;
vector<int> res;
void norm(int &pos) {
while (s[pos] != '>') pos++;
pos++;
}
void read_table(int &pos);
int read_cell(int &pos) {
norm(pos);
while (s[pos + 1] != '/') read_table(pos);
norm(pos);
return 1;
}
int read_row(int &pos) {
int now = 0;
norm(pos);
while (s[pos + 1] != '/') {
now += read_cell(pos);
}
norm(pos);
return now;
}
void read_table(int &pos) {
int now = 0;
norm(pos);
while (s[pos + 1] != '/') {
cerr << pos << " " << s[pos] << " " << s[pos + 1] << endl;
now += read_row(pos);
}
norm(pos);
res.push_back(now);
}
int main() {
while (cin >> w) s += w;
s += ">>>";
int now = 0;
read_table(now);
sort(res.begin(), res.end());
for (int i = 0; i < (int)(res.size()); i++) cout << res[i] << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100 * 1000;
const int MOD = 1e9 + 7;
const int INF = (1 << 30);
vector<pair<int, int> > aint[4 * NMAX + 2];
vector<int> G[NMAX + 2];
int v[NMAX + 2], lev[NMAX + 2], e[NMAX + 2], st[NMAX + 2], dr[NMAX + 2];
bool viz[NMAX + 2];
int N, Q, R, e_ind = 0;
void DFS(int nod) {
viz[nod] = 1;
st[nod] = ++e_ind;
e[e_ind] = nod;
for (int x : G[nod]) {
if (viz[x]) continue;
lev[x] = lev[nod] + 1;
DFS(x);
}
dr[nod] = e_ind;
}
void build(int nod, int st, int dr) {
if (st == dr) {
aint[nod].push_back({lev[e[st]], v[e[st]]});
return;
}
int mid = (st + dr) / 2;
build(2 * nod, st, mid);
build(2 * nod + 1, mid + 1, dr);
int ind = 0;
for (int i = 0; i < aint[2 * nod].size(); ++i) {
while (ind < aint[2 * nod + 1].size() &&
aint[2 * nod + 1][ind] < aint[2 * nod][i]) {
aint[nod].push_back(aint[2 * nod + 1][ind]);
++ind;
}
aint[nod].push_back(aint[2 * nod][i]);
}
while (ind < aint[2 * nod + 1].size())
aint[nod].push_back(aint[2 * nod + 1][ind++]);
for (int i = 1; i < aint[nod].size(); ++i)
aint[nod][i].second = min(aint[nod][i].second, aint[nod][i - 1].second);
}
int Query(int nod, int st, int dr, int x, int y, int maxl) {
if (dr < x || st > y) return INF;
if (x <= st && dr <= y) {
auto it =
upper_bound(aint[nod].begin(), aint[nod].end(), make_pair(maxl, INF));
if (it == aint[nod].begin()) return INF;
--it;
return (*it).second;
}
int mid = (st + dr) / 2;
int a = Query(2 * nod, st, mid, x, y, maxl);
int b = Query(2 * nod + 1, mid + 1, dr, x, y, maxl);
return min(a, b);
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> R;
for (int i = 1; i <= N; ++i) cin >> v[i];
for (int i = 1; i < N; ++i) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
DFS(R);
build(1, 1, N);
cin >> Q;
int last = 0;
while (Q--) {
int nod, level;
cin >> nod >> level;
nod = (nod + last) % N + 1;
level = (level + last) % N;
cout << (last = Query(1, 1, N, st[nod], dr[nod], lev[nod] + level)) << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
int n;
cin >> n;
int cnt = 0;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
for (int g = 0; g < 33; g++) {
long long k = pow(2ll, g);
int f = 0;
if (binary_search(a, a + n, k + a[i])) {
cnt = max(cnt, 2);
v = {a[i], k + a[i]};
f = 1;
}
if (binary_search(a, a + n, 2 * k + a[i]) && f == 1) {
cnt = 3;
v = {a[i], k + a[i], 2 * k + a[i]};
cout << cnt << endl;
cout << v[0] << " " << v[1] << " " << v[2];
return 0;
}
}
}
if (cnt == 2) {
cout << 2 << endl;
cout << v[0] << " " << v[1];
return 0;
}
cout << 1 << endl;
cout << a[0] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 5;
const long long mod = 1e9 + 7;
const long long N = 2e5 + 314;
const long double pi = 3.1415926535897932384626433832795;
void solve() {
long long a, b, first, k;
cin >> a >> b >> first >> k;
long long cnt = 0, fl = b;
b -= first;
while (k) {
if (b < 0) {
cout << "-1\n";
return;
}
if (k > 1) {
if (b < 2 * (a - first)) {
b = fl;
cnt++;
}
b -= 2 * (a - first);
} else {
if (b < a - first) {
b = fl;
cnt++;
}
b -= (a - first);
}
if (b < 0) {
cout << "-1\n";
return;
}
k--;
if (k == 0) {
cout << cnt;
return;
}
if (k == 1) {
if (b >= first)
cout << cnt;
else
cout << cnt + 1;
break;
}
if (k > 1) {
if (b < 2 * first) {
cnt++;
b = fl;
}
b -= 2 * first;
} else {
if (b < first) {
b = fl;
cnt++;
}
b -= first;
}
if (b < 0) {
cout << "-1\n";
return;
}
k--;
if (k == 0) {
cout << cnt;
return;
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int INF = 0x3f3f3f3f;
char op[10];
int x;
int S[maxn];
int main() {
int n, pos = 1, ans = 0, top = 0;
scanf("%d", &n);
for (int i = 0; i < 2 * n; i++) {
scanf("%s", op);
if (strcmp("add", op) == 0) {
scanf("%d", &x);
S[++top] = x;
} else {
if (top) {
if (S[top] == pos)
top--;
else
top = 0, ans++;
}
pos++;
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long q;
long long f[1000500], ni[1000500];
long long ci[1000500];
long long pri[101], cnt;
long long edans[1000500];
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
long long quickpow(long long x, long long t, long long p) {
long long ans = 1;
for (; t; t >>= 1, x = (x * x) % p)
if (t & 1) ans = (ans * x) % p;
return ans;
}
long long n1, m1, a;
long long s, frog;
long long work() {
long long sum = a, now = 1;
while (sum != 1) {
sum = sum * a % q;
now++;
}
return now;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &n1, &m1, &a, &q);
frog = work();
f[0] = 1;
for (int i = 1; i <= frog; i++) f[i] = f[i - 1] * i % frog;
ni[frog - 1] = frog - 1;
for (int i = frog - 2; i >= 0; i--) ni[i] = ni[i + 1] * (i + 1) % frog;
int sum = 1, nsum = 0;
;
for (int i = 0; i <= (n1 - 1 < m1 ? n1 - 1 : m1); i++) {
sum = f[m1] % frog * ni[i] % frog * ni[m1 - i] % frog;
nsum = (nsum + sum) % frog;
ci[n1 - i] = quickpow(a, nsum, q);
}
for (int i = n1 - m1 - 1; i > 0; i--) ci[i] = ci[i + 1];
for (int i = 1; i <= n1; i++) printf("%I64d ", ci[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
// #define ls n << 1
// #define rs n << 1 | 1
#define PB push_back
#define MP make_pair
#define int long long
// #define us unsigned
// #define LL long long
const int N = 5e5;
// const int M = 2e;
// #define re register
// const int mod = 10000;
// const double eps = 1e-8;
// inline char nc()
// {
// static char buf[1000000], *p1 = buf, *p2 = buf;
// return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++;
// }
// #define getchar nc
inline int read()
{
int s = 0;
register bool neg = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
neg |= (c == '-');
for (; c >= '0' && c <= '9'; s = s * 10 + (c ^ 48), c = getchar())
;
s = (neg ? -s : s);
return s;
}
int t,a,vis[N+10],siz[N+10];
bool p[N+10];
vector<int> st[N+10];
inline void dfs(int n) {
for(int i=0;i<st[n].size();i++) {
int v=st[n][i];
// cout<<v<<endl;
if(vis[v]!=1) {
vis[v]--;
if(vis[v]==1)
dfs(v);
}
}
}
inline void Dfs(int n,int fa) {
siz[n]=1;
for(int i=0;i<st[n].size();i++) {
int v=st[n][i];
if(v==fa) continue;
if(vis[v]==1) {
Dfs(v,n);
siz[n]+=siz[v];
}
}
}
signed main()
{
// freopen("in.txt","r",stdin);
t=read();
while(t--) {
a=read();
for(int i=1;i<=a;i++) siz[i]=vis[i]=p[i]=0,st[i].clear();
int x,y;
for(int i=1;i<=a;i++) {
x=read();
y=read();
st[x].PB(y);
st[y].PB(x);
vis[x]++;
vis[y]++;
if(vis[x]!=1) p[x]=1;
if(vis[y]!=1) p[y]=1;
}
// for(int i=1;i<=a;i++) cout<<vis[i]<<' ';
// cout<<endl;
for(int i=1;i<=a;i++) if(!p[i]) dfs(i);
// for(int i=1;i<=a;i++) cout<<vis[i]<<' ';
// cout<<endl;
int tmp=0,ans=0;
for(int i=1;i<=a;i++) if(vis[i]==2) {
Dfs(i,0);
ans+=tmp*siz[i]*2;
ans+=siz[i]*(siz[i]-1)/2;
tmp+=siz[i];
// cout<<siz[i]<<endl;
}
printf("%lld\n",ans);
}
return 0;
} | 6 |
#include<bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#endif
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
#define endl "\n"
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef std::vector<vector<int> > vvi;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
typedef vector<vll> vvll;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<ld> vld;
typedef vector<vld> vvld;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<char> vch;
typedef vector<vch> vvch;
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define repi(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)
#define pb push_back
#define fi first
#define se second
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a.size())
template<typename T> void umin(T &a, T b) { a = min(a, b); }
template<typename T> void umax(T &a, T b) { a = max(a, b); }
ll nxt() {
ll x; cin >> x; return x;
}
void setIO(string s) {
#ifndef LOCAL
ios_base::sync_with_stdio(0); cin.tie(0);
freopen((s+".in").c_str(),"r",stdin);
freopen((s+".out").c_str(),"w",stdout);
#endif
}
void yes() {
cout << "yes\n";
}
void no() {
cout << "no\n";
}
void flush() {
debug("#################");
}
const ll mod = 1e9 + 7;
const ll INF = 1e9;
void solve() {
int m, k; cin >> m >> k;
vi cnt(k + 1);
rep(i, 1, k + 1) {
cnt[i] = nxt();
}
int mx = *max_element(all(cnt));
int mxid = -1;
rep(i, 1, k + 1) if (cnt[i] == mx) mxid = i;
int lo = 1, hi = 200005;
while (lo < hi) {
int mid = (lo + hi) / 2;
ll one = 1LL * mid * mid - 1LL * (mid / 2) * (mid / 2);
ll two = 1LL * mid * ((mid + 1) / 2);
if (one >= m && two >= mx) {
hi = mid;
} else {
lo = mid + 1;
}
}
int n = lo;
vvi a(n + 1, vi(n + 1));
vpi filling_order;
rep(i, 1, k + 1) filling_order.pb({cnt[i], i});
sort(all(filling_order)); reverse(all(filling_order));
vi order;
for (auto it : filling_order) {
rep(i, 0, it.fi) order.pb(it.se);
}
assert(sz(order) == m);
int ptr = 0;
int done = 0;
for (int row = 2; row <= n; row += 2) {
for (int col = 1; col <= n; col += 2) {
if (done >= mx) break;
a[row][col] = order[ptr++];
done++;
}
}
if (done < mx) {
for (int row = 1; row <= n; row += 2) {
for (int col = 1; col <= n; col += 2) {
if (done >= mx) break;
a[row][col] = order[ptr++];
done++;
}
}
} else {
for (int row = 2; row <= n; row += 2) for (int col = 1; col <= n; col += 2) {
if (ptr >= m) break;
if (a[row][col] == 0) a[row][col] = order[ptr++];
}
}
//all reds are filled
//fill all non-filled
for (int row = 1; row <= n; row++) {
int add = 2;
if (row % 2 == 1) {
add = 1;
}
for (int col = 1; col <= n; col += add) {
if (a[row][col] == 0 && ptr < m) {
a[row][col] = order[ptr++];
}
}
}
cout << n << endl;
for (int row = 1; row <= n; row++) {
for (int col = 1; col <= n; col++) {
cout << a[row][col] << " ";
}
cout << endl;
}
flush();
for (int row = 1; row <= n; row++) for (int col = 1; col <= n; col++) {
debug(row, col);
if (row + 1 <= n && col + 1 <= n && a[row][col] != 0 && a[row + 1][col + 1] != 0) assert(a[row][col] != a[row + 1][col + 1]);
if (row + 1 <= n && col - 1 >= 1 && a[row][col] != 0 && a[row + 1][col - 1] != 0) assert(a[row][col] != a[row + 1][col - 1]);
if (row + 1 <= n && col + 1 <= n) assert(a[row][col] == 0 or a[row][col + 1] == 0 or a[row + 1][col] == 0 or a[row + 1][col + 1] == 0);
}
}
int32_t main(){
// setIO("trapped");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(10);
int T = 1;
cin >> T;
for (int tc = 1; tc <= T; tc++) {
// cout << "Case #" << tc << ": ";
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int f[(1 << 22) + 10], pre[(1 << 22) + 10], key[(1 << 22) + 10];
int a[30], ans[30], cnt, n, m;
queue<int> q;
void bfs() {
memset(f, 0, sizeof(f));
memset(key, -1, sizeof(key));
memset(pre, -1, sizeof(pre));
for (int i = 0; i < n; i++) {
f[a[i]] = 1;
key[a[i]] = i;
q.push(a[i]);
}
int now, tmp;
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < n; i++) {
if (now & (1 << i)) {
tmp = now | a[i];
if (!f[tmp]) {
f[tmp] = f[now] + 1;
key[tmp] = i;
pre[tmp] = now;
q.push(tmp);
if (tmp == ((1 << n) - 1)) {
return;
}
}
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
int from, to;
for (int i = 0; i < n; i++) {
a[i] |= (1 << i);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &from, &to);
from--;
to--;
a[from] |= (1 << to);
a[to] |= (1 << from);
}
if (m == n * (n - 1) / 2) {
puts("0");
return 0;
}
bfs();
cnt = 0;
int now = (1 << n) - 1;
while (~now) {
ans[++cnt] = key[now];
now = pre[now];
}
printf("%d\n", cnt);
while (cnt) {
printf("%d", ans[cnt--] + 1);
if (cnt)
printf(" ");
else
printf("\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<long long> st;
int main() {
long long a, b;
cin >> a >> b;
long long n = (a + b);
long long res = 1e18;
for (long long i = 1; i * i <= n; i++) {
if (a % i == 0) st.insert(a / i);
if (b % i == 0) st.insert(b / i);
if (n % i == 0) {
long long h = i;
long long w = n / i;
if (*st.begin() <= w) {
res = min(res, h * 2 + w * 2);
}
}
}
cout << res << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, tong = 0;
vector<int> v;
cin >> n >> x;
v.resize(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
tong += v[i] * x;
if (x > 1) {
x--;
}
}
cout << tong;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int mod = 1e9 + 7;
const int N = 106 * 106;
const int nax = 1e6 + 6;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
pair<int, int> me[3];
for (int i = 0; i < 3; i++) cin >> me[i].first >> me[i].second;
sort(me, me + 3);
int x = me[0].first;
int y = me[0].second;
int a = me[1].first;
int b = me[1].second;
int c = me[2].first;
int d = me[2].second;
int mn = min(y, d);
int mx = max(y, d);
set<pair<int, int>> ans;
ans.insert(make_pair(a, b));
if (mn < b) {
for (int i = b; i >= mn; i--) {
ans.insert(make_pair(a, i));
}
}
if (mx > b) {
for (int i = b; i <= mx; i++) {
ans.insert(make_pair(a, i));
}
}
ans.insert(make_pair(x, y));
for (int i = x; i <= a; i++) {
ans.insert(make_pair(i, y));
}
ans.insert(make_pair(c, d));
for (int i = c; i >= a; i--) {
ans.insert(make_pair(i, d));
}
cout << ans.size() << '\n';
for (auto it : ans) cout << it.first << ' ' << it.second << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 12;
bool a[maxn][maxn];
bool mark[maxn][maxn];
vector<int> ans;
int n;
bool isvalid(int jahat, int i, int j) {
if (i >= n || j >= n || j < 0 || i < 0) return 0;
if (jahat == 4) {
if (j + 1 == n) return 0;
bool q = 0;
for (int s = j + 1; s < n; s++)
if (a[i][s]) q = 1;
if (q) return 1;
return 0;
} else if (jahat == 3) {
if (i + 1 == n) return 0;
bool q = 0;
for (int s = i + 1; s < n; s++)
if (a[s][j]) q = 1;
if (q) return 1;
return 0;
} else if (jahat == 2) {
if (j - 1 == -1) return 0;
bool q = 0;
for (int s = j - 1; s >= 0; s--)
if (a[i][s]) q = 1;
if (q) return 1;
return 0;
} else {
if (i - 1 == -1) return 0;
bool q = 0;
for (int s = i - 1; s >= 0; s--)
if (a[s][j]) q = 1;
if (q) return 1;
return 0;
}
}
void dfs(int i, int j) {
mark[i][j] = 1;
if (!a[i][j]) ans.push_back(2), a[i][j] = 1;
if (isvalid(4, i, j))
if (!mark[i][j + 1]) ans.push_back(6), dfs(i, j + 1), ans.push_back(4);
if (isvalid(3, i, j))
if (!mark[i + 1][j]) ans.push_back(5), dfs(i + 1, j), ans.push_back(3);
if (isvalid(2, i, j))
if (!mark[i][j - 1]) ans.push_back(4), dfs(i, j - 1), ans.push_back(6);
if (isvalid(1, i, j))
if (!mark[i - 1][j]) ans.push_back(3), dfs(i - 1, j), ans.push_back(5);
ans.push_back(1), a[i][j] = 0;
}
int main() {
int x1, y1;
cin >> n >> x1 >> y1;
x1--, y1--;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
dfs(x1, y1);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i][j]) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 0; i < ans.size(); i++) {
if (ans[i] == 6)
cout << "R";
else if (ans[i] == 5)
cout << "D";
else if (ans[i] == 4)
cout << "L";
else if (ans[i] == 3)
cout << "U";
else if (ans[i] == 2)
cout << 1;
else
cout << 2;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int LL_MAX = 922337203685477580;
void seive(vector<long long int>& v, long long int n) {
v.push_back(n);
for (long long int i = 1; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
if (i != n / i) {
v.push_back(n / i);
}
}
}
}
long long int mod(long long int x) { return (x % MOD + MOD) % MOD; }
void solve() {
long long int n;
cin >> n;
long long int temp = n / 2;
long long int ans = 0;
long long int e = 8;
for (long long int i = 1; i < temp + 1; i++) {
ans += (i * e);
e += 8;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long a, b, c;
cin >> a >> b >> c;
long long ans = 0;
while (a >= 1 && b >= 2 && c >= 4) {
ans += 7;
a -= 1;
b -= 2;
c -= 4;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
vector<long long> cnt(n);
for (int i = 0; i < m; i++) {
int p;
cin >> p;
++cnt[p - 1];
}
for (int i = n - 1; i >= 1; i--) {
cnt[i - 1] += cnt[i];
}
int ans[26] = {0};
for (int i = 0; i < n; i++) {
ans[s[i] - 'a'] += cnt[i];
ans[s[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
int main() {
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
const int maxn = 300005;
int a[maxn];
long long dp[1005][1005];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i * k <= maxn; i++) {
for (int j = 1; j <= n; j++) dp[1][j] = 1;
for (int j = 2; j <= k; j++) {
int end = 1;
long long sum = 0;
for (int z = 1; z <= n; z++) {
while (a[z] - a[end] >= i) sum = (sum + dp[j - 1][end++]) % 998244353;
dp[j][z] = sum;
}
}
for (int j = 1; j <= n; j++) ans = (ans + dp[k][j]) % 998244353;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
struct suffixArray {
string s;
int n, alphabet;
vector<int> p, c, cnt, rank, lcp;
vector<vector<int> > st;
suffixArray() {}
suffixArray(string s) : s(s) {
s += '$';
n = s.size();
alphabet = 256;
p.resize(n, 0);
c.resize(n, 0);
cnt.resize(max(alphabet, n), 0);
rank.resize(n - 1, 0);
lcp.resize(n - 2, 0);
st.clear();
fill(p.begin(), p.begin() + n, 0);
fill(c.begin(), c.begin() + n, 0);
fill(cnt.begin(), cnt.begin() + max(alphabet, n), 0);
fill(rank.begin(), rank.begin() + n - 1, 0);
fill(lcp.begin(), lcp.begin() + n - 2, 0);
}
void build() {
for (int i = 0; i < n; i++) cnt[s[i]]++;
for (int i = 1; i < alphabet; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i < n; i++) p[--cnt[s[i]]] = i;
c[p[0]] = 0;
int classes = 1;
for (int i = 1; i < n; i++) {
if (s[p[i]] != s[p[i - 1]]) classes++;
c[p[i]] = classes - 1;
}
vector<int> pn(n), cn(n);
for (int h = 0; (1ll << h) < n; h++) {
for (int i = 0; i < n; i++) {
pn[i] = p[i] - (1ll << h);
if (pn[i] < 0) pn[i] += n;
}
fill(cnt.begin(), cnt.begin() + classes, 0);
for (int i = 0; i < n; i++) cnt[c[pn[i]]]++;
for (int i = 1; i < classes; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) p[--cnt[c[pn[i]]]] = pn[i];
cn[p[0]] = 0;
classes = 1;
for (int i = 1; i < n; i++) {
if (c[p[i]] != c[p[i - 1]] ||
c[p[i] + (1 << h) - (p[i] + (1 << h) < n ? 0 : n)] !=
c[p[i - 1] + (1 << h) - (p[i - 1] + (1 << h) < n ? 0 : n)])
classes++;
cn[p[i]] = classes - 1;
}
swap(c, cn);
}
n--;
p.erase(p.begin());
return;
}
int lcp2(int l, int r) {
l = rank[l];
r = rank[r];
if (l > r) swap(l, r);
int T = r - l + 1;
int lg = 31 - (__builtin_clz(T));
return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
}
void buildST() {
st.push_back(vector<int>(n, -1));
for (int i = 0; i < n; i++) st[0][i] = n - p[i];
for (int h = 1; (1ll << h) <= n; h++) {
st.push_back(vector<int>(n, -1));
for (int i = 0; i + (1ll << h) - 1 < n; i++) {
st[h][i] = min({st[h - 1][i], st[h - 1][i + (1ll << (h - 1))],
lcp[i - 1 + (1ll << (h - 1))]});
}
}
return;
}
void lcp_construction() {
for (int i = 0; i < n; i++) rank[p[i]] = i;
int k = 0;
for (int i = 0; i < n; i++) {
if (rank[i] == n - 1) {
k = 0;
continue;
}
int j = p[rank[i] + 1];
while (i + k < n && j + k < n && s[i + k] == s[j + k]) k++;
lcp[rank[i]] = k;
if (k) k--;
}
buildST();
return;
}
};
int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
int lim;
suffixArray sa;
vector<int> acum;
vector<string> cad;
bool cmp(int a, int b) {
int L, R;
if (a < lim) {
L = 0;
} else {
L = lim + 1;
}
if (a != L) L++;
if (b < lim) {
R = 0;
} else {
R = lim + 1;
}
if (b != R) R++;
int preffix = min(a - L, b - R);
int common = sa.lcp2(L, R);
if (common < preffix) return sa.rank[L] < sa.rank[R];
if (a - L < b - R) {
L = L + preffix + 1;
R = R + preffix;
preffix = b - R;
common = sa.lcp2(L, R);
if (common < preffix) return sa.rank[L] < sa.rank[R];
L = L + preffix;
R = R + preffix + 1;
} else if (a - L > b - R) {
L = L + preffix;
R = R + preffix + 1;
preffix = a - L;
common = sa.lcp2(L, R);
if (common < preffix) return sa.rank[L] < sa.rank[R];
L = L + preffix + 1;
R = R + preffix;
} else {
L = L + preffix + 1;
R = R + preffix + 1;
}
return sa.rank[L] < sa.rank[R];
}
void solve(int posi) {
vector<int> auxi(cad[posi].size() + 1, 0);
string s = "0" + cad[posi] + "$0" + cad[posi - 1] + "$";
sa = suffixArray(s);
sa.build();
sa.lcp_construction();
lim = cad[posi].size() + 1;
vector<int> ord;
for (int i = 0; i < s.size() - 1; i++) {
if (i == lim) continue;
ord.push_back(i);
}
sort(ord.begin(), ord.end(), cmp);
int sum = 0;
for (int i = 0; i < ord.size(); i++) {
int pp = ord[i];
if (pp < lim) {
auxi[pp] = add(auxi[pp], sum);
} else if (pp > lim) {
sum = add(sum, acum[pp - lim - 1]);
}
}
acum = auxi;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(10);
cout << fixed;
int n;
cin >> n;
cad.resize(n);
for (int i = 0; i < n; i++) cin >> cad[i];
if (n == 1) {
cout << cad[0].size() + 1 << "\n";
return 0;
}
acum.resize(cad[0].size() + 1, 1);
for (int i = 1; i < n; i++) solve(i);
int ans = 0;
for (int xx : acum) ans = add(ans, xx);
cout << ans << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int a[N];
int main() {
int n, i;
scanf("%d", &n);
if (n % 4 == 2 || n % 4 == 3)
printf("-1\n");
else {
for (i = 1; i <= n / 2; i += 2) {
a[i] = i + 1;
a[i + 1] = n - i + 1;
a[n - i] = i;
a[n - i + 1] = n - i;
}
if (n % 4 == 1) a[n / 2 + 1] = n / 2 + 1;
for (i = 1; i < n; i++) printf("%d ", a[i]);
printf("%d\n", a[n]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[105];
vector<int> graph[105];
int node;
int dp[105][105];
int main() {
int x, y;
long long T, n, k;
vector<int> v;
map<int, int> freq;
int n0, n1, n2;
cin >> T;
while (T--) {
cin >> n >> k;
long long temp = k, sum = 0;
int rem = 0;
while (temp > 0) {
temp += rem;
rem = temp % n;
sum += temp / n;
temp /= n;
}
k += sum;
if (k % n == 0) {
cout << k + 1 << endl;
} else
cout << k << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 30000;
long long base[6][6], a[6];
int n, d, c;
map<unsigned long long, int> h;
long long Pow(long long a, long long b, long long mod) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long inv(long long a) { return Pow(a, mod - 2, mod); }
void ins(long long *a) {
for (int i = 1; i <= d; ++i)
if (a[i])
if (base[i][i]) {
long long num = mod - a[i];
for (int j = i; j <= d; ++j)
a[j] = (a[j] + num * base[i][j] % mod) % mod;
} else {
long long num = inv(a[i]);
for (int j = i; j <= d; ++j) a[j] = a[j] * num % mod;
for (int j = 1; j <= d; ++j) base[i][j] = a[j];
break;
}
}
int main() {
int T;
scanf("%d%d", &T, &d);
while (T--) {
memset(base, 0, sizeof(base));
scanf("%d", &n);
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= d; ++i)
scanf("%lld", &a[i]), a[i] = (a[i] + mod) % mod;
ins(a);
}
for (int i = 1; i <= d; ++i)
if (base[i][i])
for (int j = 1; j < i; ++j)
if (base[j][i]) {
long long num = mod - base[j][i];
for (int k = 1; k <= d; ++k)
base[j][k] = (base[j][k] + num * base[i][k] % mod) % mod;
}
unsigned long long num = 0;
for (int i = 1; i <= d; ++i)
for (int j = 1; j <= d; ++j) num = num * 233 + base[i][j];
if (h[num] == 0) h[num] = ++c;
printf("%d ", h[num]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void RI() {}
template <typename... T>
void RI(int& head, T&... tail) {
scanf("%d", &head);
RI(tail...);
}
const int N = 100010;
const int M = 500010;
struct E {
int a, b;
} es[M];
int n, m, old_m;
vector<int> e[N];
void add_edge(int a, int b) {
e[a].push_back(m);
e[b].push_back(m);
es[m++] = E{a, b};
}
int loop[N];
void input() {
RI(n, old_m);
m = 0;
for (int i = (1); i <= int(n); i++) e[i].clear();
for (int i = 0; i < int(old_m); i++) {
int a, b;
RI(a, b);
add_edge(a, b);
}
}
void build() {
old_m = m;
vector<int> odd;
for (int i = (1); i <= int(n); i++)
if (((int)(e[i]).size()) % 2 == 1) odd.push_back(i);
assert(((int)(odd).size()) % 2 == 0);
for (int i = 0; i < ((int)(odd).size()); i += 2) add_edge(odd[i], odd[i + 1]);
}
vector<int> path;
bool vis[M];
void dfs(int p) {
while (!e[p].empty()) {
int i = e[p].back();
e[p].pop_back();
if (vis[i]) continue;
auto& ee = es[i];
vis[i] = 1;
dfs(p ^ ee.a ^ ee.b);
}
path.push_back(p);
}
int ci[N], co[N];
void solve() {
for (int i = 0; i < int(m); i++) vis[i] = 0;
dfs(1);
for (int i = (1); i <= int(n); i++) assert(e[i].empty());
assert(path[0] == path.back());
vector<pair<int, int> > sol;
for (int i = 0; i < int(((int)(path).size()) - 1); i++) {
if (i % 2 == 0)
sol.push_back(make_pair(path[i], path[i + 1]));
else
sol.push_back(make_pair(path[i + 1], path[i]));
}
for (auto it = (sol).begin(); it != (sol).end(); it++) {
ci[it->first]++;
co[it->second]++;
}
vector<int> vi, vo;
for (int i = (1); i <= int(n); i++)
if (ci[i] % 2 == 1) vi.push_back(i);
for (int i = (1); i <= int(n); i++)
if (co[i] % 2 == 1) vo.push_back(i);
assert(((int)(vi).size()) == ((int)(vo).size()));
for (int i = 0; i < int(((int)(vi).size())); i++)
sol.push_back(make_pair(vi[i], vo[i]));
printf("%d\n", ((int)(sol).size()));
for (auto it = (sol).begin(); it != (sol).end(); it++)
printf("%d %d\n", it->first, it->second);
}
int main() {
input();
build();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 9;
long long tr[4 * maxn], a[maxn];
bool s[20];
void update(int rt, int l, int r, int pos, int val, int f) {
if (l == r) {
tr[rt] = val;
} else {
if (s[f]) pos = l + r - pos;
int mid = (l + r) / 2;
if (pos <= mid) {
update((rt * 2), l, mid, pos, val, f - 1);
} else {
update((rt * 2 + 1), mid + 1, r, pos, val, f - 1);
}
tr[rt] = tr[(rt * 2)] + tr[(rt * 2 + 1)];
}
}
long long query(int rt, int l, int r, int L, int R, int f) {
if (s[f]) {
int L1 = L;
L = l + r - R;
R = l + r - L1;
}
if (l >= L && r <= R) {
return tr[rt];
}
int mid = (l + r) / 2;
long long ans = 0;
if (L <= mid) {
ans += query((rt * 2), l, mid, L, R, f - 1);
}
if (R > mid) {
ans += query((rt * 2 + 1), mid + 1, r, L, R, f - 1);
}
return ans;
}
int main(int argc, char** argv) {
int n, q;
scanf("%d%d", &n, &q);
int len = 1 << n;
for (int i = 1; i <= len; i++) {
scanf("%d", &a[i]);
update(1, 1, len, i, a[i], n);
}
for (int i = 1; i <= q; i++) {
int in;
scanf("%d", &in);
if (in == 1) {
int pos, val;
scanf("%d%d", &pos, &val);
update(1, 1, len, pos, val, n);
}
if (in == 2) {
int k;
scanf("%d", &k);
s[k] ^= 1;
}
if (in == 3) {
int k;
scanf("%d", &k);
s[k + 1] ^= 1;
s[k] ^= 1;
}
if (in == 4) {
int l, r;
scanf("%d%d", &l, &r);
cout << query(1, 1, len, l, r, n) << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = -1;
const int mod = 1e9 + 7;
int sum(int a, int b) {
int c = (a + b);
if (c >= mod) c -= mod;
return c;
}
int mul(int a, int b) { return 1ll * a * b % mod; }
void solve() {
int x;
cin >> x;
string s;
cin >> s;
int mx = 2 * x;
int len = ((int)(s).size());
for (int i = 1; i <= x; i++) {
int cur = i;
int rem = sum(len, mod - i);
len = sum(len, mul(rem, (s[i - 1] - '1')));
string t = "";
if (((int)(s).size()) < mx && s[i - 1] != '1')
t = s.substr(i, ((int)(s).size()) - i);
while (((int)(s).size()) < mx && s[i - 1] != '1') {
s += t;
s[i - 1]--;
}
}
cout << len << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
int A[2123456];
int main() {
int n;
scanf("%d", &n);
int a, b, c;
printf("? %d %d\n", 1, 2);
fflush(stdout);
scanf("%d", &a);
printf("? %d %d\n", 1, n);
fflush(stdout);
scanf("%d", &b);
printf("? %d %d\n", 2, n);
fflush(stdout);
scanf("%d", &c);
int one = a + b - c;
one >>= 1;
int two = a - one;
int en = b - one;
A[1] = one;
A[2] = two;
A[n] = en;
for (int i = 2; i < n - 1; i++) {
int foo;
printf("? %d %d\n", i, i + 1);
fflush(stdout);
scanf("%d", &foo);
A[i + 1] = foo - two;
two = A[i + 1];
}
printf("! ");
for (int i = 1; i < n; i++) printf("%d ", A[i]);
printf("%d\n", A[n]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v[100005], ans;
int n, A[100005], p;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> p >> A[i];
if (p != -1) v[p].push_back(i);
}
for (int i = 1; i <= n; ++i) {
if (A[i] == 0) continue;
bool ok = true;
for (auto g : v[i]) {
if (A[g] != 1) {
ok = false;
break;
}
}
if (ok) ans.push_back(i);
}
sort(ans.begin(), ans.end());
for (auto g : ans) cout << g << " ";
if ((int)ans.size() == 0) cout << -1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
long long fastPow(long long a, long long b) {
if (b == 0) {
return 1;
}
ans = fastPow(a, b / 2);
ans *= ans;
if (b & 1) {
return a * ans;
} else {
return ans;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, i, j, k, count = 0, sum = 0;
cin >> n;
vector<long long> v(n);
unordered_map<long long, long long> m1;
for (i = 0; i < n; i++) {
cin >> v[i];
}
sort((v).begin(), (v).end());
i = 0;
while (i < n) {
if (m1[i] == 0) {
m1[i] = 1;
count++;
sum = 1;
for (j = 0; j < v.size(); j++) {
if (v[j] >= sum && m1[j] == 0) {
m1[j] = 1;
sum++;
}
}
}
i++;
}
cout << count;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1.1e5;
int n, m, nq;
int f[N];
int fn(int x) { return f[x] ? (f[x] = fn(f[x])) : x; }
int64_t ans;
struct E {
int x, y, z;
bool operator<(const E& o) const { return z < o.z; }
} e[N * 2];
vector<pair<int, int>> a[N];
int d[N], up[N][17], upm[N][17];
void dfs(int v, int f) {
d[v] = d[f] + 1;
for (int i = 1; i < 17; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
upm[v][i] = max(upm[v][i - 1], upm[up[v][i - 1]][i - 1]);
}
for (auto& i : a[v])
if (i.first != f) {
up[i.first][0] = v;
upm[i.first][0] = i.second;
dfs(i.first, v);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].z);
sort(e, e + m);
int nc = n;
for (int i = 0; i < m; ++i) {
int x = fn(e[i].x), y = fn(e[i].y);
if (x != y) {
ans += e[i].z;
f[x] = y;
--nc;
a[e[i].x].emplace_back(e[i].y, e[i].z);
a[e[i].y].emplace_back(e[i].x, e[i].z);
}
}
if (nc == 1) dfs(1, 0);
scanf("%d", &nq);
while (nq--) {
int x, y;
scanf("%d%d", &x, &y);
if (nc > 2)
puts("-1");
else if (nc == 2 && fn(x) == fn(y))
puts("-1");
else if (nc == 2)
printf("%" PRId64 "\n", ans);
else if (nc == 1) {
int mx = 0;
if (d[x] > d[y]) swap(x, y);
int dd = d[y] - d[x];
for (int i = 0; i < 17; ++i)
if (dd >> i & 1) {
mx = max(mx, upm[y][i]);
y = up[y][i];
}
for (int i = 16; i >= 0; --i) {
if (up[x][i] != up[y][i]) {
mx = max(mx, upm[x][i]);
mx = max(mx, upm[y][i]);
x = up[x][i];
y = up[y][i];
}
}
if (x != y) {
mx = max(mx, upm[x][0]);
mx = max(mx, upm[y][0]);
x = up[x][0];
y = up[y][0];
}
printf("%" PRId64 "\n", ans - mx);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
vector<vector<int> > pf(26, vector<int>(n));
for (int i = 0; i < 26; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (s[j] == 'a' + i) sum++;
pf[i][j] = sum;
}
}
int m;
cin >> m;
while (m--) {
string t;
cin >> t;
vector<int> temp(26);
int len = t.size();
for (int i = 0; i < len; i++) {
temp[t[i] - 'a']++;
}
int start = 0;
for (int j = 0; j < 26; j++) {
int ind = lower_bound(pf[j].begin() + start, pf[j].end(), temp[j]) -
pf[j].begin();
start = ind;
}
cout << start + 1 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t;
vector<pair<int, int>> a[30], res[2];
string s[2005];
bool cmp1(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) {
return a.first < b.first;
} else {
return a.second < b.second;
}
}
bool cmp2(pair<int, int> a, pair<int, int> b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < 30; i++) {
a[i].clear();
}
res[0].clear();
res[1].clear();
for (int i = 1; i <= n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size(); j++) {
if (s[i][j] != '.') {
a[s[i][j] - 'a'].push_back(make_pair(i, j + 1));
}
}
}
bool flag = 0;
int mx;
for (int i = 29; i >= 0; i--) {
if (a[i].size()) {
mx = i;
flag = 1;
break;
}
}
if (!flag) {
cout << "YES" << endl;
cout << "0" << endl;
continue;
}
flag = 1;
for (int i = mx; i >= 0; i--) {
if (a[i].size() == 0) {
res[0].push_back(res[0][0]);
res[1].push_back(res[1][0]);
continue;
}
sort(a[i].begin(), a[i].end(), cmp1);
if (a[i][0].first == a[i][a[i].size() - 1].first) {
res[0].push_back(make_pair(a[i][0].first, a[i][0].second));
res[1].push_back(make_pair(a[i][a[i].size() - 1].first,
a[i][a[i].size() - 1].second));
} else {
sort(a[i].begin(), a[i].end(), cmp2);
if (a[i][0].second == a[i][a[i].size() - 1].second) {
res[0].push_back(make_pair(a[i][0].first, a[i][0].second));
res[1].push_back(make_pair(a[i][a[i].size() - 1].first,
a[i][a[i].size() - 1].second));
} else {
flag = 0;
break;
}
}
pair<int, int> x = res[0][res[0].size() - 1],
y = res[1][res[1].size() - 1];
for (int j = min(x.first, y.first); j <= max(x.first, y.first); j++) {
for (int k = min(x.second, y.second); k <= max(x.second, y.second);
k++) {
if ((s[j][k - 1] < 'a' + i) || (s[j][k - 1] == '.')) {
flag = 0;
}
}
}
if (!flag) break;
}
if (!flag) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << res[0].size() << endl;
for (int i = res[0].size() - 1; i >= 0; i--) {
cout << res[0][i].first << ' ' << res[0][i].second << ' '
<< res[1][i].first << ' ' << res[1][i].second << endl;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
int main() {
int n;
while (cin >> n) {
int flag = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 != 0) flag = 1;
}
flag == 1 ? cout << "First" << endl : cout << "Second" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
int main() {
double a, b, m;
double vx, vy, vz;
scanf("%lf%lf%lf%lf%lf%lf", &a, &b, &m, &vx, &vy, &vz);
vy = -vy;
double t = m / vy;
int count = (int)(t * vz / b);
double z0 = t * vz - b * count;
if (count % 2) z0 = b - z0;
int flag;
if (vx > 0)
flag = 1;
else {
flag = 0;
vx = -vx;
}
double x0;
if (vx <= eps)
x0 = 0.5 * a;
else {
double res = 0.5 * a * vy / vx;
if (m < res)
x0 = (res - m) * vx / vy;
else {
m -= res;
t = m / vy;
count = (int)(t * vx / a);
x0 = t * vx - count * a;
if (count % 2) x0 = a - x0;
}
}
if (flag) x0 = a - x0;
printf("%.10lf %.10lf\n", x0, z0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
printf("%d\n", (n & 1) ? (n - 1) + (n - 1) * ((n - 3) / 2) / 2
: (n - 2) * (n - 2) / 4 + (n - 2));
if (n & 1) {
for (int i = 2; i <= n; i += 2) {
printf("%d %d %d %d\n", 3, 1, i, i + 1);
printf("%d %d %d %d\n", 3, 1, i, i + 1);
for (int j = 2; j < i; j += 2) {
printf("%d %d %d %d %d\n", 4, i, j, i + 1, j + 1);
printf("%d %d %d %d %d\n", 4, i, j, i + 1, j + 1);
}
}
} else {
puts("4 1 2 3 4"), puts("4 1 3 4 2"), puts("4 1 4 2 3");
for (int i = 5; i <= n; i += 2) {
printf("%d %d %d %d \n", 3, 1, i, i + 1);
printf("%d %d %d %d \n", 3, 2, i, i + 1);
printf("%d %d %d %d %d\n", 4, 1, i, 2, i + 1);
for (int j = 3; j < i; j += 2) {
printf("%d %d %d %d %d\n", 4, i, j, i + 1, j + 1);
printf("%d %d %d %d %d\n", 4, i, j, i + 1, j + 1);
}
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
if (b > 0) {
for (int i = 0; i < b; i++) {
a++;
if (a == n + 1) a = 1;
}
} else if (b < 0) {
b = abs(b);
for (int i = 0; i < b; i++) {
a--;
if (a == 0) a = n;
}
}
cout << a << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1, num, count;
cin >> n1;
int n = n1 * 2;
int inum = sqrt(n);
bool is = false;
for (int i = 1; i <= inum; i++) {
num = n - (i * i + i);
int l = 0, r = inum, m;
if (i == 30) {
int b;
int c;
int s;
}
while (l <= r) {
m = (l + r) / 2;
if (m * m + m > num) {
r = m - 1;
} else if (m * m + m < num) {
l = m + 1;
} else {
is = true;
count = m;
goto loop;
}
}
}
loop:
if (is && count != 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, si[1050005];
long long a[1050005], b[1050005];
char s[20][100005];
inline void fwt(long long *a, int l, int r) {
if (l == r) return;
int mid = l + r >> 1;
fwt(a, l, mid), fwt(a, mid + 1, r);
for (int i = l; i <= mid; i++) {
long long x = a[i], y = a[i + mid - l + 1];
a[i] = x + y, a[i + mid - l + 1] = x - y;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= m; i++) {
int t = 0;
for (int j = 1; j <= n; j++) t = t * 2 + s[j][i] - '0';
a[t]++;
}
k = (1 << n) - 1;
for (int i = 1; i <= k; i++) si[i] = si[i ^ (i & -i)] + 1;
for (int i = 0; i <= k; i++) b[i] = max(si[i], n - si[i]);
fwt(a, 0, k);
fwt(b, 0, k);
for (int i = 0; i <= k; i++) a[i] = a[i] * b[i];
fwt(a, 0, k);
int ans = 0;
for (int i = 0; i <= k; i++) ans = max(ans, (int)(a[i] / (k + 1)));
printf("%d\n", n * m - ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool cmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
bool cmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int N = 1e4 + 10;
int n;
char s[N];
int f[N][2];
int same(int i1, int j1, int i2, int j2) {
if (j1 != j2) {
return 0;
}
for (int k = 0; k < 2 + j1; k++) {
if (s[i1 + k] != s[i2 + k]) {
return 0;
}
}
return 1;
}
int main() {
scanf("%s", s);
n = strlen(s);
reverse(s, s + n);
n -= 5;
f[2][0] = f[3][1] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (f[i][j] == 0) {
continue;
}
for (int k = 0; k < 2 && i + 2 + k <= n; k++) {
if (!same(i - (2 + j), j, i, k)) {
f[i + 2 + k][k] |= 1;
}
}
}
}
set<string> ans;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 2; j++) {
if (f[i][j]) {
string t = "";
for (int k = 0; k < 2 + j; k++) {
t += s[i - k - 1];
}
ans.insert(t);
}
}
}
printf("%d\n", ((int)(ans).size()));
for (string s : ans) {
printf("%s\n", s.c_str());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<long long int, long long int> > v;
vector<pair<long long int, long long int> > vv;
long long int n, k;
cin >> n >> k;
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
long long int l;
cin >> l;
sum += l;
v.push_back(make_pair(l, i + 1));
}
long long int r = sum % n;
if (r != 0) r = 1;
sort(v.begin(), v.end());
if (v[0].first + r == v[n - 1].first) {
cout << r << " " << 0;
return 0;
}
long long int u = 0;
for (long long int i = 1; i <= k; i++) {
vv.push_back(make_pair(v[n - 1].second, v[0].second));
v[0].first++;
v[n - 1].first--;
sort(v.begin(), v.end());
if (v[0].first + r == v[n - 1].first) {
cout << r << " " << i << endl;
u = 1;
break;
}
}
if (u == 1) {
for (long long int i = 0; i < vv.size(); i++) {
cout << vv[i].first << " " << vv[i].second << endl;
}
return 0;
}
cout << v[n - 1].first - v[0].first << " " << k << endl;
for (long long int i = 0; i < vv.size(); i++)
cout << vv[i].first << " " << vv[i].second << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(2e9) + 99;
int n, x, y, d;
int dist(int x, int y) { return (abs(x - y) + (d - 1)) / d; }
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
cin >> n >> x >> y >> d;
int len = abs(x - y);
int res = INF;
if (len % d == 0) res = min(res, dist(x, y));
len = y - 1;
if (len % d == 0) res = min(res, dist(x, 1) + dist(1, y));
len = n - y;
if (len % d == 0) res = min(res, dist(x, n) + dist(n, y));
if (res == INF) res = -1;
cout << res << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ans = 0;
void f(int n, int x = 1) {
if (x > n) return;
ans++;
f(n, 10 * x), f(n, 10 * x + 1);
}
int main() {
int n;
cin >> n;
f(n);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) { return (a >= b ? a : b); }
long long int min(long long int a, long long int b) { return (a <= b ? a : b); }
void solve_code() {
long long int n;
cin >> n;
long long int a[n + 1];
for (int(i) = 0; (i) < n; (i)++) cin >> a[i];
long long int right[n + 1];
long long int left[n + 1];
left[0] = 1;
for (int(i) = (1); (i) < (n); (i)++)
if (a[i] > a[i - 1])
left[i] = left[i - 1] + 1;
else
left[i] = 1;
right[n - 1] = 1;
for (int(i) = (n - 2); (i) >= (0); (i)--)
if (a[i] < a[i + 1])
right[i] = right[i + 1] + 1;
else
right[i] = 1;
long long int val[n + 1];
for (int(i) = (0); (i) < (n); (i)++) {
if (i == 0) {
if (a[i] < a[i + 1])
val[i] = right[i];
else
val[i] = right[i + 1];
} else if (i == n - 1) {
if (a[i] > a[i - 1])
val[i] = left[i];
else
val[i] = left[i - 1];
} else {
if (a[i - 1] < a[i + 1]) {
if (a[i] > a[i - 1] && a[i] < a[i + 1])
val[i] = left[i] + right[i] - 1;
else
val[i] = left[i - 1] + right[i + 1];
} else {
val[i] = max(left[i], right[i]);
}
}
}
sort(val, val + n);
cout << val[n - 1];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int test = 1;
while (test--) {
solve_code();
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[2000069], fq[2000069], sq[2][1000069], zs[2];
int main() {
long long i, ii, u, p;
scanf("%lld", &n);
for (i = 1; i <= n * 2; i++) {
scanf("%lld", a + i);
u = (i <= n) * 2 - 1;
a[i] *= u;
}
for (p = 1; fq[p] < 2; p += a[p]) {
if (fq[p]) {
zs[p > n]++;
sq[p > n][zs[p > n]] = (p - 1) % n + 1;
}
fq[p]++;
}
for (ii = 0; ii < 2; ii++) {
printf("%lld\n", zs[ii]);
for (i = 1; i <= zs[ii]; i++) {
printf("%lld%c", sq[ii][i], " \n"[i == zs[ii]]);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 25;
const int BASE_BITS = 31, INF = (1ll << BASE_BITS) - 1;
const int64_t OFFSET = 1ll << (BASE_BITS - 1);
int N;
int bestA0 = -INF;
int64_t bestMask = 0;
array<int, 3> A[MAXN];
map<int64_t, int64_t> firstHalf;
void find1stHalf(int id, int lim, array<int, 3> &arr, uint32_t curMask) {
if (id == lim) {
int64_t code =
((arr[1] - arr[0] + OFFSET) << BASE_BITS) ^ (arr[2] - arr[0] + OFFSET);
if (firstHalf.find(code) != firstHalf.end() &&
(firstHalf[code] >> BASE_BITS) >= arr[0])
return;
firstHalf[code] = ((int64_t)arr[0] << BASE_BITS) ^ curMask;
return;
}
for (int i = 0; i <= 2; ++i) arr[i] += A[id][i];
for (int i = 0; i <= 2; ++i) {
arr[i] -= A[id][i];
find1stHalf(id + 1, lim, arr, curMask | (i << (2 * id)));
arr[i] += A[id][i];
}
for (int i = 0; i <= 2; ++i) arr[i] -= A[id][i];
}
void find2ndHalf(int id, int lim, array<int, 3> &arr, int64_t curMask) {
if (id == lim) {
int64_t code =
((arr[0] - arr[1] + OFFSET) << BASE_BITS) ^ (arr[0] - arr[2] + OFFSET);
if (firstHalf.find(code) == firstHalf.end()) return;
uint32_t firstHalfMask = firstHalf[code] & ((1ll << BASE_BITS) - 1);
int firstHalfA0 = firstHalf[code] >> BASE_BITS;
if (firstHalfA0 + arr[0] > bestA0) {
bestA0 = firstHalfA0 + arr[0];
bestMask = curMask ^ firstHalfMask;
}
return;
}
for (int i = 0; i <= 2; ++i) arr[i] += A[id][i];
for (int i = 0; i <= 2; ++i) {
arr[i] -= A[id][i];
find2ndHalf(id + 1, lim, arr, curMask | ((int64_t)i << (2 * id)));
arr[i] += A[id][i];
}
for (int i = 0; i <= 2; ++i) arr[i] -= A[id][i];
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int i = 0; i <= N - 1; ++i)
for (int j = 0; j <= 2; ++j) cin >> A[i][j];
array<int, 3> tmp = {};
find1stHalf(0, N / 2, tmp, 0);
find2ndHalf(N / 2, N, tmp, 0);
if (bestA0 == -INF) return cout << "Impossible" << endl, 0;
for (int i = 0; i <= N - 1; ++i) {
int leftover = (bestMask >> (2 * i)) & 3;
assert(leftover != 3);
if (leftover != 0) cout << 'L';
if (leftover != 1) cout << 'M';
if (leftover != 2) cout << 'W';
cout << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
long long a, z;
int p, i, j, P[78777];
int C(long long x) {
for (j = 0;;) {
z = P[j++];
if ((z * z) > x) return 1;
if (!(x % z)) return 0;
}
}
inline int F(int i, long long a) {
if (a == 1) return 1;
long long y = P[i];
if ((y + 1) > a) return 0;
if (((y * y) + 1) > a) return C(--a);
int res = F(i + 1, a);
for (;;) {
if (++y > a) return res;
if (!(a % y)) res += F(i + 1, a / y);
y = (y - 1) * P[i];
}
}
int main() {
P[p++] = 2;
for (i = 3; i < 1000010; i += 2) P[C(i) ? p++ : p] = i;
scanf("%I64d", &a);
printf("%d\n", F(0, a));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> A(n + 10, 0);
for (int i = 0; i < n; i++) cin >> A[i];
unordered_map<long long, int> fir, sec;
fir[A[0]] = 1;
for (int i = 1; i < n; i++) sec[A[i]]++;
long long S = 0;
for (int i = 0; i < n; i++) S += A[i];
long long sdash = 0;
if (S & 1) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < n; i++) {
sdash += A[i];
if (sdash == S / 2) {
cout << "YES";
return 0;
}
if (sdash < S / 2) {
long long x = S / 2 - sdash;
if (sec[x] > 0) {
cout << "YES";
return 0;
}
} else {
long long y = sdash - S / 2;
if (fir[y] > 0) {
cout << "YES";
return 0;
}
}
fir[A[i + 1]]++;
sec[A[i + 1]]--;
}
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, s[333333], pz[333333], have[333333], p[333333];
void modify(int x, int v) {
while (x <= n) {
s[x] += v;
x = (x | (x - 1)) + 1;
}
}
int findsum(int x) {
int v = 0;
while (x > 0) {
v += s[x];
x &= x - 1;
}
return v;
}
void put(int x, int v) {
if (have[x] != v) {
modify(x, v - have[x]);
have[x] = v;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int foo;
scanf("%d", &foo);
p[i] = foo;
pz[foo] = i;
}
for (int i = 1; i <= n; i++) s[i] = have[i] = 0;
for (int i = 1; i < n; i++)
if (pz[i] > pz[i + 1]) put(i, 1);
int tt;
scanf("%d", &tt);
while (tt--) {
int com, x, y;
scanf("%d %d %d", &com, &x, &y);
if (com == 1) {
printf("%d\n", findsum(y - 1) - findsum(x - 1) + 1);
} else {
int tmp = p[x];
p[x] = p[y];
p[y] = tmp;
pz[p[x]] = x;
pz[p[y]] = y;
{
int z = x;
if (p[z] > 1)
if (pz[p[z] - 1] > pz[p[z]])
put(p[z] - 1, 1);
else
put(p[z] - 1, 0);
if (p[z] < n)
if (pz[p[z]] > pz[p[z] + 1])
put(p[z], 1);
else
put(p[z], 0);
}
{
int z = y;
if (p[z] > 1)
if (pz[p[z] - 1] > pz[p[z]])
put(p[z] - 1, 1);
else
put(p[z] - 1, 0);
if (p[z] < n)
if (pz[p[z]] > pz[p[z] + 1])
put(p[z], 1);
else
put(p[z], 0);
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int t, k, n, up;
int cg[30];
bool used[30];
char s[maxn], a[maxn], b[maxn];
inline bool dfs(int pos, bool lil, bool lir) {
if (pos >= n) return true;
char c = s[pos], l = a[pos], r = b[pos];
int now = c - 'a';
int mic = lil ? l - 'a' : 0;
int mac = lir ? r - 'a' : up;
if (cg[now] == -1) {
for (register int i = mic; i <= mac; ++i)
if (!used[i]) {
used[i] = 1;
int pre = cg[now];
cg[now] = i;
if (dfs(pos + 1, lil & (i == mic), lir & (i == mac))) return true;
cg[now] = pre;
used[i] = 0;
}
return false;
} else if (cg[now] < mic || cg[now] > mac)
return false;
else
return dfs(pos + 1, lil & (cg[now] == mic), lir & (cg[now] == mac));
}
inline void solve() {
memset(used, 0, sizeof(used));
memset(cg, -1, sizeof(cg));
scanf("%d", &k);
up = k - 1;
scanf("%s%s%s", s, a, b);
n = strlen(s);
for (register int i = 0; i < n; ++i)
if ((s[i] - 'a') > up) {
printf("NO\n");
return;
}
if (dfs(0, 1, 1)) {
printf("YES\n");
for (register int i = 0; i < k; ++i)
if (cg[i] == -1)
for (register int j = 0; j < k; ++j)
if (!used[j]) {
used[j] = 1;
cg[i] = j;
break;
}
for (register int i = 0; i < k; ++i) printf("%c", cg[i] + 'a');
printf("\n");
return;
}
printf("NO\n");
return;
}
int main() {
scanf("%d", &t);
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long MAX_N = 2e5 + 100;
const long long MOD = 1e9 + 7;
using namespace std;
long long rm[MAX_N][20];
long long a[MAX_N];
map<int, int> last;
long long ans;
const long long c = (1ll << 50) - 1;
long long ask(long long l, long long r) {
long long len = r - l + 1;
int lg = (int)log2(len);
long long s = r - (1 << lg) + 1;
return (rm[l][lg] | rm[s][lg]);
}
bool check(long long i, long long j) {
j ^= c;
if (j & i) return true;
return false;
}
int main() {
long long n;
cin >> n;
ans = n * (n + 1) / 2;
for (int i = 1; i <= n; ++i) cin >> a[i], last[a[i]] = 0;
for (int i = 1; i <= n; ++i) rm[i][0] = a[i];
for (int i = 1; i < 20; ++i) {
for (int j = 1; j <= n - (1 << i) + 1; ++j) {
rm[j][i] = rm[j][i - 1] | rm[j + (1 << (i - 1))][i - 1];
}
}
for (int i = 1; i <= n; ++i) {
long long l1 = i;
long long r1 = last[a[i]] + 1;
long long l2 = i;
long long r2 = n;
if (!check(ask(r1, i), a[i]))
l1 = r1;
else {
while (l1 - r1 > 1) {
long long mid = (l1 + r1) / 2;
if (!check(ask(mid, i), a[i]))
l1 = mid;
else
r1 = mid;
}
}
if (!check(ask(i, n), a[i]))
l2 = n;
else {
while (r2 - l2 > 1) {
long long mid = (l2 + r2) / 2;
if (!check(ask(i, mid), a[i]))
l2 = mid;
else
r2 = mid;
}
}
ans -= (i - l1 + 1) * (l2 - i + 1);
last[a[i]] = i;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1e3 + 7;
const double eps = 1e-6, pi = acos(-1);
struct P {
double x, y;
P(double _x = 0, double _y = 0) { x = _x, y = _y; }
} p[N];
P operator-(P a, P b) { return P(a.x - b.x, a.y - b.y); }
double operator*(P a, P b) { return a.x * b.x + a.y * b.y; }
double cal(P a, P b) { return acos(a * b / (a * a) / (b * b)); }
bool chk(P a, P b, P c) {
double ang1 = pi - cal(a, b);
double ang2 = pi - cal(b, c);
return fabs(ang1 + ang2 - pi) < eps;
}
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lf%lf", &p[i].x, &p[i].y);
if (n & 1)
puts("NO");
else {
double xc = p[1].x + p[n / 2 + 1].x;
double yc = p[1].y + p[n / 2 + 1].y;
bool ans = 1;
for (int i = 2; i <= n / 2; i++)
ans &= (p[i].x + p[n / 2 + i].x == xc) && (p[i].y + p[n / 2 + i].y == yc);
if (ans)
puts("YES");
else
puts("NO");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int getint() {
unsigned int c;
int x = 0;
while (((c = getchar()) - '0') >= 10) {
if (c == '-') return -getint();
if (!~c) exit(0);
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while (((c = getchar()) - '0') < 10);
return x;
}
long long getll() {
unsigned int c;
long long x = 0;
while (((c = getchar()) - '0') >= 10) {
if (c == '-') return -getll();
if (!~c) exit(0);
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while (((c = getchar()) - '0') < 10);
return x;
}
const int MAXN = 66;
long long bn[MAXN + 1][MAXN + 1];
void make_bn(int n) {
for (int i = 0; i <= n; i++) {
bn[i][0] = bn[i][i] = 1;
for (int j = 1; j < i; j++) bn[i][j] = bn[i - 1][j - 1] + bn[i - 1][j];
}
}
long long m;
int k, add;
unsigned long long count(unsigned long long now, int need) {
if (need == 0) {
if (now == 0) return 1;
return 0;
}
if (now == 0) return 0;
int under_bits;
for (under_bits = 0; (1ULL << (under_bits + 1)) <= now; under_bits++)
;
return bn[under_bits][need] + count(now - (1ULL << under_bits), need - 1);
}
int main() {
int i, j, tcc, tc = 1 << 28;
make_bn(65);
for (tcc = 0; tcc < tc; tcc++) {
m = getll(), k = getint();
unsigned long long a = 1, b = 1e18 + 12, mid;
for (; a <= b;) {
mid = a + b >> 1;
unsigned long long num = count(mid * 2, k) - count(mid, k);
if (num == m) {
b = mid;
break;
}
if (num > m) {
b = mid - 1;
} else {
a = mid + 1;
}
}
cout << b << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
if (x == y)
cout << x;
else
cout << 2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ask(int x) {
cout << "? " << x + 1 << endl;
fflush(stdout);
int ret;
cin >> ret;
return ret;
}
int ask2(int x) {
int x1 = ask(x), x2 = ask((x + n / 2) % n);
return x2 - x1;
}
void ans(int x) {
cout << "! " << x + 1 << endl;
fflush(stdout);
}
int main() {
cin >> n;
if (n % 4) {
ans(-2);
return 0;
}
int lo = 0, hi = n / 2;
int meglo = ask2(0), meghi = -meglo;
while (meglo != 0) {
int mid = (hi + lo) / 2;
int meg = ask2(mid);
if (meg * meglo < 0) {
meghi = meg;
hi = mid;
} else {
meglo = meg;
lo = mid;
}
}
ans(lo);
}
| 6 |
#include <bits/stdc++.h>
int setBit(int N, int pos) { return N = N | (1 << pos); }
int resetBit(int N, int pos) { return N = N & ~(1 << pos); }
bool checkBit(int N, int pos) { return (bool)(N & (1 << pos)); }
using namespace std;
int r, c;
string in[105], store[105];
void add(int col) {
int i;
for (i = 0; i < r; i++) store[i] += in[i][col];
}
bool check() {
for (int i = 1; i < r; i++) {
if (store[i] < store[i - 1]) return false;
}
return true;
}
void del(int col) {
int i;
for (i = 0; i < r; i++) store[i].pop_back();
}
int main() {
int i, cnt = 0;
scanf("%d %d", &r, &c);
getchar();
for (i = 0; i < r; i++) cin >> in[i];
for (i = 0; i < c; i++) {
add(i);
if (!check()) {
cnt++;
del(i);
}
}
printf("%d\n", cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int a1[40], sum[40];
void solve() {
long long int a, b, c, d, i, j, k, l;
cin >> a >> b;
bool visited[a + 1];
memset(visited, false, sizeof(visited));
for (i = 0; i < b; i++) {
cin >> c >> d;
visited[c] = true;
visited[d] = true;
}
for (i = 1; i <= a; i++)
if (visited[i] == false) {
cout << a - 1 << endl;
for (j = 1; j <= a; j++) {
if (j != i) {
cout << i << " " << j << endl;
}
}
break;
}
}
int main() {
solve();
unsigned long long int ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d, k, m, q, z;
long double A, B, C, D;
long double eps = 1e-20;
pair<long double, long double> calcpom(long double B, long double C,
long double x) {
long double mi = 1e18;
long double mx = -1e18;
mi = min(mi, (B - x) * (C - x));
mi = min(mi, (B + x) * (C - x));
mi = min(mi, (B - x) * (C + x));
mi = min(mi, (B + x) * (C + x));
mx = max(mx, (B - x) * (C - x));
mx = max(mx, (B + x) * (C - x));
mx = max(mx, (B - x) * (C + x));
mx = max(mx, (B + x) * (C + x));
return make_pair(mi, mx);
}
bool first(long double x) {
pair<long double, long double> p1 = calcpom(B, C, x);
pair<long double, long double> p2 = calcpom(A, D, x);
if (p1.first - eps < p2.first && p2.first < p1.second + eps) return 1;
if (p1.first - eps < p2.second && p2.first < p1.second + eps) return 1;
swap(p1, p2);
if (p1.first - eps < p2.first && p2.first < p1.second + eps) return 1;
if (p1.first - eps < p2.second && p2.first < p1.second + eps) return 1;
return 0;
}
int main() {
cin >> A >> B >> C >> D;
long double poc = 0;
long double kon = 1e10;
long double sr;
for (int _ = 0; _ < (400); _++) {
sr = (poc + kon) / 2;
if (first(sr) == 0)
poc = sr;
else
kon = sr;
}
cout << fixed;
cout << setprecision(10) << sr;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, a[30], b[30], i, j, k = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (a[i] == b[j]) k++;
}
}
printf("%d", k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int AMAX = 1e9;
int main() {
int m, n, i, j, x, y, k = 0, k2;
cin >> n >> m;
vector<int> a(n + 1, AMAX), add(n + 1), l(m + 1), r(m + 1), d(m + 1),
t(m + 1);
for (i = 1; i <= m; i++) {
cin >> t[i] >> l[i] >> r[i] >> d[i];
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) add[j] += d[i];
} else {
for (j = l[i]; j <= r[i]; j++) a[j] = min(a[j], d[i] - add[j]);
}
}
for (i = 1; i <= n; i++) add[i] = 0;
for (i = 1; i <= m; i++) {
if (t[i] == 1) {
for (j = l[i]; j <= r[i]; j++) add[j] += d[i];
} else {
int maxx = -1000000000;
for (j = l[i]; j <= r[i]; j++) {
maxx = max(maxx, a[j] + add[j]);
}
if (maxx != d[i]) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<int> vect(n);
for (int i = 0; i < n; i++) cin >> vect[i];
long long ans = 0;
sort(vect.begin(), vect.end());
for (int i = 0; i < m; i++) {
if (vect[i] < 0) {
ans -= vect[i];
}
}
cout << ans << endl;
}
int main() { solve(); }
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct str {
long long val;
long long pos;
};
bool compare(str a, str b) {
if (a.val == b.val) return a.pos < b.pos;
return a.val > b.val;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1, n, xx, x = 0, y = 0, cc, f, m, k;
cin >> t;
while (t--) {
cin >> n >> k >> m;
long long a[n + 4], pr[n + 5];
str b[n + 5];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
pr[0] = a[0];
for (int i = 1; i < n; i++) {
pr[i] = pr[i - 1] + a[i];
b[i - 1].val = a[i] + a[i - 1];
b[i - 1].pos = i;
}
long long r, sum = 0, mx = -1;
for (int i = 0; i < n - 1; i++) {
if (b[i].pos > k) break;
r = k - b[i].pos;
x = min(r, 2 * m);
sum = pr[b[i].pos];
sum += (x / 2) * a[b[i].pos];
sum += ((x + 1) / 2) * a[b[i].pos - 1];
r -= x;
sum += (pr[min(b[i].pos - (x % 2) + r, n - 1)] - pr[b[i].pos - (x % 2)]);
mx = max(mx, sum);
sum = 0;
}
cout << mx << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b;
int cnt = 0;
cin >> a >> b;
long long d = abs(a - b);
if (d % 10 == 0) {
cout << d / 10 << endl;
} else {
cout << d / 10 + 1 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2005][2005];
vector<vector<long long> > fact;
int main() {
int i, j, k, n, l;
cin >> n >> k;
memset(dp, 0, sizeof(dp));
fact.resize(n + 1);
for (i = 1; i < n + 1; i++)
for (j = 1; j < i + 1; j++)
if (i % j == 0) fact[i].push_back(j);
for (i = 0; i < n + 1; i++) dp[1][i] = 1;
for (i = 2; i < k + 1; i++) {
for (j = 1; j < n + 1; j++) {
for (l = 0; l < (int)fact[j].size(); l++)
dp[i][j] += dp[i - 1][fact[j][l]];
dp[i][j] = dp[i][j] % 1000000007LL;
}
}
long long ans = 0;
for (i = 1; i < n + 1; i++) ans += dp[k][i];
cout << ans % 1000000007LL << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
long long n, m;
long long a[maxn + 10];
map<long long, long long> mp;
int main() {
while (cin >> n >> m) {
mp.clear();
for (long long i = 0; i < n; ++i) {
cin >> a[i];
mp[a[i] % m]++;
}
long long num = n / m;
set<long long> s;
for (long long i = 0; i < m; ++i) {
if (mp[i] < num) {
s.insert(i);
}
}
long long ans = 0;
for (long long i = 0; i < n; ++i) {
if (s.size() == 0) break;
long long x = a[i] % m;
if (mp[x] <= num) continue;
mp[x]--;
set<long long>::iterator it;
it = s.lower_bound(x);
if (it != s.end()) {
long long y = *it;
mp[y]++;
a[i] += y - x;
ans += y - x;
if (mp[y] == num) s.erase(y);
} else {
it = s.begin();
long long y = *it;
mp[y]++;
if (mp[y] == num) s.erase(y);
y += m - x;
ans += y;
a[i] += y;
}
}
cout << ans << endl;
for (long long i = 0; i < n; ++i) cout << a[i] << " ";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = 755;
const int S = 1e7 + 5;
using namespace std;
int n, v[S][2];
int u[S][2], f[S], p[S], val[S], cnt;
int g[N][N];
char str[S];
int re[N], er[N];
bool vis[N];
bool mark[N][2];
bool find(int x) {
for (int i = 0; i < n; ++i) {
if (g[x][i] && !vis[i]) {
vis[i] = 1;
if (!~re[i] || find(re[i])) {
re[i] = x;
er[x] = i;
return 1;
}
}
}
return 0;
}
void DFS(int x, int side) {
if (mark[x][side]) return;
mark[x][side] = 1;
if (!side) {
for (int i = 0; i < n; ++i)
if (g[x][i]) DFS(i, 1);
} else {
if (~re[x]) DFS(re[x], 0);
}
}
int main() {
scanf("%d", &n);
val[cnt++] = -1;
for (int i = 0; i < n; ++i) {
scanf("%s", str);
int x = 0;
for (int j = 0; str[j]; ++j) {
int c = str[j] - 'a';
if (!u[x][c]) {
val[cnt] = -1;
p[cnt] = x;
u[x][c] = v[x][c] = cnt++;
}
x = u[x][c];
}
val[x] = i;
}
queue<int> Q;
for (int i = 0; i < 2; ++i)
if (u[0][i]) {
Q.push(u[0][i]);
f[u[0][i]] = 0;
}
while (!Q.empty()) {
int x = Q.front();
Q.pop();
if (~val[x]) {
for (int y = p[x]; y; y = p[y])
if (~val[y]) g[val[x]][val[y]] = 1;
if (~val[f[x]]) g[val[x]][val[f[x]]] = 1;
} else {
val[x] = val[f[x]];
}
for (int i = 0; i < 2; ++i) {
int y = u[x][i];
if (!y) {
u[x][i] = u[f[x]][i];
} else {
Q.push(y);
f[y] = u[f[x]][i];
}
}
}
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) g[i][j] |= g[i][k] && g[k][j];
memset(re, -1, sizeof(re));
memset(er, -1, sizeof(er));
int res = 0;
for (int i = 0; i < n; ++i) {
memset(vis, 0, sizeof(vis));
res += find(i);
}
printf("%d\n", n - res);
for (int i = 0; i < n; ++i)
if (!~er[i]) DFS(i, 0);
for (int i = 0; i < n; ++i) {
if (!(~er[i] && !mark[i][0] || ~re[i] && mark[i][1])) printf("%d ", i + 1);
}
puts("");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> l(m);
vector<int> p(m);
for (int i = 0; i < m; i++) cin >> l[i];
int prev = l[0];
int remainder = n - l[0];
long long sum = 0;
for (int i = 1; i < m; i++) sum += l[i];
int pos = 1;
p[0] = pos;
if (sum < remainder) {
cout << -1 << "\n";
return 0;
}
for (int i = 1; i < m; i++) {
if (sum < remainder) {
cout << -1 << "\n";
return 0;
} else {
int disc = min(prev - 1LL, sum - remainder);
pos += prev;
pos -= disc;
if (pos + l[i] - 1 > n) {
cout << -1 << "\n";
return 0;
}
p[i] = pos;
prev = l[i];
sum -= prev;
remainder = n - (pos + l[i] - 1);
}
}
for (int i = 0; i < m; i++) cout << p[i] << " ";
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int debug = 1;
const int mod = 1e9 + 7;
unsigned long long int fact(unsigned long long int b,
unsigned long long int a) {
unsigned long long int ans = 1;
for (unsigned long long int i = b; i > a; i--) {
ans = (ans * i) % 10;
}
return ans % 10;
}
void solve() {
unsigned long long int a, b;
cin >> a >> b;
if (a == 0 and b == 0) {
cout << "1" << endl;
return;
}
if (b == 1) {
cout << "1" << endl;
return;
}
if (a == 0) {
if (b > 5) {
cout << "0" << endl;
return;
} else {
cout << fact(b, a) << endl;
return;
}
}
if (b - a > 5) {
cout << "0" << endl;
return;
} else {
cout << fact(b, a) << endl;
return;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long brr[500000];
long long arr[500000];
map<int, int> mm;
map<long long, long long> mmm;
vector<int> v;
vector<long long> vv;
bool check(int n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
long long n, k;
cin >> k;
while (k--) {
cin >> n;
int lose = 0;
if (n == 1) lose = 1;
if (n > 2 and n % 2 == 0) {
if ((n & (n - 1)) == 0) {
lose = 1;
}
if (n % 4 != 0 and check(n / 2)) {
lose = 1;
}
}
if (lose) {
cout << "FastestFinger" << endl;
} else {
cout << "Ashishgup" << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = 5005;
inline void mod(int &x) {
if (x >= MOD) x -= MOD;
if (x < 0) x += MOD;
}
int dp[2][MAXN + 1];
inline void update(int l, int r, int val, int i) {
if (l > r) {
return;
}
dp[1 - i & 1][l] += val;
mod(dp[1 - i & 1][l]);
dp[1 - i & 1][r + 1] -= val;
mod(dp[1 - i & 1][r + 1]);
}
int main() {
int i, j, n, a, b, k;
ios::sync_with_stdio(false);
cin >> n >> a >> b >> k;
dp[0][a] = 1;
dp[0][a + 1] = MOD - 1;
for (i = 0; i < k; i++) {
memset(dp[1 - i & 1], 0, sizeof(dp[1 - i & 1]));
for (j = 1; j <= n; j++) {
dp[i & 1][j] += dp[i & 1][j - 1];
mod(dp[i & 1][j]);
int l = max(0, j - abs(j - b) + 1);
int r = j - 1;
update(l, r, dp[i & 1][j], i);
l = j + 1;
r = min(n, j + abs(j - b) - 1);
update(l, r, dp[i & 1][j], i);
}
}
int ans = 0;
for (i = 1; i <= n; i++) {
dp[k & 1][i] += dp[k & 1][i - 1];
mod(dp[k & 1][i]);
ans += dp[k & 1][i];
mod(ans);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int l, k, s = 0;
scanf("%d%d", &k, &l);
while (l % k == 0) {
s++;
l /= k;
}
if (l == 1) {
printf("YES\n%d", s - 1);
} else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int X[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int Y[8] = {0, 1, 1, 1, 0, -1, -1, -1};
struct fire {
int n, di, first, second;
fire(int _n, int _di, int _x, int _y)
: n(_n), di(_di), first(_x), second(_y) {}
};
int m[300][300];
int visit[300][300][20];
int main() {
int n;
scanf("%d", &n);
queue<fire> q;
memset(m, 0, sizeof(m));
q.push(fire(0, 0, 150, 150));
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
memset(visit, 0, sizeof(visit));
int aa = 0;
while (q.front().n == i) {
fire f = q.front();
q.pop();
m[f.first][f.second] = 1;
for (int j = a - 1; j > 0; j--) {
f.first += X[f.di];
f.second += Y[f.di];
m[f.first][f.second] = 1;
}
if (visit[f.first + X[(f.di + 1) % 8]][f.second + Y[(f.di + 1) % 8]]
[(f.di + 1) % 8] != 1) {
visit[f.first + X[(f.di + 1) % 8]][f.second + Y[(f.di + 1) % 8]]
[(f.di + 1) % 8] = 1;
q.push(fire(f.n + 1, (f.di + 1) % 8, f.first + X[(f.di + 1) % 8],
f.second + Y[(f.di + 1) % 8]));
}
if (visit[f.first + X[(f.di + 7) % 8]][f.second + Y[(f.di + 7) % 8]]
[(f.di + 7) % 8] != 1) {
visit[f.first + X[(f.di + 7) % 8]][f.second + Y[(f.di + 7) % 8]]
[(f.di + 7) % 8] = 1;
q.push(fire(f.n + 1, (f.di + 7) % 8, f.first + X[(f.di + 7) % 8],
f.second + Y[(f.di + 7) % 8]));
}
}
}
int ans = 0;
for (int i = 0; i < 300; i++)
for (int j = 0; j < 300; j++) {
ans += m[i][j];
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
bool comp(int i, int j) { return i > j; }
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, comp);
cout << a[k - 1];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int main() {
int n;
long long a, b;
a = 0;
b = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
long long s;
scanf("%lld", &s);
a |= s;
}
for (int i = 0; i < n; i++) {
long long s;
scanf("%lld", &s);
b |= s;
}
printf("%lld\n", a + b);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int maxn = 1005;
int N;
int c[maxn];
long long int pov[maxn][maxn];
long long int dp[maxn];
void rijesi() {
pov[0][0] = 1;
for (int n = 1; n < maxn; n++) {
pov[n][0] = 1;
for (int k = 1; k <= n; k++) {
pov[n][k] = pov[n - 1][k - 1] + pov[n - 1][k];
pov[n][k] %= mod;
}
}
dp[0] = 1;
int ukupno = c[0];
for (int i = 1; i < N; i++) {
dp[i] = dp[i - 1] * pov[ukupno + c[i] - 1][c[i] - 1];
dp[i] %= mod;
ukupno += c[i];
}
printf("%I64d\n", dp[N - 1]);
}
void ucitaj() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &c[i]);
}
int main(void) {
ucitaj();
rijesi();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
struct Tree {
long long l, r, mi;
} tree[2000005];
long long a[300005], b[300005], p[300005], n;
vector<long long> c[300005], d[300005];
void buildtree(long long i, long long l, long long r) {
tree[i].l = l;
tree[i].r = r;
if (tree[i].r == tree[i].l) {
tree[i].mi = a[l];
return;
}
buildtree(i * 2, l, (r + l) / 2);
buildtree(i * 2 + 1, (l + r) / 2 + 1, r);
tree[i].mi = min(tree[i * 2].mi, tree[i * 2 + 1].mi);
}
void update(long long i, long long l, long long r, long long k) {
if (tree[i].l >= l && tree[i].r <= r) {
tree[i].mi = k;
return;
}
long long m = (tree[i].l + tree[i].r) / 2;
if (l <= m) update(i * 2, l, r, k);
if (r > m) update(i * 2 + 1, l, r, k);
tree[i].mi = min(tree[i * 2].mi, tree[i * 2 + 1].mi);
}
long long querymin(long long i, long long l, long long r) {
if (tree[i].l >= l && tree[i].r <= r) {
return tree[i].mi;
}
long long ans = 2e9, m = (tree[i].r + tree[i].l) / 2;
if (l <= m) ans = min(ans, querymin(i * 2, l, r));
if (r > m) ans = min(ans, querymin(i * 2 + 1, l, r));
return ans;
}
int main() {
long long q;
cin >> q;
while (q--) {
long long t = 0;
cin >> n;
for (long long i = 0; i <= n + 1; i++) {
p[i] = 0;
c[i].clear();
d[i].clear();
}
for (long long i = 1; i <= n; i++) {
cin >> a[i];
c[a[i]].push_back(i);
}
for (long long i = 1; i <= n; i++) {
cin >> b[i];
d[b[i]].push_back(i);
}
for (long long i = 1; i <= n; i++) {
if (c[i].size() != d[i].size()) {
cout << "NO" << endl;
t = 1;
break;
}
}
if (t) continue;
buildtree(1, 1, n);
for (long long i = 1; i <= n; i++) {
long long x = c[b[i]][p[b[i]]];
long long v = querymin(1, 1, x);
p[b[i]]++;
if (v != b[i]) {
cout << "NO" << endl;
t = 1;
break;
}
update(1, x, x, 2e9);
}
if (!t) cout << "YES" << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long cnt1 = 0, cnt2 = 0, cnt3 = 0;
for (long long i = 0; i < s.length(); i++) {
if (s[i] == 'A') {
cnt1++;
} else if (s[i] == 'B') {
cnt2++;
} else {
cnt3++;
}
}
if (cnt1 != 0 && cnt2 != 0 && cnt3 != 0) {
if (cnt1 + cnt3 == cnt2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else if (cnt1 != 0 && cnt2 != 0 && cnt3 == 0) {
if (cnt1 == cnt2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else if (cnt2 != 0 && cnt3 != 0 && cnt1 == 0) {
if (cnt2 == cnt3) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
cout << "NO" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string mima[1002], z;
int n, k, a = 0, b = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> mima[i];
}
cin >> z;
int rule = z.size();
for (int i = 0; i < n; i++) {
if ((int)mima[i].size() < rule)
a++;
else if ((int)mima[i].size() == rule)
b++;
}
cout << (a / k) * 5 + a + 1 << " " << ((a + b - 1) / k) * 5 + a + b;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[100010];
long long subtree[100010];
bool f;
long long l, r, n;
void dfs(long long u, long long p) {
subtree[u] = 1;
for (auto v : adj[u]) {
if (v != p) {
dfs(v, u);
subtree[u] += subtree[v];
}
}
if (subtree[u] == n / 2) {
l = u;
r = p;
f = true;
}
}
int main() {
long long t, x, y;
cin >> t;
while (t--) {
cin >> n;
for (long long i = 1; i <= n; i++) adj[i].clear();
for (long long i = 1; i < n; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
if (n % 2 == 1) {
cout << x << " " << y << "\n";
cout << x << " " << y << "\n";
} else {
f = false;
dfs(1, 0);
if (!f) {
cout << x << " " << y << "\n";
cout << x << " " << y << "\n";
} else {
long long k = adj[l][0];
if (k == r) k = adj[l][1];
cout << l << " " << k << "\n";
cout << r << " " << k << "\n";
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5;
vector<pair<long long, long long>> v[maxn];
long long vis[maxn];
long long sum = 0, n;
void dfs(long long ch, long long p) {
vis[ch] = 1;
for (auto i : v[ch]) {
if (vis[i.first] == 0) {
sum += i.second;
dfs(i.first, ch);
} else {
if (i.first != p) sum += i.second;
}
}
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
long long a, b, w;
cin >> a >> b >> w;
v[a].push_back({b, 0});
v[b].push_back({a, w});
}
memset(vis, 0, sizeof(vis));
long long c1 = v[1][0].first;
long long c2 = v[1][1].first;
long long w1 = v[1][0].second;
long long w2 = v[1][1].second;
vis[1] = 1;
dfs(c1, 1);
long long ans = INT_MAX;
ans = min(ans, w1 + sum);
memset(vis, 0, sizeof(vis));
vis[1] = 1;
sum = 0;
dfs(c2, 1);
ans = min(ans, w2 + sum);
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, s, i;
int A[1001], B[1001];
int main() {
scanf("%d%d", &n, &s);
s--;
for (i = 0; i < n; i++) scanf("%d", &A[i]);
for (i = 0; i < n; i++) scanf("%d", &B[i]);
if (A[0] == 0) {
printf("NO\n");
return 0;
}
for (i = n - 1; i >= 0 && (A[i] == 0 || B[i] == 0); i--)
;
if (A[s] == 1 || (i >= s && B[s]))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
void read(vector<T> &v) {
T x;
cin >> x;
v.push_back(x);
}
int n, k, a[200005], ans = 1000000007;
vector<int> v;
int Solve(int k) {
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
int cnt = 0;
for (__typeof(v.begin()) it = v.begin(); it != v.end(); it++) {
if (k > 0) {
k -= *it;
cnt += 2;
}
}
if (k > 0) return 1000000007;
return cnt;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
int cnt = 0;
for (int i = (1); i <= (n + 1); ++i) {
if (i == n + 1 || (i > 1 && (a[i] >= 0) ^ (a[i - 1] >= 0))) {
if (a[i - 1] >= 0) v.push_back(cnt);
cnt = 0;
}
++cnt;
}
if (a[1] >= 0) {
k += *v.begin();
v.erase(v.begin());
}
if (v.size() == 0) {
if (a[1] >= 0) {
if (a[n] < 0) {
if (n - k > 0)
puts("-1");
else
puts("1");
} else
puts("0");
} else {
if (n == k)
puts("1");
else
puts("-1");
}
return 0;
}
if (a[n] >= 0) {
int x = *v.rbegin();
v.pop_back();
ans = min(ans, Solve(n - k - x) + 2);
}
ans = min(ans, Solve(n - k) + 1);
if (ans == 1000000007)
puts("-1");
else
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("omit-frame-pointer")
#pragma GCC optimize("unroll-loops")
const int MAXINT = 2147483640;
const long long MAXLL = 9223372036854775800LL;
const long long MAXN = 1000000;
const double pi = 3.1415926535897932384626433832795;
using namespace std;
struct di4 {
long long l, r, ans;
};
di4 t[4000000];
di4 combine(di4 t1, di4 t2) {
long long kol = min(t1.l, t2.r);
di4 data;
data.ans = t1.ans + t2.ans + kol * 2;
data.l = t1.l + t2.l - kol;
data.r = t1.r + t2.r - kol;
return data;
}
void modify(long long v, long long tl, long long tr, long long pos,
long long val1, long long val2) {
if (tl == tr) {
t[v].l += val1;
t[v].r += val2;
return;
} else {
long long tm = (tl + tr) / 2;
if (pos <= tm)
modify(v * 2, tl, tm, pos, val1, val2);
else
modify(v * 2 + 1, tm + 1, tr, pos, val1, val2);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
di4 get(long long v, long long tl, long long tr, long long l, long long r) {
if (tl == l and tr == r) return t[v];
long long tm = (tl + tr) / 2;
if (r <= tm) return get(v * 2, tl, tm, l, min(r, tm));
if (l > tm) return get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
return combine(get(v * 2, tl, tm, l, min(r, tm)),
get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
srand(time(0));
long long n, i, q, a, b, n1;
char k;
string s;
cin >> s;
n1 = s.size();
for (i = 0; i < s.size(); i++) {
if (s[i] == '(')
modify(1, 1, n1, i + 1, 1, 0);
else
modify(1, 1, n1, i + 1, 0, 1);
}
cin >> q;
for (i = 1; i <= q; i++) {
cin >> a >> b;
cout << get(1, 1, n1, a, b).ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-10;
int n, x, v;
vector<pair<int, int> > r, l;
long double lo, hi, ans = 1e10;
long double loc(pair<int, int> p, long double t) {
return (long double)p.first + t * p.second;
}
bool check(long double t) {
int dex = l.size() - 1;
long double mini = 1e16;
for (int i = r.size() - 1; i >= 0; i--) {
while (dex >= 0 && l[dex].first + eps >= r[i].first) {
mini = min(mini, loc(l[dex], t));
dex--;
}
if (mini <= loc(r[i], t) && mini < 1e16 - 10) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
while (n--) {
cin >> x >> v;
if (v > 0)
r.push_back(pair<int, int>(x, v));
else
l.push_back(pair<int, int>(x, v));
}
lo = 0, hi = 1e9 + 100;
for (int i = 0; i < 150; i++) {
long double c = (lo + hi) / 2.;
if (check(c))
hi = ans = c;
else
lo = c;
}
if (ans > 1e9 + 200) ans = -1;
cout << fixed << setprecision(20) << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main(void) {
int n, m, k, i, count = 0;
scanf("%d%d%d", &n, &m, &k);
int a[n];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
if (a[i] == 1) {
if (m == 0)
count++;
else
m--;
} else if (a[i] == 2) {
if (m == 0 && k == 0)
count++;
else if (k == 0)
m--;
else
k--;
}
}
printf("%d", count);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double eps = 1e-9;
const int int_inf = 2000000000;
const long long i64_inf = 1000000000000000000LL;
const double pi = acos(-1.0);
using namespace std;
int wa[1000010];
int wb[1000010];
int a[1000100];
int b[1000100];
int la, lb;
int res = 0;
int main() {
memset(wa, -1, sizeof(wa));
memset(wb, -1, sizeof(wb));
cin >> la >> lb;
for (int i = 0; i < (int)la; i++) scanf("%d", &a[i]), wa[a[i]] = i;
for (int i = 0; i < (int)lb; i++) scanf("%d", &b[i]), wb[b[i]] = i;
int first = wb[a[0]], last = first, len = 1;
if (first != -1) {
for (int i = 1; i < (int)la; i++) {
if (wb[a[i]] == -1) break;
if (first <= last)
if (wb[a[i]] > last || wb[a[i]] < first) {
last = wb[a[i]];
len++;
continue;
} else
break;
if (wb[a[i]] > last && wb[a[i]] < first) {
last = wb[a[i]];
len++;
continue;
} else
break;
}
} else
len = 0;
res = max(res, len);
for (int i = 1; i < (int)la; i++) {
if (len == 0) {
if (wb[a[i]] == -1) continue;
first = last = wb[a[i]];
len = 1;
} else {
len--;
first = wb[a[i]];
if (first == -1) {
len = 0;
continue;
}
}
int j = (i + len) % la;
while (j != i) {
if (wb[a[j]] == -1) break;
if (first <= last)
if (wb[a[j]] > last || wb[a[j]] < first) {
last = wb[a[j]];
len++;
j = (j + 1) % la;
continue;
} else
break;
if (wb[a[j]] > last && wb[a[j]] < first) {
last = wb[a[j]];
len++;
j = (j + 1) % la;
continue;
} else
break;
}
res = max(res, len);
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline bool chkmax(T& a, U b) {
return (a < b) ? (a = b, true) : false;
}
template <class T, class U>
inline bool chkmin(T& a, U b) {
return (a > b) ? (a = b, true) : false;
}
template <class T>
inline vector<T> uniq(vector<T> vec) {
sort((vec).begin(), (vec).end()),
vec.erase(unique((vec).begin(), (vec).end()), end(vec));
return vec;
}
void solve();
int main(int argc, char** argv) {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout.setf(ios_base::fixed), cout.precision(10);
solve();
double times = (clock() * 1.0 / CLOCKS_PER_SEC);
do {
} while (0);
}
template <int NV>
class undirectedEulerPath {
public:
vector<int> path;
multiset<int> G[NV];
void addedge(int u, int v) { G[u].insert(v), G[v].insert(u); }
void dfs(int cur) {
while (!G[cur].empty()) {
int tar = *G[cur].begin();
G[cur].erase(G[cur].begin());
G[tar].erase(G[tar].find(cur));
dfs(tar);
}
path.push_back(cur);
}
bool get() {
int src = -1, odd = 0, tot = 0;
for (int i = 0; i < NV; i++) {
tot += G[i].size();
if (G[i].size() % 2 == 1) {
odd++, src = (~src) ? src : i;
}
}
if (odd != 0 && odd != 2) return false;
dfs(odd ? src : 0);
reverse(path.begin(), path.end());
return (int)path.size() == tot / 2 + 1;
}
};
undirectedEulerPath<202020> solver;
void solve() {
int n;
cin >> n;
vector<int> b(n - 1), c(n - 1);
for (int i = 0; i < n - 1; i++) cin >> b[i];
for (int i = 0; i < n - 1; i++) cin >> c[i];
for (int i = 0; i < n - 1; i++) {
if (b[i] > c[i]) do {
cout << ("-1") << "\n";
return;
} while (0);
}
vector<int> index;
for (int i = 0; i < n - 1; i++) {
index.push_back(b[i]), index.push_back(c[i]);
}
index = uniq(index);
for (int i = 0; i < n - 1; i++) {
b[i] = lower_bound((index).begin(), (index).end(), b[i]) - index.begin();
c[i] = lower_bound((index).begin(), (index).end(), c[i]) - index.begin();
solver.addedge(b[i], c[i]);
}
if (solver.get()) {
for (auto& x : solver.path) cout << index[x] << " ";
} else {
do {
cout << ("-1") << "\n";
return;
} while (0);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
for (int i = 1; (1 << i) <= n; ++i) {
for (int j = 1; j <= n; j += (1 << i)) {
if (a >= j && a < j + (1 << i) && b >= j && b < j + (1 << i)) {
if ((1 << i) != n) {
cout << i << '\n';
return 0;
} else {
cout << "Final!\n";
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 10;
int n;
set<int> st, oo;
int a[1005] = {};
int answer[25][25] = {};
int main() {
ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= (int)n * n; ++i) {
int x;
cin >> x;
a[x]++;
st.insert(x);
}
if (n % 2 == 0) {
for (auto u : st)
if (a[u] % 4 != 0)
return cout << "NO"
<< "\n",
0;
for (int i = 1; i <= (int)n / 2; ++i) {
for (int j = 1; j <= (int)n / 2; ++j) {
if (a[*st.begin()]) {
int z = *st.begin();
a[z] -= 4;
if (!a[z]) st.erase(z);
answer[i][j] = answer[n - i + 1][j] = answer[i][n - j + 1] =
answer[n - i + 1][n - j + 1] = z;
}
}
}
} else {
for (int i = 1; i <= (int)n / 2; ++i) {
for (int j = 1; j <= (int)n / 2; ++j) {
while (a[*st.begin()] < 4) {
oo.insert(*st.begin());
st.erase(*st.begin());
if (!st.size()) break;
}
if (!st.size())
return cout << "NO"
<< "\n",
0;
if (a[*st.begin()]) {
int z = *st.begin();
a[z] -= 4;
if (!a[z]) st.erase(z);
answer[i][j] = answer[n - i + 1][j] = answer[i][n - j + 1] =
answer[n - i + 1][n - j + 1] = z;
}
}
}
for (auto u : st) oo.insert(u);
st.clear();
int center = -1;
for (int i = 1; i <= (int)n / 2; ++i) {
while (a[*oo.begin()] < 2) {
center = *oo.begin();
oo.erase(*oo.begin());
if (!oo.size()) break;
}
if (!oo.size())
return cout << "NO"
<< "\n",
0;
if (a[*oo.begin()]) {
int z = *oo.begin();
a[z] -= 2;
if (!a[z]) oo.erase(z);
answer[i][(n + 1) / 2] = answer[n - i + 1][(n + 1) / 2] = z;
}
}
for (int i = 1; i <= (int)n / 2; ++i) {
while (a[*oo.begin()] < 2) {
center = *oo.begin();
oo.erase(*oo.begin());
if (!oo.size()) break;
}
if (!oo.size())
return cout << "NO"
<< "\n",
0;
if (a[*oo.begin()]) {
int z = *oo.begin();
a[z] -= 2;
if (!a[z]) oo.erase(z);
answer[(n + 1) / 2][i] = answer[(n + 1) / 2][n - i + 1] = z;
}
}
if (center != -1)
answer[(n + 1) / 2][(n + 1) / 2] = center;
else if (!oo.size())
return cout << "NO"
<< "\n",
0;
else
answer[(n + 1) / 2][(n + 1) / 2] = *oo.begin();
}
cout << "YES\n";
for (int i = 1; i <= (int)n; ++i) {
for (int j = 1; j <= (int)n; ++j) cout << answer[i][j] << " ";
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 9;
inline long long power(long long base, long long exp) {
long long ans = 1;
while (exp > 0) {
if (exp & 1) ans = (ans * base) % MOD;
exp >>= 1;
base = (base * base) % MOD;
}
return ans;
}
int main() {
int n, m, k;
long long ans;
cin >> n >> m >> k;
int blocksCount = n / k;
int remQuestions = n % k;
int rem = m - blocksCount * (k - 1) - remQuestions;
if (rem <= 0) {
ans = m;
} else {
ans = power(2, rem + 1) - 2;
ans = (ans + MOD) % MOD;
ans = (ans * k) % MOD;
ans = (ans + m - rem * k) % MOD;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct sort_pred {
bool operator()(const long long &left, const long long &right) {
return left > right;
}
};
long long exp(long long a, long long b) {
long long ans = 1;
while (b != 0) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long arr[2005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset((arr), 0, sizeof((arr)));
long long n, k;
cin >> n >> k;
if (k == 1) {
cout << n << endl;
return 0;
}
for (long long i = 1; i < n + 1; i++) arr[i] = n / i;
for (long long i = 0; i < k - 2; i++) {
for (long long j = 1; j < n + 1; j++) {
long long sum = 0;
for (int k = j; k <= n; k += j) {
sum = (sum % 1000000007LL + arr[k] % 1000000007LL);
}
arr[j] = sum;
}
}
long long ans = 0;
for (long long i = 1; i < n + 1; i++)
ans = (ans % 1000000007LL + arr[i] % 1000000007LL);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int tc = 1;
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
const int M = 1e9 + 7;
const long long Inf = (long long)2e18 + 5;
const int N = 2e5 + 5;
long long vis[N], res[N];
int solve() {
int n, b, k;
cin >> n >> b >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
if ((a[i] - k) <= a[i - 1]) {
b += (a[i - 1] - max(0, (a[i] - k)));
} else {
if (b >= ((a[i] - k) - a[i - 1]))
b -= ((a[i] - k) - a[i - 1]);
else {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
return 0;
}
int main() {
int test = 1;
scanf("%d", &test);
while (test--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
}
for (int i = 0; i < 9; i++)
cout << i << "??"
<< "<>" << (i + 1) % 10 << endl;
cout << "9??"
<< ">>"
<< "??0" << endl;
cout << "??"
<< "<>" << 1 << endl;
for (int i = 0; i < 10; i++) cout << "?" << i << ">>" << i << "?" << endl;
for (int i = 0; i < 9; i++)
cout << i << "?"
<< "<>" << (i + 1) % 10 << endl;
cout << 9 << "?"
<< ">>" << 9 << "??" << endl;
cout << ">>"
<< "?";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, t, d, ans;
vector<long long> a;
int main() {
cin >> n >> d;
for (int i = 0; i < n; i++) cin >> t, a.push_back(t);
for (int i = 1; i < n; i++)
if (a[i] <= a[i - 1])
ans += (((a[i - 1] - a[i]) / d) + 1),
a[i] += (((a[i - 1] - a[i]) / d) + 1) * d;
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, v, l = 0, r = 0, max = 0;
vector<int> skills;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v;
skills.push_back(v);
}
sort(skills.begin(), skills.end());
for (; r < n; ++r) {
if (skills[r] - skills[l] <= 5) {
if (r - l > max) {
max = r - l;
}
} else {
for (; skills[r] - skills[l] > 5; ++l)
;
}
}
cout << max + 1 << endl;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.