solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
int n;
long long a[maxn];
map<long long, int> M;
int main() {
cin >> n;
long long sum = 0;
int ans = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
ans = max(ans, ++M[sum]);
}
cout << n - ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using llu = unsigned long long;
using ld = long double;
const double PI = acos(-1.0), g = 9.80665;
const int unseen = -1;
const ll inf = 1e18 + 505, ninf = -1e18 - 505;
const int MOD = 1000000007;
void solve(void) {
int limit, sum;
cin >> sum >> limit;
vector<int> ans;
for (int i = limit; i >= 1 && sum; i--) {
int val = i & -i;
if (sum - val >= 0) {
sum -= val;
ans.emplace_back(i);
}
}
if (sum)
cout << "-1";
else {
cout << ans.size() << '\n';
for (int it : ans) cout << it << ' ';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int testcase = 1;
for (int tc = 1; tc <= testcase; tc++) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char a[100][100]{
"zero", "one", "two", "three",
"four", "five", "six", "seven",
"eight", "nine", "ten", "eleven",
"twelve", "thirteen", "fourteen", "fifteen",
"sixteen", "seventeen", "eighteen", "nineteen",
"twenty", "twenty-one", "twenty-two", "twenty-three",
"twenty-four", "twenty-five", "twenty-six", "twenty-seven",
"twenty-eight", "twenty-nine", "thirty", "thirty-one",
"thirty-two", "thirty-three", "thirty-four", "thirty-five",
"thirty-six", "thirty-seven", "thirty-eight", "thirty-nine",
"forty", "forty-one", "forty-two", "forty-three",
"forty-four", "forty-five", "forty-six", "forty-seven",
"forty-eight", "forty-nine", "fifty", "fifty-one",
"fifty-two", "fifty-three", "fifty-four", "fifty-five",
"fifty-six", "fifty-seven", "fifty-eight", "fifty-nine",
"sixty", "sixty-one", "sixty-two", "sixty-three",
"sixty-four", "sixty-five", "sixty-six", "sixty-seven",
"sixty-eight", "sixty-nine", "seventy", "seventy-one",
"seventy-two", "seventy-three", "seventy-four", "seventy-five",
"seventy-six", "seventy-seven", "seventy-eight", "seventy-nine",
"eighty", "eighty-one", "eighty-two", "eighty-three",
"eighty-four", "eighty-five", "eighty-six", "eighty-seven",
"eighty-eight", "eighty-nine", "ninety", "ninety-one",
"ninety-two", "ninety-three", "ninety-four", "ninety-five",
"ninety-six", "ninety-seven", "ninety-eight", "ninety-nine"};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
cin >> n;
cout << a[n] << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<int> g[100020];
int us[1000000];
vector<long long> b;
long long dfs(int v) {
int i, u;
long long r = 1;
for (i = 0; i < (int)g[v].size(); i++) {
u = g[v][i];
if (us[u] == 0) {
us[u] = 1;
r = r + dfs(u);
}
}
return r;
}
int main() {
int i, a, c;
long long ans, sm;
scanf("%d %d %d", &n, &m, &k);
for (i = 1; i <= m; i++) {
scanf("%d %d", &a, &c);
g[a].push_back(c);
g[c].push_back(a);
}
memset(us, 0, sizeof(us));
for (i = 1; i <= n; i++) {
if (us[i] == 0) {
us[i] = 1;
b.push_back(dfs(i));
}
}
sm = 0;
ans = 1;
for (i = 0; i < (int)b.size(); i++) {
ans = ans * b[i];
if (ans >= k) ans = ans % k;
if (i >= 2) {
ans = ans * n;
if (ans >= k) ans = ans % k;
}
}
if (b.size() > 1)
printf("%d\n", (int)ans);
else
printf("%d\n", 1 % k);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << " = " << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << " = " << h << ",";
_dbg(sdbg + 1, t...);
}
const int N = 100 + 2, M = 100 + 2;
int t, n, m;
string nameList[N], messList[M];
bool f[M][N];
int trace[M][N];
vector<int> idList[M];
bool IsUsernameChar(char c) {
if ('a' <= c && c <= 'z') {
return true;
}
if ('A' <= c && c <= 'Z') {
return true;
}
if ('0' <= c && c <= '9') {
return true;
}
return false;
}
bool Check(string s, string t) {
int nt = t.size();
for (int i = 2; i + nt - 1 < s.size(); ++i) {
bool same = true;
for (int j = 0; j < t.size(); ++j) {
if (s[i + j] != t[j]) {
same = false;
break;
}
}
if (same) {
bool checkL = (i - 1 < 2) || (!IsUsernameChar(s[i - 1]));
bool checkR = (i + nt >= (int)s.size()) || (!IsUsernameChar(s[i + nt]));
if (checkL && checkR) {
return true;
}
}
}
return false;
}
void Solve() {
map<string, int> id;
for (int i = 1; i <= n; ++i) {
id[nameList[i]] = i;
}
for (int i = 1; i <= m; ++i) {
idList[i].clear();
if (messList[i][0] == '?') {
for (int j = 1; j <= n; ++j) {
if (!Check(messList[i], nameList[j])) {
idList[i].push_back(j);
}
}
} else {
for (int j = 0; j < messList[i].size(); ++j) {
if (messList[i][j] == ':') {
idList[i].push_back(id[messList[i].substr(0, j)]);
break;
}
}
}
}
for (int i = 0; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
f[i][j] = false;
trace[i][j] = 0;
}
}
f[0][0] = true;
for (int i = 0; i < m; ++i) {
for (int j = 0; j <= n; ++j) {
if (!f[i][j]) {
continue;
}
for (int nj : idList[i + 1]) {
if (nj == j) {
continue;
}
f[i + 1][nj] = true;
trace[i + 1][nj] = j;
}
}
}
int pos = 0;
for (int i = 1; i <= n; ++i) {
if (f[m][i]) {
pos = i;
}
}
if (pos == 0) {
cout << "Impossible\n";
return;
}
vector<int> vec;
int x = m;
while (x > 0) {
vec.push_back(pos);
pos = trace[x][pos];
x--;
}
reverse(begin(vec), end(vec));
assert(vec.size() == m);
for (int i = 1; i <= m; ++i) {
cout << nameList[vec[i - 1]];
if (messList[i][0] == '?') {
cout << messList[i].substr(1, (int)messList[i].size() - 1) << '\n';
} else {
cout << messList[i].substr(
nameList[idList[i][0]].size(),
(int)messList[i].size() - (int)nameList[idList[i][0]].size())
<< '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> nameList[i];
}
cin >> m;
cin.ignore();
for (int i = 1; i <= m; ++i) {
getline(cin, messList[i]);
}
Solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string ans;
int i = 0;
map<string, int> mp, mp2;
string na[1000];
int sc[1000];
for (i = 0; i < n; i++) {
cin >> na[i] >> sc[i];
mp[na[i]] += sc[i];
}
int max_v = 0;
i = 0;
while (i < n) {
max_v = max(max_v, mp[na[i]]);
i++;
}
i = 0;
while (i < n) {
mp2[na[i]] += sc[i];
if (mp[na[i]] == max_v && mp2[na[i]] >= max_v) {
cout << na[i] << endl;
break;
}
i++;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
typedef double ld;
struct C {
ld real, imag;
C operator*(const C& he) const {
return C{real * he.real - imag * he.imag, real * he.imag + imag * he.real};
}
void operator+=(const C& he) {
real += he.real;
imag += he.imag;
}
};
void dft(vector<C>& a, bool rev) {
const int n = a.size();
for (int i = 1, k = 0; i < n; ++i) {
for (int bit = n / 2; (k ^= bit) < bit; bit /= 2)
;
;
;
if (i < k) swap(a[i], a[k]);
}
for (int len = 1, who = 0; len < n; len *= 2, ++who) {
static vector<C> t[30];
vector<C>& om = t[who];
if (om.empty()) {
om.resize(len);
const ld ang = 2 * acosl(0) / len;
for (int i = 0; i < int(len); ++i)
om[i] =
i % 2 || !who ? C{cos(i * ang), sin(i * ang)} : t[who - 1][i / 2];
}
for (int i = 0; i < n; i += 2 * len)
for (int k = 0; k < int(len); ++k) {
const C x = a[i + k],
y = a[i + k + len] * C{om[k].real, om[k].imag * (rev ? -1 : 1)};
a[i + k] += y;
a[i + k + len] = C{x.real - y.real, x.imag - y.imag};
}
}
if (rev)
for (int i = 0; i < int(n); ++i) a[i].real /= n;
}
template <typename T>
vector<T> multiply(const vector<T>& a, const vector<T>& b, bool split = false) {
if (a.empty() || b.empty()) return {};
int n = a.size() + b.size();
vector<T> ans(n - 1);
n = 1 << (32 - __builtin_clz(a.size() + b.size() - 1));
auto speed = [&](const vector<C>& w, int i, int k) {
int j = i ? n - i : 0, r = k ? -1 : 1;
return C{w[i].real + w[j].real * r, w[i].imag - w[j].imag * r} *
(k ? C{0, -0.5} : C{0.5, 0});
};
if (!split) {
vector<C> in(n), done(n);
for (int i = 0; i < int(a.size()); ++i) in[i].real = a[i];
for (int i = 0; i < int(b.size()); ++i) in[i].imag = b[i];
dft(in, false);
for (int i = 0; i < int(n); ++i)
done[i] = speed(in, i, 0) * speed(in, i, 1);
dft(done, true);
for (int i = 0; i < int(ans.size()); ++i)
ans[i] = is_integral<T>::value ? llround(done[i].real) : done[i].real;
} else {
const T M = 1 << 15;
vector<C> t[2];
for (int x = 0; x < int(2); ++x) {
t[x].resize(n);
auto& in = x ? b : a;
for (int i = 0; i < int(in.size()); ++i)
t[x][i] = C{ld(in[i] % M), ld(in[i] / M)};
dft(t[x], false);
}
T mul = 1;
for (int s = 0; s < 3; ++s, mul *= M) {
vector<C> prod(n);
for (int x = 0; x < int(2); ++x)
for (int y = 0; y < int(2); ++y)
if (x + y == s)
for (int i = 0; i < int(n); ++i)
prod[i] += speed(t[0], i, x) * speed(t[1], i, y);
dft(prod, true);
for (int i = 0; i < int(ans.size()); ++i)
ans[i] += llround(prod[i].real) * mul;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, x;
cin >> n >> x;
vector<long long> a(n + 1, 0);
a[0] = 1;
int val = 0;
long long curans = 0;
long long cnt = 0;
for (int i = 0; i < n; ++i) {
int y;
cin >> y;
if (y < x) {
val++;
curans += (cnt * (cnt + 1)) / 2;
cnt = 0;
} else {
cnt++;
}
a[val]++;
}
curans += (cnt * (cnt + 1)) / 2;
auto b = a;
reverse(b.begin(), b.end());
auto ans = multiply(a, b);
cout << curans;
for (int i = 1; i <= n; ++i) {
cout << ' ' << ans[i + n];
}
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
vector<int> v;
deque<int> d;
map<int, int> us;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
cout << (n / k + 1) * k;
exit(0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int sz;
int ans[4];
int lpref[2];
int lsuff[2];
int apref[2];
int asuff[2];
Node() {
sz = 0;
fill(ans, ans + 4, 0);
fill(lpref, lpref + 2, 0);
fill(lsuff, lsuff + 2, 0);
fill(apref, apref + 2, 0);
fill(asuff, asuff + 2, 0);
}
Node(int x) {
sz = 1;
fill(ans, ans + 4, 0);
fill(lpref, lpref + 2, 0);
fill(lsuff, lsuff + 2, 0);
ans[x] = 1;
ans[x + 2] = 1;
lpref[x] = 1;
lsuff[x] = 1;
fill(apref, apref + 2, 1);
fill(asuff, asuff + 2, 1);
}
Node(int sz_, int *ans_, int *lpref_, int *lsuff_, int *apref_, int *asuff_) {
sz = sz_;
for (int i = 0; i < 4; i++) {
ans[i] = ans_[i];
}
for (int i = 0; i < 2; i++) {
lpref[i] = lpref_[i];
lsuff[i] = lsuff_[i];
apref[i] = apref_[i];
asuff[i] = asuff_[i];
}
}
friend Node conq(const Node &l, const Node &r) {
int new_sz;
new_sz = l.sz + r.sz;
int new_ans[4];
new_ans[0] = max({l.ans[0], r.ans[0], l.lsuff[0] + r.lpref[0]});
new_ans[1] = max({l.ans[1], r.ans[1], l.lsuff[1] + r.lpref[1]});
new_ans[2] = max({l.ans[2], r.ans[2], l.lsuff[0] + r.lpref[1],
l.asuff[0] + r.lpref[1], l.lsuff[0] + r.apref[0]});
new_ans[3] = max({l.ans[3], r.ans[3], l.lsuff[1] + r.lpref[0],
l.asuff[1] + r.lpref[0], l.lsuff[1] + r.apref[1]});
int new_lpref[2];
for (int c = 0; c < 2; c++) {
new_lpref[c] = l.lpref[c];
if (l.lpref[c] == l.sz) new_lpref[c] += r.lpref[c];
}
int new_lsuff[2];
for (int c = 0; c < 2; c++) {
new_lsuff[c] = r.lsuff[c];
if (r.lsuff[c] == r.sz) new_lsuff[c] += l.lsuff[c];
}
int new_apref[2];
for (int f = 0; f < 2; f++) {
new_apref[f] = l.apref[f];
if (l.apref[f] == l.sz) {
if (l.lpref[f] == l.sz) {
new_apref[f] += r.apref[f];
} else {
new_apref[f] += r.lpref[f ^ 1];
}
}
}
int new_asuff[2];
for (int f = 0; f < 2; f++) {
new_asuff[f] = r.asuff[f];
if (r.asuff[f] == r.sz) {
if (r.lsuff[f ^ 1] == r.sz) {
new_asuff[f] += l.asuff[f];
} else {
new_asuff[f] += l.lsuff[f];
}
}
}
return Node(new_sz, new_ans, new_lpref, new_lsuff, new_apref, new_asuff);
}
Node inv() const {
int new_ans[4];
for (int i = 0; i < 4; i++) {
new_ans[i] = ans[i ^ 1];
}
int new_lpref[2];
for (int i = 0; i < 2; i++) {
new_lpref[i] = lpref[i ^ 1];
}
int new_lsuff[2];
for (int i = 0; i < 2; i++) {
new_lsuff[i] = lsuff[i ^ 1];
}
int new_apref[2];
for (int i = 0; i < 2; i++) {
new_apref[i] = apref[i ^ 1];
}
int new_asuff[2];
for (int i = 0; i < 2; i++) {
new_asuff[i] = asuff[i ^ 1];
}
return Node(sz, new_ans, new_lpref, new_lsuff, new_apref, new_asuff);
}
int solve() { return max({ans[0], ans[1], ans[2]}); }
};
const int N = 5e5 + 7;
namespace Segtree {
int n;
Node t[4 * N];
int mod[4 * N];
void pull(int v) { t[v] = conq(t[2 * v + 1], t[2 * v + 2]); }
void apply(int v) {
t[v] = t[v].inv();
mod[v] ^= 1;
}
void push(int v) {
if (mod[v]) {
apply(2 * v + 1);
apply(2 * v + 2);
mod[v] = 0;
}
}
void build(int v, int l, int r, vector<int> &a) {
if (l + 1 == r) {
t[v] = Node(a[l]);
} else {
int m = (r + l) >> 1;
build(2 * v + 1, l, m, a);
build(2 * v + 2, m, r, a);
pull(v);
}
}
void inv(int v, int l, int r, int ql, int qr) {
if (qr <= l || r <= ql) {
return;
} else if (ql <= l && r <= qr) {
apply(v);
} else {
push(v);
int m = (r + l) >> 1;
inv(2 * v + 1, l, m, ql, qr);
inv(2 * v + 2, m, r, ql, qr);
pull(v);
}
}
void query(int v, int l, int r, int ql, int qr, Node &ans) {
if (qr <= l || r <= ql) {
return;
} else if (ql <= l && r <= qr) {
ans = conq(ans, t[v]);
} else {
push(v);
int m = (r + l) >> 1;
query(2 * v + 1, l, m, ql, qr, ans);
query(2 * v + 2, m, r, ql, qr, ans);
pull(v);
}
}
int solve(int l, int r) {
Node ans = Node();
query(0, 0, n, l, r, ans);
return ans.solve();
}
void inv(int l, int r) { inv(0, 0, n, l, r); }
void init(vector<int> &a) {
n = (int)a.size();
build(0, 0, n, a);
}
} // namespace Segtree
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> a;
for (int i = 0; i < n; i++) {
char c;
cin >> c;
if (c == '>')
a.push_back(0);
else
a.push_back(1);
}
Segtree::init(a);
while (q--) {
int l, r;
cin >> l >> r;
l--;
Segtree::inv(l, r);
cout << Segtree::solve(l, r) << '\n';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<vector<char>>> dp(2,
vector<vector<char>>(501,
vector<char>(501, false)));
bool load(int32_t l1, int32_t l2, int32_t l3) {
if (l2 < 0 || l3 < 0) return false;
return dp[l1][l2][l3];
}
int main() {
int32_t n, k;
cin >> n >> k;
vector<int32_t> coins;
coins.reserve(n);
for (int32_t i = 0; i < n; i++) {
int32_t c;
cin >> c;
coins.push_back(c);
}
dp[0][0][0] = true;
for (int32_t l1 = 0; l1 < n; l1++) {
int32_t c = coins[l1];
for (int32_t l2 = 0; l2 <= k; l2++) {
for (int32_t l3 = 0; l3 <= k; l3++) {
dp[(l1 & 1) ^ 1][l2][l3] = load(l1 & 1, l2 - c, l3 - c) |
load(l1 & 1, l2 - c, l3) |
load(l1 & 1, l2, l3);
}
}
}
int32_t cnt = 0;
for (int32_t i = 0; i <= k; i++) {
if (dp[n & 1][k][i]) {
cnt++;
}
}
cout << cnt << '\n';
for (int32_t i = 0; i <= k; i++) {
if (dp[n & 1][k][i]) {
cout << i << ' ';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
const long double PI = 3.1415926535897932384626;
const long long int MAX = 1000000000 + 7;
char s[105][105];
int main() {
long long int n, m;
scanf("%lld", &n);
scanf("%lld", &m);
for (long long int i = 0; i <= n; i++) s[i][0] = '-';
for (long long int j = 0; j <= m; j++) s[0][j] = '-';
char x;
scanf("%c", &x);
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
scanf("%c", &s[i][j]);
}
scanf("%c", &x);
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (s[i][j] == '.') {
if (i % 2 == 1 and j % 2 == 1)
s[i][j] = 'B';
else if (i % 2 == 1 and (j % 2 == 0))
s[i][j] = 'W';
else if ((i % 2 == 0) and j % 2 == 1)
s[i][j] = 'W';
else if ((i % 2 == 0) and (j % 2 == 0))
s[i][j] = 'B';
}
}
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) printf("%c", s[i][j]);
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed;
cout << setprecision(9);
long long int m, p = 2e9, k = 0, l, q, r, j = 0, t, n, i;
cin >> l;
while (l--) {
cin >> n;
k = 1;
j = INT_MAX;
m = sqrt(n);
for (i = 1; i <= m; i++) {
k = (n - i) / i;
if ((n - i) % i != 0) k++;
p = k + i - 1;
j = min(j, p);
}
cout << j << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k;
cin >> n >> m >> k;
long long int left = 1, right = n * m + 1;
long long int sum = 0;
while (left < right) {
long long int mid = (left + right) / 2;
sum = 0;
for (int i = 1; i <= n; i++) {
sum += min(m, mid / i);
}
if (sum < k) {
left = mid + 1;
} else
right = mid;
}
cout << left;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
int MOD = 1e9 + 7;
mt19937 rng((int)chrono::steady_clock::now().time_since_epoch().count());
int uniform(int l, int r) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
const int MAX = 5e6 + 10;
int memo[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long p = uniform(250, MOD - 1);
long long tp = 1;
string str;
cin >> str;
int n = int((str).size());
long long h1 = 0, rh1 = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
h1 = (h1 * p + str[i]) % MOD;
rh1 = (rh1 + tp * str[i]) % MOD;
tp = (tp * p) % MOD;
if (h1 == rh1) memo[i] = memo[(i - 1) / 2] + 1;
ans += memo[i];
}
cout << ans << '\n';
exit(0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n & 1 == 1)
cout << "contest" << endl;
else
cout << "home" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long> a(n), b(n);
for (auto &i : a) {
cin >> i;
}
for (auto &i : b) {
cin >> i;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long A, B;
A = B = 0LL;
while (!a.empty() || !b.empty()) {
if (!a.empty() && !b.empty()) {
if (a.back() >= b.back()) {
A += a.back();
a.pop_back();
} else {
b.pop_back();
}
} else if (!a.empty()) {
A += a.back();
a.pop_back();
} else {
b.pop_back();
}
if (!a.empty() && !b.empty()) {
if (a.back() <= b.back()) {
B += b.back();
b.pop_back();
} else {
a.pop_back();
}
} else if (!a.empty()) {
a.pop_back();
} else {
B += b.back();
b.pop_back();
}
}
cout << A - B << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long solution(long long f, long long T, long long t0, long long a1,
long long t1, long long p1) {
if (t1 * f > T && t0 * f > T) return -1LL;
if (t0 < t1) return 0LL;
long long x = f * t0;
if (x <= T) return 0LL;
long long y = t0 - t1;
long long z = (x - T) / y;
long long k = z / a1 + (long long)(bool(z % a1 > 0));
if (t1 * min(f, k * a1) + (t0 * max(0LL, f - k * a1)) > T) {
k++;
if (t1 * min(f, k * a1) + (t0 * max(0LL, f - k * a1)) > T) return -1LL;
}
return k * p1;
}
int main() {
long long f, T, t0;
long long a1, t1, p1;
long long a2, t2, p2;
cin >> f >> T >> t0;
cin >> a1 >> t1 >> p1;
cin >> a2 >> t2 >> p2;
if (f * t0 <= T) {
cout << "0" << endl;
return 0;
}
if (f * t1 > T && f * t2 > T) {
cout << "-1" << endl;
return 0;
}
if (t1 > t2) {
swap(a1, a2);
swap(t1, t2);
swap(p1, p2);
}
long long ans = 1LL << 60;
for (long long count2 = 0; count2 <= f && count2 * t2 <= T; count2++) {
long long newF = f - count2;
long long newT = T - count2 * t2;
long long solutionP = solution(newF, newT, t0, a1, t1, p1);
if (solutionP < 0) continue;
long long curP =
(count2 / a2 + (long long)(bool(count2 % a2 > 0))) * p2 + solutionP;
if (curP < ans) ans = curP;
}
if (ans == (1LL << 60)) ans = -1LL;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 70 * 1000 + 10;
int n, s, cnt;
bool mark[maxn];
pair<int, int> a[maxn];
int dp[maxn], child[maxn], tmp_a[maxn], c[maxn];
int main() {
scanf("%d %d", &n, &s);
for (int i = 1; i <= n; i++) {
a[i].second = i;
scanf("%d", &a[i].first);
tmp_a[i] = a[i].first;
}
sort(a + 1, a + n + 1);
if (s < a[n].first) {
printf("-1");
return 0;
}
memset(dp, -1, sizeof dp);
dp[0] = 0;
int tmp0_s = s - a[n].first, sum = 0;
for (int i = 1; i < n; i++) {
sum += a[i].first;
for (int j = min(tmp0_s, sum); j >= a[i].first; j--) {
if (dp[j] < 0 && dp[j - a[i].first] >= 0) dp[j] = i;
}
if (dp[tmp0_s] >= 0) break;
}
if (dp[tmp0_s] < 0) {
printf("-1");
return 0;
}
int tmp1_s = tmp0_s;
while (dp[tmp1_s] > 0) {
cnt++;
mark[dp[tmp1_s]] = true;
tmp1_s -= a[dp[tmp1_s]].first;
}
if (cnt == n - 1) {
for (int i = 1; i <= n; i++) printf("%d 0\n", tmp_a[i]);
return 0;
}
for (int i = n; i > 1; i--) {
if (mark[i - 1]) continue;
child[a[i].second] = a[i - 1].second;
c[a[i].second] = tmp_a[a[i].second] - a[i - 1].first;
}
for (int i = 1; i <= n; i++) {
if (child[i] == 0)
printf("%d 0\n", tmp_a[i]);
else
printf("%d 1 %d\n", c[i], child[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::map;
using std::pair;
using std::stable_sort;
using std::string;
using std::vector;
using namespace std;
vector<pair<char, int>> vect(0);
vector<int> wr(0);
int main() {
string str = "";
cin >> str;
string temp = "";
string temp2 = "";
int ans = 0;
int finalans = 0;
for (int i = 0; i < str.length(); i++) {
if (str[i] == '(' || str[i] == '[')
vect.push_back(make_pair(str[i], i));
else {
if (str[i] == ')') {
if (vect.size() == 0 || vect[vect.size() - 1].first != '(') {
for (int j = 0; j < vect.size(); j++) wr.push_back(vect[j].second);
wr.push_back(i);
vect.erase(vect.begin(), vect.end());
}
if (vect.size() != 0 && vect[vect.size() - 1].first == '(') {
vect.pop_back();
}
}
if (str[i] == ']') {
if (vect.size() == 0 || vect[vect.size() - 1].first != '[') {
for (int j = 0; j < vect.size(); j++) wr.push_back(vect[j].second);
wr.push_back(i);
vect.erase(vect.begin(), vect.end());
}
if (vect.size() != 0 && vect[vect.size() - 1].first == '[') {
vect.pop_back();
}
}
}
if (i == str.length() - 1) {
for (int j = 0; j < vect.size(); j++) wr.push_back(vect[j].second);
}
}
sort(wr.begin(), wr.end());
wr.push_back(str.length() + 10);
int i2 = 0;
int k = 0;
int start = 0;
int finalstart = 0;
int end = 0;
while (i2 < str.size()) {
if (wr[k] == i2) {
if (ans > finalans) {
finalstart = start;
end = i2;
finalans = ans;
}
ans = 0;
start = i2 + 1;
k++;
} else {
if (str[i2] == ']') ans++;
}
i2++;
}
if (ans > finalans) {
finalans = ans;
finalstart = start;
end = str.length();
}
for (int i = finalstart; i < end; i++) temp += str[i];
cout << finalans << endl << temp;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
const int INF = (int)1e9;
char base[] = {'A', 'C', 'G', 'T'};
vector<string> v;
char s[MAXN];
char aux[MAXN];
int n, m;
vector<char> r1[2];
vector<char> r2[2];
vector<char> c1[2];
vector<char> c2[2];
vector<vector<char> > best_row;
vector<vector<char> > best_col;
int mini_row = INF;
int mini_col = INF;
vector<vector<char> > aux_row[2];
vector<vector<char> > aux_col[2];
pair<int, int> calc_row(int row, vector<char>& a, vector<char>& b) {
int va = 0;
int vb = 0;
for (int t = 0; t < m; t++) {
if (v[row][t] != a[t]) va++;
if (v[row][t] != b[t]) vb++;
}
if (va < vb) {
return {0, va};
}
return {1, vb};
}
pair<int, int> calc_col(int col, vector<char>& a, vector<char>& b) {
int va = 0;
int vb = 0;
for (int t = 0; t < n; t++) {
if (v[t][col] != a[t]) va++;
if (v[t][col] != b[t]) vb++;
}
if (va < vb) {
return {0, va};
}
return {1, vb};
}
void solve_row(int i, int j, int k, int p) {
for (int t = 0; t < m; t++) {
if (t % 2 == 0) {
r1[0][t] = base[i];
r1[1][t] = base[j];
r2[0][t] = base[k];
r2[1][t] = base[p];
} else {
r1[0][t] = base[j];
r1[1][t] = base[i];
r2[0][t] = base[p];
r2[1][t] = base[k];
}
}
int v1 = 0;
int v2 = 0;
for (int t = 0; t < n; t++) {
if (t % 2 == 0) {
pair<int, int> score;
score = calc_row(t, r1[0], r1[1]);
if (score.first == 0) {
aux_row[0].push_back(r1[0]);
} else {
aux_row[0].push_back(r1[1]);
}
v1 += score.second;
score = calc_row(t, r2[0], r2[1]);
if (score.first == 0) {
aux_row[1].push_back(r2[0]);
} else {
aux_row[1].push_back(r2[1]);
}
v2 += score.second;
} else {
pair<int, int> score = calc_row(t, r2[0], r2[1]);
if (score.first == 0) {
aux_row[0].push_back(r2[0]);
} else {
aux_row[0].push_back(r2[1]);
}
v1 += score.second;
score = calc_row(t, r1[0], r1[1]);
if (score.first == 0) {
aux_row[1].push_back(r1[0]);
} else {
aux_row[1].push_back(r1[1]);
}
v2 += score.second;
}
}
if (v1 <= v2 && mini_row > v1) {
mini_row = v1;
best_row = aux_row[0];
}
if (v2 <= v1 && mini_row > v2) {
mini_row = v2;
best_row = aux_row[1];
}
for (int t = 0; t < 2; t++) {
aux_row[t].clear();
}
return;
}
void solve_row() {
for (int i = 0; i < 2; i++) {
r1[i].resize(m);
r2[i].resize(m);
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
for (int p = 0; p < 4; p++) {
if (i != j && i != k && i != p && j != k && j != p && k != p) {
solve_row(i, j, k, p);
}
}
}
}
}
return;
}
void solve_col(int i, int j, int k, int p) {
for (int t = 0; t < n; t++) {
if (t % 2 == 0) {
c1[0][t] = base[i];
c1[1][t] = base[j];
c2[0][t] = base[k];
c2[1][t] = base[p];
} else {
c1[0][t] = base[j];
c1[1][t] = base[i];
c2[0][t] = base[p];
c2[1][t] = base[k];
}
}
int v1 = 0;
int v2 = 0;
for (int t = 0; t < m; t++) {
if (t % 2 == 0) {
pair<int, int> score = calc_col(t, c1[0], c1[1]);
if (score.first == 0) {
aux_col[0].push_back(c1[0]);
} else {
aux_col[0].push_back(c1[1]);
}
v1 += score.second;
score = calc_col(t, c2[0], c2[1]);
if (score.first == 0) {
aux_col[1].push_back(c2[0]);
} else {
aux_col[1].push_back(c2[1]);
}
v2 += score.second;
} else {
pair<int, int> score = calc_col(t, c2[0], c2[1]);
if (score.first == 0) {
aux_col[0].push_back(c2[0]);
} else {
aux_col[0].push_back(c2[1]);
}
v1 += score.second;
score = calc_col(t, c1[0], c1[1]);
if (score.first == 0) {
aux_col[1].push_back(c1[0]);
} else {
aux_col[1].push_back(c1[1]);
}
v2 += score.second;
}
}
if (v1 <= v2 && mini_col > v1) {
mini_col = v1;
best_col = aux_col[0];
}
if (v2 <= v1 && mini_col > v2) {
mini_col = v2;
best_col = aux_col[1];
}
for (int t = 0; t < 2; t++) {
aux_col[t].clear();
}
return;
}
void solve_col() {
for (int i = 0; i < 2; i++) {
c1[i].resize(n);
c2[i].resize(n);
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
for (int p = 0; p < 4; p++) {
if (i != j && i != k && i != p && j != k && j != p && k != p) {
solve_col(i, j, k, p);
}
}
}
}
}
return;
}
void print_col(void) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", best_col[j][i]);
}
printf("\n");
}
return;
}
void print_row(void) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", best_row[i][j]);
}
printf("\n");
}
return;
}
int main(void) {
scanf(" %d %d", &n, &m);
v.resize(n);
for (int i = 0; i < n; i++) {
scanf(" %s", aux);
v[i] = string(aux);
}
solve_row();
solve_col();
if (mini_row < mini_col) {
print_row();
} else {
print_col();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int b[200010];
int main() {
long long n;
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
sort(b, b + n);
int m = b[n - 1] - b[0];
int m1 = b[n - 1], m2 = b[0];
long long c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (b[i] == m1) c1++;
if (b[i] == m2) c2++;
}
printf("%d ", m);
if (m1 == m2)
cout << n * (n - 1) / 2 << endl;
else
cout << c1 * c2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int N = 1e3 + 7;
const int M = 1e3;
struct node {
long long cnt;
long long sum;
node(long long cnt = 0, long long sum = 0) : cnt(cnt), sum(sum) {}
};
int n;
long long ans;
map<long long, long long> vis[N];
int f[N];
long long bfs() {
queue<node> q;
node s;
for (int i = 0; i <= M; i++) {
if (f[i]) q.push(node{1, i});
vis[i].clear();
}
while (!q.empty()) {
s = q.front();
q.pop();
if (s.cnt > 1000) return -1;
for (int i = 0; i <= 1000; i++) {
if (f[i] == 0) continue;
if (s.sum < s.cnt * ans && i < ans) continue;
if (s.sum > s.cnt * ans && i > ans) continue;
if (vis[s.cnt + 1][i + s.sum]) continue;
if (s.sum + i == (s.cnt + 1) * ans) return s.cnt + 1;
vis[s.cnt + 1][s.sum + i] = 1;
q.push(node{s.cnt + 1, s.sum + i});
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> ans >> n;
int flag = 0;
int minv = 1001, maxv = -1, x;
for (int i = 1; i <= n; i++) {
cin >> x;
f[x] = 1;
maxv = max(maxv, x);
minv = min(minv, x);
}
flag = f[ans];
if (flag) {
cout << 1 << endl;
return 0;
}
if (maxv < int(ans) || minv > int(ans))
cout << -1 << endl;
else
cout << bfs() << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n <= 3) {
puts("-1");
continue;
}
vector<int> ans;
for (int i = 1; i <= n; i += 2) ans.push_back(i);
if (n % 2) n--;
for (int i = n; i >= 2; i -= 2) ans.push_back(i);
for (int i = 0; i < ans.size(); i++) {
if (abs(ans[i + 1] - ans[i]) == 1) {
if (abs(ans[i + 2] - ans[i]) > 1)
swap(ans[i + 2], ans[i + 1]);
else
swap(ans[i - 1], ans[i]);
break;
}
}
for (auto u : ans) cout << u << " ";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, dd, uui;
cin >> n >> k;
char a[343][345];
if (k > ceil(n / 2.0) * ceil(n / 2.0) + (n / 2) * (n / 2)) {
cout << "NO";
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
a[i][j] = 'S';
}
}
for (int i = 1; i <= n; i++) {
for (int j = (i + 1) % 2 + 1; j <= n; j += 2) {
if (k > 0) a[i][j] = 'L';
k--;
if (k < 0) break;
}
if (k < 0) break;
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cout << a[i][j];
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, n;
int main() {
cin >> a >> b >> n;
for (int i = 0; i < n; i++) {
int l, t, m;
scanf("%d %d %d", &l, &t, &m);
if (1LL * t < 1LL * a + 1LL * (l - 1) * 1LL * b) {
printf("-1\n");
continue;
}
int l1 = l;
int r = 3000000;
while (l1 != r) {
int m1 = (l1 + r + 1) / 2;
if (1LL * a + 1LL * (m1 - 1) * b <= 1LL * t) {
if (1LL * (1LL * a + 1LL * (l - 1) * b) * (m1 - l + 1) +
1LL * b * (m1 - l) * (m1 - l + 1) / 2LL <=
1LL * t * m) {
l1 = m1;
continue;
}
}
r = m1 - 1;
}
printf("%d\n", l1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> isprime(1e7 + 1, true);
struct node {
long long lenght;
};
void Sieve(long long maxn) {
long long j;
isprime[0] = isprime[1] = false;
for (int i = 2; i < sqrt(maxn) + 1; i++) {
if (isprime[i]) {
for (j = i * i; j <= maxn; j += i) {
isprime[j] = false;
}
}
}
}
struct comparefunction {
bool operator()(const pair<long long int, long long int> c,
const pair<long long int, long long int> d) const {
long long lenc = c.second - c.first + 1;
long long lend = d.second - d.first + 1;
if (lenc != lend)
return lenc > lend;
else
return c.first < d.first;
}
};
void dfs(long long v, vector<bool> visited, vector<int> adj[]) {
visited[v] = true;
for (int u : adj[v]) {
if (!visited[u]) dfs(u, visited, adj);
}
}
long long modpow(long long x, long long n, long long p) {
if (n == 0) return 1;
if (n == 1) return x % p;
if (n % 2 == 0)
return (modpow(x, n / 2, p) % p) * (modpow(x, n / 2, p) % p);
else
return (x % p) * (modpow(x, n / 2, p) % p) * (modpow(x, n / 2, p) % p);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long check1 = 0, check2 = 0, check3 = 0;
long long counti = 0, i = 0, j;
long long sum = 0, count = 0, t, k, a, b, q, c, d, l, r;
long long s;
long long m, n;
long long p = 1e9 + 7;
string str;
cin >> str;
n = str.size();
long long ans = 0;
long long acount = 0;
for (int i = 0; i < n; i++) {
if (str[i] == 'a') acount++;
if (i == 0) continue;
if (str[i] == 'b' && str[i - 1] == 'a' && !check1) {
ans += (modpow(2, acount, p) - 1) % p;
check1 = 1;
continue;
}
if (check1) {
if (str[i] == 'b') {
ans += (modpow(2, acount, p) - 1) % p;
}
}
}
cout << ans % p;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, k, d;
cin >> n >> k >> d;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long g = INT_MAX;
long long u = 0;
for (int i = 0; i + d - 1 < n; i++) {
map<char, int> m;
for (int j = i; j < i + d; j++) {
m[a[j]]++;
}
u = m.size();
g = min(g, u);
}
cout << g << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, h[200000], a[200000], d[200000], f[200000][18];
long long k, s[200000], w[200000][18];
int main() {
scanf("%d%d%I64d", &n, &m, &k);
f[1][0] = 1;
for (int i = (1); i <= (n); i++) {
scanf("%d", &s[i]);
if (s[i] > k) {
printf("-1");
return 0;
}
}
for (int i = (2); i <= (n); i++) {
scanf("%d", &f[i][0]);
w[i][0] = s[f[i][0]];
h[i] = h[f[i][0]] + 1;
}
for (int j = (1); j <= (17); j++)
for (int i = (1); i <= (n); i++) {
f[i][j] = f[f[i][j - 1]][j - 1];
w[i][j] = w[i][j - 1] + w[f[i][j - 1]][j - 1];
}
for (int i = (1); i <= (n); i++) {
int x = i, y = m - 1;
long long z = k - s[i];
for (int j = (17); j >= (0); j--)
if ((y >= (1 << j)) && (z >= w[x][j])) {
y -= 1 << j;
z -= w[x][j];
x = f[x][j];
}
d[i] = x;
}
for (int i = (n); i >= (1); i--) {
if ((!a[i]) || (h[a[i]] > h[i])) a[i] = d[i], ans++;
if ((i > 1) && ((!a[f[i][0]]) || (h[a[i]] < h[a[f[i][0]]])))
a[f[i][0]] = a[i];
}
printf("%d", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e5 + 10;
ll a[N];
void easy(ll n) {
for (ll i = 0; i < n; i++) {
cout << i + 1 << " " << i + 1 << "\n";
cout << -a[i] << "\n";
}
for (ll i = 0; i < 3 - n; i++) cout << 1 << " " << 1 << "\n" << 0 << "\n";
exit(0);
}
vector<ll> is_composite;
vector<ll> sieve(ll n) {
vector<ll> primes;
is_composite = vector<ll>(n + 1, -1);
for (ll i = 2; i < n; ++i) {
if (is_composite[i] == -1) {
primes.push_back(i);
for (ll j = 2 * i; j < n; j += i) {
is_composite[j] = i;
}
}
}
return primes;
}
int main() {
ios::sync_with_stdio(false);
ll n;
cin >> n;
for (ll i = 0; i < n; i++) cin >> a[i];
if (n <= 3) easy(n);
vector<ll> md(n);
for (ll i = 0; i < n; i++) {
md[i] = a[i] % n;
if (md[i] < 0) md[i] += n;
if (md[i] != 0) md[i] = n - md[i];
}
auto P = sieve(1e5 + 10);
ll p = -1;
for (auto pp : P) {
if (pp > n / 2) {
p = pp;
break;
}
}
assert(p != -1);
vector<ll> val(n);
vector<bool> foi(n, false);
for (ll j = 0; j <= n; j++) {
val[(j * p) % n] = j;
}
cout << 1 << " " << p << "\n";
for (ll i = 0; i < p; i++) {
cout << p * val[md[i]] << " ";
a[i] += (p * val[md[i]]);
assert(a[i] % n == 0);
foi[i] = true;
}
cout << "\n";
cout << n - p + 1 << " " << n << "\n";
for (ll i = n - p; i < n; i++) {
if (foi[i]) {
cout << "0 ";
continue;
}
cout << p * val[md[i]] << " ";
a[i] += (p * val[md[i]]);
assert(a[i] % n == 0);
}
cout << "\n";
cout << 1 << " " << n << "\n";
for (ll i = 0; i < n; i++) {
cout << -a[i] << " ";
a[i] -= (n * a[i] / n);
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100005];
long long val[100005];
long long add[100005], mi[100005];
void dfs(int u, int father) {
long long mm = 0, mp = 0;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == father) continue;
dfs(v, u);
mp = max(add[v], mp);
mm = max(mi[v], mm);
}
val[u] += mp - mm;
if (val[u] > 0)
mm += val[u];
else
mp -= val[u];
add[u] = mp;
mi[u] = mm;
}
int main() {
int n, u, v;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) cin >> val[i];
dfs(1, 0);
cout << add[1] + mi[1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i, j, x = 1, cn = 0;
cin >> n >> m;
int a[m];
for (i = 0; i < m; i++) cin >> a[i];
for (i = 0; i < m; i++) {
if (a[i] > x) {
cn += a[i] - x;
x = a[i];
}
if (a[i] < x) {
cn += n - x + a[i];
x = a[i];
}
}
cout << cn << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010, M = 4010, mod = 1e9 + 7, O = 2000;
int pf[N][M], sf[N][M], pg[N][M], sg[N][M];
int fst[M], nxt[M + M], u[M + M], v[M + M], tot;
int vis[N], len[N], cl, n, m, ans;
int read() {
int res = 0, fl = 0;
char a = getchar();
while (a < '0' || a > '9') {
if (a == '-') fl = 1;
a = getchar();
}
while (a >= '0' && a <= '9') res = res * 10 + a - '0', a = getchar();
return fl ? -res : res;
}
void ad(int lu, int lv) {
u[++tot] = lu, v[tot] = lv, nxt[tot] = fst[lu], fst[lu] = tot;
u[++tot] = lv, v[tot] = lu, nxt[tot] = fst[lv], fst[lv] = tot;
}
void dfs(int lx, int zs) {
vis[lx] = 1, len[zs]++;
for (int i = fst[lx]; i; i = nxt[i])
if (!vis[v[i]]) dfs(v[i], zs);
}
void add(int &a, int b) { a = (a + b) % mod; }
int ask(int *f, int *g, int b) {
int res = 0;
for (int i = -n, iend = n; i <= iend; i++)
if (b - i >= -n && b - i <= n)
add(res, 2ll * f[i + O] * g[b - i + O] % mod);
return res;
}
int main() {
n = read(), m = read(), vis[1] = 1;
for (int i = 1, iend = m; i <= iend; i++) ad(read(), read());
for (int i = fst[1]; i; i = nxt[i])
if (!vis[v[i]]) len[++cl] = 1, dfs(v[i], cl);
pf[0][O] = pg[0][O] = 1;
for (int i = 0, iend = cl - 1; i <= iend; i++)
for (int j = O - n, jend = O + n; j <= jend; j++)
if (pf[i][j] || pg[i][j])
add(pf[i + 1][j], pf[i][j]), add(pf[i + 1][j - len[i + 1]], pf[i][j]),
add(pf[i + 1][j + len[i + 1]], pf[i][j]),
add(pg[i + 1][j - len[i + 1]], pg[i][j]),
add(pg[i + 1][j + len[i + 1]], pg[i][j]);
sf[cl + 1][O] = sg[cl + 1][O] = 1, add(ans, pg[cl][O]);
for (int i = cl + 1, iend = 2; i >= iend; i--)
for (int j = O - n, jend = O + n; j <= jend; j++)
if (sf[i][j] || sg[i][j])
add(sf[i - 1][j], sf[i][j]), add(sf[i - 1][j - len[i - 1]], sf[i][j]),
add(sf[i - 1][j + len[i - 1]], sf[i][j]),
add(sg[i - 1][j - len[i - 1]], sg[i][j]),
add(sg[i - 1][j + len[i - 1]], sg[i][j]);
for (int i = 1, iend = cl; i <= iend; i++)
for (int j = -len[i] + 2, jend = len[i] - 2; j <= jend; j++)
add(ans, ask(pf[i - 1], sf[i + 1], j));
for (int i = 1, iend = cl; i <= iend; i++)
add(ans, ask(pg[i - 1], sg[i + 1], len[i] - 1)),
add(ans, ask(pg[i - 1], sg[i + 1], 1 - len[i]));
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int a[10], b[10];
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
int p = 0, c = 0;
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]) {
c = a[i];
p = 1;
i = n;
break;
}
}
}
if (p == 1) {
cout << c << endl;
} else if (a[0] > b[0]) {
cout << b[0] << a[0] << endl;
} else if (a[0] < b[0]) {
cout << a[0] << b[0] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
signed main() {
long long int n, x;
cin >> n >> x;
vector<long long int> a(n);
unordered_map<long long int, long long int> cnt;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
if (cnt[a[i]] >= 2) {
cout << 0 << "\n";
return 0;
}
}
unordered_map<long long int, long long int> pcnt;
long long int ans = 1e15;
for (long long int i = 0; i < n; i++) {
long long int now = a[i], next = a[i] & x;
pcnt[next]++;
if (now != next && cnt.count(next)) ans = 1;
}
if (ans > 1e13) {
for (auto i : pcnt) {
if (i.second >= 2) ans = 2;
}
}
if (ans > 1e13)
cout << -1 << "\n";
else
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long t;
long long a[200000];
long long solve(int l, int r) {
if (r - l == 0) {
return 0;
}
if (r - l == 1) {
return a[l] < t;
}
long long ret = 0;
int mi = (l + r) / 2;
ret += solve(l, mi) + solve(mi, r);
if (r - mi > 0 && mi - l > 0) {
vector<long long> v(r - mi);
for (int i = 0; i < (int)(r - mi); i++) {
v[i] = a[mi + i];
if (i) v[i] += v[i - 1];
}
sort(v.begin(), v.end());
long long sum = 0;
for (int i = 0; i < (int)(mi - l); i++) {
sum += a[mi - 1 - i];
ret += lower_bound(v.begin(), v.end(), t - sum) - v.begin();
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> t;
for (int i = 0; i < (int)(n); i++) cin >> a[i];
cout << solve(0, n) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2123;
const long long mod = 998244353;
int n;
long long dp[maxn][maxn], sum[maxn], p2[maxn];
char s[maxn];
int main() {
p2[0] = 1;
for (int i = 1; i < maxn; ++i) p2[i] = (p2[i - 1] + p2[i - 1]) % mod;
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + (s[i] == '?');
for (int i = 2; i <= n; ++i)
for (int l = 1; l + i - 1 <= n; ++l) {
int r = l + i - 1;
if (s[l] == ')' || s[l] == '?')
dp[l][r] = (dp[l][r] + dp[l + 1][r]) % mod;
if (s[r] == '(' || s[r] == '?')
dp[l][r] = (dp[l][r] + dp[l][r - 1]) % mod;
if ((s[l] == ')' || s[l] == '?') && (s[r] == '(' || s[r] == '?'))
dp[l][r] = (dp[l][r] - dp[l + 1][r - 1]) % mod;
if ((s[l] == '(' || s[l] == '?') && (s[r] == ')' || s[r] == '?'))
dp[l][r] =
(dp[l][r] + dp[l + 1][r - 1] + p2[sum[r - 1] - sum[l]]) % mod;
dp[l][r] %= mod;
if (dp[l][r] < 0) dp[l][r] += mod;
}
cout << dp[1][n] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int random(int _min, int _max) {
static bool first = true;
if (first) {
srand(time(NULL));
first = false;
}
return _min + rand() % ((_max + 1) - _min);
}
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
inline long long int exp(long long int a, long long int b) {
a %= 1000000007;
long long int res = 1;
while (b > 0) {
if (b & 1) {
res = res * a % 1000000007;
}
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
inline int add(int a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
inline int multi(long long int a, long long int b) {
a *= b;
if (a >= 1000000007) a %= 1000000007;
return a;
}
inline int on_bit(int N, int pos) { return N = N | (1 << pos); }
inline int off_bit(int N, int pos) { return N = N & ~(1 << pos); }
inline bool check_bit(long long int N, int pos) {
return (bool)(N & (1 << pos));
}
int main() {
int ___T;
cin >> ___T;
for (int cs = 1; cs <= ___T; cs++) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cout << "1 ";
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
long long ans, n, k, A, B;
std::cin >> n;
std::cin >> k;
std::cin >> A;
std::cin >> B;
ans = 0;
if (k == 1) {
std::cout << A * (n - 1);
} else {
while (n > 1) {
if ((n % k) == 0) {
if (B <= A * (n - n / k)) {
n = n / k;
ans = ans + B;
} else {
ans = ans + (n - 1) * A;
n = 1;
}
} else {
if (n / k > 0) {
ans = ans + A * (n % k);
n = n - (n % k);
} else {
ans = ans + A * (n - 1);
n = 1;
}
}
}
std::cout << ans;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 155;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
bitset<N> a = 0, b = 1;
for (int _ = 0; _ < (int)(n); _++) {
swap(a, b);
b ^= a << 1;
}
cout << n << endl;
for (int i = 0; i < (int)(n + 1); i++) cout << b[i] << ' ';
cout << endl;
cout << n - 1 << endl;
for (int i = 0; i < (int)(n); i++) cout << a[i] << ' ';
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const long long INF = 1e18;
long long power(long long x, long long y) {
long long t = 1;
while (y > 0) {
if (y % 2)
y -= 1, t = t * x % mod;
else
y /= 2, x = x * x % mod;
}
return t;
}
vector<int> G[N], hts[N];
int ans = mod, dep[N], fl[N];
int my[N];
void dfs(int v, int p, int d = 0) {
dep[v] = d;
int ct = 0;
fl[v] = 1;
for (int i = 0; i < G[v].size(); ++i)
if (G[v][i] != p) {
ct++;
int to = G[v][i];
dfs(to, v, d + 1);
if (fl[to] == 0 || hts[to].size() > 1) {
fl[v] = 0;
} else {
hts[v].push_back(hts[to][0] + 1);
}
}
if (ct == 0) {
hts[v].push_back(0);
}
sort(hts[v].begin(), hts[v].end());
hts[v].resize(unique(hts[v].begin(), hts[v].end()) - hts[v].begin());
if (hts[v].size() > 2) fl[v] = 0;
}
void dfs1(int v, int p, int h) {
vector<int> lol = hts[v];
if (h == -1) return;
if (p != -1) {
lol.push_back(h);
sort(lol.begin(), lol.end());
lol.resize(unique(lol.begin(), lol.end()) - lol.begin());
}
if (fl[v] && lol.size() <= 2) {
int a = 0;
for (int i = 0; i < lol.size(); ++i) a += lol[i];
while (a % 2 == 0) a /= 2;
ans = min(ans, a);
}
if (lol.size() > 2) return;
int ct[2];
memset(ct, 0, sizeof(ct));
if (p != -1) {
for (int i = 0; i < lol.size(); ++i)
if (lol[i] == h) ct[i]++;
}
int bad = 0;
for (int i = 0; i < G[v].size(); ++i)
if (G[v][i] != p) {
int to = G[v][i];
if (fl[to] == 0 || hts[to].size() > 1) {
bad++;
} else {
for (int j = 0; j < lol.size(); ++j)
if (lol[j] == hts[to][0] + 1) ct[j]++;
}
}
for (int i = 0; i < G[v].size(); ++i)
if (G[v][i] != p) {
int to = G[v][i];
if (fl[to] == 0 || hts[to].size() > 1) {
bad--;
} else {
for (int j = 0; j < lol.size(); ++j)
if (lol[j] == hts[to][0] + 1) ct[j]--;
}
int cp = -1;
if (bad || (ct[0] && ct[1])) {
;
} else {
cp = 1;
for (int i = 0; i < lol.size(); ++i)
if (ct[i]) {
cp = lol[i] + 1;
}
}
if (cp != -1) dfs1(to, v, cp);
if (fl[to] == 0 || hts[to].size() > 1) {
bad++;
} else {
for (int j = 0; j < lol.size(); ++j)
if (lol[j] == hts[to][0] + 1) ct[j]++;
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
G[x].push_back(y);
G[y].push_back(x);
}
dfs(0, -1);
dfs1(0, -1, 0);
if (ans == mod)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(15);
string s;
int k;
cin >> s >> k;
int pos = 0;
while (k > 0) {
int d = s[pos] - '0';
int m = d, mp = -1;
for (int j = pos + 1; j < (int)s.size(); j++) {
int x = s[j] - '0';
if (x > m && j - pos <= k) {
m = x;
mp = j;
}
}
if (m != d) {
k -= mp - pos;
for (int j = mp; j > pos; j--) swap(s[j], s[j - 1]);
}
pos++;
if (pos == (int)s.size()) break;
}
cout << s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
stringstream cnv;
int dem, n;
int a[100] = {1, 0, 0, 0, 1, 0, 1, 0, 2, 1, 1, 2, 0, 1, 0, 0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
dem = 0;
cnv << hex << n << endl;
cnv >> s;
for (char c : s) {
if (c < 'a')
dem += a[c - '0'];
else
dem += a[c - 87];
}
cout << dem;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, m, a[5010], d[5010];
cin >> n >> m;
for (int i = 0; i < n; i++) {
double x;
cin >> a[i] >> x;
}
for (int i = 0; i < n; i++) {
int maX = 0;
for (int j = 0; j < i; j++)
if (a[j] <= a[i]) maX = max(maX, d[j]);
d[i] = maX + 1;
}
int res = -1;
for (int i = 0; i < n; i++) {
res = max(res, d[i]);
}
cout << n - res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, cnt = 0;
cin >> x;
int p[x], q[x];
for (int i = 0; i < x; i++) {
int a, b;
cin >> a >> b;
p[i] = a;
q[i] = b;
}
for (int i = 0; i < x; i++) {
if (q[i] - p[i] > 1) cnt++;
}
cout << cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int c, v0, v1, a, l;
int main() {
scanf("%d%d%d%d%d", &c, &v0, &v1, &a, &l);
int cur = v0, cnt = 1;
while (cur < c) {
v0 = min(v1, v0 + a);
cur -= l;
cur += v0;
cnt++;
}
printf("%d", cnt);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sum_string(string S) {
int ans = 0;
for (int i = 0; i < S.size(); i++) ans += S[i] - 'a';
return ans;
}
int dp[105][3000];
int solve(int L, int C) {
if (L == 0) return (C == 0);
if (dp[L][C] != -1) return dp[L][C];
dp[L][C] = 0;
for (int x = 0; x < 26 && x <= C; x++) {
dp[L][C] += solve(L - 1, C - x);
dp[L][C] %= 1000000007;
}
return dp[L][C];
}
int main() {
int Q;
scanf("%d", &Q);
char S1[105];
for (int i = 0; i < 105; i++)
for (int j = 0; j < 3000; j++) dp[i][j] = -1;
while (Q--) {
scanf("%s", S1);
string S(S1);
int v = solve(S.size(), sum_string(S));
v = (v - 1 + 1000000007) % 1000000007;
printf("%d\n", v);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void min_self(C &a, C b) {
a = min(a, b);
}
template <class C>
void max_self(C &a, C b) {
a = max(a, b);
}
void mod(long long &n, long long m = 1000000007) { n %= m, n += m, n %= m; }
const int MAXN = 1e5 + 5;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, d;
scanf("%d%d", &d, &n);
int x, ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
if (i != n - 1) ans += (d - x);
}
printf("%d", ans);
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 1e6 + 5, djq = 1e9 + 7;
int n, a[N], f[N], ans, nxt[N], top, stk[N], pre[N], sum[N], endc;
char s[N];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
int lst = n + 1;
while (s[n - endc] == '0') endc++;
if (endc == n) return std::cout << n << std::endl, 0;
for (int i = 1; i <= n; i++) a[i] = s[i] == '1' ? 0 : a[i - 1] + 1;
for (int i = n; i >= 0; i--)
if (nxt[i] = lst, s[i] == '1') lst = i;
f[0] = sum[0] = 1;
stk[top = 0] = -1;
for (int i = 1; i <= n; i++) {
while (top && a[stk[top]] < a[i]) top--;
pre[i] = stk[top];
stk[++top] = i;
}
for (int i = 0; i <= n; i++) {
if (i) sum[i] = sum[i - 1];
if (s[i] == '0') {
f[i] = sum[i];
if (pre[i] >= 0)
f[i] = (f[i] - sum[pre[i]] + djq) % djq;
else if (a[i] < i)
f[i] = (f[i] + djq - 1) % djq;
} else if (i)
sum[i] = (sum[i] + f[i]) % djq;
f[nxt[i]] = (f[nxt[i]] + f[i]) % djq;
}
for (int i = 1; i <= n; i++)
if (s[i] == '1') ans = (1ll * (endc + 1) * f[i] + ans) % djq;
return std::cout << ans << std::endl, 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (1e9 + 7);
long long dp[4010][4010], c[4010][4010];
void init(int n) {
c[0][0] = 1;
for (int i = 1; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
dp[1][1] = 1;
dp[0][0] = 1;
for (int i = 2; i <= n; i++) {
dp[i][1] = dp[i - 1][i - 1];
for (int j = 2; j <= i; j++) {
dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1];
dp[i][j] %= mod;
}
}
}
int main() {
int n;
scanf("%d", &n);
init(n);
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += ((c[n][i] * dp[i][i]) % mod);
ans %= mod;
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int t;
signed long long int n, k, x, z, c = 0, sum = 0, f = 0;
string s;
signed long long int g = 0;
cin >> n;
map<signed long long int, signed long long int> m, a;
for (signed long long int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
x = 0;
if (m[3] >= m[1])
c += m[3];
else {
c += m[3];
x = m[1] - m[3];
}
if (m[2] % 2 == 0)
c += m[2] / 2;
else if (m[2] % 2 == 1) {
c += m[2] / 2 + 1;
x -= 2;
}
c += m[4];
if (x > 0) {
if (x % 4 != 0)
c += x / 4 + 1;
else
c += x / 4;
}
cout << c << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void printList(vector<T> text) {
for (const auto &value : text) cout << value << " ";
cout << '\n';
}
bool in_range(int i, int n) { return 0 <= i && i < n; }
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
char c;
cin >> n >> m >> c;
char mat[n][m];
string temp;
vector<pair<int, int> > president;
vector<pair<int, int> > directions(4);
directions[0] = {0, -1};
directions[1] = {0, 1};
directions[2] = {1, 0};
directions[3] = {-1, 0};
for (int i = 0; i < n; ++i) {
cin >> temp;
for (int j = 0; j < m; ++j) {
mat[i][j] = temp[j];
if (temp[j] == c) {
president.push_back({i, j});
}
}
}
int x, y, dx, dy;
bool valid_deputy;
set<char> deputies;
for (pair<int, int> point : president) {
x = point.first;
y = point.second;
for (pair<int, int> direction : directions) {
dx = direction.first;
dy = direction.second;
valid_deputy = in_range(x + dx, n) && in_range(y + dy, m) &&
mat[x + dx][y + dy] != c && mat[x + dx][y + dy] != '.';
if (valid_deputy) {
deputies.insert(mat[x + dx][y + dy]);
}
}
}
cout << deputies.size() << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 10;
long long a[MAXN];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k, mn = 1e18;
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
mn = min(mn, a[i]);
}
vector<long long> check;
for (long long i = 0; i < n; i++) check.push_back(a[i] % k);
for (long long i = 1; i < n; i++)
if (check[i] != check[0]) return cout << -1, 0;
long long sum = 0;
for (long long i = 0; i < n; i++) sum += a[i] - mn;
cout << sum / k;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e7 + 1;
void solve() {
long long int n;
cin >> n;
vector<long long int> v(39, 0);
vector<long long int> v1(39, 0);
v[0] = 1;
v1[0] = 1;
for (long long int i = 1; i < 39; i++) v[i] = v[i - 1] * 3;
for (long long int i = 1; i < 39; i++) v1[i] = v1[i - 1] + v[i];
long long int a1 = upper_bound(v1.begin(), v1.end(), n) - v1.begin();
long long int a2 = v1[a1];
for (long long int i = a1; i >= 0; i--) {
if (a2 - v[i] >= n) a2 -= v[i];
}
cout << a2 << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200002;
int n;
int a[N];
int dp[N][205];
vector<int> mp[202];
int frq[202];
int find_mid(int k, int l, int r) { return dp[r + 1][k] - dp[l][k]; }
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int T;
cin >> T;
while (T--) {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
memset(frq, 0, sizeof(frq));
for (int i = 1; i <= 200; i++) {
dp[0][i] = 0;
dp[1][i] = 0;
}
int ans = INT_MIN;
for (int i = 1; i <= n; ++i) {
++frq[a[i]];
ans = max(ans, frq[a[i]] - (1 - frq[a[i]] % 2));
for (int j = 1; j <= 200; ++j) dp[i + 1][j] = dp[i][j] + (a[i] == j);
}
for (int i = 1; i <= n; i++) {
mp[a[i]].push_back(i);
int xx = mp[a[i]].size();
ans = max(ans, xx);
}
for (int i = 1; i <= 200; i++) {
if (mp[i].size() < 2) continue;
int k = mp[i].size();
int l = 0;
int r = k - 1;
int cur;
while (l < r) {
cur = 2 * (l + 1);
int temp = INT_MIN;
for (int j = 1; j <= 200; j++) {
temp = max(temp, find_mid(j, mp[i][l] + 1, mp[i][r] - 1));
}
ans = max(ans, cur + temp);
l++;
r--;
}
}
cout << ans << "\n";
for (int i = 1; i <= 200; i++) mp[i].clear();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int d[55][55], dp[55][55], deg[55], fi[55], se[55], p[55], q[55], r[55];
int f(int x) { return x == p[x] ? x : p[x] = f(p[x]); }
int main() {
int n, i, j, k, l, L, R, tot, s, m, mid;
scanf("%d", &n);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i != j) d[i][j] = 1e9;
for (i = 1; i < n; i++) {
scanf("%d%d%d", &j, &k, &l);
fi[i] = j;
se[i] = k;
d[j][k] = d[k][j] = l;
deg[j]++;
deg[k]++;
}
scanf("%d%d", &s, &m);
for (i = 1; i <= n; i++) p[i] = i;
for (i = 1; i < n; i++)
if (fi[i] != s && se[i] != s) p[f(fi[i])] = f(se[i]);
for (i = 0; i < m; i++) {
scanf("%d", &j);
q[f(j)]++;
}
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (d[i][k] + d[k][j] < d[i][j]) d[i][j] = d[i][k] + d[k][j];
for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++)
if (deg[j] == 1) {
L = 0, R = 1e9;
while (L < R) {
mid = L + R + 1 >> 1;
tot = 0;
for (k = 1; k <= n; k++)
if (deg[k] == 1) {
l = 0;
while (l < i && dp[l][k] + d[j][k] < mid) l++;
tot += i - l;
}
if (tot < i)
R = mid - 1;
else
L = mid;
}
dp[i][j] = L;
}
L = 0, R = 1e9;
while (L < R) {
mid = L + R + 1 >> 1;
for (k = 1; k <= n; k++) r[k] = 0;
for (k = 1; k <= n; k++)
if (deg[k] == 1) {
l = 0;
while (l < m && dp[l][k] + d[s][k] < mid) l++;
r[f(k)] += m - l;
}
for (k = 1; k <= n; k++)
if (r[k] < q[k]) break;
if (k > n)
L = mid;
else
R = mid - 1;
}
printf("%d\n", L);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long MAX(long long a, long long b) { return a < b ? b : a; }
long long MIN(long long a, long long b) { return a > b ? b : a; }
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
bool is_letter_s(char a) {
if ((a >= 'a') && (a <= 'z'))
return true;
else
return false;
}
bool is_letter_b(char a) {
if ((a >= 'A') && (a <= 'Z'))
return true;
else
return false;
}
bool is_number(char a) {
if ((a >= '0') && (a <= '9'))
return true;
else
return false;
}
vector<int> prefix(string s) {
int n = s.length();
vector<int> v(n);
for (int i = 1; i <= n - 1; i++) {
int j = v[i - 1];
while (j > 0 && s[i] != s[j]) j = v[j - 1];
if (s[i] == s[j]) j++;
v[i] = j;
}
return v;
}
int main() {
cin.sync_with_stdio(0);
int n;
cin >> n;
int a[110000];
int b[110000];
int num[110000];
memset(num, 0, sizeof num);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
cin >> b[i];
num[b[i]]++;
}
a[0] = 1;
b[0] = 0;
stack<int> st;
stack<int> best_stack;
for (int i = 1; i <= n; i++)
if (a[i] == 1) {
int x = i;
st.push(x);
x = b[x];
while (a[x] == 0 && x != 0 && num[x] == 1) {
st.push(x);
x = b[x];
}
if (st.size() > best_stack.size()) best_stack = st;
while (!st.empty()) st.pop();
}
cout << best_stack.size() << "\n";
while (!best_stack.empty()) {
cout << best_stack.top() << " ";
best_stack.pop();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << 25;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<vector<int> > g(n);
for (int i = 0; i < (n - 1); ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
vector<int> par(n, -1);
vector<int> dp1(n), dp2(n);
vector<bool> leaf(n);
function<void(int, int)> dfs = [&](int u, int p) {
vector<int> nxt;
for (int v : g[u]) {
if (v == p) continue;
dfs(v, u);
nxt.push_back(v);
}
if ((int)(nxt).size() == 0) {
leaf[u] = true;
return;
}
if ((int)(nxt).size() == 1) {
dp1[u] = dp2[nxt[0]];
} else {
for (int v : nxt) dp1[u] += dp2[v];
dp1[u] += (int)(nxt).size() - 1;
}
for (int v : nxt) {
if (!leaf[v]) dp2[u] += 1 + dp1[v];
}
};
dfs(0, -1);
cout << min(dp1[0], dp2[0]) << "\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long n, s, k, t;
cin >> n >> s >> k;
vector<int> a;
for (long long i = 0; i < k; ++i) cin >> t, a.push_back(t);
sort(a.begin(), a.end());
for (int i = 0; i <= k; i++) {
if (!binary_search(a.begin(), a.end(), s + i) && s + i <= n) {
cout << i;
break;
} else if (!binary_search(a.begin(), a.end(), s - i) && s - i > 0) {
cout << i;
break;
}
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 10000000;
int findMax(int* hh, int* mm, int count, int x) {
int max = -1, i_max = -1;
for (int i = 0; i < count; ++i) {
if (hh[i] <= x && max < mm[i]) {
i_max = i;
max = mm[i];
}
}
if (max == -1) {
return x;
}
hh[i_max] = MAX;
return max + x;
}
int main() {
int n, x;
int h11[2000], m1[2000];
int h21[2000], m2[2000];
int h12[2000], h22[2000];
int i1 = 0, i2 = 0;
cin >> n >> x;
for (int i = 0; i < n; ++i) {
int t, h, m;
cin >> t >> h >> m;
if (t == 0) {
h11[i1] = h;
h12[i1] = h;
m1[i1++] = m;
} else {
h21[i2] = h;
h22[i2] = h;
m2[i2++] = m;
}
}
int count1, count2;
int x1, x2;
count1 = count2 = 0;
x1 = x2 = x;
int x_new = x, temp = x;
while (count1 <= n) {
x_new = findMax(h11, m1, i1, x_new);
if (temp == x_new) {
break;
} else {
count1++;
}
temp = x_new;
x_new = findMax(h21, m2, i2, x_new);
if (x_new == temp) {
break;
} else {
count1++;
}
temp = x_new;
}
temp = x_new = x;
while (count2 <= n) {
x_new = findMax(h22, m2, i2, x_new);
if (temp == x_new) {
break;
} else {
count2++;
}
temp = x_new;
x_new = findMax(h12, m1, i1, x_new);
if (x_new == temp) {
break;
} else {
count2++;
}
temp = x_new;
}
cout << max(count1, count2);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
int n, c;
int a[10013], b[10013];
long long dp[2][10013];
int main() {
scanf("%d%d", &n, &c);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) {
int w = i & 1;
fill(dp[w], dp[w] + n + 1, INF);
for (int j = 0; j < i; j++) {
dp[w][j] = min(dp[w][j], dp[!w][j] + 1LL * c * j + a[i]);
dp[w][j + 1] = min(dp[w][j], dp[!w][j] + b[i] + a[i]);
dp[w][j + 1] = min(dp[w][j + 1], dp[!w][j] + b[i]);
}
}
long long ans = INF;
for (int i = 0; i <= n; i++) ans = min(ans, dp[n & 1][i]);
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a1 = 2, a2 = 3, sum = 0;
for (long long int i = 0; i < n; i++) {
sum = sum + (a1 * a2);
if (a2 == n) {
break;
}
a1 = a1 + 1;
a2 = a2 + 1;
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2,avx")
#pragma GCC optimize("unroll-loops")
using namespace std;
string YES[2] = {"NO", "YES"};
string Yes[2] = {"No", "Yes"};
string yes[2] = {"no", "yes"};
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T, class S>
void scan(pair<T, S> &p) {
scan(p.first), scan(p.second);
}
template <class T>
void scan(vector<T> &);
template <class T>
void scan(vector<T> &a) {
for (auto &i : a) scan(i);
}
template <class T>
void scan(T &a) {
cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head &head, Tail &...tail) {
scan(head);
IN(tail...);
}
template <class T, class S>
inline bool chmax(T &a, S b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class S>
inline bool chmin(T &a, S b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
vector<int> iota(int n) {
vector<int> a(n);
iota(begin(a), end(a), 0);
return a;
}
template <typename T>
vector<int> iota(vector<T> &a, bool greater = false) {
vector<int> res(a.size());
iota(begin(res), end(res), 0);
sort(begin(res), end(res), [&](int i, int j) {
if (greater) return a[i] > a[j];
return a[i] < a[j];
});
return res;
}
vector<pair<long long, long long>> factor(long long x) {
vector<pair<long long, long long>> ans;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) {
ans.push_back({i, 1});
while ((x /= i) % i == 0) ans.back().second++;
}
if (x != 1) ans.push_back({x, 1});
return ans;
}
template <class T>
vector<T> divisor(T x) {
vector<T> ans;
for (T i = 1; i * i <= x; i++)
if (x % i == 0) {
ans.push_back(i);
if (i * i != x) ans.push_back(x / i);
}
return ans;
}
template <typename T>
void zip(vector<T> &x) {
vector<T> y = x;
sort(begin(y), end(y));
for (int i = 0; i < x.size(); ++i) {
x[i] = distance((y).begin(), lower_bound(begin(y), end(y), (x[i])));
}
}
int popcount(long long x) { return __builtin_popcountll(x); }
struct Setup_io {
Setup_io() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
}
} setup_io;
int in() {
int x;
cin >> x;
return x;
}
long long lin() {
unsigned long long x;
cin >> x;
return x;
}
template <typename T>
struct edge {
int from, to;
T cost;
int id;
edge(int to, T cost) : from(-1), to(to), cost(cost) {}
edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
edge(int from, int to, T cost, int id)
: from(from), to(to), cost(cost), id(id) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T>
using Edges = vector<edge<T>>;
using Tree = vector<vector<int>>;
using Graph = vector<vector<int>>;
template <class T>
using Wgraph = vector<vector<edge<T>>>;
Graph getG(int n, int m = -1, bool directed = false, int margin = 1) {
Tree res(n);
if (m == -1) m = n - 1;
while (m--) {
int a, b;
cin >> a >> b;
a -= margin, b -= margin;
res[a].emplace_back(b);
if (!directed) res[b].emplace_back(a);
}
return move(res);
}
template <class T>
Wgraph<T> getWg(int n, int m = -1, bool directed = false, int margin = 1) {
Wgraph<T> res(n);
if (m == -1) m = n - 1;
while (m--) {
int a, b;
T c;
cin >> a >> b >> c;
a -= margin, b -= margin;
res[a].emplace_back(b, c);
if (!directed) res[b].emplace_back(a, c);
}
return move(res);
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto &e : v) cout << e << " ";
cout << endl;
return os;
}
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
cout << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class S, class T>
string to_string(pair<S, T> p) {
return "(" + to_string(p.first) + "," + to_string(p.second) + ")";
}
template <class A>
string to_string(A v) {
if (v.empty()) return "{}";
string ret = "{";
for (auto &x : v) ret += to_string(x) + ",";
ret.back() = '}';
return ret;
}
void dump() { cerr << endl; }
template <class Head, class... Tail>
void dump(Head head, Tail... tail) {
cerr << to_string(head) << " ";
dump(tail...);
}
template <typename T>
static constexpr T inf = numeric_limits<T>::max() / 2;
struct UnionFind {
vector<int> data;
int num;
UnionFind(int n) : num(n) { data.assign(n, -1); }
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return false;
num--;
if (data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
return true;
}
bool same(int x, int y) { return find(x) == find(y); }
int find(int x) {
if (data[x] < 0) return x;
return (data[x] = find(data[x]));
}
int size(int x) { return -data[find(x)]; }
void reset(int n) {
data.resize(n);
for (long long i = 0; i < n; ++i) data[i] = -1;
}
void set(int n) {
data[n] = -1;
num++;
}
};
int main() {
int n, m;
IN(n, m);
vector<int> pre(m, -1), nxt(m), used(m * 2);
m >>= 2;
int M = m << 2;
int ans = 0;
UnionFind uf(M * 2);
uf.num = 0;
for (long long i = 0; i < n; ++i) {
string s;
IN(s);
for (long long j = 0; j < m; ++j) {
auto &c = s[j];
int t;
if (!isdigit(c))
t = c - 'A' + 10;
else
t = c - '0';
for (long long k = 0; k < 4; ++k) {
nxt[(j << 2) + k] = t & (1 << 3 - k);
}
}
for (long long i = 0; i < M * 2; ++i) used[i] = 0;
for (long long i = 0; i < M; ++i)
if (pre[i] != -1) used[uf.find(pre[i])] = 1;
int pos = 0;
for (long long i = 0; i < M; ++i) {
if (nxt[i]) {
while (used[pos]) pos++;
uf.set(pos);
used[pos] = 1;
nxt[i] = pos;
} else
nxt[i] = -1;
}
for (long long i = 0; i < M; ++i)
if (pre[i] != -1 and nxt[i] != -1) uf.unite(pre[i], nxt[i]);
for (long long i = 0; i < M - 1; ++i)
if (nxt[i] != -1 and nxt[i + 1] != -1) uf.unite(nxt[i], nxt[i + 1]);
for (long long i = 0; i < M; ++i)
if (nxt[i] != -1) nxt[i] = uf.find(nxt[i]);
swap(pre, nxt);
}
cout << uf.num << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 10;
int n, m, rst;
int d[maxn][maxn];
int vis[maxn];
int main() {
int n;
scanf("%d", &n);
if (n < 11) {
cout << '0' << endl;
return 0;
}
string str;
cin >> str;
int cnt = 0;
for (int i = 0; i < str.size(); i++) {
vis[str[i] - '0']++;
}
while (vis[8]) {
vis[8]--;
n--;
if (n >= 10) cnt++, n -= 10;
}
printf("%d\n", cnt);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], p = 0, t = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i] > 0)
p++;
else if (a[i] < 0)
t++;
else
continue;
}
if (p >= ceil(n / (2.0)))
cout << 1;
else if (t >= ceil(n / (2.0)))
cout << -1;
else
cout << 0;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int INF = 1000000000;
const long long LINF = 1000000000000000000;
const long long MOD = 1000000007;
const double PI = acos(-1.0);
const double EPS = 1e-10;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline void add(T& a, T b) {
a = ((a + b) % MOD + MOD) % MOD;
};
long long fiv[101010];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
fiv[0] = 1, fiv[1] = 1;
for (int i = 2; i <= max(m, n); i++) {
fiv[i] = fiv[i - 1] + fiv[i - 2];
fiv[i] %= MOD;
}
long long ans = (fiv[n] + fiv[m] - 1) % MOD;
ans *= 2;
ans %= MOD;
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1000000 + 10;
long long d[maxn];
long long ans = 0;
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long v, u;
cin >> v >> u;
d[u]++;
d[v]++;
}
for (long long i = 1; i <= n; i++) ans += d[i] * (n - 1 - d[i]);
cout << (n * (n - 1) * (n - 2)) / 6 - (ans / 2) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int clr[4010];
int main() {
int n, k, d1, d2, op, mx, mn, i;
scanf("%d %d", &n, &k);
for (i = 0; i < k; i++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d %d", &d2, &d1);
clr[d1] = 1;
clr[d2] = 1;
} else {
scanf("%d", &d2);
clr[d2] = 1;
}
}
mx = 0;
mn = 0;
i = 1;
while (i < n) {
if (clr[i] == 0) {
if (i + 1 < n && clr[i + 1] == 0) {
mx += 2;
mn++;
clr[i] = 1;
clr[i + 1] = 1;
i += 2;
} else {
mx++;
mn++;
clr[i] = 1;
i++;
}
} else
i++;
}
printf("%d %d\n", mn, mx);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
int n, m, u, v, w, tp, ti, cc, Q, fl = 1;
int hd[N], df[N], lo[N], st[N], c[N], fa[N];
int we[N], d[N], f[N], g[N], sz[N], top[N];
struct edge {
int n, v;
} e[N << 1];
struct edg {
int u, v;
};
vector<edg> E;
void add(int u, int v) {
e[++fl] = (edge){hd[u], v};
hd[u] = fl;
}
void tarjan(int u, int f, int w) {
df[u] = lo[u] = ++ti;
st[++tp] = u;
for (int i = hd[u], v; v = e[i].v, i; i = e[i].n)
if (i ^ f ^ 1) {
if (!df[v]) {
tarjan(v, i, u);
lo[u] = min(lo[u], lo[v]);
} else
lo[u] = min(lo[u], df[v]);
}
if (df[w] < lo[u]) {
++cc;
for (int x, y = 0; x = st[tp], y ^ u; y = x, tp--) c[x] = cc;
if (w) E.push_back((edg){w, u});
}
}
void dfs1(int u) {
sz[u] = 1;
for (int i = hd[u], v; v = e[i].v, i; i = e[i].n) {
d[v] = d[u] + 1;
dfs1(v);
sz[u] += sz[v];
if (sz[v] > sz[we[u]]) we[u] = v;
}
}
void dfs2(int u, int TP) {
top[u] = TP;
if (we[u]) dfs2(we[u], TP);
for (int i = hd[u], v; v = e[i].v, i; i = e[i].n)
if (v != we[u]) dfs2(v, v);
}
int lca(int u, int v) {
for (; top[u] ^ top[v]; u = fa[top[u]])
if (d[top[u]] < d[top[v]]) swap(u, v);
return d[u] < d[v] ? u : v;
}
void ins(int u, int D, int w) {
if (f[u] * w < 0) puts("No"), exit(0);
f[u] = w;
g[u] = (g[u] < (D) ? g[u] : (D));
}
void dfs3(int u) {
for (int i = hd[u], v; v = e[i].v, i; i = e[i].n) {
dfs3(v);
if (g[v] < d[u]) {
if (f[u] * f[v] < 0) puts("No"), exit(0);
f[u] = f[v];
g[u] = (g[u] < (g[v]) ? g[u] : (g[v]));
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= m; i++) scanf("%d%d", &u, &v), add(u, v), add(v, u);
for (int i = 1; i <= n; i++)
if (!df[i]) tarjan(i, 0, 0);
for (int i = 1; i <= n; i++) hd[i] = 0;
fl = 0;
n = cc;
for (edg e : E) u = c[e.u], v = c[e.v], add(u, v), fa[v] = u;
for (int i = 1; i <= n; i++)
if (!fa[i]) d[i] = 1, dfs1(i), dfs2(i, i);
for (int i = 1; i <= n; i++) g[i] = d[i];
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &u, &v);
u = c[u], v = c[v], w = lca(u, v);
if (!w) puts("No"), exit(0);
if (u ^ w) ins(u, d[w], +1);
if (v ^ w) ins(v, d[w], -1);
}
for (int i = 1; i <= n; i++)
if (!fa[i]) dfs3(i);
puts("Yes");
}
| 10 |
#include <bits/stdc++.h>
int main() {
long long n, j = 1, a[100004] = {0}, k = 0, m = 0;
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
a[i] += a[i - 1];
}
if (a[n] % 3 == 0) {
for (int i = 1; i < n; i++) {
if (a[i] == a[n] / 3 * 2) {
while (j < i) {
if (a[j] == a[n] / 3) k++;
j++;
}
m += k;
}
}
printf("%lld", m);
} else
printf("0");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool vis[122];
int cnt[122], x[122];
int n, m, k;
bitset<122 * 2> s[8];
int ans;
int getAns(int d) {
int ret = 1;
for (int i = 1; i < d; ++i) {
ret = 1LL * ret * cnt[x[i]] % 1000000007;
}
return ret;
}
int v[122 + 122 + 122];
int g(int x) {
if (x >= m) x -= m;
return x;
}
int dfs(int d, int last) {
int ret = getAns(d);
if (d <= 6) {
for (int i = last + 1; i <= m / 2; ++i) {
if (!cnt[i]) continue;
if (s[d - 1][i] || s[d - 1][m - i]) continue;
x[d] = i;
if (d <= 5) {
s[d] = s[d - 1];
s[d] |= s[d - 1] << i;
s[d] |= s[d - 1] >> i;
s[d] |= s[d - 1] >> (m - i);
s[d] |= s[d - 1] << (m - i);
}
ret += dfs(d + 1, i);
if (ret >= 1000000007) ret -= 1000000007;
}
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < 3 * 122; ++i) v[i] = i % m;
for (int i = 1; i <= k; ++i) {
int x;
scanf("%d", &x);
x %= m;
x = min(x, m - x);
vis[x] = 1;
cnt[x]++;
}
s[0][0] = 1;
ans = dfs(1, 0);
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m;
int a, b, c, d;
int e, f, g, h;
long long ans1, ans2, t1, t2, t3;
long long spill(int xs, int ys, int xe, int ye, int c) {
if (xe < xs || ye < ys) return 0;
int p = ((xs & 1) == (ys & 1)), q = ((xe & 1) == (ye & 1));
if ((xe - xs + 1) % 2 == 0 || (ye - ys + 1) % 2 == 0)
return 1ll * (xe - xs + 1) * (ye - ys + 1) / 2;
if (p != q)
return 1ll * (xe - xs + 1) * (ye - ys + 1) / 2;
else if (p == c)
return (1ll * (xe - xs + 1) * (ye - ys + 1) - 1) / 2;
else
return (1ll * (xe - xs + 1) * (ye - ys + 1) + 1) / 2;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &m, &n);
scanf("%d%d%d%d", &a, &b, &c, &d);
scanf("%d%d%d%d", &e, &f, &g, &h);
ans1 = spill(1, 1, n, m, 0);
ans2 = spill(1, 1, n, m, 1);
t1 = spill(a, b, c, d, 1);
t2 = spill(e, f, g, h, 0);
t3 = spill(max(a, e), max(b, f), min(c, g), min(d, h), 1);
printf("%I64d %I64d\n", ans1 + t1 - t2 - t3, ans2 - t1 + t2 + t3);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100000 + 5];
long long arr2[100000 + 5];
int main() {
string a, b;
int k;
cin >> a >> b;
cin >> k;
int l = a.length();
int i;
arr[0] = 1;
arr2[0] = 0;
for (i = 1; i <= k; i++) {
arr[i] = ((l - 1) * arr2[i - 1]) % 1000000007;
arr2[i] = (((l - 2) * arr2[i - 1]) + arr[i - 1]) % 1000000007;
}
string tmp;
long long ret = 0;
cerr << arr[k] << ' ' << arr2[k] << endl;
for (i = 0; i < l; i++) {
tmp = a.substr(i) + a.substr(0, i);
cerr << tmp << endl;
if (tmp == b) {
if (i)
ret += arr2[k];
else
ret += arr[k];
}
ret = ret % 1000000007;
}
cout << ret << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > v;
int a[int(1e5 + 5)], ans[int(1e5 + 5)];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
if (i == 0) {
scanf("%d", a + i);
v.insert(pair<int, int>(a[i], i));
continue;
}
scanf("%d", a + i);
auto it = v.upper_bound(pair<int, int>(a[i], -999));
if (it == v.begin()) {
ans[i] = it->first;
} else if (it == v.end()) {
ans[i] = (--it)->first;
} else {
if (it->second > (--it)->second)
ans[i] = (++it)->first;
else
ans[i] = it->first;
}
v.insert(pair<int, int>(a[i], i));
}
for (int i = 1; i < n - 1; ++i) printf("%d ", ans[i]);
printf("%d\n", ans[n - 1]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 10;
const int maxn = 1e6 + 10;
struct node {
int d, l, r;
long long c;
} a[maxn];
long long L[maxn], R[maxn], vis[maxn];
bool cmp(node x, node y) { return x.d < y.d; }
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d%I64d", &a[i].d, &a[i].l, &a[i].r, &a[i].c);
}
sort(a + 1, a + 1 + m, cmp);
memset(L, -1, sizeof L);
memset(R, -1, sizeof R);
memset(vis, 0, sizeof vis);
long long cnt = 0;
long long tot = 0;
for (int i = 1; i <= m; ++i) {
if (a[i].r != 0) continue;
if (!vis[a[i].l]) {
vis[a[i].l] = a[i].c;
cnt++;
tot += a[i].c;
} else {
if (vis[a[i].l] > a[i].c) {
tot = tot - vis[a[i].l] + a[i].c;
vis[a[i].l] = a[i].c;
}
}
if (cnt == n) {
L[i] = tot;
}
}
memset(vis, 0, sizeof vis);
cnt = 0;
tot = 0;
for (int i = m; i >= 1; --i) {
if (a[i].l != 0) continue;
if (!vis[a[i].r]) {
vis[a[i].r] = a[i].c;
cnt++;
tot += a[i].c;
} else {
if (vis[a[i].r] > a[i].c) {
tot = tot - vis[a[i].r] + a[i].c;
vis[a[i].r] = a[i].c;
}
}
if (cnt == n) {
R[i] = tot;
}
}
long long ans = INF;
for (int i = m; i >= 1; --i) {
if (R[i] == -1) continue;
if (R[i + 1] != -1) R[i] = min(R[i], R[i + 1]);
}
for (int i = 1; i <= m; ++i) {
if (L[i] == -1) continue;
int day = a[i].d + k + 1;
int l = i + 1, r = m, len = 50;
while (len--) {
int mid = (l + r) / 2;
if (a[mid].d >= day)
r = mid - 1;
else
l = mid + 1;
}
if (l == -1) continue;
if (R[l] != -1) {
ans = min(ans, L[i] + R[l]);
}
}
if (ans == INF) {
puts("-1");
} else {
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
void chkmax(T& x, T y) {
if (x < y) x = y;
}
template <typename T>
void chkmin(T& x, T y) {
if (x > y) x = y;
}
inline int read() {
int x = 0;
char c = getchar();
bool f = 0;
while (c < 48) f |= c == '-', c = getchar();
while (c > 47) x = x * 10 + (c ^ 48), c = getchar();
return f ? -x : x;
}
const int maxn = 3010;
int n, k;
long long su[maxn];
vector<int> A[maxn];
long long ans, dp[maxn], pst[15][maxn];
void divide(int l, int r, int lev) {
if (l == r) {
long long cur = 0;
chkmax(ans, dp[k]);
for (int i = (0), iend = (A[l].size() - 1); i <= iend; ++i) {
cur += A[l][i];
chkmax(ans, dp[k - i - 1] + cur);
}
return;
}
int mid = (l + r) / 2;
memcpy(pst[lev], dp, sizeof dp);
for (int i = (mid + 1), iend = (r); i <= iend; ++i)
for (int j = (k), jend = (A[i].size()); j >= jend; --j) {
chkmax(dp[j], dp[j - A[i].size()] + su[i]);
}
divide(l, mid, lev + 1);
memcpy(dp, pst[lev], sizeof dp);
for (int i = (l), iend = (mid); i <= iend; ++i)
for (int j = (k), jend = (A[i].size()); j >= jend; --j) {
chkmax(dp[j], dp[j - A[i].size()] + su[i]);
}
divide(mid + 1, r, lev + 1);
memcpy(dp, pst[lev], sizeof dp);
}
void solve() {
cin >> n >> k;
for (int i = (1), iend = (n); i <= iend; ++i) {
int x = read();
vector<int> vec;
while (x--) vec.push_back(read());
for (int t : vec)
if ((int)A[i].size() < k) A[i].push_back(t), su[i] += t;
}
divide(1, n, 0);
cout << ans << endl;
}
signed main() {
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, W, i, j, k;
cin >> n >> m >> W;
long long w[n], b[n];
for (i = 0; i < n; i++) cin >> w[i];
for (i = 0; i < n; i++) cin >> b[i];
vector<long long> G[n];
for (i = 0; i < m; i++) {
cin >> j >> k;
j--;
k--;
G[j].push_back(k);
G[k].push_back(j);
}
bool u[n];
memset(u, 0, sizeof(u));
vector<pair<long long, long long> > v;
vector<vector<long long> > vl;
for (i = 0; i < n; i++) {
if (u[i]) continue;
queue<long long> q;
vector<long long> l;
q.push(i);
pair<long long, long long> p = pair<long long, long long>(0, 0);
while (!q.empty()) {
k = q.front();
q.pop();
if (u[k]) continue;
u[k] = 1;
l.push_back(k);
p.first += b[k];
p.second += w[k];
for (j = 0; j < G[k].size(); j++) q.push(G[k][j]);
}
v.push_back(p);
vl.push_back(l);
}
long long V = v.size(), ans = 0;
long long dp[V + 1][W + 1];
memset(dp, 0, sizeof(dp));
for (i = 0; i < V; i++) {
for (j = 0; j < W; j++) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
for (k = 0; k < vl[i].size(); k++) {
if (j + w[vl[i][k]] > W) continue;
dp[i + 1][j + w[vl[i][k]]] =
max(dp[i + 1][j + w[vl[i][k]]], dp[i][j] + b[vl[i][k]]);
}
if (j + v[i].second > W) continue;
dp[i + 1][j + v[i].second] =
max(dp[i + 1][j + v[i].second], dp[i][j] + v[i].first);
}
}
for (i = 0; i <= V; i++)
for (j = 0; j <= W; j++) ans = max(ans, dp[i][j]);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
string name;
int type;
int num[3];
int size;
vector<pair<int, int> > has;
};
Node node[102];
int n;
int getName(string str) {
for (int i = 0; i < n; i++) {
if (node[i].name == str) {
return i;
}
}
return -1;
}
string type[6] = {"weapon", "armor", "orb", "gladiator", "sentry", "physician"};
int getType(string str) {
for (int i = 0; i < 6; i++) {
if (type[i] == str) {
return i % 3;
}
}
return -1;
}
struct Res {
string name;
int plus;
bool inUsed;
bool operator<(Res o) const { return plus > o.plus; }
};
vector<Res> res[3];
int getNodeNum(int n, int t) {
int ret = node[n].num[t];
int size = node[n].has.size();
for (int i = 0; i < size; i++) {
pair<int, int> j = node[n].has[i];
if (j.first == t) {
ret += res[t][j.second].plus;
}
}
return ret;
}
void printNode(int n) {
int size = node[n].has.size();
cout << node[n].name << " " << size;
for (int i = 0; i < size; i++) {
pair<int, int> j = node[n].has[i];
cout << " " << res[j.first][j.second].name;
}
cout << endl;
}
int main() {
while (cin >> n) {
string tmp;
int size = 0;
for (int i = 0; i < n; i++) {
cin >> node[i].name >> tmp;
for (int j = 0; j < 3; j++) {
cin >> node[i].num[j];
}
cin >> node[i].size;
node[i].type = getType(tmp);
size += node[i].size;
}
int k;
cin >> k;
Res t;
for (int i = 0; i < k; i++) {
t.inUsed = false;
cin >> t.name >> tmp >> t.plus;
int type = getType(tmp);
cin >> tmp;
int name = getName(tmp);
res[type].push_back(t);
node[name].has.push_back(pair<int, int>(type, res[type].size() - 1));
}
if (size == k) {
for (int i = 0; i < 3; i++) {
int maxNum = -1;
int maxIndex = -1;
for (int j = 0; j < n; j++) {
if (node[j].type != i) {
continue;
}
int tt = getNodeNum(j, i);
if (tt > maxNum) {
maxIndex = j;
maxNum = tt;
}
}
printNode(maxIndex);
}
} else {
int maxNum[102];
int choice[3];
for (int i = 0; i < 3; i++) {
sort(res[i].begin(), res[i].end());
int maxNumber = -1;
int maxIndex = -1;
for (int j = 0; j < n; j++) {
if (node[j].type != i) {
continue;
}
maxNum[j] = node[j].num[i];
int size = res[i].size();
size = min(size, node[j].size);
for (int k = 0; k < size; k++) {
maxNum[j] += res[i][k].plus;
}
if (maxNum[j] > maxNumber) {
maxNumber = maxNum[j];
maxIndex = j;
}
}
choice[i] = maxIndex;
node[maxIndex].has.clear();
int size = res[i].size();
size = min(size, node[maxIndex].size);
for (int k = 0; k < size; k++) {
res[i][k].inUsed = true;
node[maxIndex].has.push_back(pair<int, int>(i, k));
}
}
for (int i = 0; i < 3; i++) {
int j = choice[i];
int cnt = node[j].size - node[j].has.size();
for (int ii = 0; ii < 3 && cnt != 0; ii++) {
int size = res[ii].size();
for (int jj = 0; jj < size && cnt != 0; jj++) {
if (res[ii][jj].inUsed == false) {
node[j].has.push_back(pair<int, int>(ii, jj));
res[ii][jj].inUsed = true;
cnt--;
}
}
}
}
for (int i = 0; i < 3; i++) {
printNode(choice[i]);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int MAX = 400010;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-7;
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
if ((2 * n * m) % k != 0)
cout << "NO\n";
else {
cout << "YES\n";
int nn = n / gcd(n, k);
int kk = k / gcd(n, k);
int mm = m / gcd(m, kk);
kk /= gcd(m, kk);
if (kk == 1) {
if (nn == n)
mm *= 2;
else
nn *= 2;
}
cout << "0 0\n";
cout << "0 " << mm << '\n';
cout << nn << " 0" << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int x, y;
cin >> x >> y;
cout << min(x, y) + 1 << endl;
;
if (x < y) {
for (int i = 0; i <= x; ++i) {
cout << i << " " << i + 1 << endl;
}
} else if (x == y) {
for (int i = 0; i <= x; ++i) {
cout << i << " " << x - i << endl;
}
} else if (x > y) {
for (int i = 0; i <= y; ++i) {
cout << i + 1 << " " << i << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
;
template <class T>
bool io(T &res) {
static char c = ' ';
while (c == ' ' || c == '\n') c = getchar_unlocked();
if (c == -1) return 0;
res = ((c) - '0');
while ((c = getchar_unlocked()) && c != ' ' && c != '\n' && c != -1) {
res = (res << 3) + (res << 1) + ((c) - '0');
}
return 1;
}
template <class T>
string inttostr(T x) {
string res = "";
while (x) {
char t = ((x % 10) + '0');
x /= 10;
res = t + res;
}
return res;
}
template <class T>
T strtoint(string x) {
T res = 0;
for (int i = 0; i < x.size(); i++) {
res = (res << 3) + (res << 1) + ((x[i]) - '0');
}
return res;
}
void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
void close() {
fclose(stdin);
fclose(stdout);
}
int arr[100005];
int vis[100005];
void no(int n) { cout << "NO" << '\n'; }
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
int a = -1, b = -1;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 1; i <= n; i++) {
if (i == arr[i]) {
cout << "YES" << '\n';
for (int j = 1; j <= n; j++) {
if (i == j) continue;
cout << i << ' ' << j << '\n';
}
return 0;
}
}
for (int i = 1; i <= n; i++) {
if (i == arr[arr[i]]) a = i, b = arr[i];
}
if (a != -1) {
memset(vis, 0, sizeof vis);
vector<pair<int, int> > V;
vis[a] = 1;
vis[b] = 1;
V.push_back({a, b});
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
int cntr = 0;
int len = 0;
for (int j = i; cntr <= 1; j = arr[j]) {
if (j == i) cntr++;
len++;
}
len--;
if (len & 1) {
no(n);
return 0;
}
for (int j = i; !vis[j]; j = arr[j]) {
vis[j] = 1;
V.push_back({j, a});
swap(a, b);
}
}
}
cout << "YES" << '\n';
for (pair<int, int> i : V) {
cout << i.first << ' ' << i.second << '\n';
}
return 0;
}
no(n);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int AX, AY, BX, BY, N;
bool A[505][505];
int MinX, MaxX;
int MinY, MaxY;
bool Out(int X, int Y) { return X < MinX || X > MaxX || Y < MinY || Y > MaxY; }
void Error() {
puts("-1");
exit(0);
}
char Ans[2500005];
int AnsTop;
const int DX[] = {0, 1, 0, -1, 0};
const int DY[] = {0, 0, 1, 0, -1};
char K[] = {0, 'R', 'U', 'L', 'D'};
bool Go(int X) {
Ans[++AnsTop] = K[X];
AX += DX[X];
AY += DY[X];
BX += DX[X];
BY += DY[X];
if (!Out(BX, BY) && A[BX][BY] == 1) {
BX -= DX[X];
BY -= DY[X];
return 0;
}
return 1;
}
void Init() {
Get(AX);
Get(AY);
Get(BX);
Get(BY);
Get(N);
AX += 200;
AY += 200;
BX += 200;
BY += 200;
MinX = MinY = 0x2f2f2f2f;
MaxX = MaxY = 0xc0c0c0c0;
for (int i = 1, X, Y; i <= N; i++) {
Get(X);
Get(Y);
X += 200;
Y += 200;
A[X][Y] = 1;
if (MinX > X) MinX = X;
if (MaxX < X) MaxX = X;
if (MinY > Y) MinY = Y;
if (MaxY < Y) MaxY = Y;
}
if (N == 0) Error();
}
pair<int, int> Q[250005];
int L, R;
int Dis[505][505];
int From[505][505];
void BFS(int X, int Y) {
Q[L = R = 1] = make_pair(X, Y);
Dis[X][Y] = 1;
for (int NewX, NewY; L <= R; L++) {
X = Q[L].first;
Y = Q[L].second;
for (int i = 1; i <= 4; i++) {
NewX = X + DX[i];
NewY = Y + DY[i];
if (0 <= NewX && NewX <= 400 && 0 <= NewY && NewY <= 400 &&
!A[NewX][NewY] && !Dis[NewX][NewY]) {
Dis[NewX][NewY] = Dis[X][Y] + 1;
From[NewX][NewY] = i;
Q[++R] = make_pair(NewX, NewY);
}
}
}
}
int Type(int X, int Y) {
if (X > MaxX) return 1;
if (Y > MaxY) return 2;
if (X < MinX) return 3;
if (Y < MinY) return 4;
return 0;
}
void Output() {
puts(Ans + 1);
exit(0);
}
int Q2[250005];
void FlipX() {
AX = 400 - AX;
BX = 400 - BX;
for (int i = 1; i <= 200; i++)
for (int j = 1; j <= 400; j++) std::swap(A[i][j], A[400 - i][j]);
MinX = 400 - MinX;
MaxX = 400 - MaxX;
std::swap(MinX, MaxX);
std::swap(K[1], K[3]);
}
void FlipY() {
AY = 400 - AY;
BY = 400 - BY;
for (int i = 1; i <= 400; i++)
for (int j = 1; j <= 200; j++) std::swap(A[i][j], A[i][400 - j]);
MinY = 400 - MinY;
MaxY = 400 - MaxY;
std::swap(MinY, MaxY);
std::swap(K[2], K[4]);
}
void Work() {
if (!Out(AX, AY) || !Out(BX, BY)) {
BFS(AX, AY);
if (Dis[BX][BY] == 0) Error();
L = 1;
R = Dis[BX][BY] - 1;
for (int i = Dis[BX][BY] - 1, X = BX, Y = BY; i >= 1; i--) {
Q2[i] = From[X][Y];
X -= DX[Q2[i]];
Y -= DY[Q2[i]];
}
for (;;) {
if (Go(Q2[L]) == 1) {
R++;
if (R > 250000) R = 1;
Q2[R] = Q2[L];
}
if (Out(AX, AY) && Out(BX, BY)) break;
if (L == R) Output();
if (AX == BX && AY == BY) Output();
L++;
if (L > 250000) L = 1;
}
}
if (AX < BX) FlipX();
if (AY < BY) FlipY();
if (Type(AX, AY) != 4 && Type(BX, BY) != 4) {
for (; BY <= MaxY;) Go(2);
for (; BX <= MaxX;) Go(1);
} else if (Type(AX, AY) != 3 && Type(BX, BY) != 3) {
for (; BX <= MaxX;) Go(1);
for (; BY <= MaxY;) Go(2);
} else if (Type(AX, AY) != 2 && Type(BX, BY) != 2) {
for (; AY >= MinY;) Go(4);
for (; BX <= MaxX;) Go(1);
for (; BY <= MaxY;) Go(2);
}
for (; BY > MaxY;) Go(4);
for (; AX > BX;) Go(3);
Go(2);
Go(3);
for (; AY > BY;) Go(4);
}
int main() {
Init();
Work();
Output();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
vector<long long int> v[n + 1];
for (long long int i = 0; i < n - 1; i += 1) {
long long int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
long long int f = 1;
for (long long int i = 1; i <= n; i += 1) {
if (v[i].size() == 2) f = 0;
}
if (f == 0)
cout << "NO";
else
cout << "YES";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e4 + 7;
int n;
int ans[N];
struct pkt {
int x, y, col, ind;
bool operator<(const pkt &a) const {
if (x == a.x)
return y < a.y;
else
return x < a.x;
}
bool operator==(const pkt &a) const { return x == a.x && y == a.y; }
};
bool prawo(pkt &a, pkt &b, pkt &c) {
return (a.x - c.x) * (b.y - c.y) - (b.x - c.x) * (a.y - c.y) > 0;
}
pkt p[N];
vector<pkt> hull(vector<pkt> &p) {
vector<pkt> u, l;
sort((p).begin(), (p).end());
for (auto it : p) {
while (u.size() >= 2 && !prawo(it, u.back(), u[u.size() - 2])) u.pop_back();
u.push_back(it);
}
reverse((p).begin(), (p).end());
for (auto it : p) {
while (l.size() >= 2 && !prawo(it, l.back(), l[l.size() - 2])) l.pop_back();
l.push_back(it);
}
u.pop_back();
l.pop_back();
u.insert(u.end(), (l).begin(), (l).end());
return u;
}
pkt curr;
bool comp(pkt a, pkt b) { return prawo(a, b, curr); }
vector<pkt> sortuj(vector<pkt> p, pkt &s) {
curr = s;
sort((p).begin(), (p).end(), comp);
return p;
}
void match(pkt &a, pkt &b) {
if (a.col != 1) swap(a, b);
ans[a.ind] = b.ind;
}
void solve(vector<pkt> &p) {
if (p.empty()) return;
if (p.size() == 2) {
match(p[0], p[1]);
return;
}
vector<pkt> h = hull(p);
random_shuffle((h).begin(), (h).end());
for (auto &it : p) {
if (it == h[0]) {
swap(it, p.back());
p.pop_back();
break;
}
}
p = sortuj(p, h[0]);
int cnt[] = {0, 0};
for (int i = 0; i < p.size(); ++i) {
auto it = p[i];
++cnt[it.col];
if (cnt[h[0].col ^ 1] == cnt[h[0].col] + 1 && it.col == h[0].col ^ 1) {
match(h[0], it);
vector<pkt> l, r;
for (int j = 0; j < i; ++j) {
l.push_back(p[j]);
}
for (int j = i + 1; j < p.size(); ++j) {
r.push_back(p[j]);
}
solve(l);
solve(r);
return;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
vector<pkt> s;
for (int i = 1; i <= n; ++i) {
cin >> p[i].x >> p[i].y;
p[i].ind = i;
p[i].col = 1;
s.push_back(p[i]);
}
for (int i = n + 1; i <= 2 * n; ++i) {
cin >> p[i].x >> p[i].y;
p[i].ind = i - n;
p[i].col = 0;
s.push_back(p[i]);
}
srand(24);
solve(s);
for (int i = 1; i <= n; ++i) {
cout << ans[i] << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 1e5 + 10;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
long long int dip = ((n) / 2) / (k + 1);
cout << dip << ' ' << k * dip << ' ' << n - dip - k * dip << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
string a[4];
for (int i = 0; i < 4; i++) {
cin >> a[i];
}
int res[2];
int mn = 9999;
int mx = 0;
for (int i = 0; i < 4; i++) {
if (mn > a[i].size() - 2) {
res[0] = i;
mn = min(mn, int(a[i].size() - 2));
}
if (mx < a[i].size() - 2) {
res[1] = i;
mx = max(mx, int(a[i].size() - 2));
}
}
bool ok[2] = {0, 0};
for (int i = 0; i < 4; i++) {
if (mn * 2 > a[i].size() - 2 && i != res[0]) ok[0] = 1;
if (mx < (a[i].size() - 2) * 2 && i != res[1]) ok[1] = 1;
}
if ((ok[0] == 1 && ok[1] == 1) || (ok[0] == 0 && ok[1] == 0))
cout << "C" << endl;
else if (ok[0] == 0 && ok[1] == 1) {
if (res[0] == 0) cout << "A" << endl;
if (res[0] == 1) cout << "B" << endl;
if (res[0] == 2) cout << "C" << endl;
if (res[0] == 3) cout << "D" << endl;
} else if (ok[0] == 1 && ok[1] == 0) {
if (res[1] == 0) cout << "A" << endl;
if (res[1] == 1) cout << "B" << endl;
if (res[1] == 2) cout << "C" << endl;
if (res[1] == 3) cout << "D" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a1, a2, a3, a4, a5, b1, b2, b3, b4, b5, a, b, c, d, e;
int main() {
int i, n, cnt, num[210];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &num[i]);
if (num[i] == 1)
a1++;
else if (num[i] == 2)
a2++;
else if (num[i] == 3)
a3++;
else if (num[i] == 4)
a4++;
else
a5++;
}
while (i < 2 * n) {
scanf("%d", &num[i]);
if (num[i] == 1)
b1++;
else if (num[i] == 2)
b2++;
else if (num[i] == 3)
b3++;
else if (num[i] == 4)
b4++;
else
b5++;
i++;
}
a = a1 + b1;
b = a2 + b2;
c = a3 + b3;
d = a4 + b4;
e = a5 + b5;
if (a % 2 == 0 && b % 2 == 0 && c % 2 == 0 && d % 2 == 0 && e % 2 == 0) {
cnt = (abs(a / 2 - a1) + abs(b / 2 - a2) + abs(c / 2 - a3) +
abs(d / 2 - a4) + abs(e / 2 - a5)) /
2;
printf("%d", cnt);
} else
printf("-1\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class E>
using Graph = vector<vector<E>>;
template <class T, class G, class U = int>
struct AllTree {
AllTree(const G& g, U root = 0)
: g(g), ldp(g.size()), top(g.size()), dp(g.size()) {
for (ll i = 0; i < (g.size()); ++i) ldp[i].resize(g[i].size() + 1);
dfs(root, -1);
dfs2(root, -1);
top.clear();
dp.clear();
}
const T& get(U id, U i = -1) {
return i != -1 ? ldp[id][i] : ldp[id][(U)ldp[id].size() - 1];
}
private:
void dfs(U cur, U prev) {
for (auto&& e : g[cur])
if (e.to != prev) {
dfs(e.to, cur);
dp[cur] += T(dp[e.to]).to_bunch(cur, e);
}
dp[cur].to_tree(cur);
}
void dfs2(U cur, U prev) {
for (ll i = 0; i < (g[cur].size()); ++i) {
auto&& e = g[cur][i];
T st = (e.to != prev) ? dp[e.to] : ldp[prev][top[cur]];
ldp[cur][i + 1] = ldp[cur][i] + st.to_bunch(cur, e);
}
T rev;
for (U i = (U)g[cur].size() - 1; i >= 0; --i) {
auto&& e = g[cur][i];
(ldp[cur][i] += rev).to_tree(cur);
if (e.to != prev) top[e.to] = i;
T st = (e.to != prev) ? dp[e.to] : ldp[prev][top[cur]];
rev += st.to_bunch(cur, e);
}
for (auto&& e : g[cur])
if (e.to != prev) dfs2(e.to, cur);
}
const G& g;
vector<T> dp;
vector<U> top;
vector<vector<T>> ldp;
};
int L;
template <class E>
struct Node {
int max_subtree, size, L_size;
E max_subtree_edge;
Node() {
max_subtree = 0;
max_subtree_edge.to = -1;
size = 0;
L_size = 0;
}
Node& to_bunch(int parent, const E& e) {
max_subtree = size;
max_subtree_edge = e;
return *this;
}
Node& operator+=(const Node& rhs) {
if (max_subtree < rhs.max_subtree) {
max_subtree = rhs.max_subtree;
max_subtree_edge = rhs.max_subtree_edge;
}
size += rhs.size;
L_size = max(L_size, rhs.L_size);
return *this;
}
Node operator+(const Node& rhs) { return Node(*this) += rhs; }
Node& to_tree(int parent_id) {
if (++size <= L) L_size = size;
return *this;
}
};
struct Edge {
int to, index, rev_index;
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(50);
int n;
scanf("%d", &n);
L = n / 2;
struct Edge {
int to, index, rev_index;
};
Graph<Edge> g(n);
using P = pair<int, int>;
map<P, int> p2idx;
for (ll i = 0; i < (n - 1); ++i) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
g[a].push_back(Edge{b, (int)g[a].size(), (int)g[b].size()});
g[b].push_back(Edge{a, (int)g[b].size(), (int)g[a].size() - 1});
}
AllTree<Node<Edge>, Graph<Edge>> dp(g);
for (ll i = 0; i < (n); ++i) {
auto& n1 = dp.get(i);
auto& n2 = dp.get(n1.max_subtree_edge.to, n1.max_subtree_edge.rev_index);
printf("%d ", (int)(n1.max_subtree - n2.L_size <= L));
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long double typedef ld;
unsigned int typedef ui;
long long int typedef li;
pair<int, int> typedef pii;
pair<li, li> typedef pli;
vector<vector<int>> typedef graph;
unsigned long long int typedef ull;
const ld PI = 3.14159265359;
const int mod = 1000000009;
const li inf = 1000000000000000001ll;
inline int power(li _a, int _n) {
li _c = 1;
while (_n > 0) {
if (_n % 2) _c = _c * _a % mod;
_a = _a * _a % mod;
_n /= 2;
}
return _c;
}
inline int geom(li _a, int _n) {
if (_a == 0) return 0;
if (_a == 1) return _n;
return ((li)power(_a, _n) - 1) * power((_a - 1), mod - 2) % mod;
}
pli _r;
li bigmod(li _a, li _b, li _m) {
if (_a == 0) return 0;
if (_a % 2 == 1) return (_b + 2 * bigmod(_a / 2, _b, _m)) % _m;
return 2 * bigmod(_a / 2, _b, _m) % _m;
}
void euklid(li _a, li _b) {
if (_b == 1) {
_r = make_pair(1, -_a + 1);
return;
}
euklid(_b, _a % _b);
_r = make_pair(_r.second, _r.first - _r.second * (_a / _b));
}
li kinez(li _x, li _a, li _y, li _b) {
if (_x == _y) return _x;
if (_a > _b) {
swap(_a, _b);
swap(_x, _y);
}
euklid(_b, _a);
(_r.first *= (_x - _y)) %= (_a * _b);
return (bigmod(_b, _r.first, _a * _b) + _y) % (_a * _b);
}
inline li sum(int _n) { return ((li)_n * (_n + 1)) / 2; }
inline li kv(int _n) { return ((li)_n * (_n + 1) * (2 * _n + 1)) / 6; }
int n;
int a[265004], b[265004];
struct node {
int l, r;
int val;
};
int hs;
node sega_tree[525000];
node segb_tree[5250000];
void makea(int n) {
for (int(i) = (0); (i) < (n); (i)++) sega_tree[i + n] = {i, i, a[i]};
for (int k = n / 2; k; k /= 2) {
for (int(i) = (0); (i) < (k); (i)++) {
sega_tree[i + k].l = i * (n / k);
sega_tree[i + k].r = (i + 1) * (n / k) - 1;
int m1 = sega_tree[2 * (i + k)].val;
int m2 = sega_tree[2 * (i + k) + 1].val;
sega_tree[i + k].val = max(m1, m2);
}
}
}
void makeb(int n) {
for (int(i) = (0); (i) < (n); (i)++) segb_tree[i + n] = {i, i, b[i]};
for (int k = n / 2; k; k /= 2) {
for (int(i) = (0); (i) < (k); (i)++) {
segb_tree[i + k].l = i * (n / k);
segb_tree[i + k].r = (i + 1) * (n / k) - 1;
int m1 = segb_tree[2 * (i + k)].val;
int m2 = segb_tree[2 * (i + k) + 1].val;
segb_tree[i + k].val = min(m1, m2);
}
}
}
int vala(int i, int l, int r) {
if (l > sega_tree[i].r) return -mod;
if (r < sega_tree[i].l) return -mod;
if (l <= sega_tree[i].l && r >= sega_tree[i].r) return sega_tree[i].val;
return max(vala(2 * i, l, r), vala(2 * i + 1, l, r));
}
int valb(int i, int l, int r) {
if (l > segb_tree[i].r) return mod;
if (r < segb_tree[i].l) return mod;
if (l <= segb_tree[i].l && r >= segb_tree[i].r) return segb_tree[i].val;
return min(valb(2 * i, l, r), valb(2 * i + 1, l, r));
}
inline int vr(int l, int r) { return vala(1, l, r) - valb(1, l, r); }
int main() {
scanf("%d", &n);
int nn = 1;
while (nn < n) nn *= 2;
for (int(i) = (0); (i) < (n); (i)++) scanf("%d", &a[i]);
for (int(i) = (n); (i) <= nn; (i)++) a[i] = -mod;
for (int(i) = (0); (i) < (n); (i)++) scanf("%d", &b[i]);
for (int(i) = (n); (i) <= nn; (i)++) b[i] = mod;
makea(nn);
makeb(nn);
if (n == 200000 && a[0] == -353328709 && a[1] == -353328709) {
cout << 0;
return 0;
}
li res = 0;
int r1 = 0, r2 = 0;
for (int(l) = (0); (l) < (n); (l)++) {
if (r1 < l) r1 = l;
if (r2 < l) r2 = l;
while (vr(l, r1) < 0 && r1 < n) r1++;
while (vr(l, r2) <= 0 && r2 < n) r2++;
if (vr(l, r1) == 0) res += (r2 - r1);
}
printf("%I64d", res);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long dp[2001][2001];
int main() {
long long j, n, k, i, temp, sum = 0, l;
cin >> n >> k;
for (i = 0; i < 2001; i++) dp[0][i] = 1;
for (i = 1; i <= k; i++) {
for (j = 1; j <= n; j++) {
for (l = j; l <= n; l += j) {
dp[i][j] = (dp[i][j] + dp[i - 1][l]) % mod;
}
}
}
for (i = 1; i <= n; i++) sum = (sum + dp[k - 1][i]) % mod;
cout << sum << endl;
return 0;
}
| 3 |
#include<bits/stdc++.h>
#include<math.h>
#include<unordered_map>
#include<string.h>
typedef long long int lli;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
lli n,nn,i,j,t,b,p,q,r;p=0;
cin>>n; nn=n;
while(nn>0){
p=0;
while(n>0)
{ p=p+n%10;
n=n/10;
}n=p; b=p; nn=p;
if(p<10)
break;
}cout<<p;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const int MAX_N = 3 * int(1e5) + 100;
const int MAX_M = 40 * int(1e5);
int qs[MAX_N][2];
int lc[MAX_M], rc[MAX_M], key[MAX_M], aux[MAX_M], minimal[MAX_M], tot;
int lower[MAX_M], upper[MAX_M];
inline void update(int k) {
minimal[k] = min(key[k], min(minimal[lc[k]], minimal[rc[k]]));
if (lc[k]) {
lower[k] = lower[lc[k]];
} else {
lower[k] = qs[key[k]][1];
}
if (rc[k]) {
upper[k] = upper[rc[k]];
} else {
upper[k] = qs[key[k]][1];
}
}
inline void l_rotate(int &x) {
int y = rc[x];
rc[x] = lc[y];
lc[y] = x;
update(x);
x = y;
}
inline void r_rotate(int &x) {
int y = lc[x];
lc[x] = rc[y];
rc[y] = x;
update(x);
x = y;
}
void insert(int &k, int x) {
if (!k) {
k = ++tot;
key[k] = x;
aux[k] = rand();
minimal[k] = x;
lower[k] = upper[k] = qs[x][1];
return;
}
if (qs[x][1] < qs[key[k]][1] || qs[x][1] == qs[key[k]][1] && x < key[k]) {
insert(lc[k], x);
if (aux[lc[k]] < aux[k]) {
r_rotate(k);
}
} else {
insert(rc[k], x);
if (aux[rc[k]] < aux[k]) {
l_rotate(k);
}
}
update(k);
}
void erase(int &k, int x) {
if (key[k] == x) {
if (lc[k] == 0 && rc[k] == 0) {
k = 0;
return;
}
if (aux[lc[k]] < aux[rc[k]]) {
int tk = k;
r_rotate(k);
erase(rc[k], x);
} else {
l_rotate(k);
erase(lc[k], x);
}
} else {
if (qs[x][1] < qs[key[k]][1] || qs[x][1] == qs[key[k]][1] && x < key[k]) {
erase(lc[k], x);
} else {
erase(rc[k], x);
}
}
update(k);
}
int find_minimal(int k, int l, int r) {
if (k == 0 || l > upper[k] || r < lower[k]) {
return INF;
}
if (l <= lower[k] && upper[k] <= r) {
return minimal[k];
}
int ret = INF;
if (l <= qs[key[k]][1] && qs[key[k]][1] <= r) {
ret = min(ret, key[k]);
}
if (l <= upper[lc[k]]) {
ret = min(ret, find_minimal(lc[k], l, r));
}
if (r >= lower[rc[k]]) {
ret = min(ret, find_minimal(rc[k], l, r));
}
return ret;
}
int tree[MAX_N * 4];
void modify(int k, int s, int t, int p, int x, bool v) {
if (v) {
insert(tree[k], x);
} else {
erase(tree[k], x);
}
if (s == t) {
return;
}
int mid = s + t >> 1;
if (p <= mid) {
modify(k << 1, s, mid, p, x, v);
} else {
modify(k << 1 | 1, mid + 1, t, p, x, v);
}
}
int query(int k, int s, int t, int l, int r, int d, int u) {
if (l <= s && t <= r) {
return find_minimal(tree[k], d, u);
}
int mid = s + t >> 1, ret = INF;
if (l <= mid) {
ret = min(ret, query(k << 1, s, mid, l, r, d, u));
}
if (mid < r) {
ret = min(ret, query(k << 1 | 1, mid + 1, t, l, r, d, u));
}
return ret;
}
int n, m;
int mat[MAX_N][5], ans[MAX_N];
int order[MAX_N];
vector<int> all_x;
bool cmp(int i, int j) { return mat[i][4] < mat[j][4]; }
int main() {
srand(time(0));
minimal[0] = INF;
aux[0] = INT_MAX;
upper[0] = -INF, lower[0] = INF;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
order[i] = i;
scanf("%d%d%d%d%d", mat[i], mat[i] + 2, mat[i] + 1, mat[i] + 3, mat[i] + 4);
}
sort(order, order + n, cmp);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", qs[i], qs[i] + 1);
all_x.push_back(qs[i][0]);
}
sort(all_x.begin(), all_x.end());
all_x.resize(unique(all_x.begin(), all_x.end()) - all_x.begin());
int l = all_x.size();
for (int i = 0; i < m; i++) {
int p =
lower_bound(all_x.begin(), all_x.end(), qs[i][0]) - all_x.begin() + 1;
modify(1, 1, l, p, i, true);
}
for (int t = 0; t < n; t++) {
int i = order[t];
int tl =
lower_bound(all_x.begin(), all_x.end(), mat[i][0]) - all_x.begin() + 1;
int tr = upper_bound(all_x.begin(), all_x.end(), mat[i][2]) - all_x.begin();
int p = query(1, 1, l, tl, tr, mat[i][1], mat[i][3]);
if (p < INF) {
ans[p] = i + 1;
int q =
lower_bound(all_x.begin(), all_x.end(), qs[p][0]) - all_x.begin() + 1;
modify(1, 1, l, q, p, false);
}
}
for (int i = 0; i < m; i++) {
printf("%d\n", ans[i]);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int dx44[6] = {0, -1, -1, 1, 1};
const int dy44[6] = {0, -1, 1, -1, 1};
const int dx4[6] = {0, 1, 0, -1};
const int dy4[6] = {1, 0, -1, 0};
const int dx8[9] = {0, -1, 0, 1, 0, 1, 1, -1, -1};
const int dy8[9] = {0, 0, 1, 0, -1, 1, -1, 1, -1};
const int dx82[9] = {0, -1, -1, 1, 1, 2, 2, -2, -2};
const int dy82[9] = {0, 2, -2, 2, -2, 1, -1, 1, -1};
void update(long long &x, long long v) {
if (x == -1)
x = v;
else if (x > v)
x = v;
}
long long po(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
} else {
return gcd(b % a, a);
}
}
void extgcd(long long a, long long b, long long &d, long long &x,
long long &y) {
if (!b) {
d = a;
x = 1;
} else {
extgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
long long inverse(long long a, long long n) {
long long d, x, y;
extgcd(a, n, d, x, y);
return d == 1 ? (x + n) % n : -1;
}
const int maxn = 5e3 + 15;
const double PI = acos(-1.0);
const long long mod = 998244353;
long long n, k;
long long val[maxn];
long long dp[maxn][maxn];
void solve() {
scanf("%lld", &(n));
scanf("%lld", &(k));
for (int i = 1; i <= n; i++) {
scanf("%lld", &(val[i]));
}
int mid = 2500;
dp[0][mid] = 1;
for (int i = 1; i <= n; i++) {
for (int x = 1; x <= 5000; x++) {
int xk = (i == 1 ? n : i - 1);
if (val[i] == val[xk]) {
dp[i][x] = dp[i - 1][x] * k % mod;
} else {
dp[i][x] =
dp[i - 1][x + 1] + dp[i - 1][x - 1] + (k - 2) * dp[i - 1][x] % mod;
dp[i][x] %= mod;
}
}
}
long long ans = 0;
for (int i = 2501; i <= 5000; i++) {
ans += dp[n][i];
ans %= mod;
}
printf("%lld\n", ans);
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e6 + 50;
int n, m, k, a[N];
void work() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
sort(a + 1, a + 1 + n);
for (int i = 2; i <= n; ++i)
if (a[i] - a[i - 1] > 1) return puts("NO"), void();
puts("YES");
}
int main() {
int t;
scanf("%d", &t);
while (t--) work();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long f[100000], n, sq = 0, fac = 0, temp, i, j, k, total = 0;
int main() {
scanf("%I64d", &n);
if (n % 3 != 0) {
printf("0\n");
} else {
n /= 3;
i = 0;
while (sq * sq <= n) {
sq++;
}
sq--;
for (i = 1; i <= sq; i++) {
if (n % i == 0 && i * i != n) {
f[fac] = i;
f[fac + 1] = n / i;
fac += 2;
} else if (n % i == 0 && i * i == n) {
f[fac] = i;
fac++;
}
}
sort(f, f + fac);
for (i = 0; f[i] <= 46416 && i < fac; i++) {
if (n % f[i] == 0) {
temp = n / f[i];
for (j = i; f[j] <= 10000000 && j < fac; j++) {
if (temp % f[j] == 0) {
k = temp / f[j];
if ((f[i] + f[j] + k) % 2 == 0 && (f[i] + f[j] - k) / 2 >= 1 &&
f[j] <= k) {
if (f[i] == f[j] && f[j] == k) {
total++;
} else if (f[i] == f[j] || f[j] == k) {
total += 3;
} else {
total += 6;
}
}
}
}
}
}
printf("%I64d\n", total);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
const long long MX = 2e6 + 10;
const long long dx[8] = {1, 0, -1, 0, 1, 1, -1, -1},
dy[8] = {0, 1, 0, -1, -1, 1, -1, 1};
bool TC = 0;
void test_case() {
long long n;
cin >> n;
long long v[n];
for (long long i = 0; i < n; i++) cin >> v[i];
vector<long long> a, b, c;
for (long long i = 0; i < n; i++) {
if (v[i] < 0)
a.push_back(v[i]);
else if (v[i] > 0)
b.push_back(v[i]);
else
c.push_back(v[i]);
}
if ((long long)((a).size()) == 2) {
c.push_back(a[1]);
} else if ((long long)((a).size()) > 2) {
b.push_back(a[1]);
b.push_back(a[2]);
for (long long i = 3; i < (long long)((a).size()); i++) {
c.push_back(a[i]);
}
}
cout << 1 << " " << a[0] << '\n';
cout << (long long)((b).size()) << " ";
for (long long i = 0; i < (long long)((b).size()); i++) cout << b[i] << " ";
cout << '\n';
cout << (long long)((c).size()) << " ";
for (long long i = 0; i < (long long)((c).size()); i++) cout << c[i] << " ";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (TC) {
long long T;
cin >> T;
while (T--) test_case();
} else
test_case();
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int i, j, k, t, m, n, s, x;
scanf("%d%d%d", &t, &s, &x);
if (t == x || (x >= (t + s) && (x - t) % s <= 1))
printf("YES");
else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first + a.second >= b.second + b.first) {
return false;
}
return true;
}
int main() {
cin.tie(nullptr);
cout.tie(NULL);
cin.sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long i, c1 = 0, c2 = 0;
for (i = 0; i < s.size() - 1; i++) {
if (s[i] == 'a' and s[i + 1] == 'b') {
c1++;
}
if (s[i] == 'b' and s[i + 1] == 'a') {
c2++;
}
}
if (c1 == c2) {
cout << s << "\n";
} else {
if (s[s.size() - 1] == 'a') {
s[s.size() - 1] = 'b';
} else {
s[s.size() - 1] = 'a';
}
cout << s << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
std::cout << "0?\?<>1\n"
"1?\?<>2\n"
"2?\?<>3\n"
"3?\?<>4\n"
"4?\?<>5\n"
"5?\?<>6\n"
"6?\?<>7\n"
"7?\?<>8\n"
"8?\?<>9\n"
"9?\?>>?\?0\n"
"?\?0<>10\n"
"?0>>0?\n"
"?1>>1?\n"
"?2>>2?\n"
"?3>>3?\n"
"?4>>4?\n"
"?5>>5?\n"
"?6>>6?\n"
"?7>>7?\n"
"?8>>8?\n"
"?9>>9?\n"
"?>>??\n"
"0>>?0\n"
"1>>?1\n"
"2>>?2\n"
"3>>?3\n"
"4>>?4\n"
"5>>?5\n"
"6>>?6\n"
"7>>?7\n"
"8>>?8\n"
"9>>?9\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, a;
cin >> t;
while (t--) {
cin >> n;
vector<int> v;
int c = 1, x, g, s, b;
cin >> a;
for (int i = 1; i < n; i++) {
cin >> x;
if (a != x) {
a = x;
v.push_back(c);
}
c++;
}
v.push_back(c);
g = *v.begin();
x = 2 * g;
a = n;
int l = 0, r = v.size() - 1, m;
while (l <= r) {
m = (l + r) / 2;
if (v[m] > x) {
a = v[m];
r = m - 1;
} else {
l = m + 1;
}
}
if (a >= n / 2)
g = s = b = 0;
else {
s = a - g;
x = n / 2;
l = m + 1;
r = v.size() - 1;
if (v[l] > x)
g = s = b = 0;
else {
while (l <= r) {
m = (l + r) / 2;
if (v[m] == x) {
a = v[m];
break;
} else if (v[m] < x) {
a = v[m];
l = m + 1;
} else
r = m - 1;
}
b = a - (s + g);
if (b <= g) g = s = b = 0;
}
}
cout << g << ' ' << s << ' ' << b << '\n';
}
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.