solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, t;
double a;
cin >> n >> t;
a = ((double)n * pow(1.000000011, (double)t));
cout << a;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char a[100020], b[100020];
int c[1 << 8][1 << 8];
int main(void) {
int i;
scanf("%s", a);
scanf("%s", b);
for (i = 0; a[i]; i++) ++c[a[i]][b[i]];
printf("%d\n", max(c['4']['7'], c['7']['4']));
return 0;
}
| 1 |
#include<bits/stdc++.h>
double dy[110][210][110];
bool chk[110][210][110];
int T[110];
int V[110];
int n;
double go(int idx, int t, int v) {
if (idx == n && v == 0) {
return 0;
}
if (idx == n) {
return -1e9;
}
if (v > V[idx])return -1e9;
auto& ret = dy[idx][t][v];
if (chk[idx][t][v])return ret;
chk[idx][t][v] = true;
ret = -1e9;
if (t == 0) {
ret = go(idx + 1, T[idx+1], v);
return ret;
}
if (v < V[idx]) {
ret = std::max(ret, go(idx, t - 1, v + 1) + v + 0.5);
ret = std::max(ret, go(idx, t - 1, v) + v + 0.25);
}
ret = std::max(ret, go(idx, t - 1, v) + v);
if (v > 0) {
ret = std::max(ret, go(idx, t - 1, v - 1) + v - 0.5);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &T[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &V[i]);
}
printf("%.10lf", go(0, T[0], 0));
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long double d, r, x1, y1, x2, y2;
cin >> r >> x1 >> y1 >> x2 >> y2;
d = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
cout << ceil(d / (2.0 * r)) << endl;
}
| 2 |
#include <bits/stdc++.h>
template <typename C>
int sz(const C &c) {
return c.size();
}
using namespace std;
int main() {
iostream::sync_with_stdio(false);
int n;
cin >> n;
int d;
cin >> d;
int r = 2;
int p;
cin >> p;
for (int i = 1; i < n; ++i) {
int c;
cin >> c;
if (c - p == 2 * d) {
++r;
} else if (c - p > 2 * d) {
r += 2;
}
p = c;
}
cout << r << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const int N = 100010;
int n, m, p, q;
int f[N];
long long w[N];
set<pair<long long, int> > s;
int find_set(int x) {
if (f[x] == x) return x;
return f[x] = find_set(f[x]);
}
int main() {
scanf("%d %d %d %d", &n, &m, &p, &q);
for (int i = 1; i <= n; ++i) f[i] = i, w[i] = 0;
for (int i = 0, x, y, l; i < m; ++i) {
scanf("%d %d %d", &x, &y, &l);
x = find_set(x), y = find_set(y);
if (x == y)
w[x] += l;
else {
f[x] = y;
w[y] += w[x] + l;
}
}
for (int i = 1; i <= n; ++i) {
if (f[i] == i) s.insert(make_pair(w[i], i));
}
int fp = s.size();
vector<pair<int, int> > ans;
if (fp - p > q or fp < q)
puts("NO");
else {
for (int i = 0; i < fp - q; ++i) {
pair<long long, int> u = *s.begin();
s.erase(s.begin());
pair<long long, int> v = *s.begin();
s.erase(s.begin());
ans.push_back(make_pair(u.second, v.second));
s.insert(make_pair(u.first + v.first + min(inf, u.first + v.first + 1),
u.second));
f[u.second] = v.second;
}
int x = -1;
for (int i = 1; i <= n; ++i)
if (f[i] != i) x = i;
if (p - (fp - q) and x == -1) {
puts("NO");
return 0;
}
for (int i = 0; i < p - (fp - q); ++i) ans.push_back(make_pair(x, f[x]));
puts("YES");
for (int i = 0; i < ans.size(); ++i) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n <= 10 || n > 21) {
cout << 0 << endl;
} else if (n == 20) {
cout << 15 << endl;
} else {
cout << 4 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> M = {{"monday", 0}, {"tuesday", 1}, {"wednesday", 2},
{"thursday", 3}, {"friday", 4}, {"saturday", 5},
{"sunday", 6}};
int main() {
ios_base::sync_with_stdio(false);
string a, b;
cin >> a >> b;
assert(M.count(a));
assert(M.count(b));
int aa = M[a], bb = M[b];
int d = (bb - aa + 7) % 7;
vector<int> v = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
for (int i = (int)(0); i < (int)(v.size()); ++i)
if (v[i] % 7 == d) {
cout << "YES\n";
return 0;
}
cout << "NO\n";
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
int n;
int dist[101][101];
int atk[101][101];
int memo[101][101]; //memo[i][j] : ??????j??§?????????i???????????¨??????????°??\???\?????°
bool used[101][101];
const int INF = 1000000000;
struct V{
int p,m;
V(int p,int m):p(p),m(m){}
};
bool operator < (const V& a,const V& b){
return memo[a.p][a.m] > memo[b.p][b.m];
}
int solve(int s,int l){
for(int i=0;i<=100;++i)
for(int j=0;j<=100;++j){
used[i][j]=false;
memo[i][j]=INF;
}
memo[s][l] = 0;
priority_queue<V> Q;
Q.push(V(s,l));
while(!Q.empty()){
V x=Q.top(); Q.pop();
int cur = x.p, mon = x.m, cst=memo[cur][mon];
// if(used[cur][mon]) continue;
// used[cur][mon] = true;
for(int i=0;i<n;++i){
if(dist[cur][i]){
if(cst+atk[cur][i] < memo[i][mon]){
memo[i][mon] = cst+atk[cur][i];
Q.push(V(i,mon));
}
if(mon-dist[cur][i]>=0){
if(memo[i][mon-dist[cur][i]] > cst){
memo[i][mon-dist[cur][i]] = cst;
Q.push(V(i,mon-dist[cur][i]));
}
}
}
}
}
int ret = INF;
for(int i=0;i<=l;++i) ret = min(ret, memo[n-1][i]);
return ret;
}
int main(){
int m,l;
while(cin>>n>>m>>l,n||m||l){
memset(dist,0,sizeof(dist));
memset(atk,0,sizeof(atk));
while(m--){
int a,b,d,e;
cin >> a >> b >> d >> e;
a--;b--;
dist[a][b] = dist[b][a] = d;
atk[a][b] = atk[b][a] = e;
}
cout<<solve(0,l)<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n, d;
cin >> n >> d;
int len = 0;
int64_t temp = n, to_add = 0, num = n;
while (1) {
if (temp == 0) {
break;
}
int64_t t_ans = num;
int val = 0;
if (temp % 10 != 9) {
val = 1;
}
temp /= 10;
len++;
temp -= val;
to_add *= 10;
to_add += 9;
num = temp * pow(10, len) + to_add;
if (n - num > d) {
cout << t_ans << "\n";
return 0;
}
}
cout << to_add << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
string a, b, c;
cin >> a >> b >> c;
int flag = 0;
for (int i = 0; i < a.length(); i++) {
if ((a[i] == c[i]) || (c[i] == b[i])) {
} else {
flag = 1;
}
}
if (flag) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
long long n, p[N], tp;
bool vld;
char c;
string s;
string::iterator it;
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
getline(cin, s);
vld = 1;
for (int i = 1; i <= n; i++) {
getline(cin, s);
tp = 0;
for (it = s.begin(); it != s.end(); it++) {
c = *it;
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
c == 'y') {
tp++;
}
}
if (tp != p[i]) vld = 0;
}
if (vld)
cout << "YES\n";
else
cout << "NO\n";
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 61;
const long long mod = 1000000007;
const int maxn = 3e5 + 10;
long long c[maxn], a[maxn];
priority_queue<pair<long long, int> > que;
int main() {
std::ios::sync_with_stdio(false);
int n, k;
long long sum = 0, ans = 0;
;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &c[i]);
if (i <= k) {
que.push(make_pair(c[i], i));
sum += c[i];
ans += sum;
}
}
pair<long long, int> tmp;
for (int i = k + 1; i <= k + n; i++) {
if (i <= n) {
que.push(make_pair(c[i], i));
sum += c[i];
}
tmp = que.top();
que.pop();
sum -= tmp.first;
ans += sum;
a[tmp.second] = i;
}
printf("%lld\n", ans);
for (int i = 1; i <= n; i++) {
printf("%lld%c", a[i], i == n ? '\n' : ' ');
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>> a >> b;
int ans=0;
if (12<a) ans=b;
else if (6<=a) ans=b/2;
cout<< ans <<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r;
cin >> n >> r;
int a[2222] = {0}, x = 0, ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i]) x++;
}
if (x * (2 * r - 1) < n)
cout << -1;
else {
int t = 0;
int x = -1;
for (int i = r - 1; i >= 0; i--) {
if (a[i]) {
x = i;
break;
}
}
if (x == -1) {
cout << x;
return 0;
} else {
for (int i = x; i < n; i++) {
if (a[i]) {
ans++;
int find = 0;
if (i + r >= n) {
cout << ans;
return 0;
} else {
for (int j = i + 2 * r - 1; j > i; j--) {
if (a[j]) {
i = j - 1;
if (i + 1 >= n) ans++;
find = 1;
break;
}
}
if (!find) {
cout << -1;
return 0;
}
}
}
}
cout << ans;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> ans;
long long pw[205];
set<long long> stc[2], str[2];
map<long long, vector<long long>> mpc[2], mpr[2];
long long cur;
void bct(vector<long long> v) {
if (v.size() == 1) {
long long hsh = 0;
ans[v[0]] = 1;
for (long long i = 1; i < ans.size(); i++)
if (ans[i]) {
hsh = (hsh + i * pw[ans[i]]) % 998244353;
}
stc[cur].insert(hsh);
mpc[cur][hsh] = ans;
ans[v[0]] = 2;
hsh = 0;
for (long long i = 1; i < ans.size(); i++)
if (ans[i]) hsh = (hsh + i * pw[ans[i]]) % 998244353;
str[cur].insert(hsh);
mpr[cur][hsh] = ans;
ans[v[0]] = 0;
return;
}
long long n = v.size() / 2;
for (long long mask = 0; mask < (1 << n); mask++) {
vector<long long> winner, looser;
for (long long j = 0; j < n; j++) {
if (mask & (1 << j)) {
winner.push_back(v[2 * j]);
looser.push_back(v[2 * j + 1]);
} else {
winner.push_back(v[2 * j + 1]);
looser.push_back(v[2 * j]);
}
ans[looser.back()] = v.size() + 1;
}
bct(winner);
for (auto &cv : looser) ans[cv] = 0;
}
}
void print(vector<long long> v1, vector<long long> v2) {
for (long long i = 1; i < v1.size(); i++) cout << max(v1[i], v2[i]) << ' ';
cout << endl;
}
void solve() {
long long k, a, h;
cin >> k >> a >> h;
long long n = (1 << k);
pw[0] = 1;
for (long long i = 1; i <= n; i++) pw[i] = pw[i - 1] * a % 998244353;
vector<long long> v1, v2;
ans.resize(n + 1);
for (long long i = 1; i <= n; i++)
if (i <= (n / 2))
v1.push_back(i);
else
v2.push_back(i);
long long sum = 0;
sum += pw[1] * 5;
sum += pw[5] * 6;
sum += pw[5] * 7;
sum += pw[3] * 8;
bct(v1);
cur++;
bct(v2);
for (auto &cv : stc[0]) {
long long laagbe = (h - cv + 998244353) % 998244353;
if (str[1].find(laagbe) == str[1].end()) continue;
print(mpc[0][cv], mpr[1][laagbe]);
return;
}
for (auto &cv : stc[1]) {
long long laagbe = (h - cv + 998244353) % 998244353;
if (str[0].find(laagbe) == str[0].end()) continue;
print(mpc[1][cv], mpr[0][laagbe]);
return;
}
cout << -1 << endl;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int l, k;
char s[100050];
char fb[14][4];
int bad[26];
int dp[100050][26] = {0};
inline void relax(int &x, int val) {
if (val > x) x = val;
}
int main(void) {
scanf("%s", s);
scanf("%d", &k);
memset(bad, -1, sizeof(bad));
for (int i = 0; i < k; i++) {
scanf("%s", fb[i]);
fb[i][0] -= 'a';
fb[i][1] -= 'a';
bad[fb[i][0]] = fb[i][1];
bad[fb[i][1]] = fb[i][0];
}
l = strlen(s);
for (int i = 0; i < l; i++) {
char c = s[i] - 'a';
for (int j = 0; j < 26; j++) {
relax(dp[i + 1][j], dp[i][j]);
if (bad[j] == c) continue;
relax(dp[i + 1][c], dp[i][j] + 1);
}
}
int opt = 0;
for (int i = 0; i < 26; i++) relax(opt, dp[l][i]);
printf("%d\n", l - opt);
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
void itval(istream_iterator<string> it) {}
template <typename T, typename... Args>
void itval(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
itval(++it, args...);
}
const long long int MOD = 1e9 + 7;
template <typename T>
inline void print(T x) {
cout << x << "\n";
}
template <typename T>
inline void printvec(T x) {
for (auto a : x) cout << a << ' ';
cout << '\n';
}
struct custom {
bool operator()(const pair<long long int, long long int> &p1,
const pair<long long int, long long int> &p2) const {
if (p1.second == p2.second) {
return p1.first < p2.first;
}
return p1.second > p2.second;
}
};
long long int get_pow(long long int a, long long int b, long long int M = MOD) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % M;
a = (a * a) % M;
b >>= 1;
}
return res;
}
const long long int N = 5e5 + 5, inf = 2e18;
long long int foo(long long int p) {
vector<long long> r = {p, 1, p + 1, 0};
return r[p % 4];
}
void solve() {
long long int n;
cin >> n;
long long int x, m, ans = 0;
for (long long int i = (long long int)0; i < (long long int)(n); i++) {
cin >> x >> m;
long long int a = x, b = x + m - 1;
ans ^= (foo(b) ^ foo(a - 1));
}
if (ans)
cout << "tolik\n";
else
cout << "bolik\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
clock_t z = clock();
for (long long int tes = (long long int)0; tes < (long long int)(test);
tes++) {
solve();
}
fprintf(stderr, "Total Time:%.4f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[666666], b[666666], x, y, l, r, m[666666], i, n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x >> y;
m[x] = i;
m[y] = i;
if (x > y) {
l++;
a[l] = x;
} else {
r++;
b[r] = -y;
}
}
sort(a + 1, a + l + 1);
sort(b + 1, b + r + 1);
if (l >= r) {
cout << l << endl;
for (i = 1; i <= l; i++) cout << m[a[i]] << " ";
} else {
cout << r << endl;
for (i = 1; i <= r; i++) cout << m[-b[i]] << " ";
}
}
| 4 |
#include<iostream>
using namespace std;
int N,Y;
int main(void){
cin>>N>>Y;
Y=Y/1000;
for(int i=0;i<=N;i++)
for(int j=0;j<=N-i;j++)
if(i*10+j*5+(N-i-j)==Y){
cout<<i<<' '<<j<<' '<<N-i-j;
return 0;
}
cout<<"-1 -1 -1";
return 0;
} | 0 |
#include<stdio.h>
int main()
{
int N,M,P,i;
while(scanf("%d%d%d",&N,&M,&P),N)
{
int a[101]={0},s=0;
for(i=1;i<=N;++i)scanf("%d",&a[i]),s+=a[i];
if(a[M])printf("%d\n",s*(100-P)/a[M]);
else puts("0");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
char limit;
bool solve(int n) {
if (n == -1) return 0;
for (int i = 1;; ++i) {
if (s[n] + i >= limit) break;
if (n > 0 && s[n - 1] == s[n] + i) continue;
if (n > 1 && s[n - 2] == s[n] + i) continue;
s[n] += i;
return true;
}
if (!solve(n - 1)) return false;
s[n] = 'a';
for (int i = 0;; ++i) {
if (s[n] + i >= limit) break;
if (n > 0 && s[n - 1] == s[n] + i) continue;
if (n > 1 && s[n - 2] == s[n] + i) continue;
s[n] += i;
return true;
}
return false;
}
int main() {
int n, p;
cin >> n >> p;
cin >> s;
limit = p + 'a';
if (solve(n - 1))
cout << s << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
// C - Traveling
#include <bits/stdc++.h>
using namespace std;
int main(){
int N; cin>>N;
bool ans=true;
for(int i=0; i<N; ++i){
int t,x,y; cin>>t>>x>>y;
if(t%2 != (x+y)%2){ ans = false; break; }
else if(t < x+y){ ans = false; break; }
}
cout<< (ans?"Yes":"No") <<endl;
} | 0 |
#include <bits/stdc++.h>
const long long inf = 1e9;
const double eps = 1e-9;
const long long infll = 1e18;
const long long mod = 1e9 + 7;
const long long N = 1001;
using namespace std;
vector<vector<long long> > g, gi, gt;
vector<vector<long long> > dp;
vector<long long> a, b;
vector<long long> u, d;
inline long long safe_add(long long a, long long b) {
if (a + b >= mod) return a + b - mod;
return a + b;
}
long long inv(long long a, long long m) {
m -= 2;
long long ans = 1;
while (m) {
if (m & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
m /= 2;
}
return ans;
}
void ddf(long long v = 0) {
for (long long i = 0; i < g[v].size(); i++) {
if (d[g[v][i]] == -1) {
d[g[v][i]] = d[v] + 1;
ddf(g[v][i]);
}
}
}
inline void dfs(long long v) {
u[v] = 1;
a[v] = 1;
b[v] = 1;
bool ch = true;
long long aa = -1, bb = -1;
for (long long i = 0; i < g[v].size(); i++) {
if (u[g[v][i]] == 0) {
gi[g[v][i]].push_back(v);
gt[v].push_back(g[v][i]);
ch = false;
dfs(g[v][i]);
if (aa == -1) aa = 1;
aa = (aa * a[g[v][i]]) % mod;
if (bb == -1) bb = 1;
bb = (bb * b[g[v][i]]) % mod;
}
}
if (bb == -1)
a[v] = max(aa, 1ll);
else
a[v] = safe_add(aa, bb);
if (aa == -1)
b[v] = max(bb, 1ll);
else
b[v] = safe_add(aa, bb);
if (aa == -1) aa = 1;
if (bb == -1) bb = 1;
dp[v][0] = aa;
dp[v][1] = bb;
}
inline void dfsinv(long long v) {
u[v] = 1;
bool ch = true;
for (long long i = 0; i < gi[v].size(); i++) {
if (u[gi[v][i]] == 0) {
dfsinv(gi[v][i]);
}
long long aa = 1, bb = 1;
for (long long j = 0; j < gt[v].size(); j++) {
aa = (aa * a[gt[v][j]]) % mod;
bb = (bb * b[gt[v][j]]) % mod;
}
long long qweq = inv(a[v], mod);
long long sa = (dp[gi[v][i]][0] * inv(a[v], mod) + mod) % mod,
sb = (dp[gi[v][i]][1] * inv(b[v], mod) + mod) % mod;
long long saa;
if (g[gi[v][i]].size() == 1) {
saa = 1;
} else
saa = (sa + sb + mod) % mod;
aa = (aa * saa) % mod;
bb = (bb * saa) % mod;
a[v] = safe_add(aa, bb);
b[v] = safe_add(aa, bb);
dp[v][0] = (aa) % mod;
dp[v][1] = (bb) % mod;
}
}
void solve() {
long long n;
cin >> n;
g.resize(n);
gi.resize(n);
dp.assign(n, vector<long long>(2, 0));
d.assign(n, -1);
u.resize(n, 0);
a.resize(n);
b.resize(n);
gt.resize(n);
for (long long i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
ddf();
long long v = 0;
for (long long i = 0; i < n; i++) {
if (d[i] > d[v]) v = i;
}
dfs(v);
long long ans = 0;
u.assign(n, 0);
for (long long i = 0; i < n; i++) {
if (u[i] == 0) {
dfsinv(i);
}
}
for (long long i = 0; i < n; i++) ans = (ans + a[i]) % mod;
cout << ans << endl;
return;
}
bool check(long long v, long long mask, long long mood = 1) {
u[v] = 1;
bool ch = 0;
for (long long i = 0; i < g[v].size(); i++) {
if (u[g[v][i]] == 0) {
ch = 1;
long long nv = g[v][i];
bool qnv = (1 << nv) & mask;
if (!check(g[v][i], mask, mood ^ qnv)) {
return false;
}
}
}
if (ch == 0) return mood;
return true;
}
void solve1() {
long long n;
cin >> n;
g.resize(n);
gi.resize(n);
dp.assign(n, vector<long long>(2, 0));
u.resize(n, 0);
a.resize(n);
b.resize(n);
gt.resize(n);
for (long long i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
long long ans = 0;
for (long long i = 0; i < 1 << n; i++) {
for (long long j = 0; j < n; j++) {
u.assign(n, 0);
if (check(j, i)) {
ans++;
cout << j << ' ';
for (long long q = 0; q < n; q++) cout << (bool)((1 << q) & i) << ' ';
cout << endl;
}
}
}
cout << ans << endl;
return;
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char S[100];
int n, sum, f[1 << 22], a[200200], bin[100];
int get() {
int ret = 0, l = strlen(S + 1);
for (int i = 1; i <= l; i++) ret = (ret << 1) + S[i] - '0';
return ret;
}
void Min(int &a, int b) {
if (a > b) a = b;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s", S + 1), a[i] = get();
int len = strlen(S + 1);
bin[0] = 1;
for (int i = 1; i <= len + 1; i++) bin[i] = bin[i - 1] << 1;
memset(f, 60, sizeof f);
f[1] = sum = 0;
for (int i = 1; i <= n; i++) {
int j;
for (j = len; j; j--)
if (i > 1 && (a[i - 1] & (bin[j] - 1)) == (a[i] >> len - j)) break;
int tmp = 1e9;
sum += len - j;
for (int k = 0; k <= len; k++)
Min(tmp, f[(a[i] >> len - k) | bin[k]] - k + j);
if (i > 1)
for (int k = 0; k <= len; k++)
Min(f[((a[i - 1]) & (bin[k] - 1)) | bin[k]], tmp);
}
int tmp = 1e9;
for (int i = 0; i <= bin[len + 1] - 1; i++) tmp = min(tmp, f[i]);
printf("%d\n", sum + tmp);
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int k,s,cnt;
int main()
{
cin>>k>>s;
for(register int x=0;x<=k;x++)for(register int y=0;y<=k;y++) if(s-x-y>=0&&s-x-y<=k) cnt++;
cout<<cnt<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int arr[810][810];
int maxx = 0;
int p, q;
int d[1000];
int main() {
cin >> n;
for (int i = 2; i <= 2 * n; i++) {
for (int j = 1; j < i; j++) cin >> arr[i][j];
}
for (int k = 1; k <= n; k++) {
for (int i = 0; i <= 2 * n; i++) {
for (int j = 0; j <= 2 * n; j++) {
if (maxx < arr[i][j]) {
maxx = arr[i][j];
p = i;
q = j;
}
}
}
for (int i = 0; i <= 2 * n; i++) {
arr[p][i] = 0;
arr[q][i] = 0;
arr[i][p] = 0;
arr[i][q] = 0;
}
d[p] = q;
d[q] = p;
maxx = 0;
}
for (int i = 1; i <= 2 * n; i++) {
cout << d[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long powermodm(long long x, long long n, long long M) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
const long long N = 2e5 + 5;
const long long M = 1e2 + 5;
const long long mod = 1e9 + 7;
const long long m1 = 1e9 + 7;
const long long m2 = 1e9 + 9;
const long long p1 = 402653189;
const long long p2 = 1610612741;
const long long LN = 20;
const long long dx[4] = {-1, 1, 0, 0};
const long long dy[4] = {0, 0, -1, 1};
vector<long long> adj[N], g[N];
bool visited[N];
long long depth[N];
vector<pair<long long, pair<long long, long long>>> ans;
void dfs(long long node, long long par) {
visited[node] = true;
depth[node] = depth[par] + 1;
for (auto it : adj[node]) {
if (it == par) continue;
if (visited[it]) {
if (depth[it] < depth[node]) g[node].push_back(it);
} else
dfs(it, node);
}
if (g[node].size() % 2) {
if (par != 0) g[node].push_back(par);
} else
g[par].push_back(node);
for (long long i = 0; i + 1 < g[node].size(); i += 2)
ans.push_back({g[node][i], {node, g[node][i + 1]}});
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (long long i = 1; i <= n; i++) {
if (!visited[i]) dfs(i, 0);
}
cout << ans.size() << "\n";
for (auto it : ans)
cout << it.first << " " << it.second.first << " " << it.second.second
<< "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, f[1005][1005], a, b, sum;
int x[1005], y[1005], r[1005], rx[1005], ry[1005];
bool cal(int i, int j) {
return (long long int)(x[i] - rx[j]) * (x[i] - rx[j]) +
(long long int)(y[i] - ry[j]) * (y[i] - ry[j]) <
(long long int)r[j] * r[j];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%d%d", x + i, y + i);
for (int i = 0; i < m; i++) scanf("%d%d%d", r + i, rx + i, ry + i);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (cal(i, j)) f[i][j] = 1;
for (int i = 0; i < k; i++) {
scanf("%d%d", &a, &b);
a--;
b--;
sum = 0;
for (int j = 0; j < m; j++)
if (f[a][j] ^ f[b][j]) sum++;
printf("%d\n", sum);
}
}
| 4 |
#include<iostream>
#include<string>
#define NUM 26
using namespace std;
int gcd(int a, int b){
if(a%b){
return gcd(b, a%b);
}
return b;
}
int main(){
int a, y, b, n, i, j, k, fy;
int ay[257];
string str, tmpstr;
cin>>n;cin.ignore();
for(i=0;i<n;i++){
getline(cin, str);
y=0;
tmpstr = str;
while(true){
tmpstr=str;
while(true){
y++;
if(gcd(NUM, y) == 1){
break;
}
}
for(j=0;j<tmpstr.size();j++){
if(tmpstr[j] != ' '){
ay[j] = int(tmpstr[j] - 'a') * y;
}else{
ay[j] = -1;
}
}
for(b=0;b<NUM;b++){
for(j=0;j<tmpstr.size();j++){
if(ay[j] == -1){
tmpstr[j] = ' ';
}else{
tmpstr[j] = 'a' + ((ay[j] + b) % NUM);
}
}
if(tmpstr.find("this") != string::npos)break;
if(tmpstr.find("that") != string::npos)break;
tmpstr = str;
}
if(b!=NUM)break;
}
cout << tmpstr << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef complex<double> P;
int main(){
int n;
map<int,int> p;
int mx = 0;
while( cin >> n){
mx = max(mx,++p[n]);
}
for(auto i : p )
if( mx == i.second ) cout << i.first << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int a[n + 1];
int b[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
int s = 0;
for (int i = 1; i <= n; i++) {
if (b[n - i + 1] > 0 && (b[n - i + 1] == b[n] - i + 1)) {
s++;
} else {
break;
}
}
if (s == b[n]) {
int i;
for (i = 1; i <= n - s; i++) {
if (b[i] > 0 && (i - (b[i] - s - 1)) > 0) {
break;
}
}
if (i > n - s) {
cout << n - s;
return 0;
}
}
s = 0;
for (int i = 1; i <= n; i++) {
if (b[i] > 0) {
s = max(s, i - (b[i] - 1));
}
}
cout << n + s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const long long MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
long long N, K, L, M;
struct matrix {
long long m[2][2];
} ji;
matrix m_cheng(matrix x, matrix y) {
matrix ans;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
ans.m[i][j] = 0;
for (int k = 0; k < 2; k++) {
ans.m[i][j] = (ans.m[i][j] + x.m[i][k] * y.m[k][j] % M) % M;
}
}
}
return ans;
}
matrix quick_matrix(matrix x, long long y) {
matrix ans;
ans.m[0][0] = ans.m[1][1] = 1;
ans.m[0][1] = ans.m[1][0] = 0;
while (y) {
if (y & 1) ans = m_cheng(ans, x);
y >>= 1;
x = m_cheng(x, x);
}
return ans;
}
long long Fib(long long x) {
if (x == 1) return 1;
if (x == 2) return 1;
matrix temp = quick_matrix(ji, x - 2);
return (temp.m[0][0] + temp.m[0][1]) % M;
}
long long quickmod(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % M;
y >>= 1;
x = x * x % M;
}
return ans;
}
int main() {
M = 1e9 + 7;
ji.m[0][0] = 1;
ji.m[0][1] = 1;
ji.m[1][0] = 1;
ji.m[1][1] = 0;
while (scanf("%I64d%I64d%I64d%I64d", &N, &K, &L, &M) != EOF) {
long long cnt0 = 0;
long long cnt1 = 0;
long long temp = 1;
long long temp2 = K;
long long len = 0;
while (temp2) {
if (temp2 & 1)
cnt1++;
else
cnt0++;
len++;
temp2 >>= 1;
}
if (len > L) {
printf("0\n");
continue;
}
cnt0 += L - len;
long long A = ((quickmod(2, N) - Fib(N + 2)) % M + M) % M;
long long ans = quickmod(Fib(N + 2), cnt0) * quickmod(A, cnt1) % M;
printf("%I64d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500007;
int n, t, cH, cS;
char a[maxn];
bool check(int v) {
stack<int> mystack;
int prev;
int c = v, cost = 0, pos = -1;
for (int i = 0, _a = (n); i < _a; ++i)
if (a[i] == 'S') {
if (mystack.empty()) {
c++;
} else {
prev = mystack.top();
mystack.pop();
if (mystack.empty()) {
cost += abs(prev - i) + abs(i - pos);
pos = prev;
}
}
} else if (a[i] == 'H') {
if (c > 0) {
c--;
cost += abs(i - pos);
pos = i;
} else {
mystack.push(i);
cost += abs(i - pos);
pos = i;
}
}
return cost <= t;
}
int main() {
scanf("%d%d\n", &n, &t);
gets(a);
cH = cS = 0;
for (int i = 0, _a = (n); i < _a; ++i)
if (a[i] == 'H')
cH++;
else if (a[i] == 'S')
cS++;
if (t >= n * 2 - 1) {
printf("%d\n", max(cH - cS, 0));
return 0;
}
int l = max(cH - cS, 0), r = cH, mid, res = 1000000007;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid)) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (res == 1000000007)
puts("-1");
else
printf("%d\n", res);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> ans;
long long root(long long x) {
long long left = 0, right = 1e9;
long long mid, ans;
while (left <= right) {
mid = (left + right) >> 1;
if (mid * mid <= x) {
ans = mid;
left = mid + 1;
} else
right = mid - 1;
}
return ans;
}
int main() {
int q;
long long L, R;
cin >> q;
for (long long a = 2; a <= 1e6; a++) {
double tmp = 1.0 * a * a * a;
long long tmp2 = a * a * a;
while (tmp <= 1e18) {
long long sqr = root(tmp2);
if (sqr * sqr != tmp2) {
ans.push_back(tmp2);
}
tmp *= a;
tmp2 *= a;
}
}
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
while (q--) {
cin >> L >> R;
cout << upper_bound(ans.begin(), ans.end(), R) -
lower_bound(ans.begin(), ans.end(), L) + root(R) - root(L - 1)
<< endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2500, M = 1000000;
int a[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int k;
cin >> k;
if (k <= M) {
cout << "1\n" << -k << endl;
return 0;
}
int n = 1501, d = 125000;
while ((k + d) % 1500) {
++d;
}
int c = d + (k + d) / 1500;
for (int i = 1; i <= 1500; i += 2) {
a[i] = 1;
a[i + 1] = -2;
}
a[n - 1] -= (d - 750);
a[n] = c;
cout << n << endl;
for (int i = 1; i <= n; ++i) {
cout << a[i] << ' ';
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int LINF = -1 * 1e6;
char str[1003], a[53], b[53];
int len, alen, blen;
int dp[1003][53][53];
int api[53], bpi[53];
void getpi(const char s[53], int *pi, int tlen) {
int j = 0;
for (int i = 2; i <= tlen; i++) {
while (j > 0 && s[j + 1] != s[i]) j = pi[j];
if (s[j + 1] == s[i]) j++;
pi[i] = j;
}
}
int main() {
scanf(" %s %s %s", str + 1, a + 1, b + 1);
len = strlen(str + 1);
alen = strlen(a + 1);
blen = strlen(b + 1);
getpi(a, api, alen);
getpi(b, bpi, blen);
for (int i = 0; i <= len; i++)
for (int j = 0; j <= alen; j++)
for (int k = 0; k <= blen; k++) dp[i][j][k] = LINF;
dp[0][0][0] = 0;
for (int i = 0; i < len; i++) {
for (int j = 0; j <= alen; j++) {
for (int k = 0; k <= blen; k++) {
if (dp[i][j][k] == LINF) continue;
if (str[i + 1] == '*') {
for (char c = 'a'; c <= 'z'; c++) {
int at = j, bt = k;
while (at > 0 && a[at + 1] != c) at = api[at];
while (bt > 0 && b[bt + 1] != c) bt = bpi[bt];
if (a[at + 1] == c) at++;
if (b[bt + 1] == c) bt++;
dp[i + 1][at][bt] = max(dp[i + 1][at][bt],
dp[i][j][k] + (at == alen) - (bt == blen));
}
} else {
int at = j, bt = k;
while (at > 0 && a[at + 1] != str[i + 1]) at = api[at];
while (bt > 0 && b[bt + 1] != str[i + 1]) bt = bpi[bt];
if (a[at + 1] == str[i + 1]) at++;
if (b[bt + 1] == str[i + 1]) bt++;
dp[i + 1][at][bt] =
max(dp[i + 1][at][bt], dp[i][j][k] + (at == alen) - (bt == blen));
}
}
}
}
int ret = LINF;
for (int i = 0; i <= alen; i++) {
for (int j = 0; j <= blen; j++) {
ret = max(ret, dp[len][i][j]);
}
}
printf("%d", ret);
}
| 4 |
#include <iostream>
using namespace std;
const int N = 8;
int rows[8];
bool cols[8];
bool dpos[15];
bool dneg[15];
bool skip[8];
void displayBoard(){
for(auto i = 0; i < N; ++i){
for(auto j = 0; j < N; ++j){
if(j == rows[i] && cols[j]) cout << 'Q';
else cout << '.';
}
cout << endl;
}
}
void putQueen(int i){
if(i == N){
displayBoard();
return;
}
if(skip[i]){
putQueen(i + 1);
return;
}
for(auto j = 0; j < N; ++j){
if(cols[j] || dpos[i + j] || dneg[i - j + N - 1]) continue;
rows[i] = j;
cols[j] = dpos[i + j] = dneg[i - j + N - 1] = true;
putQueen(i + 1);
cols[j] = dpos[i + j] = dneg[i - j + N - 1] = false;
}
}
int main(){
for(auto i = 0; i < N; ++i){
rows[i] = 0;
cols[i] = false;
skip[i] = false;
}
for(auto i = 0; i < 2 * N - 1; ++i){
dpos[i] = false;
dneg[i] = false;
}
// memset(rows, 0, sizeof(rows));
// memset(cols, false, sizeof(cols));
// memset(dpos, false, sizeof(dpos));
// memset(dneg, false, sizeof(dneg));
int k;
cin >> k;
for(auto i = 0; i < k; ++i){
int r, c;
cin >> r >> c;
skip[r] = true;
rows[r] = c;
cols[c] = dpos[r + c] = dneg[r - c + N - 1] = true;
}
// displayBoard();
putQueen(0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double P[110], PP, PP2, MAX;
int n;
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%lf", &P[i]);
sort(P, P + n);
if (P[n - 1] == 1.0) {
printf("%.13lf\n", 1.0);
return 0;
}
for (i = 0; i < n; i++) {
PP = 1;
PP2 = 0;
for (j = i; j < n; j++) {
PP = PP * (1 - P[j]);
PP2 += P[j] / (1 - P[j]);
}
if (MAX < PP * PP2) MAX = PP * PP2;
}
printf("%.13lf\n", MAX);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 3e6;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
int n;
long long a[maxn], b[maxn];
long long diff[maxn];
int ind[maxn];
int cnt[maxn];
void range(int l, int r) {
cout << r - l + 1 << '\n';
for (int i = l; i <= r; i++) cout << i << ' ';
cout << '\n';
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] += a[i - 1];
for (int i = 1; i <= n; i++) cin >> b[i], b[i] += b[i - 1];
int f = 0;
if (a[n] > b[n]) swap(a, b), f = 1;
int pos = 0;
for (int i = 1; i <= n; i++) {
while (b[pos] < a[i]) pos++;
if (a[i] == b[pos]) {
if (f)
range(1, pos), range(1, i);
else
range(1, i), range(1, pos);
return (0);
}
ind[i] = pos;
int x = b[pos] - a[i];
if (cnt[x]) {
if (f)
range(ind[cnt[x]] + 1, pos), range(cnt[x] + 1, i);
else
range(cnt[x] + 1, i), range(ind[cnt[x]] + 1, pos);
return (0);
}
cnt[x] = i;
}
return (0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int r, b;
int points[2][20][2] = {0};
bool flag = false;
int cha(int x, int y, int x2, int y2) {
if ((x * y2 - x2 * y) > 0)
return 1;
else
return -1;
}
bool connect(int i, int j, int a[]) {
int x[2][2] = {0};
int y[2][2] = {0};
x[0][0] = points[0][i][0];
x[0][1] = points[1][a[i]][0];
x[1][0] = points[0][j][0];
x[1][1] = points[1][a[j]][0];
y[0][0] = points[0][i][1];
y[0][1] = points[1][a[i]][1];
y[1][0] = points[0][j][1];
y[1][1] = points[1][a[j]][1];
int tmp1 = cha(x[1][0] - x[0][0], y[1][0] - y[0][0], x[0][1] - x[0][0],
y[0][1] - y[0][0]);
int tmp2 = cha(x[1][1] - x[0][0], y[1][1] - y[0][0], x[0][1] - x[0][0],
y[0][1] - y[0][0]);
int tmp3 = cha(x[0][0] - x[1][0], y[0][0] - y[1][0], x[1][1] - x[1][0],
y[1][1] - y[1][0]);
int tmp4 = cha(x[0][1] - x[1][0], y[0][1] - y[1][0], x[1][1] - x[1][0],
y[1][1] - y[1][0]);
if (tmp1 * tmp2 < 0 && tmp3 * tmp4 < 0)
return true;
else
return false;
}
bool check(int a[]) {
for (int i = 0; i < r; ++i) {
for (int j = i + 1; j < r; ++j) {
if (connect(i, j, a)) return false;
}
}
return true;
}
void matching(int a[], bool used[], int ind) {
if (ind == r) {
if (check(a)) flag = true;
} else {
for (int i = 0; i < r; ++i) {
if (!used[i]) {
a[ind] = i;
used[i] = 1;
matching(a, used, ind + 1);
used[i] = 0;
}
}
}
}
int main() {
scanf("%d%d", &r, &b);
if (r != b) {
cout << "No" << endl;
} else {
for (int i = 0; i < r; ++i) cin >> points[0][i][0] >> points[0][i][1];
for (int i = 0; i < r; ++i) cin >> points[1][i][0] >> points[1][i][1];
bool used[20] = {0};
int a[20] = {0};
matching(a, used, 0);
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 5 |
#import<bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long LL;
LL i,j,k,l,m=-1e9,n,s,w,z,c[5040],p[5040],v[5040],x[5040],y[5040];
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>n>>k;
for(;i++<n;)cin>>p[i];
for(i=0;i++<n;)
{
cin>>c[i];
m=max(m,c[i]);
}
for(i=0;i++<n;)
{
if(!v[i])
{
for(j=i,s=w=0;!v[j];j=p[j])
{
w++;
s+=c[j];
v[j]=1;
}
s=max(s,0LL);
for(j=i,l=0;l<w;j=p[j],l++)
{
x[j]=w;
y[j]=s;
}
}
}
for(i=0;i++<n;)
{
for(j=i,l=s=0,z=min(x[i],k);l++<z;j=p[j])
{
s+=c[j];
m=max(m,s+(k-l)/x[i]*y[i]);
}
}
cout<<m;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int isp[10000089], T = 0;
vector<long long> primes;
void prime_gen() {
primes.push_back(2);
T = 1;
for (long long i = 3; i <= 10000079; i += 2) {
if (!isp[i]) {
primes.push_back(i);
for (long long j = i * i; j <= 10000079; j += i) {
isp[j] = 1;
}
}
}
}
int main() {
long long N;
prime_gen();
while (cin >> N) {
long long M = N;
if (N == 1) {
cout << 1 << endl << 0 << endl;
continue;
}
int fact = 0, ar[1000], is = 0;
for (int i = 0; primes[i] * primes[i] <= (N); i++) {
while (N % primes[i] == 0) {
N /= primes[i];
fact++;
if (is < 3) {
ar[is++] = primes[i];
}
}
}
if (N > 1) {
ar[is++] = N;
fact++;
}
if (fact == 1) {
cout << 1 << endl << 0 << endl;
} else if (fact == 2) {
cout << 2 << endl;
} else {
cout << 1 << endl;
if (is < 2)
while (1)
;
cout << (ar[0] * ar[1]) << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b; cin >> a >> b;
string s; cin >> s;
int n = a + b;
if (n % 2 == 0 && a % 2 == 1 && b % 2 == 1) {
cout << "-1\n";
return;
}
for (char c : s) {
if (c == '0') a -= 1;
else if (c == '1') b -= 1;
if (a < 0 || b < 0) {
cout << "-1\n";
return;
}
}
for (int i = 0; i < n / 2; ++i) {
if (s[i] == '?' && s[n - 1 - i] != '?') {
s[i] = s[n - 1 - i];
if (s[n - 1 - i] == '0') a -= 1;
else b -= 1;
} else if (s[i] != '?' && s[n - 1 - i] == '?') {
s[n - 1 - i] = s[i];
if (s[i] == '0') a -= 1;
else b -= 1;
}
if (a < 0 || b < 0) {
cout << "-1\n";
return;
}
}
for (int i = 0; i < n / 2; ++i) {
if (s[i] == '?' && s[n - 1 - i] == '?') {
if (a >= 2) {
s[i] = s[n - 1 - i] = '0';
} else {
s[i] = s[n - 1 - i] = '1';
}
if (s[i] == '0') a -= 2;
else b -= 2;
} else {
if (s[i] != s[n - 1 - i]) {
cout << "-1\n";
return;
}
}
if (a < 0 || b < 0) {
cout << "-1\n";
return;
}
}
if (n % 2 == 1 && s[n / 2] == '?') {
if (a > 0) s[n / 2] = '0';
else s[n / 2] = '1';
}
cout << s << "\n";
}
int main() {
int t; cin >> t;
while (t--) solve();
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int ans[200005];
int n, val;
struct node {
int l, r;
int len;
node(int lll, int rr, int llen) {
l = lll;
r = rr;
len = llen;
}
friend bool operator<(const node &a, const node &b) {
if (a.len == b.len) return a.l > b.l;
return a.len < b.len;
}
};
void bfs() {
priority_queue<node> Q;
node t = node(1, n, n);
Q.push(t);
while (!Q.empty()) {
node T = Q.top();
Q.pop();
if (T.l > T.r) continue;
int mid;
int l = T.l, r = T.r;
if ((r - l + 1) % 2 == 0)
mid = (l + r - 1) / 2;
else
mid = (l + r) / 2;
ans[mid] = val;
val++;
if (mid % 2 == 0) {
if ((r - l + 1) % 2 == 0) {
Q.push(node(mid + 1, r, r - mid));
Q.push(node(l, mid - 1, mid - l));
} else {
Q.push(node(l, mid - 1, mid - l));
Q.push(node(mid + 1, r, r - mid));
}
} else {
if ((r - l + 1) % 2 == 0) {
Q.push(node(mid + 1, r, r - mid));
Q.push(node(l, mid - 1, mid - l));
} else {
Q.push(node(l, mid - 1, mid - l));
Q.push(node(mid + 1, r, r - mid));
}
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(0);
int t;
cin >> t;
while (t--) {
memset(ans, 0, sizeof(ans));
cin >> n;
val = 1;
if (n == 1)
cout << 1 << "\n";
else {
bfs();
cout << ans[1];
for (int i = 2; i <= n; ++i) cout << " " << ans[i];
cout << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[300005];
int col[300005], cnt, m;
bool comp(vector<int> x, vector<int> y) {
if (x.size() != y.size()) return x.size() > y.size();
int mn = min(x.size(), y.size());
for (int i = 0; i < mn; i++)
if (x[i] < y[i])
return 1;
else
return 0;
return 1;
}
int tr[1500000];
void init(int nd, int b, int e) {
if (b == e) {
tr[nd] = b;
return;
}
int md, lf, rt;
md = (b + e) / 2;
lf = nd * 2;
rt = lf + 1;
init(lf, b, md);
init(rt, md + 1, e);
tr[nd] = min(tr[lf], tr[rt]);
}
void update(int nd, int b, int e, int i, int x) {
if (i > e || i < b) return;
if (b == e) {
tr[nd] = b + x;
return;
}
int md, lf, rt;
md = (b + e) / 2;
lf = nd * 2;
rt = lf + 1;
update(lf, b, md, i, x);
update(rt, md + 1, e, i, x);
tr[nd] = min(tr[lf], tr[rt]);
}
vector<int> g[300000];
void dfs(int i, int par) {
int k = v[i].size();
for (int j = 0; j < k; j++) {
if (col[v[i][j]] != 0) update(1, 1, m, col[v[i][j]], 300000);
}
for (int j = 0; j < k; j++) {
if (col[v[i][j]] == 0) {
col[v[i][j]] = tr[1];
cnt = max(cnt, tr[1]);
update(1, 1, m, tr[1], 300000);
}
}
for (int j = 0; j < k; j++) {
update(1, 1, m, col[v[i][j]], 0);
}
k = g[i].size();
for (int j = 0; j < k; j++) {
if (g[i][j] != par) {
dfs(g[i][j], i);
}
}
}
int main() {
int n;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int vl;
scanf("%d", &vl);
v[i].push_back(vl);
}
}
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
init(1, 1, m);
cnt = 1;
dfs(0, -1);
cout << cnt << endl;
for (int i = 1; i <= m; i++) printf("%d ", col[i] == 0 ? 1 : col[i]);
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class _Tp>
void ckmax(_Tp &a, _Tp b) {
if (a < b) a = b;
}
template <class _Tp>
void ckmin(_Tp &a, _Tp b) {
if (a > b) a = b;
}
template <class _Tp>
_Tp gcd(_Tp a, _Tp b) {
return (b == 0) ? (a) : (gcd(b, a % b));
}
int read() {
char ch = getchar();
bool f = 1;
int x = 0;
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') f = 0, ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch & 15);
ch = getchar();
}
return f ? x : -x;
}
const int inf = 1000000000;
const long long Inf = 1000000000000000000ll;
struct Edge {
int to, nxt, frm;
long long p, w, c;
} e[200050 << 1];
int Top, head[200050];
void add(int u, int v, long long w, long long p) {
e[++Top].to = v;
e[Top].nxt = head[u];
head[u] = Top;
e[Top].p = p;
e[Top].w = w;
e[Top].frm = u;
}
bool tag;
long long siz[200050];
void dfs1(int u) {
for (int i = head[u]; i; i = e[i].nxt) {
if (tag) return;
dfs1(e[i].to);
long long t = min(min(e[i].w - 1, e[i].p), e[i].p - siz[e[i].to]);
if (t < 0) {
tag = 1;
return;
}
e[i].p -= t;
e[i].w -= t;
e[i].c = t;
siz[u] += siz[e[i].to] + e[i].w;
}
}
long long dfs2(int u, long long val) {
long long delta = 0;
for (int i = head[u]; i; i = e[i].nxt) {
long long t = min(val, e[i].c);
e[i].w += t;
e[i].p += t;
delta += t;
val -= t;
long long sons = dfs2(e[i].to, min(val, e[i].p - siz[e[i].to]));
delta += sons;
val -= sons;
}
return delta;
}
int n;
int main() {
n = read();
for (int i = 1; i < n; ++i) {
int x = read(), y = read(), w = read(), p = read();
add(x, y, w, p);
}
dfs1(1);
if (tag) {
puts("-1");
return 0;
}
dfs2(1, Inf);
printf("%d\n", n);
for (int i = 1; i <= Top; ++i)
printf("%d %d %lld %lld\n", e[i].frm, e[i].to, e[i].w, e[i].p);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void ckmin(T &a, T b) {
a = min(a, b);
}
template <class T>
void ckmax(T &a, T b) {
a = max(a, b);
}
const int inf = int(1e9);
const int mod = inf + 7;
const int N = 1e6 + 555;
const double PI = acos(-1.0);
void solve() {
int n, k;
string s;
cin >> n >> k >> s;
int need = k / 2;
int ca = 0, cb = 0;
string ans = "";
for (int i = 0; i < (int)s.size(); ++i) {
if (s[i] == '(' && need) {
ans += '(';
need--;
ca++;
} else if (s[i] == ')' && cb < ca) {
ans += ')';
cb++;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[7];
long long t1, t2, t3, t4;
long long ans;
void work() {
for (int i = 1; i <= 6; i++) cin >> a[i];
t1 = min(a[1], a[5]);
t2 = min(a[2], a[4]);
t3 = max(a[1], a[5]) - t1;
ans = (a[6] + (t1 + a[6] - 1)) * (t1) + t1;
ans += (a[3] + (t2 + a[3] - 1)) * (t2) + t2;
ans += t3 * (a[6] + t1) * 2;
cout << ans << endl;
}
int main() {
work();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[200003];
int n, num[200003];
int main() {
gets(s);
int len = strlen(s);
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
num[k]++;
}
for (int i = 1; i <= len / 2; i++) num[i] += num[i - 1];
for (int i = 0; i < len; i++) {
if (num[i + 1] % 2 == 1) {
char t = s[i];
s[i] = s[len - i - 1];
s[len - i - 1] = t;
}
}
puts(s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int n, a[200005], used[200005];
string s1, s2;
long long int ok(long long int x) {
memset(used, 0, sizeof(used));
for (long long int i = 0; i < x; i++) used[a[i]] = 1;
long long int cnt = 0;
for (long long int i = 0; i < n; i++) {
if (!used[i] && s1[i] == s2[cnt]) cnt++;
if (cnt == s2.size()) return 1;
}
return 0;
}
int main() {
long long int i, j, k, nb, x, y, z;
cin >> s1 >> s2;
n = s1.size();
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) a[i]--;
x = -1;
for (z = n; z >= 1; z /= 2) {
while (z + x <= n && ok(z + x)) x += z;
}
if (x != -1)
cout << x << endl;
else
cout << "0";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double dp[210][210][210 * 2];
int p[210], a[210];
inline int fix(int x, int bb) {
if (x < 0) return x;
if (x >= bb) return bb - 1;
return x;
}
int main() {
int i, j, k, l, n, r;
cin >> n >> l >> k;
for (i = 1; i <= n; i++) cin >> p[i];
for (i = 1; i <= n; i++) cin >> a[i];
for (r = 0; r < 210; r++)
for (i = 0; i <= n; i++)
for (j = 0; j < 210 * 2; j++) dp[r][i][j] = 0;
dp[0][0][210 + k] = 1;
for (i = 1; i <= n; i++) {
if (a[i] == -1) {
for (j = 0; j < 210; j++)
for (r = 0; r < 210 * 2; r++) {
dp[i][fix(j + 1, 210)][fix(r - 1, 210 * 2)] +=
dp[i - 1][j][r] * p[i] * 0.01;
dp[i][j][r] += dp[i - 1][j][r] * (100 - p[i]) * 0.01;
}
} else {
for (j = 0; j < 210; j++)
for (r = 0; r < 210 * 2; r++) {
dp[i][j + 1][fix(r + a[i], 210 * 2)] += dp[i - 1][j][r] * p[i] * 0.01;
dp[i][j][r] += dp[i - 1][j][r] * (100 - p[i]) * 0.01;
}
}
}
double an = 0;
for (i = l; i < 210; i++)
for (j = 210; j < 210 * 2; j++) an += dp[n][i][j];
printf("%.9lf\n", an);
return 0;
}
| 4 |
#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
#include<map>
#include<functional>
#include<stack>
#include<list>
#include<set>
#include<deque>
#include<climits>
using namespace std;
typedef long long ll;
int main(){
int N;
string S, T;
cin >> N >> S >> T;
int cntS[26] = {}, cntT[26] = {};
for (int i = 0; i < N; i++)
{
cntS[S[i] - 'a']++;
cntT[T[i] - 'a']++;
}
priority_queue<int> s, t;
for (int i = 0; i < 26; i++)
{
s.push(cntS[i]);
t.push(cntT[i]);
}
int ans = 0;
while(!s.empty() || !t.empty())
{
//printf("%d, %d\n", s.top(), t.top());
ans += abs(s.top() - t.top());
s.pop();
t.pop();
}
printf("%d\n", ans/2);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
bool vis[100005][2];
pair<int, int> path[100005][2];
bool draw = false;
void bfs(int v) {
queue<pair<int, int> > q;
q.push(make_pair(v, 0));
vis[v][0] = true;
path[v][0] = {-1, -1};
int it = 0;
while (!q.empty() && it < 2e6) {
int x = q.front().first, dis = q.front().second;
if (dis >= 1e6) {
draw = true;
}
if (g[x].size() == 0 && dis % 2 != 0) {
return;
}
q.pop();
for (int i = 0; i < g[x].size(); i++) {
if (!vis[g[x][i]][(dis + 1) % 2]) {
q.push(make_pair(g[x][i], dis + 1));
vis[g[x][i]][(dis + 1) % 2] = true;
path[g[x][i]][(dis + 1) % 2] = {x, dis % 2};
}
}
it++;
}
}
int col[200005];
bool dfs(int v) {
col[v] = 1;
bool cycle = false;
for (int i = 0; i < g[v].size(); i++) {
if (col[g[v][i]] == 0) {
if (dfs(g[v][i])) {
cycle = true;
}
}
if (col[g[v][i]] == 1) {
cycle = true;
}
}
col[v] = 2;
return cycle;
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n + 1);
for (int i = 1; i <= n; i++) {
int c;
cin >> c;
for (int j = 0; j < c; j++) {
int u;
cin >> u;
g[i].push_back(u);
}
}
int s;
cin >> s;
bfs(s);
for (int i = 1; i <= n; i++) {
if ((int)g[i].size() == 0 && vis[i][1]) {
cout << "Win\n";
int curr = 0;
vector<int> ans;
for (int j = i; j != -1; j = path[j][curr].first) {
ans.push_back(j);
if (curr == 0) {
curr = 1;
} else {
curr = 0;
}
}
for (int j = ans.size() - 1; j >= 0; j--) {
cout << ans[j] << " ";
}
return 0;
}
}
if (dfs(s))
cout << "Draw";
else
cout << "Lose";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x(0), f(1);
char c(getchar());
while (c < '0' || '9' < c) {
if (c == '-') {
f = -1;
}
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return f * x;
}
void Write(int x) {
if (x < 0) {
printf("-");
x = -x;
}
if (9 < x) {
Write(x / 10);
}
putchar(x % 10 + '0');
}
inline void Writeln(int x) {
Write(x);
puts("");
}
const int MAXN = 1e5 + 5;
long long f[MAXN][4][4];
int dis[4][4];
int ans[4][4];
long long DFS(int n, int l, int r) {
if (f[n][l][r]) {
return f[n][l][r];
}
if (n == 1) {
return ans[l][r];
}
return f[n][l][r] = min(
DFS(n - 1, l, 6 - l - r) + DFS(n - 1, 6 - l - r, r) + dis[l][r],
(DFS(n - 1, l, r) << 1) + DFS(n - 1, r, l) + dis[l][6 - l - r] +
dis[6 - l - r][r]);
}
int main() {
for (int i = 1; i <= 3; ++i) {
for (int j = 1; j <= 3; ++j) {
scanf("%d", &dis[i][j]);
ans[i][j] = dis[i][j];
}
}
for (int k = 1; k <= 3; ++k) {
for (int i = 1; i <= 3; ++i) {
for (int j = 1; j <= 3; ++j) {
ans[i][j] = min(ans[i][j], ans[i][k] + ans[k][j]);
}
}
}
printf("%lld\n", DFS(Read(), 1, 3));
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma comment(linker, "/STACK:367077216")
using namespace std;
const long double EPS = 1e-9;
const long double PI = acos(-1);
int mod = (int)998244353;
const int MOD7 = 1000000007;
const int MOD9 = 1000000009;
const int a228 = 18;
const int inf = 1e9;
const long long kekmod = 1791791791;
const long long bestmod = 1148822869;
vector<long long> genarray(long long n) {
if (n == 1) return {1};
if (n == 2) return {3, 4};
if (n % 2 == 1) {
vector<long long> ans;
ans.push_back(2);
for (long long i = 0; i < n - 2; ++i) ans.push_back(1);
ans.push_back(n / 2 + 1);
return ans;
} else {
vector<long long> ans;
ans.push_back(2);
ans.push_back(2);
for (long long i = 0; i < n - 3; ++i) ans.push_back(1);
ans.push_back(n / 2 + 2);
return ans;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
srand(time(NULL));
long long n, m;
cin >> n >> m;
vector<long long> a = genarray(n);
vector<long long> b = genarray(m);
vector<vector<long long>> ans(n, vector<long long>(m));
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
ans[i][j] = a[i] * b[j];
}
}
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
cout << ans[i][j] << ' ';
}
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2000];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
sort(a, a + n);
printf("%d ", a[n - 1]);
for (int i = 1; i < n - 1; i++) {
printf("%d ", a[i]);
}
printf("%d\n", a[0]);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int power(int a, int b) {
long long int t;
if (b == 0)
return 1;
else if (b == 1)
return a;
else if (b % 2) {
t = power(a, b / 2);
t *= t;
t %= 1000000007;
t *= a;
t %= 1000000007;
return t;
} else {
t = power(a, b / 2);
t *= t;
t %= 1000000007;
return t;
}
}
int main() {
string str;
cin >> str;
long long int a = 0, k = 1;
for (int i = 0; i < str.length(); i++) {
if (str[str.length() - 1 - i] == '1') {
a += k;
a %= 1000000007;
}
k *= 2;
k %= 1000000007;
}
a *= power(2, str.length() - 1);
a %= 1000000007;
cout << a << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int x;
cin >> x;
printf("%.9lf\n", x*x*x/27.0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5;
int pr[maxn];
int cnt[6][6][200000];
void precalc() {
for (int i = 2; i * i <= maxn; i++)
if (pr[i] == 0) {
for (int j = i * i; j <= maxn; j += i) pr[j] = i;
}
for (int len = 1; len <= 5; len++) {
int fin = 1;
for (int j = 0; j < len; j++) fin *= 10;
for (int mask = 2; mask < fin; mask++)
if (pr[mask] == 0) {
int rest = 0;
int st = 1;
int x = mask;
for (int pos = len; pos >= 1; pos--) {
cnt[len][pos][(x / 10) * st + rest]++;
rest = (x % 10) * st + rest;
x /= 10;
st *= 10;
}
}
}
}
int x[6];
int y[6];
int ret = 0;
int st[6] = {1, 10, 100, 1000, 10000, 100000};
int n = 0;
void rec(int pos) {
if (pos == n) {
int tmp = 1;
for (int i = 2; i <= n; i++) tmp *= cnt[n][i][x[i] * st[n - i] + y[i]];
ret += tmp;
return;
}
int fi = 1;
for (int j = pos + 1; j <= n; j++) fi *= 10;
for (int mask = 1; mask < fi; mask++) {
int xx = mask;
y[pos] = xx;
for (int j = n; j > pos; j--) {
x[j] += (xx % 10) * st[j - pos - 1];
xx /= 10;
}
rec(pos + 1);
xx = mask;
for (int j = n; j > pos; j--) {
x[j] -= (xx % 10) * st[j - pos - 1];
xx /= 10;
}
}
}
int ans(int xx) {
n = 0;
vector<int> dig;
dig.clear();
while (xx > 0) {
n++;
dig.push_back(xx % 10);
xx /= 10;
}
for (int i = 0; i <= n; i++) {
x[i] = y[i] = 0;
}
for (int i = 0; i < n; i++) x[n - i] += dig[i] * st[n - i - 2];
ret = 0;
rec(2);
return ret;
}
int main() {
int test = 0;
cin >> test;
precalc();
while (test--) {
int x = 0;
cin >> x;
cout << ans(x) << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3000;
int n, m, x, y;
vector<int> g[N];
int d[N][N];
int s1, t1, l1;
int s2, t2, l2;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) d[i][j] = -1;
for (int i = 0; i < n; i++) {
queue<int> q;
d[i][i] = 0;
q.push(i);
while (!q.empty()) {
int a = q.front();
q.pop();
for (int j = 0; j < g[a].size(); j++) {
int b = g[a][j];
if (d[i][b] == -1) {
d[i][b] = d[i][a] + 1;
q.push(b);
}
}
}
}
cin >> s1 >> t1 >> l1;
cin >> s2 >> t2 >> l2;
s1--, t1--, s2--, t2--;
int ans = m + 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int f1 = d[s1][i] + d[i][j] + d[j][t1];
int f2 = d[s2][i] + d[i][j] + d[j][t2];
int f3 = d[t1][i] + d[i][j] + d[j][s1];
if (f1 <= l1 && f2 <= l2) ans = min(ans, f1 + f2 - d[i][j]);
if (f3 <= l1 && f2 <= l2) ans = min(ans, f3 + f2 - d[i][j]);
}
}
if (d[s1][t1] <= l1 && d[s2][t2] <= l2) ans = min(ans, d[s1][t1] + d[s2][t2]);
cout << (m - ans);
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int main(){
int cnt, a, b, tmp;
while(cin>>a>>b){
cnt=0;
tmp=a+b;
while(tmp>0){
cnt++;
tmp/=10;
}
cout<<cnt<<endl;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int N, C;
int A[401], B[401];
long long ptable[401][401]; //dp a, b = 1^b + ... + a^b
long long dp[401][401];
const int MOD = 1e9+7;
void init()
{
for(int b=0; b<=400; ++b)
{
for(int a=1; a<=400; ++a)
{
long long x = 1;
for(int i=0; i<b; ++i)
x = (x*a)%MOD;
ptable[a][b] = (ptable[a-1][b] + x) %MOD;
}
}
return;
}
int main()
{
init();
scanf("%d%d", &N, &C);
for(int i=0; i<N; ++i) scanf("%d", A+i+1);
for(int i=0; i<N; ++i) scanf("%d", B+i+1);
dp[0][0] = 1;
for(int k=1; k<=N; ++k)
{
for(int c=0; c<=C; ++c)
{
dp[k][c] = 0;
for(int ak=0; ak<=c; ++ak)
{
dp[k][c] += dp[k-1][c-ak] * (MOD + ptable[B[k]][ak] -ptable[A[k]-1][ak]);
dp[k][c] %= MOD;
}
}
}
printf("%lld\n", dp[N][C]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10, K = 1e6 + 10;
int n, m, k, p;
long long rowSum[N], colSum[N];
long long rowGain[K], colGain[K];
priority_queue<long long> rowPQ, colPQ;
long long ans = LLONG_MIN;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
scanf("%d%d%d%d", &n, &m, &k, &p);
for (int r = 1; r <= n; r++)
for (int c = 1; c <= m; c++) {
int a;
scanf("%d", &a);
rowSum[r] += a;
colSum[c] += a;
if (r == n) colPQ.push(colSum[c]);
if (c == m) rowPQ.push(rowSum[r]);
}
for (int kk = 1; kk <= k; kk++) {
rowGain[kk] = rowGain[kk - 1] + rowPQ.top();
int top = rowPQ.top();
top -= p * m;
rowPQ.pop();
rowPQ.push(top);
colGain[kk] = colGain[kk - 1] + colPQ.top();
top = colPQ.top();
top -= p * n;
colPQ.pop();
colPQ.push(top);
}
for (int rowK = 0; rowK <= k; rowK++) {
int colK = k - rowK;
long long cost = (long long)p * rowK * colK;
ans = max(ans, rowGain[rowK] + colGain[colK] - cost);
}
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include<cstdio>
#include<algorithm>
#include<ctype.h>
#define int long long
using namespace std;
inline int read()
{
int x=0,f=1;char ch=getchar();
while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int T,n,k,a[100005],ans;
bool check(int x)
{
for(int i=1;i<=n;i++)
if(a[i]==x)return false;
return true;
}
signed main()
{
T=read();
while(T--)
{
n=read(),k=read();
for(int i=1;i<=n;i++)
a[i]=read();
sort(a+1,a+n+1);
int maxx=0,mex=0;
for(int i=1;i<=n;i++)
{
if(a[i]==mex)mex++;
maxx=max(maxx,a[i]);
}
if(maxx>mex&&k!=0)
{
int ret=(maxx+mex)/2;
if((maxx+mex)&1)
ret++;
if(check(ret))
printf("%lld\n",n+1);
else
printf("%lld\n",n);
}
else
printf("%lld\n",n+k);
}
} | 2 |
#include <bits/stdc++.h>
using namespace std;
char func(char a) {
if (a == 'a') return 'b';
return 'a';
}
int main() {
int n, ans = 0;
cin >> n;
string s;
cin >> s;
for (int i = 1; i < n; i += 2) {
if (s[i] == s[i - 1]) {
ans++;
s[i] = func(s[i]);
}
}
cout << ans << endl;
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ans;
int main() {
int n, b = 0, c = INT_MAX;
cin >> n;
int a[n];
for (int z = 0; z < n; z++) {
cin >> a[z];
b = max(b, a[z]);
c = min(c, a[z]);
}
cout << max(0, b - c - (n - 1));
}
| 1 |
#include<iostream>
using namespace std;
int main() {
int W, H, C, divisor, bolck_sum, ans;
cin >> W >> H >> C;
/* 回数を減らすために少ない方に入れ替える */
if (W >= H)swap(W, H);
for (int i = 1; i <= W; i++) {
if (W % i == 0) { /* 約数を求める */
divisor = i;
if (H % divisor == 0) bolck_sum = divisor * divisor; /* 求めた約数から正方形を求める */
}
}
/* 最小の費用の計算 */
ans = C * (W * H) / bolck_sum; /* 値段×( 縦の土地 × 横の土地 ) / 正方形の土地 */
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
inline unsigned long long gen(unsigned long long x) {
return x ^= x << 13, x ^= x >> 7, x ^= x << 17;
}
std::map<unsigned long long, unsigned long long> map = {
{12807924072251749236, 25},
{8316942776798443357, 125},
{1427138097708291513, 230},
{13880348951595021113, 120},
{6374836989393964970, 27},
{6374836991524949803, 26},
{1617718956769881006, 2000000000000000000},
{13104906001067308152, 2},
{6374836542479079162, 52},
{1997500239843237258, 53},
{5005434723849298790, 207},
{705889088240544217, 6699},
{7321221188472650894, 6812},
{13284730628184471094, 622832834},
{6866128521784462594, 620189650},
{14983406519702253193, 624668154},
{14986992737031916708, 625406094},
{15224900970971026899, 12972},
{7657887909776344917, 12972},
{10759796125372197250, 216245},
{7027837586770640842, 216245},
{4670933202406654248, 240314083},
{10338390062674655084, 240314083},
{5461628462320801029, 122973},
{16696814090209157332, 1038071},
{14376707829214466416, 20203527703},
{7011678043931836694, 19018621728},
{527898215563447140, 247432457339710},
{9406324644475704115, 229533246298127},
{11225131137915910858, 20929602014808},
{2935760206482797523, 7900},
{1975800214784338554, 17544094280356},
{5359405218643444672, 17544044596722},
{5871972456727461334, 17469733613212},
{5697754496098349964, 27728032700840},
{16953734000944670709, 221336290388556},
};
int main() {
unsigned long long x = 0, ans = 0;
for (int i = 0; i < 5; ++i) std::cin >> x, ans = gen(ans) + x;
std::cout << map[ans] << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100000 + 10;
int main() {
int n;
while (~scanf("%d", &n)) {
int a[M], dp[M], s[M];
int res = 0;
memset(s, 0, sizeof(s));
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
s[a[i]] = 1;
if (s[a[i] - 1])
dp[a[i]] = dp[a[i] - 1] + 1;
else
dp[a[i]] = 1;
res = max(dp[a[i]], res);
}
printf("%d\n", n - res);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 2e5 + 4;
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void input() {}
int main() {
fastio();
input();
int n;
cin >> n;
int a[n + 1];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] != 25) {
cout << "NO" << endl;
} else {
int x = 1;
map<int, int> make_pair;
make_pair[25] = 1;
for (int i = 1; i < n; i++) {
if (a[i] == 25) {
make_pair[25]++;
} else if (a[i] == 50) {
make_pair[50]++;
if (make_pair[25] <= 0) {
cout << "NO" << endl;
return 0;
}
make_pair[25]--;
} else {
make_pair[100]++;
if (make_pair[50] <= 0 && make_pair[25] < 1) {
cout << "NO" << endl;
return 0;
} else if (make_pair[50] > 0 && make_pair[25] >= 1) {
make_pair[50]--;
make_pair[25]--;
} else if (make_pair[25] > 2) {
make_pair[25]--;
make_pair[25]--;
make_pair[25]--;
} else {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int pd(long long int x, long long int y) {
if (x % y == 0)
return x / y;
else
return x / y + 1;
}
long long int mdls(long long int x) { return max(x, -x); }
long long int pow1(long long int n, long long int p) {
if (p == 0) return 1;
long long int x = pow1(n, p / 2);
x = (x * x);
if (p % 2 == 0)
return x;
else
return (x * n);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int t = 1;
while (t--) {
long long int n, m, j, l, i;
long long int k;
long long int t1, t2;
cin >> n >> t1 >> t2 >> k;
long long int a[n], b[n];
long long int d[n];
long long int e[n];
map<long long int, long long int> M;
long double c[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
a[i] *= 100;
b[i] *= 100;
long double g = 100;
long long int ans1 = (a[i] / 100) * t1 * ((100 - k)) + b[i] * t2;
long long int ans2 = (b[i] / 100) * t1 * ((100 - k)) + a[i] * t2;
long long int ans = max(ans1, ans2);
d[i] = ans;
e[i] = ans;
}
sort(e, e + n);
long long int counter = n;
for (j = n - 1; j >= 0; j--) {
for (i = 0; i < n; i++) {
if (M[i] != -1) {
if (e[j] == d[i]) {
if (d[i] % 100 < 10)
cout << i + 1 << " " << d[i] / 100 << ".0" << d[i] % 100;
else
cout << i + 1 << " " << d[i] / 100 << "." << d[i] % 100;
cout << "\n";
counter--;
M[i] = -1;
break;
}
}
}
}
}
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main(){
int n;
cin >> n;
for(int i=0;i<n;i++){
int a,b,c;
cin >> a >> b >> c;
if((a*a+b*b==c*c)||(b*b+c*c==a*a)||(c*c+a*a==b*b))
cout << "YES" << endl;
else cout << "NO" << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> d1;
vector<long long> d2;
struct Point {
long long x, y;
};
bool check(Point p1, Point p2, Point p3) {
if (p1.x == p2.x) {
long long miny = min(p1.y, p2.y);
long long maxy = max(p1.y, p2.y);
if (p3.y <= miny || p3.y >= maxy) {
return true;
}
}
if (p1.y == p2.y) {
long long minx = min(p1.x, p2.x);
long long maxx = max(p1.x, p2.x);
if (p3.x <= minx || p3.x >= maxx) {
return true;
}
}
return false;
}
int main() {
Point p1, p2, p3;
cin >> p1.x >> p1.y;
cin >> p2.x >> p2.y;
cin >> p3.x >> p3.y;
if (p1.x == p2.x && p1.x == p3.x) {
cout << 1 << endl;
return 0;
} else if (p1.y == p2.y && p1.y == p3.y) {
cout << 1 << endl;
return 0;
}
if (check(p1, p2, p3) || check(p2, p1, p3) || check(p1, p3, p2) ||
check(p3, p1, p2) || check(p2, p3, p1) || check(p3, p2, p1)) {
cout << 2 << endl;
return 0;
}
cout << 3 << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int M=100017;
bool book[510][510];
int n,m,a[M],b[M];
bool vis[510];
int main(){
cin>>n>>m;
for(int i=1;i<=m;i++){
cin>>a[i]>>b[i];
}
for(int i=1;i<=n;i++){
book[i][i]=1;
for(int j=m;j>=1;j--){
bool x=book[i][a[j]],y=book[i][b[j]];
if(x&&y){
vis[i]=1;
break;
}
else if(x){
book[i][b[j]]=1;
}
else if(y){
book[i][a[j]]=1;
}
}
}
int ans=0;
for(int i=1;i<n;i++){
if(vis[i]){
continue;
}
for(int j=i+1;j<=n;j++){
if(vis[j]){
continue;
}
bool flag=1;
for(int k=1;k<=n;k++){
if(book[i][k]&&book[j][k]){
flag=0;
}
}
ans+=flag;
}
}
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, w, i, step, Max;
int a[100000 + 5], sum[100000 + 5];
bool ok(int l) {
int crt, m2;
m2 = m;
for (int j = 1; j <= n; ++j) sum[j] = 0;
for (int j = 1; j <= n; ++j) {
sum[j] += sum[j - 1];
if (sum[j] + a[j] >= l) continue;
crt = sum[j] + a[j];
if (l - crt > m2) return false;
m2 -= (l - crt);
sum[j] += (l - crt);
sum[min(n + 1, j + w)] -= (l - crt);
}
return true;
}
int main() {
scanf("%d%d%d", &n, &m, &w);
for (i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
Max = max(Max, a[i] + m);
}
for (step = 1; step < Max; step <<= 1)
;
for (i = 0; step; step >>= 1)
if (i + step <= Max)
if (ok(i + step)) i += step;
printf("%d\n", i);
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 2e5 + 54;
int n, a[N], s[N];
long long ans;
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) std::cin >> a[i], ++s[a[i]];
for (int i = 1; i <= n; ++i)
if (s[i]) ans += (long long) s[i] * (s[i] - 1) / 2;
for (int i = 1; i <= n; ++i) {
std::cout << ans - s[a[i]] + 1 << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20000;
long long int inf = 1000ll * 1000 * 1000 * 1000 * 1000 * 1000;
vector<pair<int, int> > adj[maxn];
vector<pair<int, pair<int, int> > > sadj[maxn];
vector<pair<pair<int, int>, pair<int, int> > > E;
long long int d[maxn];
int mark[maxn];
void mul_dij(int s1, int s2, int f, char state) {
map<pair<int, int>, int> mp;
d[s1] = 0;
d[s2] = 0;
mark[s1] |= 1;
mark[s2] |= 2;
set<pair<int, int> > st;
st.insert({d[s1], s1});
st.insert({d[s2], s2});
while (!st.empty()) {
int u = st.begin()->second;
st.erase(st.begin());
for (pair<int, int> p : adj[u]) {
if (d[p.first] > d[u] + p.second) {
st.erase({d[p.first], p.first});
d[p.first] = d[u] + p.second;
mark[p.first] = mark[u];
st.insert({d[p.first], p.first});
continue;
}
if (d[p.first] == d[u] + p.second) {
mark[p.first] |= mark[u];
}
}
for (auto p : sadj[u]) {
int weight = (mark[u] == 1)
? p.second.first
: ((mark[u] == 2) ? p.second.second
: ((state == 'W') ? p.second.second
: p.second.first));
mp[{u, p.first}] = weight;
if (d[p.first] > d[u] + weight) {
st.erase({d[p.first], p.first});
d[p.first] = d[u] + weight;
st.insert({d[p.first], p.first});
mark[p.first] = mark[u];
continue;
}
if (d[p.first] == d[u] + weight) {
mark[p.first] |= mark[u];
}
}
}
if (mark[f] == 1) {
cout << "WIN\n";
for (auto p : E) {
long long int res = ((mp[p.first]) ? mp[p.first] : p.second.first);
if (res == 8382401) {
cout << p.second.second << " ";
} else {
cout << res << " ";
}
}
exit(0);
}
if (mark[f] == 3 && state == 'D') {
cout << "DRAW\n";
for (auto p : E) {
cout << ((mp[p.first]) ? mp[p.first] : p.second.first) << " ";
}
exit(0);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
int s1, s2, f;
cin >> s1 >> s2 >> f;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
adj[u].push_back({v, w});
}
for (int i = 0; i < k; i++) {
int u, v, l, r;
cin >> u >> v >> l >> r;
E.push_back({{u, v}, {l, r}});
sadj[u].push_back({v, {l, r}});
}
fill(d, d + maxn, inf);
fill(mark, mark + maxn, 0);
mul_dij(s1, s2, f, 'W');
fill(d, d + maxn, inf);
fill(mark, mark + maxn, 0);
mul_dij(s1, s2, f, 'D');
cout << "LOSE";
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int main(){
int d;
cin>>d;
cout<<d/30<<" "<<(d%30)*2<<endl;
return 0;
}
| 0 |
#include<iostream>
#include<string>
using namespace std;
int main(){
string bg[8]={"AAA","AA","A","B","C","D","E","NA"};
double m500[7]={35.5,37.5,40.0,43.0,50.0,55.0,70.0};
double m1000[7]={71.0,77.0,83.0,89.0,105.0,116.0,148.0};
double a,b;
while(cin >> a && cin >> b){
int ans=7;
for(int i=0;i<7;i++){
if(a < m500[i] && b < m1000[i]){
ans = i;
break;
}
}
cout << bg[ans] << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1E6 + 10;
int a[MAXN];
struct range {
int bg, ed, step;
range(int a, int b, int c) {
bg = a;
ed = b;
step = c;
}
int next() { bg += step; }
int end() { return bg > ed; }
int now() { return bg; }
};
int getAns(long long n, long long k) {
printf("%lld\n", (6 * n - 1) * k);
for (long long i = 1; i <= n; ++i) {
printf("%lld %lld %lld %lld\n", (6 * i - 5) * k, (6 * i - 4) * k,
(6 * i - 3) * k, (6 * i - 1) * k);
}
return 0;
}
int main() {
int n;
int k;
scanf("%d%d", &n, &k);
getAns(n, k);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int l[5];
int r[5];
int s[5];
int p[5];
int main() {
for (int i = 0; i < 4; i++) {
cin >> l[i] >> s[i] >> r[i] >> p[i];
}
for (int t = 0; t < 4; t++) {
if (p[t] == 1) {
if (l[(t + 1) % 4] == 1 || s[(t + 2) % 4] == 1 || r[(t + 3) % 4] == 1) {
cout << "YES" << endl;
return 0;
}
if (l[t] == 1 || s[t] == 1 || r[t] == 1) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int v, kd;
char s[20];
} a[100010];
int n, m;
bool cmp(Node x, Node y) {
if (x.kd == y.kd) {
return x.v > y.v;
}
return x.kd < y.kd;
}
int main() {
scanf("%d %d\n", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s %d %d", a[i].s, &a[i].kd, &a[i].v);
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++) {
if (a[i].kd != a[i - 1].kd) {
if (a[i + 1].v == a[i + 2].v && a[i + 1].kd == a[i + 2].kd) {
puts("?");
} else {
cout << a[i].s << " " << a[i + 1].s << endl;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
std::map<long long, long long> mp, love, mp1, fucklove;
std::vector<long long> v[1000001], v1[1000001];
void dfs(long long a, long long c) {
love[a] = c;
mp[a] = 1;
for (long long i = 0; i < v[a].size(); ++i) {
if (mp[v[a][i]] == 0) dfs(v[a][i], c);
}
}
void dfs1(long long a, long long c) {
fucklove[a] = c;
mp1[a] = 1;
for (long long i = 0; i < v1[a].size(); ++i) {
if (mp1[v1[a][i]] == 0) dfs1(v1[a][i], c);
}
}
int main() {
long long n, m1, m2, a, b;
cin >> n >> m1 >> m2;
for (long long i = 0; i < m1; ++i) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (long long i = 0; i < m2; ++i) {
cin >> a >> b;
v1[a].push_back(b);
v1[b].push_back(a);
}
long long c = 1, d = 1;
for (long long i = 1; i <= n; ++i) {
if (mp[i] == 0) dfs(i, c++);
}
for (long long i = 1; i <= n; ++i) {
if (mp1[i] == 0) dfs1(i, d++);
}
std::vector<pair<long long, long long>> ans;
c = 0;
d = 0;
map<long long, long long> map, map1;
for (long long i = 1; i <= n; ++i) {
for (long long j = i + 1; j <= n; ++j) {
if ((love[i] != love[j] && fucklove[i] != fucklove[j]) &&
((map[love[i]] + map[love[j]] == 0 &&
map1[fucklove[i]] + map1[fucklove[j]] == 0) ||
map[love[i]] != map[love[j]] &&
map1[fucklove[i]] != map1[fucklove[j]])) {
if (map[love[i]] + map[love[j]] == 0)
map[love[i]] = ++c, map[love[j]] = c;
else {
map[love[i]] = max(map[love[i]], map[love[j]]);
map[love[j]] = max(map[love[i]], map[love[j]]);
}
if (map1[fucklove[i]] + map1[fucklove[j]] == 0)
map1[fucklove[i]] = ++d, map1[fucklove[j]] = d;
else {
map1[fucklove[i]] = max(map1[fucklove[i]], map1[fucklove[j]]);
map1[fucklove[j]] = max(map1[fucklove[i]], map1[fucklove[j]]);
}
ans.push_back({i, j});
}
}
}
cout << ans.size() << endl;
for (long long i = 0; i < ans.size(); ++i)
cout << ans[i].first << " " << ans[i].second << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> pega[200005];
int peg[200005], id[200005], rev[200005];
int main() {
ios::sync_with_stdio(false);
int n, q, p;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> pega[i].first;
pega[i].second = i;
}
sort(pega + 1, pega + n + 1);
for (int i = 1; i <= n; i++) {
peg[i] = pega[i].first;
id[i] = pega[i].second;
rev[id[i]] = i;
}
for (int i = 0; i < q; i++) {
int remain;
cin >> p >> remain;
p = rev[p];
int lastleft = 0, lastright = 0, dir = 0;
int fail = 0;
while (true) {
if (dir == 0) {
int rightmost =
upper_bound(peg + p, peg + n + 1, peg[p] + remain) - peg;
rightmost--;
if (rightmost == p) {
if (fail) {
cout << id[p] << endl;
break;
} else {
fail = 1;
dir = 1;
continue;
}
}
remain -= peg[rightmost] - peg[p];
if (rightmost != lastright) {
lastleft = 0;
}
lastright = p = rightmost;
dir = 1;
} else {
int leftmost = lower_bound(peg + 1, peg + p, peg[p] - remain) - peg;
if (leftmost == p) {
if (fail) {
cout << id[p] << endl;
break;
} else {
fail = 1;
dir = 0;
continue;
}
}
if (lastright > 0 && leftmost == lastleft) {
remain %= (peg[lastright] - peg[lastleft]) * 2;
lastleft = lastright = 0;
} else {
remain -= peg[p] - peg[leftmost];
lastleft = p = leftmost;
dir = 0;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int position = n - a, tot_pos;
if (position - 1 <= b) {
position = n - a;
} else {
position = b + 1;
}
cout << position << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int d, n;
int a[N];
int ans = 0;
int cnt[N];
vector<int> g[N];
void dfs(int v, int id, int p = -1) {
cnt[v] = 1;
for (int j = 0; j < g[v].size(); ++j) {
int to = g[v][j];
if (a[to] > a[id] || to == p) continue;
if ((a[to] == a[id] && to > id) || (a[to] < a[id] && a[id] - a[to] <= d)) {
dfs(to, id, v);
cnt[v] = (cnt[v] * 1ll * (cnt[to] + 1)) % 1000000007;
}
}
}
int main() {
scanf("%d%d", &d, &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
memset(cnt, 0, sizeof cnt);
dfs(i, i);
ans = (ans + cnt[i]) % 1000000007;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, t = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * t;
}
const int N = 1e5 + 5;
int n, tot, rt;
int c[N][2], prt[N], sz[N];
long long Sum, Ans, a[N], s[N], d[N];
void Pushup(int x) {
sz[x] = sz[c[x][0]] + sz[c[x][1]] + 1;
s[x] = s[c[x][0]] + s[c[x][1]] + a[x];
}
void Init(int x, long long t) { a[x] += t, s[x] += t * sz[x], d[x] += t; }
void Pushdown(int x) {
if (!d[x]) return;
if (c[x][0]) Init(c[x][0], d[x]);
if (c[x][1]) Init(c[x][1], d[x]);
d[x] = 0;
}
void rot(int x, int &f) {
int y = prt[x], z = prt[y];
int l = c[y][0] != x, r = l ^ 1;
if (y == f)
f = x;
else
c[z][c[z][0] != y] = x;
prt[x] = z, prt[y] = x, prt[c[x][r]] = y;
c[y][l] = c[x][r], c[x][r] = y;
Pushup(y), Pushup(x);
}
void Splay(int x, int &f) {
while (x ^ f) {
int y = prt[x], z = prt[y];
if (y ^ f) Pushdown(z);
Pushdown(y), Pushdown(x);
if (y ^ f) {
if ((c[y][0] == x) ^ (c[z][0] == y))
rot(x, f);
else
rot(y, f);
}
rot(x, f);
}
}
int Find(int k) {
for (int x = rt; x;) {
Pushdown(x);
if (sz[c[x][0]] + 1 == k) return x;
if (k <= sz[c[x][0]])
x = c[x][0];
else
k -= sz[c[x][0]] + 1, x = c[x][1];
}
}
void Upd(int l, int r, long long v) {
if (l == 1) {
Init(rt, v);
return;
}
Splay(Find(l - 1), rt);
Init(c[rt][1], v), Pushup(rt);
}
int Node(long long v) {
int x = ++tot;
return sz[x] = 1, s[x] = a[x] = v, x;
}
void Ins(int k, long long v) {
if (!rt) {
rt = Node(v);
return;
}
for (int x = rt, y = x, tp = 0; x;) {
Pushdown(x), sz[x]++, s[x] += v;
tp = !(k <= sz[c[x][0]] + 1), y = x;
if (k <= sz[c[x][0]] + 1)
x = c[x][0];
else
k -= sz[c[x][0]] + 1, x = c[x][1];
if (!x) prt[c[y][tp] = Node(v)] = y, Splay(tot, rt);
}
}
void Trans(int i, int v) {
int res = i;
for (int x = rt, tp = 0; x;) {
Pushdown(x);
int j = tp + sz[c[x][0]] + 1;
if (1ll * j * v >= a[x])
res = j, x = c[x][0];
else
tp += sz[c[x][0]] + 1, x = c[x][1];
}
Ins(res, 1ll * v * res);
if (res ^ i) Upd(res + 1, i, v);
}
void Solve(int x) {
Pushdown(x);
if (c[x][0]) Solve(c[x][0]);
Sum += a[x], Ans = max(Ans, Sum);
if (c[x][1]) Solve(c[x][1]);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) Trans(i, read());
Solve(rt);
printf("%lld", Ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = (a), i##_end_ = (b); i < i##_end_; ++i)
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define mp make_pair
#define x first
#define y second
#define pb push_back
#define SZ(x) (int((x).size()))
#define ALL(x) (x).begin(), (x).end()
template<typename T> inline bool chkmin(T &a, const T &b) { return b < a ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
typedef long long LL;
const int oo = 0x3f3f3f3f;
const int Mod = 1e9 + 7;
const int inv2 = (Mod + 1) >> 1;
const int maxn = 110;
int n, K;
int dp[maxn + 5][maxn * maxn + 5];
int main()
{
#ifdef matthew99
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
scanf("%d%d", &n, &K);
dp[n][0] = 1;
for (int i = n; i >= 1; --i) REP(j, 0, n * n + 1) if (dp[i][j])
{
REP(k, 0, K + 1)
{
if (k > i) (dp[i - 1][j] += dp[i][j]) %= Mod;
else
{
(dp[i - 1][j + (k + j) / i] += dp[i][j]) %= Mod;
}
}
}
int ans = 1;
REP(i, 0, n) ans = (LL)ans * (K + 1) % Mod;
ans = (LL)ans * n % Mod * K % Mod * inv2 % Mod;
REP(i, 0, n * n + 1) (ans -= (LL)i * dp[0][i] % Mod) %= Mod;
(ans += Mod) %= Mod;
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int n, k, a, b;
vector<int> v;
int ret(int lt, int rt) {
int id2 = upper_bound(v.begin(), v.end(), rt) - v.begin();
int id1 = lower_bound(v.begin(), v.end(), lt) - v.begin();
return id2 - id1;
}
long long dfs(int lt, int rt) {
int nm = ret(lt, rt);
if (!nm) return a;
long long on = b * 1LL;
on *= nm;
on *= (rt - lt + 1);
if (lt == rt) return on;
int md = (lt + rt) / 2;
long long tw = dfs(lt, md) + dfs(md + 1, rt);
return min(on, tw);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> a >> b;
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
cout << dfs(1, 1 << n) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N;
int main() {
cin >> N;
if (N % 2 == 1) {
cout << (N - 1) / 2 << "\n";
return 0;
}
int msb = 30;
for (; msb >= 0; msb--)
if ((N & (1 << msb))) break;
cout << (N - (1 << msb)) / 2 << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200004;
int n, a[N], ans = 1;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int res = 1, i = 1;
while (i < n) {
if (a[i] * 2 >= a[i + 1])
res++;
else
res = 1;
ans = max(ans, res);
i++;
}
ans = max(ans, res);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 100007;
const int MAXL = 19;
const int MOD = 998244353;
const int RT = 3;
struct eT {
void setd(int _u, int _v, int _l) { u = _u, v = _v, last = _l; }
int u, v, last;
} edge[MAXN * 2];
int n, X;
int ke, la[MAXN];
int sz[MAXN], pre[MAXN], kp;
int wc[MAXN], lc[MAXN];
int tna[MAXN];
int dp[MAXN << 1], tmpa[MAXN << 1], tmpb[MAXN << 1], tmp_mul[MAXN];
int ca[MAXN << 2], cb[MAXN << 2], cans[MAXN << 2], rt[MAXN << 2],
irt[MAXL][MAXN << 2];
void init();
void input();
void work();
void mul(int a[], int n, int b[], int m, int ans[]);
void fft(int ar[], int tn);
int divi(int a[], int l, int r, int ta[], int tb[]);
int dfs1(int now, int fa);
void dfs2(int now);
void dfs(int now);
int add(int x, int y) {
x += y;
return (x < MOD) ? x : (x - MOD);
}
void addv(int &x, int y) {
x += y;
(x < MOD) ? x : (x -= MOD);
}
int sub(int x, int y) {
x -= y;
return (x >= 0) ? x : (x + MOD);
}
void subv(int &x, int y) {
x -= y;
(x >= 0) ? x : (x += MOD);
}
int qpow(int a, int b) {
long long base = a, ans = 1;
while (b) {
if (b & 1) (ans *= base) %= MOD;
(base *= base) %= MOD;
b >>= 1;
}
return static_cast<int>(ans);
}
int main() {
init();
input();
work();
}
void init() {
ios::sync_with_stdio(false);
for (int i = 0; i < MAXL; ++i) {
int tn = 1 << i;
int nrt = qpow(RT, (MOD - 1) / tn);
irt[i][0] = 1;
for (int j = 1; j < tn; ++j)
irt[i][j] = static_cast<long long>(irt[i][j - 1]) * nrt % MOD;
}
}
void input() {
long long tX;
scanf("%d%I64d", &n, &tX);
X = tX % MOD;
int u, v;
memset(la, -1, sizeof(la));
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
edge[ke].setd(u, v, la[u]);
la[u] = ke++;
edge[ke].setd(v, u, la[v]);
la[v] = ke++;
}
}
void work() {
dfs1(1, -1);
dfs2(1);
dp[0] = 1;
dfs(1);
int ans = 0, nC = 1;
for (int i = 1; i <= n; ++i) {
addv(ans, static_cast<long long>(nC) * dp[(pre[1] << 1) + i] % MOD);
nC = static_cast<long long>(nC) * (X + i) % MOD * qpow(i, MOD - 2) % MOD;
}
printf("%d\n", ans);
}
void mul(int a[], int n, int b[], int m, int ans[]) {
int nm = n + m, tn = 1, tb = 0;
while (tn <= nm) tn <<= 1, ++tb;
for (int i = 0; i <= n; ++i) ca[i] = a[i];
for (int i = n + 1; i < tn; ++i) ca[i] = 0;
for (int i = 0; i <= m; ++i) cb[i] = b[i];
for (int i = m + 1; i < tn; ++i) cb[i] = 0;
for (int i = 0; i < tn; ++i) rt[i] = irt[tb][i];
fft(ca, tn);
fft(cb, tn);
for (int i = 0; i < tn; ++i)
cans[i] = static_cast<long long>(ca[i]) * cb[i] % MOD;
reverse(rt + 1, rt + tn);
fft(cans, tn);
int rn = qpow(tn, MOD - 2);
for (int i = 0; i <= nm; ++i)
ans[i] = static_cast<long long>(cans[i]) * rn % MOD;
}
void fft(int ar[], int tn) {
for (int i = 0, j = 0; i < tn; ++i) {
if (i > j) swap(ar[i], ar[j]);
for (int bt = tn >> 1; bt && (!((j ^= bt) & bt)); bt >>= 1)
;
}
int m, x, y;
for (int i = 2; i <= tn; i <<= 1) {
m = i >> 1;
for (int j = 0; j < tn; j += i) {
for (int k = 0; k < m; ++k) {
x = ar[j + k],
y = static_cast<long long>(ar[j + k + m]) * rt[tn / i * k] % MOD;
ar[j + k] = add(x, y);
ar[j + k + m] = sub(x, y);
}
}
}
}
int divi(int a[], int l, int r, int ta[], int tb[]) {
if (l == r) {
ta[0] = tb[0] = 0;
for (int i = 1; i <= sz[a[l]] + 1; ++i) {
ta[i] = tb[i] = dp[(pre[a[l]] << 1) + i - 1];
}
return sz[a[l]] + 1;
}
int mid = (l + r) >> 1;
int sl = divi(a, l, mid, ta, tb);
int sr = divi(a, mid + 1, r, ta + sl + 1, tb + sl + 1);
mul(tb, sl, ta + sl + 1, sr, tmp_mul);
for (int i = 0; i <= sr; ++i) ta[sl + 1 + i] = 0;
for (int i = 0; i <= sl + sr; ++i) addv(ta[i], tmp_mul[i]);
mul(tb, sl, tb + sl + 1, sr, tb);
return sl + sr;
}
int dfs1(int now, int fa) {
sz[now] = 1;
int v, ch[2] = {0, 0}, kc = 0;
for (int i = la[now]; ~i; i = edge[i].last) {
if ((v = edge[i].v) ^ fa) {
ch[kc++] = v;
sz[now] += dfs1(v, now);
}
}
if (sz[ch[0]] < sz[ch[1]]) swap(ch[0], ch[1]);
wc[now] = ch[0], lc[now] = ch[1];
return sz[now];
}
void dfs2(int now) {
pre[now] = ++kp;
if (wc[now]) dfs2(wc[now]);
if (lc[now]) dfs2(lc[now]);
}
void dfs(int now) {
for (int t = now; t; t = wc[t])
if (lc[t]) dfs(lc[t]);
int kt = 0;
for (int t = now; t; t = wc[t]) tna[++kt] = lc[t];
divi(tna, 1, kt, tmpa, tmpb);
for (int i = 0; i <= sz[now]; ++i) dp[(pre[now] << 1) + i] = tmpa[i];
addv(dp[pre[now] << 1], 1);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
cin >> n;
int i = 2;
while (i <= n) {
if (n % i == 0) {
cout << i;
n = n / i;
}
i++;
}
if (n != 1) cout << n;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1e9;
struct edge {
int to, cost;
};
using edges = vector<edge>;
using graph = vector<edges>;
int main() {
int C, N, M, S, D;
while(cin >> C >> N >> M >> S >> D, N) {
S--; D--;
graph g(N);
for(int i=0; i<M; ++i) {
int a, b, f;
cin >> a >> b >> f;
a--; b--;
g[a].push_back((edge){b, f});
g[b].push_back((edge){a, f});
}
int res = INF;
using state = tuple<int, int, int>;
vector<vector<int>> d(N, vector<int>(C+1, INF));
d[S][C] = 0;
priority_queue<state, vector<state>, greater<state>> que;
que.push(make_tuple(0, S, C));
while(!que.empty()) {
int cur, v, c;
tie(cur, v, c) = que.top();
que.pop();
if(d[v][c] < cur) {
continue;
}
if(v == D) {
res = min(res, d[v][c]);
}
for(auto& e : g[v]) {
if(c > 0 && d[e.to][c-1] > d[v][c] + e.cost / 2) {
d[e.to][c-1] = d[v][c] + e.cost / 2;
que.push(make_tuple(d[e.to][c-1], e.to, c-1));
}
if(d[e.to][c] > d[v][c] + e.cost) {
d[e.to][c] = d[v][c] + e.cost;
que.push(make_tuple(d[e.to][c], e.to, c));
}
}
}
cout << res << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int tot, h[105];
int f[105][105][30];
struct node {
int to, nxt, v;
} e[5005];
void add_edge(int x, int y, int v) {
e[++tot].to = y;
e[tot].v = v;
e[tot].nxt = h[x];
h[x] = tot;
}
int dfs(int x, int y, int c) {
if (f[x][y][c] != 0) return f[x][y][c];
int ans = -1;
for (int i = h[x]; i; i = e[i].nxt) {
if (e[i].v >= c && dfs(y, e[i].to, e[i].v) == -1) {
ans = 1;
break;
}
}
f[x][y][c] = ans;
return ans;
}
int main() {
scanf("%d%d", &n, &m);
int u, v;
char s[5];
for (int i = 1; i <= m; i++) {
scanf("%d%d%s", &u, &v, &s);
add_edge(u, v, s[0] - 'a');
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (dfs(i, j, 0) == 1)
printf("A");
else
printf("B");
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, r, avg;
class woca {
public:
long long p;
long long b;
} F[100005];
bool CMP(woca A, woca B) {
if (A.b < B.b) return 1;
return 0;
}
long long tot = 0;
double temp = 0.0;
long long ANS = 0;
int main() {
int i;
scanf("%I64d%I64d%I64d", &n, &r, &avg);
for (i = 1; i <= n; i++) {
scanf("%I64d%I64d", &F[i].p, &F[i].b);
tot += F[i].p;
}
sort(F + 1, F + n + 1, CMP);
for (i = 1; i <= n; i++) {
if (tot / (n * 1.0) >= avg) break;
if (r - F[i].p > 0) {
if ((r - F[i].p + tot) / (n * 1.0) >= avg) {
ANS += (avg * n - tot) * F[i].b;
break;
} else {
ANS += (r - F[i].p) * F[i].b;
tot += (r - F[i].p);
}
}
}
printf("%I64d\n", ANS);
return 0;
}
| 3 |
// D - 3N Numbers
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rp(i,n) for(int i=0;i<(n);++i)
#define all(x) (x).begin(),(x).end()
int main(){
int N; cin>>N;
vector<ll> A(3*N);
rp(i, 3*N) cin>>A[i];
vector<ll> F(3*N);
F[0] = A[0];
priority_queue<int> fque;
fque.push(-A[0]);
for(int i=1; i<3*N; ++i){
fque.push(-A[i]);
ll minA = 0;
if(fque.size() > N){
minA = -fque.top();
fque.pop();
}
F[i] += F[i-1] + A[i] - minA;
}
reverse(all(A));
vector<ll> B(3*N);
B[0] = A[0];
priority_queue<int> bque;
bque.push(A[0]);
for(int i=1; i<3*N; ++i){
bque.push(A[i]);
ll minA = 0;
if(bque.size() > N){
minA = bque.top();
bque.pop();
}
B[i] += B[i-1] + A[i] - minA;
}
reverse(all(B));
ll maxfb = LLONG_MIN;
rp(i, N+1){
int f = N - 1 + i;
int b = f + 1;
maxfb = max(maxfb, F[f]-B[b]);
}
cout<< maxfb <<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300864;
struct sam {
sam *son[26], *pre;
int len;
long long cnt;
void init() {
memset(son, 0, sizeof(son));
pre = 0;
len = 0;
cnt = 0;
}
} que[maxn], *root, *tail, *b[maxn];
int tot;
void initt() {
tot = 0;
tail = root = &que[tot++];
root->init();
}
void add(int c, int len) {
sam *p = tail, *np = &que[tot++];
np->init();
np->len = len;
tail = np;
for (; p && p->son[c] == NULL; p = p->pre) p->son[c] = np;
if (p == NULL)
np->pre = root;
else {
sam *q = p->son[c];
if (p->len + 1 == q->len)
np->pre = q;
else {
sam *nq = &que[tot++];
*nq = *q;
nq->len = p->len + 1;
np->pre = q->pre = nq;
for (; p && p->son[c] == q; p = p->pre) p->son[c] = nq;
}
}
}
char str[maxn];
int cup[maxn];
int main() {
while (~scanf("%s", str)) {
initt();
for (int i = 0; str[i]; i++) add(str[i] - 'a', i + 1);
sam *p = root;
memset(cup, 0, sizeof(cup));
int m = strlen(str);
for (int i = 0; i < tot; i++) cup[que[i].len]++;
for (int i = 1; i <= m; i++) cup[i] += cup[i - 1];
for (int i = 0; i < tot; i++) b[--cup[que[i].len]] = &que[i];
for (int i = 0; str[i]; i++) {
int c = str[i] - 'a';
p = p->son[c];
p->cnt++;
}
for (int i = tot - 1; i > 0; i--) {
p = b[i];
p->pre->cnt += p->cnt;
}
long long ans = 0;
for (int i = tot - 1; i > 0; i--) {
p = b[i];
long long tmp = (((p->len - p->pre->len) * (p->cnt + 1) * p->cnt) / 2);
ans += tmp;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
int n;
int ta[N], tc[N], ret;
int a[N], b[N];
void update(int i, long long v) {
for (v -= ta[i], ta[i++] += v; i <= n;
tc[i - 1] += v, i += ((i) & ((i) ^ ((i)-1))))
;
}
int query(int i) {
for (ret = 0; i; ret += tc[i - 1], i ^= ((i) & ((i) ^ ((i)-1))))
;
return ret;
}
int main() {
int l = 0;
int r = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] >= i)
b[a[i] - i]++, l++;
else
r++;
}
for (int i = 0; i <= n; i++) update(i, b[i]);
long long now = 0;
long long ans1 = 0;
int ans2 = 0;
for (int i = 1; i <= n; i++) ans1 += abs(a[i] - i);
now = ans1;
for (int i = 1; i <= n - 1; i++) {
r += b[i - 1];
l -= b[i - 1];
int k = query(n) - query(i - 1) + i - 1;
now += r - l - 1 + 2 * a[n - i + 1] - n - 1;
r--;
l++;
b[i + a[n - i + 1] - 1]++;
update(i + a[n - i + 1] - 1, ta[i + a[n - i + 1] - 1] + 1);
if (now < ans1) {
ans1 = now;
ans2 = i;
}
}
cout << ans1 << " " << ans2;
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.