solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool check(int p, int b[], int n, int k, vector<int> s) {
for (int i = 0; i < k; i++) {
s[i] += p;
}
for (int i = 0; i < n; i++) {
auto it1 = s.begin();
it1++;
auto w = lower_bound(s.begin(), s.end(), b[i]);
if (*w != b[i]) return false;
}
return true;
}
int main() {
int k, n;
cin >> k >> n;
int a[k], b[n];
for (int i = 0; i < k; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
vector<int> s(k, 0);
s[0] = a[0];
for (int i = 1; i < k; i++) s[i] = s[i - 1] + a[i];
sort(s.begin(), s.end());
int T = 0;
set<int> p;
for (int i = 0; i < k; i++) {
p.insert(b[0] - s[i]);
}
for (int p1 : p) {
if (check(p1, b, n, k, s) == 1) T++;
}
cout << T;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 10;
char s[N], t[N];
int b[4][N];
int d[4][N];
int sum[4][N];
int k, a1, a2;
const double pi = acos(-1.0);
struct C {
double a, b;
C() {}
C(double _a) {
a = _a;
b = 0;
}
C(double _a, double _b) {
a = _a;
b = _b;
}
double &real() { return a; }
inline C operator*(const C &A) const {
return C(a * A.a - b * A.b, a * A.b + b * A.a);
}
inline C operator-(const C &A) const { return C(a - A.a, b - A.b); }
inline void operator+=(const C &A) {
a += A.a;
b += A.b;
}
inline C operator/(const double &N) const { return C(a / N, b / N); }
};
C x[N][4], y[N][4], X[N][4], Y[N][4];
void FFT(C x[][4], int n, int s, C X[][4], const int &k) {
if (n == 1) {
for (int j = 0; j < 4; j++) X[0][j] = x[0][j];
return;
}
n >>= 1;
FFT(x, n, s << 1, X, k);
FFT(x + s, n, s << 1, X + n, k);
double w = -pi * k / n;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 4; j++) {
C off = X[i + n][j] * C(cos(w * i), sin(w * i));
X[i + n][j] = X[i][j] - off;
X[i][j] += off;
}
}
}
void calcFFT() {
int N = 1 << (32 - __builtin_clz((a1 + a2) + 1));
if (N > 1e6) N = 1e6;
for (int i = 0; i < N; i++)
for (int j = 0; j < 4; j++) x[i][j] = y[i][j] = 0;
for (int i = 0; i < a1; i++)
for (int j = 0; j < 4; j++) x[i][j].real() = b[j][i];
for (int i = 0; i < a2; i++)
for (int j = 0; j < 4; j++) y[i][j].real() = d[j][i];
FFT(x, N, 1, X, 1);
FFT(y, N, 1, Y, 1);
for (int i = 0; i < N; i++)
for (int j = 0; j < 4; j++) X[i][j] = (X[i][j] * Y[i][j]) / (double)N;
FFT(X, N, 1, x, -1);
for (int i = 0; i < N; i++)
for (int j = 0; j < 4; j++) sum[j][i] = x[i][j].real() + 1e-1;
}
int calculate() {
int N = a1 + a2;
int answer = 0;
calcFFT();
for (int i = 0; i < N; i++) {
int QQ = 0;
for (int j = 0; j < 4; j++) QQ += sum[j][i];
if (QQ == a2) answer++;
}
return answer;
}
int main() {
scanf("%d%d%d", &a1, &a2, &k);
scanf("%s%s", s, t);
for (int i = 0; i < a1; i++) {
if (s[i] == 'A') b[0][i] = 1;
if (s[i] == 'G') b[1][i] = 1;
if (s[i] == 'C') b[2][i] = 1;
if (s[i] == 'T') b[3][i] = 1;
}
memset(sum, 0, sizeof(sum));
for (int j = 0; j < 4; j++) {
for (int i = 0; i < a1; i++) {
if (i != 0) sum[j][i] = sum[j][i - 1];
if (b[j][i]) sum[j][i]++;
}
for (int i = 0; i < a1; i++) {
int u = min(i + k, a1 - 1);
int l = max(i - k, 0) - 1;
int calc = sum[j][u];
if (l >= 0) calc -= sum[j][l];
if (calc > 0)
b[j][i] = 1;
else
b[j][i] = 0;
}
}
for (int i = 0; i < a2; i++) {
int j = a2 - i - 1;
if (t[i] == 'A') d[0][j] = 1;
if (t[i] == 'G') d[1][j] = 1;
if (t[i] == 'C') d[2][j] = 1;
if (t[i] == 'T') d[3][j] = 1;
}
printf("%d\n", calculate());
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int mod = 1e9 + 7;
struct mat {
int n;
vector<vector<int> > m;
mat(int nn) : n(nn) {
m = vector<vector<int> >(n + 1, vector<int>(n + 1, 0));
}
mat ident() {
mat ret(n);
for (int i = 1; i <= n; i++) ret.m[i][i] = 1;
return ret;
}
mat operator*(const mat &b) {
mat ret(n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
ret.m[i][j] = (ret.m[i][j] + (1ll * m[i][k] * b.m[k][j]) % mod) % mod;
return ret;
}
void print() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cout << m[i][j] << " \n"[j == n];
}
};
mat power(mat b, long long e) {
mat ret = b.ident();
while (e) {
if (e & 1) ret = ret * b;
e >>= 1;
b = b * b;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
int m;
cin >> n >> m;
mat b(m);
b.m[1][1] = b.m[1][m] = 1;
for (int i = 2; i <= m; i++) b.m[i][i - 1] = 1;
mat ans = power(b, n);
int sol = (ans.m[1][1]) % mod;
cout << sol << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} g[100100];
int main() {
int n;
scanf("%d", &n);
int mi = 0x3fffffff, mx;
int id;
for (int i = 0; i < n; i++) {
scanf("%d%d", &g[i].x, &g[i].y);
if (g[i].x <= mi) {
if (g[i].x == mi) {
if (g[i].y > mx) {
mx = g[i].y;
id = i + 1;
}
} else {
mi = g[i].x;
mx = g[i].y;
id = i + 1;
}
}
}
int flag = 0;
for (int i = 0; i < n; i++) {
if (g[i].y > mx) {
flag = 1;
break;
}
}
if (flag == 0)
printf("%d", id);
else
printf("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
long long n, r;
cin >> n >> r;
vector<int> v;
double rows = pow(2, n);
double sum = 0;
for (long long i = 0; i < rows; ++i) {
int k;
cin >> k;
sum += k;
v.push_back(k);
}
cout << setprecision(20) << sum / rows << '\n';
for (int i = 0; i < r; ++i) {
int pos, val;
cin >> pos >> val;
int dif = val - v[pos];
v[pos] = val;
sum += dif;
cout << setprecision(20) << sum / rows << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e5 + 5;
const int Mod = 998244353;
const int inf = 0x3f3f3f3f;
long long sum[Max], p[Max];
long long F[20];
void init() {
F[0] = 1;
for (int i = 1; i <= 15; i++) F[i] = F[i - 1] * i;
}
long long ConTor(int n, int Mid) {
long long X = 1;
for (int i = Mid + 1; i < n; i++) {
long long temp = 0;
for (int j = i + 1; j <= n; j++) {
if (p[j] > p[i]) continue;
temp++;
}
X += temp * F[n - i];
}
return X;
}
bool vis[Max];
void invConTor(int n, int Mid, long long X) {
X--;
long long rest = X;
vector<int> vec;
for (int i = Mid + 1; i <= n; i++) {
vis[i] = 0;
vec.push_back(i);
}
for (int i = Mid + 1; i <= n; i++) {
int num = rest / F[n - i];
rest = rest % F[n - i];
p[i] = vec[num];
vec.erase(vec.begin() + num);
}
}
int main(void) {
init();
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) p[i] = i;
int Mid = max(0, n - 15);
for (int i = 1; i <= Mid; i++) sum[i] = sum[i - 1] + p[i];
while (q--) {
int op;
cin >> op;
if (op == 1) {
int l, r;
cin >> l >> r;
if (r <= Mid)
cout << sum[r] - sum[l - 1] << '\n';
else if (l <= Mid) {
long long temp = sum[Mid] - sum[l - 1];
for (int i = Mid + 1; i <= r; i++) temp += p[i];
cout << temp << '\n';
} else {
long long temp = 0;
for (int i = l; i <= r; i++) temp += p[i];
cout << temp << '\n';
}
} else {
long long x;
cin >> x;
long long now = ConTor(n, Mid);
now += x;
invConTor(n, Mid, now);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 312345;
int n, k;
int c[MAXN];
int t[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> c[i];
set<pair<int, int>> q;
for (int i = 0; i < k; i++) q.insert({-c[i], i});
for (int i = 0; i < n; i++) {
if (i + k < n) {
q.insert({-c[i + k], i + k});
}
t[q.begin()->second] = i + k + 1;
q.erase(q.begin());
}
ll value = 0;
for (int i = 0; i < n; i++) {
value += ll(t[i] - i - 1) * ll(c[i]);
}
cout << value << endl;
for (int i = 0; i < n; i++) {
if (i) cout << ' ';
cout << t[i];
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans;
string str;
long long solve() {
cin >> n >> str;
long long i = 0;
while (1) {
if (str[i] != str[i + 1]) {
i += 2;
} else {
str.erase(str.begin() + i + 1);
}
if (i >= str.length()) break;
}
if (str.length() % 2) str.erase(str.end() - 1);
cout << n - str.length() << "\n" << str;
return 0;
}
signed main() {
ios::sync_with_stdio(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7fffffffffffffff;
const double eps = 1e-10;
unsigned int seed = 19260817;
const unsigned int _RAND_MAX_ = 4294967295u;
__inline__ __attribute__((always_inline)) unsigned int Rand() {
return seed = seed * 998244353u + 1000000007u;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) bool _cmp(const _Tp &a,
const _Tp &b) {
return abs(a - b) <= eps;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
register char ch(getchar());
bool f(false);
while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (ch >= 48 && ch <= 57)
x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
register char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
register char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 1000005;
bool vis[N];
int a[N];
void MAIN() {
int n;
read(n);
memset(vis, 0, n + 3);
for (int i = 1; i <= n; ++i) read(a[i]);
std::vector<int> ans, res;
int cur = 1;
while (!vis[cur]) {
ans.push_back(cur);
vis[cur] = true;
cur = cur - a[cur];
}
while (!ans.empty() && ans.back() != cur) {
res.push_back(ans.back());
ans.pop_back();
}
res.push_back(cur);
printf("%d\n", (int)res.size());
for (auto it : res) printf("%d ", it);
printf("\n");
}
int main() {
int _;
read(_);
while (_--) MAIN();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
sort(s.begin(), s.end());
int sum = s[0] - 'a' + 1;
int i = 1;
char p = s[0];
k--;
while (i < s.length() && k > 0) {
if (s[i] - p > 1) {
sum = sum + s[i] - 'a' + 1;
p = s[i];
k--;
}
i++;
}
if (k == 0)
cout << sum;
else
cout << -1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m;
int h[1000005];
char c[25][4];
int a[25], dp[1 << 22], vis[1 << 22];
bool cmp(int a, int b) { return a > b; }
int dfs(int num, int s) {
if (s >= m) return 0;
if (vis[num]) return dp[num];
int &res = dp[num] = 0;
vis[num] = 1;
while (s < m) {
if (c[s][0] == 'p') {
for (int i = 0; i < n; ++i)
if (!(num & (1 << i))) {
num |= 1 << i;
if (a[s] == 1)
res += h[i];
else
res -= h[i];
break;
}
} else {
int t = a[s] == 1 ? -inf : inf;
for (int i = 0; i < n; ++i)
if (!(num & (1 << i))) {
int x = dfs(num | (1 << i), s + 1);
if (a[s] == 1)
t = max(t, x);
else
t = min(t, x);
}
res += t;
break;
}
++s;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", h + i);
sort(h, h + n, cmp);
scanf("%d", &m);
for (int i = 0; i < m; ++i) scanf("%s%d", c[i], a + i);
n = min(n, 20);
int ans = dfs(0, 0);
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k = 0;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
if (a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1) {
k++;
a[i + 1] = 0;
}
}
printf("%d\n", k);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int siz = 3e5 + 5;
map<int, vector<int>> adjList;
long long int ans[siz] = {0};
long long int cum[siz] = {0};
map<long long int, long long int> q[siz];
void dfs(int cur, int parent, int level, long long int val) {
for (pair<long long int, long long int> temp : q[cur]) {
cum[level] += temp.second;
cum[min(level + temp.first + 1, siz - 1)] -= temp.second;
}
val += cum[level];
ans[cur] = val;
for (int child : adjList[cur]) {
if (child != parent) {
dfs(child, cur, level + 1, val);
}
}
for (pair<long long int, long long int> temp : q[cur]) {
cum[level] -= temp.second;
cum[min(level + temp.first + 1, siz - 1)] += temp.second;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n;
cin >> n;
int y;
long long int x;
for (int i = 0; i < (int)(n - 1); i++) {
cin >> x >> y;
adjList[x].push_back(y);
adjList[y].push_back(x);
}
int m;
cin >> m;
int d, v;
for (int i = 0; i < (int)(m); i++) {
cin >> v >> d >> x;
q[v][d] += x;
}
dfs(1, -1, 1, 0);
for (int i = 1; i <= (int)(n); i++) {
cout << ans[i] << " ";
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 5;
const ll mod = 1e9;
int n, q;
int initVal[N];
vector<pair<int, pair<int, int> > > queRy[N];
int nNode, rootVer[N];
struct node {
ll a, b;
int lef, rig;
} st[20 * N];
int build(int l, int r) {
if (l == r) {
int cur = ++nNode;
st[cur] = {0, initVal[l], 0, 0};
return cur;
}
int cur = ++nNode;
int mid = (l + r) >> 1;
int L = build(l, mid);
int R = build(mid + 1, r);
st[cur].lef = L;
st[cur].rig = R;
st[cur].a = st[L].a + st[R].a;
st[cur].b = st[L].b + st[R].b;
return cur;
}
int update(int old, int l, int r, int i, ll x, ll y) {
if (l == r) {
int cur = ++nNode;
st[cur].a = st[old].a + x;
st[cur].b = st[old].b + y;
st[cur].lef = st[cur].rig = 0;
return cur;
}
int cur = ++nNode;
int mid = (l + r) >> 1;
if (i <= mid) {
st[cur].lef = update(st[old].lef, l, mid, i, x, y);
st[cur].rig = st[old].rig;
} else {
st[cur].lef = st[old].lef;
st[cur].rig = update(st[old].rig, mid + 1, r, i, x, y);
}
int L = st[cur].lef, R = st[cur].rig;
st[cur].a = st[L].a + st[R].a;
st[cur].b = st[L].b + st[R].b;
return cur;
}
pair<ll, ll> get(int id, int l, int r, int i, int j) {
if (l > j || r < i || i > j) {
return {0, 0};
}
if (l >= i && r <= j) {
return {st[id].a, st[id].b};
}
int mid = (l + r) >> 1;
pair<ll, ll> tmp1 = get(st[id].lef, l, mid, i, j);
pair<ll, ll> tmp2 = get(st[id].rig, mid + 1, r, i, j);
return {tmp1.first + tmp2.first, tmp1.second + tmp2.second};
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
ll x1, x2, a, b, val1, val2;
cin >> x1 >> x2 >> val1 >> a >> b >> val2;
initVal[i] = val1;
queRy[x1 + 1].push_back({i, {a, b - val1}});
queRy[x2 + 1].push_back({i, {-a, val2 - b}});
}
rootVer[0] = build(1, n);
for (int i = 1; i <= 2e5 + 1; i++) {
rootVer[i] = rootVer[i - 1];
for (auto j : queRy[i]) {
rootVer[i] =
update(rootVer[i], 1, n, j.first, j.second.first, j.second.second);
}
}
cin >> q;
ll last = 0;
while (q--) {
ll l, r, x;
cin >> l >> r >> x;
x = (x + last) % mod;
x = min(x, (ll)(2e5 + 1));
pair<ll, ll> res = get(rootVer[x], 1, n, l, r);
last = res.first * x + res.second;
cout << last << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int n, siz[MAXN], tot;
double sum[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lf", &sum[++tot]);
siz[tot] = 1;
int t = tot;
while (t > 1 && (sum[t - 1] + sum[t]) / (siz[t - 1] + siz[t]) <=
sum[t - 1] / siz[t - 1]) {
sum[t - 1] += sum[t];
siz[t - 1] += siz[t];
t--;
tot--;
}
}
for (int i = 1; i <= tot; i++)
for (int j = 1; j <= siz[i]; j++) printf("%.9lf\n", sum[i] / siz[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int readInt() {
int x;
if (scanf(" %d", &x) != EOF) return x;
return -1;
}
long long int readLint() {
long long int x;
if (cin >> x) return x;
return -1;
}
string readString() {
string s;
if (cin >> s) return s;
return "";
}
struct SingleCase {
int m, n;
vector<vector<int> > v;
vector<vector<int> > rowRank, colRank;
vector<int> rowSize, colSize;
bool solveCase() {
m = readInt();
if (m == -1) return false;
n = readInt();
v = vector<vector<int> >(m, vector<int>(n, 0));
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j) v[i][j] = readInt();
rowRank = vector<vector<int> >(m, vector<int>(n, -1));
rowSize = vector<int>(m, -1);
for (int i = 0; i < m; ++i) {
map<int, int> M;
for (int j = 0; j < n; ++j) M[v[i][j]] = 0;
int k = 1;
for (auto& p : M) {
p.second = k++;
}
for (int j = 0; j < n; ++j) rowRank[i][j] = M[v[i][j]];
rowSize[i] = k - 1;
}
colRank = vector<vector<int> >(m, vector<int>(n, -1));
colSize = vector<int>(n, -1);
for (int j = 0; j < n; ++j) {
map<int, int> M;
for (int i = 0; i < m; ++i) M[v[i][j]] = 0;
int k = 1;
for (auto& p : M) {
p.second = k++;
}
for (int i = 0; i < m; ++i) colRank[i][j] = M[v[i][j]];
colSize[j] = k - 1;
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (j > 0) printf(" ");
int a = max(rowRank[i][j], colRank[i][j]);
int c1 = a + (rowSize[i] - rowRank[i][j]);
int c2 = a + (colSize[j] - colRank[i][j]);
int ret = max(c1, c2);
if (i == 0 && j == 0) {
}
printf("%d", ret);
}
printf("\n");
}
return true;
}
};
int main() {
while (SingleCase().solveCase()) {
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int k, a, b, count;
cin >> k >> a >> b;
if (a < 0 && b < 0)
count = (-a / k) + ((b + 1) / k);
else if (a <= 0 && b >= 0)
count = 1 + (-a / k) + (b / k);
else
count = (b / k) - ((a - 1) / k);
cout << count << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct exam {
int a, b;
} e[100005];
bool cmp(const exam a, const exam b) { return a.b < b.b; }
int main() {
int n, r;
long long sum = 0;
double avg;
scanf("%d%d%lf", &n, &r, &avg);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &e[i].a, &e[i].b);
sum += e[i].a;
}
if (sum / n >= avg)
printf("0\n");
else {
long long cnt = 0;
sort(e + 1, e + 1 + n, cmp);
long long tmpS = avg * n - sum;
int index = 1;
while (tmpS != 0 && index <= n) {
long long t = (r - e[index].a) > tmpS ? tmpS : (r - e[index].a);
tmpS -= t;
cnt += t * e[index].b;
index++;
}
printf("%I64d\n", cnt);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
_T MAX(_T p1, _T p2) {
return (p1 > p2) ? p1 : p2;
}
template <class _T>
_T MIN(_T p1, _T p2) {
return (p1 < p2) ? p1 : p2;
}
template <class _Tv>
inline string join(_Tv &v, string sep = " ") {
ostringstream s;
for (__typeof__((v).begin()) it = (v).begin(); it != (v).end(); ++it) {
if (it != v.begin()) s << sep;
s << *it;
};
return s.str();
}
int m[1010][1010], cost[1010][1010], inq[1010][1010];
unsigned int step[1010][1010];
int sx, sy, gx, gy;
const int dir[][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1},
{1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
int main() {
int h, w;
cin >> h >> w;
for (int y = (0); y < (0 + h); ++y) {
string s;
cin >> s;
for (int x = (0); x < (0 + w); ++x) {
if (s[x] == 'T') m[y][x] = -1;
if (s[x] == 'S') sx = x, sy = y;
if (s[x] == 'E') gx = x, gy = y;
if (isdigit(s[x])) m[y][x] = s[x] - '0';
}
}
deque<pair<int, int> > q;
set<int> s;
memset(step, -1, sizeof(step));
step[sy][sx] = 0;
q.push_back(make_pair(sx, sy));
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop_front();
inq[y][x] = 0;
for (int i = (0); i < (0 + 4); ++i) {
int mx = x + dir[i][0];
int my = y + dir[i][1];
if (mx < 0 || my < 0 || mx >= w || my >= h) continue;
if (m[my][mx] < 0) continue;
if (step[my][mx] > step[y][x] + 1) {
step[my][mx] = step[y][x] + 1;
if (inq[my][mx] == 0) {
q.push_back(make_pair(mx, my));
inq[my][mx] = 1;
}
}
}
}
unsigned int st = step[gy][gx];
memset(step, -1, sizeof(step));
step[gy][gx] = 0;
int count = 0;
q.push_back(make_pair(gx, gy));
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop_front();
inq[y][x] = 0;
for (int i = (0); i < (0 + 4); ++i) {
int mx = x + dir[i][0];
int my = y + dir[i][1];
if (mx < 0 || my < 0 || mx >= w || my >= h) continue;
if (m[my][mx] < 0) continue;
if (step[my][mx] > step[y][x] + 1) {
step[my][mx] = step[y][x] + 1;
if (m[my][mx] > 0 && step[my][mx] <= st) {
count += m[my][mx];
m[my][mx] = 0;
}
if (inq[my][mx] == 0) {
q.push_back(make_pair(mx, my));
inq[my][mx] = 1;
}
}
}
}
for (int y = (0); y < (0 + h); ++y) {
for (int x = (0); x < (0 + w); ++x) {
;
};
}
cout << count << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct D {
int a, b;
D(int a = 0, int b = 0) : a(a), b(b) {}
bool operator<(const D& d) const {
if (a != d.a) return a < d.a;
return b < d.b;
}
bool operator>(const D& d) const {
if (a != d.a) return a > d.a;
return b > d.b;
}
};
D operator+(const D& l, const D& r) { return D(l.a + r.a, l.b + r.b); }
int n;
const int knight = 0;
const int bishop = 1;
const int rook = 2;
vector<int> ai;
vector<vector<int> > a;
int f(int x, int y, int z, int piece) {
return ((x * n + y) * n * n + z) * 3 + piece;
}
bool h(int x, int y, int z, int w, int piece) {
x = abs(x - z);
y = abs(y - w);
if (piece == knight) return ((x == 1 && y == 2) || (x == 2 && y == 1));
if (piece == bishop) return x == y;
return x == 0 || y == 0;
}
struct graph {
struct edge {
int to;
D cost;
edge(int to, D cost) : to(to), cost(cost) {}
bool operator<(const edge& r) const { return cost < r.cost; }
};
int V;
vector<vector<edge> > adj;
vector<D> dist;
vector<int> prev;
graph() {}
graph(int n) { init(n); }
void init(int size) {
V = size;
adj.assign(size, vector<edge>());
}
void add_edge(int from, int to, D cost) {
adj[from].push_back(edge(to, cost));
}
void Dijkstra(int from, D inf) {
priority_queue<pair<D, int>, vector<pair<D, int> >, greater<pair<D, int> > >
q;
dist.assign(V, inf);
prev.assign(V, -2);
dist[from] = D();
prev[from] = -1;
q.push(pair<D, int>(D(), from));
while (!q.empty()) {
pair<D, int> p = q.top();
q.pop();
int v = p.second;
if (p.first > dist[v]) continue;
for (edge e : adj[v]) {
if (dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
prev[e.to] = v;
q.push(pair<D, int>(dist[e.to], e.to));
}
}
}
}
};
graph g;
D dst(int v) {
D res = g.dist[f(ai[v] / n, ai[v] % n, v, 0)];
for (int p = 1; p < 3; p++) {
D tmp = g.dist[f(ai[v] / n, ai[v] % n, v, p)];
if (tmp < res) res = tmp;
}
return res;
}
int main(void) {
cin >> n;
a.assign(n, vector<int>(n, 0));
ai.assign(n * n + 1, 0);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> a[i][j];
ai[--a[i][j]] = i * n + j;
}
g.init(n * n * n * n * 3 + 1);
for (int i = 0; i < n * n; i++) {
for (int k = 0; k < n * n - 1; k++) {
for (int p = 0; p < 3; p++) {
int x = i / n;
int y = i % n;
int id = f(x, y, k, p);
g.add_edge(id, f(x, y, k, (p + 1) % 3), D(1, 1));
g.add_edge(id, f(x, y, k, (p + 2) % 3), D(1, 1));
for (int j = 0; j < n * n; j++) {
if (h(x, y, j / n, j % n, p)) {
if (a[j / n][j % n] == k + 1)
g.add_edge(id, f(j / n, j % n, k + 1, p), D(1, 0));
else
g.add_edge(id, f(j / n, j % n, k, p), D(1, 0));
}
}
}
}
}
g.add_edge(n * n * n * n * 3, f(ai[0] / n, ai[0] % n, 0, knight), D(0, 0));
g.add_edge(n * n * n * n * 3, f(ai[0] / n, ai[0] % n, 0, bishop), D(0, 0));
g.add_edge(n * n * n * n * 3, f(ai[0] / n, ai[0] % n, 0, rook), D(0, 0));
g.Dijkstra(n * n * n * n * 3, D(1e9, 1e9));
D ans = dst(n * n - 1);
cout << ans.a << " " << ans.b << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 998244353, mgc = 1000000;
long long inv(long long x, long long m = M) {
return x <= 1 ? x : ((1 - inv(m % x, x) * m) / x + m) % m;
}
struct poly {
vector<long long> v;
inline long long& operator[](int i) {
if (v.size() <= i) v.resize(i + 1);
return v[i];
}
inline long long operator()(long long x) {
long long res = 0;
for (int i = v.size() - 1; i >= 0; --i) res = (res * x + v[i]) % M;
return res;
}
inline void integrate() {
if (v.empty() || v.back()) v.push_back(0);
for (int i = v.size() - 1; i; --i) v[i] = v[i - 1] * inv(i) % M;
v[0] = 0;
}
} dp1[930];
int n, fc, cut[30];
long long x[30], pt[931], dist[930], dp2[930];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
vector<int> f = {0};
for (int i = 0; i < n; ++i) {
double d;
cin >> d;
x[i] = (long long)(d * mgc + 0.5);
f.push_back(x[i] % mgc);
}
sort(f.begin(), f.end());
f.resize(unique(f.begin(), f.end()) - f.begin());
fc = f.size();
for (int i = 0; i < n; ++i)
for (int j = 0; j < fc; ++j) pt[i * fc + j] = (i + f[j] * inv(mgc)) % M;
pt[n * fc] = n;
for (int i = 0; i < n; ++i)
cut[i] = find(pt, pt + n * fc + 1, (x[i] * inv(mgc)) % M) - pt;
for (int i = 0; i < n * fc; ++i) dist[i] = (pt[i + 1] - pt[i] + M) % M;
for (int i = 0; i < n * fc; ++i) {
if (i < min(fc, cut[0])) {
dp1[i][1] = 1;
dp2[i] = dist[i];
}
}
for (int k = 1; k < n; ++k) {
for (int i = n * fc - 1; i >= 0; --i) {
if (i >= cut[k]) {
dp1[i].v.clear();
dp2[i] = 0;
} else {
for (int j = i - 1; j >= max(i - fc, 0); --j) dp1[i][0] += dp2[j];
dp1[i][0] %= M;
if (i - fc >= 0)
for (int j = 0; j < dp1[i - fc].v.size(); ++j)
dp1[i][j] = (dp1[i][j] - dp1[i - fc][j] + M) % M;
dp1[i].integrate();
dp2[i] = dp1[i](dist[i]);
}
}
}
long long ans = 0;
for (int i = 0; i < n * fc; ++i) ans += dp2[i];
cout << ans % M;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, k, g, ans, f, a[20000], b[20000], c[20000], d[20000], e[20000];
int main() {
cin >> n >> m;
int mm = m;
for (i = 0; i < n; i++) cin >> a[i] >> b[i] >> c[i];
g = -1;
ans = 0;
for (i = 0; i < n; i++) {
k = 0;
f = -1;
for (j = 0; j < n; j++)
if (a[j] != g && d[j] == 0 && b[j] <= m) {
if (i != 0) {
if (f == -1)
k = c[j], f = j;
else if (k < c[j])
k = c[j], f = j;
} else if (a[j] == 1) {
if (f == -1)
k = c[j], f = j;
else if (k < c[j])
k = c[j], f = j;
}
}
if (f == -1) break;
d[f] = 1;
m += k;
g = a[f];
ans++;
}
g = -1;
m = mm;
int anss = ans;
ans = 0;
for (i = 0; i < n; i++) {
k = 0;
f = -1;
for (j = 0; j < n; j++)
if (a[j] != g && e[j] == 0 && b[j] <= m) {
if (i != 0) {
if (f == -1)
k = c[j], f = j;
else if (k < c[j])
k = c[j], f = j;
} else if (a[j] == 0) {
if (f == -1)
k = c[j], f = j;
else if (k < c[j])
k = c[j], f = j;
}
}
if (f == -1) break;
e[f] = 1;
m += k;
g = a[f];
ans++;
}
cout << max(ans, anss);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long arr[n + 1];
long long mn = INT_MAX;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
mn = min(mn, arr[i]);
}
int mn_mn_pos = -1, mx_mn_pos = -1;
for (int i = 0; i < n; ++i) {
if (arr[i] == mn && mn_mn_pos == -1) {
mn_mn_pos = i;
mx_mn_pos = i;
}
if (arr[i] == mn) mx_mn_pos = i;
}
long long a = 0LL;
for (int i = 0; i < n; ++i) {
a += mn;
}
int c = 0, size = 0;
for (int i = 0; i < n;) {
size = 0;
if (arr[i] != mn) {
while (i < n && arr[i] != mn) {
i++;
size++;
}
c = max(c, size);
} else {
i++;
}
}
size = n - 1 - (mx_mn_pos);
size += mn_mn_pos;
c = max(c, size);
a += c;
cout << a << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout.precision(17);
unsigned long long n, a, cf, cm, m;
cin >> n >> a >> cf >> cm >> m;
vector<pair<unsigned long long, unsigned long long> > v(n);
unsigned long long req = 0;
for (size_t i = 0; i < n; ++i) {
v[i].second = i;
cin >> v[i].first;
req += (a - v[i].first);
}
if (req <= m) {
cout << (cf * n + cm * a) << endl;
for (size_t i = 0; i < n; ++i) cout << a << " ";
cout << endl;
return 0;
}
sort((v).begin(), (v).end(),
greater<pair<unsigned long long, unsigned long long> >());
vector<unsigned long long> up(n, 0);
for (size_t i = 1; i < n; ++i)
up[n - 1 - i] = up[n - i] + i * (v[n - 1 - i].first - v[n - i].first);
unsigned long long r = 0;
unsigned long long best_full = 0;
unsigned long long best_min_cnt = 0;
unsigned long long best_min_val = 0;
for (size_t i = 0; i <= n; ++i) {
unsigned long long cur = 0;
if (i) {
if (m < (a - v[i - 1].first)) break;
m -= a - v[i - 1].first;
cur = cf * i;
}
unsigned long long cnt =
upper_bound(up.rbegin(), up.rend() - i, m) - up.rbegin();
unsigned long long j = n - cnt;
cur += cm * (v[j].first + (m - up[j]) / cnt);
if (cur > r) {
r = cur;
best_full = i;
best_min_cnt = cnt;
best_min_val = (v[j].first + (m - up[j]) / cnt);
}
}
cout << r << endl;
for (size_t i = 0; i < best_full; ++i) v[i].first = a;
for (size_t i = 0; i < best_min_cnt; ++i) v[n - 1 - i].first = best_min_val;
sort((v).begin(), (v).end(),
[](pair<unsigned long long, unsigned long long> lhs,
pair<unsigned long long, unsigned long long> rhs) {
return lhs.second < rhs.second;
});
for (size_t i = 0; i < n; ++i) cout << v[i].first << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
map<int, long long> m;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
m[t]++;
}
long long sum = 0;
for (int i = -10; i < 0; i++) {
if (m[i] != 0) {
long long x = m[i] * m[-i];
sum += x;
}
}
long long h = m[0];
sum += (m[0] * (m[0] - 1)) / 2;
cout << sum << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long sum1[100005];
long long sum2[100005];
char a[100005];
long long sx, sy, ex, ey, n, i, j, kx, ky;
inline bool check(long long x) {
long long k1 = (x / n), k2 = x % n;
return (llabs(sum1[n - 1] * k1 + (k2 == 0 ? 0 : (sum1[k2 - 1])) - ky) +
llabs(sum2[n - 1] * k1 + (k2 == 0 ? 0 : (sum2[k2 - 1])) - kx)) <= x;
}
int main() {
long long l, r, mid;
while (scanf("%I64d%I64d", &sx, &sy) != EOF) {
scanf("%I64d%I64d", &ex, &ey);
scanf("%I64d", &n);
getchar();
scanf("%s", a);
kx = ex - sx;
ky = ey - sy;
sum1[0] = 0;
sum2[0] = 0;
if (a[0] == 'U') sum1[0] = 1;
if (a[0] == 'D') sum1[0] = -1;
if (a[0] == 'R') sum2[0] = 1;
if (a[0] == 'L') sum2[0] = -1;
for (i = 1; i < n; i++) {
sum2[i] = sum2[i - 1];
sum1[i] = sum1[i - 1];
if (a[i] == 'U') sum1[i] = sum1[i - 1] + 1;
if (a[i] == 'D') sum1[i] = sum1[i - 1] - 1;
if (a[i] == 'R') sum2[i] = sum2[i - 1] + 1;
if (a[i] == 'L') sum2[i] = sum2[i - 1] - 1;
}
l = 0;
r = 2e14 + 1;
while (l + 1 < r) {
mid = l + (r - l) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
if (r == 2e14 + 1)
printf("-1\n");
else
printf("%I64d\n", r);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct state {
int son[26], link, len;
} st[400010];
struct data {
int x, y, id;
};
char s[400010];
int cnt = 1, last, jump[400010][20], mn_l[400010], mx_l[400010], lg,
size[400010];
int son[400010], top[400010], now, father[400010], node[400010], n;
int id[400010], pos[400010], tl[400010], tr[400010];
long long res[400010];
vector<int> neigh[400010];
vector<data> Q[400010];
bool cmp1(data a, data b) {
if (a.y == b.y)
return a.id < b.id;
else
return a.y > b.y;
}
bool cmp2(data a, data b) {
if (a.x == b.x)
return a.id < b.id;
else
return a.x < b.x;
}
struct ds {
long long sum[2][400010];
int m, used[400010], tot, change[400010], P;
int lowbit(int x) { return x - (x & x - 1); }
void clear() {
sum[0][0] = sum[1][0] = 0;
for (int i = 1; i <= tot; i++)
sum[0][change[i]] = sum[1][change[i]] = used[change[i]] = 0;
tot = 0;
}
long long query(int c, int x) {
x += P;
if (x <= 0) return 0;
if (x >= m) return sum[c][0];
long long res = 0;
while (x) {
res += sum[c][x];
x -= lowbit(x);
}
return res;
}
void modify(int x, int c1, int c0) {
x += P;
sum[0][0] += c0;
sum[1][0] += c1;
while (x <= m) {
sum[0][x] += c0;
sum[1][x] += c1;
if (used[x] == 0) {
change[++tot] = x;
used[x] = 1;
}
x += lowbit(x);
}
}
} bit;
int get_node(int res, int len) {
if (len >= mn_l[res]) return res;
for (int i = lg; i >= 0; i--)
if (jump[res][i] && mn_l[jump[res][i]] > len) res = jump[res][i];
return jump[res][0];
}
void insert(int x, int id) {
int cur = ++cnt, p = last, q;
st[cur].len = st[last].len + 1;
last = pos[id] = cur;
for (; p != -1 && st[p].son[x] == 0; p = st[p].link) st[p].son[x] = cur;
if (p == -1) {
st[cur].link = 1;
return;
}
q = st[p].son[x];
if (st[q].len == st[p].len + 1) {
st[cur].link = q;
return;
}
int clone = ++cnt;
st[clone] = st[q];
st[clone].len = st[p].len + 1;
st[q].link = st[cur].link = clone;
for (; p != -1 && st[p].son[x] == q; p = st[p].link) st[p].son[x] = clone;
}
void dfs(int u) {
size[u] = 1;
int len = neigh[u].size(), mx = 0;
for (int i = 0; i <= len - 1; i++) {
int v = neigh[u][i];
father[v] = u;
dfs(v);
size[u] += size[v];
if (size[v] > mx) {
mx = size[v];
son[u] = v;
}
}
}
void connect(int u, int ancient) {
top[u] = ancient;
id[u] = ++now;
node[cnt] = u;
if (son[u]) connect(son[u], ancient);
int len = neigh[u].size();
for (int i = 0; i <= len - 1; i++) {
int v = neigh[u][i];
if (v != son[u]) connect(v, v);
}
}
void solve1(int x) {
sort(Q[x].begin(), Q[x].end(), cmp1);
bit.m = n;
bit.P = 0;
int len = Q[x].size();
for (int i = 0; i <= len - 1; i++) {
data tmp = Q[x][i];
if (tmp.id == -1)
bit.modify(tmp.x, tmp.x, 1);
else {
long long t1 = bit.query(1, tmp.x),
t0 = bit.sum[0][0] - bit.query(0, tmp.x);
res[tmp.id] -= t1 + t0 * tmp.x;
}
}
bit.clear();
}
void solve2(int x) {
int len = Q[x].size();
sort(Q[x].begin(), Q[x].end(), cmp2);
bit.m = n + 1;
bit.P = 1;
for (int i = len - 1; i >= 0; i--) {
data tmp = Q[x][i];
if (tmp.id == -1)
bit.modify(tmp.y, tmp.y, 1);
else {
long long t1 = bit.query(1, tmp.x + tmp.y - 2) - bit.query(1, tmp.y - 3),
t0;
t0 = bit.query(0, tmp.x + tmp.y - 2) - bit.query(0, tmp.y - 3);
res[tmp.id] += t1 + (2 - tmp.y) * t0;
t0 = bit.sum[0][0] - bit.query(0, tmp.x + tmp.y - 2);
res[tmp.id] += t0 * tmp.x;
}
}
bit.clear();
bit.m = 2 * n + 1;
bit.P = n + 1;
for (int i = 0; i <= len - 1; i++) {
data tmp = Q[x][i];
if (tmp.id == -1)
bit.modify(tmp.y - tmp.x, tmp.y, 1);
else {
long long t1 = bit.query(1, tmp.y - 2), t0 = bit.query(0, tmp.y - 2);
res[tmp.id] += t1 + (2 - tmp.y) * t0;
}
}
bit.clear();
for (int i = 0; i <= len - 1; i++) {
data tmp = Q[x][i];
if (tmp.id == -1)
bit.modify(tmp.y, tmp.y, 1);
else {
long long t1 = bit.query(1, tmp.y - 2), t0 = bit.query(0, tmp.y - 2);
res[tmp.id] -= t1 + (2 - tmp.y) * t0;
}
}
bit.clear();
for (int i = 0; i <= len - 1; i++) {
data tmp = Q[x][i];
if (tmp.id == -1)
bit.modify(tmp.y - tmp.x, tmp.x, 1);
else {
long long t1 = bit.sum[1][0] - bit.query(1, tmp.y - 2);
res[tmp.id] += t1;
}
}
bit.clear();
}
int main() {
int q;
scanf("%s", s + 1);
n = strlen(s + 1);
reverse(s + 1, s + n + 1);
last = 1;
st[1].link = -1;
for (int i = 1; i <= n; i++) insert(s[i] - 'a', i);
for (int i = 2; i <= cnt; i++) {
mx_l[i] = st[i].len;
mn_l[i] = st[st[i].link].len + 1;
jump[i][0] = st[i].link;
neigh[st[i].link].push_back(i);
}
int tmp = 1;
while (tmp <= cnt) {
tmp *= 2;
lg++;
}
for (int j = 1; j <= lg; j++)
for (int i = 1; i <= cnt; i++) jump[i][j] = jump[jump[i][j - 1]][j - 1];
dfs(1);
connect(1, 1);
int ch = 0;
for (int i = 2; i <= cnt; i++)
if (top[i] == 1 && father[i] == 1) {
ch = i;
break;
}
for (int i = 2; i <= cnt; i++)
if (top[i] == 1) top[i] = ch;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r, tmp;
scanf("%d%d", &l, &r);
l = n - l + 1;
r = n - r + 1;
swap(l, r);
tmp = get_node(pos[r], r - l + 1);
while (tmp != 1) {
int x = top[tmp];
Q[x].push_back((data){min(r - l + 1, mx_l[tmp]) - mn_l[x] + 1, r + 1, i});
tmp = father[x];
}
tl[i] = l;
tr[i] = r;
}
for (int i = 1; i <= n; i++) {
int tmp = pos[i];
while (tmp != 1) {
int x = top[tmp];
Q[x].push_back((data){mx_l[tmp] - mn_l[x] + 1, i, -1});
tmp = father[x];
}
}
for (int i = 2; i <= cnt; i++)
if (top[i] == i) {
solve1(i);
Q[i].clear();
}
for (int i = 1; i <= q; i++) {
int tmp = get_node(pos[tr[i]], tr[i] - tl[i] + 1);
while (tmp != 1) {
int x = top[tmp], cur_len = min(tr[i] - tl[i] + 1, mx_l[tmp]);
Q[x].push_back((data){cur_len - mn_l[x] + 1, tl[i], i});
tmp = father[x];
}
}
for (int i = 1; i <= n; i++) {
int tmp = pos[i];
while (tmp != 1) {
int x = top[tmp];
Q[x].push_back((data){mx_l[tmp] - mn_l[x] + 1, i - mn_l[x], -1});
tmp = father[x];
}
}
for (int i = 2; i <= cnt; i++)
if (top[i] == i) solve2(i);
for (int i = 1; i <= q; i++) printf("%lld\n", res[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct Rec {
int x1, y1;
int x2, y2;
} res[2000], cc[200];
int ans[2000];
bool vis[200];
int main() {
int w, h, n, num;
while (scanf("%d%d%d", &w, &h, &n) == 3) {
res[0].x1 = 0, res[0].y1 = 0, res[0].x2 = w, res[0].y2 = h;
num = 1;
memset(vis, 0, sizeof(vis));
int x1, x2, y1, y2, i, j, k;
for (j = 1; j <= n; ++j) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
cc[j].x1 = x1, cc[j].y1 = y1, cc[j].x2 = x2, cc[j].y2 = y2;
}
for (int ll = 0; ll < n; ++ll) {
for (j = 1; j <= n; ++j) {
if (vis[j]) continue;
for (k = 0; k < num; ++k) {
if (cc[j].x1 == cc[j].x2 &&
(cc[j].y1 == res[k].y1 && cc[j].y2 == res[k].y2) &&
(cc[j].x1 < res[k].x2 && cc[j].x1 > res[k].x1))
break;
if (cc[j].y1 == cc[j].y2 &&
(cc[j].x1 == res[k].x1 && cc[j].x2 == res[k].x2) &&
(cc[j].y1 < res[k].y2 && cc[j].y1 > res[k].y1))
break;
}
if (k == num) continue;
vis[j] = 1;
x1 = cc[j].x1, y1 = cc[j].y1, x2 = cc[j].x2, y2 = cc[j].y2;
if (y1 == y2) {
for (i = 0; i < num; ++i)
if (res[i].x1 == x1 && res[i].x2 == x2 && y1 < res[i].y2 &&
y1 > res[i].y1) {
res[num].x1 = res[i].x1;
res[num].x2 = x2;
res[num].y1 = res[i].y1;
res[num++].y2 = y2;
res[i].y1 = y1;
break;
}
} else if (x1 == x2) {
for (i = 0; i < num; ++i)
if ((res[i].y1 == y1 && res[i].y2 == y2) &&
(x1 < res[i].x2 && x1 > res[i].x1)) {
res[num].x1 = res[i].x1;
res[num].y1 = res[i].y1;
res[num].x2 = x2;
res[num++].y2 = y2;
res[i].x1 = x1;
break;
}
}
}
}
for (i = 0; i < num; ++i) {
ans[i] = (res[i].y2 - res[i].y1) * (res[i].x2 - res[i].x1);
}
sort(ans, ans + num);
for (i = 0; i < num; ++i) printf("%d ", ans[i]);
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pii pair<int, int>
#define fi first
#define se second
#define size(a) (int) a.size()
#define chkmin(a, b) a = min(a, b)
#define chkmax(a, b) a = max(a, b)
#define all(a) begin(a), end(a)
#define mp make_pair
#define pb emplace_back
#define ld long double
mt19937 rnd;
const int inf = 2e9 + 3, mod = 1e9 + 7;
const int max_n = 1e3 + 3;
int n, m;
int a[max_n][max_n], sum[max_n], sum2[max_n];
void run() {
cin >> m >> n;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
sum[i] += a[i][j];
sum2[i] += a[i][j] * a[i][j];
}
}
int x = (sum[n - 1] - sum[0]) / (n - 1), ad;
int r1 = -1, r2 = -1;
for (int i = 1; i < n; ++i) {
if (sum[0] + i * x != sum[i]) r1 = i, ad = sum[0] + i * x - sum[i];
}
int y = 0;
for (int i = 1; i < n - 1; ++i) {
if (i + 1 < r1 || i - 1 > r1) {
y = (sum2[i + 1] + sum2[i - 1] - 2 * sum2[i]);
}
}
for (int i = 0; i < m; ++i) {
int c = sum2[r1] - a[r1][i] * a[r1][i] + (a[r1][i] + ad) * (a[r1][i] + ad);
if (sum2[r1 + 1] + sum2[r1 - 1] - 2 * c == y) {
r2 = i;
}
}
cout << r1 << " " << a[r1][r2] + ad << endl;
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0);
cout.precision(20);
#ifdef ahahaha
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t = 1;
//cin >> t;
while (t--) {
run();
}
} | 11 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 3e2 + 2, N = 1e5 + 7, MOD = 1e9 + 7, Mod = 1e9 + 6,
INF = 1LL << 56;
long long n, m, k, x, y, z, dp[maxN][maxN], ans[maxN][maxN];
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) dp[i][j] = INF, ans[i][j] = INF;
}
for (int i = 1; i <= m; i++) cin >> x >> y >> z, dp[x][y] = min(dp[x][y], z);
for (long long i = n; i >= 1; i--) {
for (long long j = n; j >= 1; j--)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]),
dp[i][j - 1] = min(dp[i][j], dp[i][j - 1]);
}
for (int len = 1; len <= n - 1; len++) {
for (int i = 1; i <= n - len; i++) {
long long j = len - i;
for (int u = i; u <= j; u++)
dp[i][j] = min(dp[i][u] + dp[u + 1][j], dp[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
if (i != 1) ans[i][j] = min(ans[i][j], ans[i - 1][j]);
for (int u = 1; u <= j; u++)
ans[i][j] = min(ans[i - u][j - u] + dp[i - u + 1][i], ans[i][j]);
}
}
if (ans[n][k] == INF) return cout << "-1\n", 0;
return cout << ans[n][k] << "\n", 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
int n;
long long MOD = 1e9 + 7;
const int MAX = 1e3 + 10;
long long memo[MAX][MAX][2];
long long get(int o, int c, bool b) {
if (o == n && c == n) return 0;
long long &ans = memo[o][c][b];
if (ans != -1) return ans;
ans = 0;
long long r = 0;
{
if (o < n) {
r += get(o + 1, c, true);
}
if (c < o) {
r += get(o, c + 1, true);
}
}
long long l = 0;
if (b) {
l = 1;
{
if (o < n) {
l += get(o + 1, c, false);
}
if (c < o) {
l += get(o, c + 1, false);
}
}
}
ans = max(l, r);
ans %= MOD;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
memset(memo, -1, sizeof memo);
cout << get(0, 0, false) << '\n';
exit(0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
string s;
cin >> n;
cin >> s;
int m = s.size();
int count = 0;
for (int i = n; i < m; i += n) {
if (s[i - 1] == s[i - 2] && s[i - 3] == s[i - 1]) count++;
}
cout << count;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T = int>
inline T nxt() {
char c = nc();
T x = 0;
int f = 1;
for (; c > '9' || c < '0'; c = nc())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= f;
return x;
}
const int MAXN = 1000123;
int d[MAXN];
bool a[MAXN];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int q = nxt();
while (q--) {
int t = nxt();
if (t == 1) {
int x = nxt();
a[x] = true;
for (int i = 1; i < (350); ++i) {
if (x % i == 0) d[i] = max(x, d[i]);
}
} else {
int x = nxt(), k = nxt(), s = nxt(), ans = -1;
if (x % k == 0) {
if (k >= 350) {
for (int i = x; i <= s; i += k) {
if (a[i - x]) ans = max(ans, (i - x) ^ x);
}
} else {
for (int i = min(s, x + d[k]); i >= 0; i--) {
int v = i ^ x;
if (v % k == 0 && v + x <= s && a[v]) {
ans = i;
break;
}
}
}
}
if (ans != -1) ans ^= x;
cout << ans << '\n';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
long long n, m;
cin >> n >> m;
vector<long long> x(2);
x[0] = n / 2 + 1;
x[1] = n + 1 - x[0];
vector<long long> y(2);
y[0] = m / 2 + 1;
y[1] = m + 1 - y[0];
vector<long long> rozX(n + 1, 0);
vector<long long> rozY(m + 1, 0);
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= i; ++j) ++rozX[i - j];
for (int i = 0; i <= m; ++i)
for (int j = 0; j <= i; ++j) ++rozY[i - j];
long long odp = 0;
for (int a = 0; a < 2; ++a) {
for (int b = 0; b < 2; ++b) {
for (int c = 0; c < 2; ++c) {
for (int d = 0; d < 2; ++d) {
for (int e = 0; e < 2; ++e) {
for (int f = 0; f < 2; ++f) {
long long l = (c - a) * (f - b);
long long p = (d - b) * (e - a);
long long r = l - p;
if (r < 0) r *= -1;
if (r % 2 == 0) {
long long t = x[c] * x[a] % MOD * y[f] % MOD * y[b] % MOD *
y[d] % MOD * x[e] % MOD;
odp = (odp + t) % MOD;
}
}
}
}
}
}
}
vector<vector<int> > nwd(n + 1, vector<int>(m + 1));
for (int i = 0; i <= m; ++i) nwd[0][i] = i;
for (int i = 1; i <= n; ++i) {
nwd[i][0] = i;
for (int j = 1; j <= m; ++j) {
if (i <= j)
nwd[i][j] = nwd[i][j % i];
else
nwd[i][j] = nwd[i % j][j];
}
}
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
long long sr = nwd[i][j] - 1;
if (sr <= 0) continue;
long long x = rozX[i];
long long y = rozY[j];
long long t =
x * y % MOD * sr % MOD * ((i == 0 || j == 0) ? 6 : 12) % MOD;
odp -= t;
if (odp < 0) odp += MOD;
}
}
long long a = (n + 1) * (m + 1);
long long c = a * (a - 1) * 3 % MOD;
odp -= c;
if (odp < 0) odp += MOD;
odp -= a;
if (odp < 0) odp += MOD;
cout << odp;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long double C(int n, int m) {
if (m > n) return 0;
if (m > n / 2) m = n - m;
long double ret = 1;
for (int i = 0; i <= m - 1; i++) ret = ret * (n - i) / (m - i);
return ret;
}
int main() {
scanf("%d%d", &n, &m);
long double ans = 0;
for (int i = 1; i <= n; i++) {
ans += ((double)i) * ((double)i / n) * C(m, i) *
(C(n * m - m, n - i) / C(n * m, n));
}
printf("%.8f\n", (double)ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)3e5 + 1;
int n, m, h;
int a[maxn], b[maxn];
vector<int> v;
int t[maxn * 4], add[maxn * 4];
void push(int v, int tl, int tr) {
if (tl != tr) {
add[v * 2] += add[v];
add[v * 2 + 1] += add[v];
}
t[v] += add[v];
add[v] = 0;
}
void upd1(int v, int tl, int tr, int p, int q) {
if (tl == tr) {
t[v] = q;
} else {
int mid = (tl + tr) / 2;
if (p <= mid) {
upd1(v * 2, tl, mid, p, q);
} else {
upd1(v * 2 + 1, mid + 1, tr, p, q);
}
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
}
void upd(int v, int tl, int tr, int l, int r, int h) {
push(v, tl, tr);
if (l > tr || tl > r) {
return;
}
if (l <= tl && tr <= r) {
add[v] = h;
push(v, tl, tr);
return;
}
int mid = (tl + tr) / 2;
upd(v * 2, tl, mid, l, r, h);
upd(v * 2 + 1, mid + 1, tr, l, r, h);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
int ans;
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= m; i++) {
cin >> a[i];
v.push_back(h - a[i]);
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
v.push_back(b[i]);
}
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
for (int i = 1; i <= n; i++) {
b[i] = lower_bound(v.begin(), v.end(), b[i]) - v.begin() + 1;
}
for (int i = 1; i <= m; i++) {
a[i] = lower_bound(v.begin(), v.end(), h - a[i]) - v.begin() + 1;
}
sort(a + 1, a + m + 1);
reverse(a + 1, a + m + 1);
for (int i = 1; i <= m; i++) {
upd1(1, 1, 300000, a[i], i);
}
for (int i = 1; i <= m; i++) {
upd(1, 1, 300000, 1, b[i], -1);
}
if (t[1] < 1) {
ans++;
}
for (int i = m + 1; i <= n; i++) {
upd(1, 1, 300000, 1, b[i - m], 1);
upd(1, 1, 300000, 1, b[i], -1);
if (t[1] < 1) {
ans++;
}
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline namespace Infinity {
inline namespace IO {
const char CR = '\n';
const char SP = ' ';
inline void write(const int n) { printf("%d", n); }
inline void write(const unsigned n) { printf("%u", n); }
inline void write(const long long n) { cout << n; }
inline void write(const unsigned long long n) { cout << n; }
inline void writef(const double a, const int n = 15) { printf("%.*f", n, a); }
inline void writef(const long double a, const int n = 18) {
cout << setprecision(n) << fixed << a;
}
inline void write(const char c) { printf("%c", c); }
inline void write(const char s[]) { printf("%s", s); }
inline void write(const string &s) { cout << s; }
inline void write(const pair<int, int> &p) {
printf("%d %d", p.first, p.second);
}
template <class T>
inline void write(const T a) {
for (auto i : a) write(i), write(SP);
}
inline void writeln() { write(CR); }
template <typename T>
inline void writeln(const T &a) {
write(a);
write(CR);
}
inline void writefln(const double a, int n) {
printf("%.*f", n, a);
write(CR);
}
inline void writefln(const long double a, int n = 18) {
cout << setprecision(n) << fixed << a << endl;
}
inline void writesln(const int *a, const int l, const int r) {
for (int i = l; i <= r; i++) printf("%d ", a[i]);
writeln(CR);
}
template <class T>
inline void writelns(const T a) {
for (__typeof a.begin() i = a.begin(); i != a.end(); i++) writeln(*i);
}
template <typename T, typename... types>
inline void write(const T &a, const types &...args) {
write(a);
write(args...);
}
template <typename... types>
inline void writeln(const types &...args) {
write(args...);
write(CR);
}
inline void writelnYN(bool b) { writeln(b ? "YES" : "NO"); }
inline void writelnyn(bool b) { writeln(b ? "Yes" : "No"); }
string caseSharpSpace(int n) { return "Case #" + to_string(n) + ": "; }
string caseNoSharpSpace(int n) { return "Case " + to_string(n) + ": "; }
string caseSharpNoSpace(int n) { return "Case #" + to_string(n) + ":"; }
string caseNoSharpNoSpace(int n) { return "Case " + to_string(n) + ":"; }
inline int read(int &n) { return scanf("%d", &n); }
inline int read(long long &n) { return cin >> n ? 1 : -1; }
template <typename T, typename... types>
inline int read(T &n, types &...args) {
read(n);
return read(args...);
}
inline char getcc() {
char c;
do c = getchar();
while (c == ' ' || c == '\n');
return c;
}
inline int getint() {
int n;
read(n);
return n;
}
inline long long getll() {
long long n;
read(n);
return n;
}
inline double getdouble() {
double n;
scanf("%lf", &n);
return n;
}
inline vector<int> getints(int n) {
vector<int> v(n);
for (int i = 0; i < n; i++) v[i] = getint();
return v;
}
inline vector<pair<int, int> > getpairs(int n) {
vector<pair<int, int> > v(n);
for (int i = 0; i < n; i++) {
int a = getint(), b = getint();
v[i] = pair<int, int>(a, b);
}
return v;
}
inline void read(string &str, const unsigned size) {
char s[size];
scanf("%s", s);
str = string(s);
}
inline string getstr(const unsigned size = 1048576) {
string s;
read(s, size + 1);
return s;
}
inline string getln(const unsigned size = 1048576) {
char s[size + 1];
scanf("%[^\n]", s);
getchar();
return string(s);
}
} // namespace IO
inline namespace Functions {
inline constexpr int ctoi(const char c) { return c - '0'; }
inline constexpr char itoc(const int n) { return n + '0'; }
inline int dtoi(const double d) { return round(d); }
template <typename T>
inline bool in(T x, T l, T r) {
return l <= x && x <= r;
}
template <class T>
inline int size(const T &a) {
return a.size();
}
template <typename T1, typename T2>
inline pair<T1, T2> mkp(const T1 &a, const T2 &b) {
return make_pair(a, b);
}
template <class T>
inline void sort(T &a) {
std::sort(a.begin(), a.end());
}
template <class T1, class T2>
inline void sort(T1 &a, T2 comp) {
std::sort(a.begin(), a.end(), comp);
}
template <class T1, typename T2>
inline int lbound(const T1 &a, const T2 k) {
return lower_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, typename T2>
inline int ubound(const T1 &a, const T2 k) {
return upper_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, class T2>
int count(T1 &a, T2 k) {
return ubound(a, k) - lbound(a, k);
}
template <class T1, class T2>
int find(T1 &a, T2 k) {
return count(a, k) ? lbound(a, k) : -1;
}
template <typename T>
inline void clear(T &a) {
memset(a, 0, sizeof a);
}
template <typename T>
T gcd(T a, T b) {
while (b) {
T t = a % b;
a = b;
b = t;
}
return a;
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long qpow(long long a, long long b, long long c) {
return b ? qpow(a * a % c, b >> 1, c) * (b & 1 ? a : 1) % c : 1;
}
template <typename T>
T exGcd(T a, T b, T &x, T &y) {
T d = a;
if (b) {
d = exGcd(b, a % b, y, x);
y -= a / b * x;
} else {
x = 1;
y = 0;
}
return d;
}
template <typename T>
T mps(T l, T r, T k) {
return ((r - (r % k + k) % k) - (l + (k - l % k) % k)) / k + 1;
}
template <typename T>
T sgn(T a) {
return a == 0 ? 0 : a > 0 ? 1 : -1;
}
template <typename T>
constexpr T sq(T a) {
return a * a;
}
} // namespace Functions
inline namespace TypeDefine {}
} // namespace Infinity
template <typename value_type>
class SegmentTree {
protected:
typedef std::function<value_type(value_type, value_type)> binary_op;
public:
SegmentTree(unsigned int n, value_type default_value = value_type(),
binary_op op = std::plus<int>())
: m(1 << (32 - __builtin_clz(n + 2))),
t(std::vector<value_type>(1 << (32 - __builtin_clz(n + 2) + 1),
default_value)),
d(default_value),
op(op) {
this->build();
}
void build() {
for (unsigned int i = this->m - 1; i; i--)
this->t[i] = this->op(this->t[i << 1], this->t[i << 1 | 1]);
}
template <typename RAIt>
void assign(RAIt l, RAIt r) {
copy(l, r, this->t.begin() + this->m);
this->build();
}
value_type get(unsigned int pos) const { return this->t[this->m + pos]; }
void set(unsigned int pos, value_type x) {
this->t[this->m + pos] = x;
for (unsigned int i = (this->m + pos) >> 1; i; i >>= 1)
this->t[i] = this->op(this->t[i << 1], this->t[i << 1 | 1]);
}
value_type query(unsigned int l, unsigned int r) const {
if (l > r) return 0;
if (l < 1 || r > t.size() - 2 || l > r)
throw std::out_of_range("Segment tree query: out of range");
value_type a = this->d;
for (l += this->m - 1, r += this->m + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) a = this->op(a, this->t[l ^ 1]);
if (r & 1) a = this->op(a, this->t[r ^ 1]);
}
return a;
}
protected:
unsigned int m;
std::vector<value_type> t;
value_type d;
binary_op op;
};
int main(int, char *[]) {
int n = getint();
int k = getint();
int a = getint();
int b = getint();
SegmentTree<int> ft1(n + k, 0, [](int a, int b) { return a + b; }),
ft2(n + k, 0, [](int a, int b) { return a + b; });
for (int q = getint(); q--;) {
if (getint() == 1) {
int d = getint();
int r = getint();
ft1.set(d, min(a - ft1.get(d), r) + ft1.get(d));
ft2.set(d, min(b - ft2.get(d), r) + ft2.get(d));
} else {
int p = getint();
writeln(ft2.query(1, p - 1) + ft1.query(p + k, n));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
string line;
vector<long long> vec;
long long t;
int main() {
long long n, m, k;
cin >> n;
vec.resize(n);
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
sort(vec.begin(), vec.end());
long long cnt = 0;
for (int i = 1; i < vec.size(); i++) {
if (vec[i] == vec[i - 1]) cnt++;
}
if (cnt >= 2) {
cout << "cslnb";
return 0;
}
for (int i = 0; i < vec.size(); i++) {
if (i > 0 && i < vec.size() - 1 && vec[i] == vec[i + 1] &&
vec[i - 1] + 1 == vec[i]) {
cout << "cslnb";
return 0;
}
if (vec[i] < i) {
cout << "cslnb";
return 0;
}
sum += (vec[i] - i);
}
if (sum % 2 != 0) {
cout << "sjfnb";
} else {
cout << "cslnb";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, k;
cin >> n >> k;
if (k == 1) {
cout << n << "\n";
return 0;
}
long long i;
for (i = 0; ((long long)1 << i) <= n; i++)
;
cout << ((long long)1 << i) - 1 << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
std::bitset<2001> f[65536];
int n, k, a[16], now;
std::priority_queue<std::pair<int, int> > heap;
void findpath(int i, int j) {
if (!i) return;
if (j * k <= 2000 && f[i][j * k]) {
++now, findpath(i, j * k);
} else {
for (int l = 0; l < n; l++)
if ((i & (1 << l)) && j >= a[l] && f[i ^ (1 << l)][j - a[l]]) {
heap.push(std::make_pair(now, a[l]));
findpath(i ^ (1 << l), j - a[l]);
return;
}
}
}
int main() {
scanf("%d%d", &n, &k);
int mx = 0;
for (int i = 0; i < n; i++) scanf("%d", a + i), mx += a[i];
f[0][0] = 1;
for (int i = 0; i < (1 << n); i++) {
for (int j = mx; j; --j)
if (j % k == 0 && f[i][j]) f[i][j / k] = 1;
for (int j = mx + 1; j <= 2000; j++) f[i][j] = 0;
for (int j = 0; j < n; j++)
if (!(i & (1 << j))) f[i | (1 << j)] |= f[i] << a[j];
}
if (!f[(1 << n) - 1][1]) {
puts("NO");
} else {
puts("YES");
findpath((1 << n) - 1, 1);
for (int i = 1; i < n; i++) {
std::pair<int, int> a, b;
a = heap.top(), heap.pop();
b = heap.top(), heap.pop();
printf("%d %d\n", a.second, b.second);
a.second += b.second;
while (a.second % k == 0) --a.first, a.second /= k;
heap.push(a);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const int MOD = 998244353;
int n, ans;
int c[N], p[N];
int dp[N][N], sm[N][N];
int dfs(int x, int y) {
int C = sm[x][y];
if (dp[x][y] != -1) return dp[x][y];
if (x == y) return dp[x][y] = 1;
if (x > y) return dp[x][y] = 0;
dp[x][y] = 0ll;
int lft = 2ll * dfs(x, p[C] - 1), rht = 2ll * dfs(p[C] + 1, y);
for (int i = x + 1; i <= p[C] - 1; i++)
lft = (1ll * lft + 1ll * dfs(i, p[C] - 1) * dfs(x, i - 1) % MOD) % MOD;
for (int i = p[C] + 1; i <= y - 1; i++)
rht = (1ll * rht + 1ll * dfs(p[C] + 1, i) * dfs(i + 1, y) % MOD) % MOD;
if (!lft) lft++;
if (!rht) rht++;
ans = (1ll * lft * rht) % MOD;
return dp[x][y] = ans;
}
int main() {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) dp[i][j] = -1;
scanf("%d%d", &n, &n);
for (int i = 1; i <= n; i++) scanf("%d", c + i);
for (int i = 1; i <= n; i++) {
int mn = c[i];
p[c[i]] = i;
for (int j = i; j <= n; j++) {
mn = min(mn, c[j]);
sm[i][j] = mn;
}
}
printf("%d\n", dfs(1, n));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, r, k;
std::priority_queue<std::pair<long long int, int> > pq;
cin >> n >> m >> r >> k;
vector<long long int> arr(n, 0), barr(m, 0);
vector<long long int> nxt(n, 0);
long long int i, j, v = 0;
long long int r1, r2;
r1 = min(n - r + 1, r);
for (i = 0; i < n; i++) {
v++;
arr[i] = min(v, r1);
}
v = 0;
for (i = n - 1; i >= 0; i--) {
v++;
arr[i] = min(v, arr[i]);
}
v = 0;
r2 = min(m - r + 1, r);
for (i = 0; i < m; i++) {
v++;
barr[i] = min(v, r2);
}
v = 0;
for (i = m - 1; i >= 0; i--) {
v++;
barr[i] = min(v, barr[i]);
}
sort(arr.begin(), arr.end());
sort(barr.begin(), barr.end());
std::pair<long long int, int> temp;
for (i = 0; i < n; i++) {
nxt[i] = m - 1;
temp.first = 1LL * arr[i] * barr[m - 1];
temp.second = i;
pq.push(temp);
}
long long int ans = 0, var;
while (k--) {
ans += pq.top().first;
var = pq.top().second;
pq.pop();
if (nxt[var]) {
nxt[var]--;
temp.second = var;
temp.first = 1LL * arr[var] * barr[nxt[var]];
pq.push(temp);
}
}
printf("%.12lf\n", 1.0 * ans / (n - r + 1) / (m - r + 1));
return 0;
}
| 6 |
#include <bits/stdc++.h>
static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;
template <class T>
constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
int main() {
int t;
cin >> t;
while (t--) {
string a, b;
cin >> a;
b += a[0];
for (int i = 1; i < a.size(); i += 2) {
b += a[i];
}
cout << b << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
map<int, int> sqrt;
for (int i = 0; i <= 1000; i++) sqrt[i * i] = i;
cin >> s;
int nH = 0;
int nQ = 0;
for (int i = 0; i < s.length(); i++)
if (s[i] == 'H')
nH++;
else
nQ++;
if (sqrt.count(nQ) == 0) {
cout << "No" << endl;
return 0;
}
if (nQ == 0) {
cout << "Yes" << endl;
return 0;
}
int mQ = sqrt[nQ];
int mH = nH / (mQ + 1);
if (nH % (mQ + 1) != 0) {
cout << "No" << endl;
return 0;
}
int firstQ = -1;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'Q') {
firstQ = i;
break;
}
}
if (firstQ % 2 == 1) {
cout << "No" << endl;
return 0;
}
string p = s.substr(firstQ / 2, mH + mQ);
string output;
for (int i = 0; i < p.length(); i++) output += p[i] == 'H' ? "H" : p;
cout << (s == output ? "Yes" : "No") << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void setmax(T& x, T y) {
x = max(x, y);
}
template <typename T>
void setmin(T& x, T y) {
x = min(x, y);
}
const double PI = acos(-1.0);
const int INF = 1e9 + 47;
const long long LINF = 1LL * INF * INF;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
string s;
cin >> n >> s;
if (n % 2) {
bool ok = 0;
for (int i = (0); i < (n); ++i)
if ((i % 2 == 0) && (s[i] - '0') % 2 == 1) ok = 1;
cout << 2 - ok << endl;
} else {
bool ok = 0;
for (int i = (0); i < (n); ++i)
if (i % 2 && (s[i] - '0') % 2 == 0) ok = 1;
cout << 1 + ok << endl;
}
}
cerr << "Time elapsed: " << clock() / (double)CLOCKS_PER_SEC << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q, x, y;
pair<int, int> a[30005], b[30005];
int posa[30005], posb[30005], match[30005];
long long dp[30005];
void updp(int bas) {
for (int i = bas; i <= n; i++) {
dp[i] = -200000000000000000;
if (match[i] != i)
dp[i] = max(dp[i], dp[i - 1] + 1ll * a[i].first * b[i].first);
if (i >= 2 && match[i] != i - 1 && match[i - 1] != i)
dp[i] = max(dp[i], dp[i - 2] + 1ll * a[i - 1].first * b[i].first +
1ll * a[i].first * b[i - 1].first);
if (i >= 3 && match[i] != i - 1 && match[i - 1] != i - 2 &&
match[i - 2] != i)
dp[i] = max(dp[i], dp[i - 3] + 1ll * a[i].first * b[i - 1].first +
1ll * a[i - 1].first * b[i - 2].first +
1ll * a[i - 2].first * b[i].first);
if (i >= 3 && match[i] != i - 2 && match[i - 1] != i &&
match[i - 2] != i - 1)
dp[i] = max(dp[i], dp[i - 3] + 1ll * a[i].first * b[i - 2].first +
1ll * a[i - 1].first * b[i].first +
1ll * a[i - 2].first * b[i - 1].first);
}
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].first);
for (int i = 1; i <= n; i++) scanf("%d", &b[i].first);
for (int i = 1; i <= n; i++) a[i].second = b[i].second = i;
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + n);
for (int i = 1; i <= n; i++) {
posb[b[i].second] = i;
posa[a[i].second] = i;
}
for (int i = 1; i <= n; i++) {
match[i] = posb[a[i].second];
}
updp(1);
while (q--) {
scanf("%d %d", &x, &y);
swap(match[posa[x]], match[posa[y]]);
updp(min(posa[x], posa[y]));
printf("%lld\n", dp[n]);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v(6);
for (int i = 0; i < 6; i++) cin >> v[i];
int suma = 0;
int minA = min(v[1], v[5]);
int maxA = max(v[1], v[5]);
int inicial = v[0] * 2 + 1;
for (int i = 0; i < minA; i++) {
suma += inicial;
inicial += 2;
}
if (maxA != minA) inicial--;
for (int i = minA; i < maxA; i++) {
suma += inicial;
}
minA = min(v[2], v[4]);
maxA = max(v[2], v[4]);
inicial = v[3] * 2 + 1;
for (int i = 0; i < minA; i++) {
suma += inicial;
inicial += 2;
}
if (maxA != minA) inicial--;
if (v[1] == v[5]) {
for (int i = minA; i < maxA; i++) {
suma += inicial;
}
}
cout << suma << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool flag[100000005];
int main() {
long long n, m, sum, b, t_sqrt, t, b_sq;
while (cin >> n >> m) {
sum = 0;
memset(flag, 0, sizeof(flag));
for (b = 1; b <= n; b++) {
sum += min(m * 2, b * b * 2);
b_sq = b * b;
for (t_sqrt = b - 1; t_sqrt >= 0; t_sqrt--) {
t = t_sqrt * t_sqrt;
if (b_sq - t > m) break;
if (flag[b - t_sqrt]) sum--;
flag[b - t_sqrt] = true;
if (flag[b + t_sqrt]) sum--;
flag[b + t_sqrt] = true;
}
}
cout << sum << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2")
const long long MOD = 1e9 + 7;
const double PI = acos(-1);
long long add(long long x, long long y) {
long long res = x + y;
return (res >= MOD ? res - MOD : res);
}
long long mul(long long x, long long y) {
long long res = x * y;
return (res >= MOD ? res % MOD : res);
}
long long sub(long long x, long long y) {
long long res = x - y;
return (res < 0 ? res + MOD : res);
}
long long power(long long a, long long b, long long m = MOD) {
long long ans = 1;
a = a % m;
while (b > 0) {
if (b & 1) ans = (1ll * a * ans) % m;
b >>= 1;
a = (1ll * a * a) % m;
}
return ans;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long x, long long y) { return (x * y) / gcd(x, y); }
bool isprime(long long n) {
if (n < 2) return 0;
long long i = 2;
while (i * i <= n) {
if (n % i == 0) return 0;
i++;
}
return 1;
}
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
double distform(long long x, long long y, long long z, long long w) {
return sqrt(1. * pow(x - z, 2) + 1. * pow(y - w, 2));
}
long long dx[] = {-1, 1, 0, 0, -1, 1, 1, -1};
long long dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
const long long MAXN = 2e5 + 10;
const long long inf = 1e18;
template <typename T, typename T1>
T amax(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T &a, T1 b) {
if (b < a) a = b;
return a;
}
long long intlog(double base, double x) {
return (long long)(log(x) / log(base));
}
bool isvalid(long long x, long long y, long long n, long long m) {
return x >= 0 and x < n and y >= 0 and y < m;
}
template <typename T>
void read(T &x) {
for (long long i = 0; i < ((long long)(x).size()); ++i) cin >> x[i];
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
read(a);
sort(a.begin(), a.end());
unordered_map<long long, long long> diff;
for (long long i = 1; i < n; ++i) {
diff[a[i] - a[i - 1]]++;
}
if (((long long)(diff).size()) > 2) {
cout << 0 << endl;
return;
}
long long minn = inf;
long long diffatmin;
long long other = 1;
for (auto &x : diff) {
if (minn > x.second) {
minn = x.second;
diffatmin = x.first;
}
if (minn == x.second) {
if (diffatmin < x.first) diffatmin = x.first;
}
}
for (auto &x : diff) {
if (x.first == diffatmin) continue;
other = x.first;
}
if (((long long)(diff).size()) > 1 and minn > 1) {
cout << 0 << endl;
return;
}
{
cerr << " ["
<< "(diffatmin % 2 != 0)"
<< ": " << (diffatmin % 2 != 0) << "]\n";
}
{
cerr << " ["
<< "(diffatmin / 2 != other)"
<< ": " << (diffatmin / 2 != other) << "]\n";
}
{
cerr << " ["
<< "(other != 0)"
<< ": " << (other != 0) << "]\n";
}
if (((long long)(diff).size()) > 1 and
(diffatmin % 2 != 0 or diffatmin / 2 != other or other == 0)) {
cout << 0 << endl;
return;
}
if (((long long)(diff).size()) == 2) {
cout << 1 << endl;
for (long long i = 1; i < n; ++i) {
if (a[i] - a[i - 1] == diffatmin) {
cout << a[i - 1] + diffatmin / 2 << endl;
return;
}
}
}
if (a.size() == 1) {
cout << -1 << endl;
return;
}
bool ok = false;
bool x = ((a[1] - a[0]) % 2 == 0);
ok = ((long long)(a).size()) == 2 and ((a[1] - a[0]) % 2 == 0);
if (diff.begin()->first == 0) {
cout << 1 << endl;
cout << a[0] << endl;
return;
}
cout << 2 + ok << endl;
cout << a[0] - diff.begin()->first << " ";
if (ok) {
cout << a[0] + (a[1] - a[0]) / 2 << " ";
}
cout << a[n - 1] + diff.begin()->first << " ";
return;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
set<long long int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q;
cin >> q;
while (q--) {
v.clear();
int n, r;
cin >> n >> r;
int maxi = -1;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.insert(x);
}
long long int cnt = 0;
long long int ans = 0;
for (auto it = v.rbegin(); it != v.rend(); it++) {
long long int i = *it;
if (i - cnt * r > 0ll) {
ans++;
cnt++;
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, c, ar[300005];
vector<char> vr;
int main() {
cin >> n;
for (int i = 1; i < n + 1; i++) cin >> ar[i];
long long st = 0;
for (int i = n; i >= 1; i--) {
if (ar[i]) {
st = i;
break;
}
}
long long tot = 0, diff = 0;
for (int i = st; i >= 1; i--) {
for (int j = 0; j < ar[i] - ar[i + 1] - diff; j++) {
for (int k = 0; k < i; k++) vr.push_back('a' + c % 26);
c++;
}
diff += ar[i] - ar[i + 1] - diff;
}
for (int i = 0; i < vr.size(); i++) cout << vr[i];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <int input_buf_size, int output_buf_size>
class FastIO {
char cbuf[input_buf_size + 1];
int icur = 0;
inline bool go_to_next_token() {
while (cbuf[icur] == ' ' || cbuf[icur] == '\n') icur++;
while (cbuf[icur] == 0) {
icur = 0;
if (fgets(cbuf, sizeof(cbuf), stdin) != cbuf) return false;
while (cbuf[icur] == ' ' || cbuf[icur] == '\n') icur++;
}
return true;
}
public:
string readString() {
assert(go_to_next_token());
string ans;
while (cbuf[icur] != ' ' && cbuf[icur] != '\n' && cbuf[icur] != 0)
ans.push_back(cbuf[icur++]);
ans.shrink_to_fit();
return ans;
}
template <class int_type>
int_type readInt() {
assert(go_to_next_token());
int_type x = 0;
bool m = cbuf[icur] == '-';
if (m) icur++;
while ('0' <= cbuf[icur] && cbuf[icur] <= '9') {
x *= 10;
x += (cbuf[icur] - '0');
icur++;
}
if (m) x = -x;
return x;
}
bool seekEof() { return !go_to_next_token(); }
private:
char obuf[output_buf_size + 1];
int ocur = 0;
inline void write_string(const char *str, size_t sz = 0) {
if (sz == 0) sz = strlen(str);
if (ocur + sz > output_buf_size) {
fputs(obuf, stdout);
fputs(str, stdout);
ocur = 0;
obuf[0] = 0;
return;
}
strcpy(obuf + ocur, str);
ocur += sz;
obuf[ocur] = 0;
}
public:
template <class int_type>
void writeInt(int_type x, bool sp = true) {
char buf[20];
int c = 0;
if (x < 0) {
buf[c++] = '-';
x = -x;
}
int s = c;
if (x == 0) {
buf[c++] = '0';
}
while (x > 0) {
buf[c++] = (x % 10) + '0';
x /= 10;
}
for (int i = 0; 2 * i < c - s; i++) {
swap(buf[s + i], buf[c - 1 - i]);
}
buf[c] = 0;
write_string(buf, c);
if (sp) write_string(" ", 1);
}
void writeString(string s, bool space = true) {
write_string(s.c_str(), s.size());
if (space) write_string(" ", 1);
}
void writeEndl() { write_string("\n", 1); }
void flush() {
fputs(obuf, stdout);
ocur = 0;
obuf[0] = 0;
}
private:
bool lflush;
public:
FastIO(bool local_flush) {
obuf[0] = 0;
lflush = local_flush;
}
~FastIO() { fputs(obuf, stdout); }
};
FastIO<10000000, 10000000> IO(true);
const int upper_inf = numeric_limits<int>::max();
const int lower_inf = numeric_limits<int>::min();
const string task = "DBG";
const int N = 1e6 + 9;
const int M = 1e9 + 7;
auto ans = 0;
void init();
void reset();
void input();
void solve();
void ouput();
int tester(int nT);
int main() {
init();
reset();
input();
solve();
ouput();
return 0;
}
void init() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
void reset() {}
int n, a[N];
string s;
void input() { s = IO.readString(); }
void solve() {
n = (int)s.size();
for (int i = 0; i < n - 1; i++)
a[i] = (s[i] == s[i + 1]), a[i] += i ? a[i - 1] : 0;
int q = IO.readInt<int>();
while (q--) {
int l = IO.readInt<int>();
int r = IO.readInt<int>();
IO.writeInt<int>(a[--r - 1] - a[--l - 1]);
IO.writeEndl();
}
}
void ouput() {}
void gen() {
srand(time(NULL));
ofstream fi((task + ".INP").c_str());
fi.close();
}
int checker() { return 0; }
int tester(int nT) {
for (int iT = 1; iT <= nT; iT++) {
cerr << "Test " << iT << ": ";
gen();
clock_t t0 = clock();
init();
reset();
input();
solve();
clock_t t1 = clock();
int temp = checker();
if (temp == ans)
cerr << "Passed";
else
return cerr << "Wrong, answer must be " << temp << ", not " << ans, 1;
fprintf(stderr, " - %.4lfs.\n", (double)(t1 - t0) / 1000);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int dem = 0, n;
string s = "";
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == s[i + 1]) dem++;
}
cout << dem;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 200010, kM = 5;
int n, q;
char s[kN];
struct State {
int m[kM][kM];
State() {
for (int i = 0; i < kM; ++i) {
for (int j = 0; j < kM; ++j) m[i][j] = kN;
}
}
State operator*(const State& b) const {
State a(*this), res;
for (int i = 0; i < kM; ++i) {
for (int j = 0; j < kM; ++j) {
for (int k = 0; k < kM; ++k)
res.m[i][j] = min(res.m[i][j], a.m[i][k] + b.m[k][j]);
}
}
return res;
}
} tree[kN << 2];
void build(int l, int r, int root) {
if (l == r) {
tree[root].m[0][0] = 0;
tree[root].m[1][1] = 0;
tree[root].m[2][2] = 0;
tree[root].m[3][3] = 0;
tree[root].m[4][4] = 0;
if (s[l] == '2') {
tree[root].m[0][0] = 1;
tree[root].m[0][1] = 0;
} else if (s[l] == '0') {
tree[root].m[1][1] = 1;
tree[root].m[1][2] = 0;
} else if (s[l] == '1') {
tree[root].m[2][2] = 1;
tree[root].m[2][3] = 0;
} else if (s[l] == '7') {
tree[root].m[3][3] = 1;
tree[root].m[3][4] = 0;
} else if (s[l] == '6') {
tree[root].m[3][3] = 1;
tree[root].m[4][4] = 1;
}
return;
}
int mid = (l + r) >> 1;
build(l, mid, root << 1);
build(mid + 1, r, root << 1 | 1);
tree[root] = tree[root << 1] * tree[root << 1 | 1];
}
State query(int L, int R, int l, int r, int root) {
if (L == l && r == R) {
return tree[root];
}
int mid = (l + r) >> 1;
if (R <= mid)
return query(L, R, l, mid, root << 1);
else if (L > mid)
return query(L, R, mid + 1, r, root << 1 | 1);
else
return query(L, mid, l, mid, root << 1) *
query(mid + 1, R, mid + 1, r, root << 1 | 1);
}
void getData() { scanf("%d%d%s", &n, &q, (s + 1)); }
void solve() {
int l, r;
build(1, n, 1);
while (q--) {
scanf("%d%d", &l, &r);
int ans = query(l, r, 1, n, 1).m[0][4];
if (ans == kN) ans = -1;
printf("%d\n", ans);
}
}
int main() {
getData();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
struct edge {
int star, to;
int w;
};
struct query {
int edgeIndex, queryIndex;
};
struct cancel {
int rootAPos, rootBPos;
int AHigh, BHigh;
};
int n, m, q;
int root[N], high[N];
bool ans[N];
int b[N];
edge Edge[N];
query Query[N];
cancel Cancel[N];
inline bool mmp(int a, int b);
inline bool cnm(const query &a, const query &b);
inline int seekRoot(int x);
inline int seekRootCompreesion(int x);
inline void combine(int x, int y);
int main() {
scanf("%d %d", &n, &m);
for (register int i = 1; i < m + 1; i++) {
scanf("%d %d %d", &Edge[i].star, &Edge[i].to, &Edge[i].w);
b[i] = i;
}
scanf("%d", &q);
int queryNum = 0;
for (register int i = 0; i < q; i++) {
int len;
scanf("%d", &len);
for (register int j = 0; j < len; j++) {
int temp1;
scanf("%d", &temp1);
Query[queryNum++] = {temp1, i};
}
}
sort(Query, Query + queryNum, cnm);
for (register int i = 1; i < n + 1; i++) root[i] = i;
sort(b + 1, b + m + 1, mmp);
int i = 1, j = 0;
while (i <= m && j < queryNum) {
for (; Edge[b[i]].w < Edge[Query[j].edgeIndex].w; i++) {
int rootA = seekRootCompreesion(Edge[b[i]].star);
int rootB = seekRootCompreesion(Edge[b[i]].to);
if (rootA != rootB) combine(rootA, rootB);
}
int target = Edge[b[i]].w;
while (j < queryNum && Edge[Query[j].edgeIndex].w == target) {
int cancelNum = 0;
for (int k = Query[j].queryIndex;
Query[j].queryIndex == k && Edge[Query[j].edgeIndex].w == target;
j++) {
if (ans[k]) continue;
edge &e = Edge[Query[j].edgeIndex];
int rootA = seekRoot(e.star);
int rootB = seekRoot(e.to);
if (rootA == rootB) {
ans[k] = true;
} else {
Cancel[cancelNum++] = {rootA, rootB, high[rootA], high[rootB]};
combine(rootA, rootB);
}
}
for (register int _ = cancelNum - 1; _ >= 0; _--) {
root[Cancel[_].rootAPos] = Cancel[_].rootAPos;
root[Cancel[_].rootBPos] = Cancel[_].rootBPos;
high[Cancel[_].rootAPos] = Cancel[_].AHigh;
high[Cancel[_].rootBPos] = Cancel[_].BHigh;
}
}
}
for (register int i = 0; i < q; i++) puts(ans[i] ? "NO" : "YES");
return 0;
}
inline int seekRoot(int x) {
while (x != root[x]) x = root[x];
return x;
}
inline int seekRootCompreesion(int x) {
if (root[x] == x)
return x;
else
return root[x] = seekRootCompreesion(root[x]);
}
inline bool mmp(int a, int b) { return Edge[a].w < Edge[b].w; }
inline bool cnm(const query &a, const query &b) {
return Edge[a.edgeIndex].w < Edge[b.edgeIndex].w ||
(Edge[a.edgeIndex].w == Edge[b.edgeIndex].w &&
a.queryIndex < b.queryIndex);
}
inline void combine(int x, int y) {
if (high[x] > high[y])
root[y] = x;
else {
root[x] = y;
if (high[x] == high[y]) ++high[y];
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int g[6][6];
int i, j;
int ans = 0;
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) cin >> g[i][j];
}
int a, b, c, d, e;
for (a = 0; a < 5; a++) {
for (b = 0; b < 5; b++) {
for (c = 0; c < 5; c++) {
for (d = 0; d < 5; d++) {
for (e = 0; e < 5; e++) {
if (a == b || a == c || a == d || a == e)
;
else if (b == c || b == d || b == e)
;
else if (c == d || c == e)
;
else if (d == e)
;
else {
int tmp = (g[b][a] + g[a][b]) + (g[c][b] + g[b][c]) +
2 * (g[d][c] + g[c][d]) + 2 * (g[e][d] + g[d][e]);
if (ans < tmp) ans = tmp;
}
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
int main() {
int n;
scanf("%d", &n);
if (n % 2 == 0)
printf("-1\n");
else {
for (int i = 0; i < n; ++i) printf("%d ", i);
printf("\n");
for (int i = 0; i < n; ++i) printf("%d ", i);
printf("\n");
for (int i = 0; i < n; ++i) printf("%d ", (i + i) % n);
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long t = 1;
void solve() {
long long int n, c = 0, t = 0;
cin >> n;
c = c + n / 100;
n = n % 100;
if (n / 20 >= 1) {
t = n / 20;
c += n / 20;
n = n - t * 20;
t = 0;
}
if (n / 10 >= 1) {
t = n / 10;
c += t;
n = n - t * 10;
t = 0;
}
if (n / 5 >= 1) {
t = n / 5;
c += t;
n -= t * 5;
t = 0;
}
if (n >= 1) {
t = n;
c += t;
t = 0;
}
cout << c;
}
int main() {
int i;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, bool>> g[101234];
vector<pair<int, bool>> p[2];
vector<bool> used[2];
vector<char> state(101234, 0);
bool draw, win, lose;
bool dfs(int pos) {
state[pos] = 1;
for (auto i : g[pos]) {
if (state[i.first] == 0) {
if (dfs(i.first) == 1) return 1;
} else if (state[i.first] == 1) {
return 1;
}
}
state[pos] = 2;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
p[0].resize(101234);
p[1].resize(101234);
used[1].resize(101234);
used[0].resize(101234);
int n, m, x, t;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
for (int j = 0; j < x; j++) {
cin >> t;
g[i].emplace_back(t - 1, 0);
g[i].emplace_back(t - 1, 1);
}
}
pair<int, bool> start;
cin >> start.first;
start.first--;
start.second = 0;
if (dfs(start.first)) draw = 1;
queue<pair<int, bool>> q;
q.push(start);
pair<int, bool> finish;
while (!q.empty()) {
auto v = q.front();
q.pop();
if (v.second && g[v.first].size() == 0) {
win = 1;
finish = v;
break;
}
for (auto qwe : g[v.first]) {
if (v.second != qwe.second && !used[qwe.second][qwe.first]) {
q.push(qwe);
used[qwe.second][qwe.first] = 1;
p[qwe.second][qwe.first] = v;
}
}
}
vector<int> ans;
bool tmp;
if (win) {
while (finish != start) {
ans.push_back(finish.first);
finish = p[finish.second][finish.first];
}
ans.push_back(finish.first);
reverse(ans.begin(), ans.end());
cout << "Win" << endl;
for (auto qwe : ans) {
cout << qwe + 1 << " ";
}
} else if (draw) {
cout << "Draw";
} else {
cout << "Lose";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool isPowerOfTwo(int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
void asquare() {
long long n, c = 0, ans = LONG_LONG_MAX;
cin >> n;
string sn;
if (isPowerOfTwo(n) == true)
cout << "0\n";
else {
long long j = 0, k = 0, nn = 1;
string s = to_string(n);
for (int i = 0; i <= 60; i++) {
nn = (long long)pow(2, i);
sn = to_string(nn);
c = 0, j = 0, k = 0;
bool bb;
while (j != s.length() && k != sn.length()) {
if (s[j] == sn[k]) {
j++;
k++;
bb = true;
} else {
j++;
c++;
bb = false;
}
}
if (bb = true) {
if (j == s.length()) {
k--;
c += sn.length() - k - 1;
} else if (k == sn.length()) {
j--;
c += s.length() - j - 1;
}
} else {
k--;
c += sn.length() - k - 1;
}
if (c == 1) {
ans = 1;
break;
} else
ans = min(ans, c);
}
cout << ans << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
asquare();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, m, val[10005];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < (n); i++) cin >> val[i];
if (n % 2 == 0)
cout << 0 << endl;
else {
if (n == 1)
cout << ((val[0]) < (m * k) ? (val[0]) : (m * k)) << endl;
else {
if (m < (n / 2 + 1))
cout << 0 << endl;
else {
long long b = val[0];
for (int i = 2; i < n; i += 2) b = ((b) < (val[i]) ? (b) : (val[i]));
b = ((b) < ((m / (n / 2 + 1)) * k) ? (b) : ((m / (n / 2 + 1)) * k));
cout << b << endl;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
void swap(long long *xp, long long *yp) {
long long temp = *xp;
*xp = *yp;
*yp = temp;
}
const long long maxn = 1e5 + 1;
void print(vector<long long> v) {
long long i, j, n = v.size();
for (i = 0; i < n; i++) {
cout << v[i] << " ";
}
cout << "\n";
}
void scan(vector<long long> &v, long long n) {
for (long long i = 0; i < n; i++) cin >> v[i];
}
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); }
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y / 2;
x = (x * x) % mod;
}
return res % mod;
}
long long modinv(long long x) { return power(x, mod - 2) % mod; }
vector<bool> prime(maxn, true);
void sieve() {
long long n = maxn;
prime[0] = false;
prime[1] = false;
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;
}
}
}
int main() {
long long int i, j, inc, dec, t, r;
long long int c, d, e, temp, m, p, w, k, x, y, sum, pre, temp2, mid, n, low,
high, ans;
t = 1;
n = 1;
while (t--) {
cin >> n;
string s;
cin >> s;
vector<vector<long long> > dp(26, vector<long long>(n + 1, 0));
for (i = 0; i < n; i++) {
for (j = 0; j < 26; j++) {
sum = 0;
for (k = i; k < n; k++) {
if (s[k] != 'a' + j) {
sum++;
}
dp[j][sum] = max(dp[j][sum], k - i + 1);
}
}
}
for (i = 1; i <= n; i++) {
for (j = 0; j < 26; j++) {
dp[j][i] = max(dp[j][i], dp[j][i - 1]);
}
}
long long q;
cin >> q;
while (q--) {
char ch;
cin >> m >> ch;
long long ind = ch - 'a';
ans = dp[ind][m];
cout << ans << "\n";
;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
string s;
vector<pair<int, int> > ops;
void Rev(int l, int r) {
ops.push_back({l + 1, r + 1});
reverse(s.begin() + l, s.begin() + r + 1);
}
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k >> s;
int cnt = n / 2;
for (int i = 0; i < n and cnt; i++) {
if (s[i] != '(') {
for (int j = i + 1; j < n; j++) {
if (s[j] == '(') {
Rev(i, j);
break;
}
}
}
if (k > 1) {
if (s[i + 1] != ')') {
for (int j = i + 2; j < n; j++) {
if (s[j] == ')') {
Rev(i + 1, j);
break;
}
}
}
k--;
i++;
cnt--;
continue;
}
cnt--;
}
cout << ops.size() << endl;
for (auto it : ops) cout << it.first << " " << it.second << endl;
ops.clear();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 100;
const int NN = 1272727;
struct Node {
int sz, val, flag, mx;
Node *ls, *rs, *fa;
} buf[NN];
inline char gchar() {
static char fjf[2020], *a_st = fjf, *a_ed = fjf;
if (a_st == a_ed) {
int len = fread(fjf, 1, 2020, stdin);
if (!len) return -1;
a_st = fjf, a_ed = fjf + len;
}
return *(a_st++);
}
inline bool gn(int &first) {
char c, sg = 0;
while (c = gchar(), (c < '0' || '9' < c) && c != '-' && ~c)
;
if (!~c) return false;
if (c == '-') sg = 1, c = gchar();
for (first = 0; '0' <= c && c <= '9'; c = gchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
return true;
}
int used, ans, cnt, F;
struct Splay_Tree {
Node *root, *NIL;
Node *create_node(int first) {
Node *node = &buf[used++];
node->sz = 1;
node->val = first;
node->flag = 0;
node->mx = first;
node->ls = node->rs = node->fa = NIL;
return node;
}
void init() {
used = 0;
NIL = create_node(0);
NIL->sz = 0;
NIL->mx = NIL->val = 0;
NIL->flag = 0;
Node *first = create_node(0);
Node *second = create_node(inf);
first->rs = second;
second->fa = first;
root = first;
update(first);
}
void update(Node *first) {
first->sz = first->ls->sz + first->rs->sz + 1;
first->mx = first->val;
if (first->rs != NIL) first->mx = max(first->mx, first->rs->mx);
}
void zig(Node *first) {
Node *second = first->rs, *p = first->fa;
first->rs = second->ls;
second->ls->fa = first;
second->ls = first;
first->fa = second;
second->fa = p;
if (p == NIL)
root = second;
else if (p->ls == first)
p->ls = second;
else
p->rs = second;
update(first);
}
void zag(Node *first) {
Node *second = first->ls, *p = first->fa;
first->ls = second->rs;
second->rs->fa = first;
second->rs = first;
first->fa = second;
second->fa = p;
if (p == NIL)
root = second;
else if (p->rs == first)
p->rs = second;
else
p->ls = second;
update(first);
}
void splay(Node *first, Node *g) {
Node *second, *z;
while (first->fa != g) {
second = first->fa;
z = second->fa;
if (z == g) {
if (first == second->rs)
zig(second);
else
zag(second);
} else if (second == z->rs) {
if (first == second->rs)
zig(z), zig(second);
else
zag(second), zig(z);
} else {
if (first == second->rs)
zig(second), zag(z);
else
zag(z), zag(second);
}
}
update(first);
}
void push_down(Node *u) {
if (!(u->flag)) return;
u->ls->val += u->flag;
u->rs->val += u->flag;
u->ls->mx += u->flag;
u->rs->mx += u->flag;
u->ls->flag += u->flag;
u->rs->flag += u->flag;
u->flag = 0;
}
Node *find(Node *first, int k) {
push_down(first);
if (k <= first->ls->sz) return find(first->ls, k);
if (k == first->ls->sz + 1) return first;
return find(first->rs, k - first->ls->sz - 1);
}
void insert(int k, int val) {
Node *first = create_node(val);
Node *z = find(root, k);
Node *second = find(root, k + 1);
splay(z, NIL);
splay(second, z);
second->ls = first;
first->fa = second;
update(second);
update(z);
}
void remove(int k) {
Node *z = find(root, k), *second = find(root, k + 2);
splay(z, NIL);
splay(second, z);
second->ls = NIL;
update(second);
update(z);
}
void add(int l, int r) {
Node *z = find(root, l);
Node *second = find(root, r + 2);
splay(z, NIL);
splay(second, z);
Node *first = second->ls;
first->flag++;
first->val++;
first->mx++;
}
int FF(Node *u, int V) {
push_down(u);
if (u->ls->sz and u->ls->mx >= V) return FF(u->ls, V);
cnt += u->ls->sz;
if (u->val >= V) {
return cnt;
}
cnt++;
return FF(u->rs, V);
}
int FIND(int P) {
cnt = 0;
return FF(root, P);
}
} Splay;
int main() {
Splay.init();
int n;
gn(n);
int ans = 0, fl = 1;
for (int i = 1; i <= n; i++) {
if (fl) Splay.insert(ans + 1, inf);
fl = 0;
int l, r;
gn(l);
gn(r);
int st = Splay.FIND(l);
int ed = Splay.FIND(r);
if (ed > ans) {
ans++;
fl = 1;
}
Splay.remove(ed);
if (ed > st) Splay.add(st, ed - 1);
Splay.insert(st, l);
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100010;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> v(n);
vector<int> freq(101);
for (int i = 0; i < n; i++) {
cin >> v[i];
++freq[v[i]];
}
int high = 0, count = 0, ind;
for (int i = 1; i <= 100; i++) {
if (freq[i] > high) {
high = freq[i];
ind = i;
count = 0;
} else if (freq[i] == high) {
count = 1;
}
}
if (count) {
cout << n << endl;
return 0;
}
vector<int> c;
int ans = 0;
for (int i = 1; i < 100; i++) {
if (i == ind) continue;
c.assign(2 * n + 2, -2);
int a = n;
c[a] = -1;
for (int j = 0; j < n; j++) {
if (v[j] == ind) ++a;
if (v[j] == i) --a;
if (c[a] >= -1) {
ans = max(ans, j - c[a]);
} else {
c[a] = j;
}
}
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, in = 0, im = 0;
cin >> n >> m;
vector<long long> a, b;
for (long long i = 0; i < n / 9; i++) {
cout << 90;
}
cout << 9 << endl;
for (long long i = 0; i < n / 9; i++) cout << 90;
cout << 91 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 6;
int n;
int A[maxn], B[maxn];
bool vis[maxn];
vector<int> pre[maxn + 1];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
A[i]--;
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
vector<int> q;
q.push_back(i);
{
int x = A[i];
while (x != i) {
q.push_back(x);
vis[x] = 1;
x = A[x];
}
}
if (q.size() & 1) {
for (int j = 0, x = 0; j < q.size();
++j, x = (x + (q.size() + 1) / 2) % q.size()) {
B[q[x]] = q[(x + (q.size() + 1) / 2) % q.size()];
}
} else {
if (pre[q.size()].size() == 0) {
pre[q.size()] = q;
} else {
for (int j = 0; j < q.size(); ++j) {
B[q[j]] = pre[q.size()][j];
B[pre[q.size()][j]] = q[(j + 1) % q.size()];
}
pre[q.size()].clear();
}
}
}
}
for (int i = 0; i <= n; i++) {
if (!pre[i].empty()) {
cout << -1;
return 0;
}
}
for (int i = 0; i < n; i++) {
cout << B[i] + 1 << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 3e5 + 10;
double x1, x2;
int n;
pair<int, int> a[MAX_N];
int main() {
scanf("%d%lf%lf", &n, &x1, &x2);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a + 1, a + n + 1);
int pos;
for (pos = n; pos >= 1; --pos)
if (x2 / (n - pos + 1) <= a[pos].first) break;
for (int i = 1; i <= n; ++i) {
int p = x1 / a[i].first + 1;
while (p >= 2 && x1 / (p - 1) <= a[i].first) --p;
if (i + p - 1 < pos) {
puts("Yes");
printf("%d %d\n", p, n - pos + 1);
for (int j = i; j <= i + p - 1; ++j) printf("%d ", a[j].second);
puts("");
for (int j = pos; j <= n; ++j) printf("%d ", a[j].second);
return 0;
}
}
swap(x1, x2);
for (pos = n; pos >= 1; --pos)
if (x2 / (n - pos + 1) <= a[pos].first) break;
for (int i = 1; i <= n; ++i) {
int p = x1 / a[i].first + 1;
while (p >= 2 && x1 / (p - 1) <= a[i].first) --p;
if (i + p - 1 < pos) {
puts("Yes");
printf("%d %d\n", n - pos + 1, p);
for (int j = pos; j <= n; ++j) printf("%d ", a[j].second);
puts("");
for (int j = i; j <= i + p - 1; ++j) printf("%d ", a[j].second);
return 0;
}
}
puts("No");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[16];
bitset<2001> dp[1 << 16];
int ans[16];
int findAns(int m, int num, int n, int k) {
if (m == 0)
return 0;
else if (((num * k) <= 2000) && dp[m][num * k]) {
int i;
for (i = 0; i < n; i++) {
if (m & (1 << i)) ans[i]++;
}
findAns(m, num * k, n, k);
return 0;
}
int i;
for (i = 0; i < n; i++) {
if ((m & (1 << i)) && (num >= a[i]) && dp[m ^ (1 << i)][num - a[i]]) {
findAns(m ^ (1 << i), num - a[i], n, k);
return 0;
}
}
return 0;
}
priority_queue<pair<int, int> > H;
int main() {
int i;
int n, k;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
int j;
dp[0][0] = 1;
for (i = 1; i < (1 << n); i++) {
for (j = 0; j < n; j++) {
if (i & (1 << j)) dp[i] |= dp[i ^ (1 << j)] << a[j];
}
for (j = 2000 / k; j >= 0; j--) {
if (dp[i][j * k]) dp[i][j] = 1;
}
}
if (dp[(1 << n) - 1][1]) {
printf("YES\n");
findAns((1 << n) - 1, 1, n, k);
for (i = 0; i < n; i++) H.push(make_pair(ans[i], a[i]));
for (i = 0; i < n - 1; i++) {
pair<int, int> a = H.top();
H.pop();
pair<int, int> b = H.top();
H.pop();
printf("%d %d\n", a.second, b.second);
int s = a.second + b.second;
while ((s % k) == 0) s /= k, a.first--;
H.push(make_pair(a.first, s));
}
} else
printf("NO\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16000000")
using namespace std;
const int Inf = 1000000000;
const int Maxn = 100005;
int n, m, d;
vector<int> neigh[Maxn];
bool spec[Maxn];
int h[Maxn][2];
int res;
void Traverse(int v, int p) {
h[v][0] = h[v][1] = -Inf;
for (int i = 0; i < neigh[v].size(); i++) {
int u = neigh[v][i];
if (u == p) continue;
Traverse(u, v);
int cand = h[u][0] + 1;
if (cand > h[v][0])
h[v][1] = h[v][0], h[v][0] = cand;
else if (h[u][0] > h[v][1])
h[v][1] = cand;
}
if (spec[v]) {
if (h[v][0] < 0) h[v][0] = 0;
if (h[v][1] < 0) h[v][1] = 0;
}
}
void Calc(int v, int p, int ft) {
if (max(h[v][0], ft) <= d) res++;
for (int i = 0; i < neigh[v].size(); i++) {
int u = neigh[v][i];
if (u == p) continue;
if (h[v][0] == h[u][0] + 1)
Calc(u, v, max(ft, h[v][1]) + 1);
else
Calc(u, v, max(ft, h[v][0]) + 1);
}
}
int main() {
scanf("%d %d %d", &n, &m, &d);
while (m--) {
int s;
scanf("%d", &s);
spec[s] = true;
}
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
neigh[a].push_back(b);
neigh[b].push_back(a);
}
Traverse(1, 0);
Calc(1, 0, -Inf);
printf("%d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long m, i, ansx;
int ans;
void work(long long m, long long a, int step, long long x) {
if (!a) return;
if (m == 0) {
if (step > ans || (step == ans && x > ansx)) ans = step, ansx = x;
return;
}
for (; a * a * a > m; --a)
;
work(m - a * a * a, a, step + 1, x + a * a * a);
work(a * a * a - (a - 1) * (a - 1) * (a - 1) - 1, a - 1, step + 1,
x + (a - 1) * (a - 1) * (a - 1));
}
int main() {
scanf("%I64d\n", &m);
for (i = 1; i * i * i <= m; ++i)
;
work(m, i, 0, 0);
printf("%d %I64d\n", ans, ansx);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int buf_size = 1e5 + 5;
char buf[buf_size], *S, *T;
inline char gc() {
if (S == T) T = (S = buf) + fread(buf, 1, buf_size, stdin);
return S != T ? *(S++) : EOF;
}
inline int in() {
int x = 0, f = 1;
char c = gc();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = gc();
}
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = gc();
return x * f;
}
const int N = 2e6 + 5, mod = 1e9 + 7;
int q, x, y, n = 2000000, ans;
int inv[N], fac[N], finv[N];
int pri[N], pc, c[N];
int p[N];
bool inp[N];
int a[105], ac;
inline int add(const int &a, const int &b) {
return a + b >= mod ? a + b - mod : a + b;
}
inline int mul(const int &a, const int &b) { return 1ll * a * b % mod; }
inline int C(const int &a, const int &b) {
return mul(fac[a], mul(finv[b], finv[a - b]));
}
int main() {
inv[1] = fac[0] = fac[1] = finv[0] = finv[1] = 1;
for (int i = 2; i <= n; i++) {
inv[i] = mul(mod - mod / i, inv[mod % i]);
fac[i] = mul(fac[i - 1], i);
finv[i] = mul(finv[i - 1], inv[i]);
}
for (int i = 2; i <= n; i++) {
if (!inp[i]) pri[++pc] = i, c[i] = i;
for (int j = 1; j <= pc && i * pri[j] <= n; j++) {
inp[i * pri[j]] = 1;
c[i * pri[j]] = pri[j];
if (i % pri[j] == 0) break;
}
}
p[0] = 1;
for (int i = 1; i <= n; i++) p[i] = mul(p[i - 1], 2);
q = in();
while (q--) {
x = in(), y = in();
ac = 0, ans = 0;
int res = 1;
while (x > 1) {
a[++ac] = c[x];
x /= c[x];
}
for (int i = 1, j; i <= ac; i = j + 1) {
j = i;
while (j + 1 <= ac && a[j + 1] == a[i]) j++;
res = mul(res, C(j - i + y, y - 1));
}
ans = mul(res, p[y - 1]);
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
string s, t;
cin >> s >> t;
int count = 0;
int i = s.length() - 1;
int j = t.length() - 1;
while (s[i] == t[j] && i >= 0 && j >= 0) {
i -= 1;
j -= 1;
count += 1;
}
cout << (s.length() + t.length() - 2 * count);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int arr[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
sort(arr, arr + n);
int ans = n;
long long sum = 0;
for (int i = 0; i < n; ++i) {
if (sum > arr[i])
--ans;
else
sum += arr[i];
}
printf("%d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long f = 1, x = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
long long k, sum;
int n, ans[1000005];
signed main() {
n = read();
k = read();
if (k < (sum = 1ll * (n + 1) * n / 2)) return 0 & puts("-1");
for (int i = 1, l = 1, r = n; i <= n; i++) {
if (r <= i) {
ans[i] = r--;
continue;
}
if (sum + r - i <= k)
sum += r - i, ans[i] = r--;
else
ans[i] = l++;
}
printf("%lld\n", sum);
for (int i = 1; i <= n; i++) printf("%d ", i);
puts("");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
using namespace std;
const long long maxn = 1e5 + 12, inf = 1e9, LOG = 18, mod = 1e9 + 7,
block = 316;
int n, x, a[maxn], pos[maxn];
multiset<int> st;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
pos[x] = i;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
st.insert(i - pos[a[i]]);
}
for (int i = 0; i < n; i++) {
multiset<int>::iterator it = st.lower_bound(i);
x = 1e9;
if (it != st.end()) x = min(x, *it - i);
if (it != st.begin()) {
it--;
x = min(x, i - *it);
}
cout << x << endl;
it = st.find(i - pos[a[i]]);
st.erase(it);
st.insert(i - pos[a[i]] + n);
}
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 2000000000;
const int MAX = 30007;
const int MAX2 = 207;
const int BASE = 1000000000;
int n, k;
int A[MAX];
long long S[MAX];
long long R[MAX][MAX2];
long long M[MAX][MAX2][2];
long long Q[MAX2][7];
long long Sum(int l, int r) { return (S[r] - (l == 0 ? 0 : S[l - 1])); }
int main() {
cin >> n >> k;
for (int i = (1); i < (n + 1); ++i) cin >> A[i];
for (int i = (1); i < (n + 1); ++i) {
S[i] = A[i];
if (i > 0) S[i] += S[i - 1];
}
for (int i = (0); i < (MAX); ++i)
for (int j = (0); j < (MAX2); ++j) {
R[i][j] = -INF;
for (int t = (0); t < (2); ++t) M[i][j][t] = -INF;
}
for (int i = (0); i < (MAX2); ++i)
for (int j = (0); j < (7); ++j) Q[i][j] = -INF;
for (int i = (0); i < (7); ++i) Q[0][i] = -INF;
int res = -INF;
long long minS = 0;
long long maxS = 0;
long long minSS = INF;
long long maxSS = -INF;
for (int i = (1); i < (n + 1); ++i) {
maxSS = max(maxSS, S[i] - minS);
minSS = min(minSS, S[i] - maxS);
minS = min(minS, S[i]);
maxS = max(maxS, S[i]);
for (int cnt = (1); cnt < (k + 1); ++cnt) {
R[i][cnt] = max(R[i][cnt], R[i - 1][cnt]);
for (int j = (0); j < (2); ++j)
M[i][cnt][j] = max(M[i][cnt][j], M[i - 1][cnt][j]);
if (cnt == 1) {
M[i][cnt][0] = -minSS;
M[i][cnt][1] = maxSS;
R[i][cnt] = max(R[i][cnt], max(M[i][cnt][0], M[i][cnt][1]));
} else {
long long val1 = Q[cnt - 1][0] + S[i];
long long val2 = Q[cnt - 1][1] - S[i];
R[i][cnt] = max(R[i][cnt], max(val1, val2));
val1 = Q[cnt - 1][2];
val2 = Q[cnt - 1][3] - 2 * S[i];
M[i][cnt][0] = max(M[i][cnt][0], max(val1, val2));
val1 = Q[cnt - 1][4] + 2 * S[i];
val2 = Q[cnt - 1][5];
M[i][cnt][1] = max(M[i][cnt][1], max(val1, val2));
}
}
for (int cnt = (1); cnt < (k + 1); ++cnt) {
Q[cnt][0] = max(Q[cnt][0], M[i][cnt][0] - S[i]);
Q[cnt][1] = max(Q[cnt][1], M[i][cnt][1] + S[i]);
Q[cnt][2] = max(Q[cnt][2], M[i][cnt][0]);
Q[cnt][3] = max(Q[cnt][3], M[i][cnt][1] + 2 * S[i]);
Q[cnt][4] = max(Q[cnt][4], M[i][cnt][0] - 2 * S[i]);
Q[cnt][5] = max(Q[cnt][5], M[i][cnt][1]);
}
}
res = R[n][k];
cout << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
int times[45];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> m;
for (int i = 0; i < k; i++) cin >> times[i];
int s = 0;
for (int i = 0; i < k; i++) s += times[i];
sort(begin(times), begin(times) + k);
int currBest = 0;
for (int numSolves = 0; numSolves < n + 1; numSolves++) {
if (s * numSolves > m) break;
int score = 0;
score += numSolves * (k + 1);
int timeLeft = m - s * numSolves;
int numUnsolved = n - numSolves;
int i = 0;
while (timeLeft >= times[i] && i < k) {
score += min(timeLeft / times[i], numUnsolved);
timeLeft -= times[i] * min(timeLeft / times[i], numUnsolved);
i++;
}
currBest = max(score, currBest);
}
cout << currBest << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 74, OO = 0x3f3f3f3f;
class CAboutBacteria {
public:
void solve(istream& cin, ostream& cout) {
long long k, b, n, t;
cin >> k >> b >> n >> t;
long long m = 0, z = 1;
for (int i = 0; i < n; i++) {
z = (z * k) + b;
++m;
if (z > t) {
break;
}
}
if (t >= z)
m = n = 0;
else
--m;
cout << n - m;
}
};
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
CAboutBacteria solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1500 + 85 - 69;
vector<int> adj[maxn];
complex<long long int> P[maxn];
int vec[maxn][maxn], vecsz[maxn], down[maxn], ans[maxn], n, cmpvert;
inline long long int cross(complex<long long int> x, complex<long long int> y) {
return x.real() * y.imag() - x.imag() * y.real();
}
bool cmp(int i, int j) {
return cross(P[i] - P[cmpvert], P[j] - P[cmpvert]) > 0;
}
int rightmost(int id) {
int ret = vec[id][0];
for (int i = 0; i < vecsz[id]; i++) {
int val = vec[id][i];
if (P[val].real() > P[ret].real()) ret = val;
}
return ret;
}
int dfs_preprocess(int v, int p = -1) {
down[v] = 1;
for (auto u : adj[v])
if (u != p) down[v] += dfs_preprocess(u, v);
return down[v];
}
void dfs(int v, int vecid, int p = -1) {
int fv = rightmost(vecid);
ans[fv] = v;
int idtmp = find(vec[vecid], vec[vecid] + vecsz[vecid], fv) - vec[vecid];
swap(vec[vecid][idtmp], vec[vecid][vecsz[vecid] - 1]);
vecsz[vecid]--;
cmpvert = fv;
sort(vec[vecid], vec[vecid] + vecsz[vecid], cmp);
int ptr = 0;
for (int i = 0; i < ((int)(adj[v]).size()); i++)
if (adj[v][i] != p) {
int u = adj[v][i];
for (int j = ptr; j < ptr + down[u]; j++)
vec[vecid + 1][j - ptr] = vec[vecid][j];
vecsz[vecid + 1] = down[u];
ptr += down[u];
dfs(u, vecid + 1, v);
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int fi, se;
cin >> fi >> se;
fi--, se--;
adj[fi].push_back(se);
adj[se].push_back(fi);
}
for (int i = 0; i < n; i++) {
long long int xx, yy;
cin >> xx >> yy;
P[i] = complex<long long int>(xx, yy);
vec[0][vecsz[0]++] = i;
}
dfs_preprocess(0);
dfs(0, 0);
for (int i = 0; i < n; i++) cout << ans[i] + 1 << ' ';
cout << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, l;
cin >> n;
vector<int> tab;
for (long long int i = 0; i < n; ++i) {
l = 0;
cin >> x;
if (x <= 7)
tab.push_back(1);
else if (x % 7 == 0)
tab.push_back(x / 7);
else if (x % 6 == 0)
tab.push_back(x / 6);
else if (x % 5 == 0)
tab.push_back(x / 5);
else if (x % 4 == 0)
tab.push_back(x / 4);
else if (x % 3 == 0)
tab.push_back(x / 3);
else if (x % 2 == 0)
tab.push_back(x / 2);
else {
while ((x >= 7) && (x / 7 != 1)) {
x -= 7;
++l;
}
while ((x >= 6) && (x / 6 != 1)) {
x -= 6;
++l;
}
while ((x >= 5) && (x / 5 != 1)) {
x -= 5;
++l;
}
while ((x >= 4) && (x / 4 != 1)) {
x -= 4;
++l;
}
while ((x >= 3) && (x / 3 != 1)) {
x -= 3;
++l;
}
while ((x >= 2) && (x / 2 != 1)) {
x -= 2;
++l;
}
tab.push_back(l);
}
}
for (long long int i = 0; i < tab.size(); ++i) {
cout << tab[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long x) {
long long p = 1;
while (p <= x) p *= 10;
return x * (p - x - 1);
}
int main(int argc, char **argv) {
long long l, r;
cin >> l >> r;
long long res = max(f(l), f(r));
for (long long i = 5; i <= r; i *= 10)
if (l <= i) res = max(res, f(i));
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[20];
map<string, int> p;
string str[20];
int main() {
int i;
for (i = 10; i < 15; i++) {
cin >> a[i];
}
int n;
cin >> n;
str[10] = "S";
str[11] = "M";
str[12] = "L";
str[13] = "XL";
str[14] = "XXL";
for (i = 10; i < 15; i++) {
p[str[i]] = i;
}
for (i = 0; i < n; i++) {
string s;
cin >> s;
int ind = p[s];
for (int d = 0; d < 5; d++) {
if (a[ind + d] > 0) {
a[ind + d]--;
cout << str[ind + d] << endl;
break;
}
if (a[ind - d] > 0) {
a[ind - d]--;
cout << str[ind - d] << endl;
break;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
using D = double;
using ii = pair<int, int>;
using vi = vector<int>;
using vii = vector<ii>;
template <typename T>
T sqr(T a) {
return a * a;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T sgn(T a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
template <typename T>
T abs(T a) {
return a > 0 ? a : -a;
}
const D inf = 2e4;
const ld pi = acos((ld)-1);
const int N = 2e3 + 10;
const D eps = 0.000001;
int n;
int m;
struct p {
D x, y, z;
p(D xx, D yy, D zz) {
x = xx;
y = yy;
z = zz;
}
p() { x = y = z = 0; }
};
vector<p> v;
D f(D x, D y, D z) {
D cur = 0;
for (int i = 0; i < n; i++) {
cur = max(sqr(x - v[i].x) + sqr(y - v[i].y) + sqr(z - v[i].z), cur);
}
return cur;
}
pair<D, D> getz(D x, D y) {
D l = -inf;
D r = inf;
D len = 0;
while (r - l > eps) {
D m1 = l + (r - l) / 3;
D m2 = r - (r - l) / 3;
len = f(x, y, m1);
if ((len) > f(x, y, m2))
l = m1;
else
r = m2;
}
return make_pair(l, len);
}
pair<D, D> gety(D x) {
D l = -inf;
D r = inf;
D len = 0;
while (r - l > eps) {
D m1 = l + (r - l) / 3;
D m2 = r - (r - l) / 3;
len = getz(x, m1).second;
if (len > getz(x, m2).second)
l = m1;
else
r = m2;
}
return make_pair(l, len);
}
D getx() {
D l = -inf;
D r = inf;
while (r - l > eps) {
D m1 = l + (r - l) / 3;
D m2 = r - (r - l) / 3;
if (gety(m1).second > gety(m2).second)
l = m1;
else
r = m2;
}
return l;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
D x, y, z;
cin >> x >> y >> z;
v.push_back(p(x, y, z));
}
D X = getx();
D Y = gety(X).first;
D Z = getz(X, Y).first;
cout.setf(ios::fixed);
cout << setprecision(15) << X << ' ' << Y << ' ' << Z;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dd, mm, yy;
bool is18(int d, int m, int y) {
if (m > 12 || d > 31) return false;
if (d == 31 && (m == 9 || m == 4 || m == 6 || m == 11)) return false;
if (d > 29 && m == 2) return false;
if (d == 29 && m == 2 && y % 4) return false;
if (yy - y > 18) return true;
if (yy - y < 18) return false;
if (mm > m) return true;
if (mm < m) return false;
if (dd >= d) return true;
return false;
}
int main() {
int bd, bm, by;
char c;
cin >> dd >> c >> mm >> c >> yy;
cin >> bd >> c >> bm >> c >> by;
if (is18(bd, bm, by) || is18(bd, by, bm) || is18(bm, bd, by) ||
is18(bm, by, bd) || is18(by, bm, bd) || is18(by, bd, bm))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50005;
map<pair<int, int>, int> mp;
map<pair<int, int>, int> at;
map<long long, bool> used;
int fa[N], nd, x1, x2, ysghysgsygsh, y2;
int x[N], y[N], ans, n;
long long hsh[N];
pair<int, int> q[N];
int getid(int x, int y) {
if (mp.find(pair<int, int>(x, y)) == mp.end()) {
++nd;
fa[nd] = nd;
return mp[pair<int, int>(x, y)] = nd;
}
return mp[pair<int, int>(x, y)];
}
int get(int x) { return x == fa[x] ? x : fa[x] = get(fa[x]); }
void add(int x, int y) {
x = get(x);
y = get(y);
if (x != y) {
if (x < y) swap(x, y);
fa[x] = y;
}
}
void insert(int sx, int sy, int tx, int ty) {
if (pair<int, int>(sx, sy) > pair<int, int>(tx, ty))
swap(sx, tx), swap(sy, ty);
if (sx == tx && x1 < sx && sx < x2) {
if (ty <= ysghysgsygsh || sy >= y2) return;
int py1 = max(ysghysgsygsh, sy), py2 = min(y2, ty);
add(getid(sx, py1), getid(sx, py2));
}
if (sy == ty && ysghysgsygsh < sy && sy < y2) {
if (tx <= x1 || sx >= x2) return;
int px1 = max(x1, sx), px2 = min(x2, tx);
add(getid(px1, sy), getid(px2, sy));
}
}
void UPDans(int px, int py, int qx, int qy) {
if (px != -1 && py != -1) {
long long val = hsh[getid(px, py)];
if (used[val]) return;
used[val] = 1;
}
int flg = 0;
for (int i = (int)(1); i <= (int)(n); i++) {
int sx = x[i], sy = y[i], tx = x[i % n + 1], ty = y[i % n + 1];
if (sx != tx || sx <= qx) continue;
if ((sy <= qy) ^ (ty <= qy)) flg ^= 1;
}
ans += flg;
}
int main() {
scanf("%d%d%d%d", &x1, &y2, &x2, &ysghysgsygsh);
for (int i = (int)(x1 + 1); i <= (int)(x2 - 1); i++) getid(i, ysghysgsygsh);
for (int i = (int)(ysghysgsygsh + 1); i <= (int)(y2 - 1); i++) getid(x2, i);
for (int i = (int)(x2 - 1); i >= (int)(x1 + 1); i--) getid(i, y2);
for (int i = (int)(y2 - 1); i >= (int)(ysghysgsygsh + 1); i--) getid(x1, i);
int tmp = nd, top = 0, flg = 0;
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d%d", &x[i], &y[i]);
for (int i = (int)(1); i <= (int)(n); i++)
flg |= (x[i] < x1 || x[i] > x2 || y[i] < ysghysgsygsh || y[i] > y2);
if (!flg) return puts("1"), 0;
for (int i = (int)(1); i <= (int)(n); i++)
insert(x[i], y[i], x[i % n + 1], y[i % n + 1]);
for (int i = (int)(1); i <= (int)(tmp); i++)
if (get(i) != i) q[++top] = pair<int, int>(i, get(i));
if (!top)
UPDans(-1, -1, x1, ysghysgsygsh);
else {
for (int i = (int)(1); i <= (int)(top); i++) {
long long val = 1ll * i * i * i;
hsh[q[i].second + 1] ^= val;
hsh[q[i].first + 1] ^= val;
}
for (int i = (int)(1); i <= (int)(tmp); i++) hsh[i] ^= hsh[i - 1];
for (int i = (int)(x1 + 1); i <= (int)(x2 - 1); i++)
UPDans(i, ysghysgsygsh, i - 1, ysghysgsygsh);
for (int i = (int)(x1 + 1); i <= (int)(x2 - 1); i++)
UPDans(i, y2, i, y2 - 1);
for (int i = (int)(ysghysgsygsh + 1); i <= (int)(y2 - 1); i++)
UPDans(x2, i, x2 - 1, i - 1);
for (int i = (int)(ysghysgsygsh + 1); i <= (int)(y2 - 1); i++)
UPDans(x1, i, x1, i);
}
printf("%d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5 + 10;
const int MOD = 1e9 + 7;
int n, q;
long long A[mxn], ans[mxn], two[mxn];
vector<vector<pair<long long, int>>> Q(mxn);
void solve() {
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int l, x;
for (int i = 0; i < q; i++) {
cin >> l >> x;
Q[l].push_back({x, i});
}
two[0] = (long long)1;
for (int i = 1; i <= n; i++) {
two[i] = two[i - 1] << 1;
if (two[i] > MOD) {
two[i] %= MOD;
}
}
vector<long long> basis;
for (int l = 0; l < n; l++) {
long long a = A[l];
for (long long b : basis) {
a = min(a, a ^ b);
}
if (a) {
basis.push_back(a);
}
for (auto qry : Q[l + 1]) {
long long x = qry.first;
int i = qry.second;
for (long long b : basis) {
x = min(x, x ^ b);
}
if (x) {
ans[i] = 0;
} else {
ans[i] = two[l + 1 - basis.size()];
}
}
}
for (int i = 0; i < q; i++) {
cout << ans[i] << '\n';
}
}
int main() { solve(); }
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T>
constexpr T inf;
template <>
constexpr int inf<int> = 1e9;
template <>
constexpr ll inf<ll> = 1e18;
template <>
constexpr double inf<double> = 1e18;
constexpr double eps = 1e-9;
constexpr ll mod = 1e9 + 7;
int main() {
int n;
double T;
scanf("%d %lf", &n, &T);
vector<pair<double, double>> taps(n);
for (int i = 0; i < n; ++i) {
scanf("%lf", &taps[i].second);
}
for (int i = 0; i < n; ++i) {
scanf("%lf", &taps[i].first);
}
sort(begin(taps), end(taps));
double sum_temp = 0, vol = 0;
for (int i = 0; i < n; ++i) {
vol += taps[i].second;
sum_temp += taps[i].first * taps[i].second;
}
if (sum_temp / vol - T > eps) {
int i = n - 1;
while (vol > eps && i >= 0) {
double a = taps[i].second, t = taps[i].first;
double lb = 0, ub = a;
for (int lp = 0; lp < 100; ++lp) {
double mid = (lb + ub) / 2;
double ntemp = sum_temp - mid * t;
double nvol = vol - mid;
if (ntemp / nvol - T > eps) {
lb = mid;
} else {
ub = mid;
}
}
sum_temp -= lb * t;
vol -= lb;
if (abs(sum_temp / vol - T) < eps * 2) {
break;
}
i -= 1;
}
} else if (sum_temp / vol - T < -eps) {
int i = 0;
while (vol > eps && i < n) {
double a = taps[i].second, t = taps[i].first;
double lb = 0, ub = a;
for (int lp = 0; lp < 100; ++lp) {
double mid = (lb + ub) / 2;
double ntemp = sum_temp - mid * t;
double nvol = vol - mid;
if (ntemp / nvol - T < -eps) {
lb = mid;
} else {
ub = mid;
}
}
sum_temp -= lb * t;
vol -= lb;
i += 1;
if (abs(sum_temp / vol - T) < eps * 2) {
break;
}
}
}
if (fabs(sum_temp / vol - T) > 10 * eps || vol < eps) {
vol = 0;
}
cout << fixed << setprecision(9) << vol << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int isPrime(long long int n) {
long long int p = (long long int)sqrt(n);
for (long long int i = (2); i <= (p); i += (1))
if (n % i == 0) return 0;
return 1;
}
long long int pows(long long int b, long long int e) {
if (e == 0)
return 1;
else if (e % 2 == 0) {
long long int a = pow(b, e / 2);
return a * a;
} else {
long long int a = pow(b, e / 2);
return b * a * a;
}
}
long long int powm(long long int x, long long int y,
long long int m = 1000000007) {
x = x % m;
long long int res = 1;
while (y) {
if (y & 1) res = res * x;
res %= m;
y = y >> 1;
x = x * x;
x %= m;
}
return res;
}
long long int modInverse(long long int a, long long int m = 1000000007) {
return powm(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int T;
cin >> T;
while (T--) {
long long int n, m, i, j, k, x, y, z, f, p, q, g, l, r, w, h,
count = 0, count1 = 0, prod = 1, a, b, c, d, index, x1, x2, diff,
sum = 0, sum1 = 0, sum2 = 0, flag = 0, flag1 = 0, flag2 = 0;
string s, s1;
cin >> n >> k;
for (i = 0; i < k - 1; i++) {
s1 += "()";
}
for (i = 0; i < n / 2 - (k - 1); i++) {
s1 += '(';
}
for (i = 0; i < n / 2 - (k - 1); i++) {
s1 += ')';
}
cin >> s;
vector<pair<long long int, long long int>> v;
j = 0;
for (i = 0; i < n; i++) {
if (s[i] == s1[j]) {
j++;
continue;
} else if (s[i] != s1[j]) {
for (k = i + 1; k < n; k++) {
if (s[k] == s1[j]) {
p = k;
break;
}
}
j++;
v.push_back(make_pair(i + 1, p + 1));
reverse(s.begin() + i, s.begin() + p + 1);
}
}
cout << v.size() << "\n";
for (i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
if (n == 1) {
cout << 1 << ' ' << 0 << "\n";
return;
}
long long q = sqrt(n), p = n, mul = 1, count = 0, minm = INT_MAX, maxm = 0;
for (long long i = 2; i <= q; i++) {
if (n % i == 0) {
mul = mul * i;
long long count = 0;
while (n % i == 0) {
count++;
n = n / i;
}
minm = min(minm, count);
maxm = max(maxm, count);
}
}
if (n > 1) {
minm = min(1ll, minm);
maxm = max(1ll, maxm);
mul = mul * n;
}
long long ans = ceil(double(log2(maxm)));
if (minm == maxm && pow(2, ans) == maxm) {
ans = ans;
} else {
ans++;
}
cout << mul << ' ' << ans << "\n";
}
void init_code() {}
int main() {
init_code();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int x1, x2, y1, y2;
map<pair<int, int>, int> M;
int countX = 0, countY = 0;
for (int i = 0; i < 4; i++) {
cin >> x1 >> y1 >> x2 >> y2;
if ((x1 == x2) && (y1 != y2)) countY++;
if ((y1 == y2) && (x1 != x2)) countX++;
M[make_pair(x1, y1)]++;
M[make_pair(x2, y2)]++;
}
bool flag = ((countX == 2) && (countY == 2)) ? true : false;
map<pair<int, int>, int>::iterator itM;
for (itM = M.begin(); itM != M.end(); itM++)
if (flag &= (itM->second == 2) ? true : false)
continue;
else
break;
cout << ((flag) ? "YES" : "NO");
return (0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[n];
vector<pair<long long, long long> > v;
long long mx = -1;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
v.push_back({arr[i], i + 1});
if (mx < arr[i]) mx = arr[i];
}
sort(v.begin(), v.end());
long long count = 1, k = 0;
long long max = -1;
for (long long i = 0; i < n; i++) {
count = 0;
if (arr[i] == mx) {
while (arr[i] == mx) {
count++;
i++;
}
}
if (max < count) max = count;
}
cout << max << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100010;
int parent[20][max_n];
int depth[max_n];
int n, q;
vector<int> G[max_n];
void dfs(int v, int par, int d) {
depth[v] = d;
parent[0][v] = par;
for (auto u : G[v]) {
if (u != par) {
dfs(u, v, d + 1);
}
}
}
void init() {
dfs(1, -1, 0);
for (int k = 0; k < 19; k++) {
for (int i = 1; i <= n; i++) {
if (parent[k][i] < 0)
parent[k + 1][i] = -1;
else
parent[k + 1][i] = parent[k][parent[k][i]];
}
}
}
int LCA(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
for (int k = 0; k < 20; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v) return u;
for (int k = 19; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
int dis(int u, int v) { return depth[u] + depth[v] - 2 * depth[LCA(u, v)]; }
int res(int a, int b, int c) {
int x = dis(a, b), y = dis(b, c), z = dis(a, c);
int A = (x + y - z) / 2;
int B = (x + z - y) / 2;
int C = (y + z - x) / 2;
return max(max(A, B), C) + 1;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 2; i <= n; i++) {
int u;
scanf("%d", &u);
G[u].push_back(i);
G[i].push_back(u);
}
init();
for (int i = 0; i < q; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
printf("%d\n", res(a, b, c));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, ans = 0;
cin >> a >> b >> c;
long long a1[3] = {a, b, c};
long long m = *max_element(a1, a1 + 3);
if (a1[0] == m && a1[1] == m && a1[2] == m) {
cout << 0;
return 0;
}
if (a1[0] == m && a1[1] != m && a1[2] != m) {
ans += (a1[0] - 1) - a1[1];
ans += (a1[0] - 1) - a1[2];
} else if (a1[1] == m && a1[0] != m && a1[2] != m) {
ans += (a1[1] - 1) - a1[0];
ans += (a1[1] - 1) - a1[2];
} else if (a1[2] == m && a1[1] != m && a1[0] != m) {
ans += (a1[2] - 1) - a1[1];
ans += (a1[2] - 1) - a1[0];
} else if (a1[2] == m && a1[1] == m && a1[0] != m) {
ans += (m - 1) - a1[0];
} else if (a1[0] == m && a1[1] == m && a1[2] != m) {
ans += (m - 1) - a1[2];
} else if (a1[0] == m && a1[2] == m && a1[1] != m) {
ans += (m - 1) - a1[1];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
struct Node *parent, *left, *right;
int minp[10], maxp[10];
int size;
int priority;
};
struct Node *root;
int n, k;
int s[50000][10];
void read_data() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
scanf("%d", &s[i][j]);
}
}
root = NULL;
}
bool thinner_node(struct Node *node1, struct Node *node2) {
for (int i = 0; i < k; i++) {
if (!(node1->maxp[i] < node2->minp[i])) {
return false;
}
}
return true;
}
bool bigger_node(struct Node *node1, struct Node *node2) {
for (int i = 0; i < k; i++) {
if (!(node1->minp[i] > node2->maxp[i])) {
return false;
}
}
return true;
}
int compare_node(struct Node *node1, struct Node *node2) {
int x = 0;
if (thinner_node(node1, node2)) {
return -1;
} else if (bigger_node(node1, node2)) {
return 1;
} else {
return 0;
}
}
void left_rotate(struct Node *parent, struct Node *node) {
node->parent = parent->parent;
if (node->parent != NULL) {
if (node->parent->left == parent) {
node->parent->left = node;
} else {
node->parent->right = node;
}
}
parent->parent = node;
parent->left = node->right;
if (node->right != NULL) node->right->parent = parent;
node->right = parent;
}
void right_rotate(struct Node *parent, struct Node *node) {
node->parent = parent->parent;
if (node->parent != NULL) {
if (node->parent->left == parent) {
node->parent->left = node;
} else {
node->parent->right = node;
}
}
parent->parent = node;
parent->right = node->left;
if (node->left != NULL) node->left->parent = parent;
node->left = parent;
}
void insert_node(struct Node **rootp, struct Node *node) {
struct Node **nodep = rootp;
while (*nodep != NULL) {
if (thinner_node(*nodep, node)) {
node->parent = *nodep;
nodep = &(*nodep)->right;
} else {
node->parent = *nodep;
nodep = &(*nodep)->left;
}
}
*nodep = node;
node->priority = rand();
while (node->parent != NULL && node->parent->priority > node->priority) {
if (node->parent->left == node) {
left_rotate(node->parent, node);
} else {
right_rotate(node->parent, node);
}
}
if (node->parent == NULL) {
*rootp = node;
}
}
struct Node *build_node(int sn[]) {
struct Node *node = (struct Node *)malloc(sizeof(struct Node));
for (int i = 0; i < k; i++) {
node->minp[i] = node->maxp[i] = sn[i];
}
node->size = 1;
node->parent = NULL;
node->left = NULL;
node->right = NULL;
return node;
}
struct Node **binsearch(struct Node **nodep, struct Node *nn) {
struct Node *parent = *nodep;
while (parent != NULL) {
if (thinner_node(parent, nn)) {
nodep = &parent->right;
parent = parent->right;
} else if (bigger_node(parent, nn)) {
nodep = &parent->left;
parent = parent->left;
} else {
return nodep;
}
}
return NULL;
}
void remove_node(struct Node **rootp, struct Node **nodep) {
struct Node *node = *nodep;
while (true) {
if (node->left == NULL && node->right == NULL) {
*nodep = NULL;
if (node->parent == NULL) *rootp = NULL;
break;
} else if (node->left == NULL) {
if (node->parent == NULL) *rootp = node->right;
node->right->parent = node->parent;
*nodep = node->right;
break;
} else if (node->right == NULL) {
if (node->parent == NULL) *rootp = node->left;
node->left->parent = node->parent;
*nodep = node->left;
break;
} else {
if (node->left->priority < node->right->priority) {
nodep = &node->left->right;
if (node->parent == NULL) {
*rootp = node->left;
}
left_rotate(node, node->left);
} else {
nodep = &node->right->left;
if (node->parent == NULL) {
*rootp = node->right;
}
right_rotate(node, node->right);
}
}
}
node->left = NULL;
node->right = NULL;
node->parent = NULL;
}
void merge_node(struct Node *node1, struct Node *node2) {
for (int i = 0; i < k; i++) {
if (node2->minp[i] < node1->minp[i]) {
node1->minp[i] = node2->minp[i];
}
if (node2->maxp[i] > node1->maxp[i]) {
node1->maxp[i] = node2->maxp[i];
}
}
node1->size += node2->size;
}
void search_node(struct Node *root) {
cout << root->size << " " << root->priority << endl;
cout << "minp: ";
for (int i = 0; i < k; i++) cout << root->minp[i] << ' ';
cout << endl;
cout << "maxp: ";
for (int i = 0; i < k; i++) cout << root->maxp[i] << ' ';
cout << endl;
if (root->left != NULL) {
cout << "L" << endl;
search_node(root->left);
}
if (root->right != NULL) {
cout << "R" << endl;
search_node(root->right);
}
cout << root->priority << "end" << endl;
}
void deal() {
for (int i = 0; i < n; i++) {
struct Node *nn = build_node(s[i]);
struct Node **t = NULL;
struct Node *tmp = NULL;
while ((t = binsearch(&root, nn)) && (t != NULL)) {
tmp = *t;
remove_node(&root, t);
merge_node(nn, tmp);
}
insert_node(&root, nn);
tmp = root;
while (tmp->right != NULL) tmp = tmp->right;
cout << tmp->size << endl;
}
}
int main() {
srand(time(NULL));
read_data();
deal();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int pos[1005], num[1005];
int row[1005], col[1005];
void solve(int t[1005]) {
for (int i = (1); i <= (n - 1); i++) {
if (num[i] != i) {
int p = i, q = pos[i];
t[p] = q;
swap(num[p], num[q]);
swap(pos[num[p]], pos[num[q]]);
} else {
t[i] = i;
}
}
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) {
scanf("%d", &num[i]);
pos[num[i]] = i;
}
solve(row);
for (int i = (1); i <= (n); i++) {
scanf("%d", &num[i]);
pos[num[i]] = i;
}
solve(col);
int cnt = 0;
for (int i = (1); i <= (n - 1); i++) cnt += !(row[i] == i && i == col[i]);
printf("%d\n", cnt);
for (int i = (1); i <= (n - 1); i++) {
if (row[i] == i && i == col[i]) continue;
printf("%d %d %d %d\n", row[i], i, i, col[i]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int n;
pii p[1001];
map<long long, vector<pii>> mp;
long long sqr(int a) { return 1LL * a * a; }
long long dist(int a, int b) {
return sqr(p[a].first - p[b].first) + sqr(p[a].second - p[b].second);
}
struct dsu {
int ds[1003];
void init() { iota(ds, ds + 1003, 0); }
int find(int u) { return u == ds[u] ? u : ds[u] = find(ds[u]); }
bool same(int u, int v) { return find(u) == find(v); }
void merge(int u, int v) { ds[find(u)] = find(v); }
} ds;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> p[i].first >> p[i].second;
for (int j = 1; j < i; ++j) {
mp[dist(i, j)].emplace_back(j, i);
}
}
if (n == 2) {
cout << "1\n1";
return 0;
}
ds.init();
for (auto& i : mp) {
if (i.second.size() == 1) continue;
for (auto& j : i.second) {
if (!ds.same(j.first, j.second)) ds.merge(j.first, j.second);
}
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (ds.find(i) == ds.find(1)) cnt++;
}
if (cnt != n) {
cout << cnt << '\n';
for (int i = 1; i <= n; ++i) {
if (ds.find(i) == ds.find(1)) cout << i << ' ';
}
return 0;
}
ds.init();
for (auto& i : mp) {
if (i.second.size() == 1) continue;
for (auto& j : i.second) {
if (ds.same(j.first, j.second))
break;
else if (ds.same(j.first, 1001))
ds.merge(j.second, 1002);
else if (ds.same(j.first, 1002))
ds.merge(j.second, 1001);
else if (ds.same(j.second, 1001))
ds.merge(j.first, 1002);
else if (ds.same(j.second, 1002))
ds.merge(j.first, 1001);
else
ds.merge(j.first, 1001), ds.merge(j.second, 1002);
}
}
cnt = 0;
for (int i = 1; i <= n; ++i) {
if (ds.find(i) == ds.find(1001)) cnt++;
}
if (cnt != n) {
cout << cnt << '\n';
for (int i = 1; i <= n; ++i) {
if (ds.find(i) == ds.find(1001)) cout << i << ' ';
}
return 0;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans;
long long binary(long long k, long long n, long long sum) {
long long l = 1, r = k, mid;
while (l < r) {
mid = (l + r) / 2;
if (sum - (mid * (mid - 1) / 2) < n)
r = mid;
else if (sum - (mid * (mid - 1) / 2) > n)
l = mid + 1;
else if (sum - (mid * (mid - 1) / 2) == n)
return k - mid + 1;
}
return k - r + 2;
}
int main() {
cin >> n >> k;
if (n == 1)
cout << "0";
else if (k >= n)
cout << "1";
else {
n--;
k--;
if ((k * (k + 1)) / 2 < n)
cout << "-1";
else if ((k * (k + 1)) / 2 == n)
cout << k;
else
cout << binary(k, n, k * (k + 1) / 2);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define MAX 112345
int n, m;
char t;
int a;
char pole[1123][1123];
void solve()
{
cin >> n >> m;
for(int i=0; i<n; i++)
{
cin >> pole[i];
}
if(m==1)
{
cout << "YES" << endl;
cout << 1 << " " << 2 << endl;
return;
}
if(pole[0][1]==pole[1][0] or (m%2))
{
cout << "YES" << endl;
for(int i=0; i<=m; i++)
{
if(i%2) cout << 1 << " ";
else cout << 2 << " ";
}
cout << endl;
return;
}
if(n==2)
{
cout << "NO" << endl;
return;
}
if(pole[0][2]==pole[2][0])
{
cout << "YES" << endl;
for(int i=0; i<=m; i++)
{
if(i%2) cout << 1 << " ";
else cout << 3 << " ";
}
cout << endl;
return;
}
if(pole[1][2]==pole[2][1])
{
cout << "YES" << endl;
for(int i=0; i<=m; i++)
{
if(i%2) cout << 2 << " ";
else cout << 3 << " ";
}
cout << endl;
return;
}
if(pole[0][1]==pole[1][2])
{
a=4;
}
if(pole[1][2]==pole[2][0])
{
a=5;
}
if(pole[0][1]==pole[2][0])
{
a=3;
}
m=m/2;
cout << "YES" << endl;
for(int i=0; i<=m; i++)
{
if(i%2==m%2) cout << ((a%3)+1) << " ";
else cout << ((a-1)%3+1) << " ";
}
for(int i=1; i<=m; i++)
{
if(i%2==0) cout << ((a%3)+1) << " ";
else cout << ((a+1)%3+1) << " ";
}
cout << endl;
}
int main()
{
int t;
cin >> t;
while(t--)
{
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
char a[N];
int main() {
int n;
scanf("%d", &n);
scanf("%s", a);
int m = strlen(a);
if (m < 4) {
puts("0");
return 0;
}
int cnt = 0;
for (int i = 0; i < m; i++) {
if (i % n == 0 && i) {
int ok = 1;
for (int j = 2; j <= 3; j++) {
int x = (i - j + m) % m;
if (a[x] != a[(i - 1 + m) % m]) ok = 0;
}
if (ok) cnt++;
}
}
printf("%d\n", cnt);
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.