solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, angka, ans;
int i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> angka;
ans = angka / 2;
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 1e5 + 7;
int n;
long long ans;
int f[maxm];
long long s[maxm];
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &f[i]);
for (int i = 1; i <= n; i++) {
scanf("%lld", &s[i]);
if (s[i] == -1) s[i] = 2147483647;
}
for (int i = 2; i <= n; i++) s[f[i]] = min(s[i], s[f[i]]);
for (int i = 1; i <= n; i++) {
if (s[i] < s[f[i]]) {
printf("-1\n");
return 0;
}
if (s[i] < 2147483647) ans += s[i] - s[f[i]];
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int abs(int x) { return (x > 0 ? x : -x); }
int main() {
ios::sync_with_stdio(false);
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 != x2 && y1 != y2 && abs(x1 - x2) != abs(y1 - y2))
cout << -1 << endl;
else if (x1 == x2)
cout << x1 + abs(y1 - y2) << " " << y1 << " " << x2 + abs(y1 - y2) << " "
<< y2 << endl;
else if (y1 == y2)
cout << x1 << " " << y1 + abs(x1 - x2) << " " << x2 << " "
<< y2 + abs(x1 - x2) << endl;
else
cout << x1 << " " << y2 << " " << x2 << " " << y1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long po(long long n, long long exp) {
long long prod = 1;
for (long long i = 0; i < exp; i++) prod = (prod * n);
return prod;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
signed main() {
ios_base::sync_with_stdio(false);
long long TESTS = 1;
while (TESTS--) {
long long c1, c2, c3, c4;
cin >> c1 >> c2 >> c3 >> c4;
long long n, m;
cin >> n >> m;
long long a[n], b[m];
long long sum1 = 0, sum2 = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum1 += a[i];
}
for (long long i = 0; i < m; i++) {
cin >> b[i];
sum2 += b[i];
}
long long cost1 = c1 * (sum1), cost2 = c1 * (sum2);
for (long long i = 0; i < n; i++) {
if (a[i] * c1 > c2) {
cost1 -= a[i] * c1 - c2;
}
}
for (long long i = 0; i < m; i++) {
if (b[i] * c1 > c2) {
cost2 -= b[i] * c1 - c2;
}
}
if (cost1 > c3) cost1 = c3;
if (cost2 > c3) cost2 = c3;
long long cost = cost1 + cost2;
if (cost > c4) cost = c4;
cout << cost;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5;
const long long hash_mod = 167;
long long rd() {
long long _;
scanf("%lld", &_);
return _;
}
long long n, m, k, ans;
unsigned long long a[10][10], hash_val[maxn], hash_sum;
vector<pair<long long, long long> > edge[maxn];
void dfs(long long i) {
if (i > k) {
ans += !hash_sum;
return;
}
for (long long j = 1; j <= i; j++) {
hash_sum -= a[i][j];
dfs(i + 1);
hash_sum += a[i][j];
}
}
int main() {
n = rd(), m = rd(), k = rd();
hash_val[0] = 1;
for (long long i = 1; i <= n; i++)
hash_val[i] = hash_val[i - 1] * hash_mod, hash_sum += hash_val[i];
for (long long i = 0; i < m; i++) {
long long u = rd(), v = rd(), w = rd();
edge[u].push_back({w, v});
}
for (long long u = 1; u <= n; u++) {
if (edge[u].empty()) return printf("0\n"), 0;
sort(edge[u].begin(), edge[u].end());
for (long long j = 0; j < edge[u].size(); j++)
a[edge[u].size()][j + 1] += hash_val[edge[u][j].second];
}
dfs(1);
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, s, k, f[55][2010], r[55], ans = INF;
bool usd[55][2010];
char col[55];
int dfs(int u, int v, int w) {
if (v <= 0) {
return 0;
}
if (usd[u][v]) {
return f[u][v];
}
int rep = INF;
for (int i = 1; i <= n; i++) {
if (col[i] != col[u] && r[i] > w) {
rep = min(rep, abs(u - i) + dfs(i, v - r[i], r[i]));
}
}
usd[u][v] = true;
return f[u][v] = rep;
}
int main() {
scanf("%d%d%d", &n, &s, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &r[i]);
}
scanf("%s", col + 1);
memset(f, 0x3f, sizeof f);
for (int i = 1; i <= n; i++) {
ans = min(ans, abs(i - s) + dfs(i, k - r[i], r[i]));
}
if (ans == INF) {
printf("-1\n");
} else {
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[8], pro[1 << 8];
int bit_cnt[1 << 8];
vector<long long> pp;
bitset<1000000> p;
map<long long, int> H;
int N, an;
int qq(long long x) {
if (H.count(x)) return H[x];
long long X = x;
int res = 0;
for (int i = 0; i < ((int)(pp).size()) && pp[i] * pp[i] <= x; i++) {
while (x % pp[i] == 0) {
x /= pp[i];
res++;
}
}
if (x != 1) res++;
return H[X] = res;
}
int qq2(long long x) {
if (H.count(x)) {
int tmp = H[x];
if (tmp == 1) return 0;
return tmp;
}
long long X = x;
int res = 0;
for (int i = 0; i < ((int)(pp).size()) && pp[i] * pp[i] <= x; i++) {
while (x % pp[i] == 0) {
x /= pp[i];
res++;
}
}
if (x != 1) res++;
H[X] = res;
if (res == 1) return 0;
return res;
}
void dfs(int x, int mask, int v, int head) {
if (x == -1) {
if (head == 1)
an = min(an, v);
else
an = min(an, v + 1);
return;
}
if (!((mask >> x) & 1)) {
v++;
head++;
}
for (int i = 0; i < (1 << x); ++i) {
if (!i) {
dfs(x - 1, mask, v + qq2(a[x]), head);
} else if (!(mask & i) && a[x] % pro[i] == 0) {
dfs(x - 1, mask | i, v + bit_cnt[i] + qq(a[x] / pro[i]), head);
}
}
}
int main() {
for (int i = 3; i < 1000; i += 2) {
for (int j = i * i; j < 1000000; j += i + i) p[j] = 1;
}
pp.push_back(2);
for (int i = 3; i < 1000000; i += 2) {
if (!p[i]) pp.push_back(i);
}
int(n);
scanf("%d", &n);
N = n;
for (int i = 0; i < (n); ++i) cin >> a[i];
sort(a, a + n);
pro[0] = 1;
for (int i = (1); i < (1 << n); ++i) {
int k = 0;
while (!((i >> k) & 1)) k++;
bit_cnt[i] = bit_cnt[i - (1 << k)] + 1;
long long tmp1 = pro[i - (1 << k)];
long long tmp2 = a[k];
if (tmp1 > 10000000000000ll / tmp2)
pro[i] = 10000000000000ll;
else
pro[i] = tmp1 * tmp2;
}
an = 1000000;
dfs(n - 1, 0, 0, 0);
printf("%d\n", an);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
long long freqs[27], freqt[27], ein;
int check(long long k) {
long long cnt = 0;
for (int i = 0; i < 26; i++) {
long long dif = freqt[i] * k - freqs[i];
cnt += max(0LL, dif);
}
return cnt <= ein;
}
int leftmost(int left = 1, int right = 1000007) {
if (left == right) return left;
int mid = (left + right) / 2;
if (check(mid) > 0)
return leftmost(mid + 1, right);
else
return leftmost(left, mid);
}
int main() {
cin >> s >> t;
ein = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '?')
ein++;
else
freqs[s[i] - 'a']++;
}
for (int i = 0; i < t.size(); i++) freqt[t[i] - 'a']++;
int ans = leftmost() - 1;
if (ein == 0) {
cout << s << endl;
return 0;
}
for (int i = 0; i < 26; i++) freqt[i] = max(freqt[i] * ans - freqs[i], 0LL);
int letter = 0;
for (int i = 0; i < s.size(); i++) {
while (letter < 25 && !freqt[letter]) letter++;
if (s[i] == '?') {
s[i] = (letter + 'a');
freqt[letter]--;
}
}
cout << s << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x, y, a, b;
int ans = 0;
int main() {
cin >> x >> y >> a >> b;
if (x <= b) {
cout << 0 << '\n';
return 0;
}
while (a <= b) a++;
for (int i = a; i <= x; i++)
for (int j = b; j < i && j <= y; j++) ans++;
cout << ans << '\n';
for (int i = a; i <= x; i++)
for (int j = b; j < i && j <= y; j++) cout << i << " " << j << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void sc(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
long long power(long long a, long long b, long long m) {
long long res = 1;
while (b > 0) {
if (b % 2 != 0) res = (res * a) % m;
a = (a * a) % m;
b /= 2;
}
return res % m;
}
long long gcd(long long a, long long b) {
return ((b == 0) ? a : gcd(b, a % b));
}
int main() {
int n, q, i, j;
int arr[102];
memset(arr, 0, sizeof(arr));
long long sum;
int ans, rem;
int t[100001], d[100001], k[100001];
long long a[100001];
sc(n), sc(q);
for (i = 1; i < q + 1; i++) sc(t[i]), sc(k[i]), sc(d[i]);
for (i = 1; i < q + 1; i++) {
sum = 0;
ans = 0;
rem = 0;
for (j = 1; j < n + 1; j++) {
if (arr[j] != 0) {
if (t[i] > arr[j])
arr[j] = 0;
else
rem++;
}
}
if (n - rem < k[i]) {
a[i] = -1;
continue;
}
for (j = 1; j < n + 1; j++) {
if (arr[j] == 0) {
ans++;
sum += j;
arr[j] = t[i] + d[i] - 1;
}
if (ans == k[i]) {
a[i] = sum;
break;
}
}
}
for (i = 1; i < q + 1; i++) cout << a[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define MAXN 200 + 10
#define BASE 1000000007
int n;
int Dp[MAXN][MAXN];
vector<int> neighbors[MAXN];
int pa[MAXN][10], in[MAXN], out[MAXN], level[MAXN];
int countIn, countOut;
int getPow(int x, int y) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = ((long long)res * x) % BASE;
}
x = ((long long)x * x) % BASE;
y >>= 1;
}
return res;
}
int getParent(int child, int level) {
if (child == -1) return -1;
return pa[child][level];
}
void init(int pos, int parent) {
in[pos] = ++countIn;
if (parent == -1) level[pos] = 1;
else level[pos] = level[parent] + 1;
pa[pos][0] = parent;
for (int i = 1; i < 10; i++) {
pa[pos][i] = getParent(pa[pos][i - 1], i - 1);
}
for (int i = 0; i < neighbors[pos].size(); i++) {
if (neighbors[pos][i] != parent) {
init(neighbors[pos][i], pos);
}
}
out[pos] = ++countOut;
}
int getLCA(int a, int b) {
if (in[a] <= in[b] && out[a] >= out[b]) return a;
if (in[b] <= in[a] && out[b] >= out[a]) return b;
for (int i = 9; i >= 0; i--) {
int pa = getParent(a, i);
if ((pa == -1) || (in[pa] <= in[b] && out[pa] >= out[b])) continue;
a = pa;
}
return getParent(a, 0);
}
int DpCalc(int x, int y) {
if (x == 0) return 1;
if (y == 0) return 0;
if (Dp[x][y] > -1) return Dp[x][y];
int res = 0;
res = ((long long)res + (long long)DpCalc(x - 1, y) * getPow(2, BASE - 2)) % BASE;
res = ((long long)res + (long long)DpCalc(x, y - 1) * getPow(2, BASE - 2)) % BASE;
Dp[x][y] = res;
return res;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
neighbors[x - 1].push_back(y - 1);
neighbors[y - 1].push_back(x - 1);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Dp[i][j] = -1;
}
}
int res = 0;
for (int i = 0; i < n; i++) {
countIn = countOut = 0;
init(i, -1);
for (int a = 0; a < n; a++) {
for (int b = 0; b < a; b++) {
int c = getLCA(a, b);
res = ((long long)res + (long long)DpCalc(level[a] - level[c], level[b] - level[c]) * getPow(n, BASE - 2)) % BASE;
}
}
}
cout << res << endl;
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 300000;
const int Q_MAX = 300000;
const int BITS = 19;
int n, q, k;
int a[N_MAX + 2];
int lg2[N_MAX + 2];
int rm[N_MAX + 2][BITS];
int rmq(int l, int r) {
if (l > r) return 0;
int bit = lg2[r - l + 1];
return min(rm[l][bit], rm[r - (1 << bit) + 1][bit]);
}
struct SGTNode {
long long sum;
int lazy;
};
SGTNode operator+(const SGTNode &u, const SGTNode &v) {
return SGTNode{u.sum + v.sum, 0};
}
SGTNode SGT[N_MAX * 4 + 2];
void build(int node, int l, int r) {
if (l == r) {
SGT[node].sum = 0;
SGT[node].lazy = 0;
return;
}
int mid = (l + r) / 2;
int lSon = node * 2, rSon = node * 2 + 1;
build(lSon, l, mid);
build(rSon, mid + 1, r);
SGT[node] = SGT[lSon] + SGT[rSon];
}
void split(int node, int l, int r) {
if (SGT[node].lazy == 0) return;
int mid = (l + r) / 2;
int lSon = node * 2, rSon = node * 2 + 1;
SGT[lSon].sum = (long long)(mid - l + 1) * SGT[node].lazy;
SGT[lSon].lazy = SGT[node].lazy;
SGT[rSon].sum = (long long)(r - mid) * SGT[node].lazy;
SGT[rSon].lazy = SGT[node].lazy;
SGT[node].lazy = 0;
}
void update(int node, int l, int r, int ul, int ur, int uval) {
if (ul <= l && r <= ur) {
SGT[node].sum = (long long)(r - l + 1) * uval;
SGT[node].lazy = uval;
return;
}
split(node, l, r);
int mid = (l + r) / 2;
int lSon = node * 2, rSon = node * 2 + 1;
if (ul <= mid) update(lSon, l, mid, ul, ur, uval);
if (mid + 1 <= ur) update(rSon, mid + 1, r, ul, ur, uval);
SGT[node] = SGT[lSon] + SGT[rSon];
}
long long query(int node, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return SGT[node].sum;
split(node, l, r);
int mid = (l + r) / 2;
int lSon = node * 2, rSon = node * 2 + 1;
long long sum = 0;
if (ql <= mid) sum += query(lSon, l, mid, ql, qr);
if (mid + 1 <= qr) sum += query(rSon, mid + 1, r, ql, qr);
return sum;
}
int qr[N_MAX + 2];
vector<int> queries[N_MAX + 2];
long long answer[N_MAX + 2];
int cost[N_MAX + 2];
int encode(int x, int pos) { return (pos - x) / k + (x != 0); }
int decode(int x, int i) { return (i - (x != 0)) * k + x; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) rm[i][0] = a[i];
for (int bit = 1; bit < BITS; bit++)
for (int i = 1; i + (1 << bit) - 1 <= n; i++)
rm[i][bit] = min(rm[i][bit - 1], rm[i + (1 << (bit - 1))][bit - 1]);
for (int i = 1; i <= n; i++) {
lg2[i] = lg2[i - 1];
if ((1 << (lg2[i] + 1)) <= i) lg2[i]++;
}
for (int i = 1; i <= q; i++) {
int l;
cin >> l >> qr[i];
queries[l].push_back(i);
}
for (int x = 0; x < k; x++) {
int m = encode(x, n);
build(1, 1, m);
vector<int> st;
for (int i = m; i >= 1; i--) {
int pos = decode(x, i);
while (st.empty() == false && a[pos] <= cost[st.back()]) st.pop_back();
update(1, 1, m, i, (st.empty() == true ? m : st.back() - 1), a[pos]);
for (int id : queries[pos]) {
answer[id] += a[pos];
int j = encode(x, qr[id]);
answer[id] += query(1, 1, m, i + 1, j);
}
cost[i] = rmq(max(1, pos - k + 1), pos);
while (st.empty() == false && cost[i] <= cost[st.back()]) st.pop_back();
update(1, 1, m, i, (st.empty() == true ? m : st.back() - 1), cost[i]);
st.push_back(i);
}
}
for (int i = 1; i <= q; i++) cout << answer[i] << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, j, temp, cnt = 0;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
temp = 0;
for (int j = 0; j < n - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'P') {
s[j + 1] = 'A';
j++;
temp = 1;
}
}
if (temp == 1) {
cnt++;
} else
break;
}
cout << cnt << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 1e9 + 100;
const long long inf_ll = 1e18;
const double pi = 3.1415926535898;
bool debug = 0;
const int MAXN = 2e5 + 100;
const int LOG = 21;
const int mod = 998244353;
const int MX = (1e7 + 100);
int go[1024][16];
int sufLink[1024];
int leaf[1024];
int top = 1;
void build() {
memset(sufLink, -1, sizeof sufLink);
queue<int> q;
q.push(0);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < 16; ++i) {
int to = go[v][i];
int suf = sufLink[v] == -1 ? 0 : go[sufLink[v]][i];
if (to >= 0) {
sufLink[to] = suf;
q.push(to);
} else {
go[v][i] = suf;
}
}
if (sufLink[v] >= 0) leaf[v] += leaf[sufLink[v]];
}
}
long long dp[2][1 << 14][1024];
inline pair<int, long long> process_string(int v, const string &a) {
long long res = 0;
for (char c : a) {
v = go[v][c];
res += leaf[v];
}
return {v, res};
}
long long calc_cost[1024];
int calc_pos[1024];
void solve() {
memset(go, -1, sizeof go);
int k;
cin >> k;
for (int i = 1; i <= k; ++i) {
string a;
cin >> a;
int v = 0;
for (int c : a) {
c = c - 'a';
if (go[v][c] == -1) {
go[v][c] = top++;
}
v = go[v][c];
}
int cost;
cin >> cost;
leaf[v] += cost;
}
build();
string t;
cin >> t;
for (char &c : t) {
if (c == '?') {
continue;
}
c = c - 'a';
}
vector<int> pos;
for (int i = 0; i < (int(t.size())); ++i) {
if (t[i] == '?') {
pos.push_back(i);
}
}
long long ans = 0;
if (pos.empty()) {
int v = 0;
for (char c : t) {
v = go[v][c];
ans += leaf[v];
}
cout << ans << "\n";
return;
}
int st = pos[0];
for (int i = 0; i < (1 << 14); ++i) {
fill(dp[0][i], dp[0][i] + 1024, -inf_ll);
fill(dp[1][i], dp[1][i] + 1024, -inf_ll);
}
auto x = process_string(0, t.substr(0, st));
dp[0][0][x.first] = x.second;
42;
for (int i = 0; i < (int(pos.size())); ++i) {
for (int mask = 0; mask < (1 << 14); ++mask) {
for (int v = 0; v < top; ++v) {
if (dp[0][mask][v] != -inf_ll) {
long long val = dp[0][mask][v];
for (int c = 0; c < 14; ++c) {
if (!(mask & (1 << c))) {
int to = go[v][c];
dp[1][mask | (1 << c)][to] =
max(dp[1][mask | (1 << c)][to], val + leaf[to]);
}
}
dp[0][mask][v] = -inf_ll;
}
}
}
string to_nxt = "";
if (i + 1 < (int(pos.size()))) {
to_nxt = t.substr(pos[i] + 1, pos[i + 1] - pos[i] - 1);
} else {
to_nxt = t.substr(pos[i] + 1, (int(t.size())) - pos[i] - 1);
}
42;
for (int v = 0; v < top; ++v) {
auto x = process_string(v, to_nxt);
calc_cost[v] = x.second;
calc_pos[v] = x.first;
}
for (int mask = 0; mask < (1 << 14); ++mask) {
for (int v = 0; v < top; ++v) {
if (dp[1][mask][v] != -inf_ll) {
dp[0][mask][calc_pos[v]] =
max(dp[0][mask][calc_pos[v]], dp[1][mask][v] + calc_cost[v]);
dp[1][mask][v] = -inf_ll;
}
}
}
}
ans = -inf_ll;
for (int mask = 0; mask < (1 << 14); ++mask) {
for (int v = 0; v < top; ++v) {
ans = max(ans, dp[0][mask][v]);
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(2);
int t = 1;
while (t--) {
solve();
}
42;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int n, m, l, r, i;
char s[101], c1, c2;
scanf("%d %d", &n, &m);
scanf("%s", s);
while (m--) {
scanf("%d %d %c %c", &l, &r, &c1, &c2);
for (i = l - 1; i < r; ++i) {
if (s[i] == c1) {
s[i] = c2;
}
}
}
printf("%s", s);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct E {
int nxt, to;
} e[N << 1];
int head[N], tot;
void add(int x, int y) {
e[++tot].nxt = head[x];
e[tot].to = y;
head[x] = tot;
e[++tot].nxt = head[y];
e[tot].to = x;
head[y] = tot;
}
int A[N], B[N], ans[N], cnt;
void dfs2(int x, int ji, int ou, int dep, int fa) {
int tmp = A[x];
if (dep & 1) {
if (ji & 1) tmp ^= 1;
} else {
if (ou & 1) tmp ^= 1;
}
if (tmp != B[x]) {
ans[++cnt] = x;
ji += (dep & 1);
ou += (!(dep & 1));
}
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].to != fa) dfs2(e[i].to, ji, ou, dep + 1, x);
}
int main() {
int n, x, y;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y);
}
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
for (int i = 1; i <= n; i++) scanf("%d", &B[i]);
dfs2(1, 0, 0, 1, 0);
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d\n", ans[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
const int maxm = 3 * maxn;
vector<pair<int, int> > G[maxn];
vector<int> mp;
int vis[maxn], vis1[maxn], ans1, ans;
int vis2[maxn], vis3[maxn];
bool dfs(int u, int num) {
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first, w = G[u][i].second;
if (vis[v] != 0) {
if (w == num) {
if (vis[u] != vis[v]) return false;
continue;
} else {
if (vis[u] == vis[v]) return false;
continue;
}
}
if (w == num) {
vis[v] = vis[u];
mp.push_back(v);
if (vis[v] == 2) ans1++;
if (!dfs(v, num)) return false;
} else {
vis[v] = 3 - vis[u];
mp.push_back(v);
if (vis[v] == 2) ans1++;
if (!dfs(v, num)) return false;
}
}
return true;
}
void solve(int n, int num) {
memset(vis, 0, sizeof(vis)), memset(vis1, 0, sizeof(vis1)),
memset(vis2, 0, sizeof(vis2));
mp.clear();
int ANS = 0;
for (int i = 1; i <= n; i++) {
if (vis1[i] == 1) continue;
ans1 = 0, vis[i] = 1;
int flag1 = 0, flag2 = 0;
mp.push_back(i);
if (dfs(i, num)) flag1 = 1;
for (int j = 0; j < mp.size(); j++) {
vis2[mp[j]] = (vis[mp[j]] == 2 ? 1 : 0);
vis[mp[j]] = 0;
vis1[mp[j]] = 1;
}
int Ans1 = ans1;
mp.clear();
mp.push_back(i);
ans1 = 1, vis[i] = 2;
if (dfs(i, num)) flag2 = 1;
int Ans2 = ans1;
for (int j = 0; j < mp.size(); j++) vis1[mp[j]] = 1;
if (flag1 == 1 && flag2 == 1) {
if (Ans1 < Ans2)
ANS += Ans1;
else {
ANS += Ans2;
for (int j = 0; j < mp.size(); j++)
vis2[mp[j]] = (vis[mp[j]] == 2 ? 1 : 0);
}
} else if (flag1 == 1)
ANS += Ans1;
else if (flag2 == 1) {
ANS += Ans2;
for (int j = 0; j < mp.size(); j++)
vis2[mp[j]] = (vis[mp[j]] == 2 ? 1 : 0);
} else {
ANS = 0x3f3f3f3f;
break;
}
mp.clear();
}
if (ANS < ans) {
for (int i = 1; i <= n; i++) vis3[i] = vis2[i], ans = ANS;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int u, v;
char s[2];
for (int i = 0; i < m; i++) {
scanf("%d%d%s", &u, &v, s);
if (s[0] == 'B') {
G[u].push_back(pair<int, int>{v, 1});
G[v].push_back(pair<int, int>{u, 1});
} else {
G[u].push_back(pair<int, int>{v, 2});
G[v].push_back(pair<int, int>{u, 2});
}
}
ans = 0x3f3f3f3f;
solve(n, 1);
solve(n, 2);
if (ans == 0x3f3f3f3f)
puts("-1");
else {
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (vis3[i] == 1) printf("%d ", i);
printf("\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 10000000000000;
long long n, a[4003], m, dp[4003][4003], lson[4003], rson[4003], siz[4003],
lval[4003], rval[4003];
void solve(long long l, long long r, long long pos) {
if (l == r) return;
long long mn, now;
mn = now = MAXN;
for (long long i = l; i < pos; ++i)
if (a[i] < mn) mn = a[i], now = i;
if (mn < MAXN) {
lson[pos] = now;
lval[pos] = mn - a[pos];
solve(l, pos - 1, now);
}
mn = now = MAXN;
for (long long i = pos + 1; i <= r; ++i)
if (a[i] < mn) mn = a[i], now = i;
if (mn < MAXN) {
rson[pos] = now;
rval[pos] = mn - a[pos];
solve(pos + 1, r, now);
}
}
void dfs(long long pos) {
siz[pos] = 1;
if (lson[pos]) {
dfs(lson[pos]);
for (long long i = siz[pos]; i >= 0; --i)
for (long long j = siz[lson[pos]]; j >= 0; --j)
dp[pos][i + j] = max(dp[pos][i + j], dp[lson[pos]][j] + dp[pos][i] +
j * (m - j) * lval[pos]);
siz[pos] += siz[lson[pos]];
}
if (rson[pos]) {
dfs(rson[pos]);
for (long long i = siz[pos]; i >= 0; --i)
for (long long j = siz[rson[pos]]; j >= 0; --j)
dp[pos][i + j] = max(dp[pos][i + j], dp[rson[pos]][j] + dp[pos][i] +
j * (m - j) * rval[pos]);
siz[pos] += siz[rson[pos]];
}
}
signed main() {
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> a[i];
long long to, mn = MAXN;
for (long long i = 1; i <= n; ++i)
if (a[i] < mn) mn = a[i], to = i;
solve(1, n, to);
dfs(to);
printf("%lld\n", dp[to][m]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int count = 1;
bool flL = false;
bool flR = false;
bool flU = false;
bool flD = false;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'R') {
if (!flL && !flR) {
flR = true;
} else if (flL && !flR) {
flL = false;
flR = true;
flD = false;
flU = false;
count++;
}
} else if (s[i] == 'L') {
if (!flL && !flR) {
flL = true;
} else if (!flL && flR) {
flR = false;
flL = true;
flU = false;
flD = false;
count++;
}
} else if (s[i] == 'D') {
if (!flD && !flU) {
flD = true;
} else if (flU && !flD) {
flU = false;
flD = true;
flL = false;
flR = false;
count++;
}
} else if (s[i] == 'U') {
if (!flD && !flU) {
flU = true;
} else if (!flU && flD) {
flU = true;
flD = false;
flR = false;
flL = false;
count++;
}
}
}
cout << count;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m;
vector<long long int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m, rb, cb, rd, cd;
cin >> n >> m >> rb >> cb >> rd >> cd;
long long int ans = 0, s1 = 1, s2 = 1;
while (true) {
if (rb == rd || cb == cd) break;
if (rb + s1 > n || rb + s1 < 1) s1 *= -1;
if (cb + s2 > m || cb + s2 < 1) s2 *= -1;
rb += s1;
cb += s2;
ans++;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 123;
int siz[N], son[N], fa[N], top[N], dep[N], dfn[N], tot;
struct Edge {
int to, pre;
} e[N * 2];
int ecnt = 0, h[N];
void addedge(int u, int v) {
e[ecnt] = (Edge){v, h[u]};
h[u] = ecnt++;
}
void dfs1(int u, int t) {
top[u] = t;
dfn[u] = ++tot;
if (son[u]) dfs1(son[u], t);
for (int i = h[u]; ~i; i = e[i].pre) {
int v = e[i].to;
if (v == son[u] || v == fa[u]) continue;
dfs1(v, v);
}
}
void dfs(int u) {
siz[u] = 1;
for (int i = h[u]; ~i; i = e[i].pre) {
int v = e[i].to;
if (v == fa[u]) continue;
fa[v] = u;
dep[v] = dep[u] + 1;
dfs(v);
siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
}
int lca(int u, int v) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
u = fa[top[u]];
}
return dep[u] < dep[v] ? u : v;
}
int sum(int u, int v) {
int res = 0;
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
res += dfn[u] - dfn[top[u]] + 1;
u = fa[top[u]];
}
res += abs(dfn[u] - dfn[v]) + 1;
return res;
}
int get(int a, int b, int c) {
int u = lca(a, b), v = c;
int p = lca(a, c);
int A, B;
if (dep[p] >= dep[u])
A = sum(c, p);
else
A = sum(u, c);
p = lca(b, c);
if (dep[p] >= dep[u])
B = sum(c, p);
else
B = sum(u, c);
return min(A, B);
}
int main() {
memset(h, 0xff, sizeof h);
int n, q;
scanf("%d %d", &n, &q);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
addedge(p, i);
}
dfs(1);
dfs1(1, 1);
while (q--) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
int ans = max(get(a, b, c), max(get(a, c, b), get(b, c, a)));
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string p;
cin >> p;
bool f = 0;
for (int i = 0; i < p.size(); i++) {
if (p[i] != 'a') {
for (int j = i; j < p.size(); j++) {
if (p[j] == 'a') break;
p[j] = p[j] - 1;
f = 1;
}
cout << p << endl;
return 0;
}
}
if (!f) p[p.size() - 1] = 'z';
cout << p << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dfs(long long n, long long h, bool dir) {
if (h == 0) return 0;
bool side = n <= (1LL << (h - 1)) - 1;
long long ans;
long long newn = side == 1 ? n : (n % (1LL << (h - 1)));
if (side == dir) {
ans = 1 + dfs(newn, h - 1, !side);
return ans;
}
ans = 1 + (1LL << h) - 1 + dfs(newn, h - 1, !side);
return ans;
}
int main() {
long long n, h;
cin >> h >> n;
cout << dfs(n - 1, h, true) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T pmax(T a, T b) {
return max(a, b);
}
const long long int mod = 1e9 + 7;
const long long int Maa = 2e5 + 3;
vector<long long int> edge[Maa];
long long int n, m, node, cnt;
long long int act_dfs(long long int V, long long int P, long long int l) {
map<long long int, long long int> mp;
for (auto u : edge[V]) {
if (u == P) continue;
long long int val = act_dfs(u, V, l);
if (val == -1) return -1;
mp[1 + val]++;
}
if (mp.size() > 1 and V != l) return node = V, -1;
long long int ans = cnt = 0;
for (auto u : mp) ans += u.first, cnt++;
return ans;
}
int main() {
long long int T, l, r, f = 0;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> l >> r;
edge[l].push_back(r);
edge[r].push_back(l);
}
node = 1;
act_dfs(1, 0, 1);
long long int a = act_dfs(node, 0, node);
if (a == -1 or cnt > 2)
cout << -1;
else if (a % 2 != 0)
cout << a;
else {
while (a % 2 == 0) a = a / 2;
cout << a;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
while (a > 0 && b > 0)
if (a > b)
a %= b;
else
b %= a;
return a + b;
}
int main() {
int x, y, a, b, n, m;
cin >> n >> m >> x >> y >> a >> b;
int temp = gcd(a, b);
a /= temp;
b /= temp;
temp = min(n / a, m / b);
a *= temp;
b *= temp;
int x1 = 0, y1 = 0;
if (a / 2.0 < x) x1 = min(int(x - a / 2.0), n - a);
if (b / 2.0 < y) y1 = min(int(y - b / 2.0), m - b);
cout << x1 << " " << y1 << " " << x1 + a << " " << y1 + b;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 200005;
vector<int> v[maxm];
long long dp[maxm][5] = {0}, a[maxm] = {0}, ans = 0;
int k, n;
void dfs(int x, int pre, int num);
int main() {
int i, j, sum, x, y;
scanf("%d%d", &n, &k);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, -1, 0);
printf("%lld\n", ans / k);
return 0;
}
void dfs(int x, int pre, int num) {
dp[x][num % k] = 1;
a[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int xx = v[x][i];
if (xx == pre) continue;
dfs(xx, x, num + 1);
for (int j = 0; j < k; j++) {
for (int r = 0; r < k; r++) {
int dis = ((j + r) % k - ((num * 2) % k + k)) % k;
int rev = (k - dis + k) % k;
ans += rev * dp[x][j] * dp[xx][r];
}
}
a[x] += a[xx];
for (int j = 0; j < k; j++) dp[x][j] += dp[xx][j];
ans += (n - a[xx]) * a[xx];
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n), b;
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = 1; i < n; i++) b.push_back(abs(a[i] - a[i - 1]));
n = b.size();
long long int dp[n][2];
dp[n - 1][0] = b[n - 1];
dp[n - 1][1] = -b[n - 1];
long long int ans = -(long long int)(1e16);
for (long long int i = n - 1 - 1; i >= 0; i--) {
dp[i][0] = max(b[i], b[i] + dp[i + 1][1]);
dp[i][1] = max(-b[i], -b[i] + dp[i + 1][0]);
}
for (long long int i = 0; i < n; i++) {
ans = max(ans, dp[i][0]);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int a[maxn << 3], fl[maxn << 3], tot[maxn << 3];
int b[maxn << 1];
int arr[maxn], l[maxn], r[maxn], k[maxn], ID[maxn << 1];
void build(int u, int l, int r) {
if (l == r) {
a[u] = tot[u] = b[l];
} else {
int md = l + r >> 1, ls = u << 1, rs = ls | 1;
build(ls, l, md);
build(rs, md + 1, r);
a[u] = tot[u] = tot[ls] + tot[rs];
}
}
void push_down(int u) {
if (fl[u]) {
int f = fl[u], ls = u << 1, rs = ls | 1;
fl[ls] = fl[rs] = f;
fl[u] = 0;
if (f == 2) {
a[ls] = tot[ls];
a[rs] = tot[rs];
} else {
a[ls] = a[rs] = 0;
}
}
}
int update(int u, int l, int r, int L, int R, int K) {
if (L <= l and r <= R) {
int an = a[u];
if (K == 1) {
if (a[u]) {
a[u] = 0;
fl[u] = 1;
}
} else {
if (a[u] != tot[u]) {
a[u] = tot[u];
fl[u] = 2;
}
}
return an;
}
push_down(u);
int md = l + r >> 1, ls = u << 1, rs = ls | 1, an;
if (R <= md)
an = update(ls, l, md, L, R, K);
else if (md < L)
an = update(rs, md + 1, r, L, R, K);
else
an = update(ls, l, md, L, R, K) + update(rs, md + 1, r, L, R, K);
a[u] = a[ls] + a[rs];
return an;
}
int n, q, nn, i, N, L, R, ans, cur;
int main() {
scanf("%d%d", &n, &q);
for (i = 1; i <= q; i++) {
scanf("%d%d%d", l + i, r + i, k + i);
arr[nn++] = l[i];
arr[nn++] = r[i];
}
sort(arr, arr + nn);
nn = unique(arr, arr + nn) - arr;
arr[nn] = n + 1;
if (arr[0] != 1) b[++N] = a[0] - 1;
for (i = 0; i < nn; i++) {
b[++N] = 1;
ID[i] = N;
if (arr[i] + 1 < arr[i + 1]) {
b[++N] = arr[i + 1] - arr[i] - 1;
}
}
build(1, 1, N);
ans = n;
for (i = 1; i <= q; i++) {
L = lower_bound(arr, arr + nn, l[i]) - arr;
R = lower_bound(arr, arr + nn, r[i]) - arr;
cur = update(1, 1, N, ID[L], ID[R], k[i]);
ans -= cur;
if (k[i] == 2) ans += r[i] - l[i] + 1;
printf("%d\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
const long long INF = 1e9 + 7;
const long long maxn = 2e5 + 7;
using namespace std;
vector<long long> a;
long long n;
vector<vector<int>> dp;
int calc(int l, int r) {
if (l > r) return -1;
if (l == r) return dp[l][r] = a[l];
if (dp[l][r] != -1) return dp[l][r];
dp[l][r] = -2;
for (long long mid = l; mid < r; mid++) {
int le = calc(l, mid);
int re = calc(mid + 1, r);
if (le > 0 && (le == re)) {
dp[l][r] = le + 1;
}
}
return dp[l][r];
}
void solve() {
cin >> n;
a.resize(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
dp = vector<vector<int>>(n + 1, vector<int>(n + 1, -1));
auto dp2 = vector<long long>(n + 1, INF);
dp2[0] = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n + 1; j++) {
if (calc(i, j - 1) > 0) {
dp2[j] = min(dp2[j], dp2[i] + 1);
}
}
}
cout << dp2[n] << '\n';
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.1415926535897932384626433832795;
int const inf = (int)1e9;
long long const inf64 = (long long)2e18;
const string pname = "c";
const int NMAX = 1010;
const string TYPE[3] = {"gladiator", "sentry", "physician"};
const string ZN[3] = {"weapon", "armor", "orb"};
int n, m;
string name[NMAX], zn[NMAX], hero[NMAX], type[NMAX], home[NMAX];
int param[NMAX][3], places[NMAX], bonus[NMAX], extra[NMAX];
void answer(int x, int y, int z) {
cout << name[x] << " " << places[x];
for (int i = 0; i < (int)m; i++)
if (home[i] == name[x]) cout << " " << hero[i];
cout << endl;
cout << name[y] << " " << places[y];
for (int i = 0; i < (int)m; i++)
if (home[i] == name[y]) cout << " " << hero[i];
cout << endl;
cout << name[z] << " " << places[z];
for (int i = 0; i < (int)m; i++)
if (home[i] == name[z]) cout << " " << hero[i];
cout << endl;
exit(0);
}
int get(int now) {
int best = -1, ans = -1;
for (int i = 0; i < (int)n; i++)
if (zn[i] == ZN[now] && best < param[i][now]) best = param[i][now], ans = i;
return ans;
}
vector<pair<int, int> > q[3];
int ans[3];
int sum[NMAX];
void solve(int now) {
memset(sum, 0, sizeof(sum));
sum[0] = 0;
for (int i = 0; i < (int)q[now].size(); i++)
sum[i + 1] = sum[i] - q[now][i].first;
int best = -1, ind = -1;
for (int i = 0; i < (int)n; i++)
if (zn[i] == ZN[now]) {
int tmp = param[i][now] + sum[min((int)q[now].size(), places[i])];
if (best < tmp) {
best = tmp;
ind = i;
}
}
int cnt = min((int)q[now].size(), places[ind]);
extra[ind] = places[ind] - cnt;
places[ind] = cnt;
for (int i = 0; i < (int)cnt; i++) home[q[now][i].second] = name[ind];
ans[now] = ind;
}
int main() {
cin >> n;
int sum = 0;
for (int i = 0; i < (int)n; i++) {
cin >> name[i] >> zn[i];
for (int j = 0; j < (int)3; j++) cin >> param[i][j];
cin >> places[i];
sum += places[i];
}
cin >> m;
for (int i = 0; i < (int)m; i++)
cin >> hero[i] >> type[i] >> bonus[i] >> home[i];
if (sum == m) {
for (int i = 0; i < (int)m; i++)
for (int j = 0; j < (int)n; j++)
if (name[j] == home[i])
for (int f = 0; f < (int)3; f++)
if (TYPE[f] == type[i]) param[j][f] += bonus[i];
answer(get(0), get(1), get(2));
}
for (int i = 0; i < (int)m; i++)
for (int j = 0; j < (int)3; j++)
if (type[i] == TYPE[j]) q[j].push_back(make_pair(-bonus[i], i));
for (int j = 0; j < (int)3; j++) sort((q[j]).begin(), (q[j]).end());
for (int i = 0; i < (int)m; i++) home[i] = "";
for (int j = 0; j < (int)3; j++) solve(j);
for (int i = 0; i < (int)n; i++)
if (i != ans[0] && i != ans[1] && i != ans[2]) {
extra[i] = places[i];
places[i] = 0;
}
int yl = 0;
for (int i = 0; i < (int)m; i++)
if (home[i] == "") {
while (extra[yl] == 0) yl++;
home[i] = name[yl];
extra[yl]--;
places[yl]++;
}
answer(ans[0], ans[1], ans[2]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, ans;
signed main() {
cin >> n >> m >> k;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> b(n, 0);
sort(a.begin(), a.end());
for (long long i = k - 1; i < n; i++) {
long long p = k;
while (b[max(i - (p - 1), (long long)0)] == -1) {
k += b[max(i - (k - 1), (long long)0)];
b[max(i - (p - 1), (long long)0)] = 0;
p = k;
}
if (k - 1 <= i && a[i] - a[i - (k - 1)] < m) {
ans++;
b[i]--;
k++;
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<long long> a(n);
for (auto& x : a) cin >> x;
long long sum = accumulate(begin(a), end(a), 0LL);
sum /= n;
long long ans = 0;
for (int i = 0; i + 1 < n; i++) {
ans += abs(sum - a[i]);
a[i + 1] += a[i] - sum;
}
cout << ans << '\n';
return (0);
}
| 4 |
#include <bits/stdc++.h>
int main() {
int a[3][3], i, n, j;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++) scanf("%d", &a[i][j]);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
if (i == 1 && j == 1)
n = a[i][j] + a[i + 1][j] + a[i - 1][j] + a[i][j + 1] + a[i][j - 1];
else if (i == 0 && j == 0)
n = a[i][j] + a[i + 1][j] + a[i][j + 1];
else if (i == 1 && j == 0)
n = a[i][j] + a[i + 1][j] + a[i - 1][j] + a[i][j + 1];
else if (j == 1 && i == 0)
n = a[i][j] + a[i + 1][j] + a[i][j + 1] + a[i][j - 1];
else if (j == 2 && i == 1)
n = a[i][j] + a[i - 1][j] + a[i + 1][j] + a[i][j - 1];
else if (j == 2 && i == 0)
n = a[i][j] + a[i][j - 1] + a[i + 1][j];
else if (i == 2 && j == 0)
n = a[i][j] + a[i - 1][j] + a[i][j + 1];
else
n = a[i][j] + a[i - 1][j] + a[i][j + 1] + a[i][j - 1];
if (n % 2 == 0)
printf("1");
else
printf("0");
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
bool check = true;
bool check2 = true;
vector<int> c(n);
vector<int> d(n);
long long minp, maxp;
int prevp;
for (int i = 0; i < n; i++) {
if (i == 0) {
cin >> c[i] >> d[i];
if (d[i] == 1) {
maxp = 2000000000;
minp = 1900;
prevp = 1;
} else {
maxp = 1899;
minp = -2000000000;
prevp = 2;
check2 = false;
}
} else {
cin >> c[i] >> d[i];
if (prevp == d[i]) {
if (d[i] == 1) {
minp = max(minp + c[i - 1], (long long)1900);
maxp = maxp + c[i - 1];
if (maxp < 1900) check = false;
}
if (d[i] == 2) {
minp = minp + c[i - 1];
maxp = min(maxp + c[i - 1], (long long)1899);
if (minp > 1899) check = false;
}
} else {
if (d[i] == 1) {
prevp = 1;
if (maxp + c[i - 1] < 1900)
check = false;
else {
minp = max((long long)1900, minp + c[i - 1]);
maxp = maxp + c[i - 1];
}
} else {
prevp = 2;
check2 = false;
if (minp + c[i - 1] > 1899)
check = false;
else {
minp = minp + c[i - 1];
maxp = min((long long)1899, maxp + c[i - 1]);
}
}
}
}
}
maxp = maxp + c[n - 1];
if (check2)
cout << "Infinity";
else if (check)
cout << maxp;
else
cout << "Impossible";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, tr, kol, kond;
char c;
string s;
map<char, long long> a;
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> c;
cin >> s;
if (c == '.') {
for (int j = 0; j < s.size(); j++) {
a[s[j]] = -1;
}
}
if (c == '!') {
if (tr == 0) {
for (int j = 0; j < s.size(); j++) {
if (a[s[j]] == 0) {
a[s[j]] = 1;
tr = 1;
}
}
}
if (tr == 1) {
map<char, long long> v;
for (int j = 0; j < s.size(); j++) {
v[s[j]]++;
}
for (int k = (int)'a'; k <= (int)'z'; k++) {
if (a[(char)k] == 1 && v[(char)k] == 0) a[(char)k] = -1;
}
}
if (tr == 2) {
kol++;
}
}
if (c == '?') {
if (tr < 2) {
a[s[0]] = -1;
}
if (tr == 2) kol++;
}
kond = 0;
for (int k = (int)'a'; k <= (int)'z'; k++) {
if (a[(char)k] == 1 || (tr == 0 && a[(char)k] == 0)) kond++;
}
if (kond == 1) tr = 2;
}
cout << kol;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct node {
long double x0, y0;
long double xv, yv;
void print() { cout << x0 << " " << y0 << " " << xv << " " << yv << "\n"; }
} a[1111];
const long double eps1 = 1e-7, eps2 = 1e-7;
int sgn1(long double a) {
if (-eps1 <= a && a <= eps1) return 0;
return a > 0 ? 1 : -1;
}
int sgn2(long double a) {
if (-eps2 <= a && a <= eps2) return 0;
return a > 0 ? 1 : -1;
}
const long double pi = acos(-1);
map<pair<int, pair<int, int> >, int> mp;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int aa, b, c, d, e, f;
cin >> aa >> b >> c >> d >> e >> f;
a[i].xv = 1. * (e - b) / (d - aa);
a[i].yv = 1. * (f - c) / (d - aa);
a[i].x0 = b - aa * a[i].xv;
a[i].y0 = c - aa * a[i].yv;
}
int ans = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j)
a[j].xv -= a[i].xv, a[j].yv -= a[i].yv, a[j].x0 -= a[i].x0,
a[j].y0 -= a[i].y0;
}
vector<long double> v;
vector<pair<long double, pair<long double, long double> > > w;
for (int j = 1; j <= n; j++) {
if (i != j) {
if (sgn2(a[j].xv) == 0 && sgn2(a[j].yv) == 0) continue;
long double t = sgn2(a[j].xv) ? a[j].x0 / a[j].xv : a[j].y0 / a[j].yv;
if (sgn2(a[j].x0 - t * a[j].xv) == 0 &&
sgn2(a[j].y0 - t * a[j].yv) == 0) {
v.push_back(t);
long double t = atan2(a[j].yv, a[j].xv);
auto p = make_pair(a[j].xv, a[j].yv);
w.push_back(make_pair(t, p));
}
}
}
sort(v.begin(), v.end());
int cur = 0;
for (int i = 0; i < v.size(); i++) {
if (i && sgn1(v[i] - v[i - 1]) != 0) ans = max(ans, cur + 1), cur = 0;
cur++;
}
ans = max(ans, cur + 1);
sort(w.begin(), w.end());
cur = 0;
vector<vector<pair<long double, long double> > > u(1);
for (int i = 0; i < w.size(); i++) {
if (i && sgn1(w[i].first - w[i - 1].first) != 0)
u.push_back(vector<pair<long double, long double> >());
u.rbegin()->push_back(w[i].second);
}
for (auto& x : u) {
cur = 0;
sort(x.begin(), x.end(),
[&](pair<long double, long double> a,
pair<long double, long double> b) {
if (sgn2(a.first - b.first)) return a.first < b.first;
return a.second < b.second;
});
for (int i = 0; i < x.size(); i++) {
if (i == 0)
cur++;
else if (sgn2(x[i].first - x[i - 1].first) != 0 ||
sgn2(x[i].second - x[i - 1].second) != 0)
cur++;
}
ans = max(ans, cur + 1);
}
ans = max(ans, cur + 1);
for (int j = 1; j <= n; j++) {
if (i != j)
a[j].xv += a[i].xv, a[j].yv += a[i].yv, a[j].x0 += a[i].x0,
a[j].y0 += a[i].y0;
}
}
cout << ans << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N];
int main() {
int T;
scanf("%d", &T);
while (T) {
T--;
int n, cnt1 = 0, cnt2 = 0, l, r;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
if (a[i] != i) cnt1++;
}
if (cnt1 == 0)
printf("0\n");
else {
for (l = 1; l <= n; l++)
if (l != a[l]) break;
for (r = n; r > 0; r--)
if (r != a[r]) break;
for (int i = l; i <= r; i++)
if (a[i] == i) cnt2++;
if (cnt2)
printf("2\n");
else
printf("1\n");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 20;
int n, l, r;
double f[1 << MAX];
double first[MAX], second[MAX], a[MAX];
double get(double l, double first, double second, double a) {
a = a * M_PI / 180;
double ang = atan2(second, l - first);
ang -= a;
if (ang > 1e-9) return first + second / tan(ang);
return r;
}
int main() {
int i, j;
cin >> n >> l >> r;
for ((i) = (0); (i) != (n); ++(i)) cin >> first[i] >> second[i] >> a[i];
for ((i) = (0); (i) != ((1 << n)); ++(i)) f[i] = l;
f[0] = l;
for ((i) = (0); (i) != ((1 << n) - 1); ++(i))
for ((j) = (0); (j) != (n); ++(j))
if (!(i & (1 << j)))
f[i | (1 << j)] =
max(f[i | (1 << j)], get(f[i], first[j], second[j], a[j]));
printf("%.6f\n", min(f[(1 << n) - 1], (double)r) - l);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void Karl_Heinrich_Marx() {}
int n, m;
char c[605][605];
void Vladimir_Ilyich_Lenin() {
int d = 0, cc = 0;
cin >> n >> m;
for (int i = 0; i <= n + 10; ++i)
for (int j = 0; j <= m + 10; ++j) c[i][j] = '.';
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> c[i][j];
}
}
int i = d, j = cc;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (i != 0 && j != 0) {
if (c[i][j] == 'W')
if (c[i + 1][j] == 'S' || c[i][j + 1] == 'S' || c[i - 1][j] == 'S' ||
c[i][j - 1] == 'S') {
cout << "No";
return;
}
}
cout << "Yes" << endl;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (c[i][j] == '.')
cout << "D";
else
cout << c[i][j];
}
cout << endl;
}
}
int main() {
Karl_Heinrich_Marx();
Vladimir_Ilyich_Lenin();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e6;
bool tub(int n) {
if (n < 2) return 0;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return 0;
return 1;
}
bool prime[3123456];
int main() {
int n;
cin >> n;
if (n == 4) return cout << "2\n 2 2", 0;
bool ok = 1;
if (tub(n)) return cout << "1\n" << n, 0;
prime[1] = 1;
for (int i = 2; i * i <= maxn; i++) {
if (!prime[i]) {
for (int j = i * i; j <= maxn; j += i) prime[j] = 1;
}
}
n -= 3;
for (int i = 2; i < min(n, maxn); i++)
if (!prime[i] && tub(n - i))
return cout << "3\n"
<< "3 " << i << " " << n - i,
0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int size(const T& c) {
return c.size();
}
using namespace std;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
const int maxn = 100000 + 10;
int a[maxn];
map<int, bool> ma;
map<int, bool> ma1;
map<int, bool> ma2;
int l, x, y, n;
bool ok1, ok2;
int main() {
scanf("%d%d%d%d", &n, &l, &x, &y);
ma.clear();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] >= x && ma[a[i] - x]) ok1 = true;
if (a[i] >= y && ma[a[i] - y]) ok2 = true;
ma[a[i]] = true;
if (a[i] >= x) ma1[a[i] - x] = true;
if (a[i] + x <= l) ma1[a[i] + x] = true;
if (a[i] >= y) ma2[a[i] - y] = true;
if (a[i] + y <= l) ma2[a[i] + y] = true;
}
if (ok1 && ok2) {
cout << 0;
} else if (ok1 || ok2) {
if (ok1) {
cout << 1 << endl;
cout << y;
}
if (ok2) {
cout << 1 << endl;
cout << x << endl;
}
} else {
for (__typeof((ma2).begin()) it = (ma2).begin(); it != (ma2).end(); it++) {
int u = (*it).first;
if (ma1[u] && ma2[u]) {
cout << 1 << endl;
cout << u << endl;
return 0;
}
}
cout << 2 << endl;
cout << x << ' ' << y << endl;
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
using iii = pair<int, ii>;
const string FILENAME = "";
const bool FILE_IO = 1;
const int INF = 1000000000;
const int MOD = 1000000000;
void init() {
if (!FILENAME.empty()) {
freopen((FILENAME + ".in").c_str(), "r", stdin);
freopen((FILENAME + ".out").c_str(), "w", stdout);
}
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout.precision(6);
}
void solve() {
int t;
cin >> t;
for (int k = 0; k < t; k++) {
int n;
string resp;
cin >> n;
if (n == 1) {
cout << "! 1 1" << endl;
continue;
}
vector<int> min, max;
int ans1 = -1, ans2 = -1;
if (n % 2 == 1) {
max.push_back(n);
min.push_back(n);
n--;
}
for (int i = 0, cnt = 1; i < n / 2; cnt += 2, i++) {
cout << "? " << cnt << " " << cnt + 1 << endl;
cin >> resp;
if (resp == "<") {
min.push_back(cnt);
max.push_back(cnt + 1);
} else {
if (resp == ">") {
max.push_back(cnt);
min.push_back(cnt + 1);
} else {
max.push_back(cnt + 1);
min.push_back(cnt);
}
}
}
ans2 = max[0];
for (int i = 1; i < max.size(); i++) {
cout << "? " << ans2 << " " << max[i] << endl;
cin >> resp;
if (resp == "<") {
ans2 = max[i];
}
}
if (min.size() == 0) {
ans1 = ans2;
} else {
ans1 = min[0];
for (int i = 1; i < min.size(); i++) {
cout << "? " << ans1 << " " << min[i] << endl;
cin >> resp;
if (resp == ">") {
ans1 = min[i];
}
}
}
cout << "! " << ans1 << " " << ans2 << endl;
}
}
int main() {
init();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long cnt_max = 1, cnt_min = 1, max, min, n, temp, ans = 0, cnt = 1;
scanf("%I64d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &temp);
if (i == 0) {
max = temp;
min = temp;
} else {
if (temp == max) cnt_max++;
if (temp == min) cnt_min++;
if (temp > max) {
max = temp;
cnt_max = 1;
}
if (temp < min) {
min = temp;
cnt_min = 1;
}
}
ans = max - min;
if (ans == 0)
cnt = cnt_max * (cnt_max - 1) / 2;
else
cnt = cnt_max * cnt_min;
}
printf("%I64d %I64d\n", ans, cnt);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long cnt1, cnt2, x, y;
long long calc(long long num, long long x) {
return num / x * (x - 1) + num % x;
}
long long calc2(long long num, long long x, long long y) {
return num / y - num / (x * y);
}
bool available(long long num) {
long long both = calc(num, x) + calc(num, y) - calc(num, x * y);
long long onlyX = calc2(num, x, y);
long long onlyY = calc2(num, y, x);
long long remain1 = max(cnt1 - onlyX, 0ll);
long long remain2 = max(cnt2 - onlyY, 0ll);
if (remain1 + remain2 <= both) {
return true;
}
return false;
}
int main() {
cin >> cnt1 >> cnt2 >> x >> y;
long long low = 1, high = cnt1 * x + cnt2 * y;
while (low <= high) {
long long mid = (low + high) / 2;
if (available(mid)) {
high = mid - 1;
} else {
low = mid + 1;
}
}
cout << low << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
long long a[100000];
for (int i = 0; i < n; i++) std::cin >> a[i];
if (n % 2 == 0) {
for (int i = 0; i < n; i++)
std::cout << (a[i] >= 0 ? -a[i] - 1 : a[i]) << " ";
std::cout << "\n";
} else {
for (int i = 0; i < n; i++)
if (a[i] >= 0) a[i] = -a[i] - 1;
int k = -1;
for (int i = 0; i < n; i++)
if (k == -1 || a[i] < a[k]) k = i;
for (int i = 0; i < n; i++)
if (i == k)
std::cout << -a[i] - 1 << " ";
else
std::cout << a[i] << " ";
std::cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ch[50050][12], l1, l2, fail[50050], ct = 1, dp[50050][52][2][2][2],
is[50050], fa[50050];
char s[50050], l[50050], r[50050];
void ins(int l, int r) {
int st = 1;
for (int i = l; i <= r; i++) {
int vl = s[i] - '0';
if (!ch[st][vl]) ch[st][vl] = ++ct, fa[ct] = st;
st = ch[st][vl];
}
is[st] = 1;
}
void init() {
queue<int> st;
st.push(1);
while (!st.empty()) {
int x = st.front();
st.pop();
for (int i = 0; i < 10; i++)
if (ch[x][i]) {
int t = fail[x];
while (t && !ch[t][i]) t = fail[t];
if (t == 0 && x != 1) t = 1;
fail[ch[x][i]] = ch[t][i];
st.push(ch[x][i]);
}
}
}
int main() {
scanf("%s%s%s", s + 1, l + 1, r + 1);
l1 = strlen(s + 1);
l2 = strlen(l + 1);
for (int i = 1; i <= l1 - l2 / 2 + 1; i++) ins(i, i + l2 / 2 - 1);
init();
dp[1][0][1][1][0] = 1;
for (int i = 0; i < l2; i++)
for (int j = 1; j <= ct; j++)
for (int k = 0; k < 2; k++)
for (int l1 = 0; l1 < 2; l1++)
for (int s = 0; s < 2; s++)
if (dp[j][i][k][l1][s]) {
int lb = k ? l[i + 1] - '0' : 0, rb = l1 ? r[i + 1] - '0' : 9;
for (int t = lb; t <= rb; t++) {
int st = j;
while (!ch[st][t] && st) st = fail[st];
if (!st) st = 1;
st = ch[st][t];
if (!st) st = 1;
int nk = k & (t == l[i + 1] - '0'),
nl = l1 & (t == r[i + 1] - '0'), ns = s | is[st];
dp[st][i + 1][nk][nl][ns] =
(dp[st][i + 1][nk][nl][ns] + dp[j][i][k][l1][s]) %
1000000007;
}
}
int as = 0;
for (int i = 1; i <= ct; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) as = (as + dp[i][l2][j][k][1]) % 1000000007;
printf("%d\n", as);
}
| 12 |
#include <bits/stdc++.h>
int main() {
int N, i;
scanf("%d", &N);
if (N < 6)
puts("-1");
else {
for (i = 2; i <= 4; i++) printf("1 %d\n", i);
for (i = 5; i <= N; i++) printf("4 %d\n", i);
}
for (i = 2; i <= N; i++) printf("1 %d\n", i);
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int MAX_N = 20;
int n, k, t;
int e[MAX_N + 1][MAX_N + 1];
int choosen[MAX_N + 1];
int mid;
int cnt;
void dfs(int x, int now_cost_sum) {
if (x > n) {
cnt++;
return;
}
dfs(x + 1, now_cost_sum);
for (int y = 1; y <= n && cnt < t; y++) {
if (!choosen[y] && e[x][y] && now_cost_sum + e[x][y] <= mid) {
choosen[y] = 1;
dfs(x + 1, now_cost_sum + e[x][y]);
choosen[y] = 0;
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &t);
for (int i = 1; i <= k; i++) {
int h, w, r;
scanf("%d%d%d", &h, &w, &r);
e[h][w] = r;
}
int low = 0, high = 1000 * n;
while (low < high) {
mid = (low + high) >> 1;
cnt = 0;
dfs(1, 0);
if (cnt >= t)
high = mid;
else
low = mid + 1;
}
printf("%d\n", low);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n;
int dp[1000010][21][2];
long long cnt(long long x, long long y) {
return n / ((1 << x) * (y == 1 ? 3 : 1));
}
int main() {
scanf("%lld", &n);
int bit = log2(n);
dp[1][bit][0] = 1;
if ((1 << bit - 1) * 3 <= n) {
dp[1][bit - 1][1] = 1;
}
for (register int i = 2; i <= n; i++) {
for (register int j = 0; j <= bit; j++) {
for (register int k = 0; k <= 1; k++) {
dp[i][j][k] =
(dp[i][j][k] + 1ll * dp[i - 1][j][k] * (cnt(j, k) - i + 1) % mod) %
mod;
if (j < bit) {
dp[i][j][k] = (dp[i][j][k] + 1ll * dp[i - 1][j + 1][k] *
(cnt(j, k) - cnt(j + 1, k)) % mod) %
mod;
}
if (k < 1) {
dp[i][j][k] = (dp[i][j][k] + 1ll * dp[i - 1][j][k + 1] *
(cnt(j, k) - cnt(j, k + 1)) % mod) %
mod;
}
}
}
}
printf("%d", dp[n][0][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const long long mod = 998244353;
long long l, r;
int k;
long long dp[21][11][1 << 10], dp2[21][11][1 << 10];
int f[1 << 10];
long long play(long long x) {
if (x == 0) return 0;
if (x < 10) return x * (x + 1) / 2;
int i;
long long now = 1, ans = 0, w = 0, num = 1, w2 = 0;
while (now * 10 <= x) {
for (i = 1; i <= 9; i++) {
for (int j = 0; j < 1 << 10; j++)
if (f[j] <= k) ans += dp2[num][i][j];
}
num++;
now *= 10;
}
ans %= mod;
for (int i = 0; i < (1 << 10); i++)
if (f[i] <= k) ans -= dp2[num][0][i];
while (now) {
for (i = 0;; i++) {
if (now != 1) {
if ((i + 1) * now > x) break;
} else if (i > x)
break;
for (int j = 0; j < 1 << 10; j++)
if (f[j | w] <= k) {
ans += dp2[num][i][j] + dp[num][i][j] * (w2 % mod);
ans %= mod;
}
}
x %= now;
w |= 1 << i;
w2 += i * now;
num--;
now /= 10;
}
return ans;
}
int main() {
scanf("%lld%lld%d", &l, &r, &k);
int i, j, k, a, b;
memset(dp2, 0, sizeof(dp2));
dp[0][10][0] = 1;
dp2[0][10][0] = 0;
for (i = 0; i < 1 << 10; i++) {
a = 0;
for (j = 0; j < 10; j++)
if (i & (1 << j)) a++;
f[i] = a;
}
long long qaq = 1;
for (i = 1; i <= 18; i++) {
for (j = 0; j < 10; j++) {
for (k = 0; k < (1 << 10); k++) {
if (dp[i - 1][10][k] == 0) continue;
dp[i][j][k | 1 << j] += dp[i - 1][10][k];
dp[i][j][k | 1 << j] %= mod;
dp2[i][j][k | 1 << j] +=
dp2[i - 1][10][k] + qaq % mod * j % mod * dp[i - 1][10][k];
dp2[i][j][k | 1 << j] %= mod;
dp[i][10][k | 1 << j] += dp[i - 1][10][k];
dp[i][10][k | 1 << j] %= mod;
dp2[i][10][k | 1 << j] +=
dp2[i - 1][10][k] + qaq % mod * j % mod * dp[i - 1][10][k];
dp2[i][10][k | 1 << j] %= mod;
}
}
qaq *= 10;
}
long long ans = play(r) - play(l - 1);
printf("%lld\n", (ans % mod + mod) % mod);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
for (int i = 0; i < str.length(); i++) {
if (str[i] == 'H' || str[i] == 'Q' || str[i] == '9') {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[200][200];
int N, M;
int MoveFront(int nn, int mm, int d) {
int j, cc;
cc = 0;
for (j = mm + d; j >= 0 && j < M; j += d) {
cc++;
if (s[nn][j] == 'W') return cc;
}
if (nn >= N) return 0;
cc = 0;
if (d == 1) {
for (j = M; j > mm; j--) {
cc++;
if (s[nn + 1][j] == 'W') return M - mm - cc + 1;
}
} else {
for (j = 0; j < mm; j++) {
cc++;
if (s[nn + 1][j] == 'W') return mm - cc + 1;
}
}
return 0;
}
int main() {
int nn, mm, allmove, allw, i, j, d;
cin >> N >> M;
nn = 0;
mm = 0;
d = 1;
for (i = 0; i < N; i++) cin >> s[i];
allw = 0;
for (i = 0; i < N; i++)
for (j = 0; j < M; j++)
if (s[i][j] == 'W') allw++;
if (s[0][0] == 'W') allw--;
allmove = 0;
int ccc;
while (allw != 0) {
if (ccc = MoveFront(nn, mm, d)) {
for (i = 1; i <= ccc; i++) {
mm += d;
allmove++;
}
if (s[nn][mm] == 'W') {
s[nn][mm] = 'G';
allw--;
continue;
} else {
nn++;
d = -d;
allmove++;
if (s[nn][mm] == 'W') {
s[nn][mm] = 'G';
allw--;
}
}
} else {
nn++;
d = -d;
allmove++;
if (s[nn][mm] == 'W') {
s[nn][mm] = 'G';
allw--;
}
}
}
cout << allmove << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, 0, 0, -1};
int dy[] = {0, 0, 1, -1, 0};
const long long mod = 1000000000 + 7;
map<int, bool> m;
int main() {
int n, k;
scanf("%d", &n);
scanf("%d", &k);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
vector<int> b(k);
for (int i = 0; i < k; i++) scanf("%d", &b[i]);
sort(b.rbegin(), b.rend());
int j = 0;
for (int i = 0; i < n; i++) {
if (!a[i]) {
a[i] = b[j++];
}
}
for (int i = 1; i < n; i++) {
if (a[i] <= a[i - 1]) {
puts("Yes");
return 0;
}
}
puts("No");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w1, h1, w2, h2, a1, a2, b;
cin >> w1 >> h1 >> w2 >> h2;
a1 = (w1 + h1) * 2 + 4;
a2 = (w2 + h2) * 2 + 4;
b = a1 + a2;
if (w1 > w2) {
b = b - (2 * w2) - 4;
} else
b = b - (2 * w1) - 4;
cout << b;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
long long int ans = (a + b + c) * (a + b + c) - a * a - c * c - e * e;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, m;
long long a[maxn];
long long l[maxn], r[maxn];
int id[maxn];
int ans[maxn];
int cmp(const int &i, const int &j) { return a[i] < a[j]; }
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
priority_queue<pair<long long, int> > q1, q2;
for (int i = 0; i < n; i++) {
scanf("%I64d %I64d", &l[i], &r[i]);
if (i) {
q1.push(make_pair(r[i - 1] - l[i], i));
}
}
for (int i = 0; i < m; i++) {
scanf("%I64d", &a[i]);
id[i] = i;
}
if (m < n - 1) {
puts("No");
continue;
}
sort(id, id + m, cmp);
int now = 0;
for (int i = 0; i < m; i++) {
long long x = a[id[i]];
while (!q1.empty() && q1.top().first >= -x) {
int idx = q1.top().second;
q1.pop();
long long len = l[idx - 1] - r[idx];
q2.push(make_pair(len, idx - 1));
}
if (!q2.empty() && q2.top().first <= -x) {
ans[q2.top().second] = id[i] + 1;
q2.pop();
}
}
if (q1.empty() && q2.empty()) {
puts("Yes");
for (int i = 0; i < n - 1; i++) printf("%d ", ans[i]);
puts("");
} else
puts("No");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, b, maxp, cnt, i, j, tot, nown, ans;
struct node {
long long p, numb, numn;
} f[30];
bool isprime[1000011];
vector<long long> prime;
int main() {
while (~scanf("%lld%lld", &n, &b)) {
prime.clear();
maxp = (long long)sqrt(b);
cnt = 0;
memset(isprime, true, sizeof(isprime));
for (i = 2; i <= maxp; i++) {
if (isprime[i]) {
prime.push_back(i);
cnt++;
for (j = 0; j < cnt && i * prime[j] <= maxp; j++) {
isprime[i * prime[j]] = false;
if (i % prime[j] == 0) break;
}
}
}
tot = 0;
for (i = 0; i <= cnt - 1; i++) {
if (b % prime[i] == 0) {
tot++;
f[tot].p = prime[i];
f[tot].numb = 0;
f[tot].numn = 0;
while (b % prime[i] == 0) {
f[tot].numb++;
b /= prime[i];
}
nown = n;
while (nown) {
f[tot].numn += nown / prime[i];
nown /= prime[i];
}
}
}
if (b != 1) {
tot++;
f[tot].p = b;
f[tot].numb = 0;
f[tot].numn = 0;
f[tot].numb++;
nown = n;
while (nown) {
f[tot].numn += nown / b;
nown /= b;
}
}
ans = 1700000000000000000;
for (i = 1; i <= tot; i++) {
nown = f[i].numn / f[i].numb;
ans = min(nown, ans);
}
printf("%lld\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void dfs(int root, map<int, vector<int> > &mp, map<int, bool> &visited) {
visited[root] = true;
cout << root << " ";
for (int i = 0; i < mp[root].size(); i++)
if (visited[mp[root][i]] == false) dfs(mp[root][i], mp, visited);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
{
int n;
cin >> n;
map<int, vector<int> > mp;
map<int, int> de;
map<int, bool> visited;
for (long long int i = (0); i < (n); i++) {
int x, y;
cin >> x >> y;
de[x]++;
de[y]++;
mp[x].push_back(y);
mp[y].push_back(x);
visited[x] = 0;
visited[y] = 0;
}
int root;
for (auto it = de.begin(); it != de.end(); it++)
if (it->second == 1) {
root = it->first;
break;
}
dfs(root, mp, visited);
}
}
| 4 |
#include <bits/stdc++.h>
const double eps = 1e-9;
using namespace std;
double f[2050], p[2050], q[2050];
int fa[2050], fb[2050];
int n, a, b;
void calc(double w1, double w2) {
for (int i = 1; i <= n; i++) {
f[i] = f[i - 1];
fa[i] = fa[i - 1];
fb[i] = fb[i - 1];
if (f[i - 1] + p[i] - w1 > f[i]) {
f[i] = f[i - 1] + p[i] - w1;
fa[i] = fa[i - 1] + 1;
fb[i] = fb[i - 1];
}
if (f[i - 1] + q[i] - w2 > f[i]) {
f[i] = f[i - 1] + q[i] - w2;
fa[i] = fa[i - 1];
fb[i] = fb[i - 1] + 1;
}
if (f[i - 1] + p[i] + q[i] - p[i] * q[i] - w1 - w2 > f[i]) {
f[i] = f[i - 1] + p[i] + q[i] - p[i] * q[i] - w1 - w2;
fa[i] = fa[i - 1] + 1;
fb[i] = fb[i - 1] + 1;
}
}
}
int main() {
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%lf", &p[i]);
for (int i = 1; i <= n; i++) scanf("%lf", &q[i]);
double l1 = 0, r1 = 1, l2, r2;
while (l1 + eps < r1) {
double mid1 = (l1 + r1) / 2;
l2 = 0, r2 = 1;
while (l2 + eps < r2) {
double mid2 = (l2 + r2) / 2;
calc(mid1, mid2);
if (fb[n] > b)
l2 = mid2;
else
r2 = mid2;
}
calc(mid1, r2);
if (fa[n] > a)
l1 = mid1;
else
r1 = mid1;
}
calc(r1, r2);
printf("%.10lf\n", f[n] + a * r1 + b * r2);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
int v[n];
for (int i = 0; i < n; ++i) scanf("%d", &v[i]);
double l = 0.0, e = 1000.0;
double m;
for (int itr = 0; itr < 500; itr++) {
m = (l + e) / 2.0;
double x = 0.0, y = 0.0;
for (int i = 0; i < n; ++i) {
if (v[i] < m)
x += (m - v[i]);
else
y += (v[i] - m);
}
if (y - y * k / 100 >= x)
l = m;
else
e = m;
}
printf("%.7lf\n", m);
return 0;
}
| 4 |
/*
ID: varunra2
LANG: C++
TASK: a
*/
#include <bits/stdc++.h>
using namespace std;
#ifdef DEBUG
#include "lib/debug.h"
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#define debug_arr(...) \
cerr << "[" << #__VA_ARGS__ << "]:", debug_arr(__VA_ARGS__)
#pragma GCC diagnostic ignored "-Wsign-compare"
//#pragma GCC diagnostic ignored "-Wunused-parameter"
//#pragma GCC diagnostic ignored "-Wunused-variable"
#else
#define debug(...) 42
#endif
#define EPS 1e-9
#define IN(A, B, C) assert(B <= A && A <= C)
#define INF (int)1e9
#define MEM(a, b) memset(a, (b), sizeof(a))
#define MOD 1000000007
#define MP make_pair
#define PB push_back
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define x first
#define y second
const double PI = acos(-1.0);
typedef long long ll;
typedef long double ld;
typedef pair<int, int> PII;
typedef map<int, int> MPII;
typedef multiset<int> MSETI;
typedef set<int> SETI;
typedef set<string> SETS;
typedef vector<int> VI;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef vector<string> VS;
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define trav(a, x) for (auto& a : x)
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
typedef vector<int> vi;
#pragma GCC diagnostic ignored "-Wsign-compare"
// util functions
struct segtree {
int n;
VI st;
void init(int _n) {
n = _n;
st.assign(4 * n, 0);
}
void upd(int i, int x, int lo, int hi, int node) {
if (hi == -1) hi = n - 1;
if (hi < i || lo > i) return;
if (lo == hi) {
st[node] = x;
return;
}
int mid = (lo + hi) / 2;
upd(i, x, lo, mid, 2 * node + 1);
upd(i, x, mid + 1, hi, 2 * node + 2);
st[node] = max(st[2 * node + 1], st[2 * node + 2]);
}
int qry(int s, int e, int lo, int hi, int node) {
if (hi == -1) hi = n - 1;
if (hi < s || lo > e) return 0;
if (lo >= s && hi <= e) return st[node];
int mid = (lo + hi) / 2;
return max(qry(s, e, lo, mid, 2 * node + 1),
qry(s, e, mid + 1, hi, 2 * node + 2));
}
void upd(int ind, int val) { upd(ind, val, 0, n - 1, 0); }
int qry(int l, int r) {
if (l > r) return -2;
return qry(l, r, 0, n - 1, 0);
}
};
//[inds, msk]: {0, 7, 8, 9, 10, 11, 12, 13} 16257
// 9 1 14 1 1 7 4 10
int solve() {
int n;
cin >> n;
VII vals(n);
for (int i = 0; i < n; i++) {
cin >> vals[i].x;
vals[i].y = i;
}
VI pos(n);
stack<int> st;
for (int i = 0; i < n; i++) {
while (!st.empty() and vals[st.top()].x <= vals[i].x) st.pop();
if (st.empty())
pos[i] = -1;
else
pos[i] = st.top();
st.push(i);
}
segtree seg;
seg.init(n);
VI dp(n);
auto cop = vals;
sort(all(vals));
for (int i = 0; i < n; i++) {
int val = vals[i].x, ind = vals[i].y;
int ps = pos[ind];
dp[ind] = max(seg.qry(0, ps) + 2, seg.qry(ps + 1, ind) + 1);
seg.upd(ind, dp[ind]);
}
int mx = -1;
// debug(dp);
for (int i = n - 1; i >= 0; i--) {
if (mx > cop[i].x) dp[i]++;
mx = max(mx, cop[i].x);
}
// debug(dp);
return *max_element(all(dp));
}
int main() {
#ifndef ONLINE_JUDGE
freopen("a.in", "r", stdin);
freopen("a.out", "w", stdout);
#endif
cin.sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cout << solve() << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char a[] = {'v', '<', '^', '>'};
int main() {
char t1, t2;
scanf("%c %c", &t1, &t2);
int pos, n;
scanf("%d", &n);
for (int i = 0; i < 4; i++) {
if (a[i] == t1) {
pos = i;
break;
}
}
int tt = n % 4;
int a1 = (tt + pos) % 4, a2 = (pos - tt + 4) % 4;
if (a[a1] == t2 && a1 != a2)
puts("cw");
else if (a[a2] == t2 && a1 != a2)
puts("ccw");
else
puts("undefined");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<string, int> S;
unordered_set<int> y;
int main() {
ios_base::sync_with_stdio(0);
int n, k, g;
string s;
cin >> n >> k >> s >> g;
s += s;
for (int i = 0; i < g; i++) {
string t;
cin >> t;
S.insert(make_pair(t, i));
}
int len = n * k;
vector<int> ans(n);
bool ok;
for (int j = len - k; j < len; j++) {
ok = 1;
for (int i = 0; i < n; i++) {
auto u = S.find(s.substr(j + i * k, k));
if (u == S.end() || y.find(u->second) != y.end()) {
ok = 0;
break;
}
ans[i] = u->second;
y.insert(u->second);
}
if (ok) break;
y.clear();
}
if (ok) {
cout << "YES\n";
for (auto x : ans) cout << x + 1 << " ";
} else {
cout << "NO\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const double pi = 3.1415926;
using namespace std;
long long fact(long long n) {
long long f = 1;
for (long long i = n; i >= 1; i--) f *= i;
return f;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int divisor(int n) {
int sum = 0;
if (n / sqrt(n) == sqrt(n)) sum++;
for (int i = 1; i < sqrt(n); i++)
if (n % i == 0) sum += 2;
return sum;
}
bool prime(long long n) {
if (n == 1) return false;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
bool palindrome_str(string n) {
int x = 0;
int m = n.size() / 2 - 1;
int r = n.size();
for (int i = 0; i < m; i++)
if (n[i] == n[r - i - 1]) x++;
if (x == m) return true;
return false;
}
bool palindrome_num(int n) {
int x = 0, a[10000], r = 0;
while (n) {
a[r++] = n % 10;
n /= 10;
}
for (int i = 0; i < r / 2; i++)
if (a[i] == a[r - i - 1]) x++;
if (x == r / 2) return true;
return false;
}
void small(string &n) {
for (int i = 0; i < n.size(); i++)
if (n[i] >= 'A' && n[i] <= 'Z') n[i] += 32;
}
void capital(string &n) {
for (int i = 0; i < n.size(); i++)
if (n[i] >= 'a' && n[i] <= 'z') n[i] -= 32;
}
long long fast_power(long long n, long long m) {
if (m == 0) return 0;
if (m == 1) return n;
long long x = fast_power(n, m / 2) % 1000000007;
x = (x * x) % 1000000007;
if (m % 2 != 0) x *= n;
x %= 1000000007;
return x;
}
void fast() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int sum(int n) {
int sum = 0;
while (n) {
int x = n % 2;
if (x == 1) sum++;
n /= 2;
}
return sum;
}
int main() {
fast();
int n, a, b, c, d, m = 0, s1[200], s2[200];
cin >> n;
for (int i = 0; i < n; i++) cin >> s1[i] >> s2[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (s1[i] > s1[j] && s2[i] == s2[j])
a++;
else if (s1[i] < s1[j] && s2[i] == s2[j])
b++;
else if (s1[i] == s1[j] && s2[i] > s2[j])
c++;
else if (s1[i] == s1[j] && s2[i] < s2[j])
d++;
}
if (a && b && c && d) m++;
a = 0, b = 0, c = 0, d = 0;
}
cout << m << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[100010];
cin.getline(str, 100010);
bool flag_in = false;
string tmp;
for (int i = 0; str[i] != 0; ++i) {
if (str[i] == '"') {
if (flag_in) {
cout << '<' << tmp << '>' << endl;
tmp.clear();
}
flag_in = !flag_in;
} else if (str[i] != ' ' || flag_in) {
tmp += str[i];
} else {
if (tmp.size() != 0) {
cout << '<' << tmp << '>' << endl;
tmp.clear();
}
}
}
if (tmp.size() != 0) {
cout << '<' << tmp << '>' << endl;
tmp.clear();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void func();
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
func();
}
return 0;
}
void func() {
long long int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long int t = 0;
if (x1 == x2 || y1 == y2)
t = abs(x2 - x1) + abs(y2 - y1);
else
t = abs(x2 - x1) + abs(y2 - y1) + 2;
cout << t << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int prime[18003000 + 10], lp, color[6010];
bool vis[18003000 + 10];
void Get_prime() {
int i, j;
lp = 0;
vis[1] = true;
for (i = 2; i <= 18003000; i++) {
if (vis[i] == false) {
prime[++lp] = i;
}
for (j = 1; j <= lp && prime[j] * i <= 18003000; j++) {
vis[prime[j] * i] = true;
if (i % prime[j] == 0) {
break;
}
}
}
}
int main() {
int n, i, s, ii, j, ss, pp;
Get_prime();
scanf("%d", &n);
s = (1 + n) * n / 2;
if (vis[s] == false) {
for (i = 1; i <= n; i++) printf("1 ");
return 0;
}
if (s % 2 == 0) {
for (i = 1; i <= lp && prime[i] <= s; i++)
if (vis[s - prime[i]] == false) break;
ii = prime[i];
memset(color, 0, sizeof(color));
for (j = n; j >= 1; j--)
if (ii >= j) {
color[j] = 1;
ii -= j;
}
for (j = 1; j <= n; j++) printf("%d ", (color[j] == 1) ? 1 : 2);
} else {
ss = s;
memset(color, 0, sizeof(color));
ss -= 2;
color[2] = 1;
if (vis[ss] == false) {
for (j = 1; j <= n; j++) printf("%d ", (color[j] == 1) ? 1 : 2);
} else {
ss = s;
memset(color, 0, sizeof(color));
for (i = lp; i >= 1; i--)
if (prime[i] <= n) break;
pp = prime[i];
ss -= pp;
color[pp] = 1;
for (i = 1; i <= lp && prime[i] <= ss; i++)
if (vis[ss - prime[i]] == false) break;
ii = prime[i];
for (j = n; j >= 1; j--)
if (ii >= j && j != pp) {
color[j] = 2;
ii -= j;
}
for (j = 1; j <= n; j++) {
if (color[j] == 0)
printf("3 ");
else
printf("%d ", color[j]);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_ = 1500 + 5;
const int INF = 0x3f3f3f3f;
int a[MAX_];
int getall(int r, int l) {
int k = r - l + 1;
int ans = 0;
while (k--) {
ans += k;
}
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int j = 1; j < i; j++)
if (a[j] > a[i]) ans++;
}
int m;
cin >> m;
int l, r;
for (int i = 1; i <= m; i++) {
cin >> l >> r;
int k = getall(r, l);
if (k & 1) ans++;
if (ans & 1)
cout << "odd" << endl;
else
cout << "even" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 2e5, pt = 1e9 + 9;
int n;
bool taken[MaxN + 5];
map<pair<int, int>, int> reloc;
set<int> stsmall;
set<int> stbig;
struct LOC {
int x, y;
} loc[MaxN + 5];
struct ARR {
int cnt;
bool c[5];
} a[MaxN + 5];
bool cantake(int x) {
for (int i = -1; i <= 1; i++) {
int pos = reloc[make_pair(loc[x].x + i, loc[x].y + 1)];
if (pos == 0) continue;
if (taken[pos]) continue;
if (a[pos].cnt <= 1) return false;
}
return true;
}
void Init() {
reloc.clear();
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
reloc[make_pair(x, y)] = i;
loc[i].x = x, loc[i].y = y;
}
for (int i = 1; i <= n; i++) {
for (int dx = 0; dx <= 2; dx++) {
a[i].cnt += (int)(reloc[make_pair(loc[i].x + dx - 1, loc[i].y - 1)] > 0);
a[i].c[dx] =
(bool)(reloc[make_pair(loc[i].x + dx - 1, loc[i].y - 1)] > 0);
}
}
stsmall.clear(), stbig.clear();
for (int i = 1; i <= n; i++) {
if (cantake(i)) {
stsmall.insert(i);
stbig.insert(n - i + 1);
}
}
}
void solve() {
int t = 0;
long long ans = 0;
memset(taken, 0, sizeof(taken));
for (int i = 1; i <= n; i++) {
t = 1 - t;
int now;
if (t)
now = n - (*stbig.begin()) + 1;
else
now = (*stsmall.begin());
stsmall.erase(now);
stbig.erase(n - now + 1);
taken[now] = true;
ans = (ans * n % pt + now - 1) % pt;
for (int dx = 0; dx <= 2; dx++) {
int pos = reloc[make_pair(loc[now].x + dx - 1, loc[now].y + 1)];
if (pos == 0) continue;
a[pos].cnt--, a[pos].c[2 - dx] = false;
}
for (int dx = -2; dx <= 2; dx++) {
int pos = reloc[make_pair(loc[now].x + dx, loc[now].y)];
if (pos == 0) continue;
if (taken[pos]) continue;
if ((stsmall.find(pos) == stsmall.end()) && cantake(pos)) {
stsmall.insert(pos), stbig.insert(n - pos + 1);
} else if ((stsmall.find(pos) != stsmall.end()) && !cantake(pos)) {
stsmall.erase(pos), stbig.erase(n - pos + 1);
}
}
for (int dx = -1; dx <= 1; dx++) {
int pos = reloc[make_pair(loc[now].x + dx, loc[now].y - 1)];
if (pos == 0) continue;
if (taken[pos]) continue;
if ((stsmall.find(pos) == stsmall.end()) && cantake(pos)) {
stsmall.insert(pos), stbig.insert(n - pos + 1);
} else if ((stsmall.find(pos) != stsmall.end()) && !cantake(pos)) {
stsmall.erase(pos), stbig.erase(n - pos + 1);
}
}
}
printf("%lld\n", ans);
}
int main() {
while (~scanf("%d", &n)) {
Init();
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[100010];
bool check(int mid) {
int sum = 0, j = 1;
for (long long i = 0; i <= 40; i++) {
long long now = (1LL << i);
int cnt = 0;
for (; j <= n && a[j] <= now; j++) {
if (a[j] == now)
cnt++;
else if (a[j] < now)
sum++;
}
if (sum > mid) return false;
if (mid > cnt) {
sum -= (mid - cnt);
if (sum < 0) sum = 0;
mid = cnt;
} else if (cnt >= mid)
sum += cnt - mid;
if (sum > mid) return false;
}
return true;
}
int main() {
scanf("%d", &n);
int R = 0;
for (int i = 1; i < (n + 1); i++) scanf("%I64d", &a[i]);
for (int i = 1; i < (n + 1); i++) R += (a[i] == 1 ? 1 : 0);
int tmpR = R;
int L = 1, ans = R + 1;
while (L <= R) {
int mid = ((L + R) >> 1);
if (check(mid)) {
R = mid - 1;
ans = mid;
} else
L = mid + 1;
}
if (ans > tmpR)
puts("-1");
else {
for (int i = ans; i < (tmpR + 1); i++) printf("%d ", i);
puts("");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n;
int k = 2;
while (1) {
int z = pow(2, k);
if ((n % (z - 1)) == 0) {
x = n / (z - 1);
cout << x << '\n';
break;
} else
k++;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(0), ios::sync_with_stdio(0);
ll t, n;
string s;
cin >> t;
while (t--) {
cin >> n >> s;
vector<int> a(n), b(n);
int i = 0, j = 0, k = 1;
while (i < n) {
if (s[i] == '<') {
for (int l = i; l >= j; l--) a[l] = k++;
j = i + 1;
}
i++;
}
for (int l = i - 1; l >= j; l--) a[l] = k++;
i = n - 1, j = n - 1, k = 1;
while (i >= 0) {
if (s[i] == '>') {
for (int l = i + 1; l <= j; l++) b[l] = k++;
j = i;
}
i--;
}
for (int l = i + 1; l <= j; l++) b[l] = k++;
for (int i = 0; i < n; i++) cout << b[i] << " \n"[i == n - 1];
for (int i = 0; i < n; i++) cout << a[i] << " \n"[i == n - 1];
}
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double pi = 3.14159265358979323846264338327950288419716939937511;
const double eps = 1e-13;
char ch_ch_ch[1 << 20];
string gs() {
scanf("%s", ch_ch_ch);
return string(ch_ch_ch);
}
string gl() {
gets(ch_ch_ch);
return string(ch_ch_ch);
}
struct pt {
int x, y;
pt(){};
pt(int xx, int yy) : x(xx), y(yy){};
};
vector<pt> A;
vector<pt> B;
int na, nb;
vector<pair<pt, int> > a;
pt pivot;
long long dist(pt a, pt b) {
return (a.x - b.x) * 1ll * (a.x - b.x) + (a.y - b.y) * 1ll * (a.y - b.y);
}
double mina, maxa;
bool compAng(const pair<pt, int> &a, const pair<pt, int> &b) {
double val1 = atan2(a.first.y - pivot.y, a.first.x - pivot.x);
double val2 = atan2(b.first.y - pivot.y, b.first.x - pivot.x);
double val = val1 - val2;
if (abs(val) < eps)
return (abs(val2 - mina) < eps)
? (dist(a.first, pivot) < dist(b.first, pivot))
: (dist(a.first, pivot) > dist(b.first, pivot));
return val < 0;
}
inline int sieg(long long a) { return (a < 0) ? -1 : ((a == 0) ? 0 : 1); }
long long vmul(int i, int j, int k) {
long long vx = a[k].first.x - a[i].first.x;
long long vy = a[k].first.y - a[i].first.y;
long long ux = a[j].first.x - a[i].first.x;
long long uy = a[j].first.y - a[i].first.y;
return ux * vy - uy * vx;
}
inline bool eq(pt a, pt b) { return a.x == b.x && a.y == b.y; }
bool comp(const pair<pt, int> &a, const pair<pt, int> &b) {
if (a.first.x < b.first.x) return true;
if (a.first.x == b.first.x && a.first.y < b.first.y) return true;
return false;
}
bool workon() {
a.clear();
for (int i = 0; i < (A.size()); ++i) a.push_back(make_pair(A[i], 0));
for (int i = 0; i < (B.size()); ++i) a.push_back(make_pair(B[i], 1));
vector<int> conv, convu, convd, up, down;
sort(a.begin(), a.end(), comp);
down.push_back(0);
for (int i = (1); i < ((int)a.size() - 1); ++i)
if (vmul(0, a.size() - 1, i) > 0)
up.push_back(i);
else
down.push_back(i);
up.push_back(a.size() - 1);
convu.push_back(0);
convu.push_back(up[0]);
for (int i = (1); i < (up.size()); ++i) {
while (convu.size() >= 2 &&
vmul(convu.back(), convu[convu.size() - 2], up[i]) < 0)
convu.pop_back();
convu.push_back(up[i]);
}
convd.push_back(a.size() - 1);
convd.push_back(down.back());
for (int i = (int)down.size() - 2; i >= 0; --i) {
while (convd.size() >= 2 &&
vmul(convd.back(), convd[convd.size() - 2], down[i]) < 0)
convd.pop_back();
convd.push_back(down[i]);
}
conv = convu;
for (int i = (1); i < (convd.size() - 1); ++i) conv.push_back(convd[i]);
for (int i = 0; i < (conv.size()); ++i)
if (a[conv[i]].second == 1) return false;
return true;
}
void solution() {
cin >> na;
for (int i = 0; i < (na); ++i) {
int x, y;
scanf("%d%d", &x, &y);
A.push_back(pt(x, y));
}
cin >> nb;
for (int i = 0; i < (nb); ++i) {
int x, y;
scanf("%d%d", &x, &y);
B.push_back(pt(x, y));
}
if (!workon()) {
cout << "NO\n";
return;
}
cout << "YES\n";
}
int main(int argc, char **argv) {
solution();
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
for (long long i = 1; s.length() <= 10000; i++) {
s += to_string(i);
}
long long k;
cin >> k;
cout << s[k - 1] << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MAX_LEN = 1010;
using namespace std;
template <typename U, typename V>
string to_string(pair<U, V>);
string to_string(const string& e_) { return "\"" + e_ + "\""; }
string to_string(char e_) { return "\'" + string(1, e_) + "\'"; }
string to_string(bool e_) { return e_ ? "true" : "false"; }
template <typename T>
string to_string(T e_) {
string s_ = "[ ";
for (const auto& x_ : e_) s_ += to_string(x_) + " ";
return s_ + "]";
}
template <typename U, typename V>
string to_string(pair<U, V> e_) {
return "(" + to_string(e_.first) + ", " + to_string(e_.second) + ")";
}
void dbg_str() { ; }
template <typename U, typename... V>
void dbg_str(U u, V... v) {
;
dbg_str(v...);
}
long long int a, b, c, d;
long long int ans;
char op[3];
void calminval(vector<long long int> values) {
;
int num = (int)values.size();
if (num == 1) {
ans = min(ans, values[0]);
return;
}
for (int i = 0; i < num; i++)
for (int j = i + 1; j < num; j++) {
vector<long long int> temp;
for (int k = 0; k < num; k++)
if (k != i && k != j) temp.push_back(values[k]);
if (op[4 - num] == '*')
temp.push_back(values[i] * values[j]);
else
temp.push_back(values[i] + values[j]);
calminval(temp);
}
}
int main() {
scanf("%lld %lld %lld %lld\n", &a, &b, &c, &d);
scanf("%c %c %c", &op[0], &op[1], &op[2]);
ans = 1e17;
calminval({a, b, c, d});
printf("%lld\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string str;
cin >> str;
int a, c, g, t, k;
a = c = g = t = k = 0;
for (int i = 0; i < n; i++) {
if (str[i] == 'A')
++a;
else if (str[i] == 'C')
++c;
else if (str[i] == 'G')
++g;
else if (str[i] == 'T')
++t;
else
++k;
}
int l = n / 4;
for (int i = 0; i < n; i++) {
if (str[i] == '?' && a != l) {
str[i] = 'A';
++a;
} else if (str[i] == '?' && c != l) {
str[i] = 'C';
++c;
} else if (str[i] == '?' && g != l) {
str[i] = 'G';
++g;
} else if (str[i] == '?' && t != l) {
str[i] = 'T';
++t;
}
}
if ((a != l || c != l || g != l || t != l) || n % 4 != 0)
cout << "===" << endl;
else
cout << str;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int aux;
long long work;
vector<int> coffee;
bool possible(int days) {
int day = 0;
long long ans = 0;
for (int i = 1; i < n + 1; i++) {
ans += max(0, coffee[i - 1] - day);
if (i % days == 0) day++;
}
return ans >= work;
}
int main() {
cin >> n >> work;
long long total = 0;
for (int i = 0; i < n; i++) {
cin >> aux;
total += aux;
coffee.push_back(aux);
}
if (work > total) {
cout << "-1\n";
return 0;
}
sort(coffee.begin(), coffee.end());
reverse(coffee.begin(), coffee.end());
int ans;
int ini = 1, fin = n + 1;
while (ini <= fin) {
int mid = (ini + fin) / 2;
if (possible(mid)) {
ans = mid;
fin = mid - 1;
} else {
ini = mid + 1;
}
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void err(istringstream *iss) {}
template <typename T, typename... Args>
void err(istringstream *iss, const T &$val, const Args &...args) {
string $name;
*iss >> $name;
if ($name.back() == ',') $name.pop_back();
cout << $name << " = " << $val << "; ", err(iss, args...);
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
int n, m, K, T, Q, cn;
int s, e, a[100005], b[100005], dp[5][305];
vector<int> posb[100005];
int main() {
cin.tie(NULL);
scanf("%d%d%d%d", &n, &m, &s, &e);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]), posb[b[i]].push_back(i);
}
for (int i = 0; i < 100005; i++) {
posb[i].push_back(m + 1);
}
int mx = 0;
for (int i = 1; i < 305; i++) {
dp[0][i] = m + 1;
}
for (int i = 1; i <= n; i++) {
int at = i & 1, prv = at ^ 1;
for (int j = 1; j < 305; j++) {
if (dp[prv][j - 1] <= m)
dp[at][j] = min(
dp[prv][j],
*upper_bound(posb[a[i]].begin(), posb[a[i]].end(), dp[prv][j - 1]));
else
dp[at][j] = dp[prv][j];
if (dp[at][j] <= m and i + dp[at][j] + j * ll(e) <= s) mx = max(mx, j);
}
}
printf("%d\n", mx);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void print(tuple<long long, long long, long long> t) {
auto [a, b, c] = t;
cout << "(" << a << ", " << b << ", " << c << ") ";
}
template <class T>
void print(T& x) {
cout << x;
}
template <class T, class U>
void print(pair<T, U>& p) {
cout << "(";
print(p.first);
cout << ", ";
print(p.second);
cout << ")";
}
template <class T>
void print(vector<T>& v) {
cout << "{";
if (((int)(v).size())) print(v[0]);
for (int i = 1; i < ((int)(v).size()); i++) cout << ", ", print(v[i]);
cout << "}\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long N;
string S;
cin >> N >> S;
deque<tuple<long long, long long, long long>> st;
long long cnt = 0;
long long res = 0;
for (long long i = N - 1; i >= 0; i--) {
if (S[i] == '0') {
cnt = 0;
} else {
cnt++;
}
while (((int)(st).size()) && get<0>(st[0]) <= cnt) st.pop_front();
auto it = st.begin();
long long curVal = 0;
if (it == st.end()) {
curVal += cnt * (cnt + 1) / 2;
curVal += (N - (i + cnt)) * cnt;
} else {
auto [c, pos, val] = *it;
curVal += (pos + cnt - (i + cnt)) * cnt;
curVal += val;
}
st.emplace_front(cnt, i, curVal);
res += curVal;
}
cout << res << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct SSP {
int n, source, sink;
vector<vector<int> > adj;
struct edge {
int u, flow, cap, cost, origcost;
};
vector<edge> edges;
SSP(int n, int source, int sink) : n(n), source(source), sink(sink), adj(n) {}
int add_edge(int a, int b, int cap, int cost) {
int result = edges.size();
adj[a].push_back(edges.size());
edges.push_back({b, 0, cap, cost, cost});
adj[b].push_back(edges.size());
edges.push_back({a, 0, 0, -cost, -cost});
return result;
}
pair<int, int> djk() {
struct state_t {
int dist, prev, maxf;
};
queue<int> q;
vector<state_t> states(n, {INT_MAX / 2, -1, 0});
states[source] = {0, -2, INT_MAX};
vector<int> inqueue(n, 0);
inqueue[source] = 1;
q.push(source);
while (!q.empty()) {
int v = q.front();
q.pop();
inqueue[v] = 0;
for (int edid : adj[v]) {
edge& ed = edges[edid];
if (ed.flow < ed.cap && states[ed.u].dist > states[v].dist + ed.cost) {
states[ed.u].dist = states[v].dist + ed.cost;
states[ed.u].prev = edid;
states[ed.u].maxf = min(states[v].maxf, ed.cap - ed.flow);
if (!inqueue[ed.u]) q.push(ed.u), inqueue[ed.u] = 1;
}
}
}
int lastid = states[sink].prev, extraflow = states[sink].maxf, atcost = 0;
if (lastid == -1) return {0, 0};
for (int id = lastid; id != -2; id = states[edges[id ^ 1].u].prev) {
edges[id].flow += extraflow;
edges[id ^ 1].flow -= extraflow;
atcost += edges[id].origcost;
}
for (int id = 0; id < (int)edges.size(); id++) {
int v = edges[id ^ 1].u, u = edges[id].u;
if (states[v].prev != -1 && states[u].prev != -1)
edges[id].cost += states[v].dist - states[u].dist;
}
return {extraflow, atcost};
}
pair<int, int> mfmc() {
int flow = 0, cost = 0;
if (any_of(edges.begin(), edges.end(),
[](const edge& ed) { return ed.flow > 0 && ed.cost < 0; }))
bellamanford();
int extraflow, atcost;
while (tie(extraflow, atcost) = djk(), extraflow > 0)
flow += extraflow, cost += extraflow * atcost;
return {flow, cost};
}
void bellamanford() {
vector<int> dist(n, INT_MAX / 2);
dist[source] = 0;
for (int rep = 0; rep < n; rep++) {
bool changed = false;
for (int id = 0; id < (int)edges.size(); id++) {
int v = edges[id ^ 1].u, u = edges[id].u;
if (edges[id].flow < edges[id].cap && dist[v] != INT_MAX / 2 &&
dist[u] > dist[v] + edges[id].cost) {
dist[u] = dist[v] + edges[id].cost;
changed = true;
assert(rep < n - 1);
}
}
if (!changed) break;
}
for (int id = 0; id < (int)edges.size(); id++) {
int v = edges[id ^ 1].u, u = edges[id].u;
if (dist[v] < INT_MAX / 2 && dist[u] < INT_MAX / 2)
edges[id].cost += dist[v] - dist[u];
}
}
};
const int maxn = 3030;
const int magic = ((int)log2(maxn));
int in[maxn], out[maxn], arr[maxn];
int cnt = 0;
int get_node() {
cnt++;
return cnt - 1;
}
int main() {
int n;
scanf("%d", &n);
for (int e = 0; e < n; e++) scanf("%d", arr + e);
int source = get_node();
int sink = get_node();
int ssink = get_node();
for (int e = 0; e < n; e++) in[e] = get_node();
for (int e = 0; e < n; e++) out[e] = get_node();
SSP solver(cnt, source, ssink);
for (int e = 0; e < n; e++) solver.add_edge(in[e], out[e], 1, -1);
for (int e = 0; e < n; e++) solver.add_edge(source, in[e], 1, 0);
for (int e = 0; e < n; e++) solver.add_edge(out[e], sink, 1, 0);
for (int e = 0; e < n; e++) {
int qtd_by_1 = 0;
int qtd_by_7 = 0;
for (int f = e + 1; f < n; f++) {
if (abs(arr[e] - arr[f]) == 1 && qtd_by_1 < 2 * magic) {
solver.add_edge(out[e], in[f], 1, 0);
qtd_by_1++;
} else if ((arr[e] % 7) == (arr[f] % 7) && qtd_by_7 < magic) {
solver.add_edge(out[e], in[f], 1, 0);
qtd_by_7++;
}
}
}
solver.add_edge(sink, ssink, 4, 0);
pair<int, int> ans = solver.mfmc();
printf("%d\n", -ans.second);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool vis[100];
void init() {
memset(vis, true, sizeof(vis));
vis['B' - 'A'] = false;
vis['C' - 'A'] = false;
vis['D' - 'A'] = false;
vis['E' - 'A'] = false;
vis['F' - 'A'] = false;
vis['G' - 'A'] = false;
vis['J' - 'A'] = false;
vis['K' - 'A'] = false;
vis['L' - 'A'] = false;
vis['N' - 'A'] = false;
vis['P' - 'A'] = false;
vis['Q' - 'A'] = false;
vis['R' - 'A'] = false;
vis['S' - 'A'] = false;
vis['Z' - 'A'] = false;
}
int main() {
init();
char s[100000 + 10];
while (~scanf("%s", s)) {
bool flag = false;
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (!vis[s[i] - 'A']) {
flag = true;
break;
}
}
if (flag)
puts("NO");
else {
for (int i = 0; i < len / 2; i++) {
if (s[len - 1 - i] != s[i]) {
flag = true;
break;
}
}
if (flag)
puts("NO");
else
puts("YES");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
double L[100010], R[100010];
int A[100010], h[100010], B[N], C[10010], D[10010];
double O[N << 2], laz[N << 2];
void build(int o, int l, int r) {
laz[o] = 1;
if (l == r) {
O[o] = 1;
return;
}
int mid = l + (r - l) / 2;
build(o * 2, l, mid);
build(o * 2 + 1, mid + 1, r);
O[o] = O[o * 2] + O[o * 2 + 1];
}
void pushdown(int o) {
if (laz[o] != 1) {
laz[o * 2] *= laz[o];
laz[o * 2 + 1] *= laz[o];
O[o * 2] *= laz[o];
O[o * 2 + 1] *= laz[o];
laz[o] = 1;
}
}
void update(int o, int l, int r, int x, int y, double p) {
if (x <= l && r <= y) {
O[o] *= p;
laz[o] *= p;
return;
}
int mid = l + (r - l) / 2;
pushdown(o);
if (x <= mid) update(o * 2, l, mid, x, y, p);
if (y > mid) update(o * 2 + 1, mid + 1, r, x, y, p);
O[o] = O[o * 2] + O[o * 2 + 1];
}
double query(int o, int l, int r, int x) {
if (l == r) return O[o];
int mid = l + (r - l) / 2;
pushdown(o);
if (x <= mid)
return query(o * 2, l, mid, x);
else
return query(o * 2 + 1, mid + 1, r, x);
}
int main() {
int n, m, c = 0;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d %d %lf %lf", &A[i], &h[i], &L[i], &R[i]);
L[i] /= 100;
R[i] /= 100;
B[++c] = A[i] - h[i];
B[++c] = A[i] - 1;
B[++c] = A[i] + h[i];
B[++c] = A[i] + 1;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &C[i], &D[i]);
B[++c] = C[i];
}
sort(B + 1, B + 1 + c);
int u = unique(B + 1, B + 1 + c) - B - 1;
build(1, 1, u);
for (int i = 1; i <= n; i++) {
int a = lower_bound(B + 1, B + 1 + u, A[i] - h[i]) - B;
int b = lower_bound(B + 1, B + 1 + u, A[i] - 1) - B;
update(1, 1, u, a, b, 1 - L[i]);
a = lower_bound(B + 1, B + 1 + u, A[i] + 1) - B;
b = lower_bound(B + 1, B + 1 + u, A[i] + h[i]) - B;
update(1, 1, u, a, b, 1 - R[i]);
}
double ans = 0;
for (int i = 1; i <= m; i++) {
int a = lower_bound(B + 1, B + 1 + u, C[i]) - B;
double p = query(1, 1, u, a);
ans += p * D[i];
}
printf("%f\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define mp make_pair
#define fr first
#define sc second
int n;
ll x[5002],y[5002];
int p[5002];
bool f(int s,int t,int u){
ll inn=(x[s]-x[t])*(x[u]-x[t])+(y[s]-y[t])*(y[u]-y[t]);
return inn>0;
}
int main(){
scanf("%d",&n);
for(int i=0;i<n;i++)scanf("%lld%lld",&x[i],&y[i]);
p[0]=0;
p[1]=1;
for(int i=2;i<n;i++){
if(f(p[i-2],p[i-1],i)){
p[i]=i;
continue;
}
if(f(i,p[0],p[1])){
for(int j=i;j>0;j--){
p[j]=p[j-1];
}
p[0]=i;
continue;
}
for(int j=0;j+1<i;j++){
bool ok=f(p[j],i,p[j+1]);
if(j-1>=0&&!f(p[j-1],p[j],i))ok=false;
if(j+2<i&&!f(i,p[j+1],p[j+2]))ok=false;
if(ok){
for(int k=i;k>j+1;k--){
p[k]=p[k-1];
}
p[j+1]=i;
break;
}
}
}
for(int i=0;i<n;i++){
printf("%d%c",p[i]+1,(i+1==n)?'\n':' ');
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ord[100100];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
ord[t - 1].push_back(i);
}
int best = 0;
for (int i = 0; i < 100100; i++) {
for (int j = 0; j < ord[i].size(); j++) {
ord[i][j] -= j;
}
for (int j = 0; j < ord[i].size(); j++) {
int cur = ord[i][j];
int nxt = cur + k;
int pos = upper_bound(ord[i].begin(), ord[i].end(), nxt) - ord[i].begin();
best = max(best, pos - j);
}
}
cout << best << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
int n, m;
vector<pair<int, pair<int, int> > > adj[102];
bool czytaj_graf() {
scanf("%d %d", &n, &m);
for (int(k) = 0; (k) < (m); ++(k)) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
if (d % c) return false;
adj[a].push_back(make_pair(b, make_pair(c, d)));
adj[b].push_back(make_pair(a, make_pair(c, d)));
}
return true;
}
long long nwd(long long a, long long b) {
if (b == 0) return a;
return nwd(b, a % b);
}
long long nww(long long a, long long b) { return a / nwd(a, b) * b; }
int vis[102];
int num[102];
int numset[102];
int main() {
if (!czytaj_graf()) {
printf("NO");
return 0;
}
int proba = 0;
for (int(i) = 1; (i) <= (n); ++(i)) vis[i] = num[i] = numset[i] = 0;
for (int(i) = 1; (i) <= (n); ++(i)) {
if (vis[i]) continue;
if (adj[i].empty()) {
num[i] = 1;
continue;
}
int gcd = adj[i][0].second.first, lcm = adj[i][0].second.second;
int mnoznik;
for (mnoznik = 1; mnoznik * gcd <= lcm; ++mnoznik) {
if (lcm % (mnoznik * gcd)) continue;
++proba;
num[i] = mnoznik * gcd;
numset[i] = proba;
bool broken = false;
deque<int> q;
q.push_back(i);
while (!q.empty()) {
int v = q.front();
q.pop_front();
if (vis[v] == proba) continue;
vis[v] = proba;
for (typeof(adj[v].begin()) it = adj[v].begin(); it != adj[v].end();
it++) {
int w = it->first;
int g = it->second.first;
int l = it->second.second;
if ((num[v] % g) || (l % num[v])) {
broken = true;
goto breaker;
}
int shouldbenumw = l / num[v] * g;
if (nwd(num[v], shouldbenumw) != g ||
nww(num[v], shouldbenumw) != l) {
broken = true;
goto breaker;
}
if (numset[w] == proba) {
if (num[w] != shouldbenumw) {
broken = true;
goto breaker;
}
} else {
num[w] = shouldbenumw;
numset[w] = proba;
}
q.push_back(w);
}
}
breaker:
if (!broken) {
break;
}
}
if (mnoznik * gcd > lcm) {
printf("NO");
return 0;
}
}
printf("YES\n");
for (int(i) = 1; (i) <= (n); ++(i)) printf("%d ", num[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool palindrome(const string &s) {
int n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] != s[n - i - 1]) return false;
}
return true;
}
vector<pair<long long int, long long int>> fct_list;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (b.second < a.second);
}
void factors(long long int num) {
for (int i = 1; i * i <= num; i++) {
if (num % i == 0) {
if (num / i == i)
fct_list.push_back(make_pair(i, (num / i) - 1));
else {
fct_list.push_back(make_pair(i, (num / i) - 1));
fct_list.push_back(make_pair(num / i, (num / (num / i)) - 1));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n, x, y;
cin >> n >> x >> y;
long long int dif = y - x;
factors(dif);
long long int req = n - 2;
long long int cmn_dif = 0;
long long int dummy = -1;
sort(fct_list.begin(), fct_list.end(), sortbysec);
for (int i = 0; i < fct_list.size(); i++) {
if (fct_list[i].second <= req) {
cmn_dif = fct_list[i].first;
dummy = fct_list[i].second;
break;
}
}
for (int i = x; i <= y; i = i + cmn_dif) {
cout << i << " ";
}
req = req - dummy;
while (x - cmn_dif > 0 && req > 0) {
cout << x - cmn_dif << " ";
x = x - cmn_dif;
req--;
}
while (req > 0) {
cout << y + cmn_dif << " ";
y = y + cmn_dif;
req--;
}
cout << "\n";
fct_list.clear();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int first[100010], last[100010];
int q[100010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i, j;
int cnt = 0;
int n, k;
cin >> n >> k;
for (i = 0; i < n; i++) {
first[i] = INT_MAX;
last[i] = -1;
}
for (i = 0; i < k; i++) {
cin >> q[i];
q[i]--;
last[q[i]] = max(last[q[i]], i);
first[q[i]] = min(first[q[i]], i);
}
for (i = 0; i < n; i++) {
if (first[i] == INT_MAX) cnt++;
if (i < n - 1) {
if (first[i + 1] > last[i]) cnt++;
}
if (i > 0) {
if (first[i - 1] > last[i]) cnt++;
}
}
cout << cnt << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
const long long MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = 4 * atan((long double)1);
long long power_md(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res = (res % md * a % md) % md;
a = (a % md * a % md) % md;
n /= 2;
}
res %= md;
return res;
}
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res *= a;
a = a * a;
n /= 2;
}
return res;
}
long long abst(long long a) { return ((a < 0) ? (-1 * a) : (a)); }
class cmp_set {
public:
bool operator()(long long a, long long b) { return a > b; }
};
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) long long idx,
__attribute__((unused)) long long LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, long long idx, long long LINE_NUM, Head H,
Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long n;
cin >> n;
string s;
cin >> s;
if (n == 1) {
cout << 0 << "\n";
return 0;
}
long long oa[n + 1], ob[n + 1];
long long cnt = 0;
long long ma = n, mb = n;
for (long long i = n - 1; i >= 0; i--) {
oa[i] = ma;
ob[i] = mb;
if (s[i] == 'A')
ma = i;
else
mb = i;
}
for (long long i = n - 2; i >= 0; i--) {
if (s[i] == 'A') {
cnt += (oa[i] - i - 1);
if ((ob[i] > oa[i]) && (ob[i] < n)) cnt++;
} else {
cnt += (ob[i] - i - 1);
if ((oa[i] > ob[i]) && (oa[i] < n)) cnt++;
}
}
long long res = ((n * (n - 1))) / 2;
res -= cnt;
cout << res << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 7;
const int INF = 0x3f3f3f3f;
int vis[MAXN];
long long b[MAXN];
int main() {
ios::sync_with_stdio(false);
b[0] = 1;
for (long long i = 1; i <= 36; i++) {
b[i] = 3 * b[i - 1];
}
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
long long sum = 0;
for (int i = 36; i >= 0; i--) {
if (sum + b[i] < n) {
vis[i] = 1;
sum += b[i];
}
}
for (int i = 0; i <= 36; i++) {
if (vis[i] == 1) {
sum -= b[i];
} else {
sum += b[i];
break;
}
}
cout << sum << endl;
memset(vis, 0, sizeof(vis));
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1111], n, m, k, ans, p;
string s1, s2, c;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> m >> k;
for (int i = min(m, k); i < max(m, k); i++) ans += a[i];
for (int i = max(m, k); i <= n; i++) p += a[i];
for (int i = 1; i < min(m, k); i++) p += a[i];
cout << min(ans, p);
cin >> n;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct fri {
int i, num;
fri() { i = num = 0; }
fri(int x, int y) {
i = x;
num = y;
}
bool operator<(const fri &x) const { return i < x.i; }
};
int n, a[100005];
fri b[100005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &b[i].i);
b[i].num = i + 1;
}
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(b, b + n);
for (int i = 0; i < n; i++) {
printf("%d ", b[lower_bound(b, b + n, fri(a[i], 0)) - b].num);
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const int N = 100 + 5;
int n, a[N], ans;
int main() {
ios ::sync_with_stdio(0);
cin >> n;
if (!(n & 1) or n == 1) {
cout << -1 << '\n';
return 0;
}
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n - 1 >> 1; i >= 1; i--) {
int mx = max(a[i * 2], a[i * 2 + 1]);
if (mx <= 0) continue;
a[i] -= mx;
a[i * 2] -= mx;
a[i * 2 + 1] -= mx;
ans += mx;
}
cout << ans + (a[1] > 0 ? a[1] : 0) << '\n';
cerr << "Tooks " << (double)clock() / CLOCKS_PER_SEC << " seconds." << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1000000007;
long long dp[2][502][502];
int d1x[2] = {0, -1};
int d2x[2] = {0, 1};
char s[502][502];
int n, m;
int main() {
scanf("%d%d", &n, &m);
getchar();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char tt = getchar();
s[i][j] = tt;
}
getchar();
}
dp[0][0][n - 1] = 1;
if (s[0][0] != s[n - 1][m - 1]) {
puts("0");
return 0;
}
if ((m + n) & 1) {
int len = (m + n) / 2 - 1;
for (int i = 1; i <= len; i++) {
for (int j = 0; j <= min(i, n); j++) {
for (int k = min(0, n - 1 - i); k < n; k++) {
dp[i % 2][j][k] = 0;
if (s[j][i - j] != s[k][n + m - 2 - i - k]) continue;
for (int u = 0; u < 2; u++) {
for (int v = 0; v < 2; v++) {
int t1 = j + d1x[u], t2 = k + d2x[v];
if (t1 >= 0 && t1 < n && t2 >= 0 && t2 < n)
dp[i % 2][j][k] =
(dp[i % 2][j][k] + dp[(i - 1) % 2][t1][t2]) % Mod;
}
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i == j && len - i + 1 == m + n - 2 - len - j) ||
(i + 1 == j && len - i == m + n - 2 - len - j)) {
ans = (ans + dp[len % 2][i][j]) % Mod;
}
}
}
printf("%I64d\n", ans);
} else {
if (m + n == 2) {
puts("1");
return 0;
}
int len = (m + n) / 2 - 2;
for (int i = 1; i <= len; i++) {
for (int j = 0; j <= min(i, n); j++) {
for (int k = min(n - i - 1, 0); k < n; k++) {
dp[i % 2][j][k] = 0;
if (s[j][i - j] != s[k][n + m - 2 - i - k]) continue;
for (int u = 0; u < 2; u++) {
for (int v = 0; v < 2; v++) {
int t1 = j + d1x[u], t2 = k + d2x[v];
if (t1 >= 0 && t1 < n && t2 >= 0 && t2 < n)
dp[i % 2][j][k] =
(dp[i % 2][j][k] + dp[(i - 1) % 2][t1][t2]) % Mod;
}
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i == j && len - i + 2 == m + n - 2 - len - j) ||
(i + 2 == j && len - i == m + n - 2 - len - j)) {
ans = (ans + dp[len % 2][i][j]) % Mod;
} else if ((i + 1 == j && len - i + 1 == m + n - 2 - len - j) ||
(i - 1 == j && len - i - 1 == m + n - 2 - len - j)) {
ans = (ans + 2 * dp[len % 2][i][j]) % Mod;
}
}
}
printf("%I64d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int x1, y1, r1, x2, y2, r2;
scanf("%d %d %d %d %d %d", &x1, &y1, &r1, &x2, &y2, &r2);
double ans;
ans = (sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) - r1 - r2) / 2;
if (ans < 0)
if (r1 > r2)
ans = (r1 - r2 - sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))) / 2;
else
ans = ans =
(r2 - r1 - sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))) / 2;
if (ans < 0)
printf("0.000000000");
else
printf("%lf", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 1)
cout << "-1" << endl;
else {
for (int i = 0; i < n - 1; i++) cout << "5";
cout << "4" << endl;
}
}
}
| 1 |
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
ll T=1;
cin>>T;
while(T--)
{
ll i=0,j=0,ans=0,x=0,y=0,z=0;
ll n,k=0,m=0,mn=INT_MAX,mx=INT_MIN;
cin>>n;
x=9;
ll a[n];
if(n==1)
{
cout<<9<<endl;
continue;
}
a[0]=9;
a[1]=8;
for(i=2;i<n;i++)
{
a[i]=x;
x++;
x%=10;
}
for(i=0;i<n;i++)
cout<<a[i];
cout<<endl;
}
return 0;
}
/*test cases
2
8 38
7 8 19 7 8 7 10 20
4 5
2 10 4 9
*/
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
inline int read() {
char c = getchar();
int t = 0, f = 1;
while ((!isdigit(c)) && (c != EOF)) {
if (c == '-') f = -1;
c = getchar();
}
while ((isdigit(c)) && (c != EOF)) {
t = (t << 3) + (t << 1) + (c ^ 48);
c = getchar();
}
return t * f;
}
int n, q, p[maxn];
vector<int> g[maxn];
int sz[maxn], son[maxn], dep[maxn];
void dfs(int u) {
sz[u] = 1;
dep[u] = dep[p[u]] + 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
dfs(v);
sz[u] += sz[v];
if (sz[son[u]] < sz[v]) son[u] = v;
}
}
int top[maxn], dfn, id[maxn];
void dfs2(int u, int tp) {
dfn++;
top[u] = tp;
id[u] = dfn;
if (son[u]) {
dfs2(son[u], tp);
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == son[u]) continue;
dfs2(v, v);
}
}
int sum[maxn << 2], mx[maxn << 2], tag[maxn << 2];
inline void pushup(int rt) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
mx[rt] = max(mx[rt << 1 | 1], sum[rt << 1 | 1] + mx[rt << 1]);
}
inline void build(int rt, int l, int r) {
if (l == r) {
sum[rt] = -1;
mx[rt] = -1;
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
inline void pushdown(int rt, int l, int r) {
if (!tag[rt]) return;
int mid = (l + r) >> 1;
sum[rt << 1] = -(mid - l + 1);
mx[rt << 1] = -1;
tag[rt << 1] = 1;
sum[rt << 1 | 1] = -(r - mid);
mx[rt << 1 | 1] = -1;
tag[rt << 1 | 1] = 1;
tag[rt] = 0;
}
inline void modify(int rt, int l, int r, int x, int y, int val) {
if (x <= l && r <= y) {
sum[rt] += val;
mx[rt] += val;
return;
}
pushdown(rt, l, r);
int mid = (l + r) >> 1;
if (x <= mid) modify(rt << 1, l, mid, x, y, val);
if (y > mid) modify(rt << 1 | 1, mid + 1, r, x, y, val);
pushup(rt);
}
inline void add(int u, int val) { modify(1, 1, n, id[u], id[u], val); }
inline void remove(int rt, int l, int r, int x, int y) {
if (x <= l && r <= y) {
sum[rt] = -(r - l + 1);
mx[rt] = -1;
tag[rt] = 1;
return;
}
pushdown(rt, l, r);
int mid = (l + r) >> 1;
if (x <= mid) remove(rt << 1, l, mid, x, y);
if (y > mid) remove(rt << 1 | 1, mid + 1, r, x, y);
pushup(rt);
}
inline void change(int u) { remove(1, 1, n, id[u], id[u] + sz[u] - 1); }
int tmp, suf;
inline void tquery(int rt, int l, int r, int x, int y) {
if (x <= l && r <= y) {
tmp = max(tmp, suf + mx[rt]);
suf += sum[rt];
return;
}
pushdown(rt, l, r);
int mid = (l + r) >> 1;
if (y > mid) tquery(rt << 1 | 1, mid + 1, r, x, y);
if (x <= mid) tquery(rt << 1, l, mid, x, y);
}
inline void query(int u) {
suf = 0;
tmp = -1;
while (top[u]) {
tquery(1, 1, n, id[top[u]], id[u]);
u = p[top[u]];
}
}
int val[maxn];
inline void del(int u) {
val[u] = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
del(v);
}
}
inline int find(int u) {
int tmp = 0, sum = 0;
while (u) {
sum += val[u];
tmp = max(tmp, sum + dep[u]);
u = p[u];
}
return tmp;
}
signed main() {
n = read(), q = read();
for (int i = 2; i <= n; i++) {
p[i] = read();
g[p[i]].push_back(i);
}
dfs(1);
{
dfs2(1, 1);
build(1, 1, n);
while (q--) {
int t = read(), v = read();
if (t == 1) {
add(v, 1);
}
if (t == 2) {
change(v);
query(v);
int ans = -tmp - 1;
add(v, ans);
}
if (t == 3) {
query(v);
if (tmp >= 0)
puts("black");
else
puts("white");
}
}
return 0;
}
}
| 12 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast", "unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long inf = numeric_limits<long long>::max() / 2;
const long double eps = 1e-9;
const long double pi = acos(-1);
inline void solve(), read();
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read();
solve();
return 0;
}
long long n, m;
set<pair<long long, long long> > g;
inline void solve() {
for (long long i = 0; i < 100; i++) {
vector<long long> a(n);
iota((a).begin(), (a).end(), 0);
random_shuffle((a).begin(), (a).end());
long long ok = 1;
for (long long i = 0; i < m; i++) {
if (g.count({a[i % n], a[(i + 1) % n]})) {
ok = 0;
break;
}
}
if (!ok) {
continue;
}
for (long long i = 0; i < m; i++) {
cout << a[i % n] + 1 << " " << a[(i + 1) % n] + 1 << "\n";
}
return;
}
cout << -1 << "\n";
}
inline void read() {
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long v, u;
cin >> v >> u;
--v, --u;
g.insert({v, u});
g.insert({u, v});
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int p[300005];
int pp[300005];
int q;
struct Node {
int sum, sfx;
};
Node operator+(Node x, Node y) {
Node ret;
ret.sum = x.sum + y.sum;
ret.sfx = max(y.sfx, y.sum + x.sfx);
return ret;
}
class ST {
public:
vector<Node> tree;
int ts;
ST(int N) {
for (ts = 1; ts < N; ts <<= 1)
;
tree.resize(ts << 1);
ts--;
}
void add(int x, Node v) {
x += ts;
tree[x].sum += v.sum;
tree[x].sfx = tree[x].sum;
for (x >>= 1; x > 0; x >>= 1) tree[x] = tree[x + x] + tree[x + x + 1];
}
int MAX() { return tree[1].sfx; }
};
int main(void) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
pp[p[i]] = i;
}
ST st(300005);
int x = n + 1;
for (int i = 1; i <= n; i++) {
while (st.MAX() <= 0) {
x--;
st.add(pp[x], {1, 1});
}
cout << x << " ";
scanf("%d", &q);
st.add(q, {-1, -1});
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int x[10002], y[10002];
int main() {
int cnt = 0, i, a, b, c, sm = 0, v = 1;
cin >> a;
c = a;
if (a == 0) {
cout << "a";
return 0;
}
while (c > 0) {
sm = 0;
i = 0;
while (1) {
if (sm + i > c) {
c = c - sm;
break;
}
sm += i;
i++;
x[v] = i;
}
v++;
}
for (i = 1; i < v; i++) {
for (int j = 1; j <= x[i]; j++) {
printf("%c", 96 + i);
}
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.