solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void debugs() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long multiply(long long x, long long res[], long long ressize) {
long long carry = 0;
for (long long i = 0; i < ressize; i++) {
long long product = res[i] * x + carry;
res[i] = product % 10;
carry = product / 10;
}
while (carry) {
res[ressize] = carry % 10;
carry = carry / 10;
ressize++;
}
return ressize;
}
void bigfactorial(long long n) {
long long ressize = 1;
long long res[10000];
res[0] = 1;
for (long long i = 2; i <= n; i++) {
ressize = multiply(i, res, ressize);
}
for (long long i = ressize - 1; i >= 0; i--) {
cout << res[i];
}
}
bool substring(string s1, string s2) {
int M = s1.length();
int N = s2.length();
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return true;
;
}
return false;
;
}
long long n;
bool palindrome(string s) {
string t;
t = s;
reverse(t.begin(), t.end());
if (s == t) {
return true;
}
return false;
}
bool issafe(vector<vector<long long>> board, long long row, long long col) {
for (long long i = 0; i < col; i++) {
if (board[row][i]) return false;
}
for (long long i = row, j = col; i >= 0 && j >= 0; i--, j--) {
if (board[i][j] == 1) return false;
}
for (long long i = row, j = col; i < n && j < n; i++, j++) {
if (board[i][j] == 1) return false;
}
return true;
}
void display(vector<vector<long long>> &board) {
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
cout << board[i][j] << " ";
}
cout << endl;
}
}
bool solvenqueen(vector<vector<long long>> &board, long long col) {
if (col >= n) {
return true;
}
for (long long i = 0; i < n; i++) {
if (issafe(board, i, col)) {
board[i][col] = 1;
if (solvenqueen(board, col + 1)) return true;
board[i][col] = 0;
}
}
return false;
}
int convertstring(string s) {
stringstream geek(s);
int x = 0;
geek >> x;
return x;
}
bool binary(long long k, long long a[]) {
long long l = 1;
long long r = 1e4;
while (l <= r) {
long long mid = (l + r) / 2;
if (a[mid] == (k)) {
return true;
} else if (a[mid] > (k)) {
r = mid - 1;
} else {
l = mid + 1;
}
}
return false;
}
bool notprime(int n) {
if (n == 2 || n == 3 || n == 5 || n == 7) {
return false;
}
return true;
}
int bin(string n) {
int num = convertstring(n);
int dec_value = 0;
int base = 1;
int temp = num;
while (temp) {
int last_digit = temp % 10;
temp = temp / 10;
dec_value += last_digit * base;
base = base * 2;
}
return dec_value;
}
bool sorted(int a[], int n) {
for (int i = 1; i <= n - 1; i++) {
if (a[i] > a[i + 1]) {
return false;
}
}
return true;
}
int main() {
long long a, b;
cin >> a >> b;
int m = ((a + b) / 2) - min(a, b);
int maxi = a + b - (((a + b) / 2) - min(a, b));
if ((a + b) % 2 == 0) {
cout << (maxi - m) / 2 + 1 << endl;
for (int i = m; i <= maxi; i += 2) {
cout << i << " ";
}
cout << endl;
} else {
cout << maxi - m + 1 << endl;
for (int i = m; i <= maxi; i++) {
cout << i << " ";
}
cout << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[200010];
int temp[200010];
long long dp[200010];
long long check(int x) {
if (x == 0) return 0;
for (int i = 0; i < x; i++) dp[i] = 0;
dp[0] = max(0, temp[0]);
long long ans = dp[0];
for (int i = 1; i < x; i++) {
dp[i] = max(dp[i - 1] + temp[i], 0 * 1ll);
ans = max(ans, dp[i]);
}
return ans;
}
int main() {
int T;
cin >> T;
while (T--) {
long long sum = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (i % 2 == 0) sum = sum + a[i];
}
long long ans = sum, cnt = 0;
for (int i = 0; i < n - 1; i = i + 2) {
temp[i / 2] = a[i + 1] - a[i];
cnt++;
}
ans = max(ans, sum + check(cnt));
cnt = 0;
for (int i = 1; i < n - 1; i = i + 2) {
temp[i / 2] = a[i] - a[i + 1];
cnt++;
}
ans = max(ans, sum + check(cnt));
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
return x * f;
}
const int N = 50005;
int cnt, n, q, u, v, a[N], dep[N], head[N], fa[N], sc, son[5000][2], t, c, now,
sum, f[N][260], jp[N], ans, base;
struct node {
int to, next;
} num[N * 2];
void add(int x, int y) {
num[++cnt].to = y;
num[cnt].next = head[x];
head[x] = cnt;
}
void dfs(int x) {
for (int i = head[x]; i; i = num[i].next)
if (num[i].to != fa[x]) {
dep[num[i].to] = dep[x] + 1;
fa[num[i].to] = x;
dfs(num[i].to);
}
}
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) u = read(), v = read(), add(u, v), add(v, u);
dfs(1);
for (int i = 1; i <= n; i++)
if (dep[i] >= 255) {
int x = i;
sc = 0;
son[0][0] = son[0][1] = 0;
for (int j = 0; j < 256; j++, x = fa[x]) {
t = a[x] ^ j;
now = 0;
for (int k = 16; k >= 0; k--) {
c = (t >> k) & 1;
if (!son[now][c]) son[now][c] = ++sc, son[sc][0] = son[sc][1] = 0;
now = son[now][c];
}
}
for (int j = 0; j < 256; j++) {
t = j << 8;
now = sum = 0;
for (int k = 16; k >= 0; k--) {
c = (t >> k) & 1;
if (son[now][c ^ 1])
now = son[now][c ^ 1], sum += (1 << k);
else
now = son[now][c];
}
f[i][j] = sum;
}
jp[i] = x;
}
while (q--) {
u = read();
v = read();
ans = base = 0;
for (; dep[v] - dep[u] >= 255; v = jp[v])
ans = max(ans, f[v][base]), base++;
for (base = base * 256; v != fa[u]; v = fa[v], base++)
ans = max(ans, a[v] ^ base);
printf("%d\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
string s;
int arr[26], dp[1005], dp2[1005];
int main() {
int n, l = 0;
cin >> n >> s;
for (int i = 0; i < 26; i++) cin >> arr[i];
dp[0] = 1;
dp2[0] = 0;
for (int i = 1; i <= n; i++) {
int f = 0;
dp2[i] = n;
for (int x = i - 1; x >= 0; x--) {
f = max(f, i - arr[s[x] - 'a']);
if (f > x) continue;
dp[i] = (dp[i] + dp[x]) % 1000000007;
dp2[i] = min(dp2[i], 1 + dp2[x]);
l = max(l, i - x);
}
}
cout << dp[n] << endl << l << endl << dp2[n] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)5e5 + 10;
char c[N];
double a[N], p[N], s[N], d[N];
bool check(char x) {
if (x == 'A' || x == 'E' || x == 'I' || x == 'O' || x == 'U' || x == 'Y')
return true;
else
return false;
}
int main() {
scanf("%s", c);
int n = strlen(c), t = 0;
for (int i = 0; i < n; i++)
if (check(c[i])) a[i + 1] = 1, t++;
for (int i = 1; i <= n; i++) p[i] = p[i - 1] + a[i];
for (int i = n; i >= 1; i--) s[i] = s[i + 1] + a[i];
for (int i = 1; i <= n; i++) d[i] = d[i - 1] + p[i] + s[n - i + 1];
double ans = 0.0;
for (int i = 1; i <= n; i++) ans += (double)t - (double)d[i - 1] / (double)i;
printf("%.7lf\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dist[500][500];
int main() {
long long n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> dist[i][j];
ans = ans + dist[i][j];
}
int k;
cin >> k;
ans = ans / 2;
for (int i = 0; i < k; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
if (c >= dist[a][b]) {
cout << ans << ' ';
continue;
}
ans = 0;
dist[a][b] = dist[b][a] = c;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
dist[i][j] =
min(dist[i][j],
min(dist[i][a] + dist[j][b], dist[i][b] + dist[j][a]) + c);
ans = ans + dist[i][j];
}
ans /= 2;
cout << ans << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
struct T {
int l, r, mid;
int sum, add;
} tree[maxn << 2];
void push_up(int rt) {
tree[rt].sum = tree[rt << 1].sum & tree[rt << 1 | 1].sum;
}
void push_down(int rt) {
if (tree[rt].add != 0) {
int tmp = tree[rt].add;
tree[rt << 1].add = tree[rt << 1].add | tmp;
tree[rt << 1].sum = tree[rt << 1].sum | tmp;
tree[rt << 1 | 1].add = tree[rt << 1 | 1].add | tmp;
tree[rt << 1 | 1].sum = tree[rt << 1 | 1].sum | tmp;
tree[rt].add = 0;
}
}
void build(int rt, int l, int r) {
tree[rt].l = l;
tree[rt].r = r;
tree[rt].sum = 0;
tree[rt].add = 0;
if (l == r) return;
int mid = tree[rt].mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
return;
}
void update(int rt, int l, int r, int val) {
if (tree[rt].l > r || tree[rt].r < l) return;
if (tree[rt].sum == tree[rt].r - tree[rt].l + 1) return;
if (tree[rt].l >= l && tree[rt].r <= r) {
tree[rt].sum = tree[rt].sum | val;
tree[rt].add = tree[rt].add | val;
return;
}
push_down(rt);
if (tree[rt].mid >= l) update(rt << 1, l, r, val);
if (tree[rt].mid < r) update(rt << 1 | 1, l, r, val);
push_up(rt);
return;
}
int query(int rt, int l, int r) {
if (tree[rt].l > r || tree[rt].r < l) return 0;
if (tree[rt].l >= l && tree[rt].r <= r) return tree[rt].sum;
push_down(rt);
int ans = (1 << 30) - 1;
if (tree[rt].mid >= l) ans = ans & query(rt << 1, l, r);
if (tree[rt].mid < r) ans = ans & query(rt << 1 | 1, l, r);
push_up(rt);
return ans;
}
int ans[maxn];
map<pair<int, int>, int> mp;
int main() {
int n, m, l, r, q;
scanf("%d%d", &n, &m);
build(1, 1, n);
int flag = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &l, &r, &q);
if (mp.count(pair<int, int>(l, r))) {
if (mp[pair<int, int>(l, r)] != q) flag = 1;
}
mp[pair<int, int>(l, r)] = q;
if (flag == 1) continue;
int res = query(1, l, r);
if ((q & res) == res) {
int tmp = q - res;
update(1, l, r, tmp);
} else
flag = 1;
}
if (flag == 1) return 0 * puts("NO");
for (int i = 1; i <= n; i++) ans[i] = query(1, i, i);
puts("YES");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const int maxn = 3e5 + 5, N = 1e6 + 5, SQ = 55, base = 879169, mod = 1e9 + 7,
INF = 1e9 + 5, lg = 20;
const long double eps = 1e-4;
struct node {
int mn = INF, lz = 0;
int c1 = 0, c2 = 0;
};
node seg[4 * maxn];
int n, p[maxn], pos[maxn], q[maxn];
inline void shift(int v) {
seg[2 * v].mn += seg[v].lz;
seg[2 * v + 1].mn += seg[v].lz;
seg[2 * v].lz += seg[v].lz;
seg[2 * v + 1].lz += seg[v].lz;
seg[v].lz = 0;
}
void add(int l, int r, int x, int v = 1, int s = 0, int e = n) {
if (l >= e || s >= r) {
return;
}
if (l <= s && e <= r) {
seg[v].mn += x;
seg[v].lz += x;
return;
}
shift(v);
add(l, r, x, 2 * v, s, (s + e) / 2);
add(l, r, x, 2 * v + 1, (s + e) / 2, e);
seg[v].mn = min(seg[2 * v].mn, seg[2 * v + 1].mn);
}
pair<int, int> get(int l, int r, int v = 1, int s = 0, int e = n) {
if (l >= e || s >= r) {
return {0, 0};
}
if (l <= s && e <= r) {
return {seg[v].c1, seg[v].c2};
}
shift(v);
pair<int, int> a = get(l, r, 2 * v, s, (s + e) / 2);
pair<int, int> b = get(l, r, 2 * v + 1, (s + e) / 2, e);
return {a.first + b.first, a.second + b.second};
}
void modify_num(int p, int x, int v = 1, int s = 0, int e = n) {
seg[v].c2++;
seg[v].mn = min(seg[v].mn, x);
if (e - s == 1) {
return;
}
shift(v);
if (p < (s + e) / 2) {
modify_num(p, x, 2 * v, s, (s + e) / 2);
return;
}
modify_num(p, x, 2 * v + 1, (s + e) / 2, e);
}
void modify_bomb(int p, int v = 1, int s = 0, int e = n) {
seg[v].c1++;
if (e - s == 1) {
return;
}
shift(v);
if (p < (s + e) / 2) {
modify_bomb(p, 2 * v, s, (s + e) / 2);
return;
}
modify_bomb(p, 2 * v + 1, (s + e) / 2, e);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> p[i];
}
for (int i = 0; i < n; ++i) {
cin >> q[i];
}
for (int i = 0; i < n; ++i) {
p[i]--, q[i]--;
pos[p[i]] = i;
}
int ans = n - 1;
for (int i = 0; i < n; ++i) {
while (ans) {
add(0, pos[ans], -1);
pair<int, int> res = get(pos[ans], n);
if (res.first < res.second + 1 || seg[1].mn <= 0) {
add(0, pos[ans], 1);
break;
}
modify_num(pos[ans], res.first - res.second);
ans--;
}
cout << ans + 1 << ' ';
modify_bomb(q[i]);
add(0, q[i] + 1, 1);
}
cout << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k, l, m, n;
cin >> n >> m;
k = n - m;
if (n - m != n and n - m)
cout << 1 << " " << min(2 * m, n - m) << endl;
else
cout << 0 << " " << 0 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m, l;
char s[N];
set<int> ix[255];
int v[N], ft[N];
void update(int i, int x) {
v[i] += x;
for (; i <= n; i += i & -i) ft[i] += x;
}
int query(int i) {
int ans = 0;
for (; i > 0; i -= i & -i) ans += ft[i];
return ans;
}
int index(int i) {
int b = 1;
int e = n;
while (b < e) {
int m = (b + e) / 2;
int x = m - query(m);
if (x < i)
b = m + 1;
else
e = m;
}
return e;
}
int main() {
scanf("%d%d %s", &n, &m, s + 1);
for (int i = 1; i <= n; ++i) ix[s[i]].insert(i);
l = n;
while (m--) {
int a, b;
char c;
scanf("%d%d %c", &a, &b, &c);
a = index(a);
b = index(b);
auto ap = ix[c].lower_bound(a);
auto bp = ix[c].upper_bound(b);
for (auto it = ap; it != bp;) {
--l;
update(*it, 1);
it = ix[c].erase(it);
}
}
for (int i = 1; i <= n; ++i) {
if (!v[i]) printf("%c", s[i]);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, x, y;
int main() {
cin >> n;
a = n / 10;
b = n % 10;
switch (a) {
case 0:
x = 2;
break;
case 1:
x = 7;
break;
case 2:
x = 2;
break;
case 3:
x = 3;
break;
case 4:
x = 3;
break;
case 5:
x = 4;
break;
case 6:
x = 2;
break;
case 7:
x = 5;
break;
case 8:
x = 1;
break;
case 9:
x = 2;
break;
}
switch (b) {
case 0:
y = 2;
break;
case 1:
y = 7;
break;
case 2:
y = 2;
break;
case 3:
y = 3;
break;
case 4:
y = 3;
break;
case 5:
y = 4;
break;
case 6:
y = 2;
break;
case 7:
y = 5;
break;
case 8:
y = 1;
break;
case 9:
y = 2;
break;
}
cout << x * y;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
const long double pi = 3.14159265358979323846;
const long long mod = 1000000007;
const int MaxSize = 200001;
long long dp[51][10];
int main() {
ios::sync_with_stdio(false);
long long n, a, b, c, ans = 0;
string s;
cin >> s;
vector<int> A(s.length());
for (int i = 0; i < s.length(); ++i) A[i] = (int)(s[i] - '0');
for (int i = 0; i < 10; ++i) dp[0][i] = 1;
for (int i = 1; i < s.length(); ++i) {
for (int j = 0; j < 10; ++j) {
if (dp[i - 1][j] == 0) continue;
int x = j + A[i];
if (x % 2 == 0) {
dp[i][x / 2] += dp[i - 1][j];
} else {
dp[i][x / 2] += dp[i - 1][j];
dp[i][x / 2 + 1] += dp[i - 1][j];
}
}
}
for (int j = 0; j < 10; ++j) {
ans += dp[s.length() - 1][j];
}
bool bad = true;
for (int i = 1; i < s.length() && bad; ++i) {
if (abs(A[i] - A[i - 1]) > 1) bad = false;
}
cout << ans - (bad);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = (long long)1e9 + 7LL;
int main() {
int i, j, n, m, k, a[51][51], b[51][51];
cin >> n >> m;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) cin >> a[i][j];
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) cin >> b[i][j];
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (a[i][j] > b[i][j]) {
k = a[i][j];
a[i][j] = b[i][j];
b[i][j] = k;
}
if (i > 0 && (a[i][j] <= a[i - 1][j] || b[i][j] <= b[i - 1][j])) {
cout << "Impossible" << '\n';
return 0;
}
if (j > 0 && (a[i][j] <= a[i][j - 1] || b[i][j] <= b[i][j - 1])) {
cout << "Impossible" << '\n';
return 0;
}
}
}
cout << "Possible" << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, l, tab[100005], m;
long long suma = 0;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> l;
m = n * k;
for (int i = 1; i <= m; i++) cin >> tab[i];
sort(tab + 1, tab + m + 1);
int wska = m, wskb = 1;
while ((tab[wskb] <= tab[1] + l) && (wskb <= m)) wskb++;
wskb--;
if (wskb < n) {
cout << 0 << endl;
return 0;
}
int adolf = wskb;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (j == k) {
suma += tab[wskb];
wskb--;
if (wska == wskb + 1) wska--;
} else {
wska--;
if (wska == adolf) wska = wskb;
if (wska < wskb) wskb--;
}
}
}
cout << suma << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
int n;
long long m;
int main() {
n = read(), m = read();
for (long long i = 1; i <= n; i++) {
long long t = 1ll << i;
if ((m % t) == (t >> 1)) {
printf("%d\n", i);
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long n, m;
cin >> n >> m;
long long tmp = 0;
for (long long i = 0; i < n; ++i) {
long long t;
cin >> t;
int ans = 0;
long long t1 = 2333, t2 = 6666;
if (tmp) {
if (t > tmp) {
t = t - tmp;
ans = 1;
} else if (t == tmp) {
ans = 1;
tmp = 0;
goto th;
} else {
tmp = tmp - t;
goto th;
}
}
t1 = t / m;
t2 = t % m;
tmp = m - t2;
if (t2 == 0) {
tmp == 0;
}
ans += t1;
th:
printf("%d ", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[111];
bool vis[111];
int f[111][111][2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), vis[a[i]] = 1;
int tot = 0, one = 0;
for (int i = 1; i <= n; i++)
if (vis[i] == 0) {
tot++;
if (i & 1) one++;
}
for (int j = 0; j <= one; j++) f[1][j][0] = f[1][j][1] = 0x3f3f3f3f;
if (a[1] > 0)
f[1][0][a[1] & 1] = 0;
else
f[1][0][0] = f[1][1][1] = 0;
for (int i = 2; i <= n; i++)
for (int j = 0; j <= one; j++) {
if (a[i] > 0) {
if (a[i] & 1) {
f[i][j][1] = min(f[i - 1][j][0] + 1, f[i - 1][j][1]);
f[i][j][0] = 0x3f3f3f3f;
} else {
f[i][j][0] = min(f[i - 1][j][0], f[i - 1][j][1] + 1);
f[i][j][1] = 0x3f3f3f3f;
}
} else {
f[i][j][0] = min(f[i - 1][j][0], f[i - 1][j][1] + 1);
if (j == 0)
f[i][j][1] = 0x3f3f3f3f;
else
f[i][j][1] = min(f[i - 1][j - 1][0] + 1, f[i - 1][j - 1][1]);
}
}
printf("%d\n", min(f[n][one][0], f[n][one][1]));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long max(long long a, long long b) { return a > b ? a : b; }
bool r(long long p1, long long p2) { return (p2 < p1); }
long long min(long long a, long long b) { return a < b ? a : b; }
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
const int N = 9;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a);
}
a = (a * a);
b >>= 1;
}
return ans;
}
void solve() {
string s;
cin >> s;
long long l = s.length();
long long dp[l + 1], lower[l + 1], upper[l + 1];
lower[0] = 0;
for (int i = 1; i < l; i++) {
lower[i] = lower[i - 1] + (s[i - 1] >= 'a' && s[i - 1] <= 'z');
}
upper[l - 1] = 0;
for (int i = l - 2; i >= 0; i--) {
upper[i] = upper[i + 1] + (s[i + 1] >= 'A' && s[i + 1] <= 'Z');
}
long long ans = l + 1;
for (int i = 0; i < l; i++) {
ans = min(ans, upper[i] + lower[i]);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long N, M, K, Ans;
vector<pair<int, pair<long long, long long> > > mods[1000005];
long long bit[2][1000005];
long long query(int t, int x) {
long long sum = 0;
for (; x; x -= (x & -x)) sum += bit[t][x];
return sum;
}
long long maxp;
void modify(int t, int x, long long d) {
for (; x <= maxp; x += (x & -x)) bit[t][x] += d;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K >> M;
long long Li, Ri, Ci, Pi;
maxp = 0;
for (int i = 1; i <= M; i++) {
cin >> Li >> Ri >> Ci >> Pi;
mods[Li].push_back(make_pair(0, make_pair(Ci, Pi)));
mods[Ri + 1].push_back(make_pair(1, make_pair(Ci, Pi)));
maxp = max(maxp, Pi);
}
bool Mod = true;
long long Prv = -1;
for (int i = 1; i <= N; i++) {
for (pair<int, pair<long long, long long> > mi : mods[i]) {
int tp = mi.first;
long long ci = mi.second.first, pi = mi.second.second;
if (!tp) {
modify(0, pi, ci);
modify(1, pi, ci * pi);
} else {
modify(0, pi, -ci);
modify(1, pi, -ci * pi);
}
Mod = true;
}
if (!Mod) {
Ans += Prv;
} else {
int Lo = 0, Hi = maxp + 1;
while (Lo + 1 < Hi) {
int Md = (Lo + Hi) / 2;
long long C = query(0, Md);
if (C < K)
Lo = Md;
else
Hi = Md;
}
if (Hi == maxp + 1) {
Prv = query(1, maxp);
} else if (Hi == 1) {
Prv = K;
} else {
long long Kp = query(0, Hi - 1);
Prv = query(1, Hi - 1) + (K - Kp) * Hi;
}
Ans += Prv;
Mod = false;
}
}
cout << Ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long mod = 1e9 + 7;
inline long long gcd(long long a, long long b) {
return !b ? a : gcd(b, a % b);
}
inline long long q_pow(long long a, long long x) {
long long ans = 1, tmp = a;
while (x) {
if (x & 1) (ans *= tmp) %= mod;
(tmp *= tmp) %= mod;
x >>= 1;
}
return ans;
}
template <typename T>
inline void re(T &N) {
int f = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') f = -1;
N = c - '0';
while ((c = getchar()) >= '0' && c <= '9') N = N * 10 + c - '0';
N *= f;
}
int m, n, t = 1, st, en;
int a[300][300], b[300][300];
int row[300], col[300];
pair<int, int> sta[300 * 300];
pair<int, pair<int, int> > ins[N];
int cnt;
int main() {
re(m);
re(n);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) re(a[i][j]);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) row[i] = max(row[i], a[i][j]);
for (int j = 1; j <= n; j++)
for (int i = 1; i <= m; i++) col[j] = max(col[j], a[i][j]);
for (int i = 1; i <= m; i++) sta[row[i]].first = 1;
for (int i = 1; i <= n; i++) sta[col[i]].second = 1;
int r = 0, c = 0;
for (int i = m * n; i >= 1; i--) {
if (sta[i].first && sta[i].second) {
r++;
c++;
b[r][c] = i;
} else if (sta[i].first) {
r++;
b[r][c] = i;
} else if (sta[i].second) {
c++;
b[r][c] = i;
}
}
sort(row + 1, row + m + 1, greater<int>());
sort(col + 1, col + n + 1, greater<int>());
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (!b[i][j]) ins[++cnt] = {min(row[i], col[j]), {i, j}};
sort(ins + 1, ins + cnt + 1, greater<pair<int, pair<int, int> > >());
cnt = 0;
for (int i = m * n; i >= 1; i--)
if (!sta[i].first && !sta[i].second) {
cnt++;
b[ins[cnt].second.first][ins[cnt].second.second] = i;
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) printf("%d%c", b[i][j], " \n"[j == n]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int n, r;
string ans;
int cal(int a, int b, bool type = 0) {
int ret = 0, tot = 0;
ans.clear();
char cur = 'B';
while (max(a, b) > 1 && min(a, b) >= 1) {
if (a < b) swap(a, b);
int z = a / b;
if (b == 1) {
z = a - 1;
a = 1;
} else
a %= b;
ret += z - 1;
tot += z;
if (type) {
while (z--) ans += cur;
if (cur == 'B')
cur = 'T';
else
cur = 'B';
}
}
if (tot != n - 1 || min(a, b) < 1) return -1;
if (type) {
if (ans.size() && ans.back() == 'T')
for (char &c : ans) {
if (c == 'T')
c = 'B';
else
c = 'T';
}
ans += 'T';
}
if (a == b && a == 1) return ret;
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> r;
if (n == 1) {
if (r > 1)
cout << "IMPOSSIBLE\n";
else
cout << "0\nT\n";
return 0;
}
int mn = 1e9, ind = -1;
for (int i = 1; i < r; i++) {
int z = cal(i, r);
if (~z && z < mn) mn = z, ind = i;
}
if (mn > 1e8)
cout << "IMPOSSIBLE\n";
else {
cal(ind, r, 1);
cout << mn << "\n";
reverse(ans.begin(), ans.end());
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void Boost() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
Boost();
int a, b;
cin >> a >> b;
if (a == b) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s, s1;
long long int n, i, j, k, l, x;
long long int tc, m, mx, mn, flag;
int ar[10007], br[20004], a, b, c, d;
void process() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> ar[i];
}
for (i = 0; i < n; i++) {
for (int j = i + 2; j < n; j++) {
if (ar[i] == ar[j]) {
flag = 1;
}
}
}
if (flag == 1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
int main() {
cin >> tc;
while (tc--) {
flag = 0;
process();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char st[100005];
int main() {
int n;
int m;
scanf("%d %d", &n, &m);
scanf("%s", st);
vector<int> vt;
int cnt = 1;
for (int i = 1; i < n; i++) {
if (st[i] == st[i - 1])
cnt++;
else {
vt.push_back(cnt);
cnt = 1;
}
}
vt.push_back(cnt);
long long ans = 1ll * vt.size() * (n * m - n);
cnt = 0;
for (int i = 1; i < n; i++) {
if (st[i] != st[i - 1]) {
if (i >= 2 && st[i - 2] == st[i])
cnt++;
else
cnt = 2;
} else {
cnt = 1;
}
if (cnt) ans -= cnt - 1;
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 211;
vector<pair<int, int> > con[maxn];
vector<pair<int, int> > edge;
bool vis[maxn];
int n, w, tmx, tv, ans;
void dfs(int x, int dis) {
vis[x] = 1;
if (dis > tmx) tmx = dis, tv = x;
for (int i = 0; i < con[x].size(); i++)
if (!vis[con[x][i].first] && w != con[x][i].second)
dfs(con[x][i].first, dis + 1);
}
int go(int x) {
memset(vis, 0, sizeof(vis));
tmx = tv = 0, dfs(x, 0);
memset(vis, 0, sizeof(vis));
tmx = 0, dfs(tv, 0);
return tmx;
}
int main() {
scanf("%d", &n);
int x, y;
for (int i = 1; i < n; i++) {
scanf("%d %d", &x, &y);
con[x].push_back(make_pair(y, i));
con[y].push_back(make_pair(x, i));
edge.push_back(make_pair(x, y));
}
for (w = 1; w < n; w++)
ans = max(ans, go(edge[w - 1].first) * go(edge[w - 1].second));
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s;
cin >> s;
int q[3000];
for (int i = 0; i < s; i++) {
int a, b, c;
cin >> a >> b >> c;
int min = abs(a - b) + abs(a - c) + abs(b - c);
if (abs(a - b) + abs(a - (c + 1)) + abs(b - (1 + c)) < min) {
min = abs(a - b) + abs(a - (c + 1)) + abs(b - (1 + c));
}
if (abs(a - (1 + b)) + abs(a - (c + 1)) + abs((b + 1) - (1 + c)) < min) {
min = abs(a - (1 + b)) + abs(a - (c + 1)) + abs((b + 1) - (1 + c));
}
if (abs(a - (1 + b)) + abs(a - c) + abs((b + 1) - c) < min) {
min = abs(a - (1 + b)) + abs(a - c) + abs((b + 1) - c);
}
if (abs(a - b) + abs(a - (c - 1)) + abs(b - (c - 1)) < min) {
min = abs(a - b) + abs(a - (c - 1)) + abs(b - (c - 1));
}
if (abs(a - (b - 1)) + abs(a - c) + abs((b - 1) - c) < min) {
min = abs(a - (b - 1)) + abs(a - c) + abs((b - 1) - c);
}
if (abs(a - (b - 1)) + abs(a - (c - 1)) + abs((b - 1) - (c - 1)) < min) {
min = abs(a - (b - 1)) + abs(a - (c - 1)) + abs((b - 1) - (c - 1));
}
if (abs(a - (b + 1)) + abs(a - (c - 1)) + abs((b + 1) - (c - 1)) < min) {
min = abs(a - (b + 1)) + abs(a - (c - 1)) + abs((b + 1) - (c - 1));
}
if (abs(a - (b - 1)) + abs(a - (c + 1)) + abs((b - 1) - (c + 1)) < min) {
min = abs(a - (b - 1)) + abs(a - (c + 1)) + abs((b - 1) - (c + 1));
}
if (abs(a + 1 - b) + abs(a + 1 - (c + 1)) + abs(b - (1 + c)) < min) {
min = abs(a + 1 - b) + abs(a + 1 - (c + 1)) + abs(b - (1 + c));
}
if (abs(a + 1 - (1 + b)) + abs(a + 1 - (c + 1)) + abs((b + 1) - (1 + c)) <
min) {
min =
abs(a + 1 - (1 + b)) + abs(a + 1 - (c + 1)) + abs((b + 1) - (1 + c));
}
if (abs(a + 1 - (1 + b)) + abs(a + 1 - c) + abs((b + 1) - c) < min) {
min = abs(a + 1 - (1 + b)) + abs(a + 1 - c) + abs((b + 1) - c);
}
if (abs(a + 1 - b) + abs(a + 1 - (c - 1)) + abs(b - (c - 1)) < min) {
min = abs(a + 1 - b) + abs(a + 1 - (c - 1)) + abs(b - (c - 1));
}
if (abs(a + 1 - (b - 1)) + abs(a + 1 - c) + abs((b - 1) - c) < min) {
min = abs(a + 1 - (b - 1)) + abs(a + 1 - c) + abs((b - 1) - c);
}
if (abs(a + 1 - (b - 1)) + abs(a + 1 - (c - 1)) + abs((b - 1) - (c - 1)) <
min) {
min =
abs(a + 1 - (b - 1)) + abs(a + 1 - (c - 1)) + abs((b - 1) - (c - 1));
}
if (abs(a + 1 - (b + 1)) + abs(a + 1 - (c - 1)) + abs((b + 1) - (c - 1)) <
min) {
min =
abs(a + 1 - (b + 1)) + abs(a + 1 - (c - 1)) + abs((b + 1) - (c - 1));
}
if (abs(a + 1 - (b - 1)) + abs(a + 1 - (c + 1)) + abs((b - 1) - (c + 1)) <
min) {
min =
abs(a + 1 - (b - 1)) + abs(a + 1 - (c + 1)) + abs((b - 1) - (c + 1));
}
if (abs(a + 1 - b) + abs(a + 1 - c) + abs(b - c) < min) {
min = abs(a + 1 - b) + abs(a + 1 - c) + abs(b - c);
}
if (abs(a - 1 - b) + abs(a - 1 - (c + 1)) + abs(b - (1 + c)) < min) {
min = abs(a - 1 - b) + abs(a - 1 - (c + 1)) + abs(b - (1 + c));
}
if (abs(a - 1 - (1 + b)) + abs(a - 1 - (c + 1)) + abs((b + 1) - (1 + c)) <
min) {
min =
abs(a - 1 - (1 + b)) + abs(a - 1 - (c + 1)) + abs((b + 1) - (1 + c));
}
if (abs(a - 1 - (1 + b)) + abs(a - 1 - c) + abs((b + 1) - c) < min) {
min = abs(a - 1 - (1 + b)) + abs(a - 1 - c) + abs((b + 1) - c);
}
if (abs(a - 1 - b) + abs(a - 1 - (c - 1)) + abs(b - (c - 1)) < min) {
min = abs(a - 1 - b) + abs(a - 1 - (c - 1)) + abs(b - (c - 1));
}
if (abs(a - 1 - (b - 1)) + abs(a - 1 - c) + abs((b - 1) - c) < min) {
min = abs(a - 1 - (b - 1)) + abs(a - 1 - c) + abs((b - 1) - c);
}
if (abs(a - 1 - (b - 1)) + abs(a - 1 - (c - 1)) + abs((b - 1) - (c - 1)) <
min) {
min =
abs(a - 1 - (b - 1)) + abs(a - 1 - (c - 1)) + abs((b - 1) - (c - 1));
}
if (abs(a - 1 - (b + 1)) + abs(a - 1 - (c - 1)) + abs((b + 1) - (c - 1)) <
min) {
min =
abs(a - 1 - (b + 1)) + abs(a - 1 - (c - 1)) + abs((b + 1) - (c - 1));
}
if (abs(a - 1 - (b - 1)) + abs(a - 1 - (c + 1)) + abs((b - 1) - (c + 1)) <
min) {
min =
abs(a - 1 - (b - 1)) + abs(a - 1 - (c + 1)) + abs((b - 1) - (c + 1));
}
if (abs(a - 1 - b) + abs(a - 1 - c) + abs(b - c) < min) {
min = abs(a - 1 - b) + abs(a - 1 - c) + abs(b - c);
}
q[i] = min;
}
for (int i = 0; i < s; i++) {
cout << q[i] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int maxN = 1 << 19;
vector<int> G[maxN], H[maxN];
int vis[maxN];
char out[maxN];
void fail() {
printf("-1\n");
exit(0);
}
void dfs0(int v) {
vis[v] = 1;
for (int u : G[v]) {
if (vis[u] == 1) fail();
if (vis[u] == 0) dfs0(u);
}
vis[v] = 2;
}
void dfs(int v) {
vis[v] |= 1;
for (int u : G[v])
if (!((vis[u]) >> (0) & 1)) dfs(u);
}
void dfsr(int v) {
vis[v] |= 4;
for (int u : H[v])
if (!((vis[u]) >> (2) & 1)) dfsr(u);
}
void solve() {
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
H[b].push_back(a);
}
for (int i = (1); i < (n + 1); i++)
if (vis[i] == 0) dfs0(i);
fill(out + 1, out + n + 1, 'E');
int res = 0;
for (int i = (1); i < (n + 1); i++) {
if (vis[i] == 2) out[i] = 'A', res++;
dfs(i);
dfsr(i);
}
printf("%d\n%s\n", res, out + 1);
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
long long ans = 0;
int n, num = 0, fst[500010], a[500010], root = 1, lg[500010];
struct edge {
int x, y, n;
} e[1000010];
struct pnt {
int fa[20], dep;
} p[500010];
void ins(int x, int y) {
e[++num] = {x, y, fst[x]};
fst[x] = num;
}
void dfs(int x, int fa) {
p[x].fa[0] = fa;
p[x].dep = p[fa].dep + 1;
long long mn = 1LL * (lg[p[x].dep - p[fa].dep] + 1) * a[fa] + a[x];
for (int i = 1; i <= 19; i++) {
p[x].fa[i] = p[p[x].fa[i - 1]].fa[i - 1];
mn = min(mn, 1LL * (lg[p[x].dep - p[p[x].fa[i]].dep] + 1) * a[p[x].fa[i]] +
a[x]);
}
if (x != root) ans += mn;
for (int i = fst[x]; i; i = e[i].n) {
int y = e[i].y;
if (y == fa) continue;
dfs(y, x);
}
}
int main() {
scanf("%d", &n);
lg[1] = 1;
for (int i = 2; i <= n; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n; i <<= 1) lg[i]--;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] < a[root]) root = i;
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
ins(x, y);
ins(y, x);
}
dfs(root, root);
printf("%lld\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
struct O {
double l, r;
} b[20010 * 80];
int i, j, k, n, m, t, tt, an;
int f[20010 * 80];
double x, y, rr, c[20010 * 80];
inline void Into(double l, double r) {
b[++t] = (O){l, r};
c[++tt] = l;
c[++tt] = r;
}
inline int find(double x) {
int l = 1, r = m, mid;
for (; l <= r;) {
mid = (l + r) / 2;
if (abs(c[mid] - x) < (1e-8)) return mid;
if (c[mid] < x)
l = mid + 1;
else
r = mid - 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%lf%lf%lf", &x, &y, &rr);
double ng = x * x + y * y;
double dis = sqrt(ng);
int L = int(ceil(dis - rr - (1e-8)) + (1e-8)), R = int(dis + rr + (1e-8));
L = (L - 1) / m + 1, R /= m;
for (; L <= R; L++) {
double ri = L * m;
double ang = atan2(y, x);
double A = (ri * ri + ng - rr * rr) / 2 / ri / dis;
A = abs(acos(A));
double l = ang - A;
double r = ang + A;
if (l < -pi) l += 2 * pi;
if (r > pi) r -= 2 * pi;
if (l <= r)
Into(l, r);
else
Into(l, pi), Into(-pi, r);
}
}
sort(c + 1, c + tt + 1);
m = 0;
for (i = 1; i <= tt; i++)
if (i == 1 || c[i] > c[m] + (1e-8)) c[++m] = c[i];
for (i = 1; i <= t; i++) {
int A = find(b[i].l);
f[A]++;
A = find(b[i].r) + 1;
f[A]--;
}
for (i = 1; i <= m; i++) f[i] += f[i - 1], an = max(an, f[i]);
printf("%d\n", an);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string ve[500];
int v[300005][10];
int poz[500];
unordered_set<string> us;
int sol, x1, x2;
bool se_pupa(string a, string b) {
for (int i = 0; i < m; i++)
if (a[i] + b[i] - '0' - '0' == 0) return false;
return true;
}
bool valid(int val) {
us.clear();
int contor = 0;
for (int i = 1; i <= n; i++) {
string str = "";
for (int j = 1; j <= m; j++) {
if (v[i][j] >= val) {
str += '1';
} else
str += '0';
}
if (us.count(str) == 0) {
us.insert(str);
ve[++contor] = str;
poz[contor] = i;
}
}
for (int i = 1; i <= contor; i++) {
for (int j = i; j <= contor; j++) {
if (se_pupa(ve[i], ve[j]) == true) {
x1 = poz[i];
x2 = poz[j];
return true;
}
}
}
return false;
}
void cb(int st, int dr) {
if (st > dr) return;
int mid = (st + dr) / 2;
if (valid(mid) == true) {
sol = mid;
cb(mid + 1, dr);
} else
cb(st, mid - 1);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cin >> v[i][j];
}
cb(0, 1000000000);
cout << x1 << " " << x2;
return 0;
}
| 6 |
#include <bits/stdc++.h>
inline int getInt() {
int s;
scanf("%d", &s);
return s;
}
using namespace std;
struct Node {
long long highest;
int mxL;
int mxR;
int idxL;
int idxR;
Node(long long h, long long l, long long r, int il, int ir)
: highest(h), mxL(l), mxR(r), idxL(il), idxR(ir) {}
};
template <typename Data, typename Func>
class SegmentTree {
public:
int n;
std::vector<Data> data;
Func f;
Data d;
Data query(int a, int b, int k, int l, int r) const {
if (r <= a || b <= l) return d;
if (a <= l && r <= b)
return data[k];
else {
const Data v1 = query(a, b, k * 2 + 1, l, (l + r) / 2);
const Data v2 = query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(v1, v2);
}
}
SegmentTree(int nn, Func f, Data d) : f(f), d(d) {
n = 1;
while (n < nn) n *= 2;
data = std::vector<Data>(2 * n, d);
}
void update(int k, const Data &a) {
k += n - 1;
data[k] = a;
while (k > 0) {
k = (k - 1) / 2;
data[k] = f(data[k * 2 + 1], data[k * 2 + 2]);
}
}
Data query(int a, int b) const { return query(a, b, 0, 0, n); }
};
template <typename Data, typename Func>
SegmentTree<Data, Func> segtree(int numberOfElements, Data defaultValue,
Func mergeFunc) {
return SegmentTree<Data, Func>(numberOfElements, mergeFunc, defaultValue);
}
int main() {
const int n = getInt();
const int m = getInt();
vector<long long> d(n);
vector<long long> h(n);
for (int i = 0; i < (int)(n); i++) d[i] = getInt();
for (int i = 0; i < (int)(n); i++) h[i] = getInt();
vector<long long> ps(2 * n + 1);
for (int i = 0; i < (int)(2 * n); i++) ps[i + 1] = ps[i] + d[i % n];
const Node df(-1, 0, 0, 0, 0);
auto calc = [&](int l, int r) {
if (l == r) return 0ll;
return ps[r] - ps[l] + 2 * (h[l % n] + h[r % n]);
};
auto st = segtree(2 * n, df, [&](const Node &lhs, const Node &rhs) {
if (lhs.highest == -1) return rhs;
if (rhs.highest == -1) return lhs;
const int idxL = lhs.idxL;
const int idxR = rhs.idxR;
const long long la = calc(idxL, lhs.mxL);
const long long lb = calc(idxL, rhs.mxL);
const long long lc = calc(idxL, rhs.idxL);
const long long ml = max(max(la, lb), lc);
const int mxL = lc > la && lc > lb ? rhs.idxL : la > lb ? lhs.mxL : rhs.mxL;
const long long ra = calc(lhs.mxR, idxR);
const long long rb = calc(rhs.mxR, idxR);
const long long rc = calc(lhs.idxR, idxR);
const long long mr = max(max(ra, rb), rc);
const int mxR = rc > ra && rc > rb ? lhs.idxR : rb > ra ? rhs.mxR : lhs.mxR;
const long long t =
max(max(calc(lhs.mxR, rhs.mxL), calc(lhs.mxR, rhs.idxL)),
max(calc(lhs.idxR, rhs.mxL), calc(lhs.idxR, rhs.idxL)));
const long long highest = max(
t,
max(max(max(lhs.highest, rhs.highest), max(ml, mr)), calc(idxL, idxR)));
return Node(highest, mxL, mxR, idxL, idxR);
});
for (int i = 0; i < (int)(2 * n); i++) st.update(i, Node(0, i, i, i, i));
for (int i = 0; i < (int)(m); i++) {
const int a = getInt() - 1;
const int b = getInt() - 1;
const int aa = b + 1;
const int bb = a <= b ? a + n - 1 : a - 1;
const Node ans = st.query(aa, bb + 1);
cout << ans.highest << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
const int mod = 1000000000 + 7;
int p[maxn];
long long dp[maxn];
int main() {
int i, n;
cin >> n;
for (i = 1; i <= n; i++) cin >> p[i];
dp[1] = 0;
for (int i = 1; i <= n; i++)
dp[i + 1] = (2 * dp[i] - dp[p[i]] + 2 + mod) % mod;
cout << dp[n + 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1010;
int dp[2][M][M][2], n, m, k;
void inc(int& x, int y) {
if (x < y) x = y;
}
char s[M], t[M];
int main() {
scanf("%d%d%d%s%s", &n, &m, &k, s + 1, t + 1);
for (int iter = 1; iter <= k; iter++) {
int now = iter & 1, pre = 1 - now;
memset(dp[now], 0, sizeof dp[now]);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (i > 0) {
inc(dp[now][i][j][0],
max(dp[now][i - 1][j][0], dp[now][i - 1][j][1]));
}
if (j > 0) {
inc(dp[now][i][j][0],
max(dp[now][i][j - 1][0], dp[now][i][j - 1][1]));
}
if (i > 0 && j > 0 && s[i] == t[j]) {
inc(dp[now][i][j][1],
max(dp[pre][i - 1][j - 1][0], dp[pre][i - 1][j - 1][1]) + 1);
inc(dp[now][i][j][1], dp[now][i - 1][j - 1][1] + 1);
}
}
}
}
printf("%d\n", max(dp[k & 1][n][m][0], dp[k & 1][n][m][1]));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
long long sp(long long v, long long u, long long w) {
long long sm = 0;
while (v != u) {
if (v < u) {
swap(v, u);
}
sm = sm + mp[v];
mp[v] += w;
v /= 2;
}
return sm;
}
int main() {
long long n, x, v, u, w;
cin >> n;
while (n--) {
cin >> x;
if (x == 1) {
cin >> v >> u >> w;
sp(v, u, w);
} else {
cin >> v >> u;
cout << sp(v, u, 0) << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[2][2][31][31][31], n, h, mod = 1000000009;
int main() {
memset(dp, 0, sizeof dp);
cin >> n >> h;
for (int i = 0; i < 2; i++) {
for (int d1 = 0; d1 <= h; d1++) {
for (int d2 = 0; d2 <= h; d2++) {
for (int d3 = 0; d3 <= h; d3++) {
dp[(n + 1) % 2][i][d1][d2][d3] = (i || d1 || d2 || d3);
}
}
}
}
for (int i = n; i >= 1; i--) {
for (int alive = 0; alive < 2; alive++) {
for (int d1 = 0; d1 <= h; d1++) {
for (int d2 = 0; d2 <= h; d2++) {
for (int d3 = 0; d3 <= h; d3++) {
dp[i % 2][alive][d1][d2][d3] = 0;
dp[i % 2][alive][d1][d2][d3] +=
dp[(i + 1) % 2][alive][(!d1 || d1 == h) ? 0 : (d1 + 1)]
[(!d2 || d2 == h) ? 0 : (d2 + 1)]
[(!d3 || d3 == h) ? 0 : (d3 + 1)];
dp[i % 2][alive][d1][d2][d3] +=
dp[(i + 1) % 2][d1 || i < h][!alive || alive == h ? 0 : 2]
[(!d2 || d2 == h) ? 0 : (d2 + 1)]
[(!d3 || d3 == h) ? 0 : (d3 + 1)];
dp[i % 2][alive][d1][d2][d3] +=
dp[(i + 1) % 2][d2 || i < h][!alive || alive == h ? 0 : 2]
[(!d1 || d1 == h) ? 0 : (d1 + 1)]
[(!d3 || d3 == h) ? 0 : (d3 + 1)];
dp[i % 2][alive][d1][d2][d3] +=
dp[(i + 1) % 2][d3 || i < h][!alive || alive == h ? 0 : 2]
[(!d1 || d1 == h) ? 0 : (d1 + 1)]
[(!d2 || d2 == h) ? 0 : (d2 + 1)];
dp[i % 2][alive][d1][d2][d3] %= mod;
}
}
}
}
}
cout << dp[1][1][1][1][1] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[5001], caracter[12502502];
short int end_pos[12502502];
int nodes = 1, n;
int last[12502502], Next[12502502];
int getID(int cur, int c) {
for (int to = last[cur]; to != -1; to = Next[to])
if (caracter[to] == c) return to;
return -1;
}
void add(int pos) {
int cur = 0;
for (int i = pos, c, nxt; s[i]; i++) {
c = s[i] - 'a';
nxt = getID(cur, c);
if (nxt == -1)
caracter[nodes] = c, Next[nodes] = last[cur], end_pos[nodes] = i,
last[cur] = nodes, cur = nodes++;
else
cur = nxt;
}
}
int memo[5001], a, b;
int DP(int pos) {
if (pos == n) return 0;
int &ret = memo[pos];
if (ret != -1) return ret;
int ans = a + DP(pos + 1);
int cur = 0;
char c;
for (int i = pos, nxt; i < n; i++) {
c = s[i] - 'a';
cur = getID(cur, c);
if (end_pos[cur] >= pos) break;
ans = min(ans, b + DP(i + 1));
}
return ret = ans;
}
int main() {
cin >> n >> a >> b;
scanf("%s", s);
memset(last, -1, sizeof last);
for (int i = 0; i < n; i++) add(i);
memset(memo, -1, sizeof memo);
int ans = DP(0);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0)
return (b);
else
return (gcd(b % a, a));
}
long long int fastpow(long long int a, long long int n, long long int temp) {
if (n == 0) return (1);
if (n == 1) return ((a * temp) % 1000000007);
if (n & 1) temp = (temp * a) % 1000000007;
return (fastpow((a * a) % 1000000007, n / 2, temp));
}
char dum;
long long int bit[1000005];
int ind[1000005], req[1000005];
void update(int ind, int val) {
for (int i = ind; i <= 1000000; i += i & -i) {
bit[i] += val;
}
}
long long int query(int ind) {
long long int res = 0;
for (int i = ind; i > 0; i -= i & -i) {
res += bit[i];
}
return res;
}
int main() {
int n, k, a, beg, end;
cin >> n >> k;
set<int> s;
set<int>::iterator it;
memset(bit, 0, sizeof(bit));
memset(req, 0, sizeof(req));
s.insert(0), s.insert(n + 1);
for (int i = 1; i < n + 1; i++) {
cin >> a;
ind[a] = i;
update(i, 1);
}
for (int i = 1; i < k + 1; i++) {
cin >> a;
req[a] = 1;
}
long long int ans = 0;
for (int i = 1; i < n + 1; i++) {
if (req[i] == 1) {
s.insert(ind[i]);
} else {
it = s.lower_bound(ind[i]);
it--;
beg = *it;
it = s.upper_bound(ind[i]);
end = *it;
ans += query(end - 1) - query(beg);
update(ind[i], -1);
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
bool f = false;
int r1, r2, c1, c2, d1, d2, a, b, c, d;
scanf("%d%d%d%d%d%d", &r1, &r2, &c1, &c2, &d1, &d2);
for (a = 1; a < 10; ++a) {
for (b = 1; b < 10; ++b) {
if (a == b) continue;
for (c = 1; c < 10; ++c) {
if (a == c || b == c) continue;
for (d = 1; d < 10; ++d) {
if (a == d || b == d || c == d) continue;
if (a + b == r1 && c + d == r2 && a + c == c1 && b + d == c2 &&
a + d == d1 && b + c == d2) {
f = true;
printf("%d %d\n%d %d\n", a, b, c, d);
}
}
}
}
}
if (!f) puts("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res = 0;
cin >> n;
vector<int> v;
vector<pair<int, int> > vv;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
v.push_back(c);
}
sort(v.begin(), v.end());
int cnt = 1;
for (int i = 1; i < n; i++) {
if (v[i] != v[i - 1]) {
vv.push_back(make_pair(v[i - 1], cnt));
cnt = 1;
} else
cnt++;
}
vv.push_back(make_pair(v[n - 1], cnt));
for (int i = 0; i < vv.size(); i++) {
int temp = vv[i].first, j = i + 1;
cnt = vv[i].second;
while ((vv[j].first - temp) <= 5 && j < vv.size()) {
cnt += vv[j].second;
j++;
}
res = max(res, cnt);
}
cout << res << endl;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 30;
int a[N];
const int M = 3e6 + 10;
vector<pair<int, int>> me[M];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
n = min(n, 2000);
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
int diff = max(a[i], a[j]) - min(a[i], a[j]);
if (me[diff].size()) {
int first = me[diff][0].first;
int second = me[diff][0].second;
if (i != first && j != second && i != second && j != first) {
cout << "YES" << endl;
int ii = i;
int jj = j;
if (a[i] < a[j]) swap(ii, jj);
cout << ii << " " << second << " " << jj << " " << first << endl;
return 0;
}
}
if (me[diff].size())
continue;
if (a[i] > a[j]) {
me[a[i] - a[j]].push_back({ i,j });
}
else {
me[a[j] - a[i]].push_back({ j,i });
}
}
}
cout << "NO" << endl;
} | 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
int n;
int a[100001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int maxx = -1;
for (int i = 1; i <= n; i++) {
if (a[i] > maxx + 1) {
cout << i;
return 0;
}
maxx = max(maxx, a[i]);
}
cout << "-1";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string answer[512];
string change(string k) {
string x = "";
for (int i = 0; i < k.length(); i++) {
x += (k[i] == '+') ? "*" : "+";
}
return x;
}
int main() {
int k;
cin >> k;
if (k == 0) {
cout << "+" << endl;
return 0;
}
int cur = 2;
answer[0] = "++";
answer[1] = "+*";
for (int j = 0; j < k - 1; j++) {
string ans2[512];
for (int i = 0; i < cur; i++) {
ans2[i] = answer[i];
ans2[i] += answer[i];
}
for (int i = cur; i < 2 * cur; i++) {
ans2[i] = answer[i - cur];
ans2[i] += change(answer[i - cur]);
}
cur *= 2;
for (int i = 0; i < cur; i++) answer[i] = ans2[i];
}
for (int i = 0; i < cur; i++) cout << answer[i] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
vector<int> suffix_array(char *t, int N) {
int A = 128;
vector<int> sa(N);
vector<int> c(max(A, N));
vector<int> rank(N);
vector<int> sa2(N);
for (int i = 0; i < A; ++i) c[i] = 0;
for (int i = 0; i < N; ++i) c[rank[i] = t[i]]++;
for (int i = 1; i < A; ++i) c[i] += c[i - 1];
for (int i = N - 1; i >= 0; --i) sa[--c[t[i]]] = i;
for (int n = 1; n < N; n *= 2) {
int r = 0;
for (int i = N - n; i < N; ++i) sa2[r++] = i;
for (int i = 0; i < N; ++i)
if (sa[i] >= n) sa2[r++] = sa[i] - n;
for (int i = 0; i < A; ++i) c[i] = 0;
for (int i = 0; i < N; ++i) c[rank[i]]++;
for (int i = 1; i < A; ++i) c[i] += c[i - 1];
for (int i = N - 1; i >= 0; --i) sa[--c[rank[sa2[i]]]] = sa2[i];
sa2[sa[0]] = r = 0;
for (int i = 1; i < N; ++i) {
if (!(rank[sa[i - 1]] == rank[sa[i]] && sa[i - 1] + n < N &&
rank[sa[i - 1] + n] == rank[sa[i] + n]))
r++;
sa2[sa[i]] = r;
}
swap(rank, sa2);
if (r == N - 1) break;
A = r + 1;
}
return sa;
}
vector<int> lcp_array(char *s, const vector<int> &sa) {
int N = sa.size();
vector<int> rank(N);
vector<int> lcpa(N);
for (int i = 0; i < N; ++i) rank[sa[i]] = i;
for (int i = 0, lcp = 0; i < N; i++)
if (rank[i] == 0)
lcpa[0] = 0;
else {
int j = sa[rank[i] - 1];
if (lcp > 0) lcp--;
while (s[i + lcp] == s[j + lcp]) lcp++;
lcpa[rank[i]] = lcp;
}
return lcpa;
}
char s[5000005];
int ans[5000005];
int main() {
int N, K;
scanf("%d", &N), scanf("%d", &K);
scanf("%s", s);
if (K == 1) {
for (int i = 0; i < (N); i++) {
s[i] = '1';
}
puts(s);
return 0;
}
auto sa = suffix_array(s, N);
auto lcpa = lcp_array(s, sa);
int i = 0;
while (i < N) {
if (sa[i] == 0) break;
i++;
}
int j = i + 1, lcp = N;
while (j < N) {
lcp = min(lcp, lcpa[j]);
long long p = sa[j];
if (p * K <= p + lcp) {
ans[p * K - 1]++;
ans[min(p + lcp, p * (K + 1))]--;
}
j++;
}
j = i - 1, lcp = N;
while (j >= 0) {
lcp = min(lcp, lcpa[j + 1]);
long long p = sa[j];
if (p * K <= p + lcp) {
ans[p * K - 1]++;
ans[min(p + lcp, p * (K + 1))]--;
}
j--;
}
for (int i = 0; i < (N); i++) {
assert(ans[i] >= 0);
ans[i + 1] += ans[i];
if (ans[i])
s[i] = '1';
else
s[i] = '0';
}
puts(s);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
point(double aa, double bb) : x(aa), y(bb) {}
};
double sq(double x) { return x * x; }
double dist(point p1, point p2) {
return sqrt(sq(p1.x - p2.x) + sq(p1.y - p2.y));
}
double dist2(point v, point w) { return sqrt(v.x - w.x) + sqrt(v.y - w.y); }
double pDistance(double x, double y, double x1, double y1, double x2,
double y2) {
double A = x - x1;
double B = y - y1;
double C = x2 - x1;
double D = y2 - y1;
double dot = A * C + B * D;
double len_sq = C * C + D * D;
double param = -1;
if (len_sq != 0) param = dot / len_sq;
double xx, yy;
if (param < 0) {
xx = x1;
yy = y1;
} else if (param > 1) {
xx = x2;
yy = y2;
} else {
xx = x1 + param * C;
yy = y1 + param * D;
}
double dx = x - xx;
double dy = y - yy;
return sqrt(dx * dx + dy * dy);
}
int n;
const int n_ = 1001;
vector<point> P;
struct vec {
double x, y;
vec(double _x, double _y) : x(_x), y(_y) {}
};
vec toVec(point a, point b) { return vec(b.x - a.x, b.y - a.y); }
double cross(vec a, vec b) { return a.x * b.y - a.y * b.x; }
bool ccw(point p, point q, point r) {
return cross(toVec(p, q), toVec(p, r)) > 0;
}
bool isConvex() {
int sz = (int)P.size();
if (sz <= 3) return false;
bool isLeft = ccw(P[0], P[1], P[2]);
for (int i = 1; i < sz - 1; i++)
if (ccw(P[i], P[i + 1], P[(i + 2) == sz ? 1 : i + 2]) != isLeft)
return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i <= n - 1; i++) {
double a, b;
cin >> a >> b;
P.push_back(point(a, b));
}
double res = 1e11;
for (int i = 0; i <= n - 1; i++) {
double here = pDistance(P[i].x, P[i].y, P[(i - 1) == -1 ? n - 1 : i - 1].x,
P[(i - 1) == -1 ? n - 1 : i - 1].y,
P[(i + 1) == n ? 0 : i + 1].x,
P[(i + 1) == n ? 0 : i + 1].y) /
2;
res = min(res, here);
}
cout << setprecision(7) << fixed << res << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string beautiful_numbers() {
int size, input;
string result = "";
cin >> size;
int position[size];
for (int i = 0; i < size; i++) {
cin >> input;
position[input - 1] = i;
}
int min = size + 1;
int max = -1;
for (int i = 0; i < size; i++) {
if (min > position[i]) {
min = position[i];
}
if (max < position[i]) {
max = position[i];
}
if ((max - min) == i) {
result.push_back('1');
} else {
result.push_back('0');
}
}
return result;
}
int main() {
int size;
cin >> size;
vector<string> results;
for (int i = 0; i < size; i++) {
results.push_back(beautiful_numbers());
}
for (string s : results) {
cout << s << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int v[1200000], c[1200000], t1[1200000], t2[1200000], q1[1200000], q2[1200000],
K, n, n1, n2, ans[1200000];
double pr[1200000];
int main() {
scanf("%d%d", &n, &K);
for (int i = (1); i <= (n); ++i) scanf("%d", &v[i]);
for (int i = (1); i <= (n); ++i) scanf("%d", &c[i]);
int R = n, p1 = 1, p2 = 1;
t1[0] = n + 1;
t2[0] = n + 1;
for (int i = n; i >= 1; --i) {
while (n2 > 0 && v[i] >= q2[n2]) n2--;
q2[++n2] = v[i];
t2[n2] = i;
while (n1 > 0 && c[i] <= q1[n1]) n1--;
q1[++n1] = c[i];
t1[n1] = i;
p1 = min(p1, n1);
p2 = min(p2, n2);
while (R > i && q2[p2] * 100 > q1[p1]) {
R--;
if (R < t2[p2]) p2++;
if (R < t1[p1]) p1++;
}
ans[i] = min(100 * q2[p2], q1[p1]);
if (t1[p1 - 1] == t2[p2 - 1])
ans[i] = max(ans[i], min(100 * q2[p2 - 1], q1[p1 - 1]));
else if (t1[p1 - 1] > t2[p2 - 1])
ans[i] = max(ans[i], min(100 * q2[p2 - 1], q1[p1]));
else if (t1[p1 - 1] < t2[p2 - 1])
ans[i] = max(ans[i], min(100 * q2[p2], q1[p1 - 1]));
}
sort(ans + 1, ans + n + 1);
pr[0] = (double)K / (n - K + 1);
for (int i = (0); i <= (n - 1); ++i)
pr[i + 1] = pr[i] / (n - i) * (n - i - K + 1);
double fans = 0;
for (int i = (1); i <= (n); ++i) fans += ans[i] * pr[i];
printf("%lf\n", fans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using std::map;
using std::pair;
long long N, Pow[20];
map<std::pair<long long, int>, std::pair<long long, int> > dp;
std::pair<long long, int> DP(long long N, int dep, int m) {
if (dep == 1) return std::make_pair((1LL), (int(N - std::max(m * 1ll, N))));
if (N < Pow[dep - 1]) return DP(N, dep - 1, m);
std::pair<long long, int>& ans = dp[std::make_pair((N), (m))];
if (ans.first) return ans;
std::pair<long long, int> tmp =
DP(N % Pow[dep - 1], dep - 1,
std::max(m, static_cast<int>(N / Pow[dep - 1])));
std::pair<long long, int> res = DP(N - N % Pow[dep - 1] + tmp.second, dep, m);
return ans = std::make_pair((tmp.first + res.first), (res.second));
}
int main() {
Pow[0] = 1;
for (int i = 1; i <= 18; i++) Pow[i] = Pow[i - 1] * 10;
scanf("%I64d", &N);
long long Other = N;
int bit = 0;
for (; Other; Other /= 10) bit++;
long long Answer = (!N ? 0 : DP(N, bit, 0).first);
printf("%I64d\n", Answer);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, i, a[105], y, z = 0, s = 0;
cin >> n >> x;
memset(a, 0, sizeof a);
for (i = 0; i < n; i++) {
cin >> y;
a[y]++;
}
for (i = 0; i <= 100; i++) {
if (i == x && a[x] == 0) {
cout << z;
break;
} else if (i == x && a[x] == 1) {
cout << z + 1;
break;
}
if (a[i] == 0)
z++;
else
s++;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define si(a) scanf("%d",&a)
#define sii(a,b) scanf("%d %d",&a,&b)
#define siii(a,b,c) scanf("%d %d %d",&a,&b,&c)
#define sl(a) scanf("%lld",&a)
#define sll(a,b) scanf("%lld %lld",&a,&b)
#define slll(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)
#define pf printf
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define PB pop_back
#define mp make_pair
#define all(a) a.begin(),a.end()
#define F(i,n) for(i=0;i<n;i++)
#define FR(i,n) for(i=n;i>0;i--)
#define FT(i,n) for(i=1;i<=n;i++)
vl a;
void ordinarry_number(){
int x = 0;
for(int i=1;i<=9;i++){
x = x+1;
for(int j=1;j<=9;j++){
a.pb(j*x);
}
x=x*10;
}
}
void solve(){
int t;
ordinarry_number();
si(t);
while (t--){
ll n;
cin>>n;
ll l = lower_bound(all(a),n)-a.begin();
if(a[l]!=n){
l--;
}
cout<<l+1<<endl;
}
}
int main(){
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
solve();
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, x;
long long ans = 0;
long long pre[1000000 + 5];
long long last[1000000 + 5];
void isi() {
memset(pre, 0, sizeof pre);
for (long long i = 1; i <= 1000000; i++) {
pre[i] = i + pre[i - 1];
}
for (long long i = 1; i <= 1000000; i++) {
pre[i] += pre[i - 1];
}
for (long long i = 1; i <= 1000000; i++) {
pre[i] = pre[i] * 2 - i;
}
}
int main() {
memset(last, -1, sizeof last);
isi();
scanf("%I64d", &n);
ans = pre[n];
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &x);
if (last[x] != -1) {
ans -= 2 * (n - i + 1) * (last[x]);
}
last[x] = i;
}
printf("%.6lf\n", (double)ans / n / n);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int v = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
v = v * 10 + c - '0';
c = getchar();
}
return v * f;
}
struct po {
int from, to, dis, nxt, w;
} edge[250001];
int head[250001], cur[1000001], dep[60001], n, m, s, t, u,
num = -1, x, y, l, tot, sum, k, fa[10001];
int dis[5001], b[5001], xb[5001], flow[5001];
inline void add_edge(int from, int to, int w, int dis) {
edge[++num].nxt = head[from];
edge[num].from = from;
edge[num].to = to;
edge[num].w = w;
edge[num].dis = dis;
head[from] = num;
}
inline void add(int from, int to, int w, int dis) {
add_edge(from, to, w, dis);
add_edge(to, from, 0, -dis);
}
inline bool bfs() {
memset(dis, 100, sizeof(dis));
memset(b, 0, sizeof(b));
queue<int> q;
while (!q.empty()) q.pop();
for (register int i = 1; i <= n; i++) {
fa[i] = -1;
}
b[s] = 1;
dis[s] = 0;
fa[s] = 0;
flow[s] = 1000000000;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
b[u] = 0;
for (register int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].to;
if (edge[i].w > 0 && dis[v] > dis[u] + edge[i].dis) {
dis[v] = dis[u] + edge[i].dis;
fa[v] = u;
xb[v] = i;
flow[v] = min(flow[u], edge[i].w);
if (!b[v]) {
b[v] = 1, q.push(v);
}
}
}
}
return dis[t] < 1000000000;
}
vector<int> V;
vector<int> S;
inline void max_flow() {
while (bfs()) {
int k = t;
while (k != s) {
edge[xb[k]].w -= flow[t];
edge[xb[k] ^ 1].w += flow[t];
k = fa[k];
}
tot += flow[t];
for (int i = 0; i < flow[t]; i++) V.push_back(dis[t]);
sum += flow[t] * dis[t];
}
}
int main() {
memset(head, -1, sizeof(head));
n = read();
m = read();
s = 1;
t = n;
for (register int i = 1; i <= m; i++) {
x = read();
y = read();
l = 1;
int d = read();
add(x, y, l, d);
}
max_flow();
S.resize(V.size());
S[0] = V[0];
for (int i = 1; i < V.size(); i++) S[i] = S[i - 1] + V[i];
int q = read();
while (q--) {
int x;
x = read();
int lo = 0, hi = V.size();
while (hi - lo > 1) {
int mid = lo + hi >> 1;
if (S[mid - 1] + x >= V[mid] * (mid))
lo = mid;
else
hi = mid;
}
int tmp = (lo == 0) ? 0 : (V[lo] * (lo)-S[lo - 1]);
x -= tmp;
double ans = V[lo] + (double)x / (lo + 1);
printf("%.10lf\n", ans);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int p[1000001];
int main() {
int n, ind = 0, w, input;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> input;
p[input]++;
if (ind < p[input]) {
ind = p[input];
w = input;
}
}
cout << w << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int f(char c) {
if (c >= 'A' && c <= 'Z')
return 10 + c - 'A';
else
return c - '0';
}
int Pow(int i, int k) {
int sum = 1;
for (int j = 0; j < k; j++) sum *= i;
return sum;
}
char a[10], b[10], c[20];
int x[10], y[10], total, mn, lx, ly, res[210];
int solve() {
int i;
for (i = mn + 1; i < 62; i++) {
int flag = 0;
int sum = 0;
for (int j = lx - 1, k = 0; j >= 0; j--, k++) {
sum += x[j] * Pow(i, k);
}
if (sum > 23) flag = 1;
sum = 0;
for (int j = ly - 1, k = 0; j >= 0; j--, k++) {
sum += y[j] * Pow(i, k);
}
if (sum > 59) flag = 1;
if (!flag) {
res[total++] = i;
if (i >= 60) return 2;
}
}
if (total == 0)
return 0;
else
return 1;
}
int main() {
scanf("%s", c);
int i, j;
for (i = 0, j = 0; i < strlen(c); i++) {
if (c[i] == ':') break;
a[j++] = c[i];
}
a[j] = '\0';
i++;
for (j = 0; i < strlen(c); i++) {
if (c[i] == ':') break;
b[j++] = c[i];
}
b[j] = '\0';
for (i = 0; i < strlen(a); i++)
if (a[i] != '0') break;
lx = 0, ly = 0;
for (; i < strlen(a); i++) x[lx++] = f(a[i]);
for (i = 0; i < strlen(b); i++)
if (b[i] != '0') break;
for (; i < strlen(b); i++) y[ly++] = f(b[i]);
mn = 0;
if (!lx) lx = 1;
if (!ly) ly = 1;
for (int i = 0; i < lx; i++)
if (mn < x[i]) mn = x[i];
for (int i = 0; i < ly; i++)
if (mn < y[i]) mn = y[i];
total = 0;
if (mn == 0) mn = 1;
int nnn = solve();
if (nnn > 1)
printf("-1\n");
else if (nnn == 0)
printf("0\n");
else {
for (i = 0; i < total; i++)
printf("%d%c", res[i], i == total - 1 ? '\n' : ' ');
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, Q, fa[N], sz[N], row[N];
vector<int> v[N];
map<int, int> mp[N];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> Q;
for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 0;
int r, c;
for (int i = 0; i < Q; i++) {
cin >> r >> c;
v[r].push_back(c);
if (!row[c])
row[c] = r;
else {
int x = find(r), y = find(row[c]);
if (x != y) fa[x] = y;
}
}
for (int i = 1; i <= n; i++) {
int x = find(i);
for (int j = 0; j < v[i].size(); j++) {
int y = v[i][j];
if (!mp[x][y]) {
mp[x][y] = true;
sz[x]++;
}
}
}
int cnt = 0, res = 0;
for (int i = 1; i <= n; i++) {
if (i != fa[i]) continue;
cnt += sz[i];
res++;
}
res--;
res += (m - cnt);
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1000000001, INF = (ll)1e18 + 1;
ll take(ll &x, ll &y) {
ll tk = min(x, y);
x -= tk;
y -= tk;
return tk;
}
void solve() {
ll x[2], y[2], z[2];
cin >> x[0] >> y[0] >> z[0];
cin >> x[1] >> y[1] >> z[1];
ll sum = 0;
sum += 2 * take(z[0], y[1]);
take(z[1], x[0]);
take(z[0], z[1]);
take(y[0], x[1]);
take(y[0], y[1]);
sum -= 2 * take(z[1], y[0]);
cout << sum << endl;
}
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[5010][5010] = {0};
int main() {
int n, m;
cin >> n >> m;
string a, b;
cin >> a >> b;
int ans = 0;
a = " " + a;
b = " " + b;
for (int i = 1; i <= a.length() - 1; ++i) {
for (int j = 1; j <= b.length() - 1; ++j) {
if (a[i] == b[j]) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 2);
} else {
dp[i][j] = max(dp[i][j], max(dp[i - 1][j], dp[i][j - 1]) - 1);
}
ans = max(ans, dp[i][j]);
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
int n, m;
int k[3];
char a[1 << 7][1 << 7];
int ddx[4] = {-1, -1, 0, 1};
int ddy[4] = {0, 1, -1, -1};
char b[2][2];
void imp() {
puts("IMPOSSIBLE");
exit(0);
}
int check(int x, int y) { return (x >= 0 && y >= 0 && x < n && y < m); }
void paint(int x, int y, char b[2][2]) {
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) a[x + i][y + j] = b[i][j];
}
int main() {
cin >> n >> m >> k[0] >> k[1] >> k[2];
if ((n & 1) && (m & 1)) imp();
memset(a, ' ', sizeof a);
int sx = 0, sy = 0;
if (n & 1) {
char c = 'a';
for (int j = 0; j < m; j += 2) {
if (!k[0]) imp();
--k[0];
a[0][j] = a[0][j + 1] = c;
if (c == 'a')
c = 'b';
else
c = 'a';
}
++sx;
}
if (m & 1) {
char c = 'a';
for (int i = 0; i < n; i += 2) {
if (!k[1]) imp();
--k[1];
a[i][0] = a[i + 1][0] = c;
if (c == 'a')
c = 'b';
else
c = 'a';
}
++sy;
}
for (int t = 0; t < 3; ++t) {
int dx = 2;
if (t == 2) dx = 1;
for (int i = sx; i < n; i += 2)
for (int j = sy; j < m; j += 2) {
if (k[t] < dx) break;
if (a[i][j] != ' ') continue;
k[t] -= dx;
char c1 = 'a', c2 = 'b';
while (c1 <= 'z') {
int ok = 1;
for (int tk = 0; tk < 4; ++tk) {
int nx = i + ddx[tk];
int ny = j + ddy[tk];
if (!check(nx, ny)) continue;
if (c1 == a[nx][ny]) ok = 0;
}
if (!ok)
++c1;
else
break;
}
while (c2 <= 'z') {
int ok = 1;
for (int tk = 0; tk < 4; ++tk) {
int nx = i + ddx[tk];
int ny = j + ddy[tk];
if (!check(nx, ny)) continue;
if (c2 == a[nx][ny]) ok = 0;
}
if (c1 == c2) ok = 0;
if (!ok)
++c2;
else
break;
}
if (t == 2) {
b[0][0] = b[0][1] = b[1][0] = b[1][1] = c1;
}
if (t == 1) {
b[0][0] = b[1][0] = c1;
b[0][1] = b[1][1] = c2;
}
if (t == 0) {
b[0][0] = b[0][1] = c1;
b[1][0] = b[1][1] = c2;
}
paint(i, j, b);
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (a[i][j] == ' ') imp();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cout << a[i][j];
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> a;
vector<int> q;
void read() {
cin >> n;
int ai;
cin >> ai;
a.push_back(ai);
for (int i = 1; i < n; ++i) {
cin >> ai;
a.push_back(a[i - 1] + ai);
}
cin >> m;
for (int i = 0; i < m; ++i) {
int qi;
cin >> qi;
q.push_back(qi);
}
}
int bin_search(int l, int r, int val) {
int mid = (l + r + 1) / 2;
if (a[mid] == val) return mid + 1;
if (a[mid] < val) {
if (a[mid + 1] >= val) return mid + 2;
if (a[mid + 1] < val) return bin_search(mid, r, val);
}
if (a[mid] > val) {
if (a[mid - 1] < val) return mid + 1;
if (a[mid - 1] == val) return mid;
if (a[mid - 1] > val) return bin_search(l, mid, val);
}
return -10;
}
void solve() {
for (int i = 0; i < m; ++i) {
if (q[i] < a[0]) {
cout << "1\n";
} else {
cout << bin_search(0, n - 1, q[i]) << '\n';
}
}
}
int main() {
read();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[100010];
struct node {
long long id, x, y, step;
bool operator<(const node& f) const { return x - y < f.x - f.y; }
};
long long ans = 0;
priority_queue<node> q;
void run(int T) {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ans += a[i] * a[i];
q.push((node){i, a[i] * a[i],
(a[i] / 2) * (a[i] / 2) * (2 - a[i] % 2) +
(a[i] / 2 + 1) * (a[i] / 2 + 1) * (a[i] % 2),
1});
}
for (int i = 1; i <= k - n; i++) {
node top = q.top();
q.pop();
ans += top.y - top.x;
long long j = top.step + 2;
long long tmp = (a[top.id] / j) * (a[top.id] / j) * (j - a[top.id] % j) +
(a[top.id] / j + 1) * (a[top.id] / j + 1) * (a[top.id] % j);
q.push((node){top.id, top.y, tmp, j - 1});
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
int T = 1;
for (int i = 1; i <= T; i++) run(i);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int PaperA, PaperB;
cin >> PaperA;
cin >> PaperB;
if (PaperA == PaperB) {
cout << "0 6 0" << endl;
} else if (PaperA == 1 && PaperB == 2) {
cout << "1 0 5" << endl;
} else if (PaperA == 1 && PaperB == 3) {
cout << "1 1 4" << endl;
} else if (PaperA == 1 && PaperB == 4) {
cout << "2 0 4" << endl;
} else if (PaperA == 1 && PaperB == 5) {
cout << "2 1 3" << endl;
} else if (PaperA == 1 && PaperB == 6) {
cout << "3 0 3" << endl;
} else if (PaperA == 2 && PaperB == 1) {
cout << "5 0 1" << endl;
} else if (PaperA == 2 && PaperB == 3) {
cout << "2 0 4" << endl;
} else if (PaperA == 2 && PaperB == 4) {
cout << "2 1 3" << endl;
} else if (PaperA == 2 && PaperB == 5) {
cout << "3 0 3" << endl;
} else if (PaperA == 2 && PaperB == 6) {
cout << "3 1 2" << endl;
} else if (PaperA == 3 && PaperB == 1) {
cout << "4 1 1" << endl;
} else if (PaperA == 3 && PaperB == 2) {
cout << "4 0 2" << endl;
} else if (PaperA == 3 && PaperB == 4) {
cout << "3 0 3" << endl;
} else if (PaperA == 3 && PaperB == 5) {
cout << "3 1 2" << endl;
} else if (PaperA == 3 && PaperB == 6) {
cout << "4 0 2" << endl;
} else if (PaperA == 4 && PaperB == 1) {
cout << "4 0 2" << endl;
} else if (PaperA == 4 && PaperB == 2) {
cout << "3 1 2" << endl;
} else if (PaperA == 4 && PaperB == 3) {
cout << "3 0 3" << endl;
} else if (PaperA == 4 && PaperB == 5) {
cout << "4 0 2" << endl;
} else if (PaperA == 4 && PaperB == 6) {
cout << "4 1 1" << endl;
} else if (PaperA == 5 && PaperB == 1) {
cout << "3 1 2" << endl;
} else if (PaperA == 5 && PaperB == 2) {
cout << "3 0 3" << endl;
} else if (PaperA == 5 && PaperB == 3) {
cout << "2 1 3" << endl;
} else if (PaperA == 5 && PaperB == 4) {
cout << "2 0 4" << endl;
} else if (PaperA == 5 && PaperB == 6) {
cout << "5 0 1" << endl;
} else if (PaperA == 6 && PaperB == 1) {
cout << "3 0 3" << endl;
} else if (PaperA == 6 && PaperB == 2) {
cout << "2 1 3" << endl;
} else if (PaperA == 6 && PaperB == 3) {
cout << "2 0 4" << endl;
} else if (PaperA == 6 && PaperB == 4) {
cout << "1 1 4" << endl;
} else if (PaperA == 6 && PaperB == 5) {
cout << "1 0 5" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &cout, vector<T> &a) {
for (size_t i = 0; i < a.size(); ++i) cout << a[i] << " ";
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, vector<vector<T> > &a) {
for (size_t i = 0; i < a.size(); ++i) cout << a[i] << endl;
return cout;
}
string s;
int a[100000];
int f(char s) {
if (s == 'A')
return 0;
else if (s == 'T')
return 1;
else if (s == 'G')
return 2;
else
return 3;
}
struct nyx {
int div5[5];
int div6[6];
int div7[7];
int div8[8];
int div9[9];
int div10[10];
} tree[400000][4];
void build(int x = 0, int l = 0, int r = s.size() - 1) {
if (l == r) {
tree[x][a[l]].div5[0] = 1;
tree[x][a[l]].div6[0] = 1;
tree[x][a[l]].div7[0] = 1;
tree[x][a[l]].div8[0] = 1;
tree[x][a[l]].div9[0] = 1;
tree[x][a[l]].div10[0] = 1;
return;
}
int m = (l + r) / 2;
build(2 * x + 1, l, m);
build(2 * x + 2, m + 1, r);
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 5; ++j) {
tree[x][i].div5[j] =
tree[2 * x + 1][i].div5[j] +
tree[2 * x + 2][i].div5[((j + l - m - 1) % 5 + 5) % 5];
}
for (int j = 0; j < 6; ++j) {
tree[x][i].div6[j] =
tree[2 * x + 1][i].div6[j] +
tree[2 * x + 2][i].div6[((j + l - m - 1) % 6 + 6) % 6];
}
for (int j = 0; j < 7; ++j) {
tree[x][i].div7[j] =
tree[2 * x + 1][i].div7[j] +
tree[2 * x + 2][i].div7[((j + l - m - 1) % 7 + 7) % 7];
}
for (int j = 0; j < 8; ++j) {
tree[x][i].div8[j] =
tree[2 * x + 1][i].div8[j] +
tree[2 * x + 2][i].div8[((j + l - m - 1) % 8 + 8) % 8];
}
for (int j = 0; j < 9; ++j) {
tree[x][i].div9[j] =
tree[2 * x + 1][i].div9[j] +
tree[2 * x + 2][i].div9[((j + l - m - 1) % 9 + 9) % 9];
}
for (int j = 0; j < 10; ++j) {
tree[x][i].div10[j] =
tree[2 * x + 1][i].div10[j] +
tree[2 * x + 2][i].div10[((j + l - m - 1) % 10 + 10) % 10];
}
}
}
void update(int prev, int next, int l, int x = 0, int curL = 0,
int curR = s.size() - 1) {
if (l == curL && l == curR) {
tree[x][prev].div5[0] = 0;
tree[x][prev].div6[0] = 0;
tree[x][prev].div7[0] = 0;
tree[x][prev].div8[0] = 0;
tree[x][prev].div9[0] = 0;
tree[x][prev].div10[0] = 0;
tree[x][next].div5[0] = 1;
tree[x][next].div6[0] = 1;
tree[x][next].div7[0] = 1;
tree[x][next].div8[0] = 1;
tree[x][next].div9[0] = 1;
tree[x][next].div10[0] = 1;
return;
}
int m = (curL + curR) / 2;
if (l <= m)
update(prev, next, l, 2 * x + 1, curL, m);
else
update(prev, next, l, 2 * x + 2, m + 1, curR);
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 5; ++j) {
tree[x][i].div5[j] =
tree[2 * x + 1][i].div5[j] +
tree[2 * x + 2][i].div5[((j + curL - m - 1) % 5 + 5) % 5];
}
for (int j = 0; j < 6; ++j) {
tree[x][i].div6[j] =
tree[2 * x + 1][i].div6[j] +
tree[2 * x + 2][i].div6[((j + curL - m - 1) % 6 + 6) % 6];
}
for (int j = 0; j < 7; ++j) {
tree[x][i].div7[j] =
tree[2 * x + 1][i].div7[j] +
tree[2 * x + 2][i].div7[((j + curL - m - 1) % 7 + 7) % 7];
}
for (int j = 0; j < 8; ++j) {
tree[x][i].div8[j] =
tree[2 * x + 1][i].div8[j] +
tree[2 * x + 2][i].div8[((j + curL - m - 1) % 8 + 8) % 8];
}
for (int j = 0; j < 9; ++j) {
tree[x][i].div9[j] =
tree[2 * x + 1][i].div9[j] +
tree[2 * x + 2][i].div9[((j + curL - m - 1) % 9 + 9) % 9];
}
for (int j = 0; j < 10; ++j) {
tree[x][i].div10[j] =
tree[2 * x + 1][i].div10[j] +
tree[2 * x + 2][i].div10[((j + curL - m - 1) % 10 + 10) % 10];
}
}
}
int find(int obj, int mod, int val, int l, int r, int x = 0, int curL = 0,
int curR = s.size() - 1) {
if (l > r || curL > curR) return 0;
if (curL == l && curR == r) {
int ans = 0;
if (mod == 5) {
ans += tree[x][obj].div5[val % 5];
} else if (mod == 7) {
ans += tree[x][obj].div7[val % 7];
} else if (mod == 8) {
ans += tree[x][obj].div8[val % 8];
} else if (mod == 4) {
ans += tree[x][obj].div8[val % 8] + tree[x][obj].div8[(val + 4) % 8];
} else if (mod == 2) {
ans += tree[x][obj].div8[val % 8] + tree[x][obj].div8[(val + 2) % 8] +
tree[x][obj].div8[(val + 4) % 8] +
tree[x][obj].div8[(val + 6) % 8];
} else if (mod == 9) {
ans += tree[x][obj].div9[val % 9];
} else if (mod == 3) {
ans += tree[x][obj].div9[val % 9] + tree[x][obj].div9[(val + 3) % 9] +
tree[x][obj].div9[(val + 6) % 9];
} else if (mod == 1) {
for (int i = 0; i < 5; ++i) {
ans += tree[x][obj].div5[i];
}
} else if (mod == 6) {
ans += tree[x][obj].div6[val % 6];
} else if (mod == 10) {
ans += tree[x][obj].div10[val % 10];
}
return ans;
}
int m = (curL + curR) / 2;
if (m < l)
return find(obj, mod, val, l, r, 2 * x + 2, m + 1, curR);
else if (m >= r)
return find(obj, mod, val, l, r, 2 * x + 1, curL, m);
return find(obj, mod, val, l, m, 2 * x + 1, curL, m) +
find(obj, mod, ((val - (m - l + 1)) % mod + mod) % mod, m + 1, r,
2 * x + 2, m + 1, curR);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
for (int i = 0; i < s.size(); ++i) {
a[i] = f(s[i]);
}
build();
int q;
cin >> q;
int t, l, r;
string tmp;
int ans = 0;
while (q--) {
cin >> t;
if (t == 1) {
cin >> l >> tmp;
--l;
update(f(s[l]), f(tmp[0]), l);
s[l] = tmp[0];
} else {
cin >> l >> r >> tmp;
--l;
--r;
ans = 0;
for (int i = 0; i < tmp.size(); ++i) {
ans += find(f(tmp[i]), tmp.size(), i, l, r);
}
cout << ans << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
int main() {
fast();
const int N = 2e6 + 15;
int n, m;
cin >> n;
int l = 0, r = 0, t;
vector<int> a(N, 0);
for (int i = 0; i < n; i++) {
cin >> t;
l = r + 1;
r += t;
a[l]++;
}
for (int i = 1; i < N; i++) a[i] = a[i] + a[i - 1];
cin >> m;
for (int i = 0; i < m; i++) cin >> t, cout << a[t] << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j, sum = 0;
string s;
cin >> n >> k >> s;
sort(s.begin(), s.end());
sum = sum + s[0] - 96;
k--;
for (i = 0; i < n - 1 && k > 0; i = j) {
for (j = i + 1; j < n; j++)
if (s[j] - s[i] > 1) {
sum += s[j] - 96;
k--;
break;
}
}
if (k > 0)
printf("-1\n");
else
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char cH;
string sA;
int i, N, A[100000], MAX = 0, res = 0, k;
cin >> N;
for (i = 1; i <= N; i++) {
cin >> A[i];
if (A[i] > MAX) {
MAX = A[i];
}
}
while (MAX >= A[1]) {
for (i = 2; i <= N; i++) {
if (A[i] == MAX) {
A[i]--;
A[1]++;
res++;
if (A[1] >= MAX) break;
}
}
MAX = 0;
for (i = 2; i <= N; i++) {
if (A[i] > MAX) {
MAX = A[i];
}
}
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)(2e6) + 10;
vector<int> ed[N], ed2[N];
int n, m;
vector<int> a[N];
int num[N], low[N], dd[N], pa[N];
stack<int> Stack;
int cnt, cntcom;
vector<int> Com[N];
void add(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first)
ed[a.second].push_back(b.second), ed[b.second].push_back(a.second);
else
ed[a.second].push_back(b.second);
}
void visit(int u) {
low[u] = num[u] = ++cnt;
Stack.push(u);
for (int i = 0; i <= (int)ed[u].size() - 1; i++) {
int v = ed[u][i];
if (dd[v]) continue;
if (pa[v] == -1) {
pa[v] = u;
visit(v);
low[u] = min(low[u], low[v]);
} else
low[u] = min(low[u], num[v]);
}
if (low[u] == num[u]) {
cntcom++;
while (Stack.top() != u) {
Com[cntcom].push_back(Stack.top());
dd[Stack.top()] = cntcom;
Stack.pop();
}
Com[cntcom].push_back(u);
dd[Stack.top()] = cntcom;
Stack.pop();
}
}
vector<pair<int, int> > b;
int dev[N];
queue<int> Queue;
int d[N], val[N];
void TOPO() {
for (int i = 1; i <= cntcom; i++)
if (!dev[i]) {
Queue.push(i);
d[i] = 1;
}
while (!Queue.empty()) {
int u = Queue.front();
Queue.pop();
for (int i = 0; i <= (int)ed2[u].size() - 1; i++) {
int v = ed2[u][i];
dev[v]--;
if (!dev[v]) {
Queue.push(v);
d[v] = d[u] + 1;
}
}
}
for (int i = 1; i <= cntcom; i++)
for (int j = 0; j <= (int)Com[i].size() - 1; j++) val[Com[i][j]] = d[i];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
a[i].clear();
for (int j = 1; j <= m; j++) {
int x;
scanf("%d", &x);
a[i].push_back(x);
}
}
for (int i = 1; i <= n; i++) {
b.clear();
for (int j = 1; j <= m; j++)
b.push_back(make_pair(a[i][j - 1], (i - 1) * m + j));
sort(b.begin(), b.end());
for (vector<pair<int, int> >::iterator it = b.begin() + 1; it != b.end();
it++)
add(*(it - 1), *it);
}
for (int j = 1; j <= m; j++) {
b.clear();
for (int i = 1; i <= n; i++)
b.push_back(make_pair(a[i][j - 1], (i - 1) * m + j));
sort(b.begin(), b.end());
for (vector<pair<int, int> >::iterator it = b.begin() + 1; it != b.end();
it++)
add(*(it - 1), *it);
}
for (int i = 1; i <= n * m; i++) pa[i] = -1;
for (int i = 1; i <= n * m; i++)
if (pa[i] == -1) {
pa[i] = i;
visit(i);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int kk = (i - 1) * m + j;
for (int k = 0; k <= (int)ed[kk].size() - 1; k++) {
int kkk = ed[kk][k];
if (dd[kk] != dd[kkk]) {
ed2[dd[kk]].push_back(dd[kkk]);
dev[dd[kkk]]++;
}
}
}
TOPO();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d ", val[(i - 1) * m + j]);
printf("\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, d, a[N], b[N];
long long x;
int getNextX() {
x = (x * 37 + 10007) % 1000000007;
return x;
}
void initAB() {
for (int i = 0; i < n; i = i + 1) {
a[i] = i + 1;
}
for (int i = 0; i < n; i = i + 1) {
swap(a[i], a[getNextX() % (i + 1)]);
}
for (int i = 0; i < n; i = i + 1) {
if (i < d)
b[i] = 1;
else
b[i] = 0;
}
for (int i = 0; i < n; i = i + 1) {
swap(b[i], b[getNextX() % (i + 1)]);
}
}
int idx[N], c[N];
int main() {
cin >> n >> d >> x;
initAB();
for (int i = 0; i < n; ++i) idx[a[i]] = i;
vector<int> vec;
for (int i = 0; i < n; ++i) {
if (b[i]) vec.push_back(i);
for (int v = n; v >= 1 && v >= n - 300; v--) {
int j = idx[v];
if (i >= j && b[i - j]) {
c[i] = v;
break;
}
}
if (!c[i]) {
for (int z = 0; z < vec.size(); ++z) {
int k = vec[z];
c[i] = max(c[i], a[i - k]);
}
}
printf("%d\n", c[i]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
vector<pair<int, int> > v;
for (int i = c; i <= a; i++) {
for (int j = d; j <= b; j++) {
if (i > j) v.push_back(make_pair(i, j));
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long res = 0;
int num(long long n) {
int num = 0;
while (n) {
n /= 10;
num++;
}
return num;
}
long long find(long long n) {
int ex = num(n);
long long cur = 0, ad = 1;
for (int i = 0; i <= ex - 1; i++) {
cur += ad;
ad *= 10;
}
if (cur <= n) return cur;
return ((cur - 1) / 10);
}
long long process(long long n) {
if (n <= 6) {
return n;
}
if (n <= 11) return (13 - n);
long long tmp = find(n);
long long more = tmp * 10 + 1;
if (n % tmp == 0) {
long long t = n / tmp;
if (n <= more / 2 + tmp)
return num(tmp) * t;
else {
long long cur = process(more - n);
return num(more) + cur;
}
} else {
long long _m = (n / tmp) * tmp;
long long res = process(_m) + process(n - _m);
if (n > more / 2)
res = min(process(_m) + process(n - _m), num(more) + process(more - n));
return res;
}
}
int main() {
long long n;
cin >> n;
cout << process(n) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int a[maxn];
vector<int> V[maxn * 2];
long long powa(long long x, long long y) {
long long res = 1;
while (y) {
if (y % 2) res = res * x;
y /= 2;
x = x * x;
}
return res;
}
void work(int val) {
for (int i = 2; 1LL * i * i <= val; i++) {
if (val % i == 0) {
int res = 0;
while (val % i == 0) {
res++;
val /= i;
}
V[i].push_back(res);
}
}
if (val) {
V[val].push_back(1);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
work(a[i]);
}
long long res = 1;
for (int i = 2; i < maxn * 2; i++) {
if (V[i].size()) {
int zero_num = n - V[i].size();
if (zero_num >= 2) continue;
int idx = 1 - zero_num;
sort(V[i].begin(), V[i].end());
res = res * powa(i, V[i][idx]);
}
}
printf("%lld\n", res);
}
| 4 |
#include <bits/stdc++.h>
char s[800005], ans[800006], b[800005];
struct node {
int n;
char c;
} a[800005];
int tot, n;
int read() {
int t = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
t = t * 10 + ch - '0';
ch = getchar();
}
return t * f;
}
int main() {
int limitnum = 0, m = 0;
n = read();
scanf("%s", s + 1);
std::sort(s + 1, s + 1 + n);
s[0] = '&';
for (int i = 1; i <= n; i++)
if (s[i] != s[i - 1]) {
a[++m].c = s[i];
a[m].n = 1;
} else
a[m].n++;
for (int i = 1; i <= m; i++)
if (a[i].n % 2) limitnum++;
if (limitnum == 0) {
int num = 1;
for (int i = 1; i <= n / 2; i++) ans[i] = ans[n - i + 1] = s[num], num += 2;
printf("%d\n", 1);
for (int i = 1; i <= n; i++) printf("%c", ans[i]);
return 0;
}
for (int i = 1; i <= n; i++)
if (i >= limitnum && n % i == 0 && (n / i) % 2 == 1 &&
(i - limitnum) % 2 == 0) {
tot = i;
break;
}
int ss = 0;
for (int i = 1; i <= m; i++)
if (a[i].n % 2) {
a[i].n--;
b[++ss] = a[i].c;
}
int rou = 1;
while (ss < tot) {
while (a[rou].n && ss < tot) {
b[++ss] = a[rou].c;
b[++ss] = a[rou].c;
a[rou].n -= 2;
}
if (!a[rou].n) rou++;
}
int k = 1;
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) {
for (int j = 1; j <= (n / tot) / 2; j++) {
while (!a[k].n && k < m) k++;
ans[j] = ans[(n / tot) - j + 1] = a[k].c, a[k].n -= 2;
}
ans[((n / tot) / 2) + 1] = b[i];
for (int j = 1; j <= n / tot; j++) printf("%c", ans[j]);
printf(" ");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, MOD = 1E9 + 7;
int miu[N], a[N], cnt[N];
int n, m;
long long pow2[N];
bool v[N];
void init(int n) {
pow2[0] = 1;
for (int i = 1; i <= n; i++) {
pow2[i] = (pow2[i - 1] + pow2[i - 1]) % MOD;
}
for (int i = 1; i <= n; i++) miu[i] = 1, v[i] = 0;
for (int i = 2; i <= n; i++) {
if (v[i]) continue;
miu[i] = -1;
for (int j = 2 * i; j <= n; j += i) {
v[j] = 1;
if ((j / i) % i == 0)
miu[j] = 0;
else
miu[j] *= -1;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
m = max(m, a[i]);
cnt[a[i]]++;
}
init(N - 5);
long long ans = pow2[n] - 1;
for (int i = 2; i <= m; i++) {
int sum = 0;
for (int j = i; j <= m; j += i) sum = (1LL * sum + cnt[j]) % MOD;
ans = (ans + 1LL * miu[i] * (pow2[sum] - 1) % MOD + MOD) % MOD;
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
int n, a, b, k, f;
cin >> n >> a >> b >> k >> f;
string p[n][2];
for (int i = 0; i < n; i++) cin >> p[i][0] >> p[i][1];
map<pair<string, string>, int> cnt;
for (int i = 0; i < n; i++)
if (i == 0 || p[i - 1][1] != p[i][0])
cnt[{min(p[i][0], p[i][1]), max(p[i][0], p[i][1])}] += a;
else
cnt[{min(p[i][0], p[i][1]), max(p[i][0], p[i][1])}] += b;
vector<int> cost;
for (auto it : cnt) cost.push_back(it.second);
sort(cost.begin(), cost.end(), [](int x, int y) { return x > y; });
int sum = 0;
for (int i : cost)
if (i > f && k > 0) {
sum += f;
k--;
} else
sum += i;
cout << sum << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
bool doubleEqual(long double a, long double b) { return fabs(a - b) < EPS; }
bool doubleLessOrEqual(long double a, long double b) {
return doubleEqual(a, b) || a < b;
}
bool doubleLess(long double a, long double b) {
return !doubleEqual(a, b) && a < b;
}
bool doubleGreaterOrEqual(long double a, long double b) {
return a > b || doubleEqual(a, b);
}
bool doubleGreater(long double a, long double b) {
return a > b && !doubleEqual(a, b);
}
long double mySqrt(long double a) {
if (a < 0) {
return 0;
}
return sqrt(a);
}
long double sqr(long double a) { return a * a; }
struct Point {
long double x, y;
Point() : x(0), y(0) {}
Point(long double x, long double y) : x(x), y(y) {}
Point operator-(const Point &p) const { return {x - p.x, y - p.y}; }
Point operator+(const Point &p) const { return {x + p.x, y + p.x}; }
Point &operator+=(const Point &p) {
x += p.x, y += p.y;
return *this;
}
long double operator%(const Point &p) const { return x * p.x + y * p.y; }
long double operator*(const Point &p) const { return x * p.y - p.x * y; }
Point operator/(long double k) const { return {x / k, y / k}; }
Point &operator/=(long double k) {
x /= k;
y /= k;
return *this;
}
bool operator<(const Point &p) const {
return x < p.x || (x == p.x && y < p.y);
}
Point operator*(long double k) const { return {x * k, y * k}; }
Point &operator*=(long double k) {
x *= k, y *= k;
return *this;
}
long double length() const { return mySqrt(*this % *this); }
long double distTo(const Point &p) const { return (*this - p).length(); }
long double distTo(const Point &A, const Point &B) const {
long double d = A.distTo(B);
long double s = (*this - A) * (*this - B);
return fabs(s) / d;
}
Point normalize(long double k = 1.0) const {
long double len = length();
return *this * (k / len);
}
Point getH(const Point &A, const Point &B) const {
Point C = *this;
Point v = B - A;
Point u = C - A;
long double k = v % u / v.length();
v = v.normalize(k);
Point H = A + v;
return H;
}
Point rotate() const { return {-y, x}; }
Point rotate(long double alpha) const {
Point v = *this;
Point w;
w.x = v.x * cos(alpha) - v.y * sin(alpha);
w.y = v.x * sin(alpha) + v.y * cos(alpha);
return w;
}
bool isOnLine(const Point &A, const Point &B) const {
return doubleEqual((*this - A) * (*this - B), 0.0);
}
bool isInSegment(const Point &A, const Point &B) const {
return isOnLine(A, B) && doubleLessOrEqual((A - *this) % (B - *this), 0);
}
bool isInSegmentStrictly(const Point &A, const Point &B) const {
return isOnLine(A, B) && doubleLess((A - *this) % (B - *this), 0);
}
long double getAngle() { return atan2(y, x); }
long double getAngle(const Point &p) const {
return atan2(p * *this, p % *this);
}
};
int getTangent(const Point &A, const Point &O, long double r, Point &M,
Point &N) {
Point v = O - A;
long double d = v.length();
long double alpha = asin(r / d);
long double L = mySqrt(sqr(d) - sqr(r));
v = v.normalize(L);
M = A + v.rotate(alpha);
N = A + v.rotate(-alpha);
if (doubleEqual(r, d)) return 1;
return 2;
}
istream &operator>>(istream &in, Point &A) {
in >> A.x >> A.y;
return in;
}
ostream &operator<<(ostream &in, Point &A) {
in << A.x << A.y;
return in;
}
Point O;
bool cmp(const Point &A, const Point &B) {
return (A - O) * (B - O) < 0 ||
((A - O) * (B - O) == 0 && (A - O).length() < (B - O).length());
}
vector<Point> convexHull(vector<Point> &a) {
vector<Point> convex;
convex.push_back(O);
for (int i = 1; i < a.size(); ++i) {
Point A = convex.back() - convex[convex.size() - 2],
B = a[i] - convex.back();
long double k = A * B;
while (convex.size() > 1 && ((convex.back() - convex[convex.size() - 2]) *
(a[i] - convex.back()) >=
0)) {
convex.pop_back();
}
convex.push_back(a[i]);
}
return convex;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
Point A, B, C, D, E, F, G, H;
cin >> A >> B >> C >> D >> E >> F >> G >> H;
set<Point> q;
map<pair<Point, Point>, bool> was;
was[{A, B}] = 1;
was[{C, D}] = 1;
was[{E, F}] = 1;
was[{G, H}] = 1;
q.insert(A);
q.insert(B);
q.insert(C);
q.insert(D);
q.insert(E);
q.insert(F);
q.insert(G);
q.insert(H);
if (q.size() != 4) {
cout << "NO\n";
return 0;
}
vector<Point> pts;
for (auto x : q) {
pts.push_back(x);
}
Point O1;
long double sq = 0;
sort(pts.begin(), pts.end());
O = pts[0];
sort(pts.begin() + 1, pts.end(), cmp);
pts = convexHull(pts);
for (int i = 0; i < 4; ++i) {
int next = (i + 1) % 4;
sq += (pts[i] - O1) * (pts[next] - O1);
if (!was[{pts[i], pts[next]}] && !was[{pts[next], pts[i]}]) {
cout << "NO\n";
return 0;
}
}
sq = abs(sq) / 2;
long double sq1 = pts[0].distTo(pts[1]) * pts[0].distTo(pts[3]);
if (sq == sq1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 200005;
int m, n, ta, tb, k, a[SIZE], b[SIZE], ans, p;
inline int max(int x, int y) {
if (x > y)
return x;
else
return y;
}
int main() {
scanf("%d%d%d%d%d", &n, &m, &ta, &tb, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
if (k >= n || k >= m) {
printf("-1\n");
return 0;
}
for (int i = 0; i <= k; ++i) {
while (a[i + 1] + ta > b[p] && p <= m) ++p;
if (p + k - i > m) {
ans = -1;
break;
}
ans = max(ans, b[p + k - i] + tb);
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int INF = 12345678;
using namespace std;
const int N = 1e5 + 7;
int st1[N][20], st2[N][20];
int a[N], dp[N];
struct node {
node(){};
node(int a1, int a2) : first(a1), second(a2){};
int first, second;
} q[N];
int query(int l, int r) {
if (l >= r) return 0;
int len = log2(r - l + 1);
return max(st1[l][len], st1[r - (1 << len) + 1][len]) -
min(st2[l][len], st2[r - (1 << len) + 1][len]);
}
int main() {
ios::sync_with_stdio(false);
int n, s, l;
cin >> n >> s >> l;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) st1[i][0] = st2[i][0] = a[i];
for (int j = 1; j < 20; j++) {
for (int i = 1; i <= n; i++) {
if (i + (1 << (j - 1)) <= n) {
st1[i][j] = max(st1[i][j - 1], st1[i + (1 << (j - 1))][j - 1]);
st2[i][j] = min(st2[i][j - 1], st2[i + (1 << (j - 1))][j - 1]);
}
}
}
if (l > n || query(1, l) > s) {
cout << -1 << endl;
return 0;
}
int head = 0, tail = 0;
q[tail++] = node(0, 0);
for (int i = 1; i <= n; i++) dp[i] = INF;
dp[0] = 0;
dp[l] = 1;
for (int i = l + 1; i <= n; i++) {
int L = 1, R = i - l + 1, ans = -1;
while (L <= R) {
int mid = (L + R) >> 1;
if (query(mid, i) <= s)
R = mid - 1, ans = mid;
else
L = mid + 1;
}
while (head < tail && q[tail - 1].first >= dp[i - l]) tail--;
q[tail++] = node(dp[i - l], i - l);
if (ans != -1) {
while (head < tail && q[head].second < ans - 1) head++;
if (head < tail && q[head].first != INF)
dp[i] = min(dp[i], q[head].first + 1);
}
}
if (dp[n] == INF) dp[n] = -1;
cout << dp[n] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, s;
cin >> n >> s;
cout << s / (n - (n - 1) / 2) << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int f[N][N], z[N][N], p[N], vis[N], x[N], y[N];
char s[100005];
int n = 0;
int parse(int &x) {
int res = 0;
while (s[x] >= '0' && s[x] <= '9') {
res = 10 * res + s[x] - '0';
++x;
}
++x;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
int j = 0, k = 0;
while (k < n - 1) {
z[i][++p[i]] = parse(j);
k += z[i][p[i]];
for (int l = 0; l < z[i][p[i]]; ++l) {
f[i][parse(j)] = p[i];
}
}
}
for (int l = 1; l < n; ++l) {
int i = 1;
while (i <= n) {
if (!vis[i] && p[i] == 1) {
break;
}
++i;
}
if (i > n) {
printf("-1");
return 0;
}
int j = 1;
while (j <= n) {
if (!vis[j] && z[j][f[j][i]] == 1) {
break;
}
++j;
}
if (j > n) {
printf("-1");
return 0;
}
for (int k = 1; k <= n; ++k) {
if (!vis[k] && k != i && k != j) {
if (f[k][j] != f[k][i]) {
printf("-1");
return 0;
}
--z[k][f[k][i]];
}
}
x[l] = i;
y[l] = j;
--p[j];
vis[i] = 1;
}
printf("%d\n", n - 1);
for (int l = 1; l < n; ++l) {
printf("%d %d\n", x[l], y[l]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct data {
unsigned long long a, b;
};
struct data f(unsigned long long a, unsigned long long b) {
data ret;
ret.a = a;
ret.b = b;
if (a == 0 or b == 0) return ret;
if (a >= b * 2) return f(a % (b * 2), b);
if (b >= a * 2)
return f(a, b % (a * 2));
else
return ret;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
unsigned long long a, b;
cin >> a >> b;
data ans = f(a, b);
cout << ans.a << " " << ans.b << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, m, valor, conte = 0, res = 0;
string porta;
cin >> a >> b >> c;
cin >> m;
vector<pair<int, string> > mv(m);
for (int i = 0; i < m; i++) {
cin >> valor >> porta;
mv[i] = make_pair(valor, porta);
}
sort(mv.begin(), mv.end());
for (int i = 0; i < mv.size(); i++) {
if (mv[i].second == "USB") {
if (a > 0 || c > 0) {
conte++;
res += mv[i].first;
if (a > 0)
a--;
else if (c > 0)
c--;
}
} else {
if (b > 0 || c > 0) {
conte++;
res += mv[i].first;
if (b > 0)
b--;
else if (c > 0)
c--;
}
}
}
cout << conte << " " << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, count = 0, l, check = 0;
cin >> n;
l = sqrt(n);
for (i = 2; i <= l; i++) {
if ((n % i) == 0) {
check = 1;
break;
}
}
if (check == 1) {
cout << 1 + (n - i) / 2;
} else {
cout << "1";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[100005], m = 1000000007, s;
int main() {
int i, j;
scanf("%d", &n);
a[1] = 20;
s = 20;
for (i = 2; i <= n; ++i) {
a[i] = a[i - 1];
a[i] *= 7;
a[i] %= m;
s *= 27;
s %= m;
s += a[i];
s %= m;
}
printf("%I64d", s);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string p = "a", u = "";
char now = 'a';
inline void sol(int x) {
if (x == 1) return;
if (x == 2) {
u = "a";
return;
}
if (x & 1) {
sol((x - 1) >> 1);
++now;
u = u + now + now;
p = p + now;
} else {
sol((x - 2) >> 1);
++now;
u = now + u + now + now;
p = p + now;
}
}
int n;
int main() {
scanf("%d", &n);
sol(n);
u = p + u;
cout << u << " " << p;
return 0;
}
| 7 |
#include <bits/stdc++.h>
template <typename _T>
inline bool read(_T& x) {
x = 0;
_T y = 1;
char c = getchar();
while ((c < '0' || '9' < c) && c != EOF) {
if (c == '-') y = -1;
c = getchar();
}
if (c == EOF) return false;
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getchar();
x *= y;
return true;
}
int N, M, top;
long long K, l[200007], r[200007], L[200007], R[200007], a[200007 << 2];
long long f[200007 << 1][3], g[3];
int b[200007 << 1], B[200007 << 1];
inline int find(int x) { return std::lower_bound(a + 1, a + top + 1, x) - a; }
inline long long qpow(long long x, long long p) {
long long ans = 1;
while (p) {
if (p & 1) (ans *= x) %= 1000000007;
(x *= x) %= 1000000007;
p >>= 1;
}
return ans;
}
int main() {
read(K), read(N), read(M);
a[++top] = 0, a[++top] = K;
for (int i = 1; i <= N; ++i) {
read(l[i]), read(r[i]);
a[++top] = --l[i], a[++top] = r[i];
}
for (int i = 1; i <= M; ++i) {
read(L[i]), read(R[i]);
a[++top] = --L[i], a[++top] = R[i];
}
std::sort(a + 1, a + top + 1);
top = std::unique(a + 1, a + top + 1) - a - 1;
int p, P;
long long x;
for (int i = 1; i <= top; ++i) b[i] = B[i] = top + 1;
for (int i = 1; i <= N; ++i) {
p = find(l[i]);
b[p] = std::min(b[p], find(r[i]));
}
for (int i = 1; i <= M; ++i) {
P = find(L[i]);
B[P] = std::min(B[P], find(R[i]));
}
for (int i = top - 1; i; --i)
b[i] = std::min(b[i], b[i + 1]), B[i] = std::min(B[i], B[i + 1]);
f[top][0] = f[top][1] = f[top][2] = 1;
for (int i = top - 1; i; --i) {
g[2] = f[i + 1][2] *
((qpow(2LL, a[i + 1] - a[i]) - 2 + 1000000007) % 1000000007) %
1000000007;
for (int j = 0; j <= 1; ++j)
g[j ^ 1] =
(f[i + 1][j] - f[j == 1 ? b[i] : B[i]][j] + 1000000007) % 1000000007;
f[i][0] = (f[i + 1][0] + g[0] + g[2]) % 1000000007;
f[i][1] = (f[i + 1][1] + g[1] + g[2]) % 1000000007;
f[i][2] = (g[0] + g[1] + g[2]) % 1000000007;
}
printf("%lld\n", f[1][2]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const bool debugger1 = 0;
const bool debugger2 = 0;
const bool debugger3 = 0;
const bool debugger4 = 1;
const bool debugger5 = 1;
const int N = 500;
int n;
bool sim[N][N];
int dp[N][N];
string text[N];
int dltxt;
int main() {
scanf("%d", &n);
dltxt = n - 1;
for (int i = 0; i < n; i++) cin >> text[i], dltxt += text[i].size();
for (int i = 0; i < n; i++) {
sim[i][i] = 1;
for (int j = 0; j < i; j++) {
sim[i][j] = sim[j][i] = text[i] == text[j];
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = n - 1; j >= 0; j--) {
if (sim[i][j]) {
if (i + 1 < n && j + 1 < n)
dp[i][j] = dp[i + 1][j + 1] + 1;
else
dp[i][j] = 1;
}
}
}
int ans = dltxt;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; i + j < n; j++) {
sum += text[i + j].size();
int cnt = 1;
for (int pos = i + j + 1; pos < n; pos++) {
if (dp[i][pos] > j) {
cnt++;
pos += j;
}
}
int cur = dltxt - sum * cnt + (j + 1) * cnt - j * cnt;
if (cnt > 1 && ans > cur) ans = cur;
}
}
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int pwr(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
struct base {
double x, y;
base() { x = y = 0; }
base(double _x, double _y) { x = _x, y = _y; }
base(double _x) { x = _x, y = 0; }
void operator=(double _x) { x = _x, y = 0; }
double real() { return x; }
double imag() { return y; }
base operator+(const base& b) { return base(x + b.x, y + b.y); }
void operator+=(const base& b) { x += b.x, y += b.y; }
base operator*(const base& b) {
return base(x * b.x - y * b.y, x * b.y + y * b.x);
}
void operator*=(const base& b) {
double p = x * b.x - y * b.y, q = x * b.y + y * b.x;
x = p, y = q;
}
void operator/=(double k) { x /= k, y /= k; }
base operator-(const base& b) { return base(x - b.x, y - b.y); }
void operator-=(const base& b) { x -= b.x, y -= b.y; }
base conj() { return base(x, -y); }
base operator/(double k) { return base(x / k, y / k); }
void Print() { cerr << x << " + " << y << "i\n"; }
};
double PI = 2.0 * acos(0.0);
const int MAXN = 19;
const int maxn = (1 << MAXN);
base W[maxn], invW[maxn], P1[maxn], Q1[maxn];
void precompute_powers() {
for (int i = 0; i < maxn / 2; i++) {
double ang = (2 * PI * i) / maxn;
double _cos = cos(ang), _sin = sin(ang);
W[i] = base(_cos, _sin);
invW[i] = base(_cos, -_sin);
}
}
void fft(vector<base>& a, bool invert) {
int n = (int)a.size();
for (int i = 1, j = 0; i < n; ++i) {
int bit = n >> 1;
for (; j >= bit; bit >>= 1) j -= bit;
j += bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
for (int i = 0; i < n; i += len) {
int ind = 0, add = maxn / len;
for (int j = 0; j < len / 2; ++j) {
base u = a[i + j],
v = (a[i + j + len / 2] * (invert ? invW[ind] : W[ind]));
a[i + j] = (u + v);
a[i + j + len / 2] = (u - v);
ind += add;
}
}
}
if (invert)
for (int i = 0; i < n; ++i) a[i] /= n;
}
int p[30], ip[30];
vector<base> sp[26];
vector<base> temp;
const int N = 2e5 + 5;
char s[N], t[N];
int main() {
precompute_powers();
for (int i = 0; i < 26; i++) {
scanf("%d", &p[i]);
p[i]--;
ip[p[i]] = i;
}
scanf("%s", s);
scanf("%s", t);
int n = strlen(s), m = strlen(t);
int tot = n + m - 1;
int sz = 1;
while (sz < tot) sz <<= 1;
for (int i = 0; i < 26; i++) {
sp[i].reserve(sz);
sp[i].resize(sz);
}
for (int i = 0; i < n; i++) {
sp[s[i] - 'a'][n - 1 - i].x = 1;
}
for (int j = 0; j < m; j++) {
sp[t[j] - 'a'][j].y = 1;
sp[ip[t[j] - 'a']][j].y = 1;
}
vector<base> ans(sz);
for (int i = 0; i < 26; i++) {
fft(sp[i], 0);
for (int j = 0; j < sz; j++) {
base a = sp[i][j], b = sp[i][(sz - j) & (sz - 1)].conj();
base p = (a + b) * base(0.5, 0), q = (a - b) * base(0, -0.5);
ans[j] += p * q;
}
}
fft(ans, 1);
const double EPS = 1e-3;
for (int i = n - 1; i <= m - 1; i++) {
if (fabs(ans[i].x - n) < EPS) {
putchar('1');
} else {
putchar('0');
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
char s[N], t[N];
int sum[N << 1];
vector<int> calPos(int l, int r) {
vector<int> ans;
int cnt = 0;
for (int i = l; i <= r; i++) {
if (t[i] == '(')
cnt++;
else
cnt--;
if (cnt == 0) ans.push_back(i);
}
return ans;
}
int calAns(int l, int r, int flag = 0) {
int cnt = 0, ans = 0;
int pre = 0;
int m = 0;
for (int i = l; i <= r; i++) {
if (t[i] == '(')
cnt++;
else
cnt--;
if (cnt == 0) {
ans++;
if (flag) m = max(calAns(pre + 1, i, 0), m);
}
}
return ans + 1;
}
void solve() {
int n;
scanf("%d%s", &n, s + 1);
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '(')
cnt++, sum[i] = 1;
else
sum[i] = -1;
sum[i + n] = sum[i];
}
if (n % 2 == 0 && cnt == n / 2) {
sum[0] = 0;
for (int i = 1; i <= 2 * n; i++) sum[i] += sum[i - 1];
multiset<int> st;
for (int i = 1; i <= n; i++) st.insert(sum[i]);
for (int i = 1; i <= n; i++) {
int v = *st.begin() - sum[i - 1];
st.erase(st.lower_bound(sum[i]));
st.insert(sum[i + n]);
if (v == 0) {
int m = 0;
for (int j = i; j <= n; j++) t[++m] = s[j];
for (int j = 1; j < i; j++) t[++m] = s[j];
vector<int> vec = calPos(1, n);
int ans = (int)vec.size();
pair<int, int> pos = pair<int, int>(1, 1);
int pre = 0;
for (auto j : vec) {
vector<int> tvec = calPos(pre + 2, j - 1);
if ((int)tvec.size() + 1 > ans) {
ans = (int)tvec.size() + 1;
pos = pair<int, int>(pre + 1, j);
}
int pp = pre + 1;
for (auto k : tvec) {
int cnt = (int)calPos(pp + 2, k - 1).size() + 1 + (int)vec.size();
if (cnt > ans) {
ans = cnt;
pos = pair<int, int>(pp + 1, k);
}
pp = k;
}
pre = j;
}
pos.first += i - 1;
pos.second += i - 1;
if (pos.first > n) pos.first -= n;
if (pos.second > n) pos.second -= n;
printf("%d\n%d %d\n", ans, pos.first, pos.second);
break;
}
}
} else {
printf("0\n1 1\n");
}
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
int len[300 + 5];
string str[300 + 5];
bool vis[300 + 5][300 + 5];
int main() {
int n = read(), Ans;
for (int i = 1; i <= n; i++) {
cin >> str[i];
len[i] = int(str[i].length()) + len[i - 1];
}
Ans = len[n] + n - 1;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int tmp = 0;
if (vis[i][j]) continue;
vis[i][j] = 1;
for (int t = j + 1; t <= n - j + i; t++) {
bool flag = 0;
for (int s = 0; s <= j - i; s++)
if (str[i + s] != str[t + s]) {
flag++;
break;
}
if (!flag) tmp++, t += j - i, vis[t][t + j - i] = 1;
}
if (tmp != 0) {
int tot = len[n] - (tmp + 1) * (len[j] - len[i - 1]) + tmp + n;
Ans = min(Ans, tot);
}
}
}
printf("%d\n", Ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 111111;
long long c[N];
long long n, k1, k2, k3, t1, t2, t3;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> k1 >> k2 >> k3 >> t1 >> t2 >> t3 >> n;
multiset<long long> s1, s2, s3;
k1 = min(k1, n);
k2 = min(k2, n);
k3 = min(k3, n);
for (long long i = (1); i <= (k1); i++) {
s1.insert(0);
}
for (long long i = (1); i <= (k2); i++) {
s2.insert(0);
}
for (long long i = (1); i <= (k3); i++) {
s3.insert(0);
}
long long ans = 0;
for (long long i = (1); i <= (n); i++) {
cin >> c[i];
long long f1 = max(c[i], *(s1.begin()));
s1.erase(s1.begin());
f1 += t1;
s1.insert(f1);
long long f2 = max(f1, *(s2.begin()));
s2.erase(s2.begin());
f2 += t2;
s2.insert(f2);
long long f3 = max(f2, *(s3.begin()));
s3.erase(s3.begin());
f3 += t3;
s3.insert(f3);
ans = max(ans, f3 - c[i]);
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505 + 5;
const int mod = 998244353;
int an[maxn + 5];
long long dp[maxn * maxn + 5];
long long dfs(int l, int r) {
if (l >= r) return 1;
if (dp[l * maxn + r] != -1) return dp[l * maxn + r];
long long ansleft = 0;
long long ansright = 0;
int p = l;
int now_min = an[l];
for (int i = l + 1; i <= r; i++) {
if (now_min > an[i]) {
p = i;
now_min = an[i];
}
}
for (int i = l - 1; i < p; i++) {
ansleft = (ansleft + dfs(l, i) * dfs(i + 1, p - 1)) % mod;
}
for (int i = r + 1; i > p; i--) {
ansright = (ansright + dfs(i, r) * dfs(p + 1, i - 1)) % mod;
}
dp[l * maxn + r] = (ansleft * ansright) % mod;
return dp[l * maxn + r];
}
int main() {
int n, m;
while (cin >> n >> m) {
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
scanf("%d", &an[i]);
}
printf("%lld\n", dfs(1, n));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
int a, b, c, d, n, m, k, m1, m2;
struct IG {
std::bitset<1004> good[2004], bad[2004];
bool bv[2004];
IG() {
for (int _n((2004) - 1), i(0); i <= _n; i++) {
good[i].reset();
bad[i].reset();
}
memset((bv), 0, sizeof(bv));
}
static inline int getNum(int a) {
if (a > 0) return a - 1;
a = -a;
return n + a - 1;
}
static inline int neg(int a) {
if (a < n)
return a + n;
else
return a - n;
}
inline void addImplication(int a, int b) {
a = getNum(a);
b = getNum(b);
if (b < n) {
good[a].set(b);
} else {
bad[a].set(b - n);
}
}
inline void add(int a, int b) {
addImplication(-a, b);
addImplication(-b, a);
}
void transitiveClosure() {
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
if (i < n) {
good[i].set(i);
} else {
bad[i].set(i - n);
}
}
for (int _n((2 * n) - 1), mid(0); mid <= _n; mid++) {
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
bool ok = 0;
if (mid < n) {
if (good[i].test(mid)) {
ok = 1;
}
} else {
if (bad[i].test(mid - n)) {
ok = 1;
}
}
if (ok) {
good[i] |= good[mid];
bad[i] |= bad[mid];
}
}
}
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
if (i < n) {
if (bad[i].test(i)) bv[i] = 1;
} else {
if (good[i].test(i - n)) bv[i] = 1;
}
}
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
for (int _n((2 * n) - 1), j(0); j <= _n; j++) {
if (!bv[j]) continue;
if (j < n) {
if (good[i].test(j)) bv[i] = 1;
} else {
if (bad[i].test(j - n)) bv[i] = 1;
}
}
}
}
bool hasSolution() {
for (int _n((n)-1), i(0); i <= _n; i++) {
if (bad[i].test(i) && good[i + n].test(i)) {
return 0;
}
}
return 1;
}
int num[1004], sof[1004];
inline bool select(int v) {
int t = v;
if (num[v] == 0) t += n;
if (bv[t]) return false;
int k = 0;
sof[k++] = v;
bool ok = 1;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (good[t].test(i)) {
if (num[i] == 0) {
ok = 0;
break;
}
if (num[i] == -1) {
num[i] = 1;
sof[k++] = i;
}
}
if (bad[t].test(i)) {
if (num[i] == 1) {
ok = 0;
break;
}
if (num[i] == -1) {
num[i] = 0;
sof[k++] = i;
}
}
}
if (!ok) {
for (int _n((k)-1), i(0); i <= _n; i++) {
num[sof[i]] = -1;
}
return 0;
}
return 1;
}
void printSolutionAndDie(int f1, int f2) {
memset(num, -1, sizeof(num));
if (f1 != -1) {
if (f1 < n) {
num[f1] = 1;
} else {
f1 -= n;
num[f1] = 0;
}
select(f1);
}
if (f2 != -1) {
if (num[f2 < n ? f2 : f2 - n] == -1) {
if (f2 < n) {
num[f2] = 1;
} else {
f2 -= n;
num[f2] = 0;
}
select(f2);
}
}
for (int _n((n)-1), i(0); i <= _n; i++) {
if (num[i] != -1) continue;
num[i] = 0;
if (!select(i)) {
num[i] = 1;
select(i);
}
}
for (int _n((n)-1), i(0); i <= _n; i++) {
if (i) printf(" ");
printf("%d", num[i]);
}
printf("\n");
exit(0);
}
inline bool checkBad(int v1, int v2) {
auto t = (good[v1] | good[v2]) & (bad[v1] | bad[v2]);
if (t.any()) {
return 1;
} else {
return 0;
}
}
};
char buf[65537];
char *ch = buf;
inline char get_char() {
if (*ch == 0) {
ch = buf;
fread(buf, sizeof(char), 65536, stdin);
}
return *(ch++);
}
char _ch;
inline void next_int(int &ans) {
ans = 0;
while (((_ch = get_char()) < '0' || _ch > '9') && _ch != '-')
;
bool neg = 0;
if (_ch == '-') {
neg = 1;
_ch = get_char();
}
do {
ans = ans * 10 + _ch - '0';
} while ((_ch = get_char()) >= '0' && _ch <= '9');
if (neg) ans = -ans;
}
IG g1, g2;
bool used[2002][2002];
pair<int, int> cl1[1000002], cl2[1000002];
inline void solve(pair<int, int> *cl1, pair<int, int> *cl2, IG &g1, IG &g2,
int m1, int m2) {
memset((used), 0, sizeof(used));
for (int _n((m1)-1), i(0); i <= _n; i++) {
int v1 = IG::getNum(cl1[i].first);
int v2 = IG::getNum(cl1[i].second);
v1 = IG::neg(v1);
v2 = IG::neg(v2);
if (v1 > v2) swap(v1, v2);
if (used[v1][v2]) continue;
used[v1][v2] = 1;
if (g2.bv[v1] || g2.bv[v2]) continue;
if (g2.checkBad(v1, v2)) continue;
g2.printSolutionAndDie(v1, v2);
}
}
int main() {
next_int(n);
next_int(m1);
next_int(m2);
for (int _n((m1)-1), i(0); i <= _n; i++) {
next_int(a);
next_int(b);
cl1[i] = make_pair(a, b);
g1.add(a, b);
}
for (int _n((m2)-1), i(0); i <= _n; i++) {
next_int(a);
next_int(b);
cl2[i] = make_pair(a, b);
g2.add(a, b);
}
g1.transitiveClosure();
g2.transitiveClosure();
bool r1 = g1.hasSolution();
bool r2 = g2.hasSolution();
if (!r1 && !r2) {
printf("SIMILAR\n");
exit(0);
}
if (!r1) {
g2.printSolutionAndDie(-1, -1);
}
if (!r2) {
g1.printSolutionAndDie(-1, -1);
}
solve(cl1, cl2, g1, g2, m1, m2);
solve(cl2, cl1, g2, g1, m2, m1);
printf("SIMILAR\n");
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h;
cin >> n >> h;
for (int i = 1; i < n; i++) {
cout << setprecision(7) << fixed << sqrt(1.0 * i / n) * h << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000000")
using namespace std;
signed main() {
long long n;
cin >> n;
set<long long> kek;
long long st = 1;
while (st <= 10000020) {
kek.insert(st - 1);
st *= 2;
}
vector<long long> ans;
if (kek.count(n) == 1) {
cout << 0 << endl;
return 0;
}
for (long long i = 0; i < 41; i++) {
bitset<40> myb(n);
bool flag = false;
for (long long h = 39; h >= 0; --h) {
if (myb[h] == 1) {
for (long long j = h; j >= 0; --j) {
if (myb[j] == 0) {
long long hz = (1 << (j + 1)) - 1;
ans.push_back(j + 1);
n ^= hz;
flag = true;
break;
}
}
}
if (flag) break;
}
if (kek.count(n) == 1) {
cout << i + 1 << endl;
for (long long h = 0; h < ans.size(); h++) cout << ans[h] << " ";
cout << endl;
return 0;
}
n++;
i++;
if (kek.count(n) == 1) {
cout << i + 1 << endl;
for (long long h = 0; h < ans.size(); h++) cout << ans[h] << " ";
cout << endl;
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int b[maxn], s[maxn];
vector<int> d, p;
int n, m;
int get_par(int x) {
if (s[x] == 0)
return x;
else {
s[x] = get_par(s[x]);
return s[x];
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int t;
cin >> t;
if (t == 1) {
int x, y;
cin >> x >> y;
b[x] = y;
s[x] = y;
} else if (t == 2) {
int x;
cin >> x;
d.push_back(x);
p.push_back(get_par(x));
} else {
int x, i;
cin >> x >> i;
int y = d[i - 1], z = p[i - 1];
while (y != z) {
if (y == x) {
break;
}
y = b[y];
}
if (y == x)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j > 0) {
cout << " ";
}
if (i % 2 == 0) {
cout << 0;
} else {
cout << (1LL << (i + j - 1));
}
}
cout << endl;
}
int tt;
cin >> tt;
while (tt--) {
long long x;
cin >> x;
int i = 0;
int j = 0;
cout << 1 << " " << 1 << endl;
while (i < n - 1 || j < n - 1) {
int r = 0;
if (x & (1LL << (i + j))) {
r = 1;
}
if (i % 2 != r) {
i += 1;
} else {
j += 1;
}
cout << i + 1 << " " << j + 1 << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int ar[n], p[n + 1];
for (int i = 0; i < n; i++) {
cin >> ar[i];
p[ar[i]] = i;
}
int ans[n + 1];
for (int i = 0; i <= n; i++) ans[i] = 0;
ans[n] = 1;
int c = 0;
int i = 1;
int po = -1;
while (i <= n) {
if (po == -1)
po = p[i];
else if (p[i] != po) {
c = 1;
break;
}
ans[po] = 1;
if (ans[po + 1] == 1)
po = -1;
else
po++;
i++;
}
if (c == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool prime[1000005];
void SieveOfEratosthenes() {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= 1000005; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= 1000005; i += p) prime[i] = false;
}
}
}
string toLower(string s) {
for (int i = 0; i < s.size(); i++)
if (s[i] >= 'A' && s[i] <= 'Z') s[i] = s[i] + 32;
return s;
}
long long int modC(long long int n) {
n--;
long long int val = 1;
while (n--) {
val = val * 2;
val = val % 1000000007;
}
return val % 1000000007;
}
int main() {
long long int n;
cin >> n;
long long int i, val = 1;
for (i = 1; i <= n; i++) {
val = val * i;
val = val % 1000000007;
}
long long int ex = modC(n);
if (ex > val)
cout << (val - ex) % 1000000007 + 1000000007 << "\n";
else
cout << (val - ex) % 1000000007 << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int s[100005][3], t[100005];
int cmp(const void *aa, const void *bb) {
return *((int *)aa + 1) - *((int *)bb + 1);
}
int main() {
int n, m, ans = 0, k, k1 = 0, a, b, c, count, d;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d%d", &s[i][0], &s[i][1]);
s[i][2] = i + 1;
}
if (n % m == 0)
k = n / m;
else
k = n / m + 1;
while (k1 < k) {
a = k1 * m;
if (k1 < k - 1)
b = (k1 + 1) * m;
else
b = n;
if (ans >= s[b - 1][0])
for (int i = a; i < b; i++) s[i][0] = ans;
else {
for (int i = a; i < b; i++) s[i][0] = s[b - 1][0];
ans = s[b - 1][0];
}
qsort(s + a, b - a, sizeof(s[0]), cmp);
count = 1;
c = s[a][1];
d = s[a][0] + c;
t[s[a][2] - 1] = c + s[a][0];
for (int i = a + 1; i < b; i++) {
if (s[i][1] == c) {
count++;
t[s[i][2] - 1] = t[s[i - 1][2] - 1];
} else {
d = t[s[i - 1][2] - 1] + s[i][1] - c + 1 + count / 2;
t[s[i][2] - 1] = d;
c = s[i][1];
count = 1;
}
}
ans = t[s[b - 1][2] - 1] + s[b - 1][1] + 1 + count / 2;
k1++;
}
for (int i = 0; i < n; i++) printf("%d ", t[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
clock_t launch = clock();
long long t = 1;
while (t--) {
string s;
cin >> s;
long long len = s.length(), lax = -1;
bool aa = true;
vector<char> n;
for (long long i = 0; i < len; i++)
if (s[i] != 'a') {
n.push_back(s[i]);
aa = false;
} else
lax = i;
long long len2 = n.size();
bool ans = true;
for (long long i = 0; i < len2 / 2; i++)
if (n[i] != n[i + len2 / 2]) ans = false;
if (lax >= len - len2 / 2) {
ans = false;
}
if (len2 & 1) ans = false;
if (aa) ans = true;
if (!ans)
cout << ":(" << endl;
else
for (long long i = 0; i < len - len2 / 2; i++) cout << s[i];
cout << endl;
}
clog << ((long double)(clock() - launch) / CLOCKS_PER_SEC) << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int flag = 0;
for (int i = 0; i < s.length();) {
if (s[i] == '1') {
i++;
if (s[i] == '4') {
i++;
if (s[i] == '4') {
i++;
} else {
continue;
}
} else {
continue;
}
} else {
flag = 1;
break;
}
}
if (flag)
cout << "NO"
<< "\n";
else
cout << "YES"
<< "\n";
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.