solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k, ans = 0, cnt = 0;
cin >> n >> k;
string s;
cin >> s;
char a[k];
for (int i = 0; i < k; i++) {
cin >> a[i];
}
bool flag;
for (int i = 0; i < n; i++) {
flag = false;
for (int j = 0; j < k; j++) {
if (s[i] == a[j]) {
cnt++;
flag = true;
break;
}
}
if (!flag) {
ans += ((cnt * (cnt + 1)) / 2);
cnt = 0;
}
}
ans += ((cnt * (cnt + 1)) / 2);
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long maxm = -1e18;
long long minm = 1e18;
const long double Pi = 3.141592653;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[n];
string k = "";
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0 && i != n - 1) {
k += "R";
} else if (i != n - 1 && a[i] != 0) {
for (int j = 0; j < a[i] - 1; j++) {
k += "PRL";
}
k += "PR";
} else if (i == n - 1 && a[i] != 0) {
for (int j = 0; j < a[i] - 1; j++) {
k += "PLR";
}
k += "P";
}
}
cout << k << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s = "";
int i, a, b, x, y;
cin >> a >> b >> x;
y = x;
if (y % 2 == 0) {
y = (y / 2);
} else {
y = (y / 2) + 1;
}
for (i = 0; i < y; i++) {
s = s + "10";
a--;
b--;
}
if (x % 2 == 0) {
if ((a != 0) && (b != 0)) {
for (i = 0; i < b; i++) {
s = "1" + s;
}
for (i = 0; i < a; i++) {
s = "0" + s;
}
} else if (a == 0) {
for (i = 0; i < b; i++) {
s = s + "1";
}
} else {
for (i = 0; i < a; i++) {
s = "0" + s;
}
}
} else {
for (i = 0; i < a; i++) {
s = s + "0";
}
for (i = 0; i < b; i++) {
s = "1" + s;
}
}
cout << s;
}
| 5 |
#include <bits/stdc++.h>
const int N = 1e5 + 1;
int i, j, n, m, q, t, d[N], lg[N], fa[N], en[N * 2], nxt[N * 2], ft[N][17];
std::priority_queue<int> b, s, f[N][17];
void Mer(std::priority_queue<int>& a, std::priority_queue<int>& x) {
for (b = x; !b.empty(); a.size() > t ? a.pop() : void(0))
a.push(b.top()), b.pop();
}
void dfs(int u) {
for (i = 0; i++ < lg[d[u]];
Mer(f[u][i] = f[u][i - 1], f[ft[u][i - 1]][i - 1]))
ft[u][i] = ft[ft[u][i - 1]][i - 1];
for (int i = fa[u]; i; i = nxt[i])
if (!d[en[i]]) d[en[i]] = d[u] + 1, *ft[en[i]] = u, dfs(en[i]);
}
void cal(int x, int y) {
if (d[x] < d[y]) std::swap(x, y);
for (s = **f, n = d[x] - d[y]; n; n -= n & -n)
Mer(s, f[x][lg[n & -n]]), x = ft[x][lg[n & -n]];
if (x == y) return Mer(s, *f[x]);
for (n = lg[d[x]]; ~n; --n)
if (ft[x][n] ^ ft[y][n])
Mer(s, f[x][n]), x = ft[x][n], Mer(s, f[y][n]), y = ft[y][n];
Mer(s, f[x][1]), Mer(s, *f[y]);
}
void W(int n, int x) {
if (!n) return;
s.pop(), W(n - 1, s.top());
if (n <= t) printf(" %d", x);
}
int main() {
for (scanf("%d%d%d", &n, &m, &q); ++t < n + n - 1;) {
scanf("%d%d", &i, &j);
en[t] = j, nxt[t] = fa[i], fa[i] = t;
en[++t] = i, nxt[t] = fa[j], fa[j] = t;
}
for (i = 1; i++ < n; lg[i] = lg[i >> 1] + 1)
;
for (t = 10, i = 0; i++ < m;)
if (scanf("%d", &j), f[j]->push(i), f[j]->size() > t) f[j]->pop();
for (dfs(d[1] = 1); q--; puts("")) {
scanf("%d%d%d", &i, &j, &t), cal(i, j);
printf("%d", t = std::min((int)s.size(), t));
W(s.size(), s.top());
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 7;
int a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n / 2; ++i) scanf("%d", &a[i]);
sort(a + 1, a + n / 2 + 1);
int res = 1e9, sum = 0;
for (int i = 1; i <= n / 2; ++i) sum += abs(i * 2 - 1 - a[i]);
res = min(res, sum);
sum = 0;
for (int i = 1; i <= n / 2; ++i) sum += abs(i * 2 - a[i]);
res = min(res, sum);
printf("%d", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void vp(T &a, int p) {
for (int i = 0; i < p; i++) cout << a[i] << " ";
cout << endl;
}
const long long mod = 1000000007;
const int N = 16;
bool tc[N][N];
const string noans = "The times have changed";
void wf(int n) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) tc[i][j] |= (tc[i][k] & tc[k][j]);
}
long long dp[1 << N][N];
long long compute(const int n, const int d, const vector<int> &a, int st,
int now, vector<int> &in) {
if (now == in.size()) return 1;
long long &ret = dp[st][now];
if (ret != -1) return ret;
ret = 0;
for (int i = d; i < n; i++) {
int nest = (1 << i);
if ((nest & st) != 0) continue;
bool isok = true;
for (int j = 0; j < d; j++) {
if (tc[i][j] && !(in[now] < a[j])) isok = false;
if (tc[j][i] && !(a[j] < in[now])) isok = false;
}
for (int j = d; j < n; j++) {
if (((1 << j) & st) && tc[i][j]) isok = false;
}
if (!isok) continue;
ret += compute(n, d, a, st | nest, now + 1, in);
}
return ret;
}
void solve(int n, long long y) {
vector<int> ans(n);
for (int i = 0; i < n; i++)
if (tc[i][i]) {
cout << noans << endl;
return;
}
for (int i = 0; i < (1 << n); i++)
for (int j = 0; j < n; j++) dp[i][j] = -1;
{
vector<int> tmp;
for (int i = 0; i < n; i++) tmp.push_back(i);
long long total = compute(n, 0, ans, 0, 0, tmp);
if (total < y) {
cout << noans << endl;
return;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ans[i] = j;
vector<int> tmp;
set<int> S;
for (int ii = 0; ii < i; ii++) S.insert(ans[ii]);
if (S.find(j) != S.end()) continue;
S.insert(j);
for (int ii = 0; ii < n; ii++)
if (S.find(ii) == S.end()) tmp.push_back(ii);
for (int ii = 0; ii < (1 << n); ii++)
for (int jj = 0; jj < n; jj++) dp[ii][jj] = -1;
long long cnt = compute(n, i + 1, ans, 0, 0, tmp);
if (cnt != 0 && cnt >= y)
break;
else
y -= cnt;
}
}
for (int i = 0; i < ans.size(); i++) {
if (i) cout << " ";
cout << ans[i] + 1;
}
cout << endl;
}
int main() {
int n, m;
long long y;
while (cin >> n >> y >> m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) tc[i][j] = false;
for (int i = 0; i < m; i++) {
int f, t;
cin >> f >> t;
f--;
t--;
tc[f][t] = true;
}
wf(n);
y -= 2000;
solve(n, y);
}
return false;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10e5 + 10;
int n, sx[maxn], sy[maxn];
vector<int> x, y;
int main() {
while (~scanf("%d", &n)) {
x.clear();
y.clear();
for (int i = 0; i < n; i++) {
int t, w;
scanf("%d%d", &t, &w);
if (t == 1) {
x.push_back(w);
} else {
y.push_back(w);
}
}
sort(x.begin(), x.end(), greater<int>());
sort(y.begin(), y.end(), greater<int>());
sx[0] = sy[0] = 0;
for (int i = 1; i <= x.size(); i++) {
sx[i] = sx[i - 1] + x[i - 1];
}
for (int i = 1; i <= y.size(); i++) {
sy[i] = sy[i - 1] + y[i - 1];
}
int result = 0x7fffffff;
for (int i = 0; i <= x.size(); i++) {
for (int j = 0; j <= y.size(); j++) {
int w = sx[x.size()] + sy[y.size()] - sx[i] - sy[j], tt = i + j * 2;
if (w <= tt) {
result = min(result, tt);
}
}
}
printf("%d\n", result);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int a[505][505];
int main() {
int x, y, x0, y0, test;
char c;
while (scanf("%d %d %d %d", &x, &y, &x0, &y0) != EOF) {
memset(a, 0, sizeof(a));
getchar();
a[x0][y0] = 1;
test = x * y;
int move = 1;
int again = 0;
while ((c = getchar()) != '\n') {
if (move && !again) {
printf("1 ");
test--;
} else
printf("0 ");
if (c == 'U') {
if (x0 == 1)
move = 0;
else {
x0 = x0 - 1;
move = 1;
if (a[x0][y0] == 0) {
a[x0][y0] = 1;
again = 0;
} else
again = 1;
}
}
if (c == 'D') {
if (x0 == x)
move = 0;
else {
x0 = x0 + 1;
move = 1;
if (a[x0][y0] == 0) {
a[x0][y0] = 1;
again = 0;
} else
again = 1;
}
}
if (c == 'L') {
if (y0 == 1)
move = 0;
else {
y0 = y0 - 1;
move = 1;
if (a[x0][y0] == 0) {
a[x0][y0] = 1;
again = 0;
} else
again = 1;
}
}
if (c == 'R') {
if (y0 == y)
move = 0;
else {
y0 = y0 + 1;
move = 1;
if (a[x0][y0] == 0) {
a[x0][y0] = 1;
again = 0;
} else
again = 1;
}
}
}
if (move == 0)
printf("0");
else
printf("%d", test);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000000")
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
ostream& operator<<(ostream& o, vector<T> x) {
for (auto it : x) o << it << ' ';
return o;
}
template <typename T>
istream& operator>>(istream& i, vector<T>& x) {
for (auto& it : x) i >> it;
return i;
}
template <typename T1, typename T2>
void chkmin(T1& a, T2 b) {
a > b ? a = b : 0;
}
template <typename T1, typename T2>
void chkmax(T1& a, T2 b) {
a < b ? a = b : 0;
}
const int INF = 1000000007;
const int INF2 = 100000000000000007;
const int mINF = 1e16;
const int MOD1 = 998244353;
const int MOD = 1000000007;
const int SIZE = 200010;
const int base = 53;
const long double eps = 1e-6;
const long double pi = acosl(-1.0);
int add(int a, int b) { return ((a + b) % MOD + MOD) % MOD; }
int mult(int a, int b) { return (a * b) % MOD; }
int binpow(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res = mult(res, a);
a = mult(a, a);
n >>= 1;
}
return res;
}
int binpow1(int a, int n) {
int res = 1;
while (n) {
if (n & 1) {
res *= a;
}
a *= a;
n >>= 1;
}
return res;
}
int inv(int a) { return binpow(a, MOD - 2); }
int del(int a, int b) { return mult(a, inv(b)); }
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int sqr(int x) { return x * x; }
int n, k, maxost, n1;
vector<int> divs;
void rec(int pos, int x) {
if (x >= k) return;
chkmax(maxost, x);
if (pos < divs.size()) {
rec(pos + 1, x);
rec(pos + 1, x * divs[pos]);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
maxost = 1;
n1 = n;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) n /= i, divs.push_back(i);
}
if (n != 1) divs.push_back(n);
rec(0, 1);
cout << k * n1 / maxost + maxost;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int S, a, b, c;
int main() {
while (scanf("%d", &S) != EOF) {
scanf("%d%d%d", &a, &b, &c);
int sum = a + b + c;
if (sum == 0)
printf("%d 0.0 0.0\n", S);
else
printf("%.10f %.10f %.10f\n", (S * a * 1.0) / sum, (S * b * 1.0) / sum,
(S * c * 1.0) / sum);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int p[1005][1005];
long long hor[1005][1005];
long long vol[1005][1005];
long long dr[1005][1005];
long long dl[1005][1005];
long long v[1005][1005][5];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> p[i][j];
for (int i = 0; i < n; ++i) {
long long s = 0;
for (int j = 0; j < m; ++j) {
hor[i][j] = s + (long long)p[i][j];
s = hor[i][j];
}
}
for (int i = 0; i < m; ++i) {
long long s = 0;
for (int j = 0; j < n; ++j) {
vol[j][i] = s + (long long)p[j][i];
s = vol[j][i];
}
}
for (int i = 1 - m; i < n; ++i) {
long long s = 0;
for (int x = (i < 0 ? 0 : i), y = (i < 0 ? -i : 0); x < n && y < m;
++x, ++y) {
dr[x][y] = s + (long long)p[x][y];
s = dr[x][y];
}
}
for (int i = 1 - m; i < n; ++i) {
long long s = 0;
for (int x = (i > 0 ? i : 0), y = (i < 0 ? m + i - 1 : m - 1);
(n > x) && (y >= 0); ++x, --y) {
dl[x][y] = s + (long long)p[x][y];
s = dl[x][y];
}
}
for (int i = 0; i <= k - 1; ++i)
for (int j = k - 1 - (k - 1 - (k - 1 - i));
j <= k - 1 + (k - 1 - (k - 1 - i)); ++j)
v[k - 1][k - 1][0] += (long long)p[i][j];
for (int i = k - 1; i <= k - 1 + k - 1; ++i)
for (int j = k - 1 - (k - 1 - (i - (k - 1)));
j <= k - 1 + (k - 1 - (i - (k - 1))); ++j)
v[k - 1][k - 1][1] += (long long)p[i][j];
for (int i = 0; i <= 2 * (k - 1); ++i)
for (int j = k - 1; j <= k - 1 + (k - 1 - abs(i - (k - 1))); ++j)
v[k - 1][k - 1][2] += (long long)p[i][j];
for (int i = 0; i <= 2 * (k - 1); ++i)
for (int j = k - 1 - (k - 1 - abs((k - 1) - i)); j <= k - 1; ++j)
v[k - 1][k - 1][3] += (long long)p[i][j];
long long mv = v[k - 1][k - 1][4], mx = k - 1, my = k - 1;
for (int i = k; i <= n - k; ++i) {
v[i][k - 1][0] =
v[i - 1][k - 1][0] + hor[i][(k - 1) * 2] -
(dl[i - 1][0] - dl[i - 1 - (k - 1)][k - 1]) -
(dr[i - 1][k - 1 + k - 1] -
((i > k && k > 1) ? dr[i - 1 - (k - 1) - 1][k - 1 - 1] : 0));
v[i][k - 1][1] = v[i - 1][k - 1][1] - hor[i - 1][(k - 1) * 2] +
dr[i + k - 1][k - 1] +
(dl[i + k - 1 - 1][k] - dl[i - 1][2 * (k - 1) + 1]);
v[i][k - 1][2] = v[i - 1][k - 1][2] - dr[i - 1][(k - 1) * 2] +
((i > k && k > 1) ? dr[i - 1 - k][k - 2] : 0) +
dl[i + k - 1][k - 1] -
((2 * (k - 1) + 1 < m) ? dl[i - 1][2 * (k - 1) + 1] : 0);
v[i][k - 1][3] = v[i - 1][k - 1][3] -
(dl[i - 1][0] - (i > k ? dl[i - 1 - k][k] : 0)) +
dr[i + k - 1][k - 1];
v[i][k - 1][4] = v[i - 1][k - 1][4] + v[i][k - 1][1] - v[i - 1][k - 1][0];
if (mv < v[i][k - 1][4]) mv = v[i][k - 1][4], mx = i;
}
for (int i = k - 1; i <= n - k; ++i)
for (int j = k; j <= m - k; ++j) {
v[i][j][2] = v[i][j - 1][2] -
(vol[i + k - 1][j - 1] - (i >= k ? vol[i - k][j - 1] : 0)) +
dr[i][j + k - 1] - (i >= k ? dr[i - k][j - 1] : 0) +
dl[i + k - 1][j] - dl[i][j + k - 1];
v[i][j][3] = v[i][j - 1][3] + vol[i + k - 1][j] -
(i >= k ? vol[i - k][j] : 0) -
(dl[i][j - 1 - (k - 1)] - (i >= k ? dl[i - k][j] : 0)) -
(dr[i + k - 1][j - 1] - dr[i][j - 1 - (k - 1)]);
v[i][j][4] = v[i][j - 1][4] + v[i][j][2] - v[i][j - 1][3];
if (v[i][j][4] > mv) mv = v[i][j][4], mx = i, my = j;
}
cout << (mx + 1) << ' ' << (my + 1);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
int n, a[2015];
int pre1[2015], suf2[2015], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
pre1[i] = (1 == a[i] ? pre1[i - 1] + 1 : pre1[i - 1]);
}
for (int i = n; i; --i) {
suf2[i] = (2 == a[i] ? suf2[i + 1] + 1 : suf2[i + 1]);
}
for (int i = 1; i <= n; ++i) {
if (2 == a[i]) {
ans = max(ans, pre1[i] + suf2[i]);
}
}
for (int l = 1; l <= n; ++l) {
int t1 = pre1[l - 1], ma = 0, cnt_2 = 0;
for (int r = l; r <= n; ++r) {
int t2 = suf2[r + 1];
if (1 == a[r]) {
++ma;
} else {
++cnt_2;
ma = max(ma, cnt_2);
}
ans = max(ans, t1 + t2 + ma);
}
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> rt[8080];
vector<int> rrt[8080];
string s(int a) {
if (a & 2) {
return "row " + to_string(a / 4) + "=" + to_string(a & 1);
} else {
return "col " + to_string(a / 4) + "=" + to_string(a & 1);
}
}
void mrt(int a, int b) {
rt[a].push_back(b);
rrt[b].push_back(a);
}
string mg[2020];
string t;
int row(int i) { return 4 * i; }
int col(int i) { return 4 * i + 2; }
int st[8080];
int cmp[8080];
vector<int> icmp[8080];
int cmpsz;
vector<int> crt[8080];
vector<int> nds;
void f(int c) {
if (st[c] == 1) return;
st[c] = 1;
for (auto w : rt[c]) {
f(w);
}
nds.push_back(c);
}
void g(int c, int ci) {
if (st[c] == 2) return;
st[c] = 2;
icmp[ci].push_back(c);
cmp[c] = ci;
for (auto w : rrt[c]) {
g(w, ci);
}
}
void h(int c) {
if (st[c] == 2) return;
f(c);
}
void ff(int c) {
if (st[c] == 3) return;
st[c] = 3;
for (auto w : crt[c]) ff(w);
nds.push_back(c);
}
bool v[4040];
bool rd[4040];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> mg[i];
}
string s;
for (int i = 0; i < N; ++i) {
cin >> s;
for (int j = 0; j < N; ++j) {
mg[i][j] = (mg[i][j] == s[j] ? '0' : '1');
}
}
cin >> s;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
if (mg[i][j] == '0') {
if (s[i] == '0' && s[j] == '0') {
} else if (s[i] == '1' && s[j] == '0') {
mrt(col(j) + 1, col(j));
} else if (s[i] == '0' && s[j] == '1') {
mrt(row(i) + 1, row(i));
} else {
mrt(row(i), col(j));
mrt(row(i) + 1, col(j) + 1);
mrt(col(j), row(i));
mrt(col(j) + 1, row(i) + 1);
}
} else {
if (s[i] == '0' && s[j] == '0') {
cout << -1 << "\n";
return 0;
} else if (s[i] == '1' && s[j] == '0') {
mrt(col(j), col(j) + 1);
} else if (s[i] == '0' && s[j] == '1') {
mrt(row(i), row(i) + 1);
} else {
mrt(row(i), col(j) + 1);
mrt(row(i) + 1, col(j));
mrt(col(j), row(i) + 1);
mrt(col(j) + 1, row(i));
}
}
}
}
for (int i = 0; i < 4 * N; ++i) h(i);
for (int i = nds.size() - 1; i >= 0; --i) {
if (st[nds[i]] == 2) continue;
g(nds[i], cmpsz++);
}
nds.clear();
for (int i = 0; i < 4 * N; ++i) {
for (auto w : rt[i]) {
crt[cmp[i]].push_back(cmp[w]);
}
}
for (int i = 0; i < cmpsz; ++i) ff(i);
for (int i = 0; i < 2 * N; ++i) {
if (cmp[2 * i] == cmp[2 * i + 1]) {
cout << -1 << "\n";
return 0;
}
}
for (auto ni : nds) {
for (auto c : icmp[ni]) {
if (rd[c / 2]) continue;
rd[c / 2] = 1;
v[c / 2] = c & 1;
}
}
int ano = 0;
for (int i = 0; i < N; ++i) ano += v[row(i) / 2] + v[col(i) / 2];
cout << ano << "\n";
for (int i = 0; i < N; ++i) {
if (v[row(i) / 2]) cout << "row " << i << "\n";
}
for (int i = 0; i < N; ++i) {
if (v[col(i) / 2]) cout << "col " << i << "\n";
}
}
| 13 |
/*
构造一个正交化的线性基
实现完全正交 is impossible;
退而求之局部正交,即crucial musk不能出现在其他向量中
竟然要用并查集我日你先人(
*/
#include<bits/stdc++.h>
#define ll long long
using namespace std;
#define pb push_back
const int ha = 1e9+7;
inline int add(int x,int y){ x+=y; return x>=ha?x-ha:x;}
inline void ADD(int &x,int y){ x+=y; if(x>=ha) x-=ha;}
inline int ksm(int x,int y){
int an=1;
for(;y;y>>=1,x=x*(ll)x%ha) if(y&1) an=an*(ll)x%ha;
return an;
}
class liner_base{
public:
int n,*e,*hd,*ne,*tl;
char *ex;
liner_base(int N) : n(N){
e = new int [N+5];
hd = new int [N+5];
ne = new int [N+5];
tl = new int [N+5];
ex = new char [N+5];
memset(hd,0,sizeof(int)*(N+3));
memset(ne,0,sizeof(int)*(N+3));
memset(tl,0,sizeof(int)*(N+3));
memset(ex,0,sizeof(char)*(N+3));
for(int i=0;i<=N;i++) e[i] = i;
}
~liner_base(){
/*
delete e;
delete hd;
delete ne;
delete tl;
delete ex;
*/
}
int gete(int x){ return e[x] == x ? x : (e[x] = gete(e[x]));}
inline void add_to_list(int Element,int List){
ne[Element] = hd[List];
e[Element] = List;
hd[List] = Element;
if(!tl[List]) tl[List] = Element;
}
void delete_list(int List){
for(int now = hd[List],NE;now;now = NE)
NE = ne[now] , e[now] = now , ne[now] = 0;
hd[List] = tl[List] = 0;
}
inline void alter_list(int List1,int List2){
if(!hd[List1]) return;
if(!hd[List2]) hd[List2] = hd[List1],tl[List2] = tl[List1];
else ne[tl[List2]] = hd[List1],tl[List2] = tl[List1];
hd[List1] = tl[List1] = 0;
}
inline void add(int x){ /*printf("add %d\n",x),*/ex[x] = 1,e[x] = x,delete_list(x);}
inline void add(int x,int y){ /*printf("add %d %d\n",x,y),*/ex[x] = 1,alter_list(x,y),add_to_list(x,y);}
inline bool insert(int x){
if(ex[x] && gete(x) == x) return 0;
if(ex[x]) add(gete(x));
else add(x);
return 1;
}
inline bool insert(int x,int y){
if(x == y) return 0;
if(ex[x] && (gete(x) == x)) return insert(y);
else if(ex[x]) return insert(min(gete(x),y),max(gete(x),y));
else if(ex[y] && gete(y) == y) return insert(x);
else if(ex[y]) return insert(x,gete(y));
else add(x,y);
return 1;
}
inline void consistent_check(){
int *color = new int [n+5];
memset(color,0,sizeof(int)*(n+3));
for(int i=1;i<=n;i++)
for(int j=hd[i];j;j=ne[j]) color[j] = i;
for(int i=1;i<=n;i++) if(ex[i] && !color[i]) color[i] = i;
for(int i=1;i<=n;i++) if(ex[i] && color[i] != gete(i))
printf("There is an unconsistent with node %d\ncolor is %d, but father is %d\n",i,color[i],gete(i));
}
inline void check(){
for(int i=1;i<=n;i++) if(ex[i]) printf("%d : %d\n",i,gete(i));
}
};
int main(){
// freopen("data.in","r",stdin);
// freopen("data.out","w",stdout);
int n,m; scanf("%d%d",&n,&m);
liner_base a(m);
queue<int> q;
for(int opt,X,Y,i=1;i<=n;i++){
scanf("%d",&opt);
if(opt==1){
scanf("%d",&X);
if(a.insert(X)) q.push(i);
}
else{
scanf("%d%d",&X,&Y);
if(a.insert(min(X,Y),max(X,Y))) q.push(i);
}
}
// a.consistent_check();
printf("%d %d\n",ksm(2,q.size()),(int)q.size());
while(!q.empty()) printf("%d ",q.front()),q.pop();
// a.check();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)200 + 7;
int d[N];
int d_in[N], d_out[N];
multiset<int> g[N];
vector<pair<int, int> > go;
void dfs(int v) {
while (g[v].size() > 0) {
int to = *g[v].begin();
go.push_back({v, to});
g[to].erase(g[to].find(v));
g[v].erase(g[v].begin());
dfs(to);
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
memset(d, 0, sizeof d);
memset(d_in, 0, sizeof d_in);
memset(d_out, 0, sizeof d_out);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
d[u]++, d[v]++;
g[u].insert(v);
g[v].insert(u);
}
int t = n;
for (int i = 0; i < n; i++) {
if (d[i] % 2 == 1) {
g[i].insert(t);
g[t].insert(i);
}
}
go.clear();
for (int i = 0; i <= n; i++) dfs(i);
vector<pair<int, int> > res;
for (auto f : go) {
if (f.first != t && f.second != t) {
d_out[f.first]++;
d_in[f.second]++;
res.push_back(f);
}
}
int ans = 0;
for (int i = 0; i < n; i++) ans += (d_in[i] == d_out[i]);
printf("%d\n", ans);
for (auto f : res) {
printf("%d %d\n", f.first + 1, f.second + 1);
}
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10, mod = 1e9 + 7;
int q, cnt, f[N], t, k;
long long dp[N][N][2], x1, x2;
char c[N];
long long dfs(int pos, int dis, bool lim, bool ok) {
if (!pos) return ok;
if (!lim and ~dp[pos][dis][ok]) return dp[pos][dis][ok];
long long ans = 0;
for (register int i = 0; i <= (lim ? f[pos] : 9); ++i) {
if (i != 4 and i != 7)
ans += dfs(pos - 1, max(dis - 1, 0), lim and i == f[pos], ok);
else
ans += dfs(pos - 1, k, lim and i == f[pos], ok || dis);
if (ans >= mod) ans %= mod;
}
if (!lim) dp[pos][dis][ok] = ans;
return ans;
}
inline long long sol(bool minus) {
scanf("%s", c + 1);
cnt = strlen(c + 1);
for (register int i = 1; i <= cnt; ++i) f[i] = c[cnt - i + 1] ^ 48;
f[1] -= minus;
for (register int i = 1; i <= cnt; ++i) {
if (f[i] < 0)
f[i] += 10, --f[i + 1];
else
break;
}
return dfs(cnt, 0, 1, 0);
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d%d", &t, &k);
while (t--) {
x1 = sol(1);
x2 = sol(0);
printf("%lld\n", (x2 - x1 + mod) % mod);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const char E = '\n';
const int N = 500051;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int a[N] = {0};
long long s = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s += a[i];
}
sort(a + 1, a + n + 1);
if (s % 2 == 0 && s - a[n] >= a[n]) {
cout << "YES" << E;
} else {
cout << "NO" << E;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long N, X, Y, C;
long long D[5];
void read(void);
void soups_on(void);
long long yee_haw(long long);
int main() {
read(), soups_on();
return 0;
}
void read(void) { cin >> N >> X >> Y >> C, --X, --Y; }
void soups_on(void) {
long long low = 0, up = 0, mid;
D[0] = X, D[1] = Y, D[2] = N - 1 - X, D[3] = N - 1 - Y, D[4] = D[0];
for (int i = 0; i < 4; ++i) up = max(up, D[i] + D[i + 1]);
while (low < up) {
mid = (low + up) / 2;
if (yee_haw(mid) < C)
low = mid + 1;
else
up = mid;
}
cout << low << "\n";
}
long long yee_haw(long long b) {
long long res = 1;
for (int i = 0; i < 4; ++i) {
if (D[i] + D[i + 1] <= b)
res += (D[i] + 1) * (D[i + 1] + 1);
else {
res += (b + 1) * (b + 2) / 2;
if (D[i] < b) res -= (b - D[i]) * (b - D[i] + 1) / 2;
if (D[i + 1] < b) res -= (b - D[i + 1]) * (b - D[i + 1] + 1) / 2;
}
res -= min(D[i], b) + 1;
}
return res;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int toInt(string X) {
int val;
istringstream ss(X);
ss >> val;
return val;
}
int diff(string A, string B) { return abs(toInt(A) - toInt(B)); }
int main() {
int n, k;
cin >> n >> k;
vector<string> numbers(n);
string num;
for (int i = (0); i < (n); ++i) cin >> numbers[i];
vector<int> perm(k);
for (int i = (0); i < (k); ++i) perm[i] = i;
vector<int> differences;
do {
vector<string> newNums(n);
for (int i = (0); i < (n); ++i) {
string N = "";
for (int j = (0); j < (k); ++j) {
N += numbers[i][perm[j]];
}
newNums[i] = N;
}
sort(newNums.begin(), newNums.end());
differences.push_back(diff(newNums[0], newNums[n - 1]));
} while (next_permutation(perm.begin(), perm.end()));
sort(differences.begin(), differences.end());
cout << differences[0] << endl;
}
| 6 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const int mod = 1e9 + 7;
using namespace std;
vector<int> g[maxn];
int dist[maxn];
int n, x, not_ok, max_d;
void dfs(int last_v, int curr_v, int _d) {
dist[curr_v] = _d;
for (auto _x : g[curr_v]) {
if (_x != last_v) dfs(curr_v, _x, _d + 1);
}
}
void dfs2(int curr, int last) {
if (dist[curr] <= not_ok) return;
max_d = max(max_d, dist[curr]);
for (int _x : g[curr]) {
if (_x != last) dfs2(_x, curr);
}
}
void solve() {
cin >> n >> x;
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0, 1, 0);
not_ok = dist[x] / 2;
dfs2(x, x);
int ans = 2 * max_d;
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, x[100009], y[100009], j = 0, t1 = 0, t2 = 0;
string second, s1, s2;
bool isnum(string a) {
if (a[0] == '0' && a.length() > 1) return 0;
if (a.length() == 0) return 0;
for (int(i) = 0; i < (a.length()); i++) {
if (!(a[i] >= 48 && a[i] < 58)) return 0;
}
return 1;
}
int main() {
cin >> second;
x[j] = 0;
s1 += '\"';
s2 += '\"';
for (int(i) = 0; i < (second.length()); i++)
if (second[i] == ';' || second[i] == ',') {
y[j] = i - 1;
j++;
x[j] = i + 1;
}
y[j] = second.length() - 1;
for (int(i) = 0; i < (j + 1); i++)
if (isnum(second.substr(x[i], y[i] - x[i] + 1))) {
if (t1 != 0) s1 += ',';
t1++;
s1 += second.substr(x[i], y[i] - x[i] + 1);
} else {
if (t2 != 0) s2 += ',';
t2++;
s2 += second.substr(x[i], y[i] - x[i] + 1);
}
s1 += '\"';
s2 += '\"';
if (t1 == 0) s1 = "-";
if (t2 == 0) s2 = "-";
cout << s1 << endl << s2;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, i, j, ans = 0, n, arr[4100], find[50000] = {}, sum = 0;
string s;
cin >> a >> s;
n = s.size();
for (i = 0; i < n; i++) arr[i] = s[i] - '0';
for (i = 0; i < n; i++) {
sum = 0;
for (j = i; j < n; j++) {
sum += arr[j];
find[sum]++;
}
}
if (a == 0)
ans = n * (n + 1) * find[0] - find[0] * find[0];
else {
for (i = 0; i < n; i++) {
sum = 0;
for (j = i; j < n; j++) {
sum += arr[j];
if (sum != 0 && a % sum == 0 && a / sum <= n * 9) ans += find[a / sum];
}
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
deque<long long int> q;
long long int id[n];
int cnt = 0;
for (int i = 0; i < n; i++) {
cin >> id[i];
}
map<long long int, bool> mp;
for (int i = 0; i < n; i++) {
if (cnt == k) {
break;
}
if (mp[id[i]] == true) continue;
mp[id[i]] = true;
cnt++;
q.push_front(id[i]);
}
if (q.size() < k) {
cout << q.size() << endl;
for (long long itr : q) {
cout << itr << " ";
}
return 0;
} else {
for (int i = cnt; i < n; i++) {
if (mp[id[i]]) continue;
mp[id[i]] = true;
q.push_front(id[i]);
mp[q.back()] = false;
q.pop_back();
}
}
cout << q.size() << endl;
for (long long itr : q) {
cout << itr << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, a;
cin >> n;
int pos1[n + 2], pos2[n + 2];
for (int i = 0; i < n; i++) {
cin >> a;
pos1[a] = i;
}
for (int i = 0; i < n; i++) {
cin >> a;
pos2[a] = i;
}
int mx = 0, cnt;
unordered_map<int, int> mp;
for (int i = 1; i <= n; i++) {
int f1 = pos1[i] - pos2[i];
if (f1 < 0) f1 = n + f1;
mp[f1]++;
}
for (auto [x, y] : mp) mx = max(mx, y);
cout << mx << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-7;
const long double PI = 3.141592653589793;
int main() {
ios_base::sync_with_stdio(0);
int n, m, a, b;
cin >> n >> m >> a >> b;
int aa = n * a;
int bb = (n / m) * b + (n % m) * a;
int cc = (n / m) * b + b;
cout << (((aa) < ((((bb) < (cc)) ? (bb) : (cc))))
? (aa)
: ((((bb) < (cc)) ? (bb) : (cc))))
<< '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, i, cnt = 0;
scanf("%d", &n);
for (i = 1; i <= n / 2; i++) {
if (!((n - i) % i)) cnt++;
}
printf("%d", cnt);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1000 * 1000 * 1000 + 7;
long long n, k, a, b, q, type, d, x, p, arr[200005], arrb[200005], tree[200005],
treeb[200005], upd, updb;
void update(int x, long long val) {
while (x < 200005) {
tree[x] += val;
x += (x & -x);
}
}
void updateb(int x, long long val) {
while (x < 200005) {
treeb[x] += val;
x += (x & -x);
}
}
long long sum(int x) {
long long res = 0;
while (x > 0) {
res += tree[x];
x -= (x & -x);
}
return res;
}
long long sumb(int x) {
long long res = 0;
while (x > 0) {
res += treeb[x];
x -= (x & -x);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> a >> b >> q;
while (q--) {
cin >> type;
if (type == 1) {
cin >> d >> x;
if (arr[d] == a) continue;
if (!arr[d]) {
arr[d] = min(x, a);
arrb[d] = min(arr[d], b);
update(d, arr[d]);
updateb(d, arrb[d]);
continue;
}
if (arr[d] + x > a) {
upd = a - arr[d];
arr[d] = a;
} else {
arr[d] += x;
upd = x;
}
if (arr[d] > b) {
updb = b - arrb[d];
arrb[d] = b;
} else {
arrb[d] += x;
updb = x;
}
update(d, upd);
updateb(d, updb);
} else {
cin >> p;
cout << (sum(n) - sum(p + k - 1)) + sumb(p - 1) << "\n";
}
}
return 0;
}
| 9 |
// Created by Kshitij Anand NSIT
#include <bits/stdc++.h>
//#include <ext/numeric>
//using namespace __gnu_cxx;
using namespace std;
#define int long long
#define pb push_back
#define P pair<int,int>
#define F first
#define S second
#define vi vector<int>
#define vc vector<char>
#define vb vector<bool>
#define vp vector<P>
#define all(x) x.begin(),x.end()
#define sz(x) (int)x.size()
#define mp(a, b) make_pair(a, b)
#define min3(a, b, c) min(min(a, b), c)
#define min4(a, b, c, d) min(min(a, b), min(c, d))
#define max3(a, b, c) max(max(a, b), c)
#define max4(a, b, c, d) max(max(a, b), max(c, d))
#define fill(arr,val) memset(arr,val,sizeof(arr))
#define inf 1e18
#define ps(x,y) fixed<<setprecision(y)<<x
#define db(x) cout<<#x<<" : "<<x<<endl
#define filler(arr, n) \
for (int i = 0; i < n; i++) \
cin >> arr[i];
#define filler2(arr, n , m) \
for (int i = 0; i < n; i++) \
for(int j=0; j<m; j++) \
cin >> arr[i][j];
const int N = 1000000007;
void solve(){
int n,a,b,c,k,m, ans=0, count=0, sum=0;
cin>>n>>m>>k;
int arr1[k];
int arr2[k];
filler(arr1 , k);
filler(arr2 , k);
map<int,int> m1 , m2;
int init = k - 1;
for(int i=0; i<k; i++) {
ans += init--;
ans-= m1[arr1[i]];
ans-= m2[arr2[i]];
m1[arr1[i]]++;
m2[arr2[i]]++;
// m1[{arr1[i] , arr2[i]}] = k--;
}
cout<<ans<<endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int t; cin>>t; while(t--)
{
solve();
}
return 0;
}
/*Things to do if you are stuck:-
1.Read the problem statement again, maybe you've read something wrong.
2.See the explanation for the sample input .
3.If the solution is getting too complex in cases where no. of submissions
are high ,then drop that idea because there is something simple which you are
missing.
4.Check for runtime errors if unexpected o/p is seen.
5.Check on edge cases before submitting.
6.Ensure that you have read all the inputs before returning for a test case.
7.Try to think of brute force first if nothing is striking.
8.Don't give up , maybe you're just one statement away!
*/
| 6 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
long long power(long long x, unsigned long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) {
res = res * x;
}
y = y >> 1;
x = x * x;
}
return res;
}
long long powermod(long long x, unsigned long long y, long long p) {
long long 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 min(long long a, long long b) { return a < b ? a : b; }
long long max(long long a, long long b) { return a > b ? a : b; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void snow() {
long long n, k;
cin >> n >> k;
cout << (6 * n - 1) * k;
cout << '\n';
for (long long i = 0; i < n; i++) {
cout << k * (6 * i + 1) << " " << k * (6 * i + 2) << " " << k * (6 * i + 3)
<< " " << k * (6 * i + 5) << '\n';
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
t = 1;
for (long long i = 1; i <= t; i++) {
snow();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > G[100006];
bool visited[100006];
int parent[100006];
long long int n, m, p, q;
vector<pair<long long int, long long int> > ans;
long long int dfs(long long int u) {
long long int sum = 0;
visited[u] = true;
for (long long int i = 0; i < G[u].size(); ++i) {
pair<long long int, long long int> v = G[u][i];
if (!visited[v.first]) sum += dfs(v.first);
sum += v.second;
}
return sum;
}
set<pair<long long int, long long int> > vc;
int main() {
cin >> n >> m >> p >> q;
pair<long long int, long long int> et = make_pair(-1, -1);
memset(visited, 0, sizeof visited);
memset(parent, -1, sizeof parent);
long long int u = -1, v, w = INT_MAX;
for (long long int i = 0; i < m; ++i) {
long long int xi, yi, l;
cin >> xi >> yi >> l;
G[xi].push_back({yi, l});
G[yi].push_back({xi, l});
if (et.first == -1) et = make_pair(xi, yi);
}
for (long long int i = 1; i <= n; ++i)
if (!visited[i]) {
long long int x = dfs(i);
vc.insert({min(x / 2, 1000000000LL), i});
}
long long int comp = vc.size();
if (p == 0) {
if (comp == q) {
cout << "YES";
return 0;
} else {
cout << "NO";
return 0;
}
}
if (comp - q > p || (et.first == -1 && comp == q) || q > comp) {
cout << "NO";
return 0;
} else
cout << "YES\n";
int i = 0;
for (; i < p && i < comp - q; ++i) {
pair<long long int, long long int> now = *(vc.begin());
vc.erase(vc.begin());
if (et.first == -1) et = make_pair(now.second, vc.begin()->second);
cout << now.second << ' ' << vc.begin()->second << endl;
now.first = min(2 * now.first + 2 * vc.begin()->first + 1, 1000000000LL);
vc.erase(vc.begin());
vc.insert(now);
}
for (; i < p; ++i) {
cout << et.first << ' ' << et.second << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
inline int input() {
int n;
cin >> n;
return n;
}
long long pw(long long a, long long b) {
return (!b ? 1 : (b & 1 ? a * pw(a * a, b / 2) : pw(a * a, b / 2)));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, k;
cin >> n >> k;
if (k > n) return cout << -1 << endl, 0;
k--;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, greater<int>());
cout << a[k] << ' ' << a[k] << endl;
return 0;
}
| 1 |
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
const int N = 300005;
int t, n, a[N], b[N], fa[N];
int dfn[N], rks[N], siz[N], tt;
struct Edge
{
int to, nxt;
}E[N];
int head[N], tot;
inline void add(int f, int t)
{
E[++tot] = (Edge){t, head[f]}, head[f] = tot;
return;
}
void dfs1(int x)
{
rks[dfn[x] = ++tt] = x, siz[x] = 1;
for(int i = head[x];i;i = E[i].nxt)
{
int y = E[i].to;
dfs1(y), siz[x] += siz[y];
}
return;
}
std::set<int> st[N];
void dfs2(int x)
{
st[x].clear();
for(int i = head[x];i;i = E[i].nxt)
{
int y = E[i].to;
dfs2(y);
if(st[y].size() > st[x].size())
st[x].swap(st[y]);
for(std::set<int>::iterator it = st[y].begin();it != st[y].end();++it)
st[x].insert(*it);
}
std::set<int>::iterator it = st[x].lower_bound(dfn[x]);
while(it != st[x].end() && *it <= dfn[x]+siz[x]-1)
fa[rks[*it]] = x, st[x].erase(it++);
st[x].insert(dfn[x]);
return;
}
bool vis[N];
int ans, now;
void dfs3(int x)
{
int v = vis[fa[x]];
vis[fa[x]] = 0, now = now-v+1, vis[x] = 1;
ans = std::max(ans, now);
for(int i = head[x];i;i = E[i].nxt)
{
int y = E[i].to;
dfs3(y);
}
vis[fa[x]] = v, now = now+v-1, vis[x] = 0;;
return;
}
int main(void)
{
scanf("%d", &t);
while(t--)
{
scanf("%d", &n);
for(int i = 2;i <= n;++i)
scanf("%d", a+i);
for(int i = 2;i <= n;++i)
scanf("%d", b+i);
tt = now = ans = 0;
memset(vis, 0, sizeof(bool[n+5]));
memset(head, 0, sizeof(int[n+5])), tot = 0;
for(int i = 2;i <= n;++i)
add(b[i], i);
dfs1(1);
memset(head, 0, sizeof(int[n+5])), tot = 0;
for(int i = 2;i <= n;++i)
add(a[i], i);
dfs2(1);
dfs3(1);
printf("%d\n", ans);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5 + 42, LIM = 130, inf = 1e9;
int n;
long long inp[nmax];
vector<int> seen[61], adj[nmax];
queue<pair<int, int> > q, idle;
vector<pair<int, int> > edges;
int dist[nmax];
bool eq(int a, int b, pair<int, int> c) {
if (c == make_pair(a, b)) return 1;
if (c == make_pair(b, a)) return 1;
return 0;
}
int main() {
scanf("%i", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &inp[i]);
for (int i = 1; i <= n; i++)
for (int bit = 0; bit < 60; bit++)
if (((1LL << bit) & inp[i])) {
seen[bit].push_back(i);
}
for (int bit = 0; bit < 60; bit++)
if (seen[bit].size() >= 3) {
printf("3\n");
return 0;
} else if (seen[bit].size() == 2) {
adj[seen[bit][0]].push_back(seen[bit][1]);
adj[seen[bit][1]].push_back(seen[bit][0]);
edges.push_back({seen[bit][0], seen[bit][1]});
}
int shortest = inf;
for (auto k : edges) {
q = idle;
for (int j = 1; j <= n; j++) dist[j] = inf;
q.push({k.first, 0});
while (q.size()) {
pair<int, int> now = q.front();
q.pop();
int to = now.first;
int d = now.second;
if (dist[to] >= d)
dist[to] = d;
else
continue;
for (auto e : adj[to])
if (eq(to, e, k) == 0) {
q.push({e, d + 1});
}
}
shortest = min(shortest, dist[k.second] + 1);
}
if (shortest != inf)
printf("%i\n", shortest);
else
printf("-1");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void task();
int main() {
srand(time(0));
ios_base::sync_with_stdio(0);
task();
return 0;
}
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 10;
const int M = 1e5 + 10;
struct SufAutomaton {
struct State {
int len;
int link;
int cnt;
unordered_map<char, int> next;
State() : len(0), link(-1), cnt(0){};
};
State st[2 * N];
int sz = 1;
int last = 0;
void push(char ch) {
int cur = sz++;
st[cur].len = st[last].len + 1;
st[cur].cnt = 1;
int p = last;
last = cur;
for (; p != -1 && !st[p].next.count(ch); p = st[p].link)
st[p].next[ch] = cur;
if (p == -1) {
st[cur].link = 0;
return;
}
int q = st[p].next[ch];
if (st[p].len + 1 == st[q].len) {
st[cur].link = q;
return;
}
int clone = sz++;
st[clone].len = st[p].len + 1;
st[clone].next = st[q].next;
st[clone].link = st[q].link;
st[q].link = st[cur].link = clone;
for (; p != -1 && st[p].next.count(ch) && st[p].next[ch] == q;
p = st[p].link)
st[p].next[ch] = clone;
}
void calc() {
vector<pair<int, int> > v;
for (int i = 0; i < sz; ++i) v.push_back(pair<int, int>{st[i].len, i});
sort((v.begin()), (v.end()));
reverse((v.begin()), (v.end()));
for (pair<int, int> p : v) st[st[p.second].link].cnt += st[p.second].cnt;
}
int prefix_function(string s) {
int n = s.length();
vector<int> p(n, 0);
for (int i = 1; i < n; ++i) {
int j = p[i - 1];
while (j && s[i] != s[j]) j = p[j - 1];
if (s[i] == s[j]) p[i] = j + 1;
if (p[i] == n / 2) return i;
}
}
int solve(string& s) {
int n = s.length();
int yet = prefix_function(s + s) - n;
int len = 0;
int ans = 0;
int cur = 0;
for (int i = 0; i < n; ++i) {
while (cur != -1 && st[cur].next.count(s[i]) == 0) {
cur = st[cur].link;
len = cur == -1 ? 0 : st[cur].len;
}
if (cur == -1) {
cur = 0;
len = 0;
} else {
++len;
cur = st[cur].next[s[i]];
}
}
if (len == n) ans += st[cur].cnt;
for (int i = 0; i < yet; ++i) {
if (len == n) {
--len;
if (len <= st[st[cur].link].len) cur = st[cur].link;
}
while (cur != -1 && st[cur].next.count(s[i]) == 0) {
cur = st[cur].link;
len = cur == -1 ? 0 : st[cur].len;
}
if (cur == -1) {
cur = 0;
len = 0;
} else {
++len;
cur = st[cur].next[s[i]];
}
if (len == n) {
ans += st[cur].cnt;
}
}
return ans;
}
};
string s;
SufAutomaton sa;
void task() {
cin >> s;
for (int i = 0; i < s.length(); ++i) sa.push(s[i]);
sa.calc();
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s;
cout << sa.solve(s) << "\n";
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
map<long long, long long> colors[N];
map<pair<long long, long long>, long long> done;
long long par[N];
inline long long get(long long x) {
return ((par[x] == x) ? (x) : (par[x] = get(par[x])));
}
inline void unite(long long v, long long u) {
long long parv = get(v);
long long paru = get(u);
par[paru] = parv;
return;
}
inline bool same(long long v, long long u) {
long long parv = get(v);
long long paru = get(u);
return (parv == paru);
}
int main() {
long long n, m, v, u, i, c, q, ans, a, b;
scanf("%lld%lld", &n, &m);
for (i = 1; i < N; i++) par[i] = i;
for (i = 1; i <= m; i++) {
scanf("%lld%lld%lld", &v, &u, &c);
a = b = -1;
if (colors[v].count(c)) a = colors[v][c];
if (colors[u].count(c)) b = colors[u][c];
if (a != -1) unite(a, i);
if (b != -1) unite(b, i);
colors[v][c] = i;
colors[u][c] = i;
}
scanf("%lld", &q);
while (q--) {
scanf("%lld%lld", &v, &u);
if (done.count(make_pair(v, u)))
printf("%lld\n", done[make_pair(v, u)]);
else {
ans = 0;
if (colors[v].size() > colors[u].size()) swap(v, u);
for (map<long long, long long>::iterator vit = colors[v].begin();
vit != colors[v].end(); vit++) {
map<long long, long long>::iterator uit = colors[u].find(vit->first);
if (uit != colors[v].end()) ans += (same(vit->second, uit->second));
}
done[make_pair(v, u)] = done[make_pair(u, v)] = ans;
printf("%lld\n", ans);
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, b, n, t;
cin >> k >> b >> n >> t;
long long z = 1, ans = 0;
while (z <= t) z = k * z + b, ++ans;
cout << max(n - ans + 1, 0LL) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int hm, gs, zh;
} a[101];
bool cmp(node aa, node bb) {
if (aa.gs > bb.gs) return 1;
if (aa.gs == bb.gs && aa.zh < bb.zh) return 1;
return 0;
}
int main() {
int n, k, m, aa;
scanf("%d %d %d %d", &n, &k, &m, &aa);
for (int i = 1; i <= n; i++) {
a[i].hm = i;
a[i].gs = 0;
a[i].zh = 0;
}
int data;
for (int i = 1; i <= aa; i++) {
scanf("%d", &data);
a[data].gs++;
a[data].zh = i;
}
sort(a + 1, a + n + 1, cmp);
int ans[101];
int g = 0;
for (g = 1; g <= n; g++) {
if (a[g].gs == 0) break;
}
g--;
for (int i = 1; i <= n; i++) {
int j;
for (j = 1; j <= g; j++) {
if (a[j].hm == i) break;
}
if (j <= k && a[j].gs != 0) {
int s = m - aa;
int kk;
for (kk = j + 1; kk <= n; kk++) {
s = s - (a[j].gs - a[kk].gs + 1);
if (s < 0) break;
}
kk--;
if (kk <= k) {
ans[i] = 1;
continue;
}
}
if (j <= k && (a[j].gs != 0 || (m - aa) != 0)) {
ans[i] = 2;
continue;
}
if (a[j].gs == 0 && (m - aa) == 0) {
ans[i] = 3;
continue;
}
int t = a[j].gs + m - aa;
int kk = j;
for (kk = j; kk >= k; kk--) {
if (t <= a[kk].gs) break;
}
kk++;
if (kk <= k)
ans[i] = 2;
else
ans[i] = 3;
}
printf("%d", ans[1]);
for (int i = 2; i <= n; i++) {
printf(" %d", ans[i]);
}
printf("\n");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using ui = unsigned int;
const ll amn = 2e5 + 5, mod = 1e9 + 7, an = 5e3 + 5;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll n, m;
ll a[amn], b[amn];
map<ll, ll> mp;
int main() {
ll T = 1, cas = 1;
while (T--) {
cin >> n;
for (ll i = 1; i <= n; i++) cin >> a[i], b[i] = a[i] - i;
mp.clear();
for (ll i = 1; i <= n; i++) mp[b[i]] += a[i];
ll ans = 0;
for (auto i = mp.begin(); i != mp.end(); i++) {
ans = max(ans, i->second);
}
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[(100002)];
long long dp[(100002)][2];
long long sol(int i, bool t) {
if (i == ((100002) - 1)) return 0;
long long &tt = dp[i][t];
if (tt != -1) return tt;
long long c1, c2 = 0;
c1 = sol(i + 1, 0);
if (t == 0) c2 = a[i] + sol(i + 1, 1);
return tt = max(c1, c2);
}
int main() {
memset(a, 0, sizeof(a));
memset(dp, -1, sizeof(dp));
cin >> n;
int num;
for (int i = 0; i < n; i++) {
cin >> num;
a[num]++;
}
for (int i = 1; i < (100002); i++) a[i] *= i;
cout << sol(1, 0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char grid[105][105];
int main() {
bool x;
string t;
cin >> n >> m;
for (int i = 0; i < n; i++) {
if (i % 2 != 0) {
x = false;
} else {
x = true;
}
cin >> t;
for (int j = 0; j < m; j++) {
if (t[j] == '.' && x == true) {
grid[i][j] = 'B';
x = false;
} else if (t[j] == '.' && x == false) {
grid[i][j] = 'W';
x = true;
} else {
grid[i][j] = '-';
if (x == true) {
x = false;
} else {
x = true;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << grid[i][j];
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int min(long long int a, long long int b) { return (a >= b) ? b : a; }
long long int max(long long int a, long long int b) { return (a <= b) ? b : a; }
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int tc;
cin >> tc;
while (tc--) {
long long int x, y, a, b;
cin >> x >> y >> a >> b;
long long int ans1 = x * (y - (b + 1));
long long int ans2 = x * (b);
long long int ans3 = y * (x - (a + 1));
long long int ans4 = y * (a);
long long int ans = max(ans1, max(ans2, max(ans3, ans4)));
cout << ans << endl;
}
return 0;
}
| 0 |
#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;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
struct edge {
int u, v, w, num;
} e[N], c[N];
map<long long, int> mp;
int n, m, q, s, sz[N], fa[N];
long long L[N], R[N];
bool vis[N];
int find(int x) { return fa[x] ? fa[x] = find(fa[x]) : x; }
bool comp(edge x, edge y) { return x.w < y.w; }
int main() {
int i, j, k, x, num;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &c[i].u, &c[i].v, &c[i].w);
c[i].num = i;
}
sort(c + 1, c + 1 + m, comp);
for (i = 1; i <= m; i++) sz[c[i].num] = i;
for (i = 1; i <= m; i = j + 1) {
for (j = i; j < m && c[j + 1].w == c[i].w; j++)
;
for (k = i; k <= j; k++)
L[c[k].num] = 1LL * c[k].w * m + find(c[k].u),
R[c[k].num] = 1LL * c[k].w * m + find(c[k].v);
for (k = i; k <= j; k++)
if (find(c[k].u) != find(c[k].v)) fa[find(c[k].u)] = find(c[k].v);
}
memset(fa, 0, sizeof(fa));
scanf("%d", &q);
for (i = 1; i <= q; i++) {
scanf("%d", &s);
mp.clear();
bool flag = true;
num = 0;
for (j = 1; j <= s; j++) {
scanf("%d", &x);
if (!mp[L[x]]) fa[mp[L[x]] = ++num] = 0;
if (!mp[R[x]]) fa[mp[R[x]] = ++num] = 0;
if (find(mp[L[x]]) == find(mp[R[x]]))
flag = false;
else
fa[find(mp[L[x]])] = find(mp[R[x]]);
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 15 |
// HJB
// PME
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define FOR(i, a, b) for(int i = a; i <= b; i++)
#define FOD(i, a, b) for(int i = a; i >= b; i--)
#define II pair <int, int>
#define fi first
#define se second
const int N = 505;
const int MOD = 998244353;
void add(int &a, int b) {
a = (a + b) % MOD;
}
int n, a[N], f[N][N];
void in() {
cin >> n;
FOR(i, 1, n) {
char c; cin >> c;
if(c == '-') a[i] = 0;
else cin >> a[i];
}
}
void process() {
int res = 0;
FOR(step, 1, n) {
if(a[step] == 0) continue;
int X = a[step];
memset(f, 0, sizeof(f));
f[0][0] = 1;
FOR(i, 1, n) FOR(j, 0, i) {
if(a[i] == 0) {
if(j > 0 || (i <= step)) {
add(f[i][max(0ll, j - 1)], f[i - 1][j]);
}
}
else {
if(a[i] < X || (a[i] == X && i < step)) add(f[i][j], f[i - 1][j - 1]);
else add(f[i][j], f[i - 1][j]);
}
if(i != step) add(f[i][j], f[i - 1][j]);
}
FOR(i, 0, n) add(res, X * f[n][i]);
}
cout << res << '\n';
}
#undef int
int main() {
if(fopen("trash.inp", "r"))
freopen("trash.inp", "r", stdin), freopen("trash.out", "w", stdout);
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
in();
process();
}
| 14 |
#include <bits/stdc++.h>
int main() {
unsigned long long n;
scanf("%I64u", &n);
printf("%I64u\n", n / 2520);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q, ans, i, j;
string str;
while (scanf("%d%d%d\n", &n, &p, &q) != EOF) {
int a = -1, b = -1;
cin >> str;
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
ans = i * p + j * q;
if (ans == n) {
a = i;
b = j;
break;
}
}
}
if (a == -1 || b == -1)
cout << "-1" << endl;
else {
int temp1, temp2, temp3, k;
temp1 = a * p;
temp2 = b * q;
temp3 = a + b;
cout << temp3 << endl;
int count = 0;
for (i = 0; i < temp1; i++) {
cout << str[i];
count++;
if (count == p) cout << endl, count = 0;
}
count = 0;
for (i = temp1; i < temp1 + temp2; i++) {
cout << str[i];
;
count++;
if (count == q) cout << endl, count = 0;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
vector<pair<long long, int> > seats;
priority_queue<pair<long long, int> > extro;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long w;
cin >> w;
seats.push_back(make_pair(w, i));
}
sort(seats.begin(), seats.end());
string passengers;
cin >> passengers;
int index = 0;
for (int i = 0; i < 2 * n; i++) {
if (passengers[i] == '0') {
cout << seats[index].second + 1 << " ";
extro.push(seats[index]);
index++;
} else {
pair<long long, int> top = extro.top();
extro.pop();
cout << top.second + 1 << " ";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 20;
vector<int> adj[maxn], ver[maxn];
vector<pair<int, int> > mh[maxn];
int a[maxn], b[maxn];
int LazyAdd[maxn * 4], mn[maxn * 4];
void handle(int v) {
sort(mh[v].begin(), mh[v].end());
while ((int)mh[v].size() > 2) mh[v].pop_back();
}
void dfs(int v, int p = -1) {
mh[v].push_back({a[v], v});
handle(v);
if ((int)mh[v].size() == 1 || mh[v][0].first != mh[v][1].first)
ver[mh[v][0].second].push_back(v);
for (auto u : adj[v])
if (u != p) {
mh[u] = mh[v];
dfs(u, v);
}
}
vector<int> cmp;
inline int Id(int x) {
return upper_bound(cmp.begin(), cmp.end(), x) - cmp.begin() - 1;
}
void add(int r, int val, int s, int e, int v) {
if (e <= r + 1) {
LazyAdd[v] += val;
mn[v] += val;
return;
}
if (r + 1 <= s) return;
int m = (s + e) / 2;
add(r, val, s, m, 2 * v);
add(r, val, m, e, 2 * v + 1);
mn[v] = min(mn[2 * v], mn[2 * v + 1]) + LazyAdd[v];
}
bool check(int v, int x) {
for (auto u : ver[v]) {
add(Id(mh[u][0].first), -1, 0, cmp.size(), 1);
add(Id(min(mh[u][1].first, x)), 1, 0, cmp.size(), 1);
}
bool f = (mn[1] >= 0);
for (auto u : ver[v]) {
add(Id(mh[u][0].first), 1, 0, cmp.size(), 1);
add(Id(min(mh[u][1].first, x)), -1, 0, cmp.size(), 1);
}
return f;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) scanf("%d", &b[i]), cmp.push_back(b[i]);
dfs(0);
mh[0].push_back({2e9, -1});
sort(cmp.begin(), cmp.end());
cmp.resize(unique(cmp.begin(), cmp.end()) - cmp.begin());
for (int i = 0; i < k; i++) add(Id(b[i]), -1, 0, cmp.size(), 1);
for (int i = 0; i < n; i++) add(Id(mh[i][0].first), 1, 0, cmp.size(), 1);
if (mn[1] >= 0) return cout << 0 << endl, 0;
int res = 2e9;
for (int v = 0; v < n; v++) {
int l = a[v], r = 1e9 + 10;
if (!check(v, r)) continue;
while (r - l > 1) {
int m = (l + r) / 2;
if (check(v, m))
r = m;
else
l = m;
}
res = min(res, r - a[v]);
}
if (res >= 1e9) res = -1;
cout << res << endl;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, u, v, y, w[200020], d[200020], f[200020][18], s[200020], L[200020],
R[200020], ss;
vector<int> a[200020];
int lca(int x, int y) {
if (d[x] > d[y]) swap(x, y);
for (int k = d[y] - d[x], i = 18; i--;)
if (k >> i & 1) y = f[y][i];
if (x == y) return x;
for (int i = 18; i--;)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
void dfs(int x) {
s[L[x] = ss++] = x;
for (int i : a[x]) {
d[i] = d[x] + 1;
dfs(i);
}
R[x] = ss;
}
struct N {
N *l, *r;
int s;
} t[5000020], *rt[100020], *tt = t;
N *bd(int l, int r) {
N *p = tt++;
int m = l + r >> 1;
if (l != r) {
p->l = bd(l, m);
p->r = bd(m + 1, r);
}
return p;
}
N *cg(N *q, int l, int r, int x, int d) {
if (x > r) return q;
N *p = tt++;
*p = *q;
p->s = q->s + d;
if (l != r) {
int m = (l + r) >> 1;
if (x <= m)
p->l = cg(q->l, l, m, x, d);
else
p->r = cg(q->r, m + 1, r, x, d);
}
return p;
}
int A(N *l, N *r, int x) {
int tl = 1, tr = n, re = 0;
x = L[x];
while (tl != tr) {
int m = (tl + tr) >> 1;
if (x <= m)
l = l->l, r = r->l, tr = m;
else
re += r->l->s - l->l->s, l = l->r, r = r->r, tl = m + 1;
}
return re + r->s - l->s;
}
int qy(int u, int x, int l, int r) {
x = d[u] - A(rt[l], rt[r], u) - x + 1;
for (int k = 18; k--;)
if (x <= d[f[u][k]] - A(rt[l], rt[r], f[u][k])) u = f[u][k];
return u;
}
int Q(int x) { return w[x] <= y; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", f[i]), a[f[i][0]].push_back(i);
for (int j = 1; j < 18; j++)
for (int i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
dfs(0);
rt[0] = bd(1, n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &k);
if (k == 1) {
scanf("%d", &u), w[u] = i,
rt[i] = cg(cg(rt[i - 1], 1, n, L[u], 1), 1, n, R[u], -1);
} else {
scanf("%d%d%d%d", &u, &v, &k, &y);
rt[i] = rt[i - 1];
int p = lca(u, v), cu = d[u] - A(rt[y], rt[i], u),
cv = d[v] - A(rt[y], rt[i], v), cp = d[p] - A(rt[y], rt[i], p);
cu = cu - cp + Q(p);
cv = cv - cp;
if (k > cu + cv - Q(u) - Q(v))
puts("-1");
else if (k <= cu - Q(u))
printf("%d\n", qy(u, k + Q(u), y, i));
else
printf("%d\n", qy(v, cv + cu - k - Q(u) + 1, y, i));
}
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
int q, n;
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
if (n == 2 || (n % 2 != 0 && n <= 11 && n != 9))
printf("-1\n");
else {
int ans = 0;
if (n % 2) {
n -= 9;
ans++;
}
ans += n / 4;
printf("%d\n", ans);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, p;
struct Cons {
long long a;
long long b;
};
Cons cons[100010];
long long tot_p;
long long tot_l;
long long max_p;
bool cmp(const Cons& x, const Cons& y) {
return ((double)x.b / x.a) < ((double)y.b / y.a);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> p;
for (int i = 0; i < n; i++) {
cin >> cons[i].a >> cons[i].b;
tot_p += cons[i].a;
tot_l += cons[i].b;
max_p = max(max_p, cons[i].a);
}
if (p >= tot_p) {
cout << -1 << endl;
} else {
sort(cons, cons + n, cmp);
double t = 0;
long long curr_p = 0;
double save = 0;
for (int i = 0; i < n; i++) {
double curr_t = (double)cons[i].b / cons[i].a;
double curr_save = save + (p - curr_p) * (curr_t - t);
if (curr_save <= 0) break;
curr_p += cons[i].a;
t = curr_t;
save = curr_save;
}
cout << save / (curr_p - p) + t << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int64_t random_long(long long l = LLONG_MIN, long long r = LLONG_MAX) {
uniform_int_distribution<int64_t> generator(l, r);
return generator(rng);
}
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long inf = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
const int N = 2e6 + 1;
void solve() {
string s, t, v;
cin >> s >> t >> v;
vector<int> ve;
ve.push_back(s[0] - '0');
ve.push_back(t[0] - '0');
ve.push_back(v[0] - '0');
;
sort((ve).begin(), (ve).end());
if ((s == t && t == v) || (s[1] == t[1] && t[1] == v[1] &&
ve[1] == ve[0] + 1 && ve[2] == ve[1] + 1)) {
cout << 0 << "\n";
return;
}
if ((s == t) || (t == v) || (v == s)) {
cout << 1 << "\n";
return;
}
if (s[1] == t[1] && (abs(s[0] - t[0]) == 1 || abs(s[0] - t[0]) == 2)) {
cout << 1 << "\n";
return;
}
if (t[1] == v[1] && (abs(v[0] - t[0]) == 1 || abs(v[0] - t[0]) == 2)) {
cout << 1 << "\n";
return;
}
if (s[1] == v[1] && (abs(s[0] - v[0]) == 1 || abs(s[0] - v[0]) == 2)) {
cout << 1 << "\n";
return;
}
cout << 2 << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define ll long long
const int N = 1010;
const ll mod = 998244353;
char x[N],y[N];
int n,m;
ll dp[N][N][2],ans;
int main(){
scanf(" %s",x+1);
scanf(" %s",y+1);
n = strlen(x+1);
m = strlen(y+1);
for(int i = 0 ; i <= n ; ++i){
for(int j = 0 ; j <= m ;++j){
if(i>=1) dp[i][j][0]+=1;
if(j>=1) dp[i][j][1]+=1;
if(i-1>=0&&x[i]!=x[i-1])
dp[i][j][0]+=dp[i-1][j][0];
if(i-1>=0&&x[i]!=y[j])
dp[i][j][0]+=dp[i-1][j][1];
if(j-1>=0&&y[j]!=x[i])
dp[i][j][1]+=dp[i][j-1][0];
if(j-1>=0&&y[j]!=y[j-1])
dp[i][j][1]+=dp[i][j-1][1];
dp[i][j][0]%=mod;
dp[i][j][1]%=mod;
ans = (ans + dp[i][j][0])%mod;
ans = (ans + dp[i][j][1])%mod;
}
}
//printf("debug : %lld %lld %lld %lld\n",dp[1][0][0],dp[0][1][1],dp[1][1][0],dp[1][1][1]);
for(int i = 1 ; i <= n ; ++i){
int j = i ;
while(j+1<=n&&x[j+1]!=x[j]) ++j ;
ll len = j - i + 1;
ll val = (len)*(len+1)/2;
val%=mod;
val = (val * (m+1)) %mod ;
//printf("x:val %d\n",val);
ans = (ans - val + mod)%mod;
i = j ;
}
for(int i = 1 ; i <= m ; ++i){
int j = i ;
while(j+1<=m&&y[j+1]!=y[j]) ++j ;
ll len = j - i + 1;
ll val = (len)*(len+1)/2;
val%=mod;
val = (val * (n+1)) %mod ;
//printf("y:val %d\n",val);
ans = (ans - val + mod)%mod;
i = j ;
}
printf("%lld",ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int a, s, d[200004], f, g, h, j, k, l, i, n, m;
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> d[i];
if (d[i] == -1)
k++;
else
l++;
}
for (i = 0; i < m; i++) {
cin >> a >> s;
if ((s - a + 1) % 2 == 0 && k >= (s - a + 1) / 2 && l >= (s - a + 1) / 2)
cout << 1;
else
cout << 0;
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void minimize(X &x, const Y &y) {
if (x > y) x = y;
}
template <class X, class Y>
void maximize(X &x, const Y &y) {
if (x < y) x = y;
}
template <class T>
T Abs(const T &x) {
return (x < 0 ? -x : x);
}
const int INF = (int)1e9;
class SegmentTreeMin {
private:
vector<int> lazy;
int n;
void update(int i, int l, int r, int u, int v, int c) {
if (l > v || r < u || l > r || v < u) return;
if (u <= l && r <= v) return minimize(lazy[i], c);
int m = (l + r) >> 1;
update(2 * i, l, m, u, v, c);
update(2 * i + 1, m + 1, r, u, v, c);
}
public:
SegmentTreeMin(int n = 0) {
this->n = n;
lazy.assign(4 * n + 7, INF);
}
void update(int l, int r, int v) { update(1, 1, n, l, r, v); }
int get(int x) const {
int res = INF;
int i = 1, l = 1, r = n;
while (true) {
minimize(res, lazy[i]);
if (l == r) return res;
int m = (l + r) >> 1;
if (x > m) {
i = 2 * i + 1;
l = m + 1;
} else {
i = 2 * i;
r = m;
}
}
}
};
class SegmentTreeMax {
private:
vector<pair<int, int> > tree;
int n;
void build(int i, int l, int r) {
if (l == r) {
tree[i] = make_pair(-1, r);
return;
}
int m = (l + r) >> 1;
build(2 * i, l, m);
build(2 * i + 1, m + 1, r);
tree[i] = max(tree[2 * i], tree[2 * i + 1]);
}
void assign(int i, int l, int r, int x, int v) {
if (l == r) {
tree[i] = make_pair(v, x);
return;
}
int m = (l + r) >> 1;
if (x > m)
assign(2 * i + 1, m + 1, r, x, v);
else
assign(2 * i, l, m, x, v);
tree[i] = max(tree[2 * i], tree[2 * i + 1]);
}
pair<int, int> getMax(int i, int l, int r, int u, int v) const {
if (l > v || r < u || l > r || v < u) return make_pair(-1, 0);
if (u <= l && r <= v) return tree[i];
int m = (l + r) >> 1;
pair<int, int> L = getMax(2 * i, l, m, u, v);
pair<int, int> R = getMax(2 * i + 1, m + 1, r, u, v);
return max(L, R);
}
public:
SegmentTreeMax(int n = 0) {
this->n = n;
tree.assign(4 * n + 7, make_pair(-1, -1));
build(1, 1, n);
}
void assign(int x, int v) { assign(1, 1, n, x, v); }
pair<int, int> getMax(int l, int r) const { return getMax(1, 1, n, l, r); }
};
struct Query {
int type, l, r, pos, value;
bool good;
Query() {
type = l = r = pos = value = 0;
good = false;
}
void input(void) {
scanf("%d", &type);
if (type == 1)
scanf("%d%d%d", &l, &r, &value);
else
scanf("%d%d", &pos, &value);
}
};
void noAnswer(void) {
cout << "NO" << endl;
exit(0);
}
int n, q;
Query queries[300300];
int maxValue[300300];
int hold[300300], res[300300];
void init(void) {
scanf("%d%d", &n, &q);
for (int i = (1), _b = (q); i <= _b; i = i + 1) queries[i].input();
}
void process(void) {
SegmentTreeMax maxUpdate(n);
SegmentTreeMin queryLimit(n);
memset(maxValue, -1, sizeof maxValue);
for (int i = (1), _b = (q); i <= _b; i = i + 1) {
if (queries[i].type == 1) {
int L = queries[i].l, R = queries[i].r, V = queries[i].value;
queryLimit.update(L, R, V);
int tmp = maxUpdate.getMax(L, R).first;
if (tmp > V) noAnswer();
queries[i].good = tmp == V;
} else {
int pos = queries[i].pos;
if (maxValue[pos] < 0) maxValue[pos] = queryLimit.get(pos);
maxUpdate.assign(pos, queries[i].value);
}
}
for (int i = (1), _b = (n); i <= _b; i = i + 1)
if (maxValue[i] < 0) maxValue[i] = queryLimit.get(i);
SegmentTreeMax maxSeq(n);
for (int i = (1), _b = (n); i <= _b; i = i + 1) maxSeq.assign(i, maxValue[i]);
memset(hold, -1, sizeof hold);
for (int i = (1), _b = (q); i <= _b; i = i + 1) {
if (queries[i].type == 1) {
pair<int, int> v = maxSeq.getMax(queries[i].l, queries[i].r);
if (v.first != queries[i].value) noAnswer();
if (!queries[i].good) {
assert(hold[v.second] < 0);
hold[v.second] = i;
}
} else
maxSeq.assign(queries[i].pos, queries[i].value);
}
set<pair<int, int> > freePos;
int sumOr = 0;
for (int i = (1), _b = (n); i <= _b; i = i + 1) {
if (hold[i] > 0) {
res[i] = maxValue[i];
sumOr |= maxValue[i];
} else
freePos.insert(make_pair(maxValue[i], i));
}
for (int i = (30), _a = (0); i >= _a; i = i - 1)
if (!(((sumOr) >> (i)) & 1)) {
__typeof(freePos.begin()) it =
freePos.lower_bound(make_pair((1LL << (i)), -1));
if (it == freePos.end()) continue;
pair<int, int> tmp = *it;
res[tmp.second] |= (1LL << (i));
sumOr |= (1LL << (i));
tmp.first -= (1LL << (i));
freePos.erase(it);
freePos.insert(tmp);
}
printf("YES\n");
for (int i = (1), _b = (n); i <= _b; i = i + 1) printf("%d ", res[i]);
printf("\n");
}
int main(void) {
init();
process();
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
long long a[101000];
int n;
bool cmp(long long a, long long b) { return a < b; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, cmp);
int flag = true;
for (int i = 0; i < n - 1; i++)
if (a[i] != a[i + 1] && a[i + 1] < a[i] * 2) {
flag = false;
break;
}
if (flag == true) {
cout << "NO" << endl;
} else
cout << "YES" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int pre[2000000 + 5] = {0};
vector<int> a;
int main() {
int ans = 0, n, p;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &p);
if (s.find(p) == s.end()) a.push_back(p);
s.insert(p);
}
a.push_back(2000000 + 5 - 1);
sort((a).begin(), (a).end());
n = a.size() - 1;
for (int i = 0; i < n; i++)
for (int j = a[i] + 1; j < a[i + 1] + 1; j++) pre[j] = a[i];
for (int i = 0; i < n; i++)
for (int j = 2; a[i] * j < 2000000 + 5; j++)
ans = max(ans, pre[a[i] * j] % a[i]);
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
vector<string> v, v1;
vector<long long> v2;
string s;
long long n, m, i = -1, j = 0;
cin >> n >> m;
for (long long x = 0; x < n; x++) {
cin >> s;
v.push_back(s);
}
for (long long x = 0; x < n; x++) {
for (long long y = 0; y < m; y++) {
if (v[x][y] == '*') {
if (i == -1) i = x;
j = x;
v2.push_back(y);
}
}
}
for (long long x = i; x <= j; x++) {
v1.push_back(v[x]);
}
sort(v2.begin(), v2.end());
for (long long x = 0; x < v1.size(); x++) {
for (long long y = v2[0]; y <= v2[v2.size() - 1]; y++) {
cout << v1[x][y];
}
cout << "\n";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
namespace ywy {
int ch[2111][2], fa[2111], gpt = 1, size[2111];
unsigned char bv[2111];
int tot = 0, zx;
void afs(int pt) {
if (bv[pt] || !pt) return;
if (!ch[pt][0] && !ch[pt][1]) {
tot++;
return;
}
afs(ch[pt][0]);
afs(ch[pt][1]);
}
int minn = 1234567890;
void bfs(int pt) {
if (bv[pt] || !pt) return;
int mx = 0;
if (!ch[pt][0] && !ch[pt][1])
size[pt] = 1;
else {
size[pt] = 0;
for (register int i = 0; i <= 1; i++) {
if (bv[ch[pt][i]]) continue;
bfs(ch[pt][i]);
size[pt] += size[ch[pt][i]];
mx = max(mx, size[ch[pt][i]]);
}
if (max(mx, tot - size[pt]) < minn) zx = pt, minn = max(mx, tot - size[pt]);
}
}
void digui(int pt, int me) {
if (bv[pt] || (!ch[pt][0] && !ch[pt][1])) {
int cjr = gpt;
gpt++;
ch[fa[pt]][(pt == ch[fa[pt]][1])] = cjr;
fa[cjr] = fa[pt];
fa[me] = cjr;
fa[pt] = cjr;
ch[cjr][0] = me;
ch[cjr][1] = pt;
return;
}
tot = 0;
afs(pt);
minn = 1234567890;
bfs(pt);
int lef = zx;
while (ch[lef][0]) lef = ch[lef][0];
int rgh = zx;
while (ch[rgh][1]) rgh = ch[rgh][1];
printf("%d %d %d\n", lef, rgh, me);
fflush(stdout);
char c;
cin >> c;
bv[zx] = 1;
if (c == 'Z') {
digui(ch[zx][0], me);
return;
}
if (c == 'Y') {
digui(ch[zx][1], me);
return;
}
if (c == 'X') {
if (bv[fa[zx]] || !fa[zx]) {
int cjr = gpt;
gpt++;
fa[cjr] = fa[zx];
ch[fa[zx]][(zx == ch[fa[zx]][1])] = cjr;
ch[cjr][0] = zx;
ch[cjr][1] = me;
fa[zx] = cjr;
fa[me] = cjr;
return;
}
int cur = fa[zx];
while (!bv[fa[cur]] && fa[cur]) cur = fa[cur];
digui(cur, me);
}
}
void ywymain() {
int n;
cin >> n;
gpt = n + 2;
ch[n + 1][0] = 1;
ch[n + 1][1] = 2;
fa[1] = fa[2] = n + 1;
for (register int i = 3; i <= n; i++) {
memset(bv, 0, sizeof(bv));
int cur = 1;
while (fa[cur]) cur = fa[cur];
digui(cur, i);
}
printf("-1\n");
fflush(stdout);
for (register int i = 1; i <= n * 2 - 1; i++) {
if (!fa[i])
printf("-1 ");
else
printf("%d ", fa[i]);
}
cout << endl;
fflush(stdout);
}
} // namespace ywy
int main() {
ywy::ywymain();
return (0);
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
long long n;
priority_queue<pair<long long, pair<long long, long long>>> q;
long long x = 0, y = 0;
int main() {
cin >> n;
q.push({n, {0, 0}});
while (q.size() > 0) {
long long e = q.top().first;
long long d = q.top().second.first;
long long l = q.top().second.second;
long long a = 0, b = 100001;
while (b - a > 1) {
long long c = (a + b) / 2;
if (c * c * c <= e) {
a = c;
} else {
b = c;
}
}
q.pop();
if (e != 0) {
q.push({e - a * a * a, {d + 1, l + a * a * a}});
if (a != 1) {
long long p = a * a * a - 1;
q.push({p - (a - 1) * (a - 1) * (a - 1),
{d + 1, l + (a - 1) * (a - 1) * (a - 1)}});
}
} else {
if (d > x || (d == x && l > y)) {
x = d;
y = l;
}
}
}
cout << x << " " << y << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int element[200010], marker[200010];
int main() {
int n, t, k, a, x, maxval = 1, cut = 0;
double sum = 0;
cin >> n;
while (n--) {
cin >> t;
if (t == 1) {
cin >> a >> x;
marker[a] += x;
sum += a * x;
} else if (t == 2) {
cin >> k;
element[++maxval] = k;
sum += k;
} else if (t == 3) {
sum -= (element[maxval] + marker[maxval]);
marker[maxval - 1] += marker[maxval];
element[maxval] = 0;
marker[maxval--] = 0;
}
printf("%.15lf\n", sum / (double)maxval);
cut = 0;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, l, r, Ql, Qr;
cin >> n >> l >> r >> Ql >> Qr;
vector<int> W(n);
for (int &w : W) cin >> w;
int leftsum = 0, rightsum = 0;
for (int w : W) rightsum += w;
int ans = INT_MAX;
for (int L = 0, R = n; L <= n; ++L, --R) {
int opt = l * leftsum + r * rightsum;
if (L > R)
opt += Ql * (L - R - 1);
else if (L < R)
opt += Qr * (R - L - 1);
ans = min(opt, ans);
if (L != n) {
leftsum += W[L];
rightsum -= W[L];
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int MOD = 1000000007;
using namespace std;
string second[10];
int m[9][8];
int main() {
for (int i = 0; i < 8; i++) getline(cin, second[i]);
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
if (second[i][j] == 'S') m[i][j] = -1;
int k = 1;
m[7][0] = k;
for (int k = 1; k < 42; k++) {
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
if (m[i][j] == k) {
if (i + 1 < 8 && m[i + 1][j] == 0) m[i + 1][j] = k + 1;
if (j + 1 < 8 && i - 1 && m[i - 1][j + 1] == 0)
m[i - 1][j + 1] = k + 1;
if (j - 1 >= 0 && i - 1 && m[i - 1][j - 1] == 0)
m[i - 1][j - 1] = k + 1;
if (j + 1 < 8 && i + 1 && m[i + 1][j + 1] == 0)
m[i + 1][j + 1] = k + 1;
if (j - 1 >= 0 && i + 1 && m[i + 1][j - 1] == 0)
m[i + 1][j - 1] = k + 1;
if (i - 1 >= 0 && m[i - 1][j] == 0) m[i - 1][j] = k + 1;
if (j + 1 < 8 && m[i][j + 1] == 0) m[i][j + 1] = k + 1;
if (j - 1 >= 0 && m[i][j - 1] == 0) m[i][j - 1] = k + 1;
}
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
if (m[i][j] == k) m[i][j] = k + 1;
for (int i = 8; i > 0; i--)
for (int j = 0; j < 8; j++)
if (m[i - 1][j] == -1) {
m[i - 1][j] = 0;
m[i][j] = -1;
}
}
if (m[0][0] > 0)
cout << "WIN\n";
else
cout << "LOSE\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long ful = 0;
vector<pair<int, int> > v;
long long ans = 111111111111;
int l[111111];
int c[111111];
int n;
int d[111111];
int max(int x, int y) {
if (x < y) return y;
return x;
}
int min(int x, int y) {
if (x > y) return y;
return x;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) c[i] = 0;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) {
cin >> d[i];
ful += d[i];
}
for (int i = 0; i < n; i++) v.push_back(make_pair(l[i], d[i]));
sort(v.begin(), v.end());
int l = 0;
int r = 0;
v.push_back(make_pair(111111, 0));
while (true) {
if (r == n) break;
while (v[r].first == v[l].first) r++;
long long cur = 0;
long long cnt = r - l - 1;
long long now = 0;
for (int i = l; i < r; i++) {
now += v[i].second;
}
for (int cc = 222; cc >= 0; cc--) {
cur += min(c[cc], cnt) * cc;
cnt = max(0, cnt - c[cc]);
if (cnt == 0) break;
}
ans = min(ans, ful - cur - now);
for (int i = l; i < r; i++) c[v[i].second]++;
l = r;
}
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int N = 105;
const int mod = 998244353;
char s[N];
int d[N], n;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
map<pair<int, int>, long long> dp[2][2][11][11];
int tot1[15], tot2[15];
template <typename T>
void add(T &a, T b) {
a += b;
if (a >= mod) a -= mod;
}
long long solve(int x, int y) {
memset(dp, 0, sizeof(dp));
memset(tot1, 0, sizeof(tot1));
memset(tot2, 0, sizeof(tot2));
for (int i = 1; i * y < 10; i++) {
tot1[i * x] = 1 << (i - 1);
tot2[i * y] = 1 << (i - 1);
}
int c = 0, b = 1;
for (int depth = 0; depth < 2; depth++) {
for (int l = 0; l < 10; l++) {
for (int r = 0; r < 10; r++) {
dp[c][depth][l][r].clear();
}
}
}
dp[c][0][0][0][{0, 0}] = 1;
for (int i = 0; i < n; i++) {
swap(b, c);
for (int depth = 0; depth < 2; depth++) {
for (int l = 0; l < 10; l++) {
for (int r = 0; r < 10; r++) {
dp[c][depth][l][r].clear();
}
}
}
for (int depth = 0; depth < 2; depth++) {
for (int l = 0; l < 10; l++) {
for (int r = 0; r < 10; r++) {
for (auto u : dp[b][depth][l][r]) {
long long now = u.second;
if (now == 0) continue;
pair<int, int> fi = u.first;
int fa = fi.first, fb = fi.second;
for (int k = 0; k < 10; k++) {
int l0 = l + x * k, r0 = r + y * k;
int dl = l0 % 10, dr = r0 % 10;
l0 /= 10, r0 /= 10;
int more;
if (dr > d[i])
more = 1;
else if (dr == d[i])
more = depth;
else
more = 0;
add(dp[c][more][l0][r0][{fa | tot1[dl], fb | tot2[dr]}], now);
}
}
}
}
}
}
long long ans = 0LL;
for (auto u : dp[c][0][0][0]) {
pair<int, int> f = u.first;
if (f.first & f.second) add(ans, u.second);
}
return ans;
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) d[n - 1 - i] = s[i] - '0';
d[n] = 0;
long long ans = 0LL;
for (int x = 1; x <= 9; x++) {
for (int y = x + 1; y <= 9; y++) {
if (gcd(x, y) != 1) continue;
ans = (ans + 2 * solve(x, y)) % mod;
}
}
ans = (ans + solve(1, 1)) % mod;
printf("%lld\n", ans);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const double eps = 1e-9, Pi = 2 * acos(0.0);
int main() {
string s;
cin >> s;
vector<string> t;
string cur = "";
for (int i = 0; i < s.length(); i++)
if (s[i] == '.')
t.push_back(cur), cur = "";
else
cur += s[i];
t.push_back(cur);
bool ok = true;
int n = t.size();
if (t.size() < 2)
ok = false;
else if (t[0].length() < 1 || t[0].length() > 8)
ok = false;
else if (t[n - 1].length() < 1 || t[n - 1].length() > 3)
ok = false;
else {
for (int i = 1; i < n - 1; i++)
if (t[i].length() < 2 || t[i].length() > 11) ok = false;
}
if (!ok)
cout << "NO\n";
else {
cout << "YES\n";
cout << t[0];
for (int i = 1; i < n - 1; i++) {
cout << ".";
if (t[i].length() < 10) {
cout << t[i][0];
cout << "\n";
for (int j = 1; j < t[i].size(); j++) cout << t[i][j];
} else {
cout << t[i][0] << t[i][1] << t[i][2];
cout << "\n";
for (int j = 3; j < t[i].size(); j++) cout << t[i][j];
}
}
cout << "." << t[n - 1] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, c, ans;
int jc[710000];
int qpow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)ret * x % 1000003;
x = (long long)x * x % 1000003;
y >>= 1;
}
return ret;
}
int main() {
scanf("%d%d", &n, &c);
jc[0] = 1;
for (int i = 1; i <= n + c - 1; i++)
jc[i] = (long long)jc[i - 1] * i % 1000003;
for (int i = 1; i <= n; i++)
ans = (ans + (long long)jc[i + c - 1] * qpow(jc[c - 1], 1000003 - 2) %
1000003 * qpow(jc[i], 1000003 - 2) % 1000003) %
1000003;
printf("%d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 2, ctr = 0;
string s, str;
cin >> n;
cin >> s;
while (c <= n) {
for (int i = 0; (i + c <= n) && i < (n - 1); i++) {
str = s.substr(i, c);
if (count(str.begin(), str.end(), 'R') ==
count(str.begin(), str.end(), 'L') &&
count(str.begin(), str.end(), 'U') ==
count(str.begin(), str.end(), 'D')) {
ctr++;
}
}
c += 2;
}
cout << ctr;
}
| 2 |
#include <bits/stdc++.h>
int read() {
register int x = 0;
register char f = 1, ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f ^= 1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ '0');
return f ? x : -x;
}
int n, m;
char a[2005][2005], b[2005][2005], c[2005], tmp[2005];
int edge, to[16000005], pr[16000005], hd[8005];
void addedge(int u, int v) { to[++edge] = v, pr[edge] = hd[u], hd[u] = edge; }
int idx, dfn[8005], low[8005], top, sta[8005], vis[8005], cnt, col[8005];
void tarjan(int u) {
dfn[u] = low[u] = ++idx, sta[++top] = u, vis[u] = 1;
for (register int i = hd[u], v; i; i = pr[i])
if (!dfn[v = to[i]])
tarjan(v), low[u] = std ::min(low[u], low[v]);
else if (vis[v])
low[u] = std ::min(low[u], dfn[v]);
if (dfn[u] == low[u]) {
++cnt, sta[top + 1] = -1;
while (sta[top + 1] != u) col[sta[top]] = cnt, vis[sta[top--]] = 0;
}
}
std ::vector<int> ans;
int main() {
n = read();
for (register int i = 0; i < n; ++i) scanf("%s", a[i]);
for (register int i = 0; i < n; ++i) scanf("%s", b[i]);
scanf("%s", c);
for (register int i = 0; i < n; ++i)
for (register int j = 0; j < n; ++j) {
if (c[j] ^ a[i][j] ^ b[i][j] ^ '0')
if (c[i] == '1')
addedge(i << 1 | 1, (n << 1) + (j << 1 | 1));
else
addedge(i << 1 | 1, i << 1);
else if (c[i] == '1')
addedge(i << 1 | 1, (n << 1) + (j << 1));
if (a[i][j] ^ b[i][j])
if (c[i] == '1')
addedge(i << 1, (n << 1) + (j << 1 | 1));
else
addedge(i << 1, i << 1 | 1);
else if (c[i] == '1')
addedge(i << 1, (n << 1) + (j << 1));
}
for (register int j = 0; j < n; ++j)
for (register int i = 0; i < n; ++i) {
if (c[i] ^ a[i][j] ^ b[i][j] ^ '0')
if (c[j] == '1')
addedge((n << 1) + (j << 1 | 1), i << 1 | 1);
else
addedge((n << 1) + (j << 1 | 1), (n << 1) + (j << 1));
else if (c[j] == '1')
addedge((n << 1) + (j << 1 | 1), i << 1);
if (a[i][j] ^ b[i][j])
if (c[j] == '1')
addedge((n << 1) + (j << 1), i << 1 | 1);
else
addedge((n << 1) + (j << 1), (n << 1) + (j << 1 | 1));
else if (c[j] == '1')
addedge((n << 1) + (j << 1), i << 1);
}
for (register int i = 0; i < (n << 2); ++i)
if (!dfn[i]) tarjan(i);
for (register int i = 0; i < (n << 1); ++i)
if (col[i << 1] == col[i << 1 | 1])
return puts("-1"), 0;
else if (col[i << 1 | 1] < col[i << 1])
ans.push_back(i);
printf("%d\n", ans.size());
for (int v : ans)
if (v < n)
printf("row %d\n", v);
else
printf("col %d\n", v - n);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> prime(1000000, 1);
long long M = 1e9 + 7;
long long powmodM(long long a, long long b, long long c = M) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % M;
a = (a * a) % M;
b /= 2;
}
return res;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a);
a = (a * a);
b /= 2;
}
return res;
}
long long gcd(long long a, long long b) {
while (a && b) a > b ? a %= b : b %= a;
return a + b;
}
long long lcm(long long a, long long b) {
return (max(a, b) / gcd(a, b)) * min(a, b);
}
vector<long long> sieve(int n) {
vector<long long> ans;
prime[0] = false;
prime[1] = false;
for (int p = 2; p * p <= n; p++)
if (prime[p])
for (int i = p * p; i <= n; i += p) prime[i] = 0;
for (long long p = (2); p <= (n); ++p)
if (prime[p]) ans.push_back(p);
return ans;
}
long long modInverse(long long n, long long p = M) {
return powmodM(n, p - 2, p);
}
long long nCrModP(long long n, long long r, long long p = M) {
if (r == 0) return 1;
long long fac[n + 1];
fac[0] = 1;
for (long long 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;
}
double pie = 3.14159265358979323846264338;
const int INF = 0x3f3f3f3f;
class l {
public:
int data;
l* next = NULL;
l* prev = NULL;
l(int d) {
data = d;
next = NULL;
prev = NULL;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k;
cin >> n >> k;
if (n <= 1) {
cout << 1;
return 0;
}
int a;
cin >> a;
map<int, pair<l*, int>> list;
l* prev = new l(a);
l* head = prev;
list[a] = {prev, 0};
int i = 1;
while (i < n) {
cin >> a;
l* curr = new l(a);
curr->prev = prev;
curr->next = NULL;
prev->next = curr;
prev = prev->next;
list[a] = {prev, i};
i++;
}
int maax = 200000;
bool first = 0;
vector<long long> res(n);
while (list.size()) {
if (list.find(maax) == list.end()) {
maax--;
continue;
}
first = !first;
l* temp = list[maax].first;
l* pre = temp;
if (first)
res[list[maax].second] = 1;
else
res[list[maax].second] = 2;
list.erase(maax);
int f = 0;
while (f < k && temp->next != NULL) {
f++;
temp = temp->next;
if (first)
res[list[temp->data].second] = 1;
else
res[list[temp->data].second] = 2;
list.erase(temp->data);
}
f = 0;
while (f < k && pre->prev != NULL) {
f++;
pre = pre->prev;
if (first)
res[list[pre->data].second] = 1;
else
res[list[pre->data].second] = 2;
list.erase(pre->data);
}
if (temp->next != NULL && pre->prev != NULL) {
pre->prev->next = temp->next;
temp->next->prev = pre->prev;
} else if (temp->next == NULL && pre->prev != NULL) {
pre->prev->next = NULL;
} else if (temp->next != NULL && pre->prev == NULL) {
temp->next->prev = NULL;
}
maax--;
}
for (long long i = (0); i <= (n - 1); ++i) {
cout << res[i];
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, s, x;
while (~scanf("%d%d%d", &t, &s, &x)) {
if (x < t) {
printf("NO\n");
continue;
}
if (x == t) {
printf("YES\n");
continue;
}
if ((x - 1 - t) != 0 && (x - 1 - t) % s == 0) {
printf("YES\n");
} else if ((x - t) != 0 && (x - t) % s == 0) {
printf("YES\n");
} else {
printf("NO\n");
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int alice[n], bob[m], i, j;
for (i = 0; i < n; i++) {
scanf("%d", &alice[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &bob[i]);
}
i = n - 1;
j = m - 1;
bool flag = false;
sort(alice, alice + n);
sort(bob, bob + m);
while (i >= 0 && j >= 0) {
if (alice[i] > bob[j]) {
flag = true;
break;
}
i--;
j--;
}
if (n > m) flag = true;
if (flag == true)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int in[1000100];
int n;
int il[1000100];
long long re[1000100];
long long pre[1001000];
void test() {
long long b;
scanf("%lld", &b);
int ans = 1000000000;
long long sum = 0;
int w2 = n - 1;
il[n] = 0;
re[n] = 0;
for (int i = n - 1; i >= 0; i--) {
sum += in[i];
while (sum > b) {
sum -= in[w2];
w2--;
}
if (w2 == n - 1) {
re[i] = sum;
il[i] = 1;
} else {
re[i] = re[w2 + 1];
il[i] = il[w2 + 1] + 1;
}
if (i == 0 || pre[i - 1] + re[i] <= b) ans = min(ans, il[i]);
}
printf("%d\n", ans);
}
int main() {
int q;
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%d", &in[i]);
pre[i] = in[i];
if (i) pre[i] += pre[i - 1];
}
for (int i = 0; i < q; i++) test();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
struct edge {
int v;
int Next;
} Edge[maxn * 10];
int tot = 0;
int head[maxn];
int ind[maxn];
int ans[maxn];
void init() {
memset(head, -1, sizeof(head));
tot = 0;
}
void addedge(int u, int v) {
Edge[tot].v = v;
Edge[tot].Next = head[u];
head[u] = tot++;
}
int n, m;
int main() {
cin >> n >> m;
init();
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
addedge(v, u);
ind[u]++;
}
priority_queue<int> q;
for (int i = 1; i <= n; i++) {
if (ind[i] == 0) q.push(i);
}
int cnt = n;
while (!q.empty()) {
int x = q.top();
q.pop();
ans[x] = cnt--;
for (int i = head[x]; i != -1; i = Edge[i].Next) {
int v = Edge[i].v;
ind[v]--;
if (ind[v] == 0) {
q.push(v);
}
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int n, i, f;
string s;
int main() {
cin >> n >> s;
for (; i < n - 1; i++) s[i] <= s[i + 1] || f ? cout << s[i], 0 : f = 1;
if (f) cout << s[i];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10, LG = 15, inf = 1e9, Sink = 1, Source = 2;
vector<pair<int, int> > v[maxn], g[maxn], cut;
vector<int> idv[maxn], ans1, ans2;
int refind[maxn];
int sp[LG][maxn], id[LG][maxn], C = 5;
int arr[maxn], h[maxn], pt[maxn];
void add_edge(int a, int b, int w) {
v[a].push_back({b, w});
v[b].push_back({a, 0});
idv[a].push_back(int((v[b]).size()) - 1);
idv[b].push_back(int((v[a]).size()) - 1);
}
void prep(int u, int par = 0, int ID = -2, int H = 1) {
h[u] = H;
sp[0][u] = par;
id[0][u] = ++C;
add_edge(C, Sink, 1);
refind[C] = ID;
for (int i = 1; i < LG; i++) {
sp[i][u] = sp[i - 1][sp[i - 1][u]];
id[i][u] = ++C;
add_edge(C, id[i - 1][u], inf);
add_edge(C, id[i - 1][sp[i - 1][u]], inf);
}
for (pair<int, int> p : g[u]) {
if (p.first != par) prep(p.first, u, p.second, H + 1);
}
}
void Add(int a, int b) {
add_edge(Source, ++C, 1);
if (h[a] < h[b]) swap(a, b);
for (int i = LG - 1; i >= 0; i--) {
if (h[sp[i][a]] >= h[b]) add_edge(C, id[i][a], inf), a = sp[i][a];
}
if (a == b) return;
for (int i = LG - 1; i >= 0; i--) {
if (sp[i][a] != sp[i][b])
add_edge(C, id[i][a], inf), add_edge(C, id[i][b], inf), a = sp[i][a],
b = sp[i][b];
}
add_edge(C, id[0][a], inf);
add_edge(C, id[0][b], inf);
}
bool bfs(int Source, int Sink) {
memset(h, 0, sizeof h);
int L = 0, R = 0;
arr[R++] = Source;
h[Source] = 1;
while (L < R) {
int u = arr[L++];
if (u == Sink) return 1;
for (pair<int, int> p : v[u]) {
if (p.second > 0 && h[p.first] == 0)
h[p.first] = h[u] + 1, arr[R++] = p.first;
}
}
return 0;
}
int dfs(int u, int Sink, int flow) {
if (u == Sink) return flow;
int ans = 0;
while (pt[u] < int((v[u]).size())) {
int &y = v[u][pt[u]].first, &w = v[u][pt[u]].second,
&w2 = v[y][idv[u][pt[u]]].second;
if (h[u] + 1 == h[y] && w > 0) {
int num = dfs(y, Sink, min(flow, w));
ans += num;
w -= num;
w2 += num;
}
if (flow == ans) break;
++pt[u];
}
return ans;
}
int flow(int Source, int Sink) {
int ans = 0;
while (bfs(Source, Sink)) {
memset(pt, 0, sizeof pt);
ans += dfs(Source, Sink, inf);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a].push_back({b, i});
g[b].push_back({a, i});
}
prep(1);
int start = C + 1;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
Add(a, b);
}
cout << flow(Source, Sink) << "\n";
for (int i = 0; i < maxn; i++) {
for (pair<int, int> p : v[i]) {
if (h[i] > 0 && h[p.first] == 0 && p.second == 0)
cut.push_back({i, p.first});
}
}
for (pair<int, int> p : cut) {
if (p.first == Source) ans1.push_back(p.second - start + 1);
if (p.second == Sink) ans2.push_back(refind[p.first] + 1);
}
cout << int((ans1).size()) << " ";
for (int x : ans1) cout << x << " ";
cout << "\n";
cout << int((ans2).size()) << " ";
for (int x : ans2) cout << x << " ";
cout << "\n";
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void Chkmax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
void Chkmin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
void read(T &x) {
int f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
long long n, p;
int Cnt(long long x) {
int s = 0;
for (; x; x -= x & -x) ++s;
return s;
}
int main() {
read(n);
read(p);
for (int i = 1, x;; ++i) {
n -= p;
if (n < 0) break;
x = Cnt(n);
if (x <= i && x && n >= i) {
printf("%d\n", i);
return 0;
}
}
puts("-1");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
register int x = 0;
register char c = getchar();
register bool f = false;
while (!isdigit(c)) {
f = (c == '-'), c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - 48, c = getchar();
}
return f ? -x : x;
}
int n, m, b, mod;
int a[510];
int dp[510][510];
int main() {
n = rd();
m = rd();
b = rd();
mod = rd();
for (int i = 1; i <= n; i++) {
a[i] = rd();
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = b; k >= a[i]; k--) {
dp[j][k] += dp[j - 1][k - a[i]];
dp[j][k] %= mod;
}
}
}
int ans = 0;
for (int i = 0; i <= b; i++) {
ans = (ans + dp[m][i]) % mod;
}
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 500010;
const int MOD = 998244353;
const int G = 3;
long long modpow(long long base, long long exp) {
base %= MOD;
long long result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % MOD;
base = (base * base) % MOD;
exp >>= 1;
}
return result;
}
long long modinv(long long a) { return modpow(a, MOD - 2); }
void dft(vector<int>& a, int DFT, int N) {
static int rev[MAX];
for (int i = 0; i < N; i++) {
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) ? (N >> 1) : 0);
if (i < rev[i]) swap(a[i], a[rev[i]]);
}
for (int m = 2, m2 = 1; m <= N; m <<= 1, m2 <<= 1) {
int wm = modpow(G, (MOD - 1) / m * DFT + (DFT == -1 ? MOD - 1 : 0));
for (int k = 0; k < N; k += m)
for (int j = 0, u, t, w = 1; j < m2; j++)
t = 1ll * w * a[k + j + m2] % MOD, u = a[k + j], w = 1ll * w * wm % MOD,
a[k + j] = (u + t) % MOD, a[k + j + m2] = (u - t + MOD) % MOD;
}
if (DFT == -1)
for (int i = 0, invN = modinv(N); i < N; i++)
a[i] = 1ll * a[i] * invN % MOD;
}
int n;
map<int, int> c;
vector<long long> alfa;
vector<int> solve(int l, int r) {
if (l == r) {
vector<int> v;
for (int i = 0; i <= alfa[l]; ++i) v.push_back(1);
return v;
}
int mid = (l + r) / 2;
vector<int> lp = solve(l, mid);
vector<int> rp = solve(mid + 1, r);
int len = lp.size() + rp.size();
int N = 1;
for (; N < len; N <<= 1)
;
while ((int)lp.size() < N) lp.push_back(0);
while ((int)rp.size() < N) rp.push_back(0);
dft(lp, 1, N);
dft(rp, 1, N);
for (int i = 0; i < N; ++i) lp[i] = (1ll * lp[i] * rp[i]) % MOD;
dft(lp, -1, N);
while (lp.back() == 0) lp.pop_back();
return lp;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
int p;
for (int i = 0; i < n; ++i) {
cin >> p;
if (c.count(p))
c[p]++;
else
c[p] = 1;
}
for (auto x : c) alfa.push_back(x.second);
vector<int> ans = solve(0, alfa.size() - 1);
cout << ans[n / 2] << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e5 + 20;
long long n, k, x, y, x2, y2;
pair<long long, long long> l[N], r[N], high[N], low[N];
bool mark[N];
long long solve(long long _k, long long p1, long long p2, long long p3,
long long p4) {
long long res = 0;
while (mark[l[p1].second] && p1 < n) p1++;
while (mark[r[p2].second] && p2 < n) p2++;
while (mark[high[p3].second] && p3 < n) p3++;
while (mark[low[p4].second] && p4 < n) p4++;
res = max(r[p2].first - l[p1].first, 2LL) *
max(high[p3].first - low[p4].first, 2LL) / 4;
if (_k != k) {
mark[l[p1].second] = 1;
res = min(res, solve(_k + 1, p1, p2, p3, p4));
mark[l[p1].second] = 0;
mark[r[p2].second] = 1;
res = min(res, solve(_k + 1, p1, p2, p3, p4));
mark[r[p2].second] = 0;
mark[high[p3].second] = 1;
res = min(res, solve(_k + 1, p1, p2, p3, p4));
mark[high[p3].second] = 0;
mark[low[p4].second] = 1;
res = min(res, solve(_k + 1, p1, p2, p3, p4));
mark[low[p4].second] = 0;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> x >> y >> x2 >> y2;
l[i].second = r[i].second = high[i].second = low[i].second = i;
l[i].first = r[i].first = (x + x2);
low[i].first = high[i].first = (y + y2);
}
sort(l, l + n);
sort(low, low + n);
sort(r, r + n, greater<pair<long long, long long> >());
sort(high, high + n, greater<pair<long long, long long> >());
return cout << solve(0, 0, 0, 0, 0), 0;
}
| 15 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T, typename TT>
inline ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T>
inline istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &is, pair<T1, T2> &t) {
is >> t.first >> t.second;
return is;
}
const long long mod = 1e9 + 7;
bool check(vector<long long> &v) {
for (int i = 1; i < v.size(); i++) {
if (v[i] - v[i - 1] != v[1] - v[0]) return 0;
}
return 1;
}
void solve() {
long long n;
cin >> n;
vector<long long> v(n);
cin >> v;
if (n == 2) {
cout << v[0] << '\n';
cout << v[1] << '\n';
return;
}
vector<vector<long long> > pos = {{0, 1}, {1, 2}, {0, 2}};
for (auto &x : pos) {
vector<long long> a, b;
for (int i = 0; i < n; i++) {
;
if (i <= x[1]) {
if (find(x.begin(), x.end(), i) == x.end())
b.push_back(v[i]);
else
a.push_back(v[i]);
continue;
}
bool f1 = (v[i] - a.back() == a[1] - a[0]);
bool f2 = (b.empty() or b.size() < 2 or v[i] - b.back() == b[1] - b[0]);
if (f1 and f2) {
if (i == n - 1)
b.push_back(v[i]);
else {
if (!b.empty() and v[i + 1] - v[i] == v[i] - b.back())
b.push_back(v[i]);
else
a.push_back(v[i]);
}
} else if (f1)
a.push_back(v[i]);
else
b.push_back(v[i]);
}
if (check(b)) {
cout << a << '\n';
cout << b << '\n';
return;
}
}
cout << "No solution" << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, a, want = 1;
vector<int> ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
if (a == want) {
want++;
ans.push_back(2001 + i);
}
}
cout << want - 1 << '\n';
for (int num : ans) cout << num << ' ';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cin >> a[i][j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int f = 0;
if (a[i][j] != 1) {
f = 1;
for (int k = 0; k < n; k++) {
if (k == j) continue;
int fl = 0;
for (int l = 0; l < n; l++) {
int sum = a[i][k];
if (l == i) continue;
sum += a[l][j];
if (sum == a[i][j]) {
fl = 1;
f = 2;
break;
}
}
if (fl) {
fl = 0;
break;
}
}
}
if (f == 1) {
cout << "No\n";
return 0;
}
}
}
cout << "Yes\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[int(3e5 + 10)], team[int(3e5 + 10)][3];
bool b[int(3e5 + 10)];
int main() {
int n;
scanf("%d ", &n);
for (int i = 0; i < 3 * n; i++) {
int num;
scanf("%d ", &num);
a[num] = i;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++) scanf("%d ", &team[i][j]);
int k;
scanf("%d ", &k);
int i, j;
bool cont = true;
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++) {
if (team[i][j] == k) cont = false;
if (!cont) break;
}
if (!cont) break;
}
int k1, k2;
if (j == 0) k1 = 1, k2 = 2;
if (j == 1) k1 = 2, k2 = 0;
if (j == 2) k1 = 0, k2 = 1;
int p = team[i][j], p1 = team[i][k1], p2 = team[i][k2];
if (a[p] > a[p1] || a[p] > a[p2]) {
for (int i = 1; i <= 3 * n; i++)
if (i != k) printf("%d ", i);
return 0;
}
for (int j = 0; j <= i; j++)
for (int st = 0; st < 3; st++) b[team[j][st]] = true;
for (int j = 1; j <= max(p1, p2); j++)
if (b[j] && j != k) printf("%d ", j);
for (int j = max(p1, p2) + 1; j <= 3 * n; j++) b[j] = false;
for (int j = 1; j <= 3 * n; j++)
if (!b[j] && j != k) printf("%d ", j);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> tree[524288 * 2];
pair<int, int> lazy[524288 * 2];
pair<int, int> min(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first) return a;
if ((a.first == b.first) && (a.second < b.second)) return a;
return b;
}
void lazyShiftMax(long long node, long long start, long long finish) {
long long mid = (start + finish) / 2;
tree[node] = min(tree[node], lazy[node]);
if (node < 524288) {
lazy[node * 2] = min(lazy[node * 2], lazy[node]);
lazy[node * 2 + 1] = min(lazy[node * 2 + 1], lazy[node]);
}
}
int findMax(long long from, long long to, long long node = 1,
long long start = 1, long long finish = 524288) {
lazyShiftMax(node, start, finish);
if (from > finish || to < start) return 0;
long long mid = (start + finish) / 2;
if (from <= start && to >= finish) return tree[node].second;
return max(findMax(from, to, node * 2, start, mid),
findMax(from, to, node * 2 + 1, mid + 1, finish));
}
void setValueMax(long long from, long long to, pair<int, int> value,
long long node = 1, long long start = 1,
long long finish = 524288) {
long long mid = (start + finish) / 2;
if (from <= start && to >= finish) {
lazy[node] = min(lazy[node], value);
if (from == to && value.second == 2000000000) {
lazy[node] = value;
}
}
lazyShiftMax(node, start, finish);
if ((from <= start && to >= finish) || to < start || from > finish) return;
if ((findMax(1, 2000000000, node * 2) > value.second))
setValueMax(from, to, value, node * 2, start, mid);
if ((findMax(1, 2000000000, node * 2 + 1) > value.second))
setValueMax(from, to, value, node * 2 + 1, mid + 1, finish);
tree[node].second = max(tree[2 * node].second, tree[2 * node + 1].second);
}
int main() {
ios_base::sync_with_stdio(false);
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
fill(tree, tree + 524288 * 2, make_pair(2000000000, 2000000000));
fill(lazy, lazy + 524288 * 2, make_pair(2000000000, 2000000000));
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
setValueMax(a, c - 1, make_pair(i, c));
setValueMax(c + 1, b, make_pair(i, c));
if (i == m - 1) setValueMax(c, c, make_pair(0, 0));
}
for (int i = 1; i <= n; ++i) {
cout << findMax(i, i);
if (i < n)
cout << " ";
else
cout << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const long long inf = 2147483647;
int n, m, k;
long long ans, x, y, tmp, cnt;
struct node {
long long xl, yl, xr, yr;
} a[maxn], aa, l[maxn], r[maxn];
bool jud(node aa) {
if (aa.xl > aa.xr) return 0;
if (aa.yl > aa.yr)
return 0;
else
return 1;
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++)
scanf("%lld%lld%lld%lld", &a[i].xl, &a[i].yl, &a[i].xr, &a[i].yr);
l[0].xl = l[0].yl = -inf;
l[0].xr = l[0].yr = inf;
for (int i = 1; i <= n; i++) {
l[i].xl = max(a[i].xl, l[i - 1].xl);
l[i].yl = max(a[i].yl, l[i - 1].yl);
l[i].xr = min(a[i].xr, l[i - 1].xr);
l[i].yr = min(a[i].yr, l[i - 1].yr);
}
r[n + 1].xl = r[n + 1].yl = -inf;
r[n + 1].xr = r[n + 1].yr = inf;
for (int i = n; i >= 1; i--) {
r[i].xl = max(a[i].xl, r[i + 1].xl);
r[i].yl = max(a[i].yl, r[i + 1].yl);
r[i].xr = min(a[i].xr, r[i + 1].xr);
r[i].yr = min(a[i].yr, r[i + 1].yr);
}
if (jud(l[n - 1])) {
printf("%I64d %I64d\n", l[n - 1].xl, l[n - 1].yl);
} else if (jud(r[2])) {
printf("%I64d %I64d\n", r[2].xl, r[2].yl);
} else
for (int i = 2; i <= n - 1; i++) {
aa.xl = max(l[i - 1].xl, r[i + 1].xl);
aa.yl = max(l[i - 1].yl, r[i + 1].yl);
aa.xr = min(l[i - 1].xr, r[i + 1].xr);
aa.yr = min(l[i - 1].yr, r[i + 1].yr);
if (jud(aa)) {
printf("%I64d %I64d\n", aa.xl, aa.yl);
break;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
pair<double, double> ara[n];
for (int i = 0; i < n; i++) {
scanf("%lf %lf", &ara[i].first, &ara[i].second);
}
double mini = 100000000000009.0;
for (int i = 0; i < n; i++) {
int a = (i - 1 + n) % n;
int b = (i + 1) % n;
double x1 = ara[a].first, x2 = ara[b].first, y1 = ara[a].second,
y2 = ara[b].second;
if (x1 == x2) {
mini = min(mini, fabs(ara[i].first - x1));
continue;
}
double m = (y1 - y2) / (x1 - x2);
double c = y1 - m * x1;
double dist =
fabs((ara[i].second - m * ara[i].first - c)) / (sqrt(1 + m * m));
mini = min(dist, mini);
}
printf("%.10lf\n", mini / 2);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main () {
int q;
cin >> q;
while (q--) {
long long a , b , aa , bb , x , y , ans = 0;
cin >> a >> b;
cin >> aa >> bb;
cin >> x >> y;
if ( bb == b ) {
if ( (aa > x && x > a || aa < x && x < a ) && y == b) {
ans = abs(aa-a) + 2;
}
else ans = abs(aa-a);
}
else if ( aa == a ) {
if (( bb > y && y > b || bb < y && y < b) && x == a ) {
ans = abs(bb-b) + 2;
}
else ans = abs(bb-b);
}
else ans = abs(aa-a) + abs(bb-b);
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long p, q;
cin >> p >> q;
if (p % q != 0) {
cout << p << "\n";
} else {
set<long long> ans;
long long temp2 = q;
for (int i = 2; i * i <= q; i++) {
if (temp2 % i == 0) {
while (temp2 % i == 0) {
temp2 /= i;
}
ans.insert(i);
}
}
if (temp2 != 1) {
ans.insert(temp2);
}
long long val = 1;
for (auto &it : ans) {
long long temp = p;
while (temp % q == 0) {
temp /= it;
}
val = max(val, temp);
}
cout << val << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int INF = 1000 * 1000 * 1000;
using namespace std;
int n, m;
int imp[5005];
int nxt[5005];
vector<vector<int> > g(5005);
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
}
int sz = 0;
for (int i = 0; i < n; i++) {
sort(g[i].begin(), g[i].end());
sz = max(sz, ((int)(g[i].size())));
}
for (int i = 0; i < n; i++) {
imp[i] = ((int)(g[i].size())) == sz;
if (lower_bound(g[i].begin(), g[i].end(), i) == g[i].end()) {
if (((int)(g[i].size())))
nxt[i] = g[i].front();
else
nxt[i] = -1;
} else
nxt[i] = *lower_bound(g[i].begin(), g[i].end(), i);
}
for (int i = 0; i < n; i++) {
int ans2 = 0;
for (int j = 0; j < n; j++) {
if (imp[j]) {
ans2 = max(ans2, (sz - 1) * n + (j - i + n) % n + (nxt[j] - j + n) % n);
} else if (((int)(g[j].size())) == sz - 1 && ((int)(g[j].size()))) {
ans2 = max(ans2, (sz - 2) * n + (j - i + n) % n + (nxt[j] - j + n) % n);
}
}
cout << ans2 << " ";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (n == 1) {
long long a;
cin >> a;
cout << min(a, k * m) << endl;
return 0;
}
long long lowest_odd = 1e9;
if (n % 2ll == 0) {
cout << 0 << endl;
return 0;
}
long long sum_odd = 0;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
if (i % 2 == 0) {
lowest_odd = min(lowest_odd, a);
sum_odd += a;
}
}
cout << min(lowest_odd, k * (m / (n / 2ll + 1ll))) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 505;
const int MAXM = 1010;
int n, m;
int H[MAXN], E[MAXM], X[MAXM], B[MAXM], co = 0;
inline void add(int x, int y) {
E[++co] = y, B[co] = x, X[co] = H[x], H[x] = co;
}
bool del[MAXM], v[MAXN];
int lk[MAXN];
bool find(int x) {
for (int p = H[x]; p; p = X[p])
if (!del[p] && !v[E[p]]) {
v[E[p]] = true;
if (!lk[E[p]] || find(lk[E[p]])) return lk[E[p]] = x;
}
return false;
}
int main() {
scanf("%d %d", &n, &m);
int x, y;
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &x, &y);
add(x, y);
}
int ans = 1000000000, M;
for (int i = 1; i <= n; ++i) {
memset(del, false, sizeof del);
memset(lk, false, sizeof lk);
M = 0;
for (int j = 1; j <= m; ++j)
if (B[j] == i || E[j] == i) del[j] = true, ++M;
int cur = 0;
for (int j = 1; j <= n; ++j) {
memset(v, false, sizeof v);
cur += find(j);
}
cur = (2 * n - 1 - M) + (m - M - cur) + (n - 1 - cur);
if (cur < ans) ans = cur;
}
printf("%d\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, s;
int v[200010];
int f[200010];
int nxt[200010];
int getNxt(int cpoz, int spec) {
int ans = nxt[cpoz];
if (spec <= cpoz && spec > ans) ans = spec;
return ans;
}
int solve(int val) {
int csum = s;
int prv = s + 1;
while (csum > 0) {
int cr = getNxt(min(csum, prv - 1), val);
if (cr == 0 || cr == prv) return 1;
prv = cr;
if (1LL * csum > 1LL * f[cr] * cr)
csum -= f[cr] * cr;
else
csum %= cr;
}
return 0;
}
int main() {
cin >> s;
cin >> n;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
++f[x];
}
for (int i = 1; i <= s; ++i) {
if (f[i] == 0)
nxt[i] = nxt[i - 1];
else
nxt[i] = i;
}
int sol = 0;
for (int cval = 1; cval < s; ++cval) {
++f[cval];
if (solve(cval)) {
sol = cval;
break;
}
--f[cval];
}
if (!sol)
cout << "Greed is good\n";
else
cout << sol << "\n";
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, 0, -1, 0};
long long dy[] = {0, 1, 0, -1};
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
long long expo(long long n, long long m, long long p) {
long long r = 1;
n = n % p;
while (m > 0) {
if (m % 2) r = (r * n) % p;
n = (n * n) % p;
m = m / 2;
}
return r % p;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < m; i++) {
cin >> b[i];
}
vector<long long> an;
for (long long i = 0; i < n; i++) {
vector<long long> bn;
for (long long j = 0; j < m; j++) {
for (long long k = 0; k < n; k++) {
if (k != i) {
bn.push_back(b[j] * a[k]);
}
}
}
sort(bn.begin(), bn.end());
an.push_back(bn[bn.size() - 1]);
}
sort(an.begin(), an.end());
cout << an[0] << '\n';
}
| 6 |
#include <bits/stdc++.h>
void solve(const int n, const int m, const int cl, const int ce, const int v,
const int *ll, const int *e) {
int x, y, p, q;
scanf("%d%d%d%d", &x, &y, &p, &q);
if (x == p) {
printf("%d\n", ((y - q) > (0) ? (y - q) : -(y - q)));
return;
}
if (y > q) {
int swap = y;
y = q;
q = swap;
}
int min = n + 2 * m;
if (cl > 0) {
int l = 0;
int r = cl;
while (l + 1 < r) {
int m = (l + r) / 2;
if (ll[m] >= y) {
r = m;
} else {
l = m;
}
}
min = ((min) < (((ll[l] - y) > (0) ? (ll[l] - y) : -(ll[l] - y)) +
((x - p) > (0) ? (x - p) : -(x - p)) +
((ll[l] - q) > (0) ? (ll[l] - q) : -(ll[l] - q)))
? (min)
: (((ll[l] - y) > (0) ? (ll[l] - y) : -(ll[l] - y)) +
((x - p) > (0) ? (x - p) : -(x - p)) +
((ll[l] - q) > (0) ? (ll[l] - q) : -(ll[l] - q))));
if (r < cl)
min = ((min) < (((ll[r] - y) > (0) ? (ll[r] - y) : -(ll[r] - y)) +
((x - p) > (0) ? (x - p) : -(x - p)) +
((ll[r] - q) > (0) ? (ll[r] - q) : -(ll[r] - q)))
? (min)
: (((ll[r] - y) > (0) ? (ll[r] - y) : -(ll[r] - y)) +
((x - p) > (0) ? (x - p) : -(x - p)) +
((ll[r] - q) > (0) ? (ll[r] - q) : -(ll[r] - q))));
}
if (ce > 0) {
int l = 0;
int r = ce;
while (l + 1 < r) {
int m = (l + r) / 2;
if (e[m] >= y) {
r = m;
} else {
l = m;
}
}
min = ((min) < (((e[l] - y) > (0) ? (e[l] - y) : -(e[l] - y)) +
(((x - p) > (0) ? (x - p) : -(x - p)) + v - 1) / v +
((e[l] - q) > (0) ? (e[l] - q) : -(e[l] - q)))
? (min)
: (((e[l] - y) > (0) ? (e[l] - y) : -(e[l] - y)) +
(((x - p) > (0) ? (x - p) : -(x - p)) + v - 1) / v +
((e[l] - q) > (0) ? (e[l] - q) : -(e[l] - q))));
if (r < ce)
min = ((min) < (((e[r] - y) > (0) ? (e[r] - y) : -(e[r] - y)) +
(((x - p) > (0) ? (x - p) : -(x - p)) + v - 1) / v +
((e[r] - q) > (0) ? (e[r] - q) : -(e[r] - q)))
? (min)
: (((e[r] - y) > (0) ? (e[r] - y) : -(e[r] - y)) +
(((x - p) > (0) ? (x - p) : -(x - p)) + v - 1) / v +
((e[r] - q) > (0) ? (e[r] - q) : -(e[r] - q))));
}
printf("%d\n", min);
return;
}
void run(void) {
int n, m, cl, ce, v;
scanf("%d%d%d%d%d", &n, &m, &cl, &ce, &v);
int *l = (int *)malloc(sizeof(int) * (cl + 1));
int i;
for (i = 0; i < cl; i++) scanf("%d", l + i);
int *e = (int *)malloc(sizeof(int) * (ce + 1));
for (i = 0; i < ce; i++) scanf("%d", e + i);
int q;
scanf("%d", &q);
while (q--) {
solve(n, m, cl, ce, v, l, e);
}
return;
}
int main(void) {
run();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long fact[1000007] = {0};
long long spf[(long long)(1e6)];
bool prime[(long long)((1e7) + 20)];
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void sp(long long n) {
spf[1] = 1;
for (long long i = 2; i < n; i++) spf[i] = i;
for (long long i = 4; i < n; i += 2) spf[i] = 2;
for (long long i = 3; i * i < n; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < n; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
void sieve(long long n) {
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true)
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
prime[0] = false;
prime[1] = false;
}
long long xyp(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y % 2 == 1) res = (res * x) % 1000000007;
x = (x * x) % 1000000007;
y /= 2;
}
return res % 1000000007;
}
long long inv(long long x) { return xyp(x, 1000000007 - 2); }
void init() {
fact[0] = 1;
fact[1] = 1;
for (long long i = 2; i < 100007; i++)
fact[i] = (fact[i - 1] * i) % 1000000007;
}
long long ncr(long long n, long long r) {
long long res = 1;
res = fact[n];
res = (res * (xyp(fact[r], 1000000007 - 2))) % 1000000007;
res = (res * (xyp(fact[n - r], 1000000007 - 2))) % 1000000007;
return res;
}
long long npr(long long n, long long r) {
long long res = 1;
res = fact[n];
res = (res * (xyp(fact[n - r], 1000000007 - 2))) % 1000000007;
return res;
}
bool isp(long long a) {
if (a == 2) return true;
if (a == 1) return false;
for (long long x = 2; x <= sqrt(a) + 1; x++)
if (a % x == 0) return false;
return true;
}
long long add(long long a, long long b) {
return (a % 1000000007 + b % 1000000007) % 1000000007;
}
long long sub(long long a, long long b) {
return (a % 1000000007 - b % 1000000007 + 1000000007) % 1000000007;
}
long long mul(long long a, long long b) {
return ((a % 1000000007) * (b % 1000000007)) % 1000000007;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<pair<long long, long long> > v(n);
vector<long long> xo(n, 0);
map<long long, set<long long> > adj;
set<long long> q;
for (long long i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
if (v[i].first == 1) q.insert(i);
}
vector<pair<long long, long long> > ans;
set<long long> vis;
while (q.size() != 0) {
set<long long> tmp;
for (auto z : q) {
if (v[z].first - 1 == adj[z].size()) {
vis.insert(z);
tmp.insert(z);
long long node = (xo[z] ^ v[z].second);
xo[node] = (xo[node] ^ z);
adj[node].insert(z);
adj[z].insert(node);
ans.push_back({node, z});
if (!vis.count(node)) q.insert(node);
} else if (v[z].first == adj[z].size())
tmp.insert(z);
}
for (auto z : tmp) q.erase(z);
}
cout << ans.size() << endl;
for (auto z : ans) {
cout << z.first << " " << z.second << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct deb {
template <class c>
deb &operator<<(const c &) {
return *this;
}
};
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
const long long dx[8] = {0, 1, -1, 0, 1, 1, -1, -1};
const long long dy[8] = {1, 0, 0, -1, 1, -1, -1, 1};
const long long mod = 1e9 + 7;
inline long long add(long long a, long long b) {
return ((a % mod) + (b % mod)) % mod;
}
inline long long sub(long long a, long long b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
inline long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
const double PI = acos(-1.0);
const long long inf = 1e18;
const long long maxn = 1e3 + 5;
void solve() {
string s;
cin >> s;
long long n = (long long)s.size();
vector<pair<long long, long long>> dp(n);
dp[0] = {1, 0};
for (long long i = 1; i < n; i++) {
if (s[i] == 'A') {
dp[i] = {dp[i - 1].first + 1, i};
} else {
dp[i].first = inf;
long long idx = dp[i - 1].second;
if (idx >= 0) {
if (idx > 0) {
dp[i].first = dp[idx - 1].first;
dp[i].second = dp[idx - 1].second;
} else {
dp[i] = {0, -1};
}
}
if (i - 2 >= 0) {
if (dp[i].first > dp[i - 2].first) dp[i] = dp[i - 2];
} else {
dp[i] = {0, -2};
}
}
}
cout << dp[n - 1].first << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
for (long long tt = 1; tt <= t; tt++) {
solve();
}
}
| 3 |
/**
* 𝕬𝖚𝖙𝖍𝖔𝖗: 𝕽𝖊𝖉 𝕯𝖗𝖆𝖌𝖔𝖓
**/
#include <bits/stdc++.h>
using namespace std;
#define Fast_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define int long long int
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
/* *********** My code start here *********** */
int32_t main() {
Fast_IO
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
clock_t danger_close = clock();
int t;
cin >> t;
while (t-- > 0) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int ans = 0;
int val = n - 1;
for (int i = 0; i < n; i++) {
ans += val * arr[i];
val -= 2;
}
cout << ans + arr[n - 1] << '\n';
}
debug("Total Time: %.3f\n", (double)(clock() - danger_close) / CLOCKS_PER_SEC);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, t, x, y, c, d, a[5001], res[5001], cnt[5001];
bool f;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < n; ++i) {
for (long long j = i; j < n; ++j) {
++cnt[a[j]];
if (x < cnt[a[j]]) {
x = cnt[a[j]];
y = a[j];
} else if (x == cnt[a[j]])
y = min(y, a[j]);
++res[y];
}
memset(cnt, 0, sizeof(cnt));
x = 0;
y = 0;
}
for (long long i = 1; i <= n; ++i) cout << res[i] << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int n, m;
char s[5005][5005];
int dp[5005][5005];
int h[5005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == '1') {
if (j)
dp[i][j] = dp[i][j - 1] + 1;
else
dp[i][j] = 1;
}
int ans = 0;
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) h[i] = dp[i][j];
sort(h, h + n);
int tmp = 168430090;
for (int i = n - 1; i >= 0; i--) {
tmp = min(tmp, h[i]);
ans = max(ans, tmp * (n - i));
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.