solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int MOD(int a, int b) {
if (a > b)
return a - b;
else
return b - a;
}
long long int max3(long long int a, long long int b, long long int c) {
return max(c, max(a, b));
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int max(long long int a, long long int b) { return (a > b) ? a : b; }
long long int min(long long int a, long long int b) { return (a < b) ? a : b; }
long long int gcd(long long int a, long long int b) {
if (b == 1)
return 1;
else if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
long long int mod(long long int x) {
if (x >= 0)
return x;
else
return -x;
}
long long int dp[501][501];
void calculate(int n, int h) {
long long int res = 0;
for (int i = 1; i <= n; i++) {
res += (dp[i - 1][h - 1] * dp[n - i][h - 1]) % 1000000007;
}
dp[n][h] = res % 1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, s;
cin >> n >> s;
cout << (int)ceil((float)s / n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long mod = 1000000000 + 7;
const long long INF = 9000000000000000000;
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b / (gcd(a, b))); }
long long go(long long n, long long l, long long r) {
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (i >= l && i <= r) return i;
if ((n / i) >= l && (n / i) <= r) return (n / i);
}
}
return -1;
}
void solve() {
long long l, r, m;
cin >> l >> r >> m;
long long low = (m - (r - l)) > 0 ? m - (r - l) : 0;
long long high = m + (r - l);
if (low == high) {
cout << l << " " << l << " " << l << endl;
return;
}
if (low >= l && low <= r) {
cout << low << " " << r << " " << l << endl;
} else if (high >= l && high <= r) {
cout << high << " " << l << " " << r << endl;
} else {
for (long long i = l; i <= r; i++) {
if ((low / i) != (high / i)) {
long long x = low / i * i;
if (x < low) x += i;
long long xb, xc;
if (x > m) {
xc = l + x - m;
xb = l;
} else {
xb = l + m - x;
xc = l;
}
cout << i << " " << xb << " " << xc << endl;
break;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long tests = 1;
cin >> tests;
while (tests--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC target("avx")
using namespace std;
inline char gc() {
static char buf[1 << 16], *p1 = buf, *p2 = buf;
if (p1 == p2) {
p2 = (p1 = buf) + fread(buf, 1, 1 << 16, stdin);
if (p2 == p1) return EOF;
}
return *p1++;
}
template <class t>
inline t read(t &x) {
char c = gc();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = gc();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = gc();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const long long N = 6e4 + 5, M = 2e5 + 5;
long long en = 1, h[N], cur[N], d[N], n, m, ans;
struct edge {
long long n, v, w;
} e[M << 1];
void add(long long x, long long y, long long z) {
e[++en] = (edge){h[x], y, z};
h[x] = en;
}
bool bfs(long long s, long long aim) {
memset(d, 0, sizeof d);
memcpy(cur, h, sizeof cur);
queue<long long> q;
q.push(s);
d[s] = 1;
while (!q.empty()) {
long long x = q.front();
q.pop();
for (long long i = h[x]; i; i = e[i].n) {
long long y = e[i].v;
if (!d[y] && e[i].w) {
d[y] = d[x] + 1;
if (y == aim) return 1;
q.push(y);
}
}
}
return 0;
}
long long dfs(long long x, long long flow, long long aim) {
if (x == aim) return flow;
long long rest = flow;
for (long long &i = cur[x]; i && rest; i = e[i].n) {
long long y = e[i].v;
if (d[y] == d[x] + 1 && e[i].w) {
long long tp = dfs(y, min(rest, e[i].w), aim);
rest -= tp;
e[i].w -= tp;
e[i ^ 1].w += tp;
}
}
return flow - rest;
}
long long dinic(long long s, long long t) {
long long res = 0;
while (bfs(s, t)) res += dfs(s, 1000000000000, t);
return res;
}
void exadd(long long x, long long y, long long f) {
add(x, y, f);
add(y, x, 0);
}
signed main() {
read(n);
for (long long i = 1, m, x; i <= n; i++) {
read(m);
while (m--) exadd(i, read(x) + n, 100000000);
}
for (long long i = 1, x; i <= n; i++) {
read(x);
exadd(0, i, 100000000 - x);
ans += 100000000 - x;
}
for (long long i = 1; i <= n; i++) exadd(i + n, n * 2 + 1, 100000000);
write(min(dinic(0, n * 2 + 1) - ans, 0ll));
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, c, i;
cin >> n >> c;
vector<int> s;
s.resize(n);
vector<int> t;
t.resize(n);
for (i = 0; i < n; i++) {
cin >> s[i];
}
for (i = 0; i < n; i++) {
cin >> t[i];
}
int lmarks = 0, rmarks = 0, ltime = 0, rtime = 0;
for (i = 0; i < n; i++) {
ltime += t[i];
lmarks += max(0, (s[i] - c * ltime));
rtime += t[n - i - 1];
rmarks += max(0, (s[n - i - 1] - c * rtime));
}
if (lmarks > rmarks) {
cout << "Limak" << endl;
} else if (lmarks == rmarks) {
cout << "Tie" << endl;
} else {
cout << "Radewoosh" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 20;
const int C = 10;
const int M = (1 << C) + 20;
const int mod = 998244353;
int ans[N];
int dp[N][N];
int pd[2][N][M];
int cnt[N];
int pw[N];
int a[N], inv[N];
int n, c;
inline void add(int &a) {
if (a >= mod) {
a -= mod;
} else {
if (a < 0) {
a += mod;
}
}
}
int power(int a, int b) {
if (!b) {
return 1;
}
int x = power(a, b / 2);
x = 1LL * x * x % mod;
if (b & 1) {
x = 1LL * x * a % mod;
}
return x;
}
void pre() {
pw[0] = 0;
for (int i = 1; i < N; i++) {
pw[i] = 1LL * (pw[i - 1] + 1) * 2 % mod;
add(pw[i] -= 1);
inv[i] = 1LL * pw[i] * power(pw[i - 1], mod - 2) % mod;
}
}
void input() {
cin >> n >> c;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i]--;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
pre();
input();
if (c <= C) {
pd[0][0][0] = 1;
for (int i = 0; i < n; i++) {
int x = (i & 1);
for (int j = 0; j <= i / c + 3; j++) {
for (int mask = 0; mask < (1 << c); mask++) {
pd[x ^ 1][j][mask] = 0;
}
}
for (int j = 0; j <= i / c; j++) {
for (int mask = 0; mask < (1 << c) - 1; mask++) {
add(pd[x ^ 1][j][mask | (1 << a[i + 1])] += pd[x][j][mask]);
add(pd[x ^ 1][j][mask] += pd[x][j][mask]);
}
add(pd[x ^ 1][j + 1][0] += pd[x ^ 1][j][(1 << c) - 1]);
}
}
for (int j = 0; j <= n; j++) {
int s = 0;
for (int mask = 0; mask < (1 << c) - 1; mask++) {
add(s += pd[n & 1][j][mask]);
}
if (!j) {
add(s -= 1);
}
cout << s << " ";
}
cout << endl;
return 0;
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
memset(cnt, 0, sizeof cnt);
int tmp = c - 1;
int tmp2 = 1;
for (int k = i - 1; k >= 0; k--) {
int x = a[k + 1];
if (x != a[i]) {
cnt[x]++;
if (cnt[x] == 1) {
tmp--;
} else {
tmp2 = 1LL * tmp2 * inv[cnt[x]] % mod;
}
}
if (!tmp) {
for (int j = 1; j <= k / c + 1; j++) {
dp[i][j] = (dp[i][j] + 1LL * dp[k][j - 1] * tmp2) % mod;
}
}
}
}
for (int i = 0; i <= n; i++) {
memset(cnt, 0, sizeof cnt);
for (int k = i + 1; k <= n; k++) {
cnt[a[k]]++;
}
int all = pw[n - i];
add(all += 1);
int tmp = 1;
for (int i = 0; i < c; i++) {
tmp = 1LL * tmp * pw[cnt[i]] % mod;
}
add(all -= tmp);
for (int j = 0; j <= i / c; j++) {
add(ans[j] += 1LL * dp[i][j] * all % mod);
}
}
add(ans[0] -= 1);
for (int i = 0; i <= n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
double ans = 1.0 / tan(3.14159265357 / n / 2);
cout << fixed << setprecision(12) << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
int main() {
long long n, k, j, i;
scanf("%lld %lld", &n, &k);
if (n % 2 == 0)
j = n / 2;
else
j = (n / 2) + 1;
if (k <= j)
i = (k * 2) - 1;
else
i = (k - j) * 2;
printf("%lld\n", i);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e5 + 5, M = 100 + 5, OO = 0x3f3f3f3f, mod = 1e9 + 7, base = 131,
MOD2 = 1000136437;
const double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 1; i <= n; i++) v[i - 1] = i;
rotate(v.begin(), v.begin() + 1, v.end());
for (auto i : v) cout << i << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1000000 + 5], f[1000000 + 5], maxl, ans;
string s;
stack<int> stk;
int main() {
cin >> s;
n = s.length();
for (int i = 0; i < n; ++i) {
if (s[i] == '(')
stk.push(i);
else if (s[i] == ')' && !stk.empty())
a[i] = a[stk.top()] = 1, stk.pop();
}
f[0] = a[0];
for (int i = 1; i < n; ++i)
f[i] = (a[i] ? f[i - 1] + 1 : 0), maxl = max(maxl, f[i]);
if (maxl == 0) {
cout << "0 1" << endl;
return 0;
}
for (int i = 0; i < n; ++i) ans += (f[i] == maxl);
cout << maxl << " " << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool DD = 0;
namespace mine {
long long qread() {
long long ans = 0, f = 1;
char c = getchar();
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) putchar('-'), num = -num;
if (num >= 10) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
putchar('\n');
}
template <typename T>
inline bool chmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
bool IN(long long x, long long l, long long r) { return l <= x and x <= r; }
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int mm(const int x) { return x >= MOD ? x - MOD : x; }
template <typename T>
void add(T &x, const int &y) {
x = (x + y >= MOD ? x + y - MOD : x + y);
}
long long qpower(long long x, long long e, int mod = MOD) {
long long ans = 1;
while (e) {
if (e & 1) ans = ans * x % mod;
x = x * x % mod;
e >>= 1;
}
return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int N = 1e6 + 10;
deque<int> que;
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
sit;
priority_queue<int, vector<int>, greater<int> > wt;
long long ans[N];
void upd() {
if (((int)(wt).size()))
if (!((int)(que).size()) or wt.top() < que.back())
que.push_back(wt.top()), wt.pop();
}
void main() {
int n = qread();
long long P = qread();
for (int i = (1), I = (n); i <= I; i++) sit.push({qread(), i});
long long time = 0;
while (1) {
if (((int)(que).size())) {
int id = que.front();
time += P, ans[id] = time;
while (((int)(sit).size()) and sit.top().first < time)
wt.push(sit.top().second), sit.pop(), upd();
que.pop_front();
} else if (((int)(wt).size()))
;
else if (!((int)(wt).size()) and ((int)(sit).size()))
time = sit.top().first;
else
break;
while (((int)(sit).size()) and sit.top().first <= time)
wt.push(sit.top().second), sit.pop(), upd();
upd();
}
for (int i = (1), I = (n); i <= I; i++) write1(ans[i]);
}
}; // namespace mine
signed main() {
srand(time(0));
mine::main();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int oo = ~0u >> 2, mo = (int)1e9 + 7;
const int mn = 160, mm = ((mn) * (mn));
bitset<mm> a, b, c, d;
int n, m, k;
char ch;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i <= n - 1; ++i)
for (int j = 0; j <= m - 1; ++j) {
do {
scanf("%c", &ch);
} while (ch != '#' && ch != 'E' && ch != '.');
(ch != '#' ? a : b).set(i * m + j);
if (ch == 'E') d.set(i * m + j);
}
c = a;
if (c == d) {
printf("0\n");
return 0;
}
for (int i = 1; i <= k; ++i) {
do {
scanf("%c", &ch);
} while (ch != 'U' && ch != 'L' && ch != 'R' && ch != 'D');
if (ch == 'U')
c = ((c >> m) & a) | (c & (b << m));
else if (ch == 'L')
c = ((c >> 1) & a) | (c & (b << 1));
else if (ch == 'R')
c = ((c << 1) & a) | (c & (b >> 1));
else if (ch == 'D')
c = ((c << m) & a) | (c & (b >> m));
if (c == d) {
printf("%d\n", i);
return 0;
}
}
printf("-1\n");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
vector<long long int> pos;
for (long long int i = 0; i < n; i++) {
long long int cur;
cin >> cur;
pos.push_back(cur);
}
bool lit = true;
long long int totalLit = 0;
long long int onTime = 0;
long long int offTime = 0;
long long int last = 0;
for (long long int i = 0; i < n + 1; i++) {
long long int cur;
if (i == n) {
cur = m;
} else {
cur = pos[i];
}
long long int duration = cur - last;
if (lit) {
totalLit += duration;
}
lit = !lit;
last = cur;
}
reverse(pos.begin(), pos.end());
lit = pos.size() % 2 == 0;
pos.push_back(0);
long long int answer = totalLit;
last = m;
for (long long int i = 0; i < n + 1; i++) {
long long int duration = last - pos[i];
if (lit) {
onTime += duration;
} else {
offTime += duration;
}
if (duration > 1) {
if (lit) {
long long int p1 = totalLit - onTime + offTime + 1;
long long int p2 = totalLit - onTime + offTime + duration - 1;
;
answer = max(answer, p1);
answer = max(answer, p2);
} else {
long long int p1 = totalLit + offTime - onTime - 1;
long long int p2 = totalLit + offTime - onTime - (duration - 1);
;
answer = max(answer, p1);
answer = max(answer, p2);
}
}
lit = !lit;
last = pos[i];
};
cout << answer << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class Cont>
inline int len(const Cont &c) {
return static_cast<int>(c.size());
}
template <typename T>
inline void maximize(T &what, const T &with) {
if (what < with) what = with;
}
template <typename T>
inline void minimize(T &what, const T &with) {
if (what > with) what = with;
}
int main() {
vector<pair<string, string>> a;
int n;
string prev;
cin >> n;
for (int i = 0; i < n; ++i) {
string na, sn;
cin >> na >> sn;
a.emplace_back(na, sn);
}
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
--x;
if (a[x].first > prev && a[x].second > prev) {
prev = min(a[x].first, a[x].second);
} else if (a[x].first > prev) {
prev = a[x].first;
} else if (a[x].second > prev) {
prev = a[x].second;
} else {
cout << "NO" << endl;
return 0;
}
}
cout << "YES\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, b, d, x, finall = 0;
long long counter = 0;
cin >> n >> b >> d;
for (int i = 0; i < n; i++) {
cin >> x;
if (x <= b) {
counter += x;
}
if (counter > d) {
finall++;
counter = 0;
}
}
cout << finall << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void err(istringstream *iss) {}
template <typename T, typename... Args>
void err(istringstream *iss, const T &$val, const Args &...args) {
string $name;
*iss >> $name;
if ($name.back() == ',') $name.pop_back();
cout << $name << " = " << $val << "; ", err(iss, args...);
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
int n, m, K, T, Q, cn;
int s[102], t[21];
char a[21];
int trailingOnes(int x) {
int temp = ~x;
return temp == 0 ? 32 : __builtin_ctz(temp);
}
bitset<1 << 21 | 5> vstd[21];
int memo[21][1 << 21 | 5];
int dp(int at, int cur) {
if (at == m) return 0;
int &ret = memo[at][cur];
if (vstd[at][cur]) return ret;
vstd[at][cur] = 1;
if (a[at] == 'p') {
int best = trailingOnes(cur);
ret = (t[at] == 1 ? s[best] + dp(at + 1, cur | (1 << best))
: -s[best] + dp(at + 1, cur | (1 << best)));
} else {
ret = dp(at + 1, cur);
for (int i = 0; i < m; i++) {
if ((cur >> i) & 1) continue;
ret = (t[at] == 1 ? max(ret, dp(at + 1, cur | (1 << i)))
: min(ret, dp(at + 1, cur | (1 << i))));
}
}
return ret;
}
int main() {
cin.tie(NULL);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &s[i]);
}
sort(s, s + n, greater<int>());
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf(" %c %d", &a[i], &t[i]);
}
printf("%d\n", dp(0, 0));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
const int maxn = 4e5 + 5;
const int INF = 0x3f3f3f3f;
long long t, a[maxn], b[maxn], n, m;
string s;
bool check(long long mid) {
for (int i = 1; i <= n; i++) b[i] = a[i];
for (int i = 1; i <= n; i++) {
if (b[i - 1] > b[i] + mid)
return false;
else if (b[i] + mid >= m && b[i - 1] <= (b[i] + mid) % m)
b[i] = b[i - 1];
else if (b[i - 1] - b[i] <= mid && b[i - 1] > b[i])
b[i] = b[i - 1];
else
b[i] = a[i];
}
return true;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long long l = 0, r = m, ans = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000009;
int n, m, k;
int exp_mod(int a, int b) {
int ret = 1;
for (; b; a = 1ll * a * a % MOD, b >>= 1) {
if (b & 1) ret = 1ll * ret * a % MOD;
}
return ret;
}
int main() {
while (cin >> n >> m >> k) {
int t = n / k, x = m - t * (k - 1) - n % k;
if (x <= 0)
printf("%d\n", m);
else {
int ans =
((1ll * k * (exp_mod(2, x + 1) - 2) + m - 1ll * x * k) % MOD + MOD) %
MOD;
printf("%d\n", ans);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e7 + 7;
int lazy[M];
struct _info {
int n4, n7, n47, n74;
_info() { n4 = 0, n7 = 0, n47 = 0, n74 = 0; }
} tree[M];
string s;
_info merg(_info l, _info r) {
_info res;
res.n4 = l.n4 + r.n4;
res.n7 = l.n7 + r.n7;
res.n47 = max(l.n4 + r.n47, l.n47 + r.n7);
res.n74 = max(l.n7 + r.n74, l.n74 + r.n4);
return res;
}
void build(int node, int beg, int ed) {
if (beg == ed) {
if (s[beg - 1] == '4') {
tree[node].n4 = 1;
tree[node].n47 = 1;
tree[node].n74 = 1;
tree[node].n7 = 0;
} else {
tree[node].n4 = 0;
tree[node].n47 = 1;
tree[node].n74 = 1;
tree[node].n7 = 1;
}
return;
}
int mid = (beg + ed) >> 1;
int lft = 2 * node;
int rgt = lft + 1;
build(lft, beg, mid);
build(rgt, mid + 1, ed);
tree[node] = merg(tree[lft], tree[rgt]);
}
void relax(int node, int beg, int ed) {
if (lazy[node]) {
lazy[2 * node] ^= 1;
lazy[2 * node + 1] ^= 1;
swap(tree[node].n4, tree[node].n7);
swap(tree[node].n47, tree[node].n74);
}
lazy[node] = 0;
}
void rangeUpdate(int node, int beg, int ed, int l, int r) {
if (lazy[node]) relax(node, beg, ed);
if (beg > r || ed < l) return;
if (beg >= l && ed <= r) {
lazy[node] ^= 1;
relax(node, beg, ed);
return;
}
int mid = (beg + ed) >> 1;
int lft = 2 * node;
int rgt = lft + 1;
rangeUpdate(lft, beg, mid, l, r);
rangeUpdate(rgt, mid + 1, ed, l, r);
tree[node] = merg(tree[lft], tree[rgt]);
}
_info query(int node, int beg, int ed, int l, int r) {
if (lazy[node]) relax(node, beg, ed);
if (beg > r || ed < l) {
_info dummy;
return dummy;
}
if (beg >= l && ed <= r) return tree[node];
int mid = (beg + ed) >> 1;
int lft = 2 * node;
int rgt = lft + 1;
_info p = query(lft, beg, mid, l, r);
_info q = query(rgt, mid + 1, ed, l, r);
return merg(p, q);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
int n, m;
cin >> n >> m;
cin >> s;
build(1, 1, n);
while (m--) {
cin >> s;
if (s[0] == 'c') {
cout << query(1, 1, n, 1, n).n47 << "\n";
} else {
int l, r;
cin >> l >> r;
rangeUpdate(1, 1, n, l, r);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void main2();
int main() {
int tests = 1;
for (int i = 1; i <= tests; i++) {
main2();
}
}
map<int, long long> col;
map<int, long long> row;
long long cs = 0, rs = 0;
multiset<long long> stc, str;
void main2() {
int n, m, p, k;
cin >> n >> m >> k >> p;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int tmp;
scanf("%d", &tmp);
row[i] += tmp;
col[j] += tmp;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) str.insert(row[i]);
for (int i = 1; i <= m; i++) stc.insert(col[i]);
vector<long long> dpr(k + 5), dpc(k + 5);
dpr[0] = 0;
for (int i = 1; i <= k; i++) {
dpr[i] = dpr[i - 1];
long long val = *str.rbegin();
dpr[i] += val;
auto it = str.find(val);
str.erase(it);
str.insert(val - (long long)m * p);
}
dpc[0] = 0;
for (int i = 1; i <= k; i++) {
dpc[i] = dpc[i - 1];
long long val = *stc.rbegin();
dpc[i] += val;
auto it = stc.find(val);
stc.erase(it);
stc.insert(val - (long long)n * p);
}
ans = LLONG_MIN;
for (int i = 0; i <= k; i++) {
ans = max(
ans, dpr[i] + dpc[k - i] - 1LL * i * (long long)(k - i) * (long long)p);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
int a[100005], tmp[100005], l[100005], r[100005], n, q;
int main() {
scanf("%d%d", &n, &q);
for (int i = (1); i <= (n); ++i) scanf("%d", &tmp[i]);
--n;
for (int i = (1); i <= (n); ++i) a[i] = abs(tmp[i] - tmp[i + 1]);
stack<int> s;
for (int i = (1); i <= (n); ++i) {
while (!s.empty() && a[s.top()] < a[i]) s.pop();
if (!s.empty())
l[i] = s.top() + 1;
else
l[i] = 1;
s.push(i);
}
while (!s.empty()) s.pop();
for (int i = (n); i >= (1); --i) {
while (!s.empty() && a[s.top()] <= a[i]) s.pop();
if (!s.empty())
r[i] = s.top() - 1;
else
r[i] = n;
s.push(i);
}
for (int iq = (1); iq <= (q); ++iq) {
int u, v;
scanf("%d%d", &u, &v);
--v;
long long ans = 0;
for (int i = (u); i <= (v); ++i)
ans += a[i] * (long long)(i - max(u, l[i]) + 1) *
(long long)(min(r[i], v) - i + 1);
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long n, qx, qy, ksx, ksy, kex, key;
int main() {
scanf("%lld", &n);
scanf("%lld %lld", &qx, &qy);
scanf("%lld %lld", &ksx, &ksy);
scanf("%lld %lld", &kex, &key);
if (ksx > qx && kex < qx || ksx < qx && kex > qx) {
printf("NO\n");
} else if (ksy > qy && key < qy || ksy < qy && key > qy) {
printf("NO\n");
} else {
printf("YES\n");
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
void qread(int &x) {
int neg = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = 10 * x + c - '0', c = getchar();
x *= neg;
}
const int maxn = 500005;
int n, ans;
char c[maxn];
int dp[maxn];
namespace Sa {
pair<int, int> cur[maxn];
int rk[maxn], sa[maxn], tmp[maxn], sum[maxn], lcp[maxn];
void rsort() {
int mx = 0;
for (int(i) = 0; (i) < n; i++)
sum[cur[i].second]++, mx = max(mx, cur[i].second);
for (int(i) = 1; (i) <= mx; i++) sum[i] += sum[i - 1];
for (int i = n - 1; i >= 0; i--) tmp[--sum[cur[i].second]] = i;
for (int(i) = 0; (i) < mx + 1; i++) sum[i] = 0;
mx = 0;
for (int(i) = 0; (i) < n; i++)
sum[cur[tmp[i]].first]++, mx = max(mx, cur[tmp[i]].first);
for (int(i) = 1; (i) <= mx; i++) sum[i] += sum[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--sum[cur[tmp[i]].first]] = tmp[i];
for (int(i) = 0; (i) < mx + 1; i++) sum[i] = 0;
rk[sa[0]] = 0;
for (int(i) = 1; (i) <= n - 1; i++)
rk[sa[i]] = rk[sa[i - 1]] + (cur[sa[i]] != cur[sa[i - 1]]);
}
void init(char *s) {
for (int(i) = 0; (i) < n; i++) cur[i] = make_pair(s[i], s[i]);
rsort();
for (int m = 1; m <= n; m <<= 1) {
for (int(i) = 0; (i) < n; i++)
cur[i] = make_pair(rk[i] + 1, i + m < n ? rk[i + m] + 1 : 0);
rsort();
}
int h = 0;
for (int(i) = 0; (i) < n; i++) {
if (!rk[i]) continue;
int j = sa[rk[i] - 1];
if (h) h--;
while (i + h < n && j + h < n && s[i + h] == s[j + h]) h++;
lcp[rk[i]] = h;
}
}
} // namespace Sa
namespace St {
const int mlog = 20;
int mn[maxn][mlog];
void init(int *a) {
for (int(i) = 0; (i) < n; i++) mn[i][0] = a[i];
for (int(j) = 1; (j) <= mlog - 1; j++)
for (int(i) = 0; (i) < n; i++) {
if (i + (1 << j - 1) < n)
mn[i][j] = min(mn[i][j - 1], mn[i + (1 << j - 1)][j - 1]);
else
mn[i][j] = 1e9;
}
}
pair<int, int> range(int i, int len) {
int l = i, r = i;
for (int j = mlog - 1; j >= 0; j--) {
if (l - (1 << j) >= 0 && mn[l - (1 << j) + 1][j] >= len) l -= (1 << j);
if (r + (1 << j) < n && mn[r + 1][j] >= len) r += (1 << j);
}
return make_pair(l, r);
}
} // namespace St
namespace Segt {
int sz;
int t[maxn * 4];
void init() {
sz = 1;
for (; sz <= n; sz <<= 1)
;
for (int(i) = 0; (i) < sz << 1; i++) t[i] = 0;
}
void update(int v, int val) {
v += sz;
t[v] = max(val, t[v]);
for (v >>= 1; v; v >>= 1) t[v] = max(t[v << 1], t[v << 1 | 1]);
}
int query(int l, int r) {
int res = 0;
for (l += sz, r += sz; l <= r; l >>= 1, r >>= 1) {
if (l & 1) res = max(res, t[l]), l++;
if ((r + 1) & 1) res = max(res, t[r]), r--;
}
return res;
}
} // namespace Segt
int main() {
scanf("%d%s", &n, c);
Sa::init(c);
St::init(Sa::lcp);
Segt::init();
for (int i = n - 1; i >= 0; i--) {
dp[i] = dp[i + 1] + 1;
while (dp[i]) {
pair<int, int> cur = St::range(Sa::rk[i], dp[i] - 1);
int mx = Segt::query(cur.first, cur.second);
if (i + 1 < n) {
cur = St::range(Sa::rk[i + 1], dp[i] - 1);
mx = max(mx, Segt::query(cur.first, cur.second));
}
if (mx >= dp[i] - 1) break;
dp[i]--;
if (i + dp[i] < n) Segt::update(Sa::rk[i + dp[i]], dp[i + dp[i]]);
}
ans = max(ans, dp[i]);
}
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char buf[31];
int a[31][31];
int b[29], c[29];
bool used[7][7];
int d[15];
int cnt;
int ans;
char res[31][31];
void dfs(int x) {
if (x > 6) {
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 6; j++) used[i][j] = false;
}
for (int i = 1; i <= 28; i++) {
if (used[d[b[i]]][d[c[i]]]) return;
used[d[b[i]]][d[c[i]]] = used[d[c[i]]][d[b[i]]] = true;
}
if (!ans) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!a[i][j])
res[i][j] = '.';
else
res[i][j] = '0' + d[a[i][j]];
}
}
}
ans++;
return;
}
for (int i = 1; i <= 14; i++) {
if (d[i] != -1) continue;
d[i] = x;
for (int j = i + 1; j <= 14; j++) {
if (d[j] != -1) continue;
d[j] = x;
dfs(x + 1);
d[j] = -1;
}
d[i] = -1;
break;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", buf + 1);
for (int j = 1; j <= m; j++) {
if (buf[j] == '.') continue;
if (!a[i][j])
a[i][j] = a[i][j + 1] = a[i + 1][j] = a[i + 1][j + 1] = ++cnt;
int v;
if (buf[j] <= 'B')
v = buf[j] - 'A' + 1;
else
v = buf[j] - 'a' + 3;
if (!b[v])
b[v] = a[i][j];
else
c[v] = a[i][j];
}
}
for (int i = 1; i <= 14; i++) d[i] = -1;
dfs(0);
printf("%lld\n", 5040LL * ans);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", res[i][j]);
puts("");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c, countm = 0, countc = 0;
cin >> n;
while (n) {
cin >> m >> c;
if (m > c)
countm++;
else if (c > m)
countc++;
n--;
}
if (countm > countc)
cout << "Mishka";
else if (countm < countc)
cout << "Chris";
else
cout << "Friendship is magic!^^";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<string, vector<string> > g;
map<string, unsigned char> vis;
int dfs(string s) {
vis[s] = true;
int maxs = 0;
if (g[s].size() == 0) return 1;
for (auto it : g[s]) {
if (!vis[it]) {
maxs = max(dfs(it), maxs);
}
}
return maxs + 1;
}
string tolower(string s) {
for (char &i : s) {
if (i < 97) i += ' ';
}
return s;
}
void print() {
for (map<string, vector<string> >::iterator it = g.begin(); it != g.end();
it++) {
cout << it->first << " length (" << it->second.size() << "): ";
for (string s : it->second) {
cout << s << " ";
}
cout << endl;
}
}
int main() {
int n;
cin >> n;
while (n--) {
string a, b, c, tempa, tempc;
cin >> a >> b >> c;
tempa = tolower(a);
tempc = tolower(c);
g[tempc].push_back(tempa);
}
cout << dfs("polycarp");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct segment {
int l, r, fu;
bool operator<(const segment &temp) const { return l < temp.l; }
};
segment sg[5000];
int cnt_sg;
const int inf = 1e9;
int xx[400], yy[400];
int cnt_x, cnt_y;
struct rectangle {
int lx, ly, rx, ry;
};
rectangle rec[99];
int n, m, k, cnt, mc[1111][1111], nc[1111][11111], list[99], cnt_list, ls[99],
cnt_ls;
long long ans, now;
char str[1111][1111];
bool vsx[400], vsy[400];
int main() {
int i, j, s, p, q, id, dx1, dx2, dy1, dy2, lx, ly, rx, ry, pn;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) scanf("%s", str[i]);
cnt = 0;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
if (str[i][j] == '*' && !(i > 0 && str[i - 1][j] == '*') &&
!(j > 0 && str[i][j - 1] == '*')) {
rec[cnt].lx = i;
rec[cnt].ly = j;
for (s = i; s < n; s++) {
for (p = j; p < m; p++) {
if (str[s][p] != '*') break;
}
if (p == j) break;
rec[cnt].ry = p - 1;
}
rec[cnt++].rx = s - 1;
}
}
memset(mc, 0, sizeof(mc));
memset(nc, 0, sizeof(nc));
for (i = 0; i < k; i++) mc[rec[i].lx][rec[i].ly]++;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
mc[i + 1][j] += mc[i][j];
mc[i][j + 1] += mc[i][j];
mc[i + 1][j + 1] -= mc[i][j];
}
cnt_x = cnt_y = 0;
for (i = 0; i < k; i++) {
xx[cnt_x++] = rec[i].lx;
xx[cnt_x++] = rec[i].rx;
if (rec[i].lx - 1 >= 0) xx[cnt_x++] = rec[i].lx - 1;
if (rec[i].rx + 1 < n) xx[cnt_x++] = rec[i].rx + 1;
yy[cnt_y++] = rec[i].ly;
yy[cnt_y++] = rec[i].ry;
if (rec[i].ly - 1 >= 0) yy[cnt_y++] = rec[i].ly - 1;
if (rec[i].ry + 1 < m) yy[cnt_y++] = rec[i].ry + 1;
}
sort(xx, xx + cnt_x);
sort(yy, yy + cnt_y);
int nn = 0;
for (i = 0; i < cnt_x; i++) {
if (nn == 0 || xx[nn - 1] < xx[i]) xx[nn++] = xx[i];
}
cnt_x = nn;
nn = 0;
for (i = 0; i < cnt_y; i++) {
if (nn == 0 || yy[nn - 1] < yy[i]) yy[nn++] = yy[i];
}
cnt_y = nn;
ans = 0;
for (i = 0; i < cnt_x; i++) {
if (i == 0)
dx1 = xx[i] + 1;
else
dx1 = xx[i] - xx[i - 1];
for (j = i + 1; j <= cnt_x; j++) {
if (j == cnt_x)
dx2 = n - xx[j - 1];
else
dx2 = xx[j] - xx[j - 1];
cnt_sg = 0;
for (s = 0; s < k; s++) {
if (rec[s].rx < xx[i] || rec[s].lx > xx[j - 1]) continue;
if ((rec[s].rx >= xx[i] && rec[s].lx < xx[i]) ||
(rec[s].rx > xx[j - 1] && rec[s].lx <= xx[j - 1]))
sg[cnt_sg].fu = 1;
else
sg[cnt_sg].fu = 0;
sg[cnt_sg].l = rec[s].ly;
sg[cnt_sg++].r = rec[s].ry;
}
sort(sg, sg + cnt_sg);
nn = 0;
for (s = 0; s < cnt_sg; s++) {
if (nn == 0 || sg[nn - 1].r < sg[s].l)
sg[nn++] = sg[s];
else {
sg[nn - 1].r = max(sg[nn - 1].r, sg[s].r);
sg[nn - 1].fu = max(sg[nn - 1].fu, sg[s].fu);
}
}
cnt_sg = nn;
for (s = 1; s <= cnt_sg; s++) {
if (s < cnt_sg)
dy2 = sg[s].l - sg[s - 1].r;
else
dy2 = m - sg[s - 1].r;
pn = 0;
for (p = s - 1; p >= 0; p--) {
lx = xx[i];
ly = sg[p].l;
rx = xx[j - 1];
ry = sg[s - 1].r;
int rs = mc[rx][ry];
if (lx > 0) rs -= mc[lx - 1][ry];
if (ly > 0) rs -= mc[rx][ly - 1];
if (lx > 0 && ly > 0) rs += mc[lx - 1][ly - 1];
if (rs > 3 || sg[p].fu == 1) break;
if (rs == 0) continue;
if (p == 0)
dy1 = sg[p].l + 1;
else
dy1 = sg[p].l - sg[p - 1].r;
pn += dy1;
}
ans += (long long)pn * (long long)dy2 * (long long)dx1 * (long long)dx2;
}
}
}
printf("%I64d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string str;
cin >> n;
cin >> str;
int t = 0;
for (int i = 0; i < str.length(); i++) {
if ((str[i] == 'i' || str[i] == 'e' || str[i] == 'o' || str[i] == 'u' ||
str[i] == 'a' || str[i] == 'y') &&
t == 1)
continue;
else if ((str[i] == 'i' || str[i] == 'e' || str[i] == 'o' ||
str[i] == 'u' || str[i] == 'a' || str[i] == 'y') &&
t == 0)
t = 1;
else
t = 0;
cout << str[i];
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 1e5 + 5;
int n, m, w, a[maxn];
int ft[maxn];
void upd(int pos, int val) {
while (pos <= n) ft[pos] += val, pos += pos & (-pos);
}
int get_prf(int pos) {
int ret = 0;
while (pos > 0) ret += ft[pos], pos &= pos - 1;
return ret;
}
bool can(int mid) {
memset(ft, 0, sizeof(int) * (n + 1));
int moves = 0;
for (int i = 1; i <= n; i++) {
int diff = max(mid - int(a[i] + get_prf(i)), 0);
moves += diff;
upd(i, diff);
upd(i + w, -diff);
if (moves > m) return false;
}
return true;
}
int main() {
scanf("%d %d %d", &n, &m, &w);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int l = 1, r = 1e9 + 2e5;
while (l < r) {
int mid = l + (r - l + 1) / 2;
if (can(mid))
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void rt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
rt(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
const int maxn = 100005, S = 1000000;
int n, A, cnt[maxn], a[maxn];
vector<int> ps[S + 5];
int main() {
n = rd(), A = rd();
for (int i = int(1); i <= (int)(n); i++) {
a[i] = rd();
ps[a[i]].push_back(i);
cnt[i] = cnt[i - 1] + (a[i] == A);
}
for (int i = int(1); i <= (int)(S); i++) {
if (i == A) continue;
int cou = 0, flg = 1;
for (int j = int(0); j <= (int)(ps[i].size() - 1); j++) {
if (cnt[ps[i][j]] > cou) {
flg = 0;
break;
}
cou++;
}
if (cnt[n] > cou) flg = 0;
if (flg) return rt(i), putchar('\n'), 0;
}
puts("-1");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 3;
int cnt[N] = {0};
void f() {
cnt[0] = 0;
cnt[1] = 1;
cnt[2] = 2;
for (int i = 3; i < N; i++)
cnt[i] = (cnt[i - 1] % mod + cnt[i - 2] % mod) % mod;
}
int main() {
ios_base::sync_with_stdio(false);
f();
string s;
cin >> s;
vector<int> cons;
bool check = 1;
int i = 0;
while (i < s.size()) {
if (s[i] == 'w' || s[i] == 'm') {
check = 0;
break;
}
if (s[i] == 'u' || s[i] == 'n') {
char c = s[i];
int len = 0;
while (s[i + len] == c && i + len < s.size()) {
++len;
}
if (len) cons.push_back(len);
i += len;
} else
i++;
}
if (!check) {
cout << 0 << endl;
return 0;
}
long long ans = 1ll;
for (int l : cons) {
ans = (ans * cnt[l]) % mod;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
char ia[100007][10];
int ix[100007], iy[100007];
vector<int> bb;
long long sum[400007][5], num[400007];
int N = (1 << 17);
void Gao(int what) {
while (what > 1) {
what /= 2;
num[what] = num[what * 2] + num[what * 2 + 1];
for (int i = 0; i < 5; i++) sum[what][i] = sum[what * 2][i];
for (int j = 0; j < 5; j++)
sum[what][(j + num[what * 2]) % 5] += sum[what * 2 + 1][j];
}
}
void add(int what) {
what += N;
num[what] = 1;
sum[what][0] = bb[what - N];
Gao(what);
}
void del(int what) {
what += N;
num[what] = 0;
sum[what][0] = 0;
Gao(what);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", ia[i]);
if (ia[i][0] == 's')
ix[i] = -1;
else {
scanf("%d", ix + i);
bb.push_back(ix[i]);
}
}
sort(bb.begin(), bb.end());
bb.resize(unique(bb.begin(), bb.end()) - bb.begin());
for (int i = 0; i < n; i++)
iy[i] = lower_bound(bb.begin(), bb.end(), ix[i]) - bb.begin();
for (int i = 0; i < n; i++) {
if (!strcmp(ia[i], "sum"))
cout << sum[1][2] << endl;
else if (!strcmp(ia[i], "add"))
add(iy[i]);
else
del(iy[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
const double eps = 1e-9;
const double pie = acos(-1);
void solve();
bool cmp(long long n1, long long n2);
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int kase = 1;
cin >> kase;
while (kase--) solve();
return 0;
}
bool cmp(long long n1, long long n2) { return n1 > n2; }
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> pos;
vector<long long> neg;
long long posCnt = 0, negCnt = 0;
for (long long i = 0; i < n; ++i) {
long long input;
cin >> input;
if (input > 0) {
pos.push_back(input);
posCnt += 1;
} else if (input < 0) {
neg.push_back(-input);
negCnt += 1;
}
}
sort(pos.begin(), pos.end(), cmp);
sort(neg.begin(), neg.end(), cmp);
long long ans = 0;
for (long long i = 0; i < pos.size(); i += k) {
ans += pos[i];
}
for (long long i = 0; i < neg.size(); i += k) {
ans += neg[i];
}
ans = ans * 2;
long long maxOf2;
if (pos.size() == 0 && neg.size() == 0)
maxOf2 = 0;
else if (pos.size() == 0)
maxOf2 = neg[0];
else if (neg.size() == 0)
maxOf2 = pos[0];
else {
if (pos[0] > neg[0])
maxOf2 = pos[0];
else
maxOf2 = neg[0];
}
ans = ans - maxOf2;
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int a, b, c, d, i, j, ans;
char s[100001];
while (cin >> a >> b >> c >> d) {
cin >> s;
ans = 0;
for (i = 0; i < strlen(s); i++) {
if (s[i] == '1')
ans += a;
else if (s[i] == '2')
ans += b;
else if (s[i] == '3')
ans += c;
else if (s[i] == '4')
ans += d;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Vi = vector<int>;
using Pii = pair<int, int>;
int uplg(int n) { return 32 - __builtin_clz(n); }
int uplg(ll n) { return 64 - __builtin_clzll(n); }
void run();
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(18);
run();
return 0;
}
void run() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<Vi> pos(26);
for (int i = (0); i < (n); i++) pos[s[i] - 'a'].push_back(i);
for (auto& v : (pos)) reverse((v).begin(), (v).end());
for (int i = (0); i < (k); i++) {
for (int c = (0); c < (26); c++) {
if (!pos[c].empty()) {
int first = pos[c].back();
pos[c].pop_back();
s[first] = '?';
break;
}
}
}
string ans;
for (auto& c : (s))
if (c != '?') ans.push_back(c);
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
template <class T>
T abs(T x) {
return (x > 0) ? x : (-x);
}
int n, w[26][26], ans;
char s[100005], t[100005], a[5], b[5];
int main() {
scanf("%s%s", s, t);
scanf("%d", &n);
memset(w, 0x3f3f3f3f, sizeof(w));
for (int i = 0; i < 26; ++i) w[i][i] = 0;
for (int i = 0, c; i < n; ++i) {
scanf("%s%s%d", a, b, &c);
w[a[0] - 'a'][b[0] - 'a'] = std::min(w[a[0] - 'a'][b[0] - 'a'], c);
}
if (strlen(s) != strlen(t)) {
printf("-1\n");
return 0;
}
for (int k = 0; k < 26; ++k)
for (int i = 0; i < 26; ++i)
for (int j = 0; j < 26; ++j)
if (w[i][k] + w[k][j] < w[i][j]) w[i][j] = w[i][k] + w[k][j];
for (int i = 0, c, d; s[i]; ++i) {
if (s[i] == t[i]) continue;
c = 0x3f3f3f3f;
for (int j = 0, x, y; j < 26; ++j) {
x = s[i] - 'a', y = t[i] - 'a';
if (w[x][j] + w[y][j] < c) {
c = w[x][j] + w[y][j];
d = j;
}
}
if (c < 0x3f3f3f3f) {
ans += c;
t[i] = d + 'a';
} else {
ans = 0x3f3f3f3f;
break;
}
}
if (ans < 0x3f3f3f3f)
printf("%d\n%s\n", ans, t);
else
printf("-1\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline long long squ(T x) {
return (long long)x * x;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T read() {
T sum = 0, fg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') fg = -1;
for (; isdigit(c); c = getchar()) sum = (sum << 3) + (sum << 1) + (c ^ 0x30);
return fg * sum;
}
const int maxn = 400 + 10;
char S[maxn], T[maxn];
int n, m, dp[maxn];
inline bool chk(int x) {
dp[0] = x;
for (int i = 1; i <= x; i++) dp[i] = -1;
for (int i = 0; i < n; i++) {
for (int j = x; ~j; j--) {
if (j < x && S[i] == T[j]) chkmax(dp[j + 1], dp[j]);
if (~dp[j] && S[i] == T[dp[j]]) ++dp[j];
}
}
return dp[x] >= m;
}
inline void solve() {
scanf("%s", S), n = strlen(S);
scanf("%s", T), m = strlen(T);
for (int i = 0; i < m; i++)
if (chk(i)) {
printf("YES\n");
return;
}
printf("NO\n");
}
int main() {
int T = read<int>();
while (T--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ask(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
int s;
scanf("%d", &s);
return s;
}
int n;
int a[5010];
int p[5010];
int b[5010];
int d[5010];
void solve1() {
int s = 0;
int i;
for (i = 0; i < n; i++) s ^= (i ^ a[i]);
for (i = 0; i < n; i++) {
b[i] = (a[i] ^ s);
p[b[i]] = i;
}
printf("!\n1\n");
for (i = 0; i < n; i++) printf("%d ", p[i]);
printf("\n");
}
int c[5010];
int check(int x) {
memset(c, 0, sizeof c);
int i;
for (i = 0; i < n; i++) {
b[i] = (x ^ a[i]);
if (b[i] >= n) return 0;
if (c[b[i]]) return 0;
p[b[i]] = i;
c[b[i]] = 1;
}
if (p[0] != x) return 0;
for (i = 0; i < n; i++)
if (a[i] != (p[0] ^ b[i])) return 0;
for (i = 0; i < n; i++)
if (d[i] != (p[i] ^ b[i])) return 0;
return 1;
}
void solve2() {
int sum = 0;
int mi = -1;
int i;
for (i = 0; i < n; i++) d[i] = ask(i, i);
for (i = 0; i < n; i++)
if (check(i)) {
sum++;
if (mi == -1) mi = i;
}
printf("!\n%d\n", sum);
for (i = 0; i < n; i++) {
b[i] = (mi ^ a[i]);
p[b[i]] = i;
}
for (i = 0; i < n; i++) printf("%d ", p[i]);
printf("\n");
}
int main() {
scanf("%d", &n);
int i;
for (i = 0; i < n; i++) a[i] = ask(0, i);
if (n % 2 == 1)
solve1();
else
solve2();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> v[100005];
int px[100005];
int py[100005];
int pz[100005];
bool use[100005];
int cnt[100005];
map<int, int> mp[100005];
int sol[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int x, y, z;
for (int i = 0; i < n - 2; i++) {
cin >> x >> y >> z;
mp[x][y]++;
mp[y][x]++;
mp[x][z]++;
mp[z][x]++;
mp[y][z]++;
mp[z][y]++;
cnt[x]++;
cnt[y]++;
cnt[z]++;
}
for (int i = 1; i <= n; i++) {
if (cnt[i] == 1) {
sol[1] = i;
break;
}
}
for (int i = 1; i <= n; i++) {
if (cnt[i] == 2 and mp[i][sol[1]] == 1) {
sol[2] = i;
break;
}
}
use[sol[1]] = true;
use[sol[2]] = true;
vector<pair<int, int> > vv;
for (int i = 3; i <= n; i++) {
vv.clear();
for (auto x : mp[sol[i - 1]]) {
vv.push_back({x.first, x.second});
}
for (auto x : vv) {
if (x.second == 2 and !use[x.first]) {
use[x.first] = true;
sol[i] = x.first;
}
}
}
for (int i = 1; i < n; i++) cout << sol[i] << " ";
for (int i = 1; i <= n; i++)
if (!use[i]) cout << i << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 dadi(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 100 + 5, K = 1e3 + 5;
int n, m, k, w[N], p[K], cnt[N][K];
struct game {
int u, v, t;
} a[K];
inline int add(int u, int v) {
shuffle(p, p + k, dadi);
int mx1 = *max_element(cnt[u], cnt[u] + k);
int mx2 = *max_element(cnt[v], cnt[v] + k);
for (int i = 0; i < k; i++)
if (cnt[u][p[i]] < mx1 && cnt[v][p[i]] < mx2) return p[i];
for (int i = 0; i < k; i++)
if (cnt[u][p[i]] < mx1 || cnt[v][p[i]] < mx2) return p[i];
return p[0];
}
inline void read_input() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < m; i++) {
cin >> a[i].u >> a[i].v;
a[i].u--, a[i].v--;
}
}
inline void solve() {
for (iota(p, p + k, 0); true; memset(cnt, 0, sizeof cnt)) {
bool flag = true;
for (int i = 0; i < m; i++) {
cnt[a[i].u][a[i].t = add(a[i].u, a[i].v)]++;
cnt[a[i].v][a[i].t++]++;
}
for (int i = 0; i < n; i++)
flag &=
*max_element(cnt[i], cnt[i] + k) - *min_element(cnt[i], cnt[i] + k) <
3;
if (flag) break;
}
}
inline void write_output() {
for (int i = 0; i < m; i++) cout << a[i].t << endl;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read_input(), solve(), write_output();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n{};
int p{};
int k, l, last, j;
cin >> n >> p;
last = 7 - p;
for (int i = 0; i < n; ++i) {
set<int> s{1, 2, 3, 4, 5, 6};
cin >> k >> l;
s.erase(k);
s.erase(7 - k);
s.erase(l);
s.erase(7 - l);
auto it = s.begin();
j = *it;
if (j != last && j != 7 - last) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
long long a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", a + i);
a[i]--;
}
long long tot = a[0];
long long p = 0;
long long val = 0;
long long ans = tot;
for (int i = 1; i < n; i++) {
if (a[i - 1] < a[i]) {
p = a[i - 1];
val = tot;
} else {
if (p < a[i]) {
val = (val * p + a[i] - p) % mod;
p = a[i];
} else {
val = (val * a[i]) % mod;
p = a[i];
}
}
val = (val + 1) % mod;
if (val < 0) val += mod;
if (p < 0) p += mod;
tot = (p * val + a[i] - p) % mod;
if (tot < 0) tot += mod;
ans = (ans + tot) % mod;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 3000;
const int MaxM = 3000;
const int MaxNL = MaxN * MaxM * 2;
int n, m, l, q;
int nl;
bool a[MaxN][MaxM];
int ufs[MaxNL];
int ufs_find(int v) {
int r = v;
while (ufs[r] >= 0) r = ufs[r];
for (int u = v, p = ufs[u]; u != r; u = p, p = ufs[u]) ufs[u] = r;
return r;
}
void ufs_union(int v, int u) {
v = ufs_find(v), u = ufs_find(u);
if (v == u) return;
if (ufs[v] > ufs[u])
ufs[v] = u;
else {
ufs[u] = v;
if (ufs[v] == ufs[u]) ufs[v]--;
}
}
int main() {
cin >> n >> m >> q;
l = m * 2;
nl = n * l;
for (int v = 0; v < nl; v++) ufs[v] = -1;
int res = 0;
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
if (m == 1) continue;
bool ok = true;
int liA_n = 0;
static int liA[8];
int liB_n = 0;
static int liB[8];
for (int dx = -1; dx <= 1; dx++)
if (0 <= x + dx && x + dx < n)
for (int dy = -1; dy <= 1; dy++) {
int ux = x + dx, uy = (y + dy + l) % l;
if (a[ux][uy % m]) liA[liA_n++] = ufs_find(ux * l + uy);
}
for (int ex = -1; ex <= 1; ex++)
if (0 <= x + ex && x + ex < n)
for (int ey = -1; ey <= 1; ey++) {
int wx = x + ex, wy = (y + ey + m) % l;
if (a[wx][wy % m]) liB[liB_n++] = ufs_find(wx * l + wy);
}
for (int i = 0; i < liA_n; i++)
for (int j = 0; j < liB_n; j++)
if (liA[i] == liB[j]) ok = false;
if (!ok) continue;
res++;
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++)
if (0 <= x + dx && x + dx < n) {
int ux = x + dx, uy = (y + dy + l) % l;
if (a[ux][uy % m]) ufs_union(ux * l + uy, x * l + y);
}
for (int dx = -1; dx <= 1; dx++)
for (int dy = -1; dy <= 1; dy++)
if (0 <= x + dx && x + dx < n) {
int ux = x + dx, uy = (y + dy + m) % l;
if (a[ux][uy % m]) ufs_union(ux * l + uy, x * l + m + y);
}
a[x][y] = true;
}
cout << res << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int k = 3;
while ((k + 1) * k / 2 <= n) k++;
vector<vector<int> > ans(k);
int c = 1;
for (int i = 0; i < k; i++)
for (int j = i + 1; j < k; j++) {
ans[i].push_back(c);
ans[j].push_back(c);
c++;
}
while (c <= n) {
ans[k - 1].push_back(c);
c++;
}
cout << k << endl;
for (int i = 0; i < k; i++) {
for (int j = 0; j < ans[i].size(); j++) cout << ans[i][j] << " ";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long t = 1, n, a, b, c[1000009], d[1000009];
map<long long, long long> mp2;
long long qp(long long x, long long y) {
if (!y) return 1;
long long p = qp(x, y / 2);
if (y & 1) return p * p * x;
return p * p;
}
int main() {
cin >> t;
while (t--) {
long long c1 = 0, c2 = 0, ans, aa = 1e18, f = 0;
cin >> a >> b, ans = a;
for (long long i = 2; i <= sqrt(b); i += 1)
if (!(b % i)) d[c2++] = i, mp2[i] += 1, b /= i, i -= 1;
if (b > 1) d[c2++] = b, mp2[b] += 1;
for (long long i = 0; i < c2; i += 1) {
if (i && d[i] == d[i - 1]) continue;
if (a % d[i]) {
f = 1;
break;
}
long long aaa = a, cur = 0;
while (!(aaa % d[i])) aaa /= d[i], cur += 1;
if (cur >= mp2[d[i]]) aa = min(aa, qp(d[i], cur - mp2[d[i]] + 1));
}
for (long long i = 0; i < c2; i += 1)
if (a % d[i]) f = 1;
for (long long i = 0; i < c2; i += 1) mp2[d[i]] = 0;
if (f == 1)
cout << ans << endl;
else
cout << (aa < 1e18 ? ans / aa : ans) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int label = -1, tot = 0;
int unpresent[105];
int n, contact[105][105];
bool con = 0;
int pre[105];
string tem;
cin >> n;
memset(contact, 0, sizeof(contact));
for (int i = 0; i < n; i++) {
cin >> tem;
for (int j = 0; j < tem.size(); j++) contact[i][j] = tem[j] - '0';
}
memset(unpresent, 0, sizeof(unpresent));
memset(pre, 0, sizeof(pre));
for (int i = 0; i < n; i++) cin >> pre[i];
for (int i = 0; i < n; i++)
if (pre[i] == 0) con = 1;
while (con) {
for (int i = 0; i < n; i++)
if (!pre[i]) {
label = i;
break;
}
unpresent[label] = 1;
tot++;
for (int i = 0; i < n; i++) {
if (contact[label][i]) pre[i]--;
}
con = 0;
for (int i = 0; i < n; i++)
if (pre[i] == 0) con = 1;
}
cout << tot << endl;
for (int i = 0; i < n; i++)
if (unpresent[i]) cout << i + 1 << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int ans = 1e9;
for (int i = 1; i * i <= n; i++) {
ans = min(ans, i - 1 + ((n - 1) / i));
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a1[300000], a2[300000], a3[300000];
int g[1000000], d[1000000];
int k1, k2, k3;
int main() {
cin >> k1 >> k2 >> k3;
for (int i = 0; i < k1; i++) cin >> a1[i];
for (int i = 0; i < k2; i++) cin >> a2[i];
for (int i = 0; i < k3; i++) cin >> a3[i];
sort(a1, a1 + k1);
sort(a2, a2 + k2);
sort(a3, a3 + k3);
int num[900000];
int n = k1 + k2 + k3;
int tot = 0;
for (int i = 0; i < k1; i++) num[tot++] = a1[i];
for (int i = 0; i < k2; i++) num[tot++] = a2[i];
for (int i = 0; i < k3; i++) num[tot++] = a3[i];
int l = n;
fill(g, g + l, (1 << 31 - 1));
int max_ = -1;
for (int i = 0; i < l; i++) {
int j = lower_bound(g, g + l, num[i]) - g;
d[i] = j + 1;
if (max_ < d[i]) max_ = d[i];
g[j] = num[i];
}
printf("%d\n", n - max_);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-15;
const double pi = acos(-1.0);
const int inf = (int)1e9 + 7;
const int mod = (int)1e9 + 7;
const int N = 1e5 + 5;
map<int, int> cnt;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int sum = 0;
for (int i = 1; i <= 5; i++) {
int k;
cin >> k;
cnt[k]++;
sum += k;
}
int mx = 0;
for (auto i : cnt) {
if (i.second == 2) {
mx = max(mx, 2 * i.first);
} else if (i.second > 2) {
mx = max(mx, 3 * i.first);
}
}
cout << sum - mx << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long linf = (long long)1e18;
const int mod = (int)1e9 + 7;
const long double eps = (long double)1e-8;
const int maxn = (int)2e5 + 5;
const long double pi = acos(-1);
vector<pair<pair<int, int>, int>> ans;
int centre, centre2;
vector<int> a[maxn];
set<pair<int, int>> q;
int sz[maxn], en[maxn], rv[maxn];
int n;
void dfs0(int v, int p = -1) {
int fl = 1;
sz[v] = 1;
for (auto to : a[v]) {
if (to == p) continue;
dfs0(to, v);
sz[v] += sz[to];
if (sz[to] >= n / 2 + n % 2) fl = 0;
}
if (n - sz[v] <= n / 2 && fl) {
centre = v;
centre2 = p;
}
}
void answer() {
assert(((int)(ans).size()) <= 2 * n);
cout << ((int)(ans).size()) << endl;
for (auto p : ans) {
cout << p.first.first << " " << p.first.second << " " << p.second << "\n";
}
exit(0);
}
void upd(int x, int y, int ty) {
ans.push_back({{x, y}, ty});
q.erase({min(x, y), max(x, y)});
q.insert({min(x, ty), max(x, ty)});
}
void solve(int v, int p) {
int cp = p;
en[v] = v;
rv[v] = v;
for (auto i = 0; i < ((int)(a[v]).size()); ++i) {
int to = a[v][i];
if (to == p) continue;
solve(to, v);
if (i == ((int)(a[v]).size()) - 1 ||
(i == ((int)(a[v]).size()) - 2 &&
a[v][((int)(a[v]).size()) - 1] == p)) {
en[v] = en[to];
break;
}
int ten = en[to];
upd(cp, v, ten);
if (cp == p) {
rv[v] = ten;
}
cp = rv[to];
}
en[rv[v]] = en[v];
}
void sol_centre(int centre, int centre2) {
for (auto to : a[centre]) {
if (to != centre2) solve(to, centre);
}
}
void dfs(int v, int p, int z) {
for (auto to : a[v]) {
if (to == p) continue;
dfs(to, v, z);
if (to != z) upd(v, to, z);
}
}
void sol2_centre(int centre, int centre2) {
for (auto to : a[centre]) {
if (to != centre2) {
dfs(to, centre, en[to]);
if (to != en[to]) upd(centre, to, en[to]);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
q.clear();
for (auto i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
q.insert({min(x, y), max(x, y)});
}
centre = -1;
dfs0(1);
assert(centre != -1);
if (sz[centre] == n / 2 && n % 2 == 0) {
} else {
centre2 = -1;
}
ans.clear();
sol_centre(centre, centre2);
if (centre2 != -1) {
sol_centre(centre2, centre);
}
for (auto i = 1; i <= n; ++i) {
a[i].clear();
}
for (auto e : q) {
a[e.first].push_back(e.second);
a[e.second].push_back(e.first);
}
sol2_centre(centre, centre2);
if (centre2 != -1) {
sol2_centre(centre2, centre);
}
answer();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long F[15];
vector<long long> p;
void dfs(long long c, long long mx) {
if (c > mx) return;
if (c) p.push_back(c);
dfs(10 * c + 4, mx);
dfs(10 * c + 7, mx);
}
int main() {
F[0] = 1;
for (int i = 1; i < 15; i++) F[i] = F[i - 1] * i;
cin >> n >> k;
if (n < 15 && F[n] < k)
cout << -1 << endl;
else {
int m = min(n, 15LL);
vector<long long> d;
for (long long i = n - m + 1; i <= n; i++) d.push_back(i);
vector<long long> pp;
int K = --k;
for (int i = 0; i < m; i++) {
int t = 0;
while (K >= F[m - i - 1]) {
K -= F[m - i - 1];
t++;
}
pp.push_back(d[t]);
d.erase(d.begin() + t);
}
long long r = 0;
dfs(0, n);
sort(p.begin(), p.end());
for (int i = 0; i < p.size(); i++)
if (p[i] <= n - m) r++;
for (int i = 1; i <= m; i++) {
if (binary_search(p.begin(), p.end(), n - m + i) &&
binary_search(p.begin(), p.end(), pp[i - 1]))
r++;
}
cout << r << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > V;
int main() {
int n, k, i, j;
scanf("%d %d", &n, &k);
int arr[n];
long long int suffix_total = 0;
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
suffix_total = suffix_total + arr[i];
}
sort(arr, arr + n);
pair<int, int> p;
p.first = arr[0];
p.second = 1;
V.push_back(p);
for (i = 1; i < n; i++) {
if (arr[i] == V[V.size() - 1].first) {
V[V.size() - 1].second++;
} else {
p.first = arr[i];
V.push_back(p);
}
}
if (V[0].second >= k || V[V.size() - 1].second >= k) {
printf("0");
return 0;
}
long long int ans = 1000000000000000000, prefix_total = 0;
int prefix_num = 0, suffix_num = n;
for (i = 0; i < V.size(); i++) {
if (V[i].second >= k) {
printf("0");
return 0;
}
int current_num = V[i].second;
long long int current_sum = V[i].first;
current_sum = current_sum * current_num;
suffix_total = suffix_total - current_sum;
suffix_num = suffix_num - current_num;
long long int cc = (k - V[i].second);
long long int first = V[i].first - 1, last = V[i].first + 1;
first = first * prefix_num - prefix_total;
last = suffix_total - last * suffix_num;
if (V[i].second + suffix_num >= k) {
ans = min(ans, last + cc);
}
if (V[i].second + prefix_num >= k) {
ans = min(ans, first + cc);
}
ans = min(ans, first + last + cc);
prefix_num = prefix_num + current_num;
prefix_total = prefix_total + current_sum;
}
printf("%I64d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
ofstream out("biconex.out");
ifstream in("biconex.in");
struct Edge {
int node;
bool is_critic;
};
const int N_MAX = 100000;
vector<Edge> neighbours[1 + N_MAX];
stack<int> component;
int n, m, h, minim = N_MAX + 1, node_ans, Depth, root_sons, depth[1 + N_MAX],
height[1 + N_MAX], main_hour[1 + N_MAX], color[1 + N_MAX];
bool visited[1 + N_MAX], not_in_subgraph[1 + N_MAX], is_critic[1 + N_MAX],
on_stack[1 + N_MAX];
void read() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> main_hour[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (main_hour[x] - main_hour[y] == 1 |
(main_hour[x] == 0 & main_hour[y] == h - 1))
neighbours[y].push_back({x, false});
if (main_hour[y] - main_hour[x] == 1 |
(main_hour[y] == 0 & main_hour[x] == h - 1))
neighbours[x].push_back({y, false});
}
for (int i = 1; i <= n; i++) depth[i] = -1;
}
void DFS(int node, int root) {
depth[node] = height[node] = Depth;
component.push(node);
on_stack[node] = true;
Depth++;
for (Edge& son : neighbours[node]) {
if (depth[son.node] == -1) {
DFS(son.node, root);
height[node] = min(height[node], height[son.node]);
} else if (on_stack[son.node])
height[node] = min(height[node], depth[son.node]);
}
if (height[node] == depth[node]) {
int son;
do {
son = component.top();
color[son] = node;
component.pop();
on_stack[son] = false;
} while (son != node);
}
}
int DFS2(int node, int cnt, bool possible_ans) {
cnt++;
visited[node] = true;
for (Edge son : neighbours[node]) {
if (color[node] != color[son.node]) {
possible_ans = false;
continue;
}
if (visited[son.node]) continue;
cnt = DFS2(son.node, cnt, possible_ans);
if (!cnt) possible_ans = false;
}
if (!possible_ans) cnt = 0;
return cnt;
}
void solution() {
for (int i = 1; i <= n; i++)
if (depth[i] == -1) DFS(i, i);
for (int i = 1; i <= n; i++) visited[i] = false;
for (int i = 1; i <= n; i++) {
if (visited[i]) continue;
int cnt = DFS2(i, 0, true);
if (cnt)
if (minim > cnt) {
minim = cnt;
node_ans = i;
}
}
}
void DFS_print(int node) {
cout << node << " ";
visited[node] = true;
for (Edge son : neighbours[node]) {
if (!visited[son.node]) DFS_print(son.node);
}
}
void print() {
cout << minim << "\n";
for (int i = 1; i <= n; i++) visited[i] = false;
DFS_print(node_ans);
}
int main() {
read();
solution();
print();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
int a, b, c, d;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> c >> d;
deque<int> res;
for (int i = 0; i < d; i++) {
res.push_back(3);
res.push_back(2);
c--;
}
if (res.size()) {
res.pop_back();
c++;
}
if (c < 0) {
cout << "NO";
return 0;
}
int cnt = 0;
while (c > 0 && b > 0) {
if (cnt % 2) {
if (res.size() == 0 || abs(res.back() - 2) == 1) {
res.push_back(2);
res.push_back(1);
b--;
c--;
}
} else {
if (res.size() == 0 || abs(res.front() - 2) == 1) {
res.push_front(2);
res.push_front(1);
b--;
c--;
}
}
cnt++;
}
if (c > 2) return cout << "NO", 0;
if (c == 1)
res.push_front(2);
else if (c == 2) {
res.push_back(2);
res.push_front(2);
}
if (res.size() && res.back() == 2) reverse(res.begin(), res.end());
while (b > 0 || a > 0) {
bool found = false;
if (a > 0) {
if (res.size() == 0 || res.back() == 1) {
res.push_back(0);
a--;
found = true;
} else if (res.size() == 0 || res.front() == 1) {
res.push_front(0);
a--;
found = true;
}
}
if (b > 0) {
if (res.size() == 0 || abs(res.back() - 1) == 1) {
res.push_back(1);
b--;
found = true;
} else if (res.size() == 0 || abs(res.front() - 1) == 1) {
res.push_front(1);
b--;
found = true;
}
}
if (!found) return cout << "NO", 0;
}
for (int i = 1; i < res.size(); i++) {
if (abs(res[i] - res[i - 1]) != 1) return cout << "NO", 0;
}
cout << "YES\n";
for (int x : res) cout << x << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void display(T a[], int size) {
for (int i = 0; i < size; i++) {
cout << a[i] << " ";
}
cout << endl;
}
void display(vector<pair<int, int> > a) {
for (int i = 0; i < a.size(); i++) {
cout << "(" << a[i].first << "," << a[i].second << ")"
<< " ";
}
cout << endl;
}
void display(vector<int> a) {
for (int i = 0; i < a.size(); i++) {
cout << a[i];
if (i == a.size() - 1)
cout << endl;
else
cout << " ";
}
}
template <typename T>
void initialise(T a[], T value, int length) {
for (int i = 0; i < length; i++) a[i] = value;
}
template <typename T>
void initialise(vector<T>& a, T value) {
for (int i = 0; i < a.size(); i++) a[i] = value;
}
bool compare(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second < b.second;
}
int max(int a[], int n) {
int max = -1000000000;
for (int i = 0; i < n; i++) {
if (a[i] > max) max = a[i];
}
return max;
}
bool find(string a[], string s, int n) {
int left = 0;
int right = n - 1;
while (left < right) {
int mid = (left + right) / 2;
if (s.compare(a[mid]) == 0)
return true;
else if (s.compare(a[mid]) < 0) {
right = mid;
} else {
left = mid + 1;
}
}
return false;
}
void factor(int a[], int base, int num, int n) {
for (int i = n - 1; i >= 0; i--) {
a[i] = num % base;
num = num / base;
}
}
int findLength(int n, int base) {
int i = 0;
while (n > 0) {
i++;
n = n / base;
}
return i;
}
int gcd(int a, int b) {
while (a % b != 0 && b % a != 0) {
if (b > a) {
b = b % a;
} else if (a > b) {
a = a % b;
}
}
if (a <= b)
return a;
else
return b;
}
int main() {
int n, m;
cin >> n >> m;
list<int> son[n];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
son[u - 1].push_back(v - 1);
son[v - 1].push_back(u - 1);
}
int side[n];
initialise(side, -1, n);
for (int i = 0; i < n; i++) {
if (side[i] != -1) continue;
queue<int> q;
q.push(i);
side[i] = 0;
while (!q.empty()) {
int current = q.front();
q.pop();
for (auto fil : son[current]) {
if (side[fil] == -1) {
side[fil] = 1 - side[current];
q.push(fil);
} else if (side[fil] == side[current]) {
cout << -1 << endl;
return 0;
} else
continue;
}
}
}
vector<int> zero;
vector<int> one;
for (int i = 0; i < n; i++) {
if (side[i] == 0)
zero.push_back(i + 1);
else
one.push_back(i + 1);
}
cout << zero.size() << endl;
for (int i = 0; i < zero.size(); i++) {
cout << zero[i];
if (i == zero.size() - 1)
cout << endl;
else
cout << " ";
}
cout << one.size() << endl;
for (int i = 0; i < one.size(); i++) {
cout << one[i];
if (i == one.size() - 1)
cout << endl;
else
cout << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long Raise(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = (1ll * ans * a) % MOD;
}
b >>= 1;
a = (1ll * a * a) % MOD;
}
return ans;
}
long long Multiply(long long a, long long b) {
long long ans = 0;
while (b) {
if (b & 1) {
ans = (1ll * ans + a) % MOD;
}
b >>= 1;
a = (1ll * a + a) % MOD;
}
return ans;
}
int main() {
long long x, k;
cin >> x >> k;
if (x == 0) {
cout << 0 << '\n';
return 0;
}
long long y = Raise(2, k);
cout << ((Multiply(y, (2 * x - 1) % MOD) + 1) % MOD + MOD) % MOD << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[55];
int main() {
int n;
cin >> n;
int m = 99;
for (int i = 0; i < n; i++) {
cin >> a[i];
m = min(a[i], m);
}
sort(a, a + n);
if (a[n / 2] == m)
cout << "Bob" << endl;
else
cout << "Alice" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
vector<long long> a(n + 1, -1), b(n + 1, 0);
vector<pair<long long, long long> > c;
for (long long i = 1; i < n + 1; i++) {
long long x, y;
cin >> x >> y;
c.push_back(make_pair(x, y));
}
sort(c.begin(), c.end());
for (long long i = 0; i < n; i++) {
a[i + 1] = c[i].first;
b[i + 1] = c[i].second;
}
vector<long long> dp(n + 1, 0);
for (long long i = 2; i < n + 1; i++) {
long long k = max(-1LL, a[i] - b[i]);
vector<long long>::iterator it = lower_bound(a.begin(), a.end(), k);
if (*it == a[i]) continue;
if (*it == -1)
dp[i] = i - (it - a.begin()) - 1;
else
dp[i] = i - (it - a.begin());
}
long long rem[n + 1];
for (long long i = 0; i < n + 1; i++) rem[i] = 0;
rem[1] = 1;
for (long long i = 2; i < n + 1; i++) rem[i] = 1 + rem[i - dp[i] - 1];
long long m = rem[n];
for (long long i = n; i >= 1; i--) m = max(m, rem[i - 1]);
cout << n - m;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt;
long long m, p[1000000], l[111111], r[111111], fl[1000000], fr[1000000], q,
dmin;
int main() {
scanf("%d%I64d", &n, &m);
for (int i = 1; i <= 18; ++i) {
for (int s = 0; s < (1 << i); ++s) {
long long k = 0;
for (int j = (i - 1); j >= (0); --j) k = k * 10 + (s >> j & 1 ? 7 : 4);
p[cnt++] = k;
}
}
for (int i = 0; i < (n); ++i) {
scanf("%I64d%I64d", l + i, r + i);
if (!i || r[i] - l[i] < dmin) dmin = r[i] - l[i];
}
sort(l, l + n);
sort(r, r + n);
q = 0;
l[n] = r[n] = 2E18;
for (int i = 0; i < (cnt); ++i) {
if (!i)
fl[i] = 0;
else {
if (fl[i - 1] + double(q) * (p[i] - p[i - 1]) > 2E18)
fl[i] = m + 1;
else
fl[i] = fl[i - 1] + q * (p[i] - p[i - 1]);
}
if (fl[i] > m) fl[i] = m + 1;
while (r[q] < p[i]) {
fl[i] += p[i] - r[q++];
if (fl[i] > m) fl[i] = m + 1;
}
}
q = n - 1;
for (int i = (cnt - 1); i >= (0); --i) {
if (i == cnt - 1)
fr[i] = 0;
else {
if (fr[i + 1] + double(n - 1 - q) * (p[i + 1] - p[i]) > 2E18)
fr[i] = m + 1;
else
fr[i] = fr[i + 1] + (n - 1 - q) * (p[i + 1] - p[i]);
}
if (fr[i] > m) fr[i] = m + 1;
while (l[q] > p[i]) {
fr[i] += l[q--] - p[i];
if (fr[i] > m) fr[i] = m + 1;
}
}
int l = 0, r = cnt;
while (l < r) {
int md = 1 + l + r >> 1;
bool ok = false;
for (int i = (md - 1); i <= (cnt - 1); ++i) {
if (p[i] - p[i - md + 1] <= dmin && fr[i - md + 1] + fl[i] <= m) {
ok = true;
break;
}
}
if (!ok)
r = md - 1;
else
l = md;
}
cout << l << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 77, Mod = 1e9 + 7;
int n, U, a[N];
long double A = -1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> U;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
a[n + 1] = Mod * 2;
for (int i = 1; i <= n; i++) {
int pos = upper_bound(a + i, a + n + 2, U + a[i]) - a;
pos--;
if (a[pos] - a[i] > U || pos <= i + 1) continue;
A = max(A, (long double)(a[pos] - a[i + 1]) / (long double)(a[pos] - a[i]));
}
if (A == -1) return cout << -1, 0;
cout << fixed << setprecision(13) << A;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l, c, d, p, nl, np, m1, m2, m3, m = 99999999;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
m1 = k * l / nl;
m2 = c * d;
m3 = p / np;
m = min(m, m1);
m = min(m, m2);
m = min(m, m3);
cout << m / n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005, L = 1505, M = 1e9 + 7;
long long n, m, x, y, P, k, fac[N], inv[N], p[L], f[L][L], s[L][L], pre[L];
long long ksm(long long x, long long y) {
if (y < 0) y += M - 1;
long long ans = 1;
for (; y; y >>= 1, x = x * x % M)
if (y & 1) (ans *= x) %= M;
return ans;
}
long long C(long long x, long long y) {
if (x < y) return 0;
return fac[x] * inv[y] % M * inv[x - y] % M;
}
signed main() {
scanf("%lld%lld%lld%lld%lld", &n, &m, &x, &y, &k);
P = x * ksm(y, M - 2) % M;
fac[0] = inv[0] = 1;
for (long long i = 1; i < N; i++)
fac[i] = fac[i - 1] * i % M, inv[i] = ksm(fac[i], M - 2);
for (long long i = 1; i <= m; i++)
p[i] =
ksm(P, i - 1) * ksm((1 - P + M) % M, k - i + 1) % M * C(k, i - 1) % M;
for (long long i = 1; i <= m; i++) pre[i] = (pre[i - 1] + p[i]) % M;
f[0][m] = s[0][m] = 1;
for (long long i = 1; i <= n; i++) {
long long w = 0;
for (long long j = 1; j <= m; j++) {
(w += p[j] * (s[i - 1][m] + M - s[i - 1][j - 1]) % M) %= M;
f[i][j] = (w + M - s[i - 1][m - j] * pre[j] % M) * p[m - j + 1] % M;
s[i][j] = (s[i][j - 1] + f[i][j]) % M;
}
}
printf("%lld", s[n][m]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string lb[1010];
bool u[1010][1010][4];
char ch(char c, int state) {
if (c == '+' || c == '*') return c;
if (c == '-') return (state % 2 == 0) ? '-' : '|';
if (c == '|') return (state % 2 == 0) ? '|' : '-';
if (c == '>') state = (state + 1) % 4;
if (c == 'v') state = (state + 2) % 4;
if (c == '<') state = (state + 3) % 4;
if (c == '^' || c == '>' || c == 'v' || c == '<') {
if (state == 0) return '^';
if (state == 1) return '>';
if (state == 2) return 'v';
if (state == 3) return '<';
}
if (c == 'R') state = (state + 1) % 4;
if (c == 'D') state = (state + 2) % 4;
if (c == 'L') state = (state + 3) % 4;
if (c == 'U' || c == 'R' || c == 'D' || c == 'L') {
if (state == 0) return 'U';
if (state == 1) return 'R';
if (state == 2) return 'D';
if (state == 3) return 'L';
}
}
bool rt(int x, int y, int d, int state) {
char c = lb[y][x];
c = ch(c, state);
if (c == '+') return 1;
if (c == '*') return 0;
if (c == '-') return d % 2 == 0;
if (c == '|') return d % 2 == 1;
if (c == '<') return d == 0;
if (c == '^') return d == 1;
if (c == '>') return d == 2;
if (c == 'v') return d == 3;
if (c == 'L') return !(d == 0);
if (c == 'U') return !(d == 1);
if (c == 'R') return !(d == 2);
if (c == 'D') return !(d == 3);
}
bool pg(int x, int y, int d, int state) {
int x1 = x;
int y1 = y;
if (d == 0) --x1;
if (d == 1) --y1;
if (d == 2) ++x1;
if (d == 3) ++y1;
if (x1 < 0 || x1 >= m || y1 < 0 || y1 >= n) return 0;
return rt(x, y, d, state) && rt(x1, y1, (d + 2) % 4, state);
}
vector<pair<pair<pair<int, int>, int>, int> > ww;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> lb[i];
int xt, yt, xm, ym;
cin >> xt >> yt >> xm >> ym;
--xt;
--yt;
--xm;
--ym;
swap(xt, yt);
swap(xm, ym);
ww.push_back(make_pair(make_pair(make_pair(xt, yt), 0), 0));
u[xt][yt][0] = 1;
int ans = -1;
for (int i = 0; i < ww.size(); ++i) {
int x = ww[i].first.first.first;
int y = ww[i].first.first.second;
int st = ww[i].first.second;
int mv = ww[i].second;
if (x == xm && y == ym) {
ans = mv;
break;
}
for (int d = 0; d < 4; ++d) {
int x1 = x;
int y1 = y;
if (d == 0) --x1;
if (d == 1) --y1;
if (d == 2) ++x1;
if (d == 3) ++y1;
if (pg(x, y, d, st) == 0 || u[x1][y1][st]) continue;
u[x1][y1][st] = 1;
ww.push_back(make_pair(make_pair(make_pair(x1, y1), st), mv + 1));
}
if (u[x][y][(st + 1) % 4] == 0) {
u[x][y][(st + 1) % 4] = 1;
ww.push_back(make_pair(make_pair(make_pair(x, y), (st + 1) % 4), mv + 1));
}
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 50 + 10;
int n;
struct tim {
int scr, goal, sub;
string name;
} arr[Maxn];
vector<string> ans;
bool moq(tim a, tim b) {
if (a.scr < b.scr) return true;
if (a.scr > b.scr) return false;
if (a.sub < b.sub) return true;
if (a.sub > b.sub) return false;
if (a.goal < b.goal) return true;
return false;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i].name;
for (int k = 0; k < n * (n - 1) / 2; k++) {
string s1, s2, s, sp;
cin >> s >> sp;
int j = 0;
while (s[j] != '-') {
s1 += s[j];
j++;
}
j++;
while (j < s.size()) {
s2 += s[j];
j++;
}
int g1 = 0, g2 = 0;
j = 0;
while (sp[j] != ':') {
g1 *= 10;
g1 += sp[j] - '0';
j++;
}
j++;
while (j < sp.size()) {
g2 *= 10;
g2 += sp[j] - '0';
j++;
}
for (int i = 0; i < n; i++) {
if (arr[i].name == s1) {
arr[i].goal += g1;
arr[i].sub += g1 - g2;
if (g1 > g2)
arr[i].scr += 3;
else {
if (g1 == g2) arr[i].scr++;
}
}
if (arr[i].name == s2) {
arr[i].goal += g2;
arr[i].sub += g2 - g1;
if (g2 > g1)
arr[i].scr += 3;
else {
if (g1 == g2) arr[i].scr++;
}
}
}
}
sort(arr, arr + n, moq);
for (int i = n / 2; i < n; i++) ans.push_back(arr[i].name);
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
template <class T>
inline bool read(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return false;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return true;
}
template <class T>
inline void output(T answer) {
if (answer < 0) {
putchar('-');
answer = -answer;
}
if (answer >= 10) output(answer / 10);
putchar(answer % 10 + '0');
return;
}
inline long long addMod(long long x, long long y, long long mod) {
x += y;
if (x > mod) x -= mod;
return x;
}
inline long long minusMod(long long x, long long y, long long mod) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline long long qmul(long long, long long, long long);
inline long long qpow_qmul(long long, long long, long long);
inline long long mul(long long, long long, long long);
inline long long qpow(long long, long long, long long);
inline long long gcd(long long, long long);
inline long long qpow_mul(long long, long long, long long);
const int N = 1e5 + 10;
const int M = 2e5 + 5;
const long long INF = 1e14 + 2;
const long long mod = 1e9 + 7;
const double PI = acos(-1.0);
const double esp = 1e-7;
const int MAXN = 2e5 + 5;
long long solve(long long n) {
if (n < 10)
return max(1ll, n);
else
return max((n % 10) * solve(n / 10), 9 * solve(n / 10 - 1));
}
int main() {
long long n, m, s, e;
int q, x, y;
scanf("%lld%lld%d", &n, &m, &q);
long long gcd_ = gcd(n, m);
n /= gcd_;
m /= gcd_;
while (q--) {
scanf("%d%lld%d%lld", &x, &s, &y, &e);
if (gcd_ == 1)
printf("YES\n");
else {
if (x == 1 && y == 1) {
if ((s - 1) / n == (e - 1) / n)
printf("YES\n");
else
printf("NO\n");
} else if (x == 1 && y == 2) {
if ((s - 1) / n == (e - 1) / m)
printf("YES\n");
else
printf("NO\n");
} else if (x == 2 && y == 1) {
if ((s - 1) / m == (e - 1) / n)
printf("YES\n");
else
printf("NO\n");
} else {
if ((s - 1) / m == (e - 1) / m)
printf("YES\n");
else
printf("NO\n");
}
}
}
return 0;
}
inline long long mul(long long a, long long b, long long MOD) {
long long L = a * (b >> 25ll) % MOD * (1ll << 25) % MOD;
long long R = a * (b & ((1ll << 25) - 1)) % MOD;
return (L + R) % MOD;
}
inline long long qpow_mul(long long x, long long n, long long MOD) {
long long ans = 1, a = x % MOD;
while (n) {
if (n & 1) {
ans = mul(ans, a, MOD);
}
a = mul(a, a, MOD);
n >>= 1;
}
return ans;
}
inline long long qmul(long long a, long long b, long long MOD) {
long long ans = 0, x = a;
while (b) {
if (b & 1) {
ans = (ans + x) % MOD;
}
x = x * 2 % MOD;
b >>= 1;
}
return ans % MOD;
}
inline long long qpow_qmul(long long x, long long n, long long MOD) {
long long ans = 1, a = x % MOD;
while (n) {
if (n & 1) {
ans = qmul(ans, a, MOD);
}
a = qmul(a, a, MOD);
n >>= 1;
}
return ans;
}
inline long long qpow(long long x, long long n, long long MOD) {
if (x == 1) return 1;
long long ans = 1, a = x;
while (n) {
if (n & 1) {
ans = ans * a % MOD;
}
a = a * a % MOD;
n >>= 1;
}
return ans;
}
inline long long gcd(long long m, long long n) {
return n == 0 ? m : gcd(n, m % n);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 9;
struct bridge {
long long int x;
long long int v;
bool operator<(const bridge &t) const { return v < t.v; }
};
multiset<bridge> vec;
struct P {
long long int first, second;
long long int ans;
int x;
};
P maxn[MAX_N];
bool cmp(const P &A, const P &B) { return A.first < B.first; }
bool cmp3(const P &A, const P &B) { return A.x < B.x; }
bool used[MAX_N];
int main() {
int N, M, T;
while (scanf("%d%d", &N, &M) != EOF) {
vec.clear();
memset(used, false, sizeof(used));
long long int pre1, pre2;
scanf("%I64d%I64d", &pre1, &pre2);
for (int i = 1; i < N; i++) {
long long int temp1, temp2;
scanf("%I64d%I64d", &temp1, &temp2);
maxn[i - 1].second = temp1 - pre2;
maxn[i - 1].first = temp2 - pre1;
maxn[i - 1].x = i;
pre1 = temp1;
pre2 = temp2;
}
for (int i = 0; i < M; i++) {
bridge temp;
scanf("%I64d", &temp.v);
temp.x = i + 1;
vec.insert(temp);
}
sort(maxn, maxn + N - 1, cmp);
int point = 1;
for (int i = 0; i < N - 1; i++) {
multiset<bridge>::iterator it;
it = vec.lower_bound(bridge{0, maxn[i].second});
if (it == vec.end()) {
cout << "No" << endl;
point = 0;
break;
} else if (it->v <= maxn[i].first) {
maxn[i].ans = it->x;
vec.erase(it);
} else {
cout << "No" << endl;
point = 0;
break;
}
}
sort(maxn, maxn + N - 1, cmp3);
if (point == 1) {
printf("Yes\n");
for (int i = 0; i < N - 2; i++) {
printf("%I64d ", maxn[i].ans);
}
printf("%I64d\n", maxn[N - 2].ans);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long n, i;
using namespace std;
int main() {
cin >> n;
cout << n;
for (i = 1; i < n; i++) cout << " " << i;
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long MOD = 998244353;
using ll = long long;
const int maxn = 2e6 + 555;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int len;
string x;
cin >> len >> x;
int L = 0, R = 0;
for (auto i : x) {
if (i == '(')
L++;
else
R++;
}
if (L != R) {
cout << "No" << endl;
return 0;
}
stack<char> s;
int vain = 0;
for (auto i : x) {
if (i == '(')
s.push(i);
else if (!s.empty() && s.top() == '(')
s.pop();
else if (vain) {
cout << "No" << endl;
return 0;
} else {
vain = 1;
}
}
if (!vain) {
cout << "Yes" << endl;
return 0;
} else if (s.size() == 1 && s.top() == '(') {
cout << "Yes" << endl;
return 0;
} else {
cout << "No" << endl;
return 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename D>
std::ostream& operator<<(std::ostream& os, const std::pair<T, D>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> a;
a.push_back(0);
for (int i = (0); i < (n); i++) {
long long e;
cin >> e;
a.push_back(e);
}
a.push_back(1001);
long long max_chain = 1;
long long curr_num = 0;
long long chain = 1;
for (int i = (1); i < (n + 2); i++) {
if (a[i] == curr_num + 1) {
chain++;
if (chain > max_chain) max_chain = chain;
} else {
chain = 1;
}
curr_num = a[i];
}
cout << max(max_chain - 2, 0ll) << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * f;
}
inline long long readll() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * f;
}
inline void write(int x) {
if (!x) putchar('0');
if (x < 0) x = -x, putchar('-');
static int sta[20];
register int tot = 0;
while (x) sta[tot++] = x % 10, x /= 10;
while (tot) putchar(sta[--tot] + 48);
}
const int maxn = 200007, INF = 0x3f3f3f3f;
const int MOD = 998244353;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const long long P = 19260817;
inline int mod1(int x) { return x < MOD ? x : x - MOD; }
inline int mod2(int x) { return x < 0 ? x + MOD : x; }
inline void add(int &x, int y) { x = mod1(x + y); }
inline void sub(int &x, int y) { x = mod2(x - y); }
int n, m, K;
long long a[19][19];
long long gauss(int N) {
long long ans = 1;
for (int i = 1; i <= N; i++) {
for (int k = i + 1; k <= N; k++) {
while (a[k][i]) {
long long d = a[i][i] / a[k][i];
for (int j = i; j <= N; j++)
a[i][j] = (a[i][j] - d * a[k][j] % MOD + MOD) % MOD;
swap(a[i], a[k]), ans = MOD - ans;
}
}
ans = ans * a[i][i] % MOD, ans = (ans + MOD) % MOD;
}
return ans % MOD;
}
void addedge(int u, int v) {
a[u][u]++, a[v][v]++;
a[u][v]--, a[v][u]--;
}
int g[19][19];
int f[1089];
int st[maxn], tp;
int main() {
n = read(), m = read(), K = read();
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
g[u][v]++;
g[v][u]++;
}
for (int i = 0; i < (1 << n); i++) {
memset(a, 0, sizeof(a));
tp = 0;
for (int j = 1; j <= n; j++)
if (!((1 << (j - 1)) & i)) st[++tp] = j;
for (int j = 1; j <= tp; j++) {
for (int k = j + 1; k <= tp; k++) {
if (g[st[j]][st[k]]) addedge(j, k);
}
}
f[i] = gauss(tp - 1);
for (int j = 1; j <= n; j++) {
if (!((1 << (j - 1)) & i)) continue;
int tmp = 0;
for (int k = 1; k <= n; k++)
if (g[j][k] && !((1 << (k - 1)) & i)) tmp++;
f[i] *= tmp;
}
}
for (int i = 1; i <= n; i++) {
for (int j = (1 << n) - 1; j >= 0; j--) {
if (!(j & (1 << (i - 1)))) f[j] -= f[j ^ (1 << (i - 1))];
}
}
int ans = 0;
for (int i = 0; i < (1 << n); i++) {
if (__builtin_popcount(i) == K) ans += f[i];
}
printf("%d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
;
int64_t n, p, w, d;
cin >> n >> p >> w >> d;
int64_t x, y, z, xx;
for (y = 0; y < w; ++y) {
xx = (p - (y * d)) % w;
if (xx == 0) {
x = (p - (y * d)) / w;
z = n - x - y;
break;
}
}
if (x < 0 or y < 0 or z < 0)
cout << "-1\n";
else
cout << x << " " << y << " " << z << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans;
int main() {
scanf("%lld", &n);
for (long long i = 2; i < n; i++) {
ans += i * (i + 1);
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF_MAX = 0x7FFFFFFF;
const int INF_MIN = -(1 << 31);
const double eps = 1e-10;
const double pi = acos(-1.0);
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
int dir_4[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
int dir_8[8][2] = {{0, 1}, {-1, 1}, {-1, 0}, {-1, -1},
{0, -1}, {1, -1}, {1, 0}, {1, 1}};
stack<char> s;
stack<char> a;
void fun(char k) {
while (!s.empty() && k > s.top()) s.pop();
s.push(k);
}
void output() {
while (!s.empty()) {
a.push(s.top());
s.pop();
}
while (!a.empty()) {
cout << a.top();
a.pop();
}
cout << endl;
return;
}
int main() {
string ss;
cin >> ss;
for (int i = 0; i < ss.length(); i++) {
fun(ss[i]);
}
output();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > a[100100];
set<int> b[100100];
priority_queue<pair<int, int> > q;
int stm[100100];
int main(int argc, char *argv[]) {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int st, en, val;
cin >> st >> en >> val;
--st;
--en;
a[st].push_back(make_pair(en, val));
a[en].push_back(make_pair(st, val));
}
for (int i = 0; i < n; ++i) {
stm[i] = 2100000000;
int kn;
cin >> kn;
for (int j = 0; j < kn; ++j) {
int tmp;
cin >> tmp;
b[i].insert(tmp);
}
}
stm[0] = 0;
q.push(make_pair(0, 0));
while (!q.empty()) {
int nowt = -q.top().first;
int nown = q.top().second;
q.pop();
if (b[nown].count(nowt) > 0) {
q.push(make_pair(-(nowt + 1), nown));
continue;
}
for (int i = 0; i < ((int)((a[nown]).size())); ++i) {
pair<int, int> next = a[nown][i];
if (nowt + next.second < stm[next.first]) {
stm[next.first] = nowt + next.second;
q.push(make_pair(-stm[next.first], next.first));
}
}
}
if (stm[n - 1] >= 2100000000)
cout << -1 << endl;
else
cout << stm[n - 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 10;
const int INF = INT_MAX;
const double EXP = 0.0001;
void files() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int a[MAXN];
int main() {
ios_base::sync_with_stdio(false);
int n, ans0 = 0, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 1) ans0++;
}
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
int cnt1 = 0, cnt2 = 0;
for (int i = l; i <= r; i++)
if (a[i] == 0)
cnt1++;
else
cnt2++;
ans = max(ans, ans0 + cnt1 - cnt2);
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n;
cin >> n;
cin >> s;
int sum = 0;
for (int i = n; i < s.size(); i += n)
if (s[i - 1] == s[i - 2] && s[i - 2] == s[i - 3]) sum++;
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<set<int> > adj(222222);
vector<int> ans;
void doit(int x, int p) {
if (p != -1) {
adj[p].erase(adj[p].find(x));
adj[x].erase(adj[x].find(p));
}
ans.push_back(x);
vector<int> edg;
for (__typeof(adj[x].begin()) it = adj[x].begin(); it != adj[x].end(); it++)
edg.push_back(*it);
for (__typeof(edg.begin()) it = edg.begin(); it != edg.end(); it++)
doit(*it, x);
}
void dfs(int x, int p) {
int ec = 0;
vector<int> edg;
for (__typeof(adj[x].begin()) it = adj[x].begin(); it != adj[x].end(); it++) {
if (*it == p) continue;
edg.push_back(*it);
}
for (__typeof(edg.begin()) it = edg.begin(); it != edg.end(); it++)
dfs(*it, x);
ec += adj[x].size();
if (ec % 2 == 0) doit(x, p);
}
int main() {
cin >> n;
int x;
for (int i = 1; i <= n; i++) {
cin >> (x);
if (x == 0) continue;
adj[i].insert(x);
adj[x].insert(i);
}
dfs(1, -1);
if (adj[1].size() == 0) {
cout << "YES" << '\n';
for (__typeof(ans.begin()) it = ans.begin(); it != ans.end(); it++)
cout << *it << '\n';
} else
cout << "NO" << '\n';
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long INF = 1000LL * 1000 * 1000 * 1000 * 1000 * 1000;
const int inf = 1000 * 1000 * 1000;
const long double PI = acos(-1.0);
const long long mod1 = inf + 9;
const long long mod2 = inf + 9;
const long long bigmod = 1LL * inf * 100 + 3;
const int MAXN = 1000005;
const long double EPS = 1e-11;
const int N = 300228;
long long hp = 29;
int ans = 0;
vector<int> cnt(228228);
vector<int> aoao;
bool cmp(int a, int b) { return cnt[a] > cnt[b]; }
bool check(int k, int sz) {
int ns = 0;
for (int i : aoao) {
int tk = 0;
while (cnt[i] / (tk + 1) >= sz) tk++;
ns += tk;
}
return ns >= k;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
;
int n, k;
cin >> n >> k;
vector<int> a(n);
for (long long i = 0; i < a.size(); ++i) cin >> a[i];
;
for (int i : a) {
cnt[i]++;
}
for (int i = 0; i < cnt.size(); ++i) {
if (cnt[i]) {
aoao.push_back(i);
}
}
sort((aoao).begin(), (aoao).end(), cmp);
int l = 0, r = n;
while (r - l > 1) {
int m = (l + r) / 2;
if (check(k, m)) {
l = m;
} else {
r = m;
}
}
if (!check(k, r)) {
r--;
}
if (check(k, r + 1)) {
r++;
}
vector<int> ans;
int ns = 0;
for (int i : aoao) {
int tk = 1;
ans.push_back(i);
ns++;
while (cnt[i] / (tk + 1) >= r) {
tk++;
ns++;
ans.push_back(i);
if (ns == k) {
break;
}
}
if (ns == k) {
break;
}
}
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << ' ';
;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200, M = 1000000007;
int n, x[maxn], y[maxn], opt[maxn][maxn];
bool st[maxn][maxn];
int Muti(int p0, int p1, int q0, int q1) {
int px = x[p1] - x[p0], py = y[p1] - y[p0], qx = x[q1] - x[q0],
qy = y[q1] - y[q0];
long long t = 1LL * px * qy - 1LL * py * qx;
if (t > 0) return 1;
if (t < 0) return -1;
return 0;
}
int Poin(int p0, int p1, int q0, int q1) {
int px = x[p1] - x[p0], py = y[p1] - y[p0], qx = x[q1] - x[q0],
qy = y[q1] - y[q0];
long long t = 1LL * px * qx + 1LL * py * qy;
if (t > 0) return 1;
if (t < 0) return -1;
return 0;
}
bool Cross(int x, int y, int u, int v) {
if (x == u || x == v || y == u || y == v) return 0;
if (Muti(x, u, x, y) * Muti(x, v, x, y) < 0 &&
Muti(u, x, u, v) * Muti(u, y, u, v) < 0)
return 1;
return 0;
}
bool Online(int p, int x, int y) {
if (p == x || p == y) return 0;
if (Muti(p, x, p, y) == 0 && Poin(p, x, p, y) < 0) return 1;
return 0;
}
bool Outside(int p0, int p1) {
int i, j = n - 1;
double yi, yj, xi, xj, px = x[p0] + x[p1], py = y[p0] + y[p1];
px = px / 2;
py = py / 2;
bool q = 1;
for (i = 0; i < n; i++) {
yi = y[i], yj = y[j], xi = x[i], xj = x[j];
if (((yi < py && yj >= py) || (yj < py && yi >= py)) &&
(xi <= px || xj <= px))
q ^= (xi + (py - yi) / (yj - yi) * (xj - xi) < px);
j = i;
}
return q;
}
bool Check(int x, int y) {
if (x == y) return 0;
if ((x + 1) % n == y || (y + 1) % n == x) return 1;
for (int i = 0; i < n; i++)
if (Online(i, x, y)) return 0;
for (int i = 0; i < n; i++)
if (Cross(x, y, i, (i + 1) % n)) return 0;
if (Outside(x, y)) return 0;
return 1;
}
int Ans(int x, int y) {
if (opt[x][y] < 0) {
opt[x][y] = 0;
for (int i = x + 1; i < y; i++)
if (st[x][i] && st[i][y])
opt[x][y] = (1LL * Ans(x, i) * Ans(i, y) + opt[x][y]) % M;
}
return opt[x][y];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &x[i], &y[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
opt[i][j] = -1;
st[i][j] = Check(i, j);
}
for (int i = 0; i < n - 1; i++) opt[i][i + 1] = 1;
printf("%d\n", Ans(0, n - 1));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const double eps = 1e-8;
const int INF32 = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const unsigned long long mod2 = 1;
const int N = 5e3 + 5;
const int sz = (1 << 20);
int num[N], ans[N], cnt;
void dfs(int dpt, int fa) {
ans[++cnt] = fa;
int u = cnt;
if (num[dpt]) {
--num[dpt];
dfs(dpt + 1, u);
}
if (num[dpt]) {
--num[dpt];
dfs(dpt + 1, u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int q;
cin >> q;
while (q--) {
int n, d;
cin >> n >> d;
for (int i = 0; i < n; ++i) {
num[i] = 1;
d -= i;
}
int l = 1, r = n - 1;
while (d) {
if (l - r < d) {
++l;
} else {
d += r - l;
++num[l];
--num[r];
--r;
if (num[l] == (1 << min(l, 20))) ++l;
}
if (l >= r) break;
}
if (l >= r && d) {
cout << "NO" << '\n';
continue;
}
cout << "YES" << '\n';
cnt = 0;
dfs(1, 0);
for (int i = 2; i <= n; ++i) {
cout << ans[i] << ' ';
}
cout << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int r1, c1, r2, c2;
char Map[600][600];
int dir[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};
typedef struct point {
int x, y;
};
bool judge(const point &t) {
if (t.x < 1 || t.x > N || t.y < 1 || t.y > M) return false;
return true;
}
bool bfs() {
queue<point> q;
point sta, endd, tmp, nex;
while (!q.empty()) q.pop();
sta.x = r1;
sta.y = c1;
endd.x = r2;
endd.y = c2;
q.push(sta);
while (!q.empty()) {
tmp = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
nex.x = tmp.x + dir[i][0];
nex.y = tmp.y + dir[i][1];
if (judge(nex)) {
if (nex.x == endd.x && nex.y == endd.y) {
if (Map[endd.x][endd.y] == 'X')
return 1;
else {
Map[endd.x][endd.y] = 'X';
q.push(nex);
}
} else {
if (Map[nex.x][nex.y] == '.') {
Map[nex.x][nex.y] = 'X';
q.push(nex);
}
}
}
}
}
return false;
}
int main() {
cin >> N >> M;
memset(Map, 0, sizeof(Map));
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
cin >> Map[i][j];
}
}
cin >> r1 >> c1 >> r2 >> c2;
if (bfs())
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long k;
vector<pair<long long, char>> aa;
void print(long long a, char c) {
a = min(a, k);
if (a != 0) {
aa.push_back({a, c});
}
k -= a;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m >> k;
if (k > 4 * n * m - 2 * n - 2 * m) {
cout << "NO";
return 0;
}
cout << "YES\n";
for (long long i = 0; i < m - 1; i++) {
print(1, 'R');
print(n - 1, 'D');
print(n - 1, 'U');
}
print(m - 1, 'L');
for (long long i = 0; i < n - 1; i++) {
print(1, 'D');
print(m - 1, 'R');
print(m - 1, 'L');
}
print(n - 1, 'U');
cout << aa.size() << "\n";
for (auto i : aa) {
cout << i.first << " " << i.second << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long in[100010];
long long n;
int main() {
long long x, y;
while (~scanf("%lld", &n)) {
memset(in, 0, sizeof(in));
for (long long i = 1; i < n; i++) {
scanf("%lld%lld", &x, &y);
in[x]++;
in[y]++;
}
if (n == 2) {
printf("Yes\n");
printf("1\n");
printf("%lld %lld\n", x, y);
continue;
}
long long ok = 0, root = 0, cnt = 0;
for (long long i = 1; i <= n; i++) {
if (in[i] >= 3) {
root = i;
ok++;
} else if (in[i] == 1) {
cnt++;
}
}
if (root == 0) {
for (long long i = 1; i <= n; i++) {
if (in[i] == 2) {
root = i;
break;
}
}
}
if (ok > 1)
printf("No\n");
else {
printf("Yes\n");
printf("%lld\n", cnt);
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
if (in[i] == 1) {
printf("%lld %lld\n", root, i);
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, cnt, f[2000005], head[2000005], vis[2000005], cnt1, cnt2,
l[2000005], use[2000005];
struct edge {
int v, nxt;
} e[2000005];
void add(int u, int v) {
e[++cnt].v = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
int find(int x) {
if (f[x] == x)
return f[x];
else
return f[x] = find(f[x]);
}
void bfs() {
queue<int> q;
q.push(1);
vis[1] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (!vis[v]) {
vis[v] = 1;
q.push(v);
printf("%d %d\n", u, v);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (u > v) swap(u, v);
if (u != 1) {
add(u, v);
add(v, u);
f[find(u)] = find(v);
} else
l[++cnt1] = v;
}
for (int i = 2; i <= n; i++) {
if (f[i] == i) cnt2++;
}
if (cnt1 < k || cnt2 > k) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= cnt1; i++) {
int v = l[i];
if (use[find(v)]) continue;
use[find(v)] = 1;
l[i] = -1;
add(1, v);
add(v, 1);
k--;
}
if (k) {
for (int i = 1; i <= cnt1 && k; i++) {
int v = l[i];
if (l[i] == -1) continue;
add(1, v);
add(v, 1);
k--;
}
}
bfs();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mo = 1e9 + 7;
long long poi[10001], F[10001], nxt[10001], dep[1001], f[1001][1001], tmp[1001],
ans, n, k, x, y, cnt;
bool vis[1001];
inline void add(long long x, long long y) {
poi[++cnt] = y;
nxt[cnt] = F[x];
F[x] = cnt;
}
inline void dfs(long long x) {
vis[x] = 1;
f[x][0] = 1;
f[x][k + 1] = 1;
for (long long i = F[x]; i; i = nxt[i]) {
long long ne = poi[i];
if (vis[ne]) continue;
dep[ne] = dep[x] + 1;
dfs(ne);
for (long long j = 0; j <= 2 * k; j++) tmp[j] = 0;
for (long long j = 0; j <= 2 * k; j++)
for (long long t = 0; t <= 2 * k + 1; t++) {
if (j + t <= 2 * k)
tmp[min(j, t + 1)] += f[x][j] * f[ne][t], tmp[min(j, t + 1)] %= mo;
else
tmp[max(j, t + 1)] += f[x][j] * f[ne][t], tmp[max(j, t + 1)] %= mo;
}
for (long long j = 0; j <= 2 * k; j++) f[x][j] = tmp[j];
}
}
int main() {
scanf("%lld %lld", &n, &k);
if (k == 0) return puts("1") & 0;
for (long long i = 1; i <= n - 1; i++) {
scanf("%lld %lld", &x, &y);
add(x, y);
add(y, x);
}
dfs(1);
for (long long i = 0; i <= k; i++) ans += f[1][i], ans %= mo;
printf("%lld", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 69;
int A[N], B[N], C[N], D[N], fix[N], tree[4 * N], P[N];
int n;
vector<int> ans;
set<pair<int, int> > S[N];
queue<int> q;
void compress() {
vector<pair<int, int> > P;
for (int i = 0; i <= n; i++) {
P.push_back({A[i], i});
P.push_back({C[i], i + n + 1});
}
P.push_back({-1, 0});
sort(P.begin(), P.end());
int tot = 0;
for (int i = 1; i < P.size(); i++) {
int x = P[i].first;
int ind = P[i].second;
if (x != P[i - 1].first) {
tot++;
}
if (ind <= n)
A[ind] = tot;
else
C[ind - n - 1] = tot;
}
}
void upd(int node, int tl, int tr, int pos, int x) {
if (tl == tr) {
tree[node] = x;
return;
}
int mid = (tl + tr) >> 1;
int left = node << 1;
int right = left | 1;
if (pos <= mid) {
upd(left, tl, mid, pos, x);
} else {
upd(right, mid + 1, tr, pos, x);
}
int ind1 = tree[left];
int ind2 = tree[right];
if (B[ind1] < B[ind2]) {
tree[node] = ind1;
} else {
tree[node] = ind2;
}
}
int get(int node, int tl, int tr, int l, int r) {
if (tl > r || tr < l) {
return 0;
}
if (l <= tl && tr <= r) {
return tree[node];
}
int mid = (tl + tr) >> 1;
int left = node << 1;
int right = left | 1;
int ind1 = get(left, tl, mid, l, r);
int ind2 = get(right, mid + 1, tr, l, r);
if (B[ind1] < B[ind2]) {
return ind1;
} else {
return ind2;
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i] >> B[i] >> C[i] >> D[i];
}
A[0] = 0;
B[0] = 1e9;
C[0] = 0;
D[0] = 0;
compress();
for (int i = 1; i <= 2 * n + 1; i++) {
S[i].insert({1e9, 0});
}
for (int i = 1; i <= n; i++) {
S[A[i]].insert({B[i], i});
}
for (int i = 1; i <= 2 * n + 1; i++) {
int x = (*S[i].begin()).first;
int ind = (*S[i].begin()).second;
upd(1, 1, 2 * n + 1, i, ind);
}
q.push(0);
while (q.size()) {
int ind = q.front();
q.pop();
if (ind == n) {
while (ind != 0) {
ans.push_back(ind);
ind = P[ind];
}
reverse(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
while (true) {
int x = get(1, 1, 2 * n + 1, 1, C[ind]);
if (x == 0) break;
if (B[x] > D[ind]) break;
S[A[x]].erase({B[x], x});
q.push(x);
P[x] = ind;
upd(1, 1, 2 * n + 1, A[x], (*S[A[x]].begin()).second);
}
}
cout << -1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 123;
const long long INF = 1e18 + 123;
const double pi = acos(-1.0);
int n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n % 2 == 0)
cout << "Mahmoud", exit(0);
else
cout << "Ehab", exit(0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long arr[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 0; i < (n); i++) cin >> arr[i];
if (k == 1)
cout << *min_element(arr, arr + n);
else if (k == 2) {
long long Min1[n], Min2[n];
Min1[0] = arr[0];
Min2[n - 1] = arr[n - 1];
for (int i = 1; i < n; i++) Min1[i] = min(Min1[i - 1], arr[i]);
for (int i = n - 2; i >= 0; i--) Min2[i] = min(Min2[i + 1], arr[i]);
long long ans = -10000000000;
for (int i = 0; i < n; i++) {
ans = max(ans, max(Min1[i], Min2[i]));
}
cout << ans << endl;
} else {
cout << *max_element(arr, arr + n);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int h[200005];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int tmp;
for (int i = 0; i < 200005; ++i) {
h[i] = 0;
}
int maxn = -1;
int minn = 2000000;
for (int i = 0; i < n; ++i) {
scanf("%d", &tmp);
h[tmp]++;
if (tmp > maxn) maxn = tmp;
if (minn > tmp) minn = tmp;
}
int last = maxn;
int pointer = maxn;
if (maxn == minn) {
printf("0\n");
return 0;
}
int cnter = 0;
while (1) {
int sum = 0;
int mul = h[last];
int flag = 0;
while (1) {
pointer--;
sum += mul;
mul += h[pointer];
if (sum > k) {
last = pointer + 1;
h[last] = mul - h[pointer];
pointer = last;
cnter++;
break;
}
if (pointer == minn) {
cnter++;
flag = 1;
break;
}
}
if (flag) {
printf("%d\n", cnter);
return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chkmax(T &a, T b) {
if (a < b) a = b;
}
const int inf = 0x3f3f3f3f;
int n, a[200005];
int bs, b[200005], L[200005], R[200005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
bs = 0;
for (int i = 1; i <= n; i++) {
int k = upper_bound(b, b + bs, a[i] - i) - b;
b[k] = a[i] - i;
if (k == bs) bs++;
L[i] = k + 1;
}
for (int i = 1; i <= n; i++) a[i] = a[i] - i + 1, a[i] = inf - a[i];
bs = 0;
R[n - 1] = 1;
a[0] = inf * 2;
for (int i = n; i >= 1; i--) {
int k = upper_bound(b, b + bs, a[i]) - b;
b[k] = a[i];
if (k == bs) bs++;
if (i > 1) {
k = upper_bound(b, b + bs, a[i - 2] + 1) - b;
R[i - 2] = k + 1;
}
}
int ans = 0;
for (int i = 0; i <= n - 1; i++) chkmax(ans, L[i] + R[i] - 1);
printf("%d\n", n - 1 - ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
long long int gcd(long long int x, long long int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
fastio();
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int ans = a[n - 1] - a[0];
k--;
vector<int> v;
for (int i = 1; i < n; i++) {
v.push_back(a[i] - a[i - 1]);
}
sort(v.begin(), v.end());
for (int i = 0; i < k; i++) {
ans -= v[v.size() - 1 - i];
}
cout << ans;
}
| 3 |
// *********************************************************************************
// * MURTAZA MUSTAFA KHUMUSI *
// * NIT-DGP,CSE - 2019-2023 *
// *********************************************************************************
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MOD 1000000007;
#define loop(i, a, n) for (int i = a; i < n; i++)
#define loop1(i, b, n) for (int i = b; i <= n; i++)
#define loopit(a) for (auto it = a.begin(); it != a.end(); it++)
#define ms(a, b) memset(a, b, sizeof(a))
#define pb(a) push_back(a)
#define MP make_pair
#define pi pair<int, int>
#define ff first
#define ss second
#define bloop(i, a, b) for (int i = a; i > b; i--)
#define bloop1(i, a, b) for (int i = a; i >= b; i--)
#define PQ priority_queue<int> pq;
#define vi vector<int>
#define si set<int>
#define MPQ priority_queue<pi, vector<int>, greater<pi>> mpq;
#define io \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL);
const int maxm = 100001;
// ll m = 1e9+7;
ll m = 998244353;
vector<vi> adj;
vi h, sz, in;
vector<ll> fact;
//modular arithmentic
ll add(ll a, ll b, ll mod = m)
{
return ((a % mod) + (b % mod)) % mod;
}
ll mul(ll a, ll b, ll mod = m)
{
return ((a % mod) * (b % mod)) % mod;
}
ll sub(ll a, ll b, ll mod = m)
{
return ((a % mod) - (b % mod) + mod) % mod;
}
ll modmul(ll a, ll b, ll mod = m)
{
ll ans = 0;
a = a % mod;
while (b)
{
if (b & 1)
ans = add(ans, a, mod);
a = mul(a, 2, mod);
b >>= 1;
}
return ans;
}
ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll fe(ll base, ll exp, ll mod = m)
{
ll ans = 1;
while (exp)
{
if (exp & 1)
ans = mul(ans, base, mod);
base = mul(base, base, mod);
exp >>= 1;
}
return ans;
}
ll modin(ll a, ll mod = m)
{
return fe(a, mod - 2, mod);
}
ll nCr(ll a, ll b, ll mod = m)
{
if (a < b)
return 0;
return mul(fact[a], mul(modin(fact[b], mod), modin(fact[a - b], mod)));
}
//graph theory
void dfs_h_sz(int cur, int par)
{
h[cur] = h[par] + 1;
sz[cur]++;
for (const auto &v : adj[cur])
{
if (v == par)
continue;
dfs_h_sz(v, cur);
sz[cur] += sz[v];
}
}
void buildGraph(int n, int m)
{
adj = vector<vi>(n + 1);
h = vector<int>(n + 1);
sz = vector<int>(n + 1);
in = vector<int>(n + 1);
loop(i, 0, m)
{
int a, b;
cin >> a >> b;
adj[a].pb(b);
adj[b].pb(a);
}
dfs_h_sz(1, 0);
}
struct cmp
{
bool operator()(const pi &a, const pi &b)
{
return a.ff < b.ff;
}
};
void display(vi &in){
loop(i,0,in.size()){
cout<<in[i]<<" ";
}
cout<<"\n";
}
void solve()
{
int n;
cin >> n;
vi in(n);
ll ans = 0, sum = 0;
loop(i, 0, n)
{
cin >> in[i];
sum += in[i];
}
vi out(n);
out = in;
loop(i, 0, n)
{
if (i & 1)
{
ans += abs(in[i] - 1);
out[i] = 1;
}
}
if (2 * ans <= sum)
{
display(out);
return;
}
out = in;
ans = 0;
loop(i, 0, n)
{
if ((i & 1) == 0)
{
ans += abs(in[i] - 1);
out[i] = 1;
}
}
display(out);
}
int main()
{
io;
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
int test;
cin >> test;
// test=1;
while (test--)
{
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x1, x2, x3, y1, y2, y3, num = 1;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char ch;
cin >> ch;
if (ch == '*') {
switch (num) {
case 1:
x1 = j, y1 = i;
break;
case 2:
x2 = j, y2 = i;
break;
case 3:
x3 = j, y3 = i;
break;
}
num++;
}
}
if (y1 != y2 && y1 != y3)
cout << y1;
else if (y2 != y1 && y2 != y3)
cout << y2;
else
cout << y3;
cout << " ";
if (x1 != x2 && x1 != x3)
cout << x1;
else if (x2 != x1 && x2 != x3)
cout << x2;
else
cout << x3;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, -1, 0, 1};
int dy[] = {1, 0, -1, 0};
vector<int> edge[200010];
int out[200010];
int n, m, a, b, c;
int dfs(int i) {
for (int j = (1); j <= (3); ++j) {
for (int k = 0; k < ((int)edge[i].size()); ++k)
if (out[edge[i][k]] == j) goto end;
out[i] = j;
for (int k = 0; k < ((int)edge[i].size()); ++k)
if (out[edge[i][k]] <= 0) dfs(edge[i][k]);
end:;
}
return 0;
}
int main(int argc, char *argv[]) {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i) edge[i].clear();
for (int i = 0; i < (m); ++i) {
scanf("%d%d%d", &a, &b, &c);
edge[a].push_back(b);
edge[a].push_back(c);
edge[b].push_back(a);
edge[b].push_back(c);
edge[c].push_back(a);
edge[c].push_back(b);
}
memset(out, 0, sizeof(out));
for (int i = (1); i <= (n); ++i)
if (!out[i]) dfs(i);
for (int i = (1); i <= (n); ++i) printf("%d%c", out[i], i < n ? ' ' : '\n');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 2e5 + 100;
const int sigma = 30;
int n, m, k, t;
map<pair<int, int>, int> pres;
pair<int, int> ele[ms];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b, c;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ele[i].first >> ele[i].second;
}
pair<int, int> ans;
for (int i = 0; i < n; i++) {
cin >> a >> b;
for (int j = 0; j < n; j++) {
pair<int, int> t = {a + ele[j].first, b + ele[j].second};
pres[t]++;
if (pres[t] == n) {
ans = t;
cout << ans.first << ' ' << ans.second << '\n';
return 0;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long W, H;
cin >> W >> H;
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long w, h;
cin >> w >> h;
long long a, b;
a = x2 - x1;
b = y2 - y1;
if ((a + w > W) && (b + h > H)) {
cout << -1;
return;
}
if ((a + w) > W) {
if (y1 - h >= 0) {
cout << 0;
return;
}
if ((H - h) - y2 >= 0) {
cout << 0;
return;
}
cout << min(h - y1, y2 - (H - h));
return;
}
if ((b + h) > H) {
if (x1 - w >= 0) {
cout << 0;
return;
}
if ((W - w) - x2 >= 0) {
cout << 0;
return;
}
cout << min(w - x1, x2 - (W - w));
return;
} else {
if (y1 - h >= 0) {
cout << 0;
return;
}
if ((H - h) - y2 >= 0) {
cout << 0;
return;
}
if (x1 - w >= 0) {
cout << 0;
return;
}
if ((W - w) - x2 >= 0) {
cout << 0;
return;
}
long long x = min(h - y1, y2 - (H - h));
long long y = min(w - x1, x2 - (W - w));
cout << min(x, y);
return;
}
}
signed main() {
long long t;
cin >> t;
while (t--) {
solve();
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char a[500500], b[500500];
long long i, n, k, ans, sum = 2;
int main() {
scanf("%lld%lld%s%s", &n, &k, a + 1, b + 1);
for (i = 1; i <= n; sum <<= 1, i++)
sum -= (b[i] == 'a') + (a[i] == 'b'),
ans += min(sum = (sum > k) ? k + 1 : sum, k);
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
const double EPS = 1e-10;
const long long p = 1e7 + 9;
const long long mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline int read() {
int ret = 0, f = 0;
char ch = getchar();
while (ch > '9' || ch < '0') f ^= ch == '-', ch = getchar();
while (ch <= '9' && ch >= '0') ret = ret * 10 + ch - '0', ch = getchar();
return f ? -ret : ret;
}
string s;
int main() {
ios::sync_with_stdio(false);
cin >> s;
long long r = 0, t = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'b') r = t;
if (s[i] == 'a') t = (r + t + 1) % mod;
}
cout << t << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 4005, M = 1000010;
using namespace std;
map<int, int> m;
int dp[N][N];
int c[M];
int main() {
memset(dp, -1, sizeof(dp));
memset(c, 0, sizeof(c));
int n, b[N];
int cnt = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", b + i);
++c[b[i]];
if (!m[b[i]]) m[b[i]] = ++cnt;
}
int res = 0;
for (int i = 0; i < M; ++i) res = max(res, c[i]);
for (int i = 0; i < n; ++i) {
int ind = m[b[i]];
for (int j = 1; j <= cnt; ++j) {
if (ind == j) continue;
if (dp[ind][j] == -1) dp[ind][j] = 1;
if (dp[j][ind] != -1) dp[ind][j] = max(dp[ind][j], dp[j][ind] + 1);
}
}
for (int i = 1; i <= cnt; ++i)
for (int j = 1; j <= cnt; ++j)
if (i != j) res = max(res, dp[i][j]);
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
int Set(int N, int pos) { return (N | (1 << pos)); }
long long BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return R;
}
int n, m;
vector<int> G[20];
long long dp[19][1 << 19];
bool con[20][20];
int visid, vis[19][1 << 19];
long long call(int pos, int mask, int u) {
if (vis[pos][mask] == 1) return dp[pos][mask];
vis[pos][mask] = 1;
long long ret = 0;
if (con[pos][u]) ret++;
for (int i = 0; i < G[pos].size(); i++) {
int go = G[pos][i];
if (go < u) continue;
if (Check(mask, go)) continue;
int newmask = Set(mask, go);
ret += call(go, newmask, u);
}
return dp[pos][mask] = ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a - 1].push_back(b - 1);
G[b - 1].push_back(a - 1);
con[a - 1][b - 1] = con[b - 1][a - 1] = 1;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
visid++;
for (int j = i + 1; j < n; j++) {
if (i == j) continue;
for (int k = i + 1; k < n; k++) {
if (j == k or k == i) continue;
if (con[i][j] and con[j][k]) {
int mask = (1 << i) | (1 << j) | (1 << k);
ans += call(k, mask, i);
}
}
}
}
cout << ans / 2;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int h, n;
cin >> h >> n;
vector<int> vec;
while (n--) {
int a;
cin >> a;
vec.push_back(a);
}
vec.push_back(0);
int cur = vec[0], cost = 0;
for (int i = 1; i < vec.size() and cur > 2; ++i) {
if (cur - vec[i] > 1)
cur = vec[i] + 1, --i;
else {
if (vec[i] > vec[i + 1] + 1)
cur = vec[i + 1] + 1, ++cost;
else
cur -= 2, ++i;
}
}
cout << cost << endl;
}
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.