solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[1005];
bool vis[1005];
void dfs(int x) {
vis[x] = true;
for (auto i : adj[x]) {
if (vis[i]) continue;
dfs(i);
}
}
int main() {
cin >> n >> m;
int ai, bi;
for (int i = 0; i < m; i++) {
cin >> ai >> bi;
ai--;
bi--;
adj[ai].push_back(bi);
adj[bi].push_back(ai);
}
if (m != n - 1) {
cout << "no" << endl;
return 0;
}
dfs(0);
for (int i = 0; i < n; i++) {
if (!vis[i]) {
cout << "no" << endl;
return 0;
}
}
cout << "yes" << endl;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int moves, matrix[5][5], horizontal = 2, vertical = 2;
for (int i = 0; i < 5; i++)
scanf("%d %d %d %d %d", &matrix[i][0], &matrix[i][1], &matrix[i][2],
&matrix[i][3], &matrix[i][4]);
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (matrix[i][j] == 1) {
horizontal = j;
vertical = i;
break;
}
}
}
moves = abs(horizontal - 2) + abs(vertical - 2);
printf("%d", moves);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int poss(char *s1, char *s2, int l, int flag2) {
int flag = 1, count = 0;
for (int i = 0; i < 7; ++i) {
if (s2[i] == '0' && s1[i] == '1')
flag = 0;
else {
if (s2[i] == '1' && s1[i] == '0') count++;
}
}
if (flag2 == 1)
if (count != l)
flag = 0;
else {
if (count > l) flag = 0;
}
if (flag) return count;
return -1;
}
int main() {
char *v1[10] = {"1110111", "0010010", "1011101", "1011011", "0111010",
"1101011", "1101111", "1010010", "1111111", "1111011"};
int n, k;
cin >> n >> k;
char *v2[n];
for (int i = 0; i < n; ++i) {
v2[i] = (char *)malloc(sizeof(char) * 8);
scanf("%s", v2[i]);
}
int b[n][k + 1][10];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k + 1; ++j) {
for (int l = 0; l < 10; ++l) b[i][j][l] = 0;
}
}
int bi[n][k + 1];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k + 1; ++j) bi[i][j] = -1;
}
for (int j = 0; j < k + 1; ++j) {
for (int r = 0; r < 10; ++r) {
b[0][j][r] = poss(v2[n - 1], v1[r], j, 1);
if (b[0][j][r] != -1) bi[0][j] = r;
}
}
for (int i = 1; i < n; ++i) {
for (int j = 0; j < k + 1; ++j) {
for (int r = 0; r < 10; ++r) {
int t = poss(v2[n - 1 - i], v1[r], j, 0);
if (t != -1 && t <= j) {
if (bi[i - 1][j - t] != -1) {
b[i][j][r] = t;
bi[i][j] = r;
}
}
}
}
}
int st = n - 1, c = k;
vector<int> v3;
while (st > -1) {
v3.push_back(bi[st][c]);
c = c - b[st][c][bi[st][c]];
st--;
}
if (v3[0] == -1)
cout << "-1\n";
else {
for (int i = 0; i < n; ++i) cout << v3[i];
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long m[9], ans;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (int)n; i++) m[(i + 1) % 9]++, ans -= n / (i + 1);
for (int i = 0; i < (int)9; i++)
for (int j = 0; j < (int)9; j++) ans += m[i] * m[j] * m[(i * j) % 9];
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include "iostream"
#include "algorithm"
#include "cstring"
#include "cstdio"
#include "cmath"
#include "vector"
#include "map"
#include "set"
#include "queue"
using namespace std;
#define MAXN 104
//#define int long long
#define rep(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++i)
#define per(i, a, b) for (int i = (a), i##end = (b); i >= i##end; --i)
#define pii pair<int,int>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define vi vector<int>
#define all(x) (x).begin() , (x).end()
#define mem( a ) memset( a , 0 , sizeof a )
typedef long long ll;
int n , m;
int A[MAXN][MAXN];
void solve() {
cin >> n >> m;
rep( i , 1 , n ) rep( j , 1 , m ) scanf("%d",A[i] + j);
rep( t , 2 , n + m ) {
int s = 0;
rep( i , max( 1 , t - m ) , min( n , t - 1 ) ) {
int j = t - i;
s ^= A[i][j];
}
if( s ) { puts("Ashish"); return; }
}
puts("Jeel");
}
signed main() {
int T;cin >> T;while( T-- ) solve();
// solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int> > graph;
map<int, vector<int> > cons;
bool arr[405][405];
int inf = 1e6;
int n, m;
int level[1000];
int bfs(int u) {
memset(level, -1, sizeof level);
queue<int> q;
q.push(u);
level[u] = 0;
while (!q.empty()) {
int from = q.front();
q.pop();
for (auto v : graph[from]) {
if (level[v] == -1) {
level[v] = level[from] + 1;
q.push(v);
}
}
}
if (level[n] == -1) return inf;
return level[n];
}
int bfs_bus(int u) {
memset(level, -1, sizeof level);
queue<int> q;
q.push(u);
level[u] = 0;
while (!q.empty()) {
int from = q.front();
q.pop();
for (auto v : cons[from]) {
if (level[v] == -1) {
level[v] = level[from] + 1;
q.push(v);
}
}
}
if (level[n] == -1) return inf;
return level[n];
}
int main() {
int u, v;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
arr[u][v] = true;
arr[v][u] = true;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (!arr[i][j]) {
cons[i].push_back(j);
cons[j].push_back(i);
}
}
}
u = bfs(1);
v = bfs_bus(1);
int result = max(u, v);
if (result == inf) {
cout << -1 << endl;
exit(0);
}
cout << result << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ggg(unsigned long long x, unsigned long long y) {
unsigned long long temp;
if (x < y) {
temp = x;
x = y;
y = temp;
}
if (x % y == 0)
return 1;
else
return 0;
}
int main() {
int T;
unsigned long long l, r;
cin >> T;
for (int i = 0; i < T; i++) {
cin >> l >> r;
while (!ggg(l, r)) {
r = 2 * l;
}
cout << l << " " << r << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100010;
const int mod = 1000000007;
const double eps = 1e-8;
const double Pi = 2 * acos(0.0);
double rec[M], ans;
double fix(int x, int y) {
if (y == 0) return x > 0 ? 0.0 : 180.0;
if (x == 0) return y > 0 ? 90.0 : 270.0;
double tmp = atan(1.0 * y / x) / Pi * 180.0;
if (x > 0 && y > 0)
return tmp;
else if (x < 0 && y > 0)
return 180.0 + tmp;
else if (x < 0 && y < 0)
return 180.0 + tmp;
else
return 360.0 + tmp;
}
int main() {
ios::sync_with_stdio(0);
int n, x, y;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
rec[i] = fix(x, y);
}
sort(rec, rec + n);
ans = rec[n - 1] - rec[0];
for (int i = 1; i < n; i++) {
double tmp = 360.0 - rec[i] + rec[i - 1];
ans = min(ans, tmp);
}
printf("%.10lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio();
cin.tie(NULL);
cout.tie(NULL);
string str;
cin >> str;
long long n, a = 4, b = 5, c = 6, d = 3, e = 2, f = 1, i;
char s;
long long len = str.size();
s = str[len - 1];
n = 0;
for (i = 0; i < len - 1; i++) {
n = (10 * n) + (str[i] - 48);
}
long long ans, val = (n % 2);
if (n % 2 == 0) {
if (s == 'a') {
val = a + 7;
} else if (s == 'b') {
val = b + 7;
} else if (s == 'c') {
val = c + 7;
} else if (s == 'd') {
val = d + 7;
} else if (s == 'e') {
val = e + 7;
} else if (s == 'f') {
val = f + 7;
}
} else {
if (s == 'a') {
val = a;
} else if (s == 'b') {
val = b;
} else if (s == 'c') {
val = c;
} else if (s == 'd') {
val = d;
} else if (s == 'e') {
val = e;
} else if (s == 'f') {
val = f;
}
}
ans = (16 * ((n - 1) / 4)) + val;
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool debug = false;
int k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
struct node {
long long p, s, id;
bool operator<(const node &b) const { return p > b.p; }
};
node shoe[100005], cus[100005];
map<long long, int> mp;
vector<int> g[100005];
long long ans;
int match[100005];
bool vis[100005];
bool dfs(int x) {
for (int child : g[x]) {
if (match[child] != x && !vis[child]) {
vis[child] = 1;
if (match[child] == -1 || dfs(match[child])) {
match[child] = x;
return 1;
}
}
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &shoe[i].p, &shoe[i].s);
shoe[i].id = i;
}
sort(shoe + 1, shoe + n + 1);
for (int i = 1; i <= n; i++) mp[shoe[i].s] = i;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%lld%lld", &cus[i].p, &cus[i].s);
cus[i].id = i;
if (mp[cus[i].s] && shoe[mp[cus[i].s]].p <= cus[i].p) {
g[(mp[cus[i].s])].push_back(i);
}
if (mp[cus[i].s + 1] && shoe[mp[cus[i].s + 1]].p <= cus[i].p) {
g[mp[cus[i].s + 1]].push_back(i);
}
}
memset(match, -1, sizeof match);
int av = 0;
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof vis);
if (dfs(i)) {
ans += shoe[i].p;
av++;
}
}
printf("%lld\n%d\n", ans, av);
for (int i = 1; i <= m; i++)
if (match[i] != -1) {
printf("%d %lld\n", i, shoe[match[i]].id);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ans;
int main() {
int d, n, u, i, prev;
cin >> d >> n;
for (i = 0; i < n; i++) {
cin >> u;
if (i and prev != 1) ans += d - prev + 1;
prev = u + 1;
if (prev > d) prev -= d;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = (s << 3) + (s << 1) + (ch ^ 48);
ch = getchar();
}
return s * w;
}
const int N = 1001000;
typedef struct Edge {
int x, y, w, id;
} Edge;
int n, m, q, t, len;
long long k;
char str[N];
int a[N], top;
int pre[N], last[N];
int main() {
int T = 1;
while (T--) {
k = read();
scanf("%s", str + 1);
int len = strlen(str + 1);
if (k == 0) {
int cnt = 0, l = 1;
long long sum = 0;
str[len + 1] = '1';
for (int i = 1; i <= len + 1; i++) {
if (str[i] == '0') {
cnt++;
continue;
} else {
sum += (1 + cnt) * (long long)cnt / 2;
cnt = 0;
}
}
if (1 == 0)
printf("%lld ", sum);
else
printf("%lld\n", sum);
;
return 0;
}
for (int i = 1; i <= len; i++)
if (str[i] == '1') a[++top] = i;
long long sum = 0;
if (top < k) {
printf("0\n");
return 0;
}
int r = k, l = 1;
a[0] = 0;
a[top + 1] = len + 1;
while (r <= top) {
int m1 = a[l] - a[l - 1];
int m2 = a[r + 1] - a[r];
sum += (long long)m1 * m2;
r++;
l++;
}
printf("%lld\n", sum);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p);
template <class T>
ostream &operator<<(ostream &os, vector<T> &v);
template <class T>
ostream &operator<<(ostream &os, set<T> &v);
template <class T1, class T2>
ostream &operator<<(ostream &os, map<T1, T2> &v);
const int N = 3e5 + 5;
const long long mod = 998244353;
long long bigmod(long long a, long long b) {
a %= mod;
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % mod;
}
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long fact[N];
void init() {
fact[0] = 1;
for (long long i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % mod;
}
long long getncr(long long n, long long r) {
if (n < r || n < 0 || r < 0) {
return 0;
}
long long up = fact[n];
long long down = (fact[r] * fact[n - r]) % mod;
return (up * bigmod(down, mod - 2)) % mod;
}
long long add(long long x, long long y) {
if (x >= mod) x %= mod;
if (y >= mod) y %= mod;
x += y;
if (x >= mod) x -= mod;
return x;
}
long long sub(long long x, long long y) {
if (x >= mod) x %= mod;
if (y >= mod) y %= mod;
x -= y;
if (x < 0) x += mod;
return x;
}
long long gun(long long x, long long y) {
if (x >= mod) x %= mod;
if (y >= mod) y %= mod;
return (x * y) % mod;
}
long long vag(long long x, long long y) {
if (x >= mod) x %= mod;
if (y >= mod) y %= mod;
return (x * bigmod(y, mod - 2)) % mod;
}
void TEST_CASES(int cas) {
init();
long long n;
cin >> n;
n *= 2;
long long half = n / 2;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
long long ans = 0;
for (long long i = 0, j = n - 1; i < half; i++, j--) {
ans = add(ans, a[j] - a[i]);
}
ans = gun(ans, getncr(n, half));
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1, cas = 0;
while (t--) {
TEST_CASES(++cas);
}
return 0;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << "{" << p.first << ", " << p.second << "} ";
return os;
}
template <class T>
ostream &operator<<(ostream &os, vector<T> &v) {
os << "[ ";
for (int i = 0; i < v.size(); i++) {
os << v[i] << " ";
}
os << " ]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> &v) {
os << "[ ";
for (T i : v) {
os << i << " ";
}
os << " ]";
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, map<T1, T2> &v) {
for (auto i : v) {
os << "Key : " << i.first << " , Value : " << i.second << endl;
}
return os;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int maxn = 210000, BUBEN = 300;
short a[2][maxn];
short getx(int i) { return a[0][i] ^ a[1][i]; }
vector<vector<short> > difs, shifts;
vector<vector<vector<int> > > cnts;
int bad = 0, ans = 0;
int n, k, q;
void change_bad(int p, int d) {
int i = difs[p].size() - 1;
if (difs[p][i] != shifts[p][i / BUBEN]) bad += d;
}
void change_dif(int p, int i, short x) {
if (difs[p][i] == shifts[p][i / BUBEN]) --ans;
if (!cnts[p].empty()) --cnts[p][i / BUBEN][difs[p][i]];
difs[p][i] ^= x;
if (!cnts[p].empty()) ++cnts[p][i / BUBEN][difs[p][i]];
if (difs[p][i] == shifts[p][i / BUBEN]) ++ans;
}
void change_shift(int p, int i, short x) {
assert(!cnts[p].empty());
ans -= cnts[p][i][shifts[p][i]];
shifts[p][i] ^= x;
ans += cnts[p][i][shifts[p][i]];
}
void change(int p, int i, short x) {
change_bad(p, -1);
for (; i < difs[p].size() && i % BUBEN; ++i) change_dif(p, i, x);
if (i != difs[p].size()) {
i /= BUBEN;
for (; i < shifts[p].size(); ++i) change_shift(p, i, x);
}
change_bad(p, 1);
}
int get_ans() {
if (bad) return -1;
return n - ans;
}
int dumb() {
vector<int> px(k);
int ans = n + 1;
for (int i = 0; i < (int)(n + 1); ++i) {
px[i % k] ^= getx(i) ^ getx(i + 1);
if (!px[i % k]) --ans;
}
if (*max_element((px).begin(), (px).end())) return -1;
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
cin >> n >> k >> q;
for (int i = 0; i < (int)(2); ++i)
for (int j = 0; j < (int)(n); ++j) cin >> a[i][j + 1];
difs.assign(k, vector<short>(1));
shifts.resize(k);
cnts.resize(k);
ans = n;
for (int i = 0; i < (int)(n + 1); ++i) {
int p = i % k;
short v = getx(i) ^ getx(i + 1);
short z = difs[p].back();
difs[p].push_back(z ^ v);
if (difs[p].back()) --ans;
}
int ts = 0;
for (int i = 0; i < (int)(k); ++i) {
int len = difs[i].size();
int sz = (len + BUBEN - 1) / BUBEN;
shifts[i].resize(sz);
if (len >= BUBEN)
cnts[i].assign(sz, vector<int>(1 << 14)), ts += (sz << 14);
if (!cnts[i].empty())
for (int j = 0; j < (int)(len); ++j) ++cnts[i][j / BUBEN][difs[i][j]];
if (difs[i].back()) ++bad;
}
cerr << ts << '\n';
cout << get_ans() << '\n';
for (int i = 0; i < (int)(q); ++i) {
char c;
int j;
short x;
cin >> c >> j >> x;
int cc = c - 'a';
short xx = x;
x ^= a[cc][j];
a[cc][j] = xx;
change(j % k, j / k + 1, x);
change((j - 1) % k, (j - 1) / k + 1, x);
cout << get_ans() << '\n';
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b, w, x, c;
long long int c_after(long long int t) { return c - t; }
long long int a_after(long long int t) {
long long int b_after = b - x * t;
if (b_after >= 0) return a;
return a - (((-b_after - 1) / w) + 1);
}
bool cond(long long int t) { return c_after(t) <= a_after(t); }
int main() {
cin >> a >> b >> w >> x >> c;
long long int low = -1, high = 1;
while (!cond(high)) high *= 2;
while (low + 1 < high) {
long long int mid = (low + high + 1) / 2;
if (cond(mid)) {
high = mid;
} else {
low = mid;
}
}
assert(cond(high));
assert(high == 0 || !cond(high - 1));
cout << high << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T_container, typename T = typename enable_if<
!is_same<T_container, string>::value,
typename T_container::value_type>::type>
ostream& operator<<(ostream& os, const T_container& v) {
string sep;
for (const T& x : v) os << sep << x, sep = " ";
return os;
}
const int mxN = 18 * 18 + 18;
const long long oo = 1e16;
const int mxM = 2000;
struct flow {
struct edge {
long long f, c;
int to;
};
vector<vector<int>> adj;
vector<edge> edges;
int n;
long long scale = 0;
flow(int _n) {
n = _n;
adj.resize(n);
}
void addEdge(int a, int b, long long w, bool directed = true) {
scale = max(w, scale);
adj[a].push_back((int)edges.size());
adj[b].push_back((int)edges.size() + 1);
edges.push_back({0, w, b});
edges.push_back({0, directed ? 0 : w, a});
}
bitset<mxN> visited;
void dfs2(int at = 0) {
visited[at] = true;
for (int i : adj[at]) {
auto& e = edges[i];
if (e.c != e.f and !visited[e.to]) {
dfs2(e.to);
}
}
}
long long dfs(int at = 0, long long mn = oo) {
if (at == n - 1) return mn;
visited[at] = true;
for (int i : adj[at]) {
auto& e = edges[i];
if (!visited[e.to] and e.f + scale <= e.c) {
long long tmp = min(mn, e.c - e.f);
tmp = min(tmp, dfs(e.to, tmp));
if (tmp) {
e.f += tmp;
auto& o = edges[i ^ 1];
o.f -= tmp;
return tmp;
}
}
}
return 0;
}
long long solve() {
long long res = 0;
while (true) {
visited.reset();
long long tmp = dfs();
if (tmp != 0)
res += tmp;
else {
scale /= 2;
if (!scale) break;
}
}
return res;
}
};
const long long big = 1e12;
int id[18][19];
int main() {
int n, m;
cin >> n >> m;
int total = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j <= n; ++j) id[i][j] = total++;
flow f(total + 1);
int T = total;
int c[18] = {};
for (int i = 0; i < m; ++i) {
int x, y, w;
cin >> x >> y >> w, --x, --y;
c[x] += w, c[y] -= w;
for (int j = 0; j < n; ++j) f.addEdge(id[y][j], id[x][j + 1], oo);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
f.addEdge(id[i][j], id[i][j + 1], c[i] * j + big);
f.addEdge(0, id[i][0], oo);
f.addEdge(id[i][n], T, oo);
}
f.solve();
f.visited.reset();
f.dfs2();
vector<int> ans(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (f.visited[id[i][j]]) ans[i] = j;
}
}
cout << ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
#define inf 1000000000000000005
#define mod 1000000007
#define pi 3.1415926536
#define all(c) (c).begin(), (c).end()
ll fpow(ll n, ll k, ll p = mod) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n%p; n = n * n%p;} return r;}
ll inv(ll a, ll p = mod) {return fpow(a, p - 2, p);}
int n,m,arr[100009],see[100009];
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int t;
cin >> t;
while(t--){
cin >> n>>m;
for(int i=1;i<=n;i++){
cin >> arr[i];
see[i] = 0;
}
for(int i=0;i<100009;i++){
see[i] = 1;
}
if(arr[n]!=n){
see[n] = 0;
}
for(int i=n-1;i>=1;i--){
if(see[i+1]==1){
if(arr[i]==i){
see[i] = 1;
}
else{
see[i] = 0;
}
}
else{
see[i] = 0;
}
}
vector<double> v1;
vector<double> v2;
for(int i=0;i<m;i++){
int nn;
double kk;
cin >> nn>>kk;
if(see[nn+1]){
v1.push_back(kk);
if(v2.size()>0){
double t1 = v2.back();
double t2 = double((double)1.0-kk);
t2 = t2*t1;
v2.push_back(t2);
}
else{
double t2 = double((double)1.0-kk);
v2.push_back(t2);
}
}
}
if(see[1]){
double ans = 1.0;
cout<<fixed;
cout<<setprecision(6);
cout<<ans<<"\n";
continue;
}
double ans = 0.0;
if(v1.size()>0){
ans+=v1[0];
}
for(int i=1;i<v1.size();i++){
double kk = v2[i-1];
kk *= v1[i];
ans+=kk;
}
cout<<fixed;
cout<<setprecision(6);
cout<<ans<<"\n";
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, num;
cin >> n >> k;
if (k < n / 2)
cout << -1;
else if (n == 1) {
if (k == 0)
cout << 1;
else
cout << -1;
} else if (k == n / 2) {
for (long long i = 0; i < n; i++) cout << i + 1 << " ";
} else if (k == n / 2 + 1) {
num = 2;
cout << num << " " << 2 * num << " ";
num = 2 * num;
for (long long i = 2; i < n; i++) cout << ++num << " ";
} else {
num = k - n / 2 + 1;
cout << num << " " << 2 * num << " ";
num = 2 * num;
for (long long i = 2; i < n; i++) cout << ++num << " ";
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a[4], i = 0;
scanf("%d %d %d %d", &a[i], &a[i + 1], &a[i + 2], &a[i + 3]);
if (a[i] == a[i + 1] + a[i + 2] + a[i + 3]) {
printf("yes");
} else if (a[i] + a[i + 1] == a[i + 2] + a[i + 3]) {
printf("yes");
} else if (a[i] + a[i + 1] + a[i + 2] == a[i + 3]) {
printf("yes");
} else if (a[i] + a[i + 2] == a[i + 1] + a[i + 3]) {
printf("yes");
} else if (a[i] + a[i + 3] == a[i + 1] + a[i + 2]) {
printf("yes");
} else if (a[i + 2] == a[i] + a[i + 1] + a[i + 3]) {
printf("yes");
} else if (a[i + 1] == a[i + 3] + a[i] + a[i + 2]) {
printf("yes");
} else {
printf("no");
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, i, j;
char str[3000];
scanf("%d", &n);
scanf("%s", str);
int count = 0;
int no_turns = strlen(str) / n;
for (i = 1; i <= no_turns; i++) {
j = i * n;
if ((str[j - 1] == str[j - 2]) && (str[j - 1] == str[j - 3]) &&
(j < strlen(str)))
count++;
}
printf("%d", count);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int p[250010], d[250010], f[250010][18];
vector<int> order, av[250010], bv[250010];
void dfs1(int x, int pa) {
p[x] = pa;
for (int i = 0; i < av[x].size(); i++) {
int y = av[x][i];
if (y == pa) continue;
dfs1(y, x);
}
if (x > 1) order.push_back(x);
}
void dfs(int x, int pa) {
f[x][0] = pa;
d[x] = d[pa] + 1;
for (int i = 1; i < 18; i++) f[x][i] = f[f[x][i - 1]][i - 1];
for (int i = 0; i < bv[x].size(); i++) {
int y = bv[x][i];
if (y == pa) continue;
dfs(y, x);
}
}
int anc(int x, int y) {
for (int i = 31 - __builtin_clz(y); i >= 0; i--)
if (y & (1 << i)) x = f[x][i];
return x;
}
int lca(int x, int y) {
if (d[x] > d[y])
x = anc(x, d[x] - d[y]);
else if (d[y] > d[x])
y = anc(y, d[y] - d[x]);
if (x == y) return x;
for (int i = 31 - __builtin_clz(d[x]); i >= 0; i--)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
int root[250010];
int find(int x) { return root[x] == x ? x : root[x] = find(root[x]); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1, x, y; i < n; i++) {
cin >> x >> y;
bv[x].push_back(y);
bv[y].push_back(x);
}
dfs(1, 0);
for (int i = 1, x, y; i < n; i++) {
cin >> x >> y;
av[x].push_back(y);
av[y].push_back(x);
}
dfs1(1, 0);
vector<pair<pair<int, int>, pair<int, int> > > ans;
for (int i = 1; i <= n; i++) root[i] = i;
for (int i = 0; i < order.size(); i++) {
int x = order[i];
int y = p[x];
int z = lca(x, y);
pair<int, int> p1(x, y);
if (find(z) == x) {
for (int i = 18 - 1; i >= 0; i--) {
int w = f[y][i];
if (d[w] <= d[z]) continue;
if (find(w) == x)
z = w;
else
y = w;
}
ans.push_back(
pair<pair<int, int>, pair<int, int> >(p1, pair<int, int>(y, z)));
root[x] = find(y);
} else {
y = x;
for (int i = 18 - 1; i >= 0; i--) {
int w = f[x][i];
if (d[w] <= d[z]) continue;
if (find(w) == y)
x = w;
else
z = w;
}
ans.push_back(
pair<pair<int, int>, pair<int, int> >(p1, pair<int, int>(x, z)));
root[y] = find(z);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].second.first << ' ' << ans[i].second.second << ' ';
cout << ans[i].first.first << ' ' << ans[i].first.second << endl;
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, u;
int s[200010], id[200010], be[200010], f[200010][6], h[200010][6], a[200010],
b[200010], en[200010];
inline bool judge() {
int A = u - j, B = k - s[i], C = be[i] - A - B, D = b[i] - b[i - 1] - 1;
return 2 * D <= C && C <= 5 * D;
}
inline void tian(int x) {
int i, j, k;
for (i = m; i; i--) {
int A = x - s[i];
for (j = 1; j <= A; j++) a[id[i] - j] = b[i];
A = f[i][x] - h[i][x];
for (j = 1; j <= A; j++) a[en[i - 1] + j] = b[i - 1];
A = b[i] - b[i - 1] - 1;
if (!A) {
x = h[i][x];
continue;
}
int D = be[i] - (x - s[i]) - (f[i][x] - h[i][x]);
int B = D / A, C = en[i - 1] + f[i][x] - h[i][x] + 1;
for (j = 1; j <= A; j++)
for (k = 1; k <= (j <= D % A) + B; k++) a[C++] = b[i - 1] + j;
x = h[i][x];
}
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
{
for (i = 1; i <= n;) {
for (; i <= n && !a[i]; i++)
;
if (i > n) break;
for (j = i + 1; j <= n && !a[j]; j++)
;
if (a[i] == a[j])
for (k = i + 1; k <= j - 1; k++) a[k] = a[i];
i = j;
}
id[0] = -4, s[0] = 5;
for (i = 1; i <= n;) {
int A = i;
for (; i <= n && !a[i]; i++)
;
if (i > n) break;
for (j = i + 1; j <= n && a[i] == a[j]; j++)
;
id[++m] = i;
s[m] = j - i;
be[m] = i - A;
b[m] = a[i];
en[m] = j - 1;
i = j;
}
}
{
f[0][5] = 1;
for (i = 1; i <= m; i++)
for (j = s[i - 1]; j <= 5; j++)
if (f[i - 1][j])
for (u = max(2, j); u <= 5; u++)
for (k = s[i]; k <= 5; k++)
if (judge()) f[i][k] = u, h[i][k] = j;
}
{
for (i = 5; i; i--)
if (f[m][i]) {
if (i == 5 && en[m] + 1 == n) continue;
if (i == 1 && en[m] == n) continue;
int A = en[m] + 1, B = b[m];
if (i == 1) a[A++] = B;
for (j = A; j < n; j += 2) a[j] = a[j + 1] = ++B;
for (; j <= n; j++) a[j] = a[j - 1];
tian(i);
printf("%d\n", B);
for (j = 1; j <= n; j++) printf("%d ", a[j]);
return 0;
}
}
printf("-1\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, s;
cin >> n >> s;
long long a, b, c;
c = -1;
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (a < s && b > 0) {
c = (100 - b) > c ? (100 - b) : c;
} else if (a <= s && b == 0) {
c = c > 0 ? c : 0;
}
}
cout << c;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a(2230, '5'), b(2229, '4');
b += '5';
cout << a << ' ' << b << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
static char buf[100000], *p1 = buf, *p2 = buf;
inline int read(void) {
register char ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
register int res = 0;
while (ch < '0' || '9' < ch)
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
while ('0' <= ch && ch <= '9')
res = 10 * res + ch - '0',
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
return res;
}
const int MAXM = 3e5 + 5;
struct Node {
long long x, y;
inline Node(register long long x = 0, register long long y = 0) : x(x), y(y) {
return;
}
inline Node operator-(const Node& a) const { return Node(x - a.x, y - a.y); }
inline double operator*(const Node& a) {
return 1.0 * x * a.y - 1.0 * y * a.x;
}
};
long long K, B;
inline long long Calc(const Node& a) { return a.y + K * a.x + B; }
long long n;
int m;
Node S[MAXM];
int main(void) {
n = read(), m = read();
register int top = 0;
S[top = 1] = Node(0, 0);
while (m--) {
static int type;
static long long k, b, s;
type = read();
switch (type) {
case 1: {
k = read();
n += k;
S[top = 1] = Node(0, 0);
K = B = 0;
break;
}
case 2: {
k = read();
Node t(n, -(n * K + B));
n += k;
while (top > 1 && (t - S[top - 1]) * (S[top] - S[top - 1]) > -1e-6)
--top;
S[++top] = t;
break;
}
case 3: {
b = read(), s = read();
B += b, K += s;
break;
}
}
while (top > 1 && Calc(S[top]) >= Calc(S[top - 1])) --top;
printf("%lld %lld\n", S[top].x + 1, Calc(S[top]));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long numz[22] = {0}, zero = 0, n, i, j, count = 0, l;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> l;
if (l < 0)
numz[-1 * l]++;
else if (l > 0)
numz[l + 10]++;
else
numz[0]++;
}
for (j = 1; j < 11; j++) count += numz[j] * numz[j + 10];
while (numz[0]) count += --numz[0];
cout << count << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, len, dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
char d[17][17];
bool vis[17][17][1 << 16];
struct node {
int x, y, sta, step;
} seg[12];
int f_dir(node a, node b) {
if (a.x == b.x)
return a.y > b.y ? 0 : 1;
else
return a.x > b.x ? 2 : 3;
}
int test(node a, node b) {
if (a.x < 1 || a.x > n || a.y < 1 || a.y > m || d[a.x][a.y] == '#' ||
vis[a.x][a.y][a.sta])
return 0;
node tmp = b;
for (int i = 1; i < len - 1; i++) {
int sta = (b.sta >> (len * 2 - i * 2 - 2)) & 3;
if (sta == 0)
b.y--;
else if (sta == 1)
b.y++;
else if (sta == 2)
b.x--;
else if (sta == 3)
b.x++;
if (a.x == b.x && a.y == b.y) return 0;
}
return 1;
}
int bfs() {
queue<node> Q;
int sta = 0;
for (int i = 2; i <= len; i++) {
int tmp = f_dir(seg[i - 1], seg[i]);
sta = (sta << 2) | tmp;
}
seg[1].sta = sta;
seg[1].step = 0;
Q.push(seg[1]);
while (!Q.empty()) {
node now = Q.front();
Q.pop();
node next;
for (int i = 0; i < 4; i++) {
next.x = now.x + dir[i][0];
next.y = now.y + dir[i][1];
int tt = f_dir(next, now);
next.sta = (now.sta >> 2) | (tt << (len * 2 - 4));
next.step = now.step + 1;
int t = test(next, now);
if (!t) continue;
vis[next.x][next.y][next.sta] = 1;
if (d[next.x][next.y] == '@') return next.step;
Q.push(next);
}
}
return -1;
}
int main() {
scanf("%d%d", &n, &m);
len = 0;
for (int i = 1; i <= n; i++) scanf("%s", d[i] + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (d[i][j] > '0' && d[i][j] <= '9') {
len = max(len, d[i][j] - '0');
seg[d[i][j] - '0'].x = i;
seg[d[i][j] - '0'].y = j;
}
}
}
printf("%d\n", bfs());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, sum, x;
cin >> n;
vector<long long> A(n);
sum = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
sum += A[i];
}
sort(A.begin(), A.end(), greater<int>());
for (int i = 0; i < n; i++) {
A[i] = sum - A[i];
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> x;
cout << A[x - 1] << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXX = 1e5 + 5, INF = 1e9 + 7;
long long n, m, k, i, j, s, ans, l, r;
vector<long long> a(MAXX), b(MAXX);
char ch;
vector<int> v;
string s1, s2, s3;
vector<bool> u(MAXX);
map<long long, int> mp;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> s;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
l = 0, r = n + 1;
ans = 0;
while (r - l > 1) {
int z = (l + r) / 2;
long long t = 0;
for (i = 1; i <= n; i++) b[i] = a[i] + i * z;
sort(b.begin() + 1, b.begin() + n + 1);
for (i = 1; i <= z; i++) t += b[i];
if (t <= s) {
ans = t;
l = z;
} else
r = z;
}
cout << l << ' ' << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 998244353;
const int FFTN = (1 << 19);
const int N = FFTN + 5;
int n, x, y, L;
int a[N], b[N], R[N];
int w[N], W[N], f[N * 2];
unsigned long long p[N];
int power(int x, int y) {
int s = 1;
for (; y; y /= 2, x = 1ll * x * x % mo)
if (y & 1) s = 1ll * s * x % mo;
return s;
}
void FFTinit() {
W[0] = 1;
W[1] = power(3, (mo - 1) / FFTN);
for (int i = (int)(2); i <= (int)(N - 1); i++)
W[i] = 1ll * W[i - 1] * W[1] % mo;
}
void DFT(int *a, int n) {
for (int i = (int)(0); i <= (int)(n - 1); i++) p[R[i]] = a[i];
for (int d = 1; d < n; d <<= 1) {
int len = FFTN / (d << 1);
for (int i = 0, j = 0; i < d; i++, j += len) w[i] = W[j];
for (int i = 0; i < n; i += (d << 1))
for (int j = 0; j < d; j++) {
int y = p[i + j + d] * w[j] % mo;
p[i + j + d] = p[i + j] + mo - y;
p[i + j] += y;
}
if (d == 1 << 10)
for (int i = (int)(0); i <= (int)(n - 1); i++) p[i] %= mo;
}
for (int i = (int)(0); i <= (int)(n - 1); i++) a[i] = p[i] % mo;
}
void IDFT(int *a, int n) {
for (int i = (int)(0); i <= (int)(n - 1); i++) p[R[i]] = a[i];
for (int d = 1; d < n; d <<= 1) {
int len = FFTN / (d << 1);
for (int i = 0, j = FFTN; i < d; i++, j -= len) w[i] = W[j];
for (int i = 0; i < n; i += (d << 1))
for (int j = 0; j < d; j++) {
int y = p[i + j + d] * w[j] % mo;
p[i + j + d] = p[i + j] + mo - y;
p[i + j] += y;
}
if (d == 1 << 10)
for (int i = (int)(0); i <= (int)(n - 1); i++) p[i] %= mo;
}
int v = power(n, mo - 2);
for (int i = (int)(0); i <= (int)(n - 1); i++) a[i] = p[i] * v % mo;
}
int main() {
FFTinit();
scanf("%d%d%d", &n, &x, &y);
L = 524288;
for (int i = (int)(1); i <= (int)(n + 1); i++) {
int p;
scanf("%d", &p);
a[p] = b[(1 << 18) - p] = 1;
}
for (int i = (int)(0); i <= (int)(L - 1); i++)
R[i] = (R[i >> 1] >> 1) | ((i & 1) ? (L >> 1) : 0);
DFT(a, L);
DFT(b, L);
for (int i = (int)(0); i <= (int)(L - 1); i++) a[i] = 1ll * a[i] * b[i] % mo;
IDFT(a, L);
memset(f, -1, sizeof(f));
for (int i = (int)(1); i <= (int)(x); i++)
if (a[(1 << 18) + i]) f[2 * i + 2 * y] = 2 * i + 2 * y;
for (int i = (int)(1); i <= (int)(1000000); i++)
for (int j = (int)(1); j <= (int)(1000000 / i); j++)
f[i * j] = max(f[i * j], f[i]);
int Q;
scanf("%d", &Q);
while (Q--) {
int x;
scanf("%d", &x);
printf("%d ", f[x]);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct str {
long len;
long shir;
};
struct str2 {
long len;
long shir;
long val;
};
int main() {
long n;
cin >> n;
vector<str> mass(n);
long q;
for (long i = 0; i < n; i++) {
cin >> mass[i].shir;
cin >> q;
cin >> mass[i].len;
mass[i].shir += q;
mass[i].shir *= 2;
}
long m;
cin >> m;
long res = 0;
vector<str2> mass2(m);
for (long i = 0; i < m; i++)
cin >> mass2[i].len >> mass2[i].shir >> mass2[i].val;
long temp = 0, tt = 0, kol, kol2, koll;
for (long i = 0; i < n; i++) {
temp = 1000000;
for (long j = 0; j < m; j++) {
kol = mass2[j].len / mass[i].len;
if (kol > 0) {
kol2 = mass[i].shir / mass2[j].shir;
if (mass[i].shir % mass2[j].shir != 0) kol2++;
koll = kol2 / kol;
if (kol2 % kol != 0) koll++;
temp = min((long)temp, (long)(koll * mass2[j].val));
}
}
res += temp;
}
cout << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, nn, K, p;
int h[100010], a[100010], f[100010];
int get(int x) { return f[x] == x ? x : f[x] = get(f[x]); }
inline bool ju(long long H) {
int i, j;
for (i = 0; i <= nn; i++) f[i] = i;
for (i = 1; i <= n; i++) {
long long last = h[i] + 1ll * a[i] * m;
if (last <= H) continue;
long long left = last - H, ci = left / p + (left % p > 0),
mi = m - H / a[i];
long long yu = left % p;
if (!yu) yu = p;
for (j = 1; j <= ci; j++) {
long long ju = last - 1ll * (j - 1) * p - yu;
long long wei = min(mi, m - ju / a[i]);
int x = get(max(0ll, wei) * K);
if (x == nn) return 0;
f[x] = x + 1;
}
}
return 1;
}
int main() {
scanf("%d%d%d%d", &n, &m, &K, &p);
nn = m * K;
for (i = 1; i <= n; i++) scanf("%d%d", &h[i], &a[i]);
long long l = 0, r = (long long)1e18, mid;
for (; l <= r;) {
mid = (l + r) / 2;
if (ju(mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%I64d\n", r + 1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a, b, x, i = 1, ij[200001];
vector<long long> y(200001);
vector<vector<long long> > tab(200001);
vector<vector<long long> > e(200001);
long long h[2 * 200001], h2[2 * 200001], ih = 1;
void pop() {
h[1] = h[ih - 1], h2[1] = h2[ih - 1], ih--;
long long j = 1, c;
while (j < ih) {
if (j * 2 < ih && h[j * 2] < h[j] &&
(h[j * 2 + 1] >= h[j * 2] || j * 2 + 1 >= ih))
c = h[j], h[j] = h[j * 2], h[j * 2] = c, c = h2[j], h2[j] = h2[j * 2],
h2[j * 2] = c, j = j * 2;
else if (j * 2 + 1 < ih && h[j * 2 + 1] < h[j] && h[j * 2 + 1] < h[j * 2])
c = h[j], h[j] = h[j * 2 + 1], h[j * 2 + 1] = c, c = h2[j],
h2[j] = h2[j * 2 + 1], h2[j * 2 + 1] = c, j = j * 2 + 1;
else
break;
}
}
void push(long long a, long long v) {
h[ih] = a, h2[ih] = v, ih++;
long long j = ih - 1, c;
while (j > 1) {
if (h[j / 2] > h[j])
c = h[j], h[j] = h[j / 2], h[j / 2] = c, c = h2[j], h2[j] = h2[j / 2],
h2[j / 2] = c, j /= 2;
else
break;
}
}
bool check[200001];
vector<long long> d(200001);
vector<long long> full_dijkstra(vector<vector<long long> > tab,
vector<vector<long long> > e, long long s) {
long long x, j = 0, y;
d[s] = 0;
push(0, s);
while (ih > 1) {
x = h[1], y = h2[1];
pop();
if (check[y] == 1) continue;
check[y] = 1, d[y] = x;
while (j < ij[y]) {
if (check[tab[y][j]] == 0 && y == 0)
push(x + e[y][j], tab[y][j]);
else if (check[tab[y][j]] == 0)
push(x + 2 * e[y][j], tab[y][j]);
j++;
}
j = 0;
}
return d;
}
int main() {
scanf("%lld %lld", &n, &m);
while (m--) {
scanf("%lld %lld %lld", &a, &b, &x);
tab[a].push_back(b), tab[b].push_back(a);
e[a].push_back(x), e[b].push_back(x);
ij[a]++, ij[b]++;
}
while (i <= n) {
scanf("%lld", &a);
tab[0].push_back(i);
e[0].push_back(a);
ij[0]++;
i++;
}
y = full_dijkstra(tab, e, 0);
for (long long j = 1; j <= n; j++) printf("%lld\n", y[j]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 100005;
long long n;
long long s;
long long mins(long long k) {
long long s = 0;
long long ast = 1;
long long mn = ast;
long long d = 1;
for (int i = 1; i <= n; ++i) {
s += d;
--mn;
if (mn == 0) {
ast *= k;
mn = ast;
d = d + 1;
}
}
return s;
}
long long q[N];
vector<int> v[N];
int ans[N];
void solv() {
scanf("%lld%lld", &n, &s);
if ((n * (n + 1)) / 2 < s) {
printf("No\n");
return;
}
if (mins(n - 1) > s) {
printf("No\n");
return;
}
long long k;
long long l = 1, r = n - 1;
while (l <= r) {
long long m = (l + r) / 2;
if (mins(m) <= s) {
k = m;
r = m - 1;
} else
l = m + 1;
}
q[1] = 1;
long long ys = 1;
long long p = 1;
for (int i = 2; i <= n; ++i) {
long long l = 0, r = q[i - 1] * k;
q[i] = 0;
while (l <= r) {
long long m = (l + r) / 2;
if (ys + m * i <= s && p + m <= n &&
ys + m * i + ((i + 1) + (i + (n - (p + m)))) * (n - (p + m)) / 2 >=
s) {
q[i] = m;
l = m + 1;
} else
r = m - 1;
}
ys += q[i] * i;
p += q[i];
}
int z = 0;
v[1].push_back(++z);
for (int i = 2; i <= n; ++i) {
int u = 0;
int mn = k;
for (int j = 1; j <= q[i]; ++j) {
ans[++z] = v[i - 1][u];
v[i].push_back(z);
--mn;
if (mn == 0) {
++u;
mn = k;
}
}
}
printf("Yes\n");
for (int i = 2; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
}
int main() {
solv();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
constexpr int MAXN = 100;
constexpr int MOD = 1000000007;
constexpr int MAXTOLERANCE = 10000001; //10001; // really? TODO
int c[MAXN], b[MAXN], magic[MAXN];
int dp1[MAXTOLERANCE], dp2[MAXTOLERANCE];
int coalesce[MAXTOLERANCE+1];
int* const coal=coalesce+MAXTOLERANCE/2;
int32_t main(){
ios_base::sync_with_stdio(false);
int n,q;
cin>>n;
for (int i=0;i<n;++i){
cin>>c[i];
}
for(int i=1;i<n;++i){
cin>>b[i];
}
cin>>q;
for(int j=0;j<q;++j){
int x;
cin>>x;
/*if (x>MAXN){
cout<<0<<'\n';
continue;
}*/
magic[0]=x;
for(int i=1;i<n;++i){
magic[i]=magic[i-1]+b[i];
}
int* prev=dp1+MAXTOLERANCE/2;
fill_n(prev-MAXTOLERANCE/2, MAXTOLERANCE, 0);
prev[x]=1;
int prev_low=x;
int prev_high=x;
int* curr=dp2+MAXTOLERANCE/2;
fill_n(curr-MAXTOLERANCE/2, MAXTOLERANCE, 0);
for(int i=0;i<n-1;++i){
//fill_n(curr-MAXTOLERANCE/2, MAXTOLERANCE, 0);
//fill_n(coal-MAXTOLERANCE/2, MAXTOLERANCE+1, 0);
// TODO: optimize
int coal_low=LLONG_MAX;
int coal_high=LLONG_MIN;
for(int k=prev_low;k<=prev_high;++k){
int start = max(k, 0ll);
if (start <= c[i] && prev[k]>0){
int c_start = min(max(magic[i+1]-(c[i]-k), -MAXTOLERANCE/2), MAXTOLERANCE/2+1);
int c_end = min(max(magic[i+1]-(start-k)+1, -MAXTOLERANCE/2), MAXTOLERANCE/2+1);
coal[c_start]+=prev[k];
coal[c_start]%=MOD;
coal[c_end]+=(MOD-prev[k]);
coal[c_end]%=MOD;
coal_low=min(coal_low,c_start);
coal_high=max(coal_high,c_end-1);
}
/*for(int kk=start;kk<=c[i];++kk){
int ind = magic[i+1]-(kk-k);
if (ind >= -MAXTOLERANCE/2 && ind <= MAXTOLERANCE/2){
curr[ind]+=prev[k];
curr[ind]%=MOD;
}
}*/
}
int cum=0;
for(int k=coal_low;k<=coal_high;++k){
cum+=coal[k];
cum%=MOD;
curr[k]=cum;
}
fill(coal+coal_low,coal+coal_high+2,0);
fill(prev+prev_low, prev+prev_high+1,0);
prev_low=coal_low;
prev_high=coal_high;
swap(prev, curr);
/*for(int k=-10;k<=10;++k){
cout<<' '<<prev[k];
}
cout<<endl;
cout<< prev_low<<' '<<prev_high<<endl;*/
}
int ans=0;
{
//fill_n(curr-MAXTOLERANCE/2, MAXTOLERANCE, 0);
// TODO: optimize
for(int k=-MAXTOLERANCE/2;k<=MAXTOLERANCE/2;++k){
int start = max(k, 0ll);
for(int kk=start;kk<=c[n-1];++kk){
ans+=prev[k];
ans%=MOD;
}
}
}
cout<<ans<<'\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 5;
const int M = 5e5 + 5;
const int OO = 1e9;
const int mod = 1e9 + 7;
int n, x, y;
complex<long long> c1, c2, p[N];
long long ans;
bool insideCircle(complex<long long> p, complex<long long> c, long long rs) {
return (((conj(p - c) * (p - c)).real())) <= rs;
}
double solve(long long sr1) {
long long sr2 = 0;
for (int i = 0; i < n; ++i) {
if (!insideCircle(p[i], c1, sr1))
sr2 = max(sr2, (((conj(c2 - p[i]) * (c2 - p[i])).real())));
}
return sr2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
cin >> x >> y;
c1 = {x, y};
cin >> x >> y;
c2 = {x, y};
for (int i = 0; i < n; ++i) {
cin >> x >> y;
p[i] = {x, y};
}
ans = solve(0);
for (int i = 0; i < n; ++i) {
long long sr1 = (((conj(c1 - p[i]) * (c1 - p[i])).real()));
long long sr2 = solve(sr1);
ans = min(ans, sr1 + sr2);
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int dd[N][N];
vector<int> T[N];
void dfs(int u, int par, int di, int root) {
dd[root][u] = di;
for (auto x : T[u]) {
if (x == par) continue;
dfs(x, u, di + 1, root);
}
}
pair<int, int> query(vector<int> ask) {
cout << "? " << ask.size() << " ";
for (auto x : ask) cout << x << " ";
cout << "\n";
fflush(stdout);
pair<int, int> ans;
cin >> ans.first >> ans.second;
return ans;
}
void solve() {
int n;
cin >> n;
int u, v;
for (int i = 1; i <= n; i++) T[i].clear();
for (int i = 1; i < n; i++) {
cin >> u >> v;
T[u].push_back(v);
T[v].push_back(u);
}
for (int i = 1; i <= n; i++) dfs(i, -1, 0, i);
pair<int, int> ss;
vector<int> qq;
for (int i = 1; i <= n; i++) qq.push_back(i);
ss = query(qq);
int root = ss.first;
int len = ss.second;
int l = (len + 1) / 2, r = len + 1;
int mid;
bool good;
while (l + 1 < r) {
mid = (l + r) / 2;
vector<int> ask;
good = true;
for (int i = 1; i <= n; i++)
if (dd[root][i] == mid) ask.push_back(i);
if (ask.empty())
good = false;
else {
ss = query(ask);
if (ss.second != len)
good = false;
else
good = true;
}
if (good)
l = mid;
else
r = mid;
}
vector<int> ask;
for (int i = 1; i <= n; i++)
if (dd[root][i] == l) ask.push_back(i);
ss = query(ask);
int v1 = ss.first;
ask.clear();
for (int i = 1; i <= n; i++)
if (dd[v1][i] == len) ask.push_back(i);
ss = query(ask);
int v2 = ss.first;
cout << "! " << v1 << " " << v2 << "\n";
fflush(stdout);
string res;
cin >> res;
}
int main() {
int tc;
cin >> tc;
for (int t = 0; t < tc; t++) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, x, i;
cin >> n >> x;
pair<long long, long long> p[n];
for (i = 0; i < n; i++) cin >> p[i].first >> p[i].second;
sort(p, p + n);
if (p[n - 1].first >= x) {
cout << "1\n";
continue;
}
long long max = LONG_MIN, index, count = 0;
for (i = 0; i < n; i++) {
if (max < p[i].first - p[i].second) {
max = p[i].first - p[i].second;
index = i;
}
}
if (max <= 0) {
cout << "-1\n";
continue;
}
count = ceil((x - p[n - 1].first) / (float)max);
x = x - count * max;
if (x == 0)
cout << count << endl;
else
cout << count + 1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char ch[105];
int num[30];
int q[205];
vector<int> v;
int main() {
int T;
int len;
int a, b;
scanf("%d", &T);
while (T--) {
v.clear();
memset(q, -1, sizeof(q));
memset(num, 0, sizeof(num));
scanf("%s", ch);
len = strlen(ch);
for (int i = 0; i < len; i++) num[ch[i] - 'a']++;
for (int i = 0; i < 26; i++)
if (num[i] != 0) v.push_back(i);
if (v.size() == 2) {
if (v[0] + 1 == v[1])
printf("No answer\n");
else {
int x = v[0];
while (num[x]) {
printf("%c", 'a' + x);
num[x]--;
}
x = v[1];
while (num[x]) {
printf("%c", 'a' + x);
num[x]--;
}
printf("\n");
}
} else if (v.size() == 3) {
if (v[0] + 1 == v[1] && v[1] + 1 == v[2])
printf("No answer\n");
else {
int q, w, r;
if (v[0] + 1 == v[1])
q = v[0], w = v[2], r = v[1];
else if (v[1] + 1 == v[2])
q = v[1], w = v[0], r = v[2];
else
q = v[0], w = v[1], r = v[2];
int x;
x = q;
while (num[x]) {
printf("%c", 'a' + x);
num[x]--;
}
x = w;
while (num[x]) {
printf("%c", 'a' + x);
num[x]--;
}
x = r;
while (num[x]) {
printf("%c", 'a' + x);
num[x]--;
}
printf("\n");
}
} else if (v.size() == 1) {
int x = v[0];
while (num[x]) {
printf("%c", 'a' + x);
num[x]--;
}
printf("\n");
continue;
} else {
int x = v[0];
int siz = v.size();
q[100] = v[0];
q[101] = v[siz - 1];
q[99] = v[siz - 2];
a = 98;
b = 102;
if (siz % 2) {
for (int i = 1; i < siz - 2; i++) {
if (i % 2)
q[a--] = v[i];
else
q[b++] = v[i];
}
} else {
for (int i = 1; i < siz - 2; i++) {
if (i % 2)
q[b++] = v[i];
else
q[a--] = v[i];
}
}
for (int i = 0; i < 200; i++) {
if (q[i] == -1)
continue;
else {
x = q[i];
while (num[x]) {
printf("%c", 'a' + x);
num[x]--;
}
}
}
printf("\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int add(int _a, int _b) {
_a = (_a + 998244353) % 998244353;
_b = (_b + 998244353) % 998244353;
return (_a + _b) % 998244353;
}
int mul(int _a, int _b) {
_a = (_a + 998244353) % 998244353;
_b = (_b + 998244353) % 998244353;
return ((long long int)((long long int)_a * (long long int)_b)) % 998244353;
}
int bigMod(int v, int p) {
if (p == 0) {
return 1;
}
int ret = bigMod(v, p / 2) % 998244353;
if (p % 2 == 0) {
return mul(ret, ret);
} else {
return mul(ret, mul(ret, v));
}
}
int n, m, ara[2 * 100010], bra[2 * 100010], mxa, mxb, suma, sumb, sum,
inv[50 * 2 * 100010], f[2][52][52][102], g[2][52][52][102];
int frqa[52], frqb[52], ans[52];
void input() {
int i, j;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &ara[i]);
}
for (i = 0; i < n; i++) {
scanf("%d", &bra[i]);
}
suma = sumb = sum = 0, mxa = mxb = -1;
for (i = 0; i < n; i++) {
if (ara[i] == 1) {
suma += bra[i];
mxa = max(mxa, bra[i]);
frqa[bra[i]]++;
} else {
sumb += bra[i], mxb = max(mxb, bra[i]);
frqb[bra[i]]++;
}
sum += bra[i];
}
}
void pre() {
int i, j;
for (i = 1; i <= sum + m; i++) {
inv[i] = bigMod(i, 998244353 - 2);
}
}
void solve() {
pre();
int i, j, ret = 0, v, k, l;
for (i = 0; i <= m; i++) {
if (i == 0) {
for (j = m - i; j >= 0; j--) {
for (k = min(m - j - i, sumb); k >= 0; k--) {
for (l = mxa + j; l >= 0; l--) {
f[i % 2][j][k][l] = l;
}
}
}
continue;
}
for (j = m - i; j >= 0; j--) {
for (k = min(m - j - i, sumb); k >= 0; k--) {
for (l = mxa + j; l >= 0; l--) {
ret = 0;
v = mul(mul(l, inv[suma + j + sumb - k]),
f[(i - 1) % 2][j + 1][k][l + 1]);
ret = add(ret, v);
v = mul(mul(suma + j - l, inv[suma + j + sumb - k]),
f[(i - 1) % 2][j + 1][k][l]);
ret = add(ret, v);
v = mul(mul(sumb - k, inv[suma + j + sumb - k]),
f[(i - 1) % 2][j][k + 1][l]);
ret = add(ret, v);
f[i % 2][j][k][l] = ret;
}
}
}
}
for (i = 0; i <= m; i++) {
if (i == 0) {
for (j = m - i; j >= 0; j--) {
for (k = min(m - j - i, sumb); k >= 0; k--) {
for (l = mxb; l >= 0; l--) {
g[i % 2][j][k][l] = l;
}
}
}
continue;
}
for (j = m - i; j >= 0; j--) {
for (k = min(m - j - i, sumb); k >= 0; k--) {
for (l = mxb; l >= 0; l--) {
ret = 0;
if (l - 1 >= 0) {
v = mul(mul(l, inv[suma + j + sumb - k]),
g[(i - 1) % 2][j][k + 1][l - 1]);
} else {
v = 0;
}
ret = add(ret, v);
v = mul(mul(sumb - k - l, inv[suma + j + sumb - k]),
g[(i - 1) % 2][j][k + 1][l]);
ret = add(ret, v);
v = mul(mul(suma + j, inv[suma + j + sumb - k]),
g[(i - 1) % 2][j + 1][k][l]);
ret = add(ret, v);
g[i % 2][j][k][l] = ret;
}
}
}
}
for (i = 0; i < n; i++) {
if (ara[i] == 1) {
printf("%d", f[m % 2][0][0][bra[i]]);
puts("");
} else {
printf("%d", g[m % 2][0][0][bra[i]]);
puts("");
}
}
}
int main() {
input();
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, s;
pair<long long, long long> p[100005], a[100005];
pair<pair<long long, long long>, long long> d[100005];
priority_queue<pair<long long, long long> > q;
int xl(int k) {
memset(p, 0, sizeof(p));
while (!q.empty()) q.pop();
long long ans = 0;
int tp = n;
for (int vv = m; vv >= 1; vv -= k) {
while (d[tp].first.first >= a[vv].first && tp > 0) {
q.push(make_pair(-d[tp].first.second, d[tp].second));
tp--;
}
if (q.empty()) return false;
ans += -q.top().first;
p[vv] = make_pair(a[vv].second, q.top().second);
q.pop();
}
return (ans <= s);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> s;
for (int i = 1; i <= m; i++) cin >> a[i].first;
for (int i = 1; i <= n; i++) cin >> d[i].first.first;
for (int i = 1; i <= n; i++) cin >> d[i].first.second;
for (int i = 1; i <= m; i++) a[i].second = i;
for (int i = 1; i <= n; i++) d[i].second = i;
sort(a + 1, a + m + 1);
sort(d + 1, d + n + 1);
int l = 0;
int r = 100005;
xl(3);
while (r - l > 1) {
int g = (l + r) / 2;
if (xl(g))
r = g;
else
l = g;
}
xl(r);
for (int i = 1; i <= m; i++) p[i].first = a[i].second;
for (int i = m - 1; i >= 1; i--)
if (!p[i].second) p[i].second = p[i + 1].second;
sort(p + 1, p + m + 1);
if (r <= 100000) {
cout << "YES" << endl;
for (int i = 1; i <= m; i++) cout << p[i].second << " ";
} else
cout << "NO";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n;
cin >> n;
getchar();
getline(cin, s);
int cnt = 0, prev = 0;
for (int i = 0; i < n; i++) {
if (s[i] == ' ') {
prev = max(prev, cnt);
cnt = 0;
} else if (s[i] >= 'A' && s[i] <= 'Z')
cnt++;
}
prev = max(prev, cnt);
cout << prev;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, i, j, t;
cin >> t;
while (t--) {
cin >> n;
long long a[n];
for (i = 1; i <= n; ++i) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long long res = min(a[n - 1] - 1, n - 2);
cout << res << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool func(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second < b.second;
}
long long int power(long long int a, long long int b) {
long long int res = 1;
a %= 1000000007;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
long long int modInverse(long long int a) { return power(a, 1000000007 - 2); }
void solve() {
int n, m;
long long int t;
cin >> n >> m >> t;
char v[n][m];
for (__typeof(n) i = 0; i < n; ++i)
for (__typeof(m) j = 0; j < m; ++j) cin >> v[i][j];
int tp[n][m];
int vis[n][m];
for (__typeof(n) i = 0; i < n; ++i)
for (__typeof(m) j = 0; j < m; ++j) tp[i][j] = 0;
for (__typeof(n) i = 0; i < n; ++i)
for (__typeof(m) j = 0; j < m; ++j) vis[i][j] = 0;
for (__typeof(n) i = 0; i < n; ++i) {
for (__typeof(m) j = 0; j < m; ++j) {
if (i > 0)
if (v[i - 1][j] == v[i][j]) tp[i][j] = tp[i - 1][j] = 1;
if (i < n - 1)
if (v[i + 1][j] == v[i][j]) tp[i][j] = tp[i + 1][j] = 1;
if (j > 0)
if (v[i][j - 1] == v[i][j]) tp[i][j] = tp[i][j - 1] = 1;
if (j < m - 1)
if (v[i][j + 1] == v[i][j]) tp[i][j] = tp[i][j + 1] = 1;
}
}
queue<pair<int, int> > q;
for (__typeof(n) i = 0; i < n; ++i)
for (__typeof(m) j = 0; j < m; ++j) {
if (tp[i][j]) {
q.push({i, j});
vis[i][j] = 1;
}
}
while (!q.empty()) {
pair<int, int> p;
p = q.front();
q.pop();
if (p.first > 0) {
if (!vis[p.first - 1][p.second]) {
tp[p.first - 1][p.second] = tp[p.first][p.second] + 1;
q.push({p.first - 1, p.second});
vis[p.first - 1][p.second] = 1;
}
}
if (p.second > 0) {
if (!vis[p.first][p.second - 1]) {
tp[p.first][p.second - 1] = tp[p.first][p.second] + 1;
q.push({p.first, p.second - 1});
vis[p.first][p.second - 1] = 1;
}
}
if (p.first < n - 1) {
if (!vis[p.first + 1][p.second]) {
tp[p.first + 1][p.second] = tp[p.first][p.second] + 1;
q.push({p.first + 1, p.second});
vis[p.first + 1][p.second] = 1;
}
}
if (p.second < m - 1) {
if (!vis[p.first][p.second + 1]) {
tp[p.first][p.second + 1] = tp[p.first][p.second] + 1;
q.push({p.first, p.second + 1});
vis[p.first][p.second + 1] = 1;
}
}
}
for (__typeof(t) k = 0; k < t; ++k) {
int i, j;
long long int tr;
cin >> i >> j >> tr;
i--, j--;
if (!vis[i][j] || tr < tp[i][j]) {
cout << v[i][j] << "\n";
continue;
}
tr -= tp[i][j];
if (tr % 2 == 0)
cout << 1 - (v[i][j] == '1') << '\n';
else
cout << v[i][j] << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1, tmp = 0;
while (t--) {
solve();
if (t) cout << "\n";
}
cerr << "Time : " << (double)clock() / (double)CLOCKS_PER_SEC << "s\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
double a, s;
int main() {
ios_base::sync_with_stdio(false);
double last = 0;
cin >> n >> a >> s;
cout << fixed << setprecision(10);
for (int i = 0; i < n; ++i) {
double t, v;
int tt, vv;
cin >> tt >> vv;
t = tt, v = vv;
double use;
if (v * v / 2.0 / a < s)
use = s / v + v / 2.0 / a;
else
use = sqrt(2 * s / a);
double arrive = t + use;
arrive = max(arrive, last);
cout << arrive << '\n';
last = arrive;
}
}
| 4 |
#include <bits/stdc++.h>
int ans[1000010];
int main() {
int a;
scanf("%d", &a);
int count1 = 0, count2 = 0;
for (int i = a - 1; i >= 1; i -= 2) count1++;
for (int i = 1; i <= count1; i++) ans[i] = a - 1 + (2 * i - 2 * count1);
for (int i = count1 + 1; i <= 2 * count1; i++)
ans[i] = a - 1 + (2 * count1 + 2 - 2 * i);
ans[2 * count1 + 1] = a;
for (int i = a - 2; i >= 1; i -= 2) count2++;
for (int i = 2 * count1 + 2; i <= 2 * count1 + 1 + count2; i++)
ans[i] = a - 2 + (2 * i - 4 * count1 - 2 - 2 * count2);
ans[2 * count1 + count2 + 2] = a;
for (int i = 2 * count1 + count2 + 3; i <= 2 * a; i++)
ans[i] = a - 2 + (4 * count1 + 2 * count2 + 6 - 2 * i);
for (int i = 1; i <= 2 * a; i++) printf("%d ", ans[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans = 0, m = 0;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long a = arr[n - 1], b = arr[n - 2];
for (int i = 0; i < (n - 2); i++) {
if (arr[i] + arr[i + 1] > arr[i + 2]) {
m = 1;
break;
}
}
if (m == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
int total = n * (n - 1) / 2;
if (total <= k)
printf("no solution\n");
else {
for (int i = 0; i < n; i++) printf("0 %d\n", i);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(1000005);
long long a[MAXN];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a[x]++;
}
int mina;
for (int i = 1; i <= 1000001; i++) a[i] += a[i - 1];
for (int i = 1; i <= 1000001; i++)
if (a[i] > 0) {
mina = i;
break;
}
vector<pair<int, int> > ans;
for (int i = mina; i >= 1; i--) {
bool fail = 0;
for (int j = i; j <= 1000000; j += i) {
int l = min(1000001, j + i);
if (j + k < l && a[l - 1] - a[j + k] > 0) {
fail = 1;
break;
}
}
if (!fail) {
printf("%d\n", i);
break;
}
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
inline long long add(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x += _y;
return _x >= _mod ? _x - _mod : _x;
}
inline long long sub(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x -= _y;
return _x < 0 ? _x + _mod : _x;
}
inline long long mul(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x *= _y;
return _x >= _mod ? _x % _mod : _x;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1LL;
long long _ret = mypow(mul(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = mul(_ret, _a, _mod);
return _ret;
}
long long mymul(long long _a, long long _x, long long _mod) {
if (_x == 0) return 0LL;
long long _ret = mymul(add(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = add(_ret, _a, _mod);
return _ret;
}
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
int __ = 1, _cs;
void build() {}
struct Tree {
int n;
vector<int> v[1021];
void init() {
n = getint();
for (int i = 1; i <= n; i++) v[i].clear();
for (int i = 1; i < n; i++) {
int ai = getint();
int bi = getint();
v[ai].push_back(bi);
v[bi].push_back(ai);
}
}
} s, t;
int hsvl[1021], mid, con;
vector<int> v;
map<vector<int>, int> M;
int Hash(int x, int prt = -1) {
vector<int> tv;
for (int son : t.v[x]) {
if (son == prt) continue;
tv.push_back(Hash(son, x));
}
sort(tv.begin(), tv.end());
if (M.count(tv) == 0) {
M[tv] = ++mid;
if (tv.empty()) con = mid;
}
return M[tv];
}
void init() {
s.init();
t.init();
}
vector<int> son[1021], vs[1021];
void pre_go(int now, int prt) {
for (int x : s.v[now]) {
if (x == prt) continue;
vs[now].push_back(x);
pre_go(x, now);
}
}
vector<int> useful;
unordered_map<int, int> who;
int go(int now, int prt) {
for (int tson : t.v[now]) {
if (tson == prt) continue;
son[now].push_back(go(tson, now));
}
sort(son[now].begin(), son[now].end());
int ret = M[son[now]];
useful.push_back(ret);
who[ret] = now;
return ret;
}
int target, ans, tdp[1 << 12], rdp[1 << 12];
int q[1 << 12], qt;
int iq[1 << 12], stmp;
unordered_map<int, int> dp[1021];
void go_cal(int now) {
for (int sn : vs[now]) go_cal(sn);
for (auto cv : useful) {
if (cv == con) {
dp[now][cv] = 1;
} else {
int he = who[cv];
int csz = son[he].size();
for (int j = 0; j < (1 << csz); j++) tdp[j] = 0;
tdp[0] = 1;
iq[0] = ++stmp;
q[0] = 0;
qt = 1;
for (int sn : vs[now]) {
for (int _ = 0; _ < qt; _++) rdp[q[_]] = tdp[q[_]];
int cqt = qt;
for (int _ = 0; _ < cqt; _++) {
int inow = q[_];
for (int j = 0; j < csz; j++) {
if ((inow >> j) & 1) continue;
if (j && son[he][j] == son[he][j - 1] &&
((inow >> (j - 1)) & 1) == 0)
continue;
tdp[inow | (1 << j)] =
add(tdp[inow | (1 << j)], mul(rdp[inow], dp[sn][son[he][j]]));
if (iq[inow | (1 << j)] != stmp) {
iq[inow | (1 << j)] = stmp;
q[qt++] = inow | (1 << j);
}
}
}
}
dp[now][cv] = tdp[(1 << csz) - 1];
}
if (cv == target) ans = add(ans, dp[now][cv]);
}
}
void cal(int i) {
for (int j = 1; j <= t.n; j++) son[j].clear();
who.clear();
useful.clear();
target = go(i, i);
sort(useful.begin(), useful.end());
useful.resize(unique(useful.begin(), useful.end()) - useful.begin());
for (int j = 1; j <= s.n; j++) dp[j].clear();
go_cal(1);
}
void solve() {
pre_go(1, 1);
for (int i = 1; i <= t.n; i++) {
hsvl[i] = Hash(i);
bool bye = false;
for (int j = 1; j < i; j++)
if (hsvl[i] == hsvl[j]) {
bye = true;
break;
}
if (bye) continue;
cal(i);
}
printf("%d\n", ans);
}
int main() {
build();
while (__--) {
init();
solve();
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
int b[11];
int get(int p) {
int s = 0, i;
for (i = p - 1; i >= 0; i--) {
if (b[i] > 0)
s = s * 10 + 1;
else
s = s * 10;
}
return s;
}
int main() {
int i, n, k;
cin >> n;
k = 0;
while (n > 0) {
int p = 0, w = n;
while (w > 0) {
b[p++] = w % 10;
w = w / 10;
}
int q = get(p);
a[k++] = q;
n = n - q;
}
printf("%d\n", k);
for (i = k - 1; i >= 0; i--) printf("%d ", a[i]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 5;
int r[maxn], ans[maxn];
vector<int> g[maxn];
bitset<maxn> b[maxn];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) g[i].clear();
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
bool z = true;
for (int i = 0; i < n; ++i) {
if (g[i].size() & 1) z = false;
}
if (z) {
puts("1");
for (int i = 0; i < n; ++i) printf("1 ");
puts("");
continue;
}
for (int i = 0; i < n; ++i) b[i].reset(), r[i] = 0;
for (int i = 0; i < n; ++i) {
if (g[i].size() & 1) {
b[i][i] = 1;
for (const int &u : g[i]) b[i][u] = 1;
r[i] = 1;
} else {
for (const int &u : g[i]) b[i][u] = 1;
r[i] = 0;
}
}
int last = 0;
for (int i = 0; i < n; ++i) {
int p = -1;
for (int j = last; j < n; ++j) {
if (b[j][i]) p = j;
}
if (p == -1) continue;
swap(r[last], r[p]);
swap(b[last], b[p]);
for (int j = last + 1; j < n; ++j) {
if (b[j][i]) {
b[j] ^= b[last];
r[j] ^= r[last];
}
}
++last;
}
for (int i = n - 1; i >= 0; --i) {
int p = -1;
for (int j = 0; j < n && !~p; ++j) {
if (b[i][j]) p = j;
}
if (p == -1) continue;
swap(b[p], b[i]);
swap(r[p], r[i]);
}
for (int i = n - 1; i >= 0; --i) {
if (b[i][i] == 0) {
ans[i] = 0;
continue;
}
int k = 0;
for (int j = i + 1; j < n; ++j)
if (b[i][j]) k ^= ans[j];
ans[i] = (r[i] ^ k);
}
puts("2");
for (int i = 0; i < n; ++i) printf("%d ", ans[i] + 1);
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 5007;
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = a * a % M) ret = 1ll * ret * a % M;
return ret;
}
int a[maxn];
int dp[maxn][maxn];
int maxmod[7], maxnum[100007];
int n, m;
int i, j, k;
int x_x, y_y;
int ans;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (x_x = 0; x_x <= n; x_x++) {
for (k = 0; k < 7; k++) maxmod[k] = 0;
for (k = 1; k <= n; k++)
maxnum[a[k] + 1] = maxnum[a[k] - 1] = maxnum[a[k]] = 0;
dp[x_x][0] = dp[0][x_x];
for (y_y = 1; y_y <= n; y_y++) {
if (x_x < y_y) {
dp[x_x][y_y] = dp[x_x][0] + 1;
dp[x_x][y_y] = max(dp[x_x][y_y], maxnum[a[y_y] - 1] + 1);
dp[x_x][y_y] = max(dp[x_x][y_y], maxnum[a[y_y] + 1] + 1);
dp[x_x][y_y] = max(dp[x_x][y_y], maxmod[a[y_y] % 7] + 1);
dp[y_y][x_x] = dp[x_x][y_y];
ans = max(ans, dp[x_x][y_y]);
} else
dp[x_x][y_y] = dp[y_y][x_x];
maxnum[a[y_y]] = max(maxnum[a[y_y]], dp[x_x][y_y]);
maxmod[a[y_y] % 7] = max(maxmod[a[y_y] % 7], dp[x_x][y_y]);
}
}
printf("%d", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
void solve() {
ll n, x;
cin >> n;
vector<ll> v;
for (ll j = 0; j < n; j++) {
cin >> x;
v.emplace_back(x);
}
sort(v.begin(), v.end());
ll flag = 0;
for (ll i = 0; i < n - 2; i++) {
ll a = v[i];
ll b = v[i + 1];
ll c = v[i + 2];
if (a + b > c && a + c > b && b + c > a) {
flag = 1;
cout << "YES\n";
break;
}
}
if (flag == 0) cout << "NO\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
;
ll t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
template <class T>
void dbs(string str, T t) {
cout << str << " : " << t << endl;
}
template <class T, class... second>
void dbs(string str, T t, second... s) {
int idx = str.find(',');
cout << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class second, class T>
ostream& operator<<(ostream& os, const pair<second, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class second, class T>
ostream& operator<<(ostream& os, const map<second, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void prc(T a, T b) {
cout << "[";
for (T i = a; i != b; ++i) {
if (i != a) cout << ", ";
cout << *i;
}
cout << "]";
cout << endl;
}
bool isPrime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
const int K = 1;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.length();
vector<int> primes;
for (int i = inf; int(primes.size()) < K; --i) {
if (isPrime(i)) primes.push_back(i);
}
vector<vector<int> > p(K, vector<int>(n));
vector<vector<int> > sum(K, vector<int>(n));
for (int i = (0); i <= (K - 1); ++i) {
int pr = primes[i];
p[i][0] = 1, p[i][1] = 10;
for (int j = (2); j <= (n - 1); ++j) {
p[i][j] = (p[i][j - 1] * 10LL) % pr;
}
sum[i][0] = s[0] - '0';
for (int j = (1); j <= (n - 1); ++j) {
sum[i][j] = (sum[i][j - 1] * 10LL + (s[j] - '0')) % pr;
}
}
auto get = [&](int l, int r) {
vector<int> ans(K);
for (int i = (0); i <= (K - 1); ++i) {
int pr = primes[i];
if (l == 0) {
ans[i] = sum[i][r];
} else {
ans[i] =
(sum[i][r] + (pr - (sum[i][l - 1] * 1LL * p[i][r - l + 1]) % pr)) %
pr;
}
}
return ans;
};
auto add = [&](vector<int> x, const vector<int>& y) -> vector<int> {
for (int i = (0); i <= (K - 1); ++i) {
x[i] = (x[i] + y[i]) % primes[i];
}
return x;
};
for (int i = (0); i <= (n - 1); ++i) {
int len = n - i;
for (int x : {len, len - 1})
if (x > 0) {
int y = n - len - x;
if (y > 0 and y <= x and (s[n - len] != '0' or len == 1)) {
if ((s[0] != '0' or x == 1) and (s[x] != '0' or y == 1) and
add(get(0, x - 1), get(x, x + y - 1)) == get(x + y, n - 1)) {
return cout << s.substr(0, x) << "+" << s.substr(x, y) << "="
<< s.substr(x + y),
0;
}
swap(x, y);
if (s[x] != '0' and
add(get(0, x - 1), get(x, x + y - 1)) == get(x + y, n - 1)) {
return cout << s.substr(0, x) << "+" << s.substr(x, y) << "="
<< s.substr(x + y),
0;
}
swap(x, y);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 405;
int n, m, N, M, ans;
int A[MAX_N][MAX_N], goRight[MAX_N][MAX_N], goDown[MAX_N][MAX_N],
goDiagonal[MAX_N][MAX_N];
string str[MAX_N];
void precompute() {
memset(goRight, 0, sizeof(goRight));
memset(goDown, 0, sizeof(goDown));
memset(goDiagonal, 0, sizeof(goDiagonal));
for (int i = 1; i <= n; i++)
for (int j = m - 1; j >= 1; j--)
if (A[i][j + 1] == 0)
goRight[i][j] = goRight[i][j + 1] + 1;
else
goRight[i][j] = 0;
for (int j = 1; j <= m; j++)
for (int i = n - 1; i >= 1; i--)
if (A[i + 1][j] == 0)
goDown[i][j] = goDown[i + 1][j] + 1;
else
goDown[i][j] = 0;
for (int i = n - 1; i >= 1; i--)
for (int j = 1; j < m; j++)
if (A[i + 1][j + 1] == 0)
goDiagonal[i][j] = goDiagonal[i + 1][j + 1] + 1;
else
goDiagonal[i][j] = 0;
}
void write() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << A[i][j] << " ";
cout << '\n';
}
cout << "\n\n";
}
void solve() {
precompute();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (A[i][j] == 0)
for (int k = 1; i - k >= 1 && j + k <= m && A[i - k][j + k] == 0; k++) {
int x = i - k;
int y = j + k;
if (goRight[i][j] >= k && goDown[x][y] >= k) ans++;
if (goRight[i][j] >= 2 * k && goDiagonal[x][y] >= k) ans++;
}
}
void rotate1() {
n = N;
m = M;
for (int i = 1; i <= N; i++)
for (int j = 0; j < M; j++) A[i][j + 1] = str[i][j] - '0';
}
void rotate2() {
n = M;
m = N;
for (int j = 1; j <= M; j++)
for (int i = N; i >= 1; i--) A[j][N - i + 1] = str[i][j - 1] - '0';
}
void rotate3() {
n = N;
m = M;
for (int i = N; i >= 1; i--)
for (int j = M; j >= 1; j--) A[N - i + 1][M - j + 1] = str[i][j - 1] - '0';
}
void rotate4() {
n = M;
m = N;
for (int j = M; j >= 1; j--)
for (int i = 1; i <= N; i++) A[M - j + 1][i] = str[i][j - 1] - '0';
}
int main() {
cin >> N >> M;
for (int i = 1; i <= N; i++) cin >> str[i];
rotate1();
solve();
rotate2();
solve();
rotate3();
solve();
rotate4();
solve();
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long double pi = acos(-1.0);
const long double eps = 1e-5;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
map<long long, int> cnt;
map<long long, long long> val;
long long a[200010];
long long b[200010];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = (1); i <= (n); i++) cin >> a[i];
for (int i = (1); i <= (n); i++) {
cin >> b[i];
cnt[a[i]]++;
val[a[i]] += b[i];
}
set<int> s;
for (auto &it : cnt) {
if (it.second < 2) continue;
for (int i = (1); i <= (n); i++)
if ((a[i] | it.first) == it.first) s.emplace(i);
}
long long ans = 0;
for (auto it : s) ans += b[it];
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
static void amin(T &x, U y) {
if (x > y) x = y;
}
int main() {
int n, ans;
scanf("%d", &n);
ans = 0;
vector<int> a(n);
for (int i = 0; i < (n); i++) scanf("%d", &a[i]);
sort(a.begin(), a.end());
for (int i = 0; i < (n); i++)
if (ans * (a[i] + 1) <= i) ++ans;
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
int Dx[] = {-1, -1, -1, 0, 1, 1, 1, 0};
int Dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int arr[10000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, T, res;
int maxi = -(1 << 30) - 1, mini = (1 << 30) - 1, count = 0;
int i, j, k;
bool flag;
string s1, s2;
char s[100000];
int ara[100005], ara2[100005];
cin >> n >> m;
pair<int, pair<int, int>> p[n];
for (i = 0; i < n; i++) {
cin >> p[i].second.first;
}
for (i = 0; i < n; i++) {
cin >> p[i].second.second;
}
for (i = 0; i < n; i++) {
p[i].first = p[i].second.first - p[i].second.second;
}
sort(p, p + n);
int sum = 0;
m = n - m;
for (i = n - 1; i >= 0; i--) {
if (p[i].first >= 0 && m > 0) {
sum += p[i].second.second;
m--;
} else {
sum += p[i].second.first;
}
}
cout << sum << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
vector<vector<char> > g(n, vector<char>(m, 0));
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) cin >> g[i][j];
int cnt = 0;
for (long long i = 0; i < n; i++)
if (g[i][m - 1] == 'R') cnt++;
for (long long i = 0; i < m; i++)
if (g[n - 1][i] == 'D') cnt++;
cout << cnt << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e2 + 10;
int a[N], cont[N];
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
cont[a[i]]++;
}
int ans = 0;
bool ok1 = true, ok2 = true;
for (int i = 0; i <= 100; i++) {
if (ok1 and cont[i] == 0) {
ans += i;
ok1 = false;
}
if (ok2 and cont[i] <= 1) {
ans += i;
ok2 = false;
}
}
cout << ans << '\n';
for (int i = 0; i < n; i++) cont[a[i]] = 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int exp(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t;
cin >> t;
unordered_map<char, int> rps;
while (t--) {
string s;
cin >> s;
rps['R'] = 0;
rps['P'] = 0;
rps['S'] = 0;
int n = s.length();
for (int i = 0, _n = (n); i < _n; i++) {
rps[s[i]]++;
}
char m = 'P';
if (rps['P'] > rps['R']) m = 'S';
if (rps['S'] > rps['R'] && rps['S'] > rps['P']) m = 'R';
for (int i = 0, _n = (n); i < _n; i++) cout << m;
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, totData, sec, wait;
cin >> a >> b >> c;
totData = a * c;
sec = totData / b;
if (totData % b > 0) {
sec++;
}
wait = sec - c;
if (wait == 0) {
wait = 1;
}
cout << wait;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long l, last;
long long sum1 = 0, sum2 = 0;
vector<long> v1, v2;
for (int i = 0; i < n; i++) {
cin >> l;
if (l > 0) {
v1.push_back(l);
sum1 += l;
} else {
sum2 += abs(l);
v2.push_back(abs(l));
}
if (i == n - 1) last = l;
}
if (sum1 > sum2)
cout << "first";
else if (sum1 < sum2)
cout << "second";
else {
string ans = "";
int i = 0, j = 0;
while (i < v1.size() && j < v2.size()) {
if (v1[i] < v2[i]) {
ans = "second";
break;
} else if (v1[i] > v2[j]) {
ans = "first";
break;
}
i++;
j++;
}
if (ans == "" && v1.size() > v2.size())
ans = "first";
else if (ans == "" && v1.size() < v2.size())
ans = "second";
else if (ans == "") {
if (last > 0)
ans = "first";
else {
ans = "second";
}
}
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 500111;
struct DSU {
int lab[MN];
void init(int n) {
for (int i = 0, _a = (n + 1); i < _a; i++) lab[i] = -1;
}
int getRoot(int u) {
if (lab[u] < 0) return u;
return lab[u] = getRoot(lab[u]);
}
bool merge(int u, int v) {
u = getRoot(u);
v = getRoot(v);
if (u == v) return false;
if (lab[u] > lab[v]) swap(u, v);
lab[u] += lab[v];
lab[v] = u;
return true;
}
};
int n, m, q, comId[MN], nCom;
vector<int> ke[MN], com_ke[MN];
set<pair<int, int> > bridges, tree_edges;
map<pair<int, int>, int> cnt;
int father[22][MN], isUp[22][MN], isDown[22][MN], h[MN];
void init() {
for (int i = 0, _a = (n + 2); i < _a; i++) {
ke[i].clear();
com_ke[i].clear();
}
bridges.clear();
tree_edges.clear();
cnt.clear();
memset(comId, -1, sizeof comId);
memset(h, -1, sizeof h);
memset(father, 0, sizeof father);
memset(isUp, 0, sizeof isUp);
memset(isDown, 0, sizeof isDown);
}
struct UndirectedDfs {
vector<int> low, num, parent;
int counter, root, children;
vector<pair<int, int> > bridges;
vector<int> cuts;
UndirectedDfs()
: low(n, 0), num(n, -1), parent(n, 0), counter(0), children(0) {
for (int i = 0; i < n; ++i)
if (num[i] == -1) {
root = i;
children = 0;
dfs(i);
}
}
private:
void dfs(int u) {
low[u] = num[u] = counter++;
for (int j = 0; j < ke[u].size(); ++j) {
int v = ke[u][j];
if (num[v] == -1) {
parent[v] = u;
if (u == root) children++;
dfs(v);
if (low[v] > num[u]) bridges.push_back(make_pair(u, v));
low[u] = min(low[u], low[v]);
} else if (v != parent[u])
low[u] = min(low[u], num[v]);
}
}
};
void dfs(int u, int com) {
comId[u] = com;
for (int v : ke[u]) {
if (bridges.count(make_pair(u, v)) || bridges.count(make_pair(v, u)))
continue;
if (comId[v] < 0) {
dfs(v, com);
}
}
}
void dfs2(int u, int fu) {
father[0][u] = fu;
for (int v : com_ke[u]) {
if (v == fu) continue;
h[v] = h[u] + 1;
dfs2(v, u);
}
}
void initLCA() {
for (int t = (1), _b = (20); t <= _b; t++) {
for (int u = (1), _b = (nCom); u <= _b; u++) {
father[t][u] = father[t - 1][father[t - 1][u]];
}
}
}
void go(int u, int v) {
if (u == v) return;
if (h[u] < h[v]) {
for (int t = (20), _b = (0); t >= _b; t--) {
int x = father[t][v];
if (h[x] >= h[u]) {
isDown[t][v] = true;
v = x;
}
}
}
if (h[u] > h[v]) {
for (int t = (20), _b = (0); t >= _b; t--) {
int x = father[t][u];
if (h[x] >= h[v]) {
isUp[t][u] = true;
u = x;
}
}
}
if (u == v) return;
for (int t = (20), _b = (0); t >= _b; t--)
if (father[t][u] != father[t][v]) {
isUp[t][u] = isDown[t][v] = true;
u = father[t][u];
v = father[t][v];
}
isUp[0][u] = isDown[0][v] = true;
}
int main() {
ios ::sync_with_stdio(false);
while (cin >> n >> m >> q) {
DSU dsu;
dsu.init(n);
init();
for (int i = (1), _b = (m); i <= _b; i++) {
int u, v;
cin >> u >> v;
--u;
--v;
dsu.merge(u, v);
ke[u].push_back(v);
ke[v].push_back(u);
cnt[make_pair(u, v)]++;
cnt[make_pair(v, u)]++;
}
UndirectedDfs tree;
for (auto p : tree.bridges) {
if (cnt[p] == 1) {
bridges.insert(p);
bridges.insert(make_pair(p.second, p.first));
}
}
nCom = 0;
for (int i = 0, _a = (n); i < _a; i++)
if (comId[i] < 0) {
++nCom;
dfs(i, nCom);
}
for (int i = 0, _a = (n); i < _a; i++) {
for (int j : ke[i]) {
int u = comId[i], v = comId[j];
if (u == v) continue;
if (tree_edges.count(make_pair(u, v))) continue;
if (tree_edges.count(make_pair(v, u))) continue;
tree_edges.insert(make_pair(u, v));
com_ke[u].push_back(v);
com_ke[v].push_back(u);
}
}
for (int i = (1), _b = (nCom); i <= _b; i++)
if (h[i] < 0) {
h[i] = 1;
dfs2(i, 0);
}
initLCA();
bool ok = true;
while (q--) {
int u, v;
cin >> u >> v;
--u;
--v;
if (dsu.getRoot(u) != dsu.getRoot(v)) ok = false;
u = comId[u];
v = comId[v];
go(u, v);
}
for (int t = (20), _b = (1); t >= _b; t--) {
for (int u = (1), _b = (nCom); u <= _b; u++) {
if (isUp[t][u]) {
int x = father[t - 1][u];
isUp[t - 1][u] = isUp[t - 1][x] = true;
}
if (isDown[t][u]) {
int x = father[t - 1][u];
isDown[t - 1][u] = isDown[t - 1][x] = true;
}
}
}
for (int i = (1), _b = (nCom); i <= _b; i++)
if (isUp[0][i] && isDown[0][i]) ok = false;
cout << (ok ? "Yes" : "No") << endl;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, p, q;
bool check(long long t) {
return ((p * t >= x) && ((q * t - p * t) >= (y - x)));
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%I64d%I64d%I64d%I64d", &x, &y, &p, &q);
long long l = 0, r = 1e9, mid;
long long ans = -1;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (ans == -1)
printf("-1\n");
else
printf("%I64d\n", ans * q - y);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, h, m, k;
vector<long long int> freight;
int workingTrains(long long int time) {
if (time - k >= 0) {
return n - (lower_bound(freight.begin(), freight.end(), time) -
upper_bound(freight.begin(), freight.end(), time - k));
} else {
return upper_bound(freight.begin(), freight.end(),
(time - k + m / 2) % (m / 2)) -
lower_bound(freight.begin(), freight.end(), time);
}
}
void solve(int test_index) {
cin >> n >> h >> m >> k;
freight.resize(n);
vector<long long int> raw(n);
for (int i = 0; i < n; i++) {
long long int hh, mm;
cin >> hh >> mm;
freight[i] = (hh * m + mm) % (m / 2);
raw[i] = freight[i];
}
sort(freight.begin(), freight.end());
long long int t = freight[0], works = workingTrains(freight[0]);
for (int time : freight) {
long long int w = workingTrains(time);
if (works < w) {
works = w;
t = time;
}
}
cout << n - works << " " << t << "\n";
for (int i = 0; i < n; i++) {
if (t - k < 0) {
if (raw[i] < t || raw[i] > (t - k + m / 2) % (m / 2)) {
cout << i + 1 << " ";
}
} else {
if (raw[i] > t - k && raw[i] < t) {
cout << i + 1 << " ";
}
}
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int num_tests = 1;
for (int test_index = 1; test_index <= num_tests; test_index++) {
solve(test_index);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int gi() {
char cc = getchar();
int cn = 0, flus = 1;
while (cc < '0' || cc > '9') {
if (cc == '-') flus = -flus;
cc = getchar();
}
while (cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
const int N = 2e5 + 5;
struct E {
int to, next;
} e[N << 1];
int n, cnt, A, B, head[N];
void add(int x, int y) {
e[++cnt] = (E){y, head[x]}, head[x] = cnt, e[++cnt] = (E){x, head[y]},
head[y] = cnt;
}
void Dfs(int x, int fa, int dep) {
(dep ^ 1) ? ++A : ++B;
for (register int i = head[x]; i; i = e[i].next)
if (e[i].to ^ fa) Dfs(e[i].to, x, dep ^ 1);
}
signed main() {
n = gi();
int x, y;
for (register int i = (2); i <= (n); ++i) x = gi(), y = gi(), add(x, y);
Dfs(1, 1, 0);
cout << min(A, B) - 1 << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> pr;
int a, b, c, d;
int main() {
scanf("%d %d", &a, &b);
scanf("%d %d", &c, &d);
for (int i = 0; i < 200000; ++i) {
pr[b + a * i]++;
pr[d + c * i]++;
if (pr[d + c * i] == 2 || pr[b + a * i] == 2) {
printf("%d", pr[d + c * i] == 2 ? d + c * i : b + a * i);
return 0;
}
}
printf("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 4e5 + 9;
int n, q, tree[2][4 * MAX], lazy[2][4 * MAX], l, r, idx, val;
vector<pair<pair<int, int>, char> > v;
map<int, int> encode, decode;
void push(int id, int low, int high, int pos) {
tree[id][pos] = max(tree[id][pos], lazy[id][pos]);
if (low != high) {
lazy[id][(pos << 1)] = max(lazy[id][(pos << 1)], lazy[id][pos]);
lazy[id][(pos << 1) + 1] = max(lazy[id][(pos << 1) + 1], lazy[id][pos]);
}
}
void upd(int id, int low, int high, int pos) {
push(id, low, high, pos);
if (l > high || r < low) {
return;
}
if (l <= low && r >= high) {
lazy[id][pos] = max(lazy[id][pos], val);
return;
}
int mid = ((low + high) >> 1);
upd(id, low, mid, (pos << 1));
upd(id, mid + 1, high, (pos << 1) + 1);
tree[id][pos] = max(tree[id][(pos << 1)], tree[id][(pos << 1) + 1]);
}
int qwr(int id, int low, int high, int pos) {
push(id, low, high, pos);
if (low == high) {
return tree[id][pos];
}
int mid = ((low + high) >> 1);
if (idx <= mid) {
return qwr(id, low, mid, (pos << 1));
} else {
return qwr(id, mid + 1, high, (pos << 1) + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> q;
for (int i = 1; i <= q; ++i) {
int x, y;
char type;
cin >> x >> y >> type;
encode[x];
encode[y];
v.push_back({{x, y}, type});
}
int cnt = 0;
for (auto& element : encode) {
element.second = ++cnt;
decode[cnt] = element.first;
}
for (int i = 0; i < q; ++i) {
int newX = encode[v[i].first.first], newY = encode[v[i].first.second];
char type = v[i].second;
if (type == 'L') {
idx = newY;
int lastX = qwr(1, 1, (q << 1), 1);
cout << decode[newX] - decode[lastX] << "\n";
l = lastX + 1;
r = newX;
val = newY;
upd(0, 1, (q << 1), 1);
l = newY;
r = newY, val = newX;
upd(1, 1, (q << 1), 1);
} else {
idx = newX;
int lastY = qwr(0, 1, (q << 1), 1);
cout << decode[newY] - decode[lastY] << "\n";
l = lastY + 1;
r = newY;
val = newX;
upd(1, 1, (q << 1), 1);
l = newX;
r = newX, val = newY;
upd(0, 1, (q << 1), 1);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, m, vx, vy, vz, t, t1, t2, x, z = 0;
cin >> a >> b >> m >> vx >> vy >> vz;
x = a / 2;
t2 = t1 = -m / vy;
while (t1) {
if (vx < 0) {
t = -x / vx;
if (t < t1) {
t1 -= t;
x = 0;
} else {
x += vx * t1;
t1 = 0;
}
} else {
t = (a - x) / vx;
if (t < t1) {
t1 -= t;
x = a;
} else {
x += vx * t1;
t1 = 0;
}
}
vx = -vx;
}
while (t2) {
if (vz < 0) {
t = -z / vz;
if (t < t2) {
t2 -= t;
z = 0;
} else {
z += vz * t2;
t2 = 0;
}
} else {
t = (b - z) / vz;
if (t < t2) {
t2 -= t;
z = b;
} else {
z += vz * t2;
t2 = 0;
}
}
vz = -vz;
}
printf("%.9f %.9f", x, z);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
string s;
cin >> s;
int a, b;
cin >> a >> b;
int n = s.size();
int arr[n];
memset(arr, -1, sizeof(arr));
string ans1, ans2;
int k = 0;
for (int i = 0; i < n; i++) {
int d = s[i] - '0';
k = ((k * 10) % a + d % a) % a;
if (k == 0) {
arr[i] = 0;
}
}
k = 0;
int p = 1;
for (int i = n - 1; i > 0; i--) {
int d = s[i] - '0';
k = ((k % b) + (p * (d % b)) % b) % b;
p = ((p % b) * (10 % b)) % b;
if (k == 0) {
if (arr[i - 1] == 0 && s[i] != '0') {
ans1 = s.substr(0, i);
ans2 = s.substr(i);
break;
}
}
}
if (ans2 != "" && ans1 != "") {
cout << "YES" << endl;
cout << ans1 << endl;
cout << ans2 << endl;
return 0;
}
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long p, k, ti, n;
long long t[100007], r[100007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> p >> k >> ti >> n;
for (int i = 1; i <= n; i++) cin >> t[i];
t[n + 1] = k - ti + 1;
t[0] = 0;
long long cnt = 0;
long long res;
long long mi = 1000000000000000;
for (int i = 1; i <= n + 1; i++) {
if (t[i] - 1 < p) {
r[i] = abs(p - t[i]) + cnt + 1;
cnt += ti;
} else {
r[i] = cnt - abs(p - (t[i] - 1));
cnt += ti;
}
if (t[i] - 1 < k && r[i] < mi && t[i] - 1 + r[i] <= k - ti) {
mi = r[i];
res = t[i] - 1;
}
}
cout << res;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int result = 1;
for (int i = 0; i < (x + y); ++i) {
result *= 2;
result %= 998244353;
}
cout << result;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-12;
const int INF = 999999999;
int n;
int a[3], b[3];
int c[100000];
void Read() {
for (int i = 0; i < 3; ++i) scanf("%d", &a[i]);
for (int i = 0; i < 3; ++i) scanf("%d", &b[i]);
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &c[i]);
}
long long Solve() {
priority_queue<pair<long long, vector<int> >,
vector<pair<long long, vector<int> > >,
greater<pair<long long, vector<int> > > >
Q;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
Qw[3];
for (int i = 0; i < n; ++i) {
vector<int> u(3);
u[0] = i, u[1] = -1, u[2] = 0;
Q.push(make_pair(c[i], u));
}
for (int i = 0; i < 3; ++i) {
a[i] = min(a[i], n);
for (int j = 0; j < a[i]; ++j) Qw[i].push(make_pair(0, 0));
}
long long res = 0;
while (!Q.empty()) {
pair<long long, vector<int> > u = Q.top();
Q.pop();
if (u.second[1] == 2) {
res = max(res, u.first - c[u.second[0]]);
continue;
}
int w = ++u.second[1];
pair<long long, int> wu = Qw[w].top();
Qw[w].pop();
u.first = max(wu.first, u.first) + b[w];
u.second[2] = wu.second;
wu.first = u.first;
Qw[w].push(wu);
Q.push(u);
}
return res;
}
int main() {
Read();
cout << Solve() << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5) + 5;
const int inf = (int)1e9 + 7;
int n, m;
vector<pair<int, int> > g[N];
int ban[N];
int dfs(int v) {
vector<int> to;
for (pair<int, int> i : g[v]) {
if (ban[i.second]) {
continue;
}
ban[i.second] = 1;
to.push_back(i.first);
}
vector<int> all;
for (int i : to) {
int w = dfs(i);
if (w == 0) {
all.push_back(i);
} else {
printf("%d %d %d\n", w, i, v);
}
}
while ((int)all.size() >= 2) {
printf("%d %d %d\n", all.back(), v, all[(int)all.size() - 2]);
all.pop_back(), all.pop_back();
}
return all.empty() ? 0 : all.back();
}
int main() {
scanf("%d %d", &n, &m);
if (m & 1) {
printf("No solution");
return 0;
}
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back({y, i});
g[y].push_back({x, i});
}
dfs(1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = 3.14159265358979323846264338327950288419716939937510;
const int inf = 0x3f3f3f3f;
const int mod = 1000000007;
const int mod2 = 1000000006;
const long long infll = 0x3f3f3f3f3f3f3f3fLL;
const int dx[8] = {0, 1, 0, -1, -1, 1, 1, -1};
const int dy[8] = {1, 0, -1, 0, 1, 1, -1, -1};
template <typename T>
inline bool RD(T& v) {
char c;
bool n;
while (c = getchar(), c != '-' && (c < '0' || c > '9'))
if (c == EOF) return false;
if (c == '-') {
n = true;
v = 0;
} else {
n = false;
v = c - '0';
}
while (c = getchar(), c >= '0' && c <= '9') v = (v << 3) + (v << 1) + c - '0';
if (n) v *= -1;
return true;
}
template <typename T>
inline bool RD(T& a, T& b) {
return RD(a) && RD(b);
}
template <typename T>
inline bool RD(T& a, T& b, T& c) {
return RD(a, b) && RD(c);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d) {
return RD(a, b, c) && RD(d);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e) {
return RD(a, b, c, d) && RD(e);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f) {
return RD(a, b, c, d, e) && RD(f);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f, T& g) {
return RD(a, b, c, d, e, f) && RD(g);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h) {
return RD(a, b, c, d, e, f, g) && RD(h);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h, T& i) {
return RD(a, b, c, d, e, f, g, h) && RD(i);
}
template <typename T>
inline bool RD(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h, T& i, T& j) {
return RD(a, b, c, d, e, f, g, h, i) && RD(j);
}
inline int RD() {
int v;
RD(v);
return v;
}
static char _BUF_[1 << 15], *_HEAD_ = _BUF_, *_TAIL_ = _BUF_;
inline static char getchar_buffered() {
return _HEAD_ == _TAIL_ &&
(_TAIL_ = (_HEAD_ = _BUF_) + fread(_BUF_, 1, 1 << 15, stdin),
_HEAD_ == _TAIL_)
? EOF
: *_HEAD_++;
}
template <typename T>
inline bool RDB(T& v) {
char c;
bool n;
while (c = getchar_buffered(), c != '-' && (c < '0' || c > '9'))
if (c == EOF) return false;
if (c == '-') {
n = true;
v = 0;
} else {
n = false;
v = c - '0';
}
while (c = getchar_buffered() - '0', c >= 0 && c <= 9)
v = (v << 3) + (v << 1) + c;
if (n) v *= -1;
return true;
}
template <typename T>
inline bool RDB(T& a, T& b) {
return RDB(a) && RDB(b);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c) {
return RDB(a, b) && RDB(c);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d) {
return RDB(a, b, c) && RDB(d);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e) {
return RDB(a, b, c, d) && RDB(e);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f) {
return RDB(a, b, c, d, e) && RDB(f);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f, T& g) {
return RDB(a, b, c, d, e, f) && RDB(g);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h) {
return RDB(a, b, c, d, e, f, g) && RDB(h);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h, T& i) {
return RDB(a, b, c, d, e, f, g, h) && RDB(i);
}
template <typename T>
inline bool RDB(T& a, T& b, T& c, T& d, T& e, T& f, T& g, T& h, T& i, T& j) {
return RDB(a, b, c, d, e, f, g, h, i) && RDB(j);
}
inline int RDB() {
int v;
RDB(v);
return v;
}
template <typename T>
inline void _WR(T a) {
if (a < 0) {
putchar('-');
a *= -1;
}
T t = a / 10;
if (t) _WR(t);
putchar(a - (t << 1) - (t << 3) + '0');
}
template <typename T>
inline void WR_(const T& a) {
_WR(a);
putchar(' ');
}
template <typename T>
inline void WR(const T& a) {
_WR(a);
putchar('\n');
}
template <typename T>
inline void _WR(const T& a, const T& b) {
WR_(a);
_WR(b);
}
template <typename T>
inline void WR_(const T& a, const T& b) {
WR_(a);
WR_(b);
}
template <typename T>
inline void WR(const T& a, const T& b) {
WR_(a);
WR(b);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c) {
WR_(a, b);
_WR(c);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c) {
WR_(a, b);
WR_(c);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c) {
WR_(a, b);
WR(c);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d) {
WR_(a, b, c);
_WR(d);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d) {
WR_(a, b, c);
WR_(d);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d) {
WR_(a, b, c);
WR(d);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e) {
WR_(a, b, c, d);
_WR(e);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e) {
WR_(a, b, c, d);
WR_(e);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e) {
WR_(a, b, c, d);
WR(e);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
WR_(a, b, c, d, e);
_WR(f);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
WR_(a, b, c, d, e);
WR_(f);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
WR_(a, b, c, d, e);
WR(f);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
WR_(a, b, c, d, e, f);
_WR(g);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
WR_(a, b, c, d, e, f);
WR_(g);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
WR_(a, b, c, d, e, f);
WR(g);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
WR_(a, b, c, d, e, f, g);
_WR(h);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
WR_(a, b, c, d, e, f, g);
WR_(h);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
WR_(a, b, c, d, e, f, g);
WR(h);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
WR_(a, b, c, d, e, f, g, h);
_WR(i);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
WR_(a, b, c, d, e, f, g, h);
WR_(i);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
WR_(a, b, c, d, e, f, g, h);
WR(i);
}
template <typename T>
inline void _WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
WR_(a, b, c, d, e, f, g, h, i);
_WR(j);
}
template <typename T>
inline void WR_(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
WR_(a, b, c, d, e, f, g, h, i);
WR_(j);
}
template <typename T>
inline void WR(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
WR_(a, b, c, d, e, f, g, h, i);
WR(j);
}
template <typename A>
inline istream& IN(A& a) {
return std::cin >> a;
}
template <typename A, typename B>
inline istream& IN(A& a, B& b) {
return std::cin >> a >> b;
}
template <typename A, typename B, typename C>
inline istream& IN(A& a, B& b, C& c) {
return std::cin >> a >> b >> c;
}
template <typename A, typename B, typename C, typename D>
inline istream& IN(A& a, B& b, C& c, D& d) {
return std::cin >> a >> b >> c >> d;
}
template <typename A, typename B, typename C, typename D, typename E>
inline istream& IN(A& a, B& b, C& c, D& d, E& e) {
return std::cin >> a >> b >> c >> d >> e;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f) {
return std::cin >> a >> b >> c >> d >> e >> f;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F, typename G>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f, G& g) {
return std::cin >> a >> b >> c >> d >> e >> f >> g;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h) {
return std::cin >> a >> b >> c >> d >> e >> f >> g >> h;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i) {
return std::cin >> a >> b >> c >> d >> e >> f >> g >> h >> i;
}
template <typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J>
inline istream& IN(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j) {
return std::cin >> a >> b >> c >> d >> e >> f >> g >> h >> i >> j;
}
inline std::ostream& OUT() { return std::cout << std::endl; }
template <typename T>
inline ostream& _OUT(const T& a) {
return std::cout << a;
}
template <typename T>
inline ostream& OUT_(const T& a) {
return std::cout << a << ' ';
}
template <typename T>
inline ostream& OUT(const T& a) {
return std::cout << a << std::endl;
}
template <typename T, typename U>
inline ostream& _OUT(const T& a, const U& b) {
return std::cout << a << " " << b;
}
template <typename T, typename U>
inline ostream& OUT_(const T& a, const U& b) {
return std::cout << a << " " << b << " ";
}
template <typename T, typename U>
inline ostream& OUT(const T& a, const U& b) {
return std::cout << a << " " << b << std::endl;
}
template <typename T, typename U, typename V>
inline ostream& _OUT(const T& a, const U& b, const V& c) {
OUT_(a, b);
return _OUT(c);
}
template <typename T, typename U, typename V>
inline ostream& OUT_(const T& a, const U& b, const V& c) {
OUT_(a, b);
return OUT_(c);
}
template <typename T, typename U, typename V>
inline ostream& OUT(const T& a, const U& b, const V& c) {
OUT_(a, b);
return OUT(c);
}
template <typename T, typename U, typename V, typename W>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d) {
OUT_(a, b, c);
return _OUT(d);
}
template <typename T, typename U, typename V, typename W>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d) {
OUT_(a, b, c);
return OUT_(d);
}
template <typename T, typename U, typename V, typename W>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d) {
OUT_(a, b, c);
return OUT(d);
}
template <typename T, typename U, typename V, typename W, typename X>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d,
const X& e) {
OUT_(a, b, c, d);
return _OUT(e);
}
template <typename T, typename U, typename V, typename W, typename X>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d,
const X& e) {
OUT_(a, b, c, d);
return OUT_(e);
}
template <typename T, typename U, typename V, typename W, typename X>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d,
const X& e) {
OUT_(a, b, c, d);
return OUT(e);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f) {
OUT_(a, b, c, d, e);
return _OUT(f);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f) {
OUT_(a, b, c, d, e);
return OUT_(f);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f) {
OUT_(a, b, c, d, e);
return OUT(f);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g) {
OUT_(a, b, c, d, e, f);
return _OUT(g);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g) {
OUT_(a, b, c, d, e, f);
return OUT_(g);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g) {
OUT_(a, b, c, d, e, f);
return OUT(g);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h) {
OUT_(a, b, c, d, e, f, g);
return _OUT(h);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h) {
OUT_(a, b, c, d, e, f, g);
return OUT_(h);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h) {
OUT_(a, b, c, d, e, f, g);
return OUT(h);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i) {
OUT_(a, b, c, d, e, f, g, h);
return _OUT(i);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i) {
OUT_(a, b, c, d, e, f, g, h);
return OUT_(i);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i) {
OUT_(a, b, c, d, e, f, g, h);
return OUT(i);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B, typename C>
inline ostream& _OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i,
const C& j) {
OUT_(a, b, c, d, e, f, g, h, i);
return _OUT(j);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B, typename C>
inline ostream& OUT_(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i,
const C& j) {
OUT_(a, b, c, d, e, f, g, h, i);
return OUT_(j);
}
template <typename T, typename U, typename V, typename W, typename X,
typename Y, typename Z, typename A, typename B, typename C>
inline ostream& OUT(const T& a, const U& b, const V& c, const W& d, const X& e,
const Y& f, const Z& g, const A& h, const B& i,
const C& j) {
OUT_(a, b, c, d, e, f, g, h, i);
return OUT(j);
}
template <typename A>
inline void clr(A& a) {
a.clear();
}
template <typename A, typename B>
inline void clr(A& a, B& b) {
a.clear();
b.clear();
}
template <typename A, typename B, typename C>
inline void clr(A& a, B& b, C& c) {
a.clear();
b.clear();
c.clear();
}
template <typename A, typename B, typename C, typename D>
inline void clr(A& a, B& b, C& c, D& d) {
a.clear();
b.clear();
c.clear();
d.clear();
}
template <typename A, typename B, typename C, typename D, typename E>
inline void clr(A& a, B& b, C& c, D& d, E& e) {
a.clear();
b.clear();
c.clear();
d.clear();
e.clear();
}
template <typename A, typename B, typename C, typename D, typename E,
typename F>
inline void clr(A& a, B& b, C& c, D& d, E& e, F& f) {
a.clear();
b.clear();
c.clear();
d.clear();
e.clear();
f.clear();
}
inline long long madd(long long a, long long b,
const long long mod = 1000000007) {
long long ret = (a + b) % mod;
if (ret < 0) ret += mod;
return ret;
}
inline long long msub(long long a, long long b,
const long long mod = 1000000007) {
long long ret = (a - b) % mod;
if (ret < 0) ret += mod;
return ret;
}
inline long long mmul(long long a, long long b,
const long long mod = 1000000007) {
return a * b % mod;
}
inline long long mpow(long long x, long long k,
const long long mod = 1000000007) {
x %= mod;
long long ret = 1;
while (k > 0) {
if (k & 1) ret = ret * x % mod;
x = x * x % mod;
k >>= 1;
}
return ret;
}
template <typename T, typename U>
inline bool cmax(T& a, const U& b) {
return a < b ? a = b, true : false;
}
template <typename T, typename U>
inline bool cmin(T& a, const U& b) {
return a > b ? a = b, true : false;
}
template <typename T, typename U>
inline T cadd(T& a, const U& b, const int mod = 1000000007) {
a = (a * 1LL + b) % mod;
if (a < 0) a += mod;
return a;
}
template <typename T, typename U>
inline T csub(T& a, const U& b, const int mod = 1000000007) {
a = (a * 1LL - b) % mod;
if (a < 0) a += mod;
return a;
}
template <typename T, typename U>
inline T cmul(T& a, const U& b, const int mod = 1000000007) {
return a = (a * 1LL * b) % mod;
}
template <typename T>
inline T clow(T& a, const int mod = 1000000007) {
while (a < 0) a += mod;
return a;
}
template <typename T>
inline T cup(T& a, const int mod = 1000000007) {
while (a >= mod) a -= mod;
return a;
}
template <typename T>
inline T cboth(T& a, const int mod = 1000000007) {
while (a < 0) a += mod;
while (a >= mod) a -= mod;
return a;
}
template <typename T>
inline T vlow(T a, const int mod = 1000000007) {
while (a < 0) a += mod;
return a;
}
template <typename T>
inline T vup(T a, const int mod = 1000000007) {
while (a >= mod) a -= mod;
return a;
}
template <typename T>
inline T vboth(T a, const int mod = 1000000007) {
while (a < 0) a += mod;
while (a >= mod) a -= mod;
return a;
}
template <typename T>
inline T max(const T& a, const T& b, const T& c) {
return std::max(std::max(a, b), c);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d) {
return std::max(max(a, b, c), d);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e) {
return std::max(max(a, b, c, d), e);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
return std::max(max(a, b, c, d, e), f);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
return std::max(max(a, b, c, d, e, f), g);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
return std::max(max(a, b, c, d, e, f, g), h);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
return std::max(max(a, b, c, d, e, f, g, h), i);
}
template <typename T>
inline T max(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
return std::max(max(a, b, c, d, e, f, g, h, i), j);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c) {
return std::min(std::min(a, b), c);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d) {
return std::min(min(a, b, c), d);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e) {
return std::min(min(a, b, c, d), e);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f) {
return std::min(min(a, b, c, d, e), f);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g) {
return std::min(min(a, b, c, d, e, f), g);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h) {
return std::min(min(a, b, c, d, e, f, g), h);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i) {
return std::min(min(a, b, c, d, e, f, g, h), i);
}
template <typename T>
inline T min(const T& a, const T& b, const T& c, const T& d, const T& e,
const T& f, const T& g, const T& h, const T& i, const T& j) {
return std::min(min(a, b, c, d, e, f, g, h, i), j);
}
struct default_random_weight_generator {
int operator()() const { return rand() << 15 | rand(); }
};
template <typename T,
typename RandomWeightGenerator = default_random_weight_generator>
struct treap_node_base {
T val;
int weight;
size_t subtree_size;
treap_node_base *father, *left, *right;
static RandomWeightGenerator generate_weight;
treap_node_base(T v = 0)
: val(v),
weight(generate_weight()),
subtree_size(1),
father(0),
left(0),
right(0) {}
virtual void downpush() {}
};
template <typename T, typename RandomWeightGenerator>
RandomWeightGenerator
treap_node_base<T, RandomWeightGenerator>::generate_weight =
RandomWeightGenerator();
template <typename T, typename TreapNode = treap_node_base<T> >
class treap_tree {
private:
TreapNode* __root;
public:
treap_tree(TreapNode* r = 0) : __root(r) {}
treap_tree(const treap_tree& tt) : __root(tt.__root) {}
void destroy() { __destroy(__root); }
void clear() {
__destroy(__root);
__root = 0;
}
size_t size() const { return __root ? __root->subtree_size : 0; }
bool empty() const { return !__root; }
TreapNode* root() const { return __root; }
TreapNode* insert(const T& val) {
TreapNode* newnode = new TreapNode(val);
return insert(newnode);
}
TreapNode* insert(TreapNode* newnode) {
if (!__root) {
__root = newnode;
return newnode;
}
__insert(__root, newnode);
__rotate(newnode);
return newnode;
}
void erase(const T& val) {
TreapNode* pos;
while (pos = __find(__root, val)) __erase(pos);
}
void erase(TreapNode* node) {
if (!node) return;
__erase(node);
}
TreapNode* find(const T& val) const { return __find(__root, val); }
std::pair<treap_tree, treap_tree> split(const T& k) {
TreapNode *l, *r;
__split(__root, k, l, r);
return std::make_pair(treap_tree(l), treap_tree(r));
}
treap_tree& merge(treap_tree& rhs) {
__root = __merge(__root, rhs.__root);
return *this;
}
void downpush_all() { __downpush_all(__root); }
TreapNode* max_element() const {
TreapNode* u = __root;
assert(u);
u->downpush();
while (u->right) {
u = u->right;
u->downpush();
}
return u;
}
TreapNode* min_element() const {
TreapNode* u = __root;
assert(u);
u->downpush();
while (u->left) {
u = u->left;
u->downpush();
}
return u;
}
private:
void __destroy(TreapNode* u) {
if (!u) return;
__destroy(u->left);
__destroy(u->right);
delete u;
}
void __downpush_all(TreapNode* u) {
if (!u) return;
u->downpush();
__downpush_all(u->left);
__downpush_all(u->right);
}
TreapNode* __merge(TreapNode* l, TreapNode* r) {
if (!l) return r;
if (!r) return l;
l->downpush();
r->downpush();
if (l->weight < r->weight) {
l->subtree_size += r->subtree_size;
r = __merge(l->right, r);
l->right = r;
r->father = l;
return l;
} else {
r->subtree_size += l->subtree_size;
l = __merge(l, r->left);
l->father = r;
r->left = l;
return r;
}
}
void __split(TreapNode* u, const T& k, TreapNode*& l, TreapNode*& r) {
if (!u) {
l = r = NULL;
return;
}
u->downpush();
if (u->val < k) {
__split(u->right, k, l, r);
if (r) u->subtree_size -= r->subtree_size;
u->right = l;
if (l) l->father = u;
if (r) r->father = NULL;
l = u;
} else {
__split(u->left, k, l, r);
if (l) u->subtree_size -= l->subtree_size;
u->left = r;
if (r) r->father = u;
if (l) l->father = NULL;
r = u;
}
}
TreapNode* __find(TreapNode* u, const T& val) const {
if (!u) return u;
if (u->val < val) return __find(u->right, val);
if (u->val > val) return __find(u->left, val);
return u;
}
void __erase(TreapNode* node) {
node->downpush();
while (node->left && node->right) {
if (node->left->weight < node->right->weight)
__right_rotate(node);
else
__left_rotate(node);
}
TreapNode* f = node->father;
while (f) {
--(f->subtree_size);
f = f->father;
}
if (node->left) {
node->left->father = node->father;
if (node == __root)
__root = node->left;
else {
if (node == node->father->left)
node->father->left = node->left;
else
node->father->right = node->left;
}
} else if (node->right) {
node->right->father = node->father;
if (node == __root)
__root = node->right;
else {
if (node == node->father->left)
node->father->left = node->right;
else
node->father->right = node->right;
}
} else {
if (node == __root)
__root = NULL;
else {
if (node == node->father->left)
node->father->left = NULL;
else
node->father->right = NULL;
}
}
delete node;
}
TreapNode* __insert(TreapNode* cur, TreapNode* newnode) {
++(cur->subtree_size);
cur->downpush();
if (newnode->val < cur->val) {
if (cur->left != 0) return __insert(cur->left, newnode);
cur->left = newnode;
newnode->father = cur;
return newnode;
} else {
if (cur->right != 0) return __insert(cur->right, newnode);
cur->right = newnode;
newnode->father = cur;
return newnode;
}
}
void __rotate(TreapNode* newnode) {
while (newnode->father) {
TreapNode* f = newnode->father;
if (newnode->weight >= f->weight) break;
if (newnode == (f->left))
__right_rotate(f);
else
__left_rotate(f);
}
}
void __left_rotate(TreapNode* f) {
TreapNode* r = f->right;
f->downpush();
r->downpush();
--(f->subtree_size);
if (r->right) f->subtree_size -= r->right->subtree_size;
++(r->subtree_size);
if (f->left) r->subtree_size += f->left->subtree_size;
r->father = f->father;
if (f == __root)
__root = r;
else {
if (f->father->left == f)
f->father->left = r;
else
f->father->right = r;
}
f->right = r->left;
if (r->left) r->left->father = f;
r->left = f;
f->father = r;
}
void __right_rotate(TreapNode* f) {
TreapNode* l = f->left;
f->downpush();
l->downpush();
--(f->subtree_size);
if (l->left) f->subtree_size -= l->left->subtree_size;
++(l->subtree_size);
if (f->right) l->subtree_size += f->right->subtree_size;
l->father = f->father;
if (f == __root)
__root = l;
else {
if (f->father->left == f)
f->father->left = l;
else
f->father->right = l;
}
f->left = l->right;
if (l->right) l->right->father = f;
l->right = f;
f->father = l;
}
};
const int _ = (int)(2e5 + 10);
const int __ = (int)(1e6 + 10);
const int LOG = 20;
struct TreapNode : treap_node_base<int> {
TreapNode *father, *left, *right;
int cnt, id;
int val_lazy, cnt_lazy;
TreapNode(int v = 0, int i = 0)
: treap_node_base(v),
cnt(0),
id(i),
val_lazy(0),
cnt_lazy(0),
father(0),
left(0),
right(0) {}
void downpush() override {
if (left) {
left->apply(val_lazy, cnt_lazy);
}
if (right) {
right->apply(val_lazy, cnt_lazy);
}
val_lazy = cnt_lazy = 0;
}
void apply(int dv, int dc) {
val += dv;
val_lazy += dv;
cnt += dc;
cnt_lazy += dc;
}
};
treap_tree<int, TreapNode> tt;
int n, k;
pair<int, int> tshirt[_];
int ans[_];
void dfs(TreapNode* u) {
if (!u) return;
ans[u->id] = u->cnt;
dfs(u->left);
dfs(u->right);
}
inline void _main() {
RDB(n);
for (long long i = 0; i < (long long)(n); ++i) {
RDB(tshirt[i].second, tshirt[i].first);
tshirt[i].first *= -1;
}
sort(tshirt, tshirt + n);
RDB(k);
for (long long i = 0; i < (long long)(k); ++i)
tt.insert(new TreapNode(RDB(), i));
for (long long i = 0; i < (long long)(n); ++i) {
int c = tshirt[i].second;
treap_tree<int, TreapNode> l, r;
tie(l, r) = tt.split(c);
if (r.empty()) continue;
r.root()->apply(-c, 1);
if (l.empty()) continue;
TreapNode* lr = l.max_element();
TreapNode* rl = r.min_element();
while (lr->val > rl->val) {
treap_tree<int, TreapNode> Rl, Rr;
tie(Rl, Rr) = r.split(rl->val + 1);
treap_tree<int, TreapNode> Ll, Lr;
tie(Ll, Lr) = l.split(rl->val);
l = Ll.merge(Rl).merge(Lr);
r = Rr;
if (l.empty() || r.empty()) break;
lr = l.max_element();
rl = r.min_element();
}
tt = l.merge(r);
}
tt.downpush_all();
dfs(tt.root());
{
for (long long _i_ = (long long)(0); _i_ < (long long)(k - 1); ++_i_)
WR_((ans)[_i_]);
if (k > 0) WR((ans)[k - 1]);
};
tt.destroy();
}
void generate_test_case() { exit(0); }
int main() {
_main();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, freq[205] = {}, x[205], l = 0, r = 0, res[205] = {}, k = 0;
cin >> n;
for (int i = 0; i < 2 * n; i++) {
cin >> x[i];
if (freq[x[i]] < 2) freq[x[i]]++;
}
for (int i = 0; i < 2 * n; i++) {
if (freq[x[i]] == 1) {
if (l < r) {
res[i] = 1;
l++;
} else {
res[i] = 2;
r++;
}
} else if (freq[x[i]] < 4) {
freq[x[i]]++;
res[i] = freq[x[i]] - 2;
if (freq[x[i]] == 3) k++;
}
}
cout << l * r + k * l + k * r + k * k << endl;
for (int i = 0; i < 2 * n; i++) {
if (!res[i]) {
if (l + k < n) {
res[i] = 1;
l++;
} else {
res[i] = 2;
r++;
}
}
}
for (int i = 0; i < 2 * n; i++) cout << res[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
const int mod = 10007;
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int mul(int x, int y) { return x * y % mod; }
int pw(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = mul(ret, x);
x = mul(x, x);
y >>= 1;
}
return ret;
}
namespace berlekamp_massey {
vector<int> bm(vector<int> x) {
vector<int> rel, cur;
int lf, ld;
for (int i = 0; i < x.size(); ++i) {
int sum = 0;
for (int j = 0; j < cur.size(); ++j) add(sum, mul(x[i - j - 1], cur[j]));
if (sum == x[i]) continue;
if (!cur.size()) {
cur.resize(i + 1);
lf = i;
ld = sum - x[i];
add(ld, mod);
continue;
}
int coef = mul(sum - x[i] + mod, pw(ld, mod - 2));
vector<int> new_cur(i - lf - 1);
new_cur.push_back(coef);
for (int j = 0; j < rel.size(); ++j) {
new_cur.push_back(mul(mod - rel[j], coef));
}
if (new_cur.size() < cur.size()) new_cur.resize(cur.size());
for (int j = 0; j < cur.size(); ++j) add(new_cur[j], cur[j]);
if (i - lf + rel.size() >= cur.size()) {
rel = cur, lf = i, ld = sum - x[i];
add(ld, mod);
}
cur = new_cur;
}
return cur;
}
int sz;
int a[5005], rel[5005], tmp[5005];
int ff[5005], gg[5005];
void mulmod(int *p, int *q) {
for (int i = 0; i < sz + sz; ++i) tmp[i] = 0;
for (int i = 0; i < sz; ++i)
if (p[i]) {
for (int j = 0; j < sz; ++j) {
add(tmp[i + j], mul(p[i], q[j]));
}
}
for (int i = sz + sz - 1; i >= sz; --i)
if (tmp[i]) {
for (int j = sz - 1; j >= 0; --j) {
add(tmp[i - j - 1], mul(tmp[i], rel[j]));
}
}
for (int i = 0; i < sz; ++i) p[i] = tmp[i];
}
int solve(vector<int> x, int n) {
if (n < x.size()) return x[n];
vector<int> cur = bm(x);
sz = cur.size();
for (int i = 0; i < sz; ++i) rel[i] = cur[i], a[i] = x[i];
for (int i = 0; i < sz; ++i) ff[i] = gg[i] = 0;
ff[0] = 1;
if (sz > 1)
gg[1] = 1;
else
gg[0] = rel[0];
while (n) {
if (n & 1) mulmod(ff, gg);
mulmod(gg, gg);
n >>= 1;
}
int ret = 0;
for (int i = 0; i < sz; ++i) add(ret, mul(ff[i], a[i]));
return ret;
}
} // namespace berlekamp_massey
using namespace berlekamp_massey;
int n, m;
string s;
int f[805][N][N], ans[1405];
vector<int> g;
int main() {
ios_base::sync_with_stdio(false);
cin >> s >> n;
m = s.size();
s = '~' + s;
f[0][0][0] = 1;
int len = m + 1400 >> 1;
for (int i = 1; i <= len; ++i) {
for (int j = 0; j <= m; ++j) {
for (int k = 0; k <= m; ++k) {
if (f[i - 1][j][k] == 0) continue;
if (j == m && k == m)
add(f[i][j][k], mul(26, f[i - 1][j][k]));
else if (j == m) {
add(f[i][j][k], mul(25, f[i - 1][j][k]));
add(f[i][j][k + 1], f[i - 1][j][k]);
} else if (k == m) {
add(f[i][j][k], mul(25, f[i - 1][j][k]));
add(f[i][j + 1][k], f[i - 1][j][k]);
} else {
if (s[j + 1] == s[m + 1 - k - 1]) {
add(f[i][j + 1][k + 1], f[i - 1][j][k]);
add(f[i][j][k], mul(25, f[i - 1][j][k]));
} else {
add(f[i][j + 1][k], f[i - 1][j][k]);
add(f[i][j][k + 1], f[i - 1][j][k]);
add(f[i][j][k], mul(24, f[i - 1][j][k]));
}
}
}
}
}
for (int i = 0; i < 1400; ++i) {
int l = m + i >> 1;
for (int j = 0; j <= m; ++j) {
for (int k = 0; k <= m; ++k) {
if (j + k >= m) {
if (m + i & 1)
add(ans[i], mul(26, f[l][j][k]));
else
add(ans[i], f[l][j][k]);
}
if (j + k == m - 1) {
if (m + i & 1) add(ans[i], f[l][j][k]);
}
}
}
}
for (int i = 0; i < 1400; ++i) g.push_back(ans[i]);
cout << solve(g, n) << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int ms = 200200;
int n, m, k;
int ans[ms];
std::pair<int, int> edges[ms];
std::vector<int> use[ms];
int deg[ms];
bool del[ms];
int main() {
std::cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
use[u].push_back(i);
use[v].push_back(i);
deg[u]++;
deg[v]++;
edges[i] = std::pair<int, int>(u, v);
}
std::queue<int> q;
for (int i = 1; i <= n; i++) {
if (deg[i] < k) {
q.push(i);
}
}
del[m] = true;
int cur_ans = n;
for (int i = m; i >= 0; i--) {
if (!del[i]) {
int u = edges[i].first, v = edges[i].second;
if (deg[u] == k) {
q.push(u);
}
if (deg[v] == k) {
q.push(v);
}
deg[u]--;
deg[v]--;
del[i] = true;
}
while (!q.empty()) {
cur_ans--;
int on = q.front();
q.pop();
for (auto e : use[on]) {
if (!del[e]) {
int u = edges[e].first, v = edges[e].second;
if (deg[u] == k) {
q.push(u);
}
if (deg[v] == k) {
q.push(v);
}
deg[u]--;
deg[v]--;
del[e] = true;
}
}
}
ans[i] = cur_ans;
}
for (int i = 0; i < m; i++) {
printf("%d\n", ans[i + 1]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];
vector<pair<int, int> > wz;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int fg = 0;
int sb1 = 0, sb2 = 0;
for (int i = n; i >= 1; i--) {
if (a[i] < a[i - 1]) {
if (fg == 0) {
sb1 = i;
fg = 1;
}
} else {
if (fg == 1) {
sb2 = i;
fg = 0;
wz.push_back(pair<int, int>(sb2, sb1));
}
fg = 0;
}
}
a[n + 1] = 1e9 + 7;
if (wz.size() > 1)
printf("no");
else if (wz.size() != 0) {
if (a[wz[0].first] < a[wz[0].second + 1] &&
a[wz[0].second] > a[wz[0].first - 1])
printf("yes\n%d %d", wz[0].first, wz[0].second);
else
printf("no");
} else if (wz.size() == 0) {
printf("yes\n1 1");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 5, mod = 998244353;
long long n, k, a[N], ji[N], ou[N], dp[N][2], cji = 1, cou = 1;
int main() {
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
if (i % 2 == 1)
ji[++ji[0]] = a[i];
else
ou[++ou[0]] = a[i];
}
dp[0][0] = 0;
dp[0][1] = 1;
for (int i = 1; i <= n; i++) {
dp[i][0] = dp[i - 1][1] * (k - 1) % mod;
dp[i][1] = (dp[i - 1][0] % mod + (k - 2) * dp[i - 1][1] % mod) % mod;
}
int i = 0;
while (ji[i + 1] == -1 && i + 1 <= ji[0]) i++;
if (i > 0) {
if (i < ji[0]) cji *= (dp[i - 1][0] + dp[i - 1][1] * (k - 1)) % mod;
if (i == ji[0]) {
if (i - 2 >= 0)
cji = k * dp[i - 2][0] + k * (k - 1) * dp[i - 2][1];
else
cji = k;
}
}
while (i + 1 <= ji[0]) {
int l, r;
while (ji[i + 1] != -1 && i + 1 <= ji[0]) {
i++;
if (ji[i] == ji[i - 1]) {
printf("0\n");
return 0;
}
}
l = i;
if (l == ji[0]) break;
while (ji[i + 1] == -1 && i + 1 <= ji[0]) i++;
r = i + 1;
if (r > ji[0])
cji *= (dp[r - l - 2][0] + dp[r - l - 2][1] * (k - 1)) % mod;
else if (ji[l] == ji[r])
cji *= dp[r - l - 1][0];
else
cji *= dp[r - l - 1][1];
cji %= mod;
}
i = 0;
while (ou[i + 1] == -1 && i + 1 <= ou[0]) i++;
if (i > 0) {
if (i < ou[0]) cou *= (dp[i - 1][0] + dp[i - 1][1] * (k - 1)) % mod;
if (i == ou[0]) {
if (i - 2 >= 0)
cou = k * dp[i - 2][0] + k * (k - 1) * dp[i - 2][1];
else
cou = k;
}
}
while (i + 1 <= ou[0]) {
int l, r;
while (ou[i + 1] != -1 && i + 1 <= ou[0]) {
i++;
if (ou[i] == ou[i - 1]) {
printf("0\n");
return 0;
}
}
l = i;
if (l == ou[0]) break;
while (ou[i + 1] == -1 && i + 1 <= ou[0]) i++;
r = i + 1;
if (r > ou[0])
cou *= (dp[r - l - 2][0] + dp[r - l - 2][1] * (k - 1)) % mod;
else if (ou[l] == ou[r])
cou *= dp[r - l - 1][0];
else
cou *= dp[r - l - 1][1];
cou %= mod;
}
printf("%lld\n", cji * cou % mod);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int precal[100005];
map<long long int, long long int> s[26];
vector<int> v;
long long int nc2(long long int x) {
x = (x) * (x - 1);
x /= 2;
return x;
}
int main() {
int i, j, val;
long long int ans = 0;
for (i = 0; i < 26; i++) {
cin >> val;
v.push_back(val);
}
string str;
cin >> str;
str = "#" + str;
long long int sum = 0;
for (i = 1; i < str.length(); i++) {
int to = int(str[i]) - 97;
sum += v[to];
precal[i] = sum;
}
long long int tmp;
for (i = 1; i < str.length(); i++) {
int to = int(str[i]) - 97;
tmp = precal[i];
tmp -= v[to];
ans += s[to][tmp];
s[to][precal[i]]++;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> V[100200];
const long long INF = (long long)1e14;
long long a[100200];
long long d[100200];
bool visited[100200];
long long x = INF;
long long ss = 0;
int n;
void swap(long long &a, long long &b) {
long long tmo = a;
a = b;
b = tmo;
}
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
assert(b != 0);
while (a % b != 0) {
long long r = a % b;
a = b;
b = r;
}
return b;
}
long long lcm(long long a, long long b) {
if (a >= INF || b >= INF) return (INF);
long long re = gcd(a, b);
if (a / re >= INF / b) return INF;
return (a / re) * b;
}
void minimize(long long &a, long long b) {
if (a > b) a = b;
}
void predfs(int u) {
visited[u] = true;
long long cnt = 0;
long long res = 1;
for (int i = 0; i < V[u].size(); i++) {
int v = V[u][i];
if (!visited[v]) {
predfs(v);
a[u] += a[v];
res = lcm(res, d[v]);
cnt++;
}
}
if (cnt == 0) {
d[u] = 1;
return;
}
if (res >= INF / cnt)
d[u] = INF;
else
d[u] = res * cnt;
}
void dfs(int u) {
visited[u] = true;
long long cnt = 0;
minimize(x, a[u] / d[u]);
if (x == 0) return;
for (int i = 0; i < V[u].size(); i++) {
int v = V[u][i];
if (!visited[v]) cnt++;
}
for (int i = 0; i < V[u].size(); i++) {
int v = V[u][i];
if (!visited[v]) {
d[v] = d[u] / cnt;
dfs(v);
if (x == 0) return;
}
}
}
void loadgraph() {
memset(d, 0, sizeof d);
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
ss += a[i];
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
V[u].push_back(v);
V[v].push_back(u);
}
}
void solve() {
memset(visited, 0, sizeof visited);
predfs(1);
memset(visited, 0, sizeof visited);
dfs(1);
printf("%I64d", ss - d[1] * x);
}
int main() {
loadgraph();
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> res;
for (int i = 1; i <= min(81, n); i++) {
int x = n - i;
int s = 0;
while (x) {
s += (x % 10);
x /= 10;
}
if (s == i) res.push_back(n - i);
}
cout << res.size() << "\n";
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++) cout << res[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T min(T& x, const T& y) {
return x > y ? y : x;
}
template <class T>
inline T max(T& x, const T& y) {
return x < y ? y : x;
}
long long read() {
long long c = getchar(), Nig = 1, x = 0;
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') Nig = -1, c = getchar();
while (isdigit(c)) x = ((x << 1) + (x << 3)) + (c ^ '0'), c = getchar();
return Nig * x;
}
const long long inf = 1e15;
const long long INF = 0x3f3f3f3f;
const int maxn = 1e6 + 7;
const int mod = 1e9 + 7;
inline long long gcd(long long a, long long b) {
long long t;
while (b != 0) {
t = a % b;
a = b;
b = t;
}
return a;
}
inline long long qPow(long long x, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = (res * x);
k >>= 1;
x = (x * x);
}
return res;
}
priority_queue<int, vector<int>, greater<int> > xiaogen;
priority_queue<int, vector<int>, less<int> > dagen;
int a[maxn], b[maxn];
bool cmp(int a, int b) { return a > b; }
int main() {
int T = read();
while (T--) {
int n = read(), x = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) b[i] = read();
sort(a + 1, a + 1 + n, cmp);
sort(b + 1, b + 1 + n);
long long c = b[1];
int flag = 1;
for (int i = 1; i <= n; i++) {
if (a[i] + b[i] > x) {
flag = 0;
break;
}
}
if (flag)
puts("Yes");
else
puts("No");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, i;
cin >> n;
map<string, long long int> m;
vector<vector<string> > vec;
vector<string> name;
for (i = 1; i <= n; i++) {
string s = "";
int p;
cin >> s >> p;
auto it = m.find(s);
long long int f = -1;
if (it != m.end()) {
f = it->second;
}
long long int j;
vector<string> str;
for (j = 1; j <= p; j++) {
string ph = "";
cin >> ph;
if (f != -1) {
vec[f].push_back(ph);
} else {
str.push_back(ph);
}
}
if (f == -1) {
vec.push_back(str);
m[s] = vec.size() - 1;
name.push_back(s);
}
}
for (i = 0; i < vec.size(); i++) {
if (vec[i].size() == 1) continue;
long long int j = 0;
long long int k;
long long int nn = vec[i].size();
for (j = 0; j < (vec[i].size()); j++) {
string sr = vec[i][j];
for (k = 0; k < vec[i].size(); k++) {
if (j == k) continue;
string tr = vec[i][k];
if (sr.size() > tr.size()) continue;
long long int x = sr.size() - 1;
long long int y = tr.size() - 1;
int ff = 1;
while (x >= 0 && y >= 0) {
if (sr[x] != tr[y]) {
ff = 0;
break;
}
x--;
y--;
}
if (ff) {
vec[i].erase(vec[i].begin() + j);
j--;
break;
}
}
}
}
cout << vec.size() << "\n";
for (i = 0; i < vec.size(); i++) {
cout << name[i] << " " << vec[i].size() << " ";
long long int j;
for (j = 0; j < vec[i].size(); j++) {
cout << vec[i][j] << " ";
}
cout << "\n";
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
int t;
t = 1;
while (t > 0) {
t--;
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
int count = 0;
vector<int> v(101, 0);
int sum = 0;
while (m--) {
int x, y, z;
cin >> x >> y >> z;
v[x] -= z;
v[y] += z;
}
for (int i = 0; i <= n; i++) {
if (v[i] >= 0) sum += v[i];
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int l, r, m;
cin >> l >> r;
if (r - l < l) {
cout << r - l << endl;
} else {
m = (r / 2) + 1;
cout << r % m << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
struct rec {
double x, y;
} a[110], s, e, f[2];
int g[2], n, m, i;
double ans;
double XJ(rec a, rec b, rec c) {
return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}
double dist(rec a, rec b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
void cross(rec a, rec b, rec c, rec d) {
double t1 = XJ(a, c, b), t2 = XJ(a, b, d), t3 = XJ(c, a, d), t4 = XJ(c, d, b);
if (fabs(t1) < eps && fabs(t2) < eps) return;
if (fabs(dist(a, c) + dist(b, c) - dist(a, b)) < eps) {
f[m] = c;
g[m++] = i;
return;
}
if (t1 * t2 > eps && t3 * t4 > eps) {
f[m].x = (t1 * d.x + t2 * c.x) / (t1 + t2);
f[m].y = (t1 * d.y + t2 * c.y) / (t1 + t2);
g[m++] = i;
return;
}
}
double calc(int st, int ed, int s, int e) {
if (ed == 1)
ed = n;
else
ed--;
double ans = dist(f[s], a[st]);
for (int i = st; i != ed; i == n ? i = 1 : i++)
ans += dist(a[i], a[i == n ? 1 : i + 1]);
return ans + dist(a[ed], f[e]);
}
int main() {
scanf("%lf%lf%lf%lf%d", &s.x, &s.y, &e.x, &e.y, &n);
for (i = 1; i <= n; i++) cin >> a[i].x >> a[i].y;
a[0] = a[n];
for (i = 1; i <= n; i++) cross(s, e, a[i - 1], a[i]);
if (m > 1) {
if (dist(s, f[0]) > dist(s, f[1])) swap(f[0], f[1]), swap(g[0], g[1]);
ans = min(calc(g[0], g[1], 0, 1), calc(g[1], g[0], 1, 0));
ans = min(ans, 2 * dist(f[0], f[1]));
ans += dist(s, f[0]) + dist(f[1], e);
} else
ans = dist(s, e);
printf("%.10lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
long n, m;
std::cin >> n >> m;
std::string s, t;
std::cin >> s >> t;
bool possible(s.size() <= 1 + t.size());
long sl(0), tl(0), sr(s.size() - 1), tr(t.size() - 1);
while (sl < s.size() && tl < t.size() && s[sl] == t[tl]) {
++sl;
++tl;
}
if ((sl < s.size()) && s[sl] != '*') {
possible = false;
} else if (sl == s.size()) {
possible = (s.size() == t.size());
}
while (0 <= sr && 0 <= tr && s[sr] == t[tr]) {
--sr;
--tr;
}
if ((sr >= 0) && s[sr] != '*') {
possible = false;
} else if (sr < 0) {
possible = (s.size() == t.size());
}
for (long p = tl; p <= tr; p++) {
if (t[p] < 'a' || t[p] > 'z') {
possible = false;
}
}
std::cout << (possible ? "YES" : "NO") << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, i, j, a[200001], b, d, c = 1;
int main() {
cin >> n;
cout << 1 + (3 * n * (n + 4) + 2 - pow(-1, n) * (n * (n + 4) + 2)) / 8;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 100;
const int INF = 1000 * 1000 * 1000;
int n, m, k, a[MAXN][MAXN];
vector<pair<int, int> > ans;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> a[i][j];
for (int l = 1; l < m; ++l)
for (int r = l + 1; r <= m; ++r) {
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (k == 0 && a[i][r] < a[i][l]) cnt++;
if (k == 1 && a[i][r] > a[i][l]) cnt++;
}
if (cnt >= 1) {
ans.push_back(make_pair(l, r));
for (int i = 1; i <= n; ++i) {
if (k == 0 && a[i][l] > a[i][r]) swap(a[i][r], a[i][l]);
if (k == 1 && a[i][l] < a[i][r]) swap(a[i][r], a[i][l]);
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) {
if (k == 0)
cout << ans[i].first << " " << ans[i].second << endl;
else
cout << ans[i].second << " " << ans[i].first << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e6 + 10;
int a[MAX_N];
int res;
const int BUFSIZE = MAX_N;
char buf[BUFSIZE + 1];
string nextString() {
scanf("%s", buf);
return buf;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < (n); ++i) cin >> a[i];
int mx = 0;
for (int i = 1; i < n; ++i) mx = max(mx, a[i]);
while (a[0] <= mx) {
for (int i = 1; a[0] <= mx && i < n; ++i)
if (a[i] == mx) {
a[i]--;
a[0]++;
++res;
}
--mx;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long int t;
cin >> t;
while (t--) {
long long int n, k;
bool val;
cin >> n >> k;
if (n < k)
n % 3 == 0 ? val = false : val = true;
else if (n == k)
val = true;
else {
if (k % 3 != 0) {
n % 3 == 0 ? val = false : val = true;
} else {
n = n - k;
n = n % (k + 1);
n % 3 == 1 ? val = false : val = true;
}
}
val ? cout << "Alice\n" : cout << "Bob\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int ncr(long long int n, long long int r) {
long long int ans = 1;
if (r > n - r) r = n - r;
for (int i = 1; i <= r; i++) ans = ans * (n - i + 1) / i;
return ans;
}
long long int sumofdigits(long long int n) {
long long int sum = 0;
while (n > 0) {
sum += n % 10;
n = n / 10;
}
return sum;
}
int main() {
long long int n, t, nt = 0;
cin >> n;
vector<long long int> q;
for (int i = 0; i <= 100; i++) {
t = n - i;
if (t >= 0 && t + sumofdigits(t) == n) {
q.push_back(t);
nt++;
}
}
cout << nt << endl;
sort(q.begin(), q.end());
for (int i = 0; i < nt; i++) {
cout << q[i] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct I {
int x, y;
};
int a, b, k, n, c, d, m, i, e, o[311113], l[335222],
dx[20] = {1, 0, -1, 0}, dy[20] = {0, 1, 0, -1}, dz[20] = {1, -1};
long long x, y, z[110];
int j[501060];
char r2[50005];
struct P {
int x, y;
bool operator<(const P &a) const { return x > a.x; }
};
stack<P> s;
double u[110000];
vector<P> v[411010];
queue<P> q;
queue<int> q1;
string r[666], r1;
map<int, int> p;
bool asd(P a, P b) { return a.x < b.x; }
int f(int t) {
if (o[t]) return o[t];
if (t == 0) return 1;
int k = f(t / b);
if (t / b % 2)
return o[t] = k * f(t % b) % b;
else
return o[t] = k * (b - f(t % b)) % b;
}
int main() {
scanf("%d %d", &a, &b);
for (int t = 0;; t++) {
if (a > b) {
printf("%d", t);
return 0;
}
a *= 3;
b <<= 1;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5010;
int p[MAX_N][MAX_N];
int b[MAX_N][MAX_N];
vector<int> adj[MAX_N];
bool visit[MAX_N];
int par[MAX_N];
int Height[MAX_N];
int dp[MAX_N];
void dfs(int root) {
visit[root] = 1;
for (int i = 0; i < adj[root].size(); i++) {
if (visit[adj[root][i]] == 0) {
dfs(adj[root][i]);
}
dp[root] = max(dp[root], dp[adj[root][i]] + 1);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int y;
cin >> y;
y--;
p[i][j] = y;
b[i][y] = j;
}
}
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
int cnt = 0;
for (int l = 0; l < m; l++) {
if (b[l][p[0][i]] < b[l][p[0][j]]) {
cnt++;
}
}
if (cnt == m) {
adj[p[0][j]].push_back(p[0][i]);
}
}
}
for (int i = 0; i < n; i++) {
if (visit[i] == 0) {
dfs(i);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, dp[i]);
}
cout << ans + 1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int analisa(int a[], int n) {
int j;
for (j = 0; j < n - 1; j++) {
if (a[j] > a[j + 1]) {
return 1;
}
}
return 0;
}
int main() {
int t, n, i, j;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int t = 0, y = 0, k = 0, kul = 0;
k = 0;
int g = n;
int u = n - 1;
while (1) {
if (analisa(a, n) != 1) {
break;
}
if (kul % 2 != 0) {
for (i = 1; i < n; i += 2) {
t = a[i];
y = a[i + 1];
if (a[i] > a[i + 1]) {
a[i] = y;
a[i + 1] = t;
}
}
} else {
for (i = 0; i < n - 1; i += 2) {
t = a[i];
y = a[i + 1];
if (a[i] > a[i + 1]) {
a[i] = y;
a[i + 1] = t;
}
}
}
kul++;
}
printf("%d\n", kul);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll MOD = 1000000007;
int main() {
ll z;
cin >> z;
while (z--) {
ll l, r, ans, a, b;
cin >> l >> r;
if (r - l < l)
ans = r % l;
else {
r++;
ans = r / 2;
ans--;
}
cout << ans << endl;
}
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.