solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5015;
const int MOD = 1000000007;
const int LIMIT = 5001;
int G[MAXN][MAXN];
int dp[MAXN][MAXN];
int A[MAXN], B[MAXN];
char line[MAXN];
int freq[LIMIT];
void countsort(int n) {
memset(freq, 0, sizeof(freq));
for (int i = 0; i <= n - 1; i++) freq[A[i]]++;
int tot = 0;
int pres = 0;
for (int i = 0; i <= LIMIT - 1; i++) {
pres = freq[i];
freq[i] = tot;
tot += pres;
}
for (int i = 0; i <= n - 1; i++) {
B[freq[A[i]]] = A[i];
freq[A[i]]++;
}
}
int main() {
int n, m;
scanf("%d", &n), scanf("%d", &m);
long long int ans = 0;
for (int i = 0; i <= n - 1; i++) {
scanf("%s", line);
for (int j = 0; j <= m - 1; j++) {
if (line[j] == '1')
G[i][j] = 1;
else
G[i][j] = 0;
}
}
for (int i = n - 1; i >= 0; i--) {
if (G[i][m - 1] == 0)
dp[i][m - 1] = 0;
else
dp[i][m - 1] = 1;
for (int j = m - 2; j >= 0; j--) {
if (G[i][j] == 0)
dp[i][j] = 0;
else
dp[i][j] = dp[i][j + 1] + 1;
}
}
for (int j = 0; j < m; j++) {
for (int i = 0; i <= n - 1; i++) A[i] = dp[i][j];
countsort(n);
long long int maxw = (int)1e9;
long long int area = -1;
int pres = (int)1e9;
int cc = 0;
for (int i = n - 1; i >= 0; i--) {
cc++;
pres = ((B[i]) < (maxw) ? (B[i]) : (maxw));
if (area < (long long int)cc * pres) {
area = cc * pres;
maxw = pres;
}
}
ans = ((ans) > (area) ? (ans) : (area));
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = (long double)(3.1415926535897932384626433832795);
int parity_check(int n) {
int par = n;
par = par ^ (par >> 1);
par = par ^ (par >> 2);
par = par ^ (par >> 4);
par = par ^ (par >> 8);
par = par ^ (par >> 16);
if (par % 2 == 1) {
return 1;
} else {
return 0;
}
}
int lcs(string X, string Y, int m, int n) {
int L[m + 1][n + 1];
int i, j;
for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
if (i == 0 || j == 0)
L[i][j] = 0;
else if (X[i - 1] == Y[j - 1])
L[i][j] = L[i - 1][j - 1] + 1;
else
L[i][j] = max(L[i - 1][j], L[i][j - 1]);
}
}
return L[m][n];
}
int long long gcd(int long long a, int long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
int long long lcm(int long long a, int long long b) {
int long long pro = a * b;
int long long ans = gcd(a, b);
pro = pro / ans;
return pro;
}
int long long fast_power(int long long a, int long long b, int long long p) {
if (b == 0) {
return (1 % p);
}
int long long t = fast_power(a, b / 2, p);
int long long ans = (t * t) % p;
if (b % 2) {
ans = (ans * (a % p)) % p;
}
return ans;
}
bool prime_check(int long long n) {
int long long i, j;
if (n == 1) {
return false;
}
for (i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
int long long fact(int long long n, int long long mod) {
int long long prod = 1;
for (int long long i = 1; i <= n; i++) {
prod = (prod * i) % mod;
}
return prod;
}
void dfs(int long long s, int long long d,
vector<pair<int long long, int long long> > v[], bool visited[],
int long long *max, int long long *maxcount, int long long min,
int long long count) {
visited[s] = true;
if (s == d) {
if ((*max) < min) {
(*max) = min;
(*maxcount) = count;
} else if ((*max) == min) {
if ((*maxcount) < count) {
(*maxcount) = count;
}
}
} else {
for (int long long i = 0; i < v[s].size(); i++) {
if (!visited[v[s][i].first]) {
if (min > v[s][i].second) {
min = v[s][i].second;
}
dfs(v[s][i].first, d, v, visited, max, maxcount, min, count + 1);
}
}
}
visited[s] = false;
}
void polygonArea(int long long X[], int long long Y[], int long long n,
int long long dp[]) {
int long long area = 0;
int long long j = n - 1;
for (int long long i = 0; i < n; i++) {
area += (X[j] + X[i]) * (Y[j] - Y[i]);
dp[i + 1] = area;
j = i;
}
}
void mera_sieve() {
bool prime[6000013];
memset(prime, true, sizeof(prime));
for (int long long p = 2; p * p <= 6000012; p++) {
if (prime[p] == true) {
for (int long long i = p * p; i <= 6000012; i += p) prime[i] = false;
}
}
for (int long long i = 2; i <= 6000012; i++) {
if (prime[i]) {
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int long long n, m, i, j;
cin >> n >> m;
int long long arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
int long long k = n / m;
vector<vector<int long long> > v(m);
for (i = 0; i < n; i++) {
v[arr[i] % m].push_back(i);
}
vector<int long long> free;
int long long ans = 0;
for (i = 0; i < m; i++) {
while (v[i].size() > k) {
free.push_back(v[i].back());
v[i].pop_back();
}
if (v[i].size() < k) {
while (!free.empty() && v[i].size() < k) {
int long long a = (m + i - (arr[free.back()] % m)) % m;
ans += a;
arr[free.back()] += a;
v[i].push_back(free.back());
free.pop_back();
}
}
}
for (i = 0; i < m; i++) {
while (v[i].size() > k) {
free.push_back(v[i].back());
v[i].pop_back();
}
if (v[i].size() < k) {
while (!free.empty() && v[i].size() < k) {
int long long a = (m + i - (arr[free.back()] % m)) % m;
ans += a;
arr[free.back()] += a;
v[i].push_back(free.back());
free.pop_back();
}
}
}
cout << ans << "\n";
for (i = 0; i < n; i++) {
cout << arr[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int s[N];
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) {
scanf("%d", &s[i]);
}
int cnt = 0;
for (int i = 2; i < n; i++) {
if (s[i - 1] == 1 && s[i] == 0 && s[i + 1] == 1) {
s[i + 1] = 0;
cnt++;
}
}
printf("%d\n", cnt);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int MAX_N = (int)2e5 + 123;
const double eps = 1e-6;
const int inf = (int)1e9 + 123;
using namespace std;
int n;
int a[MAX_N];
vector<int> id[MAX_N], q[MAX_N];
pair<long long, int> t[4 * MAX_N];
void build(int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
t[v].first = tl;
return;
}
int tm = (tl + tr) / 2;
build(v * 2, tl, tm), build(v * 2 + 1, tm + 1, tr);
t[v].first = t[v * 2].first + t[v * 2 + 1].first;
}
void push(int v, int tl, int tr) {
if (!t[v].second) return;
t[v].first = (tr - tl + 1) * 1ll * t[v].second;
if (tl != tr) t[v * 2].second = t[v * 2 + 1].second = t[v].second;
t[v].second = 0;
}
void update(int l, int r, int x, int v = 1, int tl = 1, int tr = n) {
push(v, tl, tr);
if (tl > r || l > tr) return;
if (tl >= l && tr <= r) {
t[v].second = x;
push(v, tl, tr);
return;
}
int tm = (tl + tr) / 2;
update(l, r, x, v * 2, tl, tm), update(l, r, x, v * 2 + 1, tm + 1, tr);
t[v].first = t[v * 2].first + t[v * 2 + 1].first;
}
long long get(int x, int v = 1, int tl = 1, int tr = n) {
push(v, tl, tr);
if (tl == tr) return t[v].first;
int tm = (tl + tr) / 2;
if (x <= tm) return get(x, v * 2, tl, tm);
return get(x, v * 2 + 1, tm + 1, tr);
}
void max_eq(int l, int r, int x) {
int L = l, R = r, mid = -1, ans = -1;
while (L <= R) {
mid = (L + R) / 2;
if (get(mid) <= x) {
ans = mid;
L = mid + 1;
} else
R = mid - 1;
}
if (ans != -1) update(l, ans, x);
}
void calc(vector<int> &q) {
if (q[1] + 1 <= n) update(q[1] + 1, n, n + 1);
max_eq(q[0] + 1, q[1], q.back());
max_eq(1, q[0], q[int((q).size()) - 2]);
}
long long h[MAX_N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
id[a[i]].push_back(i);
}
for (int i = 1; i <= (int)2e5; i++) {
for (int j = i; j <= (int)2e5; j += i)
for (auto k : id[j]) q[i].push_back(k);
sort(q[i].begin(), q[i].end());
}
build();
for (int i = (int)2e5; i >= 0; i--) {
h[i] = n * 1ll * n - t[1].first + n;
if (int((q[i]).size()) > 1) calc(q[i]);
}
long long ans = 0;
for (int i = 1; i <= (int)2e5; i++) ans += 1ll * (h[i] - h[i - 1]) * i;
printf("%lld", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, p, a[50 + 10];
double b[50 + 10][50 + 10][50 * 50 + 10], c[50 + 10][50 + 10],
d[50 + 10][50 + 10];
void init() {
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= i; ++j)
c[i][j] = (j == 0 || j == i) ? 1 : c[i - 1][j - 1] + c[i - 1][j];
int pre;
for (int i = 1; i <= n; ++i) {
b[i][0][0] = 1;
for (int j = 1; j <= n; ++j)
if (j != i)
for (int l = n; l; --l)
for (int k = a[j]; k <= n * p; ++k)
b[i][l][k] += b[i][l - 1][k - a[j]];
for (int j = 0; j <= n; ++j)
for (int k = max(0, p - a[i] + 1); k <= p; ++k) d[i][j] += b[i][j][k];
}
}
int main() {
scanf("%d", &n);
int s = 0;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), s += a[i];
scanf("%d", &p);
if (s <= p) {
printf("%.10lf\n", double(n));
return 0;
}
init();
double ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j < n; ++j) ans += j * d[i][j] / (n - j) / c[n][j];
printf("%.10lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, a[1000010], b[1000010], son[1000010][2];
int dp[1000010][2];
char op[100];
void dfs(int u) {
if (b[u] == 5) return;
if (b[u] == 4) {
dfs(son[u][0]);
a[u] = !a[son[u][0]];
return;
}
dfs(son[u][0]);
dfs(son[u][1]);
if (b[u] == 1)
a[u] = a[son[u][0]] & a[son[u][1]];
else if (b[u] == 2)
a[u] = a[son[u][0]] | a[son[u][1]];
else
a[u] = a[son[u][0]] ^ a[son[u][1]];
return;
}
void solve() {
dfs(1);
queue<int> q;
q.push(1);
dp[1][0] = 0;
dp[1][1] = 1;
int u, v1, v2;
while (!q.empty()) {
u = q.front();
q.pop();
if (b[u] == 5) continue;
if (b[u] == 4) {
v1 = son[u][0];
dp[v1][a[v1]] = dp[u][a[u]];
dp[v1][!a[v1]] = dp[u][!a[u]];
q.push(v1);
continue;
}
v1 = son[u][0];
v2 = son[u][1];
if (b[u] == 1) {
dp[v1][0] = dp[v2][0] = dp[v1][1] = dp[v2][1] = dp[u][0];
if (a[v2] == 1) dp[v1][1] = dp[u][1];
if (a[v1] == 1) dp[v2][1] = dp[u][1];
} else if (b[u] == 2) {
dp[v1][1] = dp[v2][1] = dp[v1][0] = dp[v2][0] = dp[u][1];
if (a[v2] == 0) dp[v1][0] = dp[u][0];
if (a[v1] == 0) dp[v2][0] = dp[u][0];
} else {
if (a[v1] == 0) {
dp[v2][0] = dp[u][0];
dp[v2][1] = dp[u][1];
} else {
dp[v2][0] = dp[u][1];
dp[v2][1] = dp[u][0];
}
if (a[v2] == 0) {
dp[v1][0] = dp[u][0];
dp[v1][1] = dp[u][1];
} else {
dp[v1][0] = dp[u][1];
dp[v1][1] = dp[u][0];
}
}
q.push(v1);
q.push(v2);
}
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int i = 1, u, v; i <= n; ++i) {
scanf("%s", op);
if (op[0] == 'I') {
scanf("%d", &u);
a[i] = u;
b[i] = 5;
} else if (op[0] == 'N') {
scanf("%d", &u);
son[i][0] = u;
b[i] = 4;
} else {
scanf("%d%d", &u, &v);
son[i][0] = u;
son[i][1] = v;
if (op[0] == 'A') b[i] = 1;
if (op[0] == 'O') b[i] = 2;
if (op[0] == 'X') b[i] = 3;
}
}
solve();
for (int i = 1; i <= n; ++i)
if (b[i] == 5) printf("%d", dp[i][!a[i]]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
long long highp2(long long n) { return (n & (~(n - 1))); }
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long binarysearchlf(long long l, long long h, vector<long long> &a,
long long k) {
while (l < h) {
long long mid = l + ((h - l + 1) / 2);
if (a[mid] < k)
l = mid;
else
h = mid - 1;
}
return l;
}
long long binarysearchft(long long l, long long h, vector<long long> &a,
long long k) {
while (l < h) {
long long mid = l + ((h - l) / 2);
if (a[mid] < k)
l = mid + 1;
else
h = mid;
}
return l;
}
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return (b, a % b);
}
string getstring(long long k, char x) {
string s(k, x);
return s;
}
bool sortcol1(const vector<int> &v1, const vector<int> &v2) {
return v1[0] < v2[0];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string s;
cin >> s;
long long bal = 0;
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == '(')
bal++;
else {
bal--;
if (bal < 0) {
bal = 0;
ans++;
}
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
int a[110], b[110];
map<int, vector<int> > mp;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) cin >> a[i];
for (int i = 1; i <= k; i++) cin >> b[i];
for (int i = 1; i <= m; i++) {
int tmp = 0;
for (int j = 1; j <= k; j++)
if (b[j] % a[i] == 0) tmp++;
mp[tmp].push_back(i);
}
cout << mp.begin()->second.size() << endl;
for (int i = 0; i < (int)mp.begin()->second.size(); i++)
cout << mp.begin()->second[i] << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int x1[110];
int botva[110];
int x2[110];
int y2[110];
int xc[110];
int yc[110];
long long m[110];
const long double eps = 1e-05;
bool inside(int x1, int botva, int x2, int y2, long long a, long long b,
long long m) {
if (a < x1 * m || a > x2 * m) return false;
if (b < botva * m || b > y2 * m) return false;
return true;
}
bool check(int k) {
long long x = 0, y = 0;
long long m = 0;
for (int i = k; i >= 0; i--) {
x = x + xc[i] * ::m[i];
y = y + yc[i] * ::m[i];
m += ::m[i];
if (i == 0) {
if (!inside(x1[i], botva[i], x2[i], y2[i], x, y, m)) return false;
} else {
if (!inside(max(x1[i], x1[i - 1]), max(botva[i], botva[i - 1]),
min(x2[i], x2[i - 1]), min(y2[i], y2[i - 1]), x, y, m))
return false;
}
}
return true;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d %d", &x1[i], &botva[i], &x2[i], &y2[i]);
int a = abs(x2[i] - x1[i]);
m[i] = a * a * a;
x1[i] *= 2;
botva[i] *= 2;
x2[i] *= 2;
y2[i] *= 2;
xc[i] = (x1[i] + x2[i]) / 2;
yc[i] = (botva[i] + y2[i]) / 2;
if (x1[i] > x2[i]) swap(x1[i], x2[i]);
if (botva[i] > y2[i]) swap(botva[i], y2[i]);
if (!check(i)) {
printf("%d\n", i);
return 0;
}
}
printf("%d\n", n);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long int MOD = 1009;
long long int mpow(long long int a, long long int b) {
if (b == 0) return 1;
long long int t1 = mpow(a, b / 2);
t1 *= t1;
t1 %= MOD;
if (b % 2) t1 *= a;
t1 %= MOD;
return t1;
}
long long int modinverse(long long int a, long long int m) {
long long int m0 = m;
long long int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long int q = a / m;
long long int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long int range(long long int l, long long int r) {
return l + rand() % (r - l + 1);
}
using cd = complex<double>;
const double PI = acos(-1);
long long int reverse(long long int num, long long int lg_n) {
long long int res = 0;
for (long long int i = 0; i < lg_n; i++) {
if (num & (1 << i)) res |= 1 << (lg_n - 1 - i);
}
return res;
}
void fft(vector<cd>& a, bool invert) {
long long int n = a.size();
long long int lg_n = 0;
while ((1 << lg_n) < n) lg_n++;
for (long long int i = 0; i < n; i++) {
if (i < reverse(i, lg_n)) swap(a[i], a[reverse(i, lg_n)]);
}
for (long long int len = 2; len <= n; len <<= 1) {
double ang = 2 * PI / len * (invert ? -1 : 1);
cd wlen(cos(ang), sin(ang));
for (long long int i = 0; i < n; i += len) {
cd w(1);
for (long long int j = 0; j < len / 2; j++) {
cd u = a[i + j], v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert) {
for (cd& x : a) x /= n;
}
}
void multiply(vector<long long int>& a, vector<long long int> const& b) {
vector<cd> fa(a.begin(), a.end()), fb(b.begin(), b.end());
long long int n = 1;
while (n < a.size() + b.size()) n <<= 1;
fa.resize(n);
fb.resize(n);
fft(fa, false);
fft(fb, false);
for (long long int i = 0; i < n; i++) fa[i] *= fb[i];
fft(fa, true);
a.clear();
a.resize(n);
double eps = 0.1;
for (long long int i = 0; i < n; i++) {
a[i] = ((long long int)(fa[i].real() + eps));
}
}
int main() {
long long int n, x;
cin >> n >> x;
vector<long long int> arr;
long long int counter = 0;
for (long long int i = 1; i <= n; i++) {
counter++;
long long int temp;
cin >> temp;
if (temp < x) {
arr.push_back(counter);
counter = 0;
}
}
arr.push_back(counter + 1);
long long int m = (long long int)arr.size();
vector<long long int> brr(m);
for (long long int i = 0; i < m; i++) brr[i] = arr[m - i - 1];
vector<long long int> ans(n + 2, 0);
for (long long int i = 0; i < m - 1; i++) {
ans[0] += arr[i] - 1 + ((arr[i] - 1) * (arr[i] - 2)) / 2;
}
ans[0] += arr[m - 1] - 1 + ((arr[m - 1] - 1) * (arr[m - 1] - 2)) / 2;
multiply(arr, brr);
for (long long int i = 1; i <= m - 1; i++) {
ans[i] = arr[m - 1 - i];
}
for (long long int i = 0; i < n + 1; i++) cout << ans[i] << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
int main() {
int b = 0, c = 0, i;
vector<int> a(4);
string s[4];
for (i = 0; i < 4; i++) {
cin >> s[i];
a[i] = s[i].length();
a[i] = a[i] - 2;
}
sort(a.begin(), a.end());
if ((2 * a[0]) <= a[1]) b++;
if ((2 * a[2]) <= a[3]) c++;
if (b == c) {
cout << 'C';
return 0;
}
if (b > 0) {
for (i = 0; i < 4; ++i) {
if ((a[0] + 2) == s[i].length()) {
cout << s[i][0];
return 0;
}
}
}
if (c > 0) {
for (i = 0; i < 4; ++i) {
if ((a[3] + 2) == s[i].length()) {
cout << s[i][0];
return 0;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
using namespace std;
template <class T>
inline void sort(T &a) {
sort((a).begin(), (a).end());
}
template <class T>
inline void rsort(T &a) {
sort((a).rbegin(), (a).rend());
}
template <class T>
inline void reverse(T &a) {
reverse((a).begin(), (a).end());
}
template <class T, class U>
inline void checkmin(T &x, U y) {
if (x > y) x = y;
}
template <class T, class U>
inline void checkmax(T &x, U y) {
if (x < y) x = y;
}
struct bag : public set<int> {
int ind;
};
bool cmp(const bag &a, const bag &b) { return int(a.size()) > int(b.size()); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
srand(time(nullptr));
int n, m;
cin >> n >> m;
vector<bag> arr(n);
int sumb = 0;
for (int i = 0; i < n; ++i) {
int c;
cin >> c;
sumb += c;
for (int j = 0; j < c; ++j) {
int k;
cin >> k;
arr[i].insert(k);
}
arr[i].ind = i;
}
sort((arr).begin(), (arr).end(), cmp);
vector<int> first(n);
for (int i = 0; i < n; ++i) first[i] = sumb / n + (sumb % n > i);
int ptra = 0, ptrb = n - 1;
vector<vector<int>> ans;
while (ptra<ptrb &&int(arr[ptra].size())> first[ptra]) {
int x = *(arr[ptra].begin());
while (int(arr[ptra].size()) > first[ptra] &&
int(arr[ptrb].size()) < first[ptrb]) {
if (!arr[ptrb].count(x)) {
arr[ptra].erase(x);
arr[ptrb].insert(x);
ans.push_back({arr[ptra].ind, arr[ptrb].ind, x});
}
auto it = arr[ptra].upper_bound(x);
if (it == arr[ptra].end()) break;
x = *it;
}
if (int(arr[ptra].size()) == first[ptra]) ++ptra;
if (int(arr[ptrb].size()) == first[ptrb]) --ptrb;
}
cout << int(ans.size()) << '\n';
for (auto i : ans) cout << i[0] + 1 << ' ' << i[1] + 1 << ' ' << i[2] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y;
cin >> x >> y;
stringstream second;
while ((x > 1 || y > 1) && x != 0 && y != 0) {
if (x >= y) {
if (y == 1) {
second << x - 1 << 'A';
x = 1;
} else {
second << (x / y) << 'A';
x = x % y;
}
} else {
if (x == 1) {
second << y - 1 << 'B';
y = 1;
} else {
second << (y / x) << 'B';
y = y % x;
}
}
}
string ans;
second >> ans;
if (x == 1 && y == 1) {
cout << ans << endl;
} else {
cout << "Impossible" << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, a[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
int t = (n - 2) / 2, ans = a[n - 1] - a[0];
for (int i = 0; i + t + 1 < n; i++) ans = min(ans, a[i + t + 1] - a[i]);
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
long long n, m, heap[1010000], tail, ans;
char mark[110000];
void swap(long long x, long long y) {
long long tmp = heap[x];
heap[x] = heap[y];
heap[y] = tmp;
}
long long cmp(long long x, long long y) { return heap[x] <= heap[y]; }
void up(long long x) {
while ((x >> 1) >= 1) {
if (x == 1 || cmp(x >> 1, x))
return;
else
swap(x, x >> 1);
x >>= 1;
}
}
void down(long long x) {
while ((x << 1) <= tail) {
long long y = x << 1;
if (y < tail && cmp(y + 1, y)) y++;
if (cmp(x, y))
return;
else
swap(x, y);
x = y;
}
}
signed main() {
long long n, x;
scanf("%lld%lld", &n, &x), heap[++tail] = x, up(tail);
for (long long i = 1, x; i < n; i++) {
scanf("%lld", &x);
if (tail && heap[1] < x) ans += x - heap[1], heap[1] = x, down(1);
heap[++tail] = x, up(tail);
}
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dp[403][403];
int n, k;
int parent[403];
int cnt, uu, vv, cur;
vector<int> adj[403];
int nexty[403], order[403];
int ans[403][403][403];
vector<int> answ;
map<pair<int, int>, int> mp;
void dfs(int u) {
int nobat = cnt;
order[cnt++] = u;
for (auto v : adj[u]) {
if (parent[u] != v) {
parent[v] = u;
dfs(v);
}
}
nexty[nobat] = cnt;
}
int cdp(int i, int j) {
if (dp[i][j] != -1) {
return dp[i][j];
}
if (i == n && j == 0) {
ans[cur][i][j] = n;
return 0;
}
if (n - i == j) {
ans[cur][i][j] = ans[cur][i + 1][j - 1];
return dp[i][j] = cdp(i + 1, j - 1);
}
int c, b = INT_MAX;
if (j > 0) {
b = cdp(i + 1, j - 1);
}
if (n - nexty[i] >= j) {
c = 1 + cdp(nexty[i], j);
if (b > c) {
b = c;
ans[cur][i][j] = i;
return dp[i][j] = b;
}
}
ans[cur][i][j] = ans[cur][i + 1][j - 1];
return dp[i][j] = b;
}
int main() {
cin >> n >> k;
if (n == 1) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < n - 1; ++i) {
cin >> uu >> vv;
uu--;
vv--;
mp[{vv, uu}] = mp[{uu, vv}] = i + 1;
adj[uu].push_back(vv);
adj[vv].push_back(uu);
}
int res = INT_MAX, res_i, a;
for (int i = 0; i < n; ++i) {
fill_n(parent, n + 1, -1);
for (int j = 0; j <= n; ++j) {
for (int f = 0; f <= n; ++f) {
dp[j][f] = -1;
}
}
cnt = 0;
dfs(i);
cur = i;
a = cdp(0, k);
if (res > a) {
res_i = i;
res = a;
answ.clear();
if (res != 0) {
int d = ans[i][0][k], pre = k, cu = 0;
while (d != n) {
if (d == cu) {
answ.push_back(mp[{parent[order[d]], order[d]}]);
cu = nexty[d];
d = ans[i][nexty[d]][pre];
continue;
}
d = ans[i][cu + 1][pre - 1];
cu++;
pre--;
}
}
}
}
cout << answ.size() << endl;
sort(answ.begin(), answ.end());
for (auto vv : answ) {
cout << vv << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int a, b, c, m;
cin >> a >> b >> c >> m;
int mx = max(max(a, b), c);
int mn = 0, total = 0;
total = a - 1 + b - 1 + c - 1;
if (mx == c && c > a + b + 1) {
mn = c - a - b - 1;
}
if (mx == a && a > c + b + 1) {
mn = a - c - b - 1;
}
if (mx == b && b > c + a + 1) {
mn = b - c - a - 1;
}
if (m >= mn && m <= total)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int inf = (int)1e9;
int main() {
int a, b, n;
cin >> n >> a >> b;
vector<int> s;
int z;
for (int i = 0; i < n; ++i) {
cin >> z;
s.push_back(z);
}
sort(s.begin(), s.end());
int x = s[b];
int x1 = s[b - 1];
cout << x - x1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
struct node {
int x;
int id;
} a[maxn], b[maxn];
bool cmp(node a, node b) { return a.x < b.x; }
bool cmp2(node a, node b) { return a.x > b.x; }
bool cmp3(node a, node b) { return a.id < b.id; }
int main() {
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &a[i].x);
a[i].id = i;
}
for (int i = 0; i < m; i++) {
scanf("%d", &b[i].x);
b[i].id = i;
}
sort(a, a + m, cmp2);
sort(b, b + m, cmp);
for (int i = 0; i < m; i++) a[i].id = b[i].id;
sort(a, a + m, cmp3);
for (int i = 0; i < m; i++) printf("%d ", a[i].x);
return 0;
}
| 2 |
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int N=200100;
int a[N],vis[N];
int n;
vector<int>cyc;
vector<pair<int,int>>res;
void dfs(int idx){
vis[idx]=true;
cyc.push_back(idx);
if(!vis[a[idx]])dfs(a[idx]);
}
int mex(vector<int>&c){
int cur=0;
while(cur<c.size()&&c[cur]==cur)++cur;
return cur;
}
int solve2(vector<int>c1,vector<int>c2);
int solve1(vector<int>c){
if(c.size()==1)return 1;
if(c.size()==2)return solve2(c,{mex(c)});
int n=c.size();
res.push_back({c[n-2],c[n-1]});
res.push_back({c[n-3],c[n-1]});
for(int i=0;i<n-2;++i)res.push_back({c[i],c[n-2]});
res.push_back({c[n-2],c[n-1]});
return 1;
}
int solve2(vector<int>c1,vector<int>c2){
if(c1.size()==1)return solve1(c2);
for(auto p:c1)res.push_back({p,c2.back()});
for(auto p:c2)res.push_back({c1[0],p});
return 1;
}
int main(){
cin.tie(0);ios::sync_with_stdio(0);
cin>>n;
for(int i=0;i<n;++i)cin>>a[i];
for(int i=0;i<n;++i)--a[i];
vector<vector<int>>cycles;
for(int i=0;i<n;++i)if(!vis[i]){
dfs(i);
cycles.push_back(cyc);
cyc.clear();
}
for(int i=0;i<cycles.size();i+=2){
if(i+1<cycles.size())solve2(cycles[i],cycles[i+1]);
else solve1(cycles[i]);
}
cout<<res.size()<<endl;
for(auto r:res)cout<<r.first+1<<" "<<r.second+1<<endl;
assert(res.size()<=n+1);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, ans;
cin >> s;
long long k;
cin >> k;
long long ss = 0;
for (long long i = 0; i < s.size(); i++)
if (s[i] != '*' && s[i] != '?') ss++;
if (ss >= k) {
long long x = ss - k;
for (long long i = 0; i < s.size(); i++) {
if ((s[i] == '?' || s[i] == '*')) {
if (x) {
ans.pop_back();
x--;
}
} else
ans += s[i];
}
} else {
long long x = k - ss;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == '?') {
continue;
}
if (s[i] == '*') {
while (x > 0) {
ans += s[i - 1];
x--;
}
} else
ans += s[i];
}
}
if (ans.size() == k)
cout << ans;
else
cout << "Impossible";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e+5;
map<int, int>::iterator it;
int n, fa[maxn];
map<int, int> mp;
pair<int, int> p[maxn];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 0; i < n; i++) scanf("%d%d", &p[i].first, &p[i].second);
sort(p, p + n);
int cnt = 0;
for (int i = 0; i < n; i++) {
it = mp.lower_bound(p[i].first);
while (it != mp.end() && it->first < p[i].second) {
int fx = find(i), fy = find(it->second);
if (fx == fy || cnt >= n) {
printf("NO\n");
return 0;
} else {
cnt++;
fa[fx] = fy;
}
++it;
}
mp[p[i].second] = i;
}
if (cnt == n - 1)
printf("YES\n");
else
printf("NO\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[500];
long long c[501][501];
long long dp[2][501][501];
int main() {
int n, m, mod, x = 0, y = 0, i, j, k;
scanf("%d %d %d", &n, &m, &mod);
for (i = 0; i < m; i++) {
char s[501];
scanf("%s", s);
for (j = 0; j < n; j++) {
if (s[j] == '1') a[j]++;
}
}
for (i = 0; i < n; i++) {
if (a[i] == 0) {
x++;
} else if (a[i] == 1) {
y++;
}
}
for (i = 0; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (j = 1; j < i; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
dp[m & 1][x][y] = 1;
for (i = m; i < n; i++) {
for (j = 0; j <= n; j++) {
for (k = 0; k <= n; k++) {
if (dp[i & 1][j][k] == 0) continue;
if (j >= 2) {
dp[(i + 1) & 1][j - 2][k + 2] = (dp[(i + 1) & 1][j - 2][k + 2] +
dp[i & 1][j][k] * c[j][2] % mod) %
mod;
}
if (j >= 1 && k >= 1) {
dp[(i + 1) & 1][j - 1][k] = (dp[(i + 1) & 1][j - 1][k] +
dp[i & 1][j][k] * j % mod * k % mod) %
mod;
}
if (k >= 2) {
dp[(i + 1) & 1][j][k - 2] =
(dp[(i + 1) & 1][j][k - 2] + dp[i & 1][j][k] * c[k][2] % mod) %
mod;
}
dp[i & 1][j][k] = 0;
}
}
}
printf("%d\n", dp[n & 1][0][0]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int head[500008];
int nedge;
int dep[500008];
int nv;
bool vis[500008];
struct edge {
int u, v, nxt;
} edges[500008 * 2];
void add_edge(int u, int v) {
edges[nedge].u = u;
edges[nedge].v = v;
edges[nedge].nxt = head[u];
head[u] = nedge++;
}
void dfs(int u, int d) {
bool flag = 0;
vis[u] = 1;
for (int i = head[u]; i != -1; i = edges[i].nxt) {
int v = edges[i].v;
if (vis[v]) continue;
vis[v] = 1;
flag = 1;
dfs(v, d + 1);
}
if (!flag) {
dep[nv++] = d;
}
}
int solve() {
int ret = 0;
vis[1] = 1;
for (int i = head[1]; i != -1; i = edges[i].nxt) {
int v = edges[i].v;
vis[v] = 1;
nv = 0;
dfs(v, 0);
sort(dep, dep + nv);
int tmp = dep[0];
for (int i = 1; i < nv; i++) {
tmp = max(dep[i], tmp + 1);
}
ret = max(ret, tmp + 1);
}
return ret;
}
int main() {
int u, v;
scanf("%d", &n);
memset(head, -1, sizeof head);
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
cout << solve() << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long mod = 1e9 + 7;
template <typename T>
inline T gcd(T a, T b) {
return !b ? a : gcd(b, a % b);
}
template <typename T>
inline T q_pow(T a, T x) {
T ans = 1, tmp = a;
while (x) {
if (x & 1) (ans *= tmp) %= mod;
(tmp *= tmp) %= mod;
x >>= 1;
}
return ans;
}
template <typename T>
inline void re(T &N) {
int f = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') f = -1;
N = c - '0';
while ((c = getchar()) >= '0' && c <= '9') N = N * 10 + c - '0';
N *= f;
}
int m, n, t = 1, st, en;
struct edge {
int to, nxt;
edge(int to = 0, int nxt = 0) : to(to), nxt(nxt) {}
} e[N << 1];
int head[N];
inline void add(int x, int y) {
e[++t] = edge(y, head[x]);
head[x] = t;
e[++t] = edge(x, head[y]);
head[y] = t;
}
int d[N], pa[N];
void dfs(int x, int p) {
pa[x] = p;
d[x] = d[p] + 1;
for (int i = head[x]; i; i = e[i].nxt) {
int to = e[i].to;
if (d[to]) continue;
dfs(to, x);
}
}
vector<int> v[N];
int main() {
int _;
re(_);
while (_--) {
re(n);
re(m);
t = 1;
for (int i = 1; i <= n; i++) head[i] = d[i] = pa[i] = 0;
for (int i = 1; i <= m; i++) {
int x, y;
re(x);
re(y);
add(x, y);
}
for (int i = 1; i <= n; i++)
if (!d[i]) dfs(i, 0);
int ma = 0, pos;
for (int i = 1; i <= n; i++)
if (ma < d[i]) {
ma = d[i];
pos = i;
}
if (ma >= n / 2 + n % 2) {
puts("PATH");
vector<int> ans;
while (pos) ans.push_back(pos), pos = pa[pos];
printf("%d\n", (int)ans.size());
for (int i : ans) printf("%d ", i);
puts("");
} else {
puts("PAIRING");
for (int i = 1; i <= ma; i++) v[i].clear();
for (int i = 1; i <= n; i++) v[d[i]].push_back(i);
vector<pair<int, int> > ans;
for (int i = 1; i <= ma; i++)
for (int j = 1; j < v[i].size(); j += 2)
ans.emplace_back(v[i][j - 1], v[i][j]);
printf("%d\n", (int)ans.size());
for (pair<int, int> i : ans) printf("%d %d\n", i.first, i.second);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int num;
int count = 0;
for (int i = 0; i < n; ++i) {
cin >> num;
if ((k % 2 == 0) && (num == (k / 2)))
cout << ((count++) % 2) << " ";
else if ((2 * num) < k)
cout << 0 << " ";
else
cout << 1 << " ";
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int l[100010];
int d[100010];
int s[100010];
int sum[100010];
long long suffix_sum[100010];
long long suffix_s[100010];
vector<int> leg[210];
int max(int a, int b) { return a > b ? a : b; }
int min(long long int a, long long int b) { return a < b ? a : b; }
int main() {
int n, maxlen = -1, total = 0, ans = 0x7FFFFFFF;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &l[i]);
maxlen = max(maxlen, l[i]);
s[l[i]]++;
}
for (int i = 0; i < n; i++) {
scanf("%d", &d[i]);
sum[l[i]] += d[i];
leg[d[i]].push_back(l[i]);
}
suffix_s[maxlen + 1] = 0;
suffix_sum[maxlen + 1] = 0;
for (int i = maxlen; i >= 0; i--) {
suffix_s[i] = suffix_s[i + 1] + s[i];
suffix_sum[i] = suffix_sum[i + 1] + sum[i];
}
for (int i = 0; i <= 200; i++) sort(leg[i].begin(), leg[i].end());
for (int i = 1; i <= maxlen; i++) {
if (s[i] == 0) continue;
long long cut_n = suffix_s[i + 1], cut_d = suffix_sum[i + 1];
for (int j = 0; j <= 200 && n - cut_n >= 2 * s[i]; j++) {
int tmp = lower_bound(leg[j].begin(), leg[j].end(), i) - leg[j].begin();
tmp = min(tmp, n - cut_n - 2 * s[i] + 1);
cut_n += tmp;
cut_d += j * tmp;
}
ans = min(ans, cut_d);
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 * 4 + 100;
vector<int> vec[maxn];
queue<int> q;
int n, c[maxn], fa[maxn], maxe;
bool check[maxn];
void bfs() {
check[1] = 1;
q.push(1);
while (!q.empty()) {
int cur = q.front();
q.pop();
int cnt = 0;
for (auto nei : vec[cur])
if (!check[nei]) {
fa[nei] = cur;
q.push(nei);
check[nei] = 1;
while (cnt == c[cur] || cnt == c[fa[cur]]) {
cnt++;
cnt %= maxe;
}
c[nei] = cnt++;
cnt %= maxe;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int f, g;
cin >> f >> g;
vec[f].push_back(g);
vec[g].push_back(f);
}
maxe = 0;
for (int i = 1; i <= n; i++) maxe = max(maxe, (int)vec[i].size() + 1);
cout << maxe << endl;
bfs();
for (int i = 1; i <= n; i++) cout << c[i] + 1 << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<long long> v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
int i = 1, j = n;
long long sum = 0;
while (i < j) {
sum += (v[i] + v[j]) * (v[i] + v[j]);
i++;
j--;
}
cout << sum << endl;
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[360];
int c[360];
int main() {
long long n;
cin >> n;
n %= 360;
n *= -1;
if (n < 0) n = 360 + n;
int b = 0;
memset(a, -1, sizeof a);
memset(c, -1, sizeof c);
while (true) {
if (a[n] != -1) break;
a[n] = b;
c[360 - n] = b;
++b;
n += 90;
n %= 360;
}
for (int i = 0; i < 361; ++i) {
if (c[i] != -1 && a[i] != -1) {
cout << min(a[i], c[i]);
return 0;
}
if (c[i] != -1) {
cout << c[i];
return 0;
}
if (a[i] != -1) {
cout << a[i];
return 0;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
struct vec {
int a[2];
};
struct mat {
int a[2][2];
};
int n, m, P;
long long k;
void update(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
vec operator*(vec x, mat y) {
vec ans;
ans.a[0] = (1ll * x.a[0] * y.a[0][0] + 1ll * x.a[1] * y.a[1][0]) % P;
ans.a[1] = (1ll * x.a[0] * y.a[0][1] + 1ll * x.a[1] * y.a[1][1]) % P;
return ans;
}
mat operator*(mat x, mat y) {
mat ans;
ans.a[0][0] = (1ll * x.a[0][0] * y.a[0][0] + 1ll * x.a[0][1] * y.a[1][0]) % P;
ans.a[0][1] = (1ll * x.a[0][0] * y.a[0][1] + 1ll * x.a[0][1] * y.a[1][1]) % P;
ans.a[1][0] = (1ll * x.a[1][0] * y.a[0][0] + 1ll * x.a[1][1] * y.a[1][0]) % P;
ans.a[1][1] = (1ll * x.a[1][0] * y.a[0][1] + 1ll * x.a[1][1] * y.a[1][1]) % P;
return ans;
}
mat make(int x, int y) {
mat ans;
ans.a[0][0] = 0, ans.a[0][1] = x;
ans.a[1][0] = 1, ans.a[1][1] = y;
return ans;
}
mat unit() {
mat ans;
ans.a[0][0] = ans.a[1][1] = 1;
ans.a[1][0] = ans.a[0][1] = 0;
return ans;
}
mat power(mat a, long long x) {
if (x == 0) return unit();
mat tmp = power(a, x / 2);
if (x % 2 == 0)
return tmp * tmp;
else
return tmp * tmp * a;
}
struct SegmentTree {
struct Node {
int lc, rc;
mat sum;
} a[MAXN * 2];
int n, root, size;
void build(int &root, int l, int r, int *c) {
root = ++size;
if (l == r) {
a[root].sum = make(c[l - 1], c[l]);
return;
}
int mid = (l + r) / 2;
build(a[root].lc, l, mid, c);
build(a[root].rc, mid + 1, r, c);
a[root].sum = a[a[root].lc].sum * a[a[root].rc].sum;
}
void init(int x, int *c) {
n = x;
build(root, 1, n, c);
}
mat query(int root, int l, int r, int ql, int qr) {
if (l == ql && r == qr) return a[root].sum;
int mid = (l + r) / 2;
if (mid >= qr)
return query(a[root].lc, l, mid, ql, qr);
else if (mid + 1 <= ql)
return query(a[root].rc, mid + 1, r, ql, qr);
else
return query(a[root].lc, l, mid, ql, mid) *
query(a[root].rc, mid + 1, r, mid + 1, qr);
}
mat query(int l, int r) { return query(root, 1, n, l, r); }
} ST;
int a[MAXN];
pair<long long, int> b[MAXN];
int query(long long x) { return a[(x - 1) % n]; }
mat query(long long l, long long r) {
mat ans = unit();
if (l > r) return ans;
l--, r--;
r -= (l - 1) / n * n;
l -= (l - 1) / n * n;
if (r <= n) return ST.query(l, r);
int x = r % n;
if (x == 0) x = n;
ans = ans * ST.query(l, n) * power(ST.query(1, n), (r - x) / n - 1) *
ST.query(1, x);
return ans;
}
int main() {
read(k), read(P), read(n);
if (k <= 1) {
cout << k % P << endl;
return 0;
}
for (int i = 0; i <= n - 1; i++) read(a[i]);
a[n] = a[0];
ST.init(n, a);
read(m);
for (int i = 1; i <= m; i++)
read(b[i].first), read(b[i].second), b[i].first++;
b[++m] = make_pair(2e18, 0);
sort(b + 1, b + m + 1);
b[0] = make_pair(1, a[0]);
vec ans = (vec){0, 1};
for (int i = 1; i <= m; i++) {
if (k < b[i].first) {
if (k == b[i - 1].first) {
cout << ans.a[1] << endl;
return 0;
}
ans = ans * make(b[i - 1].second, query(b[i - 1].first + 1)) *
query(b[i - 1].first + 2, k);
cout << ans.a[1] << endl;
return 0;
}
if (b[i].first == b[i - 1].first + 1)
ans = ans * make(b[i - 1].second, b[i].second);
else
ans = ans * make(b[i - 1].second, query(b[i - 1].first + 1)) *
query(b[i - 1].first + 2, b[i].first - 1) *
make(query(b[i].first - 1), b[i].second);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 10, inf = 1000 * 1000 * 1000 + 100;
pair<int, int> p[N];
long long ans = 0;
map<int, int> mapi, sapi;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
ans += (1LL * mapi[p[i].first]++);
ans += (1LL * sapi[p[i].second]++);
}
sort(p, p + n);
p[n] = make_pair(inf, inf);
long long cnt = 1;
for (int i = 0; i < n; i++) {
if ((p[i].first == p[i + 1].first) && (p[i].second == p[i + 1].second))
cnt++;
if ((p[i].first != p[i + 1].first) || (p[i].second != p[i + 1].second)) {
ans -= (1ll * (cnt * (cnt - 1)) / 2);
cnt = 1;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vlli = vector<long long int>;
using vpii = vector<pair<int, int>>;
const int N = 1010;
const int M = 30010;
lli n, m, u, v, w, s, t, x, budget = 1000111000111000111LL, c, ans[3], curr,
curr_idx, C, T;
vb allowed(M, true), visit, bridge;
vector<vector<tuple<lli, lli, lli>>> adj(N), tree;
vlli parent, low, disc, path, component, temp, cost(M);
bool reachable;
void init() {
C = T = 0;
tree.clear();
tree.resize(n + 1);
parent.resize(n + 1);
disc.resize(n + 1);
low.resize(n + 1);
component.assign(n + 1, -1);
visit.assign(n + 1, false);
bridge.assign(m + 1, false);
}
void dfs_path(int u) {
if (reachable) return;
if (u == t) {
reachable = true;
path = temp;
return;
}
visit[u] = true;
for (auto i : adj[u]) {
lli v, w, idx;
tie(v, w, idx) = i;
if (visit[v]) continue;
temp.push_back(idx);
dfs_path(v);
temp.pop_back();
}
}
void find_bridges(int u) {
visit[u] = true;
disc[u] = low[u] = ++T;
for (auto i : adj[u]) {
lli v, w, idx;
tie(v, w, idx) = i;
if (!allowed[idx]) continue;
if (!visit[v]) {
parent[v] = u;
find_bridges(v);
low[u] = min(low[u], low[v]);
if (low[v] > disc[u]) bridge[idx] = true;
} else if (v != parent[u])
low[u] = min(low[u], disc[v]);
}
}
void dfs_components(int u) {
component[u] = C;
for (auto i : adj[u])
if (component[get<0>(i)] == -1 && !bridge[get<2>(i)] && allowed[get<2>(i)])
dfs_components(get<0>(i));
}
void build(int u) {
visit[u] = true;
for (auto i : adj[u]) {
lli v, w, idx;
tie(v, w, idx) = i;
if (!allowed[idx]) continue;
if (!visit[v]) {
build(v);
if (bridge[idx]) {
tree[component[u]].push_back(make_tuple(component[v], w, idx));
tree[component[v]].push_back(make_tuple(component[u], w, idx));
}
}
}
}
void dfs_min_edge(int u, int prev, lli minm, int minm_idx) {
visit[u] = true;
if (u == component[t]) {
curr = minm;
curr_idx = minm_idx;
return;
}
for (auto i : tree[u]) {
lli v, w, idx;
tie(v, w, idx) = i;
if (allowed[idx] && v != prev && v != u)
dfs_min_edge(v, u, min(minm, w), minm < w ? minm_idx : idx);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> s >> t;
for (int i = 1; i <= m; i++) {
cin >> u >> v >> w;
adj[u].push_back(make_tuple(v, w, i));
adj[v].push_back(make_tuple(u, w, i));
cost[i] = w;
}
visit.assign(n + 1, false);
dfs_path(s);
if (!reachable) return cout << 0 << '\n' << 0, 0;
for (auto i : path) {
allowed[i] = false;
init();
for (int j = 1; j <= n; j++)
if (!visit[j]) find_bridges(j);
for (int j = 1; j <= n; j++)
if (component[j] == -1) {
C++;
dfs_components(j);
}
visit.assign(n + 1, false);
for (int j = 1; j <= n; j++)
if (!visit[j]) build(j);
if (component[s] != component[t]) {
curr = 1000111000111000111LL;
visit.assign(n + 1, false);
dfs_min_edge(component[s], component[s], 1000111000111000111LL, -1);
if (curr == 1000111000111000111LL && cost[i] < budget)
budget = cost[i], c = 1, ans[1] = i;
else if (curr != 1000111000111000111LL && cost[i] + curr < budget)
budget = cost[i] + curr, c = 2, ans[1] = i, ans[2] = curr_idx;
}
allowed[i] = true;
}
if (budget == 1000111000111000111LL) return cout << -1, 0;
if (c == 1)
cout << budget << '\n' << c << '\n' << ans[1];
else
cout << budget << '\n' << c << '\n' << ans[1] << " " << ans[2];
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int f[N];
int pref[N];
int pos[N];
int res[2 * N];
void upd(int pos, int val) {
for (int i = pos; i < N; i += i & (-i)) f[i] += val;
}
int get(int pos) {
int res = 0;
for (int i = pos; i > 0; i -= i & (-i)) res += f[i];
return res;
}
int find_nearest(int pos) {
int left = 0, right = pos, mid;
int need = get(pos);
if (need == 0) return -1;
while (right - left > 1) {
mid = (left + right) / 2;
if (get(mid) == need)
right = mid;
else
left = mid;
}
return right;
}
signed main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(f, 0, sizeof(f));
int n;
cin >> n;
vector<pair<char, int>> x(2 * n + 1);
for (int i = 1; i <= 2 * n; i++) {
char c;
cin >> c;
if (c == '+')
x[i] = make_pair('+', -1), upd(i, 1);
else {
int k;
cin >> k;
x[i] = make_pair('-', k);
pos[k] = i;
}
}
for (int i = 1; i <= n; i++) {
int cur = find_nearest(pos[i]);
if (cur == -1) {
cout << "NO" << endl;
return 0;
}
upd(cur, -1);
res[cur] = i;
}
set<int> have;
vector<int> aans;
for (int i = 1; i <= 2 * n; i++) {
if (x[i].first == '+') {
have.insert(res[i]);
aans.push_back(res[i]);
} else {
auto l = *have.begin();
have.erase(have.begin());
if (l != x[i].second) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int elem : aans) {
cout << elem << ' ';
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int N = 2e5 + 10;
const int MOD = 998244353;
const int STP = 119;
const int MXL = 8388608;
const int g = 3;
inline int Mul(int a, int b) {
unsigned long long x = (long long)a * b;
unsigned xh = (unsigned)(x >> 32), xl = (unsigned)x, d, m;
asm("divl %4;\n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(MOD));
return m;
}
int Qpow(int x, int y = MOD - 2) {
int res = 1;
for (; y; y >>= 1, x = Mul(x, x))
if (y & 1) res = Mul(res, x);
return res;
}
int n, K, jc[N], njc[N];
int Ar(int n, int m) { return Mul(jc[n], njc[n - m]); }
int sz[N], sm[N];
vector<int> G[N];
int U(int x, int y) { return ((x += y) >= MOD) ? (x - MOD) : x; }
void SU(int& x, int y) { ((x += y) >= MOD) ? (x -= MOD) : 0; }
int ans;
vector<int> t;
int w[MXL + 10];
void FFT(vector<int>& A, bool fl) {
int L = A.size();
if (fl) {
int t = Qpow(L);
for (int& v : A) v = Mul(v, t);
reverse(A.begin() + 1, A.end());
}
for (int i = 1, j = L >> 1, k; i < L; ++i, j ^= k) {
if (i < j) swap(A[i], A[j]);
k = L >> 1;
while (j & k) {
j ^= k;
k >>= 1;
}
}
for (int i = 1; i < L; i <<= 1) {
int t = Qpow(g, (MOD - 1) / (i << 1));
vector<int>::iterator p = A.begin(), q = p + i;
for (int j = 0, x = MXL / (i << 1); j < L; j += (i << 1), p += i, q += i) {
for (int k = 0, y = 0; k < i; ++k, ++p, ++q, y += x) {
t = Mul(*q, w[y]);
*q = U(*p, MOD - t);
SU(*p, t);
}
}
}
}
vector<int> operator*(vector<int> A, vector<int> B) {
int need = A.size() + B.size() - 1, L;
for (L = 1; L < need; L <<= 1)
;
A.resize(L);
FFT(A, false);
B.resize(L);
FFT(B, false);
for (int i = 0; i < L; ++i) A[i] = Mul(A[i], B[i]);
FFT(A, true);
A.resize(min(K + 1, need));
return A;
}
vector<int> DivCalc(int l, int r) {
if (l < r)
return DivCalc(l, (l + r) >> 1) * DivCalc(((l + r) >> 1) + 1, r);
else if (l == r)
return {1, t[l]};
else
return {1};
}
int Dark(vector<int> p, int x, int y) {
for (int i = 1; i <= (int)p.size() - 1; ++i) SU(p[i], MOD - Mul(y, p[i - 1]));
for (int i = p.size() - 1; i > 0; --i) SU(p[i], Mul(x, p[i - 1]));
int res = 0;
for (int i = 1; i < (int)p.size(); ++i) SU(res, Mul(p[i], Ar(K, i)));
return res;
}
int rec[N], vis[N], cc;
void Dfs(int u, int fa = 0) {
sz[u] = sm[u] = 1;
for (int v : G[u])
if (v != fa) {
Dfs(v, u);
SU(ans, Mul(sm[u], sm[v]));
SU(sm[u], sm[v]);
sz[u] += sz[v];
}
t.clear();
for (int v : G[u])
if (v != fa) t.emplace_back(sz[v]);
static vector<int> p;
p = DivCalc(0, t.size() - 1);
if ((int)p.size() - 1 > K) p.resize(K + 1);
for (int i = 1; i < (int)p.size(); ++i) SU(sm[u], Mul(Ar(K, i), p[i]));
++cc;
for (int v : G[u])
if (v != fa) {
if (vis[sz[v]] != cc) {
rec[sz[v]] = Dark(p, n - sz[u], sz[v]);
vis[sz[v]] = cc;
}
SU(ans, Mul(rec[sz[v]], sm[v]));
}
}
void Prework() {
jc[0] = 1;
for (int i = 1; i <= K; ++i) jc[i] = Mul(jc[i - 1], i);
njc[K] = Qpow(jc[K]);
for (int i = K - 1; ~i; --i) njc[i] = Mul(njc[i + 1], i + 1);
w[0] = 1;
int x = Qpow(g, STP);
for (int i = 1; i < MXL; ++i) w[i] = Mul(w[i - 1], x);
}
int main() {
scanf("%d%d", &n, &K);
if (K == 1) {
printf("%lld\n", (long long)n * (n - 1) / 2 % MOD);
return 0;
}
Prework();
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
G[u].emplace_back(v);
G[v].emplace_back(u);
}
Dfs(1);
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int f[maxn];
int d[maxn];
vector<pair<int, int> > G[maxn];
int mx[maxn], mx_pos[maxn], dye[maxn], sum[maxn];
int v[maxn];
int ans, ans_cnt, root, pos, n, m;
void add(int x, int y, int z) {
G[x].push_back(make_pair(y, z));
G[y].push_back(make_pair(x, z));
}
bool dfs(int x, int fa, int now) {
int flag = (v[x] == 1);
d[x] = now;
for (auto y : G[x]) {
if (y.first == fa) continue;
int tmp = dfs(y.first, x, now + y.second);
flag |= tmp;
f[y.first] = x;
}
if (flag && d[x] > ans) {
ans = d[x];
pos = x;
}
return flag;
}
void get_root() {
dfs(1, -1, 0);
memset(d, 0, sizeof(d));
ans = 0;
root = pos;
dfs(root, -1, 0);
int Sum = d[pos], tmp = pos;
while (d[tmp] > d[pos] / 2) {
tmp = f[tmp];
}
root = tmp;
}
void update(int pos, int ch, int val) {
if (mx[pos] < mx[ch] + val) {
mx[pos] = mx[ch] + val;
mx_pos[pos] = mx_pos[ch];
} else if (mx[pos] == mx[ch] + val) {
mx_pos[pos] = pos;
}
}
bool dfs1(int x, int fa, int color) {
dye[x] = color;
int flag = (v[x] == 1);
if (flag == 1) mx_pos[x] = x;
for (auto y : G[x]) {
if (y.first == fa) continue;
int tmp;
tmp = dfs1(y.first, x, color);
f[y.first] = x;
if (tmp) {
update(x, y.first, y.second);
}
flag |= tmp;
}
return flag;
}
void dfs2(int x, int fa) {
for (auto y : G[x]) {
if (y.first == fa) continue;
dfs2(y.first, x);
sum[x] += sum[y.first];
}
if (sum[x] > ans && v[x] == 0) {
ans = sum[x];
ans_cnt = 1;
} else if (sum[x] == ans && v[x] == 0) {
ans_cnt++;
}
}
vector<pair<int, int> > res;
map<int, int> mp;
set<int> s;
int tot;
void solve() {
for (auto y : G[root]) {
int tmp = dfs1(y.first, root, ++tot);
if (tmp) {
res.push_back(make_pair(mx[y.first] + y.second, mx_pos[y.first]));
}
}
if (v[root] == 1) {
res.push_back(make_pair(0, root));
}
sort(res.begin(), res.end());
s.insert(dye[res[res.size() - 1].second]);
for (int i = res.size() - 1; i >= 1; i--) {
if (res[i].first == res[i - 1].first) {
s.insert(dye[res[i].second]);
s.insert(dye[res[i - 1].second]);
} else {
break;
}
}
for (int i = 0; i < res.size(); i++) {
mp[res[i].first]++;
}
for (int i = 1; i <= n; i++) {
if (v[i] == 1) {
if (s.count(dye[i]) && s.size() > 1) {
if (s.size() > 2) {
sum[i]++;
} else {
for (int j = res.size() - 1; j >= 0; j--) {
if (dye[i] != dye[res[j].second]) {
sum[i]++;
sum[res[j].second]++;
sum[root]--;
break;
}
}
}
} else {
if (s.size() > 1) {
sum[i]++;
continue;
}
if (dye[i] != dye[res[res.size() - 1].second]) {
sum[i]++;
sum[res[res.size() - 1].second]++;
sum[root]--;
} else {
sum[i]++;
if (mp[res[res.size() - 2].first] == 1) {
sum[res[res.size() - 2].second]++;
sum[root]--;
}
}
}
}
}
ans = ans_cnt = 0;
dfs2(root, -1);
}
int main() {
int x, y, z;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
v[x] = 1;
}
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
}
get_root();
solve();
printf("%d %d\n", ans, ans_cnt);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int size = 2e5 + 7;
int sz[size], dp[size][5], n, k;
long long rem[size], ans;
vector<int> v[size];
void dfs(int i, int p) {
sz[i] = dp[i][0] = 1;
for (int j : v[i]) {
if (j == p) continue;
dfs(j, i);
sz[i] += sz[j];
ans += sz[j] * 1ll * (n - sz[j]);
for (int l = 0; l < k; l++)
for (int second = 0; second < k; second++)
rem[(l + second + 1) % k] += dp[i][l] * 1ll * dp[j][second];
for (int l = 0; l < k; l++) dp[i][(l + 1) % k] += dp[j][l];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int i, x, y;
cin >> n >> k;
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
x--;
y--;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(0, -1);
for (i = 1; i < k; i++) ans += (k - i) * rem[i];
ans /= k;
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 1e5 + 5, inf = 0x3f3f3f3f;
vector<int> e[maxn], ans;
int n, m, t, h, k, tim, du[maxn], cnt, c[maxn], vis[maxn];
int main() {
cin >> n >> m >> h >> t;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
du[u]++, du[v]++;
}
for (int i = 1; i <= m; i++) {
if (du[i] <= h) continue;
for (auto j : e[i]) c[j] = i;
for (auto j : e[i]) {
tim++;
int p = du[i] - 1 - h, q = 0;
ans.clear();
for (auto k : e[j]) {
if (k != i) {
if (c[k] == i && p) {
p--;
q++;
vis[k] = tim;
ans.push_back(k);
} else if (c[k] != i) {
q++;
vis[k] = tim;
ans.push_back(k);
}
}
if (q == t) break;
}
if (q == t) {
int res = 0;
puts("YES");
printf("%d %d\n", i, j);
for (int k : e[i]) {
if (k != j && vis[k] != tim) {
printf("%d ", k);
res++;
}
if (res == h) break;
}
puts("");
for (auto x : ans) {
printf("%d ", x);
}
return 0;
}
}
}
puts("NO");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, -1, 0};
int dy[4] = {1, 0, 0, -1};
long long limit = 1000000000;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
void a() {
long long n;
cin >> n;
vector<long long> v(n);
vector<long long> neg, pos, zero;
for (long long &x : v) {
cin >> x;
if (x < 0) {
neg.emplace_back(x);
} else if (x > 0) {
pos.emplace_back(x);
} else {
zero.emplace_back(x);
}
}
if (pos.size() == 0 && neg.size()) {
if (neg.size() > 1) {
pos.emplace_back(neg[0]);
pos.emplace_back(neg[1]);
neg.erase(neg.begin() + 0);
neg.erase(neg.begin() + 0);
}
}
if (neg.size() && ((neg.size()) % 2 == 0)) {
zero.emplace_back(neg[0]);
neg.erase(neg.begin() + 0);
}
cout << neg.size() << " ";
for (long long x : neg) cout << x << ' ';
cout << '\n';
;
cout << pos.size() << " ";
for (long long &x : pos) cout << x << " ";
cout << '\n';
cout << zero.size() << " ";
for (long long &x : zero) cout << x << " ";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
a();
}
| 1 |
/*
Powered by C++11.
Author : Alex_Wei.
*/
#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize(3)
//using int = long long
//using i128 = __int128;
#define fi first
#define se second
#define pb emplace_back
#define all(x) (x).begin(),(x).end()
#define sor(x) sort(all(x))
#define rev(x) reverse(all(x))
#define mem(x,v) memset(x,v,sizeof(x))
#define Time 1.0*clock()/CLOCKS_PER_SEC
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair <int,int>;
using pll = pair <ll,ll>;
using pdd = pair <double,double>;
namespace IO{
char buf[1<<25],*p1=buf,*p2=buf,obuf[1<<25],*O=obuf;
#ifdef __WIN32
#define gc getchar()
#else
#define gc (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<22,stdin),p1==p2)?EOF:*p1++)
#endif
#define pc(x) (*O++=x)
#define flush() fwrite(obuf,O-obuf,1,stdout)
inline ll read(){
ll x=0; bool sign=0; char s=gc;
while(!isdigit(s))sign|=s=='-',s=gc;
while(isdigit(s))x=(x<<1)+(x<<3)+(s-'0'),s=gc;
return sign?-x:x;
} inline void print(ll x){if(x>9)print(x/10); pc(x%10+'0');}
inline void print(string s){for(int it:s)pc(it); pc('\n');};
}
const int mod=998244353;
const long double Pi=acos(-1);
namespace math{
const int MAXN=1e6+5;
ll ksm(ll a,ll b){
ll s=1,m=a;
while(b){
if(b&1)s=s*m%mod;
m=m*m%mod,b>>=1;
} return s;
} ll inv(ll x){return ksm(x,mod-2);}
ll fc[MAXN],ifc[MAXN];
void init(){
fc[0]=1; for(int i=1;i<MAXN;i++)fc[i]=fc[i-1]*i%mod;
ifc[MAXN-1]=inv(fc[MAXN-1]);
for(int i=MAXN-2;i>=0;i--)ifc[i]=ifc[i+1]*(i+1)%mod;
} ll bin(ll n,ll m){return fc[n]*ifc[m]%mod*ifc[n-m]%mod;}
}
mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());
// Please give me more points.
using namespace IO;
//using namespace math;
const int N=1e5+5;
int q(int x){
cout<<"? "<<x+1<<endl;
int tmp; cin>>tmp;
return tmp;
}
void solve(){
int n,k,b;
cin>>n>>k,b=sqrt(n)-1;
for(int i=0;i<b;i++)q(i);
for(int i=0;;){
int v=q(i);
if(v>k){
v=q(i=(i-1+n)%n);
while(v>k)v=q(i=(i-1+n)%n);
cout<<"! "<<i+1<<endl,exit(0);
} i=min(n-1,i+b);
}
}
int main(){
int t=1;
// cin>>t;
while(t--)solve();
return flush(),0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using LD = long double;
using PLL = pair<long long, long long>;
using VII = vector<pair<int, int> >;
template <class T>
bool power_2(T v) {
static_assert(std::is_integral<T>::value, "type should be integral");
return v && !(v & (v - 1));
}
template <class T>
istream& operator>>(istream& st, vector<T>& container) {
for (auto& u : container) st >> u;
return st;
}
template <class T>
ostream& operator<<(ostream& st, const vector<T>& container) {
for (auto& u : container) st << u << '\n';
return st;
}
template <class T, size_t N>
istream& operator>>(istream& st, array<T, N>& container) {
for (auto& u : container) st >> u;
return st;
}
template <class T, size_t N>
ostream& operator<<(ostream& st, const array<T, N>& container) {
for (auto u : container) st << u << ' ';
return st;
}
template <class T, class U>
istream& operator>>(istream& st, pair<T, U>& p) {
st >> p.first >> p.second;
return st;
}
template <class T, class U>
ostream& operator<<(ostream& st, pair<T, U> p) {
st << p.first << ' ' << p.second;
return st;
}
template <class T, class U, class V>
pair<T, U> operator*(pair<T, U> p, V val) {
return {p.first * val, p.second * val};
}
template <class T, class U, class V>
pair<T, U> operator/(pair<T, U> p, V val) {
return {p.first / val, p.second / val};
}
template <class T, class U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
template <class T, class U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
template <class T>
T dotProduct(pair<T, T> a, pair<T, T> b) {
return a.first * b.first + a.second * b.second;
}
template <class T>
T crossProduct(pair<T, T> a, pair<T, T> b) {
return a.first * b.second - a.second * b.first;
}
template <class T>
T lengthPow(pair<T, T> a) {
return a.first * a.first + a.second * a.second;
}
template <class T>
LD length(pair<T, T> a) {
return sqrt(lengthPow(a));
}
const int N = 1e6 + 57, inf = 1e9 + 7;
const long long MOD = 1e9 + 7;
const long long INF = 1e18 + 7;
const int M = 155;
const long double PI = acos(-1);
const LD EPS = 1e-12;
bitset<N> bylo;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout << fixed << setprecision(9);
int a, b;
cin >> a >> b;
if (a == 1 && b == 1) {
cout << "1\n1\n0";
return 0;
}
int ile = 0;
int i = 1;
while (a >= i) {
bylo[i] = 1;
a -= i;
++i;
++ile;
}
if (a) {
bylo[i] = 1;
bylo[i - a] = 0;
}
cout << ile << '\n';
for (int j = 0; j <= i; ++j)
if (bylo[j]) cout << j << ' ';
cout << '\n';
vector<int> res;
i = 1;
while (b >= i) {
if (!bylo[i]) {
res.push_back(i);
b -= i;
}
++i;
}
cout << res.size() << '\n';
for (auto u : res) cout << u << ' ';
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c;
cin >> a >> b >> c;
if (min(min(a, b), c) > 3) {
cout << "NO" << endl;
} else {
if ((a == 3 && b == 3 && c == 3) || (a == 1) || (b == 1) || (c == 1) ||
(a == 2 && b == 2) || (a == 2 && c == 2) || (c == 2 && b == 2) ||
(a == 2 && b == 4 && c == 4) || (a == 4 && b == 2 && c == 4) ||
(a == 4 && b == 4 && c == 2)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int inf = 0x3f3f3f3f;
const int bb = 13331;
const int mod = 1e9 + 7;
int a, b, c, d;
int n, m, k;
int ans = 0;
string q;
priority_queue<int, vector<int>, less<int> > w;
void solvea() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> q;
a = 0;
for (int t = 0; t < q.length(); t++) {
if (q[t] == '0') {
if (a > 0) w.push(a);
a = 0;
} else
a++;
}
if (a > 0) w.push(a);
b = 0;
while (w.size() > 0) {
b += w.top();
if (w.size() > 0) w.pop();
if (w.size() > 0) w.pop();
}
cout << b << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solvea();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
return x;
}
const int N = 255, mod = 1e9 + 7;
int n, k, fac[N], inv[N], ans;
void Exgcd(int a, int b, int &x, int &y) {
if (!b)
x = 1, y = 0;
else
Exgcd(b, a % b, y, x), y -= a / b * x;
}
int Qinv(int a) {
int x, y;
Exgcd(a, mod, x, y);
x = (x % mod + mod) % mod;
return x;
}
int C(int n, int m) { return 1LL * fac[n] * inv[m] % mod * inv[n - m] % mod; }
int ksm(int b, int p) {
int base = b, ans = 1;
while (p) {
if (p & 1) ans = (1LL * ans * base) % mod;
p >>= 1;
base = (1LL * base * base) % mod;
}
return ans;
}
int add(int a, int b) { return (a % mod + b % mod) % mod; }
int sub(int a, int b) { return ((a % mod - b % mod) % mod + mod) % mod; }
int main() {
n = read();
k = read();
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = (1LL * fac[i - 1] * i) % mod;
inv[n] = Qinv(fac[n]);
for (int i = n - 1; ~i; i--) inv[i] = (1LL * inv[i + 1] * (i + 1)) % mod;
for (int i = 0; i <= n; i++) {
if (i & 1)
ans = sub(ans, 1LL * C(n, i) *
ksm(sub(1LL * ksm(k - 1, i) * ksm(k, n - i) % mod,
ksm(k - 1, n)),
n) %
mod);
else
ans = add(ans, 1LL * C(n, i) *
ksm(sub(1LL * ksm(k - 1, i) * ksm(k, n - i) % mod,
ksm(k - 1, n)),
n) %
mod);
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50005, M = 256;
int n, q, sl, fh, ans, fa[N], dep[N], vis[N], lst[N], val[N], f[N][M], mx[N][M],
t, h[N], idx;
vector<int> v[N];
int trie[1024][2];
void add(int uu, int vv) {
v[uu].push_back(vv);
v[vv].push_back(uu);
h[uu] = vv;
h[vv] = uu;
}
void ins(int x) {
int rt = 0;
for (int i = 7; i >= 0; --i) {
if (!trie[rt][(x >> i) & 1]) {
trie[rt][(x >> i) & 1] = ++idx;
trie[idx][0] = trie[idx][1] = 0;
}
rt = trie[rt][(x >> i) & 1];
}
}
int query(int pos, int tt) {
int d, v = 0, rt = 0, ret = 0;
for (int i = 7; i >= 0; --i) {
d = ((pos >> i) & 1) ^ 1;
if (trie[rt][d])
rt = trie[rt][d], ret |= 1 << i;
else
rt = trie[rt][d ^= 1];
v |= d << i;
}
return ret << 8 | mx[tt][v];
}
inline void smx(int &x, int y) {
if (x < y) x = y;
}
void dfs(int pos) {
if (dep[pos] >= M) {
idx = 0;
trie[0][0] = trie[0][1] = 0;
int i;
for (i = pos; dep[pos] - dep[i] < M; i = fa[i]) {
smx(mx[pos][val[i] >> 8], ((dep[pos] - dep[i]) ^ val[i]) & 255);
if (vis[val[i] >> 8] != pos) ins(val[i] >> 8), vis[val[i] >> 8] = pos;
}
lst[pos] = i;
for (int i = 0; i < M; i++) f[pos][i] = query(i, pos);
}
for (auto &i : v[pos]) {
if (i == fa[pos]) continue;
dep[i] = dep[pos] + 1;
fa[i] = pos;
dfs(i);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> q;
int t1, t2, dis;
for (int i = 1; i <= n; i++) cin >> val[i];
for (int i = 1; i < n; i++) cin >> t1 >> t2, add(t1, t2);
dep[1] = 1;
dfs(1);
while (q--) {
dis = ans = 0;
for (cin >> t1 >> t2; dep[t2] - dep[t1] >= M; t2 = lst[t2], ++dis)
ans = max(ans, f[t2][dis]);
for (dis <<= 8; t2 != fa[t1]; t2 = fa[t2], ++dis)
ans = max(ans, val[t2] ^ dis);
cout << ans << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair <int, int> pin;
const int N = 405;
const int M = 105;
const ll P = 998244353LL;
int n, c[M];
ll f[2][N][N][3][3], sum[N][N][3][3], g[N][N];
template <typename T>
inline void read(T &X) {
char ch = 0; T op = 1;
for (X = 0; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') op = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
X = (X * 10) + ch - '0';
X *= op;
}
inline void inc(ll &x, ll y) {
x += y;
if (x >= P) x -= P;
}
inline void sub(ll &x, ll y) {
x -= y;
if (x < 0) x += P;
}
inline void clear(int cur) {
for (int j = 0; j <= n; j++)
for (int k = 0; k <= n; k++)
for (int x = 0; x <= 2; x++)
for (int y = 0; y <= 2; y++)
f[cur][j][k][x][y] = 0;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("sample.in", "r", stdin);
clock_t st_clock = clock();
#endif
read(n);
for (int i = 1; i <= 26; i++) read(c[i]);
f[0][0][0][0][0] = 24LL * 24LL;
f[0][1][0][0][1] = 24LL;
f[0][0][1][0][2] = 24LL;
f[0][2][0][1][1] = 1LL;
f[0][1][0][1][0] = 24LL;
f[0][1][1][1][2] = 1LL;
f[0][0][2][2][2] = 1LL;
f[0][1][1][2][1] = 1LL;
f[0][0][1][2][0] = 24LL;
// for (int i = 3; i <= n; i++) {
// int cur = i & 1, pre = cur ^ 1;
// clear(cur);
// for (int j = 0; j <= n; j++)
// for (int k = 0; k <= n; k++) {
// if (j + k > n) break;
// for (int x = 0; x <= 2; x++) {
// inc(f[cur][j][k][0][x], f[pre][j][k][x][0] * 23LL % P);
// inc(f[cur][j][k][0][x], f[pre][j][k][x][1] * 24LL % P);
// inc(f[cur][j][k][0][x], f[pre][j][k][x][2] * 24LL % P);
// if (j >= 1) {
// inc(f[cur][j][k][1][x], f[pre][j - 1][k][x][0]);
// inc(f[cur][j][k][1][x], f[pre][j - 1][k][x][2]);
// }
// if (k >= 1) {
// inc(f[cur][j][k][2][x], f[pre][j][k - 1][x][0]);
// inc(f[cur][j][k][2][x], f[pre][j][k - 1][x][1]);
// }
// }
// }
// }
for (int i = 2; i < n; i++) {
int cur = i & 1, nxt = cur ^ 1;
clear(nxt);
for (int j = 0; j <= n; j++)
for (int k = 0; k <= n; k++) {
for (int x = 0; x <= 2; x++)
for (int y = 0; y <= 2; y++) {
ll now = f[cur][j][k][x][y];
if (now == 0) continue;
if (y == 0) inc(f[nxt][j][k][0][x], now * 23LL % P);
else inc(f[nxt][j][k][0][x], now * 24LL % P);
if (y != 1) inc(f[nxt][j + 1][k][1][x], now);
if (y != 2) inc(f[nxt][j][k + 1][2][x], now);
}
}
// if (i == 2) {
// printf("%lld\n", f[1][0][0][0][0]);
// printf("%lld\n", f[1][1][0][0][1]);
// printf("%lld\n", f[1][0][1][0][2]);
// printf("%lld\n", f[1][2][0][1][1]);
// printf("%lld\n", f[1][1][0][1][0]);
// printf("%lld\n", f[1][1][0][1][2]);
// printf("%lld\n", f[1][0][2][2][2]);
// printf("%lld\n", f[1][0][1][2][1]);
// printf("%lld\n", f[1][0][1][2][0]);
// }
}
// for (int x = 0; x <= 2; x++)
// for (int y = 0; y <= 2; y++)
// for (int j = 0; j <= n; j++)
// for (int k = 0; k <= n; k++)
// inc(g[j][k], f[n & 1][j][k][x][y]);
// for (int i = 0; i <= n; i++)
// for (int j = 0; j <= n; j++)
// printf("%lld%c", g[i][j], " \n"[j == n]);
for (int x = 0; x <= 2; x++)
for (int y = 0; y <= 2; y++) {
int cur = n & 1;
for (int j = 0; j <= n; j++)
for (int k = 0; k <= n; k++) {
sum[j][k][x][y] = f[cur][j][k][x][y];
if (k >= 1) inc(sum[j][k][x][y], sum[j][k - 1][x][y]);
}
for (int j = 1; j <= n; j++)
for (int k = 0; k <= n; k++)
inc(sum[j][k][x][y], sum[j - 1][k][x][y]);
}
ll ans = 0;
for (int x = 0; x <= 2; x++)
for (int y = 0; y <= 2; y++)
inc(ans, sum[n][n][x][y]);
// printf("%lld\n", ans);
for (int a = 1; a <= 26; a++)
for (int j = 0; j <= n; j++)
for (int k = c[a] + 1; k <= n; k++)
for (int x = 0; x <= 2; x++)
for (int y = 0; y <= 2; y++)
sub(ans, f[n & 1][j][k][x][y]);
// printf("%lld\n", ans);
for (int a = 1; a <= 26; a++)
for (int b = a + 1; b <= 26; b++) {
for (int x = 0; x <= 2; x++)
for (int y = 0; y <= 2; y++) {
// ans += sum[n][n] + sum[c[a]][c[b]] - sum[n][c[b]] - sum[c[a]][n];
inc(ans, sum[n][n][x][y]);
inc(ans, sum[c[a]][c[b]][x][y]);
sub(ans, sum[n][c[b]][x][y]);
sub(ans, sum[c[a]][n][x][y]);
}
}
printf("%lld\n", ans);
#ifndef ONLINE_JUDGE
clock_t ed_clock = clock();
printf("time = %f ms\n", (double)(ed_clock - st_clock) / CLOCKS_PER_SEC * 1000);
#endif
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100006;
int n;
vector<int> e[maxn];
int c[maxn];
bool check(int x, int p, int o) {
if (p != 0 && c[x] != c[p]) return false;
for (auto i : e[x])
if (i != p && i != o)
if (!check(i, x, o)) return false;
return true;
}
bool check_point(int o) {
for (auto i : e[o])
if (!check(i, 0, o)) return false;
return true;
}
void judge() {
for (int i = 1; i <= n; ++i)
for (auto j : e[i])
if (c[i] != c[j]) {
if (check_point(i)) {
cout << "YES\n" << i << endl;
return;
}
if (check_point(j)) {
cout << "YES\n" << j << endl;
return;
}
cout << "NO\n";
return;
}
cout << "YES\n1\n";
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) e[i].clear();
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i <= n; ++i) cin >> c[i];
judge();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> elements;
int n;
long long a, answer = 1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
elements.push_back(a);
}
sort(elements.begin(), elements.end());
for (int i = 0; i < elements.size(); i++) {
if (answer <= elements[i]) {
answer += 1;
}
}
cout << answer;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
int a, b, l, r, n, ans;
char s[N];
bool vis[30];
int dfs(char ch) {
int res = 0;
for (int i = 0; i < a; i++) s[i] = (i + 'a');
for (int i = a; i < a + b; i++) s[i] = ch;
memset(vis, 0, sizeof(vis));
for (int i = b; i < a + b; i++) vis[s[i] - 'a'] = 1;
int p = a + b, cnt = 0;
while (p < 2 * a + b) {
while (vis[cnt]) cnt++;
s[p] = cnt + 'a';
p++;
cnt++;
}
for (int i = 2 * a + b; i < n; i++) s[i] = s[i - 1];
memset(vis, 0, sizeof(vis));
if (l <= r) {
for (int i = l; i <= r; i++)
if (!vis[s[i] - 'a']) {
res++;
vis[s[i] - 'a'] = 1;
}
} else {
for (int i = 0; i <= r; i++)
if (!vis[s[i] - 'a']) {
res++;
vis[s[i] - 'a'] = 1;
}
for (int i = l; i < n; i++)
if (!vis[s[i] - 'a']) {
res++;
vis[s[i] - 'a'] = 1;
}
}
return res;
}
int main() {
scanf("%d%d%d%d", &a, &b, &l, &r);
l--;
r--;
if (a <= b)
ans = a + 1;
else
ans = 2 * a - b;
n = 2 * (a + b);
if (r - l < n) {
l %= n;
r %= n;
for (int i = 0; i < a; i++) ans = min(ans, dfs('a' + i));
}
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
string smallest(string s) {
if (s.length() % 2 == 1) return s;
string s1 = smallest(s.substr(0, s.length() / 2));
string s2 = smallest(s.substr(s.length() / 2, s.length()));
if (s1 < s2)
return s1 + s2;
else
return s2 + s1;
}
int main() {
cin >> s1 >> s2;
if (smallest(s1) == smallest(s2))
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
using namespace std;
int num[1001];
long long n;
long long check(long long k) {
long long p = 0, v = 0;
long long t = n;
while (t) {
if (t >= k) {
p += k;
t -= k;
} else {
p += t;
t = 0;
}
v += t / 10;
t -= t / 10;
}
if (v <= p)
return 1;
else
return 0;
}
int main() {
cin >> n;
long long l = 1;
long long r = 1e18;
long long ans = 0;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9999999999;
long long dp[25][2521][50];
long long a[25];
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long b[3000], k;
long long dfs(long long pos, long long m, bool limit, long long sta) {
if (pos <= 0) {
return m % sta == 0;
}
if (dp[pos][m][b[sta]] != -1 && !limit) return dp[pos][m][b[sta]];
long long up = limit ? a[pos] : 9;
long long ans = 0;
for (long long i = 0; i <= up; ++i) {
if (i != 0)
ans +=
dfs(pos - 1, (m * 10 + i) % 2520, limit && i == a[pos], lcm(sta, i));
else
ans += dfs(pos - 1, (m * 10 + i) % 2520, limit && i == a[pos], sta);
}
if (!limit) dp[pos][m][b[sta]] = ans;
return ans;
}
void pre() {
k = 0;
for (long long i = 1; i <= 2520; ++i) {
if (2520 % i == 0) b[i] = ++k;
}
}
long long solve(long long x) {
long long tot = 0;
while (x) {
a[++tot] = x % 10;
x /= 10;
}
return dfs(tot, 0, 1, 1);
}
int main() {
long long t;
scanf("%lld", &t);
pre();
memset(dp, -1, sizeof(dp));
while (t--) {
long long x, y;
scanf("%I64d%I64d", &x, &y);
long long ans = solve(y) - solve(x - 1);
printf("%I64d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long> q;
vector<pair<long, long long> > vv[100001];
long n, m, i, j, p[100001], x, y, c;
long long d[100001];
void prt(long x) {
if (x != 1) prt(p[x]);
cout << x << " ";
}
int main() {
cin >> n >> m;
while (m--) {
cin >> x >> y >> c;
vv[x].push_back(make_pair(y, c));
vv[y].push_back(make_pair(x, c));
}
fill(d, d + n + 1, 2e18);
d[1] = 0;
q.push(1);
while (!q.empty()) {
int u = q.top();
q.pop();
for (auto it : vv[u]) {
int v = it.first;
long long t = d[u] + it.second;
if (d[v] > t) {
p[v] = u;
d[v] = t;
q.push(v);
}
}
}
if (d[n] == 2e18) {
cout << -1;
return 0;
}
prt(n);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long s, t;
vector<vector<pair<long long, long long> > > adj[2];
vector<vector<pair<long long, long long> > > temp1;
vector<vector<pair<long long, long long> > > temp2;
const long long mod = 3000000517;
long long dis[2][100005];
long long vis[100005];
vector<long long> comp;
vector<long long> temp;
long long parent[100004];
void dikstra(long long x) {
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
qq;
if (x == 0) {
dis[x][s] = 0;
qq.push({0, s});
} else {
dis[x][t] = 0;
qq.push({0, t});
}
while (!qq.empty()) {
pair<long long, long long> p = qq.top();
qq.pop();
if (dis[x][p.second] < p.first) continue;
for (auto i : adj[x][p.second]) {
if (dis[x][i.first] > p.first + i.second) {
dis[x][i.first] = p.first + i.second;
qq.push({dis[x][i.first], i.first});
}
}
}
}
void dfs(long long ver) {
vis[ver] = 1;
for (auto i : temp1[ver]) {
if (!vis[i.first]) dfs(i.first);
}
comp.push_back(ver);
}
void dfs2(long long ver) {
vis[ver] = 1;
temp.push_back(ver);
for (auto i : temp2[ver]) {
if (!vis[i.first]) dfs2(i.first);
}
}
long long dp[2][100005];
long long fi[100005];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
long long n, m;
cin >> n >> m >> s >> t;
adj[0].resize(n + 1);
adj[1].resize(n + 1);
temp1.resize(n + 1);
temp2.resize(n + 1);
for (long long i = 1; i <= n; i++) {
dis[0][i] = 1e17;
dis[1][i] = 1e17;
}
long long x, y, z;
vector<pair<pair<long long, long long>, long long> > pp;
for (long long i = 0; i < m; i++) {
cin >> x >> y >> z;
adj[0][x].push_back({y, z});
adj[1][y].push_back({x, z});
pp.push_back({{x, y}, z});
}
dikstra(0);
dikstra(1);
long long index = 0;
vector<long long> lol;
for (auto i : pp) {
long long mn = dis[0][i.first.first] + i.second + dis[1][i.first.second];
if (mn == dis[0][t]) {
lol.push_back(index);
temp1[i.first.first].push_back({i.first.second, index});
temp2[i.first.second].push_back({i.first.first, index});
}
index++;
}
dfs(s);
reverse(comp.begin(), comp.end());
fill_n(vis, n + 1, 0);
for (auto i : comp) {
if (!vis[i]) {
temp.clear();
dfs2(i);
for (auto j : temp) parent[j] = i;
}
}
temp1.clear();
temp1.resize(n + 1);
temp2.clear();
temp2.resize(n + 1);
for (auto i : lol) {
long long x = parent[pp[i].first.first];
long long y = parent[pp[i].first.second];
temp1[x].push_back({y, i});
temp2[y].push_back({x, i});
}
comp.clear();
fill_n(vis, n + 1, 0);
dfs(parent[s]);
reverse(comp.begin(), comp.end());
dp[0][parent[s]] = 1;
for (auto i : comp) {
for (auto j : temp2[i]) {
dp[0][i] += dp[0][j.first];
dp[0][i] %= mod;
}
}
temp1.clear();
temp1.resize(n + 1);
temp2.clear();
temp2.resize(n + 1);
for (auto i : lol) {
long long x = parent[pp[i].first.first];
long long y = parent[pp[i].first.second];
temp2[x].push_back({y, i});
temp1[y].push_back({x, i});
}
comp.clear();
fill_n(vis, n + 1, 0);
dfs(parent[t]);
reverse(comp.begin(), comp.end());
dp[1][parent[t]] = 1;
for (auto i : comp) {
for (auto j : temp2[i]) {
dp[1][i] += dp[1][j.first];
dp[1][i] %= mod;
}
}
fill_n(fi, m, -1);
for (auto i : lol) {
long long x = parent[pp[i].first.first];
long long y = parent[pp[i].first.second];
if ((dp[0][x] * dp[1][y]) % mod == dp[0][parent[t]]) {
fi[i] = 0;
}
}
long long mini = dis[0][t];
for (long long i = 0; i < m; i++) {
if (fi[i] == -1) {
long long mn = dis[0][pp[i].first.first] + dis[1][pp[i].first.second];
long long aa = mini - mn - 1;
if (pp[i].second > aa) {
if (aa >= 1) {
fi[i] = pp[i].second - aa;
}
}
}
}
for (long long i = 0; i < m; i++) {
if (fi[i] == -1)
cout << "NO\n";
else if (fi[i] == 0)
cout << "YES\n";
else
cout << "CAN " << fi[i] << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
constexpr int inf = 1e9;
constexpr int N = 3000 + 5;
void solve() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
auto get = [&](int curr, int last) {
int best = 1e9;
if (curr >= last) best = curr;
int prev = 0, f = 1000;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 10; j++) {
int now = prev + (curr % f) + (j * f);
if (now >= last) best = min(best, now);
}
prev = curr - curr % f;
f /= 10;
}
return best;
};
arr[0] = get(arr[0], 1000);
if (arr[0] == inf) {
cout << "No solution\n";
return;
}
for (int i = 1; i < n; i++) {
arr[i] = get(arr[i], arr[i - 1]);
if (arr[i] == inf) {
cout << "No solution\n";
return;
}
}
if (arr[n - 1] > 2011) {
cout << "No solution\n";
return;
}
for (int a : arr) cout << a << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
std::cout << std::fixed << std::setprecision(20);
;
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, voy, parado = 1;
long long mov = 0;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> voy;
mov += voy - parado;
if (parado > voy) mov += n;
parado = voy;
}
cout << mov;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int MOD = 1000000007;
cin >> n;
int p[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
long long dp[n + 1][2];
dp[0][0] = dp[0][1] = 0;
dp[1][0] = 0;
dp[1][1] = 1;
for (int i = 2; i <= n; i++) {
dp[i][0] = (dp[i - 1][1] + 1) % MOD;
dp[i][1] =
(((2 * dp[i][0]) % MOD - dp[p[i - 1]][0] + MOD) % MOD + 1 + MOD) % MOD;
}
cout << (dp[n][1] + 1) % MOD;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1005;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, x, y, xt, yt, v;
long double mn = 1000000000.0, dis;
cin >> x >> y >> n;
for (long long i = 0; i < n; i++) {
cin >> xt >> yt >> v;
dis = sqrt(abs(x - xt) * abs(x - xt) * 1.0 +
abs(y - yt) * abs(y - yt) * 1.0) /
(v * 1.0);
mn = min(mn, dis);
}
cout << fixed << setprecision(6) << mn;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[10][10], x1, x2, x3, tri = 2187, res1 = 1234567890, res2 = 0,
was[10], kol = 7, t1, t2, YES[10];
string s[] = {"Anka", "Chapay", "Cleo", "Troll",
"Dracul", "Snowy", "Hexadecimal"};
void dfs(int s, int q) {
++t1;
++was[s];
for (int i = 0; i < kol; ++i)
if (YES[i] == q && a[s][i]) ++t2;
for (int i = 0; i < kol; ++i)
if (YES[i] == q && !was[i]) dfs(i, q);
}
int main() {
scanf("%d", &n);
memset(a, 0, sizeof a);
for (int i = 0; i < n; ++i) {
string name1, likes, name2;
cin >> name1 >> likes >> name2;
int x = 0, y = 0;
for (int i = 0; i < kol; ++i)
if (name1 == s[i]) x = i;
for (int i = 0; i < kol; ++i)
if (name2 == s[i]) y = i;
a[x][y] = 1;
}
cin >> x1 >> x2 >> x3;
for (int i = 0; i < tri; ++i) {
int kol1 = 0, yes = 0;
memset(YES, 0, sizeof YES);
int num = i;
while (num) {
++YES[kol1] = num % 3;
num /= 3;
++kol1;
}
for (int i = 0; i < kol; ++i)
if (YES[i] == 0) {
++yes;
break;
}
for (int i = 0; i < kol; ++i)
if (YES[i] == 1) {
++yes;
break;
}
for (int i = 0; i < kol; ++i)
if (YES[i] == 2) {
++yes;
break;
}
if (yes == 3) {
long long ex1, ex2, ex3, maxf = 0;
t1 = 0, t2 = 0;
for (int i = 0; i < kol; ++i)
if (YES[i] == 0) {
memset(was, 0, sizeof was);
dfs(i, 0);
break;
}
ex1 = x1 / t1;
maxf += t2;
t1 = 0, t2 = 0;
for (int i = 0; i < kol; ++i)
if (YES[i] == 1) {
memset(was, 0, sizeof was);
dfs(i, 1);
break;
}
ex2 = x2 / t1;
maxf += t2;
t1 = 0, t2 = 0;
for (int i = 0; i < kol; ++i)
if (YES[i] == 2) {
memset(was, 0, sizeof was);
dfs(i, 2);
break;
}
ex3 = x3 / t1;
maxf += t2;
long long maxex = max(ex1, max(ex2, ex3));
long long minex = min(ex1, min(ex2, ex3));
if (maxex - minex < res1) {
res1 = maxex - minex;
res2 = maxf;
}
if (maxex - minex == res1 && res2 < maxf) {
res2 = maxf;
}
}
}
cout << res1 << ' ' << res2;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
long long n, k, t;
cin >> n >> k >> t;
long long ans = k;
if (t < k) ans -= (k - t);
if (t > n) ans -= (t - n);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
int n, k;
cin >> n >> k;
int o = n - (k - 1);
int e = n - (2 * (k - 1));
if ((o % 2 == 0 || o <= 0) && (e % 2 == 1 || e <= 0)) {
cout << "NO\n";
} else if (o > 0 && o % 2 == 1) {
cout << "YES\n";
cout << o << " ";
for (int i = 2; i <= k; i++) cout << 1 << " ";
cout << "\n";
} else if (e > 0 && e % 2 == 0) {
cout << "YES\n";
cout << e << " ";
for (int i = 2; i <= k; i++) cout << 2 << " ";
cout << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
int main() {
long long tc;
cin >> tc;
while (tc--) {
long long x, y;
cin >> x >> y;
if (y / x >= 2) {
cout << x << " " << 2 * x;
cout << "\n";
} else {
cout << -1 << ' ' << -1;
cout << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
template <typename T>
void cins(T &first) {
cin >> first;
}
template <typename T, typename... Ts>
void cins(T &first, T &second, Ts &...rest) {
cin >> first;
cins(second, rest...);
}
const long long mod = pow(10, 9) + 7;
const long long N = 3e5;
const long long inf = LLONG_MAX;
const long long infn = LLONG_MIN;
constexpr long long dx4[4] = {1, 0, -1, 0};
constexpr long long dy4[4] = {0, 1, 0, -1};
constexpr long long dx8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
constexpr long long dy8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
void iluzn() {
long long a, b, n;
cins(a, b, n);
long long x[3] = {a, b, a ^ b};
cout << x[n % 3] << "\n";
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1;
cin >> t;
while (t--) iluzn();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 99, a = 0, k = 0;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
k = v[0];
for (int i = 0; i < n - 1; i++) {
a += v[i] - v[i + 1];
if (a < 0) {
k += -a;
a = 0;
}
}
cout << k;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[2 * n];
cin >> arr[0];
bool flag = 0;
for (int i = 1; i <= 2 * n - 1; i++) {
cin >> arr[i];
if (!flag && arr[i] != arr[0]) flag = 1;
}
if (!flag)
cout << -1;
else {
sort(arr, arr + 2 * n);
for (int i = 0; i <= 2 * n - 1; i++) cout << arr[i] << " ";
}
}
| 1 |
#include<bits/stdc++.h>
#include<iostream>
#define mi map<int,int>
#define umi unordered_map<int,int>
#define pii pair<int,int>
#define pll pair<long long int,long long int>
#define si set<int>
#define st stack<int>
#define di deque<int>
#define qi queue<int>
#define pq priority_queue<int>
#define dl deque<long long int>
#define usi unordered_set<int>
#define vi vector<int>
#define vl vector<long long int>
#define ll long long int
#define pb push_back
#define mk make_pair
#define all(v) v.begin(),v.end()
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define M1 1000000007
#define M2 998244353
#define I1 1000000001
#define I2 1000000000000000001
#define rev(v) reverse(v.begin(),v.end());
#define asort(v) sort(v.begin(),v.end())
#define dsort(v) sort(v.begin(),v.end(),greater<int>())
double PI=3.14159265358979323846;
using namespace std;
ll gcd(ll a,ll b){if(b==0) return a;else return gcd(b,a%b);}
bool isprime(ll a){for(int i=2;i<=sqrt(a);i++){if(a%i==0) return false;} return true;}
ll lcm(ll a,ll b){return (a*b)/gcd(a,b);}
// the number of zeros at the beginning of the bit representation //
int prefixzero(int x) {return __builtin_clz(x);}
// the number of zeros at the end of the bit representation //
int suffixzero(int x) {return __builtin_ctz(x);}
// the number of ones in the bit representation //
int numberone(int x) {return __builtin_popcount(x);}
// push the value of array element //
void read(vector<int> &v,int n) {for(int i=0;i<n;i++) cin>>v[i];}
void readl(vector<ll> &v,ll n) {for(ll i=0;i<n;i++) cin>>v[i];}
// to check the given number prime or not //
vector<bool>sprime(int n)
{
vector<bool>prime(n+1,true);
prime[0]=false;
prime[1]=false;
for(ll i=2;i*i<=n;i++)
{
if(prime[i])
{
for(ll j=i*i;j<=n;j+=i) prime[j]=false;
}
}
return prime;
}
// return the value of x and y in given equation of ax+by=gcd(a,b) //
tuple<int,int,int> GCD(int a,int b)
{
if(b==0) return {1,0,a};
else
{
int x,y,g;
tie(x,y,g)=GCD(b,a%b);
return {y,x-(a/b)*y,g};
}
}
// to find the power of given number in logn time //
ll pw(ll base,ll power,ll mode)
{
ll res=1;
base=base%mode;
while(power!=0)
{
if(power&1) {power-=1;res=(res*base)%mode;}
else {power/=2;base=(base*base)%mode;}
}
return res;
}
// return total prime factor//
vector<ll>factor(ll n)
{
vl fac;
for(ll i=2;i<=sqrt(n);i++)
{
while(n%i==0)
{
fac.pb(i);
n/=i;
}
}
if(n!=1) fac.pb(n);
return fac;
}
// the equation ax+by=c give the positive solution or not //
bool sol(ll a,ll b,ll c)
{
if(c%gcd(a,b)==0)
{
ll m=c/gcd(a,b);
double x1,y1,g;
tie(x1,y1,g)=GCD(a,b);
x1*=m;
y1*=m;
// general solution xi=x1+i(b/g),yi=y1-i(a/g) where i belong (-inf,inf)//
ll x2=ceil(-1.0*x1*(g/b));
ll y2=floor(y1*(g/a)*1.0);
if(x2<=y2) return true;
}
return false;
}
// return the fn and fn+1 of fibonacci number//
pair<ll,ll>fib(ll n)
{
if(n==0) return {0,1};
auto p=fib(n>>1);
ll c =p.first*(2 *p.second-p.first);
ll d =p.first*p.first+p.second*p.second;
if (n & 1) return {d,c + d};
else return {c,d};
}
// hash the string in given string //
ll gethash(string &keys)
{
ll p=31;
ll m=1e9+9;
ll hash_value=0;
ll p_pow=1;
for(char c:keys)
{
hash_value=(hash_value+(c-'a'+1)*p_pow)%m;
p_pow=(p_pow*p)%m;
}
return hash_value;
}
// return the proper prifix array of given string //
vector<int>p_prefix(string s)
{
int n=s.size();
vector<int>pi(n);
int j=0;
for(int i=1;i<n;i++)
{
j=pi[i-1];
while(j>0&&s[i]!=s[j]) j=pi[j-1];
if(s[i]==s[j]) j++;
pi[i]=j;
}
return pi;
}
// dfs traversal for graph and find the minimum distance from root node //
/*void dfs(int node,int d)
{
visit[node]=1;
dist[node]=d;
for(int child:ar[node])
{
if(visit[child]==0) dfs(child,dist[node]+1);
}
}*/
// bfs traversal for graph and find the minimum distance from root node //
/*void bfs(int node)
{
queue<int>q;
q.push(node);
visit[node]=1;
dist[node]=0;
while(!q.empty())
{
int curr=q.front();
q.pop();
for(int child:ar[curr])
{
if(visit[child]==0)
{
q.push(child);
dist[child]=dist[curr]+1;
visit[child]=1;
}
}
}
}*/
//---------------------------------START THE CODE------------------------------//
void solve()
{
int n;cin>>n;
vi v(2*n);
read(v,2*n);
asort(v);
for(int i=0;i<n;i++)
{
cout<<v[i]<<" "<<v[2*n-i-1]<<" ";
}
cout<<"\n";
return;
}
int main()
{
IOS;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll t;cin>>t;
while(t--) {solve();}
return 0;
}
/*-----------------END OF CODE------------------*/ | 0 |
#include <bits/stdc++.h>
int main() {
int x;
scanf("%d", &x);
if (x == 0)
printf("1\n");
else if (x % 4 == 0)
printf("6\n");
else if (x % 4 == 1)
printf("8\n");
else if (x % 4 == 2)
printf("4\n");
else
printf("2\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXW = 1000100, MAXN = 1000100, INF = 0x3f3f3f3f;
vector<pair<int, int>> a[MAXW], r[MAXW];
int n, w, l;
long long ans;
struct maxqueue {
private:
stack<int, list<int>> s1, s2;
int mx = -INF;
public:
inline void insert(int x) { mx = max(mx, x), s2.push(x); }
inline int get() { return max((s1.empty() ? -INF : s1.top()), mx); }
inline void clear() {
s1 = stack<int, list<int>>(), s2 = stack<int, list<int>>(), mx = -INF;
}
inline bool empty() { return s1.empty() && s2.empty(); }
void pop() {
if (s1.empty()) {
mx = -INF;
while (!s2.empty())
s1.push(max(s2.top(), s1.empty() ? -INF : s1.top())), s2.pop();
}
s1.pop();
}
} m[MAXN];
int main() {
for (scanf("%d %d", &n, &w); n--;) {
scanf("%d", &l);
if (l < w) {
a[1].emplace_back(0, n);
r[w - l + 1].emplace_back(0, n);
a[l + 1].emplace_back(0, n);
r[w + 1].emplace_back(0, n);
}
for (int i = 1, x; i <= l; ++i) {
scanf("%d", &x);
a[i].emplace_back(x, n);
r[w - l + i + 1].emplace_back(x, n);
}
}
for (int i = 1; i <= w; ++i) {
for (const auto [x, arr] : a[i]) {
ans -= (m[arr].empty() ? 0 : m[arr].get());
m[arr].insert(x);
ans += (m[arr].empty() ? 0 : m[arr].get());
}
for (const auto [x, arr] : r[i]) {
ans -= (m[arr].empty() ? 0 : m[arr].get());
m[arr].pop();
ans += (m[arr].empty() ? 0 : m[arr].get());
}
printf("%lld ", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[555];
int cnt[555][27][2];
int dp[555][27][27];
int A[555][27][27];
int B[555][27][27];
void rec(int r, int a, int b) {
if (r == 0) return;
rec(r - 1, A[r][a][b], B[r][a][b]);
for (int i = 0; i < m; i++) {
if (i & 1)
cout << char(b + 'a');
else
cout << char(a + 'a');
}
cout << "\n";
}
int main() {
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 < 26; j++) {
for (int k = 0; k < 26; k++) {
dp[i][j][k] = i ? (n * m + 1) : 0;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cnt[i][s[i][j] - 'a'][j % 2]++;
}
}
for (int i = 0; i < n; i++) {
vector<tuple<int, int, int> > v;
for (int j = 0; j < 26; j++) {
for (int k = 0; k < 26; k++) {
if (j != k) {
v.push_back(make_tuple(dp[i][j][k], j, k));
}
}
}
sort(v.begin(), v.end());
for (int j = 0; j < 26; j++) {
for (int k = 0; k < 26; k++) {
if (j != k) {
int ind = 0;
while (get<1>(v[ind]) == j || get<2>(v[ind]) == k) ind++;
int a = get<1>(v[ind]);
int b = get<2>(v[ind]);
dp[i + 1][j][k] = dp[i][a][b] + m - cnt[i][j][0] - cnt[i][k][1];
A[i + 1][j][k] = a;
B[i + 1][j][k] = b;
}
}
}
}
int lastA = -1;
int lastB = -1;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < 26; j++) {
if (i == j) continue;
if (lastA == -1 || dp[n][lastA][lastB] > dp[n][i][j]) {
lastA = i;
lastB = j;
}
}
}
cout << dp[n][lastA][lastB] << "\n";
rec(n, lastA, lastB);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, h1[100010], h2[100010], dp[100010][3];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> h1[i];
for (int i = 1; i <= n; i++) cin >> h2[i];
dp[1][0] = 0, dp[1][1] = h1[1], dp[1][2] = h2[1];
for (int i = 2; i <= n; i++) {
dp[i][0] = max({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]});
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + h1[i];
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + h2[i];
}
cout << max({dp[n][0], dp[n][1], dp[n][2]}) << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cnt = 0;
int arr[200004];
cin >> n;
for (int i = 0; i < n; i++) arr[i] = i;
cnt += n * (n - 1) / 2;
for (int j = n - 1; j > 0; j--) {
for (int i = 0; i < j; i++) cnt += arr[i];
cnt++;
}
cnt++;
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
std::vector<double> a(n);
double sum = 0, p = 0, x;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a.begin(), a.end());
if (round(sum / n) == 5) {
cout << "0" << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (a[i] < 5) {
sum += (5.0 - a[i]);
x = round(sum / n);
p++;
if (x == 5) {
cout << p << endl;
return 0;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n, m, q;
scanf("%d%d%d%d\n", &k, &n, &m, &q);
map<string, int> mp;
vector<string> sl;
for (int i = 0; i < n; i++) {
string s;
getline(cin, s);
mp.insert(make_pair(s, i));
sl.push_back(s);
}
vector<vector<int> > v;
vector<string> st;
for (int i = 0; i < m; i++) {
string s, s1 = "";
getline(cin, s);
int p = 0, a;
for (int i = 0; i < s.size(); i++) {
if (s[i] == ':') {
s1 = s.substr(0, i - p);
v.push_back(vector<int>(n, 0));
st.push_back(s1);
p = i + 2;
i += 1;
} else if (s[i] == ' ') {
a = mp[s.substr(p, i - p)];
p = i + 1;
} else if (s[i] == ',') {
int b = atoi(s.substr(p, i - p).c_str());
v[v.size() - 1][a] = b;
p = i + 2;
i++;
}
}
v[v.size() - 1][a] = atoi(s.substr(p).c_str());
}
vector<vector<int> > fr(k, vector<int>(n, 0)), sp(k, vector<int>(m, 0));
for (int i = 0; i < q; i++) {
int a;
string s;
cin >> a >> s;
a--;
int b = mp[s];
fr[a][b]++;
for (int j = 0; j < m; j++) {
bool fl = 1;
for (int z = 0; z < n; z++)
if (fr[a][z] < v[j][z]) {
fl = 0;
break;
}
if (fl) {
sp[a][j]++;
for (int z = 0; z < n; z++) fr[a][z] -= v[j][z];
break;
}
}
}
for (int i = 0; i < k; i++) {
vector<pair<string, int> > ans;
for (int j = 0; j < m; j++)
if (sp[i][j]) ans.push_back(make_pair(st[j], sp[i][j]));
for (int j = 0; j < n; j++)
if (fr[i][j]) ans.push_back(make_pair(sl[j], fr[i][j]));
cout << (int)ans.size() << endl;
sort(ans.begin(), ans.end());
for (int j = 0; j < ans.size(); j++)
cout << ans[j].first << ' ' << ans[j].second << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 105;
int n;
vector<string> v;
map<string, int> M;
char s[N];
string str, sol;
int cnt[30], cnt2[30];
int cmp(string a, string b) { return a.size() < b.size(); }
pair<int, int> hsh() {}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("? %d %d\n", 1, 1);
fflush(stdout);
scanf("%s", s);
printf("! %s\n", s);
fflush(stdout);
return 0;
}
printf("? %d %d\n", 2, n);
fflush(stdout);
for (int i = 0; i < n * (n - 1) / 2; ++i) {
scanf("%s", s);
str = s;
sort(str.begin(), str.end());
M[str]++;
}
printf("? %d %d\n", 1, n);
fflush(stdout);
for (int i = 0; i < (n + 1) * n / 2; ++i) {
scanf("%s", s);
str = s;
sort(str.begin(), str.end());
if (M[str]) {
M[str]--;
continue;
}
v.push_back(str);
}
sort(v.begin(), v.end(), cmp);
sol = "";
for (int i = 0; i < v.size(); ++i) {
memset(cnt2, 0, sizeof cnt2);
for (char c : v[i]) {
cnt2[c - 'a']++;
}
for (int i = 0; i < 26; ++i) {
if (cnt[i] != cnt2[i]) sol += 'a' + i;
cnt[i] = cnt2[i];
}
}
printf("! %s\n", sol.c_str());
fflush(stdout);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i;
scanf("%d", &n);
scanf("%d", &k);
int tot = (n * (n - 1)) / 2;
if (tot > k) {
for (int i = (int)0; i < (int)n; ++i) {
printf("0 %d\n", i + 1);
}
} else
printf("no solution\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int const mod = 1000000007;
long long int countDivisors(long long int n) {
long long int cnt = 0;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
return cnt;
}
long long int power(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2) % mod;
if (y % 2 == 0)
return ((temp) * (temp)) % mod;
else
return (((x % mod)) * ((temp * temp) % mod)) % mod;
}
long long int gcd1(long long int a, long long int b) {
if (a == 0) return b;
return gcd1(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd1(a, b);
}
long long int dis[2009][2009];
long long int dirx[4] = {0, -1, 0, 1};
long long int diry[4] = {-1, 0, 1, 0};
long long int cost[4] = {1, 0, 0, 0};
char arr[2009][2009];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m, r, l, x, y;
cin >> n >> m;
cin >> x >> y;
cin >> l >> r;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dis[i][j] = 100000000000000000;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> arr[i][j];
}
}
queue<pair<long long int, long long int> > q;
q.push({x, y});
dis[x][y] = 0;
pair<long long int, long long int> p;
long long int xx, yy;
while (!q.empty()) {
p = q.front();
q.pop();
if (arr[p.first][p.second] == '*') continue;
for (int j = 0; j < (int)4; j++) {
xx = p.first + dirx[j];
yy = p.second + diry[j];
if (xx >= 1 && xx <= n && yy >= 1 && yy <= m && arr[xx][yy] != '*') {
if (dis[p.first][p.second] + cost[j] < dis[xx][yy]) {
dis[xx][yy] = dis[p.first][p.second] + cost[j];
q.push({xx, yy});
}
}
}
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (j > y) {
if (dis[i][j] <= l && (j - y) + dis[i][j] <= r) {
ans++;
}
} else {
if (dis[i][j] <= l && dis[i][j] - (y - j) <= r) {
ans++;
}
}
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string info[20005];
string rO(string a, int i) {
if (i == -3) return "";
if (i == -2) return "~";
if (i == -1) return a;
return a.substr(0, i) + a.substr(i + 1);
}
bool ccomp(array<int, 3> a, array<int, 3> b) {
string a1, b1;
a1 = rO(info[a[0]], a[1]);
b1 = rO(info[b[0]], b[1]);
return ((a1).compare(b1) < 0);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> info[i];
}
vector<array<int, 3>> save;
save.push_back({0, -3, 1});
save.push_back({0, -2, 0});
int next[20005];
for (int i = 0; i < n; i++) {
deque<array<int, 3>> start;
deque<array<int, 3>> end;
int wLen = info[i].length();
next[wLen - 1] = wLen;
for (int z = wLen - 2; z >= 0; z--) {
if (info[i][z] != info[i][z + 1])
next[z] = z + 1;
else
next[z] = next[z + 1];
}
for (int z = 0; z < wLen; z++) {
if (next[z] == wLen || info[i][next[z]] < info[i][z]) {
start.push_back({i, z, -1});
} else {
end.push_front({i, z, -1});
}
}
vector<array<int, 3>> temp;
for (auto a : start) {
temp.push_back(a);
if (a[1] == wLen - 1) temp.push_back({i, -1, -1});
}
for (auto a : end) {
temp.push_back(a);
if (a[1] == wLen - 1) temp.push_back({i, -1, -1});
}
vector<array<int, 3>> newS;
int s = 0;
auto it = save.begin();
auto it1 = temp.begin();
while (it1 != temp.end()) {
array<int, 3> curr = (*it);
array<int, 3> curr1 = (*it1);
while (!ccomp(curr1, curr)) {
s = (s + curr[2]) % 1000000007;
curr = (*(++it));
}
newS.push_back({curr1[0], curr1[1], s});
it1++;
}
newS.push_back({i, -2, 0});
save = newS;
}
int ans = 0;
for (auto a : save) {
ans = (ans + a[2]) % 1000000007;
}
cout << ans << "\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, sub[1111], x, y, ct, pa[1111], mn, cur, cnt, A, B, pos, arr[1111];
vector<int> g[1111];
pair<int, int> a[1111];
void dfs(int i, int fa) {
sub[i] = 1;
pa[i] = fa;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa) continue;
dfs(to, i);
sub[i] += sub[to];
}
}
void dft(int i, int fa, int dep) {
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa) continue;
printf("%d %d %d\n", i, to, arr[cur] - dep);
cur++;
dft(to, i, arr[cur - 1]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
mn = 1e9;
for (int i = 1; i <= n; i++) {
cur = 0;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == pa[i])
cur = max(cur, n - sub[i]);
else
cur = max(cur, sub[to]);
}
if (cur < mn) {
ct = i;
mn = cur;
}
}
for (int j = 0; j < g[ct].size(); j++) {
int to = g[ct][j];
if (to == pa[ct]) {
a[++cnt] = make_pair(n - sub[ct], to);
} else {
a[++cnt] = make_pair(sub[to], to);
}
}
sort(a + 1, a + cnt + 1);
reverse(a + 1, a + cnt + 1);
for (int i = 1; i <= cnt; i++) {
A += a[i].first;
B = n - 1 - A;
if (A * B + A >= (2 * n * n / 9)) {
pos = i;
break;
}
}
for (int i = 1; i <= A; i++) arr[i] = i;
cur = 1;
for (int i = 1; i <= pos; i++) {
printf("%d %d %d\n", ct, a[i].second, arr[cur]);
cur++;
dft(a[i].second, ct, arr[cur - 1]);
}
for (int i = 1; i <= B; i++) arr[i] = i * A;
cur = 1;
for (int i = pos + 1; i <= cnt; i++) {
printf("%d %d %d\n", ct, a[i].second, arr[cur]);
cur++;
dft(a[i].second, ct, arr[cur - 1]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char g[55][55];
bool vis[55][55];
void go(int i, int j, char tow = '-', int c = 0) {
if (i < 0 || i >= n || j < 0 || j >= m) return;
if (g[i][j] == 'W') return;
if (c > 1) return;
vis[i][j] = true;
if (tow == 'u' || tow == '-') {
go(i - 1, j, 'u', c);
go(i, j + 1, 'r', c + 1);
go(i, j - 1, 'l', c + 1);
}
if (tow == 'd' || tow == '-') {
go(i + 1, j, 'd', c);
go(i, j + 1, 'r', c + 1);
go(i, j - 1, 'l', c + 1);
}
if (tow == 'l' || tow == '-') {
go(i, j - 1, 'l', c);
go(i + 1, j, 'd', c + 1);
go(i - 1, j, 'u', c + 1);
}
if (tow == 'r' || tow == '-') {
go(i, j + 1, 'r', c);
go(i + 1, j, 'd', c + 1);
go(i - 1, j, 'u', c + 1);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> g[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
memset(vis, false, sizeof vis);
if (g[i][j] == 'B') {
go(i, j);
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++) {
if (g[k][l] == 'B' && !vis[k][l]) {
cout << "NO" << endl;
return 0;
}
}
}
}
cout << "YES" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int x[maxn][maxn], y[maxn][maxn];
void Query(vector<int>& X) {
printf("%d\n", X.size());
for (int i = 0; i < X.size(); i++) printf("%d ", X[i] + 1);
fflush(stdout);
}
int main() {
int n;
scanf("%d", &n);
for (int bit = 0; (1 << bit) < n; bit++) {
vector<int> A, B;
A.clear(), B.clear();
for (int i = 0; i < n; i++)
if ((i >> bit) & 1)
A.push_back(i);
else
B.push_back(i);
Query(A);
for (int i = 0; i < n; i++) scanf("%d", &x[i][bit]);
Query(B);
for (int i = 0; i < n; i++) scanf("%d", &y[i][bit]);
}
puts("-1");
for (int i = 0; i < n; i++) {
int ans = 1e9;
for (int bit = 0; (1 << bit) < n; bit++) {
if ((i >> bit) & 1)
ans = min(ans, y[i][bit]);
else
ans = min(ans, x[i][bit]);
}
printf("%d ", ans);
}
fflush(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c = 0;
char sr, sc;
string s;
vector<vector<char>> v;
int main() {
cin.tie(0);
int n, c = 0, cc = 0;
cin >> n;
string s = "", s1 = "", s2;
char ch;
for (int i = 0; i < n; i++) {
cin >> ch;
s += ch;
}
for (int i = 0; i < n; i++) {
cin >> ch;
s1 += ch;
}
sort(s.begin(), s.end());
sort(s1.begin(), s1.end());
for (int i = 0; i < n; i++) {
if (s[i] - '0' < s1[i] - '0') {
c++;
}
}
if (c == n) {
cout << "YES";
return 0;
}
for (int i = 0; i < n; i++) {
if (s[i] - '0' > s1[i] - '0') {
cc++;
}
}
if (cc == n) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isnum(string s) {
if (s[0] == '0') return false;
for (char c : s)
if (c > '9' || c < '0') return false;
return true;
}
int n;
vector<pair<string, string> > V;
void dod(string a, string b) { V.push_back(pair<string, string>(a, b)); }
char A[10];
string tost(int x) {
for (int i = 0; i < 10; ++i) A[i] = 0;
sprintf(A, "%d", x);
return string(A);
}
int T[120000];
int main() {
scanf("%d", &n);
vector<string> ex, re;
for (int i = 0; i < n; ++i) {
int t;
scanf("%s%d", A, &t);
string s(A);
if (t == 0)
re.push_back(s);
else
ex.push_back(s);
}
vector<string> res, exs;
for (string s : ex) {
if (isnum(s) && atoi(s.c_str()) <= n) {
int k = atoi(s.c_str());
if (k <= ex.size())
T[k] = 1;
else
T[k] = 3;
} else
exs.push_back(s);
}
for (string s : re) {
if (isnum(s) && atoi(s.c_str()) <= n) {
int k = atoi(s.c_str());
if (k > ex.size())
T[k] = 1;
else
T[k] = 2;
} else
res.push_back(s);
}
stack<int> Fe;
stack<int> Fr;
stack<int> Ce;
stack<int> Cr;
for (int i = 1; i <= ex.size(); ++i) {
if (T[i] == 0)
Fe.push(i);
else {
if (T[i] == 2) Cr.push(i);
}
}
for (int i = ex.size() + 1; i <= n; ++i) {
if (T[i] == 0)
Fr.push(i);
else {
if (T[i] == 3) Ce.push(i);
}
}
while (Ce.size() > 0 || Cr.size() > 0) {
if (Fe.size() == 0 && Fr.size() == 0) {
string s = "rgassg";
dod(tost(Ce.top()), s);
Fr.push(Ce.top());
Ce.pop();
exs.push_back(s);
}
while (Ce.size() > 0 && Fe.size() > 0) {
dod(tost(Ce.top()), tost(Fe.top()));
Fr.push(Ce.top());
Ce.pop();
Fe.pop();
}
while (Cr.size() > 0 && Fr.size() > 0) {
dod(tost(Cr.top()), tost(Fr.top()));
Fe.push(Cr.top());
Cr.pop();
Fr.pop();
}
}
for (string s : exs) {
dod(s, tost(Fe.top()));
Fe.pop();
}
for (string s : res) {
dod(s, tost(Fr.top()));
Fr.pop();
}
printf("%d\n", V.size());
for (auto v : V) printf("move %s %s\n", v.first.c_str(), v.second.c_str());
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void pre() {}
int n, m;
int a[(1 << 21) + 9];
int f[(1 << 21) + 9];
void fx(int x) {
if (a[2 * x] == a[2 * x + 1] && a[2 * x] == 0) {
a[x] = 0;
return;
}
int bg = 2 * x, sm = 2 * x + 1;
if (a[2 * x] < a[2 * x + 1]) swap(bg, sm);
a[x] = a[bg];
fx(bg);
bg = 2 * x, sm = 2 * x + 1;
if (a[2 * x] < a[2 * x + 1]) swap(bg, sm);
if (a[2 * x] == a[2 * x + 1]) {
if (x > m)
f[x] = x;
else
f[x] = 0;
} else if (f[bg] == bg)
f[x] = x;
else if (a[f[bg]] > a[f[sm]])
f[x] = f[bg];
else
f[x] = f[sm];
}
vector<int> ans;
void solve() {
int h, g;
cin >> h >> g;
n = (1 << h) - 1;
m = (1 << g) - 1;
for (int i = 1; i <= (n); ++i) cin >> a[i], a[i + n] = 0;
for (int i = 1; i <= (n); ++i) f[i] = i, f[i + n] = 0;
a[2 * n + 1] = f[2 * n + 1] = 0;
ans.clear();
ans.reserve(n - m);
for (int i = 0; i < (n - m); ++i) {
int x = f[1];
ans.push_back(f[1]);
fx(f[1]);
x /= 2;
while (x >= 1) {
int bg = 2 * x, sm = 2 * x + 1;
if (a[2 * x] < a[2 * x + 1]) swap(bg, sm);
if (a[2 * x] == a[2 * x + 1]) {
if (x > m)
f[x] = x;
else
f[x] = 0;
} else if (f[bg] == bg)
f[x] = x;
else if (a[f[bg]] > a[f[sm]])
f[x] = f[bg];
else
f[x] = f[sm];
x /= 2;
}
}
long long sum = 0;
for (int i = 1; i <= (m); ++i) sum += a[i];
cout << sum << '\n';
for (auto &i : ans) cout << i << ' ';
cout << '\n';
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
pre();
int n;
cin >> n;
for (int i = 0; i < (n); ++i) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n = 0, i = 0;
cin >> n;
while (n != 0) {
i = n % 2 + i;
n = n / 2;
}
cout << i;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string str;
int n, p, q;
bool imposs;
void read() {
cin >> n >> p >> q;
cin >> str;
}
void solve_print() {
int div1 = n / p, div2 = -1;
for (; div1 >= 0; --div1) {
if ((n - div1 * p) % q == 0) {
div2 = (n - div1 * p) / q;
break;
}
}
if (div2 == -1) {
cout << "-1\n";
imposs = true;
return;
}
int current = 0;
cout << div1 + div2 << "\n";
for (; div1 > 0; --div1) {
int i;
for (i = 0; i < p; ++i) {
cout << str[current + i];
}
current += i;
cout << "\n";
}
for (; div2 > 0; --div2) {
int i;
for (i = 0; i < q; ++i) {
cout << str[current + i];
}
current += i;
cout << "\n";
}
}
int main() {
read();
solve_print();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class node {
public:
node* l;
node* r;
node* p;
long long square_light;
int light;
int size;
int id;
node(int id) : id(id) {
l = r = p = NULL;
square_light = 0;
light = size = 1;
}
void pull() {
size = light;
if (l != NULL) {
l->p = this;
size += l->size;
}
if (r != NULL) {
r->p = this;
size += r->size;
}
}
};
bool is_bst_root(node* v) {
if (v == NULL) {
return false;
}
return (v->p == NULL || (v->p->l != v && v->p->r != v));
}
void rotate(node* v) {
node* u = v->p;
assert(u != NULL);
v->p = u->p;
if (v->p != NULL) {
if (v->p->l == u) {
v->p->l = v;
}
if (v->p->r == u) {
v->p->r = v;
}
}
if (v == u->l) {
u->l = v->r;
v->r = u;
} else {
u->r = v->l;
v->l = u;
}
u->pull();
v->pull();
}
void splay(node* v) {
if (v == NULL) {
return;
}
while (!is_bst_root(v)) {
node* u = v->p;
if (!is_bst_root(u)) {
if ((u->l == v) ^ (u->p->l == u)) {
rotate(v);
} else {
rotate(u);
}
}
rotate(v);
}
}
void access(node* v) {
node* u = NULL;
while (v != NULL) {
splay(v);
if (v->r != NULL) {
v->square_light += (long long)v->r->size * v->r->size;
v->light += v->r->size;
}
v->r = u;
if (v->r != NULL) {
v->square_light -= (long long)v->r->size * v->r->size;
v->light -= v->r->size;
}
u = v;
v = v->p;
}
}
node* find_root(node* v) {
access(v);
splay(v);
while (v->l != NULL) {
v = v->l;
}
splay(v);
return v;
}
long long link(node* v, node* u) {
long long ans = 0;
access(v);
splay(v);
ans -= v->square_light;
node* w = find_root(u);
access(w);
ans -= w->square_light;
access(u);
splay(u);
v->p = u;
u->square_light += (long long)v->size * v->size;
u->light += v->size;
u->pull();
access(w);
splay(w);
ans += w->square_light;
return ans;
}
long long cut(node* v, node* u) {
long long ans = 0;
node* w = find_root(v);
access(w);
ans -= w->square_light;
access(u);
splay(u);
v->p = NULL;
u->square_light -= (long long)v->size * v->size;
u->light -= v->size;
u->pull();
access(w);
splay(w);
ans += w->square_light;
access(v);
splay(v);
ans += v->square_light;
return ans;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> c(n);
for (int i = 0; i < n; ++i) {
cin >> c[i];
--c[i];
}
vector<vector<int>> adj(n);
for (int i = 0; i < n - 1; ++i) {
int from, to;
cin >> from >> to;
--from;
--to;
adj[from].push_back(to);
adj[to].push_back(from);
}
vector<vector<pair<int, int>>> events(n);
for (int i = 0; i < n; ++i) {
events[c[i]].emplace_back(i, 0);
}
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
events[c[x]].emplace_back(x, i);
c[x] = y;
events[c[x]].emplace_back(x, i);
}
vector<int> parent(n + 1);
function<void(int)> dfs = [&](int x) {
for (auto y : adj[x]) {
if (y != parent[x]) {
parent[y] = x;
dfs(y);
}
}
};
parent[0] = n;
dfs(0);
vector<node*> tree(n + 1);
for (int i = 0; i <= n; ++i) {
tree[i] = new node(i);
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
ans += link(tree[i], tree[parent[i]]);
}
vector<bool> black(n, true);
vector<long long> add(m + 1);
for (int i = 0; i < n; ++i) {
long long last = ans;
add[0] += last;
for (auto p : events[i]) {
if (black[p.first]) {
ans += cut(tree[p.first], tree[parent[p.first]]);
} else {
ans += link(tree[p.first], tree[parent[p.first]]);
}
black[p.first] = !black[p.first];
add[p.second] += ans - last;
last = ans;
}
for (auto p : events[i]) {
if (!black[p.first]) {
ans += link(tree[p.first], tree[parent[p.first]]);
black[p.first] = true;
}
}
}
long long cur = (long long)n * n * n;
for (int i = 0; i <= m; ++i) {
cur -= add[i];
cout << cur << "\n";
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
class TaskD {
public:
int n, k, p;
int a[1011];
;
int b[2011];
int sorted[2011];
void solve(std::istream& in, std::ostream& out) {
in >> n >> k >> p;
for (int i = 0; i < n; i++) in >> a[i];
for (int j = 0; j < k; j++) in >> b[j];
comp c;
c.p = p;
sort(a, a + n, c);
sort(b, b + k, c);
long long l = 0, r = INT_MAX;
long long res = 0;
while (r >= l) {
long long mid = (l + r) / 2;
if (check(mid)) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
out << res << endl;
}
int vst[2011];
bool check(long long mid) {
memset(vst, 0, sizeof vst);
for (int i = 0; i < n; i++) {
bool ok = 0;
for (int j = 0; j < k; j++) {
if (!vst[j]) {
int dist = abs(a[i] - b[j]) + abs(b[j] - p);
if (dist <= mid) {
ok = 1;
vst[j] = 1;
break;
}
}
}
if (!ok) return 0;
}
return 1;
}
struct comp {
int p;
bool operator()(int x, int y) {
int dist1 = abs(x - p);
int dist2 = abs(y - p);
return dist1 > dist2;
}
};
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
TaskD solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string S;
cin >> S;
int s = 0, R = 0, P = 0;
for (int i = 0; i < S.size(); i++) {
if (S[i] == 'S') {
s++;
}
if (S[i] == 'R') {
R++;
}
if (S[i] == 'P') {
P++;
}
}
if (s >= R && s >= P) {
for (int i = 0; i < S.size(); i++) {
cout << "R";
}
} else if (R >= s && R >= P) {
for (int i = 0; i < S.size(); i++) {
cout << "P";
}
} else if (P >= R && P >= s) {
for (int i = 0; i < S.size(); i++) {
cout << "S";
}
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
for (long long i = 1; i < (n - 1); i++) {
if (arr[i] <= arr[i - 1] && arr[i] <= arr[i + 1]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 505, MOD = 1e9 + 7;
long long n, m, ans;
long long f[N][N];
char s[N][N];
signed main() {
scanf("%lld%lld", &n, &m);
for (register long long i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
if (s[1][1] != s[n][m]) {
printf("%d\n", 0);
return 0;
}
f[1][n] = 1;
for (register long long i = 1; i <= (n + m) / 2 - 1; ++i) {
for (register long long j = i + 1; j >= 1; --j)
for (register long long k = n - i; k <= n; ++k)
if (s[j][i + 2 - j] == s[k][n + m - i - k])
f[j][k] =
(f[j][k] + f[j - 1][k] + f[j][k + 1] + f[j - 1][k + 1]) % MOD;
else
f[j][k] = 0;
}
if ((n + m) % 2 == 0)
for (register long long i = 1; i <= n; ++i) ans = (ans + f[i][i]) % MOD;
else
for (register long long i = 1; i <= n; ++i)
ans = (ans + f[i][i] + f[i][i + 1]) % MOD;
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using PII = pair<int, int>;
using TI3 = tuple<int, int, int>;
using LL = long long;
using ULL = unsigned long long;
using MAT = array<array<LL, 2>, 2>;
template <class T>
void _read(T &x) {
cin >> x;
}
void _read(int &x) { scanf("%d", &x); }
void _read(LL &x) { scanf("%lld", &x); }
void _read(ULL &x) { scanf("%llu", &x); }
void _read(double &x) { scanf("%lf", &x); }
void _read(char &x) { scanf(" %c", &x); }
void _read(char *x) { scanf("%s", x); }
void read() {}
template <class T, class... U>
void read(T &head, U &...tail) {
_read(head);
read(tail...);
}
template <class T>
void _print(const T &x) {
cout << x;
}
void _print(const int &x) { printf("%d", x); }
void _print(const LL &x) { printf("%lld", x); }
void _print(const double &x) { printf("%.16lf", x); }
void _print(const char &x) { putchar(x); }
void _print(const char *x) { printf("%s", x); }
template <class T>
void _print(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _print(*i++))
if (i != x.cbegin()) putchar(' ');
}
void print() {}
template <class T, class... U>
void print(const T &head, const U &...tail) {
_print(head);
putchar(sizeof...(tail) ? ' ' : '\n');
print(tail...);
}
template <class T>
void print1(T &x, int cond = 0) {
_print(x);
printf("%c", " \n"[cond]);
}
const int MOD = 1000000007;
LL shift[100];
int main() {
int Q;
read(Q);
for (int q = 0; q < (int)(Q); q++) {
int T;
LL X, K;
read(T);
if (T == 1) {
read(X, K);
LL lvl = LL(log2l(X));
LL n = 1LL << lvl;
shift[lvl] = (shift[lvl] + n + K) % n;
} else if (T == 2) {
read(X, K);
LL lvl = LL(log2l(X));
LL n = 1LL << lvl;
for (int i = lvl; i < (int)(61); i++) {
shift[i] = (shift[i] + n + K) % n;
n <<= 1;
K <<= 1;
}
} else {
read(X);
LL lvl = LL(log2l(X));
LL n = 1LL << lvl;
for (int i = lvl;
(-1 > 0 and i < (int)(-1)) or (-1 < 0 and i > (int)(-1)); i += -1) {
print1(X, i == 0);
if (i == 0) {
break;
}
X = n + (X + shift[i]) % n / 2;
n >>= 1;
X = n + (X + n - shift[i - 1]) % n;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n;
int arr[1001];
bool works() {
for (int x = 1; x < n; x++) {
if (arr[x - 1] > arr[x]) {
return false;
}
}
return true;
}
int mex() {
int test[n + 2];
for (int x = 0; x < n + 2; x++) {
test[x] = 1;
}
for (int x = 0; x < n; x++) {
test[arr[x]] = 2;
}
for (int x = 0; x < n + 2; x++) {
if (test[x] == 1) {
return x;
}
}
}
int main() {
cin >> t;
for (int b = 0; b < t; b++) {
cin >> n;
for (int x = 0; x < n; x++) {
cin >> arr[x];
}
vector<int> records;
while (!works()) {
int cur = mex();
if (cur == n) {
for (int x = 0; x < n; x++) {
if (arr[x] != x) {
arr[x] = cur;
records.push_back(x);
break;
}
}
} else {
arr[cur] = cur;
records.push_back(cur);
}
}
cout << records.size() << "\n";
for (int x = 0; x < records.size(); x++) {
cout << records[x] + 1 << " ";
}
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n == 1) {
printf("a\n");
printf("a\n");
printf("b\n");
printf("b\n");
} else if (n == 2) {
printf("aa\n");
printf("bb\n");
printf("cc\n");
printf("dd\n");
} else if (n % 2 == 0) {
const char *s1[] = {"aa", "bb"};
for (int i = 0; i < n / 2; i++) printf("%s", s1[i % 2]);
printf("\n");
const char *s2[] = {"dd", "ee"};
printf("c");
for (int i = 0; i < n / 2 - 1; i++) printf("%s", s2[i % 2]);
printf("f\n");
const char *s3[] = {"gg", "hh"};
printf("c");
for (int i = 0; i < n / 2 - 1; i++) printf("%s", s3[i % 2]);
printf("f\n");
const char *s4[] = {"ii", "jj"};
for (int i = 0; i < n / 2; i++) printf("%s", s4[i % 2]);
printf("\n");
} else {
const char *s1[] = {"aa", "bb"};
for (int i = 0; i < n / 2; i++) printf("%s", s1[i % 2]);
printf("c\n");
const char *s2[] = {"dd", "ee"};
for (int i = 0; i < n / 2; i++) printf("%s", s2[i % 2]);
printf("c\n");
const char *s3[] = {"ff", "gg"};
printf("h");
for (int i = 0; i < n / 2; i++) printf("%s", s3[i % 2]);
printf("\n");
const char *s4[] = {"ii", "jj"};
printf("h");
for (int i = 0; i < n / 2; i++) printf("%s", s4[i % 2]);
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
namespace patch {
template <typename T>
std::string to_string(const T& n) {
std::ostringstream stm;
stm << n;
return stm.str();
}
} // namespace patch
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long int N;
cin >> N;
map<string, long long int> MP;
for (int i = 0; i < N; i++) {
string S;
long long int X;
cin >> S >> X;
MP[S] = max(X, MP[S]);
}
vector<pair<long long int, string> > V;
map<string, long long int>::iterator it = MP.begin();
for (; it != MP.end(); it++) {
V.push_back(make_pair(it->second, it->first));
}
sort(V.begin(), V.end());
cout << V.size() << '\n';
for (int i = 0; i < V.size(); i++) {
long double cnt = 0;
for (int j = 0; j < V.size(); j++) {
if (V[j].first > V[i].first) {
cnt++;
}
}
long double rate = 100, X, sz = V.size();
X = cnt / sz;
X *= 100.0;
rate -= X;
if (rate >= 99) {
cout << V[i].second << " "
<< "pro";
} else if (rate >= 90) {
cout << V[i].second << " "
<< "hardcore";
} else if (rate >= 80) {
cout << V[i].second << " "
<< "average";
} else if (rate >= 50) {
cout << V[i].second << " "
<< "random";
} else {
cout << V[i].second << " "
<< "noob";
}
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[55][55];
int cod1x[5];
int cod1y[5];
int n1 = 0;
bool check() {
if (n1 != 4) return false;
if (!((cod1x[0] == cod1x[1]) && (cod1x[2] == cod1x[3]) &&
(cod1y[0] == cod1y[2]) && (cod1y[1] == cod1y[3])))
return false;
for (int i = cod1y[0] + 1; i < cod1y[1]; i++) {
if (a[cod1x[0]][i] != 2 || a[cod1x[2]][i] != 2)
return false;
else
a[cod1x[0]][i] = 0, a[cod1x[2]][i] = 0;
}
for (int i = cod1x[0] + 1; i < cod1x[2]; i++) {
if (a[i][cod1y[0]] != 2 || a[i][cod1y[1]] != 2)
return false;
else
a[i][cod1y[0]] = 0, a[i][cod1y[1]] = 0;
}
for (int x = cod1x[0] + 1; x < cod1x[2]; x++) {
for (int y = cod1y[0] + 1; y < cod1y[1]; y++) {
if (a[x][y] != 4)
return false;
else
a[x][y] = 0;
}
}
for (int i = 0; i < 4; i++) a[cod1x[i]][cod1y[i]] = 0;
return true;
}
int main() {
scanf("%d", &n);
getchar();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = getchar() - '0';
if (a[i][j] == 1) {
cod1x[n1] = i;
cod1y[n1++] = j;
}
}
getchar();
}
if (!check()) {
printf("No");
} else {
printf("Yes");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
const long long MOD = 10007;
int n;
string s;
int a[2 * N - 1][2 * N - 1], S, ap[2 * N - 1][2 * N - 1], dp[N][N][N + 1];
int tmp[2 * N - 1][2 * N - 1], res[2 * N - 1][2 * N - 1];
long long te[2 * N][2 * N];
void matmul(int a[][2 * N - 1], int b[][2 * N - 1]) {
for (int i = 0; i < S; i++)
for (int j = 0; j < S; j++) {
long long sum = 0;
for (int k = i; k <= j; k++) sum += a[i][k] * b[k][j];
te[i][j] = sum % MOD;
}
for (int i = 0; i < S; i++)
for (int j = 0; j < S; j++) a[i][j] = te[i][j];
}
int calc(int lo, int hi, int n24) {
int& res = dp[lo][hi][n24];
if (res != -1) return res;
res = 0;
if (lo == hi) {
if (n24 == 0) res = 1;
} else {
if (s[lo] == s[hi]) {
if (lo + 1 == hi) {
if (n24 == 0) res = 1;
} else {
res = calc(lo + 1, hi - 1, n24);
}
} else {
if (n24 > 0) res = calc(lo + 1, hi, n24 - 1) + calc(lo, hi - 1, n24 - 1);
}
}
return res %= MOD;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> s >> n;
int l = (int)s.size();
n += l;
int m = (n + 1) >> 1;
int N24 = l - 1, N25 = (l + 1) >> 1;
int N26 = (l + 1) >> 1;
S = N24 + N25 + N26;
memset(a, 0, sizeof a);
for (int i = 0; i < S; i++) {
if (i < N24) {
a[i][i] = 24;
a[i][i + 1] = 1;
} else if (i < N24 + N25) {
a[i][i] = 25;
if (i < N24 + N25 - 1) a[i][i + 1] = 1;
a[i][i + N25] = 1;
} else
a[i][i] = 26;
}
memcpy(tmp, a, sizeof a);
memset(res, 0, sizeof res);
for (int i = 0; i < S; i++) res[i][i] = 1;
for (int x = m - 1; x; x >>= 1) {
if (x & 1) matmul(res, a);
matmul(a, a);
}
for (int i = 0; i < S; i++)
for (int j = 0; j < S; j++) a[i][j] = res[i][j];
memcpy(ap, a, sizeof a);
matmul(a, tmp);
memset(dp, -1, sizeof dp);
long long ans = 0;
for (int n26, n25, n24 = 0; n24 <= N24; n24++) {
n25 = (l - n24 + 1) >> 1;
bool last25 = !((l - n24) % 2);
n26 = m - n24 - n25;
if (n26 < 0) continue;
int way = calc(0, l - 1, n24);
ans += way * a[N24 - n24][N24 + N25 + n25 - 1];
if (n % 2 == 1 && last25)
ans += MOD * MOD - way * ap[N24 - n24][N24 + n25 - 1];
ans %= MOD;
}
cout << ans % MOD << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, r, ans;
cin >> n >> r;
ans = (n * r * r * sin(3.141592654 / n) * sin(3.141592654 / (2 * n))) /
sin((3 * 3.141592654) / (2 * n));
cout << setprecision(12) << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace std {
bool operator<(const complex<double>& a, const complex<double>& b) {
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
} // namespace std
inline double dot(complex<double> a, complex<double> b) {
return real(conj(a) * b);
}
inline double cross(complex<double> a, complex<double> b) {
return imag(conj(a) * b);
}
const double PI = acos(-1);
const double EPS = 1e-12;
int ccw(complex<double> a, complex<double> b, complex<double> c) {
b -= a;
c -= a;
if (cross(b, c) > EPS) return +1;
if (cross(b, c) < -EPS) return -1;
if (dot(b, c) < -EPS) return +2;
if (norm(b) + EPS < norm(c)) return -2;
return 0;
}
bool IsIntersectSS(complex<double> a1, complex<double> a2, complex<double> b1,
complex<double> b2) {
return ccw(a1, a2, b1) * ccw(a1, a2, b2) <= 0 &&
ccw(b1, b2, a1) * ccw(b1, b2, a2) <= 0;
}
double arg(complex<double> a, complex<double> b) { return arg(a / b); }
complex<double> IntersectionLL(complex<double> a1, complex<double> a2,
complex<double> b1, complex<double> b2) {
complex<double> a = a2 - a1;
complex<double> b = b2 - b1;
return a1 + a * cross(b, b1 - a1) / cross(b, a);
}
bool bunkatu(pair<complex<double>, complex<double> > s,
pair<complex<double>, complex<double> > t) {
complex<double> p = IntersectionLL(s.first, s.second, t.first, t.second);
double len1 = abs(s.first - p);
double len2 = abs(s.second - p);
if (len1 > len2) swap(len1, len2);
double r = len1 / (len1 + len2);
return 1.0 / 5 - EPS <= r;
}
bool IsIntersectSP(complex<double> a, complex<double> b, complex<double> c) {
return (abs(a - c) + abs(c - b) < abs(a - b) + EPS);
}
bool IsTouch(pair<complex<double>, complex<double> > s,
pair<complex<double>, complex<double> > t) {
complex<double> p = IntersectionLL(s.first, s.second, t.first, t.second);
if (abs(t.first - p) < EPS) return true;
if (abs(t.second - p) < EPS) return true;
return false;
}
bool check(pair<complex<double>, complex<double> > seg[]) {
if (!(seg[0].first == seg[1].first || seg[0].first == seg[1].second ||
seg[0].second == seg[1].first || seg[0].second == seg[1].second)) {
return false;
}
if (seg[0].second == seg[1].first || seg[0].second == seg[1].second) {
swap(seg[0].first, seg[0].second);
}
if (seg[0].first == seg[1].second) swap(seg[1].first, seg[1].second);
assert(seg[0].first == seg[1].first);
double thete =
arg(seg[0].second - seg[0].first, seg[1].second - seg[1].first);
if (!(EPS < thete && thete < PI / 2 + EPS)) return false;
if (!IsIntersectSS(seg[0].first, seg[0].second, seg[2].first,
seg[2].second) ||
!IsIntersectSS(seg[1].first, seg[1].second, seg[2].first, seg[2].second))
return false;
if (!IsTouch(seg[0], seg[2]) || !IsTouch(seg[1], seg[2])) return false;
if (!bunkatu(seg[0], seg[2]) || !bunkatu(seg[1], seg[2])) return false;
return true;
}
int main() {
int T;
cin >> T;
while (T--) {
pair<complex<double>, complex<double> > seg[3];
for (int i = 0; i < (int)(3); ++i) {
int x, y, z, w;
cin >> x >> y >> z >> w;
seg[i] = make_pair(complex<double>(x, y), complex<double>(z, w));
}
bool ok = false;
sort(seg, seg + 3);
do {
pair<complex<double>, complex<double> > clone[3];
for (int i = 0; i < (int)(3); ++i) clone[i] = seg[i];
if (check(clone)) {
ok = true;
break;
}
} while (next_permutation(seg, seg + 3));
cout << (ok ? "YES" : "NO") << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
template <class T>
inline void read(T &x) {
char c = getchar(), f = 0;
x = 0;
while (!isdigit(c)) f = (c == '-'), c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x = f ? -x : x;
}
using namespace std;
const int N = 10001;
const int M = 300011;
const int HA = 998244353;
int n, q, a[M], b[M];
vector<pair<int, int> > Q[M];
namespace Segment_tree {
struct Node {
int l, r, len;
int num, add;
} node[M << 2];
inline void pushup(int x) {
node[x].num = (node[(x << 1)].num + node[(x << 1 | 1)].num);
}
inline void pushdown(int x) {
if (node[x].add == 0) return;
node[(x << 1)].add += node[x].add;
node[(x << 1)].num += node[(x << 1)].len * node[x].add;
node[(x << 1 | 1)].add += node[x].add;
node[(x << 1 | 1)].num += node[(x << 1 | 1)].len * node[x].add;
node[x].add = 0;
}
void build(int x, int l, int r) {
node[x].l = l, node[x].r = r;
node[x].len = (r - l + 1);
if (l == r) {
return;
}
int mid = (l + r) >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r);
pushup(x);
}
void range_add(int x, int ql, int qr, int val) {
if (ql > qr) return;
if (node[x].l > qr || node[x].r < ql) return;
if (ql <= node[x].l && node[x].r <= qr) {
node[x].add += val;
node[x].num += val * node[x].len;
return;
}
pushdown(x);
range_add((x << 1), ql, qr, val);
range_add((x << 1 | 1), ql, qr, val);
pushup(x);
}
int range_query(int x, int ql, int qr) {
if (ql <= node[x].l && node[x].r <= qr) {
return node[x].num;
}
pushdown(x);
int mid = (node[x].l + node[x].r) >> 1, ans = 0;
if (ql <= mid) {
ans += range_query((x << 1), ql, qr);
}
if (mid + 1 <= qr) {
ans += range_query((x << 1 | 1), ql, qr);
}
return ans;
}
int find_pla(int x) {
int l = 1, r = x, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (range_query(1, mid, mid) >= b[x]) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
} // namespace Segment_tree
using namespace Segment_tree;
int ans[M];
int main() {
read(n), read(q);
for (int i = (1); i <= (n); i++) {
read(a[i]);
b[i] = i - a[i];
if (b[i] < 0) b[i] = 0x3f3f3f3f;
}
for (int i = (1); i <= (q); i++) {
int l, r;
read(l), read(r);
l += 1, r = n - r;
Q[r].push_back(make_pair(l, i));
}
build(1, 1, n);
for (int i = (1); i <= (n); i++) {
int pla = find_pla(i);
range_add(1, 1, pla, 1);
for (int j = 0; j < Q[i].size(); j++) {
ans[Q[i][j].second] = range_query(1, Q[i][j].first, Q[i][j].first);
}
}
for (int i = (1); i <= (q); i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int color[100110];
vector<int> conn[100110];
bool done[100110];
int main() {
int V, E;
scanf("%d%d", &V, &E);
for (int i = 0; i < V; ++i) scanf("%d", color + i);
for (int i = 0; i < E; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
if (color[a] != color[b]) {
conn[color[a]].push_back(color[b]);
conn[color[b]].push_back(color[a]);
}
}
int maxx = -1, wh = 10000000;
for (int k = 0; k < V; ++k) {
int nr = color[k];
if (!done[nr]) {
sort(conn[nr].begin(), conn[nr].end());
int amo = 0;
for (int i = 0; i < conn[nr].size(); ++i)
if (i == 0 || conn[nr][i] != conn[nr][i - 1]) amo++;
if (amo > maxx || (amo == maxx && wh > nr)) {
maxx = amo;
wh = nr;
}
done[nr] = true;
}
}
printf("%d\n", wh);
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.