solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include<bits/stdc++.h>
using namespace std;
int main(){
int x;
cin >> x;
int num=x/100;
if(x<=105*num)cout << 1;
else cout << 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
string fun(string s, string t) {
int n = s.length();
string ans = "";
int ind;
for (int i = 0; i < n; i++) {
if (s[i] == t[i])
ans += s[i];
else {
ind = i;
break;
}
}
if (t[ind] - s[ind] > 1) {
char ch = s[ind] - 'a' + 98;
ans += ch;
for (int i = ind + 1; i < n; i++) ans += 'a';
return ans;
}
if (ind == n - 1) return "No such string";
bool fir = false;
bool sec = false;
for (int i = ind + 1; i < n; i++) {
if (s[i] != 'z') {
fir = true;
break;
}
}
if (fir) {
ans += s[ind];
for (int i = ind + 1; i < n; i++) ans += 'z';
return ans;
}
for (int i = ind + 1; i < n; i++) {
if (t[i] != 'a') {
sec = true;
break;
}
}
if (sec) {
ans += t[ind];
for (int i = ind + 1; i < n; i++) ans += 'a';
return ans;
}
return "No such string";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> s >> t;
cout << fun(s, t);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long takemod(long long a, long long mod) {
a %= mod;
if (a < 0) a += mod;
return a;
}
void solve() {
long long w, h, a = 0, b = 0;
cin >> w >> h;
for (long long i = 2; 1; i += 2) {
if (i > w && i > h) break;
if (i <= w) {
a += w - i + 1;
}
if (i <= h) {
b += h - i + 1;
}
}
cout << (a * b);
return;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
using P = pair<ll,int>;
const int V = 50000;
const ll INF = LLONG_MAX/3;
struct edge{int to; ll cost;};
vector<edge> G[V];
ll d[V];
int main()
{
int n,m;
scanf(" %d %d", &n, &m);
vector<int> x(m),y(m);
vector<ll> t(m);
rep(i,m)
{
scanf(" %d %d %lld", &x[i], &y[i], &t[i]);
--x[i];
--y[i];
}
int v0,a,b,c;
scanf(" %d %d %d %d", &v0, &a, &b, &c);
rep(v,c)
{
int nv = (a*v+b)%c;
rep(i,m)
{
G[c*x[i]+v].pb({c*y[i]+nv,t[i]*v});
G[c*y[i]+v].pb({c*x[i]+nv,t[i]*v});
int A = c*n;
G[A+c*x[i]+v].pb({A+c*y[i]+nv,t[i]*v});
G[A+c*y[i]+v].pb({A+c*x[i]+nv,t[i]*v});
}
}
rep(i,c)
{
int u = c*(n-1)+i, v = n*c+u;
G[u].pb({v,0});
G[v].pb({u,0});
}
// dijkstra
fill(d,d+V,INF);
d[v0]=0;
priority_queue<P,vector<P>,greater<P>> que;
que.push(P(0,v0));
while(!que.empty())
{
P p = que.top();
que.pop();
int v = p.se;
if(p.fi>d[v]) continue;
for(const auto &e:G[v])
{
if(d[e.to]>d[v]+e.cost)
{
d[e.to] = d[v]+e.cost;
que.push(P(d[e.to],e.to));
}
}
}
ll ans = INF;
rep(i,c) ans = min(ans,d[n*c+i]);
printf("%lld\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s = to_string(n);
for (int i = 0; i < s.length(); i++) {
if (s[i] == '1' and s[i + 1] == '4' and s[i + 2] == '4') {
s[i] = 'a';
s[i + 1] = 'a';
s[i + 2] = 'a';
i += 2;
} else if (s[i] == '1' and s[i + 1] == '4') {
s[i] = 'a';
s[i + 1] = 'a';
i += 1;
} else if (s[i] == '1') {
s[i] = 'a';
}
}
for (int i = 0; i < s.length(); i++) {
if (s[i] != 'a') {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans[104] = {
1, 4, 10, 11, 12, 13, 14, 15, 16, 18, 20, 23, 26, 29, 30,
32, 34, 36, 37, 38, 40, 41, 43, 44, 46, 47, 48, 50, 53, 54,
55, 56, 57, 58, 61, 71, 73, 77, 80, 81, 88, 91, 93, 94, 98,
99, 100, 101, 102, 106, 108, 110, 111, 115, 116, 117, 118, 122, 124, 125,
126, 128, 132, 136, 138, 139, 140, 141, 142, 143, 144, 145, 146, 148, 154,
157, 159, 161, 163, 166, 167, 170, 175, 177, 180, 182, 183, 188, 189, 191,
193, 194, 195, 197, 198, 200, 203, 205, 206, 209, 213, 214, 216, 202};
bool res[250] = {};
for (int i = 0; i < 104; ++i) {
res[ans[i]] = 1;
}
int T;
cin >> T;
for (int t = 0; t < T; ++t) {
if (res[t + 1]) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, k, m, t;
cin >> n >> k >> m >> t;
long long int curr = k;
long long int noe = n;
long long int a, b;
while (t--) {
cin >> a >> b;
if (a == 0) {
if (b < curr) {
curr -= b;
noe -= b;
cout << noe << " " << curr << endl;
continue;
} else {
noe = b;
cout << noe << " " << curr << endl;
continue;
}
} else {
noe++;
if (b <= curr) curr++;
cout << noe << " " << curr << endl;
continue;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1 ; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1 ; } return 0; }
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e9+100;
const bool debug = 0;
/***************************************/
int N;
int level[30];
int num[30]; // 0~9, 10:+, 11:*
ll solve(int p, int ope) { // 0:+, 1:*
vector<ll> v;
FOR(i, p, N) {
if (level[p] > level[i]) break;
if (level[i] == level[p]) {
if (num[i] >= 10) v.push_back(solve(i + 1, num[i] == 11));
else v.push_back(num[i]);
}
}
ll res = ope == 1;
REP(i, v.size()) {
if (ope) res *= v[i];
else res += v[i];
}
return res;
}
int main() {
while (cin >> N, N) {
REP(i, N) {
string str;
cin >> str;
level[i] = str.size() - 1;
if (str.back() == '+') num[i] = 10;
else if (str.back() == '*') num[i] = 11;
else num[i] = str.back() - '0';
}
if (debug) printf("@ ");
cout << solve(0, 0) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a < b) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int N;
vector<int> costs;
vector<int> lengths;
map<pair<int, int>, long long int> rem;
long long int mincost(int current, int g) {
map<pair<int, int>, long long int>::iterator r =
rem.find(make_pair(current, g));
if (r != rem.end()) {
return r->second;
}
if (g == 1) {
return 0;
}
if (current == N) {
return 1000000000000;
}
long long minc = 1000000000000;
if (g == -1) {
minc = mincost(current + 1, lengths[current]) + costs[current];
} else {
minc = mincost(current + 1, gcd(g, lengths[current])) + costs[current];
}
minc = min(minc, mincost(current + 1, g));
rem[make_pair(current, g)] = minc;
return minc;
}
int main() {
cin >> N;
lengths.resize(N);
costs.resize(N);
for (int i = 0; i < N; i++) {
cin >> lengths[i];
}
for (int i = 0; i < N; i++) {
cin >> costs[i];
}
long long int ans = mincost(0, -1);
if (ans >= 1000000000000) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d, e, f, flag = 0, w;
queue<int> q1;
queue<int> q2;
cin >> n;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> c;
q1.push(c);
}
cin >> b;
for (int i = 0; i < b; i++) {
cin >> d;
q2.push(d);
}
while (1) {
e = q1.front();
f = q2.front();
q1.pop();
q2.pop();
if (e > f) {
q1.push(f);
q1.push(e);
flag++;
} else {
q2.push(e);
q2.push(f);
flag++;
}
if (q1.empty()) {
w = 2;
break;
}
if (q2.empty()) {
w = 1;
break;
}
if (flag > 10000) {
cout << "-1";
return 0;
}
}
cout << flag << " " << w;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, d, n, m, k;
cin >> c >> d >> n >> m >> k;
int t = max((m * n) - k, 0);
int p = min(c, n * d);
long long int ans = p * (t / n);
int total = (t % n);
cout << ans + min(c, total * d);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t;
long long n, k, ai;
void solve() {
cin >> n >> k;
if (n <= k)
cout << 1;
else {
ai = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (i <= k) ai = min(ai, (n / i));
if ((n / i) <= k) ai = min(ai, i);
}
}
cout << ai;
}
cout << endl;
}
int main() {
cin >> t;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>
inline T gethash(T h[], T power[], int l, int r) {
if (r < l) return (T)0;
return h[l] - h[r + 1] * power[r - l + 1];
}
struct data {
data() {}
bool friend operator<(data a, data b) { return 0; }
};
int n, m, k;
long long N, M, K;
int main() {
int t, tc = 1;
scanf("%d %d", &n, &m);
string s1 = "";
string s2 = "";
string s = "";
s = "1";
for (int i = 1; i <= 1200; i++) {
cout << 1;
}
cout << '\n';
for (int i = 1; i <= 1199; i++) {
cout << 8;
}
cout << 9 << '\n';
cout << s2 << '\n';
return 0;
}
| 2 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include<cstdio>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> a(n),b(n);
for(int i=0;i<n;++i){
cin>>a[i];
}
for(int i=0;i<n;++i){
cin>>b[i];
}
double r1,r2,r3,r4;
r1=r2=r3=r4=0;
for(int i=0;i<n;++i){
r1+=abs(a[i]-b[i]);
r2+=pow(a[i]-b[i],2.0);
r3+=abs(pow(a[i]-b[i],3.0));
r4 = max(r4,abs((double)a[i]-b[i]));
}
r2=pow(r2,0.5);
r3=pow(r3,1/3.0);
printf("%.6f\n%.6f\n%.6f\n%.6f\n",r1,r2,r3,r4);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 3e5 + 10;
long long power(long long a, long long b, long long md) {
return (!b ? 1 : power(a * a % md, b >> 1, md) * (b & 1LL ? a : 1) % md);
}
long long n;
long long A[MXN];
bool vis[MXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 2; i < MXN; i++) {
if (vis[i]) continue;
for (int j = 2; j * i < MXN; j++) vis[j * i] = 1;
}
cin >> n;
if (n == 1) return cout << "YES\n1", 0;
if (n == 4) return cout << "YES\n1\n3\n2\n4", 0;
if (vis[n]) return cout << "NO\n", 0;
A[1] = 1, A[n] = n;
for (int i = 2; i < n; i++) A[i] = i * power(i - 1, n - 2, n) % n;
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << A[i] << ' ';
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x[1010], dp[1010][1010], sm[1010];
int solve(int gap) {
dp[0][0] = 1, x[0] = -200000;
for (int i = 1; i <= k; ++i) {
for (int j = 0; j <= n; ++j)
sm[j] = j == 0 ? dp[i - 1][j] : (dp[i - 1][j] + sm[j - 1]) % 998244353;
int pos = 0;
for (int j = 1; j <= n; ++j) {
while (x[j] - x[pos + 1] >= gap) pos++;
dp[i][j] = sm[pos];
}
}
int sum = 0;
for (int i = 1; i <= n; ++i) sum = (sum + dp[k][i]) % 998244353;
return sum;
}
int32_t main() {
cin.tie(0), cout.sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> x[i];
sort(x + 1, x + 1 + n);
int dis = 100000 / (k - 1), pre = solve(1), ans = 0;
for (int i = 2; i <= dis + 5; ++i) {
int now = solve(i);
ans = (ans + 1ll * (pre - now + 998244353) * (i - 1)) % 998244353;
pre = now;
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 114514;
typedef pair<int, int> pii;
int N, A[MAX_N];
vector<pii> opers;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]);
sort(A + 1, A + N + 1);
int split = 1;
while (split + 1 < N && A[split + 1] < 0) split++;
int curr = A[1];
for (int i = N; i > split + 1; i--) {
opers.emplace_back(curr, A[i]);
curr -= A[i];
}
opers.emplace_back(A[split + 1], curr);
curr = A[split + 1] - curr;
for (int i = 2; i <= split; i++) {
opers.emplace_back(curr, A[i]);
curr -= A[i];
}
printf("%d\n", curr);
for (auto i : opers) {
printf("%d %d\n", i.first, i.second);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long shift[65];
long long two[65];
long long getlevel(long long node) {
for (long long i = 1; i <= 60; i++) {
if (two[i] + 1 > node) return i;
}
}
void printshift() {
for (int i = 1; i <= 4; i++) {
printf("%lld ", shift[i]);
}
puts("");
}
int main() {
two[0] = 1;
for (long long i = 1; i <= 60; i++) {
two[i] = two[i - 1] * 2;
}
for (long long i = 0; i <= 60; i++) {
two[i]--;
}
int q;
scanf("%d", &q);
for (int _z = 0; _z < q; _z++) {
int type;
long long x, k;
scanf("%d", &type);
if (type == 1) {
scanf("%lld %lld", &x, &k);
long long L = getlevel(x);
k += (two[60] + 1);
k %= (two[L] - two[L - 1]);
shift[L] += k;
shift[L] %= (two[L] - two[L - 1]);
} else if (type == 2) {
scanf("%lld %lld", &x, &k);
long long L = getlevel(x);
k += (two[60] + 1);
for (int i = L; i <= 60; i++) {
k %= (two[i] - two[i - 1]);
shift[i] += k;
shift[i] %= (two[i] - two[i - 1]);
k += k;
}
} else {
scanf("%lld", &x);
long long L = getlevel(x);
x -= two[L - 1];
x += shift[L];
x %= (two[L] - two[L - 1]);
if (x == 0) x = two[L] - two[L - 1];
x += two[L - 1];
for (int i = L; i >= 2; i--) {
long long p = x;
p -= two[i - 1];
p -= shift[i];
p += (two[i] - two[i - 1]);
p %= (two[i] - two[i - 1]);
if (p == 0) p = two[i] - two[i - 1];
p += two[i - 1];
printf("%lld ", p);
x /= 2;
}
printf("1\n");
}
}
return 0;
}
| 4 |
#include <cstdio>
using namespace std;
int main()
{
for(;;){
int hist[3] = {0};
int input[5];
for(int i=0; i<5; ++i){
scanf("%d", &input[i]);
--input[i];
if(input[i] == -1)
break;
hist[input[i]]++;
}
if(input[0] == -1)
break;
for(int i=0; i<5; ++i){
bool weak = !!hist[(input[i]+1)%3];
bool strong = !!hist[(input[i]+2)%3];
printf("%d\n", weak ? (strong ? 3 : 1) : (strong ? 2 : 3));
}
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<vector<int>> G;
int par[200010], dep[200010], ans[200010];
void dfs(int key){
for(int i=0; i<G[key].size(); ++i){
if(G[key][i]!=par[key]){
par[G[key][i]]=key;
dep[G[key][i]]=dep[key]+1;
dfs(G[key][i]);
}
}
}
int main() {
int N;
cin >> N;
G.resize(N+1);
for(int i=1; i<N; ++i){
int a, b;
cin >> a >> b;
G[a].emplace_back(b);
G[b].emplace_back(a);
}
dep[1]=0;
dfs(1);
int od=0;
for(int i=1; i<=N; ++i){
od += dep[i]%2;
}
if(min(od, N-od)*3<=N){
int xnow=3, ynow=1;
for(int i=1; i<=N; ++i){
if(dep[i]%2==(od*2<N ? 1 : 0)){
ans[i]=xnow;
xnow += 3;
}else{
ans[i]=ynow;
if(ynow%3==0) ynow -= 3;
else{
ynow += ynow%3;
if(ynow>N) ynow=(N/3)*3;
}
}
}
}else{
int t=1, u=2, v=3;
for(int i=1; i<=N; ++i){
if(dep[i]%2==0){
if(t<=N){
ans[i]=t;
t += 3;
}else{
ans[i]=v;
v += 3;
}
}else{
if(u<=N){
ans[i]=u;
u += 3;
}else{
ans[i]=v;
v += 3;
}
}
}
}
cout << ans[1];
for(int i=2; i<=N; ++i) cout << ' ' << ans[i];
cout << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 998244353;
const int G = 3;
const int Gi = (mods + 1) / G;
const int MAXN = 400005;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
*oT = obuf + SIZE - 1, c;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
inline void getc(char &c) {
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c == ' ' || c == '\n';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
;
}
inline void reads(char *st) {
int n;
getc(st[n = 1]);
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c != ' ' && c != '\n' && c != EOF;
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
st[++n] = c;
}
template <class I>
inline void read(I &x) {
for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 3) + (x << 1) + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (x < 0) putc('-'), x = -x;
if (!x) putc('0');
while (x) que[++num] = x % 10 + 48, x /= 10;
while (num) putc(que[num--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_Flusher_;
} // namespace FastIO
using FastIO ::print;
using FastIO ::putc;
using FastIO ::read;
vector<int> e[MAXN], E[MAXN], f[MAXN], V, F, GF;
int g[MAXN], sz[MAXN], fac[MAXN], inv[MAXN], A[MAXN], B[MAXN], C[MAXN],
rev[MAXN], H[MAXN], top[MAXN], mx[MAXN], Limit, l;
int upd(int x, int y) { return x + y >= mods ? x + y - mods : x + y; }
int quick_pow(int x, int y) {
int ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = 1ll * ret * x % mods;
x = 1ll * x * x % mods;
}
return ret;
}
void Init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mods;
inv[n] = quick_pow(fac[n], mods - 2);
for (int i = n - 1; i >= 0; --i) inv[i] = 1ll * inv[i + 1] * (i + 1) % mods;
}
void getrev(int n) {
l = 0, Limit = 1;
while (Limit <= n) Limit <<= 1, ++l;
for (int i = 0; i < Limit; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (l - 1));
}
void NTT(int *A, int opt, int n = 0) {
for (int i = 0; i < Limit; ++i)
if (rev[i] < i) swap(A[rev[i]], A[i]);
for (int mid = 1; mid < Limit; mid <<= 1) {
int Wn = quick_pow((opt == 1 ? G : Gi), (mods - 1) / (mid << 1));
for (int R = mid << 1, j = 0; j < Limit; j += R)
for (int k = j, w = 1; k < j + mid; ++k, w = 1ll * w * Wn % mods) {
int x = A[k], y = 1ll * A[k + mid] * w % mods;
A[k] = upd(x, y), A[k + mid] = upd(x, mods - y);
}
}
if (opt == -1) {
int invLimit = quick_pow(Limit, mods - 2);
for (int i = 0; i < n; ++i) A[i] = 1ll * A[i] * invLimit % mods;
for (int i = n; i < Limit; ++i) A[i] = 0;
}
}
void solve(int l, int r, vector<int> &Ans) {
if (l == r) {
Ans = f[V[l]];
return;
}
vector<int> L, R;
int mid = (l + r) >> 1;
solve(l, mid, L);
solve(mid + 1, r, R);
int sum = L.size() + R.size() - 2;
getrev(sum);
for (int i = 0; i < (int)L.size(); ++i) A[i] = L[i];
for (int i = (int)L.size(); i < Limit; ++i) A[i] = 0;
for (int i = 0; i < (int)R.size(); ++i) B[i] = R[i];
for (int i = (int)R.size(); i < Limit; ++i) B[i] = 0;
NTT(A, 1), NTT(B, 1);
for (int i = 0; i < Limit; ++i) C[i] = 1ll * A[i] * B[i] % mods;
NTT(C, -1, sum + 1);
Ans.resize(sum + 1);
for (int i = 0; i <= sum; ++i) Ans[i] = C[i];
}
void Solve(int l, int r, vector<int> &Ans, vector<int> &All) {
if (l == r) {
Ans = All = f[V[l]];
return;
}
vector<int> L, R, _L, _R;
int mid = (l + r) >> 1;
Solve(l, mid, L, _L);
Solve(mid + 1, r, R, _R);
int sum = L.size() + R.size() - 2;
getrev(sum);
for (int i = 0; i < (int)_R.size(); ++i) A[i] = _R[i];
for (int i = (int)_R.size(); i < Limit; ++i) A[i] = 0;
for (int i = 0; i < (int)L.size(); ++i) B[i] = L[i];
for (int i = (int)L.size(); i < Limit; ++i) B[i] = 0;
NTT(A, 1), NTT(B, 1);
for (int i = 0; i < Limit; ++i) C[i] = 1ll * A[i] * B[i] % mods;
NTT(C, -1, sum + 1);
Ans.resize(sum + 1);
for (int i = 0; i <= sum; ++i) Ans[i] = C[i];
for (int i = 0; i < (int)R.size(); ++i) Ans[i] = upd(Ans[i], R[i]);
for (int i = 0; i < (int)_L.size(); ++i) B[i] = _L[i];
for (int i = (int)_L.size(); i < Limit; ++i) B[i] = 0;
NTT(B, 1);
for (int i = 0; i < Limit; ++i) C[i] = 1ll * A[i] * B[i] % mods;
NTT(C, -1, sum + 1);
All.resize(sum + 1);
for (int i = 0; i <= sum; ++i) All[i] = C[i];
}
void dfs1(int x, int father) {
sz[x] = 1;
for (auto v : E[x]) {
if (v == father) continue;
e[x].push_back(v);
dfs1(v, x);
sz[x] += sz[v];
if (sz[v] > sz[mx[x]]) mx[x] = v;
}
}
void dfs2(int x, int Top) {
top[x] = Top;
if (mx[x]) dfs2(mx[x], Top), H[x] = H[mx[x]] + 1;
for (auto v : e[x]) {
if (v == mx[x]) continue;
dfs2(v, v);
}
}
void tree_dp(int x) {
for (auto v : e[x]) tree_dp(v);
if (!e[x].size()) {
f[x].clear(), f[x].push_back(1), f[x].push_back(1);
return;
}
V.clear();
for (auto v : e[x])
if (v != mx[x]) V.push_back(v);
if (V.size()) {
solve(0, (int)V.size() - 1, f[x]);
f[x].resize(f[x].size() + 1);
for (int i = (int)f[x].size() - 1; i >= 1; --i) f[x][i] = f[x][i - 1];
f[x][0] = 0;
} else
f[x].clear(), f[x].push_back(0), f[x].push_back(1);
if (top[x] == x) {
V.clear();
for (int i = 1, nw = x; i <= H[x] + 1; ++i) V.push_back(nw), nw = mx[nw];
reverse(V.begin(), V.end());
f[V[0]][0] = 0;
Solve(0, (int)V.size() - 1, F, GF);
f[x].resize(F.size());
for (int i = 0; i < (int)F.size(); ++i) f[x][i] = F[i];
f[x][0] = 1;
}
}
signed main() {
int n;
long long X;
read(n), read(X), Init(n);
for (int i = 1, u, v; i < n; ++i)
read(u), read(v), E[u].push_back(v), E[v].push_back(u);
dfs1(1, 0);
dfs2(1, 1);
tree_dp(1);
int ans = 0;
for (int i = 1, mul = 1; i < (int)f[1].size(); ++i) {
ans = upd(ans, 1ll * mul * f[1][i] % mods);
mul = 1ll * mul * quick_pow(i, mods - 2) % mods * ((X + i) % mods) % mods;
}
print(ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int S, g[N][N], lx[N], ly[N], match[N], ans, slack[N];
int res[N];
bool fx[N], fy[N];
bool find(int x) {
fx[x] = 1;
for (int y = 1; y <= S; ++y) {
if (fy[y]) continue;
if (lx[x] + ly[y] == g[x][y]) {
fy[y] = 1;
if (!match[y] || find(match[y])) {
match[y] = x;
res[x] = y;
return 1;
}
} else {
slack[y] = min(slack[y], lx[x] + ly[y] - g[x][y]);
}
}
return 0;
}
void update() {
int delta = 1 << 30, i;
for (i = 1; i <= S; ++i)
if (!fy[i]) delta = min(delta, slack[i]);
for (i = 1; i <= S; ++i) {
if (fx[i]) lx[i] -= delta;
if (fy[i]) ly[i] += delta;
slack[i] -= delta;
}
}
void Kuhn_Munkras() {
int i, j;
for (i = 1; i <= S; ++i) {
match[i] = lx[i] = ly[i] = 0;
for (j = 1; j <= S; ++j) lx[i] = max(lx[i], g[i][j]);
}
for (i = 1; i <= S; ++i) {
while (1) {
for (j = 1; j <= S; ++j) fx[j] = fy[j] = 0, slack[j] = 1 << 30;
if (find(i))
break;
else
update();
}
}
}
int n, K;
char A[2000005];
char B[2000005];
void work() {
scanf("%d%d%s%s", &n, &K, A, B);
for (int i = 0; i < n; ++i) {
int x = isupper(A[i]) ? A[i] - 'A' + 27 : A[i] - 'a' + 1;
int y = isupper(B[i]) ? B[i] - 'A' + 27 : B[i] - 'a' + 1;
++g[x][y];
}
S = K;
Kuhn_Munkras();
ans = 0;
for (int i = 1; i <= S; ++i) {
ans += g[i][res[i]];
}
printf("%d\n", ans);
for (int i = 1; i <= S; ++i) {
if (res[i] <= 26)
printf("%c", res[i] - 1 + 'a');
else
printf("%c", res[i] - 27 + 'A');
}
}
int main() {
work();
return 0;
}
| 3 |
#include<cstdio>
#include<iostream>
#include<vector>
#include<complex>
#include<algorithm>
#include<cmath>
using namespace std;
#define reps(i,f,n) for(int i=f;i<int(n);i++)
#define rep(i,n) reps(i,0,n)
typedef complex<double> Point;
const double EPS = 0.000001;
int main(){
A:;
int n;
cin>>n;
if(n==0)return 0;
vector<Point> point;
rep(i,n){
double a,b;
cin>>a>>b;
point.push_back(Point(a,b));
}
int ans = 1;
rep(i,n){
rep(j,n){
if(i==j)continue;
Point p1 = point[j];
Point p0 = point[i];
Point diff = p1-p0;
Point d2 = diff/Point(2,0);
double dlen = abs(d2);
if(dlen>1.0)continue;
double clen = sqrt(1-dlen*dlen);
Point e = d2*Point(0,1);
e = e/Point(abs(e),0)*Point(clen,0);
Point t = p0 + d2 + e;
int count = 0;
rep(k,n){
if(abs(t-point[k])<=1.0+EPS)count++;
}
ans = max(ans,count);
}
}
printf("%d\n",ans);
goto A;
}
/*
3
6.47634 7.69628
5.16828 4.79915
6.69533 6.20378
2
0 0
0.8 0
2
0 0
0.5 0.5
2
0 0
0 2
6
7.15296 4.08328
6.50827 2.69466
5.91219 3.86661
5.29853 4.16097
6.10838 3.46039
6.34060 2.41599
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n, k, m;
int a[MAXN];
long long res;
void solve(deque<int> &a) {
if (a.empty()) return;
int l = 0;
int r = (int)a.size() - 1;
while (l < (int)a.size() && a[l] == a[0]) {
++l;
}
while (r > -1 && a[r] == a.back()) {
--r;
}
if (l == (int)a.size()) {
res -= l * 1ll * m / k * k;
if (l * 1ll * m % k == 0) {
a.clear();
}
return;
}
int pref = l;
int suff = (int)a.size() - 1 - r;
if (a[0] == a.back() && pref + suff == k) {
res -= (m - 1) * 1ll * k;
while (pref-- > 0) {
a.pop_front();
}
while (suff-- > 0) {
a.pop_back();
}
solve(a);
if (a.empty()) res -= k;
} else if (a[0] == a.back() && pref + suff > k) {
res -= (m - 1) * 1ll * k;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> m;
res = n * 1ll * m;
for (int i = 0, x; i < n; ++i) {
cin >> x;
a[i] = x;
}
vector<pair<int, int> > st;
for (int i = 0; i < n; ++i) {
if (!st.empty()) {
if (st.back().first == a[i]) {
++st.back().second;
if (st.back().second == k) {
res -= k * 1ll * m;
st.pop_back();
}
} else {
st.push_back({a[i], 1});
}
} else {
st.push_back({a[i], 1});
}
}
deque<int> b;
for (int i = 0; i < (int)st.size(); ++i) {
for (int j = 0; j < (int)st[i].second; ++j) {
b.push_back(st[i].first);
}
}
solve(b);
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using ul = std::uint32_t;
using li = std::int32_t;
using ull = std::uint64_t;
using ll = std::int64_t;
using vul = std::vector<ul>;
using vb = std::vector<bool>;
using vvb = std::vector<vb>;
using vvvb = std::vector<vvb>;
std::mt19937_64 rands;
class point {
public:
li x = 0;
li y = 0;
point() = default;
point(li a, li b) : x(a), y(b) {}
};
bool operator==(const point& a, const point& b) {
return a.x == b.x && a.y == b.y;
}
point operator+(const point& a, const point& b) {
return point(a.x + b.x, a.y + b.y);
}
point operator-(const point& a, const point& b) {
return point(a.x - b.x, a.y - b.y);
}
ll inner(const point& a, const point& b) {
return ll(a.x) * ll(b.x) + ll(a.y) * ll(b.y);
}
point rotate(const point& a) { return point(-a.y, a.x); }
ul region(ll x, ll y) {
if (x < 0) {
if (y < 0) {
return 2;
} else {
return 1;
}
} else {
if (y < 0) {
return 3;
} else {
return 0;
}
}
}
bool lesslean(const point& a, const point& b, const point& cor) {
ll ax = ll(a.x) * ll(cor.x) + ll(a.y) * ll(cor.y);
ll ay = ll(a.y) * ll(cor.x) - ll(a.x) * ll(cor.y);
ll bx = ll(b.x) * ll(cor.x) + ll(b.y) * ll(cor.y);
ll by = ll(b.y) * ll(cor.x) - ll(b.x) * ll(cor.y);
if (region(ax, ay) != region(bx, by)) {
return region(ax, ay) < region(bx, by);
} else {
return ll(a.x) * ll(b.y) - ll(a.y) * ll(b.x) > 0;
}
}
std::vector<point> points(2000);
ul n;
ull ans = 0;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
rands.seed(std::time(0));
std::cin >> n;
points.resize(n);
for (ul i = 0; i != n; ++i) {
std::cin >> points[i].x >> points[i].y;
}
for (const point& center : points) {
std::deque<point> reorder;
for (const point& p : points) {
if (!(p == center)) {
reorder.push_back(p);
}
}
std::sort(reorder.begin(), reorder.end(),
[&](const point& a, const point& b) {
return lesslean(a - center, b - center, point(1, 0));
});
for (ul i = 0; i != reorder.size(); ++i) {
auto p = reorder.front();
reorder.pop_front();
auto it = std::lower_bound(
reorder.begin(), reorder.end(), center + center - p,
[&](const point& a, const point& b) {
return lesslean(a - center, b - center, p - center);
});
ul k1 = it - reorder.begin();
ul k2 = reorder.end() - it;
ans += ull(k1 * (k1 - 1) >> 1) * ull(k2 * (k2 - 1) >> 1);
reorder.push_back(p);
}
}
std::cout << (ans >> 1) << std::endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
bool vis[maxn];
int newedge[maxn];
vector<int> v[maxn];
int ans = 0;
int dfs(int x, int depth) {
vis[x] = 1;
int re = 1;
for (auto tmp : v[x]) {
if (!vis[tmp]) {
int child = dfs(tmp, depth + 1);
if (!newedge[x] && child == 1 && depth > 1) {
ans++;
newedge[x] = 1;
re = -1;
}
if (re == 1 && child == -1) re = 0;
}
}
return re;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, l, r;
cin >> n;
for (int i = 1; i <= n - 1; i++) {
cin >> l >> r;
v[l].push_back(r);
v[r].push_back(l);
}
dfs(1, 0);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 500;
const int MX = (int)1 << 20;
vector<int> g[N];
int n, sz[N];
long long ans[N], cnt[MX];
char c[N];
bool used[N];
void sizes(int v, int p) {
sz[v] = 1;
for (auto u : g[v]) {
if (u == p || used[u]) continue;
sizes(u, v);
sz[v] += sz[u];
}
}
int centroid(int v, int p, int sz_comp) {
for (auto u : g[v])
if (u != p && !used[u] && sz[u] > sz_comp / 2)
return centroid(u, v, sz_comp);
return v;
}
void upd(int v, int p, int k, int sum) {
sum ^= (1 << (c[v] - 'a'));
cnt[sum] += k;
for (auto u : g[v]) {
if (u == p || used[u]) continue;
upd(u, v, k, sum);
}
}
long long calc(int v, int p, int sum) {
sum ^= (1 << (c[v] - 'a'));
long long res = cnt[sum];
for (int i = 0; i < 20; i++) res += cnt[sum ^ (1 << i)];
for (auto u : g[v]) {
if (u == p || used[u]) continue;
res += calc(u, v, sum);
}
ans[v] += res;
return res;
}
void solve(int v) {
sizes(v, v);
used[v] = 1;
upd(v, 0, 1, (1 << (c[v] - 'a')));
long long res = cnt[(1 << (c[v] - 'a'))];
for (int i = 0; i < 20; i++) res += cnt[(1 << (c[v] - 'a')) ^ (1 << i)];
for (auto u : g[v]) {
if (used[u]) continue;
upd(u, v, -1, 0);
res += calc(u, v, (1 << (c[v] - 'a')));
upd(u, v, 1, 0);
}
upd(v, 0, -1, (1 << (c[v] - 'a')));
ans[v] += res / 2 + 1;
for (auto u : g[v])
if (!used[u]) solve(centroid(u, v, sz[u]));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) cin >> c[i];
solve(1);
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e9;
long long r, n, p[35], w[35], ww[35], v;
long long u[35], g[100005][30], bj[100005], shu[1000005], ans, a, b, c;
void dfs(long long i, long long x) {
if (i == n + 1) {
for (int j = 1; j <= n; ++j) {
g[r][j] = u[j];
}
bj[r] = r;
shu[r++] = x;
return;
}
for (int j = 0; j <= w[i]; ++j) {
u[i] = j;
dfs(i + 1, x);
if (j < w[i] && x <= maxn / p[i]) {
x *= p[i];
} else {
break;
}
if (x > v / x / x) {
break;
}
}
return;
}
bool cmp(int aa, int bb) { return shu[aa] < shu[bb]; }
void dfs2(int i, long long aa, long long bb, long long cc) {
if (i == n + 1) {
if (aa >= bb) {
cc = cc / aa;
if ((long long)aa * bb + bb * cc + aa * cc < ans) {
ans = aa * bb + bb * cc + aa * cc;
a = aa;
b = bb;
c = cc;
}
}
return;
}
for (int j = 0; j <= ww[i]; ++j) {
dfs2(i + 1, aa, bb, cc);
if (j < ww[i] && aa <= maxn / p[i]) {
aa *= p[i];
} else {
break;
}
if (aa > cc / aa) {
break;
}
}
return;
}
int main() {
long long T;
scanf("%lld", &T);
while (T--) {
v = 1;
scanf("%lld", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld%lld", &p[i], &w[i]);
for (int j = 1; j <= w[i]; ++j) {
v *= p[i];
}
}
r = 0;
ans = 7e18;
dfs(1, 1);
sort(bj, bj + r, cmp);
for (int num = r - 1; num >= 0; --num) {
int i = bj[num];
double jj = sqrt(v / (double)shu[i]);
if (2 * shu[i] * jj + jj * jj >= ans) {
continue;
}
for (int j = 1; j <= n; ++j) {
ww[j] = w[j] - g[i][j];
}
dfs2(1, 1, shu[i], v / shu[i]);
}
cout << ans * 2 << " " << a << " " << b << " " << c << endl;
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
using lint = long long;
template<typename T = lint>inline T in() { T x; cin >> x; return x; }
#define INF 1e9
#define INFL static_cast<lint>(INF)
#define REP(i,n) for(lint i=0,i##_len=(n);i<i##_len;++i)
#define REP1(i,n) for(lint i=1,i##_len=(n);i<=i##_len;++i)
#define REPR(i,n) for(lint i=n-1;i>=0;--i)
#define REPR1(i,n) for(lint i=n;i>0;--i)
#define REPI(i,ini,n) for(lint i=(ini),i##_len=(n);i<i##_len;++i)
#define REPC(i,obj) for(auto i:obj)
#define R_UP(a,b) (((a)+(b)-1)/(b))
#define ALL(obj) (obj).begin(),(obj).end()
int main()
{
int n = in();
vector<int>a(n);
REPC(&i, a)i = in();
int q = in();
REP(i, q)
{
int k = in();
cout << (binary_search(a.begin(), a.end(), k) ? 1 : 0) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, bar;
vector<int> choco;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> bar;
choco.push_back(bar);
}
if (n == 1)
cout << "1 0\n";
else {
auto l = choco.begin();
auto r = choco.end() - 1;
int diff = 0;
int l_count = 0;
int r_count = 0;
while (true) {
if ((l + 1) == r) {
++l_count;
++r_count;
break;
}
diff = (*l) - (*r);
if (diff < 0) {
(*r) -= (*l);
++l_count;
++l;
} else if (diff > 0) {
(*l) -= (*r);
++r_count;
--r;
} else {
++l_count;
(*l) = 0;
if ((l + 2) == r)
++l;
else {
++r_count;
(*r) = 0;
++l;
--r;
}
}
}
cout << l_count << ' ' << r_count << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 250, N = (1 << 15), JYY = 1e9 + 7;
long long n, Ans = 1;
long long read() {
long long x = 0, y = 1;
char ch = getchar();
while (ch < '0' || ch > '9') y = ch == '-' ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * y;
}
long long tot, top, cnt = 0, a[M], in[M], id[M], val[M], st[M], sz[N], dp[M][N],
C[M][M];
bool vis[M];
void Add(long long &x, long long y) { x = (x + y) % JYY; }
void dfs(long long u, long long rt) {
id[u] = rt, tot++;
if (in[u] == 0) st[top++] = u, vis[u] = 1;
for (long long i = 1; i <= n; i++)
if (!id[i] && (a[u] % a[i] == 0 || a[i] % a[u] == 0)) dfs(i, rt);
}
void solve() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read(), in[i] = 0;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= n; j++)
if (i != j && a[i] % a[j] == 0) in[i]++;
for (long long i = 1; i <= n; i++) {
C[i][0] = C[i][i] = 1;
for (long long j = 1; j < i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % JYY;
}
for (long long l = 1; l <= n; l++) {
if (id[l]) continue;
top = 0, tot = 0;
dfs(l, l);
if (tot - top <= 1) continue;
long long lim = (1 << top);
for (long long i = 1; i <= n; i++) {
if (id[i] != l || vis[i]) continue;
val[i] = 0;
for (long long j = 0; j < top; j++)
if (a[i] % a[st[j]] == 0) val[i] |= (1 << j);
}
for (long long i = 0; i < lim; i++) {
sz[i] = 0;
for (long long j = 1; j <= n; j++)
if (id[j] == l && !vis[j] && (i & val[j]) == val[j]) sz[i]++;
}
for (long long i = 1; i <= n; i++) {
if (i <= tot - top)
for (long long j = 0; j < lim; j++) dp[i][j] = 0;
if (id[i] == l && !vis[i]) dp[1][val[i]]++;
}
for (long long i = 1; i < tot - top; i++)
for (long long S = 0; S < lim; S++) {
if (!dp[i][S]) continue;
if (sz[S] > i) Add(dp[i + 1][S], dp[i][S] * (sz[S] - i) % JYY);
for (long long j = 1; j <= n; j++) {
if (id[j] != l || vis[j] || (S & val[j]) == val[j] || !(S & val[j]))
continue;
Add(dp[i + 1][S | val[j]], dp[i][S]);
}
}
long long res = 0;
tot = tot - top;
for (long long i = 0; i < lim; i++) Add(res, dp[tot][i]);
Ans = Ans * res % JYY * C[cnt + tot - 1][tot - 1] % JYY;
cnt += tot - 1;
}
printf("%lld\n", Ans);
}
signed main() { solve(); }
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int countDigit(long long int n) {
string s = to_string(n);
return s.size();
}
bool sol(long long int x) {
string s = to_string(x);
if (s.size() == 1) {
return true;
}
if (s[0] == s[s.size() - 1]) {
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int l, r;
cin >> l >> r;
long long int ans = 0;
if (countDigit(r) <= 2) {
for (long long int i = l; i <= r; i++) {
if (sol(i)) {
ans++;
}
}
cout << ans << endl;
return 0;
}
while (countDigit(l) < 3) {
if (sol(l)) {
ans++;
}
l++;
}
while (l % 10 != 0) {
if (sol(l)) {
ans++;
}
l++;
}
while (r % 10 != 0) {
if (sol(r)) {
ans++;
}
r--;
}
ans += (r - l) / 10;
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ans[1000000];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n;
cin >> n;
for (int i = 1; i <= n; i++) {
ans[i] = 1;
}
for (int i = 2; i <= n; i++) {
for (int j = 2 * i; j <= n; j = j + i) {
ans[j] = i;
}
}
sort(ans + 1, ans + 1 + n);
for (int i = 2; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
vector<long long> g[1000005];
vector<bool> vis(1000005, 0);
long long dx[] = {-1, 0, 1, 0};
long long dy[] = {0, -1, 0, 1};
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
long long d = v[n - 1] - v[0];
bool check = true;
if (d % 2 == 0) {
for (long long i = 0; i < n; i++) {
if (abs(v[i] - v[n - 1]) != 0 && abs(v[i] - v[n - 1]) != d &&
abs(v[i] - v[n - 1]) != d / 2)
check = false;
}
if (check)
cout << d / 2;
else
cout << -1;
} else {
for (long long i = 0; i < n; i++) {
if (abs(v[i] - v[n - 1]) != 0 && abs(v[i] - v[n - 1]) != d) check = false;
}
if (check)
cout << d;
else
cout << -1;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100], b[100], c[100], d[100], p, q, l, r;
void update(int t) {
for (int i = 1; i <= q; i++) c[i] -= t, d[i] -= t;
}
bool check(int t) {
for (int i = 1; i <= q; i++) c[i] += t, d[i] += t;
for (int i = 1; i <= p; i++) {
int l1 = a[i], r1 = b[i];
for (int j = 1; j <= q; j++) {
int l2 = c[j], r2 = d[j];
int l = max(l1, l2), r = min(r1, r2);
if (l <= r) {
update(t);
return true;
}
}
}
update(t);
return false;
}
int findchat() {
int res = 0;
for (int i = l; i <= r; i++)
if (check(i)) res++;
return res;
}
int main() {
cin >> p >> q >> l >> r;
for (int i = 1; i <= p; i++) cin >> a[i] >> b[i];
for (int i = 1; i <= q; i++) cin >> c[i] >> d[i];
cout << findchat() << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long arr[1000000];
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> arr[i];
if (n == 1) {
cout << "+";
return 0;
}
long long su = -arr[n - 1];
string hi = "-";
for (long long i = n - 2; i >= 0; i--) {
if (i <= 20) {
for (long long j = 0; j < (1 << (i + 1)); j++) {
long long yo = su;
for (long long k = 0; k <= i; k++) {
if (j & (1 << k))
yo += arr[k];
else
yo -= arr[k];
}
if (yo >= 0 && yo <= arr[0]) {
for (long long k = i; k >= 0; k--) {
if (j & (1 << k))
hi += '+';
else
hi += '-';
}
reverse(hi.begin(), hi.end());
cout << hi;
return 0;
}
}
break;
} else {
if (su >= 0)
su -= arr[i], hi += '-';
else
su += arr[i], hi += '+';
}
}
hi = "+";
su = arr[n - 1];
for (long long i = n - 2; i >= 0; i--) {
if (i <= 20) {
for (long long j = 0; j < (1 << (i + 1)); j++) {
long long yo = su;
for (long long k = 0; k <= i; k++) {
if (j & (1 << k))
yo += arr[k];
else
yo -= arr[k];
}
if (yo >= 0 && yo <= arr[0]) {
for (long long k = i; k >= 0; k--) {
if (j & (1 << k))
hi += '+';
else
hi += '-';
}
reverse(hi.begin(), hi.end());
cout << hi;
return 0;
}
}
break;
} else {
if (su >= 0)
su -= arr[i], hi += '-';
else
su += arr[i], hi += '+';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using VI = vector<int>;
ll pref_sum(ll n) { return (n * (n + 1)) / 2; }
vector<int> gen(int sz, ll id) {
VI ranks(sz);
ll div = 1;
for (int i = 1; i <= sz; i++) {
div *= i;
}
for (int i = 1; i <= sz; i++) {
div /= (sz - i + 1);
ranks[i - 1] = id / div;
id %= div;
}
set<int> vals;
for (int i = 1; i <= sz; i++) {
vals.insert(i);
}
VI perm;
for (int r : ranks) {
auto it = vals.begin();
while (r > 0) {
it++;
r--;
}
perm.push_back(*it);
vals.erase(it);
}
return perm;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n >> q;
int m = min(n, 15);
ll id = 0;
while (q--) {
int ty;
cin >> ty;
if (ty == 1) {
int l, r;
cin >> l >> r;
ll ans = 0;
if (l <= n - m) {
ll r1 = min(r, n - m);
ans += pref_sum(r1) - pref_sum(l - 1);
}
if (r > n - m) {
auto suf = gen(m, id);
for (int i = max(l, n - m + 1); i <= r; i++) {
ans += n - m + suf[i - (n - m) - 1];
}
}
cout << ans << endl;
} else {
int x;
cin >> x;
id += x;
}
}
return 0;
}
| 5 |
#include <iostream>
#include <cstdio>
using namespace std;
int different( double h, double m )
{
h += m / 12;
double a = h - m;
if( a < 0 ) a = -a;
if( 360 - a < a ) a = 360 - a;
return a;
}
int main(int argc, char const* argv[])
{
double h,m;
int n;
cin >> n;
for( int i = 0;i < n;i++ ){
scanf("%lf:%lf",&h,&m);
h *= 30;
m *= 6;
double answer = different( h, m );
if( answer >= 0 && answer < 30 ) cout << "alert" << endl;
else if( answer >= 90 && answer <= 180 ) cout << "safe" << endl;
else cout << "warning" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a[100010], tree[4 * 100010], lazy[4 * 100010], x;
char op;
void push(int id, int l, int r) {
if (lazy[id]) {
if (lazy[id] == 2 || lazy[id] == 3) {
tree[id] = lazy[id];
if (l != r) {
lazy[id * 2] = lazy[id];
lazy[id * 2 + 1] = lazy[id];
}
} else if (lazy[id] == 1) {
tree[id] ^= 1;
if (l != r) {
lazy[id * 2] ^= 1;
lazy[id * 2 + 1] ^= 1;
}
}
lazy[id] = 0;
}
}
void update(int id, int l, int r, int lq, int rq, int op) {
push(id, l, r);
if (lq > rq || r < lq || rq < l) return;
if (lq <= l && r <= rq) {
lazy[id] = op;
push(id, l, r);
return;
}
int m = (l + r) / 2;
update(id * 2, l, m, lq, rq, op);
update(id * 2 + 1, m + 1, r, lq, rq, op);
}
int query(int id, int l, int r, int pos) {
push(id, l, r);
if (l == r) return tree[id];
int m = (l + r) / 2;
if (pos <= m) return query(id * 2, l, m, pos);
return query(id * 2 + 1, m + 1, r, pos);
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < q; i++) {
scanf(" %c %d", &op, &x);
if (op == '<') {
if (x > 0) {
update(1, 1, 100000, x, 100000, 2);
update(1, 1, 100000, 1, x - 1, 1);
} else {
update(1, 1, 100000, abs(x) + 1, 100000, 2);
}
} else if (op == '>') {
if (x > 0) {
update(1, 1, 100000, x + 1, 100000, 3);
} else {
update(1, 1, 100000, 1, abs(x) - 1, 1);
update(1, 1, 100000, abs(x), 100000, 3);
}
} else
assert(false);
}
for (int i = 0; i < n; i++) {
if (a[i] == 0) {
printf("0 ");
continue;
}
int x = query(1, 1, 100000, abs(a[i]));
if (x == 2)
printf("%d ", abs(a[i]));
else if (x == 3)
printf("%d ", -abs(a[i]));
else if (x == 1)
printf("%d ", -a[i]);
else
printf("%d ", a[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans, f[310][2][2];
char s[310];
int n;
long long get(int x, int y) {
memset(f, 0, sizeof f);
f[0][x][y] = 1;
for (int i = 0; i <= n; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) {
if ((s[i] == 'A' && (k == 0 || (k == 1 && j == 0))) ||
(s[i] == 'B' && j == 1 && k == 1))
f[i + 1][k][0] += f[i][j][k];
if ((s[i] == 'A' && j == 0 && k == 1) ||
(s[i] == 'B' && (k == 0 || (k == 1 && j == 1))))
f[i + 1][k][1] += f[i][j][k];
}
return f[n][x][y];
}
int main() {
scanf("%s", s);
n = strlen(s);
s[n] = s[0];
ans = get(0, 0) + get(0, 1) + get(1, 0) + get(1, 1);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long i, j, m, n, s, t, x, y, z, ma, a, b, c;
int main() {
while (scanf("%lld %lld", &n, &m) != EOF) {
if (n > m) {
x = n;
n = m;
m = x;
}
a = 0;
b = 0;
a = (n / 2 + n % 2) * (m % 2);
b = (m % 2 + m / 2) * (n % 2);
if (((n / 2) * m + b) > (m / 2) * n + a)
ma = (n / 2) * m + b;
else
ma = (m / 2) * n + a;
if (n == 1) ma = m;
if (m % 4 > 2)
c = 2;
else
c = m % 4;
if (n == 2) {
if (((m / 4) * 4 + c * 2) > ma) ma = (m / 4) * 4 + c * 2;
if (m == 2 || m == 3) ma == 4;
}
if (n == 3 && m == 3) ma == 5;
printf("%lld\n", ma);
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int tc;
cin>>tc;
while(tc--)
{
int a;
string s;
cin>>a>>s;
sort(s.begin(),s.end());
cout<<s<<endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1111][1111], b[1111][1111];
int c[1111], d[1111];
int n, m;
int main() {
scanf("%d%d", &n, &m);
int x, y;
for (int i = 0; i < (n); i++) {
scanf("%d%d", &x, &y);
a[x][y]++;
c[y]++;
}
for (int i = 0; i < (m); i++) {
scanf("%d%d", &x, &y);
b[x][y]++;
d[y]++;
}
int a1 = 0, a2 = 0;
for (int i = 1; i <= (1000); i++)
for (int j = 1; j <= (1000); j++) a1 += min(a[i][j], b[i][j]);
for (int i = 1; i <= (1000); i++) a2 += min(c[i], d[i]);
printf("%d %d\n", a2, a1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool win(long long a, long long b) {
if (a < b) swap(a, b);
if (!b) return (false);
if (!win(b, a % b)) return (true);
long long p = a / b;
return (p % (b + 1) % 2 == 0);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long a, b;
scanf("%I64d%I64d", &a, &b);
printf("%s\n", win(a, b) ? "First" : "Second");
}
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int a[120][120], b[120][120];
int main() {
int n, m;
cin >> m >> n;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) {
cin >> a[i][j];
if (a[i][j] == 0) {
for (int k = 0; k < n; k++) b[i][k] = -1;
for (int k = 0; k < m; k++) b[k][j] = -1;
}
}
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) {
if (a[i][j] == 1) {
bool isok = 0;
for (int k = 0; k < n; k++)
if (b[i][k] != -1) {
b[i][k] = 1;
isok = 1;
}
for (int k = 0; k < m; k++)
if (b[k][j] != -1) {
b[k][j] = 1;
isok = 1;
}
if (!isok) {
puts("NO");
return 0;
}
}
}
puts("YES");
for (int i = 0; i < m; i++) {
for (int j = 0; j < n - 1; j++) {
if (b[i][j] == -1)
cout << 0 << " ";
else
cout << b[i][j] << " ";
}
if (b[i][n - 1] == -1)
cout << 0 << endl;
else
cout << b[i][n - 1] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
void quit();
using namespace std;
const long double PI = acos((double)-1.0);
const long double EPS = 1e-11;
double __t;
int n;
long long k;
int a[55];
long long f[55];
void solve(int n, long long k) {
for (int i = 0; i < (int)n; ++i) a[i] = i + 1;
for (int i = 0; i < (int)n; ++i) {
if (k >= f[n - i]) {
swap(a[i - 1], a[i]);
k -= f[n - i];
}
}
for (int i = 0; i < (int)n; ++i) cout << a[i] << ' ';
cout << endl;
}
int main() {
f[0] = 1;
f[1] = 1;
for (int i = 2; i < 55; i++) f[i] = f[i - 1] + f[i - 2];
cin >> n >> k;
k--;
solve(n, k);
quit();
}
void quit() { exit(0); }
| 4 |
#include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<array>
#include<map>
#include<iomanip>
#include<assert.h>
#include<list>
#include<bitset>
#include<stack>
#include<memory>
#include<numeric>
using namespace std;
using namespace std::chrono;
typedef long long int llint;
typedef long double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);*/
const llint mod=1000000007 /5;
const llint big=2.19e15+1;
const long double pai=3.141592653589793238462643383279502884197;
const long double eps=1e-10;
const long double epsA=1e-4;
template <class T,class U>bool mineq(T& a,U b){if(a>b){a=b;return true;}return false;}
template <class T,class U>bool maxeq(T& a,U b){if(a<b){a=b;return true;}return false;}
llint gcd(llint a,llint b){if(a%b==0){return b;}else return gcd(b,a%b);}
llint lcm(llint a,llint b){if(a==0){return b;}return a/gcd(a,b)*b;}
template<class T> void SO(T& ve){sort(ve.begin(),ve.end());}
template<class T> void REV(T& ve){reverse(ve.begin(),ve.end());}
template<class T>llint LBI(const vector<T>&ar,T in){return lower_bound(ar.begin(),ar.end(),in)-ar.begin();}
template<class T>llint UBI(const vector<T>&ar,T in){return upper_bound(ar.begin(),ar.end(),in)-ar.begin();}
bool solve(int ca){
int n,t,k,i,j,ans=0;cin>>n>>t>>k;
if(n==0){return false;}
cout<<"Case "<<ca<<": ";
vector<vector<int>>go(n);
vector<int>gowa(n);//行き先の残り和
vector<int>zi(n);//残り次数
vector<tuple<int,int,int>>edges(n-1);
vector<tuple<int,int,int>>zyo(n-1);
vector<bool>kie(n-1);
for(i=0;i<n-1;i++){
int a,b,c;cin>>a>>b>>c;a--;b--;
if(a>b){swap(a,b);}
edges[i]=mt(c,a,b);
zyo[i]=mt(a,b,c);
go[a].pub(b);gowa[a]+=b;zi[a]++;
go[b].pub(a);gowa[b]+=a;zi[b]++;
}
SO(edges);
for(i=0;i<n-1;i++){
int a,b,c;tie(c,a,b)=edges[i];
zyo[i]=mt(a,b,i);
}
SO(zyo);
vector<bool>nobe(n,true);//baseの否定
for(i=0;i<t;i++){
int a;cin>>a;a--;
nobe[a]=false;
}
stack<int>eraque;
for(i=0;i<n;i++){
if(nobe[i]&&zi[i]==1){eraque.push(i);}
}
int bas=0;
while(k--){
while(eraque.size()){
int ter=eraque.top();
eraque.pop();
if(zi[ter]!=1){continue;}
int it=gowa[ter];
//cerr<<"eter="<<ter<<"it="<<it<<endl;
zi[ter]--;
zi[it]--;
gowa[it]-=ter;
if(nobe[it]&&zi[it]==1){eraque.push(it);}
if(ter>it){swap(ter,it);}
int ban=get<2>(*lower_bound(zyo.begin(),zyo.end(),mt(ter,it,-1)));
//cerr<<"ban="<<ban<<endl;
kie[ban]=1;//この辺は消えた!
}
while(kie[bas]){bas++;}
int c,a,b;tie(c,a,b)=edges[bas];
ans+=c;
zi[a]--;gowa[a]-=b;
if(nobe[a]&&zi[a]==1){eraque.push(a);}
zi[b]--;gowa[b]-=a;
if(nobe[b]&&zi[b]==1){eraque.push(b);}
bas++;
}
cout<<ans<<endl;
return true;
}
/*
4 3 2
1 2 3
2 3 4
3 4 10
1
3
4
*/
int main(void){
cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);
int ca=1;
while(solve(ca)){ca++;}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool debug;
template <typename T>
struct SqrtLCASum {
public:
SqrtLCASum(const vector<T> &v)
: n((int)v.size()), lg(log2Up(n)), v(v), clz(1 << lg), onLayer(lg + 1) {
clz[0] = 0;
for (int i = 1; i < (int)clz.size(); i++) clz[i] = clz[i >> 1] + 1;
int tlg = lg;
while (tlg > 1) {
onLayer[tlg] = (int)layers.size();
layers.push_back(tlg);
tlg = (tlg + 1) >> 1;
}
for (int i = lg - 1; i >= 0; i--)
onLayer[i] = max(onLayer[i], onLayer[i + 1]);
pref.assign(layers.size(), vector<T>(n));
suf.assign(layers.size(), vector<T>(n));
between.assign(layers.size(), vector<T>(1 << lg));
build(0, 0, n);
}
inline T query(int l, int r) {
if (l == r) return v[l];
if (l + 1 == r) return op(v[l], v[r]);
int layer = onLayer[clz[l ^ r]];
int bSzLog = (layers[layer] + 1) >> 1;
int bCntLog = layers[layer] >> 1;
int lBound = (l >> layers[layer]) << layers[layer];
int lBlock = ((l - lBound) >> bSzLog) + 1;
int rBlock = ((r - lBound) >> bSzLog) - 1;
T ans = suf[layer][l];
if (lBlock <= rBlock) {
ans = op(ans, between[layer][lBound + (lBlock << bCntLog) + rBlock]);
}
ans = op(ans, pref[layer][r]);
return ans;
}
private:
int n, lg;
vector<T> v, clz, layers, onLayer;
vector<vector<T>> pref, suf, between;
void build(int layer, int lBound, int rBound) {
if (layer >= (int)layers.size()) return;
int bSzLog = (layers[layer] + 1) >> 1;
int bCntLog = layers[layer] >> 1;
int bSz = 1 << bSzLog;
int bCnt = 0;
for (int l = lBound; l < rBound; l += bSz) {
bCnt++;
int r = min(l + bSz, rBound);
pref[layer][l] = v[l];
for (int i = l + 1; i < r; i++)
pref[layer][i] = op(pref[layer][i - 1], v[i]);
suf[layer][r - 1] = v[r - 1];
for (int i = r - 2; i >= l; i--)
suf[layer][i] = op(v[i], suf[layer][i + 1]);
build(layer + 1, l, r);
}
for (int i = 0; i < bCnt; i++) {
T ans;
for (int j = i; j < bCnt; j++) {
T add = suf[layer][lBound + (j << bSzLog)];
ans = (i == j) ? add : op(ans, add);
between[layer][lBound + (i << bCntLog) + j] = ans;
}
}
}
inline int log2Up(int n) {
int res = 0;
while ((1 << res) < n) res++;
return res;
}
T op(const T &a, const T &b) { return min(a, b); }
};
template <typename T, typename RSQ>
struct TreePathQuerySum {
public:
int n, root;
vector<T> nodeVal;
TreePathQuerySum(vector<T> nodeVal, int root)
: n(nodeVal.size()),
root(root),
adj(n),
first(n),
inOrder(n),
last(n),
revOrder(n),
isBuilt(false) {
this->nodeVal = nodeVal;
euler.reserve(2 * n);
}
void addEdge(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
int getLCA(int a, int b) {
if (!isBuilt) {
build();
}
int l = first[a], r = first[b];
if (l > r) swap(l, r);
return revOrder[sqt->query(l, r)];
}
T queryIn(int a, int b) {
int lca = getLCA(a, b);
T lKeA = rsq->rangeQuery(first[lca], first[a]);
T lKeB = rsq->rangeQuery(first[lca], first[b]);
return lKeA - nodeVal[lca] + lKeB;
}
T queryEx(int a, int b) {
int lca = getLCA(a, b);
T lKeA = rsq->rangeQuery(first[lca], first[a]);
T lKeB = rsq->rangeQuery(first[lca], first[b]);
return lKeA - 2 * nodeVal[lca] + lKeB;
}
void update(int u, T val) {
nodeVal[u] += val;
rsq->update(first[u], val);
rsq->update(last[u] + 1, -val);
}
void set(int u, T val) {
T diff = val - nodeVal[u];
nodeVal[u] = val;
rsq->update(first[u], diff);
rsq->update(last[u] + 1, -diff);
}
void build() {
isBuilt = true;
visited.assign(n, false);
wkt = 0;
rsq = new RSQ(vector<T>(2 * n, 0));
dfs(root);
sqt = new SqrtLCASum<int>(euler);
if (debug) {
cout << "inOrder"
<< ": ";
for (auto i : inOrder) {
cout << i << ' ';
}
cout << endl;
}
if (debug) {
cout << "revOrder"
<< ": ";
for (auto i : revOrder) {
cout << i << ' ';
}
cout << endl;
}
if (debug) {
cout << "euler"
<< ": ";
for (auto i : euler) {
cout << i << ' ';
}
cout << endl;
}
if (debug) {
cout << "first"
<< ": ";
for (auto i : first) {
cout << i << ' ';
}
cout << endl;
}
if (debug) {
cout << "last"
<< ": ";
for (auto i : last) {
cout << i << ' ';
}
cout << endl;
}
}
private:
SqrtLCASum<int> *sqt;
RSQ *rsq;
bool isBuilt;
vector<int> euler, first, inOrder, revOrder, last;
vector<vector<int>> adj;
int wkt;
vector<bool> visited;
void dfs(int u) {
visited[u] = true;
inOrder[u] = wkt++;
first[u] = euler.size();
rsq->update(first[u], nodeVal[u]);
last[u] = first[u];
revOrder[inOrder[u]] = u;
euler.push_back(inOrder[u]);
for (int v : adj[u])
if (!visited[v]) {
dfs(v);
last[u] = euler.size();
euler.push_back(inOrder[u]);
}
rsq->update(last[u] + 1, -nodeVal[u]);
}
};
template <typename T>
struct FenwickTreeSum {
public:
vector<T> ft;
FenwickTreeSum(int n) { ft.assign(n + 1, 0); }
FenwickTreeSum(vector<T> arr) {
int n = arr.size();
ft.assign(n + 1, 0);
for (int i = 0; i < n; i++) update(i, arr[i]);
}
T query(int b) {
b++;
T sum = 0;
for (; b; b -= LSOne(b)) sum = op(sum, ft[b]);
return sum;
}
T rangeQuery(int a, int b) {
return invOp(query(b), (a == 0 ? 0 : query(a - 1)));
}
void update(int k, T v) {
k++;
for (; k < ft.size(); k += LSOne(k)) ft[k] = op(ft[k], v);
}
private:
int LSOne(int x) { return x & (-x); }
T op(const T &a, const T &b) { return a + b; }
T invOp(const T &a, const T &b) { return a - b; }
};
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
debug = argc > 1;
int n, q, p;
cin >> n >> q;
vector<int> nodeVal(n, 1);
TreePathQuerySum<int, FenwickTreeSum<int>> lca(nodeVal, 0);
for (int i = 1; i < n; i++) {
cin >> p;
p--;
lca.addEdge(p, i);
}
lca.build();
int a, b, c;
while (q--) {
cin >> a >> b >> c;
a--, b--, c--;
int maxi = 0;
vector<int> endPoint = {a, b, c};
sort(endPoint.begin(), endPoint.end());
do {
int s = endPoint[0], t = endPoint[1], f = endPoint[2];
int res = (lca.queryIn(s, f) + lca.queryIn(t, f) - lca.queryEx(s, t)) / 2;
maxi = max(maxi, res);
} while (next_permutation(endPoint.begin(), endPoint.end()));
cout << maxi << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
string to_string(char s) {
string res = "'''";
res[1] = s;
return res;
}
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = 1;
string res = "{";
for (const auto& x : v) {
if (!first) res += ", ";
first = 0;
res += to_string(x);
}
res += "}";
return res;
}
void debug() { cout << "\n"; }
template <typename Head, typename... Tail>
void debug(Head H, Tail... T) {
cout << " " << to_string(H);
debug(T...);
}
const long long int MOD = 1e9 + 7;
inline long long int add(long long int a, long long int b,
long long int p = MOD) {
a = a + b;
if (a >= p) a -= p;
return a;
}
inline long long int sub(long long int a, long long int b,
long long int p = MOD) {
a = a - b;
if (a < 0) a += p;
return a;
}
inline long long int mul(long long int a, long long int b,
long long int p = MOD) {
a = (a * 1ll * b) % p;
return a;
}
const ld pi = acos(-1), eps = 1e-9;
const ll inf = 1e18;
const long long int N = 2e5 + 5;
long long int tree[4 * N];
void point_update(long long int node, long long int beg, long long int en,
long long int idx, long long int val) {
if (beg == en) {
tree[node] += val;
return;
}
long long int mid = (beg + en) / 2;
if (beg <= idx && idx <= mid)
point_update(2 * node, beg, mid, idx, val);
else
point_update(2 * node + 1, mid + 1, en, idx, val);
tree[node] = tree[2 * node] + tree[2 * node + 1];
}
long long int range_query(long long int node, long long int beg,
long long int en, long long int l, long long int r) {
if (r < beg || en < l) return 0;
if (l <= beg && en <= r) return tree[node];
long long int mid = (beg + en) / 2;
long long int q1 = range_query(2 * node, beg, mid, l, r);
long long int q2 = range_query(2 * node + 1, mid + 1, en, l, r);
return (q1 + q2);
}
void init(long long int n) {
for (long long int i = 0; i < (4 * n + 3); ++i) tree[i] = 0;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int i = 0; i < (n); ++i) cin >> v[i];
map<long long int, long long int> compress;
for (auto c : v) compress[c];
long long int cnt = 0;
for (auto& c : compress) c.second = ++cnt;
init(cnt);
long long int dp[n + 1][2];
memset(dp, 0, sizeof(dp));
for (long long int i = (1); i <= (n); ++i) {
for (long long int j = 0; j < (2); ++j)
dp[i][j] = min(dp[i - 1][0], dp[i - 1][1]);
long long int val = compress[v[i - 1]];
dp[i][0] += range_query(1, 1, cnt, 1, val - 1);
dp[i][1] += range_query(1, 1, cnt, val + 1, cnt);
point_update(1, 1, cnt, val, 1);
}
long long int ans = min(dp[n][0], dp[n][1]);
cout << ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long int t = 1;
cin >> t;
for (long long int z = 1; z <= t; ++z) {
solve();
cout << "\n";
}
return 0;
}
| 5 |
#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<queue>
using namespace std;
int x[300][50];
int y[300][50];
double ijk[300];
int v[300];
int size[300];
const double EPS=1e-10;
const double INF=1e+10;
const double PI=acos(-1);
int sig(double r){return (r<-EPS)?-1:(r>+EPS)?+1:0;}
double Abs(double a){return max(a,-a);}
struct Pt{
double x,y;
Pt(){}
Pt(double x,double y):x(x),y(y){}
Pt operator+(const Pt &a)const{return Pt(x+a.x,y+a.y);}
Pt operator-(const Pt &a)const{return Pt(x-a.x,y-a.y);}
Pt operator*(const Pt &a)const{return Pt(x*a.x-y*a.y,x*a.y+y*a.x);}
Pt operator-()const{return Pt(-x,-y);}
Pt operator*(const double &k)const{return Pt(x*k,y*k);}
Pt operator/(const double &k)const{return Pt(x/k,y/k);}
double Abs()const{return sqrt(x*x+y*y);}
double Abs2()const{return x*x+y*y;}
double arg()const{return atan2(y,x);}
double dot(const Pt &a)const{return x*a.x+y*a.y;}
double det(const Pt &a)const{return x*a.y-y*a.x;}
};
Pt point[300][50];
double tri(const Pt&a,const Pt&b,const Pt&c){return (b-a).det(c-a);}
int iSP(Pt a,Pt b,Pt c){
int s=sig((b-a).det(c-a));
if(s)return s;
if(sig((b-a).dot(c-a))<0)return -2;
if(sig((a-b).dot(c-b))<0)return +2;
return 0;
}
bool iSS(Pt a,Pt b,Pt c,Pt d){
return (iSP(a,b,c)*iSP(a,b,d)<=0&&iSP(c,d,a)*iSP(c,d,b)<=0);
}
double dSP(Pt a,Pt b,Pt c){
if(sig((b-a).dot(c-a))<=0)return (c-a).Abs();
if(sig((a-b).dot(c-b))<=0)return (c-b).Abs();
return Abs(tri(a,b,c))/(b-a).Abs();
}
double dSS(Pt a,Pt b,Pt c,Pt d){
return iSS(a,b,c,d)?0:min(min(dSP(a,b,c),dSP(a,b,d)),min(dSP(c,d,a),dSP(c,d,b)));
}
double dist[300][300];
int main(){
int a,b;
while(scanf("%d%d",&a,&b),a){
for(int i=0;i<b;i++){
int c;
scanf("%d",&c);
size[i]=c;
for(int j=0;j<c;j++){
scanf("%d%d",&y[i][j],&x[i][j]);
point[i][j]=Pt(x[i][j],y[i][j]);
}
}
for(int i=0;i<300;i++){
for(int j=0;j<300;j++){
if(i==j)dist[i][j]=0;
else dist[i][j]=999999999;
}
}
dist[b][b+1]=a;
for(int i=0;i<b;i++){
for(int j=0;j<size[i];j++){
dist[b][i]=dist[i][b]=min(dist[b][i],point[i][j].y);
dist[b+1][i]=dist[i][b+1]=min(dist[b+1][i],a-point[i][j].y);
}
}
for(int i=0;i<b;i++){
for(int j=i+1;j<b;j++){
for(int k=0;k<size[i];k++)
for(int l=0;l<size[j];l++)
dist[i][j]=dist[j][i]=min(dist[i][j],dSS(point[i][k],point[i][(k+1)%size[i]],point[j][l],point[j][(l+1)%size[j]]));
}
}
for(int k=0;k<b+2;k++)
for(int i=0;i<b+2;i++)
for(int j=0;j<b+2;j++)
dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]);
printf("%.8f\n",dist[b][b+1]);
}
} | 0 |
#include <bits/stdc++.h>
const int N = 100005, mu = 1e9 + 7;
int g[2][2][2], st[N], tp, a[N][2], type[N], vis[N], c[2], dp[2][2];
int d[N], n, m, k, x;
std::vector<int> e[N], v[N];
void reduce(int &x) { x += x >> 31 & mu; }
void dfs(int x) {
vis[x] = 1, st[++tp] = x;
for (auto u : e[x])
if (!vis[u]) dfs(u);
}
void Dp(int sl, int sr, int tl, int tr) {
int now = 0;
memset(g[now], 0, sizeof(g[now]));
for (int i = sl; i <= sr; i++) g[now][0][i] = 1;
int x = st[1], nxt = st[2];
if ((!a[x][1]) ||
(abs(a[x][1]) != abs(a[nxt][0])) && (abs(a[x][1]) != abs(a[nxt][1])))
std::swap(a[x][0], a[x][1]);
for (int i = 2; i <= tp; i++)
if (abs(a[st[i - 1]][1]) != abs(a[st[i]][0]))
std::swap(a[st[i]][0], a[st[i]][1]);
for (int i = 1; i <= tp; i++) {
int x = st[i];
now = now ^ 1;
memset(g[now], 0, sizeof(g[now]));
for (int lst = 0; lst <= 1; lst++)
for (int s = 0; s <= 1; s++) {
int t = g[now ^ 1][s][lst];
if (!t) continue;
for (int j = 0; j <= 1; j++) {
int l = lst, r = j;
if (a[x][0] < 0) l = l ^ 1;
if (a[x][1] < 0) r = r ^ 1;
reduce(g[now][s ^ (l | r)][j] += t - mu);
}
}
}
for (int i = 0; i <= 1; i++)
for (int j = tl; j <= tr; j++) reduce(c[i] += g[now][i][j] - mu);
}
void solve(int x) {
c[0] = c[1] = 0;
tp = 0;
dfs(x);
if (tp == 1) {
int t = st[1];
if (type[t] == 1)
c[0] = c[1] = 1;
else {
if (abs(a[t][0]) != abs(a[t][1]))
c[0] = 1, c[1] = 3;
else if (a[t][0] == a[t][1])
c[0] = c[1] = 1;
else
c[1] = 2;
}
return;
}
int rt = 0;
for (int i = 1; i <= tp; i++)
if (d[st[i]] == 1) rt = st[i];
if (rt) {
for (int i = 1; i <= tp; i++) vis[st[i]] = 0;
tp = 0, dfs(rt);
int x = st[1], sl = 0, sr = 1, tl = 0, tr = 1;
if (type[x] == 1) sr = 0, type[x] = 2;
x = st[tp];
if (type[x] == 1) tr = 0, type[x] = 2;
Dp(sl, sr, tl, tr);
return;
}
Dp(0, 0, 0, 0), Dp(1, 1, 1, 1);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &k);
type[i] = k;
for (int j = 0; j < k; j++) {
scanf("%d", &x);
a[i][j] = x;
v[abs(x)].push_back(i);
}
}
int ans = 1;
for (int i = 1; i <= m; i++)
if (!(v[i].size()))
ans = ans * 2ll % mu;
else if (v[i].size() == 2) {
int x = v[i][0], y = v[i][1];
e[x].push_back(y), e[y].push_back(x);
d[x]++, d[y]++;
}
dp[0][0] = 1;
int now = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
solve(i);
now = now ^ 1, dp[now][0] = dp[now][1] = 0;
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++)
reduce(dp[now][j ^ k] += (long long)dp[now ^ 1][j] * c[k] % mu - mu);
}
ans = (long long)ans * dp[now][1] % mu;
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[100005];
int main() {
long long int n, m;
scanf("%lld%lld", &n, &m);
set<long long int> S;
for (long long int i = 1; i <= m; i++) {
long long int v;
scanf("%lld", &v);
arr[v]++;
S.insert(v);
if (S.size() == n) {
printf("1");
for (long long int j = 1; j <= n; j++) {
arr[j]--;
if (arr[j] == 0) S.erase(j);
}
} else
printf("0");
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n, m;
int a, b;
for (int q = 0; q < t; q++) {
long long hasil = 0;
int genap = 0, ganjil = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
if (a % 2 == 0) {
genap++;
} else {
ganjil++;
}
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> b;
if (b % 2 == 0) {
hasil += genap;
} else {
hasil += ganjil;
}
}
cout << hasil << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 9;
const int Mod = 1e9 + 7;
inline int scan() {
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;
}
inline long long scan(long long x) {
int f = 1;
char ch = getchar();
x = 0;
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 n, m;
int ans, tp;
int mp[55][55], mk;
void solve() {
n = scan();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) mp[i][j] = scan();
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (mp[i][j] != 1) {
mk = 0;
for (int l = 1; l <= n; l++) {
for (int k = 1; k <= n; k++) {
if (mp[i][j] == mp[l][j] + mp[i][k]) mk = 1;
}
}
if (!mk) {
cout << "NO" << endl;
return;
}
}
}
}
cout << "YES" << endl;
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long n, mod[40], m[N], tmp, ans;
map<long long, int> freq;
void start() {
long long ans = 1;
for (int i = 1; i <= 34; i++) {
mod[i] = ans;
ans *= 2;
}
return;
}
int main() {
start();
scanf("%I64d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &m[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 34; j++) {
tmp = mod[j] - m[i];
if (tmp > 0) {
ans += (freq[tmp]);
}
}
freq[m[i]]++;
}
printf("%I64d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, s1 = 0, s2 = 0, i;
cin >> t;
while (t--) {
s1 = 0;
s2 = 0;
cin >> n;
s1 = (long long)pow(2, n);
for (i = 1; i <= n / 2 - 1; i++) s1 = s1 + (long long)pow(2, i);
for (i = n / 2; i < n; i++) s2 = s2 + (long long)pow(2, i);
cout << abs(s1 - s2) << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int p1, p2, p3, p4, a, b;
cin >> p1 >> p2 >> p3 >> p4 >> a >> b;
long long int p = min(p1, min(p2, min(p3, p4)));
long long int ans = 0;
if (p >= a && p <= b) ans = max(ans, p - a);
if (p > b) ans = max(ans, b - a + 1);
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m;
bool mark[maxn], on[maxn];
int ans = 1e9, qtd;
bool ok;
char C;
vector<pair<int, char> > grafo[maxn];
vector<int> V, comp;
void dfs(int u) {
comp.push_back(u);
mark[u] = true;
if (on[u]) ++qtd;
for (auto pp : grafo[u]) {
int v = pp.first, c = pp.second;
if (mark[v]) {
if ((!on[u] && on[v]) || (on[u] && !on[v])) {
if (c == C) ok = false;
} else {
if (c != C) ok = false;
}
continue;
}
if ((on[u] && c == C) || (!on[u] && c != C))
on[v] = true;
else
on[v] = false;
dfs(v);
}
}
int getmin(int u) {
int q1 = 1e9, q2 = 1e9;
comp.clear();
ok = true, qtd = 0, on[u] = false;
dfs(u);
if (ok) q1 = qtd;
for (auto v : comp) mark[v] = false;
comp.clear();
ok = true, qtd = 0, on[u] = true;
dfs(u);
if (ok) q2 = qtd;
if (q1 == 1e9 && q2 == 1e9) return -1;
if (q1 < q2) {
for (auto v : comp) mark[v] = false;
on[u] = false;
dfs(u);
}
return min(q1, q2);
}
void get(char c) {
C = c;
memset(mark, 0, sizeof mark);
memset(on, 0, sizeof on);
int tot = 0;
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
int x = getmin(i);
if (x == -1) return;
tot += x;
}
}
if (tot < ans) {
ans = tot;
V.clear();
for (int i = 1; i <= n; i++)
if (on[i]) V.push_back(i);
}
}
int main(void) {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
char c;
scanf("%d %d %c", &u, &v, &c);
grafo[u].push_back({v, c});
grafo[v].push_back({u, c});
}
get('R');
get('B');
if (ans == 1e9)
printf("-1\n");
else {
printf("%d\n", ans);
for (auto u : V) printf("%d ", u);
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, x, k, r, t, u;
cin >> l >> x;
bool done = false;
vector<vector<int> > w;
for (int i = 1; i <= 9 && !done; i++) {
vector<int> v;
k = i;
r = 0;
for (int j = 0; j < l; j++) {
v.push_back(k);
t = (k * x + r) / 10;
u = (k * x + r) % 10;
r = t;
k = u;
}
if (r == 0 && k == i && v[v.size() - 1] != 0) {
reverse(v.begin(), v.end());
w.push_back(v);
done = true;
}
}
if (!done)
cout << "Impossible";
else {
sort(w.begin(), w.end());
for (int i = 0; i < w[0].size(); i++) cout << w[0][i];
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
bool a[10]={};
bool ok(int x){
while(x != 0){
if(a[x%10]) return false;
x /= 10;
}
return true;
}
int main(){
int n,k,tp;
cin>>n>>k;
for(int i=0;i<k;i++){
cin>>tp;
a[tp]=true;
}
while(!ok(n)) n++;
cout << n << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int LINF = 0x3f3f3f3f3f3f3f3fll;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
int n;
vector<int> sobra;
int main() {
scanf("%d", &n);
int n0 = 0, n1 = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (x % 2 == 0) {
for (int i = 0; i < x / 2; i++) {
int y;
scanf("%d", &y);
n0 += y;
}
for (int i = 0; i < x / 2; i++) {
int y;
scanf("%d", &y);
n1 += y;
}
} else {
for (int i = 0; i < x / 2; i++) {
int y;
scanf("%d", &y);
n0 += y;
}
int y;
scanf("%d", &y);
sobra.push_back(y);
for (int i = 0; i < x / 2; i++) {
int y;
scanf("%d", &y);
n1 += y;
}
}
}
bool j1 = true;
sort(sobra.begin(), sobra.end());
while (sobra.size() > 0) {
if (j1) {
n0 += sobra.back();
} else {
n1 += sobra.back();
}
j1 = !j1;
sobra.pop_back();
}
cout << n0 << " " << n1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define for_(i,a,b) for(int i=(a);i<(b);++i)
struct Edge { int v, f; };
int n, m, f[110][110];
int getCost(vector< int > X) {
if (X.size() == 1) return 0;
int ret = 0;
for (int v : X) {
int add = 1L << 30;
for (int u : X) if (u != v) add = min(add, f[u][v]);
ret += add;
}
return ret;
}
int main() {
cin >> n >> m;
vector< vector< int > > adj(n, vector< int >());
for_(i,0,m) {
int u, v, c;
cin >> u >> v >> c;
--u; --v;
adj[u].push_back(v);
adj[v].push_back(u);
f[u][v] = f[v][u] = c;
}
vector< int > order(n);
iota(order.begin(), order.end(), 0);
sort(order.begin(), order.end(), [&](int i, int j) { return adj[i].size() < adj[j].size(); });
int ans = 0;
for_(v,0,n) {
int k = adj[v].size();
for_(S,0,(1<<k)) {
vector< int > X = {v};
for_(i,0,k) if (S >> i & 1) X.push_back(adj[v][i]);
ans = max(ans, getCost(X));
}
}
cout << ans << endl;
} | 0 |
#include<iostream>
#include<cstring>
using namespace std;
int t[55][55];
int main(){
int n,m;
int i,j,k;
int a,b,c;
while(cin>>n>>m){
if(!n)break;
memset(t,0,sizeof(t));
for(i=0;i<n;i++)t[0][i]=n-i;
for(i=0;i<m;i++){
cin>>a>>b;
for(j=0;j<n;j++){
if(j<b)t[i+1][j]=t[i][a+j-1];
else if(j<a+b-1)t[i+1][j]=t[i][j-b];
else t[i+1][j]=t[i][j];
}
}
cout<<t[m][0]<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int d1[3];
int d2[3];
int d_min[3];
int d_max[3];
int mons[] = {1, 3, 5, 7, 8, 10, 12};
int determine_less() {
for (int i = 0; i < 3; i++) {
if (d1[i] < d2[i])
return -1;
else if (d1[i] > d2[i])
return 1;
}
return 0;
}
bool large_month(int mon) {
for (int i = 0; i < 7; i++) {
if (mons[i] == mon) return true;
}
return false;
}
bool leap_year(int year) {
if (year % 400 == 0) return true;
if (year % 100 == 0) return false;
if (year % 4 == 0) return true;
return false;
}
int num_days() {
if (d_min[0] == d_max[0] && d_min[1] == d_max[1] && d_min[2] == d_max[2]) {
return 0;
}
if (d_min[1] != 2) {
if (d_min[2] < 30) {
d_min[2]++;
return 1 + num_days();
} else if (large_month(d_min[1]) && d_min[2] < 31) {
d_min[2]++;
return 1 + num_days();
} else {
if (d_min[1] != 12) {
d_min[2] = 1;
d_min[1]++;
return 1 + num_days();
} else {
d_min[0]++;
d_min[1] = 1;
d_min[2] = 1;
return 1 + num_days();
}
}
} else {
if (d_min[2] < 28) {
d_min[2]++;
return 1 + num_days();
} else {
if (d_min[2] == 28 && leap_year(d_min[0])) {
d_min[2]++;
return 1 + num_days();
} else {
d_min[1]++;
d_min[2] = 1;
return 1 + num_days();
}
}
}
}
int main() {
int d1_d2;
scanf("%d:%d:%d", &d1[0], &d1[1], &d1[2]);
scanf("%d:%d:%d", &d2[0], &d2[1], &d2[2]);
d1_d2 = determine_less();
if (d1_d2 == 0) {
cout << 0;
return 0;
}
if (d1_d2 == -1) {
for (int i = 0; i < 3; i++) {
d_min[i] = d1[i];
d_max[i] = d2[i];
}
} else {
for (int i = 0; i < 3; i++) {
d_min[i] = d2[i];
d_max[i] = d1[i];
}
}
int res = 0;
res = num_days();
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
mt19937 rng(std::chrono::system_clock::now().time_since_epoch().count());
int n, x, y, ans[N], delta[N];
int find(int a) {
int l = 2, r = 1000;
while (l <= r) {
int mid = (l + r) / 2;
int temp = mid * (mid - 1) / 2;
if (temp == a) return mid;
if (temp < a)
l = mid + 1;
else
r = mid - 1;
}
return 0;
}
int main() {
int nx, ny;
scanf("%d%d%d", &n, &x, &y);
for (int i = 1; i < n; i++) {
cout << "+ " << i << endl;
cin >> nx >> ny;
delta[i] = ny - y;
if (nx - x > 0) ans[i] = find(nx - x);
x = nx;
y = ny;
}
cout << "+ 1" << endl;
cin >> nx >> ny;
if (nx - x) ans[1] = find(nx - x) - 1;
int temp = ny - y - delta[1] - 1;
if (ans[2])
ans[3] = temp - ans[2];
else if (ans[3])
ans[2] = temp - ans[3];
else if (temp == 2)
ans[2] = ans[3] = 1;
else if (temp == 1 && delta[2])
ans[3] = 1;
else if (temp == 1)
ans[2] = 1;
for (int i = 4; i < n; i++) {
if (ans[i]) continue;
ans[i] = delta[i - 1] != (ans[i - 2] + 1) * (ans[i - 3] + 1);
}
ans[n] =
(delta[n - 1] - (ans[n - 2] + 1) * (ans[n - 3] + 1)) / (ans[n - 2] + 1);
cout << "! ";
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 6 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <map>
using namespace std;
int t;
string a;
bool check(int x){
map<string ,int> v;
for(int i=1;i<=t+1-x;i++){
string s=a.substr(i-1,x);
if(v[s]){
if(i-v[s]>=x){
return true;
}
}else{
v[s]=i;
}
}
return false;
}
int main(){
cin>>t>>a;
int l=0,r=t/2;
while(l<=r){
int mid=(l+r)/2;
if(check(mid)){
l=mid+1;
}else{
r=mid-1;
}
}
cout<<r<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int a[N], b;
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int k = 0, l = 0;
for (int i = 1; i <= n; ++i) {
cin >> b;
if (b != a[i]) {
k += a[i];
l += b;
}
}
if (l == n || k == 0)
cout << -1 << endl;
else
cout << l / k + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m, dp[N], sm[N], sdp[N];
int tot, fi[N], a[N], ne[N];
struct Mt {
int x, y, v;
};
vector<Mt> g[N];
inline int read() {
char c = getchar();
int x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
return x;
}
inline void add(int x, int y) {
a[++tot] = y;
ne[tot] = fi[x];
fi[x] = tot;
}
int si[N], ms[N], de[N], tp[N], fa[N];
inline void get_ms(int x, int pa) {
si[x] = 1;
fa[x] = pa;
de[x] = de[pa] + 1;
for (int i = fi[x]; i; i = ne[i])
get_ms(a[i], x), si[x] += si[a[i]],
ms[x] = si[a[i]] > si[ms[x]] ? a[i] : ms[x];
}
inline void get_tp(int x, int top) {
tp[x] = top;
if (ms[x]) get_tp(ms[x], top);
for (int i = fi[x]; i; i = ne[i])
if (a[i] != ms[x]) get_tp(a[i], a[i]);
}
inline int get_lca(int x, int y) {
while (tp[x] != tp[y])
if (de[tp[x]] > de[tp[y]])
x = fa[tp[x]];
else
y = fa[tp[y]];
return de[x] > de[y] ? y : x;
}
inline int jp(int x, int o) {
int ans = 0;
while (tp[x] != tp[o])
ans += (sm[tp[x]] - sm[ms[x]]) - (sdp[tp[x]] - sdp[ms[x]]), x = fa[tp[x]];
return ans + (sm[o] - sm[ms[x]]) - (sdp[ms[o]] - sdp[ms[x]]);
}
inline void solve(int x) {
for (int i = fi[x]; i; i = ne[i]) solve(a[i]), sm[x] += dp[a[i]];
dp[x] = sm[x];
sm[x] += sm[ms[x]];
for (vector<Mt>::iterator it = g[x].begin(); it != g[x].end(); ++it)
dp[x] = max(dp[x], jp(it->x, x) + jp(it->y, x) - sm[x] + sm[ms[x]] + it->v);
sdp[x] = sdp[ms[x]] + dp[x];
}
int main() {
n = read();
m = read();
int x, y, z;
for (int i = 2; i <= n; ++i) add(read(), i);
get_ms(1, 0);
get_tp(1, 1);
for (int i = 1; i <= m; ++i) {
x = read();
y = read();
z = read();
g[get_lca(x, y)].push_back((Mt){x, y, z});
}
solve(1);
printf("%d\n", dp[1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main(){
int N;
std::cin >> N;
std::cout << N*N*N << std::endl;
} | 0 |
#include<string>
#include<iostream>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const string INF="NO";
struct Edge{ int u,v; string w; };
int n,m,s,g;
Edge E[400];
string BackwardBellmanFord(){
string d[40];
rep(u,n) d[u]=(u==g?"":INF);
rep(k,6*n+1){
bool changed=false;
rep(i,m){
int u=E[i].u,v=E[i].v;
string nextd=E[i].w+d[v];
if(d[v]!=INF && (d[u]==INF || nextd<d[u])){
d[u]=nextd;
changed=true;
if(u==s && k>=n) return INF;
}
}
if(!changed) break;
}
return d[s];
}
int main(){
while(cin>>n>>m>>s>>g,n){
rep(i,m) cin>>E[i].u>>E[i].v>>E[i].w;
cout<<BackwardBellmanFord()<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e1 + 5;
int main() {
int n;
cin >> n;
map<string, int> mp1, mp2, mp3;
vector<pair<string, int>> vec;
for (int i = 0; i < n; i++) {
string s;
int k;
cin >> s >> k;
mp1[s] += k;
vec.push_back({s, k});
}
string ans;
long long mx = -1e18;
for (auto v : mp1)
if (v.second > mx) {
mx = v.second;
ans = v.first;
}
long long cnt = 0;
for (auto v : mp1)
if (v.second == mx) cnt++, mp3[v.first];
if (cnt == 1)
cout << ans;
else {
for (int i = 0; i < n; i++) {
mp2[vec[i].first] += vec[i].second;
if (mp3.find(vec[i].first) != mp3.end() && mp2[vec[i].first] >= mx) {
cout << vec[i].first;
break;
}
}
}
}
| 1 |
#include<iostream>
using namespace std;
#define M 101
#define INF 100000003
#define min(a,b) (a<b?a:b)
int main() {
int n, m, a, b, c, t, pn, p, q, r;
int dc[M][M], dt[M][M];
while(1) {
cin >> n >> m;
if(!n&&!m) break;
for(int i=1; i<=m; ++i) {
for(int j=1; j<=m; ++j) {
dc[i][j] = dt[i][j] = INF;
}
}
for(int i=0; i<n; ++i) {
cin >> a >> b >> c >> t;
dc[a][b] = dc[b][a] = c;
dt[a][b] = dt[b][a] = t;
}
for(int k=1; k<=m; ++k) {
for(int i=1; i<=m; ++i) {
for(int j=1; j<=m; ++j) {
dc[i][j] = min(dc[i][j], dc[i][k]+dc[k][j]);
dt[i][j] = min(dt[i][j], dt[i][k]+dt[k][j]);
}
}
}
cin >> pn;
for(int i=0; i<pn; ++i) {
cin >> p >> q >> r;
cout << (!r ? dc[p][q] : dt[p][q]) << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long m[n];
for (long long i = 0; i < n; i++) {
cin >> m[i];
}
vector<long long> ls(n);
stack<pair<long long, long long> > s;
for (long long i = 0; i < n; i++) {
while (!s.empty() && s.top().first >= m[i]) {
s.pop();
}
if (s.empty())
ls[i] = -1;
else
ls[i] = s.top().second;
s.push({m[i], i});
}
vector<long long> rs(n);
while (!s.empty()) s.pop();
for (long long i = n - 1; i >= 0; i--) {
while (!s.empty() && s.top().first >= m[i]) s.pop();
if (s.empty())
rs[i] = -1;
else
rs[i] = s.top().second;
s.push({m[i], i});
}
long long l[n];
for (long long i = 0; i < n; i++) {
if (ls[i] == -1)
l[i] = (i + 1) * m[i];
else {
long long j = ls[i];
l[i] = l[j] + (i - j) * m[i];
}
}
long long r[n];
for (long long i = n - 1; i >= 0; i--) {
if (rs[i] == -1)
r[i] = (n - i) * m[i];
else {
long long j = rs[i];
r[i] = r[j] + (j - i) * m[i];
}
}
long long floors = 0, index = -1;
for (long long i = 0; i < n; i++) {
if (l[i] + r[i] - m[i] > floors) {
floors = l[i] + r[i] - m[i];
index = i;
}
}
long long ans[n];
ans[index] = m[index];
long long last = m[index];
for (long long j = index - 1; j >= 0; j--) {
if (m[j] >= last) {
ans[j] = last;
} else {
ans[j] = m[j];
last = m[j];
}
}
last = m[index];
for (long long j = index + 1; j < n; j++) {
if (m[j] >= last) {
ans[j] = last;
} else {
ans[j] = m[j];
last = m[j];
}
}
for (long long i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#define pb push_back
#define ll long long
#define mp make_pair
#define inf 1000000007
#define ll long long
using namespace std;
signed main(){
vector< pair<ll,ll> > v;
ll n;
cin>>n;
for(ll i=1;i<=n;i++){
ll x;
cin>>x;
v.pb( mp(x,i) );
}
sort(v.begin(),v.end());
reverse(v.begin(),v.end());
v.pb(mp(0,0));
vector<ll> a;
for(ll i=0;i<=n;i++){
a.pb(0);
}
priority_queue<ll> que;
for(ll i=0;i<n;i++){
que.push( -v[i].second );
ll idx = -que.top();
a[idx] += (v[i].first-v[i+1].first) * (i+1);
}
for(ll i=1;i<=n;i++){
cout<<a[i]<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int l[N], e[N];
int main() {
int n, m, cl, ce, v;
cin >> n >> m >> cl >> ce >> v;
for (int i = 0; i < cl; i++) scanf("%d", &l[i]);
l[cl] = m + 1;
cl += 1;
for (int i = 0; i < ce; i++) scanf("%d", &e[i]);
e[ce] = m + 1;
ce += 1;
int q;
int x1, x2, y1, y2;
cin >> q;
while (q--) {
scanf("%d%d%d%d", &y1, &x1, &y2, &x2);
int ans = 1e9 + 7;
int p = lower_bound(l, l + cl, x1) - l;
int temp;
if (p != cl - 1) {
temp = abs(x1 - l[p]) + abs(x2 - l[p]) + abs(y1 - y2);
ans = min(ans, temp);
}
p -= 1;
if (p >= 0) {
temp = abs(x1 - l[p]) + abs(x2 - l[p]) + abs(y1 - y2);
ans = min(ans, temp);
}
p = lower_bound(e, e + ce, x1) - e;
if (p != ce - 1) {
temp = abs(x1 - e[p]) + abs(x2 - e[p]);
temp += abs(y1 - y2) / v;
if (abs(y1 - y2) % v) temp += 1;
ans = min(ans, temp);
}
p -= 1;
if (p >= 0) {
temp = abs(x1 - e[p]) + abs(x2 - e[p]);
temp += abs(y1 - y2) / v;
if (abs(y1 - y2) % v) temp += 1;
ans = min(ans, temp);
}
if (y1 == y2) ans = abs(x1 - x2);
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
#define loop(i,a,b) for(int i=(a);i<ull(b);++i)
#define rep(i,n) loop(i,0,n)
bool isIn(int x, int y, int n, int m){
return 0 <= x && x <= n && 0 <= y && y <= m;
}
int main(){
int n;
cin >> n;
for(int q=0; q < n; q++){
int gx, gy;
cin >> gx >> gy;
int m;
cin >> m;
bool passable[20][20][20][20];
rep(i, 20)rep(j, 20)rep(k, 20)rep(l, 20) passable[i][j][k][l] = true;
rep(i, m){
int a, b, c, d;
cin >> a >> b >> c >> d;
passable[a][b][c][d] = false; passable[c][d][a][b] = false;
}
int dp[20][20];
rep(i, 20)rep(j, 20) dp[i][j] = 0;
dp[0][0] = 1;
for(int i = 0; i <= gy; i++){
for(int j = 0; j <= gx; j++){
if(isIn(j, i-1, gx, gy) && passable[j][i-1][j][i]) dp[i][j] += dp[i-1][j];
if(isIn(j-1, i, gx, gy) && passable[j-1][i][j][i]) dp[i][j] += dp[i][j-1];
}
}
if(dp[gy][gx] == 0) cout << "Miserable Hokusai!" << endl;
else cout << dp[gy][gx] << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long a, b;
cin >> a >> b;
cout << "YES" << endl;
for (long long i = a; i <= b; i += 2) cout << i << " " << i + 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
char s[N * 2], a[N], b[N];
vector<int> P, P1;
int n, m;
struct Tri {
int st, delta, len;
int val;
Tri() {}
Tri(int st1, int delta1, int len1) {
st = st1;
delta = delta1;
len = len1;
}
friend bool operator==(Tri x, Tri y) { return x.delta == y.delta; }
};
struct Data {
int v, pos;
Data() {}
Data(int v1, int pos1) {
v = v1;
pos = pos1;
}
friend bool operator<(Data x, Data y) { return x.v < y.v; }
} pl[N * 2], gpl[N * 2];
vector<Tri> G, G1, G2;
void dp_nlogn(int n) {
int r;
Tri x;
Data tmp;
for (int i = 1; i <= n; ++i) pl[i] = gpl[i] = Data(n + 1, -1);
pl[0] = Data(0, 0);
G.clear();
for (int j = 1; j <= n; ++j) {
G1.clear();
for (int i = 0; i < G.size(); ++i) {
x = G[i];
if (x.st > 1 && s[x.st - 1] == s[j])
G1.push_back(Tri(x.st - 1, x.delta, x.len));
}
G2.clear();
r = -j;
for (int i = 0; i < G1.size(); ++i) {
x = G1[i];
if (x.st - r != x.delta) {
G2.push_back(Tri(x.st, x.st - r, 1));
if (x.len > 1) G2.push_back(Tri(x.st + x.delta, x.delta, x.len - 1));
} else
G2.push_back(x);
r = x.st + (x.len - 1) * x.delta;
}
if (j > 1 && s[j - 1] == s[j]) {
G2.push_back(Tri(j - 1, j - 1 - r, 1));
r = j - 1;
}
G2.push_back(Tri(j, j - r, 1));
G.clear();
x = G2[0];
for (int i = 1; i < G2.size(); ++i) {
if (G2[i] == x)
x.len += G2[i].len;
else {
G.push_back(x);
x = G2[i];
}
}
G.push_back(x);
if (j % 2 == 0) {
if (s[j] == s[j - 1]) pl[j] = min(pl[j], Data(pl[j - 2].v, j - 2));
}
for (int i = 0; i < G.size(); ++i) {
x = G[i];
r = x.st + (x.len - 1) * x.delta;
if (r & 1)
tmp = Data(pl[r - 1].v + 1, r - 1);
else
tmp = Data(n + 1, -1);
if (x.delta <= x.st) {
if (x.len > 1) tmp = min(tmp, gpl[x.st - x.delta]);
gpl[x.st - x.delta] = tmp;
}
if (j % 2 == 0) pl[j] = min(pl[j], tmp);
}
}
}
int main() {
scanf("%s", a + 1);
scanf("%s", b + 1);
n = strlen(a + 1);
for (int i = 1, pos = 1; i <= n; ++i, pos += 2) s[pos] = a[i];
n = strlen(b + 1);
for (int i = 1, pos = 2; i <= n; ++i, pos += 2) s[pos] = b[i];
n = strlen(s + 1);
dp_nlogn(n);
if (pl[n].v > n)
printf("-1\n");
else {
printf("%d\n", pl[n].v);
for (int i = n; i >= 1; i = pl[i].pos)
if (i - pl[i].pos > 2) {
printf("%d %d\n", pl[i].pos / 2 + 1, i / 2);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[100005];
struct Tree {
char c;
int next[26];
bool en;
int dep;
} tree[100005];
int tot = 1;
struct Queue {
int dep;
bool operator<(const Queue &c) const { return dep < c.dep; }
} tmp;
priority_queue<Queue> q[100005];
void Add(char s[]) {
int len = strlen(s + 1);
int p = 1;
for (int i = 1; i <= len; i++) {
if (tree[p].next[s[i] - 'a'] == 0) {
tot++;
tree[tot].dep = tree[p].dep + 1;
tree[p].next[s[i] - 'a'] = tot;
p = tot;
} else
p = tree[p].next[s[i] - 'a'];
}
tree[p].en = 1;
}
void dfs(int i) {
for (int k = 0; k < 26; k++)
if (tree[i].next[k]) dfs(tree[i].next[k]);
for (int k = 0; k < 26; k++)
if (tree[i].next[k])
while (!q[tree[i].next[k]].empty()) {
tmp = q[tree[i].next[k]].top();
q[tree[i].next[k]].pop();
q[i].push(tmp);
}
if (tree[i].en) {
tmp.dep = tree[i].dep;
q[i].push(tmp);
} else {
if (i != 1) {
tmp = q[i].top();
q[i].pop();
tmp.dep = tree[i].dep;
q[i].push(tmp);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
Add(s);
}
dfs(1);
int ans = 0;
while (!q[1].empty()) {
ans += q[1].top().dep;
q[1].pop();
}
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[1000005][2];
int main() {
string s;
int l, c, i;
cin >> s;
stack<int> st;
for (i = 0; s[i]; i++) {
if (s[i] == '(') {
st.push(i);
dp[i][0] = dp[i][1] = -1;
} else if (st.empty())
dp[i][0] = dp[i][1] = -1;
else {
dp[i][0] = dp[i][1] = st.top();
st.pop();
if (dp[i][0] > 0 && dp[dp[i][0] - 1][1] >= 0)
dp[i][1] = dp[dp[i][0] - 1][1];
}
}
for (i = l = 0; s[i]; i++)
if (dp[i][1] >= 0) l = max(l, i - dp[i][1] + 1);
if (l == 0)
cout << "0 1";
else {
for (i = c = 0; s[i]; i++)
if (dp[i][1] >= 0 && i - dp[i][1] + 1 == l) c++;
cout << l << " " << c;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int X[] = {1, 0, -1, 0, 1, -1, -1, 1};
int Y[] = {0, 1, 0, -1, 1, 1, -1, -1};
void MN(long long int &a, long long int b) {
if (a > b) a = b;
}
void MX(long long int &a, long long int b) {
if (a < b) a = b;
}
void MN(int &a, int b) {
if (a > b) a = b;
}
void MX(int &a, int b) {
if (a < b) a = b;
}
void MN(double &a, int b) {
if (a > b) a = b;
}
void MX(double &a, int b) {
if (a < b) a = b;
}
vector<pair<pair<long long int, long long int>,
pair<long long int, long long int> > >
vm;
int main() {
long long int t, t1, t2, t3, be = 0, stp = 0;
int m, n;
scanf("%d", &m);
vm.push_back(make_pair(make_pair(0, 0), make_pair(0, 0)));
for (int i = 0; i < m; i++) {
scanf("%lld%lld", &t1, &t2);
if (t1 == 1) {
be++;
if (be + 1 < vm[vm.size() - 1].first.second) stp = 1;
if (!stp) {
vm.push_back(make_pair(make_pair(be, be), make_pair(t2, 0)));
}
} else {
scanf("%lld", &t3);
be++;
if (be < vm[vm.size() - 1].first.second) stp = 1;
if (!stp) {
vm.push_back(make_pair(make_pair(be, ((be) + (t2 * t3)) - 1),
make_pair(t3, t2)));
be = ((be) + (t2 * t3)) - 1;
}
}
}
scanf("%d", &n);
int size = vm.size();
for (int i = 0; i < n; i++) {
scanf("%lld", &t);
while (true) {
int start = 1, end = size - 1, mid;
while (start < end) {
mid = start + (end - start) / 2;
if (t < vm[mid].first.first)
end = mid - 1;
else if (t > vm[mid].first.second)
start = mid + 1;
else {
start = mid;
break;
}
}
if (vm[start].first.first == vm[start].first.second &&
vm[start].second.second == 0) {
t = vm[start].second.first;
break;
} else {
t -= (vm[start].first.first - vm[start].second.second - 1);
t %= vm[start].second.second;
if (t == 0) t = vm[start].second.second;
}
}
printf("%lld ", t);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
int a[(150 + 10)];
char s[(150 + 10)];
int f[(150 + 10)][(150 + 10)][(150 + 10)];
int g[(150 + 10)];
void update(int &u, int v) {
if (v < 0) return;
u = max(u, v);
}
void update(int &u, int a, int b) {
if (a < 0 || b < 0) return;
u = max(u, a + b);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
scanf("%s", s + 1);
memset(f, -1, sizeof f);
for (int i = 1; i <= n; ++i) {
f[i][i - 1][0] = 0;
f[i][i][1] = 0;
}
for (int len = 1; len <= n; ++len) {
for (int i = 1; i + len - 1 <= n; ++i) {
int j = i + len - 1;
for (int l = 0; l <= len; ++l) {
if (s[i] == s[j] && l >= 2) update(f[i][j][l], f[i + 1][j - 1][l - 2]);
for (int k = i; k < j; ++k)
update(f[i][j][l], f[i][k][l], f[k + 1][j][0]),
update(f[i][j][l], f[i][k][0], f[k + 1][j][l]);
update(f[i][j][0], f[i][j][l], a[l]);
}
}
}
for (int i = 1; i <= n; ++i) {
g[i] = g[i - 1];
for (int j = 1; j <= i; ++j) update(g[i], g[j - 1], f[j][i][0]);
}
printf("%d\n", g[n]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, r, a;
cin >> l >> r >> a;
cout << min((l + a) * 2, min((r + a) * 2, (l + r + a) / 2 * 2));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
string str;
cin >> str;
long long cnt = 0, c = 0, mn = 0;
if (str.length() % 2 == 1) return cout << "No\n", 0;
for (long long i = 0; i < str.length(); i++) {
if (str[i] == '(')
c++;
else {
c--;
if (c < mn) {
cnt++;
mn = c;
}
}
}
if (cnt <= 1 && c == 0) return cout << "Yes\n", 0;
cout << "No\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int mod = 1e9 + 7;
struct node {
long long a, b, val, sum;
bool operator<(const node &r) const { return val > r.val; }
} a[maxn];
long long Pow(long long x) {
long long ret = 1;
for (int i = 1; i <= x; ++i) ret *= 2;
return ret;
}
int main() {
int n, x, y;
scanf("%d%d%d", &n, &x, &y);
long long p = Pow(x), ans = 0;
for (int i = 1; i <= n; ++i) {
scanf("%I64d%I64d", &a[i].a, &a[i].b);
a[i].val = a[i].a - a[i].b;
a[i].sum = a[i].a * p;
ans += a[i].b;
}
if (!y) {
printf("%I64d\n", ans);
return 0;
}
sort(a + 1, a + n + 1);
ans = 0;
for (int i = 1; i <= y; ++i) ans += max(a[i].a, a[i].b);
for (int i = y + 1; i <= n; ++i) ans += a[i].b;
long long tmp = ans;
for (int i = 1; i <= y; ++i)
ans = max(ans, tmp - max(a[i].a, a[i].b) + a[i].sum);
tmp = tmp - max(a[y].a, a[y].b) + a[y].b;
for (int i = y + 1; i <= n; ++i) ans = max(ans, tmp - a[i].b + a[i].sum);
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> a(n);
for (int(i) = (0); (i) < (n); ++(i)) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
vector<int> temp = a;
int day = 1;
while (temp[i] != i + 1) {
swap(temp[i], temp[temp[i] - 1]);
day++;
}
cout << day << " ";
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = (1e5 + 100) * 2;
int a[maxn], ans[maxn];
int l[maxn], r[maxn];
int n, mm, mx;
int main() {
while (~scanf("%d", &n)) {
mm = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
mm = min(a[i], mm);
}
l[1] = 1;
for (int i = 2; i <= n; i++) {
int pos = i;
while (pos - 1 >= 1 && a[i] <= a[pos - 1]) pos = l[pos - 1];
l[i] = pos;
}
r[n] = n;
for (int i = n - 1; i >= 1; i--) {
int pos = i;
while (pos + 1 <= n && a[i] <= a[pos + 1]) pos = r[pos + 1];
r[i] = pos;
}
memset(ans, 0, sizeof ans);
mx = mm;
for (int i = 1; i <= n; i++)
ans[r[i] - l[i] + 1] = max(a[i], ans[r[i] - l[i] + 1]);
for (int i = n; i >= 1; i--) {
mx = max(mx, ans[i]);
ans[i] = mx;
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
string words[10];
int b[10], c[10], a[10];
map<string, string> M;
int main() {
set<string> S;
for (int i = 1; i <= 2; ++i) {
for (int j = 1; j <= 2; ++j) {
for (int k = 1; k <= 2; ++k) {
for (int l = 1; l <= 2; ++l) {
char s[15];
for (int f = 0; f < 10; ++f) {
s[f] = 0;
}
sprintf(s, "%d%d%d%d%d%d\n", (i != j), (i != k), (i != l), (j != k),
(j != l), (k != l));
string res = "";
for (int f = 0; f < 6; ++f) {
res += s[f];
}
S.insert(res);
string r = "";
r += 'a' + i - 1;
r += 'a' + j - 1;
r += 'a' + k - 1;
r += 'a' + l - 1;
M[res] = r;
}
}
}
}
int n = 0;
for (set<string>::iterator it = S.begin(); it != S.end(); ++it) {
words[n++] = *it;
}
for (int i = 1; i <= 6; ++i) {
cin >> b[i];
}
int res = 1000000000, need = -1;
for (int i = 0; i <= 1000000; ++i) {
c[1] = 2 * i;
c[2] = b[4] + c[1] - b[3] - b[5] + b[2];
c[3] = -c[1] - b[1] + b[3] + b[5];
c[4] = b[1] + c[1] - b[3] - b[6] + b[4];
c[5] = -c[1] + b[3] - b[2] + b[6];
c[6] = -b[4] - c[1] + b[5] + b[6];
c[7] = b[1] + b[2] - b[6] + c[1] - b[5];
bool good = true;
for (int j = 1; j <= 7; ++j) {
if (c[j] < 0) {
good = false;
}
if (c[j] % 2 != 0) {
good = false;
}
}
if (good) {
int cur = 0;
for (int j = 1; j <= 7; ++j) {
cur += c[j] / 2;
}
if (cur < res) {
res = cur;
need = i;
}
}
}
if (need == -1) {
cout << -1 << endl;
} else {
cout << res << endl;
string s1 = "", s2 = "", s3 = "", s4 = "";
c[1] = 2 * need;
c[2] = b[4] + c[1] - b[3] - b[5] + b[2];
c[3] = -c[1] - b[1] + b[3] + b[5];
c[4] = b[1] + c[1] - b[3] - b[6] + b[4];
c[5] = -c[1] + b[3] - b[2] + b[6];
c[6] = -b[4] - c[1] + b[5] + b[6];
c[7] = b[1] + b[2] - b[6] + c[1] - b[5];
for (int i = 1; i <= 7; ++i) {
a[i] = c[i] / 2;
string cur = M[words[i]];
for (int j = 0; j < a[i]; ++j) {
s1 += cur[0];
s2 += cur[1];
s3 += cur[2];
s4 += cur[3];
}
}
cout << s1 << endl;
cout << s2 << endl;
cout << s3 << endl;
cout << s4 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long num[1010], ans;
void ok(long long x, long long y, long long n, long long m) {
for (long long i = 0; i < 10; i++) num[i] = 0;
if (!n) num[0]++;
if (!m) num[0]++;
while (n) {
num[x % 7]++;
x /= 7;
n /= 7;
}
while (m) {
num[y % 7]++;
y /= 7;
m /= 7;
}
for (int i = 0; i < 10; i++)
if (num[i] > 1) return;
ans++;
}
int main() {
long long n, m;
scanf("%lld%lld", &n, &m);
if (111 * n * m > 1e8) {
puts("0");
return 0;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) ok(i, j, n - 1, m - 1);
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
map<long long, long long> pm;
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
mp[x + y]++;
pm[x - y]++;
}
long long sum = 0;
for (long long i = -2000; i <= 2000; i++) {
if (mp[i]) sum += ((mp[i] * (mp[i] - 1)) / 2);
if (pm[i]) sum += ((pm[i] * (pm[i] - 1)) / 2);
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
string str, Output;
while (cin >> str) {
char ch = str[(int)str.size() - 1];
for (i = (int)str.size(); i >= 0; i--) {
if (str[i] == ch)
Output += str[i];
else if (str[i] > ch) {
ch = str[i];
Output += str[i];
}
}
reverse(Output.begin(), Output.end());
cout << Output << "\n";
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int n,AS,AT,BS,BT;
char ss[200005];
bool pan3(int s,int t) {
for(int i=s;i<=t;i++) {
if(ss[i-1]=='.'&&ss[i]=='.'&&ss[i+1]=='.') return 1;
}
return 0;
}
bool ok(int s,int t) {
if(ss[s]=='#'||ss[t]=='#') return 0;
for(int i=s+1;i<=t;i++) {
if(ss[i]=='#'&&ss[i-1]=='#') return 0;
}
return 1;
}
int main() {
scanf("%d%d%d%d%d",&n,&AS,&BS,&AT,&BT);
scanf("%s",&ss[1]);
if(AT<BS|| (BT>AT) ) {
if(ok(AS,AT)&&ok(BS,BT)) puts("Yes");
else puts("No");
return 0;
}
if(pan3(BS,BT)&&ok(BS,BT)&&ok(AS,AT)) puts("Yes");
else puts("No");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void io() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
long long n;
int main() {
io();
cin >> n;
for (int i = 1; i <= n; ++i) cout << 2 * i / 3 << ' ' << 2 * i % 3 << endl;
}
| 3 |
#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
using namespace std;
const double EPS = 1e-10;
const double INF = 1e12;
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()
typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
L(const P& a, const P& b){ at(0)=a; at(1)=b; }
L(){}
};
namespace std{
bool operator < (const P& a, const P& b){
return (a.X!=b.X) ? a.X<b.X : a.Y<b.Y;
}
bool operator == (const P& a, const P& b){
return abs(a-b) < EPS;
}
}
double dot(P a, P b){
return (conj(a)*b).X;
}
double cross(P a, P b){
return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
b -= a;
c -= a;
if(cross(b,c) > EPS) return +1; //ccw
if(cross(b,c) < -EPS) return -1; //cw
if(dot(b,c) < -EPS) return +2; //c-a-b
if(abs(c)-abs(b) > EPS) return -2; //a-b-c
return 0; //a-c-b
}
bool intersectSS(const L& a, const L& b){
return ( ccw(a[0],a[1],b[0]) *ccw(a[0],a[1],b[1]) <= 0 ) &&
( ccw(b[0],b[1],a[0]) *ccw(b[0],b[1],a[1]) <= 0 );
}
P crosspointLL(const L &l, const L &m) {
double A = cross(l[1]-l[0], m[1]-m[0]);
double B = cross(l[1]-l[0], l[1]-m[0]);
return m[0] + B/A *(m[1]-m[0]);
}
bool isParallel(const P &a, const P &b){
return abs(cross(a,b)) < EPS;
}
bool isParallel(const L &a, const L &b){
return isParallel(a[1]-a[0], b[1]-b[0]);
}
double getarea(const VP &poly){
double ret = 0;
for (int i=0; i<(int)poly.size(); i++){
ret += cross(poly[i], poly[(i+1)%poly.size()]);
}
return ret*0.5;
}
int main(){
while(1){
int x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
if(x1==0 && y1==0 && x2==0 && y2==0) break;
vector<L> line(3);
for(int i=0; i<3; i++){
if(i != 0) cin >> x1 >> y1 >> x2 >> y2;
line[i] = L(P(x1,y1), P(x2,y2));
}
VP v;
for(int i=0; i<3; i++){
if(!isParallel(line[i], line[(i+1)%3]) && intersectSS(line[i], line[(i+1)%3])){
v.push_back(crosspointLL(line[i], line[(i+1)%3]));
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
if((int)v.size() != 3){
cout << "kyo" << endl;
}else{
if(ccw(v[0], v[1], v[2]) == -1) swap(v[1], v[2]);
double s = getarea(v);
if(s >= 1900000){
cout << "dai-kichi" << endl;
}else if(s >= 1000000){
cout << "chu-kichi" << endl;
}else if(s >= 100000){
cout << "kichi" << endl;
}else{
cout << "syo-kichi" << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<vector<long long>> lr(n);
for (long long i = (0); i < (n); i++) {
long long l, r;
cin >> l >> r;
lr[i] = {l, r, i};
}
sort(lr.begin(), lr.end());
long long rb = lr[0][1];
long long ans[n];
bool ok = false;
for (long long i = (1); i < (n); i++) {
if (rb < lr[i][0]) {
for (long long j = (0); j < (i); j++) ans[lr[j][2]] = 1;
for (long long j = (i); j < (n); j++) ans[lr[j][2]] = 2;
ok = true;
break;
}
rb = max(rb, lr[i][1]);
}
if (ok) {
for (long long i = (0); i < (n); i++) cout << ans[i] << " ";
cout << endl;
} else {
cout << (-1) << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;cin>>c;
cout<<(c<='Z'?"A":"a")<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
for (char& c : s) c = c == ',' ? ' ' : c;
stringstream ss;
ss << s;
vector<string> res;
for (string z; ss >> z; res.push_back(z))
;
return res;
}
void debug_out(vector<string> args, int idx) { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, Head H, Tail... T) {
if (idx > 0) cerr << ", ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, T...);
}
void localTest() {}
const long long N = 2e5 + 5, M1 = 1e9 + 7, M2 = 1e9 + 9, P1 = 31, P2 = 43;
long long po[N][2], pre[N], nxt[N];
pair<pair<long long, long long>, long long> dp[N];
string s;
pair<pair<long long, long long>, long long> add(
pair<pair<long long, long long>, long long> X, long long val) {
X.first.first = (X.first.first * P1 + val) % M1;
X.first.second = (X.first.second * P2 + val) % M2;
X.second++;
return X;
}
pair<pair<long long, long long>, long long> sub(
pair<pair<long long, long long>, long long> X,
pair<pair<long long, long long>, long long> Y) {
long long pwr = X.second - Y.second;
X.first.first = (X.first.first - (Y.first.first * po[pwr][0]) % M1 + M1) % M1;
X.first.second =
(X.first.second - (Y.first.second * po[pwr][1]) % M2 + M2) % M2;
X.second = pwr;
return X;
}
pair<pair<long long, long long>, long long> getHash(long long x, long long y) {
if (pre[y] >= x) {
auto ret = dp[x];
long long val = 0;
if (s[x - 1] == '1' && ((nxt[x] - x) % 2)) val = 1;
ret = add(ret, val);
ret = sub(ret, dp[pre[y]]);
return ret;
}
return {{0LL, 0LL}, 0LL};
}
int main() {
localTest();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n >> s;
po[0][0] = po[0][1] = 1;
for (long long i = 1; i < N; ++i) {
po[i][0] = (po[i - 1][0] * P1) % M1;
po[i][1] = (po[i - 1][1] * P2) % M2;
}
nxt[n + 1] = n + 1;
for (long long i = 1; i <= n; ++i) {
if (s[i - 1] == '0')
pre[i] = i;
else
pre[i] = pre[i - 1];
}
long long val = 0;
dp[n + 1] = {{0LL, 0LL}, 0LL};
for (long long i = n; i >= 1; --i) {
if (s[i - 1] == '0') {
dp[i] = add(dp[i + 1], val);
nxt[i] = i;
val = 0;
} else {
dp[i] = dp[i + 1];
nxt[i] = nxt[i + 1];
val ^= 1LL;
}
}
long long q;
cin >> q;
while (q--) {
long long x, y, z;
cin >> x >> y >> z;
if (getHash(x, x + z - 1) == getHash(y, y + z - 1))
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
int n;
string t, s[MAXN];
int numPref[MAXN];
long long ans = 0;
struct AhoCorasick {
const static char START = 'a';
const static int NUM_CHAR = 26;
struct Node {
char ch;
int p;
int trie[NUM_CHAR], nex[NUM_CHAR];
int link;
vector<int> revLink;
int leaf = 0;
Node(char _ch = '$', int _p = -1) : ch(_ch), link(-1), p(_p) {
memset(trie, -1, sizeof trie);
memset(nex, -1, sizeof nex);
}
};
public:
vector<Node> t;
AhoCorasick() { t.push_back(Node()); }
void addString(string s) {
int cur = 0;
for (char c : s) {
int idx = c - START;
if (t[cur].trie[idx] == -1) {
t[cur].trie[idx] = t.size();
t.push_back(Node(c, cur));
}
cur = t[cur].trie[idx];
}
++t[cur].leaf;
}
int getLink(int state);
int go(int state, char ch) {
int idx = ch - START;
if (t[state].nex[idx] == -1) {
if (t[state].trie[idx] == -1) {
t[state].nex[idx] = (state == 0) ? 0 : go(getLink(state), ch);
} else {
t[state].nex[idx] = t[state].trie[idx];
}
}
return t[state].nex[idx];
}
void traverse() {
for (int i = 0; i < t.size(); ++i) {
int link = getLink(i);
if (link >= 0 && link != i) {
t[link].revLink.push_back(i);
}
}
queue<int> q;
q.push(0);
while (!q.empty()) {
int front = q.front();
q.pop();
for (int i : t[front].revLink) {
t[i].leaf += t[front].leaf;
q.push(i);
}
}
}
int getLeaf(int state) { return t[state].leaf; }
} f, r;
int AhoCorasick::getLink(int state) {
if (t[state].link == -1) {
if (state == 0 || t[state].p == 0) {
t[state].link = 0;
} else {
t[state].link = go(getLink(t[state].p), t[state].ch);
}
}
return t[state].link;
};
int main() {
cin >> t;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s[i];
f.addString(s[i]);
reverse(s[i].begin(), s[i].end());
r.addString(s[i]);
}
f.traverse();
r.traverse();
int state = 0;
for (int i = 0; i < t.size(); ++i) {
state = f.go(state, t[i]);
numPref[i] = f.getLeaf(state);
}
state = 0;
for (int i = t.size() - 1; i >= 0; --i) {
state = r.go(state, t[i]);
if (i > 0) {
ans += 1LL * numPref[i - 1] * r.getLeaf(state);
}
}
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, ar[55], i, m, p;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> ar[i];
m = ar[k - 1];
if (!m) m = 1;
sort(ar, ar + n);
p = lower_bound(ar, ar + n, m) - ar;
cout << n - p;
return 0;
}
| 1 |
#define ENABLE_LL
#include <iostream>
#include <cstdio>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <queue>
#include <cmath>
#include <cstring>
using namespace std;
void init();
void solve();
int main(){
try {
#ifndef CUSTOM_MAIN
#ifdef MULTIPLE_TEST_CASES_WITH_T
int T; scanf("%d",&T); while(T--) {init(); solve();}
#else
#ifdef MULTIPLE_TEST_CASES_WITHOUT_T
while(1) {try{init(); } catch(bool t){return 0;} solve(); }
#else
init(); solve();
#endif
#endif
#endif
} catch (const char* s) { return 0; }
return 0;
}
#ifdef ENABLE_LL
#define int long long
#endif
#ifdef ENABLE_LL
#define I "%lld"
#define II "%lld%lld"
#define III "%lld%lld%lld"
#define IIII "%lld%lld%lld%lld"
#define IN "%lld\n"
#define IIN "%lld%lld\n"
#define IIIN "%lld%lld%lld\n"
#define IIIIN "%lld%lld%lld%lld\n"
#else
#define I "%d"
#define II "%d%d"
#define III "%d%d%d"
#define IIII "%d%d%d%d"
#define IN "%d\n"
#define IIN "%d%d\n"
#define IIIN "%d%d%d\n"
#define IIIIN "%d%d%d%d\n"
#endif
#ifdef __LOCALE__
#define see(a) std::cout << #a << "=" << a << std::endl
#define ses(a) std::cout << #a << "=" << a << " "
#else
#define see(a) //std::cout << #a << "=" << a << std::endl
#define ses(a)
#endif
#define repe(a,b) for (int a=0;a<(int)b.size();a++)
#define rep(i,n) for (int i=0;i<n;i++)
#define repa(i,n) for (int i=1;i<=n;i++)
#define repi(i,a,b) for (int i=a;i<=b;i++)
#define repb(i,a,b) for (int i=a;i>=b;i--)
typedef pair < int , int > pr; typedef pair < pr , int > prr;
#define L first
#define R second
template <class T> inline bool checkMin(T& a , T b) { return (a > b ? a=b,1 : 0); }
template <class T> inline bool checkMax(T& a , T b) { return (a < b ? a=b,1 : 0); }
class Scanner{ private: istream& ist;public: Scanner(istream& in):ist(in){} string next(){ string r; ist >> r; return r; } string nextLine(){ string r; getline(ist,r); return r; } int nextInt(){ int r; ist >> r; return r; } double nextDouble(){ double r; ist >> r; return r; } char nextChar(){ char r; ist>>r; return r;} }; Scanner sc(cin);
void ALERT(bool judgememt, const char* phrase) { if (judgememt) { puts(phrase); throw "ALERT"; } }
bool alert(bool judgememt, const char* phrase) { if (judgememt) puts(phrase); return judgememt; }
const int N = 125;
int a[N], l[N], r[N];
int sa[N], sl, sr;
int n, k;
void init() {
scanf(II,&n,&k);
rep (i,n) scanf(I,&a[i]); sort(a,a+n,[](int a,int b){return a>b;}); rep (i,n) sa[i+1] = sa[i] + a[i];
rep (i,k) scanf(I,&l[i]); sort(l,l+n,[](int a,int b){return a>b;}); rep (i,k) sl+=l[i];
rep (i,k) scanf(I,&r[i]); sort(r,r+n,[](int a,int b){return a>b;}); rep (i,k) sr+=r[i];
}
int dp[2][N][3005];
void solve() {
memset(dp,0x3f,sizeof(dp)); dp[0][0][0] = 0;
repa (i,n) { // i means on a[i]
int pos=i&1, per=pos^1; memset(dp[pos],0x3f,sizeof(dp[pos]));
rep (j,min(i,k+1)) rep(t,3005) { // j means j red are chosen , t means their sum (of a)
if (t+a[i-1]<=sl) checkMin(dp[pos][j+1][t+a[i-1]] , dp[per][j][t] + max(0LL,a[i-1]-l[j])) ;
if (sa[i-1]-t+a[i-1]<=sr) checkMin(dp[pos][j][t], dp[per][j][t] + max(0LL,a[i-1]-r[i-j-1]));
}
}
int ans=0x3f3f3f3f3f3f3f3f , pos=n&1;
rep (i,k+1) rep (t,3005) checkMin(ans,dp[pos][i][t]);
ALERT(ans==0x3f3f3f3f3f3f3f3f,"-1");
printf(IN,ans);
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.