solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
bool is_possible(const std::string &s1, const std::string &s2) {
int n = s1.size();
for (int i = 0; i < n; ++i)
if (s1[i] < s2[i]) return false;
return true;
}
int main() {
std::string s1, s2;
std::cin >> s1 >> s2;
if (!is_possible(s1, s2)) {
std::cout << -1 << '\n';
return 0;
}
std::cout << s2 << '\n';
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class T>
inline void amin(T &x, const T &y) {
if (y < x) x = y;
}
template <class T>
inline void amax(T &x, const T &y) {
if (x < y) x = y;
}
template <class Iter>
void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp = 0; begin != end; ++begin) {
if (sp)
putchar(' ');
else
sp = true;
printf(fmt, *begin);
}
putchar('\n');
}
int N;
vector<int> G[100011];
int stk[100011];
int iter[100011];
int par[100011];
int sz[100011];
int dp[100011];
vector<int> que;
void dfs(int root) {
que.clear();
que.push_back(root);
stk[0] = stk[1] = root;
int last = 1;
while (last) {
int p = stk[last - 1];
int v = stk[last];
if (iter[v] == (int)G[v].size()) {
last--;
} else {
int w = G[v][iter[v]++];
if (w == p) continue;
que.push_back(w);
stk[++last] = w;
}
}
}
void MAIN() {
scanf("%d", &N);
for (int i = 0, i_len = (N - 1); i < i_len; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
G[x].push_back(y);
G[y].push_back(x);
}
que.reserve(N);
que.push_back(0);
for (int i = 0, i_len = (N); i < i_len; ++i) {
int v = que[i];
for (__typeof((G[v]).begin()) e = (G[v]).begin(), e_end = (G[v]).end();
e != e_end; ++e)
if (*e != par[v]) {
par[*e] = v;
que.push_back(*e);
}
}
long long ans = 0;
for (int i = 0, i_len = (N); i < i_len; ++i) {
int v = que[N - 1 - i];
sz[v] = 1;
for (__typeof((G[v]).begin()) e = (G[v]).begin(), e_end = (G[v]).end();
e != e_end; ++e)
if (*e != par[v]) {
sz[v] += sz[*e];
amax(dp[v], sz[*e]);
}
ans += min(sz[v], N - sz[v]);
}
for (int i = 0, i_len = (N); i < i_len; ++i)
if (dp[i] * 2 <= N && (N - sz[i]) * 2 <= N) {
dfs(i);
int shift = max(dp[i], N - sz[i]);
for (int k = 0, k_len = (N); k < k_len; ++k) {
iter[que[k]] = que[(k + shift) % N] + 1;
}
printf("%lld\n", ans * 2);
rprintf("%d", iter, iter + N);
return;
}
assert(false);
}
int main() {
int TC = 1;
for (int tc = 0, tc_len = (TC); tc < tc_len; ++tc) MAIN();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void readi(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readll(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline long long inc(int &x) { return ++x; }
inline long long inc(long long &x) { return ++x; }
inline long long inc(int &x, long long y) { return x += y; }
inline long long inc(long long &x, long long y) { return x += y; }
inline double inc(double &x, double y) { return x += y; }
inline long long dec(int &x) { return --x; }
inline long long dec(long long &x) { return --x; }
inline long long dec(int &x, long long y) { return x -= y; }
inline long long dec(long long &x, long long y) { return x -= y; }
inline double dec(double &x, double y) { return x -= y; }
inline long long mul(int &x) { return x = ((long long)x) * x; }
inline long long mul(long long &x) { return x = x * x; }
inline long long mul(int &x, long long y) { return x *= y; }
inline long long mul(long long &x, long long y) { return x *= y; }
inline double mul(double &x, double y) { return x *= y; }
inline long long divi(const int &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(const long long &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(int &x, long long y) { return x /= y; }
inline long long divi(long long &x, long long y) { return x /= y; }
inline double divi(double &x, double y) { return x /= y; }
inline long long mod(int &x, long long y) { return x %= y; }
inline long long mod(long long &x, long long y) { return x %= y; }
int n, m, len, i, j, cnt[2005], l, r, dp[2005][2005], p[2005], ans = 0x16161616,
x;
vector<long long> c[2005];
int main() {
ios_base::sync_with_stdio(false);
;
cin >> len >> n >> m;
while (n--) {
cin >> l >> r;
cnt[l]++;
cnt[r]--;
}
if ((1) <= ((len)))
for (((i)) = (1); ((i)) <= ((len)); ((i))++) cnt[i] += cnt[i - 1];
if ((1) <= ((m)))
for (((i)) = (1); ((i)) <= ((m)); ((i))++) {
cin >> x >> p[i];
c[x].push_back(i);
}
memset((dp), (0x16), (sizeof((dp))));
dp[0][0] = 0;
for (i = 0; i < len; i++) {
if ((1) <= ((m)))
for (((j)) = (1); ((j)) <= ((m)); ((j))++)
dp[i][0] = min(dp[i][0], dp[i][j]);
for (j = 0; j < c[i].size(); j++)
dp[i][c[i][j]] = min(dp[i][c[i][j]], dp[i][0]);
if ((1) <= ((m)))
for (((j)) = (1); ((j)) <= ((m)); ((j))++)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + p[j]);
if (cnt[i] <= 0) dp[i + 1][0] = min(dp[i + 1][0], dp[i][0]);
}
if ((0) <= (m))
for ((j) = (0); (j) <= (m); (j)++) ans = min(ans, dp[len][j]);
if (ans >= 0x16161616)
cout << -1;
else
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, r;
cin >> n >> r;
double theta = acos(-1) / n;
double x = (r * sin(theta)) / (1 - sin(theta));
cout << setprecision(10) << x << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
long long gcd(long long a, long long b) {
if (a == 0 || b == 0) return 0;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
long long powermod(long long x, long long y) {
long long res = 1;
x = x % 1000000007;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res;
}
long long mulmod(long long a, long long b) {
long long res = 0;
a %= 1000000007;
while (b) {
if (b & 1) res = (res + a) % 1000000007;
a = (2 * a) % 1000000007;
b >>= 1;
}
return res;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i += 6) {
if ((n % i == 0) || (n % (i + 2) == 0)) return false;
}
return true;
}
long double dist(long long x1, long long y1, long long x2, long long y2) {
return (long double)sqrt(
(long double)((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
}
long long squaredist(long long x1, long long y1, long long x2, long long y2) {
return ((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long nCr(long long n, long long r) {
if (r == 0) return 1;
return (n * nCr(n - 1, r - 1)) / r;
}
long long countDivisors(long long n) {
long long cnt = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt = cnt + 2;
}
}
return cnt;
}
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int l;
cin >> l;
string s;
cin >> s;
if (s.length() >= 11) {
if (s.find("8") != string::npos && s.length() - s.find("8") >= 11)
cout << "YES\n";
else {
cout << "NO\n";
}
} else {
cout << "NO\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long m;
long long num[21];
int inv[21];
int ans = 0;
const int mod = 1e9 + 7;
inline int por(int x, int y) {
long long res = 1;
while (y) {
if (y & 1) (res *= x) %= mod;
y >>= 1;
x = (long long)x * x % mod;
}
return res;
}
inline int C(long long x, int y) {
if (x < y) return 0;
x %= mod;
if (x < y) return 0;
long long res = 1;
for (int i = x - y + 1; i <= x; ++i) (res *= i) %= mod;
(res *= inv[y]) %= mod;
return res;
}
int main(void) {
scanf("%d%lld", &n, &m);
inv[0] = inv[1] = 1;
for (int i = 2; i <= 20; ++i) inv[i] = por(i, mod - 2);
for (int i = 2; i <= 20; ++i) inv[i] = (long long)inv[i] * inv[i - 1] % mod;
for (int i = 1; i <= n; ++i) scanf("%lld", num + i);
for (int i = 0; i < (1 << n); ++i) {
long long k = n + m - 1, cnt = 0;
for (int j = 0; j < n; ++j)
if (i >> j & 1) k -= num[j + 1] + 1, ++cnt;
if (cnt & 1)
(ans -= C(k, n - 1)) %= mod;
else
(ans += C(k, n - 1)) %= mod;
}
ans = (ans + mod) % mod;
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
inline int read() {
register int x;
register char c(getchar());
register bool k;
while ((c < '0' || c > '9') && c ^ '-')
if ((c = getchar()) == EOF) exit(0);
if (c ^ '-')
x = c & 15, k = 1;
else
x = 0, k = 0;
while (c = getchar(), c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c & 15);
return k ? x : -x;
}
const int MAX_NUM = 1e6 + 5;
bool is_prime[MAX_NUM];
int prime[MAX_NUM];
void sieve() {
fill(is_prime, is_prime + MAX_NUM, 1);
is_prime[0] = is_prime[1] = 0;
prime[0] = 0;
for (long long i = 2; i < MAX_NUM; i++) {
if (is_prime[i]) prime[++prime[0]] = i;
for (int j = 1; j <= prime[0] && i * prime[j] < MAX_NUM; j++) {
is_prime[i * prime[j]] = 0;
if (i % prime[j] == 0) break;
}
}
}
int table[MAX_NUM];
void init() {
sieve();
table[1] = 1;
for (int i = 2; i < MAX_NUM; i++) {
table[i] = table[i - 1];
if (is_prime[i]) table[i]++;
int k = sqrt(i);
if (k * k == i && is_prime[k]) table[i]--;
}
}
int main() {
init();
int t = read();
while (t--) {
int n = read();
cout << table[n] << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int na, nb, k, m, i, j, ou, arr[100004], brr[100005];
int main(void) {
cin >> na >> nb >> k >> m;
for (i = 0; i < na; i++) {
cin >> arr[i];
}
for (i = 0; i < nb; i++) {
cin >> brr[i];
}
if (m > nb) {
cout << "NO" << endl;
return 0;
}
nb = nb - m;
for (i = 0; i <= nb; i++) {
if (brr[i] > arr[k - 1]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int MOD1 = 998244353;
const long long int N = 2e5 + 5;
const long long int INF = 1000111000111000111LL;
const long double EPS = 1e-12;
const long double PI = 3.141592653589793116;
string s, t;
vector<long long int> v;
int32_t main() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
cin >> s >> t;
long long int c1 = 0, c2 = 0;
for (long long int i = 0; i < n; i++) {
if (s[i] == '1' && t[i] == '0') {
c1++;
v.push_back(1);
}
if (s[i] == '0' && t[i] == '1') {
c2++;
v.push_back(2);
}
}
if (s == t) {
return cout << 0, 0;
}
if (c1 != c2) return cout << -1, 0;
if (c1 == 0) {
return cout << 0, 0;
}
long long int ans = 0;
set<long long int> s1, s2;
for (long long int i = (0); i < ((long long int)((v).size())); i++) {
if (v[i] == 1)
s1.insert(i);
else
s2.insert(i);
}
long long int Tc = c1;
while (Tc--) {
long long int init = *s1.begin();
vector<long long int> v1, v2;
for (auto it = s1.begin(); it != s1.end();) {
auto nt = s2.upper_bound(*it);
if (nt == s2.end()) {
if (*s2.begin() > *s1.begin()) break;
v2.push_back(*s2.begin());
v1.push_back(*it);
break;
}
v2.push_back(*nt);
v1.push_back(*it);
it = s1.upper_bound(*nt);
}
if ((long long int)((v1).size())) {
ans++;
} else {
break;
}
for (auto it : v1) s1.erase(it);
for (auto it : v2) s2.erase(it);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][102][102][102];
int choose[102][102];
int main() {
int N, M, K;
scanf("%d%d%d", &N, &M, &K);
choose[0][0] = 1;
for (int n = (1); n <= (N); ++n) {
choose[n][0] = 1;
for (int k = (1); k <= (n); ++k)
choose[n][k] = min(choose[n - 1][k - 1] + choose[n - 1][k], 6000);
}
memset(dp, 0, sizeof(dp));
int next = 0;
int prev = 1;
int ans = 0;
int new_n, new_s, new_k;
for (int m = (2); m <= (M); ++m) {
memset(dp[next], 0, sizeof(dp[next][0][0][0]) * 102 * 102 * 102);
if (m == 2) {
for (int n = (2); n <= (N); ++n)
if ((n % 2) == 0) dp[next][n][n / 2][1] = 1;
} else {
for (int n = (0); n <= (N); ++n) {
for (int s = (0); s <= (n); ++s) {
for (int k = (0); k <= (K); ++k) {
if (!dp[prev][n][s][k]) continue;
for (int x = (1); x <= (N); ++x) {
new_n = n + x + x;
if (new_n > N) break;
new_s = x;
new_k = k * choose[s + x - 1][s];
if (new_k > K) break;
dp[next][new_n][new_s][new_k] =
(dp[next][new_n][new_s][new_k] + dp[prev][n][s][k]) %
1000000007;
}
}
}
}
}
for (int n = (1); n <= (N); ++n)
for (int s = (0); s <= (n); ++s)
for (int k = (1); k <= (K); ++k) {
ans = (ans + 1ll * (M - m + 1) * dp[next][n][s][k]) % 1000000007;
}
swap(next, prev);
}
printf("%d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const string tp[4] = {"aaaa", "aabb", "abab", "abba"};
int n;
int m, k;
string w[10000];
int main() {
cin >> n >> k;
n *= 4;
int bad = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
w[i] = "";
int l = 0;
while (l < k && s.size()) {
char c = s[s.size() - 1];
w[i] += c;
s.erase(s.size() - 1);
if (c == 'a' || c == 'i' || c == 'e' || c == 'o' || c == 'u') {
l++;
}
}
if (l < k) {
bad = 1;
}
}
if (!bad) {
for (int t = 0; t < 4; t++) {
int ok2 = 1;
for (int i = 0; i < n; i += 4) {
int ok = 1;
for (int p = 0; p < 4 && ok; p++) {
for (int q = p + 1; q < 4 && ok; q++) {
if (tp[t][p] == tp[t][q] && w[i + p] != w[i + q]) {
ok = 0;
}
}
}
if (!ok) {
ok2 = 0;
break;
}
}
if (ok2) {
cout << tp[t] << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long inf = 1e18;
long long mx = -1;
long long mn = 1e18;
long long calpow(long long a, long long b, long long md) {
long long mul = 1;
while (b > 0) {
if (b & 1) {
mul = ((a % md) * (mul % md)) % md;
b--;
} else {
a = ((a % md) * (a % md)) % md;
b /= 2;
}
}
return mul;
}
void solve() {
long long i, j, n, t, q, a, b, m, k, ct = 0, sum = 0, flag = 0;
string s;
cin >> s;
cin >> n;
while (n--) {
string s1;
cin >> s1;
if (s1.size() != s.size()) continue;
j = s.size();
ct = 0;
for (long long i = (0); i < (j); i++) {
if (s[i] == s1[i])
ct++;
else {
if (s[i] == '0' || s[i] == 'o' || s[i] == 'O') {
if (s1[i] == '0' || s1[i] == 'o' || s1[i] == 'O') ct++;
} else if (s[i] == '1' || s[i] == 'I' || s[i] == 'i' || s[i] == 'L' ||
s[i] == 'l') {
if (s1[i] == '1' || s1[i] == 'I' || s1[i] == 'i' || s1[i] == 'L' ||
s1[i] == 'l')
ct++;
} else {
m = s[i];
k = s1[i];
char c = s[i], d = s1[i];
if (m >= 65 && m < 97) {
m += 32;
c = m;
}
if (k >= 65 && k < 97) {
k += 32;
d = k;
}
if (c == d) ct++;
}
}
}
if (ct == j) {
cout << "No";
return;
}
}
cout << "Yes";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
cerr << endl << clock() * 1000.0 / CLOCKS_PER_SEC << 'm' << 's';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<int> a(n, -1), u(n, 0);
int px;
cin >> px;
--px;
for (int i = 1; i < m; ++i) {
int x;
cin >> x;
--x;
int dx = (n - 1 + x - px) % n;
if (a[px] != -1 && a[px] != dx) {
cout << -1 << endl;
return;
}
if (a[px] == -1 && u[dx] == 1) {
cout << -1 << endl;
return;
}
a[px] = dx;
u[dx] = 1;
px = x;
}
for (int i = 0; i < n; ++i) {
if (a[i] == -1) {
for (int j = 0; j < n; ++j) {
if (u[j] == 0) {
a[i] = j;
u[j] = 1;
break;
}
}
}
cout << a[i] + 1 << " ";
}
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, tim = 0;
long long strtim[100005], endtim[100005], level[100005];
long long par[20 + 5][100005];
vector<long long> gr[100005];
void dfs(long long x, long long parent, long long lvl) {
strtim[x] = ++tim;
level[x] = lvl;
par[0][x] = parent;
for (auto it : gr[x])
if (it != parent) dfs(it, x, lvl + 1);
endtim[x] = tim;
}
void precompute() {
for (long long j = 1; j < 20; j++)
for (long long i = 1; i <= n; i++) par[j][i] = par[j - 1][par[j - 1][i]];
}
long long kth_ancestor(long long u, long long k) {
for (long long j = 20; j >= 0; j--)
if (k & (1LL << j)) u = par[j][u];
return u;
}
long long LCA(long long u, long long v) {
if (level[u] < level[v]) swap(u, v);
long long diff = level[u] - level[v];
for (long long i = 20 - 1; i >= 0; i--) {
if ((1 << i) & diff) {
u = par[i][u];
}
}
if (u == v) return u;
for (long long i = 20 - 1; i >= 0; i--) {
if (par[i][u] && par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
}
return par[0][u];
}
long long dist(long long u, long long v) {
return level[u] + level[v] - 2 * level[LCA(u, v)];
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (long long i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
gr[x].push_back(y);
gr[y].push_back(x);
}
dfs(1, 0, 1);
precompute();
long long q;
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long flag = 0;
long long dist_a_b = dist(a, b);
long long dist_a_x_y_b = dist(a, x) + 1 + dist(y, b);
long long dist_a_y_x_b = dist(a, y) + 1 + dist(x, b);
if ((k - dist_a_b) >= 0 and (k - dist_a_b) % 2 == 0) flag = 1;
if ((k - dist_a_x_y_b) >= 0 and (k - dist_a_x_y_b) % 2 == 0) flag = 1;
if ((k - dist_a_y_x_b) >= 0 and (k - dist_a_y_x_b) % 2 == 0) flag = 1;
if (flag == 1)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll t;
cin>>t;
while (t--){
ll r,b,d;
cin>>r>>b>>d;
ll low,high;
low=min(r,b);
high=max(r,b);
if (low*(d+1)>=high)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x[2];
for (int i = 0; i < 2; i++) {
cin >> x[i];
}
int l = min(x[1], x[0]);
if (l % 2 == 0)
cout << "Malvika";
else
cout << "Akshat";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m, a[N], b, d[N];
int c, u, ans[N];
bool vis[N];
map<int, set<int> > MP;
int main() {
while (~scanf("%d %d", &n, &m)) {
MP.clear();
for (int i = 1; i <= n; i++) {
scanf("%d", &b);
MP[b].insert(i);
ans[i] = 0;
}
for (int i = 1; i <= m; i++) {
scanf("%d", a + i);
vis[i] = 0;
d[i] = 0;
}
c = u = 0;
for (int i = 0; i <= 30; i++) {
for (int j = 1; j <= m; j++) {
if (vis[j]) continue;
if (MP.count(a[j])) {
c++;
u += i;
b = *MP[a[j]].begin();
MP[a[j]].erase(b);
if (MP[a[j]].empty()) {
MP.erase(a[j]);
}
d[j] = i;
ans[b] = j;
vis[j] = 1;
}
a[j] = a[j] / 2 + a[j] % 2;
}
}
printf("%d %d\n", c, u);
for (int i = 1; i <= m; i++) {
printf("%d%c", d[i], i == m ? '\n' : ' ');
}
for (int i = 1; i <= n; i++) {
printf("%d%c", ans[i], i == n ? '\n' : ' ');
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int LG = 20;
int n, m;
long long a[maxn];
int visited[maxn];
long long weight[maxn];
vector<pair<int, int>> g[maxn];
vector<int> odd, even;
long long sumodd, sumeven;
int depth[maxn];
int parEdge[maxn];
int jump[maxn][LG];
vector<int> oddcycle;
pair<int, int> edges[maxn];
void dfs_prepare(int v, int color) {
if (!v) {
fill(visited, visited + maxn, -1);
}
visited[v] = color;
if (color) {
sumodd += a[v];
odd.emplace_back(v);
} else {
sumeven += a[v];
even.emplace_back(v);
}
for (auto &e : g[v]) {
if (visited[e.first] != -1) {
if (visited[e.first] != visited[v] || oddcycle.size() > 0) continue;
oddcycle.emplace_back(color);
oddcycle.emplace_back(e.second);
for (int x = v; x != e.first; x = jump[x][0]) {
oddcycle.emplace_back(parEdge[x]);
}
continue;
}
int s = e.first;
parEdge[s] = e.second;
jump[s][0] = v;
depth[s] = depth[v] + 1;
for (int j = 1; j < LG; ++j) jump[s][j] = jump[jump[s][j - 1]][j - 1];
dfs_prepare(s, 1 - color);
}
}
int LCA(int u, int v) {
if (depth[u] < depth[v]) swap(u, v);
for (int j = LG - 1; j >= 0; --j) {
if (depth[jump[u][j]] >= depth[v]) u = jump[u][j];
}
if (u == v) return v;
for (int j = LG - 1; j >= 0; --j) {
if (jump[u][j] != jump[v][j]) {
u = jump[u][j];
v = jump[v][j];
}
}
return jump[v][0];
}
long long fs[maxn];
int same(int x, int y) { return x / abs(x) == y / abs(y); }
void upd(int x, int w, int sign = 1) {
if (a[x] < 0) {
a[x] += w;
fs[x] += sign * w;
} else {
a[x] -= w;
fs[x] -= sign * w;
}
}
void normalize(vector<int> ids) {
vector<int> stac;
for (int x : ids) {
if (a[x] == 0) continue;
if (stac.empty() || same(a[x], a[stac.back()])) {
stac.push_back(x);
} else {
while (abs(a[x]) > 0) {
if (stac.empty()) break;
int y = stac.back();
int w = min(abs(a[x]), abs(a[y]));
upd(x, w);
upd(y, w);
if (a[y] == 0) stac.pop_back();
}
if (abs(a[x]) > 0) stac.push_back(x);
}
}
}
void dfs_solve(int v) {
if (!v) {
fill(visited, visited + maxn, -1);
}
visited[v] = 1;
for (auto &e : g[v]) {
int s = e.first, w = e.second;
if (visited[s] != -1) continue;
dfs_solve(s);
weight[w] += fs[s];
fs[v] -= fs[s];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
g[--u].emplace_back(--v, i);
g[v].emplace_back(u, i);
weight[i]++;
a[v]++;
a[u]++;
edges[i] = make_pair(u, v);
}
dfs_prepare(0, 0);
if (sumodd != sumeven) {
if (oddcycle.empty()) {
cout << "NO" << endl;
return 0;
}
long long need = sumodd - sumeven;
need /= 2;
int sign = 1;
if (oddcycle.front() == 0) sign *= -1;
for (int i = 1; i < oddcycle.size(); ++i) {
auto [u, v] = edges[oddcycle[i]];
a[v] -= sign * need;
a[u] -= sign * need;
weight[oddcycle[i]] -= sign * need;
sign *= -1;
}
}
normalize(even);
normalize(odd);
for (int i = 0, j = 0;;) {
if (i == even.size() || j == odd.size()) break;
if (a[even[i]] == 0) {
++i;
continue;
}
if (a[odd[j]] == 0) {
++j;
continue;
}
int x = even[i], y = odd[j];
int w = min(abs(a[x]), abs(a[y]));
upd(x, w);
upd(y, w);
}
dfs_solve(0);
cout << "YES\n";
for (int i = 0; i < m; ++i) cout << -weight[i] << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int t;
std::cin >> t;
while (t--) {
int n, k;
std::cin >> n >> k;
std::vector<int> a(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
}
std::vector<bool> is_peak(n);
for (int i = 1; i + 1 < n; i++) {
is_peak[i] = a[i] > a[i - 1] && a[i] > a[i + 1];
}
int left_border = 1, best_peak_cnt = 0, cur_peak_cnt = 0;
for (int i = 0; i + 1 < k; i++) {
if (is_peak[i]) {
best_peak_cnt++;
cur_peak_cnt++;
}
}
for (int i = k; i < n; i++) {
if (is_peak[i - k + 1]) {
cur_peak_cnt--;
}
if (is_peak[i - 1]) {
cur_peak_cnt++;
}
if (cur_peak_cnt > best_peak_cnt) {
best_peak_cnt = cur_peak_cnt;
left_border = i - k + 1 + 1;
}
}
std::cout << (best_peak_cnt + 1) << " " << left_border << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
const int maxn = 200005;
int a[maxn], b[maxn], pos[maxn], vis[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], pos[a[i]] = i, vis[i] = 0;
for (int i = 1; i <= k; i++) cin >> b[i];
reverse(b + 1, b + 1 + k);
long long ans = 1;
for (int i = 1; i <= k; i++) {
long long ans1 = 2;
if (pos[b[i]] == 1 || vis[pos[b[i]] - 1]) ans1--;
if (pos[b[i]] == n || vis[pos[b[i]] + 1]) ans1--;
vis[pos[b[i]]] = 1;
ans = ans * ans1 % p;
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
string s;
cin >> s;
long long int sum = 0, x = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') sum = max(sum + a[i], x);
x += a[i];
}
cout << sum << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct nod {
int d, f, t, c;
};
long long ans1[1000005], ans2[1000005];
int cmp(nod x, nod y) { return x.d < y.d; }
nod arr[100005];
int n, m, k;
int vis[100005];
long long sum, num;
int main() {
while (cin >> n >> m >> k) {
for (int i = 1; i <= m; i++)
scanf("%d %d %d %d", &arr[i].d, &arr[i].f, &arr[i].t, &arr[i].c);
sort(arr + 1, arr + m + 1, cmp);
memset(vis, 0, sizeof(vis));
num = 0;
sum = 0;
int now = 1;
for (int day = 1; day <= 1000000; day++) {
for (now; now <= m && arr[now].d <= day; now++) {
if (arr[now].f == 0) continue;
if (vis[arr[now].f] != 0 && vis[arr[now].f] < arr[now].c) continue;
if (vis[arr[now].f] == 0) num++;
sum = sum - vis[arr[now].f] + arr[now].c;
vis[arr[now].f] = arr[now].c;
}
if (num != n)
ans1[day] = 9999999999999999LL;
else
ans1[day] = sum;
}
long long best = 9999999999999999LL;
num = 0;
sum = 0;
now = m;
memset(vis, 0, sizeof(vis));
for (int day = 1000000; day - k - 1 >= 1; day--) {
for (now; now >= 1 && arr[now].d >= day; now--) {
if (arr[now].t == 0) continue;
if (vis[arr[now].t] != 0 && vis[arr[now].t] < arr[now].c) continue;
if (vis[arr[now].t] == 0) num++;
sum = sum - vis[arr[now].t] + arr[now].c;
vis[arr[now].t] = arr[now].c;
}
if (num == n) best = min(best, sum + ans1[day - k - 1]);
}
if (best == 9999999999999999LL) best = -1;
cout << best << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, b, sum = 0;
cin >> n >> b;
vector<double> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
sum += v[i];
}
sum += b;
sum /= n;
bool yes = true;
for (int i = 0; yes && i < n; i++) {
v[i] = sum - v[i];
if (v[i] < 0) {
yes = false;
}
}
if (yes) {
cout.precision(6);
for (int i = 0; i < n; i++) {
cout << fixed << showpoint << v[i] << endl;
}
} else {
cout << -1;
}
}
| 1 |
/// Black lives matter
#include <bits/stdc++.h>
/// 500 485 462 A4
using namespace std;
typedef long long int ll;
typedef complex<double> point;
typedef long double ld;
#define pb push_back
#define pii pair < ll , ll >
#define F first
#define S second
//#define endl '\n'
#define int long long
#define sync ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#define kill(x) return cout<<x<<'\n', 0;
const int N=2e5+100;
ll mx[N];
ll mn[N];
ll f[N];
vector <int> a,b;
vector <pii> baz;
set <pii> s,t;
void del(ll x){
s.erase({-mx[x],x});
t.erase({mn[x],x});
}
int32_t main(){
sync;
ll n;
cin >> n;
for (int i=1;i<=n;i++){
cin >> mx[i] >> mn[i];
if (mx[i]<mn[i]){
f[i]=1;
swap(mx[i],mn[i]);
}
}
for (int i=1;i<=n;i++){
s.insert({-mx[i],i});
t.insert({mn[i],i});
}
while(a.size()+b.size()!=n){
pii p=*s.begin();
baz.pb({a.size()+1,n-b.size()});
del(p.S);
a.pb(p.S);
// cout << " a1 " << p.S << endl;
while(t.size()){
ll p1=0;
pii u=*t.begin();
if (mn[a.back()]>mn[u.S]){
del(u.S);
p1=1;
b.pb(u.S);
// cout << " B " << u.S << endl;
}
if (s.size()==0 || b.size()==0) break;
u=*s.begin();
if (mx[u.S]>mx[b.back()]){
p1=1;
del(u.S);
a.pb(u.S);
// cout << " A " << u.S << endl;
}
if (p1==0) break;
}
}
vector <int> c;
/// check -1
for (int i=1;i<a.size();i++){
if (mx[a[i]]>mx[a[i-1]]) kill(-1);
if (mn[a[i]]<mn[a[i-1]]) kill(-1);
}
for (int i=1;i<b.size();i++){
if (mx[b[i]]>mx[b[i-1]]) kill(-1);
if (mn[b[i]]<mn[b[i-1]]) kill(-1);
}
if (a.size() && b.size()){
if (mx[a.back()]<mn[b.back()]) kill(-1);
if (mn[a.back()]>mx[b.back()]) kill(-1);
}
c.pb(0);
for (auto u : a){
if (f[u]==0) c.pb(1);
else c.pb(0);
}
reverse(b.begin(),b.end());
for (auto u : b){
if (f[u]) c.pb(1);
else c.pb(0);
}
ll ans=0;
reverse(baz.begin(),baz.end());
ll t1=0,t0=0;
for (int i=baz[0].F;i<=baz[0].S;i++){
if (c[i]) t1++;
else t0++;
}
ans+=max(t0,t1);
for (int i=1;i<baz.size();i++){
ll l=baz[i].F,r=baz[i].S,L=baz[i-1].F,R=baz[i-1].S;
ll t0=0,t1=0;
for (int j=l;j<L;j++){
if (c[j]==1) t1++;
else t0++;
}
for (int j=R+1;j<=r;j++){
if (c[j]==1) t1++;
else t0++;
}
ans+=max(t0,t1);
}
kill(n-ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int T, N;
map<int, int> mp;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> T >> N;
for (int i = 1; i <= N; i++) {
int n;
cin >> n;
mp[n]++;
}
int ans = T;
int tot = 0;
for (int n = T - 1; n > 1; n--) {
while (mp[n + 1] && tot + n + 1 <= T) {
tot += n + 1;
mp[n + 1]--;
}
mp.erase(n + 1);
if (n + tot >= T) {
continue;
}
int temp = tot + n;
int lst = T;
while (temp < T) {
auto ptr = mp.upper_bound(min(lst - 1, T - temp));
if (ptr == mp.begin()) {
break;
}
ptr--;
lst = (*ptr).first;
if (temp + 1LL * (*ptr).first * (*ptr).second <= T) {
temp += 1LL * (*ptr).first * (*ptr).second;
} else {
temp += (T - temp) / (*ptr).first * (*ptr).first;
}
}
if (temp != T) {
ans = n;
}
}
cout << (ans == T ? "Greed is good" : to_string(ans)) << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
namespace {
const int kMaxN = 100000, kMaxM = 100000;
int n, m, f[kMaxN];
bool vis[2][kMaxN];
struct Graph {
int cnt, begin[kMaxN], end[kMaxM], next[kMaxM];
Graph() : cnt(0) { memset(begin, -1, sizeof(begin)); }
void add_edge(int u, int v) {
next[cnt] = begin[u];
begin[u] = cnt;
end[cnt++] = v;
}
} g[2];
void Dfs(int gr, int u) {
vis[gr][u] = true;
if (gr == 1 && f[u] == 1) return;
for (int now = g[gr].begin[u], v; now != -1; now = g[gr].next[now])
if (!vis[gr][v = g[gr].end[now]]) Dfs(gr, v);
}
void Solve(FILE *fin, FILE *fout) {
fscanf(fin, "%d%d", &n, &m);
for (int i = 0; i < n; ++i) fscanf(fin, "%d", &f[i]);
for (int u, v; m--;) {
fscanf(fin, "%d%d", &u, &v);
--u, --v;
g[0].add_edge(u, v);
g[1].add_edge(v, u);
}
for (int i = 0; i < n; ++i) {
if (f[i] == 1 && !vis[0][i]) Dfs(0, i);
if (f[i] == 2 && !vis[1][i]) Dfs(1, i);
}
for (int i = 0; i < n; ++i) fprintf(fout, "%d\n", vis[0][i] && vis[1][i]);
}
} // namespace
int main() {
::Solve(stdin, stdout);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct line {
int x1, y1, x2, y2;
};
set<int> mst;
vector<line> sgm1, sgm2, isg1, isg2;
vector<pair<int, int>> pts1, pts2, lst;
inline bool cmp1(line l1, line l2) {
return (l1.x1 == l2.x2) ? (l1.y1 < l2.y1) : (l1.x1 < l2.x2);
}
inline bool cmp2(line l1, line l2) {
return (l1.y1 == l2.y2) ? (l1.x1 < l2.x1) : (l1.y1 < l2.y2);
}
inline bool solve(int val) {
val *= 2;
isg1.clear();
for (pair<int, int> &pt : pts1) {
int x = pt.first, y = pt.second;
isg1.push_back({x + y, x - y - val, x + y, x - y + val});
}
isg2.clear();
for (pair<int, int> &pt : pts2) {
int x = pt.first, y = pt.second;
isg2.push_back({x + y - val, x - y, x + y + val, x - y});
}
sort(isg1.begin(), isg1.end(), cmp1);
sort(isg2.begin(), isg2.end(), cmp2);
sgm1.clear();
for (line &ln : isg1) {
if (sgm1.empty() || sgm1.back().x1 < ln.x1)
sgm1.push_back(ln);
else if (sgm1.back().x1 == ln.x1 && sgm1.back().y2 < ln.y1)
sgm1.push_back(ln);
else
sgm1.back().y2 = ln.y2;
}
sgm2.clear();
for (line &ln : isg2) {
if (sgm2.empty() || sgm2.back().y1 < ln.y1)
sgm2.push_back(ln);
else if (sgm2.back().y1 == ln.y1 && sgm2.back().x2 < ln.x1)
sgm2.push_back(ln);
else
sgm2.back().x2 = ln.x2;
}
for (int i = 0; i < sgm1.size(); i++) {
line ln1 = sgm1[i];
mst.clear();
lst.clear();
for (line &ln2 : sgm2) {
if (ln2.y1 < ln1.y1 || ln2.y1 > ln1.y2) continue;
if (ln1.x1 < ln2.x1 || ln1.x1 > ln2.x2) continue;
mst.insert(ln2.y2);
lst.push_back(make_pair(ln2.x2, ln2.y2));
}
mst.insert(1e9);
sort(lst.begin(), lst.end(), greater<pair<int, int>>());
for (int j = i + 1; j < sgm1.size(); j++) {
line ln2 = sgm1[j];
for (; lst.empty() == false && lst.back().first < ln2.x2; lst.pop_back())
mst.erase(mst.find(lst.back().second));
if (ln1.x1 == ln2.x1) continue;
if (lst.size() <= 1) break;
set<int>::iterator it;
it = mst.lower_bound(ln2.y1);
if (*it <= ln2.y2 && *next(it) <= ln2.y2) return true;
}
}
return false;
}
int main(void) {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
pts1.resize(n);
for (pair<int, int> &pt : pts1) cin >> pt.first >> pt.second;
pts2.resize(m);
for (pair<int, int> &pt : pts2) cin >> pt.first >> pt.second;
int pos = 1;
for (int le = 1, ri = 1e7; le <= ri;) {
int md = (le + ri) / 2;
if (solve(md) == true)
ri = md - 1;
else
pos = le = md + 1;
}
if (pos >= 1e7)
cout << "Poor Sereja!" << endl;
else
cout << pos << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000009;
const int N = 4000 + 11;
int n, w, b, inv[N][2], mul[N];
long long ans;
inline int P(int n) { return mul[n]; }
inline int C(int n, int m) {
return mul[n] * (long long)inv[m][1] % mod * inv[n - m][1] % mod;
}
int main(int argc, char **argv) {
inv[0][1] = mul[0] = 1;
inv[1][0] = inv[1][1] = mul[1] = 1;
for (int i = 2; i < N; ++i)
inv[i][0] = -inv[mod % i][0] * (long long)(mod / i) % mod,
inv[i][1] = inv[i - 1][1] * (long long)inv[i][0] % mod,
mul[i] = mul[i - 1] * (long long)i % mod;
scanf("%d%d%d", &n, &w, &b);
for (int i = 1; i <= w && i <= n; ++i)
for (int j = max(1, n - w); i + j < n && j <= b; ++j)
ans = (ans + C(b - 1, j - 1) * (long long)C(w - 1, n - j - 1)) % mod;
ans = ans * P(w) % mod * P(b) % mod;
printf("%d\n", (ans + mod) % mod);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10010;
int pos[N];
int main() {
int n;
cin >> n;
string s;
cin >> s;
s = " " + s;
string b = s;
int cnt = 0;
int i;
int s1 = 0, s2 = 0;
for (i = 1; i <= s.size(); i++) {
if (s[i] == 'W') s1++;
}
if (s1 == n || s1 == 0) {
cout << 0 << endl;
return 0;
}
for (i = 2; i <= s.size(); i++) {
if (s[i] == 'W' && s[i - 1] == 'W') {
pos[cnt++] = i - 1;
s[i] = s[i - 1] = 'B';
}
}
int sum = 0;
for (i = 1; i <= s.size(); i++) {
if (s[i] == 'W') sum++;
}
if (sum % 2) {
s = b;
int cnt = 0;
int i;
for (i = 2; i <= s.size(); i++) {
if (s[i] == 'B' && s[i - 1] == 'B') {
pos[cnt++] = i - 1;
s[i] = s[i - 1] = 'W';
}
}
int sum = 0;
for (i = 1; i <= s.size(); i++) {
if (s[i] == 'B') sum++;
}
if (sum % 2) {
cout << -1 << endl;
} else {
for (i = 1; i < s.size(); i++) {
if (s[i] == 'B') {
pos[cnt++] = i;
s[i] = 'W';
s[i + 1] = s[i + 1] == 'W' ? 'B' : 'W';
}
}
if (cnt > 3 * n) {
cout << -1 << endl;
return 0;
}
cout << cnt << endl;
for (i = 0; i < cnt - 1; i++) {
cout << pos[i] << " ";
}
cout << pos[i] << endl;
}
return 0;
} else {
for (i = 1; i < s.size(); i++) {
if (s[i] == 'W') {
pos[cnt++] = i;
s[i] = 'B';
s[i + 1] = s[i + 1] == 'B' ? 'W' : 'B';
}
}
if (cnt > 3 * n) {
cout << -1 << endl;
return 0;
}
cout << cnt << endl;
for (i = 0; i < cnt - 1; i++) {
cout << pos[i] << " ";
}
cout << pos[i] << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
unordered_map<char, int> m;
for (int i = 0; i < n; i++) {
m[s[i]]++;
}
string ans = "";
for (auto x : m) {
for (int i = 0; i < x.second; i++) {
ans += x.first;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n;
const long long MAXN = 2e5 + 69;
long long a[MAXN];
long long L[MAXN];
long long R[MAXN];
signed main() {
cin >> n;
long long maxx = 0;
for (long long i = 1; i <= n; i++) cin >> a[i], maxx = max(maxx, a[i]);
for (long long i = 1; i <= n; i++)
for (L[i] = i - 1; L[i] > 0 && a[L[i]] <= a[i];) L[i] = L[L[i]];
for (long long i = n; i >= 1; i--)
for (R[i] = i + 1; R[i] <= n && a[R[i]] <= a[i];) R[i] = R[R[i]];
long long ok = 1;
for (long long i = 1; i <= n; i++) {
if ((R[i] - L[i] - 1) % 2 != 0 && a[i] != maxx) ok = 0;
}
if (ok)
cout << "YES";
else
cout << "NO";
}
| 7 |
#include <bits/stdc++.h>
struct EDGE {
int y, v;
EDGE(int y, int v) : y(y), v(v) {}
};
const int MAX_N = 20;
int n, k, t;
std::vector<EDGE> e[MAX_N + 1];
int choosen[MAX_N + 1];
int mid;
int cnt;
void dfs(int x, int now_cost_sum) {
if (now_cost_sum > mid) return;
if (cnt >= t) return;
if (x > n) {
cnt++;
return;
}
dfs(x + 1, now_cost_sum);
for (auto [y, v] : e[x]) {
if (!choosen[y]) {
choosen[y] = 1;
dfs(x + 1, now_cost_sum + v);
choosen[y] = 0;
}
}
}
int main() {
scanf("%d%d%d", &n, &k, &t);
for (int i = 1; i <= k; i++) {
int h, w, r;
scanf("%d%d%d", &h, &w, &r);
e[h].push_back(EDGE(w, r));
}
int low = 0, high = 1000 * n;
while (low < high) {
mid = (low + high) >> 1;
cnt = 0;
dfs(1, 0);
if (cnt >= t)
high = mid;
else
low = mid + 1;
}
printf("%d\n", low);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 5;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const long double eps8 = 1e-8;
const long double eps9 = 1e-9;
const long double pi = acos(-1);
struct pnt {
long double x, y;
pnt() {}
pnt(long double x, long double y) : x(x), y(y) {}
pnt operator-(pnt A) { return pnt(x - A.x, y - A.y); }
long double operator*(pnt A) { return x * A.y - y * A.x; }
long double operator%(pnt A) { return x * A.x + y * A.y; }
void read() { cin >> x >> y; }
void Epr() {}
};
pnt p[maxn];
bool a[maxn][maxn];
long long dp[maxn][maxn];
int n;
int next(int x) { return (x + 1) % n; }
bool boundBox(long double a, long double b, long double c, long double d) {
if (a > b) swap(a, b);
if (c > d) swap(c, d);
return max(a, c) <= min(b, d);
}
bool intersec(pnt A, pnt B, pnt C, pnt D) {
return boundBox(A.x, B.x, C.x, D.x) && boundBox(A.y, B.y, C.y, D.y) &&
((C - A) * (B - A)) * ((D - A) * (B - A)) <= eps8 &&
((A - D) * (C - D)) * ((B - D) * (C - D)) <= eps8;
}
bool check(pnt A, pnt B, pnt C, pnt D) {
pnt v, u, t;
v = A - B;
u = C - B;
t = D - B;
if ((v * u) * (v * t) < 0) {
return v * u > 0;
}
if ((v * u) == 0) {
return t * v > 0;
}
if ((v * t) == 0) {
return v * u > 0;
}
return u * t > 0;
}
int main() {
int v;
scanf("%d", &n);
for (int i = 0; i < n; i++) p[i].read();
long double ang = 0;
for (int i = 0; i < n; i++) {
pnt v, u;
v = p[(i + 1) % n] - p[i];
u = p[(i + 2) % n] - p[(i + 1) % n];
ang += atan2(v * u, v % u);
}
if (ang < 0) {
reverse(p, p + n);
}
for (int i = 0; i < n; i++)
for (int j = i + 2; j < n; j++) {
if (i == 0 && j == n - 1) continue;
bool flag = 1;
for (int k = 0; k < n; k++) {
if (i == k || i == (k + 1) % n || j == k || j == (k + 1) % n) continue;
flag &= !intersec(p[i], p[j], p[k], p[(k + 1) % n]);
}
flag &= check(p[(i - 1 + n) % n], p[i], p[(i + 1) % n], p[j]);
flag &= check(p[(j - 1 + n) % n], p[j], p[(j + 1) % n], p[i]);
a[i][j] = a[j][i] = flag;
}
for (int i = 0; i < n; i++) a[i][(i + 1) % n] = a[(i + 1) % n][i] = 1;
for (int i = 0; i < n; i++) dp[i][1] = 1;
for (int i = 0; i < n; i++)
if (a[i][(i + 2) % n]) dp[i][2] = 1;
for (int len = 3; len < n; len++) {
for (int l = 0; l < n; l++) {
int r = (l + len) % n;
if (a[l][r] == 0) continue;
if (a[next(l)][r]) dp[l][len] = (dp[l][len] + dp[next(l)][len - 1]) % MOD;
for (int i = l + 2; i < l + len; i++) {
v = i % n;
if (a[l][v] == 0) continue;
dp[l][len] = (dp[l][len] + dp[l][i - l] * dp[i][l + len - i]) % MOD;
}
}
}
cout << dp[0][n - 1] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
char s[maxn];
struct Node {
int num;
char c;
} node[maxn], tmp[maxn], temp[maxn];
int main() {
int i;
while (~scanf("%s", &s)) {
int ans = 0;
int n = strlen(s);
int cn = 0;
for (i = 0; i < n; i++) {
if (i == 0 || (s[i] != s[i - 1])) {
node[cn].c = s[i];
node[cn++].num++;
} else if (s[i] == s[i - 1] && i > 0) {
node[cn - 1].num++;
}
}
if (cn == 1) {
printf("0\n");
continue;
}
while (1) {
ans++;
for (i = 0; i < cn; i++) {
if (i == 0 || i == cn - 1)
node[i].num--;
else {
if (node[i].num >= 2) {
node[i].num -= 2;
} else {
node[i].num--;
}
}
}
int cnt = 0;
for (i = 0; i < cn; i++) {
if (node[i].num == 0) continue;
tmp[cnt].c = node[i].c;
tmp[cnt++].num = node[i].num;
}
if (cnt == 0) break;
int zz = 1;
temp[0].c = tmp[0].c;
temp[0].num = tmp[0].num;
for (i = 1; i < cnt; i++) {
if (temp[zz - 1].c == tmp[i].c) {
temp[zz - 1].num += tmp[i].num;
} else {
temp[zz].c = tmp[i].c;
temp[zz++].num = tmp[i].num;
}
}
for (i = 0; i < zz; i++) {
node[i].c = temp[i].c;
node[i].num = temp[i].num;
}
cn = zz;
if (cn == 1) break;
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main(void) {
int n, m;
std::cin >> n >> m;
int t;
for (int i = 0; i < m; ++i) {
std::cin >> t;
if (t == 1) {
std::cout << "2";
return 0;
}
}
for (int j = 1; j < n - 1; ++j) {
std::cin >> t;
if (t == 1) {
std::cout << "2";
return 0;
}
for (int i = 1; i < m; ++i) std::cin >> t;
if (t == 1) {
std::cout << "2";
return 0;
}
}
for (int i = 0; i < m; ++i) {
std::cin >> t;
if (t == 1) {
std::cout << "2";
return 0;
}
}
std::cout << "4";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<int> adj[200005];
bool vis[200005];
int depth[200005];
bool used_parent[200005];
vector<vector<int>> paths;
void dfs(int u, int p) {
depth[u] = depth[p] + 1;
vis[u] = 1;
vector<int> nodes;
for (auto v : adj[u]) {
if (v == p) continue;
if (vis[v]) {
if (depth[v] < depth[u]) nodes.emplace_back(v);
continue;
}
dfs(v, u);
if (!used_parent[v]) nodes.emplace_back(v);
}
if ((int)nodes.size() & 1) {
if (p) {
used_parent[u] = 1;
nodes.emplace_back(p);
}
for (int i = 0; i < (int)nodes.size() - 1; i += 2) {
vector<int> path;
path.emplace_back(nodes[i]);
path.emplace_back(u);
path.emplace_back(nodes[i + 1]);
paths.emplace_back(path);
}
} else {
for (int i = 0; i < (int)nodes.size() - 1; i += 2) {
vector<int> path;
path.emplace_back(nodes[i]);
path.emplace_back(u);
path.emplace_back(nodes[i + 1]);
paths.emplace_back(path);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
for (int u = 1; u <= n; u++) {
if (!vis[u]) dfs(u, 0);
}
cout << (int)paths.size() << "\n";
for (auto path : paths) {
for (auto node : path) cout << node << " ";
cout << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
const long long inf = 1e18;
long long AP(long long n, long long first, long long df) {
if (n > 1e5) return inf;
long long ret = 2 * first + (n - 1) * df;
return (ret * n) / 2;
}
long long GP(long long n, long long first, long long fc) {
if (n >= 30) return inf;
long long ret = first * (pow(fc, n) - 1);
return ret / (fc - 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
long long st = -1;
long long lo = 1, hi = n, md;
while (lo < hi) {
md = (lo + hi) / 2;
long long lt = AP(k, md, 1);
long long rt = GP(k, md, 2);
if (lt > n)
hi = md;
else if (rt < n)
lo = md + 1;
else {
st = md;
break;
}
}
if (st == -1) {
long long lt = AP(k, lo, 1);
long long rt = GP(k, lo, 2);
if (n >= lt && n <= rt) st = lo;
}
if (st == -1) cout << "NO" << endl, exit(0);
cout << "YES" << endl;
cout << st << " ";
n -= st;
for (int i = 2; i <= k; i++) {
long long lo = st + 1, hi = 2 * st, md, f = 0;
while (lo < hi) {
md = (lo + hi) / 2;
long long lt = AP(k - i + 1, md, 1);
long long rt = GP(k - i + 1, md, 2);
if (lt > n)
hi = md;
else if (rt < n)
lo = md + 1;
else {
cout << md << " ";
n -= md;
f = 1;
st = md;
break;
}
}
if (f == 0) {
cout << lo << " ";
n -= lo;
st = lo;
}
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%I64d", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
long long int dp[5010][5010];
const long long MOD[] = {1000000007LL, 2117566807LL, 1000000007LL,
1000000037LL};
const long long BASE[] = {1572872831LL, 1971536491LL, 1000003LL, 31};
class stringhash {
public:
long long int base, mod, len, ar[5010], P[5010];
void GenerateFH(string s, long long int b, long long int m) {
base = b;
mod = m;
len = s.length();
P[0] = 1;
long long h = 0;
for (int i = 1; i <= len; i++)
P[i] = ((long long int)P[i - 1] * (long long int)base) % mod;
for (int i = 0; i < len; i++) {
h = (h * base) + s[i];
h %= mod;
ar[i] = h;
}
}
int Fhash(int x, int y) {
long long int h = ar[y];
if (x > 0) {
h = (h - (long long int)P[y - x + 1] * (long long int)ar[x - 1]) % mod;
if (h < 0) h += mod;
}
return h;
}
void GenerateRH(string s, long long int b, long long int m) {
base = b;
mod = m;
len = s.length();
P[0] = 1;
long long int h = 0;
for (int i = 1; i <= len; i++)
P[i] = ((long long int)P[i - 1] * (long long int)base) % mod;
for (int i = len - 1; i >= 0; i--) {
h = (h * base) + s[i];
h %= mod;
ar[i] = h;
}
}
long long int Rhash(int x, int y) {
long long h = ar[x];
if (y < len - 1) {
h = (h - (long long int)P[y - x + 1] * (long long int)ar[y + 1]) % mod;
if (h < 0) h += mod;
}
return h;
}
};
stringhash s1, s2;
int main() {
string s;
cin >> s;
s = '&' + s;
s1.GenerateFH(s, BASE[0], MOD[0]);
s2.GenerateRH(s, BASE[0], MOD[0]);
int n = s.length();
for (int i = 1; i < n; i++) {
for (int j = i; j < n; j++) {
dp[i][j] = (s1.Fhash(i, j) == s2.Rhash(i, j));
dp[i][j] = dp[i][j] + dp[i][j - 1];
}
}
for (int i = 1; i < n; i++)
for (int j = 1; j < n; j++) dp[i][j] += dp[i - 1][j];
int q = nxt();
while (q--) {
int a = nxt();
int b = nxt();
int ans = dp[b][b] + dp[a - 1][a - 1] - dp[a - 1][b] - dp[b][a - 1];
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 100;
int InValues[N];
int Impr[N][3];
vector<pair<pair<long long, long long>, int> > Mult;
pair<long long, int> Best[N];
vector<pair<long long, int> > ImprPoz[N];
vector<int> Choosen;
void Wczytaj(int &k, int &n, int &m) {
int i;
scanf("%d%d%d", &k, &n, &m);
for (i = 0; i < k; i++) {
scanf("%d", &InValues[i]);
}
for (i = 0; i < n; i++) {
scanf("%d%d%d", &Impr[i][0], &Impr[i][1], &Impr[i][2]);
Impr[i][1]--;
if (Impr[i][0] == 3)
Mult.push_back(make_pair(make_pair((long long)Impr[i][2], 1LL), i));
if (Impr[i][0] == 1)
Best[Impr[i][1]] =
max(Best[Impr[i][1]], make_pair((long long)Impr[i][2], i));
if (Impr[i][0] == 2)
ImprPoz[Impr[i][1]].push_back(make_pair((long long)Impr[i][2], i));
}
}
bool Cmp1(pair<pair<long long, long long>, int> p1,
pair<pair<long long, long long>, int> p2) {
long long a, b, c, d;
a = p1.first.first;
b = p1.first.second;
c = p2.first.first;
d = p2.first.second;
long double w1, w2;
w1 = log(a) - log(b);
w2 = log(c) - log(d);
return w1 > w2;
}
bool Cmp2(int i1, int i2) {
if (Impr[i1][0] != Impr[i2][0]) return Impr[i1][0] < Impr[i2][0];
return i1 < i2;
}
void WybierzNajlepsze(int k, int n, int m) {
int i, j;
long long ost;
for (i = 0; i < k; i++) {
if (Best[i].first > InValues[i])
ImprPoz[i].push_back(
make_pair((long long)(Best[i].first - InValues[i]), Best[i].second));
sort(ImprPoz[i].begin(), ImprPoz[i].end());
reverse(ImprPoz[i].begin(), ImprPoz[i].end());
ost = InValues[i];
for (j = 0; j < ImprPoz[i].size(); j++) {
Mult.push_back(make_pair(make_pair(ost + ImprPoz[i][j].first, ost),
ImprPoz[i][j].second));
ost += ImprPoz[i][j].first;
}
}
sort(Mult.begin(), Mult.end(), Cmp1);
for (i = 0; i < min(m, (int)Mult.size()); i++)
Choosen.push_back(Mult[i].second);
}
void Wypisz() {
int i;
sort(Choosen.begin(), Choosen.end(), Cmp2);
printf("%d\n", (int)Choosen.size());
for (i = 0; i < Choosen.size(); i++) printf("%d ", Choosen[i] + 1);
printf("\n");
}
int main() {
int k, n, m;
Wczytaj(k, n, m);
WybierzNajlepsze(k, n, m);
Wypisz();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans = 0;
cin >> n;
ans = (n - 2) + (2 * (n - 3));
if (n > 3) {
ans += ((n - 3) * (n - 4));
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-18;
const long double PI = 3.141592653589793238;
const long long MOD = 1e9 + 7;
const int N = int(5e5) + 10;
queue<int> e, ne;
int n;
vector<int> v;
string x;
bool del[N];
int main() {
memset(del, false, sizeof(del));
cin >> n >> x;
int have = n;
for (int i = 0; i < n; i++) {
if (x[i] == '8')
e.push(i);
else
ne.push(i);
}
for (int i = 0; i < n && have > 11; i++) {
if (i % 2 == 0) {
if (ne.size())
ne.pop();
else
e.pop();
} else {
if (e.size())
e.pop();
else
ne.pop();
}
have--;
}
while (ne.size()) {
v.push_back(ne.front());
ne.pop();
}
while (e.size()) {
v.push_back(e.front());
e.pop();
}
sort((v).begin(), (v).end());
if (x[v[0]] == '8') {
cout << "YES";
} else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
struct node {
node *lc, *rc;
int sum;
node(int c) {
lc = NULL;
rc = NULL;
sum = c;
}
node(node *x, node *y) {
lc = x;
rc = y;
sum = 0;
if (lc) sum += lc->sum;
if (rc) sum += rc->sum;
}
} * root[MAXN];
node *update(node *a, int x, int l, int r, int v) {
if (l == r) return new node(v);
int mid = (l + r) / 2;
if (x <= mid) {
return new node(update((a ? a->lc : NULL), x, l, mid, v),
(a ? a->rc : NULL));
} else {
return new node((a ? a->lc : NULL),
update((a ? a->rc : NULL), x, mid + 1, r, v));
}
}
int query(node *a, int l, int r, int L, int R) {
if (l > R || r < L || !a || L > R) return 0;
if (L <= l && r <= R) return a->sum;
int mid = (l + r) / 2;
return query(a->lc, l, mid, L, R) + query(a->rc, mid + 1, r, L, R);
}
int n, k, q;
int a[MAXN], cnt[MAXN];
vector<int> id[MAXN];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
id[a[i]].push_back(i);
cnt[a[i]]++;
root[i] = update(root[i - 1], i, 1, MAXN, 1);
if (cnt[a[i]] > k) {
root[i] = update(root[i], id[a[i]][cnt[a[i]] - k - 1], 1, MAXN, 0);
}
}
int last = 0;
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
int l = (x + last) % n + 1;
int r = (y + last) % n + 1;
if (l > r) swap(l, r);
cout << (last = query(root[r], 1, MAXN, l, r)) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace acheing {
set<int> s1[110000], s2[110000];
int i, j, k, n, m, x, y, t, num, a[110000];
bool b[110000], c[110000];
struct data {
int x, y, id, k, p, ansid;
} w[1000010], ask[110000], mark[1000010];
long long ans[1000010], s[110000], ti, v[110000];
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
f = ch == '-' ? -f : f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
void init() {
n = read();
m = read();
for (i = 1; i <= n; i++) a[i] = read();
for (i = 1; i <= m; i++) {
ask[i].k = read();
ask[i].x = read();
ask[i].y = read();
ask[i].id = i;
}
}
bool cmp(const data& a, const data& b) {
return a.x == b.x ? (a.y == b.y ? a.id < b.id : a.y < b.y) : a.x > b.x;
}
void pre() {
for (i = 1; i <= n; i++) {
x = -*s2[a[i]].lower_bound(-i);
if (x != 0) {
w[++num].x = x;
w[num].y = i;
w[num].id = num;
w[num].k = 1;
w[num].p = i - x;
}
s1[a[i]].insert(i);
s2[a[i]].insert(-i);
if (!c[a[i]]) {
s1[a[i]].insert(n + 10);
s2[a[i]].insert(0);
c[a[i]] = 1;
}
}
for (i = 1; i <= m; i++) {
if (ask[i].k == 1) {
if (!c[ask[i].y]) {
s1[ask[i].y].insert(n + 10);
s2[ask[i].y].insert(0);
c[ask[i].y] = 1;
}
x = *s1[a[ask[i].x]].lower_bound(ask[i].x + 1),
y = -*s2[a[ask[i].x]].lower_bound(-ask[i].x + 1);
if (y) {
w[++num].x = y;
w[num].y = ask[i].x;
w[num].p = -(ask[i].x - y);
w[num].k = 1;
w[num].id = num;
}
if (x != n + 10) {
w[++num].x = ask[i].x;
w[num].y = x;
w[num].p = -(x - ask[i].x);
w[num].k = 1;
w[num].id = num;
}
if (x != n + 10 && y) {
w[++num].x = y;
w[num].y = x;
w[num].p = (x - y);
w[num].k = 1;
w[num].id = num;
}
s1[a[ask[i].x]].erase(ask[i].x);
s2[a[ask[i].x]].erase(-ask[i].x);
x = *s1[ask[i].y].lower_bound(ask[i].x + 1),
y = -*s2[ask[i].y].lower_bound(-ask[i].x + 1);
if (y) {
w[++num].x = y;
w[num].y = ask[i].x;
w[num].p = (ask[i].x - y);
w[num].k = 1;
w[num].id = num;
}
if (x != n + 10) {
w[++num].x = ask[i].x;
w[num].y = x;
w[num].p = (x - ask[i].x);
w[num].k = 1;
w[num].id = num;
}
if (x != n + 10 && y) {
w[++num].x = y;
w[num].y = x;
w[num].p = -(x - y);
w[num].k = 1;
w[num].id = num;
}
s1[ask[i].y].insert(ask[i].x);
s2[ask[i].y].insert(-ask[i].x);
a[ask[i].x] = ask[i].y;
} else {
w[++num].x = ask[i].x;
w[num].y = ask[i].y;
w[num].k = 2;
w[num].id = num;
w[num].ansid = i;
b[i] = 1;
}
}
sort(w + 1, w + 1 + num, cmp);
}
void update(int x, int y) {
int t = x;
while (t <= n) {
if (v[t] != ti) s[t] = 0, v[t] = ti;
s[t] += y;
t += t & -t;
}
}
long long query(int x) {
int t = x;
long long ans = 0;
while (t) {
if (v[t] != ti) s[t] = 0, v[t] = ti;
ans += s[t];
t -= t & -t;
}
return ans;
}
void cdq(int l, int r) {
if (l >= r) return;
int mid = (l + r) >> 1;
int x = l, y = mid + 1;
ti++;
for (int i = l; i <= r; i++)
if (w[i].id <= mid) {
mark[x++] = w[i];
if (w[i].k == 1) update(w[i].y, w[i].p);
} else {
if (w[i].k == 2) ans[w[i].ansid] += query(w[i].y);
mark[y++] = w[i];
}
for (int i = l; i <= r; i++) w[i] = mark[i];
cdq(l, mid);
cdq(mid + 1, r);
}
void work() {
pre();
cdq(1, num);
for (i = 1; i <= m; i++)
if (b[i]) printf("%lld\n", ans[i]);
return;
}
void main() {
init();
work();
return;
}
} // namespace acheing
int main() {
acheing::main();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> a[500001];
int main() {
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
long long int i, j, n, f;
double lo, mid, hi, ans = -1, last;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
lo = 0;
hi = 1e10;
for (i = 0; i < 100; i++) {
mid = (lo + hi) / 2.0;
f = 0;
last = -1e100;
for (j = 1; j <= n; j++) {
if (a[j].second > 0)
last = max(last, 1.0 * (a[j].first + 1.0 * a[j].second * mid));
else {
if (1.0 * (a[j].first + 1.0 * a[j].second * mid) < last) {
f = 1;
break;
}
}
}
if (f) {
hi = mid;
ans = mid;
} else
lo = mid;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long nTest;
cin >> nTest;
while (nTest--) {
long N;
string S, T;
cin >> N >> S >> T;
string SS = S, TT = T;
sort(SS.begin(), SS.end());
sort(TT.begin(), TT.end());
if (SS != TT) {
cout << -1 << '\n';
continue;
}
long Answer = N;
for (long k = 0; k < N; ++k) {
long j = k;
for (long i = 0; i < N; ++i)
if (j < N && S[i] == T[j]) ++j;
Answer = min(Answer, N - j + k);
}
cout << Answer << '\n';
}
flush(cout);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<string> ssplit(string a) {
int i;
string tmp;
vector<string> ret;
for (i = 0; i < a.size(); i++) {
if (a[i] == '\\') ret.push_back(tmp);
tmp += a[i];
}
return ret;
}
map<string, int> ff;
map<string, int> mp;
set<string> sf[10002];
int main() {
string cmd;
vector<string> a;
map<string, int>::iterator it;
int ra, rb, cnt = 0, i, j;
while (cin >> cmd) {
a = ssplit(cmd);
for (i = 1; i < a.size(); i++) {
if (mp.find(a[i]) == mp.end()) mp[a[i]] = cnt++;
}
for (i = a.size() - 1; i > 0; i--) {
ff[a[i]]++;
}
for (i = 1; i < a.size(); i++) {
for (j = i + 1; j < a.size(); j++) {
sf[mp[a[i]]].insert(a[j]);
}
}
}
ra = rb = 0;
for (i = 0; i < cnt; i++) {
ra = ((ra) > ((int)sf[i].size()) ? (ra) : ((int)sf[i].size()));
}
for (it = ff.begin(); it != ff.end(); it++) {
cnt = it->second;
rb = ((rb) > (cnt) ? (rb) : (cnt));
}
cout << ra << " " << rb << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define sz(x) (int)x.size()
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define eb emplace_back
#define ff first
#define ss second
#define pi pair<int, int>
#ifdef int
#undef int
#endif
template <int MOD_> struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) { if (v < 0) v += MOD; }
explicit operator int() const { return v; }
friend std::ostream& operator << (std::ostream& out, const modnum& n) { return out << int(n); }
friend std::istream& operator >> (std::istream& in, modnum& n) { ll v_; in >> v_; n = modnum(v_); return in; }
friend bool operator == (const modnum& a, const modnum& b) { return a.v == b.v; }
friend bool operator != (const modnum& a, const modnum& b) { return a.v != b.v; }
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
friend modnum inv(const modnum& m) { return m.inv(); }
modnum neg() const {
modnum res;
res.v = v ? MOD-v : 0;
return res;
}
friend modnum neg(const modnum& m) { return m.neg(); }
modnum operator- () const {
return neg();
}
modnum operator+ () const {
return modnum(*this);
}
modnum& operator ++ () {
v ++;
if (v == MOD) v = 0;
return *this;
}
modnum& operator -- () {
if (v == 0) v = MOD;
v --;
return *this;
}
modnum& operator += (const modnum& o) {
v += o.v;
if (v >= MOD) v -= MOD;
return *this;
}
modnum& operator -= (const modnum& o) {
v -= o.v;
if (v < 0) v += MOD;
return *this;
}
modnum& operator *= (const modnum& o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum& operator /= (const modnum& o) {
return *this *= o.inv();
}
friend modnum operator ++ (modnum& a, int) { modnum r = a; ++a; return r; }
friend modnum operator -- (modnum& a, int) { modnum r = a; --a; return r; }
friend modnum operator + (const modnum& a, const modnum& b) { return modnum(a) += b; }
friend modnum operator - (const modnum& a, const modnum& b) { return modnum(a) -= b; }
friend modnum operator * (const modnum& a, const modnum& b) { return modnum(a) *= b; }
friend modnum operator / (const modnum& a, const modnum& b) { return modnum(a) /= b; }
friend string to_string (const modnum& a) { return to_string(int(a)); }
};
const int md = 998244353;
using Mint = modnum<md>;
vector<Mint> fact(1, 1);
vector<Mint> inv_fact(1, 1);
template<class T, class U>
T power(const T& a, const U& b) {
assert(b >= 0);
T x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
Mint C(int n, int k) {
if (k < 0 || k > n) {
return 0;
}
while ((int) fact.size() < n + 1) {
fact.push_back(fact.back() * (int) fact.size());
inv_fact.push_back(1 / fact.back());
}
return fact[n] * inv_fact[k] * inv_fact[n - k];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<vector<int>> d(m, vector<int>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> d[j][i];
}
}
Mint ans = 0;
Mint f = 1;
for (int i = 1; i <= n; i++) {
f *= i;
}
for (vector<int> dd : d) {
// we want to count the number of permutation of [1 ... n]
// in which given point is included
// there are total f = n! permutations
//
// we sort the cities by distance from given point
// in non-decreasing order
// let it be [v1, v2, ..., vn] with distances
// [d1, d2, ..., dn] (non-decreasing)
// lets count the number of permutation for which given point is not included
sort(all(dd));
Mint cur = 1; // number of permutation which don't include given point
for (int i = 1; i <= n; i++) {
cur *= max(0, dd[i - 1] - i);
// if (dd[i - 1] - i) achives a non-positive value for any i
// then we assert that given point is contained in every permutation
//
// proof: suppose for some i, (dd[i - 1] - i) is non-positive
// let the corresponding city for this i be v
// this means the permuations for which city v occurs at or after position i
// the given point will be included in those permuation
//
// also if we put city v at position < i, then some other city whose
// distance is less than that of v will be assigned position greater or equal to i
// and again we can take this given point
// hence every permuation will then include the given point
}
ans += f - cur;
}
cout << ans / f << "\n";
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, t, mx, c;
pair<long long, long long> a[2123];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
}
c = a[0].second;
mx = max(c, mx);
for (int i = 1; i < n; ++i) {
c = max(0ll, c - (a[i].first - a[i - 1].first)) + a[i].second;
mx = max(c, mx);
}
cout << a[n - 1].first + c << " " << mx;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N;
bool asked[1000001];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin >> N;
int low = -1, high = 1000000000, mid;
int queries = 60;
while (low + 1 < high) {
mid = (low + high) / 2;
queries--;
cout << ">" << ' ' << mid << '\n';
cout << flush;
int ans;
cin >> ans;
if (ans == 1)
low = mid;
else
high = mid;
}
vector<int> v;
v.push_back(high);
for (int i = 0; i < queries; i++) {
int x = rng() % N + 1;
if (asked[x] == false) {
asked[x] = true;
cout << "? " << x << '\n';
cout << flush;
int num;
cin >> num;
v.push_back(num);
}
}
sort(v.begin(), v.end());
long long dif = 0;
for (int i = 0; i + 1 < v.size(); i++) dif = gcd(dif, v[i + 1] - v[i]);
cout << "! " << high - dif * (N - 1) << ' ' << dif << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &first, T second) {
first < second ? first = second : T();
}
template <typename T>
void chkmin(T &first, T second) {
first > second ? first = second : T();
}
template <typename T>
void readint(T &first) {
first = 0;
int f = 1;
char c;
for (c = getchar(); !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) first = first * 10 + c - '0';
first *= f;
}
const int MAXN = 1005, MAXM = 200005, DIR[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
int n, m, a[MAXN][MAXN];
pair<int, int> b[MAXM];
vector<int> G[MAXM];
namespace LCT {
int ch[MAXM][2], fa[MAXM];
bool rev[MAXM];
bool nroot(int u) { return ch[fa[u]][0] == u || ch[fa[u]][1] == u; }
bool sontype(int u) { return ch[fa[u]][1] == u; }
void reverse(int u) {
rev[u] ^= 1;
swap(ch[u][0], ch[u][1]);
}
void pushdown(int u) {
if (rev[u]) reverse(ch[u][0]), reverse(ch[u][1]), rev[u] = 0;
}
void pushall(int u) {
if (nroot(u)) pushall(fa[u]);
pushdown(u);
}
void update(int u) {}
void rotate(int u) {
int t = sontype(u), first = fa[u], second = fa[first], z = ch[u][t ^ 1];
fa[u] = second;
if (nroot(first)) ch[second][sontype(first)] = u;
if (z) fa[z] = first;
ch[first][t] = z;
fa[first] = u;
ch[u][t ^ 1] = first;
update(first);
update(u);
}
void splay(int u) {
pushall(u);
while (nroot(u))
if (!nroot(fa[u]))
rotate(u);
else if (sontype(u) == sontype(fa[u]))
rotate(fa[u]), rotate(u);
else
rotate(u), rotate(u);
}
void access(int u) {
for (int v = 0; u; u = fa[v = u]) splay(u), ch[u][1] = v, update(u);
}
void makeroot(int u) { access(u), splay(u), reverse(u); }
void link(int u, int v) {
makeroot(u);
makeroot(v);
fa[u] = v;
}
void cut(int u, int v) {
makeroot(u);
access(v);
splay(u);
ch[u][1] = fa[v] = 0;
update(u);
}
}; // namespace LCT
namespace SEG {
pair<int, int> f[MAXM << 2];
int tag[MAXM << 2];
void pushdown(int id) {
if (!tag[id]) return;
tag[id << 1] += tag[id], f[id << 1].first += tag[id];
tag[id << 1 | 1] += tag[id], f[id << 1 | 1].first += tag[id];
tag[id] = 0;
}
pair<int, int> update(pair<int, int> p, pair<int, int> q) {
return p.first == q.first ? make_pair(p.first, p.second + q.second)
: min(p, q);
}
void build(int id, int l, int r) {
if (l == r) {
f[id] = make_pair(0, 1);
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
f[id] = update(f[id << 1], f[id << 1 | 1]);
}
void modify(int id, int l, int r, int ql, int qr, int c) {
if (l == ql && r == qr) {
tag[id] += c;
f[id].first += c;
return;
}
pushdown(id);
int mid = (l + r) >> 1;
if (qr <= mid)
modify(id << 1, l, mid, ql, qr, c);
else if (ql > mid)
modify(id << 1 | 1, mid + 1, r, ql, qr, c);
else
modify(id << 1, l, mid, ql, mid, c),
modify(id << 1 | 1, mid + 1, r, mid + 1, qr, c);
f[id] = update(f[id << 1], f[id << 1 | 1]);
}
pair<int, int> query(int id, int l, int r, int ql, int qr) {
if (l == ql && r == qr) return f[id];
pushdown(id);
int mid = (l + r) >> 1;
if (qr <= mid) return query(id << 1, l, mid, ql, qr);
if (ql > mid) return query(id << 1 | 1, mid + 1, r, ql, qr);
return update(query(id << 1, l, mid, ql, mid),
query(id << 1 | 1, mid + 1, r, mid + 1, qr));
}
}; // namespace SEG
int main() {
readint(n), readint(m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
readint(a[i][j]);
b[a[i][j]] = make_pair(i, j);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
for (int t = 0; t < 4; ++t) {
int first = i + DIR[t][0], second = j + DIR[t][1];
if (first <= 0 || second <= 0 || first > n || second > m) continue;
G[a[i][j]].push_back(a[first][second]);
}
long long ans = 0;
int l = 1;
SEG::build(1, 1, n * m);
for (int r = 1; r <= n * m; ++r) {
while (l < r) {
for (auto v : G[r])
if (v < r && v >= l) LCT::makeroot(v);
bool flag = 1;
for (auto v : G[r])
if (v < r && v >= l && LCT::fa[v]) {
flag = 0;
break;
}
if (flag) break;
for (auto v : G[l])
if (v > l) LCT::cut(l, v);
++l;
}
for (auto v : G[r])
if (v < r && v >= l) LCT::link(r, v);
SEG::modify(1, 1, n * m, 1, r, 1);
for (auto v : G[r])
if (v < r && v >= l) SEG::modify(1, 1, n * m, 1, v, -1);
ans += SEG::query(1, 1, n * m, l, r).second;
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, u;
cin >> s >> u;
int n, m;
n = int(s.size());
m = int(u.size());
int res = 0;
for (int i = -m + 1; i < n; i++) {
int t = 0;
for (int j = 0; j < m; j++) {
if (i + j >= 0 && i + j < n) {
if (s[i + j] == u[j]) t++;
}
}
res = max(t, res);
}
cout << m - res << '\n';
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define ll long long
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) a*b/(__gcd(a,b))
using namespace std;
//priority_queue <int,vector<int>,less<int> > Q;
ll qpow(ll a,ll x){ll ans=1;while(x>0){if(x&1){ans=(ans*a);}a=(a*a);x/=2;}return ans;}
const double eps = 1e-7;
const ll inf= 0x3f3f3f3f3f3f3f3f;
const int N = 1e5+5;
const int mod = 1e9+7;
void solve(){
int xa,ya,xb,yb,xf,yf;
cin >> xa >> ya >> xb >> yb >> xf >> yf;
if(xa == xb || ya == yb){
// cout << xa << ' ' << xb << ' ' << xf<< endl;
if(xa == xb && xa == xf && yf>min(ya,yb) && yf <max(ya,yb)){
cout << 2+abs(ya-yb) << endl;
return;
}
if(ya == yb && yf == ya && xf>min(xa,xb) && xf <max(xa,xb)){
cout << 2+abs(xa-xb) << endl;
return;
}
}
cout << abs(ya-yb) + abs(xa-xb) << endl;
}
int main(){
int t;
scanf("%d",&t);
while(t--)
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long testcases = 1;
cin >> testcases;
while (testcases--) {
long long n;
cin >> n;
if (n == 1) {
cout << 1 << endl;
} else if (n == 2) {
cout << 2 << endl;
} else {
if (n % 2 == 0) {
cout << (n / 2) + 1 << endl;
} else {
cout << (n / 2) + 1 << endl;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int b[70], c[70], a[70];
long long f[70], g[70], pow2[70];
bool check(int num) {
int i, j;
for (i = 1; i < num; i++) {
if (num % i != 0) continue;
bool flag = 1;
for (j = 1; j <= i; j++) {
int k = j;
while (k + i <= num) {
if (b[k] != b[k + i]) {
flag = 0;
break;
}
k += i;
}
if (flag == 0) break;
}
if (flag) return 1;
}
return 0;
}
long long cnt(int l, int len, int num) {
int i, j, k;
for (i = 1; i < l; i++) c[i] = b[i];
c[l] = 0;
memset(g, 0, sizeof(g));
g[num] = pow2[num - l];
for (i = 1; i < num; i++) {
if (num % i != 0) continue;
bool flag = 1;
for (j = 1; j <= i; j++) {
int k = j;
while (k + i <= l) {
if (c[k] != c[k + i]) {
flag = 0;
break;
}
k += i;
}
if (flag == 0) break;
}
if (flag == 0)
g[i] = 0;
else {
if (i <= l)
g[i] = 1;
else
g[i] = pow2[i - l];
}
}
for (j = 1; j <= num; j++)
for (k = 2 * j; k <= num; k += j) g[k] -= g[j];
return g[len];
}
long long sum(long long x) {
if (x == 0) return 0;
int num = 0;
long long y = x;
while (y > 0) {
a[++num] = y % 2;
y /= 2;
}
long long ans = 0;
int i, j;
for (j = 1; j <= num; j++) b[j] = a[num - j + 1];
for (i = 1; i <= 60; i++) {
if (num % i != 0) {
if (num > i) ans += (num / i - 1) * f[i];
} else {
if (num >= 2 * i) ans += (num / i - 2) * f[i];
if (num > i) {
for (j = 2; j <= num; j++) {
if (b[j] == 1) {
ans += cnt(j, i, num);
}
}
}
}
}
if (check(num)) ans++;
return ans;
}
int main() {
f[0] = 1;
pow2[0] = 1;
int i, j;
long long l, r;
for (i = 1; i <= 60; i++) {
f[i] = f[i - 1] * 2;
pow2[i] = pow2[i - 1] * 2;
}
for (i = 1; i <= 60; i++)
for (j = 2 * i; j <= 60; j += i) f[j] -= f[i];
for (i = 1; i <= 60; i++) f[i] /= 2;
scanf("%lld%lld", &l, &r);
printf("%lld\n", sum(r) - sum(l - 1));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int t, n, w[100], hh[100], maxn;
int main() {
scanf("%d", &t);
for (int s = 1; s <= t; s++) {
maxn = 0;
for (int i = 1; i <= 50; i++) hh[i] = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]), hh[w[i]]++;
for (int i = 2; i <= 2 * n; i++) {
int hhh = 0;
for (int j = 1; j <= n; j++) {
if ((i - j) <= n && (i - j) >= 1 && 2 * j <= i) {
if (j != (i - j))
hhh += min(hh[i - j], hh[j]);
else
hhh += (hh[j] / 2);
} else
continue;
}
maxn = max(maxn, hhh);
}
printf("%d\n", maxn);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long pow2[105];
const int MOD = 1000000007;
void init() {
pow2[0] = 1;
for (int i = 1; i <= 100; i++) pow2[i] = (2 * pow2[i - 1]) % MOD;
}
int main() {
string s;
cin >> s;
init();
int n = s.length();
long long res = 0;
for (int i = 0; i < n; i++)
if (s[i] == '1') res = (pow2[n - i - 1] + res) % MOD;
res = (res * pow2[n - 1]) % MOD;
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct ss {
int ind;
int val;
bool operator<(const ss& aa) const { return val > aa.val; }
};
struct ss dat[100003];
int vis[100003];
int dd[100003];
int g_n;
int main() {
long long cost;
long long sss = 0;
int n, k, cnt;
scanf("%d%d", &n, &k);
cin >> cost;
g_n = n;
for (int i = 1; i <= n; i++) {
scanf("%d", &dat[i].val);
dat[i].ind = i;
dd[i] = dat[i].val;
}
int mi = n;
cnt = 0;
sort(dat + 1, dat + n + 1);
int i;
for (i = 1;; i++) {
if (dat[i].ind != n) {
if (mi > dat[i].ind) mi = dat[i].ind;
cnt++;
sss += dat[i].val;
if (cnt >= k) break;
}
}
int tmp = dat[i].val;
if (sss <= cost) {
printf("%d\n", n);
return 0;
}
for (i = 1; i <= mi; i++) {
if (dd[i] - tmp + sss > cost) {
printf("%d\n", i);
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 61;
const int Max = 1000007;
const double PI = acos(-1.0);
long long ANS[1050];
bool taken[1050];
void solve(long long n) {
vector<long long> query1, query2;
long long i, j, k, l, step;
for (i = 0; i <= (n + 2); i++) ANS[i] = INF;
for (step = 1; step <= 10; step++) {
memset(taken, 0, sizeof(taken));
query1.clear();
query2.clear();
long long diff = 1 << (step - 1);
for (i = 1; i <= n; i += diff) {
long long tot = min(diff, n);
for (j = 0; j < diff; j++, i++) {
if (i > n) break;
query1.push_back(i);
taken[i] = true;
long long temp = i + diff;
if (temp <= n) query2.push_back(temp);
}
}
if (query1.size() == 0) break;
cout << query1.size() << endl;
for (auto &x : query1) cout << x << " ";
cout << endl;
fflush(stdout);
for (i = 1; i <= n; i++) {
cin >> k;
if (taken[i]) continue;
ANS[i] = min(ANS[i], k);
}
if (query2.size() != 0) {
cout << query2.size() << endl;
for (auto &x : query2) cout << x << " ";
cout << endl;
fflush(stdout);
for (i = 1; i <= n; i++) {
cin >> k;
if (!taken[i]) continue;
ANS[i] = min(ANS[i], k);
}
}
if ((1 << step) > n) break;
}
cout << -1 << endl;
for (i = 1; i <= n; i++) cout << ANS[i] << " ";
cout << endl;
fflush(stdout);
}
int main() {
long long i, j, k, l, temp, t, n, m, caseno = 0, ans;
string str;
while (cin >> n) {
solve(n);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k, starti, startj;
bool cells[3][102], ok[3][102];
cin >> t;
for (int ii = 0; ii < t; ++ii) {
cin >> n >> k;
char t;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < n; ++j) {
cin >> t;
if (t == 's') {
starti = i;
startj = j;
cells[i][j] = true;
} else
cells[i][j] = (t == '.');
}
for (int i = 0; i < 3; ++i)
for (int j = n; j < n + 2; ++j) cells[i][j] = true;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < n + 2; ++j) ok[i][j] = false;
ok[starti][startj] = true;
for (int j = 0; j < n - 1; j += 3) {
for (int i = 0; i < 3; ++i)
if (ok[i][j]) {
if (cells[i][j + 1]) {
ok[i][j + 1] = true;
if (i > 0 && cells[i - 1][j + 1]) ok[i - 1][j + 1] = true;
if (i < 2 && cells[i + 1][j + 1]) ok[i + 1][j + 1] = true;
}
}
for (int i = 0; i < 3; ++i)
if (ok[i][j + 1]) {
if (cells[i][j + 2]) {
ok[i][j + 2] = true;
if (cells[i][j + 3]) ok[i][j + 3] = true;
}
}
}
bool win = false;
for (int i = 0; i < 3; ++i)
for (int j = n - 1; j < n + 2; ++j)
if (ok[i][j]) win = true;
if (win)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX1 = 1e3 + 1, MAX2 = 1e5 + 1;
int n, m, q;
long long ans[MAX2];
bool inv[MAX1];
set<int> t[MAX1];
vector<int> g[MAX2];
pair<int, pair<int, int>> h[MAX2];
void dfs(int x) {
int type = h[x].first, y = h[x].second.first, z = h[x].second.second;
bool done = 0;
if (type == 1) {
if ((t[y].find(z) != t[y].end()) == inv[y]) {
done = 1;
++ans[x];
if (inv[y])
t[y].erase(z);
else
t[y].insert(z);
}
} else if (type == 2) {
if ((t[y].find(z) != t[y].end()) != inv[y]) {
done = 1;
--ans[x];
if (inv[y])
t[y].insert(z);
else
t[y].erase(z);
}
} else if (type == 3) {
done = 1;
inv[y] = !inv[y];
ans[x] += inv[y] ? m - 2 * (int)t[y].size() : -(m - 2 * (int)t[y].size());
}
for (int a : g[x]) {
ans[a] = ans[x];
dfs(a);
}
if (type == 1) {
if (done) {
if (inv[y])
t[y].insert(z);
else
t[y].erase(z);
}
} else if (type == 2) {
if (done) {
if (inv[y])
t[y].erase(z);
else
t[y].insert(z);
}
} else if (type == 3) {
inv[y] = !inv[y];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= q; i++) {
int x, y, z;
cin >> x >> y;
if (x == 4)
g[y].push_back(i);
else if (x == 3) {
g[i - 1].push_back(i);
h[i] = {x, {y, 0}};
} else {
cin >> z;
g[i - 1].push_back(i);
h[i] = {x, {y, z}};
}
}
dfs(0);
for (int i = 1; i <= q; i++) cout << ans[i] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
template <typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
double startTime;
double getCurrentTime() {
return ((double)clock() - startTime) / CLOCKS_PER_SEC;
}
const int N = 100500;
const int M = 800800;
vector<int> g[N];
pii ans[M];
int ansSz;
int k;
int n;
void dfs(int v, int par, int cPar) {
int curC = cPar;
int sz = (int)g[v].size();
if (par) sz--;
for (int u : g[v]) {
if (u == par) continue;
if (curC == k) {
curC = cPar - sz - 1;
assert(curC >= 0);
ans[ansSz++] = make_pair(v, curC);
}
sz--;
curC++;
ans[ansSz++] = make_pair(u, curC);
dfs(u, v, curC);
}
if (par == 0) return;
if (curC != cPar - 1) {
ans[ansSz++] = make_pair(v, cPar - 1);
}
ans[ansSz++] = make_pair(par, cPar);
}
int main() {
startTime = (double)clock();
scanf("%d", &n);
ans[ansSz++] = make_pair(1, 0);
for (int i = 1; i < n; i++) {
int v, u;
scanf("%d%d", &v, &u);
g[v].push_back(u);
g[u].push_back(v);
}
for (int v = 1; v <= n; v++) k = max(k, (int)g[v].size());
dfs(1, 0, 0);
printf("%d\n", ansSz);
for (int i = 0; i < ansSz; i++)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int a, b, l, t;
bool operator<(const edge e) const { return l != e.l ? l < e.l : t < e.t; }
};
struct node {
int p, q;
node() : p(-1), q(1) {}
};
const int MAXN = 100005;
const int MAXM = 300005;
int N, M, res[MAXM], ok;
edge E[MAXM], F[MAXM];
node n[MAXN];
stack<pair<int&, int>> ch;
int find(int a) {
if (n[a].p < 0) return a;
ch.push({n[a].p, n[a].p});
n[a].p = find(n[a].p);
return n[a].p;
}
void join(int a, int b) {
int u = find(a);
int v = find(b);
if (u == v) return;
if (u > v) swap(u, v);
ch.push({n[u].p, n[u].p});
ch.push({n[v].q, n[v].q});
n[u].p = v;
n[v].q ^= n[u].q;
ok += 2 * (!n[v].q && n[u].q);
}
void rollback(int t, int o) {
ok = o;
for (; ch.size() > t; ch.pop()) {
ch.top().first = ch.top().second;
}
}
void solve(int l, int r, int lo) {
if (l >= r || lo == M) return;
int t = ch.size(), o = ok;
int m = (l + r) / 2, k = lo;
for (int i = l; i <= m; i++) {
if (E[i] < F[lo]) join(E[i].a, E[i].b);
}
solve(m + 1, r, lo);
for (; k < M; k++) {
if (F[k].t <= m) join(F[k].a, F[k].b);
if (ok == N) break;
}
rollback(t, o);
for (int i = lo; i <= k; i++) {
if (F[i].t < l) join(F[i].a, F[i].b);
}
solve(l, m, k);
rollback(t, o);
res[m] = F[k].l;
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int a, b, l;
scanf("%d %d %d", &a, &b, &l);
a -= 1, b -= 1;
E[i] = {a, b, l, i};
F[i] = {a, b, l, i};
res[i] = -1;
}
F[M].l = -1;
sort(F, F + M);
solve(0, M, 0);
for (int i = 0; i < M; i++) {
printf("%d\n", res[i]);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s, f;
cin >> s >> f;
int Min = 1100;
vector<int> ans;
for (int i = 0; i < m - n + 1; i++) {
int cnt = 0;
vector<int> arr;
for (int j = i; j - i < n; j++) {
if (s[j - i] != f[j]) {
cnt++;
arr.push_back(j - i + 1);
}
}
if (cnt < Min) {
Min = cnt;
ans = arr;
}
}
if (Min == 1100)
cout << 0 << endl;
else {
cout << Min << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << ' ';
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n <= 3) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
if (n % 2) {
cout << "5 * 3 = 15\n";
cout << "4 * 2 = 8\n";
cout << "15 + 8 = 23\n";
cout << "23 + 1 = 24\n";
for (int i = 7; i <= n; i += 2) {
cout << i << " - " << i - 1 << " = 1\n";
cout << "24 * 1 = 24\n";
}
} else {
cout << "4 + 2 = 6\n";
cout << "3 + 1 = 4\n";
cout << "6 * 4 = 24\n";
for (int i = 6; i <= n; i += 2) {
cout << i << " - " << i - 1 << " = 1\n";
cout << "24 * 1 = 24\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
bool is[N];
vector<int> pri;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 2; i <= 1e5 + 5; ++i) {
if (!is[i]) {
pri.push_back(i);
for (int j = i + i; j <= 1e5 + 5; j += i) {
is[j] = 1;
}
}
}
int p = *upper_bound(pri.begin(), pri.end(), n);
cout << p << ' ' << p << endl;
for (int i = 1; i < n - 1; ++i) {
cout << i << ' ' << i + 1 << ' ' << 1 << endl;
--p;
}
cout << n - 1 << ' ' << n << ' ' << p << endl;
m -= n - 1;
for (int i = 1; i < n - 1; ++i) {
for (int j = i + 2; j <= n && m; ++j) {
cout << i << ' ' << j << ' ' << (int)1e9 << endl;
--m;
}
}
}
| 4 |
#include<iostream>
#include<cmath>
using namespace std;
int main() {
int t;
cin>>t;
while(t--) {
int r,b,d;
cin>>r>>b>>d;
if(r<b) {
r = ceil((float) b/r);
b = 1;
} else {
r = ceil((float) r/b);
b = 1;
}
if((r-b)<=d) {
cout<<"YES"<<endl;
} else {
cout<<"NO"<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[2000005];
int main() {
int n, m, i, j, k, l;
scanf("%d", &n);
for (i = 1; i <= (n); i++) {
a[i] = i;
}
for (i = 2; i <= n; i++) {
j = n % i;
m = i + n - 1;
a[m] = a[m - j];
m = i + n - j - 1;
while (m > i) {
a[m] = a[m - i];
m = m - i;
}
}
for (i = n; i < 2 * n; i++) {
printf("%d ", a[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, i, j, ma = 0, m, k;
long long ans = 0;
vector<int> c, q[200001], p;
bool used[200001];
map<int, int> co;
void dfs(int x) {
p.push_back(x);
co[c[x]]++;
ma = max(ma, co[c[x]]);
used[x] = 1;
for (auto f : q[x]) {
if (!used[f]) {
dfs(f);
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
c.resize(n);
for (i = 0; i < n; i++) {
cin >> c[i];
}
for (i = 0; i < m; i++) {
cin >> a >> b;
q[a - 1].push_back(b - 1);
q[b - 1].push_back(a - 1);
}
for (i = 0; i < n; i++) {
if (!used[i]) {
dfs(i);
ans += p.size() - ma;
ma = 0;
co.clear();
p.clear();
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535;
long long powi(long long base, int p) {
long long res = 1;
while (p--) res *= base;
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
bool is_vowel(char c) {
c = tolower(c);
return c == 'a' || c == 'e' || c == 'o' || c == 'i' || c == 'u' || c == 'y';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int k;
cin >> k;
cout << "+------------------------+\n";
cout << '|';
cout << (k > 0 ? 'O' : '#') << '.';
for (int i = 1; i <= 10; i++)
cout << ((k - 4 + 2) / 3 >= i ? 'O' : '#') << '.';
cout << "|D|)\n";
cout << '|';
cout << (k > 1 ? 'O' : '#') << '.';
for (int i = 1; i <= 10; i++)
cout << ((k - 4 + 1) / 3 >= i ? 'O' : '#') << '.';
cout << "|.|\n";
cout << '|';
cout << (k > 2 ? 'O' : '#') << '.';
for (int i = 1; i <= 10; i++) cout << "..";
cout << "..|\n";
cout << '|';
cout << (k > 3 ? 'O' : '#') << '.';
for (int i = 1; i <= 10; i++) {
cout << ((k - 4) / 3 >= i ? 'O' : '#') << '.';
}
cout << "|.|)\n";
cout << "+------------------------+";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int gridSize = 1000;
long long getPairs(int n) {
long long result = 0;
for (int i = 1; i < n; i++) result += n - i;
return result;
}
int main() {
std::cout.sync_with_stdio(false);
int n, i, x, y, j;
cin >> n;
bool a[gridSize + 1][gridSize + 1];
for (i = 1; i <= gridSize; i++)
for (j = 1; j <= gridSize; j++) a[i][j] = false;
for (i = 0; i < n; i++) {
cin >> x >> y;
a[x][y] = true;
}
long long result = 0, attacking = 0;
pair<int, int> startPoint(1, 1);
for (i = 1; i <= gridSize; i++) {
attacking = 0;
startPoint = make_pair(1, i);
do {
if (a[startPoint.first][startPoint.second]) attacking++;
startPoint.second++;
startPoint.first++;
} while (startPoint.second <= gridSize && startPoint.first <= gridSize);
if (attacking > 1) result += getPairs(attacking);
}
for (i = 2; i <= gridSize; i++) {
attacking = 0;
startPoint = make_pair(i, 1);
do {
if (a[startPoint.first][startPoint.second]) attacking++;
startPoint.second++;
startPoint.first++;
} while (startPoint.second <= gridSize && startPoint.first <= gridSize);
if (attacking > 1) result += getPairs(attacking);
}
for (i = gridSize; i >= 1; i--) {
attacking = 0;
startPoint = make_pair(1, i);
do {
if (a[startPoint.first][startPoint.second]) attacking++;
startPoint.second--;
startPoint.first++;
} while (startPoint.second >= 1 && startPoint.first <= gridSize);
if (attacking > 1) result += getPairs(attacking);
}
for (i = 2; i <= gridSize; i++) {
attacking = 0;
startPoint = make_pair(i, gridSize);
do {
if (a[startPoint.first][startPoint.second]) attacking++;
startPoint.second--;
startPoint.first++;
} while (startPoint.second >= 1 && startPoint.first <= gridSize);
if (attacking > 1) result += getPairs(attacking);
}
cout << result;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> m1;
int main() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
m1[a[i]] = 1;
}
long long m;
cin >> m;
long long b[m];
for (long long i = 0; i < m; i++) {
cin >> b[i];
m1[b[i]] = 1;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (m1[a[i] + b[j]] != 1) {
cout << a[i] << " " << b[j];
return 0;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n;
int T, l, r, ans, mid;
pair<int, int> a[maxn];
int todo[maxn], top;
long long s;
bool check(int mid) {
long long ss = s;
int tot = 0, top = 0;
for (int i = 0; i < n; i++) {
if (a[i].second >= mid) {
if (a[i].first >= mid)
tot++;
else
todo[top++] = mid - a[i].first;
}
}
sort(todo, todo + top);
for (int i = 0; i < top && ss >= todo[i]; i++) {
tot++;
ss -= todo[i];
}
return tot * 2 > n;
}
int main() {
cin >> T;
while (T--) {
cin >> n >> s;
for (int i = 0; i < n; i++) {
scanf("%d%d", &l, &r);
a[i] = pair<int, int>(l, r);
s -= l;
}
l = 0, r = 1e9;
ans = 0;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
ans = mid, l = mid + 1;
else
r = mid - 1;
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int p, int q) {
int temp;
while (p != 0) {
temp = p;
p = q % p;
q = temp;
}
return q;
}
int main() {
int n, m, i, a[105], b[105], hcf;
cin >> n >> m;
for (i = 0; i <= n; i++) cin >> a[i];
for (i = 0; i <= m; i++) cin >> b[i];
if (n == m) {
hcf = gcd(fabs(a[0]), fabs(b[0]));
if ((a[0] < 0 && b[0] > 0) || (a[0] > 0 && b[0] < 0)) {
cout << "-" << fabs(a[0] / hcf) << "/" << fabs(b[0] / hcf);
return 0;
} else {
cout << fabs(a[0] / hcf) << "/" << fabs(b[0] / hcf);
return 0;
}
} else if (n < m) {
cout << "0/1";
return 0;
} else {
if ((a[0] < 0 && b[0] > 0) || (a[0] > 0 && b[0] < 0)) {
cout << "-"
<< "Infinity";
return 0;
} else {
cout << "Infinity";
return 0;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int inf = 1e9 + 9;
const long long int MOD = 1e9 + 696969;
const long long INF = 4LL * 1000000LL * 1000000LL * 1000000LL;
template <class T>
int size(T &&x) {
return int(x.size());
}
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template <class T>
auto operator<<(ostream &out, T &&x) -> decltype(x.begin(), out) {
out << '{';
for (auto it = x.begin(); it != x.end(); ++it)
out << *it << (it == prev(x.end()) ? "" : ", ");
return out << '}';
}
void dump() {}
template <class T, class... Args>
void dump(T &&x, Args... args) {
cerr << x << "; ";
dump(args...);
}
mt19937_64 rng(0);
int random(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
inline void addmod(int &x, int val) {
x += val;
while (x >= mod) x -= mod;
}
const int maxn = 200100;
bool poss(int i, pair<int, int> stan1, int j, pair<int, int> stan2) {
assert(i <= j);
if (i == j) {
return stan1 == stan2;
}
int dst = j - i - 1;
if (stan1.first == stan2.first) {
return (stan1.second + dst + 1 == stan2.second);
} else {
int must_be = (stan1.second == 1 ? 1 : 0);
int more_copies = 5 - stan1.second - must_be;
must_be += stan2.second - 1;
int MIN = must_be + (stan2.first - stan1.first - 1) * 2;
int MAX = more_copies + must_be + (stan2.first - stan1.first - 1) * 5;
return (MIN <= dst && dst <= MAX);
}
}
int nast(int i, pair<int, int> stan1, int j, pair<int, int> stan2) {
assert(i <= j);
if (i == j) return stan1.first;
if (stan1.first == stan2.first) return stan1.first;
int value = stan1.first;
if (stan1.second != 5) {
if (poss(i + 1, make_pair(value, stan1.second + 1), j, stan2)) return value;
}
return value + 1;
}
int n;
vector<int> pos;
bool dp[maxn][6];
int tab[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
pos.push_back(0);
dp[0][5] = 1;
int lt = 0;
for (int i = 1; i <= n; ++i) {
cin >> tab[i];
if (tab[i] > 0) {
pos.push_back(i);
lt = i;
}
}
int sz = pos.size();
for (int i = 0; i + 1 < sz; ++i) {
int lewe = pos[i], prawe = pos[i + 1];
for (int a = 1; a <= 5; ++a) {
if (dp[lewe][a]) {
for (int b = 1; b <= 5; ++b) {
if (poss(lewe, {tab[lewe], a}, prawe, {tab[prawe], b})) {
0 && cerr;
dp[prawe][b] = 1;
}
}
}
}
}
bool odp = false, ans = false;
int ka = 0;
if (tab[n] == 0) {
for (int value = n; value > 0; --value) {
for (int a = 1; a <= 5; ++a) {
for (int b = 2; b <= 5; ++b) {
if (!ans && dp[lt][a] && poss(lt, {tab[lt], a}, n, {value, b})) {
tab[n] = value;
dp[n][b] = true;
pos.push_back(n);
ans = true;
}
}
}
}
}
for (int a = 2; a <= 5; ++a)
if (dp[n][a]) odp = true, ka = a;
if (!odp) {
cout << "-1";
exit(0);
};
sz = pos.size();
for (int i = sz - 2; i >= 0; --i) {
int lewe = pos[i], prawe = pos[i + 1];
for (int a = 1; a <= 5; ++a) {
if (!dp[lewe][a]) continue;
if (poss(lewe, {tab[lewe], a}, prawe, {tab[prawe], ka})) {
int kal = a;
for (int ruch = lewe; ruch + 1 < prawe; ++ruch) {
int wstawie = nast(ruch, {tab[ruch], kal}, prawe, {tab[prawe], ka});
if (wstawie == tab[ruch])
++kal;
else
kal = 1;
tab[ruch + 1] = wstawie;
}
ka = a;
break;
}
}
}
cout << tab[n] << "\n";
for (int i = 1; i <= n; ++i) cout << tab[i] << ' ';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, w;
bool g[444][444];
double x, y;
double dx[5], dy[5];
complex<double> deg(int d) {
return exp(complex<double>(0, d / 180. * acos(-1.)));
}
int o[9999], l;
void dfs(int x) {
for (int i = 1; i <= w; i++)
if (g[x][i]) {
g[x][i] = g[i][x] = false;
dfs(i);
}
o[l++] = x;
}
int main() {
complex<double> a[5];
double L = 5 / sin(acos(-1.) / 5);
a[1] = deg(90);
a[4] = deg(90 - 72);
a[3] = deg(90 - 72 - 72 + 360);
a[2] = deg(90 - 72 - 72 - 72 + 360);
a[0] = deg(90 + 72);
for (int i = 0; i < 5; i++) {
dx[i] = (a[i].real() - a[0].real()) * L;
dy[i] = (a[i].imag() - a[0].imag()) * L;
}
scanf("%d", &n);
x = y = 0;
printf("%d\n", n * 4 + 1);
w = 1;
printf("0 0\n");
for (int i = 0; i < n; i++) {
g[w + 1][w + 2] = true;
g[w + 2][w + 1] = true;
g[w + 2][w + 4] = true;
g[w + 4][w + 2] = true;
g[w + 4][w] = true;
g[w][w + 4] = true;
g[w][w + 3] = true;
g[w + 3][w] = true;
g[w + 3][w + 1] = true;
g[w + 1][w + 3] = true;
for (int i = 1; i <= 4; i++)
printf("%.19lf %.19lf\n", x + dx[i], y + dy[i]);
x += dx[4];
y += dy[4];
w += 4;
}
w = 1;
for (int i = 1; i <= n; i++) {
printf("%d %d %d %d %d\n", w, w + 2, w + 3, w + 4, w + 1);
w += 4;
}
dfs(1);
for (int i = 0; i < l; i++) printf("%d%c", o[i], i < l - 1 ? ' ' : '\n');
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, y;
scanf("%lld %lld %lld", &n, &x, &y);
vector<pair<long long, long long> > shows(n);
for (int i = 0; i < n; i++) {
pair<long long, long long> next;
scanf("%lld %lld", &next.first, &next.second);
shows[i] = next;
}
sort((shows).begin(), (shows).end());
long long gasto = 0;
multiset<long long> finais;
for (int i = 0; i < n; i++) {
pair<long long, long long> next = shows[i];
if (int(finais.size()) == 0) {
gasto += x + y * (next.second - next.first);
gasto %= 1000000007;
finais.insert(next.second);
continue;
}
auto it = finais.lower_bound(next.first);
while (it != finais.begin() && *it >= next.first) {
it--;
}
if (it == finais.begin() && *it >= next.first) {
gasto += x + y * (next.second - next.first);
gasto %= 1000000007;
finais.insert(next.second);
continue;
} else {
if ((next.first - *it) * y < x) {
long long val = *it;
gasto += (next.second - val) * y;
gasto %= 1000000007;
finais.erase(it);
finais.insert(next.second);
} else {
gasto += x + y * (next.second - next.first);
gasto %= 1000000007;
finais.insert(next.second);
}
}
}
cout << gasto << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long k, qzh[100005], val[100005], l, r, mid, ans;
long long n, i, j, a[100005], seq[100005], rk[100005], rt[100005], lc[5000005],
rc[5000005];
long long mx[100005][19], mi[100005][19];
long long lg[100005], cnt, pr[100005], cov[100005];
bool cmp(long long x, long long y) { return qzh[x] < qzh[y]; }
long long querymx(long long l, long long r) {
long long ans = -0x3f3f3f3f3f3f3f3fll;
if (l < 1) {
ans = 0;
l++;
}
if (l <= r) {
long long t = lg[r - l + 1];
return max(ans, max(mx[l][t], mx[r - (1 << t) + 1][t]));
}
return ans;
}
long long querymi(long long l, long long r) {
long long ans = 0x3f3f3f3f3f3f3f3fll;
if (l < 1) {
ans = 0;
l++;
}
if (l <= r) {
long long t = lg[r - l + 1];
return min(ans, min(mi[l][t], mi[r - (1 << t) + 1][t]));
}
return ans;
}
struct seg {
long long sum;
long long sz, mx;
} s[5000005];
void update(long long &x, long long l, long long r, long long y) {
cnt++;
s[cnt] = s[x];
lc[cnt] = lc[x];
rc[cnt] = rc[x];
x = cnt;
s[x].sz++;
s[x].mx = max(s[x].mx, seq[y]);
s[x].sum += val[y];
if (l == r) return;
long long mid = (l + r) / 2;
if (y <= mid)
update(lc[x], l, mid, y);
else
update(rc[x], mid + 1, r, y);
}
seg tmp;
void query(long long x, long long l, long long r, long long v) {
if (!x) return;
if (val[l] > v) {
tmp.mx = max(tmp.mx, s[x].mx);
tmp.sz += s[x].sz;
tmp.sum += s[x].sum;
return;
}
if (l == r) return;
long long mid = (l + r) / 2;
if (v < val[mid]) query(lc[x], l, mid, v);
query(rc[x], mid + 1, r, v);
}
struct ii {
long long ans;
long long cnt;
} dp[100005];
struct itv {
long long l, r;
} ss[100005];
ii solve(long long d) {
ii ans = (ii){0, 0};
long long i;
memset(pr, 0, sizeof(pr));
for ((i) = (n); (i) >= 1; --(i)) {
tmp = (seg){0, 0, 0};
query(rt[i], 1, n, qzh[i - 1] - d);
pr[i] = tmp.mx;
ans.ans += tmp.sum - (qzh[i - 1] - d) * tmp.sz;
ans.cnt += tmp.sz;
}
memset(cov, 0, sizeof(cov));
long long lst = 0;
for ((i) = 1; (i) <= (n); ++(i)) {
if (pr[i] > lst) {
lst = max(lst, i - 1);
while (lst < pr[i]) {
cov[++lst] = 1;
}
}
}
long long cc = 0;
if (!cov[1]) ss[++cc] = (itv){1, 0};
for ((i) = 1; (i) <= (n); ++(i)) {
if (cov[i]) {
if (i == 1 || !cov[i - 1]) ss[++cc] = (itv){i, 0};
if (i == n || !cov[i + 1]) ss[cc].r = i;
} else {
if (i > 1 && !cov[i - 1]) {
ss[++cc] = (itv){i + 1, i};
}
}
}
if (!cov[n]) ss[++cc] = (itv){n + 1, n};
if (cc == 1) return ans;
ii mx = (ii){-0x3f3f3f3f3f3f3f3fll, 0};
for ((i) = 1; (i) <= (cc); ++(i)) {
if (i == 1)
dp[i] = (ii){0, 0};
else {
dp[i].ans = mx.ans + querymx(ss[i].l - 1, ss[i].r) + d;
dp[i].cnt = mx.cnt + 1;
}
ii t;
t.ans = dp[i].ans - querymi(ss[i].l - 1, ss[i].r);
t.cnt = dp[i].cnt;
if (t.ans > mx.ans || t.ans == mx.ans && t.cnt < mx.cnt) {
mx = t;
}
}
return (ii){ans.ans + dp[cc].ans, ans.cnt + dp[cc].cnt};
}
signed main() {
for ((i) = (2); (i) <= (100000); ++(i)) lg[i] = lg[i / 2] + 1;
scanf("%lld%lld", &n, &k);
for ((i) = 1; (i) <= (n); ++(i)) {
scanf("%lld", &a[i]);
qzh[i] = qzh[i - 1] + a[i];
seq[i] = i;
}
sort(seq + 1, seq + n + 1, cmp);
for ((i) = 1; (i) <= (n); ++(i)) {
rk[seq[i]] = i;
val[i] = qzh[seq[i]];
}
for ((i) = (n); (i) >= 1; --(i)) {
rt[i] = rt[i + 1];
update(rt[i], 1, n, rk[i]);
}
for ((i) = 1; (i) <= (n); ++(i)) mi[i][0] = mx[i][0] = qzh[i];
for ((j) = 1; (j) <= (18); ++(j))
for ((i) = 1; (i) <= (n - (1 << j) + 1); ++(i)) {
mi[i][j] = min(mi[i][j - 1], mi[i + (1 << (j - 1))][j - 1]);
mx[i][j] = max(mx[i][j - 1], mx[i + (1 << (j - 1))][j - 1]);
}
solve(3);
l = -1e15;
r = 1e15;
while (l < r) {
mid = (l + r) >> 1;
ii s = solve(mid);
if (s.cnt <= k) {
l = mid + 1;
ans = s.ans - 1ll * k * mid;
} else {
r = mid;
}
}
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct Bag {
int linker;
int node;
int distance;
Bag() { linker = node = distance = 0; }
};
int n;
int parent[200005], depth[200005];
vector<int> g[200005];
Bag bags[2];
int low[200005], high[200005];
int ind;
vector<int> layerNodes[200005];
void dfs(int node) {
layerNodes[depth[node]].push_back(node);
low[node] = ind;
for (int i = 0; i < int(g[node].size()); i++) dfs(g[node][i]);
high[node] = ind++;
}
bool isAncestor(int parent, int node) {
return low[parent] <= high[node] && high[node] <= high[parent];
}
int getParent(int node, int layer) {
int start = -1;
int end = layerNodes[layer].size();
while (end - start > 1) {
int mid = (end + start) >> 1;
if (high[node] < low[layerNodes[layer][mid]])
end = mid;
else
start = mid;
}
return layerNodes[layer][start];
}
int lca(int u, int v) {
int start = -1;
int end = min(depth[u], depth[v]) + 1;
while (end - start > 1) {
int mid = (end + start) >> 1;
int lca = getParent(u, mid);
if (isAncestor(lca, v))
start = mid;
else
end = mid;
}
return getParent(u, start);
}
int getDistance(int u, int v) {
int w = lca(u, v);
return depth[u] + depth[v] - 2 * depth[w];
}
int getLink(int centerNode, int newNode) {
if (!isAncestor(centerNode, newNode)) return parent[centerNode];
int start = -1;
int end = g[centerNode].size();
while (end - start > 1) {
int mid = (end + start) >> 1;
if (high[newNode] < low[g[centerNode][mid]])
end = mid;
else
start = mid;
}
return g[centerNode][start];
}
int main() {
ios::sync_with_stdio(false);
scanf("%d", &n);
parent[0] = -1;
for (int i = 1; i < n; i++) {
scanf("%d", parent + i);
--parent[i];
g[parent[i]].push_back(i);
depth[i] = 1 + depth[parent[i]];
}
dfs(0);
int curCenter = 0;
for (int i = 1; i < n; i++) {
int newNode = i;
int newDistance = getDistance(curCenter, newNode);
int linker = getLink(curCenter, newNode);
if (linker == bags[0].linker) {
if (newDistance > bags[0].distance) {
bags[0].distance = newDistance;
bags[0].node = newNode;
}
} else if (linker == bags[1].linker) {
if (newDistance > bags[1].distance) {
bags[1].distance = newDistance;
bags[1].node = newNode;
}
} else if (newDistance > bags[0].distance) {
bags[1] = bags[0];
bags[0].linker = linker;
bags[0].node = newNode;
bags[0].distance = newDistance;
} else if (newDistance > bags[1].distance) {
bags[1].linker = linker;
bags[1].node = newNode;
bags[1].distance = newDistance;
}
if (bags[1].distance > bags[0].distance) swap(bags[0], bags[1]);
if (bags[0].distance - bags[1].distance > 1 && bags[1].distance != 0) {
int oldCenter = curCenter;
curCenter = bags[0].linker;
bags[0].linker = getLink(curCenter, bags[0].node);
bags[0].distance -= 1;
bags[1].linker = oldCenter;
bags[1].distance += 1;
}
printf("%d ", bags[0].distance + bags[1].distance);
}
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
char c[20];
long long dp[20][20][2], a[20], ans;
int n;
void dfs(int x, int m, long long re) {
if (x == 6) {
ans = (ans + re) % 1000000007;
return;
}
for (int i = 0; i < m && i <= n; i++) {
if (a[i]) {
a[i]--;
dfs(x + 1, m - i, (re * (a[i] + 1)) % 1000000007);
a[i]++;
}
}
}
int main() {
int i, j, k;
scanf("%s", c);
n = strlen(c);
dp[0][0][1] = 1;
for (k = 0; c[k]; k++) {
for (i = 0; i <= k; i++) {
for (j = 0; j < 10; j++) {
if (j == 4 || j == 7) {
dp[k + 1][i + 1][0] += dp[k][i][0];
} else {
dp[k + 1][i][0] += dp[k][i][0];
}
}
for (j = 0; j < c[k] - '0'; j++) {
if (j == 4 || j == 7) {
dp[k + 1][i + 1][0] += dp[k][i][1];
} else {
dp[k + 1][i][0] += dp[k][i][1];
}
}
if (j == 4 || j == 7) {
dp[k + 1][i + 1][1] += dp[k][i][1];
} else {
dp[k + 1][i][1] += dp[k][i][1];
}
}
}
for (i = 0; i <= n; i++) {
a[i] = dp[n][i][0] + dp[n][i][1];
}
a[0]--;
for (i = 1; i <= n; i++) {
if (a[i]) {
a[i]--;
dfs(0, i, a[i] + 1);
a[i]++;
}
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, d;
cin >> n >> d;
vector<pair<long long int, long long int>> friends(n);
vector<long long int> prefix(n);
vector<long long int> results;
results.reserve(n);
for (auto&& _friend : friends) cin >> _friend.first >> _friend.second;
sort(friends.begin(), friends.end());
prefix[0] = friends[0].second;
for (long long int i = 1; i < n; i++)
prefix[i] = prefix[i - 1] + friends[i].second;
for (long long int i = 0; i < n; i++) {
long long int l_min = i, r_max;
long long int l = i, r = n - 1;
while (r >= l) {
long long int m = (l + r) / 2;
if (friends[m].first >= friends[i].first + d) {
r = m - 1;
} else {
l = m + 1;
}
}
r_max = l - 1;
if (l_min == 0)
results.push_back(prefix[r_max]);
else
results.push_back(prefix[r_max] - prefix[l_min - 1]);
}
long long int _max = -1;
for (auto&& result : results)
if (result > _max) _max = result;
cout << _max;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100010;
char a[M];
set<char> myset;
int main() {
int n;
while (~scanf("%d%s", &n, a)) {
int ans = 0;
int la = strlen(a);
for (int i = n; i < la; i += n) {
if (a[i - 3] == a[i - 2] && a[i - 2] == a[i - 1]) ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define db(x) cout << #x << "=" << x << endl
#define li(i, n) for (ll i = 0; i < n; i++)
#define ld(i, k, n) for (ll i = k; k < n ? i < n : i > n; k < n ? i += 1 : i -= 1)
#define lc(i, v) for (auto i : v)
#define db3(a) \
cout << "container:" << endl; \
for (auto i : a) \
cout << i << endl; \
cout << endl
#define db4(a) \
cout << "container:" << endl; \
for (auto i : a) \
cout << i.first << " " << i.second << endl; \
cout << endl
#define db0(x) cout << #x << endl
#define lv(type, name, it) for (vector<type>::iterator it = name.begin(); it < name.end(); it++)
#define db2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define pb push_back
#define mod 1000000007
#define el "\n"
#define rs(vec, size) vec.reserve(size)
#define rr(c) c.begin(), c.end()
#define inf LONG_LONG_MAX
#define F first
#define S second
#define pp(a) cout << fixed << setprecision(a);
typedef long long ll;
typedef vector<ll> vi;
typedef vector<vector<ll>> vvi;
vi invi(ll n)
{
ll x;
vi a;
li(i, n)
{
cin >> x;
a.pb(x);
}
return a;
}
vector<bool> prime;
void checkPrime(ll n)
{
li(i, n + 1)
{
prime.push_back(true);
}
prime[0] = false;
prime[1] = false;
for (ll p = 2; p * p <= n; p++)
{
if (prime[p] == true)
{
for (ll i = p * p; i <= n; i += p)
prime[i] = false;
}
}
}
//======function here=====================================================
//=========================================================================
void solve();
int main()
{
#ifndef ONLINE_JUDGE
freopen(".input.txt", "r", stdin);
freopen(".output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
// cin >> t;
while (t--)
{
solve();
}
}
void solve()
{
ll n;
cin >> n;
//check t
vi a=invi(n);
priority_queue<ll> hold;
ll cnt=0,h=0;
li(i,n)
{
if(a[i]<0)
{
hold.push((-1*a[i]));
}
h+=a[i];
cnt++;
if(h<0)
{
h+=hold.top() ;
hold.pop();
cnt--;
}
}
cout<<cnt<<el;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, d;
cin >> n >> d;
long long int x, y, t1, t2;
cin >> x >> y;
vector<int> ans;
vector<pair<int, int> > a(n + 2);
for (int i = 0; i < n; i++) {
cin >> t1 >> t2;
a[i].first = t1 * x + t2 * y;
a[i].second = i + 1;
}
sort(a.begin(), a.begin() + n);
int i = 0;
while (d >= 0 && i < n) {
if (d >= a[i].first) {
d = d - a[i].first;
ans.push_back(a[i].second);
i++;
} else {
break;
}
}
cout << i << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans.at(i) << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N = 1e5 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
int n, sz[N];
vector<int> G[N];
double f[N];
void dfs1(int u) {
sz[u] = 1;
for (int v : G[u]) {
dfs1(v);
sz[u] += sz[v];
}
}
void dfs2(int u) {
for (int v : G[u]) {
f[v] = f[u] + 1 + (sz[u] - sz[v] - 1) * 0.5;
dfs2(v);
}
}
int main() {
ios_base::sync_with_stdio(0);
clock_t _ = clock();
while (scanf("%d", &n) == 1) {
for (int i = 1; i <= n; ++i) G[i].clear();
for (int i = 2; i <= n; ++i) {
int f;
scanf("%d", &f);
G[f].push_back(i);
}
dfs1(1);
f[1] = 1;
dfs2(1);
for (int i = 1; i <= n; ++i) printf("%.1f%c", f[i], " \n"[i == n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s, p;
int lps[200001];
void compute_lps() {
int idx = 0;
for (int i = 1; i < p.size();) {
if (p[i] == p[idx])
lps[i] = idx + 1, idx++, i++;
else {
if (idx)
idx = lps[idx - 1];
else
lps[i] = 0, i++;
}
}
}
long long a[200001], q1[200001], q2[200001];
long long ans = 0;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> s >> p;
int start = p.size() + 1;
p += '$';
p += s;
compute_lps();
int idx = 1;
for (int i = start; i < p.size(); i++) {
if (lps[i] != start - 1)
a[i] = a[i - 1];
else
a[i] = idx - (start - 1) + 1 + q2[i - (start - 1)];
a[i] %= 1000000007;
q1[i] = q1[i - 1] + a[i];
q1[i] %= 1000000007;
q2[i] = q2[i - 1] + q1[i];
q2[i] %= 1000000007;
ans += a[i];
ans %= 1000000007;
idx++;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
const int maxn = (int)1e5 + 5;
int n;
long long a[maxn];
bool read() {
if (scanf("%d", &n) < 1) {
return false;
}
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
return true;
}
const int maxb = 60;
pair<long long, int> b[maxn], c[maxn];
int dp[maxn], ndp[maxn];
int cnt[maxn];
void solve() {
for (int i = 0; i < n; i++) {
dp[i] = i;
}
dp[n] = 0;
for (int i = 0; i < n; i++) {
c[i] = make_pair(a[i], i);
}
sort(c, c + n);
for (int bit = maxb - 1; bit >= 0; bit--) {
for (int i = 0; i < n; i++) {
b[i] = make_pair((a[i] & ((1ll << bit) - 1)), i);
}
sort(b, b + n);
cnt[0] = 0;
for (int i = 0; i < n; i++) {
int id = b[i].second;
cnt[i + 1] = cnt[i] + ((a[id] >> bit) & 1);
}
b[n].first = (1ll << bit);
for (int i = 0; i <= n; i++) {
int x = cnt[i] + ((n - i) - (cnt[n] - cnt[i]));
int j = lower_bound(c, c + n, make_pair(b[i].first, -1)) - c;
ndp[i] = dp[j] + x;
j = lower_bound(c, c + n, make_pair(b[i].first + (1ll << bit), -1)) - c;
ndp[i] = min(ndp[i], dp[j] + n - x);
}
swap(b, c);
swap(dp, ndp);
}
printf("%d\n", dp[n]);
}
int main() {
precalc();
while (read()) {
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 10000000;
int main() {
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long tek = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (tek < a[i]) {
ans += a[i] - tek;
tek = a[i];
}
ans++;
if (i != n - 1) {
if (tek > a[i + 1]) {
ans += tek - a[i + 1];
tek = a[i + 1];
}
ans++;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return 0;
return 1;
}
long long n, x;
vector<long long> fact, prim;
long long pow(long long a, long long p) {
if (!p) return 1;
long long x = pow(a, p / 2);
if (p % 2) return x * x % n * a % n;
return x * x % n;
}
int main() {
cin >> n >> x;
if (n == 1) {
if (x == 2) cout << '-';
cout << x - 1;
return 0;
}
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
fact.push_back(i);
fact.push_back(n / i);
}
}
n++;
if (!isPrime(n)) {
cout << "-1\n";
return 0;
}
for (int i = n + x % n - 1; i > x % n - 1; i--) {
for (int j = 0; j < fact.size(); j++) {
if (pow(i % n, fact[j]) == 1) break;
if (j + 1 == fact.size()) {
if ((x - i % n) / n * n + i % n == 0)
cout << "-1\n";
else
cout << (x - i % n) / n * n + i % n;
return 0;
}
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN();
int main() {
int a, b;
scanf("%d%d", &a, &b);
int maxa = 0, maxb = 0, t;
t = a;
while (t) {
maxa = max(maxa, t % 10);
t /= 10;
}
t = b;
while (t) {
maxb = max(maxb, t % 10);
t /= 10;
}
int base = max(maxa, maxb) + 1, mul, sum = 0;
mul = 1;
while (a) {
sum += (a % 10 * mul);
a /= 10;
mul *= base;
}
mul = 1;
while (b) {
sum += (b % 10 * mul);
b /= 10;
mul *= base;
}
int ans = 0;
while (sum) {
ans++;
sum /= base;
}
printf("%d", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[100], sum1 = 0, sum2 = 0, n, x1, x2, y1, y2, k = 0;
for (int i = 1; i <= 3; i++) {
scanf("%d", &a[i]);
sum1 += a[i];
}
for (int i = 1; i <= 3; i++) {
scanf("%d", &a[i]);
sum2 += a[i];
}
scanf("%d", &n);
x1 = sum1 / 5;
x2 = sum1 % 5;
y1 = sum2 / 10;
y2 = sum2 % 10;
if (x2 > 0) k++;
if (y2 > 0) k++;
k += x1 + y1;
if (k > n)
printf("NO\n");
else {
printf("YES\n");
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int a, b;
while (scanf("%d%d", &a, &b) == 2) {
if (a < b) {
puts("-1");
} else {
double n = (a - b) / (2 * b);
printf("%.12f\n", b + (a - (2.0 * n + 1.0) * b) / (2.0 * n + 2.0));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct solution_dag {
vector<vector<int> > v;
int path_12;
solution_dag() {
v = vector<vector<int> >(4);
v[0].push_back(2);
v[2].push_back(3);
v[3].push_back(1);
path_12 = 3;
}
void pow(int P) {
int A = v[0][0];
v[0].clear();
int B = add_node();
v[0].push_back(B);
for (int i = 0; i < P; i++) {
int C = add_node();
v[B].push_back(C);
v[C].push_back(A);
}
path_12 += 2;
}
void plus_k(int k) {
int A = v[0][0];
if (path_12 == 3) {
for (int i = 0; i < k; i++) {
int temp = add_node();
v[A].push_back(temp);
v[temp].push_back(1);
}
} else {
int prev = add_node();
for (int i = 0; i < k; i++) {
int temp = add_node();
v[A].push_back(temp);
v[temp].push_back(prev);
}
for (int i = 0; i < path_12 - 4; i++) {
int next = add_node();
v[prev].push_back(next);
prev = next;
}
v[prev].push_back(1);
}
}
int add_node(void) {
int res = v.size();
v.push_back(vector<int>());
return res;
}
};
const int MX = 1009;
bool ans[MX][MX];
const int LG = 32;
int k_digs[LG];
const int MOD = 7;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
int k;
cin >> k;
for (int i = 0; i < LG; i++) {
k_digs[i] = k % MOD;
k /= MOD;
}
int it = LG - 1;
while (k_digs[it] == 0) {
it--;
}
solution_dag D;
if (k_digs[it] != 1) D.plus_k(k_digs[it] - 1);
it--;
while (it >= 0) {
if (k_digs[it] != 0) {
D.pow(MOD);
D.plus_k(k_digs[it]);
} else {
D.pow(MOD);
}
it--;
}
int n = D.v.size();
cout << n << '\n';
assert(n <= 1000);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) ans[i][j] = false;
for (int i = 0; i < n; i++) {
for (size_t j = 0; j < D.v[i].size(); j++) {
int k = D.v[i][j];
ans[i][k] = true;
ans[k][i] = true;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << (ans[i][j] ? 'Y' : 'N');
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int v[510][5010];
struct lenka {
int len, mod, sum;
char s[600];
lenka() {
len = -1;
mod = sum = 0;
memset(s, 0, sizeof s);
}
};
int main() {
int d, s;
cin >> d >> s;
queue<lenka> p;
lenka now;
p.push(now);
while (!p.empty()) {
now = p.front();
p.pop();
for (int i = 0; i <= 9; i++) {
lenka nex = now;
nex.len++;
nex.s[nex.len] = i + '0';
nex.mod = (nex.mod * 10 + i) % d;
nex.sum += i;
if (v[nex.mod][nex.sum] || nex.sum > s) continue;
v[nex.mod][nex.sum] = 1;
if (nex.mod == 0 && nex.sum == s) {
puts(nex.s);
return 0;
}
p.push(nex);
}
}
puts("-1");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return a.first < b.first;
}
bool check(int a) {
int sum = 0;
while (a > 0) {
sum += (a % 10);
a /= 10;
}
if (sum == 10) return true;
return false;
}
bool prime[10005];
void seivertexe() {
memset(prime, 1, sizeof(prime));
prime[0] = 0;
prime[1] = 0;
for (long long int i = 2; i <= 10000; i++) {
if (prime[i] == 1) {
for (long long int j = i * i; j <= 10000; j += i) prime[j] = 0;
}
}
}
template <typename T>
std::string NumberToString(T Number) {
std::ostringstream ss;
ss << Number;
return ss.str();
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int power(long long int x, long long int y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return (power(x, y / 2) % 1000000007 * power(x, y / 2) % 1000000007) %
1000000007;
else
return (x % 1000000007 *
(power(x, y / 2) % 1000000007 * power(x, y / 2) % 1000000007) %
1000000007) %
1000000007;
}
long long int factorial1(long long int n) {
return (n == 1 || n == 0)
? 1
: (n % 1000000007 * factorial1(n - 1) % 1000000007) % 1000000007;
}
long long int fact(long long int n);
long long int nCr(long long int n, long long int r) {
return fact(n) % 1000000007 /
((fact(r) % 1000000007 * fact(n - r) % 1000000007)) % 1000000007;
}
long long int fact(long long int n) {
long long int res = 1;
for (int i = 2; i <= n; i++) res = (res * i) % 1000000007;
return res % 1000000007;
}
void solve() {}
struct pr {
long long int a;
long long int t;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
string second;
cin >> second;
long long int p[m + 1];
long long int last[26] = {0};
for (long long int i = 0; i < m; i++) {
cin >> p[i];
}
long long int count[26] = {0};
vector<vector<long long int> > v(n + 100);
for (int i = 0; i < n; i++) {
count[second[i] - 'a']++;
last[second[i] - 'a']++;
for (long long int j = 0; j < 26; j++) {
v[i].push_back(count[j]);
}
}
long long int k = 0;
long long int acc[26] = {0};
for (long long int i = 0; i < m; i++) {
k = 0;
p[i]--;
for (auto it = v[p[i]].begin(); it != v[p[i]].end(); it++) {
acc[k++] += (*it);
}
}
for (int i = 0; i < 26; i++) {
acc[i] += last[i];
}
for (int i = 0; i < 26; i++) {
cout << acc[i] << " ";
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void readInputData();
void run();
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
readInputData();
run();
return 0;
}
int x;
bool used[10];
void readInputData() { cin >> x; }
bool isEq(int a, int b) {
memset(used, false, sizeof(used));
while (a > 0) {
used[a % 10] = true;
a /= 10;
}
while (b > 0) {
if (used[b % 10]) return true;
b /= 10;
}
return false;
}
void run() {
int answer = 0;
for (int d = 1; d <= (int)sqrt(x); d++) {
if (x % d == 0) {
answer += isEq(x, d);
answer += isEq(x, x / d) && (d != x / d);
}
}
cout << answer << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int A[110000], len;
map<int, int> M[110000];
int gox[4] = {1, 0, -1, 0}, goy[4] = {0, 1, 0, -1};
int check(int k1, int k2) { return k1 >= 1 && k1 <= n && k2 >= 1 && k2 <= m; }
int getw(int k1, int k2) { return (k1 - 1) * m + k2; }
int connect(int k1, int k2) { return M[k1][k2]; }
int qua(int k1, int k2) {
for (int i = 0; i < 4; i++)
if (check(k1 + gox[i], k2 + goy[i]) &&
connect(A[getw(k1, k2)], A[getw(k1 + gox[i], k2 + goy[i])]))
return 0;
return 1;
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
len = 0;
for (int i = 1; i <= n * m; i++) M[i].clear();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 0; k < 4; k++)
if (check(i + gox[k], j + goy[k]))
M[getw(i, j)][getw(i + gox[k], j + goy[k])] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) A[getw(i, j)] = (i - 1) * m + j;
}
for (int i = 1; i <= n; i++)
if (i & 1) {
int num = A[getw(i, 1)];
for (int j = 1; j < m; j++) A[getw(i, j)] = A[getw(i, j + 1)];
A[getw(i, m)] = num;
}
if (n < m)
for (int i = 1; i <= n; i++)
if (i & 1) {
int num = A[getw(i, 1)];
for (int j = 1; j < m; j++) A[getw(i, j)] = A[getw(i, j + 1)];
A[getw(i, m)] = num;
}
for (int i = 1; i <= m; i++)
if (i & 1) {
int num = A[getw(n, i)];
for (int j = n - 1; j; j--) A[getw(j + 1, i)] = A[getw(j, i)];
A[getw(1, i)] = num;
}
if (n >= m)
for (int i = 1; i <= m; i++)
if (i & 1) {
int num = A[getw(n, i)];
for (int j = n - 1; j; j--) A[getw(j + 1, i)] = A[getw(j, i)];
A[getw(1, i)] = num;
}
if (n == 3 && m == 3) {
A[1] = 8;
A[2] = 3;
A[3] = 4;
A[4] = 1;
A[5] = 5;
A[6] = 9;
A[7] = 6;
A[8] = 7;
A[9] = 2;
}
if (n == 1 || m == 1) {
int tot = n * m;
len = 0;
for (int i = 1; i <= tot; i++)
if (i & 1) A[++len] = i;
for (int i = 1; i <= tot; i++)
if (i % 2 == 0) A[++len] = i;
}
if (n * m == 4) {
A[1] = 3;
A[2] = 1;
A[3] = 4;
A[4] = 2;
}
int flag = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (qua(i, j) == 0) flag = 1;
if (flag)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d ", A[(i - 1) * m + j]);
printf("\n");
}
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double pi = acos(-1.0), eps = 1e-9, e = exp(1.0);
const int INF = 1000 * 1000 * 1000 + 7, MAXN = 100005, MOD = 1000000007,
MAXBIT = 30, pHash = 53;
const long long INFL = 1e+18;
void prepare(string s) {
if ((int)s.size() != 0) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
}
int n, a[3005], b[3005], c[3005];
long long dp0[3005], dp1[3005];
void read() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
for (int i = 0; i < n; ++i) cin >> c[i];
}
void solve() {
dp0[0] = a[0];
dp1[0] = 0;
for (int i = 1; i < n; i++) {
if (i > 1) {
dp0[i] = max(dp0[i - 1] - a[i - 1] + b[i - 1] + a[i],
dp1[i - 1] - b[i - 1] + c[i - 1] + a[i]);
} else {
dp0[i] = dp0[i - 1] - a[i - 1] + b[i - 1] + a[i];
}
dp1[i] = max(dp0[i - 1] + b[i], dp1[i - 1] + b[i]);
}
cout << max(dp0[n - 1], dp1[n - 1]);
}
int main() {
prepare("");
read();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
int n, m, K, r[N], cnt, du[N], Du[N], head[N], Cnt, Head[N], q[N], L[N], U[N],
mk[N];
struct xint {
int to, next;
} e[N * 2], E[N * 2];
void addedge(int x, int y) {
e[++cnt] = (xint){y, head[x]};
head[x] = cnt;
du[y]++;
}
void Addedge(int x, int y) {
E[++Cnt] = (xint){y, Head[x]};
Head[x] = Cnt;
Du[y]++;
}
int h, t;
bool instk[N];
void dfs(int x) {
mk[x] = 1;
instk[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int y = e[i].to;
if (instk[y]) {
cout << -1 << endl;
exit(0);
}
if (mk[y]) continue;
dfs(y);
}
instk[x] = 0;
}
void check() {
memset(mk, 0, sizeof mk);
for (int i = 1; i <= n; ++i)
if (!mk[i]) dfs(i);
}
void work1() {
h = 0, t = 0;
memset(mk, 0, sizeof mk);
memset(q, 0, sizeof q);
for (int i = 1; i <= n; ++i) L[i] = 1;
for (int i = 1; i <= n; ++i)
if (r[i]) q[++t] = i, L[i] = r[i], mk[i] = 1;
for (int i = 1; i <= n; ++i)
if (!du[i] && !r[i]) q[++t] = i, L[i] = 1, mk[i] = 1;
while (h++ < t) {
int u = q[h];
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (mk[v]) continue;
du[v]--;
L[v] = max(L[v], L[u] + 1);
if (!du[v]) q[++t] = v;
}
}
}
void work2() {
h = 0, t = 0;
memset(mk, 0, sizeof mk);
memset(q, 0, sizeof q);
for (int i = 1; i <= n; ++i) U[i] = K;
for (int i = 1; i <= n; ++i)
if (r[i]) q[++t] = i, U[i] = r[i], mk[i] = 1;
for (int i = 1; i <= n; ++i)
if (!Du[i] && !r[i]) q[++t] = i, U[i] = K, mk[i] = 1;
while (h++ < t) {
int u = q[h];
for (int i = Head[u]; i; i = E[i].next) {
int v = E[i].to;
if (mk[v]) continue;
Du[v]--;
U[v] = min(U[v], U[u] - 1);
if (!Du[v]) q[++t] = v;
}
}
}
struct yint {
int x, y, o;
} sL[N], sU[N];
bool cmpx(yint a, yint b) { return a.x < b.x; }
bool cmpy(yint a, yint b) { return a.y < b.y; }
set<pair<int, int> > s;
int ans[N];
void work3() {
for (int i = 1; i <= n; ++i)
if (L[i] > U[i]) {
cout << -1 << endl;
exit(0);
}
for (int i = 1; i <= n; ++i)
sL[i].x = sU[i].x = L[i], sL[i].y = sU[i].y = U[i], sL[i].o = sU[i].o = i;
sort(sL + 1, sL + n + 1, cmpx);
sort(sU + 1, sU + n + 1, cmpy);
int cnt1 = 1, cnt2 = 1;
s.insert(make_pair(0, 0));
s.insert(make_pair(2e9, 2e9));
for (int i = 1; i <= K; ++i) {
while (cnt1 <= n && sL[cnt1].x <= i)
s.insert(make_pair(sL[cnt1].y, sL[cnt1].o)), cnt1++;
pair<int, int> S = *s.upper_bound(make_pair(0, 0));
if (S.second > n) {
cout << -1 << endl;
exit(0);
}
ans[S.second] = i;
s.erase(S);
while (cnt2 <= n && sU[cnt2].y <= i) {
pair<int, int> S(sU[cnt2].y, sU[cnt2].o);
if (!ans[sU[cnt2].o]) {
ans[sU[cnt2].o] = i;
s.erase(S);
}
cnt2++;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = 1; i <= n; ++i) scanf("%d", &r[i]);
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (r[x] && r[y] && r[x] <= r[y]) {
cout << -1 << endl;
exit(0);
}
addedge(y, x);
Addedge(x, y);
}
check();
work1();
work2();
work3();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
int t;
string str;
cin >> t;
while (t--) {
cin >> str;
int ans = 0;
int dist = 0;
for (int i = 0; i < str.length(); i++) {
dist++;
if (str[i] == 'R') {
ans = max(ans, dist);
dist = 0;
}
}
ans = max(ans, dist + 1);
cout << ans << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
int n;
string s;
cin >> n >> s;
int x = -1;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '1') {
x = n - i;
break;
}
}
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == '1') {
if ((x) < (i + 1)) {
x = i + 1;
}
break;
}
}
if (x == -1) {
cout << n << "\n";
} else {
cout << 2 * x << "\n";
}
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.