solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int maxint = 0x7f;
unsigned long long cnk(unsigned long long nn, unsigned long long kk) {
const int maxn = 60;
unsigned long long C[maxn + 1][maxn + 1];
for (int n = 0; n <= maxn; ++n) {
C[n][0] = C[n][n] = 1;
for (int k = 1; k < n; ++k) C[n][k] = C[n - 1][k - 1] + C[n - 1][k];
}
return C[nn][kk];
}
int main() {
unsigned long long n, m, t;
unsigned long long ans = 0;
cin >> n >> m >> t;
for (int i = 4; i < t; ++i) {
ans += cnk(n, i) * cnk(m, t - i);
}
cout << ans;
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
vector<long long> a, p;
unordered_map<long long, long long> ma[11];
long long len(long long x) {
long long res = 0;
while (x) {
++res;
x /= 10;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
p.assign(11, 1);
for (int i = 1; i < 11; ++i) {
p[i] = (p[i - 1] * 10) % k;
ma[i].reserve(2 * n + 5);
}
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
for (int j = 1; j < 11; ++j) ++ma[j][(a[i] * p[j]) % k];
}
long long res = 0;
for (int i = 0; i < n; ++i) {
int j = len(a[i]);
--ma[j][(a[i] * p[j]) % k];
res += ma[j][(k - a[i] % k) % k];
++ma[j][(a[i] * p[j]) % k];
}
cout << res;
return 0;
}
| 5 |
#include <map>
#include <set>
#include <ctime>
#include <queue>
#include <stack>
#include <cmath>
#include <vector>
#include <bitset>
#include <cstdio>
#include <cctype>
#include <string>
#include <numeric>
#include <cstring>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std ;
#define int long long
#define rep(i, a, b) for (ll i = (a); i <= (b); ++i)
#define per(i, a, b) for (ll i = (a); i >= (b); --i)
#define loop(it, v) for (auto it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (ll i = head[x]; i; i = edge[i].nex)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, cnt) memset(a, cnt, sizeof(a))
#define cop(a, b) memcpy(a, b, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define SC(t, x) static_cast <t> (x)
#define ub upper_bound
#define lb lower_bound
#define pqueue priority_queue
#define mp make_pair
#define pb push_back
#define pof pop_front
#define pob pop_back
#define fi first
#define se second
#define y1 y1_
#define Pi acos(-1.0)
#define iv inline void
#define enter putchar('\n')
#define siz(x) ((ll)x.size())
#define file(x) freopen(x".in", "r", stdin),freopen(x".out", "w", stdout)
typedef double db ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair <ll, ll> pii ;
typedef vector <ll> vi ;
typedef vector <pii> vii ;
typedef queue <ll> qi ;
typedef queue <pii> qii ;
typedef set <ll> si ;
typedef map <ll, ll> mii ;
typedef map <string, ll> msi ;
const ll maxn = 2e6 + 100 ;
const ll inf = 0x3f3f3f3f ;
const ll iinf = 1 << 30 ;
const ll linf = 2e18 ;
const ll mod = 998244353 ;
const double eps = 1e-7 ;
template <class T = ll> T chmin(T &a, T b) { return a = min(a, b);}
template <class T = ll> T chmax(T &a, T b) { return a = max(a, b);}
template <class T = ll> iv red(T &x) { x -= mod, x += x >> 31 & mod;}
template <class T = ll> T read()
{
T f = 1, a = 0;
char ch = getchar() ;
while (!isdigit(ch)) { if (ch == '-') f = -1 ; ch = getchar() ; }
while (isdigit(ch)) { a = (a << 3) + (a << 1) + ch - '0' ; ch = getchar() ; }
return a * f ;
}
ll t;
ll n;
char s[maxn];
ll sum[maxn][2];
void solve()
{
scanf("%s", s + 1);
n = strlen(s + 1);
ll now = n + 5;
rep(i, 1, n)
{
sum[now][s[i] - '0'] ++;
if(s[i] == '0') now --;
else now ++;
}
now = n + 5;
rep(i, 1, n)
{
if(sum[now][0] && sum[now - 1][1]) putchar('0'), sum[now][0] --, now --;
else if(sum[now][1]) sum[now][1] --, putchar('1'), now ++;
else putchar('0'), sum[now][0] --, now --;
}
putchar('\n');
}
signed main()
{
t = read();
while(t --) solve();
return 0;
} | 11 |
#include <bits/stdc++.h>
using namespace std;
void use_cio() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto x : V) os << x << ", ";
return os << "]";
}
template <typename... Args>
void dbg(Args... args) {
((cout << args << " "), ...);
cout << "\n";
}
int n, m, k;
int s[100010], t[100010], d[100010], w[100010];
vector<pair<pair<int, int>, pair<int, int>>> event;
multiset<pair<int, int>> st;
long long dp[100010][210];
int flag[100010][210];
int main() {
use_cio();
cin >> n >> m >> k;
for (int i = 0; i < (k); i++) cin >> s[i] >> t[i] >> d[i] >> w[i];
for (int i = 0; i < (k); i++) {
event.push_back({{s[i], 1}, {w[i], d[i]}});
event.push_back({{t[i] + 1, -1}, {w[i], d[i]}});
}
sort(event.begin(), event.end());
int pv = 0;
for (int i = 0; i < (n + 2); i++)
for (int j = 0; j < (m + 1); j++) dp[i][j] = 1e15;
dp[0][0] = 0;
dp[1][0] = 0;
dp[1][1] = 0;
long long ans = 1e15;
for (int i = (1); i < (n + 1); i++) {
while (pv < event.size() && event[pv].first.first == i) {
auto [ww, dd] = event[pv].second;
if (event[pv].first.second == 1)
st.insert({-ww, -dd});
else {
auto it = st.find({-ww, -dd});
st.erase(it);
}
pv++;
}
if (pv == event.size()) {
for (int j = (i); j < (n + 2); j++) {
for (int k = 0; k < (m + 1); k++) ans = min(ans, dp[j][k]);
}
break;
}
if (st.empty()) {
for (int j = 0; j < (m + 1); j++) {
if (dp[i][j] < 1e15) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
}
}
continue;
}
auto [ww, dd] = *st.begin();
ww *= -1, dd *= -1;
for (int j = 0; j < (m + 1); j++) {
if (dp[i][j] < 1e15) {
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j]);
dp[dd + 1][j] = min(dp[dd + 1][j], dp[i][j] + ww);
}
}
}
for (int j = 0; j < (m + 1); j++) ans = min(ans, dp[n + 1][j]);
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[3][1001], s[3][1001];
short dp[1001][1001][51][2];
int n, p, k, r, x;
short solve(int x, int re, int len, int type) {
if (x > n) return 0;
if (re == 0) {
return s[type][x + len - 1] - s[type][x - 1];
}
if (dp[x][re][len][type] != -1) return dp[x][re][len][type];
short& ans = dp[x][re][len][type];
ans = 0;
int Len = min(k, n - x + 1);
if (len == 0) {
ans = solve(x + 1, re, len, type);
ans = max(ans, solve(x, re - 1, Len, 0));
ans = max(ans, solve(x, re - 1, Len, 1));
} else {
ans =
max(ans, (short)(solve(x + 1, re, len - 1, type) + (short)a[type][x]));
ans = max(ans, (short)(solve(x + len, re - 1, Len - len, 1 - type) +
(short)(s[2][x + len - 1] - s[2][x - 1])));
}
return ans;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d%d%d", &n, &p, &k);
scanf("%d", &r);
for (int i = 0; i < r; i++) {
scanf("%d", &x);
a[0][x] = 1;
}
scanf("%d", &r);
for (int i = 0; i < r; i++) {
scanf("%d", &x);
a[1][x] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 2; j++) s[j][i] += a[j][i] + s[j][i - 1];
s[2][i] += s[2][i - 1];
if (a[0][i] || a[1][i]) s[2][i]++;
}
cout << solve(1, p, 0, 0) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct node {
int u, v, val, id;
node() {}
node(int u1, int v1, int id1, int val1) : u(u1), v(v1), id(id1), val(val1) {}
bool operator<(const node &a) const {
if (val != a.val) return val < a.val;
return u < a.u;
}
} l[100010];
vector<node> spe, del;
vector<int> id;
vector<int> a[100010], idx[100010];
int sum, ans, fa[100010], fav[100010];
bool used[100010];
int get_fa(int x) {
if (fa[x] == 0) return x;
fa[x] = get_fa(fa[x]);
return fa[x];
}
void dfs(int x, int f, int id) {
if (f != 1 && f != 0) {
if (del[fav[f]].val > del[id].val)
fav[x] = fav[f];
else
fav[x] = id;
}
for (int i = 0; i < a[x].size(); i++) {
if (a[x][i] == f) continue;
dfs(a[x][i], x, idx[x][i]);
}
}
void build() {
memset(a, 0, sizeof a);
memset(idx, 0, sizeof idx);
memset(fav, 0, sizeof fav);
for (int i = 0; i < del.size(); i++)
if (used[i] == 1) {
int u = del[i].u, v = del[i].v, val = del[i].val;
a[u].push_back(v);
a[v].push_back(u);
idx[u].push_back(i);
idx[v].push_back(i);
}
dfs(1, 0, 0);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int u, v, val;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &val);
l[i] = node(u, v, i, val);
}
sort(l + 1, l + 1 + m);
for (int i = 1; i <= m; i++) {
int u = l[i].u, v = l[i].v, val = l[i].val;
if (u == 1 || v == 1) continue;
int fu = get_fa(u);
int fv = get_fa(v);
if (fu != fv) {
fa[fu] = fv;
sum += val;
del.push_back(l[i]);
used[del.size() - 1] = 1;
}
}
for (int i = 1; i <= m; i++) {
int u = l[i].u, v = l[i].v, val = l[i].val;
if (u != 1 && v != 1) continue;
if (v == 1) swap(u, v);
del.push_back(l[i]);
spe.push_back(l[i]);
id.push_back(del.size() - 1);
int fu = get_fa(u);
int fv = get_fa(v);
if (fu != fv) {
fa[fu] = fv;
sum += val;
used[del.size() - 1] = 1;
k--;
}
}
ans = sum;
while (k > 0) {
build();
int add = -1, maxd, delx;
for (int i = 0; i < spe.size(); i++) {
if (used[id[i]] == 1) continue;
int u = spe[i].u, v = spe[i].v, val = spe[i].val;
if (v == 1) swap(u, v);
int maxv = del[fav[v]].val;
if (add == -1 || maxd < maxv - val) {
add = id[i];
delx = fav[v];
maxd = maxv - val;
}
}
if (add == -1) break;
used[add] = 1;
used[delx] = 0;
sum -= maxd;
ans = min(ans, sum);
k--;
}
if (k != 0) {
printf("-1");
return 0;
}
printf("%d\n", n - 1);
for (int i = 0; i < del.size(); i++)
if (used[i] == 1) {
printf("%d ", del[i].id);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long a, m, i, k, t;
int main() {
cin >> a >> m;
for (i = 0; i <= 20; i++) {
t = pow(2, i);
if (a * t % m == 0) {
cout << "Yes";
return 0;
}
}
cout << "No";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 100000000;
inline int fastMin(int x, int y) { return x > y ? y : x; }
inline int fastMax(int x, int y) {
return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y;
}
inline int fastAbs(int x) { return ((x >> (32 - 1)) & (x ^ (-x))) ^ x; }
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
class UnionFind {
int n;
vector<int> par;
public:
vector<int> num;
UnionFind() {}
UnionFind(int size) { reset(size); }
void reset(int size) {
n = size;
par.resize(size);
num.resize(size);
for (int i = 0; i < size; i++) par[i] = i, num[i] = 1;
}
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) assert(false);
if (x < y) swap(x, y);
par[x] = y;
num[y] += num[x];
n--;
}
bool same(int x, int y) { return find(x) == find(y); }
int size() { return n; }
};
vector<int> e[((int)1e5)];
int a[((int)1e5)];
double f(double x) { return x * (x - 1); }
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (n); i++) cin >> a[i];
for (int i = 0; i < (m); i++) {
int x, y;
cin >> x >> y;
x--;
y--;
e[x].push_back(y);
e[y].push_back(x);
}
vector<pair<int, int> > vp;
for (int i = 0; i < (n); i++) vp.emplace_back(a[i], i);
sort(vp.rbegin(), vp.rend());
UnionFind uf(n);
double ans = 0;
for (int i = 0; i < (n); i++) {
int pt = vp[i].second;
double prev_cnt = f(uf.num[uf.find(pt)]);
for (auto p : e[pt]) {
if (vp[i].first > a[p]) continue;
if (uf.same(pt, p)) continue;
double prv = f(uf.num[uf.find(p)]);
prev_cnt += prv;
uf.unite(pt, p);
}
double now = f(uf.num[uf.find(pt)]);
double cnt = now - prev_cnt;
double add = cnt * vp[i].first;
ans += add;
}
ans /= f(n);
printf("%.10lf\n", ans);
}
| 5 |
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define int long long
using namespace std;
void fileio(const string &s)
{
freopen((s+".in").c_str(),"r",stdin);
freopen((s+".out").c_str(),"w",stdout);
}
const int INF=4e18;
inline int read()
{
int x=0;
bool flag=1;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
flag=0;
c=getchar();
}
while(c>='0'&&c<='9')
{
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return (flag?x:~(x-1));
}
int t,tx,ty,ax,ay,bx,by;
void solve()
{
ax=read();
ay=read();
bx=read();
by=read();
int ans=abs(ax-bx)+abs(ay-by);
tx=read();
ty=read();
if(tx==ax&&tx==bx)
{
if(ay<ty&&ty<by)
ans+=2;
if(ay>ty&&ty>by)
ans+=2;
}
if(ty==ay&&ty==by)
{
if(ax<tx&&tx<bx)
ans+=2;
if(ax>tx&&tx>bx)
ans+=2;
}
cout<<ans<<endl;
}
signed main()
{
t=read();
while(t--)
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
signed main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
if (n > m) {
cout << 0;
return 0;
}
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = 1;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
ans *= abs(a[i] - a[j]);
ans %= m;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 16 | 5, M = 2e3 + 5;
int n, k, a[N], b[N];
bitset<M> f[N];
int main() {
cin >> n >> k;
int sm = 0;
for (int i = 0; i < n; i++) scanf("%d", &a[i]), sm += a[i];
f[0][0] = 1;
for (int S = 1; S < (1 << n); S++) {
for (int j = 0; j < n; j++)
if (S >> j & 1) f[S] |= f[S ^ (1 << j)] << a[j];
for (int l = sm / k; l; l--) f[S][l] = f[S][l] | f[S][l * k];
}
int u = (1 << n) - 1, c = 1;
if (!f[u][1]) return puts("NO"), 0;
int cur = 0;
while (u) {
for (int i = 0; i < n; i++)
if (u >> i & 1) {
int d = c, v = u ^ (1 << i);
bool o = 0;
for (int t = 0; d <= sm; ++t, d = d * k) {
int e = d - a[i];
if (e < 0) continue;
if (f[v][e]) {
u = v;
c = e;
o = 1;
cur += t;
b[i] = cur;
break;
}
}
if (o) break;
}
}
priority_queue<pair<int, int> > q;
for (int i = 0; i < n; i++) q.push(pair<int, int>(b[i], i));
puts("YES");
while (!q.empty()) {
int x = q.top().second;
q.pop();
int y = q.top().second;
q.pop();
cout << a[x] << ' ' << a[y] << '\n';
a[x] += a[y];
while (a[x] % k == 0) --b[x], a[x] /= k;
if (b[x]) q.push(pair<int, int>(b[x], x));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define mp make_pair
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define fr(i,a,n) for(lli i=a;i<(n);i++)
#define frj(j,a,n) for(lli j=a;j<(n);j++)
#define frx(i,a,n) for(lli i=a;i>=(n);i--)
#define frxj(j,a,n) for(lli j=a;j>=(n);j--)
#define lli long long int
#define ld long double
#define vecI vector<lli>
#define vecP vector<pair<lli,lli>>
#define plli pair<lli,lli>
#define out2(x, a) << x << a
#define out1(x) << x
#define br << "\n"
#define itr iterator
#define print(v) for(auto it = v.begin(); it != v.end(); it++) {cout << *it << " ";} cout << endl;
#define sz(a) ((lli) a.size())
#define shiftleft(a, b) ((lli) a << b)
template<typename T>
class DSU {
public:
T length;
vector<T> par;
DSU(T n): length(n) {
// assign all nodes as -1. Negative par[i] denotes that it is parent of the set and its magnitude denote size of the set
par.assign(length, -1);
}
T getParent(T elem){
T parent = elem;
while(par[parent] >= 0){
parent = par[parent];
}
// if(parent != elem){
// // To collapse the the size of chains
// // if parent of this element is other than itself update it
// par[elem] = parent;
// }
return parent;
}
void unionNodes(T a, T b){
T parent_a = getParent(a);
T parent_b = getParent(b);
T size_par_a = getSetSize(a);
T size_par_b = getSetSize(b);
if(size_par_a >= size_par_b){
par[parent_b] = parent_a;
par[parent_a] = - (size_par_a + size_par_b);
} else {
par[parent_a] = parent_b;
par[parent_b] = - (size_par_a + size_par_b);
}
}
T getSetSize(T elem){
return abs(par[getParent(elem)]);
}
};
void solve(){
lli n;
string s;
cin >> n >> s;
DSU<lli> dsu(2*n+2);
// 0 ... n
// n+1, ...., 2*n+1
fr(i,0,n){
if(s[i] == 'L'){
// union nodes i+1 , i+n
dsu.unionNodes(i+1, i+n+1);
} else {
dsu.unionNodes(i, i+1+n+1);
}
}
fr(i,0,n+1){
cout << dsu.getSetSize(i) << " ";
} cout br;
}
int main() {
fast;
lli t;
cin >> t;
while(t--)
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long h, n;
cin >> h >> n;
--n;
long long result = 0;
while (true) {
assert(0 <= h and h <= 50);
assert(0 <= n and n < (1ll << h));
if (h == 0) break;
result += ((result & 1) == (n < (1ll << (h - 1)))) ? (1ll << h) : 1;
h -= 1;
n %= 1ll << h;
}
cout << result << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long big = 1000000007;
long long mod = 998244353;
double pi = 3.14159265;
unsigned long long gcd(unsigned long long a, unsigned long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
string getbin(unsigned long long x) {
if (x == 0) return "0";
string ret = "";
while (x != 0) {
ret = (char)('0' + x % 2) + ret;
x /= 2;
}
return ret;
}
unsigned long long getdec(string b) {
unsigned long long ret = 0;
for (int i = 0; i < b.size(); i += 1) {
ret *= 2;
ret += b[i] - '0';
}
return ret;
}
int getp(unsigned long long x) {
int ret = 0;
while (x > 1) {
x /= 2;
ret += 1;
}
return ret;
}
unsigned long long modfact(long long x, long long modulo) {
if (x == 0)
return 1;
else
return (x * modfact(x - 1, modulo)) % modulo;
}
unsigned long long modexp(long long x, long long m, long long n) {
if (n == 0) return 1;
if (n == 1) return x;
unsigned long long y = modexp(x, m, n / 2);
if (n & 1) {
return ((x * y % m) * y) % m;
} else {
return y * y % m;
}
}
unsigned long long modinv(int a, int m) {
int g = gcd(a, m);
if (g != 1) throw "Inverse doesn't exist";
return modexp(a, m, m - 2);
}
unsigned long long binexp(long long x, long long n) {
if (n == 0) return 1;
if (n == 1) return x;
unsigned long long y = binexp(x, n / 2);
if (n & 1) {
return x * y * y;
} else {
return y * y;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
long long n, m;
cin >> n >> m;
vector<vector<int>> g(n + 1, vector<int>(m + 1, 0));
char c;
for (int i = 1; i < n + 1; i += 1) {
for (int j = 1; j < m + 1; j += 1) {
cin >> c;
g[i][j] = (c == 'X');
}
}
vector<int> pref(m + 1, 0);
for (int j = 1; j < m; j += 1) {
pref[j + 1] = pref[j];
for (int i = 1; i < n + 1; i += 1) {
if (g[i][j] and g[i - 1][j + 1]) pref[j + 1] += 1;
}
}
int q, l, r;
cin >> q;
while (q--) {
cin >> l >> r;
if (l == r)
cout << "YES \n";
else if (pref[l] == pref[r])
cout << "YES \n";
else
cout << "NO \n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans, a[511];
int judge(int x) {
for (int i = 1; i <= n; i++) {
if (a[i] % x == 0) {
ans += a[i] / x;
} else if (a[i] / x + a[i] % x >= x - 1) {
ans += a[i] / x + 1;
} else
return 0;
}
return 1;
}
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= sqrt(a[1]); i++) {
for (int x = a[1] / i + 1; x >= a[1] / i; x--) {
ans = 0;
if (judge(x)) {
printf("%I64d", ans);
return 0;
} else {
ans = 0;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
pair<long long, long long> a[3];
for (int i = 0; i < 3; i++) cin >> a[i].first >> a[i].second;
int x_equal = 0, y_equal = 0;
long long x_max[2], y_max[2];
x_max[0] = x_max[1] = a[0].first;
y_max[0] = y_max[1] = a[0].second;
long long x_rem, y_rem;
int cnt = 0;
for (int i = 1; i < 3; i++) {
if (a[i].first == a[0].first) {
cnt++;
y_max[0] = max(y_max[0], a[i].second);
y_max[1] = min(y_max[1], a[i].second);
} else
y_rem = a[i].second;
}
if (cnt)
x_equal = cnt + 1;
else if (a[1].first == a[2].first) {
x_equal = 2;
y_max[0] = max(a[1].second, a[2].second);
y_max[1] = min(a[1].second, a[2].second);
y_rem = a[0].second;
}
cnt = 0;
for (int i = 1; i < 3; i++) {
if (a[i].second == a[0].second) {
cnt++;
x_max[0] = max(x_max[0], a[i].first);
x_max[1] = min(x_max[1], a[i].first);
} else
x_rem = a[i].first;
}
if (cnt)
y_equal = cnt + 1;
else if (a[1].second == a[2].second) {
y_equal = 2;
x_max[0] = max(a[1].first, a[2].first);
x_max[1] = min(a[1].first, a[2].first);
x_rem = a[0].first;
}
if (x_equal == 3 || y_equal == 3) {
cout << "1\n";
return 0;
} else if (x_equal == 2 && y_equal == 2) {
cout << "2\n";
return 0;
} else if (x_equal == 2) {
if (y_rem < y_max[0] && y_rem > y_max[1]) {
cout << "3\n";
return 0;
}
cout << "2\n";
return 0;
} else if (y_equal == 2) {
if (x_rem < x_max[0] && x_rem > x_max[1]) {
cout << "3\n";
return 0;
}
cout << "2\n";
return 0;
} else
cout << "3\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
string s;
cin >> a >> s;
long long cnt[40000];
memset(cnt, 0, sizeof(cnt));
int len = s.length();
for (int i = 0; i < len; ++i) {
int sum = 0;
for (int j = i; j < len; ++j) {
sum += s[j] - '0';
if (sum <= a)
cnt[sum]++;
else
break;
}
}
long long ans = 0;
if (a == 0) {
ans = cnt[0] * 1ll * len * (len + 1) - cnt[0] * cnt[0];
cout << ans << endl;
return 0;
}
for (int i = 1; i < 40000; ++i) {
if (a % i == 0 && a / i < 40000) ans += cnt[i] * cnt[a / i];
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool sortinrev(const pair<int, int>& a, const pair<int, int>& b) {
return (a.first > b.first);
}
string getString(char x) {
string s(1, x);
return s;
}
long long max(long long a, long long b) {
if (b > a)
return b;
else {
return a;
}
}
long long power(long long x, long long y, long long m) {
if (y == 0) return 1;
long long p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
long long factorial[500005];
void swap(int* a, int* b) {
int temp;
temp = *a;
*a = *b;
*b = temp;
}
int visited[200005], val[200000];
void DFS(long long n, vector<int> v[]) {
visited[n] = 1;
for (int i = 0; i < v[n].size(); i++) {
if (visited[v[n][i]] == 0) {
DFS(v[n][i], v);
}
}
}
void dfs(int n, vector<int> v[], int dis) {
visited[n] = 1;
val[n] = dis;
for (int i = 0; i < v[n].size(); i++) {
if (visited[v[n][i]] == 0) {
dfs(v[n][i], v, dis + 1);
}
}
}
int vitree(int n, vector<int> v[]) {
int count = 0;
visited[n] = 1;
for (int i = 0; i < v[n].size(); i++) {
if (visited[v[n][i]] == 0) {
count += vitree(v[n][i], v);
}
}
if (count == 0) {
val[n] = 1;
return 1;
} else {
val[n] = count;
return count;
}
}
bool bipartite(int n, vector<int> v[], int co) {
visited[n] = 1;
val[n] = co;
for (int i = 0; i < v[n].size(); i++) {
if (visited[v[n][i]] == 0) {
bool m = bipartite(v[n][i], v, (co == 1) ? 0 : 1);
if (m == false) return false;
} else {
if (val[v[n][i]] == co) return false;
}
}
return true;
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int dp[202][202][202];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int r, g, b;
cin >> r >> g >> b;
int x[r], y[g], z[b];
for (int i = 0; i < r; i++) cin >> x[i];
for (int i = 0; i < g; i++) cin >> y[i];
for (int i = 0; i < b; i++) cin >> z[i];
int ans = 0;
sort(x, x + r, greater<int>());
sort(y, y + g, greater<int>());
sort(z, z + b, greater<int>());
for (int i = 0; i < r + 1; i++) {
for (int j = 0; j < g + 1; j++) {
for (int k = 0; k < b + 1; k++) {
if (i) dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][k]);
if (j) dp[i][j][k] = max(dp[i][j][k], dp[i][j - 1][k]);
if (k) dp[i][j][k] = max(dp[i][j][k], dp[i][j][k - 1]);
if (i && j)
dp[i][j][k] =
max(dp[i][j][k], dp[i - 1][j - 1][k] + x[i - 1] * y[j - 1]);
if (j && k)
dp[i][j][k] =
max(dp[i][j][k], dp[i][j - 1][k - 1] + z[k - 1] * y[j - 1]);
if (i && k)
dp[i][j][k] =
max(dp[i][j][k], dp[i - 1][j][k - 1] + x[i - 1] * z[k - 1]);
ans = max(ans, dp[i][j][k]);
}
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, num[310], cnt, last, tot;
vector<int> a, b;
inline void cz(bool u, int v) {
if (!u) return;
int i, j;
cnt++;
for (i = v + 1; i <= tot; i++) {
a.push_back(v);
b.push_back(i);
}
}
int main() {
int i, j, l, r;
cin >> n;
for (i = 1; i <= n; i++) scanf("%d", &num[i]);
tot = num[n] + 1;
for (i = 1, l = 1, r = n; i <= tot && l <= r; i++) {
if (cnt + tot - i == num[r]) {
r--;
cz(1, i);
last = 1;
} else if (cnt == num[l]) {
l++;
cz(0, i);
last = 0;
} else
cz(last, i);
}
for (; i <= tot; i++) cz(last, i);
cout << a.size() << endl;
for (i = 0; i < a.size(); i++) {
printf("%d %d\n", a[i], b[i]);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt, kov;
vector<pair<int, int> > sz;
vector<int> sol[100002], p;
void pb() { p.pop_back(); }
void add(int a, int b) { sol[a].push_back(b); }
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
sz.push_back({x, i});
}
sort(sz.rbegin(), sz.rend());
for (int i = 1; i <= sz[0].first; i++)
cnt++, p.push_back(i), add(sz[0].second, i);
for (int i = 1; i < n; i++) {
if (i == n - 1)
kov = 2;
else
kov = sz[i + 1].first;
int fi = sz[i].first, se = sz[i].second, si = p.size(), ut = p.back();
if (fi == 3 && si <= 4 && kov == 3) {
int q = sz[i + 1].second;
pb(), add(se, p.back()), add(q, p.back()), pb(), add(se, p.back()), cnt++,
add(se, cnt), add(q, cnt);
p.push_back(cnt), p.push_back(ut), add(q, ut), i++;
} else {
if (si == 4 && kov == 4) kov--;
fi--;
while (fi > 0 && si + fi > kov + 1) add(se, p.back()), pb(), si--, fi--;
add(se, p.back());
while (fi > 0) cnt++, add(se, cnt), p.push_back(cnt), fi--;
p.push_back(ut);
}
}
cout << cnt << "\n";
for (int i = 1; i <= n; i++) {
for (int j = 0; j < sol[i].size(); j++) cout << sol[i][j] << " ";
cout << "\n";
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
int main() {
long long int i, j, k, l, m, n, t;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
t = 1;
while (t--) {
cin >> n;
vector<long long int> a(n + 1, 0);
a[1] = 0;
l = 1;
for (i = 2; i <= n; i++) {
if (a[i] == 0) {
for (j = i; j <= n; j += i) {
a[j] = l;
}
l++;
}
}
for (i = 2; i <= n; i++) {
cout << a[i] << ' ';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[n];
int i, j, k, l;
long long s = 0;
long long minodd = 1000000007;
int numodd = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 1) {
numodd++;
minodd = min(minodd, a[i]);
}
s += a[i];
}
if (numodd % 2 == 0) {
cout << s;
} else
cout << s - minodd;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[111];
double dp[111111], t[111111], pre[111111];
int main() {
int n, m, sum = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), sum += a[i];
if (m == 1) {
puts("1");
return 0;
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n * m; i++) pre[i] = pre[i - 1] + dp[i - 1];
for (int i = 1; i <= n * m; i++) {
t[i] = pre[i] - pre[max(0, i - m)];
if (i >= a[k]) t[i] -= dp[i - a[k]];
t[i] /= (m - 1);
}
for (int i = 1; i <= n * m; i++) dp[i] = t[i];
dp[0] = 0;
}
double ans = 0;
for (int i = 1; i < sum; i++) ans += dp[i];
printf("%.9lf\n", ans * (m - 1) + 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int N = 1010;
char s[N][N], a[N];
int len[N], n, mx, len1;
inline void Max(int &a, int b) {
if (b > a) a = b;
}
inline void Max(long long &a, long long b) {
if (b > a) a = b;
}
int c[10], Rank[N], Rank2[N], h[N], C[10];
long long f[N], tmp[N];
int v[N];
inline void add(int x, int p) {
memset(v, 0, sizeof(v));
long long cost = 0;
int mi = n + 1;
for (int i = n; i > 0; i--) {
v[Rank[i]] = x;
if (s[Rank[i]][p] >= '0' && s[Rank[i]][p] <= '9')
v[Rank[i]] += s[Rank[i]][p] - '0';
if (p < max(len1, len[Rank[i]]) || v[Rank[i]] != 0)
cost += C[v[Rank[i]] % 10];
if (v[Rank[i]] >= 10) mi = min(mi, i);
}
Max(tmp[mi - 1], f[n] + cost);
for (int i = n; i > 0; i--) {
if (p < max(len1, len[Rank2[i]]) || v[Rank2[i]] != 0)
cost -= C[v[Rank2[i]] % 10];
v[Rank2[i]]++;
cost += C[(v[Rank2[i]]) % 10];
if (v[Rank2[i]] >= 10) mi = min(mi, h[Rank2[i]]);
Max(tmp[mi - 1], f[i - 1] + cost);
}
}
int main() {
scanf("%s", a);
len1 = strlen(a);
Max(mx, len1);
reverse(a, a + len1);
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i]);
len[i] = strlen(s[i]);
reverse(s[i], s[i] + len[i]);
Max(mx, len[i]);
}
for (int i = 0; i < 10; i++) scanf("%d", C + i);
for (int i = 1; i <= n; i++) Rank2[i] = i;
for (int i = 0; i < n; i++) f[i] = -INF;
mx += 2;
for (int i = 0; i < mx; i++) {
memset(c, 0, sizeof(c));
for (int j = 1; j <= n; j++)
if (s[j][i] >= '0' && s[j][i] <= '9')
c[s[j][i] - '0']++;
else
c[0]++;
for (int j = 1; j < 10; j++) c[j] += c[j - 1];
for (int j = 9; j > 0; j--) c[j] = c[j - 1];
c[0] = 0;
for (int j = 1; j <= n; j++)
if (s[Rank2[j]][i] <= '9' && s[Rank2[j]][i] >= '0') {
Rank[++c[s[Rank2[j]][i] - '0']] = Rank2[j];
} else
Rank[++c[0]] = Rank2[j];
for (int j = 1; j <= n; j++) h[Rank[j]] = j;
for (int j = 0; j <= n; j++) tmp[j] = -INF;
if (i < len1) {
if (a[i] >= '0' && a[i] <= '9') {
add(a[i] - '0', i);
} else if (a[i] == '?') {
for (int j = 0; j < 10; j++) {
if (j == 0 && i == len1 - 1) continue;
add(j, i);
}
}
} else
add(0, i);
memcpy(Rank2, Rank, sizeof(Rank));
memcpy(f, tmp, sizeof(f));
}
printf("%I64d\n", f[n]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
if ((n == 1 || m == 1) || (n == 2 && m == 2))
cout << "YES\n";
else
cout << "NO\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long T = 1;
cin >> T;
while (T--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int sum() { return 0; }
template <typename T, typename... Args>
T sum(T a, Args... args) {
return a + sum(args...);
}
void solve() {
long long int n;
cin >> n;
if (n == 1) {
cout << "FastestFinger"
<< "\n";
return;
}
if (n % 2) {
cout << "Ashishgup"
<< "\n";
return;
}
long long int c = 0;
while (n % 2 == 0) {
c++;
n /= 2;
}
if (n == 1) {
if (c == 1) {
cout << "Ashishgup"
<< "\n";
return;
} else {
cout << "FastestFinger"
<< "\n";
return;
}
} else {
bool prime = true;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) prime = false;
}
if (prime) {
if (c == 1) {
cout << "FastestFinger"
<< "\n";
return;
} else {
cout << "Ashishgup"
<< "\n";
return;
}
} else {
cout << "Ashishgup"
<< "\n";
return;
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<int> s;
long long int n, m, k, a;
cin >> n >> m;
while (n--) {
cin >> k;
while (k--) {
cin >> a;
s.insert(a);
}
}
if (s.size() == m) {
cout << "YES"
<< "\n";
} else {
cout << "NO"
<< "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000111;
const int LIM = 10000010;
const int S_N = 100001;
const int MOD = 1000000007;
int n, k;
void mult(vector<int> a, vector<int> b, vector<int>& c) {
vector<int> _(n);
for (int i = 0; i < (n); ++i) {
long long sum = 0;
for (int j = 0; j <= (i); ++j) {
sum += a[j] * (long long)b[i - j];
if (sum >= 1000000 * MOD) sum %= MOD;
}
_[i] = sum;
}
c = _;
}
ostream& operator<<(ostream& out, vector<int> v) {
for (int i = 0; i < (v.size()); ++i) out << v[i] << " ";
out << endl;
return out;
}
int main() {
cin >> n >> k;
vector<int> s(n);
for (int i = 0; i < (n); ++i) cin >> s[i];
vector<int> a(n, 0);
a[0] = 1;
vector<int> b(n, 1);
for (k; k > 0; k /= 2) {
if (k % 2) mult(a, b, a);
mult(b, b, b);
}
mult(a, s, s);
cout << s;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1], b[n + 1];
string s;
cin >> s;
int i;
for (i = 0; i < n; i++) {
a[i] = s[i] - '0';
}
for (; i < 2 * n; i++) {
b[i - n] = s[i] - '0';
}
sort(a, a + n);
sort(b, b + n);
int flag1 = 0, flag2 = 0;
for (i = 0; i < n; i++) {
if (a[i] < b[i])
flag1 += 1;
else if (a[i] > b[i])
flag2 += 1;
}
if (flag1 == n || flag2 == n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, x[100002], d;
long long res;
long long C2(long long n) {
if (n < 2) return 0;
return (n * (n - 1)) / 2;
}
int main() {
int i, j;
scanf("%d%d", &n, &d);
for (i = 0; i < n; i++) scanf("%d", &x[i]);
res = 0;
i = 0;
for (j = 2; j < n; j++) {
for (i = i; i < j; i++)
if (x[j] - x[i] <= d) break;
res += C2(j - i);
}
printf("%I64d", res);
return 0;
};
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int ax, ay;
int bx, by;
int cx, cy;
cin >> n;
cin >> ax >> ay;
cin >> bx >> by;
cin >> cx >> cy;
int final, initial;
if (cx > ax) {
if (cy > ay)
final = 1;
else
final = 4;
} else {
if (cy > ay)
final = 2;
else
final = 3;
}
if (bx > ax) {
if (by > ay)
initial = 1;
else
initial = 4;
} else {
if (by > ay)
initial = 2;
else
initial = 3;
}
if (final == initial)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int mod = 998244353;
int f[maxn][maxn], pre[maxn][maxn], n, k, a[maxn], ans;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) pre[i][1] = i;
for (int v = 1; v * (k - 1) <= a[n]; v++) {
int p = 1;
for (int i = 2; i <= n; i++) {
while (a[p] + v <= a[i]) p++;
for (int j = 2; j <= min(i, k); j++) {
f[i][j] = pre[p - 1][j - 1];
pre[i][j] = (f[i][j] + pre[i - 1][j]) % mod;
}
}
ans = (ans + pre[n][k]) % mod;
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<char, vector<int> > m;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
m[s[i]].push_back(i);
}
int M;
cin >> M;
while (M--) {
string t;
cin >> t;
int ans = 0;
map<char, int> tut;
for (int i = 0; i < t.length(); i++) {
tut[t[i]]++;
ans = max(ans, m[t[i]][tut[t[i]] - 1]);
}
cout << ans + 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, b, t, ans, i;
cin >> t;
while (t--) {
cin >> a >> b >> n;
i = a ^ b;
if (n % 3 == 0) {
cout << a << endl;
} else if (n % 3 == 1)
cout << b << endl;
else
cout << i << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const char el = '\n';
void outputplan(int d, int k, vector<int>& a, vector<int>& b, int rblperdollar,
int rblperpound, vector<pair<int, int> >& dollargadgets,
vector<pair<int, int> >& poundgadgets) {
cout << d + 1 << el;
int n = (int)a.size();
int dollarday, poundday;
for (int i = 0; i < n; ++i) {
if (a[i] == rblperdollar) {
dollarday = i;
break;
}
}
for (int i = 0; i < n; ++i) {
if (b[i] == rblperpound) {
poundday = i;
break;
}
}
int m = (int)dollargadgets.size();
n = (int)poundgadgets.size();
int i = 0, j = 0;
for (int t = 0; t < k; ++t) {
if (i == m) {
cout << poundgadgets[j].second << " " << poundday + 1 << el;
++j;
} else if (j == n) {
cout << dollargadgets[i].second << " " << dollarday + 1 << el;
++i;
} else {
int nextdollarcost = dollargadgets[i].first;
int nextpoundcost = poundgadgets[j].first;
long long nextrblcost1 =
(long long)nextdollarcost * (long long)rblperdollar;
long long nextrblcost2 =
(long long)nextpoundcost * (long long)rblperpound;
if (nextrblcost1 <= nextrblcost2) {
cout << dollargadgets[i].second << " " << dollarday + 1 << el;
++i;
} else {
cout << poundgadgets[j].second << " " << poundday + 1 << el;
++j;
}
}
}
}
bool isenough(long long s, int k, int rblperdollar, int rblperpound,
vector<pair<int, int> >& dollargadgets,
vector<pair<int, int> >& poundgadgets) {
int m = (int)dollargadgets.size();
int n = (int)poundgadgets.size();
int i = 0, j = 0;
long long rblcost = 0;
for (int t = 0; t < k; ++t) {
if (i == m) {
rblcost += (long long)rblperpound * (long long)poundgadgets[j].first;
++j;
} else if (j == n) {
rblcost += (long long)rblperdollar * (long long)dollargadgets[i].first;
++i;
} else {
int nextdollarcost = dollargadgets[i].first;
int nextpoundcost = poundgadgets[j].first;
long long nextrblcost1 =
(long long)nextdollarcost * (long long)rblperdollar;
long long nextrblcost2 =
(long long)nextpoundcost * (long long)rblperpound;
if (nextrblcost1 <= nextrblcost2) {
rblcost += nextrblcost1;
++i;
} else {
rblcost += nextrblcost2;
++j;
}
}
}
return (rblcost <= s);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
long long s;
cin >> n >> m >> k >> s;
cin.ignore();
vector<int> a(n);
vector<int> b(n);
vector<int> minperdollar(n);
vector<int> minperpound(n);
int tempa = INT_MAX, tempb = INT_MAX;
for (int i = 0; i < n; ++i) {
cin >> a[i];
tempa = min(tempa, a[i]);
minperdollar[i] = tempa;
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
tempb = min(tempb, b[i]);
minperpound[i] = tempb;
}
vector<pair<int, int> > dollargadgets{};
vector<pair<int, int> > poundgadgets{};
for (int i = 1; i <= m; ++i) {
int t, cost;
cin >> t >> cost;
if (t == 1) {
dollargadgets.push_back({cost, i});
} else {
poundgadgets.push_back({cost, i});
}
}
sort(dollargadgets.begin(), dollargadgets.end());
sort(poundgadgets.begin(), poundgadgets.end());
bool lastdaypossible = isenough(s, k, minperdollar[n - 1], minperpound[n - 1],
dollargadgets, poundgadgets);
if (!lastdaypossible) {
cout << -1 << el;
return 0;
}
if (n == 1) {
if (lastdaypossible) {
outputplan(0, k, a, b, minperdollar[0], minperpound[0], dollargadgets,
poundgadgets);
} else {
cout << -1 << el;
}
return 0;
}
int impossible = -1;
int possible = n - 1;
while (possible - impossible > 1) {
int med = impossible + (possible - impossible) / 2;
int exchdollar = minperdollar[med];
int exchpound = minperpound[med];
if (isenough(s, k, exchdollar, exchpound, dollargadgets, poundgadgets)) {
possible = med;
} else {
impossible = med;
}
}
outputplan(possible, k, a, b, minperdollar[possible], minperpound[possible],
dollargadgets, poundgadgets);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T>& a) {
os << "{";
for (size_t i = 0; i < a.size(); ++i) os << (i > 0 ? "," : "") << a[i];
return os << "}";
}
[[maybe_unused]] constexpr ll MOD = 1e9 + 7;
[[maybe_unused]] constexpr int INF = 0x3f3f3f3f;
[[maybe_unused]] constexpr ll INFL = 0x3f3f3f3f3f3f3f3fLL;
int main() {
int n, q;
cin >> n >> q;
vector<int> bit(32);
for (int i = 0; i < (n); ++i) {
int a;
cin >> a;
for (int j = 0; j < (32); ++j) {
if (a >> j & 1) bit[j]++;
}
}
for (int i = 0; i < (q); ++i) {
int a;
cin >> a;
vector<int> tmp(bit);
int ans = 0;
for (int j = (32) - 1; 0 <= j; --j) {
int v = 1 << j;
if (a >= v) {
int d = min(a / v, bit[j]);
ans += d;
a -= d * v;
}
}
if (a != 0)
cout << -1 << '\n';
else
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10, MAXM = 2e5 + 10, MAXL = 20, ALP = 26, INF = 1e9 + 10,
MOD = 1e9 + 7;
const string no = "NO\n", yes = "YES\n";
const int hA[4] = {1, 0, -1, 0}, kA[4] = {0, 1, 0, -1};
vector<int> adj[MAXN];
int cnt[2];
void dfs(int c = 0, int p = -1, int col = 0) {
cnt[col]++;
for (auto nxt : adj[c])
if (nxt != p) {
dfs(nxt, c, col ^ 1);
}
}
void solve() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b, --a, --b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs();
cout << max(min(cnt[0], cnt[1]) - 1, 0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int calc(string s) {
int ans_b = 0, j = -1, ans = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'b') ans_b++;
while (j <= i && ans_b > m) {
j++;
if (s[j] == 'b') ans_b--;
}
ans = max(ans, i - j);
}
return ans;
}
int main() {
cin >> n >> m;
string s;
cin >> s;
int r = calc(s);
for (int i = 0; i < s.length(); i++) s[i] = s[i] ^ 'a' ^ 'b';
cout << max(r, calc(s)) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long x, n;
bool operator<(node y) const { return x < y.x; }
};
bool cmp(node x, node y) { return x.n < y.n; }
long long n, A, cf, cm, m, ans, sum, remain;
long long s[100010], num[100010];
node a[100010];
int main() {
long long i, j, l, r, mid, w, d1, d2, d, d3, d4;
scanf("%I64d%I64d%I64d%I64d%I64d", &n, &A, &cf, &cm, &m);
for (i = 1; i <= n; i++) scanf("%I64d", &a[i].x), a[i].n = i;
sort(a + 1, a + 1 + n);
s[0] = 0;
w = 0;
for (i = 1; i <= n; i++) {
s[i] = s[i - 1] + a[i].x;
if (a[i].x == A) w++;
}
ans = w * cf + a[1].x * cm;
d2 = n + 1;
d1 = 0;
remain = m;
for (i = n + 1; i >= 1; i--) {
sum = 0;
if (i != n + 1) {
remain = m - (A * (n - i + 1) - (s[n] - s[i - 1]));
if (remain < 0) break;
sum = (n - i + 1) * cf;
}
l = 0;
r = A;
d = 0;
if (i > 1) {
while (l <= r) {
mid = (l + r) / 2;
w = lower_bound(a + 1, a + 1 + n, (node){mid, 0}) - (a + 1);
w = min(w, i - 1);
if (s[w] - s[0] + remain >= mid * w)
d4 = mid, l = mid + 1, d = w;
else
r = mid - 1;
}
if (d4 == A) sum += cf * d;
l = d4;
}
if (sum + l * cm > ans) {
ans = sum + l * cm;
d1 = d;
d2 = i;
d3 = l;
}
}
for (i = 1; i <= d1; i++) a[i].x = d3;
for (i = d2; i <= n; i++) a[i].x = A;
sort(a + 1, a + 1 + n, cmp);
printf("%I64d\n", ans);
for (i = 1; i < n; i++) printf("%I64d ", a[i].x);
printf("%I64d\n", a[n].x);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int k, a, b, v, s = 0;
int main() {
cin >> k >> a >> b >> v;
while (b >= k - 1) {
s++;
b -= k - 1;
a -= v * k;
if (a <= 0) {
cout << s << endl;
return 0;
}
}
s++;
a -= (b + 1) * v;
if (a <= 0) {
cout << s << endl;
return 0;
}
if (a % v == 0) {
cout << s + a / v << endl;
return 0;
}
cout << s + a / v + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 1e9;
inline int _abs(int a) { return a < 0 ? -a : a; }
inline long long _abs(long long a) { return a < 0 ? -a : a; }
int main() {
long long a, b, p = 1;
scanf("%lld%lld", &a, &b);
for (int i = 0; i < a && p <= b; p *= 2, i++)
;
printf("%lld\n", b % p);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a(n), res(n);
for (int i = 0; i < n; i++) cin >> a[i];
long long mx = INT_MIN;
for (int i = n - 1; i >= 0; i--) {
res[i] = (mx >= a[i] ? mx - a[i] + 1 : 0);
mx = max(mx, a[i]);
}
for (int i = 0; i < n; i++) {
cout << res[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101010;
const int mod = 1e9 + 7;
struct Node {
int x, y, i;
Node() {}
Node(int x, int y, int i) {
this->x = x;
this->y = y;
this->i = i;
}
} nn[N];
bool loop[N], vis[N];
int pre[N];
long long a[N << 1];
set<long long> s[N];
void init() {
a[0] = 1;
for (int i = (1); i < (N * 2); i++) a[i] = a[i - 1] * 2 % mod;
}
bool cmp1(Node a, Node b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
bool cmp2(Node a, Node b) {
if (a.y != b.y) return a.y < b.y;
return a.x < b.x;
}
int find(int x) {
if (x == pre[x]) return x;
return pre[x] = find(pre[x]);
}
void join(int x, int y) {
int fx = find(x), fy = find(y);
pre[fx] = fy;
}
int main() {
init();
int n;
while (~scanf("%d", &n)) {
memset(loop, 0, sizeof(loop));
memset(vis, 0, sizeof(vis));
for (int i = (0); i < (n); i++) pre[i] = i;
for (int i = (0); i < (n); i++) s[i].clear();
for (int i = (0); i < (n); i++) {
int x, y;
scanf("%d%d", &x, &y);
nn[i] = Node(x, y, i);
}
sort(nn, nn + n, cmp1);
for (int i = (0); i < (n - 1); i++)
if (nn[i].x == nn[i + 1].x) {
int x = nn[i].i, y = nn[i + 1].i;
if (find(x) == find(y))
loop[x] = loop[y] = 1;
else
join(x, y);
}
sort(nn, nn + n, cmp2);
for (int i = (0); i < (n - 1); i++)
if (nn[i].y == nn[i + 1].y) {
int x = nn[i].i, y = nn[i + 1].i;
if (find(x) == find(y))
loop[x] = loop[y] = 1;
else
join(x, y);
}
for (int i = (0); i < (n); i++) {
int x = nn[i].i;
int fx = find(x);
if (loop[x]) loop[fx] = 1;
s[fx].insert(nn[i].x);
s[fx].insert(nn[i].y + 2020202020ll);
}
long long ans = 1;
for (int i = (0); i < (n); i++) {
int x = find(nn[i].i);
if (!vis[x]) {
vis[x] = 1;
long long res = a[s[x].size()] - !loop[x];
if (res < 0) res += mod;
ans = ans * res % mod;
}
}
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, a, b;
int gcd(int i, int j) {
if (j == 0) return i;
return gcd(j, i % j);
}
void solve() {
int g = gcd(a, b);
a /= g;
b /= g;
int r = min(n / a, m / b);
int w = a * r;
int h = b * r;
int x1 = x - (w + 1) / 2;
int x2 = x1 + w;
if (x1 < 0) {
x2 += -x1;
x1 = 0;
} else if (x2 > n) {
x1 -= x2 - n;
x2 = n;
}
int y1 = y - (h + 1) / 2;
int y2 = y1 + h;
if (y1 < 0) {
y2 += -y1;
y1 = 0;
} else if (y2 > m) {
y1 -= y2 - m;
y2 = m;
}
cout << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << endl;
}
int main() {
cin >> n >> m >> x >> y >> a >> b;
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
long long r;
int n;
char str[1000100];
int ans[80100];
struct tup {
long long t1, t2;
int typ;
};
long long gcd(long long a, long long b) {
if (!a) return b;
return gcd(b % a, a);
}
pair<long long, long long> nor(pair<long long, long long> a) {
long long g = gcd(a.first, a.second);
return pair<long long, long long>(a.first / g, a.second / g);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%lld ", &r);
stack<long long> st;
stack<char> tmp;
fgets(str, 1000000, stdin);
n = strlen(str);
while (str[n - 1] == '\n' || str[n - 1] == ' ') n--;
str[n] = 0;
string arr;
for (int i = 0; i < n; i++) {
if (str[i] == ' ') continue;
if (str[i] == '(') {
tmp.push('(');
} else if (str[i] == '*') {
arr.push_back('*');
} else if (str[i] == 'S' || str[i] == 'P') {
tmp.push(str[i]);
} else {
while (!tmp.empty() && tmp.top() != '(') {
arr.push_back(tmp.top());
tmp.pop();
}
if (!tmp.empty()) tmp.pop();
}
}
int p = 0;
vector<tup> trr;
for (int i = 0; i < arr.size(); i++) {
if (arr[i] == '*') {
st.push(1);
trr.push_back({0, 0, 2});
} else if (arr[i] == 'S') {
long long t1 = st.top();
st.pop();
long long t2 = st.top();
st.pop();
st.push(min(t1, t2));
trr.push_back({t1, t2, 0});
} else {
long long t1 = st.top();
st.pop();
long long t2 = st.top();
st.pop();
st.push(t1 + t2);
trr.push_back({t1, t2, 1});
}
}
vector<pair<long long, pair<long long, long long> > > tt;
tt.push_back({st.top(), pair<long long, long long>(r, 1)});
vector<long long> ans;
for (int i = (int)trr.size() - 1; i >= 0; i--) {
pair<long long, pair<long long, long long> > tmp = tt.back();
tt.pop_back();
if (trr[i].typ == 0) {
if (trr[i].t1 < trr[i].t2) {
tt.push_back({trr[i].t2, pair<long long, long long>(0, 1)});
tt.push_back({trr[i].t1, tmp.second});
} else {
tt.push_back({trr[i].t2, tmp.second});
tt.push_back({trr[i].t1, pair<long long, long long>(0, 1)});
}
} else if (trr[i].typ == 1) {
pair<long long, long long> tttt =
nor(pair<long long, long long>(trr[i].t1 + trr[i].t2, trr[i].t2));
tttt.first *= tmp.second.first;
tttt.second *= tmp.second.second;
tttt = nor(tttt);
tt.push_back({trr[i].t2, tttt});
tttt =
nor(pair<long long, long long>(trr[i].t1 + trr[i].t2, trr[i].t1));
tttt.first *= tmp.second.first;
tttt.second *= tmp.second.second;
tttt = nor(tttt);
tt.push_back({trr[i].t1, tttt});
} else {
ans.push_back(tmp.second.first / tmp.second.second);
}
}
reverse(ans.begin(), ans.end());
printf("REVOLTING ");
for (long long &v : ans) {
printf("%lld ", v);
}
puts("");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long number;
number = ((y2 - y1) / 2 + 1ll) * (x2 - x1 + 1ll) - (x2 - x1) / 2;
cout << number;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int elementos;
int valor;
vector<int> numeros;
scanf("%d", &elementos);
for (int i = (0); i < (elementos); ++i) {
int flag = 1;
for (int j = (0); j < (elementos); ++j) {
scanf("%d", &valor);
if (valor == 3 || valor == 1) flag = 0;
}
if (flag == 1) numeros.push_back(i + 1);
}
printf("%d\n", numeros.size());
for (int i = 0; i < numeros.size(); ++i) {
printf("%d", numeros[i]);
if (i != numeros.size() - 1) printf(" ");
}
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void gmin(T &x, const T &y) {
if (x > y) x = y;
}
template <class T>
inline void gmax(T &x, const T &y) {
if (x < y) x = y;
}
const int BufferSize = 1 << 16;
char buffer[BufferSize], *Bufferhead, *Buffertail;
bool Terminal;
inline char Getchar() {
if (Bufferhead == Buffertail) {
int l = fread(buffer, 1, BufferSize, stdin);
if (!l) {
Terminal = 1;
return 0;
}
Buffertail = (Bufferhead = buffer) + l;
}
return *Bufferhead++;
}
template <class T>
inline bool read(T &x) {
x = 0;
char c = Getchar(), rev = 0;
while (c < '0' || c > '9') {
c = Getchar();
rev |= c == '-';
if (Terminal) return 0;
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = Getchar();
if (c == '.') {
c = Getchar();
double t = 0.1;
while (c >= '0' && c <= '9')
x = x + (c - '0') * t, c = Getchar(), t = t / 10;
}
x = rev ? -x : x;
return 1;
}
inline bool reads(char *x) {
char c = Getchar();
while (c < 33 || c > 126) {
c = Getchar();
if (Terminal) return 0;
}
while (c >= 33 && c <= 126) (*x++) = c, c = Getchar();
*x = 0;
return 1;
}
template <class T>
inline void print(T x, const char c = '\n') {
if (!x) {
putchar('0');
putchar(c);
return;
}
if (x < 0) putchar('-'), x = -x;
int m = 0, a[20];
while (x) a[m++] = x % 10, x /= 10;
while (m--) putchar(a[m] + '0');
putchar(c);
}
const int inf = 0x3f3f3f3f;
const int N = 305, M = 100005, mod = 1e9 + 7;
template <class T, class S>
inline void ch(T &x, const S y) {
x = (x + y) % mod;
}
inline int exp(int x, int y, const int mod = ::mod) {
int ans = 1;
while (y) {
if (y & 1) ans = (long long)ans * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ans;
}
int n, m, a[N], b[N], dp[N][N], c[N][N];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
for (int i = 1; i <= n; i++) {
int x, y = 1;
scanf("%d", &x);
for (int j = 2; j * j <= x; j++)
if (x % j == 0) {
bool ok = 0;
while (x % j == 0) ok ^= 1, x /= j;
if (ok) y = y * j;
}
a[i] = x * y;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++)
if (a[i] != a[i - 1])
b[++m] = 1;
else
b[m]++;
dp[0][0] = 1;
for (int i = 1; i <= m; i++)
for (int j = 0; j <= n; j++)
for (int k = 1; k <= b[i] && k <= j; k++)
ch(dp[i][j], (long long)dp[i - 1][j - k] * c[j][k] % mod *
c[b[i] - 1][k - 1] % mod);
int ans = 0;
for (int i = 0; i <= n; i++)
if ((n - i) & 1)
ch(ans, mod - dp[m][i]);
else
ch(ans, dp[m][i]);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= b[i]; j++) ans = (long long)ans * j % mod;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const clock_t MAXT = (100 * CLOCKS_PER_SEC) / 1000;
const int px[5] = {0, 0, 1, -1}, py[5] = {-1, 1, 0, 0}, N = 1100, INF = 1e9,
MOD = 1e9 + 7;
const long double eps = 1e-6, PI = 3.14159265358979323846;
long long n, k, m, mx, mx_num, ans, sum, kek, s[N], c[N];
vector<int> g[N];
bitset<N> usd, cap;
void dfs(int v) {
usd[v] = true;
++sum;
for (int i = 0; i < g[v].size(); ++i)
if (!usd[g[v][i]]) dfs(g[v][i]);
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; ++i) {
cin >> c[i];
cap[c[i]] = true;
}
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
mx = 0;
for (int i = 0; i < k; ++i) {
sum = 0;
dfs(c[i]);
s[i] = sum;
if (sum >= mx) {
mx = sum;
mx_num = i;
}
}
for (int i = 1; i <= n; ++i)
if (!usd[i] && !cap[i]) ++kek;
s[mx_num] += kek;
ans = 0;
for (int i = 0; i < k; ++i)
if (s[i]) ans += s[i] * (s[i] - 1);
ans /= 2;
cout << ans - m;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
const int INF = 1e9;
int n, a[maxn][200], b[maxn][200], c[maxn][200];
string s, ss, str[maxn * maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
if (n == 1) {
cout << '?' << ' ' << 1 << ' ' << 1 << endl;
cin >> s;
cout << '!' << ' ' << s << '\n';
return 0;
}
if (n == 2) {
cout << '?' << ' ' << 1 << ' ' << 1 << endl;
cin >> s;
cout << '?' << ' ' << 2 << ' ' << 2 << endl;
cin >> ss;
cout << '!' << ' ' << s << ss << '\n';
return 0;
}
cout << '?' << ' ' << 2 << ' ' << n / 2 + 1 << endl;
int x = (n / 2) * (n / 2 + 1) / 2, len, flag;
while (x--) {
cin >> s;
len = s.length();
for (int i = 0; i < len; i++) a[len][s[i]]++;
}
cout << '?' << ' ' << 1 << ' ' << n / 2 + 1 << endl;
x = (n / 2 + 2) * (n / 2 + 1) / 2;
while (x--) {
cin >> s;
len = s.length();
for (int i = 0; i < len; i++) b[len][s[i]]++;
}
string pre_s = "", saf_s = "";
for (int i = 1; i <= n / 2 + 1; i++) {
for (int j = 'a'; j <= 'z'; j++) {
if (a[i][j] < b[i][j]) {
for (int k = i + 1; k <= n / 2 + 1; k++) a[k][j]++;
pre_s += char(j);
}
}
}
cout << '?' << ' ' << 1 << ' ' << n << endl;
x = n * (n + 1) / 2;
while (x--) {
cin >> s;
len = s.length();
for (int i = 0; i < len; i++) c[len][s[i]]++;
}
char cc;
for (int i = 1; i <= n - (n / 2 + 1); i++) {
for (int j = 'a'; j <= 'z'; j++) {
cc = j;
int num = c[1][j] - (c[i + 1][j] - c[i][j]);
for (int k = 0; k < i; k++) num -= pre_s[k] == cc;
for (int k = 0; k < saf_s.length(); k++) num -= saf_s[k] == cc;
if (num > 0) {
saf_s = cc + saf_s;
break;
}
}
}
cout << '!' << ' ' << pre_s << saf_s << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const double EPS = 1e-9;
const double PI = acos(-1.);
const int MX = 2e6;
int cnt[10][MX];
int pos = 1;
char s[100500];
bool used[100500];
int fst[100500];
int lf[100500];
int rg[100500];
int ip;
int nxtr[100500], nxtl[100500];
void mrigh() {
rg[ip] = min(rg[ip], pos);
while (s[nxtr[ip]] == ' ') {
rg[nxtr[ip]] = min(rg[nxtr[ip]], pos);
nxtr[ip] = nxtr[nxtr[ip]];
}
ip = nxtr[ip];
}
void mleft() {
lf[ip] = min(lf[ip], pos);
while (s[nxtl[ip]] == ' ') {
lf[nxtl[ip]] = min(lf[nxtl[ip]], pos);
nxtl[ip] = nxtl[nxtl[ip]];
}
ip = nxtl[ip];
}
void build(int st) {
ip = st;
int dir = 1;
while (true) {
if (ip < st || s[ip] == 0) return;
used[ip] = true;
fst[ip] = min(fst[ip], pos);
int cur = ip;
if (s[ip] == '>') {
mrigh();
if (s[ip] == '>' || s[ip] == '<') s[cur] = ' ';
dir = 1;
continue;
}
if (s[ip] == '<') {
mleft();
if (s[ip] == '>' || s[ip] == '<') s[cur] = ' ';
dir = -1;
continue;
}
cnt[s[ip] - '0'][pos] = 1;
++pos;
if (s[ip] == '0')
s[ip] = ' ';
else
--s[ip];
if (dir > 0)
mrigh();
else
mleft();
}
}
int main() {
int n, q;
scanf("%d%d%s", &n, &q, &s);
int len = strlen(s);
for (int i = 0; i <= len; ++i) {
nxtl[i] = i - 1;
nxtr[i] = i + 1;
fst[i] = INF;
lf[i] = INF;
rg[i] = INF;
}
for (int i = 0; i < len; ++i) {
if (!used[i]) build(i);
}
for (int j = 0; j < 10; ++j)
for (int i = 1; i < pos; ++i) {
cnt[j][i] += cnt[j][i - 1];
}
for (int i = 0; i < q; ++i) {
int l, r;
scanf("%d%d", &l, &r);
--l;
--r;
int frm = fst[l] - 1;
int to = min(lf[l], rg[r]) - 1;
to = min(to, pos - 1);
for (int j = 0; j < 10; ++j) {
printf("%d ", cnt[j][to] - cnt[j][frm]);
}
puts("");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <int Size>
struct UF {
UF() {
for (int i = 0; i < Size; i++) {
rep[i] = i;
parent[i] = 0;
tail[i] = i;
}
}
int find(int a) {
while (rep[a] != a) {
a = rep[a] = rep[rep[a]];
}
return a;
}
int rep[Size];
int parent[Size];
int tail[Size];
bool uni(int a, int b) {
a = find(a);
b = find(b);
if (a == b) {
return false;
}
rep[a] = b;
parent[a] = tail[b];
tail[b] = tail[a];
return true;
}
};
const int L = 150000 + 10;
int main() {
UF<L> uf;
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
uf.uni(a, b);
}
int r = uf.find(1);
int v = uf.tail[r];
auto sp = "";
while (v != 0) {
printf("%s%d", sp, v);
v = uf.parent[v];
sp = " ";
}
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 3e3 + 5, MOD = 998244353;
int a[N], w[N], inv[N], dp[M][M];
int sum(int a, int b) { return a + b - (a + b >= MOD ? MOD : 0); }
int mul() { return 1; }
template <typename Head, typename... Tail>
int mul(Head H, Tail... T) {
return 1ll * mul(T...) * H % MOD;
}
int Pow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) res = mul(res, a);
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
int Pos = 0, Neg = 0;
for (int i = 1; i <= n; i++) {
cin >> w[i];
if (a[i])
Pos += w[i];
else
Neg += w[i];
}
int Sum = Pos + Neg;
for (int i = -m; i <= m; i++) inv[i + m] = Pow(Sum + i, MOD - 2);
int InvP = Pow(Pos, MOD - 2), InvN = Pow(Neg, MOD - 2);
dp[0][0] = 1;
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= min(m, Neg); j++) {
if (i)
dp[i][j] =
sum(dp[i][j], mul(dp[i - 1][j], Pos + i - 1, inv[i - j - 1 + m]));
if (j)
dp[i][j] =
sum(dp[i][j], mul(dp[i][j - 1], Neg - j + 1, inv[i - j + 1 + m]));
}
}
int EP = 0, EN = 0;
for (int i = 0; i <= m; i++) {
int j = m - i;
EP = sum(EP, mul(dp[i][j], Pos + i));
EN = sum(EN, mul(dp[i][j], Neg - j));
}
for (int i = 1; i <= n; i++) {
if (a[i])
cout << mul(w[i], InvP, EP) << "\n";
else
cout << mul(w[i], InvN, EN) << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
int ans[N], idx[N];
vector<pair<int, int> > edges[N << 2], query[N];
void update(int v, int l, int r, int L, int R, int x, int y) {
if (l > R || r < L) return;
if (l >= L && r <= R) {
edges[v].push_back(make_pair(x, y));
return;
}
int mid = (l + r) / 2;
update(v * 2, l, mid, L, R, x, y);
update(v * 2 + 1, mid + 1, r, L, R, x, y);
}
struct DSU {
vector<int> p, sz;
stack<int> stk;
DSU(int n) {
p.resize(n + 1);
sz.resize(n + 1, 1);
for (int i = 1; i <= n; i++) p[i] = i;
}
int find(int x) { return (p[x] == x) ? p[x] : find(p[x]); }
int merge(int x, int y) {
if ((x = find(x)) == (y = find(y))) return 0;
if (sz[x] > sz[y]) swap(x, y);
p[x] = y;
sz[y] += sz[x];
stk.push(x);
return 1;
}
void roll_back(int t) {
while (stk.size() > t) {
int x = stk.top();
stk.pop();
sz[p[x]] -= sz[x];
p[x] = x;
}
}
};
void build(int v, int l, int r, DSU &d) {
int tm = d.stk.size();
for (auto e : edges[v]) {
d.merge(e.first, e.second);
}
if (l == r) {
for (auto kk : query[l]) ans[kk.second] = d.sz[d.find(kk.first)];
} else {
int mid = (l + r) / 2;
build(v * 2, l, mid, d);
build(v * 2 + 1, mid + 1, r, d);
}
d.roll_back(tm);
}
int tt[N], xx[N], yy[N], dd[N];
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q, k, day = 1, c = 0;
cin >> n >> q >> k;
DSU d(n);
fill(begin(idx), end(idx), q + 1);
idx[1] = 1;
for (int i = 1; i <= q; i++) {
int typ;
cin >> typ;
if (typ == 1) {
tt[i] = 1;
cin >> xx[i] >> yy[i];
dd[i] = day;
} else if (typ == 2) {
int z;
cin >> z;
query[i].push_back(make_pair(z, ++c));
} else {
day++;
idx[day] = i + 1;
}
}
for (int i = 1; i <= q; i++) {
if (tt[i] == 1) {
update(1, 1, q, i, idx[dd[i] + k] - 1, xx[i], yy[i]);
}
}
build(1, 1, q, d);
for (int i = 1; i <= c; i++) cout << ans[i] << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int NO = 1000005;
const int MOD = 1000000007;
long long value[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
bit[10] = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
string p[NO];
string s;
int main() {
cin >> s;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = n; i >= 1; i--) {
long long v = 0, b = 1;
for (int j = p[i].length() - 1; j >= 3; j--) {
v = (v + value[p[i][j] - '0'] * b) % MOD;
b = b * bit[p[i][j] - '0'] % MOD;
}
value[p[i][0] - '0'] = v;
bit[p[i][0] - '0'] = b;
}
long long ans = 0;
for (int i = 0; s[i]; i++)
ans = (ans * bit[s[i] - '0'] + value[s[i] - '0']) % MOD;
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
int d1[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int d2[8][2] = {{1, 0}, {0, 1}, {0, -1}, {-1, 0},
{1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
vector<vector<int>> adj(100001);
int dist1[100001];
int b1[100001];
int dist2[100001];
int b2[100001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
queue<pair<int, int>> q;
q.push({1, 0});
while (!q.empty()) {
auto f = q.front();
q.pop();
if (b1[f.first]) continue;
b1[f.first] = 1;
dist1[f.first] = f.second;
for (auto i : adj[f.first]) {
if (!b1[i]) q.push({i, f.second + 1});
}
}
int mx = -1, mxind = -1;
for (int i = 1; i <= n; ++i) {
if (mx < dist1[i]) {
mxind = i;
mx = dist1[i];
}
}
q.push({mxind, 0});
while (!q.empty()) {
auto f = q.front();
q.pop();
if (b2[f.first]) continue;
b2[f.first] = 1;
dist2[f.first] = f.second;
for (auto i : adj[f.first]) {
if (!b2[i]) q.push({i, f.second + 1});
}
}
mx = -1, mxind = -1;
for (int i = 1; i <= n; ++i) {
if (mx < dist2[i]) {
mxind = i;
mx = dist2[i];
}
}
cout << mx << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double const eps = 1e-12;
double const infi = 1e22;
double const pi = acos(-1.0);
const int N = 1010;
const int M = 10;
const int P = 8;
double drand() { return (rand() % 100) / 100.0; }
struct point {
double x, y;
void init() { x = y = 0; }
point make(double x, double y) {
this->x = x;
this->y = y;
return *this;
}
double dist(point b) {
return sqrt((x - b.x) * (x - b.x) + (y - b.y) * (y - b.y));
}
bool good(int w, int h) { return (x >= 0 && x <= w && y >= 0 && y <= h); }
point random_walk(double d) {
point ans = *this;
double angle = drand() * 2.0 * pi;
ans.x += d * cos(angle);
ans.y += d * sin(angle);
return ans;
}
};
point a[N], b[M + 10];
double d[M + 10];
int w, h, n;
double min2(point p) {
double mn1 = infi, mn2 = infi;
for (int i = 1; i <= n; ++i) {
double now = a[i].dist(p);
if (now + eps < mn1)
mn2 = mn1, mn1 = now;
else if (now + eps < mn2)
mn2 = now;
}
return mn2;
}
int main() {
ios::sync_with_stdio(0);
srand((int)time(NULL));
cin >> w >> h >> n;
for (int i = 1, x, y; i <= n; ++i) {
cin >> x >> y;
a[i].make(x, y);
}
for (int i = 1; i <= M; ++i) {
double x = drand() * w;
double y = drand() * h;
b[i].make(x, y);
d[i] = min2(b[i]);
}
double dt = sqrt(1LL * w * w + 1LL * h * h);
for (double distance = dt; distance > eps; distance *= 0.99)
for (int i = 1; i <= M; ++i) {
point now = b[i];
double dnow = d[i];
for (int j = 1; j <= P; ++j) {
point next = b[i].random_walk(distance);
if (next.good(w, h)) {
double dnext = min2(next);
if (dnext > dnow + eps) {
dnow = dnext;
now = next;
}
}
}
b[i] = now;
d[i] = dnow;
}
double ans = 0;
for (int i = 1; i <= M; ++i) ans = max(ans, d[i]);
cout << fixed << setprecision(20) << ans << '\n';
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct Item {
int c, h, t;
};
class Knapstack {
private:
vector<vector<int> > one;
vector<Item> onone;
vector<vector<int> > two;
void add(vector<vector<int> >& dp, Item it) {
vector<int> n;
for (int i = 0; i < 4013; i++) {
n.push_back(dp.back()[i]);
if (i >= it.c) n[i] = max(n[i], dp.back()[i - it.c] + it.h);
}
dp.push_back(n);
}
void move() {
while (one.size() > 1) {
add(two, onone.back());
onone.pop_back();
one.pop_back();
}
}
public:
Knapstack() {
one.push_back(vector<int>(4013));
two.push_back(vector<int>(4013));
}
void push(Item it) {
add(one, it);
onone.push_back(it);
}
void pop() {
if (two.size() == 1) move();
two.pop_back();
}
int query(int b) {
int ans = 0;
for (int u = 0; u <= b; u++)
ans = max(ans, one.back()[u] + two.back()[b - u]);
return ans;
}
};
int n, p, q;
Item items[4013];
vector<Item> on[20013];
int off[20013];
vector<pair<int, int> > queries[20013];
int ans[20013];
Knapstack k;
int main() {
scanf("%d%d", &n, &p);
for (int i = 0; i < n; i++) {
int c, h, t;
scanf("%d%d%d", &c, &h, &t);
items[i] = {c, h, t};
}
for (int i = 0; i < n; i++) {
on[items[i].t].push_back(items[i]);
off[items[i].t + p] += 1;
}
scanf("%d", &q);
for (int Q = 0; Q < q; Q++) {
int a, b;
scanf("%d%d", &a, &b);
queries[a].push_back(make_pair(b, Q));
}
for (int t = 0; t < 20013; t++) {
for (int i = 0; i < off[t]; i++) k.pop();
for (Item it : on[t]) k.push(it);
for (pair<int, int> query : queries[t]) {
ans[query.second] = k.query(query.first);
}
}
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100050;
const int S = 400;
const int H = N / S + 1;
const int mod = 998244353;
const int base = 1e6 + 7;
int mul(int x, int y) { return (long long)x * y % mod; }
int add(int x, int y) {
x += y;
return x >= mod ? x - mod : x;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + mod : x;
}
int pow(int x, int k) {
int ans = 1;
for (; k; k >>= 1, x = mul(x, x))
if (k & 1) ans = mul(ans, x);
return ans;
}
int inv(int x) { return pow(x, mod - 2); }
int hsh[H][S], pw[N], ipw[N], n, a[N], clssz[H], clsh[H], ok[H], opnsz[H];
int gth(int b, int l, int r) {
if (l == 0) return hsh[b][r];
return mul(sub(hsh[b][r], hsh[b][l - 1]), ipw[l]);
}
void Build(int b) {
int l = max(1, b * S), r = min(n, (b + 1) * S - 1);
stack<int> stk;
clsh[b] = clssz[b] = 0;
ok[b] = 1;
for (int i = l; i <= r; i++) {
if (a[i] > 0) {
stk.push(a[i]);
} else {
if (stk.size()) {
if (stk.top() != -a[i]) ok[b] = 0;
stk.pop();
} else {
clssz[b]++;
clsh[b] = add(mul(clsh[b], base), -a[i]);
}
}
}
opnsz[b] = stk.size();
while (stk.size()) hsh[b][(int)stk.size() - 1] = stk.top(), stk.pop();
for (int i = 0; i < opnsz[b]; i++) hsh[b][i] = mul(hsh[b][i], pw[i]);
for (int i = 1; i < opnsz[b]; i++) hsh[b][i] = add(hsh[b][i], hsh[b][i - 1]);
}
struct STK {
struct node {
int b, l, r;
};
stack<node> stk;
int ssz;
bool ok;
STK() {
ok = 1;
ssz = 0;
}
void add(int b, int l, int r) {
if (!ok) return;
if (b == -1)
ssz++;
else
ssz += r - l + 1;
stk.push((node){b, l, r});
}
void del(int x, int h1) {
if (ssz < x) ok = 0;
if (!ok) return;
ssz -= x;
int h2 = 0;
while (x) {
node now = stk.top();
stk.pop();
if (now.b == -1) {
x--;
h2 = ::add(mul(h2, base), now.l);
} else {
int mn = min(x, now.r - now.l + 1);
h2 = ::add(mul(h2, pw[mn]), gth(now.b, now.r - mn + 1, now.r));
if (mn != now.r - now.l + 1) stk.push((node){now.b, now.l, now.r - mn});
x -= mn;
}
}
if (h1 != h2) ok = 0;
}
bool CBS() { return ok && ssz == 0; }
} stk;
void AddOne(int i) { stk.add(-1, a[i], -1); }
void AddBlock(int b) { stk.add(b, 0, opnsz[b] - 1); }
void DelOne(int i) { stk.del(1, -a[i]); }
void DelBlock(int b) { stk.del(clssz[b], clsh[b]); }
void One(int i) { a[i] > 0 ? AddOne(i) : DelOne(i); }
void Block(int b) {
DelBlock(b);
stk.ok &= ok[b];
AddBlock(b);
}
int main() {
scanf("%i %*i", &n);
for (int i = 1; i <= n; i++) scanf("%i", &a[i]);
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = mul(pw[i - 1], base);
ipw[0] = 1;
ipw[1] = inv(base);
for (int i = 2; i <= n; i++) ipw[i] = mul(ipw[i - 1], ipw[1]);
for (int i = 0; i * S <= n; i++) Build(i);
int q;
scanf("%i", &q);
while (q--) {
int t, l, r;
scanf("%i %i %i", &t, &l, &r);
if (t == 1)
a[l] = r, Build(l / S);
else {
stk = STK();
int L = l / S, R = r / S;
if (L == R)
for (int i = l; i <= r; i++) One(i);
else {
for (int i = l; i < (L + 1) * S; i++) One(i);
for (int i = L + 1; i < R; i++) Block(i);
for (int i = R * S; i <= r; i++) One(i);
}
if (stk.CBS())
printf("Yes\n");
else
printf("No\n");
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct rua {
int l, x, id;
} q[100001];
int n, Q, _, cnt, a[100001], v[21], res[100001];
bool cmp(rua x, rua y) { return x.l < y.l; }
long long qow(long long x, long long y) {
return y ? (y & 1 ? x * qow(x, y - 1) % 1000000007
: qow(x * x % 1000000007, y / 2))
: 1;
}
void insert(int x) {
int k = 0, p = -1;
while ((1 << k) <= x) k++;
k--;
for (int i = k; i >= 0; i--)
if (v[i])
x = min(x, x ^ v[i]);
else if ((1 << i) <= x) {
v[i] = x, p = i;
break;
}
if (p != -1) {
for (int i = p + 1; i < 20; i++) v[i] = min(v[i], v[i] ^ v[p]);
for (int i = p - 1; i >= 0; i--) v[p] = min(v[p], v[i] ^ v[p]);
}
if (!x || (p != -1 && !v[p])) cnt++;
}
bool find(int x) {
for (int i = 19; i >= 0; i--) x = min(x, x ^ v[i]);
return !x;
}
int main() {
scanf("%d%d", &n, &Q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= Q; i++) scanf("%d%d", &q[i].l, &q[i].x), q[i].id = i;
sort(q + 1, q + Q + 1, cmp);
for (int i = 1; i <= Q; i++) {
while (_ < q[i].l) insert(a[++_]);
res[q[i].id] = find(q[i].x) ? qow(2, cnt) : 0;
}
for (int i = 1; i <= Q; i++) printf("%d\n", res[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tos(T a) {
stringstream ss;
string ret;
ss << a;
ss >> ret;
return ret;
}
string st;
int l, memo[1000009][2];
int get(int pos, int carry) {
if (pos < 0) return carry;
int &ret = memo[pos][carry];
if (ret != -1) return ret;
ret = 9999999;
if (carry == 0) {
if (st[pos] == '0')
return ret = get(pos - 1, 0);
else {
int ra = get(pos - 1, carry) + 1;
int rb = get(pos - 1, 1 - carry) + 1;
ret = min(ra, rb);
return ret;
}
} else {
if (st[pos] == '1')
return ret = get(pos - 1, carry);
else {
int ra = get(pos - 1, 0) + 1;
int rb = get(pos - 1, 1) + 1;
ret = min(ra, rb);
return ret;
}
}
}
int print_path(int pos, int carry) {
if (pos < 0) {
if (carry) printf("+2^%d\n", l - pos - 1);
return carry;
}
if (carry == 0) {
if (st[pos] == '0')
return print_path(pos - 1, 0);
else {
int ra = get(pos - 1, carry) + 1;
if (ra == memo[pos][carry]) {
printf("+2^%d\n", l - pos - 1);
return print_path(pos - 1, carry);
} else {
printf("-2^%d\n", l - pos - 1);
return print_path(pos - 1, 1 - carry);
}
}
} else {
if (st[pos] == '1')
return print_path(pos - 1, carry);
else {
int ra = get(pos - 1, 0) + 1;
if (ra == memo[pos][carry]) {
printf("+2^%d\n", l - pos - 1);
return print_path(pos - 1, 0);
} else {
printf("-2^%d\n", l - pos - 1);
return print_path(pos - 1, 1);
}
}
}
}
int main() {
while (cin >> st) {
memset(memo, -1, sizeof memo);
;
l = st.size();
cout << get(l - 1, 0) << endl;
print_path(l - 1, 0);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long inf = 1e9 + 7;
const long long INF = 1e18 + 5;
const long long maxn = 5e5 + 5;
long long n = 100000000000, a[1555555], o[1055555], mx = 0;
long long u[1511111], b[1100005], sum, cnt, l[555555];
int c[555555];
long long bi(long long x, long long y) {
if (y == 0) return 1ll;
if (y == 1) return x;
long long z = bi(x, y / 2);
z = z * z % n;
if (y & 1) z = z * x % n;
return z % n;
}
vector<int> g[555555], v, vv, ve, gg[555555], gr[555555], gi[555555];
long long ti, tin[555555], fup[555555], x[555555], y[555555], used[555555];
unordered_map<int, int> dp[33333];
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(NULL);
int n, d;
cin >> n >> d;
for (int i = 1; i <= n; i++) cin >> a[i], c[a[i]]++;
dp[d][d] = c[d];
int sum = dp[d][d];
for (int i = 1; i <= 30000; i++)
for (auto to : dp[i]) {
int v = to.second;
int l = to.first;
if (l + i <= 30000) dp[i + l][l] = max(dp[i + l][l], v + c[i + l]);
if (i + l - 1 <= 30000 && l > 1)
dp[i + l - 1][l - 1] = max(dp[i + l - 1][l - 1], v + c[i + l - 1]);
if (i + l + 1 <= 30000)
dp[i + l + 1][l + 1] = max(dp[i + l + 1][l + 1], v + c[i + l + 1]);
sum = max(sum, v);
}
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> x, pair<int, int> y) {
return abs(x.first - x.second) <= abs(y.first - y.second);
}
int main() {
int t;
cin >> t;
while (t--) {
vector<int> cnt[5];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
int ct[5];
memset(ct, 0, sizeof(ct));
for (auto it : str) ct[it - 'a']++;
for (int j = 0; j < 5; j++) cnt[j].push_back(2 * ct[j] - str.size());
}
int ans = 0;
for (int k = 0; k < 5; k++) {
int sp = 0;
sort(cnt[k].begin(), cnt[k].end(), greater<int>());
if (cnt[k][0] <= 0) continue;
sp = 1;
int i = 1, p = cnt[k][0];
while (i < n && p + cnt[k][i] > 0) {
p += cnt[k][i];
sp++;
i++;
}
ans = max(ans, sp);
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, tot, neg;
int head[110000], nex[110000 << 1], to[110000 << 1], val[110000 << 1];
int vis[110000], cnt[110000], a[110000], b[110000], use[110000],
u1[110000 << 1];
int st[110000][2], top, ans, du[110000], f[110000][2][2], g[110000][2][2][2],
d[110000][2];
int e[110000], sum;
void add(int x, int y, int z) {
tot++;
nex[tot] = head[x];
head[x] = tot;
to[tot] = y;
val[tot] = z;
}
void dfs(int x) {
if (use[x]) return;
use[x] = 1;
for (int i = head[x]; i; i = nex[i])
if (!u1[i]) {
e[++sum] = i;
u1[i] = u1[i ^ 1] = 1;
dfs(to[i]);
}
}
int get(int v, int x, int y) {
if (to[v] != abs(b[val[v]])) swap(x, y);
int t = val[v];
if (a[t] < 0) x ^= 1;
if (b[t] < 0) y ^= 1;
return x | y;
}
int main() {
scanf("%d%d", &n, &m);
tot = 1;
int ans = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &cnt[i]);
if (cnt[i] == 1) {
scanf("%d", &a[i]);
if (vis[abs(a[i])]) {
st[top][0] = st[top][1] = 0;
top--;
(ans *= 2) %= 1000000007;
continue;
}
vis[abs(a[i])] = a[i];
if (!du[abs(a[i])]) st[++top][0] = st[top][1] = 1;
}
if (cnt[i] == 2) {
scanf("%d%d", &a[i], &b[i]);
if (a[i] == -b[i]) {
neg++, vis[abs(a[i])] = 1;
(ans *= 2) %= 1000000007;
} else {
int a1 = abs(a[i]), b1 = abs(b[i]);
if (a1 == b1)
vis[a1] = 1, st[++top][0] = st[top][1] = 1;
else {
add(a1, b1, i);
add(b1, a1, i);
du[a1]++;
du[b1]++;
if (vis[a1]) st[top][0] = st[top][1] = 0, top--;
if (vis[b1]) st[top][0] = st[top][1] = 0, top--;
}
}
}
}
for (int now = 1; now <= m; now++)
if (!use[now] && du[now] != 2) {
if (!du[now] && !vis[now])
(ans *= 2) %= 1000000007;
else if (!du[now])
continue;
else {
sum = 0;
dfs(now);
for (int i = 1; i <= sum; i++) memset(f[i], 0, sizeof(f[i]));
if (vis[now]) {
if (vis[now] < 0) {
f[1][0][get(e[1], 0, 0) ^ 1]++;
f[1][1][get(e[1], 0, 1) ^ 1]++;
f[1][0][get(e[1], 1, 0)]++;
f[1][1][get(e[1], 1, 1)]++;
} else {
f[1][0][get(e[1], 0, 0)]++;
f[1][1][get(e[1], 0, 1)]++;
f[1][0][get(e[1], 1, 0) ^ 1]++;
f[1][1][get(e[1], 1, 1) ^ 1]++;
}
} else {
f[1][0][get(e[1], 0, 0)]++;
f[1][1][get(e[1], 0, 1)]++;
f[1][0][get(e[1], 1, 0)]++;
f[1][1][get(e[1], 1, 1)]++;
}
for (int i = 1; i < sum; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++)
for (int t = 0; t <= 1; t++) {
(f[i + 1][j][t ^ get(e[i + 1], k, j)] += f[i][k][t]) %=
1000000007;
}
top++;
for (int i = 0; i <= 1; i++) {
for (int j = 0, t; j <= 1; j++) {
if (t = vis[to[e[sum]]])
(st[top][j ^ i ^ (t < 0)] += f[sum][i][j]) %= 1000000007;
else
(st[top][j] += f[sum][i][j]) %= 1000000007;
}
}
}
}
for (int now = 1; now <= m; now++)
if (!use[now] && du[now] == 2) {
sum = 0;
dfs(now);
for (int i = 1; i <= sum; i++) memset(g[i], 0, sizeof(g[i]));
g[1][0][0][get(e[1], 0, 0)]++;
g[1][0][1][get(e[1], 0, 1)]++;
g[1][1][0][get(e[1], 1, 0)]++;
g[1][1][1][get(e[1], 1, 1)]++;
for (int i = 1; i < sum - 1; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++)
for (int t = 0; t <= 1; t++)
for (int w = 0; w <= 1; w++) {
(g[i + 1][j][t][w ^ get(e[i + 1], k, t)] += g[i][j][k][w]) %=
1000000007;
}
top++;
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++) {
(st[top][get(e[sum], j, i) ^ k] += g[sum - 1][i][j][k]) %=
1000000007;
}
}
d[0][0] = ans;
for (int i = 1; i <= top; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++)
(d[i][j ^ k] += (long long)d[i - 1][j] * st[i][k] % 1000000007) %=
1000000007;
if (neg & 1)
printf("%d\n", d[top][0]);
else
printf("%d\n", d[top][1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void read(long long &x) { scanf("%lld", &x); }
void read(long long &x, long long &y) { scanf("%lld%lld", &x, &y); }
void read(long long &x, long long &y, long long &z) {
scanf("%lld%lld%lld", &x, &y, &z);
}
void read(long long &x, long long &y, long long &z, long long &w) {
scanf("%lld%lld%lld%lld", &x, &y, &z, &w);
}
void read(vector<long long> &oneD) {
for (long long i = 0; i < oneD.size(); i++) {
read(oneD[i]);
}
}
void read(vector<vector<long long> > &twoD) {
for (long long i = 0; i < twoD.size(); i++) {
read(twoD[i]);
}
}
void write(vector<long long> &oneD) {
for (long long i = 0; i < oneD.size(); i++) {
printf("%lld ", oneD[i]);
}
printf("\n");
}
void write(vector<vector<long long> > &twoD) {
for (long long i = 0; i < twoD.size(); i++) {
write(twoD[i]);
}
}
void write(vector<pair<long long, long long> > &oneDP) {
for (long long(i) = 0; (i) < (oneDP.size()); ++(i)) {
printf("%lld %lld\n", oneDP[i].first, oneDP[i].second);
}
}
void write(map<long long, long long> &mpp) {
for (map<long long, long long>::iterator it = mpp.begin(); it != mpp.end();
it++) {
cout << it->first << " : " << it->second << endl;
}
cout << endl;
}
vector<long long> seive;
void Seive() {
const long long maxn = 1000005;
seive.resize(maxn);
for (long long(i) = 0; (i) < (maxn); ++(i)) seive[i] = i;
seive[1] = -1;
seive[0] = -1;
for (long long(i) = 2; (i) <= (maxn); (i) += (1))
if (i == seive[i])
for (long long j = 2 * i; j < maxn; j += i)
if (seive[j] == j) seive[j] = i;
}
long long power(long long x, long long y, long long m) {
if (y == 1) return x % m;
if (y == 0) return 1;
if (y & 1) return (x * power((x * x) % m, (y - 1) / 2, m)) % m;
return power((x * x) % m, y / 2, m) % m;
}
long long modinv(long long x, long long mod = 1000000007) {
return power(x, mod - 2, mod);
}
int main() {
long long n, k;
read(n, k);
long long si = 2;
long long sj = 2, ej = n - 1;
long long m = (n + 1) / 2;
vector<vector<long long> > A(5, vector<long long>(n + 1, 0));
while (k > 1) {
if (sj == ej && k == 2) {
A[2][sj] = 1;
A[3][sj] = 1;
k -= 2;
}
if (sj >= ej) break;
A[si][sj] = 1;
A[si][ej] = 1;
k -= 2;
if (si == 2) {
si = 3;
} else {
si = 2;
sj++;
ej--;
}
}
if (k == 1) {
A[2][m] = 1;
k -= 1;
}
if (k == 0) {
cout << "YES\n";
for (long long(i) = 1; (i) <= (4); ++(i)) {
for (long long(j) = 1; (j) <= (n); ++(j)) {
if (A[i][j] == 1)
cout << "#";
else
cout << ".";
}
cout << endl;
}
} else {
cout << "NO\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
vector<int> G[MAXN];
vector<int> grafo[MAXN];
struct edge {
int u, v, comp;
bool bridge;
};
vector<edge> e;
void addEdge(int u, int v) {
G[u].push_back(e.size()), G[v].push_back(e.size());
e.push_back((edge){u, v, -1, false});
}
int V[MAXN], L[MAXN], P[MAXN], comp[MAXN];
int qV, nbc;
void initDfs(int n) {
for (int i = (0); i < (MAXN); i++) G[i].clear();
memset(G, 0, sizeof(G)), memset(V, 0, sizeof(V)), memset(L, 0, sizeof(L)),
memset(comp, 0, sizeof(comp)), memset(P, 0, sizeof(P));
e.clear();
for (int i = (0); i < (n); i++) V[i] = -1;
nbc = qV = 0;
}
stack<int> st;
void dfs(int u, int pe) {
L[u] = V[u] = qV++;
comp[u] = (pe != -1);
for (auto &ne : G[u])
if (ne != pe) {
int v = e[ne].u ^ e[ne].v ^ u;
if (V[v] == -1) {
st.push(ne);
dfs(v, ne);
if (L[v] > V[u]) {
e[ne].bridge = true;
}
P[u] += (L[v] >= V[u]);
if (L[v] >= V[u]) {
int last;
do {
last = st.top();
st.pop();
e[last].comp = nbc;
} while (last != ne);
nbc++;
comp[u]++;
}
L[u] = min(L[u], L[v]);
} else if (V[v] < V[u]) {
st.push(ne);
L[u] = min(L[u], V[v]);
}
}
}
set<int> C[2 * MAXN];
int compnodo[MAXN];
int ptoart;
void blockcuttree() {
memset(compnodo, 0, sizeof(compnodo));
ptoart = 0;
for (int i = (0); i < (2 * MAXN); i++) C[i].clear();
for (auto &it : e) {
vector<int> nodos = {it.u, it.v};
for (int u : nodos) {
if (comp[u] == 1)
compnodo[u] = it.comp;
else {
if (compnodo[u] == 0) {
compnodo[u] = nbc + ptoart;
ptoart++;
}
C[it.comp].insert(compnodo[u]);
C[compnodo[u]].insert(it.comp);
}
}
}
}
map<pair<int, int>, int> id_eje;
map<pair<int, int>, int> eje_componente;
bool visitado[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
initDfs(n + 1);
for (int i = (0); i < (m); i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
id_eje[{a, b}] = i + 1;
id_eje[{b, a}] = i + 1;
grafo[a].push_back(b);
grafo[b].push_back(a);
addEdge(a, b);
}
for (int i = (0); i < (n); i++) {
if (V[i] == -1) {
dfs(i, -1);
}
}
vector<edge> ejesPorComponente[nbc];
for (auto &eje : e) {
eje_componente[{eje.u, eje.v}] = eje.comp;
eje_componente[{eje.v, eje.u}] = eje.comp;
ejesPorComponente[eje.comp].push_back(eje);
}
vector<int> res;
for (int i = (0); i < (nbc); i++) {
if ((int)(ejesPorComponente[i]).size() <= 2) continue;
bool simple = true;
map<int, int> apariciones_por_nodo;
for (auto &eje : ejesPorComponente[i]) {
apariciones_por_nodo[eje.u]++;
apariciones_por_nodo[eje.v]++;
if (apariciones_por_nodo[eje.u] > 2 || apariciones_por_nodo[eje.v] > 2) {
simple = false;
break;
}
}
if (simple) {
for (auto &eje : ejesPorComponente[i]) {
res.push_back(id_eje[{eje.u, eje.v}]);
}
}
}
sort(res.begin(), res.end());
cout << (int)(res).size() << "\n";
for (auto it = res.begin(); it != res.end(); it++) {
cout << *it << " ";
}
cout << "\n";
}
| 8 |
#include <bits/stdc++.h>
template <typename T>
class IntegerIterator
: public std::iterator<std::input_iterator_tag, T, std::ptrdiff_t, T*, T> {
public:
explicit IntegerIterator(int value) : value(value) {}
IntegerIterator& operator++() {
++value;
return *this;
}
IntegerIterator operator++(int) {
IntegerIterator copy = *this;
++value;
return copy;
}
IntegerIterator& operator--() {
--value;
return *this;
}
IntegerIterator operator--(int) {
IntegerIterator copy = *this;
--value;
return copy;
}
T operator*() const { return value; }
bool operator==(IntegerIterator rhs) { return value == rhs.value; }
bool operator!=(IntegerIterator rhs) { return !(*this == rhs); }
private:
T value;
};
template <typename T>
class IntegerRange {
public:
IntegerRange(T begin, T end) : begin_(begin), end_(end) {}
IntegerIterator<T> begin() const { return IntegerIterator<T>(begin_); }
IntegerIterator<T> end() const { return IntegerIterator<T>(end_); }
private:
T begin_;
T end_;
};
template <typename T>
class ReversedIntegerRange {
public:
ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) {}
std::reverse_iterator<IntegerIterator<T>> begin() const {
return std::reverse_iterator<IntegerIterator<T>>(
IntegerIterator<T>(begin_));
}
std::reverse_iterator<IntegerIterator<T>> end() const {
return std::reverse_iterator<IntegerIterator<T>>(IntegerIterator<T>(end_));
}
private:
T begin_;
T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
;
return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
;
return IntegerRange<T>(from, to);
}
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
;
return IntegerRange<T>(0, to + 1);
}
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
;
return IntegerRange<T>(from, to + 1);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
;
return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
;
return ReversedIntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
;
return ReversedIntegerRange<T>(from + 1, 0);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
;
return ReversedIntegerRange<T>(from + 1, to);
}
using namespace std;
class TaskC {
public:
void solve(std::istream& in, std::ostream& out) {
int n;
in >> n;
vector<vector<int>> g(n);
for (int i : range(n - 1)) {
int x, y;
in >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
int root = -1;
for (int i : range(n)) {
if (g[i].size() > 3) {
root = i;
break;
}
}
if (root == -1) {
out << "Yes\n";
return;
}
remove.assign(n, 0);
canBeInCenter.assign(n, 0);
dfs(g, root, -1);
if (dfs2(g, root, -1, 2))
out << "Yes\n";
else
out << "No\n";
}
vector<int> remove;
vector<int> canBeInCenter;
void dfs(const vector<vector<int>>& g, int v, int p) {
int cntChildren = 0;
int cntDeletedChildren = 0;
for (int to : g[v]) {
if (p == to) {
continue;
}
dfs(g, to, v);
if (remove[to]) {
++cntDeletedChildren;
}
++cntChildren;
}
if (cntChildren <= 1 && cntDeletedChildren == cntChildren) {
remove[v] = 1;
}
if (remove[v] || (cntChildren <= 2 && cntChildren == cntDeletedChildren)) {
canBeInCenter[v] = 1;
}
}
bool dfs2(const vector<vector<int>>& g, int v, int p, int allow) {
int bads = 0;
if (v == 18) {
int x;
x = 3;
cerr << 1;
}
for (int to : g[v]) {
if (p == to) {
continue;
}
if (!canBeInCenter[to]) {
++bads;
}
}
if (bads > allow) return false;
for (int to : g[v]) {
if (p == to) {
continue;
}
if (!canBeInCenter[to]) {
if (!dfs2(g, to, v, 1)) {
return false;
}
}
}
return true;
}
};
int main() {
std::ios_base::sync_with_stdio(false);
TaskC solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
in.tie(0);
out << std::fixed;
out.precision(20);
solver.solve(in, out);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, p, lato;
cin >> n >> p;
lato = max(max(n, p), 2 * min(n, p));
cout << lato * lato << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[1005500], b[1005500];
set<int> s;
int main() {
int n, mx = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", a + i), s.insert(a[i]), mx = max(mx, a[i]);
for (int i = 0; i < n; i++) {
if (mx == a[i]) {
b[i] = *s.begin();
s.erase(s.begin());
} else {
b[i] = *s.upper_bound(a[i]);
s.erase(s.upper_bound(a[i]));
}
}
for (int i = 0; i < n; i++) printf("%d ", b[i]);
puts("");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, m, M, Max;
long long cost = 0, t;
vector<pair<int, int>> v;
cin >> n;
M = 0;
while (n--) {
cin >> m >> Max;
for (i = 2; i <= m; i++) {
cin >> k;
Max = max(Max, k);
}
M = max(M, Max);
v.push_back(make_pair(Max, m));
}
for (i = 0; i < v.size(); i++) {
t = v[i].first;
m = v[i].second;
if (t != M) {
cost += ((M - t) * m);
}
}
cout << cost;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int EXP = 1e-8;
const int N = 1e5 + 5;
const int MOD = 1e9 + 7;
const int MAXN = 3e5 + 5;
const int M = 1e9 + 7;
using namespace std;
int n;
char s[MAXN];
long long a[5];
int main() {
cin >> n >> s;
memset(a, 0, sizeof(a));
for (int i = 0; i < n; ++i) a[s[i] - '0']++;
n /= 3;
a[0] -= n, a[1] -= n, a[2] -= n;
if (a[0] == 0 && a[1] == 0 && a[2] == 0) {
cout << s << endl;
return 0;
}
long long tmp = a[0] * a[1] * a[2];
long long cnt1 = 0, cnt2 = 0, p, q, j;
if (tmp == 0) {
for (int i = 0; i < 3; ++i) {
if (a[i] > 0) cnt1 = abs(a[i]), p = i;
if (a[i] < 0) cnt2 = abs(a[i]), q = i;
}
if (p < q)
for (int i = n * 3 - 1; i >= 0; i--)
if (cnt1 && s[i] == (p + '0')) s[i] = q + '0', cnt1--;
if (p > q)
for (int i = 0; i < 3 * n; ++i)
if (cnt1 && s[i] == (p + '0')) s[i] = q + '0', cnt1--;
} else if (tmp > 0) {
for (int i = 0; i < 3; ++i) {
if (a[i] > 0)
j = i;
else if (a[i] < 0)
if (!cnt1)
cnt1 = abs(a[i]), p = i;
else if (!cnt2)
cnt2 = abs(a[i]), q = i;
}
if (j == 0)
for (int i = n * 3 - 1; i >= 0; i--)
if (cnt2 && s[i] == (j + '0'))
s[i] = q + '0', cnt2--;
else if (cnt1 && s[i] == (j + '0'))
s[i] = p + '0', cnt1--;
if (j == 1) {
for (int i = 0; i < 3 * n; ++i)
if (cnt1 && s[i] == (j + '0')) s[i] = p + '0', cnt1--;
for (int i = n * 3 - 1; i >= 0; i--)
if (cnt2 && s[i] == (j + '0')) s[i] = q + '0', cnt2--;
}
if (j == 2)
for (int i = 0; i < 3 * n; ++i)
if (cnt1 && s[i] == (j + '0'))
s[i] = p + '0', cnt1--;
else if (cnt2 && s[i] == (j + '0'))
s[i] = q + '0', cnt2--;
} else if (tmp < 0) {
for (int i = 0; i < 3; ++i) {
if (a[i] < 0)
j = i;
else if (a[i] > 0)
if (!cnt1)
cnt1 = abs(a[i]), p = i;
else if (!cnt2)
cnt2 = abs(a[i]), q = i;
}
if (j == 2)
for (int i = n * 3 - 1; i >= 0; i--)
if (cnt2 && s[i] == (q + '0'))
s[i] = j + '0', cnt2--;
else if (cnt1 && s[i] == (p + '0'))
s[i] = j + '0', cnt1--;
if (j == 1) {
for (int i = 0; i < 3 * n; ++i)
if (cnt2 && s[i] == (q + '0')) s[i] = j + '0', cnt2--;
for (int i = n * 3 - 1; i >= 0; i--)
if (cnt1 && s[i] == (p + '0')) s[i] = j + '0', cnt1--;
}
if (j == 0)
for (int i = 0; i < 3 * n; ++i)
if (cnt1 && s[i] == (p + '0'))
s[i] = j + '0', cnt1--;
else if (cnt2 && s[i] == (q + '0'))
s[i] = j + '0', cnt2--;
}
cout << s << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int par[1001], ran[1001] = {}, cnt[1001] = {};
int main() {
int n, t, i;
cin >> n;
for (i = 2; i <= n; i++) {
cin >> par[i];
ran[par[i]]++;
}
for (i = 1; i <= n; i++) {
if (!ran[i]) cnt[par[i]]++;
}
for (i = 1; i <= n; i++) {
if (ran[i] && cnt[i] < 3) break;
}
i > n ? cout << "Yes\n" : cout << "No\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> a(n);
int mod = 998244353;
a[0] = 10;
vector<long long> dp(n);
dp[0] = 10;
for (int i = 1; i <= n - 1; i++) dp[i] = (dp[i - 1] * 10) % mod;
for (int i = 1; i <= n - 1; i++) {
a[i] = 9 * dp[i - 1] * 2;
a[i] %= mod;
long long aux = 81 * dp[i - 2];
aux %= mod;
aux *= (i - 1);
aux %= mod;
a[i] += aux;
a[i] %= mod;
}
for (int i = n - 1; i >= 0; i--) cout << a[i] << ' ';
cout << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[(1 << 20)];
int node[(1 << 20)];
int n;
int root(int x) {
while (node[x] != x) {
x = node[x];
}
return x;
}
void init() {
for (int i = 1; i <= n; i++) {
node[i] = i;
}
}
void uni(int x, int y) {
int p = root(x);
int q = root(y);
node[p] = node[q];
}
int kruskal() {
for (int i = 1; i <= n - 1; i++) {
int x = p[i].first;
int y = p[i].second;
if (root(x) != root(y)) {
uni(x, y);
} else {
return 0;
}
}
return 1;
}
int main() {
int i, m, x, y;
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
p[i].first = x;
p[i].second = y;
}
if (m != n - 1) {
printf("no\n");
return 0;
}
init();
int ans = kruskal();
if (ans == 1)
printf("yes\n");
else
printf("no\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
float s, k;
cin >> n;
for (int i; i < n; i++) {
cin >> k;
s += k;
}
cout << setprecision(6) << float(s / n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void err(istringstream *iss) {}
template <typename T, typename... Args>
void err(istringstream *iss, const T &varVal, const Args &...args) {
string varName;
*iss >> varName;
if (varName.back() == ',') varName.back() = ' ';
cout << varName << " = " << varVal << "; ", err(iss, args...);
}
int n, m, K, T, Q, cn;
int lcm[] = {0, 1, 2, 6, 12, 60, 60, 420,
840, 2520, 2520, 27720, 27720, 360360, 360360, 360360};
long long a, b;
long long func(long long hi, long long lo) {
long long ret = 0;
while (hi > lo) {
long long mx = 1;
for (int i = 2; i <= K; i++) {
if (hi % i <= hi - lo) mx = max(mx, hi % i);
}
hi -= mx;
ret++;
}
return ret;
}
int main() {
cin.tie(NULL);
scanf("%lld%lld%d", &a, &b, &K);
int l = lcm[K];
long long x = ((b - 1) / l + 1) * l, y = a / l * l;
printf("%lld\n", a - b <= l ? func(a, b)
: func(x, b) + (y / l - x / l) * func(x + l, x) +
func(a, y));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 5;
const long long inf = ~0ULL >> 2;
template <class T>
inline void mini(T &a, const T b) {
if (b < a) a = b;
}
template <class T>
inline void maxi(T &a, const T b) {
if (b > a) a = b;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
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 g, n[2], inv[2];
vector<long long> a[2][N];
map<long long, long long> mp;
inline void ins(long long loc, long long val) {
if (mp.find(loc) == mp.end()) mp[loc] = inf;
mini(mp[loc], val);
}
long long seq[N];
void scan(int i, long long &now) {
for (map<long long, long long>::iterator cur = mp.begin(); cur != mp.end();) {
mini(cur->second, now);
mini(now, cur->second);
map<long long, long long>::iterator nex = cur;
++nex;
now += ((nex != mp.end() ? nex->first : mp.begin()->first + n[i]) -
cur->first) *
n[i ^ 1] * g;
cur = nex;
}
}
long long work(long long r) {
long long best = 0;
for (int i = 0; i <= 1; i++) {
mp.clear();
*seq = 0;
for (int j = 0; j <= 1; j++) {
for (vector<long long>::iterator cur = a[j][r].begin();
cur != a[j][r].end(); cur++) {
long long id = (*cur) % n[i] * inv[i ^ 1] % n[i];
ins(id, (*cur) * g + r);
ins((id + n[i] - 1) % n[i], inf);
if (j == i) seq[++*seq] = id;
}
}
sort(seq + 1, seq + *seq + 1);
long long now = inf;
scan(i, now);
scan(i, now);
int j = 1;
for (map<long long, long long>::iterator cur = mp.begin(); cur != mp.end();
cur++) {
for (; j <= *seq && seq[j] < cur->first; j++)
;
if (j <= *seq && seq[j] == cur->first)
;
else
maxi(best, cur->second);
}
}
return best;
}
int main() {
scanf("%I64d%I64d", &n[0], &n[1]);
g = gcd(n[0], n[1]);
if (g > 1e5) {
puts("-1");
return 0;
}
n[0] /= g;
n[1] /= g;
exgcd(n[0], n[1], inv[0], inv[1]);
inv[0] = (inv[0] % n[1] + n[1]) % n[1];
inv[1] = (inv[1] % n[0] + n[0]) % n[0];
for (int i = 0; i <= 1; i++) {
int cnt;
scanf("%d", &cnt);
while (cnt--) {
int x;
scanf("%d", &x);
a[i][x % g].push_back(x / g);
}
}
for (int r = 0; r < g; r++)
if (a[0][r].empty() && a[1][r].empty()) {
puts("-1");
return 0;
}
long long ans = 0;
for (int r = 0; r < g; r++) ans = max(ans, work(r));
printf("%I64d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, t, x, y;
vector<int> g[(1 << 10)];
int main() {
cin >> n >> t;
for (int i = 1; i <= n; i++) cin >> x >> y, g[x].push_back(y);
for (int i = 1; i <= t; i++) {
sort(g[i].begin(), g[i].end(), greater<int>());
for (int j = 0; j < g[i].size(); j += 2)
if (j == g[i].size() - 1)
g[i + 1].push_back(g[i][j]);
else
g[i + 1].push_back(g[i][j] + g[i][j + 1]);
}
cout << g[t][0] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 10012;
const long long inf = 2e9;
int n, x[N], y[N];
int ans;
int sdflksdfld[N], sdlfklsd[N];
vector<int> g[N], G[N][2];
int used[N], tmr;
map<int, vector<int>> gx, gy;
map<int, vector<pair<int, int>>> A, B;
inline bool dfs(int v) {
if (used[v] == tmr) return false;
used[v] = tmr;
for (int to : g[v])
if (sdlfklsd[to] == -1 || dfs(sdlfklsd[to])) {
sdlfklsd[to] = v;
sdflksdfld[v] = to;
return true;
}
return false;
}
int was[N][2];
inline void go(int v, int is_l = 0) {
if (was[v][is_l]) return;
was[v][is_l] = 1;
for (int to : G[v][is_l]) go(to, is_l ^ 1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
ans = 4 * n;
vector<pair<int, pair<int, int>>> ver, hor;
for (long long i = 1; i <= n; ++i) {
cin >> x[i] >> y[i], gx[x[i]].push_back(y[i]), gy[y[i]].push_back(x[i]);
}
for (auto &v : gx) {
sort(v.second.begin(), v.second.end());
for (int i = 1; i < v.second.size(); ++i) {
ver.push_back({v.first, {v.second[i - 1], v.second[i]}});
}
for (int i = 0; i < v.second.size(); ++i) {
ver.push_back({v.first, {v.second[i], v.second[i]}});
}
}
for (auto &v : gy) {
sort(v.second.begin(), v.second.end());
for (int i = 1; i < v.second.size(); ++i) {
hor.push_back({v.first, {v.second[i - 1], v.second[i]}});
}
for (int i = 0; i < v.second.size(); ++i) {
hor.push_back({v.first, {v.second[i], v.second[i]}});
}
}
for (int i = 0; i < ver.size(); ++i)
for (int j = 0; j < hor.size(); ++j) {
auto &v = ver[i], h = hor[j];
int vx = v.first, vl = v.second.first, vr = v.second.second;
int hy = h.first, hl = h.second.first, hr = h.second.second;
if (hl < vx && vx < hr && vl < hy && hy < vr) {
g[i].push_back(j);
}
}
for (int i = 0; i < ver.size(); ++i) sdflksdfld[i] = -1;
for (int i = 0; i < hor.size(); ++i) sdlfklsd[i] = -1;
for (int run = 1; run;) {
run = 0;
tmr++;
for (int i = 0; i < ver.size(); ++i)
if (sdflksdfld[i] == -1 && dfs(i)) run = 1;
}
int par = 0;
for (int i = 0; i < ver.size(); ++i)
if (sdflksdfld[i] != -1) {
G[sdflksdfld[i]][1].push_back(i);
++par;
}
for (int i = 0; i < ver.size(); ++i) {
for (int to : g[i])
if (sdflksdfld[i] != to) {
G[i][0].push_back(to);
}
}
for (int i = 0; i < ver.size(); ++i)
if (sdflksdfld[i] == -1) go(i);
vector<pair<int, int>> ans;
for (int i = 0; i < ver.size(); ++i)
if (was[i][0]) ans.push_back({i, 0});
for (int i = 0; i < hor.size(); ++i)
if (was[i][1] == 0) ans.push_back({i, 1});
for (int i = 0; i < ans.size(); ++i) {
if (ans[i].second == 0) {
int id = ans[i].first;
int x = ver[id].first;
int l = ver[id].second.first;
int r = ver[id].second.second;
A[x].push_back({l, r});
} else {
int id = ans[i].first;
int y = hor[id].first;
int l = hor[id].second.first;
int r = hor[id].second.second;
B[y].push_back({l, r});
}
}
vector<pair<int, pair<int, int>>> ansx, ansy;
for (auto &v : A) {
sort(v.second.begin(), v.second.end());
pair<int, int> cur = {-1, -1};
int x = v.first;
for (int i = 0; i < v.second.size(); ++i) {
int l = v.second[i].first, r = v.second[i].second;
if (l == cur.second) {
cur = {cur.first, r};
} else {
if (cur.first > 0) ansx.push_back({x, cur});
cur = {l, r};
}
}
if (cur.first > 0) ansx.push_back({x, cur});
}
for (auto &v : B) {
sort(v.second.begin(), v.second.end());
pair<int, int> cur = {-1, -1};
int y = v.first;
for (int i = 0; i < v.second.size(); ++i) {
int l = v.second[i].first, r = v.second[i].second;
if (l == cur.second) {
cur = {cur.first, r};
} else {
if (cur.first > 0) ansy.push_back({y, cur});
cur = {l, r};
}
}
if (cur.first > 0) ansy.push_back({y, cur});
}
cout << ansy.size() << '\n';
for (auto &v : ansy) {
cout << v.second.first << ' ' << v.first << ' ' << v.second.second << ' '
<< v.first << '\n';
}
cout << ansx.size() << '\n';
for (auto &v : ansx) {
cout << v.first << ' ' << v.second.first << ' ' << v.first << ' '
<< v.second.second << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> v;
int max_f;
int f(vector<int> &v) {
int res = 0;
for (int i = 0; i < v.size(); i++) {
int temp = 1000000;
for (int j = i; j < v.size(); j++) {
temp = min(temp, v[j]);
res += temp;
}
}
return res;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) v.push_back(i);
do {
max_f = max(max_f, f(v));
} while (next_permutation(v.begin(), v.end()));
do {
if (f(v) == max_f) {
m--;
if (m == 0) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
}
} while (next_permutation(v.begin(), v.end()));
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int INF = 1e8;
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 1; i < 100000; i++) {
long long aux = i;
long long poner = aux * (aux + 1) / 2;
long long comer = poner - k;
if (poner < k) continue;
if (comer >= 0 && comer <= poner && aux + comer == n) {
ans = max(ans, n - aux);
}
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int i, j, k, l, m, n, r, t, a[123][123];
int main() {
for (scanf("%i", &t); t--;) {
scanf("%i", &n), scanf("%i", &m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) scanf("%i", &a[i][j]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (a[i][j] % 2 == (i + j) % 2) a[i][j]++;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) printf("%i ", a[i][j]);
puts("");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long q;
cin >> q;
while (q--) {
long long k, x;
cin >> k >> x;
cout << (k - 1) * 9 + x << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void sol() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int>> v;
for (int i = 1; i <= n; i++) {
if (i % 2 == 1) {
for (int j = 1; j <= m; j++) {
v.push_back(make_pair(i, j));
}
} else {
for (int j = m; j >= 1; j--) {
v.push_back(make_pair(i, j));
}
}
}
cout << n * m - 2 * (k - 1) << " ";
for (int i = 0; i < n * m - 2 * (k - 1); i++) {
cout << v[i].first;
cout << " ";
cout << v[i].second;
cout << " ";
}
cout << endl;
int a = n * m - 2 * (k - 1);
for (int i = 0; i < k - 1; i++) {
cout << 2 << " ";
cout << v[a].first << " " << v[a].second << " ";
a++;
cout << v[a].first << " " << v[a].second << " ";
a++;
cout << endl;
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
sol();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
map<int, int> ma;
int n, m;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
ma[a] = max(ma[a], b);
}
cin >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
ma[a] = max(ma[a], b);
}
long long ans = 0;
for (auto i : ma) {
ans += i.second;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long long INF = 1e18;
inline long long min(const long long x, const long long y) {
return x < y ? x : y;
}
inline long long max(const long long x, const long long y) {
return x > y ? x : y;
}
struct Node {
long long l, r, sum, *v;
} t[4000005];
long long a[1000005], p, ans, l, r;
void pushup(const long long O) {
t[O].sum = t[O << 1].sum + t[O << 1 | 1].sum;
long long n(t[O << 1].r - t[O << 1].l + 1),
m(t[O << 1 | 1].r - t[O << 1 | 1].l + 1);
for (long long i(0), j(0); i <= n; ++i) {
if (m < j) --j;
for (; j <= m; ++j) {
long long tmp(t[O << 1 | 1].v[j] + i * p - t[O << 1].sum);
if (t[O << 1].v[i + 1] - 1 < tmp) {
j = max(j - 1, 0);
break;
}
t[O].v[i + j] = min(t[O].v[i + j], max(t[O << 1].v[i], tmp));
}
}
}
void make_tree(const long long O, const long long L, const long long R) {
t[O].l = L, t[O].r = R, t[O].v = new long long[R - L + 3];
if (L != R) {
make_tree(O << 1, L, L + R >> 1);
make_tree(O << 1 | 1, (L + R >> 1) + 1, R);
for (long long i(0); i <= R - L + 2; ++i) t[O].v[i] = INF;
pushup(O);
} else
t[O].v[0] = -INF, t[O].v[1] = p - a[L], t[O].v[2] = INF, t[O].sum = a[L];
}
void query(const long long O, const long long L, const long long R) {
if (L <= t[O].l && t[O].r <= R) {
ans += t[O].sum -
(std::upper_bound(t[O].v, t[O].v + t[O].r - t[O].l + 3, ans) -
t[O].v - 1) *
p;
return;
}
const long long mid(t[O].l + t[O].r >> 1);
if (L <= mid) query(O << 1, L, R);
if (mid < R) query(O << 1 | 1, L, R);
}
signed main() {
long long n, m;
scanf("%lld%lld%lld", &n, &m, &p);
for (long long i(1); i <= n; ++i) scanf("%lld", a + i);
make_tree(1, 1, n);
while (m--) {
ans = 0LL;
long long l, r;
scanf("%lld%lld", &l, &r);
query(1, l, r);
printf("%lld\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
double n, p[100005];
void solve() {
double ans = 0, g = 0, s = 0, t = 0;
for (int i = 1; i <= n; i++) {
t = p[i - 1] * (t + 2 * s) + (1 - p[i - 1]);
s = p[i - 1] * s + (1 - p[i - 1]);
g = p[i] * (g + t);
ans += (1 - p[i + 1]) * g;
}
cout << fixed << setprecision(9) << ans << endl;
}
int main() {
while (cin >> n) {
memset(p, 0, sizeof(p));
for (int i = 1; i <= n; i++) {
scanf("%lf", &p[i]);
}
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int values[1013];
int dp[1013][1013];
int prefix[1013][1013];
int main() {
if (fopen("FILENAME.in", "r")) {
freopen("FILENAME.in", "r", stdin);
freopen("FILENAME.out", "w", stdout);
}
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> values[i];
}
sort(values, values + n);
int answer = 0;
for (int beauty = 1; beauty * (k - 1) <= 100010; beauty++) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= k; j++) {
dp[i][j] = 0;
prefix[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
dp[i][1] = 1;
prefix[i + 1][1] = prefix[i][1] + 1;
}
int bound = 0;
for (int i = 1; i < n; i++) {
while (abs(values[bound] - values[i]) >= beauty) {
bound++;
}
bound--;
if (abs(values[0] - values[i]) < beauty) {
for (int j = 2; j <= k; j++) {
prefix[i + 1][j] += prefix[i][j];
}
continue;
}
for (int j = 2; j <= k; j++) {
dp[i][j] += prefix[bound + 1][j - 1];
dp[i][j] %= 998244353;
prefix[i + 1][j] += prefix[i][j] + dp[i][j];
prefix[i + 1][j] %= 998244353;
}
}
for (int i = 0; i < n; i++) {
answer += dp[i][k];
answer %= 998244353;
}
}
cout << answer << endl;
}
| 8 |
#include<bits/stdc++.h>
#define DEBUG freopen("input.txt", "r", stdin);
using namespace std;
vector<int> vec;
string temp;
void solve(){
int n;
cin >> n;
vector<int>().swap(vec);
vec.push_back(1);
int x;
cin >> x;
int k = 1;
cout << 1 << endl;
for(int i = 1; i < n; ++i){
cin >> x;
if(x == 1){
if(vec.size() == k){
vec.push_back(1);
k++;
}
else vec[k++] = 1;
for(int j = 0; j < k; ++j){
cout << vec[j];
if(j != k - 1) cout << ".";
}
cout << endl;
continue;
}
else{
while(k > 0 && vec[k - 1] != x - 1) k--;
vec[k - 1] = x;
for(int j = 0; j < k; ++j){
cout << vec[j];
if(j != k - 1) cout << ".";
}
cout << endl;
}
}
//cout << "here:" << endl;
}
int main(){
// DEBUG
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while(t--){
solve();
//cout << "here:" << endl;
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
struct data {
data() {}
bool friend operator<(data a, data b) { return 0; }
};
int n, m, k;
long long N, M, K;
int main() {
int t, tc = 1;
scanf("%d", &n);
int ct = 0;
for (int i = 2; i <= n; i++) {
if (n % i == 0) ct++;
}
printf("%d", ct);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, a[105];
int p, z, sum;
cin >> t;
while (t--) {
cin >> n;
z = 0, sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
if (a[i] == 0) z++;
}
if ((sum + z) == 0) z++;
cout << z << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 1e5 + 5;
char a[20][MAXN];
int des;
int n, m;
int d[20][2];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%s", a[i]);
}
d[n + 1][1] = INF;
int des = n;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < m + 2; j++) {
if (a[i][j] == '1') {
des = i;
}
}
}
for (int i = n; i >= des + 1; i--) {
int fir = m + 1, last = 0;
for (int j = 0; j < m + 2; j++) {
if (a[i][j] == '1') {
if (fir == m + 1) {
fir = j;
}
last = j;
}
}
d[i][0] = min(d[i + 1][0] + (last + 1) * 2 - 1, d[i + 1][1] + m + 2);
d[i][1] = min(d[i + 1][1] + (m + 2 - fir) * 2 - 1, d[i + 1][0] + m + 2);
}
int ans = 0;
int fir = m + 1, last = 0;
for (int i = 0; i < m + 2; i++) {
if (a[des][i] == '1') {
if (fir == m + 1) {
fir = i;
}
last = i;
}
}
ans = min(d[des + 1][0] + last, d[des + 1][1] + m + 2 - fir - 1);
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char mp[510][510];
int main() {
int n, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> mp[i][j];
}
}
for (int i = 2; i < n; i++) {
for (int j = 2; j < n; j++) {
if (mp[i][j] == 'X' && mp[i - 1][j - 1] == 'X' &&
mp[i + 1][j - 1] == 'X' && mp[i + 1][j + 1] == 'X' &&
mp[i - 1][j + 1] == 'X')
ans++;
}
}
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int x = 0, y = 0;
cin >> str;
int i = 0;
while (str[i]) {
if (str[i] == 'x')
x++;
else
y++;
i++;
}
if (y > x)
cout << string(y - x, 'y');
else
cout << string(x - y, 'x');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n + 1);
for (long long i = 1; i <= n; i++) cin >> a[i];
vector<long long> s;
for (long long i = 1; i <= n; i++) s.push_back(a[i] - a[i - 1]);
long long mx = s[0];
for (long long i = 1; i < n; i++) {
if (s[i] < 0 and mx + s[i] >= 0) {
mx += s[i];
s[i] = 0;
}
}
bool ok = 1;
for (long long i = 0; i < n; i++) ok &= (s[i] >= 0);
if (ok)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const long long INF = 1e9;
int n, m;
vector<int> ar[MAXN];
int marc[MAXN];
long long seg[4 * MAXN], id[4 * MAXN], lz[4 * MAXN];
vector<int> ans;
void refresh(int pos, int ini, int fim);
void build(int pos, int ini, int fim);
void update(int pos, int ini, int fim, int p, int q, long long val);
int bb(int pos, int ini, int fim);
void getComp(int cur);
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
ar[a].push_back(b);
ar[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (marc[i]) continue;
getComp(i);
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
printf("\n");
}
void refresh(int pos, int ini, int fim) {
if (lz[pos] == 0) return;
seg[pos] += lz[pos];
if (ini != fim) {
int e = pos << 1, d = e | 1;
lz[e] += lz[pos];
lz[d] += lz[pos];
}
lz[pos] = 0;
}
void build(int pos, int ini, int fim) {
if (ini == fim) {
if (marc[ini])
seg[pos] = 3 * INF;
else
seg[pos] = -INF;
id[pos] = ini;
lz[pos] = 0;
return;
}
int mid = (ini + fim) >> 1, e = pos << 1, d = e | 1;
build(e, ini, mid);
build(d, mid + 1, fim);
if (seg[e] <= seg[d])
seg[pos] = seg[e], id[pos] = id[e];
else
seg[pos] = seg[d], id[pos] = id[d];
lz[pos] = 0;
}
void update(int pos, int ini, int fim, int p, int q, long long val) {
refresh(pos, ini, fim);
if (ini > q || fim < p) return;
if (ini >= p && fim <= q) {
lz[pos] += val;
refresh(pos, ini, fim);
return;
}
int mid = (ini + fim) >> 1, e = pos << 1, d = e | 1;
update(e, ini, mid, p, q, val);
update(d, mid + 1, fim, p, q, val);
if (seg[e] <= seg[d])
seg[pos] = seg[e], id[pos] = id[e];
else
seg[pos] = seg[d], id[pos] = id[d];
lz[pos] = 0;
}
void getComp(int cur) {
marc[cur] = 1;
build(1, 1, n);
for (int i = 0; i < ar[cur].size(); i++)
update(1, 1, n, ar[cur][i], ar[cur][i], INF + 1);
int cnt = 1;
while (1) {
if (seg[1] > 0) break;
int viz = id[1];
cnt++;
marc[viz] = 1;
for (int i = 0; i < ar[viz].size(); i++)
update(1, 1, n, ar[viz][i], ar[viz][i], 1);
update(1, 1, n, 1, n, -1);
update(1, 1, n, viz, viz, 3 * INF);
}
ans.push_back(cnt);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct lwn {
int value, key, id;
} sta[300050];
int cnt[1000050];
int s[300050];
int maxa[300050];
int a[300050], m, i, j, k, n;
long long ans;
void solve(int l, int r) {
if (l == r) return;
solve(l, ((l + r) >> 1));
solve(((l + r) >> 1) + 1, r);
s[((l + r) >> 1)] = a[((l + r) >> 1)] % m;
maxa[((l + r) >> 1)] = a[((l + r) >> 1)];
s[((l + r) >> 1) + 1] = a[((l + r) >> 1) + 1] % m;
maxa[((l + r) >> 1) + 1] = a[((l + r) >> 1) + 1];
for (i = ((l + r) >> 1) - 1; i >= l; i--) {
s[i] = (s[i + 1] + a[i]) % m;
maxa[i] = max(maxa[i + 1], a[i]);
}
for (i = ((l + r) >> 1) + 2; i <= r; i++) {
s[i] = (s[i - 1] + a[i]) % m;
maxa[i] = max(maxa[i - 1], a[i]);
}
k = 0;
for (i = ((l + r) >> 1), j = ((l + r) >> 1) + 1; i >= l && j <= r;) {
for (; i >= l && maxa[i] <= maxa[j]; i--) {
sta[++k].key = maxa[i];
sta[k].value = s[i];
sta[k].id = i;
}
for (; j <= r && maxa[i] > maxa[j]; j++) {
sta[++k].key = maxa[j];
sta[k].value = s[j];
sta[k].id = j;
}
}
for (; i >= l; i--) {
sta[++k].key = maxa[i];
sta[k].value = s[i];
sta[k].id = i;
}
for (; j <= r; j++) {
sta[++k].key = maxa[j];
sta[k].value = s[j];
sta[k].id = j;
}
for (i = 1; i <= k; i++)
if (sta[i].id > ((l + r) >> 1))
cnt[(m - sta[i].value) % m]++;
else
ans += cnt[(m + sta[i].value - sta[i].key % m) % m];
for (i = 1; i <= k; i++)
if (sta[i].id > ((l + r) >> 1)) cnt[(m - sta[i].value) % m]--;
for (i = k; i >= 1; i--)
if (sta[i].id > ((l + r) >> 1))
cnt[(m + sta[i].key - sta[i].value) % m]++;
else
ans += cnt[sta[i].value % m];
for (i = k; i >= 1; i--)
if (sta[i].id > ((l + r) >> 1)) cnt[(m + sta[i].key - sta[i].value) % m]--;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
solve(1, n);
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105, INF = 0x3f3f3f3f, mod = 1000000007;
int a[maxn], fa[maxn], d[maxn], c[maxn];
inline int fnd(int x) { return x == fa[x] ? x : fa[x] = fnd(fa[x]); }
inline void jn(int a, int b) { fa[fnd(a)] = fnd(b); }
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", a + i);
fa[i] = i;
}
for (i = 1; i <= n; i++) {
scanf("%d", d + i);
if (i + d[i] <= n) jn(i, i + d[i]);
if (i - d[i] > 0) jn(i, i - d[i]);
}
for (i = 1; i <= n; i++) {
if (fnd(i) == i) {
memset(c, 0, sizeof(c));
for (j = 1; j <= n; j++) {
if (fnd(j) == i) {
c[j]++;
c[a[j]]--;
}
}
for (j = 1; j <= n; j++) {
if (c[j]) break;
}
if (j <= n) break;
}
}
printf("%s\n", i <= n ? "NO" : "YES");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
unsigned long long a, b;
cin >> a >> b;
if (a - b & 1 || a < b) {
cout << -1;
return 0;
}
cout << (a - b) / 2 << " " << a - (a - b) / 2;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t, n, k, x, y, m;
cin >> t;
while (t--) {
cin >> n >> k;
cin >> x;
m = x;
k--;
while (k--) {
cin >> y;
m = max(m, (y - x) / 2 + 1);
x = y;
}
m = max(m, n - x + 1);
cout << m << "\n";
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.