solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long result = 0;
void check(long long a, long long b, long long c, long long n) {
if (a <= 0) return;
if (b <= 0) return;
if (c <= 0) return;
if (a > b) return;
if (b > c) return;
long long inc = 0;
if (a == b && b == c)
inc = 1;
else if (a == b || b == c)
inc = 3;
else
inc = 6;
if (a * a * a + b * b * b + c * c * c + n ==
(a + b + c) * (a + b + c) * (a + b + c))
result += inc;
}
int main() {
long long n;
cin >> n;
if (n % 3 != 0) {
cout << "0";
return 0;
}
n /= 3;
for (long long x = 1; x * x * x <= n; x++)
if (n % x == 0) {
long long t = n / x;
for (long long a = 1; a <= x / 2; a++) {
long long b = x - a;
long long D = (a + b) * (a + b) - 4 * (a * b - t);
if (D < 0) continue;
long long q = (long long)sqrt(D);
if (q * q != D) continue;
if (D == 0) {
long long c = (-(a + b)) / 2;
check(a, b, c, n * 3);
} else {
long long c = (-(a + b) + q) / 2;
check(a, b, c, n * 3);
c = (-(a + b) - q) / 2;
check(a, b, c, n * 3);
}
}
}
cout << result;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int hoge, foo, bar, t, m, n;
int mapp[505][505];
int fla[505][505];
int main() {
memset(fla, 0, sizeof(fla));
int x, y, x1, y1;
scanf("%d%d%d%d", &x, &y, &x1, &y1);
char s[100006];
scanf("%s", s);
int num = 0;
n = strlen(s);
for (int i = 0; i < n; i++) {
if (fla[x1][y1] == 0) {
printf("1 ");
fla[x1][y1] = 1;
num++;
} else {
printf("0 ");
}
if (s[i] == 'U') {
if (x1 - 1 > 0) {
x1 -= 1;
}
} else if (s[i] == 'D') {
if (x1 + 1 <= x) {
x1 += 1;
}
} else if (s[i] == 'R') {
if (y1 + 1 <= y) {
y1 += 1;
}
} else if (s[i] == 'L') {
if (y1 - 1 > 0) {
y1 -= 1;
}
}
}
printf("%d\n", x * y - num);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool d = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') d = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return d ? x : -x;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar('0' + x % 10);
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void writep(long long x) {
write(x);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 2e5 + 5;
int a[N];
long long sum[N], cnt[N];
vector<long long> v[N];
long long dfs(int u) {
long long mx = 0;
sum[u] = a[u];
for (auto k : v[u]) {
mx = max(mx, dfs(k));
sum[u] += sum[k];
cnt[u] += cnt[k];
}
if (!v[u].size()) cnt[u] = 1;
return max(mx, (sum[u] + cnt[u] - 1) / cnt[u]);
}
int main() {
int n = read();
for (int i = (int)(2); i <= (int)(n); i++) v[read()].push_back(i);
for (int i = (int)(1); i <= (int)(n); i++) a[i] = read();
cout << dfs(1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j;
cin >> n;
vector<string> s(n);
for (i = 0; i < n; i++) {
cin >> s[i];
}
for (i = 0; i < n; i++) {
char x = s[i][0];
for (j = 0; j < s[i].length() / 2; j++) {
if (s[i][j] != s[i][s[i].length() - j - 1]) {
cout << s[i] << endl;
break;
}
if (s[i][j] != x) {
char y = x;
s[i][0] = s[i][j];
s[i][j] = y;
cout << s[i] << endl;
break;
}
}
if (j == (s[i].length() / 2) && s[i].length() % 2 != 0) {
if (x != s[i][j]) {
char y = x;
s[i][0] = s[i][j];
s[i][j] = y;
cout << s[i] << endl;
} else
cout << "-1" << endl;
} else if (j == (s[i].length() / 2))
cout << "-1" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 2 * 1e5;
char tt[2003][2003];
int vis[107];
int size = 0;
map<char, int> mp;
map<char, int> mp1;
bool solve() {
for (auto i : mp1) {
if (mp[i.first] < i.second) {
return 0;
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, p;
cin >> s >> p;
bool ok = true;
long long cnt = 0, pl = p.length(), sl = s.length();
for (int i = 0; i < pl; i++) {
mp[p[i]]++;
}
for (int i = 0; i < pl; i++) {
if (s[i] == '?')
continue;
else
mp1[s[i]]++;
}
cnt += solve();
for (int i = 1; i <= sl - pl; i++) {
if (s[pl + i - 1] != '?') mp1[s[pl + i - 1]]++;
if (s[i - 1] != '?') mp1[s[i - 1]]--;
cnt += solve();
}
cout << cnt << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int nums[100];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &nums[i]);
}
int r = 0;
for (int i = 0; i < n; i++) {
int a = nums[i];
for (int j = i + 1; j < n; j++) {
a = a ^ nums[j];
int b = 0;
if (j < n - 1) b = nums[j] ^ nums[j + 1];
r = max(max(a, b), r);
}
r = max(max(a, r), nums[i]);
}
printf("%d\n", r);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
int main() {
int n, la, lb, a, b, ans = 0;
cin >> n;
la = lb = 0;
while (n--) {
cin >> a >> b;
ans += max(min(a, b) - max(la, lb), 0);
if (min(a, b) - max(la, lb) >= 0 && la != lb) ans++;
la = a;
lb = b;
}
cout << ans + 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
double tick() {
static clock_t oldt, newt = clock();
double diff = 1.0 * (newt - oldt) / CLOCKS_PER_SEC;
oldt = newt;
return diff;
}
template <typename T>
T gcd(T a, T b) {
return (b ? __gcd(a, b) : a);
}
template <typename T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
int mod_neg(int a, int b, int c) {
int res;
if (abs(a - b) < c)
res = a - b;
else
res = (a - b) % c;
return (res < 0 ? res + c : res);
}
template <typename T>
T extended_euclid(T a, T b, T &x, T &y) {
T xx = 0, yy = 1;
y = 0;
x = 1;
while (b) {
T q = a / b, t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
template <typename T>
T mod_inverse(T a, T n) {
T x, y, z = 0;
T d = extended_euclid(a, n, x, y);
return (d > 1 ? -1 : mod_neg(x, z, n));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N;
cin >> N;
long long int arr[N];
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
stack<long long int> s;
long long int max = -1;
for (int i = 0; i < N; i++) {
while (!s.empty() && arr[i] > s.top()) {
long long int now = s.top();
s.pop();
long long int temp1 = now ^ arr[i];
if (temp1 > max) max = temp1;
}
if (!s.empty()) {
long long int now = s.top();
long long int temp1 = now ^ arr[i];
if (temp1 > max) max = temp1;
}
s.push(arr[i]);
}
cout << max << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> b, s;
vector<pair<int, int> > b1, s1;
int main() {
ios_base::sync_with_stdio(0);
int n, ss;
cin >> n >> ss;
char com;
int d, p;
for (int i = 0; i < n; ++i) {
cin >> com >> d >> p;
if (com == 'S')
s[d] += p;
else
b[d] += p;
}
for (auto i = b.begin(); i != b.end(); i++)
b1.push_back(make_pair(i->first, i->second));
for (auto i = s.begin(); i != s.end(); i++)
s1.push_back(make_pair(i->first, i->second));
if (ss < s1.size()) {
for (int i = ss - 1; i >= 0; --i) {
cout << "S " << s1[i].first << " " << s1[i].second << "\n";
}
} else {
for (int i = s1.size() - 1; i >= 0; --i) {
cout << "S " << s1[i].first << " " << s1[i].second << "\n";
}
}
if (ss < b1.size()) {
for (int i = b1.size() - 1; i >= b1.size() - ss; --i) {
cout << "B " << b1[i].first << " " << b1[i].second << "\n";
}
} else {
for (int i = b1.size() - 1; i >= 0; --i) {
cout << "B " << b1[i].first << " " << b1[i].second << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2005;
string s;
long long n, sum[10], fac[20], num[10], ans;
void DFS(long long x) {
if (x == 10) {
long long cnt = 0;
for (long long i = 0; i < 10; i++) cnt += num[i];
long long p = fac[cnt];
for (long long i = 0; i < 10; i++) p /= fac[num[i]];
if (num[0]) p -= (p * num[0] / cnt);
ans += p;
return;
}
for (long long i = 1; i <= sum[x]; i++) num[x] = i, DFS(x + 1);
if (num[x] == 0) DFS(x + 1);
}
signed main() {
ios::sync_with_stdio(false);
cin >> s;
n = s.length();
for (long long i = 0; i < n; i++) sum[s[i] - 48]++;
fac[0] = 1;
for (long long i = 1; i <= 19; i++) fac[i] = fac[i - 1] * i;
DFS(0);
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1510;
long long n;
vector<long long> al[N], s[N];
long long sz[N], x[N], y[N], p[N], res[N];
bool cmp(long long a, long long b) {
if (y[a] < y[b])
return true;
else if (y[a] == y[b])
return x[a] < x[b];
else
return false;
}
void dfs(long long v) {
sz[v] = 1;
for (int i = 0; i < al[v].size(); i++) {
long long u = al[v][i];
if (u != p[v]) {
p[u] = v;
dfs(u);
sz[v] += sz[u];
}
}
}
pair<int, int> center;
bool cmp2(int a, int b) {
return ((long long)(x[a] - center.first) * (y[b] - center.second) <
(long long)(y[a] - center.second) * (x[b] - center.first));
}
void answer(int u) {
sort(s[u].begin(), s[u].end(), cmp);
res[s[u][0]] = u;
center = {x[s[u][0]], y[s[u][0]]};
s[u].erase(s[u].begin());
sort(s[u].begin(), s[u].end(), cmp2);
int x = 0;
for (int i = 0; i < al[u].size(); i++) {
int v = al[u][i];
if (v != p[u]) {
for (int j = 0; j < sz[v]; j++) {
s[v].push_back(s[u][x]);
x++;
}
answer(v);
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
al[a].push_back(b);
al[b].push_back(a);
}
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
for (int i = 0; i < n; i++) s[0].push_back(i);
dfs(0);
answer(0);
for (int i = 0; i < n; i++) cout << res[i] + 1 << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x, a, b, s;
cin >> n >> x >> a >> b;
if (a > b) {
s = abs(b - 1) + abs(n - a);
} else {
s = abs(n - b) + abs(a - 1);
}
if (x >= s) {
cout << s + abs(a - b) << "\n";
} else {
cout << abs(a - b) + x << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int two[20];
double a[20][20], f[262144];
int main() {
int i, j, k, n;
scanf("%d", &n);
two[0] = 1;
for (i = 1; i <= n; ++i) two[i] = two[i - 1] << 1;
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) scanf("%lf", &a[i][j]);
f[1] = 1.0;
for (i = 2; i < two[n]; ++i)
for (j = 1; j <= n; ++j)
for (k = 1; k <= n; ++k)
if ((i & two[j - 1]) && (i & two[k - 1]))
f[i] = ((f[i]) > (f[i ^ two[j - 1]] * a[k][j] +
f[i ^ two[k - 1]] * a[j][k])
? (f[i])
: (f[i ^ two[j - 1]] * a[k][j] +
f[i ^ two[k - 1]] * a[j][k]));
printf("%.7lf\n", f[two[n] - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a[100000], sum = 0, count = 0;
cin >> n;
cin >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n, greater<int>());
for (int i = 0; i < n; ++i) {
sum += a[i];
count++;
if (sum >= m) {
break;
}
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> dp;
vector<long long> fac(22);
void fact() {
fac.clear();
fac[0] = 1;
fac[1] = 1;
for (long long i = 2; i < 22; i++) {
fac[i] = i * fac[i - 1];
}
}
vector<long long> fun(vector<long long> v) {
vector<long long> dif;
if (v.size() == 0) return {};
dif.push_back(v[0]);
for (long long i = 1; i < v.size(); i++) {
if (v[i] != v[i - 1]) dif.push_back(v[i]);
}
return dif;
}
void helper(vector<long long>& v, long long i, vector<long long> temp) {
if (i >= v.size()) {
if (fun(temp) == fun(v)) {
sort(temp.begin(), temp.end());
dp.push_back(temp);
return;
} else
return;
}
helper(v, i + 1, temp);
temp.push_back(v[i]);
helper(v, i + 1, temp);
return;
}
void solve() {
long long n;
cin >> n;
vector<long long> v;
long long temp = n;
while (temp) {
v.push_back(temp % 10);
temp /= 10;
}
sort(v.begin(), v.end());
dp.clear();
helper(v, 0, {});
long long res = 0;
vector<vector<long long>> test;
if (dp.size() == 0) {
cout << "0" << endl;
return;
}
sort(dp.begin(), dp.end());
test.push_back(dp[0]);
for (long long i = 1; i < dp.size(); i++) {
if (dp[i] != dp[i - 1]) test.push_back(dp[i]);
}
dp.clear();
dp = test;
test.clear();
for (long long i = 0; i < dp.size(); i++) {
vector<long long> temp = dp[i];
long long ans = 0;
map<long long, long long> m;
for (long long i = 0; i < temp.size(); i++) {
m[temp[i]]++;
}
if (temp[0] == 0) {
ans = (temp.size() - m[0]) * fac[temp.size() - 1];
} else {
ans = fac[temp.size()];
}
auto it = m.begin();
while (it != m.end()) {
ans /= fac[it->second];
it++;
}
res += ans;
}
cout << res << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fac.clear();
fact();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int K = 35;
long long A[40], B[40];
void addit(long long x, long long *a) {
for (int i = 0; i < (int)(K); i++)
if (x & (1LL << i)) ++a[i];
}
int main() {
int N, M;
while (2 == scanf("%d%d", &N, &M)) {
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
{
int a;
for (int i = 0; i < (int)(N); i++) {
scanf("%d", &a);
addit(a, A);
}
for (int i = 0; i < (int)(M); i++) {
scanf("%d", &a);
++B[a];
}
}
long long lb = 0, ub = M + 1;
while (ub - lb > 1) {
long long X = (lb + ub) / 2;
long long b[40];
{
long long x = X;
for (int i = 0; i < (int)(K); i++) {
b[i] = min(B[i], x);
x -= b[i];
}
}
long long a[40] = {};
for (int i = K - 1; i >= 0; --i) {
a[i] += A[i];
if (a[i] < b[i]) goto dmp;
a[i] -= b[i];
if (i > 0) a[i - 1] += a[i] * 2;
}
lb = X;
continue;
dmp:
ub = X;
}
printf("%d\n", (int)lb);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 9;
int n, a[MAX];
long double tree[(MAX << 2)], lazy[(MAX << 2)][2];
void Build(int low = 1, int high = n, int pos = 1) {
lazy[pos][0] = 1.0;
if (low == high) {
tree[pos] = a[low];
return;
}
int mid = ((low + high) >> 1);
Build(low, mid, (pos << 1));
Build(mid + 1, high, (pos << 1 | 1));
tree[pos] = tree[(pos << 1)] + tree[(pos << 1 | 1)];
}
void Push(int low, int high, int pos) {
tree[pos] *= lazy[pos][0];
if (low != high) {
lazy[(pos << 1)][0] *= lazy[pos][0];
lazy[(pos << 1 | 1)][0] *= lazy[pos][0];
lazy[(pos << 1)][1] *= lazy[pos][0];
lazy[(pos << 1 | 1)][1] *= lazy[pos][0];
}
lazy[pos][0] = 1.0;
tree[pos] += 1.0 * (high - low + 1) * lazy[pos][1];
if (low != high) {
lazy[(pos << 1)][1] += lazy[pos][1];
lazy[(pos << 1 | 1)][1] += lazy[pos][1];
}
lazy[pos][1] = 0;
}
void PushAll(int low = 1, int high = 1, int pos = 1) {
Push(low, high, pos);
if (low == high) {
return;
}
int mid = ((low + high) >> 1);
PushAll(low, mid, (pos << 1));
PushAll(mid + 1, high, (pos << 1 | 1));
tree[pos] = tree[(pos << 1)] + tree[(pos << 1 | 1)];
}
void Update(bool id, int L, int R, long double val, int low = 1, int high = n,
int pos = 1) {
if (low == 1 && high == n) {
PushAll();
}
Push(low, high, pos);
if (L > high || R < low) {
return;
}
if (L <= low && R >= high) {
if (!id)
lazy[pos][0] *= val;
else
lazy[pos][1] += val;
Push(low, high, pos);
return;
}
int mid = ((low + high) >> 1);
Update(id, L, R, val, low, mid, (pos << 1));
Update(id, L, R, val, mid + 1, high, (pos << 1 | 1));
tree[pos] = tree[(pos << 1)] + tree[(pos << 1 | 1)];
}
long double Query(int L, int R, int low = 1, int high = n, int pos = 1) {
if (low == 1 && high == n) {
PushAll();
}
Push(low, high, pos);
if (L > high || R < low) {
return 0;
}
if (L <= low && R >= high) {
return tree[pos];
}
int mid = ((low + high) >> 1);
return Query(L, R, low, mid, (pos << 1)) +
Query(L, R, mid + 1, high, (pos << 1 | 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
Build();
while (q--) {
int op;
cin >> op;
if (op == 1) {
int L1, R1, L2, R2;
cin >> L1 >> R1 >> L2 >> R2;
long double sum1 = Query(L1, R1);
long double sum2 = Query(L2, R2);
Update(0, L1, R1, (long double)(R1 - L1) / (long double)(R1 - L1 + 1));
Update(0, L2, R2, (long double)(R2 - L2) / (long double)(R2 - L2 + 1));
Update(1, L1, R1,
1.0 / (long double)(R1 - L1 + 1) * (long double)1.0 /
(long double)(R2 - L2 + 1) * sum2);
Update(1, L2, R2,
1.0 / (long double)(R2 - L2 + 1) * (long double)1.0 /
(long double)(R1 - L1 + 1) * sum1);
} else {
int L, R;
cin >> L >> R;
cout << setprecision(5) << Query(L, R) << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char MA[1001][1001];
bool MARC[1001][1001] = {};
int scc[1001][1001], lvl[1000001] = {};
int n, m, scnum = 0;
int bfs(int i, int j);
int main() {
int sum = 0;
vector<int> v;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", MA[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (MA[i][j] == '.' && MARC[i][j] == 0) {
lvl[scnum] = bfs(i, j);
scnum++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (MA[i][j] == '*') {
if (i - 1 >= 0 && MA[i - 1][j] == '.') {
sum += lvl[scc[i - 1][j]];
v.push_back(scc[i - 1][j]);
}
if (i + 1 < n && MA[i + 1][j] == '.' &&
find(v.begin(), v.end(), scc[i + 1][j]) == v.end()) {
sum += lvl[scc[i + 1][j]];
v.push_back(scc[i + 1][j]);
}
if (j - 1 >= 0 && MA[i][j - 1] == '.' &&
find(v.begin(), v.end(), scc[i][j - 1]) == v.end()) {
sum += lvl[scc[i][j - 1]];
v.push_back(scc[i][j - 1]);
}
if (j + 1 < m && MA[i][j + 1] == '.' &&
find(v.begin(), v.end(), scc[i][j + 1]) == v.end()) {
sum += lvl[scc[i][j + 1]];
v.push_back(scc[i][j + 1]);
}
sum++;
putchar((sum % 10) + '0');
sum = 0;
v.clear();
} else
putchar('.');
}
putchar('\n');
}
return 0;
}
int bfs(int i, int j) {
queue<pair<int, int> > fila;
int cont = 1;
pair<int, int> v;
MARC[i][j] = 1;
scc[i][j] = scnum;
fila.push(pair<int, int>(i, j));
while (!fila.empty()) {
v = fila.front();
if (v.first + 1 < n && MA[v.first + 1][v.second] == '.' &&
MARC[v.first + 1][v.second] == 0) {
cont++;
MARC[v.first + 1][v.second] = 1;
fila.push(pair<int, int>(v.first + 1, v.second));
scc[v.first + 1][v.second] = scnum;
}
if (v.first - 1 >= 0 && MA[v.first - 1][v.second] == '.' &&
MARC[v.first - 1][v.second] == 0) {
cont++;
MARC[v.first - 1][v.second] = 1;
fila.push(pair<int, int>(v.first - 1, v.second));
scc[v.first - 1][v.second] = scnum;
}
if (v.second + 1 < m && MA[v.first][v.second + 1] == '.' &&
MARC[v.first][v.second + 1] == 0) {
cont++;
MARC[v.first][v.second + 1] = 1;
fila.push(pair<int, int>(v.first, v.second + 1));
scc[v.first][v.second + 1] = scnum;
}
if (v.second - 1 >= 0 && MA[v.first][v.second - 1] == '.' &&
MARC[v.first][v.second - 1] == 0) {
cont++;
MARC[v.first][v.second - 1] = 1;
fila.push(pair<int, int>(v.first, v.second - 1));
scc[v.first][v.second - 1] = scnum;
}
fila.pop();
}
return cont;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1005];
vector<pair<int, int> > states;
int lst = 0;
pair<int, int> ant[1000 * 1000 + 5];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
states.push_back({n + 1, 0});
for (int i = 1; i <= n; i++) {
int cnt0 = n + 1 - a[i];
int cnt1 = a[i];
sort(states.begin(), states.end());
vector<pair<int, int> > n_states = {};
for (auto it : states) {
if (it.first == 1) {
n_states.push_back({1, ++lst});
if (cnt1 > cnt0) {
ant[lst] = {1, it.second};
cnt1--;
} else {
ant[lst] = {0, it.second};
cnt0--;
}
} else {
if (cnt0 == 0) {
n_states.push_back({it.first, ++lst});
ant[lst] = {1, it.second};
cnt1 -= it.first;
} else if (cnt1 == 0) {
n_states.push_back({it.first, ++lst});
ant[lst] = {0, it.second};
cnt0 -= it.first;
} else {
n_states.push_back({min(it.first - 1, cnt0), ++lst});
ant[lst] = {0, it.second};
int tmp = min(it.first - 1, cnt0);
cnt0 -= min(it.first - 1, cnt0);
n_states.push_back({it.first - tmp, ++lst});
ant[lst] = {1, it.second};
cnt1 -= it.first - tmp;
}
}
}
states = n_states;
}
printf("%d\n", n + 1);
for (auto it : states) {
int state = it.second;
vector<int> tmp;
while (state) {
tmp.push_back(ant[state].first);
state = ant[state].second;
}
reverse(tmp.begin(), tmp.end());
for (auto it : tmp) {
printf("%d", it);
}
printf("\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#define M 1100000000
#define Nmax 300005
using namespace std;
int q, n, k, a[Nmax], t[Nmax], st[Nmax], dr[Nmax];
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> q;
while(q--)
{
cin >> n >> k;
for(int i=1;i<=k;i++)
cin >> a[i];
for(int i=1;i<=k;i++)
cin >> t[i];
for(int i=1;i<=n;i++)
st[i]=dr[i]=M;
for(int i=1;i<=k;i++)
st[a[i]]=dr[a[i]]=t[i];
for(int i=2;i<=n;i++)
st[i]=min(st[i], st[i-1]+1);
for(int i=n-1;i>=1;i--)
dr[i]=min(dr[i], dr[i+1]+1);
for(int i=1;i<=n;i++)
cout << min(st[i], dr[i]) << ' ';
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int num[55], ch[55], sym[55], i, j, n, m, fix[4], ans[4], k;
map<int, int> Hash;
int main() {
cin >> n >> m;
string s;
for (i = 0; i < n; i++) {
cin >> s;
for (j = 0; j < m; j++) {
if (s[j] >= 48 && s[j] <= 57) {
fix[1] = 1;
num[i] = j;
break;
}
}
for (j = m - 1; j >= 0; j--) {
if (s[j] >= 48 && s[j] <= 57) {
fix[1] = 1;
num[i] = min(num[i], m - j);
break;
}
}
for (j = 0; j < m; j++) {
if (s[j] >= 35 && s[j] <= 42) {
fix[2] = 1;
sym[i] = j;
break;
}
}
for (j = m - 1; j >= 0; j--) {
if (s[j] >= 35 && s[j] <= 42) {
fix[2] = 1;
sym[i] = min(sym[i], m - j);
break;
}
}
for (j = 0; j < m; j++) {
if (s[j] >= 97) {
fix[3] = 1;
ch[i] = j;
break;
}
}
for (j = m - 1; j >= 0; j--) {
if (s[j] >= 97) {
fix[3] = 1;
ch[i] = min(ch[i], m - j);
break;
}
}
if (fix[1] == 0) {
num[i] = -1;
}
if (fix[2] == 0) {
sym[i] = -1;
}
if (fix[3] == 0) {
ch[i] = -1;
}
fix[1] = 0;
fix[2] = 0;
fix[3] = 0;
}
ans[1] = 1e6;
ans[2] = ans[1];
ans[3] = ans[2];
for (i = 0; i < n; i++) {
if (num[i] != -1) {
if (ans[1] > num[i]) {
ans[1] = num[i];
k = i;
}
}
}
Hash[k] = 1;
for (i = 0; i < n; i++) {
if (ch[i] != -1 && Hash[i] == 0) {
if (ans[2] > ch[i]) {
ans[2] = ch[i];
k = i;
}
}
}
Hash[k] = 1;
for (i = 0; i < n; i++) {
if (sym[i] != -1 && Hash[i] == 0) {
if (ans[3] > sym[i]) {
ans[3] = sym[i];
}
}
}
cout << ans[1] + ans[2] + ans[3];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int max_p2n = (1 << 20) + 5;
const int max_n = 20 + 5;
const double acc = (1.0e-6);
const double eps = (1.0e-12);
const double pi = 4.0 * atan(1.0);
bool leq(const double &a, const double &b) { return (a < b + eps); }
bool lt(const double &a, const double &b) { return (a + eps < b); }
bool eq(const double &a, const double &b) { return (abs(a - b) < eps); }
int n;
int L, R;
int x[max_n], y[max_n], a[max_n];
double fdist(const double &x1, const double &y1, const double &x2,
const double &y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
double f(int i, const double &l) {
if (y[i] == 0) {
double dxi = (double(x[i]));
if (leq(dxi, l)) return (double(R));
return min(dxi, (double(R)));
}
double xa = (double(x[i])), ya = (double(y[i]));
double xb = (double(l)), yb = 0.0;
double xab = xb - xa, yab = yb - ya;
double th = (double(a[i])) * pi / 180.0;
double xac = cos(th) * xab - sin(th) * yab,
yac = sin(th) * xab + cos(th) * yab;
double z = 0.0;
if (leq(z, yac)) return (double(R));
return min(xa + ya / abs(yac) * xac, (double(R)));
}
double dp[max_p2n];
int main() {
scanf("%d", &n);
scanf("%d", &L);
scanf("%d", &R);
if (L == R) {
printf("%.12f\n", (double(0)));
return 0;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &x[i]);
scanf("%d", &y[i]);
y[i] = abs(y[i]);
scanf("%d", &a[i]);
}
dp[0] = (double(L));
for (int mask = 1; mask < (1 << n); ++mask) {
dp[mask] = (double(L - 1));
for (int b = 0; b < n; ++b)
if ((mask >> b) % 2) {
double dR = (double(R));
if (eq(dp[mask - (1 << b)], dR)) {
dp[mask] = (double(R));
break;
}
dp[mask] = max(dp[mask], f(b, dp[mask - (1 << b)]));
}
dp[mask] = min(dp[mask], (double(R)));
}
printf("%.12f\n", dp[(1 << n) - 1] - (double(L)));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long u;
long long a[1000];
long long d[1000];
long long minn = -1e17;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
d[i] = minn;
}
for (int i = n; i >= 0; --i) {
for (int j = n; j >= 0; --j) {
if (j == 0) {
u = minn;
} else
u = d[j - 1];
d[j] = max(min(d[j] + a[i], 0LL), u);
}
}
while (m--) {
scanf("%lld", &u);
int k = lower_bound(d, d + n + 1, -u) - d;
cout << k << endl;
}
return 0;
}
| 7 |
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '"' << x << '"';}
void __print(const char *x) {cerr << '"' << x << '"';}
void __print(const string &x) {cerr << '"' << x << '"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]" << endl;}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define deb(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define deb(x...)
#endif
typedef long long int ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
#define ff first
#define ss second
#define pb push_back
#define MESSI ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define all(x) (x).begin(), (x).end()
#define rep(i,a,b) for(ll i=a ; i<b ; ++i)
#define VectorInput(v,n) for(ll i=0;i<n;i++)cin>>v[i];
#define VectorPrint(v) for(ll i=0;i<v.size();i++)cout<<v[i]<<" ";
#define line "\n"
#define YES "YES"
#define NO "NO"
#define Variable(x) ll x;cin>>x;
const ll MOD = 1e9 + 7;
const ll maxn = 1e6 + 4;
const ll INF = 1e18;
void answer()
{
ll k,n,m;cin>>k>>n>>m;
vll one(n);VectorInput(one,n);
vll two(m);VectorInput(two,m);
vll ans;
bool fuckedup=false;
ll oi=0,ti=0;
ll c=0;
ll curr=k;
while(c<n+m)
{
ll newo=(oi<n?one[oi]:-1);
ll newt=(ti<m?two[ti]:-1);
if(newo>curr && newt>curr)
{
fuckedup=true;
break;
}
if(newo==-1 && newt==-1)break;
if(newo==-1)
{
if(newt==0)
{
ti++;c++;curr++;
ans.pb(0);
}
else
{
if(newt>curr)
{
fuckedup=true;
break;
}
else
{
ti++;c++;
ans.pb(newt);
}
}
continue;
}
if(newt==-1)
{
if(newo==0)
{
oi++;c++;curr++;
ans.pb(0);
}
else
{
if(newo>curr)
{
fuckedup=true;
break;
}
else
{
oi++;c++;
ans.pb(newo);
}
}
continue;
}
if(newo==0)
{
oi++;c++;curr++;
ans.pb(0);
}
if(newt==0)
{
ti++;c++;curr++;
ans.pb(0);
}
if(newo<=curr && newo!=0 && newo!=-1)
{
oi++;c++;
ans.pb(newo);
}
if(newt<=curr && newt!=0 && newo!=-1)
{
ti++;c++;
ans.pb(newt);
}
}
if(fuckedup==true || ans.size()!=n+m){cout<<-1<<line;return;}
VectorPrint(ans);cout<<line;
}
int main()
{
MESSI
int t;cin>>t;
while(t--)answer();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> d;
long long points[10] = {25, 18, 15, 12, 10, 8, 6, 4, 2, 1};
struct foo {
long long places[100];
long long pnts;
string name;
foo() {
for (int i = 0; i < 100; i++) places[i] = 0;
pnts = 0;
name = "";
}
};
foo a[2000];
long long t, n;
string s;
bool cmp1(foo a, foo b) {
if (a.pnts != b.pnts) return a.pnts > b.pnts;
for (int i = 0; i < 100; i++)
if (a.places[i] != b.places[i]) return a.places[i] > b.places[i];
return a.name < b.name;
};
bool cmp2(foo a, foo b) {
if (a.places[0] != b.places[0]) return a.places[0] > b.places[0];
if (a.pnts != b.pnts) return a.pnts > b.pnts;
for (int i = 1; i < 100; i++)
if (a.places[i] != b.places[i]) return a.places[i] > b.places[i];
return a.name < b.name;
}
int main() {
cin >> t;
int l = 0;
for (int k = 0; k < t; k++) {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> s;
if (d.find(s) == d.end()) {
d[s] = l;
a[l].name = s;
a[l].pnts = 0;
l++;
}
a[d[s]].places[i]++;
if (i < 10) a[d[s]].pnts += points[i];
}
}
sort(a, a + l, cmp1);
cout << a[0].name << endl;
sort(a, a + l, cmp2);
cout << a[0].name << endl;
d.clear();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long tar[500005];
long long arr[500005];
int main() {
long long n;
cin >> n;
long long idx = 0;
map<long long, long long> mp;
arr[0] = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
long long mini;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
pq.push({arr[i], i});
}
while (!pq.empty()) {
mini = pq.top().first;
idx = pq.top().second;
pq.pop();
long long cnt = 0;
int i = idx, j = idx - 1;
if (mp[idx] > 0) continue;
for (i = idx; i <= n; i++) {
if (tar[i] != 0) {
cnt += tar[i];
i += (tar[i] - 1);
continue;
}
if (arr[i] != mini) break;
mp[i]++;
cnt++;
}
for (j = idx - 1; j >= 1; j--) {
if (tar[j] != 0) {
cnt += tar[j];
j -= tar[j];
j++;
continue;
}
if (arr[j] != mini) break;
mp[j]++;
cnt++;
}
if (cnt % 2 && cnt != n) {
cout << "NO";
return 0;
}
if (cnt % 2) break;
if (i - 1 >= 0) tar[i - 1] = cnt;
tar[j + 1] = cnt;
}
cout << "YES";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k;
cin >> k;
if (k <= 9) {
cout << k;
return 0;
}
k -= 9;
long long num = 90, d = 2;
while (k > num * d) {
k -= num * d;
num *= 10;
d++;
}
long long first = 10;
for (long long i = 2; i < d; i++) first *= 10;
k--;
first += k / d;
string digits = to_string(first);
cout << digits.at(k % d);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
struct node {
long long x;
int f;
} pt[500005];
long long fac[200005];
long long powdd[200005];
bool cmp(node a, node b) { return a.x < b.x; }
long long mod = 1e9 + 7;
long long powd(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b % 2 == 1) {
ans = ans * a % mod;
}
a = a * a % mod;
b /= 2;
}
return ans;
}
long long C(long long b, long long a) {
long long ans = 1;
if (a > b) return 0;
ans = (fac[b] * powdd[a] % mod) * powdd[b - a] % mod;
return ans;
}
int main() {
fac[0] = 1;
for (long long i = 1; i <= 200000; i++) fac[i] = fac[i - 1] * i % mod;
for (int i = 0; i <= 200000; i++) powdd[i] = powd(fac[i], mod - 2) % mod;
while (~scanf("%d%d", &n, &k)) {
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &pt[i * 2].x, &pt[i * 2 + 1].x);
pt[i * 2].f = 1;
pt[2 * i + 1].f = -1;
pt[i * 2 + 1].x++;
}
sort(pt, pt + (2 * n), cmp);
int ct = 0;
int pre = -(1e9 + 7);
long long ans = 0;
for (int i = 0; i < 2 * n; i++) {
if (i != 0) {
if (pt[i].x != pt[i - 1].x) {
ans = (ans + C(ct, k) * (pt[i].x - pre) % mod) % mod;
}
}
ct += pt[i].f;
pre = pt[i].x;
}
printf("%lld\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 2;
const long long inf = (long long)1000000 * 1000000000;
long long p[MAXN * 4];
long long minimum[MAXN * 4];
int n, q;
inline void maintain(int v) {
minimum[v] = min(minimum[2 * v + 1], minimum[2 * v + 2]);
}
inline void push(int v) {
if (p[v] == 0) return;
p[2 * v + 1] += p[v];
p[2 * v + 2] += p[v];
minimum[2 * v + 1] += p[v];
minimum[2 * v + 2] += p[v];
maintain(v);
p[v] = 0;
}
void update(int v, int tl, int tr, int l, int r, long long delta) {
if (l > r) return;
if (tl == l & tr == r) {
minimum[v] += delta;
p[v] += delta;
return;
}
int tm = (tl + tr) / 2;
push(v);
update(2 * v + 1, tl, tm, l, min(r, tm), delta);
update(2 * v + 2, tm + 1, tr, max(tm + 1, l), r, delta);
maintain(v);
}
long long getmin(int v, int tl, int tr, int l, int r) {
if (l > r) return inf;
if (tl == l && tr == r) return minimum[v];
int tm = (tl + tr) / 2;
push(v);
long long first = getmin(2 * v + 1, tl, tm, l, min(r, tm));
long long second = getmin(2 * v + 2, tm + 1, tr, max(l, tm + 1), r);
maintain(v);
return min(first, second);
}
struct edge {
int initial, terminal;
long long weight;
};
long long toroot[MAXN];
vector<struct edge> edges;
vector<int> g[MAXN];
int timer = -1;
int tin[MAXN];
int tout[MAXN];
void read() {
scanf("%d %d", &n, &q);
for (int i = 0; i < 2 * (n - 1); i++) {
int initial, terminal;
long long weight;
scanf("%d %d %lld", &initial, &terminal, &weight);
struct edge tmp;
tmp.initial = initial;
tmp.terminal = terminal;
tmp.weight = weight;
edges.push_back(tmp);
if (terminal != 1) g[initial].push_back(edges.size() - 1);
}
}
void dfs(int v, int p) {
tin[v] = ++timer;
for (auto index : g[v]) {
int to = edges[index].terminal;
if (to == p) continue;
dfs(to, v);
}
tout[v] = timer;
}
inline bool upper(int a, int b) {
return tin[a] <= tin[b] && tout[b] <= tout[a];
}
void filltree() {
for (auto it : edges) {
if (it.terminal == 1) {
update(0, 0, n - 1, tin[it.initial], tin[it.initial], it.weight);
toroot[it.initial] = it.weight;
} else
update(0, 0, n - 1, tin[it.terminal], tout[it.terminal], it.weight);
}
}
void updateedge(int index, long long newval) {
long long delta = newval - edges[index].weight;
edges[index].weight = newval;
int initial = edges[index].initial, terminal = edges[index].terminal;
if (terminal == 1) {
update(0, 0, n - 1, tin[initial], tin[initial], delta);
toroot[initial] = newval;
} else
update(0, 0, n - 1, tin[terminal], tout[terminal], delta);
}
inline long long shortestwaytoroot(int v) {
long long answer = getmin(0, 0, n - 1, tin[v], tout[v]);
answer -= (getmin(0, 0, n - 1, tin[v], tin[v]) - toroot[v]);
return answer;
}
inline long long shortestwayfromroot(int v) {
return getmin(0, 0, n - 1, tin[v], tin[v]) - toroot[v];
}
long long decide(int a, int b) {
if (upper(a, b)) return shortestwayfromroot(b) - shortestwayfromroot(a);
return shortestwaytoroot(a) + shortestwayfromroot(b);
}
int main() {
read();
dfs(1, 1);
filltree();
for (int i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int index;
long long weight;
scanf("%d %lld", &index, &weight);
updateedge(index - 1, weight);
}
if (type == 2) {
int u, v;
scanf("%d %d", &u, &v);
printf("%lld\n", decide(u, v));
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1E-9;
int cnt;
double a, b, m, vx, vy, vz, t, f;
double ansx, ansz;
int main() {
scanf("%lf%lf%lf", &a, &b, &m);
scanf("%lf%lf%lf", &vx, &vy, &vz);
t = -m / vy;
ansx = a / 2 + t * vx;
ansz = t * vz;
while (ansx < 0) ansx += a;
while (ansz < 0) ansz += b;
while (ansx + eps > a) ansx -= a;
while (ansz + eps > b) ansz -= b;
cnt = (int)(fabs(t / (b / vz)) + eps);
if (cnt % 2) ansz = b - ansz;
cnt = 0;
if (t + eps > fabs((a / 2) / vx)) {
cnt = 1;
t -= fabs(a / 2 / vx);
}
cnt += (int)(fabs(t / (a / vx)) + eps);
if (cnt % 2) ansx = a - ansx;
printf("%.10lf %.10lf\n", ansx, ansz);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unsigned char revMirrow(unsigned char c) {
char a = 0;
for (int _n(8), i(0); i < _n; i++)
if ((1 << i) & c) a |= 1 << (7 - i);
return a;
}
int main() {
char s[256];
cin.getline(s, 256);
int N = strlen(s);
unsigned char prev = 0;
for (int _n(N), i(0); i < _n; i++) {
unsigned char c = s[i];
unsigned char rev = revMirrow(c);
cout << (int(prev) - int(rev) + 512) % 256 << endl;
prev = rev;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int inf = 0x3f3f3f3f;
template <class T>
void show(T a, int n) {
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
cout << endl;
}
template <class T>
void show(T a, int r, int l) {
for (int i = 0; i < r; ++i) show(a[i], l);
cout << endl;
}
const int N = 100 + 11;
int main() {
long long n;
while (cin >> n) {
long long i = 1;
while (n % i == 0) {
i = i * 3;
}
long long ans = n / i + 1;
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, m = 0, t = 0;
char a[100], b[100], c[100];
scanf("%s", a);
for (j = 0; a[j] != '|'; j++)
;
for (k = 0; a[j + k + 1]; k++) b[k] = a[j + k + 1];
a[j] = b[k] = '\0';
scanf("%s", c);
for (n = 0; c[n]; n++)
;
if ((j + k + n) % 2 == 0) {
if (j <= k) {
if (k <= (j + k + n) / 2) {
for (i = j; i < (j + k + n) / 2; i++) a[i] = c[t++];
a[i] = '\0';
for (i = k; i < (j + k + n) / 2; i++) b[i] = c[t++];
b[i] = '\0';
} else
m = 1;
} else {
if (j <= (j + k + n) / 2) {
for (i = j; i < (j + k + n) / 2; i++) a[i] = c[t++];
a[i] = '\0';
for (i = k; i < (j + k + n) / 2; i++) b[i] = c[t++];
b[i] = '\0';
} else
m = 1;
}
} else
m = 1;
if (m)
printf("Impossible\n");
else
printf("%s|%s\n", a, b);
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long double PI = 3.141592653589793236L;
using namespace std;
void solve() {
int n, m, x, y;
cin >> n >> m >> x >> y;
cout << x << " " << y << "\n";
cout << x << " "
<< "1"
<< "\n";
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (i & 1) {
if (i == 1 && j == x) {
continue;
}
if (j == x && i == y) {
continue;
}
cout << j << " " << i << "\n";
} else {
if (i == 1 && (n - j + 1) == x) {
continue;
}
if ((n - j + 1) == x && i == y) {
continue;
}
cout << n - j + 1 << " " << i << "\n";
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int mod = 1e9 + 7;
const int M = 100005;
int n, m, s, e;
int a[M], b[M];
int dp[M][315];
vector<int> yo[M];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> s >> e;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
cin >> b[i];
yo[b[i]].push_back(i);
}
memset(dp, -1, sizeof dp);
int ses = 0;
dp[0][0] = 0;
for (int j = 1; j <= 305; j++) {
int bpos = inf;
for (int i = 1; i <= n; i++) {
if (dp[i - 1][j - 1] != -1) bpos = min(bpos, dp[i - 1][j - 1]);
if (i < j || bpos >= inf) continue;
int val = a[i], nxt;
auto it = upper_bound(yo[val].begin(), yo[val].end(), bpos);
if (it == yo[val].end())
nxt = -1;
else
nxt = *it;
dp[i][j] = nxt;
int cost = i + dp[i][j] + (j * e);
if (cost <= s && nxt != -1) ses = max(ses, j);
}
}
cout << ses << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const double PI = 2 * acos((double)0);
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
const int maxn = 200010;
int n, t, q;
int p[maxn];
int l[maxn];
int f[maxn];
double g[maxn];
double h[maxn];
set<pair<double, int> > st1, st2;
double ans;
void update() {
while (t && int((st1).size())) {
int u = st1.rbegin()->second;
double x = (double)p[u] * f[u] / (f[u] + l[u]);
ans -= x;
f[u]++;
double y = (double)p[u] * f[u] / (f[u] + l[u]);
ans += y;
if (st2.find(make_pair(h[u], u)) != st2.end()) {
st2.erase(make_pair(h[u], u));
}
h[u] = y - x;
st2.insert(make_pair(h[u], u));
st1.erase(make_pair(g[u], u));
if (f[u] + 1 <= l[u]) {
g[u] = (double)p[u] * (f[u] + 1) / (f[u] + l[u] + 1) -
(double)p[u] * f[u] / (f[u] + l[u]);
st1.insert(make_pair(g[u], u));
}
t--;
}
}
void solve() {
scanf("%d%d%d", &n, &t, &q);
for (int i = (0); i < (n); i++) scanf("%d", p + i);
for (int i = (0); i < (n); i++) {
scanf("%d", l + i);
g[i] = (double)p[i] / (l[i] + 1);
st1.insert(make_pair(g[i], i));
}
update();
while (q--) {
int op, u;
scanf("%d%d", &op, &u);
u--;
if (f[u]) {
ans -= (double)p[u] * f[u] / (f[u] + l[u]);
f[u]--;
t++;
}
if (st1.find(make_pair(g[u], u)) != st1.end()) {
st1.erase(make_pair(g[u], u));
}
if (st2.find(make_pair(h[u], u)) != st2.end()) {
st2.erase(make_pair(h[u], u));
}
int v = -1;
if (int((st2).size()) && st2.begin()->second != u) {
v = st2.begin()->second;
ans -= (double)p[v] * f[v] / (f[v] + l[v]);
f[v]--;
t++;
if (st1.find(make_pair(g[v], v)) != st1.end()) {
st1.erase(make_pair(g[v], v));
}
st2.erase(make_pair(h[v], v));
}
if (op == 1)
l[u]++;
else
l[u]--;
ans += (double)p[u] * f[u] / (f[u] + l[u]);
if (f[u] + 1 <= l[u]) {
g[u] = (double)p[u] * (f[u] + 1) / (f[u] + l[u] + 1) -
(double)p[u] * f[u] / (f[u] + l[u]);
st1.insert(make_pair(g[u], u));
}
if (f[u]) {
h[u] = (double)p[u] * ((double)f[u] / (f[u] + l[u]) -
(double)(f[u] - 1) / (f[u] + l[u] - 1));
st2.insert(make_pair(h[u], u));
}
if (~v) {
ans += (double)p[v] * f[v] / (f[v] + l[v]);
if (f[v] + 1 <= l[v]) {
g[v] = (double)p[v] * (f[v] + 1) / (f[v] + l[v] + 1) -
(double)p[v] * f[v] / (f[v] + l[v]);
st1.insert(make_pair(g[v], v));
}
if (f[v]) {
h[v] = (double)p[v] * ((double)f[v] / (f[v] + l[v]) -
(double)(f[v] - 1) / (f[v] + l[v] - 1));
st2.insert(make_pair(h[v], v));
}
}
update();
cout << fixed << setprecision(9) << ans << "\n";
}
}
int main() {
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, a[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
int have = 0, ans = 0;
for (int i = 0; i < n; i++) {
if (!a[i]) continue;
a[i] += have;
if (a[i]) ans++;
have += -a[i];
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int m[N], n, mi = N, k, a = 0, r = 0, to = 0, t;
int main() {
scanf("%d %d", &n, &k);
memset(m, 0, sizeof m);
for (int i = 0; i < n; i++) {
scanf("%d", &t);
m[t]++;
mi = min(mi, t);
}
for (int i = N - 1; i > mi; i--) {
r += m[i];
if (to + r > k) {
to = r;
a++;
continue;
}
to += r;
}
if (to > 0) a++;
printf("%d\n", a);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int r1, r2, c1, c2;
int Ans[233], Cnt = 0;
int main() {
bool flag1 = false, flag2 = false;
int x;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
printf("? %d %d %d %d\n", 1, i, n, i);
fflush(stdout);
scanf("%d", &x);
if (x % 2 == 1) {
if (flag1)
r2 = i;
else
flag1 = true, r1 = i;
}
}
for (int i = 1; i <= n; i++) {
printf("? %d %d %d %d\n", i, 1, i, n);
fflush(stdout);
scanf("%d", &x);
if (x % 2 == 1) {
if (flag2)
c2 = i;
else
flag2 = true, c1 = i;
}
}
if (flag1 && flag2) {
printf("? %d %d %d %d\n", c1, r1, c1, r1);
fflush(stdout);
scanf("%d", &x);
if (x == 1)
printf("! %d %d %d %d\n", c1, r1, c2, r2);
else
printf("! %d %d %d %d\n", c1, r2, c2, r1);
fflush(stdout);
return 0;
}
int l = 1, r = n, mid;
if (flag1) {
l = 1, r = n;
do {
mid = (l + r) / 2;
printf("? %d %d %d %d\n", l, r1, mid, r1);
fflush(stdout);
scanf("%d", &x);
if (x % 2 == 1)
r = mid;
else
l = mid + 1;
} while (l != r);
c1 = c2 = l;
} else {
l = 1, r = n;
do {
mid = (l + r) / 2;
printf("? %d %d %d %d\n", c1, l, c1, mid);
fflush(stdout);
scanf("%d", &x);
if (x % 2 == 1)
r = mid;
else
l = mid + 1;
} while (l != r);
r1 = r2 = l;
}
printf("! %d %d %d %d\n", c1, r1, c2, r2);
fflush(stdout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A[9][9], B[9], n;
for (int i = 0; i < 9; i++)
for (int j = 0; j < 9; j++) A[i][j] = (i * j) % 9;
cin >> n;
for (int i = 0; i < 9; i++) {
B[i] = n / 9;
if (i == 0) B[i]--;
if (n % 9 >= i) B[i]++;
}
long long res = 0;
for (int i = 0; i < 9; i++)
for (int j = 0; j < 9; j++) res += (long long)B[i] * B[j] * B[A[i][j]];
for (int i = 1; i <= n; i++) res -= (long long)floor(n / i);
cout << res << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << n - max(a + 1, n - b) + 1 << "\n";
}
| 1 |
#include <bits/stdc++.h>
const int mod1 = 998244353, mod2 = 1e9 + 7;
const int N = 2e5 + 5;
void solve() {
int n; std::cin >> n;
std::vector<int> b(n);
for (int i = 0; i < n; i++) {
std::cin >> b[i];
}
std::multiset<int> st;
st.insert(b[0]);
int ok = 1;
for (int i = 1; i < n; i++) {
if (b[i] > b[i - 1]) {
auto pos = st.upper_bound(b[i - 1]);
if (pos != st.end() && (*pos) < b[i]) {
ok = 0; break;
}
} else if (b[i] < b[i - 1]) {
auto pos = st.lower_bound(b[i - 1]);
if (pos != st.begin() && (*(--pos)) > b[i]) {
ok = 0; break;
}
}
st.insert(b[i]);
}
if (ok) {
std::cout << "YES\n";
} else {
std::cout << "NO\n";
}
}
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
int T = 1; std::cin >> T;
while (T--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void push(vector<long long> &v, long long x) {
v.push_back(x);
push_heap(v.begin(), v.end());
}
void pop(vector<long long> &v) {
pop_heap(v.begin(), v.end());
v.pop_back();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, k, p, a;
cin >> n >> m >> k >> p;
long long r[n], c[m];
for (int i = 0; i < n; i++) r[i] = 0;
for (int i = 0; i < m; i++) c[i] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a;
r[i] += a;
c[j] += a;
}
}
vector<long long> sr, sc;
for (int i = 0; i < n; i++) push(sr, r[i]);
for (int i = 0; i < m; i++) push(sc, c[i]);
long long tmp = 0, pr[k + 1], pc[k + 1];
for (int i = 0; i < k; i++) {
pr[i] = tmp;
tmp += sr[0];
push(sr, sr[0] - p * m);
pop(sr);
}
pr[k] = tmp;
tmp = 0;
for (int i = 0; i < k; i++) {
pc[i] = tmp;
tmp += sc[0];
push(sc, sc[0] - p * n);
pop(sc);
}
pc[k] = tmp;
long long res = pr[k];
for (int i = 0; i <= k; i++) {
tmp = pr[i] + pc[k - i] - i * (k - i) * p;
if (tmp > res) res = tmp;
}
cout << res << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAX_S = 500;
const int MAX_K = 10;
int n, m, k;
char s[MAX_S + 1];
struct data {
int cnt, dif;
};
bool operator<(data lhs, data rhs) {
if (lhs.cnt != rhs.cnt)
return lhs.cnt < rhs.cnt;
else
return lhs.dif > rhs.dif;
}
void refine(std::vector<data> &tar, std::vector<data> &src) {
tar.clear();
std::sort(src.begin(), src.end());
int max = -1;
for (data dat : src)
if (dat.dif > max) {
max = dat.dif;
tar.push_back(dat);
}
}
struct node {
int cnt;
std::vector<data> vec[MAX_K + 1];
node *ptr[10];
node() : cnt(), vec() {
for (int i = 0; i < 10; ++i) ptr[i] = nullptr;
}
void add(char *s, int m) {
cnt += m;
if (*s) {
if (ptr[*s - '0'] == nullptr) ptr[*s - '0'] = new node();
ptr[*s - '0']->add(s + 1, m);
}
}
void solve() {
for (int i = 0; i <= MAX_K; ++i) vec[i].push_back({0, 0});
for (node *p : ptr)
if (p != nullptr) {
p->solve();
std::vector<data> tmp[MAX_K + 1];
for (int i = 0; i <= MAX_K; ++i)
for (int j = 0; i + j <= MAX_K; ++j)
for (data u : vec[i])
for (data v : p->vec[j])
tmp[i + j].push_back({u.cnt + v.cnt, u.dif + v.dif});
for (int i = 0; i <= MAX_K; ++i) refine(vec[i], tmp[i]);
}
if (cnt == 0) return;
std::vector<data> tmp[MAX_K + 1];
for (int i = 0; i <= MAX_K; ++i)
for (data dat : vec[i]) {
tmp[i].push_back({dat.cnt + cnt - dat.dif, dat.dif});
if (i < MAX_K) tmp[i + 1].push_back({dat.cnt, cnt});
}
for (int i = 0; i <= MAX_K; ++i) refine(vec[i], tmp[i]);
}
} root;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%s%d", s, &m);
root.add(s, m);
}
root.cnt = 0;
root.solve();
printf("%d\n", root.vec[k].front().cnt);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005], b, c, d, e, f[5005][5005], g, h, i, j, k, l, m, n, p[5005],
q[5005], F[2][5005], mo;
int main() {
scanf("%d%d%d", &n, &m, &mo);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
p[0] = q[0] = 1;
for (i = 1; i <= 5000 && i <= m; i++)
p[i] = 1ll * p[i - 1] * (m - i + 1) % mo;
for (i = 1; i <= 5000 && i <= m; i++) q[i] = 1ll * q[i - 1] * i % mo;
f[1][1] = f[2][2] = 1;
for (i = 3; i <= 5000; i++)
for (j = 2; j <= i; j++) {
(f[i][j] += 1ll * f[i - 1][j] * (j - 1) % mo) %= mo;
(f[i][j] += f[i - 1][j - 1]) %= mo;
}
for (j = 1; j <= a[1] && j <= m; j++) F[1][j] = 1ll * f[a[1]][j] * p[j] % mo;
for (i = 2; i <= n; i++) {
for (j = 1, g = 0; j <= a[i - 1] && j <= m; j++)
(g += F[(i & 1) ^ 1][j]) %= mo;
for (j = 1; j <= a[i] && j <= m; j++) {
F[i & 1][j] = 1ll * g * f[a[i]][j] % mo * p[j] % mo;
if (j <= a[i - 1])
(F[i & 1][j] -=
1ll * F[(i & 1) ^ 1][j] * q[j] % mo * f[a[i]][j] % mo) %= mo;
}
}
for (i = 1; i <= a[n] && i <= m; i++) (h += F[n & 1][i]) %= mo;
(h += mo) %= mo;
printf("%d\n", h);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, od = 0, i, co;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 != 0) od += 1;
}
if (od == 0)
co = n;
else if (od > 0 && od % 2 == 0)
co = n - od;
else if (od == n)
co = n;
else
co = od;
cout << co << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline bool isvowel(char ch) {
ch = tolower(ch);
return (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' ||
ch == 'y');
}
inline bool isprime(int n) {
if (n < 2 || (n % 2 == 0 && n != 2)) return false;
for (int i = 3; i * i <= n; i += 2)
if (n % i == 0) return false;
return true;
}
const long long mod = 1e6 + 3;
long long binpow(long long a, long long b) {
if (!b) return 1;
if (b & 1) {
return binpow(a, b - 1) * a % mod;
} else {
long long c = binpow(a, b / 2);
return c * c % mod;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long n;
cin >> n;
if (!n)
cout << 1;
else
cout << binpow(3, n - 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, d, i, j, k, l, x;
cin >> n >> d;
vector<long long> v;
for (i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
reverse((v).begin(), (v).end());
for (i = 0; i < n; i++) {
v.push_back(v[i]);
}
vector<pair<long long, long long>> vs;
for (i = 0; i < v.size(); i++) {
vs.push_back({v[i], (v[i] * (v[i] + 1)) / 2LL});
}
for (i = 1; i < vs.size(); i++) {
vs[i].first += vs[i - 1].first;
vs[i].second += vs[i - 1].second;
}
long long ans = 0;
long long sz = vs.size();
for (i = 1; i < sz; i++) {
auto it = upper_bound((vs).begin(), (vs).end(),
make_pair(vs[i - 1].first + d, 0LL));
it = prev(it);
long long idx = it - vs.begin();
long long num = vs[idx].first - vs[i - 1].first;
long long diff = d - num;
long long tmp = vs[idx].second - vs[i - 1].second;
if (diff == 0) {
ans = max(ans, tmp);
continue;
}
if (diff > 0 && idx < sz - 1) {
long long st = v[idx + 1];
tmp += (diff * (2LL * st + 1 - diff)) / 2LL;
ans = max(ans, tmp);
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using pi = pair<int, int>;
using ll = long long int;
template <typename T1, typename T2, typename T3>
T1 modpow(T1 _a, T2 p, T3 mod) {
assert(p >= 0);
ll ret = 1, a = _a;
if (a < 0) {
a %= mod;
a += mod;
}
if (a >= mod) {
a %= mod;
}
for (; p > 0; p /= 2) {
if (p & 1) ret = ret * a % mod;
a = a * a % mod;
}
return ret;
}
constexpr int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
constexpr auto PI = 3.14159265358979323846L;
constexpr auto oo = numeric_limits<int>::max() / 2 - 2;
constexpr auto eps = 1e-6;
constexpr auto mod = 1000000007;
constexpr int mx_n = 100005;
int add[mx_n], rem[mx_n];
int a[mx_n];
int main() {
int n;
cin >> n;
for (int i = ((0)), _i = ((n)-1); i <= _i; ++i) cin >> a[i];
ll esum = 0;
ll nsum = 0;
for (int i = ((0)), _i = ((n)-1); i <= _i; ++i) {
nsum += 1ll * (a[i]) * (n - a[i] + 1);
}
for (int i = ((0)), _i = ((n - 1) - 1); i <= _i; ++i) {
int l = min(a[i], a[i + 1]);
int r = max(a[i], a[i + 1]);
esum += 1ll * l * (n - r + 1);
}
ll ans = nsum - esum;
;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
struct tri {
int d[3];
void init() { sort(d, d + 3); }
} S, T;
int main() {
int x, y;
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
S.d[0] = S.d[1] = S.d[2] = x;
T.d[0] = T.d[1] = T.d[2] = y;
int cnt = 0;
while (S.d[0] != y) {
int& a = S.d[0];
int sum = S.d[1] + S.d[2];
a = min(y, sum - 1);
S.init();
cnt++;
}
printf("%d\n", cnt);
}
| 4 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int maxn = 200200;
const int mod = 998244353;
inline long long pow(long long a, int b, int ans = 1) {
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) ans = ans * a % mod;
return ans;
}
inline long long inverse(int x) { return pow(x, mod - 2); }
struct T {
int x, y, id;
};
int n;
int to[maxn];
T node;
inline bool cmp(const T& x, const T& y) {
return (x.x - node.x) * (y.y - node.y) - (y.x - node.x) * (x.y - node.y) > 0;
}
inline void clear(std::vector<T>& v) { std::vector<T>().swap(v); }
inline void solve(std::vector<T>& v) {
if (v.empty()) return;
T* min = &v.back();
for (T& i : v)
if (i.x < min->x || (i.x == min->x && i.y < min->y)) min = &i;
node = *min;
std::swap(v.front(), *min);
sort(v.begin() + 1, v.end(), cmp);
int cnt = 0, can_pos = -1;
for (int i = 1; i < v.size(); ++i) {
if (((node.id > n) ^ (v[i].id > n)) && cnt == 0) {
if (can_pos == -1 || std::abs((can_pos * 2 - (int)v.size()) >
std::abs(i * 2 - (int)v.size()))) {
can_pos = i;
}
}
cnt += v[i].id > n ? 1 : -1;
}
std::vector<T> v0, v1;
to[node.id] = v[can_pos].id;
to[v[can_pos].id] = node.id;
if (can_pos << 1 < v.size()) {
for (int i = 1; i < can_pos; ++i) v0.push_back(v[i]);
solve(v0);
for (int i = can_pos + 1; i < v.size(); ++i) v1.push_back(v[i]);
clear(v0);
clear(v);
solve(v1);
} else {
for (int i = can_pos + 1; i < v.size(); ++i) v1.push_back(v[i]);
solve(v1);
for (int i = 1; i < can_pos; ++i) v0.push_back(v[i]);
clear(v1);
clear(v);
solve(v0);
}
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
std::vector<T> vc;
for (int i = (1), iend = (n + n); i <= iend; ++i) {
T x;
x.id = i;
cin >> x.x >> x.y;
vc.push_back(x);
}
solve(vc);
for (int i = (1), iend = (n); i <= iend; ++i) {
cout << to[i] - n << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, k;
cin >> n >> k;
if (n == 1 && k > 2)
cout << 0;
else if (n == 1 && k == 2)
cout << 1;
else if (k % n == 0) {
if (k / n == 2)
cout << n;
else
cout << 0;
} else if (k % n != 0) {
if (k / n == 2) {
long long int rem = k % n;
cout << n - rem;
} else
cout << 0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int comp[205];
int pre[205][205];
int main() {
memset(comp, 0, sizeof comp);
memset(pre, 0, sizeof pre);
int N;
cin >> N;
for (int i = 0; i < int(N); ++i) cin >> comp[i];
int start[3] = {-1, -1, -1};
for (int i = 0; i < int(N); ++i) {
int k;
cin >> k;
for (int j = 0; j < int(k); ++j) {
int t;
cin >> t;
t--;
pre[i][t] = 1;
}
if (!k) start[comp[i] - 1] = i;
}
int best = 99999;
for (int s = 0; s < int(3); ++s) {
if (start[s] == -1) continue;
for (int i = 0; i < int(N); ++i) {
pre[i][i] = 0;
pre[i][i] = accumulate(pre[i], pre[i] + N, 0);
}
queue<int> q[3];
int time = 0, curc = s;
q[s].push(start[s]);
while (q[0].size() || q[1].size() || q[2].size()) {
if (q[curc].size()) {
int top = q[curc].front();
q[curc].pop();
pre[top][top] = -1;
for (int i = 0; i < int(N); ++i) {
if (pre[i][top]) pre[i][i]--;
if (pre[i][i] == 0) pre[i][i] = -1, q[comp[i] - 1].push(i);
}
} else {
curc = (curc + 1) % 3;
time++;
}
}
best = min(best, time + N);
}
cout << best << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int p[1000005], x[1000005], y[1000005];
bool cmp(int a, int b) {
if (x[a] / 1000 == x[b] / 1000) return ((y[a] < y[b]) ^ ((x[a] / 1000) % 2));
return (x[a] < x[b]);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
p[i] = i;
}
sort(p, p + n, cmp);
for (int i = 0; i < n; i++) printf("%d ", p[i] + 1);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int x[100005];
int main() {
cin >> n;
if (n % 2) {
cout << 0 << endl;
return 0;
}
if (n % 4 == 0) k = -1;
cout << n / 4 + k << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 101234, INF = 10001;
int a[MN], cnt[MN], good[MN], mn[MN * 4], sm[MN * 4], add[MN * 4], n;
vector<int> vec = {-1};
int get2(int l, int r, int s = 0, int e = n, int v = 1) {
if (r <= s || e <= l) return 0;
if (l <= s && e <= r) return sm[v];
int mid = (s + e) / 2;
return get2(l, r, s, mid, v * 2) + get2(l, r, mid, e, v * 2 + 1);
}
void add2(int p, int val, int s = 0, int e = n, int v = 1) {
if (e - s == 1) {
sm[v] += val;
return;
}
int mid = (s + e) / 2;
if (p < mid)
add2(p, val, s, mid, v * 2);
else
add2(p, val, mid, e, v * 2 + 1);
sm[v] = sm[v * 2] + sm[v * 2 + 1];
}
void relax(int sv, int s, int e, int v) {
if (e - s == 1) {
if (good[s]) add2(s, -1);
int x = -mn[v] - sv + vec[cnt[s]];
while (vec[cnt[s]] < x) cnt[s]++;
if (vec[cnt[s]] == x)
add2(s, +1), good[s] = true;
else
good[s] = false;
mn[v] = vec[cnt[s]] - x - sv;
return;
}
sv += add[v];
int mid = (s + e) / 2;
if (mn[v * 2] + sv <= 0) relax(sv, s, mid, v * 2);
if (mn[v * 2 + 1] + sv <= 0) relax(sv, mid, e, v * 2 + 1);
mn[v] = min(mn[v * 2], mn[v * 2 + 1]) + add[v];
}
void add1(int l, int r, int val, int sv = 0, int s = 0, int e = n, int v = 1) {
if (r <= s || e <= l) return;
if (l <= s && e <= r) {
add[v] += val;
mn[v] += val;
relax(sv, s, e, v);
return;
}
int mid = (s + e) / 2;
add1(l, r, val, sv + add[v], s, mid, v * 2);
add1(l, r, val, sv + add[v], mid, e, v * 2 + 1);
mn[v] = min(mn[v * 2], mn[v * 2 + 1]) + add[v];
}
void build(int s = 0, int e = n, int v = 1) {
if (e - s == 1) {
int x = a[s];
while (vec[cnt[s]] < x) cnt[s]++;
if (vec[cnt[s]] == x) add2(s, +1), good[s] = true;
mn[v] = vec[cnt[s]] - x;
return;
}
int mid = (s + e) / 2;
build(s, mid, v * 2);
build(mid, e, v * 2 + 1);
mn[v] = min(mn[v * 2], mn[v * 2 + 1]);
}
bool luck(int x) {
return (!x) || ((x % 10 == 7 || x % 10 == 4) && luck(x / 10));
}
int main() {
for (int i = 1; i < INF; i++)
if (luck(i)) vec.push_back(i);
vec.push_back(INF);
int q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
build();
for (int i = 0; i < q; i++) {
string type;
cin >> type;
if (type == "add") {
int l, r, val;
cin >> l >> r >> val;
l--;
add1(l, r, -val);
} else {
int l, r;
cin >> l >> r;
l--;
cout << get2(l, r) << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int const mod = (1e9) + 7;
int const N = (1e5) + 5;
long long power(long long a, long long deg) {
long long res = 1;
while (deg) {
if (deg % 2 == 0) {
a = (a * a) % mod;
deg /= 2;
} else {
res = (res * a) % mod;
deg--;
}
}
return res;
}
int main() {
int k;
cin >> k;
int even = 1;
long long deg = 2;
for (int i = 0; i < k; ++i) {
long long a;
scanf("%I64d", &a);
even *= (a % 2 == 0 ? 0 : 1);
deg = (power(deg, a)) % mod;
}
deg = (deg * power(2, mod - 2)) % mod;
long long p = deg;
if (!even)
p = (p + 1) % mod;
else
p = (p - 1) % mod;
p = (p * power(3, mod - 2)) % mod;
long long q = deg;
cout << p << "/" << q;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
inline void chmax(int& x, int y) {
if (x < y) x = y;
}
inline void chmin(int& x, int y) {
if (x > y) x = y;
}
inline int LSB(int i) { return (i & -i); }
const int maxn = 1e5 + 5;
long long n, sl, s[maxn], a[maxn], b[maxn], d[maxn], pizza, res, A, B, av, bv,
ares, bres;
vector<pair<long long, int> > x, y;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> sl;
long long total = 0, subt = 0;
for (int i = 0; i < n; i++) {
cin >> s[i] >> a[i] >> b[i];
total += s[i];
d[i] = abs(a[i] - b[i]);
if (a[i] == b[i]) subt += s[i], ares += a[i] * s[i], bres += a[i] * s[i];
}
pizza = ceil(total * 1.0 / sl);
if (total <= sl) {
long long f = 0, se = 0;
for (int i = 0; i < n; i++) {
f += s[i] * a[i];
se += s[i] * b[i];
}
cout << max(f, se) << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (a[i] > b[i])
A += s[i], av += s[i] * a[i], x.push_back({d[i], i});
else if (b[i] > a[i])
B += s[i], bv += s[i] * b[i], y.push_back({d[i], i});
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
long long amt = 0;
amt = ceil(A * 1.0 / sl);
long long asub = B - (pizza - amt) * sl;
for (int i = 0; i < y.size(); i++) {
if (asub <= 0) break;
ares -= min(asub, s[y[i].second]) * y[i].first;
asub -= min(asub, s[y[i].second]);
}
amt = ceil(B * 1.0 / sl);
long long bsub = A - (pizza - amt) * sl;
for (int i = 0; i < x.size(); i++) {
if (bsub <= 0) break;
bres -= min(bsub, s[x[i].second]) * x[i].first;
bsub -= min(bsub, s[x[i].second]);
}
cout << max(bres + av + bv, ares + av + bv) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> caps, full;
int main() {
int w, l;
cin >> w >> l;
caps = vector<int>(w + 1, 0);
caps[w] = 2e9;
full = vector<int>(w + 1, 0);
full[0] = 2e9;
for (int i = 1; i < w; i++) cin >> caps[i];
int from = 0;
int to = 1;
while (from != w) {
;
if (to == from)
to++;
else if (to - from > l) {
;
from++;
} else if (full[to] == caps[to]) {
;
to++;
} else if (full[from] == 0) {
;
from++;
} else {
int k = min(full[from], caps[to] - full[to]);
full[from] -= k;
full[to] += k;
;
}
}
cout << full[w] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[1000100];
long long usum[1000100], dsum[1000100];
long long uqtd[1000100], dqtd[1000100];
int main() {
int n;
scanf("%d", &n);
scanf("%s", (s + 1));
for (int i = 1; i <= n; i++) {
usum[i] = (usum[i - 1] + uqtd[i - 1]);
if (s[i] == 'U') uqtd[i]++;
uqtd[i] += uqtd[i - 1];
}
for (int i = n; i >= 1; i--) {
dsum[i] = (dsum[i + 1] + dqtd[i + 1]);
if (s[i] == 'D') dqtd[i]++;
dqtd[i] += dqtd[i + 1];
}
for (int i = 1; i <= n; i++) {
if (i != 1) cout << " ";
long long qtdL = uqtd[i];
long long qtdR = dqtd[i];
long long ans = 0;
if (qtdL < qtdR || (s[i] == 'U' && qtdL == qtdR)) {
if (s[i] == 'D') qtdL++;
int lo = i + 1;
int hi = n + 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (dqtd[i] - dqtd[mid] < qtdL)
lo = mid + 1;
else
hi = mid;
}
long long perc = 2 * (dsum[i] - dsum[lo] - (lo - i) * (dqtd[lo]));
long long perc2 = 2 * usum[i];
ans = (perc2 + perc + i);
} else if (qtdR < qtdL || (s[i] == 'D' && qtdL == qtdR)) {
if (s[i] == 'U') qtdR++;
int lo = 0;
int hi = i - 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (uqtd[i] - uqtd[mid] > qtdR)
lo = mid + 1;
else
hi = mid;
}
long long perc = 2 * (usum[i] - usum[lo] - (i - lo) * (uqtd[lo]));
long long perc2 = 2 * dsum[i];
ans = (perc2 + perc + (n - i + 1));
}
cout << ans;
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> v[5];
long long p[60], h, q, frst, lst, rght, lft, c, ans, res;
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
p[0] = 1;
for (int i = 1; i <= 55; i++) p[i] = p[i - 1] * 2;
cin >> h >> q;
for (int k = 1, i; k <= q; k++) {
cin >> i >> lft >> rght >> ans;
v[ans].push_back(make_pair(lft * p[h - i], (rght + 1) * p[h - i] - 1));
}
frst = p[h - 1];
lst = p[h] - 1;
for (int i = 0; i < v[1].size(); i++) {
if (v[1][i].first > frst) frst = v[1][i].first;
if (v[1][i].second < lst) lst = v[1][i].second;
}
if (lst < frst) {
cout << "Game cheated!\n";
return 0;
}
sort(v[0].begin(), v[0].end());
lft = rght = -1;
for (int i = 0; i < v[0].size(); i++) {
if (v[0][i].first > rght) {
if (rght != -1) v[2].push_back(make_pair(lft, rght));
lft = v[0][i].first;
}
rght = max(rght, v[0][i].second);
}
if (rght != -1) v[2].push_back(make_pair(lft, rght));
c = lst - frst + 1;
for (int i = 0; i < v[2].size(); i++) {
rght = min(v[2][i].second, lst);
if (frst > rght) continue;
lft = max(v[2][i].first, frst);
if (lst < lft) break;
c -= rght - lft + 1;
if (lft > frst + 1) break;
if (lft == frst + 1) res = frst;
frst = rght + 1;
if (frst > lst) break;
}
if (frst == lst) res = frst;
if (c == 1)
cout << res << "\n";
else if (c == 0)
cout << "Game cheated!\n";
else
cout << "Data not sufficient!\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void Fast_IO() {
ios::sync_with_stdio(0);
cin.tie(0);
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long n, ans;
long long a[100001];
vector<vector<long long> > adj;
vector<map<long long, long long> > gcds;
void dfs(long long u, long long p) {
map<long long, long long> new_map;
for (auto x : gcds[u]) {
ans += ((gcd(x.first, a[u]) % 1000000007) * (x.second % 1000000007)) %
1000000007;
ans %= 1000000007;
new_map[gcd(x.first, a[u])] += x.second;
}
ans += a[u] % 1000000007;
ans %= 1000000007;
if (new_map.find(a[u]) == new_map.end())
new_map[a[u]] = 1;
else
new_map[a[u]]++;
for (auto v : adj[u])
if (v != p) {
gcds[v] = new_map;
dfs(v, u);
}
}
int main() {
Fast_IO();
cin >> n;
for (long long i = (long long)0; i <= (long long)n - 1; i++) cin >> a[i];
adj.resize(n);
gcds.resize(n);
for (long long _ = (long long)1; _ <= (long long)n - 1; _++) {
long long u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
ans = 0;
dfs(0, 0);
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long dp[705][3][705][3];
int p[705];
const long long MOD = 1e9 + 7;
void func(int l, int r) {
if (l == r - 1)
dp[l][0][r][1] = dp[l][0][r][2] = dp[l][1][r][0] = dp[l][2][r][0] = 1;
else if (l == p[r]) {
func(l + 1, r - 1);
for (int cl = 0; cl < 3; cl++)
for (int cr = 0; cr < 3; cr++) {
if (cr != 1)
dp[l][0][r][1] = (dp[l][0][r][1] + dp[l + 1][cl][r - 1][cr]) % MOD;
if (cr != 2)
dp[l][0][r][2] = (dp[l][0][r][2] + dp[l + 1][cl][r - 1][cr]) % MOD;
if (cl != 1)
dp[l][1][r][0] = (dp[l][1][r][0] + dp[l + 1][cl][r - 1][cr]) % MOD;
if (cl != 2)
dp[l][2][r][0] = (dp[l][2][r][0] + dp[l + 1][cl][r - 1][cr]) % MOD;
}
} else {
func(l, p[l]);
func(p[l] + 1, r);
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
for (int m = 0; m < 3; m++) {
if ((j == k) && (j != 0)) continue;
dp[l][i][r][m] =
(dp[l][i][r][m] + dp[l][i][p[l]][j] * dp[p[l] + 1][k][r][m]) %
MOD;
}
}
return;
}
int main() {
cin >> s;
stack<int> st;
int n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '(')
st.push(i);
else {
p[i] = st.top();
p[st.top()] = i;
st.pop();
}
}
func(0, n - 1);
long long ans = 0LL;
for (int cl = 0; cl < 3; cl++)
for (int cr = 0; cr < 3; cr++) ans = (ans + dp[0][cl][n - 1][cr]) % MOD;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (a && b) {
if (a >= b)
a %= b;
else
b %= a;
}
return a + b;
}
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
int getint() {
char c;
int ret = c - '0', sgn = 0;
while ((c = getchar()) && !(c >= '0' && c <= '9') && c != '-')
;
if (c == '-') sgn = 1, ret = 0;
while ((c = getchar()) && c >= '0' && c <= '9') ret = ret * 10 + c - '0';
if (sgn) ret = -ret;
return ret;
}
const int maxn = 1e5 + 10;
const int maxm = maxn * 2;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
int sz[maxn];
long long cost[maxn];
long long f[maxn], ft[maxn], f2[maxn], f1[maxn];
vector<pair<int, int> > g[maxn];
long long get(long long x, long long y) {
x %= mod, y %= mod;
x = ((x - y) % mod + mod) % mod;
return x;
}
void add(long long& x, long long y) {
x %= mod, y %= mod;
x = (x + y) % mod;
}
void dfs1(int u, int pa) {
int len = g[u].size();
sz[u] = 1;
for (int i = 0; i < len; i++) {
int v = g[u][i].first;
long long w = g[u][i].second;
if (v == pa) continue;
cost[v] = w;
dfs1(v, u);
sz[u] += sz[v];
ft[u] += (ft[v] + w * sz[v] % mod) % mod;
ft[u] %= mod;
if (ft[u] < 0) ft[u] += mod;
f[u] +=
((f[v] + w * w % mod * sz[v] % mod) % mod + w * 2 % mod * ft[v] % mod) %
mod;
f[u] %= mod;
}
}
int n;
void dfs2(int u, int pa) {
int len = g[u].size();
for (int i = 0; i < len; i++) {
int v = g[u][i].first;
long long w = g[u][i].second;
if (v == pa) continue;
long long temp = get(ft[u], sz[v] * w % mod) + (n - sz[v]) * w % mod;
temp %= mod;
long long temp2 = get(temp, ft[v]);
temp2 = get(temp2, (n - sz[v]) * w % mod);
f1[v] = temp2;
long long temp3 = f[v];
f[v] = ((f[u] - 1LL * sz[v] * w % mod * w % mod) % mod -
1LL * 2 * w % mod * ft[v] % mod) %
mod;
f[v] = (f[v] + mod) % mod;
f2[v] = get(f[v], temp3);
f[v] = (f[v] + 1LL * (n - sz[v]) * w % mod * w % mod +
2LL * w % mod * temp2 % mod) %
mod;
ft[v] = temp;
dfs2(v, u);
}
}
int deep[maxn], fa[25][maxn];
long long ds[maxn], sumdis[maxn], sumq[maxn];
void dfs(int u, int pa, int d) {
deep[u] = d;
fa[0][u] = pa;
int i;
int len = g[u].size();
sumdis[u] = ds[u], sumq[u] = ds[u] * ds[u] % mod;
for (int i = 0; i < len; i++) {
int v = g[u][i].first, w = g[u][i].second;
if (v == pa) continue;
ds[v] = ds[u] + w;
ds[v] %= mod;
dfs(v, u, d + 1);
add(sumdis[u], sumdis[v]);
add(sumq[u], sumq[v]);
}
}
void lca_init() {
for (int k = 0; k < 20; k++) {
for (int i = 1; i <= n; i++) {
if (fa[k][i] == -1)
fa[k + 1][i] = -1;
else
fa[k + 1][i] = fa[k][fa[k][i]];
}
}
}
int lca(int u, int v) {
if (deep[u] > deep[v]) swap(u, v);
for (int k = 0; k < 22; k++) {
if ((deep[v] - deep[u]) >> k & 1) {
v = fa[k][v];
}
}
if (u == v) return u;
for (int k = 21; k >= 0; k--) {
if (fa[k][u] != fa[k][v]) {
u = fa[k][u], v = fa[k][v];
}
}
return fa[0][v];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
g[u].push_back(make_pair(v, w));
g[v].push_back(make_pair(u, w));
}
memset(f, 0, sizeof(f));
f1[1] = f2[1] = 0;
dfs1(1, -1);
dfs2(1, -1);
ds[1] = sumdis[1] = sumq[1] = 0;
dfs(1, -1, 1);
lca_init();
int q;
cin >> q;
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
int la = lca(u, v);
long long ans = 0;
if (la != v) {
long long cnt = sz[v] - 1;
long long x = get(ds[u] + ds[v], 2 * ds[la]), y = x;
x = get(x, ds[v]);
long long temp =
(cnt * x % mod * x % mod + get(sumq[v], ds[v] * ds[v] % mod)) % mod +
2 * x % mod * get(sumdis[v], ds[v]) % mod;
temp %= mod;
add(temp, y * y % mod);
ans = temp;
} else {
long long cnt = n - sz[v];
long long x = get(ds[u], ds[v]);
long long ww = (x + cost[v]) % mod;
long long temp = (f2[v] + cnt * ww % mod * ww % mod) % mod +
ww * 2 % mod * f1[v] % mod;
temp = temp % mod;
ans = get(f[u], temp);
}
ans = get(ans, get(f[u], ans));
cout << ans << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int x[1000003];
int y[1000003];
int main() {
int a, b;
scanf("%d %d", &a, &b);
for (int i = 0; i < a; i++) scanf("%d", &x[i]);
for (int i = 0; i < b; i++) scanf("%d", &y[i]);
int p = 1, q = 1;
int pn = x[0], qn = y[0];
int ans = 0;
while (true) {
if (a < p || b < q) break;
if (pn > qn) {
qn += y[q];
q++;
} else if (pn == qn) {
ans++;
pn = x[p], qn = y[q];
p++, q++;
} else {
pn += x[p];
p++;
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, num, ans = 2005;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> num;
if (!(m % num)) ans = min(ans, m / num);
}
cout << ans << '\n';
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 1e6 + 10;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
int n, a[N], lz[N << 2], prv[N];
pair<int, int> seg[N << 2];
pair<int, int> Merge(pair<int, int> A, pair<int, int> B) {
if (A.first == B.first) return make_pair(A.first, A.second + B.second);
return min(A, B);
}
void build(int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
seg[v] = make_pair(tl, 1);
return;
}
int mid = (tl + tr) >> 1;
build(v << 1, tl, mid);
build(v << 1 | 1, mid + 1, tr);
seg[v] = Merge(seg[v << 1], seg[v << 1 | 1]);
}
void second(int v, int tl, int tr) {
if (tl == tr || lz[v] == 0) return;
seg[v << 1].first += lz[v];
seg[v << 1 | 1].first += lz[v];
lz[v << 1] += lz[v];
lz[v << 1 | 1] += lz[v];
lz[v] = 0;
}
void upd(int l, int r, int x, int v = 1, int tl = 1, int tr = n) {
second(v, tl, tr);
if (l > tr || r < tl || l > r) return;
if (l <= tl && tr <= r) {
lz[v] += x;
seg[v].first += x;
return;
}
int mid = (tl + tr) >> 1;
upd(l, r, x, v << 1, tl, mid);
upd(l, r, x, v << 1 | 1, mid + 1, tr);
seg[v] = Merge(seg[v << 1], seg[v << 1 | 1]);
}
pair<int, int> get(int l, int r, int v = 1, int tl = 1, int tr = n) {
second(v, tl, tr);
if (l > tr || r < tl) return make_pair(1e9, 0);
if (l <= tl && tr <= r) {
return seg[v];
}
int mid = (tl + tr) >> 1;
return Merge(get(l, r, v << 1, tl, mid), get(l, r, v << 1 | 1, mid + 1, tr));
}
int main() {
scanf("%d", &n);
build();
deque<int> dq;
dq.push_back(0);
a[0] = 1e9;
long long tot = 0;
int last = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
last = max(last, prv[a[i]] + 1);
prv[a[i]] = i;
upd(1, n, -1);
upd(i, i, a[i]);
int r = i;
while ((int)dq.size() > 1 && a[dq.back()] <= a[i]) {
upd(dq.back() + 1, r, a[i] - a[r]);
r = dq.back();
dq.pop_back();
}
upd(dq.back() + 1, r, a[i] - a[r]);
dq.push_back(i);
pair<int, int> cu = get(last, i);
tot += (cu.first == 1 ? cu.second : 0);
}
printf("%lld", tot);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int T;
int N;
struct node {
int x, next;
};
struct node edge[200000 + 5];
int head[100000 + 5], edgenum;
void AddEdge(int x, int y) {
edge[edgenum].x = y;
edge[edgenum].next = head[x];
head[x] = edgenum++;
}
int g[100000 + 5];
long long dp[100000 + 5], Left[100000 + 5], fa[100000 + 5];
int start;
vector<long long> temp;
void dfs(int x) {
dp[x] = 0;
Left[x] = g[x] - 1;
long long cnt = 0;
for (int i = head[x]; i != -1; i = edge[i].next) {
int tx = edge[i].x;
if (fa[x] == tx) continue;
fa[tx] = x;
cnt++;
dfs(tx);
}
temp.clear();
for (int i = head[x]; i != -1; i = edge[i].next) {
int tx = edge[i].x;
if (fa[x] == tx) continue;
temp.push_back(dp[tx]);
cnt += Left[tx];
}
sort(temp.begin(), temp.end());
reverse(temp.begin(), temp.end());
for (int i = 0; i < (int)(temp).size() && temp[i] > 0 && Left[x] > 0; i++) {
dp[x] += temp[i] + 2;
Left[x]--;
cnt--;
}
dp[x] += min(Left[x], cnt) * 2;
Left[x] -= min(Left[x], cnt);
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &g[i]);
for (int i = 0, x, y; i + 1 < N; i++) {
scanf("%d %d", &x, &y);
AddEdge(x, y);
AddEdge(y, x);
}
scanf("%d", &start);
g[start]++;
dfs(start);
cout << dp[start] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int a[maxn], b[maxn];
int main() {
int n, m;
while (cin >> n >> m) {
int o1 = 0, o2 = 0, e1 = 0, e2 = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] % 2 == 0)
o1++;
else
e1++;
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
if (b[i] % 2 == 0)
o2++;
else
e2++;
}
cout << min(o1, e2) + min(o2, e1) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
int x, k, p;
double f[N][N];
int main() {
scanf("%d %d %d", &x, &k, &p);
for (int i = 0; i <= k; i++)
for (int j = x + i; !(j % 2); j >>= 1) f[0][i]++;
for (int i = 0; i < k; i++)
for (int j = 0; j <= k; j++) {
if (j) f[i + 1][j - 1] += (1 - p / 100.0) * f[i][j];
if (j * 2 <= k) f[i + 1][j * 2] += (p / 100.0) * (f[i][j] + 1);
}
printf("%.12lf", f[k][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000ll;
vector<pair<int, int> > v[110];
struct spaceship {
int x, a, f;
long long p;
} s[100010];
int n, m, p[110], f[110][110], x, y, id[100010], d, g, S, B, K, D[100010],
e[100010][2];
bool cmp(const int &a, const int &b) { return s[a].a < s[b].a; }
namespace MaxFlow {
struct node {
int to, next;
long long c;
} e[100010];
int hd[10010], cnt, n, cur[10010], dis[10010], q[10010], l, r, x;
void addedge(int x, int y, long long c) {
e[++cnt] = (node){y, hd[x], c}, hd[x] = cnt;
e[++cnt] = (node){x, hd[y], 0}, hd[y] = cnt;
}
bool bfs() {
for (int i = 1; i <= n; i++) dis[i] = 0;
dis[1] = 1, q[l = r = 1] = 1;
while (l <= r) {
x = q[l++];
for (int i = hd[x]; i; i = e[i].next)
if (e[i].c > 0 && !dis[e[i].to])
dis[e[i].to] = dis[x] + 1, q[++r] = e[i].to;
}
return (dis[n] > 0);
}
long long dinic(int x, long long f) {
if (x == n) return f;
for (int &i = cur[x]; i; i = e[i].next)
if (e[i].c > 0 && dis[e[i].to] == dis[x] + 1) {
long long nw = dinic(e[i].to, min(f, e[i].c));
if (nw > 0) return e[i].c -= nw, e[i ^ 1].c += nw, nw;
}
return 0;
}
long long solve() {
long long ans = 0, nw;
while (bfs()) {
for (int i = 1; i <= n; i++) cur[i] = hd[i];
while (nw = dinic(1, inf)) ans += nw;
}
return ans;
}
} // namespace MaxFlow
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = 100000;
for (int i = 1; i <= m; i++) scanf("%d%d", &x, &y), f[x][y] = f[y][x] = 1;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
scanf("%d%d%d", &S, &B, &K);
for (int i = 1; i <= S; i++)
id[i] = i, scanf("%d%d%d%d", &s[i].x, &s[i].a, &s[i].f, &s[i].p);
sort(id + 1, id + 1 + S, cmp);
for (int i = 1; i <= B; i++)
scanf("%d%d%d", &x, &d, &g), v[x].push_back(make_pair(d, g));
for (int i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end()), p[i] = 0;
for (int j = 1, sz = v[i].size(); j < sz; j++)
v[i][j].second = max(v[i][j].second, v[i][j - 1].second);
}
long long ans = 0;
for (int I = 1; I <= S; I++) {
int i = id[I];
long long ma = -inf;
for (int j = 1; j <= n; j++)
if (f[s[i].x][j] <= s[i].f) {
int sz = v[j].size();
if (!sz) continue;
while (p[j] < sz - 1 && v[j][p[j] + 1].first <= s[i].a) p[j]++;
if (v[j][p[j]].first <= s[i].a)
ma = max(ma, (long long)v[j][p[j]].second);
}
s[i].p = ma - s[i].p;
if (s[i].p > 0) ans += s[i].p;
}
MaxFlow::n = 2, MaxFlow::cnt = 1;
for (int i = 1; i <= K; i++)
scanf("%d%d", &e[i][0], &e[i][1]), D[e[i][0]]++, D[e[i][1]]++;
for (int i = 1; i <= S; i++)
if (D[i]) id[i] = (MaxFlow::n++);
for (int i = 1; i <= K; i++) MaxFlow::addedge(id[e[i][0]], id[e[i][1]], inf);
for (int i = 1; i <= S; i++)
if (D[i]) {
if (s[i].p > 0)
MaxFlow::addedge(1, id[i], s[i].p);
else
MaxFlow::addedge(id[i], MaxFlow::n, -s[i].p);
}
ans -= MaxFlow::solve();
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
using namespace std;
int v[5005];
int main() {
int t1;
cin >> t1;
for (int t = 1; t <= t1; t++) {
int n, d;
cin >> n >> d;
memset(v, 0, sizeof(v));
int l = 1, nr = n - 1;
v[0] = 1;
for (; nr >= v[l - 1] * 2; l++) {
v[l] = v[l - 1] * 2;
d -= v[l] * l;
nr -= v[l];
}
if (nr == 0)
l--;
else
d -= nr * l, v[l] = nr;
if (d < 0) {
cout << "NO\n";
continue;
}
int l2;
for (l2 = l; d > 0 && l >= 1; l--) {
if (v[l] == 1) continue;
if (l2 + 1 - l > d) {
v[l]--;
v[l + d]++;
d = 0;
break;
}
v[++l2] = 1;
d -= l2 - l;
v[l]--;
l++;
}
if (d == 0) {
cout << "YES\n";
queue<int> p[5005];
p[0].push(1);
p[0].push(1);
for (int i = 1, node = 2; i <= l2; i++)
if (v[i] > 0) {
cout << p[i - 1].front() << ' ';
p[i - 1].pop();
p[i].push(node);
p[i].push(node);
v[i--]--;
node++;
}
cout << '\n';
} else {
cout << "NO\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
int pset[MAXN], rk[MAXN], numS;
void init(int N) {
for (int i = (1); i <= (N); ++i) {
pset[i] = i;
rk[i] = 1;
}
numS = N;
}
int findSet(int i) { return (pset[i] == i) ? i : (pset[i] = findSet(pset[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
if (rk[findSet(i)] >= rk[findSet(j)]) {
rk[findSet(i)] += rk[findSet(j)];
rk[findSet(j)] = 0;
pset[findSet(j)] = findSet(i);
} else {
rk[findSet(j)] += rk[findSet(i)];
rk[findSet(i)] = 0;
pset[findSet(i)] = findSet(j);
}
--numS;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
map<int, int> s, occ;
int ans[n];
for (int i = (1); i <= (n); ++i) {
int x, y;
cin >> x >> y;
if (x == 0) ans[1] = y;
s[x] = y;
++occ[x];
++occ[y];
}
int ft = 0;
for (auto it : s) {
if (occ[it.first] == 1) {
ft = it.first;
break;
}
}
ans[0] = ft;
for (int i = (2); i <= (n - 1); ++i) ans[i] = s[ans[i - 2]];
for (int i = (0); i <= (n - 1); ++i) cout << ans[i] << " \n"[i == n - 1];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1e9 + 7;
void solve(int cnum) {
int n;
cin >> n;
vector<int> col(2 * n);
vector<vector<int>> pos(100);
for (int i = 0; i < 2 * n; ++i) {
int tmp;
cin >> tmp;
pos[tmp].push_back(i);
}
int dif0 = 0;
int dif1 = 0;
vector<int> filler;
for (int i = 0; i < 100; ++i) {
if ((int)pos[i].size() == 0) continue;
if ((int)pos[i].size() > 1) {
dif0++;
dif1++;
for (int j = 0; j + 1 < (int)pos[i].size(); j += 2) {
col[pos[i][j]] = 0;
col[pos[i][j + 1]] = 1;
}
if ((int)pos[i].size() % 2) filler.push_back(i);
} else {
if (dif0 > dif1) {
dif1++;
col[pos[i].back()] = 1;
} else {
dif0++;
col[pos[i].back()] = 0;
}
}
}
cout << dif0 * dif1 << "\n";
for (int i : filler) {
if (dif0 > dif1) {
col[pos[i].back()] = 1;
dif1++;
} else {
dif0++;
}
}
assert(dif1 == dif0);
for (int i : col) cout << i + 1 << " ";
cout << endl;
}
int main() {
int t;
int cnum = 1;
for (t = 1; t--; solve(cnum), cnum++)
;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void in() {}
int main() {
in();
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
x2 -= x1;
y2 -= y1;
x2 = abs(x2), y2 = abs(y2);
cout << max(x2, y2) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int T, N, M, a[7], cnt[100001], ans = 0x3fffffff;
pair<int, int> b[6 * 100001];
int get() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
int main() {
for (int i = 1; i <= 6; i++) a[i] = get();
N = get();
for (int i = 1; i <= N; i++) {
int x = get();
for (int j = 1; j <= 6; j++) b[(i - 1) * 6 + j] = make_pair(x - a[j], i);
}
sort(b + 1, b + N * 6 + 1);
int j = 0, tot = 0;
for (int i = 1; i <= N * 6; i++) {
while (j < N * 6 && tot < N)
cnt[b[++j].second]++, cnt[b[j].second] == 1 ? tot++ : 0;
if (tot == N) ans = min(ans, b[j].first - b[i].first);
cnt[b[i].second]--;
if (!cnt[b[i].second]) tot--;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, k;
cin >> n >> k;
if (n * n < k) {
cout << "-1";
return 0;
}
bool mat[n][n];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
mat[i][j] = false;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (mat[i][j] == true || mat[j][i] == true) continue;
if (i == j && k > 0) {
mat[i][j] = true;
k--;
} else if (k >= 2) {
mat[i][j] = true;
mat[j][i] = true;
k -= 2;
}
if (k == 0) break;
}
if (j != n) break;
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf("%d ", mat[i][j]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int compute(int len) { return ceil((double)n / len) + len; }
int main() {
cin >> n;
if (n == 2) {
cout << 2 << " " << 1 << endl;
return 0;
}
int min_val = INT_MAX;
int min_pos = 1;
for (int i = 1; i <= n; i++) {
int cur_val = compute(i);
if (cur_val < min_val) {
min_val = cur_val;
min_pos = i;
}
}
int t = n;
while (t > 0) {
for (int i = min_pos - 1; i >= 0; i--) {
if ((t - i) <= 0) continue;
cout << t - i << " ";
}
t -= min_pos;
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
const int N = 1010;
int nxt[N][N], num[N][N], n;
int find(int p, int x) {
return nxt[p][x] == x ? x : nxt[p][x] = find(p, nxt[p][x]);
}
int b[N], vis[N];
vector<pair<int, int> > G[N];
int col[N];
void dfs(int u, int c) {
col[u] = c;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i].first;
if (!~col[v]) dfs(v, c ^ G[u][i].second);
}
}
int main() {
rd(n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n + 1; ++j) nxt[i][j] = j;
}
for (int i = 1; i <= n; ++i) {
int m;
rd(m);
for (int j = 1; j <= m; ++j) rd(b[j]), vis[b[j]] = 1;
for (int j = 1; j <= m; ++j) {
int u = b[j];
for (int k = find(u, 1); k <= n; k = find(u, k + 1))
if (vis[k]) {
num[u][k]++;
if (num[u][k] == 3) nxt[u][k] = k + 1;
}
}
for (int j = 1; j <= m; ++j) vis[b[j]] = 0;
}
if (n == 2) {
printf("1 2\n");
return 0;
}
int f5 = 0;
for (int i = 1; i <= n && !f5; ++i)
for (int j = 1; j <= n && !f5; ++j)
if (num[i][j] == 0) f5 = 1;
if (!f5) {
int f4 = 0;
for (int i = 1; i <= n && !f4; ++i)
for (int j = 1; j <= n && !f4; ++j)
if (num[i][j] == 1) f4 = 1;
if (!f4) {
int f3 = 0;
for (int i = 1; i <= n && !f3; ++i)
for (int j = 1; j <= n && !f3; ++j)
if (num[i][j] == 2) f3 = 1;
if (!f3) {
for (int i = 2; i <= n; ++i) printf("1 %d\n", i);
return 0;
}
int u = 0, v = 0;
for (int i = 1; i <= n; ++i) {
int flg = 0;
for (int j = 1; j <= n; ++j)
if (num[i][j] == 2) {
flg = 1;
break;
}
if (!flg) {
if (!u)
u = i;
else {
v = i;
break;
}
}
}
int p = 1;
for (; p == u || p == v; ++p)
;
printf("%d %d\n", u, v);
printf("%d %d\n", p, u);
for (int i = 1; i <= n; ++i)
if (i != u && i != v && i != p) {
if (num[i][p] == 2)
printf("%d %d\n", v, i);
else
printf("%d %d\n", u, i);
}
return 0;
}
int rt = 1;
for (;; ++rt) {
int flg = 1;
for (int i = 1; i <= n; ++i)
if (i != rt && num[i][rt] < 3) {
flg = 0;
break;
}
if (flg) break;
}
vector<int> a, b;
for (int i = 1; i <= n; ++i)
if (i != rt) {
int mi = 3;
for (int j = 1; j <= n; ++j) mi = min(mi, num[i][j]);
if (mi == 2)
a.push_back(i);
else
b.push_back(i);
}
for (int i = 0; i < a.size(); ++i) printf("%d %d\n", a[i], rt);
for (int i = 0; i < b.size(); ++i)
for (int j = 0; j < a.size(); ++j)
if (num[b[i]][a[j]] == 3) {
printf("%d %d\n", b[i], a[j]);
break;
}
return 0;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (num[i][j] && num[i][j] < 3) {
if (num[i][j] == 1)
G[i].push_back(make_pair(j, 0)), G[j].push_back(make_pair(i, 0));
else
G[i].push_back(make_pair(j, 1)), G[j].push_back(make_pair(i, 1));
}
memset(col, -1, sizeof(col));
int tot = 0;
for (int i = 1; i <= n; ++i)
if (!~col[i]) dfs(i, tot), tot += 2;
int edgetot = 0;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
if (num[i][j] == 3 && (col[i] >> 1) == (col[j] >> 1) && col[i] != col[j])
printf("%d %d\n", i, j), edgetot++;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, col[N], mx[26], ans;
char s[N];
int main() {
cin >> n >> (s + 1);
for (int i = n; i; i--) {
col[i] = mx[s[i] - 'a'] + 1;
for (int j = s[i] - 'a' + 1; j < 26; j++) mx[j] = max(mx[j], col[i]);
ans = max(ans, col[i]);
}
if (ans > 2) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << col[i] - 1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n;
int a[N], L[N], R[N];
long long Max() {
long long S = 0;
stack<int> ST;
for (int i = 1; i <= n; ++i) {
while (ST.size() && a[i] > a[ST.top()]) ST.pop();
L[i] = ST.empty() ? 1 : ST.top() + 1;
ST.push(i);
}
while (ST.size()) ST.pop();
for (int i = n; i >= 1; --i) {
while (ST.size() && a[i] >= a[ST.top()]) ST.pop();
R[i] = ST.empty() ? n : ST.top() - 1;
ST.push(i);
}
for (int i = 1; i <= n; ++i)
S += (long long)a[i] * (i - L[i] + 1) * (R[i] - i + 1);
return S;
}
long long Min() {
long long S = 0;
stack<int> ST;
for (int i = 1; i <= n; ++i) {
while (ST.size() && a[i] < a[ST.top()]) ST.pop();
L[i] = ST.empty() ? 1 : ST.top() + 1;
ST.push(i);
}
while (ST.size()) ST.pop();
for (int i = n; i >= 1; --i) {
while (ST.size() && a[i] <= a[ST.top()]) ST.pop();
R[i] = ST.empty() ? n : ST.top() - 1;
ST.push(i);
}
for (int i = 1; i <= n; ++i)
S += (long long)a[i] * (i - L[i] + 1) * (R[i] - i + 1);
return S;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
printf("%I64d", Max() - Min());
return 0;
}
| 5 |
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize ("unroll-loops")
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<string>
#include<queue>
#include<map>
#include<stack>
#include<iostream>
#define INF 0x3f3f3f3f
#define lowbit(a) ((a)&-(a))
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
ll t,n,a[100005];
map<ll,ll>mp;
int main()
{
cin>>t;
while(t--)
{
cin>>n;
mp.clear();
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
ll sum=0;
for(int i=n;i>=1;i--)
{
sum+=i*mp[a[i]];
mp[a[i]]+=n-i+1;
}
cout<<sum<<endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1e17;
const double pi = acos(-1.0);
const int maxn = 1e6 + 5;
long long kase;
long long n, m, p, k, cnt, x, y;
int mypow(int a, int b, int p) {
int ans = 1;
for (a %= p; b; b >>= 1, a = a * a % p)
if (b & 1) ans = ans * a % p;
return ans;
}
void run() {
cin >> x >> y >> k;
long long tmp = 1;
int ans = 0;
cout << (y * k + k + x - 3) / (x - 1) + k << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin >> kase;
while (kase--) run();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
istream &operator>>(istream &cin, vector<T> &v) {
for (auto &i : v) cin >> i;
return cin;
}
template <typename T>
ostream &operator<<(ostream &cout, vector<T> &v) {
for (auto &i : v) cout << i << " ";
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> &v) {
cout << v.first << " " << v.second << " ";
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, vector<vector<T> > &v) {
for (auto &i : v) cout << i << '\n';
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, map<T1, T2> &v) {
for (auto &i : v) cout << i.first << " " << i.second << " ";
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, unordered_map<T1, T2> &v) {
for (auto &i : v) cout << i.first << " " << i.second << " ";
return cout;
}
void solution();
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solution();
return 0;
}
void solution() {
ll n;
cin >> n;
;
n -= 10;
if (n <= 0) {
cout << 0;
} else if (n == 1) {
cout << 4;
} else if (n < 10) {
cout << 4;
} else if (n == 10) {
cout << 15;
} else if (n == 11) {
cout << 4;
} else {
cout << 0;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, arr[100000], r, arr1[100000], z;
bool boo[100000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> r;
arr[i] = r;
}
for (int i = 0; i < n; i++) arr1[i] = arr[i];
reverse(arr1, arr1 + n);
z = arr1[0];
boo[0] = 1;
for (int i = 0; i < n; i++) {
if (arr1[i] > z) boo[i] = 1;
if (arr1[i] >= z)
z = arr1[i];
else
arr1[i] = z;
}
reverse(arr1, arr1 + n);
reverse(boo, boo + n);
for (int i = 0; i < n; i++) {
int k = arr1[i] - arr[i];
if (boo[i] == 1)
cout << 0 << endl;
else
cout << k + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int t;
cin >> t;
int a[1000 + 3], b[1000 + 3];
while (t--) {
int n, m;
string s;
cin >> n >> m >> s;
int pre = -1;
for (int i = 0; i < n; i++) if (s[i] == '1') {
if (pre != -1) if (((i - pre) & 1) == 0) s[i - (i - pre) / 2] = '*';
pre = i;
a[i] = i;
} else a[i] = pre;
pre = -1;
for (int i = s.size() - 1; ~i; i--) if (s[i] == '1') {
pre = i;
b[i] = pre;
} else b[i] = pre;
for (int i = 0; i < n; i++) {
pre = INT_MAX;
if (~a[i]) pre = i - a[i];
if (~b[i]) pre = min(pre, b[i] - i);
if (s[i] != '*' && pre <= m) cout << 1; else cout << '0';
}
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200500;
const int MAXK = 262144;
struct List {
set<int> comp_id;
} tree[2 * MAXK];
struct DSU_Node {
int par, rank;
int left, right;
};
vector<DSU_Node> dsu;
int n;
int tp[MAXN];
int x[MAXN], y[MAXN];
int curk;
int getPar(int x) {
if (dsu[x].par != x) {
dsu[x].par = getPar(dsu[x].par);
}
return dsu[x].par;
}
void link(int a, int b) {
if (dsu[a].rank >= dsu[b].rank) {
dsu[b].par = a;
} else {
dsu[a].par = b;
}
if (dsu[a].rank == dsu[b].rank) {
dsu[a].rank++;
}
int par = getPar(a);
dsu[par].left = min(dsu[a].left, dsu[b].left);
dsu[par].right = max(dsu[a].right, dsu[b].right);
}
bool isCover(int from, int to) {
return (dsu[from].left <= dsu[to].left && dsu[from].right >= dsu[to].right);
}
void updateCover(int from, int to, int id) {
from += curk - 1;
to += curk - 1;
while (from < to) {
if (from % 2 == 1) {
tree[from].comp_id.insert(id);
}
from = (from + 1) / 2;
if (to % 2 == 0) {
tree[to].comp_id.insert(id);
}
to = (to - 1) / 2;
}
if (from == to) {
tree[from].comp_id.insert(id);
}
}
void addVertices(int pnt, set<int> &res) {
pnt += curk - 1;
while (pnt != 0) {
res.insert(tree[pnt].comp_id.begin(), tree[pnt].comp_id.end());
tree[pnt].comp_id.clear();
pnt /= 2;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
vector<int> all_coord;
all_coord.reserve(50);
for (int i = 0; i < n; ++i) {
cin >> tp[i] >> x[i] >> y[i];
if (tp[i] == 1) {
all_coord.push_back(x[i]);
all_coord.push_back(y[i]);
}
}
sort(all_coord.begin(), all_coord.end());
all_coord.resize(unique(all_coord.begin(), all_coord.end()) -
all_coord.begin());
for (int i = 0; i < n; ++i) {
if (tp[i] == 1) {
x[i] = lower_bound(all_coord.begin(), all_coord.end(), x[i]) -
all_coord.begin() + 1;
y[i] = lower_bound(all_coord.begin(), all_coord.end(), y[i]) -
all_coord.begin() + 1;
}
}
dsu.push_back(DSU_Node());
curk = 2;
while (curk < n) {
curk *= 2;
}
for (int i = 1; i <= 2 * curk; ++i) {
tree[i].comp_id.clear();
}
int cnt_v = 0;
for (int i = 0; i < n; ++i) {
if (tp[i] == 1) {
cnt_v++;
DSU_Node tmp = {cnt_v, 1, x[i], y[i]};
dsu.push_back(tmp);
set<int> all_comps;
addVertices(x[i], all_comps);
addVertices(y[i], all_comps);
for (set<int>::const_iterator it = all_comps.begin();
it != all_comps.end(); ++it) {
int aa = getPar(cnt_v), bb = getPar(*it);
if (aa != bb) {
link(aa, bb);
}
}
int new_comp = getPar(cnt_v);
int left_bound = dsu[new_comp].left, right_bound = dsu[new_comp].right;
updateCover(left_bound + 1, right_bound - 1, new_comp);
} else {
int a_comp = getPar(x[i]), b_comp = getPar(y[i]);
if (isCover(b_comp, a_comp)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int tree[500005 << 2];
struct P {
int x, y, z;
int id;
} p[500005];
bool cmp1(P a, P b) {
if (a.x != b.x)
return a.x > b.x;
else if (a.y != b.y)
return a.y > b.y;
else
return a.z > b.z;
}
bool cmp2(P a, P b) { return a.y < b.y; }
void push_up(int rt) { tree[rt] = max(tree[rt << 1], tree[rt << 1 | 1]); }
void update(int pos, int x, int l, int r, int rt) {
if (l == r) {
tree[rt] = max(tree[rt], x);
return;
}
int m = (l + r) >> 1;
if (pos <= m)
update(pos, x, l, m, rt << 1);
else
update(pos, x, m + 1, r, rt << 1 | 1);
push_up(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && R >= r) return tree[rt];
int m = (l + r) >> 1;
int ans = 0;
if (L <= m) ans = max(ans, query(L, R, l, m, rt << 1));
if (R > m) ans = max(ans, query(L, R, m + 1, r, rt << 1 | 1));
return ans;
}
int main() {
int i, j, n, ans, cnt, pre;
while (~scanf("%d", &n)) {
ans = 0;
cnt = 1;
memset(tree, 0, sizeof(tree));
for (i = 0; i < n; i++) scanf("%d", &p[i].x), p[i].id = i;
for (i = 0; i < n; i++) scanf("%d", &p[i].y);
for (i = 0; i < n; i++) scanf("%d", &p[i].z);
sort(p, p + n, cmp2);
pre = p[0].y;
p[0].y = 1;
for (i = 1; i < n; i++)
if (p[i].y == pre) {
pre = p[i].y;
p[i].y = cnt;
} else {
pre = p[i].y;
p[i].y = ++cnt;
}
sort(p, p + n, cmp1);
for (i = 0; i < n;) {
for (j = i; j < n && p[i].x == p[j].x; j++) {
if (query(p[j].y + 1, cnt, 1, cnt, 1) > p[j].z) ans++;
}
for (; i < j; i++) update(p[i].y, p[i].z, 1, cnt, 1);
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3100;
int r, c, n, k, a[maxn], nn, pre[maxn], nex[maxn], cal[maxn];
long long ans, now;
struct node {
int x, y;
} p[maxn], q[maxn];
bool cmpy(node a, node b) { return a.y < b.y; }
bool cmp(int a, int b) { return q[a].x > q[b].x; }
int main() {
cin >> r >> c >> n >> k;
for (int i = 1; i <= n; i++) scanf("%d%d", &p[i].x, &p[i].y);
for (int i = 1; i <= r; i++) {
nn = 0;
now = 0;
memset(cal, 0, sizeof(cal));
for (int j = 1; j <= n; j++)
if (p[j].x >= i) q[++nn] = p[j], a[nn] = nn;
sort(q + 1, q + nn + 1, cmpy);
for (int j = 1; j <= nn - 1; j++) nex[j] = j + 1;
nex[nn] = 0;
for (int j = 2; j <= nn; j++) pre[j] = j - 1;
pre[1] = 0;
for (int j = k + 1; j <= nn; j++)
cal[j - 1] = (q[j].y - q[j - 1].y) * q[j - k].y, now += cal[j - 1];
if (nn >= k) cal[nn] = (c - q[nn].y + 1) * q[nn - k + 1].y;
now += cal[nn];
sort(a + 1, a + nn + 1, cmp);
int w = 1;
for (int j = r; j >= i; j--) {
ans += now;
while (w <= nn && q[a[w]].x == j) {
int t = a[w];
now -= cal[t];
cal[t] = 0;
int lt = pre[t], rt = nex[t];
if (lt) nex[lt] = rt;
if (rt) pre[rt] = lt;
if (lt)
rt = lt;
else
lt = rt;
int tt = 1;
for (; tt < k && pre[lt]; tt++, lt = pre[lt])
;
for (int l = 1; rt && l <= k; l++, rt = nex[rt], tt++) {
now -= cal[rt];
cal[rt] = 0;
if (tt < k) continue;
if (tt > k) lt = nex[lt], tt--;
if (nex[rt])
cal[rt] = (q[nex[rt]].y - q[rt].y) * q[lt].y;
else
cal[rt] = (c - q[rt].y + 1) * q[lt].y;
now += cal[rt];
}
w++;
}
}
}
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
string current = "hello";
int idx = 0;
for (int i = 0; i < current.size(); i++) {
bool flag = false;
char current_letter = current[i];
for (int j = idx; j < str.size(); j++) {
char comp_char = str[j];
if (current_letter == comp_char) {
idx = j + 1;
flag = true;
break;
}
}
if (flag == false) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int i, j, k, max = 0, n, b, a[3000], buy, sell, hand;
scanf("%d %d", &n, &b);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
max = b;
for (i = 0; i < n; i++) {
sell = 0;
buy = b / a[i];
hand = b % a[i];
for (j = i + 1; j < n; j++) {
sell = buy * a[j] + hand;
if (sell > max) max = sell;
}
}
printf("%d\n", max);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using vi = vector<int>;
const int maxn = 3000000;
ll a10[1000];
char st[maxn];
ll getnum(ll i, ll msk, int d) {
ll ans = 0;
ll x = i / a10[d];
for (int j = d - 1; j >= 0; --j)
if ((msk >> j) & 1) {
ans += x;
x = i / a10[j] % 10;
} else
x = x * 10 + i / a10[j] % 10;
ans += x;
return ans;
}
int getd(ll x) {
ll d;
for (d = 17; d >= 0; --d)
if (x / a10[d] > 0 || d == 0) break;
return d;
}
vector<char> s1, s2;
bool dfs1(ll x) {
int d = getd(x);
for (int msk = (1ll << d) - 1; msk >= 0; msk--) {
if (getnum(x, msk, d) < 10) {
s1.clear();
for (int i = d; i >= 0; --i) {
if ((msk >> i) & 1) s1.push_back('+');
s1.push_back(x / a10[i] % 10 + '0');
}
return true;
}
}
return false;
}
bool dfs2(ll x) {
int d = getd(x);
for (int msk = (1ll << d) - 1; msk >= 0; msk--) {
if (dfs1(getnum(x, msk, d))) {
s2.clear();
for (int i = d; i >= 0; --i) {
if ((msk >> i) & 1) s2.push_back('+');
s2.push_back(x / a10[i] % 10 + '0');
}
return true;
}
}
return false;
}
vector<int> cho;
mt19937 myrand(time(0));
int main() {
a10[0] = 1;
for (int i = 1; i <= 18; ++i) a10[i] = a10[i - 1] * 10;
int len;
vector<string> s;
s.clear();
ll sum = 0;
scanf("%d%s", &len, st);
for (int i = 0; i < len; ++i) {
s.push_back({st[i]});
sum += st[i] - '0';
}
while (!dfs2(sum)) {
cho.clear();
for (int i = 0; i < (int)s.size() - 1; ++i)
if (stoi(s[i]) != 0) cho.push_back(i);
int x = cho[myrand() % cho.size()];
sum -= stoi(s[x]);
sum -= stoi(s[x + 1]);
s[x] = s[x] + s[x + 1];
sum += stoi(s[x]);
s.erase(s.begin() + x + 1);
}
for (int i = 0; i < (int)s.size(); ++i) {
if (i != 0) printf("+");
printf("%s", s[i].c_str());
}
puts("");
for (auto i : s2) printf("%c", i);
puts("");
for (auto i : s1) printf("%c", i);
puts("");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using PR = pair<T, T>;
template <class T>
int lwb(V<T>& a, const T& b) {
return int(lower_bound(begin(a), end(a), b) - begin(a));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tt;
cin >> tt;
for (int ti = 0; ti < tt; ti++) {
int n;
cin >> n;
vector<int> a(n);
vector<int> c(2);
int first = -1;
int second = -1;
for (int i = (0); i < (n); ++i) {
cin >> a[i];
c[a[i]]++;
if (a[i] == 0 && first == -1 && c[1] % 2 == 0) first = i;
}
for (int i = (0); i < (n); ++i) {
if (i > 0 && i < n - 1 && a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1)
second = i;
}
if (c[1] == 0) {
cout << "YES" << endl << 0 << endl;
continue;
}
if (c[1] % 2 == 1 || c[0] == 0) {
cout << "NO" << endl;
continue;
}
vector<int> ans;
if (first == -1) {
if (second == -1) {
int last = -1;
for (int i = (0); i < (n); ++i) {
if (a[i] == 0) {
if (last == -1) last = i;
} else {
if (last != -1) {
if (i - last >= 3 && (i - last) % 2 == 1) {
for (int j = last; j < i - 2; j += 2) {
ans.push_back(j - 1);
a[j] = a[j + 1] = 1;
}
second = i - 1;
break;
}
}
last = -1;
}
}
}
if (second != -1) {
ans.push_back(second - 1);
a[second] = 0;
a[second - 1] = a[second + 1] = 0;
first = second - 1;
}
if (first == -1) {
cout << "NO" << endl;
continue;
}
}
if (first > 0) {
int i = first - 1;
while (i >= 0) {
if (a[i] == 1) {
if (i - 1 >= 0 && a[i - 1] == 1) {
ans.push_back(i - 1);
a[i] = a[i - 1] = 0;
i = i - 2;
} else {
if (i - 2 >= 0 && a[i - 2] == 1) {
ans.push_back(i - 2);
a[i] = a[i - 2] = 0;
i = i - 3;
} else {
ans.push_back(i - 2);
ans.push_back(i - 1);
a[i] = 0;
i = i - 2;
a[i] = 1;
}
}
} else {
i = i - 1;
}
}
}
if (first < n - 1) {
int i = first + 1;
while (i < n) {
if (a[i] == 1) {
if (i + 1 < n & a[i + 1] == 1) {
ans.push_back(i - 1);
a[i] = a[i + 1] = 0;
i += 2;
} else {
if (i + 2 < n && a[i + 2] == 1) {
ans.push_back(i);
a[i] = a[i + 2] = 0;
i = i + 3;
} else {
ans.push_back(i);
ans.push_back(i - 1);
a[i] = 0;
i = i + 2;
a[i] = 1;
}
}
} else {
i = i + 1;
}
}
}
cout << "YES" << endl;
cout << ans.size() << endl;
if (ans.size() > 0) {
for (int i = (0); i < (ans.size()); ++i) {
if (i > 0) cout << " ";
cout << ans[i] + 1;
}
cout << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using std::max;
using std::min;
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
__inline__ __attribute__((always_inline)) unsigned int rnd() {
static unsigned int seed = 416;
return seed += 0x71dad4bfu, seed ^= seed >> 5, seed += 0xc6f74d88u,
seed ^= seed << 17, seed += 0x25e6561u, seed ^= seed >> 13;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (!isdigit(ch)) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
f && (x = -x);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b,
const Args &...args) {
return a < b ? min(a, args...) : min(b, args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b,
const Args &...args) {
return a < b ? max(b, args...) : max(a, args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 100005;
int d, p;
int mod, C[15][15];
int k[15], a[15][15];
int cur = 201;
template <typename _Tp1, typename _Tp2>
__inline__ __attribute__((always_inline)) void add(_Tp1 &a, _Tp2 b) {
(a += b) >= mod && (a -= mod);
}
template <typename _Tp1, typename _Tp2>
__inline__ __attribute__((always_inline)) void sub(_Tp1 &a, _Tp2 b) {
(a -= b) < 0 && (a += mod);
}
long long ksm(long long a, long long b = p - 2) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % p;
a = a * a % p, b >>= 1;
}
return res;
}
void add(int a, int b, int c) { printf("+ %d %d %d\n", a, b, c); }
void powd(int a, int b) { printf("^ %d %d\n", a, b); }
void clear(int x) { powd(34, x); }
void mul(int a, int C) {
add(a, 34, 100);
for (int i = 100; i < 130; ++i) add(i, i, i + 1);
clear(a);
for (int i = 0; i <= 30; ++i)
if ((C >> i) & 1) add(100 + i, a, a);
}
void _div(int a, int C) { mul(a, ksm(C)); }
int pow2(int a) {
add(a, 34, 40);
for (int i = 40; i < 40 + d; ++i) add(i, 35, i + 1);
for (int i = 0; i <= d; ++i) powd(40 + i, 40 + i);
++cur;
clear(cur);
for (int i = 40; i <= 40 + d; ++i) mul(i, k[i - 40]), add(i, cur, cur);
return cur;
}
int main() {
read(d, p);
mod = p;
for (int i = 1; i <= 30; ++i) add(2 + i, 2 + i, 2 + i + 1);
int tar = p - 1;
for (int i = 0; i <= 30; ++i)
if ((tar >> i) & 1) add(3 + i, 34, 34);
for (int i = 0; i < 15; ++i)
for (int j = C[i][0] = 1; j <= i; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % p;
for (int i = 0; i <= d; ++i) {
for (int j = 0; j <= d; ++j) a[i][j] = 1ll * C[d][i] * ksm(j, d - i) % mod;
a[i][d + 1] = (i == 2);
}
for (int i = 0; i <= d; ++i) {
int pos = i;
for (int j = i; j <= d; ++j)
if (a[j][i]) {
pos = j;
break;
}
std::swap(a[i], a[pos]);
assert(a[i][i]);
long long inv = ksm(a[i][i]);
for (int j = i; j <= d + 1; ++j) a[i][j] = 1ll * a[i][j] * inv % mod;
for (int j = 0; j <= d; ++j) {
if (i == j) continue;
for (int k = d + 1; k >= i; --k)
sub(a[j][k], 1ll * a[j][i] * a[i][k] % mod);
}
}
for (int i = 0; i <= d; ++i) k[i] = a[i][d + 1];
add(1, 2, ++cur);
int xy2 = pow2(cur);
int x2 = pow2(1);
int y2 = pow2(2);
mul(x2, p - 1);
add(x2, xy2, xy2);
mul(y2, p - 1);
add(y2, xy2, xy2);
mul(xy2, (p + 1) >> 1);
printf("f %d\n", xy2);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long read() {
long long s = 0;
char c = getchar(), lc = '+';
while (c < '0' || '9' < c) lc = c, c = getchar();
while ('0' <= c && c <= '9') s = s * 10 + c - '0', c = getchar();
return lc == '-' ? -s : s;
}
void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10)
putchar(x + '0');
else {
write(x / 10);
putchar(x % 10 + '0');
}
}
void print(long long x, char c = '\n') {
write(x);
putchar(c);
}
void Print(long long x) {
if (x & 1) x++;
print(x / 2);
}
long long n, Max1 = 0, Max2 = 0, a[N];
void add(long long l, long long x) {
l--;
if (l == 0) Max1 += x;
if (l < 1 || n <= l) return;
if (a[l] > 0) Max2 -= a[l];
a[l] += x;
if (a[l] > 0) Max2 += a[l];
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read();
Max1 = a[1];
for (long long i = 1; i <= n; i++) a[i] = a[i + 1] - a[i];
for (long long i = 1; i < n; i++)
if (a[i] > 0) Max2 += a[i];
Print(Max1 + Max2);
long long m = read();
for (long long i = 1; i <= m; i++) {
long long l = read(), r = read(), x = read();
add(l, x);
add(r + 1, -x);
Print(Max1 + Max2);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
const int maxn = 2021;
int ldr[maxn];
int mark[maxn];
int dgt(int v) { return (ldr[v] == v) ? v : ldr[v] = dgt(ldr[v]); }
void uni(int u, int v) {
u = dgt(u);
v = dgt(v);
if (u == v) return;
ldr[v] = u;
}
inline long long int pw(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) {
res = (res * a) % mod;
}
a = (a * a) % mod;
b /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i <= n; i++) {
ldr[i] = i;
}
for (int i = 0, j = k - 1; j < n; i++, j++) {
for (int ii = i, jj = j; ii < jj; ii++, jj--) {
uni(ii, jj);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!mark[dgt(i)]) {
ans++;
mark[dgt(i)] = 1;
}
}
cout << pw(m, ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, c = 0;
cin >> n >> k;
vector<long long> a;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
a.push_back(x);
}
sort(a.begin(), a.end());
while (1) {
if (a.size() % 2 == 1) {
if (a[int(a.size() / 2)] == k) {
cout << c;
return 0;
} else {
a.push_back(k);
}
} else if (a.size() % 2 == 0) {
if (a[int(a.size() / 2) - 1] == k) {
cout << c;
return 0;
} else {
a.push_back(k);
}
}
sort(a.begin(), a.end());
c++;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int T = 1;
while (T--) {
string a, b;
cin >> a >> b;
if (a.compare(b) == 0)
cout << -1 << endl;
else if (a.size() > b.size())
cout << a.size() << endl;
else
cout << b.size() << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define flash ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define int long long
signed main()
{
flash
int t = 1;
cin>>t;
while (t--) {
int n;
cin>>n;
vector<int> arr(n);
for (int i = 0; i < n; ++i) {
cin>>arr[i];
}
for (int i = 1; i < n; ++i) {
int temp = arr[i-1]-(i-1)>=0?arr[i-1]-i+1:0;
if (temp>0) {
arr[i] += temp;
arr[i-1] = i;
}
}
bool flag = true;
for (int i = 0;i < n; ++i) {
if (arr[i]<i) {
flag = false;
break;
}
}
if (flag) {
cout<<"YES";
}
else {
cout<<"NO";
}
cout<<"\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double pi = acos(-1.0);
const double eps = 1e-12;
string a[] = {
"111111101010101111100101001111111", "100000100000000001010110001000001",
"101110100110110000011010001011101", "101110101011001001111101001011101",
"101110101100011000111100101011101", "100000101010101011010000101000001",
"111111101010101010101010101111111", "000000001111101111100111100000000",
"100010111100100001011110111111001", "110111001111111100100001000101100",
"011100111010000101000111010001010", "011110000110001111110101100000011",
"111111111111111000111001001011000", "111000010111010011010011010100100",
"101010100010110010110101010000010", "101100000101010001111101000000000",
"000010100011001101000111101011010", "101001001111101111000101010001110",
"101101111111000100100001110001000", "000010011000100110000011010000010",
"001101101001101110010010011011000", "011101011010001000111101010100110",
"111010100110011101001101000001110", "110001010010101111000101111111000",
"001000111011100001010110111110000", "000000001110010110100010100010110",
"111111101000101111000110101011010", "100000100111010101111100100011011",
"101110101001010000101000111111000", "101110100011010010010111111011010",
"101110100100011011110110101110000", "100000100110011001111100111100000",
"111111101101000101001101110010001"};
int x, y;
int main() {
cin >> x >> y;
cout << a[x][y];
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.