solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int n, a, b, sum = 0, sum1, m;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cin >> m;
v.push_back(m);
}
sort(v.begin(), v.end());
if (v[b - 1] >= v[b]) {
cout << 0 << endl;
return 0;
}
sum1 = v[b] - v[b - 1];
if (v[b - 1] < v[b]) {
cout << sum1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, K, T, AnsX[100005], AnsY[100005];
bool V[100005];
bool Equ(double a, double b) { return abs(a - b) <= (1e-9); }
struct Nod {
double x, y;
bool operator==(const Nod& a) { return Equ(x, a.x) && Equ(y, a.y); }
} D[100005];
struct Lin {
double A, B, C;
void Rd() {
scanf("%lf%lf%lf", &A, &B, &C);
C = -C;
}
double Num(const Lin& a) { return A * a.B - B * a.A; }
bool IN(const Nod& a) { return Equ(A * a.x + B * a.y, C); }
Nod operator*(const Lin& a) {
return (Nod){(C * a.B - B * a.C) / Num(a), (A * a.C - C * a.A) / Num(a)};
}
} A[100005], B[100005];
int main() {
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; i++) A[i].Rd();
for (int d = 1; d <= K; d++) {
int tot = 0, cnt = 0;
for (int i = 1; i <= N; i++)
if (!V[i] && tot < K * K + 1) B[++tot] = A[i];
for (int i = 1; i <= tot; i++)
for (int j = i + 1; j <= tot; j++)
if (!Equ(B[i].Num(B[j]), 0)) {
Nod x = B[i] * B[j];
int flag = 0;
for (int k = 1; k <= cnt; k++)
if (D[k] == x) flag = 1;
if (!flag) D[++cnt] = x;
}
if (!cnt) {
cnt = 1;
if (B[1].A)
D[1] = (Nod){B[1].C / B[1].A, 0};
else
D[1] = (Nod){0, B[1].C / B[1].B};
}
int u = -1, Max = -1;
for (int i = 1; i <= cnt; i++) {
int t = 0;
for (int j = 1; j <= tot; j++)
if (B[j].IN(D[i])) t++;
if (u == -1 || t > Max) u = i, Max = t;
}
AnsX[d] = AnsY[d] = -1;
for (int i = 1; i <= N; i++)
if (!V[i] && A[i].IN(D[u])) {
V[i] = 1;
T++;
if (AnsX[d] == -1)
AnsX[d] = i;
else if (AnsY[d] == -1)
AnsY[d] = i;
}
if (T == N) {
K = d;
break;
}
}
if (T < N) return puts("NO"), 0;
printf("YES\n%d\n", K);
for (int i = 1; i <= K; i++) printf("%d %d\n", AnsX[i], AnsY[i]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int father[100005], mark[100005];
int head[100005], tot, Cnt[100005];
int sum[100005];
struct Edge {
int to, index, next;
} edge[100005 * 10];
struct node {
int x, y, v, index;
long long tree;
} s[100005];
long long Ans[100005];
bool cmp(node a, node b) { return (a.v < b.v); }
bool cmp2(node a, node b) { return (a.index < b.index); }
int getfa(int v) {
if (father[v] != v) father[v] = getfa(father[v]);
return father[v];
}
void add(int a, int b, int c) {
edge[tot].to = b, edge[tot].index = c;
edge[tot].next = head[a], head[a] = tot++;
}
void DFS(int x, int pre) {
sum[x] = Cnt[x];
for (int i = head[x]; i != -1; i = edge[i].next) {
int y = edge[i].to;
if (y != pre) {
DFS(y, x);
sum[x] += sum[y];
}
}
}
void Calc(int x, int pre, int All) {
for (int i = head[x]; i != -1; i = edge[i].next) {
int y = edge[i].to;
if (y != pre) {
Ans[edge[i].index] = (long long)sum[y] * (All - sum[y]) * 2;
Calc(y, x, All);
}
}
}
void solve(int be, int en) {
int i, j;
tot = 0;
for (i = be; i <= en; i++) {
int x = getfa(s[i].x);
int y = getfa(s[i].y);
head[x] = -1;
head[y] = -1;
sum[x] = 0;
sum[y] = 0;
}
for (i = be; i <= en; i++) {
int x = getfa(s[i].x);
int y = getfa(s[i].y);
add(x, y, s[i].index);
add(y, x, s[i].index);
}
for (i = be; i <= en; i++) {
int x = getfa(s[i].x);
if (sum[x] == 0) {
DFS(x, -1);
Calc(x, -1, sum[x]);
}
}
for (i = be; i <= en; i++) {
int x = getfa(s[i].x);
int y = getfa(s[i].y);
if (x == y) continue;
father[x] = y;
Cnt[y] += Cnt[x];
}
}
int main() {
int n, i, j;
while (scanf("%d", &n) != EOF) {
for (i = 1; i <= n; i++) {
father[i] = i;
Cnt[i] = 1;
}
for (i = 1; i < n; i++) {
scanf("%d %d %d", &s[i].x, &s[i].y, &s[i].v);
s[i].index = i;
}
sort(s + 1, s + n, cmp);
for (i = 1; i < n;) {
for (j = i + 1; j < n; j++)
if (s[j].v != s[i].v) break;
solve(i, j - 1);
i = j;
}
long long ans = -1;
int cnt = 0;
for (i = 1; i < n; i++) {
if (Ans[i] > ans)
ans = Ans[i], cnt = 1;
else if (Ans[i] == ans)
cnt++;
}
cout << ans << " " << cnt << endl;
for (i = 1; i < n; i++)
if (Ans[i] == ans) printf("%d ", i);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int m, n, k, R[27], C[27], r, c, y, x;
char a[101][102], s[1001];
int main() {
scanf("%d%d%d", &m, &n, &k);
for (int i = 1; i <= m; i++) {
scanf("%s", a[i] + 1);
for (int j = 1; j <= n; j++)
if (islower(a[i][j])) {
R[a[i][j] - 'a'] = i;
C[a[i][j] - 'a'] = j;
a[i][j] = '1';
}
}
scanf("%d%d%s%d%d", &y, &x, s, R + 26, C + 26);
for (int i = 0; s[i] || s[i - 1] != (s[i] = 'a' + 26); i++) {
r = R[s[i] - 'a'];
c = C[s[i] - 'a'];
while (y != r || x != c) {
k -= a[y][x] - '0';
if (k < 0) goto end;
y += (y < r) - (y > r);
x += (x < c) - (x > c);
}
}
end:
printf("%d %d\n", y, x);
}
| 7 |
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int mod = read();
long long l, r, k;
bool judge(long long x) { return r / x - (l - 1) / x >= k; }
struct juzhen {
long long m[3][3];
void clearit() {
memset(m, 0, sizeof m);
m[1][1] = m[2][2] = 1;
}
void clear() { memset(m, 0, sizeof m); }
juzhen operator*(const juzhen &b) const {
int i, j, k;
juzhen ans;
ans.clear();
for (i = 1; i < 3; ++i) {
for (j = 1; j < 3; ++j) {
for (k = 1; k < 3; ++k) {
ans.m[i][j] = (ans.m[i][j] + m[i][k] * b.m[k][j]) % mod;
}
}
}
return ans;
}
};
juzhen operator^(juzhen a, long long b) {
juzhen c;
c.clearit();
for (; b; b >>= 1, a = a * a)
if (b & 1) c = c * a;
return c;
}
int main() {
read(l), read(r), read(k);
long long ans = 0;
for (long long i = 1; i * i <= r; ++i) {
if (judge(i)) ans = max(ans, i);
if (judge(r / i)) ans = max(ans, r / i);
}
juzhen tmp;
tmp.clear();
tmp.m[1][1] = tmp.m[1][2] = tmp.m[2][1] = 1;
tmp = tmp ^ ans - 1;
write((tmp.m[1][1] + mod) % mod);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 111111;
int N, p[MAXN];
long long cnt[MAXN];
int find(int x) {
if (p[x] == x) return x;
return p[x] = find(p[x]);
}
bool lucky(int k) {
if (!k) return false;
while (k) {
int tmp = k % 10;
if (tmp != 4 && tmp != 7) return false;
k /= 10;
}
return true;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) p[i] = i;
for (int i = 1; i < N; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (!lucky(z)) p[find(x)] = find(y);
}
for (int i = 1; i <= N; i++) cnt[find(i)]++;
long long ans = 0;
for (int i = 1; i <= N; i++) ans += cnt[i] * (N - cnt[i]) * (N - cnt[i] - 1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void add(int& a, int b, int mod) { a = (a + b) % mod; }
void sub(int& a, int b, int mod) { a = ((a - b) % mod + mod) % mod; }
void mul(int& a, int b, int mod) { a = (a * 1ll * b) % mod; }
template <class T>
bool umin(T& a, const T& b) {
return a > b ? a = b, true : false;
}
template <class T>
bool umax(T& a, const T& b) {
return a < b ? a = b, true : false;
}
template <int sz>
using tut = array<int, sz>;
void usaco(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 5e3 + 5;
const int mod = 1e9 + 7;
const long long inf = 1e18;
const long double Pi = acos(-1);
int n, m, k, t, q, ans, res, a[N];
int prof[N], dp[N][N], c[N];
void solve(int t_case) {
memset(dp, -127, sizeof dp);
cin >> n >> m;
for (int i = n; i > 0; i--) cin >> a[i];
for (int i = n; i > 0; i--) cin >> c[i];
for (int i = 1; i <= n + m; i++) cin >> prof[i], dp[i][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = n; j > 0; j--)
umax(dp[a[i]][j], dp[a[i]][j - 1] - c[i] + prof[a[i]]);
for (int j = a[i]; j < n + m; j++) {
for (int l = n >> (j - a[i]); l >= 0; l--) {
umax(dp[j + 1][l / 2], dp[j][l] + prof[j + 1] * (l / 2));
}
}
}
for (int i = 1; i <= n + m; i++)
for (int j = 0; j < 2; j++) umax(res, dp[i][j]);
cout << res << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (0) {
int t;
cin >> t;
for (int t_case = 1; t_case <= t; t_case++) solve(t_case);
} else
solve(1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt;
int head[205], Next[50005], vet[50005];
void add(int x, int y) {
cnt++;
Next[cnt] = head[x];
head[x] = cnt;
vet[cnt] = y;
}
struct node {
int id;
long long dis;
friend bool operator<(node a, node b) { return a.dis > b.dis; }
};
long long dis[205], f[205];
priority_queue<node> q;
void dij(int s) {
memset(dis, 0x3f, sizeof(dis));
memset(f, 0, sizeof(f));
dis[s] = 0;
f[s] = 1;
q.push((node){s, 0});
while (!q.empty()) {
node t = q.top();
q.pop();
if (t.dis > dis[t.id]) continue;
for (int i = head[t.id]; i; i = Next[i]) {
int v = vet[i];
if (dis[v] > t.dis + 1) {
dis[v] = t.dis + 1;
f[v] = f[t.id];
q.push((node){v, dis[v]});
} else if (dis[v] == t.dis + 1) {
f[v] += f[t.id];
}
}
}
}
int main() {
cin >> n >> m;
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
dij(1);
long long ans = f[n], t = f[n], len = dis[n];
for (int i = 2; i < n; i++) {
dij(i);
if (dis[1] + dis[n] == len) ans = max(ans, f[1] * f[n] * 2);
}
printf("%.12lf", 1.0 * ans / t);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int prime[1000];
bool bo[10001];
int prime_table() {
int i, j, flag = 0;
memset(bo, 0, sizeof(bo));
bo[0] = bo[1] = 1;
for (i = 2; i <= 100; i++)
if (!bo[i]) {
j = i * i;
for (; j <= 10000; j += i) bo[j] = 1;
}
for (i = 0; i <= 10000; i++)
if (!bo[i]) prime[flag++] = i;
return flag;
}
int cnt[30];
char s[1005];
char ans[1005];
bool b[1005];
int main() {
int len, i, tmp, k, num, j;
int flag = prime_table();
scanf("%s", s);
len = strlen(s);
memset(cnt, 0, sizeof(cnt));
memset(ans, 0, sizeof(ans));
memset(b, 0, sizeof(b));
for (i = 0; i < len; i++) cnt[s[i] - 'a']++;
for (i = 0; i < flag; i++)
if (prime[i] > len / 2) break;
flag = i;
for (i = 0; i < flag; i++) {
tmp = prime[i];
for (j = tmp; j <= len; j += tmp) b[j] = 1;
}
num = 0;
for (i = 0; i < len; i++)
if (b[i + 1]) num++;
for (i = 0; i < 26; i++)
if (cnt[i] >= num) {
puts("YES");
cnt[i] -= num;
for (j = 0; j < len; j++)
if (b[j + 1]) ans[j] = char(i + 'a');
for (j = 0; j < len; j++)
if (ans[j] == '\0') {
for (k = 0; k < 26; k++)
if (cnt[k]) {
ans[j] = char(k + 'a');
cnt[k]--;
break;
}
}
puts(ans);
break;
}
if (i == 26) puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int getBit(unsigned int, int);
void setBit(unsigned int &, int);
void clearBit(unsigned int &, int);
void reverseBit(unsigned int &, int);
int INF = 1e9;
int m, n, k;
int sx, sy;
string a[20];
int f[20][20][1 << 8][1 << 8];
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
vector<pair<int, int> > bomb;
pair<int, int> treasure[8];
int v[8];
int res;
typedef struct _Element {
int x;
int y;
unsigned int mb;
unsigned int mt;
_Element(int _x, int _y, unsigned int _mb, unsigned int _mt) {
x = _x;
y = _y;
mb = _mb;
mt = _mt;
}
} Element;
void Solve();
int main() {
cin >> m >> n;
for (int i = 0; i < m; i++) {
cin >> a[i];
for (int j = 0; j < n; j++) {
if ('0' <= a[i][j] && a[i][j] <= '9') {
k = max(k, a[i][j] - '0');
a[i][j] = '0' + int(a[i][j] - '0' - 1);
treasure[a[i][j] - '0'].first = i;
treasure[a[i][j] - '0'].second = j;
} else if (a[i][j] == 'S') {
sx = i;
sy = j;
a[i][j] = '.';
} else if (a[i][j] == 'B') {
bomb.push_back(pair<int, int>(i, j));
}
}
}
for (int i = 0; i < k; i++) {
cin >> v[i];
}
Solve();
return 0;
}
int getBit(unsigned int x, int i) { return ((x & (1 << i)) != 0); }
void setBit(unsigned int &x, int i) { x = x | (1 << i); }
void clearBit(unsigned int &x, int i) { x = x & (~(1 << i)); }
void reverseBit(unsigned int &x, int i) {
if (getBit(x, i)) {
clearBit(x, i);
} else {
setBit(x, i);
}
}
bool Intersect(int x0, int y0, int x1, int y1, int x2, int y2) {
int x3 = x2 + 1;
int y3 = n * 2;
int A01, A23, B01, B23, C01, C23;
A01 = y0 - y1;
B01 = x1 - x0;
C01 = (x0 * y1 - x1 * y0);
A23 = y2 - y3;
B23 = x3 - x2;
C23 = (x2 * y3 - x3 * y2);
int f01 = (A23 * x0 + B23 * y0 + C23) * (A23 * x1 + B23 * y1 + C23);
int f23 = (A01 * x2 + B01 * y2 + C01) * (A01 * x3 + B01 * y3 + C01);
return (f01 < 0 && f23 < 0);
}
void Solve() {
queue<Element> q;
Element s(sx, sy, 0, 0);
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
for (int b1 = 0; b1 < (1 << 8); b1++)
for (int b2 = 0; b2 < (1 << 8); b2++) {
f[i][j][b1][b2] = INF;
}
f[sx][sy][0][0] = 0;
q.push(s);
while (!q.empty()) {
Element tx = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
Element qx(tx.x + dx[i], tx.y + dy[i], tx.mb, tx.mt);
if (!(0 <= qx.x && qx.x < m && 0 <= qx.y && qx.y < n)) continue;
if (a[qx.x][qx.y] != '.') continue;
for (int j = 0; j < k; j++) {
if (Intersect(2 * tx.x, 2 * tx.y, 2 * qx.x, 2 * qx.y,
2 * treasure[j].first, 2 * treasure[j].second)) {
reverseBit(qx.mt, j);
}
}
for (int j = 0; j < bomb.size(); j++) {
if (Intersect(2 * tx.x, 2 * tx.y, 2 * qx.x, 2 * qx.y, 2 * bomb[j].first,
2 * bomb[j].second)) {
reverseBit(qx.mb, j);
}
}
if (f[qx.x][qx.y][qx.mb][qx.mt] > f[tx.x][tx.y][tx.mb][tx.mt] + 1) {
f[qx.x][qx.y][qx.mb][qx.mt] = f[tx.x][tx.y][tx.mb][tx.mt] + 1;
q.push(qx);
}
}
}
int res = 0;
for (int b2 = 1; b2 < (1 << k); b2++) {
int total = 0;
for (int t = 0; t < k; t++)
if (getBit(b2, t)) {
total += v[t];
}
res = max(res, total - f[sx][sy][0][b2]);
}
cout << res << endl;
}
| 9 |
#include <bits/stdc++.h>
const int N = 1e6 + 5;
const int mod = 998244353;
using namespace std;
int n, g[N], f[N], fac[N], inv[N], ans;
template <typename T>
inline T read() {
T x = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * w;
}
int C(int n, int m) {
if (n < m || n < 0 || m < 0) return 0;
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int fpow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) res = 1ll * res * x % mod;
return res;
}
int main() {
n = read<int>();
for (int i = (fac[0] = 1); i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = fpow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
for (int i = 0; i <= n; i++) {
if (!i)
g[i] = fpow((fpow(3, n - i) - 3 + mod) % mod, n);
else
g[i] = 1ll * C(n, i) * (fpow(3, i) - (i ? 3 : 0) + mod) % mod *
fpow(3, 1ll * n * (n - i) % (mod - 1)) % mod;
f[i] = 1ll * C(n, i) * 3 % mod * fpow(fpow(3, n - i) - 1, n) % mod;
}
for (int op = 1, i = 0; i <= n; i++, op = mod - op) {
if (!i)
ans = (1ll * op * g[i] + ans) % mod;
else
ans = (1ll * op * (g[i] + f[i]) + ans) % mod;
}
ans = (fpow(3, 1ll * n * n % (mod - 1)) - ans + mod) % mod;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, d, a, b;
struct person {
int x, y, index;
bool operator<(const person &t) const {
return x * a + y * b < t.x * a + t.y * b;
}
};
vector<int> ans;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> d >> a >> b;
vector<person> arr(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i].x >> arr[i].y;
arr[i].index = i + 1;
}
sort(arr.begin(), arr.end());
for (int i = 0; i < n; ++i) {
d -= arr[i].x * a + arr[i].y * b;
if (d >= 0)
ans.push_back(arr[i].index);
else
break;
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); ++i)
cout << ans[i] << " \n"[i == ans.size() - 1];
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1E6 + 77;
const int mod = 1E9 + 7;
long long P[maxn], D[maxn], S[maxn];
long long N, K, ans;
long long Pow(long long v, int p) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * v) % mod;
v = (v * v) % mod;
p >>= 1;
}
return ret;
}
long long Div(long long a, long long b) { return (a * Pow(b, mod - 2)) % mod; }
int main() {
P[0] = 1;
for (int i = 1; i < maxn; ++i) P[i] = (P[i - 1] * i) % mod;
cin >> N >> K;
++K;
for (int i = K + 1; i <= N; ++i) {
D[i] = (i - K) + S[i - 1] - S[i - K];
if (D[i] < 0) D[i] += mod;
if (D[i] >= mod) D[i] -= mod;
if (D[i] >= mod) D[i] -= mod;
S[i] = S[i - 1] + Div(D[i], i - 1);
if (S[i] >= mod) S[i] -= mod;
D[i] = (D[i] * P[i - 2]) % mod;
}
for (int i = K + 1; i <= N; ++i) {
ans += (D[i] * Div(P[N - 1], P[i - 1])) % mod;
if (ans >= mod) ans -= mod;
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 300005;
int q;
int a, b;
char str[Maxn];
int slen;
vector<int> seq;
bool Solve() {
if (seq.empty() || seq[0] < a) return false;
if (seq.size() >= 2 && seq[int(seq.size()) - 2] >= 2 * b &&
seq.back() >= 2 * b)
return false;
if (seq.back() < 2 * b) return int(seq.size()) % 2 != 0;
int len = seq.back();
seq.pop_back();
for (int i = 0; i + a <= len; i++) {
int fir = i, sec = len - (i + a);
if (fir >= 2 * b || sec >= 2 * b) continue;
int mn = Maxn;
if (!seq.empty()) mn = min(mn, seq[0]);
int siz = int(seq.size());
if (fir >= b) {
siz++;
mn = min(mn, fir);
}
if (sec >= b) {
siz++;
mn = min(mn, sec);
}
if (mn >= a && siz % 2 == 0) return true;
}
return false;
}
int main() {
scanf("%d", &q);
while (q--) {
scanf("%d %d", &a, &b);
scanf("%s", str);
slen = strlen(str);
seq.clear();
for (int i = 0; i < slen;)
if (str[i] == 'X')
i++;
else {
int j = i;
while (j < slen && str[i] == str[j]) j++;
if (j - i >= b) seq.push_back(j - i);
i = j;
}
sort(seq.begin(), seq.end());
printf("%s\n", Solve() ? "YES" : "NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll t;
cin >> t;
while (t--) {
ll n, m, k;
cin >> n >> m >> k;
k--;
k--;
if (m > n * (n - 1) / 2 || m < n - 1) {
cout << "nO" << '\n';
continue;
}
if (k > 1) {
if (m > n - 2) {
cout << "yEs" << '\n';
} else
cout << "nO" << '\n';
} else if (k == 1) {
if (m == n * (n - 1) / 2) {
cout << "yEs" << '\n';
} else
cout << "nO" << '\n';
} else if (k == 0) {
if (n == 1)
cout << "yEs" << '\n';
else
cout << "nO" << '\n';
} else
cout << "nO" << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct data {
long long t;
int s, f, r;
} a[100010];
bool operator<(const data &a, const data &b) { return a.t < b.t; }
int n, m, cur;
int F[100010];
long long tg, kq[100010];
set<pair<int, int> > u1, u2, d1, d2;
void nhap() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
scanf("%I64d%d%d", &a[i].t, &a[i].s, &a[i].f), F[i] = a[i].f, a[i].r = i;
}
void chuanbi() {
sort(a + 1, a + n + 1);
cur = 1;
a[n + 1].t = 1ll * 98765432123456;
}
void Push(int x, int y) {
if (x == cur) kq[y] = tg;
if (x > cur) u1.insert(pair<int, int>(x, y));
if (x < cur) d1.insert(pair<int, int>(x, y));
}
int getu(const set<pair<int, int> > &s) {
if (!s.size()) return 987654321;
return (s.begin()->first);
}
int getd(const set<pair<int, int> > &s) {
if (!s.size()) return 0;
return (s.rbegin()->first);
}
void dichuyen(long long cl) {
while (cl) {
if (u1.size() + u2.size() + d1.size() + d2.size() == 0) break;
if (u1.size() + u2.size() >= d1.size() + d2.size()) {
long long dich = min(getu(u1), getu(u2));
dich = min(dich, cur + cl);
tg += dich - cur;
cl -= dich - cur;
cur = dich;
while (u1.size() && u1.begin()->first == dich) {
kq[u1.begin()->second] = tg;
u1.erase(u1.begin());
}
while (u2.size() && u2.begin()->first == dich) {
Push(F[u2.begin()->second], u2.begin()->second);
u2.erase(u2.begin());
}
} else {
long long dich = max(getd(d1), getd(d2));
dich = max(dich, cur - cl);
tg += cur - dich;
cl -= cur - dich;
cur = dich;
while (d1.size() && d1.rbegin()->first == dich) {
kq[d1.rbegin()->second] = tg;
d1.erase(--d1.end());
}
while (d2.size() && d2.rbegin()->first == dich) {
Push(F[d2.rbegin()->second], d2.rbegin()->second);
d2.erase(--d2.end());
}
}
}
}
void xuli() {
for (int i = 1; i <= n; i++) {
tg = a[i].t;
if (cur == a[i].s) Push(a[i].f, a[i].r);
if (cur < a[i].s) u2.insert(pair<int, int>(a[i].s, a[i].r));
if (cur > a[i].s) d2.insert(pair<int, int>(a[i].s, a[i].r));
dichuyen(a[i + 1].t - a[i].t);
}
}
void inkq() {
for (int i = 1; i <= n; i++) printf("%I64d\n", kq[i]);
}
int main() {
nhap();
chuanbi();
xuli();
inkq();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, total = 0, num;
cin >> n;
for (i = 0; i < n; i++) {
cin >> num;
total += num;
if (num != 1) total += (num - 1) * i;
}
cout << total << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
char a[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i][j] = 'S';
if (k <= (n * n + 1) / 2) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i % 2 == 0 && j % 2 == 0 || i % 2 == 1 && j % 2 == 1) {
if (k > 0) {
a[i][j] = 'L';
k--;
}
} else {
a[i][j] = 'S';
}
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << a[i][j];
}
cout << endl;
}
} else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 2000010;
int n, cnt[N], mx = 0;
int pri[N], d[N], ds[N];
bool ty[N];
inline int add(const int &x, const int &y) {
return x + y < mod ? x + y : x + y - mod;
}
inline int sub(const int &x, const int &y) {
return x - y < 0 ? x - y + mod : x - y;
}
inline int mul(const int &x, const int &y) {
return (int)((long long)x * y % mod);
}
inline int Max(const int &x, const int &y) { return x > y ? x : y; }
void mdy(int i, int x) {
x > d[i] ? d[i] = x, ds[i] = 1 : x == d[i] ? ++ds[i] : 0;
}
int main() {
scanf("%d", &n);
for (int i = 1, x; i <= n; i++) scanf("%d", &x), mx = Max(mx, x), ++cnt[x];
for (int i = 2; i <= mx; i++)
if (!pri[i])
for (int j = i; j <= mx; j += i)
if (!pri[j]) pri[j] = i;
int Circle = 1, Pre = 0;
for (int i = mx; i; i--)
for (int j = cnt[i]; j--;) {
if (d[i]) {
for (int x = i - 1; x > 1;) {
int p = pri[x], c = 0;
for (; x % p == 0; x /= p) ++c;
for (int e = d[p]; e < c; ++e) Circle = mul(Circle, p);
mdy(p, c);
}
ty[i] = 1;
} else
mdy(i, 1), Circle = mul(Circle, i);
}
for (int i = mx; i; i--)
if (ty[i]) {
bool flag = 1;
for (int x = i - 1; x > 1;) {
int p = pri[x], c = 0;
for (; x % p == 0; x /= p) ++c;
if (c == d[p] && ds[p] == 1) flag = 0;
}
if (flag) Pre = 1;
}
printf("%d\n", add(Circle, Pre));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VL = vector<LL>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
void dout() { cerr << endl; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << H << ' ';
dout(T...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
VI t(n), x(n);
for (int i = (0); i < (n); ++i) cin >> t[i] >> x[i];
VI ans(n, -1);
map<int, VI> who;
int sz = 0;
int addT = 0;
int mx = 0;
int start_t = 0;
for (int i = (0); i < (n); ++i) {
who[x[i]].push_back(i);
sz++;
mx = max(mx, x[i]);
start_t = max(start_t, t[i]);
if (sz == m || i == n - 1) {
int last = 0;
for (auto [k, v] : who) {
for (auto j : v) {
ans[j] = addT + start_t + k;
last = ans[j];
}
last += 1 + ((int)v.size() / 2);
addT += 1 + ((int)v.size() / 2);
}
start_t = last + mx;
who.clear();
sz = 0;
mx = 0;
addT = 0;
}
}
for (auto x : ans) {
cout << x << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long tavmd(long long a, long long b) {
if (b == 0) {
return 1;
}
if (b % 2 == 0) {
long long x = tavmd(a, b / 2);
return (x * x) % MOD;
} else {
return (a % MOD * tavmd(a, b - 1) % MOD) % MOD;
}
}
const long long lNF = 3e18;
long long dp[1000100], ps[1000100], f[1000100], inv[1000100];
int main() {
;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, k, ans = 0;
cin >> n >> k;
f[0] = 1;
inv[0] = 1;
dp[1] = 1;
for (int j = 1; j < 1000100; j++) {
f[j] = (f[j - 1] * j) % MOD;
inv[j] = tavmd(f[j], MOD - 2);
}
for (int i = 1; i <= n; i++) {
if (k <= i && i != 1) {
dp[i] = (ps[i] - ps[i - k] + MOD) % MOD * f[i - 2] % MOD;
} else if (i != 1)
dp[i] = (ps[i] - ps[0] + MOD) % MOD * f[i - 2] % MOD;
ps[i + 1] = (ps[i] + dp[i] * inv[i - 1]) % MOD;
}
for (int i = 1; i <= n; i++)
ans = (ans + dp[i] * f[n - i] % MOD * f[n - 1] % MOD * inv[n - i] % MOD *
inv[i - 1] % MOD) %
MOD;
cout << (f[n] - ans + MOD) % MOD;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n % 5) % 3 + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int mod = 1e9 + 7;
string s[N];
struct info {
int a, b, a2, b2, a3, b3;
};
void cam(int i, int j) {
if (s[i][j] == '1')
s[i][j] = '0';
else
s[i][j] = '1';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> s[i];
vector<info> ans;
for (int i = 0; i < n - 2; ++i) {
for (int j = 0; j < m - 2; ++j) {
if (s[i][j] == '0') continue;
ans.push_back({i, j, i + 1, j, i, j + 1});
cam(i + 1, j);
cam(i, j + 1);
}
if (s[i][m - 2] == '1' && s[i][m - 1] == '1') {
ans.push_back({i, m - 2, i, m - 1, i + 1, m - 2});
cam(i + 1, m - 2);
} else if (s[i][m - 2] == '0' && s[i][m - 1] == '1') {
ans.push_back({i + 1, m - 1, i, m - 1, i + 1, m - 2});
cam(i + 1, m - 2);
cam(i + 1, m - 1);
} else if (s[i][m - 2] == '1' && s[i][m - 1] == '0') {
ans.push_back({i, m - 2, i + 1, m - 1, i + 1, m - 2});
cam(i + 1, m - 2);
cam(i + 1, m - 1);
}
}
for (int j = 0; j < m - 2; ++j) {
if (s[n - 2][j] == '1' && s[n - 1][j] == '1') {
ans.push_back({n - 2, j, n - 1, j, n - 1, j + 1});
cam(n - 1, j + 1);
} else if (s[n - 2][j] == '0' && s[n - 1][j] == '1') {
ans.push_back({n - 2, j + 1, n - 1, j, n - 1, j + 1});
cam(n - 1, j + 1);
cam(n - 2, j + 1);
} else if (s[n - 2][j] == '1' && s[n - 1][j] == '0') {
ans.push_back({n - 2, j, n - 2, j + 1, n - 1, j + 1});
cam(n - 1, j + 1);
cam(n - 2, j + 1);
}
}
for (int i = 0; i < 4; ++i) {
vector<pair<int, int>> bad, good;
for (int k = n - 2; k < n; ++k) {
for (int h = m - 2; h < m; ++h) {
if (s[k][h] == '1')
bad.push_back({k, h});
else
good.push_back({k, h});
}
}
if (bad.size() == 4 || bad.size() == 3) {
ans.push_back({bad[0].first, bad[0].second, bad[1].first, bad[1].second,
bad[2].first, bad[2].second});
for (int j = 0; j < 3; ++j) cam(bad[j].first, bad[j].second);
} else if (bad.size() == 2 || bad.size() == 1) {
ans.push_back({bad[0].first, bad[0].second, good[0].first,
good[0].second, good[1].first, good[1].second});
for (int j = 0; j < 2; ++j) cam(good[j].first, good[j].second);
cam(bad[0].first, bad[0].second);
} else
break;
}
cout << ans.size() << endl;
for (auto i : ans)
cout << i.a + 1 << ' ' << i.b + 1 << ' ' << i.a2 + 1 << ' ' << i.b2 + 1
<< ' ' << i.a3 + 1 << ' ' << i.b3 + 1 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec[(long long)1e6];
vector<long long> comp;
long long vis[(long long)1e6];
long long dis[(long long)1e6];
long long a[(long long)1e6];
long long DFS(long long x) {
vis[x] = true;
for (long long i = 0; i < vec[x].size(); i++) {
if (!vis[vec[x][i]]) {
DFS(vec[x][i]);
}
}
return x;
}
long long power(long long x, long long y) {
long long temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return (temp * temp) % ((long long)(1e9 + 7));
else
return (x * temp * temp) % (long long)(1e9 + 7);
}
void coding() {
long long i, j, k, l, m, n, t;
cin >> t;
while (t--) {
cin >> n >> k;
vector<long long> v(n), V;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 1; i < n - 1; i++) {
if (v[i] > v[i - 1] && v[i] > v[i + 1]) V.push_back(i);
}
l = 1;
m = 0;
for (int i = 0; i < n - k + 1; i++) {
long long a = upper_bound((V).begin(), (V).end(), i) - V.begin();
long long b = lower_bound((V).begin(), (V).end(), i + k - 1) - V.begin();
if (b - a > m) {
m = b - a;
l = i + 1;
}
}
cout << m + 1 << " " << l << endl;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cout << fixed << setprecision(11);
while (t--) {
coding();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dp[200010], a[200010];
pair<int, int> p[200010];
int tree[200010 << 2];
inline void pushUp(int rt) {
tree[rt] = tree[rt << 1] + tree[rt << 1 | 1];
if (tree[rt] >= 1000000007) tree[rt] -= 1000000007;
}
void update(int x, int val, int L, int R, int rt) {
if (L == R) {
tree[rt] += val;
if (tree[rt] >= 1000000007) tree[rt] -= 1000000007;
} else {
int mid = (L + R) >> 1;
if (x <= mid)
update(x, val, L, mid, rt << 1);
else
update(x, val, mid + 1, R, rt << 1 | 1);
pushUp(rt);
}
}
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int query(int x, int y, int L, int R, int rt) {
if (x <= L && R <= y) return tree[rt];
int mid = (L + R) >> 1, ans = 0;
if (x <= mid) ans += query(x, y, L, mid, rt << 1);
if (y > mid) ans += query(x, y, mid + 1, R, rt << 1 | 1);
if (ans >= 1000000007) ans -= 1000000007;
return ans;
}
int main() {
int n, m, cnt, i, j;
while (~scanf("%d%d", &n, &m)) {
for (i = cnt = 0; i < m; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
a[cnt++] = p[i].first;
a[cnt++] = p[i].second;
}
a[cnt++] = 0;
a[cnt++] = n;
sort(a, a + cnt);
cnt = unique(a, a + cnt) - a;
n = lower_bound(a, a + cnt, n) - a;
memset(dp, 0, sizeof(dp));
memset(tree, 0, sizeof(tree));
for (i = 0; i < m; i++) {
p[i].first = lower_bound(a, a + cnt, p[i].first) - a;
p[i].second = lower_bound(a, a + cnt, p[i].second) - a;
}
sort(p, p + m, cmp);
dp[0] = 1;
update(0, dp[0], 0, cnt - 1, 1);
for (i = 0; i < m; i = j) {
for (j = i; j < m && p[i].second == p[j].second; j++) {
dp[p[j].second] += query(p[j].first, p[j].second, 0, cnt - 1, 1);
if (dp[p[j].second] >= 1000000007) dp[p[j].second] -= 1000000007;
}
update(p[i].second, dp[p[i].second], 0, cnt - 1, 1);
}
printf("%d\n", dp[n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unordered_map<char, int> rank;
rank.insert(make_pair('6', 1));
rank.insert(make_pair('7', 2));
rank.insert(make_pair('8', 3));
rank.insert(make_pair('9', 4));
rank.insert(make_pair('T', 5));
rank.insert(make_pair('J', 6));
rank.insert(make_pair('Q', 7));
rank.insert(make_pair('K', 8));
rank.insert(make_pair('A', 9));
unordered_map<char, int> suit;
suit.insert(make_pair('S', 0));
suit.insert(make_pair('H', 0));
suit.insert(make_pair('D', 0));
suit.insert(make_pair('C', 0));
char c;
string s1, s2;
cin >> c;
suit[c]++;
cin >> s1 >> s2;
if ((suit[s1[1]] > suit[s2[1]]) ||
(s1[1] == s2[1] && rank[s1[0]] > rank[s2[0]]))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int powmod(int a, int l, int md) {
a %= md;
int res = 1;
while (l) {
if (l & 1) res = res * a % md;
l /= 2;
a = a * a % md;
}
return res;
}
int binpow(int a, int l) {
int res = 1;
while (l) {
if (l & 1) res = res * a;
l /= 2;
a = a * a;
}
return res;
}
int invmod(int a, int md) { return powmod(a, md - 2, md); }
int __set(int b, int i) { return b | (1LL << i); }
int __unset(int b, int i) { return b & (~(1UL << i)); }
int __check(int b, int i) { return b & (1LL << i); }
int mulmod(int a, int b, int md) {
return (((a % md) * (b % md)) % md + md) % md;
}
int addmod(int a, int b, int md) { return ((a % md + b % md) % md + md) % md; }
int submod(int a, int b, int md) {
return (((a % md - b % md) % md) + md) % md;
}
int divmod(int a, int b, int md) {
return mulmod(a, powmod(b, md - 2, md), md);
}
const long long inf = 0xFFFFFFFFFFFFFFFL;
priority_queue<int, vector<int>, greater<int> > pq;
int n, m, sq;
vector<vector<int> > g(200010);
vector<vector<int> > back(200010);
int seen[200010], parent[200010], dis[200010], color[200010];
void dfs(int u) {
seen[u] = 1;
for (int v : g[u]) {
if (seen[v]) {
back[u].push_back(v);
}
}
if ((int)(back[u].size()) >= sq - 1) {
int ed;
for (int i = 0; i < (int)(back[u].size()); i++) {
if (dis[u] - dis[back[u][i]] >= sq - 1) {
ed = back[u][i];
break;
}
}
cout << 2 << "\n" << dis[u] - dis[ed] + 1 << "\n";
while (u != ed) {
cout << u + 1 << " ";
u = parent[u];
}
cout << ed + 1 << "\n";
exit(0);
}
int cc = -1, occ[450] = {};
for (int v : back[u]) {
occ[color[v]] = 1;
}
for (int i = 0; i < 450; i++) {
if (!occ[i]) {
cc = i;
break;
}
}
color[u] = cc;
for (int v : g[u]) {
if (!seen[v]) {
dis[v] = dis[u] + 1;
parent[v] = u;
dfs(v);
}
}
}
signed main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
sq = (int)sqrt(n);
if (sq * sq != n) sq++;
dfs(0);
cout << 1 << "\n";
for (int i = 0; i < sq; i++) {
vector<int> tmp;
for (int j = 0; j < n; j++)
if (color[j] == i) tmp.push_back(j);
if ((int)(tmp.size()) >= sq) {
for (int j = 0; j < sq; j++) cout << tmp[j] + 1 << " ";
cout << "\n";
return 0;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(false);
long long friends;
std::cin >> friends;
long long w[friends], h[friends], hp[friends + 1], hs[friends + 1];
long long wsum = 0;
for (long long i = 0; i < friends; i++) {
std::cin >> w[i] >> h[i];
wsum += w[i];
}
hs[friends] = 0;
hp[0] = 0;
for (long long i = friends - 1; i >= 0; i--) {
hs[i] = std::max(hs[i + 1], h[i]);
}
for (long long i = 1; i < friends; i++) {
hp[i] = std::max(hp[i - 1], h[i - 1]);
}
for (long long i = 0; i < friends; i++) {
std::cout << (wsum - w[i]) * std::max(hp[i], hs[i + 1]) << ' ';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double OO = 1e18;
const double eps = 1e-10;
const long long one = 1000000LL;
int n, t;
struct problem {
long long scsmall, sclarge, tsmall, tlarge;
double pfail;
bool operator<(const problem &st) const {
double t1 = tlarge * (1.0 - pfail) * st.pfail +
(tlarge + st.tlarge) * (1.0 - st.pfail);
double t2 = st.tlarge * (1.0 - st.pfail) * pfail +
(st.tlarge + tlarge) * (1.0 - pfail);
return t1 < t2;
}
};
int dcmp(double a, double b) {
if (fabs(a - b) < eps) return 0;
return a < b ? -1 : 1;
}
void update(pair<long long, double> &m, pair<long long, double> r) {
if (r.first > m.first || (r.first == m.first && dcmp(r.second, m.second) < 0))
m = r;
}
vector<problem> v;
pair<long long, double> memo[1002][1600];
pair<long long, double> DP(int siz, int remt) {
if (remt < 0) return make_pair(((long long)-OO), (-OO));
if (siz == 0)
return remt ? make_pair(((long long)-OO), (-OO)) : make_pair((0LL), (0.0));
int idx = siz - 1;
pair<long long, double> &m = memo[idx][remt];
if (m.first != -1) return m;
m = DP(siz - 1, remt);
pair<long long, double> r = DP(siz - 1, remt - v[idx].tsmall);
r.first += v[idx].scsmall * one;
r.second += v[idx].tsmall;
update(m, r);
r = DP(siz - 1, remt - v[idx].tsmall - v[idx].tlarge);
r.second += v[idx].tsmall;
r.first +=
v[idx].scsmall * one + one * v[idx].sclarge * (1.0 - v[idx].pfail + eps);
r.second = r.second * (v[idx].pfail) + remt * (1.0 - v[idx].pfail);
update(m, r);
return m;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> t;
v.resize(n);
double d;
for (int i = 0; i < n; i++) {
cin >> v[i].scsmall >> v[i].sclarge >> v[i].tsmall >> v[i].tlarge >>
v[i].pfail;
}
sort((v).begin(), (v).end());
memset((memo), (-1), sizeof(memo));
pair<long long, double> m = make_pair((0LL), (0.0));
for (int i = 1; i <= t; i += 1) {
pair<long long, double> r = DP(n, i);
update(m, r);
}
printf("%.10lf %.10lf\n", (1.0 * m.first) / one, m.second);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int lowbit(int x) { return x & (-x); }
inline int read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
inline int gcd(int a, int b) { return a % b ? gcd(b, a % b) : b; }
inline int lcm(int a, int b) { return a / gcd(a, b) * b; }
template <typename T>
inline T max(T x, T y, T z) {
return max(max(x, y), z);
}
template <typename T>
inline T min(T x, T y, T z) {
return min(min(x, y), z);
}
template <typename A, typename B, typename C>
inline A fpow(A x, B p, C lyd) {
A ans = 1;
for (; p; p >>= 1, x = 1LL * x * x % lyd)
if (p & 1) ans = 1LL * x * ans % lyd;
return ans;
}
const int N = 100005;
int a[N], n;
long long ans;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
ans += 1LL * a[1] * (n - a[1] + 1);
for (int i = 2; i <= n; i++) {
if (a[i] < a[i - 1])
ans += 1LL * a[i] * (a[i - 1] - a[i]);
else if (a[i] > a[i - 1])
ans += 1LL * (a[i] - a[i - 1]) * (n - a[i] + 1);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, ai;
vector<vector<long long> > data;
vector<deque<vector<long long> > > lengths;
vector<deque<long long> > treb, how;
vector<deque<vector<pair<long long, long long> > > > pluss;
vector<long long> answer, where, ls;
vector<long long> freem;
bool cmp(long long first, long long second) { return (ls[first] > ls[second]); }
void up(long long deq) {
long long wanted = 0;
long long hwanted = 0;
for (long long i = 0; i < lengths[deq].size(); i++) {
wanted += treb[deq][i];
hwanted += how[deq][i];
wanted += hwanted * lengths[deq][i].size();
treb[deq][i] = 0;
how[deq][i] = 0;
if (wanted > 0)
pluss[deq][i].push_back(make_pair(wanted, lengths[deq][i].size() - 1));
}
for (long long i = 0; i < lengths[deq].size(); i++) {
long long summ = 0;
for (long long j = 0; j < pluss[deq][i].size(); j++) {
summ += pluss[deq][i][j].first;
}
long long ind = 0;
for (long long j = 0; j < lengths[deq][i].size(); j++) {
while (ind < pluss[deq][i].size() && pluss[deq][i][ind].second < j) {
summ -= pluss[deq][i][ind].first;
ind++;
}
long long num = lengths[deq][i][j];
answer[num] += summ;
}
}
}
void clear_l(long long ind) {
for (long long i = 0; i < lengths[ind].size(); i++) {
lengths[ind][i].clear();
}
lengths[ind].clear();
}
void clear_p(long long ind) {
for (long long i = 0; i < pluss[ind].size(); i++) {
pluss[ind][i].clear();
}
pluss[ind].clear();
}
void dfs(long long vertex, long long sz) {
if (data[vertex].size() == 0) {
deque<vector<long long> > d;
deque<long long> d1, d2;
deque<vector<pair<long long, long long> > > pp;
vector<pair<long long, long long> > hp;
hp.push_back(make_pair(1, 0));
pp.push_back(hp);
vector<long long> add1;
add1.push_back(vertex);
d.push_back(add1);
d1.push_back(0);
d2.push_back(0);
if (freem.size() == 0) {
pluss.push_back(pp);
lengths.push_back(d);
treb.push_back(d2);
how.push_back(d1);
where[vertex] = lengths.size() - 1;
} else {
long long hind = freem.back();
freem.pop_back();
pluss[hind] = pp;
lengths[hind] = d;
treb[hind] = d2;
how[hind] = d1;
where[vertex] = hind;
}
return;
}
dfs(data[vertex][0], sz + 1);
long long hero = data[vertex][0];
long long when = 0;
if (data[vertex].size() > 1) {
when = ls[data[vertex][1]] - sz;
}
long long heros = where[hero];
where[vertex] = heros;
long long wanted = 0;
long long hwanted = 0;
for (long long i = 0; i < when; i++) {
wanted += treb[heros][i];
hwanted += how[heros][i];
wanted += hwanted * lengths[heros][i].size();
treb[heros][i] = 0;
how[heros][i] = 0;
if (wanted > 0)
pluss[heros][i].push_back(
make_pair(wanted, lengths[heros][i].size() - 1));
}
if (when != lengths[heros].size()) {
treb[heros][when] += wanted;
how[heros][when] += hwanted;
}
for (long long i = 1; i < data[vertex].size(); i++) {
long long to = data[vertex][i];
dfs(to, sz + 1);
long long tt = where[to];
up(tt);
for (long long j = 0; j < lengths[tt].size(); j++) {
for (long long k = 0; k < lengths[tt][j].size(); k++) {
lengths[heros][j].push_back(lengths[tt][j][k]);
}
}
clear_l(tt);
clear_p(tt);
treb[tt].clear();
how[tt].clear();
freem.push_back(tt);
}
vector<long long> d;
vector<pair<long long, long long> > pp;
pluss[heros].push_front(pp);
d.push_back(vertex);
lengths[heros].push_front(d);
treb[heros].push_front(0);
how[heros].push_front(0);
when++;
long long nn = 0;
for (long long i = 0; i < when; i++) {
nn += lengths[heros][i].size();
pluss[heros][i].push_back(make_pair(nn, lengths[heros][i].size() - 1));
}
if (when != lengths[heros].size()) {
treb[heros][when] += nn;
how[heros][when]++;
}
}
void dfs3(long long vertex, long long ll) {
answer[vertex] -= ll;
for (long long i = 0; i < data[vertex].size(); i++) {
long long to = data[vertex][i];
dfs3(to, ll + 1);
}
}
long long dfs2(long long vertex, long long ll) {
long long mm = ll;
for (long long i = 0; i < data[vertex].size(); i++) {
long long to = data[vertex][i];
mm = max(mm, dfs2(to, ll + 1));
}
ls[vertex] = mm;
return mm;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 0; i < n; i++) {
vector<long long> help;
data.push_back(help);
answer.push_back(0);
where.push_back(-1);
ls.push_back(-1);
}
long long dyr;
for (long long i = 0; i < n; i++) {
cin >> ai;
if (ai == 0) {
dyr = i;
continue;
}
data[ai - 1].push_back(i);
}
dfs2(dyr, 1);
for (long long i = 0; i < n; i++) {
sort(data[i].begin(), data[i].end(), cmp);
}
dfs(dyr, 1);
up(where[dyr]);
dfs3(dyr, 1);
for (long long i = 0; i < n; i++) {
cout << answer[i] << " ";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double t1, t2, num, n, l, v1, v2, k;
cin >> n >> l >> v1 >> v2 >> k;
num = (int)n / (int)k + ((int)n % (int)k != 0);
t2 = l / ((1 + (v2 - v1) / (v2 + v1)) * (num - 1) * v1 + v2);
t1 = (l - t2 * v2) / v1;
printf("%.10lf", t1 + t2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
string s[n + 1];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
getchar();
vector<int> v;
for (int i = 0; i < n; i++) {
string b;
getline(cin, b);
int count = 0;
for (int j = 0; j < b.length(); j++) {
if (b[j] == 'a' || b[j] == 'e' || b[j] == 'i' || b[j] == 'o' ||
b[j] == 'u' || b[j] == 'y') {
count++;
}
}
v.push_back(count);
}
for (int i = 0; i < n; i++) {
if (a[i] != v[i]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#endif
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef std::vector<vector<int> > vvi;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
typedef vector<vll> vvll;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<ld> vld;
typedef vector<vld> vvld;
typedef vector<bool> vb;
typedef vector<vb> vvb;
#define rep(i, a, b) for (int i = (int)a; i < (int)b; i++)
#define repi(i, a, b) for (int i = (int)a; i >= (int)b; i--)
#define pb push_back
#define fi first
#define se second
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a.size())
#define umin(a, x) a = min(a, x)
#define umax(a, x) a = max(a, x)
ll nxt() {
ll x; cin >> x; return x;
}
void setIO(string s) {
#ifndef LOCAL
ios_base::sync_with_stdio(0); cin.tie(0);
freopen((s+".in").c_str(),"r",stdin);
freopen((s+".out").c_str(),"w",stdout);
#endif
}
const int inf = 1e9;
struct SegmentTree
{
vi a, t;
int n;
SegmentTree(int n): n(n){
a.resize(n+1, inf);
t.resize(4*n+1, inf);
}
void update(int pos, int val){
updatehelper(pos, val, 1, 1, n); //pos, val, node, left, right
//node is the index in the tree
}
int get(int l, int r){
return gethelper(l, r, 1, 1, n);
}
void updatehelper(int pos, int val, int node, int left, int right){
if(pos < left || pos > right) return;
else if(left == right){
a[pos] = val;
t[node] = val;
}
else{
updatehelper(pos, val, 2*node, left, (left+right)/2);
updatehelper(pos, val, 2*node + 1, (left+right)/2 + 1, right);
t[node] = min(t[2*node], t[2*node+1]);
}
}
int gethelper(int l, int r, int node, int left, int right){
if(r < left || l > right) return inf;
else if( l <= left && right <= r) return t[node];
else{
return min(gethelper(l, r, 2*node, left, (left + right)/2), gethelper(l, r, 2*node+1, (left+right)/2 + 1, right));
}
}
};
void solve() {
int n = nxt();
SegmentTree seg(n + 2);
vi a(n + 1); rep(i, 1, n + 1) {
cin >> a[i];
seg.update(i, a[i]);
}
vi pref_max(n + 2), suf_max(n + 2);
map<int, int> first_occ, last_occ;
rep(i, 1, n + 1) {
pref_max[i] = max(pref_max[i - 1], a[i]);
int x = suf_max[n - i + 1] = max(suf_max[n - i + 2], a[n - i + 1]);
if (!last_occ.count(x)) {
last_occ[x] = n - i + 1;
}
first_occ[x] = n - i + 1;
}
suf_max[0] = inf;
vi negs = suf_max;
rep(i, 0, sz(negs)) negs[i] = -suf_max[i];
debug("###############");
debug(n, a);
debug(suf_max);
debug(first_occ);
debug(last_occ);
rep(x, 1, n - 1) {
int cur = pref_max[x];
int id1, id2;
if (first_occ.count(cur)) {
id1 = first_occ[cur];
id2 = last_occ[cur];
id1 = max(x + 1, id1);
if (id2 < id1) continue;
} else {
continue;
}
int lo = max(id1 - 1, x + 1), hi = max(id2 - 1, x + 1);
assert(id1 >= x + 1 && id1 <= id2);
debug(x, cur, lo, hi);
while (lo < hi) {
int mid = (lo + hi) / 2;
int mn = seg.get(x + 1, mid);
if (mn > cur) {
lo = mid + 1;
} else {
hi = mid;
}
}
assert(lo == hi);
if (lo >= x + 1 && lo < id2 && seg.get(x + 1, lo) == cur) {
cout << "YES\n";
int y = lo - x, z = n - lo;
cout << x << " " << lo - x << " " << n - lo << "\n";
debug(id1, id2, cur);
assert(x >= 1 && y >= 1 && z >= 1 && x + y + z == n);
assert(pref_max[x] == suf_max[n - z + 1]
&& pref_max[x] == seg.get(x + 1, x + y));
return;
}
}
cout << "NO\n";
}
int32_t main(){
// setIO("trapped");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(10);
int T = 1;
cin >> T;
for (int tc = 1; tc <= T; tc++) {
// cout << "Case #" << tc << ": ";
solve();
}
}
| 6 |
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
int n;
bool has[2020];
void check(int now){
int lb = 0, ub = now - 1;
while(lb <= ub){
int mid = (lb + ub) >> 1;
cout << "? " << mid + 1 << " 1" << endl;
rep(i, mid+1) cout << i+1 << " ";
cout << endl;
cout << now + 1 << endl;
int ans;
cin >> ans;
if(ans != 0) ub = mid - 1;
else lb = mid + 1;
}
has[lb] = 1;
has[now] = 1;
for(int i = now + 1; i < n; i++){
cout << "? 1 1" << endl;
cout << i+1 << endl;
cout << now+1 << endl;
int ans;
cin >> ans;
if(ans != 0) has[i] = 1;
}
cout << "! ";
vector<int> ans;
rep(i, n) if(!has[i]) ans.push_back(i + 1);
cout << (int)ans.size() << " ";
rep(i, (int)ans.size()) cout << ans[i] << " ";
cout << endl;
}
int main(){
ios::sync_with_stdio(false);
int T;
cin >> T;
while(T--){
memset(has, 0, sizeof(has));
cin >> n;
for(int i = 1; i < n; i++){
cout << "? " << i << " 1" << endl;
for(int j = 0; j < i; j++) cout << j + 1 << " ";
cout << endl;
cout << i+1 << endl;
int ans;
cin >> ans;
if(ans != 0){
check(i);
break;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T = int>
T input() {
T res;
cin >> res;
return res;
}
template <typename It>
void input_seq(It begin, It end, istream &in = cin) {
generate(begin, end,
input<typename remove_reference<decltype(*begin)>::type>);
}
template <class It>
void output(It begin, It end, ostream &out = cerr) {
while (begin != end) {
out << *(begin++) << ' ';
}
out << endl;
}
constexpr int N = 100;
long double tmp[N];
int to[N];
int num(int i, int j) {
if (i % 2 == 0) {
return N - 10 * i - j - 1;
}
return N - 10 * (i + 1) + j;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
for (int i = 0; i < 10; ++i) {
for (int j = 0; j < 10; ++j) {
int t = input();
if (t) {
to[num(i, j)] = num(i - t, j);
}
}
}
tmp[98] = 6;
tmp[97] = 6;
tmp[96] = 6;
tmp[95] = 6;
tmp[94] = 6;
for (int i = 93; i >= 0; --i) {
for (int r = 1; r <= 6; ++r) {
if (to[i + r]) {
tmp[i] += (1.l / 6) * min(tmp[i + r] + 1, tmp[to[i + r]] + 1);
} else {
tmp[i] += (1.l / 6) * (tmp[i + r] + 1);
}
}
}
cout << fixed << setprecision(10) << tmp[0] << endl;
}
| 7 |
#include <bits/stdc++.h>
int a[100009], hash[100009];
int main() {
int i, n, k, cot, p, min;
scanf("%d%d", &n, &k);
memset(hash, 0, sizeof(int));
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
cot = i % k;
hash[cot] += a[i];
}
min = hash[0], p = 0;
for (i = 0; i < k; i++) {
if (hash[i] < min) {
min = hash[i];
p = i;
}
}
printf("%d\n", p + 1);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2100;
long long a[maxn], b[maxn];
long long pre[maxn];
long long ini[maxn];
long long bn[maxn];
int k, n;
set<long long> ans, init, bset, tmp;
bool bs(long long des) {
int l = 0, r = n - 1;
while (l <= r) {
int m = (l + r) / 2;
if (b[m] == des) {
return true;
}
if (b[m] < des) {
l = m + 1;
} else if (b[m] > des) {
r = m - 1;
}
}
return false;
}
int main() {
scanf("%d%d", &k, &n);
for (int i = 0; i < k; i++) {
scanf("%I64d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%I64d", &b[i]);
bset.insert(b[i]);
}
pre[0] = a[0];
for (int i = 1; i < k; i++) {
pre[i] = pre[i - 1] + a[i];
}
for (int i = 0; i < k; i++) {
ini[i] = b[0] - pre[i];
init.insert(ini[i]);
}
sort(b, b + n);
for (auto it = init.begin(); it != init.end(); it++) {
long long cur = *it;
int num = 0;
tmp.clear();
for (int j = 0; j < k; j++) {
if (bs(cur + pre[j])) {
tmp.insert(cur + pre[j]);
if (tmp.size() == n) {
ans.insert(cur);
break;
}
continue;
}
}
}
printf("%d\n", ans.size());
return 0;
}
| 4 |
#include <iostream>
#include <vector>
#include <bits/stdc++.h>
#include <string.h>
#include <algorithm>
#include <math.h>
using namespace std;
#define ll long long int
#define lll unsigned long long
#define ssl signed long long
#define pb push_back
bool sortcol( const vector<int>& v1, const vector<int>& v2 ) {
return v1[1] < v2[1];
}
lll gcd(lll a, lll b)
{
// Everything divides 0
if (a == 0)
return b;
if (b == 0)
return a;
// base case
if (a == b)
return a;
// a is greater
if (a > b)
return gcd(a-b, b);
return gcd(a, b-a);
}
int32_t main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--){
ll n;
cin>>n;
string s;
cin>>s;
int t=0,m=0;
bool flag=true;
for(int i=0;i<s.length();i++){
if(s[i]=='T')
t++;
else
m++;
if(m>t && flag==true){
flag=false;
}
}
if(t%2==1 || flag==false || m*2!=t){
cout<<"NO"<<endl;
continue;
}
t=m;
for(int i=0;i<n;i++){
if(s[i]=='T')
t--;
else
t++;
if(t<0){
break;
}
}
if(t<0){
cout<<"NO"<<endl;
}
else
cout<<"YES"<<endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e9 + 5;
int main() {
long long a, b, c;
long long answer;
cin >> a >> b >> c;
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
if (c % 2 == b % 2) answer = c;
if (c % 2 == a % 2) answer = c;
if (b % 2 == a % 2) answer = b;
cout << answer << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long n) {
for (int i = 2; (long long int)i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int findgrouplcm(long long int arr[], long long int n) {
long long int ans = arr[0];
for (long long int i = 1; i < n; i++)
ans = (arr[i] * (ans / (gcd(arr[i], ans))));
return ans;
}
void solve(int n, long long int s[], long long int p[]);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
long long int a, b, count = 0;
cin >> (a) >> b;
while (b != 0) {
count += a / b;
a %= b;
swap(a, b);
}
cout << (count);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, top = 0, i, b;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &b);
top += b;
}
printf("%lf", (double)top / n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, L, a, t, l, s = 0, b = 0;
scanf("%d %d %d", &n, &L, &a);
for (int i = 0; i < n; i++) {
scanf("%d %d", &t, &l);
b += (t - s) / a;
s = t + l;
}
b += (L - s) / a;
printf("%d\n", b);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int l, r, k;
cin >> l >> r >> k;
--l, --r, --k;
k %= (r - l + 1);
rotate(s.begin() + l, s.begin() + r - k, s.begin() + r + 1);
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 3;
int n;
int typ[N], val[N], chg[N], sum[N];
int kid[N][2];
char opt[5];
void dfs1(int p);
void dfs2(int p);
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%s", opt);
if (opt[0] == 'A') typ[i] = 1;
if (opt[0] == 'O') typ[i] = 2;
if (opt[0] == 'X') typ[i] = 3;
if (opt[0] == 'N') typ[i] = 4;
if (opt[0] == 'I')
scanf("%d", val + i);
else {
scanf("%d", kid[i]);
if (opt[0] != 'N') scanf("%d", kid[i] + 1);
}
}
dfs1(1);
dfs2(1);
for (int i = 2; i <= n; ++i)
if (!typ[i]) printf("%d", sum[i] ^ val[1]);
return 0;
}
void dfs1(int p) {
if (kid[p][0]) dfs1(kid[p][0]);
if (kid[p][1]) dfs1(kid[p][1]);
if (typ[p] == 1) {
val[p] = val[kid[p][0]] & val[kid[p][1]];
if (val[kid[p][0]] + val[kid[p][1]] == 2)
chg[kid[p][0]] = chg[kid[p][1]] = 1;
if (val[kid[p][0]] + val[kid[p][1]] == 1)
chg[kid[p][0]] = val[kid[p][0]] ^ 1, chg[kid[p][1]] = val[kid[p][1]] ^ 1;
}
if (typ[p] == 2) {
val[p] = val[kid[p][0]] | val[kid[p][1]];
if (val[kid[p][0]] + val[kid[p][1]] == 0)
chg[kid[p][0]] = chg[kid[p][1]] = 1;
if (val[kid[p][0]] + val[kid[p][1]] == 1)
chg[kid[p][0]] = val[kid[p][0]], chg[kid[p][1]] = val[kid[p][1]];
}
if (typ[p] == 3)
val[p] = val[kid[p][0]] ^ val[kid[p][1]],
chg[kid[p][0]] = chg[kid[p][1]] = 1;
if (typ[p] == 4) val[p] = !val[kid[p][0]], chg[kid[p][0]] = 1;
}
void dfs2(int p) {
sum[p] = 1;
if (kid[p][0] && chg[kid[p][0]]) dfs2(kid[p][0]);
if (kid[p][1] && chg[kid[p][1]]) dfs2(kid[p][1]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n;
int a[n + 1];
for (i = 1; i <= n; i++) cin >> a[i];
cin >> m;
int x[m + 1], y[m + 1];
for (i = 1; i <= m; i++) cin >> x[i] >> y[i];
for (i = 1; i <= m; i++) {
a[x[i] - 1] = y[i] - 1 + a[x[i] - 1];
a[x[i] + 1] = a[x[i]] - y[i] + a[x[i] + 1];
a[x[i]] = 0;
}
for (i = 1; i <= n; i++) cout << a[i] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int a[105];
int main() {
int n, m, i, k, max, t;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 0; i < n; i++) scanf("%d", &a[i]);
if (a[0] > m) {
if (a[0] % m == 0)
max = a[0] / m;
else
max = a[0] / m + 1;
} else
max = 1;
k = 0;
for (i = 1; i < n; i++) {
if (a[i] > m) {
if (a[i] % m == 0)
t = a[i] / m;
else
t = a[i] / m + 1;
} else
t = 1;
if (max <= t) {
max = t;
k = i;
}
}
printf("%d\n", k + 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int d[3100][3100];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
vector<long double> p(n);
vector<int> pref(n);
vector<int> full(n);
for (long double &e : p) {
cin >> e;
}
pref[n - 1] = p[n - 1] != 0;
for (int i = n - 2; i >= 0; i--) {
pref[i] = pref[i + 1] + (p[i] != 0);
}
full[n - 1] = p[n - 1] == 100;
for (int i = n - 2; i >= 0; i--) {
full[i] = full[i + 1] + (p[i] == 100);
}
queue<pair<int, int>> q;
q.push({0, 1});
int cnt = 0;
d[0][1] = 1;
while (!q.empty()) {
pair<int, int> t = q.front();
q.pop();
cnt++;
if (t.first == n || t.second == n) {
continue;
}
if (d[t.first][t.second] == k + 1) {
continue;
}
if (p[t.first] > 0 && full[t.second] == 0 && !d[t.first][t.second + 1]) {
d[t.first][t.second + 1] = d[t.first][t.second] + 1;
q.push({t.first, t.second + 1});
}
if (p[t.first] > 0 && pref[t.second] > 0 &&
!d[t.second + 1][t.second + 2]) {
d[t.second + 1][t.second + 2] = d[t.first][t.second] + 1;
q.push({t.second + 1, t.second + 2});
}
if (pref[t.second] > 0 && p[t.first] != 100 && !d[t.second][t.second + 1]) {
d[t.second][t.second + 1] = d[t.first][t.second] + 1;
q.push({t.second, t.second + 1});
}
}
cout << cnt;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 110;
int a[MAX];
double dist(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int main() {
int i, j, k;
int p, q;
int n;
int t0, t1, t2;
int x1, x2;
double r3, r4;
int r2, r1;
int x, y;
map<int, int> m;
map<int, int>::iterator it;
while (scanf("%d%d%d%d%d", &t1, &t2, &x1, &x2, &t0) != EOF) {
if (t1 == t0) {
if (t2 == t1) {
printf("%d %d\n", x1, x2);
} else {
printf("%d 0\n", x1);
}
} else if (t2 == t0 || (long long)(t0 - t1) > (long long)(t2 - t0) * x2) {
printf("0 %d\n", x2);
} else {
t2 -= t1;
t0 -= t1;
t2 -= t0;
r4 = 100000000;
for (i = 1; i <= x1; i++) {
r2 = ((long long)(t0)*i + t2 - 1) / t2;
if (r2 > x2) {
break;
}
r3 = (double)(t2 + t0) * r2 / (i + r2);
if (r4 + 0.0000001 >= r3) {
y = r2;
x = i;
r4 = r3;
}
}
printf("%d %d\n", x, y);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long d, k, a, b, t;
cin >> d >> k >> a >> b >> t;
if (d <= k)
cout << d * a;
else {
long long cnt = d / k;
cout << min(k * a + (d - k) * b,
cnt * (k * a + t) + min(d % k * b - t, d % k * a));
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &a, &b);
if (a == b)
cout << 0 << endl;
else {
if (a < b && (b - a) % 2)
cout << 1 << endl;
else if (a > b && (a - b) % 2 == 0)
cout << 1 << endl;
else
cout << 2 << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 9;
int a[MAX], x[2 * MAX], y[MAX], pf[MAX];
vector<int> ans;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) x[i] = a[i + 1] - a[i];
x[n - 1] = a[0] + m - a[n - 1];
for (int i = 0, j = n - 1; i < n; i++, j--) x[n + i] = y[j] = x[i];
for (int i = 1, k = 0; i < n; i++) {
while (k && y[i] != y[k]) k = pf[k];
if (y[i] == y[k]) k++;
pf[i + 1] = k;
}
for (int i = 0, k = 0; i < 2 * n - 1; i++) {
while (k && x[i] != y[k]) k = pf[k];
if (x[i] == y[k]) k++;
if (k == n) {
ans.push_back((a[0] + a[i - k + 1]) % m);
k = pf[k];
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int v : ans) cout << v << ' ';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const ll mod = 1000000007;
const ll M = 1000000000000000000ll;
inline ll add(ll a, ll b) { return ((a % mod + b % mod) % mod); }
inline ll sub(ll a, ll b) { return ((a % mod - b % mod + mod) % mod); }
inline ll mult(ll a, ll b) { return (((a % mod) * (b % mod)) % mod); }
inline ll power(ll n, ll x) {
ll p = 1;
while (x != 0) {
if (x % 2 == 0) {
n = mult(n, n);
x = x / 2;
}
p = mult(p, n);
x--;
}
return p;
}
inline ll recurmult(ll a, ll b) {
ll r = 0;
while (b) {
if (b & 1) r = add(r, a);
a = mult(2, a);
b >>= 1;
}
return r % mod;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ll n;
cin >> n;
multiset<pair<ll, ll>> m;
for (ll i = 0; i < n; i++) {
ll x;
cin >> x;
m.insert({x, i + 1});
}
map<ll, ll> ans;
while (!m.empty()) {
pair<ll, ll> t1 = (*m.begin());
m.erase(m.begin());
if (m.empty()) {
ans[t1.second] = t1.first;
break;
}
pair<ll, ll> t2 = (*m.begin());
if (t1.first == t2.first) {
m.erase(m.begin());
m.insert({t2.first * 2, t2.second});
} else
ans[t1.second] = t1.first;
}
cout << ans.size() << "\n";
for (auto it : ans) cout << it.second << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
long long int min(long long int a, long long int b) {
if (a < b)
return a;
else
return b;
}
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
int XX[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int YY[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int k, i, j, t, a, b, l, r, x, n;
cin >> n >> k;
long long int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long int maxi = k, count = 0;
for (i = 0; i < n; i++) {
long long int z = ceil(arr[i] * 1.0 / 2);
if (maxi >= z) {
maxi = max(maxi, arr[i]);
continue;
}
while (maxi < z) {
maxi = 2 * maxi;
count++;
}
maxi = max(maxi, arr[i]);
}
cout << count;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string button1(string s) {
for (int i = 0; i < s.size(); i++) {
int n = s[i] - '0';
n++;
n = n % 10;
s[i] = (char)(n + '0');
}
return s;
}
string button2(string s) {
char a = s[0];
for (int i = 1; i < s.size(); i++) {
char b = s[i];
s[i] = a;
a = b;
}
s[0] = a;
return s;
}
int main() {
int n;
scanf("%d", &n);
string s, t;
cin >> s;
t.resize(s.size(), '9');
for (int i = 0; i < 10; i++) {
for (int j = 0; j < s.size(); j++) {
s = button2(s);
if (s < t) t = s;
}
s = button1(s);
}
printf("%s\n", t.c_str());
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 0.000001;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
while (cin >> n >> m) {
if ((m == 0 || m == 1) && n) {
cout << "no" << endl;
continue;
}
n -= m - 1;
if (n < 0 || (n & 1))
cout << "no" << endl;
else
cout << "yes" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int p[51][51];
int a[51];
int pos[51];
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cin >> p[i][j];
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) pos[i] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (p[i][j] == k) pos[j]++;
}
}
int max = 0;
int max_idx = 0;
for (int i = 1; i <= n; i++) {
if (pos[i] > max) {
max = pos[i];
max_idx = i;
}
}
if (max_idx == 0) {
for (int j = 1; j <= n; j++) {
if (a[j] == 0) {
a[j] = k;
break;
}
}
} else
a[max_idx] = k;
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, ans = 0, ai;
cin >> n;
map<int, bool> hap;
vector<int> cur(1, 0);
while (n--) {
cin >> ai;
int s = cur.size();
vector<int> newi;
map<int, bool> si;
for (int i = 0; i < s; i++) {
int acr = cur[i] | ai;
if (!hap[acr]) {
ans++;
hap[acr] = true;
si[acr] = true;
newi.push_back(acr);
} else if (!si[acr]) {
si[acr] = true;
newi.push_back(acr);
}
}
cur = newi;
cur.push_back(0);
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct _ {
_() { ios_base::sync_with_stdio(0); }
} _;
template <class A, class B>
ostream &operator<<(ostream &o, pair<A, B> t) {
o << "(" << t.first << ", " << t.second << ")";
return o;
}
template <class T>
string tostring(T first, int len = 0, char c = '0') {
stringstream ss;
ss << first;
string r = ss.str();
if (r.length() < len) r = string(len - r.length(), c) + r;
return r;
}
template <class T>
void PV(T a, T b, int n = 0, int w = 0, string s = " ") {
int c = 0;
while (a != b) {
cout << tostring(*a++, w, ' ');
if (a != b && (n == 0 || ++c % n))
cout << s;
else
cout << "\n";
cout.flush();
}
}
template <class T>
inline bool chmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool chmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
const long long linf = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = int(1e9) + 7;
const int N = 111111;
struct DSU {
int par[N + 1], cnt[N + 1];
DSU(int n = N) { init(n); }
void init(int n) {
for (int i = 0; i <= n; i++) {
par[i] = i;
cnt[i] = 1;
}
}
int find(int first) {
if (par[first] != first) par[first] = find(par[first]);
return par[first];
}
bool merge(int first, int second) {
first = find(first), second = find(second);
if (first == second) return 0;
if (cnt[first] < cnt[second]) swap(first, second);
par[second] = first;
cnt[first] += cnt[second];
return 1;
}
} dsu;
int n;
vector<int> g[N];
vector<pair<int, pair<int, int>>> E;
map<pair<int, int>, int> eID;
map<pair<int, int>, int> D;
long long ans[N];
int cnt[N];
int sb[N];
int tot;
void dfs(int u, int par) {
sb[u] = cnt[u];
for (int v : g[u]) {
if (v == par) continue;
dfs(v, u);
sb[u] += sb[v];
long long first = (long long)sb[v] * (tot - sb[v]);
if (u < v) {
ans[D[make_pair(u, v)]] += first;
} else {
ans[D[make_pair(v, u)]] += first;
}
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int a, b, d;
cin >> a >> b >> d;
E.push_back(make_pair(d, make_pair(a, b)));
eID[make_pair(a, b)] = i;
eID[make_pair(b, a)] = i;
}
dsu.init(n);
sort((E).begin(), (E).end());
vector<pair<int, pair<int, int>>> e;
vector<pair<int, int>> e1;
int i = 0;
while (i < E.size()) {
e.clear();
e1.clear();
while (1) {
e.push_back(E[i]);
i++;
if (i == E.size() || E[i].first != E[i - 1].first) break;
}
vector<int> vlist;
D.clear();
for (auto t : e) {
int w = t.first, u = t.second.first, v = t.second.second;
int first = dsu.find(u);
int second = dsu.find(v);
cnt[first] = dsu.cnt[first];
cnt[second] = dsu.cnt[second];
vlist.push_back(first);
vlist.push_back(second);
e1.push_back(make_pair(first, second));
if (first > second) {
D[make_pair(second, first)] = eID[t.second];
} else {
D[make_pair(first, second)] = eID[t.second];
}
}
for (auto t : e)
assert(dsu.merge(dsu.find(t.second.first), dsu.find(t.second.second)));
for (auto t : e1) {
g[t.first].clear();
g[t.second].clear();
}
for (auto t : e1) {
g[t.first].push_back(t.second);
g[t.second].push_back(t.first);
}
sort((vlist).begin(), (vlist).end()),
vlist.resize(unique((vlist).begin(), (vlist).end()) - vlist.begin());
for (int root : vlist) {
if (root != dsu.find(root)) continue;
tot = dsu.cnt[root];
dfs(root, -1);
assert(tot == sb[root]);
}
}
long long mx = *max_element(ans, ans + n);
vector<int> res;
for (int i = 1; i < n; i++)
if (ans[i] == mx) res.push_back(i);
sort((res).begin(), (res).end());
cout << 2 * mx << " " << res.size() << endl;
for (int i : res) cout << i << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5123;
const int INF = 0x3f3f3f3f;
const long long MOD = 1000000007;
int n, T;
int s[MAX];
double dp[MAX][MAX];
double p[MAX];
int main() {
scanf("%d %d", &n, &T);
for (int i = 1; i <= n; i++) {
scanf("%lf %d", &p[i], &s[i]);
p[i] *= .01;
}
dp[0][0] = 1;
double resp = 0;
for (int i = 1; i <= n; i++) {
double sum = dp[i - 1][0];
double fail = 1.0 - p[i];
for (int j = 1; j <= T; j++) {
dp[i][j] = sum * p[i];
sum = sum * (1.0 - p[i]) + dp[i - 1][j];
if (j < s[i])
fail *= (1.0 - p[i]);
else {
sum -= dp[i - 1][j - s[i]] * fail;
dp[i][j] += dp[i - 1][j - s[i]] * fail;
}
resp += dp[i][j];
}
}
printf("%lf\n", resp);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#define all(nums) nums.begin(), nums.end()
#define allr(nums) nums.rbegin(), nums.rend()
#define len(a) int((a).size())
typedef long long int ll;
const ll imax = INT64_MAX;
const ll imin = INT64_MIN;
typedef vector<vector<int>> graph;
graph g;
template<class T>T cal(T n) {return (n*1ll*(n-1))/2;}
template<class T>T mx(T begin, T end){return max_element(begin, end);}
template<class T>T mn(T begin, T end){return min_element(begin, end);}
template<class T>void getUnique(vector<T>& nums){sort(nums.begin(), nums.end()); nums.erase(unique(nums.begin(), nums.end()), nums.end());}
template<class T>void print(vector<T>nums){for(T i:nums)cout<<i<<" ";cout<<"\n";}
template<class T>void read(vector<T>&nums){for(T& i:nums)cin>>i;}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll t = 1;
cin>>t;
while(t--) {
int n, k;
cin>>n>>k;
string s, t;
cin>>s>>t;
vector<int>a(26), b(26);
for (char ch: s) a[ch-'a']++;
for (char ch: t) b[ch-'a']++;
for (int i=0; i<26; ++i) {
if (a[i] == b[i]) continue ;
for (int j=i-1; j>=0; --j) {
while (a[i] < b[i] && a[j]-k >= b[j]) {
a[i] += k;
a[j] -= k;
}
}
}
// 4 2
// abba
// azza
cout << (a == b?"Yes":"No")<<"\n";
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b;
cin >> a >> b;
if (a > b) swap(a, b);
int x = min(a, b - a);
long long ans = 0;
for (int z = max(0, x - 10); z <= (x + 10); z++) {
if (z * 2 > b || z > a) continue;
ans = max(ans, (long long)z + (min(a - z, b - 2 * z) / 3) * 2);
}
cout << ans << endl;
}
int main() {
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
long long n, i, j = 0, x;
cin >> n;
string s = "";
stack<long long> q;
deque<long long> d;
for (i = 0; i < (n); i++) {
cin >> x;
d.push_back(x);
}
q.push(0);
while (!d.empty()) {
if (d.front() > q.top() && (d.front() < d.back() || d.back() < q.top())) {
q.push(d.front());
s += 'L';
d.pop_front();
} else if (d.back() > q.top() &&
(d.front() >= d.back() || d.front() < q.top())) {
q.push(d.back());
s += 'R';
d.pop_back();
} else
break;
}
cout << q.size() - 1 << "\n";
cout << s;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T min(T &a, T &b) {
return a < b ? a : b;
}
template <class T>
inline T max(T &a, T &b) {
return a > b ? a : b;
}
template <class T>
void read(T &x) {
char ch;
while ((ch = getchar()) && !isdigit(ch))
;
x = ch - '0';
while ((ch = getchar()) && isdigit(ch)) x = x * 10 + ch - '0';
}
struct point {
int x, y;
point() {}
point(int _x, int _y) : x(_x), y(_y) {}
};
const int N = 120000;
vector<int> E[N];
int dfn[N], low[N], n, m, val[N], dep[N], ti, F[N], f[N][23], ok[N];
void dfs(int x) {
dfn[x] = low[x] = ++ti;
F[x] = 1;
for (int i = 0; i < E[x].size(); i++)
if (!dfn[E[x][i]]) {
f[E[x][i]][0] = x;
dfs(E[x][i]);
low[x] = min(low[x], low[E[x][i]]);
if (dfn[x] < low[E[x][i]]) ok[E[x][i]] = 1;
} else if (E[x][i] != f[x][0])
low[x] = min(low[x], dfn[E[x][i]]);
}
void Dfs(int x, int c) {
dfn[x] = ++ti;
val[x] = c + ok[x];
for (int i = 0; i < E[x].size(); i++)
if (!dfn[E[x][i]]) dep[E[x][i]] = dep[x] + 1, Dfs(E[x][i], val[x]);
}
void dp() {
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20; i >= 0; i--)
if (dep[f[x][i]] >= dep[y]) x = f[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
int main() {
scanf("%d%d", &n, &m);
int x, y;
for (int i = 1; i <= m; i++)
scanf("%d%d", &x, &y), E[x].push_back(y), E[y].push_back(x);
dfs(1);
memset(dfn, 0, sizeof(dfn));
;
dep[1] = 1;
Dfs(1, 0);
dp();
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
int z = lca(x, y);
printf("%d\n", val[x] + val[y] - val[z] * 2);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
int par[1001000], rank[1001000];
void init(int N) {
for (int i = 0; i < N; i++) {
par[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (rank[x] < rank[y])
par[x] = y;
else
par[y] = x;
if (rank[x] == rank[y]) rank[x]++;
}
bool same(int x, int y) { return find(x) == find(y); }
};
UnionFind uf;
vector<int> G[1001000];
int cnt[1001000] = {};
int odd[1001000];
int main() {
int N, M;
scanf("%d%d", &N, &M);
uf.init(N);
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
uf.unite(u, v);
G[u].push_back(v);
G[v].push_back(u);
cnt[u]++;
cnt[v]++;
}
memset(odd, -1, sizeof(odd));
for (int i = 0; i < N; i++) {
if (cnt[i] == 0) continue;
int p = uf.find(i);
if (odd[p] == -1) odd[p] = 0;
if (cnt[i] % 2 == 1) odd[p]++;
}
if (odd[uf.find(0)] == -1) odd[uf.find(0)] = 0;
int ans = 0;
int com = 0;
int id;
for (int i = 0; i < N; i++) {
if (odd[i] == -1) continue;
com++;
id = i;
}
if (com == 1) {
ans = odd[id] / 2;
} else {
ans = com;
for (int i = 0; i < N; i++) {
if (odd[i] == -1) continue;
ans += (max(odd[i] - 2, 0) / 2);
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include<bits/stdc++.h>
#define fre(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout)
#define ll long long
using namespace std;
inline int read(){
int 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<<3)+(x<<1)+(c^'0'),c=getchar();
return x*f;
}
const int N=2e5+5;
int n,a[N],l,r,s1[N],s2[N],ans;
inline void solve(){
n=read(),l=read(),r=read();
for(int i=1;i<=n;i++) s1[i]=s2[i]=0;
ans=0;
for(int i=1;i<=l;i++){
a[i]=read();
s1[a[i]]++;
}
for(int i=1;i<=r;i++){
a[i]=read();
s2[a[i]]++;
}
for(int i=1;i<=n;i++){
int x=min(s1[i],s2[i]);
s1[i]-=x,s2[i]-=x;
l-=x,r-=x;
}
if(l>r){
for(int i=1;i<=n;i++) swap(s1[i],s2[i]);
swap(l,r);
}
// printf("%d\n",l);
// for(int i=1;i<=n;i++) printf("%d ",s1[i]);puts("");
// printf("%d\n",r);
// for(int i=1;i<=n;i++) printf("%d ",s2[i]);puts("");
for(int i=1;i<=n;i++){
while(s2[i]>=2&&l!=r){
s2[i]-=2;
r-=2;
ans++;
}
}
printf("%d\n",ans+(r-l)/2+(r+l)/2);
}
int main(){
int T=read();
while(T--) solve();
return 0;
}
/*
2
6 2 4
1 1 2 2 2 2
*/ | 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
int n, visited[N], mat[N][N];
vector<int> gp[N], aux, pos;
string tmp;
void DFS(int x, int a[]) {
visited[x] = 1;
pos.push_back(x);
aux.push_back(a[x]);
for (int j = 1; j <= n; j++)
if (!visited[j] && mat[x][j]) DFS(j, a);
}
void func(int a[]) {
sort(pos.begin(), pos.end());
sort(aux.begin(), aux.end());
for (int i = 0; i < pos.size(); i++) a[pos[i]] = aux[i];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
cin >> tmp;
for (int j = 0; j < n; j++) mat[i][j + 1] = (tmp[j] - '0');
}
for (int i = 1; i <= n; i++)
if (!visited[i]) {
aux.clear();
pos.clear();
DFS(i, a);
func(a);
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int used[444444];
int A, B;
int DX = 100000;
void brute(int i, int val) {
if (used[i] != -1) return;
if (i > val) val = i;
used[i] = val;
if (i - B >= 0) brute(i - B, val);
if (i + A <= A + DX) brute(i + A, val);
}
int main() {
int m;
scanf("%d%d%d", &m, &A, &B);
fill(used, used + 444444, -1);
brute(0, 0);
long long answer = 0;
for (int i = 0; i < A; ++i) {
if (used[i] == -1) continue;
if (i > m || used[i] > m) continue;
int Z1 = m - i;
int Z2 = (used[i] - i + A - 1) / A;
int Z3 = Z1 / A;
if ((used[i] - i) % A != 0)
answer += 1LL * (1LL * Z3 * (Z3 + 1) / 2 - 1LL * Z2 * (Z2 + 1) / 2) * A +
1LL * (Z1 % A + 1) * (Z3 + 1) +
1LL * (A - (used[i] - i) % A) * Z2;
else
answer += 1LL * (1LL * Z3 * (Z3 + 1) / 2 - 1LL * Z2 * (Z2 + 1) / 2) * A +
1LL * (Z1 % A + 1) * (Z3 + 1);
}
cout << answer << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
template <typename T, size_t N>
int SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
int SIZE(const T &t) {
return t.size();
}
string to_string(const string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgm(T...);
}
const long long MOD = (int)1e9 + 7;
string ascii_lowercase = "abcdefghijklmnopqrstuvwxyz";
string ascii_uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
long long inv(long long a, long long b) {
return 1 < a ? b - inv(b % a, a) * b / a : 1;
}
const long long INF = 1e6;
unordered_map<int, int, custom_hash> mp;
long long gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long distsq(long long x1, long long y1, long long x2, long long y2) {
return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
}
long long n, m;
const int MAXN = 100005;
long long g[26][26];
char a[MAXN];
char b[MAXN];
int main() {
for (int i = 0; i < (26); i++)
for (int j = 0; j < (26); j++) g[i][j] = 1e9;
scanf("%s %s", &a, &b);
n = strlen(a);
long long z = strlen(b);
if (n != z) {
puts("-1");
return 0;
}
scanf("%lld", &m);
char u, v;
long long wt;
for (int i = 0; i < (m); i++) {
cin >> u >> v >> wt;
g[u - 'a'][v - 'a'] = min(g[u - 'a'][v - 'a'], wt);
}
for (int i = 0; i < (26); i++) g[i][i] = 0;
for (int k = 0; k < (26); k++)
for (int i = 0; i < (26); i++)
for (int j = 0; j < (26); j++) {
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
string ret = "";
long long cost = 0;
for (int i = 0; i < (n); i++) {
if (a[i] != b[i]) {
u = a[i] - 'a';
v = b[i] - 'a';
long long mn = 1e9;
char cand = '.';
for (int al = 0; al < (26); al++) {
long long curr = g[u][al] + g[v][al];
if (curr < mn) {
cand = 'a' + al;
mn = curr;
}
}
if (mn == 1e9) {
puts("-1");
return 0;
}
cost += mn;
ret += string(1, cand);
} else {
ret += string(1, a[i]);
}
}
printf("%lld\n%s", cost, ret.c_str());
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string a[1009];
int n;
set<string> s;
string h;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 0; j < a[i].size(); j++) {
char l = a[i][j];
if (a[i][j] == 'u') {
h += "oo";
} else if (a[i][j] == 'k') {
for (int k = j; k < a[i].size(); k++) {
if (a[i][k] == 'h') {
h += 'h';
j = k;
goto ss;
}
if (a[i][k] != 'k') {
h += a[i][j];
goto ss;
}
}
h += a[i][j];
ss:;
} else
h += a[i][j];
}
s.insert(h);
h.clear();
}
cout << s.size();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n > 0) {
int x, y, Sum = 0;
cin >> x >> y;
if (x < y) swap(x, y);
while (y != 0) {
Sum += x / y;
x %= y;
if (x < y) swap(x, y);
}
cout << Sum << endl;
n--;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1, 0};
const int dy[] = {0, 1, 0, -1, -1, 1, 1, -1, 0};
const int inf = 1 << 30;
long long a[100500], sum;
int i, n, t;
int main() {
srand(time(0));
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%I64d", a + i);
for (i = 1; i < n; i++) {
for (t = 0; i + (1 << t) <= n; t++)
;
t--;
a[i + (1 << t)] += a[i];
sum += a[i];
printf("%I64d\n", sum);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int t;
char s[105];
scanf("%d", &t);
while (t--) {
int l, i, count, z = 0, o = 0;
scanf("%s", &s);
l = strlen(s);
for (i = 0; i < l; i++) {
if (s[i] == '0') {
z++;
} else {
o++;
}
}
if (o > z) {
count = z;
} else {
count = o;
}
if (count % 2 == 0) {
printf("NET\n");
} else {
printf("DA\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T>
using matrix = vector<vector<T>>;
constexpr int INF = (int)1e9 + 7;
constexpr int MAXN = (int)1e3 + 1;
constexpr int MOD = (int)1e9 + 7;
constexpr double EPS = 1e-9;
vector<pii> t;
bool check(int s, int d) {
for (auto [t1, t2] : t) {
if (t1 <= s + d - 1 && t2 >= s) return false;
}
return true;
}
void solve() {
int n;
cin >> n;
t.emplace_back(0, 0);
for (int i = 0; i < n; ++i) {
int s, d;
cin >> s >> d;
if (!check(s, d)) {
s = INF;
for (auto [_, t2] : t) {
if (check(t2 + 1, d)) s = min(s, t2 + 1);
}
}
cout << s << " " << s + d - 1 << endl;
t.emplace_back(s, s + d - 1);
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(7);
solve();
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, i, x, y;
scanf("%I64d ", &a);
while (a--) {
scanf("%I64d %I64d", &x, &y);
i = ceil(cbrt(x * y));
if (x % i == 0 && y % i == 0 && (x * y) == i * i * i) {
printf("Yes\n");
} else
printf("No\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, sm, x, i, j, k, gen[11] = {0};
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> k;
gen[k]++;
}
sm = 0;
x = 1;
for (i = 1; i <= m; i++) {
for (j = i + 1; j <= m; j++) {
x = gen[i] * gen[j];
sm = sm + x;
}
}
cout << sm << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = 3.14159265359;
vector<long long> primes;
void GeneratingPrimes(int top) {
vector<bool> p(top + 1, 1);
p[0] = p[1] = 0;
for (int i = 2; i <= sqrt(top); i++) {
if (p[i]) {
for (int j = i * i; j <= top; j += i) {
p[j] = 0;
}
}
}
for (int i = 0; i < top + 1; i++)
if (p[i]) primes.push_back(i);
}
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
void EXTgcd(long long a, long long b, int& x0, int& y0) {
if (b == 0) {
x0 = 1, y0 = 0;
return;
}
EXTgcd(b, a % b, x0, y0);
long long x1 = y0;
long long y1 = x0 - (a / b) * y0;
x0 = x1;
y0 = y1;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res % p;
}
double dist(double a, double b, double x, double y) {
return sqrt(pow(a - x, 2) + pow(b - y, 2));
}
double dist3(double a, double b, double c, double x, double y, double z) {
return sqrt(pow(a - x, 2) + pow(b - y, 2) + pow(c - z, 2));
}
int xadd[9] = {1, -1, 0, 1, -1, 0, 1, -1, 0};
int yadd[9] = {1, -1, 0, -1, 0, 1, 0, 1, -1};
long long const N = 100000 + 10;
long long mod = 998244353;
vector<int> ans;
bool chkCD(vector<int> v, int c, int d) {
if (v.size()) {
if (v.back() != 2) {
if (d) return 0;
}
if (d < c) return 0;
while (c--) {
v.push_back(3), v.push_back(2);
d--;
}
if (d) v.push_back(3), d--;
if (!d) {
ans = v;
return 1;
} else
return 0;
} else {
if (c > d) {
if (c - 1 > d) return 0;
for (int i = 0; i < d; i++) ans.push_back(2), ans.push_back(3);
ans.push_back(2);
return 1;
}
while (c--) {
ans.push_back(3), ans.push_back(2);
d--;
}
if (d) ans.push_back(3), d--;
return (!d);
}
}
bool chkBC(int b, vector<int> v, int c, int d) {
if (v.size()) {
if (v.back() == 0) {
if (c) return 0;
return chkCD(v, 0, d);
}
if (b > c) return 0;
for (int i = 0; i < b; i++) v.push_back(2), v.push_back(1);
if (c > b) v.push_back(2);
return chkCD(v, (c > b) ? c - b - 1 : 0, d);
} else {
if (b > c) {
if (b - 1 > c) return 0;
for (int i = 0; i < c; i++) v.push_back(1), v.push_back(2);
v.push_back(1);
return chkCD(v, 0, d);
}
for (int i = 0; i < b; i++) v.push_back(1), v.push_back(2);
if (chkCD(v, c - b, d)) return 1;
v.clear();
for (int i = 0; i < b; i++) v.push_back(2), v.push_back(1);
if (c > b) v.push_back(2);
return chkCD(v, (c == b) ? 0 : c - b - 1, d);
}
}
bool chkAB(int a, int b, int c, int d) {
if (a - 1 > b) return 0;
if (a - 1 == b) {
vector<int> v;
for (int i = 0; i < b; i++) {
v.push_back(0);
v.push_back(1);
}
v.push_back(0);
if (chkBC(0, v, c, d)) return 1;
return 0;
}
vector<int> v;
for (int i = 0; i < a; i++) v.push_back(0), v.push_back(1);
if (chkBC(b - a, v, c, d)) return 1;
v.clear();
for (int i = 0; i < a; i++) v.push_back(1), v.push_back(0);
if (b > a) v.push_back(1);
return (chkBC((b > a) ? b - a - 1 : b - a, v, c, d));
}
int a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
if (!chkAB(a, b, c, d)) {
cout << "NO";
} else {
cout << "YES\n";
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 10;
int par[maxN];
int n, k;
bool isPower(int n) {
int dd = (n + 1);
return ((dd & (dd - 1)) == 0);
}
bool can[105][105];
bool ok(int n, int k) {
if (n < 100) {
if (!can[n][k]) {
return false;
}
} else {
if (k == 0) {
if (!isPower(n)) {
return false;
}
}
if (k == 1) {
if (isPower(n)) {
return false;
}
}
if (k > (n - 3) / 2) {
return false;
}
}
return true;
}
void solve(int l, int r, int k) {
int n = (r - l + 1);
if (n == 1) {
assert(k == 0);
return;
}
assert((n - 3) / 2 >= k && k >= 0);
if (n <= 40) {
for (int c1 = 1; c1 < n; c1 += 2) {
int c2 = n - 1 - c1;
int fl = max(c1, c2) >= 2 * min(c1, c2);
for (int p = 0; p + fl <= k && p <= c1; p++) {
if (can[c1][p] && can[c2][k - fl - p]) {
par[l + 1] = l;
par[l + c1 + 1] = l;
solve(l + 1, l + c1, p);
solve(l + c1 + 1, r, k - fl - p);
return;
}
}
}
assert(false);
}
if (k == 0) {
assert(isPower(n));
int c1 = (n - 1) / 2;
par[l + 1] = l;
par[l + c1 + 1] = l;
solve(l + 1, l + c1, 0);
solve(l + c1 + 1, r, 0);
return;
} else {
for (int c1 = 1; c1 < n; c1 += 2) {
int c2 = n - 1 - c1;
int fl = max(c1, c2) >= 2 * min(c1, c2);
for (int p = 0; p + fl <= k && p <= c1; p++) {
if (ok(c1, p) && ok(c2, k - fl - p)) {
par[l + 1] = l;
par[l + c1 + 1] = l;
solve(l + 1, l + c1, p);
solve(l + c1 + 1, r, k - fl - p);
return;
}
}
}
assert(false);
}
}
void go() {
can[1][0] = true;
for (int i = 3; i < 100; i += 2) {
for (int c1 = 1; c1 < (i - 1); c1 += 2) {
int c2 = i - 1 - c1;
int fl = (max(c1, c2) >= 2 * min(c1, c2));
for (int d = 0; d <= c1; d++) {
for (int p = 0; p <= c2; p++) {
if (can[c1][d] && can[c2][p]) {
can[i][d + p + fl] = true;
}
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
go();
cin >> n >> k;
if (n % 2 == 0) {
cout << "NO\n";
return 0;
}
if (!ok(n, k)) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
solve(1, n, k);
for (int i = 1; i <= n; i++) cout << par[i] << " ";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
//#define mp make_pair
#define pb push_back
const int INF = (int)1e18;
const int N = 111;
const int MAXN = (int)1e9;
const int md = (int)1e9 + 7;
const int DEBUG = 0;
mt19937 rnd(time(nullptr));
vector<int> ans;
int ask(int t,int i,int j,int x){
if(DEBUG){
if(t == 1)
return max(min(ans[i],x),min(x+1,ans[j]));
else
return min(max(ans[i],x),max(x+1,ans[j]));
}
cout << "? " << t << " " << i << " " << j << " " << x << "\n";
cout.flush();
int a;
cin >> a;
if(a == -1)
exit(0);
return a;
}
vector<int> v;
int n;
void answer(){
cout << "! ";
for(int i = 1; i <= n; i++){
cout << v[i] << " ";
}
cout << "\n";
cout.flush();
return;
}
void solve_case(){
cin >> n;
if(DEBUG){
ans.resize(n+1);
for(int i = 1; i <= n; i++)
cin >> ans[i];
}
v.clear();
v.resize(n+1);
v.assign(n+1,0);
int id = 0;
for(int i = 1; i < n; i += 2){
int k = ask(2,i,i+1,1);
if(k == 1){
id = i;
break;
} else if(k == 2){
k = ask(2,i+1,i,1);
if(k == 1){
id = i + 1;
break;
}
}
}
if(!id)
id = n;
v[id] = 1;
for(int i = 1; i <= n; i++){
if(i == id)
continue;
int k = ask(1,id,i,n-1);
v[i] = k;
}
answer();
return;
}
signed main(){
ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
int t = 1;
cin >> t;
for(int _ = 1; _ <= t; _++){
// n = _;
solve_case();
// cout.flush();
}
return 0;
}
/*
12
20
*/
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> in[2 * 100000 + 5], out[2 * 100000 + 5];
bool cycle;
int visited[100000 + 5];
int done[100000 + 5];
int offset = 1;
void dfs(int v) {
visited[v] = offset;
for (int i = 0; i < out[v].size(); ++i) {
int u = out[v][i];
if (visited[u] == 0) {
dfs(u);
} else if (visited[u] == offset) {
cycle = 1;
}
}
visited[v] = offset + 1;
}
int finish(int v) {
int c = 1;
visited[v] = offset;
done[v] = 1;
for (int i = 0; i < out[v].size(); ++i) {
int u = out[v][i];
if (visited[u] != offset) c += finish(u);
}
for (int i = 0; i < in[v].size(); ++i) {
int u = in[v][i];
if (visited[u] != offset) c += finish(u);
}
return c;
}
int main() {
int N, M, a, b;
cin >> N >> M;
for (int i = 1; i <= M; ++i) {
scanf("%d", &a);
scanf("%d", &b);
out[a].push_back(b);
in[b].push_back(a);
}
int ans = 0;
for (int i = 1; i <= N; ++i) {
if (visited[i] == 0) {
cycle = 0;
dfs(i);
offset += 2;
if (cycle == 1) {
ans += finish(i);
offset++;
}
}
}
for (int i = 1; i <= N; ++i) {
if (done[i] == 0) {
ans += finish(i) - 1;
offset++;
}
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
string c;
set<int> s[2];
int numL, numR;
int ans[100001];
inline void work(int type) {
int p = 0;
for (int i = 1; i <= n; i++) {
if (s[type].lower_bound(p) == s[type].end()) {
ans[0]++;
p = *s[type].begin();
} else {
p = *s[type].lower_bound(p);
if (s[type ^ 1].lower_bound(p) == s[type ^ 1].end() &&
*s[type].begin() < *s[type ^ 1].begin()) {
p = *s[type].begin();
ans[0]++;
}
}
ans[i] = p;
s[type].erase(p);
type ^= 1;
}
}
int main() {
cin >> c;
n = c.length();
c = " " + c;
for (int i = 1; i <= n; i++) {
if (c[i] == 'L') {
s[0].insert(i);
numL++;
} else {
s[1].insert(i);
numR++;
}
}
if (numL > numR) {
work(0);
} else if (numR > numL) {
work(1);
} else {
work(c[1] == 'R');
}
cout << ans[0] << endl;
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int add(int a, int b) {
return (a + b >= 1000000007) ? a + b - 1000000007 : a + b;
}
inline void inc(int &a, int b) { a = add(a, b); }
inline int mul(int a, int b) { return 1ll * a * b % 1000000007; }
int dp[55][55][2] = {{0}};
int comb[55][55] = {{0}};
const int inv2 = 500000004;
int n, k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
if (k > n / 2) {
cout << 0 << endl;
exit(0);
}
for (int i = 1; i < 55; i++) {
comb[i][0] = 1;
comb[i][i] = 1;
for (int j = 1; j < i; j++)
comb[i][j] = add(comb[i - 1][j], comb[i - 1][j - 1]);
}
dp[0][0][0] = 1;
dp[1][0][1] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= i / 2; j++) {
int tmp1 = 0;
for (int a = 0; a <= i - 1; a++) {
for (int b = 0; b <= min(a / 2, j); b++) {
inc(tmp1, mul(mul(mul(dp[a][b][0], dp[i - 1 - a][j - b][0]),
comb[i - 1][a]),
max(a, 1) * max(1, (i - 1 - a))));
}
}
tmp1 = mul(tmp1, inv2);
int tmp0 = 0;
for (int a = 0; a <= i - 1; a++) {
for (int b = 0; b <= min(a / 2, j - 1); b++) {
int t2 = add(add(mul(dp[a][b][0], dp[i - 1 - a][j - 1 - b][1]),
mul(dp[a][b][1], dp[i - 1 - a][j - 1 - b][0])),
mul(dp[a][b][1], dp[i - 1 - a][j - 1 - b][1]));
t2 = mul(t2, comb[i - 1][a]);
t2 = mul(t2, max(a, 1) * max(1, (i - 1 - a)));
inc(tmp0, t2);
}
}
tmp0 = mul(tmp0, inv2);
dp[i][j][1] = tmp1;
dp[i][j][0] = tmp0;
}
}
cout << add(dp[n][k][0], dp[n][k][1]) << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ans[100005];
int dp[100005];
int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
int q, k;
cin >> q >> k;
dp[0] = 1;
for (int i = 1; i <= 100000; i++) {
if (i < k)
dp[i] = dp[i - 1];
else
dp[i] = dp[i - 1] + dp[i - k];
dp[i] %= mod;
}
for (int i = 1; i <= 100000; i++) {
ans[i] = ans[i - 1] + dp[i];
ans[i] %= mod;
}
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
cout << (ans[b] - ans[a - 1] + mod) % mod << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e6 + 10;
int n, q, a[N];
int Lmin[N], Lmax[N], Rmin[N], Rmax[N];
int f3[N], f4[N];
vector<pair<int, int> > s;
vector<int> ans3[N], ans4[N];
int mi[N << 2];
int find(int o, int l, int r, int first, int v) {
if (r <= first) {
if (mi[o] > v) return -1;
if (l == r) return l;
if (mi[((o << 1) | 1)] <= v)
return find(((o << 1) | 1), ((l + r) >> 1) + 1, r, first, v);
return find((o << 1), l, ((l + r) >> 1), first, v);
}
if (((l + r) >> 1) >= first)
return find((o << 1), l, ((l + r) >> 1), first, v);
int t = find(((o << 1) | 1), ((l + r) >> 1) + 1, r, first, v);
if (t == -1) return find((o << 1), l, ((l + r) >> 1), first, v);
return t;
}
void update(int o, int l, int r, int first, int v) {
if (l == r) return mi[o] = v, void();
if (((l + r) >> 1) >= first)
update((o << 1), l, ((l + r) >> 1), first, v);
else
update(((o << 1) | 1), ((l + r) >> 1) + 1, r, first, v);
mi[o] = min(mi[(o << 1)], mi[((o << 1) | 1)]);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i) {
while (s.size() && s.back().first <= a[i]) s.pop_back();
if (s.size()) Lmax[i] = s.back().second;
s.push_back(pair<int, int>(a[i], i));
}
s.clear();
for (int i = 1; i <= n; ++i) {
while (s.size() && s.back().first >= a[i]) s.pop_back();
if (s.size()) Lmin[i] = s.back().second;
s.push_back(pair<int, int>(a[i], i));
}
s.clear();
for (int i = n; i >= 1; --i) {
while (s.size() && s.back().first <= a[i]) s.pop_back();
if (s.size())
Rmax[i] = s.back().second;
else
Rmax[i] = n + 1;
s.push_back(pair<int, int>(a[i], i));
}
s.clear();
for (int i = n; i >= 1; --i) {
while (s.size() && s.back().first >= a[i]) s.pop_back();
if (s.size())
Rmin[i] = s.back().second;
else
Rmin[i] = n + 1;
s.push_back(pair<int, int>(a[i], i));
}
for (int i = 1; i <= n; ++i) {
if (i >= 4) {
int p = min(Lmin[i], Lmax[i]);
if (p > 1) f4[i] = find(1, 1, n, p - 1, i - 1);
}
update(1, 1, n, i, max(Rmin[i], Rmax[i]));
if (f4[i] >= 1 && ans4[f4[i]].empty()) {
ans4[f4[i]].push_back(f4[i]);
if (a[Lmin[i]] < a[Rmin[f4[i]]])
ans4[f4[i]].push_back(Lmin[i]);
else
ans4[f4[i]].push_back(Rmin[f4[i]]);
if (a[Lmax[i]] > a[f4[i]])
ans4[f4[i]].push_back(Lmax[i]);
else
ans4[f4[i]].push_back(Rmax[f4[i]]);
ans4[f4[i]].push_back(i);
sort(ans4[f4[i]].begin(), ans4[f4[i]].end());
}
}
for (int i = 1; i <= n; ++i) {
if (i >= 3) {
int p = Lmin[i];
if (p > 1) f3[i] = find(1, 1, n, p - 1, i - 1);
}
update(1, 1, n, i, Rmin[i]);
if (f3[i] >= 1 && ans3[f3[i]].empty()) {
ans3[f3[i]].push_back(f3[i]);
if (a[Lmin[i]] < a[Rmin[f3[i]]])
ans3[f3[i]].push_back(Lmin[i]);
else
ans3[f3[i]].push_back(Rmin[f3[i]]);
ans3[f3[i]].push_back(i);
}
}
for (int i = 1; i <= n; ++i) {
if (i >= 3) {
int p = Lmax[i];
if (p > 1) f3[i] = max(f3[i], find(1, 1, n, p - 1, i - 1));
}
update(1, 1, n, i, Rmax[i]);
if (f3[i] >= 1 && ans3[f3[i]].empty()) {
ans3[f3[i]].push_back(f3[i]);
if (a[Lmax[i]] > a[f3[i]])
ans3[f3[i]].push_back(Lmax[i]);
else
ans3[f3[i]].push_back(Rmax[f3[i]]);
ans3[f3[i]].push_back(i);
}
}
for (int i = 1; i <= n; ++i) {
f3[i] = max(f3[i], f3[i - 1]);
f4[i] = max(f4[i], f4[i - 1]);
}
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
if (f4[r] >= l) {
puts("4");
for (int t : ans4[f4[r]]) printf("%d ", t);
} else if (f3[r] >= l) {
puts("3");
for (int t : ans3[f3[r]]) printf("%d ", t);
} else
puts("0");
puts("");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int count = 0;
int k = 0;
int r = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 0 && k == 0)
continue;
else if (a[i] == 1) {
if (r == 1) {
count++;
r = 0;
}
count++;
k = 1;
r = 0;
} else if (a[i] == 0) {
r++;
}
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
char s[N];
int ans;
void dfs(int l, int r, int cnt, char c) {
if (l == r) {
if (s[l] != c) cnt++;
ans = min(ans, cnt);
return;
}
int cnt1 = 0, cnt2 = 0, mid = l + r >> 1;
for (int i = l; i <= mid; i++)
if (s[i] != c) cnt1++;
for (int i = mid + 1; i <= r; i++)
if (s[i] != c) cnt2++;
dfs(l, mid, cnt + cnt2, c + 1);
dfs(mid + 1, r, cnt + cnt1, c + 1);
}
int main() {
int t, n;
scanf("%d", &t);
while (t--) {
scanf("%d%s", &n, s + 1);
ans = n;
dfs(1, n, 0, 'a');
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, top, zhan[500001];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
while (top > 1 && zhan[top - 1] >= zhan[top] && zhan[top] <= x) {
ans += min(zhan[top - 1], x);
top--;
}
zhan[++top] = x;
}
sort(zhan + 1, zhan + top + 1);
for (int i = 1; i <= top - 2; i++) {
ans += zhan[i];
}
printf("%lld", ans);
}
| 8 |
#include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define per(i, a, b) for (int i = a; i >= b; i--)
using namespace std;
typedef unsigned long long ull;
typedef pair <int, int> pii;
typedef long long ll;
template <typename _T>
inline void read(_T &f) {
f = 0; _T fu = 1; char c = getchar();
while (c < '0' || c > '9') { if (c == '-') { fu = -1; } c = getchar(); }
while (c >= '0' && c <= '9') { f = (f << 3) + (f << 1) + (c & 15); c = getchar(); }
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10) putchar(x + 48);
else print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x); putchar(t);
}
const int N = 3005;
struct segment_tree {
struct node_t { int minn, tag; } p[N << 2];
void update(int u) {
p[u].minn = min(p[u << 1].minn, p[u << 1 | 1].minn);
}
void add_tag(int u, int x) {
p[u].minn += x;
p[u].tag += x;
}
void pushdown(int u) {
if (p[u].tag) {
add_tag(u << 1, p[u].tag);
add_tag(u << 1 | 1, p[u].tag);
p[u].tag = 0;
}
}
void build(int u, int l, int r) {
p[u].tag = 0;
if (l == r) {
p[u].minn = N;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid); build(u << 1 | 1, mid + 1, r);
update(u);
}
void add(int u, int L, int R, int l, int r, int x) {
if (l <= L && R <= r) {
add_tag(u, x);
return;
}
pushdown(u);
int mid = (L + R) >> 1;
if (mid >= l) add(u << 1, L, mid, l, r, x);
if (mid + 1 <= r) add(u << 1 | 1, mid + 1, R, l, r, x);
update(u);
}
void modify(int u, int L, int R, int x, int y) {
if (L == R) {
p[u].minn = y;
return;
}
pushdown(u);
int mid = (L + R) >> 1;
if (mid >= x) modify(u << 1, L, mid, x, y);
else modify(u << 1 | 1, mid + 1, R, x, y);
update(u);
}
int query(int u, int L, int R, int l, int r) {
if (l <= L && R <= r) return p[u].minn;
pushdown(u);
int mid = (L + R) >> 1, ans = N;
if (mid >= l) ans = min(ans, query(u << 1, L, mid, l, r));
if (mid + 1 <= r) ans = min(ans, query(u << 1 | 1, mid + 1, R, l, r));
return ans;
}
} tr[N];
int a[N];
int T, n;
int main() {
read(T);
while (T--) {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i < n; i++) tr[i].build(1, i, n);
int zero = 0;
for (int i = n - 1; i >= 1; i--) {
if (i + a[i] < n) {
for (int j = i + 1; j <= min(n - 1, i + a[i]); j++) {
tr[i].modify(1, i, n, j, tr[j].query(1, j, n, i + a[i] + 1, n));
tr[j].add(1, j, n, j + 1, n, 1);
}
} else {
for (int j = i + 1; j < n; j++) {
tr[j].add(1, j, n, j + 1, n, 1);
}
tr[i].modify(1, i, n, n, zero);
++zero;
}
}
print(tr[1].query(1, 1, n, 2, n), '\n');
}
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
int vocala(char c) {
if (c == 'a' || c == 'A' || c == 'e' || c == 'E' || c == 'i' || c == 'I' ||
c == 'o' || c == 'O' || c == 'u' || c == 'U')
return 1;
if (c == 'y' || c == 'Y') return 1;
return 0;
}
int 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 isfibo(long long n) {
long long a = 5 * n * n + 4;
long long b = a - 8;
if (sqrt(a) == int(sqrt(a)) || sqrt(b) == int(sqrt(b))) return 1;
return 0;
}
int gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
ifstream in("input.txt");
ofstream out("output.txt");
long long const nrmax = 1e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b;
cin >> a >> b;
if (a > b) swap(a, b);
long long t, d;
cin >> t >> d;
long long cnt = a + b;
for (int i = 2; i < t; ++i) {
long long k = t - i;
long long x = min(d, k * d + (b - a));
a += x;
cnt += a;
}
cout << cnt << '\n';
in.close();
out.close();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false), cout.tie(0), cin.tie(0);
int n, x;
cin >> n >> x;
int ans = 0, last = 0;
while (n--) {
int l, r;
cin >> l >> r;
ans += (l - last - 1) % x;
ans += r - l + 1;
last = r;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 13;
int n;
int cnt[MAXN];
int fr[MAXN];
int sum_from_root[MAXN];
int mx_from_bot[MAXN];
int added[MAXN];
int main() {
cin >> n;
for (int i = 2; i <= (1 << (n + 1)) - 1; i++) {
cin >> cnt[i];
}
int max_cnt = 0;
for (int i = (1 << n); i <= (1 << (n + 1)) - 1; i++) {
int v = i;
while (v > 1) {
fr[i] += cnt[v];
v >>= 1;
}
max_cnt = max(fr[i], max_cnt);
}
int total = 0;
for (int i = 2; i <= (1 << (n + 1)) - 1; i++)
sum_from_root[i] = sum_from_root[i >> 1] + cnt[i];
for (int i = (1 << (n + 1)) - 1; i >= 1; i--)
mx_from_bot[i] = max(mx_from_bot[i << 1] + cnt[i << 1],
mx_from_bot[i << 1 | 1] + cnt[i << 1 | 1]);
for (int i = 2, delta; i <= (1 << (n + 1)) - 1; i++) {
delta = max_cnt - mx_from_bot[i] - sum_from_root[i] - added[i];
if (delta >= 0) {
total += delta;
added[i << 1] = delta + added[i];
added[i << 1 | 1] = delta + added[i];
}
}
printf("%d\n", total);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, l = 0, r = 10000, a[1000], b[1000];
bool solve(int mid) {
int kk = k;
for (int i = 0; i < n; i++) {
if (mid * a[i] > b[i]) {
kk -= (mid * a[i] - b[i]);
}
if (kk < 0) return false;
}
return true;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
while (l < r) {
int mid = (l + r + 1) / 2;
if (solve(mid)) {
l = mid;
} else
r = mid - 1;
}
cout << l << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s[4][105];
string t[205];
int per[4];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < 4; i++) {
for (int j = 0; j < n; j++) cin >> s[i][j];
}
per[0] = 0, per[1] = 1, per[2] = 2, per[3] = 3;
int ans = 1e9;
do {
for (int i = 0; i < n; i++) t[i] = s[per[0]][i] + s[per[1]][i];
for (int i = 0; i < n; i++) t[i + n] = s[per[2]][i] + s[per[3]][i];
int res1 = 0, res2 = 0;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < 2 * n; j++) {
res1 += (t[i][j] - '0' != (i + j) % 2);
res2 += (t[i][j] - '0' != (i + j + 1) % 2);
}
}
ans = min(ans, res1);
ans = min(ans, res2);
} while (next_permutation(per, per + 4));
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
unordered_map<int, int> idx;
for (int i = 0; i < n; i++) {
cin >> a[i];
idx[a[i]] = i;
}
vector<int> was(n, 0);
int flag = 1, id;
int f = n, sub_count = 0;
for (int i = 1; i < n; i++) {
id = idx[i];
if (id + 1 == f) {
f = id - sub_count;
sub_count = 0;
} else if (a[id + 1] == i + 1)
sub_count++;
else {
flag = 0;
break;
}
}
if (flag)
cout << "Yes";
else
cout << "No";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 20;
pair<long long, long long> b[maxn];
long long a[maxn], res[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i].first, b[i].second = i;
sort(a, a + n);
sort(b, b + n);
reverse(a, a + n);
for (int i = 0; i < n; i++) res[b[i].second] = a[i];
for (int i = 0; i < n; i++) cout << res[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct __timestamper {};
void make_op(vector<int>& x, vector<pair<int, int>>& ans, int i, int j) {
x[i] ^= x[j];
ans.push_back(make_pair(i, j));
}
void make_swap(vector<int>& x, vector<pair<int, int>>& ans, int i, int j) {
if (i == j) return;
make_op(x, ans, i, j);
make_op(x, ans, j, i);
make_op(x, ans, i, j);
}
int n;
int make_iter(vector<int>& x, vector<pair<int, int>>& ans, int pos) {
int mid = max_element(x.begin() + pos, x.end()) - x.begin();
make_swap(x, ans, mid, pos);
if (x[pos] == 0) return -1;
int bit = 31 - __builtin_clz(x[pos]);
for (int j = 0; j < n; j++)
if (j != pos && (x[j] & (1 << bit))) make_op(x, ans, j, pos);
return bit;
}
void solve() {
vector<int> xs(n), ys(n);
for (int& x : xs) scanf("%d", &x);
for (int& y : ys) scanf("%d", &y);
vector<pair<int, int>> ans1, ans2;
for (int i = 0; i < n; i++) {
int b1 = make_iter(xs, ans1, i);
int b2 = make_iter(ys, ans2, i);
if (b1 == -1 && b2 == -1) break;
if (b1 == b2) continue;
if (b2 > b1) {
printf("-1\n");
return;
}
for (int j = 0; j < i; j++) {
if (ys[j] & (1 << b1)) make_op(xs, ans1, j, i);
}
make_op(xs, ans1, i, i);
i--;
}
if (xs != ys) {
printf("-1\n");
return;
}
ans1.insert(ans1.end(), ans2.rbegin(), ans2.rend());
printf("%d\n", ans1.size());
for (auto x : ans1) printf("%d %d\n", x.first + 1, x.second + 1);
}
int main() {
while (scanf("%d", &n) == 1) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int curr = 0;
int energy = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
if (v[i] >= curr) {
if (v[i] - curr > energy) {
ans = ans + v[i] - curr - energy;
energy = 0;
} else {
energy = energy - v[i] + curr;
}
} else {
energy = energy + curr - v[i];
}
curr = v[i];
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
int a[200005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &k);
int pos = 0, mn = 1000000000;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (i > k && a[i] - a[i - k] < mn) {
mn = a[i] - a[i - k];
pos = i;
}
}
printf("%d\n", (a[pos] + a[pos - k]) / 2);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int a[200005], nex[200005], pre[200005], ans[200005];
void NSE(int arr[], int n) {
stack<int> s;
s.push(1);
for (int i = 2; i <= n; i++) {
int v = arr[i];
while (!s.empty() && arr[s.top()] > v) {
nex[s.top()] = i;
s.pop();
}
s.push(i);
}
while (!s.empty()) {
nex[s.top()] = n + 1;
s.pop();
}
}
void PSE(int arr[], int n) {
stack<int> s;
s.push(n);
for (int i = n - 1; i >= 1; i--) {
int v = arr[i];
while (!s.empty() && arr[s.top()] > v) {
pre[s.top()] = i;
s.pop();
}
s.push(i);
}
while (!s.empty()) {
pre[s.top()] = 0;
s.pop();
}
}
int main() {
int n;
cin >> n;
for (int i = (int)1; i <= (int)n; i++) cin >> a[i];
NSE(a, n);
PSE(a, n);
for (int i = (int)1; i <= (int)n; i++) {
mp[a[i]] = max(mp[a[i]], nex[i] - pre[i] - 1);
}
map<int, int>::iterator it;
it = mp.end();
it--;
int last = 0;
for (;; it--) {
if (it->second > last) {
for (int i = (int)last + 1; i <= (int)it->second; i++) ans[i] = it->first;
last = it->second;
}
if (it == mp.begin()) break;
}
for (int i = (int)1; i <= (int)n; i++) cout << ans[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v1[300001], v2[300001];
map<long long, long long> vis;
long long n, m, k, xb, xx, yy, s = 1, a[300001];
inline long long read() {
long long sum = 0, x = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') x = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
sum = sum * 10 + ch - '0';
ch = getchar();
}
return sum * x;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
return;
}
inline void dfs(long long x, long long y) {
vis.clear();
for (register long long i = 0; i < v1[x].size(); ++i)
if (a[v1[x][i]]) vis[a[v1[x][i]]] = 1;
xb = 0;
for (register long long i = 0; i < v1[x].size(); ++i)
if (!a[v1[x][i]]) {
while (vis[++xb])
;
a[v1[x][i]] = xb;
}
for (register long long i = 0; i < v2[x].size(); ++i)
if (v2[x][i] != y) dfs(v2[x][i], x);
}
signed main() {
n = read();
m = read();
for (register long long i = 1; i <= n; ++i) {
k = read();
s = max(s, k);
for (register long long j = 1; j <= k; ++j) {
xx = read();
v1[i].push_back(xx);
}
}
for (register long long i = 1; i < n; ++i) {
xx = read();
yy = read();
v2[xx].push_back(yy);
v2[yy].push_back(xx);
}
dfs(1, -1);
write(s);
putchar('\n');
for (register long long i = 1; i <= m; ++i) {
if (a[i])
write(a[i]);
else
write(1);
putchar(' ');
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.