solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 9;
const long long MAXN = 1e6 + 1;
const long long MAXN1 = 1 << 10;
const long long MAXN2 = 1e6 + 7;
const long long MOD = 998244353;
const long long PW = 31;
const long long BLOCK = 317;
void solve();
mt19937 mt(1e9 + 7);
signed main() {
srand('a' + 'l' + 'e' + 'x' + 'X' + '5' + '1' + '2');
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q = 1;
if (0) cin >> q;
while (q--) {
solve();
}
}
long long bin_pow(long long a, long long k) {
if (k == 0) return 1;
if (k % 2 == 0) return bin_pow(a * a % MOD, k / 2);
return bin_pow(a, k - 1) * a % MOD;
}
int cnt[MAXN], bp[MAXN];
void solve() {
int n;
cin >> n;
vector<vector<int>> v(n);
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
for (int j = 0; j < k; ++j) {
int a;
cin >> a;
++cnt[a];
v[i].emplace_back(a);
}
}
long long ans = 0, kek;
for (auto &i : v) {
if (bp[i.size()] == 0) bp[i.size()] = bin_pow(i.size(), MOD - 2);
long long kek = bp[i.size()];
for (auto &j : i) {
ans = (ans + kek * cnt[j]) % MOD;
}
}
cout << ans * bin_pow(n, 2 * MOD - 4) % MOD;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int MOD = 1e9 + 7;
struct segment {
int l, r, to_add;
pair<int, int> sum;
int size() { return r - l; }
int unity(int _l, int _r) { return max(0 * l, min(_r, r) - max(_l, l)); }
segment(int _l = 0, int _r = 0) {
l = _l;
r = _r;
sum = pair<int, int>(0, 0);
to_add = 0;
}
} seg[N << 2];
int n, h[N], lp[N], rp[N], ans[N];
vector<pair<int, int> > que[N], g[N];
vector<int> st;
int dfs(int, int = 0, int = 0, int = 0);
void build(int, int, int = 1);
void add(int, int, int = 1);
pair<int, int> get(int, int, int = 0, int = 1);
void update(int);
pair<int, int> get(int);
void answer(int, int = 0);
pair<int, int> calc(pair<int, int>, int, int);
pair<int, int> _pair_sum(pair<int, int>, pair<int, int>);
int _sum(int, int);
int _mul(int, int);
int _neg(int);
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int v, u, w;
cin >> v >> u >> w;
v--;
u--;
g[v].push_back({u, w});
g[u].push_back({v, w});
}
dfs(0);
build(0, n);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
que[v].push_back({u, i});
}
answer(0);
for (int i = 0; i < q; i++) cout << ans[i] << endl;
}
int dfs(int v, int pv, int d, int cur_pos) {
h[v] = d;
lp[v] = cur_pos;
rp[v] = cur_pos + 1;
st.push_back(v);
for (auto [u, w] : g[v])
if (u != pv) rp[v] = dfs(u, v, _sum(d, w), rp[v]);
return rp[v];
}
void answer(int v, int pv) {
int sigma_t = _neg(get(0).second);
for (auto [u, query] : que[v])
ans[query] = _sum(sigma_t, _mul(2, get(u).second));
for (auto [u, w] : g[v])
if (u != pv) {
add(0, w);
add(u, _mul(_neg(2), w));
answer(u, v);
add(u, _mul(2, w));
add(0, _mul(_neg(1), w));
}
}
void build(int l, int r, int v) {
seg[v] = segment(l, r);
if (r - l == 1) {
seg[v].sum = {h[st[l]], _mul(h[st[l]], h[st[l]])};
return;
}
int med = (l + r) / 2;
build(l, med, v << 1);
build(med, r, v << 1 | 1);
update(v);
}
void add(int ver, int val, int v) {
int l = lp[ver];
int r = rp[ver];
if (seg[v].unity(l, r) == 0) return;
if (seg[v].unity(l, r) == seg[v].size()) {
seg[v].to_add = _sum(seg[v].to_add, val);
seg[v].sum = calc(seg[v].sum, seg[v].size(), val);
return;
}
add(ver, val, v << 1);
add(ver, val, v << 1 | 1);
update(v);
seg[v].sum = calc(seg[v].sum, seg[v].size(), seg[v].to_add);
}
pair<int, int> get(int ver) { return get(lp[ver], rp[ver]); }
pair<int, int> get(int l, int r, int par_sum, int v) {
if (seg[v].unity(l, r) == 0) return pair<int, int>(0, 0);
if (seg[v].unity(l, r) == seg[v].size())
return calc(seg[v].sum, seg[v].size(), par_sum);
pair<int, int> lc = get(l, r, _sum(par_sum, seg[v].to_add), v << 1);
pair<int, int> rc = get(l, r, _sum(par_sum, seg[v].to_add), v << 1 | 1);
return _pair_sum(lc, rc);
}
void update(int v) {
seg[v].sum = _pair_sum(seg[v << 1].sum, seg[v << 1 | 1].sum);
}
pair<int, int> calc(pair<int, int> v, int cnt, int d) {
auto [A, B] = v;
int C = _mul(d, cnt);
int sum_1 = _sum(A, C);
int sum_2 = _sum(_sum(B, _mul(d, C)), _mul(_mul(2, d), A));
return pair<int, int>(sum_1, sum_2);
}
int _sum(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
int _mul(int a, int b) { return 1LL * a * b % MOD; }
int _neg(int x) {
return MOD - x;
x = -x;
while (x < 0) x += MOD;
return x;
}
pair<int, int> _pair_sum(pair<int, int> a, pair<int, int> b) {
return pair<int, int>(_sum(a.first, b.first), _sum(a.second, b.second));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int BSer(long long int arr[], long long int n, long long int ser) {
long long int start = 0, end = n - 1;
long long int pos = -2;
while (start <= end) {
long long int mid = (start + end) / 2;
if (arr[mid] == ser) {
start = mid + 1;
} else if (arr[mid] < ser) {
pos = mid;
start = mid + 1;
} else if (arr[mid] > ser) {
end = mid - 1;
}
}
return pos;
}
int main() {
long long int n, m, ta, tb, k;
cin >> n >> m >> ta >> tb >> k;
long long int a[n], b[m], temp;
for (long long int i = 0; i < n; ++i) {
cin >> temp;
a[i] = temp + ta;
}
for (long long int i = 0; i < m; ++i) {
cin >> b[i];
}
long long int calc[n];
fill_n(calc, n, -5);
for (long long int i = 0; i < n; ++i) {
if (k - i < 0) break;
if (a[i] < b[0]) {
if (k - i < m)
calc[i] = b[k - i];
else
calc[i] = -1;
} else if (a[i] > b[m - 1]) {
calc[i] = -1;
} else {
long long int ptr = BSer(b, m, a[i]);
if (ptr != -2) {
if (ptr + k + 1 - i >= m) {
calc[i] = -1;
} else {
calc[i] = b[ptr + k + 1 - i];
}
} else {
calc[i] = b[k - 1];
}
}
}
if (k >= n) {
cout << "-1";
return 0;
}
long long int ans = -1;
for (long long int i = 0; i < n; ++i) {
if (calc[i] == -5) break;
if (calc[i] == -1) {
cout << "-1";
return 0;
} else {
if (calc[i] > ans) {
ans = calc[i];
}
}
}
cout << ans + tb;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool vis[100005];
int c[100005];
vector<int> v[100005];
vector<pair<int, int> > p;
bool t = 1;
void dfs(int u, int col) {
vis[u] = 1;
if (c[u] != col) t = 0;
for (int j = 0; j < v[u].size(); j++) {
if (!vis[v[u][j]]) dfs(v[u][j], col);
}
}
bool check(int x) {
int i, j, k;
bool ans = 1;
vis[x] = 1;
for (i = 0; i < v[x].size(); i++) {
t = 1;
dfs(v[x][i], c[v[x][i]]);
if (t == 0) ans = 0;
}
return ans;
}
int main() {
int N, i, j, k;
cin >> N;
for (i = 0; i < N - 1; i++) {
int x, y;
cin >> x >> y;
p.push_back(make_pair(x, y));
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= N; i++) cin >> c[i];
int a = -1, b = -1;
for (i = 0; i < N - 1; i++) {
if (c[p[i].first] != c[p[i].second]) {
a = p[i].first;
b = p[i].second;
break;
}
}
if (a == -1) {
cout << "YES" << endl;
cout << "1\n";
return 0;
}
bool flag1 = check(a);
memset(vis, 0, sizeof(vis));
bool flag2 = check(b);
if (flag1 || flag2) {
cout << "YES\n";
if (flag1)
cout << a << endl;
else
cout << b << endl;
} else
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, dem1, dema1, dem2, dema2, dem3, dema3, c1, c2, c3, sai1, sai2,
sai3, moc1, moc2, moc3;
double ad1, a[10001], ad2, ad3, bd1, bd2, bd3, a1[1111], a2[1111], a3[1111];
int main() {
std::ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
ad1 = (a[2] - a[1]);
bd1 = a[1] - ad1;
ad2 = a[3] - a[2];
bd2 = a[2] - ad2 * 2;
ad3 = (a[3] - a[1]) / 2;
bd3 = a[1] - ad3;
for (int i = 1; i <= n; i++) {
if (i * ad1 + bd1 == a[i]) {
a1[dema1] = i;
dema1++;
} else {
if (c1 == 0) {
c1++;
moc1 = a[i] - i * ad1;
dem1++;
} else {
if (i * ad1 + moc1 != a[i]) {
sai1 = 1;
} else {
dem1++;
}
}
}
if (i * ad2 + bd2 == a[i]) {
a2[dema2] = i;
dema2++;
} else {
if (c2 == 0) {
c2++;
moc2 = a[i] - i * ad2;
dem2++;
} else {
if (i * ad2 + moc2 != a[i]) {
sai2 = 1;
} else {
dem2++;
}
}
}
if (i * ad3 + bd3 == a[i]) {
a3[dema3] = i;
dema3++;
} else {
if (c3 == 0) {
c3++;
moc3 = a[i] - i * ad3;
dem3++;
} else {
if (i * ad3 + moc3 != a[i]) {
sai3 = 1;
} else {
dem3++;
}
}
}
}
if ((dem1 + dema1 == n && dem1 != 0) || (dem2 + dema2 == n && dem2 != 0) ||
(dem3 + dema3 == n && dem3 != 0)) {
cout << "Yes";
return 0;
}
cout << "No";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
long long m = -1, index = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] - (i + 1) > m) {
m = a[i] - i - 1;
}
}
if (m > 0)
cout << m << endl;
else
cout << 0 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 17, M = 1 << N;
int dp[M][2][2];
bool a[M];
int n, m;
inline void update(int &a, int b, int c, int d) {
if (b == -1 || c == -1) return;
a = max(a, b + c + d);
}
void merge(int a[2][2], int b[2][2], int cc[2][2]) {
int c[2][2];
memset(c, -1, sizeof c);
for (int i1 = 0; i1 < 2; ++i1)
for (int i2 = 0; i2 < 2; ++i2)
for (int j1 = 0; j1 < 2; ++j1)
for (int j2 = 0; j2 < 2; ++j2) {
for (int res = 0; res < 8; ++res) {
int o[] = {(res >> 2) & 1, (res >> 1) & 1, res & 1};
int k1 = -1, k2 = -1;
int tmp, tmp2;
int cost = 0;
if (o[0]) {
k1 = i1;
tmp = j1;
} else {
k1 = j1;
tmp = i1;
}
if (i1 || j1) ++cost;
if (o[1]) {
tmp2 = i2;
} else {
tmp2 = j2;
}
if (i2 || j2) ++cost;
if (o[2])
k2 = tmp;
else
k2 = tmp2;
if (tmp || tmp2) ++cost;
update(c[k1][k2], a[i1][i2], b[j1][j2], cost);
if (c[k1][k2] == 7) {
;
}
}
}
memcpy(cc, c, sizeof(c));
}
int main(int argc, char const *argv[]) {
memset(dp, -1, sizeof dp);
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int x;
scanf("%d", &x);
a[--x] = 1;
}
for (int i = 0; i < M; i += 2) {
if (a[i] || a[i + 1])
dp[i][a[i]][a[i + 1]] = dp[i][a[i + 1]][a[i]] = 1;
else
dp[i][0][0] = 0;
}
for (int k = 0; k < (1 << n); ++k)
;
for (int i = 2; i <= n; ++i) {
;
int step = 1 << i, seg = 1 << (i - 1);
for (int j = 0; j < (1 << n); j += step) {
;
merge(dp[j], dp[j + seg], dp[j]);
}
for (int k = 0; k < (1 << n); ++k)
;
}
int ans =
max(dp[0][0][0], 1 + max(dp[0][0][1], max(dp[0][1][0], dp[0][1][1])));
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const int32_t mod = 1e9 + 7;
const long long INF = 1e18;
const long long N = 2e5 + 5, M = 103;
bool cmp(const vector<long long>& a, const vector<long long>& b) {
if (a[0] > b[0]) return 1;
if (a[0] == b[0] && a[1] >= b[1]) return 1;
return 0;
}
long long occurance(string patt, string text) {
long long cnt = -1;
size_t f = -1;
do {
++cnt;
f = text.find(patt, f + 1);
} while (f != string::npos);
return cnt;
}
void solve() {
long long n;
cin >> n;
string s, t = "abacaba";
cin >> s;
long long num = occurance(t, s);
if (num > 1) {
cout << "NO\n";
return;
}
if (num == 1) {
for (char& c : s) {
if (c == '?') c = 'z';
}
cout << "YES\n" << s << "\n";
return;
}
for (long long i = 0; i <= n - 7; ++i) {
long long j = i;
string temp = s;
while (j - i <= 6 && (temp[j] == '?' || temp[j] == t[j - i])) {
if (temp[j] == '?') temp[j] = t[j - i];
++j;
}
if (j - i == 7) {
num = occurance(t, temp);
if (num == 1) {
for (char& c : temp) {
if (c == '?') c = 'z';
}
cout << "YES\n" << temp << "\n";
return;
}
}
}
cout << "NO\n";
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pci = pair<char, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
const ll infll = 1e18 + 3;
const int maxn = 1e6 + 77;
const int nmax = 1e6 + 77;
const ll basell = 1e18 + 3;
const int mod = 1e9 + 7;
const ld eps = 1e-7;
const int inf = 1009000999;
const int nv = 100100;
const int baseint = 1000200013;
const ld PI = acos(-1.0);
inline bool EQ(ld a, ld b) { return fabs(a - b) < 1e-9; }
int n;
int ask(int x) {
cout << "? " << (x % n) + 1 << '\n';
int a;
cin >> a;
return a;
}
void ans(int x) {
cout << "! " << (x % n) + 1 << '\n';
exit(0);
}
int sgn(int x) {
if (x == 0) {
return 0;
}
return x < 0 ? -1 : 1;
}
int inline solve() {
cin >> n;
int m = n / 2;
int s = ask(0);
int t = ask(m);
if (s == t) ans(0);
if ((s - t) % 2 != 0) {
return cout << "! -1\n", 0;
}
int l = 0, r = m;
while (r - l > 1) {
int mid = (r + l) / 2;
int a = ask(mid);
int b = ask(mid + m);
if (a == b) ans(mid);
if (sgn(a - b) != sgn(s - t)) {
r = mid;
} else {
l = mid;
}
}
if (ask(l) == ask(l + m)) {
ans(l);
} else {
ans(r);
}
}
int32_t main() {
solve();
return 0;
}
| 6 |
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
string a, b;
int dp[1010][1010] = {0};
int main(int argc, char *argv[]) {
int t;
cin >> t;
while (t--) {
int max = 0;
cin >> a;
cin >> b;
int m = a.size();
int n = b.size();
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (a[i - 1] == b[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (dp[i][j] > max) {
max = dp[i][j];
}
}
}
for (int i = 0; i < 1010; i++) {
for (int j = 0; j < 1010; j++) {
dp[i][j] = 0;
}
}
cout << m + n - (2 * max) << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long a[N];
void solve() {
long long n, t;
cin >> n >> t;
set<long long> s;
for (int i = 1; i <= n; i++) s.insert(i);
while (t--) {
long long a, b;
cin >> a >> b;
s.erase(a);
s.erase(b);
}
cout << n - 1 << endl;
for (int i = 1; i <= n; i++) {
if (i != *s.begin()) cout << i << " " << *s.begin() << endl;
}
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 100001, mod = 1000000007;
vector<int64_t> factorial(N), inverse_factorial(N);
bool is_lucky(int64_t n) {
while (n) {
if (n % 10 != 4 and n % 10 != 7) {
return false;
}
n /= 10;
}
return true;
}
int64_t power(int64_t x, int64_t n) {
int64_t res = 1;
while (n) {
if (n & 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
n >>= 1;
}
return res;
}
int64_t nCr(int64_t n, int64_t r) {
if (r > n or r < 0) {
return 0;
}
int64_t res = 1;
res *= factorial[n];
res %= mod;
res *= inverse_factorial[r];
res %= mod;
res *= inverse_factorial[n - r];
res %= mod;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
factorial[0] = 1;
inverse_factorial[0] = power(factorial[0], mod - 2);
for (int64_t i = 1; i < N; i++) {
factorial[i] = (factorial[i - 1] * i) % mod;
inverse_factorial[i] = power(factorial[i], mod - 2);
}
int64_t n, k;
cin >> n >> k;
int64_t unlucky = 0;
vector<int64_t> a(n), lucky_numbers;
for (int64_t i = 0; i < n; i++) {
cin >> a[i];
if (is_lucky(a[i])) {
lucky_numbers.emplace_back(a[i]);
} else {
unlucky++;
}
}
sort(lucky_numbers.begin(), lucky_numbers.end());
lucky_numbers.resize(unique(lucky_numbers.begin(), lucky_numbers.end()) -
lucky_numbers.begin());
lucky_numbers.insert(lucky_numbers.begin(), 0);
int64_t lucky = lucky_numbers.size();
vector<int64_t> c(lucky + 1, 0);
for (int64_t i = 0; i < n; i++) {
if (is_lucky(a[i])) {
auto x = lower_bound(lucky_numbers.begin(), lucky_numbers.end(), a[i]) -
lucky_numbers.begin();
c[x]++;
}
}
vector<vector<int64_t>> dp(lucky + 1, vector<int64_t>(lucky + 1, 0));
dp[0][0] = 1;
for (int64_t i = 1; i <= lucky; i++) {
dp[i][0] = 1;
for (int64_t j = 1; j <= lucky; j++) {
dp[i][j] = (dp[i - 1][j] + ((dp[i - 1][j - 1] * c[i]) % mod)) % mod;
}
}
int64_t ways = 0;
for (int64_t i = 0; i <= lucky; i++) {
int64_t cur = (dp[lucky][i] * nCr(unlucky, k - i)) % mod;
ways = (ways + cur) % mod;
}
cout << ways;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long n, k, p[N];
int m, ans, now = 1;
int tt;
struct SegmentTree {
long long maxn, minn, tag;
} t[N << 2];
inline void build(int o, int L, int R) {
if (L == R) {
t[o].maxn = t[o].minn = p[L];
return;
}
int M = (L + R) >> 1, lc = o << 1, rc = (o << 1) + 1;
build(lc, L, M);
build(rc, M + 1, R);
t[o].maxn = max(t[lc].maxn, t[rc].maxn);
t[o].minn = min(t[lc].minn, t[rc].minn);
}
inline void pushdown(int o, int L, int R) {
if (!t[o].tag) return;
int lc = o << 1, rc = (o << 1) + 1;
t[lc].maxn += t[o].tag;
t[lc].minn += t[o].tag;
t[lc].tag += t[o].tag;
t[rc].maxn += t[o].tag;
t[rc].minn += t[o].tag;
t[rc].tag += t[o].tag;
t[o].tag = 0;
}
inline long long query(int o, int L, int R, int x) {
if (L == R) return t[o].maxn;
int M = (L + R) >> 1, lc = o << 1, rc = (o << 1) + 1;
pushdown(o, L, R);
if (x <= M)
return query(lc, L, M, x);
else
return query(rc, M + 1, R, x);
}
inline int Find(int o, int L, int R, long long x) {
if (L == R) return L;
int M = (L + R) >> 1, lc = o << 1, rc = (o << 1) + 1;
pushdown(o, L, R);
if (t[rc].minn <= x)
return Find(rc, M + 1, R, x);
else
return Find(lc, L, M, x);
}
inline void update(int o, int L, int R, int l, int r, int v) {
if (l <= L && R <= r) {
t[o].maxn += v;
t[o].minn += v;
t[o].tag += v;
return;
}
int M = (L + R) >> 1, lc = o << 1, rc = (o << 1) + 1;
pushdown(o, L, R);
if (l <= M) update(lc, L, M, l, r, v);
if (r > M) update(rc, M + 1, R, l, r, v);
t[o].maxn = max(t[lc].maxn, t[rc].maxn);
t[o].minn = min(t[lc].minn, t[rc].minn);
}
int main() {
scanf("%lld%d%lld", &n, &m, &k);
for (register int i = 1; i <= m; i++) scanf("%lld", &p[i]);
build(1, 1, m);
while (now != m + 1) {
long long t = query(1, 1, m, now);
long long r = ((t - 1) / k + 1) * k;
int pos = Find(1, 1, m, r);
update(1, 1, m, 1, m, -(pos - now + 1));
now = pos + 1;
ans++;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[30][2], t = 0;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
cin >> a[i][j];
}
}
for (int r = 0; r < n; r++) {
for (int k = 0; k < n; k++) {
if (a[r][0] == a[k][1]) t++;
}
}
cout << t;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[300005];
int cnt[600005][2];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
int len = strlen(s);
int flag1 = 0, flag2 = 0, jian = 0;
for (int j = 0; j < len; j++) {
if (s[j] == '(')
jian++;
else
jian--;
if (jian < 0) flag1 = 1;
}
jian = 0;
for (int j = len - 1; j >= 0; j--) {
if (s[j] == '(')
jian++;
else
jian--;
if (jian > 0) flag2 = 1;
}
if (!flag1) cnt[jian + 300000][0]++;
if (!flag2) cnt[jian + 300000][1]++;
}
long long ans = 0;
ans += (long long)cnt[300000][0] * cnt[300000][1];
for (int i = 1; i <= 300000; i++) {
ans += (long long)cnt[300000 - i][0] * cnt[300000 + i][1];
ans += (long long)cnt[300000 - i][1] * cnt[300000 + i][0];
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s[8] = {"S", "M", "L", "XL", "XXL", "XXXL"};
int a[8], b[8], c[1 << 17][2];
int buf[8][2];
int cal(string st) {
for (int i = 0; i < 6; ++i)
if (s[i] == st) return i;
}
int main() {
int n;
string t;
memset(c, -1, sizeof(c));
for (int i = 0; i < 6; ++i) scanf("%d", &a[i]);
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
cin >> t;
int pos = t.find(",", 0);
if (pos == string::npos) {
int id = cal(t);
if (--a[id] < 0)
return 0 * puts("NO");
else
c[i][0] = id;
} else {
int id = cal(t.substr(0, pos));
++b[id];
c[i][1] = id;
}
}
for (int i = 0; i < 5; ++i) {
if (b[i]) {
int imin = min(b[i], a[i]);
a[i] -= imin, b[i] -= imin;
buf[i][0] = imin;
imin = min(b[i], a[i + 1]);
a[i + 1] -= imin;
b[i] -= imin;
buf[i][1] = imin;
if (b[i]) return 0 * puts("NO");
}
}
puts("YES");
for (int i = 0; i < n; ++i) {
if (c[i][0] != -1)
cout << s[c[i][0]] << endl;
else {
if (buf[c[i][1]][0] > 0) {
--buf[c[i][1]][0];
cout << s[c[i][1]] << endl;
} else {
--buf[c[i][1]][1];
cout << s[c[i][1] + 1] << endl;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10000 + 100;
const int inf = 0x3fffffff;
int n, p;
char str[MAXN];
int main() {
while (~scanf("%d%d", &n, &p)) {
scanf("%s", str);
int len = strlen(str);
int flag = 0;
int pos = len - 1;
for (int i = len - 1; i >= 0; i--) {
int x = str[i] - 'a' + 1;
if (i >= 2) {
int l = str[i - 2] - 'a' + 1;
int r = str[i - 1] - 'a' + 1;
for (int k = x + 1; k <= p; k++)
if (k != l && k != r) {
flag = 1;
break;
}
if (flag) break;
pos = i - 1;
} else if (i == 1) {
int l = str[i - 1] - 'a' + 1;
for (int k = x + 1; k <= p; k++)
if (k != l) {
flag = 1;
break;
}
if (flag) break;
pos = i - 1;
} else {
if (x != p) {
flag = 1;
break;
}
pos = i - 1;
}
}
if (pos == -1) {
printf("NO\n");
continue;
}
if (pos == 0)
str[pos] = (str[pos] - 'a' + 1) + 'a';
else if (pos == 1) {
int l = str[pos - 1] - 'a';
int x = str[pos] - 'a';
for (int k = x + 1; k < p; k++)
if (k != l) {
str[pos] = k + 'a';
break;
}
} else {
int x = str[pos] - 'a';
int l = str[pos - 2] - 'a';
int r = str[pos - 1] - 'a';
for (int k = x + 1; k < p; k++)
if (k != l && k != r) {
str[pos] = k + 'a';
break;
}
}
pos++;
for (int i = pos; i < len; i++) {
if (i == 1) {
int l = str[i - 1] - 'a';
for (int k = 0; k < p; k++)
if (k != l) {
str[i] = k + 'a';
break;
}
} else {
int l = str[i - 2] - 'a';
int r = str[i - 1] - 'a';
for (int k = 0; k < p; k++)
if (k != l && k != r) {
str[i] = k + 'a';
break;
}
}
}
printf("%s\n", str);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5 + 1;
const double PI = acos(-1);
int n;
long double tan1[100000], x[nmax], y[nmax];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
tan1[i] = atan2(y[i], x[i]);
}
sort(tan1, tan1 + n);
long double mi = (tan1[n - 1] - tan1[0]) / PI * 180.0;
for (int i = 0; i <= n; i++)
mi = min(mi, 360.0 - (tan1[i] - tan1[i - 1]) / PI * 180.0);
cout << setprecision(6) << fixed << mi;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int scale(char c) {
if (c <= '9' && c >= '0') return c - '0';
if (c <= 'Z' && c >= 'A') return c - 'A' + 1;
return c - 'a' + 1;
}
const int inf = 1e8 + 5;
int main() {
int n;
cin >> n;
vector<int> v(2 * n);
for (int i = 0; i < 2 * n; ++i) cin >> v[i];
sort(v.begin(), v.end());
int ans = inf;
for (int i = 0; i < 2 * n; i++) {
for (int j = i + 1; j < 2 * n; j++) {
vector<int> tm;
for (int k = 0; k < 2 * n; ++k) {
if (k != i && k != j) tm.push_back(v[k]);
}
int tmp = 0;
for (int k = 0; k < (int)tm.size() - 1; k += 2)
tmp += abs(tm[k] - tm[k + 1]);
ans = min(ans, tmp);
}
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
vector<long long> a;
cin >> n;
long long i = 0;
long long tmp;
long long sum = 0;
sum = 0;
for (i = 0; i < n; i++) {
cin >> tmp;
a.push_back(tmp);
sum += tmp;
}
sort(a.begin(), a.end());
cin >> m;
long long ans = 0;
for (i = 0; i < m; i++) {
cin >> tmp;
cout << sum - a[n - tmp] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acosl(-1.);
int main() {
int n, aux;
long double r, l, arg, arg2, S, Ss;
cin >> n >> r;
aux = n / 2;
arg = aux - 1;
arg *= PI;
arg /= n;
arg2 = PI;
arg2 /= n;
S = (r * cosl(arg2)) * (r * sinl(arg2));
S *= n;
l = 2 * (r * sinl(arg2));
Ss = l * l;
Ss /= 4;
Ss *= tanl(arg);
Ss *= n;
cout << setprecision(15) << fixed << S - Ss;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, x[1 << 22], y[100005 * 10], ta;
void go(int a) {
if (x[a]) return;
x[a] = ta;
for (int b = (0); b < (22); b++)
if (!(a & (1 << b))) go(a | (1 << b));
}
int main() {
scanf("%d", &n);
for (int a = (0); a < (n); a++) {
scanf("%d", &ta);
y[a] = ta ^ ((1 << 22) - 1);
go(ta);
}
for (int a = (0); a < (n); a++) {
ta = -1;
if (x[y[a]]) ta = x[y[a]];
printf("%d%c", ta, a == n - 1 ? '\n' : ' ');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using std::deque;
using std::make_pair;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::string;
using std::vector;
double distance(pair<double, double> p1, pair<double, double> p2) {
return std::sqrt((p1.first - p2.first) * (p1.first - p2.first) +
(p1.second - p2.second) * (p1.second - p2.second));
}
pair<double, double> crossY(double a, double b, double c, double x) {
return {x, (-a * x - c) / b};
}
pair<double, double> crossX(double a, double b, double c, double y) {
return {(-b * y - c) / a, y};
}
double dist4(pair<double, double> a, pair<double, double> b,
pair<double, double> c, pair<double, double> d) {
return distance(a, b) + distance(b, c) + distance(c, d);
}
int main() {
int a, b, c;
std::cin >> a >> b >> c;
pair<double, double> p1, p2;
std::cin >> p1.first >> p1.second >> p2.first >> p2.second;
double best_dist =
std::abs(p1.first - p2.first) + std::abs(p1.second - p2.second);
if (a != 0 && b != 0) {
pair<double, double> p1a = crossY(a, b, c, p1.first);
pair<double, double> p1b = crossX(a, b, c, p1.second);
pair<double, double> p2a = crossY(a, b, c, p2.first);
pair<double, double> p2b = crossX(a, b, c, p2.second);
best_dist = min(best_dist, dist4(p1, p1a, p2a, p2));
best_dist = min(best_dist, dist4(p1, p1b, p2a, p2));
best_dist = min(best_dist, dist4(p1, p1a, p2b, p2));
best_dist = min(best_dist, dist4(p1, p1b, p2b, p2));
}
std::cout.precision(17);
std::cout << best_dist << std::endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
unsigned long long int dp[maxn];
pair<int, int> st[maxn][18];
unsigned long long int ans;
pair<int, int> getRMQ(int l, int r) {
int lg = log2(r - l);
return max(st[l][lg], st[r - (1 << lg)][lg]);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << setprecision(30);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> st[i][0].first;
st[i][0].second = i;
}
st[n][0] = {n, n};
for (int i = 1; i < 18; i++) {
for (int j = 1; j <= n; j++) {
st[j][i] = max(st[j][i - 1], st[j + (1 << (i - 1))][i - 1]);
}
}
for (int i = n; i; i--) {
int mx = getRMQ(i, st[i][0].first + 1).second;
dp[i] = dp[mx] - (st[i][0].first - mx) + (n - i);
ans += dp[i];
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline bool SR(int &x) { return scanf("%d", &x) == 1; }
inline bool SR(long long &x) { return scanf("%lld", &x) == 1; }
inline bool SR(double &x) { return scanf("%lf", &x) == 1; }
inline bool SR(char *s) { return scanf("%s", s) == 1; }
inline bool RI() { return true; }
template <typename I, typename... T>
inline bool RI(I &x, T &...tail) {
return SR(x) && RI(tail...);
}
inline void SP(const int x) { printf("%d", x); }
inline void SP(const long long x) { printf("%lld", x); }
inline void SP(const double x) { printf("%.16lf", x); }
inline void SP(const char *s) { printf("%s", s); }
inline void PL() { puts(""); }
template <typename I, typename... T>
inline void PL(const I x, const T... tail) {
SP(x);
if (sizeof...(tail)) putchar(' ');
PL(tail...);
}
template <typename I>
void _DOING(const char *s, I &&x) {
cerr << s << " = " << x << endl;
}
template <typename I, typename... T>
void _DOING(const char *s, I &&x, T &&...tail) {
int c = 0;
while (*s != ',' || c != 0) {
if (*s == '(' || *s == '[' || *s == '{') c++;
if (*s == ')' || *s == ']' || *s == '}') c--;
cerr << *s++;
}
cerr << " = " << x << " , ";
_DOING(s + 1, tail...);
}
inline int RAND() {
static int x = 880301;
return (x = x * 0xdefaced + 1) & 0x7fffffff;
}
const int MAX_N = 100 + 10;
const long long MOD = 1000000000 + 7;
struct Matrix {
long long a[MAX_N][MAX_N];
int r, c;
Matrix(int _r = 0, int _c = 0) : r(_r), c(_c) {
for (int i = 0; i < int(_r); i++) {
for (int j = 0; j < int(_c); j++)
if (i == j)
a[i][j] = 1;
else
a[i][j] = 0;
}
}
};
inline Matrix operator*(const Matrix &a, const Matrix &b) {
Matrix c(a.r, b.c);
memset(c.a, (0), sizeof(c.a));
;
for (int k = 0; k < int(a.c); k++) {
for (int i = 0; i < int(a.r); i++) {
for (int j = 0; j < int(b.c); j++)
(c.a[i][j] += (a.a[i][k] * b.a[k][j]) % MOD) %= MOD;
}
}
return c;
}
inline Matrix power(Matrix a, long long n) {
Matrix x(a.r, a.c);
while (n) {
if (n & 1) x = x * a;
a = a * a;
n >>= 1;
}
return x;
}
Matrix mat;
long long a[MAX_N];
int main() {
int n;
long long k;
RI(n, k);
for (int i = 0; i < int(n); i++) RI(a[i]);
if (k == 1) {
PL(n);
return 0;
}
mat = Matrix(n, n);
memset(mat.a, (0), sizeof(mat.a));
;
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(n); j++) {
if (__builtin_popcountll(a[i] ^ a[j]) % 3 == 0) mat.a[i][j] = 1;
}
}
Matrix x = power(mat, k - 1);
long long ans = 0;
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(n); j++) ans = (ans + x.a[i][j]) % MOD;
}
PL(ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int a, b;
long double y2_;
long long int fn(long long int x) {
long double num = a * a - x * x;
long double n = sqrt(num);
if (ceil(n) != floor(n)) return -1;
if (n == 0) return -1;
return (long long int)n;
}
bool dist(long long int x, long long int y) {
long double dis = sqrt(x * x + y * y);
if (dis == b)
return true;
else
return false;
}
bool check(long long int x1, long long int y1, long long int x2) {
if (x2 == 0) return false;
y2_ = (x1 * -1 * x2) / (long double)y1;
if (ceil(y2_) != floor(y2_)) return false;
if (y2_ == 0) return false;
if (!dist(x2, y2_)) return false;
if (y1 == y2_) return false;
return true;
}
void solve() {
cin >> a >> b;
for (long long int x1 = -a; x1 <= a; x1++) {
if (x1 == 0) continue;
long long int y1 = fn(x1);
if (y1 == -1) continue;
for (long long int x2 = -b; x2 <= b; x2++) {
if (x1 == x2) continue;
if (check(x1, y1, x2)) {
cout << "YES" << endl
<< 0 << " " << 0 << endl
<< x1 << " " << y1 << "\n"
<< x2 << " " << (long long int)y2_ << "\n";
return;
}
if (check(x1, -y1, x2)) {
printf("YES\n");
cout << "YES" << endl
<< 0 << " " << 0 << endl
<< x1 << " " << y1 << "\n"
<< x2 << " " << (long long int)y2_ << "\n";
return;
}
}
}
cout << "NO" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
#define int long long int
bool isvalid( int H, int M, int h, int m )
{
string hour = to_string(M);
string minu = to_string(H);
reverse(hour.begin(), hour.end());
reverse(minu.begin(), minu.end());
if( hour.length() == 1 )
hour.push_back('0');
if( minu.length() == 1 )
minu.push_back('0');
for( auto &v: hour )
{
if( v == '2' )
{
v = '5';
}
else
{
if( v == '5' )
v = '2';
else
{
if( !( v == '0' || v == '1' || v =='8' ) )
return false;
}
}
}
for( auto &v: minu )
{
if( v == '2' )
{
v = '5';
}
else
{
if( v == '5' )
v = '2';
else
{
if( !( v == '0' || v == '1' || v =='8' ) )
return false;
}
}
}
int candH = stoi(hour), candM = stoi(minu);
return candH <= h && candM <= m;
}
int32_t main()
{
int T = 1;
cin>>T;
while( T-- )
{
int h, m;
cin>>h>>m;
string s;
cin>>s;
string ans = "00:00";
int H, M, pos;
H = stoi( s.substr(0, 2) );
s.erase(0, 3 );
M = stoi(s);
int flag = 0;
while( H < h )
{
while( M < m )
{
if( isvalid( H, M, h - 1, m - 1 ) )
{
string hora = to_string(H), minu = to_string(M);
if( hora.length() < 2 )
hora = "0" + hora;
if( minu.length() < 2 )
minu = "0" + minu;
ans = hora + ":" + minu;
flag = 1;
break;
}
M++;
}
if( flag == 1 )
break;
H++;
M = 0;
}
cout<<ans<<endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1), EPS = 1e-8;
const int mod = 1000000007;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int N = 1e5 + 9;
long long fact[N];
long long power(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long r = power(x, y >> 1);
return ((r * r) % mod * power(x, y & 1)) % mod;
}
long long inverse(long long n) { return power(n, mod - 2); }
long long nCr(int n, int r) {
return (fact[n] * inverse(fact[n - r] * fact[r] % mod)) % mod;
}
int main() {
run();
int n;
cin >> n;
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = (i * fact[i - 1]) % mod;
long long cnt = 0;
for (int i = 1; i <= n; i++) {
long long c = nCr(n - 1, i - 1) * nCr(n, i) % mod;
if (i > 1) c = (c * 2) % mod;
cnt = (cnt + c) % mod;
}
cout << cnt << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned int n, a, p, mi, s, i;
int main() {
cin >> n;
cin >> a >> mi;
s = s + a * mi;
for (i = 2; i <= n; i++) {
cin >> a >> p;
if (p < mi) mi = p;
s = s + a * mi;
}
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
int n, ip[MAXN], p[MAXN], q[MAXN];
int tree[4 * MAXN], flag[4 * MAXN];
void push(int i, int L, int R) {
if (L < R) {
flag[2 * i] += flag[i];
flag[2 * i + 1] += flag[i];
}
tree[i] += flag[i];
flag[i] = 0;
}
void update(int i, int L, int R, int u, int v, int val) {
push(i, L, R);
if (R < u || v < L) return;
if (u <= L && R <= v) {
flag[i] += val;
push(i, L, R);
return;
}
int mid = (L + R) / 2;
update(2 * i, L, mid, u, v, val);
update(2 * i + 1, mid + 1, R, u, v, val);
tree[i] = max(tree[2 * i], tree[2 * i + 1]);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
p[i]--;
ip[p[i]] = i;
}
int j = n - 1;
update(1, 0, n - 1, 0, ip[j], 1);
for (int i = 0; i < n; i++) {
scanf("%d", &q[i]);
q[i]--;
if (i > 0) printf(" ");
printf("%d", j + 1);
if (i != n - 1) {
update(1, 0, n - 1, 0, q[i], -1);
while (true) {
if (tree[1] > 0) {
break;
} else {
j--;
update(1, 0, n - 1, 0, ip[j], 1);
}
}
}
}
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int n, m;
char s[N], num[N];
int P1, P2;
mt19937 rnd(__builtin_ia32_rdtsc());
pair<int, int> h1[N], h2[N], p10[N];
int isprime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
const pair<int, int> B = {10, 10};
pair<int, int> operator+(const pair<int, int> a, const pair<int, int> b) {
return {(a.first + b.first) % P1, (a.second + b.second) % P2};
}
pair<int, int> operator-(const pair<int, int> a, const pair<int, int> b) {
return {(a.first - b.first + P1) % P1, (a.second - b.second + P2) % P2};
}
pair<int, int> operator*(const pair<int, int> a, const pair<int, int> b) {
return {1ll * a.first * b.first % P1, 1ll * a.second * b.second % P2};
}
pair<int, int> query(int l, int r) {
return h1[r] - h1[l - 1] * p10[r - l + 1];
}
int LCP(int first) {
int l = 1, r = min(n - first + 1, m), best = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (query(first, first + mid - 1) == h2[mid])
best = mid, l = mid + 1;
else
r = mid - 1;
}
return best;
}
void check(int len) {
if (len == 0) return;
for (int i = 1; i + len - 1 <= n; i++) {
int lcp = len - min(len, LCP(i));
for (int j = max(1, lcp - 1); j <= lcp && i + len + j - 1 <= n; j++) {
if (query(i, i + len - 1) + query(i + len, i + len + j - 1) == h2[m]) {
printf("%d %d\n%d %d\n", i, i + len - 1, i + len, i + len + j - 1);
exit(0);
}
}
for (int j = max(1, lcp - 1); j <= lcp && i - j >= 1; j++) {
if (query(i, i + len - 1) + query(i - j, i - 1) == h2[m]) {
printf("%d %d\n%d %d\n", i - j, i - 1, i, i + len - 1);
exit(0);
}
}
}
return;
}
int rndprime() {
uniform_int_distribution<int> dist(5e8, 1e9);
int p = dist(rnd);
while (!isprime(p)) p++;
return p;
}
int main() {
P1 = rndprime();
P2 = rndprime();
scanf("%s", s + 1);
n = strlen(s + 1);
p10[0] = {1, 1};
for (int i = 1; i <= n; i++) p10[i] = p10[i - 1] * B;
for (int i = 1; i <= n; i++) {
int c = s[i] - '0';
h1[i] = h1[i - 1] * B + pair<int, int>{c, c};
}
scanf("%s", num + 1);
m = strlen(num + 1);
for (int i = 1; i <= m; i++) {
int c = num[i] - '0';
h2[i] = h2[i - 1] * B + pair<int, int>{c, c};
}
check(m);
check(m - 1);
return 0;
}
| 12 |
#include <bits/stdc++.h>
namespace FASTIO {
char buf[1 << 21];
char *p1, *p2;
template <typename T>
inline void wt(T x, char c = '\n') {
if (x < 0) {
x = -x;
putchar('-');
}
static char sta[sizeof(T) * 8];
T top = 0;
do {
sta[top++] = x % 10;
x /= 10;
} while (x);
while (top) putchar(sta[--top] + '0');
putchar(c);
}
template <typename T>
inline T rd() {
T sum = 0, fl = 1;
char ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
for (; ch < '0' || ch > '9';
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++))
if (ch == '-')
fl = -1;
else if (ch == EOF)
exit(0);
for (; '0' <= ch && ch <= '9';
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++))
sum = sum * 10 + ch - '0';
return sum * fl;
}
} // namespace FASTIO
using namespace FASTIO;
int n, m;
int k;
int len;
std::vector<int> a;
struct node {
node *son[2];
int cnt;
node() {
son[0] = NULL;
son[1] = NULL;
cnt = 0;
}
~node() {
delete son[0];
delete son[1];
}
} root;
inline void insert(int x) {
node *p = &root;
for (int i = len; i >= 0; i--) {
p->cnt++;
const bool $ = (x & 1 << i) != 0;
if (!p->son[$]) p->son[$] = new node();
p = p->son[$];
}
p->cnt++;
return;
}
inline int query() {
const node *p = &root;
int ans = 0;
for (int i = len; p && i >= 0; i--) {
const bool $ = (k & 1 << i) != 0;
if (!p->son[$] || p->son[$]->cnt < 1 << i)
p = p->son[$];
else {
p = p->son[!$];
ans |= 1 << i;
}
}
return ans;
}
int main() {
n = rd<int>();
m = rd<int>();
a.resize(n);
for (int &ele : a) ele = rd<int>();
std::sort(a.begin(), a.end());
a.erase(std::unique(a.begin(), a.end()), a.end());
len = a.back();
len = len ? log2(len) + 2 : 2;
for (const int &A : a) insert(A);
while (m--) {
k ^= rd<int>();
wt(query());
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
string t;
cin >> s >> t;
reverse(s.begin(), s.end());
if (s == t) {
cout << "YES";
} else {
cout << "NO";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <int MOD, int RT>
struct Mint {
static const int mod = MOD;
static constexpr Mint rt() { return RT; }
static constexpr int md() { return MOD; }
int v;
explicit operator int() const { return v; }
explicit operator bool() const { return v != 0; }
Mint() { v = 0; }
Mint(long long _v) {
v = int((-MOD <= _v && _v < MOD) ? _v : _v % MOD);
if (v < 0) v += MOD;
}
friend bool operator==(const Mint& a, const Mint& b) { return a.v == b.v; }
friend bool operator!=(const Mint& a, const Mint& b) { return !(a == b); }
friend bool operator<(const Mint& a, const Mint& b) { return a.v < b.v; }
friend bool operator>(const Mint& a, const Mint& b) { return a.v > b.v; }
friend bool operator<=(const Mint& a, const Mint& b) { return a.v <= b.v; }
friend bool operator>=(const Mint& a, const Mint& b) { return a.v >= b.v; }
friend std::istream& operator>>(std::istream& in, Mint& a) {
long long x;
std::cin >> x;
a = Mint(x);
return in;
}
friend std::ostream& operator<<(std::ostream& os, const Mint& a) {
return os << a.v;
}
Mint& operator+=(const Mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this;
}
Mint& operator-=(const Mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this;
}
Mint& operator*=(const Mint& m) {
v = (long long)v * m.v % MOD;
return *this;
}
Mint& operator/=(const Mint& m) { return (*this) *= inv(m); }
friend Mint pow(Mint a, long long p) {
Mint ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend Mint inv(const Mint& a) {
assert(a.v != 0);
return pow(a, MOD - 2);
}
Mint operator-() const { return Mint(-v); }
Mint& operator++() { return *this += 1; }
Mint& operator--() { return *this -= 1; }
friend Mint operator+(Mint a, const Mint& b) { return a += b; }
friend Mint operator-(Mint a, const Mint& b) { return a -= b; }
friend Mint operator*(Mint a, const Mint& b) { return a *= b; }
friend Mint operator/(Mint a, const Mint& b) { return a /= b; }
};
using mi = Mint<1000000007, 5>;
int main() {
long long n, m, k, r, c;
cin >> n >> m >> k >> r >> c;
int w, x, y, z;
cin >> w >> x >> y >> z;
mi ans;
if (w == y && x == z) {
ans = pow(mi(k), n * m);
} else {
ans = pow(mi(k), n * m - r * c);
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<string, string> def[102];
map<string, int> mp;
int sflv[102] = {0};
int stk[102], sh;
int ts[102], th;
int cal(int ty, int x, int y) {
if (x == 1 || y == 1) return 1;
switch (ty) {
case 4:
return 2;
case 5:
return y == 2 ? 1 : 2;
case 6:
return (x == 2 || y == 2) ? 1 : 3;
case 7:
return (x == 2 || y != 0) ? 1 : 3;
default:
return 0;
}
}
bool cn(char c) {
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9');
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n + 1; i++) {
if (i <= n) {
cin >> def[i].first;
if (def[i].first == "#") cin >> def[i].first;
cin >> def[i].first;
} else
def[i].first = "";
getline(cin, def[i].second);
mp[def[i].first] = i;
sh = 0;
stk[sh] = -1;
for (int j = 0; j < (int)def[i].second.length(); j++) {
char c = def[i].second[j];
if (cn(c)) {
if (j != 0 && cn(def[i].second[j - 1])) continue;
string tmp;
int t = j;
while (t < (int)def[i].second.length() && cn(def[i].second[t])) {
tmp += def[i].second[t];
t++;
}
if (mp[tmp])
stk[++sh] = sflv[mp[tmp]];
else
stk[++sh] = 0;
if (stk[sh - 1] == 6 || stk[sh - 1] == 7) {
stk[sh - 2] = cal(stk[sh - 1], stk[sh - 2], stk[sh]);
sh -= 2;
}
} else if (c == ' ')
continue;
else if (c == '+')
stk[++sh] = 4;
else if (c == '-')
stk[++sh] = 5;
else if (c == '*')
stk[++sh] = 6;
else if (c == '/')
stk[++sh] = 7;
else if (c == '(')
stk[++sh] = 8;
else if (c == ')') {
memset(ts, 0, sizeof(ts));
th = 0;
while (stk[sh] != 8) {
ts[++th] = stk[sh--];
}
while (th > 1) {
if (ts[th - 1] == 4 || ts[th - 1] == 5) {
ts[th - 2] = cal(ts[th - 1], ts[th], ts[th - 2]);
th -= 2;
}
}
stk[sh] = (int)(ts[th] == 1);
if (sh > 1 && (stk[sh - 1] == 6 || stk[sh - 1] == 7)) {
stk[sh - 2] = cal(stk[sh - 1], stk[sh - 2], stk[sh]);
sh -= 2;
}
}
}
memset(ts, 0, sizeof(ts));
th = 0;
while (sh) {
ts[++th] = stk[sh--];
}
while (th > 1) {
if (ts[th - 1] == 4 || ts[th - 1] == 5) {
ts[th - 2] = cal(ts[th - 1], ts[th], ts[th - 2]);
th -= 2;
}
}
sflv[i] = ts[th];
}
cout << (sflv[n + 1] != 1 ? "OK" : "Suspicious") << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> readvec(long long length, long long off = 0);
template <typename T>
string ts(T v);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
long long z;
cin >> n >> z;
vector<long long> v = readvec(n);
sort(v.begin(), v.end());
long long left = 0;
long long right = v.size() / 2;
long long ans = 0;
while (true) {
if (left >= v.size() / 2 || right >= v.size()) break;
if (v[right] - v[left] >= z) {
ans++;
left++;
right++;
} else {
right++;
}
}
cout << ans << endl;
}
template <typename T>
string ts(T v) {
stringstream ss;
ss << "[";
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) ss << ", ";
ss << *it;
}
ss << "]";
return ss.str();
}
vector<long long> readvec(long long length, long long off) {
vector<long long> v;
for (long long i = 0; i < length; i++) {
long long x;
cin >> x;
v.push_back(x + off);
}
return v;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long int req[30][30][5000], hum = 193, som[30];
int main() {
double q, r;
map<double, int> map2;
map<double, int>::iterator fin;
long int a, b = 0, c, d = 0, i, n, k = 3, s = 0;
map<pair<char, char>, long int> map1, map3;
map<pair<char, char>, long int>::iterator it, p;
string wor, tor;
cin >> wor;
n = wor.length();
tor = wor + wor;
for (i = 0; i < n; i++) som[wor[i] + 'a' - 193] = som[wor[i] + 'a' - 193] + 1;
for (i = 0; i <= 26; i++)
for (c = 0; c <= 26; c++)
for (k = 0; k < n; k++) req[i][c][k] = -1;
for (k = 1; k < n; k++) {
d = 0;
for (i = 0; i < n; i++) {
if (req[(tor[i] + 'a') - 193][(tor[i + k] + 'a') - 193][k] == -1)
req[(tor[i] + 'a') - 193][(tor[i + k] + 'a') - 193][k] = 1;
else
req[(tor[i] + 'a') - 193][(tor[i + k] + 'a') - 193][k] = 0;
}
}
b = 0;
s = 0;
d = 0;
for (c = 1; c <= 26; c++) {
for (k = 1; k < n; k++) {
for (i = 1; i <= 26; i++)
if (req[c][i][k] == 1) s = s + 1;
b = max(s, b);
s = 0;
}
d = d + min(b, som[c]);
b = 0;
}
cout.precision(15);
cout << fixed << (double)d / (double)n;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, m;
cin >> n;
if (n % 2 == 0) {
k = pow(n, 2) / 4 + 1;
m = k - 2;
} else {
k = (pow(n, 2) + 1) / 2;
m = (pow(n, 2) - 1) / 2;
}
if (k > 0 && m > 0)
cout << m << " " << k;
else
cout << -1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<double, int> m;
char s[11];
double a[200000];
int main() {
int n, i, x, b, c;
cin >> n;
for (i = 0; i < n; i++) {
cin >> s;
sscanf(s, "(%d+%d)/%d", &x, &b, &c);
a[i] = (double)(x + b) / (double)(c);
m[a[i]]++;
}
for (i = 0; i < n; i++) {
cout << m[a[i]] << " ";
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s1, s2, inp;
cin >> s1 >> s2 >> inp;
map<char, char> mp;
for (int i = 0; i < s1.size(); i++) {
mp[s1[i]] = s2[i];
mp[s1[i] - 32] = s2[i] - 32;
}
for (int i = 0; i < inp.size(); i++) {
if (inp[i] >= '0' && inp[i] <= '9') {
cout << inp[i];
} else {
cout << mp[inp[i]];
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int N;
vector<int> adj[200001];
long long dp[200001], newdp[200001];
int parent[200001];
int ans[200001];
vector<pair<long long, long long>> v[200001];
vector<int> pref[200001], suff[200001];
long long fastexp(long long base, long long exp) {
if (exp == 0) return 1;
long long temp = fastexp(base, exp / 2);
temp = (temp * temp) % 1000000007;
if (exp % 2 == 1) temp = (temp * base) % 1000000007;
return temp;
}
void dfs1(int node, int par) {
parent[node] = par;
dp[node] = 1;
for (int x : adj[node]) {
dfs1(x, node);
dp[node] *= (dp[x] + 1);
dp[node] %= 1000000007;
}
}
void dfs2(int node, int par) {
if (node != 1) {
int pos = lower_bound(v[par].begin(), v[par].end(),
make_pair((long long)node, (long long)(-1))) -
v[par].begin();
newdp[par] = 1;
if (pos > 0) newdp[par] *= pref[par][pos - 1];
if (pos + 1 < (int)v[par].size())
newdp[par] = (newdp[par] * suff[par][pos + 1]) % 1000000007;
if (par != 1)
newdp[par] = (newdp[par] * (newdp[parent[par]] + 1)) % 1000000007;
newdp[node] = (dp[node] * (newdp[par] + 1)) % 1000000007;
ans[node] = newdp[node];
} else
ans[node] = dp[node];
for (int x : adj[node]) dfs2(x, node);
}
int main() {
cin >> N;
for (int i = 2; i <= N; i++) {
int p;
cin >> p;
adj[p].push_back(i);
}
dfs1(1, 1);
for (int i = 1; i <= N; i++) {
for (int x : adj[i]) v[i].push_back({x, dp[x] + 1});
sort(v[i].begin(), v[i].end());
long long temp = 1;
for (auto it : v[i]) {
temp = (temp * it.second) % 1000000007;
pref[i].push_back(temp);
}
temp = 1;
for (int j = (int)v[i].size() - 1; j >= 0; j--) {
temp = (temp * v[i][j].second) % 1000000007;
suff[i].push_back(temp);
}
reverse(suff[i].begin(), suff[i].end());
}
dfs2(1, 1);
for (int i = 1; i <= N; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e8;
int main() {
int n, a, b;
cin >> n;
a = (double)n / 3 + 0.5;
cout << a / 12 << " " << a % 12;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
int data[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &data[i]);
int l = 1, r = n;
while (l < n && data[l] < data[l + 1]) l++;
while (r > 1 && data[r] < data[r - 1]) r--;
int flag = 1;
if (l > r) flag = 0;
for (int i = l; i < r; ++i) {
if (data[i] != data[i + 1]) flag = 0;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
int mod = 1000000007;
using namespace std;
char c[500005];
int cn[500005];
int bits[500005][10];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
string a, b;
cin >> a >> b;
int a0 = 0, a1 = 0, b0 = 0, b1 = 0;
if (a.size() != b.size()) {
cout << "NO" << '\n';
return 0;
}
for (int i = 0; i < a.size(); i++) {
if (a[i] == '0')
a0++;
else
a1++;
if (b[i] == '0')
b0++;
else
b1++;
}
if ((a1 == 0 && b1 != 0) || (a1 != 0 && b1 == 0)) {
cout << "NO" << '\n';
} else
cout << "YES" << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int a, b, c;
cin >> a >> b >> c;
cout << (b >= a and c >= a ? "Yes" : "No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ri, ci;
cin >> n;
int r[55] = {0};
int c[55] = {0};
for (int i = 0; i < n * n; i++) {
cin >> ri >> ci;
if (r[ri - 1] != 1 && c[ci - 1] != 1) {
cout << i + 1 << " ";
r[ri - 1] = 1;
c[ci - 1] = 1;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2111111;
int a[maxn], n;
vector<int> v;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) a[i] = i;
int p = 0;
for (int i = 2; i <= n; i++) {
v.clear();
v.push_back(p);
for (int j = i; j <= n; j += i) v.push_back(j + p);
if (n % i != 0) v.push_back(n + p);
int l = v[v.size() - 2] + 1;
for (int j = v.size() - 1; j > 0; j--) {
int r = v[j], l = v[j - 1] + 1;
a[r + 1] = a[l];
}
p++;
}
for (int i = p + 1; i <= p + n; i++) cout << a[i] << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <class T>
inline T BigMod(T Base, T power, T M = 1000000007) {
if (power == 0) return 1;
if (power & 1)
return ((Base % M) * (BigMod(Base, power - 1, M) % M)) % M;
else {
T y = BigMod(Base, power / 2, M) % M;
return (y * y) % M;
}
}
template <class T>
inline T ModInv(T A, T M = 1000000007) {
return BigMod(A, M - 2, M);
}
int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0};
int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0};
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
vector<pair<pair<int, int>, int> > v;
set<int> row, col, jog, biyog;
int pk[200005], ans[200005];
bool cmp(const pair<pair<int, int>, int> &a,
const pair<pair<int, int>, int> &b) {
if (a.first.first == b.first.first) return a.first.second < b.first.second;
return a.first.first < b.first.first;
}
void CLEAR() {
row.clear();
col.clear();
jog.clear();
biyog.clear();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int r, c;
cin >> r >> c;
v.push_back(pair<pair<int, int>, int>(pair<int, int>(r, c), i));
}
sort(v.begin(), v.end(), cmp);
for (int i = 0; i < v.size(); i++) {
if (row.find(v[i].first.first) != row.end()) ans[v[i].second]++;
if (col.find(v[i].first.second) != col.end()) ans[v[i].second]++;
if (jog.find(v[i].first.first + v[i].first.second) != jog.end())
ans[v[i].second]++;
if (biyog.find(v[i].first.first - v[i].first.second) != biyog.end())
ans[v[i].second]++;
row.insert(v[i].first.first);
col.insert(v[i].first.second);
jog.insert(v[i].first.first + v[i].first.second);
biyog.insert(v[i].first.first - v[i].first.second);
}
CLEAR();
for (int i = v.size() - 1; i >= 0; i--) {
if (row.find(v[i].first.first) != row.end()) ans[v[i].second]++;
if (col.find(v[i].first.second) != col.end()) ans[v[i].second]++;
if (jog.find(v[i].first.first + v[i].first.second) != jog.end())
ans[v[i].second]++;
if (biyog.find(v[i].first.first - v[i].first.second) != biyog.end())
ans[v[i].second]++;
row.insert(v[i].first.first);
col.insert(v[i].first.second);
jog.insert(v[i].first.first + v[i].first.second);
biyog.insert(v[i].first.first - v[i].first.second);
}
for (int i = 0; i < m; i++) pk[ans[i]]++;
for (int i = 0; i <= 8; i++) cout << pk[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int gcd(int a, int b) {
while (b) {
a = a % b;
std::swap(a, b);
}
return a;
}
std::map<std::pair<int, int>, int> ans;
std::map<int64_t, std::vector<std::pair<int, int> > > points;
int total_cnt = 0;
int main() {
int Q;
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int T, X, Y;
scanf("%d %d %d", &T, &X, &Y);
int g = gcd(X, Y);
switch (T) {
case 1: {
int64_t R = int64_t(X) * X + int64_t(Y) * Y;
for (auto p : points[R]) {
int xx = X + p.first, yy = Y + p.second;
int gg = gcd(xx, yy);
ans[{xx / gg, yy / gg}] += 2;
}
points[R].emplace_back(X, Y);
ans[{X / g, Y / g}]++;
total_cnt++;
break;
}
case 2: {
int64_t R = int64_t(X) * X + int64_t(Y) * Y;
std::vector<std::pair<int, int> >& ps = points[R];
ps.erase(std::find(ps.begin(), ps.end(), std::make_pair(X, Y)));
ans[{X / g, Y / g}]--;
for (auto p : ps) {
int xx = X + p.first, yy = Y + p.second;
int gg = gcd(xx, yy);
ans[{xx / gg, yy / gg}] -= 2;
}
total_cnt--;
break;
}
case 3: {
printf("%d\n", total_cnt - ans[std::make_pair(X / g, Y / g)]);
break;
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[110][110];
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) scanf("%s", s[i]);
int cnt = 0;
for (int i = 0; i < n; i++) {
int tag = 1;
for (int j = 0; j < n; j++) {
if (s[i][j] == '.') {
tag = 0;
break;
}
}
cnt += (tag == 0);
}
if (cnt == n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (s[i][j] == '.') {
printf("%d %d\n", i + 1, j + 1);
break;
}
}
}
} else {
cnt = 0;
for (int i = 0; i < n; i++) {
int tag = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == '.') {
tag = 1;
break;
}
}
cnt += tag;
}
if (cnt == n) {
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
if (s[i][j] == '.') {
printf("%d %d\n", i + 1, j + 1);
break;
}
}
}
} else {
printf("-1\n");
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int marks[5][3];
int main() {
cin >> n;
for (int k = 0; k < 4; ++k) {
marks[k][0] = marks[k][1] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
char b;
cin >> b;
int a = b - 48;
if (a != 1 && a != 0) assert(false);
if ((i + j) % 2)
marks[k][a]++;
else
marks[k][1 - a]++;
}
}
}
int minrecolor = 100000;
for (int i = 0; i < 4; ++i) {
for (int j = i + 1; j < 4; ++j) {
int cnt = 0;
for (int k = 0; k < 4; ++k) {
if (k == i || k == j)
cnt += marks[k][1];
else
cnt += marks[k][0];
}
minrecolor = min(minrecolor, cnt);
}
}
cout << minrecolor << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007;
long long int MOD1 = 998244353;
mt19937 tw(chrono::high_resolution_clock::now().time_since_epoch().count());
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<pair<int, int>> v;
for (int i = 0; i < n / 2; i++) {
if (s[i] == ')') {
int j;
for (int j = i + 1; j < n; j++) {
if (s[j] == '(') {
reverse(s.begin() + i, s.begin() + j + 1);
v.emplace_back(pair<int, int>(i + 1, j + 1));
break;
}
}
}
}
for (int i = 2, j = 1, l = n / 2 + 1; i <= k; i++, j += 2, l++) {
reverse(s.begin() + j, s.begin() + l);
v.emplace_back(pair<int, int>(j + 1, l));
}
cout << v.size() << "\n";
for (auto x : v) cout << x.first << " " << x.second << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 * 1e2 + 5;
bool dp[2][MAXN][MAXN];
int a[MAXN];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
dp[0][0][0] = true;
for (int i = 1; i <= n; ++i) {
bool now = i % 2;
bool last = 1 - now;
int c = a[i];
for (int j = 0; j <= k; ++j) {
for (int f = 0; f <= j; ++f) {
dp[now][j][f] = dp[last][j][f];
if (j >= c) {
dp[now][j][f] |= dp[last][j - c][f];
if (f >= c) {
dp[now][j][f] |= dp[last][j - c][f - c];
}
}
}
}
}
vector<int> vec;
for (int i = 0; i <= k; ++i) {
if (dp[n % 2][k][i]) {
vec.push_back(i);
}
}
cout << vec.size();
cout << endl;
for (auto i : vec) cout << i << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
int a[SIZE];
int n;
vector<int> an;
void big_one(int x) {
if (x <= 6) {
an.push_back(x);
an.push_back(x + 3);
an.push_back(x + 6);
an.push_back(x + 3);
an.push_back(x + 4);
an.push_back(x + 5);
an.push_back(x + 4);
an.push_back(x + 5);
an.push_back(x + 6);
} else {
an.push_back(x - 6);
an.push_back(x - 3);
an.push_back(x);
an.push_back(x - 6);
an.push_back(x - 5);
an.push_back(x - 4);
an.push_back(x - 5);
an.push_back(x - 4);
an.push_back(x - 3);
}
}
void solve_big() {
vector<int> ones;
int r = n / 3 + 12;
for (int j = 1; j + 2 <= n; j++) {
for (int dd = (1); dd <= (1000); ++dd) {
if (j - dd < 1 || j + dd > n) break;
if (a[j] && a[j - dd] && a[j + dd]) {
a[j - dd] = 0;
a[j] = 0;
a[j + dd] = 0;
r--;
an.push_back(j - dd);
an.push_back(j);
an.push_back(j + dd);
}
}
}
for (int i = (1); i <= (n); ++i) {
if (a[i] == 1) ones.push_back(i);
}
set<int> H((ones).begin(), (ones).end());
while (((int)(H).size())) {
if (((int)(H).size()) * 3 <= r) {
for (int x : H) {
big_one(x);
}
break;
} else {
int x = *H.begin();
int y = *next(H.begin());
int z = y * 2 - x;
if (z <= n) {
an.push_back(x);
an.push_back(y);
an.push_back(z);
r--;
H.erase(x);
H.erase(y);
if (H.count(z)) {
H.erase(z);
} else
H.insert(z);
} else {
z = n;
if (n % 2 != x % 2) z--;
y = (x + z) / 2;
an.push_back(x);
an.push_back(y);
an.push_back(z);
r--;
H.erase(x);
if (H.count(y)) {
H.erase(y);
} else
H.insert(y);
if (H.count(z)) {
H.erase(z);
} else
H.insert(z);
}
}
}
W("YES");
W(((int)(an).size()) / 3);
for (int i = 0; i < ((int)(an).size()); i += 3) {
W(an[i], an[i + 1], an[i + 2]);
}
}
int gg[15][100], gg_r[15];
void solve_small() {
vector<int> mask;
int gn = 0;
vector<int> ker[100];
for (int dd = (1); dd <= (12); ++dd) {
for (int j = 1; j + dd * 2 <= n; j++) {
gg[j][gn] = 1;
gg[j + dd][gn] = 1;
gg[j + dd * 2][gn] = 1;
ker[gn] = {j, j + dd, j + dd * 2};
gn++;
}
}
for (int i = (1); i <= (n); ++i) {
if (a[i]) {
gg_r[i] = 1;
}
}
int st = 1;
for (int i = 0; i < gn; i++) {
int now = -1;
for (int j = st; j <= n; j++) {
if (gg[j][i]) {
now = j;
break;
}
}
if (now == -1) continue;
if (now != st) {
for (int j = 0; j < (gn); ++j) swap(gg[now][j], gg[st][j]);
swap(gg_r[now], gg_r[st]);
}
for (int j = (1); j <= (n); ++j) {
if (j == st) continue;
if (gg[j][i]) {
for (int k = 0; k < (gn); ++k) gg[j][k] ^= gg[st][k];
gg_r[j] ^= gg_r[st];
}
}
st++;
}
for (int i = (st); i <= (n); ++i) {
if (gg_r[i]) {
W("NO");
return;
}
}
W("YES");
for (int i = st - 1; i >= 1; i--) {
if (!gg_r[i]) continue;
for (int j = 0; j < gn; j++) {
if (gg[i][j]) {
for (int x : ker[j]) {
an.push_back(x);
}
break;
}
}
}
W(((int)(an).size()) / 3);
for (int i = 0; i < ((int)(an).size()); i += 3) {
W(an[i], an[i + 1], an[i + 2]);
}
}
int main() {
R(n);
for (int i = (1); i <= (n); ++i) R(a[i]);
if (n <= 12) {
solve_small();
} else {
solve_big();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
namespace CoreLibrary {
class Reader {
private:
std::FILE* file;
std::vector<char> buffer;
char *pointer, *end;
inline void read_file() {
for (int i = 0;; ++i) {
buffer.resize(buffer.size() + (1 << i));
int t =
std::fread(&buffer[0] + buffer.size() - (1 << i), 1, (1 << i), file);
if (t != (1 << i)) {
pointer = &buffer[0];
end = pointer + buffer.size() - (1 << i) + t;
break;
}
}
}
inline void read(char& a) { a = *pointer++; }
inline void read(char* a) {
ignore();
while (pointer != end && !std::isspace(*pointer)) *a++ = *pointer++;
*a = 0;
}
inline void read(int& a) {
ignore();
bool f = false;
if (*pointer == '-') {
f = true;
++pointer;
}
a = 0;
while (pointer != end && std::isdigit(*pointer))
a = a * 10 + *pointer++ - '0';
if (f) a = -a;
}
inline void read(long long& a) {
ignore();
bool f = false;
if (*pointer == '-') {
f = true;
++pointer;
}
a = 0;
while (pointer != end && std::isdigit(*pointer))
a = a * 10 + *pointer++ - '0';
if (f) a = -a;
}
inline void ignore() {
while (pointer != end && std::isspace(*pointer)) ++pointer;
}
public:
inline Reader(std::FILE* _file) : file(_file) { read_file(); }
inline Reader(std::string _file) : file(std::fopen(_file.c_str(), "r")) {
read_file();
}
inline ~Reader() { fclose(file); }
template <class VALUE_TYPE>
inline Reader& operator>>(VALUE_TYPE& a) {
read(a);
return *this;
}
};
class Writer {
private:
std::FILE* file;
std::vector<char> buffer;
inline void write(char a) { buffer.push_back(a); }
inline void write(const char* a) {
while (*a) buffer.push_back(*a++);
}
inline void write(int a) {
if (a < 0) {
buffer.push_back('-');
a = -a;
}
static char t[10];
char* p = t;
do {
int b = a / 10;
*p++ = a - b * 10 + '0';
a = b;
} while (a);
while (p > t) buffer.push_back(*--p);
}
inline void write(long long a) {
if (a < 0) {
buffer.push_back('-');
a = -a;
}
static char t[19];
char* p = t;
do {
long long b = a / 10;
*p++ = a - b * 10 + '0';
a = b;
} while (a);
while (p > t) buffer.push_back(*--p);
}
public:
inline Writer(std::FILE* _file) : file(_file) {}
inline Writer(std::string _file) : file(std::fopen(_file.c_str(), "w")) {}
inline ~Writer() {
std::fwrite(&buffer[0], 1, buffer.size(), file);
fclose(file);
}
template <class VALUE_TYPE>
inline Writer& operator<<(VALUE_TYPE a) {
write(a);
return *this;
}
};
template <class VALUE_TYPE>
inline bool MakeMax(VALUE_TYPE& a, const VALUE_TYPE& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class VALUE_TYPE>
inline bool MakeMin(VALUE_TYPE& a, const VALUE_TYPE& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class VALUE_TYPE>
inline VALUE_TYPE Abs(const VALUE_TYPE& a) {
return a < VALUE_TYPE(0) ? -a : a;
}
} // namespace CoreLibrary
namespace DataStructures {
template <class VALUE_TYPE, class COMPARER_TYPE>
class Set {
private:
struct node {
inline node(const VALUE_TYPE& _value, node* _left, node* _right,
node* _parent, const bool& _black, const int& _size,
const int& _count)
: value(_value),
left(_left),
right(_right),
parent(_parent),
black(_black),
size(_size),
count(_count) {}
VALUE_TYPE value;
node *left, *right, *parent;
bool black;
int size, count;
} * root, *nil;
inline void clear(node* x) {
if (x != nil) {
clear(x->left);
clear(x->right);
delete x;
}
}
inline void left_rotate(node* x) {
node* y = x->right;
x->right = y->left;
if (y->left != nil) y->left->parent = x;
y->parent = x->parent;
if (x->parent == nil)
root = y;
else if (x == x->parent->left)
x->parent->left = y;
else
x->parent->right = y;
y->left = x;
x->parent = y;
y->size = x->size;
x->size = x->left->size + x->right->size + x->count;
}
inline void right_rotate(node* x) {
node* y = x->left;
x->left = y->right;
if (y->right != nil) y->right->parent = x;
y->parent = x->parent;
if (x->parent == nil)
root = y;
else if (x == x->parent->left)
x->parent->left = y;
else
x->parent->right = y;
y->right = x;
x->parent = y;
y->size = x->size;
x->size = x->left->size + x->right->size + x->count;
}
inline void insert_fixup(node* z) {
while (!z->parent->black) {
if (z->parent == z->parent->parent->left) {
node* y = z->parent->parent->right;
if (!y->black) {
z->parent->black = true;
y->black = true;
(z = z->parent->parent)->black = false;
} else {
if (z == z->parent->right) left_rotate(z = z->parent);
z->parent->black = true;
z->parent->parent->black = false;
right_rotate(z->parent->parent);
}
} else {
node* y = z->parent->parent->left;
if (!y->black) {
z->parent->black = true;
y->black = true;
(z = z->parent->parent)->black = false;
} else {
if (z == z->parent->left) right_rotate(z = z->parent);
z->parent->black = true;
z->parent->parent->black = false;
left_rotate(z->parent->parent);
}
}
}
root->black = true;
}
inline void erase(node* z) {
node* y;
if (z->left == nil || z->right == nil)
y = z;
else {
y = z->right;
while (y->left != nil) y = y->left;
z->value = y->value;
z->count = y->count;
int t = y->count;
y->count = 0;
y = z->right;
while (y->left != nil) {
y->size -= t;
y = y->left;
}
}
node* x = y->left == nil ? y->right : y->left;
x->parent = y->parent;
if (y->parent == nil)
root = x;
else if (y == y->parent->left)
y->parent->left = x;
else
y->parent->right = x;
if (y->black) erase_fixup(x);
delete y;
}
inline void erase_fixup(node* x) {
while (x != root && x->black) {
if (x == x->parent->left) {
node* w = x->parent->right;
if (!w->black) {
w->black = true;
x->parent->black = false;
left_rotate(x->parent);
w = x->parent->right;
}
if (w->left->black && w->right->black) {
w->black = false;
x = x->parent;
} else {
if (w->right->black) {
w->left->black = true;
w->black = false;
right_rotate(w);
w = x->parent->right;
}
w->black = x->parent->black;
x->parent->black = true;
w->right->black = true;
left_rotate(x->parent);
x = root;
}
} else {
node* w = x->parent->left;
if (!w->black) {
w->black = true;
x->parent->black = false;
right_rotate(x->parent);
w = x->parent->left;
}
if (w->left->black && w->right->black) {
w->black = false;
x = x->parent;
} else {
if (w->left->black) {
w->right->black = true;
w->black = false;
left_rotate(w);
w = x->parent->left;
}
w->black = x->parent->black;
x->parent->black = true;
w->left->black = true;
right_rotate(x->parent);
x = root;
}
}
}
x->black = true;
}
inline node* clone(node* x, node* y) {
if (!x->count) return nil;
node* z = new node(*x);
z->left = clone(x->left, z);
z->right = clone(x->right, z);
z->parent = y;
return z;
}
public:
class Iterator {
private:
node* pointer;
friend class Set;
inline node* precursor(node* x) {
if (x->left->count) {
x = x->left;
while (x->right->count) x = x->right;
return x;
} else {
node* y = x->parent;
while (y->count && x == y->left) {
x = y;
y = y->parent;
}
return y;
}
}
inline node* successor(node* x) {
if (x->right->count) {
x = x->right;
while (x->left->count) x = x->left;
return x;
} else {
node* y = x->parent;
while (y->count && x == y->right) {
x = y;
y = y->parent;
}
return y;
}
}
public:
inline Iterator(node* _pointer) : pointer(_pointer) {}
inline ~Iterator() {}
inline bool operator==(const Iterator& a) { return pointer == a.pointer; }
inline bool operator!=(const Iterator& a) { return pointer != a.pointer; }
inline VALUE_TYPE operator*() { return pointer->value; }
inline VALUE_TYPE* operator->() { return &pointer->value; }
inline Iterator& operator++() {
pointer = successor(pointer);
return *this;
}
inline Iterator operator++(int) {
Iterator t = *this;
pointer = successor(pointer);
return t;
}
inline Iterator& operator--() {
pointer = precursor(pointer);
return *this;
}
inline Iterator operator--(int) {
Iterator t = *this;
pointer = precursor(pointer);
return t;
}
};
inline Set() { root = nil = new node(VALUE_TYPE(), 0, 0, 0, true, 0, 0); }
inline Set(const Set& a) {
nil = new node(*a.nil);
root = clone(a.root, nil);
}
inline ~Set() {
clear(root);
delete nil;
}
inline Set& operator=(const Set& a) {
clear(root);
root = clone(a.root, nil);
return *this;
}
Iterator Begin() {
node* z = root;
while (z != nil && z->left != nil) z = z->left;
return Iterator(z);
}
Iterator ReverseBegin() {
node* z = root;
while (z != nil && z->right != nil) z = z->right;
return Iterator(z);
}
Iterator End() { return Iterator(nil); }
Iterator ReverseEnd() { return Iterator(nil); }
inline void Clear() {
clear(root);
root = nil;
}
inline void Insert(const VALUE_TYPE& a) {
node *y = nil, *x = root;
while (x != nil) {
y = x;
++x->size;
if (COMPARER_TYPE()(a, x->value))
x = x->left;
else if (COMPARER_TYPE()(x->value, a))
x = x->right;
else {
++x->count;
return;
}
}
node* z = new node(a, nil, nil, y, false, 1, 1);
if (y == nil)
root = z;
else if (COMPARER_TYPE()(z->value, y->value))
y->left = z;
else
y->right = z;
insert_fixup(z);
}
inline void Erase(const Iterator& a) {
node* z = root;
while (true) {
z->size -= a.pointer->count;
if (COMPARER_TYPE()(a.pointer->value, z->value))
z = z->left;
else if (COMPARER_TYPE()(z->value, a.pointer->value))
z = z->right;
else
break;
}
erase(z);
}
inline void Erase(const VALUE_TYPE& a) {
node* z = root;
while (true) {
--z->size;
if (COMPARER_TYPE()(a, z->value))
z = z->left;
else if (COMPARER_TYPE()(z->value, a))
z = z->right;
else
break;
}
if (!--z->count) erase(z);
}
inline int Count(const VALUE_TYPE& a) {
node* z = root;
while (z != nil) {
if (COMPARER_TYPE()(a, z->value))
z = z->left;
else if (COMPARER_TYPE()(z->value, a))
z = z->right;
else
return z->count;
}
return 0;
}
inline int CountLess(const VALUE_TYPE& a) {
int r = 0;
node* z = root;
while (z != nil) {
if (COMPARER_TYPE()(z->value, a)) {
r += z->left->size + z->count;
z = z->right;
} else
z = z->left;
}
return r;
}
inline int CountLessEqual(const VALUE_TYPE& a) {
int r = 0;
node* z = root;
while (z != nil) {
if (!COMPARER_TYPE()(a, z->value)) {
r += z->left->size + z->count;
z = z->right;
} else
z = z->left;
}
return r;
}
inline int CountGreater(const VALUE_TYPE& a) {
int r = 0;
node* z = root;
while (z != nil) {
if (COMPARER_TYPE()(a, z->value)) {
r += z->right->size + z->count;
z = z->left;
} else
z = z->right;
}
return r;
}
inline int CountGreaterEqual(const VALUE_TYPE& a) {
int r = 0;
node* z = root;
while (z != nil) {
if (!COMPARER_TYPE()(z->value, a)) {
r += z->right->size + z->count;
z = z->left;
} else
z = z->right;
}
return r;
}
inline Iterator NthElement(int a) {
node* z = root;
while (true) {
if (z->left->size > a)
z = z->left;
else if (z->left->size + z->count <= a) {
a -= z->left->size + z->count;
z = z->right;
} else
return Iterator(z);
}
}
inline Iterator Precursor(const VALUE_TYPE& a) {
node *z = root, *r = nil;
while (z != nil) {
if (COMPARER_TYPE()(z->value, a)) {
r = z;
z = z->right;
} else
z = z->left;
}
return Iterator(r);
}
inline Iterator Successor(const VALUE_TYPE& a) {
node *z = root, *r = nil;
while (z != nil) {
if (COMPARER_TYPE()(a, z->value)) {
r = z;
z = z->left;
} else
z = z->right;
}
return Iterator(r);
}
inline int Size() { return root->size; }
inline int Empty() { return root->size == 0; }
inline VALUE_TYPE Front() { return *Begin(); }
inline VALUE_TYPE Back() { return *ReverseBegin(); }
};
} // namespace DataStructures
namespace NetworkFlow {
template <typename FLOW_TYPE>
class MaxFlow {
private:
class edge {
public:
int v;
FLOW_TYPE c;
inline edge(const int& _v, const FLOW_TYPE& _c) : v(_v), c(_c) {}
};
std::vector<edge> edges;
std::vector<std::vector<int> > start;
std::vector<int> height, gap, cur, from;
int n, source, sink;
FLOW_TYPE limit;
inline void label() {
height[sink] = 0;
std::queue<int> qu;
qu.push(sink);
while (!qu.empty()) {
int u = qu.front();
qu.pop();
for (std::vector<int>::iterator i = start[u].begin(); i != start[u].end();
++i) {
edge &e = edges[*i], &ev = edges[(*i) ^ 1];
if (ev.c != FLOW_TYPE(0) && height[e.v] == n) {
height[e.v] = height[u] + 1;
qu.push(e.v);
}
}
}
for (int i = 0; i < n; ++i) ++gap[height[i]];
}
inline FLOW_TYPE augment() {
FLOW_TYPE f = limit;
for (int u = sink; u != source; u = edges[from[u] ^ 1].v)
f = std::min(f, edges[from[u]].c);
for (int u = sink; u != source; u = edges[from[u] ^ 1].v) {
edges[from[u]].c -= f;
edges[from[u] ^ 1].c += f;
}
return f;
}
public:
inline MaxFlow(const int& _n, const int& _source, const int& _sink,
const FLOW_TYPE& _limit)
: start(_n),
height(_n, _n),
gap(_n + 1),
n(_n),
cur(_n),
from(_n),
source(_source),
sink(_sink),
limit(_limit) {}
inline void AddEdge(const int& u, const int& v, const FLOW_TYPE& c) {
start[u].push_back(edges.size());
edges.push_back(edge(v, c));
start[v].push_back(edges.size());
edges.push_back(edge(u, FLOW_TYPE(0)));
}
inline FLOW_TYPE Run() {
label();
FLOW_TYPE r = FLOW_TYPE(0);
int u = source;
while (height[source] != n && limit != FLOW_TYPE(0)) {
if (u == sink) {
FLOW_TYPE t = augment();
limit -= t;
r += t;
u = source;
}
bool flag = false;
for (std::vector<int>::iterator i = start[u].begin() + cur[u];
i != start[u].end(); ++i, ++cur[u]) {
edge& e = edges[*i];
if (e.c != FLOW_TYPE(0) && height[u] == height[e.v] + 1) {
flag = true;
from[e.v] = *i;
cur[u] = i - start[u].begin();
u = e.v;
break;
}
}
if (!flag) {
int mh = n - 1;
for (std::vector<int>::iterator i = start[u].begin();
i != start[u].end(); ++i) {
edge& e = edges[*i];
if (e.c != FLOW_TYPE(0)) mh = std::min(mh, height[e.v]);
}
if (!--gap[height[u]]) break;
++gap[height[u] = mh + 1];
cur[u] = 0;
if (u != source) u = edges[from[u] ^ 1].v;
}
}
return r;
}
};
template <typename FLOW_TYPE>
class MaxFlow2 {
private:
class edge {
public:
int v;
FLOW_TYPE c;
inline edge(const int& _v, const FLOW_TYPE& _c) : v(_v), c(_c) {}
};
std::vector<edge> edges;
std::vector<std::vector<int> > start;
std::vector<int> height, cur, gap;
std::vector<FLOW_TYPE> save;
int n, source, sink;
inline void label() {
height[sink] = 0;
std::queue<int> qu;
qu.push(sink);
while (!qu.empty()) {
int u = qu.front();
qu.pop();
for (std::vector<int>::iterator i = start[u].begin(); i != start[u].end();
++i) {
edge &e = edges[*i], &ev = edges[(*i) ^ 1];
if (ev.c != FLOW_TYPE(0) && height[e.v] == n) {
height[e.v] = height[u] + 1;
qu.push(e.v);
}
}
}
for (int i = 0; i < n; ++i)
if (i != source && height[i] > 0 && height[i] < n) ++gap[height[i]];
}
public:
inline MaxFlow2(const int& _n, const int& _source, const int& _sink)
: start(_n),
height(_n, _n),
n(_n),
cur(_n),
gap(_n),
save(_n),
source(_source),
sink(_sink) {}
inline void AddEdge(const int& u, const int& v, const FLOW_TYPE& c) {
start[u].push_back(edges.size());
edges.push_back(edge(v, c));
start[v].push_back(edges.size());
edges.push_back(edge(u, FLOW_TYPE(0)));
}
inline FLOW_TYPE Run() {
label();
for (std::vector<int>::iterator i = start[source].begin();
i != start[source].end(); ++i) {
edge &e = edges[*i], &ev = edges[(*i) ^ 1];
save[e.v] += e.c;
save[source] -= e.c;
ev.c += e.c;
e.c = 0;
}
std::vector<int> nxt(n), pre(n);
nxt[source] = sink;
pre[sink] = source;
for (int i = 0; i < n; ++i)
if (i != source && i != sink) {
nxt[i] = nxt[source];
pre[nxt[source]] = i;
nxt[source] = i;
pre[i] = source;
}
for (int u = nxt[source]; u != sink; u = nxt[u]) {
bool flag = false;
while (save[u] > FLOW_TYPE(0)) {
for (std::vector<int>::iterator i = start[u].begin();
i != start[u].end(); ++i, ++cur[u]) {
edge &e = edges[*i], &ev = edges[(*i) ^ 1];
if (e.c != FLOW_TYPE(0) && height[u] == height[e.v] + 1) {
FLOW_TYPE t = std::min(save[u], e.c);
save[e.v] += t;
save[u] -= t;
ev.c += t;
e.c -= t;
if (save[u] == FLOW_TYPE(0)) break;
}
}
if (save[u] != FLOW_TYPE(0)) {
int mh = 2 * n - 2;
for (std::vector<int>::iterator i = start[u].begin();
i != start[u].end(); ++i) {
edge& e = edges[*i];
if (e.c != FLOW_TYPE(0)) mh = std::min(mh, height[e.v]);
}
int old = height[u];
if (height[u] > 0 && height[u] < n) --gap[height[u]];
height[u] = mh + 1;
if (height[u] > 0 && height[u] < n) ++gap[height[u]];
if (old > 0 && old < n && !gap[old])
for (int i = 0; i < n; ++i)
if (i != source && height[i] > old) {
if (height[i] < n) --gap[height[i]];
height[i] = std::max(height[i], n + 1);
cur[i] = 0;
}
cur[u] = 0;
flag = true;
}
}
if (flag) {
nxt[pre[u]] = nxt[u];
pre[nxt[u]] = pre[u];
pre[nxt[source]] = u;
nxt[u] = nxt[source];
nxt[source] = u;
pre[u] = source;
}
}
return save[sink];
}
};
} // namespace NetworkFlow
using namespace std;
using namespace CoreLibrary;
using namespace DataStructures;
using namespace NetworkFlow;
int tmain() {
Reader reader("1.in");
Writer writer("1.out");
int n, m;
reader >> n >> m;
MaxFlow2<long long> flow(n, 0, n - 1);
for (int i = 1; i <= m; ++i) {
int u, v, c;
reader >> u >> v >> c;
flow.AddEdge(u - 1, v - 1, c);
flow.AddEdge(v - 1, u - 1, c);
}
writer << flow.Run() << '\n';
return 0;
}
template <typename value_type>
inline void read_value(value_type& a) {
char c;
for (c = getchar(); !isdigit(c) && c != '-'; c = getchar())
;
a = value_type(0);
bool flag = c == '-';
for (; isdigit(c); c = getchar())
a = a * value_type(10) + value_type(c - '0');
if (flag) a = -a;
}
template <typename value_type>
inline void print_value(value_type a) {
bool flag = a < value_type(0);
if (flag) a = -a;
std::vector<char> t;
do {
t.push_back(a % 10 + '0');
a /= 10;
} while (a != value_type(0));
if (flag) putchar('-');
for (int i = int(t.size()) - 1; i >= 0; --i) putchar(t[i]);
}
const int MAX_SIDE = 2000010, MAX_NODE = 20010;
class network_flow {
private:
int label[MAX_NODE], GAP[MAX_NODE];
bool visited[MAX_NODE];
int in_flow[MAX_NODE];
int vS, vT;
int tot_node, label_max;
queue<int> active[MAX_NODE];
public:
struct EDGES {
int pre[MAX_SIDE], val[MAX_SIDE], node[MAX_SIDE], last[MAX_NODE];
int tot;
EDGES() { tot = 1; }
void add_edge(int s, int t, int v) {
tot++;
pre[tot] = last[s];
node[tot] = t;
val[tot] = v;
last[s] = tot;
}
} edge;
void set_s(int s) { vS = s; }
void set_t(int t) { vT = t; }
void set_tot_node(int n) { tot_node = n; }
void HLPP() {
get_length();
prepare();
max_flow();
}
void add_edge(int s, int t, int v) {
++s;
++t;
edge.add_edge(s, t, v);
edge.add_edge(t, s, 0);
}
void max_flow() {
while (label_max) {
if (active[label_max].empty()) {
label_max--;
continue;
}
int now = active[label_max].front(), ext, val;
int label_min = tot_node + 1;
int push_flow;
active[label_max].pop();
for (int pos(edge.last[now]); pos; pos = edge.pre[pos]) {
ext = edge.node[pos];
val = edge.val[pos];
if (val > 0) {
if (label[ext] + 1 == label[now]) {
push_flow = min(val, in_flow[now]);
edge.val[pos] -= push_flow;
edge.val[pos ^ 1] += push_flow;
in_flow[now] -= push_flow;
in_flow[ext] += push_flow;
if (push_flow) active[label[ext]].push(ext);
}
}
if (edge.val[pos]) label_min = min(label_min, label[ext]);
if (!in_flow[now]) break;
}
if (in_flow[now] && now != vT && label_min < tot_node) {
int cache = label[now];
GAP[label[now]]--;
label[now] = label_min + 1;
GAP[label[now]]++;
if (GAP[cache] == 0) {
for (int i(1); i <= tot_node; ++i)
if (label[i] > cache && label[i] < tot_node + 1) {
GAP[label[i]]--;
GAP[tot_node + 1]++;
label[i] = tot_node + 1;
}
}
active[label[now]].push(now);
if (label[now] > label_max) label_max = label[now];
}
}
}
void prepare() {
for (int pos(edge.last[vS]); pos; pos = edge.pre[pos]) {
int ext = edge.node[pos], val = edge.val[pos];
if (val > 0) {
in_flow[ext] += val;
edge.val[pos] -= val;
edge.val[pos ^ 1] += val;
if (label[ext] > label_max) label_max = label[ext];
active[label[ext]].push(ext);
}
}
}
void get_length() {
int queue[MAX_NODE];
fill(label + 1, label + 1 + tot_node, tot_node + 1);
memset(visited, 0, sizeof(visited));
queue[0] = vT;
label[vT] = 0;
visited[vT] = 1;
GAP[0] = 1;
GAP[tot_node + 1] = tot_node - 1;
for (int p1(0), p2(0); p1 <= p2; ++p1) {
int now = queue[p1], ext;
for (int pos(edge.last[now]); pos; pos = edge.pre[pos]) {
ext = edge.node[pos];
if (!visited[ext]) {
visited[ext] = 1;
queue[++p2] = ext;
label[ext] = label[now] + 1;
GAP[tot_node + 1]--;
GAP[label[ext]]++;
}
}
}
}
int get_ans() { return in_flow[vT]; }
} net;
int n, m, g, sex[10010];
int main() {
read_value(n);
read_value(m);
read_value(g);
net.set_s(1);
net.set_t(n + m + 2);
net.set_tot_node(n + m + 2);
for (int i = 1; i <= n; ++i) read_value(sex[i]);
for (int i = 1; i <= n; ++i) {
int v;
read_value(v);
if (!sex[i])
net.add_edge(0, i, v);
else
net.add_edge(i, n + m + 1, v);
}
int ans = 0;
for (int i = 1; i <= m; ++i) {
int tsex, w, k, isf;
read_value(tsex);
read_value(w);
read_value(k);
ans += w;
for (int j = 1; j <= k; ++j) {
int t;
read_value(t);
if (!tsex)
net.add_edge(n + i, t, ~0u >> 1);
else
net.add_edge(t, n + i, ~0u >> 1);
}
read_value(isf);
if (!tsex)
net.add_edge(0, n + i, w + isf * g);
else
net.add_edge(n + i, n + m + 1, w + isf * g);
}
net.HLPP();
print_value(ans - net.get_ans());
putchar('\n');
return 0;
}
| 7 |
#include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define ls (x<<1)
#define rs (x<<1|1)
#define db double
#define all(x) x.begin(),x.end()
#define ll long long
#define pll pair<ll,ll>
#define pii pair<int,int>
#define CK CLOCKS_PER_SEC
#define eps 1e-9
#define inf 0x3f3f3f3f
using namespace std;
const int M=1e5+7;
const int N=5e5+7;
const int Z=1e7+2;
const int mod=1e9+7;
int T;
int n;
struct edge{
int to,nxt;
}eg[N];
int head[N];
int cnt;
void add(int x,int y){
++cnt;eg[cnt].nxt=head[x];eg[cnt].to=y;head[x]=cnt;
++cnt;eg[cnt].nxt=head[y];eg[cnt].to=x;head[y]=cnt;
}
int siz[N];
vector<int>son[N];
void dfs(int x,int fa){
siz[x]=1;
son[x].clear();
for(int e=head[x];e;e=eg[e].nxt){
int v=eg[e].to;
if(v==fa)continue;
son[x].pb(v);
dfs(v,x);siz[x]+=siz[v];
// dis[x]=max(dis[v]+1,dis[x]);
}
}
int dp[N],dp1[N];
vector<int>vec;
void dfs1(int x,int fa){
if(siz[x]==1){
dp[x]=0;dp1[x]=0;return;
}
dp[x]=inf;dp1[x]=0;
int sz=son[x].size();
for(int e=head[x];e;e=eg[e].nxt){
int v=eg[e].to;if(v==fa)continue;
dfs1(v,x);
dp[x]=min(dp[v]+1,dp[x]);
dp1[x]=max(dp1[x],dp1[v]);
}
vec.clear();
for(int i=0;i<sz;i++){
vec.pb(dp[son[x][i]]);
}
sort(vec.begin(),vec.end());
if(x==1){
if(sz>=2){
dp1[x]=max(dp1[x],vec[sz-2]+2);
}
dp1[x]=max(dp1[x],vec[sz-1]+1);
}
else{
dp1[x]=max(dp1[x],vec[sz-1]+2);
}
}
void solve(){
scanf("%d",&n);
cnt=0;
for(int i=1;i<=n;i++)head[i]=0;
for(int i=0;i<n-1;i++){
int x,y;
scanf("%d%d",&x,&y);add(x,y);
}
dfs(1,0);
dfs1(1,0);
// cout<<"\n";
// for(int i=1;i<=n;i++){
// cout<<dp[i]<<" "<<dp1[i]<<"\n";
// }
cout<<dp1[1]<<"\n";
}
int main(){
scanf("%d",&T);
while(T--){
solve();
}
} | 7 |
#include <bits/stdc++.h>
using namespace std;
bool p(string s) {
string s1 = s;
reverse(s1.begin(), s1.end());
if (s == s1) return 1;
return 0;
}
int main() {
long long n;
cin >> n;
pair<long long, long long> a[n];
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
int i = 0;
int k = 1;
long long b[n];
while (i < n) {
long long x = i;
i += n - a[i].first;
if (i > n) {
cout << "Impossible";
return 0;
}
if (a[i - 1].first != a[x].first) {
cout << "Impossible";
return 0;
}
for (int j = x; j < i; j++) {
b[a[j].second] = k;
}
k++;
}
cout << "Possible" << endl;
for (int i = 0; i < n; i++) cout << b[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<long long> v(n), so(n);
for (long long i = 0; i < n; ++i) {
cin >> v[i];
so[i] = v[i];
}
sort(so.begin(), so.end());
long long m;
cin >> m;
for (long long i = 0; i < m; ++i) {
long long k, pos;
cin >> k >> pos;
map<long long, long long> mp;
for (long long j = n - k; j < n; ++j) {
mp[so[j]]++;
}
for (long long j = 0; j < n; ++j) {
if (mp.count(v[j]) and mp[v[j]] > 0) {
--pos;
mp[v[j]]--;
}
if (pos == 0) {
cout << v[j] << endl;
break;
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
{ solve(); }
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int a, b;
int gt2b = 0;
int gta = 0;
bool ex = false;
cin >> a >> b;
string s;
cin >> s;
int cnt = 0;
int len = 0;
for (auto it : s) {
if (it == '.')
cnt++;
else {
if (cnt >= 2 * b) {
gt2b++;
len = cnt;
}
if (cnt >= a) gta++;
if (cnt >= b && cnt < a) ex = true;
cnt = 0;
}
}
if (cnt > 0) {
if (cnt >= 2 * b) {
gt2b++;
len = cnt;
}
if (cnt >= a) gta++;
if (cnt >= b && cnt < a) ex = true;
cnt = 0;
}
if (gt2b >= 2 || ex)
puts("NO");
else if (gt2b == 0) {
if (gta % 2 == 1)
puts("YES");
else
puts("NO");
} else if (gt2b == 1) {
if (a > len) {
puts("NO");
} else {
bool f = false;
gta--;
for (int i = 0; i <= len - a; i++) {
int pre = i;
int last = len - i - a;
int gtaa = gta;
if (last >= b && last < a || pre >= b && pre < a) continue;
if (pre >= 2 * b || last >= 2 * b) continue;
if (pre >= a) gtaa++;
if (last >= a) gtaa++;
if (gtaa % 2 == 0) {
f = true;
break;
}
}
if (f)
puts("YES");
else
puts("NO");
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 14;
int n, m, ans, dp[maxn][maxn];
string s, p;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m >> s >> p;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
dp[i][j] = max({0, dp[i - 1][j] - 1, dp[i][j - 1] - 1});
if (s[i - 1] == p[j - 1]) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 2);
ans = max(ans, dp[i][j]);
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[5001][3];
char str[5002];
int N;
int solve(int idx, int flag) {
if (idx == N) return 0;
int &ret = dp[idx][flag];
if (ret != -1) return ret;
ret = -987654321;
if (flag == 0) {
ret = max(ret, solve(idx + 1, 0) + (str[idx] == 'a' ? 1 : 0));
ret = max(ret, solve(idx + 1, 1) + (str[idx] == 'a' ? 1 : 0));
} else if (flag == 1) {
ret = max(ret, solve(idx + 1, 1) + (str[idx] == 'b' ? 1 : 0));
ret = max(ret, solve(idx + 1, 2) + (str[idx] == 'b' ? 1 : 0));
} else {
ret = max(ret, solve(idx + 1, 2) + (str[idx] == 'a' ? 1 : 0));
}
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%s", &str);
N = strlen(str);
printf("%d\n", max(solve(0, 1), max(solve(0, 2), solve(0, 0))));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
long long equ[4005][4005];
long long C[4005][4005];
long long toteq[4005];
long long DP[4005];
int main() {
toteq[0] = 1;
equ[1][1] = 1;
toteq[1] = 1;
for (int i = 2; i < 4005; i++) {
toteq[i] = 2;
equ[i][1] = equ[i][i] = 1;
for (int j = 2; j < i; j++) {
equ[i][j] = (j * equ[i - 1][j] + equ[i - 1][j - 1]) % mod;
toteq[i] = (toteq[i] + equ[i][j]) % mod;
}
}
C[1][0] = C[1][1] = 1;
for (int i = 2; i < 4005; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
int n;
scanf("%d", &n);
DP[1] = 1;
for (int j = 2; j <= n; j++) {
DP[j] = 0;
int sig = 1;
for (int i = 1; i <= j; i++) {
DP[j] =
(DP[j] + sig * (((toteq[j - i] + DP[j - i]) * C[j][i]) % mod) + mod) %
mod;
sig *= -1;
}
}
cout << DP[n] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int o = 0; o < t; o++) {
int a, b, c;
cin >> a >> b >> c;
int x = (a - b + c + 1) / 2;
cout << max(min(c + 1, x), 0) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
bool minus = false;
set<int> ans;
cin >> n >> m;
vector<vector<char>> grid(n, vector<char>(m));
for (int i = 0; i < n; i++) {
scanf("%c", &grid[i][0]);
for (int j = 0; j < m; j++) {
scanf("%c", &grid[i][j]);
}
}
for (int i = 0; i < n; i++) {
bool dawrf_found = false, star_found = false;
int tout = 0;
for (int j = 0; j < m; j++) {
dawrf_found |= grid[i][j] == 'G';
if (grid[i][j] == 'S') {
star_found = dawrf_found;
break;
}
if (dawrf_found) {
tout++;
}
}
ans.insert(tout);
if (star_found == false) {
minus = true;
}
}
cout << (minus ? -1 : (int)ans.size()) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int N = 1 << 20;
char buf[N], *t1 = buf, *t2 = buf;
inline int read() {
static int an, f;
an = 0, f = 1;
static char ch;
ch = t1 == t2 && (t2 = (t1 = buf) + fread(buf, 1, N, stdin), t1 == t2)
? EOF
: *t1++;
while (ch < 48 || ch > 57)
ch == '-' ? f = -1 : 0,
ch = t1 == t2 && (t2 = (t1 = buf) + fread(buf, 1, N, stdin),
t1 == t2)
? EOF
: *t1++;
while (ch >= 48 && ch <= 57)
an = (an << 3) + (an << 1) + (ch ^ 48),
ch = t1 == t2 && (t2 = (t1 = buf) + fread(buf, 1, N, stdin), t1 == t2)
? EOF
: *t1++;
return an * f;
}
char buff[N], *T = buff;
void flush() {
fwrite(buff, 1, T - buff, stdout);
T = buff;
}
inline void putc(char ch) {
if (T == buff + N) flush();
*T++ = ch;
}
inline void print(int x) {
if (x < 0) putc('-'), x = -x;
if (!x) return putc('0'), void();
static int st[20], tp;
while (x) st[++tp] = x % 10, x /= 10;
while (tp) putc(st[tp] ^ 48), --tp;
}
} // namespace io
using io::flush;
using io::print;
using io::putc;
using io::read;
int T, n, k, a[100010], sum[100010];
int main() {
T = read();
while (T--) {
n = read(), k = read();
for (int i = 1; i <= n; ++i) a[i] = read();
bool flag = 0;
for (int i = 1; i <= n; ++i) flag |= a[i] == k;
if (!flag) {
printf("no\n");
continue;
}
if (n == 1) {
printf("yes\n");
continue;
}
flag = 0;
int mi = 0x3f3f3f3f;
for (int i = 1; i <= n; ++i) {
sum[i] = sum[i - 1];
if (a[i] >= k)
++sum[i];
else
--sum[i];
if (sum[i] > mi) {
flag = 1;
printf("yes\n");
break;
}
mi = min(mi, sum[i - 1]);
}
if (!flag) printf("no\n");
}
flush();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e2 + 10;
const int MOD = 1e9 + 7;
long long int a[MAXN];
long long int dp[MAXN][MAXN];
int n, m, k;
void ceshi() {
for (int i = 0; i <= k; ++i) {
for (int j = 0; j <= n; ++j) {
printf("%I64d ", dp[i][j]);
}
printf("\n");
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &a[i]);
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
if (n / m > k) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= k; ++i) {
for (int j = i; j <= n; ++j) {
for (int v = max(0, j - m); v <= j - 1; ++v) {
if (dp[i - 1][v] != -1) {
dp[i][j] = max(dp[i][j], dp[i - 1][v] + a[j]);
}
}
}
}
long long int ans = 0;
for (int i = n; i >= n - m + 1; --i) {
ans = max(ans, dp[k][i]);
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define boost \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define pb push_back
#define all(x) x.begin(), x.end()
#define se second
#define fi first
ll MOD = 1e9 + 7;
ll INFMAX = 1e16, INFMIN = -1e18;
const ll N = 2e5 + 5;
void peace(ll tc)
{
ll n;
cin >> n;
vector<ll> arr(n);
for (ll i = 0; i < n; i++)
arr[i] = i + 1;
for (ll i = 1; i < n; i += 2)
{
swap(arr[i], arr[i - 1]);
}
if (n & 1)
swap(arr[n - 1], arr[n - 2]);
for (auto x : arr)
{
cout << x << " ";
}
cout << "\n";
}
int main()
{
boost;
ll t;
t = 1;
//----------
cin >> t;
//----------
for (ll i = 1; i <= t; i++)
{
peace(i);
}
// ll T = clock();
// cerr << "\n\nTIME: " << (double)(clock() - T) / CLOCKS_PER_SEC << " sec\n";
// T = clock();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const string nl = "\n";
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
long long n;
cin >> n;
vector<long long> a(n);
for (auto& i : a) {
cin >> i;
}
vector<long long> dp;
for (long long i = 0; i < n; ++i) {
auto it = lower_bound(dp.begin(), dp.end(), a[i]);
if (it == dp.end()) {
dp.push_back(a[i]);
} else {
*it = a[i];
}
}
cout << ((long long)(dp).size()) << nl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
cin >> x;
}
template <typename T, typename T0>
void read(T &x, T0 &y) {
cin >> x >> y;
}
template <typename T, typename T0, typename T1>
void read(T &x, T0 &y, T1 &z) {
cin >> x >> y >> z;
}
template <typename T, typename T0, typename T1, typename T2>
void read(T &x, T0 &y, T1 &z, T2 &w) {
cin >> x >> y >> z >> w;
}
template <typename T, typename T0>
void read(pair<T, T0> &p) {
cin >> p.first >> p.second;
}
template <typename T>
void read(vector<T> &oneD) {
for (long long i = 0; i < oneD.size(); i++) {
read(oneD[i]);
}
}
template <typename T>
void read(T oneD[], int n) {
for (long long i = 0; i < n; i++) {
read(oneD[i]);
}
}
template <typename T>
void write(T &x) {
cout << x << " ";
}
template <typename T, typename T0>
void write(T &x, T0 &y) {
cout << x << " " << y << "\n";
}
template <typename T, typename T0, typename T1>
void write(T &x, T0 &y, T1 &z) {
cout << x << " " << y << " " << z << "\n";
}
template <typename T, typename T0, typename T1, typename T2>
void write(T &x, T0 &y, T1 &z, T2 &w) {
cout << x << " " << y << " " << z << " " << w << "\n";
}
template <typename T, typename T0>
void write(pair<T, T0> &p) {
write(p.first);
write(p.second);
cout << "\n";
}
template <typename T>
void write(vector<T> &oneD) {
for (long long i = 0; i < oneD.size(); i++) {
write(oneD[i]);
}
cout << "\n";
}
template <typename T>
void write(T oneD[], int n) {
for (long long i = 0; i < n; i++) {
write(oneD[i]);
}
cout << "\n";
}
template <typename T, typename T0>
void write(map<T, T0> &mpp) {
for (auto it : mpp) {
write(it.first);
cout << ": ";
write(it.second);
cout << "\n";
}
cout << "\n";
}
vector<long long> sieve;
void Sieve(int N) {
const long long maxn = N;
sieve.resize(maxn);
for (long long(i) = 0; (i) < (maxn); ++(i)) sieve[i] = i;
sieve[1] = -1;
sieve[0] = -1;
for (long long(i) = 2; (i) <= (maxn); (i) += (1))
if (i == sieve[i])
for (long long j = 2 * i; j < maxn; j += i)
if (sieve[j] == j) sieve[j] = i;
}
long long extended_GCD(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long gcd = extended_GCD(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
}
long long power(long long a, long long b, long long m = 1000000007) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long modinv(long long a, long long mod = 1000000007) {
long long x, y;
extended_GCD(a, mod, x, y);
if (x < 0) x += mod;
return x;
}
const int N = 1e3 + 1;
const int maxN = 2e5 + 1;
int pref[maxN];
void solve() {
int n;
cin >> n;
vector<int> A(n);
read(A);
memset(pref, 0, sizeof pref);
for (long long(i) = 0; (i) < (n); ++(i)) {
for (long long(j) = 0; (j) < (n); ++(j)) {
pref[A[i] + A[j]]++;
}
}
int ans = 0;
for (long long(i) = 0; (i) < (maxN); ++(i)) {
ans = max(pref[i], ans);
}
ans /= 2;
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
;
long long tt;
cin >> tt;
while (tt--) {
long long n;
cin >> n;
long long cnt = 1;
long long t = 4;
for (long long i = 4 * n; i >= 2 * n + 2; i -= 2) {
cout << i << " ";
}
cout << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[1005];
int main() {
int n;
while (cin >> n) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int k = n - 1;
for (int i = 0;; i++) {
if (!a[0]) break;
for (int j = 0; j < n; j++) {
if (j % 2 == 0) {
a[j]++;
if (a[j] == n) a[j] = 0;
} else {
a[j]--;
if (a[j] == -1) a[j] = k;
}
}
}
k = 1;
for (int i = 1; i < n; i++) {
if (a[i] - a[i - 1] != 1) {
k = 0;
break;
}
}
if (k)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 500;
int a[N][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<string> s(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) {
a[i][j] = (s[i][j] == '1');
}
}
long long ans = 0;
for (int l = 0; l < n; l++) {
vector<int> mid(m);
vector<int> vl(m), vr(m);
for (int r = l + 2; r < n; r++) {
for (int j = 1; j + 1 < m; j++) {
if (a[r - 2][j] && a[r - 1][j] && a[r][j] && a[r - 1][j - 1] &&
a[r - 1][j + 1]) {
mid[j]++;
}
}
auto x = mid;
x.erase(x.begin());
x.pop_back();
vector<int> p(x.size() + 1);
int s = 0;
for (int i = 0; i < (int)x.size(); i++) {
s += x[i];
p[i + 1] = s;
}
for (int l = 0; l < (int)x.size(); l++) {
int vl = l, vr = (int)p.size();
while (vl < vr - 1) {
int vm = (vl + vr) / 2;
if (p[vm] - p[l] >= k) {
vr = vm;
} else {
vl = vm;
}
}
ans += (int)p.size() - vr;
}
}
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
T gcd(T a, T b) {
return ((b == 0) ? a : gcd(b, a % b));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m, k, k1;
cin >> n >> m >> k;
k1 = k;
if (((2 * n * m) % k != 0)) {
cout << "NO" << endl;
return 0;
}
long long a = 2 * m, b = n;
for (long long i = 2; (i * i) <= k; i++) {
while (k % i == 0) {
if (a % i == 0)
a /= i;
else
b /= i;
k /= i;
}
}
if (k > 1) {
if (a % k == 0)
a /= k;
else
b /= k;
}
if (a > m) {
a = m, b = 2 * n;
k = k1;
for (long long i = 2; (i * i) <= k; i++) {
while (k % i == 0) {
if (b % i == 0)
b /= i;
else
a /= i;
k /= i;
}
}
if (k > 1) {
if (b % k == 0)
b /= k;
else
a /= k;
}
cout << "YES" << endl;
cout << "0 0" << endl;
cout << 0 << " " << a << endl;
cout << b << " " << 0 << endl;
} else {
cout << "YES" << endl;
cout << "0 0" << endl;
cout << 0 << " " << a << endl;
cout << b << " " << 0 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
static int X[100];
for (int i = 0; i < N; i++) scanf("%d", &X[i]);
vector<int> Ans;
for (int i = 0, Count = 0, First = 0; i < N; i++) {
if (X[i] < 0) Count++;
if (i == N - 1 || (Count == 2 && X[i + 1] < 0)) {
Ans.push_back(i - First + 1);
First = i + 1;
Count = 0;
}
}
int M = Ans.size();
printf("%d\n", M);
for (int i = 0; i < M; i++) {
printf("%d", Ans[i]);
putchar((i + 1 == M) ? '\n' : ' ');
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int in() {
int ret;
cin >> ret;
return ret;
}
const int N = 2e5 + 10, INF = 1e9 + 7;
int n, k, a[N], b[N], MIN[N], sts[N], sz[N];
vector<int> adj[N];
void process(int v, int par) {
MIN[v] = a[v];
sts[v] = 1;
for (auto u : adj[v])
if (u != par) process(u, v), MIN[v] = min(MIN[v], MIN[u]), sts[v] += sts[u];
}
void downdfs(int v, int par, int val) {
sz[v] = 1;
int tmp = 0;
for (auto u : adj[v])
if (u != par) {
downdfs(u, v, val);
if (MIN[u] >= val)
sz[v] += sz[u];
else
tmp = max(tmp, sz[u]);
}
sz[v] += tmp;
if (a[v] < val) sz[v] = 0;
}
void updfs(int v, int par, int val, int x) {
int sum = 0, half = 0, i = 0, MAX = 0;
x == (sts[1] - sts[v]) ? sum = x : half = x;
for (auto u : adj[v])
if (u != par) {
if (MIN[u] >= val)
sum += sts[u];
else if (half < sz[u])
half = sz[u], i = u;
}
for (auto u : adj[v])
if (u != par && u != i && MIN[u] < val) MAX = max(MAX, sz[u]);
for (auto u : adj[v])
if (u != par) {
int tmp = sum + half + 1;
if (a[v] < val)
tmp = 0;
else {
if (MIN[u] >= val) tmp -= sts[u];
if (u == i) tmp -= half - MAX;
}
updfs(u, v, val, tmp);
}
sz[v] = sum + half + 1;
if (a[v] < val) sz[v] = 0;
}
bool check(int val) {
fill(sz, sz + N - 5, 0);
downdfs(1, 0, val);
updfs(1, 0, val, 0);
for (int i = 1; i <= n; i++)
if (sz[i] >= k) return true;
return false;
}
int solve(int l, int r) {
if (r - l < 2) return b[l];
int mid = (r + l) / 2;
if (check(b[mid])) return solve(mid, r);
return solve(l, mid);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
for (int i = 1; i < n; i++) {
int u = in(), v = in();
adj[u].push_back(v), adj[v].push_back(u);
}
process(1, 0);
sort(b + 1, b + n + 1);
cout << solve(1, n + 1) << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
long long a[n + 1][n + 1];
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
cin >> a[i][j];
}
}
int dp[2 * n][n + 1][n + 1];
dp[1][1][1] = a[1][1];
for (long long i = 2; i < 2 * n; i++) {
for (long long j = max((long long)(1), i - n + 1); j <= min(i, n); j++) {
for (long long k = max((long long)(1), i - n + 1); k <= min(i, n); k++) {
if (j == k) {
if (j == 1) {
dp[i][j][k] = dp[i - 1][j][k] + a[i - j + 1][j];
} else if (i - j == 0) {
dp[i][j][k] = dp[i - 1][j - 1][k - 1] + a[i - j + 1][j];
} else {
dp[i][j][k] = dp[i - 1][j - 1][k];
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][k - 1]);
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - 1][k - 1]);
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][k]);
dp[i][j][k] += a[i - j + 1][j];
}
} else {
if ((j == 1) && (k == i)) {
dp[i][j][k] =
a[i - j + 1][j] + a[i - k + 1][k] + dp[i - 1][j][k - 1];
} else if ((j == i) && (k == 1)) {
dp[i][j][k] =
a[i - j + 1][j] + a[i - k + 1][k] + dp[i - 1][j - 1][k];
} else if (j == 1) {
dp[i][j][k] = a[i - j + 1][j] + a[i - k + 1][k] +
max(dp[i - 1][j][k], dp[i - 1][j][k - 1]);
} else if (k == 1) {
dp[i][j][k] = a[i - j + 1][j] + a[i - k + 1][k] +
max(dp[i - 1][j][k], dp[i - 1][j - 1][k]);
} else if (i == j) {
dp[i][j][k] = a[i - j + 1][j] + a[i - k + 1][k] +
max(dp[i - 1][j - 1][k], dp[i - 1][j - 1][k - 1]);
} else if (i == k) {
dp[i][j][k] = a[i - j + 1][j] + a[i - k + 1][k] +
max(dp[i - 1][j][k - 1], dp[i - 1][j - 1][k - 1]);
} else {
dp[i][j][k] = max(dp[i - 1][j - 1][k - 1], dp[i - 1][j][k]);
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - 1][k]);
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j][k - 1]);
dp[i][j][k] += a[i - j + 1][j] + a[i - k + 1][k];
}
}
}
}
}
cout << dp[2 * n - 1][n][n] << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55;
const long long INF = 1e18;
long long nn[MAXN], mm[MAXN];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> nn[i];
for (int i = 0; i < m; i++) cin >> mm[i];
long long ans = INF;
for (int i = 0; i < n; i++) {
long long mx = -INF;
for (int j = 0; j < n; j++) {
if (i != j) {
for (int k = 0; k < m; k++) mx = max(mx, nn[j] * mm[k]);
}
}
ans = min(ans, mx);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[10], total;
string s = "NO";
cin >> arr[0] >> arr[1] >> arr[2] >> arr[3] >> arr[4] >> arr[5];
total = arr[0] + arr[1] + arr[2] + arr[3] + arr[4] + arr[5];
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 5; j++) {
for (int k = j + 1; k < 6; k++) {
if ((arr[i] + arr[j] + arr[k]) * 2 == total) {
s = "YES";
}
}
}
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void cetak(T t) {
cout << t << ')' << endl;
}
template <typename T, typename... V>
void cetak(T t, V... v) {
cout << t;
if (sizeof...(v)) cerr << ", ";
cetak(v...);
}
const int MOD = 1e9 + 7;
const int mx = 1e5 + 10;
string ss, k[mx];
int n, m[mx];
vector<int> isi[mx];
const int N = 1e5 + 5;
struct AhoCorasick {
int trie[N][26];
int fail[N];
int saiz;
int apa[N];
AhoCorasick() {
memset(trie[0], -1, sizeof trie[0]);
saiz = 0;
}
void res() {
for (int i = 0; i <= saiz; i++) {
apa[i] = 0;
for (int j = 0; j < 26; j++) {
trie[i][j] = -1;
}
}
saiz = 0;
}
void add(string str, int id) {
int cur = 0;
for (int i = 0; i < str.length(); i++) {
int nex = str[i] - 'a';
if (trie[cur][nex] == -1) {
trie[cur][nex] = ++saiz;
memset(trie[saiz], -1, sizeof trie[saiz]);
}
cur = trie[cur][nex];
}
apa[cur] = id;
}
void build() {
queue<int> q;
fail[0] = 0;
for (int i = 0; i < 26; i++)
if (trie[0][i] == -1)
trie[0][i] = 0;
else {
int nex = trie[0][i];
fail[nex] = 0;
q.push(nex);
}
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = 0; i < 26; i++)
if (trie[now][i] == -1)
trie[now][i] = trie[fail[now]][i];
else {
int nex = trie[now][i];
fail[nex] = trie[fail[now]][i];
q.push(nex);
}
}
}
int getIndex(string str) {
int cur = 0;
for (int i = 0; i < str.length(); i++) {
cur = trie[cur][str[i] - 'a'];
}
return cur;
}
};
AhoCorasick ini;
vector<int> occurance[mx];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> ss >> n;
for (int i = 1; i <= n; i++)
cin >> m[i] >> k[i], isi[(int)(k[i].size())].push_back(i);
for (int i = 1; i <= (int)(ss.size()); i++) {
if ((int)(isi[i].size()) == 0) continue;
ini.res();
for (int j : isi[i]) ini.add(k[j], j);
ini.build();
int cur = 0;
for (int j = 0; j < (int)(ss.size()); j++) {
cur = ini.trie[cur][ss[j] - 'a'];
int x = ini.apa[cur];
if (x == 0) continue;
occurance[x].push_back(j);
}
}
for (int i = 1; i <= n; i++) {
if ((int)(occurance[i].size()) < m[i]) {
cout << -1 << '\n';
continue;
}
int jaw = 1e9;
for (int l = 0; l < (int)(occurance[i].size()); l++) {
int r = l + m[i] - 1;
if (r >= (int)(occurance[i].size())) break;
jaw = min(jaw, occurance[i][r] -
(occurance[i][l] - (int)(k[i].size()) + 1) + 1);
}
cout << jaw << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(double t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]" << endl;
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long power(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long mod_inverse(long long a, long long p) { return power(a, p - 2, p); }
void swap(long long &x, long long &y) {
long long temp = x;
x = y;
y = temp;
}
vector<long long> sieve(long long n) {
long long *arr = new long long[n + 1]();
vector<long long> vect;
for (long long i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (long long j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mod_inverse(b, m), m) + m) % m;
}
long long modfact(long long n, long long p) {
if (p <= n) return 0;
long long res = (p - 1);
for (long long i = n + 1; i < p; i++) res = (res * mod_inverse(i, p)) % p;
return res;
}
long long fact(long long n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> v(n);
map<long long, long long> m;
m.insert({1e11, 1});
for (long long i = n - 1; i >= 0; i--) {
auto it = m.lower_bound(a[i]);
if (it == m.begin()) {
v[i] = -1;
m.insert({a[i], i});
} else {
it--;
v[i] = it->second - i - 1;
}
}
for (auto i : v) {
cout << i << " ";
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
auto start1 = high_resolution_clock::now();
solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(false);
long long int n;
cin >> n;
vector<long long int> a(n), start(n), end(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
start[i] = i;
end[i] = i + 1;
}
stack<pair<long long int, long long int>> s;
for (long long int i = 0; i < n; i++) {
while (!s.empty() && (a[i] | s.top().first) == a[i]) {
s.pop();
}
if (s.empty()) {
start[i] = 0;
} else {
start[i] = s.top().second + 1;
}
s.push(make_pair(a[i], i));
}
stack<pair<long long int, long long int>> s2;
for (long long int i = n - 1; i >= 0; i--) {
while (!s2.empty() && (a[i] | s2.top().first) == a[i]) {
s2.pop();
}
if (s2.empty()) {
end[i] = n;
} else {
end[i] = s2.top().second;
}
s2.push(make_pair(a[i], i));
}
unordered_map<long long int, long long int> last;
long long int good = (n * (n - 1)) / 2;
for (long long int i = 0; i < n; i++) {
if (last.count(a[i]) && last[a[i]] >= start[i]) {
good -= (i - last[a[i]]) * (end[i] - i) - 1;
last[a[i]] = i;
continue;
}
last[a[i]] = i;
good -= (i - start[i] + 1) * (end[i] - i) - 1;
}
cout << good << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a, b;
int main() {
cin >> n >> q;
for (int i = 1; i <= q; i++) cin >> a >> b;
for (int i = 1; i <= n; i++) cout << i % 2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const bool print = false;
const int N = 57;
const long long mod = 1e9 + 7;
char matrix[50][50];
void preparefirst() {
for (int i = 0; i < 8; i++) {
if (i % 2) {
for (int j = 0; j < 50; j++) {
matrix[i][j] = 'B';
}
} else {
for (int j = 0; j < 50; j++) {
if (j % 2) {
matrix[i][j] = 'B';
} else {
matrix[i][j] = 'A';
}
}
}
}
matrix[6][48] = 'B';
for (int i = 8; i < 16; i++) {
if (i % 2 == 0) {
for (int j = 0; j < 50; j++) {
matrix[i][j] = 'A';
}
} else {
for (int j = 0; j < 50; j++) {
if (j % 2 == 0) {
matrix[i][j] = 'B';
} else {
matrix[i][j] = 'A';
}
}
}
}
matrix[15][48] = 'A';
for (int i = 16; i < 32; i++) {
for (int j = 0; j < 50; j++) {
if (i % 2 == 0) {
matrix[i][j] = 'A';
} else {
if (j % 2 == 0) {
if (i < 24) {
matrix[i][j] = 'C';
} else {
matrix[i][j] = 'D';
}
} else {
matrix[i][j] = 'A';
}
}
}
}
}
void removeAs(int cnt) {
for (int i = 0; i < 8; i += 2) {
for (int j = 0; j < 50; j += 2) {
if (cnt == 0) {
return;
}
matrix[i][j] = 'B';
cnt--;
}
}
}
void removeDs(int cnt) {
for (int i = 25; i < 32; i += 2) {
for (int j = 0; j < 50; j += 2) {
if (cnt == 0) {
return;
}
matrix[i][j] = 'A';
cnt--;
}
}
}
void removeBs(int cnt) {
for (int i = 9; i < 16; i += 2) {
for (int j = 0; j < 50; j += 2) {
if (cnt == 0) {
return;
}
matrix[i][j] = 'A';
cnt--;
}
}
}
void removeCs(int cnt) {
for (int i = 17; i < 24; i += 2) {
for (int j = 0; j < 50; j += 2) {
if (cnt == 0) {
return;
}
matrix[i][j] = 'A';
cnt--;
}
}
}
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
preparefirst();
removeAs(100 - a);
removeBs(100 - b);
removeCs(100 - c);
removeDs(100 - d);
cout << 32 << " " << 50 << "\n";
for (int i = 0; i < 32; i++) {
for (int j = 0; j < 50; j++) {
cout << matrix[i][j];
}
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long SG(long long x) {
if (x <= 3) return 0;
if (x <= 15) return 1;
if (x <= 81) return 2;
if (x <= 6723) return 0;
if (x <= 50625) return 3;
if (x <= 2562991875LL) return 1;
return 2;
}
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 0; i < n; ++i) {
long long t;
cin >> t;
ans = ans ^ SG(t);
}
cout << (ans ? "Furlo" : "Rublo");
return 0;
}
| 7 |
#include <bits/stdc++.h>
long long a[10010];
long long gcd(long long a, long long b) {
return a % b == 0 ? b : gcd(b, a % b);
}
long long expand_gcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = expand_gcd(b, a % b, x, y);
long long tmp = x;
x = y;
y = tmp - a / b * y;
return d;
}
int main() {
long long n, m;
int k;
while (scanf("%I64d%I64d%d", &n, &m, &k) != EOF) {
long long row = 1;
memset(a, 0, sizeof(a));
for (int i = 1; i <= k; i++) {
scanf("%I64d", &a[i]);
row = row * a[i] / gcd(row, a[i]);
}
if (row <= 0 || row > n) {
puts("NO");
continue;
}
long long a1 = a[1], r1 = 0;
long long A, B, C, D, a2, r2;
long long x, y;
int ok = 1;
for (int i = 2; i <= k; i++) {
a2 = a[i];
r2 = i - 1;
A = a1;
B = -a2;
C = -r2 - r1;
D = expand_gcd(A, B, x, y);
if (C % D) {
ok = 0;
break;
}
long long t = B / D;
x = (x * (C / D) % t + t) % t;
r1 = a1 * x + r1;
a1 = a1 * (a2 / D);
}
if (ok == 0) {
puts("NO");
continue;
}
long long line = r1;
if (line <= 0) {
line += row;
}
if (line + k - 1 > m) {
puts("NO");
continue;
}
for (int i = 1; i <= k; i++) {
if (gcd(row, line + i - 1) != a[i]) {
ok = 0;
break;
}
}
if (ok == 0) {
puts("NO");
} else {
puts("YES");
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
while (cin >> n >> k) {
vector<string> v(n);
int cnt[105][105];
memset(cnt, 0, sizeof(cnt));
for (int a = 0; a < n; a++) cin >> v[a];
for (int a = 0; a < n; a++) {
for (int b = 0; b < n; b++) {
int len = 0;
for (int c = b; c < min(n, b + k); c++) {
if (v[a][c] == '.') len++;
}
if (len == k) {
for (int c = b; c < b + k; c++) cnt[a][c]++;
}
len = 0;
for (int c = a; c < min(n, a + k); c++) {
if (v[c][b] == '.') len++;
}
if (len == k) {
for (int c = a; c < a + k; c++) cnt[c][b]++;
}
}
}
int ans = cnt[0][0], x = 0, y = 0;
for (int a = 0; a < n; a++) {
for (int b = 0; b < n; b++) {
if (ans < cnt[a][b]) {
ans = cnt[a][b];
x = a, y = b;
}
}
}
x++, y++;
cout << x << " " << y << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long x, y;
long long kuai(long long x, int y) {
long long ans = 1;
x %= mod;
while (y) {
if (y & 1) (ans *= x) %= mod;
(x *= x) %= mod;
y >>= 1;
}
return ans;
}
map<int, long long> mapp;
long long work(int n) {
if (mapp[n]) return mapp[n];
mapp[n] = kuai(2, n - 1) % mod;
for (int i = 1; i * i <= n; i++)
if (n % i == 0) {
mapp[n] = ((mapp[n] - work(i)) % mod + mod) % mod;
if (i != (n / i) && i != 1)
(mapp[n] = (mapp[n] - work(n / i)) % mod + mod) % mod;
}
return mapp[n];
}
int main() {
cin >> x >> y;
mapp[1] = 1;
if (y % x != 0)
cout << 0 << endl;
else
cout << work(y / x) % mod << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int t, n, k;
signed main() {
cin >> t;
while (t--) {
cin >> n >> k;
long long int a[n];
long long int w[k];
long long int mx[k];
long long int mn[k];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < k; i++) {
cin >> w[i];
mx[i] = 0;
mn[i] = INT_MAX;
}
sort(a, a + n, greater<long long int>());
sort(w, w + k);
long long int j = 0;
for (long long int i = 0; i < k; i++) {
mx[i] = mn[i] = a[j];
j++;
w[i]--;
}
long long int m = k - 1;
for (long long int i = n - 1; i >= j; i--) {
while (m >= 0 && w[m] == 0) {
m--;
}
if (m < 0) {
break;
}
mx[m] = max(mx[m], a[i]);
mn[m] = min(mn[m], a[i]);
w[m]--;
}
long long int answer = 0;
for (long long int i = 0; i < k; i++) {
answer += mx[i] + mn[i];
}
cout << answer << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e18;
const long long N = 1e5 + 2;
void run() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long n, p;
long long a[55], sum[55], dp[55][55];
bool isPossible(long long mask) {
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (long long k = 1; k <= p; k++) {
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < i; j++) {
if (dp[j][k - 1] && ((sum[i] - sum[j] & mask) == mask)) {
dp[i][k] = 1;
break;
}
}
}
}
return dp[n][p];
}
long long solve() {
cin >> n >> p;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
long long ans = 0;
for (long long i = 60; i >= 0; i--) {
if (isPossible(ans | (1LL << i))) {
ans |= (1LL << i);
}
}
return ans;
}
int32_t main() {
run();
cout << solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define max(a, b) (a < b ? b : a)
#define min(a, b) ((a > b) ? b : a)
#define mod 1e9 + 7
#define INF 1000000000000000003
typedef long int li;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<long long int> vll;
typedef vector<unsigned long long int> vull;
typedef pair<int, int> pi;
#define F first
#define S second
#define PB push_back
#define POB pop_back
#define MP make_pair
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
cin>>t;
while(t--){
ll n;
cin>>n;
ll m_p;
if(n==1){
cout<<"0\n";
}
else if(n==2){
cout<<"1\n";
}
else if(n%2==0||n==3){
cout<<"2\n";
}
else{
cout<<"3\n";
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
if (n == 1 || n == 0) {
cout << "0";
return 0;
}
n--, k--;
long long l = 0;
long long r = k;
long long ans = 1e9;
while (l <= r) {
long long m = (l + (r - l) / 2);
long long tot = (k - m + 1) * (k + m) / 2;
if (tot < n) {
r = m - 1;
} else {
ans = k - m + 1;
l = m + 1;
}
}
cout << (ans == 1e9 ? -1 : ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, i;
long long a[100011], b[100011], sums[100011];
long long def, l, r, c;
vector<long long> ord;
long long abss(long long x) {
if (x < 0) return -x;
return x;
}
long long ask() {
long long ans = 1LL << 60;
auto it = lower_bound(ord.begin(), ord.end(), def);
if (it != ord.end()) {
ans = abss(def - *it);
}
if (it != ord.begin()) {
it--;
ans = min(ans, abss(def - *it));
}
return ans;
}
int main() {
cin >> n >> m >> q;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (i & 1)
def += a[i];
else
def -= a[i];
}
for (i = 1; i <= m; i++) {
cin >> b[i];
if (i % 2 == 0) b[i] *= -1;
sums[i] = b[i] + sums[i - 1];
}
for (i = 1; i + n - 1 <= m; i++)
ord.push_back((sums[i + n - 1] - sums[i - 1]) * (i % 2 == 1 ? 1 : -1));
sort(ord.begin(), ord.end());
printf("%lld\n", ask());
for (i = 1; i <= q; i++) {
scanf("%lld%lld%lld", &l, &r, &c);
if ((r - l + 1) % 2 == 1) {
if (l % 2 == 1)
def += c;
else
def -= c;
}
printf("%lld\n", ask());
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005][3], s[100005], f[100005], g[100005], h[100005], n, l, r;
int main() {
cin >> n;
for (int j = 0; j <= 2; j++)
for (int i = 1; i <= n; i++) cin >> a[i][j];
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i][0] + a[i][1] + a[i][2];
for (int i = 1; i <= n; i++) f[i] = g[i] = h[i] = -1e17;
f[1] = a[1][0];
g[1] = s[1];
l = max(0LL, f[1] - s[1]);
h[1] = a[1][0] + a[1][1];
r = g[1] - s[1];
for (int i = 2; i <= n; i++) {
f[i] = max(f[i - 1] + a[i][0], s[i] + r);
g[i] = max(g[i - 1] + a[i][2], s[i] + l);
h[i] = max(h[i - 1], max(f[i - 1] + a[i][0], g[i - 1] + a[i][2])) + a[i][1];
f[i] = max(f[i], h[i - 1] + a[i][1] + a[i][0]);
g[i] = max(g[i], h[i - 1] + a[i][1] + a[i][2]);
l = max(l, f[i] - s[i]);
r = max(r, g[i] - s[i]);
}
cout << g[n];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int cmp(long double x, long double y) {
if (x == y) return 0;
return (x < y) ? -1 : 1;
}
struct Point {
long double x, y;
Point() {}
Point(long double a, long double b) : x(a), y(b) {}
Point operator-(Point b) { return Point(x - b.x, y - b.y); }
bool operator<(const Point &b) const {
return (cmp(y, b.y) != 0) ? (cmp(y, b.y) > 0) : (cmp(x, b.x) > 0);
}
};
long double cross(Point x, Point y) { return x.x * y.y - x.y * y.x; }
Point p[100005], hull[100005];
int st[100005];
int build(int n) {
sort(p + 1, p + n + 1);
int top = 0;
for (int i = 1; i <= n; i++) {
if (top && (p[i].y == p[st[top]].y || p[i].x < p[st[top]].x)) continue;
while (top > 1 &&
cmp(cross(p[i] - p[st[top]], p[st[top]] - p[st[top - 1]]), 0) <= 0)
top--;
st[++top] = i;
}
for (int i = 1; i <= top; i++) hull[i] = p[st[i]];
return top;
}
struct Matrix {
long double num[3][3];
int n, m;
Matrix() {}
Matrix(int a, int b) : n(a), m(b) { memset(num, 0, sizeof(num)); }
};
Matrix operator*(Matrix &a, Matrix &b) {
Matrix c(a.n, b.m);
for (int i = 0; i < c.n; i++)
for (int j = 0; j < c.m; j++)
for (int k = 0; k < a.m; k++) c.num[i][j] += a.num[i][k] * b.num[k][j];
return c;
}
long double maxn;
Matrix now[40];
void pre(int n, long double x, int y, long long t) {
now[0] = Matrix(3, 3);
now[0].num[0][0] = 1 - hull[y].x;
now[0].num[0][1] = hull[y].x * maxn;
now[0].num[0][2] = hull[y].y;
now[0].num[1][1] = now[0].num[1][2] = now[0].num[2][2] = 1;
for (int i = 1; i <= n; i++) now[i] = now[i - 1] * now[i - 1];
}
inline long double trans(long double x, int y, long long t) {
return (1 - hull[y].x) * x + hull[y].y + hull[y].x * maxn * t;
}
int main() {
int n;
long long m;
scanf("%d%lld", &n, &m);
for (int i = 1; i <= n; i++) {
long double x, y, z;
scanf("%Lf%Lf%Lf", &x, &y, &z);
p[i] = Point(z, x * z);
maxn = max(maxn, y * z);
}
int k = build(n);
long double ans = 0;
int lx = 1;
for (long long l = 1; l <= m; l++) {
while (lx < k && cmp(trans(ans, lx, l - 1), trans(ans, lx + 1, l - 1)) <= 0)
lx++;
pre(34, ans, lx, l - 1);
Matrix fir(3, 1);
fir.num[0][0] = ans;
fir.num[1][0] = l - 1;
fir.num[2][0] = 1;
for (int j = 34; j >= 0; j--)
if (l + (1LL << j) <= m) {
Matrix u = now[j] * fir;
long double t = u.num[0][0];
if (lx == k || cmp(trans(t, lx, l - 1 + (1LL << j)),
trans(t, lx + 1, l - 1 + (1LL << j))) >= 0) {
l += (1LL << j);
fir = u;
}
}
fir = now[0] * fir;
ans = fir.num[0][0];
}
printf("%.12Lf\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int i;
string b, a;
cin >> b;
int size = b.size();
for (i = 0; i <= size - 1; i++) {
a += b[i];
i++;
}
a += b[size - 1];
cout << a << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
getline(cin, s);
int _t = stoi(s);
while (_t--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int a, b, c, d, i, j, ans;
char s[100001];
while (cin >> a >> b >> c >> d) {
cin >> s;
ans = 0;
for (i = 0; i < strlen(s); i++) {
if (s[i] == '1')
ans += a;
else if (s[i] == '2')
ans += b;
else if (s[i] == '3')
ans += c;
else if (s[i] == '4')
ans += d;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
int solutions[40];
cin >> t;
for (int i = 0; i < t; ++i) {
int x;
cin >> x;
int num_bef;
string a = std::to_string(x);
int q = ((a[0] - '0') - 1) * 10;
if (a.size() == 1) {
q += 1;
}
if (a.size() == 2) {
q += 3;
}
if (a.size() == 3) {
q += 6;
}
if (a.size() == 4) {
q += 10;
}
solutions[i] = q;
}
for (int j = 0; j < t; ++j) {
cout << solutions[j] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int power(int, int);
int ncr(int, int);
int add(int a, int b);
void fact();
int mul(int a, int b);
int mod = 1e9 + 7;
const int N = 100002LL;
int fac[N + 2];
int inv[N + 2];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
pair<int, int> a[n];
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort(a, a + n);
if (n == 2 || m < n) {
cout << -1 << endl;
continue;
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += 2 * a[i].first;
}
cout << ans << endl;
for (int i = 0; i < m; i++) {
cout << a[i].second << " " << a[(i + 1) % m].second << endl;
}
}
return 0;
}
int add(int a, int b) {
a += b + mod;
if (a >= mod) a -= mod;
return a;
}
int mul(int a, int b) { return ((a)*1LL * (b)) % mod; }
int power(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res = mul(res, a);
n >>= 1;
a = mul(a, a);
}
return res;
}
void fact() {
inv[0] = fac[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = mul(fac[i - 1], i);
inv[i] = power(fac[i], mod - 2);
}
}
int ncr(int n, int r) {
if (r > n) return 0;
int e = fac[n];
e = mul(e, inv[r]);
e = mul(e, inv[n - r]);
return e;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
std::vector<std::vector<long long> > G(1005);
bool marked[1005];
long long component[1005];
long long govt[1005];
long long n;
std::vector<long long> nodes, edges;
void dfs(long long u, long long t, long long &noe, long long &non) {
marked[u] = true;
component[u] = t;
non++;
for (auto v : G[u]) {
noe++;
if (!marked[v]) dfs(v, t, noe, non);
}
}
long long ans = 0;
void find_component() {
long long noe, non;
long long t = 1;
for (int i = 1; i <= n; ++i) {
if (!marked[i]) {
non = noe = 0;
dfs(i, t, noe, non);
++t;
nodes.push_back(non);
edges.push_back(noe / 2);
ans += (non * (non - 1)) / 2 - noe / 2;
}
}
}
int main(int argc, char const *argv[]) {
memset(marked, 0, sizeof(marked));
memset(component, 0, sizeof(component));
long long m, k, i, j, u, v;
cin >> n >> m >> k;
for (i = 0; i < k; i++) cin >> govt[i];
for (i = 0; i < m; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
find_component();
set<long long> govt_component;
long long max_gc = 0, max_size = INT_MIN;
for (i = 0; i < k; ++i) {
govt_component.insert(component[govt[i]]);
if (max_size < nodes[component[govt[i]] - 1])
max_size = nodes[component[govt[i]] - 1];
}
long long tot_nodes = 0, temp = 0;
for (i = 0; i < nodes.size(); ++i) {
if (govt_component.find(i + 1) == govt_component.end()) {
ans += tot_nodes * nodes[i];
tot_nodes += nodes[i];
}
}
ans += max_size * tot_nodes;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, cnts = 0, cntg = 0;
cin >> n;
string s;
cin >> s;
vector<long long> v;
int flags = 0, flagg = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'G') {
cnts++;
if (cntg) {
v.push_back(-1 * cntg);
cntg = 0;
}
flags = 1;
} else {
cntg++;
if (cnts) {
v.push_back(cnts);
cnts = 0;
}
flagg = 1;
}
}
if (cnts)
v.push_back(cnts);
else if (cntg)
v.push_back(-1 * cntg);
if (flagg == 0) {
cout << n << endl;
return 0;
} else if (flags == 0) {
cout << 0 << endl;
return 0;
}
long long maxm = 0;
for (long long i = 0; i < v.size(); i++) {
if (i == 0 && v[i] < 0)
continue;
else if (i == v.size() - 1 && v[i] < 0)
continue;
else {
if (v[i] == -1) {
int flag = 0;
long long len = 0;
for (long long j = i + 3; j < v.size(); j++) {
if (v[j] > 0) {
flag = 1;
break;
}
}
for (long long j = i - 3; j >= 0; j--) {
if (v[j] > 0) {
flag = 1;
break;
}
}
if (flag)
len = v[i + 1] + v[i - 1] + 1;
else
len = v[i + 1] + v[i - 1];
maxm = max(maxm, len);
} else {
int flag = 0;
for (long long j = i + 2; j < v.size(); j++) {
if (v[j] > 0) {
flag = 1;
break;
}
}
for (long long j = i - 2; j >= 0; j--) {
if (v[j] > 0) {
flag = 1;
break;
}
}
if (flag)
maxm = max(maxm, v[i] + 1);
else
maxm = max(maxm, v[i]);
}
}
}
cout << maxm << endl;
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.