solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
vector<int> wholesquares;
int age(int i) {
int low = 0, high = wholesquares.size() - 1, mid, ans;
while (low <= high) {
mid = (low + high) / 2;
if (wholesquares[mid] <= i) {
low = mid + 1;
ans = mid;
} else {
high = mid - 1;
}
}
return ans;
}
bool cmp(pair<int, int> &a, pair<int, int> &b) {
return a.first < b.first or a.second > b.second;
}
int pore(int i) {
int low = 0, high = wholesquares.size() - 1, mid, ans;
while (low <= high) {
mid = (low + high) / 2;
if (wholesquares[mid] > i) {
high = mid - 1;
ans = mid;
} else {
low = mid + 1;
}
}
return ans;
}
int main() {
for (int i = 0; i * i <= 1e9; i++) wholesquares.push_back(i * i);
wholesquares.push_back(31623 * 31623);
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
vector<pair<int, int>> dist;
for (int i = 0; i < n; i++) {
int x = age(a[i]);
int y = pore(a[i]);
int mn = min(a[i] - wholesquares[x], wholesquares[y] - a[i]);
if (mn == 0) {
if (a[i])
dist.push_back({mn, 1});
else
dist.push_back({mn, 2});
} else {
dist.push_back({mn, 0});
}
}
sort(dist.begin(), dist.end(), cmp);
long long sum = 0;
for (int i = 0; i < n; i++) {
if (i < n / 2)
sum += dist[i].first;
else
sum += dist[i].second;
}
printf("%lld\n", sum);
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int64_t dr8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int64_t dc8[] = {0, 1, 1, 1, 0, -1, -1, -1};
int64_t dr4[] = {1, 0, 0, -1};
int64_t dc4[] = {0, 1, -1, 0};
int64_t gcd(int64_t a, int64_t b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
void solve();
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int64_t t = 1;
for (int64_t i = 1; i <= t; i++) {
solve();
}
}
void solve() {
int64_t i, n, j, m, k, l;
string s, t;
cin >> s >> t;
i = 0;
for (j = 0; j < t.length(); j++) {
if (s[i] == t[j]) i++;
}
cout << i + 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
int gcd(int a, int b) { return (!b) ? a : gcd(b, a % b); }
long long gcd(long long a, long long b) { return (!b) ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int a[5005], dp[5005], n, res = 2147483647;
int main() {
scanf("%d %*d", &n);
for (int i = 0; i < n; i++) scanf("%d %*lf", &a[i]);
for (int i = 0; i < n; i++) {
dp[i] = 1;
for (int j = 0; j < i; j++)
if (a[j] <= a[i]) dp[i] = max(dp[j] + 1, dp[i]);
res = min(n - dp[i], res);
}
printf("%d\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long prime = 1e9 + 7;
bool isvowel(char c) {
vector<char> v = {'A', 'E', 'I', 'O', 'U', 'Y'};
for (int i = 0; i < 6; i++) {
if (c == v[i]) {
return true;
}
}
return false;
}
int main() {
int n, k, n1, n2, i;
string s;
cin >> n >> k >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'G') {
n1 = i;
} else if (s[i] == 'T') {
n2 = i;
}
}
if (n1 > n2) {
swap(n1, n2);
}
if ((n2 - n1) % k != 0) {
cout << "NO";
} else {
i = n1;
while (i != n2) {
if (s[i + k] == '#') {
cout << "NO";
return 0;
}
i += k;
}
cout << "YES";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s[9];
bool f = false;
int func1() {
for (int i = 7; i >= 0; --i)
for (int j = 0; j < 8; ++j) {
f = false;
if (s[i][j] == 'B') {
for (int k = i + 1; k < 8; ++k) {
if (s[k][j] != '.') f = true;
}
if (f == false) {
return i;
}
}
}
}
int func2() {
for (int i = 0; i < 8; ++i)
for (int j = 0; j < 8; ++j) {
f = false;
if (s[i][j] == 'W') {
for (int k = i - 1; k >= 0; --k)
if (s[k][j] != '.') f = true;
if (f == false) {
return i;
}
}
f = false;
}
}
int main() {
for (int i = 0; i < 8; ++i) cin >> s[i];
int pos_b = 7;
int pos_a = 0;
pos_b = func1();
pos_a = func2();
if ((7 - pos_b) < pos_a)
cout << 'B';
else
cout << 'A';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, c;
cin >> s;
int a, b;
if (s[1] == 'o') a = 1;
if (s[1] == 'u') {
a = 2;
if (s[0] == 's') a = 7;
}
if (s[1] == 'e') a = 3;
if (s[1] == 'h') a = 4;
if (s[1] == 'r') a = 5;
if (s[1] == 'a') a = 6;
b = a;
cin >> s;
if (s[1] == 'o') a = 1;
if (s[1] == 'u') {
a = 2;
if (s[0] == 's') a = 7;
}
if (s[1] == 'e') a = 3;
if (s[1] == 'h') a = 4;
if (s[1] == 'r') a = 5;
if (s[1] == 'a') a = 6;
if (a < b) a += 7;
if (a - b == 3 || a - b == 0 || a - b == 2)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool a, b, c, d, ans;
cin >> a >> b >> c >> d;
ans = ((a ^ b) & (c | d)) ^ ((b & c) | (a ^ d));
cout << int(ans) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, i, j, sum = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a);
sum += a * (i + 1);
}
printf("%d\n", sum);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool check(string a, string b, string c, string temp) {
string t = a + b + c;
if (t == temp) {
cout << "ACC"
<< "\n";
return true;
}
return false;
}
int32_t main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long t = 1;
while (t--) {
string a, b, c;
cin >> a >> b >> c;
string na, nb, nc;
for (long long i = 0; i < a.length(); i++) {
if (a[i] >= 'A' && a[i] <= 'Z') {
a[i] += 32;
na += a[i];
} else if (a[i] >= 'a' && a[i] <= 'z')
na += a[i];
}
for (long long i = 0; i < b.length(); i++) {
if (b[i] >= 'A' && b[i] <= 'Z') {
b[i] += 32;
nb += b[i];
} else if (b[i] >= 'a' && b[i] <= 'z')
nb += b[i];
}
for (long long i = 0; i < c.length(); i++) {
if (c[i] >= 'A' && c[i] <= 'Z') {
c[i] += 32;
nc += c[i];
} else if (c[i] >= 'a' && c[i] <= 'z')
nc += c[i];
}
long long n;
cin >> n;
while (n--) {
string temp, tem;
cin >> temp;
for (long long i = 0; i < temp.length(); i++) {
if (temp[i] >= 'A' && temp[i] <= 'Z') {
temp[i] += 32;
tem += temp[i];
} else if (temp[i] >= 'a' && temp[i] <= 'z')
tem += temp[i];
}
bool k = false;
vector<string> v;
k = check(na, nb, nc, tem);
if (k) continue;
k = check(na, nc, nb, tem);
if (k) continue;
k = check(nb, na, nc, tem);
if (k) continue;
k = check(nb, nc, na, tem);
if (k) continue;
k = check(nc, na, nb, tem);
if (k) continue;
k = check(nc, nb, na, tem);
if (k) continue;
cout << "WA"
<< "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
const int inf = 1e9 + 7;
int n, m, d;
int a[maxn];
int b[maxn];
map<int, int> at;
bool ok(int x) {
for (int i = x; i < n; i++) {
if (a[i] - a[i - x] <= d) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> d;
for (int i = 0; i < n; i++) {
cin >> b[i];
a[i] = b[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
at[a[i]] = i;
}
int lo = 1;
int hi = n + 1;
while (hi - lo > 1) {
int mid = lo + (hi - lo - 1) / 2;
if (ok(mid)) {
hi = mid + 1;
} else {
lo = mid + 1;
}
}
cout << lo << endl;
for (int i = 0; i < n; i++) {
cout << (at[b[i]] % lo) + 1 << " \n"[(i < n - 1) ? 0 : 1];
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T euclide(T a, T b, T& x, T& y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline void checkmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T& a, T b) {
if (b > a) a = b;
}
template <class T>
T Abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline bool isPrime(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T Mod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long toLl(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
template <class T>
void debug(const T& e) {
cout << e << endl;
}
template <class T1, class T2>
void debug(const T1& e1, const T2& e2) {
cout << e1 << "\t" << e2 << endl;
}
template <class T1, class T2, class T3>
void debug(const T1& e1, const T2& e2, const T3& e3) {
cout << e1 << "\t" << e2 << "\t" << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void debug(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void debug(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
const T5& e5) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << endl;
}
template <class T>
void debug(vector<T>& e) {
int i;
for (i = 0; i < (int)e.size(); i++) cout << e[i] << " ";
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> >& e) {
int i, j;
for (i = 0; i < (int)e.size(); i++) {
for (j = 0; j < (int)e[i].size(); j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<vector<T> >& e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << "\t";
cout << endl;
}
cout << endl;
}
template <class T>
void debug(T e[100][100], int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
}
long long Pow(int B, int P) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
int BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return (int)R;
}
long long val[200500], fact[200500];
int main() {
int i, j, Case = 1, test, N, typ, a, x;
while (scanf("%d", &N) == 1) {
memset(val, 0, sizeof(val));
memset(fact, 0, sizeof(fact));
long long totalSum = 0;
long long sz = 1;
for (i = 0; i < N; i++) {
scanf("%d", &typ);
if (typ == 1) {
scanf("%d %d", &a, &x);
totalSum += (a * x);
fact[a] += x;
} else if (typ == 2) {
scanf("%d", &x);
sz++;
totalSum += x;
val[sz] = x;
fact[sz] = 0;
} else {
totalSum = totalSum - val[sz] - fact[sz];
fact[sz - 1] += fact[sz];
sz--;
}
printf("%.10lf\n", totalSum / (double)sz);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long power(long long x, long long p) {
if (p == 0) return 1 % MOD;
if (p & 1) return x * power(x, p - 1) % MOD;
return power(x * x % MOD, p >> 1);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << power(m, n) << '\n';
} else if (k == n) {
cout << power(m, (n + 1) / 2);
} else if (k % 2 == 0) {
cout << power(m, 1) << '\n';
} else {
cout << power(m, 2) << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << 303 << endl;
cout << "0 1000000\n";
int prev = 100000;
for (int i = 2; i <= 302; ++i) {
prev += 2 * (301 - i) + 10;
cout << prev << " " << 303 - i << "\n";
}
cout << "1000000 1000000";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void reverse(string *str, int i, int j) {
if (i <= j) {
char c = str->at(i);
char r = str->at(j);
str->at(i) = r;
str->at(j) = c;
}
}
int main() {
string s, res;
int days, aux, in;
cin >> s;
cin >> days;
aux = s.length() / 2;
int sums[aux];
fill(sums, sums + sizeof(sums) / sizeof(int), 0);
while (days--) {
cin >> in;
sums[in]++;
}
in = 0;
for (int i = 1; i <= aux; i++) {
in += sums[i];
if (in % 2) {
swap(s[i - 1], s[s.length() - i]);
}
}
cout << s << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:16000000")
#pragma warning(disable : 4996)
const int inf = 1 << 25;
const double eps = 1e-9;
struct Resident {
string name, type;
int bonus;
Resident(string name, string type, int bonus)
: name(name), type(type), bonus(bonus) {}
bool operator<(const Resident& other) const { return bonus < other.bonus; }
};
struct Equip {
string name, type;
int stat, size;
int addStat;
vector<Resident> residents;
void AddResident(const Resident& res) {
if (residents.size() >= size) throw 0;
residents.push_back(res);
addStat += (res.type == type) * res.bonus;
}
bool IsFull() const { return size == residents.size(); }
void ClearResidents() {
residents.clear();
addStat = 0;
}
void Pick(const vector<Resident>& residents) {
for (int i = 0; i < residents.size() && i < size; ++i)
AddResident(residents[i]);
}
string toString() const {
stringstream res;
res << name << " " << residents.size();
for (int i = (0); i < ((int)residents.size()); ++i)
res << " " << residents[i].name;
return res.str();
}
Equip() {
stat = -inf;
addStat = 0;
}
Equip(string name, string type, int stat, int size)
: name(name), type(type), stat(stat), size(size), addStat(0) {}
int cntStat() const { return stat + addStat; }
bool operator<(const Equip& other) const {
return cntStat() < other.cntStat();
}
bool Contains(const Resident& res) const {
for (int i = (0); i < ((int)residents.size()); ++i)
if (residents[i].name == res.name) return true;
return false;
}
};
const int WEAPON = 0, SHIELD = 1, ORB = 2;
int StoType(const string& s) {
switch (s[0]) {
case 'w':
return WEAPON;
case 'a':
return SHIELD;
default:
return ORB;
}
}
string eqTypes[] = {"weapon", "armor", "orb"};
string convertResToEqType(string type) {
switch (type[0]) {
case 'g':
return eqTypes[WEAPON];
case 's':
return eqTypes[SHIELD];
default:
return eqTypes[ORB];
}
}
int main() {
int n, k;
cin >> n;
vector<Equip> equip[3];
map<string, pair<int, int> > equipMap;
for (int i = (0); i < (n); ++i) {
string name, cls;
int size;
int stats[3];
cin >> name >> cls >> stats[0] >> stats[1] >> stats[2] >> size;
equip[StoType(cls)].push_back(Equip(name, cls, stats[StoType(cls)], size));
equipMap[name] =
pair<int, int>(StoType(cls), equip[StoType(cls)].size() - 1);
}
cin >> k;
vector<Resident> residents[3];
vector<Resident> allRes;
for (int i = (0); i < (k); ++i) {
string name, type, home;
int bonus;
cin >> name >> type >> bonus >> home;
type = convertResToEqType(type);
Resident curRes(name, type, bonus);
equip[equipMap[home].first][equipMap[home].second].AddResident(curRes);
allRes.push_back(curRes);
residents[StoType(type)].push_back(Resident(name, type, bonus));
}
Equip optimal[3];
bool hasNotFull = false;
for (int i = (0); i < (3); ++i)
for (int j = (0); j < ((int)equip[i].size()); ++j)
hasNotFull = hasNotFull || !equip[i][j].IsFull(),
optimal[i] = max(optimal[i], equip[i][j]);
if (hasNotFull) {
for (int i = (0); i < (3); ++i) {
optimal[i].ClearResidents();
sort(residents[i].begin(), residents[i].end());
reverse(residents[i].begin(), residents[i].end());
for (int j = (0); j < ((int)equip[i].size()); ++j) {
Equip cur = equip[i][j];
cur.ClearResidents();
cur.Pick(residents[i]);
optimal[i] = max(optimal[i], cur);
}
}
}
vector<bool> equippedResidents(allRes.size(), false);
for (int i = (0); i < ((int)equippedResidents.size()); ++i)
for (int j = (0); j < (3); ++j)
if (optimal[j].Contains(allRes[i])) equippedResidents[i] = true;
for (int i = (0); i < ((int)equippedResidents.size()); ++i)
if (!equippedResidents[i])
for (int j = (0); j < (3); ++j)
if (!optimal[j].IsFull()) {
optimal[j].AddResident(allRes[i]);
break;
}
for (int i = (0); i < (3); ++i) cout << optimal[i].toString() << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long LL_INF = (long long)2e18 + 5;
template <typename T, bool maximum_mode = false>
struct RMQ {
int n = 0, levels = 0;
vector<T> values;
vector<vector<int>> range_low;
RMQ(const vector<T> &_values = {}) {
if (!_values.empty()) build(_values);
}
static int largest_bit(int x) { return 31 - __builtin_clz(x); }
int better_index(int a, int b) const {
return (values[a] < values[b]) ^ maximum_mode ? a : b;
}
void build(const vector<T> &_values) {
values = _values;
n = values.size();
levels = largest_bit(n) + 1;
range_low.resize(levels);
for (int k = 0; k < levels; k++) range_low[k].resize(n - (1 << k) + 1);
for (int i = 0; i < n; i++) range_low[0][i] = i;
for (int k = 1; k < levels; k++)
for (int i = 0; i <= n - (1 << k); i++)
range_low[k][i] = better_index(range_low[k - 1][i],
range_low[k - 1][i + (1 << (k - 1))]);
}
int query_index(int a, int b) const {
assert(0 <= a && a < b && b <= n);
int level = largest_bit(b - a);
return better_index(range_low[level][a],
range_low[level][b - (1 << level)]);
}
T query_value(int a, int b) const { return values[query_index(a, b)]; }
};
struct edge {
int node = -1;
long long weight = 0;
edge() {}
edge(int _node, long long _weight) : node(_node), weight(_weight) {}
};
template <typename T_weight>
struct weighted_LCA {
int n = 0;
vector<vector<edge>> adj;
vector<int> parent, depth, subtree_size;
vector<T_weight> weighted_depth, up_weight;
vector<int> euler, first_occurrence;
vector<int> tour_start, tour_end, tour_list, postorder;
vector<int> heavy_root;
RMQ<int> rmq;
weighted_LCA(int _n = 0) { init(_n); }
weighted_LCA(const vector<vector<edge>> &_adj) { init(_adj); }
void init(int _n) {
n = _n;
adj.assign(n, {});
parent.resize(n);
depth.resize(n);
subtree_size.resize(n);
weighted_depth.resize(n);
up_weight.assign(n, numeric_limits<T_weight>::min());
first_occurrence.resize(n);
tour_start.resize(n);
tour_end.resize(n);
tour_list.resize(n);
postorder.resize(n);
heavy_root.resize(n);
}
void init(const vector<vector<edge>> &_adj) {
init(_adj.size());
adj = _adj;
}
void add_edge(int a, int b, T_weight weight) {
adj[a].emplace_back(b, weight);
adj[b].emplace_back(a, weight);
}
void erase_edge(int from, int to) {
for (edge &e : adj[from])
if (e.node == to) {
swap(e, adj[from].back());
adj[from].pop_back();
return;
}
assert(false);
}
void dfs(int node, int par, T_weight weight) {
parent[node] = par;
depth[node] = par < 0 ? 0 : depth[par] + 1;
subtree_size[node] = 1;
weighted_depth[node] = weight;
if (par >= 0) erase_edge(node, par);
for (edge &e : adj[node]) {
up_weight[e.node] = e.weight;
dfs(e.node, node, weight + e.weight);
subtree_size[node] += subtree_size[e.node];
}
sort(adj[node].begin(), adj[node].end(), [&](const edge &a, const edge &b) {
return subtree_size[a.node] > subtree_size[b.node];
});
}
int tour, post_tour;
void tour_dfs(int node, bool heavy) {
heavy_root[node] = heavy ? heavy_root[parent[node]] : node;
first_occurrence[node] = euler.size();
euler.push_back(node);
tour_list[tour] = node;
tour_start[node] = tour++;
bool heavy_child = true;
for (edge &e : adj[node]) {
tour_dfs(e.node, heavy_child);
euler.push_back(node);
heavy_child = false;
}
tour_end[node] = tour;
postorder[node] = post_tour++;
}
void build() {
parent.assign(n, -1);
for (int i = 0; i < n; i++)
if (parent[i] < 0) dfs(i, -1, 0);
tour = post_tour = 0;
for (int i = 0; i < n; i++)
if (parent[i] < 0) {
tour_dfs(i, false);
euler.push_back(-1);
}
assert((int)euler.size() == 2 * n);
vector<int> euler_depths;
for (int node : euler)
euler_depths.push_back(node < 0 ? node : depth[node]);
rmq.build(euler_depths);
build_path_maxes();
}
int get_lca(int a, int b) const {
a = first_occurrence[a];
b = first_occurrence[b];
if (a > b) swap(a, b);
return euler[rmq.query_index(a, b + 1)];
}
bool is_ancestor(int a, int b) const {
return tour_start[a] <= tour_start[b] && tour_start[b] < tour_end[a];
}
bool on_path(int x, int a, int b) const {
int anc = get_lca(a, b);
return is_ancestor(anc, x) && (is_ancestor(x, a) || is_ancestor(x, b));
}
int get_dist(int a, int b) const {
return depth[a] + depth[b] - 2 * depth[get_lca(a, b)];
}
T_weight get_weighted_dist(int a, int b) const {
return weighted_depth[a] + weighted_depth[b] -
2 * weighted_depth[get_lca(a, b)];
}
int child_ancestor(int a, int b) const {
assert(a != b);
assert(is_ancestor(a, b));
int child =
euler[rmq.query_index(first_occurrence[a], first_occurrence[b] + 1) +
1];
assert(is_ancestor(child, b));
return child;
}
static int largest_bit(int x) { return 31 - __builtin_clz(x); }
vector<vector<pair<int, T_weight>>> ancestor_max;
void build_path_maxes() {
ancestor_max.assign(largest_bit(n) + 1, vector<pair<int, T_weight>>(n));
for (int i = 0; i < n; i++) ancestor_max[0][i] = {parent[i], up_weight[i]};
for (int k = 0; k < largest_bit(n); k++)
for (int i = 0; i < n; i++) {
int k_anc = ancestor_max[k][i].first;
T_weight k_max = ancestor_max[k][i].second;
if (k_anc < 0)
ancestor_max[k + 1][i] = {-1, k_max};
else
ancestor_max[k + 1][i] = {ancestor_max[k][k_anc].first,
max(k_max, ancestor_max[k][k_anc].second)};
}
}
T_weight query_path_max(int a, int b) const {
int anc = get_lca(a, b);
int a_dist = depth[a] - depth[anc];
int b_dist = depth[b] - depth[anc];
T_weight path_max = numeric_limits<T_weight>::min();
for (int k = 0; 1 << k <= a_dist; k++)
if (a_dist >> k & 1) {
path_max = max(path_max, ancestor_max[k][a].second);
a = ancestor_max[k][a].first;
}
for (int k = 0; 1 << k <= b_dist; k++)
if (b_dist >> k & 1) {
path_max = max(path_max, ancestor_max[k][b].second);
b = ancestor_max[k][b].first;
}
return path_max;
}
};
struct dijkstra_state {
long long dist;
int node;
dijkstra_state() {}
dijkstra_state(long long _dist, int _node) : dist(_dist), node(_node) {}
bool operator<(const dijkstra_state &other) const {
return dist > other.dist;
}
};
int N, M, K, Q;
vector<vector<edge>> adj;
vector<long long> dist;
void dijkstra_check(priority_queue<dijkstra_state> &pq, int node,
long long current_dist) {
if (current_dist < dist[node]) {
dist[node] = current_dist;
pq.emplace(current_dist, node);
}
}
void dijkstra() {
dist.assign(N, LL_INF);
priority_queue<dijkstra_state> pq;
for (int source = 0; source < K; source++) dijkstra_check(pq, source, 0);
while (!pq.empty()) {
dijkstra_state top = pq.top();
pq.pop();
if (top.dist > dist[top.node]) continue;
for (edge &e : adj[top.node])
dijkstra_check(pq, e.node, top.dist + e.weight);
}
}
struct union_find {
vector<int> parent;
vector<int> size;
int components = 0;
union_find(int n = -1) {
if (n >= 0) init(n);
}
void init(int n) {
parent.resize(n + 1);
size.assign(n + 1, 1);
components = n;
for (int i = 0; i <= n; i++) parent[i] = i;
}
int find(int x) { return x == parent[x] ? x : parent[x] = find(parent[x]); }
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
if (size[x] < size[y]) swap(x, y);
parent[y] = x;
size[x] += size[y];
components--;
return true;
}
};
template <typename T>
struct kruskal {
struct edge {
int a, b;
T weight;
bool in_tree = false;
edge() {}
edge(int _a, int _b, T _weight) : a(_a), b(_b), weight(_weight) {}
bool operator<(const edge &other) const { return weight < other.weight; }
};
union_find UF;
vector<edge> edges;
kruskal(int n = -1) {
if (n >= 0) init(n);
}
void init(int n) {
UF.init(n);
edges = {};
}
void add_edge(int a, int b, T weight) { edges.emplace_back(a, b, weight); }
T solve() {
sort(edges.begin(), edges.end());
T total = 0;
for (edge &e : edges)
if (UF.unite(e.a, e.b)) {
total += e.weight;
e.in_tree = true;
}
return total;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N >> M >> K >> Q;
adj.assign(N, {});
for (int i = 0; i < M; i++) {
int u, v, weight;
cin >> u >> v >> weight;
u--;
v--;
adj[u].emplace_back(v, weight);
adj[v].emplace_back(u, weight);
}
dijkstra();
kruskal<long long> mst(N);
for (int i = 0; i < N; i++)
for (edge &e : adj[i]) {
e.weight += dist[i] + dist[e.node];
mst.add_edge(i, e.node, e.weight);
}
mst.solve();
weighted_LCA<long long> lca(N);
for (kruskal<long long>::edge &e : mst.edges)
if (e.in_tree) lca.add_edge(e.a, e.b, e.weight);
lca.build();
for (int q = 0; q < Q; q++) {
int a, b;
cin >> a >> b;
a--;
b--;
cout << max(lca.query_path_max(a, b), 0LL) << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9+7;
const ll INF = 1e18;
#define rep(i,m,n) for(ll i = (m); i <= (n); i++)
#define zep(i,m,n) for(ll i = (m); i < (n); i++)
#define rrep(i,m,n) for(ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x,m,n) for(int i = (m); i <= n; i++){cout << (x[i]) << " ";} cout<<endl;
ll x[4], y[4];
bool cross(ll a, ll b, ll c, ll d){
return !(b < c || d < a);
}
vector<ll> g(ll a, ll b, ll c, ll d){
ll cx = abs(a - b) + abs(c - d);
ll llb = min(a, b);
ll lrb = max(a, b);
ll rlb = min(c, d);
ll rrb = max(c, d);
ll mnx = cross(llb, lrb, rlb, rrb)? 0 : min(abs(llb - rrb), abs(lrb - rlb));
ll mxx = max(max(lrb - llb, rrb - rlb), max(lrb - rlb, rrb - llb));
return {cx, mnx, mxx};
}
ll f(ll a, ll b, ll c){
auto vx = g(x[0], x[a], x[b], x[c]);
auto vy = g(y[0], y[b], y[a], y[c]);
if(cross(vx[1], vx[2], vy[1], vy[2])){
return vx[0] + vy[0];
}
return vx[0] + vy[0] + 2 * min(abs(vx[1] - vy[2]), abs(vx[2] - vy[1]));
}
int main(){
cin.tie(0); ios::sync_with_stdio(false);
ll t; cin >> t;
while(t--){
zep(i, 0, 4)cin >> x[i] >> y[i];
ll ans = INF;
ans = min(ans, f(1, 2, 3));
ans = min(ans, f(1, 3, 2));
ans = min(ans, f(2, 1, 3));
ans = min(ans, f(2, 3, 1));
ans = min(ans, f(3, 1, 2));
ans = min(ans, f(3, 2, 1));
print(ans)
}
return 0;
} | 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma comment(linker, "/STACK:936777216")
using namespace std;
int OO = 0x3f3f3f3f;
const int MAX = 100000000;
char vis[MAX / 8 + 1];
void setVisited(int i) { vis[i >> 3] |= (1 << (i & 7)); }
bool isVisited(int i) { return vis[i >> 3] & (1 << (i & 7)); }
int arr[1000005];
int n, a;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
long long cost = 0;
for (int i = 0; i < s1.size(); i++) {
if (s1[i] != s2[i]) {
if (i < s1.size() && s1[i + 1] == s2[i] && s2[i + 1] == s1[i]) {
swap(s1[i], s1[i + 1]);
cost += 1;
} else if (s1[i] != s2[i]) {
cost += 1;
if (s1[i] == '0')
s1[i] = '1';
else
s1[i] = '0';
}
}
}
cout << cost << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
struct Node {
int x, y, id;
bool operator<(const Node& rhs) const {
return (x < rhs.x || (x == rhs.x && y < rhs.y));
}
} node[maxn], anss[10800], anst[10800];
int n, m;
int Move(int step, int x1, int y1, int x2, int y2) {
while (x1 != x2) {
if (x1 < x2) {
anss[++step].x = x1, anss[step].y = y1;
++x1;
anst[step].x = x1, anst[step].y = y1;
} else {
anss[++step].x = x1, anss[step].y = y1;
--x1;
anst[step].x = x1, anst[step].y = y1;
}
}
while (y1 != y2) {
if (y1 < y2) {
anss[++step].x = x1, anss[step].y = y1;
++y1;
anst[step].x = x1, anst[step].y = y1;
} else {
anss[++step].x = x1, anss[step].y = y1;
--y1;
anst[step].x = x1, anst[step].y = y1;
}
}
return step;
}
int solve(int step) {
sort(node + 1, node + 1 + m);
for (int i = 1; i <= m; i++) {
if (node[i].x > i) {
step = Move(step, node[i].x, node[i].y, i, node[i].y);
node[i].x = i;
}
}
for (int i = m; i >= 1; i--) {
step = Move(step, node[i].x, node[i].y, i, node[i].y);
node[i].x = i;
}
for (int i = 1; i <= m; i++) {
step = Move(step, node[i].x, node[i].y, node[i].x, node[i].id);
node[i].y = node[i].id;
}
for (int i = 1; i <= m; i++) {
step = Move(step, node[i].x, node[i].y, node[i].id, node[i].y);
node[i].x = node[i].id;
}
return step;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &node[i].x, &node[i].y);
node[i].id = i;
}
int step1 = solve(0);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &node[i].x, &node[i].y);
node[i].id = i;
}
int step2 = solve(step1);
printf("%d\n", step2);
for (int i = 1; i <= step1; i++) {
printf("%d %d %d %d\n", anss[i].x, anss[i].y, anst[i].x, anst[i].y);
}
for (int i = step2; i > step1; i--) {
printf("%d %d %d %d\n", anst[i].x, anst[i].y, anss[i].x, anss[i].y);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxm = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const long long llinf = 0x3f3f3f3f3f3f3f3f;
char s[maxn];
int main() {
int _;
scanf("%d", &_);
while (_--) {
int n;
scanf("%d", &n);
scanf("%s", s + 1);
int flag = 0;
for (int i = n; i >= 1; i--) {
if (s[i] == '0') {
flag = i;
break;
}
}
if (!flag) {
printf("%d %d %d %d\n", 1, n - 1, 2, n);
} else {
if (flag > n / 2) {
printf("%d %d %d %d\n", 1, flag, 1, flag - 1);
} else {
printf("%d %d %d %d\n", flag, n, flag + 1, n);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000 + 5;
const int MAX_L = 20;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
vector<pair<int, int>> ans;
vector<int> adj[MAX_N];
int mx_deg = 0, t = 0;
void dfs(int u, int backT = -1, int p = 0) {
ans.push_back({u, t});
int num_child = 0;
for (int v : adj[u])
if (v != p) num_child++;
for (int v : adj[u]) {
if (v == p) continue;
if (t == mx_deg) {
t = backT - 1 - num_child;
ans.push_back({u, t});
}
t++;
dfs(v, t, u);
ans.push_back({u, t});
num_child--;
}
if (u == 1) return;
if (t >= backT) {
t = backT - 1;
ans.push_back({u, t});
}
t++;
}
void solve() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) mx_deg = max(mx_deg, int(adj[i].size()));
dfs(1);
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); ++i)
cout << ans[i].first << " " << ans[i].second << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc = 1;
for (int t = 1; t <= tc; t++) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
char ch[N];
int n;
long long m, k;
int a[N];
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int flag = 0;
for (int i = 1; i < n; i++) {
if (a[i + 1] > a[i] + k) {
int d = a[i + 1] - a[i];
if (d - k > m) {
flag = 1;
break;
} else {
m -= d - k;
}
} else {
m += min(1LL * a[i], a[i] - (a[i + 1] - k));
}
}
if (flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int sqrtQ = 150;
class suffix_array {
const static int alpha = 128;
int getOrder(int a) const { return (a < (int)order.size() ? order[a] : 0); }
public:
int n;
string s;
vector<int> suf, order, lcp;
suffix_array() {}
suffix_array(const string &s) : n(s.size() + 1), s(s) {
suf = order = lcp = vector<int>(n);
vector<int> bucket_idx(n), newOrder(n), newsuff(n);
{
vector<int> prev(n), head(alpha, -1);
for (int i = 0; i < n; i++) {
prev[i] = head[s[i]];
head[s[i]] = i;
}
int buc = -1, idx = 0;
for (int i = 0; i < alpha; i++) {
if (head[i] == -1) continue;
bucket_idx[++buc] = idx;
for (int j = head[i]; ~j; j = prev[j]) suf[idx++] = j, order[j] = buc;
}
}
int len = 1;
do {
auto cmp = [&](int a, int b) {
if (order[a] != order[b]) return order[a] < order[b];
return getOrder(a + len) < getOrder(b + len);
};
for (int i = 0; i < n; i++) {
int j = suf[i] - len;
if (j < 0) continue;
newsuff[bucket_idx[order[j]]++] = j;
}
for (int i = 1; i < n; i++) {
suf[i] = newsuff[i];
bool cmpres = cmp(suf[i - 1], suf[i]);
newOrder[suf[i]] = newOrder[suf[i - 1]] + cmpres;
if (cmpres) bucket_idx[newOrder[suf[i]]] = i;
}
order = newOrder;
len <<= 1;
} while (order[suf[n - 1]] != n - 1);
}
int count(const string &x) {
int st = 0, ed = n;
for (int i = 0; i < (int)(x.size()) && st < ed; i++) {
auto cmp = [&](int a, int b) {
if (a == -1) return x[i] < s[b + i];
return s[a + i] < x[i];
};
st = lower_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
ed = upper_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
}
return max(0, ed - st);
}
} SA[(int)1e4];
string y;
vector<int> longestPrefix;
vector<int> Fail[26];
int fail(int k, char nxt) {
int &rt = Fail[nxt - 'a'][k];
if (~rt) return rt;
while (k > 0 && y[k] != nxt) k = longestPrefix[k - 1];
if (nxt == y[k]) k++;
return rt = k;
}
void failure_function() {
int n = y.size();
longestPrefix = vector<int>(n);
for (int i = 0; i < 26; i++) Fail[i] = vector<int>(n + 1, -1);
for (int i = 1, k = 0; i < n; i++) longestPrefix[i] = k = fail(k, y[i]);
}
int main() {
run();
string s;
int q;
cin >> s >> q;
for (int i = 0; i < (int)(s.size()); i += sqrtQ)
SA[i / sqrtQ] = suffix_array(s.substr(i, sqrtQ));
auto solve = [&](int l, int r) {
int match = 0, cnt = 0;
for (int i = l; i <= r; i++) {
match = fail(match, s[i]);
if (match == (int)(y.size())) {
cnt++;
match = longestPrefix[match - 1];
}
}
return cnt;
};
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char ch;
cin >> idx >> ch;
idx--;
s[idx] = ch;
SA[idx / sqrtQ] = suffix_array(s.substr(idx / sqrtQ * sqrtQ, sqrtQ));
} else {
int l, r;
cin >> l >> r >> y;
l--, r--;
failure_function();
if ((int)(y.size()) >= sqrtQ || r - l <= 2 * sqrtQ) {
cout << solve(l, r) << "\n";
continue;
}
int ans = 0, len = (int)(y.size());
int st = l / sqrtQ, ed = r / sqrtQ;
ans += solve(l, (st + 1) * sqrtQ + len - 2);
ans += solve(ed * sqrtQ - len + 1, r);
for (int i = st + 1; i < ed; i++) ans += SA[i].count(y);
for (int i = st + 2; i < ed; i++)
ans += solve(i * sqrtQ - len + 1, i * sqrtQ + len - 2);
cout << ans << "\n";
}
}
}
| 11 |
#include <bits/stdc++.h>
const int N = 200000;
int a[N], ans[N];
std::pair<int, int> b[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
std::sort(a, a + n);
for (int i = 0; i < n; ++i) {
scanf("%d", &b[i].first);
b[i].second = i;
}
std::sort(b, b + n);
for (int i = 0; i < n; ++i) {
ans[b[i].second] = a[n - 1 - i];
}
for (int i = 0; i < n; ++i) {
printf("%d%c", ans[i], " \n"[i == n - 1]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
string A;
const int MAX = 1e5;
int ans[MAX + 5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> A;
stack<int> S;
int id = 0, sp = 0;
for (char c : A) {
if (c == '(') S.push(-1);
if (c == ')') {
if (S.empty()) return cout << -1, 0;
int top = S.top();
S.pop();
if (!S.empty() and top != -1) S.top() = top;
}
if (c == '#') {
sp++;
if (S.empty()) return cout << -1, 0;
S.pop();
if (!S.empty()) {
S.top() = id;
}
ans[id]++;
}
id++;
}
while (!S.empty()) {
if (S.top() == -1) return cout << -1, 0;
ans[S.top()]++;
int top = S.top();
S.pop();
if (!S.empty() and top != -1) S.top() = top;
}
for (int i = 0; i < A.length(); i++) {
if (A[i] == '#') {
if (ans[i] == 0) return cout << -1, 0;
}
}
for (int i = 0; i < A.length(); i++) {
if (A[i] == '#') cout << ans[i] << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int T, N, a[MAX];
int main(int argc, char** argv) {
scanf("%d", &T);
for (int i = (0); i < (T); i++) {
long long ans = 0;
long long ma = -1;
long long sum = 0;
scanf("%d", &N);
for (int i = (0); i < (N); i++) scanf("%d", a + i);
for (int i = (1); i < (N); i++) {
if (a[i] >= a[i - 1])
ma = max(ma, a[i] + sum);
else {
ans += abs(a[i] - a[i - 1]);
sum += abs(a[i] - a[i - 1]);
}
}
printf("%I64d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[100100];
int st1[3][100100][20], st2[3][100100][20];
int s1[100100], s2[100100];
int ma[1001];
pair<int, int> ans[100100], anss;
template <class T>
int sum(T st, int l, int r) {
int ans = 0, i, tt = r - l + 1;
for (i = 0; i <= 20; i++)
if (tt & (1 << i)) {
ans += st[l][i];
l += (1 << i);
}
return ans;
}
int gett(int l, int r) {
if (l % 2 == 1) {
if (sum(st1[1], l, r) != 0) return -1;
if (sum(st2[0], l, r) != 0) return -1;
return sum(st1[2], l, r) + sum(st2[2], l, r);
} else {
if (sum(st1[0], l, r) != 0) return -1;
if (sum(st2[1], l, r) != 0) return -1;
return sum(st1[2], l, r) + sum(st2[2], l, r);
}
}
int main() {
int i, j, k;
ma['a'] = 0;
ma['b'] = 1;
ma['?'] = 2;
scanf("%d", &n);
scanf("%s", s + 1);
for (i = 1; i <= n; i++) s1[i] = s2[i] = -1;
for (i = 1; i <= n; i += 2) s1[i] = ma[s[i]];
for (i = 2; i <= n; i += 2) s2[i] = ma[s[i]];
for (k = 0; k < 3; k++)
for (i = 1; i <= n; i++) st1[k][i][0] = (s1[i] == k);
for (k = 0; k < 3; k++)
for (i = 1; i <= n; i++) st2[k][i][0] = (s2[i] == k);
for (k = 0; k < 3; k++)
for (j = 1; (1 << j) <= n; j++)
for (i = 1; i <= n - (1 << j) + 1; i++)
st1[k][i][j] = st1[k][i][j - 1] + st1[k][i + (1 << (j - 1))][j - 1];
for (k = 0; k < 3; k++)
for (j = 1; (1 << j) <= n; j++)
for (i = 1; i <= n - (1 << j) + 1; i++)
st2[k][i][j] = st2[k][i][j - 1] + st2[k][i + (1 << (j - 1))][j - 1];
memset(ans, 192, sizeof(ans));
int m, tt;
pair<int, int> now = pair<int, int>(0, 0), t2;
scanf("%d", &m);
for (i = m; i <= n; i++) {
if (now.first < ans[i - m].first ||
(now.first == ans[i - m].first && now.second > ans[i - m].second))
now = ans[i - m];
tt = gett(i - m + 1, i);
if (tt == -1) continue;
t2 = now;
t2.first++;
t2.second += tt;
ans[i] = t2;
if (anss.first < ans[i].first ||
(anss.first == ans[i].first && anss.second > ans[i].second))
anss = ans[i];
}
printf("%d", anss.second);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const int SQRTN = 1003;
const int LOGN = 22;
const double PI = acos(-1);
const int INF = 1e9;
int MOD = 1000000007;
const int FMOD = 998244353;
const double eps = 1e-9;
void solve() {
string s;
cin >> s;
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(s.begin(), s.end());
long long m = s.length();
long long k = m - 1;
string ans;
ans.resize(n);
int cnt = 0;
map<char, long long> mp;
for (int i = 0; i < m; i++) mp[s[i]]++;
while (cnt != n) {
int s1 = 0;
vector<long long> v1;
for (int i = 0; i < n; i++) {
if (arr[i] == -1) continue;
if (arr[i] == 0) {
arr[i] = -1;
v1.push_back(i);
cnt++;
}
}
int sz = v1.size();
while (k >= 0 && mp[s[k]] < sz) {
k--;
}
mp[s[k]] = 0;
for (int i = 0; i < sz; i++) {
ans[v1[i]] = s[k];
k--;
}
for (int i = 0; i < n; i++) {
if (arr[i] == -1) continue;
for (int j = 0; j < sz; j++) {
arr[i] -= abs(i - v1[j]);
}
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int h[1100];
int main() {
int n;
scanf("%d", &n);
memset(h, 0, sizeof(h));
int i;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
h[a[i]]++;
}
int sum = 0;
for (i = 0; i < 1100; i++) {
if (h[i] > sum) sum = h[i];
}
if ((((n % 2 == 0) && sum <= n / 2)) || ((n % 2 == 1) && sum <= (n / 2 + 1)))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ptr = 0;
int len;
char s[1005];
void outspace(int t) {
for (int i = 1; i <= t; i++) cout << " ";
}
void work() {
int l, r, ptr, len;
ptr = 0;
len = strlen(s);
int space = -2;
int stack = 0;
while (ptr != len) {
l = ptr;
r = ptr;
bool anti = false;
while (s[r] != '>') {
if (s[r] == '/') anti = true;
r++;
}
if (!anti) space += 2;
ptr = r + 1;
outspace(space);
for (int i = l; i <= r; i++) cout << s[i];
cout << endl;
if (anti) space -= 2;
}
}
int main() {
cin >> s;
work();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gi() {
long long res = 0, fh = 1;
char ch = getchar();
while ((ch > '9' || ch < '0') && ch != '-') ch = getchar();
if (ch == '-') fh = -1, ch = getchar();
while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0', ch = getchar();
return fh * res;
}
long long gl() {
long long res = 0, fh = 1;
char ch = getchar();
while ((ch > '9' || ch < '0') && ch != '-') ch = getchar();
if (ch == '-') fh = -1, ch = getchar();
while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0', ch = getchar();
return fh * res;
}
long long n;
long long s1, s2, s3, s4;
long long x, y;
signed main() {
n = gi();
s1 = -(1ll << 62);
s2 = (1ll << 62);
s3 = -(1ll << 62);
s4 = (1ll << 62);
while (n--) {
x = gi(), y = gi();
s1 = max(x + y, s1);
s2 = min(x + y, s2);
s3 = max(x - y, s3);
s4 = min(x - y, s4);
}
printf("%lld\n", s1 - s2 + s3 - s4 + 4);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dp[1000005][25];
int p[1000005];
int sum(long long a, long long b) {
long long ans = (a + b);
if (ans > 1000000007) ans %= 1000000007;
return int(ans);
}
int mul(long long a, long long b) {
long long ans = (a * b);
if (ans > 1000000007) ans %= 1000000007;
return int(ans);
}
void sieve() {
for (int i = 0; i < 1000005; i++) p[i] = i;
for (int i = 2; i < 1000005; i++) {
if (p[i] == i) {
for (int j = i + i; j < 1000005; j += i) p[j] = i;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
int n, r, ans = 0, tc;
sieve();
for (int i = 0; i < 1000005; i++) {
dp[i][0] = 1;
for (int j = 1; j < 25; j++) {
if (i == 0)
dp[0][j] = 2;
else
dp[i][j] = sum(dp[i][j - 1], dp[i - 1][j]);
}
}
scanf("%d", &tc);
while (tc--) {
ans = 1;
scanf("%d%d", &r, &n);
while (n != 1) {
int cnt = 0;
int k = p[n];
while (n % k == 0) {
n /= k;
cnt++;
}
ans = mul(ans, dp[r][cnt]);
}
printf("%d\n", ans);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool judge(vector<int> &a, vector<int> &b) {
for (int(i) = 0; (i) < (int)(a.size()); (i)++) {
if (a[i] != b[i]) return false;
}
return true;
}
int main() {
int N, L;
cin >> N >> L;
vector<int> A(N), B(N);
for (int(i) = 0; (i) < (int)(N); (i)++) cin >> A[i];
for (int(i) = 0; (i) < (int)(N); (i)++) cin >> B[i];
for (int(kai) = 0; (kai) < (int)(N + 1); (kai)++) {
vector<int> C(N);
for (int(i) = 0; (i) < (int)(N); (i)++) C[i] = B[(i + kai) % N];
for (int(i) = 0; (i) < (int)(L * 2); (i)++) {
for (int(j) = 0; (j) < (int)(C.size()); (j)++) C[j] = (C[j] + 1) % L;
if (judge(A, C)) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
long long p = (n - 1) / 3;
long long a = 1;
while (p >= a) {
p -= a;
a <<= 2;
}
a = a + p;
long long b = 0;
long long tmp = a;
long long mul = 1;
while (tmp) {
if (tmp % 4 == 1) b += mul * 2;
if (tmp % 4 == 2) b += mul * 3;
if (tmp % 4 == 3) b += mul * 1;
tmp /= 4;
mul *= 4;
}
long long c = a ^ b;
if (n % 3 == 1) cout << a << endl;
if (n % 3 == 2) cout << b << endl;
if (n % 3 == 0) cout << c << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int pl[100010];
int main() {
memset(pl, 0, sizeof(pl));
int l, b, f;
scanf("%d%d%d", &l, &b, &f);
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
int len;
scanf("%d", &len);
int j = 0;
while (j < l) {
if (pl[j]) {
++j;
} else {
int k = j;
while (k < l && pl[k] == 0) {
++k;
}
int num = k - j;
int carl = len;
if (j) carl += b;
if (k < l) carl += f;
if (num >= carl) {
if (j) {
printf("%d\n", j + b);
for (int k = 0; k < len; ++k) {
pl[j + b + k] = i + 1;
}
break;
} else {
printf("%d\n", j);
for (int k = 0; k < len; ++k) {
pl[j + k] = i + 1;
}
break;
}
} else {
j = k;
continue;
}
}
}
if (j >= l) {
printf("-1\n");
continue;
}
} else {
int car;
scanf("%d", &car);
for (int j = 0; j < l; ++j) {
if (pl[j] == car) {
pl[j] = 0;
}
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long oo = (long long)(1e9);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
if (a == b)
cout << 0;
else if (a < b) {
if ((b - a) % 2)
cout << 1;
else
cout << 2;
} else {
if ((b - a) % 2 == 0)
cout << 1;
else
cout << 2;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2005;
long long b[maxN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
long long k;
cin >> k;
if (k <= 2 * 1000 * 1000 - 500) {
cout << 3 << "\n";
if (k % 2 == 1) {
int x = (k + 3) / 2;
cout << x << " " << -(x + 1) << " " << x;
return 0;
} else {
int x = (k + 6) / 2;
cout << (x - 1) << " " << -(x + 1) << " " << x;
return 0;
}
}
long long opt = 5 * (int)1e5 + 10000;
for (long long val = opt; val > 0; val--) {
for (int p = 1; p <= 1000; p++) {
long long t = (2 * p - 1) * (val - (p - 1));
if (t - k >= val) {
if (t - k > (int)1e6) break;
for (int i = 1; i <= p; i++) {
b[2 * i - 1] = val;
b[2 * i] = -(val + 1);
}
b[2 * p + 1] = -(int)1e6;
b[2 * p + 2] = t - k;
assert((t - k) <= 1000 * 1000);
int n = 2 * p + 2;
long long best = 0;
int opt1 = -1;
int opt2 = -1;
for (int j = 1; j <= n; j++) {
long long sm = 0;
for (int u = j; u <= n; u++) {
sm += b[u];
best = max(best, (u - j + 1) * sm);
if (best == (u - j + 1) * sm) {
opt1 = j;
opt2 = u;
}
}
}
cout << n << '\n';
for (int i = 1; i <= n; i++) cout << b[i] << " ";
return 0;
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int minn(int x1, int x2) { return x1 < x2 ? x1 : x2; }
int maxx(int x1, int x2) { return x1 > x2 ? x1 : x2; }
int abs(int x) {
if (x >= 0)
return x;
else
return -x;
}
int main() {
int n, m, x, y, t;
scanf("%d%d%d%d", &n, &x, &m, &y);
if (n > m) {
t = n;
n = m;
m = t;
}
if (y < x) {
t = x;
x = y;
y = t;
}
int x1 = m - abs(x - y);
if (x1 < 0) x1 = 0;
int x2 = n - abs(x - y);
if (x2 < 0) x2 = 0;
long long ans = 1;
int i, d = y - x;
for (i = 1; i <= m; i++) {
if ((y - i) > (x + n)) {
ans++;
continue;
}
if ((y - i) < (x - n)) {
ans++;
continue;
}
if (i <= d) {
long long g = minn(n - (d - i), 2 * i - 1);
if (g > 0)
ans += 2 * g;
else
ans++;
} else {
long long g = minn(minn(minn(i + d - 1, n) - (i - d - 1), 2 * i - 1), n);
if (g > 0)
ans += 2 * g;
else
ans++;
}
}
if (x - n < y - m) ans += maxx(minn(y - m - x + n, n), 0);
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(20);
int n;
cin >> n;
n = pow(2, n);
int q;
cin >> q;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
cout << sum / (n * 1.0) << '\n';
for (int i = 0; i < q; i++) {
int j = 0;
cin >> j;
long double a1;
cin >> a1;
sum += a1;
sum -= a[j];
a[j] = a1;
cout << sum / (n * 1.0) << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long int n, i;
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
if (n % 4 == 2 || n % 4 == 3) {
cout << -1;
return 0;
}
long long int a[n];
if (n % 2 == 0) {
for (i = 1; i <= n / 2; i += 2) {
a[i - 1] = i + 1;
}
for (i = 2; i <= n / 2; i += 2) {
a[i - 1] = n - i + 2;
}
for (i = n; i > n / 2; i -= 2) {
a[i - 1] = i - 1;
}
for (i = n - 1; i > n / 2; i -= 2) {
a[i - 1] = n - i;
}
} else {
for (i = 1; i <= n / 2; i += 2) {
a[i - 1] = i + 1;
}
for (i = 2; i <= n / 2 + 1; i += 2) {
a[i - 1] = n - i + 2;
}
for (i = n; i > n / 2 + 1; i -= 2) {
a[i - 1] = i - 1;
}
for (i = n - 1; i > n / 2 + 1; i -= 2) {
a[i - 1] = n - i;
}
a[(n - 1) / 2] = n / 2 + 1;
}
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 9;
const int MOD = 1e9 + 7;
int R, n, m;
pair<int, int> head[205], tail[205];
int dis[205][205];
int dp[205][205];
int mark[205][205];
bool cycle;
queue<pair<int, int> > q;
int dfs(pair<int, int> v) {
int vh = v.first;
int vt = v.second;
if (vh + vt > R) return 0;
if (mark[vh][vt] == 1) {
cycle = true;
return 0;
}
if (mark[vh][vt] == 2) return dp[vh][vt];
mark[vh][vt] = 1;
for (int i = 1; i <= min(n, vh); i++) {
int ph, pt;
ph = vh - i + head[i].first;
pt = vt + head[i].second;
dp[vh][vt] = max(dp[vh][vt], dfs({ph, pt}) + 1);
}
for (int i = 1; i <= min(m, vt); i++) {
int ph, pt;
ph = vh + tail[i].first;
pt = vt - i + tail[i].second;
dp[vh][vt] = max(dp[vh][vt], dfs({ph, pt}) + 1);
}
mark[vh][vt] = 2;
return dp[vh][vt];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(dis, -1, sizeof(dis));
int h, t;
cin >> h >> t >> R;
cin >> n;
for (int i = 1; i <= n; i++) cin >> head[i].first >> head[i].second;
cin >> m;
for (int i = 1; i <= m; i++) cin >> tail[i].first >> tail[i].second;
q.push({h, t});
dis[h][t] = 0;
while (!q.empty()) {
int ch = q.front().first, ct = q.front().second;
q.pop();
int cd = dis[ch][ct];
for (int i = 1; i <= min(n, ch); i++) {
int ph, pt;
ph = ch - i + head[i].first;
pt = ct + head[i].second;
if (ph + pt <= R && dis[ph][pt] == -1) {
dis[ph][pt] = cd + 1;
q.push({ph, pt});
}
}
for (int i = 1; i <= min(m, ct); i++) {
int ph, pt;
ph = ch + tail[i].first;
pt = ct - i + tail[i].second;
if (ph + pt <= R && dis[ph][pt] == -1) {
dis[ph][pt] = cd + 1;
q.push({ph, pt});
}
}
}
if (dis[0][0] != -1) return cout << "Ivan\n" << dis[0][0] << "\n", 0;
dfs({h, t});
if (cycle) return cout << "Draw\n", 0;
cout << "Zmey\n" << dp[h][t] << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int vis[105], P[105];
int main() {
int i, j, k, l, t, r, s, m, n, a, b, c, d, e, f, g, h, u, v;
memset(vis, 0, sizeof(vis));
memset(P, -1, sizeof(P));
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d %d", &a, &b, &c);
vis[a] -= c;
vis[b] += c;
P[b] = a;
}
s = 0;
for (i = 1; i <= n; i++) {
if (P[i] != -1 && vis[i] > 0) s += vis[i];
}
printf("%d\n", s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int maxn = 1e3 + 10;
const int maxv = 1e3 + 10;
const double eps = 1e-9;
int len;
int a[maxn];
int res[maxn];
map<int, int> mp;
map<pair<int, int>, int> vis;
int cnt;
void dfs(int l, int r) {
vis[pair<int, int>(l, r)] = 1;
if (mp[l + r] > 0) {
mp[l + r]--;
cnt++;
dfs(r, l + r);
mp[l + r]++;
}
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
mp.clear();
vis.clear();
for (int i = 1; i <= n; i++) {
int tmp;
scanf("%d", &a[i]);
mp[a[i]]++;
}
sort(a + 1, a + 1 + n);
int ans = 2;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (vis.count(pair<int, int>(a[i], a[j]))) continue;
cnt = 2;
mp[a[i]]--;
mp[a[j]]--;
dfs(a[i], a[j]);
mp[a[i]]++;
mp[a[j]]++;
ans = max(ans, cnt);
}
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vlli = vector<long long int>;
using vpii = vector<pair<int, int>>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q, m, ans, other, dp[30][1510];
string s;
char fav;
cin >> n >> s >> q;
memset(dp, 0, sizeof dp);
for (int i = 0; i < q; i++) {
cin >> m >> fav;
if (dp[fav - 'a'][m])
cout << dp[fav - 'a'][m] << '\n';
else {
int l = 0, r = 0;
other = ans = 0;
if (s[l] != fav) other++;
while (l < n) {
if (other <= m) {
ans = max(ans, r - l + 1);
if (r + 1 < n) {
r++;
if (s[r] != fav) other++;
} else {
if (s[l] != fav) other--;
l++;
}
} else {
if (s[l] != fav) other--;
l++;
}
}
dp[fav - 'a'][m] = ans;
cout << ans << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m1, m2;
map<long long int, long long int>::iterator itr, itr1, itr2;
long long int freq[200] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string str;
cin >> str;
for (long long int i = 0; i < str.size(); i++) freq[str[i]]++;
long long int ans = 0;
for (long long int i = 0; i < 200; i++) {
if (freq[i] > 1) {
ans += freq[i] * (freq[i] - 1);
}
}
ans += str.size();
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main() {
cin >> a >> b;
int maxval = 0;
;
for (int i = 0; i < (int)a.length(); i++) {
maxval = max(maxval, a[i] - '0');
}
for (int i = 0; i < (int)b.length(); i++) {
maxval = max(maxval, b[i] - '0');
}
int cnt = 0;
maxval++;
int j = b.length() - 1, A, B;
int i = a.length() - 1;
int next = 0;
while (i >= 0 || j >= 0) {
if (i < 0) {
A = 0;
} else {
A = a[i] - '0';
}
if (j < 0) {
B = 0;
} else {
B = b[j] - '0';
}
cnt++;
if ((A + B + next) >= maxval) {
next = 1;
} else {
next = 0;
}
i--;
j--;
}
if (next == 1) {
cnt++;
}
cout << cnt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void Tsukuyomi_() {
int n;
cin >> n;
vector<int> a(n);
for (auto &x : a) cin >> x;
vector<int> pos(1001, -1);
for (int i = 0; i < n; i++) {
pos[a[i]] = i;
}
vector<int> ans;
for (int i = 0; i < n; i++) {
if (pos[a[i]] == i) ans.push_back(a[i]);
}
cout << ans.size() << '\n';
for (auto x : ans) cout << x << " ";
cout << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int tt = 1;
while (tt--) Tsukuyomi_();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, num[101][3];
char name[101][25];
int find(char a[]) {
int t, p, g;
t = p = g = 0;
if (a[0] == a[1] && a[1] == a[3] && a[3] == a[4] && a[4] == a[6] &&
a[6] == a[7])
return 0;
if (a[0] > a[1] && a[1] > a[3] && a[3] > a[4] && a[4] > a[6] && a[6] > a[7])
return 1;
return 2;
}
int main() {
int i, s, maxt, maxp, maxg, f;
char t[10];
while (~scanf("%d", &n)) {
memset(num, 0, sizeof(num));
for (i = 0; i < n; i++) {
scanf("%d %s", &s, &name[i]);
while (s--) {
scanf("%s", &t);
int k = find(t);
num[i][k]++;
}
}
maxt = maxp = maxg = 0;
for (i = 0; i < n; i++) {
if (num[i][0] > maxt) maxt = num[i][0];
if (num[i][1] > maxp) maxp = num[i][1];
if (num[i][2] > maxg) maxg = num[i][2];
}
printf("If you want to call a taxi, you should call: ");
f = 0;
for (i = 0; i < n; i++) {
if (num[i][0] == maxt) {
if (f)
printf(", ");
else
f = 1;
printf("%s", name[i]);
}
}
puts(".");
printf("If you want to order a pizza, you should call: ");
f = 0;
for (i = 0; i < n; i++) {
if (num[i][1] == maxp) {
if (f)
printf(", ");
else
f = 1;
printf("%s", name[i]);
}
}
puts(".");
printf(
"If you want to go to a cafe with a wonderful girl, you should call: ");
f = 0;
for (i = 0; i < n; i++) {
if (num[i][2] == maxg) {
if (f)
printf(", ");
else
f = 1;
printf("%s", name[i]);
}
}
puts(".");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int glob = 1;
int main() {
int t, i, j, temp;
string a[30], test("a"), test2, sum, temp2;
sum.clear();
char ch[10];
cin >> t;
for (i = 0; i < t; i++) {
cin >> a[i];
sum.append(" ");
sum.append(a[i]);
}
while (1) {
if (sum.find(test) != std::string::npos) {
glob++;
temp = glob;
test2.clear();
for (i = 0; temp != 0; i++) {
if (temp % 27 == 0) {
temp++;
continue;
}
ch[0] = 'a' + temp % 27 - 1;
ch[1] = '\0';
temp2.clear();
temp2.assign(ch);
test2.append(string(temp2));
temp = temp / 27;
}
i = 0;
test.clear();
for (std::string::reverse_iterator rit = test2.rbegin();
rit != test2.rend(); ++rit) {
ch[0] = *rit;
ch[1] = '\0';
temp2.clear();
temp2.assign(ch);
test.append(string(temp2));
}
} else
break;
}
cout << test;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int n, x = 1, y = 1, count = 1, count1 = 1;
cin >> n;
string s1, s2;
bool flag = true;
vector<pair<char, int>> p, q;
for (int i = 0; i < n; i++) {
flag = true;
count = 1;
cin >> s1 >> s2;
for (int j = 1; j < s1.length(); j++) {
if (s1[j] == s1[j - 1]) {
count++;
} else {
p.push_back(make_pair(s1[j - 1], count));
count = 1;
}
}
p.push_back(make_pair(s1[s1.length() - 1], count));
count = 1;
for (int j = 1; j < s2.length(); j++) {
if (s2[j] == s2[j - 1]) {
count++;
} else {
q.push_back(make_pair(s2[j - 1], count));
count = 1;
}
}
q.push_back(make_pair(s2[s2.length() - 1], count));
if (p.size() != q.size())
cout << "NO" << endl;
else {
for (int j = 0; j < p.size(); j++) {
if (p[j].first != q[j].first || p[j].second > q[j].second) {
flag = false;
break;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
p.clear();
q.clear();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int r, g, b;
cin >> r >> g >> b;
long long int a1[r];
long long int a2[g];
long long int a3[b];
for (int i = 0; i < r; i++) {
cin >> a1[i];
}
for (int i = 0; i < g; i++) {
cin >> a2[i];
}
for (int i = 0; i < b; i++) {
cin >> a3[i];
}
sort(a1, a1 + r, greater<int>());
sort(a2, a2 + g, greater<int>());
sort(a3, a3 + b, greater<int>());
long long int dp[r + 1][g + 1][b + 1];
long long int ans = 0;
for (int i = 0; i < r + 1; i++) {
for (int j = 0; j < g + 1; j++) {
for (int k = 0; k < b + 1; k++) {
dp[i][j][k] = 0;
}
}
}
for (int i = 0; i < r + 1; i++) {
for (int j = 0; j < g + 1; j++) {
for (int k = 0; k < b + 1; k++) {
if (i < r and j < g) {
dp[i + 1][j + 1][k] =
max(dp[i + 1][j + 1][k], dp[i][j][k] + a1[i] * a2[j]);
}
if (i < r and k < b) {
dp[i + 1][j][k + 1] =
max(dp[i + 1][j][k + 1], dp[i][j][k] + a1[i] * a3[k]);
}
if (k < b and j < g) {
dp[i][j + 1][k + 1] =
max(dp[i][j + 1][k + 1], dp[i][j][k] + a3[k] * a2[j]);
}
ans = max(ans, dp[i][j][k]);
}
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e3 + 1;
long long n, m, mx, val, cnt;
long long mark[N], d[N], col[N];
vector<long long> g[N], graph[N];
void DFS(long long v) {
mark[v] = 1;
for (long long u : g[v]) {
if (!mark[u]) {
col[u] = 1 - col[v];
DFS(u);
} else if (col[v] == col[u])
val = 0;
}
graph[cnt].push_back(v);
}
void BFS(long long source) {
memset(d, 63, sizeof d);
queue<long long> q;
q.push(source);
d[source] = 0;
while (q.size()) {
long long v = q.front();
q.pop();
for (long long u : g[v]) {
if (d[v] + 1 < d[u]) {
d[u] = d[v] + 1;
mx = max(mx, d[u]);
q.push(u);
}
}
}
}
long long Diameter() {
mx = 0;
for (long long u : graph[cnt]) BFS(u);
return mx;
}
int main() {
long long u, v, ans = 0;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (long long i = 1; i <= n; i++) {
if (!mark[i]) {
val = 1;
DFS(i);
ans += Diameter();
cnt++;
if (!val) return cout << -1, 0;
}
}
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
cout << min(min(b / 2, c / 4), a) + 2 * min(min(b / 2, c / 4), a) +
4 * min(min(b / 2, c / 4), a)
<< endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
vector<long long> ans;
long long cnt = 0;
long long st = 0;
long long en = n - 1;
for (long long i = n - 1; i >= 0; i--) {
char lst = s1[en];
if (cnt % 2) lst = '0' + '1' - lst;
if (lst == s2[i]) {
if (cnt % 2)
en++;
else
en--;
continue;
}
char fst = s1[st];
if (cnt % 2) fst = '0' + '1' - fst;
if (fst == s2[i]) ans.push_back(1);
ans.push_back(i + 1);
cnt++;
swap(st, en);
if (cnt % 2)
en++;
else
en--;
}
cout << ans.size() << ' ';
for (__typeof(ans.size()) i = (0) - ((0) > (ans.size()));
i != (ans.size()) - ((0) > (ans.size()));
i += 1 - 2 * ((0) > (ans.size())))
cout << ans[i] << ((i == (ans.size() - 1)) ? '\n' : ' ');
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int n, m, sx, sy, ex, ey;
char a[4][1005][1005];
int vs[4][1005][1005];
int D[4][1005][1005];
int t, fl;
queue<pair<int, pair<int, int>>> q;
string su = "+LRU|v";
string sd = "+LRD|^";
string sl = "+ULD->";
string sr = "+RUD-<";
void add(int i, int j, int k, int ii, int jj, int kk) {
if (vs[kk][ii][jj]) return;
vs[kk][ii][jj] = 1;
D[kk][ii][jj] = D[k][i][j] + 1;
q.push({kk, {ii, jj}});
if (ii == ex and jj == ey) fl = 1;
}
void u(int i, int j, int k) {
int ii = max(0, i - 1);
int jj = j;
int kk = k;
for (int x = 0; x < (int)(su.size()); x++) {
if (su[x] == a[kk][ii][jj]) {
add(i, j, k, ii, jj, kk);
return;
}
}
}
void d(int i, int j, int k) {
int ii = min(n - 1, i + 1);
int jj = j;
int kk = k;
for (int x = 0; x < (int)(sd.size()); x++) {
if (sd[x] == a[kk][ii][jj]) {
add(i, j, k, ii, jj, kk);
return;
}
}
}
void l(int i, int j, int k) {
int ii = i;
int jj = max(0, j - 1);
int kk = k;
for (int x = 0; x < (int)(sl.size()); x++) {
if (sl[x] == a[kk][ii][jj]) {
add(i, j, k, ii, jj, kk);
return;
}
}
}
void r(int i, int j, int k) {
int ii = i;
int jj = min(m - 1, j + 1);
int kk = k;
for (int x = 0; x < (int)(sr.size()); x++) {
if (sr[x] == a[kk][ii][jj]) {
add(i, j, k, ii, jj, kk);
return;
}
}
}
void g(int i, int j, int k) {
int ii = i;
int jj = j;
int kk = (k + 1) % 4;
add(i, j, k, ii, jj, kk);
}
int bfs(int x, int y, int z) {
vs[z][x][y] = 1;
if (x == ex and y == ey) {
return 0;
}
q.push({z, {x, y}});
while (!q.empty()) {
pair<int, pair<int, int>> U = q.front();
q.pop();
int i = U.second.first, j = U.second.second, k = U.first;
if (a[k][i][j] == '+') {
u(i, j, k);
d(i, j, k);
l(i, j, k);
r(i, j, k);
} else if (a[k][i][j] == '^') {
u(i, j, k);
} else if (a[k][i][j] == '>') {
r(i, j, k);
} else if (a[k][i][j] == 'v') {
d(i, j, k);
} else if (a[k][i][j] == '<') {
l(i, j, k);
} else if (a[k][i][j] == '-') {
l(i, j, k);
r(i, j, k);
} else if (a[k][i][j] == '|') {
u(i, j, k);
d(i, j, k);
} else if (a[k][i][j] == 'L') {
u(i, j, k);
d(i, j, k);
r(i, j, k);
} else if (a[k][i][j] == 'U') {
d(i, j, k);
l(i, j, k);
r(i, j, k);
} else if (a[k][i][j] == 'R') {
u(i, j, k);
d(i, j, k);
l(i, j, k);
} else if (a[k][i][j] == 'D') {
u(i, j, k);
l(i, j, k);
r(i, j, k);
}
if (a[k][i][j] != '*') {
g(i, j, k);
}
if (fl) {
return D[k][i][j] + 1;
}
}
return -1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[0][i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[0][i][j] == '+')
a[1][i][j] = '+', a[2][i][j] = '+', a[3][i][j] = '+';
else if (a[0][i][j] == '-')
a[1][i][j] = '|', a[2][i][j] = '-', a[3][i][j] = '|';
else if (a[0][i][j] == '|')
a[1][i][j] = '-', a[2][i][j] = '|', a[3][i][j] = '-';
else if (a[0][i][j] == '^')
a[1][i][j] = '>', a[2][i][j] = 'v', a[3][i][j] = '<';
else if (a[0][i][j] == '>')
a[1][i][j] = 'v', a[2][i][j] = '<', a[3][i][j] = '^';
else if (a[0][i][j] == 'v')
a[1][i][j] = '<', a[2][i][j] = '^', a[3][i][j] = '>';
else if (a[0][i][j] == '<')
a[1][i][j] = '^', a[2][i][j] = '>', a[3][i][j] = 'v';
else if (a[0][i][j] == 'L')
a[1][i][j] = 'U', a[2][i][j] = 'R', a[3][i][j] = 'D';
else if (a[0][i][j] == 'U')
a[1][i][j] = 'R', a[2][i][j] = 'D', a[3][i][j] = 'L';
else if (a[0][i][j] == 'R')
a[1][i][j] = 'D', a[2][i][j] = 'L', a[3][i][j] = 'U';
else if (a[0][i][j] == 'D')
a[1][i][j] = 'L', a[2][i][j] = 'U', a[3][i][j] = 'R';
else if (a[0][i][j] == '*')
a[1][i][j] = '*', a[2][i][j] = '*', a[3][i][j] = '*';
}
}
cin >> sx >> sy >> ex >> ey;
sx--, sy--, ex--, ey--;
int ans = bfs(sx, sy, 0);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class Q>
Q _sqr(Q x) {
return x * x;
}
template <class Q>
void gi(Q &x) {
char ch = getchar();
x = 0;
int s = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') s = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();
if (s == -1) x = -x;
}
template <class Q>
void pi(Q x) {
if (x < 0) {
putchar('-');
pi(-x);
} else {
if (x > 9) pi(x / 10);
putchar(x % 10 + 48);
}
}
const int sz = 400200;
const int huge = 1000000000;
const long long int hugell = 1ll << 61;
const double hugelf = 1e50;
const double eps = 1e-10;
const int ljz = 1000000007;
void MOD(int &x) {
if (x >= ljz) x -= ljz;
if (x < 0) x += ljz;
}
int Tm(int a, int b) {
long long int x = a, y = b;
return (x * y) % ljz;
}
int fpm(int x, int y) {
int p = 1, s = x;
for (; y; y >>= 1) {
if (y & 1) p = Tm(p, s);
s = Tm(s, s);
}
return p;
}
int Tm(int a, int b, int c) { return Tm(Tm(a, b), c); }
int Tm(int a, int b, int c, int d) { return Tm(Tm(a, b, c), d); }
int Tm(int a, int b, int c, int d, int e) { return Tm(Tm(a, b, c, d), e); }
int Tm(int a, int b, int c, int d, int e, int f) {
return Tm(Tm(a, b, c, d, e), f);
}
int node[sz], nxt[sz], to[sz], e;
void ins(int x, int y) {
e++;
nxt[e] = node[x];
node[x] = e;
to[e] = y;
}
int n, a, b;
int deg[sz];
int q[sz], dep[sz], par[sz], ooo[sz];
void bfs(int x) {
int i, j, k, l, r;
for (i = 1; i <= n; i++) dep[i] = par[i] = 0;
q[l = r = 1] = x;
while (l <= r)
for (j = node[k = q[l++]]; j; j = nxt[j])
if (to[j] != par[k]) {
par[q[++r] = to[j]] = k;
dep[to[j]] = dep[k] + 1;
if (k == x)
ooo[to[j]] = to[j];
else
ooo[to[j]] = ooo[k];
}
}
int d1, d2, indiam[sz], dd[sz], _par[sz];
int get() {
int i, j;
bfs(1);
for (i = j = 1; i <= n; i++)
if (dep[i] > dep[j]) j = i;
bfs(j);
d1 = j;
for (i = 1, d2 = 0; i <= n; i++)
if (dep[i] > dep[d2]) d2 = i;
return dep[d2];
}
int bel[sz];
void _try(int d) {
int i, x, a1 = 0, a2 = 0;
for (x = d2, i = d; i; i--) x = _par[x];
for (i = 1; i <= n; i++) bel[i] = 0;
bfs(x);
for (i = 1; i <= n; i++)
if (deg[i] == 1) {
if (bel[ooo[i]] == 0)
bel[ooo[i]] = dep[i];
else if (bel[ooo[i]] != dep[i])
return;
}
for (i = 1; i <= n; i++)
if (bel[i] != 0) {
if (a1 == 0)
a1 = bel[i];
else if (bel[i] != a1) {
if (a2 == 0)
a2 = bel[i];
else if (bel[i] != a2)
return;
}
}
int ans = a1 + a2;
while (~ans & 1) ans >>= 1;
printf("%d", ans);
exit(0);
}
void fail() {
printf("-1");
exit(0);
}
int main() {
int l = 0, i;
gi(n);
if (n == 2) return printf("1"), 0;
for (i = 1; i < n; i++) {
gi(a);
gi(b);
ins(a, b);
ins(b, a);
deg[a]++;
deg[b]++;
}
int ans = get();
for (i = 1; i <= n; i++) _par[i] = par[i];
_try(ans >> 1);
_try((ans >> 1) - 1);
_try((ans >> 1) + 1);
printf("-1");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 3e5 + 5;
const int MS = 3e6 + 5;
const int INF = 0x3f3f3f3f;
const double eps = 1e-10;
struct Slope {
double k, b;
Slope() {}
Slope(double _k, double _b) {
k = _k;
b = _b;
}
bool operator==(const Slope &P) const {
if (fabs(k - P.k) < eps && fabs(b - P.b) < eps) return 1;
return 0;
}
bool operator<(const Slope &P) const {
if (fabs(k - P.k) < eps) return b < P.b;
return k < P.k;
}
};
struct Data {
Slope k;
double x, y;
Data() {}
Data(double _x, double _y, Slope _k) {
x = _x;
y = _y;
k = _k;
}
bool operator<(const Data &P) const {
if (k == P.k) {
if (fabs(x - P.x) < eps) return y < P.y;
return x < P.x;
}
return k < P.k;
}
} A[MS];
struct Line {
double x1, y1;
double x2, y2;
} L[MX];
double x[2000], y[2000], r[2000];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lf%lf%lf%lf", &L[i].x1, &L[i].y1, &L[i].x2, &L[i].y2);
}
int sz = 0;
for (int i = 1; i <= m; i++) {
scanf("%lf%lf%lf", &x[i], &y[i], &r[i]);
for (int j = 1; j < i; j++) {
if (r[i] == r[j] &&
(x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]) >
(r[i] + r[j]) * (r[i] + r[j])) {
Slope s;
if (y[i] == y[j])
s.k = 1e9, s.b = (x[i] + x[j]) / 2;
else
s.k = (x[i] - x[j]) / (y[j] - y[i]),
s.b = (y[i] + y[j]) / 2 - s.k * (x[i] + x[j]) / 2;
A[++sz] = Data((x[i] + x[j]) / 2, (y[i] + y[j]) / 2, s);
}
}
}
sort(A + 1, A + 1 + sz);
long long ans = 0;
for (int i = 1; i <= n; i++) {
double x1 = L[i].x1, y1 = L[i].y1;
double x2 = L[i].x2, y2 = L[i].y2;
Slope s;
if (x1 == x2)
s.k = 1e9, s.b = x1;
else
s.k = (y1 - y2) / (x1 - x2), s.b = y1 - s.k * x1;
Data t1(x1, y1, s), t2(x2, y2, s);
if (x1 > x2 || (x1 == x2 && y1 > y2)) swap(t1, t2);
ans +=
upper_bound(A + 1, A + 1 + sz, t2) - lower_bound(A + 1, A + 1 + sz, t1);
}
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long res = 0, f = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
res = (res << 3) + (res << 1) + (ch - '0');
return res * f;
}
const long long MAXN = 1e5 + 5, inf = 1e18;
long long n, h[MAXN], a[MAXN], ans, m, k, p;
long long alf[MAXN];
inline bool check(long long maxx) {
priority_queue<pair<long long, long long> > q;
for (long long i = 1; i <= n; ++i) {
alf[i] = maxx;
if (alf[i] - a[i] * m < h[i]) q.push(make_pair(-(alf[i] / a[i]), i));
}
for (long long dat = 1; dat <= m; ++dat) {
for (long long i = 1; i <= k; ++i) {
if (q.empty()) return 1;
long long di = -q.top().first, id = q.top().second;
q.pop();
if (di < dat) return 0;
alf[id] += p;
if (alf[id] - a[id] * m < h[id])
q.push(make_pair(-(alf[id] / a[id]), id));
}
}
return q.empty();
}
signed main() {
n = read(), m = read(), k = read(), p = read();
for (long long i = 1; i <= n; ++i) h[i] = read(), a[i] = read();
long long l = 0, r = inf;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
string ans, s;
int len, L;
inline void check(int y, int m, int d) {
string res = "";
for (int i = 1; i <= 4; ++i) {
res += char(y % 10 + '0');
y /= 10;
}
res += '-';
for (int i = 1; i <= 2; ++i) {
res += char(m % 10 + '0');
m /= 10;
}
res += '-';
for (int i = 1; i <= 2; ++i) {
res += char(d % 10 + '0');
d /= 10;
}
reverse(res.begin(), res.end());
if (s.find(res) == string::npos) return;
int book = 0;
for (int i = 0; i < L; ++i) {
if (s.substr(i, 10) == res) {
book++;
if (book > len) {
len = book;
ans = res;
}
}
}
}
int main() {
cin >> s;
L = s.size();
for (int y = 2013; y <= 2015; ++y) {
for (int m = 1; m <= 12; ++m) {
for (int d = 1; d <= mon[m]; ++d) {
check(y, m, d);
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int output[maxn];
int main(void) {
int h;
cin >> h;
bool flag = true;
int p, f;
int last;
scanf("%d", &last);
int tot = 1;
output[tot++] = 0;
for (int i = 1; i <= h; i++) {
int cur;
scanf("%d", &cur);
if (last == 1 || cur == 1 || !flag) {
int tmp = tot - 1;
for (int k = 1; k <= cur; k++) output[tot++] = tmp;
} else {
flag = false;
int tmp1 = tot - 1, tmp2 = tot - 2;
for (int k = 1; k <= cur; k++) output[tot++] = tmp1;
p = tot - 1;
f = tmp2;
}
last = cur;
}
if (flag)
printf("perfect\n");
else {
printf("ambiguous\n");
for (int i = 1; i < tot; i++) {
if (i != 1) printf(" ");
printf("%d", output[i]);
}
printf("\n");
output[p] = f;
for (int i = 1; i < tot; i++) {
if (i != 1) printf(" ");
printf("%d", output[i]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, count_1 = 0, count_2 = 0;
int a[1000], b[1000];
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
count_1 += a[i];
}
for (i = 0; i < n; i++) {
cin >> b[i];
count_2 += b[i];
}
if (count_1 >= count_2) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
set<string> vis;
int rRight[6] = {4, 1, 2, 5, 3, 0};
int rDown[6] = {1, 3, 0, 2, 4, 5};
string rotateRight(string x) {
string res = "";
for (int i = 0; i < 6; i++) {
res += x[rRight[i]];
}
return res;
}
string rotateDown(string x) {
string res = "";
for (int i = 0; i < 6; i++) {
res += x[rDown[i]];
}
return res;
}
void dfs(string x) {
if (vis.count(x)) return;
vis.insert(x);
dfs(rotateRight(x));
dfs(rotateDown(x));
}
int main() {
string s;
cin >> s;
sort(s.begin(), s.end());
int ans = 0;
do {
if (vis.count(s)) continue;
ans++;
dfs(s);
} while (next_permutation(s.begin(), s.end()));
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int a[maxn];
int sz[maxn];
struct edg {
int x, y;
} edg[maxn];
int main() {
int i, j, n, k;
cin >> n >> k;
for (i = 1; i <= k; i++) a[i] = 1;
for (i = 2, j = 1; i <= n; i++) {
edg[i].x = a[j], edg[i].y = i;
a[j] = i;
sz[j]++;
j++;
if (j > k) j = 1;
}
sort(sz + 1, sz + k + 1);
printf("%d\n", sz[k - 1] + sz[k]);
for (i = 2; i <= n; i++) printf("%d %d\n", edg[i].x, edg[i].y);
}
| 5 |
#include <bits/stdc++.h>
int w[105], t[105], n;
int mem[105][205][205];
int min(int a, int b) {
if (a > b)
return b;
else
return a;
}
int dfs(int pos, int thi, int whi) {
if (pos == n) return thi;
if (mem[pos][thi][whi] != -1) return mem[pos][thi][whi];
if (thi - t[pos] >= whi + w[pos])
return mem[pos][thi][whi] = min(dfs(pos + 1, thi - t[pos], whi + w[pos]),
dfs(pos + 1, thi, whi));
return mem[pos][thi][whi] = dfs(pos + 1, thi, whi);
}
int main() {
int i, sum;
while (scanf("%d", &n) != EOF) {
memset(mem, -1, sizeof(mem));
sum = 0;
for (i = 0; i < n; i++) {
scanf("%d%d", &t[i], &w[i]);
sum = sum + t[i];
}
printf("%d\n", dfs(0, sum, 0));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void _dbg(string) { cout << endl; }
template <class H, class... T>
void _dbg(string s, H h, T... t) {
int l = s.find(',');
cout << s.substr(0, l) << " = " << h << ", ";
_dbg(s.substr(l + 1), t...);
}
template <class T, class U>
ostream& operator<<(ostream& o, const pair<T, U>& p) {
o << "(" << p.first << "," << p.second << ")";
return o;
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "[";
for (T t : v) {
o << t << ",";
}
o << "]";
return o;
}
bool solve() {
int n, m;
cin >> n >> m;
vector<int> vec(m);
for (int i = (int)(0); i < (int)(m); i++) cin >> vec[i], vec[i]--;
vector<int> ans(n, -1);
vector<bool> used(n + 1, false);
for (int i = (int)(0); i < (int)(m - 1); i++) {
int x = (vec[i + 1] - vec[i] + n) % n;
if (ans[vec[i]] != -1) {
if (ans[vec[i]] == x)
continue;
else
return false;
}
if (used[x]) return false;
used[x] = true;
ans[vec[i]] = x;
}
int p = 0;
for (int i = (int)(0); i < (int)(n); i++)
if (ans[i] == -1) {
while (p < n && used[p]) p++;
if (p == n) return false;
ans[i] = p;
p++;
}
for (int i = (int)(0); i < (int)(n); i++)
if (ans[i] == 0) ans[i] = n;
for (int i = (int)(0); i < (int)(n); i++)
printf("%d%c", ans[i], " \n"[i == n - 1]);
return true;
}
int main() {
if (!solve()) cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long pp(register long long g) {
if (g < 0)
return g = g * (-1);
else
return g;
}
inline long long read() {
register long long x = 0;
register long long f = 1;
char register ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = (x * 10) + (ch - '0');
return (x * f);
}
int main() {
register long long n, a, p;
cin >> n >> a;
for (register int i = 1; i <= n; i++) {
p = read();
v.push_back(p);
}
sort(v.begin(), v.end());
register long long ans = 1000000000;
if (n == 1) {
cout << "0" << endl;
return 0;
}
if (n == 2) {
ans = min(pp(a - v[0]), pp(a - v[1]));
cout << ans << endl;
return 0;
}
if (v[n - 2] <= a && v[n - 1] >= a) {
ans = min(ans, pp(v[0] - a));
ans = min(ans, 2 * pp(v[1] - a) + pp(v[n - 1] - a));
ans = min(ans, pp(v[1] - a) + 2 * pp(v[n - 1] - a));
cout << ans << endl;
return 0;
}
if (v[n - 1] < a) {
ans = min(ans, pp(v[1] - a));
cout << ans << endl;
return 0;
}
if (v[1] >= a && v[0] <= a) {
ans = min(ans, pp(v[n - 1] - a));
ans = min(ans, 2 * pp(v[n - 2] - a) + pp(v[0] - a));
ans = min(ans, pp(v[n - 2] - a) + 2 * pp(v[0] - a));
cout << ans << endl;
return 0;
}
if (v[0] > a) {
ans = min(ans, pp(v[n - 2] - a));
cout << ans << endl;
return 0;
}
ans = min(ans, 2 * pp(a - v[0]) + pp(a - v[n - 2]));
ans = min(ans, pp(a - v[0]) + 2 * pp(a - v[n - 2]));
ans = min(ans, 2 * pp(a - v[n - 1]) + pp(a - v[1]));
ans = min(ans, pp(a - v[n - 1]) + 2 * pp(a - v[1]));
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, x, a, b, dist = 0;
cin >> t;
for (int i = 1; i <= t; i++) {
cin >> n >> x >> a >> b;
if (a > b) swap(a, b);
if (x >= a - 1 + n - b)
dist = n - 1;
else
dist = b - a + x;
cout << dist << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
const long long base = 1e9 + 7;
int n, k;
long long f[N][N], fSum[N][N];
char s[N + 1];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
cin >> s + 1;
f[0][0] = 1;
fSum[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= k; j++) {
f[i][j] = (fSum[i - 1][j] * (s[i] - 'a')) % base;
for (int equa = 0; equa <= i - 1; equa++) {
if (j - (1 + equa) * (n - i + 1) < 0) break;
f[i][j] = (f[i][j] + f[i - equa - 1][j - (1 + equa) * (n - i + 1)] *
('z' - s[i])) %
base;
}
fSum[i][j] = fSum[i - 1][j] + f[i][j];
}
long long res = 0;
for (int i = 0; i <= n; i++) res = (res + f[i][k]) % base;
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> adj[100006];
int color[100006];
int ans = 0;
int dfs(int x) {
for (int i = 0; i < adj[x].size(); i++) {
int v = adj[x][i];
int c = dfs(v);
if (c != color[x]) {
ans++;
}
}
return color[x];
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) {
int x;
cin >> x;
adj[x].push_back(i);
}
for (int i = 1; i <= n; i++) {
cin >> color[i];
}
dfs(1);
cout << ans + 1 << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int prime[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41};
const int N = 3e6 + 7, M = 2 * N;
long long arr[N];
long long com[N];
map<long long, vector<long long>> mp;
pair<long long, long long> arr2[N];
long long n, m, t, a, b, row, col, r, c;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i + 1];
int k = 0;
mp[0].push_back(0);
for (int i = 0; i < n; i++) {
arr[i + 1] = arr[i + 1] + arr[i];
if (mp[arr[i + 1]].size()) {
arr2[k].first = mp[arr[i + 1]].back() + 1;
arr2[k].second = i + 1;
k++;
}
mp[arr[i + 1]].push_back(i + 1);
}
sort(arr2, arr2 + k, [](pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) return a.second < b.second;
return a.first < b.first;
});
long long ls = -1, cnt = 0;
for (int i = 0; i < k; i++) {
if (!(ls >= cnt + arr2[i].first && ls <= cnt + arr2[i].second)) {
ls = arr2[i].second + cnt;
cnt++;
}
}
cout << cnt << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void REV(T *a, int n) {
reverse(a + 1, a + 1 + n);
}
template <class T>
void SRT(T *a, int n) {
sort(a + 1, a + 1 + n);
}
template <class T>
int UNI(T *a, int n) {
sort(a + 1, a + 1 + n);
return unique(a + 1, a + 1 + n) - (a + 1);
}
template <class T>
int POS(T *a, int n, T v) {
return lower_bound(a + 1, a + 1 + n, v) - a;
}
template <class T>
int fisrtGe(T *a, int n, T v) {
return lower_bound(a + 1, a + 1 + n, v) - a;
}
template <class T>
int lastLe(T *a, int n, T v) {
return upper_bound(a + 1, a + 1 + n, v) - a - 1;
}
template <class T>
void _RD(T &x) {
cin >> x;
}
void _RD(int &x) { scanf("%d", &x); }
void _RD(unsigned int &x) { scanf("%u", &x); }
void _RD(long long &x) { scanf("%lld", &x); }
void _RD(unsigned long long &x) { scanf("%llu", &x); }
void _RD(double &x) { scanf("%lf", &x); }
void _RD(char &x) { scanf(" %c", &x); }
void _RD(char *x) { scanf("%s", x + 1); }
template <class T, class U>
void _RD(pair<T, U> &x) {
_RD(x.first);
_RD(x.second);
}
void RD() {}
template <class T, class... U>
void RD(T &head, U &...tail) {
_RD(head);
RD(tail...);
}
template <class T>
void RDN(T *a, int n) {
for (int i = 1; i <= n; ++i) _RD(a[i]);
}
template <class T>
void _WT(const T &x) {
cout << x;
}
void _WT(const int &x) { printf("%d", x); }
void _WT(const unsigned int &x) { printf("%u", x); }
void _WT(const long long &x) { printf("%lld", x); }
void _WT(const unsigned long long &x) { printf("%llu", x); }
void _WT(const double &x) { printf("%.12f", x); }
void _WT(const char &x) { putchar(x); }
void _WT(const char *x) { printf("%s", x + 1); }
template <class T, class U>
void _WT(const pair<T, U> &x) {
_WT(x.first);
putchar(' ');
_WT(x.second);
}
void WT() {}
template <class T, class... U>
void WT(const T &head, const U &...tail) {
_WT(head);
putchar(sizeof...(tail) ? ' ' : '\n');
WT(tail...);
}
template <class T>
void WTN(T *a, int n) {
for (int i = 1; i <= n; ++i) {
_WT(a[i]);
putchar(" \n"[i == n]);
}
}
template <class T>
void WTV(const vector<T> &x, bool ln = false) {
WT(x.size());
for (auto i = x.begin(); i != x.end(); ++i) {
_WT(*i);
putchar(ln ? '\n' : ' ');
}
if (!ln) putchar('\n');
}
template <typename T>
void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
if (y > x) x = y;
}
unsigned int rnd_seed = chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count();
mt19937 rnd(rnd_seed);
const int INF = 0x3F3F3F3F;
const long long LINF = 0x3F3F3F3F3F3F3F3FLL;
int MOD = 998244353;
struct ModularIntegers {
int num;
ModularIntegers() { num = 0; }
template <typename T>
ModularIntegers(const T &x) {
long long tmp = x;
if (tmp >= MOD) {
if (tmp < (MOD << 1))
tmp -= MOD;
else
tmp %= MOD;
} else if (tmp < 0) {
if (tmp >= -MOD)
tmp += MOD;
else if (tmp %= MOD)
tmp += MOD;
}
num = tmp;
}
friend ModularIntegers operator+(const ModularIntegers &x,
const ModularIntegers &y) {
return x.num + y.num;
}
friend ModularIntegers operator-(const ModularIntegers &x,
const ModularIntegers &y) {
return x.num - y.num;
}
friend ModularIntegers operator*(const ModularIntegers &x,
const ModularIntegers &y) {
return x.num * y.num;
}
friend ModularIntegers operator/(const ModularIntegers &x,
const ModularIntegers &y) {
return x * y.inv();
}
friend bool operator==(const ModularIntegers &x, const ModularIntegers &y) {
return x.num == y.num;
}
friend bool operator!=(const ModularIntegers &x, const ModularIntegers &y) {
return x.num != y.num;
}
ModularIntegers operator+() { return +this->num; }
ModularIntegers operator-() { return -this->num; }
ModularIntegers &operator+=(const ModularIntegers &x) {
if ((this->num += x.num) >= MOD) this->num -= MOD;
return *this;
}
ModularIntegers &operator-=(const ModularIntegers &x) {
if ((this->num -= x.num) < 0) this->num += MOD;
return *this;
}
ModularIntegers &operator*=(const ModularIntegers &x) {
this->num = 1LL * this->num * x.num % MOD;
return *this;
}
ModularIntegers &operator/=(const ModularIntegers &x) {
this->num = ((*this) * x.inv()).num;
return *this;
}
ModularIntegers pow(long long x) const {
ModularIntegers res(1), cur(this->num);
for (; x; cur *= cur, x >>= 1)
if (x & 1) res *= cur;
return res;
}
ModularIntegers inv() const { return pow(MOD - 2); }
operator int() { return num; }
operator unsigned int() { return num; }
operator long long() { return num; }
operator unsigned long long() { return num; }
};
void _RD(ModularIntegers &x) { scanf("%d", &x.num); }
void _WT(const ModularIntegers &x) { printf("%d", x.num); }
int n, q;
static const int MAXN = 2e5 + 10;
long long a[MAXN];
long long b[MAXN];
struct Block {
static const int MAXB = MAXN;
int rt[MAXN];
long long va[MAXN];
int lb[MAXB];
int rb[MAXB];
long long sm[MAXB];
long long ZXZ[MAXB];
long long ZDZ[MAXB];
long long Sum(int l, int r) {
long long sum = 0;
long long zxz = 0;
long long zdz = 0;
if (rt[l] == rt[r]) {
for (int i = l; i <= r; ++i) {
sum += va[i];
cmin(zxz, sum);
cmax(zdz, sum);
if (zdz > 0) return INF;
}
} else {
for (int i = l; i <= rb[rt[l]]; ++i) {
sum += va[i];
cmin(zxz, sum);
cmax(zdz, sum);
if (zdz > 0) return INF;
}
for (int b = rt[l] + 1; b <= rt[r] - 1; ++b) {
cmin(zxz, sum + ZXZ[b]);
cmax(zdz, sum + ZDZ[b]);
sum += sm[b];
if (zdz > 0) return INF;
}
for (int i = lb[rt[r]]; i <= r; ++i) {
sum += va[i];
cmin(zxz, sum);
cmax(zdz, sum);
if (zdz > 0) return INF;
}
}
if (zdz > 0) return INF;
if (sum != 0) return INF;
return zxz;
}
void Init(int n) {
int blk = (int)sqrt(n) + 1;
int cntblk = (n + blk - 1) / blk;
memset(va, 0LL, sizeof(va[0]) * (n + 1));
memset(lb, INF, sizeof(lb[0]) * (cntblk + 1));
memset(rb, -INF, sizeof(rb[0]) * (cntblk + 1));
memset(sm, 0LL, sizeof(sm[0]) * (cntblk + 1));
for (int i = 1; i <= n; ++i) {
rt[i] = (i + blk - 1) / blk;
lb[rt[i]] = min(lb[rt[i]], i);
rb[rt[i]] = max(rb[rt[i]], i);
}
for (int i = 1; i <= n; ++i) {
va[i] = a[i] - b[i];
}
for (int i = 1; i <= cntblk; ++i) {
sm[i] = 0;
ZXZ[i] = LINF;
ZDZ[i] = -LINF;
for (int j = lb[i]; j <= rb[i]; ++j) {
sm[i] += va[j];
cmin(ZXZ[i], sm[i]);
cmax(ZDZ[i], sm[i]);
}
}
}
} blk;
void purin_solve() {
RD(n, q);
RDN(a, n);
RDN(b, n);
blk.Init(n);
while (q--) {
int l, r;
RD(l, r);
long long ans = -blk.Sum(l, r);
if (ans < 0) ans = -1LL;
WT(ans);
}
}
int main() {
cout << fixed << setprecision(12);
cerr << fixed << setprecision(12);
int t = 1;
while (t--) purin_solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> o[(int)2e5 + 10];
long long n, ts[(int)2e5 + 10], tc[(int)2e5 + 10];
int main(void) {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &o[i].second);
}
for (int i = 0; i < n; i++) {
scanf("%lld", &o[i].first);
}
sort(o, o + n);
for (int i = 0; i < n; i++) {
o[i] = {o[i].second, i + 1};
}
sort(o, o + n);
long long ans = 0;
for (int i = n - 1; - 1 < i; i--) {
long long l = o[i].second - 1, r = n, idx = o[i].first;
long long s = 0, c = 0;
while (0 < r) {
s += ts[r];
c += tc[r];
r -= (r & -r);
}
while (0 < l) {
s -= ts[l];
c -= tc[l];
l -= (l & -l);
}
ans += s - c * idx;
int v = o[i].second;
while (v <= n) {
ts[v] += idx;
tc[v]++;
v += (v & -v);
}
}
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *r) -> decltype(cerr << *r);
template <class c>
char dud(...);
struct muu {
template <class c>
muu &operator<<(const c &) {
return *this;
}
};
using pii = pair<int, int>;
using ld = long double;
using ll = long long;
int tab[507][507];
int main() {
int N;
scanf("%d", &N);
if (N <= 2) {
printf("-1");
return 0;
}
tab[0][0] = 10 - 9;
tab[0][1] = 10 - 8;
tab[0][2] = 10 - 6;
tab[1][0] = 10 - 5;
tab[1][1] = 10 - 3;
tab[1][2] = 10 - 2;
tab[2][0] = 10 - 1;
tab[2][1] = 10 - 7;
tab[2][2] = 10 - 4;
int ter = 10;
bool pocz = true;
for (int i = 3; i < N; i++) {
if (pocz) {
for (int w = 0; w < i; w++) tab[i][w] = ter++;
tab[i][i] = ter++;
for (int w = i - 1; w >= 0; w--) tab[w][i] = ter++;
} else {
for (int w = 0; w < i; w++) tab[w][i] = ter++;
tab[i][i] = ter++;
for (int w = i - 1; w >= 0; w--) tab[i][w] = ter++;
}
pocz = !pocz;
}
int qq = N * N + 1;
for (int i = 0; i < N; i++) {
for (int w = 0; w < N; w++) {
printf("%2d ", qq - tab[i][w]);
}
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k;
long long int f(long long int n, long long int m, long long int k) {
if (k <= n - 1) return LONG_LONG_MAX;
k -= n - 1;
return m / (k + 1) * 1;
}
int main() {
ios ::sync_with_stdio(0);
cin >> n >> m >> k;
if (n < m) swap(n, m);
if (k > n - 1 + m - 1) {
cout << -1 << '\n';
return 0;
}
if (k <= m - 1)
cout << max(n / (k + 1) * m, m / (k + 1) * n) << '\n';
else if (k <= n - 1)
cout << n / (k + 1) * m << '\n';
else
cout << max(f(n, m, k), f(m, n, k)) << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
for (int i = 0; i < n * k; i++) {
if (s[i % n] == 'B' and s[(i % n) + 1] == 'G') {
s[i % n] = 'G';
s[(i % n) + 1] = 'B';
i++;
}
}
for (int i = 0; i < n; i++) {
cout << s[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define ll long long int
#define pll pair<ll, ll>
#define pii pair<int, int>
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
using namespace std;
ll MOD = 998244353;
ll pwr(ll x, ll y) {
ll res = 1;
x = x%MOD;
while (y > 0) {
if (y&1) res = (res*x)%MOD;
y = y>>1;
x = (x*x)%MOD;
}
return res;
}
inline ll addmod(ll a, ll b){
return ((a+b)%MOD);
}
inline ll mulmod(ll a, ll b){
return ((a*b)%MOD);
}
class BIT {
int *bit;
int N;
public:
void update(int x, int val) {
int ind = x;
while (ind <= N) {
bit[ind] += val;
ind += (ind & (-ind));
}
}
BIT(int ar[], int n) {
bit = new int[n+1];
N = n+1;
for (int i = 1; i < N; i++) bit[i] = 0;
for (int i = 1; i < N; i++) update(i, ar[i-1]);
}
int getSum(int x) {
if (x < 0) return 0;
int ind = x+1;
int sum = 0;
while (ind > 0) {
sum += bit[ind];
ind = (ind & (ind-1));
}
return sum;
}
int getValue(int x) {
return getSum(x) - getSum(x-1);
}
void changeElem(int x, int val) {
update(x+1, val-getValue(x));
}
};
int bsh(int val, int ar[], int n) { // return ind such that val >= ar[ind] and val < ar[ind+1]
int a = 0, b = n - 1, c = (a+b)/2;
if (val < ar[0]) return -1;
if (val >= ar[b]) return b;
while (!(val >= ar[c] && val < ar[c+1])) {
if (val < ar[c]) b = c;
else {
if (b-a == 1 && c == a) a = b;
else a = c;
}
c = (a+b)/2;
}
return c;
}
int main () {
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int t; cin >> t;
while (t--) {
int n; cin >> n;
vector<pii> seg(n);
vector<int> l(n), r(n);
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
seg[i].ff = l[i];
seg[i].ss = r[i];
}
sort(l.begin(), l.end());
sort(r.begin(), r.end());
int ans = n;
for (int i = 0; i < n; i++) {
int cur = 0;
cur += (int) (lower_bound(r.begin(), r.end(), seg[i].ff) - r.begin());
cur += n - (int) (upper_bound(l.begin(), l.end(), seg[i].ss) - l.begin());
ans = min(ans, cur);
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace uzumaki {}
using namespace uzumaki;
typedef std::priority_queue<long long int, std::vector<long long int>,
std::greater<long long int> >
min_pq;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
namespace uzumaki {
template <typename T>
T max(T A) {
return A;
}
template <typename T, typename... args>
T max(T A, T B, args... S) {
return max(A > B ? A : B, S...);
}
template <typename T>
T min(T A) {
return A;
}
template <typename T, typename... args>
T min(T A, T B, args... S) {
return min(A < B ? A : B, S...);
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& out, std::pair<T, U> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename U>
std::istream& operator>>(std::istream& in, std::pair<T, U>& a) {
in >> a.first >> a.second;
return in;
}
inline string inttos(long long int a) {
std::stringstream soso;
soso << a;
return soso.str();
}
inline long long int stoint(const std::string& s) {
std::stringstream soso;
soso << s;
long long x;
soso >> x;
return x;
}
inline std::string inttobin(long long int x) {
return std::bitset<40>(x).to_string();
}
inline void swp(long long int& a, long long int& b) {
auto temp = a;
a = b;
b = temp;
}
} // namespace uzumaki
void solve() {
long long int n;
cin >> n;
long long int x = n / 2;
vector<long long int> v2(n - x), v(n);
for (long long int i = 0; i < n; i++) {
cin >> v[i];
}
sort((v).begin(), (v).end());
for (long long int i = x; i < n; i++) {
v2[i - x] = v[i];
}
long long int j = 0;
long long int cnt = 0;
for (long long int i = 0; i < x; i++) {
while (j < n - x && v2[j] < 2 * v[i]) {
j++;
}
if (j == n - x) {
break;
}
cnt++;
j++;
}
cout << n - cnt << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
for (long long int i = 0; i < t; i++) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double eps = 0.000000001;
int months[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool visok(int y) {
if (y % 4 == 0 && ((y % 100 == 0) ? y % 400 == 0 : true)) return true;
return false;
}
long long daysCount(int y1, int m1, int d1) {
long long kol1 = 0;
for (int i = 1899; i < y1; ++i) {
if (visok(i))
kol1 += 366;
else
kol1 += 365;
}
for (int i = 1; i < m1; ++i) {
if (i == 2 && visok(y1))
kol1 += months[i - 1] + 1;
else
kol1 += months[i - 1];
}
kol1 += d1;
return kol1;
}
int main() {
int y1, m1, d1;
int y2, m2, d2;
char sk;
int tmp;
cin >> y1 >> sk >> m1 >> sk >> d1;
cin >> y2 >> sk >> m2 >> sk >> d2;
long long kol1 = daysCount(y1, m1, d1);
long long kol2 = daysCount(y2, m2, d2);
cout << abs(kol1 - kol2) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void checkMin(T& x, const T v) {
if (x > v) {
x = v;
}
}
template <class T>
void checkMax(T& x, const T v) {
if (x < v) {
x = v;
}
}
template <class intType>
intType ext_gcd(intType a, intType b, intType& x, intType& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
intType d = ext_gcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
template <class intType>
intType mulMod(intType a, intType b, intType mod) {
a %= mod, b %= mod;
if (a < 0) a += mod;
if (b < 0) b += mod;
intType ret = 0;
for (; b; b >>= 1) {
if (b & 1) {
ret += a;
if (ret > mod) {
ret -= mod;
}
}
a += a;
if (a > mod) {
a -= mod;
}
}
return ret;
}
template <class intType>
bool chineseRemainder(intType r1, intType m1, intType r2, intType m2,
intType& remainder, intType& mod) {
intType x, y;
intType d = ext_gcd(m1, m2, x, y);
mod = m1 / d * m2;
if ((r2 - r1) % d != 0) {
return false;
}
x = mulMod((r2 - r1) / d, x, m2) * m1;
x += r1;
x %= mod;
if (x < 0) {
x += mod;
}
remainder = x;
return true;
}
long long n, m, nk;
long long v;
vector<long long> a;
bool go() {
long long x = 0, mod = 1, d;
long long tx, ty;
for (int n___LINE__ = nk, i = 0; i < n___LINE__; ++i) {
d = ext_gcd(mod, a[i], tx, ty);
if (mod / d > n / a[i]) {
return false;
}
if (!chineseRemainder(x, mod, (a[i] - i % a[i]) % a[i], a[i], x, mod)) {
return false;
}
}
if (x == 0) x = mod;
if (x + nk - 1 > m) return false;
for (int n___LINE__ = nk, i = 0; i < n___LINE__; ++i) {
if (ext_gcd(x + i, mod, tx, ty) != a[i]) {
return false;
}
}
return true;
}
int main() {
cin >> n >> m >> nk;
for (int n___LINE__ = nk, i = 0; i < n___LINE__; ++i) {
cin >> v;
a.push_back(v);
}
puts(go() ? "YES" : "NO");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const int mod = 1e9 + 7;
long long ans;
int n, d[N], son[N], size[N];
vector<int> G[N], dp[N];
bool cmp(int i, int j) { return d[i] > d[j]; }
void dfs(int x, int f) {
size[x] = 1;
if (find(G[x].begin(), G[x].end(), f) != G[x].end())
G[x].erase(find(G[x].begin(), G[x].end(), f));
d[x] = G[x].size();
dp[x].resize(d[x] + 1);
for (int u : G[x]) {
dfs(u, x);
size[x] += size[u];
if (size[u] >= size[son[x]]) son[x] = u;
}
sort(G[x].begin(), G[x].end(), cmp);
for (int i = 1; i <= d[x]; ++i) {
multiset<int> S;
dp[x][i] = 2;
for (int u : G[x]) {
if (d[u] < i) break;
S.insert(dp[u][i]);
}
while (S.size() > i) S.erase(S.begin());
if (S.size() == i) dp[x][i] = (*S.begin()) + 1;
}
}
int f[N];
long long sum;
void clear(int x) {
for (int i = 1; i <= d[x]; ++i) f[i] = 1;
for (int u : G[x]) clear(u);
}
void insert(int x) {
for (int i = 1; i <= d[x]; ++i) {
if (dp[x][i] > f[i]) {
sum += dp[x][i] - f[i];
f[i] = dp[x][i];
}
}
for (int u : G[x]) insert(u);
}
void dfs(int x) {
for (int u : G[x]) {
if (u == son[x]) continue;
dfs(u);
sum = n;
clear(u);
}
if (son[x]) dfs(son[x]);
for (int u : G[x])
if (u != son[x]) insert(u);
for (int i = 1; i <= d[x]; ++i) {
if (dp[x][i] > f[i]) {
sum += dp[x][i] - f[i];
f[i] = dp[x][i];
}
}
ans += sum;
}
int main() {
cin >> n;
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d %d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
dfs(1, 0);
for (int i = 1; i <= n; ++i) f[i] = 1;
sum = n;
dfs(1);
cout << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const long double PI = acos(-1);
const int N = 1e5 + 5;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
struct edge {
int u, v;
long long wt;
};
int n, m;
int vis[N], par[N], sz[N];
long long x[N], dsx[N];
int find(int p) {
if (par[p] == p)
return p;
else {
int pp = find(par[p]);
dsx[p] = dsx[p] ^ dsx[par[p]];
par[p] = pp;
return pp;
}
}
bool unite(int u, int v, long long wt) {
long long du = dsx[u], dv = dsx[v];
u = find(u), v = find(v);
if (u == v) return false;
if (sz[u] > sz[v]) swap(u, v);
par[u] = v;
dsx[u] = du ^ dv ^ wt;
sz[v] += sz[u];
return true;
}
vector<bitset<60>> num, base;
int gauss_my_friend() {
int sz = (int)num.size();
int bs = 0;
for (int i = 0; i < 60; i++) {
bool found = false;
for (int j = bs; j < sz; j++)
if (num[j][i]) {
found = true;
swap(num[j], num[bs]);
}
for (int j = bs + 1; j < sz; j++)
if (num[j][i]) {
num[j] ^= num[bs];
}
if (found) base.push_back(num[bs]), bs++;
}
return base.size();
}
vector<edge> adj[N];
vector<edge> ed;
void dfs(int u, long long p, int pr) {
if (vis[u]) return;
vis[u] = 1;
x[u] = p;
for (auto e : adj[u])
if (e.v != pr) {
ed.push_back(e);
dfs(e.v, p ^ e.wt, u);
}
}
void res(int u) {
par[u] = u;
sz[u] = 1;
dsx[u] = 0;
}
long long solve(vector<edge> ed) {
vector<int> vtx;
for (auto e : ed) {
res(e.u), res(e.v);
vtx.push_back(e.u);
vtx.push_back(e.v);
}
sort(vtx.begin(), vtx.end());
long long n = unique(vtx.begin(), vtx.end()) - vtx.begin();
vtx.resize(n);
for (auto e : ed) {
int u = e.u, v = e.v;
long long wt = e.wt;
if (!unite(u, v, wt)) {
num.push_back(wt ^ dsx[u] ^ dsx[v]);
} else {
}
}
int b = gauss_my_friend();
long long sum = 0;
for (int i = 0; i < 60; i++) {
bool has = false;
for (auto j : base)
if (j[i]) has = true;
long long one = 0, zero = 0;
for (int j : vtx) {
if (x[j] & (1ll << i))
one++;
else
zero++;
}
if (has) {
long long term1 = (1ll << i) % MOD;
long long term2 = (1ll << (b - 1)) % MOD;
long long term3 = (n * (n - 1)) / 2;
term1 = (term1 * term2) % MOD;
term1 = (term1 * term3) % MOD;
sum = (sum + term1) % MOD;
} else {
long long term1 = (1ll << i) % MOD;
long long term2 = (1ll << b) % MOD;
term1 = (term1 * term2) % MOD;
term1 = (term1 * one) % MOD;
term1 = (term1 * zero) % MOD;
sum = (sum + term1) % MOD;
}
}
return sum;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
long long t;
scanf("%d %d %lld", &u, &v, &t);
edge eu = {u, v, t};
edge ev = {v, u, t};
adj[u].push_back(eu);
adj[v].push_back(ev);
}
long long ans = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
ed.clear();
num.clear();
base.clear();
dfs(i, 0, 0);
ans = (ans + solve(ed)) % MOD;
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long fac[1234567] = {};
long long inv[1234567] = {};
const long long mod = 1e9 + 7;
long long powmod(long long a, long long b) {
if (b < 0) {
b = -b;
a = powmod(a, mod - 2);
}
long long res = 1;
while (b) {
if (b & 1) res *= a, res %= mod;
a *= a;
a %= mod;
b >>= 1;
}
return res;
}
long long inv_pow(long long n) { return powmod(n, mod - 2); }
void build() {
fac[0] = fac[1] = inv[0] = 1;
for (long long i = 2; i < 1234567; i++)
fac[i] = fac[i - 1] * i, fac[i] %= mod;
for (long long i = 1; i < 1234567; i++) {
long long x = inv_pow(i);
inv[i] = inv[i - 1] * x % mod;
}
}
int32_t main() {
ios::sync_with_stdio();
cin.tie(0);
build();
long long n, m, a, b;
cin >> n >> m >> a >> b;
long long ans = 0;
for (long long edges = 1; edges < min(m + 1, n); edges++) {
long long res1 = fac[n - 2] * inv[n - edges - 1] % mod;
long long res2 = fac[m - 1] * inv[m - edges] % mod * inv[edges - 1] % mod;
long long res3 = (edges + 1) * powmod(n, n - edges - 2) % mod;
long long res4 = powmod(m, n - edges - 1) % mod;
long long res = res1 * res2 % mod * res3 % mod * res4 % mod;
ans += res % mod;
ans %= mod;
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int w[N];
vector<int> g[N];
bool used[N];
int tin[N], tup[N];
void dfs(int v, int p) {
static int time = 0;
tin[v] = time++;
tup[v] = tin[v];
used[v] = true;
for (int u : g[v]) {
if (u == p) continue;
if (!used[u]) {
dfs(u, v);
tup[v] = min(tup[v], tup[u]);
} else {
tup[v] = min(tup[v], tin[u]);
}
}
}
bool check(int v, int u) {
if (tin[v] > tin[u]) swap(u, v);
return tup[u] > tin[v];
}
void clearUsed(int n) {
for (int i = 0; i < n; ++i) used[i] = false;
}
int comp[N];
vector<int> vecComp[N];
long long wComp[N];
void dfsComp(int v, int col) {
used[v] = true;
comp[v] = col;
vecComp[col].push_back(v);
wComp[col] += w[v];
for (int u : g[v]) {
if (!used[u] && !check(u, v)) dfsComp(u, col);
}
}
vector<int> t[N];
bool has[N];
int mt[N];
void dfsTree(int v, int p = -1) {
mt[v] = v;
has[v] = (int)vecComp[v].size() > 1;
for (int u : t[v]) {
if (u == p) continue;
dfsTree(u, v);
if (has[u]) {
has[v] = true;
int a = mt[v], b = mt[u];
if ((int)vecComp[a].size() > (int)vecComp[b].size())
swap(a, b);
else
mt[v] = mt[u];
for (int x : vecComp[a]) {
comp[x] = b;
vecComp[b].push_back(x);
}
wComp[b] += wComp[a];
wComp[a] = 0;
vecComp[a].clear();
}
}
}
long long dp[N];
bool inPath[N];
bool dfsLast(int v, int p) {
bool res = false;
for (int u : t[v]) {
if (u == p) continue;
if (dfsLast(u, v))
res = true;
else
dp[v] = max(dp[v], dp[u] + wComp[u]);
}
res = res || (vecComp[v].size() > 1);
inPath[v] = res;
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", w + i);
while (m--) {
static int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0, -1);
clearUsed(n);
int cntComp = 0;
for (int v = 0; v < n; ++v)
if (!used[v]) dfsComp(v, cntComp++);
clearUsed(n);
for (int v = 0; v < n; ++v) {
for (int u : g[v]) {
if (check(u, v)) t[comp[v]].push_back(comp[u]);
}
}
int s = 0;
while (s < cntComp && (int)vecComp[s].size() <= 1) ++s;
if (s != cntComp) {
dfsTree(s);
clearUsed(n);
for (int v = 0; v < n; ++v) t[v].clear();
for (int v = 0; v < n; ++v) {
for (int u : g[v]) {
int a = comp[v];
int b = comp[u];
if (a != b) t[a].push_back(b);
}
}
}
int start;
scanf("%d", &start);
--start;
start = comp[start];
dfsLast(start, -1);
inPath[start] = true;
long long sumPath = 0, ans = 0;
for (int v = 0; v < cntComp; ++v) {
if (vecComp[v].size()) {
if (inPath[v]) {
sumPath += wComp[v];
ans = max(ans, dp[v]);
}
}
}
ans += sumPath;
printf("%lld", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long const MOD = 998244353;
int const MAXN = 100000;
vector<int> grav[MAXN];
int t_in[MAXN];
int t_out[MAXN];
string colors;
vector<pair<int, int>> dfs_order[MAXN];
vector<int> cnt[MAXN];
int depth[MAXN];
int parent[MAXN];
int up[MAXN][20];
int _t = 0;
int max_d = 0;
void dfs(int u, int p = -1, int d = 0) {
depth[u] = d;
parent[u] = p;
t_in[u] = _t++;
max_d = max(max_d, d);
dfs_order[d].emplace_back(t_in[u], u);
for (int v : grav[u]) {
dfs(v, u, d + 1);
}
t_out[u] = _t++;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
long long a, b;
cin >> a >> b;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
vector<int> ds;
auto f = [&ds](int n) {
ds.push_back(n);
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
ds.push_back(i);
while (n % i == 0) n /= i;
}
}
if (n != 1) ds.push_back(n);
};
f(v[0]);
f(v[0] - 1);
f(v[0] + 1);
f(v.back());
f(v.back() - 1);
f(v.back() + 1);
set<int> ds_s(ds.begin(), ds.end());
ds = vector<int>(ds_s.begin(), ds_s.end());
long long res = numeric_limits<long long>::max();
for (int d : ds) {
if (d == 1) continue;
vector<vector<long long>> dp(n, vector<long long>(3, -1));
if (v[0] % d == 0) {
dp[0][0] = 0;
} else if ((v[0] + 1) % d == 0 || (v[0] - 1) % d == 0) {
dp[0][0] = b;
}
dp[0][1] = a;
dp[0][2] = -1;
for (int i = 0; i + 1 < n; i++) {
int n = v[i + 1];
if (dp[i][0] != -1) {
if (n % d == 0) {
dp[i + 1][0] = dp[i][0];
} else if ((n + 1) % d == 0 || (n - 1) % d == 0) {
dp[i + 1][0] = dp[i][0] + b;
}
dp[i + 1][1] = dp[i][0] + a;
}
if (dp[i][1] != -1) {
if (dp[i + 1][1] == -1 || dp[i + 1][1] > dp[i][1] + a) {
dp[i + 1][1] = dp[i][1] + a;
}
if (n % d == 0) {
dp[i + 1][2] = dp[i][1];
} else if ((n + 1) % d == 0 || (n - 1) % d == 0) {
dp[i + 1][2] = dp[i][1] + b;
}
}
if (dp[i][2] != -1) {
if (n % d == 0) {
if (dp[i + 1][2] == -1 || dp[i + 1][2] > dp[i][2]) {
dp[i + 1][2] = dp[i][2];
}
} else if ((n + 1) % d == 0 || (n - 1) % d == 0) {
if (dp[i + 1][2] == -1 || dp[i + 1][2] > dp[i][2] + b) {
dp[i + 1][2] = dp[i][2] + b;
}
}
}
}
for (int i = 0; i < 3; i++)
if (dp[n - 1][i] != -1) res = min(res, dp[n - 1][i]);
}
cout << res << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = -1e8;
const double Pi = acos(-1);
bool inline equ(double a, double b) { return fabs(a - b) < EPS; }
int _R(int& x) { return scanf("%d", &x); }
int _R(long long& x) { return scanf("%" PRId64, &x); }
int _R(double& x) { return scanf("%lf", &x); }
int _R(char* s) { return scanf("%s", s); }
int R() { return 0; }
template <typename T1, typename... T2>
int R(T1& x, T2&... tail) {
int tmp = _R(x);
return tmp + R(tail...);
}
template <typename Iter, typename F>
inline void out(Iter s, Iter e, F of) {
bool flag = 0;
for (Iter it = s; it != e; it++) {
if (flag)
printf(" ");
else
flag = 1;
of(*it);
}
puts("");
}
const int MAXN = 100010;
int n, m, k;
int l[MAXN], r[MAXN], x[MAXN];
int main() {
R(n, m, k);
for (int i = (1); i <= (m); i++) R(l[i], r[i], x[i]);
long long ans = 0ll;
for (int i = (1); i <= (k); i++) {
int id;
R(id);
for (int j = (1); j <= (m); j++)
if (l[j] <= id && id <= r[j]) {
ans += x[j] + id - l[j];
}
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
struct Tp {
int x, y, z, i;
} a[555555];
int n, M[555555], r, t, ans = 0;
inline bool ByY(Tp A, Tp B) { return A.y > B.y; }
inline bool ByX(Tp A, Tp B) {
return A.x > B.x || A.x == B.x && A.y < B.y ||
A.x == B.x && A.y == B.y && A.z < B.z;
}
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i].x);
for (int i = 0; i < n; i++) scanf("%d", &a[i].y);
for (int i = 0; i < n; i++) scanf("%d", &a[i].z);
std::sort(a, a + n, ByY);
a[0].i = 1;
for (int i = 1; i < n; i++) a[i].i = a[i - 1].i + (a[i].y != a[i - 1].y);
memset(M, 128, sizeof(M));
std::sort(a, a + n, ByX);
for (int i = 0; i < n; i++) {
t = M[0];
r = a[i].i - 1;
while (r) {
if (M[r] > t) t = M[r];
r &= r - 1;
}
ans += (t > a[i].z);
r = a[i].i;
while (r < 555555) {
if (M[r] < a[i].z) M[r] = a[i].z;
r = (r | (r - 1)) + 1;
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n), b(n);
int bl = 0, rd = 0;
for (int i = 0; i < n; i++) {
cin >> a[n - i - 1];
if (a[n - i - 1] == 1)
rd += 1;
else
bl += 1;
}
unordered_map<int, int> lowest;
lowest[rd - bl] = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1)
rd -= 1;
else
bl -= 1;
if (lowest.find(rd - bl) == lowest.end()) lowest[rd - bl] = i + 1;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
if (b[i] == 1)
rd += 1;
else
bl += 1;
}
int best = INT_MAX;
if (lowest.find(bl - rd) != lowest.end()) best = lowest[bl - rd];
for (int i = 0; i < n; i++) {
if (b[i] == 1)
rd -= 1;
else
bl -= 1;
if (lowest.find(bl - rd) != lowest.end())
best = min(best, lowest[bl - rd] + 1 + i);
}
cout << best << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s, t;
cin >> n;
vector<vector<int> > DP(26, vector<int>(26, -10000000));
for (int i = 0; i < n; i++) {
t = s;
cin >> s;
if (i > 0)
DP[t[0] - 'a'][t[t.length() - 1] - 'a'] =
max(DP[t[0] - 'a'][t[t.length() - 1] - 'a'], (int)t.length());
for (int j = 0; j < 26; j++)
DP[j][s[s.length() - 1] - 'a'] = max(DP[j][s[s.length() - 1] - 'a'],
DP[j][s[0] - 'a'] + (int)s.length());
}
t = s;
DP[t[0] - 'a'][t[t.length() - 1] - 'a'] =
max(DP[t[0] - 'a'][t[t.length() - 1] - 'a'], (int)t.length());
int Ans = 0;
for (int i = 0; i < 26; i++) Ans = max(Ans, DP[i][i]);
cout << Ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> qu(vector<int>& w) {
if (w.size() == 0) {
return {-2, -2};
}
cout << "? " << w.size();
for (int i = 0; i < w.size(); i++) {
cout << " " << w[i] + 1;
}
cout << '\n';
cout.flush();
int a, b;
cin >> a >> b;
a--;
return {a, b};
}
bool ans(int u, int v) {
cout << "! " << u + 1 << " " << v + 1 << '\n';
cout.flush();
string s;
cin >> s;
return s[0] == 'C';
}
vector<vector<int> > g;
vector<int> lev;
vector<int> pa;
vector<int> en, ex;
int dord;
void dfa(int u, int p) {
pa[u] = p;
en[u] = dord;
dord++;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) {
continue;
}
lev[v] = lev[u] + 1;
dfa(v, u);
}
ex[u] = dord;
dord++;
}
bool anc(int a, int b) { return en[a] <= en[b] && ex[a] >= ex[b]; }
void def(int u, int de, vector<int>& le) {
if (de == 0) {
le.push_back(u);
return;
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == pa[u]) {
continue;
}
def(v, de - 1, le);
}
}
void dof(int u, int de, vector<int>& le, set<int>& no) {
if (no.count(u)) {
return;
}
if (de == 0) {
le.push_back(u);
return;
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == pa[u]) {
continue;
}
dof(v, de - 1, le, no);
}
}
void dos(int u, vector<pair<int, int> >& suc, int di, set<int>& no, int cut) {
if (no.count(u)) {
return;
}
if (di > 0 && u != 0 && (g[u].size() == 1 || di == cut)) {
suc.push_back({di, u});
return;
}
if (di == cut) {
return;
}
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == pa[u]) {
continue;
}
dos(v, suc, di + 1, no, cut);
}
}
pair<int, int> Sa(int st, int ed, int da, int sr) {
st -= lev[sr];
ed -= lev[sr];
int ls = sr;
int lu = st;
while (st <= ed) {
int m = (st + ed) / 2;
vector<int> wa;
def(sr, m, wa);
pair<int, int> ra = qu(wa);
if (ra.second <= da) {
ls = ra.first;
lu = m;
st = m + 1;
} else {
ed = m - 1;
}
}
set<int> no;
pair<int, int> res;
res.first = ls;
while (ls != sr) {
no.insert(ls);
ls = pa[ls];
}
vector<int> wa, wb;
def(sr, da - lu, wa);
for (int i = 0; i < wa.size(); i++) {
if (!no.count(wa[i])) {
wb.push_back(wa[i]);
}
}
res.second = qu(wb).first;
return res;
}
pair<int, int> Sb(int da, vector<pair<int, int> >& suc, int sr) {
set<int> no;
pair<int, int> res;
int he = sr;
while (suc.size() >= 1) {
sort(suc.begin(), suc.end(), greater<pair<int, int> >());
int le = suc[suc.size() / 2].first;
vector<int> wa;
dof(he, le, wa, no);
pair<int, int> re = qu(wa);
int u = re.first;
for (int i = 0; i < (re.second - da) / 2; i++) {
u = pa[u];
}
he = u;
for (int i = 0; i < wa.size(); i++) {
if (wa[i] == he) {
continue;
}
int v = wa[i];
while (!anc(pa[v], he)) {
v = pa[v];
}
no.insert(v);
}
suc.clear();
dos(u, suc, 0, no, da + lev[sr] - lev[he]);
}
res.first = he;
vector<int> wa, wb;
def(sr, da - (lev[he] - lev[sr]), wa);
no.clear();
while (he != sr) {
no.insert(he);
he = pa[he];
}
for (int i = 0; i < wa.size(); i++) {
if (!no.count(wa[i])) {
wb.push_back(wa[i]);
}
}
res.second = qu(wb).first;
return res;
}
int main() {
int N;
cin >> N;
while (N--) {
int n;
cin >> n;
g.assign(n, vector<int>());
pa.assign(n, -1);
en.assign(n, 0);
ex.assign(n, 0);
dord = 0;
lev.assign(n, 0);
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> wa;
for (int i = 0; i < n; i++) {
wa.push_back(i);
}
dfa(0, 0);
pair<int, int> ra = qu(wa);
int va = ra.first;
int da = ra.second;
wa.clear();
wa.push_back(0);
ra = qu(wa);
int vr = ra.first;
int dr = ra.second;
while (lev[va] > (dr - da) / 2) {
va = pa[va];
}
int ml = 0;
int wal = (da + 1) / 2;
vector<pair<int, int> > suc;
for (int i = 0; i < n; i++) {
ml = max(ml, lev[i]);
if (lev[i] >= lev[va] + wal && lev[i] <= da + lev[va]) {
int le = (i == 0) + g[i].size();
if (le == 1 || lev[i] == da + lev[va]) {
suc.push_back({lev[i] - lev[va], i});
}
}
}
ml = min(ml, da + lev[va]);
int nos = ml - wal + 1;
pair<int, int> ret;
if (0 && nos < suc.size()) {
ret = Sa(lev[va] + wal, ml, da, va);
} else {
ret = Sb(da, suc, va);
}
if (!ans(ret.first, ret.second)) {
break;
}
}
}
| 8 |
#include <bits/stdc++.h>
char a[111][111];
int r[111];
int c[111];
int n;
int max(const int &x, const int &y) {
if (x > y)
return (x);
else
return (y);
}
void init(void) {
scanf("%d", &n);
int i, j;
for (i = 1; i <= n; i = i + 1) {
r[i] = -1;
c[i] = -1;
}
for (i = 1; i <= n; i = i + 1) {
scanf("%s", &a[i][1]);
for (j = 1; j <= n; j = j + 1)
if (a[i][j] == '.') {
r[i] = max(r[i], j);
c[j] = max(c[j], i);
}
}
}
void check(void) {
int i;
bool p = true;
for (i = 1; i <= n; i = i + 1)
if (r[i] < 0) {
p = false;
break;
}
if (p) {
for (i = 1; i <= n; i = i + 1) printf("%d %d\n", i, r[i]);
return;
}
p = true;
for (i = 1; i <= n; i = i + 1)
if (c[i] < 0) {
p = false;
break;
}
if (p) {
for (i = 1; i <= n; i = i + 1) printf("%d %d\n", c[i], i);
return;
}
printf("-1");
}
int main(void) {
init();
check();
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
const int MAX_N = 1e6 + 7;
int n, k;
std::vector<int> gr[MAX_N];
std::pair<int, int> drev[MAX_N];
int d[MAX_N];
int pre[2][MAX_N], dep[MAX_N], po = 0;
int dfs(const int& cur, const int& depth) {
pre[0][cur] = po++;
dep[cur] = depth;
for (const auto& nei : gr[cur]) dfs(nei, depth + 1);
pre[1][cur] = po;
return 0;
}
int go(const int& cur) {
if (pre[0][cur] + 1 == pre[1][cur]) {
drev[cur].first = dep[cur] - k;
drev[cur].second = 1;
return 0;
}
drev[cur].first = INF;
for (const auto& nei : gr[cur]) {
go(nei);
drev[cur].first = std::min(drev[cur].first, drev[nei].first);
if (drev[nei].first <= dep[cur]) drev[cur].second += drev[nei].second;
}
return 0;
}
int despacito(const int& cur) {
if (pre[0][cur] + 1 == pre[1][cur]) {
return d[cur] = 1;
}
d[cur] = drev[cur].second;
for (const auto& nei : gr[cur]) {
despacito(nei);
d[cur] = std::max(d[cur],
drev[cur].second -
(drev[nei].first <= dep[cur] ? drev[nei].second : 0) +
d[nei]);
}
return d[cur];
}
int main(void) {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cin >> n >> k;
for (int i = 1, p; i < n; ++i) {
std::cin >> p;
gr[p - 1].push_back(i);
}
std::cout << (dfs(0, 0) + go(0) + despacito(0)) << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool minimize(T& a, const T& b) {
return b < a ? (a = b, true) : false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, a, r, m;
cin >> n >> a >> r >> m;
vector<long long> h(n);
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
sort(h.begin(), h.end());
vector<long long> p(n);
partial_sum(h.begin(), h.end(), p.begin());
auto f = [&](int mid) {
long long Add = 0;
long long Remove = 0;
int i = upper_bound(h.begin(), h.end(), mid) - h.begin();
if (i > 0) {
Add = 1LL * i * mid - p[i - 1];
}
if (i < n) {
if (i > 0) {
Remove -= p[i - 1];
}
Remove += p[n - 1] - 1LL * (n - i) * mid;
}
long long cost = Add * a + Remove * r;
long long Move = min(Add, Remove);
Add -= Move;
Remove -= Move;
minimize(cost, Move * m + Add * a + Remove * r);
return cost;
};
long long ans = LLONG_MAX;
int low = 0;
int high = 1E9;
while (low <= high) {
int mid = (low + high) >> 1;
long long cost1 = f(mid);
long long cost2 = f(mid + 1);
if (cost1 < cost2) {
ans = cost1;
high = mid - 1;
} else {
ans = cost2;
low = mid + 1;
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double win[1100][1100], lost[1100][1100];
int main() {
int w, b;
while (~scanf("%d %d", &w, &b)) {
memset(win, 0, sizeof(win));
memset(lost, 0, sizeof(lost));
for (int i = 1; i <= w; ++i) win[i][0] = 1.0;
for (int i = 1; i <= w; i++)
for (int j = 1; j <= b; j++) {
win[i][j] = i * 1.0 / (i + j) + lost[i][j - 1] * j * 1.0 / (i + j);
lost[i][j] =
j * 1.0 / (i + j) * win[i - 1][j - 1] * i * 1.0 / (i + j - 1);
lost[i][j] +=
j * 1.0 / (i + j) * win[i][j - 2] * (j - 1) * 1.0 / (i + j - 1);
}
printf("%.9lf\n", win[w][b]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int count_[100007], pre[100007], type[100007];
int n;
int main() {
memset(count_, 0, sizeof(count_));
cin >> n;
for (int i = 1; i <= n; i++) cin >> type[i];
for (int i = 1; i <= n; i++) {
int u;
cin >> u;
count_[u]++;
pre[i] = u;
}
int res = 0;
int id;
for (int i = 1; i <= n; i++) {
if (type[i] == 1) {
int temp = 0;
int j = i;
while (count_[j] < 2 && j != 0) {
temp++;
j = pre[j];
}
if (temp > res) {
res = temp;
id = i;
}
}
}
vector<int> resVe;
cout << res << endl;
while (count_[id] < 2 && id != 0) {
resVe.push_back(id);
id = pre[id];
}
reverse(resVe.begin(), resVe.end());
for (vector<int>::iterator it = resVe.begin(); it != resVe.end(); ++it)
cout << *it << " ";
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int32_t main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> aa;
for (int i = 0; i < n; i += 1) cin >> a[i];
aa = a;
vector<int> b(n);
vector<int> bb;
for (int i = 0; i < n; i += 1) cin >> b[i];
bb = b;
vector<int> c(n);
vector<int> used(n);
vector<int> d(n, n);
while (1 > 0) {
int kol = 0;
for (int i = 0; i < n; i++) kol += used[i];
if (kol == n) break;
int pos = -1;
for (int i = 0; i < n; i++)
if (a[i] == 0 && b[i] == 0 && used[i] == 0) {
pos = i;
break;
}
if (pos == -1) {
cout << "NO";
return 0;
}
for (int i = pos + 1; i < n; i++)
if (a[i] != 0 && !used[i]) --a[i], --d[i];
for (int i = 0; i < pos; i++)
if (b[i] != 0 && !used[i]) --b[i], --d[i];
c[pos] = d[pos];
++used[pos];
}
for (int i = 0; i < n; i++) {
int kol = 0;
for (int j = 0; j < i; j++) kol += (c[i] < c[j]);
if (kol != aa[i]) {
cout << "NO";
return 0;
}
kol = 0;
for (int j = i + 1; j < n; j++) kol += (c[i] < c[j]);
if (kol != bb[i]) {
cout << "NO";
return 0;
}
}
cout << "YES" << '\n';
for (auto &j : c) cout << j << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, x, a, kol = 2;
double b;
vector<pair<int, double> > v;
cin >> n >> t;
for (int i = 0; i < n; i++) {
cin >> x >> a;
b = 1. * a / 2;
v.push_back({x, b});
}
sort(v.begin(), v.end());
for (int i = 0; i < n - 1; i++) {
if (v[i + 1].first - v[i].first < t + v[i].second + v[i + 1].second)
continue;
else {
if (v[i + 1].first - v[i].first > t + v[i].second + v[i + 1].second)
kol += 2;
else
kol++;
}
}
cout << kol;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, can[10004];
set<string> ans;
string s, cur;
int main() {
ios::sync_with_stdio(0);
cin >> s;
n = s.size();
can[n - 1] = 5;
for (int r = n - 3; r >= 4; r--) {
if (can[r + 2]) {
if (can[r + 2] != 2 || s.substr(r + 1, 2) != s.substr(r + 3, 2)) {
can[r] += 2;
ans.insert(s.substr(r + 1, 2));
}
}
if (can[r + 3]) {
if (can[r + 3] != 3 || s.substr(r + 1, 3) != s.substr(r + 4, 3)) {
can[r] += 3;
ans.insert(s.substr(r + 1, 3));
}
}
}
cout << ans.size() << endl;
for (string ss : ans) cout << ss << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 20;
long long n, m, a, d, times, sec, step;
long long t[MAX], cnt, pre[MAX], nxt[MAX];
void process(long long k, long long kr, long long ti) {
long long num = kr - k + 1, aa, k2;
assert(num >= 0);
if (num % step != 0) {
aa = num / step;
times += aa;
k2 = k + aa * step;
} else {
aa = num / step - 1;
assert(aa >= 0);
times += aa;
k2 = k + aa * step;
}
long long k3 = t[ti] - (k2 * a + d);
if (k3 > (long long)0)
times++, sec = d;
else
sec = -k3;
}
int main() {
scanf("%lld %lld %lld %lld", &n, &m, &a, &d);
set<long long> mm;
step = d / a + 1;
for (int i = 0; i < m; ++i) {
scanf("%lld", &t[i]);
if (t[i] % a != 0 || t[i] / a > n) mm.insert(t[i]);
}
cnt = 0;
for (long long ele : mm) t[cnt++] = ele;
times = 1, sec = d;
if (cnt) {
for (int i = 0; i < cnt; ++i) {
long long t1 = t[i] / a;
if (t[i] % a)
pre[i] = t1, nxt[i] = t1 + 1;
else
pre[i] = t1 - 1, nxt[i] = t1 + 1;
}
if (pre[0] >= 1) {
process(1, std::min(pre[0], n), 0);
}
for (int i = 1; i < cnt; ++i) {
if (t[i - 1] + sec >= t[i])
sec = t[i - 1] + sec - t[i];
else {
if (nxt[i - 1] > pre[i]) {
times++, sec = d;
} else {
long long l = std::max((long long)1, nxt[i - 1]);
long long r = std::min(n, pre[i]);
if (l > r) {
times++, sec = d;
} else {
long long bound = t[i - 1] + sec;
times++, sec = d;
if (bound < l * a)
process(l, r, i);
else if (bound < r * a) {
long long t1 = bound / a + 1;
process(t1, r, i);
}
}
}
}
}
long long t1 = (t[cnt - 1] + sec) / a + 1;
if (t1 <= n) {
times++, sec = d;
t1 = n - t1 + 1;
if (t1 % step)
times += t1 / step;
else
times += t1 / step - 1;
}
} else {
if (n % step)
times += n / step;
else
times += n / step - 1;
}
printf("%lld\n", times);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2 * (int)1e5;
const int Q = 1e5;
vector<pair<ll, int>> ques[N];
vector<int> deps[N];
int ins[N];
int res[Q];
void combine(vector<int>& a, vector<int>& b) {
if (a.size() < b.size()) swap(a, b);
for (int j = 1; j <= b.size(); ++j) {
a[a.size() - j] += b[b.size() - j];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> as(n);
for (int i = 0; i < n; ++i) {
cin >> as[i];
--as[i];
++ins[as[i]];
}
int q;
cin >> q;
for (int j = 0; j < q; ++j) {
ll m;
int y;
cin >> m >> y;
ques[y - 1].emplace_back(m, j);
}
vector<int> que;
for (int i = 0; i < n; ++i) {
deps[i] = {1};
if (ins[i] == 0) que.push_back(i);
}
for (int j = 0; j < que.size(); ++j) {
int i = que[j];
for (auto pr : ques[i]) {
ll m = pr.first;
if (deps[i].size() <= m)
res[pr.second] = 0;
else
res[pr.second] = deps[i][deps[i].size() - (m + 1)];
}
deps[i].push_back(0);
combine(deps[as[i]], deps[i]);
--ins[as[i]];
if (ins[as[i]] == 0) que.push_back(as[i]);
deps[i].clear();
deps[i].shrink_to_fit();
}
for (int i = 0; i < n; ++i) {
if (ins[i] == 0) continue;
int len = 0;
vector<int> cur;
for (int j = i;;) {
ins[j] = 0;
++len;
vector<int> bu = deps[j];
combine(cur, bu);
cur.push_back(0);
j = as[j];
if (j == i) break;
}
for (int t = 1; t + len <= cur.size(); ++t) {
cur[cur.size() - t - len] += cur[cur.size() - t];
}
for (int j = i;;) {
combine(cur, deps[j]);
for (auto pr : ques[j]) {
ll ind = (ll)cur.size() - (pr.first + 1);
if (ind < 0) {
ind %= len;
if (ind < 0) ind += len;
}
res[pr.second] = cur[ind];
}
cur.push_back(0);
j = as[j];
if (j == i) break;
}
}
for (int i = 0; i < q; ++i) cout << res[i] << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long n, q, ans, dsum;
long long gcd(long long a, long long b) {
while (a && b) a > b ? a %= b : b %= a;
return a + b;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> q;
v.push_back(q);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
ans += 1ll * v[i] * i - dsum;
dsum += v[i];
}
ans *= 2;
for (int i = 0; i < v.size(); i++) ans += v[i];
long long q = gcd(ans, n);
cout << ans / q << " " << n / q << endl;
cin.get();
cin.get();
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.