solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long C[15][15], dp[16][15], k;
int num[16], t;
long long solve(int len) {
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= num[0]; i++) dp[0][i] = C[len][i];
for (int i = 1; i < 16; i++)
for (int l = 0; l <= len; l++)
for (int j = 0; j <= min(num[i], l); j++)
dp[i][l] += dp[i - 1][l - j] * C[len - l + j][j];
return dp[15][len];
}
int main() {
for (int i = 0; i < 15; i++) C[i][0] = 1;
for (int i = 1; i < 15; i++)
for (int j = 1; j <= i; j++) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
cin >> k >> t;
for (int i = 0; i < 16; i++) num[i] = t;
int len = 1;
for (;; len++) {
long long tmp = 0;
if (len == 1)
tmp = 15;
else {
for (int j = 1; j < 16; j++) {
num[j]--;
tmp += solve(len - 1);
num[j]++;
}
}
if (k > tmp)
k -= tmp;
else
break;
}
for (int i = len; i > 0; i--) {
if (i == 1) {
for (int j = 0; j < 16; j++) {
if (j == 0 && len == 1) continue;
if (num[j] != 0) k--;
if (k == 0) {
if (j < 10)
cout << j;
else
cout << (char)(j + 'a' - 10);
break;
}
}
break;
}
for (int j = 0; j < 16; j++) {
if (i == len && j == 0) continue;
num[j]--;
long long tmp = solve(i - 1);
if (k > tmp)
k -= tmp;
else {
if (j < 10)
cout << j;
else
cout << (char)(j + 'a' - 10);
break;
}
num[j]++;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 1e5;
const int INF = 0x3f3f3f3f;
const long long MOD = 100000007;
const int SIZE = 1010;
int n, m, r;
int cost[66][66][66];
int dp[1010][66][66];
int main() {
scanf("%d%d%d", &n, &m, &r);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) scanf("%d", &cost[i][j][k]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
for (int p = 1; p <= n; p++)
cost[i][k][p] = min(cost[i][k][p], cost[i][k][j] + cost[i][j][p]);
}
}
}
memset(dp, INF, sizeof(dp));
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
for (int p = 1; p <= n; p++)
dp[0][j][k] = min(dp[0][j][k], cost[i][j][p] + cost[i][p][k]);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
for (int p = 1; p <= n; p++)
dp[i][k][p] = min(dp[i][k][p], dp[i - 1][k][j] + dp[0][j][p]);
}
}
}
while (r--) {
int s, t, k;
scanf("%d%d%d", &s, &t, &k);
k = min(k, n);
int ans = INF;
for (int i = 0; i <= k; i++) ans = min(ans, dp[i][s][t]);
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
;
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
string s;
cin >> s;
string arr[2];
for (long long int i = 0; i <= s.length() - 1; i++) {
arr[(s[i] - '0') & 1] += s[i];
}
string res = "";
reverse(arr[0].begin(), arr[0].end());
reverse(arr[1].begin(), arr[1].end());
while (!(arr[0].empty() && arr[1].empty())) {
if (arr[0].empty()) {
res += arr[1].back();
arr[1].pop_back();
continue;
}
if (arr[1].empty()) {
res += arr[0].back();
arr[0].pop_back();
continue;
}
if (arr[0].back() < arr[1].back()) {
res += arr[0].back();
arr[0].pop_back();
} else {
res += arr[1].back();
arr[1].pop_back();
}
}
cout << res << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
int cnt[205], suff[100005], ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
v.resize(n);
for (int i = 0; i < n; i++) cin >> v[i].first;
for (int i = 0; i < n; i++) cin >> v[i].second;
sort(v.begin(), v.end());
suff[n] = 0;
for (int i = n - 1; i >= 0; i--) suff[i] = suff[i + 1] + v[i].second;
int j = 0;
memset(cnt, 0, sizeof(cnt));
ans = 1e9;
for (int i = 0; i < n; i = j) {
while (j < n && v[i].first == v[j].first) j++;
int len = j - i, tmp = suff[j];
int total = len + len - 1;
int goaway = j - total;
for (int k = 1; goaway > 0 && k <= 200; k++) {
tmp += k * min(goaway, cnt[k]);
goaway -= min(goaway, cnt[k]);
}
ans = min(ans, tmp);
for (int k = i; k < j; k++) cnt[v[k].second]++;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const double PI = acos(-1.0);
using namespace std;
const double EPS = 1e-9;
const int N = 5e5 + 9;
int n, a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int mn = -1, mx = -1;
for (int i = 1; i <= n; i++) {
if (a[i] != -1 &&
((i - 1 > 0 && a[i - 1] == -1) || (i + 1 <= n && a[i + 1] == -1))) {
if (mn == -1)
mn = mx = a[i];
else {
mn = min(mn, a[i]);
mx = max(mx, a[i]);
}
}
}
if (mn == -1)
cout << "0 1\n";
else {
int k = (mx + mn) / 2;
for (int i = 1; i <= n; i++)
if (a[i] == -1) a[i] = k;
int m = 0;
for (int i = 2; i <= n; i++) {
m = max(m, abs(a[i] - a[i - 1]));
}
cout << m << " " << k << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const double eps = 1e-8;
const int inf = 1 << 30;
int n, m, k;
struct node {
int x, y;
node(int xx = 0, int yy = 0) : x(xx), y(yy) {}
};
vector<node> ans;
int a[1010][110];
int main() {
while (cin >> n >> m >> k) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
cout << (m - 1) * m / 2 << endl;
;
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
if (k == 0) {
printf("%d %d\n", i, j);
} else
printf("%d %d\n", j, i);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long Max(long long x, long long y) { return x > y ? x : y; }
inline void read(long long &x) {
x = 0;
long long f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
s = getchar();
}
x *= f;
}
char S[1005];
long long n, k, dp[1005][1005][2], Limit[1005], Len;
long long Dfs(long long Now, long long JL, long long Mz, long long NotMan) {
if (!Now) return Mz;
if (!NotMan && ~dp[Now][JL][Mz]) return dp[Now][JL][Mz];
long long All = 0, To = NotMan ? Limit[Now] : 9;
for (register long long i = 0; i <= To; ++i) {
if (i != 4 && i != 7)
All = (All + Dfs(Now - 1, Max(JL - 1, 0), Mz, NotMan && i == To)) %
1000000007;
else
All = (All + Dfs(Now - 1, k, Mz || JL, NotMan && i == To)) % 1000000007;
}
if (!NotMan) dp[Now][JL][Mz] = All;
return All;
}
inline bool Check() {
long long Pre = 0x3f3f3f3f3f3f3f3f;
for (register long long i = Len; i; --i) {
if (Limit[i] == 4 || Limit[i] == 7) {
if (Pre - i <= k) return 1;
Pre = i;
}
}
return 0;
}
int main() {
read(n);
read(k);
memset(dp, -1, sizeof dp);
for (register long long T = 1; T <= n; ++T) {
scanf("%s", S + 1);
Len = strlen(S + 1);
for (register long long i = Len; i >= 1; --i)
Limit[Len + 1 - i] = S[i] - '0';
long long Ans = (Dfs(Len, 0, 0, 1) - Check() + 1000000007) % 1000000007;
scanf("%s", S + 1);
Len = strlen(S + 1);
for (register long long i = Len; i >= 1; --i)
Limit[Len + 1 - i] = S[i] - '0';
Ans = (Dfs(Len, 0, 0, 1) + 1000000007 - Ans) % 1000000007;
printf("%lld\n", Ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
vector<int> g[N];
int a[N], cnt[N], b[N << 1], c[N << 1];
int *vis = b + N, *val = c + N;
set<int> S, now;
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i < (n + 1); ++i)
scanf("%d", &a[i]), cnt[a[i]]++, g[a[i]].push_back(i);
int maxn = 0, p = 0;
for (int i = (1); i < (n + 1); ++i) {
if (maxn < cnt[i]) {
maxn = cnt[i];
p = i;
}
}
if (maxn == n) {
puts("0");
return 0;
}
int ans = 0;
for (auto v : g[p]) S.insert(v);
vector<int> temp;
int key = 0;
for (int i = (1); i < (n + 1); ++i) {
if (p == i) continue;
now.clear();
temp.clear();
for (auto v : g[i]) {
auto it = S.lower_bound(v);
if (it != S.end()) {
now.insert(*it);
S.erase(it);
}
it = S.lower_bound(v);
if (it != S.end()) {
now.insert(*it);
S.erase(it);
}
it = S.lower_bound(v);
if (it != S.begin()) {
--it;
now.insert(*it);
S.erase(it);
}
it = S.lower_bound(v);
if (it != S.begin()) {
--it;
now.insert(*it);
S.erase(it);
}
}
for (auto v : now) temp.push_back(v);
for (auto v : g[i]) now.insert(v);
int pos = -1, sum = 0;
for (auto v : now) {
if (v > pos) ++key;
if (vis[sum] != key) {
vis[sum] = key;
val[sum] = v;
}
if (a[v] == p) ++sum;
if (a[v] == i) --sum;
auto it = S.lower_bound(v);
if (it == S.end())
pos = n + 1;
else
pos = *it;
if (vis[sum] == key) {
int l, r;
int vv = val[sum];
auto it = now.lower_bound(vv);
if (it == now.begin())
l = 0;
else
l = *prev(it);
it = now.lower_bound(v);
++it;
if (it == now.end())
r = n + 1;
else
r = *it;
ans = max(r - l - 1, ans);
}
}
for (auto v : temp) S.insert(v);
}
printf("%d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll INF = (ll)1e18;
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr ll dx[4] = {1, 0, -1, 0};
constexpr ll dy[4] = {0, 1, 0, -1};
constexpr ll dx8[8] = {1, 0, -1, 0, 1, 1, -1, -1};
constexpr ll dy8[8] = {0, 1, 0, -1, 1, -1, 1, -1};
void p() { std::cout << '\n'; }
template <typename Head, typename... Tail>
void p(Head head, Tail... tail) {
std::cout << head << (sizeof...(tail) ? " " : "");
p(tail...);
}
template <typename T>
inline void pv(std::vector<T>& v) {
for (ll i = 0, N = v.size(); i < N; i++)
std::cout << v[i] << " \n"[i == N - 1];
}
template <typename T>
inline bool chmax(T& a, T b) {
return a < b && (a = b, true);
}
template <typename T>
inline bool chmin(T& a, T b) {
return a > b && (a = b, true);
}
template <typename T>
inline void uniq(std::vector<T>& v) {
v.erase(std::unique(v.begin(), v.end()), v.end());
}
[[nodiscard]] inline ll up(ll bit, ll i) { return bit | (1LL << i); }
[[nodiscard]] inline ll down(ll bit, ll i) { return bit & ~(1LL << i); }
[[nodiscard]] inline ll inverse(ll bit, ll i) { return bit ^ (1LL << i); }
inline bool isup(ll bit, ll i) { return bit & (1LL << i); }
inline bool isdown(ll bit, ll i) { return !(bit & (1LL << i)); }
inline ll msb(ll bit) {
assert(bit);
return numeric_limits<ll>::digits - __builtin_clzll(bit);
}
inline ll lsb(ll bit) {
assert(bit);
return __builtin_ctzll(bit);
}
void solve() {
ll N;
cin >> N;
vector<ll> a(N);
for (ll i = 0, i_length = (N); i < i_length; ++i) cin >> a[i];
ll t = 0;
if ([&] {
for (ll i = 0, i_length = (N); i < i_length; ++i) t ^= a[i];
return t == 0;
}()) {
p("DRAW");
return;
}
ll index = 0;
for (ll i = (32) - 1; i >= 0; --i) {
if (isup(t, i)) {
index = i;
break;
}
}
ll x = 0, y = 0;
for (ll i = 0, i_length = (N); i < i_length; ++i) {
if (isup(a[i], index))
x++;
else
y++;
}
do {
} while (false);
if (x % 4 == 3 && y % 2 == 0) {
p("LOSE");
} else {
p("WIN");
}
}
signed main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
ll Q;
cin >> Q;
while (Q--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
template <class T>
T read(T &a) {
a = 0;
char x = getchar();
bool f = 0;
for (; x < '0' || x > '9'; x = getchar()) f |= x == '-';
for (; x >= '0' && x <= '9'; x = getchar()) a = (a << 3) + (a << 1) + x - '0';
if (f) a = -a;
return a;
}
using namespace std;
const int N = 3e5 + 5;
struct node {
int d, l, r, lc, rc, siz;
int lazy;
} pnt[N << 1];
int n, root, d[N], pos[N], cnt = 0;
int build(int l, int r) {
int np = ++cnt;
pnt[np].l = l, pnt[np].r = r;
pnt[np].siz = r - l;
if (r - l == 1) {
return np;
}
int mid = l + r >> 1;
pnt[np].lc = build(l, mid);
pnt[np].rc = build(mid, r);
return np;
}
void upgrade(int u, int v) {
pnt[u].d += v;
pnt[u].lazy += v;
}
void pushdown(int u) {
if (pnt[u].siz == 1 || pnt[u].lazy == 0) {
return;
}
int lc = pnt[u].lc, rc = pnt[u].rc;
upgrade(lc, pnt[u].lazy);
upgrade(rc, pnt[u].lazy);
pnt[u].lazy = 0;
}
void update(int l, int r, int v, int u) {
pushdown(u);
if (pnt[u].l >= l && pnt[u].r <= r) {
upgrade(u, v);
return;
}
if (pnt[u].l >= r || pnt[u].r <= l) {
return;
}
update(l, r, v, pnt[u].lc);
update(l, r, v, pnt[u].rc);
pnt[u].d = min(pnt[pnt[u].lc].d, pnt[pnt[u].rc].d);
}
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(d[i]);
pos[d[i]] = i;
}
root = build(1, n + 1);
int x = n + 1;
for (int i = 1; i <= n; ++i) {
int q;
read(q);
while (pnt[root].d >= 0) {
update(1, pos[--x] + 1, -1, root);
}
printf("%d ", x);
update(1, q + 1, 1, root);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct number {
long long sum, a, b;
bool operator<(const number& in) const { return sum < in.sum; }
bool operator>(const number& in) const { return sum > in.sum; }
};
vector<number> v;
const long long MN = 2000 + 1;
long long a[MN], b[MN];
long long n, m, suma, sumb;
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
suma += a[i];
}
cin >> m;
for (long long j = 0; j < m; j++) {
cin >> b[j];
sumb += b[j];
}
for (long long i = 0; i < m; i++)
for (long long j = i + 1; j < m; j++) {
number temp;
temp.a = i;
temp.b = j;
temp.sum = 2 * (b[i] + b[j]);
v.push_back(temp);
}
sort(v.begin(), v.end());
long long best = abs(suma - sumb), in1 = -1, in2, in3 = -1;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++)
if (best > abs(suma - sumb - a[i] - a[i] + b[j] + b[j])) {
best = abs(suma - sumb - a[i] - a[i] + b[j] + b[j]);
in1 = i;
in2 = j;
}
if (m > 1 && n > 1) {
for (long long i = 0; i < n; i++)
for (long long j = i + 1; j < n; j++) {
long long want = suma - sumb - a[i] - a[j] - a[i] - a[j];
want *= -1;
vector<number>::iterator low, up;
number temp;
temp.sum = want;
low = std::lower_bound(v.begin(), v.end(), temp);
up = upper_bound(v.begin(), v.end(), temp);
if (low >= v.begin() && low < v.end())
if (best > abs(want - v[low - v.begin()].sum)) {
best = abs(want - v[low - v.begin()].sum);
in1 = i;
in2 = j;
in3 = low - v.begin();
}
while (up >= v.end()) up--;
if (best > abs(want - v[up - v.begin()].sum)) {
best = abs(want - v[up - v.begin()].sum);
in1 = i;
in2 = j;
in3 = up - v.begin();
}
}
}
if (in1 == -1) {
cout << best << endl << 0 << endl;
return 0;
}
if (in3 == -1) {
cout << best << endl << 1 << endl << in1 + 1 << " " << in2 + 1 << endl;
return 0;
}
cout << best << endl;
cout << 2 << endl;
cout << in1 + 1 << " " << v[in3].a + 1 << endl;
cout << in2 + 1 << " " << v[in3].b + 1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chmin(T &a, const T &val) {
if (a > val) a = val;
}
template <class T>
inline void chmax(T &a, const T &val) {
if (a < val) a = val;
}
template <class T>
long long sqr(T a) {
return 1ll * a * a;
}
template <class T>
void compress(T &a) {
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
}
const double pi = acos(-1.00);
const double eps = 1e-6;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
const int N = 2e5 + 1;
int n, m, k, ans, deg[N];
long long mask[10][10], P[N], base;
vector<pair<int, int> > a[N];
void Try(int i, long long pre = 0) {
for (int j = 1; j <= i; j++) {
long long cur = (pre + mask[i][j]) % MOD;
if (i < k)
Try(i + 1, cur);
else {
ans += (cur == base);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
P[0] = 1;
for (int i = 1; i <= n; i++) P[i] = P[i - 1] * 234567 % MOD;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
a[u].push_back({v, w});
deg[u]++;
}
for (int u = 1; u <= n; u++) {
sort(a[u].begin(), a[u].end(), [&](pair<int, int> x, pair<int, int> y) {
return x.second < y.second;
});
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
(mask[deg[u]][i + 1] += 1ll * v * P[v - 1]) %= MOD;
}
}
for (int i = 1; i <= n; i++) base = (base + 1ll * i * P[i - 1]) % MOD;
Try(1);
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 1e6 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long s, x;
cin >> x >> s;
if (x > s) out(-1);
if (x == s) {
if (x == 0) out(0);
cout << 1 << endl;
cout << x << endl;
return 0;
}
if ((s - x) & 1) {
out(-1);
}
long long y = (s - x) / 2;
assert((y + y + x) == s && ((y ^ y ^ x) == x));
if ((x & y) == 0) {
cout << 2 << endl;
cout << (x | y) << " " << y << endl;
} else {
cout << 3 << endl;
cout << x << " " << y << " " << y << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
for (int i = 0; i < s.size(); i++) {
if (!k) break;
if (i + 2 < s.size() && s[i] == '4' && s[i + 1] == '7' && s[i + 2] == '7' &&
i % 2 == 0) {
if (k % 2) s[i + 1] = '4';
break;
}
if (i + 2 < s.size() && s[i] == '4' && s[i + 1] == '4' && s[i + 2] == '7' &&
i % 2 == 0) {
if (k % 2) s[i + 1] = '7';
break;
}
if (i + 1 < s.size() && s[i] == '4' && s[i + 1] == '7' && i % 2 == 0) {
s[i + 1] = '4';
k--;
}
if (i + 1 < s.size() && s[i] == '4' && s[i + 1] == '7' && i % 2 != 0) {
s[i] = '7';
k--;
}
}
cout << s;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int z = 0;
if (x >= 0 && y >= 0) {
if (x == 0 && y != 0) {
z = 2;
for (int i = 1; i < y; i++) z = z + 4;
} else if (x != 0 && y == 0) {
z = 0;
if (x > 1) z = 5;
for (int i = 2; i < x; i++) z = z + 4;
} else {
if (x == 0 && y == 0)
z = 0;
else if (y > x) {
z = 2;
for (int i = 1; i < y; i++) z = z + 4;
} else {
z = 1;
for (int i = 1; i < x; i++) z = z + 4;
}
}
} else if (x >= 0 && y < 0) {
if (x > (abs(y) + 1)) {
z = 1;
for (int i = 1; i < x; i++) z = z + 4;
} else {
for (int i = 0; i < abs(y); i++) z = z + 4;
}
} else if (x < 0 && y >= 0) {
z = 3;
if (y < abs(x)) {
for (int i = 1; i < abs(x); i++) z = z + 4;
} else {
z = 2;
for (int i = 1; i < y; i++) z = z + 4;
}
} else {
z = 3;
if (abs(y) <= abs(x)) {
for (int i = 1; i < abs(x); i++) z = z + 4;
} else {
z = 4;
for (int i = 1; i < abs(y); i++) z = z + 4;
}
}
cout << z << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105, M = 10005;
int n, sa, mx, dif, ans;
int a[N], cnt[N], f[N][M];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sa += a[i];
mx = max(mx, a[i]);
cnt[a[i]]++;
if (cnt[a[i]] == 1) dif++;
}
if (dif <= 2) {
printf("%d", n);
return 0;
}
f[0][0] = 1;
for (int i = 1; i <= mx; i++) {
if (!cnt[i]) continue;
dif++;
for (int j = sa; j >= 0; j--)
for (int k = n; k >= 0; k--)
for (int t = 1; t <= cnt[i] && f[k][j] < 2; t++)
if (k >= t && j >= i * t) f[k][j] += f[k - t][j - i * t];
}
for (int i = 1; i <= mx; i++)
for (int j = 1; j <= cnt[i]; j++)
if (f[j][i * j] == 1 || f[n - j][sa - i * j] == 1) ans = max(ans, j);
printf("%d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n;
cin >> n;
long long h;
cin >> h;
pair<long long, long long> k[n + 1];
for (int i = 1; i <= n; i++) {
cin >> k[i].first;
k[i].second = i;
}
sort(k + 1, k + n + 1);
if (n == 2) {
cout << 0 << endl;
cout << 1 << " " << 1 << endl;
continue;
}
long long m1 = k[n].first + k[n - 1].first;
long long m2 = k[1].first + k[2].first + h;
long long m3 = k[2].first + k[3].first;
long long m4 = k[1].first + k[2].first;
long long m5 = k[1].first + k[n].first + h;
long long t1 = abs(m1 - m4);
long long t2 = max(m2, max(m1, m5)) - min(m2, m3);
if (t1 <= t2) {
cout << t1 << endl;
for (int i = 1; i <= n; i++) {
cout << 1 << " ";
}
cout << endl;
} else {
cout << t2 << endl;
for (int i = 1; i <= n; i++) {
if (k[1].second == i) {
cout << 1 << " ";
} else {
cout << 2 << " ";
}
}
cout << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[300033], mxStr = -1e9, cnt1, cnt2, ans = 2e9;
vector<vector<int>> G(300033);
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i] += 2;
mxStr = max(mxStr, a[i]);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[v].push_back(u);
G[u].push_back(v);
}
for (int i = 1; i <= n; ++i) {
if (a[i] == mxStr)
cnt1++;
else if (a[i] == mxStr - 1)
cnt2++;
}
for (int i = 1; i <= n; ++i) {
int tmp1 = 0, tmp2 = 0;
set<int> s;
if (a[i] == mxStr) {
s.insert(a[i] - 2);
tmp1++;
}
for (auto x : G[i]) {
if (a[x] == mxStr)
s.insert(a[x] - 1), tmp1++;
else if (a[x] == mxStr - 1)
s.insert(a[x] - 1), tmp2++;
}
if (cnt1 - tmp1) s.insert(mxStr);
if (cnt2 - tmp2) s.insert(mxStr - 1);
ans = min(ans, *s.rbegin());
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long n, k;
cin >> n >> k;
vector<pair<long long int, long long int> > v(n);
long long temp;
for (long long int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i;
}
sort((v).begin(), (v).end());
long long cnt = 1;
long long mcnt = 0;
for (long long int i = 1; i < n; i++) {
if (v[i].first != v[i - 1].first) {
if (cnt > mcnt) mcnt = cnt;
cnt = 1;
} else
cnt++;
}
if (cnt > mcnt) mcnt = cnt;
if (mcnt > k)
cout << "NO" << '\n';
else {
cout << "YES" << '\n';
vector<long long int> x(n);
long long i = 1;
for (long long int j = 0; j < n; j++) {
x[v[j].second] = i;
i++;
if (i == k + 1) i = 1;
}
for (long long int i = 0; i < n - 1; i++) cout << x[i] << " ";
cout << x[n - 1];
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
vector<pair<int, int> > r;
int v[N], pref1[N], pref2[N];
int n;
int calcula(int t) {
int i = 0;
int r = 0, p1 = 0, p2 = 0;
while (i <= n) {
int prox = lower_bound(pref1 + i, pref1 + n + 1, pref1[i] + t) - pref1;
int prox2 = lower_bound(pref2 + i, pref2 + n + 1, pref2[i] + t) - pref2;
i = min(prox, prox2);
if (prox < prox2) p1++;
if (prox2 < prox) p2++;
r++;
if (i == n and prox < prox2 and p1 > p2) return p1;
if (i == n and prox > prox2 and p1 < p2) return p2;
}
return -1;
}
int main() {
scanf("%d", &n);
int p1 = 0, p2 = 0;
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 1; i <= n; i++) {
pref1[i] = pref1[i - 1];
pref2[i] = pref2[i - 1];
if (v[i] == 1)
pref1[i]++;
else
pref2[i]++;
}
pref1[n + 1] = pref2[n + 1] = INF;
for (int t = 1; t <= n; t++) {
int s = calcula(t);
if (s != -1) r.push_back(make_pair(s, t));
}
sort(r.begin(), r.end());
cout << r.size() << "\n";
for (int i = 0; i < r.size(); i++)
cout << r[i].first << " " << r[i].second << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t[100000], l[100000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, L, a;
cin >> n >> L >> a;
for (int i = 0; i < n; i++) cin >> t[i] >> l[i];
for (int k = n / 2; k > 0; k /= 2) {
for (int i = k; i < n; i++) {
int j;
int templ = l[i], tempt = t[i];
for (j = i; j >= k; j -= k) {
if (tempt < t[j - k]) {
t[j] = t[j - k];
l[j] = l[j - k];
} else
break;
}
t[j] = tempt;
l[j] = templ;
}
}
if (n == 0) {
cout << L / a;
return 0;
}
long long answer = t[0] / a;
for (int i = 1; i < n; i++) {
answer += (t[i] - (t[i - 1] + l[i - 1])) / a;
}
answer += (L - (t[n - 1] + l[n - 1])) / a;
cout << answer;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int pw(long long int a, long long int b, long long int md) {
if (!b) return 1;
if (b & 1) return a * pw(a * a % md, b / 2, md) % md;
return pw(a * a % md, b / 2, md) % md;
}
const long long int MAXN = 5e5 + 10;
const long long int INF = 8e18;
const long long int MOD = 1e9 + 7;
const long long int LOG = 32;
const long long int BLOCK = 320;
const long double PI = acos(-1);
const long double SADAT = 7.84e-17;
long long int n, dp[MAXN];
pair<long long int, long long int> a[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> a[i].second >> a[i].first;
}
sort(a, a + n);
dp[0] = 1;
for (long long int i = 1; i < n; i++) {
long long int ptr =
lower_bound(a, a + i,
pair<long long int, long long int>(a[i].second, 0)) -
a;
if (a[ptr].first >= a[i].second) ptr--;
if (ptr < 0) {
dp[i] = dp[i - 1];
continue;
}
dp[i] = max(dp[i - 1], dp[ptr] + 1);
}
cout << dp[n - 1] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const long long MAXN = 1e5 + 10;
const long long INF = 0x3f3f3f3f;
const long long MOD = 1e9 + 7;
const long double eps = 1e-9;
const long double PI = acos(-1.0);
long long n, m, k;
vector<long long> E[MAXN], temp;
long long vis[MAXN], inEdge[MAXN];
struct Node {
long long deg, idx;
bool operator<(const Node &other) const {
if (deg == other.deg)
return idx < other.idx;
else
return deg < other.deg;
}
};
set<Node> S;
void solve() {
while (!S.empty()) {
Node node = *S.begin();
vis[node.idx] = 1;
if (node.deg >= k) {
cout << 1 << " " << S.size() << endl;
for (auto it = S.begin(); it != S.end(); it++) {
if (it != S.begin()) cout << " ";
cout << (*it).idx;
}
cout << endl;
return;
} else {
if (node.deg == k - 1) {
temp.clear();
long long u = node.idx;
temp.push_back(u);
for (auto v : E[u]) {
if (vis[v]) continue;
temp.push_back(v);
}
long long res = 1;
for (auto v : temp) {
for (auto t : temp) {
if (v == t) continue;
auto pos = lower_bound(E[v].begin(), E[v].end(), t);
if (pos == E[v].end() || *pos != t) {
res = 0;
break;
}
}
if (!res) break;
}
if (res) {
cout << 2 << endl;
for (long long i = 0; i < temp.size(); i++) {
if (i) cout << " ";
cout << temp[i];
}
cout << endl;
return;
}
}
S.erase(S.begin());
for (auto v : E[node.idx]) {
if (vis[v]) continue;
S.erase({inEdge[v], v});
S.insert({--inEdge[v], v});
}
}
}
cout << -1 << endl;
}
signed main() {
long long T = read();
while (T--) {
S.clear();
n = read(), m = read(), k = read();
for (long long i = 0; i <= n; i++) {
vis[i] = inEdge[i] = 0;
E[i].clear();
}
for (long long i = 0; i < m; i++) {
long long u = read(), v = read();
E[u].push_back(v);
E[v].push_back(u);
inEdge[u]++, inEdge[v]++;
}
if (k * (k - 1) > 2 * m) {
cout << -1 << endl;
continue;
}
for (long long i = 1; i <= n; i++) {
S.insert({inEdge[i], i});
sort(E[i].begin(), E[i].end());
}
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, p;
void bizu(int p1, int p2) {
if (x % 4 == 1) {
int temp = p1;
p1 = p2;
p2 = (n - temp + 1);
swap(n, m);
} else if (x % 4 == 2) {
p1 = (n - p1 + 1);
p2 = (m - p2 + 1);
} else if (x % 4 == 3) {
int temp = p1;
p1 = m - p2 + 1;
p2 = temp;
swap(n, m);
}
if (y % 2 == 1) {
p1 = p1;
p2 = m - p2 + 1;
}
if (z % 4 == 1) {
int temp = p1;
p1 = m - p2 + 1;
p2 = temp;
swap(n, m);
} else if (z % 4 == 2) {
p1 = (n - p1 + 1);
p2 = (m - p2 + 1);
} else if (z % 4 == 3) {
int temp = p1;
p1 = p2;
p2 = (n - temp + 1);
swap(n, m);
}
printf("%d %d\n", p1, p2);
}
int main() {
scanf("%d %d %d %d %d %d", &n, &m, &x, &y, &z, &p);
int nori = n, mori = m;
for (int i = 0; i < p; i++) {
int p1, p2;
scanf("%d %d", &p1, &p2);
bizu(p1, p2);
n = nori;
m = mori;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 100005;
long long read() {
long long x = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x * flag;
}
long long n, ans, m[M], t[M];
signed main() {
n = read();
for (long long i = 1; i <= n; i++) t[i] = max(t[i - 1], (m[i] = read()) + 1);
for (long long i = n - 1; i >= 1; i--)
if (t[i + 1] - 1 > t[i]) t[i] = t[i + 1] - 1;
for (long long i = 1; i <= n; i++) ans += t[i] - m[i] - 1;
printf("%lld\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long mxN = 1000000;
long long ii = 1;
void solve() {
vector<long long> v(3);
long long m;
cin >> v[0] >> v[1] >> v[2] >> m;
sort(v.rbegin(), v.rend());
long long mn = 0, mx = 0;
mn = max(0LL, v[0] - 1 - (v[1] + v[2]));
if (v[0] > 1) mx += v[0] - 2 + 1;
if (v[1] > 1) mx += v[1] - 2 + 1;
if (v[2] > 1) mx += v[2] - 2 + 1;
if (m >= mn && m <= mx)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long TestCase = 1;
cin >> TestCase;
while (TestCase--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool x = true;
long long n, sum = 0;
cin >> n;
for (int i = 1; x; i++) {
sum = sum + i;
if (n == sum) {
cout << i << endl;
x = false;
} else if (n < sum) {
for (int j = i; j >= 1; j--) {
if (sum == n) {
cout << j << endl;
x = false;
}
sum--;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, l, n, m, a[2015][2015], dx, dy, sm, dj;
string s[2015];
queue<pair<int, int> > q;
void wh(int i, int j) {
int dx = 0, dy = 0;
if (a[i][j] == 1) {
dx = i;
dy = j;
} else if (a[i][j + 1] == 1) {
dx = i;
dy = j + 1;
} else if (a[i + 1][j + 1] == 1) {
dx = i + 1;
dy = j + 1;
} else if (a[i + 1][j] == 1) {
dx = i + 1;
dy = j;
}
a[dx][dy] = 0;
q.push(make_pair(dx, dy));
}
void sum(int i, int j) {
if (i < 1 || j < 1 || i >= n || j >= m) return;
int sm = a[i][j] + a[i][j + 1] + a[i + 1][j] + a[i + 1][j + 1];
if (sm == 1) wh(i, j);
}
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> s[i];
for (j = 1; j <= m; j++)
if (s[i][j - 1] == '*') a[i][j] = 1;
}
for (i = 1; i < n; i++) {
for (j = 1; j < m; j++) {
sm = a[i][j] + a[i][j + 1] + a[i + 1][j] + a[i + 1][j + 1];
if (sm == 1) {
if (a[i][j] == 1) {
dx = i;
dy = j;
} else if (a[i][j + 1] == 1) {
dx = i;
dy = j + 1;
} else if (a[i + 1][j + 1] == 1) {
dx = i + 1;
dy = j + 1;
} else if (a[i + 1][j] == 1) {
dx = i + 1;
dy = j;
}
a[dx][dy] = 0;
q.push(make_pair(dx, dy));
}
}
}
while (!q.empty()) {
dx = q.front().first;
dj = q.front().second;
q.pop();
sum(dx, dj);
sum(dx, dj + 1);
sum(dx, dj - 1);
sum(dx + 1, dj - 1);
sum(dx + 1, dj);
sum(dx + 1, dj + 1);
sum(dx - 1, dj - 1);
sum(dx - 1, dj);
sum(dx - 1, dj + 1);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (a[i][j] == 0)
printf(".");
else
printf("*");
}
printf("\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long Mod;
long long fpow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % Mod;
x = x * x % Mod;
y >>= 1;
}
return res;
}
void PLS(long long x, long long y, long long z) {
printf("+ %lld %lld %lld\n", x, y, z);
}
void POW(long long x, long long y) { printf("^ %lld %lld\n", x, y); }
long long D, A[20][20], C[20][20], tot = 3;
const long long clr = 4998, ban = 4999, zero = 5000;
const long long mu = 4997;
void Set() {
long long y = Mod - 1;
while (y) {
if (y & 1) PLS(zero, ban, zero);
PLS(ban, ban, ban);
y >>= 1;
}
POW(clr, ban);
for (long long i = C[0][0] = 1; i <= D; i++)
for (long long j = C[i][0] = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % Mod;
}
void mul(long long x, long long y) {
if (!y) return PLS(zero, zero, x);
PLS(zero, x, ban);
y--;
while (y) {
if (y & 1) PLS(x, ban, x);
PLS(ban, ban, ban);
y >>= 1;
}
POW(clr, ban);
}
void gauss() {
for (long long j = 0; j <= D; j++)
for (long long i = 0; i <= D; i++) A[j][i] = fpow(i, D - j);
A[2][D + 1] = fpow(C[D][2], Mod - 2);
for (long long i = 0; i <= D; i++) {
long long l = i;
for (l = i; l <= D; l++)
if (A[l][i]) break;
if (l != i) {
for (long long j = i; j <= D + 1; j++) swap(A[i][j], A[l][j]);
}
for (long long j = i + 1; j <= D; j++) {
long long t = fpow(A[i][i], Mod - 2) * A[j][i] % Mod;
for (long long k = i; k <= D + 1; k++)
A[j][k] = (A[j][k] - t * A[i][k] % Mod + Mod) % Mod;
}
}
for (long long i = D; ~i; i--) {
for (long long j = i + 1; j <= D; j++)
A[i][D + 1] = (A[i][D + 1] - A[i][j] * A[j][D + 1] % Mod + Mod) % Mod;
A[i][D + 1] = A[i][D + 1] * fpow(A[i][i], Mod - 2) % Mod;
}
}
long long getpw2(long long pos) {
long long L = ++tot, R = L;
for (long long i = 1; i <= D; i++) ++R, ++tot;
++tot;
PLS(zero, zero, tot);
for (long long i = L; i <= R; i++) {
PLS(tot, pos, i);
POW(i, i);
mul(i, A[i - L][D + 1]);
PLS(clr, tot, tot);
}
for (long long i = L; i < R; i++) PLS(i, i + 1, i + 1);
return R;
}
signed main() {
cin >> D >> Mod;
Set();
gauss();
PLS(1, 2, 3);
long long p = getpw2(1);
long long q = getpw2(2);
long long r = getpw2(3);
long long ans = ++tot;
PLS(zero, zero, ans);
PLS(r, ans, ans);
mul(p, Mod - 1);
mul(q, Mod - 1);
PLS(p, ans, ans);
PLS(q, ans, ans);
mul(ans, fpow(2, Mod - 2));
printf("f %lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, max, count = 0, flag = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
cin >> m;
int b[m];
for (j = 0; j < m; j++) {
cin >> b[j];
for (i = 0; i < n; i++) {
if (b[j] % a[i] == 0) {
if (flag == 0) {
max = b[j] / a[i];
count++;
flag = 1;
} else if (b[j] / a[i] == max) {
count++;
} else if (b[j] / a[i] > max) {
max = b[j] / a[i];
count = 1;
}
}
}
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int stu[100002][2], arr[100002], sta[10002];
map<int, int> des;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int tm = 0;
int cnt = 0, mxdis = 0;
for (int i = 0; i < n; i++) {
scanf("%d %d", &stu[i][0], &stu[i][1]);
mxdis = max(mxdis, stu[i][1]);
des[stu[i][1]]++;
cnt++;
if (cnt == m || i == n - 1) {
int pre = 0;
tm = max(tm, stu[i][0]);
for (map<int, int>::iterator it = des.begin(); it != des.end(); it++) {
tm += (it->first - pre);
sta[it->first] = tm;
tm += (1 + (it->second / 2));
pre = it->first;
}
for (int j = cnt - 1; j >= 0; j--) {
arr[i - j] = sta[stu[i - j][1]];
}
tm += mxdis;
des.clear();
mxdis = 0;
cnt = 0;
}
}
printf("%d", arr[0]);
for (int i = 1; i < n; i++) {
printf(" %d", arr[i]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
int num[1000] = {0};
int vis[1000] = {0};
int t;
for (int i = 0; i < k; i++) {
cin >> vis[i];
num[vis[i]] = 1;
}
int len = 0;
for (int i = 0; i < k; i++) {
len = 0;
cout << vis[i] << " ";
len++;
for (int j = 1; j <= n * k; j++) {
if (len < n && num[j] == 0) {
cout << j;
num[j] = 1;
len++;
if (len <= n - 1) {
cout << " ";
}
}
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
template <typename Tp>
inline int getmin(Tp &x, Tp y) {
return y < x ? x = y, 1 : 0;
}
template <typename Tp>
inline int getmax(Tp &x, Tp y) {
return y > x ? x = y, 1 : 0;
}
template <typename Tp>
inline void read(Tp &x) {
x = 0;
int f = 0;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') f = 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
if (f) x = -x;
}
int n, op;
char str[maxn];
struct AC_auto {
int sz, rt[25], val[25], ch[maxn][26], ac[maxn][26], f[maxn], cnt[maxn],
sum[maxn];
queue<int> q;
void add(int x, char *s) {
for (int i = 0; s[i]; i++) {
if (!ch[x][s[i] - 'a']) ch[x][s[i] - 'a'] = ++sz;
x = ch[x][s[i] - 'a'];
}
++cnt[x];
}
void build(int rt) {
while (!q.empty()) q.pop();
int x, v, fa;
f[rt] = rt;
q.push(rt);
for (int i = 0; i < 26; i++) ac[rt][i] = rt;
while (!q.empty()) {
x = q.front();
q.pop();
fa = f[x];
for (int i = 0; i < 26; i++) {
if (!ch[x][i]) {
ac[x][i] = ac[fa][i];
continue;
}
v = ac[x][i] = ch[x][i];
f[v] = (x == rt ? rt : ac[fa][i]);
sum[v] = sum[f[v]] + cnt[v];
q.push(v);
}
}
}
int merge(int x, int y) {
if (!x || !y) return x + y;
cnt[x] += cnt[y];
for (int i = 0; i < 26; i++) ch[x][i] = merge(ch[x][i], ch[y][i]);
return x;
}
void insert(char *s) {
int i;
if (!rt[0]) rt[0] = ++sz;
add(rt[0], s);
for (i = 0; val[i]; i++) {
rt[i + 1] = merge(rt[i + 1], rt[i]);
rt[i] = 0;
val[i] ^= 1;
}
val[i] ^= 1;
build(rt[i]);
}
long long query(char *s) {
int x;
long long res = 0ll;
for (int i = 0; i < 20; i++)
if (rt[i]) {
x = rt[i];
for (int j = 0; s[j]; j++) {
x = ac[x][s[j] - 'a'];
res += sum[x];
}
}
return res;
}
} ins, del;
int main() {
read(n);
while (n--) {
read(op);
scanf("%s", str);
if (op == 1) ins.insert(str);
if (op == 2) del.insert(str);
if (op == 3)
printf("%lld\n", ins.query(str) - del.query(str)), fflush(stdout);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int a[N];
int dp[10 * N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
int lb = 0, rb = a[n - 1] + 1;
while (rb - lb > 1) {
int mb = (lb + rb) / 2;
for (int i = 0; i < 10 * N; ++i)
if (i <= mb)
dp[i] = (i < mb ? 0 : 1);
else
dp[i] = max(dp[i - 1], dp[i / 2] + dp[(i + 1) / 2]);
int cur = 0;
for (int i = 0; i < n && cur < k; ++i) cur += dp[a[i]];
if (cur >= k)
lb = mb;
else
rb = mb;
}
printf("%d", lb ? lb : -1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
vector<long long> v;
long long arr[int(1e6)];
int main() {
long long T = 1, p = int(1e9 + 7), i;
while (T--) {
long long n, k = 0, i, j = 0, l = 0, r = 0;
cin >> s;
for (i = 0; i < s.size(); i++) {
if (s[i] == '[' && j == 0) {
j = 1;
}
if (s[i] == ':' && j == 1) {
j = 2;
k = i;
}
if (j == 2 && s[i] == '|') {
r++;
}
}
for (i = s.size() - 1; i >= 0; i--) {
if (s[i] == ']' && j == 2) {
j = 3;
}
if (j == 3 && s[i] == ':') {
if (i > k) j = 4;
break;
}
if (s[i] == '|') l++;
}
if (j != 4)
cout << -1 << endl;
else {
cout << r - l + 4 << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
map<char, int> mp;
int n, i, k, l, c = 0;
cin >> n;
k = n;
while (n--) {
string s;
cin >> s;
l = s.length();
for (i = 0; i < l; i++) {
mp[s[i]]++;
}
}
for (auto i : mp) {
if (i.second % k != 0) {
c++;
cout << "NO" << endl;
break;
}
}
if (c == 0) {
cout << "YES" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> d;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
d[x]++;
}
int t = d.begin()->first - 1;
for (auto x : d) {
if (x.first != t + 1) {
printf("NO\n");
return 0;
}
t++;
}
vector<int> v;
for (auto x : d) {
v.push_back(x.second);
}
for (int i = 1; i < v.size(); i++) {
v[i] -= v[i - 1];
if (v[i] < 0) {
printf("NO\n");
return 0;
}
if (v[i] == 0 && i + 1 < v.size()) {
printf("NO\n");
return 0;
}
}
if (v.back() == 0)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10101;
const int pod = (1 << 19);
const int INF = 1e9;
struct seg {
int t[2 * pod];
void init() {
for (int i = 1; i <= 2 * pod - 1; ++i) t[i] = 0;
}
void add(int x, int c) {
x += pod;
t[x] += c;
for (x /= 2; x; x /= 2) t[x] = t[2 * x] + t[2 * x + 1];
}
int query(int l, int r) {
int res = 0;
r++;
for (l += pod, r += pod; l < r; l /= 2, r /= 2) {
if (l & 1) res += t[l++];
if (r & 1) res += t[--r];
}
return res;
}
} bombs, gao;
struct segtre {
long long lazy[2 * pod];
long long mini[2 * pod];
void init() {
for (int i = 1; i < 2 * pod; ++i) {
mini[i] = lazy[i] = 0;
}
}
inline void push(int u, int len) {
if (!lazy[u]) return;
mini[2 * u] += lazy[u];
mini[2 * u + 1] += lazy[u];
lazy[2 * u] += lazy[u];
lazy[2 * u + 1] += lazy[u];
lazy[u] = 0;
}
void add(int x, int y, long long z, int u = 1, int l = 0, int r = pod - 1) {
if (x <= l && r <= y) {
mini[u] += z;
lazy[u] += z;
return;
}
push(u, r - l + 1);
int m = (l + r) / 2;
if (x <= m) add(x, y, z, 2 * u, l, m);
if (m < y) add(x, y, z, 2 * u + 1, m + 1, r);
mini[u] = min(mini[2 * u], mini[2 * u + 1]);
}
long long query(int x, int y, int u = 1, int l = 0, int r = pod - 1) {
if (x <= l && r <= y) return mini[u];
push(u, r - l + 1);
int m = (l + r) / 2;
long long res = INF;
if (x <= m) res = min(res, query(x, y, 2 * u, l, m));
if (m < y) res = min(res, query(x, y, 2 * u + 1, m + 1, r));
return res;
}
} ja;
int BOMB[N];
int Z[N];
struct xd {
struct nod {
int L, R, W;
};
nod t[2 * pod];
void init() {
for (int i = 1; i <= 2 * pod - 1; ++i) {
t[i] = {0, 0, 0};
}
}
nod merge(nod a, nod b) {
nod c;
c.W = a.W + b.W;
int d = min(a.L, b.R);
c.W += d;
c.L = a.L + b.L - d;
c.R = a.R + b.R - d;
return c;
}
void akt(int pos) {
if (BOMB[pos] == 1) t[pod + pos].R = 1;
if (Z[pos] == 1) t[pod + pos].L = 1;
t[pod + pos].W = 0;
if (Z[pos] == 1 && BOMB[pos] == 1) {
t[pos + pod].L = t[pos + pod].R = 0;
t[pos + pod].W = 1;
}
pos += pod;
pos /= 2;
while (pos) {
t[pos] = merge(t[2 * pos], t[2 * pos + 1]);
pos /= 2;
}
}
nod query(int x, int y, int u = 1, int l = 0, int r = pod - 1) {
if (x <= l && r <= y) {
return t[u];
}
int m = (l + r) / 2;
nod ans = {0, 0, 0};
if (x <= m) ans = merge(ans, query(x, y, 2 * u, l, m));
if (m < y) ans = merge(ans, query(x, y, 2 * u + 1, m + 1, r));
return ans;
}
} on;
void addbomb(int x) {
ja.add(x, x, -INF);
ja.add(x, pod - 1, -1);
BOMB[x] = 1;
on.akt(x);
bombs.add(x, 1);
}
void addsiebie(int x) {
gao.add(x, 1);
ja.add(x, pod - 1, 1);
Z[x] = 1;
on.akt(x);
}
bool dead(int x) {
int k = on.query(1, x - 1).W;
long long MINI = ja.query(x, pod - 1);
int Left = bombs.query(1, x - 1);
int Left1 = gao.query(1, x - 1);
k = Left1 - k;
if (MINI + k + Left - Left1 < 0) return true;
return false;
}
int n;
int p[N], q[N], gdzie[N];
int main() {
ja.init();
ja.add(0, pod - 1, INF);
bombs.init();
gao.init();
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", p + i);
gdzie[p[i]] = i;
}
for (int i = 1; i <= n; ++i) scanf("%d", q + i);
int ans = n;
for (int i = 1; i <= n; ++i) {
if (i > 1) addbomb(q[i - 1]);
while (ans > 0 && dead(gdzie[ans])) {
addsiebie(gdzie[ans]);
ans--;
}
printf("%d ", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) cin >> b[i];
long long s = abs(b[0]);
for (int i = 1; i < n; i++) {
s += abs(b[i - 1] - b[i]);
}
cout << s;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define fre(x) freopen(#x".in","r",stdin);freopen(#x".out","w",stdout)
#define ll long long
#define pii pair<int,int>
#define mk make_pair
using namespace std;
inline int read(){
int x=0,f=1;char c=getchar();
while(c<'0'||c>'9') { if(c=='-') f=-1;c=getchar(); }
while(c>='0'&&c<='9') x=(x<<3)+(x<<1)+(c^'0'),c=getchar();
return x*f;
}
const int N=1e5+5,inf=0x3f3f3f3f;
int n,m;
int dis[N*52];
vector<pii>e[N*52];
inline void add(int x,int y,int v){
e[x*51].push_back({0,y*51+v});
for(int i=1;i<=50;i++) e[x*51+i].push_back({(i+v)*(i+v),y*51});
}
set<pii>st;
int main(){
n=read(),m=read();
for(int i=1;i<=m;i++){
int x=read(),y=read(),v=read();
add(x,y,v);
add(y,x,v);
}
memset(dis,0x3f,sizeof(dis));
dis[1*51]=0;
st.insert({0,1*51});
while(st.size()>0){
int x=st.begin()->second;
st.erase(st.begin());
for(auto i:e[x]){
int y=i.second,w=dis[x]+i.first;
// printf("%d %d %d\n",x,y,w);
if(dis[y]>w){
st.erase({dis[y],y});
dis[y]=w;
st.insert({dis[y],y});
}
}
}
for(int i=1;i<=n;i++) printf("%d ",dis[i*51]==inf?-1:dis[i*51]);
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x7f7f7f7f;
long long GCD(long long a, long long b) { return 0 == b ? a : GCD(b, a % b); }
const long long mod = 1e9 + 7;
const double pi = acos(-1);
struct noode {
int num, index, x;
} b[2100];
int main() {
ios_base::sync_with_stdio(false);
int a[2100];
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int ans = 0;
cout << n + 1 << endl;
for (int i = n; i >= 1; i--) {
int add = (i - 1 - (a[i] + ans) % n + n) % n;
cout << 1 << " " << i << " " << add << endl;
ans += add;
}
cout << 2 << " " << n << " " << n << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> solve(int n) {
vector<int> v(n, 1);
if (n == 1) return v;
if (n == 2) {
v[0] = 3, v[1] = 4;
return v;
}
int k = n - 1;
if (k & 1) {
int p = k >> 1;
v[n - 1] = p;
} else {
k = k - 1 + 4;
int p = k >> 1;
v[n - 2] = 2, v[n - 1] = p;
}
return v;
}
int main() {
int n, m;
while (cin >> n >> m) {
vector<int> v1 = solve(n), v2 = solve(m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
printf("%d%c", v1[i] * v2[j], j + 1 == m ? 10 : 32);
}
}
| 8 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
const double eps = 1e-14;
using namespace std;
const int N = 55;
int n, m;
int a[N];
long double pw[N], c[N][N], dp[N][N][N];
void solve() {
cin >> n >> m;
pw[0] = 1;
for (int i = 1; i < N; i++) pw[i] = pw[i - 1] * (1 / (double)m);
for (int i = 0; i < N; i++) c[i][0] = 1.0;
for (int i = 1; i < N; i++)
for (int j = 1; j < N; j++) c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
for (int i = 1; i <= m; i++) cin >> a[i];
dp[0][0][0] = 1;
for (int i = 1; i <= m; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= n; k++) {
double v = dp[i - 1][j][k];
if (abs(v) < eps) continue;
for (int t = 0; t <= n - j; t++) {
int my_mx = (t + a[i] - 1) / a[i];
dp[i][j + t][max(k, my_mx)] += c[n - j][t] * pw[t] * v;
}
}
}
}
double ans = 0.0;
for (int i = 1; i <= n; i++) {
ans += dp[m][n][i] * (double)i;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(10);
int step;
step = 1;
for (int i = 1; i <= step; i++) {
solve();
}
}
| 7 |
#include<iostream>
#include<vector>
#include<queue>
#include<cstring>
#include<cmath>
#include<map>
#include<set>
#include<cstdio>
#include<algorithm>
#define debug(a) cout<<#a<<"="<<a<<endl;
using namespace std;
const int maxn=1e5+1000;
typedef long long LL;
const LL mod=1e9+7;
inline LL read(){LL x=0,f=1;char ch=getchar(); while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;}
LL fac[maxn];
bool vis[1<<22];
LL ksm(LL a,LL k){
LL res=1;
while(k){
if(k&1) res=res*a%mod;
k>>=1;
a=a*a%mod;
}return res%mod;
}
///map<LL,LL>map1;
int main(void){
cin.tie(0);std::ios::sync_with_stdio(false);
fac[0]=1;
for(LL i=1;i<maxn;i++) fac[i]=fac[i-1]*i%mod;
LL t;cin>>t;
while(t--){
///map1.clear();
LL n,k;cin>>n>>k;
LL sum=1;
for(LL i=1;i<=k;i++){
sum=(sum%mod*n%mod)%mod;
}
cout<<sum<<"\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
string str;
while (N) {
cin >> str;
if (str.size() > 10) {
string s = str[0] + to_string(str.size() - 2) + str[str.size() - 1];
cout << s << endl;
} else
cout << str << endl;
--N;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const double eps = 1e-9;
const int MAX_N = 1e6 + 5;
const int inf = 2e9;
const long long Inf = (long long)1e18;
const long long M = (long long)1e9 + 7;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
void Char(char* ch) { scanf("%s", ch); }
template <typename t>
inline t abs(t a) {
if (a >= 0) return a;
return -a;
}
template <typename t>
inline t gcd(t a, t b) {
return !b ? a : gcd(b, a % b);
}
template <typename t>
inline t lcm(t a, t b) {
return a * (b / gcd(a, b));
}
template <typename T>
inline T modpow(T b, T p, T Mod) {
T res = 1;
while (p) {
if (p & 1) {
res *= b;
res %= Mod;
}
b *= b;
b %= Mod;
p >>= 1;
}
return res;
}
template <typename T>
inline T ModInv(T b, T Mod) {
return modpow(b, Mod - 2, Mod);
}
template <typename T>
inline T pwr(T b, T p) {
T res = 1;
while (p) {
if (p & 1) {
res *= b;
}
b *= b;
p >>= 1;
}
return res;
}
int e1, e2, d1;
template <typename T>
inline void extgcd(T a, T b) {
if (!b) {
e1 = 1, e2 = 0, d1 = a;
return;
}
extgcd(b, a % b);
T x1 = e2;
T y1 = e1 - (a / b) * e2;
e1 = x1;
e2 = y1;
}
template <typename T>
inline vector<T> Unique(vector<T> v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
return v;
}
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
int main() {
int t = 1, tc = 0;
while (t--) {
int n = Int();
std::vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
a[i] = Int();
}
int res = 1, tem = 1;
for (int i = 1; i < n; i++) {
if (a[i + 1] <= 2 * a[i]) {
tem++;
res = max(res, tem);
} else
tem = 1;
}
cout << res << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, l[300005], r[300005], f[300005], las[300005], ans;
int vis[300005], mx[300005], v[300005], p[300005], Time, Ans[300005];
vector<int> a[300005];
inline int read() {
int s = 0, f = 0;
char ch = getchar();
while (ch < 48 || ch > 57) f = (ch == '-'), ch = getchar();
while (ch > 47 && ch < 58)
s = (s << 1) + (s << 3) + (ch ^ 48), ch = getchar();
return f ? -s : s;
}
void Get(int x, int y) {
if (vis[y] != Time) vis[y] = Time, mx[y] = n + 1;
las[x] = mx[y], f[x] = f[mx[y]] + v[x];
}
void Insert(int x, int y) {
if (vis[y] != Time) vis[y] = Time, mx[y] = n + 1;
if (f[x] > f[mx[y]]) mx[y] = x;
}
int main() {
n = read(), f[n + 1] = -0x3f3f3f3f;
for (int i = 1; i <= n; ++i)
v[i] = read(), p[i] = read(), l[i] = read(), r[i] = read(),
a[p[i] + l[i] + r[i]].push_back(i);
for (int i = 1; i <= 300000; ++i)
if (a[i].size()) {
++Time, Insert(0, 0);
for (int j = 0, siz = a[i].size(), x; j < siz; ++j) {
x = a[i][j], Get(x, l[x]), Insert(x, p[x] + l[x]);
if (!r[x] && f[x] > f[ans]) ans = x;
}
}
while (ans) Ans[++Ans[0]] = ans, ans = las[ans];
printf("%d\n", Ans[0]);
for (int i = Ans[0]; i; --i) printf("%d ", Ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d\n", &n);
int ar[100000];
long long sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &ar[i]);
sum += ar[i];
}
sort(ar, ar + n, std::greater<int>());
long long ans = 0;
long long target = sum / n;
long long rem = sum % n;
for (int i = 0; i < n; ++i) {
long long goal = target;
if (i < rem) {
++goal;
}
ans += labs(goal - ar[i]);
}
cout << ans / 2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[550001], c[10005];
int main() {
int n, d;
cin >> n >> d;
for (register int i = 1; i <= n; i++) {
cin >> c[i];
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (register int i = 1; i <= n; i++) {
for (register int j = 550000; j >= c[i]; j--) {
if (dp[j - c[i]] == 1) dp[j] = 1;
}
}
register int now = 0, t = 0;
for (; t <= 550000; t++) {
int e = now + d;
for (register int i = e; i >= now; i--) {
if (dp[i] == 1) {
now = i;
break;
}
}
if (e == now + d) break;
}
cout << now << ' ' << t << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long T;
cin >> T;
while (T--) {
long long N, K;
cin >> N >> K;
vector<long long> a(N);
long long mn = INT_MAX, pmin = -1;
for (long long i = 0; i < N; ++i) {
cin >> a[i];
if (a[i] < mn) {
mn = a[i];
pmin = i;
}
}
long long ans = 0;
for (long long i = 0; i < N; ++i)
if (i != pmin) ans += (K - a[i]) / mn;
cout << ans << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct binary_indexed_tree {
int N;
vector<T> BIT;
binary_indexed_tree(int N) : N(N), BIT(N + 1, 0) {}
void add(int i, T x) {
i++;
while (i <= N) {
BIT[i] += x;
i += i & -i;
}
}
T sum(int i) {
T ans = 0;
while (i > 0) {
ans += BIT[i];
i -= i & -i;
}
return ans;
}
T sum(int L, int R) { return sum(R) - sum(L); }
};
void dfs(int n, vector<vector<int>> &c, vector<int> &a, vector<int> &ans,
vector<vector<tuple<int, int, int>>> &query, vector<int> &freq,
binary_indexed_tree<int> &freq_cnt, vector<set<int>> &st, int v = 0) {
freq_cnt.add(freq[a[v]], -1);
st[freq[a[v]]].erase(a[v]);
freq[a[v]]++;
freq_cnt.add(freq[a[v]], 1);
st[freq[a[v]]].insert(a[v]);
for (auto &q : query[v]) {
int l = get<0>(q);
int k = get<1>(q);
int id = get<2>(q);
if (freq_cnt.sum(l, n + 1) < k) {
ans[id] = -2;
} else {
int tv = n + 1, fv = l;
while (tv - fv > 1) {
int mid = (tv + fv) / 2;
if (freq_cnt.sum(l, mid) >= k) {
tv = mid;
} else {
fv = mid;
}
}
ans[id] = *st[fv].begin();
}
}
for (int w : c[v]) {
dfs(n, c, a, ans, query, freq, freq_cnt, st, w);
}
freq_cnt.add(freq[a[v]], -1);
st[freq[a[v]]].erase(a[v]);
freq[a[v]]--;
freq_cnt.add(freq[a[v]], 1);
st[freq[a[v]]].insert(a[v]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int j = 0; j < n; j++) {
cin >> a[j];
a[j]--;
}
vector<int> p(n, -1);
for (int j = 1; j < n; j++) {
cin >> p[j];
p[j]--;
}
vector<vector<tuple<int, int, int>>> query(n);
for (int j = 0; j < q; j++) {
int v, l, k;
cin >> v >> l >> k;
v--;
query[v].push_back(make_tuple(l, k, j));
}
vector<vector<int>> c(n);
for (int j = 1; j < n; j++) {
c[p[j]].push_back(j);
}
vector<int> freq(n, 0);
binary_indexed_tree<int> freq_cnt(n + 1);
freq_cnt.add(0, n);
vector<set<int>> st(n + 1);
for (int i = 0; i < n; i++) {
st[0].insert(i);
}
vector<int> ans(q);
dfs(n, c, a, ans, query, freq, freq_cnt, st);
for (int j = 0; j < q; j++) {
cout << ans[j] + 1;
if (j < q - 1) {
cout << ' ';
}
}
cout << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 44;
bool vis[N][N][2];
int f[N][N][2], p1[N][N][2], p2[N][N][2];
int s1[N], s2[N];
void update(int& f, int& p1, int& p2, int val, int sl, int sr) {
if (val < f || (val == f && (sl + sr < p1 + p2))) f = val, p1 = sl, p2 = sr;
}
int dp(int l, int r, int dif) {
if (!l || !r) return 0x7f7f7f7f;
if (l == 1 && r == 1) return (dif == 1) ? (0) : (0x7f7f7f7f);
if (vis[l][r][dif]) return f[l][r][dif];
vis[l][r][dif] = true;
for (int sl = 0; sl <= l; sl++)
for (int sr = 0; sr <= r; sr++) {
if (!sl && !sr) continue;
for (int i = 0; i < sr; i++) s1[i] = (dif + i) & 1;
s1[sr] = sl & 1;
for (int i = 0; i < sl; i++) s2[i] = i & 1;
s2[sl] = (dif + sr) & 1;
int red1 = 0, red2 = 0;
for (int i = 1; i <= sr && i < l - sl + sr; i++)
red1 += (s1[i] == s1[i - 1]);
for (int i = 1; i <= sl && i < r + sl - sr; i++)
red2 += (s2[i] == s2[i - 1]);
if (!red1 && !red2) continue;
update(f[l][r][dif], p1[l][r][dif], p2[l][r][dif],
dp(l + sr - sl - red1, r + sl - sr - red2, s1[0] != s2[0]) + 1, sl,
sr);
}
return f[l][r][dif];
}
typedef class Node {
public:
Node* suf;
int col, s;
Node() {}
Node(Node* suf, int col, int s) : suf(suf), col(col), s(s) {}
} Node;
int d;
int l = 1, r = 1;
Node *stl, *str;
Node nl[200005], nr[200005];
char buf[200005];
inline void init() {
int c1, c2;
scanf("%s", buf);
c1 = buf[0];
nl[0] = Node(nl + 1, -1, -233333);
nl[1] = Node(nl + 2, c1, 1);
for (int i = 1; buf[i]; i++)
if (buf[i] == buf[i - 1])
nl[l].s++;
else
l += 1, nl[l] = Node(nl + l + 1, buf[i], 1);
nl[l + 1].s = -1;
scanf("%s", buf);
c2 = buf[0];
nr[0] = Node(nr + 1, -1, -233333);
nr[1] = Node(nr + 2, c2, 1);
for (int i = 1; buf[i]; i++)
if (buf[i] == buf[i - 1])
nr[r].s++;
else
r += 1, nr[r] = Node(nr + r + 1, buf[i], 1);
nr[r + 1].s = -1;
d = (c1 != c2);
stl = nl, str = nr;
}
pair<int, int> swapS(int sl, int sr, int& l, int& r) {
Node *pl = stl, *psl, *pr = str, *psr;
int rl = 0, rr = 0;
for (int i = 0; i < sl; i++) pl = pl->suf, rl += pl->s;
for (int i = 0; i < sr; i++) pr = pr->suf, rr += pr->s;
psl = pl->suf, psr = pr->suf;
swap(stl, str);
pl->suf = psr;
pr->suf = psl;
if (pl->s > 0 && psr->s > 0 && pl->col == psr->col) {
pl->s += psr->s;
pl->suf = psr->suf;
r--;
}
if (pr->s > 0 && psl->s > 0 && pr->col == psl->col) {
pr->s += psl->s;
pr->suf = psl->suf;
l--;
}
return pair<int, int>(rl, rr);
}
pair<int, int> st1[4] = {pair<int, int>(1, 0), pair<int, int>(2, 1),
pair<int, int>(3, 0), pair<int, int>(1, 0)};
pair<int, int> st2[4] = {pair<int, int>(1, 0), pair<int, int>(2, 1),
pair<int, int>(0, 1), pair<int, int>(1, 0)};
pair<int, int> st3[4] = {pair<int, int>(0, 1), pair<int, int>(0, 3),
pair<int, int>(0, 3), pair<int, int>(0, 1)};
pair<int, int> st4[4] = {pair<int, int>(1, 1), pair<int, int>(2, 0),
pair<int, int>(3, 1), pair<int, int>(1, 1)};
pair<int, int> st5[4] = {pair<int, int>(1, 1), pair<int, int>(3, 1),
pair<int, int>(3, 1), pair<int, int>(1, 1)};
pair<int, int> st6[4] = {pair<int, int>(0, 2), pair<int, int>(1, 3),
pair<int, int>(1, 3), pair<int, int>(1, 1)};
pair<int, int> g(int x, int y, int d) {
if (x <= 10 && y <= 10) {
dp(x, y, d);
return pair<int, int>(p1[x][y][d], p2[x][y][d]);
}
if (!d) {
if (y == 1) return st1[x % 4];
if (y == 2) return st2[x % 4];
if (x == 1) return st3[y % 4];
if (x == 2)
return (y % 4 == 1) ? (pair<int, int>(1, 2)) : (pair<int, int>(0, 1));
return ((((x - y) % 4 + 4) % 4) == 1) ? (pair<int, int>(1, 0))
: (pair<int, int>(0, 1));
} else {
if (y == 1) return st4[x % 4];
if (y == 2) return st5[x % 4];
if (x == 1)
return (y % 4 == 2) ? (pair<int, int>(1, 3)) : (pair<int, int>(0, 2));
if (x == 2) return st6[y % 4];
return ((((x - y) % 4 + 4) % 4) == 2) ? (pair<int, int>(0, 2))
: (pair<int, int>(1, 1));
}
}
vector<pair<int, int> > opt;
inline void solve() {
memset(vis, false, sizeof(vis));
memset(f, 0x7f, sizeof(f));
while (l > 1 || r > 1) {
pair<int, int> s = g(l, r, d);
int sl = s.first, sr = s.second;
l = l - sl + sr, r = r + sl - sr;
opt.push_back(swapS(sl, sr, l, r));
d = (stl->suf->col != str->suf->col);
}
printf("%d\n", (signed)opt.size());
for (int i = 0; i < (signed)opt.size(); i++)
printf("%d %d\n", opt[i].first, opt[i].second);
}
int main() {
init();
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int flag[20];
int mark[20];
int res[20];
int main() {
int a, c, n = 0, m = 0;
cin >> a >> c;
while (a > 0 || c > 0) {
flag[n] = a % 3;
mark[n] = c % 3;
a = a / 3;
c = c / 3;
n++;
}
for (int i = n - 1; i >= 0; i--) {
if (flag[i] != mark[i]) {
if (mark[i] == 0) res[i] = 3 - flag[i];
if (flag[i] == 0) res[i] = mark[i];
if (flag[i] == 1 && mark[i] == 2) res[i] = 1;
if (flag[i] == 2 && mark[i] == 1) res[i] = 2;
}
m = m * 3 + res[i];
}
cout << m;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ans = 0;
vector<vector<int> > dp(10001);
bool DP[10001];
void dfs(int top) {
if (DP[top]) return;
DP[top] = 1;
ans += (dp[top].size() - 1) * (dp[top].size()) / 2 * 1ll;
for (int i = 0; i < dp[top].size(); i++) {
dfs(dp[top][i]);
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
dp[a].push_back(b);
dp[b].push_back(a);
}
dfs(0);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<long, long> arr[100000];
deque<long> dq;
int main() {
long n, q, temp;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> temp;
dq.push_back(temp);
}
long a, b;
for (int i = 0; i < n; i++) {
a = dq[0];
dq.pop_front();
b = dq[0];
dq.pop_front();
arr[i].first = a;
arr[i].second = b;
if (b > a) swap(a, b);
dq.push_front(a);
dq.push_back(b);
}
long long m;
while (q--) {
cin >> m;
m--;
if (m < n) {
cout << arr[m].first << " " << arr[m].second << endl;
} else {
m = m - n;
cout << dq[0] << " " << dq[1 + (m % (n - 1))] << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200100];
int le[200100], ri[200100];
int sta[200100], sz;
int pre[200100][32];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
while (sz > 0 && a[sta[sz]] < a[i]) --sz;
le[i] = sta[sz] + 1;
sta[++sz] = i;
}
sz = 0;
sta[0] = n + 1;
for (int i = n; i >= 1; --i) {
while (sz > 0 && a[sta[sz]] <= a[i]) --sz;
ri[i] = sta[sz] - 1;
sta[++sz] = i;
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 32; ++j) {
pre[i][j] = pre[i - 1][j];
if (a[i] >> j & 1) ++pre[i][j];
}
for (int i = 1; i <= n; ++i) {
int L = le[i] - 1, R = ri[i] + 1;
for (int j = 0; j < 32; ++j) {
if (a[i] >> j & 1) continue;
int lb = i, ub = ri[i] + 1;
while (ub > lb + 1) {
int mid = (lb + ub) >> 1;
if (pre[mid][j] > pre[i][j])
ub = mid;
else
lb = mid;
}
R = min(R, ub);
lb = le[i] - 1, ub = i;
while (ub > lb + 1) {
int mid = (lb + ub) >> 1;
if (pre[i][j] - pre[mid - 1][j])
lb = mid;
else
ub = mid;
}
L = max(L, lb);
}
if (L < le[i] && R > ri[i]) continue;
ans += 1LL * (L - le[i] + 1) * (ri[i] - i + 1);
ans += 1LL * (ri[i] - R + 1) * (i - le[i] + 1);
ans -= 1LL * (L - le[i] + 1) * (ri[i] - R + 1);
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
while (n) {
v.push_back(n % 2);
n /= 2;
}
while (v.size() < 6) v.push_back(0);
vector<int> ans(6);
ans[0] = v[4];
ans[1] = v[1];
ans[2] = v[3];
ans[3] = v[2];
ans[4] = v[0];
ans[5] = v[5];
reverse(ans.begin(), ans.end());
int sol = 0;
for (int i = 0; i < 6; i++) {
sol *= 2;
sol += ans[i];
}
cout << sol;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int MAXK = 17;
const int MAXN = 1 << MAXK;
const int MOD = 0;
int n, m, q;
vector<int> e[MAXN];
int down[MAXN];
int any[MAXN];
int cdiam, ccomp, comp[MAXN];
int cnt[MAXN];
void dfs1(int v, int pr, int ch) {
down[v] = 0;
for (int to : e[v]) {
if (to == pr) continue;
dfs1(to, v, ch + 1);
down[v] = max(down[v], down[to] + 1);
}
}
void dfs2(int v, int pr) {
any[v] = 0;
for (int to : e[v]) {
any[v] = max(any[v], down[to] + 1);
}
cdiam = max(cdiam, any[v]);
cnt[any[v]]++;
comp[v] = ccomp;
int k = e[v].size();
vector<int> pref(k + 2, 0), suf(k + 2, 0);
for (int i = 1; i <= k; i++)
pref[i] = max(pref[i - 1], down[e[v][i - 1]] + 1);
for (int i = k; i >= 1; i--) suf[i] = max(suf[i + 1], down[e[v][i - 1]] + 1);
for (int i = 1; i <= k; i++) {
int to = e[v][i - 1];
if (to == pr) continue;
int old = down[v];
down[v] = max(pref[i - 1], suf[i + 1]);
dfs2(to, v);
down[v] = old;
}
}
int main() {
while (scanf("%d%d%d", &n, &m, &q) == 3) {
for (int i = 0; i < n; i++) {
e[i].clear();
comp[i] = -1;
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
e[u].push_back(v);
e[v].push_back(u);
}
vector<vector<int> > vct;
ccomp = 0;
for (int i = 0; i < n; i++) {
if (comp[i] != -1) continue;
cdiam = 0;
dfs1(i, -1, 0);
dfs2(i, -1);
vector<int> cur(cdiam + 1);
for (int i = 0; i <= cdiam; i++) cur[i] = cnt[i];
vct.push_back(cur);
for (int i = 0; i <= cdiam; i++) cnt[i] = 0;
ccomp++;
}
vector<vector<long long> > sum(ccomp);
vector<vector<long long> > sum2(ccomp);
for (int i = 0; i < ccomp; i++) {
sum[i].assign(vct[i].size(), 0);
sum2[i].assign(vct[i].size(), 0);
for (int j = (int)sum[i].size() - 1; j >= 0; j--) {
if (j + 1 < (int)sum[i].size()) {
sum[i][j] = sum[i][j + 1];
sum2[i][j] = sum2[i][j + 1];
}
sum[i][j] += vct[i][j];
sum2[i][j] += 1LL * vct[i][j] * j;
}
}
map<pair<int, int>, double> mp;
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
u = comp[u];
v = comp[v];
if (u == v) {
printf("%d\n", -1);
} else {
if (!mp.count(make_pair(u, v))) {
if (vct[u].size() > vct[v].size()) swap(u, v);
int maxdiam = max((int)vct[u].size() - 1, (int)vct[v].size() - 1);
long long ccnt = 0;
long long csum = 0;
for (int i = 0; i < (int)vct[u].size(); i++) {
int j = maxdiam - i;
if (j < (int)vct[v].size()) {
ccnt += 1LL * vct[u][i] * sum[v][j];
csum +=
1LL * vct[u][i] * (sum2[v][j] + 1LL * sum[v][j] * (i + 1));
}
}
long long cnt2 = 1LL * sum[v][0] * sum[u][0] - ccnt;
double res =
(cnt2 * maxdiam + csum) * 1.0 / (1LL * sum[v][0] * sum[u][0]);
mp[make_pair(u, v)] = res;
}
printf("%.15f\n", mp[make_pair(u, v)]);
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int x;
scanf("%d", &x);
int cnt = 0;
int k = x % 10;
int dig = 0, xx = x;
while (x) {
dig++;
x /= 10;
}
int c[10] = {0, 1, 3, 6, 10};
cnt = 10 * (k - 1) + c[dig];
printf("%d\n", cnt);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
stack<char> a, b;
string s, ss;
cin >> ss;
s = ss;
for (long long i = s.size() - 1; i >= 0; i--) {
if (a.empty()) {
a.push(s[i]);
} else {
if (a.top() == s[i])
a.pop();
else
a.push(s[i]);
}
}
while (a.size()) {
cout << a.top();
a.pop();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 3e5 + 7;
struct Trie {
int ch[26];
} w[maxn], rest[maxn];
int n, res[maxn], sz[maxn], rm, id;
void merge(int u, int v) {
for (int i = 0; i < 26; i++) {
if (!w[v].ch[i]) continue;
if (!rest[u].ch[i]) {
rest[u].ch[i] = id++;
} else {
rm++;
}
merge(rest[u].ch[i], w[v].ch[i]);
}
}
void get_ans(int u, int v) {
for (int i = 0; i < 26; i++)
if (rest[u].ch[i] && w[v].ch[i]) {
rm++;
get_ans(rest[u].ch[i], w[v].ch[i]);
}
}
void init(int u) {
for (int i = 0; i < 26; i++) {
if (rest[u].ch[i]) {
init(rest[u].ch[i]);
rest[u].ch[i] = 0;
}
}
}
void dfs(int u, int dep) {
int mx = 0, mxv = -1;
sz[u] = 1;
for (int i = 0; i < 26; i++) {
if (w[u].ch[i] == 0) continue;
int v = w[u].ch[i];
dfs(v, dep + 1);
sz[u] += sz[v];
if (sz[v] > mx) {
mx = sz[v];
mxv = v;
}
}
if (mxv == -1) return;
rm = 1;
id = 2;
init(1);
for (int i = 0; i < 26; i++) {
int v = w[u].ch[i];
if (v == 0) continue;
if (v == mxv) continue;
merge(1, v);
rm++;
}
get_ans(1, mxv);
res[dep] += rm;
}
void solve() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
char c[5];
scanf("%d%d%s", &u, &v, c);
w[u].ch[c[0] - 'a'] = v;
}
dfs(1, 1);
int ans = 1;
for (int i = 1; i <= n; i++)
if (res[ans] < res[i]) ans = i;
printf("%d\n%d\n", n - res[ans], ans);
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
map<int, pair<int, int> > mp;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
mp[a].first++;
mp[a].second = i;
}
int mx = -1, mxid = -1;
for (map<int, pair<int, int> >::iterator it = mp.begin(); it != mp.end();
++it) {
if (mxid == -1 || (*it).second.first > mx ||
(*it).second.first == mx && (*it).second.second < mp[mxid].second) {
mxid = (*it).first;
mx = (*it).second.first;
}
}
cout << mxid;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(4)
using namespace std;
const int N = 3e5 + 5;
int x[N], e[N], num[N], ans[N];
char d[10];
bool cmp(int &a, int &b) { return x[a] < x[b]; }
int main() {
int n, m;
long long t;
scanf("%d %d %lld", &n, &m, &t);
int pos = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &x[i]);
x[i]--;
num[i] = i;
scanf("%s", d);
if (d[0] == 'L') {
e[i] = x[i] - t % m;
pos = ((pos - t / m) % n + n) % n;
if (e[i] < 0) e[i] += m, pos = (pos + n - 1) % n;
} else {
e[i] = x[i] + t % m;
pos = ((pos + t / m) % n + n) % n;
if (e[i] >= m) e[i] -= m, pos = (pos + 1) % n;
}
}
sort(e, e + n);
sort(num, num + n, cmp);
int cnt = 0;
for (int i = pos; i < n; ++i) ans[num[cnt++]] = e[i] + 1;
for (int i = 0; i < pos; ++i) ans[num[cnt++]] = e[i] + 1;
for (int i = 0; i < n; ++i) printf("%d ", ans[i]);
return 0;
}
| 10 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MAX 100005
int t,n,m;
int a[MAX],b[MAX],suma[MAX],sumb[MAX];
int main()
{
scanf("%d",&t);
while(t--){
scanf("%d",&n);
int maxx1=0,maxx2=0;
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
if(i==0){
suma[i]=a[i];
maxx1=max(maxx1,suma[i]);
}
if(i>0){
suma[i]=suma[i-1]+a[i];
maxx1=max(maxx1,suma[i]);
}
}
scanf("%d",&m);
for(int i=0;i<m;i++){
scanf("%d",&b[i]);
if(i==0){
sumb[i]=b[i];
maxx2=max(maxx2,sumb[i]);
}
else {
sumb[i]=sumb[i-1]+b[i];
maxx2=max(maxx2,sumb[i]);
}
}
maxx1=max(0,maxx1);
maxx2=max(0,maxx2);
printf("%d\n",max(maxx1+maxx2,0));
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXM = 200005;
const int MOD = 1000000007;
const int MAMOD = 998244353;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double EPS = 1e-8;
int main() {
ios::sync_with_stdio(0);
int T, n, x, y, maxx, minn;
cin >> T;
while (T--) {
cin >> n >> x >> y;
minn = min(x + y - 1, n);
maxx = min(max(x + y + 1 - n, 1), n);
cout << maxx << " " << minn << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, unsigned long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x;
}
y = y >> 1;
x = x * x;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int powermod(long long int x, unsigned 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;
}
int32_t main() {
long long int n;
cin >> n;
vector<long long int> v, u;
for (long long int i = (long long int)(0); i < (long long int)(n); i++) {
long long int t;
cin >> t;
v.push_back(t);
}
long long int mx = 0, sum = 0, prev, idx = 0;
for (long long int i = (long long int)(0); i < (long long int)(n); i++) {
sum = v[i];
prev = v[i];
for (long long int j = (long long int)(i - 1); j >= (long long int)(0);
j--) {
sum += min(prev, v[j]);
prev = min(v[j], prev);
}
prev = v[i];
for (long long int j = (long long int)(i + 1); j < (long long int)(n);
j++) {
sum += min(prev, v[j]);
prev = min(v[j], prev);
}
if (sum >= mx) {
idx = i;
mx = sum;
}
}
prev = v[idx];
for (long long int j = (long long int)(idx - 1); j >= (long long int)(0);
j--) {
u.push_back(min(prev, v[j]));
prev = min(v[j], prev);
}
reverse((u).begin(), (u).end());
prev = v[idx];
u.push_back(v[idx]);
for (long long int j = (long long int)(idx + 1); j < (long long int)(n);
j++) {
u.push_back(min(prev, v[j]));
prev = min(v[j], prev);
}
for (auto &val : u) cout << val << " ";
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sz = 1, t, a, x;
long long sum = 0;
vector<int> arr, d;
d.push_back(0);
arr.push_back(0);
cin >> n;
while (n--) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &a, &x);
sum += x * a;
d[a - 1] += x;
} else if (t == 2) {
scanf("%d", &x);
sum += x;
sz++;
arr.push_back(x);
d.push_back(0);
} else if (t == 3) {
sz--;
d[sz - 1] += d[sz];
sum -= d[sz] + arr[sz];
d.pop_back();
arr.pop_back();
}
printf("%.9lf\n", (double)(sum) / sz);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<long long, int> > q;
struct node {
int l;
int r;
int to;
int nx;
} e[200000];
int cabeza[100000];
int ecnt;
int respuesta[100000];
void agregarvertices(int x, int y, int l, int r) {
e[ecnt].l = l;
e[ecnt].r = r;
e[ecnt].to = y;
e[ecnt].nx = cabeza[x];
cabeza[x] = ecnt++;
}
long long d1[100000], d2[100000];
int n, m, k, s1, s2, f;
void gao(int bo) {
while (!q.empty()) q.pop();
memset(respuesta, -1, sizeof(respuesta));
for (int i = 0; i <= n; ++i) d1[i] = d2[i] = 1e15;
d1[s1] = d2[s2] = 0;
q.push(make_pair(0, s1));
q.push(make_pair(0, s2));
while (!q.empty()) {
pair<long long, int> ee = q.top();
q.pop();
long long va = -ee.first;
int id = ee.second;
if (va > d1[id] && va > d2[id]) continue;
bool ok;
if (bo == 1) {
if (d1[id] < d2[id])
ok = true;
else
ok = false;
} else {
if (d1[id] <= d2[id])
ok = true;
else
ok = false;
}
for (int i = cabeza[id]; i != -1; i = e[i].nx) {
int u = e[i].to;
long long agregar;
if (ok)
agregar = e[i].l;
else
agregar = e[i].r;
respuesta[i] = agregar;
if (d1[u] > d1[id] + agregar) {
d1[u] = d1[id] + agregar;
q.push(make_pair(-d1[u], u));
}
if (d2[u] > d2[id] + agregar) {
d2[u] = d2[id] + agregar;
q.push(make_pair(-d2[u], u));
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf("%d%d%d", &s1, &s2, &f);
memset(cabeza, -1, sizeof(cabeza));
ecnt = 0;
for (int i = 0; i < m; ++i) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
agregarvertices(x, y, z, z);
}
for (int i = 0; i < k; ++i) {
int x, y, l, r;
scanf("%d%d%d%d", &x, &y, &l, &r);
agregarvertices(x, y, l, r);
}
gao(1);
if (d1[f] < d2[f]) {
printf("WIN\n");
for (int i = m; i < m + k; ++i) {
if (respuesta[i] == -1) respuesta[i] = e[i].l;
printf("%d", respuesta[i]);
if (i == m + k - 1)
puts("");
else
printf(" ");
}
return 0;
}
gao(0);
if (d1[f] == d2[f]) {
printf("DRAW\n");
for (int i = m; i < m + k; ++i) {
if (respuesta[i] == -1) respuesta[i] = e[i].l;
printf("%d", respuesta[i]);
if (i == m + k - 1)
puts("");
else
printf(" ");
}
return 0;
}
printf("LOSE\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int n = 1200000;
int is_palin(int x) {
vector<int> a;
for (; x > 0; x /= 10) a.push_back(x % 10);
for (int i = 0, j = a.size() - 1; i < j; i++, j--)
if (a[i] != a[j]) return 0;
return 1;
}
int main() {
vector<bool> is_prime(n, true);
vector<int> pi(n, 0), su(n, 0);
su[1] = 1;
for (int i = 2; i < n; i++) {
pi[i] = pi[i - 1];
su[i] = su[i - 1] + is_palin(i);
if (is_prime[i]) {
pi[i]++;
for (int j = i << 1; j < n; j += i) is_prime[j] = false;
}
}
int ans = -1, p, q;
scanf("%d%d", &p, &q);
for (int i = 1; i < n; i++) {
if (q * pi[i] <= p * su[i]) ans = i;
}
if (ans == -1)
printf("Palindromic tree is better than splay tree\n");
else
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int shortenAndGetPower(int divider, int &x) {
int power = 0;
while (0 == x % divider) {
x /= divider;
++power;
}
return power;
}
list<pair<int, int> > factorize(int x) {
list<pair<int, int> > factorization;
if (0 == x % 2) {
factorization.emplace_back(2, shortenAndGetPower(2, x));
}
for (int divider = 3; 1LL * divider * divider <= x; divider += 2) {
if (0 == x % divider) {
factorization.emplace_back(divider, shortenAndGetPower(divider, x));
}
}
if (1 < x) {
factorization.emplace_back(x, 1);
}
return factorization;
}
map<vector<int>, long long> spragueGrundyMemory;
long long calculateSpragueGrundy(vector<int> powers) {
sort(powers.begin(), powers.end());
if (spragueGrundyMemory.count(powers)) {
return spragueGrundyMemory[powers];
}
unsigned long long spragueGrundyUsed = 0;
for (int power = 1; power <= powers.back(); ++power) {
vector<int> newPowers;
for (int i = 0; i < (int)powers.size(); ++i) {
if (powers[i] != power) {
newPowers.push_back(powers[i] < power ? powers[i] : powers[i] - power);
}
}
spragueGrundyUsed |= 1LL << calculateSpragueGrundy(newPowers);
}
long long mex;
for (mex = 0; (spragueGrundyUsed >> mex) & 1; ++mex)
;
return spragueGrundyMemory[powers] = mex;
}
bool isMojtaba(int n, int a[]) {
map<int, vector<int> > primeToPowers;
for (int i = 0; i < n; ++i) {
const auto primePowers = factorize(a[i]);
for (const auto &primePower : primePowers) {
primeToPowers[primePower.first].push_back(primePower.second);
}
}
spragueGrundyMemory.clear();
spragueGrundyMemory[vector<int>()] = 0;
long long spragueGrundy = 0;
for (const auto &primePowers : primeToPowers) {
spragueGrundy ^= calculateSpragueGrundy(primePowers.second);
}
return spragueGrundy > 0;
}
int main() {
int n;
while (~scanf("%d", &n)) {
int a[n];
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
if (isMojtaba(n, a)) {
printf("Mojtaba\n");
} else {
printf("Arpa\n");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a, s, d, f, g, h, j, k, l, i, n, m, min1 = 2003, max1, min2 = 2004, max2;
string x[2003];
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> x[i];
for (a = 0; a < m; a++) {
if (x[i][a] == 'w') {
s++;
if (min1 > i) min1 = i;
if (min2 > a) min2 = a;
if (max1 < i) max1 = i;
if (max2 < a) max2 = a;
}
}
}
if (s == 1) {
for (i = 0; i < n; i++) {
cout << x[i] << endl;
}
return 0;
}
if (max1 - min1 > max2 - min2) {
k = max1 - min1;
if (m <= k) {
cout << -1;
return 0;
}
for (l = 0; l <= m; l++) {
if (k + l >= m) {
cout << -1;
return 0;
}
for (i = 0; i <= k; i++) {
if (x[i + min1][l] != '.') j++;
if (x[i + min1][l + k] != '.') j++;
if (x[min1][l + i] != '.' && i != 0 && i != k) j++;
if (x[max1][l + i] != '.' && i != 0 && i != k) j++;
}
if (j == s) {
for (i = 0; i <= k; i++) {
if (x[i + min1][l] == '.') x[i + min1][l] = '+';
if (x[i + min1][l + k] == '.') x[i + min1][l + k] = '+';
if (x[min1][l + i] == '.') x[min1][l + i] = '+';
if (x[max1][l + i] == '.') x[max1][l + i] = '+';
}
break;
}
j = 0;
}
} else {
k = max2 - min2;
if (n <= k) {
cout << -1;
return 0;
}
for (l = 0; l <= n; l++) {
if (l + k >= n) {
cout << -1;
return 0;
}
for (i = 0; i <= k; i++) {
if (x[l][i + min2] != '.') j++;
if (x[l + k][i + min2] != '.') j++;
if (x[i + l][min2] != '.' && i != 0 && i != k) j++;
if (x[i + l][max2] != '.' && i != 0 && i != k) j++;
}
if (j == s) {
for (i = 0; i <= k; i++) {
if (x[l][i + min2] == '.') x[l][min2 + i] = '+';
if (x[l + k][i + min2] == '.') x[l + k][min2 + i] = '+';
if (x[i + l][min2] == '.') x[i + l][min2] = '+';
if (x[i + l][max2] == '.') x[i + l][max2] = '+';
}
break;
}
j = 0;
}
}
for (i = 0; i < n; i++) {
cout << x[i] << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct EulerCycle {
struct data__ {
int u, rev;
};
int n, m = 0;
vector<vector<data__>> a;
vector<int> path;
vector<bool> seen;
void dfs(int u) {
while (!a[u].empty()) {
auto [v, rev] = a[u].back();
a[u].pop_back();
if (seen[rev]) continue;
seen[rev] = true;
dfs(v);
}
path.push_back(u);
}
void addEdge(int u, int v) {
a[u].push_back({v, m});
a[v].push_back({u, m});
m++;
}
bool haveEuler() {
seen.assign(m, 0);
int sta = -1;
int total = 0;
for (int i = (int)0; i <= (int)n - 1; i++)
if (a[i].size() % 2) total++, sta = i;
if (total != 0) return false;
if (sta == -1)
for (int i = (int)0; i <= (int)n - 1; i++)
if (a[i].size()) sta = i;
if (sta == -1) sta = 0;
dfs(sta);
for (int i = (int)0; i <= (int)n - 1; i++)
if (!a[i].empty()) return false;
reverse(path.begin(), path.end());
return (path.front() == path.back());
}
EulerCycle(){};
EulerCycle(int _n) : n(_n), a(n, vector<data__>()){};
} euler;
int n;
vector<pair<int, int>> a;
vector<int> path;
bool check(int mid) {
int mask = (1 << mid) - 1;
euler = EulerCycle(1 + mask + 2 * n);
for (int i = (int)0; i <= (int)a.size() - 1; i++) {
euler.addEdge(i * 2, i * 2 + 1);
euler.addEdge(i * 2, 2 * n + (mask & a[i].first));
euler.addEdge(i * 2 + 1, 2 * n + (mask & a[i].second));
}
if (euler.haveEuler()) {
path = euler.path;
return true;
}
return false;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = (int)1; i <= (int)n; i++) {
int x, y;
cin >> x >> y;
a.push_back({x, y});
}
int l = 0, r = 20;
while (l != r) {
int mid = (l + r + 1) / 2;
if (check(mid))
l = mid;
else
r = mid - 1;
}
check(l);
cout << l << '\n';
for (auto it : path) {
if (it < 2 * n) cout << it + 1 << ' ';
}
cout << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
scanf("%d", &n);
if (n & 1)
puts("Ehab");
else
puts("Mahmoud");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Event {
long long t;
int ennemy = -1;
int health = -1;
Event(long long t, int ennemy, int health)
: t(t), ennemy(ennemy), health(health) {}
bool operator<(const Event &other) const {
if (t != other.t) return t < other.t;
if ((ennemy == -1) != (other.ennemy == -1)) return ennemy != -1;
if (health != other.health) return health > other.health;
return ennemy < other.ennemy;
}
};
int ceilDiv(int a, int b) { return (a + b - 1) / b; }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, bounty, increase, damage;
cin >> n >> m >> bounty >> increase >> damage;
vector<int> maxHealth(n + 1);
vector<pair<int, int>> currHealth(n + 1, {0, 0});
vector<int> regen(n + 1);
long long t = 0;
int killRange = 0;
set<Event> events;
for (int i = 1; i <= n; ++i) {
cin >> maxHealth[i] >> currHealth[i].second >> regen[i];
if (currHealth[i].second <= damage) {
++killRange;
if (regen[i] && maxHealth[i] > damage) {
auto te = t + ceilDiv(damage + 1 - currHealth[i].second, regen[i]);
events.insert({te, i, -1});
events.insert({te, -1, -1});
events.insert({te - 1, -1, -1});
}
}
}
while (m-- > 0) {
int te, ennemy, health;
cin >> te >> ennemy >> health;
events.insert({te, ennemy, health});
events.insert({te - 1, -1, -1});
}
long long ans = (long long)killRange * bounty;
while (!events.empty()) {
Event e = *events.cbegin();
events.erase(events.cbegin());
if (e.t < t) continue;
t = e.t;
if (e.ennemy == -1) {
ans = max(ans, (long long)killRange * (bounty + t * increase));
continue;
}
if (currHealth[e.ennemy].second <= damage) --killRange;
if (e.health != -1)
currHealth[e.ennemy] = {t, e.health};
else
currHealth[e.ennemy] = {t, min((long long)maxHealth[e.ennemy],
currHealth[e.ennemy].second +
(long long)regen[e.ennemy] *
(t - currHealth[e.ennemy].first))};
if (currHealth[e.ennemy].second <= damage) {
++killRange;
if (regen[e.ennemy] && maxHealth[e.ennemy] > damage) {
auto te = t + ceilDiv(damage + 1 - currHealth[e.ennemy].second,
regen[e.ennemy]);
events.insert({te, e.ennemy, -1});
events.insert({te, -1, -1});
events.insert({te - 1, -1, -1});
}
}
}
cout << (killRange && increase ? -1 : ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long int mod(long int x) { return (x > 0) ? x : -x; }
int main() {
ios_base::sync_with_stdio(0);
long int n, s, t, i, count = 0;
cin >> n >> s >> t;
long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
if (s == t) {
cout << 0;
return 0;
}
long int k = s;
while (a[k - 1] != s) {
count++;
if (a[k - 1] == t) {
cout << count;
return 0;
}
k = a[k - 1];
}
cout << -1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void print() { cout << "\n"; }
template <typename T, typename... Types>
void print(T arg, Types... args) {
cout << arg << " ";
print(args...);
}
const int mod = 1e9 + 7;
const int N = 2e5 + 7;
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long modInv(long long a, long long m) {
long long x, y;
long long g = gcdExtended(a, m, &x, &y);
long long res = (x % m + m) % m;
return res;
}
long long mpower(long long x, long long y, long long p) {
long long 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 power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
long long p = sqrt(n);
for (int i = 5; i <= p; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int tc = 1;
cin >> tc;
while (tc--) {
int n, k, p;
string s, t;
cin >> n >> k;
cin >> s;
p = n / 2;
for (int i = 0; i < k - 1; i++) {
t += "()";
}
for (int i = 0; i < p - k + 1; i++) t += '(';
for (int i = 0; i < p - k + 1; i++) t += ')';
std::vector<int> open, close;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
if (s[i] == '(')
open.push_back(i);
else
close.push_back(i);
}
}
vector<pair<int, int> > res;
int l = open.size();
int x, y;
for (int i = 0; i < l; i++) {
x = open[i], y = close[i];
if (x > y) swap(x, y);
res.push_back({x, y});
if (y - x > 2) {
res.push_back({x + 1, y - 1});
}
}
l = res.size();
cout << l << "\n";
for (auto i : res) {
cout << (i.first + 1) << " " << (i.second + 1) << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int d[5005][5005];
int x[5005], y[5005];
int b[5005];
int le, ri, mid;
int dfs(int x, int k) {
if (b[x] >= 0) {
return b[x] - k;
}
b[x] = k;
for (int y = 0; y < n; y++) {
if (d[x][y] > mid) {
if (dfs(y, k ^ 1)) {
return 1;
}
}
}
return 0;
}
int cal() {
int ans = 1;
memset(b, -1, sizeof(b));
for (int i = 0; i < n; i++) {
if (b[i] < 0) {
if (dfs(i, 0)) {
return -1;
}
ans = ans * 2 % 1000000007;
}
}
return ans;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
d[i][j] = abs(x[i] - x[j]) + abs(y[i] - y[j]);
}
}
le = 0;
ri = 1000000000;
mid = (le + ri) / 2;
while (ri > le) {
mid = (le + ri) / 2;
if (cal() == -1) {
le = mid + 1;
} else {
ri = mid;
}
}
mid = le;
cout << mid << endl << cal();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, count = 1;
long long A[26];
for (int i = 0; i < 26; i++) A[i] = 0;
cin >> n >> k;
string s;
cin >> s;
char last, temp;
last = s[0];
if (k != 1) {
for (long long i = 1; i < n; i++) {
temp = s[i];
if (temp == last) {
if (count == (k - 1)) {
A[temp - 'a']++;
i++;
last = s[i];
count = 1;
} else {
count++;
}
} else {
count = 1;
last = temp;
}
}
} else {
for (long long i = 0; i < n; i++) {
A[s[i] - 'a']++;
}
}
long long maxi = 0;
for (int i = 0; i < 26; i++) maxi = max(A[i], maxi);
cout << maxi;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
int main() {
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ans[n + 1];
ans[n] = 1;
int b[n + 1];
b[n] = 0;
int s1 = a[n];
for (int i = n - 1; i >= 1; i--) {
if (a[i] >= s1) {
b[i] = 1;
s1 = a[i] - s1;
ans[i] = 1;
} else {
b[i] = 0;
s1 = s1 - a[i];
ans[i] = 0;
}
}
int r = 0;
for (int i = 1; i <= n - 1; i++) {
r += b[i];
r %= 2;
if (r == 1) {
ans[i + 1] = 1 - ans[i + 1];
}
}
string ans1 = "";
for (int i = 1; i <= n; i++) {
if (ans[i] == 1) {
ans1.push_back('+');
} else {
ans1.push_back('-');
}
}
cout << ans1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float d, l, v1, v2;
cin >> d >> l >> v1 >> v2;
l = ((l - d)) / (v1 + v2);
int x = l / 1;
std::cout.precision(6 + x);
std::cout << l;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x7fffffffffffffff;
template <typename T>
inline T getNum() {
T k = 0;
long long c = getchar(), f = 1;
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) k = k * 10 + c - '0';
return k * f;
}
long long GCD(long long a, long long b) {
if (b)
while ((a %= b) && (b %= a))
;
return a + b;
}
const int maxn = 100030;
int main() {
long long t = getNum<long long>();
while (t--) {
long long n = getNum<long long>(), x = getNum<long long>(),
y = getNum<long long>();
if (y < x) swap(x, y);
int dt = y - x;
if (dt == 0) {
for (int i = 0; i < n; i++) cout << x << ' ';
cout << '\n';
} else {
set<int> yz;
for (int i = 1; i * i <= dt; i++) {
if (dt % i) continue;
yz.insert(i);
yz.insert(dt / i);
}
for (auto i : yz) {
if (dt / i > n - 1) continue;
x %= i;
if (!x) x = i;
if (x + (n - 1) * i < y) x = y - (n - 1) * i;
for (int j = 0; j < n; j++) {
cout << x + j * i << ' ';
}
cout << '\n';
break;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int func(int a) {
int rtn = 1;
for (int i = (2); i < (a + 1); i++) {
rtn *= i;
}
return rtn;
}
string next_perm(string s, vector<int> p) {
string rtn = "";
for (int i = (0); i < (p.size()); i++) {
rtn += s[p[i]];
}
return rtn;
}
void solve() {
cin >> n >> k;
vector<string> nums, nums_org;
string tmp;
vector<int> perm;
for (int i = (0); i < (k); i++) {
perm.push_back(i);
}
for (int i = (0); i < (n); i++) {
cin >> tmp;
nums.push_back(tmp);
}
copy(nums.begin(), nums.end(), back_inserter(nums_org));
int nums_int[n];
int ans = numeric_limits<int>::max();
int *max_num, *min_num;
int kex = func(k);
for (int i = (0); i < (kex + 1); i++) {
for (int j = (0); j < (n); j++) {
nums_int[j] = atoi(nums[j].c_str());
}
max_num = max_element(nums_int, nums_int + n);
min_num = min_element(nums_int, nums_int + n);
ans = min(ans, *max_num - *min_num);
next_permutation(perm.begin(), perm.end());
for (int j = (0); j < (n); j++) {
nums[j] = next_perm(nums_org[j], perm);
}
}
cout << ans << endl;
}
int main(int argc, char *argv[]) {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ip1[200005];
int ip2[200005];
int n1, n2;
int maxi = -100000000, a = -100000000;
void binary_search(int temp) {
int low1 = upper_bound(ip1, ip1 + n1, temp) - ip1;
int low2 = upper_bound(ip2, ip2 + n2, temp) - ip2;
int s1 = low1 * 2 + (n1 - low1) * 3;
int s2 = low2 * 2 + (n2 - low2) * 3;
if (maxi < (s1 - s2)) {
maxi = s1 - s2;
a = s1;
} else if (maxi == (s1 - s2) && a < s1) {
a = s1;
}
}
int main() {
set<int> ss;
cin >> n1;
for (int(i) = 0; (i) < (n1); (i)++) {
cin >> ip1[i];
ss.insert(ip1[i]);
}
cin >> n2;
for (int(i) = 0; (i) < (n2); (i)++) {
cin >> ip2[i];
ss.insert(ip2[i]);
}
sort(ip1, ip1 + n1);
sort(ip2, ip2 + n2);
while (1) {
if (ss.empty()) {
break;
}
set<int>::iterator it;
it = ss.begin();
int temp = *it;
ss.erase(temp);
binary_search(temp);
}
int yo = 3 * (n1 - n2);
if (yo > maxi) {
maxi = yo;
a = 3 * n1;
} else if (yo == maxi && a < 3 * n1)
a = 3 * n1;
cout << a << ":" << a - maxi << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long T, n, par[400010], cnt;
long long ans;
struct node {
long long pos;
long long val;
bool operator<(node b) const {
if (val == b.val) return pos < b.pos;
return val > b.val;
}
};
priority_queue<node> q;
int main() {
T = 1;
while (T--) {
scanf("%lld", &n);
long long x, z, y;
memset(par, 0, sizeof(par));
while (!q.empty()) q.pop();
ans = 0;
cnt = 0;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &x);
if (!q.empty() && q.top().val < x) {
node pre = q.top();
y = pre.val;
z = pre.pos;
par[i] = 1;
if (par[z] == 0) {
cnt++;
ans += x - y;
q.pop();
} else {
ans += x - y;
par[z] = 0;
}
}
node tmp;
tmp.val = x;
tmp.pos = i;
q.push(tmp);
}
printf("%lld\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
string s;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> s;
char aa = '3';
int ind = 0;
for (int j = 0; j < s.length(); j++) {
if (s[j] != s[0]) {
aa = s[j];
ind = j;
break;
}
}
if (aa == '3') {
cout << -1 << endl;
continue;
}
if (s[0] != s[s.length() - 1]) {
cout << s << endl;
continue;
}
swap(s[0], s[ind]);
cout << s << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MaxN = 200111;
const int AINT_SIZE = MaxN * 5;
struct AINT_NODE {
long long sum, aux;
};
int N, size, op, x, val;
AINT_NODE aint[AINT_SIZE];
int q_st, q_dr, q_val;
inline void Augment(int nod, int st, int dr) {
int l = nod << 1;
int r = l + 1;
aint[nod].sum += aint[nod].aux * (dr - st + 1);
if (st < dr) {
aint[l].aux += aint[nod].aux;
aint[r].aux += aint[nod].aux;
}
aint[nod].aux = 0;
}
void Update(int nod, int st, int dr) {
if (q_st <= st && dr <= q_dr) {
if (q_val == -1337) {
aint[nod].sum = 0;
} else {
aint[nod].aux += q_val;
Augment(nod, st, dr);
}
return;
}
int mid = st + ((dr - st) >> 1);
int l = nod << 1;
int r = l + 1;
Augment(l, st, mid);
Augment(r, mid + 1, dr);
if (q_st <= mid) {
Update(l, st, mid);
}
if (mid < q_dr) {
Update(r, mid + 1, dr);
}
aint[nod].sum = aint[l].sum + aint[r].sum;
}
int main() {
scanf("%d", &N);
size = 1;
for (register int i = 1; i <= N; ++i) {
scanf("%d", &op);
if (op == 2) {
scanf("%d", &x);
++size;
q_st = size;
q_dr = size;
q_val = x;
Augment(1, 1, MaxN);
Update(1, 1, MaxN);
} else if (op == 1) {
scanf("%d %d", &x, &val);
q_st = 1;
q_dr = x;
q_val = val;
Augment(1, 1, MaxN);
Update(1, 1, MaxN);
} else {
q_st = size;
q_dr = size;
q_val = -1337;
Augment(1, 1, MaxN);
Update(1, 1, MaxN);
--size;
}
printf("%.6lf\n", (double)(aint[1].sum) / (double)(size));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-7;
int n, k;
int fa[maxn];
int find(int a) { return fa[a] == a ? a : fa[a] = find(fa[a]); }
int main() {
n = read(), k = read();
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= k; ++i) {
int x = read(), y = read();
int a = find(x), b = find(y);
if (a != b) fa[a] = b;
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
if (fa[i] == i) cnt++;
}
cout << k - n + cnt << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e2 + 10;
int N, connect[maxN][maxN], ban[maxN][maxN];
int deg[maxN];
int main() {
scanf("%d\n", &N);
printf("%d\n", (N / 2) * (N - N / 2));
for (int i = 0; i < N / 2; i++)
for (int j = N / 2; j < N; j++) printf("%d %d\n", i + 1, j + 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using i3 = pair<int, ii>;
using li = pair<ll, int>;
using lii = pair<ll, ii>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<ii>;
using vli = vector<li>;
using vpll = vector<pll>;
using vi3 = vector<i3>;
using vlii = vector<lii>;
const int N = 150 + 5;
const ll INF = 1e17 + 7;
const double eps = 1e-9, PI = acos(-1);
int n, m;
char a[N][N];
int l[N], r[N];
void solve(int testCase) {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", a[i] + 1);
l[i] = m + 2;
r[i] = 0;
}
l[n + 1] = m + 2;
r[n + 1] = 0;
int last = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 'W') {
l[i] = min(l[i], j);
r[i] = j;
last = i;
}
}
}
int ans = 0;
int curr = 1;
for (int i = 1; i <= n; i++) {
if (i & 1) {
int nxt = max({curr, r[i], r[i + 1]});
ans += nxt - curr;
curr = nxt;
} else {
int nxt = min({curr, l[i], l[i + 1]});
ans += curr - nxt;
curr = nxt;
}
if (i < n) ans++;
}
printf("%d\n", ans - (n - last));
}
int main() {
int t = 1;
for (int testCase = 1; testCase <= t; testCase++) {
solve(testCase);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool a[10];
bool b[10];
bool c[10];
int main() {
int i, n, temp;
cin >> n;
for (i = 0; i < 6; i++) {
cin >> temp;
a[temp] = true;
}
if (n == 1) {
for (i = 1; i <= 9; i++) {
if (a[i] != true) {
cout << i - 1 << endl;
return 0;
}
}
if (i == 10) cout << 9 << endl;
}
for (i = 0; i < 6; i++) {
cin >> temp;
b[temp] = true;
}
if (n == 2) {
for (i = 1; i < 10; i++) {
if (!(a[i] or b[i])) {
cout << i - 1 << endl;
return 0;
}
}
for (i = 10; i < 100; i++) {
if (!(((a[((i / 10) % 10)] and b[(i % 10)])) ||
(a[((i) % 10)] and b[((i / 10) % 10)]))) {
cout << i - 1 << endl;
return 0;
}
}
cout << 99 << endl;
}
for (i = 0; i < 6; i++) {
cin >> temp;
c[temp] = true;
}
for (i = 1; i < 10; i++) {
if (!(a[i] or b[i] or c[i])) {
cout << i - 1 << endl;
return 0;
}
}
for (i = 10; i < 100; i++) {
if (!(((a[((i / 10) % 10)] and b[(i % 10)])) ||
(a[((i) % 10)] and b[((i / 10) % 10)]) ||
((b[((i / 10) % 10)] and c[(i % 10)])) ||
(b[((i) % 10)] and c[((i / 10) % 10)]) ||
((c[((i / 10) % 10)] and a[(i % 10)])) ||
(c[((i) % 10)] and a[((i / 10) % 10)]))) {
cout << i - 1 << endl;
return 0;
}
}
for (i = 100; i < 1000; i++) {
if (!(((a[((i / 10) % 10)] and b[((i / 10) % 10)]) and c[(i % 10)]) ||
((a[((i / 10) % 10)] and c[((i / 10) % 10)]) and b[(i % 10)]) ||
((b[((i / 10) % 10)] and a[((i / 10) % 10)]) and c[(i % 10)]) ||
((b[((i / 10) % 10)] and c[((i / 10) % 10)]) and a[(i % 10)]) ||
((c[((i / 10) % 10)] and a[((i / 10) % 10)]) and b[(i % 10)]) ||
((c[((i / 10) % 10)] and b[((i / 10) % 10)]) and a[(i % 10)]))) {
cout << i - 1 << endl;
return 0;
}
}
cout << 999 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int N2 = 1e6 + 5;
const int inf = 1e9 + 7;
int d, n, in, m, i, mn, ind, last;
int B[N], first[4 * N2];
long long ans;
pair<int, int> A[N];
int update(int root, int bas, int son, int x, int v) {
if (bas > x or son < x) return first[root];
if (bas == son) return first[root] = v;
return first[root] =
min(update((root + root), bas, ((bas + son) / 2), x, v),
update((root + root + 1), ((bas + son) / 2) + 1, son, x, v));
}
int query(int root, int bas, int son, int x, int y) {
if (bas > y or son < x) return m;
if (x <= bas and son <= y) return first[root];
return min(query((root + root), bas, ((bas + son) / 2), x, y),
query((root + root + 1), ((bas + son) / 2) + 1, son, x, y));
}
int init(int root, int bas, int son) {
if (bas == son) return first[root] = m;
return first[root] = min(init((root + root), bas, ((bas + son) / 2)),
init((root + root + 1), ((bas + son) / 2) + 1, son));
}
int main() {
scanf("%d %d %d", &d, &n, &m);
in = n;
for (i = 1; i <= m; i++) scanf("%d %d", &A[i].first, &A[i].second);
sort(A + 1, A + m + 1);
m++;
init(1, 1, N2);
A[m] = make_pair(d, 0);
for (i = m; i >= 1; i--) {
B[i] = query(1, 1, N2, 1, A[i].second);
update(1, 1, N2, A[i].second, i);
}
last = 0;
for (i = 1; i < m; i++) {
n -= A[i].first - last;
if (n < 0) return cout << -1, 0;
last = A[i].first;
ans += (long long)min(in - n, (max(0, (A[B[i]].first - A[i].first) - n))) *
(long long)A[i].second;
n += min(in - n, (max(0, (A[B[i]].first - A[i].first) - n)));
}
n -= A[i].first - last;
if (n < 0) return cout << -1, 0;
printf("%lld", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int n, m;
int a[300066];
int mn[300066], mx[300066];
int f[300066], sum[300066], all;
vector<int> vec[300066];
void add(int x, int w) {
for (; x <= n; x += ((x) & -(x))) sum[x] += w;
}
int query(int x) {
int ret = 0;
for (; x; x -= ((x) & -(x))) ret += sum[x];
return ret;
}
int pre[300066];
struct Tree {
struct Node {
int ls, rs, w;
} node[300066 << 6];
int tot, rt[300066];
void build() {
for (int i = 1; i <= m; i++) {
upd(rt[i], rt[i - 1], 1, m, i, 1);
if (pre[a[i]]) upd(rt[i], rt[i], 1, m, pre[a[i]], -1);
pre[a[i]] = i;
}
}
void upd(int &p, int q, int l, int r, int aim, int w) {
p = ++tot;
node[p] = node[q];
node[p].w += w;
if (l == r) return;
int mid = (l + r) >> 1;
if (aim <= mid)
upd(node[p].ls, node[q].ls, l, mid, aim, w);
else
upd(node[p].rs, node[q].rs, mid + 1, r, aim, w);
}
int query(int p, int l, int r, int ql, int qr) {
if (!p) return 0;
if (ql <= l && r <= qr) return node[p].w;
int mid = (l + r) >> 1, ret = 0;
if (ql <= mid) ret += query(node[p].ls, l, mid, ql, qr);
if (mid < qr) ret += query(node[p].rs, mid + 1, r, ql, qr);
return ret;
}
int query(int l, int r) { return query(rt[r], 1, m, l, r); }
} tree;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
mn[a[i]] = 1;
vec[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) vec[i].push_back(m + 1);
for (int i = 1; i <= n; i++) {
if (!mn[i]) mn[i] = i;
mx[i] = i;
}
for (int i = 1; i <= m; i++) {
if (query(a[i]) - query(a[i] - 1)) continue;
f[a[i]] = query(n) - query(a[i]);
add(a[i], 1);
}
for (int i = 1; i <= n; i++)
if (query(i) - query(i - 1) == 0) f[i] = query(n) - query(i);
tree.build();
for (int i = 1; i <= n; i++) {
mx[i] += f[i];
for (int j = 0; j < ((int)(vec[i]).size()) - 1; j++) {
if (vec[i][j] + 1 != vec[i][j + 1])
mx[i] = max(mx[i], tree.query(vec[i][j] + 1, vec[i][j + 1] - 1) + 1);
}
}
for (int i = 1; i <= n; i++) printf("%d %d\n", mn[i], mx[i]);
return 0;
}
| 6 |
#include <iostream>
#include <bits/stdc++.h>
#define ll long long
#define $Fact_Length 500001
#define mod 998244353
using namespace std;
ll Power(ll $a,ll $b)
{
ll $result=1; $a%=mod;
while($b) { if($b%2==1) $result*=$a; $a*=$a; $a%=mod; $result%=mod; $b/=2; }
return $result;
}
ll Mod_Inv(ll $a)
{
$a%=mod; $a=Power($a,mod-2); return $a;
}
ll Factorial[$Fact_Length];
ll Make_Factorial()
{
Factorial[0]=1;
for(ll i=1;i<$Fact_Length;i++) { Factorial[i]=i*Factorial[i-1]; Factorial[i]%=mod; } return 0;
}
ll Implement_Make_Factorial=Make_Factorial();
ll nCr(ll $n,ll $r)
{
if($n<$r) return 0;
ll $ans=Factorial[$n]; $ans%=mod;
$ans*=Mod_Inv(Factorial[$r]); $ans%=mod;
$ans*=Mod_Inv(Factorial[$n-$r]); $ans%=mod;
return $ans;
}
int main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
ll n;
cin>>n;
ll y=Mod_Inv(Power(2,n));
ll ans=0;
if(n%2==0)
{
for(ll i=1;i<=n/2;i++)
{
ans+= nCr((n/2)+i-1,2*i-1);
ans%=mod;
}
}
else
{
for(ll i=1;i<=((n+1)/2);i++)
{
ans+= nCr(((n+1)/2)+i-2,2*(i-1));
ans%=mod;
}
}
ans*=y;
ans%=mod;
cout<<ans<<endl;
return(0);
} | 4 |
#include <bits/stdc++.h>
using namespace std;
namespace Base {
const int inf = 0x3f3f3f3f, INF = 0x7fffffff;
const long long infll = 0x3f3f3f3f3f3f3f3fll, INFll = 0x7fffffffffffffffll;
template <typename T>
void read(T &x) {
x = 0;
int fh = 1;
double num = 1.0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') fh = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
if (ch == '.') {
ch = getchar();
while (isdigit(ch)) {
num /= 10;
x = x + num * (ch - '0');
ch = getchar();
}
}
x = x * fh;
}
template <typename T>
void chmax(T &x, T y) {
x = x < y ? y : x;
}
template <typename T>
void chmin(T &x, T y) {
x = x > y ? y : x;
}
} // namespace Base
using namespace Base;
const int N = 200010, P = 998244353;
int n;
long long x[N], y[N], tag[N], s[N], h[N];
int lowbit(int x) { return x & (-x); }
long long query(int x) {
if (x == 0) return 0;
long long num = 0;
while (x != 0) {
num = (num + h[x]) % P;
x = x - lowbit(x);
}
return num;
}
void add(int x, long long now) {
while (x <= n) {
h[x] = (h[x] + now) % P;
x = x + lowbit(x);
}
}
int findpos(long long pos) { return lower_bound(x + 1, x + n + 1, pos) - x; }
int main() {
read(n);
for (int i = 1; i <= n; i++) {
read(x[i]);
read(y[i]);
read(tag[i]);
}
for (int i = 1; i <= n; i++) {
int l = findpos(y[i]), r = i - 1;
if (l <= r) s[i] = (query(r) - query(l - 1) + P) % P;
s[i] = ((s[i] + x[i]) % P - y[i] + P) % P;
add(i, s[i]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans = (ans + x[i] - x[i - 1]) % P;
if (tag[i]) ans = (ans + s[i]) % P;
}
printf("%lld\n", (ans + 1) % P);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int M = 1e5 + 5, INF = 0x3f3f3f3f, mod = 1000007;
int A[M];
int pos[M];
bool mark[M];
int main() {
int n;
scanf("%d", &n);
vector<int> B;
for (int j = 1; j <= n; j++) {
scanf("%d", &A[j]);
B.push_back(A[j]);
}
sort(B.begin(), B.end());
for (int j = 1; j <= n; j++) {
A[j] = lower_bound(B.begin(), B.end(), A[j]) - B.begin() + 1;
pos[A[j]] = j;
}
vector<vector<int> > ans;
for (int j = 1; j <= n; j++) {
if (mark[j]) continue;
vector<int> now;
now.push_back(j);
int t = j;
while (!mark[t] && pos[t] != t) {
mark[t] = 1;
if (!mark[pos[t]]) now.push_back(pos[t]);
t = pos[t];
}
if (now.size()) ans.push_back(now);
}
printf("%d\n", ans.size());
for (auto now : ans) {
printf("%d", now.size());
for (auto x : now) printf(" %d", x);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
using std::pair;
using std::set;
using std::vector;
template <class T>
inline void read(T &x) {
T f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 1) + (x << 3) + (s & 15);
s = getchar();
}
x *= f;
}
template <class T>
inline T fabs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T po(T a) {
return a * a;
}
const long long maxn = 1e6 + 5;
struct Edge {
long long u, v, w;
} e[maxn];
inline bool cmp(Edge a, Edge b) { return a.w > b.w; }
long long fa[maxn], m, n, cnt, fx, fy, ans, siz[maxn], MAX, val[maxn];
inline long long find(long long x) {
return (fa[x] == x) ? x : fa[x] = find(fa[x]);
}
signed main() {
read(n);
read(m);
for (long long i = 1; i <= n; i++) fa[i] = i, siz[i] = 1, read(val[i]);
for (long long i = 1; i <= m; i++)
read(e[i].u), read(e[i].v), e[i].w = min(val[e[i].u], val[e[i].v]);
std::sort(e + 1, e + m + 1, cmp);
for (long long i = 1; i <= m; i++) {
fx = find(e[i].u);
fy = find(e[i].v);
if (fx == fy) continue;
ans += siz[fx] * siz[fy] * e[i].w;
fa[fx] = fy;
siz[fy] += siz[fx];
cnt++;
if (cnt == (n - 1)) break;
}
MAX = ((n * (n - 1)) >> 1);
printf("%.6Lf", ((long double)(ans)) / ((long double)(MAX)));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, t, a[234567], m, q[234567];
long long qq[234567], s;
double c, re[234567], ap[234567], er[234567], me[234567];
int main() {
cin >> n >> t >> c;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s += a[i];
qq[i] = s;
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> q[i];
re[i] = (qq[q[i]] - qq[q[i] - t] + 0.0) / t;
}
for (int j = 1; j <= n; j++) me[j] = (me[j - 1] + ((a[j] + 0.0) / t)) / c;
for (int i = 1; i <= m; i++) er[i] = abs(me[q[i]] - re[i]) / re[i];
for (int i = 1; i <= m; i++)
printf("%.6lf %.6lf %.6lf\n", re[i], me[q[i]], er[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(const T &a) {
return a * a;
}
const long double pi = acos(-1.0);
const int maxn = 5010;
int dp[maxn][maxn], sd[maxn][maxn];
int M = 1488148811, p = 13;
unsigned long long H[maxn], pows[maxn];
int N;
char s[maxn];
void precalc() {
pows[0] = 1;
for (decltype(N) i = 1; i <= N; i++) pows[i] = pows[i - 1] * p;
H[0] = s[0] - '0' + 1;
for (decltype(N - 1) i = 1; i <= N - 1; i++) {
H[i] = H[i - 1] * p + s[i] - '0' + 1;
}
}
inline unsigned long long getH(int i, int j) {
return (H[j] - (i == 0 ? 0 : H[i - 1] * pows[j - i + 1]));
}
bool comp(int i, int j, int len) {
int l = 0, r = len + 1;
while (r > l + 1) {
int m = (l + r) >> 1;
if (getH(i, i + m - 1) == getH(j, j + m - 1))
l = m;
else
r = m;
}
return (l == len ? false : s[i + l] < s[j + l]);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N;
string t;
cin >> t;
for (decltype(N) i = 0; i < N; i++) s[i] = t[i];
precalc();
int M = 1E9 + 7;
for (decltype(N) i = 0; i < N; i++) {
for (decltype(i) l = 1; l <= i; l++) {
if (l != 1 && s[i - l + 1] == '0') continue;
dp[i][l] = (dp[i][l] + sd[i - l][min(i - l + 1, l - 1)]) % M;
if (i - (l << 1) + 1 >= 0 && (l == 1 || s[i - (l << 1) + 1] != '0') &&
comp(i - (l << 1) + 1, i - l + 1, l))
dp[i][l] = (dp[i][l] + dp[i - l][l]) % M;
}
dp[i][i + 1] = 1;
for (decltype(i + 1) l = 1; l <= i + 1; l++)
sd[i][l] = (sd[i][l - 1] + dp[i][l]) % M;
}
cout << sd[N - 1][N] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ans, a[100005], l[100005], r[100005];
int main() {
int T, i, j, k, ca = 0, n, x, y, b;
while (~scanf("%d", &n)) {
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
l[1] = 1;
for (i = 2; i <= n; i++) {
x = i - 1;
while (x > 1 && a[i] > a[x]) x = l[x];
l[i] = x;
}
r[n] = n;
for (i = n - 1; i >= 1; i--) {
x = i + 1;
while (x < n && a[i] > a[x]) x = r[x];
r[i] = x;
}
ans = 0;
for (i = 1; i <= n; i++) {
if (a[l[i]] > a[i]) ans = max(ans, a[i] ^ a[l[i]]);
if (a[r[i]] > a[i]) ans = max(ans, a[i] ^ a[r[i]]);
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 34;
long long n, k, b;
long long sum, cur;
int ans;
int go[N], a[N];
pair<int, int> lst[2000004];
pair<int, int> dfs(int v, int en) {
if (v >= en) return make_pair(0, v);
pair<long long, long long> t;
if (lst[v].first != -1) {
t = dfs(lst[v].second, en);
return lst[v] = make_pair(t.first + lst[v].first, t.second);
}
t = dfs(go[v], en);
return lst[v] = make_pair(t.first + 1, t.second);
}
long long gsum;
int main() {
scanf("%I64d%I64d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
gsum += a[i];
a[n + i] = a[i];
a[n * 2 + i] = a[i];
}
for (int iq = 0; iq < k; iq++) {
scanf("%I64d", &b);
if (b >= gsum) {
printf("1\n");
continue;
}
sum = 0;
cur = 0;
for (int i = 0; i < n * 2; i++) {
while (sum + a[cur] <= b) {
sum += a[cur];
cur++;
}
go[i] = cur;
sum -= a[i];
}
for (int i = 0; i < n * 2; i++) lst[i] = make_pair(-1, -1);
ans = n;
for (int st = 0; st <= go[0]; st++) ans = min(ans, dfs(st, st + n).first);
printf("%d\n", ans);
}
return 0;
}
| 8 |
Subsets and Splits