solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
struct edge {
int v, f, w, id;
};
vector<pair<long long, long long>> path;
struct MinCost {
int n;
vector<vector<edge>> e;
void init(int _n) {
n = _n;
e.resize(n + 1);
}
void add(int x, int y, int c, int w) {
e[x].push_back((edge){y, c, w, (int)e[y].size()});
e[y].push_back((edge){x, 0, -w, (int)e[x].size() - 1});
}
pair<int, int> solve(int S, int T) {
pair<int, int> flow = make_pair(0, 0);
while (true) {
vector<int> f(n + 1), g(n + 1), vis(n + 1), dis(n + 1, inf);
queue<int> q;
q.push(S), f[S] = inf, dis[S] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto &i : e[u]) {
if (i.f && dis[u] + i.w < dis[i.v]) {
dis[i.v] = dis[u] + i.w, f[i.v] = min(f[u], i.f), g[i.v] = i.id;
if (!vis[i.v]) q.push(i.v);
}
}
vis[u] = 0;
}
if (!f[T]) break;
path.emplace_back(f[T], dis[T]);
flow.first += f[T], flow.second += f[T] * dis[T];
for (int i = T; i != S;) {
auto &t = e[i][g[i]];
t.f += f[T], e[t.v][t.id].f -= f[T], i = t.v;
}
}
return flow;
}
};
int n, m;
const int maxN = (int)1e6 + 100;
long long flow[maxN], tot_cost[maxN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
MinCost mc;
mc.init(n + 1);
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
mc.add(u, v, 1, w);
}
mc.solve(1, n);
for (int i = 0; i < path.size(); i++) {
flow[i + 1] = flow[i] + path[i].first;
tot_cost[i + 1] = tot_cost[i] + path[i].first * path[i].second;
}
int q;
cin >> q;
while (q--) {
int T;
cin >> T;
int l = 1;
int r = path.size();
auto compute = [&](int x) -> double {
assert(1 <= x && x <= path.size());
return ((double)T + tot_cost[x]) / flow[x];
};
while (r - l > 5) {
int l1 = (2 * l + r) / 3;
int r1 = (2 * r + l) / 3;
if (compute(l1) < compute(r1))
r = r1;
else
l = l1;
}
double best = 1e9;
for (int i = l; i <= r; i++) best = min(best, compute(i));
cout << fixed << setprecision(10) << best << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
set<int> buy, add, hz;
int n;
int mult(int a, int b) { return (1LL * a * b) % mod; }
int main() {
srand(time(0));
ios_base::sync_with_stdio(false);
int cnt = 1;
cin >> n;
for (int i = 1; i <= n; i++) {
string s;
int x;
cin >> s >> x;
if (s == "ADD") {
if (!buy.empty()) {
if (x <= (*(--buy.end()))) {
buy.insert(x);
continue;
}
}
if (!add.empty()) {
if (x >= (*add.begin())) {
add.insert(x);
continue;
}
}
hz.insert(x);
} else {
if (!buy.empty()) {
int v = (*(--buy.end()));
if (v > x) {
cout << 0;
return 0;
}
}
if (!add.empty()) {
int v = (*(add.begin()));
if (v < x) {
cout << 0;
return 0;
}
}
auto it = hz.lower_bound(x);
if (it != hz.end() && (*it == x)) cnt = mult(cnt, 2);
for (int v : hz) {
if (x > v) buy.insert(v);
if (x < v) add.insert(v);
}
hz.clear();
buy.erase(x);
add.erase(x);
}
}
cnt = mult(cnt, hz.size() + 1);
cout << cnt;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
long long ln, lk, lm;
long long dp[35][1005], tmp[1005];
int cnt = 0;
void init() {
dp[0][0] = 1;
tmp[0] = 1;
for (int i = 1; i <= 30; i++) {
dp[i][0] = 1;
for (int j = 1; j <= 1000; j++) {
for (int k = 0; k < j; k++) {
dp[i][j] += (tmp[k] * tmp[j - k - 1]) % 7340033;
dp[i][j] %= 7340033;
}
}
for (int j = 1; j <= 1000; j++) tmp[j] = 0;
tmp[0] = 1;
for (int j = 1; j <= 1000; j++) {
for (int k = 0; k <= j; k++) {
tmp[j] += (dp[i][k] * dp[i][j - k]) % 7340033;
tmp[j] %= 7340033;
}
}
}
}
int main() {
init();
int q;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &n, &k);
if (k == 0)
puts("1");
else {
int id = 0;
while ((n & 1) && n > 1) {
n >>= 1;
id++;
}
printf("%lld\n", dp[id][k]);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int base = 1000000000;
const int base_digits = 9;
struct bigint {
std::vector<int> z;
int sign;
bigint() : sign(1) {}
bigint(long long v) { *this = v; }
bigint(const std::string &s) { read(s); }
void operator=(const bigint &v) {
sign = v.sign;
z = v.z;
}
void operator=(long long v) {
sign = 1;
if (v < 0) sign = -1, v = -v;
z.clear();
for (; v > 0; v = v / base) z.push_back(v % base);
}
bigint operator+(const bigint &v) const {
if (sign == v.sign) {
bigint res = v;
for (int i = 0, carry = 0; i < (int)max(z.size(), v.z.size()) || carry;
++i) {
if (i == (int)res.z.size()) res.z.push_back(0);
res.z[i] += carry + (i < (int)z.size() ? z[i] : 0);
carry = res.z[i] >= base;
if (carry) res.z[i] -= base;
}
return res;
}
return *this - (-v);
}
bigint operator-(const bigint &v) const {
if (sign == v.sign) {
if (abs() >= v.abs()) {
bigint res = *this;
for (int i = 0, carry = 0; i < (int)v.z.size() || carry; ++i) {
res.z[i] -= carry + (i < (int)v.z.size() ? v.z[i] : 0);
carry = res.z[i] < 0;
if (carry) res.z[i] += base;
}
res.trim();
return res;
}
return -(v - *this);
}
return *this + (-v);
}
void operator*=(int v) {
if (v < 0) sign = -sign, v = -v;
for (int i = 0, carry = 0; i < (int)z.size() || carry; ++i) {
if (i == (int)z.size()) z.push_back(0);
long long cur = z[i] * (long long)v + carry;
carry = (int)(cur / base);
z[i] = (int)(cur % base);
}
trim();
}
bigint operator*(int v) const {
bigint res = *this;
res *= v;
return res;
}
friend std::pair<bigint, bigint> divmod(const bigint &a1, const bigint &b1) {
int norm = base / (b1.z.back() + 1);
bigint a = a1.abs() * norm;
bigint b = b1.abs() * norm;
bigint q, r;
q.z.resize(a.z.size());
for (int i = a.z.size() - 1; i >= 0; i--) {
r *= base;
r += a.z[i];
int s1 = b.z.size() < r.z.size() ? r.z[b.z.size()] : 0;
int s2 = b.z.size() - 1 < r.z.size() ? r.z[b.z.size() - 1] : 0;
int d = ((long long)s1 * base + s2) / b.z.back();
r -= b * d;
while (r < 0) r += b, --d;
q.z[i] = d;
}
q.sign = a1.sign * b1.sign;
r.sign = a1.sign;
q.trim();
r.trim();
return std::make_pair(q, r / norm);
}
friend bigint sqrt(const bigint &a1) {
bigint a = a1;
while (a.z.empty() || a.z.size() % 2 == 1) a.z.push_back(0);
int n = a.z.size();
int firstDigit = (int)sqrt((double)a.z[n - 1] * base + a.z[n - 2]);
int norm = base / (firstDigit + 1);
a *= norm;
a *= norm;
while (a.z.empty() || a.z.size() % 2 == 1) a.z.push_back(0);
bigint r = (long long)a.z[n - 1] * base + a.z[n - 2];
firstDigit = (int)sqrt((double)a.z[n - 1] * base + a.z[n - 2]);
int q = firstDigit;
bigint res;
for (int j = n / 2 - 1; j >= 0; j--) {
for (;; --q) {
bigint r1 =
(r - (res * 2 * base + q) * q) * base * base +
(j > 0 ? (long long)a.z[2 * j - 1] * base + a.z[2 * j - 2] : 0);
if (r1 >= 0) {
r = r1;
break;
}
}
res *= base;
res += q;
if (j > 0) {
int d1 = res.z.size() + 2 < r.z.size() ? r.z[res.z.size() + 2] : 0;
int d2 = res.z.size() + 1 < r.z.size() ? r.z[res.z.size() + 1] : 0;
int d3 = res.z.size() < r.z.size() ? r.z[res.z.size()] : 0;
q = ((long long)d1 * base * base + (long long)d2 * base + d3) /
(firstDigit * 2);
}
}
res.trim();
return res / norm;
}
bigint operator/(const bigint &v) const { return divmod(*this, v).first; }
bigint operator%(const bigint &v) const { return divmod(*this, v).second; }
void operator/=(int v) {
if (v < 0) sign = -sign, v = -v;
for (int i = (int)z.size() - 1, rem = 0; i >= 0; --i) {
long long cur = z[i] + rem * (long long)base;
z[i] = (int)(cur / v);
rem = (int)(cur % v);
}
trim();
}
bigint operator/(int v) const {
bigint res = *this;
res /= v;
return res;
}
int operator%(int v) const {
if (v < 0) v = -v;
int m = 0;
for (int i = z.size() - 1; i >= 0; --i)
m = (z[i] + m * (long long)base) % v;
return m * sign;
}
void operator+=(const bigint &v) { *this = *this + v; }
void operator-=(const bigint &v) { *this = *this - v; }
void operator*=(const bigint &v) { *this = *this * v; }
void operator/=(const bigint &v) { *this = *this / v; }
bool operator<(const bigint &v) const {
if (sign != v.sign) return sign < v.sign;
if (z.size() != v.z.size()) return z.size() * sign < v.z.size() * v.sign;
for (int i = z.size() - 1; i >= 0; i--)
if (z[i] != v.z[i]) return z[i] * sign < v.z[i] * sign;
return false;
}
bool operator>(const bigint &v) const { return v < *this; }
bool operator<=(const bigint &v) const { return !(v < *this); }
bool operator>=(const bigint &v) const { return !(*this < v); }
bool operator==(const bigint &v) const {
return !(*this < v) && !(v < *this);
}
bool operator!=(const bigint &v) const { return *this < v || v < *this; }
void trim() {
while (!z.empty() && z.back() == 0) z.pop_back();
if (z.empty()) sign = 1;
}
bool isZero() const { return z.empty() || (z.size() == 1 && !z[0]); }
bigint operator-() const {
bigint res = *this;
res.sign = -sign;
return res;
}
bigint abs() const {
bigint res = *this;
res.sign *= res.sign;
return res;
}
long long longValue() const {
long long res = 0;
for (int i = z.size() - 1; i >= 0; i--) res = res * base + z[i];
return res * sign;
}
friend bigint gcd(const bigint &a, const bigint &b) {
return b.isZero() ? a : gcd(b, a % b);
}
friend bigint lcm(const bigint &a, const bigint &b) {
return a / gcd(a, b) * b;
}
void read(const std::string &s) {
sign = 1;
z.clear();
int pos = 0;
while (pos < (int)s.size() && (s[pos] == '-' || s[pos] == '+')) {
if (s[pos] == '-') sign = -sign;
++pos;
}
for (int i = s.size() - 1; i >= pos; i -= base_digits) {
int x = 0;
for (int j = max(pos, i - base_digits + 1); j <= i; j++)
x = x * 10 + s[j] - '0';
z.push_back(x);
}
trim();
}
friend std::istream &operator>>(std::istream &stream, bigint &v) {
std::string s;
stream >> s;
v.read(s);
return stream;
}
friend std::ostream &operator<<(std::ostream &stream, const bigint &v) {
if (v.sign == -1) stream << '-';
stream << (v.z.empty() ? 0 : v.z.back());
for (int i = (int)v.z.size() - 2; i >= 0; --i)
stream << std::setw(base_digits) << std::setfill('0') << v.z[i];
return stream;
}
static std::vector<int> convert_base(const std::vector<int> &a,
int old_digits, int new_digits) {
std::vector<long long> p(max(old_digits, new_digits) + 1);
p[0] = 1;
for (int i = 1; i < (int)p.size(); i++) p[i] = p[i - 1] * 10;
std::vector<int> res;
long long cur = 0;
int cur_digits = 0;
for (int i = 0; i < (int)a.size(); i++) {
cur += a[i] * p[cur_digits];
cur_digits += old_digits;
while (cur_digits >= new_digits) {
res.push_back(int(cur % p[new_digits]));
cur /= p[new_digits];
cur_digits -= new_digits;
}
}
res.push_back((int)cur);
while (!res.empty() && res.back() == 0) res.pop_back();
return res;
}
static std::vector<long long> karatsubaMultiply(
const std::vector<long long> &a, const std::vector<long long> &b) {
int n = a.size();
std::vector<long long> res(n + n);
if (n <= 32) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) res[i + j] += a[i] * b[j];
return res;
}
int k = n >> 1;
std::vector<long long> a1(a.begin(), a.begin() + k);
std::vector<long long> a2(a.begin() + k, a.end());
std::vector<long long> b1(b.begin(), b.begin() + k);
std::vector<long long> b2(b.begin() + k, b.end());
std::vector<long long> a1b1 = karatsubaMultiply(a1, b1);
std::vector<long long> a2b2 = karatsubaMultiply(a2, b2);
for (int i = 0; i < k; i++) a2[i] += a1[i];
for (int i = 0; i < k; i++) b2[i] += b1[i];
std::vector<long long> r = karatsubaMultiply(a2, b2);
for (int i = 0; i < (int)a1b1.size(); i++) r[i] -= a1b1[i];
for (int i = 0; i < (int)a2b2.size(); i++) r[i] -= a2b2[i];
for (int i = 0; i < (int)r.size(); i++) res[i + k] += r[i];
for (int i = 0; i < (int)a1b1.size(); i++) res[i] += a1b1[i];
for (int i = 0; i < (int)a2b2.size(); i++) res[i + n] += a2b2[i];
return res;
}
bigint operator*(const bigint &v) const {
std::vector<int> a6 = convert_base(this->z, base_digits, 6);
std::vector<int> b6 = convert_base(v.z, base_digits, 6);
std::vector<long long> a(a6.begin(), a6.end());
std::vector<long long> b(b6.begin(), b6.end());
while (a.size() < b.size()) a.push_back(0);
while (b.size() < a.size()) b.push_back(0);
while (a.size() & (a.size() - 1)) a.push_back(0), b.push_back(0);
std::vector<long long> c = karatsubaMultiply(a, b);
bigint res;
res.sign = sign * v.sign;
for (int i = 0, carry = 0; i < (int)c.size(); i++) {
long long cur = c[i] + carry;
res.z.push_back((int)(cur % 1000000));
carry = (int)(cur / 1000000);
}
res.z = convert_base(res.z, 6, base_digits);
res.trim();
return res;
}
};
const int MAXN = 600010;
unsigned long long cur;
bigint ans;
int n;
map<int, int> mp;
class sgt {
public:
int dat[MAXN << 2];
void pushup(int p) { dat[p] = min(dat[(p << 1)], dat[((p << 1) | 1)]); }
void modify(int p, int l, int r, int pos, int v) {
if (l == r) {
dat[p] = v;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
modify((p << 1), l, mid, pos, v);
else
modify(((p << 1) | 1), mid + 1, r, pos, v);
pushup(p);
}
int query(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return dat[p];
int mid = (l + r) >> 1, ret = 1 << 30;
if (ql <= mid) ret = min(ret, query((p << 1), l, mid, ql, qr));
if (qr > mid) ret = min(ret, query(((p << 1) | 1), mid + 1, r, ql, qr));
return ret;
}
} T;
int str[MAXN], fail[MAXN], link[MAXN];
const int MASK = (1 << 30) - 1;
string S;
unsigned long long maskans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
char c = getchar();
int v, w;
while (!(c >= 'a' && c <= 'z')) c = getchar();
v = c - 'a';
scanf("%d", &w);
v = (ans + v) % 26;
w = w ^ (maskans & MASK);
str[i] = v;
T.modify(1, 1, n, i, w);
int j = fail[i - 1];
while (j) {
if (str[i] == str[j + 1]) break;
j = fail[j];
}
if (str[i] == str[j + 1]) j++;
if (i == 1)
fail[i] = 0;
else
fail[i] = j;
if (str[i] == str[fail[i - 1] + 1])
link[i - 1] = link[fail[i - 1]];
else
link[i - 1] = fail[i - 1];
int p = link[i - 1];
while (p) {
if (str[p + 1] != str[i]) {
int vl = T.query(1, 1, n, i - p, i - 1);
mp[vl]--;
cur -= vl;
p = fail[p];
} else
p = link[p];
}
if (str[1] == str[i]) {
cur += w;
mp[w]++;
}
int cnt = 0;
while (!mp.empty()) {
auto it = (--mp.end());
if (it->first <= w) break;
cur -= (unsigned long long)(it->first) * (unsigned long long)it->second;
cnt += it->second;
mp.erase(it);
}
cur += (unsigned long long)w * (unsigned long long)cnt;
mp[w] += cnt;
ans += cur;
maskans += cur;
cout << ans << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 2 * acos(0.0);
const int stdLength = 25;
const long long max_number = 1048575;
void print(vector<bool> &a) {
for (bool i : a) {
cout << i << " ";
}
cout << "\n";
}
void print(vector<int> &a) {
for (int i : a) {
cout << i << " ";
}
cout << "\n";
}
void print(vector<char> &a) {
for (char i : a) {
cout << i << " ";
}
cout << "\n";
}
void print(vector<long long> &a) {
for (long long i : a) {
cout << i << " ";
}
cout << "\n";
}
void print(vector<vector<int>> &a) {
for (vector<int> i : a) {
print(i);
}
cout << "\n";
}
void print(vector<vector<long long>> &a) {
for (vector<long long> i : a) {
print(i);
}
cout << "\n";
}
void print(vector<double> &a) {
for (double i : a) {
cout << i << " ";
}
cout << "\n";
}
void print(vector<long double> &a) {
for (long double i : a) {
cout << i << " ";
}
cout << "\n";
}
void print(vector<pair<long long, long long>> &a) {
for (auto i : a) {
cout << "(" << i.first << ", " << i.second << ") ";
}
cout << "\n";
}
void print(vector<pair<int, int>> &a) {
for (auto i : a) {
cout << "(" << i.first << ", " << i.second << ") ";
}
cout << "\n";
}
void print(pair<int, int> &p) {
cout << "(" << p.first << ", " << p.second << ") ";
}
void print(deque<pair<long long, long long>> &a) {
for (pair<long long, long long> i : a) {
cout << i.first << " " << i.second << "\n";
}
cout << "\n";
}
long long dist_sq(pair<long long, long long> a, pair<long long, long long> b) {
return ((a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second));
}
long long po(long long a, long long b) {
if (b <= 0)
return 1;
else if (b == 1)
return a;
long long vl = po((a * a), b / 2);
if (b % 2 == 0)
return vl;
else
return (vl)*a;
}
long long pomod(long long a, long long b) {
a = a % 1000000007LL;
if (b <= 0)
return 1 % 1000000007LL;
else if (b == 1)
return a % 1000000007LL;
long long vl = pomod((a * a) % 1000000007LL, b / 2);
vl = vl % 1000000007LL;
if (b % 2 == 0)
return vl;
else
return ((vl)*a) % 1000000007LL;
}
long long pomod(long long a, long long b, long long mo) {
a = a % mo;
if (b <= 0)
return 1 % mo;
else if (b == 1)
return a % mo;
long long vl = pomod((a * a) % mo, b / 2);
vl = vl % mo;
if (b % 2 == 0)
return vl;
else
return ((vl)*a) % mo;
}
long long factmod(long long n, long long mo) {
long long val = n;
long long ans = 1;
while (val >= 1) {
ans = (ans * val) % mo;
val--;
}
return ans;
}
long long inv(long long a, long long mo) { return pomod(a, mo - 2, mo); }
long long combinationMod(long long n, long long i) {
long long ans = 1;
ans = (ans * factmod(n, 1000000007LL)) % 1000000007LL;
long long invVal =
(inv(factmod(i, 1000000007LL), 1000000007LL) % 1000000007LL *
inv(factmod(n - i, 1000000007LL), 1000000007LL) % 1000000007LL) %
1000000007LL;
ans = (ans * invVal) % 1000000007LL;
return ans;
}
long long greatestCommonDivisor(long long a, long long b) {
if (b > a) {
return greatestCommonDivisor(b, a);
}
if (b == 0) {
return a;
}
if (a % b == 0) {
return b;
} else {
return greatestCommonDivisor(b, a % b);
}
}
long long greatestCommonDivisor(const vector<long long> &numList, int st,
int en) {
assert(st >= 0 and st < (int)numList.size());
assert(en >= 0 and en < (int)numList.size());
if (st > en) {
return 0;
} else if (st == en) {
return numList[st];
} else if (en == st + 1) {
return greatestCommonDivisor(numList[st], numList[st + 1]);
} else {
return greatestCommonDivisor(numList[st],
greatestCommonDivisor(numList, st + 1, en));
}
}
long long greatestCommonDivisor(const vector<long long> &numList) {
if (numList.size() == 0) {
return 0;
}
int st = 0;
int en = numList.size();
en--;
return greatestCommonDivisor(numList, st, en);
}
vector<vector<long long>> preComputeCombinationMod(int n) {
vector<vector<long long>> comb(n + 1, vector<long long>(n + 1, 0));
comb[0][0] = 1;
for (long long i = (1); i <= (n); i++) {
comb[i][0] = 1;
comb[0][i] = 0;
}
for (long long i = (1); i <= (n); i++) {
for (long long j = (1); j <= (i); j++) {
comb[i][j] =
(comb[i - 1][j - 1] % 1000000007LL + comb[i - 1][j] % 1000000007LL) %
1000000007LL;
}
}
return comb;
}
long long floorlog2(long long n) {
long long h = 0;
long long p = 1;
while (p <= n) {
h++;
p *= 2;
}
return h - 1;
}
long long floorlog2(long long n, long long b) {
long long h = 0;
long long p = 1;
while (p <= n) {
h++;
p *= b;
}
return h - 1;
}
class Trie {
private:
vector<Trie *> children;
bool this_inserted = false;
public:
Trie() {
children.resize(26, NULL);
this_inserted = false;
}
void insert(string word) {
Trie *cur = this;
for (char c : word) {
int ind = c - 'a';
if (cur->children[ind] == NULL) {
cur->children[ind] = new Trie();
}
cur = cur->children[ind];
}
cur->this_inserted = true;
}
bool search(string word) {
Trie *cur = this;
for (char c : word) {
int ind = c - 'a';
if (cur->children[ind] == NULL) {
return false;
}
cur = cur->children[ind];
}
return cur->this_inserted;
}
bool startsWith(string prefix) {
string word = prefix;
Trie *cur = this;
for (char c : word) {
int ind = c - 'a';
if (cur->children[ind] == NULL) {
return false;
}
cur = cur->children[ind];
}
return true;
}
};
class FenwickTree {
public:
vector<long long> BIT;
FenwickTree(int n = 100000) { BIT.resize(n + 1, 0); }
FenwickTree(vector<long long> a) {
int n = a.size();
BIT.resize(n + 1, 0);
for (long long i = (0); i <= (n - 1); i++) {
update(i + 1, a[i]);
}
}
FenwickTree(vector<int> a) {
vector<long long> b(a.begin(), a.end());
int n = b.size();
BIT.resize(n + 1, 0);
for (long long i = (0); i <= (n - 1); i++) {
update(i + 1, b[i]);
}
}
void update(int ind, long long val) {
assert(0 <= ind and ind < BIT.size());
int first = ind;
int sz = BIT.size();
while (first < sz) {
BIT[first] += val;
first += (first & -first);
}
}
void set(int ind, long long val) {
assert(0 <= ind and ind < BIT.size());
long long currentVal = query(ind, ind);
update(ind, val - currentVal);
}
long long query(int l, int r) {
assert(0 <= l and r < BIT.size());
if (r < l) {
return 0;
} else
return prefQuery(r) - prefQuery(l - 1);
}
long long prefQuery(int ind) {
assert(0 <= ind and ind < BIT.size());
int first = ind;
long long sum = 0;
while (first > 0) {
sum += BIT[first];
first -= (first & -first);
}
return sum;
}
};
class FenwickTreeRangeUpdate {
public:
FenwickTree bitTree;
FenwickTreeRangeUpdate(int n) { bitTree = FenwickTree(n + 1); }
void updateRange(pair<int, int> indexRange, long long val) {
bitTree.update(indexRange.first, val);
bitTree.update(indexRange.second + 1, -val);
}
long long query(int ind) { return bitTree.prefQuery(ind); }
};
struct P {
int data, version;
P(int d = 0, int ver = 0) : data(d), version(ver) {}
inline friend bool operator<(const P &a, const P &b) {
return a.version < b.version;
}
};
class PersistentFenwickTree {
public:
vector<vector<P>> BIT;
int currentVersion;
PersistentFenwickTree(int n = 100000) {
BIT.resize(n + 1, {P()});
currentVersion = 0;
}
void update(int ind, long long val) {
assert(0 <= ind and ind < BIT.size());
int first = ind;
int sz = BIT.size();
currentVersion += 1;
while (first < sz) {
if (BIT[first].empty()) {
throw logic_error("empty array spot");
}
auto newVal = P(BIT[first].back().data + val, currentVersion);
BIT[first].push_back(newVal);
first += (first & -first);
}
}
long long prefQuery(int ind, int version) {
assert(0 <= ind and ind < BIT.size());
int first = ind;
long long sum = 0;
while (first > 0) {
if (BIT[first].empty()) {
throw logic_error("empty array spot");
}
auto node = *(
upper_bound(BIT[first].begin(), BIT[first].end(), P(0, version)) - 1);
sum += node.data;
first -= (first & -first);
}
return sum;
}
};
class PersistentFenwickTreeRangeUpdate {
public:
PersistentFenwickTree bitTree;
PersistentFenwickTreeRangeUpdate(int n) {
bitTree = PersistentFenwickTree(n + 1);
}
void updateRange(pair<int, int> indexRange, long long val) {
bitTree.update(indexRange.first, val);
bitTree.update(indexRange.second + 1, -val);
}
long long query(int ind, int version) {
return bitTree.prefQuery(ind, version);
}
};
vector<long long> getPrimes(long long highestNum) {
vector<bool> isPrime(highestNum + 5, true);
vector<long long> primes;
for (long long i = (2); i <= (highestNum); i++) {
if (isPrime[i]) {
primes.push_back(i);
long long j = i;
while (j * i <= highestNum) {
isPrime[j * i] = false;
j++;
}
}
}
return primes;
}
long long getMultiplicity(long long num, long long prime) {
long long mult = 0;
while (num % prime == 0) {
mult += 1;
num /= prime;
}
return mult;
}
vector<long long> getPrimeFactorization(long long num,
vector<long long> &primes) {
int sz = primes.size();
vector<long long> multcities(sz, 0);
for (long long i = (0); i <= (sz - 1); i++) {
long long prime = primes[i];
if (prime > num)
return multcities;
else {
multcities[i] = getMultiplicity(num, prime);
long long di = po(prime, multcities[i]);
num = num / di;
}
}
return multcities;
}
map<long long, long long> getMapPrimeFactorization(long long num,
vector<long long> &primes) {
int sz = primes.size();
map<long long, long long> primeFac;
for (long long i = (0); i <= (sz - 1); i++) {
long long prime = primes[i];
if (prime > num)
return primeFac;
else {
primeFac[prime] = getMultiplicity(num, prime);
long long di = po(prime, primeFac[prime]);
num = num / di;
}
}
return primeFac;
}
vector<pair<long long, long long>> getListPrimeFactorization(
long long num, vector<long long> &primes) {
int sz = primes.size();
vector<pair<long long, long long>> primeFac;
for (long long i = (0); i <= (sz - 1); i++) {
long long prime = primes[i];
if (prime > num)
return primeFac;
else {
long long mult = getMultiplicity(num, prime);
long long di = po(prime, mult);
num = num / di;
if (mult > 0) {
primeFac.push_back(make_pair(prime, mult));
}
}
}
return primeFac;
}
vector<int> compute_z(string second) {
int n = second.length();
vector<int> z(n, 0);
int l = 0, r = 0;
z[0] = n;
for (long long i = (1); i <= (n - 1); i++) {
if (r < i) {
l = r = i;
int j = 0;
if (second[0] != second[i]) {
continue;
}
while (j < n and second[j] == second[i + j]) {
j++;
}
r = i + j - 1;
z[i] = r - i + 1;
} else {
int beta = r - i + 1;
int k = i - l;
if (z[k] < beta) {
z[i] = z[k];
} else {
int j = 0;
l = i;
while (r < n and second[r] == second[r - l]) {
r += 1;
}
r -= 1;
z[i] = r - i + 1;
}
}
}
return z;
}
vector<int> getOccurences(string second, string t) {
string comb = t + "$" + second;
auto z_vals = compute_z(comb);
int n = second.size();
int t_sz = t.size();
vector<int> occ;
for (long long i = (0); i <= (n - 1); i++) {
if (z_vals[t_sz + 1 + i] == t_sz) {
occ.push_back(i);
}
}
return occ;
}
class DSU {
private:
vector<int> parent;
vector<int> size;
public:
DSU(int n) {
parent.resize(n + 5, 0);
size.resize(n + 5, 0);
for (long long i = (1); i <= (n); i++) {
parent[i] = i;
size[i] = 1;
}
}
vector<int> getParents() { return parent; }
vector<int> getSizes() { return size; }
int getRoot(int node) {
int par = parent[node];
if (parent[par] == par) {
return par;
}
int root = getRoot(par);
parent[node] = root;
return root;
}
bool checkSame(int a, int b) { return getRoot(a) == getRoot(b); }
void connectNodes(int a, int b) {
int root1 = getRoot(a);
int root2 = getRoot(b);
if (size[root1] < size[root2]) {
swap(root1, root2);
}
parent[root2] = root1;
size[root1] += size[root2];
}
};
class SegmentTreeNode {
private:
long long total;
long long pendingUpdate;
public:
int start, end;
SegmentTreeNode() : total(0), start(-1), end(-1), pendingUpdate(0) {}
void assignLeaf(long long value, int start, int end) {
total = value;
this->start = start;
this->end = end;
}
void merge(SegmentTreeNode &left, SegmentTreeNode &right) {
this->start = left.start;
this->end = right.end;
long long leftTotal = left.getValue();
long long rightTotal = right.getValue();
if (left.ifPendingUpdate()) {
leftTotal += left.getSegmentSize() * left.getPendingUpdate();
}
if (right.ifPendingUpdate()) {
rightTotal += right.getSegmentSize() * right.getPendingUpdate();
}
this->total = leftTotal + rightTotal;
}
long long getValue() { return total; }
long long getPendingUpdate() { return pendingUpdate; }
bool ifPendingUpdate() { return pendingUpdate != 0; }
void applyPendingUpdate() {
this->total += (this->pendingUpdate) * (this->getSegmentSize());
this->pendingUpdate = 0;
}
void addUpdate(long long val) { this->pendingUpdate += val; }
int getSegmentSize() { return (end - start + 1); }
};
class SegmentTree {
public:
int N;
SegmentTree(vector<long long> &arr) {
this->N = arr.size();
this->treeSize = getSegmentTreeSize(this->N);
nodes.resize(this->treeSize);
this->buildTree(arr, 1, 0, N - 1);
}
void updateRange(int startPos, int endPos, long long val) {
updateRange(1, startPos, endPos, val);
}
long long getValue(int startPos, int endPos) {
auto res = getValue(1, startPos, endPos);
return res.getValue();
}
private:
vector<SegmentTreeNode> nodes;
int treeSize;
void buildTree(vector<long long> &arr, int stIndex, int left, int right) {
if (left == right) {
this->nodes[stIndex].assignLeaf(arr[left], left, right);
return;
}
int mid = (left + right) / 2;
int leftIndex = 2 * stIndex, rightIndex = leftIndex + 1;
buildTree(arr, leftIndex, left, mid);
buildTree(arr, rightIndex, mid + 1, right);
nodes[stIndex].merge(nodes[leftIndex], nodes[rightIndex]);
}
void updateRange(int stIndex, int startPos, int endPos, long long val) {
if (startPos == nodes[stIndex].start and endPos == nodes[stIndex].end) {
nodes[stIndex].addUpdate(val);
return;
}
int mid = (nodes[stIndex].start + nodes[stIndex].end) / 2;
int leftChildIndex = 2 * stIndex, rightChildIndex = leftChildIndex + 1;
if (endPos <= mid) {
updateRange(leftChildIndex, startPos, endPos, val);
} else if (startPos > mid) {
updateRange(rightChildIndex, startPos, endPos, val);
} else {
updateRange(leftChildIndex, startPos, mid, val);
updateRange(rightChildIndex, mid + 1, endPos, val);
}
nodes[stIndex].merge(nodes[leftChildIndex], nodes[rightChildIndex]);
}
SegmentTreeNode getValue(int stIndex, int startPos, int endPos) {
if (startPos == nodes[stIndex].start and endPos == nodes[stIndex].end) {
auto result = nodes[stIndex];
if (result.ifPendingUpdate()) result.applyPendingUpdate();
return result;
}
int mid = (nodes[stIndex].start + nodes[stIndex].end) / 2;
int leftChildIndex = 2 * stIndex, rightChildIndex = leftChildIndex + 1;
SegmentTreeNode result;
if (endPos <= mid) {
result = getValue(leftChildIndex, startPos, endPos);
} else if (startPos > mid) {
result = getValue(rightChildIndex, startPos, endPos);
} else {
auto leftResult = getValue(leftChildIndex, startPos, mid);
auto rightResult = getValue(rightChildIndex, mid + 1, endPos);
result.merge(leftResult, rightResult);
}
if (nodes[stIndex].ifPendingUpdate()) {
result.addUpdate(nodes[stIndex].getPendingUpdate());
result.applyPendingUpdate();
}
return result;
}
int getSegmentTreeSize(int N) {
int first = 1;
while (first < N) {
first = first * 2;
}
return first * 2;
}
};
vector<long long> totalBsts(50, 0);
vector<long long> totalBstSumPrefix(50, 0);
vector<vector<long long>> dp(40, vector<long long>(40, -1));
vector<vector<pair<unsigned long long, unsigned long long>>> dp_pair(
40,
vector<pair<unsigned long long, unsigned long long>>(40, make_pair(0, 0)));
void preComputeTotals(int n = 40) {
totalBsts[0] = totalBstSumPrefix[0] = 1;
for (long long j = (1); j <= (n); j++) {
for (long long k = (0); k <= (j - 1); k++) {
totalBsts[j] += totalBsts[k] * totalBsts[j - 1 - k];
}
}
}
long long computeAns(int n, int h) {
if (h <= 0) return totalBsts[n];
if (n == 0) return (h == 0) ? 1 : 0;
if (dp[n][h] >= 0) return dp[n][h];
long long finalAns = 0;
for (long long j = (1); j <= (n); j++) {
long long leftAns = computeAns(j - 1, h - 1);
long long rightAns = computeAns(n - j, h - 1);
long long leftAnsInverse = totalBsts[j - 1] - leftAns;
long long rightAnsInverse = totalBsts[n - j] - rightAns;
long long thisAns = (leftAns * rightAns) + (leftAnsInverse * rightAns) +
(leftAns * rightAnsInverse);
finalAns = finalAns + thisAns;
}
dp[n][h] = finalAns;
return dp[n][h];
}
int main(void) {
ios_base::sync_with_stdio(false);
int n, h;
cin >> n >> h;
preComputeTotals(35);
cout << computeAns(n, h);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int absolute(int a, int b) { return max(a, b) - min(a, b); }
class Union_Find {
vector<long long> rank;
vector<long long> parent;
long long size;
public:
int find_set(long long i) {
return (parent[i] == i) ? i : parent[i] = find_set(parent[i]);
}
bool is_same(long long a, long long b) { return find_set(a) == find_set(b); }
void join(long long a, long long b) {
if (is_same(a, b)) return;
a = find_set(a);
b = find_set(b);
if (rank[a] > rank[b])
parent[b] = a;
else if (rank[b] > rank[a])
parent[a] = b;
else {
parent[a] = b;
rank[b]++;
}
}
void clear(long long n) {
size = n;
rank.resize(size, 0);
parent.resize(size, 0);
for (int i = 0; i < size; i++) parent[i] = i;
}
Union_Find(long long n) {
size = n;
rank.resize(size, 0);
parent.resize(size, 0);
for (int i = 0; i < size; i++) parent[i] = i;
}
private:
};
const int MAX = 10e5 + 3;
const long long INF = 10e9 + 3;
const long long MOD = 1000000007;
const double EPS = 10e-10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n, q;
n = int((s).size());
cin >> q;
set<int> change;
for (int i = 0; i < q; i++) {
int a;
cin >> a;
a--;
if (change.find(a) != change.end())
change.erase(a);
else
change.insert(a);
}
int f = 0;
vector<int> ans(n, 0);
for (int i = 0; i < (n / 2); i++) {
if (change.find(i) != change.end()) f ^= 1;
if (f == 1) ans[i] = 1;
}
for (int i = 0; i < (n / 2); i++) {
if (ans[i] == 1) swap(s[i], s[n - i - 1]);
}
cout << s << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
int main() {
int n, mv, mi, least = 1e9, leasti = -1;
scanf("%d", &n);
for (int i = 1; i <= 9; i++) {
scanf("%d", &a[i]);
if (least >= a[i]) least = a[i];
}
int average = n / least;
if (n >= least) {
for (int i = 9; i > 0; i--)
while (n >= least && (n - a[i]) / least == average - 1 && n >= a[i]) {
printf("%d", i);
n -= a[i];
average = n / least;
}
} else
printf("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define forn(i,s,t) for(register int i=(s);i<=(t);++i)
using namespace std;
const int N = 5e2 + 10;
int t, n, m; char mp[N][N];
int main() {
scanf("%d", &t);
while(t--) {
scanf("%d%d", &n, &m);
forn(i,0,n + 1) forn(j,0,m + 1) mp[i][j] = 0;
forn(i,1,n) scanf("%s", mp[i] + 1);
int lst = 0;
for(register int i=1;i <= n;i+=3) {
forn(j,1,m) mp[i][j] = 'X'; lst = i;
}
for(register int i=1;i <= n-2;i+=3) {
int tmp = 0;
forn(j,1,m) {
int k1 = (j == 1 || (mp[i + 1][j - 1] == '.' && mp[i + 2][j - 1] == '.'));
int k2 = (j == m || (mp[i + 1][j + 1] == '.' && mp[i + 2][j + 1] == '.'));
if(k1 && k2) {
mp[i + 1][j] = mp[i + 2][j] = 'X'; break ;
}
}
}
if(n % 3 == 0) {
forn(i,1,m) if(mp[lst + 1][i] == 'X' || mp[lst + 2][i] == 'X')
mp[lst + 1][i] = mp[lst + 2][i] = 'X';
}
forn(i,1,n) {
forn(j,1,m) printf("%c", mp[i][j]); putchar('\n');
}
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, p, w, d;
long long exgcd(long long a, long long b, long long &x1, long long &y1) {
if (!b) {
x1 = 1, y1 = 0;
return a;
}
long long x2, y2;
long long d = exgcd(b, a % b, x2, y2);
x1 = y2, y1 = x2 - (a / b) * y2;
return d;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int i, j, flag = 0;
cin >> n >> p >> w >> d;
if (w > d) {
flag = 1;
swap(w, d);
}
long long x, y;
long long g = exgcd(w, d, x, y);
if (p % g != 0)
cout << -1 << endl;
else {
long long s = d / g, t = w / g;
x = (s + (p / g) % s * (x % s) % s) % s;
y = (p - x * w) / d;
if (x >= 0 && y >= 0 && x + y <= n) {
if (flag)
cout << y << ' ' << x << ' ' << n - x - y << endl;
else
cout << x << ' ' << y << ' ' << n - x - y << endl;
} else
cout << -1 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, t, k, it, res, f[60050];
vector<int> v[30050];
struct sb {
int x, y, z;
bool operator<(const sb a) const { return z < a.z; }
} s[105];
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d%d", &j, &k);
if (k >= 0) {
v[j].push_back(k);
} else {
s[++it].x = j;
s[it].y = -k;
s[it].z = j + k;
}
}
for (i = 1; i <= 30000; i++) {
if (m < i) {
break;
}
for (auto j : v[i]) {
res++;
m += j;
}
}
n = it;
sort(s + 1, s + n + 1);
for (i = 1; i <= n; i++) {
k = s[i].y;
for (j = m; j >= max(k, s[i].x); j--) {
f[j] = max(f[j], f[j - k] + 1);
}
}
printf("%d", f[m] + res);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1);
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
const int MAX = 2e5 + 10;
const long long mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
char c[3] = {'R', 'G', 'B'};
int main() {
int t;
cin >> t;
while (t--) {
int dif[3] = {0};
int n, k;
cin >> n >> k;
string s;
cin >> s;
for (int i = (0); i < (3); ++i) {
for (int j = (0); j < (k); ++j) {
if (s[j] != c[(j + i) % 3]) dif[i]++;
}
}
int ans = 0;
ans = min(dif[0], min(dif[1], dif[2]));
for (int i = 1; i + k - 1 < n; i++) {
int a0 = dif[0], a1 = dif[1], a2 = dif[2];
dif[0] = a2 - (s[i - 1] == 'B' ? 0 : 1) +
(s[i + k - 1] == c[(k - 1) % 3] ? 0 : 1);
dif[1] =
a0 - (s[i - 1] == 'R' ? 0 : 1) + ((s[i + k - 1] == c[k % 3]) ? 0 : 1);
dif[2] = a1 - (s[i - 1] == 'G' ? 0 : 1) +
((s[i + k - 1] == c[(k + 1) % 3]) ? 0 : 1);
ans = min(ans, min(dif[0], min(dif[1], dif[2])));
}
cout << ans << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<string, string> m;
int main() {
long long n, m = 1000000001, i, x, y(0);
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
y = y + x;
if (x % 2 == 1 && m > x) m = x;
}
if (y % 2 == 1) y = y - m;
cout << y;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 3020;
int t, n, m, bro[maxn], son[maxn], f[maxn][maxn], x[maxn], y[maxn], d;
long long ans, t1, t2;
long long qui(long long a, long long b) {
long long s = 1;
while (b) {
if (b & 1LL) s = s * a % mod;
a = a * a % mod;
b >>= 1LL;
}
return s;
}
void dfs(int x) {
for (register int i = 1; i <= m; ++i) f[x][i] = 1;
for (register int i = son[x]; i; i = bro[i]) {
dfs(i);
int s = 0;
for (register int j = 1; j <= m; ++j) {
s = (s + f[i][j]) % mod;
f[x][j] = 1LL * f[x][j] * s % mod;
}
}
}
int main() {
scanf("%d%d", &n, &d);
m = n + 4;
for (register int i = 2; i <= n; ++i) {
scanf("%d", &t);
bro[i] = son[t], son[t] = i;
}
dfs(1);
for (register int i = 1; i <= m; ++i) f[1][i] = (f[1][i] + f[1][i - 1]) % mod;
for (register int i = 1; i <= m; ++i) x[i] = i, y[i] = f[1][i];
for (register int i = 1; i <= m; ++i) {
t1 = y[i], t2 = 1;
for (register int j = 1; j <= m; ++j) {
if (i == j) continue;
t1 = t1 * (d - x[j] + mod) % mod;
t2 = t2 * (x[i] - x[j] + mod) % mod;
}
t2 = (t2 % mod + mod) % mod;
t1 = t1 * qui(t2, mod - 2) % mod;
t1 = (t1 % mod + mod) % mod;
ans = (ans + t1) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int k;
cin >> k;
long long int sum = k + 2000;
vector<long long int> v;
v.push_back(-1);
for (int i = 1; i < 2000; i++) {
if (sum == 0)
v.push_back(0);
else {
long long int x = min(sum, 1000000 * 1ll);
sum -= x;
v.push_back(x);
}
}
cout << 2000 << endl;
for (int i = 0; i < 2000; i++) cout << v[i] << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005, maxk = 105, maxe = 200005;
int n, m, K, S, a[maxn], f[maxn][maxk], INF = 1e9;
int fir[maxn], nxt[maxe], son[maxe], tot;
int q[maxn];
void add(int x, int y) {
son[++tot] = y;
nxt[tot] = fir[x];
fir[x] = tot;
}
void Solve(int p) {
for (int i = 1; i <= n; i++) f[i][p] = INF;
q[0] = 0;
for (int i = 1; i <= n; i++)
if (a[i] == p) q[++q[0]] = i, f[i][p] = 0;
for (int i = 1; i <= q[0]; i++) {
int x = q[i];
for (int j = fir[x]; j; j = nxt[j])
if (f[son[j]][p] == INF) f[son[j]][p] = f[x][p] + 1, q[++q[0]] = son[j];
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &K, &S);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
for (int i = 1; i <= K; i++) Solve(i);
for (int i = 1; i <= n; i++) {
sort(f[i] + 1, f[i] + 1 + K);
long long ans = 0;
for (int j = 1; j <= S; j++) ans += f[i][j];
printf("%lld ", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
for (int i = 1; i <= a; ++i) {
if (2 * i <= b and 4 * i <= c) ans = i + 2 * i + 4 * i;
}
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const ll INF = 1e18;
const ld PI = acos((ld)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U>
T fstTrue(T lo, T hi, U first) {
hi++;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo) / 2;
first(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U first) {
lo--;
assert(lo <= hi);
while (lo < hi) {
T mid = lo + (hi - lo + 1) / 2;
first(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T>
void remDup(vector<T>& v) {
sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), end(v));
}
template <class T, class U>
void erase(T& t, const U& u) {
auto it = t.find(u);
assert(it != end(t));
t.erase(u);
}
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(AR<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(db& d) {
str t;
re(t);
d = stod(t);
}
void re(ld& d) {
str t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(AR<T, SZ>& x) {
for (auto& a : x) re(a);
}
str to_string(char c) { return str(1, c); }
str to_string(const char* second) { return (str)second; }
str to_string(str second) { return second; }
str to_string(bool b) { return to_string((int)b); }
template <class T>
str to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
str to_string(vector<bool> v) {
str res = "{";
for (int i = (0); i < ((int)(v).size()); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
str to_string(bitset<SZ> b) {
str res = "";
for (int i = (0); i < (SZ); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
str to_string(pair<T, U> p);
template <class T>
str to_string(T v) {
bool fst = 1;
str res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
str to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
void setIn(str second) { freopen(second.c_str(), "r", stdin); }
void setOut(str second) { freopen(second.c_str(), "w", stdout); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIO(str second = "") {
unsyncIO();
if ((int)(second).size()) {
setIn(second + ".in"), setOut(second + ".out");
}
}
struct Dinic {
using F = ll;
struct Edge {
int to, rev;
F flo, cap;
};
int N;
V<V<Edge>> adj;
void init(int _N) {
N = _N;
adj.resize(N);
}
void ae(int a, int b, F cap, F rcap = 0) {
assert(min(cap, rcap) >= 0);
adj[a].push_back({b, (int)(adj[b]).size(), 0, cap});
adj[b].push_back({a, (int)(adj[a]).size() - 1, 0, rcap});
}
vi lev, ptr;
bool bfs(int second, int t) {
lev = ptr = vi(N);
queue<int> q({second});
lev[second] = 1;
while ((int)(q).size()) {
int u = q.front();
q.pop();
for (auto& e : adj[u]) {
if (!lev[e.to] && e.cap - e.flo) q.push(e.to), lev[e.to] = lev[u] + 1;
}
}
return lev[t];
}
F dfs(int v, int t, F flo) {
if (v == t) return flo;
for (int& i = ptr[v]; i < (int)(adj[v]).size(); i++) {
Edge& e = adj[v][i];
F dif = e.cap - e.flo;
if (lev[e.to] != lev[v] + 1 || !dif) continue;
if (F df = dfs(e.to, t, min(flo, dif))) {
e.flo += df;
adj[e.to][e.rev].flo -= df;
return df;
}
}
return 0;
}
F maxFlow(int second, int t) {
F tot = 0;
while (bfs(second, t))
while (F df = dfs(second, t, numeric_limits<F>::max())) tot += df;
return tot;
}
};
int n, m;
V<vi> A;
int hsh(int a, int b) { return m * a + b; }
Dinic D;
vi adj[MX];
vb need;
vi mt;
bool bad = 0;
vi vis;
int tt;
bool dfs(int x) {
if (vis[x] == tt) return 0;
vis[x] = tt;
for (int t : adj[x])
if (mt[t] == -1 || dfs(mt[t])) return mt[t] = x, 1;
return 0;
}
vi match(vi l, vi r) {
mt = vi(n * m, -1);
vb ok(n * m);
for (auto& t : r) ok[t] = 1;
vi res;
for (auto& t : l) {
vi now;
for (auto& u : adj[t])
if (ok[u]) now.push_back(u);
adj[t] = now;
}
for (auto& t : l)
if (need[t]) {
tt++;
if (!dfs(t)) {
bad = 1;
return {};
}
res.push_back(t);
}
for (auto& t : l)
if (!need[t]) {
tt++;
if (dfs(t)) res.push_back(t);
}
return res;
}
void solve() {
re(n, m);
A = V<vi>(n, vi(m));
re(A);
need = vb(n * m);
vis = vi(n * m);
for (int i = (0); i < (n * m); ++i) adj[i].clear();
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) {
bool les = 0;
for (int k = (0); k < (4); ++k) {
int I = i + xd[k], J = j + yd[k];
if (I < 0 || I >= n || J < 0 || J >= m) continue;
les |= A[I][J] < A[i][j];
if (A[I][J] == A[i][j]) adj[hsh(i, j)].push_back(hsh(I, J));
}
if (!les) {
need[hsh(i, j)] = 1;
0;
}
}
}
for (int i = (0); i < (n * m); ++i) 0;
bad = 0;
vi l, r;
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
if ((i + j) & 1)
l.push_back(hsh(i, j));
else
r.push_back(hsh(i, j));
}
0;
vi L = match(l, r);
if (bad) {
ps("NO");
return;
}
0;
vi R = match(r, L);
0;
if (bad) {
ps("NO");
return;
}
0;
vs ans(n, str(m, '.'));
V<vi> ANS(n, vi(m));
auto con = [&](int x) -> pi { return {x / m, x % m}; };
auto make_dir = [&](pi X, pi Y) {
if (Y == make_pair(X.first + 1, X.second)) ans[X.first][X.second] = 'D';
if (Y == make_pair(X.first - 1, X.second)) ans[X.first][X.second] = 'U';
if (Y == make_pair(X.first, X.second + 1)) ans[X.first][X.second] = 'R';
if (Y == make_pair(X.first, X.second - 1)) ans[X.first][X.second] = 'L';
};
auto make_edge = [&](int x, int y) {
pi X = con(x), Y = con(y);
ANS[X.first][X.second] = A[X.first][X.second] - 1;
ANS[Y.first][Y.second] = 1;
make_dir(X, Y);
make_dir(Y, X);
};
for (int i = (0); i < (n * m); ++i)
if (mt[i] != -1) {
make_edge(mt[i], i);
0;
}
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j)
if (ans[i][j] == '.') {
for (int k = (0); k < (4); ++k) {
int I = i + xd[k], J = j + yd[k];
if (I < 0 || I >= n || J < 0 || J >= m) continue;
if (A[I][J] < A[i][j]) {
ANS[i][j] = A[i][j] - A[I][J];
make_dir({i, j}, {I, J});
}
}
}
ps("YES");
for (auto& t : ANS) {
for (auto& u : t) pr(u, ' ');
ps();
}
for (auto& t : ans) {
for (auto& u : t) pr(u, ' ');
ps();
}
}
int main() {
setIO();
int T;
re(T);
for (int i = (0); i < (T); ++i) solve();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INT_INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const long double PI = acos((long double)-1);
const int xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
const int MN = 14;
int N, g[MN][MN];
long long ans[1 << MN];
vector<long long> dp[1 << MN][MN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) {
for (int k = 0; k < N; k++) {
char c;
cin >> c;
g[i][k] = c - '0';
}
}
for (int i = 1; i < (1 << N); i++)
for (int k = 0; k < N; k++)
if (i & (1 << k)) dp[i][k].resize(1 << (__builtin_popcount(i) - 1));
for (int i = 0; i < N; i++) dp[1 << i][i][0] = 1;
for (int i = 1; i < (1 << N); i++) {
for (int k = 0; k < N; k++) {
if (!(i & (1 << k))) continue;
for (int msk = 0; msk < dp[i][k].size(); msk++) {
for (int nxt = 0; nxt < N; nxt++) {
if (i & (1 << nxt)) continue;
dp[i ^ (1 << nxt)][nxt][msk << 1 | g[k][nxt]] += dp[i][k][msk];
}
}
}
}
int t = (1 << N) - 1;
for (int k = 0; k < N; k++) {
if (!(t & (1 << k))) continue;
for (int msk = 0; msk < dp[t][k].size(); msk++) ans[msk] += dp[t][k][msk];
}
for (int i = 0; i < (1 << (N - 1)); i++) cout << ans[i] << " ";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
vector<pair<char, pair<int, int>>> ans;
int l = 0;
int mini = INT_MAX;
for (int i = 1; i <= 1000; i++) {
int cnt = 0;
l = 0;
vector<pair<char, pair<int, int>>> v;
for (int j = 0; j < n; j++) {
if (arr[j] != i + l * k) {
if (arr[j] > i + l * k) {
v.push_back({'-', {j + 1, arr[j] - i - l * k}});
} else {
v.push_back({'+', {j + 1, i + l * k - arr[j]}});
}
cnt++;
}
l++;
}
if (cnt < mini) {
mini = cnt;
ans = v;
}
}
cout << mini << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second.first << " "
<< ans[i].second.second << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void prepare() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
vector<int> result;
int a[2005];
int main() {
prepare();
int n, p;
int begs = 0;
int ends = 0;
cin >> n >> p;
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++) {
int temp;
cin >> temp;
a[i] = temp;
begs = max(begs, a[i] - n + 1);
ends = max(ends, a[i]);
}
sort(a + 1, a + n + 1);
for (int i = begs; i <= ends; i++) {
bool pass = false;
for (int j = 1; j <= n; j++) {
pass = true;
int pos = upper_bound(a + 1, a + n + 1, i + j - 1) - a;
if ((pos - j) % p == 0) {
pass = false;
break;
}
}
if (pass) result.push_back(i);
}
sort(result.begin(), result.end());
if (result.empty()) {
cout << 0 << endl;
return 0;
}
cout << result.size() << endl;
for (int i = 0; i < result.size(); i++) {
cout << result[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long int INF = 1e18;
const double EPSILON = 0.001;
const int N = 1e5 + 5;
int main() {
cin.tie(NULL), cout.sync_with_stdio(true);
string s;
cin >> s;
int _up = 1, _down = 1;
for (auto c : s) {
if (c == '0') {
cout << 1 << " " << _up << '\n';
_up = (_up + 1 == 5 ? 1 : _up + 1);
} else {
cout << 3 << " " << _down << '\n';
_down = (_down + 2 == 5 ? 1 : _down + 2);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using ul = std::uint32_t;
using li = std::int32_t;
using ull = std::uint64_t;
using ll = std::int64_t;
using llf = long double;
ul n, m, k;
const ul maxn = 2e5;
const ul base = 998244353;
ul plus(ul a, ul b) { return a + b < base ? a + b : a + b - base; }
ul plus(ul a, ul b, ul c) { return plus(plus(a, b), c); }
ul minus(ul a, ul b) { return a < b ? a + base - b : a - b; }
ul mul(ul a, ul b) { return ull(a) * ull(b) % base; }
ul mul(ul a, ul b, ul c) { return mul(mul(a, b), c); }
ul mul(ul a, ul b, ul c, ul d) { return mul(mul(a, b, c), d); }
void exgcd(li a, li b, li& x, li& y) {
if (b) {
exgcd(b, a % b, y, x);
y -= a / b * x;
} else {
x = 1;
y = 0;
}
}
ul inverse(ul a) {
li x, y;
exgcd(a, base, x, y);
return x < 0 ? x + li(base) : x;
}
ul pow(ul a, ul b) {
ul ret = 1;
while (b) {
if (b & 1) {
ret = mul(a, ret);
}
b >>= 1;
a = mul(a, a);
}
return ret;
}
ul h[maxn + 1];
ul fac[maxn + 1];
ul fiv[maxn + 1];
ul twopow[maxn + 1];
ul bi(ul a, ul b) { return mul(fac[a], fiv[b], fiv[a - b]); }
ul g(ul a) {
ul ret = mul(base + 1 >> 1, twopow[a]);
if (~a & 1) {
ret = minus(ret, mul(base + 1 >> 1, bi(a, a >> 1)));
}
return ret;
}
int main() {
fac[0] = 1;
twopow[0] = 1;
for (ul i = 1; i <= maxn; ++i) {
fac[i] = mul(fac[i - 1], i);
twopow[i] = plus(twopow[i - 1], twopow[i - 1]);
}
fiv[maxn] = inverse(fac[maxn]);
for (ul i = maxn; i; --i) {
fiv[i - 1] = mul(fiv[i], i);
}
std::scanf("%u%u", &n, &k);
k %= base;
for (ul i = 1; i <= n; ++i) {
std::scanf("%u", &h[i]);
}
for (ul i = 1; i <= n; ++i) {
m += h[i] != h[i % n + 1];
}
ul ans = 0;
for (ul a = 0; a <= m; ++a) {
ans = plus(ans, mul(bi(m, a), pow(minus(k, 2), m - a), g(a)));
}
ans = mul(ans, pow(k, n - m));
std::printf("%u\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long double d = (double)n / 10;
if (lround(d) != 0)
cout << lround(d) << "0";
else
cout << lround(d);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 23;
int N;
int data[MAXN];
inline void swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i) cin >> data[i];
for (int i = 0; i < N; ++i)
for (int j = 0; j < N - 1; ++j)
if (data[j] > data[j + 1]) {
swap(data[j], data[j + 1]);
cout << j + 1 << ' ' << j + 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, s;
pair<int, int> a[105];
vector<int> sol;
int main() {
cin.sync_with_stdio(false);
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
s += a[i].first;
if (s > k) break;
sol.push_back(a[i].second);
}
cout << sol.size() << '\n';
for (auto it : sol) cout << it << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 707406378;
const int maxn = 1.5e7 + 10;
void read(long long &x) {
char ch;
bool flag = 0;
for (ch = getchar(); !isdigit(ch) && ((flag |= (ch == '-')) || 1);
ch = getchar())
;
for (x = 0; isdigit(ch); x = (x << 1) + (x << 3) + ch - 48, ch = getchar())
;
x *= 1 - 2 * flag;
}
int main() {
long long n, x, y;
cin >> n;
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> x >> y;
ans = max(ans, x + y);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x, a = 1;
cin >> n >> x;
if (n == 1 || n == 2)
cout << a << endl;
else {
int res = n - 2;
if (res % x == 0) {
cout << res / x + 1 << endl;
} else {
cout << res / x + 2 << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 255;
int dp[MAXN][MAXN][MAXN];
void init() {
for (int i = 0; i < MAXN; ++i) {
for (int j = 0; j < MAXN; ++j) {
for (int q = 0; q < MAXN; ++q) dp[i][j][q] = int(1e9);
}
}
dp[0][0][0] = -1;
}
void solve() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<vector<bool>> can(3, vector<bool>(n));
vector<string> cur(3);
init();
vector<vector<int>> closer(n, vector<int>(26, n));
for (int i = n - 1; i >= 0; --i) {
if (i != n - 1) {
closer[i] = closer[i + 1];
}
closer[i][s[i] - 'a'] = i;
}
while (q--) {
char type;
cin >> type;
int ind;
cin >> ind;
--ind;
if (type == '+') {
char newone;
cin >> newone;
cur[ind] += newone;
int len = int(cur[ind].size()) - 1;
if (ind == 0) {
for (int flen = 0; flen <= int(cur[1].size()); ++flen) {
for (int slen = 0; slen <= int(cur[2].size()); ++slen) {
int pos = dp[len][flen][slen];
if (pos >= n - 1) {
dp[len + 1][flen][slen] = int(1e9);
continue;
}
pos = closer[pos + 1][newone - 'a'];
if (pos < n) {
dp[len + 1][flen][slen] = pos;
} else {
dp[len + 1][flen][slen] = int(1e9);
}
}
}
for (int flen = 0; flen <= int(cur[1].size()); ++flen) {
for (int slen = 0; slen <= int(cur[2].size()); ++slen) {
int pos = dp[len + 1][flen][slen];
if (pos >= n - 1) continue;
if (flen != int(cur[1].size())) {
char f1 = cur[1][flen];
int pos1 = closer[pos + 1][f1 - 'a'];
dp[len + 1][flen + 1][slen] =
min(dp[len + 1][flen + 1][slen], pos1);
}
if (slen != int(cur[2].size())) {
char f2 = cur[2][slen];
int pos2 = closer[pos + 1][f2 - 'a'];
dp[len + 1][flen][slen + 1] =
min(dp[len + 1][flen][slen + 1], pos2);
}
}
}
}
if (ind == 1) {
for (int flen = 0; flen <= int(cur[0].size()); ++flen) {
for (int slen = 0; slen <= int(cur[2].size()); ++slen) {
int pos = dp[flen][len][slen];
if (pos >= n - 1) {
dp[flen][len + 1][slen] = int(1e9);
continue;
}
pos = closer[pos + 1][newone - 'a'];
if (pos < n) {
dp[flen][len + 1][slen] = pos;
} else {
dp[flen][len + 1][slen] = int(1e9);
}
}
}
for (int flen = 0; flen <= int(cur[0].size()); ++flen) {
for (int slen = 0; slen <= int(cur[2].size()); ++slen) {
int pos = dp[flen][len + 1][slen];
if (pos >= n - 1) continue;
if (flen != int(cur[0].size())) {
char f1 = cur[0][flen];
int pos1 = closer[pos + 1][f1 - 'a'];
dp[flen + 1][len + 1][slen] =
min(dp[flen + 1][len + 1][slen], pos1);
}
if (slen != int(cur[2].size())) {
char f2 = cur[2][slen];
int pos2 = closer[pos + 1][f2 - 'a'];
dp[flen][len + 1][slen + 1] =
min(dp[flen][len + 1][slen + 1], pos2);
}
}
}
}
if (ind == 2) {
for (int flen = 0; flen <= int(cur[0].size()); ++flen) {
for (int slen = 0; slen <= int(cur[1].size()); ++slen) {
int pos = dp[flen][slen][len];
if (pos >= n - 1) {
dp[flen][slen][len + 1] = int(1e9);
continue;
}
pos = closer[pos + 1][newone - 'a'];
if (pos < n) {
dp[flen][slen][len + 1] = pos;
} else {
dp[flen][slen][len + 1] = int(1e9);
}
}
}
for (int flen = 0; flen <= int(cur[0].size()); ++flen) {
for (int slen = 0; slen <= int(cur[1].size()); ++slen) {
int pos = dp[flen][slen][len + 1];
if (pos >= n - 1) continue;
if (flen != int(cur[0].size())) {
char f1 = cur[0][flen];
int pos1 = closer[pos + 1][f1 - 'a'];
dp[flen + 1][slen][len + 1] =
min(dp[flen + 1][slen][len + 1], pos1);
}
if (slen != int(cur[1].size())) {
char f2 = cur[1][slen];
int pos2 = closer[pos + 1][f2 - 'a'];
dp[flen][slen + 1][len + 1] =
min(dp[flen][slen + 1][len + 1], pos2);
}
}
}
}
} else {
cur[ind].pop_back();
int len = int(cur[ind].size());
if (ind == 0) {
for (int flen = 0; flen < MAXN; ++flen) {
for (int slen = 0; slen < MAXN; ++slen) {
dp[len + 1][flen][slen] = int(1e9);
}
}
}
if (ind == 1) {
for (int flen = 0; flen < MAXN; ++flen) {
for (int slen = 0; slen < MAXN; ++slen) {
dp[flen][len + 1][slen] = int(1e9);
}
}
}
if (ind == 2) {
for (int flen = 0; flen < MAXN; ++flen) {
for (int slen = 0; slen < MAXN; ++slen) {
dp[flen][slen][len + 1] = int(1e9);
}
}
}
}
int len1 = int(cur[0].size());
int len2 = int(cur[1].size());
int len3 = int(cur[2].size());
if (dp[len1][len2][len3] < n) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans, a[2000];
int main() {
cin >> n >> k;
ans = k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) ans = max(ans, k / a[i] * a[j] + k % a[i]);
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100001];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (n == 1) {
if (a[0] == 1)
puts("NO");
else {
puts("YES");
cout << a[0] << "\n";
}
} else if (n == 2) {
if (a[0] == 1 && a[1] == 0) {
puts("YES");
cout << a[0] << "->" << a[1] << "\n";
} else
puts("NO");
} else {
if (a[n - 1] == 1) {
puts("NO");
} else {
int lastOne = -1;
for (int i = 0; i < n; ++i) {
if (a[i] == 1) lastOne = i;
}
if (lastOne == -1) {
puts("YES");
for (int i = 0; i < n - 3; ++i) {
cout << a[i] << "->";
}
cout << "(" << a[n - 3] << "->" << a[n - 2] << ")->" << a[n - 1]
<< "\n";
} else if (lastOne == n - 2) {
puts("YES");
for (int i = 0; i < n - 1; ++i) {
cout << a[i];
if (i != n - 2) cout << "->";
}
cout << "->" << a[n - 1] << "\n";
} else if (lastOne == n - 3) {
int firstZero = -1;
for (int i = n - 4; i >= 0; --i) {
if (a[i] == 0) {
firstZero = i;
break;
}
}
if (firstZero == -1) {
puts("NO");
} else {
puts("YES");
for (int i = 0; i < firstZero; ++i) {
cout << a[i] << "->";
}
for (int i = firstZero; i < n - 2; ++i) {
cout << "(" << a[i] << "->";
}
cout << a[n - 2];
for (int i = firstZero; i < n - 2; ++i) {
cout << ")";
}
cout << "->" << a[n - 1] << "\n";
}
} else {
puts("YES");
for (int i = 0; i < lastOne; ++i) {
cout << a[i] << "->";
}
for (int i = lastOne; i < n - 1; ++i) {
if (i != n - 2) cout << "(";
cout << a[i];
if (i != n - 2) cout << "->";
}
for (int i = lastOne; i < n - 2; ++i) {
cout << ")";
}
cout << "->" << a[n - 1] << "\n";
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int min(const int &x, const int &y) { return x < y ? x : y; }
inline long long min(const long long &x, const long long &y) {
return x < y ? x : y;
}
inline double min(const double &x, const double &y) { return x < y ? x : y; }
inline int max(const int &x, const int &y) { return x > y ? x : y; }
inline long long max(const long long &x, const long long &y) {
return x > y ? x : y;
}
inline double max(const double &x, const double &y) { return x > y ? x : y; }
template <class T>
inline void _updmin(T &x, const T &y) {
if (x > y) x = y;
}
template <class T>
inline void _updmax(T &x, const T &y) {
if (x < y) x = y;
}
template <class T>
inline T _lowbit(const T &x) {
return (x ^ (x - 1)) & x;
}
template <class T>
inline int _bitsize(const T &x) {
return (x == 0) ? 0 : (1 + _bitsize(x & (x - 1)));
}
const double _pi = acos(-1.0);
const double _eps = 1e-5;
template <class T>
inline T _sqr(const T &x) {
return x * x;
}
template <class T>
inline T _gcd(const T &x, const T &y) {
if (x < 0) return _gcd(-x, y);
if (y < 0) return _gcd(x, -y);
return (y == 0) ? x : _gcd(y, x % y);
}
template <class T>
inline T _lcm(const T &x, const T &y) {
if (x < 0) return _lcm(-x, y);
if (y < 0) return _lcm(x, -y);
return x * (y / _gcd(x, y));
}
template <class T>
inline T _euc(const T &a, const T &b, T &x, T &y) {
if (a < 0) {
T d = _euc(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = _euc(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = _euc(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > _fac(T n) {
vector<pair<T, int> > ret;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int cnt = 0;
for (; n % i == 0; cnt++, n /= i)
;
ret.push_back(make_pair(i, cnt));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) ret.push_back(make_pair(n, 1));
return ret;
}
template <class T>
inline int _prm(const T &x) {
if (x <= 1) return 0;
for (T i = 2; sqr(i) <= x; i++)
if (x % i == 0) return 0;
return 1;
}
template <class T>
inline T _phi(T x) {
vector<pair<T, int> > f = _fac(x);
T ret = x;
for (int i = 0; i < ((int)(f.size())); i++)
ret = ret / f[i].first * (f[i].first - 1);
return ret;
}
template <class T>
inline T _inv(T a, T b) {
T x, y;
_euc(a, b, x, y);
if (x == 0) x = 1;
return x;
}
template <class T>
inline T _cmod(T x, T m) {
return (x % m + m) % m;
}
template <class T>
inline T _amod(T x, T y, T m) {
return x = ((x + y) % m + m) % m;
}
template <class T>
inline T _mmod(T x, T y, T m) {
return (
T)((((long long)x) * ((long long)y) % ((long long)m) + ((long long)m)) %
((long long)m));
}
template <class T>
inline T _pmod(T x, T y, T m) {
if (y == 0)
return 1 % m;
else if ((y & 1) == 0) {
T z = _pmod(x, y >> 1, m);
return _mmod(z, z, m);
} else
return _mmod(_pmod(x, y ^ 1, m), x, m);
}
const int _MTRXSIZE = 40;
template <class T>
inline void _shwMTRX(int n, T A[_MTRXSIZE][_MTRXSIZE]) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << A[i][j] << " ";
cout << endl;
}
}
template <class T>
inline void _stdMTRX(int n, T A[_MTRXSIZE][_MTRXSIZE]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) A[i][j] = (i == j) ? 1 : 0;
}
template <class T>
inline void _addMTRX(int n, T C[_MTRXSIZE][_MTRXSIZE],
T A[_MTRXSIZE][_MTRXSIZE], T B[_MTRXSIZE][_MTRXSIZE]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) C[i][j] = A[i][j] + B[i][j];
}
template <class T>
inline void _subMTRX(int n, T C[_MTRXSIZE][_MTRXSIZE],
T A[_MTRXSIZE][_MTRXSIZE], T B[_MTRXSIZE][_MTRXSIZE]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) C[i][j] = A[i][j] - B[i][j];
}
template <class T>
inline void _mulMTRX(int n, T C[_MTRXSIZE][_MTRXSIZE],
T _A[_MTRXSIZE][_MTRXSIZE], T _B[_MTRXSIZE][_MTRXSIZE]) {
T A[_MTRXSIZE][_MTRXSIZE], B[_MTRXSIZE][_MTRXSIZE];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
A[i][j] = _A[i][j];
B[i][j] = _B[i][j];
C[i][j] = 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) C[i][j] += A[i][k] * B[k][j];
}
template <class T>
inline void _addModMTRX(int n, T m, T C[_MTRXSIZE][_MTRXSIZE],
T A[_MTRXSIZE][_MTRXSIZE], T B[_MTRXSIZE][_MTRXSIZE]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) C[i][j] = _cmod(A[i][j] + B[i][j], m);
}
template <class T>
inline void _subModMTRX(int n, T m, T C[_MTRXSIZE][_MTRXSIZE],
T A[_MTRXSIZE][_MTRXSIZE], T B[_MTRXSIZE][_MTRXSIZE]) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) C[i][j] = _cmod(A[i][j] - B[i][j], m);
}
template <class T>
inline void _mulModMTRX(int n, T m, T C[_MTRXSIZE][_MTRXSIZE],
T _A[_MTRXSIZE][_MTRXSIZE],
T _B[_MTRXSIZE][_MTRXSIZE]) {
T A[_MTRXSIZE][_MTRXSIZE], B[_MTRXSIZE][_MTRXSIZE];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
A[i][j] = _A[i][j];
B[i][j] = _B[i][j];
C[i][j] = 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
C[i][j] = (C[i][j] + _mmod(A[i][k], B[k][j], m)) % m;
}
template <class T>
inline void _powModMTRX(int n, T y, T m, T C[_MTRXSIZE][_MTRXSIZE],
T X[_MTRXSIZE][_MTRXSIZE]) {
T R[_MTRXSIZE][_MTRXSIZE];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) R[i][j] = X[i][j];
_stdMTRX(n, C);
if (y > 0)
for (T i = 1;; i <<= 1) {
if (y & i) _mulModMTRX(n, m, C, C, R);
_mulModMTRX(n, m, R, R, R);
if (i > (y >> 1)) break;
}
}
template <class T>
struct _frct {
T a, b;
_frct(T a = 0, T b = 1);
string toString();
};
template <class T>
_frct<T>::_frct(T a, T b) {
T d = _gcd(a, b);
a /= d;
b /= d;
if (b < 0) a = -a, b = -b;
this->a = a;
this->b = b;
}
template <class T>
string _frct<T>::toString() {
ostringstream tout;
tout << a << "/" << b;
return tout.str();
}
template <class T>
_frct<T> operator+(_frct<T> p, _frct<T> q) {
return _frct<T>(p.a * q.b + q.a * p.b, p.b * q.b);
}
template <class T>
_frct<T> operator-(_frct<T> p, _frct<T> q) {
return _frct<T>(p.a * q.b - q.a * p.b, p.b * q.b);
}
template <class T>
_frct<T> operator*(_frct<T> p, _frct<T> q) {
return _frct<T>(p.a * q.a, p.b * q.b);
}
template <class T>
_frct<T> operator/(_frct<T> p, _frct<T> q) {
return _frct<T>(p.a * q.b, p.b * q.a);
}
int n, d;
char s[4100];
int a[4100], f[4100];
long long v[41000], ans, total;
int main() {
ios::sync_with_stdio(false);
while (cin >> d) {
ans = 0;
memset(v, 0, sizeof(v));
cin >> s;
n = strlen(s);
total = (1 + n) * n / 2;
f[0] = 0;
for (int i = 1; i <= n; i++) {
a[i] = s[i - 1] - '0';
if (a[i] < 0 || a[i] > 9)
while (1)
;
f[i] = f[i - 1] + a[i];
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) v[f[j] - f[i - 1]]++;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int val = f[j] - f[i - 1];
if (val == 0) {
if (d == 0) ans += total;
} else {
if (d % val != 0) continue;
val = d / val;
if (val >= 41000) continue;
ans += v[val];
}
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long r1, r2, r3, d;
const int MAXN = 1e6 + 10;
long long cnt[MAXN], dp[MAXN][2];
long long solve(int pos, int f) {
if (pos == n) {
if (!f) return -d;
return min({r1, r2, r3}) + d;
}
long long &r = dp[pos][f];
if (r != -1) return r;
r = 1e18;
if (f) {
r = min(r, r2 + solve(pos + 1, 0) + 2LL * min({r1, r2, r3}) + 3 * d);
r = min(r, min(r1, r3) * cnt[pos] + 2LL * min({r1, r2, r3}) + min(r1, r2) +
solve(pos + 1, 0) + 3 * d);
r = min(r, min(r1, r3) * cnt[pos] + r3 + min({r1, r2, r3}) + d +
(pos == n - 1 ? 0 : 2LL * d + solve(pos + 1, 0)));
} else {
r = min(r, r2 + solve(pos + 1, 1) + d);
r = min(r, min(r1, r3) * cnt[pos] + min(r1, r2) + solve(pos + 1, 1) + d);
r = min(r, min(r1, r3) * cnt[pos] + r3 + solve(pos + 1, 0) + d);
}
return r;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> r1 >> r2 >> r3 >> d;
for (long long i = 0; i < n; i++) cin >> cnt[i];
memset(dp, -1, sizeof(dp));
cout << solve(0, 0) << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int now = 1, t = 0, n, x, y, c;
scanf("%d%d%d%d", &n, &x, &y, &c);
while (now < c) {
int l = min(x - 1, ++t);
now += max(l - max((y + t - n), 0) + 1, 0) +
max(l - max((t - y + 1), 0) + 1, 0) - (l == t);
l = min(n - x, t);
now += max(l - max((y + t - n), 1) + 1, 0) +
max(l - max((t - y + 1), 1) + 1, 0) - (l == t);
}
printf("%d\n", t);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res;
cin >> n;
res = n / 5;
if (n % 5 != 0) res++;
cout << res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
long double pmin[maxn];
long double pmax[maxn];
long double A[maxn];
long double B[maxn];
bool solve() {
int n;
if (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> pmax[i];
if (i) {
pmax[i] += pmax[i - 1];
}
}
for (int i = 0; i < n; i++) {
cin >> pmin[i];
}
for (int i = n - 2; i >= 0; i--) {
pmin[i] += pmin[i + 1];
}
for (int i = 0; i < n; i++) {
long double s = pmax[i] - (i < n ? pmin[i + 1] : 0) + 1;
long double p = pmax[i];
long double d = sqrtl(max((long double)0, s * s - 4 * p));
A[i + 1] = (s - d) / 2;
B[i + 1] = (s + d) / 2;
}
A[0] = 0;
B[0] = 0;
for (int i = 0; i < n; i++) {
cout << A[i + 1] - A[i] << " \n"[i + 1 == n];
}
for (int i = 0; i < n; i++) {
cout << B[i + 1] - B[i] << " \n"[i + 1 == n];
}
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(0);
auto t = clock() / CLOCKS_PER_SEC;
while (solve()) {
auto nt = clock() / CLOCKS_PER_SEC;
cerr << "TIME: " << (nt - t) << endl;
t = nt;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100100];
int v1[100100];
int v2[100100];
int color[100100];
bool in_cycle[100100];
int getnext(int s, int eid) {
if (v1[eid] == s)
return v2[eid];
else
return v1[eid];
}
vector<vector<int> > cycles;
int stcnt = 0;
int st[100100];
int vis[100100];
map<pair<int, int>, int> wtf;
vector<int> getedges(vector<int> cycle) {
vector<int> res;
for (int i = 0; i < (int)(cycle).size(); i++) {
int cur = cycle[i];
int nxt = cycle[(i + 1) % (int)(cycle).size()];
res.push_back(wtf[make_pair(cur, nxt)]);
}
return res;
}
void go(int s, int lst = -1) {
if (vis[s] == 2) {
vector<int> cycle;
for (int i = stcnt - 1; i >= 0; i--) {
cycle.push_back(st[i]);
if (st[i] == s) break;
}
cycles.push_back(getedges(cycle));
return;
}
if (vis[s] == 1) return;
st[stcnt++] = s;
vis[s] = 2;
for (int i = 0; i < (int)(v[s]).size(); i++) {
int eid = v[s][i];
int nxt = getnext(s, eid);
if (nxt == lst) continue;
go(nxt, s);
}
vis[s] = 1;
stcnt--;
}
int good_color[100100];
vector<int> who_cycles[100100];
bool bad_cycle[100100];
void make_bad_cycle(int cyc);
void make_good_color(int col);
void make_bad_cycle(int cyc) {
if (bad_cycle[cyc]) return;
bad_cycle[cyc] = true;
for (int i = 0; i < (int)(cycles[cyc]).size(); i++) {
int eid = cycles[cyc][i];
int col = color[eid];
make_good_color(col);
}
}
void make_good_color(int col) {
if (good_color[col]) return;
good_color[col] = true;
for (int i = 0; i < (int)(who_cycles[col]).size(); i++) {
make_bad_cycle(who_cycles[col][i]);
}
}
vector<int> graph[100100];
int F[100100];
int C[100100];
int frfr[100100];
int toto[100100];
bool VIS[100100];
vector<int> VISITED;
bool dfs(int s, int T) {
if (s == T) return true;
if (VIS[s]) return false;
VIS[s] = true;
VISITED.push_back(s);
for (int i = 0; i < (int)(graph[s]).size(); i++) {
int nxt = toto[graph[s][i]];
int fff = F[graph[s][i]];
int ccc = C[graph[s][i]];
if (ccc - fff > 0 && dfs(nxt, T)) {
F[graph[s][i]]++;
F[graph[s][i] ^ 1]--;
return true;
}
}
return false;
}
int solve(int S, int T) {
int res = 0;
while (dfs(S, T)) {
while (!VISITED.empty()) {
VIS[VISITED.back()] = false;
VISITED.pop_back();
}
res++;
}
return res;
}
void add_edge(int FROM, int TO, int eid, int c) {
graph[FROM].push_back(eid);
graph[TO].push_back(eid ^ 1);
frfr[eid] = FROM;
toto[eid] = TO;
frfr[eid ^ 1] = TO;
toto[eid ^ 1] = FROM;
C[eid] = c;
C[eid ^ 1] = 0;
F[eid] = 0;
F[eid ^ 1] = 0;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
v1[i] = a;
v2[i] = b;
color[i] = c;
v[a].push_back(i);
v[b].push_back(i);
wtf[make_pair(a, b)] = i;
wtf[make_pair(b, a)] = i;
}
go(1);
for (int i = 0; i < (int)(cycles).size(); i++) {
for (int j = 0; j < (int)(cycles[i]).size(); j++) {
int eid = cycles[i][j];
int col = color[eid];
in_cycle[eid] = true;
who_cycles[col].push_back(i);
}
}
for (int i = 1; i <= m; i++) {
if (!in_cycle[i]) {
make_good_color(color[i]);
}
}
int res = 0;
int S = 0;
vector<vector<int> > good_cycles;
for (int i = 0; i < (int)(cycles).size(); i++) {
if (!bad_cycle[i]) {
vector<int> tmp;
for (int j = 0; j < (int)(cycles[i]).size(); j++) {
tmp.push_back(color[cycles[i][j]]);
}
good_cycles.push_back(tmp);
}
}
int CUREID = 0;
if ((int)(good_cycles).size() != 0) {
int CUR = 1;
int CYC_BEGIN = CUR;
for (int i = 0; i < (int)(good_cycles).size(); i++) {
add_edge(S, CUR, CUREID, (int)(good_cycles[i]).size() - 1);
CUREID += 2;
CUR++;
}
int CYC_END = CUR - 1;
int COL_BEGIN = CUR;
int COL_END = CUR + m - 1;
for (int i = 0; i < (int)(good_cycles).size(); i++) {
for (int j = 0; j < (int)(good_cycles[i]).size(); j++) {
int col = good_cycles[i][j];
int FROM = i + 1;
int TO = COL_BEGIN + col - 1;
add_edge(FROM, TO, CUREID, 1);
CUREID += 2;
}
}
int T = COL_END + 1;
for (int i = COL_BEGIN; i <= COL_END; i++) {
int FROM = i;
int TO = T;
add_edge(FROM, TO, CUREID, 1);
CUREID += 2;
}
res += solve(S, T);
}
for (int i = 1; i <= m; i++) {
if (good_color[i]) {
res++;
}
}
printf("%d\n", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const char lend = '\n';
int n, k;
string str, res;
int add(int p) {
for (int i = p + 1; i < n; ++i) str[i] = 'a';
int c = 1;
for (int i = p; i >= 0 && c; --i) {
str[i] += c;
c = 0;
if (str[i] == 'a' + k) c = 1, str[i] = 'a';
}
if (c) return 0;
return 1;
}
int get() {
for (int i = 0; i < n; ++i) {
if (str[i] == str[i + 1]) return i + 1;
if (i + 2 < n && str[i] == str[i + 2]) return i + 2;
}
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
cin >> str;
if (!add(n - 1)) {
cout << "NO\n";
return 0;
}
while (1) {
int pos = get();
if (pos == -1) {
res = str;
break;
}
if (!add(pos)) break;
}
if (res.empty()) res = "NO";
cout << res << lend;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100, mod = 1e9 + 7;
struct matrix {
int n, m, a[3][3];
matrix() {
n = m = 1;
memset(a, 0, sizeof a);
}
matrix(int first, int second) {
n = first, m = second;
memset(a, 0, sizeof a);
}
matrix(int first, int second, vector<int> v) {
n = first, m = second;
int p = 0;
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (m); ++(j)) a[i][j] = v[p++];
}
inline matrix operator*(matrix first) {
matrix ans(n, first.m);
for (int(i) = (0); (i) < (n); ++(i))
for (int(j) = (0); (j) < (first.m); ++(j))
for (int(k) = (0); (k) < (m); ++(k)) {
int second = (1LL * a[i][k] * first.a[k][j]) % mod;
ans.a[i][j] = (ans.a[i][j] + second) % mod;
}
return ans;
}
inline matrix operator^(long long r) {
matrix ans(n, m);
if (!r) {
for (int(i) = (0); (i) < (n); ++(i)) ans.a[i][i] = 1;
return ans;
}
ans = (*this) ^ (r / 2LL);
ans = ans * ans;
if (r % 2LL) ans = ans * (*this);
return ans;
}
inline void print() {
cout << "Matrix\n";
for (int(i) = (0); (i) < (n); ++(i)) {
for (int(j) = (0); (j) < (m); ++(j)) cout << a[i][j] << ' ';
cout << '\n';
}
}
};
string f[maxn], s[maxn];
long long k;
int n;
int au[maxn][2], nx = 1, root, pr[maxn], h[maxn], mx, cnt[maxn];
vector<int> node[maxn];
int lst[maxn];
inline void build(int first) {
int v = root;
for (int(i) = (0); (i) < (s[first].size()); ++(i)) {
int c = s[first][i] - 'a';
if (au[v][c] == -1) {
h[nx] = h[v] + 1;
mx = ((mx) > (h[nx]) ? (mx) : (h[nx]));
node[h[nx]].push_back(nx);
au[v][c] = nx++;
}
v = au[v][c];
}
lst[first] = v;
}
inline void det() {
for (int(i) = (0); (i) < (mx + 1); ++(i))
for (auto &(v) : (node[i]))
for (int(c) = (0); (c) < (2); ++(c)) {
if (au[v][c] + 1) {
int u = au[v][c];
if (v == root)
pr[u] = root;
else
pr[u] = au[pr[v]][c];
} else {
if (v == root)
au[v][c] = root;
else
au[v][c] = au[pr[v]][c];
}
}
}
inline void interstellar() {
for (int(i) = (mx); (i) > (-11); --(i))
for (auto &(v) : (node[i]))
if (pr[v] != root) cnt[pr[v]] += cnt[v];
}
inline vector<int> inception(string t) {
memset(cnt, 0, sizeof(cnt));
int v = root;
for (int(i) = (0); (i) < (t.size()); ++(i)) {
v = au[v][t[i] - 'a'];
cnt[v]++;
}
interstellar();
vector<int> ans;
for (int(i) = (0); (i) < (n); ++(i)) ans.push_back(cnt[lst[i]]);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
memset(au, -1, sizeof(au));
node[0].push_back(root);
cin >> k >> n;
--k;
for (int(i) = (0); (i) < (n); ++(i)) {
cin >> s[i];
build(i);
}
if (!k) {
for (int(i) = (0); (i) < (n); ++(i)) {
if (s[i] == "a")
cout << "1\n";
else
cout << "0\n";
}
return 0;
}
det();
f[0] = "a", f[1] = "b";
int first = 1;
while (f[first].size() < 100000 && first < k) {
++first;
f[first] = f[first - 1] + f[first - 2];
}
if (first == k) {
vector<int> v = inception(f[first]);
for (int(i) = (0); (i) < (n); ++(i)) cout << v[i] << '\n';
return 0;
}
++first;
f[first] = f[first - 1] + f[first - 2];
if (first == k) {
vector<int> v = inception(f[first]);
for (int(i) = (0); (i) < (n); ++(i)) cout << v[i] << '\n';
return 0;
}
vector<int> L = inception(f[first]), L1 = inception(f[first - 1]),
LL = inception(f[first] + f[first]),
LL1 = inception(f[first] + f[first - 1]),
L1L = inception(f[first - 1] + f[first]);
long long r = k - (long long)first - 1LL;
for (int(i) = (0); (i) < (n); ++(i)) {
int first = LL1[i] - L[i] - L1[i], second = L1L[i] - L[i] - L1[i],
z = LL[i] - L[i] - L[i];
matrix memento[3];
memento[2] = matrix(3, 3, {1, 1, first, 1, 0, 0, 0, 0, 1});
memento[0] = matrix(3, 3, {1, 1, second, 1, 0, 0, 0, 0, 1});
memento[1] = matrix(3, 3, {1, 1, z, 1, 0, 0, 0, 0, 1});
matrix the_prestige = memento[0] * memento[1];
matrix ans = memento[2];
if (r % 2LL) ans = ans * memento[0];
ans = ans * (the_prestige ^ (r / 2LL));
matrix darknight(3, 1, {L[i], L1[i], 1});
ans = ans * darknight;
cout << ans.a[0][0] << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
set<int> m;
int q;
for (int i = (0); i < (n); ++i) {
cin >> q;
m.insert(q);
}
bool flag = true;
while (flag) {
int k = *m.rbegin() / 2;
while (m.find(k) != m.end()) {
k /= 2;
}
if (k == 0) break;
m.erase(*m.rbegin());
m.insert(k);
}
for (auto i = m.begin(); i != m.end(); i++) {
cout << *i << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int h = 31;
int n, len[100005];
long long ans, inc, cst[100005], bef[100005][30];
unsigned long long hsh[100005], mix[100005];
int sum[30][100005];
char s[100005];
bool pef[100005][16 + 5];
unsigned long long Sub(int l, int r) {
return hsh[r] - hsh[l - 1] * mix[r - l + 1];
}
bool Check(int l1, int r1, int l2, int r2) {
return Sub(l1, r1) == Sub(l2, r2);
}
int Lcp(int l1, int l2) {
int res = 0;
for (int i = 16; i >= 0; i--) {
int lef = res + len[i];
if (l1 + lef <= n && l2 + lef <= n && Check(l1, l1 + lef, l2, l2 + lef))
res += len[i] + 1;
}
return res;
}
void Init() {
for (int i = 1; i <= 16 + 1; i++) len[i] = len[i - 1] << 1 | 1;
mix[0] = 1, ans = n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 26; j++)
sum[j][i] = sum[j][i - 1] + (s[i] - 'a' + 1 == j);
pef[i][1] = 1, mix[i] = mix[i - 1] * h;
hsh[i] = hsh[i - 1] * h + s[i] - 'a' + 1;
}
}
void Solve1() {
for (int i = 2; len[i] <= n; i++)
for (int l = 1, r = len[i]; r <= n; l++, r++) {
int mid = l + len[i - 1], ch = s[mid] - 'a' + 1;
if (sum[ch][r] - sum[ch][l - 1] == 1)
pef[l][i] =
pef[l][i - 1] & pef[mid + 1][i - 1] & Check(l, mid - 1, mid + 1, r);
ans += 1ll * pef[l][i] * len[i] * len[i];
}
}
void Solve2() {
for (int i = 1; len[i] <= n; i++)
for (int l = 1, r = len[i]; r <= n; l++, r++) {
cst[l] += 1ll * pef[l][i] * len[i] * len[i];
cst[r + 1] -= 1ll * pef[l][i] * len[i] * len[i];
}
for (int i = 1; i <= n; i++) cst[i] += cst[i - 1];
}
void Calc(int l1, int k) {
if (k == 1) {
for (int i = 1; i <= 26; i++) bef[l1][i]++;
return;
}
int mid = l1 + len[k - 1], l2 = mid + 1;
long long tmp = 1ll * len[k] * len[k];
if (pef[l1][k - 1] && pef[l2][k - 1] &&
Check(l1, mid - 1, l2, l2 + len[k - 1] - 1)) {
for (int i = 1; i <= 26; i++)
if (sum[i][l1 - 1] == sum[i][mid - 1]) bef[mid][i] += tmp;
return;
}
int prf1 = Lcp(l1, l2);
int m1 = l1 + prf1, m2 = l2 + prf1;
int prf2 = Lcp(m1 + 1, m2 + 1);
if (m1 + 1 + prf2 < mid) return;
if (pef[l1][k - 1] &&
sum[s[mid] - 'a' + 1][l1 - 1] == sum[s[mid] - 'a' + 1][mid - 1])
bef[m2][s[m1] - 'a' + 1] += tmp;
if (pef[l2][k - 1] &&
sum[s[mid] - 'a' + 1][mid] == sum[s[mid] - 'a' + 1][l2 + len[k - 1] - 1])
bef[m1][s[m2] - 'a' + 1] += tmp;
}
int main() {
scanf("%s", s + 1);
Init();
Solve1(), Solve2();
for (int i = 1; i <= n; ++i)
for (int j = 1; i + len[j] - 1 <= n; ++j) Calc(i, j);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 26; j++) inc = max(inc, bef[i][j] - cst[i]);
printf("%lld\n", ans + inc);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, val = 0, mx = 0;
cin >> n;
bool flag = true;
for (long long i = 1, j = n; i <= j;) {
if (flag) {
cout << i << " ";
flag = false;
i++;
} else if (!flag) {
cout << j << " ";
j--;
flag = true;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
vector<int> p(n + 1);
for (int i = 1; i <= n; ++i) {
scanf("%d", &p[i]);
}
auto rbound = [&p](int i) { return i + p[i]; };
vector<int> dp(n + 1), plan(n + 1, -1), sufmax;
vector<pair<int, int>> c{{dp[0], 0}};
for (int i = 1; i <= n; ++i) {
dp[i] = dp[i - 1];
if (p[i] == 0) {
continue;
}
if (i <= dp[i - 1]) {
dp[i] = max(dp[i], i + p[i]);
}
auto it = lower_bound(c.begin(), c.end(), make_pair(i - p[i] - 1, 0));
if (it != c.end()) {
int j = it->second;
auto jt = lower_bound(sufmax.begin(), sufmax.end(), j + 1);
int m = i - 1;
if (jt != sufmax.end()) {
m = max(m, rbound(*jt));
}
if (dp[i] < m) {
dp[i] = m;
plan[i] = j;
}
}
if (c.back().first < dp[i]) {
c.emplace_back(dp[i], i);
}
while (!sufmax.empty() && rbound(sufmax.back()) <= rbound(i)) {
sufmax.pop_back();
}
sufmax.push_back(i);
}
if (dp[n] >= n) {
puts("YES");
vector<char> solution(n + 1, '\0');
for (int i = n; i > 0;) {
int j = plan[i];
if (~j) {
solution[--i] = 'L';
while (j < i) {
solution[--i] = 'R';
}
} else {
solution[--i] = 'R';
}
}
puts(solution.data());
} else {
puts("NO");
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long inf = 5e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
cin >> t;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
if (k > m - 1) {
k = m - 1;
}
int a[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
vector<int> maxChoice;
for (int left = 1; left <= m + 1; left++) {
maxChoice.push_back(max(a[left], a[n - m + left]));
}
int ans = 0;
for (int i = 0; i <= k; i++) {
int tmp = INT_MAX;
for (int j = i, cnt = 0; cnt < m - k and j < maxChoice.size();
j++, cnt++) {
tmp = min(tmp, maxChoice[j]);
}
ans = max(ans, tmp);
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, L, m, k, t, sum = 0, cnt, a[100009], d, rem, mod, mx, mn, v,
r, l;
string s, s1;
map<long long, long long> _mp;
vector<long long> v1, v2, v3;
vector<long long> v4[51];
set<long long> st;
set<long long>::iterator it;
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
if (a[0] != 0)
cout << 1 << endl;
else {
_mp[0] = 1;
for (i = 0; i < n; i++) {
if (_mp[a[i]] == 1)
_mp[a[i] + 1] = 1;
else {
cout << i + 1 << endl;
return 0;
}
}
cout << -1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
inline void chkmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
inline void chkmin(T &x, T y) {
if (x > y) x = y;
}
inline int read() {
int x = 0;
char c = getchar();
while (c < 48) c = getchar();
while (c > 47) x = x * 10 + (c ^ 48), c = getchar();
return x;
}
const int maxn = 2e5 + 10;
struct LB {
int bit[30];
void clear() { memset(bit, 0, sizeof bit); }
void ins(int x) {
for (int i = (29), iend = (0); i >= iend; --i)
if (x >> i & 1) {
if (bit[i]) {
x ^= bit[i];
continue;
}
for (int j = (0), jend = (i - 1); j <= jend; ++j)
if (x >> j & 1) x ^= bit[j];
for (int j = (i + 1), jend = (29); j <= jend; ++j)
if (bit[j] >> i & 1) bit[j] ^= x;
bit[i] = x;
return;
}
}
};
void merge(LB &res, LB A, LB B) {
memcpy(res.bit, A.bit, sizeof A.bit);
for (int i = (0), iend = (29); i <= iend; ++i)
if (B.bit[i]) res.ins(B.bit[i]);
}
int n, q, A[maxn];
int c[maxn];
void add(int pos, int x) {
for (; pos <= n; pos += pos & -pos) {
c[pos] ^= x;
}
}
int query(int pos) {
int res = 0;
for (; pos; pos &= pos - 1) {
res ^= c[pos];
}
return res;
}
LB qans, val[maxn << 2];
void build(int k, int l, int r) {
if (l == r) return val[k].ins(A[l]), void();
build(k << 1, l, ((l + r) >> 1)), build(k << 1 | 1, ((l + r) >> 1) + 1, r),
merge(val[k], val[k << 1], val[k << 1 | 1]);
}
void upd(int k, int l, int r, int x, int v) {
if (l == r) return val[k].clear(), val[k].ins(v), void();
x <= ((l + r) >> 1) ? upd(k << 1, l, ((l + r) >> 1), x, v)
: upd(k << 1 | 1, ((l + r) >> 1) + 1, r, x, v),
merge(val[k], val[k << 1], val[k << 1 | 1]);
}
void query(int k, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return merge(qans, qans, val[k]), void();
if (ql <= ((l + r) >> 1)) query(k << 1, l, ((l + r) >> 1), ql, qr);
if (qr > ((l + r) >> 1)) query(k << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr);
}
void solve() {
cin >> n >> q;
for (int i = (1), iend = (n); i <= iend; ++i) A[i] = read();
for (int i = (n), iend = (1); i >= iend; --i) add(i, A[i] ^= A[i - 1]);
build(1, 1, n);
while (q--) {
int op = read(), l = read(), r = read();
if (op == 1) {
int x = read();
add(l, x), add(r + 1, x);
upd(1, 1, n, l, A[l] ^= x);
if (r < n) upd(1, 1, n, r + 1, A[r + 1] ^= x);
} else {
qans.clear();
qans.ins(query(l));
if (l < r) query(1, 1, n, l + 1, r);
int res = 0;
for (int i = (0), iend = (29); i <= iend; ++i)
if (qans.bit[i]) res++;
printf("%d\n", 1 << res);
}
}
}
int main() {
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[101];
int main() {
int n, res = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
int check;
if (a[0] == 1)
check = 1;
else
check = 0;
for (int i = 1; i < n; i++) {
if (a[i] == 1 && check == 0) {
check = 1;
} else if (a[i] != 1 && check == 1) {
check = 0;
} else {
printf("Infinite\n");
return 0;
}
}
printf("Finite\n");
check = a[0];
for (int i = 1; i < n; i++) {
if (a[i] == 2) {
if (check == 3)
res += 2;
else
res += 3;
check = 2;
} else if (a[i] == 3) {
res += 4;
check = 3;
} else
res += check + 1;
}
printf("%d\n", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n;
long long a[MAXN], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
int i = 1;
while (i <= n) {
ans++;
if (i == n) break;
long long x = 0, y = 0;
long long pre1 = 0, pre2 = 0;
if (a[i] != -1)
x = a[i];
else {
pre1++;
i++;
while (i <= n) {
if (a[i] != -1) {
x = a[i];
break;
}
pre1++;
i++;
}
}
if (!x) break;
i++;
while (i <= n) {
if (a[i] != -1) {
y = a[i];
break;
}
pre2++;
i++;
}
long long d = 0;
if (y) {
d = (y - x) / (pre2 + 1);
}
if (y && d * (pre2 + 1) == (y - x) && x - pre1 * d > 0) {
long long v = y;
i++;
while (i <= n) {
v = v + d;
if (v < 1) break;
if (a[i] != -1 && a[i] != v) break;
i++;
}
} else {
continue;
}
}
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int primes[10000010];
int p;
int low[10000010];
void ciur();
set<int> s;
int main() {
ciur();
int n, x, c;
cin >> n >> x;
while (n--) {
cin >> c;
s.insert(c);
}
if (x == 2) {
cout << 0;
return 0;
}
if (s.find(1) != s.end()) {
cout << 1;
return 0;
}
if (primes[p] < x) {
cout << -1;
return 0;
}
int ans(0);
for (int i(1); primes[i] < x; i++) {
ans++;
if (s.find(primes[i]) == s.end()) {
cout << -1;
return 0;
}
}
cout << ans;
return 0;
}
void ciur() {
for (int i(2); i <= 10000000; i++) {
if (!low[i]) low[i] = i, primes[++p] = i;
for (int j(1); j <= p && primes[j] <= low[i] && i * primes[j] <= 10000000;
j++)
low[i * primes[j]] = primes[j];
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
long long int dx[] = {0, 0, 1, -1};
long long int dy[] = {1, -1, 0, 0};
long long int m = 0, n, res = 0, k;
string s2, ch = "", s, s1 = "";
vector<pair<string, long long int> > vm;
vector<pair<pair<long long int, long long int>, long long int> > vvv;
vector<pair<long long int, long long int> > vv, vv2;
vector<long long int> v[200005], v2, v1;
long long int a[200005], dp[15][15], ans[200005], vis[200] = {0};
long long int pot(long long int a, long long int b) {
long long int r = 1;
while (b) {
if (b % 2) r = (r * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return r % mod;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long int i = 0, x = 0, z = 0, y = 0, j = 0, q, mx = 0, idx = 0, ok = 0,
l = 0, r = 0, negatif = 0, positif = 0, l1, r1, p, t, d, g = 0;
set<pair<long long int, long long int> >::iterator itp;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
memset(dp, 0, sizeof(dp));
for (i = n; i >= 1; i--) {
vector<long long int> cur;
x = a[i];
while (x > 0) {
cur.push_back(x % 10);
x /= 10;
}
k = cur.size();
vis[k]++;
long long int cnt = 0;
for (j = 1; j <= k; j++) {
dp[k][j] += cur[j - 1] % mod;
}
}
for (i = 1; i <= n; i++) {
vector<long long int> cur;
x = a[i];
while (x > 0) {
cur.push_back(x % 10);
x /= 10;
}
k = cur.size();
for (l = 1; l <= k; l++) {
if (!vis[l]) continue;
p = 0;
res = 0;
for (j = 1; j <= l; j++) {
res += dp[l][j] * pot(10, p);
res %= mod;
p++;
res += vis[l] * cur[j - 1] * pot(10, p);
res %= mod;
p++;
}
for (j = l; j < k; j++) {
res += vis[l] * cur[j] * pot(10, p);
res %= mod;
p++;
}
ans[i] += res;
ans[i] %= mod;
}
for (l = k + 1; l <= 10; l++) {
if (!vis[l]) continue;
p = 0;
res = 0;
for (j = 1; j <= k; j++) {
res += dp[l][j] * pot(10, p);
res %= mod;
p++;
res += vis[l] * cur[j - 1] * pot(10, p);
res %= mod;
p++;
}
for (j = k + 1; j <= l; j++) {
res += dp[l][j] * pot(10, p);
res %= mod;
p++;
}
ans[i] += res;
ans[i] %= mod;
}
}
res = 0;
for (i = 1; i <= n; i++) {
res += ans[i];
res = (res + mod) % mod;
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[110000];
int main() {
scanf("%s", s);
int n = strlen(s);
int v = 0;
for (int i = 0; i < n; i++) {
if (s[i] > 'a') {
v = 1;
s[i]--;
} else {
if (v) break;
}
}
if (!v) {
s[n - 1] = 'z';
}
printf("%s\n", s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vv = vector<vector<T>>;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &t) {
os << "{";
for (int(i) = 0; (i) < (t.size()); ++(i)) {
os << t[i] << ",";
}
os << "}" << endl;
return os;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &t) {
return os << "(" << t.first << "," << t.second << ")";
}
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(0);
int n;
cin >> n;
vector<long long> v(n), d(n), p(n), rem(n, 1), re;
for (int(i) = 0; (i) < (n); ++(i)) cin >> v[i] >> d[i] >> p[i];
for (int(i) = 0; (i) < (n); ++(i)) {
int f = 1;
while (f) {
f = 0;
for (int(j) = 0; (j) < (n); ++(j))
if (p[j] < 0 && rem[j]) {
f = 1;
rem[j] = 0;
for (int(k) = 0; (k) < (n); ++(k))
if (k > j) p[k] -= d[j];
}
}
if (p[i] < 0) continue;
re.push_back(i);
rem[i] = 0;
int dd = v[i];
for (int(j) = 0; (j) < (n); ++(j)) {
int k = i + j + 1;
if (k >= n || dd <= 0) break;
if (rem[k]) {
p[k] -= dd;
--dd;
}
}
}
cout << re.size() << endl;
for (long long r : re) cout << r + 1 << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int comp(const void* a, const void* b) { return (*(int*)a - *(int*)b); }
int main() {
int t, n, i, a[1000005], k, c = 1, m, j;
scanf("%ld", &t);
for (i = 1; i <= t; i++) {
scanf("%d", &n);
for (j = 0; j < n; j++) {
scanf("%d", &a[j]);
}
qsort(a, n, sizeof(int), comp);
for (j = 1; j < n; j++) {
if (a[j] != a[j - 1]) c++;
}
printf("%d\n", c);
c = 1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
struct node {
int p, c;
bool operator<(const node &u) const { return p > u.p; }
} a[maxn], b[maxn];
int ta, tb;
char ch[5];
int u, v;
int main() {
int n, c, d;
cin >> n >> c >> d;
ta = tb = 0;
for (int i = 0; i < n; i++) {
cin >> u >> v >> ch;
if (ch[0] == 'C') {
a[ta].p = u;
a[ta++].c = v;
} else {
b[tb].p = u;
b[tb++].c = v;
}
}
sort(a, a + ta);
sort(b, b + tb);
int ans = 0;
int pa = 0, pb = 0;
for (int i = 0; i < ta; i++) {
if (a[i].c <= c) {
pa = a[i].p;
break;
}
}
for (int i = 0; i < tb; i++) {
if (b[i].c <= d) {
pb = b[i].p;
break;
}
}
if (pa && pb) ans = max(ans, pa + pb);
for (int i = 0; i < ta; i++) {
for (int j = i + 1; j < ta; j++) {
if (a[i].c + a[j].c <= c) {
ans = max(ans, a[i].p + a[j].p);
break;
}
}
}
for (int i = 0; i < tb; i++) {
for (int j = i + 1; j < tb; j++) {
if (b[i].c + b[j].c <= d) {
ans = max(ans, b[i].p + b[j].p);
break;
}
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int A[1001];
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first > b.first;
return a.second < b.second;
}
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int a, b;
cin >> a >> b;
int arr[n];
vector<pair<int, int>> dp;
for (int i = 0; i < n; i++) {
cin >> arr[i];
dp.push_back({arr[i], i});
}
int ans = 0;
if (a > b) {
sort(dp.begin(), dp.end());
for (int i = 0; i <= a - 1; i++) {
arr[dp[i].second] = 1;
}
for (int i = a; i < n; i++) {
arr[dp[i].second] = 2;
}
} else if (a < b) {
sort(dp.begin(), dp.end(), cmp);
for (int i = 0; i <= a - 1; i++) {
arr[dp[i].second] = 1;
}
for (int i = a; i < n; i++) {
arr[dp[i].second] = 2;
}
} else {
for (int i = 0; i <= a - 1; i++) {
arr[dp[i].second] = 1;
}
for (int i = a; i < n; i++) {
arr[dp[i].second] = 2;
}
}
for (int i = 0; i < n; i++) cout << arr[i] << " ";
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long testcase;
cin >> testcase;
while (testcase--) {
long long n;
cin >> n;
set<long long> st;
long long val;
for (long long i = 0; i < n; i++) {
cin >> val;
st.insert(val);
}
cout << (st.size() == n ? "NO" : "YES") << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, maxsq = 32000, inf = 1e6 + 1;
int a[maxn];
vector<int> pr;
struct Dinic {
int n, s, t;
vector<int> level;
struct Edge {
int to, rev, cap;
Edge() {}
Edge(int a, int b, int c) : to(a), cap(b), rev(c) {}
};
vector<Edge> G[maxn];
bool bfs() {
level.assign(n, -1);
level[s] = 0;
queue<int> que;
que.push(s);
while (que.size()) {
int tmp = que.front();
que.pop();
for (auto e : G[tmp]) {
if (e.cap > 0 && level[e.to] == -1) {
level[e.to] = level[tmp] + 1;
que.push(e.to);
}
}
}
return level[t] != -1;
}
int flow(int now, int low) {
if (now == t) return low;
int ret = 0;
for (auto &e : G[now]) {
if (e.cap > 0 && level[e.to] == level[now] + 1) {
int tmp = flow(e.to, min(e.cap, low - ret));
e.cap -= tmp;
G[e.to][e.rev].cap += tmp;
ret += tmp;
}
}
if (ret == 0) level[now] = -1;
return ret;
}
Dinic(int _n, int _s, int _t) : n(_n), s(_s), t(_t) {
fill(G, G + maxn, vector<Edge>());
}
void add_edge(int a, int b, int c) {
G[a].push_back(Edge(b, c, G[b].size()));
G[b].push_back(Edge(a, 0, G[a].size() - 1));
}
int maxflow() {
int ret = 0;
while (bfs()) ret += flow(s, inf);
return ret;
}
};
void sieve() {
bitset<maxsq> v;
for (int i = 2; i < maxsq; ++i) {
if (!v[i]) pr.push_back(i);
for (int j = 0; i * pr[j] < maxsq; ++j) {
v[i * pr[j]] = true;
if (i % pr[j] == 0) break;
}
}
}
int x[maxn], y[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
sieve();
int n, m;
cin >> n >> m;
vector<int> used;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
int tmp = a[i];
size_t ptr = 0;
while (tmp > 1 && ptr < pr.size()) {
int c = 0;
while (tmp % pr[ptr] == 0) tmp /= pr[ptr], ++c;
if (c) used.push_back(pr[ptr]);
++ptr;
}
if (tmp > 1) used.push_back(tmp);
}
sort(used.begin(), used.end());
used.resize(unique(used.begin(), used.end()) - used.begin());
for (int i = 0; i < m; ++i) cin >> x[i] >> y[i];
int ans = 0;
for (int p : used) {
int s = 0, t = n + 1;
Dinic flow(n + 2, s, t);
for (int i = 1; i <= n; ++i) {
int c = 0;
while (a[i] % p == 0) a[i] /= p, ++c;
if (!c) continue;
if (i & 1)
flow.add_edge(s, i, c);
else
flow.add_edge(i, t, c);
}
for (int i = 0; i < m; ++i) {
if (x[i] & 1)
flow.add_edge(x[i], y[i], inf);
else
flow.add_edge(y[i], x[i], inf);
}
ans += flow.maxflow();
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 1e6 + 5;
const long long inf = 1e18;
long long powermod(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;
}
vector<long long> adj[N];
vector<long long> p[N];
vector<long long> ans(N);
void dfs(long long x, long long par) {
set<long long> s;
for (long long i = 0; i < p[x].size(); i++) {
if (ans[p[x][i]]) s.insert(ans[p[x][i]]);
}
long long c = 1;
for (long long i = 0; i < p[x].size(); i++) {
if (!ans[p[x][i]]) {
while (s.find(c) != s.end()) c++;
ans[p[x][i]] = c;
s.insert(c);
}
}
for (auto e : adj[x]) {
if (e != par) {
dfs(e, x);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
long long mx = 1;
for (long long i = 1; i <= n; i++) {
long long sz;
cin >> sz;
mx = max(mx, sz);
while (sz--) {
long long x;
cin >> x;
p[i].push_back(x);
}
}
ans.resize(n + 1);
for (long long i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, 0);
cout << mx << "\n";
for (long long i = 1; i <= m; i++) {
if (!ans[i]) ans[i] = 1;
cout << ans[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, l[200010], r[200010], id[200010], ans, minn = -2147480000;
bool cmp(int x, int y) { return r[x] == r[y] ? l[x] < l[y] : r[x] < r[y]; }
int main() {
scanf("%d", &n);
for (int x, y, i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
l[i] = x - y;
r[i] = x + y;
id[i] = i;
}
sort(id + 1, id + n + 1, cmp);
for (int i = 1; i <= n; i++)
if (minn <= l[id[i]]) ans++, minn = r[id[i]];
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<long long> tpa[6], tpb[4];
long long amt[6];
fill(amt, amt + 6, 0);
for (long long i = 0; i < n; ++i) {
long long a, b, c;
cin >> a >> b >> c;
--a;
--c;
if (c < a) {
swap(a, c);
}
if (a == 0 && c == 0) {
tpb[0].push_back(b);
} else if (a == 0 && c == 1) {
tpa[0].push_back(b);
++amt[0];
} else if (a == 0 && c == 2) {
tpa[1].push_back(b);
++amt[1];
} else if (a == 0 && c == 3) {
tpa[2].push_back(b);
++amt[2];
} else if (a == 1 && c == 1) {
tpb[1].push_back(b);
} else if (a == 1 && c == 2) {
tpa[3].push_back(b);
++amt[3];
} else if (a == 1 && c == 3) {
tpa[4].push_back(b);
++amt[4];
} else if (a == 2 && c == 2) {
tpb[2].push_back(b);
} else if (a == 2 && c == 3) {
tpa[5].push_back(b);
++amt[5];
} else {
tpb[3].push_back(b);
}
}
for (long long i = 0; i < 6; ++i) {
if (i < 4) sort((tpb[i]).begin(), (tpb[i]).end(), greater<long long>());
sort((tpa[i]).begin(), (tpa[i]).end(), greater<long long>());
}
long long ans = 0;
for (long long i = 0; i < 4; ++i) {
long long cr = 0;
for (long long j : tpb[i]) {
cr += j;
}
ans = max(ans, cr);
}
long long val[amt[0] + 1][amt[1] + 1][amt[2] + 1][amt[3] + 1][amt[4] + 1]
[amt[5] + 1];
memset(val, 0, sizeof val);
for (long long a = 0; a <= amt[0]; ++a) {
for (long long b = 0; b <= amt[1]; ++b) {
for (long long c = 0; c <= amt[2]; ++c) {
for (long long d = 0; d <= amt[3]; ++d) {
for (long long e = 0; e <= amt[4]; ++e) {
for (long long f = 0; f <= amt[5]; ++f) {
if (!a && !b && !c && !d && !e && !f) continue;
if (a) {
val[a][b][c][d][e][f] =
max(val[a][b][c][d][e][f],
val[a - 1][b][c][d][e][f] + tpa[0][a - 1]);
}
if (b) {
val[a][b][c][d][e][f] =
max(val[a][b][c][d][e][f],
val[a][b - 1][c][d][e][f] + tpa[1][b - 1]);
}
if (c) {
val[a][b][c][d][e][f] =
max(val[a][b][c][d][e][f],
val[a][b][c - 1][d][e][f] + tpa[2][c - 1]);
}
if (d) {
val[a][b][c][d][e][f] =
max(val[a][b][c][d][e][f],
val[a][b][c][d - 1][e][f] + tpa[3][d - 1]);
}
if (e) {
val[a][b][c][d][e][f] =
max(val[a][b][c][d][e][f],
val[a][b][c][d][e - 1][f] + tpa[4][e - 1]);
}
if (f) {
val[a][b][c][d][e][f] =
max(val[a][b][c][d][e][f],
val[a][b][c][d][e][f - 1] + tpa[5][f - 1]);
}
}
}
}
}
}
}
for (long long i = 0; i < 16; ++i) {
for (long long j = 0; j < 6; ++j) {
amt[j] = tpa[j].size();
}
long long cur = 0;
bool adj[4];
fill(adj, adj + 4, false);
for (long long j = 0; j < 4; ++j) {
if (i & (1 << j)) {
for (long long k : tpb[j]) {
cur += k;
}
} else {
adj[j] = 1;
if (j == 0) {
amt[0] = amt[1] = amt[2] = 0;
} else if (j == 1) {
amt[0] = amt[3] = amt[4] = 0;
} else if (j == 2) {
amt[1] = amt[3] = amt[5] = 0;
} else if (j == 3) {
amt[2] = amt[4] = amt[5] = 0;
}
}
}
if (!adj[0] && !amt[0] && !amt[1] && !amt[2]) continue;
if (!adj[1] && !amt[0] && !amt[3] && !amt[4]) continue;
if (!adj[2] && !amt[1] && !amt[3] && !amt[5]) continue;
if (!adj[3] && !amt[2] && !amt[4] && !amt[5]) continue;
bitset<4> dp[amt[0] + 1][amt[1] + 1][amt[2] + 1][amt[3] + 1][amt[4] + 1]
[amt[5] + 1];
for (long long j = 0; j < 4; ++j) {
dp[amt[0]][amt[1]][amt[2]][amt[3]][amt[4]][amt[5]][j] = 1;
}
for (long long a = amt[0]; a >= 0; --a) {
for (long long b = amt[1]; b >= 0; --b) {
for (long long c = amt[2]; c >= 0; --c) {
for (long long d = amt[3]; d >= 0; --d) {
for (long long e = amt[4]; e >= 0; --e) {
for (long long f = amt[5]; f >= 0; --f) {
if (a != amt[0]) {
if (dp[a + 1][b][c][d][e][f][0]) {
dp[a][b][c][d][e][f][1] = 1;
}
if (dp[a + 1][b][c][d][e][f][1]) {
dp[a][b][c][d][e][f][0] = 1;
}
}
if (b != amt[1]) {
if (dp[a][b + 1][c][d][e][f][0]) {
dp[a][b][c][d][e][f][2] = 1;
}
if (dp[a][b + 1][c][d][e][f][2]) {
dp[a][b][c][d][e][f][0] = 1;
}
}
if (c != amt[2]) {
if (dp[a][b][c + 1][d][e][f][0]) {
dp[a][b][c][d][e][f][3] = 1;
}
if (dp[a][b][c + 1][d][e][f][3]) {
dp[a][b][c][d][e][f][0] = 1;
}
}
if (d != amt[3]) {
if (dp[a][b][c][d + 1][e][f][2]) {
dp[a][b][c][d][e][f][1] = 1;
}
if (dp[a][b][c][d + 1][e][f][1]) {
dp[a][b][c][d][e][f][2] = 1;
}
}
if (e != amt[4]) {
if (dp[a][b][c][d][e + 1][f][3]) {
dp[a][b][c][d][e][f][1] = 1;
}
if (dp[a][b][c][d][e + 1][f][1]) {
dp[a][b][c][d][e][f][3] = 1;
}
}
if (f != amt[5]) {
if (dp[a][b][c][d][e][f + 1][2]) {
dp[a][b][c][d][e][f][3] = 1;
}
if (dp[a][b][c][d][e][f + 1][3]) {
dp[a][b][c][d][e][f][2] = 1;
}
}
}
}
}
}
}
}
long long cans = 0;
for (long long a = max(0LL, amt[0]); a >= 0; --a) {
for (long long b = max(0LL, amt[1]); b >= 0; --b) {
for (long long c = max(0LL, amt[2]); c >= 0; --c) {
for (long long d = max(0LL, amt[3]); d >= 0; --d) {
for (long long e = max(0LL, amt[4]); e >= 0; --e) {
for (long long f = max(0LL, amt[5]); f >= 0; --f) {
bool usd[4];
fill(usd, usd + 4, 0);
if (a < amt[0] || b < amt[1] || c < amt[2]) usd[0] = 1;
if (a < amt[0] || d < amt[3] || e < amt[4]) usd[1] = 1;
if (b < amt[1] || d < amt[3] || f < amt[5]) usd[2] = 1;
if (c < amt[2] || e < amt[4] || f < amt[5]) usd[3] = 1;
bool ok = 0;
for (long long j = 0; j < 4; ++j) {
if (dp[a][b][c][d][e][f][j]) ok = 1;
if (i & (1 << j)) {
if (!usd[j]) {
ok = false;
break;
}
}
}
if (!ok) continue;
cans = max(cans, cur + val[amt[0] - a][amt[1] - b][amt[2] - c]
[amt[3] - d][amt[4] - e][amt[5] - f]);
}
}
}
}
}
}
for (long long j = 0; j < 6; ++j) {
amt[j] = tpa[j].size();
}
ans = max(ans, cans);
}
cout << ans << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6;
unsigned long long arr[N] = {}, arr2[N] = {}, n, ans = 0, a, b, sum = 0;
int main() {
cin >> n;
if (n % 2 == 0)
cout << n / 2;
else
cout << "-" << ((n + 1) / 2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double a[100010];
double b[100010];
double t[100010];
int main() {
long long ax, ay, bx, by, tx, ty;
cin >> ax >> ay >> bx >> by >> tx >> ty;
int n;
cin >> n;
long long x, y;
for (int i = 0; i < n; i++) {
cin >> x >> y;
a[i] = sqrt((double)((x - ax) * (x - ax) + (y - ay) * (y - ay)));
b[i] = sqrt((double)((x - bx) * (x - bx) + (y - by) * (y - by)));
t[i] = sqrt((double)((x - tx) * (x - tx) + (y - ty) * (y - ty)));
}
double sum = 0;
for (int i = 0; i < n; i++) sum += 2 * t[i];
if (n == 1) {
sum = min(a[0], b[0]) + t[0];
printf("%.10lf", sum);
return 0;
}
int ai = 0, bi = 0;
int ai2 = -1;
int bi2 = -1;
int aii, bii;
for (int i = 0; i < n; i++) {
if (t[i] - a[i] > t[ai] - a[ai]) ai = i;
if (t[i] - b[i] > t[bi] - b[bi]) bi = i;
}
aii = ai;
bii = bi;
if (t[aii] < a[aii] || t[bii] < b[bii]) {
sum -= max(t[aii] - a[aii], t[bii] - b[bii]);
printf("%.10lf", sum);
return 0;
}
if (ai == bi) {
for (int i = 0; i < n; i++) {
if ((ai2 == -1 || t[i] - a[i] > t[ai2] - a[ai2]) && i != ai) ai2 = i;
if ((bi2 == -1 || t[i] - b[i] > t[bi2] - b[bi2]) && i != bi) bi2 = i;
}
if (t[ai] - a[ai] + max(0.0, t[bi2] - b[bi2]) >
max(0.0, t[ai2] - a[ai2]) + t[bi] - b[bi])
bii = bi2;
else
aii = ai2;
}
if (t[aii] < a[aii] || t[bii] < b[bii]) {
sum -= max(t[aii] - a[aii], t[bii] - b[bii]);
printf("%.10lf", sum);
return 0;
}
sum -= t[aii] + t[bii];
sum += a[aii] + b[bii];
printf("%.10lf", sum);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
stringstream ss;
long long mod = 1000000007LL;
int f(int *a, int n) {
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) ans += *min_element(a + i, a + j + 1);
return ans;
}
int main() {
long long n, m;
cin >> n >> m;
int a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int mx = 0;
do {
mx = max(mx, f(a, n));
} while (next_permutation(a, a + n));
int b[] = {1, 2, 3, 4, 5, 6, 7, 8};
do {
if (f(b, n) == mx) {
m--;
if (!m) {
for (int i = 0; i < n; i++) cout << b[i] << " ";
cout << endl;
}
}
} while (next_permutation(b, b + n));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
using vec = vector<T>;
template <typename T>
using Prior = priority_queue<T>;
template <typename T>
using prior = priority_queue<T, vec<T>, greater<T>>;
const int INF = 1e9;
const ll LLINF = (ll)4 * 1e18;
const ll MOD = 1e9 + 7;
const double PI = 3.14159265358;
const double EPS = 1e-8;
const int xx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int yy[8] = {1, 0, -1, 0, 1, -1, -1, 1};
void pmod(ll &a, ll b) { a = (a + b) % MOD; }
void mmod(ll &a, ll b) { a = (a - b + MOD) % MOD; }
void tmod(ll &a, ll b) { a = (a * b) % MOD; }
ll POW(ll a, ll b) {
ll res = 1;
do {
if (b % 2) tmod(res, a);
tmod(a, a);
} while (b >>= 1);
return res;
}
template <typename T>
void amax(T &a, T b) {
if (a < b) a = b;
}
template <typename T>
void amin(T &a, T b) {
if (a > b) a = b;
}
int dsu[20];
void init() {
for (int i = 0; i < (20); i++) dsu[i] = i;
}
int find(int x) {
if (dsu[x] == x) return x;
return dsu[x] = find(dsu[x]);
}
void merge(int a, int b) { dsu[find(a)] = find(b); }
void solve() {
int n;
string a, b;
cin >> n >> a >> b;
for (auto &i : a) i -= 'a';
for (auto &i : b) i -= 'a';
for (int i = 0; i < (n); i++) {
if (b[i] < a[i]) {
cout << -1 << '\n';
return;
}
}
int ans = 0;
init();
for (int i = 0; i < (20); i++) {
for (int j = 0; j < (n); j++) {
if (i == b[j]) {
if (find(i) != find(a[j])) {
merge(i, a[j]);
ans++;
}
}
}
}
cout << ans << '\n';
}
int main() {
int T = 1;
cin >> T;
while (T--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int n, c, t1 = 0, t2 = 0, t3 = 0, w, count = 0, count_w = 0;
cin >> n;
while (n--) {
cin >> c;
v.push_back(c);
if (c == 1)
t1++;
else if (c == 2)
t2++;
else
t3++;
}
if (t1 != 0 && t2 != 0 && t3 != 0) {
w = min(min(t1, t2), t3);
cout << w << endl;
for (int i = 0; i < w; i++) {
for (int a = 0; a < v.size(); a++) {
if (v[a] == 1) {
cout << a + 1 << endl;
v[a] = 0;
break;
}
}
for (int b = 0; b < v.size(); b++) {
if (v[b] == 2) {
cout << b + 1 << endl;
v[b] = 0;
break;
}
}
for (int c = 0; c < v.size(); c++) {
if (v[c] == 3) {
cout << c + 1 << endl;
v[c] = 0;
break;
}
}
}
} else
cout << 0 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int c, n, k, r = 0;
cin >> n >> k;
vector<int64_t> A(n);
for (auto& a : A) cin >> a;
sort(A.begin(), A.end());
for (int i = 0; i < n; ++i) {
c = k + A[i];
if (c <= 5) r++;
}
cout << r / 3;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int f[3], v[3];
char c;
bool yes = false;
bool check() {
if (v[1] > 12) return false;
if (v[0] > day[v[1] - 1] + (v[1] == 2 && v[2] % 4 == 0 ? 1 : 0)) return false;
if (v[2] >= f[2]) return false;
if (f[2] - 18 > v[2]) return true;
if (f[2] - 18 == v[2]) {
if (v[1] < f[1]) return true;
if (v[1] > f[1]) return false;
if (v[0] <= f[0]) return true;
if (v[0] > f[0]) return false;
}
return false;
}
int main() {
for (int i = 0; i < 2; i++) cin >> f[i] >> c;
cin >> f[2];
for (int i = 0; i < 3; i++) cin >> v[i] >> c;
sort(v, v + 3);
do {
yes |= check();
} while (next_permutation(v, v + 3));
if (yes)
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
const double PI = 3.14159265358979323846;
const double eps = (1e-9);
enum { LESS, EQUAL, GREATER };
int dcmp(long double x, long double y) {
if (fabs(x - y) <= eps) return EQUAL;
return x > y ? GREATER : LESS;
}
const int MAX_N = 101;
int freq[MAX_N], a[MAX_N];
unsigned char mem[MAX_N][MAX_N][MAX_N * MAX_N];
bool vis[MAX_N][MAX_N][MAX_N * MAX_N];
unsigned char dp(int x, int remK, int remSum) {
if (x == MAX_N) return (remK == 0 && remSum == 0);
unsigned char &ret = mem[x][remK][remSum];
if (vis[x][remK][remSum]) return ret;
vis[x][remK][remSum] = true;
ret += dp(x + 1, remK, remSum);
if (ret > 2) ret = 2;
for (int i = 1; i <= min(remK, freq[x]) && i * x <= remSum; ++i) {
ret += dp(x + 1, remK - i, remSum - i * x);
if (ret > 2) ret = 2;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
set<int> s;
for (int i = 0; i < n; ++i) {
cin >> a[i];
freq[a[i]]++;
s.insert(a[i]);
}
if ((int)((s).size()) == 1) {
cout << n << '\n';
return 0;
}
if ((int)((s).size()) == 2) {
int x = *s.begin();
if (dp(1, freq[x], x * freq[x]) == 1) {
cout << n << '\n';
return 0;
}
}
int ans = 0;
for (int x = 1; x < MAX_N; ++x) {
for (int k = 1; k <= freq[x]; ++k) {
int ways = dp(1, k, k * x);
assert(ways != 0);
if (ways == 1) ans = max(ans, k);
}
}
cout << ans << '\n';
}
| 6 |
#include<bits/stdc++.h>
#define re register
using namespace std;
typedef long long ll;
ll rd(){
ll x = 0;
char ch = getchar();
while(ch < '0' || ch > '9') {
ch = getchar();
}
while(ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
const int MOD = 998244353;
void add(int &a,int b){
a = (a + b) % MOD;
}
int dp[505][505];
int main(){
char op[5];
int n = rd();
vector<int> a(n);
for(int i = 0;i < n;i++){
scanf("%s",op);
if(op[0] == '+') a[i] = rd();
else a[i] = -1;
}
int ans = 0;
for(int i = 0;i < n;i++){
if(a[i] != -1) {
memset(dp,0,sizeof dp);
dp[0][0] = 1;
for(int j = 0;j < n;j++){
for(int k = 0;k < n;k++){
add(dp[j + 1][k],dp[j][k]);
if(j != i) {
if(a[j] >= 0) {
bool ok = (a[j] < a [i]) || (a[j] == a[i] && i < j);
add(dp[j + 1][k + ok],dp[j][k]);
}
else {
if(k > 0) {
add(dp[j + 1][k - 1],dp[j][k]);
}
else if(j < i){
add(dp[j + 1][k],dp[j][k]);
}
}
}
}
}
for(int k = 0;k <= n;k++)
ans = (ans + (ll)dp[n][k] * a[i] % MOD) % MOD;
}
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b, n;
cin >> n >> a >> b;
vector<int> A(n);
for (int &x : A) cin >> x;
sort(A.begin(), A.end());
if (A[b] - A[b - 1] == 0) {
cout << "0\n";
return;
}
cout << A[b] - A[b - 1] << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 0 |
#include <bits/stdc++.h>
std::map<int, int> track_points;
std::vector<std::vector<std::pair<int, std::pair<int, int> > > >
graph_of_tracks;
const int MAX = 1001;
const int MAXINT = 1000000001;
void Dijcstra(int start_p = 0, int end_p = -1) {
if (end_p == -1) {
end_p = graph_of_tracks.size();
}
std::set<std::pair<int, int> > queue;
std::vector<int> optimal_track(graph_of_tracks.size(), MAXINT);
std::vector<std::pair<int, int> > sequence_track(graph_of_tracks.size());
optimal_track[start_p] = 0;
queue.insert(std::pair<int, int>(0, start_p));
while (!queue.empty()) {
int start_point_indx = queue.begin()->second;
int start_track = queue.begin()->first;
queue.erase(queue.begin());
for (std::vector<std::pair<int, std::pair<int, int> > >::iterator
point_iter = ::graph_of_tracks[start_point_indx].begin();
point_iter != ::graph_of_tracks[start_point_indx].end();
++point_iter) {
int end_point_indx = (*point_iter).first;
int cost = (*point_iter).second.first;
int used_jump_indx = (*point_iter).second.second;
if (start_track + cost < optimal_track[end_point_indx]) {
if (optimal_track[end_point_indx] != MAXINT) {
queue.erase(queue.find(std::pair<int, int>(
optimal_track[end_point_indx], end_point_indx)));
}
optimal_track[end_point_indx] = start_track + cost;
sequence_track[end_point_indx] =
std::pair<int, int>(start_point_indx, used_jump_indx);
queue.insert(std::pair<int, int>(start_track + cost, end_point_indx));
}
}
}
std::vector<int> optimal_jumps;
int point_indx = end_p;
while (point_indx != 0) {
int jump_indx = sequence_track[point_indx].second;
if (jump_indx != 0) {
optimal_jumps.push_back(jump_indx);
}
point_indx = sequence_track[point_indx].first;
}
std::cout << optimal_track[end_p] << std::endl;
std::cout << optimal_jumps.size() << std::endl;
for (std::vector<int>::reverse_iterator it = optimal_jumps.rbegin();
it != optimal_jumps.rend(); ++it) {
std::cout << (*it) << " ";
}
}
int getIndxOfTrackPoint(int point_pos) {
int point_indx;
if (::track_points.find(point_pos) == ::track_points.end()) {
point_indx = ::graph_of_tracks.size();
::track_points.insert(std::pair<int, int>(point_pos, point_indx));
::graph_of_tracks.push_back(
std::vector<std::pair<int, std::pair<int, int> > >());
} else {
point_indx = ::track_points.find(point_pos)->second;
}
return point_indx;
}
int main() {
int numb_of_jump, track_length;
std::cin >> numb_of_jump >> track_length;
::track_points.insert(std::pair<int, int>(0, 0));
::track_points.insert(std::pair<int, int>(track_length, 1));
::graph_of_tracks.push_back(
std::vector<std::pair<int, std::pair<int, int> > >());
::graph_of_tracks.push_back(
std::vector<std::pair<int, std::pair<int, int> > >());
for (int jump_indx = 0; jump_indx < numb_of_jump; ++jump_indx) {
int jump_pos, pre_jump_pos, post_jump_pos, jump_time, pre_jump_pos_rltv,
post_jump_pos_rltv, jump_time_real;
std::cin >> jump_pos >> post_jump_pos_rltv >> jump_time >>
pre_jump_pos_rltv;
pre_jump_pos = jump_pos - pre_jump_pos_rltv;
post_jump_pos = jump_pos + post_jump_pos_rltv;
jump_time_real = jump_time + pre_jump_pos_rltv;
if (pre_jump_pos < 0) {
continue;
}
int start_jump_point_indx, end_jump_point_indx;
start_jump_point_indx = getIndxOfTrackPoint(pre_jump_pos);
end_jump_point_indx = getIndxOfTrackPoint(post_jump_pos);
::graph_of_tracks[start_jump_point_indx].push_back(
std::pair<int, std::pair<int, int> >(
end_jump_point_indx,
std::pair<int, int>(jump_time_real, jump_indx + 1)));
}
std::map<int, int>::iterator iter_point = track_points.begin();
int pre_point_pos = (*iter_point).first;
int pre_point_indx = (*iter_point).second;
int cur_point_pos, cur_point_indx;
++iter_point;
for (; iter_point != ::track_points.end(); ++iter_point) {
cur_point_pos = (*iter_point).first;
cur_point_indx = (*iter_point).second;
::graph_of_tracks[pre_point_indx].push_back(
std::pair<int, std::pair<int, int> >(
cur_point_indx,
std::pair<int, int>((cur_point_pos - pre_point_pos), 0)));
::graph_of_tracks[cur_point_indx].push_back(
std::pair<int, std::pair<int, int> >(
pre_point_indx,
std::pair<int, int>((cur_point_pos - pre_point_pos), 0)));
pre_point_pos = cur_point_pos;
pre_point_indx = cur_point_indx;
}
Dijcstra(0, 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30000 + 10;
const int maxm = 600000 + 10;
const int P = 1e7 + 19;
const int Q = 1e9 + 7;
struct Edge {
int next, v;
Edge() {}
Edge(int next, int v) : next(next), v(v) {}
} e[maxm];
struct Exhibit {
int l, r, v, w;
Exhibit() {
l = 1;
r = 100000;
}
} a[maxn];
int n, m, q, K;
int head[maxm], cnt;
int dp[20][maxn];
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
void Insert(int o, int l, int r, int ql, int qr, int p) {
if (ql <= l && r <= qr) {
e[++cnt] = Edge(head[o], p);
head[o] = cnt;
return;
}
int mid = (l + r) >> 1, lson = o << 1, rson = lson | 1;
if (ql <= mid) Insert(lson, l, mid, ql, qr, p);
if (qr > mid) Insert(rson, mid + 1, r, ql, qr, p);
}
void solve(int o, int l, int r, int dep) {
for (int i = 1; i <= K; i++) dp[dep][i] = dp[dep - 1][i];
for (int i = head[o], val, w; i; i = e[i].next) {
int v = e[i].v;
val = a[v].v, w = a[v].w;
for (int k = K - w; k >= 0; k--)
dp[dep][k + w] = max(dp[dep][k + w], dp[dep][k] + val);
}
if (l == r) {
long long res = 0;
for (int i = K; i >= 1; i--) {
res = res * P;
res = (res + dp[dep][i]) % Q;
}
printf("%d\n", res);
return;
}
int mid = (l + r) >> 1, lson = o << 1, rson = lson | 1;
solve(lson, l, mid, dep + 1);
solve(rson, mid + 1, r, dep + 1);
}
int main() {
if (fopen("in.in", "r") != NULL) {
freopen("in.in", "r", stdin);
freopen("out.out", "w", stdout);
}
n = read(), K = read();
for (int i = 1; i <= n; i++) a[i].v = read(), a[i].w = read();
m = read();
for (int i = 1, op; i <= m; i++) {
op = read();
if (op == 1) {
n++;
a[n].v = read(), a[n].w = read();
a[n].l = q + 1;
} else if (op == 2) {
op = read();
a[op].r = q;
} else
q++;
}
for (int i = 1; i <= n; i++) {
if (a[i].r == 100000) a[i].r = q;
if (a[i].l <= a[i].r) Insert(1, 1, q, a[i].l, a[i].r, i);
}
solve(1, 1, q, 1);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string n, m;
cin >> n >> m;
int cn[26] = {0}, cm[26] = {0};
for (int i = 0; i < n.size(); i++) cn[n[i] - 'a']++;
for (int i = 0; i < m.size(); i++) cm[m[i] - 'a']++;
int res = 0;
for (int i = 0; i < 26; i++) {
res += min(cn[i], cm[i]);
if (cm[i] != 0 and cn[i] == 0) {
cout << -1;
return 0;
}
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, flag = 1;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
if (a[i - 1] <= a[i]) {
cout << "YES" << endl;
flag = 0;
break;
}
}
if (flag) cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 10;
int ans[maxn], cnt, data[maxn];
vector<int> son[maxn];
void dfs(int u, int fa, int now, int next) {
if (now) data[u] ^= 1;
if (data[u]) {
ans[cnt++] = u;
now ^= 1;
}
for (vector<int>::iterator it = son[u].begin(); it != son[u].end(); ++it) {
if (*it != fa) dfs(*it, u, next, now);
}
}
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= n; ++i) son[i].clear();
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
son[a].push_back(b);
son[b].push_back(a);
}
for (int i = 1; i <= n; ++i) {
cin >> data[i];
}
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
data[i] ^= x;
}
cnt = 0;
dfs(1, -1, 0, 0);
sort(ans, ans + cnt);
printf("%d\n", cnt);
for (int i = 0; i < cnt; ++i) cout << ans[i] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 605;
const int M = 605;
int n, m, k;
int a[M], b[M];
int deg[N];
vector<int> edges_matched_to_vertex[N];
int col[M];
const int INF = 1000000000;
struct Edge {
int from, to, cap, flow, index;
Edge(int from, int to, int cap, int flow, int index)
: from(from), to(to), cap(cap), flow(flow), index(index) {}
};
struct Dinic {
int N;
vector<vector<Edge>> G;
vector<Edge *> dad;
vector<int> Q;
Dinic(int N) : N(N), G(N), dad(N), Q(N) {}
void AddEdge(int from, int to, int cap) {
G[from].push_back(Edge(from, to, cap, 0, G[to].size()));
if (from == to) G[from].back().index++;
G[to].push_back(Edge(to, from, 0, 0, G[from].size() - 1));
}
long long BlockingFlow(int s, int t) {
fill(dad.begin(), dad.end(), (Edge *)NULL);
dad[s] = &G[0][0] - 1;
int head = 0, tail = 0;
Q[tail++] = s;
while (head < tail) {
int x = Q[head++];
for (int i = 0; i < G[x].size(); i++) {
Edge &e = G[x][i];
if (!dad[e.to] && e.cap - e.flow > 0) {
dad[e.to] = &G[x][i];
Q[tail++] = e.to;
}
}
}
if (!dad[t]) return 0;
long long totflow = 0;
for (int i = 0; i < G[t].size(); i++) {
Edge *start = &G[G[t][i].to][G[t][i].index];
int amt = INF;
for (Edge *e = start; amt && e != dad[s]; e = dad[e->from]) {
if (!e) {
amt = 0;
break;
}
amt = min(amt, e->cap - e->flow);
}
if (amt == 0) continue;
for (Edge *e = start; amt && e != dad[s]; e = dad[e->from]) {
e->flow += amt;
G[e->to][e->index].flow -= amt;
}
totflow += amt;
}
return totflow;
}
long long GetMaxFlow(int s, int t) {
long long totflow = 0;
while (long long flow = BlockingFlow(s, t)) totflow += flow;
return totflow;
}
};
void err() {
for (int i = 1; i <= m; i++) {
cout << "0 ";
}
cout << endl;
}
void solve() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
deg[i] = 0;
edges_matched_to_vertex[i].clear();
}
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
col[i] = 0;
deg[a[i]]++;
deg[b[i]]++;
}
Dinic mf(m + n + 2);
for (int i = 1; i <= m; i++) {
if (max(deg[a[i]], deg[b[i]]) > 2 * k) {
err();
return;
}
if (deg[a[i]] > k) {
mf.AddEdge(i, m + a[i], 1);
}
if (deg[b[i]] > k) {
mf.AddEdge(i, m + b[i], 1);
}
}
for (int i = 1; i <= m; i++) {
mf.AddEdge(0, i, 1);
}
int sum = 0;
for (int i = m + 1; i <= m + n; i++) {
if (deg[i - m] > k) {
mf.AddEdge(i, m + n + 1, 2 * (deg[i - m] - k));
sum += 2 * (deg[i - m] - k);
}
}
int max_flow = mf.GetMaxFlow(0, m + n + 1);
if (max_flow < sum) {
err();
return;
}
int color = 0;
vector<vector<Edge>> residual = mf.G;
for (int edge = 1; edge <= m; edge++) {
for (auto e : residual[edge]) {
int vertex = e.to;
if (e.flow == 1) {
edges_matched_to_vertex[vertex - m].push_back(edge);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)edges_matched_to_vertex[i].size(); j += 2) {
col[edges_matched_to_vertex[i][j]] =
col[edges_matched_to_vertex[i][j + 1]] = ++color;
}
}
for (int i = 1; i <= m; i++) {
if (col[i] == 0) {
col[i] = ++color;
}
cout << col[i] << ' ';
}
cout << endl;
}
int main() {
ios ::sync_with_stdio(false);
int z;
cin >> z;
while (z--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y;
long long dp[30000050];
long long minn(long long a, long long b) {
if (a > b) return b;
return a;
}
int main() {
cin >> n >> x >> y;
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
dp[1] = x;
for (int i = 2; i <= n; i++) {
if (i % 2) {
dp[i] = minn(dp[i - 1] + x, dp[i + 1] + x);
} else {
dp[i] = minn(dp[i - 1] + x, dp[i / 2] + y);
}
dp[i * 2] = dp[i] + y;
}
cout << dp[n] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n, k, d;
int dem = 0, a[200005], mi = 1000000, i;
vector<int> cou;
for (i = 0; i < 1000003; i++) cou.push_back(0);
cin >> n >> k >> d;
t--;
for (i = 0; i < n; i++) {
cin >> a[i];
if (cou[a[i]] == 0) {
cou[a[i]]++;
dem++;
} else
cou[a[i]]++;
if (i >= d - 1) {
mi = min(mi, dem);
cou[a[i - (d - 1)]]--;
if (cou[a[i - (d - 1)]] == 0) dem--;
}
}
cout << mi << "\n";
while (t--) {
for (i = n - 1; i >= n - d; i--) cou[a[i]] = 0;
cin >> n >> k >> d;
dem = 0;
mi = 1000000;
for (i = 0; i < n; i++) {
cin >> a[i];
if (cou[a[i]] == 0) {
cou[a[i]]++;
dem++;
} else
cou[a[i]]++;
if (i >= d - 1) {
mi = min(mi, dem);
cou[a[i - (d - 1)]]--;
if (cou[a[i - (d - 1)]] == 0) dem--;
}
}
cout << mi << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
map<char, int> mmap;
for (int i = 0; i < s.size(); i++) {
mmap[s[i]]++;
}
int a = 0, b = 0;
for (int i = 0; i <= s.size(); i++) {
if (mmap['z'] == i and mmap['r'] == i) {
int x = mmap['e'] - mmap['z'];
if (mmap['o'] == mmap['e'] and mmap['n'] == x) {
a = i;
b = x;
break;
}
}
}
for (int i = 1; i <= b; i++) {
cout << 1 << " ";
}
for (int i = 1; i <= a; i++) {
cout << 0 << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int a[n], g[n];
int sa = 0, sg = 0;
char ans[n];
for (int i = 0; i < n; ++i) {
cin >> a[i] >> g[i];
}
for (int i = 0; i < n; ++i) {
sa += a[i];
if (sa <= 500) {
ans[i] = 'A';
} else if (sa > 500) {
sa -= 1000;
ans[i] = 'G';
} else {
cout << "-1";
return 0;
}
}
for (int i = 0; i < n; ++i) {
cout << ans[i];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main(void) {
int n, i;
scanf("%d", &n);
for (i = 1; i <= n * 2 / 3; i++) printf("0 %d\n", i);
for (i = 1; i <= n - n * 2 / 3; i++) printf("3 %d\n", i * 2);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[100005];
int n, k;
cin >> n >> k;
for (int i = 0; i < n; cin >> arr[i++])
;
int ass[260];
for (int i = 0; i < 260; ass[i++] = -1)
;
if (arr[0] == 0) ass[0] = 0;
for (int i = 0; i < n; i++) {
if (ass[arr[i]] == -1) {
for (int cnt = k; cnt > 0; cnt--) {
if (arr[i] - cnt + 1 >= 0 && ass[arr[i] - cnt + 1] == -1) {
for (int j = cnt; j > 0; j--) {
ass[arr[i] - j + 1] = arr[i] - cnt + 1;
}
break;
} else {
if (arr[i] - cnt + 1 >= 0 && arr[i] - ass[arr[i] - cnt + 1] < k) {
for (int j = cnt; j > 0; j--) {
ass[arr[i] - j + 1] = arr[i] - cnt + 1;
}
break;
}
}
}
}
}
for (int i = 0; i < n; i++) {
cout << ass[arr[i]] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, c = 0;
cin >> t;
for (int i = 0; i < t; i++) {
int a, b;
cin >> a >> b;
if (a != b) {
c++;
}
}
if (c) {
cout << "Happy Alex";
} else {
cout << "Poor Alex";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
namespace ywy {
inline int get() {
int n = 0;
char c;
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9') break;
if (c == '-') goto s;
}
n = c - '0';
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 + c - '0';
else
return (n);
}
s:
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 - c + '0';
else
return (n);
}
}
typedef struct _b {
int dest;
int nxt;
int c;
} bian;
bian memchi[1000001];
int gn = 2, heads[30001], id[30001], que[30001];
inline void add(int s, int t, int c) {
memchi[gn].dest = t;
memchi[gn].nxt = heads[s];
memchi[gn].c = c;
heads[s] = gn;
gn++;
}
int s, t;
inline int bfs() {
int head = 0, tail = 1;
que[0] = t;
memset(id, 0, sizeof(id));
id[t] = 1;
do {
int me = que[head];
head++;
for (register int i = heads[me]; i; i = memchi[i].nxt) {
if (!memchi[i ^ 1].c || id[memchi[i].dest]) continue;
id[memchi[i].dest] = id[me] + 1;
if (memchi[i].dest == s) return (1);
que[tail] = memchi[i].dest;
tail++;
}
} while (head < tail);
return (0);
}
int dfs(int pt, int flow) {
if (pt == t) return (flow);
int rest = flow;
for (register int i = heads[pt]; i && rest; i = memchi[i].nxt) {
if (!memchi[i].c || id[memchi[i].dest] != id[pt] - 1) continue;
int cjr = dfs(memchi[i].dest, min(rest, memchi[i].c));
if (!cjr) id[memchi[i].dest] = 0;
rest -= cjr;
memchi[i].c -= cjr;
memchi[i ^ 1].c += cjr;
}
return (flow - rest);
}
int ints[100001];
void ywymain() {
int n = get(), m = get(), g = get();
int gpt = n + 1;
s = gpt;
gpt++;
t = gpt;
gpt++;
for (register int i = 1; i <= n; i++) ints[i] = get();
for (register int i = 1; i <= n; i++) {
int v = get();
if (!ints[i])
add(s, i, v), add(i, s, 0);
else
add(i, t, v), add(t, i, 0);
}
int ans = 0;
while (m) {
m--;
int x = get(), val = get(), k = get();
ans += val;
int me = gpt;
gpt++;
while (k) {
k--;
int a = get();
if (x)
add(a, me, 1234567890), add(me, a, 0);
else
add(me, a, 1234567890), add(a, me, 0);
}
int lose = g * get();
if (x)
add(me, t, lose + val), add(t, me, 0);
else
add(s, me, lose + val), add(me, s, 0);
}
while (bfs()) {
while (1) {
int cjr = dfs(s, 1234567890);
if (!cjr) break;
ans -= cjr;
}
}
cout << ans << endl;
}
} // namespace ywy
int main() {
ywy::ywymain();
return (0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
vector<int> m;
int main() {
for (int i = 1; i <= 200000; i++) a[i] = -1000000;
int n;
cin >> n;
for (int step = 1; step <= n; step++) {
int x, y;
cin >> x >> y;
m.clear();
int k = 0;
for (int i = 1; i * i <= x; i++)
if ((x % i) == 0) {
m.push_back(i);
if (a[i] + y < step) {
k++;
}
if ((x / i) != i) {
m.push_back(x / i);
if (a[x / i] + y < step) k++;
}
}
cout << k << "\n";
for (int i = 0; i < m.size(); i++) a[m[i]] = step;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 100000000000000000LL;
const double eps = 1e-9;
const int maxn = 100000 + 10;
bool compare(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
struct edge {
pair<int, int> u, v;
};
void print(pair<int, int> a) { cout << a.first << "::" << a.second << " "; }
pair<int, int> dfs(vector<pair<int, int> > &diag, vector<edge> &edges, int &p) {
vector<pair<int, int> > neig;
int b, e;
int c = p++;
for (; p < (int)diag.size() && diag[p].first < diag[c].second;) {
b = diag[p].first, e = diag[p].second;
neig.push_back(dfs(diag, edges, p));
}
if (neig.empty()) return {diag[c].second, diag[c].second - 1};
pair<int, int> id(diag[c].second, diag[c].second - 1);
if (e == diag[c].second) id.second = b;
for (auto nn : neig) {
edges.push_back({id, nn});
}
return id;
}
bool mk[maxn];
int q[maxn], p[maxn], sz[maxn], mc[maxn];
int answer[maxn];
int centroid(int c, vector<vector<int> > &adj) {
int b = 0, e = 0;
q[e++] = c, p[c] = -1, sz[c] = 1, mc[c] = 0;
while (b < e) {
int u = q[b++];
for (auto v : adj[u])
if (v != p[u] && !mk[v]) p[v] = u, sz[v] = 1, mc[v] = 0, q[e++] = v;
}
for (int i = e - 1; ~i; --i) {
int u = q[i];
int bc = max(e - sz[u], mc[u]);
if (2 * bc <= e) return u;
sz[p[u]] += sz[u], mc[p[u]] = max(mc[p[u]], sz[u]);
}
assert(false);
return -1;
}
void calc(int u, vector<vector<int> > &adj, int v) {
int c = centroid(u, adj);
mk[c] = true;
answer[c] = v;
for (auto neig : adj[c]) {
if (mk[neig]) continue;
calc(neig, adj, v + 1);
}
}
void solve(vector<vector<int> > &adj) {
int n = (int)adj.size();
calc(0, adj, 1);
for (int i = 0; i < n; ++i) cout << answer[i] << " ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
if (m == 0) {
cout << 1 << '\n';
return 0;
}
vector<pair<int, int> > diag(m);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
diag[i] = pair<int, int>(u, v);
}
diag.push_back(pair<int, int>(1, n));
sort(diag.begin(), diag.end(), compare);
vector<edge> edges;
int pos = 0;
dfs(diag, edges, pos);
vector<pair<int, int> > nodes;
for (auto &e : edges) {
nodes.push_back(e.u);
nodes.push_back(e.v);
}
sort(nodes.begin(), nodes.end());
nodes.resize(unique(nodes.begin(), nodes.end()) - nodes.begin());
int total = nodes.size();
vector<vector<int> > adj(total);
for (auto &e : edges) {
int pu = lower_bound(nodes.begin(), nodes.end(), e.u) - nodes.begin();
int pv = lower_bound(nodes.begin(), nodes.end(), e.v) - nodes.begin();
adj[pu].push_back(pv);
adj[pv].push_back(pu);
}
solve(adj);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
swap(s[1], s[4]);
swap(s[1], s[2]);
int n = stoi(s);
long long ans = 1;
for (int i = 0; i < 5; i++) {
ans *= n;
ans %= 100000;
}
cout << setfill('0') << setw(5) << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void Genawy() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int n, cost[305];
int length[305];
map<pair<int, int>, int> dp;
int solve(int ind, int gc) {
if (ind == n) return gc == 1 ? 0 : 1e9;
if (dp.find({ind, gc}) != dp.end()) return dp[{ind, gc}];
dp[{ind, gc}] = solve(ind + 1, gc);
dp[{ind, gc}] =
min(dp[{ind, gc}], solve(ind + 1, gcd(gc, length[ind])) + cost[ind]);
return dp[{ind, gc}];
}
int main() {
Genawy();
cin >> n;
for (int i = 0; i < n; i++) cin >> length[i];
for (int i = 0; i < n; i++) cin >> cost[i];
int ans = solve(0, 0);
if (ans >= 1e9) ans = -1;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
const int mod = 1e9 + 7;
int n, m;
int c[maxn];
int lowbit(int x) { return x & (-x); }
void add(int pos, int x) {
while (pos <= n) {
c[pos] += x;
pos += lowbit(pos);
}
}
void update(int l, int r) { add(l, 1), add(r + 1, -1); }
int get(int pos) {
int ans = 0;
while (pos > 0) {
ans += c[pos];
pos -= lowbit(pos);
}
return ans;
}
void solve() {}
int main() {
cin >> n >> m;
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
update(a, b);
}
bool flag = false;
int pos;
for (int i = 1; i <= n; i++) {
if (get(i) != 1) {
flag = true;
pos = i;
break;
}
}
if (flag) {
cout << pos << " " << get(pos) << endl;
} else {
cout << "OK" << endl;
}
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string p[n], e[m];
if (n > m) cout << "YES";
if (n < m) cout << "NO";
if (n == m) {
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) cin >> e[i];
int t = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (p[i] == e[j]) {
t++;
break;
}
}
}
if (t % 2 != 0)
cout << "YES";
else
cout << "NO";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200005], b[200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
v.push_back(make_pair(b[i], i));
}
sort(v.begin(), v.end());
sort(a, a + n);
reverse(a, a + n);
for (int i = 0; i < n; i++) {
b[v[i].second] = a[i];
}
for (int i = 0; i < n; i++) {
printf("%d ", b[i]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long readi() {
long long input = 0;
char c = ' ';
while (c < '-') {
c = getchar();
}
bool negative = false;
if (c == '-') {
negative = true;
c = getchar();
}
while (c >= '0') {
input = 10 * input + (c - '0');
c = getchar();
}
if (negative) {
input = -input;
}
return input;
}
string reads() {
string input = "";
char c = ' ';
while (c <= ' ') {
c = getchar();
}
while (c > ' ') {
input += c;
c = getchar();
}
return input;
}
void printi(long long output) {
if (output == 0) {
putchar('0');
return;
}
if (output < 0) {
putchar('-');
output = -output;
}
vector<char> vout;
while (output) {
vout.push_back((output % 10) + '0');
output /= 10;
}
for (int i = vout.size() - 1; i >= 0; i--) {
putchar(vout[i]);
}
return;
}
void prints(string output) {
for (int i = 0; i < output.length(); i++) {
putchar(output[i]);
}
return;
}
int N;
int deg[55];
long long dp[2][55][55][55][55];
void ADD(int b, int c, int d, int e, long long num) {
if (b < 0 || c < 0 || d < 0 || e < 0 || b > N || c > N || d > N || e > N ||
num == 0) {
return;
}
num %= 1000000007;
dp[1][b][c][d][e] += num;
dp[1][b][c][d][e] %= 1000000007;
return;
}
long long choose(long long x) {
x %= 1000000007;
long long res = ((x) * (x - 1)) / 2ll;
res %= 1000000007;
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
if (fopen("cf814e.in", "r")) {
freopen("cf814e.in", "r", stdin);
freopen("cf814e.out", "w", stdout);
}
cin >> N;
for (int i = 0; i < N; i++) {
cin >> deg[i];
}
if (deg[0] == 2) {
if (deg[1] == 2) {
dp[0][1][0][1][0] = 1;
} else {
dp[0][1][0][0][1] = 1;
}
} else {
if (deg[1] == 2) {
dp[0][0][1][1][0] = 1;
} else {
dp[0][0][1][0][1] = 1;
}
}
for (int i = 2; i < N; i++) {
for (long long j = 0; j <= N; j++) {
for (long long k = 0; j + k <= N; k++) {
for (long long m = 0; m <= N; m++) {
for (long long n = 0; m + n <= N; n++) {
long long cdp = dp[0][j][k][m][n];
if (cdp == 0) {
continue;
}
if (j == 0 && k == 0) {
dp[0][m][n][0][0] += cdp;
continue;
}
if (deg[i] == 2) {
ADD(j - 1, k, m + 1, n, j * cdp);
ADD(j + 1, k - 1, m + 1, n, k * cdp);
ADD(j - 1, k, m - 1, n, j * m * cdp);
ADD(j + 1, k - 1, m - 1, n, k * m * cdp);
ADD(j - 1, k, m + 1, n - 1, j * n * cdp);
ADD(j + 1, k - 1, m + 1, n - 1, k * n * cdp);
} else {
ADD(j - 1, k, m, n + 1, j * cdp);
ADD(j + 1, k - 1, m, n + 1, k * cdp);
ADD(j - 1, k, m, n, j * m * cdp);
ADD(j + 1, k - 1, m, n, k * m * cdp);
ADD(j - 1, k, m + 2, n - 1, j * n * cdp);
ADD(j + 1, k - 1, m + 2, n - 1, k * n * cdp);
ADD(j - 1, k, m - 2, n, j * choose(m) * cdp);
ADD(j + 1, k - 1, m - 2, n, k * choose(m) * cdp);
ADD(j - 1, k, m + 2, n - 2, j * choose(n) * cdp);
ADD(j + 1, k - 1, m + 2, n - 2, k * choose(n) * cdp);
ADD(j - 1, k, m, n - 1, j * m * n * cdp);
ADD(j + 1, k - 1, m, n - 1, k * m * n * cdp);
}
}
}
}
}
for (long long j = 0; j <= N; j++) {
for (long long k = 0; j + k <= N; k++) {
for (long long m = 0; m <= N; m++) {
for (long long n = 0; m + n <= N; n++) {
dp[0][j][k][m][n] = dp[1][j][k][m][n];
dp[1][j][k][m][n] = 0;
}
}
}
}
}
cout << dp[0][0][0][0][0] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int arr1[5][5], i, m, t, q, n, j, sum = 0;
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
scanf("%d", &arr1[i][j]);
}
}
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
if (arr1[i][j] == 1) {
t = i;
q = j;
}
}
}
m = 2 - t;
m = abs(m);
n = 2 - q;
n = abs(n);
sum = m + n;
printf("%d", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, m, t1, t2, t3, lim;
int dep[N], vis[N], fg[N];
vector<int> g[N];
vector<int> sta;
void dfs1(int p) {
sta.push_back(p);
vis[p] = 1;
for (int q : g[p]) {
if (!vis[q]) {
dep[q] = dep[p] + 1;
dfs1(q);
} else {
if (dep[q] && dep[p] - dep[q] >= lim - 1) {
cout << 2 << endl << dep[p] - dep[q] + 1 << endl;
while (sta.back() != q && sta.size()) {
cout << sta.back() << " ";
sta.pop_back();
}
cout << q << endl;
exit(0);
}
}
}
sta.pop_back();
}
void dfs2(int p) {
vis[p] = 1;
for (int q : g[p]) {
if (!vis[q]) dfs2(q);
}
for (int q : g[p])
if (!fg[p]) fg[q] = 1;
}
signed main() {
ios::sync_with_stdio(false);
cin >> n >> m;
lim = 1;
while (lim * lim < n) ++lim;
for (int i = 1; i <= m; i++) {
cin >> t1 >> t2;
g[t1].push_back(t2);
g[t2].push_back(t1);
}
dep[1] = 1;
dfs1(1);
memset(vis, 0, sizeof vis);
dfs2(1);
int cnt = lim;
cout << 1 << endl;
for (int i = 1; i <= n && cnt; i++) {
if (!fg[i]) cout << i << " ", --cnt;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dcmp(double a, double b) {
return fabs(a - b) <= 0.00000000000001 ? 0 : (a > b) ? 1 : -1;
}
int p[1000000 + 9], dp[1000009];
int maxi = 1000009;
int main() {
int i, n, no, b;
cin >> n;
for (i = 0; i < n; i++) {
cin >> no >> b;
p[no] = b;
}
if (p[0] > 0) {
dp[0] = 1;
}
int mx = 0;
for (i = 1; i < maxi; i++) {
if (p[i] == 0) {
dp[i] = dp[i - 1];
} else {
if (p[i] >= i) {
dp[i] = 1;
} else {
dp[i] = dp[i - p[i] - 1] + 1;
}
}
if (dp[i] > mx) {
mx = dp[i];
}
}
cout << n - mx;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> my;
struct state {
int len, link;
int nexto[28];
};
const int MAXLEN = 2005000;
state st[MAXLEN];
int vis[MAXLEN], cnt[MAXLEN], casio = 1;
int sz = 0, last = 0;
void sa_init() {
sz = last = 0;
st[0].len = 0;
st[0].link = -1;
for (int i = 0; i < 26; i++) st[sz].nexto[i] = -1;
++sz;
}
int nw() {
for (int i = 0; i < 26; i++) st[sz].nexto[i] = -1;
sz++;
return sz - 1;
}
void cp(int clone, int q) {
for (int i = 0; i < 26; i++) {
st[clone].nexto[i] = st[q].nexto[i];
}
}
void sa_extend(int c) {
int cur = nw();
cnt[cur] = 1;
st[cur].len = st[last].len + 1;
int p;
for (p = last; p != -1 && st[p].nexto[c] == -1; p = st[p].link)
st[p].nexto[c] = cur;
if (p == -1)
st[cur].link = 0;
else {
int q = st[p].nexto[c];
if (st[p].len + 1 == st[q].len)
st[cur].link = q;
else {
int clone = nw();
st[clone].len = st[p].len + 1;
cp(clone, q);
st[clone].link = st[q].link;
for (; p != -1 && st[p].nexto[c] == q; p = st[p].link)
st[p].nexto[c] = clone;
st[q].link = st[cur].link = clone;
}
}
last = cur;
}
char str[3000000], red[3000000];
string pat;
int len, R;
int ans = 0;
void getans(int node, int indx) {
while (node && st[st[node].link].len >= R) {
node = st[node].link;
len = st[node].len;
}
if (len >= R && vis[node] != casio) {
ans += cnt[node];
vis[node] = casio;
}
if (pat[indx] == '\0') return;
int c = pat[indx] - 97, i;
for (i = node; i && st[i].nexto[c] == -1;) {
i = st[i].link;
len = st[i].len;
}
if (st[i].nexto[c] != -1) {
len++;
i = st[i].nexto[c];
}
getans(i, indx + 1);
}
int main() {
int i, j, k, l, m, n;
scanf("%s", str);
m = strlen(str);
sa_init();
for (int i = 0; str[i]; i++) {
sa_extend(str[i] - 97);
}
for (int i = 1; i < sz; i++) {
my.push_back(make_pair(st[i].len, i));
}
sort(my.begin(), my.end());
for (int i = my.size() - 1; i >= 0; i--) {
l = my[i].second;
cnt[st[l].link] += cnt[l];
}
scanf("%d", &l);
while (l--) {
casio++;
scanf("%s", red);
R = strlen(red);
pat = red;
pat += red;
pat.erase(pat.size() - 1);
len = 0;
ans = 0;
getans(0, 0);
printf("%d\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, cnt = 0, j, x;
double c;
cin >> n;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
c = sqrt(i * i + j * j);
x = (int)c;
if (x > n) break;
if (x == c) cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
register long long x = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * w;
}
long long a[500005 << 2], mod, k;
int l[500005 << 2], r[500005 << 2];
long long lgcd(long long a, long long b, long long c, long long n) {
if (!a) return 0;
if (a >= c || b >= c) {
return (((a / c) * (n * (n + 1) / 2) + (b / c) * (n + 1)) % mod +
lgcd(a % c, b % c, c, n) % mod) %
mod;
}
long long m = (a * n + b) / c;
return (((m % mod) * (n % mod)) % mod - lgcd(c, c - b - 1, a, m - 1) % mod +
mod) %
mod;
}
long long work(int i) {
return (lgcd(1, r[i] - i, k - 1, i - l[i]) - lgcd(1, 0, k - 1, i - l[i] - 1) +
mod) %
mod;
}
int main() {
long long n = read();
k = read();
mod = 1000000007;
long long ans = 0;
for (register int i = 1; i <= n; ++i) a[i] = read();
l[1] = 1, r[n] = n;
for (int i = 2; i <= n; ++i) {
int x = i;
while (x > 1 && a[i] >= a[x - 1]) x = l[x - 1];
l[i] = x;
}
for (int i = n - 1; i >= 1; --i) {
register int x = i;
while (x < n && a[i] > a[x + 1]) x = r[x + 1];
r[i] = x;
}
for (register int i = 1; i <= n; ++i) {
ans = (ans + ((work(i) % mod) * (a[i] % mod)) % mod) % mod;
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
string second, tmp;
int n, m;
string name[5050];
vector<string> v[5050];
vector<int> g[5050];
map<string, int> id;
int val[5050];
int get_operand(string &second) {
if (second == "OR") return 0;
if (second == "AND") return 1;
if (second == "XOR") return 2;
return -1;
}
int bin_op(int a, int op, int b) {
if (op == 0) return (a | b);
if (op == 1) return (a & b);
if (op == 2) return (a ^ b);
assert(false);
return -1;
}
bool is_name(string &second) {
if (id.count(second)) return true;
return false;
}
int get_id(string &second) {
if (id.count(second)) return id[second];
return -1;
}
int get(int ind, int bit) {
int ans = 0;
for (int i = 0; i < n; i++) {
val[i] = 0;
int op = 0;
for (int j = 0; j < v[i].size(); j++) {
int nop = g[i][j];
if (nop == -2)
nop = 0;
else if (nop == -3)
nop = 1;
else if (nop == -4)
nop = 2;
else
nop = -1;
if (nop != -1)
op = nop;
else {
if (g[i][j] == -1)
val[i] = bin_op(val[i], op, bit);
else if (g[i][j] >= 0 && g[i][j] < n) {
int p = g[i][j];
val[i] = bin_op(val[i], op, val[p]);
} else {
int x = v[i][j][ind] - '0';
val[i] = bin_op(val[i], op, x);
}
}
}
ans += val[i];
}
return ans;
}
int main() {
scanf("%d %d\n", &n, &m);
for (int i = 0; i < n; i++) {
getline(cin, second);
int cnt = 0;
string cur = "";
for (int j = 0; j < second.size(); j++) {
if (second[j] == ' ') {
if (cur.size() > 0) {
if (cnt == 0)
name[i] = cur;
else if (cnt == 1)
tmp = cur;
else
v[i].push_back(cur);
cnt++;
}
cur = "";
} else
cur += second[j];
}
if (cur.size() > 0) v[i].push_back(cur);
id[name[i]] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < v[i].size(); j++) {
if (v[i][j] == "?")
g[i].push_back(-1);
else if (v[i][j] == "OR")
g[i].push_back(-2);
else if (v[i][j] == "AND")
g[i].push_back(-3);
else if (v[i][j] == "XOR")
g[i].push_back(-4);
else if (is_name(v[i][j]))
g[i].push_back(get_id(v[i][j]));
else
g[i].push_back(-5);
}
}
string mn = "", mx = "";
for (int i = 0; i < m; i++) {
int ans0 = get(i, 0);
int ans1 = get(i, 1);
if (ans0 == ans1) {
mn += "0";
mx += "0";
} else if (ans0 < ans1) {
mn += "0";
mx += "1";
} else {
mn += "1";
mx += "0";
}
}
cout << mn << endl << mx << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, count1 = 0, count2 = 0;
cin >> n >> m;
int a[n], b[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
sort(a, a + n);
sort(b, b + m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
count1++;
cout << a[i] << endl;
break;
} else {
continue;
}
}
if (count1 > 0) {
break;
} else {
continue;
}
}
if (count1 == 0) {
if (a[0] > b[0]) {
cout << b[0] << a[0] << endl;
} else {
cout << a[0] << b[0] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 19999999;
int pos = 0, neg = 0;
int total = 0, mini = inf;
int n;
int main() {
scanf("%d", &n);
int a;
for (int i = 1; i < n * 2; i++) {
scanf("%d", &a);
if (a < 0) {
neg++;
a = -a;
} else
pos++;
total += a;
mini = min(a, mini);
}
if (n % 2 == 1)
printf("%d\n", total);
else if (neg % 2 == 0)
printf("%d\n", total);
else
printf("%d\n", total - mini * 2);
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.