solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
int main() {
string s;
int k = 0;
while (getline(cin, s)) {
if (s[0] == '+')
mp[s.substr(1)]++;
else if (s[0] == '-')
mp.erase(s.substr(1));
else {
int j = s.size() - s.find(":") - 1;
k += j * mp.size();
}
}
cout << k;
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 1 << 20;
bool vis[MAXN];
int main() {
int n;
scanf("%d", &n);
std::vector<int> ans;
for (int i = 2; i <= n; i++) {
if (vis[i]) continue;
ans.push_back(1);
for (int j = 2; i * j <= n; j++) {
if (!vis[i * j]) ans.push_back(j);
vis[i * j] = true;
}
}
std::sort(ans.begin(), ans.end());
for (auto& t : ans) printf("%d ", t);
}
| 14 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
using namespace std;
long long n, A, cf, cm, m;
vector<pair<long long, long long> > v;
long long pre[100005];
long long suf[100005];
long long s;
long long maxi = 0, posm = -1, mini = 0;
long long solve(long long val, long long ind, long long rem) {
long long i;
for (i = n - 1; i >= ind; i--)
if (v[i].first < val) {
rem = rem - (val - v[i].first);
if (rem < 0) return 0;
} else
break;
if (rem >= 0) return 1;
return 0;
}
void check(long long ind, long long rem) {
long long val = ind * cf;
while (s < ind) s++;
while (s >= ind && s < n && (v[s].first * (n - s)) - suf[s] > rem) s++;
long long x;
if (s >= n)
x = A;
else {
x = (rem + suf[s]) / (n - s);
x = min(x, A);
}
val = val + (x * cm);
if (val > maxi) {
maxi = val;
posm = ind - 1;
mini = x;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> A >> cf >> cm >> m;
long long i, x;
for (i = 0; i < n; i++) {
cin >> x;
v.push_back(make_pair(x, i));
}
sort((v).begin(), (v).end());
reverse((v).begin(), (v).end());
suf[n - 1] = v[n - 1].first;
for (i = n - 2; i >= 0; i--) suf[i] = suf[i + 1] + v[i].first;
pre[0] = A - v[0].first;
for (i = 1; i < n; i++) pre[i] = pre[i - 1] + A - v[i].first;
check(0, m);
for (i = 0; i < n; i++)
if (pre[i] <= m)
check(i + 1, m - pre[i]);
else
break;
cout << maxi << "\n";
for (i = 0; i <= posm; i++) v[i].first = A;
for (; i < n; i++)
if (v[i].first < mini) v[i].first = mini;
long long ans[n + 5];
for (i = 0; i < n; i++) ans[v[i].second] = v[i].first;
for (i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[3] = {0};
int t;
int tmp[21];
for (int i = 1; i <= n; i++) cin >> tmp[i];
for (int i = 1; i <= n; i += 3) {
arr[0] += tmp[i];
}
for (int i = 2; i <= n; i += 3) {
arr[1] += tmp[i];
}
for (int i = 3; i <= n; i += 3) {
arr[2] += tmp[i];
}
if (max(arr[0], max(arr[1], arr[2])) == arr[0])
cout << "chest";
else if (max(arr[0], max(arr[1], arr[2])) == arr[1])
cout << "biceps";
else
cout << "back";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
long long s, x1, x2, t1, t2, p, d;
cin >> s >> x1 >> x2;
cin >> t1 >> t2;
cin >> p >> d;
long long a1, a2;
if (x2 > x1) {
if (d == 1) {
a2 = (x2 - x1) * t2;
if (p > x1) {
a1 = (s - p) + s + (x2);
a1 *= t1;
} else {
a1 = (x2 - p);
a1 *= t1;
}
} else {
a2 = (x2 - x1) * t2;
if (p > x1) {
a1 = p + x2;
a1 *= t1;
} else {
a1 = p + x2;
a1 *= t1;
}
}
} else if (x1 > x2) {
if (d == 1) {
a2 = (x1 - x2) * t2;
if (p > x1) {
a1 = (s - p) + (s - x2);
a1 *= t1;
} else {
a1 = (s - p) + (s - x2);
a1 *= t1;
}
} else {
a2 = (x1 - x2) * t2;
if (p >= x1) {
a1 = (p - x2);
a1 *= t1;
} else {
a1 = p + s + (s - x2);
a1 *= t1;
}
}
}
cout << min(a1, a2) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INFI = 2e9;
int N;
int Row, Col;
int compressed[2020 + 1][2020 + 1] = {
0,
};
bool isVisited[2020 + 1][2020 + 1] = {
false,
};
struct Lines {
pair<int, int> start;
pair<int, int> end;
Lines() {}
};
vector<Lines> lines;
int MAX(int a, int b) { return a > b ? a : b; }
int MIN(int a, int b) { return a < b ? a : b; }
vector<int> startRow;
vector<int> startCol;
vector<int> endRow;
vector<int> endCol;
vector<int> rows(2020);
int rows_size = 0;
vector<int> cols(2020);
int cols_size = 0;
int d_row[] = {-1, 0, 1, 0};
int d_col[] = {0, -1, 0, 1};
int determine_Direction(const char c) {
if (c == 'U')
return 0;
else if (c == 'L')
return 1;
else if (c == 'D')
return 2;
else
return 3;
}
void compress() {
sort(rows.begin(), rows.begin() + rows_size);
sort(cols.begin(), cols.begin() + cols_size);
rows.resize(unique(rows.begin(), rows.begin() + rows_size) - rows.begin());
cols.resize(unique(cols.begin(), cols.begin() + cols_size) - cols.begin());
Row = rows.size();
Col = cols.size();
for (int i = 0; i < N; i++) {
int sy = lower_bound(rows.begin(), rows.end(), startRow[i]) - rows.begin();
int sx = lower_bound(cols.begin(), cols.end(), startCol[i]) - cols.begin();
int ey = lower_bound(rows.begin(), rows.end(), endRow[i]) - rows.begin();
int ex = lower_bound(cols.begin(), cols.end(), endCol[i]) - cols.begin();
lines[i].start.first = sy;
lines[i].start.second = sx;
lines[i].end.first = ey;
lines[i].end.second = ex;
}
}
void DrawLine() {
for (int i = 0; i < N; i++) {
int sy = lines[i].start.first;
int sx = lines[i].start.second;
int ey = lines[i].end.first;
int ex = lines[i].end.second;
for (int r = sy; r <= ey - 1; r++)
for (int c = sx; c <= ex - 1; c++) compressed[r][c] = 1;
}
}
void BFS() {
queue<pair<int, int> > Q;
Q.push(make_pair(0, 0));
isVisited[0][0] = true;
compressed[0][0] = 2;
while (!Q.empty()) {
pair<int, int> current = Q.front();
Q.pop();
for (int direction = 0; direction < 4; direction++) {
int nextRow = current.first + d_row[direction];
int nextCol = current.second + d_col[direction];
if (nextRow < 0 || nextRow >= Row || nextCol < 0 || nextCol >= Col)
continue;
if (!isVisited[nextRow][nextCol] && compressed[nextRow][nextCol] == 0) {
isVisited[nextRow][nextCol] = true;
compressed[nextRow][nextCol] = 2;
Q.push(make_pair(nextRow, nextCol));
}
}
}
}
int main(int argc, char* argv[]) {
scanf("%d", &N);
startRow = vector<int>(N);
startCol = vector<int>(N);
endRow = vector<int>(N);
endCol = vector<int>(N);
lines = vector<Lines>(N);
rows[rows_size++] = -INFI;
cols[cols_size++] = -INFI;
int y = 0;
int x = 0;
for (int i = 0; i < N; i++) {
char c;
int num;
scanf(" %c %d", &c, &num);
int direction = determine_Direction(c);
int nextY = y + d_row[direction] * num;
int nextX = x + d_col[direction] * num;
startRow[i] = MIN(y, nextY);
endRow[i] = MAX(y, nextY) + 1;
startCol[i] = MIN(x, nextX);
endCol[i] = MAX(x, nextX) + 1;
rows[rows_size++] = startRow[i];
rows[rows_size++] = endRow[i];
cols[cols_size++] = startCol[i];
cols[cols_size++] = endCol[i];
y = nextY;
x = nextX;
}
rows[rows_size++] = INFI;
cols[cols_size++] = INFI;
compress();
DrawLine();
BFS();
long long solution = 0;
for (int r = 0; r < Row - 1; r++) {
for (int c = 0; c < Col - 1; c++) {
if (compressed[r][c] != 2) {
long long height = (long long)(rows[r + 1] - rows[r]);
long long width = (long long)(cols[c + 1] - cols[c]);
solution += (height * width);
}
}
}
cout << solution << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int f = 1, sum = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
sum = (sum << 3) + (sum << 1) + ch - '0';
ch = getchar();
}
return f * sum;
}
const int N = 200010, LG = 19;
int a[N], p[N], n, m, q, nxt[N][LG], pos[N], lst[N], ans[N], t[N << 2];
void build(int o, int l, int r) {
if (l == r) {
t[o] = ans[l];
return;
}
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
t[o] = min(t[o << 1], t[o << 1 | 1]);
}
int query(int o, int l, int r, int posl, int posr) {
if (posl <= l && r <= posr) return t[o];
int mid = (l + r) >> 1, ret = 1e9 + 10;
if (posl <= mid) ret = min(ret, query(o << 1, l, mid, posl, posr));
if (mid < posr) ret = min(ret, query(o << 1 | 1, mid + 1, r, posl, posr));
return ret;
}
void init() {
for (int i = 1; i <= n; i++) pos[p[i]] = i;
p[n + 1] = p[1];
nxt[m + 1][0] = m + 1;
for (int i = m; i; i--) {
int id = pos[a[i]];
nxt[i][0] = lst[p[id + 1]] ? lst[p[id + 1]] : m + 1;
lst[a[i]] = i;
}
for (int j = 1; j < LG; j++)
for (int i = 1; i <= m + 1; i++) nxt[i][j] = nxt[nxt[i][j - 1]][j - 1];
for (int i = 1; i <= m; i++) {
int jump = i;
for (int j = 0; j < LG; j++)
if (((n - 1) >> j) & 1) jump = nxt[jump][j];
ans[i] = jump;
}
build(1, 1, m);
}
int main() {
n = gi();
m = gi();
q = gi();
for (int i = 1; i <= n; i++) p[i] = gi();
for (int i = 1; i <= m; i++) a[i] = gi();
init();
while (q--) {
int l = gi(), r = gi();
printf("%d", query(1, 1, m, l, r) <= r);
}
puts("");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int f[2000005];
void KMP(vector<pair<long long, char> > c) {
f[0] = -1;
int j = -1;
for (int i = 1; i < c.size(); i++) {
while (j != -1 && c[i] != c[j + 1]) j = f[j];
if (c[i] == c[j + 1]) j++;
f[i] = j;
}
}
bool solve() {
int n, m;
scanf("%d %d", &n, &m);
vector<pair<long long, char> > s, t;
for (int i = 0; i < n; i++) {
int first;
char a;
scanf("%d-%c", &first, &a);
if (s.size() && s.back().second == a)
s.back().first += first;
else
s.push_back(make_pair(first, a));
}
for (int i = 0; i < m; i++) {
int first;
char a;
scanf("%d-%c", &first, &a);
if (t.size() && t.back().second == a)
t.back().first += first;
else
t.push_back(make_pair(first, a));
}
if (t.size() == 1) {
long long ans = 0;
for (auto it : s) {
if (it.second == t[0].second && it.first >= t[0].first) {
ans += it.first - t[0].first + 1;
}
}
printf("%lld\n", ans);
} else if (t.size() == 2) {
int ans = 0;
for (int i = 0; i < s.size() - 1; i++) {
if (s[i].second == t[0].second && s[i + 1].second == t[1].second &&
s[i].first >= t[0].first && s[i + 1].first >= t[1].first)
ans++;
}
printf("%d\n", ans);
} else {
m = t.size();
vector<pair<long long, char> > t2 = t;
t2.pop_back();
reverse(t2.begin(), t2.end());
t2.pop_back();
reverse(t2.begin(), t2.end());
KMP(t2);
int j = -1;
int ans = 0;
for (int i = 1; i < s.size() - 1; i++) {
while (j != -1 && s[i] != t2[j + 1]) j = f[j];
if (s[i] == t2[j + 1]) j++;
if (j == t2.size() - 1) {
if (s[i + 1].second == t.back().second &&
s[i + 1].first >= t.back().first && i + 1 - t.size() + 1 >= 0 &&
s[i + 1 - t.size() + 1].second == t[0].second &&
s[i + 1 - t.size() + 1].first >= t[0].first)
ans++;
j = f[j];
}
}
printf("%d\n", ans);
}
return true;
}
int main() {
int t = 1;
while (t--) solve();
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void Digvijay() {
long long x1, y1, z1, x2, y2, z2;
cin >> x1 >> y1 >> z1 >> x2 >> y2 >> z2;
long long n = x1 + y1 + z1;
long long ans = 0;
long long v1 = min(z1, y2);
ans += 2 * v1;
if (z1 >= y2) {
z1 -= y2;
y2 = 0;
} else {
z1 = 0;
}
long long v2 = x1 + z1;
if (v2 >= z2) {
z2 = 0;
} else {
z2 -= v2;
}
ans += z2 * -2;
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long _ = 1;
cin >> _;
for (long long __ = 1; __ <= _; __++) {
Digvijay();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, d;
cin >> n >> b >> d;
int ar[n];
int s = 0, c = 0;
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 0; i < n; i++) {
if (ar[i] <= b) {
s += ar[i];
if (s > d) {
c++;
s = 0;
}
}
}
cout << c << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> months = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int MAX = 1e5 + 55;
const int inf = 1e9 + 77;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double eps = 1e-7;
int n;
int dp[7005][2];
int cnt[7005][2];
int k[2];
vector<int> adj[2];
int nxt(int x) {
if (x <= n) return x;
x %= n;
return x;
}
int main() {
scanf("%d", &n);
int k1, k2;
scanf("%d", &k[0]);
for (int i = 0; i < k[0]; ++i) {
int x;
scanf("%d", &x);
adj[0].push_back(x);
}
scanf("%d", &k[1]);
for (int i = 0; i < k[1]; ++i) {
int x;
scanf("%d", &x);
adj[1].push_back(x);
}
memset(dp, -1, sizeof(dp));
queue<pair<int, int> > q;
q.push(make_pair(1, 0));
q.push(make_pair(1, 1));
dp[1][0] = 0;
dp[1][1] = 0;
while (!q.empty()) {
int u = q.front().first;
int flg = q.front().second;
q.pop();
for (auto i : adj[!flg]) {
int v = nxt(u + i);
if (dp[v][!flg] != -1) continue;
if (dp[u][flg] == 0) {
dp[v][!flg] = 2;
q.push(make_pair(v, !flg));
} else {
cnt[v][!flg]++;
if (cnt[v][!flg] == k[!flg]) {
dp[v][!flg] = 0;
q.push(make_pair(v, !flg));
}
}
}
}
for (int i = n; i >= 2; --i) {
int res = dp[i][0];
if (res == 2) {
printf("Win ");
} else if (res == -1)
printf("Loop ");
else
printf("Lose ");
}
printf("\n");
for (int i = n; i >= 2; --i) {
int res = dp[i][1];
if (res == 2) {
printf("Win ");
} else if (res == -1)
printf("Loop ");
else
printf("Lose ");
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long cal(long long a, long long b, long long c, long long n) {
if (n == 0) return 0;
return (b / c) * n + (a / c) * n * (n - 1) / 2 +
cal(c, (a * n + b) % c, a % c, (a % c * n + b % c) / c);
}
long long a, b, p, q;
long long cnt(long long l, long long r, long long vl, long long vr) {
long long sum = cal(p, l * p + q - vl, q, r - l + 1) -
cal(p, l * p + q - vr - 1, q, r - l + 1);
return sum;
}
long long solve() {
cin >> a >> b >> p >> q;
long long l = 0, r = q / 2;
while (l != r) {
long long mid = (l + r) / 2;
long long bruh = cnt(a, b, q / 2 - mid, (q + 1) / 2 + mid);
if (bruh > 0)
r = mid;
else
l = mid + 1;
}
long long gd = l;
l = a, r = b;
while (l != r) {
long long mid = (l + r) / 2;
long long bruh = cnt(a, mid, q / 2 - gd, (q + 1) / 2 + gd);
if (bruh > 0)
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
int t;
cin >> t;
while (t--) cout << solve() << '\n';
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int w[100100];
int N, L, R, QL, QR;
int main() {
cin >> N >> L >> R >> QL >> QR;
for (int i = (1); i < (N + 1); i++) cin >> w[i];
w[0] = 0;
for (int i = (0); i < (N); i++) w[i + 1] += w[i];
long long res = 1LL << 60;
for (int i = (0); i < (N + 1); i++) {
long long l = i, r = N - i;
long long cur = 0;
if (l > r)
cur += QL * (l - r - 1);
else if (l < r)
cur += QR * (r - l - 1);
cur += w[i] * L;
cur += (w[N] - w[i]) * R;
res = min(res, cur);
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
while (cin >> n >> k) {
int c = 0, s = k;
for (int i = 1; i <= n; i++) {
s += 5 * i;
if (s > 240)
break;
else {
c++;
}
}
cout << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize(3)
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC target("sse3", "sse2", "sse")
#pragma GCC target("avx", "sse4", "sse4.1", "sse4.2", "ssse3")
#pragma GCC target("f16c")
#pragma GCC optimize("inline", "fast-math", "unroll-loops", \
"no-stack-protector")
#pragma GCC push_options
#pragma GCC pop_options
#pragma GCC reset_options
#pragma GCC optimize("O3")
const double eps = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const long long LINF = 4557430888798830399LL;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const double PI = 3.141592653589793;
inline void fastll(long long &input_number) {
input_number = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9') {
input_number = (input_number << 3) + (input_number << 1) + ch - '0';
ch = getchar_unlocked();
}
input_number *= sign;
}
inline void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
inline void fasterios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long r, c;
bool isi[55][55];
bool ans[55][55];
vector<pair<long long, long long> > allans;
int main() {
cin >> r >> c;
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
cin >> isi[i][j];
}
}
for (int i = 1; i < r; i++) {
for (int j = 1; j < c; j++) {
if (isi[i][j] && isi[i + 1][j] && isi[i][j + 1] && isi[i + 1][j + 1]) {
ans[i][j] = ans[i + 1][j] = ans[i][j + 1] = ans[i + 1][j + 1] = 1;
allans.push_back({i, j});
}
}
}
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
if (isi[i][j] != ans[i][j]) {
cout << -1 << '\n';
return 0;
}
}
}
cout << allans.size() << '\n';
for (int i = 0; i < allans.size(); i++) {
cout << allans[i].first << " " << allans[i].second << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float v1, v2, t, d, s = 0;
cin >> v1 >> v2;
cin >> t >> d;
t = t - 2;
s += v1 + v2;
while (t > 0) {
if ((v1 + d - v2) / t <= d)
s += v1 + d, v1 += d;
else
v1 = v2 + d * t, s += v2 + d * t;
t--;
}
cout << s << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, a;
int main() {
cin >> a;
j = 1;
for (i = 1; i <= a; i++) {
j *= 2;
if (i == 13) j -= 100;
}
cout << j;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = std::numeric_limits<long long>::max();
const int MX = 100001;
const long double PI =
3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270L;
template <typename T>
pair<T, T> operator+(const pair<T, T> &a, const pair<T, T> &b) {
return pair<T, T>(a.first + b.first, a.second + b.second);
}
template <typename T>
pair<T, T> operator-(const pair<T, T> &a, const pair<T, T> &b) {
return pair<T, T>(a.first - b.first, a.second - b.second);
}
template <typename T>
T operator*(const pair<T, T> &a, const pair<T, T> &b) {
return (a.first * b.first + a.second * b.second);
}
template <typename T>
T operator^(const pair<T, T> &a, const pair<T, T> &b) {
return (a.first * b.second - a.second * b.first);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N;
cin >> N;
vector<int> sk(N);
for (int i = 0; i < N; ++i) cin >> sk[i];
sort(sk.begin(), sk.end());
int ats = 1;
int l = 0, r = 0;
int maz = 0;
for (int i = 0; i < N; ++i) {
if (i != N - 1 and abs(sk[i] - sk[i + 1]) > 1) {
if (i - maz + 1 > ats) {
ats = i - maz + 1;
l = maz;
r = i;
}
maz = i + 1;
} else if ((!i or sk[i] != sk[i - 1]) and
(i == N - 1 or sk[i] != sk[i + 1])) {
if (i - maz + 1 > ats) {
ats = i - maz + 1;
l = maz;
r = i;
}
maz = i;
}
}
if (N - maz > ats) {
ats = N - maz;
l = maz;
r = N - 1;
}
deque<int> kur;
kur.push_back(sk[l]);
for (int i = l + 1; i < r; ++i) {
kur.push_front(sk[i]);
int j = 0;
while (i + j + 1 < r and sk[i + j + 1] == sk[i]) {
if (j & 1)
kur.push_front(sk[i + j + 1]);
else
kur.push_back(sk[i + j + 1]);
j++;
}
i += j;
}
if (l != r) kur.push_back(sk[r]);
printf("%d\n", (int)kur.size());
while (kur.size()) printf("%d ", kur.front()), kur.pop_front();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0, y = 0;
cin >> n;
int *mas = new int[n];
for (int i = 0; i < n; i++) cin >> mas[i];
int max = mas[0], k = 0;
for (int i = 1; i < n; i++) {
if (mas[i] > max) {
max = mas[i];
k = i;
}
}
int rez = max + 1;
for (int i = 0; i < n; i++) {
if (i != k) rez = rez - mas[i];
}
cout << rez;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
vector<pair<int, int>> blocks;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
blocks.emplace_back(x, 1);
}
vector<vector<int>> all;
while (true) {
bool fnd = false;
vector<pair<int, int>> nblocks;
for (int i = 0; i < blocks.size(); i++) {
if (fnd) break;
for (int j = i + 1; j < blocks.size(); j++) {
if (fnd) break;
if (blocks[i].first == blocks[j].first + blocks[j].second) {
fnd = true;
vector<int> sz;
for (int p = 0; p <= i; p++) {
sz.emplace_back(blocks[p].second);
}
int tot = 0;
for (int p = i + 1; p <= j; p++) {
tot += blocks[p].second;
}
sz.emplace_back(tot);
for (int p = j + 1; p < blocks.size(); p++) {
sz.emplace_back(blocks[p].second);
}
all.emplace_back(sz);
for (int t = (int)blocks.size() - 1; t >= j + 1; t--)
nblocks.emplace_back(blocks[t]);
for (int t = i + 1; t <= j - 1; t++) nblocks.emplace_back(blocks[t]);
nblocks.emplace_back(blocks[j].first,
blocks[j].second + blocks[i].second);
for (int t = i - 1; t >= 0; t--) nblocks.emplace_back(blocks[t]);
assert(nblocks.size() == blocks.size() - 1);
break;
}
}
}
if (!fnd) break;
blocks = nblocks;
}
cout << all.size() << '\n';
for (auto& it : all) {
cout << it.size() << " ";
for (int v : it) cout << v << " ";
cout << '\n';
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, 1, -1, 0, 0, -1, 1};
int dx4[] = {0, 0, 1, 1};
int dy4[] = {1, -1, 1, -1};
int arr[10010];
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int i;
vector<char> v;
v.push_back(s[0]);
for (i = 2; i < s.size(); i += 2) {
v.push_back(s[i]);
}
v.push_back(s[s.size() - 1]);
for (i = 0; i < v.size(); i++) cout << v[i];
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int next_index(int now_index, int ti, int skill[]) {
int i;
for (i = now_index + 1; skill[i] != ti; i++)
;
return i;
}
int main() {
int n, skill[5000], prog = 0, math = 0, pe = 0, teams;
int index[3] = {-1, -1, -1};
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &skill[i]);
switch (skill[i]) {
case 1:
prog++;
break;
case 2:
math++;
break;
case 3:
pe++;
break;
}
}
teams = min(min(prog, math), pe);
for (int i = 0; prog > teams; i++)
if (skill[i] == 1) {
prog--;
index[0] = i;
}
for (int i = 0; math > teams; i++)
if (skill[i] == 2) {
math--;
index[1] = i;
}
for (int i = 0; pe > teams; i++)
if (skill[i] == 3) {
pe--;
index[2] = i;
}
printf("%d\n", teams);
for (int i = 0; i < teams; i++) {
for (int j = 0; j < 3; j++) index[j] = next_index(index[j], j + 1, skill);
printf("%d %d %d\n", index[0] + 1, index[1] + 1, index[2] + 1);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return a % b == 0 ? b : gcd(b, a % b); }
using namespace std;
int t[200005] = {0}, r[200005] = {0}, T, R, top = 0, n, m, a[200005] = {0};
int px[200005] = {0};
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &T, &R);
while (top && R >= r[top]) top--;
top++;
t[top] = T, r[top] = R;
}
for (int i = 1; i <= r[1]; i++) px[i] = a[i];
int ll = 0, rr = r[1] + 1;
sort(px + 1, px + r[1] + 1);
r[top + 1] = 0;
for (int i = 1; i <= top; i++) {
if (t[i] == 1)
for (int j = r[i]; j > r[i + 1]; j--) a[j] = px[--rr];
else
for (int j = r[i]; j > r[i + 1]; j--) a[j] = px[++ll];
}
for (int i = 1; i <= n; i++) printf("%d", a[i]), putchar(i == n ? '\n' : ' ');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
void solve() {
int a, b;
scanf("%d%d", &a, &b);
int now = 9, cnt = 0;
while (now <= b) {
now *= 10;
now += 9;
cnt++;
}
printf("%lld\n", 1ll * cnt * a);
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
int a[200010], b[200010];
int main() {
int n, s, i, sign, t;
while (scanf("%d", &n) == 1) {
s = 0;
t = 0;
sign = 0;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
s += a[i];
}
for (i = 0; i < n; i++) {
if (s - a[i] == a[i] * (n - 1)) {
b[t++] = i + 1;
}
}
printf("%d\n", t);
for (i = 0; i < t; i++) {
if (i != 0) printf(" ");
printf("%d", b[i]);
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
long long que[maxn], dp[5][maxn], a[maxn], b[maxn], t[maxn], ans = -1e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m, d;
cin >> n >> m >> d;
for (int i = 1; i <= m; i++) cin >> a[i] >> b[i] >> t[i];
for (int i = 1; i <= n; i++) {
dp[0][i] = b[1] - abs(i - a[1]);
}
int v = 1;
for (int i = 2; i <= m; i++) {
long long k = (t[i] - t[i - 1]) * d;
if (k == 0) {
for (int j = 1; j <= n; j++) {
dp[v][j] = dp[1 - v][j] - abs(j - a[i]) + b[i];
}
v = 1 - v;
continue;
}
int head = 1, tail = 1, x = 1;
for (int j = 1; j <= n; j++) {
while (x <= n && x - j <= k) {
while (head != tail && dp[1 - v][que[tail - 1]] <= dp[1 - v][x]) tail--;
que[tail++] = x++;
}
while (head != tail && j - que[head] > k) head++;
dp[v][j] = dp[1 - v][que[head]] - abs(j - a[i]) + b[i];
}
v = 1 - v;
}
for (int i = 1; i <= n; i++) ans = max(ans, dp[1 - v][i]);
cout << ans << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
long long l, r;
cin >> l >> r;
long long st1 = l & 1 ? l : l + 1, ed1 = r & 1 ? r : r - 1;
long long st2 = l & 1 ? l + 1 : l, ed2 = r & 1 ? r - 1 : r;
cout << (st2 + ed2) * ((ed2 - st2) / 2 + 1) / 2 -
(st1 + ed1) * ((ed1 - st1) / 2 + 1) / 2
<< endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
map<string, int> go;
int get_id(const string &s) {
auto it = go.find(s);
if (it != go.end()) return it->second;
return go[s] = (int)go.size();
}
void norm(string &s) {
for (char &c : s) c = (char)tolower(c);
}
void norm2(char *str) {
for (int i = 0; str[i]; i++) str[i] = (char)tolower(str[i]);
}
pair<int, long long> extract(const string &s) {
int cnt = 0;
for (char c : s) cnt += c == 'r';
return make_pair(cnt, (long long)(s.size()));
}
int n;
char str[5 * N];
vector<int> g[N];
int low[N], num[N], vis[N], cnt, scc_cnt, scc[N];
vector<int> S;
void tarjan(int u) {
low[u] = num[u] = ++cnt;
vis[u] = 1;
S.push_back(u);
for (int v : g[u]) {
if (!num[v]) tarjan(v);
if (vis[v]) low[u] = min(low[u], low[v]);
}
if (low[u] == num[u]) {
scc[u] = ++scc_cnt;
int v;
do {
v = S.back();
S.pop_back();
vis[v] = 0;
scc[v] = scc_cnt;
} while (u != v);
}
}
string s[N];
pair<int, long long> val[N];
pair<int, long long> best[N];
void operator+=(pair<int, long long> &a, const pair<int, long long> &b) {
a.first += b.first;
a.second += b.second;
}
vector<int> gs[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf(" %s", str);
norm2(str);
s[i] = str;
}
int m;
scanf("%d", &m);
while (m--) {
scanf(" %s", str);
norm2(str);
int a = get_id(str);
val[a] = extract(str);
scanf(" %s", str);
norm2(str);
int b = get_id(str);
val[b] = extract(str);
g[a].push_back(b);
}
for (int i = 0; i < (int)go.size(); i++)
if (!num[i]) tarjan(i);
for (int i = 0; i < (int)go.size(); i++) {
best[scc[i]] = val[i];
}
for (int i = 0; i < (int)go.size(); i++) {
best[scc[i]] = min(best[scc[i]], val[i]);
}
for (int i = 0; i <= (int)go.size(); i++) {
for (int j : g[i])
if (scc[i] != scc[j]) {
gs[scc[i]].push_back(scc[j]);
}
}
for (int i = 1; i <= scc_cnt; i++) {
for (int j : gs[i]) {
best[i] = min(best[i], best[j]);
}
}
pair<int, long long> ans;
for (int i = 0; i < n; i++) {
pair<int, long long> now = extract(s[i]);
if (!go.count(s[i])) {
ans += now;
continue;
}
int id = get_id(s[i]);
ans += best[scc[id]];
}
printf("%d %lld\n", ans.first, ans.second);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, i, cont = 0, x;
cin >> n >> h;
for (i = 0; i < n; i++) {
cin >> x;
if (x <= h)
cont++;
else
cont += 2;
}
cout << cont << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[1001], n, s, ans[30][30];
int main() {
cin >> n;
for (int i = 0; i < n * n; i++) {
cin >> s;
arr[s]++;
}
if (n % 2 == 0) {
for (int i = 0; i <= 1000; i++)
if (arr[i] % 4 != 0) {
cout << "NO" << endl;
return 0;
}
}
if (n % 2 == 1) {
int duo = (n / 2) * 4, kk = 0, pp = 0;
int si = (n / 2) * (n / 2);
int y = 0, t = 0;
for (int i = 0; i <= 1000; i++) {
if (arr[i] % 2 != 0) {
y++;
}
if (arr[i] == 2 || arr[i] == 3) kk++;
if (arr[i] >= 4) {
pp += (arr[i] / 4);
}
}
if (y != 1 || (kk == duo && kk != 0) || pp < si) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
if (n % 2 == 1) {
for (int i = 1; i <= 1000; i++) {
if (arr[i] % 2 != 0) {
ans[n / 2 + 1][n / 2 + 1] = i;
arr[i] -= 1;
break;
}
}
}
for (int i = 1; i <= n / 2; i++) {
for (int j = 1; j <= n / 2; j++) {
for (int d = 1; d <= 1000; d++) {
if (arr[d] >= 4) {
arr[d] -= 4;
ans[i][j] = ans[n - i + 1][j] = ans[i][n - j + 1] =
ans[n - i + 1][n - j + 1] = d;
break;
}
}
}
}
if (n % 2 == 1) {
for (int r = 1; r <= n / 2; r++)
for (int i = 1; i <= 1000; i++) {
if (arr[i] != 0) {
ans[n / 2 + 1][r] = ans[n / 2 + 1][n - r + 1] = i;
arr[i] -= 2;
break;
}
}
for (int r = 1; r <= n / 2; r++)
for (int i = 1; i <= 1000; i++) {
if (arr[i] != 0) {
ans[r][n / 2 + 1] = ans[n - r + 1][n / 2 + 1] = i;
arr[i] -= 2;
break;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve(){
int n; cin >> n;
vector<vector<int>> adj(1<<n);
for(int i = 0; i<n*(1<<(n-1)); i++){
int a, b; cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<int> ord;
vector<bool> vis((1<<n), 0);
queue<int> q({0});
while(q.size()){
int v = q.front(); q.pop();
if(vis[v]) continue;
vis[v] = 1, ord.push_back(v);
for(auto u : adj[v])
if(!vis[u]) q.push(u);
}
fill(vis.begin(), vis.end(), 0);
vector<int> val(1<<n), id(1<<n);
val[0] = 0, id[0] = 0, vis[0] = 1;
for(int i = 1; i<=n; i++)
val[ord[i]] = 1<<(i-1), id[1<<(i-1)] = ord[i], vis[ord[i]] = 1;
for(int i = n+1; i<(1<<n); i++){
val[ord[i]] = 0;
for(auto u : adj[ord[i]])
if(vis[u]) val[ord[i]] |= val[u];
id[val[ord[i]]] = ord[i];
vis[ord[i]] = 1;
}
for(int i = 0; i<(1<<n); i++)
cout << id[i] << " ";
cout << endl;
int lg = 1;
while(lg < n) lg *= 2;
if(lg != n) return void(cout << -1 << endl);
vector<int> ans(1<<n);
for(int i = 0; i<(1<<n); i++){
int bruh = 0;
for(int j = 0; j<n; j++)
bruh ^= j*((i>>j)&1);
ans[id[i]] = bruh;
}
for(int i = 0; i<(1<<n); i++)
cout << ans[i] << " ";
cout << endl;
}
int main(){
// freopen("a.in", "r", stdin);
cin.tie(0)->sync_with_stdio(0);
int t; cin >> t;
while(t--) solve();
} | 19 |
#include <bits/stdc++.h>
int main() {
size_t t;
std::cin >> t;
while (--t != -1) {
size_t l, r;
std::cin >> l >> r;
std::cout << l << " " << (l << 1) << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool calcW(long long s, long long e) {
if ((e & 1) != 0) return (s & 1) == 0;
if (s > e / 2) return (s & 1) != 0;
if (s > e / 4) return true;
return calcW(s, e / 4);
}
bool calcL(long long s, long long e) {
if (s > e / 2 || s > e - 1) return true;
return calcW(s, e / 2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
if (fopen("input.in", "r")) {
freopen("input.in", "r", stdin);
freopen("output.out", "w", stdout);
}
int t;
cin >> t;
pair<long long, long long> rounds[100000];
for (int i = 0; i < t; i++) cin >> rounds[i].first >> rounds[i].second;
bool val[100000][2];
for (int i = 0; i < t; i++) {
val[i][0] = calcW(rounds[i].first, rounds[i].second);
val[i][1] = calcL(rounds[i].first, rounds[i].second);
}
bool dp[100001][2];
dp[0][0] = true;
dp[0][1] = false;
for (int i = 1; i <= t; i++) {
dp[i][0] =
(dp[i - 1][0] && val[i - 1][1]) || (dp[i - 1][1] && !val[i - 1][1]);
dp[i][1] =
(dp[i - 1][0] && val[i - 1][0]) || (dp[i - 1][1] && !val[i - 1][0]);
}
cout << dp[t][1] << " " << dp[t][0] << "\n";
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int N, m, dis;
int headline[100010];
struct edge {
int nxt;
int b;
} e[2 * 100010];
int tot;
bool mark[100010];
int max1[100010], max2[100010];
int num[100010];
int disup[100010], disdown[100010];
void INIT(void) {
memset(headline, -1, sizeof(headline));
memset(mark, false, sizeof(mark));
memset(num, 0, sizeof(num));
tot = 0;
}
void Addline(int u, int v) {
tot++;
e[tot].nxt = headline[u];
e[tot].b = v;
num[u]++;
headline[u] = tot;
}
void dfsdown(int now, int fa) {
if (num[now] == 1 && e[headline[now]].b == fa) {
if (mark[now])
disdown[now] = 0;
else
disdown[now] = INT_MIN;
return;
}
max1[now] = max2[now] = INT_MIN;
for (int i = headline[now]; i != -1; i = e[i].nxt) {
int son = e[i].b;
if (son == fa) continue;
dfsdown(son, now);
if (disdown[son] > max1[now]) {
max2[now] = max1[now];
max1[now] = disdown[son];
} else if (disdown[son] > max2[now]) {
max2[now] = disdown[son];
}
}
disdown[now] = max1[now] + 1;
if (disdown[now] < 0 && mark[now]) disdown[now] = 0;
}
void dfsup(int now, int fa) {
if (fa == -1) {
if (mark[now])
disup[now] = 0;
else
disup[now] = INT_MIN;
} else {
if (disdown[now] == max1[fa]) {
disup[now] = max2[fa] + 2;
} else {
disup[now] = max1[fa] + 2;
}
disup[now] =
((disup[now]) > (disup[fa] + 1) ? (disup[now]) : (disup[fa] + 1));
if (disup[now] < 0 && mark[now]) disup[now] = 0;
}
if (num[now] == 1 && e[headline[now]].b == fa) return;
for (int i = headline[now]; i != -1; i = e[i].nxt) {
int son = e[i].b;
if (son != fa) {
dfsup(son, now);
}
}
}
int main(void) {
while (3 == scanf("%d%d%d", &N, &m, &dis)) {
INIT();
for (int i = 1; i <= m; i++) {
int temp;
scanf("%d", &temp);
mark[temp] = true;
}
for (int i = 1; i < N; i++) {
int u, v;
scanf("%d%d", &u, &v);
Addline(u, v);
Addline(v, u);
}
dfsdown(1, -1);
dfsup(1, -1);
int ans = 0;
for (int i = 1; i <= N; i++) {
if (((disdown[i]) > (disup[i]) ? (disdown[i]) : (disup[i])) <= dis) ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > s;
map<int, int> m;
int main() {
int i, n, q, x, y;
char buf[5];
scanf("%d %d", &n, &q);
s.insert(make_pair(0, 1));
s.insert(make_pair(n + 1, 0));
for (i = 0; i < q; i++) {
scanf("%d %d", &x, &y);
scanf("%s", buf);
if (m.count(x)) {
puts("0");
continue;
}
if (buf[0] == 'U') {
pair<int, int> p = *s.lower_bound(pair<int, int>(x, -1));
if (p.second == 1) {
m[x] = p.first - x + m[p.first];
} else {
m[x] = p.first - x;
}
s.insert(pair<int, int>(x, 1));
} else {
set<pair<int, int> >::iterator it =
--s.lower_bound(pair<int, int>(x, -1));
if (it->second == 0) {
m[x] = x - it->first + m[it->first];
} else {
m[x] = x - it->first;
}
s.insert(pair<int, int>(x, 0));
}
printf("%d\n", m[x]);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << showpoint;
cout << setprecision(2);
string s;
cin >> s;
vector<int> v(26, 0);
for (int i = 0; i < s.size(); i++) {
v[s[i] - 'a'] += 1;
}
int count = 0;
for (int i = 0; i < 26; i++) {
if (v[i] % 2) count += 1;
}
if (count <= 1)
cout << "First";
else {
if (count % 2 == 0)
cout << "Second";
else
cout << "First";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int numero[5005];
int ans[5005];
int main() {
int n;
scanf("%d", &n);
int a[5005];
int i, j;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
memset(numero, 0, sizeof(numero));
int max1 = 0;
int max2 = a[i];
for (j = i; j <= n; j++) {
numero[a[j]]++;
if (max1 < numero[a[j]] || (max1 == numero[a[j]] && max2 > a[j])) {
max1 = numero[a[j]];
max2 = a[j];
}
ans[max2]++;
}
}
for (i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
const ll MOD = 1000000007;
const ll INF = 100000000000000000LL;
inline ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
inline ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
inline ll powint(ll x, ll y) {
ll r = 1;
while (y) {
if (y & 1) r *= x;
x *= x;
y >>= 1;
}
return r;
}
inline ll powmod(ll x, ll y, ll m = MOD) {
ll r = 1;
while (y) {
if (y & 1) r *= x;
x *= x;
r %= m;
x %= m;
y >>= 1;
}
return r;
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll n;
cin >> n;
ll a[3];
for (ll i = 0; i < (n); i++) {
for (ll j = 0; j < (3); j++) cin >> a[j];
sort(a, a + 3);
ll alice = a[0], bob = a[1];
alice += a[1] - a[0];
a[2] -= a[1] - a[0];
cout << alice + a[2] / 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int R() {
char c;
int sign = 1, res = 0;
while ((c = getchar()) > '9' || c < '0')
if (c == '-') sign = -1;
res += c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return res * sign;
}
const int Maxn = 2e5 + 5;
int Next[Maxn], n, m;
int s[Maxn];
int sum[Maxn][30];
int main() {
char c;
while ((c = getchar()) >= 'a' && c <= 'z') s[++n] = c - 'a' + 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 26; j++) sum[i][j] = sum[i - 1][j] + (s[i] == j);
m = R();
int l, r;
while (m--) {
l = R();
r = R();
if (l == r) {
puts("Yes");
continue;
}
int L = r - l + 1;
if (sum[r][s[l]] - sum[l - 1][s[l]] == L) {
puts("No");
continue;
}
if (s[l] == s[r]) {
if (sum[r][s[l]] - sum[l - 1][s[l]] < L - 1) {
bool __ = 0;
for (int j = 1; j <= 26; j++) {
if (j == s[l]) continue;
if (sum[r][j] - sum[l - 1][j] + sum[r][s[l]] - sum[l - 1][s[l]] ==
L) {
__ = 1;
puts("No");
}
}
if (!__) puts("Yes");
} else
puts("No");
} else
puts("Yes");
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, F = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') F = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * F;
}
int add(int a, int b) {
return (a + b >= 998244353) ? a + b - 998244353 : a + b;
}
int dec(int a, int b) { return (a - b < 0) ? a - b + 998244353 : a - b; }
int mul(int a, int b) { return (1LL * a * b) % 998244353; }
int fst_pow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = mul(res, a);
a = mul(a, a), b >>= 1;
}
return res;
}
int n, m, A, B, inv[2000000 + 5];
int main() {
n = read(), m = read();
A = mul(n + m + 1, fst_pow(m + 1, 998244353 - 2)), B = 1;
for (int i = 1; i <= n; i++) {
inv[i] = (i == 1) ? 1 : mul(inv[998244353 % i], dec(0, 998244353 / i));
B = add(B, mul(m, inv[i]));
}
printf("%d", mul(A, B));
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
long long int s, t, c, x, finally;
int main() {
ios_base::sync_with_stdio(false);
cin >> s >> t;
for (int i = 0; i < s; ++i) {
cin >> x;
c += x;
}
if ((c + 10 * (s - 1)) > t)
cout << -1;
else {
finally += (t - (c + 10 * (s - 1))) / 5;
finally += (s - 1) * 2;
cout << finally;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n_c_r(long long n) { return (n * (n - 1)) / 2; }
long long bin(long long n) {
int cnt = 0;
while (n > 0) {
n /= 2;
cnt++;
}
return cnt;
}
int main() {
ios_base ::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n, i;
cin >> n;
map<long long, long long> mp;
for (i = 0; i < n; i++) {
long long x;
cin >> x;
mp[bin(x)]++;
}
long long ans = 0;
for (auto x : mp) {
if (x.second >= 2) {
ans += n_c_r(x.second);
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4;
const int mod = 1e9 + 7;
int n;
string s[N];
map<pair<string, int>, bool> dp;
bool checkhor(int i, int x) {
if (x == 1) return true;
string t = s[i];
if (dp.count({t, x})) return dp[{t, x}];
deque<int> v;
for (int j = int(t.size() - 1); j >= int(0); j--) {
int num = t[j] - '0';
if (t[j] >= 'A' and t[j] <= 'Z') {
num = 10 + (t[j] - 'A');
}
for (int i = int(1); i <= int(4); i++) {
v.push_front(num % 2);
num /= 2;
}
}
bool ok = true;
for (int i = 0; i < v.size(); i += x) {
for (int j = int(i); j <= int(i + x - 1); j++) {
if (v[j] != v[i]) {
ok = false;
break;
}
}
}
return dp[{t, x}] = ok;
}
bool check(int x) {
if (x == 1) return true;
for (int i = int(1); i <= int(n); i++) {
int j = ceil(1.0 * i / x);
bool ok = checkhor(i, x);
if (s[i] != s[x * (j - 1) + 1] or !ok) {
return false;
}
}
return true;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = int(1); i <= int(n); i++) cin >> s[i];
for (int i = int(n); i >= int(1); i--) {
if (n % i) continue;
if (check(i)) {
cout << i << '\n';
return 0;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int not_prime(int x) {
int i, flag = 0;
if (x <= 2) {
flag == 0;
} else {
for (i = 3; i < x; i++) {
if (x % i == 0) {
flag = 1;
}
}
}
if (flag == 1) {
return 1;
} else {
return 0;
}
}
int main() {
int a, b, c, d, e, f, g, h, i, j, x = 0, y = 0;
scanf("%d", &a);
if (a == 13) {
printf("%d %d", 4, 9);
} else {
b = a / 2;
c = a - b;
while (1) {
x = not_prime(b);
y = not_prime(c);
if (x == 1 & y == 1) {
break;
} else {
b++;
c--;
}
}
printf("%d %d\n", b, c);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct abc {
long long int x, y;
};
bool compare(abc a1, abc a2) {
if (a1.x == a2.x) return a1.y < a2.y;
return a1.x < a2.x;
}
const long long int mod = 1e9 + 7;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, k, s = 0, x;
cin >> n >> k;
multiset<long long int> second;
multiset<long long int>::iterator it;
for (long long int i = 0; i < n; i++) {
cin >> x;
s += x;
if (s <= k)
cout << 0;
else {
long long int c = 0, sum = s;
it = second.end();
it--;
while (sum > k) {
c++, sum -= *it, it--;
}
cout << c;
}
second.insert(x);
cout << ' ';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char c;
int n, i, j, k, mb, rb, bn, t = 0, ato = 0, atb, nm;
struct sd {
int bl, at, u, num;
} a[1010] = {0};
struct ssd {
int ti, num;
} ans[1010] = {0};
bool cmp(sd x, sd y) { return x.at > y.at; }
int rd() {
nm = 0;
c = getchar();
while (c < '0' || '9' < c) c = getchar();
while ('0' <= c && c <= '9') nm = nm * 10 + c - '0', c = getchar();
return nm;
}
int main() {
n = rd();
bn = mb = rd();
rb = rd();
for (i = 1; i <= n; ++i) {
a[i].bl = rd();
a[i].at = rd();
a[i].num = i;
}
sort(a + 1, a + n + 1, cmp);
for (i = 0;; ++i) {
bn = min(mb, bn - ato + rb);
if (bn <= 0) {
printf("YES\n%d %d", i, t);
for (j = 1; j <= t; ++j) printf("\n%d %d", ans[j].ti, ans[j].num);
return 0;
}
atb = ato;
for (j = 1; j <= n; ++j)
if (a[j].u == 0 && a[j].bl * mb >= bn * 100) {
a[j].u = 1;
ato += a[j].at;
ans[++t].ti = i;
ans[t].num = a[j].num;
break;
}
if (bn == mb && ato == atb) {
printf("NO\n");
return 0;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
const long double PI = acos(-1.L);
using namespace std;
pair<int, int> a[1000], aa[1000];
vector<int> l[1000];
vector<bool> m[1000];
inline bool orderBySecond(pair<int, int> a, pair<int, int> b) {
return a.second > b.second;
}
int main() {
int v, e;
scanf("%d%d", &v, &e);
for (int i = 0; i < v; i++) {
a[i].first = i;
scanf("%d", &a[i].second);
m[i].assign(v, 0);
}
memcpy(aa, a, sizeof(a));
sort(a, a + v, orderBySecond);
while (e--) {
int v0, v1;
scanf("%d%d", &v0, &v1);
v0--;
v1--;
l[v0].push_back(v1);
l[v1].push_back(v0);
m[v0][v1] = m[v1][v0] = 1;
}
long long res = 0;
for (__typeof(a + 0) i = (a + 0); i != (a + v); i++) {
int u = i->first;
for (__typeof(l[u].begin()) j = (l[u]).begin(); j != (l[u]).end(); j++) {
int v = *j;
if (m[u][v]) {
m[u][v] = m[v][u] = 0;
res += aa[v].second;
}
}
}
printf("%I64d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using ll = long long;
const int N = 22, S = 1 << N;
int a[S], dp[S];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = int(0); i < int(n); i++) {
cin >> a[i];
dp[a[i]] = a[i];
}
for (int i = int(0); i < int(N); i++)
for (int j = int(0); j < int(S); j++)
if (j & (1 << i))
if (dp[j ^ (1 << i)]) dp[j] = dp[j ^ (1 << i)];
for (int i = int(0); i < int(n); i++) {
int x = dp[a[i] ^ (S - 1)];
cout << (x ? x : -1) << ' ';
}
cout << '\n';
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (a > 0) {
b %= a;
swap(a, b);
}
return b;
}
int main() {
long long n, m, x, y, a, b;
cin >> n >> m >> x >> y >> a >> b;
long long g = gcd(a, b);
b /= g;
a /= g;
long long yy = (n / a) * b, xx = (yy * a) / b;
if (yy > m || xx > n) xx = (m / b) * a, yy = (xx * b) / a;
long long lx = x - (xx + 1) / 2, ly = y - (yy + 1) / 2;
if (lx < 0) lx = 0;
if (lx + xx > n) lx = n - xx;
if (ly < 0) ly = 0;
if (ly + yy > m) ly = m - yy;
cout << lx << " " << ly << " " << lx + xx << " " << ly + yy << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long Hashimoto = 0;
bool Kanna = 1;
char I_Love = getchar();
while (I_Love < '0' || I_Love > '9') {
if (I_Love == '-') Kanna = 0;
I_Love = getchar();
}
while (I_Love >= '0' && I_Love <= '9') {
Hashimoto = Hashimoto * 10 + I_Love - '0';
I_Love = getchar();
}
return (Kanna ? Hashimoto : -Hashimoto);
}
template <typename T1, typename T2>
inline void Umax(T1 &a, T2 b) {
if (a < b) a = b;
}
template <typename T1, typename T2>
inline void Umin(T1 &a, T2 b) {
if (a > b) a = b;
}
int n;
int xa[211111], ya[211111];
vector<int> num[211111];
vector<int> X, Y;
void pre() {
n = read();
for (int i = 0; i < (n); ++i) {
xa[i] = read();
ya[i] = read();
X.push_back(xa[i]);
Y.push_back(ya[i]);
}
sort(X.begin(), X.end());
;
X.erase(unique(X.begin(), X.end()), X.end());
;
sort(Y.begin(), Y.end());
;
Y.erase(unique(Y.begin(), Y.end()), Y.end());
;
for (int i = 0; i < (n); ++i) {
int a = lower_bound(X.begin(), X.end(), xa[i]) - X.begin();
int b = lower_bound(Y.begin(), Y.end(), ya[i]) - Y.begin();
num[b].push_back(a);
}
}
struct node {
node *ls, *rs;
int vl, pr, sz;
};
void update(node *x) {
x->sz = 1;
if (x->ls) x->sz += x->ls->sz;
if (x->rs) x->sz += x->rs->sz;
}
node *merge(node *x, node *y) {
if (x == NULL) return y;
if (y == NULL) return x;
if (x->pr > y->pr) {
x->rs = merge(x->rs, y);
update(x);
return x;
} else {
y->ls = merge(x, y->ls);
update(y);
return y;
}
}
pair<node *, node *> split(node *root, int x) {
if (root == NULL) return {NULL, NULL};
if (root->vl >= x) {
pair<node *, node *> ret = split(root->ls, x);
root->ls = ret.second;
update(root);
return {ret.first, root};
} else {
pair<node *, node *> ret = split(root->rs, x);
root->rs = ret.first;
update(root);
return {root, ret.second};
}
}
void insert(node *&root, node *x) {
pair<node *, node *> ret = split(root, x->vl);
node *nroot = merge(ret.first, merge(x, ret.second));
root = nroot;
}
void erase(node *&root, int x) {
pair<node *, node *> p1 = split(root, x);
pair<node *, node *> p2 = split(p1.second, x + 1);
node *nroot = merge(p1.first, p2.second);
root = nroot;
}
int find(node *&root, int x) {
int ans = 0;
if (root->ls) {
if (root->vl > x)
return find(root->ls, x);
else
ans += root->ls->sz;
}
if (root->vl == x) {
return ans;
}
ans++;
return find(root->rs, x) + ans;
}
node pool[2222222], *node_maker = pool;
set<int> s;
int ran = 19990203;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
pre();
node *root = node_maker++;
root->ls = root->rs = NULL;
root->sz = 1;
root->vl = -1;
ran = (ran * 7ll + 20031025ll) % (1000000007ll);
root->pr = ran;
long long ans = 0;
for (int i = n - 1; i >= 0; --i) {
if (num[i].size() == 0) continue;
sort(num[i].begin(), num[i].end());
for (int j = 0; j < (num[i].size()); ++j) {
if (s.find(num[i][j]) == s.end()) {
s.insert(num[i][j]);
node *nnode = node_maker++;
nnode->ls = nnode->rs = NULL;
nnode->sz = 1;
nnode->vl = num[i][j];
ran = (ran * 7ll + 20031025ll) % (1000000007ll);
nnode->pr = ran;
insert(root, nnode);
}
}
int lastpos = -1;
for (int j = 0; j < (num[i].size()); ++j) {
int pos = find(root, num[i][j]) - 1;
long long len1 = pos - lastpos, len2 = (s.size() - pos);
ans += len1 * len2;
lastpos = pos;
}
}
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool debug = false;
int h, q, v, e;
char s[7];
map<int, double> mp;
double dfs(int i, double ss) {
if (ss >= mp[i]) return ss;
int l = i << 1, r = l + 1;
return 0.5 *
(dfs(l, max(ss, mp[i] - mp[l])) + dfs(r, max(ss, mp[i] - mp[r])));
}
int main() {
scanf("%d%d", &h, &q);
while (q--) {
scanf("%s", s);
if (s[0] == 'a') {
scanf("%d%d", &v, &e);
while (v >= 1) {
mp[v] += e;
v >>= 1;
}
} else {
printf("%.8lf\n", dfs(1, 0));
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
char str[111111];
int ans[111111] = {0}, f[111111] = {0}, res = 0, resl, resr, len;
int main() {
scanf("%s", str);
len = strlen(str);
for (int i = 0; i <= len; i++) {
if (i == 0 || i - f[i - 1] - 1 < 0) continue;
if (str[i] == ')' && str[i - f[i - 1] - 1] == '(') {
f[i] = f[i - 1] + 2 + f[i - f[i - 1] - 2];
ans[i] = ans[i - 1] + ans[i - f[i - 1] - 2];
}
if (str[i] == ']' && str[i - f[i - 1] - 1] == '[') {
f[i] = f[i - 1] + 2 + f[i - f[i - 1] - 2];
ans[i] = ans[i - 1] + ans[i - f[i - 1] - 2] + 1;
}
if (ans[i] > res) res = ans[i], resr = i, resl = i - f[i] + 1;
}
printf("%d\n", res);
if (res == 0) return 0;
for (int i = resl; i <= resr; i++) printf("%c", str[i]);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, a[1001000], f[1001000];
long long ans = 0;
scanf("%d %d", &n, &x);
int i;
memset(f, 0, sizeof(f));
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
ans += f[a[i] ^ x];
f[a[i]]++;
}
printf("%I64d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
int a, b, ls;
int kalana[1000005];
int kalanb[1000005];
char ola[1000005];
char olb[1000005];
int main() {
scanf(" %s %d %d", s + 1, &a, &b);
ls = strlen(s + 1);
for (int i = 1; i <= ls; i++) {
kalana[i] = (kalana[i - 1] * 10 + s[i] - '0') % a;
}
int on = 1;
for (int i = ls; i >= 1; i--) {
kalanb[i] = (kalanb[i + 1] + (s[i] - '0') * on) % b;
on = (on * 10) % b;
}
int sifira = 1;
for (int i = 1; i < ls; i++) {
if (s[i] != '0') sifira = 0;
if (!sifira && kalana[i] == 0) ola[i] = 1;
}
int sifirb = 1;
for (int i = ls; i >= 2; i--) {
if (s[i] != '0') sifirb = 0;
if (!sifirb && kalanb[i] == 0) olb[i] = 1;
}
for (int i = 1; i < ls; i++) {
if (ola[i] && olb[i + 1] && s[i + 1] != '0') {
printf("YES\n");
for (int j = 1; j <= ls; j++) {
if (j == i + 1) printf("\n");
printf("%c", s[j]);
}
getchar();
getchar();
getchar();
return 0;
}
}
printf("NO");
getchar();
getchar();
getchar();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1e9 + 7, N = 200010;
int x, y, n, fa[N];
bool bo[N];
long long ans, num[N];
int ask(int x) {
if (fa[x] == x) return x;
fa[x] = ask(fa[x]);
return fa[x];
}
void uni(int x, int y) {
if (x == y) return;
int xx = ask(x), yy = ask(y);
if (xx == yy) {
ans = ans * 2 % p;
return;
}
fa[yy] = xx;
num[xx] += num[yy];
}
int main() {
scanf("%d", &n);
ans = 1;
for (int i = 1; i <= 2 * n; ++i) fa[i] = i, num[i] = 1;
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &x, &y);
bo[x] = 1;
uni(y, x);
}
for (int i = 1; i <= 2 * n; ++i)
if (!bo[i]) ans = 1LL * ans * num[i] % p;
printf("%lld", ans);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long double Pi = 3.141592653;
const long long mod = 1e9 + 9;
vector<long long> primes;
long long modoinv(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) {
return 0;
}
while (a > 1) {
long long t, q = a / m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) {
x += m0;
}
return x;
}
class Graph {
map<long long, vector<long long>> ma;
public:
void addedge(long long n, long long m) {
ma[n].push_back(m);
ma[m].push_back(n);
}
};
class Node {
public:
char data;
unordered_map<char, Node*> children;
bool terminal;
Node(char d) {
data = d;
terminal = false;
}
};
class Trie {
public:
Node* root;
long long cnt;
Trie() {
root = new Node('\0');
cnt = 0;
}
void insert(char* w) {
Node* temp = root;
for (long long i = 0; w[i] != '\0'; i++) {
char ch = w[i];
if (temp->children.count(ch)) {
temp = temp->children[ch];
} else {
Node* n = new Node(ch);
temp->children[ch] = n;
temp = n;
}
}
temp->terminal = true;
}
bool find(string w) {
Node* temp = root;
for (long long i = 0; w[i] != '\0'; i++) {
char ch = w[i];
if (temp->children.count(ch) == 0)
return false;
else {
temp = temp->children[ch];
}
}
return temp->terminal;
}
};
vector<long long> primeFactors(long long n) {
vector<long long> ans;
long long cur = 1;
ans.push_back(1);
while (n % 2 == 0) {
cur = cur * 2;
ans.push_back(cur);
n = n / 2;
}
for (long long i = 3; i * i <= (n); i = i + 2) {
while (n % i == 0) {
cur = cur * i;
ans.push_back(cur);
n = n / i;
}
}
if (n > 2) ans.push_back(cur * n);
return ans;
}
void sieve(long long p) {
vector<bool> mark(p, 1);
for (long long i = 3; i < p; i += 2) {
if (mark[i] == 1) {
for (long long j = i * i; j < p; j += 2 * i) {
mark[j] = 0;
}
}
}
primes.push_back(2);
for (long long i = 3; i < p; i += 2) {
if (mark[i]) primes.push_back(i);
}
}
long long mod_exp(long long x, long long n, long long m) {
if (n == 0) return 1 % m;
long long a = mod_exp(x, n / 2, m);
if (n % 2 == 0)
return (a * a) % m;
else
return (x * a * a) % m;
}
bool isPrime(long long n) {
if (n == 1) return 0;
if (n == 2) return 1;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return 0;
return 1;
}
bool check(long long a, long long d, long long n, long long s) {
if (s >= (((2 * a + (n - 1) * d) * n) / 2)) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a1, b1, n;
cin >> a1 >> b1 >> n;
while (n--) {
long long l, t, m;
cin >> l >> t >> m;
long long a = a1 + (l - 1) * b1;
long long left = 1, right = 1 + ((t - a) / b1), mid, ans;
if (right < left) {
cout << -1 << endl;
continue;
}
while (right >= left) {
mid = (right + left) / 2;
if (check(a, b1, mid, t * m)) {
ans = mid;
left = mid + 1;
} else
right = mid - 1;
}
cout << ans + l - 1 << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
const int M = 1e9 + 7;
const double eps = 1e-6;
const double PI(acos(-1.0));
int n, k;
int a[N];
int c[300];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
memset(c, -1, sizeof c);
for (int i = (1); i <= (n); i++) {
cin >> a[i];
if (c[a[i]] == -1) {
int t = max(0, a[i] - k + 1);
while (~c[t] && a[i] - c[t] >= k) t++;
if (~c[t]) {
for (int j = (t + 1); j <= (a[i]); j++) c[j] = t;
} else {
c[t] = t;
for (int j = (t + 1); j <= (a[i]); j++) c[j] = t;
}
}
cout << c[a[i]] << " ";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z, a, b, c;
int mat[3][3];
for (int i = 0; i <= 2; i++) {
for (int j = 0; j <= 2; j++) cin >> mat[i][j];
}
a = mat[0][1] + mat[0][2];
b = mat[1][0] + mat[1][2];
c = mat[2][0] + mat[2][1];
for (int i = 0; i <= 2; i++) {
for (int j = 0; j <= 2; j++) {
if (i == 0 && j == 0)
cout << (b - a + c) / 2 << " ";
else if (i == 1 && j == 1)
cout << (a - b + c) / 2 << " ";
else if (i == 2 && j == 2)
cout << (b + a - c) / 2 << " ";
else
cout << mat[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 257;
struct mat {
int n, m;
long long a[N][N];
mat(int n = 0, int m = 0) : n(n), m(m) { memset(a, 0x3f, sizeof a); }
mat operator*(const mat& b) const {
mat c(n, b.m);
assert(m == b.n);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
for (int k = 0; k < b.m; ++k)
c.a[i][k] = min(c.a[i][k], a[i][j] + b.a[j][k]);
return c;
}
} A[33], ans;
map<int, int> mp;
int n, m, K, q, L, a[100], b[100];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> m >> n >> K >> q;
for (int i = 1; i <= n; ++i) cin >> a[i];
A[0].n = A[0].m = ans.m = L = 1 << n;
ans.n = 1;
ans.a[0][(1 << m) - 1] = 0;
for (int i = 0; i < L; ++i)
if (!(i & 1))
A[0].a[i][i / 2] = 0;
else
for (int j = 1; j <= n; ++j)
if (!(i >> j & 1)) A[0].a[i][(i | 1 << j) / 2] = a[j];
for (int i = 1; i < 30; ++i) A[i] = A[i - 1] * A[i - 1];
for (int i = 1, x; i <= q; ++i) cin >> b[i] >> x, mp[b[i]] = x;
b[++q] = K + 1;
sort(b + 1, b + q + 1);
for (int i = 1, j = 1; i <= q; ++i) {
if (j + n < b[i]) {
for (int u = b[i] - n - j, k = 0; k < 30; ++k)
if (u >> k & 1) ans = ans * A[k];
j = b[i] - n;
}
for (; j < b[i] && j <= K - m; ++j) {
mat tmp = A[0];
for (int k = 1; k < L; k += 2)
for (int l = 1; l <= n; ++l)
if (!(k >> l & 1)) tmp.a[k][(k | 1 << l) / 2] += mp[j + l];
ans = ans * tmp;
}
}
cout << ans.a[0][(1 << m) - 1] << '\n';
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int MAX = 1000000;
int MIN = -1000000;
int INF = 1000000000;
int x4[4] = {0, 1, 0, -1};
int y4[4] = {1, 0, -1, 0};
int x8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int y8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
int i, j, k;
int n, m, a[200000], b[200000], sum[200000];
bool visit[200000];
vector<int> v;
vector<int> adj[200000];
void dfs(int X) {
if (visit[X] == true) return;
visit[X] = true;
v.push_back(X);
for (int i = 0; i < adj[X].size(); i++) {
dfs(adj[X][i]);
}
}
int main() {
memset((sum), (0), sizeof(sum));
;
memset((visit), (false), sizeof(visit));
;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
sum[a[i]]++;
sum[b[i]]++;
adj[a[i]].push_back(b[i]);
adj[b[i]].push_back(a[i]);
}
for (int i = 1; i <= n; i++) {
if (visit[i]) continue;
v.clear();
dfs(i);
for (int j = 0; j < v.size() - 1; j++) {
if (sum[v[j]] != v.size() - 1) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
queue<pair<int, int> > q[10];
int n, m, p;
char a[1005];
int d[1005][1005], s[10], ans[1005];
bool check(int x, int y) { return x && y && x <= n && y <= m && d[x][y] == -1; }
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= p; ++i) scanf("%d", s + i);
for (int i = 1; i <= n; ++i) {
scanf("%s", a + 1);
for (int j = 1; j <= m; ++j) {
if (a[j] == '.')
d[i][j] = -1;
else if (a[j] == '#')
d[i][j] = 1;
else
q[a[j] - '0'].push(make_pair(i, j)), ++ans[a[j] - '0'];
}
}
for (long long turn = 1;; ++turn) {
bool f = 0;
for (int i = 1; i <= p; ++i) {
while (!q[i].empty()) {
int x = q[i].front().first, y = q[i].front().second;
if (d[x][y] >= turn * s[i]) break;
for (int j = 0; j < 4; ++j) {
int x1 = x + dx[j], y1 = y + dy[j];
if (check(x1, y1)) {
d[x1][y1] = d[x][y] + 1;
q[i].push(make_pair(x1, y1));
++ans[i];
}
}
q[i].pop();
}
if (!q[i].empty()) f = 1;
}
if (!f) break;
}
for (int i = 1; i <= p; ++i) printf("%d ", ans[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000, INF = 1000 * 1000 * 1000;
const long double eps = 1e-9;
int gcd(int a, int b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
int main() {
int x1, x2, y1, y2, r1, r2;
cin >> x1 >> y1 >> r1;
cin >> x2 >> y2 >> r2;
x2 -= x1;
y2 -= y1;
x1 = 0;
y1 = 0;
long double A = -2 * x2;
long double B = -2 * y2;
long double C = x2 * x2 + y2 * y2 + r1 * r1 - r2 * r2;
if (C * C > r1 * r1 * (A * A + B * B)) {
long double dist = sqrtl((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
if (dist < r1 + r2) {
printf("%.10lf", (max(r1, r2) - (dist + min(r1, r2))) / 2);
} else {
printf("%.10lf", (dist - r1 - r2) / 2);
}
} else {
printf("%.10lf", 0.0);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n;
int data[301];
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &data[i]);
for (int i = 1; i <= n; i++) {
if (i != n) {
while (data[i]) {
printf("PRL");
data[i]--;
}
printf("R");
} else {
while (data[i]) {
printf("PLR");
data[i]--;
}
}
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 9, maxV = 1e6 + 9, MOD = 1e9 + 7, SQ = 322;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
string a;
cin >> a;
int first = -1;
int last = -1;
for (int i = 0; i < a.size(); i++) {
if (a[i] == '1') {
first = i;
break;
}
}
for (int j = a.size() - 1; j >= 0; j--) {
if (a[j] == '1') {
last = j;
break;
}
}
if (first == -1) {
cout << 0 << endl;
continue;
}
int ans = 0;
while (first <= last) {
if (a[first] == '0') ++ans;
++first;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxq = 5e5 + 10;
vector<int> vect1[1048586];
vector<pair<int*, int> > stek[1048586];
int n, q, p[maxn], sz[maxn], rez[maxq], k;
struct second {
int tip, a, b;
} qq[maxq];
void update1(int x, int l, int r, int ll, int rr, int val) {
if (l > rr || r < ll) return;
if (l >= ll && r <= rr) {
vect1[x].push_back(val);
return;
}
int mid = (l + r) / 2;
update1(x * 2, l, mid, ll, rr, val);
update1(x * 2 + 1, mid + 1, r, ll, rr, val);
}
int root(int x) {
if (p[x] == x)
return x;
else
return root(p[x]);
}
void join(int x, int y, int id) {
x = root(x);
y = root(y);
if (x == y) return;
if (sz[x] < sz[y]) swap(x, y);
stek[id].push_back({&(sz[x]), sz[x]});
stek[id].push_back({&(p[y]), p[y]});
sz[x] += sz[y];
p[y] = x;
}
void go(int x, int l, int r) {
for (int i = 0; i < vect1[x].size(); i++) {
int id = vect1[x][i];
if (qq[id].tip == 1)
join(qq[id].a, qq[id].b, x);
else
rez[id] = sz[root(qq[id].a)];
}
vect1[x].clear();
if (l == r) {
} else {
int mid = (l + r) / 2;
go(x * 2, l, mid);
go(x * 2 + 1, mid + 1, r);
}
while (stek[x].size()) {
*(stek[x].back().first) = stek[x].back().second;
stek[x].pop_back();
}
}
int main() {
scanf("%d %d %d", &n, &q, &k);
for (int i = 1; i <= n; i++) {
sz[i] = 1;
p[i] = i;
}
int day = 1;
for (int i = 1; i <= q; i++) {
int tip;
scanf("%d", &tip);
qq[i].tip = tip;
if (tip == 1) {
int u, v;
scanf("%d %d", &u, &v);
qq[i].a = u;
qq[i].b = v;
} else if (tip == 2) {
int x;
scanf("%d", &x);
qq[i].a = x;
} else
day++;
}
int mxd = day;
day = 1;
for (int i = 1; i <= q; i++) {
if (qq[i].tip == 1) {
update1(1, 1, mxd, day, day, i);
update1(1, 1, mxd, day + 1, day + k - 1, i);
} else if (qq[i].tip == 2) {
update1(1, 1, mxd, day, day, i);
} else
day++;
}
go(1, 1, mxd);
for (int i = 1; i <= q; i++) {
if (rez[i] == 0) continue;
printf("%d\n", rez[i]);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
char myMat[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> myMat[i][j];
long long int counter = 0;
if (n < 3)
cout << 0 << endl;
else {
for (int i = 1; i < n; i++)
for (int j = 1; j < n; j++)
if (i - 1 >= 0 && i + 1 < n && j + 1 < n && j - 1 >= 0) {
if (myMat[i][j] == 'X' && myMat[i - 1][j - 1] == 'X' &&
myMat[i - 1][j + 1] == 'X' && myMat[i + 1][j - 1] == 'X' &&
myMat[i + 1][j + 1] == 'X') {
counter++;
}
}
cout << counter << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e3 + 5;
const int INF = 1e9;
vector<int> g[MAXN], gr[MAXN];
int dp[MAXN];
bool used[MAXN];
int ans;
int d[MAXN];
int top;
void dfs_dp(int v) {
used[v] = 1;
int sz, to;
dp[v] = 0;
sz = g[v].size();
for (int i = 0; i < sz; i++) {
to = g[v][i];
if (used[to]) continue;
dfs_dp(to);
dp[v] += dp[to];
}
sz = gr[v].size();
for (int i = 0; i < sz; i++) {
to = gr[v][i];
if (used[to]) continue;
dfs_dp(to);
dp[v] += dp[to];
dp[v]++;
}
}
void dfs(int p, int v, int up, int mn) {
ans = min(ans, dp[p] - up + mn);
used[v] = 1;
int sz, to;
sz = g[v].size();
for (int i = 0; i < sz; i++) {
to = g[v][i];
if (used[to]) continue;
if (!top)
d[top] = 0;
else
d[top] = d[top - 1];
top++;
dfs(p, to, up, min(mn + 1, d[top - 1]));
top--;
}
sz = gr[v].size();
for (int i = 0; i < sz; i++) {
to = gr[v][i];
if (used[to]) continue;
if (!top)
d[top] = 1;
else
d[top] = d[top - 1] + 1;
top++;
dfs(p, to, up + 1, min(mn, d[top - 1]));
top--;
}
}
void solve() {
int n;
scanf("%d", &n);
int v, to;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &v, &to);
g[v].push_back(to);
gr[to].push_back(v);
}
ans = INF;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
used[j] = 0;
dp[j] = 0;
}
dfs_dp(i);
ans = min(ans, dp[i]);
for (int j = 1; j <= n; j++) {
used[j] = 0;
}
top = 0;
dfs(i, i, 0, 0);
}
cout << ans;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, a[400015], b[400015], c[400015], ans[50], cnt;
int main() {
for (int i = 1; i <= 400010; i++) {
int x = 0, y = 0, t = i;
while (t % 2 == 0) t /= 2, x++;
while (t % 5 == 0) t /= 5, y++;
a[i] = a[i - 1] + x, b[i] = b[i - 1] + y, c[i] = min(a[i], b[i]);
}
cin >> n;
for (int i = 1; i <= 400010; i++) {
if (c[i] == n) {
ans[++cnt] = i;
}
if (c[i] > n) break;
}
cout << cnt << endl;
for (int i = 1; i <= cnt; i++) cout << ans[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 40, P = 1e9 + 7;
inline long long read() {
char c = getchar();
long long x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int n, f[N][N][2], a[N], len;
long long mi[N];
inline void mod(int &x) {
if (x >= P) x -= P;
}
int dfs(int d, int j, int sky) {
if (d == 0) return 1;
if (f[d][j][sky] != -1) return f[d][j][sky];
int &now = f[d][j][sky], lim = sky ? a[d] : 1;
now = 0;
for (int i = 0; i <= lim; i++) {
mod(now += (j == 0 ? !i : mi[j - 1]) * dfs(d - 1, j, sky && i == lim) % P);
if (i == 1) mod(now += dfs(d - 1, j + 1, sky && i == lim));
}
return now;
}
int main() {
mi[0] = 1;
for (int i = 1; i <= 30; i++) mi[i] = (mi[i - 1] << 1) % P;
n = read();
while (n) a[++len] = n & 1, n >>= 1;
memset(f, -1, sizeof(f));
printf("%d", dfs(len, 0, 1));
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long cnt1, cnt2, x, y;
const long long inf = 2e9;
long long g(long long a, long long b) {
if (b == 0) return a;
return g(b, a % b);
}
long long l(long long a, long long b) { return a * b / g(a, b); }
bool f(long long v) {
long long temp = (v / l(x, y));
temp = v - temp;
return ((v - (v / x) >= cnt1) and (v - (v / y) >= cnt2) and
temp >= cnt1 + cnt2);
}
long long binarySearch(long long st, long long end) {
while (st + 1 < end) {
long long mid = (st + end) / 2;
if (f(mid)) {
end = mid;
} else {
st = mid;
}
}
if (f(st)) return st;
return end;
}
int main() {
cin >> cnt1 >> cnt2 >> x >> y;
long long ans = binarySearch(1, inf);
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
map<int, int> dp;
pair<int, int> a[307];
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) scanf("%d", &a[i].first);
for (int i = 0; i < n; i++) scanf("%d", &a[i].second);
dp.clear();
map<int, int>::iterator it;
dp[0] = 0;
for (int i = 0; i < n; i++) {
int x = a[i].first;
int c = a[i].second;
for (it = dp.begin(); it != dp.end(); it++) {
int y = it->first;
int d = gcd(x, y);
int temp = it->second + c;
if (dp[d] && dp[d] < temp) continue;
dp[d] = temp;
}
}
if (!dp[1])
puts("-1");
else
printf("%d\n", dp[1]);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char qq[400000];
pair<int, int> m[400000];
vector<int> co;
int kr[400000], su[400000];
int n, x, y, q, a;
void sum(int i, int k) {
qq[i] = 1;
while (i <= n) {
su[i] += k;
i = i | (i + 1);
}
}
int ot(int i) {
int o = 0;
while (i >= 0) {
o += su[i];
i = (i & (i + 1)) - 1;
}
return o;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> kr[i];
kr[i]--;
m[i].first = kr[i];
m[i].second = i;
}
sort(m, m + n);
sum(0, 1);
for (int i = 1; i < n; ++i) {
if (m[i].second < m[i - 1].second) {
sum(i, 1);
}
}
cin >> q;
for (int i = 0; i < q; ++i) {
cin >> a >> x >> y;
x--;
y--;
if (a == 1) {
cout << ot(y) - ot(x) + 1 << endl;
}
if (a == 2) {
int d, t;
d = kr[x];
t = kr[y];
swap(kr[x], kr[y]);
x = d;
y = t;
swap(m[x].second, m[y].second);
for (int i = x; i < x + 2; ++i) {
if (qq[i]) {
sum(i, -1);
qq[i] = 0;
}
if (m[i].second < m[i - 1].second) {
sum(i, 1);
}
}
for (int i = y; i < y + 2; ++i) {
if (qq[i]) {
sum(i, -1);
qq[i] = 0;
}
if (m[i].second < m[i - 1].second) {
sum(i, 1);
}
}
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
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 << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
while (tc--) {
int n, k, cnt = 0, mx;
string s;
cin >> n >> k;
cin >> s;
map<char, int> m;
int u = 0, v = 2;
if (k & 1) u = 1;
for (int i = 0; i < k / 2 + u; ++i) {
mx = -1;
for (int j = 0; j < n / k; ++j) {
int g = i + (j * k);
int g2 = (k - i - 1) + j * k;
if (g != g2) {
++m[s[g]];
++m[s[g2]];
} else
++m[s[g]];
}
for (auto it = (m).begin(); it != (m).end(); ++it)
mx = max(mx, it->second);
int g5 = i;
int g6 = (k - i - 1);
if (g5 == g6) v = 1;
cnt += ((n / k) * v - mx);
v = 2;
m.clear();
}
cout << cnt << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 105 * 105;
class DSet {
public:
vector<long long> parent;
DSet(long long n) : parent(n) {
for (long long i = 0; i < n; i++) parent[i] = i;
}
void join(long long a, long long b) { parent[find(b)] = find(a); }
long long find(long long a) {
return a == parent[a] ? a : parent[a] = find(parent[a]);
}
bool check(long long a, long long b) { return find(a) == find(b); }
};
int main(void) {
long long n, m;
cin >> n >> m;
vector<vector<long long>> v2;
DSet ds(maxn);
long long ans = 0, tot = 0;
for (long long i = 1; i <= n; i++) {
long long ki;
cin >> ki;
ans += !ki;
tot += ki;
vector<long long> v(ki);
for (long long j = 0; j < ki; j++) {
cin >> v[j];
ds.join(i * 102, v[j]);
}
}
ans += (tot == 0);
set<long long> s;
for (long long i = 1; i < maxn; i++) {
ds.parent[i] = ds.find(i);
if (i != ds.parent[i]) {
s.insert(ds.find(i));
}
}
ans += s.size();
--ans;
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> g[210000];
int f[210000];
int d[210000];
int color[210000];
int b;
void ddfs(int v, int p) {
d[v] = (p == -1 ? 0 : d[p] + 1);
f[v] = p;
if (d[v] > d[b]) b = v;
for (int x : g[v])
if (x != p) ddfs(x, v);
}
int cdfs(int v, int p, int c, int d) {
c = (((c + d) % k) + k) % k;
color[v] = c;
int h = 1;
for (int x : g[v])
if (x != p) {
h = max(h, cdfs(x, v, c, d) + 1);
}
return h;
}
void solve() {
scanf("%d %d", &n, &k);
for (int i = 0; i < (n - 1); ++i) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
b = 0;
ddfs(0, -1);
ddfs(b, -1);
vector<int> path;
while (b != -1) {
path.push_back(b);
b = f[b];
}
for (int i = 0; i < path.size(); i++) {
color[path[i]] = i % k;
for (int x : g[path[i]]) {
if (i != 0 && path[i - 1] == x) continue;
if (i + 1 < path.size() && path[i + 1] == x) continue;
int left = i + 1;
int right = path.size() - i;
int delta = (right > left ? -1 : +1);
int h = cdfs(x, path[i], i % k, delta);
if (h + min(left, right) >= k && k > 2) {
printf("No");
return;
}
}
}
printf("Yes\n");
for (int i = 0; i < (n); ++i) printf("%d ", color[i] + 1);
}
int main() { solve(); }
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
void solve() {
int n;
cin >> n;
long long a[n + 1][n + 1];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i + 1][j + 1];
vector<long long> leftsum(2 * n + 1, 0), rightsum(2 * n + 1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int left = i - j;
if (left < 0) left += 2 * n;
leftsum[left] += a[i][j];
rightsum[i + j] += a[i][j];
}
}
long long x1, y1, x2, y2, sum = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int left = i - j;
if (left < 0) left += 2 * n;
if (sum <= leftsum[left] + rightsum[i + j] - a[i][j]) {
sum = leftsum[left] + rightsum[i + j] - a[i][j];
x1 = i;
y1 = j;
}
}
}
long long ans = sum;
sum = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if ((i + j) % 2 == (x1 + y1) % 2) continue;
int left = i - j;
if (left < 0) left += 2 * n;
if (sum <= leftsum[left] + rightsum[i + j] - a[i][j]) {
sum = leftsum[left] + rightsum[i + j] - a[i][j];
x2 = i;
y2 = j;
}
}
}
ans += sum;
cout << ans << "\n";
cout << x1 << " " << y1 << " " << x2 << " " << y2 << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long p[20];
long long ff(long long x) {
if (x <= 9) return x;
long long S = 9;
for (int i = 1; i < 18; i++)
for (int j = 1; j <= 9; j++)
if (x / p[i] > j)
S += p[i - 1];
else if (x / p[i] == j) {
S += x % p[i] / 10;
if (x % 10 >= j) S++;
}
return S;
}
int main() {
p[0] = 1;
for (int i = 1; i < 20; i++) p[i] = p[i - 1] * 10;
long long L, R;
scanf("%I64d%I64d", &L, &R);
printf("%I64d\n", ff(R) - ff(L - 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / gcd(a, b)) * b;
}
template <class T, class X>
inline bool getbit(T a, X i) {
T t = 1;
return ((a & (t << i)) > 0);
}
template <class T, class X>
inline T setbit(T a, X i) {
T t = 1;
return (a | (t << i));
}
template <class T, class X>
inline T resetbit(T a, X i) {
T t = 1;
return (a & (~(t << i)));
}
inline long long getnum() {
char c = getchar();
long long num, sign = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') sign = -1;
for (num = 0; c >= '0' && c <= '9';) {
c -= '0';
num = num * 10 + c;
c = getchar();
}
return num * sign;
}
inline long long power(long long a, long long b) {
long long multiply = 1;
for (int i = (0); i < (b); i++) {
multiply *= a;
}
return multiply;
}
int n, k, a[2 * 100005];
vector<int> notone;
long long sum[2 * 100005];
long long getval(long long y, long long x1, long long x2) {
if (x1 + x2 < y) return 0;
if (x1 + x2 == y) return 1;
if (x1 < x2) swap(x1, x2);
long long l = min(x1, y);
long long r = y - l;
long long p = min(x2, y);
return p - r + 1;
}
void Test() {
cout << getval(10, 6, 8) << "\n";
cout << getval(12, 15, 19) << "\n";
cout << getval(4, 2, 9) << "\n";
cout << getval(5, 8, 3) << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
int test, cases = 1;
cin >> n >> k;
for (int i = (1); i < (n + 1); i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
if (a[i] != 1) notone.push_back(i);
}
int ans = 0;
for (int i = (0); i < (notone.size()); i++) {
long long mult = a[notone[i]];
for (int j = (i + 1); j < (notone.size()); j++) {
if ((long double)mult * a[notone[j]] > 2e18) break;
mult *= a[notone[j]];
if (mult % k != 0) continue;
long long need = mult / k - (sum[notone[j]] - sum[notone[i] - 1]);
if (need < 0)
continue;
else if (need == 0)
ans++;
else {
long long x1 =
(i - 1 >= 0 ? notone[i] - notone[i - 1] - 1 : notone[i] - 1);
long long x2 =
(j + 1 < (int)notone.size() ? notone[j + 1] - notone[j] - 1
: n - notone[j]);
ans += getval(need, x1, x2);
}
}
}
if (k == 1) ans += n;
cout << ans << "\n";
return 0;
}
| 13 |
#include <iostream>
#include <vector>
#include <unordered_map>
#include <queue>
#include <climits>
#include <algorithm>
#include <stack>
#include <math.h>
#include <set>
#include <map>
typedef long long ll;
typedef long double ld;
#define mod 1000000007
#define pb push_back
#define mp make_pair
#define INF INT_MAX
#define fi first
#define sec second
#define pii pair<ll,ll>
#define vi vector< ll >
#define vvi vector< vi >
#define vpi vector< pii >
#define vvpi vector< vpi >
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define test(t) ll t;cin>>t;while(t--){solve();}
#define mem(a,b) memset(a,b,sizeof(a))
#define inn freopen("input.txt", "r", stdin)
#define outt freopen("output.txt", "w", stdout)
#define all(arr) arr.begin(),arr.end()
#define fr(i,n) for(ll i=0;i<(n);++i)
#define rep(i,a,b) for(ll i=a;i<=b;++i)
#define per(i,a,b) for(ll i=a;i>=b;i--)
#define remin(a,b) (a=min((a),(b)))
#define remax(a,b) (a=max((a),(b)))
#define pq_max priority_queue<ll>
#define pq_min priority_queue<ll,vector<ll>,greater<ll>>
#define dbgarr(arr) for(ll i=0;i<arr.size();i++){cout<<arr[i];}
#define dbg(val) cout<<val<<endl;
#define PI 3.141592653589793238
using namespace std;
void solve()
{
//code
ll a,b;
cin>>a>>b;
if(b==1){
cout<<"NO\n";
return;
}
cout<<"YES\n";
ll x=a;
ll y=a*b;
ll z=(a*b)+a;
cout<<x<<" "<<y<<" "<<z<<endl;
}
int main() {
// your code goes here
#ifndef ONLINE_JUDGE
inn;
outt;
#endif
fast;
test(t)
//solve();
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int a[2100];
int main() {
int d, n;
scanf("%d", &d);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int t = 0;
for (int i = 1; i < n; i++) {
t += d - a[i];
}
printf("%d\n", t);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int c[202000];
map<int, int> mp1, mp2, num;
int main() {
int n, a, b;
queue<int> qu;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
c[i] = a;
c[i + n] = b;
if (mp1[a] == 0) {
mp1[a] = b;
} else
mp2[a] = b;
if (mp1[b] == 0)
mp1[b] = a;
else
mp2[b] = a;
}
for (int i = 0; i < 2 * n; i++) {
if (mp2[c[i]] == 0 || mp1[c[i]] == 0) {
a = c[i];
num[a]++;
qu.push(c[i]);
while (1) {
if (num[mp1[a]] == 0) {
a = mp1[a];
num[a]++;
} else {
a = mp2[a];
num[a]++;
}
qu.push(a);
if (mp2[a] == 0 || mp1[a] == 0) break;
}
break;
}
}
while (!qu.empty()) {
printf("%d ", qu.front());
qu.pop();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int count = 2;
if (n == 1) {
cout << 1;
return 0;
}
if (n == 2) {
cout << 2;
return 0;
}
int s = 1;
int big = 2;
int temp;
while (s + big < n) {
temp = big;
big += s + 1;
s += temp;
count++;
}
cout << count;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long exp(long long x, long long y) {
x %= 1000000007;
long long res = 1;
while (y) {
if (y & 1) res = res * x % 1000000007;
x = x * x % 1000000007;
y >>= 1;
}
return res;
}
long long fact(long long n) {
long long res = 1;
for (long long i = 2; i <= n; i = i + 1) (res *= i) %= 1000000007;
return res;
}
bool isprime(long long n) {
if (n <= 1) return 0;
for (long long i = 2; i * i <= n; ++i)
if (n % i == 0) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> v(n), b, cnt(n);
for (int i = 0; i < n; ++i) cin >> v[i];
b = v;
sort(b.begin(), b.end());
int ans = 0;
b.resize(unique(b.begin(), b.end()) - b.begin());
for (int i = 0; i < n; ++i) {
ans += (!v[i]);
v[i] = lower_bound(b.begin(), b.end(), v[i]) - b.begin();
++cnt[v[i]];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j || (!b[v[i]] && !b[v[j]])) continue;
int pr = v[i], nw = v[j], mx = 2;
--cnt[v[i]];
--cnt[v[j]];
vector<int> tmp{pr, nw};
for (int idx = lower_bound(b.begin(), b.end(), b[pr] + b[nw]) - b.begin();
idx < int(b.size()) && b[idx] == b[pr] + b[nw] && cnt[idx] > 0;
idx = lower_bound(b.begin(), b.end(), b[pr] + b[nw]) - b.begin()) {
--cnt[idx];
++mx;
tmp.push_back(idx);
pr = nw;
nw = idx;
}
ans = max(ans, mx);
for (auto c : tmp) {
++cnt[c];
}
}
}
cout << ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
string s;
int sum = 0;
vector<int> val[3];
int main() {
ios::sync_with_stdio(false);
cin >> s;
int n = (int)s.size();
for (int i = n - 1; i >= 0; i--) {
sum += (s[i] - '0') % 3;
val[(s[i] - '0') % 3].push_back(i);
}
sum %= 3;
if (sum == 0)
cout << s << endl;
else {
if (n == 1)
cout << "-1" << endl;
else if (val[sum].size() == 0) {
if (n == 2)
cout << "-1" << endl;
else {
if (val[3 - sum][1] == 0) {
int st = 0;
while (st < n && (s[st] == '0' || (s[st] - '0') % 3 == 3 - sum)) st++;
if (st == n) cout << "0" << endl;
for (int i = st; i < n; i++) {
if (i != val[3 - sum][0]) cout << s[i];
}
cout << endl;
} else {
for (int i = 0; i < n; i++)
if (i != val[3 - sum][0] && i != val[3 - sum][1]) cout << s[i];
cout << endl;
}
}
} else {
if (val[sum][0] == 0 && s[1] == '0') {
if ((int)val[3 - sum].size() >= 2) {
for (int i = 0; i < n; i++)
if (i != val[3 - sum][0] && i != val[3 - sum][1]) cout << s[i];
cout << endl;
} else {
int st = 0;
while (st < n && (st == val[sum][0] || s[st] == '0')) st++;
if (st == n) cout << "0" << endl;
for (int i = st; i < n; i++) cout << s[i];
cout << endl;
}
} else {
for (int i = 0; i < n; i++)
if (i != val[sum][0]) cout << s[i];
cout << endl;
}
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
const long double PI = 3.141592653589793;
const long long INF = 9223372036854775807ll;
const long long mod = 1e9 + 7;
const int N = 2e5 + 2;
vector<int> vis(N, 0);
vector<pair<int, int>> adj[N];
vector<pair<int, int>> rev[N];
vector<int> dist(N, 1e8);
int s = 0, e = 0;
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[v].push_back({u, i});
rev[u].push_back({v, i});
}
int k;
cin >> k;
vector<int> path(k);
for (int i = 0; i < k; ++i) {
cin >> path[i];
}
s = path[0] - 1;
e = path[k - 1] - 1;
dist[e] = 0;
auto cmp = [](int a, int b) { return dist[a] > dist[b]; };
priority_queue<int, vector<int>, decltype(cmp)> pq(cmp);
pq.push(e);
while (!pq.empty()) {
auto tp = pq.top();
pq.pop();
for (auto v : adj[tp]) {
if (dist[v.first] > dist[tp] + 1) {
dist[v.first] = dist[tp] + 1;
pq.push(v.first);
}
}
}
int mn = 0, mx = 0;
vector<int> ct(N, 0);
int f = 0;
for (int i = 0; i < n; ++i) {
for (auto v : rev[i]) {
if (dist[v.first] == dist[i] - 1) ct[i]++;
}
}
for (int i = 1; i < k; ++i) {
int now = path[i] - 1;
int prev = path[i - 1] - 1;
if (dist[now] != dist[prev] - 1) {
f++;
} else {
if (ct[prev] > 1) mx++;
}
}
cout << f << " " << (f + mx) << '\n';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, m, arr[N], tmp[N];
int d[N], t[N], s = 0;
pair<int, int> arr2[N];
set<int> st;
set<int>::iterator it;
bool check(int mid) {
int one = s * 2 - mid;
if (one > mid) return false;
for (int i = 0; i < n; i++) tmp[i] = arr[i];
st.clear();
int j = 0, cur = 0;
while (j < m && arr2[j].first > mid) j++;
for (int i = mid; i > 0; i--) {
while (j < m && arr2[j].first >= i) {
if (tmp[arr2[j].second] != 0) st.insert(arr2[j].second);
j++;
}
if ((int)st.size() == 0) continue;
it = st.begin();
tmp[*it]--;
cur++;
if (tmp[*it] == 0) st.erase(it);
}
if (cur >= one) return true;
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
s += arr[i];
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &arr2[i].first, &arr2[i].second);
arr2[i].second--;
}
sort(arr2, arr2 + m);
reverse(arr2, arr2 + m);
int low = 1, high = s * 2, res = s * 2, mid;
while (high >= low) {
mid = (low + high) / 2;
if (check(mid))
res = mid, high = mid - 1;
else
low = mid + 1;
}
cout << res << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
using namespace std;
int n, a[2010], pre[2010], suf[2010];
int dp[2010][2010][2];
int dpp[2010][2010][2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
dp[i][j][0] = 0;
dp[i][j][1] = 0;
dpp[i][j][0] = 0;
dpp[i][j][1] = 0;
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
pre[0] = 0;
suf[n + 1] = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 1)
pre[i] = pre[i - 1] + 1;
else
pre[i] = pre[i - 1];
}
for (int i = n; i >= 1; i--) {
if (a[i] == 2)
suf[i] = suf[i + 1] + 1;
else
suf[i] = suf[i + 1];
}
for (int i = 1; i <= n; i++) {
if (a[i] == 1) {
dp[i][i][1] = 1;
dp[i][i][0] = 0;
} else {
dp[i][i][1] = 0;
dp[i][i][0] = 1;
}
if (a[i] == 1) {
dpp[i][i][1] = 1;
dpp[i][i][0] = 0;
} else {
dpp[i][i][1] = 0;
dpp[i][i][0] = 1;
}
for (int j = i + 1; j <= n; j++) {
if (a[j] == 2) {
dp[i][j][0] = max(dp[i][j][0], dp[i][j - 1][0] + 1);
dp[i][j][0] = max(dp[i][j][0], dp[i][j - 1][1] + 1);
} else
dp[i][j][0] = max(dp[i][j][0], dp[i][j - 1][0]);
if (a[j] == 1)
dp[i][j][1] = max(dp[i][j][1], dp[i][j - 1][1] + 1);
else
dp[i][j][1] = max(dp[i][j][1], dp[i][j - 1][1]);
dpp[i][j][0] = max(dpp[i][j][0], suf[i] - suf[j + 1]);
if (a[j] == 1) {
dpp[i][j][1] = max(dpp[i][j][1], dpp[i][j - 1][1] + 1);
dpp[i][j][1] = max(dpp[i][j][1], dpp[i][j - 1][0] + 1);
} else
dpp[i][j][1] = max(dpp[i][j][1], dpp[i][j - 1][1]);
}
}
int ans = 1;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
ans = max(ans, pre[j] + dp[j + 1][n][0]);
ans = max(ans, pre[j] + dp[j + 1][n][1]);
ans = max(ans, pre[i - 1] + dpp[i][j][0] + suf[j + 1]);
ans = max(ans, pre[i - 1] + dpp[i][j][1] + suf[j + 1]);
ans = max(ans, dp[0][i - 1][0] + suf[i + 1]);
ans = max(ans, dp[0][i - 1][1] + suf[i + 1]);
}
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct exam {
int a, b;
} p[6000];
bool cmp(exam a, exam b) {
if (a.a == b.a) return a.b < b.b;
return a.a < b.a;
}
int main() {
int n, now;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i].a, &p[i].b);
}
sort(p + 1, p + n + 1, cmp);
now = p[1].b;
for (int i = 2; i <= n; i++) {
if (p[i].b >= now)
now = p[i].b;
else
now = p[i].a;
}
cout << now << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e4 + 33;
const double eps = 0.00000000001;
struct point {
double x, y, z;
point() {}
point(double x, double y, double z) : x(x), y(y), z(z) {}
};
double dis(point a, point b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y) +
(a.z - b.z) * (a.z - b.z));
}
point arr[MAX];
double dist[MAX];
int main() {
int n, vBall, vHarry, X, Y, Z;
cin >> n;
for (int i = 0; i < n + 1; ++i) {
int a, b, c;
cin >> a >> b >> c;
arr[i] = point(a, b, c);
}
cin >> vHarry >> vBall;
cin >> X >> Y >> Z;
point harry = point(X, Y, Z);
int po = -1;
for (int i = 1; i < n + 1; ++i) {
double disBall, disHarry;
disBall = dist[i - 1] + dis(arr[i - 1], arr[i]);
dist[i] = disBall;
disHarry = dis(harry, arr[i]);
double tHarry, tBall;
tHarry = disHarry / vHarry;
tBall = disBall / vBall;
if (tBall >= tHarry) {
po = i;
break;
}
}
if (po == -1) return puts("NO");
puts("YES");
point Pst, Pen, Pmd;
Pst = arr[po - 1];
Pen = arr[po];
double st = dist[po - 1] / vBall, en = dist[po] / vBall;
while (abs(st - en) > eps) {
double md = (st + en) / 2;
Pmd = point((Pst.x + Pen.x) / 2, (Pst.y + Pen.y) / 2, (Pst.z + Pen.z) / 2);
double disBall, disHarry;
disBall = dist[po - 1] + dis(arr[po - 1], Pmd);
disHarry = dis(harry, Pmd);
double tHarry, tBall;
tHarry = disHarry / vHarry;
tBall = disBall / vBall;
if (tHarry < tBall)
en = md, Pen = Pmd;
else
st = md, Pst = Pmd;
}
cout << setprecision(10) << fixed;
cout << st << endl;
cout << Pmd.x << ' ' << Pmd.y << ' ' << Pmd.z;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
for (auto i = 1; i < s.size() - 1; i++) {
if (s[i - 1] + s[i] + s[i + 1] == 198 && s[i - 1] != s[i + 1]) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for(auto i=(l);i<=(r);++i)
inline int ask(int l1, int r1, int l2, int r2) {
printf("? %d %d\n", r1 - l1 + 1, r2 - l2 + 1);
rep(i, l1, r1)printf("%d ", i);
puts("");
rep(i, l2, r2)printf("%d ", i);
puts("");
fflush(stdout);
int res;
scanf("%d", &res);
return res;
}
int n;
vector<int> q;
inline void work1(int pos) {
int l = 1, r = pos - 1;
while (l <= r) {
int m = l + r >> 1;
int o = ask(l, m, m + 1, pos);
if (o != 0)r = m - 1;
else l = m + 1;
}
rep(i, 1, pos - 1) {
if (l != pos && i == (r + 1))continue;
q.push_back(i);
}
}
inline void work2(int pos) {
rep(i, pos + 1, n)if (ask(pos, pos, i, i) == 0)q.push_back(i);
}
inline void solve() {
scanf("%d", &n), q.clear();
rep(i, 1, n - 1) {
int res = ask(1, i, i + 1, i + 1);
if (res != 0) {
work1(i + 1), work2(i + 1);
break;
}
}
printf("! %d", q.size());
for (auto v:q)printf(" %d", v);
puts("");
fflush(stdout);
}
int main() {
int T = 1;
scanf("%d", &T);
while (T--)solve();
} | 19 |
#include <bits/stdc++.h>
using namespace std;
long long n, q;
long long a[300005], dp_child[300005], dp_par[300005];
long long now, tin[300005], tout[300005], up[300005][19], val[300005][19],
val2[300005][19];
vector<pair<long long, long long> > g[300005];
map<pair<long long, long long>, long long> mp;
void get_child(long long u, long long p) {
for (auto e : g[u])
if (e.first != p) {
long long v = e.first, w = e.second;
get_child(v, u);
dp_child[u] += max(0ll, dp_child[v] + a[v] - 2 * w);
mp[{v, u}] = max(0ll, dp_child[v] + a[v] - 2 * w);
}
}
void get_par(long long u, long long p) {
for (auto e : g[u])
if (e.first != p) {
long long v = e.first, w = e.second;
long long t = max(0ll, dp_child[u] - mp[{v, u}]);
dp_par[v] = max(0ll, dp_par[u] + a[u] - 2 * w + t);
get_par(v, u);
}
}
void dfs(long long u, long long p) {
tin[u] = ++now;
for (long long i = 1; i <= 18; i++) {
up[u][i] = up[up[u][i - 1]][i - 1];
val[u][i] = val[u][i - 1] + val[up[u][i - 1]][i - 1];
val2[u][i] = val2[u][i - 1] + val2[up[u][i - 1]][i - 1];
}
for (auto e : g[u])
if (e.first != p) {
long long v = e.first, w = e.second;
up[v][0] = u;
val[v][0] = a[v] - w + dp_child[v];
val2[v][0] = mp[{v, u}];
dfs(v, u);
}
tout[u] = now;
}
bool is_ancestor(long long u, long long v) {
return (tin[u] <= tin[v] && tout[u] >= tout[v]);
}
long long lca(long long u, long long v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (long long i = 18; i >= 0; i--)
if (!is_ancestor(up[u][i], v)) u = up[u][i];
return up[u][0];
}
long long solve(long long u, long long v) {
long long r = lca(u, v), res = 0;
for (long long i = 18; i >= 0; i--) {
if (!is_ancestor(up[u][i], r)) {
res += val[u][i] - val2[u][i];
u = up[u][i];
}
if (!is_ancestor(up[v][i], r)) {
res += val[v][i] - val2[v][i];
v = up[v][i];
}
}
if (u != r) res += val[u][0] - val2[u][0];
if (v != r) res += val[v][0] - val2[v][0];
return res + a[r] + dp_child[r] + dp_par[r];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n - 1; i++) {
long long u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
get_child(1, 0);
get_par(1, 0);
tin[0] = -1000000000000000000;
tout[0] = 1000000000000000000;
dfs(1, 0);
while (q--) {
long long u, v;
cin >> u >> v;
cout << solve(u, v) << "\n";
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
string s;
cin >> s;
int q = s.find("aa");
int w = s.find("bb");
int e = s.find("cc");
if (q >= 0 || w >= 0 || e >= 0) {
cout << "-1" << endl;
} else {
for (int i = 0; i < (s.size()); i++) {
if (s[i] == '?') {
if (s[i - 1] == 'a' || s[i + 1] == 'a') {
if (s[i - 1] == 'b' || s[i + 1] == 'b')
s[i] = 'c';
else
s[i] = 'b';
} else
s[i] = 'a';
}
}
cout << s << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
int n;
int k;
cin >> q;
while (q--) {
cin >> n;
k = ceil(log(n) / log(3));
int a[k + 1];
for (int i = k; i >= 0; i--) {
if (n > pow(3, i)) {
n -= pow(3, i);
a[i] = 1;
} else {
a[i] = 0;
}
}
int i = 0;
while (a[i]) i++;
int num = pow(3, i);
i++;
for (; i <= k; i++) {
if (a[i]) num += pow(3, i);
}
cout << num << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool tag[26];
string s[31];
struct node {
char a, b;
} num[26 * 26 + 5];
bool cmp(struct node x, struct node y) {
if (x.a == y.a) return x.b < y.b;
return x.a < y.a;
}
void solve() {
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
num[i * 26 + j].a = i + 'a';
num[i * 26 + j].b = j + 'a';
}
}
sort(num, num + 26 * 26, cmp);
for (int i = 0; i <= 26 * 26; i++) {
int flag = 1;
for (int j = 0; j < n; j++) {
for (int k = 1; k < s[j].length(); k++) {
if (s[j][k - 1] == num[i].a && s[j][k] == num[i].b) {
flag = 0;
break;
}
}
if (flag == 0) break;
}
if (flag) {
cout << num[i].a << num[i].b << endl;
break;
}
}
}
int main() {
while (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].length(); j++) tag[s[i][j] - 'a'] = 1;
}
int flag = 1;
for (int i = 0; i < 26; i++)
if (tag[i] == 0) {
cout << (char)(i + 'a') << endl;
flag = 0;
break;
}
if (flag) solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
string ans;
inline bool is_vowel(char x) {
return (x == 'a' || x == 'e' || x == 'i' || x == 'o' || x == 'u' || x == 'y');
}
void solve(int index, char last) {
if (index == n) {
return;
}
if (is_vowel(last) && is_vowel(s[index])) {
solve(index + 1, last);
} else {
ans += s[index];
solve(index + 1, s[index]);
}
}
int main() {
cin >> n >> s;
ans = s[0];
solve(1, s[0]);
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[380];
int main() {
int n, k, m, ans = 0, i;
scanf("%d%d%d", &n, &k, &m);
for (i = 1; i <= m; i++) {
scanf("%d", &a[i]);
ans = ans + 1 + (a[i] - a[i - 1] - 1) / k;
}
ans = ans + (n - a[m]) / k;
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class DebugStream {
} LOG;
template <typename T>
DebugStream &operator<<(DebugStream &s, const T &) {
return s;
}
const int MAX = 100100;
int a[MAX], b[MAX];
int main() {
int T;
scanf("%d", &T);
for (int t = 0; t < int(T); t++) {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < int(n); i++) scanf("%d", a + i);
for (int i = 0; i < int(n); i++) scanf("%d", b + i);
sort(a, a + n);
sort(b, b + n, greater<int>());
for (int i = 0; i < int(k); i++) {
if (a[i] > b[i]) break;
swap(a[i], b[i]);
}
long long ans = 0;
for (int i = 0; i < int(n); i++) ans += a[i];
printf("%lld\n", ans);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 4e5 + 10;
const int Inf = 0x3f3f3f3f;
inline int rd() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
f = -1;
}
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
inline long long readll() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
f = -1;
}
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
template <class T>
void read(T &x) {
T res = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
res = (res << 3) + (res << 1) + c - '0';
c = getchar();
}
x = res * f;
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res % mod;
}
void run() {
int t = rd();
while (t--) {
int n = rd();
long long w = readll();
long long sum = 0;
long long c = (w % 2) == 0 ? w / 2 : (w / 2 + 1);
vector<pair<int, int> > v;
for (int i = 1; i <= n; i++) {
int x = rd();
v.push_back(make_pair(x, i));
}
sort(v.begin(), v.end());
vector<int> vc;
for (int i = n - 1; i >= 0; i--) {
if (sum + v[i].first <= w) {
sum += v[i].first;
vc.push_back(v[i].second);
}
}
if (sum >= c) {
printf("%d\n", vc.size());
sort(vc.begin(), vc.end());
for (int i = 0; i < vc.size(); i++) {
printf("%d%c", vc[i], " \n"[i == vc.size() - 1]);
}
} else {
puts("-1");
}
}
}
signed main() {
run();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200200;
long long inf = 0;
long long n, m, k;
long long a[maxn], b[maxn], w[maxn];
long long c[maxn];
long long I[maxn];
long long d[808][808];
long long wk;
vector<long long> x, y;
void add_v(long long v) {
if (~I[v]) return;
I[v] = x.size();
x.push_back(v);
}
int32_t main() {
memset(I, -1, sizeof I);
memset(d, 30, sizeof d);
inf = d[0][0];
for (long long i = 0; i < 808; i++) d[i][i] = 0;
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
x.reserve(n);
y.reserve(808 * 808);
for (long long i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> w[i];
a[i]--, b[i]--, c[i] = w[i];
}
sort(c, c + m);
c[m] = inf;
wk = c[min(k - 1, m)];
for (long long i = 0; i < m; i++)
if (w[i] < wk) {
add_v(a[i]), add_v(b[i]);
a[i] = I[a[i]];
b[i] = I[b[i]];
d[a[i]][b[i]] = d[b[i]][a[i]] = w[i];
}
n = x.size();
for (long long i = 0; i < m; i++)
if (w[i] < wk)
for (long long v = 0; v < n; v++)
for (long long u = 0; u < n; u++) {
d[v][u] = min(d[v][u], d[v][a[i]] + d[b[i]][u] + w[i]);
d[u][v] = d[v][u];
}
for (long long v = 0; v < n; v++)
for (long long u = 0; u < v; u++)
if (d[v][u] < inf) y.push_back(d[v][u]);
sort(y.begin(), y.end());
if (y.size() >= k) wk = min(wk, y[k - 1]);
cout << wk << endl;
return 0;
}
| 14 |
Subsets and Splits