solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, d, arr[10001];
cin >> n >> m >> d;
for (int i = 1; i <= (n * m); i++) cin >> arr[i];
int curr = arr[1] % d;
for (int i = 2; i <= (n * m); i++) {
if (curr != (arr[i] % d)) {
cout << -1;
return 0;
}
}
sort(arr + 1, arr + (n * m) + 1);
int ans = 0, mid = arr[(n * m) / 2 + 1];
for (int i = 1; i <= (n * m); i++) {
ans += (abs(arr[i] - mid) / d);
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
const int mod = 1e9 + 7;
const int maxx = 2e5 + 10;
const double eps = 1e-6;
using namespace std;
const long double PI = 3.14159265358979323846;
char ss[maxx], pp[maxx];
long long len, n;
long long mp[maxx];
long long dou[maxx];
long long lowbit(long long x) { return x & -x; }
void update(long long x) {
while (x <= n) {
mp[x] += 1;
x += lowbit(x);
}
}
long long querry(long long x) {
long long res = 0;
while (x > 0) {
res += mp[x];
x -= lowbit(x);
}
return res;
}
queue<long long> ans[maxx];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> ss + 1;
for (long long i = 1; i <= n; i++) {
ans[ss[i] - 'a'].push(i);
pp[i] = ss[n - i + 1];
}
long long res = 0;
for (long long i = 1; i <= n; i++) {
dou[i] = ans[pp[i] - 'a'].front();
ans[pp[i] - 'a'].pop();
}
for (long long i = 1; i <= n; i++) {
update(dou[i]);
res += i - querry(dou[i]);
}
cout << res << endl;
return 0;
}
| 5 |
#include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
//#define int long long
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
template<class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
struct HopcroftKarp {
int n;
vector<vector<int>> g;
vector<int> match, dist;
vector<bool> used, alive;
HopcroftKarp(int n) : n(n), g(n), match(n), dist(n), used(n), alive(n, true) {}
void addEdge(int u, int v) {
g[u].emplace_back(v);
g[v].emplace_back(u);
}
int maximumMatching() {
int cnt = 0;
fill(match.begin(), match.end(), -1);
while (true) {
buildAlternatingLevelGraph();
fill(used.begin(), used.end(), false);
int flow = 0;
for (int u = 0; u < n; u++) {
if (!alive[u])continue;
if (match[u] == -1 && augment(u))
flow++;
}
if (flow == 0)break;
cnt += flow;
}
return cnt;
}
void buildAlternatingLevelGraph() {
fill(dist.begin(), dist.end(), -1);
queue<int> q;
for (int u = 0; u < n; u++)
if (match[u] == -1) {
q.emplace(u);
dist[u] = 0;
}
while (q.size()) {
int u = q.front(); q.pop();
for (int v : g[u]) {
int w = match[v];
if (w != -1 && dist[w] == -1) {
dist[w] = dist[u] + 1;
q.emplace(w);
}
}
}
};
bool augment(int u) {
used[u] = true;
for (int v : g[u]) {
if (!alive[v])continue;
int w = match[v];
if (w == -1 || (!used[w] && dist[w] == dist[u] + 1 && augment(w))) {
match[u] = v;
match[v] = u;
used[v] = true;
return true;
}
}
return false;
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M; cin >> N >> M;
HopcroftKarp hk(N + M);
rep(i, 0, N) {
int K; cin >> K;
rep(j, 0, K) {
int b; cin >> b; b--;
hk.addEdge(i, N + b);
}
}
int res = hk.maximumMatching();
if (res == M) {
cout << "Bob" << endl;
}
else {
cout << "Alice" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int64_t n, i, j, k, l, sum = 0, flag = 0, t, a[200005], ans = 0;
int64_t f(int64_t l, int64_t r) {
vector<int64_t> v;
for (int64_t i = l; i <= r; i++) {
v.push_back(a[i]);
}
if (is_sorted((v).begin(), (v).end())) return r - l + 1;
int64_t mid = l + (r - l) / 2;
return max(f(l, mid), f(mid + 1, r));
}
void solve() {
cin >> n;
for (int64_t i = 0; i < n; i++) {
cin >> a[i];
}
cout << f(0, n - 1) << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int64_t test = 1;
while (test--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long t1, t2, x1, x2, t0;
cin >> t1 >> t2 >> x1 >> x2 >> t0;
if (t1 == t2) {
cout << x1 << " " << x2 << endl;
return 0;
}
if (t1 == t0) {
cout << x1 << " " << 0 << endl;
return 0;
}
if (t2 == t0) {
cout << 0 << " " << x2 << endl;
return 0;
}
long double best = 1e20, besty1 = -1, besty2 = -1;
for (long long y2 = 0; y2 <= x2; y2++) {
long long y1 = min(y2 * (t2 - t0) / (t0 - t1), x1);
if (y1 + y2 == 0) continue;
long double next = (t1 * y1 + t2 * y2) * 1.0 / (y1 + y2);
if (next < t0) continue;
if (next < best || next - best < 1e-8 && y1 + y2 >= besty1 + besty2) {
best = next;
besty1 = y1;
besty2 = y2;
}
}
cout << (long long)(besty1) << " " << (long long)(besty2) << endl;
return 0;
}
| 3 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int s_to_i(string s){
int n=0;
for(int i=0 ; i<(int)s.size() ; i++ ){
n *= 10;
n += s[i] - '0';
}
return n;
}
vector<int> vs_to_vi(vector<string> vs){
vector<int> vi;
for(int i=0 ; i<(int)vs.size() ; i++ ){
vi.push_back( s_to_i(vs[i]) );
}
return vi;
}
vector<string> split(string s){
vector<string> vc;
string s_;
for(int i=0 ; i<(int)s.size() ; i++ ){
char c = s[i];
if( s[i] == ',' ){
vc.push_back( s_ );
s_.clear();
}else{
s_.push_back( c );
if( i == (int)s.size()-1 ){
vc.push_back( s_ );
}
}
}
return vc;
}
int main(){
string s;
vector<int> a[101];
int b[101][101] = {0};
int i;
for(i=0 ; getline(cin,s) ; i++ ){
vector<string> vc = split( s );
a[i] = vs_to_vi( vc );
//i++;
//if( i==9 ) break;
}
b[0][0] = a[0][0];
for(int j=1 ; j<i ; j++ ){
if( j <= i/2 ){
for(int k=0 ; k <= j ; k++ ){
if( k == 0 ){
b[j][k] = a[j][0] + b[j-1][k];
}else{
b[j][k] = a[j][k] + max( b[j-1][k] , b[j-1][k-1] );
}
}
}else{
for(int k=0 ; k < i-j ; k++ ){
b[j][k] = a[j][k] + max( b[j-1][k] , b[j-1][k+1] );
}
}
}
cout << b[i-1][0] << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int indegree[8010];
int type[8010];
int d[8010];
long long ans = 0;
bool adjacencyMat[8010][8010];
char s[8010];
queue<int> q;
map<char, string> hexToBinDict;
int main() {
hexToBinDict['0'] = "0000";
hexToBinDict['1'] = "0001";
hexToBinDict['2'] = "0010";
hexToBinDict['3'] = "0011";
hexToBinDict['4'] = "0100";
hexToBinDict['5'] = "0101";
hexToBinDict['6'] = "0110";
hexToBinDict['7'] = "0111";
hexToBinDict['8'] = "1000";
hexToBinDict['9'] = "1001";
hexToBinDict['A'] = "1010";
hexToBinDict['B'] = "1011";
hexToBinDict['C'] = "1100";
hexToBinDict['D'] = "1101";
hexToBinDict['E'] = "1110";
hexToBinDict['F'] = "1111";
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < n / 4; j++) {
string subline = hexToBinDict[s[j]];
for (int k = 0; k < 4; k++) {
int bit = subline[k] - '0';
adjacencyMat[i][4 * j + k] = bit;
if (bit == 1) indegree[4 * j + k]++;
}
}
}
for (int i = 0; i < n; i++)
if (!indegree[i]) q.push(i);
int tmp = n;
while (!q.empty()) {
int now = q.front();
q.pop();
tmp--;
type[now] = 3;
ans += (614ll * n + 1) * tmp;
for (int i = 0; i < n; i++)
if (adjacencyMat[now][i]) {
indegree[i]--;
if (!indegree[i]) q.push(i);
}
}
if (!tmp) return printf("%lld\n", ans), 0;
int maxIndegreePosition = -1;
int maxIndegree = 0;
for (int i = 0; i < n; i++)
if (indegree[i] > maxIndegree) {
maxIndegree = indegree[i];
maxIndegreePosition = i;
}
for (int i = 0; i < n; i++)
if (type[i] != 3)
type[i] =
(i == maxIndegreePosition || adjacencyMat[i][maxIndegreePosition])
? 1
: 2;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j && type[i] != 3 && type[j] != 3 && type[i] != type[j] &&
adjacencyMat[i][j])
d[j]++;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
if (type[i] != 3 && type[j] != 3)
ans += 3 + (type[i] == type[j] && d[i] == d[j]);
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d1, d2, d3, sum = 0, p;
cin >> d1 >> d2 >> d3;
sum += min(min(d1, d2 + d3), min(d2, d1 + d3));
if (sum == d1)
p = d1;
else
p = d2;
sum += min(d3, (d2 + d1));
if (p == d1)
sum += min(d2, (d1 + d3));
else
sum += min(d1, (d2 + d3));
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STATK:134217728")
using namespace std;
int n, q;
char s[1 << 17];
struct P {
int L, R;
char c;
P() {}
P(int L, int R, char c) : L(L), R(R), c(c) {}
};
bool operator<(const P& a, const P& b) { return a.L < b.L; }
int cnt[26];
int main() {
set<P> S;
scanf("%d%d", &n, &q);
scanf("%s", s);
for (int i = 0; i < n; ++i) S.insert(P(i, i + 1, s[i]));
while (q-- > 0) {
int i, j, k;
scanf("%d%d%d", &i, &j, &k);
i--;
memset(cnt, 0, sizeof(cnt));
set<P>::iterator it = S.upper_bound(P(i, j, '0'));
it--;
if (it->L <= i && j <= it->R) continue;
cnt[it->c - 'a'] += it->R - i;
int L = it->L, R = it->R;
char c = it->c;
S.erase(it);
if (L != i) S.insert(P(L, i, c));
while (1) {
it = S.upper_bound(P(i, j, '0'));
if (j <= it->R) {
cnt[it->c - 'a'] += j - it->L;
int L = it->L, R = it->R;
char c = it->c;
S.erase(it);
if (R != j) S.insert(P(j, R, c));
break;
}
cnt[it->c - 'a'] += it->R - it->L;
S.erase(it);
}
int add = 0;
if (k) {
for (int it = 0; it < 26; ++it) {
if (cnt[it] > 0) {
S.insert(P(i + add, i + add + cnt[it], 'a' + it));
add += cnt[it];
}
}
} else {
for (int it = 25; it >= 0; --it) {
if (cnt[it] > 0) {
S.insert(P(i + add, i + add + cnt[it], 'a' + it));
add += cnt[it];
}
}
}
}
for (set<P>::iterator it = S.begin(); it != S.end(); ++it)
for (int j = 0; j < it->R - it->L; ++j) printf("%c", it->c);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int M, N;
cin >> M >> N;
cout << (M * N) / 2;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a, b, x;
cin >> a >> b >> x;
if(0.5*a*a*b>x){
double r=2.0*x/(a*b);
printf("%.10f\n",90-atan(r/b)*180/M_PI);
return 0;
}
double r=(2*((double)a*a*b-x))/(a*a*a);
printf("%.10f\n",atan(r)*180/M_PI);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MXN = 1e6 + 7;
const int N = 1e3 + 7;
long long n;
long long a[MXN], t[4 * MXN], to[4 * MXN];
string s;
inline void push(long long v, long long L, long long R) {
if (to[v]) {
t[v] += to[v];
to[v + v] += to[v];
to[v + v + 1] += to[v];
to[v] = 0;
}
}
void build(long long v, long long l, long long r) {
if (l == r) {
t[v] = a[l];
} else {
long long mid = (l + r) / 2;
build(v * 2, l, mid);
build(v * 2 + 1, mid + 1, r);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
}
long long getmin(long long v, long long tl, long long tr, long long l,
long long r) {
push(v, tl, tr);
if (l > tr || tl > r) {
return INF;
}
if (l <= tl && tr <= r) {
return t[v];
}
long long mid = (tl + tr) / 2;
return min(getmin(v * 2, tl, mid, l, r),
getmin(v * 2 + 1, mid + 1, tr, l, r));
}
void upd(long long v, long long tl, long long tr, long long l, long long r,
long long val) {
push(v, l, r);
if (l > tr || tl > r) return;
if (l <= tl && tr <= r) {
to[v] += val;
push(v, l, r);
return;
}
long long mid = (tl + tr) / 2;
upd(v * 2, tl, mid, l, r, val);
upd(v * 2 + 1, mid + 1, tr, l, r, val);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
long long pw(long long x, long long y) {
long long ret = 1;
while (y) {
if (y % 2) ret *= x;
x *= x;
y /= 2;
}
return ret;
}
void solve(string v) {
long long x = 0;
vector<long long> arr;
long long sz = 0;
string s = ' ' + v;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == '-') {
x *= -1;
}
if (s[i] == ' ') {
arr.push_back(x);
x = 0;
sz = 0;
}
if (s[i] != ' ' && s[i] != '-') {
if (s[i] == '0') {
sz++;
} else {
x += ((s[i] - 48) * pw(10, sz));
sz++;
}
}
}
if (arr.size() == 2) {
long long l = arr[1], r = arr[0];
if (l > r) {
cout << min(getmin(1, 1, n, 1, r + 1), getmin(1, 1, n, l + 1, n)) << "\n";
} else {
cout << getmin(1, 1, n, l + 1, r + 1) << "\n";
}
}
if (arr.size() == 3) {
long long l = arr[2], r = arr[1], x = arr[0];
if (l > r) {
upd(1, 1, n, l + 1, n, x);
upd(1, 1, n, 1, r + 1, x);
} else {
upd(1, 1, n, l + 1, r + 1, x);
}
}
arr.clear();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
build(1, 1, n);
long long M;
cin >> M;
string num;
getline(cin, num);
for (int i = 1; i <= M; i++) {
getline(cin, num);
solve(num);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int a1, b1, c1, a2, b2, c2;
cin >> a1 >> b1 >> c1 >> a2 >> b2 >> c2;
if ((a1 == 0 and b1 == 0 and c1 != 0) or (a2 == 0 and b2 == 0 and c2 != 0)) {
cout << "0";
return 0;
}
if ((a1 * b2) != (a2 * b1)) {
cout << "1";
return 0;
}
if ((a1 * b2) == (a2 * b1)) {
if (a1 == 0 and a2 == 0) {
if ((b1 * c2) == (b2 * c1)) {
cout << "-1";
}
if ((b1 * c2) != (b2 * c1)) {
cout << "0";
}
} else {
if ((a1 * c2) == (a2 * c1)) {
cout << "-1";
}
if ((a1 * c2) != (a2 * c1)) {
cout << "0";
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, x;
cin >> t;
while (t--) {
cin >> x;
long long a = 1, b = 1, c = 1;
while (a <= x) {
b += pow(2, c);
a += (b * b) - ((b * (b - 1)) / 2);
c++;
}
cout << c - 1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void answer() {
int n, s, c = 0, d = 0;
cin >> n >> s;
if (n >= s) {
cout << 1;
return;
}
c = s / n;
d = s % n;
if (d == 0) {
cout << c;
return;
}
(d <= n) ? cout << c + 1 : cout << c + d;
}
int32_t main() {
int t;
t = 1;
while (t--) {
answer();
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
set<int> adj[MAX];
int n, m;
int dfs(int source) {
vector<int> unpaired;
while (!adj[source].empty()) {
int each = *adj[source].begin();
adj[source].erase(each);
adj[each].erase(source);
int u = dfs(each);
if (u == 0) {
unpaired.push_back(each);
} else {
printf("%d %d %d\n", u, each, source);
}
}
while (unpaired.size() >= 2) {
int u = unpaired.back();
unpaired.pop_back();
int v = unpaired.back();
unpaired.pop_back();
printf("%d %d %d\n", u, source, v);
}
if (!unpaired.empty()) {
return unpaired.back();
}
return 0;
}
int main() {
scanf("%d %d", &n, &m);
if (m & 1) {
puts("No solution");
return 0;
}
for (int i = int(0); i < int(m); i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].insert(v);
adj[v].insert(u);
}
dfs(1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(12);
solve();
return 0;
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void pr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void pr(const Head& head, const Tail&... tail) {
cout << head << ' ';
pr(tail...);
}
const int MAX_SUM = 5e5 + 10;
bool vis[MAX_SUM];
void solve() {
fill(vis, vis + MAX_SUM, false);
int n, d;
sc(n, d);
vector<int> oks;
oks.push_back(0);
for (int i = 0; i < n; i++) {
int x;
sc(x);
for (int j = ((int)oks.size()) - 1; j >= 0; j--) {
if (x + oks[j] < MAX_SUM && !vis[x + oks[j]]) {
oks.push_back(x + oks[j]);
vis[x + oks[j]] = true;
}
}
}
sort(oks.begin(), oks.end());
int ans = 0, cur = 0;
while (true) {
int idx =
upper_bound(oks.begin(), oks.end(), oks[cur] + d) - oks.begin() - 1;
if (idx >= ((int)oks.size()) || idx == cur) {
break;
}
ans++;
cur = idx;
}
pr(oks[cur], ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct T {
int t, k, d, fin;
vector<int> ids;
T(int t, int k, int d) : t(t), k(k), d(d) { fin = t + d - 1; }
T() : T(0, 0, 0) {}
bool operator<(const T &other) const { return fin < other.fin; }
bool operator>(const T &other) const { return fin > other.fin; }
};
int n, q;
vector<T> vv;
int maxT;
int read() {
if (scanf("%d%d", &n, &q) < 2) {
return 0;
}
vv.clear();
int t, d, k;
for (int i = 0; i < q; i++) {
scanf("%d%d%d", &t, &k, &d);
vv.push_back(T(t, k, d));
maxT = t;
}
return 1;
}
priority_queue<T, vector<T>, greater<T> > Q;
int srv[200];
void solve() {
Q = priority_queue<T, vector<T>, greater<T> >();
memset(srv, 0, sizeof srv);
int free = n;
int tt = 0;
int ptr = 0;
while (tt < maxT) {
while (Q.size() > 0 && Q.top().fin == tt) {
if (0)
cout << "Q.top().fin _ Q.top().k _ free"
<< " " << Q.top().fin << " " << Q.top().k << " " << free << endl;
T qtp = Q.top();
free += qtp.k;
for (auto &j : qtp.ids) {
srv[j] = 0;
}
if (0)
cout << "free"
<< " " << free << endl;
assert(free <= n);
Q.pop();
}
tt++;
if (tt == vv[ptr].t) {
int need = vv[ptr].k;
if (Q.size() > 0)
if (0)
cout << "need _ free _ Q.top().t _ Q.top().fin _ tt"
<< " " << need << " " << free << " " << Q.top().t << " "
<< Q.top().fin << " " << tt << endl;
if (need > free) {
printf("-1\n");
} else {
if (vv[ptr].d == 1) {
int kk = vv[ptr].k;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (kk == 0) break;
if (srv[i] == 0) {
ans += i;
kk--;
}
}
printf("%d\n", ans);
} else {
free -= need;
vector<int> ids;
int ans = 0;
int kk = vv[ptr].k;
for (int i = 1; i <= n; i++) {
if (kk == 0) break;
if (srv[i] == 0) {
ans += i;
kk--;
srv[i] = 1;
ids.push_back(i);
}
}
printf("%d\n", ans);
vv[ptr].ids = ids;
if (0)
cout << "ptr"
<< " " << ptr << endl;
Q.push(vv[ptr]);
}
}
ptr++;
}
}
}
int main(int argc, char *argv[]) {
while (read()) {
solve();
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef complex<long double> cd;
const int maxn = 2e5 + 5;
int p[maxn], q[maxn], rp[maxn], rq[maxn];
int n;
int rA[maxn], A[maxn], B[maxn];
void power(int b){
if (b == 0)
return;
power(b / 2);
for (int i = 1; i <= n; i++)
B[i] = A[A[i]];
for (int i = 1; i <= n; i++)
A[i] = B[i];
if (b & 1){
for (int i = 1; i <= n; i++)
B[i] = A[q[rp[rq[p[i]]]]];
for (int i = 1; i <= n; i++)
A[i] = B[i];
}
}
int main(){
ios_base::sync_with_stdio(false);
int k;
cin >> n >> k;
for (int i = 1; i <= n; i++){
cin >> p[i];
rp[p[i]] = i;
}
for (int i = 1; i <= n; i++){
cin >> q[i];
rq[q[i]] = i;
}
for (int i = 1; i <= n; i++)
A[i] = i;
power((k - 1) / 6);
if (k % 6 == 4){
for (int i = 1; i <= n; i++)
B[i] = A[q[i]];
for (int i = 1; i <= n; i++)
A[i] = B[i];
}
if (k % 6 == 5 or k % 6 == 0){
for (int i = 1; i <= n; i++)
B[i] = A[q[rp[i]]];
for (int i = 1; i <= n; i++)
A[i] = B[i];
}
for (int i = 1; i <= n; i++)
rA[A[i]] = i;
k %= 6;
if (k == 1)
for (int i = 1; i <= n; i++)
B[i] = p[i];
else if (k == 2)
for (int i = 1; i <= n; i++)
B[i] = q[i];
else if (k == 3)
for (int i = 1; i <= n; i++)
B[i] = q[rp[i]];
else if (k == 4)
for (int i = 1; i <= n; i++)
B[i] = rp[i];
else if (k == 5)
for (int i = 1; i <= n; i++)
B[i] = rq[i];
else
for (int i = 1; i <= n; i++)
B[i] = rq[p[i]];
for (int i = 1; i <= n; i++)
cout << A[B[rA[i]]] << " ";
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int xcum[1000010];
int n, q;
int v[100000];
int cnt;
int qual;
int used[21 * 50000][2];
int trie[21 * 50000][2];
void add(int x) {
int at = 0;
for (int i = 20; i >= 0; i--) {
int b = ((x & (1 << i)) != 0);
if (used[at][b] != qual) {
used[at][b] = qual;
trie[at][b] = cnt;
cnt++;
}
at = trie[at][b];
}
}
int consulta(int x) {
int ret = 0;
int at = 0;
for (int i = 20; i >= 0; i--) {
int b = ((x & (1 << i)) != 0);
if (used[at][!b] == qual) {
at = trie[at][!b];
ret |= (1 << i);
} else
at = trie[at][b];
}
return ret;
}
pair<int, int> lol[100000];
int resp[100000];
int melhor[100000];
int main() {
for (int i = 1; i < 1000010; i++) xcum[i] = (i ^ xcum[i - 1]);
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", &v[i]);
for (int i = 0; i < q; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
lol[i] = make_pair(a, b);
}
for (int i = 0; i < n; i++) {
melhor[i] = v[i];
for (int j = i + 1; j < n; j++) {
if (v[i] < v[j])
melhor[j] = max(melhor[j - 1], xcum[v[i] - 1] ^ xcum[v[j]]);
else
melhor[j] = max(melhor[j - 1], xcum[v[j] - 1] ^ xcum[v[i]]);
}
for (int j = 0; j < q; j++)
if (lol[j].first <= i) resp[j] = max(resp[j], melhor[lol[j].second]);
}
for (int i = 0; i < q; i++) printf("%d\n", resp[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)2e5 + 100;
int e[maxn][2];
double ed[maxn];
bool restr[maxn];
vector<int> g[maxn];
double w[maxn];
int getOth(int id, int v) { return e[id][0] + e[id][1] - v; }
double getDer(int v, double len = 0., int par = -1) {
double ans = pow(len, 0.5) * w[v];
for (int i = 0; i < (int)g[v].size(); i++) {
int eid = g[v][i];
int nv = getOth(eid, v);
if (nv == par) continue;
ans += getDer(nv, len + ed[eid], v);
}
return ans;
}
double getSum(int v, double len = 0., int par = -1) {
double ans = pow(len, 1.5) * w[v];
for (int i = 0; i < (int)g[v].size(); i++) {
int eid = g[v][i];
int nv = getOth(eid, v);
if (nv == par) continue;
ans += getSum(nv, len + ed[eid], v);
}
return ans;
}
int cnt[maxn];
int getSize(int v, int par = -1) {
cnt[v] = 1;
for (int i = 0; i < (int)g[v].size(); i++) {
int eid = g[v][i];
int nv = getOth(eid, v);
if (nv == par) continue;
if (restr[eid]) continue;
cnt[v] += getSize(nv, v);
}
return cnt[v];
}
int getCentr(int v, int gcnt, int par = -1) {
for (int i = 0; i < (int)g[v].size(); i++) {
int eid = g[v][i];
int nv = getOth(eid, v);
if (nv == par) continue;
if (restr[eid]) continue;
if (cnt[nv] * 2 > gcnt) return getCentr(nv, gcnt, v);
}
return v;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf", &w[i]);
for (int i = 0; i < n - 1; i++) {
int a, b;
double l;
scanf("%d%d%lf", &a, &b, &l);
a--;
b--;
e[i][0] = a;
e[i][1] = b;
ed[i] = l;
g[a].push_back(i);
g[b].push_back(i);
}
int root = 0;
while (true) {
int gcnt = getSize(root);
if (gcnt == 1) break;
root = getCentr(root, gcnt);
double mx = 0;
int mxid = -1;
for (int i = 0; i < (int)g[root].size(); i++) {
int eid = g[root][i];
int nv = getOth(eid, root);
if (restr[eid]) continue;
double cur = getDer(nv, ed[eid], root);
if (cur > mx) {
mx = cur;
mxid = eid;
}
}
if (mxid == -1) break;
42;
int new_root = getOth(mxid, root);
if (getSum(root) <= getSum(new_root)) break;
root = new_root;
restr[mxid] = true;
}
printf("%d %.10lf\n", root + 1, getSum(root));
return 0;
}
| 3 |
#include <iostream>
#include <algorithm>
using namespace std;
int dp[5009][5], n, p[100009];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 0; i <= n; i++) { for (int j = 0; j <= 4; j++) dp[i][j] = (1 << 30); }
dp[0][0] = 0; dp[0][1] = 0; dp[0][2] = 0; dp[0][3] = 0; dp[0][4] = 0;
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= 4; j++) {
// j = 次に絶対裏返さなければならない個数
for (int k = max(j, p[i + 1]); k <= 4; k++) {
int z = k - j;
dp[i + 1][z] = min(dp[i + 1][z], dp[i][j] + k);
}
}
}
int minx = (1 << 30);
for (int i = 0; i <= 4; i++) minx = min(minx, dp[n][i]);
cout << minx << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n;
int a[20];
int maxl = 1;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int flag = 1;
for (int i = n; i > 0; i /= 2) {
for (int j = 0; j < n; j += i) {
flag = 1;
for (int k = 1; k < i; k++) {
if (a[j + k] < a[j + k - 1]) {
flag = 0;
break;
}
}
if (flag) {
maxl = i;
break;
}
}
if (flag) break;
}
printf("%d\n", maxl);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, M = 5e9 + 10, mod = 1e9 + 7, inf = 1e18;
long long n, a[N], i;
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
long long x = a[i];
while (!v.empty() && v.back() == x) {
v.pop_back();
x++;
}
v.push_back(x);
}
cout << v.size() << "\n";
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5+7;
void dfs(int now,int n,string ans,int k){
if(now == n){
cout << ans << "\n";
return ;
}
for(int i = 0;i <= k;++i) dfs(now+1,n,ans+(char)('a'+i),max(k,i+1));
return ;
}
int main() {
int n;
cin >> n;
dfs(0,n,"",0);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,maxn,ans = 0;
cin >> n >> maxn;
while(n--){
int t;
cin >> t;
if(t >= maxn) ans++;
}
cout << ans << endl;
} | 0 |
#include"bits/stdc++.h"
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define int long long
constexpr long long mod = 1000000007;
typedef pair<int, int> P;
int res;
int fib[90];
int fi2[90][90];
int gcd(int a, int b) {
if (a < b)swap(a, b);
if (!b)return 0;
if (a / b > 1&&b>1)res++;
if (b == 1 && a > 2)res++;
return 1+gcd(b, a%b);
}
signed main() {
int q; cin >> q;
fib[0]=fib[1] = 1;
rep(i, 88)fib[i+2]=fib[i + 1] + fib[i];
for(int i=0;i<90;i++) {
fi2[i][0] = fi2[i][1] = 1;
for (int j = 1; j <= 88; j++) {
if (i == j)fi2[i][j + 1] = fi2[i][j] * 2 + fi2[i][j - 1];
else fi2[i][j + 1] = fi2[i][j] + fi2[i][j - 1];
}
}
//f[87]で10^18を超える
rep(i, q) {
int x, y; cin >> x >> y;
if (x > y)swap(x, y);
if (P(x, y) == P(1, 1)) {
puts("1 1"); continue;
}
int K = 0;
rep(i, 88) {
if (fib[i] <= x&&fib[i + 1] <= y)K = i;
}
if (K == 1) {
cout <<K<<' '<< x*y%mod << endl;
continue;
}
int ans = 0;
int d = y - fib[K + 1];
d /= fib[K]; d++;
ans += d;
if (x >= fib[K + 1]) {
d = x - fib[K + 1];
d /= fib[K]; d++;
ans += d;
}
for (int i = 1; i < K; i++) {
if (fi2[i][K] <= x&&fi2[i][K + 1] <= y) {
d = y - fi2[i][K + 1];
d /= fi2[i][K]; d++;
ans += d;
ans %= mod;
if (fi2[i][K + 1] <= x) {
d = x - fi2[i][K + 1];
d /= fi2[i][K]; d++;
ans += d;
ans %= mod;
}
}
}
cout <<K<<' '<< ans%mod << endl;
}
} | 0 |
#include <bits/stdc++.h>
int main() {
int n, k, s = 0;
scanf("%d %d", &n, &k);
s = n % k;
printf("%d", n + k - s);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int mn=105;
int p,pos[205],x,n;
int main()
{
scanf("%d%d",&x,&n);
for(int i=1;i<=n;++i) {scanf("%d",&p);pos[p+100]=1;}
int tmp=200,ans=0;
for(int i=-10;i<=101;++i) {
if(pos[i+100]) continue;
if(tmp>abs(x-i)) tmp=abs(x-i),ans=i;
}
cout<<ans;
} | 0 |
#include <bits/stdc++.h>
int main() {
int ch, min, a;
scanf("%d:%d%d", &ch, &min, &a);
a += ch * 60 + min;
printf("%.2d:%.2d\n", a / 60 % 24, a % 60);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> v, v1;
void solve() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x) {
v.push_back(x);
} else {
v1 = v;
sort((v).begin(), (v).end());
reverse((v).begin(), (v).end());
int flag[3];
memset(flag, 0, sizeof(flag));
for (int i = 0; i <= (int)v1.size() - 1; i++) {
if (v1[i] == v[0] and !flag[0]) {
puts("pushStack");
flag[0] = 1;
} else if (v1[i] == v[1] and !flag[1]) {
puts("pushQueue");
flag[1] = 1;
} else if (v1[i] == v[2] and !flag[2]) {
puts("pushFront");
flag[2] = 1;
} else {
puts("pushBack");
}
}
if (!(int)v.size()) {
puts("0");
}
if ((int)v.size() == 1) {
puts("1 popStack");
}
if ((int)v.size() == 2) {
puts("2 popStack popQueue");
}
if ((int)v.size() > 2) {
puts("3 popStack popQueue popFront");
}
v.clear();
v1.clear();
}
}
if ((int)v.size()) {
for (int i = 0; i <= (int)v.size() - 1; i++) {
puts("pushStack");
}
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 5000;
vector<int> g[N];
int deg[N];
const int inf = 1e9 + 5;
bool graph[N][N];
int solve(int x) {
int i, j;
int l = g[x].size();
int res = inf;
for (i = 0; i < l; i++) {
int w = g[x][i];
int l2 = g[w].size();
for (j = 0; j < l2; j++) {
int v = g[w][j];
if (graph[v][x]) res = min(res, deg[w] + deg[v] + deg[x] - 6);
}
}
return res;
}
pair<int, int> edges[N];
int A[5], b[5];
int main() {
ios_base::sync_with_stdio(false);
int n, t, m, l, k, ans, i, j, res = 0, fl;
t = 1;
while (t--) {
cin >> n >> m;
int x, y;
for (i = 0; i < m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
edges[i] = make_pair(x, y);
deg[x]++;
deg[y]++;
graph[x][y] = graph[y][x] = 1;
}
res = inf;
for (i = 0; i < m; i++) {
for (j = i + 1; j < m; ++j) {
A[0] = edges[i].first;
A[1] = edges[i].second;
A[2] = edges[j].first;
A[3] = edges[j].second;
sort(A, A + 4);
for (k = 1; k <= 3; k++) {
if (A[k] == A[k - 1]) break;
}
if (k == 4)
continue;
else {
int mid = A[k];
int ct = 0;
for (k = 0; k < 4; k++) {
if (A[k] != mid) b[ct++] = A[k];
}
int x = b[0];
int y = b[1];
if (graph[x][y]) res = min(res, deg[x] + deg[y] + deg[mid] - 6);
}
}
}
if (res == inf) res = -1;
cout << res << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int sum, N;
cin >> sum >> N;
vector<int> A(N);
for(int i = 0; i < N; i++)cin >> A[i];
sort(A.begin(), A.end(), greater<int>());
int ans = max((A[0] - 1) - (sum - A[0]), 0);
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = (1 << 22);
int dP[maxN], a[maxN], n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 0; i < (1 << 22); ++i) dP[i] = -1;
for (int i = 1; i <= n; ++i) dP[a[i]] = a[i];
for (int i = 0; i < 22; ++i)
for (int mask = 0; mask < (1 << 22); ++mask)
if ((mask & (1 << i)) && (dP[mask ^ (1 << i)] != -1))
dP[mask] = dP[mask ^ (1 << i)];
for (int i = 1; i <= n; ++i) cout << dP[(1 << 22) - 1 - a[i]] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int main() {
int h1, a1, c1, h2, a2;
cin >> h1 >> a1 >> c1 >> h2 >> a2;
vector<int> v;
while (1) {
if (h2 <= 0) break;
if (h1 <= a2 && a1 < h2) {
v.push_back(0);
h1 += c1;
h1 -= a2;
continue;
} else {
v.push_back(1);
h2 -= a1;
if (h2 <= 0) break;
h1 -= a2;
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
if (v[i] == 1)
cout << "STRIKE\n";
else
cout << "HEAL\n";
}
return 0;
}
| 2 |
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef complex<double> P;
const int H = 9;
const int W = 9;
int main() {
int T; cin >>T;
bool ff = false;
REP(t, T){
if(ff) cout <<endl; ff = true;
int v[H][W];
REP(i, H) REP(j, W) cin >>v[i][j];
bool f[H][W];
memset(f, 0, sizeof(f));
REP(i, H) REP(j, W) FOR(k, j + 1, W) if(v[i][j] == v[i][k]) f[i][j] = f[i][k] = true;
REP(i, W) REP(j, H) FOR(k, j + 1, H) if(v[j][i] == v[k][i]) f[j][i] = f[k][i] = true;
REP(i, 9){
int y = (i / 3) * 3, x = (i % 3) * 3;
REP(a, 3) REP(b, 3) REP(c, 3) REP(d, 3) if(a != c && b != d && v[a + y][b + x] == v[c + y][d + x]) f[a + y][b + x] = f[c + y][d + x] = true;
}
REP(i, H){
REP(j, W) cout <<(f[i][j] ? "*" : " ") <<v[i][j];
cout <<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 2e5 + 5, mx = 1e9, LN = 20, mod = 1e9 + 7;
int ans;
int n, m;
vector<string> v;
bool checkRow(int idx) {
for (int i = 0; i < m; i++)
if (v[idx][i] == 'P') return false;
return true;
}
bool checkCol(int idx) {
for (int i = 0; i < n; i++)
if (v[i][idx] == 'P') return false;
return true;
}
bool checkCorners() {
if (v[0][0] == 'A' or v[0][m - 1] == 'A' or v[n - 1][0] == 'A' or
v[n - 1][m - 1] == 'A')
return true;
return false;
}
bool anyRow(int idx) {
for (int i = 0; i < m; i++)
if (v[idx][i] == 'A') return true;
return false;
}
bool anyCol(int idx) {
for (int i = 0; i < n; i++)
if (v[i][idx] == 'A') return true;
return false;
}
int solve() {
cin >> n >> m;
v.clear();
v.resize(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int cells = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (v[i][j] == 'A') ++cells;
if (cells == 0) return -1;
if (cells == n * m) return 0;
if (checkRow(0) or checkRow(n - 1) or checkCol(0) or checkCol(m - 1))
return 1;
for (int i = 0; i < n; i++)
if (checkRow(i)) return 2;
for (int i = 0; i < m; i++)
if (checkCol(i)) return 2;
if (checkCorners()) return 2;
if (anyRow(0) or anyRow(n - 1) or anyCol(0) or anyCol(m - 1)) return 3;
return 4;
}
int main() {
int tests;
cin >> tests;
for (int i = 0; i < tests; i++) {
int res = solve();
if (res == -1)
cout << "MORTAL" << endl;
else
cout << res << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int f1[maxn], f2[maxn];
int find1(int a) {
if (a != f1[a]) {
a = f1[a] = find1(f1[a]);
}
return a;
}
int find2(int a) {
if (a != f2[a]) {
a = f2[a] = find2(f2[a]);
}
return a;
}
int main() {
int n, m1, m2;
cin >> n >> m1 >> m2;
for (int i = 0; i <= n; i++) {
f1[i] = f2[i] = i;
}
for (int i = 0; i < m1; i++) {
int a, b;
cin >> a >> b;
f1[find1(b)] = find1(a);
}
for (int i = 0; i < m2; i++) {
int a, b;
cin >> a >> b;
f2[find2(b)] = find2(a);
}
int cnt = 0;
int x[maxn];
int y[maxn];
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int a = find1(i);
int b = find1(j);
if (a != b) {
int a2 = find2(i);
int b2 = find2(j);
if (a2 != b2) {
f1[b] = a;
f2[b2] = a2;
x[cnt] = i;
y[cnt] = j;
cnt++;
}
}
}
}
cout << cnt << endl;
for (int i = 0; i < cnt; i++) {
cout << x[i] << " " << y[i] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline long long squ(T x) {
return (long long)x * x;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T read() {
T sum = 0, fg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') fg = -1;
for (; isdigit(c); c = getchar()) sum = (sum << 3) + (sum << 1) + (c ^ 0x30);
return fg * sum;
}
const int maxn = 3e3 + 10;
const int mod = 998244353;
inline void Add(int &x, int y) { x += y, (x >= mod ? x -= mod : 0); }
char S[maxn], T[maxn];
int n, m, dp[maxn][maxn];
int main() {
scanf("%s%s", S + 1, T + 1);
n = strlen(S + 1), m = strlen(T + 1);
for (int i = 1; i <= n; i++) dp[i][i] = ((T[i] == S[1]) || (i > m) ? 1 : 0);
for (int i = n; i >= 1; i--)
for (int j = i; j <= n; j++) {
if (i > 1 && (S[j - i + 2] == T[i - 1] || i - 1 > m))
Add(dp[i - 1][j], dp[i][j]);
if (j < n && (S[j - i + 2] == T[j + 1] || j + 1 > m))
Add(dp[i][j + 1], dp[i][j]);
}
int ans = 0;
for (int i = m; i <= n; i++) Add(ans, dp[1][i]);
cout << 2LL * ans % mod << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[300000 + 100][10];
pair<long long, long long> dp[300];
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 1; i < n + 1; i++) {
for (long long j = 0; j < m; j++) cin >> a[i][j];
for (long long mask = 0; mask < (1 << m); mask++) {
long long mn = 1000000000000000000;
for (long long k = 0; k < m; k++) {
if (mask & (1 << k)) {
mn = min(mn, a[i][k]);
}
}
if (dp[mask].first <= mn) {
dp[mask] = {mn, i};
}
}
}
long long ans = 0, ind1, ind2;
for (long long mask = 0; mask < 1 << m; mask++) {
long long rev = 0;
for (long long j = 0; j < m; j++)
if (!(mask & (1 << j))) rev += (1 << j);
if (min(dp[mask].first, dp[rev].first) >= ans) {
ans = min(dp[mask].first, dp[rev].first);
ind1 = dp[mask].second;
ind2 = dp[rev].second;
}
}
cout << ind1 << " " << ind2;
}
| 4 |
#include<bits/stdc++.h>
typedef long long lnt;
using namespace std;
lnt n,a,b,c,d,l,r;
inline bool range(lnt v,lnt x,lnt y){
return v>=x&&v<=y;
}
signed main(){
cin>>n>>a>>b>>c>>d;--n;
for(int i=0;i<=n;++i){
l=-i*d+(n-i)*c;
r=-i*c+(n-i)*d;
if(range(b-a,l,r))
return puts("YES"),0;
}
return puts("NO"),0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
int main(){
string s;
cin>>s;
reverse(s.begin(),s.end());
while (s.size()!=0){
if (s.substr(0,5)=="maerd" or s.substr(0,5)=="esare") s.erase(0,5);
else if (s.substr(0,6)=="resare") s.erase(0,6);
else if (s.substr(0,7)=="remaerd") s.erase(0,7);
else break;
}
if (s.size()==0) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n, k, x = 0;
string s;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> s;
for (char ch = 'a'; ch <= 'z'; ch++) {
long long curx = 0;
for (long long i = 0; i < n; i++) {
if (s[i] != ch) continue;
long long j = i, len = 1;
while (j + 1 < n && s[j + 1] == ch && len < k) {
len++;
j++;
}
if (len == k) curx++;
i = j;
}
x = max(x, curx);
}
cout << x;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int data[26][4 * N], flag[26][4 * N], n, q;
string s;
void shift(int ch, int node, int st, int en) {
if (flag[ch][node] == -1) return;
int mid = (st + en) / 2;
flag[ch][node * 2 + 0] = flag[ch][node];
flag[ch][node * 2 + 1] = flag[ch][node];
data[ch][node * 2 + 0] = (mid - st) * flag[ch][node];
data[ch][node * 2 + 1] = (en - mid) * flag[ch][node];
flag[ch][node] = -1;
}
void change(int ch, int node, int st, int en, int l, int r, int val) {
if (en <= l or r <= st) return;
if (l <= st and en <= r) {
data[ch][node] = (en - st) * val;
flag[ch][node] = val;
return;
}
int mid = (st + en) / 2;
shift(ch, node, st, en);
change(ch, node * 2 + 0, st, mid, l, r, val);
change(ch, node * 2 + 1, mid, en, l, r, val);
data[ch][node] = data[ch][node * 2] + data[ch][node * 2 + 1];
}
int get(int ch, int node, int st, int en, int l, int r) {
if (en <= l or r <= st) return 0;
if (l <= st and en <= r) return data[ch][node];
int mid = (st + en) / 2;
shift(ch, node, st, en);
return get(ch, node * 2 + 0, st, mid, l, r) +
get(ch, node * 2 + 1, mid, en, l, r);
}
int main() {
for (int i = 0; i < N; ++i)
for (int j = 0; j < 26; ++j) flag[j][i] = -1;
cin >> n >> q >> s;
for (int i = 0; i < n; ++i) change((int)(s[i] - 'a'), 1, 0, n, i, i + 1, 1);
int type, l, r, now, cnt;
for (int i = 0; i < q; ++i) {
scanf("%d%d%d", &l, &r, &type);
l--;
now = l;
if (type == 0)
for (int j = 25; j > -1; --j) {
cnt = get(j, 1, 0, n, l, r);
change(j, 1, 0, n, l, r, 0);
change(j, 1, 0, n, now, now + cnt, 1);
now += cnt;
}
if (type == 1)
for (int j = 0; j < 26; ++j) {
cnt = get(j, 1, 0, n, l, r);
change(j, 1, 0, n, l, r, 0);
change(j, 1, 0, n, now, now + cnt, 1);
now += cnt;
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < 26; ++j)
if (get(j, 1, 0, n, i, i + 1) > 0) cout << (char)(j + 'a');
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c, tr, tc;
double dp[2010][2010];
bool row[2010], col[2010];
int main() {
while (cin >> n >> m) {
memset(row, false, sizeof(row));
memset(col, false, sizeof(col));
tr = tc = 0;
for (int i = 1; i <= m; (i)++) {
cin >> r >> c;
if (!row[r]) {
tr++;
row[r] = true;
}
if (!col[c]) {
tc++;
col[c] = true;
}
}
tr = n - tr, tc = n - tc;
for (int i = 1; i <= tr; (i)++) {
dp[i][0] = (n + i * dp[i - 1][0]) / i;
}
for (int j = 1; j <= tc; (j)++) {
dp[0][j] = (n + j * dp[0][j - 1]) / j;
}
for (int i = 1; i <= tr; (i)++)
for (int j = 1; j <= tc; (j)++) {
dp[i][j] = (n * n + i * j * dp[i - 1][j - 1] +
i * (n - j) * dp[i - 1][j] + (n - i) * j * dp[i][j - 1]) /
((i + j) * n - i * j);
}
cout << fixed << setprecision(6) << dp[tr][tc] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110;
int n, m;
string mp[MAXN];
char getCurChar(int x, int y) {
bool can[4];
memset(can, true, sizeof(can));
if (x > 0) can[mp[x - 1][y] - 'A'] = false;
if (y > 0) can[mp[x][y - 1] - 'A'] = false;
if (y < m && mp[x][y + 1] != '*') can[mp[x][y + 1] - 'A'] = false;
for (int i = 0; i < 4; i++)
if (can[i]) return 'A' + i;
return '?';
}
void fillTable(int x, int y, int n, int m) {
if (x > n || y > m) return;
char ch = getCurChar(x, y);
char ch2 = getCurChar(x, y + 1);
int d1 = n - x + 1, d2 = m - y + 1;
int d = min(d1, d2);
if (ch != ch2) {
mp[x][y] = ch;
if (y == m) {
fillTable(x + 1, y, n, m);
return;
}
d2--;
if (d1 == d2) {
fillTable(x, y + 1, n, m);
if (d1 != 1) fillTable(x + 1, y, n, y);
} else if (d1 < d2) {
fillTable(x, y + 1, n, y + d1);
if (d1 != 1) fillTable(x + 1, y, n, y);
fillTable(x, y + d1 + 1, n, m);
} else {
fillTable(x, y + 1, x + d2 - 1, m);
if (d2 != 1) fillTable(x + 1, y, x + d2 - 1, y);
fillTable(x + d2, y, n, m);
}
return;
}
for (int i = x; i < d + x; i++)
for (int j = y; j < d + y; j++) mp[i][j] = ch;
if (d1 == d2) return;
if (d1 < d2)
fillTable(x, y + d, n, m);
else {
fillTable(x + d, y, n, m);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) mp[i] = mp[i] + "*";
}
fillTable(0, 0, n - 1, m - 1);
for (int i = 0; i < n; i++) cout << mp[i] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
unsigned long long a, b, x;
std::cin >> a >> b;
a < b | a - b & 1
? std::cout << -1
: (x = (a - b) / 2, a -= x,
x ^ a ^ b ? std::cout << -1 : std::cout << x << ' ' << a);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 610;
const int M = 5e5 + 10;
const int INF = 0x3f3f3f3f;
int mx[N][N << 2], f[M][105], pr[M], c[N], n, k, p;
int lowbit(int x) { return x & -x; }
void update(int x, int val) {
for (; x <= p; x += lowbit(x)) c[x] = max(c[x], val);
}
int get_max(int x) {
int ans = 0;
for (; x; x -= lowbit(x)) ans = max(ans, c[x]);
return ans;
}
void update(int l, int r, int x, int val, int rt, int id) {
if (l == r) {
mx[id][rt] = min(mx[id][rt], val);
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(l, mid, x, val, (rt << 1), id);
else
update(mid + 1, r, x, val, (rt << 1 | 1), id);
mx[id][rt] = min(mx[id][(rt << 1)], mx[id][(rt << 1 | 1)]);
}
int query(int l, int r, int L, int R, int rt, int id) {
if (L <= l && r <= R) return mx[id][rt];
int mid = l + r >> 1, ans = INF;
if (L <= mid) ans = min(ans, query(l, mid, L, R, (rt << 1), id));
if (mid < R) ans = min(ans, query(mid + 1, r, L, R, (rt << 1 | 1), id));
return ans;
}
int main() {
scanf("%d %d %d", &n, &k, &p);
if (n <= k * p) {
memset(mx, 0x3f, sizeof mx);
update(1, p, 1, -1, 1, 0);
for (int i = 1; i <= n; i++)
scanf("%d", &pr[i]), pr[i] = (pr[i - 1] + pr[i]) % p;
for (int i = 1; i <= n; i++) {
for (int j = k; j >= 1; j--) {
int now = pr[i] + 1;
f[i][j] = min(now + query(1, p, 1, now, 1, j - 1),
now + query(1, p, now + 1, p, 1, j - 1) + p);
update(1, p, now, f[i][j] - now, 1, j);
}
}
printf("%d\n", f[n][k]);
} else {
for (int i = 1; i <= n; i++)
scanf("%d", &pr[i]), pr[i] = (pr[i - 1] + pr[i]) % p;
for (int i = 1; i < n; i++) {
pr[i]++;
int res = get_max(pr[i]) + 1;
update(pr[i], res);
}
if (get_max(pr[n]) + 1 >= k)
printf("%d\n", pr[n]);
else
printf("%d\n", pr[n] + p);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
long long tree[1 << 19], lazy[1 << 19];
vector<int> a;
void build(int i, int l, int r) {
lazy[i] = -1;
if (l == r) {
tree[i] = a[l];
return;
}
int mid = (l + r) / 2;
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
tree[i] = tree[i * 2] + tree[i * 2 + 1];
}
void propagate(int i, int l, int r) {
if (lazy[i] == -1) return;
tree[i] = lazy[i];
if (l != r) lazy[i * 2] = lazy[i * 2 + 1] = lazy[i];
lazy[i] = -1;
}
void update(int i, int l, int r, int a, int b, int v) {
if (lazy[i] != -1) propagate(i, l, r);
if (a > r || b < l) return;
if (l >= a && r <= b) {
lazy[i] = v;
propagate(i, l, r);
return;
}
int mid = (l + r) / 2;
update(i * 2, l, mid, a, b, v);
update(i * 2 + 1, mid + 1, r, a, b, v);
tree[i] = tree[i * 2] + tree[i * 2 + 1];
}
long long getsum(int i, int l, int r, int ql, int qr) {
propagate(i, l, r);
if (ql > r || qr < l) return 0;
if (l >= ql && r <= qr) return tree[i];
int mid = (l + r) / 2;
return getsum(i * 2, l, mid, ql, qr) + getsum(i * 2 + 1, mid + 1, r, ql, qr);
}
vector<vector<int> > v(100050);
int main() {
long long ans = 0;
int x, n;
cin >> n;
a.resize(n, 0);
for (int i = 0; i < n; i++) cin >> x, v[x].push_back(i);
build(1, 0, n - 1);
int pos = 0;
for (int i = 0; i < 100050; i++) {
if (!v[i].size()) continue;
int now = lower_bound(v[i].begin(), v[i].end(), pos) - v[i].begin();
if (now >= v[i].size()) now = 0;
for (int j = 0, k = now; j < v[i].size(); j++, k = (k + 1) % v[i].size()) {
int kk = v[i][k];
if (kk >= pos)
ans += kk - pos - getsum(1, 0, n - 1, pos, kk);
else
ans += (n - pos) + kk - getsum(1, 0, n - 1, 0, kk) -
getsum(1, 0, n - 1, pos, n - 1);
pos = kk;
update(1, 0, n - 1, pos, pos, 1);
}
}
cout << ans + n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int b = 233;
const int N = 1e5 + 50;
const int mod = 1e9 + 9;
char s[N];
int n, m, opt, k, l, r;
long long Pow[N], Pow2[N];
struct Kano {
int l, r, lazy;
long long h;
} kano[N * 4];
void pushup(int x) {
kano[x].h =
((kano[x << 1].h * Pow[kano[x << 1 | 1].r - kano[x << 1 | 1].l + 1] +
kano[x << 1 | 1].h) %
mod +
mod) %
mod;
}
void pushdown(int x) {
if (kano[x].lazy + 1) {
kano[x << 1].lazy = kano[x << 1 | 1].lazy = kano[x].lazy;
kano[x << 1].h = Pow2[kano[x << 1].r - kano[x << 1].l] * kano[x].lazy % mod;
kano[x << 1 | 1].h =
Pow2[kano[x << 1 | 1].r - kano[x << 1 | 1].l] * kano[x].lazy % mod;
kano[x].lazy = -1;
}
return;
}
void build(int x, int l, int r) {
kano[x].l = l;
kano[x].r = r;
kano[x].lazy = -1;
if (l == r) {
kano[x].h = s[l] - '0' + 1;
return;
}
int mid = (kano[x].l + kano[x].r) >> 1;
build(x << 1, l, mid), build(x << 1 | 1, mid + 1, r);
pushup(x);
}
void add(int x, int l, int r, int a) {
if (kano[x].l == l && kano[x].r == r) {
kano[x].lazy = a;
kano[x].h = Pow2[kano[x].r - kano[x].l] * a % mod;
return;
}
pushdown(x);
int mid = (kano[x].l + kano[x].r) >> 1;
if (mid >= r)
add(x << 1, l, r, a);
else if (mid < l)
add(x << 1 | 1, l, r, a);
else
add(x << 1, l, mid, a), add(x << 1 | 1, mid + 1, r, a);
pushup(x);
}
long long query(int x, int l, int r) {
if (l > r) return 0;
if (kano[x].l == l && kano[x].r == r) return kano[x].h;
pushdown(x);
int mid = (kano[x].l + kano[x].r) >> 1;
if (mid >= r)
return query(x << 1, l, r);
else if (mid < l)
return query(x << 1 | 1, l, r);
else
return (query(x << 1, l, mid) * Pow[r - mid] +
query(x << 1 | 1, mid + 1, r)) %
mod;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
m += k;
scanf("%s", s + 1);
Pow[0] = Pow2[0] = 1;
for (int i = 1; i <= n; i++)
Pow[i] = Pow[i - 1] * b % mod, Pow2[i] = (Pow2[i - 1] * b + 1) % mod;
build(1, 1, n);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &opt, &l, &r, &k);
if (opt == 1)
add(1, l, r, k + 1);
else
printf("%s\n", query(1, l, r - k) == query(1, l + k, r) ? "YES" : "NO");
}
}
| 5 |
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
int ans;
vector<int> ansv;
vector<vector<int> > v;
void dfs(int prev, int next, int a, vector<int> vi, set<pair<int,int> > s){
if(v[prev][next] == -1 || s.find(pair<int,int>(prev,next)) != s.end()) return;
vi.push_back(next);
s.insert(pair<int,int>(prev,next));
s.insert(pair<int,int>(next,prev));
a += v[prev][next];
if(ans < a){
ans = a;
ansv = vi;
}
for(int i=0;i<v.size();i++) dfs(next,i,a,vi,s);
}
int main(){
int n,m;
while(cin >> n >> m && n && m){
ans = 0;
ansv.clear();
v.assign(n,vector<int>(n,-1));
for(int i=0;i<m;i++){
int a,b;
cin >> a >> b;
a--;
b--;
cin >> v[a][b];
v[b][a] = v[a][b];
}
for(int i=0;i<n;i++){
vector<int>vi;
set<pair<int,int> > s;
vi.push_back(i);
for(int j=0;j<n;j++) dfs(i,j,0,vi,s);
}
cout << ans << endl;
cout << ansv[0] + 1;
for(int i=1;i<ansv.size();i++) cout << " " << ansv[i] + 1;
cout << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b = 1, x = 0;
cin >> a;
a--;
for (int k = 1; k <= a; k++) {
x += 2;
b += 6 * x;
}
cout << b;
return 0;
}
| 2 |
#include <bits/stdc++.h>
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &xs) {
for (auto &x : xs) is >> x;
return is;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &xs) {
for (auto it = xs.begin(); it != xs.end(); ++it) {
os << "[ "[it != xs.begin()] << *it << ",]"[it == --xs.end()];
}
return os;
}
auto common(const std::set<int> &lhs, const std::set<int> &rhs) -> int {
for (auto x : lhs) {
if (rhs.count(x) != 0) {
return x;
}
}
return -1;
}
using Graph = std::vector<std::set<int>>;
struct BFS {
const Graph &graph;
std::vector<int> times;
BFS(const Graph &graph) : graph(graph), times(graph.size(), -1) {}
void fill(int root) {
times = std::vector<int>(graph.size(), -1);
times[root] = 0;
std::queue<int> queue;
queue.push(root);
for (; !queue.empty(); queue.pop()) {
auto v = queue.front();
for (auto u : graph[v]) {
if (times[u] != -1) continue;
times[u] = times[v] + 1;
queue.push(u);
}
}
}
};
auto main() -> int {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
std::cin >> n;
std::vector<int64_t> xs(n);
std::cin >> xs;
std::vector<std::set<int>> by_bits(60, std::set<int>{});
for (int64_t i = 0, bit = 1; i < 60; ++i, bit <<= 1) {
for (int j = 0; j < n; ++j) {
if (bit & xs[j]) {
by_bits[i].insert(j);
}
}
}
for (auto &lvl : by_bits) {
if (lvl.size() >= 3) {
std::cout << 3 << '\n';
return 0;
}
if (lvl.size() == 1) {
lvl = {};
}
}
auto graph = Graph(n);
for (int i = 0; i < 60; ++i)
for (int j = i + 1; j < 60; ++j) {
if (by_bits[i] == by_bits[j]) {
by_bits[j] = {};
}
}
for (auto &lvl : by_bits) {
for (auto x : lvl)
for (auto y : lvl)
if (x < y) {
graph[x].insert(y);
graph[y].insert(x);
}
}
auto upd = [](int &x, int value) {
if (x == -1) x = value;
x = std::min(x, value);
};
int answer = -1;
for (int v = 0; v < n; ++v) {
auto links = graph[v];
for (auto u : links) {
graph[v].erase(u);
auto bfs = BFS(graph);
bfs.fill(v);
if (bfs.times[u] != -1) {
upd(answer, 1 + bfs.times[u]);
}
graph[v].insert(u);
}
}
std::cout << answer << '\n';
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main()
{
int t,n,x;
cin>>t;
while(t--)
{
cin>>n;
x=2*n;
int odd=0;
int a;
for(int i=0;i<x;i++){
cin>>a;
if(a%2==1)
odd++;
}
if(odd==n)
{
cout<<"YES"<<endl;
}
else{
cout<<"NO"<<endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int> > cn(long long int n, long long int m) {
return vector<vector<long long int> >(n, vector<long long int>(m));
}
bool compare(char &s1, char &s2) { return s1 > s2; }
bool sortmahstyle(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.second > b.second) return true;
if (a.second == b.second && a.first > b.second) return true;
return false;
}
long long int const mod = 1e9 + 7;
long long int const inf = 1e5 + 1;
void solve() {
long long int n;
cin >> n;
string A, B;
cin >> A >> B;
vector<long long int> ans;
long long int cnt = (A[0] == '1') ? 1 : 0;
for (long long int i = 0; i < n - 1; i++) {
cnt = (A[i + 1] == '1') ? 1 : 0;
if (A[i] == A[i + 1]) continue;
ans.push_back(i + 1);
}
if (cnt == 1) ans.push_back(n);
cnt = 0;
for (long long int i = n - 1; i >= 0; i--) {
long long int state = (B[i] == '1') ? 1 : 0;
if (state == cnt) continue;
ans.push_back(i + 1);
cnt ^= 1;
}
cout << ans.size() << " ";
for (auto e : ans) cout << e << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t-- > 0) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool g[7][7];
int N;
int A[100];
int B[100];
int uc[7];
set<pair<int, int> > forb;
int used[100007];
int was[100007];
int AA[100007];
int BB[100007];
int p[100007];
set<pair<int, int> > forb0;
void solveSmall() {
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
g[a - 1][b - 1] = g[b - 1][a - 1] = true;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
A[N] = i;
B[N] = j;
N++;
}
if (N > 21) throw 1;
for (int mask = 0; mask < (1 << N); mask++) {
memset(uc, 0, sizeof(uc));
int cnt = 0;
for (int i = 0; i < N; i++)
if ((mask >> i) & 1) {
int a = A[i];
int b = B[i];
if (g[a][b]) goto nxt;
if (++uc[a] > 2) goto nxt;
if (++uc[b] > 2) goto nxt;
cnt++;
}
if (cnt == m) {
for (int i = 0; i < N; i++)
if ((mask >> i) & 1) {
int a = A[i];
int b = B[i];
printf("%d %d\n", a + 1, b + 1);
}
return;
}
nxt:;
}
puts("-1");
}
void solveLarge() {
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
was[a - 1]++;
was[b - 1]++;
if (a > b) swap(a, b);
forb0.insert(make_pair(a - 1, b - 1));
}
for (int i = 0; i < n; i++) p[i] = i;
while (1) {
forb = forb0;
memset(used, 0, sizeof(used));
srand(time(0));
random_shuffle(p, p + n);
int M = 0;
for (int I = 0; I < n; I++) {
int i = p[I];
if (used[i] == 2) continue;
if (was[i] < 2) continue;
for (int J = I + 1; J < n; J++) {
int j = p[J];
if (used[j] == 2) continue;
if (was[j] < 2) continue;
pair<int, int> p = make_pair(i, j);
if (p.first > p.second) swap(p.first, p.second);
if (forb.find(p) != forb.end()) continue;
used[i]++;
used[j]++;
AA[M] = i;
BB[M++] = j;
forb.insert(p);
if (M == m) {
for (int k = 0; k < M; k++) printf("%d %d\n", AA[k] + 1, BB[k] + 1);
return;
}
if (used[i] == 2) break;
}
}
for (int I = 0; I < n; I++) {
int i = p[I];
if (used[i] == 2) continue;
for (int J = I + 1; J < n; J++) {
int j = p[J];
if (used[j] == 2) continue;
pair<int, int> p = make_pair(i, j);
if (p.first > p.second) swap(p.first, p.second);
if (forb.find(p) != forb.end()) continue;
used[i]++;
used[j]++;
AA[M] = i;
BB[M++] = j;
forb.insert(p);
if (M == m) {
for (int k = 0; k < M; k++) printf("%d %d\n", AA[k] + 1, BB[k] + 1);
return;
}
if (used[i] == 2) break;
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
if (n <= 7)
solveSmall();
else
solveLarge();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
inline int fpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = 1ll * ans * x % p;
x = 1ll * x * x % p, y >>= 1;
}
return ans;
}
int n;
int cnt[100086];
int sum[100086], a[100086], b[100086];
long long siz[100086];
int f[100086];
int x, y;
int main() {
scanf("%d", &n);
while (n--) {
scanf("%d%d", &x, &y);
cnt[x] = y;
}
n = 1e5;
for (int i = 1; i <= n; i++) {
for (int j = 1; i * j <= n; j++) {
siz[i] += cnt[i * j];
a[i] = (a[i] + 1ll * cnt[i * j] * i * j % p * i * j) % p;
b[i] = (b[i] + 2ll * cnt[i * j] * i * j % p * sum[i]) % p;
b[i] =
(b[i] + 1ll * cnt[i * j] * (cnt[i * j] - 1) % p * i * j % p * i * j) %
p;
sum[i] = (sum[i] + 1ll * cnt[i * j] * i * j) % p;
}
}
for (int i = n; i; i--) {
if (siz[i] >= 2)
f[i] = (f[i] + 1ll * a[i] * fpow(2, (siz[i] - 2) % (p - 1)) % p *
((siz[i] - 1) % p)) %
p;
if (siz[i] >= 3)
f[i] = (f[i] + 1ll * b[i] * fpow(2, (siz[i] - 3) % (p - 1)) % p *
((siz[i] - 2) % p)) %
p;
if (siz[i] >= 2)
f[i] = (f[i] + 1ll * b[i] * fpow(2, (siz[i] - 2) % (p - 1))) % p;
for (int j = 2; i * j <= n; j++) f[i] = (f[i] + p - f[i * j]) % p;
}
printf("%d", f[1]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int M = 1e9 + 6;
const int ini = 333333336;
long long pow_mod(long long a, long long n) {
long long x = 1;
while (n) {
if (n & 1) x = x * a % mod;
a = a * a % mod;
n >>= 1;
}
return x;
}
void solve(long long fo, long long t) {
t = (t % M + M) % M;
if (!t) t += M;
long long a = pow_mod(2, t);
printf("%I64d/%I64d\n", (a + fo) * ini % mod, a);
}
int main() {
int T, f = 1, fo = -1;
long long t = 1, x;
scanf("%d", &T);
while (T--) {
scanf("%I64d", &x);
if (x >= M || t * x >= M) {
f = 0;
t = (t % M) * (x % M) % M;
} else
t *= x;
if (!(x & 1)) fo = 1;
}
if (f == 0)
solve(fo, t - 1);
else if (t == 1)
printf("0/1\n");
else {
long long a = pow_mod(2, t - 1);
printf("%I64d/%I64d\n", (a + fo) * ini % mod, a);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 100005;
int n, m;
vector<pair<int, int> > e[N];
long long dep[N];
void dfs(int x, long long d) {
dep[x] = d;
for (auto E : e[x]) dfs(E.first, d + E.second);
}
vector<pair<long long, long long> > v;
namespace lct {
int fa[N], son[N][2];
long long val[N], tag[N];
int isroot(int x) { return son[fa[x]][0] != x && son[fa[x]][1] != x; }
int wson(int x) { return son[fa[x]][1] == x; }
void rotate(int x) {
int y = fa[x], z = fa[y], L = wson(x), R = L ^ 1;
if (!isroot(y)) son[z][wson(y)] = x;
fa[x] = z, fa[y] = x, fa[son[x][R]] = y;
son[y][L] = son[x][R], son[x][R] = y;
}
void pushson(int x, long long v) {
val[x] = max(val[x], v);
tag[x] = max(tag[x], v);
}
void pushdown(int x) {
if (tag[x]) {
pushson(son[x][0], tag[x]);
pushson(son[x][1], tag[x]);
tag[x] = 0;
}
}
void pushadd(int x) {
if (!isroot(x)) pushadd(fa[x]);
pushdown(x);
}
void splay(int x) {
pushadd(x);
for (int y = fa[x]; !isroot(x); rotate(x), y = fa[x])
if (!isroot(y)) rotate(wson(x) == wson(y) ? y : x);
}
void access(int x, long long start_time) {
int _x = x;
int t = 0;
while (x) {
splay(x);
if (x != _x) {
v.push_back(make_pair(val[x] == 0 ? 1 : val[x] + dep[x] + 1,
start_time + dep[x]));
son[x][1] = t;
}
t = x;
x = fa[x];
}
x = _x;
splay(x);
if (son[x][0]) pushson(son[x][0], start_time);
}
} // namespace lct
void gao(long long res) {
printf("%lld ", res);
if (res == -1) res = 1e18;
int cnt = 0;
for (auto i : v) cnt += i.second < res;
printf("%d\n", cnt);
exit(0);
}
int main() {
n = read(), m = read();
for (int i = (1); i <= (n - 1); i++) {
int x = read(), y = read(), z = read();
e[x].push_back(make_pair(y, z));
lct::fa[y] = x, lct::son[x][1] = y;
}
dfs(1, 0);
for (int i = (1); i <= (m); i++) {
int s = read(), t = read();
lct::access(s, t);
}
sort(v.begin(), v.end());
priority_queue<long long, vector<long long>, greater<long long> > q;
long long t = 1;
for (auto p : v) {
while (!q.empty() && t < p.first) {
if (q.top() < t) gao(q.top());
q.pop();
t++;
}
t = max(t, p.first);
q.push(p.second);
}
while (!q.empty()) {
if (q.top() < t) gao(q.top());
q.pop();
t++;
}
gao(-1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int flag = 0, p, q, prev = INT_MAX;
for (int i = 0; i < n; ++i) {
cin >> p >> q;
if (p != q) {
cout << "rated";
return 0;
} else if (q > prev) {
flag = 1;
} else {
prev = p;
}
}
if (flag == 1)
cout << "unrated";
else
cout << "maybe";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b < a) {
long long int temp = a;
a = b;
b = temp;
}
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (a * b / gcd(a, b));
}
long long int fact(long long int x) {
long long int ans = 1;
if (x == 0) {
return 1;
}
while (x > 0) {
ans = (ans * x) % 1000000007;
x--;
}
return ans % 1000000007;
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b % 2 == 1) {
ans *= a;
ans = ans;
}
b /= 2;
a *= a;
a = a;
}
return ans;
}
vector<long long int> getbinary(long long int x) {
vector<long long int> bin(20000, 0);
long long int iter = 0;
while (x > 0) {
if (x % 2 == 1) {
bin[iter] = 1;
} else {
bin[iter] = 0;
}
iter++;
x /= 2;
}
return bin;
}
using namespace std;
int main() {
long long int n, k, b, i, x;
cin >> n >> k >> b;
pair<long long int, long long int> a[n];
for (i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort(a, a + n);
for (i = 0; i < n; i++) {
x = i + 1;
while (x < n && a[x].first == a[i].first) {
x++;
}
if (x != i + 1) reverse(a + i, a + x);
i = x - 1;
}
x = n;
for (i = n - 1; i >= 0; i--) {
if (a[i].second == n) {
continue;
} else {
if (k == 1) {
long long int j = i;
while (j >= 0) {
if (a[j].first > b && a[j].second < x) {
x = a[j].second;
}
j--;
}
}
k--;
b -= a[i].first;
if (a[i].second < x) x = a[i].second;
if (k > 0 && b <= 0) {
cout << 1;
return 0;
}
if (k == 0 && b >= 0) {
cout << n;
return 0;
}
if (k == 0) {
break;
}
}
}
cout << x;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mx = 1e5 + 10;
long long n, m, a[mx], cnt[mx], r[mx], l[mx], p[mx], ans[mx];
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] < mx) cnt[a[i]]++;
}
for (long long i = 0; i < m; i++) cin >> l[i] >> r[i];
for (long long in = 1; in < mx; in++) {
if (cnt[in] >= in) {
p[0] = 0;
for (long long i = 1; i <= n; i++) p[i] = p[i - 1] + (a[i] == in);
for (long long i = 0; i < m; i++)
ans[i] += ((p[r[i]] - p[l[i] - 1]) == in);
}
}
for (long long i = 0; i < m; i++) cout << ans[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <int BASE, long long MODULO>
class StringHash {
template <int B, long long M>
friend class StringHasher;
vector<long long> hash;
public:
size_t getSize() const { return hash.size(); }
};
template <int BASE, long long MODULO>
class StringHasher {
static long long getBasePower(int n) {
static vector<long long> power;
if (n > (int)power.size() - 1) {
int cur = (int)power.size() - 1;
power.resize(n + 1);
for (auto i = cur + 1; i <= n; ++i) {
if (i == 0) {
power[i] = 1;
} else {
power[i] = (power[i - 1] * BASE) % MODULO;
}
}
}
return power[n];
}
public:
template <class Iterator>
static StringHash<BASE, MODULO> getHash(Iterator begin, Iterator end) {
StringHash<BASE, MODULO> h;
int n = (int)(end - begin);
h.hash.resize(n);
int idx = 0;
long long last = 0;
for (auto it = begin; it != end; ++it) {
h.hash[idx] = (last * BASE + *it) % MODULO;
last = h.hash[idx];
idx++;
}
return h;
}
static long long getHashValue(const StringHash<BASE, MODULO> &sh) {
return sh.hash[sh.getSize() - 1];
}
static long long getHashValue(const StringHash<BASE, MODULO> &sh, int first,
int len) {
if (len == 0) return 0;
assert(0 <= first && first < sh.getSize());
assert(len >= 1);
assert(first + len - 1 < sh.getSize());
int last = first + len - 1;
if (first == 0) return sh.hash[last];
long long ret =
(sh.hash[last] - sh.hash[first - 1] * getBasePower(len)) % MODULO;
if (ret < 0) ret += MODULO;
return ret;
}
static long long getHashValueConcat(const StringHash<BASE, MODULO> &sh1,
const StringHash<BASE, MODULO> &sh2) {
return (getHashValue(sh1) * getBasePower((int)sh2.getSize()) +
getHashValue(sh2)) %
MODULO;
}
};
class BinarySearch {
public:
template <class T>
static T binarySearchMin(const T &minIndex, const T &maxIndex,
const function<bool(T)> &predicate) {
T leftIndex = minIndex, rightIndex = maxIndex, midIndex, ret = maxIndex + 1;
while (leftIndex <= rightIndex) {
midIndex = leftIndex + (rightIndex - leftIndex) / 2;
if (predicate(midIndex)) {
ret = midIndex;
rightIndex = midIndex - 1;
} else {
leftIndex = midIndex + 1;
}
}
return ret;
}
template <class T>
static T binarySearchMax(const T &minIndex, const T &maxIndex,
const function<bool(T)> &predicate) {
T leftIndex = minIndex, rightIndex = maxIndex, midIndex, ret = minIndex - 1;
while (leftIndex <= rightIndex) {
midIndex = leftIndex + (rightIndex - leftIndex) / 2;
if (predicate(midIndex)) {
ret = midIndex;
leftIndex = midIndex + 1;
} else {
rightIndex = midIndex - 1;
}
}
return ret;
}
static double binarySearchMaxReal(double minRange, double maxRange,
double epsilon,
const function<bool(double)> &predicate) {
double l = minRange, r = maxRange, m, ret = maxRange + 1;
while (r - l > epsilon) {
m = l + (r - l) / 2;
if (predicate(m)) {
ret = m;
l = m;
} else {
r = m;
}
}
return ret;
}
static double binarySearchMinReal(double minRange, double maxRange,
double epsilon,
const function<bool(double)> &predicate) {
double l = minRange, r = maxRange, m, ret = maxRange + 1;
while (r - l > epsilon) {
m = l + (r - l) / 2;
if (predicate(m)) {
l = m;
ret = m;
} else {
r = m;
}
}
return ret;
}
};
void testGen() {
freopen("biginput1.txt", "w", stdout);
fclose(stdout);
}
int lenS, lenT;
string s, t;
pair<StringHash<3, 1000001927>, StringHash<5, 1000001963>> hashS[26], hashT[26];
vector<long long> hT(26), htSorted(26);
bool check(int i) {
vector<long long> hS(26);
for (auto c = 0; c < 26; ++c) {
hS[c] = StringHasher<3, 1000001927>::getHashValue(hashS[c].first, i, lenT) *
1000001927 +
StringHasher<5, 1000001963>::getHashValue(hashS[c].second, i, lenT);
}
vector<long long> hsSorted = hS;
sort(hsSorted.begin(), hsSorted.end());
for (auto c = 0; c < 26; ++c) {
if (hsSorted[c] != htSorted[c]) {
return false;
}
}
for (auto c1 = 0; c1 < 26; ++c1) {
if (hS[c1] == 0) continue;
for (auto c2 = 0; c2 < 26; ++c2) {
if (hS[c1] == hT[c2] && hS[c2] != hT[c1]) {
return false;
}
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> lenS >> lenT;
cin >> s >> t;
for (auto c = 0; c < 26; ++c) {
vector<int> vs, vt;
for (auto i = 0; i < lenS; ++i) {
vs.push_back((s[i] - 'a') == c);
}
for (auto i = 0; i < lenT; ++i) {
vt.push_back((t[i] - 'a') == c);
}
hashS[c] =
make_pair(StringHasher<3, 1000001927>::getHash(vs.begin(), vs.end()),
StringHasher<5, 1000001963>::getHash(vs.begin(), vs.end()));
hashT[c] =
make_pair(StringHasher<3, 1000001927>::getHash(vt.begin(), vt.end()),
StringHasher<5, 1000001963>::getHash(vt.begin(), vt.end()));
}
for (auto c = 0; c < 26; ++c) {
hT[c] =
StringHasher<3, 1000001927>::getHashValue(hashT[c].first) * 1000001927 +
StringHasher<5, 1000001963>::getHashValue(hashT[c].second);
}
htSorted = hT;
sort(htSorted.begin(), htSorted.end());
vector<int> ans;
for (auto i = 0; i < lenS - lenT + 1; ++i) {
if (check(i)) {
ans.push_back(i);
}
}
cout << ans.size() << endl;
for (int i : ans) cout << (i + 1) << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,a[100005];
cin>>n;
for(int i=1;i<=n;i++){
int b;
cin>>b;
a[b]=i;
}
for(int i=1;i<=n;i++)
cout<<a[i]<<" ";
cout<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num, Mishka = 0, Chris = 0;
cin >> num;
for (int i = 0; i < num; i++) {
int num1, num2;
cin >> num1 >> num2;
if (num1 > num2) {
Mishka++;
} else if (num2 > num1) {
Chris++;
}
}
if (Mishka > Chris) {
cout << "Mishka" << endl;
} else if (Chris > Mishka) {
cout << "Chris" << endl;
} else {
cout << "Friendship is magic!^^" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int k;
cin>>k;
if (k%2==0||k%10==5){
cout<<-1;
return 0;
}
int ans=1, r=7%k;
while (r!=0){
ans++;
r=(r*10+7)%k;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
char c[MAXN][MAXN];
int l[MAXN][MAXN], r[MAXN][MAXN], d[MAXN][MAXN], fen[2 * MAXN][MAXN];
vector<pair<int, int> > ev[MAXN];
void add(int t, int x, int val) {
for (; x < MAXN; x |= x + 1) fen[t][x] += val;
}
int getPref(int t, int x) {
int res = 0;
for (; x >= 0; x = (x & (x + 1)) - 1) res += fen[t][x];
return res;
}
int get(int t, int l, int r) {
return getPref(t, r) - (l ? getPref(t, l - 1) : 0);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", c[i]);
for (int i = 0; i < n; i++) {
l[i][0] = 0;
for (int j = 1; j < m; j++)
l[i][j] = (c[i][j - 1] == 'z' ? l[i][j - 1] : j);
}
for (int i = 0; i < n; i++) {
r[i][m - 1] = m - 1;
for (int j = m - 2; j >= 0; j--)
r[i][j] = (c[i][j + 1] == 'z' ? r[i][j + 1] : j);
}
for (int j = 0; j < m; j++) d[0][j] = j;
for (int i = 1; i < n; i++) {
for (int j = 0; j < m - 1; j++)
d[i][j] = (c[i - 1][j + 1] == 'z' ? d[i - 1][j + 1] : j);
d[i][m - 1] = m - 1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ev[l[i][j]].push_back(make_pair(i, j));
long long ans = 0;
for (int j = 0; j < m; j++) {
for (size_t i = 0; i < ev[j].size(); i++) {
int x = ev[j][i].first, y = ev[j][i].second;
add(x + y, y, 1);
}
for (int i = 0; i < n; i++)
if (c[i][j] == 'z') ans += get(i + j, j, min(r[i][j], d[i][j]));
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int offset = 100 * 100 * 10;
long long int mxbal = offset + offset;
long long int n, k;
cin >> n >> k;
vector<long long int> a(n + 1), b(n + 1);
for (long long int i = 0; i < n; ++i) cin >> a[i];
for (long long int i = 0; i < n; ++i) cin >> b[i];
vector<vector<long long int>> dp(n + 1, vector<long long int>(mxbal, -1));
dp[0][offset] = 0;
for (long long int i = 0; i < n; ++i) {
for (long long int j = 0; j < mxbal; ++j) {
if (dp[i][j] != -1) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
dp[i + 1][j - a[i] + b[i] * k] =
max(dp[i + 1][j - a[i] + b[i] * k], dp[i][j] + a[i]);
}
}
}
if (dp[n][offset] == 0) dp[n][offset] = -1;
cout << dp[n][offset] << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long int T = 1;
for (long long int i = 1; i <= T; ++i) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const long long mod = 1e9 + 7;
long long giv[maxn];
int n, nm;
long long w[2];
long long res;
struct node {
int to, next;
} edg[maxn * 2];
int beg[maxn];
bool col[maxn];
long long num[maxn][2];
void ran(int x, bool y, int fa) {
col[x] = y;
w[y]++;
for (int i = beg[x]; i != -1; i = edg[i].next) {
if (edg[i].to == fa) continue;
ran(edg[i].to, !y, x);
}
}
void add(int a, int b) {
edg[++nm].to = b;
edg[nm].next = beg[a];
beg[a] = nm;
}
void play(int x, int fa) {
int i, j, a, b;
for (i = beg[x]; i != -1; i = edg[i].next) {
if (edg[i].to == fa) continue;
play(edg[i].to, x);
num[x][0] += num[edg[i].to][0];
num[x][1] += num[edg[i].to][1];
res += num[edg[i].to][col[x]] * (w[col[x]] - num[edg[i].to][col[x]]) % mod *
giv[x] % mod;
res -= num[edg[i].to][!col[x]] * (w[!col[x]] - num[edg[i].to][!col[x]]) %
mod * giv[x] % mod;
res = (res % mod + mod) % mod;
}
num[x][col[x]]++;
res += num[x][col[x]] * (w[col[x]] - num[x][col[x]]) % mod * giv[x] % mod;
res -= num[x][!col[x]] * (w[!col[x]] - num[x][!col[x]]) % mod * giv[x] % mod;
res = (res % mod + mod) % mod;
}
int main() {
memset(beg, -1, sizeof(beg));
int i, j, a, b;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%lld", &giv[i]);
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
add(a, b);
add(b, a);
}
ran(1, 0, 0);
for (i = 1; i <= n; i++) {
res += giv[i] * w[col[i]];
res %= mod;
}
play(1, 0);
printf("%lld", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (2e5 + 5);
const long long MOD = 1e9 + 7;
const long long INF = 1e16;
const long long LOG = 29;
long long binpow(long long a, long long b) {
a %= MOD;
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
res %= MOD;
return res;
}
void solve() {
long long n;
cin >> n;
if (n == 1) {
cout << "-1\n";
} else {
cout << 2;
for (int i = 0; i < (n - 1); i++) {
cout << 3;
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<pair<int, int>, int> req[1000];
pair<int, int> t[1000];
int n, k;
bool cmp1(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.first != b.first.first)
return a.first.first > b.first.first;
else if (a.first.second != b.first.second)
return a.first.second < b.first.second;
else
return a.second < b.second;
}
bool cmp2(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second < b.second;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
req[i].second = i;
cin >> req[i].first.second >> req[i].first.first;
}
cin >> k;
for (int i = 0; i < k; i++) {
t[i].second = i;
cin >> t[i].first;
}
sort(req, req + n, cmp1);
sort(t, t + k, cmp2);
int c = 0;
int used[1001] = {0};
int m = 0;
int h[1001] = {0};
for (int i = 0; i < n; i++) {
int mint = 10001;
int mind = -1;
int p = req[i].first.second;
for (int j = 0; j < k; j++) {
if (p <= t[j].first && !used[j]) {
mind = j;
break;
}
}
if (mind == -1)
continue;
else {
used[mind] = 1;
m++;
c += req[i].first.first;
h[req[i].second] = t[mind].second + 1;
}
}
cout << m << " " << c << endl;
for (int i = 0; i < n; i++) {
if (!h[i]) continue;
cout << i + 1 << " " << h[i] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
string a, b;
int d[30][30];
string resp;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> n;
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
if (i != j) d[i][j] = 1e8;
for (int i = 1; i <= n; i++) {
char A, B;
int c;
cin >> A >> B >> c;
int u = A - 'a', v = B - 'a';
d[u][v] = min(d[u][v], c);
}
if (a.size() != b.size()) {
cout << "-1" << '\n';
return 0;
}
for (int k = 0; k < 26; k++)
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
int ans = 0;
for (int i = 0; i < a.size(); i++) {
int x = a[i] - 'a', y = b[i] - 'a';
int menor = 1e8, id = -1;
for (int c = 0; c < 26; c++)
if (d[x][c] != 1e8 && d[y][c] != 1e8 && d[x][c] + d[y][c] < menor)
menor = d[x][c] + d[y][c], id = c;
if (id == -1) {
cout << "-1" << '\n';
return 0;
}
ans += menor;
resp.push_back(char(id + 'a'));
}
cout << ans << '\n' << resp << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
long long x, y, z, a[105];
string s[105];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
;
cin >> x >> y;
for (int i = 0; i < x; i++) {
cin >> s[i];
}
for (int i = 0; i < y; i++) {
bool can = 1;
for (int j = 1; j < x; j++) {
if (s[j][i] < s[j - 1][i] && !a[j]) {
z++;
can = 0;
break;
}
}
if (can) {
for (int j = 1; j < x; j++) {
if (s[j][i] > s[j - 1][i]) {
a[j]++;
}
}
}
}
cout << z << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int INF = 1e9 + 10;
unsigned long long MOD = 998244353;
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
unsigned long long n;
cin >> n;
if ((n - 2) % 3 != 0) {
cout << 1 << " " << 1 << " " << n - 2;
} else {
cout << 2 << " " << 1 << " " << n - 3;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, k;
cin >> t;
while (t--) {
cin >> n;
long long ans = 0;
while (n > 0) {
if (n % 2 == 1) {
ans += 1;
n--;
if ((n % 4 == 0) && (n >= 8)) {
n--;
} else {
if (n % 4 == 0) {
n /= 2;
} else {
n /= 2;
}
}
} else {
if ((n % 4 == 0) && (n >= 8)) {
ans += 1;
n -= 2;
} else {
if (n % 4 == 0) {
ans += n / 2;
n /= 2;
n /= 2;
} else {
ans += n / 2;
n /= 2;
n--;
}
}
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for (int i = (a); i < (b); i++)
#define REP(i,n) rep(i,0,n)
void solve()
{
int n,p;string s;cin>>n>>p>>s;
int64_t ans=0;
if(p==2||p==5){
REP(i,n)if(!((s[i]-'0')%p))ans+=i+1;
}else{
map<int,int>cnt;
cnt[0]=1;
int64_t cur=0,ten=1;
REP(i,n){
(cur+=(s[n-1-i]-'0')*ten)%=p;
ans+=cnt[cur]++;
(ten*=10)%=p;
}
}
cout<<ans<<endl;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 100005, mod = 1e9 + 7, inf = 1e9;
int dp[nax][2], n, col[nax];
vector<int> v[nax];
int pot(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = (long long)res * a % mod;
a = (long long)a * a % mod;
b /= 2;
}
return res;
}
void dfs(int node) {
if ((int)v[node].size() == 0) {
dp[node][col[node]] = 1;
return;
}
int ilo = 1;
for (auto it : v[node]) {
dfs(it);
ilo = (long long)ilo * (dp[it][0] + dp[it][1]) % mod;
}
if (col[node] == 1) dp[node][1] = ilo;
if (col[node] == 0) dp[node][0] = ilo;
if (col[node] == 0) {
for (auto it : v[node]) {
int nowy = (long long)ilo * pot(dp[it][0] + dp[it][1], mod - 2) % mod;
dp[node][1] = (dp[node][1] + (long long)nowy * dp[it][1] % mod) % mod;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; n > i; ++i) {
int a;
scanf("%d", &a);
v[a].push_back(i);
}
for (int i = 0; n > i; ++i) scanf("%d", &col[i]);
dfs(0);
printf("%d\n", dp[0][1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[1002][1002] = {0};
map<int, int> mx;
map<int, int> my;
int x = 0;
int y = 0;
for (int i = 1; i < 1001; i++) {
mx.insert({i, x});
my.insert({i, y});
if (i % 2 == 1)
x += 1;
else
y += 1;
if (i == n) {
cout << mx[i] + 1 << endl;
for (int j = 1; j < n + 1; j++) {
cout << mx[j] + 1 << " " << my[j] + 1 << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6 + 42;
int n, wanted, inp[nmax];
long long eval(int i, int cur) {
long long s = ((-inp[i]) % cur + cur) % cur;
long long t = cur - s;
long long d = (inp[i] + s) / cur;
return 1LL * s * (d - 1) * (d - 1) + 1LL * t * d * d;
}
priority_queue<pair<long long, int> > pq;
int groups[nmax];
int main() {
scanf("%i%i", &n, &wanted);
wanted = wanted - n;
for (int i = 1; i <= n; i++) scanf("%i", &inp[i]);
long long outp = 0;
for (int i = 1; i <= n; i++) {
outp += 1LL * inp[i] * inp[i];
groups[i]++;
pq.push({eval(i, 1) - eval(i, 2), i});
}
while (wanted) {
pair<long long, int> tp = pq.top();
pq.pop();
outp = outp - tp.first;
groups[tp.second]++;
int i = tp.second;
pq.push({eval(i, groups[i]) - eval(i, groups[i] + 1), i});
wanted--;
}
printf("%lld\n", outp);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
while (scanf("%d%d%d%d", &a, &b, &c, &d) != EOF) {
int x, y = 2, z = max(abs(a - c), abs(b - d));
if (a != c && b != d)
x = 2;
else
x = 1;
if (abs(a - c) == abs(d - b))
y = 1;
else if ((c + d + (b - a)) % 2 != 0)
y = 0;
printf("%d %d %d\n", x, y, z);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, s = 0;
cin >> n;
int d[n - 2];
for (int i = 0; i <= n - 2; i++) {
cin >> d[i];
}
cin >> a >> b;
for (int j = (a - 1); j < (b - 1); j++) {
s += d[j];
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin>>n>>k;
int x[n];
for(int i=0;i<n;i++)cin>>x[i];
int l,r,d,mm;
int m=2000000001;
for(int i=0;i<n-k+1;i++){
l=max(x[i],-x[i]);
r=max(x[i+k-1],-x[i+k-1]);
d=max(x[i]-x[i+k-1],x[i+k-1]-x[i]);
mm=min(l+d,r+d);
m=min(mm,m);
}
cout<<m<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long double tot_ans = 0;
vector<pair<int, int> > adj[N];
int u, v, c, n;
int lvl[N];
int sv[N];
int init[N];
long double compute(int wt, int t7t, int fo2) {
long double ret = 0;
if (t7t && fo2 >= 2) {
long double prop1 =
1.0 * t7t / n * fo2 / (1.0 * (n - 1)) * (fo2 - 1) / (1.0 * (n - 2)) * 3;
ret += (prop1 * wt * 2);
}
if (t7t >= 2 && fo2) {
long double prop1 =
1.0 * fo2 / n * t7t / (1.0 * (n - 1)) * (t7t - 1) / (1.0 * (n - 2)) * 3;
ret += (prop1 * wt * 2);
}
return ret;
}
void dfs(int u, int p) {
sv[u] = 1;
for (auto v : adj[u]) {
if (v.first == p) continue;
lvl[v.first] = lvl[u] + 1;
dfs(v.first, u);
sv[u] += sv[v.first];
tot_ans += compute(v.second, sv[v.first], n - sv[v.first]);
}
}
pair<int, int> edge[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v >> c;
u--, v--;
adj[u].emplace_back(v, c);
adj[v].emplace_back(u, c);
init[i] = c;
edge[i] = pair<int, int>(u, v);
}
int q, r, w;
cin >> q;
dfs(0, 0);
while (q--) {
cin >> r >> w;
r--;
u = edge[r].first, v = edge[r].second;
if (lvl[u] < lvl[v]) swap(u, v);
tot_ans -= compute(init[r] - w, sv[u], n - sv[u]);
init[r] = w;
cout << fixed << setprecision(13) << tot_ans << '\n';
}
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
int main() {
int n;
while(cin>>n, n) {
vector<int> vi;
for(int i=1; i<n; ++i)
vi.push_back(i*i%n);
sort(vi.begin(), vi.end());
vector<int>::iterator uni = unique(vi.begin(), vi.end());
vi.erase(uni, vi.end());
int cnt[(n-1)/2+1];
memset(cnt, 0, sizeof(cnt));
for(int i=0; i<vi.size(); ++i) {
for(int j=i+1; j<vi.size(); ++j) {
int ci = vi[i] - vi[j];
if(ci < 0) ci += n;
if(ci > (n-1)/2) ci = n - ci;
cnt[ci]++;
}
}
for(int i=1; i<=(n-1)/2; ++i) cout<<cnt[i]*2<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c,d,e,f,g,h,i;
cin >>a >>b >>c >>d >>e >>f >>g >>h >>i;
if(a+e==b+d&&b+f==c+e&&d+h==e+g&&e+i==f+h){
cout << "Yes" << endl;}
else{
cout << "No" << endl;}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 200000 + 5;
int v[NMAX];
int main() {
ios_base ::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> v[i];
for (int i = 1; i <= n; ++i) {
v[i] %= 2;
if (v[i] == 1) {
if (v[i + 1] == 0) {
cout << "NO\n";
return 0;
} else
v[i + 1]--;
}
}
cout << "YES\n";
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main(){
int a,b,ans=0;
cin>>a>>b;
ans+=a;
if(a>b)ans-=1;
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long previous = 0;
vector<long long> preb;
vector<long long> prea;
for (long long i = 0; i < n; i++) {
if (s[i] == 'b') {
preb.emplace_back(previous);
previous = 0;
} else
previous++;
}
preb.emplace_back(previous);
previous = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'a') {
prea.emplace_back(previous);
previous = 0;
} else
previous++;
}
prea.emplace_back(previous);
long long countb = 0;
long long counta = 0;
long long res = 0;
long long c = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'b') {
countb++;
if (countb == k + 1) {
res = max(res, counta + k);
countb--;
counta -= preb[c];
c++;
}
} else
counta++;
}
res = max(res, counta + countb);
countb = 0;
counta = 0;
c = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'a') {
counta++;
if (counta == k + 1) {
res = max(res, countb + k);
counta--;
countb -= prea[c];
c++;
}
} else
countb++;
}
res = max(res, counta + countb);
cout << res << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int solve(vector<int> v) {
int max = 0, aux = 0;
map<int, int> m;
for (int i = 0; i < v.size(); i++) {
if (v[i] < 0) {
if (m.find(-(v[i])) == m.end()) {
max++;
} else {
aux--;
}
} else {
m[v[i]]++;
aux++;
if (aux > max) max = aux;
}
}
return max;
}
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
char a;
int b;
cin >> a >> b;
if (a == '+') v.push_back(b);
if (a == '-') v.push_back(-b);
}
cout << solve(v) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, k, i;
long int a;
long long ans = 0;
cin >> n >> k;
long int x[n];
long int c[n];
for (i = 0; i < n; i++) cin >> x[i];
cin >> a;
for (i = 0; i < n; i++) cin >> c[i];
deque<long int> d;
for (i = 0; i < n; i++) {
if (k < x[i]) {
d.push_back(c[i]);
sort(d.begin(), d.end());
while (!d.empty() && k < x[i]) {
ans += d.front();
k += a;
d.pop_front();
}
if (k < x[i]) {
cout << "-1";
exit(0);
}
} else
d.push_back(c[i]);
}
cout << ans;
}
| 6 |
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <complex>
#include <ctime>
#include <cstdlib>
using namespace std;
inline int to_int(string s) {int v; istringstream sin(s); sin >> v; return v;}
template<class T> inline string to_str(T x) {ostringstream sout; sout << x; return sout.str();}
typedef long long ll;
const int N_MAX = 128;
int T[4][N_MAX];
bool cmp()
{
bool ret = true;
/*
for(int i = 0; i < 20; i++)
{
printf("%d ", T[2][i]);
}
puts("");
for(int i = 0; i < 20; i++)
{
printf("%d ", T[3][i]);
}
puts("");
*/
for(int i = 0; i < N_MAX; i++)
{
if(T[2][i] != T[3][i])
{
ret = false;
break;
}
}
return ret;
}
void pls()
{
for(int i = 0; i < N_MAX; i++)
{
T[3][i] += T[0][i] + T[1][i];
while(T[3][i] >= 10)
{
T[3][i+1]++;
T[3][i] -= 10;
}
}
return void();
}
int main()
{
string str;
while(cin >> str)
{
for(char i = '0'; i <= '9'; i++)
{
memset(T, 0, sizeof(T));
string s;
s = str;
int m;
while(s.find('X') != string::npos)
{
m = s.find('X');
s[m] = i;
}
int n = s.find('+'); m = s.find('=');
string S[3];
S[0] = s.substr(0, n);
S[1] = s.substr(n+1, m-n-1);
S[2] = s.substr(m+1, s.size()-1);
bool ok = false;
for(int j = 0; j < 3; j++)
{
if(S[j].size() > 1 && S[j][0] == '0')
{
ok = true;
}
else
{
reverse(S[j].begin(), S[j].end());
}
}
if(ok)
{
continue;
}
//printf("%s %s %s\n",S[0].c_str() ,S[1].c_str() ,S[2].c_str());
for(int j = 0; j < 3; j++)
{
for(int k = 0; k < S[j].size(); k++)
{
T[j][k] = S[j][k] - '0';
}
}
pls();
if(cmp())
{
cout << i << endl;
break;
}
else if(i == '9')
{
cout << "NA" << endl;
break;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void task();
int main() {
task();
return 0;
}
const int INF = 0x3f3f3f3f;
const int N = 203;
struct Rib {
int to;
int cap;
int flow;
int back;
};
int n, m;
int a[101];
int b[101];
vector<Rib> g[N];
int S = 201, T = 202;
int ans[101][101];
int dist[N];
int pt[N];
void add_rib(int a, int b, int cap) {
g[a].push_back(Rib{b, cap, 0, ((int)((g[b]).size()))});
g[b].push_back(Rib{a, 0, 0, ((int)((g[a]).size())) - 1});
}
int bfs() {
memset(dist, 0x3f, sizeof(dist));
dist[S] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
int v = q.front();
q.pop();
for (Rib& r : g[v])
if (r.cap - r.flow && dist[r.to] == INF) {
dist[r.to] = dist[v] + 1;
q.push(r.to);
}
}
return dist[T] != INF;
}
int dfs(int v, int flow) {
if (v == T) return flow;
for (; pt[v] < ((int)((g[v]).size())); ++pt[v]) {
Rib& r = g[v][pt[v]];
if (dist[r.to] != dist[v] + 1 || r.cap - r.flow == 0) continue;
if (int f = dfs(r.to, min(flow, r.cap - r.flow))) {
r.flow += f;
g[r.to][r.back].flow -= f;
return f;
}
}
return 0;
}
int dinic() {
int res = 0;
while (bfs()) {
memset(pt, 0, sizeof(pt));
while (int f = dfs(S, INF)) res += f;
}
return res;
}
void task() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
int sum1 = 0, sum2 = 0;
for (int i = 0; i < n; ++i) sum1 += a[i], sum2 += b[i];
if (sum1 != sum2) {
printf("NO");
return;
}
for (int i = 0; i < n; ++i) {
add_rib(S, i, a[i]);
add_rib(n + i, T, b[i]);
}
for (int i = 0; i < n; ++i) add_rib(i, n + i, INF);
for (int i = 0; i < m; ++i) {
int f, t;
scanf("%d %d", &f, &t);
--f, --t;
add_rib(f, n + t, INF);
add_rib(t, n + f, INF);
}
int max_flow = dinic();
if (max_flow != sum2) {
printf("NO");
return;
}
printf("YES\n");
for (int i = 0; i < n; ++i)
for (Rib& r : g[i]) ans[i][r.to - n] += max(0, r.flow);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) printf("%d ", ans[i][j]);
printf("\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool check(int arr[], int size, int k) {
for (int i = 0; i < size; i++) {
if (arr[i] != k) return false;
}
return true;
}
int main() {
int n, k;
cin >> n >> k;
int ranks[n];
for (int i = 0; i < n; i++) cin >> ranks[i];
int counter = 0;
while (!check(ranks, n, k)) {
int comp = 0;
for (int i = 0; i < n; i++) {
if (ranks[i] != comp && ranks[i] < k) {
comp = ranks[i];
ranks[i]++;
}
}
sort(ranks, ranks + n);
counter++;
}
cout << counter << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> primes;
if (n == 1) {
cout << 1 << endl << 0;
return 0;
}
while (n % 2 == 0) {
primes.push_back(2);
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
primes.push_back(i);
n = n / i;
}
}
if (n > 2) primes.push_back(n);
if (primes.size() == 1) {
cout << 1 << endl << 0;
} else {
if (primes.size() == 2) {
cout << 2 << endl;
} else {
cout << 1 << endl << primes[0] * primes[1] << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
vector<set<int>> num(2);
for (int i = 0; i < n; i++) {
num[s[i] - '0'].insert(i);
}
vector<int> ans(n, -1);
int id = 0;
for (int i = 0; i < n; i++) {
if (ans[i] == -1) {
ans[i] = ++id;
int val = i;
int c = (s[i] == '1');
while (num[!c].upper_bound(val) != num[!c].end()) {
auto it = num[!c].upper_bound(val);
ans[(*it)] = id;
val = (*it);
num[!c].erase(it);
c = !c;
}
}
}
cout << id << '\n';
for (int i = 0; i < n; i++) {
cout << ans[i] << ' ';
}
cout << '\n';
}
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int main() {
int n, count;
bool *data;
while (cin >> n) {
data = new bool[n + 1];
count = 0;
for (int i = 0;i <= n;i++) data[i] = true;
for (int i = 2;i <= n;i++) {
if (data[i]) {
count++;
for (int j = i + i;j <= n;j += i) {
data[j] = false;
}
}
}
cout << count << endl;
delete[] data;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class Iterable,
class = typename enable_if<!is_same<string, Iterable>::value>::type>
auto operator<<(ostream &os, Iterable v) -> decltype(os << *begin(v)) {
os << "[";
for (auto vv : v) os << vv << ", ";
return os << "]";
}
const int inf = 0x3f3f3f3f;
const long long infll = 0x3f3f3f3f3f3f3f3fll;
template <class T>
int sign(T x) {
return (x > 0) - (x < 0);
}
template <class T>
T abs(const T &x) {
return (x < T(0)) ? -x : x;
}
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> pi(n + 1);
iota(pi.begin(), pi.end(), 0);
for (int i = 0; i < n; i++) cin >> a[i];
vector<vector<int> > ans(n + 1, vector<int>(n, -1));
vector<vector<int> > v = {pi};
for (int i = 0; i < n; i++) {
sort(v.begin(), v.end(),
[](const vector<int> &lhs, const vector<int> &rhs) {
return ((int)(lhs).size()) > ((int)(rhs).size());
});
vector<vector<int> > prox;
int remain = n + 1;
for (int j = 0; j < ((int)(v).size()); j++) {
int x = min(((int)(v[j]).size()) - 1, a[i]);
if (remain - ((int)(v[j]).size()) < a[i] - x) {
x = a[i] + ((int)(v[j]).size()) - remain;
}
if (x > 0) {
prox.emplace_back();
for (int k = 0; k < x; k++) {
prox.back().push_back(v[j][k]);
ans[v[j][k]][i] = 1;
}
}
if (((int)(v[j]).size()) - x > 0) {
prox.emplace_back();
for (int k = x; k < ((int)(v[j]).size()); k++) {
prox.back().push_back(v[j][k]);
ans[v[j][k]][i] = 0;
}
}
remain -= ((int)(v[j]).size());
a[i] -= x;
}
v = prox;
}
printf("%d\n", n + 1);
for (int i = 0; i < n + 1; i++, printf("\n"))
for (int j = 0; j < n; j++) printf("%c", '0' + ans[i][j]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt[100015], x[100015], y[100015], z[100015];
vector<int> a[100015];
int getpos(int i, int u) {
if (x[i] == u) return 0;
if (y[i] == u) return 1;
if (z[i] == u) return 2;
}
void dfs(int u, int v) {
cout << u << ' ';
if (cnt[v] == 0) {
cout << v;
return;
}
for (int i : a[u])
if (i) {
--cnt[x[i]];
--cnt[y[i]];
--cnt[z[i]];
int k = 3 - getpos(i, u) - getpos(i, v);
for (int &j : a[x[i]])
if (j == i) j = 0;
for (int &j : a[y[i]])
if (j == i) j = 0;
for (int &j : a[z[i]])
if (j == i) j = 0;
if (k == 0) dfs(v, x[i]);
if (k == 1) dfs(v, y[i]);
if (k == 2) dfs(v, z[i]);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n - 2; ++i)
cin >> x[i] >> y[i] >> z[i], a[x[i]].push_back(i), a[y[i]].push_back(i),
a[z[i]].push_back(i), ++cnt[x[i]], ++cnt[y[i]], ++cnt[z[i]];
for (int i = 1; i <= n; ++i)
if (cnt[i] == 1) {
if (cnt[x[a[i][0]]] == 2) dfs(i, x[a[i][0]]);
if (cnt[y[a[i][0]]] == 2) dfs(i, y[a[i][0]]);
if (cnt[z[a[i][0]]] == 2) dfs(i, z[a[i][0]]);
}
}
| 3 |
#include <bits/stdc++.h>
int main(int argc, char *argv[]) {
int i, n;
long long res = 1;
scanf("%d", &n);
for (i = n; i < 2 * n - 1; i++) res *= i;
for (i = 2; i < n; i++) res /= i;
printf("%d", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, M, C, a[100009];
int res(int p1, int p2, int p3) {
int s = 0;
if (p1 > p2) s += (p2 - p1);
if (p2 > p3) s += (p3 - p2);
return s;
}
void solve(int s) {
int G;
cin >> G;
if (G <= C / 2) {
for (int i = 1; i <= N; i++) {
if (a[i] == 0 || a[i] > G) {
cout << i << endl;
a[i] = G;
break;
}
}
} else {
for (int i = N; i >= 1; i--) {
if (a[i] == 0 || a[i] < G) {
cout << i << endl;
a[i] = G;
break;
}
}
}
}
bool check() {
for (int i = 1; i <= N - 1; i++) {
if (a[i] > a[i + 1] || a[i] == 0 || a[i + 1] == 0) return false;
}
return true;
}
int main() {
cin >> N >> M >> C;
for (int i = 1; i <= M; i++) {
solve(i);
if (check() == true) break;
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.