solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
int main() {
int test;
int k;
bool flag[10];
int in, ans = 0;
for (scanf("%d%d", &test, &k); test--;) {
memset(flag, 0, sizeof(flag));
for (scanf("%d", &in); in; in /= 10) {
flag[in % 10] = 1;
}
for (int i = 0; i <= k; i++)
if (flag[i] == false) goto fail;
ans++;
fail:;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
ll dp[3005][3005];
int main(int argc, char *argv[]) { ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
ll mod=998244353;
ll n,s;cin>>n>>s;
vector<ll> A(n);
for(ll i=0;i<n;i++)cin>>A[i];
dp[0][0]=1;
for(ll i=0;i<n;i++){
for(ll j=0;j<=s;j++){
ll a = A[i];
dp[i+1][j] += dp[i][j] * 2ll;
dp[i+1][j] %= mod;
if(j-a>=0){
dp[i+1][j] += dp[i][j-a];
dp[i+1][j] %= mod;
}
}
}
cout<<dp[n][s]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6;
long long a[maxn];
long long n, m;
int main(void) {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &m);
for (int j = 1; j <= m; ++j) scanf("%lld", &a[j]);
long long sum = 0, num = a[m];
for (int j = m; j >= 1; j--) {
num = min(num, a[j]);
if (a[j] > num) sum++;
}
printf("%lld\n", sum);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long x, y;
float f;
string k[] = {"white", "black"};
int main() {
cin >> x >> y;
f = sqrt(x * x + y * y);
if (f == (long long)f)
cout << k[1];
else
cout << k[(x * y) < 0 ? ((long long)f % 2) : !((long long)f % 2)];
fclose(stdin);
fclose(stdout);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
S += '0';
int ans = 0;
for (int i = 0; i + 1 < S.size(); i++) {
int n = S.at(i) - '0';
ans += min(n, 10 - n);
if (n >= 6 || n == 5 && S.at(i + 1) >= '5') S.at(i + 1)++;
}
ans += S.back() - '0';
cout << ans << "\n";
}
| 0 |
#include <stdio.h>
int main(void)
{
char x[2] = {'#', '.'};
int W, H, i, j, n;
while(1) {
scanf("%d %d",&H,&W);
if(H == 0 && W == 0)
break;
for(j = 0; H > j; j++){
i = j % 2;
for(n = 0; W > n; n++){
printf("%c", x[i % 2]);
i++;
}
printf("\n");
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long exp, long long m) {
long long ans = 1;
b %= m;
while (exp) {
if (exp & 1) ans = (ans * b) % m;
exp >>= 1;
b = (b * b) % m;
}
return ans;
}
int main() {
int i, n, t;
cin >> n >> t;
int ans = 0;
if (t >= 2 && t <= 9) {
for (i = 1; i <= n; i++) cout << t;
cout << endl;
return 0;
} else if (t == 10) {
if (n == 1) {
cout << "-1" << endl;
return 0;
} else
for (i = 1; i < n; i++) cout << "1";
cout << "0" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
int arr[n + 1][2];
for (int i = 1; i <= n; i++) {
cin >> arr[i][0] >> arr[i][1];
}
vector<int> sol;
sol.push_back(1);
while (sol.size() < n) {
int last = sol.size() - 1;
last = sol[last];
int a = arr[last][0];
int b = arr[last][1];
if (arr[a][0] == b || arr[a][1] == b) {
sol.push_back(a);
sol.push_back(b);
} else {
sol.push_back(b);
sol.push_back(a);
}
}
for (int i = 0; i < n; i++) {
cout << sol[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool vis[105][105];
int main() {
int n;
scanf("%d", &n);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
vis[1][x] = true;
}
for (int i = 2; i <= n; i++) {
int m;
scanf("%d", &m);
for (int j = 1; j <= m; j++) {
int x;
scanf("%d", &x);
if (vis[i - 1][x]) vis[i][x] = true;
}
}
for (int i = 1; i <= 100; i++)
if (vis[n][i]) printf("%d ", i);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
int h, w;
int buf[2000][2000];
int core[2000][2000];
int sum[2000][2000];
struct uf {
int par[4000000];
void init() { memset(par, -1, sizeof(par)); }
int root(int a) {
if (par[a] == -1) return a;
return par[a] = root(par[a]);
}
void unite(int a, int b) {
a = root(a);
b = root(b);
if (a == b) return;
par[a] = b;
}
};
uf u, uc;
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int id[4000005];
int main() {
cin >> h >> w;
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
scanf("%d", &buf[i + 5][j + 5]);
}
h += 10;
w += 10;
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
sum[i + 1][j + 1] = sum[i][j + 1] + sum[i + 1][j] - sum[i][j] + buf[i][j];
}
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j)
if (buf[i][j]) {
int tot = sum[i + 3][j + 3] - sum[i + 3][j - 3] - sum[i - 3][j + 3] +
sum[i - 3][j - 3];
core[i][j] = (tot == 36);
}
u.init();
uc.init();
vector<int> res;
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j)
if (buf[i][j]) {
for (int d = 0; d < 4; ++d) {
int px = j + dx[d], py = i + dy[d];
if (px < 0 || py < 0 || px >= w || py >= h) continue;
if (buf[py][px]) u.unite(i * w + j, py * w + px);
}
}
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j)
if (core[i][j] & 1) {
int sz = 7;
for (int dx = -sz; dx < sz; ++dx)
for (int dy = -sz; dy < sz; ++dy) {
if (i + dy < h && i + dy >= 0 && j + dx >= 0 && j + dx <= w)
core[i + dy][j + dx] |= 2;
}
}
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j)
if (!core[i][j] && buf[i][j]) {
for (int d = 0; d < 4; ++d) {
int px = j + dx[d], py = i + dy[d];
if (px < 0 || py < 0 || px >= w || py >= h) continue;
if (!core[py][px] && buf[py][px]) uc.unite(i * w + j, py * w + px);
}
}
int cnt = 0;
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j)
if (buf[i][j] && u.root(i * w + j) == i * w + j) {
id[i * w + j] = cnt++;
}
res.resize(cnt);
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j)
if (!core[i][j] && buf[i][j] && uc.root(i * w + j) == i * w + j) {
int belong = id[u.root(i * w + j)];
res[belong]++;
}
sort((res).begin(), (res).end());
printf("%d\n", res.size());
for (int i = 0; i < res.size(); ++i) printf("%d\n", res[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
struct dat {
int i, j, x;
};
int n, a[N];
vector<dat> ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) cin >> a[i], sum += a[i];
if (sum % n != 0)
cout << -1 << '\n';
else {
ans.clear();
for (int i = 2; i <= n; i++) {
if (a[i] % i == 0)
ans.push_back((dat){i, 1, a[i] / i});
else {
ans.push_back((dat){1, i, i - a[i] % i});
ans.push_back((dat){i, 1, a[i] / i + 1});
}
}
for (int i = 2; i <= n; i++) ans.push_back((dat){1, i, sum / n});
cout << int(ans.size()) << '\n';
for (auto t : ans) cout << t.i << ' ' << t.j << ' ' << t.x << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char StrA[200100];
char StrB[200100];
long long CountP[26][200100];
long long CountE[26][200100];
int main() {
int N;
scanf("%d", &N);
scanf("%s", &StrA[1]);
scanf("%s", &StrB[1]);
for (int i = 1; i <= N; i++) {
int A = StrA[i] - 'A';
CountP[A][i] = i;
}
for (int i = N; i >= 1; i--) {
int A = StrA[i] - 'A';
CountE[A][i] = N + 1 - i;
}
for (int i = 1; i <= N; i++)
for (int j = 0; j < 26; j++) CountP[j][i] += CountP[j][i - 1];
for (int i = N - 1; i >= 1; i--)
for (int j = 0; j < 26; j++) CountE[j][i] += CountE[j][i + 1];
double Sum = 0;
for (int i = 1; i <= N; i++) {
int A = StrB[i] - 'A';
Sum += CountP[A][i] * (N + 1 - i);
Sum += CountE[A][i + 1] * i;
}
double Ans = Sum;
double Temp = N;
Ans = Ans / (Temp * (Temp + 1) * (2 * Temp + 1) / 6);
printf("%.9f\n", Ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b >> c;
cout << ((a[a.size()-1]==b[0] && b[b.size()-1]==c[0])?"YES":"NO") << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string n[102];
string s[102];
int same[102], la[102], lb[102];
bool flag[102];
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
cin >> n[i];
}
for (int i = 1; i <= t; i++) {
cin >> s[i];
}
sort(n + 1, n + t + 1);
sort(s + 1, s + t + 1);
for (int i = 1; i <= t; i++) {
la[n[i][0]]++;
lb[s[i][0]]++;
}
for (int i = 1; i <= t; i++) {
int tmp;
for (int j = 1; j <= t; j++) {
if (flag[j] == 0 && (la[s[j][0]] < lb[s[j][0]] || n[i][0] == s[j][0]) &&
(lb[n[i][0]] < la[n[i][0]] || s[j][0] >= n[i][0])) {
tmp = j;
break;
}
}
same[i] = tmp;
flag[tmp] = 1;
lb[s[tmp][0]]--;
la[n[i][0]]--;
}
for (int i = 1; i <= t; i++) {
cout << n[i] << " " << s[same[i]];
if (i != t) cout << ", ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200;
const int MAX_N2 = MAX_N * 2;
const int MAX_M = 200;
int ds[MAX_N];
int fns[MAX_M], fds[MAX_M][MAX_N];
set<int> rset;
pair<int, int> cps[MAX_N2];
int main() {
int n, m;
scanf("%d%d", &n, &m);
memset(ds, -1, sizeof(ds));
for (int i = 0; i < m; i++) {
scanf("%d", fns + i);
for (int j = 0; j < fns[i]; j++) {
scanf("%d", &fds[i][j]);
fds[i][j]--;
ds[fds[i][j]] = (i << 8) | j;
}
}
for (int i = 0; i < n; i++)
if (ds[i] < 0) rset.insert(i);
int k = 0;
for (int i = 0, d = 0; i < n; i++) {
int &fn = fns[i];
for (int j = 0; j < fn; j++, d++) {
int fd = fds[i][j];
if (fd != d) {
if (ds[d] >= 0) {
int di = (ds[d] >> 8), dj = (ds[d] & 0xff);
int r = *(rset.begin());
rset.erase(r);
fds[di][dj] = r;
ds[r] = ds[d];
ds[d] = -1;
rset.insert(d);
cps[k++] = pair<int, int>(d, r);
}
rset.erase(d);
fds[i][j] = d;
ds[d] = ds[fd];
ds[fd] = -1;
rset.insert(fd);
cps[k++] = pair<int, int>(fd, d);
}
}
}
printf("%d\n", k);
for (int i = 0; i < k; i++)
printf("%d %d\n", cps[i].first + 1, cps[i].second + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int i, i0, n, m, c, q, pre[100005];
map<int, vector<int>> mp[100005];
set<int> dic[100005];
int fin(int x) { return (pre[x] == x) ? x : pre[x] = fin(pre[x]); }
void uni(int x, int y) {
if (fin(x) != fin(y)) {
if (dic[fin(x)].size() > dic[fin(y)].size())
for (auto i : dic[fin(y)]) dic[fin(x)].insert(i), pre[fin(y)] = fin(x);
else
for (auto i : dic[fin(x)]) dic[fin(y)].insert(i), pre[fin(x)] = fin(y);
}
}
int main() {
scanf("%d %d %d %d", &n, &m, &c, &q);
for (i = 1; i <= n; i++) pre[i] = i;
while (m--) {
int x, y, col;
scanf("%d %d %d", &x, &y, &col);
dic[fin(x)].insert(y), dic[fin(y)].insert(x);
mp[x][col].push_back(y), uni(y, mp[x][col][0]);
mp[y][col].push_back(x), uni(x, mp[y][col][0]);
}
while (q--) {
char op;
scanf(" %c", &op);
if (op == '?') {
int x, y;
scanf("%d %d", &x, &y);
if (fin(x) == fin(y) || dic[fin(x)].count(y))
printf("Yes\n");
else
printf("No\n");
} else {
int x, y, col;
scanf("%d %d %d", &x, &y, &col);
dic[fin(x)].insert(y), dic[fin(y)].insert(x);
mp[x][col].push_back(y), uni(y, mp[x][col][0]);
mp[y][col].push_back(x), uni(x, mp[y][col][0]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &tx) {
long long 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();
}
tx = x * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
using namespace std;
int n;
int main() {
read(n);
writeln(((n + 1)) / 2 - 1);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool del(int a[10], int n) {
for (int i = 1; i < 10; i++) {
if (0 < a[i] && i % 3 == n) {
a[i]--;
return true;
}
}
return false;
}
bool del(int a[10], int n, int times) {
for (int i = 0; i < (times); i++) {
if (!del(a, n)) return false;
}
return true;
}
int main() {
int a[10] = {0};
int n;
int t, sum = 0;
bool f;
cin >> n;
for (int i = 0; i < (n); i++) {
cin >> t;
a[t]++;
sum += t;
}
if (a[0] == 0) {
cout << "-1" << endl;
return 0;
}
f = false;
if (sum % 3 == 0)
f = true;
else if (sum % 3 == 1) {
if (del(a, 1, 1) || del(a, 2, 2)) f = true;
} else {
if (del(a, 2, 1) || del(a, 1, 2)) f = true;
}
sum = 0;
for (int i = 0; i < (10); i++) sum += a[i] * i;
if (sum == 0) a[0] = 1;
if (f) {
for (int i = 9; i >= 0; i--)
for (int j = 0; j < (a[i]); j++) cout << i;
} else
cout << "-1";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 20;
struct state {
int num4, num7;
int linc, ldec;
state operator+(const state &s) const {
state ret;
ret.num4 = num4 + s.num4;
ret.num7 = num7 + s.num7;
ret.linc = max(num4 + s.linc, linc + s.num7);
ret.ldec = max(num7 + s.ldec, ldec + s.num4);
return ret;
}
};
void rev(state &s) {
swap(s.num4, s.num7);
swap(s.linc, s.ldec);
}
int N, M;
char str[MAXN], qtype[10];
state seg[2 * MAXN];
bool lazy[2 * MAXN];
void combine(int cur) { seg[cur] = seg[2 * cur] + seg[2 * cur + 1]; }
void down(int cur) {
if (lazy[cur]) {
lazy[2 * cur] ^= true;
rev(seg[2 * cur]);
lazy[2 * cur + 1] ^= true;
rev(seg[2 * cur + 1]);
lazy[cur] = false;
}
}
void update(int left, int right, int cur = 1, int l = 0, int r = MAXN) {
if (left <= l && r <= right) {
lazy[cur] ^= true;
rev(seg[cur]);
return;
} else if (r <= left || right <= l)
return;
down(cur);
int mid = (l + r) / 2;
update(left, right, 2 * cur, l, mid);
update(left, right, 2 * cur + 1, mid, r);
combine(cur);
}
int main() {
if (fopen("codeforces145E.in", "r")) freopen("codeforces145E.in", "r", stdin);
scanf("%d %d", &N, &M);
scanf("%s", str);
for (int i = 0; i < N; i++) {
state &ref = seg[i + MAXN];
ref.linc = ref.ldec = 1;
((str[i] == '4') ? ref.num4 : ref.num7) = 1;
}
for (int i = MAXN - 1; i; i--) combine(i);
while (M--) {
scanf("%s", qtype);
if (qtype[0] == 'c') {
printf("%d\n", seg[1].linc);
continue;
}
int l, r;
scanf("%d %d", &l, &r);
l--;
update(l, r);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[15], b[15];
int main() {
for (int i = 0; i < 14; i++) scanf("%d", a + i);
long long ans = 0;
for (int i = 0; i < 14; i++) {
for (int j = 0; j < 14; j++) b[j] = a[j];
int x = b[i];
long long w = 0;
b[i] = 0;
for (int j = 0; j < 14; j++) {
if (i != j)
b[j] += ceil(((x - (j + 14 - i) % 14) + 1) / 14.0);
else
b[j] = x / 14;
if (b[j] % 2 == 0) w += b[j];
}
ans = max(ans, w);
}
printf("%lld", ans);
return 0;
}
| 2 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<set>
#include<map>
#include<unordered_map>
#include<queue>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<cassert>
#include<random>
#include<time.h>
#include<functional>
using namespace std;
using ll=long long;
using ld=long double;
using P=pair<ll,ll>;
#define MOD 1000000007LL
#define INF 1000000000LL
#define EPS 1e-10
#define FOR(i,n,m) for(ll i=n;i<(ll)m;i++)
#define REP(i,n) FOR(i,0,n)
#define DUMP(a) REP(d,a.size()){cout<<a[d];if(d!=a.size()-1)cout<<" ";else cout<<endl;}
#define ALL(v) v.begin(),v.end()
#define UNIQUE(v) sort(ALL(v));v.erase(unique(ALL(v)),v.end());
#define pb push_back
/* --------------------------------------- */
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
ll q;
cin >> q;
vector<ll> a(q);
REP(i, q) cin >> a[i];
REP(i, q) a[i]--;
vector<ll> cnt(m, 0);
map<ll, ll> dict;
vector<ll> idx(m, -1);
ll ite = 0;
for(ll i = q - 1; i >= 0; i--) {
if(dict.count(a[i])) {
ll pos = dict[a[i]];
if(cnt[pos] == n) continue;
if(pos != 0 && cnt[pos - 1] <= cnt[pos]) continue;
cnt[pos]++;
} else {
dict[a[i]] = ite;
idx[ite] = a[i];
cnt[ite]++;
ite++;
}
}
vector<ll> not_comp;
REP(i, m) if(!dict.count(i) || cnt[dict[i]] != n) not_comp.pb(i);
sort(ALL(not_comp));
ll tmp = 0;
REP(i, m) {
if(cnt[i] == 0 || cnt[i] == n) continue;
if(idx[i] != not_comp[tmp]) {
cout << "No" << endl;
return 0;
}
tmp++;
}
cout << "Yes" << endl;
return 0;
}
/* --------------------------------------- */
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin >> a >> b >> c;
cout << a+b+c-max(a,max(b,c));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int N, K;
cin >> N >> K;
long long ans = 0, prev = 0;
for (int i = 1; i <= N; i++) {
int x;
cin >> x;
ans += (prev + K - 1) / K;
prev = max(0LL, x - (K - prev % K) % K);
}
ans += (prev + K - 1) / K;
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, a, b;
cin >> n >> a >> b;
long long arr[n + 5];
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
x = (x * a) % b;
if (a % b)
arr[i] = x / (a % b);
else
arr[i] = 0;
}
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
}
| 2 |
#include<iostream>
#include<algorithm>
#include<set>
#include<vector>
#include<cstdio>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define inf (1<<29)
using namespace std;
enum FACE { TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT };
template <class T>
class dice {
public:
dice() {
id[TOP] = 0; id[FRONT] = 1; id[LEFT] = 2;
id[RIGHT] = 3; id[BACK] = 4; id[BOTTOM] = 5;
}
T& operator[] (FACE f) { return var[id[f]]; }
const T& operator[] (FACE f) const { return var[id[f]]; }
bool operator==(const dice<T>& b) const {
const dice<T> &a = *this;
return a[TOP] == b[TOP] && a[BOTTOM] == b[BOTTOM] &&
a[FRONT] == b[FRONT] && a[BACK] == b[BACK] &&
a[LEFT] == b[LEFT] && a[RIGHT] == b[RIGHT];
}
void roll_x() { roll(TOP, BACK, BOTTOM, FRONT); }
void roll_y() { roll(TOP, LEFT, BOTTOM, RIGHT); }
void roll_z() { roll(FRONT, RIGHT, BACK, LEFT); }
vector<dice> all_rolls() {
vector<dice> ret;
for (int k = 0; k < 6; (k&1?roll_y():roll_x()),++k)
for (int i = 0; i < 4; roll_z(), ++i)
ret.push_back(*this);
return ret;
}
bool equivalent_to(const dice& di) {
for (int k = 0; k < 6; (k&1?roll_y():roll_x()),++k)
for (int i = 0; i < 4; roll_z(), ++i)
if (*this == di) return true;
return false;
}
private:
void roll(FACE a, FACE b, FACE c, FACE d) {
T tmp = id[a];
id[a] = id[b]; id[b] = id[c];
id[c] = id[d]; id[d] = tmp;
}
T var[6];
int id[6];
};
FACE face[] = {TOP,FRONT,RIGHT,LEFT,BACK,BOTTOM};
class UnionFind
{
public:
int par[40];
void init(int n){ rep(i,n)par[i] = i; }
int find(int x)
{
if(x == par[x])return x;
return par[x] = find(par[x]);
}
void unit(int x,int y)
{
x = find(x), y = find(y);
if(x != y)par[x] = y;
find(x),find(y);
}
};
int main()
{
int n;
while(cin >> n,n)
{
dice<char> dices[n];
string fc;
rep(i,n)rep(j,6)
{
cin >> fc;
dices[i][face[j]] = fc[0];
}
UnionFind uf;
uf.init(n);
rep(i,n)REP(j,i+1,n)
if(dices[i].equivalent_to(dices[j]))uf.unit(i,j);
set<int> ans;
rep(i,n)ans.insert(uf.find(i));
cout << n - ans.size() << endl;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=55;
int n,a[N],b[N],m=0;bool v[N][N],f[N][N];
ll bin[N],ans=0;
inline bool check(int x){
for(int i=0;i<=m;i++)for(int j=0;j<=m;j++)f[i][j]=v[i][j];
for(int i=0;i<=m;i++)
for(int j=1;j<=x;j++)f[i][i%j]=1;
for(int k=0;k<=m;k++)
for(int i=0;i<=m;i++)
for(int j=0;j<=m;j++)f[i][j]|=f[i][k]&f[k][j];
for(int i=0;i<=n;i++)if(!f[a[i]][b[i]])return true;
return false;
}
int main(){
scanf("%d",&n);
bin[0]=1;
for(int i=1;i<=50;i++)bin[i]=bin[i-1]<<1;
for(int i=1;i<=n;i++)scanf("%d",&a[i]),m=max(m,a[i]);
for(int i=1;i<=n;i++)scanf("%d",&b[i]);
for(int i=0;i<=m;i++)v[i][i]=1;
for(int i=m;i>=1;i--)
if(check(i-1)){
for(int j=0;j<=m;j++)v[j][j%i]=1;
ans+=bin[i];
}
for(int k=0;k<=m;k++)
for(int i=0;i<=m;i++)
for(int j=0;j<=m;j++)v[i][j]|=v[i][k]&v[k][j];
for(int i=1;i<=n;i++)
if(!v[a[i]][b[i]])puts("-1"),exit(0);
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200000;
int n, k, now;
string a[N], s, ans;
vector<string> l, b;
int main() {
cin >> n >> k;
for (int i = 0; i < 26; i++) {
string h = "";
h += ('A' + i);
l.push_back(h);
}
for (int i = 0; i < 26; i++) {
string h = "A";
h += ('a' + i);
l.push_back(h);
}
for (int i = 0; i < k - 1; i++) {
b.push_back(l[now]);
now++;
}
for (int i = k; i <= n; i++) {
string h;
cin >> h;
if (h == "NO") {
b.push_back(b[i - k]);
} else {
b.push_back(l[now]);
now++;
}
}
for (int i = 0; i < b.size(); i++) cout << b[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
struct sss {
int x, c;
} s[MAXN];
bool comp(const sss &a, const sss &b) { return a.x < b.x; }
int MIN[MAXN << 3];
void PushUPmin(int rt) { MIN[rt] = min(MIN[rt << 1], MIN[rt << 1 | 1]); }
void buildmin(int l, int r, int rt) {
if (l == r) {
MIN[rt] = s[l].c;
return;
}
int m = (l + r) >> 1;
buildmin(l, m, rt << 1);
buildmin(m + 1, r, rt << 1 | 1);
PushUPmin(rt);
}
int querymin(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return MIN[rt];
}
int m = (l + r) >> 1;
int ret = 999999999;
if (L <= m) ret = min(ret, querymin(L, R, l, m, rt << 1));
if (R > m) ret = min(ret, querymin(L, R, m + 1, r, rt << 1 | 1));
return ret;
}
int main() {
ios::sync_with_stdio(false);
;
int m, n, i, j, k, d;
scanf("%d%d%d", &d, &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &s[i].x, &s[i].c);
}
s[0].x = 0, s[0].c = 0;
m++;
s[m].x = d, s[m].c = 0;
sort(s, s + m, comp);
for (i = 1; i <= m; i++) {
if (s[i].x - s[i - 1].x > n) {
cout << -1 << endl;
return 0;
}
}
long long ans = 0;
int re = n;
buildmin(1, m, 1);
for (i = 1; i <= m; i++) {
re -= (s[i].x - s[i - 1].x);
int l = 1, r = m - i, t = 50, next = m;
while (t--) {
int mid = (l + r) >> 1;
if (querymin(i + 1, i + mid, 1, m, 1) <= s[i].c)
r = mid, next = min(next, i + mid);
else
l = mid;
}
int fill = min(n, (s[next].x - s[i].x));
if (fill < re)
continue;
else {
ans += (long long)(fill - re) * (long long)s[i].c;
re = fill;
}
}
cout << ans << endl;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int>pint;
typedef vector<int>vint;
typedef vector<pint>vpint;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
template<class T,class U>void chmin(T &t,U f){if(t>f)t=f;}
template<class T,class U>void chmax(T &t,U f){if(t<f)t=f;}
const int INF=1001001001001001001ll;
const int SIZE=100000;
int N,M,C;
vpint G[SIZE];
int dist[SIZE];
int sum;
bool used[SIZE];
signed main(){
scanf("%lld%lld%lld",&N,&M,&C);
rep(i,M){
int a,b,c;
scanf("%lld%lld%lld",&a,&b,&c);
a--;b--;
G[a].pb(pint(b,c));
G[b].pb(pint(a,c));
sum+=c;
}
priority_queue<pint,vpint,greater<pint> >que;que.push(pint(0,0));
fill_n(dist,N,INF);dist[0]=0;
while(que.size()){
int v=que.top().se,c=que.top().fi;que.pop();
if(dist[v]<c)continue;
rep(i,G[v].size()){
pint &e=G[v][i];
if(dist[e.fi]<=c+e.se)continue;
dist[e.fi]=c+e.se;
que.push(pint(dist[e.fi],e.fi));
}
}
vpint vec;
rep(i,N)vec.pb(pint(dist[i],i));
int ans=sum;
sort(all(vec));
rep(i,N){
int v=vec[i].se,c=vec[i].fi;
rep(j,G[v].size()){
pint &e=G[v][j];
if(used[e.fi]){
sum-=e.se;
}
}
used[v]=true;
chmin(ans,c*C+sum);
}
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, S, ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int s;
cin >> s;
S += s;
}
for (int i = 1; i <= 5; i++)
if ((S + i) % (n + 1) != 1) ans++;
cout << ans << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int x,y,z;
int main()
{
scanf("%d%d%d",&x,&y,&z);
printf("%d",(x-z)/(y+z));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[80005];
int cnt[80005];
unsigned long long ret;
int n;
void dfs(int v, int u) {
cnt[v] = 1;
unsigned long long val = 1ull * n * (n - 1) / 2ull;
for (int i = 0; i < edge[v].size(); i++) {
int to = edge[v][i];
if (to == u) continue;
dfs(to, v);
val -= 1ull * cnt[to] * (cnt[to] - 1) / 2ull;
cnt[v] += cnt[to];
}
val -= 1ull * (n - cnt[v]) * (n - cnt[v] - 1) / 2ull;
ret -= (val * val -
(1ull * (n - cnt[v]) * cnt[v]) * (1ull * (n - cnt[v]) * cnt[v]));
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
ret = 1ull * n * (n - 1) / 2ull;
ret *= ret;
dfs(rand() % n + 1, -1);
cout << ret << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1010;
int n, res, x_1, x_2, y_1, y_2, check[maxN][maxN];
struct ioi {
int x, y;
};
ioi q[maxN * 10];
int main() {
scanf("%d%d%d%d%d", &n, &x_1, &y_1, &x_2, &y_2);
int l = 1, r = 1;
q[1].x = x_1;
q[1].y = y_1;
check[x_1][y_1] = 1;
while (l <= r) {
ioi u = q[l++];
if ((u.x == x_2) && (u.y == y_2)) {
res = check[x_2][y_2];
break;
}
if ((u.y == 0) || (u.y == n)) {
ioi v = u;
--v.x;
if ((v.x >= 0) && (check[v.x][v.y] == 0))
check[v.x][v.y] = check[u.x][u.y] + 1, q[++r] = v;
v.x += 2;
if ((v.x <= n) && (check[v.x][v.y] == 0))
check[v.x][v.y] = check[u.x][u.y] + 1, q[++r] = v;
}
if ((u.x == 0) || (u.x == n)) {
ioi v = u;
--v.y;
if ((v.y >= 0) && (check[v.x][v.y] == 0))
check[v.x][v.y] = check[u.x][u.y] + 1, q[++r] = v;
v.y += 2;
if ((v.y <= n) && (check[v.x][v.y] == 0))
check[v.x][v.y] = check[u.x][u.y] + 1, q[++r] = v;
}
}
printf("%d", res - 1);
fclose(stdin);
fclose(stdout);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int input;
for (int y = 0; y < 5; y++) {
for (int x = 0; x < 5; x++) {
cin >> input;
if (input == 1) {
cout << abs(2 - x) + abs(2 - y);
break;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 400005;
const int max_m = 25;
struct edge {
int to, next, cost;
} es[2 * max_n];
int cnt = 0;
int head[max_n];
void add(int u, int v) {
es[cnt].to = v;
es[cnt].next = head[u];
es[cnt].cost = 1;
head[u] = cnt++;
}
int depth[max_n << 1];
int first[max_n << 1];
int dir[max_n << 1];
int que[max_n << 1];
int dp[max_n][20];
bool vis[max_n];
int tot = 0;
void dfs(int u, int dep) {
vis[u] = true;
que[++tot] = u;
first[u] = tot;
depth[tot] = dep;
for (int k = head[u]; k != -1; k = es[k].next) {
int v = es[k].to, cost = es[k].cost;
if (!vis[v]) {
dir[v] = dir[u] + cost;
dfs(v, dep + 1);
que[++tot] = u;
depth[tot] = dep;
}
}
}
void ST(int n) {
for (int i = 1; i <= n; i++) dp[i][0] = i;
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
int a = dp[i][j - 1], b = dp[i + (1 << (j - 1))][j - 1];
dp[i][j] = depth[a] < depth[b] ? a : b;
}
}
}
int RMQ(int l, int r) {
int k = 0;
while ((1 << (k + 1)) <= r - l + 1) k++;
int a = dp[l][k], b = dp[r - (1 << k) + 1][k];
return depth[a] < depth[b] ? a : b;
}
int LCA(int u, int v) {
int x = first[u], y = first[v];
if (x > y) swap(x, y);
int res = RMQ(x, y);
return que[res];
}
int x[max_n];
int main() {
int p, q;
int n;
for (int i = 0; i < max_n; i++) {
head[i] = -1;
vis[i] = false;
}
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d", x + i);
add(i, x[i]);
add(x[i], i);
}
dfs(1, 1);
ST(2 * n - 1);
int da = 1, db = 1;
int d = 0;
for (int i = 2; i <= n; i++) {
int lca1 = LCA(i, da);
int tmp1 = dir[i] + dir[da] - 2 * dir[lca1];
int lca2 = LCA(i, db);
int tmp2 = dir[i] + dir[db] - 2 * dir[lca2];
if (tmp1 < tmp2) {
if (tmp2 > d) {
da = i;
d = tmp2;
}
} else {
if (tmp1 > d) {
db = i;
d = tmp1;
}
}
printf("%d ", d);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a;
scanf("%d", &a);
if (a % 2 == 0) {
printf("0");
} else {
printf("1");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
clock_t T;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
;
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
v[i] &= 1;
}
stack<int> st;
for (int i = 0; i < n; i++) {
if (!st.empty() && v[i] == st.top())
st.pop();
else
st.push(v[i]);
}
cout << ((int)st.size() <= 1 ? "YES" : "NO");
}
| 4 |
#include<iostream>
using namespace std;
int main(){
int n,ans=0;
cin>>n;
for(int i=1;i<=n;i+=2){
int count=0;
for(int j=1;j<=n;j+=2){
if(i%j==0)count++;
}
if(count==8)ans++;
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1001;
const int maxl = 100;
int n, mo, mod;
int yu[10][maxn];
int dp[maxn][maxl][2];
void f(int& a, int x) { a = (a + x) % mod; }
int main() {
scanf("%d%d%d", &n, &mo, &mod);
if (n == 1) {
printf("%d\n", 9 / mo % mod);
return 0;
}
for (int i = 0; i <= 9; i++) {
yu[i][1] = i;
for (int j = 2; j < maxn; j++) yu[i][j] = yu[i][j - 1] * 10 % mo;
}
dp[1][0][0] = 1;
for (int i = 1; i <= 9; i++) dp[1][i % mo][(i % mo) ? 0 : 1]++;
for (int i = 1; i < n; i++) {
for (int j = 0; j < mo; j++) {
for (int k = (i == n - 1 ? 1 : 0); k < 10; k++) {
int tm = (j + yu[k][i + 1]) % mo;
if (tm == 0 && (j || k))
f(dp[i + 1][0][1], dp[i][j][0]);
else
f(dp[i + 1][tm][0], dp[i][j][0]);
f(dp[i + 1][tm][1], dp[i][j][1]);
}
}
}
int r = 0;
for (int i = 0; i < mo; i++) f(r, dp[n][i][1]);
printf("%d\n", r);
}
| 4 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int n,a[1010][1010],h[1000100],dist[1000100];
vector<int>to[1000100];
int encode(int i, int j){
if(i>j)swap(i,j);
return i*n+j;
}
int main(){
cin>>n;
rep(i,n)rep(j,n-1){
cin>>a[i][j];
a[i][j]--;
}
rep(i,n)rep(j,n-2){
int v=encode(i,a[i][j]);
int u=encode(i,a[i][j+1]);
to[v].push_back(u);
h[u]++;
}
stack<int>st;
rep(i,n*n)if(h[i]==0)st.push(i),dist[i]=1;
while(st.size()){
int v=st.top(); st.pop();
for(int u:to[v]){
h[u]--;
if(h[u]==0)st.push(u);
dist[u]=max(dist[u],dist[v]+1);
}
}
int mx=0,in=0;
rep(i,n*n)mx=max(mx,dist[i]);
rep(i,n*n)in=max(in,h[i]);
if(in!=0)cout<<-1<<endl;
else cout<<mx<<endl;
}
| 0 |
#include <bits/stdc++.h>
int n;
int arr[100050][3];
long long N[100050];
int b_s(long long t) {
int ans;
int st = 0, en = n - 1, mi;
while (st <= en) {
mi = (st + en) / 2;
if (t <= N[mi]) {
ans = mi;
en = mi - 1;
} else {
st = mi + 1;
}
}
return ans;
}
int main() {
int m;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &arr[i][0], &arr[i][1]);
if (arr[i][0] == 1) {
if (i == 0)
N[i] = 1;
else
N[i] = N[i - 1] + 1;
} else {
scanf("%d", &arr[i][2]);
N[i] = N[i - 1] + arr[i][1] * arr[i][2];
}
}
scanf("%d ", &m);
for (int i = 0; i < m; i++) {
long long wts;
scanf("%I64d", &wts);
while (true) {
int where = b_s(wts);
if (arr[where][0] == 1) {
printf("%d ", arr[where][1]);
break;
} else
wts = (wts - N[where - 1] - 1) % arr[where][1] + 1;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool valid(vector<double> &v, double &r) {
int low = upper_bound(v.begin(), v.end(), *v.begin() + 2 * r) - v.begin(),
high =
lower_bound(v.begin(), v.end(), *(--v.end()) - 2 * r) - v.begin() - 1;
if (low >= high) {
return true;
} else {
return v[low] + 2 * r >= v[high];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
double x;
set<double> s;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x;
s.insert(x);
}
vector<double> v(s.begin(), s.end());
cout << fixed << setprecision(6);
if (v.size() <= 3) {
cout << 0 << endl;
for (int i = 0; i < 3; ++i) {
cout << v[i % v.size()] << ' ';
}
} else {
double l = 0, r = (*(--v.end()) - *v.begin()) / 3, m;
int tr = 1e5;
while (r - l > 1e-8 && --tr) {
m = l + (r - l) / 2;
if (valid(v, m)) {
r = m;
} else {
l = m;
}
}
int low = upper_bound(v.begin(), v.end(), *v.begin() + 2 * r) - v.begin(),
high = lower_bound(v.begin(), v.end(), *(--v.end()) - 2 * r) -
v.begin() - 1;
cout << m << endl;
cout << *v.begin() + m << ' ' << v[low] + (v[high] - v[low]) / 2 << ' '
<< *(--v.end()) - m;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, b;
long long x, nw = 1, old;
long long dp[2][(1 << 20)], res = -1;
vector<pair<pair<long long, long long>, pair<long long, long long> > > v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> b;
v.resize(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first.second >> v[i].first.first >> v[i].second.first;
v[i].second.second = 0;
for (int j = 0; j < v[i].second.first; j++)
cin >> x, v[i].second.second += 1LL * (1 << (x - 1));
}
sort(v.begin(), v.end());
memset(dp, -1, sizeof(dp));
dp[old][0] = dp[nw][0] = 0;
for (int j = 1; j <= n; j++) {
for (int i = 1; i < (1 << m); i++) {
dp[nw][i] = dp[old][i];
long long ol = dp[old][i & (~v[j - 1].second.second)];
if (ol != -1) {
if (dp[nw][i] == -1)
dp[nw][i] = ol + v[j - 1].first.second;
else
dp[nw][i] = min(dp[nw][i], ol + v[j - 1].first.second);
}
}
if (dp[nw][(1 << m) - 1] != -1) {
if (res == -1)
res = dp[nw][(1 << m) - 1] + v[j - 1].first.first * b;
else
res = min(res, dp[nw][(1 << m) - 1] + v[j - 1].first.first * b);
}
nw = 1 - nw;
old = 1 - old;
}
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int nmax = 2e5;
set<long long> s;
void build() {
s.insert(1);
vector<long long> pot2, pot3;
long long a = 1;
for (int i = 0; i < 30; ++i) {
a *= 2LL;
pot2.push_back(a);
s.insert(a);
}
a = 1;
for (int i = 0; i < 19; ++i) {
a *= 3LL;
pot3.push_back(a);
s.insert(a);
}
for (int i = 0; i < 30; ++i)
for (int j = 0; j < 19; ++j) s.insert(pot2[i] * pot3[j]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
build();
long long l, r;
cin >> l >> r;
auto i = s.lower_bound(l);
auto j = s.upper_bound(r);
int ans = distance(i, j);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
constexpr int kBase = 26;
constexpr int kMod1 = 1285649;
constexpr int kMod2 = 666013;
int compute_hash(const string &s, const int mod) {
int hash = 0;
for (const char c : s) {
hash = (hash * kBase + (c - 'a')) % mod;
}
return hash;
}
long long compute_hash_code(const int x, const int y) {
return 1LL * x * kMod1 + y;
}
unordered_map<long long, bool> memo;
bool equiv(const string &a, const string &b) {
if (a.size() % 2 == 1) {
return a.compare(b) == 0;
}
const string merged = a + b;
int hash_1 = compute_hash(merged, kMod1);
int hash_2 = compute_hash(merged, kMod2);
auto hash_code = compute_hash_code(hash_1, hash_2);
auto find_it = memo.find(hash_code);
if (find_it != memo.end()) {
return find_it->second;
}
string a1 = a.substr(0, a.size() / 2);
string a2 = a.substr(a.size() / 2, a.size() / 2);
string b1 = b.substr(0, b.size() / 2);
string b2 = b.substr(b.size() / 2, b.size() / 2);
bool result =
(equiv(a1, b1) && equiv(a2, b2)) || (equiv(a1, b2) && equiv(a2, b1));
memo[hash_code] = result;
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string a, b;
cin >> a >> b;
if (equiv(a, b)) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string x, res;
string dp[2610][2610];
int n;
string rec(int l, int r) {
string &res = dp[l][r];
if (res == "") {
if (l == r)
res = x[l];
else if (l > r)
res = "";
else {
if (x[l] == x[r])
res = x[l] + rec(l + 1, r - 1) + x[r];
else {
res = rec(l + 1, r);
if (rec(l, r - 1).size() > res.size()) res = rec(l, r - 1);
if (rec(l + 1, r - 1).size() > res.size()) res = rec(l + 1, r - 1);
}
}
}
return res;
}
int main() {
cin >> x;
n = x.size();
if (n > 2600) {
vector<pair<int, int> > l(26);
for (int i = 0; i < 26; ++i) l[i].second = i;
for (int i = 0; i < n; ++i) l[x[i] - 'a'].first++;
sort(l.begin(), l.end());
char ch = 'a' + l[25].second;
for (int i = 0; i < 100; ++i) res += ch;
} else {
res = rec(0, n - 1);
if (res.size() > 100) {
string res1;
int w = res.size() / 2, g = 0;
if (res.size() % 2) g = 1;
for (int i = 0; i < 50; ++i) {
res1 += res[w + i + g];
res1 = res[w - i - 1] + res1;
}
res = res1;
}
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, q;
cin >> n >> q;
vector<stack<int>> s(1100);
for(int i=0; i<q; i++){
int a, t;
cin >> a >> t;
if(a == 0){
int x;
cin >> x;
s[t].push(x);
}else{
if(a == 1){
if(!(s[t].empty())){
cout << s[t].top() << endl;
}
}else{
if(!(s[t].empty())){
s[t].pop();
}
}
}
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
while(1){
int H,W;
cin >> H >> W;
if(H==0){
if(W==0) break;
}
for(int i=0;i<H;i++){
for(int j=0;j<W;j++) cout << '#';
cout << endl;;
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class vertex {
public:
int i, d, j;
vector<vertex *> stargate;
vector<int> dis_stargate;
vector<int> t;
};
vertex planet[100010];
int i, j, k, m, n, a, b, c, N;
vertex *q[100010];
int main() {
cin >> n >> m;
N = n;
for (i = 0; i < n; i++) {
planet[i].i = i;
planet[i].d = 2000000010;
planet[i].j = i;
}
planet[0].d = 0;
for (i = 0; i < m; i++) {
cin >> a >> b >> c;
a--, b--;
planet[a].stargate.push_back(planet + b);
planet[a].dis_stargate.push_back(c);
planet[b].stargate.push_back(planet + a);
planet[b].dis_stargate.push_back(c);
}
for (i = 0; i < n; i++) {
cin >> k;
for (j = 0; j < k; j++) {
cin >> a;
planet[i].t.push_back(a);
}
}
for (i = 0; i < n; i++) q[i] = planet + i;
while (n) {
vertex *v = q[0];
if (v->j == N - 1) {
break;
}
n--;
q[0] = q[n];
q[0]->i = 0;
i = 0;
while (2 * i + 1 < n) {
j = i;
if (q[2 * i + 1]->d < q[j]->d) j = 2 * i + 1;
if (2 * i + 2 < n && q[2 * i + 2]->d < q[j]->d) j = 2 * i + 2;
if (j != i) {
vertex *u = q[i];
q[i] = q[j];
q[j] = u;
q[i]->i = i;
q[j]->i = j;
i = j;
} else
break;
}
int d = v->d;
if (v->t.size()) {
vector<int>::iterator low = lower_bound(v->t.begin(), v->t.end(), d);
if (*low == d) {
low++;
d++;
while (low != v->t.end() && *low - *(low - 1) == 1) {
low++;
d++;
}
}
}
for (i = 0; i < (int)v->stargate.size(); i++) {
vertex *u = v->stargate[i];
int c = v->dis_stargate[i];
if (d + c < u->d) {
u->d = d + c;
j = u->i;
while ((j - 1) / 2 >= 0) {
k = (j - 1) / 2;
if (q[k]->d > q[j]->d) {
vertex *u = q[k];
q[k] = q[j];
q[j] = u;
q[k]->i = k;
q[j]->i = j;
j = k;
} else
break;
}
}
}
}
if (planet[N - 1].d < 2000000010)
cout << planet[N - 1].d;
else
cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
int n, a[N];
bool vis[N];
double p[N][N], f[N], g[N], pr[N];
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
n = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) p[i][j] = read() * 1.0 / 100;
for (int i = 1; i <= n; i++) pr[i] = f[i] = 1.0;
vis[n] = 1;
a[1] = n;
for (int i = 2; i <= n; i++) {
double mi = 1e18;
for (int j = 1; j <= n; j++) {
if (vis[j]) continue;
f[j] += g[a[i - 1]] * p[j][a[i - 1]] * pr[j];
pr[j] *= 1.0 - p[j][a[i - 1]];
if ((g[j] = f[j] / (1.0 - pr[j])) < mi) mi = g[j], a[i] = j;
}
vis[a[i]] = 1;
}
printf("%0.10lf", g[1]);
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main() {
string S;
cin >>S;
int N;
N=S.size();
char s=S[0];
int c=0;
char cc='0';
for(int i=0;i<S.size();i++){
if(S[i]==cc)c++;
if (cc=='0')cc='1';
else cc='0';
}
if (c*2>N)c=N-c;
cout<<c;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, cnt[10];
char s[N];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = (1), iE = (n); i <= iE; i++) {
if (s[i] == '1')
;
else if (s[i] == '2')
cnt[2]++;
else if (s[i] == '3')
cnt[3]++;
else if (s[i] == '4')
cnt[2] += 2, cnt[3]++;
else if (s[i] == '5')
cnt[5]++;
else if (s[i] == '6')
cnt[5]++, cnt[3]++;
else if (s[i] == '7')
cnt[7]++;
else if (s[i] == '8')
cnt[2] += 3, cnt[7]++;
else if (s[i] == '9')
cnt[7]++, cnt[2]++, cnt[3] += 2;
}
for (int i = (9), iE = (1); i >= iE; i--)
for (int j = (1), jE = (cnt[i]); j <= jE; j++) printf("%d", i);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
char s[N];
char mp[N];
int up[N], down[N], leftt[N], rightt[N];
int u[N], d[N], l[N], r[N];
int sum;
int tot;
int n, m, nm;
void bfs(int t) {
while (1) {
sum++;
int x = t;
int tmp = x % m;
if (tmp == 0) tmp = m;
int liml = x - tmp + 1, limr = liml + m - 1;
if (mp[t] == 'L') {
x = leftt[x];
if (x == 0) break;
} else if (mp[t] == 'R') {
x = rightt[x];
if (x == 0) break;
} else if (mp[t] == 'U') {
x = up[x];
if (x == 0) break;
} else if (mp[t] == 'D') {
x = down[x];
if (x == 0) break;
}
if (leftt[t] != 0) rightt[leftt[t]] = rightt[t];
if (rightt[t] != 0) leftt[rightt[t]] = leftt[t];
if (up[t] != 0) down[up[t]] = down[t];
if (down[t] != 0) up[down[t]] = up[t];
t = x;
}
}
void finds(int x) {
int tmp = x % m;
if (tmp == 0) tmp = m;
int liml = x - tmp + 1, limr = liml + m - 1;
int t = x - m;
while (t > 0 && mp[t] == '.') t -= m;
if (t <= 0) t = 0;
up[x] = t;
t = x + m;
while (t <= nm && mp[t] == '.') t += m;
if (t > nm) t = 0;
down[x] = t;
t = x - 1;
while (t >= liml && mp[t] == '.') t--;
if (t < liml) t = 0;
leftt[x] = t;
t = x + 1;
while (t <= limr && mp[t] == '.') t++;
if (t > limr) t = 0;
rightt[x] = t;
u[x] = up[x];
d[x] = down[x];
l[x] = leftt[x];
r[x] = rightt[x];
}
void clean() {
for (int i = 1; i <= nm; i++)
leftt[i] = l[i], rightt[i] = r[i], up[i] = u[i], down[i] = d[i];
}
int main() {
scanf("%d%d", &n, &m);
nm = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) mp[++nm] = s[j];
}
for (int i = 1; i <= nm; i++) finds(i);
int ans = 0, t = 0;
for (int i = 1; i <= nm; i++)
if (mp[i] != '.') {
sum = 0;
clean();
bfs(i);
if (sum > ans) {
ans = sum;
t = 1;
} else if (sum == ans)
t++;
}
printf("%d %d\n", ans, t);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[2][8] = {{2, 10, 3, 9, 4, 8, 6, 12}, {6, 2, 10, 3, 9, 4, 8, 12}};
int main() {
int n; cin >> n;
if (n == 3) {
cout << "2 5 63"; return 0;
}
for (int i = 0; i < n; i++) {
cout << a[n & 1][i & 7] << " ";
a[n & 1][i & 7] += 12;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int MODP(long long x) {
int r = x % 1000000007;
if (r < 0) r += 1000000007;
return r;
}
class AbstractGF2MatrixRecorder {
public:
virtual void record(int r1, int r2) {}
virtual void recordSwap(int r1, int r2) {}
};
class GF2MatrixRecorder : public AbstractGF2MatrixRecorder {
vector<pair<int, int>> op;
public:
void record(int r1, int r2) { op.emplace_back(r1, r2); }
void recordSwap(int r1, int r2) {
if (r1 == r2) return;
op.emplace_back(r1, r2);
op.emplace_back(r2, r1);
op.emplace_back(r1, r2);
}
const vector<pair<int, int>> &getOperations() { return op; }
};
template <int NCOL>
class GF2Matrix {
vector<bitset<NCOL>> row;
int nRow;
vector<int> order;
vector<size_t> length;
bool isLock;
int rank;
bool gaussianEliminationCalled;
vector<int> first1;
AbstractGF2MatrixRecorder noRecorder;
AbstractGF2MatrixRecorder &recorder;
public:
GF2Matrix(int nRow) : recorder(noRecorder) { init(nRow); }
GF2Matrix(int nRow, AbstractGF2MatrixRecorder &recorder)
: recorder(recorder) {
init(nRow);
}
int numRow() const { return nRow; }
int numCol() const { return NCOL; }
void init(int nRow) {
this->nRow = nRow;
row.resize(nRow);
order.resize(nRow);
for (auto r = 0; r < nRow; ++r) {
order[r] = r;
}
length.resize(nRow);
isLock = false;
gaussianEliminationCalled = false;
}
void setRow(int r, const bitset<NCOL> &rV) { row[r] = rV; }
void lock() {
isLock = true;
for (auto r = 0; r < nRow; ++r) {
for (auto c = NCOL - 1; c >= 0; --c) {
if (row[r].test(c)) {
length[r] = c;
break;
}
}
}
}
void gaussianElimination() {
assert(isLock);
first1.resize(nRow);
rank = 0;
for (int c = NCOL - 1, r = 0; c >= 0; c--) {
int i = r;
while (i < nRow && !getRow(i).test(c)) {
++i;
}
if (i >= nRow) {
continue;
}
first1[r] = c;
swap(order[r], order[i]);
recorder.recordSwap(r, i);
for (auto j = 0; j < nRow; ++j) {
if (j != r && getRow(j).test(c)) {
recorder.record(j, r);
row[order[j]] ^= getRow(r);
}
}
r++;
rank++;
}
gaussianEliminationCalled = true;
}
int getFirst1(int row) const {
assert(gaussianEliminationCalled);
assert(row < rank);
return first1[row];
}
void transform(const GF2Matrix<NCOL> &t) {
assert(t.isGaussianEliminationCalled());
for (auto r = 0; r < rank; ++r) {
int c = getFirst1(r);
for (auto r2 = 0; r2 < rank; ++r2) {
if (getRow(r2).test(c) != t.getRow(r2).test(c)) {
row[order[r2]] ^= getRow(r);
recorder.record(r2, r);
}
}
}
}
bool isGaussianEliminationCalled() const { return gaussianEliminationCalled; }
int getRank() const {
assert(gaussianEliminationCalled);
return rank;
}
inline const bitset<NCOL> &getRow(int r) const { return row[order[r]]; }
bool operator==(const GF2Matrix<NCOL> &y) const {
if (y.numRow() != numRow()) return false;
for (auto r = 0; r < nRow; ++r) {
if (getRow(r) != y.getRow(r)) return false;
}
return true;
}
friend std::ostream &operator<<(std::ostream &stream,
const GF2Matrix<NCOL> &matrix) {
stream << "[matrix: row = " << matrix.nRow << ", col = " << NCOL << endl;
for (auto r = 0; r < matrix.nRow; ++r) {
for (auto c = NCOL - 1; c >= 0; --c) {
stream << matrix.getRow(r).test(c) << " ";
}
stream << endl;
}
stream << "]" << endl;
return stream;
}
};
void testGen() {
freopen("biginput1.txt", "w", stdout);
fclose(stdout);
}
void output(const GF2Matrix<32> &a) {
ostringstream ss;
for (auto r = 0; r < a.numRow(); ++r) {
ss << a.getRow(r).to_ullong() << " ";
}
if (1 <= 0) cout << "[LOG " << 0 << "] " << ss.str() << endl;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> initial;
GF2MatrixRecorder recordA, recordT;
GF2Matrix<32> a(n, recordA);
for (auto r = 0; r < n; ++r) {
int x;
cin >> x;
initial.push_back(x);
a.setRow(r, x);
}
a.lock();
a.gaussianElimination();
vector<int> target;
for (auto repeat_var = 0; repeat_var < n; ++repeat_var) {
int x;
cin >> x;
target.push_back(x);
}
GF2Matrix<32> b(2 * n);
for (auto r = 0; r < n; ++r) {
b.setRow(r, a.getRow(r));
}
int r = n;
for (int x : target) {
b.setRow(r, x);
r++;
}
b.lock();
b.gaussianElimination();
if (b.getRank() != a.getRank()) {
cout << -1 << endl;
} else {
GF2Matrix<32> t(n, recordT);
for (auto r = 0; r < n; ++r) {
t.setRow(r, target[r]);
}
t.lock();
t.gaussianElimination();
a.transform(t);
vector<pair<int, int>> ret;
for (auto p : recordA.getOperations()) {
ret.push_back(p);
}
for (auto it = recordT.getOperations().rbegin();
it != recordT.getOperations().rend(); ++it) {
ret.push_back(*it);
}
cout << ret.size() << endl;
for (auto p : ret) {
cout << p.first + 1 << " " << p.second + 1 << " " << endl;
initial[p.first] ^= initial[p.second];
}
for (auto i = 0; i < n; ++i) {
if (1 <= 0) cout << "[LOG " << 0 << "] " << initial[i] << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const double pi = 3.141592653589793238462643383279;
using namespace std;
//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef pair<int, PII> TIII;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
//container util
//------------------------------------------
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SQ(a) ((a)*(a))
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
//repetition
//------------------------------------------
#define FOR(i,s,n) for(int i=s;i<(int)n;++i)
#define REP(i,n) FOR(i,0,n)
#define MOD 1000000007
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
//ここから編集
template<typename T>
struct LazySegmentTree{
const int INF = numeric_limits<int>::max();
int n0;
vector<T> node, lazy;
LazySegmentTree(vector<T> &v){
int n = v.size();
n0 = 1;
while(n0 < n) n0 <<= 1;
node.resize(2*n0-1);
lazy.assign(2*n0-1, INF);
for(int i=0; i<n; i++) node[i+n0-1] = v[i];
for(int i=n0-2; i>=0; i--) node[i] = node[i*2+1] + node[i*2+2];
}
void eval(int k, int p){
if(lazy[k] == INF) return;
if(k < n0-1){
lazy[k*2+1] = lazy[k];
lazy[k*2+2] = lazy[k];
}
node[k] = lazy[k] * p;
lazy[k] = INF;
}
void update(int a, int b, T x, int k, ll l, ll r){
eval(k, r-l);
if(a <= l && r <= b){
lazy[k] = x;
eval(k, r-l);
}else if(a < r && l < b) {
update(a, b, x, k*2+1, l, (l+r)/2);
update(a, b, x, k*2+2, (l+r)/2, r);
node[k] = node[k*2+1] + node[k*2+2];
}
}
void update(int l, int r, T x) { update(l, r, x, 0, 0, n0); }
T query(int a, int b, int k, ll l, ll r){
eval(k, r-l);
if(r <= a || b <= l) return 0;
else if(a <= l && r <= b){
return node[k];
}else{
T vl = query(a, b, k*2+1, l, (l+r)/2);
T vr = query(a, b, k*2+2, (l+r)/2, r);
return vl+vr;
}
}
T query(int l, int r) { return query(l, r, 0, 0, n0); }
inline T operator[](int a) { return query(a, a + 1); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(5);
int N, Q; cin >> N >> Q;
vector<ll> a(N, 0);
LazySegmentTree<ll> seg(a);
REP(i,Q){
int q; cin >> q;
if(q == 0){
int s, t, x;
cin >> s >> t >> x;
seg.update(s, t+1, x);
}else{
int s, t; cin >> s >> t;
cout << seg.query(s, t+1) << endl;
}
// for(int j=0; j<N; j++){
// cout << seg[j] << " ";
// }
// cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t, fa[500005], top, q[500005 << 2], d[500005], a[500005];
struct Edge {
int x, y, l, r;
} G[500005];
inline int get(int x) {
while (fa[x] != x) x = fa[x];
return x;
}
inline int dis(int x) {
int ret = 0;
while (fa[x] != x) ret ^= a[x], x = fa[x];
return ret;
}
inline void link(int x, int y, int v) {
if (d[x] > d[y]) swap(x, y);
if (d[x] == d[y]) d[y]++, q[++top] = y;
fa[x] = y;
a[x] = v;
q[++top] = x;
}
inline void erase(int x) {
for (; top > x; top--)
if (q[top < 0])
d[-q[top]]--;
else
fa[q[top]] = q[top], a[q[top]] = 0;
}
void solve(int l, int r, int k) {
int mid = (l + r) >> 1, now = top;
for (int i = 1; i <= k; i++)
if (G[i].l <= l && r <= G[i].r) {
int u = get(G[i].x), v = get(G[i].y);
if (u != v)
link(u, v, dis(G[i].x) == dis(G[i].y));
else if (dis(G[i].x) == dis(G[i].y)) {
for (int i = l; i <= r; i++) puts("NO");
erase(now);
return;
}
swap(G[k--], G[i--]);
}
if (l == r)
puts("YES");
else {
int i, j;
for (i = 1, j = 0; i <= k; i++)
if (G[i].l <= mid) swap(G[i], G[++j]);
solve(l, mid, j);
for (i = 1, j = 0; i <= k; i++)
if (G[i].r > mid) swap(G[i], G[++j]);
solve(mid + 1, r, j);
}
erase(now);
}
map<int, int> mp[500005];
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
int main() {
n = read();
t = read();
for (int i = 1; i <= t; i++) {
int x = read(), y = read();
if (x > y) swap(x, y);
if (mp[x][y])
G[mp[x][y]].r = i - 1, mp[x][y] = 0;
else {
mp[x][y] = ++m;
G[m].x = x;
G[m].y = y;
G[m].l = i - 1;
G[m].r = t;
}
}
for (int i = 1; i <= m; i++) ++G[i].l;
for (int i = 1; i <= n; i++) fa[i] = i, d[i] = 1;
solve(1, t, m);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000005;
const long long INFLL = 1000000000000000005ll;
const long long MOD = 1000000007;
const int RIGHT = 262144;
const int SIZE = 525000;
struct Node {
double left, right, total, sum;
Node(double p1 = 0, double p2 = 0, double p3 = 0, double p4 = 0)
: left(p1), right(p2), total(p3), sum(p4){};
};
Node merge(Node n1, Node n2) {
double l = max(n1.left, n1.sum + n2.left);
double r = max(n2.right, n2.sum + n1.right);
double s = n1.sum + n2.sum;
double t = max(max(n1.total, n2.total), n1.right + n2.left);
return {l, r, t, s};
}
double C, P[150005], X[150005];
int N, M;
Node Tree[SIZE];
Node query(int l, int r, int n, int a, int b) {
if (a >= l && b <= r) return Tree[n];
int mid = (a + b) / 2;
if (r <= mid)
return query(l, r, 2 * n, a, mid);
else if (l > mid)
return query(l, r, 2 * n + 1, mid + 1, b);
else
return merge(query(l, r, 2 * n, a, mid),
query(l, r, 2 * n + 1, mid + 1, b));
}
void update(int x, double v, int n, int a, int b) {
if (a > x || b < x) return;
if (a == b) {
Tree[n] = {v, v, v, v};
return;
}
int mid = (a + b) / 2;
update(x, v, 2 * n, a, mid);
update(x, v, 2 * n + 1, mid + 1, b);
Tree[n] = merge(Tree[2 * n], Tree[2 * n + 1]);
}
int main() {
cin >> N >> M >> C;
for (long long i = (1); i <= (N); i++) cin >> X[i];
for (long long i = (1); i <= (N - 1); i++) cin >> P[i];
for (long long i = (1); i <= (N - 1); i++)
update(i, (X[i + 1] - X[i]) / 2 - P[i] / 100.0 * C, 1, 1, RIGHT);
double ans = 0;
for (long long i = (1); i <= (M); i++) {
int a, b;
cin >> a >> b;
ans += max(query(a, b - 1, 1, 1, RIGHT).total, 0.0);
}
cout << fixed << setprecision(15) << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
//const int MOD=1e9+7;
//const int MOD=998244353;
const int INF=1e9;
const long long LINF=1e18;
#define int long long
//template
template <typename T>
void fin(T a){
cout<<a<<endl;
exit(0);
}
int pw(int n,int k,int MOD){
int res=1;
while(k){
if(k&1)res*=n;res%=MOD;
n*=n;n%=MOD;
k>>=1;
}
return res;
}
//main
signed main(){
int N,M;cin>>N>>M;
typedef pair<int,int> P;
std::vector<P> e[N];
while(M--){
int a,b,x;cin>>a>>b>>x;a--;b--;
e[a].push_back(P(b,x));
e[b].push_back(P(a,-x));
}
int mod[5]={1000000007,998244353,1000000009,1000000033,2147483647};
for(int i=0;i<5;i++){
int MOD=mod[i];
std::vector<int> d(N,-1);
for(int i=0;i<N;i++){
if(~d[i])continue;
d[i]=1;
queue<int> que;
que.push(i);
while(que.size()){
int p=que.front();que.pop();
for(auto q:e[p]){
int v=q.first,x=q.second;
if(x<0)x=pw(-x,MOD-2,MOD);
if(~d[v]){if(d[v]!=(d[p]*x)%MOD)fin("No");}
else{
d[v]=d[p]*x%MOD;
que.push(v);
}
}
}
}
}
fin("Yes");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
int solve() {
int m, n;
cin >> m;
cin >> n;
int oops[m][n + 1];
memset(oops, 0, sizeof(oops));
for (int i = (0); i < (m); ++i) {
int y;
cin >> y;
for (int j = (0); j < (y); ++j) {
int x;
cin >> x;
oops[i][x]++;
}
}
for (int i = (0); i < (m); ++i) {
for (int j = (i + 1); j < (m); ++j) {
bool chk = false;
for (int k = (1); k < (n + 1); ++k) {
if (oops[i][k] > 0 and oops[j][k] > 0) {
chk = true;
break;
}
}
if (chk == false) return cout << "impossible\n", 0;
}
}
cout << "possible\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, w, x = -1, y, tot;
long long ans = (long long)1e18;
map<pair<int, int>, int> A, B;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
pair<int, int> caln_A(int x) {
int k = x, rev = 0;
while (x > 0) {
rev = rev * 10 + x % 10;
x /= 10;
}
int d = gcd(k, rev);
k /= d;
rev /= d;
return make_pair(k, rev);
}
pair<int, int> caln_B(int x) {
pair<int, int> now = caln_A(x);
swap(now.first, now.second);
return now;
}
int main() {
int j = 0;
tot = 0;
scanf("%d%d%d", &n, &m, &w);
for (int i = 1; i <= n; i++) A[caln_A(i)]++;
for (int i = n; i >= 1; i--) {
while (tot < w && j < m) {
j++;
pair<int, int> now = caln_B(j);
B[now]++;
tot += A[now];
}
if (tot < w) continue;
if ((long long)i * j <= ans) ans = (long long)i * j, x = i, y = j;
pair<int, int> now = caln_A(i);
tot -= B[now];
A[now]--;
}
if (x == -1)
printf("-1\n");
else
printf("%d %d\n", x, y);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0, head[20000 + 5];
int dfn[20000 + 5], low[20000 + 5], timestamp = 0;
struct edge {
int end, next;
} e[200000 + 5];
struct node {
int u, v;
} ee[200000 + 5];
int belong[20000 + 5], sum, siz[20000 + 5];
int f[20000 + 5], len[2][20000 + 5];
bool vis[100000 + 5];
void add_edge(int u, int v) {
e[++cnt].end = v;
e[cnt].next = head[u];
head[u] = cnt;
}
bool cmp(node A, node B) { return A.u < B.u || (A.u == B.u && A.v < B.v); }
void dfs(int u, int from) {
low[u] = dfn[u] = ++timestamp;
vis[u] = true;
for (int i = head[u]; i != 0; i = e[i].next) {
int v = e[i].end;
if ((from ^ 1) == i) continue;
if (dfn[v] == 0) {
dfs(v, i);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
vis[u] = false;
}
void dfs1(int u, int num) {
belong[u] = num;
sum++;
for (int i = head[u]; i; i = e[i].next) {
if (vis[i]) continue;
int v = e[i].end;
if (belong[v]) continue;
dfs1(v, num);
}
}
void dfs2(int u, int fa) {
vis[u] = true;
f[u] = len[1][u];
int maxn1 = 0, maxn2 = 0;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].end;
if (v == fa) continue;
dfs2(v, u);
if (siz[v] == 1) continue;
if ((len[1][v] + 1) - f[v] > maxn1)
maxn2 = maxn1, maxn1 = (len[1][v] + 1) - f[v];
else if ((len[1][v] + 1) - f[v] > maxn2)
maxn2 = (len[1][v] + 1) - f[v];
}
sum = min(sum, f[u] - maxn1 - maxn2 + len[0][u]);
f[u] -= maxn1;
}
void dfs3(int u, int fa) {
siz[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].end;
if (v == fa) continue;
dfs3(v, u);
siz[u] += siz[v];
if (siz[v] != 1) len[1][u] += len[1][v] + 1;
}
}
void dfs4(int u, int fa) {
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].end;
if (v == fa) continue;
if (fa != 0) len[0][v] = (len[0][u] + 1);
if (fa == 0 && siz[v] + 1 != siz[u]) len[0][v] = 1;
len[0][v] += len[1][u];
if (siz[v] != 1) len[0][v] -= len[1][v] + 1;
dfs4(v, u);
}
}
int main() {
int i, j, A, B, tot = 0;
long long ans = 0;
scanf("%d%d", &n, &m);
cnt = 1;
for (i = 1; i <= m; i++) {
scanf("%d%d", &A, &B);
add_edge(A, B);
add_edge(B, A);
}
memset(dfn, 0, sizeof(dfn));
for (i = 1; i <= n; i++)
if (!dfn[i]) dfs(i, 0);
memset(vis, false, sizeof(vis));
for (i = 1; i <= n; i++)
for (j = head[i]; j; j = e[j].next)
if (dfn[i] < low[e[j].end] || dfn[e[j].end] < low[i]) vis[j] = true;
cnt = 0;
for (i = 1; i <= n; i++)
if (!belong[i]) {
cnt++;
sum = 0;
dfs1(i, cnt);
ans += sum - 1;
}
for (i = 1; i <= n; i++)
for (j = head[i]; j; j = e[j].next)
if (belong[i] != belong[e[j].end]) {
ee[++tot].u = belong[i];
ee[tot].v = belong[e[j].end];
if (ee[tot].u > ee[tot].v) swap(ee[tot].u, ee[tot].v);
}
sort(ee + 1, ee + tot + 1, cmp);
n = cnt;
cnt = 0;
memset(head, 0, sizeof(head));
add_edge(ee[1].u, ee[1].v);
add_edge(ee[1].v, ee[1].u);
for (i = 2; i <= tot; i++) {
if (ee[i].u == ee[i - 1].u && ee[i].v == ee[i - 1].v) continue;
add_edge(ee[i].u, ee[i].v);
add_edge(ee[i].v, ee[i].u);
}
memset(vis, false, sizeof(vis));
for (i = 1; i <= n; i++)
if (!vis[i]) {
sum = 1e9;
dfs3(i, 0);
dfs4(i, 0);
dfs2(i, 0);
ans += sum + 1;
}
printf("%lld\n", ans - 1);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int count = 0;
while (s.size() != 1) {
int sum = 0;
for (int i = 0; i < s.size(); i++) sum += s[i] - 48;
string res = "";
while (sum) {
int digit = sum % 10;
sum /= 10;
res += (char)(digit + 48);
}
s = res;
count++;
}
cout << count;
}
| 2 |
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
class Bigint
{
static const long long MAX = 1000000000LL;
vector<long long> a;
bool sign;
public:
Bigint(){
sign = true;
}
Bigint(long long x){
if(x < 0){
sign = false;
x *= -1;
}else
sign = true;
while(x > 0){
a.push_back(x % MAX);
x /= MAX;
}
}
Bigint(const string& s){
sign = true;
long long tmp = MAX;
for(int i=s.size()-1; i>=0; --i){
if(tmp == MAX){
a.push_back(0);
tmp = 1;
}
if('0' <= s[i] && s[i] <= '9'){
a.back() += (s[i] - '0') * tmp;
tmp *= 10;
}else
sign = false;
}
}
long long getNum(){
long long ret = 0;
for(int i=a.size()-1; i>=0; --i){
ret *= MAX;
ret += a[i];
}
return ret * (sign? 1:-1);
}
string getStr() const{
ostringstream oss;
if(!sign)
oss << '-';
for(int i=a.size()-1; i>=0; --i){
oss << a[i];
oss << setw(9) << setfill('0');
}
return oss.str();
}
Bigint operator+(const Bigint& x) const{
if(sign ^ x.sign){
Bigint tmp = x;
tmp.sign = !tmp.sign;
return *this - tmp;
}
Bigint ret;
ret.sign = sign;
long long carry = 0;
unsigned i = 0;
while(i < a.size() || i < x.a.size() || carry > 0){
if(i < a.size())
carry += a[i];
if(i < x.a.size())
carry += x.a[i];
ret.a.push_back(carry % MAX);
carry /= MAX;
++ i;
}
return ret;
}
Bigint operator-(const Bigint& x) const{
if(sign ^ x.sign){
Bigint tmp = x;
tmp.sign = !tmp.sign;
return *this + tmp;
}
Bigint ret;
long long carry = 0;
unsigned i=0;
while(i < a.size() || i < x.a.size()){
if(i < a.size())
carry += a[i];
if(i < x.a.size())
carry -= x.a[i];
if(carry < 0){
ret.a.push_back(MAX + carry);
carry = -1;
}else{
ret.a.push_back(carry);
carry = 0;
}
++ i;
}
if(carry == -1){
ret.sign = !ret.sign;
for(unsigned j=0; j<ret.a.size(); ++j)
ret.a[j] = MAX - ret.a[j] - 1;
++ ret.a[0];
}
while(ret.a.size() > 0 && ret.a.back() == 0)
ret.a.pop_back();
return ret;
}
Bigint operator*(const Bigint& x) const{
if(a.size() == 0 || x.a.size() == 0)
return 0;
Bigint ret;
ret.sign = !(sign ^ x.sign);
ret.a.assign(a.size() + x.a.size(), 0);
for(unsigned i=0; i<a.size(); ++i){
for(unsigned j=0; j<x.a.size(); ++j){
ret.a[i+j] += a[i] * x.a[j];
ret.a[i+j+1] += ret.a[i+j] / MAX;
ret.a[i+j] %= MAX;
}
}
if(ret.a.size() > 0 && ret.a.back() == 0)
ret.a.pop_back();
return ret;
}
bool operator<(const Bigint& x) const{
if(sign ^ x.sign)
return x.sign;
if(a.size() != x.a.size())
return !(sign ^ (a.size() < x.a.size()));
for(int i=a.size()-1; i>=0; --i){
if(a[i] != x.a[i])
return !(sign ^ (a[i] < x.a[i]));
}
return false;
}
};
void integerFactorization(int n, vector<int>& base, vector<int>& expo)
{
base.clear();
expo.clear();
int a = 2;
while(a * a <= n){
int b = 0;
while(n % a == 0){
++ b;
n /= a;
}
if(b > 0){
base.push_back(a);
expo.push_back(b);
}
++ a;
}
if(n > 1 || base.size() == 0){
base.push_back(n);
expo.push_back(1);
}
}
int main()
{
int n;
cin >> n;
map<int, int> m;
for(int i=2; i<=n+1; ++i){
vector<int> base, expo;
integerFactorization(i, base, expo);
for(unsigned j=0; j<base.size(); ++j)
m[base[j]] = max(m[base[j]], expo[j]);
}
Bigint a(1);
for(map<int, int>::iterator it=m.begin(); it!=m.end(); ++it){
for(int i=0; i<it->second; ++i)
a = a * it->first;
}
a = a + 2;
cout << a.getStr() << endl;
for(int i=2; i<n+2; ++i)
cout << i << endl;
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <cmath>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
#include <functional>
#include<complex>
#include<cassert>
using namespace std;
#define rep(i,x) for(ll i=0;i<x;i++)
#define repn(i,x) for(ll i=1;i<=x;i++)
typedef long long ll;
const ll INF = 1e17;
const ll MOD = 1000000007;
const ll MAX = 4000001;
const long double eps = 1E-14;
ll max(ll a, ll b) {
if (a > b) { return a; }
return b;
}
ll min(ll a, ll b) {
if (a > b) { return b; }
return a;
}
ll gcd(ll a, ll b) {
if (b == 0) { return a; }
if (a < b) { return gcd(b, a); }
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
struct edge {
ll ind;
ll fr;
ll to;
ll d;
};
class mint {
long long x;
public:
mint(long long x = 0) : x((x% MOD + MOD) % MOD) {}
mint operator-() const {
return mint(-x);
}
mint& operator+=(const mint& a) {
if ((x += a.x) >= MOD) x -= MOD;
return *this;
}
mint& operator-=(const mint& a) {
if ((x += MOD - a.x) >= MOD) x -= MOD;
return *this;
}
mint& operator*=(const mint& a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint& a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint& a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint& a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
// for prime MOD
mint inv() const {
return pow(MOD - 2);
}
mint& operator/=(const mint& a) {
return (*this) *= a.inv();
}
mint operator/(const mint& a) const {
mint res(*this);
return res /= a;
}
friend ostream& operator<<(ostream& os, const mint& m) {
os << m.x;
return os;
}
};
mint pw(mint a, ll b) {
if (b == 0) { return 1; }
mint ret = pw(a, b >> 1);
ret *= ret;
if (b & 1) { ret *= a; }
return ret;
}
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<mint> vmint;
typedef vector<vector<mint>> vvmint;
typedef vector<vector<vector<mint>>> vvvmint;
/////////////////////////////////////
struct unionfind {
ll N;
vector<ll> par;
vector<ll> sz;//根の場合、その木のサイズ
unionfind(ll N0) {
N = N0;
par.assign(N + 1, -1);
sz.assign(N + 1, 1);
}
ll root(ll x) {
if (par[x] == -1) { return x; }
par[x] = root(par[x]);
return par[x];
}
bool same(ll x, ll y) {
return root(x) == root(y);
}
void unite(ll x, ll y) {
ll a = root(x);
ll b = root(y);
if (a != b) {
par[a] = b; sz[b] += sz[a];
}
}
ll size(ll x) {
ll r = root(x);
return sz[r];
}
};
int main(){
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> e(M);
rep(i, M)cin >> e[i].first >> e[i].second;
vector<vector<pair<ll,ll>>> g(N + 1);
vector <vector<bool>> mat(N + 1, vector<bool>(N + 1, 0));
rep(i, N-1) {
g[e[i].first].push_back({ i,e[i].second });
g[e[i].second].push_back({ i,e[i].first });
}
rep(i,M){
mat[e[i].first][e[i].second] = 1;
mat[e[i].second][e[i].first] = 1;
}
vector<int> c(1 << (N - 1), 0);
rep(i, 1 << (N - 1)) {
vvll lis(N + 1);
vll see(N + 1, 0);
repn(v, N) {
//cout << v << endl;
if (see[v] != 0) { continue; }
lis[v].push_back(v);
see[v] = 1;
queue<ll> q;
q.push(v);
while (!q.empty()) {
ll w = q.front();
q.pop();
for (auto p : g[w]) {
if (see[p.second] != 0) { continue; }
if (!((i >> p.first) & 1)) { continue; }
see[p.second] = 1;
lis[v].push_back(p.second);
q.push(p.second);
}
}
}
repn(j, N) {
rep(k, lis[j].size())for (ll l = k + 1; l < lis[j].size(); l++) {
if (mat[lis[j][k]][lis[j][l]]) { c[i]++; }
}
}
//cout << i << " " << c[i] << endl;
}
//return 0;
vector<vector<ll>> dp1(1 << (N - 1)), dp2(1 << (N - 1));
dp1[0].push_back(1);
dp2[0].push_back(0);
repn(i, (1 << (N - 1))-1) {
//cout << i << endl;
dp1[i].assign(c[i]+1, 0);
dp2[i].assign(c[i]+1, 0);
rep(k, N - 1) {
if (!((i >> k) & 1)) { continue; }
ll x = i ^ (1 << k);
repn(j, c[x]+1) {
dp1[i][j] += dp1[x][j - 1];
dp2[i][j] += dp2[x][j - 1] + dp1[x][j - 1] * j;
dp1[i][j] %= MOD;
dp2[i][j] %= MOD;
}
}
repn(j, c[i]) {
dp1[i][j] += dp1[i][j - 1] * (c[i] - (j - 1));
dp2[i][j] += dp2[i][j - 1] * (c[i] - (j - 1));
dp1[i][j] %= MOD;
dp2[i][j] %= MOD;
}
//repn(j, c[i])cout << i << j << dp1[i][j] << dp2[i][j] << endl;
}
cout << dp2[(1 << (N - 1)) - 1][M] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
void solve() {
unsigned long long n;
cin >> n;
string s;
cin >> s;
vector<unsigned long long> dp(4);
dp[0] = 1;
for (auto x : s) {
if (x == '?') {
dp[3] = (dp[3] * 3 + dp[2]) % 1000000007;
dp[2] = (dp[2] * 3 + dp[1]) % 1000000007;
dp[1] = (dp[1] * 3 + dp[0]) % 1000000007;
dp[0] = (dp[0] * 3) % 1000000007;
}
if (x == 'a') dp[1] = (dp[1] + dp[0]) % 1000000007;
if (x == 'b') dp[2] = (dp[2] + dp[1]) % 1000000007;
if (x == 'c') dp[3] = (dp[3] + dp[2]) % 1000000007;
}
cout << dp[3] % 1000000007;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
unsigned long long t = 1;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int x, y;
cin >> x >> y;
int absx = max(x, -x), absy = max(y, -y), rez = 0;
if((absx > absy && x > 0) ||
(absx < absy && x < 0)){
++rez;
x = -x; }
const int diff = max(absx-absy, absy-absx);
x += diff;
rez += diff;
if(x != y) ++rez;
cout << rez << endl;
return 0; }
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
int i, j, n, fa[N], sum[N], num[N], tot;
struct E {
int u, v, w;
bool operator<(const E& a) const { return w < a.w; }
} e[N];
int get(int x) {
if (fa[x] == x) return x;
return fa[x] = get(fa[x]);
}
int main() {
scanf("%d", &n);
for (i = 1; i < n; i++) scanf("%d %d %d", &e[i].u, &e[i].v, &e[i].w);
for (i = 1; i <= n; i++) scanf("%d", sum + i);
for (i = 1; i <= n; i++) fa[i] = i, num[i] = 1, tot += sum[i];
sort(e + 1, e + n);
for (i = 1; i < n; i++) {
static int x, y;
for (j = 1; j <= n; j++)
if (fa[j] == j && num[j] > n / 2) break;
if (num[j] > tot - sum[j]) break;
x = get(e[i].u), y = get(e[i].v);
if (x != y) {
num[y] += num[x];
sum[y] += sum[x];
fa[x] = y;
}
}
cout << e[i - 1].w << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, s, p = 0, w = 0, ans = 0;
long long d[19];
long long f[19];
long long g[10];
bool r[19];
long long gcd(long long n, long long m) {
if (m == 0) return n;
return gcd(m, n % m);
}
long long fac(long long x, long long y) {
long long a = 1, b = 1;
for (int h = 2; h <= x; h++) b *= h;
for (int h = y; h > y - x; h--) {
int o = gcd(b, h), l;
l = h / o;
b /= o;
a *= l;
a %= 1000000007;
}
return a;
}
long long so(long long x) {
long long l = 0;
for (int h = 0; h < x; h++)
if (h != 4 && h != 7) l++;
return l;
}
void tap(long long x) {
if (x == p) {
long long y = p;
for (int h = 0; h < p; h++) y -= r[h];
for (int h = 0; h < p; h++) {
long long f = 1;
if (r[h] == 0 && d[h] > 7)
f = 2;
else if (r[h] == 0 && d[h] < 5)
f = 0;
if (r[h] == 1) f *= so(d[h]);
for (int j = 0; j < h; j++)
if ((r[j] == 1 && (d[j] == 4 || d[j] == 7)) ||
(r[j] == 0 && (d[j] != 4 && d[j] != 7)))
f = 0;
for (int j = h + 1; j < p; j++) {
if (r[j] == 0)
f *= 2;
else
f *= 8;
}
g[y] += f;
}
} else {
r[x] = 0;
tap(x + 1);
r[x] = 1;
tap(x + 1);
}
}
void tapmak(long long x, long long y, long long u) {
if (y == 0) {
long long r = 0;
for (int h = 0; h < 10; h++) r += f[h] * h;
for (int h = 0; h < 10; h++)
if (f[h] > g[h]) r = 99;
if (r < u) {
long long m = 6 * 5 * 4 * 3 * 2;
for (int h = 0; h < 10; h++)
if (f[h] != 0) m *= fac(f[h], g[h]), m %= 1000000007;
ans += (m * g[u]) % 1000000007;
ans %= 1000000007;
}
} else {
if (x > 0)
for (int h = 0; h <= y; h++) {
f[x] = h;
for (int j = 0; j < x; j++) f[j] = 0;
tapmak(x - 1, y - h, u);
}
else {
f[0] = y;
tapmak(x, 0, u);
}
}
}
int main() {
cin >> n;
s = n;
while (s != 0) {
if (s % 10 == 4 || s % 10 == 7) w++;
d[p++] = s % 10;
s /= 10;
}
int e = p - 1;
for (int h = 0; h < p / 2; h++) swap(d[h], d[e]), e--;
tap(0);
g[0]--;
g[w]++;
for (int h = 1; h < 10; h++)
if (g[h] != 0) tapmak(h - 1, 6, h), memset(f, 0, sizeof(f));
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 5;
int t[N], ans[N], num[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t[i];
t[i]--;
}
for (int i = 0; i < n; i++) {
int mx = 0;
memset(num, 0, sizeof(num));
for (int j = i; j < n; j++) {
num[t[j]]++;
if (num[t[j]] > num[mx] || (num[t[j]] == num[mx] && t[j] < mx)) mx = t[j];
ans[mx]++;
}
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 55;
long long int n, m;
char arr[N][N];
long long int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
bool valid(long long int i, long long int j) {
return i >= 1 && i <= n && j >= 1 && j <= m;
}
int main() {
long long int t;
cin >> t;
while (t--) {
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
cin >> arr[i][j];
}
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (arr[i][j] == 'B') {
for (long long int k = 0; k < 4; k++) {
long long int ni = i + dir[k][0];
long long int nj = j + dir[k][1];
if (valid(ni, nj) && arr[ni][nj] == '.') {
arr[ni][nj] = '#';
}
}
}
}
}
queue<pair<long long int, long long int> > que;
bool visited[n + 5][m + 5];
memset(visited, false, sizeof(visited));
if (arr[n][m] == '.') {
que.push({n, m});
visited[n][m] = true;
}
while (!que.empty()) {
pair<long long int, long long int> curr = que.front();
que.pop();
for (long long int k = 0; k < 4; k++) {
long long int ni = curr.first + dir[k][0];
long long int nj = curr.second + dir[k][1];
if (valid(ni, nj) && !visited[ni][nj] && arr[ni][nj] != '#') {
que.push({ni, nj});
visited[ni][nj] = true;
}
}
}
bool good = true;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if ((arr[i][j] == 'G' && !visited[i][j]) ||
(arr[i][j] == 'B' && visited[i][j])) {
good = false;
break;
}
}
}
if (good)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b[100009 * 2], c[100009 * 2];
vector<int> v, v1;
long long sm, sm1;
map<int, int> mp, mp1;
int main() {
cin >> a;
for (int i = 1; i <= a; i++) cin >> b[i];
for (int i = 1; i <= a; i++) cin >> c[i];
for (int i = 1; i <= a; i++) {
if (b[i] > 0) v.push_back(b[i]);
if (c[i] > 0)
v1.push_back(c[i]);
else
sm++;
}
if (v.size() == v1.size()) {
for (int i = 0; i < v.size() - 1; i++)
mp[v[i]] = v[i + 1], mp1[v1[i]] = v1[i + 1];
for (int i = 1; i < a; i++)
if (mp[i] > 0 and mp1[i] > 0 and mp1[i] != mp[i]) sm1++;
if (sm1 < sm) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int h = -1;
stack<long long int> s;
for (long long int i = 0; i < n; i++) {
if (s.empty() == 0) {
if (s.top() == a[i])
s.pop();
else if (a[i] > s.top()) {
cout << "NO";
exit(0);
} else {
s.push(a[i]);
h = max(h, a[i]);
}
} else {
s.push(a[i]);
h = max(h, a[i]);
}
}
if ((s.size() == 0))
cout << "YES";
else if (s.size() == 1 && s.top() >= h)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rm(int l, int r) {
uniform_int_distribution<int> dis(l, r);
return dis(rng);
}
using ulli = unsigned long long;
using lli = long long;
using ld = long double;
using ii = pair<int, int>;
using vi = vector<int>;
const int N = 2e5 + 5;
int n;
vector<int> graph[N];
lli mem[N], ans[N], tot[N];
bool done[N];
lli dfs(int u, int pr = -1) {
tot[u] = 1;
for (int v : graph[u])
if (v != pr) tot[u] += dfs(v, u);
return tot[u];
}
lli dp(int u, int pr = -1) {
lli &ans = mem[u];
if (done[u]) return ans;
done[u] = true;
ans = tot[u];
for (int v : graph[u])
if (v != pr) ans += dp(v, u);
return ans;
}
void solve(int u, int pr = -1) {
ans[u] = mem[u];
;
for (int v : graph[u])
if (v != pr) {
tot[u] -= tot[v];
mem[u] -= tot[v];
mem[u] -= mem[v];
tot[v] += tot[u];
mem[v] += tot[u];
mem[v] += mem[u];
solve(v, u);
mem[v] -= mem[u];
mem[v] -= tot[u];
tot[v] -= tot[u];
mem[u] += mem[v];
mem[u] += tot[v];
tot[u] += tot[v];
}
}
int main() {
cin.tie(0)->sync_with_stdio(0), cout.tie(0);
cin >> n;
for (auto i = (0) - ((0) > (n - 1)); i != n - 1 - ((0) > (n - 1));
i += 1 - 2 * ((0) > (n - 1))) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
dfs(1);
dp(1);
solve(1);
cout << *max_element(ans + 1, ans + n + 1) << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 15000;
int n, e;
vector<vector<int> > gt;
vector<set<int> > g;
vector<int> cyc;
void buildTrees() {
queue<int> q;
for (int i = 0; i < n; ++i)
if (g[i].size() == 1) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
int v = *g[u].begin();
gt[v].push_back(u);
g[u].erase(v);
g[v].erase(u);
if (g[v].size() == 1) q.push(v);
}
for (int i = 0; i < n; ++i)
if (g[i].size() == 2) {
int u = i, p = -1;
do {
cyc.push_back(u);
for (auto x : g[u])
if (x != p) {
p = u;
u = x;
break;
}
} while (u != i);
break;
}
}
int cost[N], sz[N];
void calc(int u) {
sz[u] = 1;
for (auto &v : gt[u]) {
calc(v);
sz[u] += sz[v];
cost[u] += cost[v];
}
cost[u] += sz[u];
}
int srcCost[N];
int calcSC(int u, int size) {
int &ret = srcCost[u];
if (ret != -1) return ret;
ret = size + 1;
int all = 0;
for (auto &v : gt[u]) all += cost[v];
for (auto &v : gt[u])
ret = max(ret, all - cost[v] + size + sz[u] - sz[v] +
calcSC(v, size + sz[u] - sz[v]));
return ret;
}
int dp[2][N];
int main() {
memset(srcCost, -1, sizeof(srcCost));
scanf("%d", &n);
g.resize(n);
gt.resize(n);
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
g[x].insert(y);
g[y].insert(x);
}
buildTrees();
for (auto &u : cyc) calc(u);
for (auto &u : cyc) calcSC(u, n - sz[u]);
int oN = n;
n = cyc.size();
vector<int> cs(2 * n + 2);
for (int i = 0; i <= 2 * n; ++i) cs[i + 1] = sz[cyc[i % n]] + cs[i];
for (int i = 0; i < n; ++i)
dp[1][i] = max(cost[cyc[i]] + oN - sz[cyc[i]], srcCost[cyc[i]]);
for (int len = 2; len <= n; ++len)
for (int i = 0; i < n; ++i)
dp[1 & len][i] = max(dp[1 & ~len][i] + oN - (cs[i + len] - cs[i]) +
cost[cyc[(i + len - 1) % n]],
dp[1 & ~len][(i + 1) % n] + oN -
(cs[i + len] - cs[i]) + cost[cyc[i]]);
cout << *max_element(dp[n & 1], dp[n & 1] + n) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 987654321;
const int N = 4004;
const int MOD = 1e9 + 7;
long long comb[N][N];
long long dp[N];
int main() {
ios_base::sync_with_stdio(false);
cout.precision(10);
cout << fixed;
int n;
cin >> n;
comb[0][0] = 1;
for (int i = 0; i < N; ++i) {
comb[i][0] = 1;
for (int j = 1; j < N; ++j)
if (i > 0) comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % MOD;
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int i = 1; i < N; ++i) {
dp[i] = 0;
for (int j = 0; j <= i - 1; ++j) (dp[i] += dp[j] * comb[i - 1][j]) %= MOD;
}
long long res = 0;
for (int i = 0; i < n; ++i) (res += comb[n][n - i] * dp[i]) %= MOD;
cout << res << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, t, a[200000 + 1], b[200000 + 1], pos[200000 + 1], c, res(0);
int main() {
scanf("%d", &n);
for (int i = (1), _b = (n); i <= _b; i++) scanf("%d", &a[i]);
for (int i = (1), _b = (n); i <= _b; i++) scanf("%d", &b[i]);
for (int i = (1), _b = (n); i <= _b; i++) pos[b[i]] = i;
t = 0;
for (int i = (1), _b = (n); i <= _b; i++) {
if (t <= pos[a[i]])
t = pos[a[i]];
else {
res = n - i + 1;
break;
}
}
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
char name[15];
int dp[30][30];
int main() {
int n;
while (~scanf("%d", &n)) {
int len;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
scanf("%s", name);
len = strlen(name);
int first = name[0] - 'a';
int last = name[len - 1] - 'a';
for (int i = 0; i < 26; i++)
if (dp[i][first] && dp[i][first] + len > dp[i][last])
dp[i][last] = dp[i][first] + len;
if (dp[first][last] < len) dp[first][last] = len;
}
int ans = 0;
for (int i = 0; i < 26; i++) ans = max(ans, dp[i][i]);
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int col[1000][1000] = {{
0,
}};
int n1 = 0;
int n2 = 0;
int N, M;
void go(queue<pair<int, int> > &q, int u, int v, int x, int y) {
if (x >= 0 && y >= 0 && x < N && y < M && col[x][y] == 0) {
q.push(make_pair(x, y));
col[x][y] = 3 - col[u][v];
if (col[x][y] == 1)
++n1;
else
++n2;
}
}
int main() {
cin >> N >> M;
int x, y;
int ans = 0;
for (int _n = N, ii = 0; ii < _n; ++ii)
for (int _n = M, jj = 0; jj < _n; ++jj) {
if (col[ii][jj]) continue;
col[ii][jj] = 1;
n1 = 1;
n2 = 0;
queue<pair<int, int> > q;
q.push(make_pair(ii, jj));
while (!q.empty()) {
int u = q.front().first;
int v = q.front().second;
q.pop();
for (int x = (max(u - 2, 0)), _b = (min(u + 2, N - 1)); x <= _b; ++x)
for (int y = (max(v - 2, 0)), _b = (min(v + 2, M - 1)); y <= _b; ++y)
if ((x - u) * (x - u) + (y - v) * (y - v) == 5) go(q, u, v, x, y);
}
ans += max(n1, n2);
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, ans = 0, h, t, t2;
string s;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> b >> c >> s;
ans = b;
h = 0;
t = s.length() - 1;
while (s[h] == '0') h++;
while (s[t] == '0') t--;
if (h > t) ans = 0;
for (int i = h; i <= t; i++) {
t2 = 0;
while (s[i] == '0') {
t2++;
i++;
}
if (t2 != 0) {
ans += min(t2 * c, b);
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x1, y1, x2, y2;
bool ans;
};
node q[600100];
bitset<510> f1[510][510], f2[510][510];
char ch[510][510];
int n, m, Q;
void solve(int l, int r, vector<int> L) {
if (l > r) return;
if (L.size() == 0) return;
int mid = (l + r) >> 1;
for (int i = l - 1; i <= r + 1; i++)
for (int j = 0; j <= m + 1; j++) f1[i][j].reset(), f2[i][j].reset();
for (int j = 1; j <= m; j++)
if (ch[mid][j] == '.') f1[mid][j].set(j), f2[mid][j].set(j);
for (int i = mid; i >= l; i--)
for (int j = m; j >= 1; j--) {
if (ch[i][j] == '#') continue;
f1[i][j] |= f1[i][j + 1];
f1[i][j] |= f1[i + 1][j];
}
for (int i = mid; i <= r; i++)
for (int j = 1; j <= m; j++) {
if (ch[i][j] == '#') continue;
f2[i][j] |= f2[i][j - 1];
f2[i][j] |= f2[i - 1][j];
}
vector<int> lL, rL;
for (int i = 0; i < L.size(); i++) {
if (q[L[i]].x2 < mid)
lL.push_back(L[i]);
else if (q[L[i]].x1 > mid)
rL.push_back(L[i]);
else
q[L[i]].ans =
(f1[q[L[i]].x1][q[L[i]].y1] & f2[q[L[i]].x2][q[L[i]].y2]).any();
}
solve(l, mid, lL);
solve(mid + 1, r, rL);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", ch[i] + 1);
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d%d%d%d", &q[i].x1, &q[i].y1, &q[i].x2, &q[i].y2);
q[i].ans = 0;
}
vector<int> L;
for (int i = 1; i <= Q; i++) L.push_back(i);
solve(1, n, L);
for (int i = 1; i <= Q; i++)
if (q[i].ans)
puts("Yes");
else
puts("No");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
vector<int> adj[maxn];
int deg[maxn];
int c[maxn];
void dfs(int u, int p, int col) {
c[u] = col;
for (int v : adj[u]) {
if (v == p || c[v] != -1) continue;
dfs(v, p, !col);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
c[i] = -1;
}
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (c[i] == -1) {
dfs(i, 0, 0);
}
}
for (int veces = 0; veces < 1; veces++) {
bool change = false;
for (int i = 1; i <= n; i++) {
int mismo = 0;
int u = i;
for (int v : adj[u]) {
if (c[v] == c[u]) mismo++;
}
if (mismo > 1) {
change = true;
queue<int> q;
q.push(u);
while (!q.empty()) {
int curr = q.front();
q.pop();
int igual = 0;
for (int v : adj[curr]) {
if (c[v] == c[curr]) igual++;
}
if (igual < 2) continue;
c[curr] = !c[curr];
for (int v : adj[curr]) {
int mismo2 = 0;
for (int w : adj[v]) {
if (c[w] == c[v]) mismo2++;
}
if (mismo2 > 1) {
q.push(v);
}
}
}
}
}
if (!change) break;
}
for (int i = 1; i <= n; i++) {
assert(c[i] >= 0);
cout << c[i];
}
cout << '\n';
return 0;
}
| 3 |
#include <iostream>
#include <cstdio>
using namespace std;
int n, p[25], cnt;
int main() {
int i;
cin>>n;
for(i=0; i<n; i++) cin>>p[i];
for(i=1; i<n-1; i++) {
if(p[i] < p[i-1] && p[i] > p[i+1] || p[i] > p[i-1] && p[i] < p[i+1]) cnt++;
}
cout<<cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200002, MN = 1000002;
const long long mod = 1000000007;
vector<pair<int, int> > Q[MAXN];
int a[MAXN], ans[MAXN];
int pos[MN], p[MN], n, q;
long long tree[MAXN * 2];
void upd(int l, int r, int x) {
for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) tree[l] = tree[l] * x % mod, l++;
if (r & 1) --r, tree[r] = tree[r] * x % mod;
}
}
long long query(int i) {
int ret = 1;
for (i += n; i > 0; i >>= 1) ret = ret * tree[i] % mod;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(pos, -1, sizeof pos);
for (int i = 2; i * i < MN; i++)
if (!p[i])
for (int j = i * i; j < MN; j += i) p[j] = i;
for (int i = 1; i < MN; i++)
if (!p[i]) p[i] = i;
cin >> n;
for (int i = 0; i < n + n; i++) tree[i] = 1;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
int r = a[0];
while (a[0] > 1) {
int t = p[a[0]];
while (a[0] % t == 0) a[0] /= t;
r /= t;
r *= t - 1;
}
cin >> q;
for (int i = 0; i < q; i++) cout << r << '\n';
return 0;
}
cin >> q;
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
Q[r - 1].push_back({l - 1, i});
}
for (int i = 0; i < n; i++) {
int x = a[i];
while (x > 1) {
int r = p[x], m = 1;
while (x % r == 0) x /= r, m *= r;
if (m != r) upd(0, i, m / r);
upd(pos[r] + 1, i, r - 1);
upd(0, pos[r], r);
pos[r] = i;
}
for (auto x : Q[i]) ans[x.second] = query(x.first);
}
for (int i = 0; i < q; i++) cout << ans[i] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20000;
set<vector<int> > s[N];
string deps[] = {"Gryffindor", "Hufflepuff", "Ravenclaw", "Slytherin"};
string dd = "GHRS";
int main() {
int n;
cin >> n;
s[0].insert(vector<int>(4, 0));
string t;
cin >> t;
set<int> types;
n++;
t += "?";
for (int i = 1; i <= n; i++) {
string f = "";
f += t[i - 1];
types.clear();
const set<vector<int> >& ss = s[i - 1];
int type = (dd.find(f) != string::npos ? dd.find(f) : -1);
for (set<vector<int> >::iterator it = ss.begin(); it != ss.end(); it++) {
if (type != -1) {
vector<int> next(*it);
next[type]++;
s[i].insert(next);
types.insert(type);
} else {
int minv = *min_element(it->begin(), it->end());
for (int j = 0; j < int(it->size()); j++)
if ((*it)[j] == minv) {
vector<int> next(*it);
next[j]++;
s[i].insert(next);
types.insert(j);
}
}
}
}
for (set<int>::iterator i = types.begin(); i != types.end(); i++)
cout << deps[*i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long root = 5e2;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
for (auto &x : a) cin >> x;
vector<vector<long long>> dp(root + 1);
long long q;
cin >> q;
vector<vector<long long>> qs(q);
vector<long long> ans(q), id(q);
for (long long i = 0; i < q; ++i) {
long long x, y;
cin >> x >> y;
qs[i] = {y, x, i};
}
sort(qs.begin(), qs.end());
for (long long i = 0; i < q; ++i) {
id[qs[i][2]] = i;
}
vector<long long> last(n);
for (long long i = 0; i < q; ++i) {
long long x = qs[i][1] - 1, y = qs[i][0];
if (qs[i][0] > root) {
for (long long j = x; j < n; j += y) {
ans[i] += a[j];
}
} else {
if (!i or (qs[i][0] != qs[i - 1][0])) {
for (long long j = 0; j < n; ++j) {
last[j] = a[j];
if (j - y >= 0) last[j] += last[j - y];
}
}
long long l = x + (n - x - 1) / y * y;
ans[i] = last[l] - last[x] + a[x];
}
}
for (long long i = 0; i < q; ++i) {
cout << ans[id[i]] << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
vector<int> a, b;
for (int i = 0; i < s.length(); i++) {
if (s[i] != t[i]) {
if (s[i] == 'a')
a.push_back(i);
else
b.push_back(i);
}
}
if (a.size() % 2 != b.size() % 2) {
cout << "-1";
return 0;
}
vector<pair<int, int>> ans;
for (int i = 0; i + 1 < a.size(); i += 2) {
ans.push_back(make_pair(a[i], a[i + 1]));
}
for (int i = 0; i + 1 < b.size(); i += 2) {
ans.push_back(make_pair(b[i], b[i + 1]));
}
if (a.size() != 0 && a.size() % 2) {
int x = a[a.size() - 1];
int y = b[b.size() - 1];
ans.push_back(make_pair(x, x));
ans.push_back(make_pair(x, y));
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
long n, x[200001], i, min = 1111111111, temp;
char s[200001];
scanf("%d %s", &n, s);
for (i = 0; i < n; i++) scanf("%d", x + i);
for (i = 0; i < n; i++) {
if (s[i] == 'R' && s[i + 1] == 'L') {
temp = (x[i + 1] - x[i]) / 2;
if (min > temp) min = temp;
}
}
printf("%d", min == 1111111111 ? -1 : min);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double mi, kq, h, c, t, q;
void xuly(long long x) {
if (x < 0) return;
double tg = abs(t - (x * (h + c) + h) * 1.0 / (2 * x + 1));
if (mi > tg || (mi == tg && kq > x * 2 + 1)) {
mi = tg;
kq = x * 2 + 1;
}
}
int main() {
cin >> q;
while (q--) {
cin >> h >> c >> t;
mi = abs(t - (h + c) * 1.0 / 2);
kq = 2;
long long l = 0, r = round(1e6);
while (l < r) {
long long mid = (l + r) >> 1;
if ((mid * (h + c) + h) <= (2 * mid + 1) * t)
r = mid;
else
l = mid + 1;
}
xuly(l);
xuly(l - 1);
cout << kq << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int neg(int n) {
int res = 0;
int k = 0;
int h = 1;
while (n != 0) {
int k = n % 2;
if (k == 0)
k = 1;
else
k = 0;
res = (k * h) + res;
n = n / 2;
h = h * 2;
}
return res;
}
int main() {
int n;
cin >> n;
vector<pair<int, int> > v;
int i = n;
long long sum = 0;
while (i != -1) {
int k = neg(i);
v.push_back(make_pair(i, k));
i = k - 1;
}
vector<int> vv;
for (int j = v.size() - 1; j >= 0; j--) {
int a = v[j].first;
int b = v[j].second;
for (int h = a; h >= b; h--) vv.push_back(h);
}
for (int i = 0; i < vv.size(); i++) {
sum += (i ^ vv[i]);
}
cout << sum << endl;
for (int i = 0; i < vv.size(); i++) cout << vv[i] << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
for (int i = 0; i < k; ++i) {
int res = 0;
int a, b, c;
cin >> a >> b >> c;
while (b != 0 && c >= 2) {
res += 3;
b -= 1;
c -= 2;
}
while (a != 0 && b >= 2) {
res += 3;
a -= 1;
b -= 2;
}
cout << res << endl;
res = 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0, j;
char a[100];
while (1) {
cin >> a[i];
if (a[i] == '?') break;
++i;
}
j = i;
for (i = 0; i <= j; ++i) {
if (a[i] == '?') break;
}
while (i >= 0) {
i = i - 1;
if (a[i] != ' ') {
if (tolower(a[i]) == 'a' || tolower(a[i]) == 'e' ||
tolower(a[i]) == 'i' || tolower(a[i]) == 'o' ||
tolower(a[i]) == 'u' || tolower(a[i]) == 'y')
cout << "YES";
else
cout << "NO";
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long OO = (long long)1000000000000000000;
const long long MOD = (long long)1000000007;
int n, c[200005], d[200005], h[200005], mx = -INT_MAX, mn = INT_MAX;
int main() {
cin >> n;
h[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> c[i] >> d[i];
h[i] = c[i] + h[i - 1];
}
for (int i = 1; i <= n + 1; i++) {
if (d[i] == 1)
mn = min(mn, h[i - 1]);
else if (d[i] == 2)
mx = max(mx, h[i - 1]);
}
if (mx == -INT_MAX) {
cout << "Infinity";
return 0;
} else if (mx >= mn) {
cout << "Impossible";
return 0;
}
cout << 1899 + (-1 * mx) + h[n] << endl;
return 0;
}
| 3 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
typedef double LD;
const int N=6;
const int C=1000;
const int M=100;
int n,c;
int l[N+10];
namespace task {
int p[N+10];
LD f[C+10][M+10][C+10];
LD Solve() {
for (int i=1;i<n;i++)
p[i]=i;
LD invfac=1;
for (int i=1;i<n;i++) invfac/=i;
LD ans=0;
do {
for (int i=0;i<=n*c;i++)
for (int j=0;j<(1<<(n-1));j++)
for (int k=0;k<=n*c;k++)
f[i][j][k]=0;
f[0][0][l[1]*n]=1;
for (int i=0;i<n*c;i++)
for (int j=0;j<(1<<(n-1));j++)
for (int k=0;k<=n*c;k++) {
if (f[i][j][k]==0||i>k) continue;
f[i+1][j][k]+=f[i][j][k];
if (i%n) {
if (j&(1<<(i%n-1))) continue;
int nowr=min(n*c,max(k,i+l[p[i%n]+1]*n));
f[i+1][j|(1<<(i%n-1))][nowr]+=f[i][j][k]*1.0/c;
}
}
ans+=f[n*c][(1<<(n-1))-1][n*c];
} while (next_permutation(p+1,p+n));
return ans*invfac;
}
}
int main() {
scanf("%d%d",&n,&c);
for (int i=1;i<=n;i++)
scanf("%d",&l[i]);
sort(l+1,l+n+1);
reverse(l+1,l+n+1);
LD ans=task::Solve();
printf("%.15lf\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long k = 999999 - n;
for (int i = 0; i < n; i++) {
cout << k << " ";
k += 2;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int t, i, n, m, a = 0, b = 0, c, d, x, y;
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%d %d", &n, &m);
a += n;
b += m;
}
c = t - a;
if (c < a)
x = c;
else
x = a;
d = t - b;
if (d < b)
x += d;
else
x += b;
printf("%d", x);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
vector<int> v;
cin >> n;
for (int i = 0; i < n; i++) {
bool f = false;
for (int j = 0; j < n; j++) {
cin >> x;
if (x == 3 || x == 1) {
f = true;
}
}
if (!f) {
v.push_back(i + 1);
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << ' ';
}
if (!v.empty()) cout << endl;
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for(int i = 0; i < n; ++i) cin >> a[i];
int q;
cin >> q;
while(q--) {
int t, l, r;
cin >> t >> l >> r;
if(t == 0) cout << *min_element(a.begin()+l, a.begin()+r) << endl;
else cout << *max_element(a.begin()+l, a.begin()+r) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, w, v;
} a[1000010];
int v[1000010] = {0}, ans[1000010];
int cmp(node a, node b) { return a.w > b.w; }
int main() {
int n;
cin >> n;
int cnt = 1;
for (int i = 2; i <= 2 * n; i++)
for (int j = 1; j < i; j++) {
cin >> a[cnt].w;
a[cnt].x = i;
a[cnt].y = j;
a[cnt++].v = 0;
}
sort(a + 1, a + cnt + 1, cmp);
for (int i = 1; i <= cnt; i++) {
int x = a[i].x, y = a[i].y;
if (!v[x] && !v[y]) {
v[x] = v[y] = 1;
ans[x] = y, ans[y] = x;
}
}
for (int i = 1; i <= 2 * n; i++) cout << ans[i] << " ";
return 0;
}
| 2 |
#include<iostream>
#include<string>
#include<map>
using namespace std;
int main(){
map<char, string> e;
e['A'] = "00000";
e['B'] = "00001";
e['C'] = "00010";
e['D'] = "00011";
e['E'] = "00100";
e['F'] = "00101";
e['G'] = "00110";
e['H'] = "00111";
e['I'] = "01000";
e['J'] = "01001";
e['K'] = "01010";
e['L'] = "01011";
e['M'] = "01100";
e['N'] = "01101";
e['O'] = "01110";
e['P'] = "01111";
e['Q'] = "10000";
e['R'] = "10001";
e['S'] = "10010";
e['T'] = "10011";
e['U'] = "10100";
e['V'] = "10101";
e['W'] = "10110";
e['X'] = "10111";
e['Y'] = "11000";
e['Z'] = "11001";
e[' '] = "11010";
e['.'] = "11011";
e[','] = "11100";
e['-'] = "11101";
e['\'']= "11110";
e['?'] = "11111";
map<string, char> d;
d["101"] = ' ';
d["000000"] = '\'';
d["000011"] = ',';
d["10010001"] = '-';
d["010001"] = '.';
d["000001"] = '?';
d["100101"] = 'A';
d["10011010"] = 'B';
d["0101"] = 'C';
d["0001"] = 'D';
d["110"] = 'E';
d["01001"] = 'F';
d["10011011"] = 'G';
d["010000"] = 'H';
d["0111"] = 'I';
d["10011000"] = 'J';
d["0110"] = 'K';
d["00100"] = 'L';
d["10011001"] = 'M';
d["10011110"] = 'N';
d["00101"] = 'O';
d["111"] = 'P';
d["10011111"] = 'Q';
d["1000"] = 'R';
d["00110"] = 'S';
d["00111"] = 'T';
d["10011100"] = 'U';
d["10011101"] = 'V';
d["000010"] = 'W';
d["10010010"] = 'X';
d["10010011"] = 'Y';
d["10010000"] = 'Z';
string s;
while(getline(cin, s)){
string t = "";
for(int i=0; i<s.length(); i++){
t += e[s[i]];
}
string ans = "";
for(int i=0; i<t.length(); i++){
string tmp = "";
for(int j=i; j<t.length(); j++){
tmp += t[j];
i = j;
if(d[tmp] != 0){
ans += d[tmp];
break;
}
}
}
cout << ans << endl;
}
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.