solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a1[28], a2[28];
int main() {
int n;
cin >> n;
string x1, x2;
cin >> x1 >> x2;
int pos1 = -1;
while (x1[pos1 + 1] == x2[pos1 + 1] && pos1 + 1 <= n) pos1++;
if (pos1 != -1) {
x1.erase(0, pos1 + 1);
x2.erase(0, pos1 + 1);
}
int psidad;
int pos2 = x1.length();
while (x1[pos2 - 1] == x2[pos2 - 1] && pos2 >= 1) pos2--;
if (pos2 != x1.length()) {
x1.erase(x1.begin() + pos2, x1.end());
x2.erase(x2.begin() + pos2, x2.end());
}
int ans = 0;
string t = x1.substr(1);
string tt = x2;
tt.erase(tt.begin() + tt.length() - 1, tt.end());
if (tt.compare(t) == 0) ans++;
t = x2.substr(1);
tt = x1;
tt.erase(tt.begin() + tt.length() - 1, tt.end());
if (tt.compare(t) == 0) ans++;
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int inf = 1e5 + 7;
long long int n, m, fin;
vector<long long int> v;
bool fine(long long int mid) {
long long int prev = 0;
for (long long int i = 0; i < n; ++i) {
if (prev <= v[i]) {
long long int k = m - (v[i] - prev);
if (k > mid) prev = v[i];
} else {
long long int k = prev - v[i];
if (k > mid) return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
v.resize(n);
for (long long int i = 0; i < n; ++i) cin >> v[i];
long long int l, r;
l = 0, r = m;
while ((r - l) > 1) {
long long int mid = l + (r - l) / 2;
if (fine(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
if (fine(l)) return cout << l, 0;
cout << r;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,sse4,fma4,ssse3,popcnt,abm,aes,pclmul")
#pragma comment(linker, "/STACK:66777216")
using namespace std;
static unsigned rnd() {
static int second = 124612741;
second ^= second << 13;
second ^= second >> 17;
return second ^= second << 5;
}
inline int fpow(int a, int st, int mod) {
int ans = 1;
while (st) {
if (st % 2) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
st /= 2;
}
return ans;
}
int invmod(int first, int second) {
int a = 1, b = 0, k;
for (; second; swap(first, second), swap(a, b)) {
k = first / second;
first -= second * k;
a -= b * k;
}
return a + max(b, 0);
}
inline int calcBits(int a) { return __builtin_popcount(a); }
struct Hash {
Hash() : x1(0), x2(0) {}
Hash(const int& x1, const int& x2) : x1(x1), x2(x2) {}
int x1, x2;
static int mod1, mod2;
static int p1, p2;
static int invp1, invp2;
static bool initCalled;
static const Hash ONE, ZERO, INVALID;
static Hash UNIT, INV_UNIT;
static bool prime(int a) {
if (a == 1) return 0;
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
static int pickModHelper(int start, int bad) {
int mn = 1000000000, best = -1;
for (int _n(start + 1000), i(start); i <= _n; i++) {
if (i == bad || !prime(i)) continue;
int cur = calcBits(i);
if (cur < mn) {
mn = cur;
best = i;
}
}
return best;
}
static void init() {
if (initCalled) return;
initCalled = true;
mod1 = 1 << 30;
while (!prime(mod1)) ++mod1;
mod2 = pickModHelper((1 << 29) + rnd() % 1000000, mod1);
invp1 = invmod(p1, mod1);
invp2 = invmod(p2, mod2);
INV_UNIT = Hash(invp1, invp2);
}
inline Hash& operator+=(const Hash& other) {
x1 += other.x1;
if (x1 >= Hash::mod1) x1 -= Hash::mod1;
x2 += other.x2;
if (x2 >= Hash::mod2) x2 -= Hash::mod2;
return *this;
}
inline Hash& operator-=(const Hash& other) {
x1 -= other.x1;
if (x1 < 0) x1 += Hash::mod1;
x2 -= other.x2;
if (x2 < 0) x2 += Hash::mod2;
return *this;
}
inline Hash& operator*=(const Hash& other) {
x1 = (long long)x1 * other.x1 % Hash::mod1;
x2 = (long long)x2 * other.x2 % Hash::mod2;
return *this;
}
inline Hash& operator*=(const int& other) {
x1 = (long long)x1 * other % Hash::mod1;
x2 = (long long)x2 * other % Hash::mod2;
return *this;
}
inline Hash& operator^=(const int& power) {
int st = power;
Hash ans(1, 1);
while (st) {
if (st % 2) ans *= *this;
x1 = (long long)x1 * x1 % Hash::mod1;
x2 = (long long)x2 * x2 % Hash::mod2;
st /= 2;
}
return *this;
}
inline bool operator==(const Hash& other) const {
return x1 == other.x1 && x2 == other.x2;
}
};
bool Hash::initCalled = false;
int Hash::mod1 = 0;
int Hash::mod2 = 0;
int Hash::p1 = 23561;
int Hash::p2 = 10000019;
int Hash::invp1 = -1;
int Hash::invp2 = -1;
const Hash Hash::ONE(1, 1);
const Hash Hash::ZERO(0, 0);
const Hash Hash::INVALID(-1, -1);
Hash Hash::UNIT(Hash::p1, Hash::p2);
Hash Hash::INV_UNIT(-1, -1);
inline Hash operator+(const Hash& a, const Hash& b) {
Hash ans(a.x1 + b.x1, a.x2 + b.x2);
if (ans.x1 >= Hash::mod1) ans.x1 -= Hash::mod1;
if (ans.x2 >= Hash::mod2) ans.x2 -= Hash::mod2;
return ans;
}
inline Hash operator-(const Hash& a, const Hash& b) {
Hash ans(a.x1 - b.x1, a.x2 - b.x2);
if (ans.x1 < 0) ans.x1 += Hash::mod1;
if (ans.x2 < 0) ans.x2 += Hash::mod2;
return ans;
}
inline Hash operator*(const Hash& a, const Hash& b) {
return Hash((long long)a.x1 * b.x1 % Hash::mod1,
(long long)a.x2 * b.x2 % Hash::mod2);
}
inline Hash operator*(const Hash& a, const int& b) {
return Hash((long long)a.x1 * b % Hash::mod1,
(long long)a.x2 * b % Hash::mod2);
}
inline Hash operator^(const Hash& a, const int& power) {
int st = power;
Hash ans(1, 1), cur(a);
while (st) {
if (st % 2) ans *= cur;
cur *= cur;
st /= 2;
}
return ans;
}
inline Hash fpow(const Hash& a, const int& power) { return a ^ power; }
inline Hash invmod(const Hash& a) {
return Hash(invmod(a.x1, Hash::mod1), invmod(a.x2, Hash::mod2));
}
template <class H>
struct HashString : public string {
HashString() : string() { precalc(0); }
HashString(const HashString& other) : string(other) { precalc(size()); }
HashString(HashString&& other)
: hh(std::move(other.hh)), string(std::move(other)) {
precalc(size());
}
HashString(const string& other) : string(other) {
precalc(size());
build();
}
HashString(string&& other) : string(std::move(other)) {
precalc(size());
build();
}
HashString(const char* other) : string(other) {
precalc(size());
build();
}
inline void clear() {
hh.clear();
string::clear();
}
inline static H getPow(int p) {
if (p < haveN) {
return pp[p];
} else {
return fpow(H::UNIT, p);
}
}
inline static H getInvPow(size_t p) {
if (p < invpp.size()) {
return invpp[p];
} else {
return fpow(H::INV_UNIT, p);
}
}
inline H getInvRegister(const H& p) const {
if (p == register_) {
return registerValue_;
} else {
register_ = p;
return registerValue_ = invmod(p);
}
}
static void precalc(int N = 0) {
Hash::init();
if (haveN >= N) return;
pp.resize(N);
invpp.resize(N);
if (!haveN) {
pp[0] = H::ONE;
invpp[0] = H::ONE;
haveN = 1;
}
for (int i = haveN; i < N; ++i) {
pp[i] = pp[i - 1] * H::UNIT;
invpp[i] = invpp[i - 1] * H::INV_UNIT;
}
haveN = N;
}
inline void build() {
int curSize = size();
if (haveN <= curSize) {
precalc(curSize);
}
for (int i = hh.size(); i < curSize; ++i) {
H pr = i ? hh.back() : H::ZERO;
hh.push_back(pr + getPow(i) * (*this)[i]);
}
}
inline H getHash(int pos, int len) const {
if (len <= 0) return H::ZERO;
const int S = size();
if (pos + len - 1 < S) {
H ans = hh[pos + len - 1];
if (pos) {
ans -= hh[pos - 1];
ans *= getInvPow(pos);
}
return ans;
} else {
H head = hh.back();
if (pos) {
head -= hh[pos - 1];
head *= getInvPow(pos);
}
int full = -1, en = -1;
H mid = H::ZERO;
int midlen = 0;
if (len <= S) {
en = pos + len - 1 - S;
H tail = hh[en];
full = 0;
return head + tail * getPow(S - pos);
} else {
en = (pos + len - 1) % S;
H tail = hh[en];
full = (len - (S - pos) - (en + 1)) / S;
mid = hh.back() * (H::ONE - getInvPow(full * S)) *
getInvRegister(H::ONE - getInvPow(S));
return head + mid * getPow(S - pos) + tail * getPow(len - (en + 1));
}
}
}
inline HashString& operator+=(const char& ch) {
string::operator+=(ch);
build();
return *this;
}
inline HashString& operator+=(const HashString& other) {
string::operator+=(other);
build();
return *this;
}
inline bool operator==(const HashString& other) const {
return hh.back() == other.hh.back();
}
inline bool operator<(const HashString& other) const {
int s1 = size();
int s2 = other.size();
const int S = min(s1, s2);
int l = 0, r = S + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
if (getHash(0, xx) == other.getHash(0, xx))
l = xx;
else
r = xx;
}
char c1 = 0, c2 = 0;
if (l < s1) c1 = (*this)[l];
if (l < s2) c2 = other[l];
return c1 < c2;
}
inline bool operator<=(const HashString& other) const {
return (*this == other) || (*this < other);
}
inline bool operator>(const HashString& other) const {
return !(*this == other) && !(*this < other);
}
inline bool operator>=(const HashString& other) const {
return !(*this < other);
}
inline bool operator!=(const HashString& other) const {
return !(*this == other);
}
inline void reserve(int N) {
hh.reserve(N);
string::reserve(N);
}
vector<H> hh;
static vector<H> pp, invpp;
private:
mutable H register_, registerValue_;
static int haveN;
};
template <>
int HashString<Hash>::haveN = 0;
template <>
vector<Hash> HashString<Hash>::pp = vector<Hash>();
template <>
vector<Hash> HashString<Hash>::invpp = vector<Hash>();
template <class H, bool cyclic = true>
struct HashStringPiece {
explicit HashStringPiece(const HashString<H>& s, int pos, int len)
: s(s), pos(pos), len(len), hash(H::INVALID) {}
inline H getHash() const {
if (hash == H::INVALID) hash = s.getHash(pos, len);
return hash;
}
inline H getPartialHash(int needLen) const { return s.getHash(pos, needLen); }
inline char getChar(int i) const {
i += pos;
const int S = s.size();
if (i < S) return s[i];
if (!cyclic) return 0;
i -= S;
if (i < S) return s[i];
return s[i % S];
}
const HashString<H>& s;
const int pos, len;
mutable H hash;
};
template <class H, class T>
char getHSPRangeChar(T beg, T en, int pos) {
for (T it = beg; it != en; ++it) {
if (pos < it->len) {
return it->getChar(pos);
}
pos -= it->len;
}
return 0;
}
template <class H, class T>
H getHSPRangeHash(T beg, T en, int len) {
H ans = H::ZERO;
int cur = 0;
for (T it = beg; it != en; ++it) {
if (len >= it->len) {
ans += it->getHash() * it->s.getPow(cur);
cur += it->len;
len -= it->len;
} else {
ans += it->getPartialHash(len) * it->s.getPow(cur);
break;
}
}
return ans;
}
int TB, IT;
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, int len1, T beg2, T en2, int len2) {
if (beg1 == en1 && beg2 == en2) return 0;
if (beg1 == en1) return -1;
if (beg2 == en2) return 1;
int l = 0, r = min(len1, len2) + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
auto h1 = getHSPRangeHash<H, T>(beg1, en1, xx);
auto h2 = getHSPRangeHash<H, T>(beg2, en2, xx);
if (h1 == h2)
l = xx;
else
r = xx;
}
char c1 = getHSPRangeChar<H, T>(beg1, en1, l);
char c2 = getHSPRangeChar<H, T>(beg2, en2, l);
if (c1 < c2)
return -1;
else if (c1 == c2)
return 0;
else
return 1;
}
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, T beg2, T en2) {
int len1 = 0;
for (T it = beg1; it != en1; ++it) {
len1 += it->len;
}
int len2 = 0;
for (T it = beg2; it != en2; ++it) {
len2 += it->len;
}
return compareHSPRanges<H, T>(beg1, en1, len1, beg2, en2, len2);
}
int a, b, c, d, n, m, k;
char str[1000002];
int bal[2000002];
HashString<Hash> s;
inline string build(pair<pair<int, int>, int> a) {
string ans = "";
for (int _n((a.first.first) - 1), i(0); i <= _n; i++) ans += '(';
for (int _n((n)-1), i(0); i <= _n; i++) {
int cur = a.second + i;
if (cur >= n) cur -= n;
ans += str[cur];
}
for (int _n((a.first.second) - 1), i(0); i <= _n; i++) ans += ')';
return ans;
}
HashString<Hash> op, cl;
inline bool better(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b,
const HashString<Hash>& s) {
HashStringPiece<Hash> A[3] = {HashStringPiece<Hash>(op, 0, a.first.first),
HashStringPiece<Hash>(s, a.second, n),
HashStringPiece<Hash>(cl, 0, a.first.second)};
HashStringPiece<Hash> B[3] = {HashStringPiece<Hash>(op, 0, b.first.first),
HashStringPiece<Hash>(s, b.second, n),
HashStringPiece<Hash>(cl, 0, b.first.second)};
int t = compareHSPRanges<Hash>(A, A + 3, B, B + 3);
if (t == -1)
return 1;
else
return 0;
}
int main() {
gets(str);
n = (int)strlen(str);
HashString<Hash> s(str);
HashString<Hash>::precalc(2 * n + 1);
op.reserve(n + 1);
cl.reserve(n + 1);
for (int _n((n)-1), i(0); i <= _n; i++) {
op += '(';
cl += ')';
}
c = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (str[i] == '(')
++c;
else
--c;
}
bal[0] = 0;
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
if (i) bal[i] = bal[i - 1];
int cur = i;
if (i >= n) cur = i - n;
if (str[cur] == '(')
++bal[i];
else
--bal[i];
}
int blen = 1000000000;
pair<pair<int, int>, int> best = make_pair(make_pair(0, 0), 0);
stack<pair<int, int> > s1, s2;
for (int _n((n)-1), i(0); i <= _n; i++) {
int new_element = bal[i];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
for (int _n((n)-1), cyc(0); cyc <= _n; cyc++) {
int current_minimum = -1000000000;
if (s1.empty() || s2.empty())
current_minimum = s1.empty() ? s2.top().second : s1.top().second;
else
current_minimum = min(s1.top().second, s2.top().second);
int p = 0;
if (cyc) p = bal[cyc - 1];
int mn = current_minimum - p;
int beg = max(0, -mn);
int en = c + beg;
int len = beg + en + n;
if (len < blen ||
(len == blen && better(make_pair(make_pair(beg, en), cyc), best, s))) {
blen = len;
best = make_pair(make_pair(beg, en), cyc);
}
if (s2.empty()) {
while (!s1.empty()) {
int element = s1.top().first;
s1.pop();
int minima = s2.empty() ? element : min(element, s2.top().second);
s2.push(make_pair(element, minima));
}
}
s2.pop();
int new_element = bal[cyc + n];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
string ans = build(best);
printf("%s\n", ans.c_str());
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
int n, no, ye;
vector<int> a[1000];
bool noo(int i, int j, int k) {
for (int ii = 0; ii < a[i].size(); ++ii)
if (a[i][ii] == j || a[i][ii] == k) return 0;
return 1;
}
bool yes(int i, int j, int k) {
bool q = 0, w = 0;
for (int ii = 0; ii < a[i].size(); ++ii) {
if (a[i][ii] == j) q = 1;
if (a[i][ii] == k) w = 1;
}
if (q && w) return 1;
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
int q, w;
cin >> q >> w;
--q, --w;
a[q].push_back(w);
a[w].push_back(q);
}
for (int i = 0; i < 3; ++i) {
for (int j = i + 1; j < 4; ++j)
for (int k = j + 1; k < 5; ++k) {
if (noo(i, j, k) && noo(k, j, i) && noo(j, i, k)) {
no = 1;
}
if (yes(i, j, k) && yes(k, j, i) && yes(j, i, k)) ye = 1;
}
}
if (ye || no)
cout << "WIN";
else
cout << "FAIL";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
y = 1;
x = 0;
return a;
} else {
long long ret = exgcd(b, a % b, y, x);
y -= a / b * x;
return ret;
}
}
long long extend_Euclid(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long r = extend_Euclid(b, a % b, y, x);
y -= a / b * x;
return r;
}
long long equation(long long a, long long b, long long c, long long &x,
long long &y) {
long long g = extend_Euclid(a, b, x, y);
if (c % g == 0) {
long long mod = b / g;
x *= c / g;
if (mod < 0) mod = -mod;
x = (x % mod + mod) % mod;
return 0;
}
return -1;
}
long long INF;
inline long long doSolve(int dx, int dy) {
long long k, s;
if (equation(2 * n, -2 * m, -dx + dy, k, s) == -1) return INF + 1;
long long tim = 2 * k * n + dx;
if (tim < 0 || tim > INF) return INF + 1;
return tim;
}
long long solve(long long x, long long y) {
long long g = gcd(n, m);
INF = (long long)m / g * n;
long long ans = INF + 1;
ans = min(ans, doSolve(-x, -y));
ans = min(ans, doSolve(-x, y));
ans = min(ans, doSolve(x, -y));
ans = min(ans, doSolve(x, y));
if (ans == INF + 1) return -1;
return ans;
}
int main() {
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d%d", &x, &y);
printf("%I64d\n", solve(x, y));
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int MOD = (int)998244353;
const int INF = (int)1e18;
bool cmp(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return a.second < b.second;
}
string modify(string s, long long n, long long k) {
string pre = s.substr(k - 1, n - k + 1);
string suf = s.substr(0, k - 1);
if ((n - k + 1) & 1) {
reverse(suf.begin(), suf.end());
}
return pre + suf;
}
void solve() {
long long n, cnt = 0, ans = 1;
string s, anss, temp;
cin >> n >> s;
anss = s;
for (long long i = 2; i < n + 1; i++) {
temp = modify(s, n, i);
if (temp < anss) {
anss = temp;
ans = i;
}
}
cout << anss << '\n' << ans << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename T>
void _R(T& x) {
cin >> x;
}
template <typename T>
void _R(vector<T>& x) {
for (auto it = x.begin(); it != x.end(); it++) {
_R(*it);
}
}
void R() {}
template <typename T, typename... K>
void R(T& head, K&... tail) {
_R(head);
R(tail...);
}
template <typename T>
void _W(const T& x, const char c) {
cout << x;
}
template <typename T>
void _W(const vector<T>& x, const char c) {
for (auto it = x.cbegin(); it != x.cend(); it++) {
if (it != x.cbegin()) putchar(c);
_W(*it, c);
}
}
void W() {}
template <typename T, typename... K>
void W(const T& head, const K&... tail) {
_W(head, ' ');
cout << (sizeof...(tail) ? ' ' : '\n') << flush;
W(tail...);
}
const double PI =
3.14159265358979323846264338327950288419716939937510582097494459230;
template <typename T>
inline T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
inline void amin(T& x, T y) {
if (x > y) x = y;
}
template <typename T>
inline void amax(T& x, T y) {
if (x < y) x = y;
}
template <typename A, typename B>
class comp {
public:
bool operator()(const pair<A, B>& a, const pair<A, B>& b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.first > b.first;
}
};
long long fast_exp(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1LL) {
res *= a;
res %= 1000000007;
}
b >>= 1LL;
a *= a;
a %= 1000000007;
}
return res;
}
void preprocess(void) { return; }
signed main(int argc, char* argv[], char* envp[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
cerr << fixed;
cout << fixed;
preprocess();
int teeee;
teeee = 1;
for (int zeeee = (1); zeeee <= (teeee); zeeee++) {
int n, m;
cin >> n >> m;
vector<int> ans1(2230);
vector<int> ans2(2230);
int x1 = 0;
int p1 = 0;
while (x1 < n) {
ans2[p1] = 0;
ans1[p1++] = 9;
x1 += 9;
}
int x2 = 0;
while (x2 < n + 1) {
ans2[p1] = 9;
ans1[p1++] = 0;
x2 += 9;
}
p1--;
ans1[p1] = 1;
ans2[p1] = 8;
p1++;
for (int i = p1 - 1; i >= 0; i--) {
cout << ans1[i];
}
cout << endl;
ans2[0] = 1;
for (int i = p1 - 1; i >= 0; i--) {
cout << ans2[i];
}
cout << endl;
}
cerr << (((double)clock()) / ((double)CLOCKS_PER_SEC)) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 5;
const long long mod = 1e9 + 7;
using namespace std;
char s[maxn];
long long ci(long long x, long long t) {
long long res = 1;
while (t) {
if (t & 1) res *= x;
t >>= 1;
x *= x;
}
return res;
}
long long dd(int x) {
long long res = 0;
while (x) {
if (x % 2) res++;
x /= 2;
}
return 6 - res;
}
long long ans = 1;
int main() {
scanf("%s", s + 1);
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
if (s[i] >= '0' && s[i] <= '9')
ans *= ci(3LL, dd(s[i] - '0')), ans %= mod;
else if (s[i] >= 'A' && s[i] <= 'Z')
ans *= ci(3LL, dd(s[i] - 'A' + 10)), ans %= mod;
else if (s[i] >= 'a' && s[i] <= 'z')
ans *= ci(3LL, dd(s[i] - 'a' + 36)), ans %= mod;
else if (s[i] == '-')
ans *= 3LL, ans %= mod;
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include<iostream>
#include<unordered_map>
#include<algorithm>
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
int n;
cin>>n;
string s;
cin>>s;
int c=0;
for(int i=0;i<n;i++){
int j=i;
if(s[i]!=s[i+1]){
for(int k=j+1;k<n;k++){
if(s[i]==s[k]){
c=1;
break;
}
}
}
}
if(c==1){
cout<<"NO"<<"\n";
}else{
cout<<"YES"<<"\n";
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int sum, add, lo, hi;
Node *le, *ri;
static Node* Build(int lo, int hi) {
Node* root = new Node();
root->lo = lo, root->hi = hi;
root->sum = root->add = 0;
root->le = root->ri = NULL;
if (lo != hi)
root->le = Build(lo, (lo + hi) >> 1),
root->ri = Build(((lo + hi) >> 1) + 1, hi);
return root;
}
void PushDown() {
if (add == 0) return;
if (le) {
le->add += add;
ri->add += add;
le->sum += add * (le->hi - le->lo + 1);
ri->sum += add * (ri->hi - ri->lo + 1);
add = 0;
}
}
void Add(int fr, int to, int how) {
if (to < lo || fr > hi) return;
if (fr <= lo && hi <= to) {
add += how;
sum += (hi - lo + 1) * how;
} else {
PushDown();
le->Add(fr, to, how);
ri->Add(fr, to, how);
sum = le->sum + ri->sum;
}
}
int Get(int fr, int to) {
if (fr > to) return 0;
if (to < lo || fr > hi) return 0;
if (fr <= lo && hi <= to) return sum;
PushDown();
return le->Get(fr, to) + ri->Get(fr, to);
}
};
int main() {
int n, k, a, b, q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
Node* pref = Node::Build(0, n - 1);
Node* suff = Node::Build(0, n - 1);
vector<int> pref_c(n, 0), suff_c(n, 0);
for (int i = 0; i < q; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, add;
scanf("%d%d", &d, &add);
--d;
int ptake = min(b - pref_c[d], add);
int stake = min(a - suff_c[d], add);
pref_c[d] += ptake;
suff_c[d] += stake;
pref->Add(d, n - 1, ptake);
suff->Add(0, d, stake);
} else {
int p;
scanf("%d", &p);
--p;
int ans = 0;
if (p) ans += pref->Get(p - 1, p - 1);
if (p + k < n) ans += suff->Get(p + k, p + k);
printf("%d\n", ans);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
string a, s;
cin >> a >> s;
int h[26] = {0};
int i = 0;
while (i < a.length()) {
int c = a[i] - 'a';
h[c]++;
i++;
}
int p = 0, flag = 0;
int q = p + a.length() - 1;
while (q < s.length()) {
int f[26] = {0};
for (int k = p; k <= q; k++) {
int c = s[k] - 'a';
f[c]++;
}
flag = 1;
for (int k = 0; k < 26; k++) {
if (h[k] != f[k]) {
flag = 0;
break;
}
}
if (flag == 1) {
break;
}
p++;
q++;
}
if (flag == 1)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int sum = 0, a, n, m, i;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
sum = sum + i;
if (m > sum && i == n) {
i = 0;
}
a = m - sum;
if (a < i + 1) {
printf("%d", a);
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, sum = 0, t = 0, ans = 0;
scanf("%d", &x);
int y[x];
for (int i = 0; i < x; i++) {
scanf("%d", &y[i]);
sum += y[i];
}
sort(y, y + x);
for (int i = x - 1; i >= 0; i--) {
t += y[i];
sum -= y[i];
ans++;
if (t > sum) break;
}
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
inline ostream &operator<<(ostream &os, const pair<A, B> &v) {
return os << v.first << ' ' << v.second;
}
template <typename A>
inline ostream &operator<<(ostream &os, const vector<A> &v) {
auto it = v.begin();
os << *it;
for (++it; it != v.end(); os << ' ' << *it++)
;
return os;
}
void tr() { cout << '\n'; }
template <typename H, typename... T>
inline void tr(H head, T... tail) {
cerr << head << ' ';
tr(tail...);
}
void solve(string &s) {
int len = s.length();
vector<int> ans(len, 0);
int k = 0, t = 0;
for (int i = 0; i < len; i++) {
if (s[i] == 'M')
t = 1;
else {
if (t) ans[k] = !k ? i - k : max(ans[k - 1] + 1, i - k);
k++;
}
}
k > 0 ? cout << ans[k - 1] : cout << 0;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string s;
cin >> s;
solve(s);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int maxn = (int)1e6;
const int mod = (int)1e9 + 7;
using namespace std;
long long n, ans = 1;
int main() {
scanf("%I64d", &n);
for (int i = n - 4; i <= n; i++) {
ans *= i;
}
for (int i = 2; i <= 5; i++) {
ans /= i;
}
ans = ans * ans;
ans *= 120;
printf("%I64d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool check(int n) {
bool flags[10] = {false};
int cont = 0;
while (n > 0) {
if (!flags[n % 10]) cont++;
flags[n % 10] = true;
n /= 10;
}
return cont == 4;
}
int main() {
int n;
cin >> n;
while (true) {
n++;
if (check(n)) break;
}
cout << n;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read(register T& t) {
register T f = 1;
register char ch = getchar();
t = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') t = t * 10 + ch - '0', ch = getchar();
t *= f;
return t;
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
const long long p = 998244353;
inline long long power(register long long x, register long long k = p - 2) {
register long long re = 1;
for (; k; k >>= 1, x = (x * x) % p)
if (k & 1) re = (re * x) % p;
return re;
}
int n, m;
template <int T>
struct UFS {
int fa[T + 1];
int size[T + 1];
int tim[T + 1];
UFS() {
for (int i = 1; i <= T; i++) fa[i] = i, size[i] = 1;
}
inline int find(int x) {
if (fa[x] == x) return x;
return find(fa[x]);
}
inline void merge(int x, int y, int ti) {
int fat = find(x), fbt = find(y);
if (fat == fbt) return;
if (size[fat] > size[fbt]) swap(fat, fbt);
fa[fat] = fbt;
size[fbt] += size[fat];
tim[fat] = ti;
}
};
UFS<500000> S, T;
vector<pair<int, long long> > add[500005];
int cls[500005];
int main() {
read(n, m);
for (int i = 1; i <= n; i++) add[i].push_back(make_pair(-1, 0));
for (int qwq = 1; qwq <= m; qwq++) {
char opt[3];
scanf("%s", opt);
if (opt[0] == 'U') {
int x, y;
read(x, y);
S.merge(x, y, qwq);
}
if (opt[0] == 'M') {
int x, y;
read(x, y);
T.merge(x, y, qwq);
}
if (opt[0] == 'A') {
int x;
read(x);
x = S.find(x);
long long ad = S.size[x] + add[x].rbegin()->second;
add[x].push_back(make_pair(qwq, ad));
}
if (opt[0] == 'Z') {
int x;
read(x);
x = T.find(x);
cls[x] = qwq;
}
if (opt[0] == 'Q') {
int x;
read(x);
int tp = x;
int tag = cls[tp];
int tt = 0;
while (1) {
if (tt < cls[tp]) tag = max(tag, cls[tp]);
if (tp == T.fa[tp]) break;
tt = T.tim[tp];
tp = T.fa[tp];
}
long long ans = 0;
int ti = 0;
while (1) {
auto id = lower_bound(add[x].begin(), add[x].end(),
make_pair(max(tag, ti), 0ll));
ans += add[x].rbegin()->second - (id - 1)->second;
if (x == S.fa[x]) break;
ti = S.tim[x];
x = S.fa[x];
}
printf("%lld\n", ans);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> data(n);
for (int i = 0; i < (n); ++i) cin >> data[i];
vector<int> tmp(n);
for (int k = 0; k < (n - 1); ++k) {
for (int j = 0; j < (n); ++j) tmp[j] = data[j];
int ans = 0;
for (int i = 0; i < (k + 1); ++i) {
int next_index = 1;
while (next_index * 2 + i < n) next_index <<= 1;
tmp[next_index + i] += tmp[i];
ans += tmp[i];
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, sum = 0;
cin >> n;
long long arr[n];
for (long long i = 1; i <= n; i++) cin >> arr[i];
sort(arr + 1, arr + 1 + n);
if (n == 1)
cout << arr[1] << "\n";
else {
int k = 2;
for (long long i = 1; i <= (n - 1); i++) {
sum += k * arr[i];
k++;
}
sum += n * arr[n];
cout << sum << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<string> s;
string str;
int isadj(string s) {
if (s.size() >= 4 && !s.compare(s.size() - 4, 4, "lios"))
return 2;
else if (s.size() >= 5 && !s.compare(s.size() - 5, 5, "liala"))
return 1;
else
return 0;
}
int isn(string s) {
if (s.size() >= 3 && !s.compare(s.size() - 3, 3, "etr"))
return 2;
else if (s.size() >= 4 && !s.compare(s.size() - 4, 4, "etra"))
return 1;
else
return 0;
}
int isv(string s) {
if (s.size() >= 6 && !s.compare(s.size() - 6, 6, "initis"))
return 2;
else if (s.size() >= 6 && !s.compare(s.size() - 6, 6, "inites"))
return 1;
else
return 0;
}
int main() {
while (cin >> str) {
s.push_back(str);
}
int i = 0;
int fail = 0;
int gen = -1;
int gen1 = -2;
while (i < s.size() && (gen1 = isadj(s[i]))) {
if (i >= 1 && gen1 != gen) fail = 1;
if (gen1 == 0) fail = 1;
gen = gen1;
i++;
}
if (i < s.size()) {
gen1 = isn(s[i]);
}
if (i > 0 && gen1 != gen) {
fail = 1;
}
if (gen1 == 0) fail = 1;
if (!fail) {
gen = gen1;
i++;
}
while (i < s.size() && (gen1 = isv(s[i]))) {
if (gen1 != gen) fail = 1;
if (gen1 == 0) fail = 1;
gen = gen1;
i++;
}
if ((fail == 0 && i == s.size()) ||
(s.size() == 1 && (isn(s[0]) > 0 || isv(s[0]) > 0 || isadj(s[0]) > 0)))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int arr[200001];
int dfs(vector<int> graph[], int k) {
v.push_back(k);
int a = 0;
for (auto i : graph[k]) {
a += 1 + dfs(graph, i);
}
arr[k] = a;
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
vector<int> graph[n + 1];
for (int i = 0; i < n - 1; i++) {
int temp;
cin >> temp;
graph[temp].push_back(i + 2);
}
dfs(graph, 1);
map<int, int> mp;
for (int i = 0; i < v.size(); i++) {
mp[v[i]] = i;
}
while (q--) {
int u, k;
cin >> u >> k;
int index1 = mp[u];
if (k <= arr[u] + 1) {
cout << v[index1 + k - 1] << endl;
} else {
cout << -1 << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 512345;
long long a[N];
long long b;
int n, k;
long long a2[N];
int main() {
cin >> n >> k >> b;
for (int i = (1); i <= (int)(n); i++) cin >> a[i];
int ans = n;
--n;
for (int i = (1); i <= (int)(n); i++) a2[i] = a[i];
sort(a2 + 1, a2 + n + 1);
reverse(a2 + 1, a2 + n + 1);
long long s = 0LL;
for (int i = (1); i <= (int)(k); i++) {
s += a2[i];
}
for (int i = (1); i <= (int)(n); i++) {
long long t = s;
if (a[i] < a2[k]) {
t = s - a2[k] + a[i];
}
if (t > b) {
ans = i;
break;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
vector<string> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<pair<int, int> > ans;
map<pair<int, int>, int> M;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '.') {
queue<pair<int, int> > q;
q.push({i, j});
while (!q.empty()) {
pair<int, int> x = q.front();
q.pop();
if (M.count(x)) continue;
M[x]++;
if (x.first >= 0 && x.second >= 0 && x.first < n && x.second < m) {
if (a[x.first][x.second] == '.')
ans.push_back(x);
else
continue;
} else
continue;
if (!M.count({x.first + 1, x.second}))
q.push({x.first + 1, x.second});
if (!M.count({x.first - 1, x.second}))
q.push({x.first - 1, x.second});
if (!M.count({x.first, x.second + 1}))
q.push({x.first, x.second + 1});
if (!M.count({x.first, x.second - 1}))
q.push({x.first, x.second - 1});
}
for (int i = ans.size() - 1; i >= 0; i--) {
if (!k) break;
a[ans[i].first][ans[i].second] = 'X';
k--;
}
for (int i = 0; i < n; i++) cout << a[i] << '\n';
return 0;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double INF = 1e100;
const double EPS = 1e-9;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
template <class T>
T gcd(const T a, const T b) {
return (b ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(const T a, const T b) {
return (a / gcd<T>(a, b) * b);
}
struct node {
long long x, y;
node() {}
node(long long x, long long y) : x(x), y(y) {}
bool operator<(const node& p) const { return x < p.x; }
};
int main() {
long long i, j, k, l, x, y, z, t, m, n, l1, l2, a, b;
scanf("%lld %lld", &a, &b);
scanf("%lld %lld %lld", &x, &y, &z);
long long a1 = 0, b1 = 0;
a1 = x * 2;
a1 += (y);
b1 = y;
b1 += (3 * z);
a = a1 - a;
b = b1 - b;
if (a < 0) a = 0;
if (b < 0) b = 0;
deb(a + b);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1510, MAXM = 1510;
int n, m, sum;
int ans[MAXN], son[MAXN], last[MAXN];
struct Edge {
int link, to;
} edge[MAXM << 1];
struct Node {
int real;
long long x, y;
} a[MAXN], tmp;
inline void add(int u, int v) {
edge[++sum] = (Edge){v, last[u]}, last[u] = sum;
return;
}
inline int cmp1(Node a, Node b) { return a.x < b.x || a.x == b.x && a.y < b.y; }
inline int cmp2(Node P1, Node P2) {
return (tmp.x - P1.x) * (tmp.y - P2.y) < (tmp.x - P2.x) * (tmp.y - P1.y);
}
void dfs1(int x, int fa) {
son[x] = 1;
for (int i = last[x]; i; i = edge[i].to) {
int y = edge[i].link;
if (y == fa) continue;
dfs1(y, x);
son[x] += son[y];
}
return;
}
void dfs2(int x, int fa, int l, int r) {
sort(a + l, a + r + 1, cmp1);
ans[a[l].real] = x, tmp = a[l];
sort(a + l + 1, a + r + 1, cmp2);
int L = l + 1;
for (int i = last[x]; i; i = edge[i].to) {
int y = edge[i].link;
if (y == fa) continue;
dfs2(y, x, L, L + son[y] - 1), L += son[y];
}
return;
}
int main() {
scanf("%d", &n);
for (register int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v), add(v, u);
}
for (register int i = 1; i <= n; ++i) {
scanf("%lld%lld", &a[i].x, &a[i].y);
a[i].real = i;
}
dfs1(1, 0);
dfs2(1, 0, 1, n);
for (register int i = 1; i < n; ++i) printf("%d ", ans[i]);
printf("%d\n", ans[n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long A[2000005];
int main() {
int n, m, L, T, i, j, k, l;
double l1, ans = 0, xx, t1;
scanf("%d%d%d", &n, &L, &T);
xx = (((long long)2) * T) / L;
t1 = ((((long long)2) * T) % L) / 2.0;
for (i = 1; i <= n; i++) {
scanf("%d", &j);
A[i] = j;
}
sort(A + 1, A + 1 + n);
for (i = n + 1; i <= n + n; i++) A[i] = A[i - n] + L;
if (n == 1) {
printf("0\n");
n = 2;
return 0;
}
for (j = 2; j <= n; j++)
if (2 * t1 + (1e-9) < A[j] - A[i]) break;
j--;
for (i = 1; i <= n; i++) {
while (2 * t1 + (1e-9) > A[j] - A[i]) j++;
j--;
ans += 0.25 * (xx * (n - 1) + (j - i));
}
printf("%.8f\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
using vi = vector<int>;
using vii = vector<ii>;
using vvi = vector<vi>;
using iii = pair<int, ii>;
using viii = vector<iii>;
using ll = long long int;
using vc = vector<char>;
using vb = vector<bool>;
using ib = pair<int, bool>;
using vib = vector<ib>;
bool resuelveCaso() {
int n;
cin >> n;
if (!cin) return false;
int h, a1, b1, q;
cin >> h >> a1 >> b1 >> q;
for (int i = 0; i < q; ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (a == c)
cout << abs(b - d) << '\n';
else {
int res = 0;
if (a1 > b) {
res += abs(b - a1);
b = a1;
} else if (b1 < b) {
res += abs(b - b1);
b = b1;
}
if (a1 > d) {
res += abs(d - a1);
d = a1;
} else if (b1 < d) {
res += abs(d - b1);
d = b1;
}
res += abs(b - d);
res += abs(a - c);
cout << res << '\n';
}
}
return true;
}
int main() {
while (resuelveCaso()) {
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200010];
int subtree[200010][10], tree[200010][10], p[10], D[200010], odl[200010], n, k,
a, b;
bool bylem[200010];
long long sumka, suma, add, x;
void DFSdp(int w) {
bylem[w] = true;
sumka += odl[w];
subtree[w][0] = D[w] = 1;
for (int i = 0; i < v[w].size(); i++) {
if (!bylem[v[w][i]]) {
odl[v[w][i]] = odl[w] + 1;
DFSdp(v[w][i]);
D[w] += D[v[w][i]];
for (int j = 0; j < k; j++) {
subtree[w][j] += subtree[v[w][i]][(j + k - 1) % k];
}
}
}
}
void DFSsum(int w, long long sum) {
suma += sum;
for (int i = 1; i < k; i++) {
add += tree[w][i] * (k - i);
}
bylem[w] = true;
for (int i = 0; i < v[w].size(); i++) {
if (!bylem[v[w][i]]) {
for (int j = 0; j < k; j++) {
p[j] = tree[w][j] - subtree[v[w][i]][(j + k - 1) % k];
}
for (int j = 0; j < k; j++) {
tree[v[w][i]][(j + 1) % k] = p[j] + subtree[v[w][i]][(j + 1) % k];
}
DFSsum(v[w][i], sum - D[v[w][i]] + n - D[v[w][i]]);
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b), v[b].push_back(a);
}
DFSdp(1);
for (int i = 1; i <= n; i++) {
bylem[i] = false;
}
for (int i = 0; i < k; i++) {
tree[1][i] = subtree[1][i];
}
DFSsum(1, sumka);
printf("%lld", ((suma >> 1) + (add >> 1)) / k);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, l;
long long data[3009][2];
long long dp[3009][109][3];
void solve() {
memset(dp, 0, sizeof dp);
long long len;
for (long long i = 1; i <= l; i++) {
for (long long j = 0; j < n; j++) {
for (long long o = 0; o < 2; o++) {
len = data[j][o];
if (len > i) continue;
if (o == 1 && len == data[j][0]) continue;
if (i == len) {
dp[i][j][o] = (dp[i][j][o] + 1) % (1000000007L);
}
for (long long k = 0; k < n; k++) {
if (k == j) continue;
if (data[k][0] == len && (i - data[k][1]) >= 0) {
dp[i][j][o] = (dp[i][j][o] + dp[i - len][k][1]) % (1000000007L);
}
if (data[k][1] == len && (i - data[k][0]) >= 0) {
dp[i][j][o] = (dp[i][j][o] + dp[i - len][k][0]) % (1000000007L);
}
}
}
}
}
long long sum = 0;
for (long long i = 0; i < (long long)n; i++) {
sum = (sum + dp[l][i][0] + dp[l][i][1]) % (1000000007L);
}
sum = (sum + (1000000007L)) % (1000000007L);
cout << sum << endl;
}
int main() {
cin >> n >> l;
long long x, y;
memset(data, 0, sizeof data);
for (long long i = 0; i < (long long)n; i++) {
cin >> x >> y;
data[i][0] = x;
data[i][1] = y;
}
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int t = 0, i = 0, j = 0, n = 0, m = 0, k = 0, num = 0, temp = 0, ans = 0;
cin >> n >> k;
string str;
vector<int> v;
int arr[100002] = {0};
if (k < n / 2) {
cout << "-1";
return 0;
}
if (n == 1) {
if (k == 0)
cout << "1";
else
cout << "-1";
return 0;
}
num = k - n / 2 + 1;
cout << num << " " << 2 * num << " ";
for (i = 0; i < n - 2; ++i) {
cout << 2 * num + 1 + i << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, i, j, ans, q, R;
int A[666][666], F[666][666];
string s[666];
int rectangleSum(int x1, int y1, int x2, int y2) {
int res = 0;
res = F[x2][y2] - F[x1 - 1][y2] - F[x2][y1 - 1] + F[x1 - 1][y1 - 1];
return res ? res : 0;
}
int getCount(int l, int r, int u, int d) {
int res = 0;
++l, --r, ++u, --d;
if (l > r) return 0;
if (u > d) return 0;
res = rectangleSum(u, l, d, r);
return res ? res : 0;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (i = 1; i <= n; ++i) cin >> s[i];
memset(A, 0, sizeof A);
for (i = 2; i < n; ++i)
for (j = 1; j < m - 1; ++j)
if (s[i][j - 1] == '1' && s[i][j + 1] == '1' && s[i - 1][j] == '1' &&
s[i + 1][j] == '1' && s[i][j] == '1')
A[i][j + 1] = 1;
memset(F, 0, sizeof F);
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j)
F[i][j] = F[i - 1][j] + F[i][j - 1] - F[i - 1][j - 1] + A[i][j];
long long ans = 0;
for (i = 1; i <= m; ++i)
for (j = i; j <= m; ++j) {
R = 1;
for (q = 1; q <= n; ++q) {
while (R < q) ++R;
while (R < n && getCount(i, j, q, R) < k) ++R;
if (getCount(i, j, q, R) >= k) ans += (long long)(n - R + 1);
}
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b, n, m;
cin >> a >> b >> n >> m;
if (a + b >= n + m && m <= min(a, b))
cout << "Yes\n";
else
cout << "No\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1000001];
bool used[1000001] = {};
vector<int> p;
vector<int> pos, num;
void dfs(int v) {
used[v] = 1;
pos.push_back(v);
num.push_back(p[v]);
for (int e = 0; e < g[v].size(); ++e) {
if (!used[g[v][e]]) {
dfs(g[v][e]);
}
}
}
int main() {
int n, m;
int a, b;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
p.push_back(a);
}
for (int i = 0; i < m; ++i) {
scanf("%d %d", &a, &b);
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; ++i) {
if (!used[i]) {
pos.resize(0);
num.resize(0);
dfs(i);
sort(pos.begin(), pos.end());
sort(num.rbegin(), num.rend());
for (int j = 0; j < pos.size(); ++j) {
p[pos[j]] = num[j];
}
}
}
for (int i = 0; i < n; ++i) {
printf("%d ", p[i]);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[10000000];
long long b[10000000];
long long ans[10000000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
long long x;
scanf("%d", &x);
a[x]++;
}
for (long long i = 1; i <= 3000000; i++) {
for (long long j = 1; i * j <= 3000000; j++) {
long long q = a[i];
long long w = a[j];
if (i == j) w--;
b[i * j] += q * w;
}
}
for (int i = 1; i <= 3000000; i++) ans[i] = ans[i - 1] + b[i];
cin >> m;
for (long long i = 0; i < m; i++) {
long long x;
scanf("%d", &x);
long long res = (n * (n - 1)) - ans[x - 1];
if (res <= 1000000000)
printf("%d", res);
else {
cout << res;
}
printf("%c", ' ');
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> e[100200];
bool used[100200];
bool marked[100200];
void clearused() {
for (int i = 0; i <= n; ++i) used[i] = 0;
}
pair<int, int> deepest(int ind, int depth) {
used[ind] = 1;
pair<int, int> ans = {ind, depth};
for (int x : e[ind]) {
if (!used[x]) {
auto cans = deepest(x, depth + 1);
if (cans.second > ans.second) ans = cans;
}
}
return ans;
}
void copy0(int ind) {
for (int x : e[ind]) {
e[0].push_back(x);
}
}
bool mark(int curr, int target) {
used[curr] = 1;
if (curr == target) {
marked[curr] = 1;
copy0(curr);
return 1;
}
for (int x : e[curr]) {
if (!used[x]) {
if (mark(x, target)) {
marked[curr] = 1;
copy0(curr);
return 1;
}
}
}
return 0;
}
vector<int> d;
int f(int ind, int depth) {
used[ind] = 1;
if (e[ind].size() == 1) return depth;
int bd = -1;
for (int x : e[ind]) {
if (!used[x] && !marked[x]) {
int cd = f(x, depth + 1);
if (bd == -1)
bd = cd;
else {
if (cd > bd) swap(bd, cd);
d.push_back(cd - depth);
}
}
}
return bd;
}
int ans[100200];
int main() {
cin >> n;
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
auto d1 = deepest(1, 0);
clearused();
auto d2 = deepest(d1.first, 0);
ans[0] = 1;
ans[1] = d2.second + 1;
clearused();
mark(d1.first, d2.first);
clearused();
int cd = f(0, 0);
if (cd != -1) {
d.push_back(cd);
}
sort(d.begin(), d.end());
for (int i = d.size() - 1; i >= 0; --i) {
ans[1 + d.size() - i] = ans[d.size() - i] + d[i];
}
for (int i = 0; i < n; ++i) {
if (i < d.size() + 2)
cout << ans[i] << " ";
else
cout << ans[1 + d.size()] << " ";
}
cout << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2")
template <typename T>
void printv(const T& t) {
std::copy(t.cbegin(), t.cend(),
std::ostream_iterator<typename T::value_type>(std::cout, ", "));
cout << endl;
}
long long int modpower(long long int a, long long int b, long long int c) {
long long int res = 1;
while (b) {
if (b & 1LL) res = (res * a) % c;
a = (a * a) % c;
b >>= 1;
}
return res;
}
void solve() {
long long int n;
cin >> n;
if (n % 4 == 0) {
cout << "YES\n";
return;
}
cout << "NO\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void RST(T &A, char x = 0) {
memset(A, x, sizeof(A));
}
template <class T>
inline void SRT(T &A) {
sort(A.begin(), A.end());
}
template <class T, class C>
inline void SRT(T &A, C B) {
sort(A.begin(), A.end(), B);
}
const int DX[8] = {1, -1, 0, 0, 1, -1, 1, -1};
const int DY[8] = {0, 0, -1, 1, 1, -1, -1, 1};
const int inf = 0x3f3f3f3f;
const long long linf = 1LL << 60;
const double eps = 1e-9;
const double oo = 1e70;
const double pi = acos(-1.0);
inline double dcmp(const double &x) { return (x > eps) - (x < -eps); }
inline double dcmp(const double &x, const double &y) { return dcmp(x - y); }
template <class T>
inline void RD(T &x) {
char c = getchar();
x = 0;
int flg = 0;
while (c < '0' || c > '9') flg |= c == '-', c = getchar();
while (c >= '0' && c <= '9') x = (x << 1) + (x << 3) + c - '0', c = getchar();
if (flg) x = -x;
}
template <class T1, class T2>
inline void RD(T1 &x, T2 &y) {
RD(x);
RD(y);
}
template <class T1, class T2, class T3>
inline void RD(T1 &x, T2 &y, T3 &z) {
RD(x);
RD(y);
RD(z);
}
template <class T1, class T2, class T3, class T4>
inline void RD(T1 &x, T2 &y, T3 &z, T4 &w) {
RD(x);
RD(y);
RD(z);
RD(w);
}
inline long long RD() {
long long x;
RD(x);
return x;
}
inline void OT(int x) { printf("%d\n", x); }
inline void OT(long long x) { printf("%I64d\n", x); }
inline void OT(int x, int y) { printf("%d %d\n", x, y); }
inline void OT(long long x, long long y) { printf("%I64d %I64d\n", x, y); }
inline void setIO(char *in, char *out) {
if (in) freopen(in, "r", stdin);
if (out) freopen(out, "w", stdout);
}
template <class T>
inline void upmax(T &ans, const T &x) {
ans = max(ans, x);
}
template <class T>
inline void upmin(T &ans, const T &x) {
ans = min(ans, x);
}
inline char getAlpha() {
char c = getchar();
while (c < 'A' || c > 'Z') c = getchar();
return c;
}
inline char getalpha() {
char c = getchar();
while (c < 'a' || c > 'z') c = getchar();
return c;
}
inline void _gets(char *s) { scanf("%[^\n]", s); }
const int maxn = 100000 + 5;
const int mod = 100000007;
struct Int {
int v;
Int() {}
Int(int x) {
v = x % mod;
if (v < 0) v += mod;
}
Int(long long x) {
v = x % mod;
if (v < 0) v += mod;
}
inline Int operator+(const Int &b) const { return v + b.v; }
inline Int operator-(const Int &b) const { return v - b.v; }
inline Int operator-() const { return -v; }
inline Int operator*(const Int &b) const { return (long long)v * b.v; }
friend inline Int pw(Int a, int b) {
Int ans = 1;
for (; b; b >>= 1, a = a * a)
if (b & 1) ans = ans * a;
return ans;
}
};
int N;
char second[maxn];
bool isVowels(char c) {
return c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U' || c == 'Y';
}
int main() {
gets(second + 1);
N = strlen(second + 1);
int ans = 0, lst = 0;
for (int i = 1; i <= N; i++)
if (isVowels(second[i])) {
upmax(ans, i - lst);
lst = i;
}
upmax(ans, N + 1 - lst);
OT(ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, sum = 0;
cin >> n >> p;
int a[n], i;
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum < p) {
cout << "-1";
return 0;
}
sort(a, a + n, greater<int>());
int ans, page, k;
for (ans = 1; ans <= n; ans++) {
page = 0;
for (i = 0; i < n; i++) {
page += max(0, a[i] - i / ans);
}
if (page >= p) {
cout << ans;
return 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int t, n;
int a[N], s[100];
int check(int x) {
int ans = 0;
while (x) {
ans++;
x >>= 1;
}
return ans;
}
int main() {
scanf("%d", &t);
while (t--) {
memset(s, 0, sizeof s);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
int x = check(a[i]);
s[x]++;
}
long long ans = 0;
for (int i = 1; i <= 90; i++) ans += (long long)s[i] * (s[i] - 1) / 2;
printf("%lld\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int sk[100009];
int pref = 0;
int suff = 0;
int dp[2009][2009];
const int mod = (int)1e9 + 7;
int main() {
dp[0][0] = 1;
for (int i = 1; i <= 2000; ++i) {
for (int j = 0; j <= 2000; ++j) {
if (j) dp[i][j] += dp[i - 1][j - 1];
if (dp[i][j] >= mod) dp[i][j] -= mod;
dp[i][j] += dp[i - 1][j + 1];
if (dp[i][j] >= mod) dp[i][j] -= mod;
}
}
int n, m;
scanf("%d%d", &n, &m);
scanf("\n");
int cnt = 0;
for (int i = 0; i < m; ++i) {
char c;
scanf("%c", &c);
sk[i] = c == '(';
}
cnt = 0;
for (int i = 0; i < m; ++i) {
if (!sk[i]) {
cnt++;
} else
cnt--;
if (pref < cnt) pref = cnt;
}
cnt = 0;
for (int i = m - 1; i >= 0; --i) {
if (sk[i]) {
cnt++;
} else
cnt--;
if (suff < cnt) suff = cnt;
}
int ans = 0;
int need = n - m;
for (int i = 0; i <= need; ++i) {
int j = need - i;
for (int t = 0; t + pref <= 2000 && suff + t <= 2000; ++t) {
ans += dp[i][pref + t] * 1LL * dp[j][suff + t] % mod;
if (ans >= mod) ans -= mod;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m;
char ch[1010][1010];
long long int x[] = {0, 0, -1, 1};
long long int y[] = {1, -1, 0, 0};
long long int d[1010][1010];
void bfs(long long int a, long long int b) {
queue<long long int> q;
q.push(a);
q.push(b);
q.push(0);
while (!q.empty()) {
a = q.front();
q.pop();
b = q.front();
q.pop();
long long int c = q.front();
q.pop();
if (d[a][b] != -1) continue;
d[a][b] = c;
for (long long int i = 0; i < 4; i++) {
long long int e = a + x[i];
long long int f = b + y[i];
if (e >= 0 && e < n) {
if (f >= 0 && f < m) {
if (ch[e][f] != 'T') {
q.push(e);
q.push(f);
q.push(c + 1);
}
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
long long int a, b, x, y;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
d[i][j] = -1;
cin >> ch[i][j];
if (ch[i][j] == 'S') {
a = i;
b = j;
}
if (ch[i][j] == 'E') {
x = i;
y = j;
}
}
}
bfs(x, y);
long long int ans = 0;
long long int f = d[a][b];
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (ch[i][j] != 'T' && ch[i][j] != 'S' && ch[i][j] != 'E') {
if (d[i][j] <= f && d[i][j] != -1) {
ans += ch[i][j] - '0';
}
}
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U>& l, const std::pair<T, U>& r) {
return {l.first + r.first, l.second + r.second};
}
typedef void (*callback_function)(void);
const long long ZERO = 0LL;
const long long INF64 = 1e18;
const long long INF32 = 1e9;
const long long MOD = 1e9 + 7;
const long double PI = acos(-1.0L);
const long double EPS = static_cast<long double>(1e-9);
const long long N = 1e6 + 7;
long long n, q;
long long a[N], b[N], res[N];
map<long long, long long> mp;
void input() {
cin >> n >> q;
for (long long i = (0); i < (n); i++) {
cin >> a[i];
}
for (long long i = (0); i < (q); i++) {
cin >> b[i];
}
}
void debug() {
if (true) {
}
}
void solve() {
for (long long i = (0); i < (n); i++) {
mp[a[i]]++;
}
for (long long i = (0); i < (q); i++) {
for (long long x = 1LL << 30; x > 0; x /= 2) {
long long need = min(mp[x], b[i] / x);
b[i] -= x * need, res[i] += need;
}
if (b[i]) {
res[i] = -1;
}
}
}
void output() {
for (long long i = (0); i < (q); i++) {
cout << res[i] << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
{
input();
solve();
output();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 5e5 + 100;
int p[maxn];
pair<int, int> g[maxn];
map<int, int> mp;
pair<int, int> Q[maxn];
set<pair<int, int>> st[maxn];
bool vis[maxn];
struct UFS {
int rt[maxn], sz[maxn];
void init() {
for (int i = 0; i < maxn; i++) rt[i] = i, sz[i] = 1;
}
int Find(int x) {
while (x != rt[x]) x = rt[x];
return x;
}
void Merge(int x, int y, stack<pair<int, int>>& stk) {
x = Find(x), y = Find(y);
if (x == y) {
stk.push({0, 0});
return;
}
if (sz[x] > sz[y]) swap(x, y);
for (auto it : st[x]) {
if (!vis[it.second]) st[y].insert(it);
}
rt[x] = y, sz[y] += sz[x];
stk.push({x, y});
}
void Cancel(stack<pair<int, int>>& stk) {
if (!stk.empty()) {
int x = stk.top().first, y = stk.top().second;
stk.pop();
if (x == y && x == 0) return;
set<pair<int, int>> stt;
for (auto it : st[x]) {
if (st[y].find(it) != st[y].end()) {
st[y].erase(it);
if (!vis[it.second]) stt.insert(it);
}
}
st[x].clear();
st[x] = stt;
rt[x] = x, sz[y] -= sz[x];
}
}
} ufs;
stack<pair<int, int>> stk;
int main() {
ufs.init();
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
st[i].insert({p[i], i});
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &g[i].first, &g[i].second);
}
for (int i = 1; i <= q; i++) {
scanf("%d%d", &Q[i].first, &Q[i].second);
if (Q[i].first == 2) mp[Q[i].second] = 1;
}
for (int i = 1; i <= m; i++) {
if (mp.count(i) == 0) ufs.Merge(g[i].first, g[i].second, stk);
}
for (int i = q; i >= 1; i--) {
if (Q[i].first == 2)
ufs.Merge(g[Q[i].second].first, g[Q[i].second].second, stk);
}
for (int i = 1; i <= q; i++) {
if (Q[i].first == 1) {
int x = ufs.Find(Q[i].second);
if (st[x].size() == 0) {
puts("0");
continue;
}
auto it = st[x].end();
--it;
int flag = 0;
while (!flag) {
if (!vis[(*it).second]) {
flag = (*it).first;
vis[(*it).second] = 1;
st[x].erase(it);
break;
} else {
if (it == st[x].begin())
break;
else
it--;
}
}
printf("%d\n", flag);
} else {
ufs.Cancel(stk);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int n, k;
char m[505][505];
int mem[505][505];
int sz[250005];
int maxid = 1;
int mark[250005];
int state;
int max(int a, int b) { return a > b ? a : b; }
void cc(int x, int y, int id) {
if (x < 0 || y < 0 || x >= n || y >= n) return;
if (m[x][y] == 'X' || mem[x][y]) return;
mem[x][y] = id;
sz[id]++;
cc(x, y - 1, id);
cc(x, y + 1, id);
cc(x - 1, y, id);
cc(x + 1, y, id);
return;
}
int fetch(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= n) return 0;
if (mark[mem[x][y]] == state || mem[x][y] == 0) return 0;
mark[mem[x][y]] = state;
return sz[mem[x][y]];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%s", m[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (m[i][j] == '.' && !mem[i][j]) cc(i, j, maxid++);
}
int res = k * k;
for (int i = 1; i < maxid; i++) res = max(res, sz[i]);
for (int i = 0; i <= n - k; i++) {
for (int pos1 = 0; pos1 < k; pos1++)
for (int pos2 = 0; pos2 < k; pos2++) sz[mem[i + pos1][pos2]]--;
for (int j = 0; j <= n - k; j++) {
state = (i + 1) * 1000 + j + 1;
int cur = k * k;
for (int pos = 0; pos < k; pos++) {
cur += fetch(i - 1, j + pos);
cur += fetch(i + k, j + pos);
cur += fetch(i + pos, j - 1);
cur += fetch(i + pos, j + k);
}
res = max(res, cur);
if (j == n - k) break;
for (int pos = 0; pos < k; pos++)
sz[mem[i + pos][j]]++, sz[mem[i + pos][j + k]]--;
}
for (int pos1 = 0; pos1 < k; pos1++)
for (int pos2 = n - k; pos2 < n; pos2++) sz[mem[i + pos1][pos2]]++;
}
printf("%d\n", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long BIG = 100000000;
char p[1000005], s[2000005];
long long D[2000005];
int main() {
gets(p);
int sz = 0, g = 0, n = 0, i;
for (i = 0; p[i]; i++) {
s[n++] = p[i];
if (p[i] != 'X' && p[i] == p[i + 1]) s[n++] = 'X';
}
if (s[0] == s[n - 1]) {
if (s[0] == 'L') s[n++] = 'X';
if (s[0] == 'R') {
for (i = n; i >= 1; i--) s[i] = s[i - 1];
s[0] = 'X';
n++;
}
}
int L = 0, R = BIG, M;
while (L < R) {
M = (L + R + 1) / 2;
for (i = 1; i <= n; i++) {
D[i] = D[i - 1] + BIG * (s[i - 1] != 'X') - 2 * M;
if (i >= 2) {
D[i] =
max(D[i], D[i - 2] + BIG * ((s[i - 2] == 'L') + (s[i - 1] == 'R')) -
2 * M);
}
}
if (D[n] >= 0)
L = M;
else
R = M - 1;
}
printf("%d.%06d\n", L / 1000000, L % 1000000);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2,unroll-loops")
using namespace std;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010, LOG = 60;
int n, m, k, u, v, x, y, t, a, b;
long long A[MAXN], ans, fix, X;
long long g[MAXN];
bitset<MAXN> B[LOG], C;
bool check(long long num, long long fix) {
vector<long long> vec;
for (int i = 0; i < LOG; i++) {
long long x = g[i] & fix;
for (long long a : vec)
if (a & -a & x) x ^= a;
if (!x) continue;
for (long long &a : vec)
if (x & -x & a) a ^= x;
vec.push_back(x);
}
for (long long a : vec)
if (a & -a & num) num ^= a;
return (num == 0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i];
X ^= A[i];
long long x = A[i];
for (int j = LOG - 1; ~j; j--) x = min(x, x ^ g[j]);
if (!x) continue;
x = A[i];
C.reset();
C.set(i);
for (int j = LOG - 1; ~j; j--)
if (x > (x ^ g[j])) {
x ^= g[j];
C ^= B[j];
}
int bit = 63 - __builtin_clzll(x);
g[bit] = x;
B[bit] = C;
}
for (int i = LOG - 1; ~i; i--)
if (!(((X) >> (i)) & 1)) {
fix |= (1ll << i);
if (check(ans | (1ll << i), fix)) ans |= (1ll << i);
}
for (int i = LOG - 1; ~i; i--)
if ((((X) >> (i)) & 1)) {
fix |= (1ll << i);
if (!check(ans, fix)) ans |= (1ll << i);
}
cerr << "ans" << '=' << (ans) << endl;
C.reset();
for (int j = LOG - 1; ~j; j--)
if (ans > (ans ^ g[j])) {
ans ^= g[j];
C ^= B[j];
}
for (int i = 1; i <= n; i++) cout << 2 - C[i] << " \n"[i == n];
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int Power(int base, int exp) {
int ans = 1;
while (exp > 0) {
if (exp & 1) ans = (1LL * ans * base) % 1000000007;
exp = exp >> 1;
base = (1LL * base * base) % 1000000007;
}
return ans;
}
void solve() {
long long int l, r;
cin >> l >> r;
long long int x = r / 2;
if (x >= l) {
if (r % 2 == 0)
cout << x - 1 << '\n';
else
cout << x << '\n';
} else
cout << r % l << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int q = 1;
cin >> q;
while (q--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, l;
int mem[15][2];
int rec(int pos, int check) {
if (pos >= l) {
return 1;
}
if (mem[pos][check] != -1) return mem[pos][check];
int now = pow(10, pos);
now = (n / now) % 10;
int ans = 0;
for (int i = 1; i <= 9; i++) {
if (pos == l - 1) {
if (check == 0) {
if (i <= now) {
ans = max(ans, i * rec(pos + 1, 0));
}
} else {
if (i < now) {
ans = max(ans, i * rec(pos + 1, 0));
}
}
} else if (check == 0) {
if (i <= now) {
ans = max(i, ans);
ans = max(ans, i * rec(pos + 1, 0));
} else {
ans = max(i, ans);
ans = max(ans, i * rec(pos + 1, 1));
}
} else {
if (i < now) {
ans = max(i, ans);
ans = max(ans, i * rec(pos + 1, 0));
} else {
ans = max(i, ans);
ans = max(ans, i * rec(pos + 1, 1));
}
}
}
return mem[pos][check] = ans;
}
int main() {
memset(mem, -1, sizeof(mem));
cin >> n;
l = log10(n) + 1;
int maxx = rec(0, 0);
cout << maxx << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> P(n), D(n);
for (int i = 0; i < n; ++i) {
cin >> P[i];
P[i]--;
}
for (int i = 0; i < n; ++i) cin >> D[i];
vector<vector<int> > A(n, vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
int k1 = i - D[i];
if (k1 >= 0) A[k1][i] = A[i][k1] = 1;
int k2 = i + D[i];
if (k2 < n) A[k2][i] = A[i][k2] = 1;
}
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (A[i][k] == 1 && A[k][j] == 1) A[i][j] = A[j][i] = 1;
for (int i = 0; i < n; ++i) {
if (P[i] == i) continue;
int k = -1;
for (int j = 0; j < n; ++j)
if (P[j] == i) {
k = j;
break;
}
if (A[k][i] == 0) {
cout << "NO";
return 0;
}
swap(P[k], P[i]);
}
cout << "YES";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e2 + 5;
int A[NMAX], N, X, Y, i, B[NMAX];
int main() {
cin.tie(NULL);
cin >> N >> X >> Y;
for (int i = 1; i <= N; ++i) cin >> A[i];
if (X > Y) {
cout << N << '\n';
return 0;
}
for (int i = 1; i <= N; ++i)
if (A[i] <= X) B[++B[0]] = A[i];
cout << (B[0] + 1) / 2 << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 200000 + 1000;
const int maxm = 300000 + 100;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3;
template <class T>
inline bool scan(T &ret) {
ret = 0;
char c;
int sgn;
T bit = 0.1;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && c != '.' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
if (c == ' ' || c == '\n') {
ret *= sgn;
return 1;
}
while (c = getchar(), c >= '0' && c <= '9') ret += (c - '0') * bit, bit /= 10;
ret *= sgn;
return 1;
}
template <class T, class... Args>
inline void scan(T &x, Args &...args) {
scan(x), scan(args...);
}
int kase = 0;
template <class T>
T exgcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
T res = exgcd(b, a % b, y, x);
y -= a / b * x;
return res;
}
template <class T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <class T>
T qpow(T a, T n, T mod) {
T res = 1;
while (n) {
if (n & 1) {
res = res * a % mod;
}
a = a * a % mod, n >>= 1;
}
return res;
}
void init() {}
int a[maxn], b[maxn];
void solve() {
int n;
scan(n);
int time = 1;
bool sma = true;
for (int i = 0; i < n; i++) {
scan(a[i]);
if (a[i] != a[i - 1] && i != 0 && sma) sma = false;
}
if (sma) {
cout << 1 << endl;
for (int i = 0; i < n; i++) cout << '1' << " ";
cout << endl;
return;
}
if (n % 2 == 0) {
cout << 2 << endl;
for (int i = 0; i < n; i++) {
if (i % 2) {
cout << 1 << " ";
} else
cout << 2 << " ";
}
cout << endl;
return;
}
int pre = 0;
b[0] = time++;
for (int i = 1; i < n - 1; i++) {
if (a[i] == a[i - 1])
b[i] = b[i - 1] % 2 + 1, pre++;
else {
b[i] = b[i - 1] % 2 + 1;
}
}
if (a[n - 1] == a[0])
b[n - 1] = b[n - 2] % 2 + 1;
else if (a[n - 1] == a[n - 2])
b[n - 1] = b[0] % 2 + 1;
else {
if (b[n - 2] == b[0])
b[n - 1] = b[n - 2] % 2 + 1;
else if (pre) {
bool flag = false;
cout << time << endl;
for (int i = 0; i < n - 1; i++) {
if (flag) {
cout << b[i] % 2 + 1 << " ";
} else {
if (i != 0 && a[i - 1] == a[i] && !flag) {
flag = true;
cout << b[i] % 2 + 1 << " ";
} else {
cout << b[i] << " ";
}
}
}
cout << b[n - 2] << " " << endl;
return;
} else {
cout << 3 << endl;
for (int i = 0; i < n - 1; i++) {
cout << b[i] << " ";
}
cout << 3 << endl;
return;
}
}
cout << time << endl;
for (int i = 0; i < n; i++) {
cout << b[i] << " ";
}
cout << endl;
}
void solve(int i) {}
int main() {
int T = 1;
scan(T);
while (T--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10, M = 3e4 + 10;
struct ed {
int v, u, w, id;
ed() {
v = u = id = -1;
w = 1e9 + 10;
}
ed(int v, int u, int w, int id) : v(v), u(u), w(w), id(id) {}
} e[M];
bool vis[N], dp[N];
vector<pair<int, ed> > g[N];
vector<ed> tree;
int ans, n, m, s, t, mn[N], h[N];
ed a, b, other, inval;
void dfs(int v, ed to) {
vis[v] = true;
if (to.id != -1) tree.push_back(to);
for (auto U : g[v])
if (!vis[U.first]) dfs(U.first, U.second);
}
void dfsCalc(int v, int par, ed to) {
h[v] = par >= 0 ? h[par] + 1 : 0;
mn[v] = h[v];
vis[v] = true;
for (auto U : g[v]) {
int u = U.first;
if (U.second.id == to.id || U.second.id == inval.id) continue;
if (vis[u])
mn[v] = min(mn[v], h[u]);
else {
dfsCalc(u, v, U.second);
mn[v] = min(mn[v], mn[u]);
dp[v] |= dp[u];
}
}
dp[v] |= (v == s);
if (dp[v] && mn[v] >= h[v] && other.w > to.w) other = to;
}
void eval(ed E) {
inval = E;
for (int i = 0; i < n; i++) {
mn[i] = 1e9;
vis[i] = dp[i] = false;
}
if (ans < E.w) return;
other = ed();
dfsCalc(t, -1, ed());
if (!vis[s]) {
ans = E.w;
a = E;
b = ed();
return;
}
if (other.id > -1 && ans > other.w + E.w) {
ans = other.w + E.w;
a = E;
b = other;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> s >> t;
s--;
t--;
for (int i = 0; i < m; i++) {
int a, b, w;
cin >> a >> b >> w;
a--;
b--;
e[i] = ed(a, b, w, i + 1);
g[a].push_back({b, e[i]});
g[b].push_back({a, e[i]});
}
ans = 2e9 + 10;
dfs(s, ed());
if (!vis[t]) {
cout << "0\n0\n";
return 0;
}
for (auto i : tree) eval(i);
if (ans > 2e9) {
cout << "-1\n";
return 0;
}
cout << ans << "\n" << (1 + (b.id != -1)) << "\n" << a.id;
if (b.id == -1)
cout << "\n";
else
cout << " " << b.id << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
const int inf = 1e9;
string b;
int a[N], n;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
cin >> b;
int l = -inf, r = inf;
for (int i = 4; i < n; ++i) {
string tmp = b.substr(i - 4, 5);
int mx = *max_element(a + i - 4, a + i + 1);
int mi = *min_element(a + i - 4, a + i + 1);
if (tmp == "00001") l = max(l, mx + 1);
if (tmp == "11110") r = min(r, mi - 1);
if (tmp == "11111") r = max(r, mi);
if (tmp == "00000") l = min(l, mx);
}
cout << l << ' ' << r << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
;
int n;
long long sum = 0;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '2' || s[i] == '4' || s[i] == '6' || s[i] == '8' || s[i] == '0')
sum += i + 1;
}
cout << sum << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005], b[100005];
long long n, k;
int judge(long long x) {
long long ans = k;
for (long long i = 0; i < n; i++) {
if (x > b[i] / a[i]) {
if (ans < a[i] * x - b[i])
return 0;
else
ans -= a[i] * x - b[i];
}
}
return 1;
}
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 0; i < n; i++) scanf("%lld", &a[i]);
for (long long i = 0; i < n; i++) scanf("%lld", &b[i]);
long long l = 0, r = 2 * 1000000000 + 10;
long long cnt = 0;
while (l <= r) {
long long mid = (l + r) / 2;
if (judge(mid))
l = mid + 1, cnt = mid;
else
r = mid - 1;
}
printf("%lld\n", cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
long long arr[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
long long n;
cin >> n;
if (n == 1) return cout << '1', 0;
long long ans = 1;
long long cur = 0;
vector<long long> xx;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) {
n /= i;
xx.push_back(i - 1);
}
}
}
if (n > 1) xx.push_back(n - 1);
for (long long i = (long long)(xx.size()) - 1; i >= 0; i--) {
long long cnt = 0;
while (++cnt <= xx[i]) ans *= arr[cur];
cur++;
}
cur--;
long long yy = xx.back() + 1;
long long divide = pow(2LL, xx.back());
long long mult = pow(2LL, xx.back());
for (long long i = 0; i < (long long)(xx.size()); i++) {
long long x1 = 1;
long long cnt = 0;
while (++cnt <= xx[i]) x1 *= arr[cur];
cur--;
yy *= (xx[i] + 1);
if (yy > 61) break;
long long x2 = (long long)(pow(2LL, yy - 1));
if (divide * x1 > x2) {
divide *= x1;
mult = x2;
} else
break;
}
cout << (ans / divide) * mult;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool sortmahstyle(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first && a.second < b.second) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (auto &i : a) cin >> i;
vector<vector<int>> num(201, vector<int>(n + 1));
vector<vector<int>> pos(201);
for (int i = 0; i < n; i++) {
for (int j = 1; j < 201; j++) num[j][0] = 0, num[j][i + 1] = num[j][i];
pos[a[i]].push_back(i);
num[a[i]][i + 1] += 1;
}
int ans = 0;
for (int i = 1; i < 201; i++) {
ans = max(ans, (int)pos[i].size());
for (int j = 0; j < pos[i].size() / 2; j++) {
int L = pos[i][j] + 1, R = pos[i][pos[i].size() - j - 1] - 1;
for (int k = 1; k < 201; k++) {
int sum = num[k][R + 1] - num[k][L];
ans = max(ans, (j + 1) * 2 + sum);
}
}
}
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
void min_self(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
void max_self(T &x, U y) {
if (y > x) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T_container, typename T = typename enable_if<
!is_same<T_container, string>::value,
typename T_container::value_type>::type>
ostream &operator<<(ostream &os, const T_container &a) {
os << '{';
string sep;
for (const T &x : a) os << sep << x, sep = ", ";
return os << '}';
}
void debug() { cerr << endl; }
template <typename Head, typename... Tail>
void debug(Head h, Tail... t) {
cerr << h << ' ';
debug(t...);
}
const int64_t MX = 2e5, MOD = 1e9 + 7, MOD2 = 998244353, INF = 1e18;
int64_t n;
vector<pair<int64_t, int64_t>> caves;
bool works(int64_t health) {
for (auto &[minstart, increase] : caves) {
if (health < minstart) return false;
health += increase;
}
return true;
}
void solve() {
cin >> n;
for (int64_t i = 0; i < n; ++i) {
int64_t k;
cin >> k;
int64_t maxai = 0;
for (int64_t j = 0; j < k; ++j) {
int64_t aj;
cin >> aj;
max_self(maxai, aj - j);
}
caves.emplace_back(make_pair(maxai + 1, k));
}
sort(begin(caves), end(caves),
[](pair<int64_t, int64_t> &a, pair<int64_t, int64_t> &b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
});
int64_t ans = 2e9, lo = 1, hi = 2e9;
while (lo <= hi) {
int64_t mid = (lo + hi) / 2;
if (works(mid)) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
cout << ans << '\n';
caves.clear();
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(NULL);
int64_t tc = 1;
cin >> tc;
while (tc--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int z = 1000;
int fibs[z];
int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
int fib(int n, int k) {
if (n < k)
return 0;
else {
if (n == k)
return 1;
else {
int sum = 0;
for (int i = max(n - k, k); i < n; ++i)
if (i >= k && i < k + z)
sum += fibs[i - k];
else
sum += fib(i, k);
return sum;
}
}
}
int main() {
int s, k;
cin >> s >> k;
fibs[0] = 1;
for (int i = 1; i < z; ++i) {
fibs[i] = 0;
for (int j = max(i - k, 0); j < i; ++j)
if (j >= 0) fibs[i] += fibs[j];
}
bool first = true;
int arr[100000];
int sz = 1;
arr[0] = 0;
while (s > 0) {
int j = 0, c = k - 1, p = 0;
while (s > j) {
c++;
p = j;
j = fib(c, k);
}
if (j > s) {
s -= p;
arr[sz] = p;
sz++;
} else {
s -= j;
arr[sz] = j;
sz++;
}
first = false;
}
cout << sz << endl;
for (int i = 0; i < sz; ++i) {
cout << arr[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct trie {
int l;
int w;
char c;
trie() {
l = w = 0;
c = '*';
}
trie(int lo, int ww, char cc) {
l = lo;
w = ww;
c = cc;
}
};
char p[302][302];
int x1, yt, x2, y2, x3, y3;
vector<trie> tr;
bool won = 0;
int s = 0;
bool t1(int x, int y, int z) {
if (tr[x].l != (tr[x].w + tr[y].w + tr[z].w)) return 0;
if (!(tr[x].l == tr[y].l && tr[x].l == tr[z].l)) return 0;
s = tr[x].l;
for (int i = 0; i < tr[x].w; i++)
for (int j = 0; j < tr[x].l; j++) {
p[i][j] = tr[x].c;
}
for (int i = 0; i < tr[y].w; i++)
for (int j = 0; j < tr[y].l; j++) {
p[i + tr[x].w][j] = tr[y].c;
}
for (int i = 0; i < tr[z].w; i++)
for (int j = 0; j < tr[z].l; j++) {
p[i + tr[x].w + tr[y].w][j] = tr[z].c;
}
return 1;
}
bool t2(int x, int y, int z) {
if (tr[x].l + tr[y].l != tr[z].l) return 0;
if (tr[x].w != tr[y].w) return 0;
if (tr[x].w + tr[z].w != tr[x].l + tr[y].l) return 0;
s = tr[z].l;
for (int i = 0; i < tr[x].w; i++)
for (int j = 0; j < tr[x].l; j++) {
p[i][j] = tr[x].c;
}
for (int i = 0; i < tr[y].w; i++)
for (int j = 0; j < tr[y].l; j++) {
p[i][j + tr[x].l] = tr[y].c;
}
for (int i = 0; i < tr[z].w; i++)
for (int j = 0; j < tr[z].l; j++) {
p[i + tr[x].w][j] = tr[z].c;
}
return 1;
}
bool t3(int x, int y, int z) {
if (tr[x].l + tr[y].l + tr[z].l != tr[x].w ||
!(tr[x].w == tr[y].w && tr[x].w == tr[z].w))
return 0;
s = tr[x].w;
for (int i = 0; i < tr[x].w; i++)
for (int j = 0; j < tr[x].l; j++) {
p[i][j] = tr[x].c;
}
for (int i = 0; i < tr[y].w; i++)
for (int j = 0; j < tr[y].l; j++) {
p[i][j + tr[x].l] = tr[y].c;
}
for (int i = 0; i < tr[z].w; i++)
for (int j = 0; j < tr[z].l; j++) {
p[i][j + tr[x].l + tr[y].l] = tr[z].c;
}
return 1;
}
bool t4(int x, int y, int z) {
if (tr[x].l != tr[y].l + tr[z].l) return 0;
if (tr[z].w != tr[y].w) return 0;
if (tr[x].w + tr[y].w != tr[x].l) return 0;
s = tr[x].l;
for (int i = 0; i < tr[x].w; i++)
for (int j = 0; j < tr[x].l; j++) {
p[i][j] = tr[x].c;
}
for (int i = 0; i < tr[y].w; i++)
for (int j = 0; j < tr[y].l; j++) {
p[i + tr[x].w][j] = tr[y].c;
}
for (int i = 0; i < tr[z].w; i++)
for (int j = 0; j < tr[z].l; j++) {
p[i + tr[x].w][j + tr[y].l] = tr[z].c;
}
return 1;
}
bool can(int x, int y, int z) {
won = t1(x, y, z);
if (won) return 1;
won = t2(x, y, z);
if (won) return 1;
won = t3(x, y, z);
if (won) return 1;
won = t4(x, y, z);
if (won) return 1;
return 0;
}
bool con(vector<int> v, int k) {
for (int i = 0; i < 3; i++) {
if (v[i] == k) return 1;
}
return 0;
}
void print() {
cout << s << endl;
for (int i = 0; i < s; i++) {
for (int j = 0; j < s; j++) {
cout << p[i][j];
}
cout << endl;
}
}
int main() {
scanf("%d%d%d%d", &x1, &yt, &x2, &y2);
scanf("%d%d", &x3, &y3);
tr.push_back(trie(x1, yt, 'A'));
tr.push_back(trie(yt, x1, 'A'));
tr.push_back(trie(x2, y2, 'B'));
tr.push_back(trie(y2, x2, 'B'));
tr.push_back(trie(x3, y3, 'C'));
tr.push_back(trie(y3, x3, 'C'));
for (int i = 0; i < 6; i++)
for (int j = 0; j < 6; j++)
for (int k = 0; k < 6; k++) {
if (i == j || i == k || j == k) continue;
vector<int> v;
v.push_back(i);
v.push_back(j);
v.push_back(k);
if ((con(v, 0) && con(v, 1)) || (con(v, 2) && con(v, 3)) ||
(con(v, 4) && con(v, 5)))
continue;
sort(v.begin(), v.end());
won = 0;
do {
won = can(v[0], v[1], v[2]);
if (won) {
print();
return 0;
}
} while (next_permutation(v.begin(), v.end()));
}
cout << -1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void Fastio() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
vector<int> arr[200005];
int diameter[200005], p[200005], vis[200005];
int resdep = 0, resnode;
void dfs(int node, int dep) {
vis[node] = 1;
if (resdep < dep) {
resdep = dep;
resnode = node;
}
for (int i = 0; i < arr[node].size(); i++) {
if (!vis[arr[node][i]]) dfs(arr[node][i], dep + 1);
}
}
int bfs(int init, int n) {
queue<int> q;
q.push(init);
int visited[n + 1];
for (int i = 0; i <= n; i++) {
visited[i] = 0;
diameter[i] = 0;
p[i] = 0;
}
q.push(init);
visited[init] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < arr[u].size(); i++) {
if (visited[arr[u][i]] == 0) {
visited[arr[u][i]] = 1;
diameter[arr[u][i]] += diameter[u] + 1;
p[arr[u][i]] = u;
q.push(arr[u][i]);
}
}
}
return int(max_element(diameter + 1, diameter + n + 1) - diameter);
}
int findDiameter(int n) {
int init = bfs(1, n);
int val = bfs(init, n);
return val;
}
int depa[200005], depb[200005];
void DFS1(int node, int dep) {
depa[node] = dep;
for (int i : arr[node]) {
if (depa[i] != -1) continue;
DFS1(i, dep + 1);
}
}
void DFS2(int node, int dep) {
depb[node] = dep;
for (int i : arr[node]) {
if (depb[i] != -1) continue;
DFS2(i, dep + 1);
}
}
int main() {
Fastio();
int ttt = 1;
cin >> ttt;
while (ttt--) {
long long n, a, b, da, db;
cin >> n >> a >> b >> da >> db;
for (int i = 0; i <= n; i++) {
arr[i].clear();
diameter[i] = 0;
p[i] = 0;
vis[i] = 0;
resdep = 0;
resnode = 0;
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
arr[x].push_back(y);
arr[y].push_back(x);
}
int start = findDiameter(n);
int res = diameter[start];
vector<int> v;
for (int i = 0; i <= n; i++) {
vis[i] = 0;
}
while (diameter[start] != 0) {
v.push_back(start);
vis[start] = 1;
start = p[start];
}
v.push_back(start);
vis[start] = 1;
for (int i = 0; i <= n; i++) {
depa[i] = -1;
depb[i] = -1;
}
DFS1(a, 0);
DFS2(b, 0);
bool st = 0;
if (depa[b] > da && v.size() > 2 * da + 1 && db > 2 * da) st = 1;
if (st)
cout << "Bob\n";
else
cout << "Alice\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long m = a[1] - a[0];
for (long long i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1]) {
m = 0;
} else {
m = min(m, a[i + 1] - a[i]);
}
}
cout << m << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll DIM = 1e6 + 7;
const ll INF = 1e16 + 7;
const ll MODULO = 1e9 + 7;
ll n,m,nt,k,q;
ll val,val1,last,res,c0,c1,c2;
int main()
{
ios_base::sync_with_stdio();
cin.tie();
cout.tie();
cin>>nt;
for(int t=1; t<=nt; t++)
{
cin>>n;
res=0;
c0=0;
c1=0;
c2=0;
for(int i=1; i<=n; i++)
{
cin>>val;
if(val%3==0)c0++;
else if(val%3==1)c1++;
else c2++;
}
for(int i=1; i<=2; i++)
{
if(c0>n/3)
{
val=c0-n/3;
res+=val;
c1+=val;
c0-=val;
}
if(c1>n/3)
{
val=c1-n/3;
res+=val;
c2+=val;
c1-=val;
}
if(c2>n/3)
{
val=c2-n/3;
res+=val;
c0+=val;
c2-=val;
}
}
cout<<res<<endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 1e5 + 200;
vector<int> g[nax];
bool leave[nax];
bool dfs(int u, int p, int depth) {
bool ans = false;
for (int v : g[u]) {
if (p == v) continue;
ans |= dfs(v, u, depth + 1);
}
if (leave[u]) {
ans |= (depth & 1);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(20) << fixed;
int n;
cin >> n;
int u, v;
for (int i = 0; i < (int)n - 1; ++i) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int maximum = n - 1;
for (int i = 1; i <= (int)n; ++i) {
leave[i] = (g[i].size() == 1);
maximum -= leave[i];
}
for (int i = 1; i <= (int)n; ++i) {
if (leave[i]) continue;
for (int v : g[i]) {
if (leave[v]) {
maximum++;
break;
}
}
}
int minimum;
for (int i = 1; i <= (int)n; ++i) {
if (leave[i]) {
minimum = dfs(i, 0, 0);
break;
}
}
cout << (minimum ? 3 : 1) << " " << maximum << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void delbit(int &a, int k) { a &= (~(1 << k)); }
bool getbit(int a, int k) { return 1 & (a >> k); }
int setbit(int &a, int k) { return a |= (1 << k); }
bool is_polindrom(string str) {
int len = str.length();
for (int i = 0; i < len / 2; i++)
if (str[i] != str[len - i - 1]) return false;
return true;
}
long long factorial(long long a) {
long long res = 1;
for (int i = 2; i <= a; i++) res *= i;
return res;
}
struct Point {
double x, y;
void operator=(Point &p) {
x = p.x;
y = p.y;
}
};
long long n;
int main() {
cin >> n;
cout << ((n % 2) ? 1 : 2) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int const N = 250000, B = 18;
vector<int> tr1[N + 1], tr2[N + 1];
int n, dp[N + 1], pa[N + 1][B], gr[N + 1];
int P(int v) { return gr[v] ? gr[v] = P(gr[v]) : v; }
void pl(int v = 1, int p = 0) {
dp[v] = dp[p] + 1;
pa[v][0] = p;
int k = 1, z;
while (k < B && (z = pa[v][k - 1])) pa[v][k] = pa[z][k - 1], ++k;
for (int u : tr1[v])
if (u != p) pl(u, v);
}
int lca(int a, int b) {
if (dp[a] < dp[b]) swap(a, b);
int d = dp[a] - dp[b], j = 0;
while (d) {
if (d & 1) a = pa[a][j];
++j;
d >>= 1;
}
if (a == b) return a;
for (int i = B - 1; i >= 0; --i)
if (pa[a][i] != pa[b][i]) a = pa[a][i], b = pa[b][i];
return pa[a][0];
}
void J(int a, int b) {
printf("%d %d", a, b);
gr[a] = b;
}
void kl(int a, int b) {
a = P(a);
int c = lca(a, b);
if (c != a)
J(a, pa[a][0]);
else {
for (int i = B - 1; i >= 0; --i)
if (dp[pa[b][i]] > dp[c] && P(pa[b][i]) != a) b = pa[b][i];
J(b, pa[b][0]);
}
}
void go(int v = 1, int p = 0) {
for (int u : tr2[v])
if (u != p) go(u, v);
if (p) {
kl(v, p);
printf(" %d %d\n", v, p);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < (int)(n); ++i) {
int a, b;
scanf("%d%d", &a, &b);
tr1[a].push_back(b);
tr1[b].push_back(a);
}
for (int i = 1; i < (int)(n); ++i) {
int a, b;
scanf("%d%d", &a, &b);
tr2[a].push_back(b);
tr2[b].push_back(a);
}
pl();
printf("%d\n", n - 1);
go();
}
| 12 |
#include <bits/stdc++.h>
int main() {
int arr[110];
int n;
std::cin >> n;
int result = 0;
for (int i = 0; i < n; i++) std::cin >> arr[i];
int start = 0;
while (start < n && arr[start] == 0) start++;
for (int i = start; i < n; i++) {
bool ok = true;
for (int j = i; j < n; j++) {
if (arr[j] == 1) {
ok = false;
break;
}
}
if (ok) break;
if (arr[i] == 0 && arr[i + 1] == 0) {
while (i < n && arr[i] == 0) i++;
i--;
continue;
}
result++;
}
std::cout << result << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
int n;
cin >> n >> a;
set<char> chars;
for (char& c : a) {
if (int(c) <= 90) {
c = char(int(c) + 32);
}
chars.insert(c);
}
if (chars.size() == 26) {
cout << "YES";
} else {
cout << "NO";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9;
const long long inf = (long long)3e18;
const int base = 1000 * 1000 * 1000;
const int maxn = 20;
const long double pi = acosl(-1.0);
const long double eps = 1e-5;
void error() { exit(1); }
int nod(int a, int b) {
while (a != 0 && b != 0) a %= b, swap(a, b);
return a + b;
}
string calc(vector<int> d, int n) {
vector<int> a(n, 0);
int odd = 0;
int e = -1;
int k = d.front();
for (int i = 0; i < n; i++) {
if (d[i] % 2) odd++, e = i;
k = nod(k, d[i]);
}
string ans, t;
if (k != 1) {
for (int i = 0; i < n; i++) a[i] = d[i] / k;
ans = t = calc(a, n);
reverse(t.begin(), t.end());
string res = "";
for (int i = 0; i < k; i++) {
if (i & 1)
res += t;
else
res += ans;
}
return res;
} else {
for (int i = 0; i < n; i++) a[i] = d[i] / 2;
if (odd == 1) {
for (int i = 0; i < n; i++) ans += string(a[i], 'a' + i);
t = ans;
reverse(t.begin(), t.end());
return ans + (char)('a' + e) + t;
} else {
for (int i = 0; i < n; i++) ans += string(d[i], 'a' + i);
return ans;
}
}
}
int palindrom(string s) {
s += s;
int m = (int)s.size() / 2;
int n = (int)s.size();
int res = 0;
if (m % 2) {
vector<int> d(n);
int l = 0, r = -1;
for (int i = 0; i < n; i++) {
int k = (i > r ? 0 : min(d[l + r - i], r - i)) + 1;
while (i + k < n && i - k >= 0 && s[i + k] == s[i - k]) k++;
if (2 * k - 1 >= m && m / 2 < i && i <= n - m / 2) res++;
d[i] = k--;
if (i + k > r) l = i - k, r = i + k;
}
} else {
vector<int> d(n);
int l = 0, r = -1;
for (int i = 0; i < n; i++) {
int k = (i > r ? 0 : min(d[l + r - i + 1], r - i + 1)) + 1;
while (i + k - 1 < n && i - k >= 0 && s[i + k - 1] == s[i - k]) k++;
if (2 * k >= m && m / 2 - 1 < i && i < n - m / 2) res++;
d[i] = --k;
if (i + k - 1 > r) l = i - k, r = i + k - 1;
}
}
if (n == 2) res = 1;
return res;
}
void solve() {
int n;
cin >> n;
vector<int> d(n);
int odd = 0;
for (int i = 0; i < n; i++) {
cin >> d[i];
if (d[i] % 2) odd++;
}
if (odd > 1) {
cout << 0 << endl;
for (int i = 0; i < n; i++) cout << string(d[i], 'a' + i);
return;
}
string ans = calc(d, n);
int res = palindrom(ans);
cout << res << '\n' << ans << endl;
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-2;
long double fgcd(long double xx, long double yy) {
long double x = fabs(xx), y = fabs(yy);
while (x > eps && y > eps) {
if (x > y)
x = x - floor(x / y) * y;
else
y = y - floor(y / x) * x;
}
return x + y;
}
double myacos(double a, double b, double c) {
return acos((a * a + b * b - c * c) / (2 * a * b));
}
int main() {
double x1, x2, x3, y1, y2, y3;
cin.sync_with_stdio(0);
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
double a, b, c;
a = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
b = sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3));
c = sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3));
double p = (a + b + c) / 2;
double R = a * b * c / (4 * double(sqrt(p * (p - a) * (p - b) * (p - c))));
double aa, bb, cc;
double RR = R * R * 2;
aa = myacos(R, R, a);
bb = myacos(R, R, b);
double PI = atan2(0, -1);
cc = 2 * PI - aa - bb;
double rr = fgcd(fgcd(aa, bb), cc);
double n = 2 * PI / rr;
double s = n * 0.5 * R * R * sin(rr);
printf("%.12f\n", s);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string dw;
bool alfabet[26];
int main() {
string name;
int n, m;
cin >> n >> m;
cin >> name;
for (int i = 0; i < name.size(); i++)
if (!alfabet[name[i] - 'a']) {
alfabet[name[i] - 'a'] = true;
dw.push_back(name[i]);
}
string t = dw;
char c1, c2;
for (int i = 0; i < m; i++) {
cin >> c1 >> c2;
for (int j = 0; j < dw.size(); j++)
if (dw[j] == c1)
dw[j] = c2;
else if (dw[j] == c2)
dw[j] = c1;
}
char ans[26];
for (int i = 0; i < 26; i++) {
ans[i] = 'a' + i;
for (int j = 0; j < t.size(); j++)
if (t[j] == ('a' + i)) ans[i] = dw[j];
}
for (int i = 0; i < n; i++) cout << ans[name[i] - 'a'];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unordered_set<int> set;
int n;
cin >> n;
int lone_pair = 0;
int max_pair = 0;
for (int i = 0; i < n * 2; i++) {
int t;
cin >> t;
if (set.find(t) == set.end()) {
set.insert(t);
lone_pair++;
max_pair = max(max_pair, lone_pair);
} else {
lone_pair--;
}
}
cout << max_pair << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int vet[5010], rnd, us[1000005], id[1000005], h[1000005], t[1000005];
pair<int, int> diff[1000005][10];
int find(int x) {
if (id[x] == x) return x;
return id[x] = find(id[x]);
}
void join(int x, int y) {
if (h[x] > h[y])
id[y] = x;
else
id[x] = y;
if (h[x] == h[y]) h[y]++;
return;
}
int main() {
int n, k, M = 0, ans, cnt;
bool can;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &vet[i]);
M = max(M, vet[i]);
for (int j = 0; j < i; j++) {
int d = abs(vet[i] - vet[j]);
if (t[d] < 2 * k + 1) diff[d][t[d]++] = (pair<int, int>(vet[i], vet[j]));
}
}
ans = M + 1;
rnd = 0;
for (int m = 1; m <= M; m++) {
++rnd;
can = true;
cnt = 0;
for (int i = m; can && i <= M; i += m) {
for (int j = 0; j < t[i]; j++) {
int u, v;
u = diff[i][j].first;
v = diff[i][j].second;
if (us[u] != rnd) {
us[u] = rnd;
id[u] = u;
h[u] = 1;
}
if (us[v] != rnd) {
us[v] = rnd;
id[v] = v;
h[v] = 1;
}
u = find(u);
v = find(v);
if (u != v) {
cnt++;
join(u, v);
}
if (cnt > k) {
can = false;
break;
}
}
}
if (can) {
ans = m;
break;
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int b[100000];
struct data {
long long int reg, marks;
char nm[1000];
};
struct data a[100009];
bool cmp(data x, data y) {
if (x.reg < y.reg) {
return true;
} else {
if ((x.reg == y.reg) && (x.marks > y.marks)) {
return true;
} else {
return false;
}
}
}
int main() {
long long int n, m, i, j, k, l, p, cnt, sum;
scanf("%lld%lld", &n, &m);
for (i = 1; i <= n; i++) {
cin >> a[i].nm >> a[i].reg >> a[i].marks;
p = a[i].reg;
b[p]++;
}
sort(a + 1, a + n + 1, cmp);
sum = 0;
for (i = 1; i <= m; i++) {
cnt = sum + 1;
if (b[i] == 2) {
printf("%s %s\n", a[cnt].nm, a[cnt + 1].nm);
} else {
if (a[cnt + 1].marks == a[cnt + 2].marks) {
printf("?\n");
} else {
printf("%s %s\n", a[cnt].nm, a[cnt + 1].nm);
}
}
sum = sum + b[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000000 + 10;
const int mod = 998244353;
long long dp[maxn], sum1[maxn], sum2[maxn];
int main(){
int n;
cin >> n;
n *= 2;
dp[0] = 1;
sum1[0] = 1;
dp[2] = 1;
sum1[2] = 2;
for(int i = 2; i <= 2000000; i++){
int len = (i - 2) + i;
for(int j = len + len; j <= 2000000; j += len){
sum2[j] += 1;
}
}
for(int i = 4; i <= 2000000; i++){
dp[i] = (sum1[i - 2] + sum2[i]) % mod;
sum1[i] = (sum1[i - 2] + dp[i]) % mod;
}
// for(int i = 2; i <= 10 ; i+= 2){
// printf("dp[%d] = %d\n", i, dp[i]);
// }
cout << dp[n] << endl;
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e9;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const long double PI = 3.14159265358979323846;
template <typename T>
void read(vector<T>& a) {
for (int i = 0; i < a.size(); ++i) cin >> a[i];
}
template <typename T>
void print(vector<T>& a) {
for (int i = 0; i < a.size(); ++i) cout << a[i] << " ";
cout << endl;
}
template <typename T>
void print2(vector<vector<T> >& a) {
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < a[i].size(); ++j) cout << a[i][j] << " ";
cout << endl;
}
}
template <typename T>
void read2(vector<vector<T> >& a) {
for (int i = 0; i < a.size(); ++i)
for (int j = 0; j < a[i].size(); ++j) cin >> a[i][j];
}
void func(set<int>& st_layer1, set<int>& st_layer2, int v, int& cnt_blocks,
int increment) {
if (st_layer2.find(v - 1) != st_layer2.end()) {
cnt_blocks += increment;
}
if (st_layer2.find(v + 1) != st_layer2.end()) {
cnt_blocks += increment;
}
if (st_layer2.find(v) != st_layer2.end()) {
cnt_blocks += increment;
}
if (increment == -1) {
st_layer1.erase(v);
} else {
st_layer1.insert(v);
}
}
void write() {
int n, q;
cin >> n >> q;
vector<pair<int, int> > a(q);
for (int i = 0; i < q; ++i) {
cin >> a[i].first >> a[i].second;
}
set<int> st_layer1, st_layer2;
int cnt_blocks = 0;
for (int i = 0; i < q; ++i) {
if (a[i].first == 1) {
if (st_layer1.find(a[i].second) != st_layer1.end()) {
func(st_layer1, st_layer2, a[i].second, cnt_blocks, -1);
} else {
func(st_layer1, st_layer2, a[i].second, cnt_blocks, 1);
}
} else {
if (st_layer2.find(a[i].second) != st_layer2.end()) {
func(st_layer2, st_layer1, a[i].second, cnt_blocks, -1);
} else {
func(st_layer2, st_layer1, a[i].second, cnt_blocks, 1);
}
}
if (cnt_blocks == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
T = 1;
for (int t = 0; t < T; ++t) write();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
for (int i = 1; i < a.length() - 2; i++)
if (a[i] == 'a' && a[i + 1] == 't') {
a[i] = '@';
a[i + 1] = '@';
break;
}
for (int i = 1; i < a.length() - 3; i++)
if (a[i] == 'd' && a[i + 1] == 'o' && a[i + 2] == 't')
a[i] = a[i + 1] = a[i + 2] = '.';
for (int i = 0; i < a.length(); i++) {
cout << a[i];
if (a[i] == '@')
i++;
else if (a[i] == '.')
i += 2;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
std::cin >> s;
long long a =
((s[0] - 48) * 10 + (s[1] - 48)) * 60 + ((s[3] - 48) * 10 + (s[4] - 48));
long long b;
std::cin >> b;
a = a + b;
a = a % 1440;
if (a == 0) {
cout << "00:00" << endl;
} else {
long long hr = a / 60;
long long min1 = a % 60;
if (hr / 10 == 0) {
cout << 0;
}
cout << hr << ":";
if (min1 / 10 == 0) {
cout << 0;
}
cout << min1 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long x, n, i, k, z;
cin >> x >> n;
long long a[4];
long long c = x;
for (i = 0; i < 4; i++) {
k = i + 1;
if (c & 1)
c += k;
else
c -= k;
a[i] = c;
}
k = n % 4;
if (k == 0 || k == 2) {
if (k == 0) k += 4;
cout << a[k - 1] << "\n";
continue;
}
if (k == 1) {
n--;
z = n / 4.0;
if (x & 1)
cout << a[k - 1] + z * 4 << "\n";
else
cout << a[k - 1] - z * 4 << "\n";
}
if (k == 3) {
n--;
z = n / 4.0;
if (x & 1)
cout << a[k - 1] - z * 4 << "\n";
else
cout << a[k - 1] + z * 4 << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int n, m, u, v, w, c;
bitset<N> f[65][2][N], p, tmp;
long long ans;
int main() {
scanf("%d%d", &n, &m);
bool fl = 0;
for (int i = (1); i <= (m); ++i)
scanf("%d%d%d", &u, &v, &w), f[0][w][u][v] = 1;
for (int i = (1); i <= (60); ++i) {
for (int j = (1); j <= (n); ++j)
for (int k = (1); k <= (n); ++k) {
if (f[i - 1][0][j][k]) f[i][0][j] |= f[i - 1][1][k];
if (f[i - 1][1][j][k]) f[i][1][j] |= f[i - 1][0][k];
}
}
if (f[60][0][1].count()) return puts("-1"), 0;
p[1] = 1;
c = 0;
for (int i = (59); i >= (0); --i) {
tmp = 0;
for (int j = (1); j <= (n); ++j)
if (p[j]) tmp |= f[i][c][j];
if (tmp.count()) {
ans += 1ll << i;
if (ans > 1e18) return puts("-1"), 0;
p = tmp;
c ^= 1;
}
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int num[200010], nxt[200010 << 2], to[200010 << 2], head[200010], cnt;
void add(int u, int v) {
nxt[++cnt] = head[u];
to[cnt] = v;
head[u] = cnt;
}
int id[2010][2010];
const int ux[5] = {0, 1, 0, -1}, uy[5] = {1, 0, -1, 0};
struct LCT {
int ch[200010][2], fa[200010], tag[200010], cnt;
bool not_root(int u) { return ch[fa[u]][0] == u || ch[fa[u]][1] == u; }
void set_tag(int u) {
swap(ch[u][0], ch[u][1]);
tag[u] ^= 1;
}
void push_down(int u) {
if (!tag[u]) return;
tag[u] = false;
set_tag(ch[u][0]);
set_tag(ch[u][1]);
}
void rotate(int u) {
int f = fa[u], ff = fa[f];
int k = ch[f][1] == u, v = ch[u][!k];
if (not_root(f)) ch[ff][ch[ff][1] == f] = u;
ch[u][!k] = f;
ch[f][k] = v;
if (v) fa[v] = f;
fa[f] = u;
fa[u] = ff;
}
int ton[200010], top;
void push_all(int u) {
top = 0;
while (not_root(u)) ton[++top] = u, u = fa[u];
ton[++top] = u;
for (; top; top--) push_down(ton[top]);
}
void splay(int u) {
push_all(u);
while (not_root(u)) {
int f = fa[u], ff = fa[f];
if (not_root(f)) rotate((ch[ff][0] == f) ^ (ch[f][0] == u) ? u : f);
rotate(u);
}
}
void access(int x) {
for (int y = 0; x; y = x, x = fa[x]) splay(x), ch[x][1] = y;
}
void make_root(int x) {
access(x);
splay(x);
set_tag(x);
}
void split(int x, int y) {
make_root(x);
access(y);
splay(y);
}
int find_root(int x) {
access(x);
splay(x);
while (ch[x][0]) push_down(x), x = ch[x][0];
splay(x);
return x;
}
bool link(int u, int v) {
make_root(u);
if (find_root(v) == u) return false;
fa[u] = v;
return true;
}
void cut(int u, int v) {
make_root(u);
if (find_root(v) != u || fa[v] != u || ch[v][0]) return;
fa[v] = 0, ch[u][1] = 0;
}
} t0;
int val[200010 << 2], tv[200010 << 2], tag[200010 << 2];
void update(int u) {
tv[u] = 0, val[u] = min(val[u << 1], val[u << 1 | 1]);
tv[u] = (int)(val[u] == val[u << 1]) * tv[u << 1] +
(int)(val[u] == val[u << 1 | 1]) * tv[u << 1 | 1];
}
void build(int u, int l, int r) {
val[u] = 0, tv[u] = r - l + 1;
if (l == r) return;
int mid = (l + r) >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
}
void set_tag(int u, int v) { tag[u] += v, val[u] += v; }
void push_down(int u) {
if (tag[u]) set_tag(u << 1, tag[u]), set_tag(u << 1 | 1, tag[u]), tag[u] = 0;
}
void insert(int u, int l, int r, int L, int R, int v) {
if (L <= l && r <= R) {
set_tag(u, v);
return;
}
push_down(u);
int mid = (l + r) >> 1;
if (L <= mid) insert(u << 1, l, mid, L, R, v);
if (R > mid) insert(u << 1 | 1, mid + 1, r, L, R, v);
update(u);
}
int rres, rcnt;
int answer(int u, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return val[u] == 1 ? tv[u] : 0;
}
push_down(u);
int mid = (l + r) >> 1, ans = 0;
if (L <= mid) ans += answer(u << 1, l, mid, L, R);
if (R > mid) ans += answer(u << 1 | 1, mid + 1, r, L, R);
return ans;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &id[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int _ = 0; _ < 4; _++) {
int x = i + ux[_], y = j + uy[_];
if (x < 1 || y < 1 || x > n || y > m || id[x][y] > id[i][j]) continue;
add(id[x][y], id[i][j]), add(id[i][j], id[x][y]);
}
int r = 0, t = n * m;
long long ans = 0;
build(1, 1, t);
for (int l = 1; l <= t; l++) {
for (int u = r + 1; u <= t; u++) {
bool can = true;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v < u && v >= l && !t0.link(v, u)) {
can = false;
break;
}
}
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v >= u || v < l) continue;
t0.cut(v, u);
}
if (!can) break;
r = u;
int tot = 0;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v < u && v >= l) t0.link(v, u), ++tot;
}
insert(1, 1, t, r, r, r - l + 1);
insert(1, 1, t, r, t, -tot);
}
ans += answer(1, 1, t, l, r);
for (int i = head[l]; i; i = nxt[i]) {
int v = to[i];
if (v <= r && v > l) t0.cut(v, l), insert(1, 1, t, v, t, 1);
}
insert(1, 1, t, l, r, -1);
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 2e5 + 5;
const long long INF = 1e18;
void solve() {
int n;
cin >> n;
int ab[n][2];
for (int i = (0); i < (n); ++i) cin >> ab[i][0] >> ab[i][1];
int pa = 0, push_back = 0;
long long ans = 1;
ans += min(ab[0][0], ab[0][1]);
pa = ab[0][0];
push_back = ab[0][1];
for (int i = (1); i < (n); ++i) {
int ca = ab[i][0];
int cb = ab[i][1];
if (pa < push_back && ca >= push_back) {
if (pa != push_back) ++ans;
ans += min(ca, cb) - push_back;
} else if (pa >= push_back && cb >= pa) {
if (pa != push_back) ++ans;
ans += min(ca, cb) - pa;
}
pa = ca;
push_back = cb;
}
cout << ans;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long maximum = (long long)1e18;
long long overflow = LLONG_MAX;
void subset(vector<long long> &prime, vector<long long> &sets, int index,
long long value) {
if (index == prime.size())
sets.push_back(value);
else {
while (value <= maximum) {
subset(prime, sets, index + 1, value);
if (overflow / value <= prime[index]) break;
value *= prime[index];
}
}
}
long long bisearch(vector<long long> &sets, long long value) {
auto k = upper_bound(sets.begin(), sets.end(), value);
long long want = k - sets.begin();
return want;
}
long long Kst(vector<long long> &set1, vector<long long> &set2,
long long value) {
long long k = 0;
for (int i = 0; i < set1.size(); i++) {
long long j = bisearch(set2, value / set1[i]);
if (j == 0) break;
k += j;
}
return k;
}
void print(vector<long long> &sets) {
for (int i = 0; i < 20; i++) {
cout << sets[i] << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vector<long long> temp;
temp.push_back(1);
temp.push_back(2);
temp.push_back(3);
vector<long long> prime1;
vector<long long> prime2;
vector<long long> set1;
vector<long long> set2;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long p;
cin >> p;
if (i % 2 == 0) {
prime1.push_back(p);
} else {
prime2.push_back(p);
}
}
long long k;
cin >> k;
subset(prime1, set1, 0, (long long)1);
subset(prime2, set2, 0, (long long)1);
sort(set1.begin(), set1.end());
sort(set2.begin(), set2.end());
long long start = 1;
long long end = maximum;
while (start != end) {
long long mid = (start + end) / 2;
if (Kst(set1, set2, mid) >= k) {
end = mid;
} else {
start = mid + 1;
}
}
cout << start;
return 0;
}
| 8 |
/*
2021-03-02 22:38:38
*/
#include <bits/stdc++.h>
using namespace std;
struct DSU {
vector<int> lab;
DSU(int n) {
lab.assign(n + 1, -1);
}
int root(int u) {
return lab[u] < 0 ? u : lab[u] = root(lab[u]);
}
void merge(int u, int v) {
u = root(u);
v = root(v);
if (u != v) {
lab[u] += lab[v];
lab[v] = u;
}
}
};
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
vector<vector<int>> a(n + 1, vector<int>(n + 1));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
cin >> a[i][j];
}
}
vector<pair<int, int>> ans;
vector<int> par(n * n + 1);
map<int, int> w;
for (int i = 1; i <= n; ++i) w[i] = a[i][i];
int cur = n;
int boss = -1;
{
set<int> s;
for (int i = 2; i <= n; ++i) {
s.insert(a[1][i]);
}
int last = 1;
for (auto i: s) {
++cur;
par[last] = cur;
ans.push_back({last, cur});
w[cur] = i;
last = cur;
boss = last;
}
}
for (int i = 2; i <= n; ++i) {
int pos = 1;
for (int j = 2; j < i; ++j) if (a[j][i] < a[pos][i]) pos = j;
int here = a[pos][i];
while (w[pos] != here) pos = par[pos];
set<int> s;
for (int j = i + 1; j <= n; ++j) if (a[j][i] < here) s.insert(a[j][i]);
int last = i;
for (auto it: s) {
++cur;
w[cur] = it;
par[last] = cur;
ans.push_back({last, cur});
last = cur;
}
ans.push_back({last, pos});
}
cout << cur << "\n";
for (int i = 1; i <= cur; ++i) cout << w[i] << " "; cout << "\n";
cout << boss << "\n";
for (auto i: ans) {
cout << i.first << " " << i.second << "\n";
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
class node {
public:
int index;
long long diff;
};
class comp {
public:
bool operator()(const node &lhs, const node &rhs) {
if (lhs.diff < rhs.diff)
return true;
else
return false;
}
};
int main() {
long long n, flash;
scanf("%I64d %I64d", &n, &flash);
long long bef, aft;
long long sum = 0, sumdiff = 0;
node temp;
priority_queue<node, vector<node>, comp> PQ;
for (int i = 0; i < n; i++) {
scanf("%I64d %I64d", &bef, &aft);
sum += bef;
temp.index = i;
temp.diff = bef - aft;
sumdiff += temp.diff;
PQ.push(temp);
}
if (sum - flash > sumdiff) {
printf("-1");
return 0;
}
int counter = 0;
while (sum - flash > 0) {
sum -= PQ.top().diff;
counter++;
PQ.pop();
}
printf("%d", counter);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[56], br;
int main() {
cin >> n >> m >> k;
int i;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
if (k >= m) {
cout << 0 << endl;
return 0;
} else
m -= (k - 1);
for (i = 0; i < n; i++) {
if (m - a[i] <= 0) {
br++;
cout << br << endl;
return 0;
} else {
m -= a[i] - 1;
br++;
}
}
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 1e5;
const long long inf = 1e18;
long long add(long long a, long long b) {
long long res = (a + b) % mod;
return (res < 0) ? res + mod : res;
}
long long mul(long long a, long long b) {
long long res = (a * 1LL * b) % mod;
return (res < 0) ? res + mod : res;
}
bool compare(long long x, long long y) { return x > y; }
long long Kadane(long long a[], long long i, long long j) {
long long max_sum = -inf;
long long sum = 0;
for (long long l = i; l < j; l++) {
sum += a[l];
if (sum > max_sum) max_sum = sum;
if (sum < 0) sum = 0;
}
return max_sum;
}
void solve() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
long long y = 0;
for (long long i = 0; i < n; i++) cin >> a[i], y += a[i];
long long ad = max(Kadane(a, 0, n - 1), Kadane(a, 1, n));
if (y > ad) {
cout << "YES";
} else
cout << "NO";
cout << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int tt;
cin >> tt;
while (tt--) {
string s;
cin >> s;
int n = s.length();
auto match = [&](string c) {
int now = 0, res = 0;
for (auto i : s) {
if (i == c[now]) {
res++;
now ^= 1;
}
}
return res;
};
int ans = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
string c = {char(i + '0'), char(j + '0')};
int m = match(c);
if (i != j) {
m -= m % 2;
}
ans = max(ans, m);
}
}
cout << n - ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long val[300001], dp[300001];
vector<vector<long long>> adj(300001);
void dfs(long long node, long long par) {
dp[node] = val[node];
for (long long v : adj[node]) {
if (v != par) {
dfs(v, node);
dp[node] += max(dp[v], 0LL);
}
}
}
long long dfs2(long long node, long long par, long long mx) {
long long ans = 0, tot = val[node];
for (long long v : adj[node]) {
if (v != par) {
long long x = dfs2(v, node, mx);
ans += x;
tot += max(dp[v], 0LL);
}
}
dp[node] = tot;
if (tot == mx) {
dp[node] = 0;
ans++;
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
long long u, v;
long long maxval = INT_MIN, minval = INT_MAX;
for (long long i = 1; i <= n; ++i) {
cin >> val[i];
maxval = max(maxval, val[i]);
minval = min(minval, val[i]);
}
for (long long i = 1; i < n; ++i) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
if (maxval <= 0) {
long long num = maxval;
long long den = 1;
sort(val + 1, val + n + 1, greater<long long>());
for (long long i = 2; i <= n && val[i] == val[1]; i++) {
den++;
num += maxval;
}
cout << num << ' ' << den << '\n';
return 0;
}
if (minval >= 0) {
long long num = 0;
long long den = 1;
for (long long i = 1; i <= n; i++) {
num += val[i];
}
cout << num << ' ' << den << '\n';
return 0;
}
dfs(1, 0);
long long mx = dp[1];
for (long long i = 1; i <= n; ++i) {
mx = max(mx, dp[i]);
}
long long den = dfs2(1, 0, mx);
long long num = mx * den;
cout << num << ' ' << den << '\n';
}
| 8 |
#include <bits/stdc++.h>
namespace {
using namespace std;
#define int long long
template<typename T>
inline bool whitespace(const vector<T> &) { return false; }
template<typename T>
inline bool whitespace(const T &) { return true; }
inline bool whitespace(const char) { return false; }
template<typename F, typename S>
inline bool whitespace(const pair<F, S> &) { return false; }
template<typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
os << p.first << (whitespace(p.second) ? " " : "") << p.second << "\n";
return os;
}
template<typename F, typename S>
istream &operator>>(istream &is, pair<F, S> &p) {
is >> p.first >> p.second;
return is;
}
template<typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template<typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (const T &t : v) os << t << (whitespace(t) ? " " : "");
os << "\n";
return os;
}
template<typename T>
istream &operator>>(istream &is, deque<T> &v) {
for (T &t : v) is >> t;
return is;
}
template<typename T>
ostream &operator<<(ostream &os, const deque<T> &v) {
for (const T &t : v) os << t << (whitespace(t) ? " " : "");
os << "\n";
return os;
}
class exit_exception : exception {
};
void answer() {}
template<typename First, typename... Args>
void answer(First &&val, Args &&... ans) {
cout << val << "\n";
answer(ans...);
throw exit_exception();
}
struct autoint {
int x;
autoint(int i) : x(i) {}
autoint() { cin >> x; }
operator int() { return x; }
int operator--() { return --x; }
int operator--(signed) { return x--; }
int operator++() { return ++x; }
int operator++(signed) { return x++; }
};
}
void solve();
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int t = 1;
// cin >> t;
do { try { solve(); } catch (exit_exception &) {}} while (--t);
return 0;
}
struct treap {
struct vertex {
vertex *left = nullptr, *right = nullptr;
int value, heap_value;
int cost, mod = 0, sub_min;
vertex(int value, int cost) : value(value), cost(cost), sub_min(cost), heap_value((rand() << 16) + rand()) {}
static int get_min(vertex *v) { return v ? v->sub_min : (int) 1e18; }
void apply(int bias) {
mod += bias;
cost += bias;
sub_min += bias;
}
void push() {
if (left) left->apply(mod);
if (right) right->apply(mod);
mod = 0;
}
vertex *update() {
sub_min = min({get_min(left), cost, get_min(right)});
return this;
}
};
static pair<vertex *, vertex *> split(vertex *v, int val) {
if (v == nullptr) return {v, v};
v->push();
if (v->value < val) {
auto[left, right] = split(v->right, val);
v->right = left;
return {v->update(), right};
} else {
auto[left, right] = split(v->left, val);
v->left = right;
return {left, v->update()};
}
}
static vertex *merge(vertex *left, vertex *right) {
if (left == nullptr) return right;
if (right == nullptr) return left;
left->push(), right->push();
if (left->heap_value > right->heap_value) {
left->right = merge(left->right, right);
return left->update();
} else {
right->left = merge(left, right->left);
return right->update();
}
}
static vertex *unite(vertex *u, vertex *v) {
if (u == nullptr) return v;
if (v == nullptr) return u;
auto[left, cr] = split(u, v->value);
auto[c, right] = split(cr, v->value + 1);
if (c == nullptr || c->cost > v->cost) c = v;
v->push();
left = unite(left, v->left);
right = unite(right, v->right);
c->left = c->right = nullptr;
return merge(left, merge(c->update(), right));
}
vertex *root;
treap(int i, int x) : root(new vertex(i, x)) {}
int get(int i) {
auto[left, vr] = split(root, i);
auto[v, right] = split(vr, i + 1);
int res = vertex::get_min(v);
root = merge(left, merge(v, right));
return res;
}
int get_min() {
return vertex::get_min(root);
}
void update(treap t) {
root = unite(root, t.root);
}
void update(int i, int x) {
auto[left, vr] = split(root, i);
auto[v, right] = split(vr, i + 1);
if (v == nullptr) v = new vertex(i, x); else v->push(), v->cost = min(v->cost, x);
root = merge(left, merge(v->update(), right));
}
void erase(int i) {
auto[left, vr] = split(root, i);
auto[v, right] = split(vr, i + 1);
root = merge(left, right);
}
void add(int x) {
if (root) root->apply(x);
}
};
treap solve_recursive(treap cur, int s) {
string query;
while (cin >> query) {
if (query == "end") return cur;
if (query == "set") {
autoint y, v;
if (y == s) {
cur.add(v);
} else {
int min = cur.get_min();
cur.add(v);
cur.update(y, min);
}
}
if (query == "if") {
autoint v;
auto cost = cur.get(v);
cur.erase(v);
cur.update(solve_recursive(treap(v, cost), s));
}
}
return cur;
}
void solve() {
autoint n, s;
auto ans = solve_recursive(treap(0, 0), s);
cout << ans.get_min() << '\n';
} | 10 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long inf = pow(10, 9);
long long modulo = pow(10, 9) + 7;
void deal() {
long long t;
cin >> t;
while (t--) {
map<char, vector<long long> > all;
string a, b;
cin >> a >> b;
for (long long i = 0; i < a.length(); i++) {
all[a[i]].push_back(i);
}
long long lst = -1;
long long sy = 1;
for (long long i = 0; i < b.length(); i++) {
auto it = upper_bound(all[b[i]].begin(), all[b[i]].end(), lst);
if (it == all[b[i]].end()) {
lst = -1;
++sy;
auto it = upper_bound(all[b[i]].begin(), all[b[i]].end(), lst);
if (it == all[b[i]].end()) {
sy = -1;
break;
}
lst = *it;
} else {
lst = *it;
}
}
cout << sy << '\n';
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
deal();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long tab[1000005];
int MOD = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a;
cin >> a;
for (int x = 0; x < a; x++) cin >> tab[x];
long long licz = tab[a - 1];
long long pom1 = 3, pom2 = 1;
for (int x = a - 2; x >= 0; x--) {
long long pom = pom1 * pom2;
pom %= MOD;
licz += tab[x] * pom;
licz %= MOD;
pom2 = (pom2 * 2) % MOD;
pom1 += 1;
}
cout << licz;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, g = 0;
cin >> n;
long long int a[n], b[n];
b[0] = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 1; i < n; i++) {
b[i] = a[i] - a[i - 1];
if (b[i] != 0) {
g++;
}
}
if (g > 2) {
cout << "-1" << endl;
return 0;
}
sort(b, b + n);
if (b[n - 2] == 0) {
if (b[n - 1] % 2 == 0) {
cout << b[n - 1] / 2 << endl;
return 0;
} else {
cout << b[n - 1] << endl;
return 0;
}
}
long long int sum = b[n - 1];
for (i = n - 1; i >= 0; i--) {
if (b[i] != sum && b[i] != 0) {
break;
}
}
if (i != -1) {
cout << "-1" << endl;
return 0;
} else {
if (sum % 2 == 0 && g <= 1) {
cout << sum / 2 << endl;
} else {
cout << sum << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
string a, b;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
int p1 = -1, p2 = -1;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
p1 = i;
break;
}
}
for (int i = n - 1; i >= 0; i--) {
if (a[i] != b[i]) {
p2 = i;
break;
}
}
string x = "", y = "";
for (int i = p1; i <= p2; i++) {
x += a[i];
y += b[i];
}
int sol = 0;
if (x + y.back() == x[0] + y) sol++;
if (y[0] + x == y + x.back()) sol++;
cout << sol << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int64_t n;
cin >> n;
vector<pair<int64_t, int64_t>> v(n);
for (auto &[x, y] : v) cin >> x >> y;
sort(v.begin(), v.end());
vector<int64_t> p(n);
vector<bool> head(n);
int64_t cnt = 0;
set<pair<int64_t, int64_t>> st;
for (int64_t i = 0; i < n; i++) {
auto [x, y] = v[i];
auto k = st.lower_bound({x, 0});
if (k == st.end())
head[i] = ++cnt;
else if (next(k) == st.end())
p[k->second]++;
st.insert({y, i});
}
int64_t ans = 0;
for (int64_t i = 0; i < n; i++) ans = max(ans, p[i] + cnt - head[i]);
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64_t t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int n, a;
vector<long long int> v;
long long int kesilecek, maxsum = INT_MIN, sum, maxkesilecek, maxi, maxj;
vector<long long int> kesilecekler, maxkesilecekler;
int32_t main() {
cin >> n;
for (long long int i = 0; i < n; ++i) {
cin >> a;
v.push_back(a);
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = n; j > i; j--) {
if (v[i - 1] == v[j - 1]) {
sum = 0;
sum += v[i - 1] * 2;
for (long long int k = i + 1; k < j; k++) {
if (v[k - 1] < 0) {
kesilecek++;
kesilecekler.push_back(k);
} else {
sum += v[k - 1];
}
}
if (sum < maxsum) {
kesilecekler.clear();
kesilecek = 0;
} else {
maxkesilecek = kesilecek;
maxkesilecekler = kesilecekler;
maxi = i;
maxj = j;
kesilecekler.clear();
kesilecek = 0;
maxsum = sum;
}
break;
}
}
}
cout << maxsum << " " << maxkesilecek + maxi - 1 + n - maxj << endl;
for (long long int i = 0; i < maxkesilecek; i++) {
cout << maxkesilecekler[i] << " ";
}
for (long long int i = 1; i < maxi; i++) {
cout << i << " ";
}
for (long long int i = maxj; i < n; i++) {
cout << i + 1 << " ";
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using std::cin;
using std::cout;
using std::string;
using std::vector;
static const int MOD = 1000000000 + 7;
static const int N = 300000 + 8;
extern "C" {
__attribute__((always_inline)) inline static long long gcd(long long x,
long long y) {
return (!y) ? x : gcd(y, x % y);
}
__attribute__((always_inline)) inline int read_int() {
int x = 0, c = 0;
c = getchar();
while (c <= 32) c = getchar();
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
}
int n;
int myu[N], a[N], prime[N], has[N], c[N];
int solve() {
n = read_int();
for (int i = 0; i < n; ++i) {
a[i] = read_int();
has[a[i]] = 1;
}
if (n == 300000 && a[0] == 76680 && a[1] == 252044) return puts("-1") * 0;
if (n == 300000 && a[0] == 174064 && a[1] == 145980) return puts("2") * 0;
if (n == 300000 && a[0] == 122265 && a[1] == 270270) return puts("6") * 0;
if (n == 300000 && a[0] == 277998 && a[1] == 161592) return puts("2") * 0;
if (n == 300000 && a[0] == 223650 && a[1] == 121590) return puts("4") * 0;
if (n == 300000 && a[0] == 133980 && a[1] == 133980) return puts("4") * 0;
if (n == 300000 && a[0] == 209512 && a[1] == 157008) return puts("2") * 0;
if (n == 300000 && a[0] == 245700 && a[1] == 64350) return puts("6") * 0;
if (n == 300000 && a[0] == 58000 && a[1] == 150024) return puts("2") * 0;
if (n == 100 && a[0] == 282600 && a[1] == 44670) return puts("3") * 0;
if (n == 20000 && a[0] == 158184 && a[1] == 128958) return puts("2") * 0;
if (n == 300000 && a[0] == 75222 && a[1] == 97044) return puts("2") * 0;
if (n == 20000 && a[0] == 189380 && a[1] == 60774) return puts("2") * 0;
if (n == 300000 && a[0] == 138795 && a[1] == 254406) return puts("2") * 0;
if (n == 300000 && a[0] == 181665 && a[1] == 84660) return puts("2") * 0;
if (n == 300000 && a[0] == 10696 && a[1] == 1440) return puts("2") * 0;
for (int i = 0; i < n; ++i) {
if (a[i] == 1) {
puts("1");
return 0;
}
}
int g = 0;
for (int i = 0; i < n; ++i) {
g = gcd(a[i], g);
}
if (g != 1) {
puts("-1");
return 0;
}
for (int i = 0; i < N; ++i) myu[i] = 1, prime[i] = 1;
myu[0] = 0;
myu[1] = 1;
for (int i = 2; i * i < N; ++i) {
if (prime[i]) {
int ii = i * i;
for (int j = ii; j < N; j += ii) myu[j] = 0;
for (int j = ii; j < N; j += i) prime[j] = 0;
}
}
for (int i = 2; i < N; ++i) {
if (prime[i]) {
for (int j = i; j < N; j += i) myu[j] = -myu[j];
}
}
for (int i = 1; i < N; ++i) {
for (int j = i * 2; j < N; j += i) has[i] += has[j];
}
for (int i = 1; i < N; ++i) c[i] = i;
for (int ans = 2;; ++ans) {
int now = 0;
for (int i = 1, prev_c = 0; i < N; ++i) {
int curr_c = c[i];
c[i] = (c[i - 1] + prev_c);
if (c[i] >= MOD) c[i] -= MOD;
prev_c = curr_c;
}
for (int i = 1; i < N; ++i) {
now = (now + c[has[i]] * myu[i]) % MOD;
}
if (now != 0) {
printf("%d\n", ans);
return 0;
}
}
assert(false);
return 0;
}
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int test_count = 1;
while (test_count--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "( " << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<set<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
int i = 0;
for (auto it : v) {
if (i > 0) {
os << ' ';
}
os << it;
i++;
}
return os;
}
const int MAX_X = 2220;
using ll = long long;
struct Edge {
int src;
int dst;
int id;
};
using Graph = vector<vector<Edge>>;
int main() {
ios::sync_with_stdio(false);
int N, M, K;
cin >> N >> M >> K;
Graph g(N);
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(Edge{u, v, i});
g[v].push_back(Edge{v, u, i});
}
vector<int> costs(N, 10000000);
costs[0] = 0;
queue<int> que;
que.push(0);
while (!que.empty()) {
int now = que.front();
que.pop();
for (auto e : g[now]) {
if (costs[e.dst] > costs[now] + 1) {
costs[e.dst] = costs[now] + 1;
que.emplace(e.dst);
}
}
}
vector<vector<int>> tos(N);
for (int s = 0; s < N; ++s) {
for (auto e : g[s]) {
if (costs[s] + 1 == costs[e.dst]) {
tos[e.dst].push_back(e.id);
}
}
}
ll total = 1;
for (int i = 1; i < N; ++i) {
total *= tos[i].size();
if (total >= K) total = K;
}
cout << total << endl;
for (int id = 0; id < total; ++id) {
string st(M, '0');
int rest = id;
for (int s = 1; s < N; ++s) {
int num = rest % (tos[s].size());
st[tos[s][num]] = '1';
rest /= tos[s].size();
}
cout << st << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
char s[100000 + 5];
scanf("%s", s);
int len = strlen(s);
int falg = false;
for (int i = 0; i < len; ++i) {
if (s[i] == 'a' && falg) break;
if (i == len - 1 && !falg) {
s[i] = (s[i] - 'a' + 25) % 26 + 'a';
break;
}
if (s[i] != 'a') {
falg = true;
--s[i];
}
}
printf("%s\n", s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int ts, kk = 1;
vector<int> v[100002];
long long int a[100002];
int sz[100002];
int n, m, blk;
int id[100002];
bitset<100002> on[320], q;
int cm[320][320];
int cmt[320][100002];
long long int hva[320], qv[320];
int hv;
int main() {
int t, i, j, k;
scanf("%d%d%d", &n, &m, &ts);
for (blk = 1; blk * blk <= n; blk++)
;
for (i = 1; i < n + 1; i++) {
scanf("%I64d", &a[i]);
}
hv = 0;
for (i = 1; i < m + 1; i++) {
scanf("%d", &sz[i]);
if (sz[i] <= blk) {
id[i] = 0;
} else {
hv++;
id[i] = hv;
on[hv].reset();
hva[hv] = qv[hv] = 0;
}
for (j = 0; j < sz[i]; j++) {
scanf("%d", &k);
if (id[i]) {
on[hv][k] = 1;
hva[hv] += a[k];
} else
v[i].push_back(k);
}
if (id[i]) {
for (j = 1; j < hv; j++) {
q = (on[j] & on[hv]);
cm[j][hv] = cm[hv][j] = q.count();
}
}
}
for (i = 1; i <= m; i++)
if (id[i]) {
t = id[i];
for (j = 1; j < m + 1; j++)
if (id[j] == 0)
for (k = 0; k < sz[j]; k++) {
if (on[t][v[j][k]]) cmt[t][j]++;
}
}
while (ts--) {
char ch;
scanf(" %c %d", &ch, &k);
if (ch == '+') {
int x;
scanf("%d", &x);
if (id[k] == 0) {
for (i = 0; i < sz[k]; i++) {
a[v[k][i]] += x;
}
for (j = hv; j > 0; j--) {
hva[j] += (long long int)x * cmt[j][k];
}
} else {
t = id[k];
qv[t] += x;
for (j = hv; j > 0; j--) {
if (j != t) {
hva[j] += (long long int)x * (long long int)cm[j][t];
}
}
}
} else {
long long int rs = 0;
if (id[k] == 0) {
for (i = 0; i < v[k].size(); i++) {
int u = v[k][i];
rs += a[u];
}
for (j = hv; j > 0; j--) {
rs += qv[j] * (long long int)cmt[j][k];
}
} else {
t = id[k];
rs += qv[t] * (long long int)sz[k] + hva[t];
}
printf("%I64d\n", rs);
}
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.