solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
const int mod = 1000000009;
int main() {
int N, M;
cin >> N >> M;
int lim = max(N, 3);
vector<int> fact(3 * lim + 1), inv(3 * lim + 1), factinv(3 * lim + 1), val(N + 1);
fact[0] = 1; inv[1] = 1; factinv[0] = 1;
for (int i = 1; i <= 3 * lim; ++i) fact[i] = (long long)(fact[i - 1]) * i % mod;
for (int i = 2; i <= 3 * lim; ++i) inv[i] = (long long)(inv[mod % i]) * (mod - mod / i) % mod;
for (int i = 1; i <= 3 * lim; ++i) factinv[i] = (long long)(factinv[i - 1]) * inv[i] % mod;
val[0] = 1; int mul = 1;
for (int i = 1; i <= N; ++i) {
mul = (long long)(mul) * factinv[3] % mod;
val[i] = (long long)(mul) * fact[3 * i] % mod * factinv[i] % mod;
}
vector<int> A(M), B(M), C(M);
vector<int> cv;
for (int i = 0; i < M; ++i) {
cin >> A[i] >> B[i] >> C[i];
cv.push_back(A[i]);
cv.push_back(B[i]);
}
sort(cv.begin(), cv.end());
cv.erase(unique(cv.begin(), cv.end()), cv.end());
int S = cv.size();
vector<int> par(S);
for (int i = 0; i < S; ++i) par[i] = i;
function<int(int)> root = [&](int x) {
if (x == par[x]) return x;
return par[x] = root(par[x]);
};
for (int i = 0; i < M; ++i) {
A[i] = find(cv.begin(), cv.end(), A[i]) - cv.begin();
B[i] = find(cv.begin(), cv.end(), B[i]) - cv.begin();
}
vector<int> nA, nB;
for (int i = 0; i < M; ++i) {
if (C[i] == 0) {
par[root(A[i])] = root(B[i]);
}
else {
nA.push_back(A[i]);
nB.push_back(B[i]);
}
}
A = nA; B = nB;
M = A.size();
vector<int> inipar = par;
int ans = 0;
for (int i = 0; i < 1 << M; ++i) {
par = inipar;
int cnt = 0;
for (int j = 0; j < M; ++j) {
if ((i >> j) & 1) {
par[root(A[j])] = root(B[j]);
++cnt;
}
}
vector<int> hist(S);
for (int j = 0; j < S; ++j) {
++hist[root(j)];
}
bool ok = true;
int c1 = 3 * N - S, c2 = 0, c3 = 0;
for (int j = 0; j < S; ++j) {
if (hist[j] >= 4) {
ok = false;
break;
}
if (hist[j] == 3) ++c3;
if (hist[j] == 2) ++c2;
if (hist[j] == 1) ++c1;
}
if (!ok || c1 < c2) continue;
int s1 = (c1 - c2) / 3, s2 = c2, s3 = c3;
int sub = (long long)(fact[c1]) * factinv[c1 - c2] % mod * val[s1] % mod;
if (cnt % 2 == 0) ans = (ans + sub) % mod;
else ans = (ans - sub + mod) % mod;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 6;
const int inf = (int)1e9 * 2;
const int mod = (int)1e9 + 7;
int n, m, t[maxn * 2];
int maxi = -inf, mini = inf, cnt, sum, qwe;
int b, c;
string s, str, save, prov, save2;
int a[100];
char alf[10] = {'a', 'e', 'i', 'o', 'u', 'y'};
bool ok;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t[i];
}
cin.ignore();
for (int i = 0; i < n; i++) {
getline(cin, s);
for (int j = 0; j < s.length(); j++) {
for (int k = 0; k < 6; k++) {
if (s[j] == alf[k]) {
cnt++;
}
}
}
if (cnt != t[i]) {
cout << "NO";
return 0;
}
cnt = 0;
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int MAXM = 3010;
int n;
int xL[MAXN], xR[MAXN], yL[MAXN], yR[MAXN];
int L[MAXM][MAXM], D[MAXM][MAXM], F[MAXM][MAXM];
int id[MAXN];
pair<int, pair<int, int> > s[MAXN * 2];
bool cmp(int a, int b) {
return yR[a] < yR[b] || yR[a] == yR[b] && xR[a] < xR[b];
}
void prepare() {
memset(L, 0, sizeof(L));
int n1 = 0;
for (int i = 0; i < (n); i++) {
s[n1++] = make_pair(yL[i], make_pair(xL[i], xR[i]));
s[n1++] = make_pair(yR[i], make_pair(xL[i], xR[i]));
}
sort(s, s + n1);
n1 = unique(s, s + n1) - s;
for (int i = 0; i < n1;) {
int j = i, Y = s[i].first;
while (j < n1 && s[j].first == Y) ++j;
int l = s[i].second.first, r = s[i].second.second;
for (int k = i; k < j; ++k) {
if (s[k].second.first > r) l = s[k].second.first;
if (s[k].second.second > r) r = s[k].second.second;
for (int x = s[k].second.first; x <= s[k].second.second; ++x) {
L[x][Y] = x - l;
}
}
i = j;
}
memset(D, 0, sizeof(D));
int n2 = 0;
for (int i = 0; i < (n); i++) {
s[n2++] = make_pair(xL[i], make_pair(yL[i], yR[i]));
s[n2++] = make_pair(xR[i], make_pair(yL[i], yR[i]));
}
sort(s, s + n2);
n2 = unique(s, s + n2) - s;
for (int i = 0; i < n2;) {
int j = i, X = s[i].first;
while (j < n2 && s[j].first == X) ++j;
int l = s[i].second.first, r = s[i].second.second;
for (int k = i; k < j; ++k) {
if (s[k].second.first > r) l = s[k].second.first;
if (s[k].second.second > r) r = s[k].second.second;
for (int y = s[k].second.first; y <= s[k].second.second; ++y) {
D[X][y] = y - l;
}
}
i = j;
}
memset(F, 0, sizeof(F));
for (int i = 0; i < (n); i++) id[i] = i;
sort(id, id + n, cmp);
for (int i = 0; i < (n); i++) {
for (int x = xL[id[i]] + 1; x <= xR[id[i]]; ++x) {
for (int y = yL[id[i]] + 1; y <= yR[id[i]]; ++y) {
F[x][y] = F[x][y - 1] + 1;
}
}
}
}
int ans[MAXN];
void output(int id, int e) {
int t = 0;
for (int i = 0; i < (n); i++) {
if (xL[i] < xR[id] - e) continue;
if (xR[i] > xR[id]) continue;
if (yL[i] < yR[id] - e) continue;
if (yR[i] > yR[id]) continue;
ans[t++] = i + 1;
}
printf("YES %d\n", t);
for (int i = 0; i < (t); i++) {
printf("%d%c", ans[i], i == t - 1 ? '\n' : ' ');
}
}
void solve() {
for (int i = 0; i < (n); i++) {
int x = xR[i], y = yR[i], minE = 10000, up = min(D[x][y], L[x][y]);
for (int e = 1; e <= up; ++e) {
minE = min(minE, F[x - e + 1][y]);
if (minE < e) break;
if (D[x][y] - D[x][y - e] < e || D[x - e][y] - D[x - e][y - e] < e)
continue;
if (L[x][y] - L[x - e][y] < e || L[x][y - e] - L[x - e][y - e] < e)
continue;
output(i, e);
return;
}
}
puts("NO");
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < (n); i++)
scanf("%d%d%d%d", xL + i, yL + i, xR + i, yR + i);
prepare();
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
string a;
cin >> a;
reverse(a.begin(), a.end());
string d;
for (int i = 0; i < a.size(); i++) {
d += a[i];
if (d == "op") {
cout << "FILIPINO" << endl;
break;
} else if (d == "used" or d == "usam") {
cout << "JAPANESE" << endl;
break;
} else if (d == "adinm") {
cout << "KOREAN" << endl;
break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
struct SegmentTree {
static const int mxn = 1 << 18;
int tag[mxn << 1];
int mx[mxn << 1], mxu[mxn << 1];
inline void push(int x, int v) {
tag[x] += v;
mx[x] += v;
}
inline void pushdown(int x) {
if (tag[x]) {
push(x << 1, tag[x]);
push(x << 1 | 1, tag[x]);
tag[x] = 0;
}
}
inline void pushup(int x) {
if (mx[x << 1] < mx[x << 1 | 1]) {
mx[x] = mx[x << 1 | 1];
mxu[x] = mxu[x << 1 | 1];
} else {
mx[x] = mx[x << 1];
mxu[x] = mxu[x << 1];
}
}
void init(int n, int a[]) {
memset(tag, 0, sizeof(tag));
for (int i = 0; i < (int)(mxn); ++i) mx[i + mxn] = 0, mxu[i + mxn] = -1;
for (int i = 0; i < (int)(n); ++i) mx[i + mxn] = a[i], mxu[i + mxn] = i;
for (int i = mxn - 1; i; --i) pushup(i);
fprintf(stderr, "%d %d\n", mx[1], mxu[1]);
}
inline void update(int l, int r, int v, int i = 1, int a = 0, int b = mxn) {
if (l <= a && b <= r) return push(i, v);
if (r <= a || b <= l) return;
pushdown(i);
int m = (a + b) >> 1;
update(l, r, v, i << 1, a, m);
update(l, r, v, i << 1 | 1, m, b);
pushup(i);
}
} seg;
const int mxn = 2e5 + 5;
int n, K;
std::vector<int> adj[mxn];
int fa[mxn], dep[mxn];
int sz[mxn], son[mxn], top[mxn];
int on[mxn], dfn[mxn], ed[mxn], tim;
void dfs(int u, int p) {
sz[u] = 1, son[u] = -1;
for (int v : adj[u]) {
if (v == p) continue;
fa[v] = u;
dep[v] = dep[u] + 1;
dfs(v, u);
sz[u] += sz[v];
if (!~son[u] || sz[v] > sz[son[u]]) son[u] = v;
}
}
void hld(int u, int p) {
top[u] = ~p && u == son[p] ? top[p] : u;
on[tim] = u;
dfn[u] = tim++;
if (son[u] != -1) hld(son[u], u);
for (int v : adj[u]) {
if (v == p || v == son[u]) continue;
hld(v, u);
}
ed[u] = tim;
}
std::set<int> unreal;
inline void UPDATE(int l, int r) {
for (auto it = unreal.lower_bound(l); it != unreal.end() && *it <= r;
it = unreal.erase(it)) {
seg.update(dfn[on[*it]], ed[on[*it]], -1);
}
}
int main() {
scanf("%d %d", &n, &K);
for (int i = 0; i < (int)(n - 1); ++i) {
int u, v;
scanf("%d %d", &u, &v);
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0, -1);
hld(0, -1);
static int temp[mxn];
for (int i = 0; i < (int)(n); ++i) temp[dfn[i]] = dep[i] + 1;
seg.init(n, temp);
for (int i = 0; i < (int)(n); ++i) unreal.insert(i);
long long ans = -(1LL << 60);
for (int r = 0; r <= K; ++r) {
int b = std::min((int)unreal.size(), n / 2);
long long cur = 1LL * (n - r - b) * (r - b);
ans = std::max(ans, cur);
if (r < K) {
int u = on[seg.mxu[1]];
while (top[u]) {
UPDATE(dfn[top[u]], dfn[u]);
u = fa[top[u]];
}
UPDATE(dfn[top[u]], dfn[u]);
}
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define INF 1e18
ll MOD = 1e9+7;
ll a[403];
ll n,K;
ll dp[100000000];
//dp[i] - in which rows i have done and ways to make it happen
int main(){
cin>>n;
memset(dp,0,sizeof dp);
ll a[n][n];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cin>>a[i][j];
}
}
dp[0]=1;
for(int i=0;i<(1<<n);i++){
int col = __builtin_popcount(i);
for(int j=0;j<n;j++){
if(((1<<j)&i)==0){
if(a[j][col]){
dp[(i|(1<<j))]+=dp[i];
dp[(i|(1<<j))] = dp[(i|(1<<j))]%MOD;
}
}
}
}
cout<<dp[(1<<n)-1]<<endl;
} | 0 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
typedef long long ll ;
#define rep(i, a, b) for (int i = a; i <= b; ++ i)
const int N = 200005, M = N << 1, inf = 1e9 + 7 ;
using namespace std ;
int e, n, ter[M], nxt[M], lnk[N], v[N], f[N][3], g[N][3] ;
char s[N] ;
ll ans = 0 ;
void add(int x, int y) {
ter[++ e] = y, nxt[e] = lnk[x], lnk[x] = e ;
}
void dfs1(int p, int las) {
f[p][0] = 0, f[p][1] = inf, g[p][0] = g[p][1] = inf ;
if (v[p]) g[p][0] = 0 ;
for (int i = lnk[p]; i; i = nxt[i]) if (ter[i] != las) {
int v = ter[i] ;
dfs1(v, p) ;
if (f[v][0] + 1 > f[p][0]) f[p][1] = f[p][0], f[p][0] = f[v][0] + 1 ; else f[p][1] = max(f[p][1], f[v][0] + 1) ;
if (g[v][0] + 1 < g[p][0]) g[p][1] = g[p][0], g[p][0] = g[v][0] + 1 ; else g[p][1] = min(g[p][1], g[v][0] + 1) ;
}
}
void dfs2(int p, int u) {
f[p][2] = 0, g[p][2] = inf ;
if (u) {
f[p][2] = max(f[p][2], f[u][2] + 1) ;
if (f[p][0] + 1 == f[u][0]) f[p][2] = max(f[p][2], f[u][1] + 1) ; else
f[p][2] = max(f[p][2], f[u][0] + 1) ;
g[p][2] = min(g[p][2], g[u][2] + 1) ;
if (g[p][0] + 1 == g[u][0]) g[p][2] = min(g[p][2], g[u][1] + 1) ; else
g[p][2] = min(g[p][2], g[u][0] + 1) ;
}
for (int i = lnk[p]; i; i = nxt[i]) if (ter[i] != u) dfs2(ter[i], p) ;
}
void dfs3(int p, int las) {
int low = inf, high = f[p][0] + 1, mx = max(f[p][2], f[p][0]), cnt = (las > 0) ;
if (las && g[p][2] < inf) low = min(low, min(f[p][2], f[p][0] + 2 * g[p][2])) ;
for (int i = lnk[p]; i; i = nxt[i]) if (ter[i] != las) {
dfs3(ter[i], p) ;
high = min(high, f[ter[i]][2]) ;
++ cnt ;
if (g[ter[i]][0] < inf) low = min(low, min(f[ter[i]][0] + 1, f[ter[i]][2] - 1 + (g[ter[i]][0] + 1) * 2)) ;
}
high = min(high, mx - 1) ;
if (cnt == 1) {
low = min(low, 2 * g[p][0]) ;
low = min(low, 2 * g[p][2]) ;
high = min(high, 1) ;
}
if (v[p]) low = 0 ;
// cout << p << " " << low << " " << high <<endl ;
ans += max(high - low + 1, 0) ;
}
int main() {
scanf("%d", &n) ;
int x, y ;
rep(i, 1, n - 1) {
scanf("%d%d", &x, &y) ;
add(x, y), add(y, x) ;
}
scanf("%s", s + 1) ;
rep(i, 1, n) v[i] = s[i] - '0' ;
dfs1(1, 0), dfs2(1, 0), dfs3(1, 0) ;
printf("%lld\n", ans + 1) ;
return 0 ;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool dv(int n, int r) { return n % r; }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, s;
cin >> n >> m >> s;
long long ioi = 0;
for (int x = 1; x <= n; x += 2)
for (int y = 1; y <= m; y += 2) {
int a = (x >> 1), b = (y >> 1);
if (x * y == s)
ioi += (2 * (a + 1) * (b + 1) - 1) * (n - x + 1) * (m - y + 1);
else if (x * y > s) {
int r = x * y - s;
if (!dv(r, 4)) {
r >>= 2;
for (int c = 1; c <= a; c++)
if (!dv(r, c))
if (r / c <= b) ioi += 2 * (n - x + 1) * (m - y + 1);
}
}
}
cout << ioi << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
int n, m, a, i, mx, cnt[N];
vector<int> vec;
bool check(int days) {
int rem = n;
for (int i = 0; i < vec.size(); ++i) {
rem -= (vec[i] / days);
}
return (rem <= 0);
}
int main() {
cin >> n >> m;
for (i = 0; i < m; ++i) {
cin >> a;
cnt[a]++;
}
for (i = 0; i < N; ++i) {
if (cnt[i] > 0) {
vec.push_back(cnt[i]);
mx = max(mx, cnt[i]);
}
}
sort(vec.rbegin(), vec.rend());
for (i = mx; i > 0; --i) {
if (check(i)) {
return cout << i, 0;
}
}
cout << 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5+100;
vector<int> g[N];
int d[N],mx[N],fa[N],n,a,t;
void dfs1(int u,int f){
fa[u]=f; mx[u]=d[u]=d[f]+1;
for(auto v:g[u]){
if(v==f) continue;
dfs1(v,u); mx[u]=max(mx[u],mx[v]);
}
}
int ans=0;
int main(){
scanf("%d %d %d",&n,&t,&a);
for(int i=1,u,v;i<n;++i){
scanf("%d %d",&u,&v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(a,a);
int k=d[t]/2-1;
if(d[t]%2==1) ans=1;
while(k--){
ans++; t=fa[t];
}
//printf("%d %d %d\n",t,mx[t],d[t]);
ans+=mx[t]-d[t];
printf("%d\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, r = 12;
bool b;
string s;
cin >> x >> s >> s;
b = s == "month";
if (b) {
switch (x) {
case 30:
r = 11;
break;
case 31:
r = 7;
break;
default:
r = 12;
}
} else {
if (x == 5 || x == 6)
r = 53;
else
r = 52;
}
cout << r << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
int gcd(int x, int y) {
while (x != 0 && y != 0) {
if (x > y) {
x %= y;
} else {
y %= x;
}
}
return x + y;
}
int main() {
ios_base::sync_with_stdio(false);
int n, l, r;
cin >> n >> l >> r;
if (n == 1) {
cout << r - l + 1 << endl;
} else if (n == 2) {
cout << (r - l + 1) * 1ll * (r - l) << endl;
} else {
long long ans = 0;
for (int x = 2; x * x <= r; x++) {
for (int y = 1; y < x; y++) {
if (gcd(x, y) == 1) {
long long maxi = 1;
for (int i = 1; i < n; i++) {
maxi *= x;
if (maxi > r) {
break;
}
}
if (maxi > r) {
continue;
}
long long mini = 1;
if (y > 1) {
for (int i = 1; i < n; i++) {
mini *= y;
}
}
long long mini_delta = (l - 1) / mini + 1;
long long maxi_delta = r / maxi;
ans += 2 * max(maxi_delta - mini_delta + 1, 0ll);
}
}
}
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
template <class T = int>
using V = vector<T>;
template <class T = int>
using VV = V<V<T> >;
template <class T>
void assign(V<T>& v, int n, const T& a = T()) {
v.assign(n, a);
}
template <class T, class... Args>
void assign(V<T>& v, int n, const Args&... args) {
v.resize(n);
for (auto&& e : v) assign(e, args...);
}
constexpr lint mod = 998244353;
inline lint emod(lint a, lint p = mod) { return (a % p + p) % p; }
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
V<> a(n);
for (int i = 0; i < n; ++i) cin >> a[i], --a[i];
V<VV<lint> > dp;
assign(dp, 2, 200, 3);
if (a[0] == -2)
for (int j = 0; j < 200; ++j) dp[1][j][1] = 1;
else
dp[1][a[0]][1] = 1;
for (int i = 1; i < n; ++i) {
assign(dp[i + 1 & 1], 200, 3, 0LL);
VV<lint> cum;
assign(cum, 3, 201);
for (int k = 0; k < 3; ++k)
for (int j = 0; j < 200; ++j)
cum[k][j + 1] = (cum[k][j] + dp[i & 1][j][k]) % mod;
if (a[i] == -2) {
for (int j = 0; j < 200; ++j) {
dp[i + 1 & 1][j][0] =
accumulate(begin(dp[i & 1][j]), end(dp[i & 1][j]), 0LL) % mod;
dp[i + 1 & 1][j][1] = (cum[0][j] + cum[1][j] + cum[2][j]) % mod;
dp[i + 1 & 1][j][2] =
(cum[0][200] - cum[0][j + 1] + cum[2][200] - cum[2][j + 1]) % mod;
}
} else {
dp[i + 1 & 1][a[i]][0] =
accumulate(begin(dp[i & 1][a[i]]), end(dp[i & 1][a[i]]), 0LL) % mod;
dp[i + 1 & 1][a[i]][1] =
(cum[0][a[i]] + cum[1][a[i]] + cum[2][a[i]]) % mod;
dp[i + 1 & 1][a[i]][2] =
(cum[0][200] - cum[0][a[i] + 1] + cum[2][200] - cum[2][a[i] + 1]) %
mod;
}
}
lint res = 0;
for (int j = 0; j < 200; ++j) res += dp[n & 1][j][0] + dp[n & 1][j][2];
cout << emod(res) << '\n';
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int g[101][101];
int main(void){
int n;
cin>>n;
for(int i=0;i<n;i++){
int u,k;
cin>>u>>k;
for(int j=0;j<k;j++){
int v;
cin>>v;
g[u][v]=1;
}
}
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
cout<<g[i][j]<<" \n"[j==n];
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
cin >> t;
while (t--) {
long long r, g, b, w;
cin >> r >> g >> b >> w;
if ((((r % 2) + (g % 2) + (b % 2) + (w % 2)) <= 1) ||
(r && g && b &&
((r - 1) % 2 + (g - 1) % 2 + (b - 1) % 2 + (w + 3) % 2) <= 1))
cout << "Yes\n";
else
cout << "No\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, d, tms, ans = 1;
cin >> n >> a >> b >> c >> d;
tms = a + b + c + d;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c >> d;
if (tms < a + b + c + d) {
ans++;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long x[4];
void solve(int tc) {
for (int i = 0; i < 4; i++) scanf("%lld", x + i);
if (x[0] == 0 && x[1] == 0 && x[2] == 0 && x[3] == 0) {
puts("0");
return;
}
if (x[0] == 1 && x[1] == 0 && x[2] == 0 && x[3] == 0) {
puts("00");
return;
}
if (x[0] == 0 && x[1] == 0 && x[2] == 0 && x[3] == 1) {
puts("11");
return;
}
if (x[0] == 0 && x[1] == 1 && x[2] == 0 && x[3] == 0) {
puts("01");
return;
}
if (x[0] == 0 && x[1] == 0 && x[2] == 1 && x[3] == 0) {
puts("10");
return;
}
if (x[0] == 0 && x[1] == 0 && x[2] == 0) {
long long m = sqrt(x[3] + x[3]) + 1;
if (m * (m - 1) != x[3] + x[3]) {
puts("Impossible");
return;
} else {
for (int i = 0; i < m; i++) printf("1");
}
return;
}
if (x[3] == 0 && x[1] == 0 && x[2] == 0) {
long long m = sqrt(x[0] + x[0]) + 1;
if (m * (m - 1) != x[0] + x[0]) {
puts("Impossible");
return;
} else {
for (int i = 0; i < m; i++) printf("0");
}
return;
}
long long n;
n = sqrt(x[0] + x[0]) + 1;
int ok = 1;
if (n * (n - 1) != x[0] + x[0]) ok = 0;
long long m = sqrt(x[3] + x[3]) + 1;
if (m * (m - 1) != x[3] + x[3]) ok = 0;
if (ok == 0) {
puts("Impossible");
return;
}
if (x[0] + x[1] + x[2] + x[3] != (n + m) * (n + m - 1) / 2) {
puts("Impossible");
return;
}
for (int i = 0; i < x[2] / n; i++) printf("1");
long long u = x[2] - n * (x[2] / n);
if (u != 0) {
for (int i = 0; i < n - u; i++) printf("0");
printf("1");
for (int i = 0; i < u; i++) printf("0");
for (int i = 0; i < m - 1 - x[2] / n; i++) printf("1");
} else {
for (int i = 0; i < n; i++) printf("0");
for (int i = 0; i < m - x[2] / n; i++) printf("1");
}
}
int main() {
int Tc = 1;
for (int tc = 1; tc <= Tc; tc++) {
solve(tc);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
int a[N + 5], p[N + 5], sp[10], cnt[10];
int main() {
int n;
scanf("%d", &n);
scanf("%d %d %d", p + 1, p + 2, p + 3);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
sort(p + 1, p + 4);
sp[1] = p[1];
sp[2] = p[2];
sp[3] = p[3];
sp[4] = p[1] + p[2];
sp[5] = p[1] + p[3];
sp[6] = p[2] + p[3];
sp[7] = p[1] + p[2] + p[3];
sort(sp + 1, sp + 8);
for (int i = 1; i <= n; ++i) {
++cnt[lower_bound(sp + 1, sp + 8, a[i]) - sp];
}
if (cnt[8]) {
printf("-1\n");
return 0;
}
int ans = cnt[7];
ans += cnt[6];
cnt[1] -= min(cnt[1], cnt[6]);
ans += cnt[5];
int k = cnt[5], tmp;
tmp = min(cnt[2], k);
k -= tmp;
cnt[2] -= tmp;
tmp = min(cnt[1], k);
k -= tmp;
cnt[1] -= tmp;
if (p[1] + p[2] > p[3]) {
ans += cnt[4];
int k = cnt[4];
tmp = min(cnt[3], k);
k -= tmp;
cnt[3] -= tmp;
tmp = min(cnt[2], k);
k -= tmp;
cnt[2] -= tmp;
tmp = min(cnt[1], k);
k -= tmp;
cnt[1] -= tmp;
cnt[4] = 0;
}
int m = cnt[3] + cnt[4], _min = INT_MAX;
for (int i = cnt[4]; i <= m; ++i) {
int j = m - i;
if (i > j) {
int _ans = i;
int a = cnt[1], b = cnt[2], k = i - j;
tmp = min(b, k);
k -= tmp;
b -= tmp;
tmp = min(a, k);
k -= tmp;
a -= tmp;
k = i - j;
tmp = min(a, k);
k -= tmp;
a -= tmp;
k = b / 2;
_ans += k;
b %= 2;
tmp = min(a, k);
k -= tmp;
a -= tmp;
if (a + b) _ans += (a + b - 1) / 3 + 1;
_min = min(_min, _ans);
} else {
int _ans = j;
int a = cnt[1], b = cnt[2], k = j - i;
tmp = min(b, k);
k -= tmp;
b -= tmp;
tmp = min(a, k);
k -= tmp;
a -= tmp;
k = b / 2;
_ans += k;
b %= 2;
tmp = min(a, k);
k -= tmp;
a -= tmp;
if (a + b) _ans += (a + b - 1) / 3 + 1;
_min = min(_min, _ans);
}
}
ans += (_min == INT_MAX ? 0 : _min);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <iostream>
#include <algorithm>
using namespace std;
const int Z = 1e9+7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int c[n];
for (int i = 0; i < n; i++) {
cin >> c[i];
}
sort(c, c+n);
int ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + 1ll * (n + 1 - i) * c[i]) % Z;
}
for (int i = 0; i < n - 1; i++) {
ans = 4ll * ans % Z;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool poss(long long int x, long long int y, long long int x1, long long int y1,
long long int t) {
long long int d = (x - x1) * (x - x1) + (y - y1) * (y - y1);
if (d <= t * t) return true;
return false;
}
int main() {
long long int n, x, y, t;
double p;
map<pair<long long int, long long int>, double> m;
vector<pair<long long int, pair<long long int, long long int> > > v;
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> x >> y >> t >> p;
m[make_pair(x, y)] = p;
v.push_back(make_pair(t, make_pair(x, y)));
}
sort(v.begin(), v.end());
double ans[n + 1], max_ans = 0;
for (long long int i = 0; i < n; i++) ans[i] = m[v[i].second];
for (long long int i = 0; i < n; i++) {
for (long long int j = i - 1; j >= 0; j--) {
if (!poss(v[j].second.first, v[j].second.second, v[i].second.first,
v[i].second.second, v[j].first - v[i].first))
continue;
ans[i] = max(ans[i], ans[j] + m[v[i].second]);
}
}
for (long long int i = 0; i < n; i++) max_ans = max(ans[i], max_ans);
cout << fixed << setprecision(10) << max_ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int r;
r = n / 2;
int u;
int counter = 0;
for (int i = 1; i <= r; i++) {
u = n - i;
if (u % i == 0) {
counter++;
}
}
cout << counter;
}
| 1 |
#include<cstdio>
#include<iostream>
using namespace std;
int main()
{
int n,x,ans=0;
cin>>n;
while(n--){
cin>>x;
ans+=x-1;
}
cout<<ans;
} | 0 |
#include <iostream>
#include <fstream>
#include <algorithm>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
long long v[200005], sum[200005], cnt[200005], w[200005];
int main()
{
ios_base::sync_with_stdio(false); cin.tie(0);
int t; cin >> t;
for(int j=1; j<=t; j++)
{
int n, num=0; cin >> n;
for(int i=1; i<=n; i++) cin >> v[i];
sort(v+1, v+n+1);
for(int i=1; i<=n; i++)
{
int nr=0;
while(v[i]==v[i+1] && i<n)
{
nr++;
i++;
}
num++; cnt[num]=nr+1;
}
int MIN=n;
for(int i=1; i<=num; i++)
{
if(w[cnt[i]]==0)
{
w[cnt[i]]=1;
int c=cnt[i], rez=0;
for(int k=1; k<=num; k++)
{
if(cnt[k]<c) rez+=cnt[k];
else rez+=cnt[k]-c;
}
if(rez<MIN) MIN=rez;
}
}
for(int i=1; i<=n; i++) w[i]=0;
cout << MIN << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int i, a = 0, b = 0, c = 0;
getline(cin, s);
if (s.length() < 5) {
cout << "Too weak";
return 0;
}
for (i = 0; i < s.length(); i++) {
if (s[i] >= '0' && s[i] <= '9') a = 1;
if (s[i] >= 'A' && s[i] <= 'Z') b = 1;
if (s[i] >= 'a' && s[i] <= 'z') c = 1;
}
if (a == 1 && b == 1 && c == 1) {
cout << "Correct";
return 0;
}
cout << "Too weak";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N], b[N], s[N];
int st[N], tp;
int xx;
bool f;
bool vis[N];
double ans[N];
struct edge {
int v, w;
edge(int x, int y) { v = x, w = y; }
};
vector<edge> e[N];
void dfs(int u) {
st[++tp] = u;
vis[u] = 1;
for (auto x : e[u]) {
int v = x.v, w = x.w;
if (vis[v]) {
if (a[u] + a[v] == 0 && b[u] + b[v] != w) {
printf("NO\n");
exit(0);
}
if (a[u] + a[v] != 0) {
int nx = (w - b[u] - b[v]) / (a[u] + a[v]);
if (f && nx != xx) {
printf("NO\n");
exit(0);
}
xx = nx;
f = 1;
}
} else {
a[v] = -a[u];
b[v] = w - b[u];
dfs(v);
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
w <<= 1;
e[u].push_back(edge(v, w));
e[v].push_back(edge(u, w));
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
a[i] = 1, b[i] = 0;
tp = 0;
f = 0;
dfs(i);
if (!f) {
for (int i = 1; i <= tp; i++) {
s[i] = -b[st[i]] / a[st[i]];
}
sort(s + 1, s + tp + 1);
xx = s[(1 + tp) >> 1];
}
for (int i = 1; i <= tp; i++) {
ans[st[i]] = 1.0 * a[st[i]] * xx + b[st[i]];
ans[st[i]] /= 2;
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) {
printf("%.1f%c", ans[i], i == n ? '\n' : ' ');
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, long long> cor;
long long n;
long long x[1000005], y[1000005];
long long perechi[1000005], unu[1000005];
void reeducare() {
for (long long i = 1; i <= n; i++) y[i] = x[i];
sort(y + 1, y + n + 1);
for (long long i = 1; i <= n; i++) {
if (y[i] != y[i - 1]) {
cor[y[i]] = y[i - 1] + 1;
y[i] = y[i - 1] + 1;
} else
y[i] = y[i - 1];
}
for (long long i = 1; i <= n; i++) x[i] = cor[x[i]];
}
void update(long long loc[], long long poz, long long val) {
if (poz == 0) return;
for (; poz <= n; poz += (poz & -poz)) loc[poz] += val;
}
long long sum(long long loc[], long long poz) {
long long sum = 0;
for (; poz; poz -= (poz & -poz)) sum += loc[poz];
return sum;
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> x[i];
reeducare();
long long rez = 0;
for (long long i = n; i >= 1; i--) {
rez += sum(perechi, x[i] - 1);
update(perechi, x[i], sum(unu, x[i] - 1));
update(unu, x[i], 1);
}
cout << rez;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y;
};
bool operator<(Point A, Point B) {
return make_pair(A.x, A.y) < make_pair(B.x, B.y);
}
bool operator==(Point A, Point B) {
return make_pair(A.x, A.y) == make_pair(B.x, B.y);
}
struct Vector {
long long x, y;
Vector(Point A, Point B) {
x = B.x - A.x;
y = B.y - A.y;
}
};
Vector neg(Vector x) {
x.x = -x.x;
x.y = -x.y;
return x;
}
Point add(Point P, Vector A) {
P.x += A.x;
P.y += A.y;
return P;
}
long long operator^(Vector a, Vector b) { return abs(a.x * b.y - a.y * b.x); }
vector<Point> P;
long long calc(int x, int y, int z) {
return Vector(P[x], P[y]) ^ Vector(P[x], P[z]);
}
int main() {
int n;
long long s;
scanf("%d %lld", &n, &s);
P = vector<Point>(n);
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &P[i].x, &P[i].y);
}
sort(P.begin(), P.end());
P.resize(unique(P.begin(), P.end()) - P.begin());
if ((int)P.size() < 3) {
while ((int)P.size() < 3) P.push_back(P[0]);
for (int i = 0; i < 3; i++) {
printf("%lld %lld\n", P[i].x, P[i].y);
}
return 0;
}
random_shuffle(P.begin(), P.end());
int a = 0, b = 1, c = 2;
while (1) {
bool better = false;
for (int i = 0; i < n; i++) {
if (calc(a, b, c) < calc(a, b, i)) {
better = true;
c = i;
}
if (calc(a, b, c) < calc(a, i, c)) {
better = true;
b = i;
}
if (calc(a, b, c) < calc(i, b, c)) {
better = true;
a = i;
}
}
if (!better) break;
}
Point R1, R2, R3;
R1 = add(P[a], Vector(P[b], P[c]));
R2 = add(P[a], neg(Vector(P[b], P[c])));
R3 = add(P[b], Vector(P[a], P[c]));
printf("%lld %lld\n", R1.x, R1.y);
printf("%lld %lld\n", R2.x, R2.y);
printf("%lld %lld\n", R3.x, R3.y);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, b, mod;
long long dp[550][550];
int a[550];
int main() {
scanf("%d%d%d%d", &n, &m, &b, &mod);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = a[i]; k <= b; k++) {
dp[j][k] = (dp[j][k] + dp[j - 1][k - a[i]]) % mod;
}
}
}
long long ans = 0;
for (int i = 0; i <= b; i++) {
ans = (ans + dp[m][i]) % mod;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int a[n], b[n];
bool c1, c2, c3;
c1 = c3 = c2 = false;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
if (a[0] == 1) c1 = true;
for (int j = (s - 1); j < n; j++) {
if (a[j] == 1 & b[j] == 1 & b[s - 1] == 1) {
c2 = true;
break;
}
}
if (a[s - 1] == 1) c3 = true;
if (c1 & (c2 || c3)) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, mx = 100000000000, a, b, i, p, q, x, y, flag = 0;
cin >> n;
a = 4;
b = 7;
for (i = 0; i * a <= n; i++) {
if ((n - (i * a)) % b == 0) {
p = i;
q = (n - (i * a)) / b;
if (p + q < mx) {
mx = p + q;
x = i;
y = q;
flag = 1;
}
}
}
if (flag == 0) {
cout << -1;
} else {
for (i = 1; i <= x; i++) {
cout << 4;
}
for (i = 1; i <= y; i++) {
cout << 7;
}
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
int sum = 0, count = 0, n, m;
scanf("%d%d", &n, &m);
int arr[n], i;
for (i = 0; i < n; i++) scanf("%d", &arr[i]);
std::sort(arr, arr + n);
for (i = 0; i < n; i++) {
if (arr[i] < 0 && count < m) {
sum += arr[i];
count++;
} else
break;
}
printf("%d", -1 * sum);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
static const long long COUNTER_CLOCKWISE = 1;
static const long long CLOCKWISE = -1;
static const long long ONLINE_BACK = 2;
static const long long ONLINE_FRONT = -2;
static const long long ON_SEGMENT = 0;
struct Point {
double x, y;
Point() {}
Point(double x, double y) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double k) { return Point(x * k, y * k); }
Point operator/(double k) { return Point(x / k, y / k); }
double norm() { return x * x + y * y; }
double abs() { return sqrt(norm()); }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-15) && fabs(y - p.y) < (1e-15);
}
};
istream &operator>>(istream &is, Point &p) {
is >> p.x >> p.y;
return is;
}
ostream &operator<<(ostream &os, Point p) {
os << fixed << setprecision(12) << p.x << " " << p.y;
return os;
}
struct Segment {
Point p1, p2;
Segment() {}
Segment(Point p1, Point p2) : p1(p1), p2(p2) {}
};
struct Circle {
Point c;
double r;
Circle() {}
Circle(Point c, double r) : c(c), r(r) {}
};
double norm(Point a) { return a.x * a.x + a.y * a.y; }
double abs(Point a) { return sqrt(norm(a)); }
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool isOrthogonal(Point a, Point b) {
return (fabs((dot(a, b)) - (0.0)) < (1e-15));
}
bool isOrthogonal(Point a1, Point a2, Point b1, Point b2) {
return isOrthogonal(a1 - a2, b1 - b2);
}
bool isOrthogonal(Segment s1, Segment s2) {
return (fabs((dot(s1.p2 - s1.p1, s2.p2 - s2.p1)) - (0.0)) < (1e-15));
}
bool isParallel(Point a, Point b) {
return (fabs((cross(a, b)) - (0.0)) < (1e-15));
}
bool isParallel(Point a1, Point a2, Point b1, Point b2) {
return isParallel(a1 - a2, b1 - b2);
}
bool isParallel(Segment s1, Segment s2) {
return (fabs((cross(s1.p2 - s1.p1, s2.p2 - s2.p1)) - (0.0)) < (1e-15));
}
Point project(Segment s, Point p) {
Point base = s.p2 - s.p1;
double r = dot(p - s.p1, base) / norm(base);
return s.p1 + base * r;
}
Point reflect(Segment s, Point p) { return p + (project(s, p) - p) * 2.0; }
long long ccw(Point p0, Point p1, Point p2) {
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > (1e-15)) return COUNTER_CLOCKWISE;
if (cross(a, b) < -(1e-15)) return CLOCKWISE;
if (dot(a, b) < -(1e-15)) return ONLINE_BACK;
if (a.norm() < b.norm()) return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersect(Point p1, Point p2, Point p3, Point p4) {
return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0 &&
ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}
bool intersect(Segment s1, Segment s2) {
return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
double getDistanceLP(Segment l, Point p) {
return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double getDistanceSP(Segment s, Point p) {
if (dot(s.p2 - s.p1, p - s.p1) < 0.0) return abs(p - s.p1);
if (dot(s.p1 - s.p2, p - s.p2) < 0.0) return abs(p - s.p2);
return getDistanceLP(s, p);
}
double getDistance(Segment s1, Segment s2) {
if (intersect(s1, s2)) return 0.0;
return min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}
Point getCrossPoint(Segment s1, Segment s2) {
Point base = s2.p2 - s2.p1;
double d1 = abs(cross(base, s1.p1 - s2.p1));
double d2 = abs(cross(base, s1.p2 - s2.p1));
double t = d1 / (d1 + d2);
return s1.p1 + (s1.p2 - s1.p1) * t;
}
pair<Point, Point> getCrossPoints(Circle c, Segment l) {
Point pr = project(l, c.c);
Point e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
double base = sqrt(c.r * c.r - norm(pr - c.c));
return make_pair(pr + e * base, pr - e * base);
}
double arg(Point p) { return atan2(p.y, p.x); }
Point polar(double a, double r) { return Point(cos(r) * a, sin(r) * a); }
pair<Point, Point> getCrossPoints(Circle c1, Circle c2) {
double d = abs(c1.c - c2.c);
double a = acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d));
double t = arg(c2.c - c1.c);
return make_pair(c1.c + polar(c1.r, t + a), c1.c + polar(c1.r, t - a));
}
long long contains(vector<Point> g, Point p) {
long long n = g.size();
bool x = false;
for (long long i = 0; i < n; i++) {
Point a = g[i] - p, b = g[(i + 1) % n] - p;
if (fabs(cross(a, b)) < (1e-15) && dot(a, b) < (1e-15)) return 1;
if (a.y > b.y) swap(a, b);
if (a.y < (1e-15) && (1e-15) < b.y && cross(a, b) > (1e-15)) x = !x;
}
return (x ? 2 : 0);
}
vector<Point> andrewScan(vector<Point> s) {
vector<Point> u, l;
if (s.size() < 3) return s;
sort(s.begin(), s.end());
u.push_back(s[0]);
u.push_back(s[1]);
l.push_back(s[s.size() - 1]);
l.push_back(s[s.size() - 2]);
for (long long i = 2; i < (long long)s.size(); i++) {
for (long long n = u.size();
n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != CLOCKWISE; n--) {
u.pop_back();
}
u.push_back(s[i]);
}
for (long long i = s.size() - 3; i >= 0; i--) {
for (long long n = l.size();
n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != CLOCKWISE; n--) {
l.pop_back();
}
l.push_back(s[i]);
}
reverse(l.begin(), l.end());
for (long long i = u.size() - 2; i >= 1; i--) l.push_back(u[i]);
return l;
}
bool isConvex(vector<Point> p) {
bool f = 1;
long long n = p.size();
for (long long i = 0; i < n; i++) {
long long t = ccw(p[(i + n - 1) % n], p[i], p[(i + 1) % n]);
f &= t != CLOCKWISE;
}
return f;
}
double area(vector<Point> s) {
double res = 0;
for (long long i = 0; i < (long long)s.size(); i++) {
res += cross(s[i], s[(i + 1) % s.size()]) / 2.0;
}
return abs(res);
}
Point getCrossPointLL(Segment l1, Segment l2) {
double a = cross(l1.p2 - l1.p1, l2.p2 - l2.p1);
double b = cross(l1.p2 - l1.p1, l1.p2 - l2.p1);
if (abs(a) < (1e-15) && abs(b) < (1e-15)) return l2.p1;
return l2.p1 + (l2.p2 - l2.p1) * (b / a);
}
vector<Point> convexCut(vector<Point> p, Segment l) {
vector<Point> q;
for (long long i = 0; i < (long long)p.size(); i++) {
Point a = p[i], b = p[(i + 1) % p.size()];
if (ccw(l.p1, l.p2, a) != -1) q.push_back(a);
if (ccw(l.p1, l.p2, a) * ccw(l.p1, l.p2, b) < 0)
q.push_back(getCrossPointLL(Segment(a, b), l));
}
return q;
}
Segment bisector(Point p1, Point p2) {
Circle c1 = Circle(p1, abs(p1 - p2)), c2 = Circle(p2, abs(p1 - p2));
pair<Point, Point> p = getCrossPoints(c1, c2);
if (cross(p2 - p1, p.first - p1) > 0) swap(p.first, p.second);
return Segment(p.first, p.second);
}
Point spin(Point v, double theta) {
Point res;
res.x = cos(theta) * v.x - sin(theta) * v.y;
res.y = sin(theta) * v.x + cos(theta) * v.y;
return res;
}
vector<Segment> corner(Segment l1, Segment l2) {
vector<Segment> res;
if (isParallel(l1, l2)) {
double d = getDistanceLP(l1, l2.p1) / 2.0;
Point v1 = l1.p2 - l1.p1;
v1 = v1 / v1.abs() * d;
Point p = l2.p1 + spin(v1, 90.0 * (3.141592653589793238 / 180.0));
double d1 = getDistanceLP(l1, p);
double d2 = getDistanceLP(l2, p);
if (abs(d1 - d2) > d) {
p = l2.p1 + spin(v1, -90.0 * (3.141592653589793238 / 180.0));
}
res.push_back(Segment(p, p + v1));
} else {
Point p = getCrossPointLL(l1, l2);
Point v1 = l1.p2 - l1.p1, v2 = l2.p2 - l2.p1;
v1 = v1 / v1.abs();
v2 = v2 / v2.abs();
res.push_back(Segment(p, p + (v1 + v2)));
res.push_back(
Segment(p, p + spin(v1 + v2, 90.0 * (3.141592653589793238 / 180.0))));
}
return res;
}
double diameter(vector<Point> s) {
vector<Point> p = s;
long long n = p.size();
if (n == 2) return abs(p[0] - p[1]);
long long i = 0, j = 0;
for (long long k = 0; k < n; k++) {
if (p[i].x < p[k].x) i = k;
if (p[j].x > p[k].x) j = k;
}
double res = 0;
long long si = i, sj = j;
do {
res = max(res, abs(p[i] - p[j]));
if (cross(p[(i + i) % n] - p[i], p[(j + 1) % n] - p[j]) < 0.0) {
i = (i + 1) % n;
} else {
j = (j + 1) % n;
}
} while (i != si || j != sj);
return res;
}
signed main() {
long long n;
scanf("%lld", &n);
vector<Point> r(4);
scanf("%lf %lf", &(r[0].x), &(r[0].y));
scanf("%lf %lf", &(r[2].x), &(r[2].y));
r[1] = Point(r[2].x, r[0].y);
r[3] = Point(r[0].x, r[2].y);
Segment l[4];
l[0] = Segment(r[0], r[1]);
l[1] = Segment(r[1], r[2]);
l[2] = Segment(r[2], r[3]);
l[3] = Segment(r[3], r[0]);
vector<Point> p(n), v(n);
for (long long i = 0; i < n; i++) {
scanf("%lf %lf", &(p[i].x), &(p[i].y));
scanf("%lf %lf", &(v[i].x), &(v[i].y));
}
double INF = 1e8;
double L = 0, R = INF;
bool f = 1;
for (long long i = 0; i < n; i++) {
long long c = contains(r, p[i]);
if ((fabs((abs(v[i])) - (0)) < (1e-15))) {
if (c == 2) continue;
f = 0;
break;
}
Segment s = Segment(p[i], p[i] + v[i] * INF);
long long fs = 0, fp = 0;
for (long long j = 0; j < 4; j++) {
fs += intersect(s, l[j]);
fp += (fabs((getDistanceSP(s, r[j])) - (0.0)) < (1e-15));
}
if (c == 0) {
if ((fs == 0) || (fs == 2 && fp == 1) || (fs == 3 && fp == 2)) {
f = 0;
break;
}
}
if (c == 1) {
if ((fs == 2 && fp == 1) || (fs == 3 && fp == 2)) {
f = 0;
break;
}
}
double tL = INF, tR = 0;
if (c == 2) tL = 0;
for (long long j = 0; j < 4; j++) {
if (!intersect(s, l[j])) continue;
double xL = 0, xR = INF;
for (long long k = 0; k < 120; k++) {
double xM = (xL + xR) / 2;
Segment t = Segment(p[i], p[i] + v[i] * xM);
if (intersect(t, l[j]))
xR = xM;
else
xL = xM;
}
tL = min(tL, xR);
tR = max(tR, xR);
}
L = max(L, tL);
R = min(R, tR);
}
if (f && !(fabs((L) - (R)) < (1e-15)) && (L < R))
printf("%.20f\n", L);
else
cout << -1 << endl;
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int a, b;
char op;
for(;;){
cin >> a >> op >> b;
if(op == '+'){cout << a + b << endl;}
else if(op == '-') {cout << a - b << endl;}
else if(op == '*') {cout << a * b << endl;}
else if(op == '/') {cout << a / b << endl;}
else break;
}
}
| 0 |
#include <iostream>
using int64 = long long;
int main()
{
int64 n, d;
std::cin >> n >> d; n--;
int64 N = n - d + 1;
std::cout << (d == 1 ? n * (n + 1) / 2 : d + (N + 3) * N / 2 - 2) << std::endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long n;
int m;
scanf("%lld %d", &n, &m);
long long sum = 0;
vector<int> vec;
priority_queue<int> pq, pq2;
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
pq.push(x);
sum += x;
}
long long pq_sum = sum;
sum = 0;
if (pq_sum < n)
printf("-1\n");
else {
int res = 0;
while (sum < n) {
int x = pq.top();
pq.pop();
pq_sum -= x;
if (x == 0) break;
if (sum + x <= n)
sum += x;
else {
if (pq_sum + sum < n) {
pq_sum += x;
pq.push(x / 2);
pq.push(x / 2);
res++;
}
}
}
printf("%d\n", res);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, c;
long long int s, a, d, b;
cin >> n >> d;
long long int ara[n];
for (i = 0; i < n; i++) {
cin >> ara[i];
}
c = 2;
for (i = 0; i < n - 1; i++) {
a = ara[i + 1] - ara[i];
if (a > 2 * d)
c += 2;
else if (a == 2 * d)
c++;
}
cout << c << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, m, k, p = 1;
scanf("%d", &n);
m = n;
while (m != 0) {
if (m % 10 == 1) {
m = m / 10;
continue;
}
if (m % 100 == 14) {
m = m / 100;
continue;
}
if (m % 1000 == 144) {
m = m / 1000;
continue;
}
p = 0;
break;
}
if (p == 1)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include<iostream>
int main(){
int arr[1000001] = {0, 1, 1, 1, 1, 1};
for(int i=6;i<=1000000;i++){
if((i%2 == 0 && arr[i/2]) ||
(i%3 == 0 && arr[i/3]) ||
(i%5 == 0 && arr[i/5])){
arr[i] = 1;
}else{
arr[i] = 0;
}
}
int m, n;
while(std::cin >> m >> n, m){
int res = 0;
while(m <= n){
if(arr[m]){
res++;
}
m++;
}
std::cout << res << std::endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long kq = 0;
long long a, b;
int main() {
cin >> a >> b;
for (int k = 1; k <= a; k++) {
long long x = (1ll * k * b + 1) % 1000000007;
long long y = (1ll * (b - 1) * b / 2) % 1000000007;
kq = (kq + (x * y) % 1000000007) % 1000000007;
}
cout << kq % 1000000007;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
41, 43, 47, 53, 59, 61, 67, 71, 72, 79, 83, 89,
97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211};
map<int, int> mp;
vector<int> x;
void divisor() {
int i, lim = sqrt(n) + 1, cnt, m = n;
for (i = 0; i < 43 && prime[i] < lim; i++) {
if (m % prime[i] == 0) {
cnt = 0;
x.push_back(prime[i]);
while (m % prime[i] == 0) {
m /= prime[i];
cnt++;
}
mp[prime[i]] = cnt;
lim = sqrt(m) + 1;
}
}
if (m > 1) {
mp[m] = 1;
x.push_back(m);
}
}
vector<int> v;
void rec(int cur, int num) {
int i, lim;
if (cur == mp.size()) {
if (num < (n / 2)) v.push_back(num);
return;
}
lim = 1;
for (i = 0; i <= mp[x[cur]]; i++) {
rec(cur + 1, num * lim);
lim *= x[cur];
}
}
int main() {
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
divisor();
int sum = 0;
for (int i = 0; i < n; i++) sum += arr[i];
int mx = sum;
rec(0, 1);
for (int i = 2; i < (n / 2); i++) {
if (n % i == 0) {
for (int j = 0; j < i; j++) {
sum = 0;
for (int k = j; k < (n); k += i) {
sum += arr[k];
}
mx = max(sum, mx);
}
}
}
cout << mx << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int feet = n / 36, inch;
n = n % 36;
inch = n / 3;
n = n % 3;
if (n == 2) inch++;
if (inch >= 12) {
feet = feet + inch / 12;
inch = inch % 12;
}
printf("%d %d", feet, inch);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int arr[n], i, sum = 0, j, k, flag = 0;
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
for (i = 0; i < n; i++) {
sum = arr[i];
for (j = 0; j < n; j++) {
for (k = j + 1; k < n; k++) {
if (sum == arr[j] + arr[k] && i != j && flag == 0) {
printf("%d %d %d", i + 1, j + 1, k + 1);
flag = 1;
break;
}
}
if (flag == 1) break;
}
if (flag == 1) break;
}
if (flag == 0) printf("-1\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline long long ty() {
long long a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
map<long long, string> s;
inline string qry(long long x) {
if (!s.count(x)) return to_string(x);
return s[x];
}
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
long long n = ty();
for (long long i = 2; i * i <= n; i++) {
for (long long j = i * i, t = 2; j <= n; j *= i, t++) {
string temp = to_string(i) + "^" + to_string(t);
if (!s.count(j)) s[j] = to_string(j);
if (temp.size() < s[j].size()) s[j] = temp;
}
}
string ans = to_string(n);
for (auto i : s) {
string now = "";
long long tim = n / i.first, res = n % i.first;
if (tim > 1) now = qry(tim) + "*";
now = now + i.second;
if (res > 0) now = now + "+" + qry(res);
if (now.size() < ans.size()) ans = now;
}
cout << ans << lf;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long stoll(string target) {
stringstream s;
s << target;
long long w;
s >> w;
return w;
}
int stoi(string target) {
stringstream s;
s << target;
int w;
s >> w;
return w;
}
string itos(int i) {
stringstream s;
s << i;
return s.str();
}
string lltos(long long i) {
stringstream s;
s << i;
return s.str();
}
int main() {
ios::sync_with_stdio(false);
bool ok = true, final = false;
int i, j, k, n, m;
int t;
int br = 0, odgovor = 0, pom = 0, mom = 0, g = 0, f = 0, pamti = 0;
string a[101];
cin >> n;
for (i = 1; i <= (int)(n); i++) cin >> a[i];
odgovor = 2000000000;
for (i = 1; i <= (int)(n); i++) {
br = 0;
for (j = 1; j <= (int)(n); j++)
if (i != j) {
string x = a[j];
m = x.size();
while (x != a[i]) {
char c = x[0];
x.erase(0, 1);
x += c;
br++;
m--;
if (m == -2) {
cout << -1;
return 0;
}
}
}
odgovor = min(odgovor, br);
}
cout << odgovor;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 mt_rand(
chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 2e5 + 5, HS = 3, K = 10;
int n, m, k;
vector<pair<int, int> > g[N];
int mod[HS];
struct hash_number {
int a[HS];
hash_number() { fill(a, a + HS, 0); }
hash_number(long long x) {
for (int i = (0); i <= (HS - 1); ++i) a[i] = (x % mod[i] + mod[i]) % mod[i];
}
hash_number operator+(hash_number x) {
hash_number res;
for (int i = (0); i <= (HS - 1); ++i)
res.a[i] = (a[i] * 1ll + x.a[i]) % mod[i];
return res;
}
bool operator==(const hash_number& x) const {
for (int i = (0); i <= (HS - 1); ++i)
if (a[i] != x.a[i]) return 0;
return 1;
}
} val[N], c[K][K], s;
int ans;
int status[K];
void dfs(int x, hash_number hsh) {
if (x == k) {
if (hsh == s) ++ans;
return;
}
for (int i = (1); i <= (x + 1); ++i) {
status[x + 1] = i;
dfs(x + 1, hsh + c[x + 1][i]);
}
}
int main() {
mod[0] = 998244353;
mod[1] = 1e9 + 7;
mod[2] = std::uniform_int_distribution<int>(1e8, 1e9)(mt_rand);
fprintf(stderr, "%d %d %d\n", mod[0], mod[1], mod[2]);
scanf("%d%d%d", &n, &m, &k);
for (int i = (1); i <= (m); ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
g[u].push_back({w, v});
}
std::uniform_int_distribution<long long> rg(1, 1e18);
for (int i = (1); i <= (n); ++i) val[i] = hash_number(rg(mt_rand));
for (int i = (1); i <= (n); ++i) s = s + val[i];
for (int u = (1); u <= (n); ++u) {
int d = g[u].size();
sort(g[u].begin(), g[u].end());
for (int i = 1; i <= g[u].size(); i++) {
int v = g[u][i - 1].second;
c[d][i] = c[d][i] + val[v];
}
}
dfs(0, hash_number());
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e3;
int n, arr[maxN];
map<int, vector<pair<int, int> > > seg;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cin.tie(0), cout.tie(0),
cout.precision(15);
cin >> n;
for (int i = int(0); i < int(n); i++) cin >> arr[i];
for (int i = int(0); i < int(n); i++) {
int sum = 0;
for (int j = int(i); j >= int(0); j--) {
sum += arr[j];
seg[sum].push_back({j + 1, i + 1});
}
}
vector<pair<int, int> > ans;
for (auto it : seg) {
vector<pair<int, int> > curr = it.second;
vector<pair<int, int> > tt;
int r = -1;
for (auto i : curr) {
if (i.first > r) {
tt.push_back(i);
r = i.second;
}
}
if ((int)tt.size() > (int)ans.size()) ans = tt;
}
cout << (int)ans.size() << '\n';
for (auto it : ans) {
cout << it.first << " " << it.second << '\n';
}
return 0;
}
| 6 |
#include <iostream>
#define MAX(a,b) ((a>b)?(a):(b))
using namespace std;
int main(void){
int a,b;
int n;
int k[10];
int i;
cin>>n;
while(n--){
a=b=-1;
for(i=0;i<10;i++) cin>>k[i];
for(i=0;i<10;i++){
if(a>k[i]&&b>k[i])break;
if(k[i]>a&&k[i]>b){
if(a>b)a=k[i];
else b=k[i];
}else if(k[i]>a)a=k[i];
else if(k[i]>b)b=k[i];
}
if(i==10)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[256];
int main() {
string s1, s2;
getline(cin, s1);
getline(cin, s2);
bool bol = true;
for (int i = 0; i < s1.size(); i++) arr[s1[i]]++;
for (int i = 0; i < s2.size() && bol; i++)
if (s2[i] != ' ') {
if (!arr[s2[i]]--) bol = false;
}
if (bol)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, curr_ans = 0, c = 0;
cin >> n;
int arr[n], i;
for (i = 0; i < n; i++) cin >> arr[i];
int m, j;
cin >> m;
int arr2[m];
for (i = 0; i < m; i++) cin >> arr2[i];
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (arr2[i] % arr[j] == 0) {
curr_ans = arr2[i] / arr[j];
if (curr_ans == ans) {
c++;
} else if (curr_ans > ans) {
ans = curr_ans;
c = 1;
}
}
}
}
cout << c;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << "square1001" << endl;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
int main(){
int K;
cin>>K;
cout<<((K+1)/2)*(K/2)<<endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
typedef pair<ll,pll> plp;
int main(){
ll inf=1000000000000000000;
ll n,m,s,t;cin>>n>>m>>s>>t;
ll u[m],v[m],a[m],b[m];
vector<plp> h[n+1];
for(ll i=0;i<m;i++){
cin>>u[i]>>v[i]>>a[i]>>b[i];
h[u[i]].push_back(make_pair(v[i],make_pair(a[i],b[i])));
h[v[i]].push_back(make_pair(u[i],make_pair(a[i],b[i])));
}
ll ds[n+1],dt[n+1];
fill(ds,ds+n+1,inf);
fill(dt,dt+n+1,inf);
priority_queue<pll,vector<pll>,greater<pll>>qs,qt;
qs.push(make_pair((ll)0,s));
ds[s]=0;
while(qs.size()>0){
pll p=qs.top();qs.pop();
ll pf=p.first,ps=p.second;
for(ll i=0;i<h[ps].size();i++){
plp hi=h[ps][i];
ll ht=hi.first,he=hi.second.first;
if(ds[ht]>pf+he){
ds[ht]=pf+he;
qs.push(make_pair(ds[ht],ht));
}
}
}
qt.push(make_pair((ll)0,t));
dt[t]=0;
while(qt.size()>0){
pll p=qt.top();qt.pop();
ll pf=p.first,ps=p.second;
for(ll i=0;i<h[ps].size();i++){
plp hi=h[ps][i];
ll ht=hi.first,hs=hi.second.second;
if(dt[ht]>pf+hs){
dt[ht]=pf+hs;
qt.push(make_pair(dt[ht],ht));
}
}
}
vector<ll>vv(n+1);
ll mi=inf;
for(ll i=n;i>0;i--){
mi=min(mi,ds[i]+dt[i]);
vv[i]=mi;
}
for(ll i=1;i<=n;i++)cout<<1000000000000000-vv[i]<<endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
char s[200000+7];
long long mp[200000+7];
int main(){
long long n,p;
cin>>n>>p;
cin>>s+1;
if(p==2||p==5){
long long ans=0;
for(long long i=n;i>=1;i--){
if((s[i]-'0')%p==0){
ans+=i;
}
}
cout<<ans<<endl;
return 0;
}
long long ans=0;
long long t=1,tmp=0;
mp[0]++;
for(int i=n;i>=1;i--){
tmp=(tmp+(s[i]-'0')*t)%p;
mp[tmp]++;
t=t*10%p;
}
for(int i=0;i<=p;i++) {
ans+=(mp[i]-1)*(mp[i])/2;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define IFOR(i, m, n) for (ll i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FOREACH(x, a) for (auto&(x) : (a))
#define ALL(v) (v).begin(), (v).end()
#define SZ(x) ll(x.size())
int main() {
ll n, k;
cin >> n >> k;
vector<ll> a(n), b(n);
REP(i, n) { cin >> a[i] >> b[i]; }
vector<ll> ks;
ks.push_back(k);
ll t = k;
// number of digits(bit)
ll d = 30;
REP(i, d) {
if (((1LL << i) & k)) {
t -= (1LL << i);
ks.push_back(t);
}
t += (1LL << i);
}
ll ans = 0;
for (ll t : ks) {
ll s = 0;
REP(i, n) {
bool ok = true;
REP(j, d) {
ll r = (1LL << j) & t;
ll l = (1LL << j) & a[i];
if (l > r) {
ok = false;
break;
}
}
if (ok) {
s += b[i];
}
}
ans = max(ans, s);
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, l, r;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &n, &l, &r);
int k = n / l;
if (1LL * r * k >= n)
puts("Yes");
else
puts("No");
}
return 0;
}
| 2 |
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<cmath>
#include<stack>
#include<algorithm>
#define rg register
#define ll long long
#define LDB long double
#define ull unsigned long long
#define view(i,x) for(rg int i=hd[x];i!=-1;i=e[i].nt)
#define go(i,x,a) for(rg int i=a;i<x;i++)
#define inf 0x3f3f3f3f
#define INF 0x7fffffff
#define mod 1000000007
using namespace std;
const int maxn=1e6+5;
int n;
ll inv[maxn],ip[maxn];
inline int rd(){
int ret=0,af=1; char gc=getchar();
while(gc < '0' || gc > '9'){ if(gc=='-') af=-af; gc=getchar(); }
while(gc >= '0' && gc <= '9') ret=ret*10+gc-'0',gc=getchar();
return ret*af;
}
inline ll qpow(int x,int k){
ll ss=1,tmp=x;
while(k > 0){
if(k & 1) ss=ss*tmp%mod;
tmp=tmp*tmp%mod;
k>>=1;
}
return ss;
}
void pre(){
inv[0]=inv[1]=1;
go(i,n+1,2) inv[i]=(-1ll*(mod/i)*inv[mod%i]%mod+mod)%mod;
ip[0]=1; ip[1]=qpow(3,mod-2);
go(i,n+1,2) ip[i]=ip[i-1]*ip[1]%mod;
}
inline void add(ll &a,ll b){ a=a+b; if(a >= mod) a-=mod; return ; }
int main(){
#ifndef ONLINE_JUDGE
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
#endif
n=rd(); pre();
ll ans=0;
go(i,n+1,1)
add(ans,ip[i]*inv[n]%mod*inv[n-i+1]%mod);
printf("%lld",ans);
return 0;
}//Faze
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 1000005;
const double PI = 4 * atan(1);
const double eps = 1e-7;
const long long oo = 1e18;
long double a, b, x;
int main() {
cin >> a >> b;
long double ans = 1e18;
long long k = (long long)((a - b) / (2 * b));
if (k != 0) ans = (ans < (a - b) / (2 * k) ? ans : (a - b) / (2 * k));
k = -1 + (long long)((a + b) / (2 * b));
if (k != -1)
ans = (ans < (a + b) / (2 * k + 2) ? ans : (a + b) / (2 * k + 2));
if (ans == 1e18)
cout << -1;
else
printf("%.12Lf", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string a, b;
while (cin >> a >> b) {
if (a == b) {
cout << a << endl;
} else {
cout << 1 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100 + 10], b[100 + 10];
int main() {
long long n, m, f;
cin >> n;
m = n;
f = m;
for (int i = 0; i <= 10; i++) {
if (m % 10 == 0) break;
m++;
}
f /= 10;
f *= 10;
if (n - f > m - n)
cout << m;
else
cout << f;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void base() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
int n, n1, n2;
cin >> n >> n1 >> n2;
priority_queue<double> pq;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
pq.push(x);
}
if (n1 > n2) swap(n1, n2);
double s1 = 0, s2 = 0;
for (int i = 0; i < n1; ++i) {
s1 += pq.top();
pq.pop();
}
for (int i = 0; i < n2; ++i) {
s2 += pq.top();
pq.pop();
}
cout << fixed << setprecision(12) << s1 / n1 + s2 / n2 << "\n";
}
int main() {
base();
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int max(const int &a, const int &b) { return a > b ? a : b; }
const int N = 2e5 + 13;
int n, q;
char s[N];
struct SegTree {
int l, r, apb, amb, dpc, dmc, lbc, rbc, res;
} t[N << 2];
inline void refresh(int p) {
if (t[p << 1].lbc < t[p << 1 | 1].rbc)
t[p].lbc = t[p << 1 | 1].lbc,
t[p].rbc = t[p << 1].rbc + t[p << 1 | 1].rbc - t[p << 1].lbc;
else
t[p].lbc = t[p << 1 | 1].lbc + t[p << 1].lbc - t[p << 1 | 1].rbc,
t[p].rbc = t[p << 1].rbc;
t[p].apb = max(t[p << 1 | 1].apb,
max(t[p << 1].apb - t[p << 1 | 1].rbc + t[p << 1 | 1].lbc,
t[p << 1].amb + t[p << 1 | 1].rbc + t[p << 1 | 1].lbc));
t[p].amb = max(t[p << 1 | 1].amb,
t[p << 1].amb + t[p << 1 | 1].rbc - t[p << 1 | 1].lbc);
t[p].dmc =
max(t[p << 1].dmc, t[p << 1 | 1].dmc + t[p << 1].lbc - t[p << 1].rbc);
t[p].dpc = max(t[p << 1].dpc,
max(t[p << 1 | 1].dpc - t[p << 1].lbc + t[p << 1].rbc,
t[p << 1 | 1].dmc + t[p << 1].lbc + t[p << 1].rbc));
t[p].res = max(
max(t[p << 1].apb + t[p << 1 | 1].dmc, t[p << 1].amb + t[p << 1 | 1].dpc),
max(t[p << 1].res, t[p << 1 | 1].res));
}
void build(int p, int l, int r) {
t[p].l = l, t[p].r = r;
if (l == r) {
int k = (s[l] == '(' ? 1 : -1);
t[p].apb = t[p].dpc = 1;
t[p].amb = max(-k, 0);
t[p].dmc = max(k, 0);
t[p].lbc = (k == 1), t[p].rbc = (k == -1);
t[p].res = 1;
return;
}
build(p << 1, l, ((t[p].l + t[p].r) >> 1)),
build(p << 1 | 1, ((t[p].l + t[p].r) >> 1) + 1, r);
refresh(p);
}
void update(int p, int x, int k) {
if (t[p].l == t[p].r) {
t[p].apb = t[p].dpc = 1;
t[p].amb = max(-k, 0);
t[p].dmc = max(k, 0);
t[p].lbc = (k == 1), t[p].rbc = (k == -1);
t[p].res = 1;
return;
}
update(x <= ((t[p].l + t[p].r) >> 1) ? p << 1 : p << 1 | 1, x, k);
refresh(p);
}
inline void solve() {
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
build(1, 1, 2 * n - 2);
printf("%d\n", t[1].res);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (s[x] != s[y]) {
swap(s[x], s[y]);
update(1, x, s[x] == '(' ? 1 : -1), update(1, y, s[y] == '(' ? 1 : -1);
}
printf("%d\n", t[1].res);
}
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, long long> mp;
int main() {
long long n, p, k;
cin >> n >> p >> k;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
mp[(((x * x % p) * (x * x % p) - k * x % p) % p + p) % p]++;
}
long long ans = 0;
for (auto it = mp.begin(); it != mp.end(); it++) {
ans += (it->second - 1ll) * (it->second) / 2;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long A, B;
scanf("%lld %lld", &A, &B);
long long X = (A - B) / 2;
long long Y = X + B;
if (2 * X + B != A)
printf("-1");
else
printf("%lld %lld", X, Y);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int size(const T &x) {
return x.size();
}
const int INF = ~(1 << 31);
const double EPS = 1e-9;
const double pi = acos(-1);
template <class T>
T smod(T a, T b) {
return (a % b + b) % b;
}
int brute(vector<int> &perm) {
int best = -1, bestval = -1;
for (__typeof(0) i = (0); i < (size(perm)); ++i) {
int mx = -1;
int cnt = 0;
for (__typeof(0) j = (0); j < (size(perm)); ++j) {
if (i == j) continue;
if (perm[j] > mx) {
cnt++;
mx = perm[j];
}
}
if (cnt > best) {
bestval = perm[i];
best = cnt;
} else if (cnt == best && perm[i] < bestval) {
bestval = perm[i];
}
}
return bestval;
}
int main() {
int n;
scanf("%d", &n);
vector<int> perm(n);
for (__typeof(0) i = (0); i < (n); ++i) {
scanf("%d", &perm[i]);
perm[i]--;
}
vector<int> big(n), fails;
int firsthigh = -1, secondhigh = -1;
for (__typeof(0) i = (0); i < (n); ++i) {
if (firsthigh > perm[i] && secondhigh > perm[i]) {
fails.push_back(perm[i]);
}
if (firsthigh > perm[i] && perm[i] > secondhigh) {
fails.push_back(perm[i]);
big[firsthigh]++;
}
if (perm[i] > firsthigh) {
secondhigh = firsthigh;
firsthigh = perm[i];
} else if (perm[i] > secondhigh) {
secondhigh = perm[i];
}
}
int mx = 0, mxel = -1;
for (__typeof(0) i = (0); i < (n); ++i) {
if (big[i] > mx) {
mxel = i;
mx = big[i];
}
}
if (mx <= 1 && size(fails)) {
sort(fails.begin(), fails.end());
mxel = fails[0];
}
if (mxel < 0) mxel = 0;
cout << mxel + 1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1005;
const int Maxm = 200005;
int n, m, q;
int dist[Maxn][Maxn];
int a[Maxm], b[Maxm];
int l[Maxm], r[Maxm], s[Maxm], t[Maxm];
vector<int> has[Maxm];
bool res[Maxm];
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dist[i][j] = (i != j) * Maxm;
for (int i = 1; i <= m; i++) scanf("%d %d", &a[i], &b[i]);
for (int i = 0; i < q; i++) {
scanf("%d %d %d %d", &l[i], &r[i], &s[i], &t[i]);
has[l[i]].push_back(i);
}
for (int i = m; i >= 1; i--) {
dist[b[i]][a[i]] = i;
dist[a[i]][b[i]] = i;
for (int j = 1; j <= n; j++)
if (j != a[i] && j != b[i])
if (dist[a[i]][j] < dist[b[i]][j])
dist[b[i]][j] = dist[a[i]][j];
else
dist[a[i]][j] = dist[b[i]][j];
for (int j = 0; j < has[i].size(); j++) {
int ind = has[i][j];
res[ind] = dist[s[ind]][t[ind]] <= r[ind];
}
}
for (int i = 0; i < q; i++) printf("%s\n", res[i] ? "Yes" : "No");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c;
cin >> a >> b >> c;
int ans = -1;
int d = abs(a - b);
int len = 2 * d;
if (a == b or b == c or c == a)
ans = -1;
else if (a == b + 1 || b == a + 1)
ans = -1;
else {
if (a > len or b > len or c > len)
ans = -1;
else {
int t1 = c + d;
int t2 = c - d;
if (t1 >= 1 and t1 <= len)
ans = t1;
else if (t2 >= 1 and t2 <= len)
ans = t2;
else
ans = -1;
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
int i, temp;
cin >> n >> q;
int a[n + 1];
int b[40] = {0};
int count;
for (i = 0; i < n; i++) {
cin >> a[i];
temp = a[i];
count = 0;
while (temp != 0) {
temp /= 2;
count++;
}
b[count - 1]++;
}
int x;
while (q--) {
cin >> x;
count = 0;
for (i = 30; i >= 0; i--) {
temp = min(x >> i, b[i]);
x -= temp * (1 << i);
count += temp;
if (x == 0) break;
}
if (x == 0)
cout << count;
else
cout << -1;
cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
template <typename T>
inline T SQR(T a) {
return a * a;
}
template <typename T>
struct InfP {
operator T() const {
return std::numeric_limits<T>::has_infinity
? std::numeric_limits<T>::infinity()
: std::numeric_limits<T>::max();
}
};
struct Infinity : InfP<int>,
InfP<long long>,
InfP<double>,
InfP<long double>,
InfP<char>,
InfP<unsigned long long>,
InfP<unsigned int>,
InfP<float> {
} INF;
const double PI = 2 * asin(1.0);
void solve();
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
solve();
return 0;
}
const double eps = 1e-6;
const int maxn = 1e5 + 100;
int a[maxn], b[maxn], c[maxn];
int n;
struct Cmp {
bool operator()(const pair<int, int> &l, const pair<int, int> &r) const {
return l.first == r.first ? l.second < r.second : l.first > r.first;
}
};
set<int> ans;
bool ch = false;
void p1() {
set<pair<int, int> > Set;
int diff = 0;
for (int i = 0; i < (int)(n); ++i) {
diff += a[i] - b[i];
Set.insert(make_pair(diff, i));
}
long long koef = 0;
for (int i = 0; i < (int)(n); ++i) {
while (Set.begin()->second < i) {
Set.erase(Set.begin());
}
if (Set.begin()->first + koef >= 0) {
if (!ch) {
ans.insert(i + 1);
} else {
ans.insert(n - i);
}
}
koef -= a[i] - b[i];
diff += a[(i + n) % n] - b[(i + n) % n];
Set.insert(make_pair(-koef, i + n));
}
}
void solve() {
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < (int)(n); ++i) {
scanf("%d", &b[i]);
}
p1();
for (int i = 0; i < (int)(n / 2); ++i) {
swap(a[i], a[n - i - 1]);
swap(b[i], b[n - i - 1]);
}
for (int i = 0; i < (int)(n); ++i) {
c[(i - 1 + n) % n] = b[i];
}
memcpy(b, c, sizeof(b));
ch = true;
p1();
cout << ans.size() << endl;
for (set<int>::iterator it = ans.begin(); it != ans.end(); ++it) {
cout << *it << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, diff, taken, money, energy;
cin >> n;
int blocks[100020];
blocks[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> blocks[i];
}
money = energy = 0;
for (int i = 0; i < n; i++) {
if (blocks[i] >= blocks[i + 1])
energy += blocks[i] - blocks[i + 1];
else {
diff = blocks[i + 1] - blocks[i];
taken = min(energy, diff);
energy -= taken;
money += diff - taken;
}
}
cout << money << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s = "";
for (int i = 1; i <= n; i++) {
stringstream ss;
ss << i;
string s1 = ss.str();
s += s1;
}
cout << s[n - 1];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int Q;
int A,B,C,D;
string hoge(int A,int B,int C,int D) {
int i;
int L=(max(A,B)+min(A,B))/(min(A,B)+1);
int na=0;
for(i=30;i>=0;i--) {
int nac=na+(1<<i);
int nb=max(0,(nac-1)/L);
if(nac>A || nb>B) continue;
int ma=A-nac;
int mb=B-nb;
if(mb>1LL*(ma+1)*L) continue;
na+=1<<i;
}
int p=na+max(0,(na-1)/L);
string R;
for(i=C;i<=D;i++) {
if(i<p) R+='A'+(i%(L+1)==L);
else R+='B'-((A+B-1-i)%(L+1)==L);
}
//cout<<p<<" "<<A<<" "<<B<<" ";
return R;
}
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>Q;
//Q=400;
FOR(i,Q) {
cin>>A>>B>>C>>D;
/*
A=1+i/20;
B=1+i%20;
C=1;
D=A+B;
*/
cout<<hoge(A,B,C-1,D-1)<<endl;
}
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long l, r;
long long lky[2048];
int ct;
void rec(long long pv, long long tt) {
if (pv > 1e9) return;
lky[ct++] = tt + pv * 4;
rec(pv * 10, lky[ct - 1]);
lky[ct++] = tt + pv * 7;
rec(pv * 10, lky[ct - 1]);
}
int main(int argc, char **argv) {
cin.tie(NULL);
ios_base::sync_with_stdio(0);
cin >> l >> r;
rec(1, 0);
sort(lky, lky + ct);
long long sum = 0;
for (int(i) = (0); (i) <= (ct - 1); ++(i)) {
if (lky[i] < l)
continue;
else if (lky[i] <= r) {
if (i == 0 || lky[i - 1] < l)
sum += lky[i] * (lky[i] - l + 1);
else
sum += lky[i] * (lky[i] - lky[i - 1]);
} else {
if (i == 0 || lky[i - 1] < l)
sum += lky[i] * (r - l + 1);
else
sum += lky[i] * (r - lky[i - 1]);
}
if (lky[i] >= r) break;
}
cout << sum << endl;
return 0;
}
| 3 |
#include<cstdio>
using namespace std;
int N,A[200005],a[200005],l=1,r=200000,mid;
bool check(int n)
{
int re=-1;
for(int i=1;i<=N*2-1;i++)
if(A[i]>=n)
a[i]=1;
else
a[i]=0;
for(int i=1;i<=N-1;i++)
{
if(a[N+i]==a[N+i-1])
{
re=a[N+i];
break;
}
if(a[N-i]==a[N-i+1])
{
re=a[N-i];
break;
}
}
if(re!=-1)
return re;
else
return a[1];
}
int main()
{
scanf("%d",&N);
for(int i=1;i<=N*2-1;i++)
scanf("%d",&A[i]);
while(l+1<r)
{
mid=(l+r)/2;
if(check(mid))
l=mid;
else
r=mid;
}
printf("%d",l);
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main() {
int N, X;
cin >> N >> X;
int n = 0, cnt = 1;
for(int i = 0; i < N; i++) {
int L;
cin >> L;
n += L;
if(n <= X) cnt++;
}
cout << cnt << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxp = 1000100;
const int mod = 1000000007;
int v[maxp];
int main() {
int p, k, res = 1;
scanf("%d%d", &p, &k);
if (k == 1) {
for (int i = (0); i <= (int(p) - 1); ++i) res = 1LL * res * p % mod;
printf("%d\n", res);
return 0;
}
for (int i = (1); i <= (p - 1); ++i)
if (!v[i]) {
res = 1LL * res * p % mod;
int cur = i;
while (!v[cur]) {
v[cur] = 1;
cur = 1LL * cur * k % p;
}
}
printf("%d\n", res);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
scanf("%d", &n);
long a[n];
long long s = 0, ss = 0;
for (int i = 0; i < n; i++) {
scanf("%ld", &a[i]);
s += a[i];
}
if (s % 3 != 0) {
printf("0\n");
return 0;
}
s = s / 3;
vector<int> sum1;
vector<int> sum2;
for (int i = 0; i < n - 1; i++) {
ss += a[i];
if (ss == s) sum1.push_back(i);
if (ss == 2 * s) sum2.push_back(i);
}
long long ans = 0;
for (int i = 0; i < sum1.size(); i++) {
ans += sum2.end() - lower_bound(sum2.begin(), sum2.end(), sum1[i] + 1);
}
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long N = 20005;
const long long NN = 105;
const long long INF = 1000000000000000000;
const long long MOD = 1000000007;
const long long M0D = 998244353;
const long double PI = acos((long double)-1);
const long long P = 53;
using namespace std;
void ma1n() {
string s;
cin >> s;
if (s.find('1') == string::npos || s.find('2') == string::npos ||
s.find('3') == string::npos) {
cout << 0 << endl;
return;
} else {
map<char, long long> mp;
long long j = 0;
long long ans = ((long long)(s).size());
for (long long i = 0; i < ((long long)(s).size()); ++i) {
mp[s[i]]++;
while (mp[s[j]] > 1) {
mp[s[j]]--;
j++;
}
if (((long long)(mp).size()) == 3) {
ans = min(ans, i - j + 1);
}
}
cout << ans << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long ttt = 1;
cin >> ttt;
while (ttt--) {
ma1n();
}
return 0;
}
| 2 |
#include <cstdio>
using namespace std;
const int N=2010;
const int INF=1e9;
int n;
int p[2][N];
int preSum[2][N][N*2];
inline void updateMin(int &x,int y){
x=(y<x)?y:x;
}
void readData(){
scanf("%d",&n);
static char str[5];
int x;
for(int i=1;i<=n*2;i++){
scanf("%s%d",str,&x);
p[str[0]=='W'][x]=i;
}
}
void initPrefix(){
for(int k=0;k<2;k++){
for(int j=n;j>=1;j--){
for(int i=1;i<=n*2;i++){
preSum[k][j][i]=preSum[k][j+1][i];
if(i>=p[k][j])
preSum[k][j][i]++;
}
}
}
}
int f[N][N];
void dp(){
for(int a=0;a<=n;a++)
for(int b=0;b<=n;b++)
f[a][b]=INF;
f[0][0]=0;
for(int i=0;i<2*n;i++){
for(int a=0,b;a<=i;a++){
b=i-a;
if(a<=n&&b<=n){
if(a<n) // fill a+1
updateMin(f[a+1][b],f[a][b]+preSum[0][a+2][p[0][a+1]-1]+preSum[1][b+1][p[0][a+1]-1]);
if(b<n) // fill b+1
updateMin(f[a][b+1],f[a][b]+preSum[0][a+1][p[1][b+1]-1]+preSum[1][b+2][p[1][b+1]-1]);
}
}
}
printf("%d\n",f[n][n]);
}
int main(){
readData();
initPrefix();
dp();
return 0;
}
| 0 |
// warm heart, wagging tail,and a smile just for you!
// ███████████
// ███╬╬╬╬╬╬╬╬╬╬███
// ███╬╬╬╬╬████╬╬╬╬╬╬███
// ███████████ ██╬╬╬╬╬████╬╬████╬╬╬╬╬██
// █████████╬╬╬╬╬████████████╬╬╬╬╬██╬╬╬╬╬╬███╬╬╬╬╬██
// ████████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████████╬╬╬╬╬╬██╬╬╬╬╬╬╬██
// ████╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████████╬╬╬╬╬╬╬╬╬╬╬██
// ███╬╬╬█╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬███╬╬╬╬╬╬╬█████
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬████████╬╬╬╬╬██
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬╬╬╬╬╬╬╬███
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬██
// ████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████╬╬╬╬╬████
// █████████████╬╬╬╬╬╬╬╬██╬╬╬╬╬████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬╬╬██████
// ████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬██████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██████╬╬╬╬╬╬╬███████████╬╬╬╬╬╬╬╬██╬╬╬██╬╬╬██
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████╬╬╬╬╬╬╬╬╬╬╬█╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬██
// ██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬▓▓▓▓▓▓╬╬╬████╬╬████╬╬╬╬╬╬╬▓▓▓▓▓▓▓▓██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬███
// ██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██████▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓▓▓▓▓██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██╬╬╬╬█████
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████████
// ███╬╬╬╬╬╬╬╬╬╬╬╬╬█████╬╬╬╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬███╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██
// ██████████████ ████╬╬╬╬╬╬███████████████████████████╬╬╬╬╬██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬████
// ███████ █████ ███████████████████
#include "bits/stdc++.h"
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
const double EPS = 1e-9;
#define INF (1LL<<60)
#define D double
#define fs first
#define sc second
#define int long long
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define RFOR(i,a,b) for(int i = (b-1);i>=(a);--i)
#define REP(i,n) FOR(i,0,(n))
#define RREP(i,n) RFOR(i,0,(n))
#define ITR(itr,mp) for(auto itr = (mp).begin(); itr != (mp).end(); ++itr)
#define RITR(itr,mp) for(auto itr = (mp).rbegin(); itr != (mp).rend(); ++itr)
#define range(i,a,b) ((a)<=(i) && (i)<(b))
#define debug(x) cout << #x << " = " << (x) << endl;
#define SP << " " <<
typedef pair<int,int> P;
typedef vector<int> vec;
typedef vector<vector<int>> mat;
vector<int> divisor(const int n){
vector<int> ret;
for(int i=1;i*i<=n;i++){
if(n % i == 0){
ret.push_back(i);
if(i*i!= n) ret.push_back(n/i);
}
}
sort(ret.begin(),ret.end());
return ret;
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> q;
vec sum(1e5+10,0);
FOR(i,2,1e5+10){
vec tmp = divisor(i);
int cur = 1;
RREP(j,tmp.size()-1){
cur *= tmp[j];
if(cur >= i*2){
sum[i]++; break;
}
}
}
REP(i,1e5+5) sum[i+1] += sum[i];
REP(i,q){
int n;
cin >> n;
cout << sum[n] << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool checkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool checkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int MAXN = 100000 + 10;
struct Node {
int id;
long long val;
bool operator<(const Node &A) const {
if (val == A.val) {
return id < A.id;
}
return val < A.val;
}
void input(const int &i) {
scanf("%I64d", &val);
id = i + 1;
}
} arr[MAXN], tmp[MAXN];
vector<int> vec[2];
int main() {
int N;
long long K;
while (scanf("%d%I64d", &N, &K) == 2) {
long long sum = 0;
for (int i = 0; i < N; i++) {
arr[i].input(i);
tmp[i] = arr[i];
sum += arr[i].val;
}
if (sum <= K) {
if (sum < K) {
printf("-1\n");
} else {
printf("\n");
}
continue;
}
sort(tmp, tmp + N);
long long cir = 0, sz = N, used = 0, left;
for (int i = 0; i < N; i++) {
if (tmp[i].val <= cir) {
sz--;
continue;
} else {
long long k = tmp[i].val - cir;
if (k * sz + used <= K) {
used += k * sz;
cir = tmp[i].val;
sz--;
} else {
k = (K - used) / sz;
left = (K - used) % sz;
cir += k;
break;
}
}
}
vec[0].clear();
vec[1].clear();
int cnt = 0;
for (int i = 0; i < N; i++) {
if (cir + (cnt < left) >= arr[i].val) {
if (cir < arr[i].val) {
cnt++;
}
continue;
} else {
if (cnt < left) {
cnt++;
vec[1].push_back(arr[i].id);
} else {
vec[0].push_back(arr[i].id);
}
}
}
for (int i = 0; i < ((int)(vec[0].size())); i++) {
printf("%d ", vec[0][i]);
}
for (int i = 0; i < ((int)(vec[1].size())); i++) {
printf("%d ", vec[1][i]);
}
printf("\n");
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
bool isprime(long long int val) {
if (val <= 1)return false;
for (long long int i = 2; i*i <= val; i++) {
if (val%i == 0LL)return false;
}
return true;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
vector<int> db;
int n,p;
while(cin>>n>>p){
if(n==-1) break;
vector<int> v;
vector<int> ans;
for(int i=1;v.size()<=100;i++){
if(isprime(n+i)){
v.push_back(n+i);
}
}
int m = v.size();
for(int i=0;i<m;i++){
for(int j=i;j<m;j++){
ans.push_back(v[i]+v[j]);
}
}
sort(ans.begin(),ans.end());
cout << ans[p-1] << endl;
db.push_back(ans[p-1]);
}
//for(auto i:db) cerr<<i<<" ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[2];
int val[1000];
int main() {
val['Q'] = 9;
val['R'] = 5;
val['B'] = 3;
val['N'] = 3;
val['P'] = 1;
val['K'] = 0;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
char c;
cin >> c;
int k;
if (c >= 'a') {
k = 1;
c -= 32;
} else
k = 0;
a[k] += val[c];
}
if (a[0] == a[1])
cout << "Draw" << endl;
else if (a[0] > a[1])
cout << "White" << endl;
else
cout << "Black" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long m, b;
long long no_of_bananas_in_rectangle(long long x, long long y) {
long long ans = (x * (x + 1) / 2) * (y + 1) + (y * (y + 1) / 2) * (x + 1);
return ans;
}
int main() {
long long max = 0;
cin >> m >> b;
for (long long i = 0; i <= b; i++)
if (no_of_bananas_in_rectangle(m * (b - i), i) > max)
max = no_of_bananas_in_rectangle(m * (b - i), i);
cout << max << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long arrv[600000 + 10];
typedef long long arre[800000 + 10];
long long i, j, k, p, n, m, tot, ans;
arrv g, f, a;
arre pt, nt, w;
struct node {
long long x, y;
} q[600000 + 10];
void Link(long long x, long long y) {
pt[++tot] = y, nt[tot] = g[x], g[x] = tot, w[tot] = m + 1;
}
void Inc(long long x, long long p) {
if (x <= 0) return;
for (; x <= n; x += ((x) & (-x))) a[x] += p;
}
long long Sum(long long x) {
if (x < 0) return -a[0];
long long res = 0;
for (; x; x -= ((x) & (-x))) res += a[x];
return res;
}
bool cmp(node a, node b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
void Init() {
scanf(
"%I64d"
"%I64d"
"\n",
&n, &m);
for (i = 1; i <= n; ++i) {
scanf(
"%I64d"
"%I64d"
"\n",
&q[i].x, &q[i].y);
if (q[i].x > q[i].y) q[i].x ^= q[i].y, q[i].y ^= q[i].x, q[i].x ^= q[i].y;
}
sort(q + 1, q + n + 1, cmp);
for (i = 1; i <= n; ++i) {
bool flag = 0;
j = q[i].x, k = q[i].y;
for (p = g[j]; p; p = nt[p])
if (pt[p] == k + n) {
w[p]++, flag = 1;
break;
}
if (!flag) Link(j, k + n);
++f[j], ++f[k];
}
for (i = 1; i <= n; ++i)
if (!f[i])
a[0]++;
else
Inc(f[i], 1);
}
void Calc() {
if (!m) {
printf(
"%I64d"
"\n",
n * (n - 1) / 2);
return;
}
for (i = 1; i <= n; ++i)
if (f[i]) {
Inc(f[i], -1);
for (j = g[i]; j; j = nt[j]) {
if (f[i] + f[pt[j] - n] >= w[j]) ans++;
Inc(f[pt[j] - n], -1);
}
ans += Sum(n) - Sum(m - f[i] - 1);
for (j = g[i]; j; j = nt[j]) Inc(f[pt[j] - n], 1);
}
printf(
"%I64d"
"\n",
ans);
}
int main() {
Init();
Calc();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int v[7];
string s1, s2, s3;
long long int a1 = 0, a2 = 0, a3 = 0;
s1 = "1 2 4\n";
s2 = "1 2 6\n";
s3 = "1 3 6\n";
for (int i = 0; i < 7; i++) v[i] = 0;
long long int a;
cin >> a;
for (int i = 0; i < a; i++) {
int x;
cin >> x;
if (x == 0 || x == 5 || x == 7) {
cout << -1 << endl;
return 0;
}
v[x]++;
}
a3 = v[3];
v[6] -= v[3];
if (v[6] < 0) {
cout << -1 << endl;
return 0;
}
a1 = v[4];
v[2] -= v[4];
if (v[2] < 0) {
cout << -1 << endl;
return 0;
}
a2 = v[6];
if (v[6] != v[2]) {
cout << -1 << endl;
return 0;
}
if (a1 + a2 + a3 != v[1]) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < a1; i++) cout << s1;
for (int i = 0; i < a2; i++) cout << s2;
for (int i = 0; i < a3; i++) cout << s3;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
int n;
vector<ll> ans;
int SIZE;
ll calc(ll x,ll y,ll z,ll k){
ll res=0;
auto sum=[&](ll a,ll b,ll l,ll r){
l=max(l,0LL);
r=min(r,x+1);
if(a==1) l=max(l,-b);
if(a==-1) r=min(r,b+1);
if(l>=r) return 0LL;
return (l*a+b+a*(r-1)+b)*(r-l)/2;
};
res+=sum(1,y+z+1-k,0,k-z);
res+=sum(0,y+1,k-z,k-y);
res+=sum(-1,k+1,k-y,x+1);
return res;
}
void solve(int x,int y,int z,int buf){
if(y>z) swap(y,z);
for(int k=0;k<SIZE;k++){
ans[(k+buf)%n]+=calc(x,y,z,k);
}
}
int main(){
int x,y,z,a,b,c;
cin>>x>>y>>z>>a>>b>>c>>n;
x--,y--,z--;
SIZE=x+y+z+1;
ans.resize(n);
vector<int> xs={a,x-a-1};
vector<int> ys={b,y-b-1};
vector<int> zs={c,z-c-1};
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
for(int k=0;k<2;k++){
if(xs[i]<0) continue;
if(ys[j]<0) continue;
if(zs[k]<0) continue;
solve(xs[i],ys[j],zs[k],i+j+k);
}
}
}
for(int i=0;i<n;i++){
cout<<ans[i]<<(i+1==n ? "\n" : " ");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 600;
int n, m, b, mod, a[Maxn];
long long d[3][Maxn][Maxn];
void input() {
cin >> n >> m >> b >> mod;
for (int i = 0; i < n; i++) cin >> a[i];
}
void solve() {
for (int k = 1; k < n + 1; k++)
for (int g = 0; g < b + 1; g++) d[0][k][g] = 1 % mod;
for (int l = 1; l < m + 1; l++)
for (int k = 1; k < n + 1; k++)
for (int g = 0; g < b + 1; g++) {
d[l % 2][k][g] = d[l % 2][k - 1][g];
if (g >= a[k - 1])
d[l % 2][k][g] =
(d[l % 2][k][g] + d[(l - 1) % 2][k][g - a[k - 1]]) % mod;
}
}
int main() {
input();
solve();
cout << d[m % 2][n][b] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef complex<double> P;
typedef pair<int,int> pii;
#define REP(i,n) for(ll i=0;i<n;++i)
#define REPR(i,n) for(ll i=1;i<n;++i)
#define FOR(i,a,b) for(ll i=a;i<b;++i)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define MOD (ll)(1e9+7)
#define ADD(a,b) a=((a)+(b))%MOD
#define FIX(a) ((a)%MOD+MOD)%MOD
vi lnk[1024];
string res[1024];
void dfs(int p,int d){
cout<<string(d,'.')<<res[p]<<endl;
REP(i,lnk[p].size()){
dfs(lnk[p][i],d+1);
}
}
int main(){
int n;
cin>>n;
int root = 0;
REP(i,n){
int k;
string m;
cin>>k>>m;
res[i] = m;
--k;
if(k==-1)root=i;
else{
lnk[k].push_back(i);
}
}
dfs(root,0);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
long long ll[maxn], rr[maxn];
long long a[maxn << 2];
int w[maxn];
struct Seg {
int sum[maxn << 4];
int lazy[maxn << 4];
int lazy_r[maxn << 4];
inline void pushup(int rt) { sum[rt] = sum[rt << 1 | 1] + sum[rt << 1]; }
inline void pushdown(int rt, int len) {
if (lazy[rt] != -1) {
sum[rt << 1] = (len - (len >> 1)) * lazy[rt];
sum[rt << 1 | 1] = (len >> 1) * lazy[rt];
lazy[rt << 1] = lazy[rt << 1 | 1] = lazy[rt];
lazy_r[rt << 1 | 1] = lazy_r[rt << 1] = 0;
lazy[rt] = -1;
}
if (lazy_r[rt]) {
sum[rt << 1] = len - (len >> 1) - sum[rt << 1];
sum[rt << 1 | 1] = (len >> 1) - sum[rt << 1 | 1];
lazy_r[rt << 1] = 1 - lazy_r[rt << 1];
lazy_r[rt << 1 | 1] = 1 - lazy_r[rt << 1 | 1];
lazy_r[rt] = 0;
}
}
void build(int l, int r, int rt) {
lazy[rt] = -1;
lazy_r[rt] = 0;
if (l == r) {
sum[rt] = 0;
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt);
}
void updata(int L, int R, int val, int l, int r, int rt) {
if (L <= l && r <= R) {
sum[rt] = (r - l + 1) * val;
lazy[rt] = val;
lazy_r[rt] = 0;
return;
}
pushdown(rt, r - l + 1);
int m = (l + r) >> 1;
if (m >= L) updata(L, R, val, l, m, rt << 1);
if (R > m) updata(L, R, val, m + 1, r, rt << 1 | 1);
pushup(rt);
}
void updata_r(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
sum[rt] = (r - l + 1) - sum[rt];
lazy_r[rt] = 1 - lazy_r[rt];
return;
}
pushdown(rt, r - l + 1);
int m = (l + r) >> 1;
if (m >= L) updata_r(L, R, l, m, rt << 1);
if (R > m) updata_r(L, R, m + 1, r, rt << 1 | 1);
pushup(rt);
}
long long query(int l, int r, int rt) {
if (l == r) {
return a[l - 1];
}
int len = r - l + 1;
pushdown(rt, len);
int m = (l + r) >> 1;
if (sum[rt << 1] < (len - len / 2))
return query(l, m, rt << 1);
else
return query(m + 1, r, rt << 1 | 1);
}
} seg;
int main() {
int n;
scanf("%d", &n);
int e = 0;
a[e++] = 1;
for (int i = 0; i < n; i++) {
scanf("%d%I64d%I64d", &w[i], &ll[i], &rr[i]);
a[e++] = ll[i];
a[e++] = rr[i];
}
sort(a, a + e);
int m = unique(a, a + e) - a;
int te = m;
for (int i = 1; i < te; i++) {
if (a[i - 1] + 1 != a[i]) a[m++] = a[i - 1] + 1;
}
sort(a, a + m);
a[m] = a[m - 1] + 1;
m++;
seg.build(1, m, 1);
int l, r;
for (int i = 0; i < n; i++) {
l = lower_bound(a, a + m, ll[i]) - a;
r = lower_bound(a, a + m, rr[i]) - a;
l++;
r++;
if (w[i] == 1)
seg.updata(l, r, 1, 1, m, 1);
else if (w[i] == 2)
seg.updata(l, r, 0, 1, m, 1);
else
seg.updata_r(l, r, 1, m, 1);
printf("%I64d\n", seg.query(1, m, 1));
}
}
| 6 |
#include<cstdio>
#include<algorithm>
using namespace std;
const int MOD=1e9+7;
int n,a=0,d=0,mmh=1;
int main(){
register int i;
scanf("%d",&n);
for (i=1;i<=n;i++){
d=max(d,i-1-(a+1)/2);
mmh=1LL*mmh*(i-d)%MOD;
scanf("%d",&a);
}
printf("%d\n",mmh);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0, i##_len = (n); i < i##_len; ++i)
int main() {
string s;
cin >> s;
int n = s.size(), u = 1, v = 1;
bool b = false;
rep(i, n / 2) if(s[i] != s[n - 2 - i]) b = true;
if(b || s[0] != '1' || s[n - 1] != '0') {
cout << -1 << endl;
return 0;
}
rep(i, n / 2 + 1) s[n / 2 + 1 + i] = '0';
reverse(begin(s), end(s));
rep(i, n - 1) {
v++;
cout << u << ' ' << v << '\n';
if(s[i + 1] == '1') u = v;
}
} | 0 |
#include <cstdio>
#define rep(i,n) for(int i=0; i<n; ++i)
int n,m,l;
int main(){
scanf("%d %d %d", &n,&m,&l);
int a[n][m];
rep(i,n){
rep(j,m){
scanf("%d", &a[i][j]);
}
}
int b[m][l];
rep(i,m){
rep(j,l){
scanf("%d", &b[i][j]);
}
}
int long long c[n][l];
rep(i,n){
rep(j,l){
int long long x=0;
rep(k,m){
x+=a[i][k]*b[k][j];
}
c[i][j]=x;
}
}
rep(i,n){
rep(j,l-1){
printf("%lld ", c[i][j]);
}
printf("%lld\n", c[i][l-1]);
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define N 3000
#define INF 0x3f3f3f3f3f3f3f3fLL
LL n,tot,ans,head[N],iter[N],level[N],q[N],a[N];
struct edge{LL v,cap,nxt;}e[N];
void add(LL x,LL y,LL z){
e[++tot].v=y; e[tot].cap=z; e[tot].nxt=head[x]; head[x]=tot;
e[++tot].v=x; e[tot].cap=0; e[tot].nxt=head[y]; head[y]=tot;
}
void bfs(LL s){
memset(level,-1,sizeof level);
LL tt=0,ww=1; q[1]=s; level[s]=0;
while (tt<ww){
LL u=q[++tt];
for (LL i=head[u],v;i;i=e[i].nxt)
if (e[i].cap>0&&level[v=e[i].v]<0){
level[v]=level[u]+1;
q[++ww]=v;
}
}
}
LL dfs(LL u,LL t,LL f){
if (u==t) return f;
for (LL &i=iter[u],v;i;i=e[i].nxt){
if (e[i].cap>0&&level[v=e[i].v]>level[u]){
LL d=dfs(v,t,min(f,e[i].cap));
if (d>0){e[i].cap-=d; e[i^1].cap+=d; return d;}
}
}
return 0;
}
LL dinic(LL s,LL t){
LL flow=0;
while (1){
bfs(s); if (level[t]<0) break;
for (LL i=0;i<=n+1;i++) iter[i]=head[i];
for (LL f=dfs(s,t,INF);f>0;f=dfs(s,t,INF)) flow+=f;
}
return flow;
}
int main(){
scanf("%lld",&n); tot=1;
for (LL i=1;i<=n;i++){
scanf("%lld",&a[i]);
if (a[i]>=0){add(0,i,a[i]); add(i,n+1,0); ans+=a[i];}
if (a[i]<0){add(0,i,0); add(i,n+1,-a[i]);}
for (LL j=2;j*i<=n;j++) add(j*i,i,INF);
}
ans-=dinic(0,n+1);
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(int k){
for(int i=2;i*i<=k;i++){
if(k%i==0)return false;
}
return true;
}
int main() {
long long x;
cin >> x;
for(int j=x;j<10000000;j++){
if(isprime(j)){cout <<j;
break;}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void amax(X& x, const Y& y) {
if (x < y) x = y;
}
template <class X, class Y>
void amin(X& x, const Y& y) {
if (x > y) x = y;
}
const int INF = 1e9 + 10;
const long long INFL = 1e18 + 10;
const int MAX = 110;
const int BASE = 1e9 + 7;
int n, k;
vector<int> es[MAX];
long long dp[MAX][50], ndp[50];
long long mul(long long a, long long b) { return (a * b) % BASE; }
template <class T>
void add(T& l, long long r) {
l = (l + r) % BASE;
}
void dfs(int u, int p) {
for (auto v : es[u])
if (v != p) dfs(v, u);
dp[u][0] = dp[u][k + 1] = 1;
for (auto v : es[u])
if (v != p) {
memset(ndp, 0, sizeof(ndp));
for (int i = 0; i <= 2 * k; i++)
for (int j = 0; j <= 2 * k; j++) {
long long t = mul(dp[u][i], dp[v][j]);
if (i <= k && j <= k) {
add(ndp[min(i, j + 1)], t);
} else if (i > k && j > k) {
add(ndp[max(i, j + 1)], t);
} else if (i <= k && j > k) {
if (j - k + i <= k)
add(ndp[i], t);
else
add(ndp[j + 1], t);
} else {
if (i - k + j <= k)
add(ndp[j + 1], t);
else
add(ndp[i], t);
}
}
for (int i = 0; i <= 2 * k; i++) dp[u][i] = ndp[i];
}
}
void process() {
cin >> n >> k;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
es[u].push_back(v);
es[v].push_back(u);
}
dfs(1, 0);
long long res = 0;
for (int i = 0; i <= k; i++) add(res, dp[1][i]);
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
process();
}
| 3 |
#include "bits/stdc++.h"
using namespace std;
int main() {
long long A, B;
cin >> A >> B;
cout << (A ^ B) << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[1000002];
char actual[1000002];
struct node {
int mini, maxi, lazy;
node() : mini(0), maxi(0), lazy(0) {}
node operator+(const node &p) const {
node ret;
ret.mini = min(mini, p.mini);
ret.maxi = max(maxi, p.maxi);
ret.lazy = 0;
return ret;
}
void a(int add) {
mini += add;
maxi += add;
lazy += add;
}
} seg[1 << 21];
void upd(int i, int tl, int tr, int l, int r, int add) {
if (tr < l or r < tl) return;
if (l <= tl and r >= tr) {
seg[i].a(add);
return;
}
int tm = (tl + tr) >> 1;
seg[i << 1].a(seg[i].lazy);
seg[i << 1 | 1].a(seg[i].lazy);
upd(i << 1, tl, tm, l, r, add);
upd(i << 1 | 1, tm + 1, tr, l, r, add);
seg[i] = seg[i << 1] + seg[i << 1 | 1];
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n;
scanf("%d\n", &n);
scanf("%s", s);
int pos, tot;
pos = 1;
tot = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'L')
pos = max(pos - 1, 1);
else if (s[i] == 'R')
pos++;
else {
if (actual[pos] == '(')
upd(1, 1, n, pos, n, -1), tot--;
else if (actual[pos] == ')')
upd(1, 1, n, pos, n, 1), tot++;
actual[pos] = s[i];
if (actual[pos] == '(')
upd(1, 1, n, pos, n, 1), tot++;
else if (actual[pos] == ')')
upd(1, 1, n, pos, n, -1), tot--;
}
if (tot != 0 or seg[1].mini < 0)
printf("%d ", -1);
else
printf("%d ", seg[1].maxi);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[100000];
void solve() {
cin >> n;
int total = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
total += arr[i];
}
int cur = 0, res = 0;
for (int i = 0; i < n - 1; i++) {
cur += arr[i];
if (2 * cur == total) res++;
}
cout << res << endl;
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
stack<time_t> time_stack;
void startTimer() { time_stack.push(clock()); }
double stopTimer() {
double time = clock() - time_stack.top();
time_stack.pop();
return time / double(CLOCKS_PER_SEC);
}
int main() {
startTimer();
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<char> v(n), h(n);
vector<int> ans;
for (int i = 0; i < n * n; i++) {
int hi, vi;
cin >> hi >> vi;
hi--;
vi--;
if (!v[vi] && !h[hi]) {
ans.push_back(i + 1);
v[vi] = 1;
h[hi] = 1;
}
}
for (auto it : ans) cout << it << " ";
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int a[124], ans;
int dp[124][100024], maxN = 100024;
long long get(long long nn, int ind) {
if (!nn) {
return 0;
}
if (ind == k) {
return nn;
}
if (nn < maxN && dp[ind][nn] >= 0) {
return dp[ind][nn];
}
long long crr = get(nn, ind + 1) - get(nn / a[ind], ind + 1);
if (nn < maxN) {
dp[ind][nn] = crr;
}
return crr;
}
int main() {
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> a[i];
}
sort(a, a + k);
reverse(a, a + k);
memset(dp, -1, sizeof(dp));
cout << get(n, 0) << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.