solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int visit[1000] = {0};
void dfs(int i, int x[], int y[], int n) {
visit[i] = 1;
for (int j = 1; j <= n; j++) {
if (!visit[j] && (x[i] == x[j] || y[i] == y[j])) dfs(j, x, y, n);
}
}
int main() {
int n;
cin >> n;
int x[1000];
int y[1000];
int i, j;
for (i = 1; i <= n; i++) cin >> x[i] >> y[i];
int ans = 0;
for (i = 1; i <= n; i++) {
if (!visit[i]) {
dfs(i, x, y, n);
ans++;
}
}
cout << ans - 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 1000010;
using namespace std;
int a[N], b[N], pa[N], pb[N];
int main() {
multiset<int> st;
int n, c;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]), pa[a[i]] = i;
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
pb[b[i]] = i;
st.insert(i - pa[b[i]]);
}
for (int i = 0; i < n; i++) {
int s = n;
multiset<int>::iterator it = st.lower_bound(i);
if (st.end() != it) s = min(s, (*it) - i);
if (st.begin() != it) s = min(s, i - (*(--it)));
printf("%d\n", s);
st.erase(st.find(i - pa[b[i]]));
st.insert(n - pa[b[i]] + i);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<int> par;
int findSet(int u) {
if (u == par[u]) return u;
return par[u] = findSet(par[u]);
}
void unionSet(int u, int v) {
u = findSet(u);
v = findSet(v);
if (u != v) {
par[u] = v;
}
}
int minSwaps(vector<int> arr, int n, int k) {
for (int i = 0; i < n; i++) {
par[i] = i;
}
for (int i = 0; i < n; i++) {
unionSet((i - k + n) % n, arr[i]);
}
set<int> s;
for (int i = 0; i < n; i++) {
s.insert(findSet(i));
}
return n - (s.size());
}
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
par.assign(n + 1, 0);
for (int i = 0; i < n; i++) {
par[i] = i;
}
vector<int> arr(n), v;
for (int i = 0; i < n; i++) {
cin >> arr[i];
arr[i]--;
}
vector<int> inPos(n, 0);
for (int i = 0; i < n; i++) {
inPos[(i - arr[i] + n) % n]++;
}
for (int i = 0; i < n; i++) {
if (inPos[i] >= n - 2 * m && minSwaps(arr, n, i) <= m) {
v.push_back(i);
}
}
cout << v.size() << " ";
for (int i : v) {
cout << i << " ";
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int read() {
int tot=0,fh=1;char c=getchar();
while (c<'0'||c>'9') {if (c=='-') fh=-1;c=getchar();}
while (c>='0'&&c<='9') {tot=tot*10+c-'0';c=getchar();}
return tot*fh;
}
void getstr(char *a) {
char c=getchar();int len=0;
while (!((c>='A'&&c<='Z')||(c>='a'&&c<='z')||(c>='0'&&c<='9'))) c=getchar();
while ((c>='A'&&c<='Z')||(c>='a'&&c<='z')||(c>='0'&&c<='9')) {a[++len]=c;c=getchar();}
}
const int maxn=4040;
ll cnt,n;
int t,step,a[maxn];
int main() {
t=read();
while (t--) {
cin>>n;
if (n%2==1) {
cout<<-1<<endl;
continue;
}
cnt=2;n-=2;
a[step=1]=1;
while (n>0) {
if (cnt+2ll<=n) {
ll cur=cnt+2ll;
n-=cur;
cnt+=cur;
a[++step]=0;
} else {
cnt=2;
n-=cnt;
a[++step]=1;
}
}
cout<<step<<endl;
for (int i=1;i<=step;i++) cout<<a[i]<<" ";
cout<<endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100001];
int par[100001][31];
int hei[100001];
int n, q;
void dfs(int cur, int p, int h) {
hei[cur] = h;
for (int next : adj[cur]) {
if (next != p) {
par[next][0] = cur;
dfs(next, cur, h + 1);
}
}
}
void processLca() {
for (int i = 1; i < 31; i++) {
for (int j = 1; j <= n; j++) {
par[j][i] = par[par[j][i - 1]][i - 1];
}
}
}
int getLca(int x, int y) {
if (hei[x] > hei[y]) swap(x, y);
int d = hei[y] - hei[x];
for (int i = 30; i >= 0; i--) {
if (d & (1 << i)) y = par[y][i];
}
if (x == y) return x;
for (int i = 30; i >= 0; i--) {
if (par[x][i] != par[y][i]) {
x = par[x][i];
y = par[y][i];
}
}
return par[x][0];
}
int getdist(int x, int y) {
int lca = getLca(x, y);
return hei[x] + hei[y] - 2 * hei[lca];
}
int cntpath(int f, int s, int t) {
int lc1 = getLca(f, s);
int lc2 = getLca(f, t);
int k = 0;
if (lc1 == lc2) {
int lc3 = getLca(s, t);
k = getdist(lc3, lc1);
}
return k + min(getdist(lc1, f), getdist(lc2, f)) + 1;
}
int main(void) {
scanf("%d %d", &n, &q);
for (int i = 2; i <= n; i++) {
int t;
scanf("%d", &t);
adj[i].push_back(t);
adj[t].push_back(i);
}
dfs(1, -1, 0);
processLca();
for (int i = 0; i < q; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
printf("%d\n",
max(cntpath(a, b, c), max(cntpath(b, a, c), cntpath(c, a, b))));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<int> v, v1;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
v.push_back(c);
}
int coun = 0;
sort(v.begin(), v.end());
int sum = 0, dis = 0;
for (int i = 1; i < n; i++) {
sum += v[i - 1];
sum -= dis;
dis = 0;
if (sum > v[i]) {
v1.push_back(i + 1);
dis += v[i];
}
}
cout << n - v1.size();
}
| 2 |
#include <bits/stdc++.h>
using std::cerr;
using std::cin;
using std::max;
using std::min;
int n, a, b, mod, cntp, pri[100005], isp[100005], ans;
std::vector<int> S;
long long cal(long long x) {
x -= x < mod ? 0 : mod;
return x;
}
long long Pow(int x, int y) {
int res = 1;
for (; y; x = (long long)x * x % mod, y >>= 1)
if (y & 1) res = (long long)res * x % mod;
return res;
}
void doPrime(int x) {
for (int i = 2; i <= x; i++) {
if (!isp[i]) pri[++cntp] = i;
for (int j = i + i; j <= x; j += i) isp[j] = 1;
}
}
void exgcd(int a, int b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, x, y);
long long t = x;
x = y, y = t - a / b * y;
}
long long inverse(int v) {
long long x, y;
exgcd(v, mod, x, y);
return cal(x + mod);
}
struct info {
int cnt[100005], val;
void add(int x, int v) {
for (int i : S)
for (; x % pri[i] == 0; x /= pri[i], cnt[i] += v)
;
if (x > 1) val = (long long)val * (v > 0 ? x : inverse(x)) % mod;
}
long long ask() {
long long res = val;
if (!res) return res;
for (int i : S)
if (cnt[i]) res = res * Pow(pri[i], cnt[i]) % mod;
return res;
}
} A, B, C;
int main() {
scanf("%d%d%d%d", &n, &mod, &a, &b), doPrime((int)sqrt(mod));
int tmp = mod;
for (int i = 1; i <= cntp; i++)
if (tmp % pri[i] == 0) {
S.push_back(i);
for (; tmp % pri[i] == 0; tmp /= pri[i])
;
}
if (tmp > 1) pri[0] = tmp, S.push_back(0);
A.val = 1;
for (int i = 0, v1, v2; i <= n; i++) {
v1 = a + i + 1 >> 1, v2 = (b + i >> 1) + 1;
if (i >= v1 && i - 1 < (a + i >> 1)) {
B.val = 1;
for (int j = 1; j <= v1; j++) B.add(i - j + 1, 1), B.add(j, -1);
} else if (i >= v1) {
B.add(i, 1);
if (a + i & 1)
B.add(v1, -1);
else
B.add(i - v1, -1);
}
if (i >= v2 && i - 1 < (b + i - 1 >> 1) + 1) {
C.val = 1;
for (int j = 1; j <= v2; j++) C.add(i - j + 1, 1), C.add(j, -1);
} else if (i >= v2) {
C.add(i, 1);
if (b + i & 1)
C.add(i - v2, -1);
else
C.add(v2, -1);
}
ans = cal(ans + A.ask() * cal(B.ask() - C.ask() + mod) % mod);
if (i < n) A.add(n - i, 1), A.add(i + 1, -1);
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
void betee_o_bete_aaj_tin_karde_momos_milenge(){
ll n,k;cin>>n>>k;
string s ;cin>>s;
if(!k){
cout<<"YES"<<endl;return;
}
for(ll i=0;i<k;i++){
if(s[i]!=s[n-1-i]){
cout<<"NO"<<endl;
return;
}
}
ll pos;
if(n%2) pos=n/2;
else pos=n/2-1;
if(k>pos) cout<<"NO"<<endl;
else cout<<"YES"<<endl;
}
int main()
{
fast;
ll t=1;
cin>>t;
for(ll i=0;i<t;i++){
//cout<<"Testcase number "<<i+1<<" :"<<endl;
betee_o_bete_aaj_tin_karde_momos_milenge();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long find_max(long long n, long long k) {
long long mx = 1;
for (int i = 2; i <= min((long long)sqrt(n), k); ++i) {
if (n % i == 0) {
mx = max(mx, (long long)i);
if (n / i <= k) mx = max(mx, (n / i));
}
}
return mx;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
if (n <= k) {
cout << 1 << '\n';
continue;
}
long long ans = n / find_max(n, k);
cout << ans << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
#define NN 200010
using namespace std;
using INT = long long;
using pii = pair<int, int>;
int c[NN], a[NN], b[NN];
int dp[NN];
int n;
int main () {
#ifndef ONLINE_JUDGE
freopen("in.in", "r", stdin);
freopen("out.out", "w", stdout);
#endif
int q;
for(cin >> q; q --;) {
cin >> n;
for(int i=1; i<=n; i++) scanf("%d", c + i);
for(int i=1; i<=n; i++) scanf("%d", a + i);
for(int i=1; i<=n; i++) scanf("%d", b + i);
INT ans = 0, pre = c[2] + 1 + abs(a[2] - b[2]);
ans = max(ans, pre);
dp[2] = pre;
for(int i=3; i<=n; i++) {
if(a[i] == b[i]) {
pre = c[i] + 1;
dp[i] = pre;
ans = max(ans, pre); continue;
}
if(a[i] < b[i]) swap(a[i], b[i]);
pre = pre - (a[i] - b[i]) + c[i] + 1;
pre = max(pre, 1LL * c[i] + a[i] - b[i] + 1);
dp[i] = pre;
ans = max(ans, pre);
}
// for(int i=2; i<=n; i++) cout << i << " " << dp[i] << endl;
// continue;
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, q, year;
cin >> m >> n;
string ans;
vector<string> st(m + 1);
vector<string> tt(n + 1);
for (int i = 1; i <= m; i++) cin >> st[i];
for (int i = 1; i <= n; i++) cin >> tt[i];
cin >> q;
while (q--) {
cin >> year;
int i1 = year % m, i2 = year % n;
if (i1 == 0) i1 = m;
if (i2 == 0) i2 = n;
ans = st[i1] + tt[i2];
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int from, to, index;
long long cap, flow;
Edge(int from, int to, long long cap, long long flow, int index)
: from(from), to(to), index(index), cap(cap), flow(flow) {}
};
struct Dinic {
int N;
vector<vector<Edge>> G;
vector<Edge *> dad;
vector<int> Q;
Dinic(int N) : N(N), G(N), dad(N), Q(N) {}
void AddEdge(int from, int to, long long cap) {
G[from].push_back(Edge(from, to, cap, 0, G[to].size()));
if (from == to) G[from].back().index++;
G[to].push_back(Edge(to, from, 0, 0, G[from].size() - 1));
}
long long BlockingFlow(int s, int t) {
fill(dad.begin(), dad.end(), nullptr);
dad[s] = &G[0][0] - 1;
int head = 0, tail = 0;
Q[tail++] = s;
while (head < tail) {
int x = Q[head++];
for (int i = 0; i < G[x].size(); i++) {
Edge &e = G[x][i];
if (!dad[e.to] && e.cap - e.flow > 0) {
dad[e.to] = &G[x][i];
Q[tail++] = e.to;
}
}
}
if (!dad[t]) return 0;
long long totflow = 0;
for (int i = 0; i < G[t].size(); i++) {
Edge *start = &G[G[t][i].to][G[t][i].index];
long long amt = 1e18;
for (Edge *e = start; amt && e != dad[s]; e = dad[e->from]) {
if (!e) {
amt = 0;
break;
}
amt = min(amt, e->cap - e->flow);
}
if (amt == 0) continue;
for (Edge *e = start; amt && e != dad[s]; e = dad[e->from]) {
e->flow += amt;
G[e->to][e->index].flow -= amt;
}
totflow += amt;
}
return totflow;
}
long long GetMaxFlow(int s, int t) {
long long totflow = 0;
while (long long flow = BlockingFlow(s, t)) totflow += flow;
return totflow;
}
};
int n, m, k, s, b;
int d[100][100];
int sa[100000];
long long sp[100000], sbest[100000];
vector<int> rs[100];
map<int, long long> gold[100];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) d[i][j] = -1;
for (int i = 0; i < n; ++i) d[i][i] = 0;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
if (d[u][v] == -1) d[u][v] = d[v][u] = 1;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k) {
if (d[j][i] == -1 || d[i][k] == -1) continue;
d[j][k] = min(d[j][k] == -1 ? (int)1e9 : d[j][k], d[j][i] + d[i][k]);
}
}
cin >> s >> b >> k;
for (int i = 0; i < s; ++i) {
int sx, sf;
cin >> sx >> sa[i] >> sf >> sp[i];
sx--;
sbest[i] = -1e18;
for (int j = 0; j < n; ++j) {
if (d[sx][j] != -1 && sf >= d[sx][j]) rs[j].push_back(i);
}
}
for (int i = 0; i < b; ++i) {
int bx, bd, bg;
cin >> bx >> bd >> bg;
bx--;
gold[bx][bd] = max(gold[bx][bd], (long long)bg);
}
for (int i = 0; i < n; ++i) {
vector<pair<int, long long>> v;
for (auto it : gold[i])
v.push_back({it.first, max(v.empty() ? 0 : v.back().second, it.second)});
sort(rs[i].begin(), rs[i].end(),
[](int a, int b) { return sa[a] < sa[b]; });
int j = 0;
for (int k = 0; k < v.size(); ++k) {
while (j < rs[i].size() && sa[rs[i][j]] < v[k].first) j++;
while (j < rs[i].size() &&
(k == v.size() - 1 || sa[rs[i][j]] < v[k + 1].first)) {
sbest[rs[i][j]] = max(sbest[rs[i][j]], v[k].second - sp[rs[i][j]]);
j++;
}
}
}
long long res = 0;
for (int i = 0; i < s; ++i)
if (sbest[i] >= 0) res += sbest[i];
Dinic dinic(s + 2);
for (int i = 0; i < s; ++i) {
if (sbest[i] >= 0)
dinic.AddEdge(0, i + 2, sbest[i]);
else
dinic.AddEdge(i + 2, 1, -sbest[i]);
}
for (int i = 0; i < k; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
dinic.AddEdge(u + 2, v + 2, 1e18);
}
res -= dinic.GetMaxFlow(0, 1);
cout << res << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 5e5 + 5;
const int base = 300;
int n, m, t, ans, k, a[N], tong, b[N], d[N];
pair<int, int> st[N * 4];
void build(int id, int l, int r) {
if (l == r) {
st[id].first = 0;
st[id].second = l;
return;
}
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid + 1, r);
st[id] = max(st[id * 2], st[id * 2 + 1]);
}
void update(int id, int l, int r, int pos, int val) {
if (l == r) {
st[id].first = val;
return;
}
int mid = (l + r) / 2;
if (mid >= pos)
update(id * 2, l, mid, pos, val);
else
update(id * 2 + 1, mid + 1, r, pos, val);
st[id] = max(st[id * 2], st[id * 2 + 1]);
}
pair<int, int> get(int id, int l, int r, int u, int v) {
if (u <= l && r <= v) return st[id];
if (u > r || l > v || u > v) return {-1, -1};
int mid = (l + r) / 2;
return max(get(id * 2, l, mid, u, v), get(id * 2 + 1, mid + 1, r, u, v));
}
void dfs(int u) {
if (get(1, 1, n, u, u).first == -1) return;
update(1, 1, n, u, -1);
if (b[u] <= n) dfs(b[u]);
while (true) {
pair<int, int> v = get(1, 1, n, 1, a[u] - 1);
if (v.first <= u) break;
dfs(v.second);
}
d[u] = ++t;
}
void sol() {
cin >> n;
fill_n(b, n + 2, n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > 0)
b[a[i]] = i;
else
a[i] = n + 1;
}
build(1, 1, n);
for (int i = 1; i <= n; i++) update(1, 1, n, i, b[i]);
for (int i = 1; i <= n; i++) {
if (get(1, 1, n, i, i).first >= 0) dfs(i);
}
for (int i = 1; i <= n; i++) cout << d[i] << " ";
}
int main() {
if (fopen("slingshot"
".in",
"r")) {
freopen(
"slingshot"
".in",
"r", stdin);
freopen(
"slingshot"
".out",
"w", stdout);
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ntest = 1;
while (ntest-- > 0) sol();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 10003;
vector<int> g[N];
long long a[N], b[N];
long long dp[3][N];
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, n, k, j;
int t;
t = 1;
long long c;
while (t--) {
cin >> n >> c;
for (i = 0; i < n; i++) cin >> b[n - i];
for (i = 0; i < n; i++) cin >> a[n - i];
dp[0][0] = 0;
for (i = 1; 1 < n + 1 ? i < n + 1 : i > n + 1; 1 < n + 1 ? i += 1 : i -= 1)
dp[0][i] = 1e15;
for (i = 1; 1 < n + 1 ? i < n + 1 : i > n + 1;
1 < n + 1 ? i += 1 : i -= 1) {
dp[(i - 1) & 1][i] = 1e15;
for (j = 0; 0 < i + 1 ? j < i + 1 : j > i + 1;
0 < i + 1 ? j += 1 : j -= 1) {
if (!j)
dp[i & 1][j] = dp[(i - 1) & 1][j] + a[i];
else
dp[i & 1][j] = min(dp[(i - 1) & 1][j - 1] + b[i],
dp[(i - 1) & 1][j] + a[i] + c * j);
}
}
long long ans = 1e15;
for (i = 0; i < n + 1; i++) ans = min(ans, dp[n & 1][i]);
cout << ans << endl;
}
return 0;
}
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % mod;
base = ((long long)base * base) % mod;
exp >>= 1;
}
return result;
}
void ipgraph(int n, int m) {
int i, u, v;
while (m--) {
cin >> u >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
}
void dfs(int u, int par) {
for (int v : g[u]) {
if (v == par) continue;
dfs(v, u);
}
}
| 10 |
#include <bits/stdc++.h>
int main() {
char s[100];
char c;
int n = 0;
while ((c = getchar()) != '\n') s[n++] = c;
while ((c = getchar()) != '\n')
if (s[--n] != c) {
printf("NO");
return 0;
}
printf("YES");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long N = 1e5 + 5;
void solve() {
string s;
cin >> s;
long long n = s.length();
string t[2];
for (auto ch : s) {
t[(ch - 'a') & 1].push_back(ch);
}
sort(t[0].begin(), t[0].end()), sort(t[1].begin(), t[1].end());
if (t[0].empty() or t[1].empty()) {
t[0].append(t[1]);
cout << t[0] << endl;
return;
}
if (abs(t[0].back() - t[1][0]) != 1) {
t[0].append(t[1]);
cout << t[0] << endl;
return;
} else if (abs(t[1].back() - t[0][0]) != 1) {
t[1].append(t[0]);
cout << t[1] << endl;
return;
}
cout << "No answer\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tt;
cin >> tt;
while (tt--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gi() {
char cc = getchar();
long long cn = 0, flus = 1;
while (cc < '0' || cc > '9') {
if (cc == '-') flus = -flus;
cc = getchar();
}
while (cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
const long long N = 3e5 + 5;
const long long inf = 1e9 + 7;
long long n, a[N], Mi[N << 2], sum[N << 2], mark[N << 2], st1[N], top1, st2[N],
top2, mx[N], mi[N];
void pushup(long long x) {
Mi[x] = min(Mi[(x << 1)], Mi[(x << 1 | 1)]), sum[x] = 0;
if (Mi[x] == Mi[(x << 1)]) sum[x] += sum[(x << 1)];
if (Mi[x] == Mi[(x << 1 | 1)]) sum[x] += sum[(x << 1 | 1)];
}
void pushmark(long long x) {
if (!mark[x]) return;
mark[(x << 1)] += mark[x], mark[(x << 1 | 1)] += mark[x],
Mi[(x << 1)] += mark[x], Mi[(x << 1 | 1)] += mark[x], mark[x] = 0;
}
void update(long long x, long long l, long long r, long long ql, long long qr,
long long k) {
if (qr < l || r < ql) return;
if (ql <= l && r <= qr) {
Mi[x] += k, mark[x] += k;
return;
}
long long mid = (l + r) >> 1;
pushmark(x);
update((x << 1), l, mid, ql, qr, k),
update((x << 1 | 1), mid + 1, r, ql, qr, k), pushup(x);
}
void build(long long x, long long l, long long r) {
Mi[x] = inf, sum[x] = 0;
if (l == r) return;
long long mid = (l + r) >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r);
}
void change(long long x, long long l, long long r, long long w, long long k) {
if (l == r) {
Mi[x] = 0, mark[x] = 0, sum[x] = 1;
return;
}
long long mid = (l + r) >> 1;
pushmark(x);
if (mid >= w)
change((x << 1), l, mid, w, k);
else
change((x << 1 | 1), mid + 1, r, w, k);
pushup(x);
}
signed main() {
n = gi();
long long x, Ans = 0, fl;
for (register long long i = (1); i <= (n); ++i) x = gi(), a[x] = gi();
build(1, 1, n), memset(mi, 63, sizeof(mi));
for (register long long i = (1); i <= (n); ++i) {
if (i > 1) update(1, 1, n, 1, i - 1, -1);
change(1, 1, n, i, 0);
fl = 0;
while (top1 && a[i] > mx[st1[top1]])
update(1, 1, n, st1[top1], i - 1, a[i] - mx[st1[top1]]), --top1, fl = 1;
(fl) ? ++top1, mx[st1[top1]] = a[i] : st1[++top1] = i, mx[i] = a[i];
fl = 0;
while (top2 && a[i] < mi[st2[top2]])
update(1, 1, n, st2[top2], i - 1, mi[st2[top2]] - a[i]), --top2, fl = 1;
(fl) ? ++top2, mi[st2[top2]] = a[i] : st2[++top2] = i, mi[i] = a[i];
Ans += sum[1];
}
printf("%lld\n", Ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void fit(vector<int> &C, int pos, int val, int n1) {
pos += n1;
C[pos] = val;
pos /= 2;
while (pos >= 1) {
C[pos] = C[2 * pos] + C[2 * pos + 1];
pos /= 2;
}
}
int findfit(vector<int> &C, int pos1, int pos2, int n1) {
pos1 += n1, pos2 += n1;
int ans = 0;
while (pos1 <= pos2) {
if (pos1 % 2 == 1) ans += C[pos1++];
if (pos2 % 2 == 0) ans += C[pos2--];
pos1 /= 2, pos2 /= 2;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
long long ans = 1;
cin >> n >> m;
set<array<int, 3>> A, B;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
A.insert({a, b, c});
}
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
if (b == 0 && c == 1e6) ans++;
B.insert({b, c, a});
}
int n1 = 1e6 + 1;
vector<int> C(3 * n1 + 10, 0);
fit(C, 1, 1, n1);
fit(C, 1e6 + 1, 1, n1);
multiset<pair<int, int>> D;
for (int h = 0; h < 1e6; h++) {
while (B.size() && (*(B.begin()))[0] == h) {
auto u = *(B.begin());
fit(C, u[2] + 1, 1, n1);
D.insert({u[1], u[2]});
B.erase(B.begin());
}
if (A.size() && (*(A.begin()))[0] == h) {
auto u = *(A.begin());
ans = ans + max(0, findfit(C, u[1] + 1, u[2] + 1, n1) - 1);
A.erase(A.begin());
}
while (D.size() && (*(D.begin())).first == h) {
int y = (*(D.begin())).second;
fit(C, y + 1, 0, n1);
D.erase(D.begin());
}
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int query = 0; query < q; query++) {
long long n, m;
cin >> n >> m;
long long s = 0;
int divs[11];
int div_sum = 0;
for (int i = 0; i < 10; i++) {
divs[i] = (m * i) % 10;
div_sum += divs[i];
}
long long p = n / m;
s += (p / 10) * div_sum;
for (int i = 1; i <= p % 10; i++) s += divs[i];
cout << s << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int N = 1e3 + 5;
const int M = 1e5 + 5;
const long long MOD = 1e9 + 7;
const long long P = 29;
int t;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<int> g[N], v[N];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x;
cin >> x;
g[i].push_back(x);
}
}
int ind;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int x;
cin >> x;
v[i].push_back(x);
if (v[i][j] == g[0][0]) ind = i;
}
}
for (int i = 0; i < n; i++) {
if (g[i][0] != v[ind][i]) {
for (int j = 0; j < n; j++) {
if (g[j][0] == v[ind][i]) {
swap(g[i], g[j]);
break;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j != m - 1)
cout << g[i][j] << ' ';
else
cout << g[i][j];
}
cout << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int NN = 1 << 20;
int qpow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = (long long)ret * a % mod;
a = (long long)a * a % mod;
b >>= 1;
}
return ret;
}
namespace NTT {
const int g = 3;
int x[NN << 2], y[NN << 2], wn[NN << 2];
void init() {
for (int i = 0; i <= 20; i++) wn[i] = qpow(g, (mod - 1) / (1 << i));
}
void brc(int *F, int len) {
int j = len / 2;
for (int i = 1; i <= len - 2; i++) {
if (i < j) swap(F[i], F[j]);
int k = len / 2;
while (j >= k) j -= k, k >>= 1;
if (j < k) j += k;
}
}
void NTT(int *F, int len, int t) {
int id = 0;
brc(F, len);
for (int h = 2; h <= len; h <<= 1) {
id++;
for (int j = 0; j < len; j += h) {
int E = 1;
for (int k = j; k < j + h / 2; k++) {
int u = F[k], v = (long long)E * F[k + h / 2] % mod;
F[k] = (u + v) % mod, F[k + h / 2] = ((u - v) % mod + mod) % mod;
E = (long long)E * wn[id] % mod;
}
}
}
if (t == -1) {
for (int i = 1; i <= len / 2 - 1; i++) swap(F[i], F[len - i]);
long long inv = qpow(len, mod - 2);
for (int i = 0; i <= len - 1; i++) F[i] = (long long)F[i] % mod * inv % mod;
}
}
} // namespace NTT
int a[NN], n, k;
int main() {
NTT::init();
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
a[x] = 1;
}
NTT::NTT(a, 1 << 20, 1);
for (int i = 0; i < (1 << 20); i++) a[i] = qpow(a[i], n / 2);
NTT::NTT(a, 1 << 20, -1);
int ans = 0;
for (int i = 0; i <= 9 * n / 2; i++) ans = (ans + 1ll * a[i] * a[i]) % mod;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long t[3000000];
long long t1[3000000];
long long dp[3000000][5];
vector<long long> v;
long long n, m, k, l, r, nb, q;
map<long long, int> mapp;
void debug(long long* tab, int len) {
cout << "debug :::: \n";
for (int i = 0; i < len; i++) cout << tab[i] << " ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin >> nb;
string s1, s2;
while (nb--) {
cin >> s1;
cin >> s2;
n = s1.length();
m = s2.length();
int a, b;
for (int i = m - 1; i >= 0; i--)
if (s2[i] - '0') {
b = m - i - 1;
break;
}
int cnt = 0;
for (int i = n - b - 1; i >= 0; i--) {
if (s1[i] == '1') break;
cnt++;
}
cout << cnt << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int chkmax(T& a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int chkmin(T& a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class iterator>
void output(iterator begin, iterator end, ostream& out = cerr) {
while (begin != end) {
out << (*begin) << " ";
begin++;
}
out << endl;
}
template <class T>
void output(T x, ostream& out = cerr) {
output(x.begin(), x.end(), out);
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
struct line {
long long k, b, id;
};
const long long INF = 1e18;
const long double EPS = 1e-9;
long long intersect(line l1, line l2) {
long double x = -(long double)(l1.b - l2.b) / (long double)(l1.k - l2.k);
long long x1 = (long long)(x + EPS);
if (l1.k * x1 + l1.b == l2.k * x1 + l2.b && l1.id > l2.id) {
x1--;
}
return x1;
}
struct cht {
vector<pair<long long, line> > st;
void add_line(line l) {
while (!st.empty()) {
long long x = intersect(l, st.back().second);
if (x > st.back().first) {
st.pop_back();
} else {
break;
}
}
long long x = INF;
if (!st.empty()) {
x = intersect(l, st.back().second);
}
st.push_back({x, l});
}
pair<int, long long> get(long long x) {
int l = 0, r = (int)st.size() - 1;
while (l < r) {
int mid = (l + r) >> 1;
if (st[mid + 1].first >= x) {
l = mid + 1;
} else {
r = mid;
}
}
return {st[l].second.id, st[l].second.k * x + st[l].second.b};
}
void clear() { st.clear(); }
};
long long n, l, r, sum_s, sum_b;
int m;
vector<long long> v;
cht T;
signed main() {
fast_io();
cin >> n >> m;
v.push_back(0);
T.add_line({0, 0, 0});
r = n - 1;
for (int i = 0; i < m; ++i) {
int type;
cin >> type;
if (type == 1) {
long long len;
cin >> len;
l -= len;
v = {l};
T.clear();
sum_s = 0;
sum_b = 0;
T.add_line({0, 0, l});
}
if (type == 2) {
long long len;
cin >> len;
long long pos = r + 1;
T.add_line({pos - l, -sum_b - sum_s * (pos - l), pos});
r += len;
}
if (type == 3) {
long long b, s;
cin >> b >> s;
sum_b += b;
sum_s += s;
}
auto pp = T.get(sum_s);
cout << (pp.first - l) + 1 << " " << pp.second + sum_b << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> counts(100001, 0);
int mx = -1;
while (n--) {
int x;
cin >> x;
counts[x]++;
mx = max(mx, x);
}
vector<long long> dp(mx + 1, 0);
dp[0] = 0;
dp[1] = counts[1];
for (int i = 2; i <= mx; i++) {
dp[i] = max(dp[i - 1], counts[i] * i + dp[i - 2]);
}
cout << dp[mx] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, p;
bool operator<(const node& _) const { return x < _.x; }
} A[200005];
int R[200005];
int main() {
int d, n, m;
scanf("%d%d%d", &d, &n, &m);
for (int i = (1), i_END = (m); i <= i_END; i++)
scanf("%d%d", &A[i].x, &A[i].p);
sort(A + 1, A + m + 1);
A[++m] = (node){d, 0};
R[m] = m;
for (int i = (m - 1), i_END = (1); i >= i_END; i--) {
int now = i;
while (A[now + 1].p > A[i].p && now + 1 <= m) now = R[now + 1];
R[i] = now;
}
for (int i = (1), i_END = (m); i <= i_END; i++) R[i] = min(m, R[i] + 1);
long long ans = 0;
int now = n, pos = 0;
for (int i = (1), i_END = (m); i <= i_END; i++) {
int nxt = R[i];
now -= (A[i].x - pos);
if (now < 0) {
puts("-1");
return 0;
}
if (i == m) break;
pos = A[i].x;
if ((A[nxt].x - A[i].x) > now) {
if (A[nxt].x - A[i].x > n) {
ans += 1ll * (n - now) * A[i].p;
now = n;
} else {
ans += 1ll * ((A[nxt].x - A[i].x) - now) * A[i].p;
now = A[nxt].x - A[i].x;
now -= A[nxt - 1].x - A[i].x;
i = nxt - 1;
pos = A[nxt - 1].x;
}
} else {
now -= (A[nxt - 1].x - A[i].x);
i = nxt - 1;
pos = A[i].x;
}
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b;
cin >> a >> b;
int ans = a;
while (a >= b) {
int t = a / b;
ans += t;
a = t + (a - b * t);
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(const T &a) {
return a * a;
}
const int turn4[2][4][2] = {{{0, 1}, {0, -1}, {1, 0}, {-1, 0}},
{{1, 1}, {-1, 1}, {1, -1}, {-1, -1}}};
const int turn8[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
const int dir[2][4] = {{1, 0, 0, 1}, {1, 1, -1, 1}};
char a[1000][1000];
int n, m;
inline int isOk(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && a[x][y] == '1';
}
inline int check(int x, int y, int type, int corner) {
if (a[x][y] != '1') return 0;
if (type == 0) {
if (corner == 1)
return isOk(x, y + 1);
else
return isOk(x + 1, y);
} else {
if (corner == 1)
return isOk(x - 1, y + 1);
else
return isOk(x + 1, y + 1);
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d ", &n, &m);
for (int i = 0; i < (n); i++) gets(a[i]);
int ans = 0;
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (m); j++) {
for (int type = 0; type < (2); type++) {
if (a[i][j] == '0') continue;
vector<pair<int, int> > cells, corners;
int lenX = 1;
int ok = 0;
int x = i + dir[type][0], y = j + dir[type][1];
corners.push_back({i, j});
while (x >= 0 && y >= 0 && x < n && y < m) {
if (a[x][y] != '1') {
ok = 0;
break;
}
if (check(x, y, type, 1)) {
ok = 1;
break;
}
cells.push_back(make_pair(x, y));
x += dir[type][0], y += dir[type][1];
lenX++;
}
if (!ok) continue;
corners.push_back({x, y});
x = i + dir[type][2], y = j + dir[type][3];
int lenY = 1;
ok = 0;
while (x >= 0 && y >= 0 && x < n && y < m) {
if (a[x][y] != '1') {
ok = 0;
break;
}
if (check(x, y, type, 2)) {
ok = 1;
break;
}
cells.push_back(make_pair(x, y));
x += dir[type][2], y += dir[type][3];
lenY++;
}
if (!ok || lenX != lenY) continue;
corners.push_back({x, y});
x = i + (dir[type][0] + dir[type][2]) * lenX,
y = j + (dir[type][1] + dir[type][3]) * lenX;
for (int k = 0; k < (lenX); k++) {
if (a[x][y] != '1') ok = 0;
cells.push_back(make_pair(x, y));
x -= dir[type][0], y -= dir[type][1];
}
x = i + (dir[type][0] + dir[type][2]) * (lenX),
y = j + (dir[type][1] + dir[type][3]) * (lenX);
corners.push_back({x, y});
for (int k = 0; k < (lenX); k++) {
if (a[x][y] != '1') ok = 0;
cells.push_back(make_pair(x, y));
x -= dir[type][2], y -= dir[type][3];
}
if (!ok) continue;
ok = 1;
for (pair<int, int> cell : cells) {
int cnt = 0;
for (int dir4 = 0; dir4 < (4); dir4++) {
x = cell.first + turn4[type][dir4][0],
y = cell.second + turn4[type][dir4][1];
if (x >= 0 && y >= 0 && x < n && y < m) cnt += a[x][y] == '1';
}
if (lenX > 1 && type) {
for (int dir4 = 0; dir4 < (4); dir4++) {
x = cell.first + turn4[1 - type][dir4][0],
y = cell.second + turn4[1 - type][dir4][1];
if (x >= 0 && y >= 0 && x < n && y < m) cnt += a[x][y] == '1';
}
}
if (cnt != 2) ok = 0;
}
for (pair<int, int> cell : corners) {
int cnt = 0;
for (int dir8 = 0; dir8 < (8); dir8++) {
x = cell.first + turn8[dir8][0], y = cell.second + turn8[dir8][1];
if (x >= 0 && y >= 0 && x < n && y < m) cnt += a[x][y] == '1';
}
if (cnt != 2 + (type == 0 && lenX == 1)) ok = 0;
}
if (lenX && ok) ans++;
}
}
}
printf("%d\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 194598;
const int qmax = 1049658;
const int valmax = 5032107;
const int distmax = 8;
const int ansmax = 16;
struct Query {
int stanga, indice;
};
int n, q;
int v[1 + nmax];
vector<Query> query[1 + nmax];
int best[1 + ansmax];
int dp[1 + valmax][1 + distmax];
vector<int> divs;
vector<int> nrFact;
int rasp[1 + qmax];
void citire() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
for (int i = 1; i <= q; i++) {
int st, dr;
cin >> st >> dr;
query[dr].push_back({st, i});
}
}
vector<int> descompunere(int x) {
vector<int> fact;
int d = 2, e, lim = sqrt(x);
while (d <= lim && x > 1) {
e = 0;
while (x % d == 0) {
e++;
x /= d;
}
if (e % 2 == 1) {
fact.push_back(d);
}
d++;
}
if (x > 1) {
fact.push_back(x);
}
return fact;
}
int divizori(int x) {
vector<int> fact = descompunere(x);
divs.clear();
nrFact.clear();
divs.push_back(1);
nrFact.push_back(1);
for (int mask = 1; mask < (1 << fact.size()); mask++) {
int cnt = 1, val = 1;
for (int k = 0; k < fact.size(); ++k) {
if (mask & (1 << k)) {
cnt++;
val *= fact[k];
}
}
divs.push_back(val);
nrFact.push_back(cnt);
}
return 1 + fact.size();
}
void solve() {
for (int i = 1; i <= n; i++) {
int nrTotalFactori = divizori(v[i]);
for (int d = 0; d < divs.size(); d++) {
int gcd = divs[d], dist = nrTotalFactori - nrFact[d];
for (int k = 0; k <= distmax; k++) {
best[k + dist] = max(best[k + dist], dp[gcd][k]);
}
dp[gcd][dist] = i;
}
for (int j = 0; j < query[i].size(); j++) {
for (int rez = 0; rez <= ansmax; rez++) {
if (query[i][j].stanga <= best[rez]) {
rasp[query[i][j].indice] = rez;
break;
}
}
}
}
}
void afis() {
for (int i = 1; i <= q; i++) {
cout << rasp[i] << '\n';
}
}
int main() {
citire();
solve();
afis();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool boys[100], girls[100];
int main() {
int n, m;
cin >> n >> m;
int b;
cin >> b;
int temp;
for (int i = 0; i < b; i++) {
cin >> temp;
boys[temp] = true;
}
int g;
cin >> g;
for (int i = 0; i < g; i++) {
cin >> temp;
girls[temp] = true;
}
for (int i = 0; i < n * m + 5000; i++) {
if (girls[i % m] || boys[i % n]) {
girls[i % m] = true;
boys[i % n] = true;
}
}
for (int i = 0; i < n; i++) {
if (!boys[i]) {
cout << "No" << endl;
return 0;
}
}
for (int i = 0; i < m; i++) {
if (!girls[i]) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
}
| 11 |
#include <bits/stdc++.h>
int main() {
double n, k, l, c, d, p, nl, np, a, b, e;
while (scanf("%lf %lf %lf %lf %lf %lf %lf %lf", &n, &k, &l, &c, &d, &p, &nl,
&np) == 8) {
a = ((k * l) / nl) / n;
b = (c * d) / n;
e = (p / np) / n;
if (a <= b && a <= e)
printf("%0.0lf\n", floor(a));
else if (b <= a && b <= e)
printf("%0.0lf\n", floor(b));
else if (e <= b && e <= a)
printf("%0.0lf\n", floor(e));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct re {
int x, w;
const bool operator<(const re &a) const { return w < a.w; }
};
const int M = 1000000000 + 7;
const int N = 200000 + 10;
const int MAX_POSSIBILITES = 50;
int n, m, k, deg[N];
vector<re> e[N];
vector<re> possibilities;
int location[10][10];
int invalid[10][10];
int cntPossibilities;
long long sumBitMask[N];
long long bitmask[MAX_POSSIBILITES];
int cal(int x, long long mask) {
if (x == k + 1) return 1;
int res = 0;
for (int i = (1); (i <= (x)); ++i) {
if (!invalid[i][x] && (mask & (1LL << location[i][x]))) {
res += cal(x + 1, (mask & bitmask[location[i][x]]));
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = (1); (i <= (m)); ++i) {
int u, v, w;
cin >> u >> v >> w;
e[u].push_back({v, w});
}
for (int i = (1); (i <= (k)); ++i) {
for (int j = (1); (j <= (i)); ++j) {
possibilities.push_back({j, i});
location[j][i] = (int)possibilities.size() - 1;
}
}
cntPossibilities = possibilities.size();
for (int i = (0); (i <= (cntPossibilities - 1)); ++i) {
bitmask[i] = (1LL << cntPossibilities) - 1;
}
for (int i = (1); (i <= (n)); ++i) {
deg[i] = e[i].size();
sort(e[i].begin(), e[i].end());
for (int j = (0); (j <= (deg[i] - 1)); ++j) {
if (sumBitMask[e[i][j].x] & (1LL << location[j + 1][deg[i]])) {
invalid[j + 1][deg[i]] = 1;
}
sumBitMask[e[i][j].x] |= (1LL << location[j + 1][deg[i]]);
}
}
for (int i = (1); (i <= (n)); ++i) {
for (int j = (0); (j <= (cntPossibilities - 1)); ++j)
if (sumBitMask[i] & (1LL << j)) {
bitmask[j] &= ~(sumBitMask[i] & ~(1LL << j));
}
}
int res = cal(1, (1LL << cntPossibilities) - 1);
cout << res;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000007;
string s;
int main() {
int n, a, b;
cin >> n >> a >> b;
cin >> s;
int ta = a, tb = b;
for (int i = 0; i < n; i++) {
if (s[i] == '*') {
continue;
}
int j = i;
while (s[j] == '.') {
j++;
}
int t = j - i;
if (t % 2 == 0) {
a -= (t / 2);
b -= (t / 2);
} else {
a -= (t / 2);
b -= (t / 2);
if (a > b) {
a -= 1;
} else {
b -= 1;
}
}
i = j;
}
if (a <= 0 && b <= 0) {
cout << ta + tb << endl;
} else if (a > 0 && b > 0) {
cout << (ta + tb) - a - b << endl;
} else if (a > 0 && b <= 0) {
cout << tb + (ta - a) << endl;
} else {
cout << ta + (tb - b) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s[0] == 's') {
long long ret = 0;
for (int i = 2; i < v.size(); i += 5) ret += v[i];
cout << ret << endl;
} else {
int x;
cin >> x;
if (s[0] == 'a')
v.insert(lower_bound(v.begin(), v.end(), x), x);
else
v.erase(lower_bound(v.begin(), v.end(), x));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename U, typename V>
void Min(U &a, const V &b) {
if (a > b) a = b;
}
template <typename U, typename V>
void Max(U &a, const V &b) {
if (a < b) a = b;
}
template <typename U, typename V>
void add(U &a, const V &b) {
a = (a + b) % 998244353;
}
template <typename U>
U gcd(U a, U b) {
if (a == 0) return b;
if (b == 0) return a;
if (a >= b)
return gcd(a % b, b);
else
return gcd(a, b % a);
}
int pow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = 1LL * ans * a % 998244353;
a = 1LL * a * a % 998244353;
b >>= 1;
}
return ans;
}
int pow(int a, long long b, int c) {
int ans = 1;
while (b) {
if (b & 1) ans = 1LL * ans * a % c;
a = 1LL * a * a % c;
b >>= 1;
}
return ans;
}
char s[400005];
const int M = 14;
int t[1005][M], w[1005], fail[1005], sz;
void add(char s[], int v) {
int p = 0, j, n = strlen(s);
for (int i = 0; i < n; i++) {
j = s[i] - 'a';
if (!t[p][j]) {
t[p][j] = sz++;
}
p = t[p][j];
}
w[p] += v;
}
void build() {
queue<int> q;
for (int i = 0; i < M; i++)
if (t[0][i]) q.push(t[0][i]);
while (!q.empty()) {
int u = q.front();
q.pop();
int fa = fail[u], j;
w[u] += w[fa];
for (int i = 0; i < M; i++) {
j = t[u][i];
if (!j) {
t[u][i] = t[fa][i];
} else {
fail[j] = t[fa][i];
q.push(j);
}
}
}
}
long long dp[1 << M][1005], g[1005];
pair<int, long long> f[1005];
int main() {
int T, m, i, j, k, K, n;
scanf("%d", &n);
sz = 1;
for (int i = 0; i < n; i++) {
scanf("%s%d", s, &k);
add(s, k);
}
fail[0] = -1;
build();
w[0] = 0;
cerr << ("sz") << "=" << sz << "\n";
scanf("%s", s);
n = strlen(s);
m = 0;
int first, st;
const long long INF = 1LL << 60;
for (int first = 0; first < (1 << M); first++)
for (int second = 0; second < sz; second++) dp[first][second] = -INF;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '?') {
for (int j = (1 << M) - 1; j >= 0; j--)
if (__builtin_popcount(j) == m) {
for (int k = 0; k < sz; k++) {
long long &v = dp[j][k];
if (v < -INF) continue;
for (int l = 0; l < M; l++)
if (!(j >> l & 1)) {
first = t[k][l];
st = j | (1 << l);
Max(dp[st][first], v + w[first]);
}
}
}
m++;
} else {
j = i;
while (j < n && s[j] != '?') j++;
for (int k = 0; k < sz; k++) {
first = k;
long long v = 0;
for (int r = i; r < j; r++) first = t[first][s[r] - 'a'], v += w[first];
f[k] = {first, v};
}
for (int l = 0; l < (1 << M); l++)
if (__builtin_popcount(l) == m) {
for (int k = 0; k < sz; k++) g[k] = dp[l][k], dp[l][k] = -INF;
for (int k = 0; k < sz; k++)
Max(dp[l][f[k].first], g[k] + f[k].second);
}
i = j - 1;
}
}
long long ans = -INF;
for (int i = 0; i < (1 << M); i++)
if (__builtin_popcount(i) == m) {
for (int j = 0; j < sz; j++) Max(ans, dp[i][j]);
}
printf("%lld\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &f);
if (a == d || b == e || c == f)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, M, nr, T[100009], aib[100009], sum[100009], pos[100009], dr[100009],
niv[100009], sens[100009];
bool ap[100009];
vector<int> v[100009];
vector<int> ans[100009];
void dfs(int nod) {
pos[nod] = ++nr, ap[nod] = 1;
for (vector<int>::iterator it = v[nod].begin(); it != v[nod].end(); it++) {
if (ap[*it] == 0) {
T[*it] = nod, niv[*it] = niv[nod] + 1, dfs(*it);
sens[*it] = 0, sum[nod] ^= 1;
} else if (nod < *it && T[nod] != *it)
ans[nod].push_back(*it), sum[nod] ^= 1;
}
dr[nod] = nr;
}
void xor_path(int x, int y) { sens[x] ^= 1, sens[y] ^= 1; }
void all_mars(int nod) {
for (vector<int>::iterator it = v[nod].begin(); it != v[nod].end(); it++)
if (T[*it] == nod) all_mars(*it), sens[nod] ^= sens[*it];
}
void Print() {
for (int i = 1; i <= N; i++)
for (int j = 0; j + 1 < ans[i].size(); j += 2)
printf("%d %d %d\n", ans[i][j], i, ans[i][j + 1]);
}
int main() {
scanf("%d %d", &N, &M);
if (M & 1) {
printf("No solution\n");
return 0;
}
for (int i = 1; i <= M; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1);
int lst = 0;
for (int i = 1; i <= N; i++)
if (sum[i]) {
if (lst == 0) {
lst = i;
continue;
}
xor_path(i, lst), lst = 0;
}
all_mars(1);
for (int i = 2; i <= N; i++)
if (sens[i] == 0)
ans[T[i]].push_back(i);
else
ans[i].push_back(T[i]);
Print();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
int t[2][N];
long long s[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
long long a = 0, b = 0, x = 0, res;
cin >> n;
for (int i = 0; i < 2; i++) {
for (int j = 1; j <= n; j++) {
cin >> t[i][j];
}
}
for (int i = n; i > 0; i--) {
s[i] = s[i + 1] + t[0][i] + t[1][i];
}
for (int i = 1; i <= n; i++) {
b += a * t[0][i];
a++;
}
for (int i = n; i > 0; i--) {
b += a * t[1][i];
a++;
}
res = b;
a = 0;
for (int i = 2; i <= n; i += 2) {
b -= x + a * t[0][i - 1] + (a + 1) * t[0][i] +
(long long)1 * (n + n - 2) * t[1][i] +
(long long)1 * (n + n - 1) * t[1][i - 1];
b += s[i + 1] * 2;
x += a * t[0][i - 1];
x += (a + 1) * t[1][i - 1];
x += (a + 2) * t[1][i];
x += (a + 3) * t[0][i];
a += 4;
b += x;
if (b > res) res = b;
}
b = 0;
a = 1;
for (int i = 1; i <= n; i++) {
b += a * t[1][i];
a++;
}
for (int i = n; i > 1; i--) {
b += a * t[0][i];
a++;
}
if (b > res) res = b;
a = 2;
x = t[1][1];
for (int i = 3; i <= n; i += 2) {
b -= x + a * t[1][i - 1] + (a + 1) * t[1][i] +
(long long)1 * (n + n - 2) * t[0][i] +
(long long)1 * (n + n - 1) * t[0][i - 1];
b += s[i + 1] * 2;
x += a * t[1][i - 1];
x += (a + 1) * t[0][i - 1];
x += (a + 2) * t[0][i];
x += (a + 3) * t[1][i];
a += 4;
b += x;
if (b > res) res = b;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
scanf("%d", &n);
int s = 0;
int k = 1;
for (int i = 0; i < n - 1; ++i) {
s += k;
++k;
s %= n;
printf("%d ", (s + 1));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll sum(ll n)
{
ll s=0;
while(n>0)
{
s+= n%10;
n=n/10;
}
return s;
}
ll gcd(ll n, ll m )
{
ll k = n%m;
while(k!=0)
{
n=m;
m=k;
k= n%m;
}
return m;
}
ll gcdSum(ll n)
{
ll x = sum(n);
ll num =gcd(n,x);
while(num ==1)
{
n++;
if (n%10 !=0)
{
x++;
}
else
{
x-= 8;
}
num = gcd(n,x);
//cout<<n<<" "<<x<<" "<<num<<endl;
}
return n;
}
int main() {
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
//code
int t;
cin >> t;
while(t>0)
{
ll n,w;
cin >> n>>w;
map<ll,int> mp;
for(ll i=0;i<n;i++)
{
ll wi ;
cin >> wi;
mp[wi]++;
}
// for(auto x : mp)
// {
// cout<< x.first<<" "<<x.second<<endl;
// }
ll h=0;
map<ll,int> :: iterator it;
while(!mp.empty())
{
h++;
it = mp.end();
it--;
ll wirem =w;
//cout<<"hi"<<endl;
while(!mp.empty() && wirem>= mp.begin()->first )
{
if(wirem - it->first >=0)
{
wirem -= it->first;
it->second--;
if(it->second==0)
{
mp.erase(it->first);
if(mp.empty())
{
break;
}
it= mp.end();
it--;
}
}
else
{
it--;
}
}
// for(auto x : mp)
// {
// cout<< x.first<<" "<<x.second<<endl;
// }
// cout<<" "<<h<<endl;
}
cout<<h<<endl;
t--;
}
return 0;
} | 2 |
#include <bits/stdc++.h>
const int MaxN = 1 << 20;
using namespace std;
int n, m, num[40];
long long a[MaxN + 5], b[MaxN + 5];
int tot_a, tot_b;
long long Get(int s, int add) {
long long res = 0;
int now = 1;
while (s != 0) {
if (s & 1) res += num[now + add];
now++;
s /= 2;
}
return res;
}
void Init() {
tot_a = tot_b = 0;
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
int one = (n + 1) / 2, two = n - one;
for (int i = 0; i <= (1 << one) - 1; i++) {
long long x = Get(i, 0);
a[++tot_a] = x % m;
}
for (int i = 0; i <= (1 << two) - 1; i++) {
long long x = Get(i, one);
b[++tot_b] = x % m;
}
sort(a + 1, a + tot_a + 1);
sort(b + 1, b + tot_b + 1);
}
void Solve() {
int now = tot_b;
long long ans = 0;
for (int i = 1; i <= tot_a; i++) {
while (now > 1 && a[i] + b[now] >= m) now--;
ans = max(ans, max((a[i] + b[now]) % m, (a[i] + b[tot_b]) % m));
}
printf("%I64d\n", ans);
}
int main() {
while (~scanf("%d%d", &n, &m)) {
Init();
Solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[5][5];
pair<int, int> cost[5];
int n;
int main() {
cin >> n;
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= 4; j++) cin >> a[i][j];
for (int i = 1; i <= 4; i++) {
cost[i].first =
min(a[i][1] + a[i][3],
min(a[i][1] + a[i][4], min(a[i][2] + a[i][3], a[i][2] + a[i][4])));
cost[i].second = i;
}
sort(cost + 1, cost + 5);
if (cost[1].first > n)
cout << -1;
else {
cout << cost[1].second << " ";
int u = cost[1].second;
if (cost[1].first == a[u][1] + a[u][3])
cout << a[u][1] << " " << n - a[u][1];
else if (cost[1].first == a[u][1] + a[u][4])
cout << a[u][1] << " " << n - a[u][1];
else if (cost[1].first == a[u][2] + a[u][3])
cout << a[u][2] << " " << n - a[u][2];
else
cout << a[u][2] << " " << n - a[u][2];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string l, r;
long long f[16][16][1 << 16];
long long g[16][16], h[16][16][16];
void init() {
int m16 = (1 << 16) - 1;
for (int j = 0; j < 16; ++j) f[1][j][j] = 1;
for (int i = 1; i < 15; ++i) {
for (int j = 0; j < 16; ++j) {
for (int k = 0; k <= m16; ++k)
if (f[i][j][k]) {
for (int d = 0; d < 16; ++d) {
int s = i < 4 ? (d << (i * 4)) : 0;
f[i + 1][max(j, d)][k | s] += f[i][j][k];
}
}
}
}
for (int i = 1; i < 16; ++i) {
for (int j = 0; j < 16; ++j) {
for (int k = 0; k <= m16; ++k) {
g[i][j] += f[i][j][k];
for (int l = 0; l < 16; ++l)
if (k & (1 << l)) h[i][j][l] += f[i][j][k];
}
}
}
}
long long toInt(string x) {
long long rr = 0;
for (int i = 0; i < x.size(); ++i) {
rr = rr * 16 + (x[i] <= '9' ? x[i] - '0' : x[i] - 'a' + 10);
}
return rr;
}
vector<int> tmp, digits;
long long bruteforce(long long x) {
long long rr = 0;
for (int i = 1; i <= x; ++i) {
tmp.clear();
int v = 0;
int j = i;
while (j) {
v = max(v, j % 16);
j /= 16;
}
if (i & (1 << v)) ++rr;
}
return rr;
}
long long count2(int len, long long cur, int bitmax) {
if (len <= 0) return (cur & (1 << bitmax)) ? 1 : 0;
long long rr = 0;
for (int j = 0; j < 16; ++j) {
int k = max(j, bitmax), block = k / 4 + 1;
if (len >= block) {
rr += h[len][j][k];
} else if (cur & (1 << k))
rr += g[len][j];
}
return rr;
}
long long count(long long x) {
if (x <= 0) return 0;
tmp.clear();
while (x) {
tmp.push_back(x % 16);
x /= 16;
}
int n = tmp.size();
long long rr = 0, cur = 0;
int bitmax = -1;
for (int i = n; i; --i) {
for (int d = 0; d < tmp.back() + (i <= 1); ++d) {
int v = max(bitmax, d);
long long cmask = cur | ((1LL * d) << (4 * (i - 1)));
rr += count2(i - 1, cmask, v);
}
bitmax = max(bitmax, tmp.back());
cur |= ((1LL * tmp.back()) << (4 * (i - 1)));
tmp.pop_back();
}
return rr;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
init();
int q;
cin >> q;
while (q--) {
cin >> l >> r;
cout << count(toInt(r)) - count(toInt(l) - 1) << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1048576 + 10;
const unsigned long long mod = 998244353;
const int U = 1048576;
int rv[N];
unsigned long long rt[2][22];
int n;
char mde[N];
int T;
inline unsigned long long po(unsigned long long a, unsigned long long p) {
unsigned long long r = 1;
for (; p; p >>= 1, a = a * a % mod)
if (p & 1) r = r * a % mod;
return r;
}
inline void ntt(unsigned long long* a, int o, int len) {
for (int i = 0; i < len; i++)
if (i < rv[i]) swap(a[i], a[rv[i]]);
for (int k = 1, j = 1; k < len; k <<= 1, j++)
for (int s = 0; s < len; s += (k << 1))
for (int i = s, w = 1; i < s + k; i++, w = w * rt[o][j] % mod) {
unsigned long long a0 = a[i];
unsigned long long a1 = a[i + k] * w % mod;
a[i] = (a0 + a1) % mod, a[i + k] = (a0 + mod - a1) % mod;
}
if (o) {
unsigned long long inv = po(len, mod - 2);
for (int i = 0; i < len; i++) (a[i] *= inv) %= mod;
}
}
unsigned long long f1[N];
unsigned long long f2[N];
unsigned long long f3[N];
inline void solve() {
scanf("%d", &n);
scanf("%s", mde);
int d = 0;
int le = 1;
for (; le < (n << 1); le <<= 1, d++)
;
for (int i = 0; i < le; i++) rv[i] = (rv[i >> 1] >> 1) | ((i & 1) << (d - 1));
for (int i = 0; i < n; i++) f1[i] = (mde[i] == 'V');
for (int i = 0; i < n; i++) f2[i] = (mde[n - 1 - i] == 'K');
ntt(f1, 0, le);
ntt(f2, 0, le);
for (int i = 0; i < le; i++) (f1[i] *= f2[i]) %= mod;
ntt(f1, 1, le);
reverse(f1, f1 + n);
for (int i = 0; i < n; i++) f3[i] += f1[i];
for (int i = 0; i < le; i++) f1[i] = 0;
for (int i = 0; i < le; i++) f2[i] = 0;
for (int i = 0; i < n; i++) f1[i] = (mde[i] == 'K');
for (int i = 0; i < n; i++) f2[i] = (mde[n - i - 1] == 'V');
ntt(f1, 0, le);
ntt(f2, 0, le);
for (int i = 0; i < le; i++) (f1[i] *= f2[i]) %= mod;
ntt(f1, 1, le);
reverse(f1, f1 + n);
for (int i = 0; i < n; i++) f3[i] += f1[i];
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = 2 * i; j <= n; j += i)
if (f3[j] != 0) {
f3[i] = -1;
break;
}
for (int i = 1; i <= n; i++) cnt += (f3[i] == 0);
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (f3[i] == 0) printf("%d ", i);
printf("\n");
for (int i = 0; i <= n; i++) f3[i] = 0;
for (int i = 0; i < le; i++) f1[i] = 0;
for (int i = 0; i < le; i++) f2[i] = 0;
}
int main() {
for (int j = 1, t = (mod - 1) / 2; j <= 20; t >>= 1, j++) rt[0][j] = po(3, t);
for (int j = 1, t = (mod - 1) / 2; j <= 20; t >>= 1, j++)
rt[1][j] = po(332748118, t);
scanf("%d", &T);
for (int z = 1; z <= T; z++) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
int p[111111];
int vst[111111];
int len, last, st;
vector<int> adj[111111];
map<int, int> id, self_a, self_b;
void dfs(int u, int fa, int key) {
if (key >= 0) vst[u] = key;
len++, last = u;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
dfs(v, u, key);
}
}
void cycle(int u, int fa = 0) {
vst[u] = 0;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == fa) continue;
if (v == st) return;
cycle(v, u);
}
}
int main() {
int n, a, b;
gn(n, a, b);
memset(vst, -1, sizeof vst);
for (int i = 1; i <= n; i++) gn(p[i]), id[p[i]] = i;
if (a == b) {
for (int i = 1; i <= n; i++)
if (!id.count(a - p[i])) {
return puts("NO");
}
puts("YES");
while (n--) printsp(0);
return 0;
}
for (int i = 1; i <= n; i++) {
if (id.count(a - p[i])) {
if (a - p[i] == p[i])
self_a[i] = 1;
else
adj[i].push_back(id[a - p[i]]);
}
if (id.count(b - p[i])) {
if (b - p[i] == p[i])
self_b[i] = 1;
else
adj[i].push_back(id[b - p[i]]);
}
}
for (int i = 1; i <= n; i++)
if (adj[i].size() == 0 and !self_a.count(i) and !self_b.count(i))
return puts("NO");
for (int i = 1; i <= n; i++)
if (vst[i] == -1 and adj[i].size() == 1) {
len = 0, dfs(i, 0, -1);
if (len & 1) {
if (self_a.count(i) or self_a.count(last))
dfs(i, 0, 0);
else if (self_b.count(i) or self_b.count(last))
dfs(i, 0, 1);
else
return puts("NO");
} else {
if (p[i] + p[adj[i][0]] == a)
dfs(i, 0, 0);
else
dfs(i, 0, 1);
}
}
for (int i = 1; i <= n; i++)
if (vst[i] == -1 and adj[i].size() == 2) {
st = i, cycle(i);
}
for (int i = 1; i <= n; i++)
if (vst[i] == -1) {
if (self_a.count(i))
vst[i] = 0;
else
vst[i] = 1;
}
puts("YES");
for (int i = 1; i <= n; i++) printsp(vst[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const int INF = 1e9 + 10;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long l, r;
cin >> l >> r;
auto f = [](long long n) {
long long res = 0;
for (long long p = 1; n; n /= 10, p *= 10) {
res += p * (9 - n % 10);
}
return res;
};
long long res = max(f(l) * l, f(r) * r);
for (long long p = 1; 5 * p < r; p *= 10) {
if (5 * p > l) {
res = max(res, f(5 * p) * 5 * p);
}
}
cout << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50100;
vector<int> v;
int n, k, st, x;
int nextchild[maxn], value[maxn];
void get_rand() {
int arr[n + 1];
for (int i = 0; i < n; i++) {
arr[i] = i + 1;
}
srand(time(0));
random_shuffle(arr, arr + n);
for (int i = 0; i < k; i++) {
v.push_back(arr[i]);
}
}
int main() {
cin >> n >> st >> x;
k = min(n, 1500);
get_rand();
memset(nextchild, 0, sizeof(nextchild));
memset(value, -1, sizeof(value));
cout << "? " << st << "\n";
fflush(stdout);
cin >> value[st] >> nextchild[st];
int maxind = st;
int maxval = value[st];
for (int i : v) {
cout << "? " << i << "\n";
fflush(stdout);
cin >> value[i] >> nextchild[i];
if (value[i] <= x && value[i] > maxval) {
maxval = value[i];
maxind = i;
}
}
int curr = maxind;
int answ = maxind;
while (true) {
cout << "? " << curr << "\n";
fflush(stdout);
cin >> value[curr] >> nextchild[curr];
if (value[curr] >= x || nextchild[curr] == -1)
break;
else
curr = nextchild[curr];
}
if (value[curr] >= x) {
cout << "! " << value[curr] << "\n";
fflush(stdout);
} else {
cout << "! -1\n";
fflush(stdout);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1000];
int main() {
memset(a, 0, sizeof a);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
for (int j = x; j <= y; ++j) ++a[j];
}
int i = 1;
while (a[i] == 1 && i < n) ++i;
if (a[i] == 1)
cout << "OK";
else
cout << i << ' ' << a[i];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b = 0, k = 0, t = 0, g = 0, x1 = 0, x2 = 0, x3 = 0, ans = 0, z = 0,
f = 0, j = 0;
cin >> n;
int a[n], o[n], p[n], l[n];
bool h = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
o[x1] = i + 1;
x1++;
}
if (a[i] == 2) {
p[x2] = i + 1;
x2++;
}
if (a[i] == 3) {
l[x3] = i + 1;
x3++;
}
}
if (x1 == 0 || x2 == 0 || x3 == 0) {
cout << "0" << endl;
} else {
z = min(x1, x2);
ans = min(z, x3);
cout << ans << endl;
for (int i = 0; i < ans; i++) {
cout << o[i] << " " << p[i] << " " << l[i] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
char c;
inline void read(int &a) {
c = getchar();
for (a = 0; c > '9' || c < '0'; c = getchar())
;
for (; c <= '9' && c >= '0'; c = getchar()) (a *= 10) += c - '0';
}
int n, k;
int A[20];
int top, cnt, ans;
int main() {
int i, u;
read(n);
read(k);
if (!n) {
printf("0\n");
return 0;
}
while (n) {
A[++top] = n % 10;
n /= 10;
}
for (i = 1; i <= top; i++) {
u = A[i] != 0;
ans += u;
cnt += u ^ 1;
if (cnt >= k) break;
}
if (cnt < k) {
printf("%d\n", top - 1);
return 0;
}
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 * 100 + 5;
const int mod = 1000000007;
int n, m, p[maxn], mark[3 * maxn];
vector<int> ans, odd;
vector<pair<int, int> > adj[maxn];
void tour(int v) {
while (p[v] < adj[v].size()) {
int id = adj[v][p[v]].second, u = adj[v][p[v]].first;
if (mark[id] == 0) {
mark[id] = 1;
tour(u);
}
p[v]++;
}
ans.push_back(v);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[v].push_back({u, i});
adj[u].push_back({v, i});
}
for (int i = 1; i <= n; i++) {
if ((int)adj[i].size() % 2 == 1) odd.push_back(i);
}
for (int i = 0; i < odd.size(); i += 2) {
m++;
adj[odd[i]].push_back({odd[i + 1], m});
adj[odd[i + 1]].push_back({odd[i], m});
}
if (m % 2 == 1) {
m++;
adj[n].push_back({n, m});
}
cout << m << endl;
tour(1);
reverse(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
if (i % 2 == 1) {
cout << ans[i] << " " << ans[i - 1] << endl;
cout << ans[i] << " " << ans[i + 1] << endl;
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void show(const vector<T> &a) {
for (T x : a) cout << x << " ";
cout << endl;
}
signed main() {
long long tc;
cin >> tc;
while (tc--) {
long long x, y, z;
cin >> x >> y >> z;
vector<long long> a(3);
a[2] = z;
a[1] = y;
a[0] = x;
sort(a.begin(), a.end());
if (a[2] == a[1]) {
cout << "YES" << endl;
cout << a[0] << " " << a[0] << " " << a[2] << endl;
} else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
FILE* stream;
mt19937 rng(1337);
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < int(n); i++) {
cin >> a[i];
}
vector<int> b(n);
for (int i = 0; i < int(n); i++) {
if (i % 2) {
b[i] = a[i - 1];
} else {
b[i] = -a[i + 1];
}
}
for (int i = 0; i < int(n); i++) cout << b[i] << ' ';
cout << endl;
return;
}
signed main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i = 0;
char k, max = 'Z';
cin >> n;
for (int j = 0; j <= 2; j++) {
if (n % 4 == 1) {
k = 'A';
} else if (n % 4 == 3) {
k = 'B';
} else if (n % 4 == 2) {
k = 'C';
} else {
k = 'D';
}
if (k < max) {
max = k;
i = j;
}
n++;
}
cout << i << " " << max << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
double ans = 1e18;
for (int i = 0; i < N; i++) {
double a, b;
cin >> a >> b;
ans = min(ans, a / b);
}
ans *= M;
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[51][51];
int n;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
int p[51];
memset(p, 0, sizeof(p));
vector<int> vx;
for (int i = 0; i < n; i++) {
unordered_map<int, int> mp;
for (int j = 0; j < n; j++) {
if (i == j) continue;
mp[a[i][j]]++;
}
int cnt = 0;
int id = -1;
for (auto it = mp.begin(); it != mp.end(); it++) {
int tmp = it->second;
if (tmp > cnt) {
id = it->first;
cnt = tmp;
}
}
if (cnt > 1) p[i] = id;
}
int x = n;
for (int i = 0; i < n; i++) {
if (p[i] == 0) {
p[i] = x;
x--;
}
cout << p[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const double eps = 1e-9;
const double pi = acos(-1);
using namespace std;
char s[200010], t[200010];
int flag;
bool cmp(char x[], char y[], int len) {
int ok = 1;
for (int i = 0; i < len; i++) {
if (x[i] != y[i]) {
ok = 0;
}
}
return ok;
}
int dfs(char x[], char y[], int len) {
if (cmp(x, y, len)) return 1;
if (len % 2 == 0) {
if ((dfs(x, y, len / 2) && dfs(x + len / 2, y + len / 2, len / 2)) ||
(dfs(x, y + len / 2, len / 2) && dfs(x + len / 2, y, len / 2)))
return 1;
}
return 0;
}
int main() {
while (gets(s)) {
gets(t);
int ls = strlen(s);
if (dfs(s, t, ls))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000003;
int n, k;
const int MOD = 1000000007;
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
int cnt[10];
int n_bit(int x) {
int res = 0;
for (int i = 0; i < 8; ++i)
if (x >> i & 1) ++res;
return res;
}
long long dp[10][10];
long long C[10][10];
void DP() {
memset(C, 0, sizeof(C));
C[0][0] = 1;
for (int i = 1; i < 10; ++i) {
C[i][i] = C[i][0] = 1;
for (int j = 1; j < i; ++j) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
dp[1][1] = 1;
for (int i = 2; i < 10; ++i) {
for (int j = 1; j <= i; ++j) {
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j] * (i - 1 + i - 1) % MOD;
if (dp[i][j] >= MOD) dp[i][j] %= MOD;
for (int k = j + 1; k < i; ++k) {
if (k - j + 1 > 2)
dp[i][j] += dp[i - 1][k] * C[k][k - j + 1] * (k - j + 2) % MOD;
else
dp[i][j] += dp[i - 1][k] * C[k][k - j + 1] % MOD;
}
if (dp[i][j] >= MOD) dp[i][j] %= MOD;
}
}
}
long long Sum(int a) {
long long res = 0;
for (int i = 0; i <= a; ++i) {
res += dp[a][i];
}
return res % MOD;
}
long long dfs(int a, int b, int cur) {
if (cur == b) {
long long res = 1;
for (int i = 0; i < a; ++i) {
res *= Sum(cnt[i]);
if (res >= MOD) res %= MOD;
}
return res;
} else {
long long res = 0;
for (int i = 0; i < a; ++i) {
++cnt[i];
res += dfs(a, b, cur + 1);
if (res >= MOD) res -= MOD;
--cnt[i];
}
return res;
}
}
long long S(int a) {
if (a == 1) return 1;
if (a == 2) return 1;
if (a == 3) return 2;
long long res = 1;
for (int i = 1; i < a; ++i) {
res *= i;
if (res >= MOD) res %= MOD;
}
return res % MOD;
}
long long get(int x, int y) {
if (!(x & 1)) return 0;
int a = n_bit(x);
int b = n_bit(y);
memset(cnt, 0, sizeof(cnt));
return S(a) * dfs(a, b, 0) % MOD;
}
long long Ans() {
int top = (1 << k) - 1;
long long res = 0;
for (int i = 0; i <= top; ++i) {
res += get(i, top ^ i);
if (res >= MOD) res -= MOD;
}
return res;
}
int main() {
DP();
while (scanf("%d%d", &n, &k) == 2) {
long long ans = power(k, k - 1) * power(n - k, n - k) % MOD;
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m, k;
vector<int> g[2009];
bool vis[2009];
void dfs(int i) {
vis[i] = 1;
for (auto j : g[i]) {
if (!vis[j]) dfs(j);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i + k - 1 < n; ++i) {
int a = i, b = i + k - 1;
while (a <= b) {
g[a].push_back(b);
g[b].push_back(a);
a++;
b--;
}
}
int c = 0;
int ans = 1;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
dfs(i);
c++;
}
}
for (int i = 0; i < c; ++i) {
ans = ((long long)ans * m) % mod;
}
cout << ans;
return 0;
}
| 4 |
//Har Har Mahadev
using namespace std;
#include <bits/stdc++.h>
#define booga cerr << "booga" << endl
#define int long long
#define ld long double
#define pb push_back
#define mp make_pair
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#define safai(...) Clearing_out(__VA_ARGS__)
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(char c) {
string s;
s += c;
return s;
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "1" : "0");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
void Clearing_out() { return; }
template <typename Head, typename... Tail>
void Clearing_out(Head &H, Tail & ... T) {
H.clear();
Clearing_out(T...);
}
void testcase(){
int n;
cin >> n;
const int mod = 998244353;
int pref = 0;
int ans = 0;
const int N = 1000005;
vector<int> divi(N, 0);
for(int i = 1; i <= N-5; i++){
for(int j = i; j <= N-5; j+=i){
divi[j]++;
}
}
for(int i = 1; i <= n; i++){
divi[i] = (divi[i] + pref)%mod;
pref = (pref + divi[i])%mod;
}
cout << divi[n];
}
int32_t main(){
ios::sync_with_stdio(false);
cin.tie(0);
int tt = 1;
// cin >> tt;
while(tt--){
testcase();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
long long l = 1, r = n / 2;
while (l <= r) {
long long mm = (l + r) / 2;
long long m = 2 * mm;
long long c = 0;
for (int i = 0; (m << i) <= n; i++) {
c += min(n, (m << i) + (1ll << (i + 1 - (m & 1))) - 1) - (m << i) + 1;
}
if (c >= k) {
l = mm + 1;
} else {
r = mm - 1;
}
}
long long ans = 2 * (l - 1);
l = 0, r = n / 2;
if (2 * r + 1 > n) r--;
while (l <= r) {
long long mm = (l + r) / 2;
long long m = 2 * mm + 1;
long long c = 0;
for (int i = 0; (m << i) <= n; i++) {
c += min(n, (m << i) + (1ll << (i + 1 - (m & 1))) - 1) - (m << i) + 1;
}
if (c >= k) {
l = mm + 1;
} else {
r = mm - 1;
}
}
ans = max(ans, 2 * (l - 1) + 1);
cout << ans << endl;
return 0;
}
| 6 |
// 1506f.cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n;
cin >> n;
vector<pair<ll, ll>> v(n);
for (int i = 0; i < n; i++)
cin >> v[i].first;
for (int i = 0; i < n; i++)
cin >> v[i].second;
sort(v.begin(), v.end());
auto last = make_pair(1LL, 1LL);
int ans = 0;
for (int i = 0; i < n; i++) {
if (v[i] == last)
continue;
if (v[i].first - last.first == v[i].second - last.second) {
ans += (last.first + last.second) % 2 == 0 ? v[i].first - last.first : 0;
last = v[i];
continue;
}
ll dr = v[i].first - last.first;
ll dc = v[i].second - last.second;
// --d;
if ((last.first + last.second) % 2 == 0) {
ans += (dr - dc)/2;
} else {
ans += (dr - dc + 1)/2;
}
last = v[i];
}
cout << ans << endl;
}
int main() {
int tc;
cin >> tc;
while (tc--)
solve();
} | 6 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> A[26], B[26];
map<long long, long long>::iterator it;
long long fact[20], ans[30], aim, sum;
int n, k, mid, kind;
void dfs(int id, int f, long long s) {
if (s > aim || f > k) return;
if ((kind == 1 && id > mid) || (kind == 2 && id > n)) {
if (kind == 1)
A[f][s]++;
else {
for (int i = f; i <= k; ++i) B[i][s]++;
}
return;
}
dfs(id + 1, f, s);
dfs(id + 1, f, s + ans[id]);
if (ans[id] < 19) dfs(id + 1, f + 1, s + fact[ans[id]]);
}
int main() {
fact[1] = 1;
for (int i = 2; i <= 19; ++i) fact[i] = fact[i - 1] * i;
scanf("%d %d %I64d", &n, &k, &aim);
for (int i = 1; i <= n; ++i) scanf("%I64d", &ans[i]);
mid = n / 2;
kind = 1;
dfs(1, 0, 0);
kind = 2;
dfs(mid + 1, 0, 0);
for (int i = 0; i <= k; ++i) {
for (it = A[i].begin(); it != A[i].end(); ++it) {
sum += (*it).second * (B[k - i][aim - (*it).first]);
}
}
printf("%I64d\n", sum);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MOD = 1e9 + 7;
string ans =
"What are you doing at the end of the world? Are you busy? Will you save "
"us?";
string a = "What are you doing while sending \"";
string b = "\"? Are you busy? Will you send \"";
string c = "\"?";
vector<long long int> dp(N, 1e18 + 1);
char get(long long int n, long long int k) {
if (k >= dp[n]) return '.';
if (n == 0) return ans[k];
if (k < a.size()) return a[k];
if (k < a.size() + dp[n - 1]) return get(n - 1, k - a.size());
if (k < a.size() + dp[n - 1] + b.size()) return b[k - a.size() - dp[n - 1]];
if (k < a.size() + dp[n - 1] + b.size() + dp[n - 1])
return get(n - 1, k - a.size() - dp[n - 1] - b.size());
if (k < a.size() + dp[n - 1] + b.size() + dp[n - 1] + c.size())
return c[k - a.size() - dp[n - 1] - b.size() - dp[n - 1]];
return '.';
}
void solve() {
dp[0] = ans.size();
for (int i = 1; i < 60; ++i) {
long long int k = (2 * dp[i - 1]) + a.size() + b.size() + c.size();
dp[i] = min(k, (long long int)1e18 + 1);
}
int q;
cin >> q;
while (q--) {
long long int n, k;
cin >> n >> k;
cout << get(n, k - 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
int n;
int a[MAXN];
pair<int, int> p[MAXN];
vector<pair<int, int> > v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
p[i] = {a[i], i};
}
sort(p, p + n);
for (int i = 0; i < n; i++) {
for (int j = n - 1; j >= 0; j--) {
if (a[i] > p[j].first && i < p[j].second)
v.push_back({i + 1, p[j].second + 1});
}
}
cout << v.size() << '\n';
for (int i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N;
bool fa[3000][3000];
bool f[3000][3000];
bool v[3000][3000];
vector<pair<int, int> > akt;
queue<pair<int, int> > qu;
void visit(int x, int y) {
if (v[x][y]) return;
v[x][y] = true;
qu.push(pair<int, int>(x, y));
while (!qu.empty()) {
int x = qu.front().first, y = qu.front().second;
qu.pop();
akt.push_back(pair<int, int>(x, y));
for (int xs = max(0, x - 1); xs <= N && xs <= x + 1; xs++)
for (int ys = max(0, y - 1); ys <= N && ys <= y + 1; ys++) {
if (!v[xs][ys] && f[xs][ys]) {
v[xs][ys] = true;
qu.push(pair<int, int>(xs, ys));
}
}
}
}
int main() {
scanf("%d", &N);
for (int y = 0; y < (N + 10); y++)
for (int x = 0; x < (N + 10); x++) fa[x][y] = f[x][y] = false;
for (int y = 0; y < (N); y++)
for (int x = 0; x < (N); x++) {
int h;
scanf("%d", &h);
fa[x + 1][y + 1] = h;
}
const int delta = 3;
for (int x = 1; x <= N; x++)
for (int y = 1; y <= N; y++) {
int s = 0;
for (int xs = x - delta; xs <= x + delta; xs++)
for (int ys = y - delta; ys <= y + delta; ys++) s += fa[xs][ys];
f[x][y] = (s > (2 * delta + 1) * (2 * delta + 1) / 2);
}
int ergkreis = 0, ergquadrat = 0;
for (int xs = 0; xs < (N); xs++) {
for (int ys = 0; ys < (N); ys++) {
if (v[xs][ys] || !f[xs][ys]) continue;
akt.clear();
visit(xs, ys);
if (akt.size() < 70) continue;
long long d2 = 0;
for (typeof((akt).begin()) it = (akt).begin(); it != (akt).end(); it++) {
int x = it->first, y = it->second;
if (f[x + 1][y] && f[x - 1][y]) continue;
if (f[x][y + 1] && f[x][y - 1]) continue;
for (typeof((akt).begin()) jt = (akt).begin(); jt != (akt).end();
jt++) {
int xx = jt->first, yy = jt->second;
d2 = max(d2, (long long)(xx - x) * (xx - x) +
(long long)(yy - y) * (yy - y));
}
}
long double ve = (long double)d2 / akt.size();
if (fabs(ve - 2) < fabs(ve - M_PI / 4))
ergquadrat++;
else
ergkreis++;
}
}
printf("%d %d\n", ergkreis, ergquadrat);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100][100];
int dx[] = {2, 1, -1, -2, 3, 0};
int dy[] = {1, 2, 2, 1, 0, 3};
void next(int &x, int &y) {
if (y == m) {
y = 1;
x++;
} else {
y++;
}
}
int table[4][4] = {
{0, 0, 0, 0},
{0, 1, 0, 1},
{0, 0, 0, 0},
{0, 1, 0, 1},
};
bool check(int x, int y) { return 1 <= x && x <= n && 1 <= y && y <= m; }
int dfs(int x, int y) {
static int cnt = 0;
cnt++;
if (cnt > 50000000) {
return n * m;
}
if (x == n && y == m) {
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!a[i][j]) ans++;
}
}
return ans;
}
if (a[x][y]) {
next(x, y);
return dfs(x, y);
} else {
if (x == n && y == m) {
return n * m;
} else {
a[x][y] = (x - 1) * m + y;
int ans = n * m;
for (int i = 0; i < 6; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (check(nx, ny) && !a[nx][ny]) {
int cx = x, cy = y;
a[nx][ny] = (x - 1) * m + y;
next(cx, cy);
ans = min(ans, dfs(cx, cy));
a[nx][ny] = 0;
}
if (!ans) return ans;
}
a[x][y] = 0;
next(x, y);
ans = min(ans, dfs(x, y));
return ans;
}
}
}
int t1[] = {0, 0, 0, 0, 2, 4};
int main() {
scanf("%d%d", &n, &m);
if (n > m) swap(n, m);
if ((long long)n * m <= 36) {
int ans = dfs(1, 1);
cout << n * m - ans;
} else if (n == 1) {
printf("%d\n", m / 6 * 6 + t1[m % 6]);
} else {
cout << (long long)n * (long long)m - table[n % 4][m % 4];
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> Q, Q1;
int g(int a, int b) { return a / b + ((a % b == 0) ? 0 : 1); }
int f(int l, int t, int x, int y, int x1, int y1) {
int sum = abs(y - l) + g(abs(x - x1), t) + abs(l - y1);
return sum;
}
int main() {
int n, m, A, B, v;
scanf("%d%d%d%d%d", &n, &m, &A, &B, &v);
for (int i = 0; i < A; i++) {
int x;
scanf("%d", &x);
Q.push_back(x);
}
for (int i = 0; i < B; i++) {
int x;
scanf("%d", &x);
Q1.push_back(x);
}
sort(Q.begin(), Q.end());
sort(Q1.begin(), Q1.end());
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int x, y, x1, y1;
int ans = 1e9 + 7;
scanf("%d%d%d%d", &x, &y, &x1, &y1);
auto it = lower_bound(Q.begin(), Q.end(), y);
if (it != Q.end()) {
ans = min(ans, f(*it, 1, x, y, x1, y1));
}
if (it != Q.begin()) {
it--;
ans = min(ans, f(*it, 1, x, y, x1, y1));
}
auto it1 = lower_bound(Q1.begin(), Q1.end(), y);
if (it1 != Q1.end()) {
ans = min(ans, f(*it1, v, x, y, x1, y1));
}
if (it1 != Q1.begin()) {
it1--;
ans = min(ans, f(*it1, v, x, y, x1, y1));
}
if (x == x1) ans = min(ans, abs(y - y1));
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100500;
int n, a, b, op[N], p[N], t[N], ansx[N], ansy[N];
vector<int> vec[(N << 1) + 3];
struct Dot {
int x, y;
} dot[N];
inline void LOCAL() { freopen("1.in", "r", stdin); }
inline void read(int &x) {
x = 0;
char c = getchar();
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = 10 * x + c - '0';
c = getchar();
}
x *= f;
}
bool cmp(int a, int b) {
int x = (op[a] == 1) ? p[a] : -t[a];
int y = (op[b] == 1) ? p[b] : -t[b];
return x < y;
}
bool cmp1(Dot a, Dot b) { return a.x != b.x ? a.x < b.x : a.y > b.y; }
int main() {
read(n);
read(a);
read(b);
for (int i = 1; i <= n; i++) {
read(op[i]);
read(p[i]);
read(t[i]);
vec[p[i] - t[i] + N].push_back(i);
}
for (int i = 1; i <= N << 1; i++)
if (vec[i].size()) {
sort(vec[i].begin(), vec[i].end(), cmp);
int len = vec[i].size();
for (int j = 0; j <= len - 1; j++) {
int pos = vec[i][j];
if (op[pos] == 1) {
dot[j].x = p[pos];
dot[j].y = b;
} else {
dot[j].x = a;
dot[j].y = p[pos];
}
}
sort(dot, dot + len, cmp1);
for (int j = 0; j <= len - 1; j++) {
int pos = vec[i][j];
ansx[pos] = dot[j].x;
ansy[pos] = dot[j].y;
}
}
for (int i = 1; i <= n; i++) printf("%d %d\n", ansx[i], ansy[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
int n, k, d[205];
int dp[205][205], dis[205][205], opt[205], way[205];
bool p[205];
vector<int> v[205];
void dfs(int x, int fa) {
if (p[x]) return;
p[x] = 1;
for (int(j) = (0); (j) < (v[x].size()); (j)++) {
int to = v[x][j];
if (to == fa) continue;
dfs(to, x);
}
for (int(i) = (1); (i) <= (n); (i)++) {
dp[x][i] = d[dis[x][i]] + k;
for (int(j) = (0); (j) < (v[x].size()); (j)++) {
int to = v[x][j];
if (to == fa) continue;
int cost1 = dp[to][i] - k;
int cost2 = dp[to][opt[to]];
dp[x][i] += min(cost1, cost2);
}
if (opt[x] == 0 || dp[x][i] < dp[x][opt[x]]) opt[x] = i;
}
}
void rec(int x, int nxt, int fa) {
way[x] = nxt;
for (int(j) = (0); (j) < (v[x].size()); (j)++) {
int to = v[x][j];
if (to == fa) continue;
int cost1 = dp[to][nxt] - k;
int cost2 = dp[to][opt[to]];
if (cost1 < cost2)
rec(to, nxt, x);
else
rec(to, opt[to], x);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int(i) = (1); (i) <= (n - 1); (i)++) scanf("%d", d + i);
for (int(i) = (1); (i) <= (n); (i)++)
for (int(j) = (1); (j) <= (n); (j)++)
if (i != j) dis[i][j] = inf;
for (int(i) = (1); (i) < (n); (i)++) {
int t1, t2;
scanf("%d%d", &t1, &t2);
v[t1].push_back(t2);
v[t2].push_back(t1);
dis[t1][t2] = dis[t2][t1] = 1;
}
for (int(k) = (1); (k) <= (n); (k)++)
for (int(i) = (1); (i) <= (n); (i)++)
for (int(j) = (1); (j) <= (n); (j)++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1, 0);
int ans = dp[1][opt[1]];
printf("%d\n", ans);
rec(1, opt[1], 0);
for (int(i) = (1); (i) <= (n); (i)++) printf("%d ", way[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int a, b, n;
while (cin >> a >> b >> n) {
for (__typeof(0) i = (0); i <= (9); i++) {
if ((a * 10 + i) % b == 0) {
cout << a << i;
b = 0;
for (__typeof(1) j = (1); j <= (n - 1); j++) cout << 0;
break;
}
}
if (b) cout << -1;
cout << '\n';
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
#define pi 3.1415926535897932384626
using namespace std;
struct P{
int x,y;
long long z;
bool operator < (const P &a )const{
//if(x!=a.x) return x<a.x;
return z>a.z;
};
};
int a,b,c,d,i,n,m,e,ee,k,dx[10]={1,0,-1,0,1,1,-1,-1},dy[10]={0,1,0,-1,1,-1,1,-1};
long long o[200011][4];
int l[1];
int ss[1];
int ans[1];
long long x,y,z,mod=1000000007,hf=(mod+1)/2;
//string r;
char r[1],r2[33];
vector<P> v[201011];
P u[1];
priority_queue<P> q;
set<P> s;
//stack<int> s;
unordered_map<int,bool> p;
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//rng()
bool as(P a,P b)
{
//if(a.x!=b.x)
//return a.x<b.x;
return a.y<b.y;
}
int main()
{
scanf("%d %d",&a,&b);
for(int t=1;t<=b;t++)
{
scanf("%d %d %d",&n,&m,&k);
v[n].push_back({m,k});
v[m].push_back({n,k});
}
for(int t=1;t<=a;t++)
for(int h=0;h<4;h++)
o[t][h]=mod*mod;
o[1][0]=0;
q.push({1,0,0});
for(;q.size();)
if(o[q.top().x][q.top().y]==q.top().z)
{
P s=q.top();
q.pop();
for(int h=0;h<v[s.x].size();h++)
{
if(s.y<2&&o[v[s.x][h].x][s.y+2]>s.z)
{
o[v[s.x][h].x][s.y+2]=s.z;
q.push({v[s.x][h].x,s.y+2,s.z});
}
if(s.y%2==0&&o[v[s.x][h].x][s.y+1]>s.z+v[s.x][h].y*2)
{
o[v[s.x][h].x][s.y+1]=s.z+v[s.x][h].y*2;
q.push({v[s.x][h].x,s.y+1,s.z+v[s.x][h].y*2});
}
if(o[v[s.x][h].x][s.y]>s.z+v[s.x][h].y)
{
o[v[s.x][h].x][s.y]=s.z+v[s.x][h].y;
q.push({v[s.x][h].x,s.y,s.z+v[s.x][h].y});
}
}
}
else q.pop();
for(int t=2;t<=a;t++)
printf("%lld ",min(o[t][0],o[t][3]));
}
| 8 |
#include <bits/stdc++.h>
inline long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
int n, m, a, b, d, block[71], k, blocknum[71], siz[71], realblock[71];
int fir[71], dis[410], nxt[410], w[410], id;
inline void link(int a, int b, int c) {
nxt[++id] = fir[a], fir[a] = id, dis[id] = b, w[id] = c;
}
inline void dfs(int x, int orz) {
realblock[x] = orz, ++siz[orz];
for (int i = fir[x]; i; i = nxt[i])
if (w[i] == a && !realblock[dis[i]]) dfs(dis[i], orz);
}
long long dist[1 << 17][71], ans[71];
bool vis[1 << 17][71];
std::priority_queue<std::pair<long long, std::pair<int, int>>> que;
int main() {
n = gi(), m = gi(), a = gi(), b = gi();
int u, v, c;
while (m--) u = gi(), v = gi(), c = gi(), link(u, v, c), link(v, u, c);
for (int i = 1; i <= n; ++i)
if (!realblock[i]) dfs(i, ++k);
for (int i = 1; i <= k; ++i)
if (siz[i] > 3)
blocknum[i] = d++;
else
blocknum[i] = -1;
for (int i = 1; i <= n; ++i) block[i] = blocknum[realblock[i]];
memset(dist, 63, sizeof dist);
memset(ans, 63, sizeof ans);
dist[~block[1] ? 1 << block[1] : 0][1] = 0;
que.push({0, {~block[1] ? 1 << block[1] : 0, 1}});
while (!que.empty()) {
int x = que.top().second.first, y = que.top().second.second;
que.pop();
if (vis[x][y]) continue;
vis[x][y] = 1;
if (ans[y] > dist[x][y]) ans[y] = dist[x][y];
for (int i = fir[y]; i; i = nxt[i]) {
int tx = x, ty = dis[i];
if (~block[ty]) tx |= 1 << block[ty];
if (dist[tx][ty] <= dist[x][y] + w[i]) continue;
if (w[i] == b &&
((~block[ty] && tx == x) || (realblock[ty] == realblock[y])))
continue;
dist[tx][ty] = dist[x][y] + w[i];
que.push({-dist[tx][ty], {tx, ty}});
}
}
for (int i = 1; i <= n; ++i) printf("%lld ", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, vol[100005], seg[500005], c;
map<long long, long long> ha;
void update(long long x, long long val, long long l = 0, long long r = c,
long long p = 1) {
if (x < l || x > r) return;
if (l == r) {
seg[p] = val;
return;
}
long long mid = (l + r) / 2;
update(x, val, l, mid, 2 * p), update(x, val, mid + 1, r, 2 * p + 1);
seg[p] = max(seg[2 * p], seg[2 * p + 1]);
return;
}
long long query(long long i, long long j, long long l = 0, long long r = c,
long long p = 1) {
if (l > j || r < i) return 0;
if (l >= i && r <= j) return seg[p];
long long mid = (l + r) / 2;
return max(query(i, j, l, mid, 2 * p), query(i, j, mid + 1, r, 2 * p + 1));
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
long long r, h;
cin >> r >> h;
vol[i] = r * r * h;
ha[vol[i]];
}
for (auto &it : ha) it.second = c++;
c--;
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
long long x = ha[vol[i]];
long long q = query(x + 1, c);
q += vol[i];
ans = max(ans, q);
update(x, q);
}
cout << fixed << setprecision(6) << ((double)(acos(-1) * ans));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, N, o, k, I, J, K, r, l, b, ta;
int a;
int v[100];
vector<pair<pair<int, int>, pair<int, int> > > A;
bool f(int x) {
if (x == 0) return a % 2;
while (x) {
if ((a & (1 << (x % 10))) == 0) return 0;
x /= 10;
}
return 1;
}
bool ch(int N) {
for (I = 1; I <= N; I++)
if (v[I] != v[N - I + 1]) return 0;
return 1;
}
bool che(int first, int second, int Z) {
int C = 0;
if (first == 0 || second == 0 || Z == 0) C = 1;
int x = first;
while (x) {
C |= (1 << (x % 10));
x /= 10;
}
x = second;
while (x) {
C |= (1 << (x % 10));
x /= 10;
}
x = Z;
while (x) {
C |= (1 << (x % 10));
x /= 10;
}
return a == C;
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> k, a |= (1 << k);
for (i = 0; i < 256; i++)
if (f(i))
for (j = 0; j < 256; j++)
if (f(j))
for (k = 0; k < 256; k++)
if (f(k))
if (che(i, j, k)) {
l = 0;
I = i;
J = j;
K = k;
if (K == 0) v[++l] = 0;
while (K) {
v[++l] = K % 10;
K /= 10;
}
if (j == 0) v[++l] = 0;
while (J) {
v[++l] = J % 10;
J /= 10;
}
if (i == 0) v[++l] = 0;
while (I) {
v[++l] = I % 10;
I /= 10;
}
reverse(v + 1, v + l + 1);
v[l + 1] = v[1];
if (ch(l + 1))
A.push_back(make_pair(make_pair(i, j), make_pair(k, v[1])));
v[l + 1] = v[2];
v[l + 2] = v[1];
if (v[2] != 0)
if (ch(l + 2))
A.push_back(make_pair(make_pair(i, j),
make_pair(k, v[2] * 10 + v[1])));
v[l + 1] = v[3];
v[l + 2] = v[2];
v[l + 3] = v[1];
if (v[3] != 0)
if (v[3] * 100 + v[2] * 10 + v[1] < 256)
if (ch(l + 3))
A.push_back(make_pair(
make_pair(i, j),
make_pair(k, v[3] * 100 + v[2] * 10 + v[1])));
}
cout << A.size() << endl;
for (i = 0; i < A.size(); i++)
printf("%d.%d.%d.%d\n", A[i].first.first, A[i].first.second,
A[i].second.first, A[i].second.second);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
};
struct Line {
Point a, b;
};
Point intersection(Line u, Line v) {
Point ret = u.a;
double t =
((u.a.x - v.a.x) * (v.a.y - v.b.y) - (u.a.y - v.a.y) * (v.a.x - v.b.x)) /
((u.a.x - u.b.x) * (v.a.y - v.b.y) - (u.a.y - u.b.y) * (v.a.x - v.b.x));
ret.x += (u.b.x - u.a.x) * t;
ret.y += (u.b.y - u.a.y) * t;
return ret;
}
Point circumcenter(Point a, Point b, Point c) {
Line u, v;
u.a.x = (a.x + b.x) / 2;
u.a.y = (a.y + b.y) / 2;
u.b.x = u.a.x - a.y + b.y;
u.b.y = u.a.y + a.x - b.x;
v.a.x = (a.x + c.x) / 2;
v.a.y = (a.y + c.y) / 2;
v.b.x = v.a.x - a.y + c.y;
v.b.y = v.a.y + a.x - c.x;
return intersection(u, v);
}
double Distance(Point pa, Point pb) {
double x = pa.x - pb.x;
double y = pa.y - pb.y;
return sqrt(x * x + y * y);
}
double gcd(double a, double b) {
while (fabs(a) > 1e-4 && fabs(b) > 1e-4) {
if (a > b)
a -= floor(a / b) * b;
else
b -= floor(b / a) * a;
}
return a + b;
}
int main() {
Point pa, pb, pc;
cin >> pa.x >> pa.y;
cin >> pb.x >> pb.y;
cin >> pc.x >> pc.y;
Point pr = circumcenter(pa, pb, pc);
double r = Distance(pr, pa);
double a = Distance(pa, pb);
double b = Distance(pa, pc);
double c = Distance(pb, pc);
double da = acos((b * b + c * c - a * a) / (2 * b * c));
double db = acos((a * a + c * c - b * b) / (2 * a * c));
double dc = acos((a * a + b * b - c * c) / (2 * a * b));
double mindeg = gcd(da, gcd(db, dc));
double n = acos(-1.0) / mindeg;
double area = n / 2.0 * r * r * sin(2 * acos(-1.0) / n);
printf("%.8f\n", area);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-6;
void err() { puts(""); }
template <typename T, typename... Args>
void err(const T &arg, const Args &...args) {
std::cout << arg << ' ';
err(args...);
}
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
long long f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
template <typename T, typename... Args>
void read(T &first, Args &...args) {
read(first);
read(args...);
}
using namespace std;
long long a, b, c, d;
long long calc(long long x) {
long long sum = 1ll * x * a;
long long r = (x - 1) * d + 1;
long long l = max((long long)floor((r - c - 1.0) / d + 1), 0ll);
long long tot = (r - l * d - 1);
long long t = tot * b;
long long dt = b * d;
sum -= (2 * t - tot / d * dt) * (tot / d + 1) / 2;
sum -= l * b * c;
return sum;
}
int main() {
int t;
for (read(t); t--;) {
read(a, b, c, d);
long long sum = 0;
if (a > b * c) {
puts("-1");
} else if (a <= b) {
printf("%d\n", a);
} else {
long long ans = 0;
long long l = 1, r = 1e6 + 10;
while (l < r) {
long long lt = (2 * l + r) / 3;
long long rt = (2 * r + l + 2) / 3;
long long ls = calc(lt), rs = calc(rt);
if (ls >= rs) {
ans = max(ans, ls);
r = rt - 1;
} else {
ans = max(ans, rs);
l = lt + 1;
}
}
printf("%lld\n", ans);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k = 0, l, m = 0, n, o, p;
cin >> n;
vector<int> v;
int a[n];
int b[n];
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
if (a[i] == 1) k++;
}
cout << k << endl;
for (i = 1; i <= n; i++) {
m++;
if (a[i + 1] == 1) {
v.push_back(m);
m = 0;
}
}
for (i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << a[n];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, one = 0, two = 0, a[102];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
((a[i] / 100) & 1) ? one++ : two++;
}
if (((100 * one + 200 * two) / 100) & 1) {
cout << "NO" << endl;
return 0;
}
sort(a, a + n);
int ans = (100 * one + 200 * two);
for (int i = 0; i < n; i++) {
ans -= a[i];
for (int j = i + 1; j < n; j++) {
if (2 * ans == (100 * one + 200 * two)) {
cout << "YES" << endl;
return 0;
}
ans -= a[j];
}
ans = (100 * one + 200 * two);
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<char, char> mp;
string check(string s) {
for (int i = 0; i <= s.size() / 2; i++)
if (s[i] != mp[s[s.size() - 1 - i]]) return "NIE";
return "TAK";
}
int main() {
mp['A'] = 'A';
mp['b'] = 'd';
mp['d'] = 'b';
mp['H'] = 'H';
mp['I'] = 'I';
mp['M'] = 'M';
mp['O'] = 'O';
mp['o'] = 'o';
mp['p'] = 'q';
mp['q'] = 'p';
mp['T'] = 'T';
mp['U'] = 'U';
mp['V'] = 'V';
mp['v'] = 'v';
mp['W'] = 'W';
mp['w'] = 'w';
mp['X'] = 'X';
mp['x'] = 'x';
mp['Y'] = 'Y';
string s;
cin >> s;
cout << check(s) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[200001];
int b[600001];
int n, L;
bool chk(int d) {
if (d * 2 >= L) return true;
int l = 0, r = 3 * n - 1;
while (b[l] < a[0] - d) l++;
while (b[r] > a[0] + d) r--;
for (int i = 1; i < n; i++) {
l++;
r++;
while (b[l] < a[i] - d) l++;
if (b[r] > a[i] + d) r--;
}
return l <= r;
}
void Init() {
scanf("%d%d", &n, &L);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", b + n + i);
}
void Solve() {
for (int i = 0; i < n; i++) {
b[i] = b[i + n] - L;
b[i + 2 * n] = b[i + n] + L;
}
sort(a, a + n);
sort(b, b + 3 * n);
int left = 0, right = L / 2 + 1;
while (left < right) {
int m = (left + right) >> 1;
if (chk(m))
right = m;
else
left = m + 1;
}
printf("%d\n", left);
}
int main() {
Init();
Solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100010], val[100010];
long long b;
int main() {
scanf("%d%d%I64d", &n, &k, &b);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
val[i] = a[i];
}
sort(val + 1, val + n);
long long sum = b;
for (int i = n - 1; i >= n - k; i--) sum -= val[i];
if (sum >= 0) {
printf("%d", n);
} else {
int ans = -1;
for (int i = 1; i <= n; i++) {
if (a[i] >= val[n - k] || sum + val[n - k] - a[i] < 0) {
ans = i;
break;
}
}
printf("%d", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long INFINIT = 100000000000000;
long long tree[300000];
long long lazy[300000];
vector<long long> ar;
vector<long long> ar2;
long long tree2[300000];
long long lazy2[300000];
int size;
void build(int left, int right, int vertex) {
if (left == right) {
tree[vertex] = ar[left];
return;
}
build(left, (left + right) / 2, 2 * vertex);
build(((left + right) / 2) + 1, right, 2 * vertex + 1);
tree[vertex] = tree[2 * vertex] + tree[2 * vertex + 1];
}
void build2(int left, int right, int vertex) {
if (left == right) {
tree2[vertex] = ar2[left];
return;
}
build2(left, (left + right) / 2, 2 * vertex);
build2(((left + right) / 2) + 1, right, 2 * vertex + 1);
tree2[vertex] = tree2[2 * vertex] + tree2[2 * vertex + 1];
}
void create() {
memset(tree, 0, sizeof(tree));
memset(lazy, 0, sizeof(lazy));
memset(tree2, 0, sizeof(tree2));
memset(lazy2, 0, sizeof(lazy2));
build(0, size - 1, 1);
build2(0, size - 1, 1);
}
long long rsq(int left, int right, int vertex, int i, int j) {
if (i > right || left > j) {
return 0;
}
if (left >= i && right <= j) {
return tree[vertex];
}
long long v1 = rsq(left, (left + right) / 2, 2 * vertex, i, j);
long long v2 = rsq(((left + right) / 2) + 1, right, 2 * vertex + 1, i, j);
return v1 + v2;
}
long long rsq2(int left, int right, int vertex, int i, int j) {
if (i > right || left > j) {
return 0;
}
if (left >= i && right <= j) {
return tree2[vertex];
}
long long v1 = rsq2(left, (left + right) / 2, 2 * vertex, i, j);
long long v2 = rsq2(((left + right) / 2) + 1, right, 2 * vertex + 1, i, j);
return v1 + v2;
}
long long query(int i, int j) { return rsq(0, size - 1, 1, i, j); }
long long query2(int i, int j) { return rsq2(0, size - 1, 1, i, j); }
int n, k, p;
int main() {
cin >> n >> k >> p;
vector<long long> even;
vector<long long> odd;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
if (num & 1) {
odd.push_back(num);
} else {
even.push_back(num);
}
}
vector<vector<long long> > even_sets(p);
vector<vector<long long> > odd_sets(k - p);
for (int i = 0; i < p; i++) {
if (even.size() > 0) {
even_sets[i].push_back(even[even.size() - 1]);
even.pop_back();
} else if (odd.size() < 2) {
printf("NO\n");
return 0;
} else {
even_sets[i].push_back(odd[odd.size() - 1]);
odd.pop_back();
even_sets[i].push_back(odd[odd.size() - 1]);
odd.pop_back();
}
}
if (odd_sets.size()) {
for (int i = 0; i < k - p; i++) {
if (odd.size() == 0) {
printf("NO\n");
return 0;
}
odd_sets[i].push_back(odd[odd.size() - 1]);
odd.pop_back();
if (even.size() > 0) {
while (even.size()) {
odd_sets[i].push_back(even[even.size() - 1]);
even.pop_back();
}
}
}
if (odd.size()) {
if (odd.size() % 2 == 0) {
while (odd.size()) {
odd_sets[0].push_back(odd[odd.size() - 1]);
odd.pop_back();
}
} else {
printf("NO\n");
return 0;
}
}
} else {
while (even.size()) {
even_sets[0].push_back(even[even.size() - 1]);
even.pop_back();
}
if (odd.size() % 2) {
printf("NO\n");
return 0;
}
while (odd.size()) {
even_sets[0].push_back(odd[odd.size() - 1]);
odd.pop_back();
even_sets[0].push_back(odd[odd.size() - 1]);
odd.pop_back();
}
}
printf("YES\n");
for (int i = 0; i < even_sets.size(); i++) {
cout << even_sets[i].size();
for (int j = 0; j < even_sets[i].size(); j++) {
cout << " " << even_sets[i][j];
}
cout << endl;
}
for (int i = 0; i < odd_sets.size(); i++) {
cout << odd_sets[i].size();
for (int j = 0; j < odd_sets[i].size(); j++) {
cout << " " << odd_sets[i][j];
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
const int maxn = 2e5 + 100;
const int mod = 1e9 + 7;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
int n;
ll k, arr[maxn];
bool chk(ll bound, bool print) {
ll need = k;
vector<ll> ans(n + 1);
vector<int> additional;
for (int i = 1; i <= n; i++) {
ll lo = 0, hi = arr[i];
while (lo < hi) {
ll mid = (lo + hi + 1) / 2;
ll change = 0;
if (mid == 0) {
change = 0;
} else {
change = arr[i] - 3 * mid * mid + 3 * mid - 1;
}
if (change >= bound) {
lo = mid;
} else {
hi = mid - 1;
}
}
ans[i] = lo;
need -= ans[i];
if (need <= 0 && !print) {
return true;
}
}
for (int i = 1; i <= n; i++) {
if (need < 0 && (arr[i] - 3 * ans[i] * ans[i] + 3 * ans[i] - 1) == bound) {
++need;
--ans[i];
}
}
if (print) {
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
cout << "\n";
}
return need == 0;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
ll lo = -4e18, hi = 4e18;
while (lo < hi) {
ll mid = (lo + hi + 1) / 2;
if (chk(mid, false)) {
lo = mid;
} else {
hi = mid - 1;
}
}
assert(!chk(lo + 1, false));
chk(lo, true);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 100010;
int f[32], g[32];
int main() {
string s, p;
cin >> s;
cin >> p;
int n = (int)(p).size();
if ((int)(p).size() > (int)(s).size()) {
puts("0");
return 0;
}
for (int i = 0, _n = (n); i < _n; ++i) {
if (p[i] != '?') f[p[i] - 'a']++;
if (s[i] != '?') g[s[i] - 'a']++;
}
int cnt = 0;
for (int i = n, _n = ((int)(s).size() + 1); i < _n; ++i) {
bool ok = 1;
for (int j = 0, _n = (26); j < _n; ++j) {
if (g[j] > f[j]) {
ok = 0;
break;
}
}
if (ok) cnt++;
if (i == (int)(s).size()) break;
if (s[i] != '?') {
g[s[i] - 'a']++;
}
if (s[i - n] != '?') {
g[s[i - n] - 'a']--;
}
}
cout << cnt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[5 + (1 << 20)];
int flag[5 + (1 << 20)];
int n, m;
string s;
int adj[26][26];
int min(int a, int b) {
if (a < b) return a;
return b;
}
int f(int bm) {
if (__builtin_popcount(bm) == m) {
return 0;
}
if (flag[bm]) return dp[bm];
flag[bm] = 1;
int &ans = dp[bm];
ans = 1e9;
int pos = __builtin_popcount(bm);
for (int i = 0; i < m; i++) {
if ((bm >> i) % 2 == 0) {
int bef = 0, aft = 0;
for (int j = 0; j < m; j++) {
if (i == j) continue;
if ((bm >> j) & 1) {
bef += adj[i][j];
} else {
aft += adj[i][j];
}
}
ans = min(ans, (bef - aft) * 1LL * pos + f(bm | (1 << i)));
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
cin >> s;
for (int i = 1; i < n; i++) {
adj[s[i] - 'a'][s[i - 1] - 'a'] += 1;
adj[s[i - 1] - 'a'][s[i] - 'a'] += 1;
}
printf("%d\n", f(0));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long mod = 998244353;
long long ceil(long long a, long long b) {
long long res = a / b + (a % b != 0);
return res;
}
void solve() {
long long n, t;
cin >> n >> t;
string grade;
cin >> grade;
bool bl = false;
bool cl = false;
long long ind = -1;
for (long long i = 0; i < n; i++) {
if (grade[i] == '.') {
ind = i;
break;
}
}
long long z = -1;
for (long long i = ind + 1; i < n; i++) {
if (grade[i] > '4') {
z = i;
break;
}
}
if (z != -1) {
grade.erase(z);
}
if (grade[grade.size() - 1] == '.') {
grade.erase(grade.size() - 1);
bool bl = false;
for (long long j = grade.size() - 1; j >= 0; j--) {
if (grade[j] == '9')
grade[j] = '0';
else {
grade[j]++;
bl = true;
break;
}
}
if (!bl) {
cout << '1';
}
cout << grade;
return;
}
long long rl = grade.size() - ind - 1;
t--;
long long p = min(rl, t);
long long i = grade.size() - 1;
long long z1 = -1;
while (p > 0) {
if (grade[i] > '3') {
z1 = i;
} else
break;
i--;
p--;
}
if (grade[i] == '.') {
grade.erase(i);
bool bl = false;
for (long long j = grade.size() - 1; j >= 0; j--) {
if (grade[j] == '9')
grade[j] = '0';
else {
grade[j]++;
bl = true;
break;
}
}
if (!bl) {
cout << '1';
}
cout << grade;
} else {
if (z != -1) {
if (z1 != -1) grade.erase(z1);
grade[grade.size() - 1]++;
}
cout << grade;
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long x;
int main() {
scanf("%I64d", &x);
x = -x;
x = x % 360;
x = (x + 360) % 360;
long long ans = min(x, 360 - x);
int sign = 0;
for (int i = 1; i < 4; i++) {
long long t = x + i * 90;
t = t % 360;
if (min(t, 360 - t) < ans) {
ans = min(t, 360 - t);
sign = i;
}
}
printf("%d\n", sign);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline char getch() {
static char buf[10000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 10000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long s = 0, f = 1;
char ch = getch();
while (ch < '0' || ch > '9') f = (ch == '-' ? -1 : 1), ch = getch();
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getch();
return s * f;
}
const int MaxN = 1e5 + 5;
struct Edge {
int to, nxt;
};
Edge e[MaxN << 1];
int h[MaxN], cnt;
void Link(int x, int y) {
e[++cnt] = (Edge){y, h[x]};
h[x] = cnt;
}
int n;
long long p, k, r, val[MaxN];
int in_0[MaxN], in_1[MaxN];
int out_0[MaxN], out_1[MaxN];
int siz[MaxN], rt, mx[MaxN];
int vis[MaxN], N;
long long ksm(long long x, long long y, long long p) {
long long res = 1;
x %= p;
y = (y + p - 1) % (p - 1);
for (; y; y >>= 1, x = x * x % p)
if (y & 1) res = res * x % p;
return res;
}
void getRt(int x, int fa) {
siz[x] = 1;
mx[x] = 0;
for (int i = h[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (y == fa || vis[y]) continue;
getRt(y, x);
siz[x] += siz[y];
mx[x] = max(mx[x], siz[y]);
}
mx[x] = max(mx[x], N - siz[x]);
if (mx[rt] > mx[x]) rt = x;
}
map<int, int> Map1, Map2;
int F0[MaxN], F1[MaxN];
int G0[MaxN], G1[MaxN];
int dep[MaxN];
long long inv[MaxN], Pow[MaxN];
void Dfs(int x, int fa, int rt) {
dep[x] = dep[fa] + 1;
F1[x] = (F1[fa] + 1ll * Pow[dep[x] - 1] * val[x] % p) % p;
F0[x] = (F1[x] - val[rt] + p) % p;
G1[x] = (1ll * G1[fa] * k % p + val[x]) % p;
G0[x] = (G1[x] - 1ll * Pow[dep[x] - 1] * val[rt] % p) % p;
G0[x] = 1ll * (r - G0[x] + p) % p * inv[dep[x] - 1] % p;
if (fa) {
Map1[F0[x]]++;
Map2[G0[x]]++;
}
for (int i = h[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (y == fa || vis[y]) continue;
Dfs(y, x, rt);
}
}
void Dec(int x, int fa) {
Map1[F0[x]]--;
Map2[G0[x]]--;
for (int i = h[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (y == fa || vis[y]) continue;
Dec(y, x);
}
}
void Get(int x, int fa, int rt) {
out_0[x] += Map1[1ll * (r - G1[x] + p) % p * inv[dep[x] - 1] % p];
in_0[x] += Map2[F1[x]];
if (G1[x] == r) out_0[x]++, in_0[rt]++;
if (F1[x] == r) in_0[x]++, out_0[rt]++;
for (int i = h[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (y == fa || vis[y]) continue;
Get(y, x, rt);
}
}
void Add(int x, int fa) {
Map1[F0[x]]++;
Map2[G0[x]]++;
for (int i = h[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (y == fa || vis[y]) continue;
Add(y, x);
}
}
void Calc(int x) {
Map1.clear();
Map2.clear();
Dfs(x, 0, x);
if (F1[x] == r) in_0[x]++, out_0[x]++;
for (int i = h[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (vis[y]) continue;
Dec(y, x);
Get(y, x, x);
Add(y, x);
}
}
void Divide(int x) {
Calc(x);
vis[x] = 1;
for (int i = h[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (vis[y]) continue;
mx[rt = 0] = n + 1;
N = siz[y];
getRt(y, 0);
Divide(rt);
}
}
int main() {
n = read(), p = read(), k = read(), r = read() % p;
for (int i = 1; i <= n; i++) val[i] = read() % p;
for (int i = 2; i <= n; i++) {
int u = read(), v = read();
Link(u, v);
Link(v, u);
}
Pow[0] = 1;
inv[0] = 1;
for (int i = 1; i <= n; i++) Pow[i] = Pow[i - 1] * k % p;
for (int i = 1; i <= n; i++) inv[i] = ksm(Pow[i], p - 2, p);
mx[rt = 0] = n + 1;
N = n;
getRt(1, 0);
Divide(rt);
long long Ans = 1ll * n * n * n;
long long res = 0;
for (int i = 1; i <= n; i++) {
out_1[i] = n - out_0[i];
in_1[i] = n - in_0[i];
}
for (int i = 1; i <= n; i++) {
res += 2ll * out_0[i] * out_1[i];
res += 1ll * out_0[i] * in_1[i];
res += 1ll * out_1[i] * in_0[i];
res += 2ll * in_0[i] * in_1[i];
}
cout << Ans - res / 2 << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int val = 0;
node *lc = nullptr, *rc = nullptr;
node() {}
node(int val) : val(val) {}
node(node *lc, node *rc) : lc(lc), rc(rc) {
val += lc->val;
val += rc->val;
}
};
typedef node *pnode;
const int maxa = 1e5 + 3, maxn = 1e5 + 3;
int n, k, q;
queue<int> qu[maxa];
int prevk[maxn];
pnode roots[maxn];
int last = 0;
pnode build(int l, int r) {
if (l == r) return new node;
int mid = (l + r) / 2;
return new node(build(l, mid), build(mid + 1, r));
}
pnode update(pnode p, int l, int r, int pos) {
if (l == r) return new node(p->val + 1);
int mid = (l + r) / 2;
if (pos <= mid)
return new node(update(p->lc, l, mid, pos), p->rc);
else
return new node(p->lc, update(p->rc, mid + 1, r, pos));
}
int query(pnode p, int l, int r, int lb, int rb) {
if (r < lb || l > rb) return 0;
if (l >= lb && r <= rb) return p->val;
int mid = (l + r) / 2;
return query(p->lc, l, mid, lb, rb) + query(p->rc, mid + 1, r, lb, rb);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
if (qu[a].size() < k)
prevk[i] = 0;
else {
prevk[i] = qu[a].front();
qu[a].pop();
}
qu[a].push(i);
}
roots[0] = build(0, n);
for (int i = 1; i <= n; i++) roots[i] = update(roots[i - 1], 0, n, prevk[i]);
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
int l = (x + last) % n + 1, r = (y + last) % n + 1;
if (l > r) swap(l, r);
last =
query(roots[r], 0, n, 0, l - 1) - query(roots[l - 1], 0, n, 0, l - 1);
cout << last << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char arr[50010];
int main() {
scanf("%s", arr);
int n = strlen(arr);
while (true) {
int _p = -1, len = 0;
for (int i = 1; i <= n / 2; ++i) {
int idx = 0;
for (int j = 0; j + (i << 1) <= n; ++j) {
while (arr[j + idx] == arr[j + idx + i]) idx++;
if (idx == i) {
_p = j;
len = i;
break;
}
idx = max(idx - 1, 0);
}
if (_p != -1) break;
}
if (_p == -1) break;
for (int i = _p + len; i <= n - len; ++i) arr[i] = arr[i + len];
n -= len;
}
puts(arr);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, i, c = -1;
cin >> n;
cin >> s;
for (i = 0; i < s.length(); i += n) {
if (s[i - 1] == s[i - 2] && s[i - 2] == s[i - 3]) c++;
}
cout << c << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> book1, book2;
int main() {
int n;
int a[2005];
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = 99999;
int p = 1, q = n;
while (p <= n) {
if (book1[a[p]]) {
break;
} else {
book1[a[p]] = p;
}
p++;
}
p--;
ans = n - p;
while (q >= 1) {
if (book2[a[q]]) {
if (ans > q - p) ans = q - p;
break;
} else {
book2[a[q]] = 1;
}
if (book1[a[q]] && p >= book1[a[q]]) {
if (ans > q - p) ans = q - p;
p = book1[a[q]] - 1;
}
q--;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int main() {
cin >> n >> x;
if (x % 2) {
cout << ((x - 1) / 2) + 1;
} else {
cout << ((n - x) / 2) + 1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long i, j, a[1010], n, x, s[4];
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
i = 1;
j = n;
x = 1;
while (i <= j) {
if (a[j] > a[i]) {
if (x % 2 == 1)
s[1] += a[j];
else
s[2] += a[j];
j--;
} else {
if (x % 2 == 1)
s[1] += a[i];
else
s[2] += a[i];
i++;
}
x++;
}
cout << s[1] << " " << s[2];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long n, long long mod) {
long long res = 1;
x %= mod;
while (n) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long c = 0, d = 0, i = 0, j = 0, k = 0, t = 0, n = 0, q = 0;
cin >> t;
while (t--) {
cin >> n;
pair<long long, long long> a, b;
string s[n];
for (long long i = 0; i < n; i++) {
cin >> s[i];
if (i == 1) a = make_pair(s[0][1] - '0', s[1][0] - '0');
if (i == n - 1)
b = make_pair(s[n - 1][n - 2] - '0', s[n - 2][n - 1] - '0');
}
long long ans = 0;
if (a.first + a.second == 2) {
if (b.first == 1) ans++;
if (b.second == 1) ans++;
cout << ans << "\n";
if (b.second) cout << n - 1 << " " << n << "\n";
if (b.first) cout << n << " " << n - 1 << "\n";
} else if (a.first + a.second == 0) {
if (b.first == 0) ans++;
if (b.second == 0) ans++;
cout << ans << "\n";
if (b.second == 0) cout << n - 1 << " " << n << "\n";
if (b.first == 0) cout << n << " " << n - 1 << "\n";
} else if (a.first + a.second == 1 && b.first + b.second == 1) {
cout << 2 << "\n";
if (a.first == 1) cout << 1 << " " << 2 << "\n";
if (a.second == 1) cout << 2 << " " << 1 << "\n";
if (b.first == 0) cout << n << " " << n - 1 << "\n";
if (b.second == 0) cout << n - 1 << " " << n << "\n";
} else if (a.first + a.second == 1 && b.first + b.second == 0) {
cout << 1 << "\n";
if (a.first == 0) cout << 1 << " " << 2 << "\n";
if (a.second == 0) cout << 2 << " " << 1 << "\n";
} else if (a.first + a.second == 1 && b.first + b.second == 2) {
cout << 1 << "\n";
if (a.first == 1) cout << 1 << " " << 2 << "\n";
if (a.second == 1) cout << 2 << " " << 1 << "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[11][11];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
a[1][i] = a[i][1] = 1;
}
for (int i = 2; i <= n; i++) {
for (int j = 2; j <= n; j++) {
a[i][j] = a[i - 1][j] + a[i][j - 1];
}
}
printf("%d", a[n][n]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
long long s, x;
vector<int> S, X;
vector<int> num(long long s) {
vector<int> res;
while (s > 0) {
res.push_back(s % 2);
s /= 2;
}
return res;
}
vector<int> add(vector<int> p, int len) {
int temp = p.size();
for (int i = temp; i < len; i++) p.push_back(0);
p.push_back(0);
return p;
}
int main() {
cin >> s >> x;
S = num(s);
X = num(x);
S = add(S, max(((int)(S).size()), ((int)(X).size())));
X = add(X, max(((int)(S).size()), ((int)(X).size())));
bool ok = true;
int c = 0;
long long ans = 1;
for (int i = 0; i < ((int)(S).size()) - 1; i++) {
if (X[i] == 1) {
if (S[i] == c) {
ok = false;
break;
}
ans = ans * 2;
} else {
if (S[i] != c) {
ok = false;
break;
} else {
if (S[i + 1] == X[i + 1]) {
c = 0;
} else {
c = 1;
}
}
}
}
if (c == 1) ok = false;
if (s == x) ans -= 2;
if (ok)
cout << ans << endl;
else
cout << "0" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int a[N];
int m, n;
long long C2(long long x) {
if (x < 2) return 0;
return x * (x - 1) / 2;
}
int dis(int x, int y) {
int d = x - y;
if (d < 0) d += 2 * m;
return d;
}
int main() {
scanf("%d%d", &m, &n);
for (int i = 0; i < n; i++) {
int x, s;
scanf("%d%d", &x, &s);
a[i] = x == 0 ? m - s : s + (m - s) * 2;
}
int t = a[0];
for (int i = 0; i < n; i++) a[i] = dis(a[i], t);
sort(a, a + n);
if (a[n - 1] == 0) {
cout << (long long)n * (n - 1) * (n - 2) / 6 << endl;
return 0;
}
int b = upper_bound(a, a + n, m) - a - 1;
int c = lower_bound(a, a + n, m) - a;
if (c == n || dis(a[c], a[b]) > m) {
if (c == n) c = 0;
long long cnt1 = 0;
for (int i = 0; i < n; i++)
if (a[i] == a[b]) cnt1++;
long long cnt2 = 0;
for (int i = 0; i < n; i++)
if (a[i] == a[c]) cnt2++;
long long ans = (n - cnt1 - cnt2) * cnt1 * cnt2;
ans += C2(cnt1) * cnt2;
ans += C2(cnt2) * cnt1;
cout << ans << endl;
return 0;
}
long long ans = (long long)n * (n - 1) * (n - 2) / 6;
int i = 0, j = 0, cnt = 0;
while (i < n) {
while (dis(a[j % n], a[i]) < m) {
ans -= C2(cnt);
if (j > n) ans += C2(j - n);
j++;
cnt++;
}
while (i < n && dis(a[j % n], a[i]) >= m) {
i++;
cnt--;
}
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
const int MX = 1e9 + 7;
const long long int INF = 1LL * MX * MX;
int n;
int First[N], Last[N];
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) First[i] = n + 1, Last[i] = 0;
for (int i = 1; i <= n; ++i) {
int a;
scanf("%d", &a);
First[a] = min(First[a], i);
Last[a] = max(Last[a], i);
}
int mx = 0, sum = 0;
int prv = 0, cur = 0;
for (int i = 1; i <= n; ++i) {
if (Last[i] == 0) continue;
++sum;
if (prv <= First[i])
++cur;
else
cur = 1;
prv = Last[i];
mx = max(mx, cur);
}
printf("%d\n", sum - mx);
}
int main() {
int quest;
scanf("%d", &quest);
while (quest--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 1;
long long w1, h1, w2, h2;
int main() {
cin >> w1 >> h1 >> w2 >> h2;
cout << w1 * 2 + h1 * 2 + 6 + (h2 - 1) * 2;
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.