solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long n, k, m, d;
long long times(long long x) { return (n / x + k - 1) / k; }
long long calc(long long x) { return times(x) * x; }
long long find(long long x, long long l, long long r) {
long long res = -1;
while (l <= r) {
long long g = (l + r) >> 1;
long long t = times(g);
if (t >= x) {
res = g;
l = g + 1;
} else
r = g - 1;
}
return res;
}
int main() {
cin >> n >> k >> m >> d;
long long res = 0;
for (long long i = 1; i <= d; i++) {
long long x = find(i, 1, m);
if (x != -1 && times(x) == i) res = max(res, x * i);
}
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
int n, k, l;
char input[maxn];
bool bitovi[maxn];
int suma[maxn];
int rj;
void daj_sumu() {
int tr_suma = 0;
for (int i = 0; i < n; i++) {
tr_suma += bitovi[i];
if (i - l >= 0) tr_suma -= bitovi[i - l];
suma[i] = tr_suma;
}
return;
}
int dp[maxn];
int kolko[maxn];
int rez(int cijena) {
if (suma[l - 1] > cijena) {
dp[l - 1] = suma[l - 1] - cijena;
kolko[l - 1] = 1;
} else {
dp[l - 1] = 0;
kolko[l - 1] = 0;
}
for (int i = l; i < n; i++) {
dp[i] = dp[i - 1];
kolko[i] = kolko[i - 1];
if (dp[i - l] + suma[i] - cijena > dp[i]) {
dp[i] = dp[i - l] + suma[i] - cijena;
kolko[i] = kolko[i - l] + 1;
}
}
return kolko[n - 1];
}
void izracunaj() {
rj = -1;
int lo = 0, hi = l, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (rez(mid) > k)
lo = mid + 1;
else
hi = mid;
}
int uzeo = rez(lo);
rj = max(rj, dp[n - 1] + uzeo * lo + (k - uzeo) * lo);
return;
}
int br_jedinica = 0;
int krj;
int main() {
scanf("%d%d%d", &n, &k, &l);
scanf("%s", input);
if ((long long)k * l >= n) {
printf("0\n");
return 0;
}
for (int i = 0; i < n; i++) {
if (input[i] >= 'a' && input[i] <= 'z') {
bitovi[i] = 1;
br_jedinica++;
}
}
daj_sumu();
izracunaj();
krj = br_jedinica - rj;
br_jedinica = n - br_jedinica;
for (int i = 0; i < n; i++) bitovi[i] = !bitovi[i];
daj_sumu();
izracunaj();
krj = min(krj, br_jedinica - rj);
printf("%d\n", krj);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9 + 2;
int main() {
ios_base::sync_with_stdio(false);
int n, x;
cin >> n >> x;
vector<pair<pair<int, int>, pair<int, int>>> vec(2 * n);
int j = 0;
for (int i = 0; i < int(n); i++) {
int l, r, cost;
cin >> l >> r >> cost;
vec[j] = make_pair(make_pair(l, 0), make_pair(r, cost));
vec[j + 1] = make_pair(make_pair(r, 1), make_pair(l, cost));
j += 2;
}
vector<int> bestCost(2e5 + 2, INF);
sort((vec).begin(), (vec).end());
long long ans = 2LL * INF;
for (int i = 0; i < int(2 * n); i++) {
int type = vec[i].first.second;
if (type == 0) {
int diff = vec[i].second.first - vec[i].first.first + 1;
if (diff < x)
ans = min(ans, 1LL * vec[i].second.second + 1LL * bestCost[x - diff]);
} else {
int diff = vec[i].first.first - vec[i].second.first + 1;
bestCost[diff] = min(bestCost[diff], vec[i].second.second);
}
}
if (ans >= INF) ans = -1;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long n, now, s[N], e[N];
long long get_ans(long long x, long long y, long long id) {
if (x == 0 && y == 0) return 1;
if (id == 1) {
if (y > (x >> 1)) return 0;
x >>= 1;
}
while (x) {
if (x & 1) return (y & 1);
if (y > (x >> 1))
return !(y & 1);
else if (y > (x >> 2))
return 0;
x >>= 2;
}
return 1;
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> s[i] >> e[i];
now = 0;
for (long long i = n; i >= 1; i--) now = !get_ans(e[i], s[i], now);
cout << now << ' ';
now = 1;
for (long long i = n; i >= 1; i--) now = !get_ans(e[i], s[i], now);
cout << now << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct TType {
double max, lmax, rmax;
};
double profit[150000], s[150000];
TType T[524288];
inline void PushUP(int l, int r, int rt) {
int m = (l + r) >> 1;
T[rt].max = max(T[(rt << 1)].rmax + T[(rt << 1 | 1)].lmax,
max(T[(rt << 1)].max, T[(rt << 1 | 1)].max));
T[rt].lmax = max(T[(rt << 1)].lmax, s[m] - s[l - 1] + T[(rt << 1 | 1)].lmax);
T[rt].rmax = max(T[(rt << 1 | 1)].rmax, T[(rt << 1)].rmax + s[r] - s[m]);
}
void build(int l, int r, int rt) {
if (l == r) {
T[rt].max = T[rt].lmax = T[rt].rmax = profit[l];
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
PushUP(l, r, rt);
}
TType query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return T[rt];
int m = (l + r) >> 1;
if (R <= m) return query(L, R, l, m, rt << 1);
if (L > m) return query(L, R, m + 1, r, rt << 1 | 1);
TType ans1, ans2, ans;
ans1 = query(L, m, l, m, rt << 1);
ans2 = query(m + 1, R, m + 1, r, rt << 1 | 1);
ans.max = max(ans1.rmax + ans2.lmax, max(ans1.max, ans2.max));
ans.lmax = max(ans1.lmax, s[m] - s[L - 1] + ans2.lmax);
ans.rmax = max(ans2.rmax, s[R] - s[m] + ans1.rmax);
return ans;
}
int main() {
int n, m, cc, last, now;
scanf("%d%d%d", &n, &m, &cc);
scanf("%d", &last);
for (int i = 1; i < n; i++) {
scanf("%d", &now);
profit[i] = (now - last) * 0.5;
last = now;
}
int p;
for (int i = 1; i < n; i++) {
scanf("%d", &p);
profit[i] -= cc * p / 100.0, s[i] = s[i - 1] + profit[i];
}
build(1, n - 1, 1);
double ans = 0;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
TType temp = query(a, b - 1, 1, n - 1, 1);
if (temp.max > 0) ans += temp.max;
}
printf("%.9lf\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int f = 1, x = 0;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
int t;
int n, k;
int main() {
t = read();
while (t--) {
n = read();
k = read();
int ans = n;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (n / i <= k) ans = min(ans, i);
if (i <= k) ans = min(ans, n / i);
}
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n;
while (t--) {
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + n);
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
for (int i = 0; i < n; i++) cout << b[i] << " ";
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[1000100], ans, cnt;
priority_queue<long long> q;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
q.push(-a[i]);
q.push(-a[i]);
ans += (a[i] + q.top());
q.pop();
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long st[111111];
long long in[111111];
int n;
long long fn[111111];
int len;
int cnt;
int l[3];
int c[3];
inline void apply(int t, int k) {
for (int(i) = 0; (i) < (n); ++(i))
if (i < k)
fn[i] = st[i] + t;
else
fn[i] = max(st[i], fn[i - k]) + t;
}
int main() {
for (int(i) = 0; (i) < (3); ++(i)) scanf("%d", &c[i]);
for (int(i) = 0; (i) < (3); ++(i)) scanf("%d", &l[i]);
scanf("%d", &n);
for (int(i) = 0; (i) < (n); ++(i)) {
int first;
scanf("%d", &first);
in[i] = st[i] = first;
}
for (int(i) = 0; (i) < (3); ++(i)) {
apply(l[i], c[i]);
for (int(j) = 0; (j) < (n); ++(j)) st[j] = fn[j];
}
long long ans = 0;
for (int(i) = 0; (i) < (n); ++(i)) ans = max(ans, st[i] - in[i]);
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y;
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> x >> y;
if (y < 6 || y > m - 5 || x < 6 || x > n - 5) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 100;
vector<long long> L[MAXN];
long long ingree[MAXN];
long long lvl[MAXN];
long long comp[MAXN];
long long contg = 0;
long long st[MAXN];
long long lt[MAXN];
long long sz[MAXN];
long long contdfs = 0;
void DFS(long long nodo) {
st[nodo] = ++contdfs;
comp[nodo] = contg;
sz[nodo] = 1;
for (auto v : L[nodo]) {
lvl[v] = lvl[nodo] + 1;
DFS(v);
sz[nodo] += sz[v];
}
lt[nodo] = contdfs;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long N, M, K, Q;
cin >> N >> M >> K >> Q;
vector<pair<long long, long long>> vect;
vector<long long> last(N, -1);
vector<bool> mk(K);
for (long long i = 0; i < K; i++) {
long long a, b;
cin >> a >> b;
vect.push_back({a, b});
last[a - 1] = i;
}
false;
for (long long i = 0; i < N; i++) {
if (last[i] != -1) mk[last[i]] = true;
}
vector<long long> temp[MAXN];
for (long long i = 0; i < K; i++) {
if (temp[vect[i].second].size() && mk[i]) {
L[temp[vect[i].second].back()].push_back(vect[i].first);
ingree[vect[i].first]++;
}
temp[vect[i].second].push_back(vect[i].first);
}
for (long long i = 1; i <= N; i++) {
if (ingree[i] == 0) {
contg++;
lvl[i] = 1;
contdfs = 0;
DFS(i);
}
}
for (long long i = 1; i <= N; i++) {
false;
}
for (long long i = 0; i < Q; i++) {
long long a, b;
cin >> a >> b;
if (temp[b].size() == 0) {
cout << 0 << '\n';
continue;
}
long long nodotemp = temp[b].back();
if (comp[a] != comp[nodotemp]) {
cout << 0 << '\n';
continue;
}
if (st[a] < st[nodotemp] && st[nodotemp] <= lt[a]) {
cout << sz[a] << '\n';
} else {
cout << 0 << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, gcd;
long long ans;
int GCD(int a, int b) { return b == 0 ? a : GCD(b, a % b); }
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a;
gcd = GCD(gcd, a - 1);
}
while (!(gcd & 1)) gcd >>= 1;
for (int i = 1; i * i <= gcd; i++)
if (!(gcd % i)) {
for (int j = i; j < m; j <<= 1) ans += m - j;
if (i * i < gcd)
for (int j = gcd / i; j < m; j <<= 1) ans += m - j;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int f[1002][1002], m, a[1020], h[1020][2];
char s[1020];
int gg(int p, int l, int b) {
if (p == -1) return 0;
if (!b && f[p][l] != -1) return f[p][l];
int r = 0;
for (int i = 0, e = b ? a[p] : 9; i <= e; i++)
if (i == 4 || i == 7)
if (l == m)
r += gg(p - 1, 0, b && i == e), r %= 1000000007;
else
r += h[p][b && i == e], r %= 1000000007;
else
r += gg(p - 1, l == m ? m : (l + 1), b && i == e), r %= 1000000007;
return b ? r : (f[p][l] = r);
}
int ff(char *s) {
int n = strlen(s);
for (int i = n - 1; i >= 0; i--) a[i] = s[i] - '0';
memset(h, -1, sizeof h);
h[0][0] = h[0][1] = 1;
for (int i = 1; i <= n; i++)
h[i][0] = (long long)h[i - 1][0] * 10 % 1000000007;
for (int i = 1; i <= n; i++)
h[i][1] = ((long long)h[i - 1][1] + (long long)a[i - 1] * h[i - 1][0]) %
1000000007;
return gg(n - 1, m, 1);
}
int main() {
memset(f, -1, sizeof f);
int _;
scanf("%d%d", &_, &m);
while (_--) {
scanf("%s", s);
int n = strlen(s), SA;
reverse(s, s + n);
if (n == 1 && s[0] == '1')
SA = 0;
else {
int i = 0;
while (s[i] == '0') s[i] = '9', i++;
s[i]--;
if (i == n - 1 && s[i] == '0') n--;
SA = ff(s);
}
scanf("%s", s);
n = strlen(s);
reverse(s, s + n);
int SB = ff(s);
SB -= SA;
while (SB < 0) SB += 1000000007;
printf("%d\n", SB);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
template <class T>
void dbs(string str, T t) {
cout << str << " : " << t << endl;
}
template <class T, class... second>
void dbs(string str, T t, second... s) {
int idx = str.find(',');
cout << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class second, class T>
ostream& operator<<(ostream& os, const pair<second, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class second, class T>
ostream& operator<<(ostream& os, const map<second, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void prc(T a, T b) {
cout << "[";
for (T i = a; i != b; ++i) {
if (i != a) cout << ", ";
cout << *i;
}
cout << "]";
cout << endl;
}
const int N = 1e5 + 10;
int p[N], r[N], sub[N], vis[N];
pair<int, int> e[N];
long long ans[N];
vector<vector<pair<int, int>>> g;
int get(int x) { return x == p[x] ? x : p[x] = get(p[x]); }
void connect(int x, int y) {
x = get(x), y = get(y);
if (x == y) return;
if (r[x] > r[y]) swap(x, y);
p[x] = y;
r[y] += r[x];
}
void dfs(int u, int par, int no) {
vis[u] = 1;
for (auto v : g[u])
if (v.first != par) {
dfs(v.first, u, no);
sub[u] += sub[v.first];
ans[v.second] = sub[v.first] * 1LL * (no - sub[v.first]);
}
}
int get_sum(int u, int par) {
int sum = sub[u];
for (auto v : g[u])
if (v.first != par) {
sum += get_sum(v.first, u);
}
return sum;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
map<int, vector<int>> mp;
iota(p, p + N, 0);
fill(r, r + N, 1);
for (auto i = (1); i <= (n - 1); ++i) {
int x, y, z;
cin >> x >> y >> z;
e[i] = {x, y};
mp[z].push_back(i);
}
for (auto it : mp) {
vector<int> id;
for (int x : it.second)
id.push_back(e[x].first = get(e[x].first)),
id.push_back(e[x].second = get(e[x].second));
sort((id).begin(), (id).end());
id.resize(unique((id).begin(), (id).end()) - id.begin());
int no = int(id.size());
g.clear();
g.resize(no);
for (auto i = (0); i <= (no - 1); ++i) sub[i] = r[id[i]];
for (int x : it.second) {
g[(lower_bound((id).begin(), (id).end(), e[x].first) - id.begin())]
.emplace_back(
(lower_bound((id).begin(), (id).end(), e[x].second) - id.begin()),
x);
g[(lower_bound((id).begin(), (id).end(), e[x].second) - id.begin())]
.emplace_back(
(lower_bound((id).begin(), (id).end(), e[x].first) - id.begin()),
x);
}
fill(vis, vis + no, 0);
for (auto i = (0); i <= (no - 1); ++i)
if (!vis[i]) {
dfs(i, -1, get_sum(i, -1));
}
for (int x : it.second) {
connect(e[x].first, e[x].second);
}
}
long long val = *max_element(ans + 1, ans + n);
cout << 2 * val << " ";
vector<int> yo;
for (auto i = (1); i <= (n - 1); ++i)
if (ans[i] == val) yo.push_back(i);
cout << int(yo.size()) << "\n";
for (int i : yo) cout << i << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int k = s.size();
if (s[k - 1] == 'o')
cout << "FILIPINO" << endl;
else if (s[k - 1] == 'u')
cout << "JAPANESE" << endl;
else
cout << "KOREAN" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double dp[100 * 1001][2];
int N, M, s[100];
int main() {
cout << fixed << setprecision(16);
while (scanf("%d %d", &N, &M) != EOF) {
for (int i = int(0); i < int(N * M + 1); i++) dp[i][0] = dp[i][1] = 0.0;
dp[0][0] = 1;
int sum = 0;
for (int i = int(0); i < int(N); i++) {
scanf("%d", s + i);
sum += s[i];
}
for (int i = int(0); i < int(N); i++) {
int cur = i & 1;
int next = !cur;
double tempSum = 0.0;
for (int j = int(0); j < int(M); j++) {
if (s[i] == j) continue;
tempSum += dp[N * M - j][cur];
}
for (int j = N * M; j >= 0; j--) {
dp[j][next] = 0.;
double div = M - 1;
if (!div || i == N - 1) div = 1.0;
tempSum -= dp[j][cur];
if (j - M >= 0) tempSum += dp[j - M][cur];
if (j - s[i] >= 0) tempSum -= dp[j - s[i]][cur];
if (j - s[i] + 1 >= 0) tempSum += dp[j - s[i] + 1][cur];
dp[j][next] = tempSum / div;
}
}
double ans = 1.;
for (int i = int(0); i < int(sum); i++) {
if (i < sum) ans += dp[i][N & 1];
}
printf("%.16f\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
char a[500001];
int start[500001];
int stop[500001];
int n, t, end;
bool f(int s) {
int l = 0, i, T = 0, END, t1 = 0, t2 = 0;
for (i = 0; i <= end || s < 0; i++) {
if (a[i] == 'S') {
s++;
if (s == 0) stop[l++] = i;
stop[l] = 0;
} else if (a[i] == 'H') {
s--;
if (s == -1) start[l] = i;
start[l + 1] = 0;
}
}
if (l == 0) return i <= t;
T = i;
END = i - 1;
for (i = l - 1; i >= 0; i--) {
t1 += (stop[i] - start[i]) * 2;
t2 = END - start[i];
if (t2 < t1) {
T += t2;
t1 = 0;
t2 = 0;
END = start[i];
}
}
if (t1) T += t1;
return T <= t;
}
int main() {
int i, H = 0, S = 0, ans = -1, left, right;
int t1, t2, T, middle, m;
scanf("%i %i %s", &n, &t, a);
for (i = 0; i < n; H += a[i] == 'H', S += a[i] == 'S', i++)
if (a[i] == 'H') end = i;
left = H > S ? (H - S) : 0;
right = H;
while (left <= right) {
T = 0;
t1 = 0;
t2 = 0;
middle = (left + right) >> 1;
if (f(middle)) {
ans = middle;
right = middle - 1;
} else
left = middle + 1;
}
printf("%i", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)3e3 + 228;
const int N = (int)1e6 + 228;
const int INF = (int)1e9 + 228;
const int MOD = (int)1e9 + 7;
int a[N][5], ans[5], mx[5];
int t[N][5];
void build(int ind, int v, int tl, int tr) {
if (tl == tr) {
t[v][ind] = a[tl][ind];
return;
}
int mid = (tl + tr) / 2;
build(ind, 2 * v, tl, mid);
build(ind, 2 * v + 1, mid + 1, tr);
t[v][ind] = max(t[2 * v][ind], t[2 * v + 1][ind]);
}
int get_max(int ind, int v, int tl, int tr, int l, int r) {
if (tl >= l && tr <= r) return t[v][ind];
if (tl > r || tr < l) return -INF;
int mid = (tl + tr) / 2;
return max(get_max(ind, 2 * v, tl, mid, l, r),
get_max(ind, 2 * v + 1, mid + 1, tr, l, r));
}
bool can(int mid, int n, int m, int k) {
for (int l = 1; l <= n; l++) {
int r = l + mid - 1;
if (r > n) break;
for (int ind = 1; ind <= m; ind++) mx[ind] = get_max(ind, 1, 1, n, l, r);
int res = 0;
for (int ind = 1; ind <= m; ind++) res += mx[ind];
if (res <= k) {
for (int ind = 1; ind <= m; ind++) ans[ind] = mx[ind];
return true;
}
}
return false;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= m; i++) build(i, 1, 1, n);
int l = 0, r = n;
while (l < r) {
int mid = (l + r + 1) / 2;
if (can(mid, n, m, k))
l = mid;
else
r = mid - 1;
}
for (int i = 1; i <= m; i++) cout << ans[i] << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, m, k, i, j, w;
scanf("%d%d%d", &n, &m, &k);
if (m < n - 1 || m > (n * n - 3 * n + 4) / 2)
printf("-1");
else {
w = 1;
if (k == 1) w = n;
for (i = 1; i <= n; i++)
if (i != k) printf("%d %d\n", k, i);
m -= n - 1;
for (i = 1; i <= n && m; i++)
if (i != k && i != w)
for (j = i + 1; j <= n && m; j++)
if (j != k && j != w) printf("%d %d\n", i, j), m--;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
vector<long long int> fib;
void calc(int n) {
fib.assign(n + 1, 0);
fib[0] = 1;
fib[1] = 1;
for (int i = (int)2; i <= (int)n; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
}
int main() {
long long int n, k;
cin >> n >> k;
calc(n);
vector<long long int> ans;
for (int i = 0; i < (int)n; i++) {
if (k <= fib[n - 1 - i])
ans.push_back(i + 1);
else {
ans.push_back(i + 2);
ans.push_back(i + 1);
k -= fib[n - 1 - i];
i++;
}
}
for (int i = 0; i < (int)n; i++) {
cout << ans[i] << " ";
}
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[400000];
int main() {
int i, j, m, n, t, r, s, v1, v2, t1, t2;
scanf("%d%d%d%d%d", &s, &v1, &v2, &t1, &t2);
m = s * v1 + t1 * 2;
n = s * v2 + t2 * 2;
if (n < m)
printf("Second\n");
else if (n > m)
printf("First\n");
else
printf("Friendship\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
vector<string> s1;
for (int i = 0; i < int((s).size()); i++) {
string s2(int((s).size()) - i, '0');
if (s[i] != '0') {
s2[0] = s[i];
s1.push_back(s2);
}
}
cout << s1.size() << "\n";
for (auto i : s1) {
cout << i << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
char s1[n][m];
int i, flag = 0, countt = 0, temp1 = 1000001, temp2 = 0, first1, last1,
first2, last2, j, height, width, ans, total, flag2 = 0;
for (i = 0; i < n; i++) scanf("%s", s1[i]);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (flag == 0 && s1[i][j] == 'B') {
first1 = i;
last1 = i;
flag = 1;
flag2 = 1;
break;
} else if (flag != 0 && s1[i][j] == 'B')
last1 = i;
}
}
flag = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (flag == 0 && s1[i][j] == 'B') {
first2 = j;
last2 = j;
flag = 1;
flag2 = 1;
countt++;
temp1 = min(first2, temp1);
temp2 = max(last2, temp2);
flag2 = 1;
} else if (flag != 0 && s1[i][j] == 'B') {
last2 = j;
countt++;
temp2 = max(last2, temp2);
flag2 = 1;
}
}
flag = 0;
}
if (flag2 == 0) {
cout << "1" << endl;
} else {
height = last1 - first1 + 1;
width = temp2 - temp1 + 1;
if (height < width) {
total = n - height;
if (height + total >= width) {
ans = width * width - countt;
cout << ans;
} else
cout << "-1" << endl;
} else if (height > width) {
total = m - width;
if (width + total >= height) {
ans = height * height - countt;
cout << ans;
} else
cout << "-1" << endl;
} else {
ans = width * width - countt;
cout << ans;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class C>
void mini(C &a, C b) {
a = min(a, b);
}
template <class C>
void maxi(C &a, C b) {
a = max(a, b);
}
double PI = acos(-1.0);
const ll mod = 998244353;
const ll INF = 5e18;
const double eps = 0.000000001;
const int N = 100;
int dp[N + 1][N + 1][N + 1];
int comb[N + 1][N + 1];
int fact[N + 1];
int p;
void precalc() {
for (int i = 0; i < N + 1; i++)
for (int j = 0; j < N + 1; j++)
for (int l = 0; l < N + 1; l++) dp[i][j][l] = -1;
fact[0] = 1;
for (int(i) = 1; i <= N; i++) fact[i] = (ll)fact[i - 1] * (ll)i % p;
for (int i = 0; i < N + 1; i++) {
comb[i][0] = comb[i][i] = 1;
for (int(j) = 1; j <= i - 1; j++)
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % p;
}
}
ll f(int n, int m, int k) {
if (n == 0) return 1;
if (m > n and k != 0) return 0;
if (m == 1) {
if (k == 1)
return fact[n];
else
return 0;
}
register int &res = dp[n][m][k];
if (res == -1) {
res = 0;
for (int(i) = 1; i <= n; i++) {
int suma = 0;
for (int k1 = max(0, k - n + i); k1 <= min(k, i - 1); k1++) {
int k2 = k - k1;
suma = (suma + 1ll * f(i - 1, m - 1, k1) * f(n - i, m - 1, k2)) % p;
}
res = (res + 1ll * suma * comb[n - 1][i - 1]) % p;
}
}
return dp[n][m][k];
}
void a() {
int n, m, k;
cin >> n >> m >> k >> p;
precalc();
cout << f(n, m, k) << '\n';
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
a();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int multi(long long int a, long long int b) {
return ((a % 1000000007) * (b % 1000000007)) % 1000000007;
}
long long int add(long long int a, long long int b) {
return ((a % 1000000007) + (b % 1000000007)) % 1000000007;
}
long long int gcd(long long int a, long long int b) {
return (b ? gcd(b, a % b) : a);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / (gcd(a, b));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
int l = -1;
int r = -1;
bool ans = false;
unordered_map<int, int> mp;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
mp[a[i]]++;
if (mp.size() == k) {
ans = true;
r = i;
break;
}
}
if (ans == true) {
l = 0;
while (mp[a[l]] > 1) {
mp[a[l]]--;
l++;
}
cout << l + 1 << ' ' << r + 1 << '\n';
} else {
cout << "-1 -1\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(0) * 2;
const double EPS = 1e-8;
const long long MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
const int oo = 1e9;
const double foo = 1e30;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcounll(s);
}
template <class T>
T sqr(T x) {
return x * x;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
struct divisorSegment {
int x;
int val[MAXN * 20];
void build(int node, int L, int R) {
val[node] = 0;
if (L < R) {
int mid = (L + R) >> 1;
build(node * 2, L, mid);
build(node * 2 + 1, mid + 1, R);
}
}
void update(int node, int pos, int L, int R, int v) {
if (pos < L || pos > R) return;
if (pos <= L && R <= pos) {
val[node] += v;
return;
}
if (L < R) {
int mid = (L + R) >> 1;
update(node * 2, pos, L, mid, v);
update(node * 2 + 1, pos, mid + 1, R, v);
val[node] = val[node * 2] + val[node * 2 + 1];
}
}
int query(int node, int l, int r, int L, int R) {
if (l > R || r < L) return 0;
if (l <= L && R <= r) {
return val[node];
}
if (L < R) {
int mid = (L + R) >> 1;
return query(node * 2, l, r, L, mid) +
query(node * 2 + 1, l, r, mid + 1, R);
}
return 0;
}
} A[10];
vector<pair<int, int> > pr;
int n, k, a[MAXN];
void build(int k) {
for (int i = 2; (long long)i * i <= k; i++) {
if (k % i == 0) {
int cnt = 0;
while (k % i == 0) {
k /= i;
cnt++;
}
pr.push_back(make_pair(i, cnt));
}
}
if (k != 1) pr.push_back(make_pair(k, 1));
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
build(k);
for (int i = 0; i < ((int)(pr).size()); i++) A[i].build(1, 0, n - 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < ((int)(pr).size()); j++) {
int cur = a[i], cnt = 0;
while (cur % pr[j].first == 0) {
cnt++;
cur /= pr[j].first;
}
if (cnt != 0) A[j].update(1, i, 0, n - 1, cnt);
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
int l = i, r = n - 1, find = -1;
while (l <= r) {
int mid = (l + r) >> 1;
int check = 1;
for (int j = 0; j < ((int)(pr).size()); j++) {
int cur = A[j].query(1, i, mid, 0, n - 1);
if (cur < pr[j].second) {
check = 0;
break;
}
}
if (check) {
find = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (!~find) break;
ans += (long long)(n - find);
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
int up = 0, down = 0;
int flag = 0;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (k > x)
up += k - x;
else
down += x - k;
if (k == x) flag++;
}
if (!up && !down)
cout << 0;
else if (up == down || flag)
cout << 1;
else
cout << 2;
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
const int mod = 1e9 + 7;
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0)
if (b & 1) {
res = (long long)(res * 1ll * a);
--b;
} else {
a = (long long)(a * 1ll * a);
b >>= 1;
}
return (long long)res;
}
vector<vector<int>> g;
vector<bool> used;
vector<long double> ver;
void dfs(int v, int prev) {
used[v] = true;
double cnt = 0, sum = 0;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == prev) continue;
dfs(to, v);
sum += ver[to];
cnt++;
}
if (cnt == 0)
ver[v] = 0;
else
ver[v] = 1 + sum / cnt;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
if (n % 4 == 0) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> is_prime(1000001, true);
vector<int> xxx;
void Sieve(int n) {
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; i++) {
if (is_prime[i] && (long long)i * i <= n) {
for (int j = i * i; j <= n; j += i) is_prime[j] = false;
}
}
}
void jabru() {
int n;
cin >> n;
long long ans = 1;
int z = sqrt(n);
sqrt(n) - 1;
auto it = lower_bound(xxx.begin(), xxx.end(), n) - xxx.begin();
if (xxx[it] == n) {
} else
it--;
it++;
for (int i = 0; i < xxx.size(); i++) {
if (1LL * xxx[i] * xxx[i] > n) {
ans += it - i;
break;
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Sieve(1000000);
for (int i = 0; i <= 1000000; i++) {
if (is_prime[i]) xxx.push_back(i);
}
int t;
t = 1;
cin >> t;
while (t--) {
jabru();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 45;
vector<int> G[N];
int f[N], g[N], child[N];
int n, u, v, res[N];
void dfs(int u, int p) {
child[u] = 1;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == p) continue;
dfs(v, u);
f[u] = max(f[u], f[v]);
child[u] += child[v];
}
if (child[u] <= n / 2) f[u] = max(f[u], child[u]);
}
void solve(int u, int p) {
int p1, p2;
p1 = p2 = 0;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == p) continue;
if (f[p1] < f[v]) {
p2 = p1;
p1 = v;
} else if (f[p2] < f[v]) {
p2 = v;
}
}
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == p) continue;
if (n - child[v] <= n / 2) g[v] = n - child[v];
g[v] = max(g[v], g[u]);
if (v == p1)
g[v] = max(g[v], f[p2]);
else
g[v] = max(g[v], f[p1]);
solve(v, u);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; ++i) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 1);
solve(1, 1);
for (int i = 1; i <= n; ++i) {
res[i] = 1;
for (int j = 0; j < G[i].size(); ++j) {
int v = G[i][j];
if (child[v] > child[i]) {
if (n - child[i] > n / 2) {
if (n - child[i] - g[i] > n / 2) {
res[i] = 0;
}
break;
}
} else {
if (child[v] > n / 2) {
if (child[v] - f[v] > n / 2) {
res[i] = 0;
}
break;
}
}
}
cout << res[i] << ' ';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 1;
for (int i = 6; i <= n; i++) {
if (n % i == 0) {
int k1 = 0, k0 = 0;
int f = 0;
int x = i;
while (x > 1 and f == 0) {
int x2 = x % 2;
if (x2 == 1 and k0 > 0)
k1++;
else if (x2 == 0 and k1 == 0)
k0++;
else
f = 1;
x /= 2;
}
if (k1 - k0 == 0 and f == 0) ans = i;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long num, long long n) {
long long e = 1LL;
long long a = num;
while (n) {
if (n & 1) {
e = (e * a) % 1000000007LL;
}
n /= 2;
a = (a * a) % 1000000007LL;
}
return e;
}
long long sum(int n) {
long long dp = 1, res = 0;
long long numerator = n - 1;
long long denominator = 1;
for (int i = 1; i <= (n / 2); i++) {
dp = (dp * numerator) % 1000000007LL;
dp = (dp * binpow(denominator, (long long)(1000000007LL - 2))) %
1000000007LL;
res = (res + dp) % 1000000007LL;
numerator = ((long long)(n - 2 * i) * (n - 2 * i - 1)) % 1000000007LL;
denominator = ((long long)(n - i) * (i + 1)) % 1000000007LL;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
long long ans = (sum(n) + sum(m) + 1) % 1000000007LL;
ans = (ans * 2LL) % 1000000007LL;
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 1000007, MOD = 1e9 + 7;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const long long P = 19260817;
char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline 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 << 3) + (x << 1) + ch - '0', ch = getchar();
return x * f;
}
void write(int x) {
if (!x) putchar('0');
if (x < 0) x = -x, putchar('-');
static int sta[20];
register int tot = 0;
while (x) sta[tot++] = x % 10, x /= 10;
while (tot) putchar(sta[--tot] + 48);
}
int n;
long long k;
long long a[maxn], b[maxn];
long long rta[maxn], rtb[maxn];
struct node {
long long x;
int id;
friend bool operator<(const node &a, const node &b) {
if (a.x != b.x) return a.x > b.x;
if (rtb[a.id] != rtb[b.id]) return rtb[a.id] < rtb[b.id];
return rta[a.id] < rta[b.id];
}
};
priority_queue<node> q;
bool check(long long x) {
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++) {
rta[i] = a[i], rtb[i] = b[i];
if (a[i] / b[i] < k) q.push((node){a[i] / b[i], i});
}
if (q.empty()) return true;
for (int i = 1; i <= k; i++) {
node rt = q.top();
q.pop();
int id = rt.id;
if (rt.x < i - 1) return false;
if ((rta[id] + x) / rtb[id] < k)
rta[id] += x, q.push((node){rta[id] / rtb[id], id});
if (q.empty()) return true;
}
return true;
}
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
for (int i = 1; i <= n; i++) scanf("%lld", b + i);
long long l = 0, r = 1e13, ans = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, t, p, k, c[60][60], ans;
int main() {
cin >> n >> t;
if (t & (t - 1)) return cout << 0, 0;
while (!(t >> p & 1)) p++;
p++, n++;
for (int i = 0; i < 60; i++)
for (int j = 0; j < 60; j++)
if (j <= i) c[i][j] = (i && j) ? c[i - 1][j] + c[i - 1][j - 1] : 1;
for (long long i = 59; i >= 0; i--)
if ((n >> i & 1) && p - k >= 0) ans += c[i][p - k], k++;
if (p == k) ans++;
if (p == 1) ans--;
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
string s;
int tb[26][100005];
int dp[255][255][255];
string w[3];
int num[3];
void recu(int a, int b, int c) {
int &val = dp[a][b][c];
val = n + 1;
if (a) val = min(val, tb[w[0][a - 1] - 'a'][dp[a - 1][b][c]] + 1);
if (b) val = min(val, tb[w[1][b - 1] - 'a'][dp[a][b - 1][c]] + 1);
if (c) val = min(val, tb[w[2][c - 1] - 'a'][dp[a][b][c - 1]] + 1);
}
int main() {
cin >> n >> q >> s;
for (int i = 0; i < 26; i++) {
int temp = n;
tb[i][n] = n;
tb[i][n + 1] = n;
for (int j = n - 1; j >= 0; j--) {
if (s[j] - 'a' == i) temp = j;
tb[i][j] = temp;
}
}
for (int i = 0; i < 255; i++)
for (int j = 0; j < 255; j++)
for (int k = 0; k < 255; k++) dp[i][j][k] = n + 1;
dp[0][0][0] = 0;
for (int i = 0; i < q; i++) {
string c;
cin >> c;
if (c[0] == '+') {
int t;
cin >> t;
cin >> c;
w[t - 1] += c;
num[t - 1]++;
int min1 = (t == 1) ? num[0] : 0;
int min2 = (t == 2) ? num[1] : 0;
int min3 = (t == 3) ? num[2] : 0;
for (int j = min1; j <= num[0]; j++)
for (int k = min2; k <= num[1]; k++)
for (int l = min3; l <= num[2]; l++) recu(j, k, l);
}
if (c[0] == '-') {
int t;
cin >> t;
w[t - 1].pop_back();
num[t - 1]--;
}
if (dp[num[0]][num[1]][num[2]] <= n)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 2e6 + 9;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<vector<int>> g(n + 1);
for (int i = 0; i < n; i++) {
int m, p;
cin >> m >> p;
g[m].push_back(p);
}
int pref = n;
long long ans = 0;
int cur = 0;
multiset<int> st;
for (int i = n; i >= 0; i--) {
pref -= (int)g[i].size();
for (auto x : g[i]) st.insert(x);
int need = 0;
if (pref + cur < i) need = i - pref - cur, cur += need;
while (need) {
need--;
ans += *st.begin();
st.erase(st.begin());
}
}
cout << ans << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, f[5005][30][30];
string s;
double res = 0.0;
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++)
for (int j = 1; j < s.size(); j++)
f[j][s[i] - 'a'][s[(i + j) % s.size()] - 'a']++;
for (int i = 0; i <= 25; i++) {
int maxn = 0;
for (int j = 1; j < s.size(); j++) {
int sum = 0;
for (int t = 0; t <= 25; t++) sum += (f[j][i][t] == 1);
maxn = max(maxn, sum);
}
res += double(maxn) / double(s.size());
}
cout << setprecision(10) << fixed << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
vector<int> a;
for (int i = 0; i < n; i++) {
int s, d;
cin >> s >> d;
int md = t - s;
if (md <= 0)
a.push_back(s);
else {
int y = md / d;
if (md % d != 0) y++;
a.push_back(s + (y * d));
}
}
int mint = 1000000, mini;
for (int i = 0; i < n; i++) {
if (a[i] < mint) {
mint = a[i];
mini = i;
}
}
cout << mini + 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 100;
char f[N][N];
bool read() {
if (!(cin >> n >> m)) return false;
for (int i = 0; i < int(n); ++i) cin >> f[i];
return true;
}
void solve() {
int res = 0;
for (int i = 0; i < int(n - 1); ++i)
for (int j = 0; j < int(m - 1); ++j) {
string t;
for (int k = 0; k < int(2); ++k)
for (int l = 0; l < int(2); ++l) t += f[i + k][j + l];
sort(t.begin(), t.end());
res += (t == "acef");
}
cout << res << endl;
}
int main() {
while (read()) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long Linf = 1e18 + 5;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T lcm(T a, T b) {
return a * b / __gcd(a, b);
}
int read() {
int res = 0;
int neg;
while (true) {
char ch = getchar();
if ((ch >= '0' && ch <= '9') || ch == '-') {
if (ch == '-')
neg = -1;
else
neg = 1, res = ch - '0';
break;
}
}
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9')
res *= 10, res += ch - '0';
else
break;
}
return res * neg;
}
void print(int x) {
if (x == 0) {
putchar('0');
putchar('\n');
return;
}
static char buf[20];
int nn = 0;
if (x < 0) putchar('-'), x *= -1;
while (x) {
buf[++nn] = x % 10 + '0';
x /= 10;
}
for (int(i) = (nn); (i) >= int(1); (i)--) putchar(buf[i]);
putchar('\n');
}
const int MAXN = 1111;
const long long mod = 1000000000;
int ar[MAXN];
long long F[MAXN];
int main() {
F[0] = 1;
F[1] = 1;
for (int(i) = (2); (i) < int(MAXN); (i)++) F[i] = (F[i - 1] + F[i - 2]) % mod;
int n = read();
int m = read();
for (int(i) = (1); (i) <= int(n); (i)++) ar[i] = read();
for (int(i) = (1); (i) <= int(m); (i)++) {
int t = read();
if (t == 1) {
int x = read();
int v = read();
ar[x] = v;
} else {
int l = read();
int r = read();
int k = 0;
long long res = 0LL;
for (int(i) = (l); (i) <= int(r); (i)++) {
res += F[k++] * ar[i] % mod;
res %= mod;
}
cout << res << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a[10], n;
string s = "codeforces";
for (int i = 0; i < 10; i++) a[i] = 1;
cin >> n;
long long int l = 2, p = 1, i = 0;
while (p < n) {
p /= a[i];
p *= l;
a[i] = l;
i++;
if (i == 10) {
i = 0;
l++;
}
}
for (int i = 0; i < 10; i++) {
while (a[i]) {
cout << s[i];
a[i]--;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int src, dst;
int weight;
Edge(int src, int dst, int weight) : src(src), dst(dst), weight(weight) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight
: e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
const int MAXN = 100;
int main() {
int x, n;
cin >> x;
for (n = 1; n * n / 2 + 1 < x; n += 2)
;
cout << (x == 3 ? 5 : n) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int maxs = 100 * 100 * 10 + 10;
int dp1[maxs], dp2[maxs];
int n, a[maxs];
using namespace std;
int findd(int k) {
int d1 = 0, d2 = 0;
if (k != 1 && a[k - 1] < a[k]) d1 = dp1[k - 1];
if (k != n && a[k + 1] > a[k]) d2 = dp2[k + 1];
return d1 + d2;
}
int f(int k) {
int d1 = 0, d2 = 0;
int x = a[k];
if (k != 1) {
a[k] = a[k - 1] + 1;
d1 = findd(k);
}
if (k != n) {
a[k] = a[k + 1] - 1;
d2 = findd(k);
}
a[k] = x;
return max(d1, d2) + 1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
dp1[1] = 1;
for (int i = 2; i <= n; i++) {
if (a[i] > a[i - 1])
dp1[i] = dp1[i - 1] + 1;
else
dp1[i] = 1;
}
dp2[n] = 1;
for (int i = n - 1; i >= 1; i--) {
if (a[i] < a[i + 1])
dp2[i] = dp2[i + 1] + 1;
else
dp2[i] = 1;
}
int ans = 1;
for (int i = 1; i <= n; i++) ans = max(ans, f(i));
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, k, a, div, dif, sum = 0, m, mark;
vector<long long> v, vec;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
div = v[0] / m;
dif = m - (v[0] % m);
vec.push_back(div);
sum += v[0];
for (i = 1; i < n; i++) {
mark = 0;
if (v[i] >= dif && dif > 0) mark = 1;
if (v[i] >= dif) {
v[i] -= dif;
dif -= dif;
}
div = v[i] / m;
if (mark == 1) div += 1;
vec.push_back(div);
if (dif > v[i])
dif -= v[i];
else
dif = m - (v[i] % m);
}
for (i = 0; i < vec.size(); i++) cout << vec[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main(int argc, char** argv) {
using std::cin;
using std::cout;
std::vector<long> nums;
nums.reserve(4);
for (size_t i = 0; i < 4; i++) {
long t;
cin >> t;
nums.push_back(t);
}
if (std::abs(nums[2] - nums[3]) > 1) {
cout << -1;
return 0;
}
std::string answer;
answer.reserve(1000000);
size_t first4 = 0U, last7 = 0U;
if (nums[2] > nums[3]) {
for (long i = 0; i < nums[2]; ++i) answer += "47";
first4 = 0U;
last7 = 2 * nums[2] - 1;
nums[0] -= nums[2];
nums[1] -= nums[2];
} else if (nums[2] < nums[3]) {
for (long i = 0; i < nums[3]; ++i) answer += "74";
first4 = 1U;
last7 = 2 * nums[3] - 2;
nums[0] -= nums[3];
nums[1] -= nums[3];
} else {
if (nums[0] == nums[2]) {
for (long i = 0; i < nums[2]; ++i) answer += "74";
answer += "7";
first4 = 1U;
last7 = 2 * nums[2];
nums[0] -= nums[2];
nums[1] -= nums[2] + 1;
} else {
for (long i = 0; i < nums[2]; ++i) answer += "47";
answer += "4";
first4 = 0U;
last7 = 2 * nums[2] - 1;
nums[0] -= nums[2] + 1;
nums[1] -= nums[2];
}
}
if (nums[0] >= 0 && nums[1] >= 0) {
for (size_t i = 0; i < answer.size(); ++i) {
if (i == first4)
for (long j = 0; j < nums[0]; ++j) cout << "4";
if (i == last7)
for (long j = 0; j < nums[1]; ++j) cout << "7";
cout << answer[i];
}
} else
cout << -1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
s += '0';
int ans = 0;
for (int i = 0; i < (int)s.length() - 1; i++) {
if (i == (int)s.length() - 2 && s[i] == '1') break;
if (s[i] == '1') {
ans += 2;
s[i + 1]++;
}
if (s[i] == '0') ans++;
if (s[i] == '2') {
ans++;
s[i + 1]++;
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[10000005], t[5000005], t1[5000005], t2[5000005], t3[5000005],
t4[5000005];
int n, k, m, nowl, z[10000005], A[5000005], l[5000005];
void extend(char* s, int l) {
for (int i = 0; i < l; i++) t[++nowl] = s[i];
}
void solve1(int n) {
for (int i = 1; i <= n; i++) t1[i] = s[n - i + 1];
}
void solve2(int n) {
for (int i = n + 1; i <= 2 * n; i++) s[i] = s[i - n];
int i = 1, j = 2, k = 0;
while (i <= n && j <= n && k < n) {
if (s[i + k] == s[j + k])
k++;
else if (s[i + k] < s[j + k])
j += k + 1, k = 0;
else
i += k + 1, k = 0;
if (i == j) j++;
}
for (int x = 0; x < n; x++) t2[x + 1] = s[min(i, j) + x];
}
void solve3(int n) {
for (int i = n + 1; i <= 2 * n; i++) s[i] = s[n - (i - n) + 1];
n *= 2;
z[1] = n;
int l = 1, r = 1;
for (int i = 2; i <= n; i++) {
if (r < i) {
l = r = i;
while (r <= n && s[r] == s[r - l + 1]) r++;
z[i] = r - l;
r--;
} else {
if (z[i - l + 1] < r - i + 1)
z[i] = z[i - l + 1];
else {
l = i;
while (r <= n && s[r] == s[r - l + 1]) r++;
z[i] = r - l;
r--;
}
}
}
n /= 2;
int j = n + 1;
for (int i = n; i >= 1; i--) {
int l = i, r = j - 1;
l = n - l + 1, r = n - r + 1;
int len = z[r + n];
if (len < l - r + 1) {
if (s[len + 1] > s[j - len - 1]) j = i;
} else {
len = j - i;
l = len + 1, r = j - 1;
if (s[z[l] + 1] < s[l + z[l]]) j = i;
}
}
int tot = 0;
for (int i = n; i >= j; i--) t3[++tot] = s[i];
for (int i = 1; i < j; i++) t3[++tot] = s[i];
}
void solve4(int n) {
int p = m;
while ((A[p + 1] - A[p]) * 2 <= (A[p] - A[p - 1])) {
bool flag = 0;
for (int i = A[p] - 1; i >= A[p - 1]; i--) {
if (s[i] < s[n - i + A[p - 1]]) {
flag = 1;
break;
}
if (s[i] > s[n - i + A[p - 1]]) break;
}
if (flag) break;
p--;
}
p = A[p];
int tot = 0;
for (int i = p; i <= n; i++) t4[++tot] = s[i];
for (int i = p - 1; i >= 1; i--) t4[++tot] = s[i];
}
void update(char* t1, char* t2, int n) {
for (int i = 1; i <= n; i++) {
if (t1[i] < t2[i]) return;
if (t2[i] < t1[i]) break;
}
for (int i = 1; i <= n; i++) t1[i] = t2[i];
}
void solve(int n) {
solve1(n);
solve2(n);
solve3(n);
solve4(n);
update(t1, t2, n);
update(t1, t3, n);
update(t1, t4, n);
extend(t1 + 1, n);
}
int main() {
scanf("%s", s + 1);
n = (int)strlen(s + 1);
scanf("%d", &k);
for (int i = 1; i * 2 <= n; i++) swap(s[i], s[n - i + 1]);
if (k == 1) {
for (int i = 1; i <= n; i++) t[i] = s[n - i + 1];
for (int i = 1; i <= n; i++) {
if (s[i] < t[i]) {
printf("%s\n", s + 1);
return 0;
}
if (s[i] > t[i]) {
printf("%s\n", t + 1);
return 0;
}
}
printf("%s\n", s + 1);
return 0;
}
for (int i = 1; i <= n;) {
int j = i, k = i + 1;
while (s[j] <= s[k]) {
if (s[j] < s[k])
j = i;
else
j++;
k++;
}
A[++m] = i;
l[m] = k - j;
while (i <= j) i += k - j;
}
A[m + 1] = n + 1;
while (m && k >= 3) {
extend(s + A[m], A[m + 1] - A[m]);
if (l[m] != 1 || l[m - 1] != 1) k--;
m--;
}
if (!m) {
printf("%s\n", t + 1);
return 0;
}
solve(A[m + 1] - 1);
printf("%s\n", t + 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char inp[1005];
scanf("%d", &n);
scanf("%s", inp);
string k = string(inp);
k = k.append(k);
int H = 0;
for (int i = 0; i < n; i++)
if (k[i] == 'H') H++;
int T = n - H;
int mat[2005];
for (int i = 0; i < 2 * n; i++)
if (k[i] == 'H')
mat[i] = 1;
else
mat[i] = 0;
int prefs[2005];
prefs[0] = 0;
for (int i = 1; i < 2 * n; i++) prefs[i] = prefs[i - 1] + mat[i];
int min = n;
for (int i = n; i < 2 * n; i++) {
int cons = prefs[i] - prefs[i - T];
if (cons < min) min = cons;
}
printf("%d\n", min);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int d(int n, int n2) {
int i, j, sum = 0;
for (i = n;; i++) {
if (i == n2) break;
if (i == 12) i = 0;
sum++;
}
return sum;
}
int main(void) {
string aa[] = {"C", "C#", "D", "D#", "E", "F",
"F#", "G", "G#", "A", "B", "H"};
int i, j, k, l, a, b, c;
string s1, s2, s3;
vector<int> as;
cin >> s1 >> s2 >> s3;
for (i = 0; i < 12; i++)
if (s1 == aa[i]) {
as.push_back(i + 1);
break;
}
for (i = 0; i < 12; i++)
if (s2 == aa[i]) {
as.push_back(i + 1);
break;
}
for (i = 0; i < 12; i++)
if (s3 == aa[i]) {
as.push_back(i + 1);
break;
}
sort(as.begin(), as.end());
a = d(as[0], as[1]);
b = d(as[1], as[2]);
if (a == 4 && b == 3) {
cout << "major\n";
return 0;
} else if (a == 3 && b == 4) {
cout << "minor\n";
return 0;
}
a = d(as[1], as[2]);
b = d(as[2], as[0]);
if (a == 4 && b == 3) {
cout << "major\n";
return 0;
} else if (a == 3 && b == 4) {
cout << "minor\n";
return 0;
}
a = d(as[2], as[0]);
b = d(as[0], as[1]);
if (a == 4 && b == 3) {
cout << "major\n";
return 0;
} else if (a == 3 && b == 4) {
cout << "minor\n";
return 0;
}
cout << "strange\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long dx[4] = {-1, 0, 1, 0};
const long long dy[4] = {0, -1, 0, 1};
const long long dxx[] = {1, 1, 0, -1, -1, -1, 0, 1};
const long long dyy[] = {0, 1, 1, 1, 0, -1, -1, -1};
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\n";
err(++it, args...);
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long modexpo(long long x, long long n, long long M) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return modexpo((x * x) % M, n / 2, M);
else
return (x * modexpo((x * x) % M, (n - 1) / 2, M)) % M;
}
long long bexpo(long long x, long long n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return bexpo(x * x, n / 2);
else
return x * bexpo(x * x, (n - 1) / 2);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
const long long mod = 1e9 + 7;
const long long N = 4e5 + 5;
const long long INF = 1e18;
void solve() {
long long p;
cin >> p;
;
vector<long long> a(p);
for (auto &i : a) cin >> i;
;
sort(a.begin(), a.end());
if (p % 2 == 0) {
cout << a[(p / 2) - 1] << "\n";
;
} else {
cout << a[p / 2] << "\n";
;
}
}
int32_t main() {
long long t;
t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
const int NN = 101010;
const int MM = 222;
const int mod = 998244353;
int dp[NN][MM][2];
int a[NN];
int add(int &u, int v) {
u += v;
if (u >= mod) u -= mod;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (int i = 1; i <= 200; i++) {
dp[1][i][0] = dp[1][i - 1][0];
if (a[1] == -1 || a[1] == i) {
dp[1][i][0]++;
}
}
for (int i = 2; i <= n; i++)
for (int j = 1; j <= 200; j++) {
dp[i][j][0] = (dp[i - 1][j - 1][0] + dp[i - 1][j - 1][1]) % mod;
dp[i][j][1] = ((dp[i - 1][200][1] - dp[i - 1][j - 1][1] + mod) % mod +
(dp[i - 1][j][0] - dp[i - 1][j - 1][0] + mod) % mod) %
mod;
if (a[i] != -1 and j != a[i]) {
dp[i][j][0] = dp[i][j][1] = 0;
}
add(dp[i][j][0], dp[i][j - 1][0]);
add(dp[i][j][1], dp[i][j - 1][1]);
}
cout << dp[n][200][1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s1 = 0, s2 = 0, count = 0;
cin >> n;
int arr[n + 5];
for (int i = 0; i < n; i++) {
cin >> arr[i];
s2 += arr[i];
}
for (int i = 0; i < n - 1; i++) {
s1 += arr[i];
s2 -= arr[i];
if (s2 == s1) count++;
}
cout << count << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
std::pair<int, int> DR[] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {-1, -1}, {1, 1}, {1, -1}};
using namespace std;
int gcd(int a, int b) {
if (b) return gcd(b, a % b);
return a;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n;
vector<int> vec[100];
int dp[505][505];
int pd[505];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n;
string s;
cin >> s;
for (int i = 0; i < (int)((s).size()); i++) {
vec[s[i] - 'a'].push_back(i + 1);
}
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= n; j++) pd[i] = 1e9;
for (int j = i; j <= n; j++) {
if (j == i) {
dp[i][j] = 1;
pd[j] = 0;
continue;
}
dp[i][j] = 1000;
pd[j] = dp[i][j - 1];
for (int jj = i; jj <= j - 1; jj++) {
if (s[jj - 1] == s[j - 1]) {
pd[j] = min(pd[j], pd[jj] + dp[jj + 1][j - 1]);
}
}
for (int jj = i; jj <= j; jj++) {
dp[i][j] = min(dp[i][j], pd[jj] + dp[jj + 1][j]);
}
dp[i][j]++;
for (int jj = i; jj <= j; jj++) {
dp[i][j] = min(dp[i][j], dp[i][jj] + dp[jj + 1][j]);
}
}
}
return cout << dp[1][n], 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
long long n, m, A, b[200005], ans = 1;
inline long long ksm(long long k, long long x) {
register long long y = 1;
while (x) {
if (x & 1) y = y * k % mod;
k = k * k % mod;
x >>= 1;
}
return y;
}
int main() {
register int i, j;
scanf("%lld%lld%lld", &n, &m, &A);
for (i = 1; i <= m; i++) {
scanf("%lld", &b[i]);
}
sort(b + 1, b + 1 + m);
for (i = 1; i <= m; i++) {
register long long len = b[i] - b[i - 1];
ans = (ans *
((ksm(A, len) * (ksm(A, len) - 1) % mod * ksm(2, mod - 2) % mod +
ksm(A, len)) %
mod) %
mod) %
mod;
}
ans = ans * ksm(A, n - 2 * b[m]) % mod;
printf("%lld", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
struct Node {
int x, y, d;
} p[N], k;
int n, ans[N], siz[N];
vector<int> edge[N];
inline bool cmp(Node u, Node v) {
return ((double)(u.y - k.y) / (u.x - k.x)) >
((double)(v.y - k.y) / (v.x - k.x));
}
void dfs1(int u, int fa) {
siz[u] = 1;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == fa) continue;
dfs1(v, u);
siz[u] += siz[v];
}
}
void dfs2(int u, int fa, int h, int t) {
int pos = h;
for (int i = h; i <= t; i++) {
if (p[i].x < p[pos].x || p[i].x == p[pos].x && p[i].y < p[pos].y) {
pos = i;
}
}
ans[p[pos].d] = u;
k = p[pos];
swap(p[h], p[pos]);
sort(p + h + 1, p + t + 1, cmp);
pos = h;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i];
if (v == fa) continue;
dfs2(v, u, pos + 1, pos + siz[v]);
pos += siz[v];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i].x, &p[i].y);
p[i].d = i;
}
dfs1(1, -1);
dfs2(1, -1, 1, n);
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, w;
vector<int> fr[111111];
vector<int> ba[111111];
int num[1111111];
long long co[111111][222];
long long a[111111];
long long sum[111111];
long long pl[222];
long long ex[222];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= m; i++) {
int how;
scanf("%d", &how);
if (how >= 500) num[i] = ++w;
while (how--) {
int temp;
scanf("%d", &temp);
sum[i] += a[temp];
fr[i].push_back(temp);
if (num[i]) ba[temp].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < ba[i].size(); j++) {
for (int k = 0; k < ba[i].size(); k++) {
co[ba[i][j]][num[ba[i][k]]]++;
}
}
}
for (int i = 1; i <= m; i++) {
if (!num[i]) {
for (int j = 0; j < fr[i].size(); j++) {
for (int k = 0; k < ba[fr[i][j]].size(); k++) {
co[i][num[ba[fr[i][j]][k]]]++;
}
}
}
}
while (q--) {
char temp;
scanf(" %c", &temp);
if (temp == '+') {
int k;
long long x;
scanf("%d%lld", &k, &x);
if (!num[k]) {
for (int i = 0; i < fr[k].size(); i++) a[fr[k][i]] += x;
} else
pl[num[k]] += x;
for (int i = 1; i <= w; i++) ex[i] += x * co[k][i];
} else {
int k;
scanf("%d", &k);
long long dap = 0;
if (!num[k]) {
for (int i = 0; i < fr[k].size(); i++) dap += a[fr[k][i]];
for (int i = 1; i <= w; i++) dap += co[k][i] * pl[i];
} else
dap = sum[k] + ex[num[k]];
printf("%lld\n", dap);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 100;
struct Node {
long long x, y;
int l, r;
Node() {}
Node(long long xx, long long yy) {
x = xx;
y = yy;
}
double length() { return sqrt(x * x + y * y); }
long long mult(const Node &n) { return x * n.x + y * n.y; }
Node operator-() { return Node(-x, -y); }
};
long long operator*(const Node &a, const Node &b) {
return a.x * b.y - a.y * b.x;
}
Node operator-(const Node &a, const Node &b) {
return Node(a.x - b.x, a.y - b.y);
}
int n, cnt;
int ans[maxn], the_Index[3];
Node node[maxn];
bool Close(Node &a, Node &b) {
if (a.mult(b) < 0) {
return false;
}
long long tmp = abs(a * b);
return tmp <= a.length() * b.length() / 2 * sqrt(3.0);
}
int Creat_Node(const Node &n, int l, int r) {
++cnt;
node[cnt] = n;
node[cnt].l = l;
node[cnt].r = r;
return cnt;
}
void Solve() {
sort(the_Index, the_Index + 3);
do {
int l = the_Index[0];
int r = the_Index[1];
Node tmp = node[l];
Node ntmp = node[r];
if (Close(tmp, ntmp)) {
ans[l] = 1;
ans[r] = -1;
int Index = Creat_Node(tmp - ntmp, l, r);
ans[Index] = 1;
the_Index[0] = Index;
the_Index[1] = the_Index[2];
return;
}
ntmp = -node[r];
if (Close(tmp, ntmp)) {
ans[l] = ans[r] = 1;
int Index = Creat_Node(tmp - ntmp, l, r);
ans[Index] = 1;
the_Index[0] = Index;
the_Index[1] = the_Index[2];
return;
}
} while (next_permutation(the_Index, the_Index + 3));
}
int main() {
ios::sync_with_stdio(false);
while (scanf("%d", &n) != EOF) {
cnt = 0;
for (int i = 1; i <= n; ++i) {
scanf("%I64d%I64d", &node[i].x, &node[i].y);
node[i].l = node[i].r = 0;
++cnt;
}
if (n == 1) {
printf("1\n");
continue;
}
ans[1] = 1;
the_Index[0] = 1;
the_Index[1] = 2;
for (int i = 3; i <= n; ++i) {
the_Index[2] = i;
Solve();
}
int l = the_Index[0];
int r = the_Index[1];
if (node[l].mult(node[r]) >= 0) {
ans[r] = -1;
} else {
ans[r] = 1;
}
for (int i = cnt; i >= 1; --i) {
ans[node[i].l] *= ans[i];
ans[node[i].r] *= ans[i];
}
for (int i = 1; i <= n; ++i) {
if (i != 1) {
printf(" ");
}
printf("%d", ans[i]);
}
printf("\n");
}
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
string a,b;
cin>>a>>b;
int r=0,bl=0,i;
for(i=0;i<n;i++)
{
if(a[i]>b[i])
{
r++;
}
else if(a[i]<b[i])
{
bl++;
}
else
{
r++;
bl++;
}
}
// cout<<r<<" "<<bl<<"\n";
if(r>bl)
{
cout<<"RED"<<"\n";
}
else if(bl>r)
{
cout<<"BLUE"<<"\n";
}
else
{
cout<<"EQUAL"<<"\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(i=a; i<b; i++)
#define bac(i,a,b) for(i=a;i>=b;i--)
#define repf(it,x) for(auto it= x.begin(); it!=x.end(); it++)
#define repb(it,x) for(auto it= x.rbegin(); it!=x.rend(); it++)
#define reps(i,a) for(i=0; a[i]!='\0'; i++)
#define fir first
#define sec second
#define b() begin()
#define e() end()
#define all(x) (x).begin(),(x).end()
#define pb(i) push_back(i)
#define ppb() pop_back()
#define ll long long
#define mp(a,b) make_pair(a,b)
#define hell 1000000000000000000
#define M 1000000007
vector<ll> cost[4];
set<pair<ll,ll>> bad[3];
int main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
long long int i, j,d, m,k, t=1, x=0, y,q,c=0, sum=0, maxx, ans=0, count, minn;
//cin>> t;
while(t--){
ll ni[4], mi[3], flag=1;
rep(i,0,4) cin>>ni[i];
rep(j,0,4)
rep(i,0,ni[j]){
cin>> x;
cost[j].pb(x);
}
rep(j,0,3){
cin>>mi[j];
rep(i,0,mi[j]){
cin>>x>>y;
bad[j].insert(mp(x-1,y-1));
}
}
vector<pair<ll,ll>> v;
rep(i,0,ni[0]) v.pb(mp(cost[0][i], i));
sort(all(v));
rep(j,0,3){
vector<pair<ll,ll>> v1;
rep(i,0,ni[j+1]){
k=0;
while(k<v.size() && bad[j].find(mp(v[k].sec, i))!=bad[j].e())
k++;
if(k==v.size()) continue;
v1.pb(mp(v[k].fir+cost[j+1][i], i));
}
sort(all(v1));
v=v1;
}
if(!v.empty()) cout<<v[0].fir;
else cout<<"-1";
cout<<"\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int nMAX = 35;
char grid[nMAX][nMAX];
int ans;
int n, m, x;
vector<pair<int, int> > shift;
vector<pair<int, int> > KeysPos[26];
int q;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> x;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
cin >> grid[i][j];
if (grid[i][j] == 'S')
shift.push_back({i, j});
else
KeysPos[grid[i][j] - 'a'].push_back({i, j});
}
cin >> q;
cin >> s;
function<int(int, int, int, int)> dis = [&](int x, int y, int xShift,
int yShift) {
return ((x - xShift) * (x - xShift) + (y - yShift) * (y - yShift));
};
function<bool(int, int)> check = [&](int xsis, int ysis) {
for (int i = 0; i < shift.size(); ++i) {
int distance = dis(xsis, ysis, shift[i].first, shift[i].second);
if (distance <= x * x) return 1;
}
return 0;
};
bool IfLessThan[26] = {0};
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < KeysPos[i].size() && !IfLessThan[i]; ++j) {
IfLessThan[i] |= check(KeysPos[i][j].first, KeysPos[i][j].second);
}
}
for (int i = 0; i < s.size(); ++i) {
if (islower(s[i])) {
if (KeysPos[s[i] - 'a'].empty()) return cout << -1 << "\n", 0;
;
} else {
char ch = tolower(s[i]);
if (KeysPos[ch - 'a'].empty() || shift.empty()) {
return cout << -1 << "\n", 0;
;
}
if (!IfLessThan[ch - 'a']) ans++;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
int n, m;
vector<int> g[N];
void eadd(int u, int v) {
g[u].push_back(v);
g[v].push_back(u);
}
int t = 0;
long long int mx[N];
long long int psum[N];
int dt[N], lw[N];
stack<int> stk;
void dfs(int u, int p = -1) {
dt[u] = lw[u] = ++t;
stk.push(u);
for (int v : g[u])
if (!dt[v]) {
dfs(v, u);
lw[u] = min(lw[u], lw[v]);
} else if (v != p)
lw[u] = min(lw[u], dt[v]);
if (lw[u] == dt[u]) {
if (u == stk.top()) {
stk.pop();
return;
}
int cmn = u, cmx = u, i = u;
do {
i = stk.top();
stk.pop();
cmn = min(cmn, i);
cmx = max(cmx, i);
} while (i != u);
mx[cmn] = cmx - 1;
}
}
void print(string s, long long int val) {
cout << '[' << s << ": " << val << ']';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
eadd(u, v);
}
fill(mx, mx + n + 1, n);
for (int i = 1; i <= n; ++i)
if (!dt[i]) dfs(i);
for (int i = n - 1; i; --i) mx[i] = min(mx[i], mx[i + 1]);
for (int i = 1; i <= n; ++i) psum[i] = psum[i - 1] + mx[i];
int q;
cin >> q;
while (q--) {
long long int l, r;
cin >> l >> r;
long long int t1 = (r * (r + 1ll) - (l - 1) * l) >> 1, t2 = r - l + 1ll,
t01 = 0, t02 = 0;
long long int k = upper_bound(mx + l, mx + r + 1, r) - mx;
--k;
if (k >= l) t01 = (psum[k] - psum[l - 1]);
++k;
if (k <= r) t02 = (r - k + 1ll) * r;
cout << t01 + t02 - t1 + t2 << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using pii = std::pair<int, int>;
using vpii = std::vector<pii>;
struct Jury {
vi perm;
vpii edges;
int getN() { return ((int)(perm).size() - 1) / 2; }
Jury(int n) : perm(1 + 2 * n, 0) {
for (int i = 1; i <= 2 * n; i++) perm[i] = i;
}
char ask(int a, int b) {
if (perm[a] < perm[b]) {
edges.emplace_back(a, b);
return '<';
}
assert(perm[a] > perm[b]);
edges.emplace_back(b, a);
return '>';
}
bool next() {
edges.clear();
return std::next_permutation(perm.begin() + 1, perm.end());
}
bool check() {
int n = ((int)(perm).size() - 1) / 2;
vi a{0}, ind{0};
for (int i = n + 1; i <= 2 * n; i++) {
a.push_back(i);
}
for (int i = 1; i <= 2 * n; i++) {
if (perm[i] > n) ind.push_back(i);
}
std::sort((a).begin(), (a).end());
vvi answers;
vi backup = perm;
do {
vi save = perm;
for (int i = 1; i <= n; i++) {
perm[ind[i]] = a[i];
}
bool ok = true;
for (auto &[a, b] : edges) {
ok &= perm[a] < perm[b];
}
if (ok) {
answers.push_back(perm);
}
perm = save;
} while (std::next_permutation(a.begin() + 1, a.end()));
perm = backup;
if ((int)(answers).size() == 1) {
std::cout << "Wrong Answer on testcase";
for (int i = 1; i <= 2 * n; i++) {
std::cout << ' ' << perm[i];
}
std::cout << std::endl;
std::cout << "order of indexes";
for (int i = 1; i <= n; i++) {
std::cout << ' ' << ind[i];
}
std::cout << " is strictly defined!" << std::endl;
std::cout << "you determined that these condition holds:" << std::endl;
perm = answers.back();
for (auto &[a, b] : edges) {
std::cout << a << '<' << b << "( means p[" << a << "]=" << perm[a]
<< " < "
<< "p[" << b << "] = " << perm[b] << std::endl;
}
return false;
} else {
assert((int)(answers).size() > 1);
for (int i = 1; i <= 2 * n; i++) {
if (i > 1) std::cout << ' ';
std::cout << perm[i];
}
std::cout << ": OK" << std::endl;
return true;
}
}
} jury(3);
bool test;
int getN() {
if (test) return jury.getN();
int n;
cin >> n;
return n;
}
char ask(int a, int b) {
if (test) return jury.ask(a, b);
cout << "? " << a << ' ' << b << endl;
char res;
cin >> res;
return res;
}
void checkAnsw() {
if (test) {
if (jury.check()) {
if (!jury.next()) {
std::exit(0);
}
} else {
getchar();
getchar();
std::exit(0);
}
} else
cout << '!' << endl;
}
void bfs(vector<vector<int>> &g, vector<pii> &arr, int start, int less_ind) {
int n = g.size();
queue<int> q;
q.push(start);
while (!q.empty()) {
int cur = q.front();
q.pop();
if (!g[cur][less_ind]) {
++arr[cur].first;
++arr[less_ind].second;
g[less_ind][cur] = -1;
g[cur][less_ind] = 1;
for (int i = 0; i < n; ++i)
if (g[cur][i] == -1) q.push(i);
}
}
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
test = false;
int t;
if (test)
t = 2e9;
else
cin >> t;
while (t--) {
int hn = getN();
int n = hn << 1;
vector<vector<int>> g(n, vector<int>(n));
vector<pii> arr;
vector<int> losers;
arr.reserve(n);
losers.reserve(hn);
for (int i = 1; i < n; i += 2) {
pii a = {1, 0}, b = {1, 0};
char res = ask(i, i + 1);
if (res == '<') {
losers.push_back(i);
++b.first;
++a.second;
g[i - 1][i] = -1;
g[i][i - 1] = 1;
} else {
losers.push_back(i + 1);
++a.first;
++b.second;
g[i][i - 1] = -1;
g[i - 1][i] = 1;
}
arr.push_back(a);
arr.push_back(b);
}
for (int i = 0; i < hn; ++i)
for (int j = i + 1; j < hn; ++j) {
int ind = losers[i];
int jnd = losers[j];
if (!g[ind - 1][jnd - 1]) {
char res = ask(ind, jnd);
int less_ind = ind - 1, start = jnd - 1;
if (res == '>') swap(less_ind, start);
bfs(g, arr, start, less_ind);
}
}
int found = 0;
while (found < hn) {
pii mina = {2e9, 2e9}, minb = {2e9, 2e9};
int mini = -1, minj = -1;
for (int i = 0; i < n; ++i) {
if (arr[i] < mina) {
swap(mina, minb);
swap(mini, minj);
mina = arr[i];
mini = i;
} else if (arr[i] < minb) {
minb = arr[i];
minj = i;
}
}
if (mina.first < minb.first) {
arr[mini] = {2e9, 2e9};
++found;
} else {
char res = ask(mini + 1, minj + 1);
int less_ind = mini, start = minj;
if (res == '>') swap(less_ind, start);
bfs(g, arr, start, less_ind);
}
}
checkAnsw();
}
return 0;
}
| 9 |
/* terminate command
taskkill /IM geek_template.exe /F
*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long
typedef long double ld;
#define syncboost ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
#define mp make_pair
#define pb push_back
#define psy push
#define pp pop_back
#define pl pair<ll,ll>
#define vl vector<ll>
#define vvl vector<vector<ll> >
#define vpl vector<pair<ll,ll>>
#define all(x) x.begin(),x.end()
#define precise(n) cout << fixed; cout << setprecision(n)
#define forn(i, n) for (ll i = 0; i < ll(n); i++)
#define setbit(x) __builtin_popcount(x)
#define run(i, v) for(auto &i: v)
#define hike(i, v) for(const auto &i: v)
#define srt(v) sort(v.begin(),v.end())
#define mem(x,val) memset(x,val,sizeof(x))
#define rep(i,init,n) for(ll i = init;i<n;i++)
#define rrep(i,n,init) for(ll i = n;i>=init;i--)
#define fi first
#define se second
long double pi = 3.14159265;
#define show(x) cerr << x
#define deb1(x) cout<<x<<"\n";
#define deb(x) show(#x << ": " << (x) << endl);
#define debn(x) show((x) <<" ");
#define debv(x) for(auto it : x ) debn(it);deb("\n");
#define det(x) cout<<x<<"\n";
#define No cout<<"No\n";
#define Yes cout<<"Yes\n";
#define YES cout<<"YES\n";
#define NO cout<<"NO\n";
#define sp " "
#define nl cout<<"\n";
#define ps(x,y) fixed<<setprecision(y)<<x
const ll mod =998244353;
const ll MOD =1000000007;
ll power(ll a, ll b, ll m)
{
if(a == 0) return 0;
if(b == 0) return 1;
if(b == 1) return a % m;
ll temp = power( a , b / 2 , m );
temp = ( temp * temp ) % m;
if(b % 2)
temp = (a * temp) % m;
return temp;
}
ll modinv(ll x) {
return power(x,MOD-2,MOD);
}
ll dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
const ll N = 100005;
void solve() {
int n;
cin>>n;
if(n == 1)
cout<<"9\n";
else
{
cout<<"98";
int cur = 9;
for(int i=3;i<=n;++i)
{
cout<<cur;
cur = (cur + 1)%10;
}
cout<<"\n";
}
}
int main()
{
ll test = 1;
//syncboost;
// io();
cin>> test;
// precomp();
// precise(6);
rep(testcase,1,test+1)
{
//deb(testcase);
// deb1(testcase)
// cout<<"Case #"<<testcase<<": ";
solve();
//nl
}
//cerr<<"Time : "<<1000*((double)clock())/(double)CLOCKS_PER_SEC<<"ms\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char str[120][120];
int main() {
int n;
scanf("%d", &n);
int i;
for (i = 0; i < n; i++) scanf("%s", str[i]);
int res = 0, j1, j2;
for (i = 0; i < n; i++) {
for (j1 = 0; j1 < n; j1++)
for (j2 = j1 + 1; j2 < n; j2++)
if (str[i][j1] == str[i][j2] && str[i][j1] == 'C') res++;
for (j1 = 0; j1 < n; j1++)
for (j2 = j1 + 1; j2 < n; j2++)
if (str[j1][i] == str[j2][i] && str[j1][i] == 'C') res++;
}
printf("%d\n", res);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using std::bitset;
using namespace std;
int g[302][302][302], f[302][302];
int s[10];
int n, ans;
void updateg(int a, int b, int c) {
int i, j, tem, t;
for (i = c + 1; i < 300; i++) {
g[a][b][i] = 1;
g[a][c][i] = 1;
g[b][c][i] = 1;
}
for (i = b + 1; i <= c; i++) {
g[a][i][c] = 1;
g[b][i][c] = 1;
}
for (i = a + 1; i <= b; i++) g[i][b][c] = 1;
for (t = 1; c + t < 300; t++) g[a + t][b + t][c + t] = 1;
}
void updatef(int a, int b) {
int i, j, tem, t;
for (i = b + 1; i < 300; i++) {
f[a][i] = 1;
f[b][i] = 1;
}
for (i = a + 1; i <= b; i++) f[i][b] = 1;
for (t = 1; b + t < 300; t++) f[a + t][b + t] = 1;
}
void init() {
int i, j, tem;
memset(g, -1, sizeof(g));
;
int a, b, c;
for (a = 0; a < 300; a++)
for (b = a; b < 300; b++)
for (c = b; c < 300; c++) {
if (g[a][b][c] == -1) {
g[a][b][c] = 0;
updateg(a, b, c);
}
}
memset(f, -1, sizeof(f));
;
for (a = 0; a < 300; a++)
for (b = a; b < 300; b++) {
if (f[a][b] == -1) {
f[a][b] = 0;
updatef(a, b);
}
}
}
int main() {
int i, j, tem;
init();
while (scanf("%d", &n) != EOF) {
memset(s, 0, sizeof(s));
;
for (i = 1; i <= n; i++) scanf("%d", &s[i]);
if (n == 1) {
if (s[1] != 0)
printf("BitLGM\n");
else
printf("BitAryo\n");
} else if (n == 2) {
if (s[1] > s[2]) swap(s[1], s[2]);
if (f[s[1]][s[2]] == 1)
printf("BitLGM\n");
else
printf("BitAryo\n");
} else {
sort(s + 1, s + 1 + 3);
if (g[s[1]][s[2]][s[3]] == 1)
printf("BitLGM\n");
else
printf("BitAryo\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, l;
long long fun(long long a, long long b, long long c, long long rem) {
long long ret = min(a - b - c, rem);
if (ret < 0) return 0;
return (ret + 2LL) * (ret + 1) / 2;
}
int main() {
cin >> a >> b >> c >> l;
long long ans = (long long)(l + 3LL) * (l + 2) * (l + 1) / 6;
for (int i = 0; i <= l; i++) {
ans -= fun(a + i, b, c, l - i);
ans -= fun(b + i, a, c, l - i);
ans -= fun(c + i, a, b, l - i);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 102;
int a[N][N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
for (int j = x1; j <= x2; ++j) {
for (int k = y1; k <= y2; ++k) {
++a[j][k];
}
}
}
int sum = 0;
for (int i = 1; i <= 100; ++i) {
for (int j = 1; j <= 100; ++j) {
sum += a[i][j];
}
}
printf("%d", sum);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, arr[71][71], dp[71][71][71][36];
int mulMod(long long, long long);
int addMod(int, int);
void readArray(int *, int);
void printArray(int *, int);
int solve(int i, int j, int mod, int left) {
if (i == n - 1 && (!left || j == m)) return (mod == 0 ? 0 : -1e8);
if (j == m || !left) return dp[i][j][mod][left] = solve(i + 1, 0, mod, m / 2);
if (dp[i][j][mod][left] != -1) return dp[i][j][mod][left];
int ans = -1e8, MOD = arr[i][j] % k;
if (MOD < mod)
ans = max(ans, arr[i][j] + solve(i, j + 1, mod - MOD, left - 1));
else if (MOD > mod)
ans = max(ans, arr[i][j] + solve(i, j + 1, k - (MOD - mod), left - 1));
else
ans = max(ans, arr[i][j] + solve(i, j + 1, 0, left - 1));
ans = max(ans, solve(i, j + 1, mod, left));
return dp[i][j][mod][left] = ans;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
memset(dp, -1, sizeof(dp));
cout << max(0, solve(0, 0, 0, m / 2)) << endl;
return 0;
}
int mulMod(long long a, long long b) {
a *= b;
a %= 1000000007;
return (int)a;
}
int addMod(int a, int b) {
long long c = a + b;
if (c >= 1000000007) {
c -= 1000000007;
}
return (int)c;
}
void readArray(int *nums, int n) {
for (int i = 0; i < n; i++) cin >> nums[i];
}
void printArray(int *nums, int n) {
for (int i = 0; i < n; i++) cout << nums[i] << " ";
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
char b, e;
int bn, n, c, en, st = 0, nt = 0;
using namespace std;
int main() {
cin >> b >> e >> n;
if (b == 94) bn = 1;
if (b == 62) bn = 2;
if (b == 118) bn = 3;
if (b == 60) bn = 4;
if (e == 94) en = 1;
if (e == 62) en = 2;
if (e == 118) en = 3;
if (e == 60) en = 4;
n %= 4;
c = bn;
for (int i = 1; i <= n; i++) {
c++;
if (c == 5) c = 1;
}
if (c == en) {
st++;
}
c = bn;
for (int i = 1; i <= n; i++) {
c--;
if (c == 0) c = 4;
}
if (c == en) {
nt++;
}
if (st == nt) {
cout << "undefined";
} else {
if (st == 1)
cout << "cw";
else
cout << "ccw";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[101];
cin.getline(s, 101);
int u = 0, l = 0;
for (int i = 0; s[i] != '\0'; i++) {
if (isupper(s[i]))
++u;
else
++l;
}
if (u > l) {
for (int i = 0; s[i] != '\0'; i++) {
cout << ((char)toupper(s[i]));
}
} else {
for (int i = 0; s[i] != '\0'; i++) {
cout << (char)tolower(s[i]);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, tot, top;
struct point {
int x, y;
bool operator<(const point b) const {
return (x != b.x) ? x < b.x : y < b.y;
};
inline double len() { return sqrt((double)x * x + (double)y * y); }
point operator-(const point b) const { return (point){x - b.x, y - b.y}; }
} a[1000005], st[1000005];
inline double cross(point a, point b) {
return (double)a.x * b.y - (double)a.y * b.x;
}
struct node {
point a, b, c;
inline double r() {
return abs(cross(a - c, b - c)) < 1e-10
? 0
: (a - b).len() * (b - c).len() * (c - a).len() / 2.0 /
abs(cross(a - c, b - c));
}
} ans, tmp;
inline int read() {
int ans = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
ans = (ans << 1) + (ans << 3) + (c ^ 48), c = getchar();
return ans * f;
}
inline void add(int x, int y) { a[++tot] = (point){x, y}; }
int main() {
n = read();
int R = 1e5;
for (int i = 1; i <= n; ++i) {
int x = read(), y = read(), v = read();
if (x + v <= R)
add(x + v, y);
else
add(R, min(R, v - (R - x) + y)), add(R, max(0, y + (R - x) - v));
if (x - v >= 0)
add(x - v, y);
else
add(0, min(R, y + v - x)), add(0, max(0, y - v + x));
if (y + v <= R)
add(x, y + v);
else
add(max(0, x - v + (R - y)), R), add(min(R, x + v - (R - y)), R);
if (y - v >= 0)
add(x, y - v);
else
add(max(0, x - v + y), 0), add(min(R, x + v - y), 0);
}
sort(a + 1, a + 1 + tot);
st[++top] = a[1];
for (int i = 2; i <= tot; ++i) {
while (top > 1 &&
cross(a[i] - st[top - 1], st[top] - st[top - 1]) >= -1e-10)
top--;
st[++top] = a[i];
}
int las = top;
for (int i = tot - 1; i; --i) {
while (top > las &&
cross(a[i] - st[top - 1], st[top] - st[top - 1]) >= -1e-10)
top--;
st[++top] = a[i];
}
top--;
ans = (node){st[1], st[2], st[3]};
for (int i = 2; i <= top; ++i) {
tmp = (node){st[i], st[i % top + 1], st[(i + 1) % top + 1]};
if (ans.r() < tmp.r()) ans = tmp;
}
printf("%d %d\n", ans.a.x, ans.a.y);
printf("%d %d\n", ans.b.x, ans.b.y);
printf("%d %d\n", ans.c.x, ans.c.y);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
std::ostream& operator<<(std::ostream& os, pair<int, int> p) {
os << p.first << ", " << p.second;
return os;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n;
cin >> n;
vector<long long int> dizi(3 * n);
for (int i = 0; i < n; i++) {
cin >> dizi[i];
}
for (int i = 0; i < n; i++) {
dizi[n + i] = dizi[i];
dizi[2 * n + i] = dizi[i];
}
vector<int> bozan(3 * n);
set<pair<long long int, long long int>,
greater<pair<long long int, long long int> > >
vls;
for (int i = 0; i < 3 * n; i++) {
while (!vls.empty() && dizi[i] * 2 + 1 <= vls.begin()->first) {
bozan[vls.begin()->second] = i;
vls.erase(vls.begin());
}
vls.insert(pair<long long int, long long int>(dizi[i], i));
}
while (!vls.empty()) {
bozan[vls.begin()->second] = 1e7;
vls.erase(vls.begin());
}
int bh = 1e7;
vector<int> snc(n);
for (int i = 3 * n - 1; i >= 0; i--) {
bh = min(bh, bozan[i]);
bozan[i] = bh;
}
for (int i = 0; i < n; i++) {
if (bozan[i] == 1e7) {
snc[i] = -1;
continue;
}
snc[i] = bozan[i] - i;
}
for (int i = 0; i < n; i++) {
cout << snc[i] << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 3e5;
const long long INF = 1e9;
long long n, m;
bool ok(long long k, vector<long long> a) {
reverse(a.begin() + 1, a.end());
a[0] = INF;
for (int i = 1; i <= n; ++i) {
if (a[i] <= a[i - 1]) {
a[i] = min({a[i - 1], a[i] + k});
if (a[i] >= m) {
a[i] = m - 1;
}
} else {
if ((a[i] + k) >= m) {
a[i] = min((a[i] + k) % m, a[i - 1]);
} else {
a[i] = min((a[i] + k) % m, a[i]);
}
}
long long tmp = a[i];
if (a[i - 1] < a[i]) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
vector<long long> a(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
long long l = 0, r = m;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (ok(mid, a)) {
r = mid;
} else {
l = mid;
}
}
if (ok(l, a)) {
cout << l << '\n';
} else {
cout << r << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, x, y;
cin >> n;
int a[n];
cin >> x >> y;
int i = 0;
for (i = 0; i < n; i++) cin >> a[i];
if (x > y)
cout << n;
else {
sort(a, a + n, greater<int>());
for (i = 0; i < n; i++) {
if (a[i] <= x) break;
}
long long int y = n - i;
cout << (y + 1) / 2;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int pp[1000000], qq[1000000], used[1000000], aa[1000000], bb[1000000 + 1];
void dfs(int i, int k) {
int a, b, j;
aa[k] = i;
if (used[i]) {
if (k % 2 == 1) {
a = aa[0], b = aa[(k + 1) / 2];
for (j = 0; j < k; j++, a = pp[a], b = pp[b]) qq[a] = b;
} else {
if (bb[k] == -1)
bb[k] = i;
else {
a = aa[0], b = bb[k];
for (j = 0; j < k; j++, a = pp[a], b = pp[b]) qq[a] = b, qq[b] = pp[a];
bb[k] = -1;
}
}
return;
}
used[i] = 1;
dfs(pp[i], k + 1);
}
int main() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
int p;
scanf("%d", &p);
pp[i] = --p;
}
for (i = 0; i < n; i++) qq[i] = -1, bb[i] = -1;
for (i = 0; i < n; i++)
if (!used[i]) dfs(i, 0);
for (i = 0; i < n; i++)
if (qq[i] == -1) {
printf("-1\n");
return 0;
}
for (i = 0; i < n; i++) printf("%d ", qq[i] + 1);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int v[100005];
int v1[100005];
int main() {
int n, j, k, l, z, t, x, i, cop, a, b, cnt, sumacurr;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
char ch;
cin >> t;
int maxim = 0;
for (z = 1; z <= t; z++) {
int difer1 = 0;
int difer0 = 0;
int egal1 = 0;
int egal0 = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> ch;
v[i] = ch - '0';
}
for (i = 1; i <= n; i++) {
cin >> ch;
v1[i] = ch - '0';
}
for (i = 1; i <= n; i++) {
if (v[i] != v1[i]) {
if (v[i] == 1) {
difer1++;
} else {
difer0++;
}
} else {
if (v[i] == 1) {
egal1++;
} else {
egal0++;
}
}
}
int sol = 10e7 + 9;
if (egal1 + egal0 == n) {
sol = min(sol, 0);
}
if (difer1 == difer0) {
sol = min(sol, difer0 + difer1);
}
if (egal1 == egal0 + 1) {
sol = min(sol, egal1 + egal0);
}
if (sol == 10e7 + 9) {
cout << -1;
} else {
cout << sol;
}
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> d, s;
bool eval(int x) {
for (int i = x + 1; i < d.size(); i++)
if (d[i] != d[i - x]) return false;
return true;
}
int main() {
if (fopen("input.txt", "r")) freopen("input.txt", "r", stdin);
int n;
scanf("%d ", &n);
d.assign(n + 1, 0);
for (int i = 1; i < n + 1; i++) scanf("%d ", &d[i]);
for (int i = n; i >= 1; i--) d[i] -= d[i - 1];
for (int i = 1; i < n + 1; i++)
if (eval(i)) s.push_back(i);
printf("%d\n", s.size());
for (int i = 0; i < s.size(); i++) printf("%d ", s[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100500;
int n;
int b[N];
int pa[N], pa2[N];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
int x;
cin >> x;
pa[i] = pa[i - 1] + x;
}
for (int i = 1; i < n; i++) {
int x;
cin >> x;
pa2[i] = pa2[i - 1] + x;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int m = 1010101010, m2;
for (int i = 0; i < n; i++) {
int cur = b[i] + pa[i] + (pa2[n - 1] - pa2[i]);
if (cur < m) {
m2 = m;
m = cur;
} else if (cur < m2) {
m2 = cur;
}
}
cout << m + m2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long fast_pow(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void solve() {
int n, p, k;
cin >> n >> p >> k;
vector<int> a(n, 0);
for (auto& x : a) {
cin >> x;
}
sort(a.begin(), a.end());
int ans = 0;
int left, pre = 0;
for (int i = 0; i < k; i++) {
int cnt;
left = p - pre;
if (pre <= p) {
cnt = i;
} else {
break;
}
for (int j = i + k - 1; j < n; j += k) {
if (a[j] <= left) {
left -= a[j];
cnt += k;
} else {
break;
}
}
pre += a[i];
ans = max(cnt, ans);
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long test = 1;
cin >> test;
while (test--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int main() {
long double s, a, b, c;
cin >> s >> a >> b >> c;
if (a + b + c > 0)
cout << fixed << setprecision(10) << (s * a) / (a + b + c) << ' '
<< (s * b) / (a + b + c) << ' ' << (s * c) / (a + b + c) << endl;
else
cout << fixed << setprecision(10) << s << ' ' << 0 << ' ' << 0 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int min(int a, int b) { return a < b ? a : b; }
char s[2][100005];
int dp[2][100005];
bool gao(int n, int k) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = (1 << 30);
}
}
queue<pair<int, int> > que;
que.push(pair<int, int>(0, 0));
dp[0][0] = 0;
while (que.empty() == false) {
int i = que.front().first;
int j = que.front().second;
int t = dp[i][j];
que.pop();
if (j + 1 >= n || j + k >= n) {
return true;
}
if (s[i][j + 1] != 'X') {
if (t + 1 < dp[i][j + 1]) {
dp[i][j + 1] = t + 1;
que.push(pair<int, int>(i, j + 1));
}
}
if (j > 0 && s[i][j - 1] != 'X' && j - 1 >= t + 1) {
if (t + 1 < dp[i][j - 1]) {
dp[i][j - 1] = t + 1;
que.push(pair<int, int>(i, j - 1));
}
}
if (s[1 - i][j + k] != 'X') {
if (t + 1 < dp[1 - i][j + k]) {
dp[1 - i][j + k] = t + 1;
que.push(pair<int, int>(1 - i, j + k));
}
}
}
return false;
}
int main() {
int n, k;
while (scanf("%d %d", &n, &k) != EOF) {
scanf("%s", s[0]);
scanf("%s", s[1]);
bool ans = gao(n, k);
puts(ans ? "YES" : "NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dis(pair<int, int>& a, pair<int, int>& b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
int main() {
vector<pair<int, int> > v(3);
for (int i = 0; i < 3; i++) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
set<pair<int, int> > p;
for (int i = v[0].first; i <= v[1].first; i++)
p.insert(make_pair(i, v[0].second));
for (int i = v[2].first; i >= v[1].first; i--)
p.insert(make_pair(i, v[2].second));
int minn = min(v[0].second, min(v[1].second, v[2].second));
int maxn = max(v[0].second, max(v[1].second, v[2].second));
for (int j = minn; j <= maxn; j++) p.insert(make_pair(v[1].first, j));
cout << p.size() << endl;
for (auto it : p) cout << it.first << " " << it.second << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vii = vector<vi>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using int64 = long long;
const int inf = 2e9 + 7;
const char nwl = '\n';
int count(int n) {
int s = 0;
while (n) s++, n /= 10;
return s;
}
int minValue(int t) {
int k = 0;
while (t--) k = k * 10 + 4;
return k;
}
bool check(int n) {
while (n) {
int k = n % 10;
n /= 10;
if (k == 7 or k == 4) continue;
return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int x = count(n);
int t = minValue(x);
int ans = (1 << x) - 2;
for (; t <= n; t++) {
if (check(t)) ans++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
vector<int> tree[maxn];
vector<int> ice[maxn];
bool vis[maxn];
int col[maxn];
void dfs(int node) {
vis[node] = 1;
int s = 1;
map<int, int> q;
for (auto idx : ice[node]) {
if (col[idx]) q.insert(make_pair(col[idx], 1));
}
for (auto idx : ice[node]) {
while (q[s]) s++;
if (!col[idx]) col[idx] = s++;
}
for (auto idx : tree[node]) {
if (!vis[idx]) dfs(idx);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int t;
cin >> t;
ice[i].resize(t);
for (auto &idx : ice[i]) cin >> idx;
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
tree[a].push_back(b);
tree[b].push_back(a);
}
dfs(1);
for (int i = 1; i <= m; i++)
if (!col[i]) col[i] = 1;
set<int> t;
for (int i = 1; i <= m; i++) t.insert(col[i]);
cout << t.size() << endl;
for (int i = 1; i <= m; i++) cout << col[i] << ' ';
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 5, blSize = 1000, blNum = 100;
int N, arr[maxN];
int block[blNum][maxN];
int s[blNum], e[blNum];
int blockAns[blNum];
int temp[maxN];
int tempAns;
int rep[maxN];
void tempAdd(int x, int val) {
tempAns -= temp[x] > 0;
temp[x] += val;
tempAns += temp[x] > 0;
}
void solve(int k) {
int e = 0;
for (int i = (int)1; i <= (int)N; i++) {
tempAdd(arr[i], 1);
tempAdd(arr[i + 1], 1);
if (tempAns > k or i == N) {
for (int j = (int)i; j >= (int)e + 1; j--) tempAdd(arr[j], -1);
e = i;
rep[k]++;
}
tempAdd(arr[i + 1], -1);
}
}
void blockAdd(int bl, int x, int val) {
blockAns[bl] -= block[bl][x] > 0;
block[bl][x] += val;
blockAns[bl] += block[bl][x] > 0;
}
void solve2(int k) {
for (int bl = (int)0; bl <= (int)blNum - 1; bl++) {
if (s[bl] > N) break;
if (bl) {
while (s[bl] <= e[bl - 1] and s[bl] <= N) blockAdd(bl, arr[s[bl]++], -1);
while (e[bl] < s[bl] and e[bl] <= N) blockAdd(bl, arr[++e[bl]], 1);
}
while (e[bl] < N) {
blockAdd(bl, arr[e[bl] + 1], 1);
if (blockAns[bl] <= k)
e[bl]++;
else {
blockAdd(bl, arr[e[bl] + 1], -1);
break;
}
}
if (e[bl] == N) rep[k] = bl + 1;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> N;
for (int i = (int)1; i <= (int)N; i++) cin >> arr[i];
for (int k = (int)1; k <= (int)N; k++) {
if (k <= blSize)
solve(k);
else
solve2(k);
cout << rep[k] << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dp[51][51][51][51] = {};
int main() {
int N;
cin >> N;
vector<vector<char>> F(N + 1, vector<char>(N + 1, 0));
vector<vector<int>> S(N + 1, vector<int>(N + 1, 0));
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) {
cin >> F[i][j];
S[i][j] = (F[i][j] == '#');
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) S[i][j] += S[i][j - 1];
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) S[i][j] += S[i - 1][j];
auto getsum = [&](int x1, int y1, int x2, int y2) {
return S[x2][y2] - S[x1 - 1][y2] - S[x2][y1 - 1] + S[x1 - 1][y1 - 1];
};
int inf = 1e9;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
for (int k = 1; k <= N; k++)
for (int l = 1; l <= N; l++) dp[i][j][k][l] = inf;
function<int(int, int, int, int)> rec = [&](int x1, int y1, int x2, int y2) {
if (x2 < x1 || y2 < y1) return 0;
if (getsum(x1, y1, x2, y2) == 0) return dp[x1][y1][x2][y2] = 0;
if (dp[x1][y1][x2][y2] != inf) return dp[x1][y1][x2][y2];
int dx = x2 - x1 + 1, dy = y2 - y1 + 1;
int res = max(dx, dy);
for (int i = x1; i <= x2; i++) {
if (getsum(i, y1, i, y2) == 0)
res = min(res, rec(x1, y1, i - 1, y2) + rec(i + 1, y1, x2, y2));
}
for (int j = y1; j <= y2; j++) {
if (getsum(x1, j, x2, j) == 0)
res = min(res, rec(x1, y1, x2, j - 1) + rec(x1, j + 1, x2, y2));
}
return dp[x1][y1][x2][y2] = res;
};
cout << rec(1, 1, N, N) << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
const double eps = 1e-10;
template <typename A, typename B>
inline void chmin(A &a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A &a, B b) {
if (a < b) a = b;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ll a[1000010] = {};
for (int i = 0; i < (n); i++) {
cin >> a[i];
}
ll al = a[0];
for (int i = 0; i < (n); i++) {
al = gcd(al, a[i]);
}
if (al != a[0]) {
cout << -1 << endl;
return 0;
}
cout << 2 * n << endl;
for (int i = 0; i < (n); i++) {
cout << a[i] << " " << a[0] << " ";
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
int a[200005];
int c[200005][2][2];
int f[200005][2][2];
char ch;
void inp() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf(" %c", &ch);
if (ch == 'L')
a[i] = 0;
else
a[i] = 1;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) c[i][j][k] = false;
}
}
}
void init() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) c[i][j][k] = false;
}
}
}
int tryy(int i, int m, int r) {
if (i == n - 1) {
if (r != a[0]) return n;
int cnt = 0;
if (m == 1) cnt++;
if (a[1] == 0) cnt++;
if (cnt == 2 || cnt == 0) return 0;
if (a[0] == 1 && a[1] == 0) return 0;
if (m == 1 && a[0] == 0) return 0;
return n;
}
if (c[i][m][r]) return f[i][m][r];
int tmp = n;
if (m == 0) {
if (r == 0) {
tmp = min(tmp, tryy(i + 1, r, 1) + 1 - a[(i + 2) % n]);
} else if (r == 1) {
tmp = min(tmp, tryy(i + 1, r, 1) + 1 - a[(i + 2) % n]);
tmp = min(tmp, tryy(i + 1, r, 0) + (0 != a[(i + 2) % n]));
}
} else if (m == 1) {
if (r == 0) {
tmp = min(tmp, tryy(i + 1, r, 1) + 1 - a[(i + 2) % n]);
tmp = min(tmp, tryy(i + 1, r, 0) + (0 != a[(i + 2) % n]));
} else if (r == 1) {
tmp = min(tmp, tryy(i + 1, r, 0) + (0 != a[(i + 2) % n]));
}
}
c[i][m][r] = true;
f[i][m][r] = tmp;
return tmp;
}
void proc() {
a[0] = a[0];
int ans = tryy(0, a[0], a[1]);
init();
a[1] = 1 - a[1];
ans = min(ans, tryy(0, a[0], a[1]) + 1);
a[0] = 1 - a[0];
init();
a[1] = 1 - a[1];
ans = min(ans, tryy(0, a[0], a[1]) + 1);
init();
a[1] = 1 - a[1];
ans = min(ans, tryy(0, a[0], a[1]) + 2);
printf("%d\n", ans);
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d", &t);
while (t--) {
inp();
proc();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, m, xc, yc, k;
scanf("%d %d %d %d %d", &n, &m, &xc, &yc, &k);
unsigned long long res = 0;
for (int i = 0; i < k; i++) {
int dx, dy;
scanf("%d %d", &dx, &dy);
int xstep = -1;
if (dx > 0)
xstep = (n - xc) / dx;
else if (dx < 0)
xstep = (xc - 1) / abs(dx);
int ystep = -1;
if (dy > 0)
ystep = (m - yc) / dy;
else if (dy < 0)
ystep = (yc - 1) / abs(dy);
int steps = 0;
if (xstep == -1)
steps = ystep;
else if (ystep == -1)
steps = xstep;
else
steps = std::min<int>(xstep, ystep);
res += steps;
xc += steps * dx;
yc += steps * dy;
}
std::cout << res << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[222222];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int kt = 1, cn = n;
long long ps = 0;
for (int i = 1; i < n; i++) {
if (ps - 1LL * kt * (cn - kt - 1) * a[i] < k) {
cn--;
cout << i + 1 << "\n";
} else {
ps += 1LL * kt * a[i];
kt++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
vector<string> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
long long dp[n][2];
for (long long i = 0; i < n; i++) {
dp[i][0] = 1000000000000000000;
dp[i][1] = 1000000000000000000;
}
dp[0][0] = 0;
dp[0][1] = a[0];
string h = v[0];
reverse(h.begin(), h.end());
for (long long i = 1; i < n; i++) {
string f = v[i];
reverse(f.begin(), f.end());
if (v[i - 1] <= v[i]) {
dp[i][0] = min(dp[i][0], dp[i - 1][0]);
}
if (h <= v[i]) {
dp[i][0] = min(dp[i][0], dp[i - 1][1]);
}
if (v[i - 1] <= f) {
dp[i][1] = min(dp[i][1], dp[i - 1][0] + a[i]);
}
if (h <= f) {
dp[i][1] = min(dp[i][1], a[i] + dp[i - 1][1]);
}
if (dp[i][0] == 1000000000000000000 && dp[i][1] == 1000000000000000000) {
cout << "-1";
return 0;
}
h = f;
}
if (dp[n - 1][0] == 1000000000000000000 &&
dp[n - 1][1] == 1000000000000000000) {
cout << "-1";
return 0;
}
cout << min(dp[n - 1][0], dp[n - 1][1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long fact(long long n, long long m) {
return n == 0 ? 1 : ((n % m) * (fact(n - 1, m) % m)) % m;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
long long r = 0, k = 0;
long long t = n * fact(n, m);
t %= m;
vector<long long> inv(n + 1);
inv[1] = 1;
for (long long i = 2; i <= n; i++) {
inv[i] = (m - (m / i) * inv[m % i] % m) % m;
}
r = t;
for (k = 1; k < n; k++) {
t *= (((((k + 1) % m) * inv[n - k + 1]) % m) *
((inv[n - k + 1] * ((n - k) % m)) % m)) %
m;
t %= m;
r += t;
r %= m;
}
cout << r << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modinv(long long int k) { return power(k, MOD - 2, MOD); }
long long int fact(long long int n);
long long int nCr(long long int n, long long int k) {
long long int C[n + 1][k + 1];
long long int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]);
}
}
return C[n][k];
}
long long int fact(long long int n) {
long long int res = 1;
for (long long int i = 2; i <= n; i++) res = res * i;
return res;
}
map<char, set<char>> adj;
map<char, bool> vis;
int cnt;
void dfs(char c) {
vis[c] = true;
cnt++;
for (auto i : adj[c]) {
if (!vis[i]) {
dfs(i);
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string a, b;
cin >> a >> b;
set<char> s;
int fl = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i])
continue;
else if (a[i] > b[i]) {
fl = 1;
break;
} else {
s.insert(a[i]);
adj[a[i]].insert(b[i]);
adj[b[i]].insert(a[i]);
}
}
if (fl) {
cout << -1 << "\n";
continue;
}
int ans = 0;
for (auto i : s) {
if (!vis[i]) {
cnt = 0;
dfs(i);
ans += cnt - 1;
}
}
cout << ans << "\n";
adj.clear();
vis.clear();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[111][111], can[111], qnt[111], n, m;
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &a[i][j]);
}
}
for (int i = 0; i < m; i++) {
int max_ = -1;
for (int j = 0; j < n; j++) {
if (a[i][j] > max_) {
max_ = a[i][j];
can[i] = j;
}
}
}
memset(qnt, 0, sizeof(qnt));
for (int i = 0; i < m; i++) {
qnt[can[i]]++;
}
int max_ = -1, resp = -1;
for (int i = 0; i < n; i++) {
if (qnt[i] > max_) {
max_ = qnt[i];
resp = i;
}
}
printf("%d\n", resp + 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void solve() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; ++i) cin >> arr[i];
int mx = *max_element(arr.begin(), arr.end());
int mxcnt = count(arr.begin(), arr.end(), mx);
vector<int> adj[n + 1];
int u, v;
for (int i = 0; i < n - 1; ++i) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
if (mxcnt == 1) {
for (int i = 0; i < n; ++i)
if (arr[i] == mx) {
u = i;
break;
}
int res = mx;
arr[u] = -(int)1000000007;
for (auto x : adj[u + 1]) {
res = max(res, arr[x - 1] + 1);
arr[x - 1] = -(int)1000000007;
}
for (int i = 0; i < n; ++i) res = max(res, arr[i] + 2);
cout << res << endl;
} else {
for (int i = 1; i < n + 1; ++i) {
int cnt = (arr[i - 1] == mx);
for (auto x : adj[i])
if (arr[x - 1] == mx) cnt++;
if (cnt == mxcnt) {
cout << mx + 1 << endl;
return;
}
}
cout << mx + 2 << endl;
}
return;
}
int main() {
boost();
int tc = 1;
while (tc--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans[1000001];
int n, k;
int main() {
scanf("%d%d", &n, &k);
if ((k * 3 > n) || (k == 1))
cout << -1 << endl;
else {
for (int i = 1; i <= k * 2; i++) ans[i] = (i + 1) / 2;
for (int i = k * 2 + 1; i <= k * 3; i++) ans[i] = i - k * 2;
for (int i = k * 3 + 1; i <= n; i++) ans[i] = 1;
for (int i = 1; i < n; i++) printf("%d ", ans[i]);
cout << ans[n] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000 + 100;
const long long mod = 998244353;
long long f[maxn];
long long pow(long long a, long long b) {
if (b == 0) return 1;
long long ret = pow(a, b / 2);
if (b % 2) return (ret * ret) % mod * a % mod;
return ret * ret % mod;
}
long long CC(long long n, long long k) {
return 1ll * f[n] * pow(f[n - k], mod - 2) % mod;
}
int main() {
f[1] = 1ll;
for (int i = 2; i < maxn - 10; i++) f[i] = (1ll * f[i - 1] * i) % mod;
long long n;
cin >> n;
long long ans = f[n];
for (int i = 1; i <= n - 2; i++)
ans = 1ll * (ans + 1ll * (f[n - i] - 1) * CC(n, i) % mod) % mod;
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1024;
long long tree[2][2][MAXN][MAXN];
void update(int x, int y, long long v) {
bool xp = x & 1, yp = y & 1;
for (int i = x; i < MAXN; i += (i & -i)) {
for (int j = y; j < MAXN; j += (j & -j)) {
tree[xp][yp][i][j] ^= v;
}
}
}
long long query(int x, int y) {
long long res = 0;
bool xp = x & 1, yp = y & 1;
for (int i = x; i; i &= i - 1) {
for (int j = y; j; j &= j - 1) {
res ^= tree[xp][yp][i][j];
}
}
return res;
}
int main() {
int m, q, x0, y0, x1, y1;
cin >> m >> m;
while (m--) {
cin >> q >> x0 >> y0 >> x1 >> y1;
if (q == 1) {
cout << (query(x1, y1) ^ query(x0 - 1, y1) ^ query(x1, y0 - 1) ^
query(x0 - 1, y0 - 1))
<< '\n';
} else {
long long v;
cin >> v;
update(x0, y0, v);
update(x0, y1 + 1, v);
update(x1 + 1, y0, v);
update(x1 + 1, y1 + 1, v);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k;
vector<string> arr;
vector<pair<long long int, long long int> > v[55 * 55];
long long int visited[55][55];
string s;
multiset<pair<long long int, long long int> > m1;
multiset<long long int> m2;
long long int dfs(long long int i, long long int j, char x, char y) {
visited[i][j] = 1;
arr[i][j] = x;
if (j + 1 < m && arr[i][j + 1] == y && !visited[i][j + 1]) {
dfs(i, j + 1, x, y);
m1.insert(make_pair(i, j + 1));
}
if (j - 1 >= 0 && arr[i][j - 1] == y && !visited[i][j - 1]) {
dfs(i, j - 1, x, y);
m1.insert(make_pair(i, j - 1));
}
if (i + 1 < n && arr[i + 1][j] == y && !visited[i + 1][j]) {
dfs(i + 1, j, x, y);
m1.insert(make_pair(i + 1, j));
}
if (i - 1 >= 0 && arr[i - 1][j] == y && !visited[i - 1][j]) {
dfs(i - 1, j, x, y);
m1.insert(make_pair(i - 1, j));
}
}
long long int dfs2(long long int i, long long int j) {
visited[i][j] = 1;
if (j + 1 < m && arr[i][j + 1] == '.' && !visited[i][j + 1]) {
dfs2(i, j + 1);
m1.insert(make_pair(i, j + 1));
}
if (j - 1 >= 0 && arr[i][j - 1] == '.' && !visited[i][j - 1]) {
dfs2(i, j - 1);
m1.insert(make_pair(i, j - 1));
}
if (i + 1 < n && arr[i + 1][j] == '.' && !visited[i + 1][j]) {
dfs2(i + 1, j);
m1.insert(make_pair(i + 1, j));
}
if (i - 1 >= 0 && arr[i - 1][j] == '.' && !visited[i - 1][j]) {
dfs2(i - 1, j);
m1.insert(make_pair(i - 1, j));
}
}
int main() {
scanf("%lld", &n);
scanf("%lld", &m);
scanf("%lld", &k);
for (long long int i = 0; i < n; i++) {
cin >> s;
arr.push_back(s);
}
for (long long int i = 0; i < n; i++) {
m1.clear();
if (!visited[i][0] && arr[i][0] == '.') {
m1.insert(make_pair(i, 0));
dfs(i, 0, '+', '.');
}
}
for (long long int i = 0; i < n; i++) {
m1.clear();
if (!visited[i][m - 1] && arr[i][m - 1] == '.') {
m1.insert(make_pair(i, m - 1));
dfs(i, m - 1, '+', '.');
}
}
for (long long int j = 1; j < m - 1; j++) {
m1.clear();
if (!visited[0][j] && arr[0][j] == '.') {
m1.insert(make_pair(0, j));
dfs(0, j, '+', '.');
}
}
for (long long int j = 1; j < m - 1; j++) {
m1.clear();
if (!visited[n - 1][j] && arr[n - 1][j] == '.') {
m1.insert(make_pair(n - 1, j));
dfs(n - 1, j, '+', '.');
}
}
memset(visited, 0, sizeof(visited));
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
m1.clear();
if (!visited[i][j] && arr[i][j] == '.') {
m1.insert(make_pair(i, j));
dfs2(i, j);
}
if (m1.size()) {
m2.insert(m1.size());
v[m1.size()].push_back(make_pair(i, j));
}
}
}
long long int ans = 0;
long long int y = 0;
memset(visited, 0, sizeof(visited));
for (auto it = m2.begin(); it != m2.end(); it++) {
long long int t = m2.size() - y;
if (t == k) break;
ans += *it;
auto it1 = v[*it].begin();
dfs(it1->first, it1->second, '*', '.');
v[*it].erase(it1);
y++;
}
cout << ans << endl;
memset(visited, 0, sizeof(visited));
for (long long int i = 0; i < n; i++) {
m1.clear();
if (!visited[i][0] && arr[i][0] == '+') {
m1.insert(make_pair(i, 0));
dfs(i, 0, '.', '+');
}
}
for (long long int i = 0; i < n; i++) {
m1.clear();
if (!visited[i][m - 1] && arr[i][m - 1] == '+') {
m1.insert(make_pair(i, m - 1));
dfs(i, m - 1, '.', '+');
}
}
for (long long int j = 1; j < m - 1; j++) {
m1.clear();
if (!visited[0][j] && arr[0][j] == '+') {
m1.insert(make_pair(0, j));
dfs(0, j, '.', '+');
}
}
for (long long int j = 1; j < m - 1; j++) {
m1.clear();
if (!visited[n - 1][j] && arr[n - 1][j] == '+') {
m1.insert(make_pair(n - 1, j));
dfs(n - 1, j, '.', '+');
}
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
cout << arr[i][j];
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const double PI = 3.14159265358979323846264338;
vector<long long int> no;
vector<vector<vector<long long int>>> dp(
12, vector<vector<long long int>>(12, vector<long long int>(2, -1)));
long long int fun(long long int ind, long long int req, bool less) {
if (ind >= (long long int)(no.size())) {
if (req == 0) {
return 1;
} else {
return 0;
}
}
if (req < 0) {
return 0;
}
if (dp[ind][req][less] != -1) {
return dp[ind][req][less];
}
long long int higher;
if (less == 1) {
higher = 9;
} else {
higher = no[ind];
}
long long int val = 0;
for (long long int i = 0; i <= higher; i++) {
bool check_current = (i < no[ind]);
bool new_less = (less | check_current);
if (i == 4 || i == 7) {
val += fun(ind + 1, req - 1, new_less);
val %= MOD;
} else {
val += fun(ind + 1, req, new_less);
val %= MOD;
}
}
dp[ind][req][less] = val;
return dp[ind][req][less];
}
void solve() {
long long int m;
cin >> m;
long long int tmp = m;
while (tmp > 0) {
no.push_back(tmp % 10);
tmp /= 10;
}
reverse(no.begin(), no.end());
for (long long int i = 1; i <= (long long int)(no.size()); i++) {
fun(0, i, 0);
}
map<long long int, long long int> mp;
long long int tot = 0;
for (long long int i = 1; i <= 9; i++) {
if (dp[0][i][0] < 0) {
dp[0][i][0] = 0;
}
mp[i] = dp[0][i][0];
tot += dp[0][i][0];
}
mp[0] = m - tot;
long long int ans = 0;
for (long long int i = 1; i <= 9; i++) {
vector<long long int> tmp;
tmp.push_back(mp[i]);
mp[i]--;
for (long long int a = 0; a <= 9; a++) {
tmp.push_back(mp[a]);
mp[a]--;
for (long long int b = 0; b < i; b++) {
tmp.push_back(mp[b]);
mp[b]--;
for (long long int c = 0; c < i; c++) {
tmp.push_back(mp[c]);
mp[c]--;
for (long long int d = 0; d < i; d++) {
tmp.push_back(mp[d]);
mp[d]--;
for (long long int e = 0; e < i; e++) {
tmp.push_back(mp[e]);
mp[e]--;
for (long long int f = 0; f < i; f++) {
tmp.push_back(mp[f]);
mp[f]--;
long long int calc = a + b + c + d + e + f;
if (i > calc) {
long long int no = 1;
for (long long int j = 0; j < (long long int)(tmp.size());
j++) {
no *= tmp[j];
no %= MOD;
}
ans += no;
ans %= MOD;
}
tmp.pop_back();
mp[f]++;
}
tmp.pop_back();
mp[e]++;
}
tmp.pop_back();
mp[d]++;
}
tmp.pop_back();
mp[c]++;
}
tmp.pop_back();
mp[b]++;
}
tmp.pop_back();
mp[a]++;
}
tmp.pop_back();
mp[i]++;
}
cout << ans << "\n";
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.