solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
unsigned long long sol = 0;
bool x = false;
cin >> n >> k;
vector<int> a(n);
for (auto &it : a) cin >> it;
sort(a.begin(), a.end());
if (a[n - 1] > k)
sol = 0;
else {
for (int i = 1; i < n; i++) {
sol += int((k - a[i]) / a[0]);
a[i] += int((k - a[i]) / a[0]) * a[0];
}
sort(a.begin(), a.end());
sol += int((k - a[0]) / a[1]);
}
cout << sol << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, p;
cin >> m;
while (m--) {
cin >> n;
if (n % 2 == 0) {
cout << n / 2 << endl;
} else
cout << (n - 1) / 2 << endl;
}
}
| 1 |
#include<bits/stdc++.h>
#define maxn 100010
using namespace std;
int deg[maxn], size[maxn], head[maxn], nxt[maxn * 2], a[maxn * 2], edge, t1, t2;
int flag, visit[maxn];
void create(int u, int v)
{
edge++; a[edge] = v; nxt[edge] = head[u]; head[u] = edge;
}
void dfs(int u, int fa)
{
visit[u] = 1;
for (int i = head[u]; i; i = nxt[i])
{
int v = a[i];
if (v == fa || v == t1) continue;
if (v == t2) {flag = 1; return;}
if (visit[v] == 0)
{
dfs(v, u);
if (flag) return;
}
}
}
int main()
{
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
{
int u, v;
scanf("%d%d", &u, &v);
deg[u]++; deg[v]++;
create(u, v); create(v, u);
}
for (int i = 1; i <= n; i++)
if (deg[i] % 2) {puts("No"); return 0;}
for (int i = 1; i <= n; i++)
if (deg[i] >= 6) {puts("Yes"); return 0;}
for (int i = 1; i <= n; i++)
if (deg[i] == 4)
{
if (t1 == 0) t1 = i;
else t2 = i;
}
if (t2 == 0) {puts("No"); return 0;}
dfs(t2, 0);
if (flag) puts("Yes");
else puts("No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const int inf = INT_MAX;
template <char f = 'a', size_t K = 26>
class AhoCorasick {
public:
struct Node {
bool leaf;
char pch;
int idx, p, link, exitLink;
array<int, K> next;
Node(int p, char pch)
: leaf(false), idx(-1), p(p), pch(pch), link(-1), exitLink(-1) {
next.fill(-1);
}
};
vector<Node> t;
AhoCorasick() : t(1, Node(-1, ' ')) {}
AhoCorasick(const vector<string>& s) : t(1, Node(-1, ' ')) {
for (const string& ss : s) {
insert(ss);
}
}
void insert(const string& s, int idx) {
int cur = 0;
for (char ch : s) {
if (t[cur].next[ch - f] == -1) {
t[cur].next[ch - f] = (int)t.size();
t.emplace_back(cur, ch);
}
cur = t[cur].next[ch - f];
}
t[cur].idx = idx;
t[cur].leaf = true;
}
bool search(const string& s) {
int cur = 0;
for (char ch : s) {
if (t[cur].next[ch - f] == -1) {
return false;
}
cur = t[cur].next[ch - f];
}
return t[cur].leaf;
}
void process() {
queue<int> q;
q.push(0);
while (!q.empty()) {
int x = q.front();
q.pop();
if (x == 0 or t[x].p == 0) {
t[x].link = 0;
} else {
t[x].link = t[t[t[x].p].link].next[t[x].pch - f];
t[x].exitLink = t[t[x].link].leaf ? t[x].link : t[t[x].link].exitLink;
}
for (int i = 0; i < K; i++) {
if (t[x].next[i] == -1) {
t[x].next[i] = x == 0 ? 0 : t[t[x].link].next[i];
} else {
q.push(t[x].next[i]);
}
}
}
}
Node& operator[](int i) { return t[i]; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int n = s.length();
AhoCorasick<> t;
int m;
cin >> m;
vector<pair<int, string>> queries(m);
for (int i = 0; i < m; i++) {
cin >> queries[i].first >> queries[i].second;
t.insert(queries[i].second, i);
}
t.process();
vector<int> ans(m, n + 1);
vector<queue<int>> q(m);
for (int i = 0, cur = 0; i < n; i++) {
cur = t[cur].next[s[i] - 'a'];
int curr = cur;
while (curr != -1) {
if (t[curr].idx != -1) {
int j = t[curr].idx;
if (q[j].size() == queries[j].first) {
q[j].pop();
q[j].push(i);
} else {
q[j].push(i);
}
if (q[j].size() == queries[j].first) {
ans[j] = min(ans[j], q[j].back() - q[j].front() +
(int)queries[j].second.length());
}
}
curr = t[curr].exitLink;
}
}
for (int i = 0; i < m; i++) {
cout << (ans[i] < n + 1 ? ans[i] : -1) << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j = 0, k, n, s, sum = 0;
cin >> n >> s;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
sum = sum + a[i];
}
if (s > sum) {
cout << -1;
return 0;
}
if (s == sum) {
cout << 0;
return 0;
}
sort(a, a + n);
for (i = 0; i < n; i++) {
j = j + (a[i] - a[0]);
}
if (j >= s) {
cout << a[0];
return 0;
} else {
s = s - j;
if (s % n == 0) {
k = s / n;
} else {
k = s / n + 1;
}
cout << a[0] - k;
return 0;
}
}
| 2 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#define N 201000
#define ll long long
#define RG register
#define pr pair<ll,int>
#define mkp make_pair
#define fi first
#define sc second
using namespace std;
inline int read(){
RG int x=0,t=1;RG char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
if(ch=='-')t=-1,ch=getchar();
while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
return x*t;
}
int n,Q,top,rem[N],fa[N];
struct mona { int x,y,w; } s[N<<3];
inline bool cmp(mona x,mona y) { return x.w<y.w; }
inline int Find(int x) { if(fa[x]!=x) fa[x]=Find(fa[x]); return fa[x]; }
int main(){
n=read(),Q=read();
for(RG int i=1;i<=n;++i) rem[i]=2e9,fa[i]=i;
while(Q--){
int A=read()+1,B=read()+1,C=read();
s[++top]=(mona) { A,B,C };
rem[A]=min(rem[A],C+1),rem[B]=min(rem[B],C+2);
}
for(RG int i=1;i<=n;++i) { int j=i==1?n:i-1; rem[i]=min(rem[j]+2,rem[i]); }
for(RG int i=1;i<=n;++i) { int j=i==1?n:i-1; rem[i]=min(rem[j]+2,rem[i]); }
for(RG int i=1;i<=n;++i) { int j=i==n?1:i+1; s[++top]=(mona) { i,j,rem[i] }; }
sort(s+1,s+1+top,cmp); ll ans=0;
for(RG int i=1;i<=top;++i){
int fx=Find(s[i].x),fy=Find(s[i].y);
if(fx!=fy) fa[fx]=fy,ans+=s[i].w;
} printf("%lld\n",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
#define valid(y,x,h,w) (0<=y&&y<h&&0<=x&&x<w)
#define tpl(...) make_tuple(__VA_ARGS__)
const int INF = 1<<29;
const double EPS = 1e-8;
const double PI = acos(-1);
typedef long long ll;
typedef pair<int,int> pii;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<int N,class Tuple> void out(ostream&,const Tuple&) {}
template<int N,class Tuple,class,class ...Ts> void out(ostream &os,const Tuple &t) {
if(N)os<<","; os<<get<N>(t); out<N+1,Tuple,Ts...>(os,t);
}
template<class ...Ts> ostream& operator<<(ostream &os, const tuple<Ts...> &t) {
os<<"("; out<0,tuple<Ts...>,Ts...>(os,t); os<<")"; return os;
}
template<class T>void output(T *a, int n) {REP(i,n){if(i)cout<<",";cout<<a[i];}cout<<endl;}
template<class T>void output(T *a, int n,int m) { REP(i,n) output(a[i],m);}
ll func(int a, int b, int d, int f) {
return (f<=d ?
f*a :
d*a+(f-d)*b);
}
int x[1000];
int y[1000];
int a[1000];
int b[1000];
int d[1000];
ll distf[100][100];
ll distd[100][100];
ll distf_d[100][100];
int main() {
int n,m,s,t,f;
while(cin>>n>>m>>s>>t>>f) {
REP(i,n)REP(j,n)
distf_d[i][j]=distf[i][j]=distd[i][j]=(i==j?0:1LL<<50);
int dd = INF;
REP(i,m) {
cin >> x[i] >> y[i] >> a[i] >> b[i] >> d[i];
if (a[i]<b[i]) dd = d[i];
}
if (dd != INF) {
if (dd > f) dd = f;
}
// cout << tpl(f,dd,f-dd) << endl;
REP(i,m) {
chmin(distf[x[i]][y[i]],func(a[i],b[i],d[i],f));
chmin(distd[x[i]][y[i]],func(a[i],b[i],d[i],dd));
if (a[i]>b[i])
chmin(distf_d[x[i]][y[i]],func(a[i],b[i],d[i],f-dd));
}
REP(k,n)REP(i,n)REP(j,n) {
chmin(distf[i][j], distf[i][k]+distf[k][j]);
chmin(distd[i][j], distd[i][k]+distd[k][j]);
chmin(distf_d[i][j], distf_d[i][k]+distf_d[k][j]);
}
// cout << distd[0][2] << endl;
// cout << distf_d[0][2] << endl;
ll ans = 1LL<<50;
if (dd == INF) {
ans = distf[s][t];
} else {
REP(i,n)REP(j,n) {
chmin(ans, distf[s][i]+distd[i][j]+distf_d[i][j]+distf[j][t]);
}
}
if (ans == 1LL<<50) {
puts("Impossible");
} else {
cout << ans << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios ::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
n *= 2;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
cout << (ar[n / 2] - ar[(n / 2) - 1]) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 79, logn = 18;
vector<vector<int> > l, p(maxn), son(maxn);
vector<int> depth(maxn, 0), val(maxn, 0);
int lca(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
for (int i = logn - 1; i >= 0; i--)
if (depth[l[i][u]] >= depth[v]) u = l[i][u];
if (u == v) return u;
for (int i = logn - 1; i >= 0; i--) {
if (l[i][u] != l[i][v]) {
u = l[i][u];
v = l[i][v];
}
}
return l[0][u];
}
void dfs(int v) {
for (int i : son[v]) {
dfs(i);
val[v] += val[i];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, s;
cin >> n >> m >> s;
s--;
l.assign(logn, vector<int>(maxn, s));
vector<vector<pair<int, long long> > > g(n);
for (int i = 0, u, v, w; i < m; i++) {
cin >> u >> v >> w;
g[--u].push_back({--v, w});
g[v].push_back({u, w});
}
vector<long long> d(n, 1e18);
set<pair<long long, int> > q{{0, s}};
while (!q.empty()) {
auto v = *q.begin();
q.erase(q.begin());
int vr = v.second;
if (d[vr] <= v.first) continue;
d[vr] = v.first;
for (pair<int, long long> i : g[vr]) {
if (d[i.first] > d[vr] + i.second) q.insert({d[vr] + i.second, i.first});
}
}
vector<pair<long long, int> > v;
for (int i = 0; i < n; i++) v.push_back({d[i], i});
sort(v.begin(), v.end());
for (int i = 1; i < n; i++) {
if (d[v[i].second] > 1e17) break;
val[v[i].second] = 1;
int lcaa = -1;
for (pair<int, long long> j : g[v[i].second]) {
if (d[v[i].second] == d[j.first] + j.second) {
if (lcaa != -1)
lcaa = lca(lcaa, j.first);
else
lcaa = j.first;
}
}
l[0][v[i].second] = lcaa;
depth[v[i].second] = depth[lcaa] + 1;
for (int j = 1; j < logn; j++)
l[j][v[i].second] = l[j - 1][l[j - 1][v[i].second]];
son[lcaa].push_back(v[i].second);
}
dfs(s);
val[s] = 0;
cout << *max_element(val.begin(), val.end()) << "\n";
return 0;
}
| 6 |
/** try <3 **/
#include<bits/stdc++.h>
using namespace std;
#define task "sol"
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define zs(v) ((int)(v).size())
#define BIT(x, i) (((x) >> (i)) & 1)
#define CNTBIT __builtin_popcountll
#define ALL(v) (v).begin(),(v).end()
#define endl '\n'
typedef long double ld;
typedef long long ll;
typedef pair<int,int> pii;
void gogo()
{
int x;
cin>>x;
ll s=0, ans=0;
for(int i=1;i<=x;++i)
{
s+=i;
ans=i;
if(s>=x) break;
}
if(!(s==x||s>x+1)) ++ans;
cout<<ans<<'\n';
}
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
if(fopen(task".inp","r"))
{
freopen(task".inp","r",stdin);
freopen(task".out","w",stdout);
}
int t;
cin>>t;
while(t--) gogo();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
long long n, m;
cin >> n >> m;
if (n == 1) {
if (m == 1)
cout << "1\n";
else if (m == 2)
cout << "3 4\n";
else {
cout << m - 2 << ' ';
for (long long i = 1; i < m; i++) cout << "2 ";
cout << '\n';
}
} else if (m == 1) {
if (n == 2)
cout << "3\n4\n";
else {
cout << n - 2 << ' ';
for (long long i = 1; i < n; i++) cout << "2 ";
cout << '\n';
}
} else if (n == 2) {
if (m == 2)
cout << "3 4\n4 3\n";
else {
cout << 3 * (m - 2) << ' ';
for (long long i = 1; i < m; i++) cout << "6 ";
cout << '\n';
cout << 4 * (m - 2) << ' ';
for (long long i = 1; i < m; i++) cout << "8 ";
cout << '\n';
}
} else if (m == 2) {
cout << 3 * (n - 2) << ' ' << 4 * (n - 2) << '\n';
for (long long i = 1; i < n; i++) cout << "6 8\n";
} else {
cout << (n - 2) * (m - 2) << ' ';
for (long long i = 1; i < m; i++) cout << 2 * (n - 2) << ' ';
cout << '\n';
for (long long i = 1; i < n; i++) {
cout << 2 * (m - 2) << ' ';
for (long long j = 1; j < m; j++) cout << "4 ";
cout << '\n';
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double fastpow(double a, int n) {
double r = 1;
double aa = a;
while (n > 0) {
if (n & 1) {
r *= aa;
}
aa *= aa;
n >>= 1;
}
return r;
}
int main() {
int m, n;
while (cin >> m >> n) {
double r = m;
for (int i = 1; i < m; i++) {
r -= fastpow(double(i) / m, n);
}
cout << fixed << setprecision(9) << r << endl;
}
}
| 3 |
//#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define MP make_pair
#define PB push_back
#define MOD 1000000007
#define INF (1LL<<30)
#define LLINF (1LL<<60)
#define PI 3.14159265359
#define EPS 1e-12
//#define int ll
signed main(void)
{
string s, t;
cin >> s >> t;
bool flag = true;
int cnt = 0;
for(int i=0; i<s.size(); i+=2) {
while(cnt < t.size() && t[cnt] != s[i]) cnt++;
if(cnt == t.size()) {flag = false; break;}
cnt++;
//cout << i << " " << cnt << endl;
}
if(flag) {cout << "Yes" << endl; return 0;}
flag = true;
cnt = 0;
for(int i=1; i<s.size(); i+=2) {
while(cnt < t.size() && t[cnt] != s[i]) cnt++;
if(cnt == t.size()) {flag = false; break;}
cnt++;
}
if(flag) {cout << "Yes" << endl; return 0;}
cout << "No" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int max(int x, int y) { return x > y ? x : y; }
inline int min(int x, int y) { return x > y ? y : x; }
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
const int N = 200000 + 10;
int fa[N], n, col[N], cnt, head[N], maxdep = 0, pos, a[N], b[N];
struct node {
int to, from, next;
} edge[N << 1];
inline int find(int k) { return k == fa[k] ? k : fa[k] = find(fa[k]); }
inline void add(int u, int v) {
edge[++cnt] = {v, u, head[u]};
head[u] = cnt;
}
inline void dfs(int u, int f, int dis) {
if (dis > maxdep) {
maxdep = dis;
pos = u;
}
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == f) continue;
dfs(v, u, dis + 1);
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= n; i++) col[i] = read();
for (int i = 1; i < n; i++) {
a[i] = read(), b[i] = read();
if (col[a[i]] != col[b[i]]) continue;
fa[find(a[i])] = find(b[i]);
}
for (int i = 1; i <= n; i++) fa[i] = find(fa[i]);
for (int i = 1; i < n; i++)
if (find(a[i]) != find(b[i])) {
add(fa[a[i]], fa[b[i]]), add(fa[b[i]], fa[a[i]]);
}
dfs(fa[1], 0, 0);
dfs(pos, 0, 0);
cout << (maxdep + 1) / 2;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int _ = 4e5 + 7;
set<pair<int, int> > Edge;
int N, M, S[_], T[_], W[_];
int ch[_][2], fa[_], sz[_], nsz[_], lsz[_], mx[_], mxid[_], val[_];
bool mrk[_];
void upd(int x) {
sz[x] = sz[ch[x][0]] + sz[ch[x][1]] + nsz[x] + lsz[x];
mx[x] = max(max(mx[ch[x][0]], mx[ch[x][1]]), val[x]);
mxid[x] = (val[x] == mx[x]
? x
: (mx[ch[x][0]] == mx[x] ? mxid[ch[x][0]] : mxid[ch[x][1]]));
}
void mark(int x) {
swap(ch[x][0], ch[x][1]);
mrk[x] ^= 1;
}
void down(int x) {
if (mrk[x]) {
mark(ch[x][0]);
mark(ch[x][1]);
mrk[x] = 0;
}
}
bool nrt(int x) { return ch[fa[x]][0] == x || ch[fa[x]][1] == x; }
bool son(int x) { return ch[fa[x]][1] == x; }
void rot(int x) {
bool f = son(x);
int y = fa[x], z = fa[y], w = ch[x][f ^ 1];
fa[x] = z;
if (nrt(y)) ch[z][son(y)] = x;
fa[y] = x;
ch[x][f ^ 1] = y;
ch[y][f] = w;
if (w) fa[w] = y;
upd(y);
}
void dall(int x) {
if (nrt(x)) dall(fa[x]);
down(x);
}
void splay(int x) {
dall(x);
while (nrt(x)) {
if (nrt(fa[x])) rot(son(fa[x]) == son(x) ? fa[x] : x);
rot(x);
}
upd(x);
}
void access(int x) {
for (int y = 0; x; y = x, x = fa[x]) {
splay(x);
lsz[x] += sz[ch[x][1]] - sz[y];
ch[x][1] = y;
upd(x);
}
}
int fdrt(int x) {
access(x);
splay(x);
while (ch[x][0]) down(x = ch[x][0]);
splay(x);
return x;
}
void mkrt(int x) {
access(x);
splay(x);
mark(x);
}
void link(int x, int y) {
mkrt(x);
access(y);
splay(y);
fa[x] = y;
lsz[y] += sz[x];
upd(y);
}
void split(int x, int y) {
mkrt(x);
access(y);
splay(y);
}
void cut(int x, int y) {
split(x, y);
ch[y][0] = fa[x] = 0;
upd(y);
}
int getsz(int x) {
access(x);
splay(x);
return sz[x];
}
int main() {
ios::sync_with_stdio(0);
cin >> N >> M;
int cnt = N;
for (int i = 1; i <= N; ++i) nsz[i] = sz[i] = 1;
for (int i = 1; i <= M; ++i) {
int u, v, w;
cin >> u >> v >> w;
S[i] = u;
T[i] = v;
mxid[N + i] = N + i;
val[N + i] = W[i] = w;
if (fdrt(u) != fdrt(v)) {
int p = getsz(u), q = getsz(v);
cnt -= (p & 1) + (q & 1) - ((p + q) & 1);
link(u, N + i);
link(v, N + i);
Edge.insert(make_pair(w, i));
} else {
split(u, v);
if (mx[ch[v][0]] > w) {
int t = mxid[ch[v][0]] - N;
cut(S[t], t + N);
cut(T[t], t + N);
link(u, N + i);
link(v, N + i);
Edge.erase(make_pair(W[t], t));
Edge.insert(make_pair(w, i));
}
}
if (cnt)
cout << "-1\n";
else {
while (!Edge.empty()) {
int t = (--Edge.end())->second;
split(S[t], T[t]);
if (sz[S[t]] & 1) break;
cut(S[t], N + t);
cut(T[t], N + t);
Edge.erase(--Edge.end());
}
cout << (--Edge.end())->first << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << ((n + 1) / 2 - 1) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, inf = 1061109567;
const long long infll = 4557430888798830399;
int y, b, r;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> y >> b >> r;
int ans1, ans2, ans3;
ans1 = ans2 = ans3 = 0;
if (y + 1 <= b && y + 2 <= r) ans1 = 3 * y + 3;
if (b - 1 <= y && b + 1 <= r) ans2 = 3 * b;
if (r - 2 <= y && r - 1 <= b) ans3 = 3 * r - 3;
cout << max(ans1, max(ans2, ans3));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1505;
char adj[N][N];
int vis[N][N], dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int n, m;
bool dfs(int x, int y, int markx, int marky) {
for (int i = 0; i < 4; i++) {
int xx = x + dir[i][0], yy = y + dir[i][1];
int imarkx = markx, imarky = marky;
if (xx < 0) imarkx++;
if (xx >= n) imarkx--;
if (yy < 0) imarky++;
if (yy >= m) imarky--;
xx = (xx + n) % n;
yy = (yy + m) % m;
if (adj[xx][yy] == '#') continue;
if (vis[xx][yy] == 0) {
vis[xx][yy] = imarkx * N + imarky;
if (dfs(xx, yy, imarkx, imarky)) return true;
} else {
if (vis[xx][yy] != (imarkx * N + imarky)) {
return true;
}
}
}
return false;
}
int main() {
int aimx, aimy;
while (scanf("%d%d", &n, &m) != EOF) {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) {
scanf("%s", adj[i]);
for (int j = 0; j < m; j++) {
if (adj[i][j] == 'S') {
aimx = i;
aimy = j;
}
}
}
vis[aimx][aimy] = N * N + N;
if (dfs(aimx, aimy, N, N))
puts("Yes");
else
puts("No");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, h;
cin >> n >> m >> h;
h--;
int sum = 0;
int Q = 0;
for (int i = (0); i < (m); ++i) {
int t;
cin >> t;
if (i == h) Q = t;
sum += t;
}
if (sum < n) {
cout << "-1\n";
return 0;
}
sum--;
Q--;
n--;
double ans = 1.0;
int it1 = sum - Q - n + 1;
int up1 = sum - n;
int it2 = sum - Q + 1;
int up2 = sum;
double eps = 1e-15;
bool bx = true;
while ((it1 <= up1 || it2 <= up2) && bx) {
bx = false;
if (ans < eps) {
while (it1 <= up1 && ans < 1e9) {
ans *= it1;
it1++;
bx = true;
}
}
while (it2 <= up2 && ans > 1e-9) {
ans = 1.0 * ans / it2;
it2++;
bx = true;
}
}
while (it1 <= up1) {
ans *= 1.0 * it1;
it1++;
}
while (it2 <= up2) {
ans = 1.0 * ans / it2;
it2++;
}
printf("%.8f\n", 1.0 - ans);
return 0;
}
| 2 |
#include <map>
#include <vector>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
vector<long long> A004394 = {
1, 2, 4, 6, 12,
24, 36, 48, 60, 120,
180, 240, 360, 720, 840,
1260, 1680, 2520, 5040, 10080,
15120, 25200, 27720, 55440, 110880,
166320, 277200, 332640, 554400, 665280,
720720, 1441440, 2162160, 3603600, 4324320,
7207200, 8648640, 10810800, 21621600, 36756720,
61261200, 73513440, 122522400, 147026880, 183783600,
367567200, 698377680, 735134400, 1102701600, 1163962800,
1396755360, 2327925600, 2793510720, 3491888400, 6983776800,
13967553600, 20951330400, 27935107200, 41902660800, 48886437600,
80313433200, 160626866400, 321253732800, 481880599200, 642507465600,
963761198400, 1124388064800, 1927522396800, 2248776129600, 3373164194400,
4497552259200, 4658179125600, 6746328388800, 9316358251200, 13974537376800,
18632716502400, 27949074753600, 32607253879200, 55898149507200, 65214507758400,
97821761637600, 130429015516800, 144403552893600, 195643523275200, 288807105787200,
433210658680800, 577614211574400, 866421317361600
};
std::map<unsigned long long, unsigned> prime_factorize(unsigned long long x) {
std::map<unsigned long long, unsigned> ret;
for (unsigned i = 2; 1ULL * i * i <= x; i++) {
while (x % i == 0) x /= i, ret[i]++;
}
if (x != 1) ret[x]++;
return ret;
}
unsigned long long divisor_function(unsigned long long x, int r = 1) {
std::map<unsigned long long, unsigned> res = prime_factorize(x);
unsigned long long ret = 1;
for (std::pair<unsigned long long, unsigned> w : res) {
unsigned long long mulexp = 1, mul = 1, sum = 1;
for (int i = 0; i < r; i++) mulexp *= w.first;
for (int i = 0; i < w.second; i++) mul *= mulexp, sum += mul;
ret *= sum;
}
return ret;
}
long long n;
int main() {
while (cin >> n, n) {
int ptr = lower_bound(A004394.begin(), A004394.end(), n + 1) - A004394.begin() - 1;
cout << fixed << setprecision(15) << 1.0 * divisor_function(A004394[ptr], 1) / A004394[ptr] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int W, H, N;
cin >> W >> H >> N;
vector<int> mx(W);
for(int i=0;i<N;++i){
int x, y;
cin >> x >> y;
mx[x] = max(mx[x], y);
}
int ans = 1e9;
int mx_y = 0;
for(int x=W-1;x>=0;--x){
ans = min(ans, x + mx_y);
mx_y = max(mx_y, mx[x]);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200007;
const long long int inf = 0x3f3f3f3f;
const int mod = 998244353;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
long long int t, n, m, x, y, z, ans = 0, cnt = 0, temp = 0, f = 0;
vector<int> v1, v2, v3;
string s1, s2, s3;
long long int a[100000], b[100000];
t = read();
while (t--) {
x = read();
y = read();
n = read();
long long int price = read();
temp = min(x, price / n);
price -= (temp * n);
if (price <= y)
cout << "YES" << '\n';
else
cout << "NO"
<< "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6;
vector<pair<int, int> > x;
int cnt[MAXN];
int pref[MAXN];
int32_t main() {
int n, k, q;
scanf("%d%d%d", &n, &k, &q);
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d%d", &l, &r);
x.push_back(make_pair(l, 1));
x.push_back(make_pair(r + 1, -1));
}
sort(x.begin(), x.end());
fill(cnt, cnt + MAXN, 0);
int last = 0, cur = 0;
for (int i = 0; i < (int)x.size(); i++) {
for (int j = last; j <= x[i].first; j++) cnt[j] = cur;
cnt[x[i].first] += x[i].second;
cur += x[i].second;
last = x[i].first + 1;
}
pref[0] = 0;
for (int i = 1; i < MAXN; i++) pref[i] = pref[i - 1] + (cnt[i - 1] >= k);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", pref[r + 1] - pref[l]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[500009], s1[500009];
int mod = 10000019;
long long b[500009], c[500009];
long long ksm(long long a, long long n, long long d) {
long long ans;
ans = 1;
while (n > 0) {
if (n % 2 == 1) ans = (ans * a) % d;
a = a * a % d;
n = n / 2;
}
return ans % d;
}
int main() {
cin >> s1 + 1;
cin >> s + 1;
int n, m;
n = strlen(s + 1);
m = strlen(s1 + 1);
int k1 = 0, k0 = 0;
for (int i = 1; i <= m; i++) {
if (s1[i] == '0')
k0++;
else
k1++;
}
for (int i = 1; i <= n; i++) {
b[i] = b[i - 1] * 5 % mod + (s[i] - '0' + 1);
b[i] %= mod;
}
for (int i = n; i >= 1; i--) {
c[i] = c[i + 1] + (s[i] - '0' + 1) * ksm(5, n - i, mod);
c[i] %= mod;
}
int maxx = 0;
for (int i = 1; i < n; i++) {
if (b[i] == c[n - i + 1]) maxx = i;
}
int kk1 = 0, kk0 = 0, kb1 = 0, kb0 = 0;
for (int i = 1; i <= maxx; i++) {
if (s[i] == '0')
kk0++;
else
kk1++;
}
for (int i = 1; i <= n; i++) {
if (s[i] == '0')
kb0++;
else
kb1++;
}
kk0 = kb0 - kk0;
kk1 = kb1 - kk1;
if (k1 >= kb1 && k0 >= kb0) {
cout << s + 1;
k1 -= kb1;
k0 -= kb0;
}
while (k1 >= kk1 && k0 >= kk0) {
k1 -= kk1;
k0 -= kk0;
for (int i = maxx + 1; i <= n; i++) cout << s[i];
}
for (int i = 1; i <= k0; i++) cout << '0';
for (int i = 1; i <= k1; i++) cout << '1';
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long big = 1000000007;
int n, m, k, T, q;
int main() {
int a, b, c, d;
scanf("%d", &n);
scanf("%d", &a);
scanf("%d", &b);
vector<long long> ANS(n);
bool fail = 1;
for (int c1 = 0; c1 < n; c1++) {
if (a * c1 > n) break;
if ((n - a * c1) % b == 0) {
fail = 0;
long long c2 = (n - a * c1) / b;
for (int c3 = 0; c3 < c1; c3++) {
for (int c4 = c3 * a; c4 < c3 * a + a; c4++) {
if (c4 < c3 * a + a - 1) {
ANS[c4] = c4 + 1;
} else {
ANS[c4] = c3 * a;
}
}
}
for (int c3 = 0; c3 < c2; c3++) {
long long down = c3 * b + c1 * a;
long long up = c3 * b + b + c1 * a;
for (int c4 = c3 * b + c1 * a; c4 < up; c4++) {
if (c4 < up - 1) {
ANS[c4] = c4 + 1;
} else {
ANS[c4] = down;
}
}
}
break;
}
}
if (fail) {
cout << "-1\n";
} else {
for (int c1 = 0; c1 < n; c1++) {
cout << ANS[c1] + 1 << " ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e16;
int main() {
long long N, K;
int i;
cin >> N >> K;
vector<int> A(N + 1);
vector<long long> Pre(N + 1, INF);
vector<long long> Suf(N + 1, INF);
for (i = 0; i <= N; ++i) cin >> A[i];
Suf[N] = Pre[0] = 0;
for (i = 0; i < N; ++i) {
if (abs(Pre[i] + A[i]) % 2) break;
Pre[i + 1] = (Pre[i] + A[i]) >> 1LL;
}
for (i = N; i >= 1; --i) {
if (abs(Suf[i] + A[i]) * 2LL > INF) break;
Suf[i - 1] = (Suf[i] + A[i]) * 2;
}
long long ans = 0;
for (i = 0; i <= N; ++i) {
if (Suf[i] != INF && Pre[i] != INF && abs(Pre[i] + Suf[i]) <= K) ++ans;
}
if (Suf[N] + Pre[N] == 0) --ans;
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin >> N >> M;
vector<int> c(N,0);
for(int i=0;i<M;i++){
int a,b;
cin >> a >> b;
c[a-1]++;
c[b-1]++;
}
for(int i=0;i<N;i++){
if(c[i]%2==1){
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 0 |
#include <iostream>
#include <map>
int main() {
using i64 = long long;
int n;
std::cin >> n;
std::map<i64, i64> mp({{0, 1}});
i64 ans = 0, acc = 0;
while (n--) {
i64 a;
std::cin >> a;
ans += mp[acc += a]++;
}
std::cout << ans << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, t;
cin >> n >> t;
vector<pair<int, int>> kek(n);
for (int i = 0; i < n; ++i) {
cin >> kek[i].first >> kek[i].second;
}
sort(kek.begin(), kek.end());
vector<int> dp(t + 3228);
for (int i = 0; i < n; ++i) {
int a = kek[i].first, b = kek[i].second;
auto ndp = dp;
for (int j = 0; j < t; ++j) {
ndp[j + a] = max(ndp[j + a], dp[j] + b);
}
dp = ndp;
}
cout << *max_element(dp.begin(), dp.end());
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 5;
int n, a[N];
static inline int lg(int x) { return 32 - __builtin_clz(x) - 1; }
struct Sparse {
static const int mk = 19;
int* tb[mk];
int* orr[mk];
Sparse(int* a, int n) {
for (int i = 0; i < mk; i++) {
tb[i] = new int[n + 5];
orr[i] = new int[n + 5];
}
for (int i = 0; i < n; i++) {
tb[0][i] = a[i];
orr[0][i] = a[i];
}
for (int k = 1; k <= lg(n); k++) {
for (int i = 0; i < n; i++) {
int nx = i + (1 << (k - 1));
if (nx < n) {
tb[k][i] = max(tb[k - 1][i], tb[k - 1][nx]);
orr[k][i] = orr[k - 1][i] | orr[k - 1][nx];
} else {
tb[k][i] = tb[k - 1][i];
orr[k][i] = orr[k - 1][i];
}
}
}
}
int getmax(int l, int r) {
int g = lg(r - l + 1);
return max(tb[g][l], tb[g][r - (1 << g) + 1]);
}
int getor(int l, int r) {
int g = lg(r - l + 1);
return orr[g][l] | orr[g][r - (1 << g) + 1];
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
Sparse st(a, n);
int K = lg(n) + 2;
ll ans = 0;
for (int i = 0; i < n; i++) {
int curOR = a[i];
int curIdx = i;
int prevIdx = i;
int add = 0;
while (true) {
curIdx++;
prevIdx = curIdx;
curOR = st.getor(i, curIdx);
int cor = curOR;
if (st.getor(i, curIdx + 1) == curOR) {
for (int k = K; k >= 0; k--) {
if (curIdx + (1 << k) >= n) continue;
int ni = curIdx + (1 << k);
if (st.getor(i, ni) == curOR) {
cor |= st.orr[k][curIdx];
curIdx = ni;
}
}
}
if (curIdx >= n) break;
int r = prevIdx - 1;
int cmax = st.getmax(i, curIdx);
for (int k = K; k >= 0; k--) {
if (r + (1 << k) > curIdx) continue;
int ni = r + (1 << k);
if (st.getmax(i, ni) < curOR) {
cmax = max(cmax, st.tb[k][r]);
r = ni;
}
}
add += (r - prevIdx + 1);
}
ans += add;
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool operator<(const pair<int, int> a, const int b) { return a.first < b; }
long long int a[200005], b[200005];
pair<int, int> c[200005];
int main() {
long long int n, m, k, s;
scanf("%I64d %I64d %I64d", &n, &m, &k);
long long int first;
scanf("%I64d %I64d", &first, &s);
for (int i = 0; i < m; i++) scanf("%I64d", &a[i]);
for (int i = 0; i < m; i++) scanf("%I64d", &b[i]);
map<int, int> mm;
for (int i = 0; i < k; i++) scanf("%d", &c[i].second);
for (int i = 0; i < k; i++) scanf("%d", &c[i].first);
sort(c, c + k);
for (int i = 1; i < k; i++)
if (c[i].second < c[i - 1].second) c[i].second = c[i - 1].second;
for (int i = 0; i < k; i++) mm[c[i].first] = c[i].second;
long long int ans = first * n;
map<int, int>::iterator it = mm.upper_bound(s);
if (it != mm.begin()) it--, ans -= first * (it->second);
for (int i = 0; i < m; i++) {
int ss = s - b[i];
it = mm.upper_bound(ss);
if (it == mm.begin()) {
if (ss >= 0) ans = min(a[i] * n, ans);
continue;
}
it--;
ans = min(a[i] * (n - it->second), ans);
}
printf("%I64d", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 20, R = 1 << M, inf = 1e9;
int arr[M][N], sz[M];
int f[R];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, d;
cin >> n >> m >> d;
for (int i = 0; i < m; i++) {
cin >> sz[i];
for (int j = 0; j < sz[i]; j++) {
int t;
cin >> t;
arr[i][j] = t;
}
sort(arr[i], arr[i] + sz[i]);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < sz[i]; j++) {
int need;
if (j == sz[i] - 1 || arr[i][j + 1] > arr[i][j] + d)
need = 0;
else
need = (1 << i);
for (int k = 0; k < m; k++) {
if (i == k) continue;
int ind = upper_bound(arr[k], arr[k] + sz[k], arr[i][j]) - arr[k];
if (ind == sz[k]) continue;
if (arr[k][ind] <= arr[i][j] + d) need |= (1 << k);
}
if (arr[i][j] <= n - d) f[need] |= (1 << i);
}
}
for (int mask = 0; mask < (1 << m); mask++) {
for (int j = 0; j < m; j++) {
if (mask & (1 << j)) f[mask] |= f[mask - (1 << j)];
}
}
int cnt = m;
for (int mask = 1; mask < (1 << m); mask++) {
int bad = (1 << m) - mask - 1, ted = 0, mini = inf;
if ((mask & f[bad]) == 0) {
for (int j = 0; j < m; j++) {
if (mask & (1 << j)) {
ted++;
mini = min(mini, arr[j][0]);
}
}
if (mini <= d) cnt = min(cnt, ted);
}
}
cout << cnt << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[10005];
int a[30], sum, k, len;
while (scanf("%s", s + 1) == 1) {
sum = 0;
scanf("%d", &k);
memset(a, 0, sizeof(a));
len = strlen(s + 1);
if (len < k) {
printf("impossible\n");
continue;
}
for (int i = 1; i <= len; i++) {
a[s[i] - 'a' + 1]++;
}
for (int i = 1; i <= 26; i++) {
if (a[i]) {
sum++;
}
}
if (sum >= k)
printf("0\n");
else
printf("%d\n", k - sum);
memset(s, 0, sizeof(s));
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
set<int> t;
int T, n;
int a[maxn], num[maxn];
int lpos[maxn], rpos[maxn];
int main() {
cin >> T;
while (T--) {
cin >> n;
for (int i = 1; i <= n; i++) lpos[i] = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) rpos[a[i]] = i;
for (int i = n; i >= 1; i--) lpos[a[i]] = i;
int lastpos = 0, len = 0, num = 0, maxlen = 0;
for (int i = 1; i <= n; i++) {
if (lpos[i]) {
if (lastpos < lpos[i])
len++;
else
len = 1;
num++;
maxlen = max(len, maxlen);
lastpos = rpos[i];
}
}
cout << num - maxlen << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int sigma = 26;
int sumv[N << 2][sigma], setv[N << 2];
int cnt[26];
char str[N];
void pushUp(int o) {
for (int i = 0; i < sigma; i++) {
sumv[o][i] = sumv[(o << 1)][i] + sumv[(o << 1 | 1)][i];
}
}
void initNode(int o) { memset(sumv[o], 0, sizeof(sumv[o])); }
void pushDown(int o, int L, int R) {
int M = (L + R) / 2;
if (setv[o] != -1) {
setv[(o << 1)] = setv[(o << 1 | 1)] = setv[o];
initNode((o << 1));
sumv[(o << 1)][setv[o]] = (M - L + 1);
initNode((o << 1 | 1));
sumv[(o << 1 | 1)][setv[o]] = (R - M);
setv[o] = -1;
}
}
void build(int o, int L, int R) {
if (L == R) {
initNode(o);
sumv[o][str[L] - 'a'] = 1;
setv[o] = str[L] - 'a';
return;
}
setv[o] = -1;
int M = (L + R) / 2;
build((o << 1), L, M);
build((o << 1 | 1), M + 1, R);
pushUp(o);
}
int query(int o, int L, int R, int ql, int qr, int val) {
if (ql <= L && R <= qr) return sumv[o][val];
pushDown(o, L, R);
int M = (L + R) / 2, ret = 0;
if (ql <= M) ret += query((o << 1), L, M, ql, qr, val);
if (qr > M) ret += query((o << 1 | 1), M + 1, R, ql, qr, val);
return ret;
}
void modify(int o, int L, int R, int ql, int qr, int val) {
if (ql <= L && R <= qr) {
for (int i = 0; i < sigma; i++) sumv[o][i] = 0;
setv[o] = val;
sumv[o][setv[o]] = (R - L + 1);
return;
}
pushDown(o, L, R);
int M = (L + R) / 2;
if (ql <= M) modify((o << 1), L, M, ql, qr, val);
if (qr > M) modify((o << 1 | 1), M + 1, R, ql, qr, val);
pushUp(o);
}
void getStr(int o, int L, int R) {
if (L == R) {
printf("%c", (char)('a' + setv[o]));
return;
}
pushDown(o, L, R);
int M = (L + R) / 2;
getStr((o << 1), L, M);
getStr((o << 1 | 1), M + 1, R);
}
int n, q;
int main() {
while (scanf("%d%d", &n, &q) != EOF) {
scanf("%s", str + 1);
build(1, 1, n);
int ql, qr, ch;
while (q--) {
scanf("%d%d%d", &ql, &qr, &ch);
for (int i = 0; i < sigma; i++) cnt[i] = query(1, 1, n, ql, qr, i);
int pos = ql;
if (ch == 1) {
for (int i = 0; i < sigma; i++) {
if (cnt[i] > 0) modify(1, 1, n, pos, pos + cnt[i] - 1, i);
pos += cnt[i];
}
} else {
for (int i = sigma - 1; i >= 0; i--) {
if (cnt[i] > 0) modify(1, 1, n, pos, pos + cnt[i] - 1, i);
pos += cnt[i];
}
}
}
getStr(1, 1, n);
puts("");
}
return 0;
}
| 5 |
#include <iostream>
int memo[101][101] = {-1};
int x[3][5] = {{1,2,6,5,1}, {1,3,6,4,1}, {2,3,5,4,2}};
int sides[3][2] = {{4, 3}, {2, 5}, {6, 1}};
int main() {
int dice_a[7], dice_b[7];
int top, front, q;
char command;
for (int i = 1; i < 7; i ++)
std::cin >> dice_a[i];
for (int i = 1; i < 7; i ++)
std::cin >> dice_b[i];
for (int j = 0; j < 3; j ++) {
for (int i = 1; i < 5; i ++) {
memo[dice_a[x[j][i]]][dice_a[x[j][i-1]]] = dice_a[sides[j][0]];
memo[dice_a[x[j][i-1]]][dice_a[x[j][i]]] = dice_a[sides[j][1]];
}
}
if (memo[dice_b[1]][dice_b[2]] == dice_b[3]
&& memo[dice_b[2]][dice_b[1]] == dice_b[4]) {
std::cout << "Yes" << std::endl;
} else {
std::cout << "No" << std::endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e4 + 10;
set<int> s;
int a[MAXN], tedad = 0;
map<int, int> ind, cnt;
vector<int> v;
bool mark[MAXN];
void change(int id, int p) {
auto itr = s.lower_bound(id);
int b = -1e9, f = -1e9;
if (itr != s.begin()) {
itr--;
int num = a[id] - a[*itr];
b = a[*itr];
cnt[num] += p;
if (p == -1 and cnt[num] == 0) tedad--;
if (p == +1 and cnt[num] == 1) tedad++;
itr++;
}
if (p == -1) itr++;
if (itr != s.end()) {
int num = a[*itr] - a[id];
f = a[*itr];
cnt[num] += p;
if (p == -1 and cnt[num] == 0) tedad--;
if (p == +1 and cnt[num] == 1) tedad++;
}
if (b != -1e9 and f != -1e9) {
cnt[f - b] += -p;
if (p == +1 and cnt[f - b] == 0) tedad--;
if (p == -1 and cnt[f - b] == 1) tedad++;
}
if (p == -1)
s.erase(id);
else
s.insert(id);
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], ind[a[i]] = i;
if (n == 2) {
cout << a[0] << endl << a[1] << endl;
return 0;
}
for (int i = 0; i < n; i++) change(i, 1);
for (int i = 1; i < n; i++) {
int dis = a[i] - a[0];
int id = 0;
while (id < n and tedad > 1) {
v.push_back(id);
change(id, -1);
int id2 = ind[a[id] + dis];
if (id2 == 0 or id2 < id) break;
id = id2;
}
if (tedad == 1) {
if (v.size() == 0) v.push_back(0);
if (int(v.size()) == n) v.pop_back();
for (auto u : v) mark[u] = true;
for (auto u : v) cout << a[u] << ' ';
cout << endl;
for (int j = 0; j < n; j++)
if (mark[j] == false) cout << a[j] << ' ';
cout << endl;
return 0;
} else {
for (auto u : v) change(u, 1);
v.clear();
}
}
cout << "No solution" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int re[1010][1010];
vector<pair<int, int> > ans;
int main() {
int n, k;
scanf("%d%d", &n, &k);
if (2 * k > n - 1) {
printf("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1, cnt = 0; j <= n && cnt < k; j++) {
if (i == j || re[i][j]) continue;
cnt++;
re[i][j] = 1;
re[j][i] = 1;
ans.push_back({i, j});
if (j == n && cnt < k) {
printf("-1");
return 0;
}
}
}
printf("%d\n", n * k);
for (auto x : ans) printf("%d %d\n", x.first, x.second);
}
| 1 |
#include <cstdio>
#include <vector>
#include <cstring>
#define pb push_back
#define catans(x) for(int i=1;i<=kn[x];++i)k[++pt]=(i-1)*3+x
using namespace std;vector<int> c[2];int id[200001],ans[200001],k[200001],n,pt,kn[4];
struct edge{int v,next;edge(){}edge(int _v,int _next){v=_v;next=_next;}}e[400001];int head[200001],sz;
void init(){memset(head,-1,sizeof(head));sz=0;}void insert(int u,int v){e[++sz]=edge(v,head[u]);head[u]=sz;}
void dfs(int u,int f,int d){c[d].pb(u);for(int i=head[u];~i;i=e[i].next)if(e[i].v!=f)dfs(e[i].v,u,d^1);}
int main()
{
scanf("%d",&n);init();for(int i=1;i<n;++i){int u,v;scanf("%d%d",&u,&v);insert(u,v);insert(v,u);}
dfs(1,0,0);if(c[0].size()>c[1].size())swap(c[0],c[1]);kn[3]=n/3;kn[1]=(n+2)/3;kn[2]=(n+1)/3;
for(int i=1;i<=c[0].size();++i)id[i]=c[0][i-1];for(int i=1;i<=c[1].size();++i)id[i+c[0].size()]=c[1][i-1];
if(n/3>=c[0].size()){catans(3);catans(1);catans(2);}else{catans(1);catans(3);catans(2);}
for(int i=1;i<=n;++i)ans[id[i]]=k[i];for(int i=1;i<=n;++i)printf("%d ",ans[i]);putchar(10);return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int64_t n;
int m, a[4000];
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i];
}
sort(a, a + m);
if (a[0] == 1 || a[m - 1] == n) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < m; i++) {
if (a[i] + 1 == a[i + 1] && a[i] + 2 == a[i + 2]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int N = 500010;
vector<int> E[N], a;
int n, q, l[N], r[N], parent[N];
bool it[N * 4], val[N * 4], lazy[N * 4];
void dfs(int u, int par) {
a.push_back(u);
l[u] = ((int)(a).size()) - 1;
for (int i = 0; i < (((int)(E[u]).size())); ++i) {
int v = E[u][i];
if (v == par) continue;
parent[v] = u;
dfs(v, u);
}
r[u] = ((int)(a).size()) - 1;
}
void update(int id, int le, int ri, int u, int v, int vv) {
if (lazy[id]) {
it[id] = val[id];
if (le < ri) {
lazy[id * 2] = true;
lazy[id * 2 + 1] = true;
val[id * 2] = val[id];
val[id * 2 + 1] = val[id];
}
lazy[id] = false;
}
if (le > v || ri < u) return;
if (u <= le && ri <= v) {
it[id] = vv;
if (le < ri) {
lazy[id * 2] = true;
lazy[id * 2 + 1] = true;
val[id * 2] = vv;
val[id * 2 + 1] = vv;
}
return;
}
int mid = (le + ri) >> 1;
update(id * 2, le, mid, u, v, vv);
update(id * 2 + 1, mid + 1, ri, u, v, vv);
it[id] = it[id * 2] | it[id * 2 + 1];
}
bool get(int id, int le, int ri, int u, int v) {
if (lazy[id]) {
it[id] = val[id];
if (le < ri) {
lazy[id * 2] = true;
lazy[id * 2 + 1] = true;
val[id * 2] = val[id];
val[id * 2 + 1] = val[id];
}
lazy[id] = false;
}
if (le > v || ri < u) return false;
if (u <= le && ri <= v) return it[id];
int mid = (le + ri) >> 1;
return get(id * 2, le, mid, u, v) | get(id * 2 + 1, mid + 1, ri, u, v);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < (n - 1); ++i) {
int u, v;
cin >> u >> v;
E[u].push_back(v);
E[v].push_back(u);
}
dfs(1, 1);
memset(it, true, sizeof(it));
cin >> q;
for (int i = 0; i < (q); ++i) {
int t, u;
cin >> t >> u;
if (t == 1) {
bool notFilled = get(1, 0, n - 1, l[u], r[u]);
if (notFilled && u != 1) {
int par = parent[u];
update(1, 0, n - 1, l[par], l[par], true);
}
update(1, 0, n - 1, l[u], r[u], false);
} else if (t == 2) {
update(1, 0, n - 1, l[u], l[u], true);
} else {
bool ok = get(1, 0, n - 1, l[u], r[u]);
cout << !ok << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,A=1;
cin>>n;
int a[n],b[4]={0,0,0,0};
for(int i=0;i<n;i++){
cin>>a[i];
a[i]%=4;
b[a[i]]++;
}
if((b[1]+b[3])>b[0]) A=0;
if(b[1]+b[3]==b[0]+1&&b[2]==0) A=1;
cout<<((A) ? "Yes":"No")<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int fa[N];
int find(int x) { return fa[x] == 0 ? x : fa[x] = find(fa[x]); }
void mrg(int x, int y) {
x = find(x), y = find(y);
if (x != y) fa[y] = x;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
mrg(i, x);
}
int ans = 0;
for (int i = 1; i <= n; i++)
if (fa[i] == 0) ans++;
printf("%d\n", ans);
return 0;
}
| 3 |
#include<iostream>
#include<cstdio>
#include<map>
#include<vector>
#include<string>
using namespace std;
vector<int> list[100];
int item[100];
int saiki(int n){
if(list[n].empty()==1){
return item[n];
}
int cont=0;
for(int i=0;i<list[n].size();i++){
cont+=saiki(list[n][i]);
}
return min(cont,item[n]);
}
int main(){
while(1){
map<string,int> name;
int n;
cin>>n;
if(n==0){
break;
}
for(int i=0;i<n;i++){
string a;int b;
cin>>a>>b;
name[a]=i;
item[i]=b;
}
for(int i=0;i<100;i++){
list[i].clear();
}
int m;
cin>>m;
for(int i=0;i<m;i++){
string a;int b;
cin>>a>>b;
for(int j=0;j<b;j++){
string c;
cin>>c;
list[name[a]].push_back(name[c]);
}
}
string a;
cin>>a;
printf("%d\n",saiki(name[a]));
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
int L[MAXN];
vector<int> A[MAXN];
priority_queue<int> pq[MAXN], pqt[MAXN];
vector<pair<int, int> > v[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int N, W;
cin >> N >> W;
for (int i = 0; i < N; i++) {
cin >> L[i];
A[i].resize(L[i]);
for (int j = 0; j < L[i]; j++) cin >> A[i][j];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < L[i]; j++) {
v[j].push_back(make_pair(i, A[i][j]));
v[W - L[i] + j + 1].push_back(make_pair(i + N, A[i][j]));
}
v[0].push_back(make_pair(i, 0));
v[W - L[i]].push_back(make_pair(i + N, 0));
v[L[i]].push_back(make_pair(i, 0));
}
long long sum = 0;
for (int i = 0; i < W; i++) {
for (auto a : v[i]) {
if (!pq[a.first % N].empty()) sum -= pq[a.first % N].top();
if (a.first < N)
pq[a.first].push(a.second);
else
pqt[a.first - N].push(a.second);
a.first %= N;
while (!pqt[a.first].empty() && pq[a.first].top() == pqt[a.first].top()) {
pq[a.first].pop();
pqt[a.first].pop();
}
if (!pq[a.first].empty()) sum += pq[a.first].top();
}
cout << sum << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<int> se[1000001];
int where[1000001];
int sz = 1;
int cnt;
int a[500005];
pair<int, int> b[500005];
int bc;
vector<int> cur;
inline bool cmp(const int &lhs, const int &rhs) {
return where[lhs] < where[rhs];
}
void update() {
sort(cur.begin(), cur.end(), cmp);
int cnt = int(cur.size());
for (int beg = 0; beg < cnt;) {
int end = beg + 1;
while (end < cnt && where[cur[beg]] == where[cur[end]]) {
++end;
}
int w = where[cur[beg]];
if (int(se[w].size()) > end - beg) {
for (int i = beg; i < end; ++i) {
se[w].erase(cur[i]);
}
for (int i = beg; i < end; ++i) {
se[sz].insert(cur[i]);
where[cur[i]] = sz;
}
++sz;
}
beg = end;
}
}
const int MOD = int(1e9) + 7;
int fac[1000005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)(m); ++i) {
se[0].insert(i + 1);
where[i + 1] = 0;
}
for (int _ = 0; _ < (int)(n); ++_) {
scanf("%d", &cnt);
for (int i = 0; i < (int)(cnt); ++i) {
scanf("%d", a + i);
}
sort(a, a + cnt);
cur.clear();
bc = 0;
for (int beg = 0; beg < cnt;) {
int end = beg + 1;
while (end < cnt && a[beg] == a[end]) {
++end;
}
b[bc++] = make_pair(end - beg, a[beg]);
beg = end;
}
sort(b, b + bc);
for (int beg = 0; beg < bc;) {
int end = beg + 1;
while (end < bc && b[beg].first == b[end].first) {
++end;
}
cur.clear();
for (int i = beg; i < end; ++i) {
cur.push_back(b[i].second);
}
update();
beg = end;
}
}
fac[0] = 1;
for (int i = 1; i < 1000005; ++i) {
fac[i] = (long long)fac[i - 1] * i % MOD;
}
int ans = 1;
for (int i = 0; i < (int)(sz); ++i) {
ans = (long long)ans * fac[int(se[i].size())] % MOD;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gi() {
T x = 0;
bool f = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') f = 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f ? -x : x;
}
const int N = 310;
int cnt, dep[N];
vector<int> e[N];
bool vis[N], flg;
void query(int x) {
if (!e[x].size()) {
if (cnt++ == 16) {
e[x].resize(2);
return;
}
printf("? %d\n", x);
fflush(stdout);
int k = gi<int>();
if (!k) exit(0);
for (int i = 0; i < k; i++) e[x].push_back(gi<int>());
}
}
void bfs(int s) {
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
query(u);
q.pop();
if (e[u].size() == 2) {
printf("! %d\n", u);
fflush(stdout);
return;
}
for (auto v : e[u])
if (!vis[v]) vis[v] = 1, q.push(v);
}
}
int h, n;
int dfs(int u, int ff, int d) {
query(u);
if (d == h - 1) return h - 1;
if (e[u].size() == 2) {
printf("! %d\n", u);
fflush(stdout);
flg = 1;
return 0;
}
for (auto v : e[u])
if (v != ff) return dfs(v, u, d + 1) + 1;
return 1;
}
void solve() {
h = gi<int>(), n = pow(2, h) - 1;
if (!h) exit(0);
for (int i = 1; i <= n; i++) e[i].clear(), vis[i] = 0, dep[i] = 0;
int x = 1;
flg = 0;
cnt = 0;
while (1) {
if (dep[x] == 1) {
printf("! %d\n", x);
fflush(stdout);
return;
}
query(x);
vis[x] = 1;
if (e[x].size() == 2) {
printf("! %d\n", x);
fflush(stdout);
return;
}
if (e[x].size() == 1) {
dep[x] = h;
x = e[x][0];
dep[x] = h - 1;
continue;
}
if (dep[x] == 3) {
bfs(x);
return;
}
if (!dep[x]) {
if (e[x].size() == 1)
dep[x] = h;
else {
int d1 = h - dfs(e[x][0], x, 1);
if (flg) return;
int d2 = h - dfs(e[x][1], x, 1);
if (flg) return;
if (d1 == d2)
dep[e[x][2]] = d1 - 1, x = e[x][2];
else if (d1 < d2)
dep[e[x][0]] = d2 - 1, x = e[x][0];
else
dep[e[x][1]] = d1 - 1, x = e[x][1];
}
} else {
if (vis[e[x][0]]) e[x][0] = e[x][1], e[x][1] = e[x][2];
if (vis[e[x][1]]) swap(e[x][1], e[x][2]);
int d = h - dfs(e[x][0], x, 1);
if (flg) return;
if (d == dep[x])
dep[e[x][1]] = dep[x] - 1, x = e[x][1];
else
dep[e[x][0]] = dep[x] - 1, x = e[x][0];
}
}
}
int main() {
int T = gi<int>();
while (T--) solve();
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int n;
long long sum[202020],ans=1e18+10;
void get(int l,int r,long long &f,long long &s)
{
long long res=1e18+10;
int ll=1,rr=r-1;
while(ll<=rr)
{
int mid=ll+rr>>1;
long long a=sum[mid]-sum[l-1],b=sum[r]-sum[mid];
if(abs(a-b)<res)
{
res=abs(a-b);
f=a;
s=b;
}
if(a<=b)
{
ll=mid+1;
}
else
{
rr=mid-1;
}
}
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
int a;
cin>>a;
sum[i]=a+sum[i-1];
}
for(int i=2;i<=n-2;i++)
{
long long a,b,c,d,can;
get(1,i,a,b);
get(i+1,n,c,d);
can=max(max(a,b),max(c,d))-min(min(a,b),min(c,d));
ans=min(ans,can);
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int M, N, K;
int jt[1010][1010];
int ot[1010][1010];
int it[1010][1010];
int main() {
cin >> M >> N >> K;
for (int i=1; i<=M; i++) {
int hj = 0, ho = 0, hi = 0;
for (int j=1; j<=N; j++) {
char c; cin >> c;
jt[i][j] = jt[i-1][j] + hj;
ot[i][j] = ot[i-1][j] + ho;
it[i][j] = it[i-1][j] + hi;
if (c == 'J') { jt[i][j]++; hj++; }
if (c == 'O') { ot[i][j]++; ho++; }
if (c == 'I') { it[i][j]++; hi++; }
}
}
for (int i=0; i<K; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << jt[c][d] - jt[a-1][d] - jt[c][b-1] + jt[a-1][b-1] << " "
<< ot[c][d] - ot[a-1][d] - ot[c][b-1] + ot[a-1][b-1] << " "
<< it[c][d] - it[a-1][d] - it[c][b-1] + it[a-1][b-1] << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, match[1000010], Stack[1000010], tot;
bool f[1000010][2][2];
char s[1000010];
int main() {
cin >> n >> s;
n = strlen(s);
for (int i = 0; i < n; i++)
if (s[i] == '(')
Stack[++tot] = i;
else if (s[i] == ')') {
match[i] = Stack[tot];
match[Stack[tot--]] = i;
}
for (int i = 0; i < n; i++) {
switch (s[i]) {
case '0':
f[i][0][0] = 1;
break;
case '1':
f[i][1][1] = 1;
break;
case '?':
f[i][0][1] = f[i][1][0] = 1;
break;
case ')':
int P_oper = s[i - 1] == ')' ? (match[i - 1] - 1) : (i - 2);
char oper = s[P_oper];
int P_left = P_oper - 1;
int P_right = i - 1;
for (int p = 0; p < 2; p++)
for (int q = 0; q < 2; q++)
if (f[P_left][p][q])
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++)
if (f[P_right][x][y]) {
switch (oper) {
case '&':
f[i][p & x][q & y] = 1;
break;
case '|':
f[i][p | x][q | y] = 1;
break;
case '^':
f[i][p ^ x][q ^ y] = 1;
}
}
}
}
if (f[n - 1][0][1] || f[n - 1][1][0])
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ul = unsigned long long;
using ii = pair<int, int>;
const ll mod7 = 1000000007, mod1 = 1000000000, OO = 0x3f3f3f3f;
const ld EPS = 1e-7;
double Pi = acos(-1);
const ld rad = Pi / 180.0;
long long power(long long a, long long b, ll mod) {
if (!b) return 1ll;
if (b == 1) return a % mod;
long long r = power(a, b / 2ll, mod) % mod;
if (b % 2ll)
return ((r * (a % mod) % mod) * r) % mod;
else
return (r * r) % mod;
}
ll nCr(ll n, ll m) { return (m == 0) ? 1 : n * nCr(n - 1, m - 1) / m; }
bool checkDivisibility(ll n, int digit) {
return (digit == 0 || (digit != 0 && n % digit == 0));
}
bool allDigitsDivide(ll n) {
ll temp = n;
while (temp > 0) {
ll digit = temp % 10;
if (!(checkDivisibility(n, digit))) return false;
temp /= 10;
}
return true;
}
bool comp(pair<int, char> a, pair<int, char> b) { return a.first > b.first; }
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return (a / gcd(a, b)) * b; }
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int winner(int a, int b) {
if ((a == 1 && b == 2) || (a == 2 && b == 3) || (a == 3 && b == 1)) return 0;
if ((a == 2 && b == 1) || (a == 1 && b == 3) || (a == 3 && b == 2)) return 1;
if (a == b) return 2;
}
int alice[3][3];
int bob[3][3];
bool visited[4][4];
ll ctr = 0, x = 0, y = 0;
int n, m;
ll k;
void dfs(int a, int b) {
if (!visited[a][b] && ctr < k) {
if (winner(a, b) == 1)
x++;
else if (winner(a, b) == 0)
y++;
ctr++;
visited[a][b] = 1;
dfs(alice[a - 1][b - 1], bob[a - 1][b - 1]);
} else {
m = a;
n = b;
}
}
int main() {
int a, b;
cin >> k >> a >> b;
memset(visited, 0, sizeof(visited));
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) cin >> alice[i][j];
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) cin >> bob[i][j];
}
dfs(a, b);
if (ctr < k) {
ll cycle = 0, c = m, d = n, x1 = 0, y1 = 0;
while (true) {
if (winner(c, d) == 1)
x1++;
else if (winner(c, d) == 0)
y1++;
int temp1 = c, temp2 = d;
c = alice[temp1 - 1][temp2 - 1];
d = bob[temp1 - 1][temp2 - 1];
cycle++;
if (c == m && d == n) break;
}
ll z = k - ctr;
x += (x1 * (z / cycle));
y += (y1 * (z / cycle));
for (int i = 0; i < z % cycle; i++) {
if (winner(m, n) == 1)
x++;
else if (winner(m, n) == 0)
y++;
int temp1 = m, temp2 = n;
m = alice[temp1 - 1][temp2 - 1];
n = bob[temp1 - 1][temp2 - 1];
}
}
cout << x << " " << y;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve(int test) {
long long n, k, q;
cin >> n >> k >> q;
long long a[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
vector<int> res;
long long mini = -1;
int vis[n + 1];
memset(vis, 0, sizeof(vis));
priority_queue<int, vector<int>, greater<int> > pq;
while (q--) {
int t, id;
cin >> t >> id;
if (t & 1) {
vis[id] = 1;
if (pq.size() < k) {
pq.push(a[id]);
continue;
}
if (a[id] > pq.top()) {
pq.pop();
pq.push(a[id]);
}
} else {
if (!vis[id] || a[id] < pq.top())
cout << "NO\n";
else
cout << "YES\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
int x = t;
while (t--) {
solve(x - t);
}
return 0;
}
| 2 |
#include "bits/stdc++.h"
#include <sys/timeb.h>
#include <fstream>
using namespace std;
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define replrev(i,a,b) for(int i=(int)(b)-1;i>=(int)(a);i--)
#define reprev(i,n) replrev(i,0,n)
#define repi(itr,ds) for(auto itr=ds.begin();itr!=ds.end();itr++)
#define all(a) a.begin(),a.end()
#define mp make_pair
#define mt make_tuple
#define INF 2000000000
#define INFL 1000000000000000000LL
#define EPS (1e-10)
#define MOD 1000000007
#define PI 3.1415926536
#define RMAX 4294967295
typedef long long ll;
typedef pair<int, double> P;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<P> vP;
typedef vector<vector<int> > vvi;
typedef vector<vector<bool> > vvb;
typedef vector<vector<ll> > vvll;
typedef vector<vector<char> > vvc;
typedef vector<vector<string> > vvs;
typedef vector<vector<double> > vvd;
typedef vector<vector<P> > vvP;
typedef priority_queue<int, vector<int>, greater<int> > pqli;
typedef priority_queue<ll, vector<ll>, greater<ll> > pqlll;
typedef priority_queue<P, vector<P>, greater<P> > pqlP;
typedef pair<int, pair<int, int> > Edge;
typedef vector<Edge> vE;
typedef priority_queue<Edge, vector<Edge>, greater<Edge> > pqlE;
int main() {
int N, S;
cin >> N >> S;
vi a(N);
rep(i, N) {
cin >> a[i];
}
vll sum(N + 1);
sum[0] = 0;
repl(i, 1, N + 1) {
sum[i] = sum[i - 1] + a[i - 1];
}
int ans = INF;
int l = 0, r = 1;
while (r < N + 1) {
while (r < N && sum[r] - sum[l] < S)r++;
while (l < r && sum[r] - sum[l] >= S)l++;
//cout << l << " " << r << endl;
l--;
if(r < N + 1 && l < r && sum[r] - sum[l] >= S)ans = min(ans, r - l);
l++;
r++;
}
if (ans == INF) {
cout << 0 << endl;
}
else {
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxLength = 600000;
int open_le[500];
int open_up[500];
int main() {
open_up[1] = open_up[4] = 1;
open_up[2] = open_up[3] = 0;
open_le[1] = open_le[2] = 1;
open_le[3] = open_le[4] = 0;
int row, col;
cin >> row >> col;
vector<int> openleft(row, 0);
vector<int> openup(col, 0);
for (int(i) = 0; (i) < (row); ++(i)) {
string single_row;
cin >> single_row;
for (int(j) = 0; (j) < (col); ++(j)) {
if (single_row[j] == '.') continue;
int id = single_row[j] - '0';
openleft[i] |= (1 << (open_le[id] ^ (j % 2)));
openup[j] |= (1 << (open_up[id] ^ (i % 2)));
}
}
long long ret = 1LL;
long long modu = 1000003LL;
for (int(i) = 0; (i) < (row); ++(i)) {
if (openleft[i] == 3)
ret = 0;
else if (openleft[i] == 0)
ret = (ret * 2LL) % modu;
}
for (int(i) = 0; (i) < (col); ++(i)) {
if (openup[i] == 3)
ret = 0;
else if (openup[i] == 0)
ret = (ret * 2LL) % modu;
}
cout << ret << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[301000];
int main() {
int i, n, k;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int large = n % k, sz = n / k;
int **dp = (int **)malloc((large + 1) * sizeof(int *));
for (int i = 0; i <= large; i++)
dp[i] = (int *)malloc((k - large + 1) * sizeof(int));
for (int i = 0; i <= large; i++)
for (int j = 0; j <= k - large; j++) dp[i][j] = 2e9;
dp[0][0] = 0;
for (int i = 0; i <= large; i++) {
for (int j = 0; j <= k - large; j++) {
int nxt = i * (sz + 1) + j * sz;
if (i < large) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + a[nxt + sz] - a[nxt]);
}
if (j < k - i) {
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + a[nxt + sz - 1] - a[nxt]);
}
}
}
printf("%d\n", dp[large][k - large]);
}
| 4 |
#include <iostream>
#include <string>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <queue>
#include <stack>
#include <list>
#include <algorithm>
using namespace std;
#define typec long long
#define V 111
typec g[V][V], w[V];
typec a[V], v[V], na[V];
typec Stoer_Wagner(int n)
{
typec i, j, pv, zj,I=1;
typec best = I<<32;
for (i = 0; i < n; i++) v[i] = i; // vertex: 0 ~ n-1
while (n > 1)
{
for (a[v[0]] = 1, i = 1; i < n; i++)
{
a[v[i]] = 0;
na[i - 1] = i;
w[i] = g[v[0]][v[i]];
}
for (pv = v[0], i = 1; i < n; i++ )
{
for (zj = -1, j = 1; j < n; j++ )
if (!a[v[j]] && (zj < 0 || w[j] > w[zj]))
zj = j;
a[v[zj]] = 1;
if (i == n - 1)
{
if (best > w[zj]) best = w[zj];
for (i = 0; i < n; i++)
g[v[i]][pv] = g[pv][v[i]] += g[v[zj]][v[i]];
v[zj] = v[--n];
break;
}
pv = v[zj];
for (j = 1; j < n; j++)
if(!a[v[j]])
w[j] += g[v[zj]][v[j]];
}
}
return best;
}
bool vis[111];
void dfs(int u,int n)
{
for(int v=0;v<n;++v)
if(g[u][v]!=0&&vis[v]==0)
{
vis[v]=1;
dfs(v,n);
}
}
bool ok(int n)
{
for(int i=0;i<n;++i)
if(vis[i]==0)return 1;
return 0;
}
int main()
{
//freopen("G:\\in.txt","r",stdin);
int n, m, u, v, w;
while(scanf("%d%d", &n, &m),n+m)
{
memset(g, 0, sizeof(g));
typec ans=0;
while(m --)
{
scanf("%d%d%d", &u, &v, &w);
if(w<=0)ans+=w;
else g[v][u]= g[u][v] = w;
}
// memset(vis,0,sizeof(vis));
//dfs(0,n);
//if(ok(n))puts("0");
printf("%lld\n", ans+Stoer_Wagner(n));
}
return 0;
}
| 0 |
#include<vector>
#include<cmath>
#include<map>
#include<cstdlib>
#include<iostream>
#include<sstream>
#include<fstream>
#include<string>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#include<stack>
#include<bitset>
#include<functional>
#include<ctime>
#include<queue>
#include<deque>
#include<complex>
#include<cassert>
using namespace std;
#define pb push_back
#define pf push_front
typedef long long lint;
typedef complex<double> P;
#define mp make_pair
#define fi first
#define se second
typedef pair<int,int> pint;
#define All(s) s.begin(),s.end()
#define rAll(s) s.rbegin(),s.rend()
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
//問題文および制約はちゃんと確認しよう！
//サイズは10^5じゃなくて2×10^5とかかもしれないし、重要な制約・条件を見落としているかも
//とりあえずサンプルを読んでから解法を考えよう？
int dp[510][510][510];
int num[510];
lint co[510][510];
lint mo=1000000007;
int main()
{
rep(i,505){
co[i][0]=co[i][i]=1;
REP(j,1,i) co[i][j]=(co[i-1][j]+co[i-1][j-1])%mo;
}
memset(num,0,sizeof(num));
int n,L,x;
cin>>n>>x;
rep(i,n){
cin>>L;num[L]++;
}
memset(dp,0,sizeof(dp));
dp[500][0][0]=1;
for(int i=500;i>0;i--) rep(j,500/i+5) rep(k,505){
if(dp[i][j][k]<1) continue;
//cout<<i<<' '<<j<<' '<<k<<' '<<dp[i][j][k]<<endl;
lint t=dp[i][j][k];
lint can=j+k-(i+1)*j;
if(j<1) can=0;
rep(l,num[i+1]){
t*=can;t%=mo;
}
/*if(i<1){
dp[i][j][k]=(int)(t%mo);continue;
}*/
for(int l=0;k+i*l<=x;l++){
dp[i-1][j+l][k+i*l]=(dp[i-1][j+l][k+i*l]+t*co[j+l][l])%mo;
//dp[i-1][j+l][k+i*l]%=mo;
}
}
lint out=0;
rep(i,x+1) REP(j,1,x+1){
if(dp[0][i][j]<1) continue;
if(j+i-1>x) continue;
//dp[0][i][j]=(dp[0][i][j]*num[1])%mo;
//cout<<0<<' '<<i<<' '<<j<<' '<<dp[0][i][j]<<endl;
lint t=dp[0][i][j];
rep(k,num[1]){
t*=j;t%=mo;
}
//cout<<0<<' '<<i<<' '<<j<<' '<<t<<endl;
t*=co[x-j+1][i];t%=mo;
if((x-j)%2==0) out+=t;else out-=t;
out%=mo;
}
out%=mo;out+=mo;out%=mo;
cout<<out<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Crater {
int s, e, i;
};
Crater c[2010];
int dp[2010];
vector<int> child[2010];
int dp2[4010], par2[4010];
void dfs(int p) {
if (c[p].i) cout << c[p].i << ' ';
for (int i : child[p]) dfs(i);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int ci, ri;
cin >> ci >> ri;
c[i].s = ci - ri;
c[i].e = ci + ri;
c[i].i = i + 1;
}
c[n].s = -2.1e9, c[n].e = 2.1e9, c[n].i = 0;
n++;
map<int, int> ma;
for (int i = 0; i < n; i++) ma[c[i].s], ma[c[i].e];
int m = 0;
for (auto& p : ma) p.second = m++;
for (int i = 0; i < n; i++) c[i].s = ma[c[i].s], c[i].e = ma[c[i].e];
int ans = -1, besti;
sort(c, c + n, [](Crater a, Crater b) { return a.e - a.s < b.e - b.s; });
for (int i = 0; i < n; i++) {
fill_n(dp2, m, 0);
fill_n(par2, m, -1);
vector<vector<int>> v(m);
for (int j = 0; j < i; j++)
if (c[j].s >= c[i].s && c[j].e <= c[i].e) v[c[j].s].push_back(j);
int best = 0, bestp = 0;
for (int p = 0; p < m; p++) {
if (p && dp2[p] < dp2[p - 1]) {
dp2[p] = dp2[p - 1];
par2[p] = par2[p - 1];
}
if (dp2[p] > best) {
best = dp2[p];
bestp = p;
}
for (int j : v[p]) {
if (dp2[c[j].e] < dp2[p] + dp[j]) {
dp2[c[j].e] = dp2[p] + dp[j];
par2[c[j].e] = j;
}
}
}
dp[i] = best + 1;
if (dp[i] > ans) {
ans = dp[i];
besti = i;
}
for (; par2[bestp] != -1; bestp = c[par2[bestp]].s)
child[i].push_back(par2[bestp]);
}
cout << ans - 1 << endl;
dfs(besti);
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int N = 2e5 + 4;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
}
return res % MOD;
}
int gcd(int a, int b) {
while (b > 0) {
int t = a % b;
a = b, b = t;
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long is_prime(long long n) {
if (n <= 1 || n > 3 && (n % 2 == 0 || n % 3 == 0)) return 0;
for (long long i = 5, t = 2; i * i <= n; i += t, t = 6 - t)
if (n % i == 0) return 0;
return 1;
}
int modI(int a, int m) {
int m0 = m, y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
int q = a / m;
int t = m;
m = a % m;
a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long mod_inv(long long a, long long m = MOD) {
return a == 1 ? 1 : m - mod_inv(m % a, a) * m / a;
}
long long choose(long long n, long long r) {
long long product = 1;
for (long long i = 0; i < r; i++)
product = product * (n - i) % MOD * mod_inv(i + 1) % MOD;
return product;
}
long long getcount(long long n, int k) {
long long res = (n >> (k + 1)) << k;
if ((n >> k) & 1) res += n & ((1ll << k) - 1);
return res;
}
int bit[N];
void init(void) {
int i;
for (int i = 0; i < N; i++) bit[i] = 0;
}
void update(int idx, int val) {
while (idx <= N) {
bit[idx] = max(bit[idx], val);
idx += idx & -idx;
}
}
int pref(int idx) {
int ans = 0;
while (idx > 0) {
ans = max(ans, bit[idx]);
idx -= idx & -idx;
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
int r = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'R') r++;
}
if (r == 0 || r == n) {
if (r == 0) r = n;
cout << (r + 2) / 3 << "\n";
continue;
}
int ans = 0;
for (int i = 0; i < n; i++) {
int f = 1;
while (i + 1 < n && s[i] == s[i + 1]) f++, i++;
ans += f / 3;
}
if (s[0] == s[n - 1]) {
int l = 1;
r = 0;
int i = 0;
while (i + 1 < n && s[i] == s[i + 1]) i++, l++;
r = 1;
i = n - 1;
while (i - 1 >= 0 && s[i] == s[i - 1]) i--, r++;
ans -= l / 3;
ans -= r / 3;
ans += (l + r) / 3;
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string aa, bb;
cin >> aa >> bb;
int n;
cin >> n;
int distance[26][26];
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
distance[i][j] = 100002;
}
distance[i][i] = 0;
}
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
int cost;
cin >> cost;
int u = a[0] - 'a';
int v = b[0] - 'a';
distance[u][v] = min(distance[u][v], cost);
}
if (aa.length() != bb.length()) {
cout << "-1" << endl;
return 0;
}
for (int k = 0; k < 26; k++) {
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
distance[i][j] = min(distance[i][j], distance[i][k] + distance[k][j]);
}
}
}
long long cost = 0;
vector<char> ans;
for (int i = 0; i < aa.length(); i++) {
int t = aa[i] - 'a';
int tt = bb[i] - 'a';
char aaa = 'a';
int flag = 0;
int add = distance[t][0] + distance[tt][0];
for (int i = 0; i < 26; i++) {
int t1 = distance[t][i];
int t2 = distance[tt][i];
if (t1 != 100002 and t2 != 100002) {
flag++;
}
int temp = distance[t][i] + distance[tt][i];
if (temp < add) {
add = temp;
int temp = i + 'a';
aaa = (char)temp;
}
}
if (flag == 0) {
cout << "-1" << endl;
return 0;
}
cost = cost + add;
ans.push_back(aaa);
}
cout << cost << endl;
for (auto i : ans) {
cout << i;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& x) {
x = 0;
char c;
int sign = 1;
do {
c = getchar();
if (c == '-') sign = -1;
} while (!isdigit(c));
do {
x = x * 10 + c - '0';
c = getchar();
} while (isdigit(c));
x *= sign;
}
const int N = 1e5 + 500;
int n, m, ans, a[N], f[N];
vector<int> to[N];
int solve(int n) {
for (register int i = 20; i >= 0; --i)
if ((n & (1 << i))) {
int x = ((1 << i + 1) - 1) ^ n;
if (x > 1) solve(x - 1);
for (register int j = n; j >= x; --j) printf("%d ", j);
break;
}
}
int main() {
read(n);
if (n & 1)
puts("NO");
else {
puts("YES");
solve(n);
puts("");
}
if (n < 6 || n == (n & (-n)))
puts("NO");
else {
puts("YES");
a[1] = 3;
a[2] = 6;
a[3] = 2;
a[4] = 5;
a[5] = 1;
a[6] = 4;
for (register int i = 7; i <= n; ++i)
if (i == (i & (-i)))
a[i] = i + 1, a[i + 1] = i, ++i;
else
a[i] = a[(i & (-i))], a[(i & (-i))] = i;
for (register int i = 1; i <= n; ++i) printf("%d ", a[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int mod = 998244353;
const int inf = 1000000009;
const long long int INF = 1000000000000000009;
const long long big = 1000000000000000;
const long double eps = 0.0000000001;
using namespace std;
int DP[200005][4];
int Pow(int a, int b) {
int wynik = 1;
while (b) {
if (b & 1) wynik = ((long long int)wynik * a) % mod;
a = ((long long int)a * a) % mod;
b /= 2;
}
return wynik;
}
vector<int> P[200005];
void dfs(int n) {
long long int a = 1, b = 0, c = 1;
for (auto v : P[n]) {
dfs(v);
long long int nw = DP[v][1] + DP[v][3], w = DP[v][2] + DP[v][3];
a *= nw;
c *= (w + nw);
c %= mod;
a %= mod;
}
for (auto v : P[n]) {
int nw = DP[v][1] + DP[v][3], w = DP[v][2] + DP[v][3];
b += (((a * w) % mod) * Pow(nw, mod - 2)) % mod;
b %= mod;
}
if (P[n].empty())
DP[n][3] = 1;
else {
DP[n][1] = a;
DP[n][2] = b;
DP[n][3] = (c - a - b + 2 * mod) % mod;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
int n;
cin >> n;
for (int i = 2; i <= n; i++) {
int a;
cin >> a;
P[a].push_back(i);
}
dfs(1);
cout << (DP[1][1] + DP[1][3]) % mod;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
long long int time[t];
long long int arr[t];
for (long long int i = 0; i < t; ++i) {
cin >> time[i];
cin >> arr[i];
}
long long int curr = 0;
long long int maxi = 0;
for (long long int i = 0; i < t; i++) {
if (i != 0) {
curr -= (time[i] - time[i - 1]);
if (curr < 0) curr = 0;
}
curr = curr + arr[i];
maxi = max(maxi, curr);
}
cout << time[t - 1] + curr << " ";
cout << maxi << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 400;
int freq[(200005 / sz) + 1][10][10];
string str, temp;
char group[200005];
char get(int pos) {
int prev = pos;
if (group[prev / sz] == 0)
return str[prev];
else
return group[prev / sz];
}
void update(int l, int r, char c) {
int g1 = l / sz;
int g2 = r / sz;
for (int i = g1 * sz; i < (g1 + 1) * sz; i++) {
if (group[g1] != 0) {
str[i] = group[g1];
}
}
for (int i = g2 * sz; i < (g2 + 1) * sz; i++) {
if (group[g2] != 0) {
str[i] = group[g2];
}
}
group[g1] = 0;
group[g2] = 0;
if (r + 1 < str.size()) {
char curr = get(r + 1);
char prev = get(r);
freq[(r + 1) / sz][curr - 'a'][prev - 'a']--;
freq[(r + 1) / sz][curr - 'a'][c - 'a']++;
}
for (int i = l; i < (((g1 + 1) * sz > r + 1) ? r + 1 : (g1 + 1) * sz); i++) {
char curr = get(i);
if (i - 1 >= 0) {
char prev = get(i - 1);
freq[g1][curr - 'a'][prev - 'a']--;
}
}
if (g1 != g2) {
for (int i = g2 * sz; i < r + 1; i++) {
char curr = get(i);
if (i - 1 >= 0) {
char prev = get(i - 1);
freq[g2][curr - 'a'][prev - 'a']--;
}
}
}
for (int i = l; i < (((g1 + 1) * sz > r + 1) ? r + 1 : (g1 + 1) * sz); i++) {
str[i] = c;
group[g1] = 0;
if (i - 1 >= 0) {
char prev = get(i - 1);
freq[g1][c - 'a'][prev - 'a']++;
}
}
for (int i = g1 + 1; i < g2; i++) {
for (int j = 0; j < 10; j++)
for (int k = 0; k < 10; k++) freq[i][j][k] = 0;
int first = i * sz;
char prev = get(first - 1);
char curr = get(first);
freq[i][c - 'a'][c - 'a'] = sz - 1;
group[i] = c;
freq[i][c - 'a'][prev - 'a']++;
}
if (g1 != g2) {
for (int i = g2 * sz; i < r + 1; i++) {
str[i] = c;
group[g2] = 0;
if (i - 1 >= 0) {
char prev = get(i - 1);
freq[g2][c - 'a'][prev - 'a']++;
}
}
}
}
int ans(string t) {
set<int> bigger;
int res = 0;
for (int i = 0; i < 10; i++) bigger.insert(i);
for (int i = 0; i < t.size(); i++) {
for (int letter : bigger) {
for (int block = 0; block < (200005 / sz) + 1; block++) {
res += freq[block][t[i] - 'a'][letter];
}
}
bigger.erase(t[i] - 'a');
}
return res + 1;
}
void updateTemp(int l, int r, char c) {
for (int i = l; i < r + 1; i++) temp[i] = c;
}
int ansTemp(string t) {
set<int> bigger;
int res = 0;
for (int i = 0; i < 10; i++) bigger.insert(i);
for (int i = 0; i < t.size(); i++) {
for (int j = 0; j < temp.length(); j++) {
if (j > 0 && temp[j] == t[i] &&
(bigger.find(temp[j - 1] - 'a') != bigger.end()))
res++;
}
bigger.erase(t[i] - 'a');
}
return res + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string sample, s2;
int n, m, k;
cin >> n >> m >> k;
cin >> str;
for (int i = 0; i < k; i++) sample += ('a' + i);
temp = str;
for (int i = 1; i < str.size(); i++) {
freq[i / sz][str[i] - 'a'][str[i - 1] - 'a']++;
}
while (m--) {
int t = 1 + rand() % 2;
cin >> t;
if (t == 1) {
int l = 1 + rand() % n, r = 1 + rand() % n;
if (l > r) swap(l, r);
char c = 'a' + rand() % k;
cin >> l >> r >> c;
l--, r--;
update(l, r, c);
} else {
string s = sample;
cin >> s;
int t = ans(s);
cout << t << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x[7] = {0, 4, 8, 15, 16, 23, 42};
int p[100];
int ans[7];
int a1, a2, a3, a4;
int main() {
printf("? %d %d\n", 1, 2);
fflush(stdout);
scanf("%d", &a1);
printf("? %d %d\n", 1, 3);
fflush(stdout);
scanf("%d", &a2);
printf("? %d %d\n", 4, 5);
fflush(stdout);
scanf("%d", &a3);
printf("? %d %d\n", 4, 6);
fflush(stdout);
scanf("%d", &a4);
for (int i = 1; i <= 6; i++) p[x[i]] = 1;
for (int i = 1; i <= 6; i++)
if (a1 % x[i] == 0 && a2 % x[i] == 0 && a1 / x[i] != x[i] && p[a1 / x[i]] &&
p[a2 / x[i]] && a2 / x[i] != x[i]) {
ans[1] = x[i];
ans[2] = a1 / x[i];
ans[3] = a2 / x[i];
}
for (int i = 1; i <= 6; i++)
if (a3 % x[i] == 0 && a4 % x[i] == 0 && p[a3 / x[i]] && a3 / x[i] != x[i] &&
p[a4 / x[i]] && a4 / x[i] != x[i]) {
ans[4] = x[i];
ans[5] = a3 / x[i];
ans[6] = a4 / x[i];
}
printf("! ");
for (int i = 1; i <= 6; i++) printf("%d ", ans[i]);
fflush(stdout);
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long mod = 1e9;
const int phash = 3;
const long long modhash = 1000000000000000003;
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (int i : a) cout << i << " ";
cout << '\n';
for (int i : b) cout << i << " ";
cout << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
using namespace std;
typedef pair <long long, int> pli;
typedef pair <int, int> pii;
long long d[100010];
map <long long, int> all;
long long dp[100010], size[100010];
int main(){
int n; scanf("%d", &n);
for (int i = 0; i < n; i++){
scanf("%lld", &d[i]);
all[d[i]] = i;
}
vector <pii> ans;
int pos = all.begin()->se;
for (auto it = all.rbegin(); it != all.rend(); it++){
long long x = it->fi; int id = it->se;
if (id == pos) continue;
size[id]++;
long long need = d[id] + 2 * size[id] - n;
if (!all.count(need) || need >= x){
printf("-1\n");
return 0;
}
int fa = all[need];
ans.push_back(mp(fa, id));
size[fa] += size[id], dp[fa] += dp[id] + size[id];
}
if (dp[pos] != d[pos]){
printf("-1\n");
return 0;
}
for (int i = 0; i < ans.size(); i++){
printf("%d %d\n", ans[i].fi + 1, ans[i].se + 1);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 128;
int main() {
int N, r[MAXN];
scanf("%d", &N);
r[0] = 0;
for (int i = 1; i <= N; i++) {
scanf("%d", r + i);
}
sort(r + 0, r + N + 1);
long long AREA = 0;
for (int i = N; i > 0; i -= 2) {
AREA += r[i] * (long long)r[i] - r[i - 1] * (long long)r[i - 1];
}
printf("%.16lf\n", M_PI * AREA);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, count = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0) {
count++;
}
}
if (n == 1) {
if (a[0] == 1) {
cout << "YES";
} else
cout << "NO";
return 0;
}
if (count == 1) {
cout << "YES";
return 0;
} else {
cout << "NO";
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<char> metszet(vector<char> v1, string v2) {
int i = 0, j = 0, c = 0;
vector<char> m;
while (i < v1.size() && j < v2.size()) {
if (v1[i] < v2[j])
i++;
else if (v1[i] > v2[j])
j++;
else {
m.push_back(v1[i++]);
j++;
}
}
return m;
}
vector<char> kulonbseg(vector<char> v1, string v2) {
int i = 0, j = 0, c = 0;
vector<char> m;
while (i < v1.size() && j < v2.size()) {
if (v1[i] == v2[j]) {
i++;
j++;
} else if (v1[i] < v2[j]) {
m.push_back(v1[i++]);
} else {
j++;
}
}
while (i < v1.size()) m.push_back(v1[i++]);
return m;
}
int main() {
vector<char> chars(26);
for (int i = 0; i < 26; ++i) {
chars[i] = i + 'a';
}
int n, shocks = 0;
cin >> n;
bool known = false;
char c;
string line;
getline(cin, line);
for (int i = 0; i < n; ++i) {
getline(cin, line, '\n');
c = line[0];
line = line.substr(2);
sort(line.begin(), line.end());
if (c == '.') {
chars = kulonbseg(chars, line);
} else if (c == '?') {
if (i < n - 1) {
chars = kulonbseg(chars, line);
if (known) shocks++;
}
} else if (c == '!') {
chars = metszet(chars, line);
if (known) shocks++;
}
if (!known && chars.size() == 1) {
known = true;
}
}
cout << shocks << endl;
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int main(){
int n, i, elm;
int isFirst;
while(cin>>n){
elm=1; isFirst=1;
for(i=0; i<10; i++){
if(n%2==1){
if(!isFirst) printf(" ");
isFirst=0;
printf("%d", elm);
}
n=n>>1; elm=elm<<1;
}
printf("\n");
}
return 0;
}
| 0 |
#include "bits/stdc++.h"
#define REP(i,num) for(int i=0;i<(num);++i)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto& x:c){cout<<x<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}
using namespace std;
using ll = long long;
constexpr ll atcoder_mod = 1e9+7;
template<typename T=int>
T in(){T x; cin >> x; return (x);}
template<typename T=int,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}
void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int Q=in();
map<string,int> M;
REP(i,Q){
int q=in();
if(q==1){
out(M[in<string>()]);
}
else{
string key=in<string>();
M[key] = in();
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int n, k, m;
int st[100005];
int dp[1005][105][2][10][2];
void add(int &a, int b) {
a += b;
if (a >= m) a -= m;
}
int main() {
cin >> n >> k >> m;
dp[0][0][0][0][0] = 1;
st[0] = 1;
for (int i = 1; i <= n; ++i) {
st[i] = st[i - 1] * 10 % k;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k; ++j)
for (int q = 0; q < 2; ++q)
for (int d = 0; d < 10; ++d)
for (int nw = 0; nw < 2; ++nw) {
if (dp[i][j][q][d][nw] == 0) continue;
for (int dig = 0; dig < 10; ++dig) {
int ost = (j + st[i] * dig) % k;
int nnw = 0;
if (dig)
nnw = 1;
else
nnw = nw;
int nq = q;
if (ost == 0 && nnw == 1) nq = 1;
add(dp[i + 1][ost][nq][dig][nnw], dp[i][j][q][d][nw]);
}
}
}
int ans = 0;
for (int i = 0; i < k; ++i)
for (int d = 1; d < 10; ++d) {
add(ans, dp[n][i][1][d][1]);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, string> arr;
set<string> map1;
map<string, string> ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
arr[a] = b;
map1.insert(b);
}
for (auto i : arr) {
if (map1.count(i.first)) continue;
auto curr = i.first;
while (arr.count(curr)) {
curr = arr[curr];
}
ans[i.first] = curr;
}
cout << ans.size() << endl;
for (auto j : ans) {
cout << j.first << " " << j.second << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template<class T>
void debug(T itr1, T itr2) { auto now = itr1; while(now<itr2) { cout << *now << " "; now++; } cout << endl; }
#define repr(i,from,to) for (int i=(int)from; i<(int)to; i++)
#define all(vec) vec.begin(), vec.end()
#define rep(i,N) repr(i,0,N)
#define per(i,N) for (int i=(int)N-1; i>=0; i--)
const ll MOD = pow(10,9)+7;
const ll LLINF = pow(2,61)-1;
const int INF = pow(2,30)-1;
vector<ll> fac;
void c_fac(int x=pow(10,6)+10) { fac.resize(x,true); rep(i,x) fac[i] = i ? (fac[i-1]*i)%MOD : 1; }
ll inv(ll a, ll m=MOD) { ll b = m, x = 1, y = 0; while (b!=0) { int d = a/b; a -= b*d; swap(a,b); x -= y*d; swap(x,y); } return (x+m)%m; }
ll nck(ll n, ll k) { return fac[n]*inv(fac[k]*fac[n-k]%MOD)%MOD; }
ll gcd(ll a, ll b) { if (a<b) swap(a,b); return b==0 ? a : gcd(b, a%b); }
ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }
struct niku { double x; double y; double c; };
int main() {
int N, K; cin >> N >> K;
niku n[N];
rep(i,N) {
double x, y, c; cin >> x >> y >> c;
n[i] = {x,y,c};
}
double l = 0, r = 5000*100;
while(r-l>=1e-8) {
double mid = (l+r)/2;
bool ok = false;
rep(i,N) repr(j,i,N) {
if (i==j) {
int count = 0;
rep(k,N) if (pow(n[k].x-n[i].x,2)+pow(n[k].y-n[i].y,2)<=pow(mid/n[k].c,2)) count++;
if (count>=K) ok = true;
}
else {
double ri = mid/n[i].c, rj = mid/n[j].c;
if (pow(n[i].x-n[j].x,2)+pow(n[i].y-n[j].y,2)>pow(ri+rj,2)) continue;
if (pow(n[i].x-n[j].x,2)+pow(n[i].y-n[j].y,2)<pow(ri-rj,2)) continue;
double vx = n[i].x-n[j].x, vy = n[i].y-n[j].y;
double vl = sqrt(vx*vx + vy*vy);
vx /= vl; vy /= vl;
double dl = (ri*ri-rj*rj+vl*vl) / (2*vl);
double rx = n[i].x - vx*dl, ry = n[i].y - vy*dl;
double rx1 = rx - vy * sqrt(ri*ri-dl*dl), ry1 = ry + vx * sqrt(ri*ri-dl*dl);
double rx2 = rx + vy * sqrt(ri*ri-dl*dl), ry2 = ry - vx * sqrt(ri*ri-dl*dl);
int count1 = 0, count2 = 0;
rep(k,N) if (pow(n[k].x-rx1,2)+pow(n[k].y-ry1,2)<=pow(mid/n[k].c,2)+1e-6) count1++;
rep(k,N) if (pow(n[k].x-rx2,2)+pow(n[k].y-ry2,2)<=pow(mid/n[k].c,2)+1e-6) count2++;
if (count1>=K||count2>=K) ok = true;
// cout << mid << " " << i << " " << j << " " << rx1 << " " << ry1 << " " << count1 << endl;
// cout << mid << " " << i << " " << j << " " << rx2 << " " << ry2 << " " << count2 << endl;
}
}
// cout << l << " " << mid << " " << r << endl;
if (ok) r = mid;
else l = mid;
}
double result = l;
cout << setprecision(10) << result << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int color[105], n, k, num;
int make(int l, int r) {
int cnt;
if (l < 0 || r >= n) {
return 0;
}
if (color[l] != color[r]) {
return 0;
}
if (l + 1 == r) {
cnt = 3;
} else
cnt = 2;
while (l > 0 && color[l - 1] == color[r]) {
--l;
++cnt;
}
while (r < n - 1 && color[r + 1] == color[l]) {
++r;
++cnt;
}
if (cnt < 3) {
return 0;
}
return cnt + make(l - 1, r + 1);
}
int main(int argc, char const *argv[]) {
scanf("%d%d%d", &n, &k, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &color[i]);
}
for (int i = 1; i < n; ++i) {
if (color[i - 1] == k && color[i] == k) {
num = max(num, make(i - 1, i));
}
}
if (num > 0) {
--num;
}
printf("%d\n", num);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int MOD = 1000000007;
const double pi = acos(-1.0);
bool can;
int a[33], deg[33];
int g[33];
int n;
void go(int pos) {
if (a[pos] == 1) {
bool ok = true;
int leaf = 0;
for (int i = (pos + 1); i <= (n); ++i) {
if (deg[i] + 1 == a[i] && g[i] == 1) ok = false;
if (deg[i] >= a[i]) ok = false;
if (a[i] - deg[i] - 1 == 1 && deg[i] == 0) ok = false;
leaf += a[i] - deg[i] - 1;
}
if (ok && leaf == pos) can = true;
return;
}
for (int fath = (pos + 1); fath <= (n); ++fath) {
g[fath]++;
deg[fath] += a[pos];
if (deg[fath] < a[fath]) go(pos - 1);
deg[fath] -= a[pos];
g[fath]--;
}
}
int main() {
cin >> n;
for (int i = (1); i <= (n); ++i) cin >> a[i];
if (n == 1 && a[1] == 1) {
cout << "YES" << endl;
return 0;
}
sort(a + 1, a + n + 1);
if (a[1] != 1) {
cout << "NO" << endl;
return 0;
}
can = false;
go(n - 1);
if (can)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int arr[200001];
vector<pair<int, int>> zeros;
int main() {
int a;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> arr[i];
if (arr[i] == 0) zeros.push_back(make_pair(i, arr[i]));
}
if (zeros.size() == 1) {
for (int i = 0; i < a; i++) cout << abs(i - zeros[0].first) << " ";
return 0;
}
int out = 300020, mid;
int end = zeros.size() - 1, start = 0;
for (int i = 0; i < a; i++) {
if (arr[i] == 0) {
cout << 0 << " ";
} else {
while (start <= end) {
mid = (start + end) / 2;
if (i > zeros[mid].first)
start = mid + 1;
else if (i < zeros[mid].first)
end = mid - 1;
}
if (end == -1)
cout << abs(i - zeros[start].first) << " ";
else if (start == zeros.size())
cout << abs(i - zeros[end].first) << " ";
else if (abs(i - zeros[start].first) <= abs(i - zeros[end].first))
cout << abs(i - zeros[start].first) << " ";
else
cout << abs(i - zeros[end].first) << " ";
end = zeros.size() - 1;
start = 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 200500;
void solve() {
int n;
cin >> n;
vector<long long> a(n + 1);
for (int quer = 1; quer < n + 1; quer++) cin >> a[quer];
map<long long, pair<int, int> > m;
long long sum = 0;
for (int i = 1; i <= n; i++) {
m[a[i]] = {i, m[a[i]].second + 1};
sum += a[i];
}
vector<int> ans;
for (int i = 1; i <= n; i++) {
long long t = sum - a[i];
if (t % 2 == 0) {
if (m[t / 2].first > 0 && (m[t / 2].first != i || m[t / 2].second > 1)) {
ans.push_back(i);
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << ' ';
}
int main() {
ios::sync_with_stdio(false);
int q = 1;
for (int i = 1; i <= q; i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3010;
int N;
int ar[MAXN];
int freq[MAXN];
int main() {
ios_base::sync_with_stdio(0);
int T;
cin >> T;
while (T > 0) {
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> ar[i];
}
memset(freq, 0, sizeof(int) * (N + 1));
long long res = 0;
for (int i = 0; i < N; ++i) {
long long add = 0;
for (int k = i + 1; k < N; ++k) {
if (ar[k] == ar[i]) {
res += add;
}
add += freq[ar[k]];
}
++freq[ar[i]];
}
cout << res << '\n';
--T;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Graph {
struct Edge {
int f, t, nxt;
} edge[400005 * 2];
int head[200005], etot;
void add_edge(int f, int t) {
edge[++etot] = (Edge){f, t, head[f]};
head[f] = etot;
}
};
Graph g, ng;
template <typename Tp>
void read(Tp &x) {
x = 0;
int f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
x *= f;
}
int dfn[200005], low[200005], ins[200005], c[200005], cnt, tot;
stack<int> st;
void dfs(int x) {
dfn[x] = low[x] = ++tot;
st.push(x);
ins[x] = 1;
for (int i = g.head[x]; i; i = g.edge[i].nxt) {
int y = g.edge[i].t;
if (!dfn[y]) {
dfs(y);
low[x] = min(low[x], low[y]);
} else if (ins[y])
low[x] = min(low[x], dfn[y]);
}
if (dfn[x] == low[x]) {
int y = st.top();
st.pop();
c[y] = ++cnt;
ins[y] = 0;
while (y != x) {
y = st.top();
st.pop();
c[y] = cnt;
ins[y] = 0;
}
}
}
int n, k, rd[200005];
int p[200005], q[200005];
map<pair<int, int>, int> mp;
int dis[200005];
queue<int> qq;
signed main() {
int x, y;
read(n);
read(k);
for (int i = 1; i <= n; i++) {
read(p[i]);
if (i > 1) g.add_edge(p[i - 1], p[i]);
}
for (int i = 1; i <= n; i++) {
read(q[i]);
if (i > 1) g.add_edge(q[i - 1], q[i]);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) dfs(i);
}
for (int i = 1; i <= g.etot; i++) {
if (c[g.edge[i].f] == c[g.edge[i].t]) continue;
if (mp[make_pair(c[g.edge[i].f], c[g.edge[i].t])]) continue;
mp[make_pair(c[g.edge[i].f], c[g.edge[i].t])] = 1;
rd[c[g.edge[i].t]]++;
ng.add_edge(c[g.edge[i].f], c[g.edge[i].t]);
}
for (int i = 1; i <= cnt; i++) {
if (!rd[i]) qq.push(i), dis[i] = 1;
}
while (!qq.empty()) {
x = qq.front();
qq.pop();
for (int i = ng.head[x]; i; i = ng.edge[i].nxt) {
y = ng.edge[i].t;
dis[y] = min(dis[x] + 1, 26);
if (--rd[y] == 0) qq.push(y);
}
}
int mx = 0;
for (int i = 1; i <= cnt; i++) mx = max(mx, dis[i]);
if (mx < k)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= n; i++) cout << (char)(dis[c[i]] + 'a' - 1);
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int k;
cin>>k;
string s;
cin>>s;
if(s.length()>k)
{
cout<<s.substr(0,k)+"..."<<endl;
}
else cout<<s<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, m;
cin >> n >> m >> k;
vector<int> v(n);
for (auto &i : v) cin >> i;
sort(v.rbegin(), v.rend());
long long a = v[0];
long long b = v[1];
cout << (m / (k + 1)) * (k * a + b) + (m % (k + 1)) * a;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main()
{
int l, m, n, mu, f;
while (cin >> l, l){
mu = f = 0;
for (int i = 0; i < 12; i++){
cin >> m >> n;
l -= (m - n);
if (l <= 0 && f == 0){
mu = i + 1;
f = 1;
}
}
if (mu != 0) cout << mu << endl;
else cout << "NA" << endl;
}
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int INF = 0x3f3f3f3f;
int n, q;
char s[N];
struct Node {
int m[5][5];
void clear() { memset(m, 0x3f, sizeof(m)); }
} tr[N * 2];
void push_up(int l, int r) {
tr[(l + r) | (l != r)].clear();
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
for (int k = 0; k < 5; k++)
tr[(l + r) | (l != r)].m[i][j] =
min(tr[(l + r) | (l != r)].m[i][j],
tr[(l + (l + r) / 2) | (l != (l + r) / 2)].m[i][k] +
tr[((l + r) / 2 + 1 + r) | ((l + r) / 2 + 1 != r)].m[k][j]);
}
void build(int l, int r) {
if (l == r) {
tr[(l + r) | (l != r)].clear();
for (int i = 0; i < 5; ++i) tr[(l + r) | (l != r)].m[i][i] = 0;
if (s[l] == '2')
tr[(l + r) | (l != r)].m[0][1] = 0, tr[(l + r) | (l != r)].m[0][0] = 1;
if (s[l] == '0')
tr[(l + r) | (l != r)].m[1][2] = 0, tr[(l + r) | (l != r)].m[1][1] = 1;
if (s[l] == '1')
tr[(l + r) | (l != r)].m[2][3] = 0, tr[(l + r) | (l != r)].m[2][2] = 1;
if (s[l] == '6')
tr[(l + r) | (l != r)].m[3][3] = 1, tr[(l + r) | (l != r)].m[4][4] = 1;
if (s[l] == '7')
tr[(l + r) | (l != r)].m[3][4] = 0, tr[(l + r) | (l != r)].m[3][3] = 1;
return;
}
build(l, (l + r) / 2);
build((l + r) / 2 + 1, r);
push_up(l, r);
}
Node query(int L, int R, int l, int r) {
if (L <= l && r <= R) return tr[(l + r) | (l != r)];
if (R <= (l + r) / 2)
return query(L, R, l, (l + r) / 2);
else if (L > (l + r) / 2)
return query(L, R, (l + r) / 2 + 1, r);
else {
Node ql = query(L, R, l, (l + r) / 2);
Node qr = query(L, R, (l + r) / 2 + 1, r);
Node ret;
ret.clear();
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++)
for (int k = 0; k < 5; k++)
ret.m[i][j] = min(ret.m[i][j], ql.m[i][k] + qr.m[k][j]);
return ret;
}
}
int main() {
scanf("%d%d%s", &n, &q, s + 1);
build(1, n);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
int ans = query(l, r, 1, n).m[0][4];
if (ans == INF) ans = -1;
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define pb push_back
#define mod 1000000007
#define ff first
#define ss second
#define pi 3.1415926535
#define endl '\n'
using namespace std;
struct custom {
static uint64_t splitmix64(uint64_t x)
{
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
//using namespace __gnu_pbds;
//typedef tree<ll,null_type,less_equal<int>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
const ll inf=4e10;
/*ll power(ll x,ll y)
{
ll res=1;
while(y>0)
{
if(y%2==1)
res=(res*x)%mod;
x=(x*x)%mod;
y=(y>>1);
}
return res;
}*/
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll a,b,c,i,x,y,k,r,d;
cin>>a>>b>>k;
string s,s1;
if((b==1|| a==0)&& k!=0)
{
cout<<"No"<<endl;
return 0;
}
if(b==1 || a==0 || k==0)
{
for(i=1;i<=b;i++)
{
s.pb('1');
s1.pb('1');
}
for(i=1;i<=a;i++)
{
s.pb('0');
s1.pb('0');
}
cout<<"Yes"<<endl;
cout<<s<<endl;
cout<<s1<<endl;
return 0;
}
c=a+b;
c=c-b+max(b-2,0LL);
if(c<k)
{
cout<<"No"<<endl;
return 0;
}
cout<<"Yes"<<endl;
for(i=1;i<=b;i++)s.pb('1');
for(i=1;i<=a;i++)s.pb('0');
s1.pb('1');
s1.pb('0');
for(i=1;i<=b-2;i++)s1.pb('1');
for(i=1;i<=a-1;i++)s1.pb('0');
s1.pb('1');
for(i=1;i<b-1;i++)
{
if(c==k)break;
swap(s1[i],s1[i+1]);
c--;
}
for(i=s1.size()-1;i>b-1;i--)
{
if(c==k)break;
swap(s1[i],s1[i-1]);
c--;
}
cout<<s<<endl;
cout<<s1<<endl;
}
| 4 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int a[4];
int b[4];
while(cin>>a[0]>>a[1]>>a[2]>>a[3]){
for(int i = 0; i < 4; i++)
cin>>b[i];
int hit=0;
int blow=0;
for(int i = 0; i < 4; i++){
if(a[i]==b[i])
hit++;
else{
for(int j = 0; j < 4; j++){
if(a[i]==b[j]){
blow++;
}
}
}
}
cout<<hit<<" "<<blow<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m;
int main() {
for (cin >> t; t--;) {
cin >> n >> m;
cout << 'W';
for (int i = 2; i <= m; i++) cout << 'B';
cout << endl;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << 'B';
cout << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < 4; i++) {
if (i < 2) cout << 'a';
for (int j = 0; j < (n - (i < 2 ? 1 : 0)) / 2; j++)
cout << char('a' + (i + j) % 24 + 1) << char('a' + (i + j) % 24 + 1);
if ((n - (i < 2 ? 1 : 0)) % 2) cout << 'z';
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int nn = 0, mp = 999999999;
int ans = 0;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (b < mp) {
ans += nn * mp;
nn = 0;
mp = b;
}
nn += a;
}
ans += nn * mp;
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 110;
const int MAX_M = 20;
const long long INF = (1LL << 60);
struct Elem {
Elem() {}
Elem(int ruble, int monitor, int prob)
: ruble(ruble), monitor(monitor), prob(prob) {}
int ruble, monitor, prob;
bool operator<(const Elem &b) const { return monitor < b.monitor; }
} elem[MAX_N];
int n, m, price;
long long f[1 << MAX_M];
int main() {
scanf("%d%d%d", &n, &m, &price);
for (int i = 0; i < n; i++) {
int a, b, c, d, e = 0;
scanf("%d%d%d", &a, &b, &c);
for (int j = 0; j < c; j++) {
scanf("%d", &d);
d--;
e = e | (1 << d);
}
elem[i] = Elem(a, b, e);
}
long long ans = INF;
sort(elem, elem + n);
fill(f, f + (1 << m), INF);
f[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++) {
f[j | elem[i].prob] = min(f[j | elem[i].prob], f[j] + elem[i].ruble);
}
ans = min(ans, f[(1 << m) - 1] + 1LL * price * elem[i].monitor);
}
if (ans == INF)
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int c[5001][5001] = {0};
const int mod = 1000000007;
int main() {
char s[5000 + 1], t[5000 + 1];
scanf("%s%s", s, t);
int sl = strlen(s), tl = strlen(t);
c[0][0] = (s[0] == t[0]);
for (int j = 1; j < tl; j++)
if (s[0] == t[j])
c[0][j] = c[0][j - 1] + 1;
else
c[0][j] = c[0][j - 1];
for (int i = 1; i < sl; i++) {
if (s[i] == t[0])
c[i][0] = 1;
else
c[i][0] = 0;
for (int j = 1; j < tl; j++)
if (s[i] == t[j])
c[i][j] = (c[i - 1][j - 1] + c[i][j - 1] + 1) % mod;
else
c[i][j] = c[i][j - 1];
}
int r = 0;
for (int i = 0; i < sl; i++) r = (r + c[i][tl - 1]) % mod;
printf("%d\n", r);
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int q;
cin>>q;
long long int lp=0;
long long int rp=0;
for(int i=0;i<q;i++){
long long int p,n;
char c;
cin>>p>>c>>n;
if(c=='(') lp+=n;
else rp+=n;
cout<<(lp==rp ? "Yes": "No")<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long exp(long long a, long long b, long long m) {
if (b == 0) return 1;
if (b == 1) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const long long MAXN = 500100;
long long dp[MAXN];
long long big[MAXN];
long long a[MAXN];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) big[i] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = i; j <= n; j += i) {
if (j != i) big[j] = max(big[j], i);
}
}
vector<long long> v;
for (long long i = 1; i <= n; i++) {
v.push_back(i);
}
sort(v.begin(), v.end(),
[&](long long a, long long b) { return big[a] < big[b]; });
for (long long i = 1; i <= n; i++) {
a[i] = v[i - 1];
}
dp[1] = 1;
for (long long i = 2; i <= n; i++) {
dp[i] = dp[i - 1];
dp[i] = max(dp[i], big[a[i]]);
}
for (long long i = 2; i <= n; i++) {
cout << dp[i] << " ";
}
cout << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dp[26][26];
int main() {
char name[20], s, e;
int n, i, j, len, maxi;
scanf("%d", &n);
for (int i = (int)0; i < (int)n; ++i) {
scanf("%s", name);
len = strlen(name);
s = name[0];
e = name[len - 1];
maxi = len;
for (j = 0; j < 26; j++) {
if (dp[j][s - 97] > 0 && dp[j][s - 97] + len > dp[j][e - 97])
dp[j][e - 97] = dp[j][s - 97] + len;
}
if (maxi > dp[s - 97][e - 97]) dp[s - 97][e - 97] = maxi;
}
int ans = 0;
for (i = 0; i < 26; i++)
if (dp[i][i] > ans) ans = dp[i][i];
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int carPos[1005];
vector<pair<int, int> > car;
int main() {
int L, b, f;
cin >> L >> f >> b;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
sort(car.begin(), car.end());
int t;
cin >> t;
if (t == 1) {
int l;
cin >> l;
int J = -1, X;
if (l > L) {
cout << "-1\n";
continue;
}
if (car.empty() || car[0].first - b >= l) {
carPos[i] = 0;
J = 0;
X = 0;
} else {
for (int j = 0; j < car.size(); ++j) {
int x = car[j].first + car[j].second + f;
if (x + l > L) break;
if (j == car.size() - 1 || car[j + 1].first >= x + b + l) {
X = x;
J = j;
break;
}
}
}
if (J == -1) {
cout << "-1\n";
} else {
car.push_back(make_pair(X, l));
carPos[i] = X;
cout << X << "\n";
}
} else {
int ind;
cin >> ind;
--ind;
for (int j = 0; j < car.size(); ++j) {
if (car[j].first == carPos[ind]) {
car.erase(car.begin() + j);
break;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100010] = {0}, b[100010] = {0}, a1[100010] = {0}, b1[100010] = {0};
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
for (int i = 1; i <= n; i++) {
a1[i] = a[i] - a[i - 1];
b1[i] = b[i] - b[i - 1];
}
sort(a1 + 1, a1 + 1 + n);
sort(b1 + 1, b1 + 1 + n);
if (a[1] == b[1] && a[n] == b[n]) {
for (int i = 1; i <= n; i++) {
if (a1[i] != b1[i]) {
cout << "No" << endl;
return 0;
}
}
} else {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes, ad[70];
bool status[105];
int n, ara[105], dp[105][(1 << 18) + 5], mp[105], dir[105][(1 << 18) + 5];
bool Check(int n, int pos) { return (bool)(n & (1 << pos)); }
int Set(int n, int pos) { return n = (n | (1 << pos)); }
void gen() {
int i, j, si = sqrt(102);
for (i = 3; i <= si; i += 2) {
if (!status[i]) {
for (j = i * i; j <= 100; j += i) {
status[j] = true;
}
}
}
primes.push_back(2);
for (i = 3; i <= 100; i += 2) {
if (!status[i]) {
primes.push_back(i);
}
}
memset(mp, -1, sizeof mp);
for (i = 0; i < primes.size(); i++) {
mp[primes[i]] = i;
}
}
int func(int indx, int mask) {
if (indx == n) {
return 0;
}
if (dp[indx][mask] != -1) {
return dp[indx][mask];
}
int ans = ara[indx] - 1 + func(indx + 1, mask);
dir[indx][mask] = 1;
for (int val = 2; val <= 60; val++) {
bool flag = true;
for (int v : ad[val]) {
bool p = Check(mask, mp[v]);
if (p) {
flag = false;
break;
}
}
if (flag) {
int temp = mask;
for (int v : ad[val]) {
temp = Set(temp, mp[v]);
}
int ret = abs(ara[indx] - val) + func(indx + 1, temp);
if (ret < ans) {
ans = ret;
dir[indx][mask] = val;
}
}
}
return dp[indx][mask] = ans;
}
void go(int indx, int mask) {
if (indx == n) return;
cout << dir[indx][mask] << ' ';
int temp = mask;
if (dir[indx][mask] == 1) {
go(indx + 1, mask);
} else {
for (int v : ad[dir[indx][mask]]) {
temp = Set(temp, mp[v]);
}
go(indx + 1, temp);
}
}
int main() {
gen();
int i, j;
for (i = 2; i <= 60; i++) {
int num = i;
for (int v : primes) {
if (num % v == 0) {
ad[i].push_back(v);
}
}
}
cin >> n;
for (i = 0; i < n; i++) {
cin >> ara[i];
}
memset(dp, -1, sizeof dp);
int ans = func(0, 0);
go(0, 0);
cout << endl;
return 0;
}
| 4 |
#include<stdio.h>
#include<vector>
struct P{int x,y;}p;
int r;
typedef std::vector<P>V;
V v[252][252];
int S(int s){return s*s;}
int F(const V&v,P p)
{
int i,a;
for(a=i=0;i<v.size();++i)
if(S(v[i].x-p.x)+S(v[i].y-p.y)<=16*r*r)
++a;
return a;
}
int main()
{
int n,m,i,j,x,y,a;
while(scanf("%d%d%d",&n,&m,&r),r)
{
for(a=i=0;i<252;++i)for(j=0;j<252;++j)v[i][j].clear();
while(n--)
{
scanf("%d%d",&p.x,&p.y);
v[p.y/40+1][p.x/40+1].push_back(p);
}
while(m--)
{
scanf("%d%d",&p.x,&p.y);
x=p.x/40+1,y=p.y/40+1;
for(i=-1;i<2;++i)for(j=-1;j<2;++j)a+=F(v[y+i][x+j],p);
}
printf("%d\n",a);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int a, b, c, n;
cin >> a >> b >> c >> n;
int res = n - (a + b - c);
if (res <= 0) {
cout << -1;
return 0;
}
if (a < c || b < c || a + b < c) {
cout << -1;
return 0;
} else
cout << res;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.