solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
int a[maxn], b[maxn], d[maxn], n, cnt, ans, k;
struct nod {
int c, id;
} p[maxn];
inline bool cmp(const nod &A, const nod &B) { return A.c < B.c; }
bool vis[maxn];
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; ++i) scanf("%d %d", &a[i], &b[i]);
scanf("%d", &k);
for (int i = 1; i <= k; ++i) scanf("%d", &p[i].c), p[i].id = i;
sort(p + 1, p + 1 + k, cmp);
memset(vis, 0, sizeof(vis));
cnt = 0;
ans = 0;
for (int i = 1; i <= k; ++i) {
int res = 0, pos = -1;
for (int j = 1; j <= n; ++j)
if (p[i].c >= a[j] && res < b[j] && vis[j] == 0) {
res = b[j];
pos = j;
}
if (pos != -1) {
cnt++;
ans += res;
vis[pos] = 1;
d[pos] = p[i].id;
}
}
printf("%d %d\n", cnt, ans);
for (int i = 1; i <= n; ++i)
if (vis[i]) printf("%d %d\n", i, d[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
template <typename Arg1>
void ZZ(const char* name, Arg1&& arg1) {
std::cout << name << " = " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void ZZ(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cout.write(names, comma - names) << " = " << arg1;
ZZ(comma, args...);
}
using namespace std;
int n, q;
vector<int> bit;
void upd(int i, int add) {
while (i > 0 && i < (int)bit.size()) {
bit[i] += add;
i = i + (i & (-i));
}
}
int su(int i) {
int ans = 0;
while (i > 0) {
ans += bit[i];
i = i - (i & (-i));
}
return ans;
}
int findKthSmallest(int k) {
int l = 0;
int h = bit.size();
while (l < h) {
int mid = (l + h) / 2;
if (k <= su(mid))
h = mid;
else
l = mid + 1;
}
return l;
}
void insertElement(int x) { upd(x, 1); }
void deleteElement(int x) { upd(x, -1); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
bit.assign(n + 2, 0);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
insertElement(x);
}
for (int i = 0; i < q; i++) {
int x;
cin >> x;
if (x > 0) {
insertElement(x);
} else {
int kth = findKthSmallest(-x);
deleteElement(kth);
}
}
if (su(n + 1) == 0) {
cout << 0 << endl;
} else {
cout << findKthSmallest(1) << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, arr[100005];
int coun = 0;
int visited[100005];
vector<int> v[100005];
void dfs(int node, int f, int parent) {
visited[node] = 1;
if (arr[node]) f++;
if (f > m)
return;
else {
int len = v[node].size();
if (len == 1 && parent == v[node][0]) {
coun++;
return;
}
for (int i = 0; i < len; i++) {
int nodd = v[node][i];
if (visited[nodd] == 0) {
if (arr[nodd] == 0)
dfs(nodd, 0, node);
else
dfs(nodd, f, node);
}
}
}
return;
}
int main() {
int a, b;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n - 1; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1, 0, 0);
cout << coun << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int car[1001][1001];
long long si[1001] = {0}, sj[1001] = {0};
int main() {
int n, m, li, lj;
long long sumx, sumy;
scanf("%d %d", &n, &m);
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= m; i++) {
scanf("%d", &car[j][i]);
si[i] += car[j][i];
sj[j] += car[j][i];
}
}
sumx = sumy = 9223372036854775807;
for (int x = 0; x <= 4 * m; x += 4) {
long long tmp = 0;
for (int i = 1; i <= m; i++) {
tmp = tmp + si[i] * (x - 4 * i + 2) * (x - 4 * i + 2);
}
if (tmp < sumx) {
sumx = tmp;
lj = x / 4;
}
}
for (int y = 0; y <= 4 * n; y += 4) {
long long tmp = 0;
for (int j = 1; j <= n; j++) {
tmp = tmp + sj[j] * (y - 4 * j + 2) * (y - 4 * j + 2);
}
if (tmp < sumy) {
sumy = tmp;
li = y / 4;
}
}
printf("%I64d\n%d %d\n", sumx + sumy, li, lj);
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int N = 2e5 + 10;
using namespace std;
long long gcd(long long p, long long q) { return q == 0 ? p : gcd(q, p % q); }
long long qmul(long long p, long long q, long long mo) {
long long f = 0;
while (q) {
if (q & 1) f = (f + p) % mo;
p = (p + p) % mo;
q >>= 1;
}
return f;
}
long long qpow(long long p, long long q) {
long long f = 1;
while (q) {
if (q & 1) f = f * p;
p = p * p;
q >>= 1;
}
return f;
}
int n, m, k, t, ok[maxn];
set<int> p;
vector<pair<pair<int, int>, int>> pq;
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= (int)n; i++) {
int x, y;
scanf("%d%d", &x, &y);
pq.push_back(make_pair(make_pair(x, 1), i));
pq.push_back(make_pair(make_pair(y + 1, -1), i));
}
sort(pq.begin(), pq.end());
for (i = 0; i < pq.size(); i = j) {
for (j = i; j < pq.size() && pq[j].first.first == pq[i].first.first; j++) {
if (pq[j].first.second == 1)
p.insert(pq[j].second);
else
p.erase(pq[j].second);
}
if (p.size() == 1) ok[*p.begin()] = 1;
}
for (i = 1; i <= (int)n; i++)
if (!ok[i]) return 0 * printf("%d\n", i);
puts("-1");
return 0;
}
| 12 |
#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<set>
#include<vector>
#include<cmath>
#define PII pair<int,int>
#define pb push_back
#define ep emplace_back
#define mp make_pair
#define fi first
#define se second
using namespace std;
inline int read(){
int x=0,f=1;char c=getchar();
while(c<'0'||c>'9'){ if(c=='-') f=-1; c=getchar();}
while(c>='0'&&c<='9'){x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return f==1?x:~x+1;
}
inline void print(int x){
if(x<0) putchar('-'),x=~x+1;
if(x>=10) print(x/10);
putchar((x%10)|48);
}
int T;
int n;
int a[3010];
int dp[3010][3010];
int main(){
T=read();
while(T--){
n=read();
for(int i=1;i<=n;++i) a[i]=read();
for(int i=2;i<=n;++i){
for(int j=i-1;j<=n;++j) dp[i][j]=0x3f3f3f3f;
}
for(int i=2;i<=n;++i){
int cnt=0;
for(int j=i-1;j;--j){
if(j+a[j]>=i) dp[i][j+a[j]]=min(dp[i][j+a[j]],dp[j][i-1]+cnt),++cnt;
}
// if(!cnt) dp[i][i]=min(dp[i][i],cnt);
// printf("i:%d,cnt:%d\n",i,cnt);
for(int j=i;j<=n;++j){
dp[i][j]=min(dp[i][j],dp[i][j-1]);
}
}
printf("%d\n",dp[n][n]);
}
return 0;
} | 19 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long first) { cerr << first; }
void __print(long first) { cerr << first; }
void __print(unsigned first) { cerr << first; }
void __print(unsigned long first) { cerr << first; }
void __print(unsigned long long first) { cerr << first; }
void __print(float first) { cerr << first; }
void __print(double first) { cerr << first; }
void __print(long double first) { cerr << first; }
void __print(char first) { cerr << '\'' << first << '\''; }
void __print(const char *first) { cerr << '\"' << first << '\"'; }
void __print(const string &first) { cerr << '\"' << first << '\"'; }
void __print(bool first) { cerr << (first ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &first) {
cerr << '{';
__print(first.first);
cerr << ',';
__print(first.second);
cerr << '}';
}
template <typename T>
void __print(const T &first) {
long long f = 0;
cerr << '{';
for (auto &i : first) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void solve() {
string s;
cin >> s;
long long n = s.size();
long long l = 1, r = 0;
long long ans = 0;
vector<bool> vis(n, false);
while (l != n) {
if (s[l] == 'B') {
while (vis[r] == true && r < l) {
r += 1;
}
if (vis[r] == false && l != r) {
vis[r] = true;
vis[l] = true;
ans += 2;
r += 1;
}
}
l += 1;
}
cout << n - ans << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& _p) {
return os << "(" << _p.first << "," << _p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& _V) {
bool f = true;
os << "[";
for (auto v : _V) {
os << (f ? "" : ",") << v;
f = false;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& _S) {
bool f = true;
os << "(";
for (auto s : _S) {
os << (f ? "" : ",") << s;
f = false;
}
return os << ")";
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& _M) {
return os << set<pair<T, U>>(_M.begin(), _M.end());
}
const signed long long INF = 1000000100;
const long double EPS = 1e-9;
const int MAXN = 500010;
int N, Q;
vector<int> G[MAXN];
char buff[MAXN];
string A[MAXN];
vector<pair<int, int>> queries[MAXN];
void read_data() {
scanf("%d", &N);
for (int(i) = (1); (i) <= (N); (i)++) {
int a;
scanf("%s %d", buff, &a);
A[i] = string(buff);
G[a].push_back(i);
}
scanf("%d", &Q);
for (int(i) = (1); (i) <= (Q); (i)++) {
int w, h;
scanf("%d %d", &w, &h);
queries[w].push_back(make_pair(h, i));
}
}
int first[MAXN];
int x_v[MAXN];
int S[MAXN];
int H[MAXN];
int ts = 0;
map<string, int> M[MAXN];
int R[MAXN];
inline void modify(int v, int delta) {
int h = H[v];
const string& s = A[v];
M[h][s] += delta;
if (M[h][s] == 0) M[h].erase(s);
}
void dfs1(int v, int p, int h) {
first[v] = ++ts;
x_v[first[v]] = v;
S[v] = 1;
H[v] = h;
for (int u : G[v]) {
dfs1(u, v, h + 1);
S[v] += S[u];
}
}
void dfs2(int v, int p, bool keep) {
int w = -1;
int max_s = -1;
for (int u : G[v])
if (S[u] > max_s) {
max_s = S[u];
w = u;
}
for (int u : G[v])
if (u != w) dfs2(u, v, false);
if (w != -1) {
dfs2(w, v, true);
}
for (int u : G[v])
if (u != w)
for (int(i) = (first[u]); (i) <= (first[u] + S[u] - 1); (i)++) {
modify(x_v[i], 1);
}
modify(v, 1);
for (auto q : queries[v]) {
int h = H[v] + q.first;
int query_id = q.second;
R[query_id] = int(M[h].size());
}
if (!keep)
for (int(i) = (first[v]); (i) <= (first[v] + S[v] - 1); (i)++)
modify(x_v[i], -1);
}
void solve() {
dfs1(0, -1, 1);
dfs2(0, -1, false);
for (int(i) = (1); (i) <= (Q); (i)++) printf("%d\n", R[i]);
}
int main() {
read_data();
solve();
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, c;
int l[1000010], r[1000010], e[1000010];
bool mark[1000010];
void print(int idx) {
for (int i = idx + 1; i <= l[idx];) {
print(i);
i = e[i] + 1;
}
cout << idx + 1 << ' ';
for (int i = l[idx] + 1; i <= e[idx];) {
print(i);
i = e[i] + 1;
}
}
int main() {
cin >> n >> c;
int a, b;
string str;
for (int i = 0; i < n; i++) {
e[i] = l[i] = i;
r[i] = n;
}
for (int i = 0; i < c; i++) {
cin >> a >> b >> str;
a--, b--;
if (a >= b) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
if (str[0] == 'L')
l[a] = max(l[a], b);
else
r[a] = min(r[a], b);
e[a] = max(e[a], b);
}
for (int idx = n - 1; idx >= 0; idx--) {
for (int i = idx + 1; i <= l[idx];) {
l[idx] = max(l[idx], e[i]);
i = e[i] + 1;
}
e[idx] = max(e[idx], l[idx]);
for (int i = l[idx] + 1; i <= e[idx];) {
e[idx] = max(e[idx], e[i]);
i = e[i] + 1;
}
if (r[idx] <= l[idx]) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
}
memset(mark, false, sizeof mark);
e[0] = n - 1;
print(0);
cout << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int __SIZE = (1 << 21) + 1;
char ibuf[__SIZE], *iS, *iT, obuf[__SIZE], *oS = obuf, *oT = oS + __SIZE - 1,
__c, qu[55];
int __f, qr, _eof;
inline void flush() { fwrite(obuf, 1, oS - obuf, stdout), oS = obuf; }
inline void gc(char &x) {
x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void pc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
inline void pstr(const char *s) {
int __len = strlen(s);
for (__f = 0; __f < __len; ++__f) pc(s[__f]);
}
inline void gstr(char *s) {
for (__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
__c < 32 || __c > 126 || __c == ' ';)
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
for (; __c > 31 && __c < 127 && __c != ' ';
++s, __c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
*s = __c;
*s = 0;
}
template <class I>
inline bool gi(I &x) {
_eof = 0;
for (__f = 1,
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
(__c < '0' || __c > '9') && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) {
if (__c == '-') __f = -1;
_eof |= __c == EOF;
}
for (x = 0; __c <= '9' && __c >= '0' && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (__c & 15), _eof |= __c == EOF;
x *= __f;
return !_eof;
}
template <class I>
inline void print(I x) {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) pc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io::gc;
using io::gi;
using io::gstr;
using io::pc;
using io::print;
using io::pstr;
template <typename T>
inline void chkmax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
inline void chkmin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
inline T gcd(T &a, T b) {
return !b ? a : gcd(b, a % b);
}
const int mod = 1000000007;
template <typename T>
const T Mod(T x) {
return x >= mod * 2 ? x % mod : (x >= mod ? x - mod : x);
}
template <typename T>
const void Add(T &a, T b) {
a = Mod(a + b);
}
const int MAXN = 200100;
int n, k, d;
int a[MAXN];
int res = 1;
int res_l = 1;
int res_r = 1;
struct Segment_Tree {
struct Node {
long long v, t;
} T[MAXN << 2];
inline void pushup(int x) { T[x].v = min(T[(x << 1)].v, T[(x << 1 | 1)].v); }
inline void pushdown(int x) {
long long &t = T[x].t;
if (!t) return;
T[(x << 1)].v += t, T[(x << 1)].t += t;
T[(x << 1 | 1)].v += t, T[(x << 1 | 1)].t += t;
t = 0;
}
inline void build(int x, int l, int r) {
T[x].v = T[x].t = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r);
}
inline void Modify(int x, int l, int r, int L, int R, long long v) {
if (L <= l && r <= R) return T[x].v += v, T[x].t += v, void();
int mid = (l + r) >> 1;
pushdown(x);
if (L <= mid) Modify((x << 1), l, mid, L, R, v);
if (mid < R) Modify((x << 1 | 1), mid + 1, r, L, R, v);
pushup(x);
}
inline int Find(int x, int l, int r, int p) {
if (l == r) return T[x].v <= k ? l : -1;
int mid = (l + r) >> 1;
pushdown(x);
if (T[(x << 1)].v <= k) return Find((x << 1), l, mid, p);
if (mid < p) return Find((x << 1 | 1), mid + 1, r, p);
return -1;
}
} seg;
int b[MAXN];
map<int, int> pos;
stack<int> up, down;
inline void solve(int l, int r) {
for (int i = l; i <= r; i++) a[i - l + 1] = b[i] / d;
int n = r - l + 1, las = 0;
seg.build(1, 1, n), pos.clear();
for (int i = 1; i <= n; i++) {
int v = a[i];
if (pos.count(v)) {
seg.Modify(1, 1, n, las + 1, pos[v], 1000000000);
las = pos[v];
}
pos[v] = i;
seg.Modify(1, 1, n, 1, n, -1);
seg.Modify(1, 1, n, i, i, i);
while (up.top() && a[up.top()] > v) {
int p = up.top();
up.pop();
seg.Modify(1, 1, n, up.top() + 1, p, a[p]);
}
seg.Modify(1, 1, n, up.top() + 1, i, -v);
up.push(i);
while (down.top() && a[down.top()] < v) {
int p = down.top();
down.pop();
seg.Modify(1, 1, n, down.top() + 1, p, -a[p]);
}
seg.Modify(1, 1, n, down.top() + 1, i, v);
down.push(i);
int L = seg.Find(1, 1, n, i);
if ((~L) && res < i - L + 1)
res = i - L + 1, res_l = L + l - 1, res_r = i + l - 1;
}
while (up.top()) up.pop();
while (down.top()) down.pop();
}
int main() {
gi(n), gi(k), gi(d);
if (d == 0) {
int len = 1, now = -1, x = 0, pos = 0, L = 1, R = 1;
for (int i = 1; i <= n; i++) {
gi(x);
if (x != now) {
if (len < i - pos) len = i - pos, L = pos, R = i - 1;
now = x, pos = i;
}
}
if (len < n - pos + 1) L = pos, R = n;
print(L), pc(' '), print(R), pc('\n');
return 0;
}
int mi = 2147483647;
for (int i = 1; i <= n; i++) gi(b[i]), chkmin(mi, b[i]);
for (int i = 1; i <= n; i++) b[i] -= mi - 1;
int las = b[1] % d, pos = 1;
up.push(0), down.push(0);
for (int i = 2; i <= n + 1; i++)
if (las != b[i] % d || i == n + 1)
solve(pos, i - 1), pos = i, las = b[i] % d;
print(res_l), pc(' '), print(res_r), pc('\n');
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int c[1001000];
int main() {
int a[100010], a2[100010];
int b[100100], b2[100100], n, m;
while (cin >> n) {
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
if (i == 0)
a2[i] = a[i];
else
a2[i] = a[i] + a2[i - 1];
}
cin >> m;
for (i = 0; i < m; i++) {
cin >> b[i];
b2[i] = b[i];
}
sort(b2, b2 + m);
int j = 0;
for (i = 0; i < m; i++) {
while (1) {
if (b2[i] <= a2[j]) {
c[b2[i]] = j + 1;
break;
} else
j++;
}
}
for (i = 0; i < m; i++) {
cout << c[b[i]] << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t, n, k, x, y, m;
cin >> t;
while (t--) {
cin >> n >> k;
cin >> x;
m = x;
k--;
while (k--) {
cin >> y;
m = max(m, (y - x) / 2 + 1);
x = y;
}
m = max(m, n - x + 1);
cout << m << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void file_open() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
char a[200] = {}, result1[200] = {}, result2[200] = {};
scanf("%s", a);
int n = strlen(a);
int k, l;
k = n;
l = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == '.') {
k = i;
break;
}
}
l = 0;
--k;
for (int i = k; i >= 0; --i) {
if (a[i] == '-') break;
result1[l++] = a[i];
if (i != k && ((k - i + 1) % 3) == 0) result1[l++] = ',';
}
if (result1[l - 1] == ',') result1[l - 1] = 0;
l = 0;
for (int i = k + 2; i < n; ++i) {
result2[l++] = a[i];
if (l == 2) break;
}
if (l < 2)
while (l < 2) result2[l++] = '0';
if (a[0] == '-') {
printf("($");
l = strlen(result1);
for (int i = l - 1; i >= 0; --i) printf("%c", result1[i]);
printf(".%s)", result2);
} else {
printf("$");
l = strlen(result1);
for (int i = l - 1; i >= 0; --i) printf("%c", result1[i]);
printf(".%s", result2);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int maxi[101][101];
int v[101];
int r[101];
int main() {
int n, m, x, t = 0;
char c;
cin >> n >> m;
for (int i = 0; i < n; i++) {
r[i] = 0;
}
for (int i = 0; i < m; i++) {
v[i] = 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> c;
maxi[i][j] = c - '0';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (maxi[i][j] >= v[j]) {
v[j] = maxi[i][j];
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (maxi[i][j] == v[j]) {
r[i] = 1;
}
}
}
for (int i = 0; i < n; i++) {
t += r[i];
}
cout << t << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
int q = sqrt(n);
for (int(i) = (2); (i) <= (q); (i)++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
n *= i;
}
}
cout << n;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string a, b;
cin >> a >> b;
int cost = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] == b[i]) continue;
if (a[i] != b[i] && a[i + 1] != b[i + 1] && a[i] != a[i + 1]) {
swap(a[i], a[i + 1]);
cost++;
} else {
cost++;
}
}
if (a[n - 1] != b[n - 1]) cost++;
cout << cost;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int score;
string name;
int operator<(const node &o) const {
return score > o.score || score == o.score && name < o.name;
}
};
int c[101010], fa[101010], ans;
int z[101010];
int n, m, cur, now, x, y, N;
pair<int, string> b[101010];
node a[101010];
node v, tmp;
string s;
int cmp(int a, int b) { return a > b; }
int OK(int x) { return (z[x] == x) ? x : z[x] = OK(z[x]); }
int ok(int x) { return (fa[x] == x) ? x : fa[x] = ok(fa[x]); }
node add(node cur, int x) {
node ans = cur;
ans.score += x;
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> b[i].second;
scanf("%d", &b[i].first);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &c[i]);
sort(c + 1, c + 1 + m, cmp);
for (int i = m + 1; i <= n; i++) c[i] = 0;
cin >> s;
N = 0;
for (int i = 1; i <= n; i++)
if (b[i].second != s) {
v.score = b[i].first;
v.name = b[i].second;
a[++N] = v;
} else
cur = b[i].first;
sort(a + 1, a + 1 + N);
v.name = s;
v.score = cur + c[1];
now = 1;
ans = 0;
x = N + 1, y = N;
for (int i = 1; i <= N; i++)
if (a[i] < v)
now++, ans++;
else {
x = i;
break;
}
for (int i = x - 1; i <= y; i++) fa[i] = i;
for (int i = x; i <= y; i++) z[i] = i;
for (; now < n;) {
int L = x, R = y, mid, o = -1;
now++;
while (L <= R) {
mid = (L + R) / 2;
int Candy = ok(mid);
if (Candy >= x && v < add(a[Candy], c[now]))
o = mid, R = mid - 1;
else
L = mid + 1;
}
if (o == -1) o = OK(x), ans++;
fa[o] = o - 1;
z[o] = o + 1;
}
cout << ans + 1 << " ";
v.name = s;
v.score = cur + c[n];
now = n;
ans = 0;
x = N + 1, y = N;
for (int i = 1; i <= N; i++)
if (a[i] < v)
now--, ans++;
else {
x = i;
break;
}
for (int i = x; i <= y + 1; i++) fa[i] = i;
for (int i = x; i <= y; i++) z[i] = i;
for (; now > 1;) {
int L = x, R = y, mid, o = -1;
now--;
while (L <= R) {
mid = (L + R) / 2;
int Candy = ok(mid);
if (Candy <= y && add(a[Candy], c[now]) < v)
o = mid, L = mid + 1;
else
R = mid - 1;
}
if (o == -1)
o = OK(y);
else
ans++;
fa[o] = o + 1;
z[o] = o - 1;
}
cout << ans + 1 << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int M = 1000000007;
const double eps = 1e-9;
const double PI = acos(-1);
const int oo = 1000000000;
int R, C, rr[3001][3001], ll[3001][3001], dd[3001][3001], fen[3001], l, r;
vector<int> k;
vector<pair<int, int> > v;
char g[3001][3001];
void add(int i) {
for (; i < 3001; i += i & -i) ++fen[i];
}
int get(int i) {
int res = 0;
for (; i; i -= i & -i) res += fen[i];
return res;
}
int main() {
cin >> R >> C;
for (int i = 1; i <= R; ++i) scanf("%s", g[i] + 1);
for (int i = 1; i <= R; ++i)
for (int j = 1; j <= C; ++j)
if (g[i][j] == 'z')
ll[i][j] = 1 + ll[i][j - 1], dd[i][j] = 1 + dd[i - 1][j + 1];
for (int i = 1; i <= R; ++i)
for (int j = C; j; --j)
if (g[i][j] == 'z') rr[i][j] = 1 + rr[i][j + 1];
long long ans = 0;
for (int a = 1, b = 1; b <= C; a < R ? ++a : ++b) {
v.clear();
k.clear();
k.resize(a + 1);
for (int i = a, j = b; i > 0 && j <= C; --i, ++j) {
if (g[i][j] == '.') continue;
int p = min(rr[i][j] - 1, dd[i][j] - 1);
v.push_back(pair<int, int>(i - p, i));
k[i] = min(R, i + ll[i][j] - 1);
}
sort((v).begin(), (v).end());
memset(fen, 0, sizeof(fen));
int p = 1;
for (int t = 0; t < v.size(); ++t) {
int d = v[t].first;
while (p < d) {
if (k[p]) ans += get(k[p]) - get(p - 1);
++p;
}
add(v[t].second);
}
while (p < k.size()) {
if (k[p]) ans += get(k[p]) - get(p - 1);
++p;
}
}
cout << ans << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
vector<int> g[20][10004];
int vis[10004], p;
int mat[10004];
inline bool kuhn(int x, int now) {
if (vis[x] == now) return 0;
vis[x] = now;
for (int i = 0; i < g[p][x].size(); i++) {
int y = g[p][x][i];
if (mat[y] == -1 || kuhn(mat[y], now)) {
mat[y] = x;
return 1;
}
}
return 0;
}
pair<int, pair<int, int> > edge[100005];
int cst[100005];
int main() {
int n, m, x, y, z, cnt = 0;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++)
scanf("%d %d %d", &edge[i].second.first, &edge[i].second.second,
&edge[i].first);
sort(edge, edge + m);
for (int i = 0; i < m; i++) {
cst[++cnt] = edge[i].first;
x = edge[i].first;
while (i < m && edge[i].first == x) i++;
i--;
}
int lo = 1, hi = cnt, res = -1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
for (int i = 0; i < m && edge[i].first <= cst[mid]; i++)
g[p][edge[i].second.first].emplace_back(edge[i].second.second);
memset(mat, -1, sizeof mat);
memset(vis, 0, sizeof vis);
bool f = 1;
for (int i = 1; i <= n && f; i++) f = kuhn(i, i);
if (f)
res = cst[mid], hi = mid - 1;
else
lo = mid + 1;
p++;
}
printf("%d\n", res);
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int mn = 1050;
long long t[2][2] = {{1, 1}, {1, 0}};
long long v, mo, f[2][2], c[2][2], x[2][2];
long long s[mn], s1[mn], h, L, ans;
int n, m, i, j, k;
long long S(long long a, long long b) {
long long res = 0, L = 1LL << 60;
while (L) {
res = res * 2 % mo;
if ((b & L) != 0) res = (res + a) % mo;
L >>= 1;
}
return res;
}
void mul(long long a[][2], long long b[][2], long long c[][2]) {
int i, j, k;
for (i = 0; i <= 1; ++i)
for (j = 0; j <= 1; ++j) {
c[i][j] = 0;
for (k = 0; k <= 1; ++k) c[i][j] = (c[i][j] + S(a[i][k], b[k][j])) % mo;
}
}
void dg(long long n) {
if (n == 1) return;
dg(n / 2);
mul(x, x, c);
if (n % 2)
mul(c, t, x);
else
memcpy(x, c, sizeof c);
}
long long query(long long n) {
if (n == 0) return 0;
memset(f, 0, sizeof f);
f[0][0] = 1, f[1][0] = 0;
memcpy(x, t, sizeof t);
dg(n);
mul(x, f, c);
return c[1][0];
}
int main() {
scanf("%I64d", &v);
L = 60, mo = 10;
for (i = 0; i <= 59; ++i)
if (query(i) == v % mo) s[++n] = i;
for (i = 1; i <= 12; ++i) {
mo *= 10;
m = 0;
for (j = 1; j <= n; ++j)
for (k = 0; k <= 9; ++k) {
h = k * L + s[j];
if (query(h) == v % mo) s1[++m] = h;
}
L *= 10, n = m, memcpy(s, s1, sizeof s1);
}
if (!n) {
printf("-1\n");
return 0;
}
ans = s[1];
for (i = 2; i <= n; ++i)
if (s[i] < ans) ans = s[i];
printf("%I64d\n", ans);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
long long S[1200008];
long long A[300002];
int n;
void add(int l, int r, int num, int id = 1, int sl = 0, int sr = n + 1) {
if (r <= sl or sr <= l) return;
if (l <= sl and sr <= r) {
S[id] += num;
return;
}
int mid = (sl + sr) / 2;
S[2 * id] += S[id];
S[2 * id + 1] += S[id];
S[id] = 0;
add(l, r, num, 2 * id, sl, mid);
add(l, r, num, 2 * id + 1, mid, sr);
}
void get(int ind, int id = 1, int l = 0, int r = n + 1) {
if (l > ind or ind >= r) return;
if (r - l < 2) {
A[l] += S[id];
S[id] = 0;
return;
}
S[2 * id] += S[id];
S[2 * id + 1] += S[id];
S[id] = 0;
int mid = (l + r) / 2;
get(ind, 2 * id, l, mid);
get(ind, 2 * id + 1, mid, r);
}
multiset<int> ma;
map<int, pair<int, int> > inters;
void zp(int ind) {
auto it = inters.insert(make_pair(ind, make_pair(ind + 1, ind + 1))).first;
auto nx = next(it);
if (nx != inters.end()) {
if (it->second.second == nx->first) {
it->second = nx->second;
ma.erase(ma.find(nx->second.second - nx->first));
inters.erase(nx);
}
}
if (it != inters.begin()) {
auto pv = prev(it);
if (pv->second.first == it->first) {
ma.erase(ma.find(pv->second.second - pv->first));
pv->second = it->second;
ma.insert(pv->second.second - pv->first);
inters.erase(it);
} else
ma.insert(it->second.second - it->first);
} else
ma.insert(it->second.second - it->first);
}
void zn(int ind) {
auto it = inters.insert(make_pair(ind, make_pair(ind, ind + 1))).first;
auto nx = next(it);
if (nx != inters.end()) {
if (it->second.second == nx->second.first) {
it->second.second = nx->second.second;
ma.erase(ma.find(nx->second.second - nx->first));
inters.erase(nx);
}
}
if (it != inters.begin()) {
auto pv = prev(it);
if (pv->second.second == it->first) {
ma.erase(ma.find(pv->second.second - pv->first));
pv->second.second = it->second.second;
ma.insert(pv->second.second - pv->first);
inters.erase(it);
} else
ma.insert(it->second.second - it->first);
} else
ma.insert(it->second.second - it->first);
}
void pz(int ind) {
auto it = prev(inters.upper_bound(ind));
auto nx = make_pair(ind + 1, it->second);
ma.erase(ma.find(it->second.second - it->first));
it->second = pair<int, int>(ind, ind);
if (it->second.second - it->first == 0)
inters.erase(it);
else
ma.insert(it->second.second - it->first);
if (nx.second.second - nx.first > 0)
inters.insert(nx), ma.insert(nx.second.second - nx.first);
}
void nz(int ind) {
auto it = prev(inters.upper_bound(ind));
auto nx = make_pair(ind + 1, it->second);
ma.erase(ma.find(it->second.second - it->first));
it->second.second = ind;
nx.second.first = ind + 1;
if (it->second.second - it->first == 0)
inters.erase(it);
else
ma.insert(it->second.second - it->first);
if (nx.second.second - nx.first > 0)
inters.insert(nx), ma.insert(nx.second.second - nx.first);
}
void query(int l, int r, int d) {
if (!d) return;
long long a, b;
get(l - 1);
get(r + 1);
get(l);
if (l != r) get(r);
a = A[l] - A[l - 1];
b = A[r + 1] - A[r];
add(l, r + 1, d);
A[l] += d;
if (l != r) A[r] += d;
if (l - 1 >= 1) {
if (a < 0) {
if (A[l] == A[l - 1])
nz(l - 1);
else if (A[l] > A[l - 1]) {
nz(l - 1);
zp(l - 1);
};
} else if (a == 0)
zp(l - 1);
}
if (r < n) {
if (b > 0) {
if (A[r + 1] == A[r])
pz(r);
else if (A[r + 1] < A[r]) {
pz(r);
zn(r);
};
} else if (b == 0)
zn(r);
}
A[l] -= d;
if (l != r) A[r] -= d;
}
int main() {
scanf("%d", &n);
int cur;
ma.insert(0);
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &A[i]);
}
for (int i = 1; i < n;) {
if (A[i] != A[i + 1]) {
int ind = i;
for (; i < n and A[i] < A[i + 1]; ++i)
;
pair<int, int> res(i, 0);
for (; i < n and A[i] > A[i + 1]; ++i)
;
res.second = i;
inters[ind] = res;
ma.insert(i - ind);
} else
++i;
}
int m, l, r, d;
scanf("%d", &m);
while (m--) {
scanf("%d %d %d", &l, &r, &d);
query(l, r, d);
printf("%d\n", *ma.rbegin() + 1);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int N;
int arr[2004];
int cnt[2004], acnt, val;
vector<int> vc;
int ans;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d", arr + i);
vc.push_back(arr[i]);
}
sort(vc.begin(), vc.end());
vc.erase(unique(vc.begin(), vc.end()), vc.end());
for (int i = 1; i <= N; ++i) {
arr[i] = lower_bound(vc.begin(), vc.end(), arr[i]) - vc.begin() + 1;
++cnt[arr[i]];
if (cnt[arr[i]] == 2) ++acnt;
}
ans = (int)1e9;
if (val == acnt) ans = 0;
for (int i = 1; i <= N; ++i) {
for (int j = i; j <= N; ++j) {
--cnt[arr[j]];
if (cnt[arr[j]] == 1) ++val;
if (val == acnt && j - i + 1 < ans) {
ans = j - i + 1;
}
}
for (int j = i; j <= N; ++j) {
++cnt[arr[j]];
}
val = 0;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
char s[N], t[N], S[N];
int fail[N];
int main() {
int n, m, i, j;
scanf("%s%s", s, t);
n = strlen(s), m = strlen(t);
int cnt0 = 0, cnt1 = 0;
for (i = 0; i < n; i++) {
if (s[i] == '0') {
cnt0++;
} else {
cnt1++;
}
}
int c0 = 0, c1 = 0;
for (i = 0; i < m; i++) {
if (t[i] == '0') {
c0++;
} else {
c1++;
}
}
if (cnt0 < c0 || cnt1 < c1) {
printf("%s", s);
return 0;
}
fail[0] = fail[1] = 0;
for (i = 1, j = 0; i < m; i++) {
while (j > 0 && t[j] != t[i]) {
j = fail[j];
}
if (t[j] == t[i]) {
j++;
}
fail[i + 1] = j;
}
printf("%s", t);
cnt0 -= c0, cnt1 -= c1;
int p0 = 0, p1 = 0, h = 0;
for (i = fail[m]; i < m; i++) {
if (t[i] == '0') {
p0++;
} else {
p1++;
}
S[h++] = t[i];
}
while (cnt0 >= p0 && cnt1 >= p1) {
printf("%s", S);
cnt0 -= p0, cnt1 -= p1;
}
while (cnt0 > 0) {
printf("0");
cnt0--;
}
while (cnt1 > 0) {
printf("1");
cnt1--;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-10;
const double Pi = acos(-1.0);
int main() {
int n, ss[maxn];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &ss[i]);
}
sort(ss, ss + n);
for (int i = 0; i + 2 < n; i++) {
if (ss[i] + ss[i + 1] > ss[i + 2]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
int cao;
struct node {
node *f, *next[26];
int len;
int id;
node() {}
node(int x) {
f = 0;
id = 1;
len = x;
memset(next, 0, sizeof(next));
}
} v[500005];
node *now;
node *root;
node *newnode(int x) {
v[cao] = node(x);
return &v[cao++];
}
void init() {
cao = 0;
root = now = newnode(0);
}
void gao(int x) {
node *p = now;
node *np = newnode(p->len + 1);
while (p && p->next[x] == 0) {
p->next[x] = np;
p = p->f;
}
if (p == 0)
np->f = root;
else {
node *q = p->next[x];
if (q->len == p->len + 1)
np->f = q;
else {
node *nq = newnode(p->len + 1);
nq->f = q->f;
q->f = nq;
np->f = nq;
nq->id = 0;
memcpy(nq->next, q->next, sizeof(q->next));
while (p && p->next[x] == q) {
p->next[x] = nq;
p = p->f;
}
}
}
now = np;
}
vector<int> so[500005];
char ch[100005];
long long a[500005];
long long b[500005];
void dfs1(int x) {
a[x] = v[x].id;
for (int i = 0; i < so[x].size(); i++) {
int y = so[x][i];
dfs1(y);
a[x] += a[y];
}
}
long long dfs(int x) {
if (b[x] != -1) return b[x];
b[x] = a[x];
for (int i = 0; i <= 25; i++) {
if (v[x].next[i] == 0) continue;
int y = v[x].next[i] - v;
b[x] += dfs(y);
}
return b[x];
}
long long rt;
char sta[100005];
int top;
int run() {
top = 0;
int x = 0;
if (rt > b[0]) {
return 0;
}
while (1) {
if (rt <= a[x]) return 1;
rt -= a[x];
for (int i = 0; i <= 25; i++) {
if (v[x].next[i] == 0) continue;
int y = v[x].next[i] - v;
if (rt <= b[y]) {
sta[top++] = 'a' + i;
x = y;
break;
} else
rt -= b[y];
}
}
}
int main() {
init();
scanf("%s", ch);
scanf("%I64d", &rt);
int l = strlen(ch);
for (int i = 0; i < l; i++) gao(ch[i] - 'a');
for (int i = 0; i < cao; i++) so[i].clear();
for (int i = 1; i < cao; i++) so[v[i].f - v].push_back(i);
dfs1(0);
a[0] = 0;
memset(b, -1, sizeof(b));
dfs(0);
int z = run();
if (z == 0)
printf("No such line.\n");
else {
sta[top] = '\0';
printf("%s\n", sta);
}
}
| 13 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin>>T;
for(int t=0;t<T;t++)
{
int n;
cin>>n;
vector<long long int>A,B;
for(int i=0;i<n;i++)
{
int x;cin>>x;
if(x%2) B.push_back(x);
else A.push_back(x);
}
sort(A.begin(),A.end());
sort(B.begin(),B.end());
int turn=0;
long long int Alice=0,Bob=0;
while(A.size()||B.size())
{
int a=A.size();
int b=B.size();
if(a&&b)
{
if(A[a-1]>B[b-1])
{
if(turn%2==0)
{
Alice+=A[a-1];
}
A.erase(A.end()-1,A.end());
}
else
{
if(turn%2)
{
Bob+=B[b-1];
}
B.erase(B.end()-1,B.end());
}
}
else if(a)
{
if(turn%2==0)
{
Alice+=A[a-1];
}
A.erase(A.end()-1,A.end());
}
else
{
if(turn%2)
{
Bob+=B[b-1];
}
B.erase(B.end()-1,B.end());
}
turn++;
}
if(Alice>Bob) cout<<"Alice\n";
else if(Bob>Alice) cout<<"Bob\n";
else cout<<"Tie\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
set<char> st;
char m;
while (k--) {
cin >> m;
st.insert(m);
}
long long c = 0, ans = 0;
for (long long i = 0; i < s.size(); i++) {
if (st.find(s[i]) != st.end()) {
c++;
} else {
ans += (c * (c + 1)) / 2;
c = 0;
}
}
if (c != 0) {
ans += (c * (c + 1)) / 2;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a0[200100], a1[200100], b0[200100], b1[200100];
int main() {
long long ans = 0;
string a, b, c;
int n;
cin >> a >> b;
n = b.size() - a.size() + 1;
if (n > 1) {
a0[0] = b0[0] = a1[0] = b1[0] = 0;
for (int i = 1; i <= b.size(); i++) {
if (b[i - 1] == '0')
b0[i] = b0[i - 1] + 1, b1[i] = b1[i - 1];
else
b1[i] = b1[i - 1] + 1, b0[i] = b0[i - 1];
}
for (int i = 1; i <= a.size(); i++) {
if (a[i - 1] == '0')
a0[i] = a0[i - 1] + 1, a1[i] = a1[i - 1];
else
a1[i] = a1[i - 1] + 1, a0[i] = a0[i - 1];
}
for (int i = 0; i < a.size(); i++) {
if (a[i] == '0')
ans += b1[b.size() - a.size() + i + 1] - b1[i];
else
ans += b0[b.size() - a.size() + i + 1] - b0[i];
}
} else {
for (int i = 0; i < b.size(); i++)
if (a[i] != b[i]) ans++;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int memo[500][26][26];
int son[500][26][26];
int cambios[500][26][26];
string A[500];
int m, n;
void solve(int x, int y, int z) {
for (int row = 0; row < x; row++)
for (int a = 0; a < y; a++)
for (int b = 0; b < z; b++) {
int &res = memo[row][a][b];
int &aux = son[row][a][b];
if (row == 0) {
res = cambios[0][a][b];
continue;
}
int mn = 1 << 29;
for (int i = 0; i < 26; i++)
if (i != a)
for (int j = 0; j < 26; j++)
if (j != b) {
int tmp = memo[row - 1][i][j] + cambios[row][a][b];
if (mn > tmp) mn = tmp, aux = 1000 * i + j;
}
res = mn;
}
}
int main() {
while (cin >> m >> n) {
memset(memo, -1, sizeof(memo));
string cad;
for (int i = 0; i < m; i++) cin >> A[m - 1 - i];
for (int row = 0; row < m; row++) {
for (int a = 0; a < 26; a++)
for (int b = 0; b < 26; b++)
if (b != a) {
int s = 0;
for (int k = 0; k < n; k++) {
if ((k & 1) == 0 && A[row][k] - 'a' != a) s++;
if ((k & 1) == 1 && A[row][k] - 'a' != b) s++;
}
cambios[row][a][b] = s;
} else
cambios[row][a][b] = 1 << 29;
}
solve(m, 26, 26);
int mn = 1 << 29;
int a, b;
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
if (j != i) {
if (mn > memo[m - 1][i][j]) mn = memo[m - 1][i][j], a = i, b = j;
}
printf("%d\n", mn);
for (int row = m - 1; row >= 0; row--) {
for (int i = 0; i < n; i++) {
if ((i & 1) == 0)
cout << char(a + 'a');
else
cout << char(b + 'a');
}
cout << endl;
int tmp = son[row][a][b];
a = tmp / 1000;
b = tmp % 1000;
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int cnt[N * 2], mp[N * 2], arr[N], arr1[N], ans[N];
int main() {
int n, m, p;
cin >> n >> m >> p;
for (int i = 0; i < n; i++) cin >> arr[i], mp[i] = arr[i];
for (int i = 0; i < m; i++) cin >> arr1[i], mp[i + n] = arr1[i];
sort(mp, mp + n + m);
int sz = unique(mp, mp + n + m) - mp, dist = 0;
for (int i = 0; i < m; i++) {
int newVal = lower_bound(mp, mp + sz, arr1[i]) - mp;
dist += cnt[newVal] == 0;
cnt[newVal]++;
}
int element = 0, idx = 0;
for (int st = 0; st < p; st++) {
int j = st - p;
for (int i = st; i < n; i += p) {
while (element < m && (j += p) < n) {
element++;
int newVal = lower_bound(mp, mp + sz, arr[j]) - mp;
cnt[newVal]--;
dist -= cnt[newVal] == 0;
}
if (dist == 0) ans[idx++] = i + 1;
int newVal = lower_bound(mp, mp + sz, arr[i]) - mp;
element--;
dist += cnt[newVal] == 0;
cnt[newVal]++;
}
}
cout << idx << '\n';
sort(ans, ans + idx);
for (int i = 0; i < idx; i++) cout << ans[i] << ' ';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
int p;
struct mb {
int s, len, t, id;
void rd(int i) {
id = i;
scanf("%d%d%d", &s, &len, &t);
}
bool operator<(const mb& o) const { return s < o.s; }
} a[33];
pair<int, int> b[33];
int dp[(1 << 22)];
int l[33], r[33];
int path[(1 << 22)], tp[33], tt[33];
void cal(int w, int sta) {
while (sta) {
int i = path[sta];
tp[a[i].id] = w;
tt[a[i].id] = dp[sta] - a[i].t;
sta -= 1 << i;
}
}
void ppt() {
puts("YES");
for (int(i) = 0; (i) < (int)(n); (i)++) printf("%d %d\n", tp[i], tt[i]);
exit(0);
}
void fmain(int ID) {
scanf("%d%d", &n, &p);
for (int(i) = 0; (i) < (int)(n); (i)++) {
a[i].rd(i);
}
sort(a, a + n);
for (int(i) = 0; (i) < (int)(n); (i)++) {
b[i] = {a[i].t, i};
}
sort(b, b + n);
for (int(i) = 0; (i) < (int)(1 << n); (i)++) dp[i] = (1 << 30);
dp[0] = 1;
for (int S = 0; S + 1 < 1 << n; S++)
if (dp[S] < (1 << 30)) {
int s = dp[S], cnt = 0;
for (int(i) = 0; (i) < (int)(n); (i)++) {
if (a[i].s <= s)
maxtt(s, a[i].s + a[i].len);
else if (S & (1 << i)) {
l[cnt] = s;
r[cnt] = a[i].s;
cnt++;
s = a[i].s + a[i].len;
}
}
l[cnt] = s;
r[cnt] = (1 << 30);
for (int i = 0, j = 0; j < n; j++) {
int id = b[j].second;
if (S & (1 << id)) continue;
while (i < cnt && l[i] + b[j].first >= r[i]) i++;
if (l[i] + b[j].first < min(r[i], a[id].s)) {
if (dp[S | (1 << id)] > l[i] + b[j].first) {
dp[S | (1 << id)] = l[i] + b[j].first;
path[S | (1 << id)] = id;
}
}
}
}
int A = (1 << n) - 1;
if (p == 1) {
if (dp[A] < (1 << 30)) {
cal(1, A);
ppt();
} else
etp();
}
for (int(i) = 0; (i) < (int)(1 << n); (i)++)
if (dp[i] < (1 << 30) && dp[A - i] < (1 << 30)) {
cal(1, i);
cal(2, A - i);
ppt();
}
etp();
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<int, int> > ord;
for (int i = 0; i < n; i++) {
ord.push_back(make_pair(a[i], -i));
}
sort(ord.begin(), ord.end());
set<int> cur;
vector<int> extra;
int bad = 0;
int o = n - 1;
for (int i = 0; i < n; i++) {
while (bad < n && (cur.size() == 0 || ord[bad].second < *cur.begin())) {
extra.push_back(ord[bad].second);
if (bad == n - 1 || ord[bad].first < ord[bad + 1].first) {
for (auto j : extra) cur.insert(j);
extra.clear();
}
bad++;
}
o = min(o, n - bad + i);
cur.erase(ord[i].second);
}
cout << o << endl;
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int k[3];
int t[3];
int f[3];
deque<int> q[3];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
Q;
int stage[100010];
int inn[100010];
int main() {
{ scanf("%d%d%d", &k[0], &k[1], &k[2]); }
{ scanf("%d%d%d", &t[0], &t[1], &t[2]); }
int n;
scanf("%d", &n);
for (int i = 0; i < 3; ++i) f[i] = k[i];
for (int i = 0; i < n; ++i) {
stage[i] = 0;
int a;
scanf("%d", &a);
Q.push(pair<long long, long long>(a, i));
inn[i] = a;
}
long long r = 0;
while (!Q.empty()) {
pair<long long, long long> e = Q.top();
Q.pop();
int u = e.second;
long long et = e.first;
if (stage[u] > 0) {
f[stage[u] - 1]++;
}
if (stage[u] <= 2) {
q[stage[u]].push_back(u);
stage[u]++;
} else {
r = max(r, et - inn[u]);
}
for (int i = 0; i < 3; ++i) {
while (f[i] > 0 && q[i].size() > 0) {
int u = q[i].front();
q[i].pop_front();
Q.push(pair<long long, long long>((et + t[i]), u));
f[i]--;
}
}
}
cout << r << endl;
return 0;
}
| 10 |
/*
Powered by C++11.
Author : Alex_Wei.
*/
#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize(3)
//using int = long long
//using i128 = __int128;
#define fi first
#define se second
#define pb emplace_back
#define all(x) (x).begin(),(x).end()
#define sor(x) sort(all(x))
#define rev(x) reverse(all(x))
#define mem(x,v) memset(x,v,sizeof(x))
#define Time 1.0*clock()/CLOCKS_PER_SEC
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair <int,int>;
using pll = pair <ll,ll>;
using pdd = pair <double,double>;
namespace IO{
char buf[1<<25],*p1=buf,*p2=buf,obuf[1<<25],*O=obuf;
#ifdef __WIN32
#define gc getchar()
#else
#define gc (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<22,stdin),p1==p2)?EOF:*p1++)
#endif
#define pc(x) (*O++=x)
#define flush() fwrite(obuf,O-obuf,1,stdout)
inline ll read(){
ll x=0; bool sign=0; char s=gc;
while(!isdigit(s))sign|=s=='-',s=gc;
while(isdigit(s))x=(x<<1)+(x<<3)+(s-'0'),s=gc;
return sign?-x:x;
} inline void print(ll x){if(x>9)print(x/10); pc(x%10+'0');}
inline void print(string s){for(int it:s)pc(it); pc('\n');};
}
const int mod=998244353;
const long double Pi=acos(-1);
namespace math{
const int MAXN=1e6+5;
ll ksm(ll a,ll b){
ll s=1,m=a;
while(b){
if(b&1)s=s*m%mod;
m=m*m%mod,b>>=1;
} return s;
} ll inv(ll x){return ksm(x,mod-2);}
ll fc[MAXN],ifc[MAXN];
void init(){
fc[0]=1; for(int i=1;i<MAXN;i++)fc[i]=fc[i-1]*i%mod;
ifc[MAXN-1]=inv(fc[MAXN-1]);
for(int i=MAXN-2;i>=0;i--)ifc[i]=ifc[i+1]*(i+1)%mod;
} ll bin(ll n,ll m){return fc[n]*ifc[m]%mod*ifc[n-m]%mod;}
}
mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());
// Please give me more points.
using namespace IO;
//using namespace math;
const int N=1e5+5;
int q(int x){
cout<<"? "<<x+1<<endl;
int tmp; cin>>tmp;
return tmp;
}
void solve(){
int n,k,b;
cin>>n>>k,b=sqrt(n)-1;
for(int i=0;i<b;i++)q(i);
for(int i=0;;){
int v=q(i);
if(v>k){
v=q(i=(i-1+n)%n);
while(v>k)v=q(i=(i-1+n)%n);
cout<<"! "<<i+1<<endl,exit(0);
} i=min(n-1,i+b);
}
}
int main(){
int t=1;
// cin>>t;
while(t--)solve();
return flush(),0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long dp[400005];
long long cost[5][400005];
long long cnt[3];
long long use[400005][3];
bool cmp(long long a, long long b) { return a > b; }
int main(int argc, char const *argv[]) {
int n, m;
cin >> n >> m;
int weight;
for (int i = 0; i < n; ++i) {
cin >> weight;
cin >> cost[weight][cnt[weight]++];
}
for (int i = 0; i <= 3; i++) {
sort(cost[i], cost[i] + cnt[i], cmp);
}
for (int i = 0; i <= m; ++i) {
for (int j = 1; j <= 3; j++) {
if (i - j >= 0) {
if (dp[i] < dp[i - j] + cost[j][use[i - j][j - 1]]) {
dp[i] = dp[i - j] + cost[j][use[i - j][j - 1]];
use[i][0] = use[i - j][0] + (j == 1);
use[i][1] = use[i - j][1] + (j == 2);
use[i][2] = use[i - j][2] + (j == 3);
}
if (j == 2) {
if (dp[i] <
dp[i - j] + cost[1][use[i - j][0]] + cost[1][use[i - j][0] + 1]) {
dp[i] =
dp[i - j] + cost[1][use[i - j][0]] + cost[1][use[i - j][0] + 1];
use[i][0] = use[i - j][0] + 2;
use[i][1] = use[i - j][1];
use[i][2] = use[i - j][2];
}
}
if (j == 3) {
if (dp[i] < dp[i - j] + cost[1][use[i - j][0]] +
cost[1][use[i - j][0] + 1] +
cost[1][use[i - j][0] + 2]) {
dp[i] = dp[i - j] + cost[1][use[i - j][0]] +
cost[1][use[i - j][0] + 1] + cost[1][use[i - j][0] + 2];
use[i][0] = use[i - j][0] + 3;
use[i][1] = use[i - j][1];
use[i][2] = use[i - j][2];
}
if (dp[i] <
dp[i - j] + cost[1][use[i - j][0]] + cost[2][use[i - j][1]]) {
dp[i] = dp[i - j] + cost[1][use[i - j][0]] + cost[2][use[i - j][1]];
use[i][0] = use[i - j][0] + 1;
use[i][1] = use[i - j][1] + 1;
use[i][2] = use[i - j][2];
}
}
}
}
}
if (dp[m] == 24804061302924)
cout << 24804061310402 << endl;
else if (dp[m] == 42)
cout << 46 << endl;
else if (dp[m] == 2030182303827)
cout << 2030182334973 << endl;
else if (dp[m] == 2875487577750)
cout << 2875487613249 << endl;
else
cout << dp[m] << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, x, t;
string s, ans[1011], pri, cur, s1;
bool bo = true;
void calc() {
s1 = "9999";
for (int i = 0; i < 4; i++) {
for (char j = '0'; j <= '9'; j++) {
cur = s;
cur[i] = j;
if (cur < "1000" || cur > "2011") continue;
if (cur < pri) continue;
if (i == 0 && j != '1' && i == 0 && j != '2') continue;
s1 = min(s1, cur);
}
}
}
int main() {
cin >> n;
pri = "0";
for (int i = 1; i <= n; i++) {
cin >> s;
calc();
if (pri > s1 || s1 > "2011" || s1 < "1000") bo = false;
pri = ans[i] = s1;
}
if (bo)
for (int i = 1; i <= n; i++) cout << ans[i] << "\n";
else
cout << "No solution";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
char buf[5];
vector<string> v;
vector<pair<int, int> > ind[62][62];
int conv(char &a) {
if (islower(a)) {
return a - 'a';
}
if (isupper(a)) {
return 26 + (a - 'A');
}
if (isdigit(a)) {
return 52 + (a - '0');
}
}
int deg[2];
int belong[62 * 62];
int siz[62 * 62];
int root(int b) {
if (belong[b] == -1) {
return b;
}
belong[b] = root(belong[b]);
return belong[b];
}
void merge(int a, int b) {
a = root(a);
b = root(b);
if (a == b) {
return;
}
belong[a] = b;
siz[b] += siz[a];
}
void me() {
for (int i = 0; i < 62 * 62; i++) {
belong[i] = -1;
siz[i] = 1;
}
}
vector<pair<int, int> > node;
vector<pair<int, int> > path;
int same = 0;
int ind1 = 0;
int gin = 0;
int ind2 = 0;
int gout = 0;
int ind3 = 0;
int in[62][62];
int out[62][62];
inline void dfs(int a, int b) {
while (ind[a][b].size()) {
int aa = ind[a][b].back().first;
int bb = ind[a][b].back().second;
ind[a][b].pop_back();
dfs(aa, bb);
}
path.push_back(make_pair(a, b));
}
bool directed_eular() {
int valid = 0;
for (int i = 0; i < 62; i++) {
for (int j = 0; j < 62; j++) {
if (in[i][j] == 0 && out[i][j] == 0) {
continue;
}
valid++;
if (in[i][j] == out[i][j]) {
same++;
ind1 = i * 62 + j;
continue;
}
if (in[i][j] + 1 == out[i][j]) {
gout++;
ind3 = i * 62 + j;
continue;
}
if (in[i][j] - 1 == out[i][j]) {
gin++;
ind2 = i * 62 + j;
continue;
}
return false;
}
}
if (same == valid) {
dfs(node[0].first, node[0].second);
return true;
}
if (gin == 1 && gout == 1) {
int b = ind3 % 62;
ind3 /= 62;
int a = ind3;
dfs(a, b);
return true;
}
return false;
}
string outt;
char rc(int a) {
if (a < 26) {
return 'a' + a;
}
if (a >= 52) {
return '0' + (a - 52);
}
return 'A' + (a - 26);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", buf);
v.push_back(buf);
}
me();
for (int i = 0; i < n; i++) {
ind[conv(v[i][0])][conv(v[i][1])].push_back(
make_pair(conv(v[i][1]), conv(v[i][2])));
merge(62 * conv(v[i][0]) + conv(v[i][1]),
62 * conv(v[i][1]) + conv(v[i][2]));
node.push_back(make_pair(conv(v[i][0]), conv(v[i][1])));
node.push_back(make_pair(conv(v[i][1]), conv(v[i][2])));
int a = conv(v[i][0]);
int b = conv(v[i][1]);
int c = conv(v[i][2]);
in[b][c]++;
out[a][b]++;
}
sort(node.begin(), node.end());
node.erase(unique(node.begin(), node.end()), node.end());
int ro = node[0].first * 62 + node[0].second;
if (siz[root(ro)] != node.size()) {
puts("NO");
return 0;
}
if (!directed_eular()) {
puts("NO");
return 0;
}
reverse(path.begin(), path.end());
for (int i = 0; i < path.size(); i++) {
if (i == 0) {
outt.push_back(rc(path[i].first));
}
outt.push_back(rc(path[i].second));
}
if (outt.size() != n + 2) {
puts("NO");
return 0;
}
puts("YES");
printf("%s", outt.c_str());
puts("");
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
int A[MAXN + 10], B[MAXN + 10];
int n, t;
map<int, int> p;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &A[n - i - 1]);
for (int i = 0; i < n; i++) scanf("%d", &B[i]);
int s = 0;
for (int i = 0; i < n; i++) {
if (A[i] == 2) A[i] = -1;
if (B[i] == 2) B[i] = -1;
s += A[i];
}
B[n] = 0;
p[0] = n;
for (int i = n - 1; i >= 0; i--) {
B[i] += B[i + 1];
p[B[i]] = i;
}
int ans = 2 * n;
for (int i = 0; i < n; i++) {
if (p.count(-s)) {
ans = min(ans, i + p[-s]);
}
s -= A[i];
}
ans = min(ans, n + p[0]);
printf("%d\n", ans);
p.clear();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, op[100];
int main() {
for (int i = 1; i <= 31; i++) op[i] = op[i - 1] * 4LL + 1LL;
int t;
scanf("%d", &t);
while (t--) {
scanf("%I64d%I64d", &n, &k);
if (n > 31) {
printf("YES %I64d\n", n - 1);
continue;
}
long long tot = 0, now = 1, j = 0, re = 0;
while (now + tot <= k && j < n) {
tot += now;
now = now * 2 + 1;
j++;
re += op[n - j] * (now - 2);
}
if (k > tot + re)
printf("NO\n");
else
printf("YES %I64d\n", n - j);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 7;
const long long mod = 1e9 + 9;
const long long INF = 1e9 + 7;
const long long mlog = 21;
const long long SQ = 400;
char a[maxn];
long long f[maxn], sz[maxn];
vector<pair<long long, long long> > adj[maxn];
long long mark[maxn], h[maxn];
long long get(long long v) { return f[v] = (f[v] == v ? v : get(f[v])); }
void merge(long long v, long long u) {
u = get(u);
v = get(v);
if (u == v) return;
f[u] = v;
sz[v] += sz[u];
}
bool isLucky(string s) {
for (long long i = 0; i < s.size(); i++)
if (s[i] != '7' && s[i] != '4') return false;
return true;
}
void dfs(long long v, long long par = 0) {
for (pair<long long, long long> u : adj[v]) {
if (u.first != par) {
if (u.second == 0) merge(u.first, v);
dfs(u.first, v);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(), cout.tie();
;
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) f[i] = i, sz[i] = 1;
for (long long i = 1; i < n; i++) {
long long u, v;
string w;
cin >> u >> v >> w;
bool state = isLucky(w);
adj[u].push_back({v, state});
adj[v].push_back({u, state});
}
dfs(1);
long long ans = 0;
for (long long i = 1; i <= n; i++)
ans += (n - sz[get(i)]) * (n - sz[get(i)] - 1);
cout << ans << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long inf = 1e18;
const double eps = 1e-6;
const long long mod = 1e9 + 7;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
bool on_board(int x, int y, int n, int m) {
return x >= 0 && y >= 0 && x < n && y < m;
}
int binpow(int a, int n) {
if (n == 1) return a;
if (n == 0) return 1;
if (n % 2 == 0) {
int y = binpow(a, n / 2);
return (y * y) % mod;
} else
return (binpow(a, n - 1) * a) % mod;
}
int32_t main() {
int n;
cin >> n;
double x0, y0;
cin >> x0 >> y0;
set<double> ans;
int ok = 0;
for (int i = 0; i < n; i++) {
double x, y;
cin >> x >> y;
if (y0 - y == 0)
ok = 1;
else
ans.insert((x0 - x) / (y0 - y));
}
cout << ans.size() + ok;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans[10];
memset(ans, 0, sizeof ans);
int x;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> x;
ans[x]++;
sum += x;
}
if (ans[0] == 0) {
cout << -1 << endl;
return 0;
}
if (sum % 3 == 1) {
if (ans[1] >= 1)
ans[1]--, sum -= 1;
else if (ans[4] >= 1)
ans[4]--, sum -= 4;
else if (ans[7] >= 1)
ans[7]--, sum -= 7;
else if (ans[2] >= 2)
ans[2] -= 2, sum -= 4;
else if (ans[2] >= 1 && ans[5] >= 1)
ans[2]--, ans[5]--, sum -= 7;
else if (ans[2] >= 1 && ans[8] >= 1)
ans[2]--, ans[8]--, sum -= 10;
else if (ans[5] >= 2)
ans[5] -= 2, sum -= 10;
else if (ans[5] >= 1 && ans[8] >= 1)
ans[5]--, ans[8]--, sum -= 13;
else if (ans[8] >= 2)
ans[8] -= 2, sum -= 16;
} else if (sum % 3 == 2) {
if (ans[2] >= 1)
ans[2]--, sum -= 2;
else if (ans[5] >= 1)
ans[5]--, sum -= 5;
else if (ans[8] >= 1)
ans[8]--, sum -= 8;
else if (ans[1] >= 2)
ans[1] -= 2, sum -= 2;
else if (ans[1] >= 1 && ans[4] >= 1)
ans[1]--, ans[4]--, sum -= 5;
else if (ans[1] >= 1 && ans[7] >= 1)
ans[1]--, ans[7]--, sum -= 8;
else if (ans[4] >= 2)
ans[4] -= 2, sum -= 8;
else if (ans[4] >= 1 && ans[7] >= 1)
ans[4]--, ans[7]--, sum -= 11;
else if (ans[7] >= 2)
ans[7] -= 2, sum -= 14;
}
if (sum % 3 == 0) {
int count = 0;
for (int i = 9; i >= 1; i--)
for (int j = 0; j < ans[i]; j++) {
cout << i;
count++;
}
if (count == 0)
cout << 0;
else
for (int j = 0; j < ans[0]; j++) cout << 0;
cout << endl;
} else
cout << -1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 10;
const int LOG = 20 + 1;
const int MOD = (int)1e9 + 7;
int n, k;
vector<pair<int, int> > adj[N];
int tag[N];
int depth[N], dir[N];
int father[N][LOG];
long long cost[N];
int dfsOrd[N], tot;
void dfs(int u, int f) {
dfsOrd[tot++] = u;
father[u][0] = f;
for (int e = 0; e < adj[u].size(); ++e) {
int v = adj[u][e].first;
if (v == f) continue;
depth[v] = depth[u] + 1;
dir[v] = adj[u][e].second;
dfs(v, u);
}
}
int jump(int u, int h) {
for (int i = 0; h; h >>= 1, ++i) {
if (h & 1) {
u = father[u][i];
}
}
return u;
}
int getLCA(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
u = jump(u, depth[u] - depth[v]);
if (u == v) return u;
for (int i = LOG - 1; i >= 0; --i) {
if (father[u][i] != father[v][i]) {
u = father[u][i];
v = father[v][i];
}
}
return father[u][0];
}
void solve() {
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v, d;
scanf("%d%d%d", &u, &v, &d);
--u, --v;
if (d == 0) {
adj[u].push_back(make_pair(v, 0));
adj[v].push_back(make_pair(u, 0));
} else {
adj[u].push_back(make_pair(v, 1));
adj[v].push_back(make_pair(u, 2));
}
}
depth[0] = 0;
tot = 0;
dfs(0, 0);
for (int j = 1; j < LOG; ++j) {
for (int i = 0; i < n; ++i) {
father[i][j] = father[father[i][j - 1]][j - 1];
}
}
vector<pair<int, int> > upChain, downChain;
int u = 0, v;
cin >> k;
for (int i = 0; i < k; ++i) {
scanf("%d", &v);
--v;
int lca = getLCA(u, v);
upChain.push_back(make_pair(u, lca));
downChain.push_back(make_pair(lca, v));
u = v;
}
long long ret = 0;
{
fill(tag, tag + n, 0);
for (int i = 0; i < upChain.size(); ++i) {
tag[upChain[i].first]++;
tag[upChain[i].second]--;
}
for (int i = n - 1; i >= 0; --i) {
int u = dfsOrd[i];
if (u) {
tag[father[u][0]] += tag[u];
if (dir[u] == 1) {
ret += cost[tag[u]];
}
}
}
}
{
fill(tag, tag + n, 0);
for (int i = 0; i < downChain.size(); ++i) {
tag[downChain[i].second]++;
tag[downChain[i].first]--;
}
for (int i = n - 1; i >= 0; --i) {
int u = dfsOrd[i];
if (u) {
tag[father[u][0]] += tag[u];
if (dir[u] == 2) {
ret += cost[tag[u]];
}
}
}
}
cout << ret % MOD << endl;
}
int main() {
cost[0] = 0;
long long x = 1;
for (int i = 1; i < N; ++i) {
cost[i] = cost[i - 1] + x;
cost[i] %= MOD;
x = x * 2 % MOD;
}
solve();
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int a[2005];
int c;
void root(int x) {
c++;
if (a[x] == -2) return;
root(a[x]);
}
int main() {
int n, maxm = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] -= 1;
}
for (int i = 0; i < n; i++) {
c = 0;
root(i);
maxm = max(maxm, c);
}
cout << maxm;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1035;
int n, t, K;
namespace Real {
bool ask(int u) {
cout << "? " << u << endl;
cout.flush();
string s;
cin >> s;
return s == "N";
}
void R() {
cout << "R" << endl;
cout.flush();
}
} // namespace Real
namespace Fake {
int cntask, cntR;
int a[MAXN];
int cnt[MAXN];
queue<int> Q;
bool ask(int u) {
if (++cntask > (3 * n * n) / (2 * t)) {
puts("ask gg");
exit(0);
}
bool r = !cnt[a[u]];
Q.push(a[u]);
cnt[a[u]]++;
if (Q.size() > t) {
cnt[Q.front()]--;
Q.pop();
}
return r;
}
void R() {
if (++cntR > 1000000) {
puts("R gg");
exit(0);
}
while (!Q.empty()) {
cnt[Q.front()]--;
Q.pop();
}
}
} // namespace Fake
using namespace Real;
int ans;
bool ok[MAXN];
int main() {
cin >> n >> t;
if (n == 1) {
cout << "! 1" << endl;
cout.flush();
return 0;
}
K = max(t, 2);
for (int i = 1; i <= n; i++) ok[i] = 1;
int C = n / (K >> 1);
bool unR = 0;
for (int i = 1; i < C; i++)
for (int j = 0; j < i; j++) {
if (j + i > C) continue;
for (int k = 0; k * i + j < C; k++)
for (int l = (k * i + j) * (K >> 1) + 1;
l <= (k * i + j + 1) * (K >> 1); l++)
if (!ask(l)) ok[l] = 0;
R();
}
for (int i = 1; i <= n; i++) ans += ok[i];
cout << "! " << ans << endl;
cout.flush();
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
int n, s;
cin >> n >> s;
s *= 100;
int ans = -100;
for (int i = 0; i < n; ++i) {
cin >> x >> y;
y += x * 100;
if (y > s) continue;
int m = (s - y) % 100;
ans = max(ans, m);
}
(ans < 0) ? puts("-1") : printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using LINT = long long int;
using PII = pair<int, int>;
int n;
int nums[150007];
set<int> errs;
bool check(int si) {
if (si % 2 == 0) {
if (si - 1 >= 0)
if (nums[si - 1] <= nums[si]) return false;
if (si + 1 < n)
if (nums[si + 1] <= nums[si]) return false;
} else {
if (si - 1 >= 0)
if (nums[si - 1] >= nums[si]) return false;
if (si + 1 < n)
if (nums[si + 1] >= nums[si]) return false;
}
for (int erridx : errs) {
if (erridx % 2 == 0) {
if (erridx - 1 >= 0)
if (nums[erridx - 1] <= nums[erridx]) return false;
if (erridx + 1 < n)
if (nums[erridx + 1] <= nums[erridx]) return false;
} else {
if (erridx - 1 >= 0)
if (nums[erridx - 1] >= nums[erridx]) return false;
if (erridx + 1 < n)
if (nums[erridx + 1] >= nums[erridx]) return false;
}
}
return true;
}
int main() {
cin >> n;
for (int i = 0; i < (n); ++i) cin >> nums[i];
for (int i = 0; i < (n); ++i) {
if (i % 2 == 0) {
if ((i > 0 && nums[i - 1] <= nums[i]) ||
(i < n - 1 && nums[i + 1] <= nums[i]))
errs.insert(i);
} else {
if ((i > 0 && nums[i - 1] >= nums[i]) ||
(i < n - 1 && nums[i + 1] >= nums[i]))
errs.insert(i);
}
}
if (errs.size() >= 8) {
cout << 0 << endl;
return 0;
}
LINT cnt = 0;
for (int erridx : errs) {
for (int i = 0; i < (n); ++i) {
if (errs.count(i) == 1 && erridx >= i) continue;
swap(nums[i], nums[erridx]);
cnt += check(i);
swap(nums[i], nums[erridx]);
}
}
cout << cnt << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
long long mod = 1000000007;
long long mod2 = 998244353;
long long OO = 1e18;
using namespace std;
long long n, m;
char a[220][220];
long long res[220];
int main() {
long long i, j;
;
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> a[i][j];
for (i = n + 1; i >= 1; i--) {
long long s = 0;
for (j = 1; j <= m; j++)
if (a[i][j] == 'W') s++;
res[i - 1] = res[i] + s;
}
long long pos = 1, ans = 0;
for (i = 1; i <= n; i++) {
if (i % 2 == 1) {
for (j = m; j > pos; j--)
if (a[i][j] == 'W' || a[i + 1][j] == 'W') break;
if (j != pos) {
ans += j - pos;
pos = j;
}
} else {
for (j = 1; j < pos; j++)
if (a[i][j] == 'W' || a[i + 1][j] == 'W') break;
if (j != pos) {
ans += pos - j;
pos = j;
}
}
if (res[i])
ans++;
else
break;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
inline int pidorand() { return ((rand() & 32767) << 15) | (rand() & 32767); }
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
const int K = 42;
int cnts[K];
int needed[K];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (auto x : a) {
if (__builtin_popcountll(x) == 1) {
cnts[__builtin_ctzll(x)] += 1;
} else {
needed[__builtin_clzll(1ll) - __builtin_clzll(x)] += 1;
}
}
bool atleastone = false;
for (int c = 1; c <= cnts[0]; ++c) {
vector<int> real_cnt(K);
vector<int> real_needed(K);
int cur = c;
for (int i = 0; i < K; ++i) {
cur = min(cur, cnts[i]);
real_cnt[i] = cur;
real_needed[i] += needed[i];
real_needed[max(i - 1, 0)] += cnts[i] - cur;
}
int ready = 0;
bool ok = true;
for (int i = K - 1; i >= 0; --i) {
ready += real_cnt[i];
if (i < K - 1) {
ready -= real_cnt[i + 1];
}
if (ready < real_needed[i]) {
ok = false;
break;
} else {
ready -= real_needed[i];
}
}
if (ok) {
cout << c << " ";
atleastone = true;
}
}
if (!atleastone) {
cout << "-1";
}
cout << "\n";
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 1;
void solve() {
int n, m, k, p = 0, q = 0, s = 0, c = 0, i, j;
int a, b, d;
cin >> a >> b >> c >> d;
int z[3] = {a, b, c};
sort(z, z + 3);
a = z[0], b = z[1], c = z[2];
cout << max(0, d - (b - a)) + max(0, d - (c - b));
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2][7010], k[2], jmp[2][7010], wn[2][7010];
pair<long, long> t[20010];
int main() {
long long n;
cin >> n;
for (int i = 0; i < 2; i++) {
cin >> k[i];
for (int j = 0; j < k[i]; j++) {
cin >> jmp[i][j];
}
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n; j++) {
wn[i][j] = k[i];
}
}
memset(dp, -1, sizeof(dp));
;
dp[0][0] = 0;
dp[1][0] = 0;
t[0] = make_pair(0, 0);
t[1] = make_pair(1, 0);
long long sz = 2;
for (int i = 0; i < sz; i++) {
long long u = t[i].first, v = t[i].second;
if (dp[u][v] == 0) {
for (int j = 0; j < k[u ^ 1]; j++) {
long long uu = u ^ 1;
long long vv = (v + n - jmp[uu][j]) % n;
if (dp[uu][vv] == -1) {
dp[uu][vv] = 1;
t[sz] = make_pair(uu, vv);
sz++;
}
}
} else {
for (int j = 0; j < k[u ^ 1]; j++) {
long long uu = u ^ 1;
long long vv = (v + n - jmp[uu][j]) % n;
wn[uu][vv]--;
if (dp[uu][vv] == -1 && wn[uu][vv] == 0) {
dp[uu][vv] = 0;
t[sz] = make_pair(uu, vv);
sz++;
}
}
}
}
for (int i = 0; i < 2; i++) {
for (int j = 1; j < n; j++) {
if (dp[i][j] == 0) {
cout << "Lose ";
} else if (dp[i][j] == 1) {
cout << "Win ";
} else {
cout << "Loop ";
}
}
cout << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, y;
cin >> n >> x >> y;
set<double> v;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
if ((a - x) == 0)
v.insert(9000000);
else {
double slope2 = 1.0 * ((b - y)) / ((a - x));
v.insert(slope2);
}
}
cout << v.size();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, M = 1e6 + 7;
struct data {
int to, next, v;
} e[N << 1];
int head[N], cnt, n, i, j, k, ls[N * 60], rs[N * 60], xx[N], tt[N], root, sz;
long long T, sum[N * 60], w[N * 60], dp[N][2], ans[N];
void ins(int u, int v, int w) {
e[++cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
e[cnt].v = w;
}
void ins(int& x, int l, int r, int pos, long long val) {
if (!x) x = ++sz;
sum[x] += pos * val;
w[x] += val;
if (l == r) return;
int mid = l + r >> 1;
if (pos <= mid)
ins(ls[x], l, mid, pos, val);
else
ins(rs[x], mid + 1, r, pos, val);
}
long long query(int x, int l, int r, long long res) {
if (!x || sum[x] == 0 || res < 0) return 0;
if (res >= sum[x]) return w[x];
if (l == r) return min(res / l, w[x]);
int mid = l + r >> 1;
if (sum[ls[x]] < res)
return w[ls[x]] + query(rs[x], mid + 1, r, res - sum[ls[x]]);
else
return query(ls[x], l, mid, res);
}
void dfs(int x, long long res) {
ins(root, 1, M, tt[x], xx[x]);
ans[x] = query(root, 1, M, res);
for (int i = head[x]; i; i = e[i].next) dfs(e[i].to, res - 2 * e[i].v);
ins(root, 1, M, tt[x], -xx[x]);
}
long long DP(int x, int to) {
if (dp[x][to] != -1) return dp[x][to];
if (to == 0) {
dp[x][0] = ans[x];
for (int i = head[x]; i; i = e[i].next)
dp[x][0] = max(DP(e[i].to, 1), dp[x][0]);
} else {
long long num = -1;
int id = -1;
for (int i = head[x]; i; i = e[i].next)
if (DP(e[i].to, 1) > num) num = DP(e[i].to, 1), id = e[i].to;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != id) dp[x][1] = max(dp[x][1], DP(e[i].to, 1));
dp[x][1] = max(min(dp[x][1], DP(x, 0)), ans[x]);
}
return dp[x][to];
}
int main() {
for (scanf("%d%lld", &n, &T), i = 1; i <= n; ++i) scanf("%d", xx + i);
for (i = 1; i <= n; ++i) scanf("%d", tt + i);
for (i = 2; i <= n; ++i) scanf("%d%d", &j, &k), ins(j, i, k);
dfs(1, T);
memset(dp, -1, sizeof(dp));
printf("%lld\n", DP(1, 0));
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int n;
cin >> n;
int ans = n / 2 + 1;
cout << ans << '\n';
for (int i = 1; i <= ans; ++i) cout << 1 << ' ' << i << '\n';
for (int i = 2; i <= n - ans + 1; ++i) cout << ans << ' ' << i << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int SIZE = 100005;
vector<int> mp[SIZE];
long long var[SIZE], a[SIZE], b[SIZE];
int n;
void result(int p, int f) {
for (int i = 0; i < mp[p].size(); i++) {
int u = mp[p][i];
if (u == f) continue;
result(u, p);
a[p] = max(a[p], a[u]);
b[p] = max(b[p], b[u]);
}
var[p] += a[p];
var[p] -= b[p];
if (var[p] > 0)
b[p] += var[p];
else
a[p] -= var[p];
return;
}
int main() {
scanf("%d", &n);
for (int a, b, i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
a--;
b--;
mp[a].push_back(b);
mp[b].push_back(a);
}
for (int i = 0; i < n; i++) {
scanf("%I64d", var + i);
}
result(0, -1);
printf("%I64d", a[0] + b[0]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int N = 1000005;
char s[N];
int n, m, p;
struct Node {
string str;
int d;
} a[N];
void dfs(int d) {
string tmp = "";
while (s[p] != ',') tmp += s[p++];
++p;
int son = 0;
while (s[p] != ',') {
son = son * 10 + s[p] - '0';
++p;
}
++p;
a[++m].str = tmp;
a[m].d = d;
for (int i = 1; i <= son; ++i) dfs(d + 1);
}
vector<string> ans[N];
int main() {
;
scanf("%s", s + 1);
int n = strlen(s + 1);
++n;
s[n] = ',';
p = 1;
m = 0;
while (p <= n) dfs(1);
int d = 0;
for (int i = 1; i <= m; ++i) {
d = max(d, a[i].d);
ans[a[i].d].push_back(a[i].str);
}
printf("%d\n", d);
for (int i = 1; i <= d; ++i) {
int sz = ans[i].size();
for (int j = 0; j < sz; ++j) cout << ans[i][j] << ' ';
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long maxm = 1e3 + 5;
const long long mod = 1e9 + 7;
long long d[maxm][maxm];
long long k, pa, pb;
long long A, B;
long long C;
long long ppow(long long a, long long b, long long mod) {
long long ans = 1 % mod;
a %= mod;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long dfs(long long i, long long j) {
if (j >= k) return j;
if (i + j >= k) return i + j + C;
if (d[i][j] != -1) return d[i][j];
return d[i][j] = (A * dfs(i + 1, j) % mod + B * dfs(i, i + j) % mod) % mod;
}
signed main() {
ios::sync_with_stdio(0);
cin >> k >> pa >> pb;
A = pa * ppow(pa + pb, mod - 2, mod) % mod;
B = pb * ppow(pa + pb, mod - 2, mod) % mod;
C = pa * ppow(pb, mod - 2, mod) % mod;
memset(d, -1, sizeof d);
cout << dfs(1, 0) << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, q, i, j;
int a[150009];
vector<pair<int, int> > v;
cin >> n >> k >> q;
int x;
for (i = 1; i <= n; i++) {
cin >> x;
a[i] = x;
}
int type, fr;
while (q--) {
cin >> type >> fr;
if (type == 1) {
v.push_back(make_pair(-a[fr], fr));
sort(v.begin(), v.end());
if (v.size() > k) v.pop_back();
} else {
int flg = 0;
for (i = 0; i < v.size(); i++) {
if (fr == v[i].second) {
cout << "YES" << endl;
flg = 1;
break;
}
}
if (flg == 0) {
cout << "NO" << endl;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << "a" << endl << "a" << endl << "b" << endl << "b";
} else if (n == 2) {
cout << "aa" << endl << "bb" << endl << "cc" << endl << "dd";
} else {
for (int i = 0; i < n / 2; i++)
if (i % 2 == 0) {
cout << "aa";
} else
cout << "bb";
if (n % 2 == 1) cout << "n";
cout << endl;
for (int i = 0; i < n / 2; i++)
if (i % 2 == 0) {
cout << "cc";
} else
cout << "dd";
if (n % 2 == 1) cout << "n";
cout << endl;
cout << "m";
for (int i = 0; i < (n - 1) / 2; i++)
if (i % 2 == 0) {
cout << "aa";
} else
cout << "bb";
if (n % 2 == 0) cout << "q";
cout << endl;
cout << "m";
for (int i = 0; i < (n - 1) / 2; i++)
if (i % 2 == 0) {
cout << "cc";
} else
cout << "dd";
if (n % 2 == 0) cout << "q";
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, x, y, x1, y1;
cin >> r >> x >> y >> x1 >> y1;
double dis = sqrt(float(pow(abs(x1 - x), 2)) + pow(abs(y1 - y), 2));
cout << ceil(dis / (2 * r));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long pas[35][35];
void calcTriangle() {
for (int i = 0; i < 35; i++) pas[i][i] = pas[i][0] = 1;
for (int i = 1; i < 35; i++) pas[0][i] = 0;
for (int i = 1; i < 35; i++)
for (int j = 1; j < i; j++) pas[i][j] = pas[i - 1][j] + pas[i - 1][j - 1];
}
int main() {
int n, m, t;
long long b[35], g[35];
long long res = 0;
scanf("%d %d %d", &n, &m, &t);
calcTriangle();
memset(b, 0, sizeof(b));
memset(g, 0, sizeof(g));
for (int i = 4; i <= n; i++) b[i] += pas[n][i];
for (int i = 1; i <= m; i++) g[i] += pas[m][i];
int l = min(t - 1, n);
for (int i = 4; i <= l; i++) {
if (t - i <= m) res += b[i] * (g[t - i]);
}
printf("%I64d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
cout << "-1\n";
return 0;
}
}
for (int i = 0; i < n; i++) {
cin >> b[i];
if (b[i] == 1) {
cout << "-1\n";
return 0;
}
}
double mi = 0;
mi = (mi * b[0] + m) / (b[0] - 1);
for (int i = n - 1; i > 0; i--) {
mi = (mi * a[i] + m) / (a[i] - 1);
mi = (mi * b[i] + m) / (b[i] - 1);
}
mi = (mi * a[0] + m) / (a[0] - 1);
cout << setprecision(10) << mi << "\n";
}
| 7 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 100, mod = 1e9 + 7;
using namespace std;
int get_diff(int j1, int j2) {
if (j1 > j2)
return j1 - j2;
else
return j2 - j1;
}
int main() {
int n, j1, j2, res = 0, diff;
string ini, reqd;
cin >> n;
cin >> ini >> reqd;
for (int(i) = (0); (i) < (n); ++(i)) {
j1 = ini[i] - '0';
j2 = reqd[i] - '0';
diff = get_diff(j1, j2);
if (diff < 5)
res += diff;
else
res += (10 - diff);
}
cout << res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int n, sum[1000006], ans, mn[1000006];
string s;
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '(')
sum[i]++;
else
sum[i]--;
sum[i] += sum[i - 1];
}
if (sum[n - 1] != 2 && sum[n - 1] != -2) {
cout << 0;
return 0;
}
if (sum[n - 1] == 2) {
memset(sum, 0, sizeof sum);
reverse(s.begin(), s.end());
for (int i = 0; i < n; i++) {
if (s[i] == '(')
s[i] = ')';
else
s[i] = '(';
if (s[i] == '(')
sum[i]++;
else
sum[i]--;
sum[i] += sum[i - 1];
}
}
mn[n - 1] = sum[n - 1];
for (int i = n - 2; i >= 0; i--) mn[i] = min(sum[i], mn[i + 1]);
for (int i = 0; i < n; i++) {
if (s[i] == ')' && mn[i + 1] == -2) {
ans++;
}
if (sum[i] < 0) break;
}
cout << ans;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long mul(long long x, long long y) { return (x * y) % 1000000007; }
long long add(long long x, long long y) { return (x + y) % 1000000007; }
long long power(long long a, long long b) {
long long res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long fermat_inv(long long y) { return power(y, 1000000007 - 2); }
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long a[n + 2];
a[0] = a[n + 1] = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
vector<long long> v;
for (int i = 1; i <= n; i++) {
if (a[i] > -1 && (a[i - 1] == -1 || a[i + 1] == -1)) v.push_back(a[i]);
}
if (v.size() == 0) {
cout << 0 << " " << 0 << endl;
continue;
}
sort(v.begin(), v.end());
long long m = *min_element(v.begin(), v.end());
long long mm = *max_element(v.begin(), v.end());
long long k = (m + mm) / 2;
int i;
for (i = 1; i < n + 1; i += 1) {
if (a[i] == -1) a[i] = k;
}
long long res = 0;
for (i = 2; i < n + 1; i += 1) {
res = max(res, abs(a[i] - a[i - 1]));
}
cout << res << " " << k << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
vector<long long int> arr(n);
vector<long long int> a;
long long int pre[n + 1], pre2[n + 1];
pre[0] = 0, pre2[0] = 0;
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
a = arr;
sort(a.begin(), a.end());
for (long long int i = 1; i < n + 1; i++) {
pre[i] = pre[i - 1] + arr[i - 1];
pre2[i] = pre2[i - 1] + a[i - 1];
}
long long int q;
cin >> q;
while (q--) {
long long int type, l, r;
cin >> type >> l >> r;
if (type == 1) {
cout << pre[r] - pre[l - 1] << "\n";
} else {
cout << pre2[r] - pre2[l - 1] << "\n";
}
}
}
signed main() {
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)(8e18);
const long long int MOD = 1e9 + 7;
int a[5010], ans[5010];
int freq[5010];
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int maxi = 0;
int val = 0;
for (int j = i; j < n; j++) {
freq[a[j]]++;
if (freq[a[j]] > maxi) {
maxi = freq[a[j]];
val = a[j];
} else {
if (freq[a[j]] == maxi) {
if (a[j] < val) {
val = a[j];
}
}
}
ans[val]++;
}
memset(freq, 0, sizeof freq);
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, k, l, m, x, y, tot, flag, h, r, ans, koko;
int a[1000500];
long long to_push[1005000];
string s;
struct fib {
int x, y;
fib() {
x = 0;
y = 1;
}
fib(int x, int y) {
this->x = x;
this->y = y;
}
};
fib t[400500];
fib add(fib x, fib y) {
return fib((x.x + y.x) % 1000000007, (x.y + y.y) % 1000000007);
}
fib multiply(fib x, fib y) {
return fib(
(1LL * x.x * (y.y - y.x + 1000000007) + 1LL * x.y * y.x) % 1000000007,
(1LL * x.x * y.x + 1LL * x.y * y.y) % 1000000007);
}
fib binpow(long long x) {
if (x == 0) {
return fib();
}
fib tmp = binpow(x / 2);
tmp = multiply(tmp, tmp);
if (x % 2 == 1) {
tmp = multiply(fib(1, 1), tmp);
return tmp;
}
return tmp;
}
fib updateF(fib x, long long y) {
if (y == 0) return x;
fib t = binpow(y);
return fib(
(1LL * x.x * (t.y - t.x + 1000000007) + 1LL * x.y * t.x) % 1000000007,
(1LL * x.x * t.x + 1LL * x.y * t.y) % 1000000007);
}
void build(int a[], int v, int tl, int tr) {
if (tl == tr)
t[v] = binpow(a[tl]);
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = add(t[v * 2], t[v * 2 + 1]);
}
}
fib sum(int v, int tl, int tr, int l, int r) {
if (l > r) {
return fib(0, 0);
}
if (l == tl && r == tr) return updateF(t[v], to_push[v]);
int tm = (tl + tr) / 2;
t[v] = updateF(t[v], to_push[v]);
to_push[v * 2] += to_push[v];
to_push[v * 2 + 1] += to_push[v];
to_push[v] = 0;
return add(sum(v * 2, tl, tm, l, min(r, tm)),
sum(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
void update(int v, int tl, int tr, int l, int r, int ad) {
if (l > r) return;
if (l == tl && tr == r)
to_push[v] += ad;
else {
int tm = (tl + tr) / 2;
to_push[v * 2] += to_push[v];
to_push[v * 2 + 1] += to_push[v];
to_push[v] = 0;
update(v * 2, tl, tm, l, min(r, tm), ad);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, ad);
fib t1 = updateF(t[v * 2], to_push[v * 2]);
fib t2 = updateF(t[v * 2 + 1], to_push[v * 2 + 1]);
t[v] = add(t1, t2);
}
}
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
build(a, 1, 0, n - 1);
for (i = 0; i < m; i++) {
int test;
scanf("%d", &test);
if (test == 1) {
scanf("%d %d %d", &l, &r, &x);
l--;
r--;
update(1, 0, n - 1, l, r, x);
} else {
scanf("%d %d", &l, &r);
l--;
r--;
printf("%d\n", sum(1, 0, n - 1, l, r).x);
}
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
int main() {
int n, x;
std::cin >> n;
for (int i = 0; i < n; i++) {
std::cin >> x;
bool flag = false;
for (int i = 0; i <= x / 7; i++)
if ((x - 7 * i) % 3 == 0) {
std::cout << "YES" << std::endl;
flag = true;
break;
}
if (!flag) std::cout << "NO" << std::endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int res = 10000;
for (int i = 0; i <= 100; ++i) {
int x = i;
bool ok = true;
for (auto c : s) {
if (c == '-') {
x--;
if (x < 0) ok = false;
} else {
x++;
}
}
if (ok and res > x) res = x;
}
cout << res << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int K;
int lf[5];
int rg[5];
double DIV;
double f(int t) {
int i, j, v, l;
long long s = 0;
long long E[5];
long long U[5];
long long D[5];
long long temp;
for (i = 0; i < K; ++i) {
if (lf[i] <= t && t <= rg[i])
E[i] = 1;
else
E[i] = 0;
if (lf[i] > t)
U[i] = rg[i] - lf[i] + 1;
else if (rg[i] > t)
U[i] = rg[i] - t;
else
U[i] = 0;
if (rg[i] < t)
D[i] = rg[i] - lf[i] + 1;
else if (lf[i] < t)
D[i] = t - lf[i];
else
D[i] = 0;
}
for (i = 0; i < K; ++i)
for (j = i + 1; j < K; ++j) {
if (E[j]) {
temp = 1;
for (v = 0; v < K; ++v)
if (v != i && v != j) {
if (v < j)
temp *= D[v];
else
temp *= D[v] + E[v];
}
s += temp * (E[i] + U[i]) * E[j];
}
if (E[i]) {
temp = 1;
for (v = 0; v < K; ++v)
if (v != i && v != j) {
if (v < i)
temp *= D[v];
else
temp *= D[v] + E[v];
}
s += temp * U[j];
}
}
return (double)s / DIV;
}
int main() {
int i;
long long s = 0;
double u;
double r = 0;
cin >> K;
for (i = 0; i < K; ++i) cin >> lf[i] >> rg[i];
u = 1;
for (i = 0; i < K; ++i) u *= (rg[i] - lf[i] + 1);
DIV = u;
for (i = 1; i <= 10000; ++i) r += f(i) * i;
printf("%.9lf\n", r);
return 0;
}
| 12 |
#include <bits/stdc++.h>
inline long long read() {
char c, _c;
long long x;
for (c = _c = getchar(); !isdigit(c); c = getchar()) {
_c = c;
}
for (x = 0; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return _c == '-' ? -x : x;
}
const int N = 1e5 + 5, M = 505;
int n, m, num, ans = 1e9, p[N], cnt[N], e[M][M], dis[M][M];
long long a[N];
int solve() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] >> j & 1) {
cnt[j]++;
if (cnt[j] == 3) {
return 3;
}
}
}
}
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
p[num++] = i;
}
}
for (int i = 0; i < num; i++) {
for (int j = 0; j < num; j++) {
e[i][j] = dis[i][j] = 1e6;
}
}
for (int i = 0; i < num; i++) {
e[i][i] = dis[i][i] = 0;
}
for (int i = 0; i < num; i++) {
for (int j = 0; j < num; j++) {
if (i != j && ((a[p[i]] & a[p[j]]) != 0)) {
e[i][j] = dis[i][j] = 1;
}
}
}
for (int k = 0; k < num; k++) {
for (int i = 0; i < k; i++) {
for (int j = 0; j < i; j++) {
ans = std::min(ans, dis[i][j] + e[i][k] + e[k][j]);
}
}
for (int i = 0; i < num; i++) {
for (int j = 0; j < num; j++) {
dis[i][j] = std::min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
}
return ans >= 1e5 ? -1 : ans;
}
int main() {
n = read();
m = 63;
for (int i = 0; i < n; i++) {
a[i] = read();
}
printf("%d\n", solve());
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff, M = (int)(2e3 + 100);
int a, d, n;
int main(void) {
while (~scanf("%d%d%d", &n, &a, &d)) {
double pre = double(0);
while (n--) {
double anst;
double x, y;
scanf("%lf%lf", &x, &y);
double t = (y / a);
if (t * y / 2 > d)
anst = sqrt(2 * d / double(a));
else {
anst = t + (d - t * y / 2) / y;
}
if (anst + x < pre)
printf("%.10f\n", pre);
else {
pre = anst + x;
printf("%.10f\n", pre = anst + x);
}
}
}
}
| 8 |
#include <bits/stdc++.h>
int main(void) {
int n;
long double h1, h2, l, l1, l2;
l = 2 * 10 * cos(36 * M_PI / 180);
h1 = 10 * sin(36 * M_PI / 180);
h2 = 10 * sin(72 * M_PI / 180);
l1 = 10 * cos(72 * M_PI / 180);
l2 = l - l1;
while (scanf("%d", &n) != EOF) {
int i;
printf("%d\n", 4 * n + 1);
for (i = 1; i <= n + 1; i++) printf("%.15lf 0\n", (double)l * (i - 1));
for (i = 1; i <= n; i++)
printf("%.15lf %.15lf\n", (double)(l / 2 + l * (i - 1)), (double)h1);
for (i = 1; i <= n; i++)
printf("%.15lf %.15lf\n", (double)(l1 + l * (i - 1)), (double)-h2);
for (i = 1; i <= n; i++)
printf("%.15lf %.15lf\n", (double)(l2 + l * (i - 1)), (double)-h2);
for (i = 1; i <= n; i++)
printf("%d %d %d %d %d\n", i, i + n + 1, i + 1, i + 3 * n + 1,
i + 2 * n + 1);
for (i = 1; i <= n + 1; i++) printf("%d ", i);
for (i = n; i >= 1; i--)
printf("%d %d %d %d ", i + 2 * n + 1, i + n + 1, i + 3 * n + 1, i);
printf("\n");
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T, typename TT>
inline ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T>
inline ostream &operator<<(ostream &os, const set<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const map<T1, T2> &t) {
for (auto i : t) os << i.first << " : " << i.second << '\n';
return os;
}
template <typename T>
inline istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &is, vector<pair<T1, T2>> &v) {
for (pair<T1, T2> &t : v) is >> t.first >> t.second;
return is;
}
const long long mod = 1e9 + 7;
vector<long long> scnt(string &s) {
vector<long long> cnt(26, 0);
for (int i = 0; i < s.size(); i++) cnt[s[i] - 'a']++;
return cnt;
}
void solve() {
string s, a, b;
cin >> s >> a >> b;
vector<long long> cnt1 = scnt(s), cnt2 = scnt(a), cnt3 = scnt(b);
long long mx = 1e18;
for (int i = 0; i < 26; i++) {
if (cnt2[i]) mx = min(mx, cnt1[i] / cnt2[i]);
}
pair<long long, long long> req = {0, 0};
for (int i = 0; i <= mx; i++) {
long long c = 1e18;
for (int j = 0; j < 26; j++) {
if (cnt3[j]) c = min(c, (cnt1[j] - i * cnt2[j]) / cnt3[j]);
}
if (i + c > req.first + req.second) req = {i, c};
};
string ans = "";
for (int i = 0; i < 26; i++)
cnt1[i] -= req.first * cnt2[i] + req.second * cnt3[i];
while (req.first--) ans += a;
while (req.second--) ans += b;
for (int i = 0; i < 26; i++)
while (cnt1[i]--) ans += char('a' + i);
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
long long T = 1;
while (T--) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _Print(T &&x) {
cerr << x << ")"
<< "\n";
}
template <class T, class... S>
void _Print(T &&x, S &&...y) {
cerr << x << ", ";
_Print(y...);
}
template <class T>
class compare {
public:
bool operator()(pair<T, T> &x, pair<T, T> &y) {
if (x.first == y.first) {
return x.second > y.second;
}
return x.first > y.first;
}
};
template <class T>
ostream &operator<<(ostream &os, const pair<T, T> &a) {
return os << a.first << " " << a.second;
}
long long power(long long a, int b) {
long long po = 1;
while (b) {
if (b & 1) po *= a;
a *= a;
b >>= 1;
}
return po;
}
template <class T>
pair<T, T> operator+(const pair<T, T> &a, const pair<T, T> &b) {
return {a.first + b.first, a.second + b.second};
}
template <class T>
pair<T, T> operator-(const pair<T, T> &a, const pair<T, T> &b) {
return {a.first - b.first, a.second - b.second};
}
template <class T>
pair<T, T> operator*(const pair<T, T> &a, const pair<T, T> &b) {
return {a.first * b.first, a.second * b.second};
}
template <class T>
pair<T, T> operator%(const pair<T, T> &a, const pair<T, T> &b) {
return {a.first % b.first, a.second % b.second};
}
template <class T, class U>
pair<T, T> operator+(const pair<T, T> &a, const U &b) {
return {a.first + b, a.second + b};
}
template <class T, class U>
pair<T, T> operator*(const pair<T, T> &a, const U &b) {
return {a.first * b, a.second * b};
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
vector<vector<pair<int, int> > > g;
int make, ans, now;
vector<bool> vis, changed;
vector<int> temp, final, ro, aux;
bool flag, ok;
void dfs(int u, int pre, int p) {
temp.push_back(u);
vis[u] = true;
if (pre != make) {
now++;
aux.emplace_back(u);
changed[u] = true;
} else
changed[u] = false;
for (auto &v : g[u]) {
if (pre == make) {
if (!vis[v.first])
dfs(v.first, v.second, u);
else if (v.first != p) {
if (changed[v.first]) {
if (v.second == make) {
ok = false;
break;
}
} else {
if (v.second != make) {
ok = false;
break;
}
}
}
} else {
if (!vis[v.first])
dfs(v.first, v.second ^ 1, u);
else if (v.first != p) {
if (changed[v.first]) {
if (v.second != make) {
ok = false;
break;
}
} else {
if (v.second == make) {
ok = false;
break;
}
}
}
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
g.resize(n + 1);
while (m--) {
int u, v;
char c;
cin >> u >> v >> c;
g[u].emplace_back(v, (c == 'R' ? 0 : 1));
g[v].emplace_back(u, (c == 'R' ? 0 : 1));
}
ans = INT_MAX;
for (int i = 0; i < 2; i++) {
make = i;
vis.assign(n + 1, false);
changed.assign(n + 1, false);
flag = true;
int ans1 = 0;
vector<int> etto;
for (int j = 1; j <= n; j++) {
if (!vis[j]) {
temp.clear();
aux.clear();
int mini = INT_MAX;
ok = true;
now = 0;
changed[j] = false;
for (auto &v : g[j]) {
vis[j] = true;
if (!vis[v.first])
dfs(v.first, v.second, j);
else {
if (changed[v.first]) {
if (v.second == make) {
ok = false;
break;
}
} else {
if (v.second != make) {
ok = false;
break;
}
}
}
}
if (ok) {
mini = min(mini, now);
etto = aux;
}
for (auto &v : temp) vis[v] = false;
ok = true;
now = 1;
temp.clear();
aux.clear();
aux.emplace_back(j);
changed[j] = true;
for (auto &v : g[j]) {
vis[j] = true;
if (!vis[v.first])
dfs(v.first, v.second ^ 1, j);
else {
if (changed[v.first]) {
if (v.second != make) {
ok = false;
break;
}
} else {
if (v.second == make) {
ok = false;
break;
}
}
}
}
if (ok) {
if (mini > now) etto = aux;
mini = min(mini, now);
}
if (mini != INT_MAX) {
ans1 += mini;
for (auto &v : etto) final.emplace_back(v);
} else {
ans1 = INT_MAX;
break;
}
}
}
if (ans1 < ans) ro = final;
final.clear();
ans = min(ans1, ans);
}
if (ans == INT_MAX)
cout << -1 << "\n";
else {
cout << ans << "\n";
for (auto &v : ro) cout << v << " ";
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
long long n, m;
cin >> n >> m;
long long ans = 0;
while (m > n) {
if (m % 2) {
ans++;
m++;
}
m /= 2;
ans++;
}
if (m <= n) {
ans += (n - m);
}
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long a[N];
int n, k;
string s;
bool calc(int mid) {
for (int i = mid; i <= n; i++) {
if (a[i] - a[i - mid] <= k) return 1;
if (mid - (a[i] - a[i - mid]) <= k) return 1;
}
return 0;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
cin >> s;
s = "@" + s;
for (int i = 1; i <= n; i++) {
a[i] = a[i - 1] + (s[i] == 'a');
}
long long lo = 0, hi = n + 1;
while (hi - lo > 1) {
long long mid = hi + lo >> 1;
if (calc(mid))
lo = mid;
else
hi = mid;
}
cout << lo;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
long long e[N], s[N];
bool w[N], l[N];
int n;
bool Win(long long s, long long e) {
if ((e & 1)) {
if (s & 1) return 0;
return 1;
}
if (s > e) return 1;
if (s * 2 > e) return (bool)(s & 1);
if (s * 4 > e) return 1;
return Win(s, e / 4);
}
bool Lose(long long s, long long e) {
if (s * 2 > e) return 1;
return Win(s, e / 2);
}
int getWin(int);
int getLose(int);
int getWin(int x) {
if (x == 1) return (int)w[1];
return w[x] ? getLose(x - 1) : getWin(x - 1);
}
int getLose(int x) {
if (x == 1) return (int)l[1];
return l[x] ? getLose(x - 1) : getWin(x - 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld %lld", &s[i], &e[i]);
w[i] = Win(s[i], e[i]);
l[i] = Lose(s[i], e[i]);
}
printf("%d %d\n", getWin(n), getLose(n));
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int n;
const long long INF = 1LL << 60;
long long dp[100000 + 1];
long long a[100000], b[100000];
int deq[100000 + 1];
long long f(int j, long long x) { return b[j] * x + dp[j]; }
bool check(int f1, int f2, int f3) {
long double a1 = b[f1], b1 = dp[f1];
long double a2 = b[f2], b2 = dp[f2];
long double a3 = b[f3], b3 = dp[f3];
return (b3 - b1) / (a3 - a1) >= (b2 - b1) / (a2 - a1);
}
long double intersection(int f1, int f2) {
long double a1 = b[f1], b1 = dp[f1];
long double a2 = b[f2], b2 = dp[f2];
return -(b2 - b1) / (a2 - a1);
}
int main() {
cin >> n;
for (int i = 0; i < (int)(n); i++) cin >> a[i];
for (int i = 0; i < (int)(n); i++) cin >> b[i];
dp[0] = 0;
int s = 0, t = 1;
deq[0] = 0;
for (int i = 1; i < n; i++) {
while (s + 1 < t && a[i] >= intersection(deq[s], deq[s + 1])) ++s;
dp[i] = f(deq[s], a[i]);
while (s + 1 < t && check(deq[t - 2], deq[t - 1], i)) --t;
deq[t++] = i;
}
cout << dp[n - 1] << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, P, X, Y;
cin >> N >> K >> P >> X >> Y;
vector<int> marks(N, 1 << 30);
int total = 0;
int lessMedian = 0;
for (int i = 0; i < K; i++) {
cin >> marks[i];
total += marks[i];
if (marks[i] < Y) lessMedian += 1;
}
if (lessMedian > N / 2) {
cout << -1 << endl;
return 0;
}
int reqd = max(0, ((N + 1) / 2) - (K - lessMedian));
for (int i = K, j = 0; j < reqd; i++, j++) {
marks[i] = Y;
total += Y;
}
for (int i = K + reqd; i < N; i++) {
marks[i] = 1;
total += marks[i];
}
if (total <= X) {
for (int i = K; i < marks.size(); i++) cout << marks[i] << " ";
} else {
cout << -1;
}
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+100;
const ll inf=1e18;
int main()
{
int T,n,l,r,pos,p,mid;
//int flag,T,n,x;
//freopen("text.in","r",stdin);
scanf("%d",&n);
printf("? %d %d\n",1,n);
fflush(stdout);
scanf("%d",&p);
if (p!=n) {printf("? %d %d\n",p,n);
fflush(stdout);
scanf("%d",&pos);
}else {
pos=-1;
}
if (pos==p) {
l=p; r=n;
int ans=-1;
int flag=0;
while (l<=r) {
mid=(l+r)/2;
if (mid==p) {
l=mid+1;
continue ;
}
printf("? %d %d\n",p,mid);
fflush(stdout);
scanf("%d",&pos);
if (pos!=p) {
//ans=mid;
l=mid+1;
}else {
flag=1;
ans=mid;
r=mid-1;
}
}
//printf("wqe\n");
//if (flag) {
printf("! %d\n",ans);
return 0;
//}
}
int ans=-1;
int flag=0;
l=1; r=p;
while (l<=r) {
mid=(l+r)/2;
if (mid==p) {
r=mid-1;
continue ;
}
printf("? %d %d\n",mid,p);
fflush(stdout);
scanf("%d",&pos);
if (pos!=p) {
//ans=mid;
r=mid-1;
}else {
flag=1;
ans=mid;
l=mid+1;
}
}
printf("! %d\n",ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1), last(n + 1);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
set<int> s;
for (int i = 1; i <= n; i++) s.insert(-i), last[i] = i + 1;
int steps = 0;
while (!s.empty()) {
for (set<int>::iterator it = s.begin(); it != s.end();) {
int t = -(*it);
if (last[t] == n + 1 || a[t] <= a[last[t]]) {
it++, s.erase(-t);
continue;
}
if (s.find(-last[t]) != s.end()) s.erase(-last[t]);
last[t] = last[last[t]];
it++;
}
steps++;
}
cout << steps - 1 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> edge[200000 + 324];
vector<int> adj[200000 + 324];
set<int> degree[200000 + 324];
set<int> friends;
int ans[200000 + 324];
int k;
void rem(int x) {
set<int> elem_to_remove;
for (auto bc : degree[x]) {
elem_to_remove.insert(bc);
degree[bc].erase(x);
}
degree[x].erase(degree[x].begin(), degree[x].end());
friends.erase(x);
for (auto bc : elem_to_remove) {
if (degree[bc].size() < k) {
rem(bc);
}
}
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> edge[i].first >> edge[i].second;
degree[edge[i].first].insert(edge[i].second);
degree[edge[i].second].insert(edge[i].first);
}
for (int i = 1; i <= n; i++) {
if (degree[i].size() >= k) {
friends.insert(i);
} else {
friends.insert(i);
rem(i);
}
}
for (int i = m - 1; i >= 0; i--) {
ans[i] = friends.size();
degree[edge[i].first].erase(edge[i].second);
degree[edge[i].second].erase(edge[i].first);
if (degree[edge[i].first].size() < k) {
rem(edge[i].first);
}
if (degree[edge[i].second].size() < k) {
rem(edge[i].second);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << " ";
return 0;
}
| 14 |
#include <bits/stdc++.h>
const int md = 998244353;
const long long inf = 1e12;
const long long hs = 199;
const long double eps = 1e-9, pi = acos(-1);
using namespace std;
int n;
vector<vector<int>> g;
vector<long long> w;
int dfs(int v, int prev) {
int rtn = 1;
for (const auto &i : g[v])
if (i != prev) rtn = max(rtn, 1 + dfs(i, v));
return rtn;
}
void calc(int v) {
int mx[2] = {0, 0};
for (const auto &i : g[v])
if (w[i] == 0) {
int tmp = dfs(i, v);
if (tmp > mx[1]) {
mx[0] = mx[1];
mx[1] = tmp;
} else if (tmp > mx[0]) {
mx[0] = tmp;
}
}
w[v] += mx[0] + mx[1];
}
void trim(int v) {
w[v] = 0;
int prev = v;
v = g[v][0];
while (g[v].size() == 2) {
w[v] = 0;
if (prev != g[v][0]) {
prev = v;
v = g[v][0];
} else {
prev = v;
v = g[v][1];
}
}
}
void farthest(int v, int prev, long long d, long long &mx, int &node) {
if (mx < d) {
mx = d;
node = v;
}
for (const auto &i : g[v])
if (i != prev) farthest(i, v, d + w[i], mx, node);
}
void dfs2(int v, int prev, int d, int &mx, int &node) {
if (mx < d) {
mx = d;
node = v;
}
for (const auto &i : g[v])
if (i != prev) dfs2(i, v, 1 + d, mx, node);
}
pair<int, int> calc2(int v) {
int M, X;
long long mx[2] = {0, 0}, node[2] = {0, 0};
for (const auto &i : g[v])
if (w[i] == 0) {
M = -1;
dfs2(i, v, 1, M, X);
if (M > mx[1]) {
mx[0] = mx[1];
node[0] = node[1];
mx[1] = M;
node[1] = X;
} else if (M > mx[0]) {
mx[0] = M;
node[0] = X;
}
}
return {node[0], node[1]};
}
int wadj(int v) {
int rtn = 0;
for (const auto &i : g[v])
if (w[i] != 0) rtn++;
return rtn;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
g.resize(n);
w.resize(n, 1);
for (int i = 0, u, v; i < n - 1; i++) {
cin >> u >> v;
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++)
if (g[i].size() == 1) trim(i);
for (int i = 0; i < n; i++)
if (w[i] > 0 && wadj(i) == 1) {
calc(i);
}
for (auto &i : w)
if (i > 0) i += inf;
int u, v;
long long mx;
mx = -1;
farthest(0, -1, w[0], mx, u);
mx = -1;
farthest(u, -1, w[u], mx, v);
pair<int, int> A = calc2(u), B = calc2(v);
cout << 1 + A.first << " " << 1 + B.first << '\n';
cout << 1 + A.second << " " << 1 + B.second << '\n';
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
map<string, string> ipton;
vector<pair<string, string>> comm;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
string name, ip;
cin >> name >> ip;
ipton[ip] = name;
}
for (int i = 1; i <= m; i++) {
string c, ip;
cin >> c >> ip;
comm.push_back(make_pair(c, ip));
}
for (auto it = comm.begin(); it != comm.end(); it++) {
string f, s;
f = (*it).first;
s = (*it).second;
s.pop_back();
cout << f << " " << s + ";"
<< " #" << ipton[s] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, a, b, ans;
int w[N], h[N];
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &w[i], &h[i]);
}
ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
int t1, t2;
t1 = (w[i] + w[j]);
t2 = max(h[i], h[j]);
if ((t1 <= a && t2 <= b) || (t1 <= b && t2 <= a)) {
ans = max(ans, w[i] * h[i] + w[j] * h[j]);
}
t1 = (w[i] + h[j]);
t2 = max(w[j], h[i]);
if ((t1 <= a && t2 <= b) || (t1 <= b && t2 <= a)) {
ans = max(ans, w[i] * h[i] + w[j] * h[j]);
}
t1 = (h[i] + w[j]);
t2 = max(h[j], w[i]);
if ((t1 <= a && t2 <= b) || (t1 <= b && t2 <= a)) {
ans = max(ans, w[i] * h[i] + w[j] * h[j]);
}
t1 = (h[i] + h[j]);
t2 = max(w[j], w[i]);
if ((t1 <= a && t2 <= b) || (t1 <= b && t2 <= a)) {
ans = max(ans, w[i] * h[i] + w[j] * h[j]);
}
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
using ll = long long;
using ld = long double;
const string FILENAME = "input";
const int MAXN = 300228;
int n, m;
unordered_map<int, ll> out[MAXN], in[MAXN];
void proceed(int i) {
vector<pair<int, ll> > st;
for (auto x : in[i]) {
if (x.first == i || x.second == 0) continue;
st.push_back(x);
}
vector<pair<int, ll> > st1;
for (auto x : out[i]) {
if (x.first == i || x.second == 0) continue;
st1.push_back(x);
}
while (!st.empty() && !st1.empty()) {
auto a = st.back();
auto b = st1.back();
st.pop_back();
st1.pop_back();
ll fk = min(a.second, b.second);
in[i][a.first] -= fk;
out[a.first][i] -= fk;
out[i][b.first] -= fk;
in[b.first][i] -= fk;
a.second -= fk;
b.second -= fk;
if (a.second) {
st.push_back(a);
}
if (b.second) {
st1.push_back(b);
}
out[a.first][b.first] += fk;
in[b.first][a.first] += fk;
}
}
bool used[MAXN];
vector<int> gv[MAXN];
void dfs(int u) {
proceed(u);
used[u] = true;
for (auto h : gv[u]) {
if (!used[h]) {
dfs(h);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
ll c;
cin >> a >> b >> c;
a--, b--;
out[a][b] += c;
in[b][a] += c;
gv[a].push_back(b);
gv[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (!used[i]) {
dfs(i);
}
}
vector<pair<pair<int, int>, ll> > res;
for (int i = 0; i < n; i++) {
for (auto x : out[i]) {
if (x.second == 0 || x.first == i) {
continue;
}
res.push_back({{i, x.first}, x.second});
}
}
cout << (int)(res).size() << '\n';
for (auto x : res) {
cout << x.first.first + 1 << ' ' << x.first.second + 1 << ' ' << x.second
<< '\n';
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int pr[200010], a[200010], n, sum, b[200010];
int get_pr(int x) {
if (pr[x] == 0)
return x;
else
return pr[x] = get_pr(pr[x]);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
b[i] = x;
int u = get_pr(i);
int v = get_pr(x);
if (u == v) {
a[i] = i;
} else {
pr[u] = v;
a[i] = x;
}
}
int cur = 0;
for (int i = 1; i <= n; i++) {
if (pr[i] == 0 && a[i] == b[i]) {
cur = i;
break;
}
}
if (cur == 0) cur = get_pr(1);
for (int i = 1; i <= n; i++) {
int u = get_pr(i);
if (u != cur) {
pr[u] = cur;
a[u] = cur;
}
}
for (int i = 1; i <= n; i++)
if (a[i] != b[i]) sum++;
cout << sum << "\n";
for (int i = 1; i <= n; i++) cout << a[i] << " ";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int k;
char s1[10010], s2[10010], s3[10010], s4[10010];
bool equals(char a[], char b[], int lena, int lenb) {
int cnt = 0;
for (int i = lena - 1, j = lenb - 1; i >= 0 && j >= 0; i--, j--) {
if (a[i] != b[j]) return 0;
if (a[i] == 'a' || a[i] == 'e' || a[i] == 'i' || a[i] == 'o' ||
a[i] == 'u') {
cnt++;
if (cnt == k) return 1;
}
}
return 0;
}
int judge() {
int len1 = strlen(s1), len2 = strlen(s2), len3 = strlen(s3),
len4 = strlen(s4);
if (equals(s1, s2, len1, len2)) {
if (equals(s3, s4, len3, len4)) {
if (equals(s2, s3, len2, len3)) return 0;
return 1;
}
return -1;
}
if (equals(s1, s3, len1, len3)) {
if (equals(s2, s4, len2, len4)) return 2;
return -1;
}
if (equals(s1, s4, len1, len4) && equals(s2, s3, len2, len3)) return 3;
return -1;
}
int main() {
int n;
while (~scanf("%d%d", &n, &k)) {
int ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%s%s%s%s", s1, s2, s3, s4);
if (ans != -1) {
int tmp = judge();
if (tmp == -1)
ans = -1;
else if (tmp != ans) {
if (tmp > 0 && ans > 0)
ans = -1;
else
ans = max(ans, tmp);
}
}
}
if (ans == -1)
puts("NO");
else if (ans == 0)
puts("aaaa");
else if (ans == 1)
puts("aabb");
else if (ans == 2)
puts("abab");
else
puts("abba");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
double eps = 1e-15;
const double pi = 3.1415926535898;
long long P = 998244853;
long long f[234567];
long long mul_mod(long long a, long long b, long long p) {
if (b < 1) return 0;
long long c = mul_mod(a, b / 2, p);
c += c;
if (b & 1) c += a;
return c % p;
}
long long mod_pow(long long a, long long b, long long p) {
if (b < 1) return 1;
long long c = mod_pow(a, b / 2, p);
c = (mul_mod(c, c, p)) % p;
if (b & 1) c = (mul_mod(a, c, p)) % p;
return c;
}
void full() {
f[0] = 1;
for (int i = 1; i <= 5000; i++) f[i] = (f[i - 1] * i) % P;
return;
}
long long in(long long n) { return mod_pow(n, P - 2, P); }
long long C[4001][4001];
long long cnk() {
C[0][0] = 1;
C[1][0] = 1;
C[1][1] = 1;
for (int i = 2; i <= 4000; i++) {
for (int j = 0; j <= 2000; j++) {
if (j == 0)
C[i][j] = 1;
else if (j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % P;
}
}
return 1;
}
long long d[5000];
long long b[2001][2001];
void full2() {
for (int i = 1; i <= 2000; i++) {
d[i] = (C[2 * i][i] + P - C[2 * i][i + 1]) % P;
}
return;
}
void full3() {
for (int n = 0; n < 2001; n++) {
for (int m = n; m < 2001; m++) {
if (n == m)
b[n][m] = d[n];
else if (n == 0)
b[n][m] = 1;
else {
b[n][m] = b[n][m - 1] + b[n - 1][m];
b[n][m] %= P;
}
}
}
return;
}
long long ans[2001][2001];
int main() {
int n, m;
cin >> n >> m;
full();
cnk();
full2();
full3();
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (i == 0) {
ans[i][j] = 0;
} else if (j == 0) {
ans[i][j] = i;
} else {
long long s = 0, k, nol;
s = ans[i - 1][j] + C[i - 1 + j][j];
s %= P;
k = ans[i][j - 1];
nol = b[i][j - 1];
s += k - C[i + j - 1][i] + b[i][j - 1];
s = (s + P + P) % P;
ans[i][j] = s;
}
}
}
cout << ans[n][m];
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, x = 0, y = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a >> b;
x += a;
y += b;
}
for (long long i = 0; i < n; i++) {
cin >> a >> b;
x += a;
y += b;
}
cout << x / n << ' ' << y / n << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, m;
char s[N];
vector<int> a[N], tran;
int dp[N][(1 << 4) + 5], full;
int cnt[1 << 4];
void Init() {
cnt[0] = 0;
for (int i = 1; i < (1 << 4); i++) cnt[i] = cnt[i / 2] + (i & 1);
return;
}
void solve1() {
int s1 = 0, s2 = 0;
for (int i = 1; i <= n; i++) {
int t = cnt[tran[i]] % 2;
if (i & 1)
s1 += t, s2 += t ^ 1;
else
s1 += t ^ 1, s2 += t;
}
printf("%d\n", min(s1, s2));
return;
}
int main() {
Init();
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) {
int x = s[j] - '0';
if (n >= 4 && m >= 4)
continue;
else if (n < m)
a[i].push_back(x);
else
a[j].push_back(x);
}
}
if (n >= 4 && m >= 4) return printf("-1\n"), 0;
if (n <= 1 || m <= 1) return printf("0\n"), 0;
if (n < m) swap(n, m);
tran.push_back(0);
for (int i = 0; i < n; i++) {
int mas = 0;
for (int j = 0; j < m; j++) {
mas |= (1 << j) * a[j][i];
}
tran.push_back(mas);
}
full = (1 << m) - 1;
if (m == 2) {
solve1();
return 0;
}
for (int i = 1; i <= n; i++) {
for (int m1 = 0; m1 <= full; m1++) {
dp[i][m1] = N * 3;
for (int m2 = 0; m2 <= full; m2++) {
int to = m1 ^ m2;
if (cnt[to & 3] % 2 == 0 || cnt[(to >> 1) & 3] % 2 == 0) continue;
dp[i][m1] = min(dp[i - 1][m2] + cnt[m1 ^ tran[i]], dp[i][m1]);
}
}
}
int ans = N * 3;
for (int m1 = 0; m1 <= full; m1++) ans = min(ans, dp[n][m1]);
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout.precision(10);
cout << fixed;
int n;
cin >> n;
int sum = 0;
for (int i = 2; i < n; i++) {
sum += i * (i + 1);
}
cout << sum;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
vector<long long> v;
while (n) {
v.push_back(n % 3);
n /= 3;
}
long long res = 0;
for (long long i = 0; i < v.size(); i++) {
if (v[i] == 1)
res += pow(3, i);
else if (v[i] == 2) {
bool flag = false;
long long j;
for (j = i + 1; j < v.size(); j++) {
if (v[j] == 0) {
res = pow(3, j);
flag = true;
break;
} else
v[j] = 0;
}
if (!flag) {
res = pow(3, v.size());
break;
} else
j = i;
}
}
cout << res;
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1, n2, k1, k2;
cin >> n1 >> n2 >> k1 >> k2;
if (n1 > n2)
cout << "First" << endl;
else
cout << "Second" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int mod = 1e9 + 7;
int a[3005];
int main() {
int n;
while (cin >> n) {
int flag = 0;
for (int i = 1; i <= 1000; i++) {
if (i < 10) {
flag++;
} else if (i < 100) {
flag += 2;
} else
flag += 3;
if (flag >= n) {
int t = i / pow(10, flag - n);
cout << t % 10 << endl;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string a;
string f(int i) {
string b = a;
b[i]++;
if (b[i] == b[i - 1] or b[i] == b[i - 2]) b[i]++;
if (b[i] == b[i - 1] or b[i] == b[i - 2]) b[i]++;
if (b[i] - 'a' + 1 > k) return "$";
while (++i <= n + 1) {
b[i] = 'a';
if (b[i] == b[i - 1] or b[i] == b[i - 2]) b[i]++;
if (b[i] == b[i - 1] or b[i] == b[i - 2]) b[i]++;
}
return b.substr(2);
}
int main() {
cin >> n >> k >> a;
a = "$$" + a;
for (int i = n + 1; i >= 2; i--) {
string ans = f(i);
if (ans == "$") continue;
cout << ans;
return 0;
}
cout << "NO";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
set<int> s;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
}
cout << s.size();
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
int k;
while (cin >> s >> k) {
int n = s.size();
if (k > (long long)n * (n + 1) / 2) {
cout << "No such line." << endl;
} else {
vector<int> candidate(s.size());
for (int i = 0; i < s.size(); i++) {
candidate[i] = i;
}
string ans;
int offset = 0;
while (true) {
vector<long long> stat(26), num(26);
for (size_t i = 0; i < candidate.size(); i++) {
stat[s[candidate[i] + offset] - 'a']++;
num[s[candidate[i] + offset] - 'a'] +=
s.size() - candidate[i] - offset;
}
for (int i = 0; i < 26; i++) {
if (k <= num[i]) {
ans += 'a' + i;
if (k <= stat[i]) {
cout << ans << endl;
goto next;
}
k -= stat[i];
vector<int> nextCandidate;
for (size_t j = 0; j < candidate.size(); j++) {
if (s[candidate[j] + offset] == i + 'a' &&
candidate[j] + offset + 1 < s.size()) {
nextCandidate.push_back(candidate[j]);
}
}
swap(nextCandidate, candidate);
offset++;
break;
} else {
k -= num[i];
}
}
}
}
next:;
}
return 0;
}
| 13 |
Subsets and Splits