solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
cout << (a ^ b) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> G[3000 + 10];
int d[3000 + 10][3000 + 10];
int s1, t1, l1;
int s2, t2, l2;
int par[3000 + 10];
bool vis[3000 + 10];
void bfs(int i) {
queue<int> Q;
Q.push(i);
d[i][i] = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int j = 0; j < G[u].size(); j++) {
int v = G[u][j];
if (d[i][v] == -1) {
d[i][v] = d[i][u] + 1;
Q.push(v);
}
}
}
}
int solve() {
int res = 0x3f3f3f3f;
for (int cases = 0; cases < 2; cases++) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int g1 = d[s1][i] + d[i][j] + d[j][t1];
int g2 = d[s2][i] + d[i][j] + d[j][t2];
if (g1 <= l1 && g2 <= l2) {
int r = g1 + g2 - d[i][j];
if (r < res) res = r;
}
}
swap(s1, t1);
}
swap(s1, t1);
if (d[s1][t1] <= l1 && d[s2][t2] <= l2 && d[s1][t1] + d[s2][t2] < res)
res = d[s1][t1] + d[s2][t2];
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
G[x].push_back(y);
G[y].push_back(x);
}
memset(d, -1, sizeof(d));
for (int i = 0; i < n; i++) bfs(i);
cin >> s1 >> t1 >> l1;
cin >> s2 >> t2 >> l2;
s1--;
t1--;
s2--;
t2--;
int ans = solve();
if (ans > m)
cout << -1 << endl;
else
cout << m - ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c = 0, d = 0, sum = 0, s = 0, x = 0, y = 0;
cin >> a >> b;
sum = a;
s = b;
if (b < 2) {
cout << "Valera" << endl;
return 0;
}
for (long long i = 1; i <= a; i += 2) {
c++;
sum = sum - i;
if (sum == 0) {
break;
} else if (sum < 0) {
c--;
break;
}
}
for (long long i = 2; i <= b; i += 2) {
d++;
s = s - i;
if (s == 0) {
break;
} else if (s < 0) {
d--;
break;
}
}
if (c == d) {
cout << "Vladik" << endl;
} else if (c > d) {
cout << "Valera" << endl;
} else {
cout << "Vladik" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
vector<vector<bool>> dp;
vector<string> result(2);
int n, sum;
int get(int idx, int sum, int maximum, int done = 1) {
if (idx == 0) return (sum ? 0 : 1);
if (done) return dp[idx][sum];
int works = 0;
int cur;
if (maximum)
cur = INT_MIN;
else
cur = INT_MAX;
for (int i = 0; i <= 9; ++i) {
if (sum - i >= 0)
if (idx != n || i) {
works |= get(idx - 1, sum - i, -1);
if (works) {
if (maximum)
cur = max(cur, i);
else
cur = min(cur, i);
}
}
}
if (maximum == 1) {
result[maximum].push_back(cur + '0');
return get(idx - 1, sum - cur, 1, 0);
} else if (maximum == 0) {
result[maximum].push_back(cur + '0');
return get(idx - 1, sum - cur, 0, 0);
}
return dp[idx][sum] = works;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> sum;
dp = vector<vector<bool>>(n + 1, vector<bool>(sum + 1, false));
if (n == 1 && sum == 0) {
cout << "0 0\n";
exit(0);
}
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= sum; ++j) {
get(i, j, -1, 0);
}
}
if (get(n, sum, -1) == 0) {
cout << "-1 -1\n";
exit(0);
}
get(n, sum, 1, 0);
get(n, sum, 0, 0);
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < result[i].size(); ++j) cout << result[i][j];
if (i == 0)
cout << ' ';
else
cout << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long ans = 1, s, x;
cin >> s >> x;
if (x > s) return cout << 0, 0;
long long t = x;
while (t) {
if (t & 1) ans *= 2;
t /= 2;
}
if (s - x == 0) ans -= 2;
if ((((s - x) / 2) & x) || (s - x) & 1) return cout << 0, 0;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
const int INF = (int)1e9 + 7;
const double EPS = 1e-9;
void nhap();
void process();
struct so {
int gt, vt;
};
int n, h, y;
int F[maxn];
so a[maxn];
int res;
int main() {
int nTest = 1;
for (int test = 1; test <= nTest; ++test) {
nhap();
process();
}
}
void nhap() {
scanf("%d%d", &n, &h);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].gt);
a[i].vt = i;
}
}
bool mycmp(const so &u, const so &v) { return u.gt < v.gt; }
void process() {
int rmin, maxx, minn, hm;
if (n != 2) {
sort(a + 1, a + 1 + n, mycmp);
hm = a[n].gt + a[1].gt + h;
maxx = max(hm, a[n].gt + a[n - 1].gt);
minn = min(a[2].gt + a[1].gt + h, a[2].gt + a[3].gt);
rmin = maxx - minn;
maxx = a[n].gt + a[n - 1].gt;
minn = a[1].gt + a[2].gt;
if (rmin > maxx - minn) {
rmin = maxx - minn;
for (int i = 1; i <= n; ++i) F[a[i].vt] = 1;
} else {
F[a[1].vt] = 1;
for (int i = 2; i <= n; ++i) F[a[i].vt] = 2;
}
} else {
F[1] = 1;
F[2] = 1;
rmin = 0;
}
printf("%d\n", rmin);
for (int i = 1; i <= n; ++i) printf("%d ", F[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long min(unsigned long long x, unsigned long long y) {
if (x < y) return x;
return y;
}
unsigned long long max(unsigned long long x, unsigned long long y) {
if (x < y) return y;
return x;
}
long long min(long long x, long long y) {
if (x < y) return x;
return y;
}
long long max(long long x, long long y) {
if (x < y) return y;
return x;
}
double min(double x, double y) {
if (x < y) return x;
return y;
}
double max(double x, double y) {
if (x < y) return y;
return x;
}
unsigned long long gcd(unsigned long long x, unsigned long long y) {
if (!x) return y;
if (!y) return x;
if (x > y) swap(x, y);
return gcd(x, y % x);
}
unsigned long long inv(unsigned long long a, unsigned long long c) {
if (a == 1) {
return 1;
}
return ((c - (c / a)) * inv(c % a, c)) % c;
}
long long n, m, dp[505][505] = {0}, c[505] = {0}, M = 998244353;
long long mul(long long a, long long b) { return (a * b) % M; }
void add(long long &a, long long b) {
a += b;
if (a >= M) a -= M;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> c[i];
}
for (int size = 1; size <= m; size++) {
for (int i = 0; i < m; i++) {
int j = i + size - 1;
if (j >= m) break;
if (size == 1) {
dp[i][j] = 1;
continue;
}
int mine = INT_MAX, mindx = -1;
for (int k = i; k <= j; k++) {
if (c[k] < mine) {
mine = c[k];
mindx = k;
}
}
if ((mindx > i) && (mindx < j)) {
dp[i][j] = mul(dp[i][mindx], dp[mindx][j]);
continue;
}
if (mindx == i) {
for (int k = i; k <= j; k++) {
if ((k > i) && (k < j))
add(dp[i][j], mul(dp[i + 1][k], dp[k + 1][j]));
else
add(dp[i][j], dp[i + 1][j]);
}
} else {
for (int k = j; k >= i; k--) {
if ((k > i) && (k < j))
add(dp[i][j], mul(dp[k][j - 1], dp[i][k - 1]));
else
add(dp[i][j], dp[i][j - 1]);
}
}
}
}
cout << dp[0][m - 1] << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
using li = long long;
using ld = long double;
void solve(bool);
void precalc();
clock_t start;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
precalc();
while (t--) {
solve(true);
}
cout.flush();
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
template <typename T>
void make_unique(vector<T>& vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
template <typename T>
void relax_min(T& cur, T val) {
cur = min(cur, val);
}
template <typename T>
void relax_max(T& cur, T val) {
cur = max(cur, val);
}
mt19937 rng(
(unsigned long long)chrono::steady_clock::now().time_since_epoch().count());
void precalc() {}
const int MAXN = 15;
unordered_map<int, li> dp[MAXN][1 << MAXN];
void solve(__attribute__((unused)) bool read) {
int n;
if (read) {
cin >> n;
} else {
n = 14;
}
vector<vector<int>> matrix(n, vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
if (read) {
string s;
cin >> s;
for (int j = 0; j < n; ++j) {
matrix[i][j] = s[j] - '0';
}
} else {
for (int j = 0; j < n; ++j) {
if (j == i) {
matrix[i][j] = 0;
continue;
}
if (i > j) {
matrix[i][j] = matrix[j][i];
continue;
}
matrix[i][j] = rand() % 2;
}
}
}
for (int i = 0; i < n; ++i) {
dp[i][1 << i][0] = 1;
}
vector<li> res(1 << (n - 1), 0);
int half = (n + 1) / 2;
for (int mask = 1; mask < (1 << n); ++mask) {
int cnt_bits = __builtin_popcount(mask);
if (cnt_bits > half) {
continue;
}
for (int last = 0; last < n; ++last) {
if (dp[last][mask].empty()) {
continue;
}
if (mask + 1 == (1 << n)) {
for (auto& item : dp[last][mask]) {
res[item.first] += item.second;
}
continue;
}
for (int nex = 0; nex < n; ++nex) {
if (mask & (1 << nex)) {
continue;
}
for (auto& item : dp[last][mask]) {
int new_m = item.first * 2 + matrix[last][nex];
dp[nex][mask | (1 << nex)][new_m] += item.second;
}
}
}
}
vector<int> reversed_mask(1 << (half - 1));
for (int m = 0; m < reversed_mask.size(); ++m) {
for (int j = 0; j < half - 1; ++j) {
if (m & (1 << j)) {
reversed_mask[m] |= (1 << (half - 2 - j));
}
}
}
int rest = n - 1 - half;
for (int mask = 1; mask < (1 << n); ++mask) {
int cnt_bits = __builtin_popcount(mask);
if (cnt_bits != half) {
continue;
}
int rev_mask = (1 << n) - 1 - mask;
if (n % 2 == 0 && mask > rev_mask) {
continue;
}
for (int last = 0; last < n; ++last) {
if (dp[last][mask].empty()) {
continue;
}
for (int nex = 0; nex < n; ++nex) {
if (dp[nex][rev_mask].empty()) {
continue;
}
for (auto& item1 : dp[last][mask]) {
int rev_1 = reversed_mask[item1.first] +
matrix[last][nex] * (1 << (half - 1));
for (auto& item2 : dp[nex][rev_mask]) {
res[rev_1 + item2.first * (1 << half)] +=
item1.second * 1LL * item2.second;
}
}
}
}
}
if (n % 2 == 0) {
for (int mask = 0; mask < (1 << (n - 1)); ++mask) {
int rev_mask = 0;
for (int i = 0; i < n - 1; ++i) {
if (mask & (1 << i)) {
rev_mask |= (1 << (n - 2 - i));
}
}
if (rev_mask < mask) {
continue;
}
auto val = res[mask] + res[rev_mask];
res[mask] = val;
res[rev_mask] = val;
}
}
if (read) {
for (auto x : res) {
cout << x << " ";
}
cout << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void doRoutine() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const long long MAXN = 200005;
long long a[MAXN];
long long n, m;
long long arr[MAXN];
long long solve(long long l, long long r) {
if (l + 1 == r) {
if (arr[l] == 1) {
return 1;
} else {
return 0;
}
}
long long m = (l + r) / 2;
long long res = 0;
res += solve(l, m);
res += solve(m, r);
vector<long long> cnt((r - l) * 2 + 5);
long long sh = (r - l);
long long cur = 0;
for (long long i = m - 1; i >= l; --i) {
cur += arr[i];
++cnt[cur + sh];
}
vector<long long> suf_cnt(cnt.size() + 1);
for (long long i = 1; i < suf_cnt.size(); ++i) {
suf_cnt[i] = suf_cnt[i - 1] + cnt[(long long)cnt.size() - i];
}
cur = 0;
for (long long i = m; i < r; ++i) {
cur += arr[i];
res += suf_cnt[(long long)cnt.size() - (sh - cur) - 1];
}
return res;
}
long long f(long long k) {
for (long long i = 0; i < n; ++i) {
if (a[i] >= k) {
arr[i] = 1;
} else {
arr[i] = -1;
}
}
return solve(0, n);
}
signed main() {
doRoutine();
cin >> n >> m;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
long long ans1 = f(m + 1), ans2 = f(m);
cout << ans2 - ans1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0;
cin >> n;
int ar[n + 1];
for (int i = 1; i <= n; i++) cin >> ar[i];
for (int i = 2; i < n; i++) {
if (ar[i] == 0 && ar[i - 1] == 1 && ar[i + 1] == 1) {
ar[i + 1] = 0;
c++;
}
}
cout << c << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int64_t t;
cin >> t;
while (t--) {
int64_t n, k;
cin >> n >> k;
vector<int64_t> ar(n);
for (int64_t i = 0; i < n; i++) cin >> ar[i];
bool a = 0, b = 0;
for (int64_t i = 0; i < n; i++) {
if (ar[i] == k) a = 1;
for (int64_t j = 1; j <= 2 && i + j < n; j++) {
if (ar[i] >= k && ar[i + j] >= k) b = 1;
}
}
if ((a && b) || (n == 1 && a))
cout << "yes"
<< "\n";
else
cout << "no"
<< "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
bool a[N], b[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n >> x;
int r = -1;
for (int i = (int)(0); i < (int)(n); i++) {
int y;
cin >> y;
if (!a[y])
a[y] = 1;
else
r = 0;
}
if (r) {
for (int i = (int)(1); i < (int)(N); i++)
if (a[i]) {
int y = i & x;
if (y != i) {
if (b[y])
r = 2;
else
b[y] = 1;
}
}
for (int i = (int)(1); i < (int)(N); i++)
if (a[i] && b[i]) {
r = 1;
break;
}
}
cout << r << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dia, n;
long long a[300000];
long long ans;
map<long long, int> S;
int main() {
scanf("%d%d", &dia, &n);
ans = (long long)n * (n - 1LL) * (n - 2LL) / 6LL;
for (int i = 1; i <= n; i++) {
int s, x;
scanf("%d%d", &s, &x);
if (!s) x += dia;
x %= dia + dia;
a[i] = x;
}
sort(a + 1, a + 1 + n);
for (int i = n + 1; i <= n + n; i++)
a[i] = a[i - n] + dia + dia, S[a[i]]++, S[a[i - n]]++;
for (int i = 1, ni = 1; i <= n; i++) {
for (; a[ni + 1] - a[i] < dia; ni++)
;
ans -= (long long)(ni - i) * (ni - 1LL - i) / 2LL;
}
if (ans)
cout << ans << endl;
else {
long long L = 0;
for (int i = 1, ni = 1; i <= n; i++) {
for (; a[ni + 1] - a[i] < dia; ni++)
;
if (ni - i > 1) L = max(L, a[ni] - a[i]);
}
for (int i = 1, ni = 1; i <= n; i++) {
ni = max(ni, i);
S[a[i]]--;
for (; a[ni + 1] - a[i] < L; ni++)
;
if (a[ni + 1] - a[i] == L) {
if (ni + 1 - i > 1) ans += (long long)(ni - i) * S[a[ni + 1]];
ans += (long long)S[a[ni + 1]] * (S[a[ni + 1]] - 1) / 2LL;
}
}
cout << ans << endl;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100007;
vector<int> G[N];
bool has[N];
int cost[N];
long long ans = 0;
int ct = INT_MAX;
void dfs(int t) {
ct = min(ct, cost[t]);
has[t] = true;
for (auto x : G[t]) {
if (!has[x]) dfs(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int a, b;
for (int i = 1; i <= n; i++) cin >> cost[i];
for (int i = 1; i <= m; i++) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (has[i]) continue;
ct = INT_MAX;
dfs(i);
ans += ct;
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, sum, mit = 0;
cin >> n >> m >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
if (m != 0)
m--;
else
mit++;
} else {
if (m + k != 0) {
if (k != 0)
k--;
else
m--;
} else
mit++;
}
}
cout << mit;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, a[100], i, j, flag = 0, count = 0, odd = 0, eve = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] % 2 == 0)
eve++;
else
odd++;
}
if (eve == 1) {
for (i = 0; i < n; i++) {
if (a[i] % 2 == 0) {
printf("%d\n", i + 1);
break;
}
}
} else {
for (i = 0; i < n; i++) {
if (a[i] % 2 == 1) {
printf("%d\n", i + 1);
break;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int quick_pow(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = a * 1ll * a % mod) {
if (b & 1) ans = ans * 1ll * a % mod;
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
int ans;
if (m == 1)
ans = n + 1;
else
ans = (quick_pow(m, n) + m * 1ll *
(quick_pow(2 * m - 1, n) - quick_pow(m, n)) %
mod * quick_pow(m - 1, mod - 2) % mod) %
mod;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 9223372036854775807;
const long long int mod = 998244353;
vector<int> prime(100001, 1);
void sieve() {
for (int i = 2; i * i <= 100001; i++) {
if (prime[i] == 1) {
prime[i] = i;
for (int j = i * i; j <= 100001; j += i) {
if (prime[j] == 1) prime[j] = i;
}
}
}
}
int gcd(long a, long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
map<int, vector<pair<int, int>>> m;
int n;
cin >> n;
vector<int> ar(n);
vector<int> c(n);
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
c[0] = ar[0];
for (int i = 1; i < n; i++) {
c[i] = c[i - 1] + ar[i];
}
int t;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
t = c[j] - c[i] + ar[i];
m[t].push_back(make_pair(j, i));
}
}
vector<pair<int, int>> sol[m.size()];
int j = 0;
pair<int, int> prev;
for (auto &it : m) {
sort(it.second.begin(), it.second.end());
prev = it.second[0];
sol[j].push_back(prev);
for (int i = 1; i < it.second.size(); i++) {
if (it.second[i].second > prev.first) {
prev = it.second[i];
sol[j].push_back(prev);
}
}
j++;
}
int mi = 0;
int k = 0;
for (int i = 0; i < m.size(); i++) {
if (sol[i].size() > mi) {
mi = sol[i].size();
k = i;
}
}
cout << sol[k].size();
cout << endl;
for (int i = 0; i < sol[k].size(); i++) {
cout << sol[k][i].second + 1 << " " << sol[k][i].first + 1 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
long long int n, x, y, cnt, res;
pair<long long int, long long int> a[N];
int bin_pow(long long int x, long long int y) {
long long int res = 1;
while (y) {
if (y % 2) res *= x;
x *= x;
y /= 2;
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i].first >> a[i].second;
sort(a + 1, a + n + 1);
for (int i = 1; i < n; ++i)
if (a[i + 1].first - a[i].first < 15ll) {
cnt = bin_pow(4ll, a[i + 1].first - a[i].first);
res = (a[i].second + cnt - 1) / cnt;
if (res > a[i + 1].second) a[i + 1].second += res - a[i + 1].second;
}
if (a[n].second == 1ll)
cout << a[n].first + 1ll << "\n";
else {
while (a[n].second != 1) {
a[n].second = (a[n].second + 3ll) / 4ll;
++a[n].first;
}
cout << a[n].first << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool hotel[10];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
char a;
cin >> a;
int j;
if (a == 'R') {
j = 9;
while (hotel[j]) --j;
hotel[j] = true;
} else if (a == 'L') {
j = 0;
while (hotel[j]) ++j;
hotel[j] = true;
} else
hotel[a - 48] = false;
}
for (int i = 0; i < 10; ++i) cout << hotel[i];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const long long OO = (long long)10e9 + 1;
const int MAX = 10e4;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, x, w = 0, countt = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
if (!x)
countt += w;
else
w++;
}
cout << countt << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 5;
int f[MAXN], u[MAXN], v[MAXN], con[MAXN];
pair<int, int> ans[MAXN];
bool ss[MAXN], tt[MAXN];
int n, m, tot;
int s, t, ds, dt, fa, fb;
int brg, both, now;
int find(int a) {
if (a != f[a]) f[a] = find(f[a]);
return f[a];
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < m; ++i) {
scanf("%d%d", u + i, v + i);
}
scanf("%d%d%d%d", &s, &t, &ds, &dt);
brg = both = tot = 0;
for (int i = 1; i <= n; ++i) f[i] = i;
bool flag = false;
memset(ss, false, sizeof(ss));
memset(tt, false, sizeof(tt));
memset(con, -1, sizeof(con));
for (int i = 0; i < m; ++i) {
if (v[i] == s) swap(u[i], v[i]);
if (u[i] == s) {
if (v[i] == t)
;
else {
ss[find(v[i])] = true;
}
} else {
if (v[i] == t) swap(u[i], v[i]);
if (u[i] == t) {
tt[find(v[i])] = true;
} else {
fa = find(u[i]);
fb = find(v[i]);
if (fa == fb) continue;
f[fb] = fa;
ss[fa] |= ss[fb];
tt[fa] |= tt[fb];
ans[tot++] = {u[i], v[i]};
}
}
}
--ds;
--dt;
for (int i = 1; i <= n; ++i)
if (i != s && i != t && i == find(i)) {
if (ss[i] && tt[i]) {
if (brg)
con[i] = 0, ++both;
else
brg = i;
} else if (ss[i]) {
--ds;
con[i] = s;
if (ds < 0) {
flag = true;
goto END;
}
} else if (tt[i]) {
--dt;
con[i] = t;
if (dt < 0) {
flag = true;
goto END;
}
}
}
if (both > ds + dt) {
flag = true;
goto END;
}
if (brg) {
now = 3;
for (int i = 0; i < m; ++i) {
if (now == 0) break;
if (u[i] == s && (now & 1) && brg == find(v[i])) {
now ^= 1;
ans[tot++] = {u[i], v[i]};
} else if (u[i] == t && (now & 2) && brg == find(v[i])) {
now ^= 2;
ans[tot++] = {u[i], v[i]};
}
}
} else
ans[tot++] = {s, t};
for (int i = 0; i < m; ++i) {
fa = find(u[i]);
fb = find(v[i]);
if (fb == s) swap(fa, fb);
if (fa == s) {
if (fb == t)
;
else if (con[fb] == s) {
f[fb] = s;
con[fb] = -1;
ans[tot++] = {u[i], v[i]};
} else if (con[fb] == 0 && ds) {
f[fb] = s;
con[fb] = -1;
ans[tot++] = {u[i], v[i]};
--ds;
}
} else {
if (fb == t) swap(fa, fb);
if (fa == t) {
if (con[fb] == t) {
f[fb] = t;
con[fb] = -1;
ans[tot++] = {u[i], v[i]};
} else if (con[fb] == 0 && dt) {
f[fb] = t;
con[fb] = -1;
ans[tot++] = {u[i], v[i]};
--dt;
}
}
}
}
END:
if (flag || tot != n - 1)
puts("No");
else {
puts("Yes");
for (int i = 0; i < tot; ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
while (b ^= a ^= b ^= a %= b)
;
return a;
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline bool isPrimeNumber(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T multiplyMod(T a, T b, T m) {
return (
T)((((long long)(a) * (long long)(b) % (long long)(m)) + (long long)(m)) %
(long long)(m));
}
template <class T>
inline T powerMod(T p, int e, T m) {
if (e == 0)
return 1 % m;
else if (e % 2 == 0) {
T t = powerMod(p, e / 2, m);
return multiplyMod(t, t, m);
} else
return multiplyMod(powerMod(p, e - 1, m), p, m);
}
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
char toLowerCase(char c) { return (isUpperCase(c)) ? (c + 32) : c; }
char toUpperCase(char c) { return (isLowerCase(c)) ? (c - 32) : c; }
long long decimaltobinary(long long b) {
long long p10 = 1, ret = 0;
for (; b > 0; b >>= 1) {
ret += p10 * (b & 1);
p10 *= 10;
}
return ret;
}
template <class T>
string toString(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double toDouble(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
const double pi = acos(-1.0);
struct sort_pred {
bool operator()(const std::pair<int, int> &left,
const std::pair<int, int> &right) {
return left.second < right.second;
}
};
struct sort_pred1 {
bool operator()(const std::pair<int, int> &left,
const std::pair<int, int> &right) {
return left.first > right.first;
}
};
int main() {
char ch[4][4];
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) cin >> ch[i][j];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
int b = 0, w = 0;
if (ch[i][j] == '#')
b++;
else
w++;
if (ch[i][j + 1] == '#')
b++;
else
w++;
if (ch[i + 1][j] == '#')
b++;
else
w++;
if (ch[i + 1][j + 1] == '#')
b++;
else
w++;
if (b >= 3 || w >= 3) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, i;
int a[500010], b[500010];
inline int Abs(int x) { return (x < 0) ? x : -x; }
inline int Min(int a, int b) { return (a < b) ? a : b; }
inline int Max(int a, int b) { return (a > b) ? a : b; }
inline int read() {
int p = 0, c = getchar();
while (c < 48 || c > 57) c = getchar();
while (c >= 48 && c <= 57) p = (p << 1) + (p << 3) + c - 48, c = getchar();
return p;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
if (a[1] != b[1] || a[n] != b[n]) {
cout << "No" << endl;
return 0;
}
if (n == 2) {
cout << "Yes";
return 0;
}
for (i = 1; i < n; i++) {
a[i] -= a[i + 1];
b[i] -= b[i + 1];
}
sort(a + 1, a + n);
sort(b + 1, b + n);
for (i = 1; i < n; i++)
if (a[i] != b[i]) {
printf("No\n");
goto END;
}
printf("Yes\n");
END:
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans;
int a[1000000];
int tree[1000000];
int b[50] = {0, 4, 7, 44, 47, 74, 77, 444, 447, 474, 477,
744, 747, 774, 777, 4444, 4447, 4474, 4477, 4744, 4747, 4774,
4777, 7444, 7447, 7474, 7477, 7744, 7747, 7774, 7777};
int f[1000000];
void Update(int id, int le, int ri, int x, int k) {
if (le == ri) {
tree[id] += k;
return;
}
int mid = (le + ri) / 2;
if (x <= mid)
Update(id * 2, le, mid, x, k);
else
Update(id * 2 + 1, mid + 1, ri, x, k);
tree[id] = tree[id * 2] + tree[id * 2 + 1];
}
int query(int id, int le, int ri, int ll, int rr) {
if (ll <= le && ri <= rr) return tree[id];
int mid = (le + ri) / 2, k = 0;
if (ll <= mid) k += query(id * 2, le, mid, ll, rr);
if (rr > mid) k += query(id * 2 + 1, mid + 1, ri, ll, rr);
return k;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= 50; i++) f[b[i]] = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (f[a[i]]) Update(1, 1, n, i, 1);
}
while (m--) {
char ch[100];
scanf("%s", &ch);
int x, y, z;
scanf("%d%d", &x, &y);
if (ch[0] == 'a') {
scanf("%d", &z);
for (int i = x; i <= y; i++) {
int k = 0;
if (f[a[i]]) k--;
a[i] += z;
if (f[a[i]]) k++;
if (k) Update(1, 1, n, i, k);
}
} else
printf("%d\n", query(1, 1, n, x, y));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long n, k, m, s;
int a[100006];
vector<int> v[100006];
int mar[106][100006] = {0};
bool vis[106][100006];
int c[100006] = {0}, sum[100006] = {0}, goal[100006] = {0}, lev[106] = {0},
lp[106], ha = 0;
int i, t1, t2;
queue<int> q[106];
queue<int> qq;
void bfs() {
int r;
i = qq.front();
qq.pop();
while (1) {
r = q[i].front();
q[i].pop();
if (!goal[r]) {
sum[r] += lev[i];
c[r]++;
if (c[r] == s) {
goal[r] = 1;
ha++;
if (ha == n) break;
}
}
for (vector<int>::iterator iter = v[r].begin(); iter != v[r].end();
iter++) {
if (vis[i][*iter]) continue;
q[i].push(*iter);
vis[i][*iter] = true;
}
if (lp[i] == r) {
if (!q[i].empty()) {
lev[i]++;
lp[i] = q[i].back();
qq.push(i);
i = qq.front();
qq.pop();
} else {
i = qq.front();
qq.pop();
}
}
}
}
int main() {
cin >> n >> m >> k >> s;
for (i = 1; i <= n; i++) {
cin >> a[i];
q[a[i]].push(i);
vis[a[i]][i] = true;
lp[a[i]] = i;
}
for (i = 0; i < m; i++) {
cin >> t1 >> t2;
v[t1].push_back(t2);
v[t2].push_back(t1);
}
for (i = 1; i <= k; i++) {
qq.push(i);
}
bfs();
for (i = 1; i < n; i++) cout << sum[i] << " ";
cout << sum[i];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[105], ans[105];
int32_t main() {
cin >> n;
for (long long i = (0); i < (n); i++) cin >> a[i];
sort(a, a + n);
for (long long i = (0); i < (n); i++) {
if (i % 2)
ans[i / 2] = a[i];
else
ans[n - i / 2 - 1] = a[i];
}
for (long long i = (0); i < (n); i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double a[5000];
int main() {
int n, i, j, c = 0;
cin >> n;
for (i = 0; i < 2 * n; i++) cin >> a[i];
for (i = 0; i < 2 * n; i++) a[i] -= (int)a[i];
double sum = 0;
for (i = 0; i < 2 * n; i++) {
sum += a[i];
if (a[i] == 0.0) c++;
}
c = n - c;
if (c < 0) c = 0;
double ans = fabs(sum - c);
while (c <= n) {
ans = min(ans, fabs(sum - c++));
}
printf("%.3lf\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int isp[10000089], T = 0;
vector<long long> primes;
void prime_gen() {
primes.push_back(2);
T = 1;
for (long long i = 3; i <= 10000079; i += 2) {
if (!isp[i]) {
primes.push_back(i);
for (long long j = i * i; j <= 10000079; j += i) {
isp[j] = 1;
}
}
}
}
int main() {
long long N;
prime_gen();
while (cin >> N) {
long long M = N;
if (N == 1) {
cout << 1 << endl << 0 << endl;
continue;
}
int fact = 0, ar[1000], is = 0;
for (int i = 0; primes[i] * primes[i] <= (N); i++) {
while (N % primes[i] == 0) {
N /= primes[i];
fact++;
if (is < 3) {
ar[is++] = primes[i];
}
}
}
if (N > 1) {
ar[is++] = N;
fact++;
}
if (fact == 1) {
cout << 1 << endl << 0 << endl;
} else if (fact == 2) {
cout << 2 << endl;
} else {
cout << 1 << endl;
if (is < 2)
while (1)
;
cout << (ar[0] * ar[1]) << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7, inv2 = (MOD + 1) / 2;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int dp[110][110][110][2], a[1000000 + 10];
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
long long readll() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
int main() {
int n = read();
int s0 = 0, s1 = 0;
for (int i = (int)1; i <= (int)n; i++)
if (i % 2 == 1)
s1++;
else
s0++;
for (int i = (int)1; i <= (int)n; i++) {
a[i] = read();
if (a[i] == 0)
a[i] = -1;
else {
a[i] = a[i] % 2;
if (a[i] == 0)
s0--;
else
s1--;
}
}
for (int i = (int)0; i <= (int)n; i++)
for (int j = (int)0; j <= (int)s0; j++)
for (int k = (int)0; k <= (int)s1; k++)
for (int op = (int)0; op <= (int)1; op++) dp[i][j][k][op] = 2e9;
dp[0][s0][s1][0] = dp[0][s0][s1][1] = 0;
a[0] = -1;
for (int i = (int)1; i <= (int)n; i++) {
if (a[i] != -1) {
for (int j = (int)0; j <= (int)s0; j++)
for (int k = (int)0; k <= (int)s1; k++)
for (int op = (int)0; op <= (int)1; op++) {
int t = 0;
if (op != a[i]) t = 1;
if (dp[i - 1][j][k][op] < 2e9)
dp[i][j][k][a[i]] =
min(dp[i][j][k][a[i]], dp[i - 1][j][k][op] + t);
}
continue;
}
for (int j = (int)0; j <= (int)s0; j++)
for (int k = (int)0; k <= (int)s1; k++)
for (int x = (int)0; x <= (int)1; x++)
for (int y = (int)0; y <= (int)1; y++) {
int t = 0;
if (x != y) t = 1;
if (x == 0 && (a[i - 1] == -1 || a[i - 1] == y) && j + 1 <= s0 &&
dp[i - 1][j + 1][k][y] < 2e9)
dp[i][j][k][x] = min(dp[i][j][k][x], dp[i - 1][j + 1][k][y] + t);
if (x == 1 && (a[i - 1] == -1 || a[i - 1] == y) && k + 1 <= s1 &&
dp[i - 1][j][k + 1][y] < 2e9)
dp[i][j][k][x] = min(dp[i][j][k][x], dp[i - 1][j][k + 1][y] + t);
}
}
int ans = min(dp[n][0][0][0], dp[n][0][0][1]);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class Point;
class Circle;
const long double EPS = 1e-14;
long double sqr(long double x) { return (x * x); }
long double ldabs(long double x) { return (x >= 0 ? x : -x); }
long double ldmax(long double a, long double b) { return (a > b ? a : b); }
long double ldmin(long double a, long double b) { return (a < b ? a : b); }
int get_deviation(long double a, long double b) {
long double delta = a - b;
if (ldabs(delta) < EPS) return 0;
return (delta > 0 ? 1 : -1);
}
void trif_limit(long double cosx) {
cosx = ldmax(ldmin(cosx, (long double)1.0), (long double)-1.0);
}
class Point {
public:
long double x, y;
public:
Point(long double i, long double j) : x(i), y(j) {}
Point() {}
public:
long double length2() const;
long double length() const;
bool is_in(const Circle &C) const;
public:
friend Point operator-(const Point &A, const Point &B);
friend Point operator/(const Point &A, const Point &B);
friend bool operator==(const Point &A, const Point &B);
friend bool operator!=(const Point &A, const Point &B);
friend long double get_distance2(const Point &A, const Point &B);
friend long double get_distance(const Point &A, const Point &B);
friend long double get_dot(const Point &A, const Point &B);
friend bool have_intersection(Circle A, Circle B, Circle C);
};
class Circle {
public:
Point center;
long double radius;
public:
Circle(Point c, long double r) : center(c), radius(r) {}
Circle() {}
public:
friend bool have_intersection(Circle A, Circle B, Circle C);
};
long double solve();
bool check();
long double t1, t2;
long double d_cs, d_sh, d_ch;
long double d1, d2;
Point cinema, house, shop;
Circle circles[3];
int main() {
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cin >> t1 >> t2 >> cinema.x >> cinema.y >> house.x >> house.y >> shop.x >>
shop.y;
d_cs = get_distance(cinema, shop);
d_sh = get_distance(shop, house);
d_ch = get_distance(cinema, house);
d1 = d_cs + d_sh;
d2 = d_ch;
long double res = solve();
cout << res << endl;
return 0;
}
long double solve() {
if (d2 + t2 >= d1) {
return ldmin(d1 + t1, d2 + t2);
}
long double left = 0, right = ldmin(d1 + t1 - d_sh, d2 + t2);
while (get_deviation(left, right) < 0) {
long double mid = (left + right) / 2;
circles[0] = Circle(cinema, mid);
circles[1] = Circle(house, d_ch + t2 - mid);
circles[2] = Circle(shop, d_cs + t1 - mid);
if (check())
left = mid;
else
right = mid;
}
return left;
}
int dcmp(long double x) {
if (fabs(x) < EPS) return 0;
return x > 0.0 ? 1 : -1;
}
bool check() {
for (int i = 0; i < 3; i++)
for (int j = i + 1; j < 3; j++) {
Circle A = circles[i];
Circle B = circles[j];
long double delta = (A.center - B.center).length();
long double rasum = ldabs(A.radius + B.radius);
if (get_deviation(delta, rasum) > 0) return false;
}
for (int i = 0; i < 3; i++)
for (int j = i + 1; j < 3; j++) {
Circle A = circles[i];
Circle B = circles[j];
long double delta = (A.center - B.center).length();
long double radelta = ldabs(A.radius - B.radius);
if (get_deviation(delta, radelta) < 0) return true;
}
for (int i = 0; i < 3; i++) {
int j = (i + 1) % 3;
int k = (i + 2) % 3;
if (have_intersection(circles[i], circles[j], circles[k])) return true;
}
return false;
}
long double Point::length2() const { return x * x + y * y; }
long double Point::length() const { return sqrt(length2()); }
bool Point::is_in(const Circle &C) const {
long double delta2 = (C.center - *this).length2();
long double radius2 = C.radius * C.radius;
return (get_deviation(delta2, radius2) <= 0);
}
Point operator-(const Point &A, const Point &B) {
return Point(A.x - B.x, A.y - B.y);
}
Point operator/(const Point &A, const Point &B) {
Point P(A.x * B.x + A.y * B.y, A.y * B.x - A.x * B.y);
P.x /= B.length2();
P.y /= B.length2();
return P;
}
bool operator==(const Point &A, const Point &B) {
return (get_deviation(A.x, B.x) == 0 && get_deviation(A.y, B.y) == 0);
}
bool operator!=(const Point &A, const Point &B) { return !(A == B); }
long double get_distance2(const Point &A, const Point &B) {
return (A - B).length2();
}
long double get_distance(const Point &A, const Point &B) {
return (A - B).length();
}
long double get_dot(const Point &A, const Point &B) {
return (A.x * B.x + A.y * B.y);
}
bool my_new_have_intersection(Circle A, Circle B, Circle C) {
long double delta = get_distance(A.center, B.center);
long double rsum = A.radius + B.radius;
long double rdelta = ldabs(A.radius - B.radius);
Point o1 = A.center, o2 = B.center;
long double r1 = A.radius, r2 = B.radius;
Point A1, A2;
long double a, b, c, p, q, r;
long double cos_value[2], sin_value[2];
a = 2.0 * r1 * (o1.x - o2.x);
b = 2.0 * r1 * (o1.y - o2.y);
c = r2 * r2 - r1 * r1 - get_distance2(o1, o2);
p = a * a + b * b;
q = -2.0 * a * c;
if (get_deviation(delta, rsum) == 0 || get_deviation(delta, rdelta) == 0) {
cos_value[0] = -q / p / 2.0;
sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);
A1.x = r1 * cos_value[0] + o1.x;
A1.y = r1 * sin_value[0] + o1.y;
if (dcmp(get_distance2(A1, o2) - sqr(r2)) != 0) {
A1.y = o1.y - r1 * sin_value[0];
}
A2 = A1;
if (A1.is_in(A) && A1.is_in(B) && A1.is_in(C)) return true;
if (A2.is_in(A) && A2.is_in(B) && A2.is_in(C)) return true;
return false;
}
r = c * c - b * b;
cos_value[0] = (sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;
cos_value[1] = (-sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;
sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);
sin_value[1] = sqrt(1 - cos_value[1] * cos_value[1]);
A1.x = r1 * cos_value[0] + o1.x;
A2.x = r1 * cos_value[1] + o1.x;
A1.y = r1 * sin_value[0] + o1.y;
A2.y = r1 * sin_value[1] + o1.y;
if (dcmp(get_distance2(A1, o2) - r2 * r2) != 0)
A1.y = o1.y - r1 * sin_value[0];
if (dcmp(get_distance2(A2, o2) - r2 * r2) != 0)
A2.y = o1.y - r1 * sin_value[1];
if (dcmp(A1.y - A2.y) == 0 && dcmp(A1.x - A2.x) == 0) {
if (A1.y > 0)
A2.y = -A2.y;
else
A1.y = -A1.y;
}
if (A1.is_in(A) && A1.is_in(B) && A1.is_in(C)) return true;
if (A2.is_in(A) && A2.is_in(B) && A2.is_in(C)) return true;
return false;
}
bool new_have_intersection(Circle A, Circle B, Circle C) {
Point o1 = A.center, o2 = B.center;
long double r1 = A.radius, r2 = B.radius;
Point A1, A2;
long double d, a, b, c, p, q, r;
long double cos_value[2], sin_value[2];
d = get_distance(o1, o2);
a = 2.0 * r1 * (o1.x - o2.x);
b = 2.0 * r1 * (o1.y - o2.y);
c = r2 * r2 - r1 * r1 - get_distance2(o1, o2);
p = a * a + b * b;
q = -2.0 * a * c;
if (dcmp(d - (r1 + r2)) == 0 || dcmp(d - fabs(r1 - r2)) == 0) {
cos_value[0] = -q / p / 2.0;
sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);
A1.x = r1 * cos_value[0] + o1.x;
A1.y = r1 * sin_value[0] + o1.y;
if (dcmp(get_distance2(A1, o2) - sqr(r2)) != 0) {
A1.y = o1.y - r1 * sin_value[0];
}
A2 = A1;
if (A1.is_in(A) && A1.is_in(B) && A1.is_in(C)) return true;
if (A2.is_in(A) && A2.is_in(B) && A2.is_in(C)) return true;
return false;
}
r = c * c - b * b;
cos_value[0] = (sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;
cos_value[1] = (-sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;
sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);
sin_value[1] = sqrt(1 - cos_value[1] * cos_value[1]);
A1.x = r1 * cos_value[0] + o1.x;
A2.x = r1 * cos_value[1] + o1.x;
A1.y = r1 * sin_value[0] + o1.y;
A2.y = r1 * sin_value[1] + o1.y;
if (dcmp(get_distance2(A1, o2) - r2 * r2) != 0)
A1.y = o1.y - r1 * sin_value[0];
if (dcmp(get_distance2(A2, o2) - r2 * r2) != 0)
A2.y = o1.y - r1 * sin_value[1];
if (dcmp(A1.y - A2.y) == 0 && dcmp(A1.x - A2.x) == 0) {
if (A1.y > 0)
A2.y = -A2.y;
else
A1.y = -A1.y;
}
if (A1.is_in(A) && A1.is_in(B) && A1.is_in(C)) return true;
if (A2.is_in(A) && A2.is_in(B) && A2.is_in(C)) return true;
return false;
}
bool ac_have_intersection(Circle A, Circle B, Circle C) {
if ((A.center - C.center).length() <= A.radius &&
(B.center - C.center).length() <= B.radius)
return true;
B.center = B.center - A.center;
C.center = C.center - A.center;
A.center = A.center - A.center;
Point R(B.center.x / B.center.length(), B.center.y / B.center.length());
B.center = B.center / R;
C.center = C.center / R;
long double x =
(A.radius * A.radius - B.radius * B.radius + B.center.length2()) /
(2 * B.center.length());
long double y = sqrt(max(A.radius * A.radius - x * x, (long double)0.0));
Point p1(x, y), p2(x, -y);
if (get_deviation(y * y + (B.center.length() - x) * (B.center.length() - x),
B.radius * B.radius) != 0)
return false;
if ((p1 - C.center).length() <= C.radius ||
(p2 - C.center).length() <= C.radius)
return true;
return false;
}
bool wa_have_intersection(Circle A, Circle B, Circle C) {
long double delta = (A.center - B.center).length();
int dev_in = get_deviation(delta, abs(A.radius - B.radius));
int dev_out = get_deviation(delta, abs(A.radius + B.radius));
if (dev_in < 0) return true;
if (dev_out > 0) return false;
long double cosa = (B.center.x - A.center.x) / delta;
long double cosb =
(A.radius * A.radius + delta * delta - B.radius * B.radius) /
(2 * A.radius * delta);
trif_limit(cosa);
trif_limit(cosb);
long double sina = sqrt(1 - cosa * cosa);
long double sinb = sqrt(1 - cosb * cosb);
trif_limit(sina);
trif_limit(sinb);
long double cosS1 = cosa * cosb - sina * sinb;
long double cosS2 = cosa * cosb + sina * sinb;
trif_limit(cosS1);
trif_limit(cosS2);
long double sinS1 = sqrt(1 - cosS1 * cosS1);
long double sinS2 = sqrt(1 - cosS2 * cosS2);
trif_limit(sinS1);
trif_limit(sinS2);
Point p1(A.center.x + A.radius * cosS1, A.center.y + A.radius * sinS1);
Point p2(A.center.x + A.radius * cosS2, A.center.y + A.radius * sinS2);
if (p1.is_in(C) || p2.is_in(C)) return true;
return false;
}
bool have_intersection(Circle A, Circle B, Circle C) {
return my_new_have_intersection(A, B, C);
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int MAXN_FOR_TRIE = 31 * 300 * 1000 + 228;
const int N = 300 * 1000 + 228;
struct Node {
int nxt[2];
int cnt;
Node() {
nxt[0] = nxt[1] = -1;
cnt = 0;
}
};
Node t[MAXN_FOR_TRIE];
int counter = 0;
inline void add(vector<int> v) {
int n = (int)v.size();
int now = 0;
for (int i = 0; i < n; ++i) {
if (t[now].nxt[v[i]] == -1) {
t[now].nxt[v[i]] = ++counter;
}
now = t[now].nxt[v[i]];
++t[now].cnt;
}
}
inline void del(vector<int> v) {
int n = (int)v.size();
int now = 0;
for (int i = 0; i < n; ++i) {
now = t[now].nxt[v[i]];
--t[now].cnt;
}
}
inline vector<int> get(vector<int> v) {
int n = (int)v.size();
int now = 0;
vector<int> res;
for (int i = 0; i < n; ++i) {
int c = v[i];
if (t[now].nxt[c] != -1 && t[t[now].nxt[c]].cnt > 0) {
now = t[now].nxt[c];
res.push_back(c);
} else {
now = t[now].nxt[c ^ 1];
res.push_back(c ^ 1);
}
}
return res;
}
inline vector<int> get_vector(int x) {
vector<int> v;
for (int i = 0; i < 30; ++i) {
v.push_back((x >> i) & 1);
}
reverse(v.begin(), v.end());
return v;
}
inline int get_int(vector<int> v) {
int x = 0;
for (int i = 0; i < 30; ++i) {
if (v[i]) {
x += (1 << (29 - i));
}
}
return x;
}
int a[N], p[N], o[N];
signed main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> p[i];
add(get_vector(p[i]));
}
for (int i = 1; i <= n; ++i) {
vector<int> kek = get(get_vector(a[i]));
del(kek);
o[i] = get_int(kek) ^ a[i];
}
for (int i = 1; i <= n; ++i) {
cout << o[i] << " ";
}
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<char> set1;
char a[100];
cin >> a;
set1.insert(a, a + (strlen(a)));
if (set1.size() % 2 == 0)
cout << "CHAT WITH HER!" << endl;
else {
cout << "IGNORE HIM!" << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int t;
cin>>t;
while(t--)
{
int n,m,a,b;
cin>>n>>m>>a>>b;
vector<int> bomb(m);
for(int i=0;i<m;i++)cin>>bomb[i];
sort(bomb.begin(),bomb.end());
if(a>b)
{
a = n-a+1;
b = n-b+1;
}
int cnt = b-a-1;
if(cnt==0)cout<<"0\n";
else
{
cnt = min(cnt,m);
int ans=0,steps=b-1;
int upto = upper_bound(bomb.begin(),bomb.begin()+cnt,steps)-bomb.begin()-1;
for(;upto>=0;upto--)
{
if(bomb[upto]<steps)
{
ans++;
steps--;
}
}
cout<<ans<<"\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int dx[8] = {1, -1, 0, 0, -1, -1, 1, 1};
int dy[8] = {0, 0, -1, 1, -1, 1, -1, 1};
vector<int> adj[200010], vis(200010, 0), dis(200010, 1000000007),
fin(200010, 0), col(200010, 0), par(200010, 0);
int myrandom(int i) { return std::rand() % i; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int l;
cin >> l;
string str;
cin >> str;
if ((int)str.length() % l == 0) {
int len = (int)str.length() / l;
string s, t;
for (int i = 0; i < l; i++) {
s.push_back(str[i]);
}
int carry = 1;
for (int i = l - 1; i >= 0; i--) {
int num = s[i] - 48;
int temp = (num + carry) % 10;
carry = (num + carry) / 10;
t.push_back(temp + 48);
}
reverse((t).begin(), (t).end());
if (!carry) {
int res = (int)str.length() / l;
for (int j = 0; j < res - 1; j++) {
for (int k = 0; k < l; k++) {
s.push_back(s[k]);
}
}
for (int j = 0; j < res - 1; j++) {
for (int k = 0; k < l; k++) {
t.push_back(t[k]);
}
}
if (s > str) {
cout << s << '\n';
} else {
cout << t << '\n';
}
} else {
string ans;
int res = (int)str.length() / l;
for (int i = 0; i < l; i++) {
if (i == 0) {
ans.push_back('1');
} else {
ans.push_back('0');
}
}
for (int j = 0; j < res; j++) {
for (int k = 0; k < l; k++) {
ans.push_back(ans[k]);
}
}
cout << ans << '\n';
}
} else {
int cnt = 0;
while (cnt * l <= (int)str.length()) {
cnt++;
}
string ans;
for (int i = 0; i < l; i++) {
if (i == 0) {
ans.push_back('1');
} else {
ans.push_back('0');
}
}
for (int j = 0; j < cnt - 1; j++) {
for (int k = 0; k < l; k++) {
ans.push_back(ans[k]);
}
}
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int type[300005];
int main() {
int n, m, c;
cin >> n >> m;
string str, stemp, s = "..";
cin >> str;
stemp = str;
long int ans = 0;
int ret;
string ::iterator it;
int i;
for (it = str.begin(), i = 1; it != str.end(); it++, i++) {
if ((*it) == '.') type[i] = 1;
}
for (int j = 1; j < n; j++) {
if (str[j] == '.' && str[j - 1] == '.') ans++;
}
while (m--) {
int x;
char ch;
cin >> x >> ch;
if (ch == '.') {
if (type[x] == 1) {
} else {
type[x] = 1;
if (type[x - 1] && type[x + 1])
ans += 2;
else if (type[x - 1] || type[x + 1])
ans += 1;
}
} else {
if (type[x] == 0) {
} else {
type[x] = 0;
if (type[x - 1] && type[x + 1])
ans -= 2;
else if (type[x - 1] || type[x + 1])
ans -= 1;
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
return x * f;
}
void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 100;
int n, m, a, b, sum[N][N];
int ans = 1000000000;
int S(int x1, int y1, int x2, int y2) {
return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + read();
a = read(), b = read();
for (int x1 = 1; x1 <= n; x1++)
for (int y1 = 1; y1 <= m; y1++) {
int x2 = x1 + a - 1, y2 = y1 + b - 1;
if (x2 <= n && y2 <= m) ans = min(ans, S(x1, y1, x2, y2));
x2 = x1 + b - 1, y2 = y1 + a - 1;
if (x2 <= n && y2 <= m) ans = min(ans, S(x1, y1, x2, y2));
}
print(ans), putchar('\n');
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
using ii = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
const int N = 5005;
const int mod = 1000000007;
ll dp[N][N];
deque<int> sv[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, x;
cin >> n >> k >> x;
vector<ll> a(n);
for (auto& x : a) cin >> x;
ll ans = -1;
memset(dp, -63, sizeof dp);
dp[n][x] = 0;
for (int i = 0; i <= x; i++) {
sv[i].push_back(n);
}
sv[x].push_back(0);
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < x; j++) {
dp[i][j] = dp[sv[j + 1].front()][j + 1] + a[i];
if (i < k && j == 0) ans = max(ans, dp[i][j]);
}
for (int j = 0; j <= x; j++) {
while (!sv[j].empty() && sv[j].front() >= i + k) sv[j].pop_front();
while (!sv[j].empty() && dp[i][j] >= dp[sv[j].back()][j])
sv[j].pop_back();
sv[j].push_back(i);
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1e9 + 7;
int n, va[100012], s[100012], tot, Q, c[100012], a[100012][2], id[100012];
vector<int> v[100012];
int rt[100012], ls[2000000], rs[2000000], he[2000000][2], su[2000000][2],
tag[2000000][2], ans[100012], js, ct[2000000], anss, len[100012], tco;
inline void ins(int x) {
for (int i = x; i <= n; i += (i & (-i))) c[i]++;
}
inline int ask(int x) {
int ret = 0;
for (int i = x; i; i -= (i & (-i))) ret += c[i];
return ret;
}
inline void pushdown(int ind) {
for (int i = 0; i < 2; i++) {
su[ls[ind]][i] =
(su[ls[ind]][i] + 1ll * tag[ind][i] * he[ls[ind]][i] % p) % p;
su[rs[ind]][i] =
(su[rs[ind]][i] + 1ll * tag[ind][i] * he[rs[ind]][i] % p) % p;
tag[ls[ind]][i] = (tag[ls[ind]][i] + tag[ind][i]) % p;
tag[rs[ind]][i] = (tag[rs[ind]][i] + tag[ind][i]) % p;
tag[ind][i] = 0;
}
}
inline void pushup(int ind) {
ct[ind] = (ct[ls[ind]] + ct[rs[ind]]) % p;
for (int i = 0; i < 2; i++)
he[ind][i] = (he[ls[ind]][i] + he[rs[ind]][i]) % p,
su[ind][i] = (su[ls[ind]][i] + su[rs[ind]][i]) % p;
}
void chnghe(int &ind, int l, int r, int x, int y, int yy, int op) {
if (!ind) ind = ++js;
if (l == r) {
he[ind][op] = a[v[tco][l - 1]][op] * y;
ct[ind] = y;
su[ind][op] = yy * y;
return;
}
int mid = (l + r) >> 1;
pushdown(ind);
if (x <= mid)
chnghe(ls[ind], l, mid, x, y, yy, op);
else
chnghe(rs[ind], mid + 1, r, x, y, yy, op);
pushup(ind);
}
void chngsu(int &ind, int l, int r, int al, int ar, int x, int op) {
if (!ind) ind = ++js;
if (al > ar) return;
if (al <= l && r <= ar) {
(su[ind][op] += 1ll * x * he[ind][op] % p) %= p;
(tag[ind][op] += x) %= p;
return;
}
int mid = (l + r) >> 1;
pushdown(ind);
if (al <= mid) chngsu(ls[ind], l, mid, al, ar, x, op);
if (ar > mid) chngsu(rs[ind], mid + 1, r, al, ar, x, op);
pushup(ind);
}
int askhe(int ind, int l, int r, int al, int ar, int op) {
if (al > ar || !ind) return 0;
if (al <= l && r <= ar) return he[ind][op];
int mid = (l + r) >> 1, ret = 0;
pushdown(ind);
if (al <= mid) ret = (ret + askhe(ls[ind], l, mid, al, ar, op)) % p;
if (ar > mid) ret = (ret + askhe(rs[ind], mid + 1, r, al, ar, op)) % p;
return ret;
}
int asksu(int ind, int l, int r, int al, int ar, int op) {
if (al > ar || !ind) return 0;
if (al <= l && r <= ar) return su[ind][op];
int mid = (l + r) >> 1, ret = 0;
pushdown(ind);
if (al <= mid) ret = (ret + asksu(ls[ind], l, mid, al, ar, op)) % p;
if (ar > mid) ret = (ret + asksu(rs[ind], mid + 1, r, al, ar, op)) % p;
return ret;
}
int askct(int ind, int l, int r, int al, int ar) {
if (al > ar || !ind) return 0;
if (al <= l && r <= ar) return ct[ind];
int mid = (l + r) >> 1, ret = 0;
pushdown(ind);
if (al <= mid) ret += askct(ls[ind], l, mid, al, ar);
if (ar > mid) ret += askct(rs[ind], mid + 1, r, al, ar);
return ret;
}
inline void ada(int x) {
tco = va[x];
anss = (anss - ans[va[x]] + p) % p;
(ans[va[x]] += 1ll * askhe(rt[va[x]], 1, len[va[x]], 1, id[x] - 1, 0) *
askhe(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], 1) %
p) %= p;
chngsu(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], 1, 0);
chngsu(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], 1, 1);
int pos = askct(rt[va[x]], 1, len[va[x]], 1, id[x]) + 1;
(ans[va[x]] +=
1ll * a[x][0] *
(asksu(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], 1) -
1ll * (pos + 1) *
askhe(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], 1) % p +
p) %
p) %= p;
(ans[va[x]] +=
1ll * a[x][1] *
(1ll * (pos - 1) * askhe(rt[va[x]], 1, len[va[x]], 1, id[x] - 1, 0) % p -
asksu(rt[va[x]], 1, len[va[x]], 1, id[x] - 1, 0) + p) %
p) %= p;
chnghe(rt[va[x]], 1, len[va[x]], id[x], 1, 1ll * pos * a[x][0] % p, 0);
chnghe(rt[va[x]], 1, len[va[x]], id[x], 1, 1ll * pos * a[x][1] % p, 1);
anss = (anss + ans[va[x]]) % p;
}
inline void sub(int x) {
tco = va[x];
anss = (anss - ans[va[x]] + p) % p;
int pos = askct(rt[va[x]], 1, len[va[x]], 1, id[x]);
chnghe(rt[va[x]], 1, len[va[x]], id[x], 0, 1ll * pos * a[x][0] % p, 0);
chnghe(rt[va[x]], 1, len[va[x]], id[x], 0, 1ll * pos * a[x][1] % p, 1);
ans[va[x]] = (ans[va[x]] -
1ll * a[x][1] *
(1ll * (pos - 1) *
askhe(rt[va[x]], 1, len[va[x]], 1, id[x] - 1, 0) % p -
asksu(rt[va[x]], 1, len[va[x]], 1, id[x] - 1, 0) + p) %
p +
p) %
p;
ans[va[x]] =
(ans[va[x]] -
1ll * a[x][0] *
(asksu(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], 1) -
1ll * (pos + 1) *
askhe(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], 1) % p +
p) %
p +
p) %
p;
chngsu(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], p - 1, 1);
chngsu(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], p - 1, 0);
ans[va[x]] =
(ans[va[x]] -
1ll * askhe(rt[va[x]], 1, len[va[x]], 1, id[x] - 1, 0) *
askhe(rt[va[x]], 1, len[va[x]], id[x] + 1, len[va[x]], 1) % p +
p) %
p;
anss = (anss + ans[va[x]]) % p;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &va[i]), s[++tot] = va[i];
sort(s + 1, s + 1 + tot);
tot = unique(s + 1, s + 1 + tot) - s - 1;
for (int i = 1; i <= n; i++)
va[i] = lower_bound(s + 1, s + 1 + tot, va[i]) - s;
for (int i = 1; i <= n; i++) a[i][0] = ask(va[i]), ins(va[i]);
for (int i = 1; i <= n; i++) c[i] = 0;
for (int i = n; i; i--) a[i][1] = ask(va[i]), ins(va[i]);
for (int i = 1; i <= n; i++) v[va[i]].push_back(i), id[i] = v[va[i]].size();
for (int i = 1; i <= n; i++) len[i] = v[i].size();
for (int i = 1; i <= n; i++) {
ada(i);
}
scanf("%d", &Q);
while (Q--) {
int op, x;
scanf("%d%d", &op, &x);
if (op == 1)
sub(x);
else
ada(x);
printf("%d\n", anss);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, d;
int a[N];
int pref[N];
void solve() {
scanf("%d %d", &n, &d);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
for (int i = 1; i <= n; ++i) {
pref[i] += pref[i - 1] + a[i];
}
long long u = 0, v = 0;
int ans = 0;
for (int i = 1; i <= n; ++i) {
u += a[i], v += a[i];
if (u > d) {
printf("-1\n");
return;
}
v = min(v, 1LL * d);
if (!a[i] and u < 0) {
if (v < 0) {
ans++;
u = 0, v = d;
} else {
u = 0;
}
}
}
printf("%d\n", ans);
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x1, y1, x2, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
if (x1 != n && x1 != 0) swap(x1, y1), swap(x2, y2);
if (x1 == x2 && (x1 == 0 || x1 == n)) {
cout << abs(y1 - y2) << endl;
} else if (y1 == y2 && (y1 == 0 || y1 == n)) {
cout << abs(x1 - x2) << endl;
} else if (x1 == 0) {
if (x2 == n) {
cout << min(y1 + y2, (n - y1) + (n - y2)) + n << endl;
} else {
cout << (y2 == 0 ? y1 : n - y1) + x2 << endl;
}
} else if (x1 == n) {
if (x2 == 0) {
cout << min(y1 + y2, (n - y1) + (n - y2)) + n << endl;
} else {
cout << (y2 == 0 ? y1 : n - y1) + (n - x2) << endl;
}
} else
abort();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 50;
int n, x, y;
int b[N];
set<int> ocu[N];
int res[N];
int getnxt(int v) {
if (ocu[v].empty()) return -1;
int c = *ocu[v].begin();
ocu[v].erase(ocu[v].begin());
return c;
}
void solve() {
cin >> n >> x >> y;
for (int i = 0; i < (n + 2); ++i) {
ocu[i].clear();
}
int rem = n;
priority_queue<pair<int, int> > pque;
map<int, int> mp;
for (int i = 0; i < (n); ++i) {
cin >> b[i];
mp[b[i]]++;
ocu[b[i]].insert(i);
}
int mex = 1;
for (auto &p : mp) {
if (p.first == mex) mex++;
}
fill(res, res + n, mex);
for (auto &p : mp) pque.push({p.second, p.first});
while (x > 0) {
pair<int, int> p = pque.top();
pque.pop();
res[getnxt(p.second)] = p.second;
p.first--;
if (p.first) pque.push(p);
x--, y--;
rem--;
}
int mxcnt = (pque.empty() ? 0 : pque.top().first);
vector<int> ct;
int mxfreq = min(rem - mxcnt, mxcnt);
while (!pque.empty()) {
pair<int, int> p = pque.top();
pque.pop();
for (int i = 0; i < mxfreq && i < p.first; i++) ct.push_back(p.second);
}
if ((int)(ct).size() < y) {
cout << "NO\n";
return;
}
for (int i = 0; i < y; i++) {
res[getnxt(ct[i])] = ct[(i + mxfreq) % (int)(ct).size()];
}
cout << "YES\n";
for (int i = 0; i < (n); ++i) cout << res[i] << " ";
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
solve();
}
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const long long MOD = 1e9 + 7;
const long long INF = 1e9 + 7;
#define pb push_back
#define ff first
#define ss second
#define max_(a,b,c) max1(max1(a,b),c)
#define min_(a,b,c) mn(mn(a,b),c)
long gcd(long a,long b) { return b?gcd(b,a%b):a;}
#define rep(i,a,n) for(int i=a;i<n;i++)
#define per(i,n,a) for(int i=n-1;i>=a;i--)
#define vi vector<int>
#define pii pair<int,int>
#define pll pair<long long,long long>
#define vll vector<long long>
const int mod = 1e9 +7;
const int inf=INT_MAX;
const ll inff=LLONG_MAX;
int mem[5005][5005];
int dp(vector<int> &a, vector<int> &b, int i, int j)
{
if(mem[i][j]!=-1)
return mem[i][j];
if(i>=a.size())
return 0;
if(j>=b.size())
return inf;
int temp=inf;
int paired=dp(a,b,i+1,j+1);
int not_paired=dp(a,b,i,j+1);
if(paired!=inf)
{
temp=min(temp,abs(a[i]-b[j])+paired);
}
if(not_paired!=inf)
{
temp=min(temp,not_paired);
}
mem[i][j]=temp;
return temp;
}
void process()
{
int n;
cin>>n;
vector<int> v;
vector<int> a1,a0;
rep(i,0,n)
{
int x;
cin>>x;
if(x==1)
{
a1.push_back(i);
}
else if(x==0)
{
a0.push_back(i);
}
v.push_back(x);
}
for(int i=0;i<n+2;++i)
{
for(int j=0;j<n+2;++j)
{
mem[i][j] = -1;
}
}
cout<<dp(a1,a0,0,0)<<"\n";
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
//cout<<"Hi!";
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
// chrono::time_point<std::chrono::system_clock> start, end;
// start = chrono::system_clock::now();
#endif // ONLINE_JUDGE
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t=1;
//cin>>t;
while(t--)
process();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[100];
vector<int> c(n * k, 0);
for (int i = 1; i <= k; ++i) {
cin >> a[i];
c[a[i]] = 1;
}
int flag = 1;
for (int i = 1; i <= k; ++i) {
cout << a[i] << " ";
int cnt = n - 1;
int j = flag;
while (cnt) {
if (c[j] != 1) {
cout << j << " ";
cnt--;
}
++j;
}
flag = j;
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c = 0, n, min = INT_MAX, max = INT_MIN;
cin >> n;
while (n--) {
int a;
cin >> a;
if (a > max) {
max = a;
c++;
}
if (a < min) {
min = a;
c++;
}
}
cout << c - 2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
int x, y, m = -1;
cin >> x;
for (int i = 1; i < n; ++i) {
cin >> y;
if (y < x) m = max(m, x - y);
x = max(x, y);
}
if (m == -1)
cout << 0 << '\n';
else
cout << ceil(log2(m + 1)) << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[6], ans;
int main() {
for (int i = 0; i < 6; i++) cin >> a[i];
ans = (a[5] + a[0] + a[1]) * (a[5] + a[4] + a[3]);
ans -= (a[5] * a[5] + a[3] * a[3] + a[1] * a[1]);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void dfs(int u, const vector<vector<int> > &a, const vector<int> &c,
vector<int> &p, vector<int> &cntRed, vector<int> &cntBlue) {
if (c[u] == 1) {
cntRed[u] = 1;
} else if (c[u] == 2) {
cntBlue[u] = 1;
}
for (int v : a[u]) {
if (p[v] != -1) {
continue;
}
p[v] = u;
dfs(v, a, c, p, cntRed, cntBlue);
cntRed[u] += cntRed[v];
cntBlue[u] += cntBlue[v];
}
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> c(n), p(n, -1), cntRed(n), cntBlue(n);
vector<vector<int> > a(n);
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
a[u - 1].push_back(v - 1);
a[v - 1].push_back(u - 1);
}
p[0] = 0;
dfs(0, a, c, p, cntRed, cntBlue);
int ans = 0;
for (int v = 1; v < n; ++v) {
int cntRedP = cntRed[0] - cntRed[v];
int cntBlueP = cntBlue[0] - cntBlue[v];
if (cntRedP && cntBlueP) {
continue;
}
if (cntRed[v] && cntBlue[v]) {
continue;
}
++ans;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int k = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
k++;
cout << "YES" << endl;
break;
}
}
if (k == 0) cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int dp[505][505];
int main() {
int n, m, b, mod, pos, pgr, bugs;
cin >> n >> m >> b >> mod;
vector<int> a(n);
for (int i = 0; i < (n); i++) cin >> a[i];
dp[m][0] = 1;
for (pgr = n - 1; pgr >= 0; pgr--)
for (pos = m - 1; pos >= 0; pos--)
for (bugs = a[pgr]; bugs <= b; bugs++)
dp[pos][bugs] = (dp[pos][bugs] + dp[pos + 1][bugs - a[pgr]]) % mod;
int res = 0;
for (int i = 0; i <= b; i++) res = (res + dp[0][i]) % mod;
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long int>;
using vvi = vector<vi>;
using vb = vector<bool>;
using vc = vector<char>;
using vs = vector<string>;
using vld = vector<long double>;
using pii = pair<long long int, long long int>;
using psi = pair<string, long long int>;
using pci = pair<char, long long int>;
using vpii = vector<pii>;
long long int mod = 1e9 + 7;
long long int const maxn = 1e5 + 5;
long long int const inf = 1e18;
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int mul(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int powm(long long int x, long long int n, long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long int modinverse(long long int a, long long int m) {
return powm(a, m - 2, m);
}
bool prime(long long int x) {
if (x <= 1) return false;
for (int i = 2; i <= sqrt(x); i++)
if (x % i == 0) return false;
return true;
}
long long int divisor(long long int x) {
long long int cnt = 0;
for (int i = 1; i <= sqrt(x); i++) {
if (x % i == 0) {
if (i != x / i)
cnt += 2;
else
cnt += 1;
}
}
return cnt;
}
vector<long long int> sieve(long long int n) {
bool prim[n + 1];
memset(prim, true, sizeof(prim));
for (long long int p = 2; p * p <= n; p++) {
if (prim[p] == true) {
for (int i = p * p; i <= n; i += p) prim[i] = false;
}
}
vector<long long int> v;
for (int i = 2; i <= n; i++)
if (prim[i]) v.push_back(i);
return v;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
t = 1;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
m += 1;
long long int cnt = 0;
while (m > 0) {
m /= 10;
cnt++;
}
long long int ans = (cnt - 1) * n;
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void wssert(bool b) {
if (!b) {
cout << "GARBAGE\n";
exit(0);
}
}
void f(const vector<int>& verts);
namespace kactl {
vector<int> val, comp, z, cont;
int Time, ncomps;
vector<vector<int>> g;
int dfs(int j) {
int low = val[j] = ++Time;
z.push_back(j);
for (auto& e : g[j])
if (comp[e] < 0) low = min(low, val[e] ? val[e] : dfs(e));
if (low == val[j]) {
int x;
do {
x = z.back();
z.pop_back();
comp[x] = ncomps;
cont.push_back(x);
} while (x != j);
f(cont);
cont.clear();
ncomps++;
}
return val[j] = low;
}
void scc(int st) {
int n = (int)(g).size();
val.assign(n, 0);
comp.assign(n, -1);
Time = ncomps = 0;
dfs(st);
}
} // namespace kactl
using kactl::comp;
using kactl::g;
using kactl::ncomps;
const int MAXN = 1.1e5;
const int MAXM = 1.1e5;
const int MAXD = 60;
int N, M;
vector<int> adj[MAXN];
int D;
bool open[MAXN][MAXD];
vector<int> dp;
void f(const vector<int>& verts) {
wssert(!verts.empty());
vector<int> opens;
for (int v : verts) {
if (open[v / D][v % D]) {
opens.push_back(v / D);
}
}
sort(opens.begin(), opens.end());
int nOpen = unique(opens.begin(), opens.end()) - opens.begin();
wssert(int(dp.size()) == ncomps);
dp.push_back(0);
for (int cur : verts) {
for (int nxt : g[cur]) {
wssert(0 <= comp[nxt] && comp[nxt] <= ncomps);
if (comp[nxt] == ncomps) continue;
dp[ncomps] = max(dp[ncomps], dp[comp[nxt]]);
}
}
dp[ncomps] += nOpen;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> N >> M >> D;
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
}
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int d = 0; d < D; d++) {
open[i][d] = (s[d] == '1');
}
}
g = vector<vector<int>>(N * D);
for (int i = 0; i < N; i++) {
for (int j : adj[i]) {
for (int d = 0; d < D; d++) {
wssert(0 <= j && j < N);
g[i * D + d].push_back(j * D + (d + 1) % D);
}
}
}
using kactl::comp;
using kactl::ncomps;
kactl::scc(0);
cout << dp[comp[0]] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long m, l, r, n, q, j, i, cr, cl, c, cnt, k;
long long ar[200005];
long long br[200005];
int kaj = 2e6 + 5;
int arr[200005];
int main() {
map<long long, long long> mp, lmp;
long long sm = 0;
scanf("%lld", &n);
for (long long i = 0; i < n; i++) {
scanf("%lld", &ar[i]);
sm += ar[i];
mp[ar[i]]++;
}
long long lf = 0;
if (sm % 2) {
cout << "NO";
} else {
long long rsm = sm;
sm /= 2;
for (i = 0; i < n; i++) {
lf += ar[i];
mp[ar[i]]--;
lmp[ar[i]]++;
rsm -= ar[i];
if (lf < sm && mp[sm - lf] || rsm < sm && lmp[sm - rsm]) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long numMatch;
long long C;
vector<long long> vecRes;
set<long long> setRes;
long long getCompareRes(long long n) {
long long tmp = n * (n - 1) / 2 + C * n;
if (tmp == numMatch) {
return 0;
} else if (tmp < numMatch) {
return -1;
} else {
return 1;
}
}
long long getAns() {
long long lb = 1, ub;
if (C == 0) {
ub = 1LL << 32 - 1;
} else {
ub = min(1LL << 32 - 1, numMatch / C);
}
long long mid;
while (lb <= ub) {
long long mid = (lb + ub) / 2;
int compareRes = getCompareRes(mid);
if (compareRes == -1) {
lb = mid + 1;
} else if (compareRes == 1) {
ub = mid - 1;
} else {
return mid;
}
}
return -1;
}
long long getBase(int exp) {
long long base = 1;
for (int i = 0; i < exp; i++) {
base *= 2;
}
return base;
}
int main() {
while (scanf("%I64d", &numMatch) != -1) {
setRes.clear();
for (int i = 0; i <= 64; i++) {
C = getBase(i) - 1;
long long res = getAns();
if ((res != -1) && res % 2 != 0) {
setRes.insert(res * (C + 1));
}
}
if (setRes.empty()) {
printf("-1\n");
continue;
}
vecRes.clear();
for (set<long long>::iterator it = setRes.begin(); it != setRes.end();
it++) {
vecRes.push_back(*it);
}
sort(vecRes.begin(), vecRes.end());
for (int i = 0; i < vecRes.size(); i++) {
cout << vecRes[i] << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, l, r, x, a, b;
long long ans = 0;
int main() {
scanf("%d %d", &n, &x);
l = r = x;
for (int i = 0; i < n; i++) {
scanf("%d %d", &a, &b);
if (a <= l && r <= b) continue;
if (l > b) {
ans += l - b;
r = l;
l = b;
} else if (r < a) {
ans += a - r;
l = r;
r = a;
} else {
if (l < a) l = a;
if (r > b) r = b;
}
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int lst[100005], to[200005], pre[200005], idx[200005], tot, deg[100005];
int seq[100005], cnt, vis[100005], st[100005][2], tp;
int dp[100005][2][2], dp2[100005][2][2][2], f[100005][2];
int a[100005], b[100005];
bool del[200005], dfs_vis[100005];
inline void upd(int &x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
inline void add_edge(int u, int v, int _idx) {
to[tot] = v;
pre[tot] = lst[u];
idx[tot] = _idx;
deg[v]++;
lst[u] = tot++;
}
inline int calc(int v, int x, int y) {
if (to[v] != ((b[idx[v]]) < 0 ? -(b[idx[v]]) : (b[idx[v]]))) swap(x, y);
if (a[idx[v]] < 0) x ^= 1;
if (b[idx[v]] < 0) y ^= 1;
return x | y;
}
void dfs(int u) {
if (dfs_vis[u]) return;
dfs_vis[u] = true;
for (int i = lst[u]; ~i; i = pre[i]) {
if (del[i]) continue;
seq[cnt++] = i;
del[i] = del[i ^ 1] = true;
dfs(to[i]);
}
}
int main() {
memset(lst, -1, sizeof(lst));
int n, m, neg = 0, ans = 1;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int len;
scanf("%d", &len);
if (len == 1) {
scanf("%d", a + i);
if (vis[((a[i]) < 0 ? -(a[i]) : (a[i]))]) {
st[tp][0] = 0;
st[tp--][1] = 0;
(ans <<= 1) %= 1000000007;
continue;
}
vis[((a[i]) < 0 ? -(a[i]) : (a[i]))] = a[i];
if (!deg[((a[i]) < 0 ? -(a[i]) : (a[i]))]) {
st[++tp][0] = 1;
st[tp][1] = 1;
}
continue;
}
scanf("%d%d", a + i, b + i);
if (a[i] == -b[i]) {
neg++;
vis[((a[i]) < 0 ? -(a[i]) : (a[i]))] = 1;
(ans <<= 1) %= 1000000007;
continue;
}
int x = ((a[i]) < 0 ? -(a[i]) : (a[i])),
y = ((b[i]) < 0 ? -(b[i]) : (b[i]));
if (x == y) {
vis[x] = 1;
st[++tp][0] = 1;
st[tp][1] = 1;
continue;
}
add_edge(x, y, i);
add_edge(y, x, i);
if (vis[x]) {
st[tp][0] = 0;
st[tp--][1] = 0;
}
if (vis[y]) {
st[tp][0] = 0;
st[tp--][1] = 0;
}
}
for (int u = 1; u <= m; u++) {
if (dfs_vis[u] || deg[u] == 2) continue;
if (!deg[u] && !vis[u]) {
(ans <<= 1) %= 1000000007;
continue;
}
if (!deg[u]) continue;
cnt = 0;
dfs(u);
for (int j = 0; j < cnt; j++) memset(dp[j], 0, sizeof(dp[j]));
if (vis[u] < 0) {
dp[0][0][calc(seq[0], 0, 0) ^ 1]++;
dp[0][1][calc(seq[0], 0, 1) ^ 1]++;
dp[0][0][calc(seq[0], 1, 0)]++;
dp[0][1][calc(seq[0], 1, 1)]++;
} else if (vis[u] > 0) {
dp[0][0][calc(seq[0], 0, 0)]++;
dp[0][1][calc(seq[0], 0, 1)]++;
dp[0][0][calc(seq[0], 1, 0) ^ 1]++;
dp[0][1][calc(seq[0], 1, 1) ^ 1]++;
} else {
dp[0][0][calc(seq[0], 0, 0)]++;
dp[0][1][calc(seq[0], 0, 1)]++;
dp[0][0][calc(seq[0], 1, 0)]++;
dp[0][1][calc(seq[0], 1, 1)]++;
}
for (int i = 1; i < cnt; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int x = 0; x < 2; x++)
upd(dp[i][j][x ^ calc(seq[i], k, j)], dp[i - 1][k][x]);
}
}
}
tp++;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (vis[to[seq[cnt - 1]]])
upd(st[tp][i ^ j ^ (vis[to[seq[cnt - 1]]] < 0)], dp[cnt - 1][i][j]);
else
upd(st[tp][j], dp[cnt - 1][i][j]);
}
}
}
for (int u = 1; u <= m; u++) {
if (dfs_vis[u] || deg[u] != 2) continue;
cnt = 0;
dfs(u);
for (int i = 0; i < cnt; i++) memset(dp2[i], 0, sizeof(dp2[i]));
dp2[0][0][0][calc(seq[0], 0, 0)]++;
dp2[0][0][1][calc(seq[0], 0, 1)]++;
dp2[0][1][0][calc(seq[0], 1, 0)]++;
dp2[0][1][1][calc(seq[0], 1, 1)]++;
for (int i = 1; i < cnt - 1; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++)
upd(dp2[i][j][x][y ^ calc(seq[i], k, x)], dp2[i - 1][j][k][y]);
}
}
}
}
tp++;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++)
upd(st[tp][k ^ calc(seq[cnt - 1], j, i)], dp2[cnt - 2][i][j][k]);
}
}
}
f[0][0] = ans;
for (int i = 1; i <= tp; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++)
upd(f[i][j ^ k], (long long)f[i - 1][j] * st[i][k] % 1000000007);
}
}
printf("%d\n", f[tp][neg & 1 ^ 1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int moves[300001];
vector<int> pile;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a != 0) {
moves[a] = 0;
}
}
for (int i = 0; i < n; i++) {
int a;
cin >> a;
pile.push_back(a);
if (a != 0) {
moves[a] = i + 1;
}
}
int largest_dif = 0;
for (int i = 1; i <= n; i++) {
if (moves[i] > i - 1) {
largest_dif = max(largest_dif, moves[i] - i + 1);
}
}
int streak = 0;
for (int i = n - 1; i >= 0; i--) {
if (pile[i] == 1) {
streak = pile[n - 1];
break;
}
if (pile[i] == 0) {
streak = 0;
break;
}
if (i > 0) {
if (pile[i] - pile[i - 1] != 1) {
streak = 0;
break;
}
}
}
if (streak == 0) {
cout << largest_dif + n << endl;
} else {
int new_largest_dif = 0;
for (int i = streak + 1; i <= n; i++) {
if (moves[i] > i - 1 - streak) {
new_largest_dif = max(new_largest_dif, moves[i] - i + 1 + streak);
}
}
if (new_largest_dif != 0) {
cout << largest_dif + n << endl;
} else {
cout << new_largest_dif + n - streak << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
unordered_map<long long, long long> a;
long long tt;
for (long long i = 0; i < n; i++) {
cin >> tt;
a[tt]++;
}
cout << a[0] << ' ';
map<long long, long long> don;
long long ans = 0;
if (a[0] == 0) {
ans = -1;
} else {
if (a[0] > 1) don[0] = (a[0] - 1);
}
long long fil = 0;
for (long long i = 1; i <= n; i++) {
long long a2 = 0;
if (ans == -1) {
cout << -1 << ' ';
continue;
}
a2 += a[i];
a2 += fil;
cout << a2 << ' ';
if (a[i] > 1) {
don[i] = (a[i] - 1);
} else if (a[i] == 0) {
if (don.size() > 0) {
auto it = don.end();
it--;
fil += (i - it->first);
it->second--;
if (it->second == 0) {
don.erase(it->first);
}
} else {
ans = -1;
}
}
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int m = n - k + 1;
int data[n];
for (int i = 0; i < n; ++i) {
cin >> data[i];
}
set<int> S;
map<int, int> mp;
for (int i = 0; i < k - 1; ++i) {
mp[data[i]]++;
if (mp[data[i]] == 1)
S.insert(data[i]);
else
S.erase(data[i]);
}
for (int i = k - 1; i < n; ++i) {
mp[data[i]]++;
if (mp[data[i]] == 1)
S.insert(data[i]);
else
S.erase(data[i]);
if (S.empty())
cout << "Nothing" << endl;
else {
set<int>::const_iterator it = S.end();
it--;
cout << *it << endl;
}
mp[data[i - (k - 1)]]--;
if (mp[data[i - (k - 1)]] == 1)
S.insert(data[i - (k - 1)]);
else
S.erase(data[i - (k - 1)]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int eg[105][105];
int ans[105][105][27];
int work(int a, int b, int c) {
if (ans[a][b][c] != -1) return ans[a][b][c];
for (int i = 0; i < 105; i++) {
if (eg[a][i] < c) continue;
if (work(b, i, eg[a][i]) == 1) return ans[a][b][c] = 0;
}
return ans[a][b][c] = 1;
}
int main() {
memset(eg, -1, sizeof(eg));
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
char inp[20];
scanf("%d%d", &u, &v);
scanf("%s", inp);
eg[u][v] = inp[0] - 'a';
}
memset(ans, -1, sizeof(ans));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (!work(i, j, 0))
printf("A");
else
printf("B");
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int sum(long long a) {
long long res = 0;
while (a > 0) {
res += a % 10;
a /= 10;
}
return res;
}
int main() {
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long n = 0;
if (sum(a) <= b) {
cout << 0 << "\n";
continue;
}
long long h = 1;
for (int i = 0; i < 18; i++) {
int x = (a / h) % 10;
long long add = h * ((10 - x) % 10);
a += add;
n += add;
if (sum(a) <= b) {
break;
}
h *= 10;
}
cout << n << endl;
}
return 0;
}
| 3 |
#include<iostream>
using namespace std;
#define maxn 5005
char s[maxn];
int sum_pref[2][maxn];
int sum_map[2 * maxn + 1];
int dp[maxn];
inline int get_lr(int l, int r)
{
int s0 = sum_pref[0][r] - (l > 0 ? sum_pref[0][l - 1] : 0);
int s1 = sum_pref[1][r] - (l > 0 ? sum_pref[1][l - 1] : 0);
if (s0 > s1)
return s0 - s1;
return s1 - s0;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
//freopen("input.txt", "r", stdin);
int t, n;
// cin >> t;
t =1;
for (int tc = 1; tc <= t; tc++)
{
cin >> n ;
for (int i = 0; i <= 2 * n; i++)
{
if (i < n)
{
sum_pref[0][i] = sum_pref[1][i] = 0;
dp[i] = 1e9;
}
sum_map[i] = -1;
}
for (int i = 0; i < n; i++)
{
int k;
cin>>k;
s[i] = k+'0';
sum_pref[s[i] - '0'][i] = i;
if (i>0)
{
sum_pref[0][i] += sum_pref[0][i - 1];
sum_pref[1][i] += sum_pref[1][i - 1];
}
}
int sum = n; // to account for negative values of sum
sum_map[sum] = 0;
for (int i = 0; i< n; i++)
{
sum += 2 * (s[i] - '0') - 1;
if (sum_map[sum] != -1)
{
int l = sum_map[sum], r = i;
int val = get_lr(l, r) + (l > 0 ? dp[l - 1] : 0);
if (dp[r] > val)
dp[r] = val;
}
sum_map[sum] = i + 1;
if (s[i] == '0')
{
if (i == 0)
dp[i] = 0;
else if (dp[i] > dp[i - 1])
dp[i] = dp[i-1];
}
}
cout <<dp[n - 1] << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
size_t maxSize = 0;
set<int> q;
for (int i = 0; i < 2 * n; i++) {
int sockNumber;
cin >> sockNumber;
set<int>::iterator it = q.find(sockNumber);
if (it != q.end())
q.erase(it);
else
q.insert(sockNumber);
maxSize = max(maxSize, q.size());
}
cout << maxSize;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace mine {
long long qread() {
long long ans = 0, f = 1;
char c = getchar();
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) putchar('-'), num = -num;
if (num >= 10) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
putchar('\n');
}
template <typename T>
void chmax(T &x, const T y) {
x = (x > y ? x : y);
}
template <typename T>
void chmin(T &x, const T y) {
x = (x < y ? x : y);
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
int mm(const int x) { return x >= MOD ? x - MOD : x; }
template <typename T>
void add(T &x, const int &y) {
x = (x + y >= MOD ? x + y - MOD : x + y);
}
long long qpower(long long x, long long e, int mod = MOD) {
long long ans = 1;
while (e) {
if (e & 1) ans = ans * x % mod;
x = x * x % mod;
e >>= 1;
}
return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int N = 2e6 + 10;
int n, m;
vector<pair<int, pair<int, int> > > to[N];
vector<pair<int, int> > hh[N], real[N][2];
int findid(int op, int x, int tim) {
return upper_bound((real[x][op]).begin(), (real[x][op]).end(),
make_pair(tim, INF)) -
real[x][op].begin() - 1;
}
int dis[N];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
qq;
struct Edge {
int x, y, l, r;
} e[N];
int cur[N][2];
pair<int, int> bak[N];
pair<int, int> fix(pair<int, int> now, int op) {
if ((now.first & 1) ^ op) now.first++;
return now;
}
void main() {
n = qread(), m = qread();
for (int i = (1), I = (m); i <= I; i++) {
int x = qread(), y = qread(), l = qread(), r = qread();
hh[x].push_back({l, r});
hh[y].push_back({l, r});
e[i] = {x, y, l, r};
}
int tim = 1;
for (int x = (1), I = (n); x <= I; x++)
if (((int)(hh[x]).size())) {
sort((hh[x]).begin(), (hh[x]).end());
for (int op = (0), I = (1); op <= I; op++) {
pair<int, int> now = fix(hh[x][0], op);
for (int t = (1), I = (((int)(hh[x]).size()) - 1); t <= I; t++) {
pair<int, int> h = fix(hh[x][t], op);
if (h.first >= h.second) continue;
if (now.first >= now.second) {
now = h;
continue;
}
if (h.first <= now.second)
chmax(now.second, h.second);
else
real[x][op].push_back(now), now = h;
}
if (now.first < now.second) real[x][op].push_back(now);
cur[x][op] = tim, tim += ((int)(real[x][op]).size());
for (int i = (cur[x][op]), I = (tim - 1); i <= I; i++) bak[i] = {x, op};
}
}
if (n == 1) {
write(0);
return;
}
if (!((int)(real[1][0]).size()) or real[1][0][0].first > 0) {
write(-1);
return;
}
for (int i = (1), I = (m); i <= I; i++) {
int x = e[i].x, y = e[i].y;
for (int op = (0), I = (1); op <= I; op++) {
pair<int, int> now = fix({e[i].l, e[i].r}, op);
if (now.first >= now.second) continue;
to[cur[x][op] + findid(op, x, now.first)].push_back({y, now}),
to[cur[y][op] + findid(op, y, now.first)].push_back({x, now});
}
}
memset(dis, 0x3f, sizeof dis);
dis[1] = 0;
qq.push({0, 1});
int ans = INF;
while (((int)(qq).size())) {
pair<int, int> now = qq.top();
qq.pop();
int rx = now.second, x = bak[rx].first, op = bak[rx].second;
if (now.first != dis[rx]) continue;
for (auto t : to[rx]) {
int y = t.first, l = t.second.first, r = t.second.second,
go = max(now.first, l);
if (go >= r) continue;
if (y == n) {
chmin(ans, go + 1);
continue;
}
int ry = cur[y][op ^ 1] + findid(op ^ 1, y, go + 1);
if (findid(op ^ 1, y, go + 1) >= 0 and dis[ry] > go + 1)
dis[ry] = go + 1, qq.push({go + 1, ry});
}
}
write(ans == INF ? -1 : ans);
}
}; // namespace mine
signed main() {
srand(time(0));
mine::main();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int oo = ~0u >> 2, mo = (int)1e9 + 7;
const int mn = 510, mm = mn * 2;
int x[mm];
int n, h, f;
double Ans(0), S;
int sgn(double x) {
if (fabs(x) <= eps) return 0;
if (x > -eps) return 1;
return -1;
}
double calc(double x1, double x2) {
double x3 = x1 * (f + h) / (f - h), x4 = x2 * (f + h) / (f - h);
if (sgn(x1 - x4) > 0 && sgn(x3 - x2) > 0) return (x4 + x2) * h;
if (sgn(x4 - x1) > 0 && sgn(x2 - x3) > 0) return (x1 + x3) * h;
if (sgn((x1 + x2) - (x3 + x4)) > 0) swap(x1, x4), swap(x2, x3);
double S = h * (x1 + x2);
double a = x4 - x1, b = x3 - x2;
if (sgn(a + b) > 0) {
double h1 = h * b / (a + b), h2 = h - h1;
double ST = h * (a + b), S1 = b * h1, S2 = a * h2;
S += (ST - S1 - S2) / 2.;
}
return S;
}
int main() {
cin >> n >> h >> f;
for (int i = (1); i <= (n); ++i) cin >> x[i + i - 1] >> x[i + i];
sort(x + 1, x + n * 2 + 1);
for (int i = (1); i <= (n); ++i) {
double a = x[i + i] - x[i + i - 1];
double b = a * (f + h) / (f - h);
S = (a + b) * h * 2, Ans += S;
}
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) {
S = calc(x[i + i], x[j + j]), Ans -= S;
S = calc(x[i + i - 1], x[j + j - 1]), Ans -= S;
S = calc(x[i + i], x[j + j - 1]), Ans += S;
S = calc(x[i + i - 1], x[j + j]), Ans += S;
}
cout << fixed << setprecision(10) << Ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long k;
vector<int> e[100010];
long long lower_limit = 0, upper_limit = 0;
int c[100010], t[100010], mson[100010], rt = 0;
void dfs1(int x, int fa) {
c[x] = 1;
mson[x] = 0;
for (int y : e[x])
if (y != fa) {
dfs1(y, x);
c[x] += c[y];
mson[x] = max(mson[x], c[y]);
lower_limit += c[y] % 2;
upper_limit += min(c[y], n - c[y]);
}
mson[x] = max(mson[x], n - c[x]);
if (mson[x] <= mson[rt]) rt = x;
}
void dfs2(int x, int fa) {
c[x] = 1;
for (int y : e[x])
if (y != fa) {
dfs2(y, x);
c[x] += c[y];
}
t[c[x]]++;
}
vector<int> d[100010], q, ans1, ans2;
void dfs3(int x, int fa) {
int sz = 1;
for (int y : e[x])
if (y != fa) dfs3(y, x), sz += c[y];
q.clear();
d[x].push_back(x);
q.push_back(x);
for (int y : e[x])
if (y != fa) q.push_back(y);
int mat = (sz - c[x]) / 2, st = 0, ed = q.size() - 1;
ans1.clear();
ans2.clear();
for (int i = 1; i <= mat; i++) {
while (!d[q[st]].size()) st++;
ans1.push_back(d[q[st]].back());
d[q[st]].pop_back();
while (!d[q[ed]].size()) ed--;
ans2.push_back(d[q[ed]].back());
d[q[ed]].pop_back();
}
for (int i = 0; i < mat; i++) printf("%d %d\n", ans1[i], ans2[mat - i - 1]);
for (int i = 1; i < q.size(); i++) {
if (d[x].size() < d[q[i]].size()) swap(d[x], d[q[i]]);
for (int j : d[q[i]]) d[x].push_back(j);
}
}
int main() {
scanf("%d %lld", &n, &k);
for (int i = 1, x, y; i < n; i++)
scanf("%d %d", &x, &y), e[x].push_back(y), e[y].push_back(x);
mson[0] = n + 1;
dfs1(1, 0);
if (k < lower_limit || k > upper_limit || k % 2 != upper_limit % 2) {
printf("NO");
return 0;
}
dfs2(rt, 0);
int p = n - 1;
for (; p > 1; p--) {
if (upper_limit - 2 * t[p] >= k) {
upper_limit -= 2 * t[p];
t[p - 2] += t[p];
} else
break;
}
for (int i = 1; i <= n; i++) c[i] = min(c[i], p - (p + c[i]) % 2);
c[rt] = 0;
for (int i = 1; i <= n; i++)
if (c[i] == p && upper_limit > k) c[i] -= 2, upper_limit -= 2;
printf("YES\n");
dfs3(rt, 0);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int N, A[222222];
int nextNumber[222222][30];
map<int, set<int> > m;
int getNext(int start, int n) {
set<int> &s = m[n];
set<int>::iterator it = s.lower_bound(start);
if (it == s.end()) return N;
return *it;
}
int main(int argc, char *argv[]) {
scanf("%d", &N);
for (int i = 0; i < (N); i++) scanf("%d", A + i);
for (int i = 0; i < (N); i++) m[A[i]].insert(i);
for (int i = 0; i < (30); i++) nextNumber[N][i] = N;
for (int i = (N - 1); i >= (0); i--) {
for (int bit = 0; bit < (30); bit++) {
if (A[i] & (1 << bit))
nextNumber[i][bit] = i;
else
nextNumber[i][bit] = nextNumber[i + 1][bit];
}
}
long long ans = 0;
for (int start = 0; start < (N); start++) {
set<int> candidates;
candidates.insert(N);
for (int bit = 0; bit < (30); bit++)
candidates.insert(nextNumber[start][bit]);
vector<int> c(candidates.begin(), candidates.end());
int n = 0;
for (int i = 0; i < (c.size() - 1); i++) {
n |= A[c[i]];
int tmp = min(c[i + 1], getNext(start, n)) - c[i];
ans += tmp;
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int inf = 2e9;
const long long linf = 2e18;
using namespace std;
const int maxn = 2e6 + 5;
char a[maxn];
int v[26];
int dfs(int l, int r, int now) {
if (l == r) return a[l] != now;
int numl = 0, numr = 0;
int mid = (l + r) >> 1;
memset(v, 0, sizeof(v));
for (int i = l; mid >= i; i++) {
v[a[i]]++;
}
numl = v[now];
memset(v, 0, sizeof(v));
for (int i = mid + 1; r >= i; i++) {
v[a[i]]++;
}
numr = v[now];
return min(dfs(l, mid, now + 1) + (r - l + 1) / 2 - numr,
dfs(mid + 1, r, now + 1) + (r - l + 1) / 2 - numl);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
scanf("%s", a + 1);
for (int i = 1; n >= i; i++) a[i] -= 'a';
printf("%d\n", dfs(1, n, 0));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const long long int MOD1 = 1e9 + 7;
const long long int MAX5 = 1e5;
const long long int MAX6 = 1e6;
const long long int MAX7 = 1e7;
const long long int MAX8 = 1e8;
const long long int MAX9 = 1e9;
const long long int MAX10 = 1e10;
const long long int MAXX = 1e18;
long long int po(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
res = res * x;
x = x * x;
y >>= 1;
}
return res;
}
long long int gcd(int a, int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(a % b, b);
}
int foo(int x, int n) {
if (x == 1) return n;
return x - 1;
}
void solve() {
int n;
cin >> n;
vector<int> a(n + 1), b(n + 1), c(n + 1), p(n + 1);
for (int ii = 0; ii < n; ii++) cin >> a[ii + 1];
for (int ii = 0; ii < n; ii++) cin >> b[ii + 1];
for (int ii = 0; ii < n; ii++) cin >> c[ii + 1];
p[1] = a[1];
for (int ii = 2; ii < n; ii++) {
if (a[ii] == p[foo(ii, n)]) {
p[ii] = b[ii];
} else
p[ii] = a[ii];
}
vector<int> z;
z.push_back(a[n]);
z.push_back(b[n]);
z.push_back(c[n]);
for (int i = 0; i < 3; i++) {
if (z[i] == p[1] || z[i] == p[n - 1]) {
z[i] = -1;
}
}
for (int ii = 0; ii < 3; ii++) {
if (z[ii] != -1) {
p[n] = z[ii];
}
}
for (int ii = 1; ii < n + 1; ii++) cout << p[ii] << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tttt;
cin >> tttt;
for (int TTTT = 1; TTTT <= tttt; TTTT++) {
solve();
cout << "\n";
;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long MOD = 1e9 + 7;
const long double eps = 1e-9;
const long double PI = acos(-1.0);
long long n;
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
signed main() {
n = read();
string str;
cin >> str;
long long ans = 0;
long long update = 1;
while (update) {
update = 0;
char maxC = 'A';
long long index = -1;
for (long long i = 0; i < n; i++) {
if ((i - 1 >= 0 && str[i - 1] - str[i] == -1) ||
(i + 1 < n && str[i + 1] - str[i] == -1)) {
if (maxC < str[i]) {
maxC = str[i];
index = i;
update = 1;
}
}
}
if (update) {
string temp = str.substr(0, index);
if (index + 1 < n) temp += str.substr(index + 1);
str = temp;
ans++;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int64_t n, m;
deque<int64_t> d[300001];
int64_t p[300001];
bool mark[300001];
int64_t ans;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int64_t i = 1; i <= n; i++) {
int64_t x;
cin >> x;
p[x] = i;
}
for (int64_t i = 1; i <= m; i++) {
int64_t x, y;
cin >> x >> y;
d[p[x]].push_back(p[y]);
}
mark[n] = true;
for (int64_t i = n - 1; i >= 1; i--) {
int64_t c = 0;
for (int64_t j = 0; j < d[i].size(); j++) {
if (mark[d[i][j]]) c++;
}
if (c + ans < n - i)
mark[i] = true;
else
ans++;
}
cout << ans;
return 0;
}
| 5 |
// Awwawa! Dis cold yis ratten buy tEMMIE!
#include <bits/stdc++.h>
#define ll long long
#define maxn 1000005 /*rem*/
#define mod 998244353
#define db double
#define vi vector<int>
#define pb push_back
#define mp make_pair
#define pi pair<int, int>
#define fi first
#define se second
template <typename T> bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T> bool chkmin(T &x, T y) {
return x > y ? x = y, true : false;
}
using namespace std;
ll ksm(ll a, ll b) {
if (!b)
return 1;
ll ns = ksm(a, b >> 1);
ns = ns * ns % mod;
if (b & 1)
ns = ns * a % mod;
return ns;
}
const int md = 998244353;
inline void add(int &x, int y) {
x += y;
if (x >= md) {
x -= md;
}
}
inline void sub(int &x, int y) {
x -= y;
if (x < 0) {
x += md;
}
}
inline int mul(int x, int y) { return (long long)x * y % md; }
inline int power(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = mul(x, x)) {
if (y & 1) {
res = mul(res, x);
}
}
return res;
}
inline int inv(int a) {
a %= md;
if (a < 0) {
a += md;
}
int b = md, u = 0, v = 1;
while (a) {
int t = b / a;
b -= t * a;
swap(a, b);
u -= t * v;
swap(u, v);
}
if (u < 0) {
u += md;
}
return u;
}
namespace ntt {
int base = 1, root = -1, max_base = -1;
vector<int> rev = {0, 1}, roots = {0, 1};
void init() {
int temp = md - 1;
max_base = 0;
while (temp % 2 == 0) {
temp >>= 1;
++max_base;
}
root = 2;
while (true) {
if (power(root, 1 << max_base) == 1 &&
power(root, 1 << max_base - 1) != 1) {
break;
}
++root;
}
}
void ensure_base(int nbase) {
if (max_base == -1) {
init();
}
if (nbase <= base) {
return;
}
assert(nbase <= max_base);
rev.resize(1 << nbase);
for (int i = 0; i < 1 << nbase; ++i) {
rev[i] = rev[i >> 1] >> 1 | (i & 1) << nbase - 1;
}
roots.resize(1 << nbase);
while (base < nbase) {
int z = power(root, 1 << max_base - 1 - base);
for (int i = 1 << base - 1; i < 1 << base; ++i) {
roots[i << 1] = roots[i];
roots[i << 1 | 1] = mul(roots[i], z);
}
++base;
}
}
void dft(vector<int> &a) {
int n = a.size(), zeros = __builtin_ctz(n);
ensure_base(zeros);
int shift = base - zeros;
for (int i = 0; i < n; ++i) {
if (i<rev[i]>> shift) {
swap(a[i], a[rev[i] >> shift]);
}
}
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += i << 1) {
for (int k = 0; k < i; ++k) {
int x = a[j + k], y = mul(a[j + k + i], roots[i + k]);
a[j + k] = (x + y) % md;
a[j + k + i] = (x + md - y) % md;
}
}
}
}
vector<int> multiply(vector<int> a, vector<int> b) {
int need = a.size() + b.size() - 1, nbase = 0;
while (1 << nbase < need) {
++nbase;
}
ensure_base(nbase);
int sz = 1 << nbase;
a.resize(sz);
b.resize(sz);
bool equal = a == b;
dft(a);
if (equal) {
b = a;
} else {
dft(b);
}
int inv_sz = inv(sz);
for (int i = 0; i < sz; ++i) {
a[i] = mul(mul(a[i], b[i]), inv_sz);
}
reverse(a.begin() + 1, a.end());
dft(a);
a.resize(need);
return a;
}
vector<int> inverse(vector<int> a) {
int n = a.size(), m = n + 1 >> 1;
if (n == 1) {
return vector<int>(1, inv(a[0]));
} else {
vector<int> b = inverse(vector<int>(a.begin(), a.begin() + m));
int need = n << 1, nbase = 0;
while (1 << nbase < need) {
++nbase;
}
ensure_base(nbase);
int sz = 1 << nbase;
a.resize(sz);
b.resize(sz);
dft(a);
dft(b);
int inv_sz = inv(sz);
for (int i = 0; i < sz; ++i) {
a[i] = mul(mul(md + 2 - mul(a[i], b[i]), b[i]), inv_sz);
}
reverse(a.begin() + 1, a.end());
dft(a);
a.resize(n);
return a;
}
}
} // namespace ntt
using ntt::inverse;
using ntt::multiply;
vector<int> &operator+=(vector<int> &a, const vector<int> &b) {
if (a.size() < b.size()) {
a.resize(b.size());
}
for (int i = 0; i < b.size(); ++i) {
add(a[i], b[i]);
}
return a;
}
vector<int> operator+(const vector<int> &a, const vector<int> &b) {
vector<int> c = a;
return c += b;
}
vector<int> &operator-=(vector<int> &a, const vector<int> &b) {
if (a.size() < b.size()) {
a.resize(b.size());
}
for (int i = 0; i < b.size(); ++i) {
sub(a[i], b[i]);
}
return a;
}
vector<int> operator-(const vector<int> &a, const vector<int> &b) {
vector<int> c = a;
return c -= b;
}
vector<int> &operator*=(vector<int> &a, const vector<int> &b) {
if (min(a.size(), b.size()) < 128) {
vector<int> c = a;
a.assign(a.size() + b.size() - 1, 0);
for (int i = 0; i < c.size(); ++i) {
for (int j = 0; j < b.size(); ++j) {
add(a[i + j], mul(c[i], b[j]));
}
}
} else {
a = multiply(a, b);
}
return a;
}
vector<int> operator*(const vector<int> &a, const vector<int> &b) {
vector<int> c = a;
return c *= b;
}
int n, k;
ll f[maxn], g[maxn];
int main() {
scanf("%d%d", &n, &k);
f[0] = 1;
g[0] = 1;
for (int i = 1; i <= k; i++) {
f[i] = f[i - 1] * i % mod;
g[i] = ksm(f[i], mod - 2);
}
vi f1(k + 1, 0), g1(k + 1, 0);
for (int i = 0; i <= k; i++) {
f1[i] = ksm(mod - 1, i) * g[i] % mod;
g1[i] = ksm(i, k) * g[i] % mod;
}
vi s = f1 * g1;
ll r = 1, ans = 0;
for (int i = 0; i <= k && i <= n; i++) {
ans = (ans + s[i] * ksm(n + 1, n - i) % mod * r) % mod;
r = r * (n - i) % mod;
}
printf("%lld\n", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t, a, b, c, A, B, C, aux;
int ans, res;
cin >> t;
while (t--) {
ans = 1e9;
cin >> a >> b >> c;
for (int i = 1; i < 2 * a; i++) {
for (int j = i; j <= 2 * b; j += i) {
for (int k = 0; k < int(2); k++) {
aux = (c / j) * j + k * j;
res = abs(a - i) + abs(b - j) + abs(c - aux);
if (res < ans) {
ans = res;
A = i;
B = j;
C = aux;
}
}
}
}
cout << ans << "\n" << A << " " << B << " " << C << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 500005;
vector<pair<long long, long long> > v[N];
long long a[N], n, cnt[N], dp[N], s[N], num[N];
void change(pair<long long, long long> &x, long long k, long long p) {
if (x.first == -1) {
x.first = k;
return;
}
if (x.second == -1) {
x.second = k;
if (x.second % p > x.first % p) swap(x.second, x.first);
return;
}
if (x.second % p < k % p) x.second = k;
if (x.second % p > x.first % p) swap(x.second, x.first);
}
long long check(long long x, long long y) {
long long delta = 1e18, p = x / y + 1;
if (v[y][p].first >= x && v[y][p].second >= x)
delta = min(delta, v[y][p].first / y + v[y][p].second / y -
(v[y][p].first - x) / y - (v[y][p].second - x) / y);
if (v[y].size() > p + 1 && v[y][p + 1].first >= x && v[y][p + 1].second >= x)
delta = min(delta, v[y][p + 1].first / y + v[y][p + 1].second / y -
(v[y][p + 1].first - x) / y -
(v[y][p + 1].second - x) / y);
if (v[y].size() > p + 1 && v[y][p + 1].first >= x && v[y][p].first >= x &&
v[y][p].first != v[y][p + 1].first)
delta =
min(delta, v[y][p + 1].first / y + v[y][p].first / y -
(v[y][p + 1].first - x) / y - (v[y][p].first - x) / y);
p = 2 * x / y + 1;
if (v[y].size() > p && v[y][p].first >= 2 * x)
delta = min(delta, v[y][p].first / y - (v[y][p].first - 2 * x) / y);
if (v[y].size() > p + 1 && v[y][p + 1].first >= 2 * x)
delta = min(delta, v[y][p + 1].first / y - (v[y][p + 1].first - 2 * x) / y);
return s[y] - delta >= x;
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]), cnt[a[i]]++;
for (long long i = 1; i < N; i++) {
num[i] = num[i - 1] + cnt[i];
if (cnt[i])
dp[i] = i;
else
dp[i] = dp[i - 1];
}
for (long long i = 2; i < N; i++) {
v[i].resize((N - 1) / i + 2);
for (long long j = (N - 1) / i + 1; j; j--) {
if (j == (N - 1) / i + 1)
v[i][j] = make_pair(-1, -1);
else
v[i][j] = v[i][j + 1];
long long k = min(N - 1, j * i - 1);
s[i] += (j - 1) * (num[k] - num[max(0ll, (j - 1) * i - 1)]);
if (dp[k] < (j - 1) * i || dp[k] < 1) continue;
change(v[i][j], dp[k], i);
k = dp[k];
if (cnt[k] == 1) k--;
if (dp[k] < (j - 1) * i || dp[k] < 1) continue;
change(v[i][j], dp[k], i);
}
}
long long y = 2;
while (check(2, y)) y++;
y--;
long long ans = 2 * y;
for (long long x = 3; y >= 2; x++) {
while (y >= 2 && !check(x, y)) y--;
if (y < 2) break;
ans = max(ans, x * y);
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000001;
int spf[MAXN];
void sieve() {
spf[1] = 1;
for (int i = 2; i < MAXN; i++) spf[i] = i;
for (int i = 4; i < MAXN; i += 2) spf[i] = 2;
for (int i = 3; i * i < MAXN; i++) {
if (spf[i] == i) {
for (int j = i * i; j < MAXN; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
int n;
cin >> n;
if (n < 6) {
cout << -1 << endl;
for (int i = 2; i <= n; i++) {
cout << 1 << " " << i << endl;
}
} else {
cout << 1 << " " << 2 << endl;
cout << 1 << " " << 3 << endl;
cout << 1 << " " << 4 << endl;
for (int i = 5; i <= n; i++) {
cout << 2 << " " << i << endl;
}
for (int i = 2; i <= n; i++) {
cout << 1 << " " << i << endl;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:268435456")
int m[60][60];
int w[60][60];
int a[60], i, j, k, n;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
m[0][i] = a[i];
}
for (i = 0; i < n; i++) {
for (j = 0; j < i; j++) w[i][j] = 999999;
for (j = i; j < n; j++) cin >> w[i][j];
for (j = n; j < 60; j++) w[i][j] = 999999;
}
w[n][n - 1] = 0;
for (k = 0; k < 300000; k++) {
memset(m, 0, sizeof(m));
for (i = 0; i < n; i++) {
m[0][i] = a[i];
}
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
if (m[i][j] >= w[i][j]) {
if (k == 0) {
if ((j > i && m[i + 1][j] + m[i][j] >= w[i + 1][j]) || j == n - 1)
m[i + 1][j] += m[i][j];
else
m[i + 1][j + 1] += m[i][j];
} else {
if ((rand() % 2 == 0 && j > i) || j == n - 1)
m[i + 1][j] += m[i][j];
else
m[i + 1][j + 1] += m[i][j];
}
}
}
}
if (m[n][n - 1] > 0 || m[n][n - 2] > 0 || m[n][n] > 0) {
cout << "Cerealguy";
return 0;
}
}
if (m[n][n - 1] > 0 || m[n][n - 2] > 0 || m[n][n] > 0)
cout << "Cerealguy";
else
cout << "Fat Rat";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, m, k;
int p[N], s[N], mx[N];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%d", p + i);
for (int i = 0; i < n; i++) {
scanf("%d", s + i);
mx[s[i]] = max(mx[s[i]], p[i]);
}
int id, ans = 0;
for (int i = 0; i < k; i++) {
scanf("%d", &id);
ans += mx[s[id - 1]] != p[id - 1];
}
printf("%d", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int oo = 1e9, bpr = 1e9 + 7, N = 1050;
long double p[N][N];
long double sum[N];
int n, m, a[N];
long double sum1[N], sum2[N];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
p[i][j] = a[i] > a[j];
}
}
while (m--) {
int a, b;
cin >> a >> b;
p[a][b] = p[b][a] = 0.5;
for (int j = 1; j <= n; ++j) {
if (j == a || j == b) continue;
long double val = 0.5 * (p[a][j] + p[b][j]);
p[a][j] = p[b][j] = val;
p[j][a] = p[j][b] = (1 - val);
}
}
long double ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) ans += p[i][j];
cout << fixed << setprecision(6);
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ciur[100005], p[100000], cmmdc[5005];
unordered_map<int, int> bad;
int a[5005], b[5005];
inline int gcd(int a, int b) {
int r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
for (int i = 2; i <= 100000; ++i) {
if (ciur[i]) continue;
p[++p[0]] = i;
for (int j = i + i; j <= 100000; j += i) {
ciur[j] = 1;
}
}
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; ++i) {
scanf("%d", &b[i]);
bad[b[i]] = 1;
}
for (int i = 1; i <= n; ++i) {
cmmdc[i] = gcd(cmmdc[i - 1], a[i]);
}
int sol = 0;
for (int i = 1; i <= n; ++i) {
int x = a[i];
for (int j = 1; j <= p[0] && p[j] * p[j] <= x; ++j) {
int add = bad[p[j]] ? -1 : 1;
while (x % p[j] == 0) {
sol += add;
x /= p[j];
}
}
if (x > 1) {
sol += bad[x] ? -1 : 1;
}
}
int divide = 1;
for (int i = n; i >= 1; --i) {
int aux_cmmdc = cmmdc[i] / divide, now = 0, acum = cmmdc[i] / divide;
for (int j = 1; j <= p[0] && p[j] * p[j] <= aux_cmmdc; ++j) {
int add = bad[p[j]] ? -1 : 1;
while (aux_cmmdc % p[j] == 0) {
now += add;
aux_cmmdc /= p[j];
}
}
if (aux_cmmdc > 1) {
now += bad[aux_cmmdc] ? -1 : 1;
}
if (now < 0) {
sol -= now * i;
divide *= acum;
}
}
printf("%d\n", sol);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 7;
int n, k;
struct trie {
int Next[N][26];
int h;
trie() {
memset(Next, -1, sizeof(Next));
h = 1;
}
void insert(string s) {
int cur = 0;
for (int i = 0; i < s.size(); i++) {
int id = s[i] - 'a';
if (Next[cur][id] == -1) {
Next[cur][id] = h++;
}
cur = Next[cur][id];
}
}
};
trie myTrie;
map<int, int> memo;
int canWin(int cur) {
if (memo.find(cur) != memo.end()) {
return memo[cur];
}
int win = false;
for (int i = 0; i < 26; i++) {
if (myTrie.Next[cur][i] != -1) {
int v = myTrie.Next[cur][i];
if (!canWin(v)) {
win = true;
break;
}
}
}
memo[cur] = win;
return memo[cur];
}
int canLose(int cur) {
if (cur >= myTrie.h) return true;
if (memo.find(cur) != memo.end()) {
return memo[cur];
}
int lose = false;
int canMove = false;
for (int i = 0; i < 26; i++) {
if (myTrie.Next[cur][i] != -1) {
canMove = true;
int v = myTrie.Next[cur][i];
if (!canLose(v)) {
lose = true;
break;
}
}
}
if (!canMove) lose = true;
memo[cur] = lose;
return memo[cur];
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
myTrie.insert(s);
}
memo.clear();
int win = canWin(0);
memo.clear();
int lose = canLose(0);
if (!win) {
cout << "Second" << endl;
} else {
if (lose)
cout << "First" << endl;
else {
if (k % 2 == 0) {
cout << "Second" << endl;
} else {
cout << "First" << endl;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t) {
t--;
string s;
cin >> s;
string ans = "";
ans += s[0];
for (int i = 1; i < (s.size() - 1); i += 2) ans += s[i];
ans += s[(int)s.size() - 1];
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "{" << p.first << "," << p.second << "}";
return os;
}
const int N = 3e5 + 5;
const int oo = 1e9 + 7;
int qsum[55][N];
int dp[55][N];
int pre[55][N];
int suf[55][N];
int n, m, k;
inline int sum(int i, int j, int k) {
return qsum[i][min(j + k - 1, m)] - qsum[i][j - 1] +
qsum[i + 1][min(j + k - 1, m)] - qsum[i + 1][j - 1];
}
inline int intersect(int i, int x, int y, int m, int k) {
return qsum[i][min({x + k - 1, y + k - 1, m})] - qsum[i][max(x - 1, y - 1)];
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> qsum[i][j];
qsum[i][j] += qsum[i][j - 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int now = sum(i, j, k);
dp[i][j] = now;
if (j - k >= 1) {
dp[i][j] = max(dp[i][j], pre[i - 1][j - k] + now);
}
if (j + k <= m) {
dp[i][j] = max(dp[i][j], suf[i - 1][j + k] + now);
}
for (int x = max(j - k + 1, 1); x <= min(j + k - 1, m); x++) {
dp[i][j] = max(dp[i][j], now + dp[i - 1][x] - intersect(i, x, j, m, k));
}
pre[i][j] = max(pre[i][j - 1], dp[i][j]);
}
for (int j = m; j >= 1; j--) suf[i][j] = max(suf[i][j + 1], dp[i][j]);
}
cout << pre[n][m] << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int v[25][25], dp[(1 << 21)];
string s[25];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> v[i][j];
}
}
for (int i = 1; i <= (1 << n) - 1; i++) {
dp[i] = 50000000;
}
for (int i = 0; i <= (1 << n) - 1; i++) {
int last = 0;
for (int j = 0; j < n; j++) {
if (!(i & (1 << j))) {
last = j;
break;
}
}
for (int j = 0; j < m; j++) {
dp[i + (1 << last)] = min(dp[i + (1 << last)], dp[i] + v[last][j]);
int poz = i, sum = 0, ma = 0;
for (int k = 0; k < n; k++) {
if (s[last][j] == s[k][j]) {
poz |= 1 << k;
sum += v[k][j];
ma = max(ma, v[k][j]);
}
}
dp[poz] = min(dp[poz], dp[i] + sum - ma);
}
}
cout << dp[(1 << n) - 1];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next, tp;
} e[1010000];
int n, m, h[1010100], tot;
int dis[1010000][2], f[1010000], vis[1010000];
inline void add(int from, int to, int tp) {
e[++tot].next = h[from];
h[from] = tot;
e[tot].to = to;
e[tot].tp = tp;
}
queue<int> q;
inline void Solve(int S) {
memset(f, 0x3f, sizeof(f));
memset(dis, 0x3f, sizeof(dis));
dis[S][0] = dis[S][1] = f[S] = 0;
vis[S] = 1;
q.push(S);
while (!q.empty()) {
int u = q.front();
q.pop();
for (register int i = h[u]; i; i = e[i].next) {
int to = e[i].to, tp = e[i].tp;
if (dis[to][tp] > 1e8) {
dis[to][tp] = f[u] + 1;
f[to] = max(dis[to][0], dis[to][1]);
if (f[to] < 1e8 && !vis[to]) vis[to] = 1, q.push(to);
}
}
}
}
int main() {
cin >> n >> m;
for (register int i = 1; i <= m; ++i) {
int u, v, tp;
cin >> u >> v >> tp;
add(v, u, tp);
}
Solve(n);
if (f[1] < 1e8)
cout << f[1] << endl;
else
cout << -1 << endl;
for (register int i = 1; i <= n; ++i)
cout << ((dis[i][0] < dis[i][1]) ? 1 : 0);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 5, M = 1e6 + 5, inf = 0x3f3f3f3f;
int n, a[N];
template <class t>
void rd(t &x) {
x = 0;
int w = 0;
char ch = 0;
while (!isdigit(ch)) w |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = w ? -x : x;
}
int cnt = 0, fr[M], to[M];
void add(int x, int y) { fr[++cnt] = x, to[cnt] = y; }
int main() {
rd(n);
for (int i = 1; i <= n; ++i) rd(a[i]);
int l = 1, r = n;
while (l <= r) {
for (int i = a[l - 1] + 1; i <= a[l]; ++i)
for (int j = i + 1; j <= a[r] + 1; ++j) add(i, j);
++l, --r;
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; ++i) printf("%d %d\n", fr[i], to[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, s;
int V[10005], Parent[10005];
map<int, int> Map;
vector<pair<int, int>> G[10005];
vector<int> Pos[10005];
int D[10005];
priority_queue<pair<int, int>> Q;
int getDist(int i, int j) {
if (j < i) swap(i, j);
return min(j - i, i + n - j);
}
char getSemn(int i, int j) {
int d = getDist(i, j);
if (j == i + d || j == i + d - n) return '+';
return '-';
}
void Dijkstra(int start) {
for (int i = 1; i <= 5000; i++) D[i] = 1e9;
D[start] = 0;
Q.push({0, start});
while (!Q.empty()) {
auto top = Q.top();
Q.pop();
if (-top.first != D[top.second]) continue;
int node = top.second;
for (auto e : G[node]) {
int vec = e.first, cost = e.second;
if (D[vec] > D[node] + cost) {
D[vec] = D[node] + cost;
Parent[vec] = node;
Q.push({-D[vec], vec});
}
}
}
}
void afis_drum(int node) {
if (Parent[node] == 0) {
cout << getSemn(s, node / 2) << getDist(s, node / 2) << '\n';
} else {
afis_drum(Parent[node]);
int p = Parent[node], q = node;
if (p % 2 == 1 && q % 2 == 0) {
p /= 2;
q /= 2;
cout << getSemn(p, q) << getDist(p, q) << '\n';
} else {
p /= 2;
q /= 2;
int d = D[node] - D[Parent[node]];
auto &W = Pos[V[p]];
int it;
for (it = 0; W[it] != p; it++)
;
char sign;
int pas;
if (q == p + d || q == p + d - n)
sign = '+', pas = +1;
else
sign = '-', pas = -1;
if (W.size() == 1) return;
int last = it, it2 = it + pas;
if (it2 >= int(W.size())) it2 -= int(W.size());
if (it2 < 0) it2 += int(W.size());
while (it != it2) {
cout << sign << getDist(W[last], W[it2]) << '\n';
last = it2;
it2 += pas;
if (it2 >= int(W.size())) it2 -= int(W.size());
if (it2 < 0) it2 += int(W.size());
}
while (it2 != it)
;
}
}
}
void addEdge(int s, int d, int c) { G[s].push_back({d, c}); }
int main() {
cin >> n >> s;
for (int i = 1; i <= n; i++) {
cin >> V[i];
Map[V[i]] = 1;
}
int vals = 0;
for (auto &x : Map) x.second = ++vals;
for (int i = 1; i <= n; i++) V[i] = Map[V[i]];
for (int i = 1; i <= n; i++) {
Pos[V[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (V[j] != V[i] + 1) continue;
int d = getDist(i, j);
addEdge(i * 2 + 1, j * 2, d);
}
}
for (int i = 1; i <= vals; i++) {
if (Pos[i].size() == 1)
addEdge(Pos[i].back() * 2, Pos[i].back() * 2 + 1, 0);
else {
for (int j = 1; j < Pos[i].size(); j++) {
int pl = Pos[i][j - 1], pr = Pos[i][j];
addEdge(pl * 2, pr * 2 + 1, n - (pr - pl));
addEdge(pr * 2, pl * 2 + 1, n - (pr - pl));
}
int pb = Pos[i][0], pe = Pos[i].back();
addEdge(pb * 2, pe * 2 + 1, pe - pb);
addEdge(pe * 2, pb * 2 + 1, pe - pb);
}
}
for (int i = 1; i <= n; i++) {
if (V[i] == 1) {
addEdge(0, i * 2, getDist(s, i));
}
}
Parent[0] = -1;
Dijkstra(0);
int mind = 1e9;
int choose = -1;
for (int i = 1; i <= n; i++) {
if (V[i] == vals && D[i * 2 + 1] < mind) {
mind = D[i * 2 + 1];
choose = i;
}
}
cout << mind << '\n';
afis_drum(choose * 2 + 1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
int n, k;
struct Edge {
int to, next;
} edge[2 * N];
int head[N], cnt;
void add_edge(int u, int v) {
cnt++;
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt;
return;
}
int root = 1, in[N];
int dis[N];
int ans = 1;
int dfs(int u, int father) {
if (in[u] == 1) return 0;
vector<int> s;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == father) continue;
s.push_back(dfs(v, u) + 1);
}
sort(s.begin(), s.end());
for (int i = s.size() - 1; i > 0; i--)
if (s[i] + s[i - 1] > k)
ans++;
else
return s[i];
return s[0];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y);
add_edge(y, x);
in[x]++, in[y]++;
}
while (in[root] == 1) root++;
dfs(root, 0);
printf("%d", ans);
return 0;
}
| 8 |
#include "bits/stdc++.h"
#define pb(x) push_back(x)
#define fil(x, y) memset(x, y, sizeof(x))
#define ll long long
#define ff first
#define ss second
#define pii pair<int,int>
#define pll pair<long long,long long>
#define mp(x, y) make_pair(x,y)
#define inf INT_MAX
#define infll LLONG_MAX
#define M 1000000007
#define N 200007
#define sm 0.0000007
#define ins insert
#define ers erase
#define cnt count
#define fastio ios_base::sync_with_stdio(0);cin.tie(0)
using namespace std;
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fastio;
int t, o = 0;
cin >> t;
while(t--)
{
int n;
cin >> n;
string s;
cin >> s;
map <char, int> amio;
bool g = 0;
for(int i = 1;i < n;i++)
{
if(s[i] != s[i-1]){
if(amio[s[i-1]] > 0)
{
g = 1;
break;
}
amio[s[i-1]]++;
}
}
if(amio[s[n-1]] > 0)
g = 1;
if(g == 0)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[300005];
int p[300005], I, D, diam[300005], n, m, q, N, x, tp, a, b, up, vp;
bool first[300005];
void dfs(int x, int par, int d) {
if (D < d) D = d, I = x;
for (int j = 0; j < v[x].size(); j++) {
if (v[x][j] == par) continue;
dfs(v[x][j], x, d + 1);
}
}
int P(int x) {
if (p[x] == x) return x;
return p[x] = P(p[x]);
}
void dsu(int u, int v) {
up = P(u), vp = P(v);
if (up == vp) return;
if (up < vp) swap(up, vp);
p[up] = vp;
diam[vp] =
max(max(diam[up], diam[vp]), (diam[up] + 1) / 2 + (diam[vp] + 1) / 2 + 1);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
dsu(a, b);
v[a].push_back(b), v[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (first[p[i]]) continue;
first[p[i]] = 1;
++N;
I = 0, D = 0;
dfs(i, i, 0);
D = 0;
dfs(I, I, 0);
diam[i] = D;
}
while (q--) {
cin >> tp;
if (tp == 1) {
cin >> x;
cout << diam[P(x)] << "\n";
} else {
cin >> a >> b;
dsu(a, b);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
static const int MXN = 20000 + 2;
const int mod = 998244353;
long long dis[MXN];
struct CostFlow {
static const long long INF = 102938475610293847LL;
struct Edge {
int v, r;
long long f, c;
Edge(int a, int b, int _c, int d) : v(a), r(b), f(_c), c(d) {}
};
int n, s, t, prv[MXN], prvL[MXN], inq[MXN];
long long fl, cost;
vector<Edge> E[MXN];
void init(int _n, int _s, int _t) {
n = _n;
s = _s;
t = _t;
for (int i = 0; i < n; i++) E[i].clear();
fl = cost = 0;
}
void add_edge(int u, int v, long long f, long long c) {
E[u].push_back(Edge(v, E[v].size(), f, c));
E[v].push_back(Edge(u, E[u].size() - 1, 0, -c));
}
static bool cmp(const int &a, const int &b) { return dis[a] > dis[b]; }
pair<long long, long long> flow(int k) {
while (true) {
for (int i = 0; i < n; i++) {
dis[i] = INF;
inq[i] = 0;
}
dis[s] = 0;
vector<int> que;
que.push_back(s);
while (!que.empty()) {
int u = que.back();
que.pop_back();
inq[u] = 0;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i].v;
long long w = E[u][i].c;
if (E[u][i].f > 0 && dis[v] > dis[u] + w) {
prv[v] = u;
prvL[v] = i;
dis[v] = dis[u] + w;
if (!inq[v]) {
inq[v] = 1;
que.push_back(v);
}
}
}
if (u == s) {
sort(que.begin(), que.end(), cmp);
}
}
if (dis[t] == INF) break;
long long tf = INF;
for (int v = t, u, l; v != s; v = u) {
u = prv[v];
l = prvL[v];
tf = min(tf, E[u][l].f);
}
for (int v = t, u, l; v != s; v = u) {
u = prv[v];
l = prvL[v];
E[u][l].f -= tf;
E[v][E[u][l].r].f += tf;
}
if (dis[t] > 0) break;
cost += tf * dis[t];
fl += tf;
if (fl == k) break;
}
return {fl, cost};
}
} flow;
int val[1 << 20];
int Index;
void solve() {
int n, k;
scanf("%d %d", &n, &k);
int a[1 << 20];
for (int i = 0; i < (1 << n); i++) scanf("%d", &a[i]);
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
pq;
for (int i = 0; i < (1 << n); i++) {
if (__builtin_popcount(i) & 1) {
for (int j = 0; j < n; j++) {
pq.push(make_pair(a[i] + a[i ^ (1 << j)], make_pair(i, i ^ (1 << j))));
}
while (pq.size() > 2 * n * k) pq.pop();
}
}
vector<pair<int, pair<int, int>>> v;
while (!pq.empty()) {
v.push_back(pq.top());
pq.pop();
}
for (int i = 0; i < n * k * 2 && i < v.size(); i++) {
int a = v[i].second.first, b = v[i].second.second;
if (!val[a]) {
val[a] = ++Index;
}
if (!val[b]) {
val[b] = ++Index;
}
}
flow.init(Index + 2, 0, Index + 1);
for (int i = 0; i < (1 << n); i++) {
if (val[i]) {
if (__builtin_popcount(i) & 1)
flow.add_edge(0, val[i], 1, -a[i]);
else
flow.add_edge(val[i], Index + 1, 1, -a[i]);
}
}
for (int i = 0; i < n * k * 2 && i < v.size(); i++) {
flow.add_edge(val[v[i].second.first], val[v[i].second.second], 1, 0);
}
printf("%lld\n", -flow.flow(k).second);
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int c[300005];
vector<int> v;
int n, m;
bool check(int mi) {
vector<int> g;
for (int i = 0; i < v.size() + 3; i++) c[i] = 0;
g.clear();
g.push_back(v[0]);
if (g[0] + mi >= m) g[0] = 0;
int j = 0;
for (int i = 1; i < v.size(); i++) {
g.push_back(v[i]);
if ((g[i] + mi) % m >= g[i - 1] && g[i] + mi >= m) g[i] = g[i - 1];
if (g[i - 1] > g[i]) {
if (g[i - 1] - g[i] > mi)
return false;
else
g[i] = g[i - 1];
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
int i;
for (i = 1; i <= n; i++) cin >> a[i];
v.clear();
v.push_back(a[1]);
for (i = 2; i <= n; i++)
if (a[i] != a[i - 1]) v.push_back(a[i]);
int l = 0, r = m, mi, ans;
while (l <= r) {
mi = (l + r) / 2;
if (check(mi))
r = mi - 1, ans = mi;
else
l = mi + 1;
}
if (n == 1) {
cout << 0;
return 0;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> s;
vector<int> c;
vector<pair<int, int> > bl;
vector<pair<int, int> > wt;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int cc, w;
cin >> cc >> w;
c.push_back(cc);
s.push_back(w);
};
for (int i = 0; i < n; ++i) {
if (c[i] == 0) {
bl.push_back(make_pair(-s[i], i + 1));
} else {
wt.push_back(make_pair(-s[i], i + 1));
}
}
sort(bl.begin(), bl.end());
sort(wt.begin(), wt.end());
vector<pair<int, int> >::iterator blc = bl.begin();
vector<pair<int, int> >::iterator wtc = wt.begin();
while (blc != bl.end() && wtc != wt.end()) {
if (blc->first < wtc->first && wt.end() - wtc > 1 || bl.end() - blc == 1) {
cout << blc->second << ' ' << wtc->second << ' ' << -wtc->first << endl;
blc->first -= wtc->first;
++wtc;
} else {
cout << blc->second << ' ' << wtc->second << ' ' << -blc->first << endl;
wtc->first -= blc->first;
++blc;
}
}
return 0;
}
| 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);
int n;
cin >> n;
vector<int> a(n);
set<int> cnt;
for (int i = 0; i < (int)(n); i++) cin >> a[i], cnt.insert(a[i]);
vector<int> ans = {a[0]};
for (int i = 0; i < (int)(n); i++) {
if (ans.size() == 3) break;
for (int j = 0; j < (int)(31); j++) {
if (ans.size() == 1) {
if ((INT_MAX - (1 << j) >= a[i]) &&
cnt.find(a[i] + (1 << j)) != cnt.end()) {
ans = {a[i], a[i] + (1 << j)};
}
if ((INT_MIN + (1 << j) <= a[i]) &&
cnt.find(a[i] - (1 << j)) != cnt.end()) {
ans = {a[i], a[i] - (1 << j)};
}
}
if (((INT_MAX - (1 << j) >= a[i]) && (INT_MIN + (1 << j) <= a[i])) &&
cnt.find(a[i] - (1 << j)) != cnt.end() &&
cnt.find(a[i] + (1 << j)) != cnt.end()) {
if (ans.size() == 2) {
ans = {a[i], a[i] - (1 << j), a[i] + (1 << j)};
}
}
}
}
cout << ans.size() << endl;
for (int x : ans) cout << x << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void scan(long long &n) { scanf("%lld", &n); }
void scan(long long &n, long long &m) { scanf("%lld%lld", &n, &m); }
void scan(vector<long long> &v) {
long long n = v.size();
for (long long i = 0; i < n; i++) scanf("%lld", &v[i]);
}
void solve() {
long long n, k, i;
cin >> n >> k;
vector<long long> v(n);
for (i = 0; i < n; i++) cin >> v[i];
vector<long long> tmp(n), a, b;
long long mm = 2;
while (mm--) {
long long mx = LLONG_MIN;
for (i = 0; i < n; i++) mx = max(mx, v[i]);
for (i = 0; i < n; i++) {
tmp[i] = mx - v[i];
v[i] = tmp[i];
}
if (mm == 1)
a = tmp;
else
b = tmp;
}
if (k % 2)
for (auto it : a) cout << it << ' ';
else
for (auto it : b) cout << it << ' ';
cout << endl;
}
int main() {
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
vector<int> elem;
int cnt = 0;
elem.resize(n, 0);
for (int i = 0; i < n; i++) cin >> elem[i];
for (int i = 1; i < n; i++) {
if (elem[i] - elem[i - 1] <= 0) {
int m = (elem[i - 1] - elem[i]) / d + 1;
elem[i] += m * d;
cnt += m;
}
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = 1000000000000000000;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<pair<long long, long long> > p(n);
for (auto& x : p) cin >> x.first >> x.second;
sort(p.begin(), p.end());
pair<long long, long long> now = {0, 0};
bool f = 1;
string ans = "";
for (int i = 0; i < n; i++) {
if (p[i].first >= now.first && p[i].second >= now.second) {
long long r = p[i].first - now.first, u = p[i].second - now.second;
while (r--) ans += 'R';
while (u--) ans += 'U';
now = p[i];
} else {
f = 0;
break;
}
}
if (f)
cout << "YES\n" << ans << endl;
else
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15;
pair<long long, long long> transform(pair<long long, long long> p) {
return pair<long long, long long>(p.first + p.second, p.first - p.second);
}
int main() {
long long minx = inf, miny = inf, maxx = -inf, maxy = -inf;
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
int C;
cin >> C;
while (C--) {
pair<long long, long long> p;
cin >> p.first >> p.second;
p = transform(p);
minx = min(minx, p.first);
miny = min(miny, p.second);
maxx = max(maxx, p.first);
maxy = max(maxy, p.second);
}
long long best = inf, besti = -1;
int H;
cin >> H;
for (int i = 1; i <= H; i++) {
pair<long long, long long> p;
cin >> p.first >> p.second;
p = transform(p);
long long dist = max(max(abs(p.first - minx), abs(p.second - miny)),
max(abs(p.first - maxx), abs(p.second - maxy)));
if (dist < best) best = dist, besti = i;
}
cout << best << endl << besti;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
register int ret = 0;
while (!(ch >= '0' && ch <= '9')) ch = getchar();
while (ch >= '0' && ch <= '9')
ret = (ret << 3) + (ret << 1) + (ch ^ 48), ch = getchar();
return ret;
}
const int maxn = 100010;
struct Task {
int id;
int bai, man;
} ts[maxn];
Task part1[maxn];
Task part2[maxn];
int cnt2 = 0;
int n, p, k;
bool cmp1(const Task &a, const Task &b) {
if (a.man == b.man) {
return a.bai > b.bai;
} else {
return a.man < b.man;
}
}
bool cmp2(const Task &a, const Task &b) {
if (a.bai == b.bai) {
return a.man > b.man;
} else {
return a.bai > b.bai;
}
}
bool cmp3(const Task &a, const Task &b) { return a.man > b.man; }
int minman = 0x3f3f3f3f;
int main() {
n = read();
p = read();
k = read();
for (register int i = 1; i <= n; i++) {
ts[i].bai = read();
ts[i].man = read();
ts[i].id = i;
}
sort(ts + 1, ts + 1 + n, cmp1);
for (register int i = 1; i <= n - (p - k); i++) {
part1[i] = ts[n - i + 1];
}
sort(part1 + 1, part1 + 1 + n - (p - k), cmp2);
for (register int i = 1; i <= k; i++) {
printf("%d ", part1[i].id);
minman = min(part1[i].man, minman);
}
for (register int i = 1; i <= (p - k); i++) {
part2[++cnt2] = ts[i];
}
for (register int i = k + 1; i <= n - (p - k); i++) {
if (part1[i].man < minman) part2[++cnt2] = part1[i];
}
sort(part2 + 1, part2 + 1 + cnt2, cmp3);
for (register int i = 1; i <= p - k; i++) {
printf("%d ", part2[i].id);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
int n;
int bin_search_upper(int tar, vector<int>& a) {
int lo = 0, hi = n - 1;
int mid = (lo + hi + 1) >> 1;
while (lo < hi) {
mid = (lo + hi + 1) >> 1;
if (a[mid] == tar)
return mid;
else if (a[mid] < tar)
lo = mid;
else
hi = mid - 1;
}
return lo;
}
int bin_search_lower(int tar, vector<int>& a) {
int lo = 0, hi = n - 1;
int mid = (lo + hi) >> 1;
while (lo < hi) {
mid = (lo + hi) >> 1;
if (a[mid] == tar)
return mid;
else if (a[mid] < tar)
lo = mid + 1;
else
hi = mid;
}
return lo;
}
int main() {
int q;
cin >> q;
while (q--) {
long long int a, b_, m;
cin >> a >> b_ >> m;
if (a == b_) {
cout << "1 " << a << "\n";
continue;
}
bool flag = false;
vector<long long int> cnt;
for (int k = 2; k <= 50; ++k) {
cnt.clear();
long long int b = b_;
long long int p = 1LL << k - 2;
if (a * p >= b) break;
b -= a * p;
cnt.push_back(a);
if (b < p) continue;
b -= p;
p >>= 1;
while (p >= 1) {
long long int j = b / p;
if (j > m - 1) j = m - 1;
b -= p * j;
cnt.push_back(j + 1);
p >>= 1;
}
if (b > m - 1) continue;
cnt.push_back(b + 1);
flag = true;
break;
}
if (flag) {
long long int sum = a;
for (int i = 1; i < cnt.size(); ++i) {
cnt[i] += sum;
sum += cnt[i];
}
cout << cnt.size();
for (int i = 0; i < cnt.size(); ++i) cout << " " << cnt[i];
cout << "\n";
} else
cout << "-1\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = 2e5 + 7;
const int inf = 1e9 + 7;
const long long base = 1e18;
const double pi = acos(-1);
const double ep = 1e-9;
string s;
int last = 0;
int ans[N];
void solve() {
cin >> s;
if (s.size() % 2 == 1) {
int t = (s.size() + 1) / 2;
for (int i = 0; i < t; i++) printf("%d", 4);
for (int i = 0; i < t; i++) printf("%d", 7);
return;
}
bool bg = false;
for (int i = 1; i < s.size() + 1; i++) {
if (bg) {
ans[i] = 4;
} else {
int c = s[i - 1] - '0';
if (c <= 4) {
ans[i] = 4;
if (c < 4) bg = true;
} else {
if (c <= 7) {
ans[i] = 7;
if (c < 7) bg = true;
} else {
if (ans[last] == 0)
ans[last] = 4;
else
ans[last] = 7;
bg = true;
for (int j = last + 1; j < i + 1; j++) ans[j] = 4;
}
}
}
if (!bg && ans[i] == 4) last = i;
}
int cnt4 = 0, cnt7 = 0;
for (int i = 0; i < s.size() + 1; i++)
if (ans[i] == 4)
cnt4++;
else if (ans[i] == 7)
cnt7++;
if ((cnt4 + cnt7) % 2 == 1 || cnt4 == 0) {
int t = (cnt4 + cnt7 + 1) / 2;
if (cnt4 == 0) t++;
for (int i = 0; i < t; i++) printf("%d", 4);
for (int i = 0; i < t; i++) printf("%d", 7);
return;
}
for (int i = s.size(); i >= 0; i--) {
if (cnt7 >= cnt4) {
break;
}
if (ans[i] == 4) {
ans[i] = 7;
cnt7++;
cnt4--;
}
}
if (cnt4 < cnt7) {
int j = -1;
int dem = 0;
for (int i = s.size(); i > -1; i--) {
if (ans[i] == 7)
dem++;
else {
if (ans[i] == 4 && cnt4 + dem - 1 >= cnt7 - dem + 1) {
ans[i] = 7;
j = i;
cnt4--;
cnt7++;
break;
}
}
}
if (j == -1) {
int t = (cnt4 + cnt7 + 2) / 2;
for (int i = 0; i < t; i++) cout << 4;
for (int i = 0; i < t; i++) cout << 7;
return;
}
for (int i = j + 1; i < s.size() + 1; i++) {
if (cnt4 == cnt7) break;
if (ans[i] == 7) {
ans[i] = 4;
cnt4++;
cnt7--;
}
}
}
for (int i = 0; i <= s.size(); i++)
if (ans[i] != 0) printf("%d", ans[i]);
}
int main() { solve(); }
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.