solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long int N = (long long int)3e5;
const long long int inf = (long long int)1e18 + 7;
const long long int mod = (long long int)1e9 + 7;
const long long int MX = (long long int)1e9 + 7;
const long long int MAX = (long long int)1e12 + 7;
bool rsort1(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.first > b.first);
}
bool rsort2(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second > b.second);
}
bool sort2(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
void add(long long int &x, long long int y) {
x = ((x % mod) + (y % mod)) % mod;
}
void mul(long long int &x, long long int y) {
x = ((x % mod) * (y % mod)) % mod;
}
bool isPrime(long long int p) {
for (long long int i = 2; i * i <= p; i++)
if (p % i == 0) return false;
return true;
}
string s;
long long int dp[N][2], n;
long long int solve(long long int ind, long long int pre) {
if (ind >= n) return 0;
long long int &res = dp[ind][pre];
if (res != -1) return res;
if (pre == 0) {
if (s[ind] <= 91)
res = 1 + solve(ind + 1, 0);
else
res = solve(ind + 1, 0);
} else {
if (s[ind] <= 91)
res = min(1 + solve(ind + 1, 0), solve(ind + 1, 1));
else
res = min(1 + solve(ind + 1, 1), solve(ind + 1, 0));
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s;
n = s.length();
memset(dp, -1, sizeof(dp));
cout << min(solve(0, 1), solve(0, 0));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q, w, w1, e, r, t, c, v, f[5002], f1[5002], ans = 0;
char a[5002];
cin >> a;
q = strlen(a);
f[q + 1] = 1;
f1[q + 1] = 0;
for (w = q - 1; w > 0; w -= 2) {
f[w] = f[w + 2] * (a[w] - 48);
f1[w] = f1[w + 2];
if (a[w - 1] == '+') {
f1[w] += f[w];
f[w] = 1;
}
}
c = 1;
v = 0;
for (w = 0; w < q; w += 2) {
e = 1;
r = 0;
for (w1 = w; w1 < q; w1 += 2) {
e *= a[w1] - 48;
ans = max(ans, v + c * (r + e) * f[w1 + 2] + f1[w1 + 2]);
if (a[w1 + 1] == '+') {
r += e;
e = 1;
}
}
c *= a[w] - 48;
if (a[w + 1] == '+') {
v += c;
c = 1;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 201010;
const int inf = 1e9;
int n, m, k, w[maxn], p, q, A, B, C, D;
int a[maxn], b[maxn], c[maxn], d[maxn];
int pos1, pos2, pos3, pos4, cnt, vis[maxn];
long long ans = 1e18, sum = 0;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
}
scanf("%d", &p);
int x;
for (int i = 1; i <= p; i++) scanf("%d", &x), vis[x] = 1;
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d", &x), vis[x] = vis[x] ? 3 : 2;
for (int i = 1; i <= n; i++) {
if (vis[i] == 1) a[++A] = w[i];
if (vis[i] == 2) b[++B] = w[i];
if (vis[i] == 3) c[++C] = w[i];
if (vis[i] == 0) d[++D] = w[i];
}
sort(a + 1, a + A + 1);
sort(b + 1, b + B + 1);
sort(c + 1, c + C + 1);
sort(d + 1, d + D + 1);
pos1 = pos2 = pos3 = pos4 = 1;
a[A + 1] = b[B + 1] = c[C + 1] = d[D + 1] = inf;
for (int i = 0; i <= min(m, C); i++) {
if (k - i > A || k - i > B) continue;
while (i >= pos3) sum += c[pos3++], cnt++;
if (k - i + 2 == pos1) sum -= a[--pos1], cnt--;
while (k - i >= pos1) sum += a[pos1++], cnt++;
if (k - i + 2 == pos2) sum -= b[--pos2], cnt--;
while (k - i >= pos2) sum += b[pos2++], cnt++;
while (cnt < m) {
int minn = inf;
if (pos1 <= A) minn = min(minn, a[pos1]);
if (pos2 <= B) minn = min(minn, b[pos2]);
if (pos3 <= C) minn = min(minn, c[pos3]);
if (pos4 <= D) minn = min(minn, d[pos4]);
if (minn >= inf) break;
cnt++;
if (minn == a[pos1])
sum += a[pos1++];
else if (minn == b[pos2])
sum += b[pos2++];
else if (minn == c[pos3])
sum += c[pos3++];
else if (minn == d[pos4])
sum += d[pos4++];
}
if (cnt == m) ans = min(ans, sum);
}
if (ans >= 1e18) ans = -1;
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int histA[6] = {};
int histB[6] = {};
for (int i = 0; i < n; i++) {
int x;
cin >> x;
histA[x]++;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
histB[x]++;
}
for (int i = 1; i <= 5; i++) {
if ((histA[i] + histB[i]) % 2 == 1) {
cout << -1 << endl;
return 0;
}
}
int hist[6] = {};
for (int i = 1; i <= 5; i++) {
hist[i] = abs(histA[i] - histB[i]) / 2;
}
int ans = 0;
for (int i = 1; i <= 5; i++) {
if (hist[i]) {
if (histA[i] > histB[i]) {
for (int j = 1; j <= 5; j++) {
if (j == i) continue;
if (hist[j] && histB[j] > histA[j]) {
int m = min(hist[i], hist[j]);
hist[i] -= m;
hist[j] -= m;
ans += m;
}
}
} else {
for (int j = 1; j <= 5; j++) {
if (j == i) continue;
if (hist[j] && histA[j] > histB[j]) {
int m = min(hist[i], hist[j]);
hist[i] -= m;
hist[j] -= m;
ans += m;
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void ECHO(string _s) {
cout << endl;
(void)_s;
}
template <typename T, typename... Args>
void ECHO(string _s, T x, Args... args) {
int _i;
string _s2 = "";
for (_i = 0; _i < (int)(_s).size(); ++_i) {
if (_s[_i] == ',') break;
if (_s[_i] != ' ') _s2 += _s[_i];
}
if (_i == (int)(_s).size()) {
--_i;
}
cout << " (" << _s2 << "):" << x;
ECHO(_s.substr(_i + 1, (int)(_s).size() - _i - 1), args...);
}
template <typename T0, typename T1>
inline ostream& operator<<(ostream& os, pair<T0, T1>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline ostream& operator<<(ostream& os, vector<T>& v) {
for (int i = 0; i < (int)(v).size(); ++i) cout << v[i] << "_";
return os;
}
template <typename T1, typename T2>
inline void ckmin(T1& x1, T2 x2) {
if (x2 < x1) x1 = x2;
}
template <typename T1, typename T2>
inline void ckmax(T1& x1, T2 x2) {
if (x2 > x1) x1 = x2;
}
inline long long _gcd(long long a, long long b) {
while (b) b %= a ^= b ^= a ^= b;
return a;
}
mt19937 ran(time(0));
const long double PI = acos(-1);
const long double eps = 1e-9;
const long long R = 0;
const long long G = 1;
const long long B = 2;
int main() {
ios::sync_with_stdio(false);
long long i, n, k, m, t;
string s;
cin >> t;
while (t--) {
cin >> n >> k;
cin >> s;
if (k == 1) {
cout << "0\n";
continue;
}
m = k;
vector<vector<long long> > a(3, vector<long long>(3, 0));
for (i = 0; i < k; ++i) {
if (s[i] == 'R') ++a[R][i % 3];
if (s[i] == 'G') ++a[G][i % 3];
if (s[i] == 'B') ++a[B][i % 3];
}
m = min(m, k - (a[R][0] + a[G][1] + a[B][2]));
m = min(m, k - (a[R][1] + a[G][2] + a[B][0]));
m = min(m, k - (a[R][2] + a[G][0] + a[B][1]));
for (; i < n; ++i) {
if (s[i - k] == 'R') --a[R][0];
if (s[i - k] == 'G') --a[G][0];
if (s[i - k] == 'B') --a[B][0];
if (k == 2) {
for (int z = 0; z < 3; ++z) {
swap(a[z][0], a[z][1]);
}
} else {
for (int z = 0; z < 3; ++z) {
swap(a[z][0], a[z][1]);
swap(a[z][1], a[z][2]);
}
}
if (s[i] == 'R') ++a[R][((k % 3) - 1 + 3) % 3];
if (s[i] == 'G') ++a[G][((k % 3) - 1 + 3) % 3];
if (s[i] == 'B') ++a[B][((k % 3) - 1 + 3) % 3];
m = min(m, k - (a[R][0] + a[G][1] + a[B][2]));
m = min(m, k - (a[R][1] + a[G][2] + a[B][0]));
m = min(m, k - (a[R][2] + a[G][0] + a[B][1]));
}
cout << m << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void sprint(string s) {
for (int i = 0; i < s.size(); ++i) printf("%c", s[i]);
printf("\n");
}
int main() {
int r, h;
cin >> r >> h;
int ans = h / r;
h -= ans * r;
ans *= 2;
double temp = h + r;
double R = r;
R /= 2.0;
double f = (2.0 * R) + (sqrtf(3)) * (R);
if (f <= temp)
ans += 3;
else if (2 * h >= r)
ans += 2;
else
ans++;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, save[N], sn;
double p[N], sum;
double cal(int now) {
double ss = sum * (1 - p[now]);
double ans = sum * p[now];
for (int i = 0; i < sn; i++) {
ans += ss / (1 - p[save[i]]) * p[save[i]];
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lf", &p[i]);
}
sort(p, p + n);
sn = 1;
save[0] = n - 1;
sum = (1 - p[n - 1]);
double Max = p[n - 1];
for (int i = n - 2; i >= 0; i--) {
double tmp = cal(i);
if (tmp > Max) {
sum *= (1 - p[i]);
Max = tmp;
save[sn++] = i;
}
}
printf("%.12lf\n", Max);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x;
friend bool operator<(node p1, node p2) { return p1.x > p2.x; }
} s;
priority_queue<node> q;
priority_queue<int> q2;
int main() {
int n, m, sum;
while (scanf("%d%d", &n, &m) != EOF) {
int i, v;
for (i = 0; i < m; i++) {
scanf("%d", &v);
s.x = v;
q.push(s);
q2.push(v);
}
sum = 0;
for (i = 0; i < n; i++) {
v = q2.top();
q2.pop();
sum += v;
v--;
if (v > 0) q2.push(v);
}
printf("%d", sum);
sum = 0;
for (i = 0; i < n; i++) {
s = q.top();
sum += s.x;
q.pop();
s.x--;
if (s.x > 0) q.push(s);
}
printf(" %d\n", sum);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
const int MAXN = 2e6 + 5;
auto mult = [&](int a, int b) { return (int)((long long)a * b % MOD); };
vector<int> dp(MAXN);
for (int i = 2; i < MAXN; i++) {
dp[i] = mult(dp[i - 2], 2) + dp[i - 1];
if (i % 3 == 2) {
dp[i] += 4;
}
dp[i] %= MOD;
}
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << dp[n - 1] << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, i;
cin >> n;
long long c1 = 0, c2 = 0;
vector<long long> a(n);
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2)
c1++;
else
c2++;
}
if (!c2 and c1 == 1)
cout << -1 << endl;
else {
if (c2) {
cout << 1 << endl;
for (i = 0; i < n; i++) {
if (a[i] % 2 == 0) {
cout << i + 1 << endl;
break;
}
}
} else {
cout << 2 << endl;
long long k = 0;
for (i = 0; i < n; i++) {
if (a[i] % 2 == 1) {
cout << i + 1 << ' ';
k++;
if (k == 2) {
cout << endl;
break;
}
}
}
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
inline int read() {
int res, ok = 1;
char ch;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') ok = -1;
res = ch - '0';
for (ch = getchar(); ch >= '0' && ch <= '9'; ch = getchar())
res = res * 10 + ch - '0';
return res * ok;
}
int x, y, n, d, vis[405][405];
struct node {
int x, y;
} a[25];
inline bool dfs(int x, int y) {
if ((x - 200) * (x - 200) + (y - 200) * (y - 200) >= d * d) return 1;
if (vis[x][y] != -1) return vis[x][y];
for (int i = 1; i <= n; i++)
if (dfs(x + a[i].x, y + a[i].y) == 0) return vis[x][y] = 1;
return vis[x][y] = 0;
}
int main() {
memset(vis, -1, sizeof(vis));
x = read();
y = read();
n = read();
d = read();
x += 200;
y += 200;
for (int i = 1; i <= n; i++) {
a[i].x = read();
a[i].y = read();
}
if (dfs(x, y))
printf("Anton\n");
else
printf("Dasha\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1005];
bool comp(int x, int y) { return x > y; }
int main() {
ios::sync_with_stdio(false);
int n, h, h2, h1;
cin >> n >> h;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
sort(a, a + i, comp);
h1 = h2 = h;
for (int j = 0; j < i; j++) {
if (h1 >= a[j]) {
h1 -= a[j];
if (j + 1 < i) h2 -= a[j + 1];
j++;
} else {
cout << i - 1;
return 0;
}
}
}
cout << n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> pos, neg;
map<int, int> lala;
int negi = 0, posi = 0;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
lala[x] = y;
if (x < 0) {
negi++;
neg.push_back(x);
} else {
posi++;
pos.push_back(x);
}
}
sort(neg.begin(), neg.end(), greater<int>());
sort(pos.begin(), pos.end());
int last = min(negi, posi);
int totapp = 0;
for (int j = 0; j < last; j++) {
totapp += (lala[neg[j]] + lala[pos[j]]);
}
if (negi < posi) {
totapp += lala[pos[last]];
} else {
totapp += lala[neg[last]];
}
cout << totapp << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 0x7f7f7f7f;
const int maxn = 1e3 + 5;
int n, u, v, root, cnt[2], S;
vector<int> vec[maxn];
int sz[maxn], msz[maxn];
void dfs1(int x, int par) {
for (int i = 0; i <= (int)vec[x].size() - 1; i++) {
if (vec[x][i] == par) continue;
dfs1(vec[x][i], x);
sz[x] += sz[vec[x][i]];
msz[x] = max(msz[x], sz[vec[x][i]]);
}
sz[x]++;
msz[x] = max(msz[x], n - sz[x]);
}
int par[maxn];
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
void dfs2(int x, int par, int f, int used) {
for (int i = 0; i <= (int)vec[x].size() - 1; i++) {
if (par == vec[x][i]) continue;
int now = ++cnt[f] - used;
dfs2(vec[x][i], x, f, now + used);
if (f) now *= (S + 1);
printf("%d %d %d\n", x, vec[x][i], now);
}
}
int main() {
cin >> n;
if (n == 1) return 0;
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u, &v);
vec[u].push_back(v);
vec[v].push_back(u);
}
dfs1(1, -1);
root = 1;
for (int i = 1; i <= n; i++) {
if (msz[i] < msz[root]) root = i;
}
memset(sz, 0, sizeof(sz));
dfs1(root, -1);
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
for (int i = 0; i <= (int)vec[root].size() - 1; i++) {
que.push(pair<int, int>(sz[vec[root][i]], vec[root][i]));
}
for (int i = 1; i <= n; i++) par[i] = i;
while (que.size() >= 3) {
pair<int, int> p1 = que.top();
que.pop();
pair<int, int> p2 = que.top();
que.pop();
par[p2.second] = find(p1.second);
que.push(pair<int, int>(p1.first + p2.first, par[p1.second]));
}
for (int i = 1; i <= n; i++) find(i);
int pp = par[vec[root][0]];
for (int i = 0; i <= (int)vec[root].size() - 1; i++) {
if (par[vec[root][i]] == pp) S += sz[vec[root][i]];
}
for (int i = 0; i <= (int)vec[root].size() - 1; i++) {
if (par[vec[root][i]] == pp) {
printf("%d %d %d\n", root, vec[root][i], ++cnt[0]);
dfs2(vec[root][i], root, 0, cnt[0]);
} else {
printf("%d %d %d\n", root, vec[root][i], ++cnt[1] * (S + 1));
dfs2(vec[root][i], root, 1, cnt[1]);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int mod = 998244353;
int n, k, m, l[N], r[N], x[N];
int s[N], asd[N];
long long dp[N];
long long solve() {
dp[0] = 1;
int cur = 0, j = 0;
long long sum = 1;
for (int i = 1; i <= n; i++) {
cur = cur + s[i];
if (cur == 0) dp[i] = sum;
while (j < asd[i]) {
sum = (sum - dp[j] + mod) % mod;
dp[j] = 0;
j++;
}
sum = (sum + dp[i]) % mod;
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k >> m;
for (int i = 1; i <= m; i++) cin >> l[i] >> r[i] >> x[i];
long long res = 1;
for (int bit = 0; bit < k; bit++) {
for (int i = 1; i <= n; i++) {
dp[i] = 0;
s[i] = 0;
asd[i] = 0;
}
for (int i = 1; i <= m; i++) {
if (x[i] >> bit & 1) {
s[l[i]]++;
s[r[i] + 1]--;
} else
asd[r[i]] = max(asd[r[i]], l[i]);
}
res = (res * solve()) % mod;
}
cout << res;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("fast-math")
#pragma GCC optimize "-O3"
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a;
a.resize(n);
for (int i = 0; i < (n); i++) cin >> a[i];
sort((a).begin(), (a).end());
long long ans = 0;
for (int i = 0; i < (n); i++) {
ans += ((a[i] + a[n - 1 - i]) * (a[i] + a[n - 1 - i]));
}
cout << ans / 2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000005;
int n;
vector<vector<uint32_t>> Mult(const vector<vector<uint32_t>>& A,
const vector<vector<uint32_t>>& B) {
vector<vector<uint32_t>> C(2 * n, vector<uint32_t>(2 * n, INF));
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < 2 * n; j++) {
for (int k = 0; k < 2 * n; k++) {
C[i][j] = min(C[i][j], A[i][k] + B[k][j]);
}
}
}
return C;
}
vector<vector<uint32_t>> Exp(vector<vector<uint32_t>> A, int b) {
vector<vector<uint32_t>> res(2 * n, vector<uint32_t>(2 * n, INF));
for (int i = 0; i < 2 * n; i++) res[i][i] = 0;
while (b) {
if (b & 1) res = Mult(res, A);
A = Mult(A, A);
b /= 2;
}
return res;
}
int a[20], b[20];
int main() {
int m;
ignore = scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) ignore = scanf("%d", a + i);
for (int j = 0; j < n; j++) ignore = scanf("%d", b + j);
vector<vector<uint32_t>> A(2 * n, vector<uint32_t>(2 * n, INF));
for (int i = 0; i < 2 * n; i++) A[i][i] = 0;
for (int rep = 0; rep < n; rep++) {
vector<vector<uint32_t>> cur(2 * n, vector<uint32_t>(2 * n, INF));
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < 2 * n; j++) {
if (j - 1 >= 0) {
cur[i][j] = min(cur[i][j], A[i][j - 1] + a[rep]);
}
if (j + 1 < 2 * n) {
cur[i][j] = min(cur[i][j], A[i][j + 1] + b[rep]);
}
}
}
A = cur;
}
A = Exp(A, m);
printf("%d\n", (int)A[0][0]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pri;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int t;
cin >> t;
while(t--) {
int n, m;
cin >> n >> m;
map<int, int> mp;
for(int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
mp[b] |= (1 << (a - 1));
}
bool isLast = false;
int num = 0;
bool flag = true;
for(auto[a, b] : mp) {
if (b != 3 && isLast) {
int tmp = (a + b) % 2;
if(tmp == num) {
flag = false;
break;
} else {
isLast = false;
}
} else if(b == 3 && isLast) {
flag = false;
break;
} else if(b != 3){
num = (a + b) % 2;
isLast = true;
}
}
if(isLast) flag = false;
if(flag) cout << "YES" << endl;
else cout << "NO" << endl;
}
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
char s[100000];
int col[100000], dp[21][1 << 20];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf(" %s", s);
for (int j = 0; j < m; j++) col[j] |= (s[j] - '0') << i;
}
for (int i = 0; i < m; i++) dp[0][col[i]]++;
for (int k = 1; k <= n; k++)
for (int mask = 0; mask < (1 << n); mask++) {
int sum = k > 1 ? (k - 2 - n) * dp[k - 2][mask] : 0;
for (int p = 0; p < n; p++) sum += dp[k - 1][mask ^ (1 << p)];
dp[k][mask] = sum / k;
}
int ans = n * m;
for (int mask = 0; mask < (1 << n); mask++) {
int cnt = 0;
for (int k = 0; k <= n; k++) cnt += min(k, n - k) * dp[k][mask];
ans = min(ans, cnt);
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m;
vector<int> g[100020];
int par[100020];
bool vis[100020];
vector<int> ans;
void DFS(int u) {
par[u] ^= 1;
ans.push_back(u);
vis[u] = true;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (vis[v]) continue;
DFS(v);
par[u] ^= 1;
ans.push_back(u);
if (par[v]) {
ans.push_back(v);
ans.push_back(u);
par[u] ^= 1;
par[v] ^= 1;
}
}
}
int main() {
int u, v, x;
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i <= n; i++) {
g[i].clear();
vis[i] = false;
}
ans.clear();
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
int root = -1;
for (int i = 1; i <= n; i++) {
scanf("%d", &par[i]);
if (par[i] == 1) root = i;
}
if (root == -1) {
printf("0\n");
break;
}
DFS(root);
if (par[root]) {
ans.pop_back();
par[root] ^= 1;
}
bool ret = true;
for (int i = 1; i <= n; i++) {
if (par[i]) {
ret = false;
printf("-1\n");
break;
}
}
if (ret) {
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d", ans[i]);
if (i == ans.size() - 1)
printf("\n");
else
printf(" ");
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101010;
int n, m, k, a[N];
pair<int, int> it[4 * N];
vector<pair<int, int> > ans;
void build(int k, int l, int r) {
if (l == r) {
it[k].first = a[l];
it[k].second = l;
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
it[k] = min(it[k * 2], it[k * 2 + 1]);
}
pair<int, int> getminIT(int k, int l, int r, int L, int R) {
if (r < L || R < l) return {1e9, 0};
if (L <= l && r <= R) {
return it[k];
}
int mid = (l + r) / 2;
return min(getminIT(k * 2, l, mid, L, R),
getminIT(k * 2 + 1, mid + 1, r, L, R));
}
void solve(int l, int r, int val) {
pair<int, int> u = getminIT(1, 1, n, l, r);
int canthem = u.first - val;
for (int i = 1; i <= canthem; i++) ans.push_back({l, r});
int pos = u.second;
if (l <= pos - 1) solve(l, pos - 1, u.first);
if (pos + 1 <= r) solve(pos + 1, r, u.first);
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
solve(1, n, 0);
cout << ans.size() << "\n";
for (auto x : ans) cout << x.first << " " << x.second << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = 1ll << 50;
const long long maxn = 100005;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << "a" << endl;
long long x;
cin >> x;
if (x == 300) {
cout << string(300, 'b') << endl;
return 0;
}
cout << string(x + 1, 'a') << endl;
long long cur;
cin >> cur;
if (cur > x) {
cout << string(x, 'b') << endl;
return 0;
}
if (cur == 0) {
cout << string(x + 1, 'a') << endl;
return 0;
} else {
string res = string(x + 1, 'a');
int len = x + 1;
long long tmp;
for (int i = len - 1; i >= 0; i--) {
res[i] = 'b';
cout << res << endl;
cin >> tmp;
if (tmp == 0) {
return 0;
}
if (tmp > cur) {
res[i] = 'a';
} else {
cur = tmp;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535897932384626433832795;
int main() {
int n, x0;
cin >> n >> x0;
vector<int> a(n), b(n);
for (int i = 0; i < (n); i++) cin >> a[i] >> b[i];
for (int i = 0; i < (n); i++)
if (a[i] > b[i]) swap(a[i], b[i]);
int cnt[5000] = {};
for (int i = 0; i < (n); i++)
for (int j = (a[i]); j <= (b[i]); j++) cnt[j]++;
int mi = 123456789;
for (int i = 0; i < (5000); i++)
if (cnt[i] == n) mi = min(mi, abs(x0 - i));
if (mi == 123456789)
cout << -1;
else
cout << mi;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char chr = getchar();
int f = 1, ans = 0;
while (!isdigit(chr)) {
if (chr == '-') f = -1;
chr = getchar();
}
while (isdigit(chr)) {
ans = ans * 10;
ans += chr - '0';
chr = getchar();
}
return ans * f;
}
int n;
int x[60005], v[60005];
bool pd(double p) {
double maxn = -2e11, minn = 2e11;
for (int i = 1; i <= n; i++) {
maxn = max(x[i] - v[i] * p, maxn);
minn = min(x[i] + v[i] * p, minn);
}
return minn >= maxn;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) x[i] = read();
for (int i = 1; i <= n; i++) v[i] = read();
double l = 0, r = 1000000000, mid, eps = 1e-6;
while (l - r <= eps) {
double mid = (l + r) / 2;
if (pd(mid))
r = mid - eps;
else
l = mid + eps;
}
printf("%.10f", l);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, m;
pair<int, pair<int, int> > st[4000001];
void update(int id, int l, int r) {
if (l == r) {
if (s[l] == '(') {
st[id] = pair<int, pair<int, int> >(0, pair<int, int>(1, 0));
} else {
st[id] = pair<int, pair<int, int> >(0, pair<int, int>(0, 1));
}
return;
}
int mid = (l + r) / 2;
update(id * 2, l, mid);
update(id * 2 + 1, mid + 1, r);
int tmp = min(st[id * 2].second.first, st[id * 2 + 1].second.second);
st[id].first = st[id * 2].first + st[id * 2 + 1].first + tmp;
st[id].second.first =
st[id * 2].second.first + st[id * 2 + 1].second.first - tmp;
st[id].second.second =
st[id * 2].second.second + st[id * 2 + 1].second.second - tmp;
}
pair<int, pair<int, int> > get(int id, int l, int r, int u, int v) {
if (v < l || u > r) {
return pair<int, pair<int, int> >(0, pair<int, int>(0, 0));
}
if (l >= u && r <= v) {
return st[id];
}
int mid = (l + r) / 2;
pair<int, pair<int, int> > a = get(id * 2, l, mid, u, v);
pair<int, pair<int, int> > b = get(id * 2 + 1, mid + 1, r, u, v);
int tmp = min(a.second.first, b.second.second);
int res = (a.first + b.first + tmp);
int o = a.second.first + b.second.first - tmp;
int c = a.second.second + b.second.second - tmp;
return pair<int, pair<int, int> >(res, pair<int, int>(o, c));
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.size();
s = '#' + s;
update(1, 1, n);
cin >> m;
while (m--) {
int l, r;
cin >> l >> r;
cout << get(1, 1, n, l, r).first * 2 << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500000;
mt19937 Rand(time(0));
int mod[3];
struct hasher {
int a[3];
hasher(int x = 0) { a[0] = a[1] = a[2] = x; }
friend hasher operator+(const hasher &a, const hasher &b) {
hasher res;
for (int i = 0; i < 3; ++i) {
res.a[i] = a.a[i] + b.a[i];
if (res.a[i] >= mod[i]) res.a[i] -= mod[i];
}
return res;
}
friend hasher operator-(const hasher &a, const hasher &b) {
hasher res;
for (int i = 0; i < 3; ++i) {
res.a[i] = a.a[i] - b.a[i];
if (res.a[i] < 0) res.a[i] += mod[i];
}
return res;
}
friend hasher operator*(const hasher &a, const hasher &b) {
hasher res;
for (int i = 0; i < 3; ++i) res.a[i] = 1LL * a.a[i] * b.a[i] % mod[i];
return res;
}
friend bool operator==(const hasher &a, const hasher &b) {
for (int i = 0; i < 3; ++i)
if (a.a[i] != b.a[i]) return 0;
return 1;
}
hasher inv() {
hasher res = 1;
for (int i = 0; i < 3; ++i) {
int k = mod[i] - 2, x = a[i];
for (; k; k >>= 1, x = 1LL * x * x % mod[i])
if (k & 1) res.a[i] = 1LL * res.a[i] * x % mod[i];
}
return res;
}
} pw[N + 9];
void Get_pw() {
pw[0] = 1;
pw[1] = 10;
for (int i = 2; i <= N; ++i) pw[i] = pw[i - 1] * pw[1];
}
hasher Get_hash(hasher *h, int l, int r) {
return h[r] - h[l - 1] * pw[r - l + 1];
}
hasher Get_hash(vector<hasher> &h, int l, int r) {
return h[r] - h[l - 1] * pw[r - l + 1];
}
char s[N + 9], t[N + 9];
int n, m;
void into() {
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
}
int Get_mod0() { return 19260817; }
bool Check_prime(int n) {
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) return 0;
return 1;
}
int Get_prime(int n) {
for (; !Check_prime(n); ++n)
;
return n;
}
int Get_mod1() {
int sum = 0;
for (int i = 1; i <= n; ++i) sum += s[i];
for (int i = 1; i <= m; ++i) sum += t[i];
int n = Rand() % 200000000 + 300000000 + sum;
return Get_prime(n);
}
int Get_mod2() {
int x = Rand() % 200000000 + 300000000;
double y = 1.0 * (Rand() % 10);
int sum = 0;
for (int i = 1; i <= n; ++i) sum += s[i];
for (int i = 1; i <= m; ++i) sum += t[i];
return Get_prime((int)(x + exp(y) + cos(sum) * sum));
}
void Get_mod() {
mod[0] = Get_mod0();
mod[1] = Get_mod1();
mod[2] = Get_mod2();
}
hasher hs[N + 9], ht[N + 9];
void Get_hash() {
for (int i = 1; i <= n; ++i) hs[i] = hs[i - 1] * pw[1] + (s[i] - '0');
for (int i = 1; i <= m; ++i) ht[i] = ht[i - 1] * pw[1] + (t[i] - '0');
}
int Get_lcp(int p) {
int l = 1, r = m, res = 0;
for (int mid; l <= r;) {
mid = l + r >> 1;
Get_hash(hs, p, p + mid - 1) == Get_hash(ht, 1, mid)
? (res = mid, l = mid + 1)
: r = mid - 1;
}
return res;
}
void Get_ans() {
for (int i = 1; i <= n; ++i) {
if (i - (m - 1) >= 0 || i + (m - 1) <= n) {
if (Get_hash(hs, i - (m - 1) + 1, i) + Get_hash(hs, i + 1, i + (m - 1)) ==
ht[m]) {
printf("%d %d\n%d %d\n", i - (m - 1) + 1, i, i + 1, i + (m - 1));
return;
}
}
if (i + m <= n) {
int t = m - Get_lcp(i + 1);
if (t >= 1 && i >= t &&
Get_hash(hs, i + 1, i + m) + Get_hash(hs, i - t + 1, i) == ht[m]) {
printf("%d %d\n%d %d\n", i - t + 1, i, i + 1, i + m);
return;
}
if (t >= 2 && i >= t - 1 &&
Get_hash(hs, i + 1, i + m) + Get_hash(hs, i - t + 2, i) == ht[m]) {
printf("%d %d\n%d %d\n", i - t + 2, i, i + 1, i + m);
return;
}
}
if (i - m >= 0) {
int t = m - Get_lcp(i - m + 1);
if (t >= 1 && i + t <= n &&
Get_hash(hs, i - m + 1, i) + Get_hash(hs, i + 1, i + t) == ht[m]) {
printf("%d %d\n%d %d\n", i - m + 1, i, i + 1, i + t);
return;
}
if (t >= 2 && i + t - 1 <= n &&
Get_hash(hs, i - m + 1, i) + Get_hash(hs, i + 1, i + t - 1) ==
ht[m]) {
printf("%d %d\n%d %d\n", i - m + 1, i, i + 1, i + t - 1);
return;
}
}
}
}
void work() {
Get_mod();
Get_pw();
Get_hash();
Get_ans();
}
void outo() {}
int main() {
int T = 1;
for (; T--;) {
into();
work();
outo();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct Namori {
vector<vector<int> > g;
vector<int> in;
Namori(int n) : g(n), in(n, 0) {}
void add_edge(int x, int y) {
g[x].push_back(y);
g[y].push_back(x);
++in[x];
++in[y];
}
void decomposition(vector<int> &loop, vector<vector<int> > &forest) {
int N = (int)in.size();
forest.resize(N);
queue<int> que;
vector<bool> v(N, 0);
for (int i = 0; i < N; i++) {
if (in[i] == 1) {
que.emplace(i);
v[i] = true;
}
}
while (!que.empty()) {
int idx = que.front();
que.pop();
for (auto &to : g[idx]) {
if (v[to]) continue;
--in[to];
forest[to].push_back(idx);
forest[idx].push_back(to);
if (in[to] > 1) continue;
que.emplace(to);
v[to] = true;
}
}
function<void(int)> dfs = [&](int idx) {
loop.push_back(idx);
for (auto &to : g[idx]) {
if (v[to]) continue;
v[to] = true;
dfs(to);
}
};
for (int i = 0; i < N; i++) {
if (v[i]) continue;
v[i] = true;
dfs(i);
break;
}
}
};
const long long INF = 1LL << 58;
struct SegNode {
long long ans, leftans, rightans;
long long rowsum;
SegNode() {}
SegNode(long long a, long long b, long long c, long long d)
: ans(a), leftans(b), rightans(c), rowsum(d) {}
} e(-INF, -INF, -INF, 0);
SegNode operator*(const SegNode &a, const SegNode &b) {
SegNode c;
c.ans = max({a.ans, b.ans, a.leftans + b.rightans});
c.leftans = max(a.leftans + b.rowsum, b.leftans);
c.rightans = max(a.rightans, b.rightans + a.rowsum);
c.rowsum = a.rowsum + b.rowsum;
return (c);
}
struct SegmentTree {
int sz;
vector<SegNode> seg;
SegmentTree(int n) {
sz = 1;
while (sz < n) sz <<= 1;
seg.assign(2 * sz - 1, e);
}
void update(int k, const SegNode &x) {
k += sz - 1;
seg[k] = x;
while (k > 0) {
k = (k - 1) >> 1;
seg[k] = seg[2 * k + 1] * seg[2 * k + 2];
}
}
SegNode query(int a, int b, int k, int l, int r) {
if (a >= r || b <= l) return (e);
if (a <= l && r <= b) return (seg[k]);
return (query(a, b, 2 * k + 1, l, (l + r) >> 1) *
query(a, b, 2 * k + 2, (l + r) >> 1, r));
}
long long query(int a, int b) { return (query(a, b, 0, 0, sz).ans); }
};
int main() {
int N;
cin >> N;
Namori namori(N);
map<pair<int, int>, int> cost;
for (int i = 0; i < N; i++) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
namori.add_edge(a, b);
cost[{a, b}] = c;
cost[{b, a}] = c;
}
vector<int> loop;
vector<vector<int> > tree;
namori.decomposition(loop, tree);
vector<long long> dp(N, 0);
long long ret1 = 0, ret2 = INF;
function<void(int, int)> rec = [&](int idx, int par) {
for (auto &to : tree[idx]) {
if (to == par) continue;
rec(to, idx);
dp[idx] = max(dp[idx], dp[to] + cost[{idx, to}]);
}
};
function<void(int, long long, int)> rec2 = [&](int idx, long long pardep,
int par) {
vector<pair<long long, int> > dist;
dist.emplace_back(pardep, par);
for (auto &to : tree[idx]) {
if (to == par) continue;
dist.emplace_back(dp[to] + cost[{idx, to}], to);
}
sort(dist.rbegin(), dist.rend());
ret1 = max(ret1, dist[0].first);
for (auto &to : tree[idx]) {
if (to == par) continue;
rec2(to, dist[to == dist[0].second].first + cost[{idx, to}], idx);
}
};
for (int i : loop) rec(i, -1);
for (int i : loop) rec2(i, 0, -1);
SegmentTree seg(loop.size() * 2);
for (int i = 0; i < loop.size() * 2; i++) {
long long latte = dp[loop[i % loop.size()]];
long long malta = cost[{loop[(i - 1 + loop.size()) % loop.size()],
loop[i % loop.size()]}];
seg.update(i, SegNode(latte, latte, latte + malta, malta));
}
for (int i = 0; i < loop.size(); i++) {
ret2 = min(ret2, seg.query(i, i + loop.size()));
}
cout << max(ret2, ret1) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ar[100000];
int main() {
int n, m;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d %d", &a, &b);
ar[a]++;
ar[b]++;
}
long long sum = 0;
for (int i = 1; i <= n; ++i) {
sum += (ar[i] * (ar[i] - 1) / 2);
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
getline(cin, str);
int l = str.length();
int i = l - 1;
while (i >= 0) {
if (str[i] != '?' && str[i] != ' ') {
if (str[i] == 'a' || str[i] == 'e' || str[i] == 'i' || str[i] == 'o' ||
str[i] == 'u' || str[i] == 'y' || str[i] == 'A' || str[i] == 'E' ||
str[i] == 'I' || str[i] == 'O' || str[i] == 'U' || str[i] == 'Y') {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
break;
} else {
i--;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int N = 200005;
int z, n, p[N], m[N], kol[N], w, alr, bid[N], last, i;
long long res;
set<pair<int, int> > s;
set<pair<int, int> >::iterator pp;
bool cmp(int a, int b) { return m[a] < m[b]; }
int main() {
scanf("%d", &z);
while (z--) {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d %d", &m[i], &p[i]);
kol[i] = i;
}
sort(kol, kol + n, cmp);
last = 0;
for (i = 0; i < n; i++) {
w = kol[i];
if (m[w] == last) {
bid[w] = 0;
continue;
}
bid[w] = max(0, m[w] - i);
last = m[w];
}
s.clear();
alr = 0;
res = 0;
for (i = n - 1; i >= 0; i--) {
w = kol[i];
s.insert(pair<int, int>(p[w], w));
while (alr < bid[w]) {
pp = s.begin();
alr++;
res += pp->first;
s.erase(pp);
}
}
printf("%lld\n", res);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int isprime[100005];
for (int i = 2; i < 100005; i++) isprime[i] = 1;
isprime[1] = 0;
for (int i = 2; i < 100005; i++) {
if (isprime[i]) {
v.push_back(i);
for (int j = i + i; j < 100005; j += i) isprime[j] = 0;
}
}
int tot = v.size();
int n, m, cnt;
cin >> n >> m;
int rowmax = INT_MAX;
int colmax = INT_MAX;
int mat[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j];
for (int i = 0; i < n; i++) {
cnt = 0;
for (int j = 0; j < m; j++) {
if (*lower_bound(v.begin(), v.end(), mat[i][j]) == 999913 &&
!isprime[mat[i][j]]) {
cnt = rowmax;
break;
} else {
cnt += (isprime[mat[i][j]] == 1)
? 0
: (*upper_bound(v.begin(), v.end(), mat[i][j]) - mat[i][j]);
}
}
rowmax = min(rowmax, cnt);
}
for (int j = 0; j < m; j++) {
cnt = 0;
for (int i = 0; i < n; i++) {
if (*lower_bound(v.begin(), v.end(), mat[i][j]) == 999913 &&
!isprime[mat[i][j]]) {
cnt = colmax;
break;
} else {
cnt += (isprime[mat[i][j]] == 1)
? 0
: (*upper_bound(v.begin(), v.end(), mat[i][j]) - mat[i][j]);
}
}
colmax = min(colmax, cnt);
}
cout << min(rowmax, colmax);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int N = 2e5 + 10;
const int M = 1000 + 10;
const int mod = (int)1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1.0);
struct E {
int v, nxt, d;
} e[N << 1];
int k;
int head[N], tot;
void init() {
tot = 0;
memset(head, 0, sizeof(int) * (k * 2 + 5));
}
inline void add(int u, int v, int d) {
e[++tot] = {v, head[u], d};
head[u] = tot;
}
long long G, B;
pair<int, bool> dfs(int u, int fa) {
int d = -1;
int sz = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
pair<int, bool> p = dfs(v, u);
sz += p.first;
B += (long long)min(p.first, 2 * k - p.first) * e[i].d;
if (p.second) {
if (d == -1)
d = e[i].d;
else {
G += d + e[i].d;
d = -1;
}
}
}
if (~d) G += d;
return {sz, d == -1};
}
void work() {
cin >> k;
init();
for (int i = 0; i < 2 * k - 1; i++) {
int x, y, z;
cin >> x >> y >> z;
add(x, y, z);
add(y, x, z);
}
G = B = 0;
dfs(1, -1);
cout << G << " " << B << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) work();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using pii = pair<int, int>;
const int MOD = 1e9 + 7;
const int MAX = 1e5 + 5;
const ll INF = 1e18 + 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> v(n);
for (auto&& i : v) cin >> i;
sort(v.begin(), v.end());
if (v.back() == 1)
v[n - 1] = 2;
else
v[n - 1] = 1;
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) cout << v[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int N = 1e6 + 10;
int n;
ll a[N], r1, r2, r3, d;
ll black[N], white[N], dp[N], suf[N];
void umin(ll &a, ll b) { a = min(a, b); }
int main() {
scanf("%d%lld%lld%lld%lld", &n, &r1, &r2, &r3, &d);
for (int i = 1; i <= n; ++i) {
scanf("%lld", a + i);
black[i] = a[i] * r1 + r3;
white[i] = min((a[i] + 1) * r1, ll(r2));
}
for (int i = 1; i <= n; ++i) {
dp[i] = 1e18;
umin(dp[i], dp[i - 1] + d + black[i]);
umin(dp[i], dp[i - 1] + 3 * d + white[i] + r1);
if (i > 1)
umin(dp[i], dp[i - 2] + 4 * d + white[i - 1] + white[i] + r1 + r1);
}
for (int i = n - 1; 1 <= i; --i) {
suf[i] = suf[i + 1] + min(black[i], white[i] + r1);
}
ll out = 1e18;
for (int e = 1; e <= n; ++e) {
ll now = dp[e - 1] - (e > 1 ? d : 0) + suf[e] +
min(black[n], white[n] + r1 + 2 * d) + 2 * ll(d) * (n - e) +
(e > 1 ? d : 0);
umin(out, now);
}
printf("%lld\n", min(out, dp[n] - d));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long double dist(long double x, long double y, long double a, long double b) {
return sqrt((a - x) * (a - x) + (y - b) * (y - b));
}
long double distMan(long double x, long double y, long double a,
long double b) {
return abs(x - a) + abs(y - b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tt = 1;
while (tt--) {
long double a, b, c;
cin >> a >> b >> c;
long double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (a == 0 || b == 0) {
cout << ' ' << fixed << setprecision(20) << ' '
<< abs(x1 - x2) + abs(y1 - y2) << '\n';
} else {
long double ans = abs(x2 - x1) + abs(y2 - y1);
long double x3, y3, x4, y4;
x3 = x1, x4 = x2;
y3 = (-a * x3 - c) / b, y4 = (-a * x4 - c) / b;
ans = min(ans, distMan(x1, y1, x3, y3) + distMan(x2, y2, x4, y4) +
dist(x4, y4, x3, y3));
x3 = x1, y4 = y2;
y3 = (-a * x3 - c) / b, x4 = (-b * y4 - c) / a;
ans = min(ans, distMan(x1, y1, x3, y3) + distMan(x2, y2, x4, y4) +
dist(x4, y4, x3, y3));
y3 = y1, x4 = x2;
x3 = (-b * y3 - c) / a, y4 = (-a * x4 - c) / b;
ans = min(ans, distMan(x1, y1, x3, y3) + distMan(x2, y2, x4, y4) +
dist(x4, y4, x3, y3));
y3 = y1, y4 = y2;
x3 = (-b * y3 - c) / a, x4 = (-b * y4 - c) / a;
ans = min(ans, distMan(x1, y1, x3, y3) + distMan(x2, y2, x4, y4) +
dist(x4, y4, x3, y3));
cout << ' ' << fixed << setprecision(20) << ' ' << ans << '\n';
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 10;
int n;
int l[MAXN], h[MAXN];
int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int main() {
cin >> n;
char tmp;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
cin >> tmp;
if (tmp == 'C') l[i]++, h[j]++;
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans += l[i] * (l[i] - 1) / 2 + h[i] * (h[i] - 1) / 2;
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int b, k;
int main() {
cin >> b >> k;
int fl = 0;
for (int i = 0; i < k; ++i) {
int x;
cin >> x;
if (i == k - 1) b = 1;
fl ^= ((b % 2) * (x % 2));
}
cout << (fl ? "odd" : "even");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch;
int x = 0, f = 1;
while (ch = getchar(), ch < '!')
;
if (ch == '-') f = -1, ch = getchar();
while (x = x * 10 + ch - '0', ch = getchar(), isdigit(ch))
;
return f * x;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int power(int x, int y, int mod) {
int res = 1;
while (y) {
if (y & 1) res = 1LL * res * x % mod;
y >>= 1, x = 1LL * x * x % mod;
}
return res;
}
int m, phi;
int niv(int x) { return power(x, phi - 1, m); }
const int N = 200005;
vector<int> G[N], p[N], ans;
int n, val[N], to[N], f[N];
int tmp[N], cnt;
bool no[N];
void init(int x) {
phi = x;
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
tmp[++cnt] = i;
phi -= phi / i;
while (x % i == 0) x /= i;
}
if (x > 1) phi -= phi / x, tmp[++cnt] = x;
}
void dfs(int u) {
for (int i = 1; i <= cnt; i++) {
long long v = 1LL * u * tmp[i];
if (v >= m) continue;
dfs(v);
if (f[v] > f[to[u]]) to[u] = v;
}
f[u] = f[to[u]] + val[u];
}
int main() {
n = read(), m = read();
init(m);
for (int i = 1, x; i <= n; i++) {
x = read();
no[x] = 1;
}
for (int i = 1; i < m; i++)
if (!no[i]) {
int bl = gcd(i, m);
val[bl]++, p[bl].push_back(i);
}
dfs(1);
int now = 1;
for (int i = 1; i; i = to[i]) {
for (int j = 0; j < p[i].size(); j++) {
int g = gcd(now, p[i][j]);
ans.push_back(1LL * niv(now / g) * (p[i][j] / g) % m);
now = p[i][j];
}
}
if (!no[0]) ans.push_back(0);
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, ret;
vector<pair<int, int> > edge[105];
void dfs(int pre, int u) {
if (u == 1) return;
for (int i = 0; i < edge[u].size(); i++) {
int v = edge[u][i].first;
int w = edge[u][i].second;
if (v == pre) continue;
ret += w;
dfs(u, v);
}
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
edge[u].push_back(make_pair(v, 0));
edge[v].push_back(make_pair(u, w));
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < edge[1].size(); i++) {
int v = edge[1][i].first;
ret = edge[1][i].second;
dfs(1, v);
ans = min(ans, ret);
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e3 + 5;
vector<long long int> sums[N];
vector<pair<int, int> > pos[N], xmax, ymax;
bool mark[N], flags[N];
int lens[N];
pair<int, int> arr[N][N];
long long int ans;
int chkr(int x1, int y1, int x2, int y2, int X1, int Y1) {
if (X1 < x1 || X1 > x2 || Y1 < y1 || Y1 > y2) return 1;
return 0;
}
void chkr2(int x1, int y1, int x2, int y2, int x, int y) {
int X1 = pos[x][0].first;
int Y1 = pos[x][0].second;
if (!(X1 < x1 || X1 > x2 || Y1 < y1 || Y1 > y2)) {
flags[x] = 1;
ans += sums[x][0];
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
arr[i][j] = {-1, -1};
}
}
for (int i = 1; i <= k; i++) {
int len;
scanf("%d", &len);
long long int temp = 0;
int xl, xr, yl, yr;
xl = yl = N;
xr = yr = -1;
for (int j = 1; j <= len; j++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
xl = min(xl, x);
xr = max(xr, x);
yl = min(yl, y);
yr = max(yr, y);
lens[j - 1] = w;
sums[i].push_back(0);
pos[i].push_back({x, y});
arr[x][y] = {i, j};
}
xmax.push_back({xl, xr});
ymax.push_back({yl, yr});
for (int j = len - 1; j >= 0; j--) {
sums[i][j] = temp + (long long int)lens[j];
temp += 1LL * lens[j];
}
}
int q;
cin >> q;
for (int ik = 0; ik < q; ik++) {
string c;
cin >> c;
if (c[0] == 'S') {
int x;
scanf("%d", &x);
mark[x] = 1 - mark[x];
} else {
memset(flags, 0, k + 2);
int xx1, yy1, xx2, yy2;
ans = 0;
scanf("%d%d%d%d", &xx1, &yy1, &xx2, &yy2);
pair<int, int> tt, y1, y2;
for (int i = yy1; i <= yy2; i++) {
tt = arr[xx1][i];
if (tt.first == -1 || mark[tt.first]) continue;
if (tt.second == 1) {
int lo = tt.first - 1;
if (pos[tt.first].size() > 1) {
y2 = pos[tt.first][tt.second];
if (chkr(xx1, yy1, xx2, yy2, y2.first, y2.second)) {
ans -= sums[tt.first][tt.second];
if (!flags[tt.first])
chkr2(xx1, yy1, xx2, yy2, tt.first, tt.second);
}
}
} else {
if (tt.second != pos[tt.first].size()) {
y2 = pos[tt.first][tt.second];
if (chkr(xx1, yy1, xx2, yy2, y2.first, y2.second)) {
ans -= sums[tt.first][tt.second];
if (!flags[tt.first])
chkr2(xx1, yy1, xx2, yy2, tt.first, tt.second);
}
}
y1 = pos[tt.first][tt.second - 2];
if (chkr(xx1, yy1, xx2, yy2, y1.first, y1.second)) {
ans += sums[tt.first][tt.second - 1];
}
}
}
for (int i = xx1 + 1; i <= xx2; i++) {
tt = arr[i][yy2];
if (tt.first == -1 || mark[tt.first]) continue;
if (tt.second == 1) {
int lo = tt.first - 1;
if (pos[tt.first].size() > 1) {
y2 = pos[tt.first][tt.second];
if (chkr(xx1, yy1, xx2, yy2, y2.first, y2.second)) {
ans -= sums[tt.first][tt.second];
if (!flags[tt.first])
chkr2(xx1, yy1, xx2, yy2, tt.first, tt.second);
}
}
} else {
if (tt.second != pos[tt.first].size()) {
y2 = pos[tt.first][tt.second];
if (chkr(xx1, yy1, xx2, yy2, y2.first, y2.second)) {
ans -= sums[tt.first][tt.second];
if (!flags[tt.first])
chkr2(xx1, yy1, xx2, yy2, tt.first, tt.second);
}
}
y1 = pos[tt.first][tt.second - 2];
if (chkr(xx1, yy1, xx2, yy2, y1.first, y1.second))
ans += sums[tt.first][tt.second - 1];
}
}
for (int i = yy2 - 1; i >= yy1; i--) {
if (xx1 == xx2) break;
tt = arr[xx2][i];
if (tt.first == -1 || mark[tt.first]) continue;
if (tt.second == 1) {
int lo = tt.first - 1;
if (pos[tt.first].size() > 1) {
y2 = pos[tt.first][tt.second];
if (chkr(xx1, yy1, xx2, yy2, y2.first, y2.second)) {
ans -= sums[tt.first][tt.second];
if (!flags[tt.first])
chkr2(xx1, yy1, xx2, yy2, tt.first, tt.second);
}
}
} else {
if (tt.second != pos[tt.first].size()) {
y2 = pos[tt.first][tt.second];
if (chkr(xx1, yy1, xx2, yy2, y2.first, y2.second)) {
ans -= sums[tt.first][tt.second];
if (!flags[tt.first])
chkr2(xx1, yy1, xx2, yy2, tt.first, tt.second);
}
}
y1 = pos[tt.first][tt.second - 2];
if (chkr(xx1, yy1, xx2, yy2, y1.first, y1.second))
ans += sums[tt.first][tt.second - 1];
}
}
for (int i = xx2 - 1; i > xx1; i--) {
if (yy1 == yy2) break;
tt = arr[i][yy1];
if (tt.first == -1 || mark[tt.first]) continue;
if (tt.second == 1) {
int lo = tt.first - 1;
if (pos[tt.first].size() > 1) {
y2 = pos[tt.first][tt.second];
if (chkr(xx1, yy1, xx2, yy2, y2.first, y2.second)) {
ans -= sums[tt.first][tt.second];
if (!flags[tt.first])
chkr2(xx1, yy1, xx2, yy2, tt.first, tt.second);
}
}
} else {
if (tt.second != pos[tt.first].size()) {
y2 = pos[tt.first][tt.second];
if (chkr(xx1, yy1, xx2, yy2, y2.first, y2.second)) {
ans -= sums[tt.first][tt.second];
if (!flags[tt.first])
chkr2(xx1, yy1, xx2, yy2, tt.first, tt.second);
}
}
y1 = pos[tt.first][tt.second - 2];
if (chkr(xx1, yy1, xx2, yy2, y1.first, y1.second))
ans += sums[tt.first][tt.second - 1];
}
}
for (int i = 0; i < k; i++) {
if (!mark[i + 1] && xx1 <= xmax[i].first && xx2 >= xmax[i].second &&
yy1 <= ymax[i].first && yy2 >= ymax[i].second) {
ans += sums[i + 1][0];
}
}
printf("%lld\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long IN() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void OUT(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
OUT(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
int main() {
int n = IN(), a = IN();
if (a & 1)
printf("%d\n", (a + 1) / 2);
else
printf("%d\n", (n - a) / 2 + 1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
static long long m1[305][305], m2[305], m3[305];
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, mo = -1, m, a, b, c, mx = 0;
cin >> n >> m;
set<long long> se, se1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cin >> m1[i][j];
mx = max(mx, *max_element(m1[i], m1[i] + m));
}
vector<long long> vc, vc1, vcm;
for (int i = 1; i < n; ++i) {
se.clear();
se1.clear();
for (int j = 0; j < m; ++j) {
a = m1[i][j] - m1[i - 1][j];
if (a < 0)
se.insert(a);
else
se1.insert(-a);
}
if (se.size() > 1 || se1.size() > 1) {
cout << "NO\n";
return 0;
}
if (se.size() && se1.size()) vcm.push_back((*se.begin()) + (*se1.begin()));
if (se.size())
vc.push_back(*se.begin());
else
vc.push_back(-(*se1.begin()));
}
for (int i = 1; i < m; ++i) {
se.clear();
se1.clear();
for (int j = 0; j < n; ++j) {
a = m1[j][i] - m1[j][i - 1];
if (a < 0)
se.insert(a);
else
se1.insert(-a);
}
if (se.size() > 1 || se1.size() > 1) {
cout << "NO\n";
return 0;
}
if (se.size() && se1.size()) vcm.push_back((*se.begin()) + (*se1.begin()));
if (se.size())
vc1.push_back(*se.begin());
else
vc1.push_back(-(*se1.begin()));
}
if (vcm.size()) {
a = vcm[0];
for (int i = 1; i < vcm.size(); ++i) a = gcd(a, vcm[i]);
} else
a = mx + 1;
a = abs(a);
if (a <= mx) {
cout << "NO\n";
return 0;
}
cout << "YES " << a << '\n';
m3[0] = m1[0][0];
for (int i = 0; i < vc.size(); ++i) m2[i + 1] = (m2[i] + vc[i] + a) % a;
for (int i = 0; i < vc1.size(); ++i) m3[i + 1] = (m3[i] + vc1[i] + a) % a;
for (int i = 0; i < vc.size() + 1; ++i) cout << m2[i] << ' ';
cout << '\n';
for (int i = 0; i < vc1.size() + 1; ++i) cout << m3[i] << ' ';
cout << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 35005;
int n, k;
int dp[55][maxn];
int tree[maxn << 2], lazy[maxn << 2];
int a[maxn], pre[maxn], pos[maxn];
void init() {
memset(tree, 0, sizeof(tree));
memset(pos, 0, sizeof(pos));
memset(pre, 0, sizeof(pre));
memset(dp, 0, sizeof(dp));
}
void pushup(int rt) { tree[rt] = max(tree[rt << 1], tree[rt << 1 | 1]); }
void pushdown(int rt) {
tree[rt << 1] += lazy[rt];
tree[rt << 1 | 1] += lazy[rt];
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
lazy[rt] = 0;
}
void build(int pos, int l, int r, int rt) {
lazy[rt] = 0;
if (l == r) {
tree[rt] = dp[pos][l - 1];
return;
}
int m = (l + r) / 2;
build(pos, l, m, rt << 1);
build(pos, m + 1, r, rt << 1 | 1);
pushup(rt);
}
void update(int L, int R, int l, int r, int rt) {
if (L == l && R == r) {
tree[rt]++;
lazy[rt]++;
return;
}
pushdown(rt);
int m = (l + r) / 2;
if (L > m)
update(L, R, m + 1, r, rt << 1 | 1);
else if (R <= m)
update(L, R, l, m, rt << 1);
else {
update(L, m, l, m, rt << 1);
update(m + 1, R, m + 1, r, rt << 1 | 1);
}
pushup(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L == l && R == r) {
return tree[rt];
}
pushdown(rt);
int m = (l + r) / 2;
int ans = 0;
if (L > m)
ans = max(ans, query(L, R, m + 1, r, rt << 1 | 1));
else if (R <= m)
ans = max(ans, query(L, R, l, m, rt << 1));
else {
ans = max(ans, max(query(L, m, l, m, rt << 1),
query(m + 1, R, m + 1, r, rt << 1 | 1)));
}
return ans;
}
int main() {
while (~scanf("%d%d", &n, &k)) {
init();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pre[i] = pos[a[i]] + 1;
pos[a[i]] = i;
}
for (int i = 1; i <= k; i++) {
build(i - 1, 1, n, 1);
for (int j = 1; j <= n; j++) {
update(pre[j], j, 1, n, 1);
dp[i][j] = query(1, j, 1, n, 1);
}
}
printf("%d\n", dp[k][n]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 10;
const int INF = 1000;
int a[N][N], n, m;
vector<pair<int, int> > ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i][j]);
if (n < m) {
for (int i = 0; i < n; i++) {
int x = INF;
for (int j = 0; j < m; j++) x = min(x, a[i][j]);
for (int j = 0; j < x; j++) ans.push_back(pair<int, int>(i, 0));
for (int j = 0; j < m; j++) a[i][j] -= x;
}
for (int i = 0; i < m; i++) {
int x = INF;
for (int j = 0; j < n; j++) x = min(x, a[j][i]);
for (int j = 0; j < x; j++) ans.push_back(pair<int, int>(i, 1));
for (int j = 0; j < n; j++) a[j][i] -= x;
}
} else {
for (int i = 0; i < m; i++) {
int x = INF;
for (int j = 0; j < n; j++) x = min(x, a[j][i]);
for (int j = 0; j < x; j++) ans.push_back(pair<int, int>(i, 1));
for (int j = 0; j < n; j++) a[j][i] -= x;
}
for (int i = 0; i < n; i++) {
int x = INF;
for (int j = 0; j < m; j++) x = min(x, a[i][j]);
for (int j = 0; j < x; j++) ans.push_back(pair<int, int>(i, 0));
for (int j = 0; j < m; j++) a[i][j] -= x;
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j]) {
printf("-1\n");
return 0;
}
printf("%d\n", (int)ans.size());
for (pair<int, int> it : ans) {
if (it.second == 0)
printf("row %d\n", it.first + 1);
else
printf("col %d\n", it.first + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int maxn = 16;
const int mod = 998244353;
int n, a[maxn], b[maxn];
int sr, sb;
int f[1 << maxn][maxn * maxn];
inline void up(int& x, int y) {
if (x < y) {
x = y;
}
}
inline void down(int& x, int y) {
if (x > y) {
x = y;
}
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
int sumr = 0, sumb = 0;
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
(c == 'R' ? sr : sb) |= 1 << i;
cin >> a[i] >> b[i];
sumr += a[i];
sumb += b[i];
}
const int N = n * (n - 1) >> 1;
for (int i = 0; i < 1 << n; ++i)
for (int j = 0; j <= N; ++j) {
f[i][j] = -1e9;
}
f[0][0] = 0;
for (int i = 0; i < 1 << n; ++i) {
int cr = __builtin_popcount(i & sr), cb = __builtin_popcount(i & sb);
for (int j = (0),
jend = (__builtin_popcount(i) * (__builtin_popcount(i) - 1) >> 1);
j <= jend; ++j) {
for (int k = (0), kend = (n - 1); k <= kend; ++k)
if ((i >> k & 1) == 0) {
const int R = std::min(cr, a[k]), B = std::min(cb, b[k]);
up(f[i | 1 << k][j + R], f[i][j] + B);
}
}
}
int ans = 1e9;
for (int j = (0), jend = (N); j <= jend; ++j) {
down(ans, std::max(sumr - j, sumb - f[(1 << n) - 1][j]));
}
cout << ans + n << '\n';
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int bit[(int)5e5 + 100];
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int T, n, k;
cin >> T;
while (T--) {
cin >> n >> k;
vector<int> a, b;
int mx = 0;
for (int i = 1, x; i <= n; ++i) {
cin >> x, mx = max(mx, abs(x));
if (x > 0) a.emplace_back(x);
if (x < 0) b.emplace_back(-x);
}
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
long long ans = 0;
for (int i = (int)a.size() - 1; i >= 0; i -= k) ans += a[i] << 1;
for (int i = (int)b.size() - 1; i >= 0; i -= k) ans += b[i] << 1;
cout << ans - mx << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
bool mycomppf(const pair<int, int> &p1, const pair<int, int> &p2) {
if (p1.first <= p2.first) return true;
return false;
}
inline long long gcd(long long a, long long b) {
return (b == 0) ? a : gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(5);
cout << fixed;
string input;
cin >> input;
if (input.length() & 1)
cout << -1 << '\n';
else {
long long ud = 0, rl = 0;
for (int(i) = 0; (i) < (int)(input.length()); ++(i)) {
if (input[i] == 'U')
ud++;
else if (input[i] == 'D')
ud--;
else if (input[i] == 'L')
rl--;
else
rl++;
}
if (!((abs(ud) + abs(rl)) & 1))
cout << (abs(ud) + abs(rl)) / 2 << '\n';
else
cout << -1 << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300100;
struct DSU {
int p[MAXN];
DSU() { iota(p, p + MAXN, 0); }
int find(int x) {
if (x == p[x]) return x;
return p[x] = find(p[x]);
}
void unite(int a, int b) { p[find(a)] = find(b); }
int ask(int a, int b) { return find(a) == find(b); }
};
int n, m;
vector<int> E[MAXN];
const int LOG = 20;
int lca[MAXN][LOG];
int dub[MAXN];
void dfs(int cvor, int par) {
for (auto ncvor : E[cvor]) {
if (ncvor == par) continue;
lca[ncvor][0] = cvor;
dub[ncvor] = dub[cvor] + 1;
dfs(ncvor, cvor);
}
}
int get_lca(int a, int b) {
if (dub[a] < dub[b]) swap(a, b);
for (int i = LOG - 1; i >= 0; i--) {
if (dub[a] - (1 << i) >= dub[b]) {
a = lca[a][i];
}
}
if (a == b) return a;
for (int i = LOG - 1; i >= 0; i--) {
if (lca[a][i] != lca[b][i]) {
a = lca[a][i];
b = lca[b][i];
}
}
return lca[a][0];
}
int cnt[MAXN];
int kolko[MAXN];
int sol;
int main() {
scanf("%d %d", &n, &m);
DSU U;
for (int i = (0); i < int(m); i++) {
int a, b;
scanf("%d %d", &a, &b);
if (!U.ask(a, b)) {
E[a].push_back(b);
E[b].push_back(a);
U.unite(a, b);
}
}
dfs(1, -1);
for (int i = 1; i < LOG; i++) {
for (int j = (1); j < int(n + 1); j++) {
lca[j][i] = lca[lca[j][i - 1]][i - 1];
}
}
int q;
scanf("%d", &q);
vector<vector<int> > ans;
for (int i = (0); i < int(q); i++) {
int a, b;
scanf("%d %d", &a, &b);
int l = get_lca(a, b);
cnt[a]++;
cnt[b]++;
cnt[l] -= 2;
vector<int> tmp;
ans.push_back(tmp);
int cvor = a;
while (cvor != l) {
ans.back().push_back(cvor);
cvor = lca[cvor][0];
}
ans.back().push_back(l);
cvor = b;
while (cvor != l) {
tmp.push_back(cvor);
cvor = lca[cvor][0];
}
reverse((tmp).begin(), (tmp).end());
for (auto x : tmp) ans.back().push_back(x);
}
vector<int> bio(n + 2);
vector<int> P;
for (int i = (1); i < int(n + 1); i++) P.push_back(i);
sort((P).begin(), (P).end(), [&](int a, int b) { return dub[a] > dub[b]; });
for (int i = (1); i < int(n + 1); i++) {
if (cnt[i] % 2) {
kolko[i] = 1;
}
}
for (int ii = (0); ii < int(n - 1); ii++) {
int i = P[ii];
sol += min(kolko[i], kolko[lca[i][0]]);
kolko[lca[i][0]] = abs(kolko[i] - kolko[lca[i][0]]);
}
if (!sol) {
puts("YES");
for (int i = (0); i < int((int)ans.size()); i++) {
printf("%d\n", (int)ans[i].size());
for (auto x : ans[i]) printf("%d ", x);
puts("");
}
} else {
puts("NO");
printf("%d\n", sol);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 10;
const long long MOD = 1e9 + 7;
int n, k;
int a[N], pre[N], nex[N];
int stk[N], top;
long long getAns(long long x) {
if (x < k) return 0;
long long c = (x - k) / (k - 1) + 1;
long long a1 = (x - k + 1);
long long len = (x - k) / (k - 1) * (k - 1) + k;
long long ac = x - len + 1;
return c * (a1 + ac) / 2;
}
long long solve(int pos, int L, int R) {
return getAns(R - L - 1) - getAns(pos - L - 1) - getAns(R - pos - 1);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
while (top && a[stk[top]] <= a[i]) top--;
pre[i] = stk[top], stk[++top] = i;
}
top = 0;
stk[top] = n + 1;
for (int i = n; i >= 1; i--) {
while (top && a[stk[top]] < a[i]) top--;
nex[i] = stk[top], stk[++top] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans = ans + solve(i, pre[i], nex[i]) % MOD * a[i] % MOD;
ans = ans % MOD;
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
using namespace std;
const int P = 998244353;
inline long long quickpow(long long x, int k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % P;
x = x * x % P;
k >>= 1;
}
return res;
}
int n;
int a[301000];
long long jie[301000], jieni[301000];
inline void init() {
jie[0] = jieni[0] = 1;
int up = n + n;
for (int i = 1; i <= up; ++i) jie[i] = jie[i - 1] * i % P;
jieni[up] = quickpow(jie[up], P - 2);
for (int i = up - 1; i; --i) jieni[i] = jieni[i + 1] * (i + 1) % P;
}
inline long long get_c(int n, int m) {
if (n < 0 || m < 0 || (n - m) < 0) return 0;
return jie[n] * jieni[m] % P * jieni[n - m] % P;
}
int main() {
read(n);
for (int i = 1; i <= n + n; ++i) read(a[i]);
sort(a + 1, a + 1 + n + n);
init();
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans -= 1ll * a[i] * get_c(n + n - 1, n - 1) % P;
}
for (int i = n + 1; i <= n + n; ++i) {
ans += 1ll * a[i] * get_c(n + n - 1, n - 1) % P;
}
printf("%lld\n", (2ll * ans % P + P) % P);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long m) {
long long r = 1;
for (; y; y >>= 1) {
if (y & 1) r = r * x % m;
x = x * x % m;
}
return r;
}
const long long N = 1e3 + 5, M = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
long long n, k, m = 0, x = 0, i, t = 1, ans = 0, j, y = 0, z = 0, c = 0, w,
last = -1;
double pi = acos(-1.0);
cin >> t;
while (t--) {
cin >> n;
n <<= 1;
double X = 90.0 / n;
cout << fixed << setprecision(9) << 0.5 / sin(X * pi / 180.0);
cout << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void itval(istream_iterator<string> it) {}
template <typename T, typename... Args>
void itval(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
itval(++it, args...);
}
long long int MOD = 1e9 + 7;
template <typename T>
inline void print(T x) {
cout << x << "\n";
}
template <typename T>
inline void printvec(T x) {
for (auto a : x) cout << a << ' ';
cout << '\n';
}
struct custom {
bool operator()(
const pair<pair<long long int, long long int>, int> &p1,
const pair<pair<long long int, long long int>, int> &p2) const {
if (p1.first.first == p2.first.first) {
if (p1.first.second == p2.first.second) return p1.second < p2.second;
return p1.first.second > p2.first.second;
}
return p1.first.first < p2.first.first;
}
};
long long int get_pow(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
const long long int N = 2e5 + 10, inf = 4e18;
void solve() {
int n, dec = -1;
cin >> n;
vector<int> v(n);
for (long long int i = (long long int)0; i < (long long int)(n); i++)
cin >> v[i];
for (long long int i = (long long int)1; i < (long long int)(n); i++) {
if (v[i] > v[i - 1]) {
dec = i - 1;
break;
}
}
if (dec == -1) {
cout << "YES\n";
return;
}
int can_do = v[dec], x = v[dec], last = -1;
v[dec] = 0;
for (long long int i = (long long int)dec + 1; i < (long long int)(n); i++) {
int t = min(v[i] - v[i - 1], can_do);
if (t < 0) {
cout << "NO\n";
return;
}
v[i] -= t;
can_do = min(t, can_do);
}
cout << "YES\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
cin >> test;
clock_t z = clock();
for (long long int tes = (long long int)0; tes < (long long int)(test);
tes++) {
solve();
}
fprintf(stderr, "Total Time:%.4f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int sum[N * 2], l[N * 2], r[N * 2], n;
void build() {
int i, mini;
for (i = n - 1; i > 0; --i) {
mini = min(l[i << 1], r[i << 1 | 1]);
l[i] = l[i << 1] - mini + l[i << 1 | 1],
r[i] = r[i << 1 | 1] - mini + r[i << 1];
sum[i] = (sum[i << 1] + sum[i << 1 | 1] + mini);
}
}
struct r {
int ret, L, R;
void init() { ret = 0, L = 0, R = 0; }
} x, y;
int query(int a, int b) {
x.init(), y.init();
int mini;
for (a += n, b += n; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
x.ret += sum[a];
x.ret += min(r[a], x.L);
x.L -= min(r[a], x.L);
x.L += l[a];
++a;
}
if (b & 1) {
--b;
mini = min(l[b], y.R);
y.R -= mini;
y.R += r[b];
y.ret += mini + sum[b];
}
}
mini = min(x.L, y.R);
return 2 * (x.ret + y.ret + mini);
}
int main() {
string s;
cin >> s;
n = s.size();
int i, q, a, b;
for (i = 0; i < n; ++i)
if (s[i] == '(') {
l[i + n] = 1;
} else {
r[i + n] = 1;
}
build();
cin >> q;
while (q--) {
scanf("%d%d", &a, &b);
--a;
printf("%d\n", query(a, b));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct pole {
int max;
char kier;
int rnast;
};
int main() {
ios_base::sync_with_stdio(0);
int n, m, k;
cin >> n >> m >> k;
int T[n][m];
string nap;
for (int i = 0; i < n; ++i) {
cin >> nap;
for (int j = 0; j < m; ++j) T[i][j] = (nap[j] - '0');
}
pole dp[n][m][k + 1];
for (int i = 0; i < m; ++i) {
for (int j = 0; j < k + 1; ++j) {
if (T[n - 1][i] % (k + 1) == j) {
dp[n - 1][i][j].max = T[n - 1][i];
dp[n - 1][i][j].kier = 'X';
} else {
dp[n - 1][i][j].max = -1;
dp[n - 1][i][j].kier = 'X';
}
}
}
for (int i = n - 2; i >= 0; --i) {
for (int j = 0; j < m; ++j) {
for (int R = 0; R < k + 1; ++R) {
char kier = 'X';
int max = -1;
int rnast = -1;
if (j > 0) {
for (int r = 0; r < k + 1; ++r) {
if (dp[i + 1][j - 1][r].max > max &&
((dp[i + 1][j - 1][r].max + T[i][j]) % (k + 1) == R)) {
max = dp[i + 1][j - 1][r].max;
kier = 'R';
rnast = r;
}
}
}
if (j < m - 1) {
for (int r = 0; r < k + 1; ++r) {
if (dp[i + 1][j + 1][r].max > max &&
((dp[i + 1][j + 1][r].max + T[i][j]) % (k + 1) == R)) {
max = dp[i + 1][j + 1][r].max;
kier = 'L';
rnast = r;
}
}
}
dp[i][j][R].max = max;
if (max != -1) dp[i][j][R].max += T[i][j];
dp[i][j][R].kier = kier;
dp[i][j][R].rnast = rnast;
}
}
}
int max = -1;
int start;
for (int i = 0; i < m; ++i) {
if (dp[0][i][0].max > max) {
max = dp[0][i][0].max;
start = i;
}
}
if (max == -1) {
cout << max;
return 0;
}
stack<char> S;
int aktx = start, akty = 0, rnast = 0;
for (int i = 0; i < n - 1; ++i) {
S.push(dp[akty][aktx][rnast].kier);
if (dp[akty][aktx][rnast].kier == 'L') {
rnast = dp[akty][aktx][rnast].rnast;
++aktx;
} else {
rnast = dp[akty][aktx][rnast].rnast;
--aktx;
}
++akty;
}
cout << max << endl << aktx + 1 << endl;
while (!S.empty()) {
cout << S.top();
S.pop();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point {
long double x, y;
};
int n;
point p[1024];
long double ans = 2e9;
long double dist(point a, point b) {
long double d = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
return d;
}
long double dist_a(point M, point N, point X) {
long double a = dist(M, N), b = dist(M, X), c = dist(N, X);
long double p = (a + b + c) / 2.0;
long double area = sqrt(p * (p - a) * (p - b) * (p - c) * 1.0);
long double h = 2.0 * area / a * 1.0;
return h;
}
int na[1024][2];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].x >> p[i].y;
}
for (int i = 0; i < n; i++) {
ans = min(ans, dist_a(p[i], p[(i + 2) % n], p[(i + 1) % n]));
}
ans = ans / 2.0;
printf("%.14Lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 1e6 + 10;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 8e18;
const int LOG = 22;
const int B = 550;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
int n, m, check[N], P[N];
vector<int> path[N];
vector<pair<int, int> > vec[N];
bool solve() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= m; i++) path[i].clear();
for (int i = 0; i <= n; i++) check[i] = P[i] = -1, vec[i].clear();
for (int i = 1; i <= m; i++) {
int sz;
scanf("%d", &sz);
for (int j = 0; j < sz; j++) {
int x;
scanf("%d", &x);
path[i].push_back(x);
}
}
for (int i = 1; i <= m; i++) {
if ((int)path[i].size() >= B) {
for (int i2 = 0; i2 < (int)path[i].size(); i2++) {
P[path[i][i2]] = i2;
}
for (int j = 1; j <= m; j++) {
if (i == j) continue;
int Mx = -1;
for (int t = (int)path[j].size() - 1; ~t; t--) {
if (P[path[j][t]] != -1) {
if (Mx > P[path[j][t]] &&
path[i][P[path[j][t]] + 1] != path[j][t + 1]) {
return !printf("Human\n");
}
}
Mx = max(Mx, P[path[j][t]]);
}
}
for (int i2 = 0; i2 < (int)path[i].size(); i2++) {
P[path[i][i2]] = -1;
}
} else {
for (int i2 = 0; i2 < (int)path[i].size(); i2++) {
for (int i3 = i2 + 1; i3 < (int)path[i].size(); i3++) {
vec[path[i][i2]].push_back(make_pair(path[i][i3], path[i][i2 + 1]));
}
}
}
}
for (int i = 1; i <= n; i++) {
for (auto x : vec[i]) {
if (check[x.first] == -1) check[x.first] = x.second;
if (check[x.first] != x.second) return !printf("Human\n");
}
for (auto x : vec[i]) check[x.first] = -1;
}
return !printf("Robot\n");
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
solve();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> odd;
vector<int> eve;
int f[2010][1010][11], g[2010][2010][11];
int T, n, cnt[2010], m;
char s[20];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
odd.clear();
eve.clear();
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
int L = strlen(s);
reverse(s, s + L);
cnt[i] = 0;
for (int j = 0; j < L; ++j)
(cnt[i] += j & 1 ? 11 - (s[j] - '0') : s[j] - '0') %= 11;
if (L & 1)
odd.push_back(cnt[i]);
else
eve.push_back(cnt[i]);
}
n = odd.size();
m = eve.size();
memset(f[0], 0, sizeof(f[0]));
f[0][n / 2][0] = 1;
for (int i = 0; i < n; ++i) {
memset(f[i + 1], 0, sizeof(f[i + 1]));
for (int j = 0; j <= n / 2; ++j)
for (int k = 0; k < 11; ++k)
if (f[i][j][k]) {
if (j)
(f[i + 1][j - 1][(k + 11 - odd[i]) % 11] +=
(long long)f[i][j][k] * j % 998244353) %= 998244353;
if (n - i - j > 0)
(f[i + 1][j][(k + odd[i]) % 11] +=
(long long)f[i][j][k] * (n - i - j) % 998244353) %= 998244353;
}
}
memset(g[0], 0, sizeof(g[0]));
for (int i = 0; i < 11; ++i) (g[0][0][i] += f[n][0][i]) %= 998244353;
for (int i = 0; i < m; ++i) {
memset(g[i + 1], 0, sizeof(g[i + 1]));
for (int j = 0; j <= i; ++j)
for (int k = 0; k < 11; ++k)
if (g[i][j][k]) {
(g[i + 1][j + 1][(k + eve[i]) % 11] +=
(long long)g[i][j][k] * (n / 2 + 1 + j) % 998244353) %= 998244353;
(g[i + 1][j][(k + 11 - eve[i]) % 11] +=
(long long)g[i][j][k] * ((n + 1) / 2 + (i - j)) % 998244353) %=
998244353;
}
}
int ans = 0;
for (int i = 0; i <= m; ++i) (ans += g[m][i][0]) %= 998244353;
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long w = 0, f = 1;
char c = ' ';
while (c < '0' || c > '9') c = getchar(), f = c == '-' ? -1 : f;
while (c >= '0' && c <= '9') w = w * 10 + c - 48, c = getchar();
return w * f;
}
string s[2][105 * 105 >> 1];
char ch[105], ans[105];
long long sum[105], w[105];
bool cmp1(char x, char y) { return x < y; }
bool cmp2(string x, string y) {
if (x.size() != y.size()) return x.size() < y.size();
for (long long i = 0; i < x.size(); i++) {
if (x[i] < y[i]) return 1;
if (x[i] > y[i]) return 0;
}
return 1;
}
bool cmp3(string x, string y) {
if (x.size() == 0) return 0;
if (y.size() == 0) return 1;
return x.size() < y.size();
}
void solve(long long n) {
printf("? 1 %lld\n", n);
fflush(stdout);
if (n == 1) {
scanf("%s", ch);
printf("! ");
puts(ch);
fflush(stdout);
return;
}
for (long long i = 1; i <= n * (n + 1) / 2; i++) {
scanf("%s", ch);
sort(ch, ch + strlen(ch), cmp1);
for (long long j = 0; j < strlen(ch); j++) s[0][i] += ch[j];
}
printf("? 2 %lld\n", n);
fflush(stdout);
for (long long i = 1; i <= n * (n - 1) / 2; i++) {
scanf("%s", ch);
sort(ch, ch + strlen(ch), cmp1);
for (long long j = 0; j < strlen(ch); j++) s[1][i] += ch[j];
}
sort(s[0] + 1, s[0] + n * (n + 1) / 2 + 1, cmp2);
sort(s[1] + 1, s[1] + n * (n - 1) / 2 + 1, cmp2);
long long it1 = 1, it2 = 1, it;
while (it2 <= n * (n - 1) / 2) {
while (s[0][it1] != s[1][it2]) it1++;
s[0][it1] = "", it1++, it2++;
}
sort(s[0] + 1, s[0] + n * (n + 1) / 2 + 1, cmp3);
ans[0] = s[0][1][0];
for (long long i = 2; i <= n; i++) {
it = 0;
while (it < i - 1 && s[0][i - 1][it] == s[0][i][it]) it++;
ans[i - 1] = s[0][i][it];
}
fflush(stdout);
}
void print(long long n) {
printf("! ");
for (long long i = 0; i < n; i++) putchar(ans[i]);
}
signed main() {
long long n = read();
if (n <= 5) {
solve(n);
print(n);
return 0;
}
solve(n + 1 >> 1);
for (long long i = 1; i <= (n + 1 >> 1); i++)
w[i] = w[i - 1] + ans[i - 1] - 'a';
printf("? 1 %lld\n", n);
fflush(stdout);
for (long long i = 1; i <= n * (n + 1) / 2; i++) {
scanf("%s", ch);
for (long long j = 0; j < strlen(ch); j++) sum[strlen(ch)] += (ch[j] - 'a');
}
long long x = 0, t[2] = {0, 0};
for (long long i = 1; i <= (n >> 1); i++) {
for (long long j = 1; j < i; j++) {
for (long long k = 0; k < i - j; k++) x += (ans[n - k - 1] - 'a');
sum[n - i] -= (sum[n] - x - w[j]), x = 0;
;
}
sum[n - i] -= (sum[n] - w[i]), t[i & 1] = sum[n] - sum[n - i],
ans[n - i] = 'a' + abs(t[0] - t[1]);
}
printf("! ");
for (long long i = 0; i < n; i++) putchar(ans[i]);
fflush(stdout);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, k, a[100], i, t = 0, min, array[100], j = 0, swap, d, c;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
if (k % a[i - 1] == 0) array[j++] = k / a[i - 1];
}
for (c = 0; c < (j - 1); c++) {
for (d = 0; d < j - c - 1; d++) {
if (array[d] > array[d + 1]) {
swap = array[d];
array[d] = array[d + 1];
array[d + 1] = swap;
}
}
}
printf("%d", array[0]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
struct Bitset {
unsigned long long v[16];
Bitset() { memset(v, 0, sizeof v); }
inline Bitset operator^(const Bitset &x) const {
Bitset z;
for (int i = 0; i < 16; i++) z.v[i] = v[i] ^ x.v[i];
return z;
}
inline void set(int x) { v[x >> 6] |= 1ull << (x & 63); }
inline unsigned long long hash() {
unsigned long long z = 0, fac = 1;
for (int i = 0; i < 16; i++, fac *= 57285791275031) z += v[i] * fac;
return z;
}
};
int n, s, q, cnt, x, val[1 << 12 | 1];
Bitset v[1 << 12 | 1], a[35];
map<unsigned long long, int> Map;
int main() {
scanf("%d%d%d", &n, &s, &q);
for (int i = 0; i < s; i++) {
scanf("%d", &cnt);
while (cnt--) scanf("%d", &x), a[i].set(x);
}
int Cnt = min(12, s);
for (int i = 0; i < 1 << Cnt; i++)
for (int j = 0; j < Cnt; j++)
if ((1 << j) & i) v[i] = v[i] ^ a[j], val[i]++;
for (int i = 0; i < 1 << (s - Cnt); i++) {
Bitset now;
int cnt = 0;
for (int j = Cnt; j < s; j++)
if ((1 << (j - Cnt)) & i) now = now ^ a[j], cnt++;
unsigned long long z = now.hash();
if (!Map.count(z) || Map[z] > cnt) Map[z] = cnt;
}
while (q--) {
Bitset now;
scanf("%d", &cnt);
while (cnt--) scanf("%d", &x), now.set(x);
int ans = 1e9;
for (int i = 0; i < 1 << Cnt; i++) {
unsigned long long z = (now ^ v[i]).hash();
if (Map.count(z)) ans = min(ans, Map[z] + val[i]);
}
if (ans == 1e9)
puts("-1");
else
printf("%d\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
const int mod = 10000009;
const long long int MOD = 1000000007;
const int INF = INT_MAX;
int DEBUG = 0;
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string a, b, c;
cin >> a >> b >> c;
int L = a.length();
unordered_map<char, int> hma, hmb, hmc;
int maxa = -1, maxb = -1, maxc = -1;
for (int i = 0; i < a.length(); i++) {
maxa = max(maxa, ++hma[a[i]]);
maxb = max(maxb, ++hmb[b[i]]);
maxc = max(maxc, ++hmc[c[i]]);
}
if (n == 1 && maxa == L)
maxa = L - 1;
else
maxa = min(maxa + n, L);
if (n == 1 && maxb == L)
maxb = L - 1;
else
maxb = min(maxb + n, L);
if (n == 1 && maxc == L)
maxc = L - 1;
else
maxc = min(maxc + n, L);
if (maxa > maxb && maxa > maxc)
cout << ("Kuro\n");
else if (maxb > maxa && maxb > maxc)
cout << ("Shiro\n");
else if (maxc > maxa && maxc > maxb)
cout << ("Katie\n");
else
cout << ("Draw\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1100];
int main() {
int n, m, h, sum, i, j;
double ss;
while (scanf("%d%d%d", &n, &m, &h) != EOF) {
for (sum = 0, i = 1; i <= m; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
if (sum < n) {
printf("-1.0\n");
continue;
}
ss = 1.0;
j = a[h];
if (n - 1 <= sum - j) {
for (i = 0; i < n - 1; i++)
ss *= (double)(sum - j - i) / (double)(sum - 1 - i);
} else
ss = 0;
printf("%.10lf\n", 1.0 - ss);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int a[212345], b[212345];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (int i = 0; i < m; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
a[n] = 2000000001;
long long p1 = 0, p2 = 0, mx = -2LL * 0x3f3f3f3f;
pair<int, int> ans;
for (int i = 0; i <= n; i++) {
p1 = i * 2LL + (n - i) * 3LL;
int j = (int)(lower_bound(b, b + m, a[i]) - b);
p2 = (j * 2LL) + (m - j) * 3LL;
if (p1 - p2 > mx) {
mx = p1 - p2;
ans = {p1, p2};
}
}
cout << ans.first << ":" << ans.second << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
struct am {
char f, s, t, fo;
am(char a, char b, char c, char d) {
this->f = a, this->s = b, this->t = c, this->fo = d;
}
bool operator==(am b) {
return this->f == b.f && this->s == b.s && this->t == b.t &&
this->fo == b.fo;
}
};
int main() {
int n;
bool x;
char a, b, c, d;
cin >> n >> a >> b >> c >> d;
n--;
vector<vector<am>> v;
vector<am> ve;
ve.push_back(am(a, b, c, d));
ve.push_back(am(c, a, d, b));
ve.push_back(am(d, c, b, a));
ve.push_back(am(b, d, a, c));
v.push_back(ve);
for (int j = 0; j < n; j++) {
x = false;
cin >> a >> b >> a >> b >> c >> d;
for (int i = 0; i < v.size() && !x; i++)
if (am(a, b, c, d) == v[i][0] || am(c, a, d, b) == v[i][0] ||
am(d, c, b, a) == v[i][0] || am(b, d, a, c) == v[i][0])
x = true;
if (!x)
ve.clear(), ve.push_back(am(a, b, c, d)), ve.push_back(am(c, a, d, b)),
ve.push_back(am(d, c, b, a)), ve.push_back(am(b, d, a, c)),
v.push_back(ve);
}
cout << v.size();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long int level = s.find('^');
long long int leftw = 0;
long long int rightw = 0;
for (long long int i = 0; i < level; ++i) {
if (s[i] != '=') {
leftw += (s[i] - '0') * (level - i);
}
}
for (long long int i = level + 1; i < s.length(); ++i) {
if (s[i] != '=') {
rightw += (s[i] - '0') * (i - level);
}
}
if (rightw == leftw) {
cout << "balance" << '\n';
} else if (rightw > leftw) {
cout << "right" << '\n';
} else {
cout << "left" << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, d[100005], c1, c2, g;
vector<int> vec;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> d[i];
}
sort(d, d + n);
for (int i = 2; i < n; i++) {
if (d[i] == d[i - 1] && d[i] == d[i - 2]) {
d[i - 2] = -1;
}
}
if (d[n - 1] == d[n - 2]) {
d[n - 2] = -1;
}
for (int i = 0; i < n; i++) {
if (d[i] != -1) {
g++;
}
}
cout << g << endl;
for (int i = 0; i < n; i++) {
if (d[i] != -1) {
if (i != 0 && d[i - 1] == d[i]) {
vec.push_back(d[i]);
} else {
cout << d[i] << " ";
}
}
}
while (vec.size()) {
cout << vec[vec.size() - 1] << " ";
vec.pop_back();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
inline int read() {
int sum = 0, p = 1;
char ch = getchar();
while (!(('0' <= ch && ch <= '9') || ch == '-')) ch = getchar();
if (ch == '-') p = -1, ch = getchar();
while ('0' <= ch && ch <= '9') sum = sum * 10 + ch - 48, ch = getchar();
return sum * p;
}
const int maxn = 120;
struct node {
int v, next;
};
node e[maxn];
int cnt, start[maxn];
inline void addedge(int u, int v) {
e[++cnt] = (node){v, start[u]};
start[u] = cnt;
}
int n;
double C[maxn][maxn];
inline void init() {
n = read();
for (int i = (1), _end_ = (n - 1); i <= _end_; i++) {
int u = read(), v = read();
addedge(u, v);
addedge(v, u);
}
C[0][0] = 1;
for (int i = (1), _end_ = (n); i <= _end_; i++)
for (int j = (0), _end_ = (i); j <= _end_; j++)
C[i][j] = ((j ? C[i - 1][j - 1] : 0) + C[i - 1][j]);
}
double dp[maxn][maxn];
int sz[maxn];
double tmp[maxn];
void dfs(int u, int fa) {
sz[u] = 0;
dp[u][0] = 1;
for (int i = start[(u)]; i; i = e[i].next) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
tmp[0] = 0;
for (int a = (1), _end_ = (sz[v]); a <= _end_; a++)
tmp[a] = tmp[a - 1] + dp[v][a - 1];
for (int a = (0), _end_ = (sz[v]); a <= _end_; a++)
tmp[a] = tmp[a] * 0.5 + dp[v][a] * (sz[v] - a);
for (int a = (sz[u]), _end_ = (0); a >= _end_; a--) {
double tmp1 = dp[u][a];
dp[u][a] = 0;
for (int b = (sz[v]), _end_ = (0); b >= _end_; b--)
dp[u][a + b] +=
(tmp1 * tmp[b] * C[a + b][a] * C[sz[u] + sz[v] - a - b][sz[u] - a]);
}
sz[u] += sz[v];
}
sz[u]++;
}
inline void doing() {
double fac = 1;
for (int i = (1), _end_ = (n - 1); i <= _end_; i++) fac *= i;
for (int i = (1), _end_ = (n); i <= _end_; i++) {
memset(dp, 0, sizeof(dp));
dfs(i, 0);
printf("%.8lf\n", dp[i][n - 1] / fac);
}
}
int main() {
init();
doing();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
using v = vector<T>;
struct Minqueue {
deque<pair<ll, ll>> q;
ll cntadded = 0, cntremoved = 0;
ll min() { return q.front().first; }
void add(ll x) {
while (!q.empty() && q.back().first > x) {
q.pop_back();
}
q.push_back({x, cntadded});
cntadded++;
}
void del() {
if (!q.empty() && q.front().second == cntremoved) {
q.pop_front();
}
cntremoved++;
}
};
struct Entry {
ll row, col, val;
bool operator<(const Entry &rhs) const {
if (val == rhs.val) {
if (row == rhs.row) {
return col < rhs.col;
}
return row < rhs.row;
}
return val < rhs.val;
}
};
ll n, m, a, b;
const ll N = 1000;
ll mp[N + 1][N + 1];
ll minmp[N + 1][N + 1];
ll minrow[N + 1][N + 1];
ll summp[N + 1][N + 1];
ll sumrow[N + 1][N + 1];
bool marked[N + 1][N + 1] = {};
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
cin >> n >> m >> a >> b;
for (ll i = 1; i <= n; i++) {
for (ll j = 1; j <= m; j++) {
cin >> mp[i][j];
}
}
for (ll i = 1; i <= n; i++) {
sumrow[i][1] = 0;
for (ll j = 1; j <= b; j++) {
sumrow[i][1] += mp[i][j];
}
for (ll j = 2; j <= m - b + 1; j++) {
sumrow[i][j] = sumrow[i][j - 1] + mp[i][j + b - 1] - mp[i][j - 1];
}
}
for (ll j = 1; j <= m - b + 1; j++) {
summp[1][j] = 0;
for (ll i = 1; i <= a; i++) {
summp[1][j] += sumrow[i][j];
}
for (ll i = 2; i <= n - a + 1; i++) {
summp[i][j] = summp[i - 1][j] + sumrow[i + a - 1][j] - sumrow[i - 1][j];
}
}
for (ll i = 1; i <= n; i++) {
Minqueue q;
for (ll j = 1; j <= b - 1; j++) {
q.add(mp[i][j]);
}
for (ll j = 1; j <= m - b + 1; j++) {
q.add(mp[i][j + b - 1]);
minrow[i][j] = q.min();
q.del();
}
}
for (ll j = 1; j <= m - b + 1; j++) {
Minqueue q;
for (ll i = 1; i <= a - 1; i++) {
q.add(minrow[i][j]);
}
for (ll i = 1; i <= n - a + 1; i++) {
q.add(minrow[i + a - 1][j]);
minmp[i][j] = q.min();
q.del();
}
}
v<Entry> pq;
const ll mult = a * b;
for (ll i = 1; i <= n - a + 1; i++) {
for (ll j = 1; j <= m - b + 1; j++) {
pq.push_back(Entry{i, j, summp[i][j] - mult * minmp[i][j]});
}
}
sort(pq.begin(), pq.end());
v<Entry> res;
for (const Entry &cur : pq) {
if (!marked[cur.row][cur.col]) {
res.push_back(cur);
const ll loi = max<ll>(cur.row - (a - 1), 1);
const ll hii = min<ll>(cur.row + (a - 1), n - a + 1);
const ll loj = max<ll>(cur.col - (b - 1), 1);
const ll hij = min<ll>(cur.col + (b - 1), m - b + 1);
for (ll i = loi; i <= hii; i++) {
for (ll j = loj; j <= hij; j++) {
marked[i][j] = true;
}
}
}
}
cout << res.size() << "\n";
for (const Entry &cur : res) {
cout << cur.row << " " << cur.col << " " << cur.val << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
int three[1111], rest[1111];
int main() {
int t, a, i, j, answer = 0, m = 0, e = 0, r = 0, n;
scanf("%d", &t);
for (i = 1; i <= t; i++) {
answer = 0, e = 0, r = 0, m = 0;
scanf("%d", &n);
for (j = 1; j <= n; j++) {
scanf("%d", &three[j]);
}
for (j = 1; j <= n; j++) {
if (three[j] % 3 == 0) {
answer++;
three[j] = 0;
}
}
for (j = 1; j <= n; j++) {
if (three[j] != 0) {
m++;
rest[m] = three[j] % 3;
}
}
for (j = 1; j <= m; j++) {
if (rest[j] == 1) e++;
if (rest[j] == 2) r++;
}
if (e == r) answer = answer + e;
if (e > r) answer = answer + r + (e - r) / 3;
if (r > e) answer = answer + e + (r - e) / 3;
printf("%d", answer);
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int temp = n / 2;
long long int ans = temp * (temp + 1) * 2;
long long int result = 0;
if (n == 1)
result = 0;
else {
long long int j = 2 * temp - 1;
for (int i = temp; i > 0; i--) {
result += j * i;
j -= 2;
}
result = result * 4;
result += ans;
}
ans = result;
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[2005];
int dp[2005];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int lo = 0, hi = 2000000000, ans = -1;
while (lo <= hi) {
int mid = ((long long)lo + hi) / 2;
memset(dp, 0, sizeof dp);
for (int i = n - 1; i >= 0; i--) {
dp[i] = 1;
for (int j = i + 1; j < n; j++)
if (abs(a[j] - a[i]) <= (long long)(j - i) * (long long)mid)
dp[i] = max(dp[i], dp[j] + 1);
}
if (n - (*max_element(dp, dp + n)) <= k)
ans = mid, hi = mid - 1;
else
lo = mid + 1;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, odd = 0;
int even = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2 == 0) {
even++;
} else
odd++;
}
if (even == n || odd == n) {
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
} else {
sort(a, a + n);
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, long long b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a);
b /= 2;
a = (a * a);
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, a, b, k;
cin >> n >> a >> b >> k;
string s;
cin >> s;
long long st = 0;
bool check = false;
long long ct = 0;
vector<long long> ans;
for (long long i = 0; i < n; i++) {
if (s[i] == '1') {
check = false;
ct = 0;
}
if (s[i] == '0') {
ct++;
if (!check) {
check = true;
}
if (ct == b) {
ans.push_back(i + 1);
check = false;
ct = 0;
}
}
}
long long sz = ans.size();
cout << sz - a + 1 << "\n";
for (long long i = 0; i <= sz - a; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios_base ::sync_with_stdio(false);
int n;
cin >> n;
long long l;
cin >> l;
int k;
cin >> k;
vector<int> v(n, 0);
long long pieces = l / n;
int tail = l % n;
vector<vector<int>> dp(k + 1, vector<int>(n + 1, 0));
vector<vector<int>> sum(k + 1, vector<int>(n + 1, 0));
for (int i = 0; i < n; ++i) {
dp[1][i] = 1;
sum[1][i] = i + 1;
}
vector<pair<int, int>> all;
for (int i = 0; i < n; ++i) {
cin >> v[i];
all.push_back(make_pair(v[i], i));
}
sort(all.begin(), all.end());
vector<int> last(n, 0);
for (int i = n - 1; i >= 0; --i) {
if (i == n - 1 || (i < n - 1 && all[i].first != all[i + 1].first))
last[i] = i;
else
last[i] = last[i + 1];
}
int ans = 0;
auto add = [&](int &a, int b) {
a += b;
while (a >= MOD) a -= MOD;
while (a < 0) a += MOD;
};
for (int i = 2; i <= k; ++i)
for (int j = 0; j < n; ++j) {
add(dp[i][j], sum[i - 1][last[j]]);
add(sum[i][j], dp[i][j]);
if (j >= 1) add(sum[i][j], sum[i][j - 1]);
}
for (int i = 1; i <= k; ++i)
for (int j = 0; j < n; ++j) {
int temp = max(0LL, (pieces - i + 1) % MOD);
add(ans, 1LL * dp[i][last[j]] * temp % MOD);
}
add(ans, tail);
for (int i = 1; i <= min(1LL * (k - 1), pieces); ++i)
for (int j = 0; j < n; ++j)
if (all[j].second < tail) {
add(ans, sum[i][last[j]]);
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int INF = 1000000007;
const double PI = acos(-1.0);
int own[MAXN];
vector<int> w[MAXN];
vector<int> X[MAXN];
int s[MAXN], f[MAXN][20], d[MAXN];
void dfs(int a, int depth) {
s[a] = 1;
d[a] = depth;
for (int i = 0; i < X[a].size(); ++i) {
dfs(X[a][i], depth + 1);
f[X[a][i]][0] = a;
s[a] += s[X[a][i]];
}
}
int main() {
ios_base::sync_with_stdio(false);
int N, M, K, Q;
cin >> N >> M >> K >> Q;
for (int i = 0; i < K; ++i) {
int a, b;
cin >> a >> b;
w[b].push_back(a);
}
for (int i = 1; i <= M; ++i) {
if (w[i].size() < 2) continue;
for (int j = 0; j + 1 < w[i].size(); ++j) {
X[w[i][j]].push_back(w[i][j + 1]);
}
}
for (int i = 1; i <= N; ++i) {
if (s[i] != 0) continue;
f[i][0] = i;
dfs(i, 0);
}
for (int i = 1; i < 20; ++i) {
for (int j = 1; j <= N; ++j) f[j][i] = f[f[j][i - 1]][i - 1];
}
for (int i = 0; i < Q; ++i) {
int a, b;
cin >> a >> b;
if (w[b].size() == 0) {
cout << 0 << endl;
continue;
}
b = w[b].back();
if (d[a] >= d[b]) {
cout << 0 << endl;
continue;
}
for (int j = 19; j >= 0; --j) {
if (d[a] + (1 << j) <= d[b]) b = f[b][j];
}
if (a != b) {
cout << 0 << endl;
} else {
cout << s[a] << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 9;
const int mod = 1e9 + 7;
const int MOD = 1e9 + 696969;
const long long int INF = 1e18 + 3;
int n, m, a, b, c;
int t[3010];
char s[3010], help[3010];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
int wyn = 0;
for (int i = 1; i <= n; ++i) help[i] = s[n - i + 1];
s[0] = 'R';
s[n + 1] = 'L';
for (int i = 1; i <= n; ++i)
if (s[i] == 'R')
for (int j = i; s[j] != 'L'; ++j) t[j] = 1;
else if (s[i] == 'L')
for (int j = i; s[j] != 'R'; --j) t[j] = 1;
for (int i = 1; i <= n; ++i)
if (t[i] == 0) ++wyn;
s[0] = '.';
s[n + 1] = '.';
for (int i = 1; i <= n; ++i)
if (s[i] == '.' && t[i] == 1) {
int lew = 0, praw = 0;
for (int j = i + 1; s[j] != 'L'; ++j) {
if (s[j] == 'R') praw = inf;
if (j > n) praw = inf;
++praw;
}
for (int j = i - 1; s[j] != 'R'; --j) {
if (s[j] == 'L') lew = 421723;
if (j == 0) lew = 412321;
++lew;
}
if (lew == praw) ++wyn, t[i] = 0;
}
printf("%d ", wyn);
}
| 1 |
#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;
err(++it, args...);
}
const long long MOD = 1e9 + 7;
const int N = 1e7 + 9, M = 1e7, OO = 0x3f3f3f3f;
long long f, s, x, F[N], S[N];
int a, b;
int main() {
int n;
scanf("%d", &n);
while (n--) {
scanf("%lld", &x);
if (x > 0) {
f += x;
F[a++] = x;
} else {
s += abs(x);
S[b++] = abs(x);
}
}
if (f == s) {
n = min(a, b);
for (int i = 0; i < n; ++i) {
if (F[i] > S[i]) {
f += OO;
break;
} else if (F[i] < S[i]) {
s += OO;
break;
}
}
}
if (f == s) {
if (a > b)
f += OO;
else if (b > a)
s += OO;
else if (x > 0)
f += OO;
else
s += OO;
}
if (f > s)
printf("first");
else if (s > f)
printf("second");
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, m, t, k, cell;
scanf("%d %d %d %d", &n, &m, &k, &t);
int wrow[k], wcol[k];
for (int i = 0; i < k; i++) {
scanf("%d %d", wrow + i, wcol + i);
}
while (t--) {
int trow, tcol, waste = 0, flag = 0;
scanf("%d %d", &trow, &tcol);
for (int i = 0; i < k; i++) {
if (trow > wrow[i])
waste++;
else if (trow == wrow[i] && tcol > wcol[i])
waste++;
else if (trow == wrow[i] && tcol == wcol[i]) {
flag = 1;
break;
}
}
if (flag) {
printf("Waste\n");
} else {
cell = (trow - 1) * m + tcol - waste;
if (cell % 3 == 1)
printf("Carrots\n");
else if (cell % 3 == 2)
printf("Kiwis\n");
else
printf("Grapes\n");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int N = 101000;
const double g = 9.8;
struct WALL {
double x;
double y;
} w[N];
bool eq(double a, double b) {
if (fabs(a - b) < eps) return true;
return false;
}
int cmp(WALL a, WALL b) {
if (eq(a.x, b.x)) return a.y > b.y;
return a.x < b.x;
}
struct ASK {
double a;
double ansx, ansy;
int id;
} f[N];
int n, m;
double v;
int cmp2(ASK a, ASK b) { return a.a < b.a; }
int cmp3(ASK a, ASK b) { return a.id < b.id; }
void work() {
int now = 0;
for (int i = 0; i < n; i++) {
double t = 2.0 * v * sin(f[i].a) / g;
double limx = v * cos(f[i].a) * t;
f[i].ansx = -100;
for (int j = now; j < m; j++) {
if (w[j].x >= limx) break;
double tmp = w[j].x / v / cos(f[i].a);
double y = v * sin(f[i].a) * tmp - g * tmp * tmp / 2.0;
if (y <= w[j].y) {
f[i].ansx = w[j].x;
f[i].ansy = y;
break;
}
now = j;
}
if (f[i].ansx < -10) {
f[i].ansx = limx;
f[i].ansy = 0;
}
}
}
void output() {
for (int i = 0; i < n; i++) printf("%lf %lf\n", f[i].ansx, f[i].ansy);
return;
}
int main() {
scanf("%d%lf", &n, &v);
for (int i = 0; i < n; i++) {
scanf("%lf", &f[i].a);
f[i].id = i;
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%lf%lf", &w[i].x, &w[i].y);
}
sort(w, w + m, cmp);
sort(f, f + n, cmp2);
work();
sort(f, f + n, cmp3);
output();
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;
int n, len = -1, lo[3000], hi[3000];
vector<string> w, w2;
vector<pair<int, int> > constructDFA(string m) {
vector<pair<int, int> > dfa(1, make_pair(-1, 0));
for (int i = 0; i < (((int)(m).size())); i++) {
int lps = dfa[i].second;
dfa[i].first = m[i];
while (lps > 0 && dfa[lps].first != m[i]) lps = dfa[lps].second;
if (dfa[lps].first == m[i] && lps != i) lps++;
dfa.push_back(make_pair(-1, lps));
}
return dfa;
}
string apply(string a, string s, string t) {
vector<pair<int, int> > dfa = constructDFA(s);
int curr = 0;
for (int i = 0; i < (((int)(a).size())); i++) {
while (curr > 0 && dfa[curr].first != a[i]) curr = dfa[curr].second;
if (dfa[curr].first == a[i]) curr++;
if (curr == ((int)(s).size())) {
return a.substr(0, i + 1 - ((int)(s).size())) + t +
a.substr(i + 1, ((int)(a).size()) - (i + 1));
}
}
return a;
}
void readInput() {
cin >> n;
for (int i = 0; i < (n); i++) {
string s;
cin >> s;
w.push_back(s);
}
for (int i = 0; i < (n); i++) {
string s;
cin >> s;
w2.push_back(s);
}
}
void findLoHi() {
for (int i = 0; i < (n); i++) lo[i] = hi[i] = -1;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (((int)(w[i]).size())); j++)
if (w[i][j] != w2[i][j]) {
if (lo[i] == -1) lo[i] = j;
hi[i] = j;
}
}
bool sameChar(int pos) {
char c1 = -1, c2 = -1;
for (int i = 0; i < (n); i++)
if (lo[i] != -1) {
if (lo[i] + pos < 0 || lo[i] + pos >= ((int)(w[i]).size())) return 0;
if (c1 == -1) c1 = w[i][lo[i] + pos], c2 = w2[i][lo[i] + pos];
if (c1 != w[i][lo[i] + pos] || c2 != w2[i][lo[i] + pos]) return 0;
}
return 1;
}
bool checkSame() {
for (int i = 0; i < (n); i++)
if (lo[i] != -1) {
if (len == -1) len = hi[i] - lo[i];
if (len != hi[i] - lo[i]) return 0;
}
for (int i = 0; i < (len); i++)
if (!sameChar(i)) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
readInput();
findLoHi();
if (!checkSame()) {
cout << "NO" << endl;
return 0;
}
while (sameChar(-1)) {
for (int i = 0; i < (n); i++)
if (lo[i] != -1) lo[i]--;
len++;
}
while (sameChar(len)) {
for (int i = 0; i < (n); i++)
if (lo[i] != -1) hi[i]++;
len++;
}
string s = "", t = "";
for (int i = 0; i < (n); i++)
if (lo[i] != -1) {
s = w[i].substr(lo[i], len);
t = w2[i].substr(lo[i], len);
break;
}
for (int i = 0; i < (n); i++)
if (apply(w[i], s, t) != w2[i]) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
cout << s << endl;
cout << t << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int k;
int go(long long a, long long b) {
long long res = 0;
while (a > b) {
++res;
long long mx = 1LL;
for (int i = (int)(2); i <= (int)(k); ++i)
if (a - a % i >= b) mx = max(mx, a % i);
a -= mx;
}
return res;
}
int main() {
long long a, b;
int m = 360360;
cin >> a >> b >> k;
long long res = 0;
if ((a / m) * m > b) {
res += go(a, (a / m) * m);
a = (a / m) * m;
} else {
res = go(a, b);
cout << res;
return 0;
}
long long bb = b;
if (bb != m) bb = (bb / m + 1) * m;
res += (a - b) / m * go(m, 0);
res += go(bb, b);
cout << res;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = int(1e9);
const int MAX = 1000007;
int fact[MAX], invFact[MAX];
inline void add(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline int mul(int a, int b) { return (long long)a * b % MOD; }
inline int exp(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b >>= 1;
}
return res;
}
inline int inv(int a) { return exp(a, MOD - 2); }
int main() {
ios_base::sync_with_stdio(false);
fact[0] = invFact[0] = 1;
int n;
cin >> n;
n++;
for (int i = 1; i <= n + 1; i++) {
fact[i] = mul(fact[i - 1], i);
invFact[i] = mul(invFact[i - 1], inv(i));
}
int res = 0;
for (int k = 1; k <= n + 1; k++) {
int t = mul(fact[n], mul(invFact[k], invFact[n - k]));
add(res, mul(t, t));
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, m, x1, y1, x2, y2;
cin >> t;
while (t--) {
cin >> n >> m >> x1 >> y1 >> x2 >> y2;
x1 = abs(x1 - x2);
y1 = abs(y1 - y2);
cout << n * m - 2 * (n - x1) * (m - y1) +
max(n - 2 * x1, 0LL) * max(m - 2 * y1, 0LL)
<< endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-8;
template <class T>
T sqr(T x) {
return x * x;
}
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
int main(int argc, char** argv) {
double ans = 0;
double a, b;
int n;
scanf("%lf%lf%d", &a, &b, &n);
if (a == 0) {
if (b == 0)
ans = 0;
else
ans = 0.5;
} else
ans = pow(abs(b / a), 1.0 / n);
if (b / a < 0 && n % 2 == 0) ans = 0.5;
if (b / a < 0 && n % 2 == 1) ans = -ans;
if (abs(ans - round(ans)) < eps)
printf("%d\n", (int)round(ans));
else
printf("No solution\n");
return (EXIT_SUCCESS);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 4;
const int maxlog = 22;
const int mod = 1e9 + 7;
const int sq = 350;
int deg[maxn], cnt[maxn];
map<pair<int, int>, int> m;
long long ans = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(20);
int n, p;
cin >> n >> p;
for (int i = 0; i < n; i++) {
int u, v;
cin >> u >> v;
deg[u]++, deg[v]++;
if (u > v) swap(u, v);
m[make_pair(u, v)]++;
}
for (int i = 1; i <= n; i++) cnt[deg[i]]++;
for (int i = n; i >= 0; i--) cnt[i] += cnt[i + 1];
for (int i = 1; i <= n; i++) {
int x = max(0, p - deg[i]);
ans += (long long)cnt[x];
if (2 * deg[i] >= p) ans--;
}
ans /= 2;
for (map<pair<int, int>, int>::iterator it = m.begin(); it != m.end(); it++) {
int u = (*it).first.first, v = (*it).first.second;
int cnt = (*it).second;
if (deg[u] + deg[v] >= p && deg[u] + deg[v] - cnt < p) ans--;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p[3000];
int d[3000];
bool mark[3000];
void dfs(int v) {
mark[v] = true;
d[v] = d[p[v]] + 1;
for (int i = 0; i < n; i++)
if (p[i] == v) {
dfs(i);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
if (num == -1)
p[i] = num;
else
p[i] = num - 1;
}
for (int i = 0; i < n; i++) {
if (p[i] == -1 && mark[i] == false) dfs(i);
}
int max1 = 0;
for (int i = 0; i < n; i++)
if (d[i] > max1) max1 = d[i];
cout << max1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int kPntMax = 111;
const int kVtxMax = 111;
const double kEps = 1e-8;
inline int sgn(double x) {
if (fabs(x) < kEps) return 0;
return x > 0 ? 1 : -1;
}
struct Point {
double x, y;
Point() {}
Point(double _x, double _y) : x(_x), y(_y) {}
bool operator<(const Point &T) const {
return sgn(x - T.x) < 0 || (sgn(x - T.x) == 0 && sgn(y - T.y) < 0);
}
bool operator==(const Point &T) const {
return sgn(x - T.x) == 0 && sgn(y - T.y) == 0;
}
} p[kPntMax], q[kPntMax], ps, pt;
int n, m;
double f[kVtxMax][kVtxMax];
Point operator+(const Point &p1, const Point &p2) {
return Point(p1.x + p2.x, p1.y + p2.y);
}
Point operator-(const Point &p1, const Point &p2) {
return Point(p1.x - p2.x, p1.y - p2.y);
}
Point operator*(const Point &p1, double k) { return Point(p1.x * k, p1.y * k); }
double cross(const Point &p1, const Point &p2) {
return p1.x * p2.y - p1.y * p2.x;
}
double dot(const Point &p1, const Point &p2) {
return p1.x * p2.x + p1.y * p2.y;
}
double calcDist(const Point &p1, const Point &p2) {
return sqrt(dot(p1 - p2, p1 - p2));
}
bool isItc(const Point &p1, const Point &p2, const Point &q1, const Point &q2) {
if (sgn(cross(p2 - p1, q2 - q1)) == 0) return false;
return sgn(cross(q1 - p1, p2 - p1)) * sgn(cross(p2 - p1, q2 - p1)) >= 0 &&
sgn(cross(p1 - q1, q2 - q1)) * sgn(cross(q2 - q1, p2 - q1)) >= 0;
}
Point getItc(const Point &p1, const Point &p2, const Point &q1,
const Point &q2) {
double a = p2.y - p1.y, b = p1.x - p2.x, c = -(a * p1.x + b * p1.y);
double u = fabs(a * q1.x + b * q1.y + c), v = fabs(a * q2.x + b * q2.y + c);
Point d = q2 - q1;
d = d * (u / (u + v));
return q1 + d;
}
int main() {
for (int i = 0; i < kVtxMax; i++)
for (int j = 0; j < kVtxMax; j++)
if (i != j) f[i][j] = 1e100;
scanf("%lf%lf%lf%lf", &ps.x, &ps.y, &pt.x, &pt.y);
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf%lf", &p[i].x, &p[i].y);
for (int i = 0; i < n; i++) {
int j = (i + 1) % n;
f[i][j] = f[j][i] = calcDist(p[i], p[j]);
if (isItc(p[i], p[j], ps, pt)) {
q[m] = getItc(p[i], p[j], ps, pt);
bool found = false;
for (int k = 0; k < m; k++)
if (q[m] == q[k]) found = true;
if (found) continue;
f[i][n + 2 + m] = f[n + 2 + m][i] = calcDist(q[m], p[i]);
f[j][n + 2 + m] = f[n + 2 + m][j] = calcDist(q[m], p[j]);
m++;
}
}
assert(m <= 2);
double ans;
if (m <= 1)
ans = calcDist(ps, pt);
else {
f[n + 2][n + 3] = f[n + 3][n + 2] = 2 * calcDist(q[0], q[1]);
if (calcDist(q[0], ps) < calcDist(q[1], ps)) {
f[n][n + 2] = f[n + 2][n] = calcDist(q[0], ps);
f[n + 1][n + 3] = f[n + 3][n + 1] = calcDist(q[1], pt);
} else {
f[n][n + 3] = f[n + 3][n] = calcDist(q[1], ps);
f[n + 1][n + 2] = f[n + 2][n + 1] = calcDist(q[0], pt);
}
int nn = n + m + 2;
for (int k = 0; k < nn; k++)
for (int i = 0; i < nn; i++)
for (int j = 0; j < nn; j++)
if (f[i][j] > f[i][k] + f[k][j]) f[i][j] = f[i][k] + f[k][j];
ans = f[n][n + 1];
}
printf("%.10lf\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
pair<double, double> t[100010];
bool done[100010];
map<pair<pair<int, int>, pair<int, int> >, long long> dp;
vector<pair<double, vector<int> > > x, y;
long long go(int n, int k, int px, int kx, int py, int ky) {
if (dp.find(make_pair(make_pair(px, kx), make_pair(py, ky))) != dp.end())
return dp[make_pair(make_pair(px, kx), make_pair(py, ky))];
if (px == kx && py == ky)
return dp[make_pair(make_pair(px, kx), make_pair(py, ky))] = 1;
long long res = (long long)max(x[kx].first - x[px].first + 0.5, 1.0) *
(long long)max(y[ky].first - y[py].first + 0.5, 1.0);
vector<int> pom;
if (px < kx) {
for (int i = 0; i < ((int)x[px].second.size()); ++i)
if (!done[x[px].second[i]]) pom.push_back(x[px].second[i]);
if (k >= (int)pom.size()) {
for (int i = 0; i < ((int)pom.size()); ++i) done[pom[i]] = 1;
res = min(res, go(n, k - (int)pom.size(), px + 1, kx, py, ky));
for (int i = 0; i < ((int)pom.size()); ++i) done[pom[i]] = 0;
}
pom.clear();
}
if (px < kx) {
for (int i = 0; i < ((int)x[kx].second.size()); ++i)
if (!done[x[kx].second[i]]) pom.push_back(x[kx].second[i]);
if (k >= (int)pom.size()) {
for (int i = 0; i < ((int)pom.size()); ++i) done[pom[i]] = 1;
res = min(res, go(n, k - (int)pom.size(), px, kx - 1, py, ky));
for (int i = 0; i < ((int)pom.size()); ++i) done[pom[i]] = 0;
}
pom.clear();
}
if (py < ky) {
for (int i = 0; i < ((int)y[py].second.size()); ++i)
if (!done[y[py].second[i]]) pom.push_back(y[py].second[i]);
if (k >= (int)pom.size()) {
for (int i = 0; i < ((int)pom.size()); ++i) done[pom[i]] = 1;
res = min(res, go(n, k - (int)pom.size(), px, kx, py + 1, ky));
for (int i = 0; i < ((int)pom.size()); ++i) done[pom[i]] = 0;
}
pom.clear();
}
if (py < ky) {
for (int i = 0; i < ((int)y[ky].second.size()); ++i)
if (!done[y[ky].second[i]]) pom.push_back(y[ky].second[i]);
if (k >= (int)pom.size()) {
for (int i = 0; i < ((int)pom.size()); ++i) done[pom[i]] = 1;
res = min(res, go(n, k - (int)pom.size(), px, kx, py, ky - 1));
for (int i = 0; i < ((int)pom.size()); ++i) done[pom[i]] = 0;
}
pom.clear();
}
return dp[make_pair(make_pair(px, kx), make_pair(py, ky))] = res;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < (n); ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
t[i].first = (x1 + x2) / 2.0;
t[i].second = (y1 + y2) / 2.0;
}
map<double, vector<int> > mx;
map<double, vector<int> > my;
for (int i = 0; i < (n); ++i) {
mx[t[i].first].push_back(i);
my[t[i].second].push_back(i);
}
for (map<double, vector<int> >::iterator it = mx.begin(); it != mx.end();
it++) {
x.push_back(*it);
}
for (map<double, vector<int> >::iterator it = my.begin(); it != my.end();
it++) {
y.push_back(*it);
}
printf("%lld\n", go(n, k, 0, x.size() - 1, 0, y.size() - 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void input(long long int a[], long long int sz) {
for (long long int i = 0; i < sz; i++) cin >> a[i];
}
void print(long long int a[], long long int sz) {
for (long long int i = 0; i < sz; i++) {
if (i == sz - 1)
cout << a[i] << "\n";
else
cout << a[i] << " ";
}
}
long long int dx1[] = {1, 1, 0, -1, -1, -1, 0, 1};
long long int dy1[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long int dx2[] = {1, 0, -1, 0};
long long int dy2[] = {0, 1, 0, -1};
long long int mul(long long int a, long long int b,
long long int p = 1000000007) {
return ((a % p) * (b % p)) % p;
}
long long int add(long long int a, long long int b,
long long int p = 1000000007) {
return (a % p + b % p) % p;
}
long long int power(long long int x, long long int y,
long long int p = 1000000007) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modInverse(long long int n, long long int p = 1000000007) {
return power(n, p - 2, p);
}
long long int ncrMod(long long int n, long long int r,
long long int p = 1000000007) {
if (r == 0) return 1;
long long int fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
bool isPrime(long long int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
void solve() {
long long int n;
cin >> n;
long long int N = 10000000;
long long int x = 0, y;
long long int temp = n;
long long int i = 1;
while (n - i > 0) {
n -= i;
i++;
}
cout << n << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, m = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
m = (a[n - 1] - a[0]) / 2;
cout << a[0] + m << endl;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n % 2) {
printf("7");
n -= 3;
}
while (n > 0) {
printf("1");
n -= 2;
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct ring {
int inside, outside, height;
} rings[200000];
long long all, tot;
bool cmp(ring a, ring b) {
if (a.outside != b.outside) return a.outside < b.outside;
return a.inside < b.inside;
}
int main() {
int n;
while (cin >> n) {
all = 0;
tot = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &rings[i].inside, &rings[i].outside, &rings[i].height);
}
sort(rings, rings + n, cmp);
stack<ring> keys;
for (int i = n - 1; i >= 0; i--) {
while (1) {
if (keys.empty()) break;
ring key = keys.top();
if (key.outside >= rings[i].outside && key.inside < rings[i].outside)
break;
all -= key.height;
keys.pop();
}
keys.push(rings[i]);
all += rings[i].height;
tot = max(tot, all);
}
cout << tot << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int div_floor(const long long int &a, const long long int &b) {
return a / b - (((a ^ b) < 0) and a % b);
}
long long int div_ceil(const long long int &a, const long long int &b) {
return a / b + (((a ^ b) >= 0) and a % b);
}
void solve() {
long long int n;
cin >> n;
long long int ans = 0, idx = 1;
while ((idx * (idx + 1)) / 2 <= n)
n -= (idx * (idx + 1)) / 2, idx = idx * 2 + 1, ans++;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
int N, K;
vector<vector<int> > adj;
vector<vector<int> > chd;
void dfs(int u, int p) {
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p) continue;
dfs(v, u);
chd[u].push_back(v);
}
}
int cc[102][102][102];
int dp(int u, int t, int d) {
int &ret = cc[u][t][d];
if (ret != -1) return ret;
if (t > K && d > K) return ret = 0;
if (d == 101) {
ret = 1;
for (int i = 0; i < chd[u].size(); i++) {
int v = chd[u][i];
ret = 1LL * ret * dp(v, min(101, t + 1), d) % mod;
}
return ret;
}
if (d == 0) {
ret = 0;
for (int i = 1; i <= 101; i++) {
ret += dp(u, 0, i);
ret %= mod;
}
return ret;
}
if (chd[u].size() == 0) return ret = 0;
if (chd[u].size() == 1) return ret = dp(chd[u][0], min(101, t + 1), d - 1);
vector<vector<int> > dpv(chd.size(), vector<int>(101));
int tmp1 = 1;
int tmp2 = 1;
for (int i = 0; i < chd[u].size(); i++) {
int v = chd[u][i];
for (int j = 101; j >= d; j--) {
if (j == 101)
dpv[i][j] = dp(v, min(101, min(t + 1, d + 1)), 101);
else
dpv[i][j] = dp(v, min(101, min(t + 1, d + 1)), j - 1);
if (j != 101) {
dpv[i][j] += dpv[i][j + 1];
dpv[i][j] %= mod;
}
}
tmp1 = 1LL * tmp1 * dpv[i][d] % mod;
tmp2 = 1LL * tmp2 * dpv[i][d + 1] % mod;
}
ret = tmp1 - tmp2;
ret = (ret % mod + mod) % mod;
return ret;
}
int main() {
scanf("%d %d", &N, &K);
adj.clear();
adj.resize(N);
for (int i = 0; i < N - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
chd.resize(N);
dfs(0, -1);
memset(cc, -1, sizeof(cc));
int ans = 0;
for (int i = 0; i <= 101; i++) {
ans += dp(0, 101, i);
ans %= mod;
}
printf("%d", ans);
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fi first
#define se second
const ll mod=1e9+7;
const int N=2e6+1;
ll n,m;
ll a[1501][1501],b[1501][1501],f[1501][1501];
int ban[1501];
bool die[1501];
vector<int>ans;
vector<int>fun[1501];
int ord[1501];
int main(){
ios::sync_with_stdio(false);cin.tie(0);
cin >> n >> m;
for(int i=1; i<=n ;i++){
for(int j=1; j<=m ;j++){
cin >> a[i][j];
}
ord[i]=i;
}
for(int i=1; i<=n ;i++){
for(int j=1; j<=m ;j++){
cin >> b[i][j];
if(i!=1){
f[i-1][j]=b[i-1][j]>b[i][j];
ban[j]+=f[i-1][j];
}
}
}
stack<int>s;
for(int i=1; i<=m ;i++){
if(ban[i]==0) s.push(i);
}
while(!s.empty()){
int x=s.top();s.pop();
ans.push_back(x);
for(int i=1; i<n ;i++){
if(die[i]) continue;
if(b[i][x]<b[i+1][x]){
die[i]=true;
for(int j=1; j<=m ;j++){
if(ban[j]==0) continue;
ban[j]-=f[i][j];
if(ban[j]==0) s.push(j);
}
}
}
}
reverse(ans.begin(),ans.end());
for(auto c:ans){
for(int j=1; j<=n ;j++){
fun[a[ord[j]][c]].push_back(ord[j]);
}
int ptr=0;
for(int j=1; j<=n ;j++){
for(auto c:fun[j]){
ord[++ptr]=c;
}
fun[j].clear();
}
}
bool ok=true;
for(int i=1; i<=n ;i++){
for(int j=1; j<=m ;j++){
if(a[ord[i]][j]!=b[i][j]) ok=false;
}
}
if(ok){
cout << ans.size() << '\n';
for(auto c:ans) cout << c << ' ';
cout << '\n';
}
else cout << "-1\n";
} | 9 |
#include <bits/stdc++.h>
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int N = 5e5 + 7;
const int INF = 1e9 + 7;
pair<int, int> spc;
int p[N], h[N];
int t, n, m;
vector<int> g[N], d[N];
void dfs(int v, int pr = 0) {
p[v] = pr;
h[v] = h[p[v]] + 1;
d[h[v]].push_back(v);
for (int to : g[v])
if (!h[to]) dfs(to, v);
if (spc.first < h[v]) spc = {h[v], v};
}
void up(int v) {
cout << v << ' ';
if (v == 1) return;
up(p[v]);
}
void pairing() {
vector<pair<int, int> > ans;
for (int i = 1; i <= n; i++)
for (int j = 0; j + 1 < d[i].size(); j += 2)
ans.push_back({d[i][j], d[i][j + 1]});
cout << "PAIRING\n" << int(ans.size()) << '\n';
for (pair<int, int> it : ans) cout << it.first << ' ' << it.second << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1);
if (spc.first >= (n + 1) / 2) {
cout << "PATH\n" << spc.first << '\n';
up(spc.second);
cout << '\n';
} else
pairing();
for (int i = 1; i <= n; i++) {
g[i].clear();
d[i].clear();
h[i] = 0;
}
spc = {0, 0};
cout << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
;
char s[200007];
char pat[200007];
char pattern[200007];
char text[200007];
int pre[200007];
int ans[200007];
int s1[200007];
int s2[200007];
vector<int> v;
set<int> st;
int psz;
int tsz;
long int h[10000000];
void compute_func() {
long long plen = strlen(pattern);
plen--;
h[0] = -1;
long long int k = -1;
for (long long int q = 1; q <= plen; q++) {
while (k > -1 && pattern[k + 1] != pattern[q]) k = h[k];
if (pattern[k + 1] == pattern[q]) k = k + 1;
h[q] = k;
}
}
void kmpi() {
compute_func();
long long tlen = strlen(text);
long long plen = strlen(pattern);
plen--;
long long int q = -1;
for (long long int i = 0; i < tlen; i++) {
while (q > -1 && pattern[q + 1] != text[i]) q = h[q];
if (pattern[q + 1] == text[i]) q = q + 1;
if (q == plen) {
v.push_back(i);
st.insert(i);
q = h[q];
}
}
}
void prefix() {
pre[0] = 0;
long long k = 0;
for (long long i = 1; i < psz; i++) {
while (k > 0 and pat[i] != pat[k]) k = pre[k];
if (pat[i] == pat[k]) k++;
pre[i] = k;
}
for (int i = 0; i < psz; i++) h[i] = pre[i] - 1;
}
void kmp() {
long long match = 0;
for (long long i = 0; i < tsz; i++) {
while (match > 0 and s[i] != pat[match]) match = pre[match - 1];
if (pat[match] == s[i]) match++;
if (match == psz) {
v.push_back(i);
st.insert(i);
match = pre[match - 1];
}
}
}
int main() {
scanf("%s", text);
scanf("%s", pattern);
tsz = strlen(text);
psz = strlen(pattern);
compute_func();
prefix();
kmpi();
for (int i = 0; i < tsz; i++) {
if (st.find(i) == st.end()) {
if (i == 0) {
s1[i] = s2[i] = 0;
ans[i] = 0;
} else {
ans[i] = ans[i - 1];
s1[i] = ans[i] + s1[i - 1];
s1[i] %= 1000000007;
s2[i] = s1[i] + s2[i - 1];
s2[i] %= 1000000007;
}
} else {
if (i == 0) {
ans[i] = s1[i] = s2[i] = 1;
continue;
}
int x = i - psz + 2 + s2[i - psz] + 1000000007;
x %= 1000000007;
ans[i] = x;
ans[i] %= 1000000007;
s1[i] = s1[i - 1] + x;
s1[i] %= 1000000007;
s2[i] = s2[i - 1] + s1[i];
s2[i] %= 1000000007;
}
}
int fans = 0;
for (int i = 0; i < tsz; i++) {
fans = fans + ans[i];
if (fans >= 1000000007) fans -= 1000000007;
}
cout << fans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 100005;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
long long int i, j, k, n, m, l, r, ans = 0, cnt = 0, sum = 0;
vector<pair<long long int, long long int>> v;
for (i = 0; i < 8; i++) {
cin >> j >> k;
v.push_back(make_pair(j, k));
}
sort((v).begin(), (v).end());
map<long long int, long long int> x, y;
for (long long int i = (long long int)(0); i < (long long int)(v.size());
i++) {
j = v[i].first;
k = v[i].second;
if (x[j] == 0) {
x[j]++;
cnt++;
} else {
x[j]++;
}
if (y[k] == 0) {
y[k]++;
sum++;
} else {
y[k]++;
}
}
l = v[3].first;
r = v[1].second;
if (cnt > 3 || sum > 3 || cnt < 3 || sum < 3) {
cout << "ugly" << endl;
return 0;
}
if (x[v[3].first] > 2) {
cout << "ugly" << endl;
return 0;
}
for (long long int i = (long long int)(0);
i < (long long int)(v.size() - 1); i++) {
if (v[i].first == v[i + 1].first && v[i].second == v[i + 1].second) {
cout << "ugly" << endl;
return 0;
}
}
for (long long int i = (long long int)(3); i < (long long int)(6); i++) {
if (v[i].first == l && v[i].second == r) {
cout << "ugly" << endl;
return 0;
}
}
cout << "respectable" << endl;
return 0;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long c2(long long a) { return (a * (a - 1)) / 2LL; }
int main() {
long long a, b, c, l;
cin >> a >> b >> c >> l;
long long res = 0;
for (long long i = 0; i <= l; i++) {
long long sum = a + b + c + i;
long long saqf = (sum + 1) / 2;
long long total = c2(i + 2);
if (a >= saqf || b >= saqf || c >= saqf) continue;
long long save = i;
long long bad = 0;
i -= saqf - a;
if (i >= 0) bad += c2(i + 2);
i = save;
i -= saqf - b;
if (i >= 0) bad += c2(i + 2);
i = save;
i -= saqf - c;
if (i >= 0) bad += c2(i + 2);
i = save;
res += (total - bad);
}
cout << res << endl;
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.