solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const long long inf = 0x3f3f3f3f;
int n, a, b, c, d, st, len;
int t[maxn], q[maxn];
long long sum = 0, minn = inf;
long long rating = 0;
int main() {
scanf("%d%d%d%d%d%d%d", &n, &a, &b, &c, &d, &st, &len);
for (int i = 1; i <= n; i++) scanf("%d%d", &t[i], &q[i]);
int pos = 1;
t[0] = -1;
rating = st;
for (int i = 1; i <= n; i++) {
while (pos <= n && t[pos] - t[i] < len) {
sum += q[pos] ? c : -d;
minn = min(minn, sum);
pos++;
}
if (rating + minn >= 0) {
cout << t[i - 1] + 1;
return 0;
}
sum -= q[i] ? c : -d;
minn -= q[i] ? c : -d;
rating += q[i] ? a : -b;
if (rating < 0) {
cout << -1;
return 0;
}
}
cout << t[n] + 1;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
long long k;
cin >> n >> k;
vector<vector<vector<long long>>> dp(
n, vector<vector<long long>>(2, vector<long long>(2 * n + 1, 0)));
vector<int> cor(n);
for (int i = 0; i < n; i++) {
cin >> cor[i];
}
if (cor[0] == cor[n - 1]) {
dp[n - 1][0][n] = k - 1;
dp[n - 1][1][n + 1] = 1;
} else {
dp[n - 1][0][n + 1] = 1;
dp[n - 1][0][n] = k - 2;
dp[n - 1][1][n] = 1;
}
for (int i = n - 1; i > 0; i--) {
if (cor[i] == cor[i - 1]) {
for (int j = 0; j < 2 * n + 1; j++) {
if (dp[i][0][j] != 0) {
(dp[i - 1][0][j] += ((k - 1) * dp[i][0][j]) % MOD) %= MOD;
(dp[i - 1][1][j + 1] += dp[i][0][j]) %= MOD;
}
if (dp[i][1][j] != 0) {
(dp[i - 1][0][j - 1] += ((k - 1) * dp[i][1][j]) % MOD) %= MOD;
(dp[i - 1][1][j] += dp[i][1][j]) %= MOD;
}
}
} else {
for (int j = 0; j < 2 * n + 1; j++) {
if (dp[i][0][j] != 0) {
(dp[i - 1][1][j] += dp[i][0][j]) %= MOD;
(dp[i - 1][0][j + 1] += dp[i][0][j]) %= MOD;
(dp[i - 1][0][j] += ((k - 2) * dp[i][0][j]) % MOD) %= MOD;
}
if (dp[i][1][j] != 0) {
(dp[i - 1][1][j - 1] += dp[i][1][j]) %= MOD;
(dp[i - 1][0][j] += dp[i][1][j]) %= MOD;
(dp[i - 1][0][j - 1] += ((k - 2) * dp[i][1][j]) % MOD) %= MOD;
}
}
}
}
long long ans = 0;
for (int i = n + 1; i <= 2 * n; i++) {
(ans += dp[0][0][i]) %= MOD;
if (i + 1 <= 2 * n) (ans += dp[0][1][i + 1]) %= MOD;
}
cout << ans << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int ST = 100010;
const int ST1 = 1000010;
const long long MOD = 1000000007;
long long ABS(long long a) {
if (a < 0)
return a * (-1);
else
return a;
}
long long binpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
a = a % MOD;
res = res % MOD;
}
return res;
}
int main() {
long long n;
cin >> n;
long long k = binpow(2, n);
long long ans = ((1 + k) * k / 2) % MOD;
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a1[100500], a2[100500];
int f[100500];
int n, m;
int used2[100500], used1[100500];
void dfs1(int v) {
if (used1[v]) return;
used1[v] = 1;
for (int i = 0; i < a1[v].size(); i++)
if (f[a1[v][i]] != 1) dfs1(a1[v][i]);
}
void dfs2(int v) {
if (used2[v]) return;
used2[v] = 1;
if (f[v] == 1) return;
for (int i = 0; i < a2[v].size(); i++) dfs2(a2[v][i]);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d", &f[i]);
for (int i = 0; i < n; i++) {
a1[i].clear();
a2[i].clear();
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
a1[x].push_back(y);
a2[y].push_back(x);
}
memset(used1, 0, sizeof(used1));
memset(used2, 0, sizeof(used2));
for (int i = 0; i < n; i++)
if (!used1[i] && f[i] == 1) dfs1(i);
for (int i = 0; i < n; i++)
if (!used2[i] && f[i] == 2) dfs2(i);
for (int i = 0; i < n; i++) printf("%d\n", used1[i] && used2[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void numgen(vector<string> &v, string &s) {
if (s.length() == 4) {
v.push_back(s);
return;
}
int p1 = s[0] - '0';
int p2 = -1, p3 = -1;
if (s.length() >= 2) {
p2 = s[1] - '0';
}
if (s.length() == 3) {
p3 = s[2] - '0';
}
for (int i = 0; i <= 9; i++) {
if (i == p1 || i == p2 || i == p3) {
continue;
}
char a = '0';
a = (char)a + i;
s.push_back(a);
numgen(v, s);
s.pop_back();
}
}
bool chk(string &s, pair<string, pair<int, int> > &pp) {
string str = pp.first;
int cnt = 0;
for (int i = 0; i < 4; i++) {
int uy = s[i] - '0';
int uv = str[i] - '0';
if (uy == uv) {
cnt++;
}
}
if (cnt == pp.second.first) {
int val = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (i == j) {
continue;
}
int y = s[i] - '0';
int yy = str[j] - '0';
if (y == yy) {
val++;
}
}
}
if (val == pp.second.second) {
return true;
} else {
return false;
}
} else {
return false;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<string> v;
for (int i = 0; i <= 9; i++) {
string s;
char a = '0';
a = (char)a + i;
s.push_back(a);
numgen(v, s);
}
int n;
cin >> n;
vector<pair<string, pair<int, int> > > vp(n);
for (int i = 0; i < n; i++) {
cin >> vp[i].first >> vp[i].second.first >> vp[i].second.second;
}
vector<string> ans;
for (int i = 0; i < v.size(); i++) {
int f = 0;
for (int j = 0; j < n; j++) {
if (chk(v[i], vp[j]) == false) {
f = 1;
break;
}
}
if (f == 0) {
ans.push_back(v[i]);
}
}
if (ans.size() > 1) {
cout << "Need more data\n";
} else if (ans.size() == 0) {
cout << "Incorrect data\n";
} else {
cout << ans[0] << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int NM = 2e5 + 10;
int p[NM], s[NM], a[NM], b[NM];
bool used[NM];
int main() {
int n, m;
scanf("%d %d", &n, &m);
unordered_map<int, vector<int>> mp;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
mp[p[i]].push_back(i);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &s[i]);
}
int c = 0, u = 0;
for (int k = 0; k <= 30; k++) {
for (int i = 1; i <= m; i++) {
if (!used[i] && !mp[s[i]].empty()) {
used[i] = true;
a[i] = k;
int idx = mp[s[i]].back();
mp[s[i]].pop_back();
b[idx] = i;
c++, u += k;
}
}
for (int i = 1; i <= m; i++) {
s[i] = (s[i] + 1) / 2;
}
}
printf("%d %d\n", c, u);
for (int i = 1; i <= m; i++) {
printf("%d ", a[i]);
}
printf("\n");
for (int i = 1; i <= n; i++) {
printf("%d ", b[i]);
}
printf("\n");
return 0;
}
| 13 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
n -= 43500;
puts(n > 0 ? (n > 2000 ? "3" : "2") : "1");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool prime[1000];
void Siev(int x) {
memset(prime, true, sizeof(prime));
for (int i = 2; i * i <= x; i++) {
if (prime[i] == true) {
for (int j = i * 2; j <= x; j += i) prime[j] = false;
}
}
}
int main() {
int n, m;
cin >> n >> m;
int flag = 0;
int prev = 0;
Siev(100);
for (int i = n + 1; i <= m; ++i) {
if (prime[i] == true && i == m && prev == 0) {
flag = 1;
}
if (prime[i] == true) {
prev = 1;
}
}
if (flag == 1) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int v[100000], c[100000], l[100000], r[100000];
int parent[100000], value[100000];
int main() {
int n, pos = 0;
cin >> n;
for (int i = 0; i < n; ++i) cin >> v[i] >> c[i] >> l[i] >> r[i];
map<pair<int, int>, pair<int, int> > hash;
map<pair<int, int>, pair<int, int> >::iterator it;
int val = -1, index = -1;
for (int i = 0; i < n; ++i) parent[i] = i, value[i] = -1;
for (int i = 0; i < n; ++i) {
pair<int, int> next = make_pair(l[i], r[i] + c[i]);
if (l[i] == 0) {
pair<int, int> make = make_pair(c[i], r[i]);
if (hash[make].first < v[i]) hash[make] = make_pair(v[i], i);
if (r[i] == 0 && val < v[i]) {
val = v[i];
index = i;
}
}
if ((it = hash.find(next)) == hash.end()) continue;
int maxi = it->second.first + v[i];
if (hash[make_pair(l[i] + c[i], r[i])].first < maxi) {
hash[make_pair(l[i] + c[i], r[i])] = make_pair(maxi, i);
parent[i] = it->second.second;
}
if (r[i] == 0 && maxi > val) val = maxi, index = i;
}
if (index == -1)
cout << 0 << endl;
else {
vector<int> ret;
while (true) {
ret.push_back(index);
if (index == parent[index]) break;
index = parent[index];
}
cout << ret.size() << endl;
for (int i = ret.size() - 1; i >= 0; --i) cout << ret[i] + 1 << " ";
cout << endl;
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long prime = 41;
int toInt(char c) {
if (c >= 'a' && c <= 'z') {
return c - 'a' + 1;
}
if (c >= '0' && c <= '9') {
return 29 + c - '0';
}
return 28;
}
vector<long long> revPrime;
vector<long long> getHash(string &kek) {
vector<long long> hash;
long long current = 0;
long long powa = 1;
for (int i = 0; i < kek.size(); ++i) {
current += toInt(kek[i]) * powa % MOD;
current %= MOD;
powa *= prime;
powa %= MOD;
hash.push_back(current);
}
return hash;
}
void add(string &kek, unordered_map<int, vector<int>> &mp, int index) {
vector<long long> hash = getHash(kek);
set<int> hashes;
for (int i = 0; i < hash.size(); ++i) {
hashes.insert(hash[i]);
}
for (int i = 1; i < kek.size(); ++i) {
for (int j = i; j < kek.size(); ++j) {
long long khash = hash[j] - hash[i - 1];
khash = ((khash % MOD) + MOD) % MOD;
khash = khash * revPrime[i] % MOD;
hashes.insert(khash);
}
}
for (auto it : hashes) {
mp[it].push_back(index);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
revPrime.push_back(1);
revPrime.push_back(658536590);
for (int i = 0; i < 20; ++i) {
revPrime.push_back((revPrime.back() * revPrime[1]) % MOD);
}
int n;
cin >> n;
vector<string> s(n);
unordered_map<string, vector<int>> mp;
for (int i = 0; i < n; ++i) {
cin >> s[i];
set<string> subs;
for (int j = 0; j < s[i].size(); ++j) {
for (int k = j; k < s[i].size(); ++k) {
subs.insert(s[i].substr(j, k - j + 1));
}
}
for (auto it : subs) {
mp[it].push_back(i);
}
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
string w;
cin >> w;
cout << mp[w].size() << " ";
if (mp[w].empty()) {
cout << "-" << endl;
} else {
cout << s[mp[w][0]] << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const N = 5e5 + 10, oo = 1e9;
int mod = oo + 7;
long long const OO = 1e18;
int n, q;
int aa[N], bb[N];
long long cum[N], an[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> aa[i];
cin >> q;
for (int i = 0; i < q; i++) {
cin >> bb[i];
an[bb[i]] = -1;
}
sort(aa + 1, aa + n + 1);
for (int i = 1; i <= n; i++) cum[i] = aa[i] + cum[i - 1];
for (int i = 0; i < q; i++) {
if (an[bb[i]] != -1) continue;
an[bb[i]] = 0;
long long pro = 1;
for (long long j = n - 1, d = 1; j > 0;
j -= pro * 1LL * bb[i], d++, pro *= bb[i]) {
int l = max(0LL, j - pro * 1LL * bb[i]);
an[bb[i]] += d * (cum[j] - cum[l]);
}
}
for (int i = 0; i < q; i++) cout << an[bb[i]] << ' ';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long c, d;
cin >> c >> d;
long long a = 0, b = 0;
if (c == 0 && d == 0) {
cout << "0" << endl;
} else if (c == d) {
cout << "1" << endl;
} else if (abs(c - d) % 2 == 0) {
cout << "2" << endl;
} else {
cout << "-1" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
const long long mod = 1e9 + 7;
long long fact[maxn + 5], inv[maxn + 5], x[maxn + 5], y[maxn + 5],
sum[maxn + 5];
void init() {
fact[0] = 1;
for (long long i = 1; i <= maxn; i++) fact[i] = (fact[i - 1] * i) % mod;
inv[1] = 1;
for (long long i = 2; i <= maxn; i++)
inv[i] = mod - mod / i * inv[mod % i] % mod;
inv[0] = 1;
for (long long i = 1; i <= maxn; i++) inv[i] *= inv[i - 1], inv[i] %= mod;
}
long long C(long long n, long long m) {
return fact[n] * inv[m] % mod * inv[n - m] % mod;
}
long long dp[105][1005];
int main() {
init();
long long m;
scanf("%lld", &m);
for (long long i = 1; i <= m; i++)
scanf("%lld", &x[i]), sum[i] = sum[i - 1] + x[i];
for (long long i = 1; i <= m; i++) scanf("%lld", &y[i]);
dp[0][0] = 1;
for (long long i = 1; i <= m; i++)
for (long long j = 0; j <= sum[i]; j++)
for (long long k = 0; k <= min(j, y[i]); k++)
dp[i][j] += dp[i - 1][j - k] * C(sum[i] - (j - k), k), dp[i][j] %= mod;
long long ans = dp[m][sum[m]];
ans *= fact[sum[m]], ans %= mod;
for (long long i = 1; i <= m; i++) ans *= inv[x[i]], ans %= mod;
cout << ans << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <typename T>
struct modular {
constexpr modular() : val(0) {}
constexpr modular(const modular<T>& _m) : val(_m.val) {}
template <typename U>
constexpr modular(const U& _r = U()) {
val = -MOD <= _r && _r < MOD ? _r : _r % MOD;
if (val < 0) {
val += MOD;
}
}
const T operator()() { return val; }
template <typename U>
explicit operator U() const {
return static_cast<U>(val);
}
modular<T>& operator+=(const modular<T>& _m) {
if ((val += _m.val) >= MOD) {
val -= MOD;
}
return *this;
}
modular<T>& operator-=(const modular<T>& _m) {
if ((val -= _m.val) < 0) {
val += MOD;
}
return *this;
}
modular<T>& operator*=(const modular<T>& _m) {
val = modular<T>(static_cast<int64_t>(val) * static_cast<int64_t>(_m.val))
.val;
return *this;
}
modular<T>& operator/=(const modular<T>& _m) {
T a = _m.val, b = MOD, u = 0, v = 1;
while (a != 0) {
T q = b / a;
b -= q * a;
swap(a, b);
u -= q * v;
swap(u, v);
}
return *this *= u;
}
modular<T>& operator=(const modular<T>& _m) {
val = _m.val;
return *this;
}
template <typename U>
modular<T>& operator+=(const U& _r) {
return *this += modular<T>(_r);
}
template <typename U>
modular<T>& operator-=(const U& _r) {
return *this -= modular<T>(_r);
}
template <typename U>
modular<T>& operator*=(const U& _r) {
return *this *= modular<T>(_r);
}
template <typename U>
modular<T>& operator/=(const U& _r) {
return *this /= modular<T>(_r);
}
template <typename U>
modular<T>& operator=(const U& _r) {
val = modular<T>(_r).val;
return *this;
}
modular<T> operator-() { return modular<T>(-val); }
template <typename U>
friend bool operator==(const modular<U>&, const modular<U>&);
friend std::istream& operator>>(std::istream& os, modular<T>& _m) {
os >> _m.val;
_m *= 1;
return os;
}
friend std::ostream& operator<<(std::ostream& os, const modular<T>& _m) {
return os << _m.val;
}
template <typename U>
modular<T> exp(U e) {
modular<T> res = 1;
modular<T> b = val;
if (e < 0) {
b = 1 / b;
e *= -1;
}
for (; e; e >>= 1) {
if (e & 1) {
res *= b;
}
b *= b;
}
return res;
}
private:
T val;
};
template <typename T>
inline modular<T> operator+(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) += _rhs;
}
template <typename T, typename U>
inline modular<T> operator+(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) += _rhs;
}
template <typename T, typename U>
inline modular<T> operator+(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) += _rhs;
}
template <typename T>
inline modular<T> operator-(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) -= _rhs;
}
template <typename T, typename U>
inline modular<T> operator-(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) -= _rhs;
}
template <typename T, typename U>
inline modular<T> operator-(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) -= _rhs;
}
template <typename T>
inline modular<T> operator*(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) *= _rhs;
}
template <typename T, typename U>
inline modular<T> operator*(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) *= _rhs;
}
template <typename T, typename U>
inline modular<T> operator*(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) *= _rhs;
}
template <typename T>
inline modular<T> operator/(const modular<T>& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) /= _rhs;
}
template <typename T, typename U>
inline modular<T> operator/(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) /= _rhs;
}
template <typename T, typename U>
inline modular<T> operator/(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) /= _rhs;
}
template <typename T>
inline bool operator==(const modular<T>& _lhs, const modular<T>& _rhs) {
return _lhs.val == _rhs.val;
}
template <typename T, typename U>
inline bool operator==(const modular<T>& _lhs, const U& _rhs) {
return _lhs == modular<T>(_rhs);
}
template <typename T, typename U>
inline bool operator==(const U& _lhs, const modular<T>& _rhs) {
return modular<T>(_lhs) == _rhs;
}
template <typename T>
inline bool operator!=(const modular<T>& _lhs, const modular<T>& _rhs) {
return !(_lhs == _rhs);
}
template <typename T, typename U>
inline bool operator!=(const modular<T>& _lhs, const U& _rhs) {
return !(_lhs == _rhs);
}
template <typename T, typename U>
inline bool operator!=(const U& _lhs, const modular<T>& _rhs) {
return !(_lhs == _rhs);
}
struct Comb {
int N;
vector<modular<int> > fac, ifac, inv;
Comb(int _n = 1) {
resize(2);
fac[0] = fac[1] = ifac[0] = ifac[1] = inv[1] = 1;
N = 1;
grow(_n);
}
void resize(int _s) {
fac.resize(_s);
ifac.resize(_s);
inv.resize(_s);
}
bool grow(int _n) {
if (_n <= N) return false;
swap(_n, N);
resize(N + 1);
for (int i = _n + 1; i <= N; i++) {
fac[i] = fac[i - 1] * i;
inv[i] = (-MOD / i) * inv[MOD % i];
ifac[i] = ifac[i - 1] * inv[i];
}
return true;
}
modular<int> a(int n, int k) {
if (n < k || k < 0) return 0;
if (n > N) grow(n);
return fac[n] * ifac[n - k];
}
modular<int> c(int n, int k) {
if (n < k || k < 0) return 0;
if (n > N) grow(n);
return fac[n] * ifac[n - k] * ifac[k];
}
modular<int> p(int s, int k) {
if (s == 0 && k == 0) return 1;
return c(s - 1, k - 1);
}
modular<int> z(int s, int k) { return p(s + k, k); }
};
const int N = 5022;
modular<int> dp[N][N];
modular<int> sum[N];
void solve() {
int n;
cin >> n;
int orin = n;
string s;
cin >> s;
s.erase(unique(s.begin(), s.end()), s.end());
n = s.size();
vector<int> pre(26, -1);
sum[0] = dp[0][0] = 1;
for (int i = 0; i < n; i++) {
int x = s[i] - 'a';
int& p = pre[x];
for (int len = 0; len <= i; len++) {
dp[i + 1][len + 1] += sum[len] - (p >= 0 ? dp[p][len] : 0);
}
for (int len = 0; len <= i + 1; len++) {
sum[len] += dp[i + 1][len] - (p >= 0 ? dp[p][len] : 0);
}
p = i + 1;
}
Comb c(n);
modular<int> res = 0;
for (int len = 1; len <= n; len++) {
res += c.p(orin, len) * sum[len];
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char ch[3], ma[3];
int store = 0;
cin >> ch;
for (int i = 0; i < 5; i++) {
cin >> ma;
if (ch[0] == ma[0] || ch[0] == ma[1] || ch[1] == ma[0] || ch[1] == ma[1]) {
store = 1;
}
}
if (store == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, sum = 0, count = 0, num[10] = {0};
string n;
cin >> k >> n;
for (int i = 0; i < n.size(); i++)
sum += int(n[i]) - 48, num[int(n[i]) - 48]++;
if (sum >= k)
cout << 0;
else
for (int i = 0; i < 10; i++)
for (int j = 0; j < num[i]; j++) {
sum += 9 - i;
count++;
if (sum >= k) {
cout << count;
return 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
bool ans = true;
int arr[n + 100];
int mini = INT_MAX;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mini = min(arr[i], mini);
}
long long res = 0;
if (ans || n == 1) {
for (int i = 0; i < n; i++) {
if ((arr[i] - mini) % k != 0) ans = false;
res += (arr[i] - mini) / k;
}
if (ans)
printf("%lld\n", res);
else
puts("-1");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, a[1007];
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> a[i];
}
int f = 0, ans = 0, d = 1, n = 0;
while (f != N) {
if (a[n] != -1 && a[n] <= f) {
a[n] = -1;
++f;
}
if (f != N && (n + d < 0 || n + d > N - 1)) {
++ans;
d = -d;
}
n += d;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 10;
int n;
int p[MAXN], l[MAXN];
pair<int, int> f[MAXN];
struct node {
int who, cost;
node() {}
node(int who, int cost) : who(who), cost(cost) {}
} dp[MAXN][20];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &p[i], &l[i]);
stack<int> s;
for (int i = n - 1; i >= 0; i--) {
f[i] = pair<int, int>(i, p[i] + l[i]);
while (!s.empty()) {
if (p[s.top()] <= p[i] + l[i]) {
f[i].first = f[s.top()].first;
f[i].second = max(f[i].second, f[s.top()].second);
s.pop();
} else
break;
}
s.push(i);
}
int MAXP = 0;
for (int k = 0; (1 << k) <= n; k++) {
for (int i = 0; i < n; i++) {
if (k == 0) {
if (f[i].first == n - 1)
dp[i][k] = node(i, 0);
else
dp[i][k] = node(f[i].first + 1, p[f[i].first + 1] - f[i].second);
} else {
dp[i][k] = dp[i][k - 1];
if (f[dp[i][k].who].first != n - 1) {
dp[i][k].who = dp[dp[i][k - 1].who][k - 1].who;
dp[i][k].cost += dp[dp[i][k - 1].who][k - 1].cost;
}
}
}
MAXP = k;
}
int que;
scanf("%d", &que);
for (int o = 0; o < que; o++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
int ans = 0;
for (int k = MAXP; k >= 0; k--)
if (f[dp[x][k].who].first < y) {
ans += dp[x][k].cost;
x = dp[x][k].who;
}
if (f[x].first < y) ans += dp[x][0].cost;
printf("%d\n", ans);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int am0[70][70];
long double am[70][70];
struct P {
long double p;
long double e;
int i;
P(long double pp, long double ee, int ii) {
p = pp;
e = ee;
i = ii;
}
};
vector<P> sav[70];
vector<P> sev[70];
int main() {
cout << setprecision(10);
int N;
scanf("%d", &N);
;
int n = 1 << N;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%d", am0[i] + j);
am[i][j] = am0[i][j] / 100.0;
}
for (int i = 0; i < n; i++) {
P p(1.0, 0.0, i);
sav[i].push_back(p);
}
for (int i = 0; i < N; i++) {
int m = 1 << (N - i - 1);
int mm = 1 << (i);
for (int k = 0; k < m; k++) {
for (int z0 = 0; z0 < mm; z0++) {
P p0 = sav[2 * k][z0];
P p(0, 0, p0.i);
for (int z1 = 0; z1 < mm; z1++) {
P p1 = sav[2 * k + 1][z1];
long double prob = am[p0.i][p1.i] * p0.p * p1.p;
p.p += prob;
p.e = max(p.e, p1.e);
}
p.e += p0.e + (1 << i) * p.p;
sev[k].push_back(p);
}
for (int z1 = 0; z1 < mm; z1++) {
P p1 = sav[2 * k + 1][z1];
P p(0, 0, p1.i);
for (int z0 = 0; z0 < mm; z0++) {
P p0 = sav[2 * k][z0];
long double prob = am[p1.i][p0.i] * p0.p * p1.p;
p.p += prob;
p.e = max(p.e, p0.e);
}
p.e += p1.e + p.p * (1 << i);
sev[k].push_back(p);
}
}
for (int k = 0; k < m; k++) {
sav[k] = sev[k];
sev[k].clear();
}
}
long double ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, sav[0][i].e);
}
cout << (double)ans << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int* tbl = new int[1000000];
int* atb = new int[1000000];
void ct(int cl, int cr, int ci) {
tbl[ci] = 0;
atb[ci] = 0;
if (cl == cr) {
return;
}
int cm = (cl + cr) / 2;
ct(cl, cm, ci * 2);
ct(cm + 1, cr, ci * 2 + 1);
}
void ut(int cl, int cr, int ci, int sp, int vta) {
int li = ci * 2;
int ri = li + 1;
tbl[ci] += atb[ci];
atb[li] += atb[ci];
atb[ri] += atb[ci];
atb[ci] = 0;
if (cl > sp) {
return;
}
if (cl == cr) {
tbl[ci] += vta;
return;
}
int cm = (cl + cr) / 2;
if (cr <= sp) {
tbl[ci] += vta;
atb[li] += vta;
atb[ri] += vta;
return;
}
ut(cl, cm, li, sp, vta);
ut(cm + 1, cr, ri, sp, vta);
tbl[ci] = max(tbl[li], tbl[ri]);
}
int ir(int cl, int cr, int ci) {
int li = ci * 2;
int ri = li + 1;
tbl[ci] += atb[ci];
atb[li] += atb[ci];
atb[ri] += atb[ci];
atb[ci] = 0;
if (tbl[ci] <= 0) {
return -1;
}
if (cl == cr) {
return cl;
}
int cm = (cl + cr) / 2;
int lv = tbl[li] + atb[li];
int rv = tbl[ri] + atb[ri];
if (rv > 0) {
return ir(cm + 1, cr, ri);
}
return ir(cl, cm, li);
}
int main() {
int n;
cin >> n;
int ar[n];
ct(0, n - 1, 1);
for (int i = 0; i < n; i++) {
int ind, o;
cin >> ind >> o;
ind--;
if (o == 1) {
int vl;
cin >> vl;
ar[ind] = vl;
ut(0, n - 1, 1, ind, 1);
} else {
ut(0, n - 1, 1, ind, -1);
}
int pi = ir(0, n - 1, 1);
if (pi < 0) {
cout << -1 << endl;
continue;
}
cout << ar[pi] << endl;
}
cin >> n;
}
| 14 |
#include <bits/stdc++.h>
const double eps = 1e-8;
const long long INF = 1e18;
const double pie = acos(-1.0);
using namespace std;
long long fun[100005], mad[100005];
long long s1[100005], s2[100005];
long long ans;
bool cmp(int x, int y) { return x > y; }
int main() {
long long n, d, m, a;
long long l1 = 0, l2 = 0;
cin >> n >> d >> m;
for (long long i = (1); i <= (n); i++) {
scanf("%lld", &a);
if (a <= m)
fun[++l1] = a;
else
mad[++l2] = a;
}
sort(fun + 1, fun + 1 + l1, cmp);
sort(mad + 1, mad + 1 + l2, cmp);
for (long long i = (1); i <= (l1); i++) s1[i] = s1[i - 1] + fun[i];
for (long long i = (1); i <= (l2); i++) s2[i] = s2[i - 1] + mad[i];
for (long long i = (0); i <= (l2); i++) {
if (l1 + l2 - i < (i - 1) * d) continue;
long long temp;
long long res = min(l1, l1 + l2 - i - (i - 1) * d);
temp = s1[res] + s2[i];
ans = max(ans, temp);
}
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
string s;
cin >> s;
transform(s.begin(), s.end(), s.begin(), ::tolower);
for (int i = 0; i < s.size(); i++) {
if (s[i] != 'a' && s[i] != 'e' && s[i] != 'i' && s[i] != 'o' &&
s[i] != 'u' && s[i] != 'y')
cout << '.' << s[i];
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VL = vector<LL>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
void dout() { cerr << endl; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << H << ' ';
dout(T...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
VI ans((int)s.size());
int l = 0, r = (int)s.size() - 1;
for (int i = (0); i < ((int)s.size()); ++i) {
char c = s[i];
if (c == 'l')
ans[r--] = i;
else
ans[l++] = i;
}
for (auto x : ans) {
cout << x + 1 << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char home[30], away[30], team[90], card[90];
int faults, dem[2][100], timefault[90], player[100], pos[200], len = 0;
cin.get(home, 30, '\n');
cin.get();
cin.get(away, 30, '\n');
cin >> faults;
for (int i = 0; i < faults; i++) {
cin >> timefault[i];
cin.get();
cin >> team[i] >> player[i];
cin.get();
cin >> card[i];
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < 100; j++) dem[i][j] = 0;
for (int i = 0; i < faults; i++) {
if (team[i] == 'a' && card[i] == 'y')
dem[0][player[i]]++;
else if (team[i] == 'h' && card[i] == 'y')
dem[1][player[i]]++;
else if (team[i] == 'a' && card[i] == 'r') {
if (dem[0][player[i]] == 1)
dem[0][player[i]] += 1;
else
dem[0][player[i]] += 2;
} else if (team[i] == 'h' && card[i] == 'r') {
if (dem[1][player[i]] == 1)
dem[1][player[i]] += 1;
else
dem[1][player[i]] += 2;
}
if ((team[i] == 'a' && dem[0][player[i]] == 2) ||
(team[i] == 'h' && dem[1][player[i]] == 2))
pos[len++] = i;
}
if (len > 0) {
for (int i = 0; i < len; i++) {
if (team[pos[i]] == 'a')
cout << away << " " << player[pos[i]] << " " << timefault[pos[i]]
<< endl;
else
cout << home << " " << player[pos[i]] << " " << timefault[pos[i]]
<< endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000;
const int oo = 998244353;
int n, m;
string s;
string t;
int dp[maxn + 1][maxn + 1];
int caldp(int x, int y) {
if (dp[x][y] != -1) return dp[x][y];
if (x == y) {
if (t[x] == s[1] or x > m)
dp[x][y] = 1;
else
dp[x][y] = 0;
return dp[x][y];
}
char cur = s[y - x + 1];
dp[x][y] = 0;
if (x > m or t[x] == cur) dp[x][y] = (dp[x][y] + caldp(x + 1, y)) % oo;
if (y > m or t[y] == cur) dp[x][y] = (dp[x][y] + caldp(x, y - 1)) % oo;
return dp[x][y];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> s >> t;
n = s.size();
m = t.size();
s = '#' + s;
t = '#' + t;
memset(dp, -1, sizeof(dp));
int res = 0;
for (int i = m; i <= n; i++) res = (res + caldp(1, i)) % oo;
cout << (res * 2) % oo;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const char* fi = "loco2.inp";
const char* fo = "loco2.out";
const int maxn = 1e5 + 2;
int n, a[maxn], dem[maxn];
void nhap() {
cin >> n;
for (int i = (1); i <= (n); i++) cin >> a[i];
}
int cal(int x) {
return x == 0 ? 0 : (x % 2 == 0 ? cal(x / 2) : cal(x / 2) + 1);
}
void xl() {
nhap();
for (int i = (1); i <= (n); i++) a[i] = cal(a[i]);
long long res = 0;
for (int i = (1); i <= (n); i++) res += dem[a[i]], dem[a[i]]++;
cout << res;
}
int main() {
ios::sync_with_stdio(false);
xl();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
bool sub = false;
int j = 0;
if (t.size() < s.size()) {
for (int i = 0; i < s.size(); i++) {
if (s[i] == t[j]) {
j++;
}
if (j == t.size()) {
sub = true;
break;
}
}
}
if (sub) {
cout << "automaton";
} else {
vector<int> a(26, 0);
vector<int> b(26, 0);
for (int i = 0; i < t.size(); i++) {
b[t[i] - 'a']++;
}
for (int i = 0; i < s.size(); i++) {
a[s[i] - 'a']++;
}
bool array = true;
bool both = true;
for (int i = 0; i < 26; i++) {
if (a[i] != b[i]) {
array = false;
}
if (a[i] < b[i]) {
both = false;
}
}
if (array) {
cout << "array";
} else if (both) {
cout << "both";
} else {
cout << "need tree";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long sum[200000 + 10];
map<long long, int> mp;
int main() {
mp.clear();
int n;
cin >> n;
long double ans = 0, x;
for (int i = 1; i <= n; i++) {
cin >> x;
ans += x * (i - 1) - (long double)(sum[i - 1]);
if (mp[x - 1]) ans -= (long double)(mp[x - 1]);
if (mp[x + 1]) ans += (long double)(mp[x + 1]);
sum[i] = sum[i - 1] + x;
mp[x]++;
}
cout << fixed << setprecision(0) << ans;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
struct bignum {
int m[201];
bignum() { memset(m, 0, sizeof(m)); }
bignum &operator=(const int a) {
memset(m, 0, sizeof(m));
m[0] = a;
for (int i = 0; i < 201; i++) {
if (m[i] >= 1000) {
m[i + 1] += m[i] / 1000;
m[i] %= 1000;
} else
break;
}
return *this;
}
bignum &operator+=(const bignum a) {
for (int i = 0; i < 201; i++) {
m[i] += a.m[i];
if (m[i] >= 1000) {
m[i + 1] += m[i] / 1000;
m[i] %= 1000;
}
}
return *this;
}
bignum &operator*=(const int a) {
int carry = 0;
for (int i = 0; i < 201; i++) {
m[i] = m[i] * a + carry;
carry = 0;
if (m[i] >= 1000) {
carry = m[i] / 1000;
m[i] %= 1000;
}
}
return *this;
}
void print() {
int now;
now = 201 - 1;
while (now >= 1 && m[now] == 0) now--;
printf("%d", m[now--]);
for (; now >= 0; now--) {
printf("%03d", m[now]);
}
printf("\n");
}
};
int n, x[5001];
char a[5001], aa[5];
bignum ans;
set<int> s;
void rec(int c, int d) {
if (c >= d) return;
int last[2010];
memset(last, -1, sizeof(last));
int tmp, l, r;
tmp = -1;
for (int i = c; i <= d; i++) {
if (a[i] == 'w') {
last[x[i]] = i;
} else {
if (tmp < x[i] && last[x[i]] != -1) {
tmp = x[i];
l = last[x[i]];
r = i;
}
}
}
if (tmp == -1) return;
rec(c, l - 1);
rec(r + 1, d);
s.insert(tmp);
}
int main() {
scanf("%d", &n);
ans = 0;
for (int i = 0; i < n; i++) {
scanf("%s%d", aa, &x[i]);
a[i] = aa[0];
}
rec(0, n - 1);
bignum btmp;
btmp = 1;
for (int i = 0; i <= 2001; i++) {
if (s.find(i) != s.end()) {
ans += btmp;
}
btmp *= 2;
}
ans.print();
return 0;
}
| 12 |
#include <bits/stdc++.h>
const int N = 105, MOD = 1000000007;
using namespace std;
int a[N][N], b[N][N];
int main() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) b[i][j] = 1;
}
int m, n;
cin >> m >> n;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
if (a[i][j] == 0) {
for (int k = 0; k < m; k++) b[k][j] = 0;
for (int k = 0; k < n; k++) b[i][k] = 0;
}
}
}
bool ok = true;
for (int i = 0; ok && i < m; i++) {
for (int j = 0; ok && j < n; j++) {
if (a[i][j] == 1) {
bool ok1 = false, ok2 = false;
for (int k = 0; k < m; k++)
if (b[k][j] == 1) ok1 = true;
for (int k = 0; k < n; k++)
if (b[i][k] == 1) ok2 = true;
if (ok1 || ok2)
ok = true;
else
ok = false;
}
}
}
if (ok) {
cout << "YES" << endl;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cout << b[i][j] << " ";
}
cout << endl;
}
} else
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2100;
int A[N], B[N];
int n;
const int SZ = N * 10 * 10 * 10 * 10;
int mem[SZ];
int go(int x, int pos, vector<int> elev) {
int ADD1 = 0;
int ADD2 = 0;
for (int i = 0; i < (4); i++)
if (elev[i] == pos) elev[i] = 0, ADD1++;
if (x == n) {
int ok = 1;
for (int i = 0; i < (4); i++)
if (elev[i]) ok = 0;
if (ok) return ADD1;
}
int hash = x * 10 + pos;
sort(elev.begin(), elev.end());
reverse(elev.begin(), elev.end());
assert(elev[3] == 0);
for (int i = 0; i < (3); i++) hash = hash * 10 + elev[i];
int &res = mem[hash];
if (res != -1) return res + ADD1;
res = 1e9;
int hasFree = 0;
for (int i = 0; i < (4); i++)
if (elev[i] == 0 && x < n) {
if (A[x] == pos) {
elev[i] = B[x];
x++;
ADD2++;
} else
hasFree = 1;
}
if (hasFree) res = min(res, abs(A[x] - pos) + go(x, A[x], elev) + ADD2);
for (int i = 0; i < (4); i++)
if (elev[i] != 0) {
res = min(res, abs(elev[i] - pos) + go(x, elev[i], elev) + ADD2);
}
return res + ADD1;
}
int main() {
memset(mem, -1, sizeof mem);
scanf("%d", &n);
for (int i = 0; i < (n); i++) scanf("%d%d", &A[i], &B[i]);
vector<int> elev = {0, 0, 0, 0};
int res = go(0, 1, elev);
printf("%d\n", res);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, x, y, s, c;
cin >> x >> y;
c = (x * x) + (y * y);
s = sqrt(c);
if ((x >= 0 && y >= 0) || (x < 0 && y < 0)) {
if (x == 0 || y == 0 || s * s == c)
printf("black");
else if (s % 2 == 0)
printf("black");
else
printf("white");
} else {
if (x == 0 || y == 0 || s * s == c)
printf("black");
else if (s % 2 == 0)
printf("white");
else
printf("black");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n, m, a, b;
int main() {
cin >> t;
while (t--) {
cin >> n >> m >> a >> b;
if (n * a != m * b)
cout << "NO\n";
else {
cout << "YES\n";
int g[55][55] = {0};
int s = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (j < a) {
g[i][(j + s) % m] = 1;
} else {
g[i][(j + s) % m] = 0;
}
}
s = (s + a) % m;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << g[i][j];
}
cout << endl;
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1000000007;
const int N = 24, NN = 1 << N;
int a[N];
long long b1, b2, d[NN];
int f[NN];
bool visited[NN];
int s[NN];
int bit[N];
int main() {
int TT = 1;
for (int tt = 1; tt <= TT; ++tt) {
int i, j;
memset(f, 0, sizeof(f));
b1 = b2 = -1;
int n;
cin >> n;
for (i = 0; i < (n); ++i) cin >> a[i];
int k;
cin >> k;
if (k > 0) cin >> b1;
if (k > 1) cin >> b2;
for (i = 0; i <= (n); ++i) bit[i] = 1 << i;
f[0] = 1;
int x, t;
for (x = 0; x < (bit[n]); ++x) {
if (d[x] == b1 || d[x] == b2) {
f[x] = 0;
}
for (j = 0; j < (n); ++j)
if ((t = x | bit[j]) != x) {
f[t] += f[x];
if (f[t] >= P) f[t] -= P;
d[t] = d[x] + a[j];
}
}
cout << f[bit[n] - 1] << endl;
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
bool v[105];
int i, a, ans = 0, j, n;
int main() {
cin >> n >> a;
for (i = 1; i <= n; ++i) cin >> v[i];
ans = (int)v[a];
for (j = 1; a - j >= 1 || a + j <= n; ++j) {
bool oks = (a - j >= 1 && v[a - j] == 1);
bool okd = (a + j <= n && v[a + j] == 1);
if (oks && okd) {
ans += 2;
continue;
}
if (a - j >= 1 && a + j > n && v[a - j] == 1) ans++;
if (a + j <= n && a - j < 1 && v[a + j] == 1) ans++;
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, p, edges, x;
scanf("%d", &t);
while (t--) {
cin >> n >> p;
x = (2 * n) + p;
edges = 0;
for (int i = 1; i <= n && edges < x; i++) {
for (int j = i + 1; j <= n && edges < x; j++) {
printf("%d %d\n", i, j);
edges++;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int a[100005];
int i, n, k, min, m, j, num;
while (scanf("%d%d", &n, &k) != EOF) {
min = 999999999;
num = 0;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= k; i++) {
num = 0;
for (j = i; j <= n;) {
num += a[j];
j += k;
}
if (min > num) {
min = num;
m = i;
}
}
printf("%d\n", m);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int a[100005];
int main() {
cin >> n >> x;
if (n == 0)
printf("YES\n");
else {
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum = sum + a[i];
}
if (sum + n - 1 == x)
printf("YES\n");
else
printf("NO\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1919810;
int n, t, a[N], s[114];
long long f[N], fac[N], kkr;
int main() {
fac[0] = 1;
f[0] = f[1] = 1;
for (int i = 1; i <= 1919800; i++) fac[i] = fac[i - 1] * i % mod;
for (int i = 2; i <= 1919800; i++)
f[i] = (f[i - 1] + (i - 1) * f[i - 2]) % mod;
scanf("%d", &n);
s[1] = s[2] = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), s[a[i]]++;
kkr = f[s[1]];
for (int i = 1; i <= s[2]; i++) kkr = kkr * (s[1] + i) % mod;
printf("%lld\n", kkr);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
char c1 = 65, c2 = 65, c3 = 65;
int i = 0;
if (s.size() < 3) {
cout << "NO\n" << endl;
return 0;
}
while (i < s.size() - 2) {
c1 = s[i];
c2 = s[i + 1];
c3 = s[i + 2];
if (c1 + c2 + c3 == 198 && c1 != c2) {
cout << "YES\n" << endl;
return 0;
}
i++;
}
cout << "NO\n" << endl;
}
| 1 |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <time.h>
#include <random>
#include <string>
#include <cassert>
#include <vector>
#include <ostream>
#include <istream>
#include <stack>
#include <deque>
#include <queue>
#include <functional>
#include <chrono>
#include <stack>
#include <limits>
using namespace std;
#define int long long
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define pii pair<int, int>
#define ld long double
istream& operator>> (istream& in, pii& b) {
in >> b.first >> b.second;
return in;
}
ostream& operator<< (ostream& out, const pii& b) {
out << "{" << b.first << ", " << b.second << "}";
return out;
}
template<typename T> ostream& operator<< (ostream& out, const vector<T>& a) {
for (auto k : a) out << k << " ";
return out;
}
template <typename T1, typename T2> inline bool chkmin(T1 &x, const T2 &y) {if (x > y) {x = y; return 1;} return 0;}
template <typename T1, typename T2> inline bool chkmax(T1 &x, const T2 &y) {if (x < y) {x = y; return 1;} return 0;}
#ifdef LOCAL
#define dbg(x) cout << #x << " : " << (x) << endl;
const long long INF = 1e18;
// const long long mod = 2600000069;
// const long long p = 10;
#else
#define dbg(x) 57
const long long INF = 1e18;
// const long long mod = 2600000069;
// const long long p = 179;
#endif
const ld PI = 4 * atan(1);
#define time clock() / (double) CLOCKS_PER_SEC
// #pragma GCC optimize("Ofast,no-stack-protector")
// #pragma GCC target("sse,sse2,sse3,sse3,sse4")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC optimize("fast-math")
// #pragma GCC target("avx2")
mt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());
struct Point {
int x, y;
Point() {}
Point(int x_, int y_) {
x = x_, y = y_;
}
};
istream& operator>> (istream& in, Point& a) {
in >> a.x >> a.y;
return in;
}
ostream& operator<< (ostream& out, const Point& a) {
out << a.x << " " << a.y;
return out;
}
int sq(int x) {return x * x;}
int dist(const Point& a, const Point& b) {
return sq(a.x - b.x) + sq(a.y - b.y);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<Point> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> used(n, 0);
vector<int> ans;
used[0] = 1;
ans.pb(1);
for (int i = 1; i < n; i++) {
int cur = ans.back() - 1;
int bst = -1;
for (int j = 0; j < n; j++) {
if (!used[j] && (bst == -1 || dist(a[cur], a[bst]) < dist(a[cur], a[j]))) {
bst = j;
}
}
used[bst] = 1;
ans.pb(bst + 1);
}
cout << ans << "\n";
}
/*
*/
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long dp[500000][3];
long long sum[500000][3];
long long lg[500000][3];
long long cnt[500000][3];
int D[500000];
long long pw(int b, int p) {
if (p == 0) return 1;
long long ans = pw(b, p / 2);
ans *= ans;
ans %= 1000000007ll;
if (p % 2) ans *= b;
ans %= 1000000007ll;
return ans;
}
void solve(int n, int eq) {
assert(n >= 0);
if (dp[n][eq] >= 0) return;
if (n == 0) {
bool cando7 = (D[n] == 7 || !eq);
if (cando7) {
cnt[n][eq] = 2;
lg[n][eq] = 7;
sum[n][eq] = 7 + 4;
dp[n][eq] = 7 * 4;
} else {
cnt[n][eq] = 1;
lg[n][eq] = 4;
sum[n][eq] = 0;
dp[n][eq] = 0;
}
return;
}
dp[n][eq] = 0;
sum[n][eq] = 0;
cnt[n][eq] = 0;
lg[n][eq] = 0;
for (int dig = 4; dig <= 7 && (dig <= D[n] || !eq); dig += 3) {
int neweq = eq && (dig == D[n]);
solve(n - 1, neweq);
cnt[n][eq] += cnt[n - 1][neweq];
cnt[n][eq] %= 1000000007ll;
long long adder = dig * pw(10, n) % 1000000007ll;
lg[n][eq] = adder + lg[n - 1][neweq];
lg[n][eq] %= 1000000007ll;
assert(cnt[n - 1][neweq] >= 1);
if (cnt[n - 1][neweq] == 1)
assert(dp[n - 1][neweq] == 0 && sum[n - 1][neweq] == 0);
dp[n][eq] += (((adder * adder) % 1000000007ll) *
(cnt[n - 1][neweq] + 1000000007ll - 1) % 1000000007ll) %
1000000007ll +
adder * sum[n - 1][neweq] % 1000000007ll +
dp[n - 1][neweq] % 1000000007ll;
dp[n][eq] %= 1000000007ll;
sum[n][eq] += adder * 2 % 1000000007ll *
(cnt[n - 1][neweq] + 1000000007ll - 1) % 1000000007ll +
sum[n - 1][neweq] % 1000000007ll;
sum[n][eq] %= 1000000007ll;
}
if (D[n] == 7 || !eq) {
long long val = (7 * pw(10, n) % 1000000007ll +
((((pw(10, n) + 1000000007ll - 1) * 4) % 1000000007ll *
pw(9, 1000000007ll - 2) % 1000000007ll) %
1000000007ll)) %
1000000007ll;
long long val2 =
(4 * pw(10, n) % 1000000007ll + lg[n - 1][0]) % 1000000007ll;
assert(lg[n - 1][0] > 0 && cnt[n - 1][0] > 1);
dp[n][eq] += val % 1000000007ll * val2 % 1000000007ll;
sum[n][eq] += (val + val2) % 1000000007ll;
dp[n][eq] %= 1000000007ll;
sum[n][eq] %= 1000000007ll;
}
}
char l[500000], r[500000];
int main() {
scanf("%s%s", l, r);
int n = strlen(l);
assert(n < 500000);
long long lval = 0;
for (int i = 0; i < n; ++i) D[n - 1 - i] = l[i] - '0';
memset(sum, -1, sizeof(sum));
memset(dp, -1, sizeof(dp));
memset(lg, -1, sizeof(lg));
memset(cnt, -1, sizeof(cnt));
solve(n - 1, 1);
lval = dp[n - 1][1];
long long rval = 0;
for (int i = 0; i < n; ++i) D[n - 1 - i] = r[i] - '0';
memset(sum, -1, sizeof(sum));
memset(dp, -1, sizeof(dp));
memset(lg, -1, sizeof(lg));
memset(cnt, -1, sizeof(cnt));
solve(n - 1, 1);
rval = dp[n - 1][1];
long long ans = (rval - lval + 1000000007ll) % 1000000007ll;
cout << ans << endl;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[107];
bool mark[107];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int nLoop = 0;
queue<int> q;
q.push(1);
mark[1] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
int size = adj[u].size();
int nRepeat = 0;
for (int i = 0; i < size; ++i) {
if (!mark[adj[u][i]]) {
mark[adj[u][i]] = true;
q.push(adj[u][i]);
} else {
++nRepeat;
}
}
if (nRepeat == 2) {
++nLoop;
} else if (nRepeat > 2) {
cout << "NO\n";
return 0;
}
}
for (int i = 1; i <= n; ++i) {
if (!mark[i]) {
cout << "NO\n";
return 0;
}
}
if (nLoop == 2) {
cout << "FHTAGN!\n";
} else {
cout << "NO\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void checkmin(T &t, T x) {
if (x < t) t = x;
}
template <class T>
void checkmax(T &t, T x) {
if (x > t) t = x;
}
const int N = 105555;
int n, m, h;
int w[N];
int v[N];
long long max_h[N];
int ind[N];
vector<int> vec;
bool cmp(int i, int j) {
if (w[i] != w[j]) return w[i] < w[j];
return v[i] < v[j];
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 1; i <= n; i++) ind[i] = i;
sort(ind + 1, ind + n + 1, cmp);
long double l = 0, r = 1e9 + 5;
for (int k = 0; k < 200; k++) {
long double mid = (l + r) / 2;
for (int i = 1; i <= n; i++) {
max_h[i] = (v[ind[i]] * mid) / h;
}
bool ok = true;
int j = 1;
for (int i = 1; i <= m; i++) {
while (j <= n && max_h[j] < i) j++;
if (j <= n) {
j++;
} else {
ok = false;
break;
}
}
if (ok) {
r = mid;
vec.clear();
j = 1;
for (int i = 1; i <= m; i++) {
while (j <= n && max_h[j] < i) j++;
if (j <= n) {
vec.push_back(j);
j++;
}
}
} else
l = mid;
}
for (int i = 0; i < vec.size(); i++) printf("%d ", ind[vec[i]]);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 101;
const long long INF = 1e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<long long> st(n);
st[0] = 1;
for (int i = 0; i < n; ++i) {
st[i + 1] = st[i] * 10 % MOD;
}
for (long long i = 1; i < n; i++) {
long long ans = 0;
ans += 2ll * 10 * 9 * st[n - i - 1];
ans %= MOD;
ans += (n - i - 1) * 10 * 81 * st[n - i - 2];
ans %= MOD;
cout << ans << ' ';
}
cout << 10 << ' ';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[3];
int cnt1 = 1, cnt2 = 0, n;
vector<int> vec, v1, v2;
while (true) {
scanf("%s", s);
if (s[0] == '+')
++cnt1, vec.push_back(1);
else if (s[0] == '-')
++cnt2, vec.push_back(-1);
else if (s[0] == '=') {
scanf("%d", &n);
break;
}
}
int l1 = cnt1, r1 = cnt1 * n, l2 = cnt2 + n, r2 = cnt2 * n + n;
if (l2 > r1 || l1 > r2) return 0 * puts("Impossible");
puts("Possible");
int sum;
if (l2 >= l1 && l2 <= r1)
sum = l2;
else
sum = l1;
for (int i = 0; i < cnt1; ++i) v1.push_back(1);
int x = sum - cnt1;
for (int i = 0; i < cnt1; ++i) {
int add = min(n - 1, x);
x -= add, v1[i] += add;
if (!x) break;
}
sum = sum - n;
for (int i = 0; i < cnt2; ++i) v2.push_back(1);
x = sum - cnt2;
for (int i = 0; i < cnt2; ++i) {
int add = min(n - 1, x);
x -= add, v2[i] += add;
if (!x) break;
}
int now1 = 0, now2 = 0;
printf("%d ", v1[now1++]);
for (int i = 0; i < (int)vec.size(); ++i) {
if (vec[i] == 1)
printf("%c %d ", '+', v1[now1++]);
else if (vec[i] == -1)
printf("%c %d ", '-', v2[now2++]);
}
printf("%c %d\n", '=', n);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, q;
long long a[maxn];
struct node {
long long l, r, lm, rm;
long long sum;
} ans[maxn * 4];
long long ls(long long x) { return x << 1; }
long long rs(long long x) { return x << 1 | 1; }
void pushup(long long x, long long l, long long r) {
ans[x].sum = ans[ls(x)].sum + ans[rs(x)].sum;
ans[x].lm = ans[ls(x)].lm;
ans[x].rm = ans[rs(x)].rm;
long long mid = (l + r) / 2;
if (a[ans[ls(x)].r] <= a[ans[rs(x)].l]) {
if (ans[ls(x)].lm == ans[ls(x)].r - ans[ls(x)].l + 1) {
ans[x].lm += ans[rs(x)].lm;
}
if (ans[rs(x)].rm == ans[rs(x)].r - ans[rs(x)].l + 1) {
ans[x].rm += ans[ls(x)].rm;
}
ans[x].sum += ans[ls(x)].rm * ans[rs(x)].lm;
}
}
void build(long long x, long long l, long long r) {
ans[x].l = l;
ans[x].r = r;
if (l == r) {
ans[x].lm = 1;
ans[x].rm = 1;
ans[x].sum = 1;
return;
}
long long mid = (l + r) / 2;
build(ls(x), l, mid);
build(rs(x), mid + 1, r);
pushup(x, l, r);
}
void updata(long long l, long long r, long long nl, long long nr, long long x,
long long k) {
if (nl >= l && nr <= r) {
a[nl] = k;
return;
}
long long mid = (nl + nr) / 2;
if (mid >= l) updata(l, r, nl, mid, ls(x), k);
if (mid < r) updata(l, r, mid + 1, nr, rs(x), k);
pushup(x, nl, nr);
}
long long query(long long l, long long r, long long nl, long long nr,
long long x) {
if (nl >= l && nr <= r) {
return ans[x].sum;
}
long long mid = (nl + nr) / 2;
long long num = 0;
if (mid >= l) {
num += query(l, r, nl, mid, ls(x));
}
if (mid < r) {
num += query(l, r, mid + 1, nr, rs(x));
}
pushup(x, nl, nr);
if (a[ans[ls(x)].r] <= a[ans[rs(x)].l]) {
long long lt = min(mid - l + 1, ans[ls(x)].rm);
long long rt = min(r - mid, ans[rs(x)].lm);
if (lt > 0 && rt > 0) {
num += lt * rt;
}
}
return num;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
build(1, 1, n);
long long t, l, r;
for (int i = 1; i <= q; i++) {
scanf("%lld %lld %lld", &t, &l, &r);
if (t == 1) {
updata(l, l, 1, n, 1, r);
} else {
printf("%lld\n", query(l, r, 1, n, 1));
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
int main() {
char arr[205], res[1000];
int i, j, len, flag = 1, k = 0;
scanf("%s", arr);
len = strlen(arr);
if (arr[0] == '@' || arr[len - 1] == '@')
printf("No solution");
else {
for (i = j = 0; i < len; i++) {
res[j++] = arr[i];
if (arr[i] == '@') k = 1;
if (k && i + 2 < len && arr[i + 2] == '@') res[j++] = ',';
if (i >= 2 && arr[i - 2] == '@' && arr[i] == '@') flag = 0;
if (i >= 1 && arr[i - 1] == '@' && arr[i] == '@') flag = 0;
}
res[j] = 0;
if (flag == 0 || k == 0)
printf("No solution");
else
printf("%s", res);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long a[40] = {
1, 2, 4, 8, 16, 32,
64, 128, 256, 512, 1024, 2048,
4096, 8092, 16184, 32368, 64736, 129472,
258944, 517888, 1035776, 2071552, 4143104, 8286208,
16572416, 33144832, 66289664, 132579328, 265158656, 530317312,
1060634624, 2121269248, 4242538496, 8485076992, 16970153984, 33940307968};
int i;
cin >> i;
cout << a[i];
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
void solve() {
long long int n, k;
cin >> n >> k;
long long int p[n];
for (int i = 0; i < n; i++) cin >> p[i];
long long int maxi = 0, num = 1;
for (int i = 0; i < k; i++) {
maxi += n - i;
}
vector<long long int> dis;
for (int i = 0; i < n; i++) {
if (p[i] > n - k) {
dis.push_back(i);
}
}
for (int i = 0; i < dis.size() - 1; i++) {
num = (num * (dis[i + 1] - dis[i])) % mod;
}
cout << maxi << " " << num << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long get() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const long long N = 405;
long long P, A[N], I[N], B[N][N], fac[N], inv[N];
long long qpow(long long x, long long y) {
long long res = 1;
while (y) res = res * ((y & 1) ? x : 1) % P, x = x * x % P, y >>= 1;
return res;
}
void init(long long n) {
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % P;
inv[n] = qpow(fac[n], P - 2);
for (long long i = n; i >= 1; i--) inv[i - 1] = inv[i] * i % P;
I[1] = 1;
for (long long i = 2; i <= n; i++) {
I[i] = fac[i];
for (long long j = 1; j < i; j++)
I[i] = (I[i] - I[j] * fac[i - j] % P + P) % P;
}
B[0][0] = 1;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= i; j++)
for (long long k = 1; k <= i; k++)
B[i][j] = (B[i][j] + B[i - k][j - 1] * fac[k] % P) % P;
A[1] = 1, A[2] = 2, A[3] = 0;
for (long long i = 4; i <= n; i++) {
A[i] = fac[i];
long long sum1 = 0, sum2 = 0;
for (long long j = 1; j < i; j++) sum1 = (sum1 + I[j] * fac[i - j] % P) % P;
A[i] = (A[i] - sum1 * 2 % P + P) % P;
for (long long j = 4; j < i; j++) sum2 = (sum2 + B[i][j] * A[j] % P) % P;
A[i] = (A[i] - sum2 + P) % P;
}
}
signed main() {
long long T = get();
P = get();
init(400);
while (T--) printf("%d\n", A[get()]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, l = 0;
cin >> n >> m;
l = n * m;
cout << l / 2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e18 + 7;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long ans = 0;
if (s.length() == 1 && k > 0) {
s[0] = '0';
cout << s << endl;
return 0;
}
if (s[0] != '1') {
if (k > 0) {
s[0] = '1';
k--;
}
}
for (long long i = 1; i < n; i++) {
if (s[i] == '0') continue;
if (k > 0) {
s[i] = '0';
k--;
} else {
break;
}
}
cout << s << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int tt = 0; tt < (t); tt++) {
int a, b, c;
cin >> a >> b >> c;
if (a + b == c || a + c == b || b + c == a || (a == b && c % 2 == 0) ||
(a == c && b % 2 == 0) || (b == c && a % 2 == 0))
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
char a[N][N];
int p[N];
string s;
int n, m, sx, sy, ex, ey, ans;
void Follow() {
int len, i, x, y;
x = sx;
y = sy;
len = s.size();
for (i = 0; i < len; i++) {
if ((s[i] - '0') == p[0]) x--;
if ((s[i] - '0') == p[1]) x++;
if ((s[i] - '0') == p[2]) y--;
if ((s[i] - '0') == p[3]) y++;
if (a[x][y] == '#') return;
if (a[x][y] == 'E') {
ans++;
return;
}
}
}
int main() {
int i, j;
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (i = 0; i <= n + 1; i++)
for (j = 0; j <= m + 1; j++) a[i][j] = '#';
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == 'S') {
sx = i;
sy = j;
}
}
cin >> s;
for (i = 0; i <= 3; i++) p[i] = i;
do {
Follow();
} while (next_permutation(p, p + 4));
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int n, maxn[100005], ans, num;
unsigned long long LtoR1[100005], LtoR2[100005], RtoL1[100005], RtoL2[100005],
mul1[100005], mul2[100005], pos[100005];
pair<int, int> ans1, ans2, ans3;
void init(unsigned long long LtoR[], unsigned long long RtoL[],
unsigned long long mul[], unsigned long long p) {
mul[0] = 1;
for (int i = 1; i < n; ++i) mul[i] = mul[i - 1] * p;
LtoR[0] = mul[n - 1] * s[0];
for (int i = 1; i < n; ++i) LtoR[i] = mul[n - i - 1] * s[i] + LtoR[i - 1];
RtoL[n - 1] = mul[n - 1] * s[n - 1];
for (int i = n - 2; i >= 0; --i) RtoL[i] = mul[i] * s[i] + RtoL[i + 1];
}
bool check(int i, int mid, unsigned long long LtoR[], unsigned long long RtoL[],
unsigned long long mul[]) {
unsigned long long hs1 = (LtoR[i + mid - 1] - LtoR[i]),
hs2 = (RtoL[i - mid + 1] - RtoL[i]);
hs1 *= mul[i];
hs2 *= mul[n - i - 1];
return hs1 == hs2;
}
void find_longest_odd_length_palindrome() {
pos[0] = 0;
for (int i = 1; i < n; ++i)
if (maxn[i] > maxn[i - 1])
pos[i] = i;
else
maxn[i] = maxn[i - 1], pos[i] = pos[i - 1];
for (int i = 0; i < n; ++i) {
int l = 1, r = min(i + 1, n - i) + 1;
while (r - l > 1) {
int mid = l + r >> 1;
if (check(i, mid, LtoR1, RtoL1, mul1) &&
check(i, mid, LtoR2, RtoL2, mul2))
l = mid;
else
r = mid;
}
if (i + l - 1 == n || i - l + 1 == 0) {
if (l + l - 1 > ans) {
ans = l + l;
num = 1;
ans1 = make_pair(i - l + 1, l + l - 1);
}
continue;
}
int t;
if (maxn[i - l] >= n - (i + l))
t = n - (i + l);
else
t = maxn[i - l];
if (t + t + l + l - 1 >= ans) {
ans = t + t + l + l - 1;
if (!t) {
num = 1;
ans1 = make_pair(i - l + 1, l + l - 1);
continue;
}
num = 3;
ans1 = make_pair(pos[i - l] - maxn[i - l] + 1, t);
ans2 = make_pair(i - l + 1, l + l - 1);
ans3 = make_pair(n - t, t);
}
}
}
bool check2(int i, int mid, unsigned long long mul[], unsigned long long LtoR[],
unsigned long long RtoL[]) {
return (LtoR[i + mid - 1] - (i > 0 ? LtoR[i - 1] : 0)) * mul[i] ==
RtoL[n - mid];
}
void init_every_index_suffix() {
int j = 0;
for (int i = 0; i < n; ++i) {
int l = 0, r = n - i;
while (r - l > 1) {
int mid = l + r >> 1;
if (check2(i, mid, mul1, LtoR1, RtoL1) &&
check2(i, mid, mul2, LtoR2, RtoL2))
l = mid;
else
r = mid;
}
while (j < i + l) maxn[j] = j - i + 1, ++j;
}
}
int main() {
scanf("%s", s);
n = strlen(s);
init(LtoR1, RtoL1, mul1, 19260817);
init(LtoR2, RtoL2, mul2, 19491001);
init_every_index_suffix();
find_longest_odd_length_palindrome();
if (num == 1)
printf("1\n%d %d", ans1.first + 1, ans1.second);
else
printf("3\n%d %d\n%d %d\n%d %d\n", ans1.first + 1, ans1.second,
ans2.first + 1, ans2.second, ans3.first + 1, ans3.second);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
long long a[N];
long long k;
int n;
long long eval(long long int d) {
long long ret = 0;
for (int i = 1; i <= n; i++) {
ret += ((a[i] + d - 1LL) / d);
}
ret = ret * d;
return ret;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
long long ans = 1;
long long sum = k;
for (int i = 1; i <= n; i++) sum += a[i];
for (long long d = 1; d * d <= sum; d++) {
if (eval(d) <= sum) ans = max(ans, d);
}
for (long long d = 1; d * d <= sum; d++) {
long long l = (sum / (d + 1LL)) + 1LL;
long long r = (sum / d);
if (eval(r) <= sum) ans = max(ans, r);
}
cout << ans << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int dy[] = {1, -1, 1, 1, -1, -1, 0, 0};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
map<int, vector<pair<int, int> > > allowed;
bool valid(int r, int c) {
if (r <= 10e9 && c <= 10e9 && r >= 0 && c >= 0)
for (auto v : allowed[r]) {
if (c >= v.first && c <= v.second) return true;
}
return false;
}
int bfs(int x1, int y1, int x2, int y2, int c) {
queue<pair<pair<int, int>, int> > q;
q.push(make_pair(make_pair(x1, y1), c));
map<pair<int, int>, int> vis;
while (!q.empty()) {
pair<pair<int, int>, int> u = q.front();
q.pop();
if (u.first.first == x2 && u.first.second == y2) {
return u.second;
}
if (++vis[u.first] > 1) continue;
u.second++;
for (int i = 0; i < 8; i++) {
int r2 = u.first.first + dy[i];
int c2 = u.first.second + dx[i];
if (valid(r2, c2)) {
q.push(make_pair(make_pair(r2, c2), u.second));
}
}
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int t1, t2, t3;
cin >> t1 >> t2 >> t3;
allowed[t1].push_back(make_pair(t2, t3));
}
cout << bfs(x1, y1, x2, y2, 0) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long a[100000 + 123];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int ta;
scanf("%d", &ta);
a[i] = ta + 0ll;
}
for (int i = 0; i < n - 1; ++i) {
int j;
for (j = 0; j <= 20; ++j)
if ((i + (1 << j)) >= n) break;
a[i + (1 << (j - 1))] += a[i];
}
long long summ = 0;
for (int i = 0; i < n - 1; ++i) {
summ += a[i];
cout << summ << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> B;
vector<pair<int, int>> V;
int a, b, c, d, q, ans;
int main() {
cin >> a >> c;
for (int i = 0; i < a; i++) {
cin >> b;
V.push_back({b, i});
}
sort(V.begin(), V.end());
for (int i = 0; i < a; i++) {
if (ans + V[i].first < c + 1) ans += V[i].first, B.push_back(i), d++;
if (ans == c) break;
}
cout << d << endl;
for (int i = 0; i < B.size(); i++) cout << V[i].second + 1 << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, ans = 0;
char a[251];
int main() {
cin >> n >> a;
int m = strlen(a);
a[m] = '0';
for (int i = 0; i <= m; i++) {
if (a[i] == '1' && a[i + 1] == '0') {
ans++;
printf("%d", ans);
ans = 0;
i++;
continue;
} else if (a[i] == '0') {
printf("0");
} else if (a[i] == '1')
ans++;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
char S[int(1e5 + 5)];
set<pair<int, int> > Set;
int main() {
scanf("%s", S + 1);
n = strlen(S + 1);
scanf("%d", &m);
while (m--) {
char s[2];
cin >> s;
Set.insert(make_pair(s[0], s[1]));
Set.insert(make_pair(s[1], s[0]));
}
for (auto it = Set.begin(); it != Set.end(); it++) {
char f = (*it).first;
char s = (*it).second;
for (int i = 1; i <= n;) {
if (S[i] == f || S[i] == s) {
int from = i, to = i, c1 = 0, c2 = 0;
bool foo = false, bar = false;
if (S[i] == f)
foo = true;
else
bar = true;
while ((S[to] == f || S[to] == s) && to <= n) {
if (S[to] == f) {
foo = true;
c1++;
} else {
bar = true;
c2++;
}
to++;
}
if (foo & bar) {
for (int j = i; j < to; j++) {
S[j] = (c1 < c2 ? s : f);
}
ans += min(c1, c2);
}
i = to;
} else {
i++;
}
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
string s[105];
char a, b, c;
bool cek;
bool hori() {
if (m % 3 != 0) {
return false;
}
a = s[1][0];
b = s[1][m / 3];
c = s[1][2 * m / 3];
if (a == b or a == c or b == c) return false;
for (long long i = 1; i <= n; i++)
for (long long j = 0; j <= m / 3 - 1; j++) {
if (s[i][j] != a or s[i][j + m / 3] != b or s[i][j + 2 * m / 3] != c) {
return false;
}
}
return true;
}
bool verti() {
if (n % 3 != 0) return false;
a = s[1][0];
b = s[1 + n / 3][0];
c = s[1 + 2 * n / 3][0];
if (a == b or b == c or a == c) {
return false;
}
for (long long i = 1; i <= n / 3; i++)
for (long long j = 0; j <= m - 1; j++) {
if (s[i][j] != a or s[i + n / 3][j] != b or s[i + 2 * n / 3][j] != c) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> s[i];
if (hori() or verti())
cout << "YES";
else
cout << "NO";
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long int pow1(long long int a, long long int b,
long long int m = 1000000007) {
if (b == 0)
return 1ll;
else if (b == 1)
return a;
else {
long long int x = pow1(a, b / 2, m);
x *= x;
x %= m;
if (b % 2) {
x *= a;
x %= m;
}
return x;
}
}
template <class avgType>
avgType avg(avgType a, avgType b) {
return (a + b) / 2;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count());
int randInt() { return rng() % INT_MAX; }
long long int randLL() { return rng64() % LLONG_MAX; }
vector<int> hashmods = {1000000007, 1000000009, 1000000021,
1000000033, 1000000087, 1000000093};
int t, n, u, v, node, dist, par[1100], reqanc[1100], maxlev = 1;
vector<vector<int> > tree(1100);
vector<vector<int> > levels(1100);
string resp;
void dfs(int index, int l) {
levels[l].push_back(index);
maxlev = max(maxlev, l);
if (l >= 2)
reqanc[index] = reqanc[par[index]];
else if (l == 1)
reqanc[index] = index;
for (int neigh : tree[index]) {
if (neigh == par[index]) continue;
par[neigh] = index;
dfs(neigh, l + 1);
}
}
int main() {
cin >> t;
while (t--) {
cin >> n;
maxlev = 1;
for (int i = 0; i <= n; i++) {
tree[i].clear();
levels[i].clear();
par[i] = 0;
reqanc[i] = 0;
}
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
tree[u].push_back(v);
tree[v].push_back(u);
}
cout << "? " << n << " ";
for (int i = 1; i <= n; i++) cout << i << " ";
cout << "\n";
fflush(stdout);
cin >> node >> dist;
int root = node;
int mindist = dist;
dfs(root, 0);
int beg = max(1, mindist / 2), end = min(mindist, maxlev), ans = -1,
ansnode = -1;
while (beg <= end) {
int mid = avg(beg, end);
cout << "? " << (levels[mid].size()) << " ";
for (int i = 0; i < levels[mid].size(); i++) {
cout << levels[mid][i] << " ";
}
cout << "\n";
fflush(stdout);
cin >> node >> dist;
assert(node != -1);
if (dist == mindist) {
ans = mid;
ansnode = node;
beg = mid + 1;
} else {
end = mid - 1;
}
}
int distlef = mindist - ans, ansothernode = -1;
if (distlef == 0) {
ansothernode = root;
} else {
int cnt = 0;
for (int i = 0; i < levels[distlef].size(); i++) {
if (reqanc[levels[distlef][i]] != reqanc[ansnode]) cnt++;
}
cout << "? " << cnt << "\n";
for (int i = 0; i < levels[distlef].size(); i++) {
if (reqanc[levels[distlef][i]] != reqanc[ansnode]) {
cout << levels[distlef][i] << " ";
}
}
fflush(stdout);
cin >> ansothernode >> dist;
}
cout << "! " << ansnode << " " << ansothernode << "\n";
fflush(stdout);
cin >> resp;
if (resp == "Incorrect") return 0;
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int cnt;
int n;
string t, ss;
bool ok;
void dfs(int p, string s) {
if (cnt >= 2) return;
if (p >= n) {
cnt++;
return;
}
if (s[p] != '?') {
dfs(p + 1, s);
return;
}
bool a = 1, b = 1, c = 1;
if (s[p - 1] == 'C' || s[p + 1] == 'C') a = 0;
if (s[p - 1] == 'Y' || s[p + 1] == 'Y') b = 0;
if (s[p - 1] == 'M' || s[p + 1] == 'M') c = 0;
string ret;
if (a) {
ret = s;
ret[p] = 'C';
dfs(p + 1, ret);
}
if (b) {
ret = s;
ret[p] = 'Y';
dfs(p + 1, ret);
}
if (c) {
ret = s;
ret[p] = 'M';
dfs(p + 1, ret);
}
}
int main() {
cin >> n >> ss;
t = 'X' + ss;
n = t.size();
t = t + 'X';
dfs(0, t);
bool ok = 1;
for (int i = 1; i < ss.size(); i++)
if (ss[i] != '?' && ss[i] == ss[i - 1]) ok = 0;
if (cnt >= 2 && ok)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
double a[18][18], f[1 << 18];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%lf", &a[i][j]);
f[(1 << n) - 1] = 1;
for (int i = (1 << n) - 1; i; i--)
for (int u = 0; u < n; u++)
if (i & (1 << u))
for (int v = u + 1; v < n; v++)
if (i & (1 << v))
f[i ^ (1 << v)] +=
f[i] * a[u][v] /
(__builtin_popcount(i) * (__builtin_popcount(i) - 1) * .5),
f[i ^ (1 << u)] +=
f[i] * a[v][u] /
(__builtin_popcount(i) * (__builtin_popcount(i) - 1) * .5);
for (int i = 0; i < n; i++) printf("%.6lf ", f[1 << i]);
puts("");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2007;
int a[N], b[N], c[N], d[N];
int patl[N * N], patr[N * N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
c[a[i]] = i;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &b[i]);
d[b[i]] = i;
}
vector<pair<int, int>> v;
int sum = 0;
int q = 0;
for (int i = n; i >= 1; i--) {
int pos = c[b[i]];
sum += i - pos;
for (int j = c[b[i]] + 1; j <= i; ++j) {
if (j > d[a[j]] && d[a[j]] <= pos) {
int r = j;
int r1 = pos;
patl[q] = j;
patr[q] = pos;
q++;
swap(a[j], a[pos]);
c[a[j]] = j;
c[a[pos]] = pos;
pos = j;
}
}
}
cout << sum << endl << q << endl;
for (int i = 0; i < q; ++i) {
printf("%d %d\n", patl[i], patr[i]);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
read:
while (n--) {
string s1, s2;
cin >> s1 >> s2;
int idx = 0;
for (int i = 0; i < s1.size(); i++) {
bool ok = 1;
for (int j = idx; j < s2.size(); j++) {
if (s1[i] == s2[j]) {
idx = max(idx, j);
idx++;
ok = 0;
break;
} else {
if (s2[j] != s1[i - 1]) {
cout << "NO" << '\n';
goto read;
}
}
}
if (ok) {
cout << "NO" << '\n';
goto read;
}
}
for (int i = idx; i < s2.size(); i++) {
if (s2[i] != s1[s1.size() - 1]) {
cout << "NO" << '\n';
goto read;
}
}
cout << "YES" << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(char c) { return '\'' + string(1, c) + '\''; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
string to_str(const int &n) {
ostringstream stm;
stm << n;
return stm.str();
}
string to_str(const long long &n) {
ostringstream stm;
stm << n;
return stm.str();
}
template <class T>
string tostring(T x, int len = 0) {
stringstream ss;
ss << x;
string r = ss.str();
if (int((r).size()) < len) r = string(len - int((r).size()), '0') + r;
return r;
}
template <class T>
void convert(string x, T &r) {
stringstream ss(x);
ss >> r;
}
long long powmod(long long a, long long b) {
long long res = 1;
a %= 998244353;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 998244353;
a = a * a % 998244353;
}
return res;
}
long long modinv(long long a) { return powmod(a, 998244353 - 2); }
long long modinv(long long a, long long m) { return powmod(a, m - 2); }
long long nCkMp(long long n, long long k) {
long long numerator = 1, denominator = 1;
for (int i = 0; i < k; i++) numerator = (numerator * (n - i)) % 998244353;
for (int i = 1; i <= k; i++) denominator = (denominator * i) % 998244353;
return (numerator * modinv(denominator)) % 998244353;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
int TT = 1, tt;
clock_t t1;
void solve() {
t1 = clock();
int n, m;
(cin >> (n));
(cin >> (m));
vector<int> prev(m), cur(m);
for (auto i = (0); i < (n); i++) {
for (auto j = (0); j < (m); j++) {
(cin >> (cur[j]));
if (j == 0)
cur[j] += prev[j];
else
cur[j] += max(cur[j - 1], prev[j]);
}
cout << cur[m - 1] << " ";
prev = cur;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (tt = 0; tt < TT; tt++) solve();
return EXIT_SUCCESS;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 5;
int n;
struct Node {
int x, i;
Node(int x = -1, int i = -1) : x(x), i(i) {}
bool operator<(const Node &node) const { return x < node.x; }
} nodes[maxn];
int a[maxn];
int d[maxn];
int cnt[maxn];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> nodes[i].x;
nodes[i].i = i;
}
sort(nodes + 1, nodes + n + 1);
a[nodes[1].i] = 1;
a[nodes[2].i] = 1;
a[nodes[3].i] = 1;
d[3] = nodes[3].x - nodes[1].x;
cnt[3] = 3;
for (int i = 4; i <= n; i++) {
if (i < 6) {
d[i] = nodes[i].x - nodes[1].x;
a[nodes[i].i] = 1;
cnt[i] = i;
} else {
if (i >= 6) {
d[i] = d[i - 3] + nodes[i].x - nodes[i - 2].x;
cnt[i] = 3;
}
if (i >= 7) {
if (d[i] > d[i - 4] + nodes[i].x - nodes[i - 3].x) {
d[i] = d[i - 4] + nodes[i].x - nodes[i - 3].x;
cnt[i] = 4;
}
}
if (i >= 8) {
if (d[i] > d[i - 5] + nodes[i].x - nodes[i - 4].x) {
d[i] = d[i - 5] + nodes[i].x - nodes[i - 4].x;
cnt[i] = 5;
}
}
}
}
int xxx = 1;
for (int i = n; i >= 1; i--) {
int tmp = 0;
while (tmp < cnt[i]) {
a[nodes[i - tmp].i] = xxx;
tmp++;
}
i = i - cnt[i] + 1;
xxx++;
}
cout << d[n] << " " << xxx - 1 << endl;
for (int i = 1; i <= n; i++) {
cout << a[i];
if (i == n) {
cout << endl;
} else {
cout << " ";
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
string s;
int m;
int ans[1100];
int solve(int i, int diff, int last) {
if ((i > 0 && diff <= 0) || diff > 10) {
return 0;
}
if (i == m) {
cout << "YES" << endl;
for (int j = 0; j < m; j++) {
cout << ans[j] << " ";
}
return 1;
}
for (int j = 0; j < s.size(); j++) {
if (s[j] == '1' && j != last) {
ans[i] = j + 1;
if (solve(i + 1, j + 1 - diff, j)) {
return 1;
}
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s >> m;
if (!solve(0, 0, 10)) {
cout << "NO" << endl;
return 0;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[4], i, c = 0;
for (i = 0; i < 4; i++) {
cin >> a[i];
}
sort(a, a + 4);
for (i = 0; i < 4; i++) {
if (a[i] == a[i + 1]) c++;
}
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long b, long long m) {
long long res = 1;
a = a % m;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long mod(long long a, long long b) {
if (a % b < 0) {
return a % b + b;
}
return a % b;
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
bool isPowerOfTwo(long long n) {
if (n == 0) return 0;
while (n != 1) {
if (n % 2 != 0) return 0;
n = n / 2;
}
return 1;
}
int main() {
long long t = 1;
cin >> t;
while (t--) {
long long a, b, n, m;
long long ans = -1;
cin >> a >> b >> n >> m;
if ((a + b) < (n + m))
ans = -1;
else {
if (((a > b) ? b : a) >= m) ans = 1;
}
if (ans == -1)
cout << "NO" << endl;
else if (ans == 1)
cout << "YES" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, A;
int mx, l, r;
long long K, B;
set<long long> p;
void cl() {
r = min(r, A - 1);
if (l > r) l = r = 0;
if (K > 0) {
long long qx = A - B;
while (!p.empty()) {
set<long long>::iterator ga = p.lower_bound(qx);
if (ga != p.end())
p.erase(ga);
else
break;
}
} else {
long long qx = B - A;
while (!p.empty()) {
set<long long>::iterator la = p.upper_bound(qx);
if (la != p.begin())
la--, p.erase(la);
else
break;
}
}
}
void rev() {
if (l) l = A - l, r = A - r, swap(l, r);
K = -K;
B = A - B;
}
int chkmax(int x) {
if (x >= l && x <= r) return 1;
set<long long>::iterator nxt = p.lower_bound((x - B) * K);
return nxt != p.end() && *nxt == (x - B) * K;
}
void solve() {
mx = -1;
l = 1;
r = 1e9;
K = 1;
B = 0;
p.clear();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &A);
cl();
rev();
if (l || !p.empty())
mx++;
else
l = 1, r = A - 1;
if (A & 1) continue;
if (chkmax(A / 2)) mx++, l = r = 0, p.clear();
p.insert((A / 2 - B) * K);
}
printf("%d\n", 2 * n - mx);
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
void tostring(pair<A, B> p) {
cerr << "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <class A>
void tostring(A v) {
int f = 1;
string r = "{";
for (auto& x : v) {
if (!f) {
r += ", ";
}
f = 0;
r += to_string(x);
}
r += "}\n";
cerr << r;
}
void _out() { cerr << '\n'; }
template <typename H, typename... T>
void _out(H h, T... t) {
cerr << ' ' << h;
_out(t...);
}
void show() { cerr << '\n'; }
template <typename H, typename... T>
void show(H h, T... t) {
cerr << h << ' ';
show(t...);
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n + 2), b(k + 2);
for (long long i = (long long)(1); i <= (long long)(n); i++) {
cin >> a[i];
a[i] -= i;
}
long long f = 1;
a[0] = -2e9, a[n + 1] = 2e9;
for (long long i = (long long)(1); i <= (long long)(k); i++) {
cin >> b[i];
if (a[b[i]] < a[b[i - 1]]) {
f = 0;
}
}
if (!f) {
cout << -1;
return;
}
b[k + 1] = n + 1;
long long res = n - k;
for (long long i = (long long)(0); i <= (long long)(k); i++) {
long long l = b[i] + 1, r = b[i + 1] - 1;
vector<long long> f(r - l + 10);
f[0] = a[b[i]];
long long len = 0;
long long x, y, ans;
for (long long j = (long long)(l); j <= (long long)(r); j++) {
if (a[j] >= f[len]) {
f[++len] = a[j];
} else {
x = 1, y = len, ans = -1;
while (x <= y) {
long long mid = x + y >> 1;
if (f[mid] <= a[j]) {
ans = mid;
x = mid + 1;
} else
y = mid - 1;
}
if (ans != -1) {
f[ans + 1] = a[j];
} else if (f[1] > a[j] && a[j] >= f[0]) {
f[1] = a[j];
}
}
}
x = 1, y = len, ans = -1;
while (x <= y) {
long long mid = x + y >> 1;
if (f[mid] <= a[b[i + 1]]) {
x = mid + 1;
ans = mid;
} else
y = mid - 1;
}
if (ans != -1) {
res -= ans;
}
}
cout << res;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
struct Path {
int x;
int y;
int z;
bool operator<(Path const &a) const {
if (x != a.x)
return x < a.x;
else if (y != a.y)
return y < a.y;
else
return z < a.z;
}
};
set<Path> invalid;
int const nmax = 3000;
int dist[1 + nmax][1 + nmax];
int last[1 + nmax][1 + nmax];
set<int> g[1 + nmax];
void print(int x, int y) {
if (0 < x) print(last[x][y], x);
cout << y << " ";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
g[x].insert(y);
g[y].insert(x);
}
for (int i = 1; i <= k; i++) {
int x, y, z;
cin >> x >> y >> z;
invalid.insert({x, y, z});
}
queue<pair<int, int> > q;
q.push({0, 1});
dist[0][1] = 0;
last[0][1] = 0;
while (0 < q.size()) {
pair<int, int> p = q.front();
q.pop();
int node = p.second;
set<int>::iterator it = g[node].begin();
while (it != g[node].end()) {
int to = *it;
if (invalid.find({p.first, node, to}) == invalid.end()) {
dist[node][to] = dist[p.first][node] + 1;
last[node][to] = p.first;
q.push({node, to});
g[node].erase(it++);
} else
it++;
}
}
int result = -1, id = 0;
for (int i = 1; i <= n; i++)
if (0 < dist[i][n] && (result == -1 || dist[i][n] < result)) {
result = dist[i][n];
id = i;
}
cout << result << '\n';
if (0 < result) print(id, n);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x;
double ans = 0;
cin >> x;
for (int i = 1; i <= x; i++) {
ans += (double)1 / i;
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 200007;
int low[maxn], high[maxn], val[maxn], n;
void update(int bit[], int k, int c) {
for (; k <= n; k += -k & k) {
bit[k] += c;
}
}
int sum(int bit[], int k) {
int ret = 0;
for (; k; k -= -k & k) {
ret += bit[k];
}
return ret;
}
int main() {
int k, a, b, q, op, l, r, x;
scanf("%d %d %d %d %d", &n, &k, &a, &b, &q);
for (int i = 0; i < q; i++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d %d", &l, &x);
update(low, l, -1 * std::min(val[l], b));
update(high, l, -1 * std::min(val[l], a));
val[l] += x;
update(low, l, std::min(val[l], b));
update(high, l, std::min(val[l], a));
} else {
scanf("%d", &l);
r = l + k - 1;
int ans = sum(low, l - 1) + sum(high, n) - sum(high, r);
printf("%d\n", ans);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
ostream &operator<<(ostream &out, pair<T, T1> obj) {
out << "(" << obj.first << "," << obj.second << ")";
return out;
}
template <typename T, typename T1>
ostream &operator<<(ostream &out, map<T, T1> cont) {
typename map<T, T1>::const_iterator itr = cont.begin();
typename map<T, T1>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, set<T> cont) {
typename set<T>::const_iterator itr = cont.begin();
typename set<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, multiset<T> cont) {
typename multiset<T>::const_iterator itr = cont.begin();
typename multiset<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T,
template <typename ELEM, typename ALLOC = allocator<ELEM>> class CONT>
ostream &operator<<(ostream &out, CONT<T> cont) {
typename CONT<T>::const_iterator itr = cont.begin();
typename CONT<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T, unsigned int N, typename CTy, typename CTr>
typename enable_if<!is_same<T, char>::value, basic_ostream<CTy, CTr> &>::type
operator<<(basic_ostream<CTy, CTr> &out, const T (&arr)[N]) {
for (auto i = 0; i < N; ++i) out << arr[i] << " ";
out << endl;
return out;
}
template <typename T>
T gcd(T a, T b) {
T min_v = min(a, b);
T max_v = max(a, b);
while (min_v) {
T temp = max_v % min_v;
max_v = min_v;
min_v = temp;
}
return max_v;
}
template <typename T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
template <typename T>
T fast_exp_pow(T base, T exp, T mod) {
long long res = 1;
while (exp) {
if (exp & 1) {
res *= base;
res %= mod;
}
exp >>= 1;
base *= base;
base %= mod;
}
return res % mod;
}
int N, A, B, long_dist, long_node, answer;
vector<int> graph[210];
vector<pair<int, int>> road;
void create_semi_graph(vector<int> semi_graph[210][210], int node, int par,
int cnt) {
for (auto conn_node : graph[node]) {
if (conn_node != par) {
semi_graph[cnt][conn_node].push_back(node);
semi_graph[cnt][node].push_back(conn_node);
create_semi_graph(semi_graph, conn_node, node, cnt);
}
}
}
void longest_path(vector<int> semi_graph[210][210], int cnt, int node, int par,
int dist) {
if (dist > long_dist) {
long_dist = dist;
long_node = node;
}
for (auto conn_node : semi_graph[cnt][node]) {
if (conn_node != par)
longest_path(semi_graph, cnt, conn_node, node, dist + 1);
}
}
int find_diameter(vector<int> semi_graph[210][210], int cnt, int node) {
long_dist = 0, long_node = 0;
longest_path(semi_graph, cnt, node, 0, 0);
long_dist = 0;
longest_path(semi_graph, cnt, long_node, 0, 0);
return long_dist;
}
void solve(int node_1, int node_2) {
vector<int> semi_graph[2][210];
int mx_1 = 0, mx_2 = 0;
create_semi_graph(semi_graph, node_1, node_2, 0);
create_semi_graph(semi_graph, node_2, node_1, 1);
for (auto i = 0; i < 2; ++i) {
int node = (!i ? node_1 : node_2);
int ret = find_diameter(semi_graph, i, node);
if (ret > mx_1) {
mx_2 = mx_1;
mx_1 = ret;
} else if (ret > mx_2)
mx_2 = ret;
}
answer = max(answer, mx_1 * mx_2);
}
int main() {
scanf("%d", &N);
for (auto i = 0; i < N - 1; ++i) {
scanf("%d%d", &A, &B);
graph[A].push_back(B);
graph[B].push_back(A);
road.emplace_back(A, B);
}
for (auto elem : road) solve(elem.first, elem.second);
printf("%d\n", answer);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 7;
vector<int> edg[MAXN];
int niche[MAXN];
map<int, int> mp[MAXN];
void dfs(int u, int p) {
for (int v : edg[u]) {
if (v == p) continue;
dfs(v, u);
niche[u] = max(niche[u], 1 + niche[v]);
mp[u][niche[v] + 1]++;
}
}
int ans[MAXN];
int up[MAXN];
void solve(int u, int p, int upore) {
up[u] = upore;
if (p > 0) {
mp[u][upore + 1]++;
}
mp[u][0]++;
int total = 0;
for (pair<int, int> pr : mp[u]) total += pr.second;
int last = -1;
for (pair<int, int> pr : mp[u]) {
if (pr.first > 0) {
ans[pr.first * 2] = max(ans[pr.first * 2], total);
ans[pr.first * 2 - 1] =
max(ans[pr.first * 2 - 1], total + (last == pr.first - 1));
ans[pr.first * 2 + 1] =
max(ans[pr.first * 2 + 1], (total - pr.second) + 1);
}
last = pr.first;
total -= pr.second;
}
for (int v : edg[u]) {
if (v == p) continue;
mp[u][niche[v] + 1]--;
auto it = prev(mp[u].end());
if (it->second == 0) it = prev(it);
solve(v, u, it->first);
mp[u][niche[v] + 1]++;
}
}
void twoPointer(int u, int v) {
int utotal = 0;
for (pair<int, int> p : mp[u]) utotal += p.second;
int vtotal = 0;
for (pair<int, int> p : mp[v]) vtotal += p.second;
for (auto ut = mp[u].begin(), vt = mp[v].begin();
ut != mp[u].end() && vt != mp[v].end();) {
if (ut->first < vt->first) {
ans[ut->first * 2] = max(ans[ut->first * 2], utotal + vtotal);
utotal -= ut->second;
ut++;
} else if (ut->first > vt->first) {
ans[vt->first * 2] = max(ans[vt->first * 2], utotal + vtotal);
vtotal -= vt->second;
vt++;
} else {
ans[ut->first * 2] = max(ans[ut->first * 2], utotal + vtotal);
utotal -= ut->second;
ut++;
vtotal -= vt->second;
vt++;
}
}
}
void haha(int u, int p) {
for (int v : edg[u]) {
if (v == p) continue;
mp[v][up[v] + 1]--;
mp[u][niche[v] + 1]--;
twoPointer(v, u);
mp[u][niche[v] + 1]++;
mp[v][up[v] + 1]++;
}
for (int v : edg[u]) {
if (v == p) continue;
haha(v, u);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
edg[u].push_back(v);
edg[v].push_back(u);
}
ans[n] = 1;
ans[n - 1] = 1;
dfs(1, 0);
solve(1, 0, 0);
haha(1, 0);
for (int i = n; i > 0; i--) {
ans[i] = max(ans[i], ans[i + 2]);
}
for (int i = 1; i <= n; i++) {
ans[1] = max(ans[1], 1 + (int)edg[i].size());
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
struct rings {
int a, b, h;
rings(int aa, int bb, int hh) {
a = aa;
b = bb;
h = hh;
}
};
vector<rings> ara;
int n;
long long int segTree[4 * 100105];
void merge_node(int nd) {
segTree[nd] = max(segTree[nd + nd], segTree[nd + nd + 1]);
}
void build(int s, int e, int nd) {
if (s == e) {
segTree[nd] = ara[s].h;
return;
}
int mid = (s + e) >> 1;
build(s, mid, nd + nd);
build(mid + 1, e, nd + nd + 1);
merge_node(nd);
}
void update(int s, int e, int nd, int p, long long v) {
if (s > p || e < p) {
return;
}
if (s == e && e == p) {
segTree[nd] += v;
return;
}
int mid = (s + e) >> 1;
update(s, mid, nd + nd, p, v);
update(mid + 1, e, nd + nd + 1, p, v);
merge_node(nd);
}
long long query(int s, int e, int nd, int l, int r) {
if (s > r || e < l || l > r) return 0LL;
if (s >= l && e <= r) return segTree[nd];
int mid = (s + e) >> 1;
return max(query(s, mid, nd + nd, l, r),
query(mid + 1, e, nd + nd + 1, l, r));
}
bool cmp(rings a, rings b) {
if (a.b != b.b) return a.b > b.b;
if (a.a != b.a) return a.a > b.a;
return a.h > b.h;
}
int upperBound(int x) {
int low = 0;
int high = n + 1;
int mid;
while (high > low) {
mid = (high + low) >> 1;
if (ara[mid].b <= x) {
high = mid;
} else
low = mid + 1;
}
while (high > 0 && ara[high - 1].b <= x) high--;
return high;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int aa, bb, hh;
scanf("%d %d %d", &aa, &bb, &hh);
ara.push_back(rings(aa, bb, hh));
}
ara.push_back(rings(0, 0, 0));
ara.push_back(rings(0, 1000000001, 0));
sort(ara.begin(), ara.end(), cmp);
build(1, n, 1);
for (int i = n; i > 0; i--) {
int up = upperBound(ara[i].a);
long long v = query(1, n, 1, i + 1, up - 1);
update(1, n, 1, i, v);
}
long long mx = 0;
for (int i = 1; i <= n; i++) {
mx = max(mx, query(1, n, 1, i, i));
}
printf("%I64d\n", mx);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[5001][5001];
vector<int> p, e;
ll solve(int i, int j){
if(i >= p.size()){ // no person left, return 0
return 0;
}
if(j >= e.size()){
return 1e18;
}
if(dp[i][j] != -1){
return dp[i][j];
}
// we have 2 options either to make ith person take jth chair or to make him take another chair
// we will take the minimum of those 2 choices
dp[i][j] = min(solve(i, j+1), abs(e[j] - p[i]) + solve(i+1, j+1));
return dp[i][j];
}
int main() {
ios_base :: sync_with_stdio(false);
cin.tie(NULL);
int n;
cin>>n;
for(int i=0;i<n;i++){
int num;
cin>>num;
if(num){
p.push_back(i); // filled chairs
}
else{
e.push_back(i); // empty chairs
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
dp[i][j] = -1;
}
}
if(p.size() == 0){
cout<<"0";
return 0;
}
else{
cout<<solve(0, 0);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int MX = (int)1e5 + 10;
std::vector<int> g[MX];
int init[MX], goal[MX];
vector<int> res;
void dfs(int x, int par, int lvl, vector<int> flipped) {
init[x] ^= flipped[lvl];
if (init[x] != goal[x]) {
flipped[lvl] ^= true;
init[x] ^= 1;
res.push_back(x);
}
for (auto y : g[x]) {
if (y == par) continue;
dfs(y, x, lvl ^ 1, flipped);
}
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i + 1 < n; ++i) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; ++i) {
cin >> init[i];
}
for (int i = 1; i <= n; ++i) {
cin >> goal[i];
}
dfs(1, 0, 0, {0, 0});
cout << res.size() << "\n";
for (auto x : res) cout << x << "\n";
cout << flush;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 300333, inf = 1000111222;
int t, n, a[max_n], ans[max_n];
vector<int> all[max_n];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
all[i + 1].push_back(-1);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
all[a[i]].push_back(i);
}
for (int i = 0; i < n; ++i) {
all[i + 1].push_back(n);
}
for (int i = 1; i <= n; ++i) {
ans[i] = inf;
}
for (int i = 1; i <= n; ++i) {
int d = 0;
for (int j = 0; j + 1 < all[i].size(); ++j) {
d = max(d, all[i][j + 1] - all[i][j]);
}
ans[d] = min(ans[d], i);
}
for (int i = 2; i <= n; ++i) {
ans[i] = min(ans[i], ans[i - 1]);
}
for (int i = 1; i <= n; ++i) {
if (ans[i] == inf) {
ans[i] = -1;
}
printf("%d ", ans[i]);
all[i].clear();
}
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int ar[n + 1];
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
int cnt = 0;
while (1) {
bool flag = true;
for (int i = 1; i <= n; i++) {
if (ar[i] != i) {
flag = false;
cnt++;
break;
}
}
if (flag) {
break;
}
if (cnt & 1) {
for (int i = 1; i <= n - 2; i += 2) {
if (ar[i] > ar[i + 1]) {
int tmp = ar[i];
ar[i] = ar[i + 1];
ar[i + 1] = tmp;
}
}
} else {
for (int i = 2; i <= n - 1; i += 2) {
if (ar[i] > ar[i + 1]) {
int tmp = ar[i];
ar[i] = ar[i + 1];
ar[i + 1] = tmp;
}
}
}
}
cout << cnt << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
int a[N];
int inverse[N];
vector<int> g[N];
int dp[N];
bool solve(int start) {
if (dp[start] != -1) return dp[start];
bool possible = false;
for (int i = 0; i < g[start].size(); i++) {
int neighbor = g[start][i];
possible = possible || !solve(neighbor);
}
dp[start] = possible;
return possible;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) dp[i] = -1;
for (int i = 0; i < n; i++) {
inverse[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
int start = inverse[i];
for (int j = start; j < n; j += i) {
if (a[j] > i && (((j - start) % i) == 0)) {
g[i].push_back(a[j]);
}
}
for (int j = start; j >= 0; j -= i) {
if (a[j] > i && (((start - j) % i) == 0)) {
g[i].push_back(a[j]);
}
}
}
for (int i = n; i >= 1; i--) {
solve(i);
}
for (int i = 0; i < n; i++) {
if (dp[a[i]] == false)
cout << "B";
else
cout << "A";
}
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _print(T a) {
cerr << a;
}
template <class T>
void _print(vector<T> v) {
cerr << "[";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(set<T> s) {
cerr << "[";
for (T i : s) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> s) {
cerr << "[";
for (T i : s) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(unordered_map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
vector<long long int> ans;
void cc() {
for (long long int i = 1; i <= 1666; i++) {
if (i % 3 == 0 || i % 10 == 3) continue;
ans.push_back(i);
}
}
void solve() {
long long int n;
cin >> n;
cout << ans[n - 1] << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cc();
long long int t = 1;
cin >> t;
for (long long int i = 1; i <= t; i++) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 150000 + 5;
using namespace std;
int a[MAXN];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int ans = 1;
if (a[1] > 1) --a[1];
for (int i = 2, last = a[1]; i <= n; ++i) {
if (a[i] - 1 > last) {
last = --a[i];
++ans;
continue;
}
if (a[i] > last) {
last = a[i];
++ans;
continue;
}
if (a[i] + 1 > last) {
last = ++a[i];
++ans;
continue;
}
}
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int A, int B) {
if (!B) return A;
return gcd(B, A % B);
}
long long int dp[200005];
int lf[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
string s;
cin >> n >> k >> s;
int nearest = -1;
for (int i = n - 1; i >= -k; i--) {
if (i >= 0 && s[i] == '1') nearest = i;
if (i + k < n) lf[i + k] = nearest;
}
fill(dp, dp + n, 1e17);
dp[n] = 0;
for (int i = n; i > 0; i--) {
if (lf[i - 1] - (i - 1) <= k && lf[i - 1] != -1) {
int x = max(0, lf[i - 1] - k);
dp[x] = min(dp[x], dp[i] + lf[i - 1] + 1);
}
dp[i - 1] = min(dp[i - 1], dp[i] + i);
}
cout << dp[0] << endl;
}
| 13 |
#include <bits/stdc++.h>
int main() {
int i, j, n, t = 1;
char s[105], s1[35];
scanf("%d", &n);
for (i = 0; i <= n; i++) scanf("%c", &s[i]);
if (n < 26)
printf("NO");
else {
for (i = 1; i <= n; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
s[i] = s[i] + 32;
}
}
s1[1] = s[1];
for (i = 2; i <= n; i++) {
for (j = 1; j <= t; j++) {
if (s[i] == s1[j])
break;
else if (j == t) {
t++;
s1[t] = s[i];
break;
} else
continue;
}
}
if (t >= 26)
printf("YES");
else
printf("NO");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7, MAXN = 1010;
char a[MAXN][MAXN];
int u[MAXN][MAXN];
int l1, l2, k, f, n, m;
int x, xx, yy, y;
bool is_in(int x, int y) {
return ((x < 1 || x > n || y < 1 || y > m) ? 0 : 1);
}
queue<pair<int, int> > q;
void dfs(int x, int y, int t) {
if (!is_in(x, y)) return;
if (u[x][y] != -1) return;
if (a[x][y] != '.') return;
u[x][y] = f + 1;
q.push({x, y});
if (t == k) return;
dfs(x + l1, y + l2, t + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
u[i][j] = -1;
}
cin >> x >> y >> xx >> yy;
u[x][y] = 0;
q.push({x, y});
while (!q.empty()) {
x = q.front().first, y = q.front().second;
q.pop();
f = u[x][y];
for (int j = -1; j <= 1; ++j) {
for (int i = -1; i <= 1; ++i) {
if (abs(i + j) != 1) continue;
l1 = i;
l2 = j;
dfs(x + i, y + j, 1);
}
}
}
cout << u[xx][yy];
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int inf = 1e9;
int n, m, v[maxn], l[maxn], ans[maxn], r[maxn], p[maxn];
char c;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> c;
v[i] = c - 'a';
}
vector<int> k;
for (int i = 0; i < 3; i++) k.push_back(i);
for (int i = 1; i <= m; i++) ans[i] = inf;
for (int i = 1; i <= m; i++) cin >> l[i] >> r[i];
do {
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1] + (k[i % 3] != v[i]);
}
for (int i = 1; i <= m; i++) ans[i] = min(ans[i], p[r[i]] - p[l[i] - 1]);
} while (next_permutation(k.begin(), k.end()));
for (int i = 1; i <= m; i++) cout << ans[i] << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100007];
int dp[100007];
int used[100007];
void input();
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
void input() {
scanf("%d", &n);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
}
void solve() {
int i;
int ans = 0;
for (i = 1; i <= n; i++) {
used[a[i]] = 1;
if (used[a[i] - 1] == 1) {
dp[a[i]] = dp[a[i] - 1] + 1;
} else {
dp[a[i]] = 1;
}
ans = max(ans, dp[a[i]]);
}
printf("%d\n", n - ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N, K, Q;
int A[100005];
long long PartialR[100005], PartialL[100005], ans;
int B[100005], bl, coord, FreqR[200005], FreqL[200005], T[200005];
long long Coord[200005], Aux[200005], Res[200005];
const int limit = 320;
pair<pair<int, int>, int> Query[100005];
void Read() {
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; i++) scanf("%d", &T[i]);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
if (T[i] == 2) A[i] = -A[i];
}
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
int l, r;
scanf("%d%d", &l, &r);
Query[i] = make_pair(make_pair(l, r), i);
}
}
void precalcPartial() {
for (int i = 1; i <= N; i++) {
PartialR[i] = PartialR[i - 1] + A[i];
PartialL[i] = PartialR[i] + K;
Coord[++coord] = PartialR[i];
Coord[++coord] = PartialL[i];
}
Coord[++coord] = 0;
Coord[++coord] = K;
PartialL[0] = K;
sort(Coord + 1, Coord + coord + 1);
}
int findValue(long long val) {
int left = 1, right = coord, mid, sol;
while (left <= right) {
mid = (left + right) / 2;
if (Coord[mid] == val) return mid;
if (Coord[mid] < val)
left = mid + 1;
else
right = mid - 1;
}
return -1;
}
void normalize() {
int ind = 0;
for (int i = 1; i <= coord; i++) {
if (i == 1 || Coord[i] != Coord[i - 1]) Aux[++ind] = Coord[i];
}
coord = ind;
for (int i = 1; i <= ind; i++) Coord[i] = Aux[i];
for (int i = 0; i <= N; i++) {
PartialL[i] = findValue(PartialL[i]);
PartialR[i] = findValue(PartialR[i]);
}
}
void precalcBlock() {
int cnt = 0;
for (int i = 1; i <= N; i++) {
++cnt;
if (cnt == limit + 1) {
cnt = 1;
bl++;
}
B[i] = bl;
}
}
bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (B[a.first.first] == B[b.first.first])
return a.first.second < b.first.second;
return B[a.first.first] < B[b.first.first];
}
void expandLeft(int left) {
FreqR[PartialR[left]]++;
FreqL[PartialL[left - 1]]++;
ans += FreqR[PartialL[left - 1]];
}
void reduceLeft(int left) {
ans -= FreqR[PartialL[left - 1]];
FreqR[PartialR[left]]--;
FreqL[PartialL[left - 1]]--;
}
void expandRight(int right) {
FreqL[PartialL[right - 1]]++;
FreqR[PartialR[right]]++;
ans += FreqL[PartialR[right]];
}
void reduceRight(int right) {
ans -= FreqL[PartialR[right]];
FreqR[PartialR[right]]--;
FreqL[PartialL[right - 1]]--;
}
void Solve() {
int left = 1, right = 1;
FreqL[PartialL[0]]++;
FreqR[PartialR[1]]++;
ans = (PartialR[1] == PartialL[0]);
sort(Query + 1, Query + Q + 1, cmp);
for (int i = 1; i <= Q; i++) {
int l = Query[i].first.first, r = Query[i].first.second,
pos = Query[i].second;
while (right < r) {
++right;
expandRight(right);
}
while (left < l) {
reduceLeft(left);
++left;
}
while (right > r) {
reduceRight(right);
right--;
}
while (left > l) {
--left;
expandLeft(left);
}
Res[pos] = ans;
}
}
void Print() {
for (int i = 1; i <= Q; i++) printf("%I64d\n", Res[i]);
}
int main() {
Read();
precalcBlock();
precalcPartial();
normalize();
Solve();
Print();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
register int data = 0, w = 1;
register char ch = 0;
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (isdigit(ch)) data = 10 * data + ch - '0', ch = getchar();
return w * data;
}
const int MAX_N = 3e5 + 5;
int N, maxd, f[20][MAX_N], dep[MAX_N];
void add(int x, int fa) {
dep[x] = dep[fa] + 1, f[0][x] = fa;
for (int i = 1; i < 20; i++) f[i][x] = f[i - 1][f[i - 1][x]];
}
int LCA(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 19; ~i; i--)
if (dep[f[i][u]] >= dep[v]) u = f[i][u];
if (u == v) return v;
for (int i = 19; ~i; i--)
if (f[i][u] != f[i][v]) u = f[i][u], v = f[i][v];
return f[0][u];
}
int dist(int u, int v) { return dep[u] + dep[v] - dep[LCA(u, v)] * 2; }
vector<int> s1, s2;
int main() {
N = gi();
add(1, 0), s1.push_back(1);
for (int i = 1; i <= N; i++) {
int x = i + 1;
add(x, gi());
int d1 = s1.empty() ? 0 : dist(x, s1[0]);
int d2 = s2.empty() ? 0 : dist(x, s2[0]);
if (max(d1, d2) > maxd) {
maxd = max(d1, d2);
if (d1 > d2) {
for (int v : s2)
if (dist(x, v) == d1) s1.push_back(v);
s2 = {x};
} else {
for (int v : s1)
if (dist(x, v) == d2) s2.push_back(v);
s1 = {x};
}
} else if (max(d1, d2) == maxd) {
if (d1 > d2)
s2.push_back(x);
else
s1.push_back(x);
}
printf("%lld\n", s1.size() + s2.size());
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int a[16][2048];
int n, m;
pair<int, int> w[2048];
int b[12][12];
int f[1 << 12];
int f2[1 << 12];
int p[12][1 << 12];
int main() {
int tn;
scanf("%d", &tn);
while (tn--) {
scanf("%d%d", &n, &m);
memset(a, 0, sizeof(a));
for (int i = 0, ThxDem = n; i < ThxDem; ++i)
for (int j = 0, ThxDem = m; j < ThxDem; ++j) scanf("%d", &a[i][j]);
m = max(m, n);
for (int j = 0, ThxDem = m; j < ThxDem; ++j) {
int mx = -1;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) mx = max(mx, a[i][j]);
w[j] = make_pair(mx, j);
}
sort(w, w + m);
reverse(w, w + m);
for (int i = 0, ThxDem = n; i < ThxDem; ++i)
for (int j = 0, ThxDem = n; j < ThxDem; ++j) b[i][j] = a[i][w[j].second];
memset(f, 0, sizeof(f));
for (int j = 0, ThxDem = n; j < ThxDem; ++j)
for (int s = 0, ThxDem = (1 << n); s < ThxDem; ++s) {
int r = 0;
for (int o = 0, ThxDem = n; o < ThxDem; ++o) {
int x = 0;
for (int i = 0, ThxDem = n; i < ThxDem; ++i)
if (s & (1 << i)) x += b[(i + o) % n][j];
r = max(r, x);
}
p[j][s] = r;
}
for (int j = 0, ThxDem = n; j < ThxDem; ++j) {
memset(f2, 0, sizeof(f2));
for (int m = 0, ThxDem = (1 << n); m < ThxDem; ++m) {
int w = ((1 << n) - 1) ^ m;
for (int s = w;; s = ((s - 1) & w)) {
f2[m | s] = max(f2[m | s], f[m] + p[j][s]);
if (!s) break;
}
}
memcpy(f, f2, sizeof(f));
}
printf("%d\n", f[(1 << n) - 1]);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ta, tb, k;
scanf("%d%d%d%d%d", &n, &m, &ta, &tb, &k);
vector<int> a(n), b(m);
for (int &t : a) scanf("%d", &t);
for (int &t : b) scanf("%d", &t);
if (k >= min(n, m)) {
puts("-1");
return 0;
}
int i = 0, j = 0;
int ans = 0;
while (k && i < n) {
while (j < m && a[i] + ta > b[j]) j++;
if (j + k >= m) {
puts("-1");
return 0;
}
ans = max(ans, b[j + k] + tb);
i++;
k--;
}
while (i < n && j < m && a[i] + ta > b[j]) j++;
if (i == n || j == m) {
puts("-1");
return 0;
}
ans = max(ans, b[j] + tb);
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3000;
const long long MOD = 1000 * 1000 * 1000 + 7;
long long n, k, dp[maxN][maxN], sum[maxN][maxN], s[maxN], ans;
char c;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> c;
s[i] = c;
}
sum[0][0] = dp[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
dp[i + 1][j] += sum[i][j] * (s[i] - 'a');
dp[i + 1][j] %= MOD;
for (int x = 0; i - x >= 0 && j >= (x + 1) * (n - i); x++)
dp[i + 1][j] =
(dp[i + 1][j] + dp[i - x][j - (x + 1) * (n - i)] * ('z' - s[i])) %
MOD;
sum[i + 1][j] += (sum[i][j] + dp[i + 1][j]) % MOD;
}
}
for (int i = 0; i <= n; i++) ans = (ans + dp[i][k]) % MOD;
cout << ans % MOD << endl;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
char s[112], chat[100][112];
int us[100], n, m;
string P[101];
vector<int> no[100];
bool vis[100][101];
bool go(int j) {
if (j == m) return true;
if (j && us[j] == us[j - 1]) return false;
if (!j && us[j] || j && us[j] && us[j] != us[j - 1]) return true;
for (int i = 1; i < (int)n + 1; ++i)
if ((!j || i != us[j - 1]) &&
!binary_search(no[j].begin(), no[j].end(), i) && !vis[j][i]) {
vis[j][i] = true;
us[j] = i;
if (go(j + 1)) return true;
us[j] = 0;
}
return false;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
for (int i = 0; i < (int)100; ++i)
for (int j = 0; j < (int)101; ++j) vis[i][j] = false;
mp.clear();
scanf("%d", &n);
for (int i = 1; i < (int)n + 1; ++i) {
scanf("%s", s);
mp[s] = i;
P[i] = s;
}
scanf("%d", &m);
for (int i = 0; i < (int)m; ++i) {
no[i].clear();
scanf("\n");
gets(chat[i]);
int j = 0, z = strlen(chat[i]);
for (int j = 0; j < (int)z; ++j) s[j] = chat[i][j];
s[z] = 0;
while (s[j] != ':') ++j;
s[j] = 0;
us[i] = mp[s];
++j;
int l;
while (j < z) {
l = j;
while (s[j] != ' ' && s[j] != '?' && s[j] != '!' && s[j] != '.' &&
s[j] != ',' && s[j])
++j;
if (l == j) {
++j;
continue;
}
s[j] = 0;
if (mp.find(s + l) != mp.end()) {
int x = mp[s + l];
if (x) no[i].push_back(x);
}
}
}
for (int i = 0; i < (int)m; ++i)
sort(no[i].begin(), no[i].end()),
no[i].resize(unique(no[i].begin(), no[i].end()) - no[i].begin());
for (int i = 0; i < (int)m; ++i)
if (!us[i]) go(i);
bool ok = true;
for (int i = 0; i < (int)m; ++i)
if (!us[i]) {
ok = false;
break;
}
if (!ok) {
printf("Impossible\n");
continue;
}
for (int i = 0; i < (int)m; ++i) {
int j = 0;
while (chat[i][j] != ':') ++j;
printf("%s%s\n", P[us[i]].c_str(), chat[i] + j);
}
}
}
| 14 |
Subsets and Splits