solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 998244353;
const long long maxn = 1e6 + 7;
const double pi = acos(-1.0);
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
inline void add(long long &x, long long y) {
x += y;
(x >= M) && (x -= M);
}
int k;
int A[maxn];
vector<int> edge[maxn];
int sz[maxn];
bool mark[maxn];
int minweight, root;
void dfs1(int x, int fa, int n) {
int weight = 0;
sz[x] = 1;
for (int v : edge[x]) {
if (v == fa || mark[v]) continue;
dfs1(v, x, n);
sz[x] += sz[v];
weight = max(weight, sz[v]);
}
weight = max(weight, n - sz[x]);
if (weight < minweight) root = x, minweight = weight;
}
vector<int> have;
long long nowans[157];
long long F[4007][157], G[4007][157];
void dfs2(int x, int fa) {
int i, j;
have.push_back(x);
for (int v : edge[x]) {
if (v == fa || mark[v]) continue;
dfs2(v, x);
}
}
void calc(int x) {
int i, j;
have.clear();
dfs2(x, 0);
for (i = 0; i <= k * 2; i++)
for (int x : have) F[x][i] = G[x][i] = 0;
G[x][0] = 1;
F[x][0] = 1;
for (i = 0; i <= k * 2 - 1; i++)
for (int y : have) {
if (G[y][i])
for (int v : edge[y])
if (!mark[v]) add(G[v][i + 1], G[y][i]);
if ((y != x || !i) && F[y][i])
for (int v : edge[y])
if (!mark[v])
if (v != x) add(F[v][i + 1], F[y][i]);
}
for (int y : have) {
for (i = 0; i <= k * 2; i++)
if (F[y][i])
for (j = 0; j <= k * 2; j++) add(nowans[i + j], F[y][i] * G[y][j] % M);
}
}
void dfs3(int x) {
calc(x);
mark[x] = 1;
for (int v : edge[x]) {
if (mark[v]) continue;
minweight = sz[v];
dfs1(v, 0, sz[v]);
dfs3(root);
}
}
long long ans_1[107], ans_2[107];
long long inv[1000002];
long long fac[1000002];
long long C(int n, int m) { return fac[n] * inv[m] % M * inv[n - m] % M; }
void solve_cnt(int n, long long ans[]) {
int i, j, x, y;
for (i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
for (i = 0; i <= k; i++) nowans[i] = 0;
minweight = n;
dfs1(1, 0, n);
dfs3(root);
for (i = 0; i <= k; i++) ans[i] = nowans[i * 2], nowans[i * 2] = 0;
for (i = 1; i <= n; i++) edge[i].clear(), mark[i] = 0;
}
int TaskA() {
int m, i, j;
int n1, n2;
scanf("%d%d%d", &n1, &n2, &k);
if (k & 1) return 0 * puts("0");
k /= 2;
solve_cnt(n1, ans_1);
solve_cnt(n2, ans_2);
long long ans = 0;
for (i = 0; i <= k; i++)
ans += C(k * 2, i * 2) * ans_1[i] % M * ans_2[k - i] % M;
ans %= M;
printf("%I64d\n", ans);
return 0;
}
void initialize() {
int i;
fac[0] = 1;
for (i = 1; i <= 1000000; i++) fac[i] = i * fac[i - 1] % M;
inv[0] = inv[1] = 1;
for (i = 2; i <= 1000000; i++) inv[i] = (M - M / i) * inv[M % i] % M;
for (i = 1; i <= 1000000; i++) inv[i] = inv[i] * inv[i - 1] % M;
}
int main() {
int startTime = clock();
initialize();
fprintf(stderr, "/--- initializeTime: %ld milliseconds ---/\n",
clock() - startTime);
int T = 1;
startTime = clock();
while (T--) TaskA();
fprintf(stderr, "/--- computeTime: %ld milliseconds ---/\n",
clock() - startTime);
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int x, long long int y) {
return y == 0 ? x : gcd(y, x % y);
}
bool isPalin(string x) {
long long int len = x.length();
for (int i = 0; i <= (len / 2) - 1; ++i) {
if (x[i] != x[len - 1 - i]) return false;
}
return true;
}
string tolowerStr(string x) {
string ret = "";
for (int i = 0; i <= (long long int)x.length() - 1; ++i) {
ret.push_back(tolower(x[i]));
}
return ret;
}
string toupperStr(string x) {
string ret = "";
for (int i = 0; i <= (long long int)x.length() - 1; ++i) {
ret.push_back(toupper(x[i]));
}
return ret;
}
long long int modulo(long long int a, long long int b, long long int c) {
long long int res = 1;
for (int i = 0; i < b; i++) {
res *= a;
res %= c;
}
return res % c;
}
bool double_equals(double a, double b, double epsilon = 0.1) {
return std::abs(a - b) < epsilon;
}
bool prime[1000005];
void seive() {
prime[0] = 1;
prime[1] = 1;
for (int i = 2; i * i <= 100007; ++i)
if (!prime[i])
for (int j = 2 * i; j < 100007; j += i)
if (!prime[j]) prime[j] = 1;
}
int ar1[100005];
int ar2[100005];
int main() {
ios_base::sync_with_stdio(false);
int n, m, ans1 = 0, ans2 = 0, pos = 0;
cin >> n >> m;
for (int i = 0; i <= n - 1; ++i) {
ar1[i] = n - i;
ar2[i] = i + 1;
}
for (int i = 0; i <= n - 1; ++i) {
for (int j = i; j <= n - 1; ++j) {
ans1 += *min_element(ar1 + i, ar1 + i + (j - i + 1));
}
}
do {
ans2 = 0;
for (int i = 0; i <= n - 1; ++i) {
for (int j = i; j <= n - 1; ++j) {
ans2 += *min_element(ar2 + i, ar2 + i + (j - i + 1));
}
}
if (ans2 == ans1) pos++;
if (pos == m) break;
} while (next_permutation(ar2, ar2 + n));
for (int i = 0; i <= n - 1; ++i) cout << ar2[i] << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int r, c;
cin >> r >> c;
char arr[r][c];
bool b = 0;
bool b2 = 0;
bool check = 1;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> arr[i][j];
if (arr[i][j] == 'A') {
b = 1;
}
if (arr[i][j] == 'P') {
check = 0;
}
}
}
if (check) {
cout << 0 << endl;
continue;
}
if (b == 0) {
cout << "MORTAL" << endl;
continue;
}
b = 1;
for (int i = 0; i < c; i++) {
if (arr[0][i] == 'P') {
b = 0;
}
if (arr[0][i] == 'A') {
b2 = 1;
}
}
if (b) {
cout << 1 << endl;
continue;
}
b = 1;
for (int i = 0; i < c; i++) {
if (arr[r - 1][i] == 'P') {
b = 0;
}
if (arr[r - 1][i] == 'A') {
b2 = 1;
}
}
if (b) {
cout << 1 << endl;
continue;
}
b = 1;
for (int i = 0; i < r; i++) {
if (arr[i][0] == 'P') {
b = 0;
}
if (arr[i][0] == 'A') {
b2 = 1;
}
}
if (b) {
cout << 1 << endl;
continue;
}
b = 1;
for (int i = 0; i < r; i++) {
if (arr[i][c - 1] == 'P') {
b = 0;
}
if (arr[i][c - 1] == 'A') {
b2 = 1;
}
}
if (b) {
cout << 1 << endl;
continue;
}
bool d = 0;
for (int i = 0; i < r; i++) {
bool booly = 1;
for (int j = 0; j < c; j++) {
if (arr[i][j] == 'P') {
booly = 0;
}
}
if (booly) {
d = 1;
}
}
for (int i = 0; i < c; i++) {
bool booly = 1;
for (int j = 0; j < r; j++) {
if (arr[j][i] == 'P') {
booly = 0;
}
}
if (booly) {
d = 1;
}
}
if (d) {
cout << 2 << endl;
continue;
}
if (arr[0][0] == 'A' || arr[r - 1][c - 1] == 'A' || arr[0][c - 1] == 'A' ||
arr[r - 1][0] == 'A') {
cout << 2 << endl;
continue;
}
if (b2) {
cout << 3 << endl;
continue;
}
cout << 4 << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000404;
const long long MOD = 1000000007ll;
const long double PI = acos(-1.0);
const long long INF = 1000000000000000404ll;
const long double EPS = 1e-9;
template <typename t1, typename t2>
inline void upmax(t1 &a, t2 b) {
a = max(a, (t1)b);
}
template <typename t1, typename t2>
inline void upmin(t1 &a, t2 b) {
a = min(a, (t1)b);
}
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
inline T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
inline bool pal(string &x) {
int n = (int)x.length();
for (int i = 0; i < n / 2; i++) {
if (x[i] != x[n - i - 1]) return 0;
}
return 1;
}
template <typename T>
inline void rev(T &x) {
int n = (int((x.size())));
for (int i = 0; i < n / 2; i++) swap(x[i], x[n - i - 1]);
}
int month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
class compare {
public:
bool operator()(const int a, const int b) const { return 1; }
};
int SQ = 400;
void solve() {
int n;
cin >> n;
int l = 0;
int r = n - 1;
int x, y;
y = n;
string s;
for (int i = 0; i < n; i++) {
s += '0';
}
int H;
string shab = s;
cout << "? " << s << endl;
cin >> H;
H = n - H;
int NH;
pair<int, int> ans;
ans.first = -1;
ans.second = -1;
while (l < r) {
int x = (l + r) / 2;
if (l == r - 1) {
string s1 = s, s2 = s;
int H1, H2;
s1[l] = '1';
s2[r] = '1';
cout << "? " << s1 << endl;
cin >> H1;
H1 = n - H1;
if (H1 == H + 1) {
ans.second = l;
} else
ans.first = l;
cout << "? " << s2 << endl;
cin >> H2;
H2 = n - H2;
if (H2 == H + 1) {
ans.second = r;
} else
ans.first = r;
break;
}
for (int i = x; i < r + 1; i++) s[i] = '1';
cout << "? " << s << endl;
s = shab;
cin >> NH;
NH = n - NH;
if (abs(NH - H) == r - x + 1) {
if (NH > H)
ans.second = x;
else
ans.first = x;
r = x - 1;
} else {
l = x;
}
}
if (ans.first == -1) ans.first = l;
if (ans.second == -1) ans.second = l;
cout << '!' << ' ' << ans.first + 1 << ' ' << ans.second + 1 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
};
getchar();
getchar();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> v;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
v.push_back({-a[i], i});
}
sort(v.begin(), v.end());
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int k, p;
cin >> k >> p;
vector<pair<int, int>> tmp;
for (int j = 0; j < k; j++) {
tmp.push_back({v[j].second, -v[j].first});
}
sort(tmp.begin(), tmp.end());
cout << tmp[p - 1].second << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ar[15], br[15];
int main() {
int n, m, i, j;
cin >> n >> m;
for (i = 0; i < n; i++) cin >> ar[i];
for (i = 0; i < m; i++) cin >> br[i];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (ar[i] == br[j]) {
cout << ar[i] << " ";
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3000;
char g[N][N + 1];
int di[] = {0, 0, 1, -1};
int dj[] = {1, -1, 0, 0};
int Qi[N * N], Qj[N * N];
bool was[N][N];
int main() {
int n, m, si, sj;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", g[i]);
for (int j = 0; j < m; ++j) {
g[i + n][j] = g[i][j + m] = g[i + n][j + m] = g[i][j];
if (g[i][j] == 'S') {
si = i;
sj = j;
}
}
}
n += n;
m += m;
int b = 0, e = 0;
Qi[e] = si;
Qj[e] = sj;
was[si][sj] = 1;
e++;
while (b < e) {
si = Qi[b];
sj = Qj[b];
for (int k = 0; k < 4; ++k) {
int i = (si + di[k] + n) % n;
int j = (sj + dj[k] + m) % m;
if (was[i][j] || g[i][j] == '#') {
continue;
}
if (g[i][j] == 'S') {
puts("Yes");
return 0;
}
was[i][j] = 1;
Qi[e] = i;
Qj[e] = j;
e++;
}
b++;
}
puts("No");
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
using dou = long double;
string yes = "yes";
string Yes = "Yes";
string YES = "YES";
string no = "no";
string No = "No";
string NO = "NO";
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long mod = 1000000007ll;
struct mint {
long long x;
mint(long long x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(long long t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream& operator>>(istream& is, const mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
long long ceili(long long a, long long b) { return ((a + b - 1) / b); }
const int INF = 2000000000;
const long long INF64 = 4223372036854775807ll;
const long long MOD = 1000000007ll;
const long long OD = 1000000000000007ll;
const dou pi = 3.141592653589793;
long long modpow(long long a, long long n) {
long long resize = 1;
while (n > 0) {
if (n & 1) resize = resize * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return resize;
}
vector<long long> divisor(long long n) {
vector<long long> ret;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
int main() {
string s;
std::cin >> s;
map<char, int> ma;
string dum = "<{[(>}])";
for (long long i = 0; i < (long long)(8); i++) ma[dum[i]] = i;
std::vector<int> a;
int ans = 0;
for (long long i = 0; i < (long long)(s.size()); i++) {
int d = ma[s[i]];
if (d / 4) {
a.push_back(d);
if (a.size() == 1) {
std::cout << "Impossible" << std::endl;
exit(0);
}
int n = a.size();
if (a[n - 1] / 4 != a[n - 2] / 4) {
if (a[n - 1] % 4 != a[n - 2] % 4) ans++;
a.pop_back();
a.pop_back();
}
} else {
a.push_back(d);
}
}
if (a.size() != 0)
std::cout << "Impossible" << std::endl;
else
std::cout << ans << std::endl;
}
| 6 |
#include <bits/stdc++.h>
int n, data[200000], ret;
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) std::cin >> data[i];
std::sort(data, data + n);
int k = 0;
for (int i = 1; i < n; i++)
if (data[i] != data[k]) data[++k] = data[i];
n = k + 1;
for (int i = 0; i < n; i++) {
int it = 2 * data[i], off = i;
while (1) {
off = std::lower_bound(data + off + 1, data + n, it) - data;
ret = std::max(ret, data[off - 1] % data[i]);
if (off == n) break;
it += data[i];
}
}
std::cout << ret << '\n';
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e5 + 9;
struct s {
long long d, w, idx;
s(long long _d, long long _w, long long _idx) {
d = _d;
w = _w;
idx = _idx;
}
};
vector<s> edges[MAX];
long long dis[MAX], counter = 0, par[MAX], cost[MAX];
bool vis[MAX];
set<int> ans;
map<pair<int, int>, int> mp;
void Dijkstra(int u) {
priority_queue<pair<long long, long long> > pq;
for (int i = 0; i < MAX; i++) dis[i] = 1e18;
pq.push({0, u});
dis[u] = 0;
while (!pq.empty()) {
long long c = -pq.top().first;
u = pq.top().second;
pq.pop();
for (auto it : edges[u]) {
int v = it.d;
c = it.w;
if (dis[v] > dis[u] + c) {
dis[v] = dis[u] + c;
pq.push({-dis[v], v});
}
}
}
}
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
long long in1, in2, in3;
scanf("%lld %lld %lld", &in1, &in2, &in3);
edges[in1].push_back(s(in2, in3, i + 1));
edges[in2].push_back(s(in1, in3, i + 1));
mp[{in1, in2}] = i + 1;
mp[{in2, in1}] = i + 1;
}
int st;
scanf("%d", &st);
Dijkstra(st);
for (int i = 1; i <= n; i++) {
bool found = false;
long long mi = 1e18;
long long e = 0;
for (int j = 0; j < edges[i].size(); j++) {
long long k = edges[i][j].d;
long long c = edges[i][j].w;
if (dis[i] == dis[k] + c && mi > c) {
found = true;
mi = c;
e = k;
}
}
if (found == true) ans.insert(mp[{i, e}]), counter += mi;
}
printf("%lld\n", counter);
for (auto it : ans) printf("%d ", it);
return 0;
}
| 12 |
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>
struct LineReader
{
std::vector<uint32_t> const &readLine()
{
std::getline(std::cin, line);
values.clear();
uint32_t value = 0;
bool gotValue = false;
for (std::size_t i = 0; i < line.length(); ++i)
{
const char c = line[i];
if (c >= '0' && c <= '9')
{
value = (value * 10) + (c - '0');
gotValue = true;
}
else if (gotValue)
{
values.emplace_back(value);
value = 0;
gotValue = false;
}
}
if (gotValue)
{
values.emplace_back(value);
}
return values;
}
std::string line;
std::vector<uint32_t> values;
};
struct Box
{
Box() = default;
Box(uint32_t const &p) : tl(1), tr(1), l(p), r(p)
{
}
Box(std::vector<uint32_t> const &data) : tl(data[0]), tr(data[1]), l(data[2]), r(data[3])
{
}
bool operator<(Box const &other) const
{
return (tl > other.tl) || ((tl == other.tl) && (l > other.l));
}
void add(Box const &other)
{
tl = std::min(tl, other.tl);
tr = std::max(tr, other.tr);
l = std::min(l, other.l);
r = std::max(r, other.r);
}
void enlarge()
{
--tl;
++tr;
--l;
r += 2;
}
uint32_t tl{0};
uint32_t tr{0};
uint32_t l{0};
uint32_t r{0};
};
struct CompressedRow
{
static constexpr uint32_t infinity{static_cast<uint32_t>(-1)};
struct Range
{
uint32_t operator[](uint32_t const x) const
{
if (x < c)
{
return d + (c - x);
}
else
{
return d + (x - c);
}
}
bool is_blocked() const
{
return d == infinity;
}
bool is_valid_after(uint32_t const t) const
{
return (!is_blocked()) || (c >= t);
}
void set_l(uint32_t const nl)
{
l = nl;
if (is_blocked())
{
return;
}
if (c < l)
{
d += (l - c);
c = l;
}
}
void set_r(uint32_t const nr)
{
r = nr;
if (is_blocked())
{
return;
}
if (c > r)
{
d += (c - r);
c = r;
}
}
void advance(uint32_t const dt)
{
if (is_blocked())
{
return;
}
c += dt;
if (c > r)
{
d += (c - r);
c = r;
}
}
void block_until(uint32_t const t)
{
if (is_blocked())
{
c = std::max(c, t);
}
else
{
c = t;
d = infinity;
}
}
void block_l()
{
if ((is_blocked()) || (c > l))
{
return;
}
++c;
++d;
if (c > r)
{
d += (c - r);
c = r;
}
}
uint32_t l;
uint32_t c;
uint32_t r;
uint32_t d;
};
CompressedRow(uint32_t const l, uint32_t const r, uint32_t const c) : time(0), l(l), r(r)
{
distance.emplace_back(Range{0, c, infinity, 0});
}
uint32_t min()
{
uint32_t result = infinity;
for (Range &dr : distance)
{
result = std::min(result, dr.d);
}
return result;
}
void advance(uint32_t new_time)
{
const uint32_t dt = new_time - time;
uint32_t offset = 0;
for (uint32_t i = 0; i < distance.size(); ++i)
{
if ((!distance[i].is_blocked()) && (i + 1 < distance.size()) && (!distance[i + 1].is_blocked()))
{
uint32_t j = i + 2;
while ((j < distance.size()) && (!distance[j].is_blocked()))
{
++j;
}
--j;
distance[i].r = std::min(distance[i].r + dt, distance[j].r);
distance[i].advance(dt);
if (offset > 0)
{
distance[i - offset] = distance[i];
}
while (i < j)
{
++i;
if (i < j)
{
distance[i].r = std::min(distance[i].r + dt, distance[j].r);
}
distance[i].advance(dt);
distance[i].l += dt;
if (distance[i].l > distance[i].r)
{
++offset;
}
else if (offset > 0)
{
distance[i - offset] = distance[i];
}
}
}
else
{
distance[i].advance(dt);
if (offset > 0)
{
distance[i - offset] = distance[i];
}
}
}
if (offset > 0)
{
distance.resize(distance.size() - offset);
}
time = new_time;
}
void change_boxes(std::vector<Box> const &boxes)
{
uint32_t i = 0;
for (Box const &box : boxes)
{
while (distance[i].r < box.l)
{
if (distance[i].is_valid_after(time))
{
new_distance.emplace_back(distance[i]);
fix_new_distance();
}
++i;
}
if (distance[i].l < box.l)
{
if (distance[i].is_valid_after(time))
{
new_distance.emplace_back(distance[i]);
}
distance[i].set_l(box.l);
new_distance.back().set_r(box.l - 1);
fix_new_distance();
}
while (distance[i].r <= box.r)
{
new_distance.emplace_back(distance[i]);
new_distance.back().block_until(box.tr);
fix_new_distance();
++i;
}
if (distance[i].l <= box.r)
{
new_distance.emplace_back(distance[i]);
new_distance.back().block_until(box.tr);
new_distance.back().set_r(box.r);
fix_new_distance();
distance[i].set_l(box.r + 1);
}
distance[i].block_l();
}
while (i < distance.size())
{
if (distance[i].is_valid_after(time))
{
new_distance.emplace_back(distance[i]);
fix_new_distance();
}
++i;
}
distance.swap(new_distance);
new_distance.clear();
}
void fix_new_distance()
{
while (new_distance.size() >= 2)
{
Range &dl = new_distance[new_distance.size() - 2];
Range &dr = new_distance.back();
if (dl.r + 1 < dr.l)
{
if ((dl.is_blocked()) && (dr.is_blocked()))
{
if (dl.c < dr.c)
{
dl.r = dr.l - 1;
}
else
{
dr.l = dl.r + 1;
}
}
else if (dl.is_blocked())
{
dr.l = dl.r + 1;
}
else
{
dl.r = dr.l - 1;
}
}
if ((dl.is_blocked()) && (dr.is_blocked()) && (dl.c == dr.c))
{
dl.r = dr.r;
new_distance.pop_back();
}
if ((!dl.is_blocked()) && (!dr.is_blocked()))
{
if (dl[dl.c] >= dr[dl.c])
{
dl.r = dr.r;
dl.c = dr.c;
dl.d = dr.d;
new_distance.pop_back();
continue;
}
else if (dl[dr.c] <= dr[dr.c])
{
dl.r = dr.r;
new_distance.pop_back();
}
else
{
const uint32_t c = (dl.c + dr.c - dl.d + dr.d) / 2;
dl.r = c;
dr.l = c + 1;
}
}
break;
}
}
std::vector<Range> distance;
uint32_t time;
uint32_t l;
uint32_t r;
std::vector<Range> new_distance;
};
struct NewBoxesExtractor
{
std::vector<Box> &operator()(std::vector<Box> &boxes, uint32_t time)
{
new_boxes.clear();
temp_boxes.clear();
while ((!boxes.empty()) && (boxes.back().tl == time))
{
if ((temp_boxes.empty()) || (boxes.back().l < temp_boxes.back().l))
{
add_box(boxes.back());
boxes.pop_back();
}
else
{
add_box(temp_boxes.back());
temp_boxes.pop_back();
}
}
while (!temp_boxes.empty())
{
add_box(temp_boxes.back());
temp_boxes.pop_back();
}
return new_boxes;
}
void add_box(Box const &box)
{
if ((new_boxes.empty()) || (new_boxes.back().r < box.l))
{
new_boxes.emplace_back(box);
}
else if (box.tr > new_boxes.back().tr)
{
if (box.r < new_boxes.back().r)
{
temp_boxes.emplace_back(new_boxes.back());
temp_boxes.back().l = box.r + 1;
}
new_boxes.back().r = box.l - 1;
if (new_boxes.back().r < new_boxes.back().l)
{
new_boxes.pop_back();
}
new_boxes.emplace_back(box);
}
else if (box.r > new_boxes.back().r)
{
const uint32_t l = new_boxes.back().r + 1;
new_boxes.emplace_back(box);
new_boxes.back().l = l;
}
}
std::vector<Box> new_boxes;
std::vector<Box> temp_boxes;
};
int main()
{
LineReader input;
const uint32_t number_of_boxes = input.readLine()[0];
uint32_t start_position = input.readLine()[0];
if (number_of_boxes == 0)
{
std::cout << '0' << std::endl;
return EXIT_SUCCESS;
}
Box bb{start_position};
std::vector<Box> boxes;
boxes.reserve(number_of_boxes);
std::vector<uint32_t> critical_times;
critical_times.reserve(2 * number_of_boxes);
for (std::size_t i = 0; i < number_of_boxes; ++i)
{
boxes.emplace_back(input.readLine());
critical_times.emplace_back(boxes.back().tl);
critical_times.emplace_back(boxes.back().tr + 1);
bb.add(boxes.back());
}
std::sort(boxes.begin(), boxes.end());
sort(critical_times.begin(), critical_times.end());
critical_times.erase(std::unique(critical_times.begin(), critical_times.end()), critical_times.end());
bb.enlarge();
CompressedRow row{bb.l, bb.r, start_position};
NewBoxesExtractor new_boxes_extractor;
for (uint32_t const time : critical_times)
{
row.advance(time);
row.change_boxes(new_boxes_extractor(boxes, time));
}
std::cout << row.min() << std::endl;
return EXIT_SUCCESS;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int INF = 10000000;
int a[N], b[N];
int n, x0;
int main() {
int i, j;
scanf("%d%d", &n, &x0);
for (i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
if (a[i] > b[i]) swap(a[i], b[i]);
}
int minerg = INF;
bool p = false;
for (i = 0; i <= 1000; i++) {
bool ok = true;
for (j = 0; j < n; j++) {
if (i < a[j] || b[j] < i) {
ok = false;
break;
}
}
if (ok) {
p = true;
minerg = min(minerg, abs(i - x0));
}
}
if (p)
printf("%d\n", minerg);
else
puts("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> ns, ms;
int n, m;
long long ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
ns[i % 5]++;
}
for (int i = 1; i <= m; i++) {
ms[i % 5]++;
}
for (pair<int, int> a : ns) {
for (pair<int, int> b : ms) {
if ((a.first + b.first) % 5 == 0) {
ans += 1LL * a.second * b.second;
}
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
double ini_place;
double fin_place;
int begin_end;
int id;
} T[400019];
bool cmp(node n1, node n2) {
if (n1.ini_place == n2.ini_place) return n1.begin_end < n2.begin_end;
return n1.ini_place < n2.ini_place;
}
int val_worker[400019];
int main() {
int n, x, y, val;
cin >> n;
int ind = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
T[ind].ini_place = x;
T[ind].fin_place = y;
T[ind].begin_end = 2;
T[ind].id = i;
ind++;
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &x, &y, &val);
double xx = (x * 1.0) - 0.5, yy = (y * 1.0) + 0.5;
T[ind].ini_place = xx;
T[ind].fin_place = yy;
T[ind].begin_end = 0;
T[ind].id = i;
ind++;
T[ind].ini_place = yy;
T[ind].fin_place = yy;
T[ind].begin_end = 1;
T[ind].id = i;
ind++;
val_worker[i] = val;
}
sort(T, T + ind, cmp);
vector<vector<int> > ans;
ans.assign(m + 2, vector<int>());
vector<pair<int, int> > kent;
set<pair<double, int> > s1;
for (int i = 0; i < ind; i++) {
if (T[i].begin_end == 0) {
s1.insert(make_pair(T[i].fin_place, T[i].id));
}
if (T[i].begin_end == 2) {
set<pair<double, int> >::iterator it =
s1.lower_bound(make_pair(T[i].fin_place, 0));
if (it == s1.end()) {
cout << "NO" << endl;
return 0;
} else {
pair<double, int> p1 = *it;
val_worker[p1.second]--;
kent.push_back(make_pair(T[i].id, p1.second));
if (val_worker[p1.second] == 0) {
s1.erase(it);
}
}
}
if (T[i].begin_end == 1) {
if (s1.count(make_pair(T[i].ini_place, T[i].id))) {
s1.erase(make_pair(T[i].ini_place, T[i].id));
}
}
}
sort(kent.begin(), kent.end());
cout << "YES" << endl;
for (int i = 0; i < (int)kent.size(); i++) {
cout << kent[i].second + 1 << " ";
}
cout << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, ma[1005][1005], ans, x[1000005], y[1000005], top, srt[1000005];
long long sum[1005][1005], cost[1000005], mini[1005][1005];
bool use[1000005];
deque<pair<long long, int> > dq;
bool cmp(int i, int j) {
return cost[i] < cost[j] ||
cost[i] == cost[j] && (x[i] < x[j] || x[i] == x[j] && y[i] < y[j]);
}
int main() {
scanf("%d %d %d %d", &n, &m, &a, &b);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &ma[i][j]);
mini[i][j] = ma[i][j];
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + ma[i][j];
}
}
for (int i = 1; i <= n; i++) {
dq.clear();
for (int j = m; j >= 1; j--) {
while (dq.size() && dq[0].second > j + b - 1) dq.pop_front();
while (dq.size() && mini[i][j] <= dq.back().first) dq.pop_back();
dq.push_back(make_pair(mini[i][j], j));
mini[i][j] = dq[0].first;
}
}
for (int j = 1; j <= m; j++) {
dq.clear();
for (int i = n; i >= 1; i--) {
while (dq.size() && dq[0].second > i + a - 1) dq.pop_front();
while (dq.size() && mini[i][j] <= dq.back().first) dq.pop_back();
dq.push_back(make_pair(mini[i][j], i));
mini[i][j] = dq[0].first;
}
}
top = 0;
for (int i = 1; i + a - 1 <= n; i++) {
for (int j = 1; j + b - 1 <= m; j++) {
top++;
x[top] = i;
y[top] = j;
cost[top] = sum[i + a - 1][j + b - 1] - sum[i + a - 1][j - 1] -
sum[i - 1][j + b - 1] + sum[i - 1][j - 1] -
mini[i][j] * a * b;
srt[top] = top;
}
}
sort(srt + 1, srt + top + 1, cmp);
ans = 0;
for (int k = 1; k <= top; k++) {
if (mini[x[srt[k]]][y[srt[k]]] >= 0) {
ans++;
use[srt[k]] = true;
for (int i = max(1, x[srt[k]] - a + 1); i <= x[srt[k]] + a - 1; i++) {
for (int j = max(1, y[srt[k]] - b + 1); j <= y[srt[k]] + b - 1; j++) {
mini[i][j] = -1;
}
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= top; i++) {
if (use[srt[i]]) {
printf("%d %d %I64d\n", x[srt[i]], y[srt[i]], cost[srt[i]]);
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
int a[105];
int cnt[105];
using namespace std;
int main() {
int n;
cin >> n;
int t = n;
while (t--) {
string s;
cin >> s;
memset(cnt, 0, sizeof(cnt));
int len = s.length();
int flag = 0;
for (int i = 0; i < len; i++) {
a[i] = s[i] - 'a';
cnt[a[i]]++;
if (cnt[a[i]] > 1) {
cout << "No" << endl;
flag = 1;
break;
}
}
if (flag == 1) continue;
sort(a, a + len);
int flag2 = 0;
for (int i = 0; i + 1 < len; i++) {
if (a[i + 1] - a[i] > 1) {
flag2 = 1;
}
}
if (flag2 == 1)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 55;
int n, m, a[M];
double pro[M], dp[M][M], cnt[M][M];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d", a + i);
}
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i <= n; ++i) {
cnt[i][0] = 1;
for (int j = 1; j <= i; ++j) {
cnt[i][j] = cnt[i - 1][j] + cnt[i - 1][j - 1];
}
}
pro[0] = 0;
for (int max = 1; max <= n; ++max) {
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= j and k <= a[i] * max; ++k) {
dp[i][j] += dp[i - 1][j - k] * cnt[j][k];
}
}
}
pro[max] = dp[m][n];
for (int i = 1; i <= n; ++i) {
pro[max] /= m;
}
}
double res = 0;
for (int i = 1; i <= n; ++i) {
res += (pro[i] - pro[i - 1]) * i;
}
printf("%.10f\n", res);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, a, d, prev = 0, t1, t2;
cin >> n >> a >> d;
for (int i = 0; i < n; ++i) {
cin >> t1 >> t2;
double t = t2 / a;
double s = a * t * t / 2;
double tt = t1 + t + (d - s) / t2;
if (s >= d) tt = t1 + sqrt(2 * d / a);
if (tt < prev)
printf("%.10f\n", prev);
else {
printf("%.10f\n", tt);
prev = tt;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int MAXN = 1.5e5 + 10;
int n, m, p;
int a[MAXN];
struct Node {
int tot, num[5], cnt[5];
inline friend Node operator+(Node a, Node b) {
Node res = a;
for (int i = 0; i < b.tot; ++i) {
int flg = 0;
for (int j = 0; j < res.tot; ++j)
if (b.num[i] == res.num[j]) {
res.cnt[j] += b.cnt[i], flg = 1;
break;
}
if (flg) continue;
if (res.tot < p) {
res.num[res.tot] = b.num[i], res.cnt[res.tot++] = b.cnt[i];
continue;
}
int num = 0;
for (int j = 1; j < res.tot; ++j) res.cnt[j] < res.cnt[num] && (num = j);
if (res.cnt[num] > b.cnt[i]) {
for (int j = 0; j < res.tot; ++j) res.cnt[j] -= b.cnt[i];
} else {
int tmp = res.cnt[num];
res.num[num] = b.num[i], res.cnt[num] = b.cnt[i];
for (int j = 0; j < res.tot; ++j) res.cnt[j] -= tmp;
}
}
return res;
}
};
template <int N>
struct SegmentTree {
static const int M = N << 2;
Node t[M];
int tag[M];
inline void gai(int x, int L, int R, int val) {
t[x].tot = 1, t[x].num[0] = tag[x] = val, t[x].cnt[0] = R - L + 1;
}
inline void pushUp(int x) { t[x] = t[((x) << 1)] + t[((x) << 1 | 1)]; }
inline void pushDown(int x, int L, int R) {
if (tag[x]) {
int mid = (L + R) >> 1;
gai(((x) << 1), L, mid, tag[x]), gai(((x) << 1 | 1), mid + 1, R, tag[x]),
tag[x] = 0;
}
}
void build(int x, int L, int R) {
if (L == R) {
t[x].tot = 1, t[x].num[0] = a[L], t[x].cnt[0] = 1;
return;
}
int mid = (L + R) >> 1;
build(((x) << 1), L, mid), build(((x) << 1 | 1), mid + 1, R), pushUp(x);
}
void update(int x, int L, int R, int ql, int qr, int val) {
if (ql <= L && R <= qr) return gai(x, L, R, val);
int mid = (L + R) >> 1;
pushDown(x, L, R);
if (ql <= mid) update(((x) << 1), L, mid, ql, qr, val);
if (qr > mid) update(((x) << 1 | 1), mid + 1, R, ql, qr, val);
pushUp(x);
}
Node query(int x, int L, int R, int ql, int qr) {
if (ql <= L && R <= qr) return t[x];
int mid = (L + R) >> 1;
pushDown(x, L, R);
if (qr <= mid)
return query(((x) << 1), L, mid, ql, qr);
else if (ql > mid)
return query(((x) << 1 | 1), mid + 1, R, ql, qr);
else
return query(((x) << 1), L, mid, ql, qr) +
query(((x) << 1 | 1), mid + 1, R, ql, qr);
}
};
SegmentTree<MAXN> Tr;
int main() {
scanf("%d%d%d", &n, &m, &p), p = 100 / p;
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
Tr.build(1, 1, n);
for (int i = 1, opt, L, R, val; i <= m; ++i) {
scanf("%d%d%d", &opt, &L, &R);
if (opt == 1)
scanf("%d", &val), Tr.update(1, 1, n, L, R, val);
else {
Node ans = Tr.query(1, 1, n, L, R);
printf("%d", ans.tot);
for (int j = 0; j < ans.tot; ++j) printf(" %d", ans.num[j]);
puts("");
}
}
return 0;
}
| 24 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define ff first
#define ss second
#define mp make_pair
#define IN insert
#define ALL(a) a.begin(),a.end()
typedef long long int ll;
int main() {
// ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output56.txt", "w", stdout);
#endif
ll t; cin >> t;
while (t--) {
ll k, n, m; cin >> k >> n >> m;
ll a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll b[m];
for (int i = 0; i < m; i++) {
cin >> b[i];
}
vector<ll> ans;
int i = 0; int j = 0;
int k0 = 0;
while (i < n && j < m) {
// cout << "d";
if (a[i] <= b[j]) {
if (a[i] > k) {k0 = 1; break;}
ans.push_back(a[i]);
if (a[i] == 0)k++;
i++;
}
else {
if (b[j] > k) {k0 = 1; break;}
ans.push_back(b[j]);
if (b[j] == 0)k++;
j++;
}
}
while (i < n) {
if (a[i] > k) {k0 = 1; break;}
ans.push_back(a[i]);
if (a[i] == 0)k++;
i++;
}
while (j < m) {
if (b[j] > k) {k0 = 1; break;}
ans.push_back(b[j]);
if (b[j] == 0)k++;
j++;
}
if (k0) {
cout << "-1\n";
}
else {
for (auto i : ans) {
cout << i << " ";
}
cout << endl;
}
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m, val, pos;
void fail() {
cout << "NO";
exit(0);
}
void ck(long long int p, long long int q, long long int z) {
if (val[q] == 1 || m[q] == 0) fail();
val[p] = 1;
val[q] = 1;
pos[p] = z;
pos[q] = z;
}
long long int a[1000002];
long long int b[1000002];
int main() {
long long int n, i, j, k, l, x, y, f, z, p, q;
f = 0;
z = 1;
cin >> n >> x >> y;
if (x > y) {
swap(x, y);
swap(f, z);
}
for (i = 0; i < int(n); i++) {
cin >> a[i];
b[i] = a[i];
m[a[i]] = i + 1;
}
sort(a, a + n);
for (i = n - 1; i >= 0; i--) {
p = a[i];
if (val[p] == 1) continue;
if (p >= y)
fail();
else if (p >= x) {
q = y - p;
ck(p, q, z);
} else {
q = x - p;
if (val[q] == 1 || m[q] == 0)
ck(p, y - p, z);
else
ck(p, q, f);
}
}
cout << "YES" << endl;
for (i = 0; i < n; i++) {
cout << pos[b[i]] << " ";
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
const int N = 1000005, mod = 1e9 + 7;
int n, m, l[N], r[N];
inline unsigned long long rnd() {
unsigned long long t = 0;
for (int i = 0; i < 10; i++) t = t << 10 ^ rand();
return t;
}
unsigned long long ha[N], ff[N], gg[N], s[N], S[N];
map<unsigned long long, long long> M1, M2;
long long ans, F[N];
int main() {
n = read();
m = read();
swap(n, m);
for (int i = 1; i <= n; i++) F[i] = F[i - 1] + (long long)i * (i + 1) / 2;
for (int i = 1; i <= m; i++) {
l[i] = read();
r[i] = read();
ha[i] = rnd();
ff[l[i]] ^= ha[i];
gg[r[i] + 1] ^= ha[i];
}
M1[0]++;
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1] ^ ff[i] ^ gg[i];
S[i] = S[i - 1] ^ s[i];
ff[i] ^= ff[i - 1];
gg[i] ^= gg[i - 1];
if (M1.count(ff[i] ^ S[i])) {
ans += M1[ff[i] ^ S[i]] * i - M2[ff[i] ^ S[i]];
}
M1[gg[i + 1] ^ gg[i] ^ S[i]]++;
M2[gg[i + 1] ^ gg[i] ^ S[i]] += i;
}
int dq = 0;
for (int i = 1; i <= n; i++)
if (s[i] == 0)
dq++;
else {
ans -= F[dq];
dq = 0;
}
ans -= F[dq];
cout << ans << endl;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
const int nMax = 1e6 + 5;
const long long mod = 1e9 + 7;
long long t, n, ps[1000005];
long long p[1000005];
vector<long long> v;
int binser(int x) {
int ans = -1, l = 0, r = v.size() - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (v[mid] * v[mid] <= x) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return ans + 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 2; i <= 1e6; i++) {
if (!p[i]) {
ps[i] = 1;
v.push_back(i);
int j = i;
while (j <= 1e6) {
p[j] = 1;
j += i;
}
}
}
ps[0] = 0;
for (int i = 1; i <= 1e6; i++) {
ps[i] += ps[i - 1];
}
cin >> t;
while (t--) {
cin >> n;
cout << ps[n] - binser(n) + 1 << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500010, M = 104;
inline int read() {
int s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
int n, K, P, a[N], qz[N], F[M][N], C[M];
const int INF = 0x3f3f3f3f;
inline int lowbit(int x) { return x & (-x); }
inline void Add(int x, int w) {
x++;
for (; x <= P; x += lowbit(x)) C[x] = min(C[x], w);
}
inline int Ask(int x) {
x++;
int now = INF;
for (; x; x -= lowbit(x)) now = min(now, C[x]);
return now;
}
signed main() {
n = read(), K = read(), P = read();
for (register int i = 1; i <= n; i++)
a[i] = read() % P, qz[i] = (qz[i - 1] + a[i]) % P;
memset(F, 0x3f, sizeof(F));
for (register int i = 0; i <= n; i++) F[0][i] = 0;
for (register int i = 1; i <= K; i++) {
int now = INF;
memset(C, 0x3f, sizeof(C));
for (register int j = 0; j <= n; j++) {
F[i][j] = min(now + P, Ask(qz[j]));
Add(qz[j], F[i - 1][j]);
now = min(now, F[i - 1][j]);
}
}
printf("%d\n", F[K][n] + qz[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> r[5555];
pair<int, int> c[5555];
int main() {
int n, m, k, i, j, ch, idx, cl;
cin >> n >> m >> k;
for (i = 1; i <= k; i++) {
cin >> ch >> idx >> cl;
if (ch == 1)
r[idx] = make_pair(cl, i);
else
c[idx] = make_pair(cl, i);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (r[i].second > c[j].second)
cout << r[i].first << ' ';
else
cout << c[j].first << ' ';
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 1e5 + 10;
using namespace std;
int book[1010], vis[1010];
struct node {
int num;
int flag;
} a[1010];
int main() {
int n, m, d;
while (~scanf("%d %d %d", &n, &m, &d)) {
memset(book, 0, sizeof(book));
memset(vis, 0, sizeof(vis));
long long ans = 0;
ans += (m + 1) * (d);
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i].num);
a[i].flag = i;
ans += a[i].num - 1;
}
if (ans < n + 1) {
printf("NO\n");
return 0;
} else {
printf("YES\n");
int i = 0;
for (int j = 1; j <= m; j++) {
i += d;
if (i > n) break;
int xx = a[j].num;
while (xx--) {
book[i] = j;
vis[j] = 1;
if (xx) i++;
}
}
int x = n;
for (int g = m; g >= 1; g--) {
if (book[x]) vis[book[x]] = 0;
if (vis[g] == 0) {
while (a[g].num--) {
if (book[x]) {
vis[book[x]] = 0;
}
book[x] = g;
x--;
}
vis[g] = 1;
}
}
for (int i = 1; i < n; i++) printf("%d ", book[i]);
printf("%d\n", book[n]);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline bool iseq(double x, double y) {
if (fabs(x - y) < 1e-8) return true;
return false;
}
template <typename T>
inline T Min(T a, T b) {
return ((a) < (b) ? (a) : (b));
}
template <typename T>
inline T Max(T a, T b) {
return ((a) > (b) ? (a) : (b));
}
template <typename T>
inline T hpt(T x1, T y1, T x2, T y2) {
return hypot(x1 - x2, y1 - y2);
}
template <typename T>
inline T gcd(T a, T b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
template <typename T>
inline void extended_euclid(T a, T b, T &x, T &y) {
if (a % b == 0)
x = 0, y = 1;
else {
extended_euclid(b, a % b, x, y);
T temp = x;
x = y;
y = -y * (a / b) + temp;
}
}
template <typename T>
inline T bigmod(T b, T p, T m) {
if (!p)
return 1;
else if (!(p % 2)) {
T x = bigmod(b, p / 2, m);
return x * x;
} else
return ((b % m) * bigmod(b, p - 1, m)) % m;
}
int prime[5 / 32 + 1];
void setbit(int i) {
int p = i >> 5, q = i & 31;
prime[p] |= (1 << q);
}
bool checkbit(int i) {
int p = i >> 5, q = i & 31;
return prime[p] & (1 << q) ? true : false;
}
void buildprime(int n) {
int i, j, k = sqrt(double(n));
prime[0] = 3;
for (i = 4; i < n; i += 2) setbit(i);
for (i = 3; i <= k; i += 2) {
if (!checkbit(i)) {
int ii = i + i;
for (j = i * i; j < n; j += ii) setbit(j);
}
}
}
int sum, r, n, N, R, C, t, txt, m;
string F[500050];
int B[500050];
long long mod = 1000003;
int Row(int x) {
int tot = 0;
for (int i = 0; i < (C + 1); i++) B[i] = 0;
for (int i = 0; i < (C); i++) {
if ('.' == F[x][i])
tot++;
else if ('1' == F[x][i] || '2' == F[x][i])
B[i] = 1;
else
B[i + 1] = 1;
}
if (tot == C) return 2;
int o = 0, e = 0;
for (int i = 0; i < (C + 1); i++)
if (B[i]) {
if (i % 2)
o++;
else
e++;
}
return !(o > 0 && e > 0);
return 1;
}
int Col(int x) {
int tot = 0;
for (int i = 0; i < (R + 1); i++) B[i] = 0;
for (int i = 0; i < (R); i++) {
if ('.' == F[i][x])
tot++;
else if ('1' == F[i][x] || '4' == F[i][x])
B[i] = 1;
else
B[i + 1] = 1;
}
if (tot == R) return 2;
int o = 0, e = 0;
for (int i = 0; i < (R + 1); i++)
if (B[i]) {
if (i % 2)
o++;
else
e++;
}
return !(o > 0 && e > 0);
return 1;
}
int main() {
while (scanf("%d%d", &R, &C) == 2) {
for (int i = 0; i < (R); i++) cin >> F[i];
long long ans = 1;
for (int i = 0; i < (R); i++) ans = (ans * Row(i)) % mod;
for (int i = 0; i < (C); i++) ans = (ans * Col(i)) % mod;
cout << ans << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int fa[101], a[101], d[101], c[101];
int n, i, j;
int Find(int x) { return fa[x] == x ? fa[x] : fa[x] = Find(fa[x]); }
void Union(int x, int y) { fa[Find(x)] = Find(y); }
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
fa[i] = i;
}
for (i = 1; i <= n; i++) {
cin >> d[i];
if (i + d[i] <= n) Union(i, i + d[i]);
if (i - d[i] >= 1) Union(i, i - d[i]);
}
for (i = 1; i <= n; i++)
if (Find(i) == i) {
memset(c, 0, sizeof(c));
for (j = 1; j <= n; j++)
if (Find(j) == i) c[j]++, c[a[j]]--;
for (j = 1; j <= n; j++)
if (c[j]) break;
if (j <= n) break;
}
if (i <= n) return puts("NO"), 0;
puts("YES");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double eps = (double)1e-8;
const int mod = (int)1000000007;
const int maxn = (int)1e5 + 5;
int n, m, l, c, kol, ans;
long long x;
int p[maxn], t[maxn], k[maxn], a[30];
vector<int> pr[maxn], prs;
char b[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
c = 0;
for (int i = (1); i <= (n); i++) {
cin >> a[i];
m += a[i];
if (a[i] & 1) c++;
}
if (n == 1) {
cout << a[1] << "\n";
for (int i = (1); i <= (a[1]); i++) cout << 'a';
return 0;
}
if (c >= 2) {
cout << 0 << "\n";
c = 1;
for (int i = (1); i <= (m); i++) {
while (a[c] == 0) c++;
a[c]--;
cout << char('a' + c - 1);
}
return 0;
}
for (int i = (2); i <= (1e5); i++) {
if (p[i]) continue;
x = (long long)i;
while (x <= 1e5) {
for (int j = x; j <= 1e5; j += x) {
p[j] = 1;
pr[j].push_back(i);
}
x *= (long long)i;
}
}
for (int i = (0); i < (pr[a[1]].size()); i++) {
k[pr[a[1]][i]]++;
t[pr[a[1]][i]] = 1;
}
for (int i = (2); i <= (n); i++) {
x = a[i];
kol = 0;
for (int j = (0); j < (pr[x].size()); j++) {
kol = 1;
while (j + 1 < pr[x].size() && pr[x][j + 1] == pr[x][j]) {
j++;
kol++;
}
if (t[pr[x][j]] != i - 1) {
k[pr[x][j]] = 0;
continue;
}
t[pr[x][j]] = i;
k[pr[x][j]] = min(kol, k[pr[x][j]]);
}
}
for (int i = (0); i < (pr[a[1]].size()); i++) {
if (t[pr[a[1]][i]] != n) k[pr[a[1]][i]] = 0;
for (int j = (1); j <= (k[pr[a[1]][i]]); j++) {
prs.push_back(pr[a[1]][i]);
}
k[pr[a[1]][i]] = 0;
}
c = 0;
for (int i = (1); i <= (n); i++) {
for (int j = (0); j < (prs.size()); j++) {
a[i] /= prs[j];
}
if (a[i] & 1) c++;
}
l = 0;
for (int i = (1); i <= (n); i++) l += a[i];
if (c >= 2) {
l *= 2;
for (int i = (1); i <= (n); i++) a[i] *= 2;
ans = 2 * (m / l);
c = 1;
for (int i = (1); i <= (l / 2); i++) {
while (a[c] <= 0) c++;
a[c] -= 2;
b[i] = char('a' + c - 1);
b[l - i + 1] = char('a' + c - 1);
}
for (int i = (l + 1); i <= (m); i++) {
b[i] = b[(i - 1) % l + 1];
}
} else {
ans = m / l;
for (int i = (1); i <= (n); i++)
if (a[i] & 1) c = i;
b[l / 2 + 1] = char('a' + c - 1);
a[c]--;
c = 1;
for (int i = (1); i <= (l / 2); i++) {
while (a[c] <= 0) c++;
a[c] -= 2;
b[i] = char('a' + c - 1);
b[l - i + 1] = char('a' + c - 1);
}
for (int i = (l + 1); i <= (m); i++) {
b[i] = b[(i - 1) % l + 1];
}
}
cout << ans << "\n";
for (int i = (1); i <= (m); i++) cout << b[i];
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
double pi = acos(-1);
struct point {
int x, y;
};
long long cross(point x, point y) { return x.x * y.y - x.y * y.x; }
long long dot(point x, point y) { return x.x * y.x + x.y * y.y; }
double nor(point a) {
double ans = dot(a, a);
return sqrt(ans);
}
bool ss(point a, point b) {
int quad_a, quad_b;
if (a.x > 0 && a.y == 0) quad_a = 1;
if (a.x > 0 && a.y > 0) quad_a = 2;
if (a.x == 0 && a.y > 0) quad_a = 3;
if (a.x < 0 && a.y > 0) quad_a = 4;
if (a.x < 0 && a.y == 0) quad_a = 5;
if (a.x < 0 && a.y < 0) quad_a = 6;
if (a.x == 0 && a.y < 0) quad_a = 7;
if (a.x > 0 && a.y < 0) quad_a = 8;
if (b.x > 0 && b.y == 0) quad_b = 1;
if (b.x > 0 && b.y > 0) quad_b = 2;
if (b.x == 0 && b.y > 0) quad_b = 3;
if (b.x < 0 && b.y > 0) quad_b = 4;
if (b.x < 0 && b.y == 0) quad_b = 5;
if (b.x < 0 && b.y < 0) quad_b = 6;
if (b.x == 0 && b.y < 0) quad_b = 7;
if (b.x > 0 && b.y < 0) quad_b = 8;
if (quad_a == quad_b) {
if (cross(a, b) != 0)
return !(cross(a, b) < 0);
else
return 0;
} else
return quad_a < quad_b;
}
int main() {
vector<point> v;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
point u;
cin >> u.x >> u.y;
v.push_back(u);
}
sort(v.begin(), v.end(), ss);
double ans = 0;
point a = v[0], b = v[v.size() - 1];
if (v.size() == 1) {
ans = 0;
cout << fixed << setprecision(8) << ans << endl;
} else if (v.size() == 2) {
if (cross(a, b) == 0 && dot(a, b) < 0)
ans = 180;
else if (cross(a, b) == 0 && dot(a, b) > 0)
ans = 0;
else
ans = 180 / pi * acos(dot(a, b) / nor(a) / nor(b));
cout << fixed << setprecision(8) << ans << endl;
} else {
double final = 1e9;
for (int i = 0; i < v.size(); i++) {
b = v[(i + 1) % (v.size())];
a = v[i];
ans = 180 / pi * asin(cross(a, b) / nor(a) / nor(b));
ans = abs(ans);
if (cross(a, b) > 0 && dot(a, b) < 0)
ans = 180 - ans;
else if (cross(a, b) < 0 && dot(a, b) < 0)
ans = 180 + ans;
else if (cross(a, b) < 0 && dot(a, b) > 0)
ans = 360 - ans;
else if (cross(a, b) == 0 && dot(a, b) > 0)
ans = 0;
else if (cross(a, b) > 0 && dot(a, b) == 0)
ans = 90;
else if (cross(a, b) == 0 && dot(a, b) < 0)
ans = 180;
else if (cross(a, b) < 0 && dot(a, b) == 0)
ans = 270;
ans = 360 - ans;
final = min(final, ans);
}
if (abs(final - 360) <= 1e-11) final = 0;
cout << fixed << setprecision(8) << final << endl;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
void chkmax(T& x, T y) {
if (x < y) x = y;
}
template <typename T>
void chkmin(T& x, T y) {
if (x > y) x = y;
}
inline int read() {
int x = 0;
char c = getchar();
while (c < 48) c = getchar();
while (c > 47) x = x * 10 + (c ^ 48), c = getchar();
return x;
}
const int maxn = 2e5 + 10;
int n, A[maxn];
vector<int> G[maxn];
int tot, L[maxn], R[maxn];
void dfs(int u, int f) {
L[u] = tot;
for (int v : G[u])
if (v != f) dfs(v, u);
R[u] = (tot += u > 1 && (int)G[u].size() == 1);
}
int par[maxn];
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
struct edge {
int u, v, w, tid;
} E[maxn];
void solve() {
cin >> n;
for (int i = (1), iend = (n); i <= iend; ++i) A[i] = read(), par[i] = i;
for (int i = (2), iend = (n); i <= iend; ++i) {
int u = read(), v = read();
G[u].push_back(v), G[v].push_back(u);
}
dfs(1, 0);
for (int i = (1), iend = (n); i <= iend; ++i) {
E[i] = {L[i], R[i], A[i], i};
}
sort(E + 1, E + n + 1, [](edge P, edge Q) { return P.w < Q.w; });
long long ans = 0;
vector<int> vec;
for (int i = (1), iend = (n); i <= iend; ++i) {
int j = i;
while (j < n && E[j + 1].w == E[i].w) j++;
for (int k = (i), kend = (j); k <= kend; ++k) {
int u = E[k].u, v = E[k].v;
if (find(u) != find(v)) vec.push_back(E[k].tid);
}
for (int k = (i), kend = (j); k <= kend; ++k) {
int u = E[k].u, v = E[k].v;
if (find(u) != find(v)) {
par[find(u)] = find(v), ans += E[k].w;
}
}
i = j;
}
cout << ans << ' ' << (int)vec.size() << endl;
sort(vec.begin(), vec.end());
for (int x : vec) printf("%d ", x);
}
signed main() {
solve();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int n, d;
cin >> n >> d;
if ((n + 1) * (n + 1) < 4 * d)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n;
std::cin >> n;
std::vector<int> fa(n, -1);
std::vector<std::vector<int>> son(n);
for (int i = 1; i < n; ++i) {
std::cin >> fa[i];
son[fa[i]].push_back(i);
}
std::vector<int> dis(n, 0);
for (int i = n - 1; i > 0; --i) {
if (fa[i] != -1) {
dis[fa[i]] = std::max(dis[fa[i]], dis[i] + 1);
}
}
for (int i = 0; i < n; ++i) {
std::sort(son[i].begin(), son[i].end(),
[&](int u, int v) { return dis[u] < dis[v]; });
}
std::vector<int> id;
std::vector<int> ans;
std::function<void(int)> dfs = [&](int u) {
id.push_back(u);
for (int v : son[u]) {
dfs(v);
}
for (int i = 1; i < (int)son[u].size(); ++i) {
for (int j = 0; j < dis[son[u][i - 1]] + 1; ++j) {
ans.push_back(son[u][i]);
}
}
};
dfs(0);
for (int i : id) {
std::cout << i << " ";
}
std::cout << "\n";
std::cout << ans.size() << "\n";
for (int i : ans) {
std::cout << i << " ";
}
std::cout << "\n";
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500;
int v[maxn + 5];
int vi;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n;
scanf("%d", &n);
map<int, int> cm;
priority_queue<int> pq;
for (int i = 0; i < n * n; i++) {
int num;
scanf("%d", &num);
cm[num]++;
pq.push(num);
}
vi = 0;
while (vi < n) {
while (!pq.empty()) {
int next = pq.top();
pq.pop();
if (cm.count(next) && cm[next]) {
v[vi] = next;
for (int i = 0; i < vi; i++) {
cm[gcd(v[i], next)] -= 2;
}
cm[next]--;
vi++;
break;
}
}
}
for (int i = 0; i < vi; i++) {
if (i > 0) {
printf(" ");
}
printf("%d", v[i]);
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 2222;
const long long INF = 1e18;
struct node {
int l, r;
} a[MN * MN];
int N, M, rk[MN][MN], lcp[MN][MN], r[MN], tot;
char s[MN];
long long dp[MN], K;
inline bool cmp(node a, node b) {
int p = a.l + lcp[a.l][b.l], q = b.l + lcp[a.l][b.l];
if (p > a.r || q > b.r) return a.r - a.l < b.r - b.l;
return s[p] < s[q];
}
inline long long calc(int mid) {
for (int i = 1; i <= N; ++i) {
r[i] = i;
while (r[i] <= N && rk[i][r[i]] < mid) ++r[i];
}
memset(dp, 0, sizeof(dp));
dp[N + 1] = 1;
for (int i = 1; i <= M; ++i) {
for (int j = N; j >= 1; --j)
dp[j] = dp[j] + dp[j + 1] < INF ? dp[j] + dp[j + 1] : INF;
for (int j = 1; j <= N; ++j) dp[j] = r[j] <= N ? dp[r[j] + 1] : 0;
dp[N + 1] = 0;
}
return dp[1];
}
int main() {
scanf("%d%d%lld%s", &N, &M, &K, s + 1);
for (int i = N; i >= 1; --i)
for (int j = N; j >= 1; --j)
if (s[i] == s[j]) lcp[i][j] = lcp[i + 1][j + 1] + 1;
for (int i = 1; i <= N; ++i)
for (int j = i; j <= N; ++j) a[++tot] = (node){i, j};
sort(a + 1, a + 1 + tot, cmp);
for (int i = 1; i <= tot; ++i) rk[a[i].l][a[i].r] = i;
int lft = 1, rht = tot, res;
while (lft <= rht) {
int mid = lft + rht >> 1;
if (calc(mid) >= K) {
lft = mid + 1;
res = mid;
} else
rht = mid - 1;
}
for (int i = a[res].l; i <= a[res].r; ++i) putchar(s[i]);
return 0;
}
| 20 |
#include <bits/stdc++.h>
const int N = 1e6 + 19;
const int mod = 998244353;
using namespace std;
int get_second(pair<int, int> i) { return i.second; }
long long power(long long x, long long y) {
int res = 1;
x = x % mod;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
int trail_zero(int n) {
while (n % 10 == 0) n /= 10;
return n;
}
map<long long, long long> mc;
multiset<long long> second;
map<pair<long long, long long>, long long> m1;
vector<pair<int, int>> v;
vector<int> val(N);
map<char, int> m4;
map<char, int> m5;
char s111[N];
long long p2[N], p3[N];
long long n, k, m, x, q, y, ans1 = INT_MAX;
bool check(int a, int b) {
if (a >= 0 || a < n) return true;
if (b >= 0 || b < m)
return true;
else
return false;
}
int dx[] = {0, -1, 0, 1};
int dy[] = {1, 0, -1, 0};
vector<vector<long long>> adj(N), ans[4];
vector<long long> vis(N), in(N), out(N), cnt(N);
vector<long long> cx;
map<long long, long long> mxx;
int xxx[111][111];
int used[100][100];
vector<pair<int, int>> e(100002), o(100002);
bool prime_check(long long a) {
if (a == 2) return true;
for (long long i = 2; i <= sqrt(a); i++) {
if (a % i) continue;
return false;
}
return true;
}
int smallest_divisor(long long a) {
for (int i = 2; i * i <= a; i++) {
if (a % i == 0) return i;
}
return a;
}
bool con(char c) {
if (c != 'a' && c != 'e' && c != 'i' && c != 'o' && c != 'u')
return true;
else
return false;
}
long long first[N], g[N], h[N];
long long a[3];
int checkr(int x, int y) {
long long sum = 0;
for (int i = x; i <= y; i++)
for (int j = 1; j <= m; j++) sum += xxx[i][j];
return sum;
}
int checkc(int x, int y) {
long long sum = 0;
for (int i = x; i <= y; i++)
for (int j = 1; j <= n; j++) sum += xxx[j][i];
return sum;
}
int max_ans = 0;
int t = 0, l = 0;
long long ind[100000], mx = 0;
vector<long long> color(N);
set<long long> s2[N];
void dfs(long long x) {
vis[x] = 1;
for (auto i : adj[x]) {
if (color[i] != color[x]) {
s2[color[i]].insert(color[x]);
s2[color[x]].insert(color[i]);
}
if (!vis[i]) dfs(i);
}
}
long long a3[N], v2[N];
string names[N];
int points[N];
map<string, int> m3, m2;
int main() {
int n, l, r, x;
cin >> n >> l >> r >> x;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int cnt = 0;
for (int i = 1; i <= (1 << n); i++) {
int sum = 0, mx = -1, mn = INT_MAX;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
sum += a[j];
mx = max(mx, a[j]);
mn = min(mn, a[j]);
}
}
if (sum >= l && sum <= r && (mx - mn) >= x) cnt++;
}
cout << cnt;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 333;
const double eps = 1e-10;
struct Point {
double x, y;
Point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
} p[N];
Point operator-(Point a, Point b) { return Point(a.x - b.x, a.y - b.y); }
double cross(Point a, Point b) { return (a.x * b.y - b.x * a.y) * 0.5; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf%lf", &p[i].x, &p[i].y);
double ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
double lmax, rmax;
lmax = rmax = 0;
for (int k = 0; k < n; k++) {
if (k == i || k == j) continue;
double s = cross(p[i] - p[k], p[j] - p[k]);
if (s < eps)
lmax = max(lmax, -s);
else
rmax = max(rmax, s);
}
if (lmax == 0 || rmax == 0) continue;
ans = max(ans, lmax + rmax);
}
}
printf("%.9lf\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int solve1(int n, int a, int b, int T, string s) {
int pre = 0;
vector<int> v;
for (int i = n - 1; i >= 0; --i) {
if (s[i] == 'w') {
pre += b;
}
pre += 1;
v.push_back(pre);
pre += a;
}
int mxlen = 0;
pre = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == 'w') {
pre += b;
}
pre += 1;
if (pre > T) {
break;
}
int temp = (T - pre - (i + 1) * a);
int k = upper_bound(v.begin(), v.end(), temp) - v.begin();
mxlen = max(mxlen, i + 1);
mxlen = max(mxlen, i + 1 + k);
pre += a;
}
return min(mxlen, n);
}
int solve2(int n, int a, int b, int T, string s) {
int pre = 0;
vector<int> v;
for (int i = 1; i < n; ++i) {
if (s[i] == 'w') {
pre += b;
}
pre += 1;
v.push_back(pre);
pre += a;
}
int mxlen = 0;
pre = 0;
if (s[0] == 'w') {
pre += b;
}
pre += 1;
if (pre > T) {
return 0;
}
pre += a;
mxlen = 1;
for (int i = n - 1; i >= 1; --i) {
if (s[i] == 'w') {
pre += b;
}
pre += 1;
if (pre > T) {
break;
}
int temp = (T - pre - (n - i + 1) * a);
int k = upper_bound(v.begin(), v.end(), temp) - v.begin();
mxlen = max(mxlen, n - i + 1);
mxlen = max(mxlen, n - i + 1 + k);
pre += a;
}
return min(mxlen, n);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b, T;
cin >> n >> a >> b >> T;
string s;
cin >> s;
int x = solve1(n, a, b, T, s);
int y = solve2(n, a, b, T, s);
cout << max(x, y) << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 10;
int m, nf, ne, ns, cnt[N], upp[N], sum;
double rf, re, rs, df, de, ans, diff[N * 2];
inline void trans(double& d) { d = sqrt(d * d - 1); }
inline int pos(int i) { return (i >= sum / 2) ? i - sum / 2 : i; }
inline double calc(double r0, int x0, double r1, int x1) {
return max(min(x0 + r0, x1 + r1) - max(x0 - r0, x1 - r1), 0.0);
}
int main() {
scanf("%d %d %d", &nf, &ne, &ns);
scanf("%lf %lf %lf", &rf, &re, &rs);
trans(rf);
trans(re);
trans(rs);
scanf("%lf %lf", &df, &de);
sum = nf + ne + ns;
m = (sum + 1) / 2;
for (int i = 0; i < sum; ++i) ++upp[pos(i)];
vector<bool> prm(ns, true);
prm.resize(sum);
do {
memset(cnt, 0, m * sizeof(int));
for (int i = 0; i < sum; ++i) cnt[pos(i)] += prm[i];
int tmp_cnt = 0;
double tmp_ans = 0;
for (int i = 0; i < m; ++i) {
if (cnt[i] < upp[i]) {
for (int k = cnt[i]; k < upp[i]; ++k) {
double ff = 2 * rf * df, ee = 2 * re * de;
for (int j = 0; j < m; ++j) {
if (cnt[j]) {
ff += df * calc(rf, i, rs, j) * cnt[j];
ee += de * calc(re, i, rs, j) * cnt[j];
}
}
diff[tmp_cnt++] = ee - ff;
tmp_ans += ee;
}
}
}
sort(diff, diff + tmp_cnt);
for (int i = 0; i < nf; ++i) tmp_ans -= diff[i];
ans = max(ans, tmp_ans);
} while (prev_permutation(prm.begin(), prm.end()));
printf("%.8f\n", ans);
}
| 18 |
#include <bits/stdc++.h>
const int INF = 1e9 + 12312, MOD = 1e9, MAXN = 200000;
const long double EPS = 0.0000000001;
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
int ans = 0;
if (t % 2) {
t -= 9;
ans++;
}
if (t % 4) {
t -= 6;
ans++;
}
if (t % 4 || t < 0) {
cout << -1;
} else
cout << ans + t / 4;
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
const long long maxn = 1e6 + 10;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 10;
long long p[maxn];
long long fen[2][maxn];
inline long long get(long long id, long long x) {
x++;
long long ret = 0;
for (; x > 0; x -= x & -x) ret += fen[id][x];
return ret;
}
inline void add(long long id, long long x) {
x++;
for (; x < maxn; x += x & -x) fen[id][x]++;
}
long long l[maxn], d[maxn], r[maxn], u[maxn];
vector<long long> Q[maxn];
long long totallyUp[maxn], totallyDown[maxn], bs[maxn];
inline long long C2(long long x) { return x * (x - 1) / 2; }
int32_t main() {
long long n = in(), q = in();
for (long long i = 0; i < n; i++) p[i] = in() - 1;
for (long long i = 0; i < maxn; i++) totallyUp[i] = totallyDown[i] = 1;
for (long long i = 0; i < q; i++) {
l[i] = in() - 1, d[i] = in() - 1, r[i] = in() - 1, u[i] = in() - 1;
Q[r[i]].push_back(i);
if (l[i] != r[i]) Q[l[i]].push_back(i);
}
for (long long i = 0; i < n; i++) {
for (auto q : Q[i]) {
if (l[q] == i) {
bs[q] += C2(i);
bs[q] -= C2(get(0, d[q] - 1));
bs[q] -= C2(i - get(0, u[q]));
}
}
add(0, p[i]);
}
for (long long i = 0; i < q; i++) {
bs[i] += C2(get(0, d[i] - 1));
bs[i] += C2(n - get(0, u[i]));
}
for (long long i = n - 1; i >= 0; i--) {
for (auto q : Q[i]) {
if (r[q] == i) {
bs[q] += C2(n - i - 1);
bs[q] -= C2(n - i - 1 - get(1, u[q]));
bs[q] -= C2(get(1, d[q] - 1));
}
}
add(1, p[i]);
}
for (long long i = 0; i < q; i++) {
cout << C2(n) - bs[i] << "\n";
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, ans;
int a[111];
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (m + i >= 1 && m + i <= n) {
if (a[m + i] != 0 && a[m + i] <= k) {
ans = i;
break;
}
}
if (m - i >= 1 && m - i <= n) {
if (a[m - i] != 0 && a[m - i] <= k) {
ans = i;
break;
}
}
}
cout << ans * 10;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool DBG = false;
template <typename T, typename S>
std::ostream& operator<<(std::ostream& os, const std::pair<T, S>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vector) {
for (size_t i = 0; i < vector.size(); ++i) {
os << (i > 0 ? " " : "") << vector[i];
}
return os;
}
template <typename T>
std::ostream& operator<<(std::ostream& os,
const std::vector<std::vector<T>>& vector) {
for (size_t i = 0; i < vector.size(); ++i) {
os << vector[i] << std::endl;
}
return os;
}
long long solve(int n, const string& s, const vector<int>& a) {
const string kWord = "hard";
const int kMaxLen = kWord.length();
vector<vector<long long>> dp(n, vector<long long>(kMaxLen, 0));
dp[0][0] = s[0] == 'h' ? a[0] : 0;
for (int i = 1; i < n; ++i) {
for (int len = 0; len < kMaxLen; ++len) {
if (s[i] != kWord[len]) {
dp[i][len] = dp[i - 1][len];
} else {
if (len > 0) {
dp[i][len] = min(dp[i - 1][len - 1], dp[i - 1][len] + a[i]);
} else {
dp[i][len] = dp[i - 1][len] + a[i];
}
}
}
}
return *min_element(dp[n - 1].begin(), dp[n - 1].end());
}
long long solve_naive(int n, const string& s, const vector<int>& a) {
const string kWord = "hard";
long long result = numeric_limits<long long>::max();
for (int mask = 0; mask < (int)((1 << n)); ++mask) {
size_t word_index = 0;
long long mask_result = 0;
for (int i = 0; i < n && word_index < kWord.size(); ++i) {
if ((mask >> i) & 1) {
word_index += (s[i] == kWord[word_index] ? 1 : 0);
} else {
mask_result += a[i];
}
}
if (word_index < kWord.size()) {
result = min(result, mask_result);
}
}
return result;
}
string generate_string(size_t length) {
const string kTemplate = "hard";
stringstream stream;
for (int i = 0; i < (int)(length); ++i) {
stream << kTemplate[rand() % kTemplate.size()];
}
return stream.str();
}
vector<int> generate_weights(size_t length, size_t max_weight) {
vector<int> w(length);
for (int i = 0; i < (int)(length); ++i) {
w[i] = 1 + rand() % max_weight;
}
return w;
}
void test() {
srand(123);
const size_t kTests = 1000000;
const size_t kMaxLength = 10;
const size_t kMaxWeight = 100;
for (int ti = 0; ti < (int)(kTests); ++ti) {
auto length = 1 + rand() % kMaxLength;
auto str = generate_string(length);
auto weights = generate_weights(length, kMaxWeight);
auto result = solve(length, str, weights);
auto expected_result = solve_naive(length, str, weights);
clog << "#" << ti + 1 << " length: " << length << " str: " << str
<< " weights: " << weights << " result: " << result
<< " expected_result: " << expected_result << endl;
assert(result == expected_result);
}
exit(1);
}
int main() {
ios_base::sync_with_stdio(false);
int n;
string s;
cin >> n >> s;
vector<int> a(n);
for (int i = 0; i < (int)(n); ++i) {
cin >> a[i];
}
cout << solve(n, s, a) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[8] = {0, 1, 0, -1, 1, -1, 1, -1};
int b[8] = {1, 0, -1, 0, 1, -1, -1, 1};
queue<pair<int, int> > q;
int n, m, dot, z, t, u, v;
char c[2010][2010];
bool fr[2010][2010];
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = (1), _b = (m); j <= _b; j++) cin >> c[i][j];
for (int i = (1), _b = (n - 1); i <= _b; i++)
for (int j = (1), _b = (m - 1); j <= _b; j++) {
fr[i][j] = true;
dot = 0;
if (c[i][j] == '.') dot++;
if (c[i + 1][j] == '.') dot++;
if (c[i][j + 1] == '.') dot++;
if (c[i + 1][j + 1] == '.') dot++;
if (dot == 4) fr[u][v] = false;
if (dot == 3) {
fr[i][j] = false;
q.push(pair<int, int>(i, j));
c[i][j] = c[i + 1][j] = c[i][j + 1] = c[i + 1][j + 1] = '.';
}
}
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
z = p.first;
t = p.second;
for (int i = (0), _b = (7); i <= _b; i++) {
u = z + a[i];
v = t + b[i];
if (u >= 1 && u < n && v >= 1 && v < m)
if (fr[u][v]) {
dot = 0;
if (c[u][v] == '.') dot++;
if (c[u + 1][v] == '.') dot++;
if (c[u][v + 1] == '.') dot++;
if (c[u + 1][v + 1] == '.') dot++;
if (dot == 4) fr[u][v] = false;
if (dot == 3) {
fr[u][v] = false;
q.push(pair<int, int>(u, v));
c[u][v] = c[u + 1][v] = c[u][v + 1] = c[u + 1][v + 1] = '.';
}
}
}
}
for (int i = (1), _b = (n); i <= _b; i++) {
for (int j = (1), _b = (m); j <= _b; j++) cout << c[i][j];
cout << endl;
}
return 0;
}
| 16 |
#include<bits/stdc++.h>
#define fi first
#define se second
#define INF 100000000000000000LL
#define ll long long
#define debug(x) cout << #x << " "<< x <<endl;
#define debug_vector(v) cout << #v << " "; _print(v);
const ll inf =1e9+44;
const int MAX=3e5+9;
const ll MOD= 1e9+7;
const double eps=1e-10;
double const PI=3.1415926535897931;
using namespace std;
int dx[4] = {1 ,0 , - 1, 0};
int dy[4] = {0 ,1 , 0 , -1};
void _print(vector<int> v){
cout << "[ ";
for ( auto u : v)
cout << u << " ";
cout << " ]"<< endl;
}
int main(){
int test;
cin >> test;
while (test--){
int n;
cin >> n;
vector < ll> v(n+1);
vector < ll > pre(n+1);
pre[0] = 0;
for (int i = 1; i <= n ; i++)
cin >> v[i];
sort(v.begin()+1 , v.end());
vector < ll > edges(n+1);
for (int i = 2; i<=n ; i++)
edges[i] = v[i]-v[i-1];
for (int i = 2; i <=n; i++)
pre[i] = (edges[i])*(long long )(i-1) + pre[i-1];
ll tot = 0;
for (int i = 2; i <=n; i++)
tot = tot + edges[i] -pre[i];
cout << tot << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long inff = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const int maxn = 20;
double dp[1 << maxn][maxn], pk[maxn][maxn];
int bit[1 << maxn], vis[1 << maxn][maxn], n;
double solve(int st, int cp) {
double &ans = dp[st][cp];
if (vis[st][cp]) return dp[st][cp];
vis[st][cp] = 1;
if (bit[st] == 1) {
if (st & 1)
return ans = 1.0;
else
return ans = 0.0;
}
if (cp == 0) {
for (int i = (0); i <= (int)(n - 2); ++i) {
for (int j = (i + 1); j <= (int)(n - 1); ++j) {
ans = max(ans, pk[i + 1][j + 1] * solve(st ^ (1 << j), i + 1) +
pk[j + 1][i + 1] * solve(st ^ (1 << i), j + 1));
}
}
return ans;
}
double p = 1.0 / (bit[st] - 1);
for (int i = (0); i <= (int)(n - 1); ++i) {
if ((st & (1 << i)) == 0 || i + 1 == cp) continue;
ans = max(ans, pk[i + 1][cp] * solve(st ^ (1 << (cp - 1)), i + 1) +
pk[cp][i + 1] * solve(st ^ (1 << (i)), cp));
}
return ans;
}
int main() {
scanf("%d", &(n));
for (int i = (1); i <= (int)(n); ++i)
for (int j = (1); j <= (int)(n); ++j) scanf("%lf", &pk[i][j]);
for (int st = (1); st <= (int)((1 << n) - 1); ++st)
bit[st] = bit[st >> 1] + (st & 1);
printf("%.9f\n", solve((1 << n) - 1, 0));
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2010;
const int inf = 1e9 + 1e8;
int N, par[MAXN], c[MAXN];
vector<int> graph[MAXN];
bool works = true;
int ans[MAXN], sz[MAXN], root, solved;
int get_min(int cur) {
int min_val = ans[cur];
for (int node : graph[cur]) {
min_val = min(min_val, get_min(node));
}
return min_val;
}
void dfs(int cur, int rev) {
if (ans[cur] >= rev) {
ans[cur]++;
}
for (int node : graph[cur]) {
dfs(node, rev);
}
return;
}
void solve(int cur) {
sz[cur] = 1;
if (graph[cur].size() == 0) {
if (c[cur] >= sz[cur]) {
works = false;
return;
}
ans[cur] = c[cur] + solved + 1;
solved++;
return;
}
for (int node : graph[cur]) {
solve(node);
sz[cur] += sz[node];
}
if (c[cur] >= sz[cur]) {
works = false;
return;
}
ans[cur] = inf;
int minn = get_min(cur);
dfs(cur, minn + c[cur]);
ans[cur] = minn + c[cur];
solved++;
return;
}
int main() {
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> par[i] >> c[i];
if (par[i] == 0) {
root = i;
continue;
}
graph[par[i]].push_back(i);
}
solve(root);
if (!works) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= N; i++) {
cout << ans[i] << ' ';
}
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m;
int x[100005], y[100005];
long long dx = 1;
int cnt[100005];
int ans = 2;
map<int, int> num;
map<int, int>::iterator it;
void solve() {
long long q = 2 * dx;
if (!q) q = -1 << 30;
for (int i = 1; i <= n; i++) num[x[i] % q]++;
for (int i = 1; i <= m; i++) num[(y[i] + dx) % q]++;
for (it = num.begin(); it != num.end(); it++) ans = max(ans, it->second);
num.clear();
}
int main() {
n = Get(), Get();
for (int i = 1; i <= n; i++) x[i] = Get();
m = Get(), Get();
for (int i = 1; i <= m; i++) y[i] = Get();
while (dx <= 1e9) {
solve();
dx <<= 1;
}
cout << ans;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1011;
double bad[MN], f[MN], p[MN][MN];
bool done[MN];
int n;
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout << (fixed) << setprecision(9);
while (scanf("%d", &n) == 1) {
for (int i = (1), _b = (n); i <= _b; ++i)
for (int j = (1), _b = (n); j <= _b; ++j) {
int t;
scanf("%d", &t);
p[i][j] = t / (double)100.0;
if (i == j) p[i][j] = 1.0;
}
f[n] = 0.0;
for (int i = (1), _b = (n - 1); i <= _b; ++i) {
bad[i] = 1 - p[i][n];
f[i] = (double)1.0 / p[i][n];
}
memset(done, 0, sizeof done);
done[n] = true;
for (int turn = (1), _b = (n - 1); turn <= _b; ++turn) {
int best = -1;
for (int i = (1), _b = (n); i <= _b; ++i)
if (!done[i]) {
if (best < 0 || f[i] < f[best]) best = i;
}
done[best] = true;
for (int i = (1), _b = (n); i <= _b; ++i)
if (!done[i] && p[i][best] > 1e-9) {
if (fabs(1 - bad[i]) < 1e-9) {
f[i] = (p[i][best] * f[best] + 1) / p[i][best];
bad[i] = 1 - p[i][best];
} else {
double S = f[i] * (1 - bad[i]) - bad[i];
double bad2 = bad[i] * (1 - p[i][best]);
double f2 =
(S + bad[i] * p[i][best] * (f[best] + 1) + bad2) / (1 - bad2);
bad[i] = bad2;
f[i] = f2;
}
if (bad[i] < 1e-90) bad[i] = 0;
}
}
cout << f[1] << endl;
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int f[3];
int temp = 0;
int k[800000];
bool check(int f[]) {
memset(k, 0, sizeof(k));
for (int i = 0; i <= 30; i++) {
k[1 + i * f[0]] = 1;
k[2 + i * f[1]] = 1;
k[3 + i * f[2]] = 1;
}
for (int j = 1; j <= 20; j++) {
if (k[j] != 1) {
return 0;
}
}
return 1;
}
int main() {
cin >> a >> b >> c;
if (!(a > 10 && b > 10 && c > 10)) {
f[0] = a;
f[1] = b;
f[2] = c;
sort(f, f + 3);
do {
if (check(f)) {
temp = 1;
}
} while (next_permutation(f, f + 3));
}
if (temp == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, pair<long long, long long> > dp;
long long N;
pair<long long, long long> DP(long long n, long long mx) {
if (n < 10) return pair<long long, long long>(1LL, n - max(mx, n));
pair<long long, long long> ret = pair<long long, long long>(n, mx);
if (dp.find(ret) != dp.end()) return dp[ret];
pair<long long, long long> ans = pair<long long, long long>(0, 0);
long long bigbit = 1LL;
while (bigbit < n) bigbit *= 10LL;
if (bigbit > n) bigbit /= 10LL;
while (n > 0) {
pair<long long, long long> tmp = DP(n % bigbit, max(mx, n / bigbit));
ans.first += tmp.first;
n = n - n % bigbit + tmp.second;
}
ans.second = n;
dp.insert(
pair<pair<long long, long long>, pair<long long, long long> >(ret, ans));
return ans;
}
int main() {
dp.clear();
while (cin >> N) {
if (N > 0)
cout << DP(N, 0).first << endl;
else
cout << "0" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> child[100007];
unordered_map<string, int> levelName[100007];
int uniqueLevelNames[2 * 100007];
int p[100007];
string name[100007];
int subtreeSize[100007];
int level[100007];
int maxChild[100007];
void dfs(int u) {
subtreeSize[u] = 1;
maxChild[u] = -1;
for (int v : child[u]) {
level[v] = level[u] + 1;
dfs(v);
subtreeSize[u] += subtreeSize[v];
if (maxChild[u] == -1 || subtreeSize[v] > subtreeSize[maxChild[u]])
maxChild[u] = v;
}
}
vector<int> queries[100007];
void add(int u) {
if (levelName[level[u]][name[u]]++ == 0) uniqueLevelNames[level[u]]++;
for (int v : child[u]) {
add(v);
}
}
void remoove(int u) {
if (--levelName[level[u]][name[u]] == 0) uniqueLevelNames[level[u]]--;
for (int v : child[u]) {
remoove(v);
}
}
int ans[100007];
void calculate(int u, int keep) {
for (int v : child[u]) {
if (v != maxChild[u]) calculate(v, 0);
}
if (maxChild[u] != -1) calculate(maxChild[u], 1);
for (int v : child[u])
if (v != maxChild[u]) add(v);
if (levelName[level[u]][name[u]]++ == 0) uniqueLevelNames[level[u]]++;
for (int i = 0; i < queries[u].size(); i += 2) {
ans[queries[u][i + 1]] = uniqueLevelNames[level[u] + queries[u][i]];
}
if (keep == 0) remoove(u);
}
int main(void) {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> name[i] >> p[i];
child[p[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (p[i] == 0) dfs(i);
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int v, k;
cin >> v >> k;
queries[v].push_back(k);
queries[v].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (p[i] == 0) calculate(i, 0);
}
for (int i = 1; i <= m; i++) cout << ans[i] << '\n';
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int a[36] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int b[36] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int c[36] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int d[36] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int m[36];
int main() {
int n, flag;
while (cin >> n) {
flag = 1;
for (int i = 0; i < n; i++) cin >> m[i];
for (int i = 0; i < 36; i++) {
if (m[0] == a[i]) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (i + j > 35) break;
if (m[j] == a[i + j]) cnt++;
}
if (cnt == n) {
cout << "YES" << endl;
flag = 0;
break;
}
}
}
if (!flag) continue;
for (int i = 0; i < 36; i++) {
if (m[0] == b[i]) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (i + j > 35) break;
if (m[j] == b[i + j]) cnt++;
}
if (cnt == n) {
cout << "YES" << endl;
flag = 0;
break;
}
}
}
if (!flag) continue;
for (int i = 0; i < 36; i++) {
if (m[0] == c[i]) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (i + j > 35) break;
if (m[j] == c[i + j]) cnt++;
}
if (cnt == n) {
cout << "YES" << endl;
flag = 0;
break;
}
}
}
if (!flag) continue;
for (int i = 0; i < 36; i++) {
if (m[0] == d[i]) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (i + j > 35) break;
if (m[j] == d[i + j]) cnt++;
}
if (cnt == n) {
cout << "YES" << endl;
flag = 0;
break;
}
}
}
if (!flag) continue;
if (flag) cout << "NO" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long w, c;
};
bool comp(node i, node j) { return (i.c > j.c); }
long long dp[300020];
long long ans;
node arr[100005];
int main() {
long long i, j, n, m;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> arr[i].w >> arr[i].c;
arr[i].c = ((arr[i].c * 6) / arr[i].w);
}
sort(arr, arr + n, comp);
long long tot = 0;
for (i = 0; i < n; i++) {
tot += arr[i].w;
tot = min(tot, m);
for (j = tot; tot - j < 4 && j >= arr[i].w; j--) {
dp[j] = max(dp[j], dp[j - arr[i].w] + ((arr[i].c * arr[i].w) / 6));
ans = max(ans, dp[j]);
}
}
cout << ans << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long a[4], mins = 1000000000000;
long long c, A, B;
int main() {
for (int i = 0; i < 4; i++) cin >> a[i];
char s[3];
for (int i = 0; i < 3; i++) cin >> s[i];
sort(a, a + 4);
do {
c = a[0];
for (int i = 0; i < 3; i++) {
if (s[i] == '+') c += a[i + 1];
if (s[i] == '*') c *= a[i + 1];
}
mins = min(c, mins);
if (s[0] == '+')
A = a[0] + a[1];
else
A = a[0] * a[1];
if (s[1] == '+')
B = a[2] + a[3];
else
B = a[2] * a[3];
long long temp = 0;
if (s[2] == '*')
temp = A * B;
else
temp = A + B;
mins = min(mins, temp);
} while (next_permutation(a, a + 4));
cout << mins << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1e6 + 5;
string s;
int N, cnt;
bool Add[Nmax];
int main() {
ios ::sync_with_stdio(false);
cin >> s;
N = s.size();
for (int i = 0; i < N; ++i) {
if (!i || s[i] ^ s[i - 1])
Add[++cnt] = 1;
else
Add[cnt] = 0;
}
if (s[0] == s[N - 1]) Add[1] = 0, --cnt;
int temp = 0, ans = 0;
for (int i = 1; i <= cnt; ++i) {
if (Add[i])
++temp;
else
ans += (temp >> 1) + 1, temp = 0;
}
cout << ans + (temp >> 1) << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int l1, r1, l2, r2;
cin >> l1 >> r1 >> l2 >> r2;
long long int a = (r1 + l1) / 2;
long long int b = (r2 + l2) / 2;
if (a == b) {
cout << a << " " << b + 1 << '\n';
;
} else {
cout << a << " " << b << '\n';
;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool flag = false;
int x = 0, y = 0, z = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if ((a[i] == (a[j] + a[k])) && (i != j && j != k)) {
x = i + 1;
y = j + 1;
z = k + 1;
flag = true;
}
}
}
}
if (flag == true) {
cout << x << " " << y << " " << z;
} else {
cout << "-1";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, mod = 1e9 + 7;
int sum[N << 2];
inline void read(int &x) {
char ch;
int t = 0;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') t = 1;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - 48, ch = getchar())
;
if (t) x = -x;
}
void pushup(int rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; }
void update(int p, int c, int l, int r, int rt) {
if (l == r) {
sum[rt] += c;
return;
}
int m = (l + r) >> 1;
if (p <= m)
update(p, c, l, m, rt << 1);
else
update(p, c, m + 1, r, rt << 1 | 1);
pushup(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return sum[rt];
int m = (l + r) >> 1, ret = 0;
if (L <= m) ret += query(L, R, l, m, rt << 1);
if (m < R) ret += query(L, R, m + 1, r, rt << 1 | 1);
return ret;
}
void build(int l, int r, int rt) {
if (l == r) {
sum[rt] = 1;
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt);
}
int search(int p, int l, int r, int rt) {
if (l == r) {
sum[rt]--;
return l;
}
int m = (l + r) >> 1, t;
if (sum[rt << 1] >= p)
t = search(p, l, m, rt << 1);
else
t = search(p - sum[rt << 1], m + 1, r, rt << 1 | 1);
pushup(rt);
return t;
}
int a[N], b[N], c[N], a1[N], b1[N], ans[N];
int main() {
int T, n, m, i, j, k, x, y, s, t;
scanf("%d", &n);
for (i = 0; i < n; i++) read(a[i]);
for (i = 0; i < n; i++) read(b[i]);
memset(sum, 0, sizeof(sum));
for (i = n - 1; i >= 0; i--) {
a1[i] = query(0, a[i], 0, n - 1, 1);
update(a[i], 1, 0, n - 1, 1);
}
memset(sum, 0, sizeof(sum));
for (i = n - 1; i >= 0; i--) {
b1[i] = query(0, b[i], 0, n - 1, 1);
update(b[i], 1, 0, n - 1, 1);
}
for (t = 0, i = n - 2; i >= 0; i--) {
k = n - i;
c[i] = a1[i] + b1[i] + t;
t = 0;
if (c[i] >= k) t++, c[i] %= k;
}
build(0, n - 1, 1);
for (i = 0; i < n; i++) printf("%d ", search(c[i] + 1, 0, n - 1, 1));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const int MAX_N = 200200;
int n, q;
long long arr[MAX_N];
long long mpow(long long base, long long exp) {
if (exp == 0) return 1;
long long res = mpow(base, exp / 2);
res *= res;
res %= MOD;
if (exp % 2 == 1) {
res *= base;
res %= MOD;
}
return res;
}
long long inv(long long x) { return mpow(x, MOD - 2); }
long long suffprod[MAX_N];
long long suffinvsum[MAX_N];
long long getExpected(int l, int r) {
if (r == n) return suffinvsum[l];
long long res = suffinvsum[l] - suffinvsum[r];
res %= MOD;
res += MOD;
res %= MOD;
res *= suffprod[r];
res %= MOD;
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
arr[i] = (x * inv(100)) % MOD;
}
suffprod[n - 1] = arr[n - 1];
for (int i = (n - 1) - 1; i >= 0; i--)
suffprod[i] = (suffprod[i + 1] * arr[i]) % MOD;
suffinvsum[n - 1] = inv(suffprod[n - 1]);
for (int i = (n - 1) - 1; i >= 0; i--)
suffinvsum[i] = (suffinvsum[i + 1] + inv(suffprod[i])) % MOD;
long long ans = getExpected(0, n);
set<int> checkpoints;
checkpoints.insert(0);
checkpoints.insert(n);
while (q--) {
int idx;
cin >> idx;
idx--;
if (checkpoints.count(idx)) {
checkpoints.erase(idx);
auto it = checkpoints.upper_bound(idx);
int idxR = *it;
int idxL = *prev(it);
long long oldNum =
(getExpected(idxL, idx) + getExpected(idx, idxR)) % MOD;
long long newNum = getExpected(idxL, idxR);
ans -= oldNum;
ans %= MOD;
ans += MOD;
ans %= MOD;
ans += newNum;
ans %= MOD;
} else {
auto it = checkpoints.upper_bound(idx);
int idxR = *it;
int idxL = *prev(it);
checkpoints.insert(idx);
long long oldNum = getExpected(idxL, idxR);
long long newNum =
(getExpected(idxL, idx) + getExpected(idx, idxR)) % MOD;
ans -= oldNum;
ans %= MOD;
ans += MOD;
ans %= MOD;
ans += newNum;
ans %= MOD;
}
cout << ans << "\n";
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
bool rev(long long x, long long y) { return x > y; }
void input_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cin >> a[i];
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second < b.second;
}
bool sortinrev(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
void print_vec(vector<long long> &v) {
for (auto i : v) cout << i << " ";
cout << '\n';
}
bool sortinrevbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second > b.second);
}
void print_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cout << a[i] << " ";
cout << '\n';
}
template <typename... T>
void input(T &...args) {
((cin >> args), ...);
}
template <typename... T>
void print(T &&...args) {
((cout << args << '\n'), ...);
}
template <typename... T>
void deb(T &&...args) {
cout << "~~ ";
((cout << args << " "), ...);
cout << '\n';
}
void stand8th() {
long long summ;
input(summ);
string s;
input(s);
long long n = (long long)(s.size());
long long a[n];
for (long long i = 0; i < n; i += 1) {
a[i] = (long long)(s[i] - '0');
}
for (long long i = 1; i < n; i += 1) a[i] += a[i - 1];
map<long long, long long> mpp;
for (long long i = 0; i < n; i += 1) {
mpp[a[i]]++;
for (long long j = i + 1; j < n; j += 1) {
mpp[a[j] - a[i]]++;
}
}
long long ans = 0;
for (auto vbn : mpp) {
if (vbn.first != 0 && summ % vbn.first == 0) {
ans += vbn.second * mpp[summ / vbn.first];
} else if (vbn.first == 0 && summ == 0) {
ans += vbn.second * (n * (n + 1) / 2);
}
}
print(ans);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tin = 1;
while (tin--) {
stand8th();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
int a[510][510];
int ans[510][510];
int sum[510][510];
int max1[510][510], max2[510][510];
long long f1[510][510], f2[510][510];
long long ans1, ans2, len[510];
void update(int m, int f) {
if (m > ans1) {
ans2 = f;
ans1 = m;
} else if (m == ans1)
ans2 += f;
}
bool check(int x, int y, int r) {
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) {
if ((((i) * (i)) + ((j) * (j)) <= r * r) &&
(((x - i) * (x - i)) + ((y - j) * (y - j)) <= r * r))
return true;
}
return false;
}
int main() {
int n = inp();
int m = inp();
int rm = std::min(inp(), n + m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
a[i][j] = inp();
sum[i][j] = sum[i][j - 1] + a[i][j];
}
for (int i = rm + 1; i <= n - rm; i++)
for (int j = rm + 1; j <= m - rm; j++) {
int l = 1;
int r = m;
for (int u = i; u >= i - rm; u--) {
while (((i - u) * (i - u)) + ((r - j) * (r - j)) > ((rm) * (rm))) r--;
while (((i - u) * (i - u)) + ((j - l) * (j - l)) > ((rm) * (rm))) l++;
ans[i][j] += sum[u][r] - sum[u][l - 1];
}
l = 1;
r = m;
for (int u = i + 1; u <= i + rm; u++) {
while (((u - i) * (u - i)) + ((r - j) * (r - j)) > ((rm) * (rm))) r--;
while (((i - u) * (i - u)) + ((j - l) * (j - l)) > ((rm) * (rm))) l++;
ans[i][j] += sum[u][r] - sum[u][l - 1];
}
}
for (int i = rm + 1; i <= n - rm; i++) {
for (int j = rm + 1; j <= m - rm; j++) {
max1[i][j] = std::max(ans[i][j], max1[i][j - 1]);
if (max1[i][j] == max1[i][j - 1]) {
if (ans[i][j] == max1[i][j])
f1[i][j] = f1[i][j - 1] + 1;
else
f1[i][j] = f1[i][j - 1];
} else
f1[i][j] = 1;
}
for (int j = m - rm; j >= rm + 1; j--) {
max2[i][j] = std::max(ans[i][j], max2[i][j + 1]);
if (max2[i][j] == max2[i][j + 1]) {
if (ans[i][j] == max2[i][j])
f2[i][j] = f2[i][j + 1] + 1;
else
f2[i][j] = f2[i][j + 1];
} else
f2[i][j] = 1;
}
}
len[0] = (rm << 1);
int lim = (rm << 1);
for (int i = 1; i <= (rm << 1); i++) {
len[i] = len[i - 1];
while (!check(i, len[i], rm) && len[i] > -1) len[i]--;
if (len[i] < 0) {
lim = i - 1;
break;
}
}
for (int i = rm + 1; i <= n - rm; i++)
for (int j = rm + 1; j <= m - rm; j++) {
for (int u = rm + 1; u < i - lim; u++)
update(max1[u][m - rm] + ans[i][j], f1[u][m - rm]);
for (int u = i + lim + 1; u <= n - rm; u++)
update(max1[u][m - rm] + ans[i][j], f1[u][m - rm]);
for (int u = i; u >= i - lim && u >= rm + 1; u--) {
int l = j - len[i - u];
int r = j + len[i - u];
if (l > rm + 1) update(max1[u][l - 1] + ans[i][j], f1[u][l - 1]);
if (r < m - rm) update(max2[u][r + 1] + ans[i][j], f2[u][r + 1]);
}
for (int u = i + 1; u <= i + lim && u <= n - rm; u++) {
int l = j - len[u - i];
int r = j + len[u - i];
if (l > rm + 1) update(max1[u][l - 1] + ans[i][j], f1[u][l - 1]);
if (r < m - rm) update(max2[u][r + 1] + ans[i][j], f2[u][r + 1]);
}
}
std::cout << ans1 << ' ' << (ans2 >> 1) << '\n';
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> v[200005], g;
int dq, dep[200005], root;
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1;
for (int i = 0; i < v[x].size(); ++i) {
int y = v[x][i];
if (y == fa) continue;
dfs(y, x);
}
}
int main() {
scanf("%d%d", &n, &k);
if (n - k == 1) {
for (int i = 2; i <= n; ++i) v[1].push_back(i), v[i].push_back(1);
} else if (n - k == 2) {
v[1].push_back(3);
v[3].push_back(1);
v[1].push_back(2);
v[2].push_back(1);
for (int i = 4; i <= n; ++i) v[2].push_back(i), v[i].push_back(2);
} else {
for (int i = k + 2; i <= n; ++i) {
dq = i - k - 2;
if (dq < k)
v[k + 1].push_back(i), v[i].push_back(k + 1);
else
v[i].push_back(i - k), v[i - k].push_back(i);
}
for (int i = k + 1; i <= n; ++i)
if (v[i].size() == 1) g.push_back(i);
for (int i = 0; i < g.size(); ++i)
v[i + 1].push_back(g[i]), v[g[i]].push_back(i + 1);
for (int i = g.size() + 1; i <= k; ++i)
v[i].push_back(k + 1), v[k + 1].push_back(i);
}
dep[0] = 0;
dfs(1, 0);
;
root = 1;
for (int i = 1; i <= n; ++i)
if (dep[i] > dep[root]) root = i;
dep[0] = 0;
dfs(root, 0);
root = 1;
for (int i = 1; i <= n; ++i)
if (dep[i] > dep[root]) root = i;
printf("%d\n", dep[root] - 1);
for (int i = 1; i <= n; ++i)
for (int j = 0; j < v[i].size(); ++j)
if (i < v[i][j]) printf("%d %d\n", i, v[i][j]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 1e18;
int main() {
long long a;
scanf("%lld", &a);
long long l = a - mxn % a * 9 % a * 9 % a;
long long r = l + mxn - 1;
cout << l << " " << r << endl;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
void solver();
long long gcd(long long A, long long B) {
if (A == 0) return B;
if (B == 0) return A;
return gcd(B % A, A);
}
long long power(long long A, long long B) {
long long res = 1;
while (B > 0) {
if (B % 2 != 0) res = (res * 1ll * A) % 1000000007;
B /= 2;
A = (A * 1ll * A) % 1000000007;
}
return res % 1000000007;
}
long long fact(long long N) {
long long res = 1;
while (N > 1) {
res = (res * 1ll * N) % 1000000007;
N--;
}
return res;
}
long long ncr(long long N, long long R) {
long long num = fact(N);
long long denum = fact(N - R);
denum = (denum * 1ll * fact(R)) % 1000000007;
denum = power(denum, 1000000007 - 2);
num = (num * 1ll * denum) % 1000000007;
return num;
}
bool isPrime(long long n, long long a) {
for (long long i = 2; i * 1ll * i <= n; i++) {
if (n % i == 0) return false;
if (i >= a) return true;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solver();
}
void solver() {
long long p, y;
cin >> p >> y;
while (y > p) {
if (isPrime(y, p)) {
cout << y << "\n";
return;
}
y--;
}
cout << "-1";
return;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
struct Node {
int val, pri, ind;
bool operator<(const Node &o) const {
return val == o.val ? pri < o.pri : val < o.val;
}
} b[maxn];
int a[maxn];
int n;
void op(int i) {
int tmp = a[i + 2];
a[i + 2] = a[i + 1];
a[i + 1] = a[i];
a[i] = tmp;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
map<int, int> mp;
int px = 0, py = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
++mp[a[i]];
b[i] = {a[i], mp[a[i]], i};
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < i; ++j) {
if (a[j] > a[i]) ++cnt;
}
}
if (((int)mp.size()) == n && (cnt & 1)) {
cout << "-1\n";
continue;
}
if (cnt & 1) {
int val = 0;
for (auto &it : mp) {
if (it.second > 1) {
val = it.first;
break;
}
}
for (int i = 1; i <= n; ++i) {
if (b[i].val == val) {
for (int j = i + 1; j <= n; ++j) {
if (b[j].val == val) {
swap(b[j].pri, b[i].pri);
break;
}
}
break;
}
}
}
sort(b + 1, b + 1 + n);
for (int i = 1; i <= n; ++i) {
a[b[i].ind] = i;
}
vector<int> ans;
for (int i = n; i >= 3; --i) {
int pmx = 0, mx = 0;
for (int j = 1; j <= i; ++j) {
if (!pmx || a[j] > mx) mx = a[j], pmx = j;
}
if (pmx == i) continue;
while (pmx < i - 1) {
ans.push_back(pmx);
op(pmx);
++pmx;
}
ans.push_back(i - 2);
op(i - 2);
}
cout << ((int)ans.size()) << "\n";
for (auto &v : ans) cout << v << " ";
cout << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dp[1000005];
bool vis[1000005];
int back(int v) {
if (vis[v]) return dp[v];
vis[v] = true;
dp[v] = 0;
if (v == 1) return 0;
int no[20];
for (int i = 0; i <= 10; i++) no[i] = 0;
for (int x = 1; x * x <= v; x++) {
if (v <= x * x * x * x) {
no[back(x)] = 1;
}
}
int ans = -1;
for (int i = 0;; i++) {
if (no[i] == 0) {
ans = i;
break;
}
}
dp[v] = ans;
return dp[v];
}
int grund(int l, int r) {
int visi[10];
for (int i = 0; i <= 9; i++) visi[i] = 0;
if ((l >= 1 && l <= 3) || (r >= 1 && r <= 3) || (l <= 1 && r >= 3))
visi[0] = 1;
if ((l >= 4 && l <= 15) || (r >= 4 && r <= 15) || (l <= 4 && r >= 15))
visi[1] = 1;
if ((l >= 16 && l <= 81) || (r >= 16 && r <= 81) || (l <= 16 && r >= 81))
visi[2] = 1;
if ((l >= 82 && l <= 6723) || (r >= 82 && r <= 6723) ||
(l <= 82 && r >= 6723))
visi[0] = 1;
if ((l >= 6724 && l <= 50625) || (r >= 6724 && r <= 50625) ||
(l <= 6724 && r >= 50625))
visi[3] = 1;
if (l >= 50626 || r >= 50626) visi[1] = 1;
for (int i = 0;; i++)
if (visi[i] == 0) return i;
return 12;
}
int main() {
long long val;
int n;
int ans = 0;
scanf("%d", &n);
while (n--) {
scanf("%I64d", &val);
if (val >= 1 && val <= 3)
;
else if (val >= 4 && val <= 15)
ans = (ans ^ 1);
else if (val >= 16 && val <= 81)
ans = (ans ^ 2);
else if (val >= 82 && val <= 6723)
;
else if (val >= 6724 && val <= 50625)
ans = (ans ^ 3);
else if (val >= 50626 && val <= 1000000)
ans = (ans ^ 1);
else {
long long lo = (long long)(pow((double)(val), 0.25));
while (lo * lo * lo * lo < val) lo++;
long long hi = (long long)(pow((double)(val), 0.5));
while (hi * hi <= val) hi++;
hi--;
ans = (ans ^ grund(lo, hi));
}
}
if (ans)
printf("Furlo\n");
else
printf("Rublo\n");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, s1, s2, s3, s4, d, i, o, n[5], m, j, k, l;
int main() {
cin >> a >> b >> c;
s1 = a + b + c;
s2 = a * 2 + b * 2;
s3 = a * 2 + c * 2;
s4 = b * 2 + c * 2;
n[0] = s1;
n[1] = s2;
n[2] = s3;
n[3] = s4;
sort(n, n + 4);
cout << n[0];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int l[30], m[30], w[30];
map<pair<int, int>, pair<int, int> > fst, scnd;
void solve(int low, int up, int a, int b, int c, int path,
map<pair<int, int>, pair<int, int> > &hs) {
if (low == up) {
if (hs.find(make_pair(a - b, b - c)) == hs.end()) {
hs[make_pair(a - b, b - c)] = make_pair(a, path);
} else {
hs[make_pair(a - b, b - c)] =
max(hs[make_pair(a - b, b - c)], make_pair(a, path));
}
} else {
solve(low + 1, up, a + l[low], b + m[low], c, path * 3 + 2, hs);
solve(low + 1, up, a + l[low], b, c + w[low], path * 3 + 1, hs);
solve(low + 1, up, a, b + m[low], c + w[low], path * 3 + 0, hs);
}
}
map<char, int> vl;
int addup = 0;
void output(int res, int num) {
vector<int> vout;
while (num) {
vout.push_back(res % 3);
res /= 3;
num--;
}
reverse(vout.begin(), vout.end());
for (int i = 0; i < vout.size(); ++i) {
int x = vout[i];
if (x == 0) {
cout << "MW" << endl;
vl['M'] += m[i + addup];
vl['W'] += w[i + addup];
}
if (x == 1) {
cout << "LW" << endl;
vl['L'] += l[i + addup];
vl['W'] += w[i + addup];
}
if (x == 2) {
cout << "LM" << endl;
vl['M'] += m[i + addup];
vl['L'] += l[i + addup];
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> l[i] >> m[i] >> w[i];
}
solve(0, n / 2, 0, 0, 0, 0, fst);
solve(n / 2, n, 0, 0, 0, 0, scnd);
int MAX = -1000 * 1000 * 1000 - 7, res[2];
for (map<pair<int, int>, pair<int, int> >::iterator i = fst.begin();
i != fst.end(); ++i) {
pair<pair<int, int>, pair<int, int> > el = *i;
pair<int, int> le = make_pair(-el.first.first, -el.first.second);
if (scnd.find(le) != scnd.end()) {
if (MAX < el.second.first + scnd[le].first) {
res[0] = el.second.second;
res[1] = scnd[le].second;
MAX = el.second.first + scnd[le].first;
}
}
}
if (MAX == -1000 * 1000 * 1000 - 7) {
cout << "Impossible" << endl;
return 0;
}
addup = 0;
output(res[0], n / 2);
addup = n / 2;
output(res[1], n - n / 2);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
static const int c[6][3] = {{0, 1, 2}, {0, 2, 1}, {1, 0, 2},
{1, 2, 0}, {2, 0, 1}, {2, 1, 0}};
static inline long long sqr(long long x) { return x * x; }
static inline long long dist(int x[3], int y[3]) {
return sqr(x[0] - y[0]) + sqr(x[1] - y[1]) + sqr(x[2] - y[2]);
}
struct Point {
long long dist;
int i;
Point() {}
Point(int i, long long dist) : i(i), dist(dist) {}
};
struct Vec {
int x, y, z;
Vec() {}
Vec(int x, int y, int z) : x(x), y(y), z(z) {}
};
Vec operator+(const Vec& l, const Vec& r) {
return Vec(l.x + r.x, l.y + r.y, l.z + r.z);
}
Vec operator+(const Vec& l, const int x[3]) {
return Vec(l.x + x[0], l.y + x[1], l.z + x[2]);
}
bool operator<(const Point& left, const Point& right) {
return left.dist < right.dist;
}
static bool is_cube(int a[8][3]) {
Point d[7];
for (int i = 1; i < 8; i++) d[i - 1] = Point(i, dist(a[0], a[i]));
sort(&d[0], &d[7]);
if (d[0].dist == 0) return false;
if (d[0].dist != d[2].dist || d[0].dist == d[3].dist) return false;
if (d[3].dist != d[5].dist || d[3].dist == d[6].dist) return false;
if (dist(a[d[0].i], a[d[1].i]) != 2 * d[0].dist) return false;
if (dist(a[d[0].i], a[d[2].i]) != 2 * d[0].dist) return false;
if (dist(a[d[1].i], a[d[2].i]) != 2 * d[0].dist) return false;
int v[3][3];
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) v[i][j] = a[d[i].i][j] - a[0][j];
Vec base(a[0][0], a[0][1], a[0][2]);
Vec pts[4] = {base + v[0] + v[1], base + v[0] + v[2], base + v[1] + v[2],
base + v[0] + v[1] + v[2]};
for (int i = 0; i < 4; i++) {
bool found = false;
for (int j = 3; j < 7; j++) {
if (pts[i].x == a[d[j].i][0] && pts[i].y == a[d[j].i][1] &&
pts[i].z == a[d[j].i][2]) {
found = true;
break;
}
}
if (!found) return false;
}
return true;
}
int main(int argc, const char* argv[]) {
int a[8][3];
int b[8][3];
for (int i = 0; i < 8; i++) scanf("%d%d%d", &a[i][0], &a[i][1], &a[i][2]);
for (int j0 = 0; j0 < 6; j0++) {
do {
b[0][0] = a[0][c[j0][0]];
b[0][1] = a[0][c[j0][1]];
b[0][2] = a[0][c[j0][2]];
} while (0);
for (int j1 = 0; j1 < 6; j1++) {
do {
b[1][0] = a[1][c[j1][0]];
b[1][1] = a[1][c[j1][1]];
b[1][2] = a[1][c[j1][2]];
} while (0);
for (int j2 = 0; j2 < 6; j2++) {
do {
b[2][0] = a[2][c[j2][0]];
b[2][1] = a[2][c[j2][1]];
b[2][2] = a[2][c[j2][2]];
} while (0);
for (int j3 = 0; j3 < 6; j3++) {
do {
b[3][0] = a[3][c[j3][0]];
b[3][1] = a[3][c[j3][1]];
b[3][2] = a[3][c[j3][2]];
} while (0);
for (int j4 = 0; j4 < 6; j4++) {
do {
b[4][0] = a[4][c[j4][0]];
b[4][1] = a[4][c[j4][1]];
b[4][2] = a[4][c[j4][2]];
} while (0);
for (int j5 = 0; j5 < 6; j5++) {
do {
b[5][0] = a[5][c[j5][0]];
b[5][1] = a[5][c[j5][1]];
b[5][2] = a[5][c[j5][2]];
} while (0);
for (int j6 = 0; j6 < 6; j6++) {
do {
b[6][0] = a[6][c[j6][0]];
b[6][1] = a[6][c[j6][1]];
b[6][2] = a[6][c[j6][2]];
} while (0);
for (int j7 = 0; j7 < 6; j7++) {
do {
b[7][0] = a[7][c[j7][0]];
b[7][1] = a[7][c[j7][1]];
b[7][2] = a[7][c[j7][2]];
} while (0);
if (is_cube(b)) {
printf("YES\n");
for (int i = 0; i < 8; i++)
printf("%d %d %d\n", b[i][0], b[i][1], b[i][2]);
return 0;
}
}
}
}
}
}
}
}
}
printf("NO\n");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 10005;
const int Q_MAX = 10005;
struct query {
int a, b, x;
};
int N, Q;
query queries[Q_MAX];
bitset<N_MAX> answer;
void solve(int start, int end, bitset<N_MAX> sums, bitset<Q_MAX> done) {
for (int q = 0; q < Q; q++) {
if (!done[q] && queries[q].a <= start && end <= queries[q].b) {
sums |= sums << queries[q].x;
done[q] = 1;
}
}
if (start + 1 >= end) {
answer |= sums;
return;
}
int mid = (start + end) / 2;
solve(start, mid, sums, done);
solve(mid, end, sums, done);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> Q;
for (int i = 0; i < Q; i++) {
int a, b, x;
cin >> a >> b >> x;
queries[i] = (query){a - 1, b, x};
}
bitset<N_MAX> sums;
sums[0] = 1;
bitset<Q_MAX> done;
solve(0, N, sums, done);
vector<int> output;
for (int i = 1; i <= N; i++) {
if (answer[i]) output.push_back(i);
}
int count = output.size();
cout << count << '\n';
for (int i = 0; i < count; i++) {
cout << output[i] << (i < count - 1 ? ' ' : '\n');
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
long x, n;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n >> x;
cout << 2 * x << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
setlocale(LC_ALL, "RUS");
int n, x, j = 0, a, b, u = 0;
cin >> n >> a >> b;
b *= 2;
while (n--) {
cin >> x;
if (x == 1) {
if (a > 0)
a--;
else {
if (b > 0) {
b -= 2;
u++;
} else if (u > 0)
u--;
else
j++;
}
} else {
if (b >= 2)
b -= 2;
else
j += 2;
}
}
cout << j;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int poz[10001];
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
poz[a[i]] = i;
}
int l, r, x;
for (int i = 0; i < m; i++) {
cin >> l >> r >> x;
l--, r--, x--;
int br = 0;
for (int j = l; j <= r; j++) {
if (a[j] < a[x]) br++;
}
if (x - l == br) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MV = 2000008;
const int ME = 10000006;
const int MOD = 1000000007;
int is[ME];
int prime[MV];
int add[ME];
int get_prime(int n) {
memset(is, 0, sizeof(is));
int en = 0;
is[0] = is[1] = 1;
for (int i = 2; i < n; i++) {
if (is[i] == 1) continue;
for (int j = 2; i * j < n; j++) {
is[i * j] = 1;
}
}
for (int i = 0; i < n; i++) {
if (is[i] == 0) {
prime[en++] = i;
}
}
return en;
}
int num[MV];
int main() {
int en = get_prime(ME);
memset(add, 0, sizeof(add));
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) scanf("%d", &num[i]);
for (int i = 0; i < n; i++) {
int t1 = num[i];
if (is[t1] == 0) {
add[t1]++;
} else {
for (int j = 0; prime[j] * prime[j] <= t1; j++) {
int t2 = prime[j];
if (t1 % t2 == 0) {
add[t2]++;
while (t1 % t2 == 0) t1 /= t2;
}
}
if (t1 != 1) {
add[t1]++;
}
}
}
for (int i = 1; i < ME; i++) add[i] += add[i - 1];
int m;
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
l = min(l, ME - 3);
r = min(r, ME - 3);
int ans = add[r] - add[l - 1];
printf("%d\n", ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
const long double PI = acos(-1);
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
int _runtimeTerror_() {
int n;
cin >> n;
set<long long> buy, sell, both;
long long ans = 1;
auto inbuy = [&](long long x) {
if (buy.empty()) return false;
return *buy.rbegin() > x;
};
auto insell = [&](long long x) {
if (sell.empty()) return false;
return x > *sell.begin();
};
for (int i = 1; i <= n; ++i) {
string s;
long long p;
cin >> s >> p;
if (s == "ADD") {
if (inbuy(p))
buy.insert(p);
else if (insell(p))
sell.insert(p);
else {
both.insert(p);
}
} else {
if (buy.count(p)) {
if (*buy.rbegin() != p) {
ans = 0;
break;
} else
buy.erase(p);
while (!both.empty() && *both.rbegin() > p)
sell.insert(*both.rbegin()), both.erase(*both.rbegin());
} else if (sell.count(p)) {
if (*sell.begin() != p) {
ans = 0;
break;
} else
sell.erase(p);
while (!both.empty() && *both.begin() < p)
buy.insert(*both.rbegin()), both.erase(*both.rbegin());
} else {
ans = (ans * 2) % M;
while (!both.empty() && *both.begin() < p)
buy.insert(*both.begin()), both.erase(both.begin());
both.erase(both.begin());
while (!both.empty())
sell.insert(*both.begin()), both.erase(both.begin());
assert(both.empty());
}
}
}
ans = (ans * ((long long)both.size() + 1)) % M;
cout << ans << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
const int mxN = 1e5 + 5;
const int mxM = 1e5 + 5;
const int mxQ = 1e5 + 5;
const int B = sqrt(mxN);
int N, M, Q;
vector<ii> edges[mxM];
ii qry[mxN];
struct UFDS {
vector<int> p, s;
void init(int n) {
p.resize(n);
iota((p).begin(), (p).end(), 0);
s.assign(n, 1);
}
int finds(int i) { return (p[i] == i) ? i : (p[i] = finds(p[i])); }
bool unions(int i, int j) {
int x = finds(i), y = finds(j);
if (x == y) return 0;
if (s[x] < s[y]) swap(x, y);
p[y] = x, s[x] += s[y];
return 1;
}
inline void reset(int i) {
p[i] = i;
s[i] = 1;
}
} ufds;
bool in[mxN];
int cmap[mxN];
vector<int> smol[mxM];
set<int> big[mxM];
int scnt, bcnt;
map<ii, int> pairwise;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N >> M;
for (int i = (1); i <= (M); ++i) {
int A, B, C;
cin >> A >> B >> C;
edges[C].emplace_back(A, B);
}
ufds.init(N + 1);
bcnt = 0;
for (int i = (1); i <= (M); ++i)
if ((int)(edges[i]).size()) {
vector<int> cur;
for (auto& e : edges[i]) {
if (!in[e.first]) cur.push_back(e.first), in[e.first] = 1;
if (!in[e.second]) cur.push_back(e.second), in[e.second] = 1;
ufds.unions(e.first, e.second);
}
scnt = 0;
for (int& x : cur) {
int u = ufds.finds(x);
if (ufds.s[u] <= B) {
if (!cmap[u]) cmap[u] = ++scnt;
smol[cmap[u]].push_back(x);
} else {
if (!cmap[u]) cmap[u] = ++bcnt;
big[cmap[u]].insert(x);
}
}
for (int& x : cur) {
cmap[ufds.finds(x)] = 0;
in[x] = 0;
ufds.reset(x);
}
for (int s = (1); s <= (scnt); ++s) {
for (int a = (0); a <= ((int)(smol[s]).size() - 1); ++a)
for (int b = (a + 1); b <= ((int)(smol[s]).size() - 1); ++b) {
int U = smol[s][a], V = smol[s][b];
if (U < V) swap(U, V);
++pairwise[ii(U, V)];
}
smol[s].clear();
}
}
cin >> Q;
for (int i = (1); i <= (Q); ++i) {
int U, V;
cin >> U >> V;
if (U < V) swap(U, V);
int ans = pairwise[ii(U, V)];
for (int b = (1); b <= (bcnt); ++b) {
auto x = big[b].find(U);
if (x == big[b].end()) continue;
auto y = big[b].find(V);
if (y == big[b].end()) continue;
++ans;
}
cout << ans << '\n';
}
}
| 16 |
/*{{{*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<iostream>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<bitset>
#include<vector>
#include<limits.h>
#include<assert.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB emplace_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }
template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }
#ifdef HOME
#define DEBUG(...) {printf("[DEBUG] ");W(__VA_ARGS__);}
#else
#define DEBUG(...)
#endif
int MOD = 1e9+7;
void ADD(LL& x,LL v){x=(x+v)%MOD;if(x<0)x+=MOD;}
/*}}}*/
const int SIZE = 1<<20;
long long mypow(long long x,long long y, int mod = MOD) {
x %= mod;
long long res = 1 % mod;
while(y){
if(y & 1) { res = res * x % mod; }
y >>= 1;
x = x * x % mod;
}
return res;
}
LL inv(LL x){
return mypow(x, MOD-2);
}
LL dp[SIZE],dp0[SIZE];
LL dp_sum[SIZE];
int n;
LL C2(LL x){
return x*(x+1)/2%MOD;
}
LL C3(LL x){
LL v1=x;
LL v2=x+1;
LL v3=x+2;
if(v1&1)v2/=2;
else v1/=2;
if(v1%3==0)v1/=3;
else if(v2%3==0)v2/=3;
else v3/=3;
return v1*v2%MOD*v3%MOD;
}
LL tmp[SIZE];
void solve() {
if(n==1){
W(5);
return;
}
dp[0]=dp_sum[0]=1;
dp[1]=2;
dp_sum[1]=3;
dp0[1]=1;
FOR(i,2,n){
ADD(dp0[i],C2(dp[i-1]));
ADD(dp0[i],dp[i-1]*dp_sum[i-2]);
dp[i]=dp[i-1];
ADD(dp[i],dp0[i]);
ADD(dp_sum[i],dp_sum[i-1]+dp[i]);
}
{
int i=n;
tmp[i]=C3(dp[n-1]);
ADD(tmp[i],C2(dp[n-1])*dp_sum[n-2]);
ADD(tmp[i],dp[n-1]*C2(dp_sum[n-2]));
ADD(tmp[i],C2(dp[n-1]));
ADD(tmp[i],dp[n-1]*dp_sum[n-2]);
ADD(tmp[i],dp[n-1]);
}
LL an=tmp[n]*2;
FOR(i,1,n-2){
ADD(an,dp0[i]*(dp[n-i-1]-1));
}
ADD(an,-1);
W(an);
}
void input() {
R(n);
}
int main(){
MOD=998244353;
input();
solve();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int cnt;
int files;
string name;
vector<int> next;
};
struct disk {
vector<node> t;
void add(string);
int filenum(int);
int dirnum(int);
};
disk d[6];
string line;
int maxfile, maxdir;
int main() {
node n;
n.files = 0;
for (int i = 0; i < 6; i++) d[i].t.push_back(n);
while (cin >> line) d[line[0] - 'C'].add(line);
for (int i = 0; i < 5; i++)
for (int j = 0; j < d[i].t[0].next.size(); j++) {
maxdir = max(maxdir, d[i].dirnum(d[i].t[0].next[j]));
maxfile = max(maxfile, d[i].filenum(d[i].t[0].next[j]));
}
cout << maxdir << " " << maxfile;
return 0;
}
void disk::add(string s) {
int cur = 0;
string ex;
bool flag;
s.erase(0, 3);
for (int i = 0; i < s.size(); i++)
if (s[i] == '\\') {
ex = s.substr(0, i);
s.erase(0, i + 1);
i = -1;
flag = true;
for (int j = 0; j < t[cur].next.size(); j++)
if (t[t[cur].next[j]].name == ex) {
cur = t[cur].next[j];
flag = false;
break;
}
if (flag) {
node n;
n.name = ex;
n.files = 0;
t[cur].next.push_back(t.size());
t.push_back(n);
cur = t.size() - 1;
}
}
t[cur].files++;
}
int disk::filenum(int nn) {
int res = 0;
res += t[nn].files;
for (int i = 0; i < t[nn].next.size(); i++) res += filenum(t[nn].next[i]);
return res;
}
int disk::dirnum(int nn) {
int res = 0;
res += t[nn].next.size();
for (int i = 0; i < t[nn].next.size(); i++) res += dirnum(t[nn].next[i]);
return res;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b, c, n;
string s;
cin >> n;
cin.ignore();
cin >> s;
long long an = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != '0') an += (s[i] - '0' + 1);
if (i == s.size() - 1 and s[i] != '0') an--;
}
cout << an;
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long m, a, n, b;
cin >> n;
while (n--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> l;
vector<int> r;
int ask(int p) {
int cnt = 0;
for (int i = 0; i < l.size(); i++) {
if (r[i] < p) {
cnt++;
} else {
break;
}
}
return l.size() - cnt;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n;
for (int i = 1; i <= n; i++) {
int ll, rr;
cin >> ll >> rr;
l.push_back(ll);
r.push_back(rr);
}
cin >> m;
cout << ask(m);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5005;
const int INF = 1 << 30;
const double EPS = 1e-7;
int H, M, N;
int cnt;
int h[MAX], mk[MAX];
map<int, int> Map;
int main() {
scanf("%d %d %d", &H, &M, &N);
for (int i = 0; i < (H); ++i) h[i] = -1;
long long ans = 0;
for (int i = 0; i < (N); ++i) {
char op;
int id;
scanf("\n%c %d", &op, &id);
if (op == '-')
h[Map[id]] = -1;
else {
int hash;
scanf("%d", &hash);
++cnt;
long long i = 0;
int pos = hash;
while (h[pos] != -1) ++i, pos = (hash + (i % H) * (M % H)) % H;
ans += i;
h[pos] = id;
Map[id] = pos;
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
long long int x, y, z;
x = a[0];
y = a[1];
z = a[n - 1];
if (x + y <= z) {
cout << "1 2 " << n << "\n";
} else {
cout << "-1\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long xx[105], yy[105], cnt;
long long gcd(long long x, long long y) {
int res = (y == 0 ? x : gcd(y, x % y));
xx[++cnt] = x;
yy[cnt] = y;
return res;
}
long long ans[105];
bool check(long long a, long long b) {
if (a % 2 == 1) {
return (b / a - 1) % 2;
} else {
if (a >= 1000000000 || b < a * a) {
return !((b / a) % 2);
} else {
long long res = b / a;
long long c1 = (res % (a + 1)) % 2;
long long c2 = res % (a + 1);
return !c1 || (c2 == a);
}
}
}
void solve(long long a, long long b) {
cnt = 0;
gcd(a, b);
ans[1] = 0;
for (int i = 2; i <= cnt; i++) {
if (ans[i - 1] == 0)
ans[i] = 1;
else if (check(yy[i], xx[i] - yy[i - 1]))
ans[i] = 1;
else
ans[i] = 0;
}
if (ans[cnt])
printf("First\n");
else
printf("Second\n");
}
int p = 12;
int biao[100005];
int dabiao(int x) {
if (biao[x] != -1) return biao[x];
if (x < 0) return 0;
int temp = p;
int flag = 0;
while (temp <= x * p) {
if (dabiao(x - temp / p) == 0) {
flag = 1;
break;
}
temp *= p;
}
return biao[x] = flag;
}
int main() {
int n;
cin >> n;
while (n--) {
long long a, b;
cin >> a >> b;
if (a < b) swap(a, b);
if (b == 0)
cout << "Second" << endl;
else if (a % b == 0)
cout << "First" << endl;
else
solve(a, b);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > root;
pair<int, int> rt(int i, int j) {
if (root[i][j] == make_pair(i, j)) {
return root[i][j];
}
return root[i][j] = rt(root[i][j].first, root[i][j].second);
}
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
vector<vector<int> > G;
G.resize(n);
for (int i = 0; i < n; i++) G[i].resize(m);
root.resize(n);
for (int i = 0; i < n; i++) root[i].resize(m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
root[i][j] = make_pair(i, j);
}
}
map<pair<int, int>, int> XX, YY;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &G[i][j]);
if (XX[make_pair(i, G[i][j])] != 0) {
root[rt(i, j).first][rt(i, j).second] =
rt(i, XX[make_pair(i, G[i][j])] - 1);
}
XX[make_pair(i, G[i][j])] = j + 1;
if (YY[make_pair(j, G[i][j])] != 0) {
root[rt(i, j).first][rt(i, j).second] =
rt(YY[make_pair(j, G[i][j])] - 1, j);
}
YY[make_pair(j, G[i][j])] = i + 1;
}
}
map<pair<int, pair<int, int> >, vector<pair<int, int> > > M;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
M[make_pair(G[i][j], rt(i, j))].push_back(make_pair(i, j));
}
}
vector<int> X(n, 0), Y(m, 0);
vector<vector<int> > ans;
ans.resize(n);
for (int i = 0; i < n; i++) ans[i].resize(m);
for (map<pair<int, pair<int, int> >, vector<pair<int, int> > >::iterator
it = M.begin();
it != M.end(); it++) {
vector<pair<int, int> >& V = it->second;
for (int i = 0; i < V.size(); i++) {
}
int tnum = 0;
for (int i = 0; i < V.size(); i++) {
int x = V[i].first;
int y = V[i].second;
tnum = max(tnum, X[x]);
tnum = max(tnum, Y[y]);
}
for (int i = 0; i < V.size(); i++) {
int x = V[i].first;
int y = V[i].second;
ans[x][y] = tnum + 1;
X[x] = max(X[x], tnum + 1);
Y[y] = max(Y[y], tnum + 1);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%d%c", ans[i][j], j == m - 1 ? '\n' : ' ');
}
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return x * x; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string s;
cin >> s;
long long i = 1, start = 0, ans = 0;
while (i < n && s[i] == s[0]) {
i++;
}
long long k = n - 1;
while (k > i && s[k] == s[0]) {
k--;
}
long long add = 0;
if (i + (n - 1 - k) == n) {
ans = (n % 3 != 0 ? 1 + n / 3 : n / 3);
cout << ans << endl;
continue;
}
ans += (i + (n - 1 - k)) / 3;
start = i;
while (i < k + 1) {
if (s[i] == s[start])
i++;
else {
ans += (i - start) / 3;
start = i;
}
}
ans += (i - start) / 3;
cout << ans << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
vector<int> v;
int c = 1;
while (n--) {
int x;
cin >> x;
bool done = 0;
while (x--) {
int y;
cin >> y;
if (y < m) done = 1;
}
if (done) v.push_back(c);
c++;
}
cout << v.size() << '\n';
{
for (auto u : v) cout << u << " ";
cout << '\n';
};
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> al[100100];
long long a[100100], t[100100];
pair<long long, long long> dfs(long long v, long long p = -1) {
pair<long long, long long> ans = make_pair(0, a[v]);
vector<long long> vec;
long long k = 0;
for (int i = 0; i < al[v].size(); i++)
if (al[v][i] - p) {
pair<long long, long long> x = dfs(al[v][i], v);
vec.push_back(x.first + 1);
k += x.second;
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
for (int i = 0; i < min(a[v], (long long)vec.size()); i++)
ans.first += vec[i] + 1;
ans.second -= min(a[v], (long long)vec.size());
ans.first += 2 * min(ans.second, k);
ans.second = max(ans.second - k, 0LL);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i], a[i]--;
for (long long i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
x--;
y--;
al[y].push_back(x), al[x].push_back(y);
}
long long s;
cin >> s;
s--;
a[s]++;
cout << dfs(s).first << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ta, tb, a[200000 + 5], b[200000 + 5];
vector<int> A[200000 + 5], B[200000 + 5];
inline void Gmax(long long& x, const long long& y) { x < y && (x = y); }
inline int gcd(const int& x, const int& y) { return y ? gcd(y, x % y) : x; }
inline void exgcd(const int& x, const int& y, int& a, int& b) {
y ? (exgcd(y, x % y, b, a), b -= x / y * a) : (a = 1, b = 0);
}
inline int GetInv(const int& x, const int& y) {
register int a, b;
return exgcd(x, y, a, b), (a % y + y) % y;
}
set<int> S;
inline long long Work(const int& n, const int& m, vector<int> A,
vector<int> B) {
if (n == 1) {
if (A.size()) return -1;
if (B.size()) return B[0];
puts("-1"), exit(0);
}
register int t, Inv = GetInv(m, n);
long long s = -1;
vector<int>::iterator i;
S.clear();
for (i = A.begin(); i != A.end(); ++i) S.insert(1LL * *i * Inv % n);
for (i = B.begin(); i != B.end(); ++i)
S.find(t = 1LL * *i * Inv % n) == S.end() && (S.insert(t), Gmax(s, *i), 0);
if (S.empty()) {
puts("-1");
exit(0);
}
set<int>::iterator x, y;
for (x = S.begin(), y = ++S.begin(); y != S.end(); ++x, ++y)
(t = *y - *x - 1) && (Gmax(s, 1LL * t * m + 1LL * *x * m % n), 0);
return y = S.begin(),
(t = n - 1 - *x + *y) && (Gmax(s, 1LL * t * m + 1LL * *x * m % n), 0),
s;
}
int main() {
register int i;
for (scanf("%d%d%d", &n, &m, &ta), i = 1; i <= ta; ++i) scanf("%d", a + i);
for (scanf("%d", &tb), i = 1; i <= tb; ++i) scanf("%d", b + i);
register int d = gcd(n, m);
if (d > ta + tb) return puts("-1"), 0;
sort(a + 1, a + ta + 1), sort(b + 1, b + tb + 1);
for (i = 1; i <= ta; ++i) A[a[i] % d].push_back(a[i] / d);
for (i = 1; i <= tb; ++i) B[b[i] % d].push_back(b[i] / d);
long long ans = 0;
for (i = 0; i ^ d; ++i)
Gmax(ans,
max(Work(n / d, m / d, A[i], B[i]), Work(m / d, n / d, B[i], A[i])) *
d +
i);
return printf("%lld\n", ans), 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int N;
int C[105];
bool Vis[105];
set<int> Cyc;
int MaxCnt[105];
int main() {
cin >> N;
for (int i = 1; i <= N; i++) cin >> C[i];
for (int Len, Now, i = 1; i <= N; i++) {
if (Vis[i]) continue;
Len = 0, Now = i;
while (!Vis[Now]) {
Vis[Now] = 1;
Now = C[Now];
Len++;
}
Cyc.insert(Len);
if (Now != i) {
cout << -1 << endl;
return 0;
}
}
for (int i : Cyc) {
for (int j = 2; j * j <= i; j++) {
int Cnt = 0;
while (i % j == 0) i /= j, Cnt++;
MaxCnt[j] = max(Cnt, MaxCnt[j]);
}
MaxCnt[i] = max(1, MaxCnt[i]);
}
long long Ans = 1LL << max(0, MaxCnt[2] - 1);
for (int i = 3; i <= 100; i++)
if (MaxCnt[i]) Ans *= pow(i, MaxCnt[i]);
cout << Ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double PI = 3.141592653589793;
const double EPS = 1e-6;
const int N = 1e6 + 5;
const long long mod = 1e9 + 7;
int oo = 1e9;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int n;
vector<string> g;
int sum[55][55];
int dp[55][55][55][55];
int sum_range(int i, int j, int k, int l) {
return sum[k][l] - sum[k][j - 1] - sum[i - 1][l] + sum[i - 1][j - 1];
}
int solve(int x1, int y1, int x2, int y2) {
if (sum_range(x1, y1, x2, y2) == 0) return 0;
int &ret = dp[x1][y1][x2][y2];
if (ret != -1) return ret;
ret = max(x2 - x1 + 1, y2 - y1 + 1);
for (int i = x1; i <= x2 - 1; i++)
ret = min(ret, solve(x1, y1, i, y2) + solve(i + 1, y1, x2, y2));
for (int i = y1; i <= y2 - 1; i++)
ret = min(ret, solve(x1, y1, x2, i) + solve(x1, i + 1, x2, y2));
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
string a = "";
while (a.size() != n + 1) a += '/';
g.push_back(a);
for (int i = 0; i <= n - 1; i++) {
string s;
cin >> s;
s = "/" + s;
g.push_back(s);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) sum[i][j] = g[i][j] == '#';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) sum[i][j] += sum[i][j - 1];
for (int j = 1; j <= n; j++)
for (int i = 1; i <= n; i++) sum[i][j] += sum[i - 1][j];
memset(dp, -1, sizeof dp);
cout << solve(1, 1, n, n);
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
void solve() {
int n, v;
cin >> n >> v;
vector<double> a(n), b(n);
double sum_a = 0, mn = DBL_MAX;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
cin >> b[i];
double temp = b[i] / a[i];
mn = min(mn, temp);
sum_a += a[i];
}
cout << fixed << setprecision(10);
cout << min(double(v), sum_a * mn) << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tc = 1;
while (tc--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2010;
double a, b;
double ax[MAXN], ay[MAXN], bx[MAXN], by[MAXN], dist[MAXN];
bool visit[MAXN];
int N;
inline double sq(double x) { return x * x; }
inline void insert(double x1_, double y1_, double x2_, double y2_) {
if (x1_ > x2_) swap(x1_, x2_);
if (y1_ > y2_) swap(y1_, y2_);
ax[N] = x1_, ay[N] = y1_, bx[N] = x2_, by[N] = y2_;
N++;
}
inline double getdis(int u, int v) {
return sq(max(0.0, max(ax[u], ax[v]) - min(bx[u], bx[v]))) +
sq(max(0.0, max(ay[u], ay[v]) - min(by[u], by[v])));
}
void dijkstra() {
for (int i = 0; i < N; i++) {
dist[i] = 1e9;
visit[i] = 0;
}
priority_queue<pair<double, int> > q;
q.push(make_pair(0, 0));
dist[0] = 0;
while (!q.empty()) {
int u = q.top().second, dis = q.top().first;
q.pop();
if (visit[u]) continue;
visit[u] = 1;
if (u == 1) break;
for (int v = 0; v < N; v++) {
if (visit[v]) continue;
double d = getdis(u, v);
if (d <= a * a) {
if (v == 1) {
if (dist[u] + sqrt(d) < dist[v]) {
q.push(make_pair(-(dist[u] + sqrt(d)), v));
dist[v] = dist[u] + sqrt(d);
}
} else {
if (dist[u] + a + b < dist[v]) {
q.push(make_pair(-(dist[u] + a + b), v));
dist[v] = dist[u] + a + b;
}
}
}
}
}
}
int main() {
scanf("%lf%lf", &a, &b);
double tx, ty, sx, sy;
scanf("%lf%lf%lf%lf", &tx, &ty, &sx, &sy);
N = 0;
insert(tx, ty, tx, ty);
insert(sx, sy, sx, sy);
int M;
scanf("%d", &M);
while (M--) {
scanf("%lf%lf%lf%lf", &tx, &ty, &sx, &sy);
insert(tx, ty, sx, sy);
}
dijkstra();
if (dist[1] == 1e9)
printf("%d\n", -1);
else
printf("%.10f\n", dist[1]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
char S[5001];
int main() {
int n;
scanf("%d ", &n);
vector<string> A(n);
vector<string> B(n);
for (auto &e : A) {
scanf("%s", S);
e = S;
}
for (auto &e : B) {
scanf("%s", S);
e = S;
}
string ret;
string retwith;
int mret = 0;
int p = 0;
for (int i = 0; i < n; i++) {
int j = 0;
int l = -1;
for (j = 0; j < A[i].size(); j++) {
if (A[i][j] != B[i][j]) {
int z;
for (l = A[i].size() - 1; l >= j; l--)
if (A[i][l] != B[i][l]) break;
l -= j;
l += 1;
break;
}
}
if (l != -1) {
if (ret.size() == 0) {
ret = A[i];
retwith = B[i];
mret = l;
p = j;
} else {
if (l != mret || ret.substr(p, l) != A[i].substr(j, l) ||
retwith.substr(p, l) != B[i].substr(j, l)) {
printf("NO\n");
return 0;
}
int b, e;
for (e = 0; j + l + e < A[i].size() && p + l + e < ret.size(); e++)
if (A[i][j + l + e] != ret[p + l + e]) break;
for (b = 1; j - b >= 0 && p - b >= 0; b++)
if (A[i][j - b] != ret[p - b]) break;
ret = ret.substr(p - b + 1, l + e + b - 1);
retwith = retwith.substr(p - b + 1, l + e + b - 1);
p -= p - b + 1;
}
}
}
for (int i = 0; i < n; i++) {
int p = A[i].find(ret);
if (ret.size() <= A[i].size() && p != string::npos) {
for (int j = 0; j < ret.size(); j++) A[i][j + p] = retwith[j];
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < A[i].size(); j++)
if (A[i][j] != B[i][j]) {
printf("NO\n");
return 0;
}
printf("YES\n");
printf("%s\n", ret.c_str());
printf("%s\n", retwith.c_str());
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
inline double sq(double a) { return a * a; }
int n, x[512], p[512];
double rs[512], radius[512];
vector<int> s;
double f(int d, double r) { return sq(d) / (4 * r); }
void relax(int i, int j) {
const int t = s[j];
radius[i] = min(radius[i], sq(x[i] - x[t]) / (4 * radius[t]));
}
double solve(int LIM) {
s.clear();
double sum = 0;
for (int i = 0; i < (int)(n); i++) {
radius[i] = p[i];
for (int j = 0; j < (int)(min((int)s.size(), LIM)); j++) {
relax(i, s.size() - 1 - j);
}
while (!s.empty() && radius[s.back()] <= radius[i]) {
s.pop_back();
}
s.push_back(i);
sum += radius[i];
}
return sum;
}
int main() {
x[0] = 0;
p[0] = 500000;
rs[0] = 500000;
x[1] = 20000;
p[1] = 500000;
rs[1] = f(x[1] - x[0], rs[0]);
for (int i = 2; i < 305; i++) {
x[i] = x[i - 1] + 1;
while (f(x[i] - x[i - 1] + 1, rs[i - 1]) < rs[i - 1]) x[i]++;
rs[i] = f(x[i] - x[i - 1], rs[i - 1]);
p[i] = rs[i] + 1;
}
x[305] = 1000000;
p[305] = 1000000;
n = 306;
printf("%d\n", n);
for (int i = 0; i < (int)(n); i++) printf("%d %d\n", x[i], p[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n;
char a[9][9];
int main() {
ios_base::sync_with_stdio(0);
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
cin >> a[i][j];
}
}
long long fb, fw;
long long f = 0;
long long mw = 1000000, mb = 10000000;
for (long long i = 0; i < 8; i++) {
for (long long j = 0; j < 8; j++) {
if (a[i][j] != 'W') {
continue;
}
long long r = i, c = j, d = 0;
for (long long k = i; k >= 0; k--) {
if (a[k][j] == 'B') {
d = 1;
break;
}
}
if (d) {
continue;
}
mw = min(mw, i);
}
if (f) {
break;
}
}
f = 0;
for (long long i = 0; i < 8; i++) {
for (long long j = 0; j < 8; j++) {
if (a[i][j] != 'B') {
continue;
}
long long r = i, c = j, d = 0;
for (long long k = i; k < 8; k++) {
if (a[k][j] == 'W') {
d = 1;
break;
}
}
if (d) {
continue;
}
mb = min(mb, 7 - i);
}
}
if (mw > mb) {
cout << "B\n";
} else {
cout << "A\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.2,popcnt,abm,mmx,avx2,tune=native")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-funroll-all-loops,-fpeel-loops,-funswitch-loops")
using namespace std;
long long power(long long x, long long y, long long m) {
long long temp;
if (y == 0) return 1;
temp = (power(x, y / 2, m)) % m;
if (y % 2 == 0)
return ((temp % m) * temp);
else
return ((x * temp % m) * temp % m) % m;
}
long long inv(long long x, long long m = 1000000007) {
return (power(x, m - 2, m)) % m;
}
string s, t;
long long DP[201][201][201], BEST = 0;
long long REC(long long idx, long long idx2, long long C) {
if (C >= 201) return INT_MAX;
if (idx == s.size() && idx2 == t.size()) return C;
if (DP[idx][idx2][C] + 1) return DP[idx][idx2][C];
bool a = 0, b = 0;
if (idx < s.size())
if (s[idx] == '(') a = 1;
if (idx2 < t.size())
if (t[idx2] == '(') b = 1;
long long miner = INT_MAX;
if (C) {
miner = REC(min(idx + (!a), (long long)s.size()),
min(idx2 + (!b), (long long)t.size()), C - 1) +
1;
}
miner = min(miner, REC(min(idx + a, (long long)s.size()),
min(idx2 + b, (long long)t.size()), C + 1) +
1);
return DP[idx][idx2][C] = miner;
}
int32_t main() {
cin.tie(0), iostream::sync_with_stdio(0);
cin >> s >> t;
for (long long i = 0; i < 201; i++)
for (long long l = 0; l < 201; l++)
for (long long x = 0; x < 201; x++) DP[i][l][x] = -1;
BEST = REC(0, 0, 0);
long long A = 0, B = 0, C = 0;
BEST--;
while (BEST >= 0) {
bool F = 0, F2 = 0;
if (A < s.size())
if (s[A] == '(') F = 1;
if (B < t.size())
if (t[B] == '(') F2 = 1;
if (C) {
if (REC(A + (!F), B + (!F2), C - 1) == BEST) {
cout << ')', BEST--, C--, A = min(A + (!F), (long long)s.size()),
B = min(B + (!F2), (long long)t.size());
goto a;
}
}
if (REC(A + F, B + F2, C + 1) == BEST)
cout << '(', BEST--, C++, A = min(A + (F), (long long)s.size()),
B = min(B + (F2), (long long)t.size());
else {
while (C--) {
cout << ')';
}
return 0;
}
a:;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
const int maxn = 2 * (1e6 + 5);
long long mod_pow(long long x, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = ans * x % Mod;
x = x * x % Mod;
n >>= 1;
}
return ans;
}
long long fac[maxn], cfac[maxn];
void init() {
memset(fac, 0, sizeof(fac));
memset(cfac, 0, sizeof(cfac));
fac[0] = cfac[0] = 1;
for (int i = 1; i < maxn; i++) {
fac[i] = fac[i - 1] * i % Mod;
cfac[i] = mod_pow(fac[i], Mod - 2);
}
}
long long c(long long m, long long n) {
return fac[m] * cfac[n] % Mod * cfac[m - n] % Mod;
}
int main(int argc, const char* argv[]) {
long long n;
cin >> n;
init();
long long ans;
ans = (2 * c(2 * n + 1, n) % Mod + Mod - 1) % Mod;
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, maxp = 0, sum = 0;
pair<long long, long long> a[200005];
cin >> n;
for (int i = 0; i < n; i++) {
long long k, maxx = 0;
cin >> k;
for (int i = 0; i < k; i++) {
long long tmp;
cin >> tmp;
maxx = max(maxx, tmp);
}
a[i] = {maxx, k};
maxp = max(maxp, maxx);
}
for (int i = 0; i < n; i++) {
sum += (maxp - a[i].first) * a[i].second;
}
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
long long toInt(char xx) { return xx - '0'; }
char toChar(long long xx) { return xx + '0'; }
long long isDigit(char xx) { return ('0' <= xx && xx <= '9'); }
bool isCharacter(char xx) {
return (('a' <= xx && xx <= 'z') || ('A' <= xx && xx <= 'Z'));
}
void swapInt(long long &x, long long &y) {
x = x ^ y;
y = x ^ y;
x = x ^ y;
}
const long long dx[4] = {-1, 1, 0, 0};
const long long dy[4] = {0, 0, -1, 1};
const long long Mod = 9901;
const long long maxn = 1e5 + 10;
long long exitInput = 0;
long long n, m;
long long a[maxn];
long long it[4 * maxn], lazy[4 * maxn];
void build_it(long long node, long long l, long long r) {
if (l == r) {
it[node] = a[l];
} else {
long long mid = (l + r) >> 1;
build_it((node << 1), l, mid);
build_it((node << 1) | 1, mid + 1, r);
it[node] = max(it[(node << 1)], it[(node << 1) | 1]);
}
}
void do_update(long long node) {
if (lazy[node]) {
it[node] = lazy[node];
if (((node << 1)) >= 4LL * maxn) {
return;
}
lazy[(node << 1)] = lazy[node];
lazy[(node << 1) | 1] = lazy[node];
lazy[node] = 0;
}
}
long long get(long long node, long long l, long long r, long long i,
long long j) {
do_update(node);
if (j < l || r < i) {
return -1;
}
if (i <= l && r <= j) {
return it[node];
}
long long mid = (l + r) >> 1;
long long p1 = get((node << 1), l, mid, i, j);
long long p2 = get((node << 1) | 1, mid + 1, r, i, j);
it[node] = max(it[(node << 1)], it[(node << 1) | 1]);
return max(p1, p2);
}
void update(long long node, long long l, long long r, long long i, long long j,
long long val) {
do_update(node);
if (j < l || r < i) {
return;
}
if (i <= l && r <= j) {
it[node] = val;
if (l != r) {
lazy[(node << 1)] = val;
lazy[(node << 1) | 1] = val;
}
return;
}
long long mid = (l + r) >> 1;
update((node << 1), l, mid, i, j, val);
update((node << 1) | 1, mid + 1, r, i, j, val);
it[node] = max(it[(node << 1)], it[(node << 1) | 1]);
}
void read() {
cin >> n;
long long i;
for (i = 1; i <= n; ++i) {
cin >> a[i];
}
cin >> m;
}
void init() { build_it(1, 1, n); }
void solve() {
long long i;
long long w, h;
long long max_h;
for (i = 1; i <= m; ++i) {
cin >> w >> h;
max_h = get(1, 1, n, 1, w);
cout << max_h << endl;
update(1, 1, n, 1, w, max_h + h);
}
}
int main() {
ios_base::sync_with_stdio(0);
int ntest = 1;
int itest = 1;
for (itest = 1; itest <= ntest; ++itest) {
read();
if (exitInput) {
break;
}
if (itest > 1) {
}
init();
solve();
}
return 0;
}
| 7 |
Subsets and Splits