solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long a;
long long int b;
cin >> a;
if (a % 2)
b = a / 2 - a;
else
b = a / 2;
cout << b;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int fin[100005];
int main() {
int n;
while (cin >> n) {
int l, r;
int flag = 1;
int temp;
for (int i = 0; i < n; i++) {
cin >> l >> r;
if (i == 0)
fin[0] = l > r ? l : r;
else {
temp = l > r ? l : r;
if (temp <= fin[i - 1])
fin[i] = temp;
else
fin[i] = l < r ? l : r;
if (fin[i] > fin[i - 1]) flag = 0;
}
}
if (!flag) cout << "NO" << endl;
if (flag) cout << "YES" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 1e9;
const long long IINF = 1e18;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const char dir[4] = {'D', 'R', 'U', 'L'};
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
os << v[i] << (i + 1 == v.size() ? "" : " ");
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ',' << p.second << ')';
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &m) {
os << '{';
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << '(' << itr->first << ',' << itr->second << ')';
if (++itr != m.end()) os << ',';
--itr;
}
os << '}';
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
os << '{';
for (auto itr = s.begin(); itr != s.end(); ++itr) {
os << *itr;
if (++itr != s.end()) os << ',';
--itr;
}
os << '}';
return os;
}
void debug_out() { cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head &&head, Tail &&...tail) {
cerr << head;
if (sizeof...(Tail) > 0) cerr << ", ";
debug_out(move(tail)...);
}
template <typename T>
T gcd(T x, T y) {
return y != 0 ? gcd(y, x % y) : x;
}
template <typename T>
T lcm(T x, T y) {
return x / gcd(x, y) * y;
}
template <class T1, class T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
struct BinaryIndexedTree {
vector<T> dat;
BinaryIndexedTree(int n) : dat(n + 1, 0) {}
void add(int i, T x) {
if (i == 0) return;
for (; i <= dat.size(); i += (i & -i)) dat[i] += x;
}
T sum(int i) {
T res = 0;
for (; i > 0; i -= (i & -i)) res += dat[i];
return res;
}
T query(int l, int r) { return sum(r - 1) - sum(l - 1); }
int lower_bound(T x) {
if (x <= 0) return 0;
int lb = 0, r = 1;
while (r < dat.size()) r <<= 1;
for (; r > 0; r >>= 1) {
if (lb + r < dat.size() && dat[lb + r] < x) {
x -= dat[lb + r];
lb += r;
}
}
return lb + 1;
}
void add0(int i, T x) { add(i + 1, x); }
T sum0(int i) { return sum(i + 1); }
T query0(int l, int r) { return sum(r) - sum(l); }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
cin >> a;
int m;
cin >> m;
vector<pair<pair<int, int>, int>> Q;
vector<pair<int, int>> A;
for (int i = 0; i < m; ++i) {
int k, p;
cin >> k >> p;
Q.push_back({{k, p}, i});
}
sort((Q).begin(), (Q).end());
for (int i = 0; i < n; ++i) A.emplace_back(a[i], -i);
sort((A).begin(), (A).end());
reverse((A).begin(), (A).end());
BinaryIndexedTree<int> BIT(n);
int now = 0;
vector<int> ans(m);
for (int i = 0; i < m; ++i) {
int k = Q[i].first.first, p = Q[i].first.second;
while (now < k) BIT.add0(-A[now++].second, 1);
ans[Q[i].second] = a[BIT.lower_bound(p) - 1];
}
for (int i = 0; i < m; ++i) cout << ans[i] << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long maxn = 2e5 + 123;
const long long inf = 1e9 + 123;
const long long linf = 1e18 + 123;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double pi = acos(-1);
int dx[4] = {0, 1, -1, 0};
int dy[4] = {1, 0, 0, -1};
long long a[maxn];
int main() {
boost();
long long n, m, k, cntr;
cin >> n >> m >> k >> cntr;
long long c = (cntr - 1) / k + 1, e = 0;
cntr = 0;
for (int i = 2; i <= m; i++) {
cin >> a[i];
if ((a[i] - e - 1) / k + 1 > c) {
e = i - 1;
c = (a[i] - e - 1) / k + 1;
cntr++;
}
}
cout << cntr + 1;
exit(0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, h, i;
cin >> n >> h;
for (i = 1; i < n; i++)
cout << fixed << setprecision(12) << h * (sqrt(i / n)) << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int t, x;
long long len;
string s, h;
int main() {
cin >> t;
while (t--) {
cin >> x >> s;
len = s.size();
for (int i = 1; i <= x; i++) {
int v = s[i - 1] - '1';
if (s.size() < x) {
if (v) h = s.substr(i);
for (int j = 1; j <= v; j++) s += h;
}
len = (len + (len - i) * v + mod) % mod;
}
cout << len % mod << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005] = {0};
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int n;
cin >> n;
s = ' ' + s;
int l = s.length();
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]]++;
b[l - a[i]]++;
}
int prev = 0;
for (int i = 1; i <= l / 2; i++) {
if ((b[i] + prev) % 2 == 1) {
swap(s[i], s[l - i]);
}
prev += b[i];
}
s.erase(0, 1);
cout << s << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double a[1000003];
double b[1000003];
int main() {
long n;
double m;
while (~scanf("%lld%lf", &n, &m)) {
double w1 = 0, w2 = 0;
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &a[i], &b[i]);
w1 += a[i];
}
if (w1 <= m) {
printf("-1\n");
continue;
}
double l = 0, r = 1e18;
double z = r;
double mid;
for (int j = 0; j < 103; j++) {
mid = (l + r) / 2.0;
w2 = m * mid;
for (int i = 0; i < n; i++) {
if (b[i] - a[i] * mid < 0) {
w2 += (b[i] - a[i] * mid);
}
}
if (w2 < 0)
r = mid;
else
l = mid;
}
printf("%.10f\n", mid);
}
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const int MOD = 1000000007;
vector<int> adj[111111];
long long DP[111111][4][11];
int M, K, X;
long long _DP2[111111][2][4][11];
void go(int v, int p = -1) {
auto DP2 = _DP2[v];
int w = 0;
for (int j = 0; j < (4); ++j)
for (int k = 0; k < (X + 1); ++k) DP2[w][j][k] = 0;
DP2[w][0][0] = 1;
for (int u : adj[v])
if (u != p) {
go(u, v);
w = 1 - w;
for (int j = 0; j < (4); ++j)
for (int k = 0; k < (X + 1); ++k) DP2[w][j][k] = 0;
for (int j = 0; j < (4); ++j)
for (int k = 0; k < (X + 1); ++k)
for (int ju = 0; ju < (4); ++ju)
for (int ku = 0; ku < (X - k + 1); ++ku) {
DP2[w][j | ju][k + ku] += DP2[1 - w][j][k] * DP[u][ju][ku] % MOD;
}
for (int j = 0; j < (4); ++j)
for (int k = 0; k < (X + 1); ++k) DP2[w][j][k] %= MOD;
}
for (int j = 0; j < (4); ++j)
for (int k = 0; k < (X + 1); ++k)
DP[v][0][k] += (K - 1) * DP2[w][j][k] % MOD;
for (int k = 0; k < (X); ++k) DP[v][2][k + 1] += DP2[w][0][k];
for (int j = 0; j < (2); ++j)
for (int k = 0; k < (X + 1); ++k)
DP[v][1][k] += (M - K) * DP2[w][j][k] % MOD;
for (int j = 0; j < (4); ++j)
for (int k = 0; k < (X + 1); ++k) DP[v][j][k] %= MOD;
}
int main() {
int N;
scanf("%d%d", &N, &M);
for (int i = 0; i < (N - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
adj[a].push_back(b);
adj[b].push_back(a);
}
scanf("%d%d", &K, &X);
go(0);
long long result = 0;
for (int j = 0; j < (4); ++j)
for (int i = 0; i < (X + 1); ++i) result += DP[0][j][i];
result %= MOD;
printf("%d\n", (int)result);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long pls(long long A, long long B, long long C) {
return (A % C + B % C) % C;
}
long long mul(long long A, long long B, long long C) {
long long res = 0;
while (B) {
if (B & 1) res = pls(A, res, C);
A = pls(A, A, C);
B >>= 1;
}
return res;
}
long long pow(long long A, long long B, long long C) {
long long res = 1;
while (B) {
if (B & 1) res = mul(A, res, C);
A = mul(A, A, C);
B >>= 1;
}
return res;
}
long long phi(long long a) {
long long res = a;
for (int i = 2; i * i <= a; i++) {
if (a % i == 0) {
while (a % i == 0) a /= i;
res -= res / i;
}
}
if (a > 1) res -= res / a;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
long long n, a, b, c;
cin >> n;
long long ma[105];
long long max = 0;
for (int i = 0; i < n; i++) {
cin >> ma[i];
if (ma[i] > max) {
max = ma[i];
}
}
long long res = 0;
for (int i = 0; i < n; i++) {
res += max - ma[i];
}
cout << res << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
string a, b, c, d;
cin >> a >> b >> c >> d;
reverse(b.begin(), b.end());
reverse(d.begin(), d.end());
a += b;
c += d;
int x = a.find('X'), y = c.find('X');
a.erase(x, 1);
c.erase(y, 1);
a += a;
if (a.find(c) != -1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long x[N], y[N];
int n;
bool gx(int a, int b, int c, int d) {
return (x[b] - x[a]) * (y[d] - y[c]) == (x[d] - x[c]) * (y[b] - y[a]);
}
int check(int d, int f) {
vector<int> q;
for (int i = 1; i <= n; i++)
if (!gx(d, f, f, i)) q.push_back(i);
if (q.size() < 3) return 1;
for (int i = 2; i < q.size(); i++)
if (!gx(q[0], q[1], q[1], q[i])) return 0;
return 1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
if (n < 5 || check(1, 2) || check(2, 3) || check(1, 3))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char str[100];
int L;
bool ok(int n) {
if (n == 0) return true;
set<string> S;
for (int i = 0; i + n <= L; i++) {
string temp(str + i, str + i + n);
if (!S.insert(temp).second) return true;
}
return false;
}
int main() {
scanf("%s", str);
L = strlen(str);
int low = 0, high = L;
while (high - low > 1) {
int mid = (low + high) / 2;
if (ok(mid)) {
low = mid;
} else {
high = mid;
}
}
if (ok(high)) {
printf("%d\n", high);
} else {
printf("%d\n", low);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void swapi(int *a, int *b) {
int temp;
temp = *a;
*a = *b;
*b = temp;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, sum = 0;
cin >> n;
long long arr[n];
for (int i = int(0); i < int(n); i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + n);
if (sum % 2 == 0 && arr[n - 1] <= (sum - arr[n - 1]))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int b[N], tot, x[N], y[N];
vector<int> V[N];
pair<int, int> res[N], cur[N];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x[i], &y[i]);
b[++tot] = x[i];
}
sort(b + 1, b + tot + 1);
int mm = unique(b + 1, b + tot + 1) - b - 1;
for (int i = 1; i <= m; i++) {
int pos = lower_bound(b + 1, b + mm + 1, x[i]) - b;
V[pos].push_back(y[i]);
}
int cnt = 0;
for (int i = 1; i <= mm; i++) sort(V[i].begin(), V[i].end());
cnt = 1;
res[0] = make_pair(1, 1);
for (int i = 1; i <= mm; i++) {
if (b[i] > b[i - 1] + 1) {
cnt = 1;
int x = res[0].first;
res[0] = make_pair(x, n);
}
int c = 0, siz = V[i].size(), pos = 0;
for (int j = 0; j < siz; j++) {
if (V[i][j] > pos + 1) cur[c] = make_pair(pos + 1, V[i][j] - 1), c++;
pos = V[i][j];
}
if (pos < n) cur[c] = make_pair(pos + 1, n), c++;
int now = 0;
for (int j = 0; j < cnt; j++) {
while (now < c && cur[now].first <= res[j].second) {
if (cur[now].second >= res[j].first) {
cur[now].first = max(cur[now].first, res[j].first);
} else
cur[now] = make_pair(-1, -1);
now++;
}
}
cnt = 0;
for (int j = 0; j < now; j++)
if (cur[j].first != -1) res[cnt] = cur[j], cnt++;
if (cnt == 0) return puts("-1");
}
bool ok = true;
if (b[mm] != n)
ok = true;
else if (res[cnt - 1].second == n)
ok = true;
else
ok = false;
printf("%d\n", ok ? 2 * n - 2 : -1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int x, y, z, t, t1, t2;
cin >> x >> y >> z >> t >> t1 >> t2;
long long el = (abs(x - z) * t1) + (t2 * 3) + (abs(x - y) * t1);
long long st = (abs(x - y) * t);
if (el <= st)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return (y ? gcd(y, x % y) : x); }
long long lcm(long long x, long long y) { return x * (y / gcd(x, y)); }
int oo = 1e9 + 7;
int n, m;
long long dpv[100000][3][3];
long long dph[100000][3][3];
long long gon(int i, int j, int mov) {
if (i == n - 1) return 1;
if (dpv[i][j][mov] != -1) return dpv[i][j][mov];
long long& ans = dpv[i][j][mov];
ans = 0;
if (mov == 1) {
ans = (ans + gon(i + 1, j, 0)) % oo;
if (j == 1) ans = (ans + gon(i + 1, j - 1, 1)) % oo;
if (j == 0) ans = (ans + gon(i + 1, j + 1, 1)) % oo;
} else {
if (j == 1) ans = (ans + gon(i + 1, j - 1, 1)) % oo;
if (j == 0) ans = (ans + gon(i + 1, j + 1, 1)) % oo;
}
return ans;
}
long long gom(int i, int j, int mov) {
if (i == m - 1) return 1;
if (dph[i][j][mov] != -1) return dph[i][j][mov];
long long& ans = dph[i][j][mov];
ans = 0;
if (mov == 1) {
ans = (ans + gom(i + 1, j, 0)) % oo;
if (j == 1) ans = (ans + gom(i + 1, j - 1, 1)) % oo;
if (j == 0) ans = (ans + gom(i + 1, j + 1, 1)) % oo;
} else {
if (j == 1) ans = (ans + gom(i + 1, j - 1, 1)) % oo;
if (j == 0) ans = (ans + gom(i + 1, j + 1, 1)) % oo;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
memset(dpv, -1, sizeof dpv);
memset(dph, -1, sizeof dph);
cin >> n >> m;
cout << ((gon(0, 0, 1) * 2ll) % oo + (gom(0, 0, 1) * 2ll) % oo - 2) % oo
<< endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c;
bitset<444> ans[444], G[26][444];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char ch;
scanf(" %c", &ch);
ans[i][j] = true;
G[ch - 'a'][i][j] = true;
}
}
scanf("%d %d", &r, &c);
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
char ch;
scanf(" %c", &ch);
if (ch == '?') continue;
for (int k = 0; k < n; k++) {
int next = ((k + n) - (i % n)) % n;
ans[next] &=
(G[ch - 'a'][k] >> (j % m)) | (G[ch - 'a'][k] << (m - (j % m)));
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ans[i][j];
}
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> nodes[N], common;
vector<pair<int, int> > edges;
int degree[N], n, m, h, t, old;
bool vis[N];
int check(int x, int y) {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < nodes[x].size(); ++i) {
vis[nodes[x][i]] = true;
}
common.clear();
for (int i = 0; i < nodes[y].size(); ++i) {
if (vis[nodes[y][i]]) {
vis[nodes[y][i]] = false;
common.push_back(nodes[y][i]);
}
}
return common.size();
}
void Print(int x, int y) {
printf("YES\n%d %d\n", x, y);
int a = 0, b = 0;
for (int i = 0; i < nodes[x].size() && a < h; ++i) {
if (nodes[x][i] == y) continue;
if (vis[nodes[x][i]]) {
printf("%d ", nodes[x][i]);
++a;
}
}
for (int i = 0; i < common.size() && a < h; ++i) {
vis[common[i]] = true;
printf("%d ", common[i]);
++a;
}
printf("\n");
for (int i = 0; i < nodes[y].size() && b < t; ++i) {
if (vis[nodes[y][i]] || nodes[y][i] == x) continue;
printf("%d ", nodes[y][i]);
++b;
}
printf("\n");
}
int main(void) {
scanf("%d%d%d%d", &n, &m, &h, &t);
int x, y;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
nodes[x].push_back(y);
++degree[x];
nodes[y].push_back(x);
++degree[y];
edges.push_back(make_pair(x, y));
}
sort(edges.begin(), edges.end(), greater<pair<int, int> >());
for (int i = 0; i < m; ++i) {
x = edges[i].first;
y = edges[i].second;
if (degree[x] >= h + 1 && degree[y] >= t + 1) {
int k = check(x, y);
if (degree[x] + degree[y] - k >= h + t + 2) {
Print(x, y);
return 0;
}
} else if (degree[y] >= h + 1 && degree[x] >= t + 1) {
int k = check(y, x);
if (degree[x] + degree[y] - k >= h + t + 2) {
Print(y, x);
return 0;
}
}
}
printf("NO\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, mx = -1;
cin >> n;
vector<pair<long long, long long>> vec;
for (long long i = 0; i < n; i++) {
long long m;
cin >> m;
vec.push_back({0, m});
for (long long i = 0; i < m; i++) {
long long x;
cin >> x;
vec.back().first = max(vec.back().first, x);
}
mx = max(mx, vec.back().first);
}
long long ans = 0;
for (auto v : vec) {
ans += v.second * (mx - v.first);
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long int n, k, s[1000000], max;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &s[i]);
}
max = s[n - 1];
for (int i = 0; i < n - k; i++) {
max = max > s[i] + s[2 * (n - k) - i - 1] ? max
: s[i] + s[2 * (n - k) - i - 1];
}
printf("%I64d", max);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int r, c;
} point[10005];
int n, m, k, dist[10005], s, t;
bool done[10005];
vector<int> col[10005];
vector<int> row[10005];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
heap;
map<pair<int, int>, int> ys;
int main() {
scanf("%d%d%d", &n, &m, &k);
bool la = 1;
for (int i = 1; i <= k; i++) {
int r, c;
scanf("%d%d", &r, &c);
ys[make_pair(r, c)] = i;
point[i].r = r;
point[i].c = c;
row[r].push_back(i);
col[c].push_back(i);
if (r == 1 && c == 1) s = i;
if (r == n && c == m) {
la = 0;
t = i;
}
}
if (la) {
t = ++k;
ys[make_pair(n + 1, m + 1)] = k;
point[k].r = n + 1;
point[k].c = m + 1;
row[n + 1].push_back(k);
col[m + 1].push_back(k);
}
memset(done, 0, sizeof(done));
memset(dist, 0x3f, sizeof(dist));
dist[s] = 0;
heap.push(make_pair(0, s));
while (!heap.empty()) {
pair<int, int> cur = heap.top();
int u = cur.second;
heap.pop();
if (done[u]) continue;
done[u] = 1;
int r = point[u].r, c = point[u].c;
int v;
if ((v = ys[make_pair(r, c - 1)]) && dist[v] > dist[u])
dist[v] = dist[u], heap.push(make_pair(dist[v], v));
if ((v = ys[make_pair(r, c + 1)]) && dist[v] > dist[u])
dist[v] = dist[u], heap.push(make_pair(dist[v], v));
if ((v = ys[make_pair(r - 1, c)]) && dist[v] > dist[u])
dist[v] = dist[u], heap.push(make_pair(dist[v], v));
if ((v = ys[make_pair(r + 1, c)]) && dist[v] > dist[u])
dist[v] = dist[u], heap.push(make_pair(dist[v], v));
for (int cc = max(1, c - 2); cc <= min(m + 1, c + 2); cc++)
for (int i = 0; i < col[cc].size(); i++) {
if (dist[col[cc][i]] > dist[u] + 1)
dist[col[cc][i]] = dist[u] + 1,
heap.push(make_pair(dist[col[cc][i]], col[cc][i]));
}
for (int rr = max(1, r - 2); rr <= min(n + 1, r + 2); rr++)
for (int i = 0; i < row[rr].size(); i++) {
if (dist[row[rr][i]] > dist[u] + 1)
dist[row[rr][i]] = dist[u] + 1,
heap.push(make_pair(dist[row[rr][i]], row[rr][i]));
}
}
if (dist[t] == 0x3f3f3f3f)
printf("-1");
else
printf("%d", dist[t]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, l, n, a, b, ans = 0;
int gcd(int a, int b) {
if (a < b) swap(a, b);
return (b == 0) ? a : gcd(b, a % b);
}
struct st {
int first;
long double second;
};
int main() {
std::ios_base::sync_with_stdio(0);
string s;
cin >> s;
n = s.size();
vector<long long> left, right;
left.reserve(n);
right.reserve(n);
j = 0;
for (auto i : s) {
if (i == 'l') {
left.push_back(++j);
} else {
right.push_back(++j);
}
}
for (auto i : right) cout << i << "\n";
reverse(left.begin(), left.end());
for (auto i : left) cout << i << "\n";
fflush(stdin);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 5e3 + 7;
vector<vector<long long int> > v(N);
long long int cl[N];
void dfs(long long int s, long long int c) {
if (cl[s] == -1 || cl[s] == c) return;
cl[s] = c;
for (auto it = v[s].begin(); it != v[s].end(); it++) {
if (cl[*it] != c) dfs(*it, c);
}
}
int main() {
long long int n, m, s, i, j, k;
cin >> n >> m >> s;
memset(cl, 0, sizeof cl);
for (i = 0; i < m; i++) {
scanf("%lld%lld", &j, &k);
v[j].push_back(k);
}
dfs(s, -1);
for (i = 1; i <= n; i++) {
if (!cl[i]) dfs(i, i);
}
set<long long int> se;
for (i = 1; i <= n; i++) se.insert(cl[i]);
cout << se.size() - 1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
int b[1000005];
int c[1000005];
int d[1000005];
int e[1000005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
e[i] += a[i];
e[i] += b[i];
e[i] += c[i];
e[i] += d[i];
}
int x = e[1];
sort(e + 1, e + n + 1);
reverse(e + 1, e + 1 + n);
for (int i = 1; i <= n; i++) {
if (e[i] == x) {
cout << i;
exit(0);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[200005], pre[200005], a[200005];
int main() {
int t;
cin >> t;
while (t--) {
int n, p, k;
scanf("%d%d%d", &n, &p, &k);
for (int i = 0; i <= n; i++) {
pre[i] = 0;
dp[i] = 0;
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
if (i >= k) pre[i % k] += a[i];
if (i >= k)
dp[i] = dp[i % k] + pre[i % k];
else
dp[i] = dp[i - 1] + a[i];
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (dp[i] <= p) ans = i;
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char g[3000][3000];
int nearC[3000], cH[3000], cC[3000], rH, rC, nearH[3000], vis[3000][3000], hang,
cot;
void dfs(int h, int c) {
if (vis[h][c] == 1 || g[h][c] != '#' || h == 0 || c == 0 | h > hang ||
c > cot) {
return;
}
vis[h][c] = 1;
dfs(h + 1, c);
dfs(h, c + 1);
dfs(h - 1, c);
dfs(h, c - 1);
}
int main() {
cin >> hang >> cot;
for (int i = 1; i <= hang; i++) {
for (int e = 1; e <= cot; e++) {
cin >> g[i][e];
}
}
for (int i = 1; i <= hang; i++) {
for (int e = 1; e <= cot; e++) {
if (g[i][e] == '#') {
if (nearC[e] != 0 && nearC[e] != i - 1) {
cout << -1;
return 0;
}
nearC[e] = i;
if (nearH[i] != 0 && nearH[i] != e - 1) {
cout << -1;
return 0;
}
nearH[i] = e;
}
}
}
int res = 0;
for (int i = 1; i <= hang; i++) {
for (int e = 1; e <= cot; e++) {
if (g[i][e] == '#' && vis[i][e] == 0) {
dfs(i, e);
res++;
}
if (g[i][e] == '#') {
cH[i] = cC[e] = 1;
}
}
}
for (int i = 1; i <= hang; i++) {
if (cH[i] == 0) {
rH++;
}
}
for (int e = 1; e <= cot; e++) {
if (cC[e] == 0) {
rC++;
}
}
if ((rH != 0 && rC == 0) || (rH == 0 && rC != 0)) {
cout << -1;
return 0;
}
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << fixed;
cout.precision(9);
string s;
getline(cin, s);
int i = (int)s.length() - 1;
while (s[i] == ' ' || s[i] == '?') {
--i;
}
const char* str = "aeiouyAEIOUY";
bool vowel = false;
for (int j = 0; j < strlen(str); ++j) {
if (str[j] == s[i]) {
vowel = true;
}
}
cout << (vowel ? "YES\n" : "NO\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
void dfs(int r, int now, int v) {
if (now == r) {
vec.push_back(v);
return;
}
dfs(r, now + 1, v * 10 + 4);
dfs(r, now + 1, v * 10 + 7);
}
long long pl, pr, vl, vr, K;
int size;
double cal() {
double s = 0;
for (int i = 0; i < size; i++) {
long long lp = i == 0 ? 1 : vec[i - 1] + 1;
lp = max(lp, pl);
long long rp = vec[i];
rp = min(rp, pr);
if (rp < lp) continue;
int rk = i + K - 1;
if (rk >= size) continue;
long long lv = vec[rk];
lv = max(lv, vl);
long long rv = rk == size - 1 ? 0x7fffffff : vec[rk + 1] - 1;
rv = min(rv, vr);
if (rv < lv) continue;
s += (rp - lp + 1) * 1.0 * (rv - lv + 1) * 1.0;
}
return s;
}
bool check(int l, int r, int x) {
if (l <= x && r >= x) return true;
return false;
}
int main() {
vec.clear();
for (int i = 1; i <= 9; i++) {
dfs(i, 0, 0);
}
sort(vec.begin(), vec.end());
size = vec.size();
while (cin >> pl >> pr >> vl >> vr >> K) {
double sum = (pr - pl + 1) * 1.0 * (vr - vl + 1);
double ans = 0;
ans += cal();
swap(pl, vl);
swap(pr, vr);
ans += cal();
if (K == 1) {
for (int i = 0; i < size; i++) {
if (check(pl, pr, vec[i]) && check(vl, vr, vec[i])) ans--;
}
}
printf("%.12f\n", ans / sum);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int t;
std::cin >> t;
while (t--) {
int n;
std::cin >> n;
int mx0 = 0, mx1 = 0, s = 0;
for (int i = 0; i < n; ++i) {
int x;
std::cin >> x;
s += x;
mx0 = std::max(mx0, s);
}
s = 0;
int m;
std::cin >> m;
for (int i = 0; i < m; ++i) {
int x;
std::cin >> x;
s += x;
mx1 = std::max(mx1, s);
}
std::cout << mx0 + mx1 << "\n";
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e9;
const int MAX_N = 2e3 + 1;
const int dir[2][2] = {{1, 0}, {0, 1}};
typedef struct Node {
int x, y;
Node(int x, int y) : x(x), y(y) {}
Node() {}
} Node;
queue<Node> q;
int d1[MAX_N][MAX_N], d2[MAX_N][MAX_N], n, k, x, y, pos, xx, yy, flag;
char a[MAX_N][MAX_N], ans[2 * MAX_N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%s", a[i] + 1);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
d1[i][j] = MAX;
}
}
d1[1][1] = 1;
d2[1][1] = a[1][1] == 'a';
for (int i = 1; i <= 2 * n - 1; i++) {
ans[i] = 'z';
}
ans[1] = d1[1][1] - d2[1][1] <= k ? 'a' : a[1][1];
q.push(Node(1, 1));
while (!q.empty()) {
Node node = q.front();
q.pop();
x = node.x;
y = node.y;
pos = x + y - 1;
if (d1[x][y] - d2[x][y] > k && a[x][y] > ans[pos]) {
continue;
}
for (int i = 0; i < 2; i++) {
xx = x + dir[i][0];
yy = y + dir[i][1];
if (xx < 1 || xx > n || yy < 1 || yy > n) {
continue;
}
flag = a[xx][yy] == 'a';
if (d1[x][y] + 1 < d1[xx][yy]) {
d1[xx][yy] = d1[x][y] + 1;
d2[xx][yy] = d2[x][y] + flag;
q.push(Node(xx, yy));
ans[pos + 1] =
min((d1[xx][yy] - d2[xx][yy] <= k ? 'a' : a[xx][yy]), ans[pos + 1]);
} else if (d2[x][y] + flag > d2[xx][yy]) {
d2[xx][yy] = d2[x][y] + flag;
q.push(Node(xx, yy));
ans[pos + 1] =
min((d1[xx][yy] - d2[xx][yy] <= k ? 'a' : a[xx][yy]), ans[pos + 1]);
}
}
}
printf("%s\n", ans + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
if (flag) x = -x;
}
using namespace std;
const int P = 1e9 + 7;
inline void MIN(int &a, int b) {
if (b < a) a = b;
}
inline void MAX(int &a, int b) {
if (a < b) a = b;
}
inline void ADD(int &a, int b) {
a += b;
if (a >= P) a -= P;
}
inline int Mod(int x) { return x >= P ? x - P : x; }
int n, K;
int X[67], Y[67], W[67];
int h[67], htot, mx;
namespace jzpac {
long long jie[1001000];
int h[67][67];
int hangcnt[67], liecnt[67];
int hmn[67], hmx[67];
unordered_map<int, int> mp[2][67];
int id[67], itot, mask[67];
inline void sol() {
jie[0] = 1;
for (int i = 1; i <= n; ++i) jie[i] = jie[i - 1] * i % P;
for (int i = 1; i <= K; ++i) ++hangcnt[X[i]], ++liecnt[Y[i]];
int hct = 0, lct = 0;
for (int i = 1; i <= mx; ++i) hct += (hangcnt[i] > 1), lct += (liecnt[i] > 1);
if (hct > lct)
for (int i = 1; i <= K; ++i) swap(X[i], Y[i]);
memset(hmn, 0x3f, sizeof(hmn));
for (int i = 1; i <= K; ++i)
MIN(hmn[X[i] - 1], Y[i] - 1), MAX(hmx[X[i] - 1], Y[i] - 1);
for (int i = 0; i < mx; ++i) id[i] = 29;
for (int i = 0; i < mx; ++i)
if (hmn[i] < hmx[i]) mask[hmx[i]] ^= (1 << itot), id[i] = itot++;
for (int i = 0; i < mx; ++i) mask[i] ^= (1 << itot) - 1;
for (int i = 1; i <= K; ++i) h[X[i] - 1][Y[i] - 1] = Mod(W[i] - 1 + P);
int nwt = 0;
mp[nwt][0][0] = 1;
for (int i = 0; i < mx; ++i) {
nwt ^= 1;
for (int j = 0; j <= i; ++j) mp[nwt][j].clear();
for (int j = 0; j <= i; ++j) {
for (unordered_map<int, int>::iterator it = mp[nwt ^ 1][j].begin();
it != mp[nwt ^ 1][j].end(); ++it) {
int s = it->first, v = it->second;
ADD(mp[nwt][j][s & mask[i]], v);
for (int k = 0; k < mx; ++k)
if (h[k][i]) {
if ((s >> id[k]) & 1) continue;
ADD(mp[nwt][j + 1][(s ^ (1 << id[k])) & mask[i]],
1ll * v * h[k][i] % P);
}
}
}
}
long long res = 0;
for (int j = 0; j <= mx; ++j) {
res += mp[nwt][j][0] * jie[n - j] % P;
}
printf("%lld\n", (res % P + P) % P);
}
} // namespace jzpac
int main() {
read(n), read(K);
for (int i = 1; i <= K; ++i) {
read(X[i]), read(Y[i]), read(W[i]);
h[++htot] = X[i];
}
sort(h + 1, h + 1 + htot);
htot = unique(h + 1, h + 1 + htot) - h - 1;
for (int i = 1; i <= K; ++i)
X[i] = lower_bound(h + 1, h + 1 + htot, X[i]) - h;
mx = htot;
htot = 0;
for (int i = 1; i <= K; ++i) h[++htot] = Y[i];
sort(h + 1, h + 1 + htot);
htot = unique(h + 1, h + 1 + htot) - h - 1;
for (int i = 1; i <= K; ++i)
Y[i] = lower_bound(h + 1, h + 1 + htot, Y[i]) - h;
if (htot > mx) mx = htot;
jzpac::sol();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, k, a, b, c, d;
cin >> n >> k;
cin >> a >> b >> c >> d;
if (k < n + 1 || n == 4)
cout << -1 << endl;
else {
cout << a << " " << c << " ";
for (i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << d << " " << b << endl;
cout << c << " " << a << " ";
for (i = 1; i <= n; i++) {
if (i != a && i != b && i != c && i != d) cout << i << " ";
}
cout << b << " " << d << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct deb {
template <class c>
deb &operator<<(const c &) {
return *this;
}
};
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
const int mod = 1e9 + 7;
inline int add(int a, int b) { return ((a % mod) + (b % mod)) % mod; }
inline int sub(int a, int b) { return ((a % mod) - (b % mod) + mod) % mod; }
inline int mul(int a, int b) { return ((a % mod) * (b % mod)) % mod; }
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
const int inf = 1e18;
const int maxn = 1e6 + 1;
int st[4 * maxn];
int n;
vector<int> arr;
vector<int> cnt;
void build(int si = 0, int ei = maxn - 1, int idx = 0) {
if (si == ei) {
if (si <= n) st[idx] = cnt[si];
return;
}
int mid = (si + ei) / 2;
build(si, mid, 2 * idx + 1);
build(mid + 1, ei, 2 * idx + 2);
st[idx] = st[2 * idx + 1] + st[2 * idx + 2];
}
void del(int si, int ei, int idx, int k) {
if (si == ei) {
st[idx]--;
return;
}
int mid = (si + ei) / 2;
int lv = st[2 * idx + 1];
if (k > lv) {
del(mid + 1, ei, 2 * idx + 2, k - lv);
} else {
del(si, mid, 2 * idx + 1, k);
}
st[idx] = st[2 * idx + 1] + st[2 * idx + 2];
}
void ins(int si, int ei, int idx, int k) {
if (si == ei) {
st[idx]++;
return;
}
int mid = (si + ei) / 2;
if (k > mid) {
ins(mid + 1, ei, 2 * idx + 2, k);
} else {
ins(si, mid, 2 * idx + 1, k);
}
st[idx] = st[2 * idx + 1] + st[2 * idx + 2];
}
void findit(int si, int ei, int idx) {
if (st[idx] == 0) {
cout << 0 << "\n";
return;
}
if (si == ei) {
cout << si << "\n";
return;
}
int mid = (si + ei) / 2;
if (st[2 * idx + 1]) {
findit(si, mid, 2 * idx + 1);
} else {
findit(mid + 1, ei, 2 * idx + 2);
}
}
void solve() {
cin >> n;
arr = vector<int>(n);
int q;
cin >> q;
for (int i = 0; i < arr.size(); i++) cin >> arr[i];
;
cnt = vector<int>(n + 1);
for (auto num : arr) {
cnt[num]++;
}
build();
while (q--) {
int k;
cin >> k;
if (k < 0) {
k = k * -1;
del(0, maxn - 1, 0, k);
} else {
ins(0, maxn - 1, 0, k);
}
}
findit(0, maxn - 1, 0);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int tt = 1; tt <= t; tt++) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long t_max = 1000000007;
long long MAXX = 1000000000000000000;
long long binpow(long long a, long long n, long long k) {
long long res = 1;
while (n)
if (n & 1) {
res *= a;
res %= k;
n--;
} else {
a *= a;
a %= k;
n >>= 1;
}
return res;
}
struct tree {
int l, r;
};
bool arr[1001];
int n;
vector<int> v;
int p[1001];
int bfs() {
queue<int> q;
for (auto et : v) {
if (et < 0) continue;
p[et] = 1;
q.push(et);
}
while (!q.empty()) {
int s = q.front();
q.pop();
if (s == 0) return p[s];
for (auto et : v) {
if (et + s >= 0 && p[et + s] == 0) {
q.push(et + s);
p[et + s] = p[s] + 1;
}
}
}
return -2;
}
int main() {
cin.tie(0);
cout.tie(0);
std::ios_base::sync_with_stdio(0);
bool c1 = 0, c2 = 0, c3 = 0;
int k, a;
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> a;
if (arr[a] == 1) continue;
v.push_back(a - n);
arr[a] = 1;
if (a > n) c1 = 1;
if (a == n) c2 = 1;
if (a < n) c3 = 1;
}
if (c2 == 1) {
cout << 1;
return 0;
}
if (!c1 || !c3) {
cout << -1;
return 0;
}
cout << bfs();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
vector<int> ve[MAX];
int vis[MAX], v[MAX], p[MAX];
void init() {
memset(v, 0, sizeof(v));
for (int i = 2; i * i < MAX; i++) {
if (!v[i]) {
for (int j = i * i; j < MAX; j += i) {
v[j] = 1;
}
}
}
int cnt = 1;
for (int i = 3; i <= 100000; i++) {
if (!v[i]) p[cnt++] = i;
}
}
int main() {
int n;
init();
while (scanf("%d", &n) != EOF) {
memset(vis, 0, sizeof(vis));
int cnt = 0, sum = 0;
for (int i = 1; p[i] <= n / 2; i++) {
int num = 0;
for (int j = p[i]; j <= n; j += p[i]) {
if (!vis[j] && j / 2 != p[i]) {
ve[p[i]].push_back(j);
num++;
vis[j] = 1;
}
}
if (num & 1) {
vis[p[i] * 2] = 1;
ve[p[i]].push_back(p[i] * 2);
}
sum += ve[p[i]].size() / 2;
}
for (int i = 2; i <= n; i++) {
if (!vis[i] && i % 2 == 0) ve[2].push_back(i);
}
sum += ve[2].size() / 2;
printf("%d\n", sum);
for (int i = 2; i <= n / 2; i++) {
if (ve[i].size()) {
for (int j = 0; j < ve[i].size() - 1; j += 2) {
printf("%d %d\n", ve[i][j], ve[i][j + 1]);
}
}
}
}
}
| 8 |
#include <bits/stdc++.h>
#define IO ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
using namespace std;
typedef long long ll;
typedef pair<long long, long long> pll;
int main() {
vector<ll> v(66);
v[0] = 1;
for (int i = 1; i <= 60; ++i) {
v[i] = v[i - 1] * 2;
}
int T;
cin >> T;
while (T--) {
ll k;
cin >> k;
if (k % 2) {
cout << -1 << endl;
} else {
vector<ll> ans;
k -= 2; // // 减去第一个1的期望值
// 00...01
while (k > 0) {
ans.push_back(1);
k -= 2;
for (int i = 2; k >= v[i]; ++i) {
ans.push_back(0);
k -= v[i];
}
}
ans.push_back(1); // 第一个一定是1
cout << ans.size() << endl;
for (int i = ans.size() - 1; i >= 0; --i) {
cout << ans[i] << " ";
}
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 9, base = 10;
const int N = 1e5 + 5;
int hsh[N << 2], laz[N << 2], pwr[N];
string str;
vector<int> sv[N];
int n, m, k;
void build(int node, int s, int e) {
laz[node] = -1;
if (s == e) {
hsh[node] = (str[s] - '0');
return;
}
int md = (s + e) >> 1;
build(node << 1, s, md);
build(node << 1 | 1, md + 1, e);
hsh[node] =
(hsh[node << 1] * 1ll * pwr[e - md] % mod + hsh[node << 1 | 1]) % mod;
}
void push(int node, int s, int e) {
if (~laz[node]) {
hsh[node] = sv[1][e - s] * 1ll * laz[node] % mod;
if (s != e) {
laz[node << 1] = laz[node];
laz[node << 1 | 1] = laz[node];
}
laz[node] = -1;
}
}
void upd(int node, int s, int e, int l, int r, int v) {
push(node, s, e);
if (r < s || e < l || l > r) return;
if (l <= s && e <= r) {
laz[node] = v;
push(node, s, e);
return;
}
int md = (s + e) >> 1;
upd(node << 1, s, md, l, r, v);
upd(node << 1 | 1, md + 1, e, l, r, v);
hsh[node] =
(hsh[node << 1] * 1ll * pwr[e - md] % mod + hsh[node << 1 | 1]) % mod;
}
void qry(int node, int s, int e, int l, int r, int &ans) {
push(node, s, e);
if (r < s || e < l || l > r) return;
if (l <= s && e <= r) {
ans = (ans * 1ll * pwr[e - s + 1] % mod + hsh[node]) % mod;
return;
}
int md = (s + e) >> 1;
qry(node << 1, s, md, l, r, ans);
qry(node << 1 | 1, md + 1, e, l, r, ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
pwr[0] = 1;
for (int i = 1; i < N; i++) pwr[i] = (pwr[i - 1] * 1ll * 10) % mod;
for (int i = 1; i < N; i++) {
sv[i].resize(N / i + 3);
sv[i][0] = 1;
for (int j = 1; j * i < N; j++)
sv[i][j] = (sv[i][j - 1] + pwr[i * j]) % mod;
}
cin >> n >> m >> k;
cin >> str;
m += k;
build(1, 0, n - 1);
int x = 0;
while (m--) {
int tp;
cin >> tp;
if (tp == 1) {
int l, r, v;
cin >> l >> r >> v;
--l, --r;
upd(1, 0, n - 1, l, r, v);
} else {
int l, r, d;
cin >> l >> r >> d;
--l, --r;
int small = 0;
qry(1, 0, n - 1, l, l + (d - 1), small);
int to = (r - l + 1) / d;
small = small * 1ll * sv[d][to - 1] % mod;
int tmp = 0;
int o = ((r - l + 1) - to * d);
qry(1, 0, n - 1, l, l + o - 1, tmp);
small = small * 1ll * pwr[o] % mod + tmp;
small %= mod;
int big = 0;
qry(1, 0, n - 1, l, r, big);
if (small == big)
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, n;
char s[300];
scanf("%d\n", &x);
n = x;
for (int i = 3; i <= n + 2; i++) {
scanf("%c", &s[i]);
while (s[i] != 'U' && s[i] != 'R') {
i--;
continue;
}
if ((s[i] == 'U' && s[i - 1] == 'R') || (s[i] == 'R' && s[i - 1] == 'U'))
s[i] = 'D', x--;
}
cout << x << endl;
}
| 0 |
#include <bits/stdc++.h>
const int md = 1e9 + 7;
const int Inf = 1e9;
const int Inf64 = 1e18;
const int MaxN = 1e5 + 10;
const int LogN = 25;
const int MaxM = 5e5 + 10;
const long double eps = 1e-7;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
const int ddx[4] = {1, 1, -1, -1};
const int ddy[4] = {1, -1, 1, -1};
const long double Pi = acos(-1);
using namespace std;
template <typename T>
istream &operator>>(istream &in, pair<T, T> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, pair<T, T> a) {
out << a.first << ' ' << a.second;
return out;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &Mt) {
for (T &a : Mt) in >> a;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> Mt) {
for (int i = 0; i < Mt.size(); i++) {
out << Mt[i];
if (i != Mt.size()) out << ' ';
}
return out;
}
inline int Mod(int &a, int m = md) {
while (a >= m) a -= m;
return a;
}
inline int gcd(int a, int b) {
while (a) {
b %= a;
swap(a, b);
}
return b;
}
inline int gcdex(int a, int mod = md) {
int g = mod, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + mod : x;
}
inline int binpow(int a, int n, int m = md) {
int res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= m;
}
a *= a;
a %= m;
n >>= 1;
}
return res % md;
}
vector<int> Gr1[MaxN];
vector<int> Gr2[MaxN];
vector<int> Gr[MaxN];
int dp[MaxN][LogN];
int tin1[MaxN];
int tin2[MaxN];
int tout1[MaxN];
int tout2[MaxN];
int T1 = 0;
int T2 = 0;
bitset<MaxN> used1;
bitset<MaxN> used2;
int Ht[MaxN];
void dfs(int v, int p) {
Ht[v] = Ht[p] + 1;
dp[v][0] = p;
for (int i = 1; i < LogN; i++) {
dp[v][i] = dp[dp[v][i - 1]][i - 1];
}
for (int to : Gr[v]) {
if (to == p) continue;
dfs(to, v);
}
}
int LCA(int v, int u) {
if (Ht[u] > Ht[v]) swap(u, v);
for (int i = LogN - 1; i >= 0; i--) {
if (Ht[dp[v][i]] >= Ht[u]) {
v = dp[v][i];
}
}
if (u != v) {
for (int i = LogN - 1; i >= 0; i--) {
if (dp[u][i] != dp[v][i]) {
u = dp[u][i];
v = dp[v][i];
}
}
u = dp[u][0];
v = dp[v][0];
}
return u;
}
void dfs1(int v, int p = -1) {
used1[v] = 1;
tin1[v] = T1++;
for (int to : Gr1[v]) {
if (to == p) continue;
dfs1(to, v);
}
tout1[v] = T1++;
}
void dfs2(int v, int p = -1) {
used2[v] = 1;
tin2[v] = T2++;
for (int to : Gr2[v]) {
if (to == p) continue;
dfs2(to, v);
}
tout2[v] = T2++;
}
bool In1(int a, int b) {
if (tin1[a] < tin1[b] && tout1[a] > tout1[b])
return 1;
else
return 0;
}
bool In2(int a, int b) {
if (tin2[a] < tin2[b] && tout2[a] > tout2[b])
return 1;
else
return 0;
}
int par[MaxN];
int FS(int a) {
if (a == par[a]) return a;
return par[a] = FS(par[a]);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed, cout.precision(20);
{
int N;
cin >> N;
for (int i = 0; i <= N; i++) {
par[i] = i;
}
for (int i = 1; i <= N; i++) {
int a, b;
cin >> b >> a;
if (a == -1 && b == -1) continue;
Gr[i].push_back(b);
Gr[b].push_back(i);
if (a == 0) {
Gr1[b].push_back(i);
Gr1[i].push_back(b);
} else {
Gr2[b].push_back(i);
Gr2[i].push_back(b);
}
int k = FS(i);
b = FS(b);
par[k] = b;
}
for (int i = 1; i <= N; i++) {
if (!used1[i]) dfs1(i, 0);
if (!used2[i]) dfs2(i, 0);
if (dp[i][0] == 0) dfs(i, 0);
}
int Q;
cin >> Q;
while (Q--) {
int t, a, b;
cin >> t >> a >> b;
if (FS(a) != FS(b)) {
cout << "NO" << '\n';
continue;
}
int lca = LCA(b, a);
if (t == 1) {
if (a != lca || a == b) {
cout << "NO" << '\n';
continue;
}
if ((In1(a, b) || In1(b, a)))
cout << "YES" << '\n';
else
cout << "NO" << '\n';
} else {
if (a == b) {
cout << "NO" << '\n';
continue;
}
if ((In2(lca, b) || In2(b, lca)) &&
(a == lca || In1(a, lca) || In1(lca, a)))
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
}
END:
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b >> c;
if (((a == "rock" && b == "scissors") || (a == "scissors" && b == "paper") ||
(a == "paper" && b == "rock")) &&
b == c)
cout << 'F';
else if (((b == "rock" && a == "scissors") ||
(b == "scissors" && a == "paper") ||
(b == "paper" && a == "rock")) &&
a == c)
cout << 'M';
else if (((c == "rock" && b == "scissors") ||
(c == "scissors" && b == "paper") ||
(c == "paper" && b == "rock")) &&
b == a)
cout << 'S';
else
cout << '?';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const int BLOK = 2000;
int n, q, st[200009], en[200009], bel[200009], arr[200009], cur = 1;
int S[102][200009];
int tap(int y, int x) {
int res = 0;
for (; x; x -= x & (-x)) res += S[y][x];
return res;
}
int smaller(int x, int k) {
if (x > n) return 0;
int res = 0;
if (bel[x] == cur) {
for (int i = x; i <= n; i++) res += (arr[i] < k);
return res;
}
for (int i = bel[x] + 1; i <= cur; i++) res += tap(i, k - 1);
for (int i = x; i <= en[bel[x]]; i++) res += (arr[i] < k);
return res;
}
void change(int y, int x, int val) {
for (; x < 200009; x += x & (-x)) S[y][x] += val;
}
void upd(int x, int r, int a) {
change(bel[x], r, -1);
change(bel[x], a, +1);
}
void build() {
st[1] = 1;
for (int i = 1; i <= n; i++) {
bel[i] = cur;
arr[i] = i;
change(cur, i, +1);
if (i % BLOK == 0) {
en[cur] = i;
if (i < n) st[++cur] = i + 1;
}
}
if (n % BLOK != 0) en[cur] = n;
}
int main() {
scanf("%d%d", &n, &q);
build();
long long ans = 0;
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
if (l == r) {
printf("%lld\n", ans);
continue;
}
if (l > r) swap(l, r);
int l1 = arr[l], r1 = arr[r];
int l2 = smaller(l + 1, l1), r2 = smaller(r + 1, r1);
ans -= (n - l1) - (n - l - l2);
ans -= l2 + r2;
ans -= (n - r1) - (n - r - r2);
ans += (l1 > r1);
upd(l, l1, r1);
upd(r, r1, l1);
swap(arr[l], arr[r]);
swap(l1, r1);
l2 = smaller(l + 1, l1);
r2 = smaller(r + 1, r1);
ans += (n - l1) - (n - l - l2);
ans += l2 + r2;
ans += (n - r1) - (n - r - r2);
ans -= (l1 > r1);
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
long long a[MAXN], pre[MAXN], res[MAXN];
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (a == 0 && b == 0) return -1;
if (b == 0) return x = 1, y = 0, a;
long long d = exgcd(b, a % b, y, x);
return y -= a / b * x, d;
}
long long go[MAXN], id[MAXN];
int main() {
int n;
long long T;
scanf("%lld%d", &T, &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 2; i <= n + 1; i++) pre[i] = pre[i - 1] + a[(i - 1) % n + 1];
long long x, y, d = exgcd(pre[n + 1] % T, T, x, y), t = T / d;
x = (x % t + t) % t;
map<long long, vector<int> > mp;
map<long long, int> vis;
for (int i = 1; i <= n; i++) {
if (vis[pre[i] % T]) continue;
vis[pre[i] % T] = 1;
mp[pre[i] % d].push_back(i);
}
for (auto itr = mp.begin(); itr != mp.end(); itr++) {
vector<int> tmp = itr->second;
int cnt = (int)tmp.size();
for (int i = 0; i < cnt; i++) {
go[i] =
((x * (pre[tmp[0]] % T - pre[tmp[i]] % T) / d) % t + t - 1) % t + 1;
id[i] = i;
}
sort(id, id + cnt, [](long long a, long long b) { return go[a] < go[b]; });
for (int i = 0; i < cnt; i++)
res[tmp[id[i]]] = go[id[i]] - (i > 0 ? go[id[i - 1]] : 0);
}
for (int i = 1; i <= n; i++) printf("%lld ", res[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const long long MOD = 1000000007;
const double EPS = 1e-9;
int n;
long long l, v1, v2;
int choc[MAXN];
pair<double, bool> event[2 * MAXN];
double ans[MAXN];
double mod(double x, double y) {
while (x > y) x -= y;
return x;
}
int main() {
for (int i = 0; i < MAXN; i++) ans[i] = 0.0;
cin >> n >> l >> v1 >> v2;
double len = ((double)v2 * (double)l) / ((double)v1 + (double)v2);
for (int i = 0; i < n; i++) {
cin >> choc[i];
event[2 * i] = make_pair(mod((choc[i] + 2 * l - len), 2 * l), true);
event[2 * i + 1] = make_pair((double)choc[i], false);
}
sort(event, event + 2 * n);
event[2 * n] = make_pair(2 * l, true);
int slope = 0;
for (int i = 0; i < n; i++)
if ((double)choc[i] < len + EPS) slope++;
double last = 0.0;
for (int i = 0; i <= 2 * n; i++) {
ans[slope] += (event[i].first - last) / (2 * (double)l);
if (event[i].second)
slope++;
else
slope--;
last = event[i].first;
}
cout << fixed << setprecision(9);
for (int i = 0; i <= n; i++) cout << ans[i] << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 600000 + 10;
int n, T, sh[MAX];
char a[MAX];
int work(int K) {
int st = 0, i, tot = K, res = 0, last = -1, dd = K, end = 0;
memset(sh, 0, sizeof sh);
for (i = 1; i <= n; ++i) {
sh[i] = sh[i - 1];
if (a[i] == 'H') ++sh[i];
}
for (i = 1; i <= n; ++i) {
if (a[i] == 'H')
--dd;
else if (a[i] == 'S')
++dd;
if (dd >= 0 && sh[i] == sh[n]) {
end = i;
break;
}
}
if (!end) return T + 1;
int ans = T + 1;
for (i = 1; i <= n; ++i) {
++st;
if (tot >= res) ans = min(ans, (end - i) * 2 + st);
if (a[i] == 'S') ++tot;
if (a[i] == 'H') {
if (tot)
--tot;
else
++res;
}
if (res && tot >= res) {
st += (i - last) * 2;
tot -= res;
res = 0;
if (sh[i] == sh[n]) st -= (i - last);
last = -1;
}
if (res && tot < res && last == -1) last = i;
if (sh[i] == sh[n] && tot >= res) return min(st, ans);
}
return T + 1;
}
int main() {
scanf("%d%d", &n, &T);
scanf("%s", a + 1);
int left = 0, right = n + 1, mid;
while (left < right) {
mid = (left + right) / 2;
if (work(mid) <= T)
right = mid;
else
left = mid + 1;
}
if (left == n + 1)
printf("-1\n");
else
printf("%d\n", left);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100020;
char s[Maxn];
int a[Maxn];
int k, n;
bool check(int m) {
for (int i = 1; i <= n; i++) {
if (s[i] == '1') continue;
if (a[i - 1] - a[max(0, i - m - 1)] + a[min(n, i + m)] - a[i] >= k)
return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) a[i] = a[i - 1] + (s[i] == '0');
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", l);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000000 + 7;
long long sTwos[300010];
int n;
long long x[300010];
void init() {
sTwos[0] = 1;
for (int i = 1; i < 300010; i++) {
sTwos[i] = sTwos[i - 1] * 2;
sTwos[i] = sTwos[i] % MOD;
}
}
bool compare(const long long &a, const long long &b) { return a < b; }
int main() {
init();
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d", &(x[i]));
sort(x, x + n, compare);
int count = n - 2;
long long sum = 0;
long long wholeDist = x[n - 1] - x[0];
int l = 0, r = n - 1;
long long countSet = 0;
while (count >= 0) {
countSet = countSet + wholeDist - (x[l] - x[0]) - (x[n - 1] - x[r]);
sum = sum + (long long)(sTwos[count] * (countSet % MOD));
sum = sum % MOD;
l++;
r--;
count--;
}
printf("%I64d\n", sum);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int n, m, a[60];
int flag = 0;
cin >> n >> m;
int i = 0;
long long int m1 = m;
while (m1 > 0) {
a[i++] = m1 % n;
m1 /= n;
}
for (int j = 0; j < i; j++) {
if (a[j] != 0 && a[j] != 1 && a[j] != n - 1 && a[j] != n) {
flag = 1;
break;
} else {
if (a[j] == n - 1 || a[j] == n) {
a[j + 1] = (a[j + 1] + 1);
}
}
}
if (flag == 0) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int mod = 1000000007;
long long f[1010000], n, m, x;
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &x), m += (x == 1);
f[0] = f[1] = 1;
for (int i = 2; i <= m; i++) f[i] = (f[i - 1] + f[i - 2] * (i - 1)) % mod;
for (int i = m + 1; i <= n; i++) f[m] = f[m] * i % mod;
printf("%I64d\n", f[m]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int G[20];
long long ans[20], dp[(1 << 16) + 5], vis[20];
int main(int argc, char** argv) {
int n;
long long y;
int m;
cin >> n >> y >> m;
y -= 2001;
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
G[b - 1] |= (1 << (a - 1));
}
int f = 0;
int S = (1 << n) - 1;
memset(ans, -1, sizeof(ans));
for (int i = 0; i <= n - 1; i++) {
if (f) break;
while (1) {
ans[i]++;
if (vis[ans[i]]) continue;
memset(dp, 0, sizeof(dp));
dp[0] = 1;
if (ans[i] >= n) {
f = 1;
break;
}
for (int j = 0; j <= S; j++) {
int cnt = 0;
for (int k = 0; k <= n - 1; k++) {
if ((1 << k) & j) cnt++;
}
for (int k = 0; k <= n - 1; k++) {
if (j & (1 << k)) continue;
if ((ans[k] == cnt || ans[k] == -1) && ((G[k] & j) == G[k])) {
dp[j | (1 << k)] += dp[j];
}
}
}
if (dp[S] > y) {
vis[ans[i]]++;
break;
} else {
y -= dp[S];
}
}
}
if (!f)
for (int i = 0; i <= n - 1; i++) {
cout << ans[i] + 1 << " ";
}
else
puts("The times have changed");
return 0;
}
| 8 |
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<stack>
#include<vector>
#include<set>
#include<map>
#include<utility>
#include<queue>
#include<cstring>
#include<deque>
#include<tuple>
#include<list>
#include<cmath>
#include<cstdlib>
#include<iomanip>
#include<bitset>
#include<random>
#include<limits>
#include<chrono>
using namespace std;
using namespace std::chrono;
typedef long long ll;
string IntToString(ll a)
{
char x[100];
sprintf(x, "%lld", a);
string s = x;
return s;
}
ll StringToInt(string a)
{
char x[100];
ll res;
strcpy(x, a.c_str());
sscanf(x, "%lld", &res);
return res;
}
vector<string> split(string s,char b)
{
vector<string>ans;
string temp = "";
for (int i=0;i<s.size();i++)
{
if (s[i]==b)
{
ans.push_back(temp);
temp = "";
}
else
temp+=s[i];
}
return ans;
}
/*-------------------------------------------------CODE STARTS HERE------------------------------------------------*/
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
//auto start = high_resolution_clock::now();
//write your code here
int t;
cin>>t;
while (t--)
{
int n;
cin>>n;
int arr[n];
int c0=0,c1=0,c2=0;
for (int i=0;i<n;i++)
{
cin>>arr[i];
if (arr[i]%3==0)
c0++;
else if (arr[i]%3==1)
c1++;
else if (arr[i]%3==2)
c2++;
}
long long val = n/3;
long long ans=0;
if (c0>val)
{
c1 += (c0-val);
ans += (c0-val);
c0 = val;
}
if (c1>val)
{
c2 += (c1-val);
ans += (c1-val);
c1 = val;
}
if (c2>val)
{
c0 += (c2-val);
ans += (c2-val);
c2 = val;
}
if (c0>val)
{
c1 += (c0-val);
ans += (c0-val);
c0 = val;
}
if (c1>val)
{
c2 += (c1-val);
ans += (c1-val);
c1 = val;
}
if (c2>val)
{
c0 += (c2-val);
ans += (c2-val);
c2 = val;
}
cout<<ans<<'\n';
}
/* auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
cout << "Time taken by function: "
<< duration.count() << " microseconds" << endl;
*/
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
void pv(vector<int> amount) {
for (auto i = amount.begin(); i != amount.end(); i++) cout << *i << " ";
cout << endl;
}
void pv(vector<long long> amount) {
for (auto i = amount.begin(); i != amount.end(); i++) cout << *i << " ";
cout << endl;
}
void pv(vector<double> amount) {
for (auto i = amount.begin(); i != amount.end(); i++) cout << *i << " ";
cout << endl;
}
void pv(vector<string> amount) {
for (auto i = amount.begin(); i != amount.end(); i++) cout << *i << " ";
cout << endl;
}
void pv(vector<bool> amount) {
for (auto i = amount.begin(); i != amount.end(); i++) cout << *i << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
long long t;
cin >> t;
for (int j = 0; j < t; j++) {
long long n, k;
cin >> n >> k;
long long arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
long long max = *max_element(arr, arr + n);
long long min = *min_element(arr, arr + n);
if (k % 2 == 0) {
k = 2;
} else {
k = 1;
}
while (k > 0) {
for (int i = 0; i < n; i++) {
arr[i] = max - arr[i];
}
max = max - min;
min = 0;
k--;
}
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 555;
int sz, N;
int Fi[MAXN];
struct Edge {
int v, nx;
} e[MAXN << 2];
void E_init() {
sz = 0;
memset(Fi, -1, sizeof(Fi));
}
void E_add(int u, int v) {
e[sz].v = v, e[sz].nx = Fi[u];
Fi[u] = sz++;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int nd[MAXN], path[MAXN];
vector<int> rec[MAXN];
void init() {
E_init();
scanf("%d", &N);
for (int i = 1; i < (N + 1); ++i) scanf("%d", &nd[i]);
for (int i = 1; i < (N); ++i) {
int u, v;
scanf("%d %d", &u, &v);
E_add(u, v);
E_add(v, u);
}
};
void dfs(int u, int fa) {
if (fa == -1) {
rec[u].push_back(0);
rec[u].push_back(nd[u]);
path[u] = nd[u];
} else {
rec[u].push_back(path[fa]);
path[u] = gcd(path[fa], nd[u]);
for (int i = 0; i < (rec[fa].size()); ++i)
rec[u].push_back(gcd(rec[fa][i], nd[u]));
sort(rec[u].begin(), rec[u].end());
rec[u].erase(unique(rec[u].begin(), rec[u].end()), rec[u].end());
}
for (int i = Fi[u]; i != -1; i = e[i].nx) {
int v = e[i].v;
if (v != fa) dfs(v, u);
}
}
int main() {
init();
dfs(1, -1);
for (int i = 1; i < (N + 1); ++i)
printf("%d%c", rec[i].back(), i == N ? '\n' : ' ');
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int n;
cin >> n;
for (int t = 0; t < n; t++) {
string s;
cin >> s;
string s1;
cin >> s1;
int t1 = 1;
bool z = 0;
if (s1[0] != s[0]) {
z = 1;
}
for (int q = 1; q < s.size(); q++) {
if (t1 == s1.size()) {
z = 1;
break;
}
while (s[q] != s1[t1]) {
if (s1[t1] != s1[t1 - 1]) {
z = 1;
break;
}
t1++;
if (t1 == s1.size()) {
z = 1;
break;
}
}
t1++;
}
for (int r = t1; r < s1.size(); r++) {
if (s1[r] != s1[r - 1]) {
z = 1;
break;
}
}
if (z) {
cout << "NO" << endl;
}
if (!z) {
cout << "YES" << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void dfs(vector<vector<int>> &gr, vector<char> &used, int color, int v) {
used[v] = color;
for (int i = 0; i < gr[v].size(); i++) {
int u = gr[v][i];
if (!used[u]) dfs(gr, used, color, u);
}
}
bool good(vector<long long> &x, vector<long long> &y, int n, long long t) {
int color = 1;
vector<char> used(n + 1, 0);
vector<vector<int>> gr(n + 1);
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (x[i] == x[j] || y[i] == y[j]) {
if (abs(x[i] - x[j] + y[i] - y[j]) <= t) {
gr[i].push_back(j);
gr[j].push_back(i);
}
}
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(gr, used, color, i);
color++;
if (color == 6) return false;
}
}
if (color == 2) return true;
if (color == 3) {
vector<int> comp1, comp2;
for (int i = 1; i <= n; i++) {
if (used[i] == 1) comp1.push_back(i);
if (used[i] == 2) comp2.push_back(i);
}
for (int iter1 = 0; iter1 < comp1.size(); iter1++) {
for (int iter2 = 0; iter2 < comp2.size(); iter2++) {
int a = comp1[iter1], b = comp2[iter2];
if (x[a] == x[b] || y[a] == y[b]) {
if (2LL * t >= abs(x[a] - x[b] + y[a] - y[b])) return true;
} else {
if (abs(x[a] - x[b]) <= t && abs(y[a] - y[b]) <= t) return true;
}
}
}
return false;
}
if (color == 4) {
vector<pair<long long, long long>> otr;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if ((x[i] == x[j] || y[i] == y[j]) && used[i] != used[j])
otr.push_back(make_pair(i, j));
}
}
for (int i = 0; i < otr.size(); i++) {
for (int j = 1; j <= n; j++) {
int a = otr[i].first, b = otr[i].second, c = j;
if (used[a] == used[c] || used[b] == used[c]) continue;
if (x[a] == x[b]) {
if (abs(y[c] - y[b]) <= t && abs(y[c] - y[a]) <= t &&
abs(x[a] - x[c]) <= t)
return true;
} else {
if (abs(x[c] - x[a]) <= t && abs(x[c] - x[b]) <= t &&
abs(y[c] - y[a]) <= t)
return true;
}
}
}
return false;
}
if (color == 5) {
vector<pair<long long, long long>> otr_y;
vector<pair<long long, long long>> otr_x;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (x[i] == x[j] && used[i] != used[j])
otr_x.push_back(make_pair(i, j));
if (y[i] == y[j] && used[i] != used[j])
otr_y.push_back(make_pair(i, j));
}
}
for (int i = 0; i < otr_x.size(); i++) {
for (int j = 0; j < otr_y.size(); j++) {
int a = otr_y[j].first, b = otr_y[j].second;
int c = otr_x[i].first, d = otr_x[i].second;
if (used[a] == used[c] || used[a] == used[d] || used[b] == used[c] ||
used[b] == used[d])
continue;
if (x[a] > x[b]) swap(a, b);
if (y[d] > y[c]) swap(c, d);
long long Ox = x[c], Oy = y[a];
if (abs(Ox - x[a]) <= t && abs(Ox - x[b]) <= t && abs(Oy - y[c]) <= t &&
abs(Oy - y[d]) <= t)
return true;
}
}
return false;
}
}
int main() {
int n;
cin >> n;
vector<long long> x(n + 1);
vector<long long> y(n + 1);
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
long long l = 1, r = (long long)2e9 + 100;
while (l < r) {
long long m = l + (r - l) / 2LL;
if (good(x, y, n, m))
r = m;
else
l = m + 1LL;
}
if (l > (long long)2e9)
cout << -1;
else
cout << l;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long int myRand(long long int B) { return (unsigned long long)rng() % B; }
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
long long int n;
cin >> n;
long long int a, b;
cin >> a >> b;
long long int t;
cin >> t;
string s;
cin >> s;
long long int sum = (n - 1) * a + n;
for (int i = 0; i < n; i++) {
if (s[i] == 'w') sum += b;
}
if (sum <= t) {
cout << n << "\n";
return 0;
}
long long int cost = 1 + (s[0] == 'w' ? b : 0);
if (cost > t) {
cout << 0 << "\n";
return 0;
}
t -= cost;
int res = 1;
vector<long long int> R(n, 1e15);
cost = 0;
R[0] = 0;
for (int i = 1; i < n; i++) {
cost += a + 1 + (s[i] == 'w' ? b : 0);
R[i] = cost;
if (cost <= t) {
res = i + 1;
} else {
break;
}
}
cost = 0;
vector<long long int> RR(n, 1e15);
RR[0] = 0;
for (int i = n - 1; i >= 0; i--) {
cost += a + 1 + (s[i] == 'w' ? b : 0);
if (cost <= t) {
RR[n - i] = cost;
res = max(res, (int)n - i + 1);
int l = 0, r = n;
long long int sum = cost + (n - i) * a;
while (r - l > 1) {
int mid = (l + r) / 2;
if (R[mid] + sum <= t) {
l = mid;
} else {
r = mid;
}
}
res = max(res, (int)n - i + 1 + l);
} else {
break;
}
}
for (int i = 1; i < n; i++) {
if (R[i] == 1e15) continue;
long long int sum = R[i] + i * a;
if (sum > t) break;
int l = 0, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
if (RR[mid] + sum <= t) {
l = mid;
} else {
r = mid;
}
}
res = max(res, i + 1 + l);
}
cout << res << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 0, ch;
while (!isdigit(ch = getchar())) f |= ch == '-';
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
int n;
int mes[] = {0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0};
int main() {
n = read();
write(mes[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int g[2][3], fr[8], z[2][3], f5[2], f3[2], an[8];
bool ok(int a, int b) {
for (int i = 0; i < (int)(2); ++i)
for (int j = 0; j < (int)(3); ++j) z[i][j] = g[i][j];
for (int i = 0; i < (int)(3); ++i) z[0][i] -= a;
for (int i = 0; i < (int)(3); ++i) z[1][i] -= fr[7] - a;
for (int i = 0; i < (int)(2); ++i) z[0][i] -= b;
for (int i = 0; i < (int)(2); ++i) z[1][i] -= fr[6] - b;
for (int i = 0; i < (int)(2); ++i)
for (int j = 0; j < (int)(3); ++j)
if (z[i][j] < 0) return false;
for (int i = 0; i < (int)(2); ++i) f5[i] = f3[i] = 0;
for (int i = 0; i < (int)(2); ++i) {
if (z[i][2] > z[i][1]) {
int t = min(fr[5] - f5[0] - f5[1], min(z[i][2] - z[i][1], z[i][0]));
f5[i] += t;
z[i][2] -= t;
z[i][0] -= t;
}
if (z[i][2] > z[i][0]) {
int t = min(fr[3] - f3[0] - f3[1], min(z[i][2] - z[i][0], z[i][1]));
f3[i] += t;
z[i][2] -= t;
z[i][1] -= t;
}
}
for (int i = 0; i < (int)(2); ++i) {
int t = min(fr[5] - f5[0] - f5[1], min(z[i][0], z[i][2]));
f5[i] += t;
z[i][0] -= t;
z[i][2] -= t;
t = min(fr[3] - f3[0] - f3[1], min(z[i][1], z[i][2]));
f3[i] += t;
z[i][1] -= t;
z[i][2] -= t;
}
if (fr[3] > f3[0] + f3[1] || fr[5] > f5[0] + f5[1] ||
fr[1] > z[0][2] + z[1][2] || fr[2] > z[0][1] + z[1][1] ||
fr[4] > z[0][0] + z[1][0])
return false;
an[1] = min(fr[1], z[0][2]);
an[2] = min(fr[2], z[0][1]);
an[3] = f3[0];
an[4] = min(fr[4], z[0][0]);
an[5] = f5[0];
an[6] = b;
an[7] = a;
return true;
}
void solve() {
for (int i = 0; i < (int)(2); ++i)
for (int j = 0; j < (int)(3); ++j) scanf("%d", g[i] + j);
for (int i = 7; i > 0; --i) scanf("%d", fr + i);
for (int i = 0; i < (int)(fr[7] + 1); ++i)
for (int j = 0; j < (int)(fr[6] + 1); ++j)
if (ok(i, j)) {
for (int i = 1; i < (int)(8); ++i) printf("%d ", an[8 - i]);
printf("\n");
return;
}
printf("-1\n");
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long tra[10000];
long long mark[1000001];
pair<long long, long long> v[1000001];
int main() {
long long n, f;
cin >> n >> f;
long long ara[n + 2], bra[n + 2];
for (long long i = 0; i < n; i++) {
cin >> ara[i] >> bra[i];
long long k = ara[i];
long long l = bra[i];
if (k >= l) {
v[i].first = 0;
v[i].second = i;
} else {
long long x = min(2 * k, l);
v[i].first = x - k;
v[i].second = i;
}
}
sort(v, v + n);
reverse(v, v + n);
long long ans = 0;
for (long long i = 0; i < f; i++) {
mark[v[i].second] = 1;
}
for (long long i = 0; i < n; i++) {
if (mark[i] == 1) {
ans += min(2 * ara[i], bra[i]);
} else {
ans += min(ara[i], bra[i]);
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD(long long int a, long long int b) {
if (a > b)
return a - b;
else
return b - a;
}
int max3(int a, int b, int c) { return max(c, max(a, b)); }
long long int power(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;
}
long long int logg(long long int a) {
long long int x = 0;
while (a > 1) {
x++;
a /= 2;
}
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; i++) cin >> A[i];
int m;
cin >> m;
vector<int> B(m);
for (int i = 0; i < m; i++) cin >> B[i];
int sum = 0;
long long int t = 0;
long long int sum1 = 0, sum2 = 0;
for (int i = 0; i < n; i++) sum1 += A[i];
for (int i = 0; i < m; i++) sum2 += B[i];
if (sum1 != sum2) {
cout << -1;
exit(0);
}
int i = 0, j = 0;
long long int t1 = A[0], t2 = B[0];
while (i < n && j < m) {
if (t1 == t2) {
sum++;
i++;
j++;
if (i == n && j == m) break;
t1 = A[i];
t2 = B[j];
} else if (t1 > t2) {
j++;
t2 += B[j];
} else {
i++;
t1 += A[i];
}
}
cout << sum;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const int mod = 1e9 + 7;
int head[N], cnt, n, d[N], f[N][21], dep[N], q[N];
long long b[N];
struct nd {
int ne, to;
} e[N * 2];
void in(int x, int y) {
e[++cnt].to = y;
e[cnt].ne = head[x];
head[x] = cnt;
}
int main() {
scanf("%d", &n);
b[0] = 1;
for (int i = 1; i < N; ++i) b[i] = (b[i - 1] * 2) % mod;
for (int i = 1, x, y; i < n; ++i)
scanf("%d%d", &x, &y), in(x, y), in(y, x), d[x]++, d[y]++;
for (int i = 1; i <= n; ++i)
if (d[i] == 1) q[++q[0]] = i;
long long ans = 0;
for (int i = 1; i <= n; ++i) (ans += b[n - q[0] + (d[i] == 1)]) %= mod;
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int q;
int pos_a[201000];
int a[211000];
int b[201000];
int pos_b[201000];
int front[201000];
int st[200100][32];
int st2[201000][32];
int fast(int x, int y) {
int temp = 1;
for (int i = 1; i <= y; i++) {
temp *= x;
}
return y;
}
int Log[201100];
void pre() {
for (int i = 1; i <= n; i++) {
st[i][0] = front[i];
}
for (int j = 1; j <= 27; j++) {
for (int i = 1; i <= n; i++) {
st[i][j] = st[st[i][j - 1]][j - 1];
}
}
Log[0] = -1;
for (int i = 1; i <= n; i++) Log[i] = Log[i >> 1] + 1;
for (int i = 1; i <= n; i++) {
int t = m - 1, p = i;
for (int j = 27; j >= 0; j--) {
if (t - (1 << j) >= 0) {
t -= (1 << j);
p = st[p][j];
}
}
st2[i][0] = p;
}
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
st2[i][j] = max(st2[i][j - 1], st2[i + (1 << j - 1)][j - 1]);
}
}
return;
}
void make(int l, int r) {
int len = r - l + 1;
int t = Log[len];
if (max(st2[l][t], st2[r - (1 << t) + 1][t]) >= l)
cout << 1;
else
cout << 0;
return;
}
int main() {
cin >> m >> n >> q;
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
pos_a[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
int t = a[pos_a[b[i]] - 1];
if (!t) t = a[m];
front[i] = pos_b[t];
pos_b[b[i]] = i;
}
pre();
int l, r;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
make(l, r);
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long double pi = 3.141592653589793238462643383279;
const long long INF = 1e18;
void bruteforce() {}
void solve() {
long long n, m, k;
cin >> n >> m >> k;
long long a[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
}
}
if (m == 1) {
cout << 0;
return;
}
long long dp[n][m][2][m / 2 + 1][k];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
for (long long x = 0; x < 2; x++) {
for (long long y = 0; y < m / 2 + 1; y++) {
for (long long z = 0; z < k; z++) {
dp[i][j][x][y][z] = 0LL;
}
}
}
}
}
dp[0][0][1][1][a[0][0] % k] = a[0][0];
for (long long i = 0; i < n; i++) {
if (i > 0) {
for (long long z = 0; z < k; z++) {
for (long long y = 0; y < m / 2 + 1; y++) {
dp[i][0][0][0][z] = max({dp[i][0][0][0][z], dp[i - 1][m - 1][0][y][z],
dp[i - 1][m - 1][1][y][z]});
dp[i][0][1][1][z] =
max({dp[i][0][1][1][z],
dp[i - 1][m - 1][0][y][(z - a[i][0] + 70 * k) % k],
dp[i - 1][m - 1][1][y][(z - a[i][0] + 70 * k) % k]});
}
if (!dp[i][0][1][1][z]) {
if (a[i][0] % k == z) {
dp[i][0][1][1][z] += a[i][0];
}
} else {
dp[i][0][1][1][z] += a[i][0];
}
}
}
for (long long j = 1; j < m; j++) {
for (long long x = 0; x < 2; x++) {
for (long long z = 0; z < k; z++) {
for (long long y = 0; y < m / 2 + 1; y++) {
if (x == 0) {
dp[i][j][0][y][z] =
max(dp[i][j - 1][0][y][z], dp[i][j - 1][1][y][z]);
} else {
if (y >= 1)
dp[i][j][1][y][z] =
max(dp[i][j - 1][0][y - 1][(z - a[i][j] + 70 * k) % k],
dp[i][j - 1][1][y - 1][(z - a[i][j] + 70 * k) % k]);
if (y >= 1)
if (dp[i][j][1][y][z] == 0) {
if (a[i][j] % k == z) {
dp[i][j][1][y][z] += a[i][j];
}
} else {
dp[i][j][1][y][z] += a[i][j];
}
}
}
}
}
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
for (long long x = 0; x < 2; x++) {
for (long long y = 0; y < m / 2 + 1; y++) {
for (long long z = 0; z < 1; z++) {
ans = max(ans, dp[i][j][x][y][z]);
}
}
}
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long T = 1;
while (T--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
void ff() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
void in_out_txt() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
ff();
int n, k;
cin >> n >> k;
vector<long long> vec1(n), vec2(n);
for (int i = 0; i < n; i++) cin >> vec1[i];
for (int j = 0; j < n; j++) cin >> vec2[j];
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) v.push_back(make_pair(vec1[i] - vec2[i], i));
sort(v.begin(), v.end());
long long sum = 0;
for (int i = 0; i < k; i++) sum += vec1[v[i].second];
for (int i = k; i < n; i++) sum += min(vec1[v[i].second], vec2[v[i].second]);
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class DSU {
private:
int dsu[200005];
public:
void Init() { memset(dsu, 0xFF, sizeof(dsu)); }
int Find(int x) {
if (dsu[x] == -1)
return x;
else
return (dsu[x] = Find(dsu[x]));
}
void Union(int a, int b) {
a = Find(a);
b = Find(b);
if (a != b) dsu[a] = b;
}
};
struct EDGE {
int id;
int to;
EDGE() : id(0), to(0) {}
EDGE(int _id, int _to) : id(_id), to(_to) {}
};
vector<EDGE> adj[200005];
int dnode[200005], uedge[200005];
long long int w[200005];
DSU dsu;
int n, m;
int depth[200005], parent[200005][20];
void LCA_init(int root, int prec, int d) {
depth[root] = d;
parent[root][0] = prec;
for (int i = 1; i < 20; ++i)
parent[root][i] = parent[parent[root][i - 1]][i - 1];
for (const EDGE& e : adj[root]) {
if (e.to == prec)
continue;
else {
dnode[e.id] = e.to;
uedge[e.to] = e.id;
LCA_init(e.to, root, d + 1);
}
}
}
int LCA_jump(int src, int len) {
for (int k = 0; (1 << k) <= len; ++k) {
if (len & (1 << k)) src = parent[src][k];
}
return src;
}
int LCA_query(int a, int b) {
if (depth[a] < depth[b]) swap(a, b);
a = LCA_jump(a, depth[a] - depth[b]);
if (a != b) {
for (int k = 18; k >= 0; --k) {
if (parent[a][k] != parent[b][k]) {
a = parent[a][k];
b = parent[b][k];
}
}
a = parent[a][0];
b = parent[b][0];
}
return a;
}
long long int solve_1(int a, int b, long long int y) {
int anc = LCA_query(a, b);
while (depth[a] > depth[anc]) {
a = dsu.Find(a);
if (depth[a] <= depth[anc]) break;
if (w[uedge[a]] == 1LL)
dsu.Union(a, parent[a][0]);
else
y /= w[uedge[a]];
a = parent[a][0];
if (y == 0) return 0LL;
}
while (depth[b] > depth[anc]) {
b = dsu.Find(b);
if (depth[b] <= depth[anc]) break;
if (w[uedge[b]] == 1LL)
dsu.Union(b, parent[b][0]);
else
y /= w[uedge[b]];
b = parent[b][0];
if (y == 0) return 0LL;
}
return y;
}
void solve_2(int p, long long int c) {
w[p] = c;
if (c == 1LL) dsu.Union(dnode[p], parent[dnode[p]][0]);
}
int main(int argc, char* argv[]) {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d%lld", &u, &v, &w[i]);
adj[u].push_back(EDGE(i, v));
adj[v].push_back(EDGE(i, u));
}
LCA_init(1, 0, 0);
dsu.Init();
while (m--) {
int op;
scanf("%d", &op);
if (op == 1) {
int a, b;
long long int y;
scanf("%d%d%lld", &a, &b, &y);
printf("%lld\n", solve_1(a, b, y));
} else {
int p;
long long int c;
scanf("%d%lld", &p, &c);
solve_2(p, c);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF64 = 1e18;
const long long mod = 1e9 + 7;
const int maxn = 3e6;
void solve() {
int n, k;
cin >> n >> k;
vector<long long> a(n), d(n);
long long minD = INF64;
long long sumA = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sumA += a[i];
}
for (int i = 0; i < n; i++) {
cin >> d[i];
}
for (int i = 0; i < n - 1; i++) {
minD = min(minD, d[i]);
}
if (k == 0) {
long long sumSuf = sumA;
long long maxAns = 0;
for (int i = 0; i < n; i++) {
maxAns = max(maxAns, sumSuf - d[i]);
sumSuf -= a[i];
}
cout << maxAns;
return;
}
if (k == 1) {
long long sumSuf = sumA - a[0];
long long maxAns1 = 0;
for (int i = 1; i < n; i++) {
maxAns1 = max(maxAns1, sumSuf - d[i]);
sumSuf -= a[i];
}
long long maxAns2 = 0;
long long prefMinD = INF64;
long long prefSumA = 0;
for (int i = 0; i < n - 1; i++) {
prefSumA += a[i];
prefMinD = min(prefMinD, d[i]);
long long sum1 = prefSumA - prefMinD;
long long sum2 = (sumA - prefSumA) - d[i + 1];
maxAns2 = max(maxAns2, max(sum1, 0ll) + max(sum2, 0ll));
}
long long maxAns3 = 0;
for (int i = 1; i < n - 1; i++) {
long long sum1 = (sumA - a[i]) - d[0];
long long sum2 = a[i] - d[i];
maxAns3 = max(maxAns3, max(sum1, 0ll) + max(sum2, 0ll));
}
long long maxAns = max(maxAns1, max(maxAns2, maxAns3));
cout << maxAns;
return;
}
cout << max(max(sumA - minD, a.back() - d.back()), 0ll);
}
int main(int argc, char** argv) {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int mul(int a, int b) { return ((long long)a * b) % (1000000007); }
struct tri {
int a, b, c;
tri() {}
tri(int _a, int _b, int _c) : a(_a), b(_b), c(_c){};
};
int pw[1020304], pw2[1020304], a4[1020304], a7[1020304], sm[1020304],
f[1020304], num[1020304], ts[1020304], mx[1020304];
tri Cal(int i, char *s) {
if (i == 0) {
if (s[0] == '4') return tri(0, 4, 1);
if (s[0] == '7') return tri(28, 11, 2);
}
tri pre = Cal(i - 1, s);
if (s[i] == '4') {
int tb = ((long long)pre.b * 2 + (1000000007) - mx[i - 1] + (1000000007) -
a4[i - 1]) %
(1000000007);
int a = ((pre.a + mul(tb, mul(pw[i], 4))) % (1000000007) +
mul(mul(pw2[i], 16), pre.c - 1)) %
(1000000007);
int b = (mul(mul(pre.c, pw[i]), 4) + pre.b) % (1000000007);
int c = pre.c;
if (pre.c == 1) a = 0;
return tri(a, b, c);
}
int ad4 = ((f[i - 1] + mul(ts[i - 1], mul(pw[i], 4))) % (1000000007) +
mul(mul(pw2[i], 16), num[i - 1] - 1)) %
(1000000007);
int a = mul(pw[i], 4), b = a7[i - 1], c = mul(pw[i], 7), d = a4[i - 1];
int mid =
((long long)mul(a, c) + mul(b, c) + mul(b, d) + mul(a, d)) % (1000000007);
int tb = ((long long)pre.b * 2 + (1000000007) - mx[i - 1] + (1000000007) -
a4[i - 1]) %
(1000000007);
int ad7 = ((pre.a + mul(tb, mul(pw[i], 7))) % (1000000007) +
mul(mul(pw2[i], 49), pre.c - 1)) %
(1000000007);
if (pre.c == 1) ad7 = 0;
int A = ((long long)ad4 + ad7 + mid) % (1000000007);
int B = ((long long)mul(mul(num[i - 1], pw[i]), 4) +
mul(mul(pre.c, pw[i]), 7) + (pre.b + sm[i - 1]) % (1000000007)) %
(1000000007);
int C = (num[i - 1] + pre.c) % (1000000007);
return tri(A, B, C);
}
char L[1020304], R[1020304];
int n;
int main() {
scanf("%s%s", L + 1, R + 1);
n = strlen(L + 1);
pw[0] = 1;
for (int i = 1; i <= n; ++i)
pw[i] = mul(pw[i - 1], 10), pw2[i] = mul(pw[i], pw[i]);
a4[0] = 4;
a7[0] = 7;
for (int i = 1; i <= n; ++i) a7[i] = (mul(a7[i - 1], 10) + 7) % (1000000007);
for (int i = 1; i <= n; ++i) a4[i] = (mul(a4[i - 1], 10) + 4) % (1000000007);
f[0] = 28;
num[0] = 2;
sm[0] = 11;
for (int i = 1; i <= n; ++i) {
ts[i - 1] = ((mul(sm[i - 1], 2) + (1000000007) - a4[i - 1]) % (1000000007) +
(1000000007) - a7[i - 1]) %
(1000000007);
int ad4 = ((f[i - 1] + mul(ts[i - 1], mul(pw[i], 4))) % (1000000007) +
mul(mul(pw2[i], 16), num[i - 1] - 1)) %
(1000000007);
int ad7 = ((f[i - 1] + mul(ts[i - 1], mul(pw[i], 7))) % (1000000007) +
mul(mul(pw2[i], 49), num[i - 1] - 1)) %
(1000000007);
int a = mul(pw[i], 4), b = a7[i - 1], c = mul(pw[i], 7), d = a4[i - 1];
int mid = ((long long)mul(a, c) + mul(b, c) + mul(b, d) + mul(a, d)) %
(1000000007);
f[i] = ((long long)ad4 + ad7 + mid) % (1000000007);
sm[i] =
(mul(mul(num[i - 1], pw[i]), 11) + mul(sm[i - 1], 2)) % (1000000007);
num[i] = mul(num[i - 1], 2);
}
reverse(L + 1, L + n + 1);
mx[0] = L[1] - '0';
for (int i = 1; i <= n - 1; ++i)
mx[i] = (mx[i - 1] + mul(L[i + 1] - '0', pw[i])) % (1000000007);
int t = Cal(n - 1, L + 1).a;
reverse(R + 1, R + n + 1);
mx[0] = R[1] - '0';
for (int i = 1; i <= n - 1; ++i)
mx[i] = (mx[i - 1] + mul(R[i + 1] - '0', pw[i])) % (1000000007);
int t2 = Cal(n - 1, R + 1).a;
int Ans = (t2 + (1000000007) - t) % (1000000007);
cout << Ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
double coins = float(n) / 3;
if (coins == int(coins))
cout << int(coins) << " " << int(coins) << endl;
else {
n = n - int(coins) * 3;
if (n == 1)
cout << int(coins) + 1 << " " << int(coins) << endl;
else
cout << int(coins) << " " << int(coins) + 1 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long k, c, r, n;
cin >> k;
n = sqrt(k);
if (k == (n * n)) {
r = n;
c = 1;
} else {
if (k <= ((n * n) + n + 1)) {
r = k - n * n;
c = n + 1;
} else {
r = n + 1;
c = (n + 1) * (n + 1) - k + 1;
}
}
cout << r << "\t" << c << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int arr[n], res[n];
map<int, int> mp;
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
res[n - 1] = 1;
mp[arr[n - 1]]++;
for (int i = n - 2; i >= 0; i--)
if (mp[arr[i]] == 0) {
res[i] = res[i + 1] + 1;
mp[arr[i]]++;
} else
res[i] = res[i + 1];
while (m--) {
int x;
scanf("%d", &x);
printf("%d\n", res[x - 1]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200100];
int n, i, j, k;
int d[200100];
int lf[200100];
void dfs(int i, int p) {
int j;
for (j = 0; j < v[i].size(); j++) {
if (v[i][j] == p) continue;
d[v[i][j]] = !d[i];
dfs(v[i][j], i);
lf[i] += lf[v[i][j]];
}
if (v[i].size() == 1 && v[i][0] == p) lf[i] = 1;
}
int recMax(int i, int p, int l, int r) {
int j, k, ans = d[i] ? r + 1 : 0;
if (l == r) return l;
for (j = 0; j < v[i].size(); j++) {
k = v[i][j];
if (k == p) continue;
if (!d[i])
ans = max(ans, recMax(k, i, r - lf[k] + 1, r));
else
ans -= lf[k] - recMax(k, i, 1, lf[k]) + 1;
}
return ans;
}
int recMin(int i, int p, int l, int r) {
int j, k, ans = d[i] ? n + 1 : l - 1;
if (l == r) return l;
for (j = 0; j < v[i].size(); j++) {
k = v[i][j];
if (k == p) continue;
if (d[i])
ans = min(ans, recMin(k, i, l, l + lf[k] - 1));
else
ans += recMin(k, i, 1, lf[k]);
}
return ans;
}
int main() {
scanf("%d", &n);
if (n == 1) {
puts("1 1");
return 0;
}
for (k = 1; k < n; k++) {
scanf("%d%d", &i, &j);
i--;
j--;
v[i].push_back(j);
v[j].push_back(i);
}
dfs(0, -1);
printf("%d %d\n", recMax(0, -1, 1, lf[0]), recMin(0, -1, 1, lf[0]));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const int N = 2e5 + 100;
struct Edge {
int v, next;
Edge(int v = -1, int next = -1) : v(v), next(next) {}
} e[N * 2];
int head[N], total;
void init() {
memset(head, -1, sizeof(head));
total = 0;
}
void adde(int u, int v) {
e[total] = Edge(v, head[u]);
head[u] = total++;
}
int c1[N], c2[N][2], c3[N][2], fg[N];
int aa[N];
void dfs(int u, int f, int id) {
c1[u] = c2[u][1] = c2[u][0] = c3[u][0] = c3[u][1] = 0;
fg[u] = 0;
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if (v == f) continue;
dfs(v, u, id);
fg[u] += fg[v] ? 1 : 0;
if (!fg[v])
c1[u] += c1[v];
else {
if (c2[u][1] < c1[v] + c2[v][1]) {
swap(c2[u][1], c3[u][1]);
swap(c2[u][0], c3[u][0]);
c2[u][0] = v;
c2[u][1] = c1[v] + c2[v][1];
} else if (c3[u][1] < c2[v][1] + c1[v]) {
c3[u][0] = v;
c3[u][1] = c2[v][1] + c1[v];
}
}
}
if (aa[u] < id) {
c1[u] = c3[u][0] = c3[u][1] = c2[u][0] = c2[u][1] = 0;
fg[u]++;
} else {
c1[u]++;
}
}
int ans;
void dfs(int u, int f, int a, int b, int id) {
if (b == 1) {
ans = max(ans, c1[u] + max(c2[u][1], a));
} else {
ans = max(ans, c1[u] + a + c2[u][1]);
}
for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;
if (v == f) continue;
if (aa[u] < id)
dfs(v, u, 0, 1, id);
else {
int xx = fg[v] ? 0 : c1[v], yy = (c2[u][0] == v) ? c3[u][1] : c2[u][1];
if (b) {
dfs(v, u, c1[u] - xx + max(a, yy), 1, id);
} else if (fg[u] - (fg[v] ? 1 : 0)) {
dfs(v, u, c1[u] - xx + a + yy, 1, id);
} else
dfs(v, u, c1[u] - xx + a, 0, id);
}
}
}
int main() {
int n, k;
while (scanf("%d%d", &n, &k) != EOF) {
int l = inf, r = -1;
for (int i = 1; i <= n; i++) {
scanf("%d", &aa[i]);
l = min(aa[i], l);
r = max(aa[i], r);
}
init();
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
adde(a, b);
adde(b, a);
}
r++;
c1[0] = c2[0][0] = c2[0][1] = c3[0][0] = c3[0][1] = 0;
fg[0] = 0;
while (l + 1 < r) {
int mid = (l + r) / 2;
dfs(1, 0, mid);
ans = 0;
dfs(1, 0, 0, 0, mid);
if (ans >= k)
l = mid;
else
r = mid;
}
printf("%d\n", l);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
struct node {
string tag;
vector<node *> children;
node(string s) { tag = s; }
};
char c[maxn];
string queryString[maxn];
int n, ans, cnt;
node *parseXML(string s) {
stack<node *> stack;
stack.push(new node("*"));
int l = s.length();
int i = 0;
while (i < l) {
i++;
if (s[i] == '/') {
i++;
while (isalpha(s[i])) i++;
node *p = stack.top();
stack.pop();
node *q = stack.top();
stack.pop();
q->children.push_back(p);
stack.push(q);
} else {
string tag = "";
while (isalpha(s[i])) {
tag.push_back(s[i]);
i++;
}
if (s[i] == '/') {
node *top = stack.top();
stack.pop();
top->children.push_back(new node(tag));
stack.push(top);
i++;
} else {
stack.push(new node(tag));
}
}
i++;
}
return stack.top();
}
void printXML(node *root, int level) {
for (int i = 1; i <= 2 * level; i++) cout << " ";
cout << "<" << root->tag << ">" << endl;
vector<node *> v = root->children;
for (int i = 0; i < (int)v.size(); i++) {
node *x = v[i];
printXML(x, level + 1);
}
for (int i = 1; i <= 2 * level; i++) cout << " ";
cout << "</" << root->tag << ">" << endl;
}
void count(node *root, int position) {
if (root->tag == queryString[position]) {
if (position == cnt - 1)
ans++;
else
position++;
}
for (int i = 0; i < (int)root->children.size(); i++) {
count(root->children[i], position);
}
}
int main() {
string s;
while (cin >> s) {
node *root = parseXML(s);
scanf("%d", &n);
gets(c);
while (n--) {
gets(c);
int l = strlen(c);
int i = 0;
cnt = 0;
while (i < l) {
string tmp = "";
while (isalpha(c[i]) && i < l) {
tmp.push_back(c[i]);
i++;
}
queryString[cnt++] = tmp;
i++;
}
ans = 0;
count(root, 0);
printf("%d\n", ans);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int N = 1e6 + 5;
constexpr int MOD = 1e9 + 7;
int T;
int main() {
scanf("%d", &T);
while (T--) {
int n, k;
scanf("%d%d", &n, &k);
ll d = 1;
ll ret = 0;
while (k) {
if (k & 1) {
ret = (ret + d) % MOD;
}
d = d * n % MOD;
k >>= 1;
}
printf("%lld\n", ret);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct pt {
long long x, y, xc;
};
pt ar[200000];
int fw[200001];
int xoc[200001];
inline void fa(int v) {
if (xoc[v]) return;
xoc[v] = 1;
while (v <= 200000) {
fw[v]++;
v += (v & -v);
}
}
inline long long sa(int id) {
long long tt = 0;
while (id > 0) {
tt += (long long)fw[id];
id -= (id & -id);
}
return tt;
}
inline long long rs(int b, int e) { return sa(e) - sa(b - 1); }
int main(int argc, char **argv) {
scanf("%d ", &n);
for (int i = 0; i < n; i++) scanf("%lld %lld\n", &ar[i].x, &ar[i].y);
auto f1 = [&](pt &a, pt &b) { return a.y == b.y ? a.xc < b.xc : a.y > b.y; };
auto f2 = [&](pt &a, pt &b) { return a.x < b.x; };
sort(ar, ar + n, f2);
for (int i = 0; i < n; i++) {
if (i >= 1)
if (ar[i].x == ar[i - 1].x)
ar[i].xc = ar[i - 1].xc;
else
ar[i].xc = ar[i - 1].xc + 1;
else
ar[i].xc = 1;
}
sort(ar, ar + n, f1);
long long tt = 0;
for (int i = 0, j = 0; i < n; i++) {
if (i == 0)
fa(ar[i].xc);
else {
if (ar[i].y == ar[i - 1].y) {
fa(ar[i].xc);
} else {
for (int k = j; k < i; k++) {
if (k == j) {
tt += rs(1, ar[k].xc) * rs(ar[k].xc, n);
} else {
tt += rs(ar[k - 1].xc + 1, ar[k].xc) * rs(ar[k].xc, n);
}
}
fa(ar[i].xc);
j = i;
}
}
if (i == n - 1) {
for (int k = j; k <= i; k++) {
if (k == j) {
tt += rs(1, ar[k].xc) * rs(ar[k].xc, n);
} else {
tt += rs(ar[k - 1].xc + 1, ar[k].xc) * rs(ar[k].xc, n);
}
}
}
}
printf("%lld\n", tt);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class Bride {
public:
int x, y, v;
void read() { scanf("%d%d%d", &x, &y, &v); }
bool operator<(const Bride &arg) const { return v > arg.v; }
};
Bride g[202020];
int n, m, ans;
int f[202020];
bool v[202020];
int getf(int p) { return p == f[p] ? p : f[p] = getf(f[p]); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) g[i].read();
for (int i = 1; i <= n; i++) f[i] = i;
sort(g + 1, g + m + 1);
for (int i = 1; i <= m; i++) {
int xt = getf(g[i].x), yt = getf(g[i].y);
if (v[xt] && v[yt]) continue;
if (xt == yt)
v[xt] = true;
else
f[g[i].x] = f[xt] = yt, v[yt] |= (v[xt] |= v[g[i].x]);
ans += g[i].v;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long int n, m, a, b;
cin >> n >> m >> a >> b;
long long int r = n % m;
long long int d = n / m;
long long int p1 = r * b;
long long int p2 = ((d + 1) * m - n) * a;
if (p1 > p2) {
cout << p2;
} else {
cout << p1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, T;
scanf("%d %d", &n, &T);
priority_queue<int> q;
int ans = 0;
for (int i = 1; i <= min(T - 1, n); i++) {
while (!q.empty() && q.top() >= T - i) q.pop();
int x;
scanf("%d", &x);
if (x < T) q.push(x - i);
ans = max(ans, (int)q.size());
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_K = 100;
int n, k, t;
int mid, cnt;
std::pair<int, long long> e[MAX_K];
void dfs(int id, int v, long long mask) {
if (id == k) return;
if (cnt >= t) return;
if (v + e[id].first > mid) return;
if (!(mask & e[id].second)) {
cnt++;
dfs(id + 1, v + e[id].first, mask | e[id].second);
}
dfs(id + 1, v, mask);
}
int main() {
scanf("%d%d%d", &n, &k, &t);
for (int i = 0; i < k; i++) {
int h, w;
scanf("%d%d%d", &h, &w, &e[i].first);
e[i].second = (1LL << (h + n)) | (1LL << w);
}
sort(e, e + k);
int low = 0, high = n * 1000;
while (low < high) {
mid = (low + high) / 2;
cnt = 1;
dfs(0, 0, 0);
if (cnt >= t)
high = mid;
else
low = mid + 1;
}
printf("%d\n", low);
return 0;
}
| 5 |
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
int dp[(int)(2600 + 25)][(int)(2600 + 25)];
string ans, s;
void trace(int i, int j) {
if (j == 1) {
ans += s[i];
return;
}
if (j == 2) {
if (dp[i][j] == 1)
ans += s[i];
else {
ans += s[i];
ans += s[i];
}
return;
}
if (j >= 3 && (s[i] == s[i + j - 1]) && dp[i][j] == 2 + dp[i + 1][j - 2]) {
ans += s[i];
trace(i + 1, j - 2);
ans += s[i];
} else if (dp[i][j] == dp[i + 1][j - 1]) {
trace(i + 1, j - 1);
} else {
trace(i, j - 1);
}
}
void solve() {
cin >> s;
int n = s.size();
s = '#' + s;
if (n < 2600) {
for (int i = 1; i <= n; i++) {
dp[i][1] = 1;
if (i == n) continue;
if (s[i] == s[i + 1]) {
dp[i][2] = 2;
} else {
dp[i][2] = 1;
}
}
for (int j = 3; j <= n; j++) {
for (int i = 1; i + j - 1 <= n; i++) {
int l = i, r = i + j - 1;
dp[i][j] = max(dp[i + 1][j - 1], dp[i][j - 1]);
if (s[l] == s[r]) {
dp[i][j] = max(dp[i + 1][j - 2] + 2, dp[i][j]);
}
}
}
for (int j = 1; j <= n; j++) {
for (int i = 1; i + j - 1 <= n; i++) {
if (dp[i][j] == 100) {
trace(i, j);
cout << ans;
return;
}
}
}
trace(1, n);
string a1, a2;
if (ans.size() >= 100) {
for (int i = 0; i < min(50, (int)ans.size()); i++) {
a1 += ans[i];
a2 += ans[ans.size() - 1 - i];
}
reverse(a2.begin(), a2.end());
cout << a1 + a2;
return;
}
cout << ans;
return;
}
int c[26];
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) {
c[s[i] - 'a']++;
if (c[s[i] - 'a'] == 100) {
for (int j = 0; j < 100; j++) {
cout << s[i];
}
break;
}
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int c = 0;
int v, sum = 0;
vector<int> x;
for (int i = 0; i < n; i++) {
cin >> v;
x.push_back(v);
}
sort(x.begin(), x.end());
for (int i = 0; i < n; i++) {
if (x[i] < 0 && c < m) {
sum = sum + abs(x[i]);
c++;
}
}
cout << abs(sum) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
long long sum = 0;
for (int i = 2; i <= n - 1; i++) {
sum += i * (i + 1);
}
cout << sum << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N = 1e6 + 10;
long long gcd(long long p, long long q) { return q == 0 ? p : gcd(q, p % q); }
int to[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
long long n, ans;
long long qp(long long a, long long b) {
long long s = 1;
while (b) {
if (b & 1) s = s * a % 998244353;
a = a * a % 998244353;
b >>= 1;
}
return s;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
ans = (qp(3, n * n) - qp(qp(3, n) - 3, n) + 998244353) % 998244353;
long long xs = -1, c1 = 1;
for (int i = 1; i <= n; i++) {
xs *= -1;
c1 = c1 * (n - i + 1) % 998244353;
c1 = c1 * qp(i, 998244353 - 2) % 998244353;
ans += xs *
(3 * c1 % 998244353 * qp(qp(3, n - i) - 1, n) % 998244353 +
c1 * (qp(3, i) - 3) % 998244353 * qp(3, (n - i) * n) % 998244353) %
998244353;
}
ans = (ans % 998244353 + 998244353) % 998244353;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n), x(n + 1, 0), y(n + 1, 0);
for (int i = 0; i < n; i++) cin >> a[i], a[i]--;
x[0] = (a[0] == 0);
y[0] = (a[0] == 1);
for (int i = 1; i < n; i++) x[i] = x[i - 1] + (a[i] == 0);
for (int i = 1; i < n; i++) y[i] = y[i - 1] + (a[i] == 1);
vector<pair<int, int> > ans;
for (int t = 1; t <= n; t++) {
int c[2] = {0, 0}, last = -1;
for (int i = 0; i < n;) {
y[n] = -1, x[n] = t;
if (i) x[n] += x[i - 1];
int l = i, r = n;
while (l < r) {
int mid = l + r >> 1;
int xx = x[mid], yy = y[mid];
if (i) xx -= x[i - 1], yy -= y[i - 1];
if (max(xx, yy) >= t)
r = mid;
else
l = mid + 1;
}
if (r == n) {
last = -1;
break;
}
int xx = x[r], yy = y[r];
if (i) xx -= x[i - 1], yy -= y[i - 1];
if (xx == t) last = 0, c[0]++;
if (yy == t) last = 1, c[1]++;
i = r + 1;
}
if (last == -1) continue;
if (c[0] != c[1] && c[last] == max(c[0], c[1]))
ans.push_back(make_pair(c[last], t));
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000001];
int nodeNumber[1000001], nodeStart[1000001], nodeEnd[1000001],
leftStart[1000001], leftEnd[1000001], rightStart[1000001],
rightEnd[1000001];
void Initialise(int n) {
sort(a + 1, a + n + 1);
for (int i = 0; i <= n; ++i) {
nodeStart[i] = 0;
nodeEnd[i] = -1;
nodeNumber[i] = 1;
}
nodeStart[1] = 1;
nodeEnd[1] = n;
}
void FixStartEnd(int &i, int &j) {
if (i > j) {
i = 0, j = -1;
}
}
void FillChildNumbers(int n, int k) {
for (int i = 0; i <= n; ++i) {
int j = nodeStart[i];
for (; j <= nodeEnd[i] && (a[j] & (1ll << k)) == 0; ++j)
;
leftStart[i] = nodeStart[i], leftEnd[i] = j - 1;
rightStart[i] = j, rightEnd[i] = nodeEnd[i];
FixStartEnd(leftStart[i], leftEnd[i]);
FixStartEnd(rightStart[i], rightEnd[i]);
j = (nodeStart[i] > 0) ? nodeEnd[i] : i;
nodeStart[i] = 0;
nodeEnd[i] = -1;
i = j;
}
}
long long ZeroBitCount(int n, int k) {
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int targetBit = ((a[i] & (1ll << k)) > 0), j = nodeNumber[i];
ans += ((targetBit == 1) ? (rightEnd[j] - rightStart[j] + 1)
: (leftEnd[j] - leftStart[j] + 1));
}
return ans;
}
void TakeZeroBit(int n, int k) {
for (int i = 1; i <= n; ++i) {
int targetBit = ((a[i] & (1ll << k)) > 0), j = nodeNumber[i], x, start, end;
if (targetBit) {
x = rightStart[j], start = rightStart[j], end = rightEnd[j];
} else {
x = leftStart[j], start = leftStart[j], end = leftEnd[j];
}
nodeNumber[i] = x, nodeStart[x] = start, nodeEnd[x] = end;
}
}
void TakeOneBit(int n, int k) {
for (int i = 1; i <= n; ++i) {
int targetBit = 1 - ((a[i] & (1ll << k)) > 0), j = nodeNumber[i], x, start,
end;
if (targetBit) {
x = rightStart[j], start = rightStart[j], end = rightEnd[j];
} else {
x = leftStart[j], start = leftStart[j], end = leftEnd[j];
}
nodeNumber[i] = x, nodeStart[x] = start, nodeEnd[x] = end;
}
}
int main() {
int n;
long long m;
scanf("%d%lld", &n, &m);
for (int j = 2; j <= n; ++j) {
int i;
long long w;
scanf("%d%lld", &i, &w);
a[j] = (w ^ a[i]);
}
Initialise(n);
long long ans = 0;
for (int k = 61; k > -1; --k) {
FillChildNumbers(n, k);
long long cnt = ZeroBitCount(n, k);
if (cnt >= m) {
TakeZeroBit(n, k);
} else {
ans += (1ll << k);
m -= cnt;
TakeOneBit(n, k);
}
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
ios_base::sync_with_stdio(0);
int n, k, ans = 1;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
while (i < n && a[i - 1] == a[i]) i++;
if (i == n) break;
int res = 1;
while (i < n && a[i - 1] != a[i]) {
res++;
i++;
}
ans = max(ans, res);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9, N = 1e4 + 10;
int dp[2][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
string s, t;
cin >> s >> t;
n = s.size();
m = t.size();
vector<int> pos, nxt(n, -1);
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '.')
pos.push_back(i);
else if (!pos.empty()) {
nxt[i] = pos.back() + 1;
pos.pop_back();
}
}
auto cur = dp[0], prv = dp[1];
for (int j = m; j >= 0; j--) {
swap(cur, prv);
cur[n] = j == m ? 0 : INF;
for (int i = n - 1; i >= 0; i--) {
cur[i] = 1 + cur[i + 1];
if (j < m && s[i] == t[j]) cur[i] = min(cur[i], prv[i + 1]);
if (nxt[i] != -1) cur[i] = min(cur[i], cur[nxt[i]]);
}
}
cout << cur[0] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int people;
cin >> people;
int taxi[people], pizza[people], girls[people];
string names[people];
for (int i = 0; i < people; i++) {
taxi[i] = 0, pizza[i] = 0, girls[i] = 0;
int contacts;
cin >> contacts >> names[i];
for (int j = 0; j < contacts; j++) {
string number;
cin >> number;
enum nType { TAXI, PIZZA, GIRLS };
nType n;
number.erase(number.begin() + number.find('-'));
number.erase(number.begin() + number.find('-'));
for (int k = 1; k < number.size(); k++) {
if (k == 1) {
if (number[k] > number[k - 1]) {
n = GIRLS;
break;
} else if (number[k] == number[k - 1]) {
n = TAXI;
} else {
n = PIZZA;
}
} else {
if (n == TAXI) {
if (number[k] != number[k - 1]) {
n = GIRLS;
break;
}
} else {
if (number[k] >= number[k - 1]) {
n = GIRLS;
break;
}
}
}
}
if (n == TAXI)
taxi[i]++;
else if (n == PIZZA)
pizza[i]++;
else
girls[i]++;
}
}
vector<string> selected;
int max = 0;
for (int i = 0; i < people; i++) {
if (taxi[i] > max) {
max = taxi[i];
vector<string> newOne;
selected = newOne;
selected.push_back(names[i]);
} else if (taxi[i] == max) {
selected.push_back(names[i]);
}
}
cout << "If you want to call a taxi, you should call:";
for (int i = 0; i < selected.size(); i++) {
if (i == 0) {
cout << " " + selected.at(i);
} else {
cout << ", " + selected.at(i);
}
}
cout << ".\n";
cout << "If you want to order a pizza, you should call:";
vector<string> newOne;
selected = newOne;
max = 0;
for (int i = 0; i < people; i++) {
if (pizza[i] > max) {
max = pizza[i];
vector<string> newOne;
selected = newOne;
selected.push_back(names[i]);
} else if (pizza[i] == max) {
selected.push_back(names[i]);
}
}
for (int i = 0; i < selected.size(); i++) {
if (i == 0) {
cout << " " + selected.at(i);
} else {
cout << ", " + selected.at(i);
}
}
cout << ".\n";
selected = newOne;
max = 0;
cout << "If you want to go to a cafe with a wonderful girl, you should call:";
for (int i = 0; i < people; i++) {
if (girls[i] > max) {
max = girls[i];
vector<string> newOne;
selected = newOne;
selected.push_back(names[i]);
} else if (girls[i] == max) {
selected.push_back(names[i]);
}
}
for (int i = 0; i < selected.size(); i++) {
if (i == 0) {
cout << " " + selected.at(i);
} else {
cout << ", " + selected.at(i);
}
}
cout << ".";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
double m[N], b[N], k[N];
struct cht {
int ptr = 0, idx = 0;
bool bad(int l1, int l2, int l3) {
return 1.0 * (b[l3] - b[l1]) * (m[l1] - m[l2]) <=
1.0 * (b[l2] - b[l1]) * (m[l1] - m[l3]);
}
void add(double _m, double _b, int _k) {
m[idx] = _m, b[idx] = _b, k[idx] = _k;
idx++;
while (idx >= 3 && bad(idx - 3, idx - 2, idx - 1)) {
m[idx - 2] = m[idx - 1];
b[idx - 2] = b[idx - 1];
k[idx - 2] = k[idx - 1];
--idx;
}
}
double f(int i, double x) { return m[i] * x + b[i]; }
pair<double, int> query(double x) {
if (ptr >= idx) ptr = idx - 1;
while (ptr < idx - 1 && f(ptr, x) > f(ptr + 1, x)) ptr++;
return {f(ptr, x), k[ptr]};
}
void clear() { ptr = idx = 0; }
} ds;
double p[N], f[N], r[N];
pair<double, int> dp[N];
int n, K;
pair<double, int> get(double C) {
ds.clear();
ds.add(0, 0, 0);
for (int i = 1; i <= n; ++i) {
pair<double, int> tmp = ds.query(r[i]);
dp[i].first = tmp.first + f[i] + C;
dp[i].second = tmp.second + 1;
if (i < n) ds.add(-p[i], dp[i].first - f[i] + r[i] * p[i], dp[i].second);
}
return dp[n];
}
int main(int argc, char const *argv[]) {
scanf("%d %d", &n, &K);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
p[i] = p[i - 1] + x;
r[i] = r[i - 1] + 1.0 / (double)x;
f[i] = f[i - 1] + p[i] / x;
}
double lo = 0, hi = p[n] * 1e5 + 100;
int l = 0, r = n + 1;
double lval, rval;
while (fabs(hi - lo) > 1e-2) {
double mid = (lo + hi) / 2;
pair<double, int> tmp = get(mid);
if (tmp.second == K) {
double ans = tmp.first - K * mid;
printf("%.10f\n", ans);
return 0;
}
if (tmp.second < K)
hi = mid;
else
lo = mid;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void sol() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long w = 0;
for (auto el : s) {
if (el == 'W') {
w++;
}
}
vector<long long> rofl;
for (long long i = 0; i < n; i++) {
if (s[i] == 'W') {
rofl.push_back(i);
}
}
vector<pair<long long, long long>> kek;
for (long long i = 1; i < (long long)rofl.size(); i++) {
long long left = rofl[i - 1], right = rofl[i];
kek.emplace_back(right - left + 1, left);
}
sort(kek.begin(), kek.end());
for (auto pp : kek) {
long long len = pp.first, l = pp.second;
for (long long i = l; i < l + len; i++) {
if (k > 0 && s[i] == 'L') {
s[i] = 'W';
k--;
}
}
}
if (rofl.empty()) {
rofl.push_back(0);
}
for (long long i = rofl.back(); i < n; i++) {
if (k > 0 && s[i] == 'L') {
k--;
s[i] = 'W';
}
}
for (long long i = rofl.back(); i >= 0; i--) {
if (k > 0 && s[i] == 'L') {
k--;
s[i] = 'W';
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'W') {
if (i == 0 || s[i - 1] == 'L') {
ans++;
} else {
ans += 2;
}
}
}
cout << ans << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t = 1;
cin >> t;
while (t--) {
sol();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long Fib[100];
long long Path[100];
pair<long long, long long> get(long long N, long long X, bool f) {
assert(Fib[N] >= X);
if (N <= 0) {
return {0, 0};
}
if (N == 1) {
if (X == 1) {
return {0, 1};
} else {
return {1, 0};
}
}
pair<long long, long long> res = {};
if (X <= Fib[N - 1]) {
res = get(N - 1, X, true);
res.second = min(res.first, res.second) + 1ll + Path[N - 2];
if (f) {
res.second = min(res.second, res.first + 2ll);
res.first = min(res.first, res.second + 2ll);
}
} else {
res = get(N - 2, X - Fib[N - 1], false);
res.first++;
if (f) {
res.second = min(res.second, res.first + 2ll);
res.first = min(res.first, res.second + 2ll);
}
}
return res;
}
long long solve(long long N, long long X, long long Y) {
int f = 0;
if (N > 90) {
N = 90;
f = 1;
}
assert(Fib[N] >= X && Fib[N] >= Y);
if (X > Y) swap(X, Y);
while (true) {
if (Y <= Fib[N - 1]) {
f = 1;
N--;
} else if (X > Fib[N - 1]) {
if (f) {
f++;
}
X -= Fib[N - 1];
Y -= Fib[N - 1];
N -= 2;
} else {
break;
}
}
if (N == 1) {
return 1;
}
auto res1 = get(N - 1, X, true);
auto res2 = get(N - 2, Y - Fib[N - 1], false);
long long res = res2.first + 1ll + min(res1.first, res1.second);
if (f) {
res = min(res, res2.second + 2ll + res1.first + f - 1ll);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
Fib[0] = 1;
Path[0] = 0;
Fib[1] = 2;
Path[1] = 1;
for (int i = 2; i < 100; i++) {
Fib[i] = Fib[i - 1] + Fib[i - 2];
Path[i] = Path[i - 2] + 1;
}
long long T, N, X, Y;
cin >> T >> N;
while (T--) {
cin >> X >> Y;
cout << solve(N, X, Y) << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010, mod = 1e9 + 7;
int n, fa[N], f[N], g[N];
long long s[N];
void upd(int& x, int y) {
x += y;
if (x > mod) x -= mod;
}
long long gcd(long long x, long long y) { return (!y) ? x : gcd(y, x % y); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
for (int i = 2; i <= n; i++) scanf("%d", &fa[i]);
for (int i = n; i >= 2; i--) s[fa[i]] += s[i];
for (int i = n; i >= 1; i--)
if ((s[i] = s[1] / gcd(s[i], s[1])) <= n) f[s[i]]++;
for (int i = n; i >= 1; i--)
for (int j = i * 2; j <= n; j += i) f[j] += f[i];
int ans = 0;
g[1] = 1;
for (int i = 1; i <= n; i++)
if (f[i] == i) {
upd(ans, g[i]);
for (int j = i * 2; j <= n; j += i) upd(g[j], g[i]);
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
const long long MOD = 1e9 + 7;
const long long INF = LLONG_MAX;
const long long SIZE = 100000;
vector<long long> temp(200005), v;
long long merge(long long l, long long mid, long long r) {
long long cnt = 0;
long long k = l, i = l, j = mid;
while (i < mid && j <= r) {
if (v[i] < v[j]) {
temp[k] = v[i];
i++;
k++;
} else {
cnt += mid - i;
temp[k] = v[j];
j++;
k++;
}
}
while (i < mid) {
temp[k] = v[i];
i++;
k++;
}
while (j <= r) {
temp[j] = v[j];
j++;
k++;
}
for (long long i = l; i < (long long)r + 1; i++) v[i] = temp[i];
return cnt;
}
long long mergesort(long long l, long long r) {
long long cnt = 0;
if (r > l) {
long long mid = (l + r) / 2;
cnt += mergesort(l, mid);
cnt += mergesort(mid + 1, r);
cnt += merge(l, mid + 1, r);
}
return cnt;
}
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
map<char, queue<long long>> make_pair;
for (long long i = 0; i < (long long)n; i++) {
make_pair[s[i]].push(i + 1);
}
reverse(s.begin(), s.end());
v.clear();
for (long long i = 0; i < (long long)n; i++) {
v.push_back(make_pair[s[i]].front());
make_pair[s[i]].pop();
}
long long ans = mergesort(0, n - 1);
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a = n % 10;
if ((a != 0) && (a >= 5)) {
cout << n - (n % 10) + 10;
} else {
if ((a != 0) && (a < 5)) {
cout << n - (n % 10);
} else {
cout << n;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void fun() {}
long long int __gcda(long long int a, long long int b) {
if (b == 0) {
return a;
} else if (a == 0) {
return b;
} else if (a == b) {
return a;
} else if (b > a) {
return __gcda(a, b % a);
} else if (a > b) {
return __gcda(a % b, b);
}
return 0;
}
long long int dp[1 << 18][18];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
map<pair<long long int, long long int>, long long int> mapp;
fun();
long long int n, m, k;
cin >> n >> m >> k;
long long int arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
long long int a, b, c;
for (long long int i = 0; i < k; i++) {
cin >> a >> b >> c;
mapp[make_pair(a - 1, b - 1)] = c;
}
long long int q = 1 << n;
for (long long int i = 0; i < n; i++) {
dp[1 << i][i] = arr[i];
}
for (long long int mask = 1; mask < q; mask++) {
long long int currmask = mask;
for (long long int i = 0; i < n; i++) {
if (currmask & (1 << i)) {
for (long long int j = 0; j < n; j++) {
if ((currmask & (1 << j)) == 0) {
dp[mask | (1 << j)][j] =
max(dp[mask | (1 << j)][j],
dp[mask][i] + arr[j] + mapp[make_pair(i, j)]);
}
}
}
}
}
long long int ans = 0;
for (long long int i = 0; i < q; i++) {
long long int currmask = i;
long long int count = 0;
while (currmask) {
count += currmask & 1;
currmask >>= 1;
}
if (count != m) continue;
for (long long int j = 0; j < n; j++) {
ans = max(ans, dp[i][j]);
}
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct tr {
int a;
int b;
int c;
tr(int x, int y, int z) {
a = x;
b = y;
c = z;
}
};
struct fenwick_tree {
vector<int> tree;
fenwick_tree(int n) {
for (int i = 0; i < n; i++) tree.push_back(0);
}
void update(int i, int delta) {
for (; i < tree.size(); i |= i + 1) {
tree[i] += delta;
}
}
int prefix_sum(int i) {
if (i < 0) return 0;
if (i >= tree.size()) return prefix_sum(tree.size() - 1);
int ans = 0;
while (i >= 0) {
ans += tree[i];
i &= i + 1;
i--;
}
return ans;
}
};
int n;
vector<tr> H;
vector<tr> V;
long long answer;
bool operator<(tr X, tr Y) {
if (X.a != Y.a) return X.a < Y.a;
return X.b < Y.b;
}
void read() {
answer = 0;
cin >> n;
vector<tr> H1;
vector<tr> V1;
int x, y, z, t;
for (int i = 0; i < n; i++) {
cin >> x >> y >> z >> t;
if (x > z) swap(x, z);
if (y > t) swap(y, t);
if (y == t)
H1.push_back(tr(t, x, z));
else
V1.push_back(tr(x, y, t));
}
sort(H1.begin(), H1.end());
sort(V1.begin(), V1.end());
for (int i = 0; i < H1.size(); i++) {
if (i > 0 && H1[i].a == H[H.size() - 1].a &&
H1[i].b <= H[H.size() - 1].c + 1)
H[H.size() - 1].c = max(H[H.size() - 1].c, H1[i].c);
else
H.push_back(H1[i]);
}
for (int i = 0; i < V1.size(); i++) {
if (i > 0 && V1[i].a == V[V.size() - 1].a &&
V1[i].b <= V[V.size() - 1].c + 1)
V[V.size() - 1].c = max(V[V.size() - 1].c, V1[i].c);
else
V.push_back(V1[i]);
}
for (int i = 0; i < H.size(); i++) answer += (H[i].c - H[i].b + 1);
for (int i = 0; i < V.size(); i++) answer += (V[i].c - V[i].b + 1);
vector<tr> nums;
for (int i = 0; i < H.size(); i++) {
nums.push_back(tr(H[i].a, i, 0));
}
for (int i = 0; i < V.size(); i++) {
nums.push_back(tr(V[i].b, i, 1));
nums.push_back(tr(V[i].c, i, 2));
}
sort(nums.begin(), nums.end());
int crt = 0;
for (int i = 0; i < nums.size(); i++) {
if (i > 0 && nums[i - 1].a != nums[i].a) crt++;
if (nums[i].c == 0) H[nums[i].b].a = crt;
if (nums[i].c == 1) V[nums[i].b].b = crt;
if (nums[i].c == 2) V[nums[i].b].c = crt;
}
nums.clear();
for (int i = 0; i < H.size(); i++) {
nums.push_back(tr(H[i].b, i, 0));
nums.push_back(tr(H[i].c, i, 1));
}
for (int i = 0; i < V.size(); i++) {
nums.push_back(tr(V[i].a, i, 2));
}
sort(nums.begin(), nums.end());
crt = 0;
for (int i = 0; i < nums.size(); i++) {
if (i > 0 && nums[i - 1].a != nums[i].a) crt++;
if (nums[i].c == 0) H[nums[i].b].b = crt;
if (nums[i].c == 1) H[nums[i].b].c = crt;
if (nums[i].c == 2) V[nums[i].b].a = crt;
}
}
void solve() {
fenwick_tree T(400400);
vector<tr> K;
for (int i = 0; i < V.size(); i++) {
K.push_back(tr(V[i].b, V[i].a, 1));
K.push_back(tr(V[i].c + 1, V[i].a, -1));
}
sort(K.begin(), K.end());
int p = 0;
for (int i = 0; i < H.size(); i++) {
while (p < K.size() && K[p].a <= H[i].a) {
T.update(K[p].b, K[p].c);
p++;
}
answer -= (T.prefix_sum(H[i].c) - T.prefix_sum(H[i].b - 1));
}
cout << answer;
}
int main() {
read();
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
vector<int> ivec;
ivec.push_back(a);
ivec.push_back(b);
ivec.push_back(c);
sort(ivec.begin(), ivec.end());
a = ivec[0];
b = ivec[1];
c = ivec[2];
cout << (2 * a + b - 1) * b + (a + b - 1) * (c - 1 - b) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string a =
"012345678910111213141516171819202122232425262728293031323334353637383940"
"414243444546474849505152535455565758596061626364656667686970717273747576"
"777879808182838485868788899091929394959697989910010110210310410510610710"
"810911011111211311411511611711811912012112212312412512612712812913013113"
"213313413513613713813914014114214314414514614714814915015115215315415515"
"615715815916016116216316416516616716816917017117217317417517617717817918"
"018118218318418518618718818919019119219319419519619719819920020120220320"
"420520620720820921021121221321421521621721821922022122222322422522622722"
"822923023123223323423523623723823924024124224324424524624724824925025125"
"225325425525625725825926026126226326426526626726826927027127227327427527"
"627727827928028128228328428528628728828929029129229329429529629729829930"
"030130230330430530630730830931031131231331431531631731831932032132232332"
"432532632732832933033133233333433533633733833934034134234334434534634734"
"834935035135235335435535635735835936036136236336436536636736836937037137"
"237337437537637737837938038138238338438538638738838939039139239339439539"
"639739839940040140240340440540640740840941041141241341441541641741841942"
"042142242342442542642742842943043143243343443543643743843944044144244344"
"444544644744844945045145245345445545645745845946046146246346446546646746"
"846947047147247347447547647747847948048148248348448548648748848949049149"
"249349449549649749849950050150250350450550650750850951051151251351451551"
"651751851952052152252352452552652752852953053153253353453553653753853954"
"054154254354454554654754854955055155255355455555655755855956056156256356"
"456556656756856957057157257357457557657757857958058158258358458558658758"
"858959059159259359459559659759859960060160260360460560660760860961061161"
"261361461561661761861962062162262362462562662762862963063163263363463563"
"663763863964064164264364464564664764864965065165265365465565665765865966"
"066166266366466566666766866967067167267367467567667767867968068168268368"
"468568668768868969069169269369469569669769869970070170270370470570670770"
"870971071171271371471571671771871972072172272372472572672772872973073173"
"273373473573673773873974074174274374474574674774874975075175275375475575"
"675775875976076176276376476576676776876977077177277377477577677777877978"
"078178278378478578678778878979079179279379479579679779879980080180280380"
"480580680780880981081181281381481581681781881982082182282382482582682782"
"882983083183283383483583683783883984084184284384484584684784884985085185"
"285385485585685785885986086186286386486586686786886987087187287387487587"
"687787887988088188288388488588688788888989089189289389489589689789889990"
"090190290390490590690790890991091191291391491591691791891992092192292392"
"492592692792892993093193293393493593693793893994094194294394494594694794"
"894995095195295395495595695795895996096196296396496596696796896997097197"
"297397497597697797897998098198298398498598698798898999099199299399499599"
"699799899910000";
cin >> n;
cout << a[n] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long sum(long long r) { return ((r + 1ll) * r) / 2; }
long long sum(long long l, long long r) { return sum(r) - sum(l - 1); }
const long double eps = 1e-9;
long double ans(long double a, long double b) {
if (fabs(b) < eps) {
return 1;
}
if (fabs(a) < eps) {
return 0.5;
}
if (b == 0) {
return 0;
}
if (a >= 4 * b) {
return (a - b) / a;
}
return ((long double)(a * a) / 8.f + (long double)(b * a)) / (a * b * 2.f);
}
int main() {
int t;
cin >> t;
cout << fixed << setprecision(9);
while (t--) {
long double a, b;
cin >> a >> b;
cout << ans(a, b) << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
std::vector<std::pair<int, int> > a(n + 1);
for (int p = 0; p < n; p++) {
int x;
scanf("%d", &x);
a[p] = std::make_pair(x, p + 1);
}
sort(++a.begin(), a.end(), std::greater<std::pair<int, int> >());
int ind(0);
std::vector<std::pair<int, int> > comm;
for (int p = 0; p < n; p++) {
for (int q = ind + 1; q <= ind + a[p].first; q++) {
if (q >= n) {
break;
}
comm.push_back(std::make_pair(a[p].second, a[q].second));
}
ind += a[p].first;
if (ind <= p) {
break;
}
}
if (comm.size() < n - 1) {
puts("-1");
} else {
printf("%d\n", n - 1);
for (int p = 0; p < comm.size(); p++) {
printf("%d %d\n", comm[p].first, comm[p].second);
}
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.