solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
int main() {
int T, S, q, q1, z = 1, a = 0, r, d;
scanf("%d%d%d", &T, &S, &q);
while (S < T) {
S *= q;
a++;
}
printf("%d", a);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
while (t > 0) {
--t;
int n, ans = 0;
scanf("%d", &n);
char a[2][n + 2];
scanf("%s %s", &a[1], &a[0]);
a[1][n] = -1;
for (int i = 0; i < n; ++i) {
if (a[0][i] == '1') {
if (a[1][i] == '0')
ans++, a[1][i] = '3';
else if (a[1][i - 1] == '1' && i - 1 >= 0)
ans++, a[1][i - 1] = '3';
else if (a[1][i + 1] == '1')
ans++, a[1][i + 1] = '3';
}
}
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int>
using V = vector<T>;
template <class T = int>
using VV = V<V<T> >;
template <class Z>
map<Z, int> factorize(Z n) {
map<Z, int> res;
for (Z i = 2; i * i <= n; ++i)
while (n % i == 0) ++res[i], n /= i;
if (n != 1) ++res[n];
return res;
}
constexpr lint inf = 9e18;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
V<> a(n);
lint sum = 0;
for (auto&& e : a) {
cin >> e;
sum += e;
}
lint res = inf;
for (const auto& p : factorize(sum)) {
lint d = p.first;
lint s = 0, crr = 0;
for (int e : a) {
s = (s + e) % d;
crr += min(s, d - s);
}
res = min(res, crr);
}
cout << (res < inf ? res : -1) << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define mod 998244353
int pot(int v, int n){
if(n == 1)
return v;
int u = pot(v, n/2);
if(n % 2)
return (long long) u * u % mod * v % mod;
return (long long) u * u % mod;
}
int main(){
int n, a = 1, b = 1, i;
a = b = 1;
cin >> n;
for(i = 2; i < n; i++){
swap(a, b);
b = (a + b) % mod;
}
cout << (long long) b * pot(pot(2, mod - 2), n) % mod << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long parent[200001], Rank[200001];
void init() {
for (long long i = 0; i < 200001; i++) {
Rank[i] = 0;
parent[i] = i;
}
}
long long find(long long a) {
return parent[a] = (parent[a] == a) ? a : find(parent[a]);
}
void merge(long long a, long long b) {
a = find(a);
b = find(b);
if (Rank[a] == Rank[b]) {
Rank[a]++;
}
if (Rank[a] > Rank[b]) {
parent[b] = a;
} else {
parent[a] = b;
}
}
void solve() {
init();
long long n;
cin >> n;
vector<string> v(n);
map<char, vector<long long>> m;
for (long long i = 0; i < n; i++) {
cin >> v[i];
for (long long j = 0; j < ((int)(v[i]).size()); j++)
m[v[i][j]].push_back(i);
};
for (auto& it : m) {
for (long long i = 0; i < ((int)(it.second).size()); i++) {
merge(it.second[0], it.second[i]);
}
}
set<long long> s;
for (long long i = 0; i < n; i++) {
s.insert(find(i));
}
cout << ((int)(s).size()) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, i, c, d, e, mas[600009], k, pas, j, ans;
int main() {
cin >> a >> k;
for (i = 1; i <= a; i++) cin >> mas[i];
for (i = 0; i < 100000; i++) i++;
for (i = 0; i < k; i++) {
d = 0;
e = 0;
for (j = 1; j <= a; j++) {
if (j % k != i) {
if (mas[j] == 1)
d++;
else
e++;
}
}
if (ans < abs(d - e)) ans = abs(d - e);
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using datas = pair<ll, ll>;
using ddatas = pair<long double, long double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
constexpr ll mod = 1000000007;
constexpr ll inf = 1LL << 60;
constexpr long double eps = 1e-9;
const long double PI = acosl(-1);
template <class T, class E>
ostream& operator<<(ostream& os, const pair<T, E>& p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
bool f = false;
for (auto& x : v) {
if (f) os << ",";
os << x;
f = true;
}
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "{";
bool f = false;
for (auto& x : v) {
if (f) os << ",";
os << x;
f = true;
}
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "{";
bool f = false;
for (auto& x : v) {
if (f) os << ",";
os << x;
f = true;
}
os << "}";
return os;
}
template <class T, class E>
ostream& operator<<(ostream& os, const map<T, E>& v) {
os << "{";
bool f = false;
for (auto& x : v) {
if (f) os << ",";
os << x;
f = true;
}
os << "}";
return os;
}
template <class T>
inline bool chmax(T& a, const T b) {
bool x = a < b;
if (x) a = b;
return x;
}
template <class T>
inline bool chmin(T& a, const T b) {
bool x = a > b;
if (x) a = b;
return x;
}
inline void startupcpp(void) noexcept {
cin.tie(0);
ios::sync_with_stdio(false);
}
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(S, F),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(vector<S>(n, e())) {}
lazy_segtree(const vector<S>& v) : _n(int(v.size())) {
log = 0;
while ((1U << log) < (unsigned int)(_n)) ++log;
size = 1 << log;
d = vector<S>(size << 1, e());
lz = vector<F>(size, id());
for (int i = 0; i < _n; ++i) d[size + i] = v[i];
for (int i = size - 1; i >= 1; --i) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; --i) push(p >> i);
d[p] = x;
for (int i = 1; i <= log; ++i) update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; --i) push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return e();
l += size;
r += size;
for (int i = log; i >= 1; --i) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; --i) push(p >> i);
d[p] = mapping(d[p], f);
for (int i = 1; i <= log; ++i) update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return;
l += size;
r += size;
for (int i = log; i >= 1; --i) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1) all_apply(l++, f);
if (r & 1) all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; ++i) {
if (((l >> i) << i) != l) update(l >> i);
if (((r >> i) << i) != r) update((r - 1) >> i);
}
}
template <bool (*g)(S)>
int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G>
int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n) return _n;
l += size;
for (int i = log; i >= 1; --i) push(l >> i);
S sm = e();
do {
while (~l & 1) l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l <<= 1;
if (g(op(sm, d[l]))) {
sm = op(sm, d[l++]);
}
}
return l - size;
}
sm = op(sm, d[l++]);
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)>
int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G>
int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0) return 0;
r += size;
for (int i = log; i >= 1; --i) push((r - 1) >> i);
S sm = e();
do {
--r;
while (r >> 1 && (r & 1)) r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = r << 1 | 1;
if (g(op(d[r], sm))) {
sm = op(d[r--], sm);
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
int _n;
private:
int size, log;
vector<S> d;
vector<F> lz;
void update(int k) { d[k] = op(d[k << 1], d[k << 1 | 1]); }
void all_apply(int k, F f) {
d[k] = mapping(d[k], f);
if (k < size) lz[k] = composition(lz[k], f);
}
void push(int k) {
all_apply(k << 1, lz[k]);
all_apply(k << 1 | 1, lz[k]);
lz[k] = id();
}
friend ostream& operator<<(
ostream& os,
const lazy_segtree<S, op, e, F, mapping, composition, id>& p) {
lazy_segtree<S, op, e, F, mapping, composition, id> printout(p);
for (int i = 0; i < printout._n; ++i) {
os << "{,"[i > 0] << printout.prod(i, i + 1);
}
os << "}";
return os;
}
};
namespace segtreefunction {
bool op(bool a, bool b) { return a | b; }
bool e() { return false; }
} // namespace segtreefunction
using segtree =
lazy_segtree<bool, segtreefunction::op, segtreefunction::e, bool,
segtreefunction::op, segtreefunction::op, segtreefunction::e>;
struct unionfind {
private:
int maxN;
vector<int> par, treesize;
public:
unionfind(int N) : maxN(N), par(N), treesize(N, 1) {
for (int i = 0; i < maxN; ++i) par[i] = i;
}
int root(int x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (treesize[x] > treesize[y]) swap(x, y);
par[x] = y;
treesize[y] += treesize[x];
return true;
}
bool unite(pair<int, int> v) { return unite(v.first, v.second); }
bool parcheck(int x, int y) { return root(x) == root(y); }
bool parcheck(pair<int, int> v) { return parcheck(v.first, v.second); }
int size(int x) { return treesize[root(x)]; }
void clear() {
treesize.assign(maxN, 1);
for (int i = 0; i < maxN; ++i) par[i] = i;
}
vector<vector<int>> groups() {
vector<vector<int>> res(maxN);
for (int i = 0; i < maxN; ++i) res[root(i)].emplace_back(i);
vector<vector<int>> res2;
for (vector<int> x : res) {
if (x.size()) res2.emplace_back(x);
}
return res2;
}
};
struct HLD {
private:
vector<vector<int>> g;
int fdfs(int now, int p) {
int d = 0;
par[now] = p;
for (size_t i = 0; i + 1 < g[now].size(); ++i) {
if (g[now][i] == p) swap(g[now][i], g[now].back());
if (chmax(d, fdfs(g[now][i], now))) swap(g[now][0], g[now][i]);
}
g[now].pop_back();
return d + 1;
}
void sdfs(int now) {
in[now] = ETlist.size();
ETlist.emplace_back(now);
for (size_t i = 0; i < g[now].size(); ++i) {
nxt[g[now][i]] = i ? g[now][i] : nxt[now];
sdfs(g[now][i]);
}
out[now] = ETlist.size();
}
public:
vector<int> par, nxt, in, out, ETlist;
segtree solvetree;
HLD(int N) : g(N), par(N), nxt(N), in(N), out(N), solvetree(N) {
ETlist.reserve(N);
};
void add_edge(int a, int b) {
g[a].emplace_back(b);
g[b].emplace_back(a);
}
void init(int first = 0) {
{
int d = 0;
par[first] = -1;
for (auto& x : g[first])
if (chmax(d, fdfs(x, first))) swap(x, g[first][0]);
}
nxt[first] = first;
sdfs(first);
}
int lca(int a, int b) {
if (in[a] > in[b]) swap(a, b);
if (nxt[a] == nxt[b]) return a;
return lca(a, par[nxt[b]]);
}
bool solveprod(int a, int b) {
if (in[a] > in[b]) swap(a, b);
if (nxt[a] == nxt[b]) return solvetree.prod(in[a] + 1, in[b] + 1);
return solveprod(a, par[nxt[b]]) | solvetree.prod(in[nxt[b]], in[b] + 1);
}
void solveapply(int a, int b) {
if (in[a] > in[b]) swap(a, b);
if (nxt[a] == nxt[b])
solvetree.apply(in[a] + 1, in[b] + 1, true);
else {
solveapply(a, par[nxt[b]]);
solvetree.apply(in[nxt[b]], in[b] + 1, true);
}
}
};
vector<vector<pair<int, int>>> g;
vector<bool> xorlist;
int N, Q;
void dfs(int now = 0, int par = -1, bool s = false) {
xorlist[now] = s;
for (auto& [f, to] : g[now]) {
if (to == par) continue;
dfs(to, now, s ^ f);
}
}
int main() {
startupcpp();
cin >> N >> Q;
g.resize(N);
HLD hld(N);
unionfind dsu(N);
vector<bool> ans(Q);
vector<tuple<int, int, int, bool>> edge;
for (int i = 0; i < Q; ++i) {
int u, v, w;
cin >> u >> v >> w;
--u;
--v;
if (dsu.unite(u, v)) {
ans[i] = true;
g[u].emplace_back(w, v);
g[v].emplace_back(w, u);
hld.add_edge(u, v);
} else
edge.emplace_back(i, u, v, !w);
}
for (int i = 1; i < N; ++i)
if (dsu.unite(0, i)) {
g[0].emplace_back(0, i);
hld.add_edge(0, i);
}
hld.init();
xorlist.resize(N);
dfs();
for (auto& [id, u, v, w] : edge) {
if ((xorlist[u] ^ xorlist[v] ^ w) || hld.solveprod(u, v)) {
ans[id] = false;
continue;
}
ans[id] = true;
hld.solveapply(u, v);
}
for (auto f : ans) {
if (f)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
if (!(N & 1))
cout << "NO\n";
else {
long long int* arr = new long long int[2 * N];
int cur = 0;
for (int i = 1; i <= 2 * N; ++i) {
arr[cur] = i;
if (i & 1)
cur = (cur + N) % (2 * N);
else
cur = (cur + 1) % (2 * N);
}
cout << "YES\n";
for (int i = 0; i < 2 * N; ++i) cout << arr[i] << " ";
cout << endl;
delete[] arr;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string getExp(string s) {
string t = "";
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(') {
++i;
while (s[i] != ')' && s[i] != ',') {
if (s[i] != ' ') t.push_back(s[i]);
++i;
}
break;
}
}
return t;
}
string getMsg(string s) {
string t = "";
for (int i = 0; i < s.size(); i++) {
if (s[i] == '\"') {
++i;
while (s[i] != '\"') {
t.push_back(s[i]);
++i;
}
break;
}
}
return t;
}
int main() {
string s[100005];
int n;
cin >> n;
cin.ignore();
int expIdx;
string myExp;
stack<int> stk;
int endd[100005];
for (int i = 0; i < n; i++) {
getline(cin, s[i]);
if (s[i].find("throw") != std::string::npos) {
endd[i] = -1;
expIdx = i;
myExp = getExp(s[i]);
} else if (s[i].find("catch") != string::npos) {
endd[i] = -1;
endd[stk.top()] = i;
stk.pop();
} else if (s[i].find("try") != string::npos) {
stk.push(i);
}
}
int myMsgIdx = -1;
for (int i = expIdx - 1; i >= 0; --i) {
if (endd[i] > expIdx && getExp(s[endd[i]]) == myExp) {
myMsgIdx = endd[i];
break;
}
}
if (myMsgIdx == -1) {
cout << "Unhandled Exception" << endl;
} else {
cout << getMsg(s[myMsgIdx]) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
void string_reader(string s, vector<T> &vec) {
istringstream sin(s);
copy(istream_iterator<T>(sin), istream_iterator<T>(), back_inserter(vec));
}
const int LEN = 100001;
const int N = 10;
char src[LEN], b[N][N + 1];
int n, len[N];
int is_end(int now) {
int ret = -1;
for (int i = 0; i < int(n); ++i) {
int pos = now - len[i] + 1;
if (pos >= 0 && strncmp(src + pos, b[i], len[i]) == 0) ret = max(ret, pos);
}
return ret;
}
int main() {
while (cin >> src >> n) {
for (int i = 0; i < int(n); ++i) cin >> b[i];
for (int i = 0; i < int(n); ++i) len[i] = strlen(b[i]);
int src_len = strlen(src);
int beg = -1;
int len = 0, pos = -1;
for (int i = 0; i < int(src_len); ++i) {
beg = max(beg, is_end(i));
if (checkmax(len, i - beg)) pos = beg;
}
cout << len << " " << pos + 1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
void __never(int a) { printf("\nOPS %d", a); }
int n;
long long p, x, y;
int A[1000100];
struct MA {
long long m[2][2];
MA(long long a00 = 0, long long a01 = 0, long long a10 = 0,
long long a11 = 0) {
m[0][0] = a00;
m[0][1] = a01;
m[1][0] = a10;
m[1][1] = a11;
}
};
MA mul(MA A, MA B) {
MA re;
for (int a = (0); a <= (1); a++)
for (int b = (0); b <= (1); b++)
for (int c = (0); c <= (1); c++)
(re.m[a][b] += A.m[a][c] * B.m[c][b]) %= p;
return re;
}
MA power(MA m, long long n) {
if (n == 0) return MA(1, 0, 0, 1);
if (n == 1) return m;
MA re = power(m, n >> 1);
re = mul(re, re);
if (n & 1) re = mul(re, m);
return re;
}
void sol() {
if (n == 1) {
cout << A[1] % p;
return;
}
long long sum = 0;
for (int a = (1); a <= (n); a++) (sum += A[a]) %= p;
MA m1 = power(MA(3, p - 1, 0, 1), x);
long long s2 =
(m1.m[0][0] * sum + m1.m[0][1] * ((long long)(A[1] + A[n]))) % p;
MA m2 = power(MA(0, 1, 1, 1), x);
long long Aa = (m2.m[1][0] * A[n - 1] + m2.m[1][1] * A[n]) % p;
MA m3 = power(MA(3, p - 1, 0, 1), y);
long long s3 = (m3.m[0][0] * s2 + m3.m[0][1] * (A[1] + Aa)) % p;
cout << s3 << "\n";
}
void stupid_sol() {
vector<int> vec;
for (int a = (1); a <= (n); a++) vec.push_back(A[a]);
for (int a = (1); a <= (x); a++) {
vector<int> vec2;
for (int b = (0); b <= ((int)((vec).size()) - 1); b++) {
vec2.push_back(vec[b]);
if (b != (int)((vec).size()) - 1) vec2.push_back(vec[b] + vec[b + 1]);
}
vec = vec2;
}
sort(vec.begin(), vec.end());
for (int a = (1); a <= (y); a++) {
vector<int> vec2;
for (int b = (0); b <= ((int)((vec).size()) - 1); b++) {
vec2.push_back(vec[b]);
if (b != (int)((vec).size()) - 1) vec2.push_back(vec[b] + vec[b + 1]);
}
vec = vec2;
}
long long sum = 0;
for (int a = (0); a <= ((int)((vec).size()) - 1); a++) (sum += vec[a]) %= p;
cout << sum << "\n";
}
int main() {
cin >> n >> x >> y >> p;
for (int a = (1); a <= (n); a++) {
scanf("%d", &A[a]);
A[a] %= p;
}
sol();
return 0;
}
| 9 |
#include <bits/stdc++.h>
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;
}
};
mt19937 myrand(time(0));
int main() {
ios::sync_with_stdio(0);
cin.tie(), cout.tie();
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string str;
cin >> str;
vector<int> v, idx;
for (int i = 0; i < n; i++) {
int j = i;
while (j < n && str[i] == str[j]) j++;
v.push_back(j - i);
if ((j - i) > 1) idx.push_back((int)v.size() - 1);
i = j - 1;
}
int ans = 0, id = 0;
for (int i = 0; i < (int)v.size(); i++) {
if (i == ((int)v.size() - 1))
ans++;
else {
if (v[i] > 1)
ans++, id++;
else {
ans++;
if (id < (int)idx.size()) {
if (--v[idx[id]] == 1) id++;
} else
i++;
}
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
deque<int> bit;
int main() {
long long n, m;
long long digits = 0;
long long i;
int flag = 0;
scanf("%lld %lld", &n, &m);
while (n) {
if (n & 1) bit.push_front(digits);
n >>= 1;
digits++;
}
int a = bit.size(), t;
if (a > m)
puts("NO");
else {
puts("YES");
long long c = m - a;
while (c > 0) {
t = bit.front();
long long cnt = 0;
for (deque<int>::iterator it = bit.begin(); it != bit.end(); it++) {
if (*it == t)
cnt++;
else
break;
}
if (cnt > c) break;
c -= cnt;
for (int k = 0; k < cnt; k++) bit.pop_front();
for (int k = 0; k < 2 * cnt; k++) bit.push_front(t - 1);
}
while (c--) {
t = bit.back();
bit.pop_back();
bit.push_back(t - 1);
bit.push_back(t - 1);
}
for (deque<int>::iterator it = bit.begin(); it != bit.end(); it++) {
printf("%d ", *it);
}
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
namespace ringo {
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) f ^= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (f) x = -x;
}
template <class T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar('0' + x % 10);
}
template <class T>
inline void print(T x, char c) {
print(x), putchar(c);
}
template <class T>
inline void print(T a, int l, int r, std::string s = "") {
if (s != "") std::cout << s << ": ";
for (int i = l; i <= r; i++) print(a[i], " \n"[i == r]);
}
const int N = 3e5 + 10, mod = 1e9 + 7;
std::map<int, int> map;
int n, cnt, ans, nod, max, lim;
int a[N], s[N], pri[N], vis[N], fac[N], ifac[N], f[N], g[N], c[N][20];
inline int get_prime(int x) {
auto it = map.find(x);
return it == map.end() ? map[x] = ++nod : it->second;
}
void init_fac(int n) {
g[0] = fac[0] = ifac[0] = ifac[1] = 1;
for (int i = 1; i <= n; i++) fac[i] = (long long)fac[i - 1] * i % mod;
for (int i = 2; i <= n; i++)
ifac[i] = (long long)(mod - mod / i) * ifac[mod % i] % mod;
for (int i = 1; i <= n; i++) ifac[i] = (long long)ifac[i - 1] * ifac[i] % mod;
for (int i = 1; i <= n - 1; i++)
g[i] =
(g[i - 1] + (long long)fac[n - 1] * ifac[i] % mod * ifac[n - i - 1]) %
mod;
for (int i = 1; i <= n; i++)
f[i] = ((long long)g[n - 1] - g[n - i] - g[n - i - 1] + mod + mod) % mod;
for (int i = 1; i <= n; i++) s[i] = (s[i - 1] + f[i]) % mod;
}
void main() {
read(n), init_fac(n);
for (int i = 1; i <= n; i++) read(a[i]), max = std::max(max, a[i]);
lim = sqrt(max);
for (int i = 2; i <= lim; i++) {
if (!vis[i]) pri[++cnt] = i;
for (int j = 1; j <= cnt && i * pri[j] <= lim; j++) {
vis[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
nod = cnt;
std::cerr << "clock: " << clock() / double(CLOCKS_PER_SEC) << std::endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= cnt; j++)
if (a[i] % pri[j] == 0) {
int tik = 0;
while (a[i] % pri[j] == 0) ++tik, a[i] /= pri[j];
++c[j][tik];
}
if (a[i] != 1) {
++c[get_prime(a[i])][1];
}
}
std::cerr << "clock: " << clock() / double(CLOCKS_PER_SEC) << std::endl;
for (int i = 1; i <= nod; i++) {
int p = n;
for (int j = 1; j < 20; j++) p -= c[i][j];
for (int j = 1; j < 20; j++) {
ans = (ans + (long long)j * (s[p + c[i][j]] - s[p] + mod)) % mod;
p += c[i][j];
}
}
std::cerr << "clock: " << clock() / double(CLOCKS_PER_SEC) << std::endl;
print(ans, '\n');
}
} // namespace ringo
signed main() { return ringo::main(), 0; }
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e7 + 10;
int n, a[maxn], b[maxn] = {0};
int main() {
ios::sync_with_stdio(false);
int i, j, k, max1 = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]]++;
max1 = max(max1, a[i]);
}
long long l, r, min1 = 1e15;
for (i = 1; i <= max1; i++) {
vector<long long> v;
for (j = i; j <= max1; j += i) {
if (!b[j]) continue;
for (k = 0; k < min(2, b[j]); k++) v.push_back(j);
if (v.size() >= 2) break;
}
if (v.size() >= 2) {
long long sum = v[0] / i * v[1];
if (sum < min1) min1 = sum, l = v[0], r = v[1];
}
}
for (i = 1; i <= n; i++) {
if (a[i] == l) {
l = i;
break;
}
}
for (i = 1; i <= n; i++) {
if (a[i] == r && i != l) {
r = i;
break;
}
}
if (l > r) swap(l, r);
cout << l << " " << r << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
register long long x = 0;
register bool f = false;
register char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = true;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + ch - '0';
return f ? ~x + 1 : x;
}
inline void write(long long x) {
register char F[200];
register long long tmp = x > 0 ? x : -x;
if (x < 0) putchar('-');
register long long cnt = 0;
if (tmp == 0) F[cnt++] = '0';
while (tmp > 0) {
F[cnt++] = tmp % 10 + '0';
tmp /= 10;
}
while (cnt > 0) putchar(F[--cnt]);
}
const long long N = 2e5 + 5;
long long d, n, m;
struct node {
long long x, p;
} a[N];
inline long long cmp(node x, node y) { return x.x < y.x; }
long long stac[N], top;
long long to[N];
long long ans;
signed main() {
d = read(), n = read(), m = read();
for (long long i = 1; i <= m; i++) a[i] = (node){read(), read()};
sort(a + 1, a + m + 1, cmp);
a[m + 1] = (node){d, -1};
stac[++top] = m + 1;
for (long long i = m; i >= 0; i--) {
while (top && a[stac[top]].p > a[i].p) top--;
to[i] = stac[top];
stac[++top] = i;
}
long long point = n;
for (long long i = 0; i <= m; i++) {
long long dis = max(0ll, min(a[to[i]].x - a[i].x, n) - point);
ans += 1ll * dis * a[i].p;
point -= a[i + 1].x - a[i].x - dis;
if (point < 0) {
puts("-1");
return 0;
}
}
write(ans);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int AKA = 5e7 + 5;
int frq[AKA];
int arr[300005];
int a[300005];
vector<int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int ts;
cin >> ts;
while (ts--) {
int n;
cin >> n;
int diff = n % 3;
n -= diff;
int c1, c2;
c1 = n / 3;
c2 = (n - c1) / 2;
if ((c1 + diff) + 2 * c2 == n + diff && abs((c1 + diff) - c2) <= 1)
cout << c1 + diff << " " << c2 << endl;
else
cout << c1 << " " << (c2 + diff / 2) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5, LogN = 20;
template <typename T>
void read(T &x) {
bool neg = false;
unsigned char c = getchar();
for (; (c ^ 48) > 9; c = getchar())
if (c == '-') neg = true;
for (x = 0; (c ^ 48) < 10; c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48);
if (neg) x = -x;
}
int q, cnt = 1, logn = 19, fa[N][LogN], p[N][LogN];
long long w[N][LogN], s[N][LogN];
long long max(long long a, long long b) { return a > b ? a : b; }
int main() {
int last = 0;
for (int i = 0, i_end = logn + 1; i < i_end; ++i) p[0][i] = -1;
read(q);
while (q--) {
int op, pp;
long long qq;
read(op);
read(pp);
read(qq);
if (op == 1) {
int r = pp ^ last, u = cnt++;
long long ww = qq ^ last;
fa[u][0] = --r;
for (int i = 0, i_end = logn; i < i_end; ++i)
fa[u][i + 1] = fa[fa[u][i]][i];
w[u][0] = ww;
for (int i = 0, i_end = logn; i < i_end; ++i)
w[u][i + 1] = max(w[u][i], w[fa[u][i]][i]);
p[u][0] = fa[u][0];
for (int i = logn - 1; ~i; --i)
if (w[p[u][0]][i] < w[u][0]) p[u][0] = fa[p[u][0]][i];
if (w[p[u][0]][0] < w[u][0]) p[u][0] = -1;
if (~p[u][0]) s[u][0] = ww;
for (int i = 0, i_end = logn; i < i_end; ++i) {
if (!~p[u][i]) {
for (int j = i, j_end = logn; j < j_end; ++j) p[u][j + 1] = -1;
break;
}
s[u][i + 1] = s[u][i] + s[p[u][i]][i];
p[u][i + 1] = p[p[u][i]][i];
}
} else {
int u = pp ^ last, ans = 0;
--u;
long long x = qq ^ last;
for (int i = logn - 1; ~i; --i) {
if (!~p[u][i]) continue;
if (s[u][i] > x) continue;
x -= s[u][i];
u = p[u][i];
ans += 1 << i;
}
if (w[u][0] <= x) ++ans;
printf("%d\n", last = ans);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
long long n;
long long spr(long long a) {
cout << "? " << a << endl;
long long ans1;
cin >> ans1;
long long b = (a + n / 2) % n;
if (b == 0) b = n;
cout << "? " << b << endl;
long long ans2;
cin >> ans2;
return ans2 - ans1;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n % 4 != 0) {
cout << "! -1" << endl;
return 0;
}
long long l = 1, r = n / 2 + 1;
long long ans = spr(1);
bool fl = true;
if (ans == 0) {
cout << "! 1" << endl;
return 0;
}
if (ans > 0) {
fl = false;
}
while (r - l > 1) {
long long m = (l + r) / 2;
long long que = spr(m);
if (fl) {
if (que == 0) {
cout << "! " << m << endl;
return 0;
} else if (que > 0) {
r = m;
} else
l = m;
} else {
if (que == 0) {
cout << "! " << m << endl;
return 0;
} else if (que > 0) {
l = m;
} else
r = m;
}
}
cout << "! " << l << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
const int maxm = 110;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
int n, m;
struct Matrix {
long long ma[maxm][maxm];
};
Matrix MM;
Matrix Mult(Matrix x, Matrix y) {
Matrix tmp;
for (int i = 0; i <= 101; i++) {
for (int j = 0; j <= 101; j++) {
tmp.ma[i][j] = 0;
for (int k = 0; k <= 101; k++) {
tmp.ma[i][j] += x.ma[i][k] * y.ma[k][j];
if (tmp.ma[i][j] >= mod) tmp.ma[i][j] %= mod;
}
}
}
return tmp;
}
Matrix Pow(Matrix x, int k) {
Matrix tmp;
int i, j;
for (i = 0; i < 101; i++)
for (j = 0; j < 101; j++) tmp.ma[i][j] = (i == j);
while (k) {
if (k & 1) tmp = Mult(tmp, x);
x = Mult(x, x);
k >>= 1;
}
return tmp;
}
long long a[maxn];
long long dp[maxn];
long long sum[maxn];
int main() {
int i, j;
while (scanf("%d%d", &n, &m) != EOF) {
memset(a, 0, sizeof(a));
memset(MM.ma, 0, sizeof(MM.ma));
for (i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[x]++;
}
memset(dp, 0, sizeof(dp));
dp[0] = 1;
sum[0] = 0;
for (i = 1; i <= 100; i++) {
for (j = 1; j <= i; j++) {
dp[i] += dp[i - j] * a[j];
dp[i] %= mod;
}
sum[i] = sum[i - 1] + dp[i];
sum[i] %= mod;
}
if (m <= 100) {
printf("%I64d\n", sum[m] + 1);
continue;
}
memset(MM.ma, 0, sizeof(MM.ma));
for (i = 1; i <= 100; i++) {
MM.ma[i][100] = MM.ma[i][101] = a[101 - i];
}
MM.ma[101][101] = 1;
for (i = 2; i <= 100; i++) {
MM.ma[i][i - 1] = 1;
}
MM = Pow(MM, m - 100);
long long ans = sum[100];
for (i = 1; i <= 100; i++) {
ans += dp[i] * MM.ma[i][101];
ans %= mod;
}
printf("%I64d\n", (ans + 1) % mod);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
long long powmod(long long a, long long b, long long MOD) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ans;
}
int bj, aa, a[2323];
void dfs(int a) {
if (!a) {
bj = 1;
return;
}
if (a >= 3) dfs(a - 3);
if (a >= 7) dfs(a - 7);
}
int main() {
ios::sync_with_stdio(false);
int t;
a[0] = 1;
for (int i = 1; i <= 100; i++) {
if (i >= 3 && !a[i]) a[i] = a[i - 3];
if (i >= 7 && !a[i]) a[i] = a[i - 7];
}
for (cin >> t; t; t--) {
cin >> aa;
bj = a[aa];
if (!bj)
puts("NO");
else
puts("YES");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 1, j = n; i < j; i++, j--) {
cout << i << " " << j << " ";
}
if (n % 2 == 1) cout << (n + 1) / 2;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return b ? "true" : "false"; }
string to_string(const char* s) { return string(s); }
string to_string(string s) { return s; }
string to_string(vector<bool> v) {
string res;
for (int i = 0; i < (int)v.size(); i++) res += char('0' + v[i]);
return res;
}
template <size_t S>
string to_string(bitset<S> b) {
string res;
for (int i = 0; i < S; i++) res += char('0' + b[i]);
return res;
}
template <class T>
string to_string(T v) {
bool f = 1;
string res;
for (auto x : v) {
if (!f) res += ' ';
f = 0;
res += to_string(x);
}
return res;
}
void dbvar() { cerr << "]" << endl; }
template <class H, class... T>
void dbvar(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
dbvar(t...);
}
template <class A>
void write(A x) {
cout << to_string(x);
}
template <class H, class... T>
void write(const H& h, const T&... t) {
write(h);
write(t...);
}
void print() { write("\n"); }
template <class H, class... T>
void print(const H& h, const T&... t) {
write(h);
if (sizeof...(t)) write(' ');
print(t...);
}
const long long int INFL = (long long int)1e18;
const int INF = (int)1e9;
const long double eps = (long double)1e-9;
const long double pi = acos(-1.0);
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
long long int power(long long int n, long long int m) {
if (m == 0) return 1;
long long int val = power(n, m / 2);
if (m % 2 == 0)
return (val * val);
else
return ((val * val) * n);
}
long long int powermod(long long int n, long long int m, long long int _MOD) {
if (m == 0) return 1;
long long int val = powermod(n, m / 2, _MOD);
val %= _MOD;
if (m % 2 == 0)
return (val * val) % _MOD;
else
return (((val * val) % _MOD) * n) % _MOD;
}
void solve() {
std::cout << std::setprecision(10) << std::fixed;
long long int n, l;
cin >> n >> l;
vector<long long int> arr(n);
for (auto& x : arr) cin >> x;
;
sort(arr.begin(), arr.end());
long long int mx = 0;
for (long long int i = 1; i < n; i++) {
mx = max(mx, arr[i] - arr[i - 1]);
}
long double d = max(mx / 2.0, max(1.0 * arr[0], 1.0 * (l - arr[n - 1])));
cout << d;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
inline long long int max(long long int a, long long int b) {
return ((a > b) ? a : b);
}
inline long long int min(long long int a, long long int b) {
return ((a > b) ? b : a);
}
inline long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
long long int l1, r1, l2, r2, k, i;
vector<long long int> lucky;
void find_lucky_numbers(long long int x) {
if (x <= 1e9) lucky.push_back(x);
if (x > 1e9) return;
find_lucky_numbers(x * 10 + 4);
find_lucky_numbers(x * 10 + 7);
}
void sol() {
cin >> l1 >> r1 >> l2 >> r2 >> k;
find_lucky_numbers(0);
lucky.push_back(2e9);
sort(lucky.begin(), lucky.end());
long long int n = lucky.size();
long double num = 0;
long double den = (r2 - l2 + 1) * (r1 - l1 + 1);
for (i = 0; i + k + 1 < n; i++) {
long long int j = i + k;
long long int range1 = min(r1, lucky[i + 1]) - max(l1, lucky[i] + 1) + 1;
long long int range2 = min(r2, lucky[j + 1] - 1) - max(l2, lucky[j]) + 1;
if (range1 >= 0 && range2 >= 0) num += (range2 * range1);
range1 = min(r2, lucky[i + 1]) - max(l2, lucky[i] + 1) + 1;
range2 = min(r1, lucky[j + 1] - 1) - max(l1, lucky[j]) + 1;
if (range1 >= 0 && range2 >= 0) num += (range2 * range1);
}
if (k == 1) {
for (auto j : lucky) {
if (j >= l1 && j <= r1 && j >= l2 && j <= r2) num--;
}
}
long double ans = num / den;
cout << fixed << setprecision(12) << ans;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
sol();
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using Graph = vector<vector<int>>;
using ll = long long;
const ll INF = 1e18;
class Dinic {
private:
constexpr static ll INF = 8 * (ll)1e18;
struct Edge {
const int s, t;
const ll c;
ll f;
Edge(int src, int tar, ll cap = INF, bool dir = 1)
: s(src), t(tar), c(dir ? cap : 2 * cap), f(dir ? 0 : cap) {}
int getOth(int i) { return i == s ? t : s; }
ll getCap(int i) { return i == s ? c - f : f; }
void push(int i, ll am) { f += (i == s ? am : -am); }
};
const int source, sink, n;
vector<Edge> edges;
vector<vector<int>> conns;
vector<int> dist;
vector<bool> done;
bool calcDists() {
for (int i = 0; i < n; ++i) dist[i] = n;
dist[sink] = 0;
vector<int> que = {sink};
for (int j = 0; j < que.size(); ++j) {
int i = que[j];
for (auto ei : conns[i]) {
int t = edges[ei].getOth(i);
if (edges[ei].getCap(t) == 0) continue;
if (dist[t] == n) {
dist[t] = dist[i] + 1;
que.push_back(t);
}
}
}
return dist[source] < n;
}
ll dfsFlow(int i, ll cap = INF) {
if (i == sink) return cap;
ll res = 0;
for (auto ei : conns[i]) {
int t = edges[ei].getOth(i);
if (done[t] || dist[t] != dist[i] - 1) continue;
ll subcap = min(cap - res, edges[ei].getCap(i));
if (subcap == 0) {
if (cap == res) return res;
} else {
ll add = dfsFlow(t, subcap);
res += add;
edges[ei].push(i, add);
}
}
if (res < cap) done[i] = true;
return res;
}
public:
Dinic(int nn, int s, int t)
: n(nn), conns(nn), dist(nn), done(nn), source(s), sink(t) {}
const Edge& getEdge(int j) const { return edges[j]; }
void addEdge(int a, int b, ll c = INF, bool dir = 1) {
edges.emplace_back(a, b, c, dir);
conns[a].push_back(edges.size() - 1);
conns[b].push_back(edges.size() - 1);
}
ll pushFlow() {
ll res = 0;
while (calcDists()) {
for (int i = 0; i < n; ++i) done[i] = false;
res += dfsFlow(source);
}
return res;
}
};
ll solve(const Graph& g, const vector<ll>& vals) {
int n = g.size();
int source = n;
int sink = n + 1;
Dinic dinic(n + 2, source, sink);
ll res = 0;
for (int i = 0; i < n; ++i) {
if (vals[i] < 0) {
dinic.addEdge(i, sink, -vals[i]);
} else {
dinic.addEdge(source, i, vals[i]);
res += vals[i];
}
for (auto t : g[i]) {
dinic.addEdge(i, t);
}
}
res -= dinic.pushFlow();
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<ll>> dist(n);
for (int i = 0; i < n; ++i) {
dist[i].resize(n, INF);
dist[i][i] = 0;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
dist[a][b] = 1;
dist[b][a] = 1;
}
for (int i = 0; i < n; ++i) {
for (int a = 0; a < n; ++a) {
for (int b = 0; b < n; ++b) {
dist[a][b] = min(dist[a][b], dist[a][i] + dist[i][b]);
}
}
}
int s, b, k;
cin >> s >> b >> k;
vector<tuple<int, int, int, int>> ships(s);
for (int i = 0; i < s; ++i) {
int loc, atk, fuel, cost;
cin >> loc >> atk >> fuel >> cost;
--loc;
ships[i] = tie(loc, atk, fuel, cost);
}
vector<tuple<int, int, int>> bases(b);
for (int i = 0; i < b; ++i) {
int tar, def, gold;
cin >> tar >> def >> gold;
--tar;
bases[i] = tie(tar, def, gold);
}
sort(bases.begin(), bases.end());
vector<vector<pair<int, int>>> offs(n);
for (int i = 0; i < b; ++i) {
int tar, def, gold;
tie(tar, def, gold) = bases[i];
if (offs[tar].empty() || offs[tar].back().second < gold) {
offs[tar].push_back({def, gold});
}
}
vector<ll> vals(s, -INF);
for (int i = 0; i < s; ++i) {
int loc, atk, fuel, cost;
tie(loc, atk, fuel, cost) = ships[i];
for (int t = 0; t < n; ++t) {
if (dist[loc][t] > fuel) continue;
int low = -1;
int high = (int)offs[t].size() - 1;
while (low != high) {
int mid = (low + high + 1) >> 1;
if (atk >= offs[t][mid].first)
low = mid;
else
high = mid - 1;
}
if (low >= 0) vals[i] = max(vals[i], (ll)offs[t][low].second);
}
vals[i] -= cost;
}
Graph g(s);
for (int j = 0; j < k; ++j) {
int x, y;
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
}
ll res = solve(g, vals);
cout << res << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
int matriz[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> matriz[i][j];
}
}
long long casilleros = n * m;
long long ans = 0;
for (int i = 0; i < n; i++) {
int blanco = 0, negro = 0;
for (int j = 0; j < m; j++) {
if (matriz[i][j] == 1) {
blanco++;
} else {
negro++;
}
}
ans += (long long)(pow(2, blanco) - 1);
ans += (long long)(pow(2, negro) - 1);
}
for (int j = 0; j < m; j++) {
int blanco = 0, negro = 0;
for (int i = 0; i < n; i++) {
if (matriz[i][j] == 1) {
blanco++;
} else {
negro++;
}
}
ans += (long long)(pow(2, blanco) - 1);
ans += (long long)(pow(2, negro) - 1);
}
cout << ans - casilleros << '\n';
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int t = 1;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
void initArray(T *arr, int size, T value) {
for (int i = 0; i < size; i++) {
arr[i] = value;
}
}
template <class T>
T readValue(string s) {
T result;
istringstream sin(s);
sin >> result;
return result;
}
template <class T>
inline T gcd(T a, T b) {
return (!a) ? b : gcd(b % a, a);
}
template <class T>
inline T mod(T a, T p) {
a %= p;
return (a < 0) ? a + p : a;
}
template <class T>
inline int numbits(T n) {
return (!n) ? 0 : 1 + numbits(n & (n - 1));
}
template <class T>
inline T inverse(T a, T m) {
a = mod<T>(a, m);
return (a == 1) ? 1 : mod((1 - m * inverse(m % a, a)) / a, m);
}
template <class T>
inline bool isPrime(T a) {
T lim = (T)sqrt((double)a);
for (T i = 2; i < lim; i++)
if (a % i == 0) return false;
return true;
}
template <class T>
inline T power(T a, T p, T mod) {
if (!p) return 1;
T temp = power(a, p >> 1, mod);
temp = (temp * temp) % mod;
if (p & 1) temp = (temp * a) % mod;
return temp;
}
void get_primes(int start, int end, vector<int> &vi) {
int *p = new int[end + 1];
initArray<int>(p, end + 1, 0);
p[1] = 1;
for (int i = 2; i <= end; i++) {
if (!p[i]) {
if (i >= start) vi.push_back(i);
for (int j = 2 * i; j <= end; j += i) p[j] = 1;
}
}
}
bool dfs(int current, int final, int total, int *visited, int **edges,
bool flow) {
if (current == final) return true;
if (visited[current]) return false;
visited[current] = true;
for (int i = 0; i < total; i++)
if (edges[current][i] && dfs(i, final, total, visited, edges, flow)) {
if (flow) {
edges[current][i]--;
edges[i][current]++;
}
return true;
}
return false;
}
int flow(int in, int out, int total, int **edges) {
int result = 0;
int *visited = new int[total];
while (initArray<int>(visited, total, 0),
dfs(in, out, total, visited, edges, true))
result++;
return result;
}
void create_set(int x, int *P, int *rank) {
P[x] = x;
rank[x] = 0;
}
int find_set(int x, int *P) {
if (x != P[x]) P[x] = find_set(P[x], P);
return P[x];
}
bool merge_sets(int x, int y, int *P, int *rank) {
int Px = find_set(x, P);
int Py = find_set(y, P);
if (Px == Py) return false;
if (rank[Px] > rank[Py])
P[Py] = Px;
else
P[Px] = Py;
if (rank[Px] == rank[Py]) rank[Py]++;
return true;
}
int read_cum_freq(int index, int *tree) {
int sum = 0;
while (index) {
sum += tree[index];
index -= (index & -index);
}
return sum;
}
void upd_freq(int index, int mxIndex, int value, int *tree) {
while (index <= mxIndex) {
tree[index] += value;
index += (index & -index);
}
}
int read_freq(int index, int *tree) {
return read_cum_freq(index, tree) - read_cum_freq(index - 1, tree);
}
void build_failure_function(const string &str, int *temp_arr) {
temp_arr[0] = temp_arr[1] = 0;
for (int i = 2; i <= static_cast<int>(str.size()); i++) {
temp_arr[i] = -1;
for (int ind = temp_arr[i - 1]; temp_arr[i] == -1; ind = temp_arr[ind]) {
if (str[ind] == str[i - 1]) {
temp_arr[i] = ind + 1;
} else if (ind == 0) {
temp_arr[i] = 0;
}
}
}
}
void KMP(const string &s1, const string &s2, int *res) {
int *temp_arr = new int[s2.size() + 1];
build_failure_function(s2, temp_arr);
int i = 0;
int ind = 0;
while (i < static_cast<int>(s1.size())) {
if (s1[i] == s2[ind]) {
res[i] = ++ind;
if (res[i] == s2.size()) {
ind = temp_arr[ind - 1];
}
i++;
} else if (ind == 0) {
res[i++] = 0;
} else {
ind = temp_arr[ind];
}
}
delete[] temp_arr;
}
void setup(int value) {
freopen("input.txt", "r", stdin);
if (value) {
freopen("output.txt", "w", stdout);
}
}
int main() {
string tmp, str;
while (cin >> tmp) str += tmp;
vector<int> vi;
stack<int> st;
for (int i = 0; i < str.size(); i++) {
string tmp;
if (str[i] == '<') {
i++;
while (str[i] != '>') {
tmp += str[i];
i++;
}
if (tmp == "table") {
st.push(0);
}
if (tmp == "/table") {
vi.push_back(st.top());
st.pop();
}
if (tmp == "td") {
st.top()++;
}
}
}
sort(vi.begin(), vi.end());
for (int i = 0; i < vi.size(); i++) std::cout << vi[i] << " ";
std::cout << std::endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
const long long MOD = 1e9 + 7;
const int N = 2e5 + 7;
vector<int> g[N];
int val[N];
int n;
int cnt[N];
int dp[N][2];
int up[N][2];
long long ans = 0;
void dfs(int u, int f) {
dp[u][0] = 1;
dp[u][1] = 0;
cnt[u] = 1;
for (auto v : g[u])
if (v != f) {
dfs(v, u);
dp[u][0] += dp[v][1];
dp[u][1] += dp[v][0];
cnt[u] += cnt[v];
}
}
void dfs2(int u, int f) {
for (auto v : g[u])
if (v != f) {
up[v][0] = up[u][1] + dp[u][1] - dp[v][0];
up[v][1] = up[u][0] + dp[u][0] - dp[v][1];
dfs2(v, u);
}
}
void dfs3(int u, int f) {
ans += 1LL * val[u] * n % MOD;
ans %= MOD;
for (auto v : g[u])
if (v != f) {
ans -= 1LL * val[u] * dp[v][0] % MOD * (n - cnt[v]) % MOD;
ans += 1LL * val[u] * dp[v][1] % MOD * (n - cnt[v]) % MOD;
ans = (ans % MOD + MOD) % MOD;
dfs3(v, u);
}
ans -= 1LL * val[u] * up[u][1] % MOD * cnt[u] % MOD;
ans += 1LL * val[u] * up[u][0] % MOD * cnt[u] % MOD;
ans = (ans % MOD + MOD) % MOD;
}
int main() {
scanf("%d", &n);
for (int i = int(1); i <= int(n); ++i) scanf("%d", val + i);
int u, v;
for (int i = int(1); i <= int(n - 1); ++i) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
dfs2(1, 0);
dfs3(1, 0);
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct segtree {
vector<int> tag;
int n, h;
string name;
segtree() {}
segtree(int sz, string nn) {
name = nn;
h = 32 - __builtin_clz(sz);
n = 1 << h;
tag = vector<int>(n << 1, 0);
}
inline void apply(int x, int t) {
if (t == (1 << 5)) {
if (tag[x] == (1 << 3)) {
tag[x] = (1 << 4);
} else if (tag[x] == (1 << 4)) {
tag[x] = (1 << 3);
} else if (tag[x] == (1 << 5)) {
tag[x] = 0;
} else {
tag[x] = (1 << 5);
}
} else {
tag[x] = t;
}
}
inline void pushh(int x) {
if (tag[x]) {
apply(x << 1, tag[x]);
apply(x << 1 | 1, tag[x]);
tag[x] = 0;
}
}
inline void push(int x) {
for (int l = h; l > 0; --l) {
pushh(x >> l);
}
}
inline void assign(int l, int r, int t) {
if (l >= r) return;
l += n, r += n;
push(l);
push(r - 1);
for (; l < r; l /= 2, r /= 2) {
if (l % 2) apply(l++, t);
if (r % 2) apply(--r, t);
}
}
inline int get(int x) {
push(x + n);
return tag[x + n];
}
};
int n, q;
const int NMAX = 100100;
int pos[NMAX];
vector<int> at[NMAX];
vector<int> nat[NMAX];
int ans[NMAX];
int cc = 0;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
if (x >= 0) {
at[abs(x)].push_back(i);
} else {
nat[abs(x)].push_back(i);
}
}
pos[100001] = n;
pos[100002] = n;
segtree po(n + 1, "po"), ne(n + 1, "ne");
for (int i = 1; i <= 1e5; ++i) {
pos[i] = cc;
cc += at[i].size();
po.assign(pos[i], pos[i] + at[i].size(), (1 << 3));
ne.assign(pos[i], pos[i] + at[i].size(), (1 << 4));
cc += nat[i].size();
ne.assign(pos[i] + at[i].size(), pos[i] + at[i].size() + nat[i].size(),
(1 << 3));
po.assign(pos[i] + at[i].size(), pos[i] + at[i].size() + nat[i].size(),
(1 << 4));
}
for (int i = 0; i < q; ++i) {
string s;
int b;
cin >> s >> b;
if (s[0] == '>') {
if (b >= -1) {
ne.assign(pos[b + 1], n, (1 << 3));
po.assign(pos[b + 1], n, (1 << 4));
} else if (b < -1) {
ne.assign(0, pos[-b], (1 << 5));
po.assign(0, pos[-b], (1 << 5));
ne.assign(pos[-b], n, (1 << 3));
po.assign(pos[-b], n, (1 << 4));
}
} else {
if (b <= 1) {
po.assign(pos[-b + 1], n, (1 << 3));
ne.assign(pos[-b + 1], n, (1 << 4));
} else if (b > 1) {
ne.assign(0, pos[b], (1 << 5));
po.assign(0, pos[b], (1 << 5));
po.assign(pos[b], n, (1 << 3));
ne.assign(pos[b], n, (1 << 4));
}
}
}
int cp = 0;
for (int i = 1; i <= 1e5; ++i) {
for (auto& j : at[i]) {
ans[j] = i;
assert(ne.get(cp) != po.get(cp));
if (ne.get(cp) == (1 << 3)) ans[j] *= -1;
}
cp += at[i].size();
for (auto& j : nat[i]) {
ans[j] = i;
assert(ne.get(cp) != po.get(cp));
if (ne.get(cp) == (1 << 3)) ans[j] *= -1;
}
cp += nat[i].size();
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, m, i, j;
scanf("%d %d", &n, &m);
if (n < m) {
i = -1;
printf("%d", i);
} else {
if (n % 2 == 0) {
for (i = n / 2; i % m != 0; i++) {
}
printf("%d", i);
} else if ((n % 2) != 0) {
for (i = ((n / 2) + 1); (i % m) != 0; i++) {
}
printf("%d", i);
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, ans = 0, l, r, mid, x;
cin >> n;
l = 2, r = n;
cout << "1 " << n - 1 << " 1 ";
for (int i = l; i <= r; i++) cout << i << " ";
cin >> ans;
cout << "\n";
while (l < r) {
mid = (l + r) >> 1;
cout << "1 " << mid - l + 1 << " 1 ";
for (int i = l; i <= mid; i++) cout << i << " ";
cin >> x;
if (x == ans) {
r = mid;
} else
l = mid + 1;
cout << "\n";
}
cout << "1 " << n - 1 << " " << l << " ";
for (int i = 1; i <= n; i++)
if (i != l) cout << i << " ";
cin >> ans;
cout << "-1 " << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int i, n, u, v;
cin >> n;
vector<int> neighbours[n];
for (i = 0; i < n - 1; i++) {
cin >> u >> v;
neighbours[u - 1].push_back(v - 1);
neighbours[v - 1].push_back(u - 1);
}
int cnt = 0;
for (i = 0; i < n; i++) {
cerr << i << ' ' << neighbours[i].size() << '\n';
if (neighbours[i].size() > 1) cnt += (neighbours[i].size() <= 2);
}
cout << (cnt > 0 ? "NO\n" : "YES\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int ksz = 5e3, mod = 998244353;
bool o = 0, x = 1;
long long n, m, c, ans;
long long dp[2][2 * ksz][2];
long long inline qpow(long long a, long long p) {
long long res = 1;
for (; p > 0; p >>= 1) {
if (p & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
}
return res;
}
long long inline inv(long long a) { return qpow(a, mod - 2); }
long long& f(int k, int a, int b) {
int p = a <= b ? 0 : 1, mn = min(a, b);
return dp[k][mn + ksz][p];
}
void inline init() {
for (int a = n - c; a <= n; ++a) {
int b = n - a;
f(o, a, b) = qpow(m, a);
}
for (int k = c - 1; k >= 0; --k) {
for (int a = n - k; a <= n; ++a) {
int b = n - a;
f(x, a, b) = a * f(o, a - 1, b + 1) % mod + b * f(o, a, b) % mod;
f(x, a, b) %= mod;
}
swap(o, x);
memset(dp[x], 0, sizeof(dp[x]));
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> c;
init();
ans = inv(qpow(m, n)) * f(o, n, 0) % mod;
cout << ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
string s;
int p1[200005], p2[200005], c1, c2, u, d, l, r;
void init() {
c1 = 0, c2 = 0;
n = s.length();
s = "*" + s;
for (int i = 1; i <= n; i++) {
if (s[i] == 'W') {
p1[c1 + 1] = p1[c1] + 1;
c1++;
} else if (s[i] == 'S') {
p1[c1 + 1] = p1[c1] - 1;
c1++;
} else if (s[i] == 'A') {
p2[c2 + 1] = p2[c2] + 1;
c2++;
} else {
p2[c2 + 1] = p2[c2] - 1;
c2++;
}
}
u = *max_element(p1, p1 + c1 + 1);
d = *min_element(p1, p1 + c1 + 1);
l = *max_element(p2, p2 + c2 + 1);
r = *min_element(p2, p2 + c2 + 1);
}
long long ans;
void slove() {
ans = 1ll * (u - d + 1) * (l - r + 1);
int a, b, x, y;
for (int i = 0; i <= c1; i++) {
if (p1[i] == u) a = i;
if (p1[c1 - i] == d) b = c1 - i;
if (p1[i] == d) x = i;
if (p1[c1 - i] == u) y = c1 - i;
}
if (a + 1 < b || x + 1 < y) ans = min(ans, 1ll * (l - r + 1) * (u - d));
for (int i = 0; i <= c2; i++) {
if (p2[i] == l) a = i;
if (p2[c2 - i] == r) b = c2 - i;
if (p2[i] == r) x = i;
if (p2[c2 - i] == l) y = c2 - i;
}
if (a + 1 < b || x + 1 < y) ans = min(ans, 1ll * (l - r) * (u - d + 1));
}
int main() {
ios::sync_with_stdio(false);
cin >> t;
while (t--) {
cin >> s;
init();
slove();
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int maxm = 10000001;
int h[maxm];
int lb[maxm], rb[maxm];
long long dp[maxm];
long long cost[maxm];
int ptr = 0;
const int maxn = 250001;
vector<int> blh[maxn], blc[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(n); ++i) {
int sz;
cin >> sz;
blh[i].resize(sz);
blc[i].resize(sz);
for (int j = 0; j < (int)(sz); ++j) cin >> blh[i][j];
for (int j = 0; j < (int)(sz); ++j) cin >> blc[i][j];
}
int q;
cin >> q;
for (int i = 0; i < (int)(q); ++i) {
int blid;
long long mul;
cin >> blid >> mul;
--blid;
int sz = blh[blid].size();
for (int j = 0; j < (int)(sz); ++j) {
h[ptr] = blh[blid][j];
cost[ptr] = blc[blid][j] * mul;
++ptr;
}
}
assert(ptr == m);
{
vector<pair<int, int> > minst;
for (int i = 0; i < (int)(m); ++i) {
lb[i] = max(i - h[i] + 1, 0);
while (!minst.empty()) {
if (minst.back().first >= lb[i] || minst.back().second >= lb[i]) {
uin(lb[i], minst.back().second);
minst.pop_back();
} else
break;
}
minst.push_back({i, lb[i]});
}
}
{
vector<pair<int, int> > minst;
for (int i = (int)(m)-1; i >= 0; --i) {
rb[i] = min(i + h[i] - 1, m - 1);
while (!minst.empty()) {
if (minst.back().first <= rb[i] || minst.back().second <= rb[i]) {
uax(rb[i], minst.back().second);
minst.pop_back();
} else
break;
}
minst.push_back({i, rb[i]});
}
}
for (int i = 0; i < (int)(m + 1); ++i) dp[i] = 1e18;
dp[0] = 0;
vector<pair<long long, long long> > minst = {{0, 0}};
for (int i = 0; i < (int)(m); ++i) {
uin(dp[rb[i] + 1], dp[i] + cost[i]);
long long v = dp[i];
while (!minst.empty()) {
if (minst.back().first >= lb[i] || minst.back().second >= v) {
uin(v, minst.back().second);
minst.pop_back();
} else
break;
}
uin(dp[i + 1], v + cost[i]);
minst.push_back({i, v});
}
cout << dp[m] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
namespace MyMinMax {
template <typename T>
inline T mn(T x, T y) {
return x < y ? x : y;
}
template <typename T>
inline T mx(T x, T y) {
return x > y ? x : y;
}
template <typename T>
inline void chmin(T &x, T y) {
(x > y) && (x = y);
}
template <typename T>
inline void chmax(T &x, T y) {
(x < y) && (x = y);
}
} // namespace MyMinMax
using namespace MyMinMax;
namespace IO {
char BB[1 << 18], *SS = BB, *TT = BB;
template <typename T = int>
inline T read() {
T x = 0;
int fu = 1;
char c =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
}
x *= fu;
return x;
}
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
}
x *= fu;
}
template <typename T>
inline void read(T *bg, T *ed) {
while (bg != ed) read(*bg++);
}
inline void read(char &ch) {
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (ch <= 32)
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
}
inline void read(char *s) {
char ch =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (ch <= 32)
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (ch > 32)
*s++ = ch,
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
*s = '\0';
}
inline void sread(char *s) {
char ch =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (ch < 32)
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (ch >= 32)
*s++ = ch,
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
*s = '\0';
}
inline void pread(char *&s) {
char ch =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (ch <= 32)
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (ch > 32)
*s++ = ch,
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
*s = '\0';
}
inline void spread(char *&s) {
char ch =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (ch < 32)
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
while (ch >= 32)
*s++ = ch,
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 18, stdin), SS == TT)
? EOF
: *SS++);
*s = '\0';
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
char out[1 << 18], *Out = out;
inline void putcha(char x) {
*Out++ = x;
if (Out - out >= (1 << 18)) fwrite(out, 1, Out - out, stdout), Out = out;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putcha(45), x = -x;
if (x > 9) fprint(x / 10);
putcha(x % 10 + 48);
}
template <typename T>
inline void print(T x) {
fprint(x);
putcha(10);
}
inline void print(char *ch) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
}
inline void put(char *ch) {
while (*ch != '\0') putcha(*(ch++));
}
inline void print(const char *ch) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
}
inline void put(const char *ch) {
while (*ch != '\0') putcha(*(ch++));
}
template <typename T, typename... Args>
inline void print(T x, Args... args) {
fprint(x);
putcha(32);
print(args...);
}
template <typename... Args>
inline void print(const char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(32);
print(args...);
}
template <typename... Args>
inline void print(char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(32);
print(args...);
}
template <typename T, typename... Args>
inline void printl(T x, Args... args) {
fprint(x);
putcha(10);
print(args...);
}
template <typename... Args>
inline void printl(const char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
print(args...);
}
template <typename... Args>
inline void printl(char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
print(args...);
}
template <typename T>
inline void sprint(T x) {
fprint(x);
putcha(32);
}
template <typename T, typename... Args>
inline void sprint(T x, Args... args) {
fprint(x);
putcha(32);
sprint(args...);
}
template <typename T>
inline void sprint(T *bg, T *ed) {
while (bg != ed) sprint(*bg++);
}
template <typename T>
inline void print(T *bg, T *ed) {
while (bg != ed) sprint(*bg++);
putcha(10);
}
template <typename T>
inline void printl(T *bg, T *ed) {
while (bg != ed) print(*bg++);
}
class AutoFlush {
public:
~AutoFlush() { fwrite(out, 1, Out - out, stdout); }
} __AutoFlush;
} // namespace IO
using namespace IO;
int n, k, N;
char BUF[100005 << 1], *p[100005];
int t[100005][26], tot;
inline void ins(char *p) {
int rt = 0;
for (char *it = p; *it != '\0'; ++it) {
if (!t[rt][*it - 97]) t[rt][*it - 97] = ++tot;
rt = t[rt][*it - 97];
}
}
int len[100005 << 1], link[100005 << 1];
int nxt[100005 << 1][26];
int sz, lst[100005 << 1];
inline int extend(int c, int pre) {
int x = sz++;
len[x] = len[pre] + 1;
int it = pre;
while (~it && !nxt[it][c]) {
nxt[it][c] = x;
it = link[it];
}
if (!~it)
link[x] = 0;
else {
int t = nxt[it][c];
if (len[it] + 1 == len[t])
link[x] = t;
else {
int y = sz++;
len[y] = len[it] + 1;
memcpy(nxt[y], nxt[t], sizeof(nxt[y]));
link[y] = link[t];
while (~it && nxt[it][c] == t) {
nxt[it][c] = y;
it = link[it];
}
link[t] = link[x] = y;
}
}
return x;
}
int buf[100005];
inline void layer() {
link[0] = -1;
++sz;
int *hd = buf, *ed = buf + 1;
while (hd != ed) {
int x = *hd++;
for (int i = (0); i <= (25); ++i)
if (t[x][i]) {
*ed++ = t[x][i];
lst[t[x][i]] = extend(i, lst[x]);
}
}
}
int head[100005 << 1], e[100005 << 1], nt[100005 << 1], cnt;
inline void add(int u, int v) {
nt[++cnt] = head[u];
head[u] = cnt;
e[cnt] = v;
}
int s[100005 << 1], tp[100005 << 1], siz[100005 << 1], son[100005 << 1],
dep[100005 << 1], dfn[100005 << 1], _tot;
void dfs1(int x) {
siz[x] = 1;
for (int i = head[x]; i; i = nt[i]) {
dep[e[i]] = dep[x] + 1;
dfs1(e[i]);
siz[x] += siz[e[i]];
if (siz[son[x]] < siz[e[i]]) son[x] = e[i];
}
}
void dfs2(int x, int tt) {
tp[x] = tt;
dfn[x] = ++_tot;
if (son[x]) dfs2(son[x], tt);
for (int i = head[x]; i; i = nt[i]) {
if (e[i] == son[x]) continue;
dfs2(e[i], e[i]);
}
}
inline int LCA(int x, int y) {
while (tp[x] ^ tp[y]) {
if (dep[tp[x]] < dep[tp[y]]) std ::swap(x, y);
x = link[tp[x]];
}
if (dep[x] > dep[y])
return y;
else
return x;
}
void dfs(int x) {
for (int i = head[x]; i; i = nt[i]) dfs(e[i]), s[x] += s[e[i]];
}
inline void build() {
for (int i = (1); i <= (sz - 1); ++i) add(link[i], i);
dep[0] = 1;
dfs1(0);
dfs2(0, 0);
}
int tmp[100005], ttp;
int fa[100005 << 1][21], c[100005], a[100005 << 1];
inline void prework() {
for (int i = (0); i <= (sz - 1); ++i) ++c[len[i]];
for (int i = (1); i <= (N); ++i) c[i] += c[i - 1];
for (int i = (0); i <= (sz - 1); ++i) a[--c[len[i]]] = i;
for (int i = (1); i <= (sz - 1); ++i) {
int x = a[i];
fa[x][0] = link[x];
for (int j = (1); j <= (20); ++j) fa[x][j] = fa[fa[x][j - 1]][j - 1];
}
}
inline bool cmp(int x, int y) { return dfn[x] < dfn[y]; }
inline void init() {
layer();
build();
for (int i = (1); i <= (n); ++i) {
int rt = 0;
ttp = 0;
for (char *it = p[i]; *it != '\0'; ++it) {
rt = nxt[rt][*it - 97];
tmp[++ttp] = rt;
++s[rt];
}
std ::sort(tmp + 1, tmp + ttp + 1, cmp);
for (int j = (1); j < (ttp); ++j) --s[LCA(tmp[j], tmp[j + 1])];
}
dfs(0);
prework();
}
inline int work(int x) {
for (int i = (20); i >= (0); --i)
if (s[fa[x][i]] < k) x = fa[x][i];
if (s[x] < k) x = link[x];
return len[x];
}
inline void solve() {
init();
for (int i = (1); i <= (n); ++i) {
int rt = 0;
long long ans = 0;
for (char *it = p[i]; *it != '\0'; ++it) {
rt = nxt[rt][*it - 97];
ans += work(rt);
}
sprint(ans);
}
putcha(10);
}
int main() {
read(n, k);
char *it = BUF;
for (int i = (1); i <= (n); ++i) {
p[i] = ++it;
pread(it);
ins(p[i]);
chmax(N, (int)strlen(p[i]));
}
solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n, r;
cin >> n >> r;
if (r >= n) {
long long ans = (1 + n - 1) * (n - 1) / 2 + 1;
cout << ans << "\n";
} else {
long long ans = (1 + r) * (r) / 2;
cout << ans << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(const int &a, const int &b) { return (a % 10) > (b % 10); }
int main(int argc, char **argv) {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n);
int score = 0;
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
sort(v.begin(), v.end(), cmp);
for (int i = 0; i < n; ++i) {
int temp = 10 - (v[i] % 10);
if (k >= temp && v[i] + temp <= 100) {
k -= temp;
v[i] += temp;
}
}
for (int i = 0; i < n; ++i) {
if (v[i] % 10 != 0) continue;
while (k >= 10 && v[i] + 10 <= 100) {
k -= 10;
v[i] += 10;
}
}
for (int i = 0; i < n; ++i) score += v[i] / 10;
cout << score << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char mt[20][20];
int dx, dy;
void _pt() {
int i, j, k;
for (i = 0; i < 9; ++i) {
for (j = 0; j < 3; putchar(mt[i][j++]))
;
putchar(' ');
for (; j < 6; putchar(mt[i][j++]))
;
putchar(' ');
for (; j < 9; putchar(mt[i][j++]))
;
putchar('\n');
if (!((i + 1) % 3)) putchar('\n');
}
};
void cl() {
int i, j, k, d, t, a, b;
for (i = 0; i < 9; ++i) {
scanf("%s", mt[i]);
scanf("%s", mt[i] + 3);
scanf("%s", mt[i] + 6);
}
scanf("%d %d", &dx, &dy);
--dx, --dy;
dx %= 3, dy %= 3;
dx *= 3, dy *= 3;
for (d = 0, j = dy; j < dy + 3; ++j)
if (mt[dx][j] == '.') mt[dx][j] = '!', d = 1;
for (j = dy; j < dy + 3; ++j)
if (mt[dx + 1][j] == '.') mt[dx + 1][j] = '!', d = 1;
for (j = dy; j < dy + 3; ++j)
if (mt[dx + 2][j] == '.') mt[dx + 2][j] = '!', d = 1;
if (d) {
_pt();
} else {
for (i = 0; i < 9; ++i)
for (j = 0; j < 9; ++j)
if (mt[i][j] == '.') mt[i][j] = '!';
_pt();
}
};
int main() {
cl();
return 0;
};
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[10][10];
int j(int b) { return b == 0 ? 0 : j(b / n) * 10 + b % n; }
int main() {
cin >> n;
int t = n - 1;
for (int i = 0; i < t; i++)
for (int x = 0; x < t; x++) {
a[i][x] = j((i + 1) * (x + 1));
cout << a[i][x];
if (x == t - 1)
cout << endl;
else
cout << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s[8][8];
bool mark[8][8][8];
bool f(int t, int i, int j) {
if (i < 0 || j < 0 || i == 8 || j == 8) return false;
return mark[t - 1][i][j];
}
bool ch(int t, int i, int j) {
bool k = false;
if (s[t][i][j] != 'S' && s[t - 1][i][j] != 'S')
for (int x = -1; x < 2; x++)
for (int y = -1; y < 2; y++) k = (k || f(t, i + x, j + y));
return k;
}
int main() {
for (int i = 0; i < 8; i++) cin >> s[0][i];
mark[0][7][0] = true;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) s[i][j] += "........";
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
if (s[0][i][j] == 'S')
for (int t = 1; t < 8; t++) {
if (i + t == 8) break;
s[t][i + t][j] = 'S';
}
for (int t = 1; t < 8; t++)
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) mark[t][i][j] = ch(t, i, j);
bool k = false;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
if (mark[7][i][j]) k = true;
cout << ((k) ? "WIN" : "LOSE") << endl;
return 0;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const int IT_MAX = 1 << 18;
const int MAXN = 2e5 + 5;
const int mod = 1e9 + 7;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
long long powmod(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) { return b ? gcd(b, a % b) : a; }
int s[MAXN], e[MAXN];
vector<pair<int, int> > gph[MAXN];
int dist[MAXN];
vector<int> pre[MAXN];
vector<string> res;
int n, m, k;
char now[MAXN];
void bfs(int v) {
memset(dist, 0x3f, sizeof(dist));
queue<int> q;
q.push(v);
dist[v] = 0;
while (!q.empty()) {
auto x = q.front();
q.pop();
for (auto &i : gph[x]) {
if (dist[i.first] > dist[x] + 1) {
dist[i.first] = dist[x] + 1;
q.push(i.first);
}
}
}
}
void dfs(int x, int k) {
if (res.size() >= k) return;
if (x > n) {
res.push_back(now + 1);
return;
}
for (auto &i : pre[x]) {
now[i] = '1';
dfs(x + 1, k);
now[i] = '0';
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i < m + 1; i++) {
scanf("%d %d", s + i, e + i);
gph[s[i]].push_back({e[i], i});
gph[e[i]].push_back({s[i], i});
}
bfs(1);
for (int i = 2; i < n + 1; i++) {
for (auto &j : gph[i]) {
if (dist[j.first] + 1 == dist[i]) {
pre[i].push_back(j.second);
}
}
}
for (int i = 1; i < m + 1; i++) now[i] = '0';
dfs(2, k);
printf("%d\n", res.size());
for (auto &i : res) cout << i << "\n";
}
| 6 |
//git pull --rebase origin master
#include<bits/stdc++.h>
using namespace std;
#define gc getchar_unlocked
#define fo(i,n) for(int i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define ll long long
#define si(x) scanf("%d",&x)
#define sl(x) scanf("%lld",&x)
#define ss(s) scanf("%s",s)
#define pi(x) printf("%d\n",x)
#define pl(x) printf("%lld\n",x)
#define ps(s) printf("%s\n",s)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define wi(t) int t;cin>>t;while(t--)
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim) {
uniform_int_distribution<int> uid(0,lim-1);
return uid(rang);
}
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
const int mod = 1000000007;
const int N = 3e5, M = N;
//=======================
vi adj[N];
vi vis(N);
ll int gcd(ll int a, ll int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
int tc=1;
void solve()
{
int n,m;
cin>>n>>m;
int ar[n][m];
fo(i,n)
{
fo(j,m)
{
char ch;
cin>>ch;
if(ch=='*') ar[i][j]=1;
else ar[i][j]=0;
}
}
ll int sum=0;
for(int i=n-2;i>=0;i--)
{
for(int j=m-2;j>=1;j--)
{
if(ar[i][j]==1)
{
ar[i][j]=ar[i][j]+min({ar[i+1][j],ar[i+1][j+1],ar[i+1][j-1]});
}
}
}
fo(i,n)
{
fo(j,m)
{
sum+=ar[i][j];
}
}
cout<<sum<<'\n';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
wi(t)
{
solve();
}
return 0;
}
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((ll)result * base) % mod;
base = ((ll)base * base) % mod;
exp >>= 1;
}
return result;
}
void ipgraph(int n, int m){
int i, u, v;
while(m--){
cin>>u>>v;
u--, v--;
adj[u].pb(v);
adj[v].pb(u);
}
}
void dfs(int u, int par){
for(int v:adj[u]){
if (v == par) continue;
dfs(v, u);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e6 + 6, md = 1e9 + 7;
int n, k;
long long l, ans, a[mxn], dp[mxn], s[mxn];
pair<int, int> p[mxn];
inline void add(long long& x, long long y) {
x += y;
if (x >= md) x -= md;
}
int main() {
scanf("%d%lld%d", &n, &l, &k);
for (int i = 0; i < n; ++i) scanf("%lld", a + i);
for (int i = 0; i < n * k; ++i) p[i] = {a[i % n], i};
sort(p, p + n * k);
for (int i = 0; i < n * k; ++i) {
dp[p[i].second] = (p[i].second < n) ? 1 : s[p[i].second / n - 1];
add(s[p[i].second / n], dp[p[i].second]);
if (p[i].second < l)
add(ans, ((l - p[i].second - 1) / n + 1) % md * dp[p[i].second] % md);
}
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a2[4][4] = {1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1}, a3[8][8],
a4[16][16], a5[32][32], a6[64][64], a7[128][128], a8[256][256],
a9[512][512];
int main() {
int n;
cin >> n;
if (n == 0) {
cout << "+" << endl;
return 0;
} else if (n == 1) {
cout << "+*" << endl << "++" << endl;
return 0;
}
for (int x = 0; x < 4; x++) {
for (int y = 0; y < 4; y++) {
if (a2[x][y] == 1) {
a3[x][2 * y] = 1;
a3[x][2 * y + 1] = 1;
a3[x + 4][2 * y] = 1;
a3[x + 4][2 * y + 1] = 0;
} else {
a3[x][2 * y] = 0;
a3[x][2 * y + 1] = 0;
a3[x + 4][2 * y] = 0;
a3[x + 4][2 * y + 1] = 1;
}
}
}
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
if (a3[x][y] == 1) {
a4[x][2 * y] = 1;
a4[x][2 * y + 1] = 1;
a4[x + 8][2 * y] = 1;
a4[x + 8][2 * y + 1] = 0;
} else {
a4[x][2 * y] = 0;
a4[x][2 * y + 1] = 0;
a4[x + 8][2 * y] = 0;
a4[x + 8][2 * y + 1] = 1;
}
}
}
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
if (a4[x][y] == 1) {
a5[x][2 * y] = 1;
a5[x][2 * y + 1] = 1;
a5[x + 16][2 * y] = 1;
a5[x + 16][2 * y + 1] = 0;
} else {
a5[x][2 * y] = 0;
a5[x][2 * y + 1] = 0;
a5[x + 16][2 * y] = 0;
a5[x + 16][2 * y + 1] = 1;
}
}
}
for (int x = 0; x < 32; x++) {
for (int y = 0; y < 32; y++) {
if (a5[x][y] == 1) {
a6[x][2 * y] = 1;
a6[x][2 * y + 1] = 1;
a6[x + 32][2 * y] = 1;
a6[x + 32][2 * y + 1] = 0;
} else {
a6[x][2 * y] = 0;
a6[x][2 * y + 1] = 0;
a6[x + 32][2 * y] = 0;
a6[x + 32][2 * y + 1] = 1;
}
}
}
for (int x = 0; x < 64; x++) {
for (int y = 0; y < 64; y++) {
if (a6[x][y] == 1) {
a7[x][2 * y] = 1;
a7[x][2 * y + 1] = 1;
a7[x + 64][2 * y] = 1;
a7[x + 64][2 * y + 1] = 0;
} else {
a7[x][2 * y] = 0;
a7[x][2 * y + 1] = 0;
a7[x + 64][2 * y] = 0;
a7[x + 64][2 * y + 1] = 1;
}
}
}
for (int x = 0; x < 128; x++) {
for (int y = 0; y < 128; y++) {
if (a7[x][y] == 1) {
a8[x][2 * y] = 1;
a8[x][2 * y + 1] = 1;
a8[x + 128][2 * y] = 1;
a8[x + 128][2 * y + 1] = 0;
} else {
a8[x][2 * y] = 0;
a8[x][2 * y + 1] = 0;
a8[x + 128][2 * y] = 0;
a8[x + 128][2 * y + 1] = 1;
}
}
}
for (int x = 0; x < 256; x++) {
for (int y = 0; y < 256; y++) {
if (a8[x][y] == 1) {
a9[x][2 * y] = 1;
a9[x][2 * y + 1] = 1;
a9[x + 256][2 * y] = 1;
a9[x + 256][2 * y + 1] = 0;
} else {
a9[x][2 * y] = 0;
a9[x][2 * y + 1] = 0;
a9[x + 256][2 * y] = 0;
a9[x + 256][2 * y + 1] = 1;
}
}
}
if (n == 2) {
for (int x = 0; x < 4; x++) {
for (int y = 0; y < 4; y++) {
if (a2[x][y] == 1)
cout << '+';
else
cout << '*';
}
cout << endl;
}
} else if (n == 3) {
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
if (a3[x][y] == 1)
cout << '+';
else
cout << '*';
}
cout << endl;
}
} else if (n == 4) {
for (int x = 0; x < 16; x++) {
for (int y = 0; y < 16; y++) {
if (a4[x][y] == 1)
cout << '+';
else
cout << '*';
}
cout << endl;
}
} else if (n == 5) {
for (int x = 0; x < 32; x++) {
for (int y = 0; y < 32; y++) {
if (a5[x][y] == 1)
cout << '+';
else
cout << '*';
}
cout << endl;
}
} else if (n == 6) {
for (int x = 0; x < 64; x++) {
for (int y = 0; y < 64; y++) {
if (a6[x][y] == 1)
cout << '+';
else
cout << '*';
}
cout << endl;
}
} else if (n == 7) {
for (int x = 0; x < 128; x++) {
for (int y = 0; y < 128; y++) {
if (a7[x][y] == 1)
cout << '+';
else
cout << '*';
}
cout << endl;
}
} else if (n == 8) {
for (int x = 0; x < 256; x++) {
for (int y = 0; y < 256; y++) {
if (a8[x][y] == 1)
cout << '+';
else
cout << '*';
}
cout << endl;
}
} else {
for (int x = 0; x < 512; x++) {
for (int y = 0; y < 512; y++) {
if (a9[x][y] == 1)
cout << '+';
else
cout << '*';
}
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
long long mod = 1000000007;
vector<long long> grev[200001];
long long a[200005];
long long b[200005];
void solve() {
string s;
cin >> s;
long long n = ((int)s.length());
long long sum = 0, even = 0, zeroes = 0;
for (long long i = int(0); i < int(n); i++) {
if (s[i] == '0')
zeroes++;
else if ((s[i] - '0') % 2 == 0)
even++;
sum += s[i] - '0';
}
if (sum % 3 == 0) {
if (even) {
if (zeroes > 0) {
cout << "red"
<< "\n";
} else
cout << "cyan"
<< "\n";
} else if (zeroes > 1) {
cout << "red"
<< "\n";
} else
cout << "cyan"
<< "\n";
} else
cout << "cyan"
<< "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, B = 10;
int n, a[N] = {}, l[B] = {}, r[B] = {};
bool check() {
for (int i = 1; i <= n; ++i)
if (a[i] != i) return false;
return true;
}
void dfs(int t) {
if (check()) {
cout << t - 1 << endl;
for (int i = t - 1; i >= 1; --i) cout << l[i] << ' ' << r[i] << endl;
exit(0);
}
if (t == 4) return;
for (int i = 1; i <= n; ++i)
if (a[i] != i && (abs(a[i] - a[i - 1]) != 1 || abs(a[i] - a[i + 1]) != 1))
for (int j = i + 1; j <= n; ++j)
if (a[j] != j &&
(abs(a[j] - a[j + 1]) != 1 || abs(a[j] - a[j - 1]) != 1)) {
reverse(a + i, a + j + 1);
l[t] = i, r[t] = j;
dfs(t + 1);
reverse(a + i, a + j + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
a[0] = a[n + 1] = -1;
dfs(1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long min(long long a, long long b) {
if (a > b) return b;
return a;
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
int main() {
long long n, m, a, b, c;
cin >> n >> m;
cin >> a >> b >> c;
n = n - a * 2 - b;
m = m - b - c * 3;
n = min(0, n);
m = min(0, m);
cout << -1 * (m + n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int res;
int A, B, C, D;
void divide(int a, int b, int c, int d, int mitad) {
int izq, der, act;
if (a > b || c > d) return;
izq = a > c ? a : c;
der = b < d ? b : d;
if (izq <= der) {
act = der - izq + 1;
} else {
act = 0;
}
if (act > res) res = act;
if ((a <= c && d <= b) || (c <= a && b <= d)) return;
divide(a < mitad ? a : mitad, b < mitad - 1 ? b : mitad - 1,
c < mitad ? c : mitad, d < mitad - 1 ? d : mitad - 1, mitad / 2);
divide(a < mitad ? a : mitad, b < mitad - 1 ? b : mitad - 1,
(c > mitad + 1 ? c : mitad + 1) - mitad,
(d > mitad ? d : mitad) - mitad, mitad / 2);
divide((a > mitad + 1 ? a : mitad + 1) - mitad,
(b > mitad ? b : mitad) - mitad, c < mitad ? c : mitad,
d < mitad - 1 ? d : mitad - 1, mitad / 2);
divide((a > mitad + 1 ? a : mitad + 1) - mitad,
(b > mitad ? b : mitad) - mitad,
(c > mitad + 1 ? c : mitad + 1) - mitad,
(d > mitad ? d : mitad) - mitad, mitad / 2);
}
int main() {
cin >> A >> B >> C >> D;
divide(A, B, C, D, (1 << 30));
cout << res << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10;
int a[N][N], dp1[N][N], dp2[N][N], dp3[N][N], dp4[N][N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
dp1[i][j] = a[i][j] + max(dp1[i - 1][j], dp1[i][j - 1]);
for (int i = 1; i <= n; ++i)
for (int j = m; j >= 1; --j)
dp2[i][j] = a[i][j] + max(dp2[i - 1][j], dp2[i][j + 1]);
for (int i = n; i >= 1; --i)
for (int j = 1; j <= m; ++j)
dp3[i][j] = a[i][j] + max(dp3[i + 1][j], dp3[i][j - 1]);
for (int i = n; i >= 1; --i)
for (int j = m; j >= 1; --j)
dp4[i][j] = a[i][j] + max(dp4[i][j + 1], dp4[i + 1][j]);
long long ans = 0;
for (int i = 2; i < n; i++)
for (int j = 2; j < m; j++) {
long long x =
dp1[i - 1][j] + dp2[i][j + 1] + dp3[i][j - 1] + dp4[i + 1][j];
long long y =
dp1[i][j - 1] + dp2[i - 1][j] + dp3[i + 1][j] + dp4[i][j + 1];
ans = max(ans, max(x, y));
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int GC(long long int a, long long int b) {
if (b == 0)
return a;
else
return GC(b, a % b);
}
long long int inv_gc(long long int a, long long int b) {
return a / GC(a, b) * b;
}
long long int Ceil(long long int a, long long int b) {
return a / b + (a % b != 0);
}
map<char, char> par;
map<char, int> rk;
void make_set(set<char> s) {
for (auto it = s.begin(); it != s.end(); it++) {
par[*it] = *it;
rk[*it] = 1;
}
}
char find(char x) {
if (x == par[x]) return x;
char p = find(par[x]);
par[x] = p;
return p;
}
int uni(char x, char y) {
char p1 = find(x);
char p2 = find(y);
if (p1 == p2) return 0;
if (rk[p1] > rk[p2]) {
par[p2] = p1;
rk[p1] += rk[p2];
} else {
par[p1] = p2;
rk[p2] += rk[p1];
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
long long int count = 0;
cin >> n;
string a, b;
cin >> a >> b;
set<char> s;
vector<pair<char, char> > v;
for (int i = 0; i < a.length(); i++) {
s.insert(a[i]);
s.insert(b[i]);
}
make_set(s);
for (int i = 0; i < n; i++) {
int r = uni(a[i], b[i]);
if (r == 1) {
count++;
v.push_back(make_pair(a[i], b[i]));
}
}
cout << count << endl;
for (int i = 0; i < v.size(); i++)
cout << v[i].first << " " << v[i].second << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct node {
int a, b;
} p[1111];
int main() {
int n;
while (~scanf("%d", &n)) {
bool rate = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &p[i].a, &p[i].b);
if (p[i].a != p[i].b) rate = 1;
}
if (rate) {
puts("rated");
continue;
}
for (int i = 1; i < n; i++)
if (p[i].b > p[i - 1].b) {
rate = 1;
break;
}
puts(rate ? "unrated" : "maybe");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2510;
bool flag[N][N];
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a > b ? b : a; }
inline void read(int& first) {
first = 0;
char c;
for (c = getchar(); c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar())
first = (first << 3) + (first << 1) + c - '0';
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL);
int first, second, xx, yy;
cin >> first >> second >> xx >> yy;
first += 1000;
xx += 1000;
yy += 1000;
second += 1000;
memset(flag, false, sizeof(flag));
if (first < xx) swap(first, xx), swap(second, yy);
if (second > yy) {
for (int i = xx + 1; i < first; i++)
flag[i][second] = true, flag[i][yy] = true;
for (int i = yy + 1; i < second; i++)
flag[first][i] = true, flag[xx][i] = true;
flag[first][second] = flag[first][yy] = flag[xx][second] = flag[xx][yy] =
true;
int q;
cin >> q;
int a, b, r;
while (q--) {
cin >> a >> b >> r;
a += 1000;
b += 1000;
for (int i = xx; i <= first; i++) {
if ((i - a) * (i - a) + (yy - b) * (yy - b) <= r * r)
flag[i][yy] = false;
if ((i - a) * (i - a) + (second - b) * (second - b) <= r * r)
flag[i][second] = false;
}
for (int i = yy; i <= second; i++) {
if ((i - b) * (i - b) + (a - xx) * (a - xx) <= r * r)
flag[xx][i] = false;
if ((i - b) * (i - b) + (a - first) * (a - first) <= r * r)
flag[first][i] = false;
}
}
int ans = 0;
for (int i = xx + 1; i < first; i++) {
if (flag[i][second]) {
ans++;
}
if (flag[i][yy]) {
ans++;
}
}
for (int i = yy + 1; i < second; i++) {
if (flag[first][i]) {
ans++;
}
if (flag[xx][i]) {
ans++;
}
}
if (flag[first][second]) ans++;
if (flag[first][yy]) ans++;
if (flag[xx][second]) ans++;
if (flag[xx][yy]) ans++;
cout << ans << endl;
} else {
for (int i = xx + 1; i < first; i++)
flag[i][second] = true, flag[i][yy] = true;
for (int i = second + 1; i < yy; i++)
flag[first][i] = true, flag[xx][i] = true;
flag[first][second] = flag[first][yy] = flag[xx][second] = flag[xx][yy] =
true;
int q;
int a, b, r;
cin >> q;
while (q--) {
cin >> a >> b >> r;
a += 1000;
b += 1000;
for (int i = xx; i <= first; i++) {
if ((i - a) * (i - a) + (yy - b) * (yy - b) <= r * r)
flag[i][yy] = false;
if ((i - a) * (i - a) + (second - b) * (second - b) <= r * r)
flag[i][second] = false;
}
for (int i = second; i <= yy; i++) {
if ((i - b) * (i - b) + (a - xx) * (a - xx) <= r * r)
flag[xx][i] = false;
if ((i - b) * (i - b) + (a - first) * (a - first) <= r * r)
flag[first][i] = false;
}
}
int ans = 0;
for (int i = xx + 1; i < first; i++) {
if (flag[i][second]) {
ans++;
}
if (flag[i][yy]) {
ans++;
}
}
for (int i = second + 1; i < yy; i++) {
if (flag[first][i]) {
ans++;
}
if (flag[xx][i]) {
ans++;
}
}
if (flag[first][second]) ans++;
if (flag[first][yy]) ans++;
if (flag[xx][second]) ans++;
if (flag[xx][yy]) ans++;
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void back_rotation(int cube[]);
void left_rotation(int cube[]);
void down_rotation(int cube[]);
int verify(int cube[]);
int check(int cube[]);
int main() {
int i;
int cube[30];
for (i = 1; i <= 24; i++) cin >> cube[i];
if (check(cube))
cout << "YES";
else
cout << "NO";
}
int check(int cube[]) {
back_rotation(cube);
if (verify(cube)) return 1;
back_rotation(cube);
back_rotation(cube);
if (verify(cube)) return 1;
back_rotation(cube);
left_rotation(cube);
if (verify(cube)) return 1;
left_rotation(cube);
left_rotation(cube);
if (verify(cube)) return 1;
left_rotation(cube);
down_rotation(cube);
if (verify(cube)) return 1;
down_rotation(cube);
down_rotation(cube);
if (verify(cube)) return 1;
down_rotation(cube);
return 0;
}
int verify(int cube[]) {
if (((cube[1] == cube[2]) && (cube[2] == cube[3]) && (cube[3] == cube[4])) &&
((cube[5] == cube[6]) && (cube[6] == cube[7]) && (cube[7] == cube[8])) &&
((cube[9] == cube[10]) && (cube[10] == cube[11]) &&
(cube[11] == cube[12])) &&
((cube[17] == cube[18]) && (cube[18] == cube[19]) &&
(cube[19] == cube[20])))
return 1;
return 0;
}
void back_rotation(int cube[]) {
int x;
x = cube[9];
cube[9] = cube[11];
cube[11] = cube[12];
cube[12] = cube[10];
cube[10] = x;
x = cube[7];
cube[7] = cube[15];
cube[15] = cube[23];
cube[23] = cube[19];
cube[19] = x;
x = cube[8];
cube[8] = cube[16];
cube[16] = cube[24];
cube[24] = cube[20];
cube[20] = x;
}
void left_rotation(int cube[]) {
int x;
x = cube[13];
cube[13] = cube[15];
cube[15] = cube[16];
cube[16] = cube[14];
cube[14] = x;
x = cube[1];
cube[1] = cube[24];
cube[24] = cube[9];
cube[9] = cube[5];
cube[5] = x;
x = cube[3];
cube[3] = cube[22];
cube[22] = cube[11];
cube[11] = cube[7];
cube[7] = x;
}
void down_rotation(int cube[]) {
int x;
x = cube[7];
cube[7] = cube[8];
cube[8] = cube[6];
cube[6] = cube[5];
cube[5] = x;
x = cube[4];
cube[4] = cube[14];
cube[14] = cube[9];
cube[9] = cube[19];
cube[19] = x;
x = cube[3];
cube[3] = cube[16];
cube[16] = cube[10];
cube[10] = cube[17];
cube[17] = x;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, s;
cin >> n >> s;
long long a[n];
long long sumofa = 0;
long long minofa = INT_MAX;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sumofa += a[i];
if (minofa > a[i]) {
minofa = a[i];
}
}
if (sumofa < s) {
cout << -1 << endl;
} else if (sumofa == s) {
cout << 0 << endl;
} else {
long long temp = sumofa - (n * minofa);
if (temp >= s) {
cout << minofa << endl;
} else {
long long cnt = s - temp;
long long res = ((n * minofa) - cnt) / n;
cout << res << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int p, v[50];
string s;
} ST;
const int top[10] = {25, 18, 15, 12, 10, 8, 6, 4, 2, 1};
ST vect[1100];
map<string, int> mp;
int node(string s) {
if (mp.find(s) != mp.end()) return mp[s];
int t = mp.size();
vect[t].s = s;
return mp[s] = t;
}
bool sortf1(const ST& a, const ST& b) {
if (a.p != b.p) return a.p > b.p;
for (int i = 0; i < 50; ++i)
if (a.v[i] != b.v[i]) return a.v[i] > b.v[i];
return false;
}
bool sortf2(const ST& a, const ST& b) {
if (a.v[0] != b.v[0]) return a.v[0] > b.v[0];
if (a.p != b.p) return a.p > b.p;
for (int i = 1; i < 50; ++i)
if (a.v[i] != b.v[i]) return a.v[i] > b.v[i];
return false;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int m;
cin >> m;
for (int j = 0; j < m; ++j) {
string s;
cin >> s;
int t = node(s);
++vect[t].v[j];
if (j < 10) vect[t].p += top[j];
}
}
sort(vect, vect + mp.size(), sortf1);
cout << vect[0].s << endl;
sort(vect, vect + mp.size(), sortf2);
cout << vect[0].s << endl;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 5000;
const long long inf = 1e15;
using namespace std;
int n;
int a[maxn + 5];
long long sum[maxn + 5];
long long S(int l, int r) {
if (l == r) return 0;
if (l == 0) return sum[r - 1];
return sum[r - 1] - sum[l - 1];
}
void ok() {
int r0, r1, r2, k0, k1, k2;
long long cot = -inf;
sum[0] = a[0];
for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + a[i];
for (int i = 0; i <= n; i++) {
long long cot1 = -inf, cot2 = -inf;
for (int j = 0; j <= i; j++) {
if (cot1 < S(0, j) - S(j, i)) cot1 = S(0, j) - S(j, i), k0 = j;
}
for (int j = i; j <= n; j++) {
if (cot2 < S(i, j) - S(j, n)) cot2 = S(i, j) - S(j, n), k2 = j;
}
k1 = i;
if (cot1 + cot2 > cot) r0 = k0, r1 = k1, r2 = k2, cot = cot1 + cot2;
}
printf("%d %d %d\n", r0, r1, r2);
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
ok();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int s, n, a;
scanf("%d %d\n", &s, &n);
vector<int> v;
v.assign(s, 0);
for (int i = 0; i < s; i++) scanf(" %d", &v[i]);
sort(v.begin(), v.end());
bool p = true;
for (int i = 0; i < s - 1; i++) {
if ((n - v[i]) >= 0)
n -= v[i];
else {
p = false;
break;
}
}
if (p)
printf("YES\n");
else
printf("NO\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<int, int>> a;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a.push_back(make_pair(y, x));
}
int c = 1, ans = 0;
sort(a.begin(), a.end(), greater<pair<int, int>>());
for (auto p : a) {
if (c > 0) {
c += p.first;
ans += p.second;
}
c--;
}
cout << ans << endl;
}
| 1 |
// Problem: F. The Treasure of The Segments
// Contest: Codeforces - Codeforces Round #690 (Div. 3)
// URL: https://codeforces.com/contest/1462/problem/F
// Memory Limit: 256 MB
// Time Limit: 3000 ms
#include<bits/stdc++.h>
using namespace std;
#define _rep(i, x, y) for(int i = (int)x; i < (int)y; ++i)
#define _dep(i,x,y) for(int i = (int)x; i > (int)y; i--)
#define PII pair<int,int>
#define eb emplace_back
#define pb push_back
#define fi first
#define se second
#define PQ priority_queue
#define lb lower_bound
#define ub upper_bound
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VII;
typedef vector<ll> VL;
typedef vector<vector<ll>> VLL;
constexpr int mod = 1e9 + 7;
constexpr int KINF = 0x3f3f3f3f;
constexpr double eps = 1e-7;
int main(){
ios::sync_with_stdio(false); cin.tie(0);
int _;
cin >> _;
while(_--){
int n;
cin >> n;
vector<PII> a(n);
VI b;
_rep(i, 0, n){
cin >> a[i].fi >> a[i].se;
b.eb(a[i].fi), b.eb(a[i].se);
}
sort(b.begin(), b.end());
b.erase(unique(b.begin(), b.end()), b.end());
_rep(i, 0, n){
a[i].fi = lb(b.begin(), b.end(), a[i].fi) - b.begin() + 1;
a[i].se = lb(b.begin(), b.end(), a[i].se) - b.begin() + 1;
}
int N = b.size();
VI sum(N + 1);
auto update = [&](int x){
for(int i = x; i <= N; i += (i & (-i)))
sum[i] += 1;
};
auto query = [&](int x){
int res = 0;
while(x){
res += sum[x];
x &= (x - 1);
}
return res;
};
sort(a.begin(), a.end());
VI ans(n);
int res = n - 1;
_rep(i, 0, n){
ans[i] = query(N) - query(a[i].fi - 1);
update(a[i].se);
}
//cout << query(N) << endl;
//_rep(i, 0, n) cout << ans[i] << " \n"[i == n - 1];
//_rep(i, 0, N + 1) cout << sum[i] << " \n"[i == N];
fill(sum.begin(), sum.end(), 0);
_dep(i, n - 1, -1){
ans[i] += query(a[i].se);
update(a[i].fi);
res = min(res, n - 1 - ans[i]);
}
cout << res << endl;
}
return 0;
}
//fixed << setprecision(8)
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 Rand(time(0));
const int maxn = 1e3 + 5;
const long long maxc = 1e9 + 7;
int kmpS[55], kmpT[55];
vector<vector<int>> nextS, nextT;
string s, t, a;
int n, m, k;
int f[maxn][55][55];
void KMP(string s, int kmp[], vector<vector<int>>& abcxyz, int n) {
abcxyz.assign(n + 2, vector<int>(257));
int j = 0;
for (int i = (2); i <= (n); ++i) {
while (j > 0 && s[j + 1] != s[i]) j = kmp[j];
if (s[j + 1] == s[i]) kmp[i] = ++j;
}
kmp[0] = -1;
for (int i = (0); i <= (n); ++i) {
for (int j = i; j >= 0; j = kmp[j])
abcxyz[i][s[j + 1]] = max(abcxyz[i][s[j + 1]], j + 1);
}
}
void solve() {
for (int i = (0); i <= (n); ++i)
for (int j = (0); j <= (m); ++j)
for (int u = (0); u <= (k); ++u) f[i][j][u] = -maxc;
f[0][0][0] = 0;
for (int i = (0); i <= (n - 1); ++i) {
for (int j = (0); j <= (m); ++j) {
for (int u = (0); u <= (k); ++u) {
if (f[i][j][u] <= -maxc) continue;
char t = a[i + 1];
if (t == '*') {
for (int c = ('a'); c <= ('z'); ++c) {
f[i + 1][nextS[j][c]][nextT[u][c]] =
max(f[i + 1][nextS[j][c]][nextT[u][c]],
f[i][j][u] + (nextS[j][c] == m) - (nextT[u][c] == k));
}
} else {
f[i + 1][nextS[j][t]][nextT[u][t]] =
max(f[i + 1][nextS[j][t]][nextT[u][t]],
f[i][j][u] + (nextS[j][t] == m) - (nextT[u][t] == k));
}
}
}
}
int ans = -maxc;
for (int j = (0); j <= (m); ++j)
for (int u = (0); u <= (k); ++u) ans = max(ans, f[n][j][u]);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> s >> t;
n = a.size(), m = s.size(), k = t.size();
a = ' ' + a + ' ';
s = ' ' + s + ' ';
t = ' ' + t + ' ';
KMP(s, kmpS, nextS, m);
KMP(t, kmpT, nextT, k);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) {
if (ch == '-') f = -1;
}
for (; isdigit(ch); ch = getchar()) {
x = x * 10 + ch - 48;
}
return x * f;
}
const int mxN = 500;
const int P = 1e9 + 7;
int cnt[mxN + 3];
int n;
long long quickpow(long long x, long long y) {
long long cur = x, ret = 1ll;
for (int i = 0; y; i++) {
if (y & (1ll << i)) {
y -= (1ll << i);
ret = ret * cur % P;
}
cur = cur * cur % P;
}
return ret;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int x = read();
if (x != -1) {
cnt[x]++;
}
}
long long ans = quickpow(2ll, n - 1) - 1;
for (int i = 1; i <= n; i++) {
ans = (ans - quickpow(2ll, cnt[i]) + 1 + P) % P;
}
printf("%I64d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, len, rec[233], bd[233], res[233];
char s[233];
long long myhash(char ch) { return ch - 'a'; }
void doit() {
len = strlen(s);
bd[myhash(s[0])] = true;
reverse(s, s + len);
for (long long i = 0, a = 1; i < len; ++i, a *= 10) rec[myhash(s[i])] += a;
}
pair<long long, long long> p[233];
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; ++i) {
scanf("%s", s);
doit();
}
for (long long i = 0; i <= 9; ++i) p[i] = make_pair(rec[i], i);
memset(res, -1, sizeof res);
sort(p, p + 10, greater<pair<long long, long long> >());
for (long long i = 0; i <= 9; ++i) {
if (!bd[p[i].second]) {
res[p[i].second] = 0;
break;
}
}
long long nw = 1;
for (long long i = 0; i <= 9; ++i) {
if (~res[p[i].second]) continue;
res[p[i].second] = nw++;
}
long long ans = 0;
for (long long i = 0; i <= 9; ++i)
if (~res[i]) ans += rec[i] * res[i];
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans, x[320], y[320], f[6][320][320];
struct node {
long long x, y, u, v;
node(long long x = 0, long long y = 0, long long u = 0, long long v = 0)
: x(x), y(y), u(u), v(v) {}
bool operator<(const node &w) const {
long long o1 = x > 0 || (x == 0 && y > 0),
o2 = (w.x > 0) || (w.x == 0 && w.y > 0);
if (o1 != o2) return o1 < o2;
return x * w.y - y * w.x >= 0;
}
} a[320 * 320];
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; ++i) {
scanf("%lld%lld", x + i, y + i);
}
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= n; ++j)
if (i != j) a[++m] = node(x[i] - x[j], y[i] - y[j], i, j);
sort(a + 1, a + m + 1);
for (long long i = 1; i <= n; ++i) f[0][i][i] = 1;
for (long long i = 1; i <= m; ++i)
for (long long j = 0; j < 5; ++j)
for (long long k = 1; k <= n; ++k) f[j + 1][k][a[i].v] += f[j][k][a[i].u];
for (long long i = 1; i <= n; ++i) ans += f[5][i][i];
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
int Cnt[1030];
long long Ans;
long long F[1030][1030];
vector<int> To[15];
int main() {
int i, j, k, t, p, s, u, v;
scanf("%d%d%d", &N, &M, &K);
while (M--) {
scanf("%d%d", &u, &v);
To[u].push_back(v);
To[v].push_back(u);
}
for (i = 0; i < N; i++) F[1 << i][1 << i] = 1;
for (i = 1; i < 1 << N; i++) Cnt[i] = __builtin_popcount(i);
for (i = 1; i < 1 << N; i++)
for (j = i; j; j = (j - 1) & i)
if (F[i][j])
for (k = 0; k < N; k++)
if (i >> k & 1)
for (t = 0; t < To[k + 1].size(); t++)
if (!(i >> (p = To[k + 1][t] - 1) & 1)) {
if (Cnt[i] > 1)
s = j & ~(1 << k) | 1 << p;
else
s = j | 1 << p;
if (!(s >> p + 1)) F[i | 1 << p][s] += F[i][j];
}
for (i = 0; i < 1 << N; i++)
if (Cnt[i] == K) Ans += F[(1 << N) - 1][i];
printf("%I64d\n", Ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;
struct Spell {
int p, d, id;
Spell() {}
Spell(int _p, int _d, int _id) : p(_p), d(_d), id(_id) {}
};
const int N = 1010;
int n, mx, reg, tm;
vector<ii> res;
Spell spell[N];
int taken[N];
bool solve() {
int hp = mx;
tm = 0;
memset(taken, 0, sizeof taken);
while (true) {
int i = -1;
for (int j = 0; j < n; j++)
if (!taken[j]) {
if (spell[j].p * mx >= 100 * hp) {
if (i == -1 || spell[j].d > spell[i].d) i = j;
}
}
if (i == -1) {
for (int j = 0; j < n; j++)
if (!taken[j]) {
if (i == -1 || spell[j].p > spell[i].p) i = j;
}
}
if (i == -1) break;
if (spell[i].p * mx < 100 * hp) {
if (reg >= 0) return false;
int k = (100 * hp - spell[i].p * mx - 1) / (-100 * reg) + 1;
tm += k;
hp = hp + k * reg;
if (hp <= 0) return true;
}
res.push_back({tm, spell[i].id});
taken[i] = true;
reg -= spell[i].d;
tm++;
hp = min(mx, hp + reg);
if (hp <= 0) return true;
}
if (reg >= 0) return false;
int k = (hp - 1) / (-reg) + 1;
tm += k;
return true;
}
int main() {
int p, d;
scanf("%d%d%d", &n, &mx, ®);
for (int i = 0; i < n; i++) {
scanf("%d%d", &p, &d);
spell[i] = Spell(p, d, i + 1);
}
if (solve()) {
printf("YES\n");
printf("%d %d\n", tm, (int)res.size());
for (const ii& e : res) printf("%d %d\n", e.first, e.second);
} else
printf("NO\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
pair<long long, long long> a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort(a, a + n);
long long mx = 0, mx_start = 0, mx_end = 0;
long long j;
long long mn = n;
for (long long i = 0; i < n; i++) {
long long c = a[i].second;
long long d, ck = 0;
for (j = i; j < n; j++) {
if (a[i].first != a[j].first) {
d = a[j - 1].second;
break;
} else
ck++;
}
if (j == n) {
d = a[j - 1].second;
i = n - 1;
} else
i = j - 1;
if (ck > mx) {
mx = ck;
mx_start = c;
mx_end = d;
mn = d - c + 1;
} else if (ck == mx && (d - c + 1) < mn) {
mx = ck;
mx_start = c;
mx_end = d;
mn = d - c + 1;
}
}
cout << mx_start << ' ' << mx_end << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, j, k, in) for (int i=j; i<k; i+=in)
#define RFOR(i, j, k, in) for (int i=j; i>=k; i-=in)
#define F(i, n) FOR(i, 0, n, 1)
#define MP make_pair
#define PB push_back
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int,int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef queue<int> QI;
typedef stack<int> SI;
const int MAX_N = 1e5 + 1;
const ll MOD = 1e9 + 7;
const ll INF = 1e9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
ll t;
cin >> t;
while(t--) {
ll n;
cin >> n;
ll sum = 0;
F(i, n){
ll temp;
cin >> temp;
sum+=temp;
}
ll v = sum % n;
ll ans = v * (n-v);
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T pwr(T b, T p) {
T r = 1, x = b;
while (p) {
if (p & 1) r *= x;
x *= x;
p = (p >> 1);
}
return r;
}
template <class T>
T lcm(T a, T b) {
return (a / __gcd(a, b)) * b;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
void xswap(T &x, T &y) {
if (x != y) {
x ^= y;
y ^= x;
x ^= y;
}
}
template <typename T>
inline bool isOn(T &mask, int pos) {
return ((mask) & (1LL << pos));
}
template <typename T>
inline T setf(T mask, int pos) {
return mask = ((mask) & (~(1LL << pos)));
}
template <typename T>
inline T sett(T mask, int pos) {
return mask = ((mask) | (1LL << pos));
}
template <typename T>
inline T flip(T mask, int pos) {
return mask = ((mask) ^ (1LL << pos));
}
template <class T1>
void put(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void put(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void put(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void put(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void put(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1>
void putv(vector<T1> e1) {
for (int i = 0; i < e1.size(); i++)
(!i ? cout << e1[i] : cout << " " << e1[i]);
cout << endl;
}
template <class T1>
void puta(T1 arr[], int l) {
for (int i = 0; i < l; i++) (!i ? cout << arr[i] : cout << " " << arr[i]);
cout << endl;
}
template <class T1>
bool tk(T1 &e1) {
return (cin >> e1 ? true : false);
}
template <class T1, class T2>
bool tk(T1 &e1, T2 &e2) {
return (cin >> e1 >> e2 ? true : false);
}
template <class T1, class T2, class T3>
bool tk(T1 &e1, T2 &e2, T3 &e3) {
return (cin >> e1 >> e2 >> e3 ? true : false);
}
template <class T1, class T2, class T3, class T4>
bool tk(T1 &e1, T2 &e2, T3 &e3, T4 &e4) {
return (cin >> e1 >> e2 >> e3 >> e4 ? true : false);
}
map<int, int> er;
map<int, int> er2;
map<int, int> er3;
int main() {
int n, tmp, mx = -9;
tk(n);
for (int i = 0; i <= n - 1; ++i) {
tk(tmp);
mx = max(mx, tmp);
er[tmp]++;
}
for (int i = 0; i <= n - 2; ++i) {
tk(tmp);
er2[tmp]++;
}
for (typeof((er).begin()) it = (er.begin()); it != (er).end(); ++it) {
if (it->second == er2[it->first] + 1) {
put(it->first);
(it->second)--;
break;
}
}
for (int i = 0; i <= n - 3; ++i) {
tk(tmp);
er3[tmp]++;
}
for (typeof((er2).begin()) it = (er2.begin()); it != (er2).end(); ++it) {
if (it->second == er3[it->first] + 1) {
put(it->first);
(it->second)--;
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
struct Rectangle {
long long w, h, c;
} rec[MAXN + 5];
long long R, C, ans, gr, gc;
vector<long long> rev;
vector<pair<long long, long long> > row[MAXN + 5];
map<long long, long long> trans;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
bool not_equal(long long c1, long long c2, long long c3, long long c4) {
long long g = gcd(c1, c4);
c1 /= g;
c4 /= g;
if (c2 % c4 != 0) return true;
c2 /= c4;
if (c1 > c3 / c2) return true;
return c1 * c2 != c3;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> rec[i].w >> rec[i].h >> rec[i].c;
rev.push_back(rec[i].h);
}
sort((rev).begin(), (rev).end());
rev.resize(unique((rev).begin(), (rev).end()) - rev.begin());
for (int i = 0; i < rev.size(); i++) {
trans[rev[i]] = i;
}
for (int i = 0; i < N; i++) {
rec[i].h = trans[rec[i].h];
}
for (int i = 0; i < N; i++) {
row[rec[i].h].push_back({rec[i].w, rec[i].c});
}
bool ok = true;
R = rev.size(), C = row[0].size();
for (int i = 0; i < R; i++) {
sort((row[i]).begin(), (row[i]).end());
if (row[i].size() != C) {
ok = false;
break;
}
for (int j = 0; j < C; j++) {
if (row[i][j].first != row[0][j].first) {
ok = false;
break;
}
if (not_equal(row[i][0].second, row[0][j].second, row[0][0].second,
row[i][j].second)) {
ok = false;
break;
}
}
}
if (!ok) {
cout << 0 << '\n';
return 0;
}
gr = gc = row[0][0].second;
for (int i = 0; i < R; i++) gc = gcd(gc, row[i][0].second);
for (int i = 0; i < C; i++) gr = gcd(gr, row[0][i].second);
long long x = row[0][0].second;
for (long long i = 1; i * i <= x; i++) {
if (x % i == 0) {
long long r = i, n = x / i;
if (gr % r == 0 && gc % n == 0) ans++;
if (r != n) {
if (gr % n == 0 && gc % r == 0) ans++;
}
}
}
cout << ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
const double eps = 1e-5;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
double x[3], y[3], z[3], r[3];
double sqr(double a) { return a * a; }
double dist(double x1, double y1, double x2, double y2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
}
double f(double xx, double yy) {
for (int i = 0; i < 3; i++) z[i] = dist(xx, yy, x[i], y[i]) / r[i];
return sqr(z[1] - z[0]) + sqr(z[2] - z[1]) + sqr(z[2] - z[0]);
}
int main() {
int p;
double m, step, xx, yy, tag;
xx = yy = 0;
for (int i = 0; i < 3; i++) scanf("%lf %lf %lf", &x[i], &y[i], &r[i]);
step = 1;
xx = (x[0] + x[1] + x[2]) / 3;
yy = (y[0] + y[1] + y[2]) / 3;
while (step > eps) {
m = f(xx, yy);
p = -1;
for (int i = 0; i < 4; i++) {
tag = f(xx + dx[i] * step, yy + dy[i] * step);
if (tag < m) {
m = tag;
p = i;
}
}
if (p == -1)
step /= 2;
else {
xx = xx + dx[p] * step;
yy = yy + dy[p] * step;
}
}
if (f(xx, yy) <= eps) printf("%.5f %.5f", xx, yy);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int scale(char c) {
if (c <= '9' && c >= '0') return c - '0';
if (c <= 'Z' && c >= 'A') return c - 'A' + 1;
return c - 'a' + 1;
}
int main() {
int n;
cin >> n;
string t;
map<string, int> m;
for (int i = 0; i < n; ++i) {
cin >> t;
m[t]++;
}
for (int i = 0; i < n; ++i) {
cin >> t;
if (m[t]) {
m[t]--;
}
}
long long sum = 0;
for (auto u : m) {
sum += u.second;
}
cout << sum << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int n, a[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, flg = 0;
cin >> n;
long long pos = 0, neg = 0;
for (int i = 0; i < (n); i++) {
cin >> a[i];
if (a[i] > 0) {
pos += a[i] / 2;
} else {
neg += a[i] / 2;
}
}
if (pos > abs(neg)) {
neg = abs(neg + pos);
for (int i = 0; i < (n); i++) {
if (a[i] % 2 != 0 && a[i] < 0 && neg) {
neg--;
cout << (a[i] / 2) - 1 << endl;
} else {
cout << a[i] / 2 << endl;
}
}
} else {
pos = abs(pos + neg);
for (int i = 0; i < (n); i++) {
if (a[i] % 2 != 0 && a[i] > 0 && pos) {
pos--;
cout << (a[i] / 2) + 1 << endl;
} else {
cout << a[i] / 2 << endl;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
unordered_map<string, int> ma;
int T, n, tot;
int a[1000010], b[1000010];
long long dp[1000010][2], ans;
struct node {
int per, to;
} e[1000010];
int head[1000010];
long long sum;
void addedge(int from, int to) {
e[++tot].to = to;
e[tot].per = head[from];
head[from] = tot;
}
void dfs(int u, int fa) {
dp[u][b[u]]++;
for (int i = head[u]; i > 0; i = e[i].per) {
int v = e[i].to;
if (v == fa) continue;
dfs(v, u);
sum += dp[v][0] * dp[u][1] + dp[v][1] * dp[u][0];
if (b[u] > 0) {
dp[u][0] += dp[v][1];
dp[u][1] += dp[v][0];
} else {
dp[u][0] += dp[v][0];
dp[u][1] += dp[v][1];
}
}
sum += b[u];
}
int main() {
T = 1;
while (T--) {
memset(head, -1, sizeof(head));
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
for (int i = 0; i <= 20; ++i) {
sum = 0;
for (int j = 1; j <= n; ++j) {
b[j] = (a[j] & (1 << i)) > 0;
dp[j][0] = dp[j][1] = 0;
}
dfs(1, -1);
ans += sum << i;
}
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<long long int> a, b;
long long int ansOfa, ansOfb;
int main() {
scanf("%d", &n);
a.resize(n);
b.resize(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
if (i == 0) {
ansOfa = a[i];
} else {
ansOfa |= a[i];
}
}
for (int i = 0; i < n; i++) {
scanf("%lld", &b[i]);
if (i == 0) {
ansOfb = b[i];
} else {
ansOfb |= b[i];
}
}
cout << ansOfa + ansOfb << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int MOD = 1000000007;
int s[11];
vector<int> g;
vector<int> ans[11];
vector<string> solve(long long n) {
vector<string> res(6, "0");
if (n < 0) {
res[0] = "-";
return res;
}
if (n == 0) return res;
for (int i1 = 0; i1 <= 2; ++i1)
for (int i2 = i1; i2 <= 2; ++i2)
for (int i3 = i2; i3 <= 2; ++i3)
for (int i4 = i3; i4 <= 2; ++i4)
for (int i5 = i4; i5 <= 2; ++i5)
for (int i6 = i5; i6 <= 2; ++i6) {
int cur = g[i1] + g[i2] + g[i3] + g[i4] + g[i5] + g[i6];
if (cur % 10 != n % 10) continue;
vector<string> got = solve((n - cur) / 10);
if (got[0] == "-") continue;
got[0] += char(g[i1] + 48);
got[1] += char(g[i2] + 48);
got[2] += char(g[i3] + 48);
got[3] += char(g[i4] + 48);
got[4] += char(g[i5] + 48);
got[5] += char(g[i6] + 48);
return got;
}
res[0] = "-";
return res;
}
int main() {
g.push_back(0);
g.push_back(4);
g.push_back(7);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<string> a = solve(n);
if (a[0] == "-")
cout << "-1";
else
for (int i = 0; i <= 5; ++i) {
int pos = 0;
while (pos < (int)((a[i]).size()) - 1 && a[i][pos] == '0') ++pos;
for (int j = pos; j <= (int)((a[i]).size()) - 1; ++j) cout << a[i][j];
cout << " ";
}
cout << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = long unsigned long;
using ld = double long;
int n, m;
int a[4000005], z[4000005];
int ad(int x, int y) {
x += y;
if (x >= m) x -= m;
return x;
}
int sub(int x, int y) {
x -= y;
if (x < 0) x += m;
return x;
}
void walk_up(int x) {
for (int q = 1; q * x <= n; q++) {
z[q * x] = ad(z[q * x], a[x]);
if (q * x + q <= n) {
z[q * x + q] = sub(z[q * x + q], a[x]);
}
}
}
int main() {
ios::sync_with_stdio(!cin.tie(0));
cin >> n >> m;
a[1] = 1;
int s = 1;
walk_up(1);
for (int x = 2; x <= n; x++) {
a[x] = s;
z[x] = ad(z[x], z[x - 1]);
a[x] = ad(a[x], z[x]);
s = ad(s, a[x]);
walk_up(x);
}
cout << a[n] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[711];
const int mod = 1e9 + 7;
int kk[711][12], f[711][711][2];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int j = 0; j <= 9; j++) {
int num = s[n] - '0';
if (j > num) {
f[n][0][0] = num + 1;
f[n][1][0] = 0;
f[n][0][1] = j - num - 1;
f[n][1][1] = 10 - j;
} else {
f[n][0][0] = j;
f[n][1][0] = num - j + 1;
f[n][0][1] = 0;
f[n][1][1] = 10 - num - 1;
}
for (int a = n - 1; a; a--) {
int num = s[a] - '0';
if (j > num) {
f[a][0][0] =
(1ll * (f[a + 1][0][0] + f[a + 1][0][1]) * num + f[a + 1][0][0]) %
mod;
f[a][0][1] = (1ll * (f[a + 1][0][0] + f[a + 1][0][1]) * (j - num - 1) +
f[a + 1][0][1]) %
mod;
for (int b = 1, to = n - a + 1; b <= to; b++) {
f[a][b][0] =
(1ll * (f[a + 1][b][0] + f[a + 1][b][1]) * num + f[a + 1][b][0]) %
mod;
f[a][b][1] =
(1ll * (f[a + 1][b - 1][0] + f[a + 1][b - 1][1]) * (10 - j) +
1ll * (f[a + 1][b][0] + f[a + 1][b][1]) * (j - num - 1) +
f[a + 1][b][1]) %
mod;
}
} else {
f[a][0][0] = (1ll * (f[a + 1][0][0] + f[a + 1][0][1]) * j) % mod;
f[a][0][1] = 0;
for (int b = 1, to = n - a + 1; b <= to; b++) {
f[a][b][0] =
(1ll * (f[a + 1][b][0] + f[a + 1][b][1]) * j +
1ll * (f[a + 1][b - 1][0] + f[a + 1][b - 1][1]) * (num - j) +
f[a + 1][b - 1][0]) %
mod;
f[a][b][1] = (1ll * (f[a + 1][b - 1][0] + f[a + 1][b - 1][1]) *
(10 - num - 1) +
f[a + 1][b - 1][1]) %
mod;
}
}
}
for (int i = n; i; i--)
f[1][i][0] += f[1][i + 1][0], f[1][i][0] -= f[1][i][0] >= mod ? mod : 0,
kk[i][j] = f[1][i][0];
}
int ans = 0;
for (int i = 1, ten = 1; i <= n; i++) {
for (int j = 0; j <= 9; j++)
ans += 1ll * (kk[i][j] - kk[i][j + 1] + mod) * ten % mod * j % mod,
ans -= ans >= mod ? mod : 0, ans += ans < 0 ? mod : 0;
ten = 1ll * ten * 10 % mod;
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> vert(n);
for (int i = 0; i < n; i++) cin >> vert[i];
sort(vert.begin(), vert.end());
vector<int> gor;
int x1, x2, y;
for (int i = 0; i < m; i++) {
cin >> x1 >> x2 >> y;
if (x1 == 1) gor.push_back(x2);
}
sort(gor.begin(), gor.end());
m = gor.size();
int j = 0;
int minAns = 10000000;
for (int i = -1; i < n - 1; i++) {
while (j < m && gor[j] < vert[i + 1]) j++;
minAns = min(minAns, (i + 1) + m - j);
}
while (j < m && gor[j] < 1000000000) j++;
minAns = min(minAns, n + m - j);
cout << minAns;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gi() {
long long ret = 0;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
char c = ch == '-' ? getchar() : ch;
while (c >= '0' && c <= '9') ret = ret * 10 + c - '0', c = getchar();
return ch == '-' ? -ret : ret;
}
const int mo = 1e9 + 7;
const int N = 200010;
int n, k, a[N];
long long fac[N], ifac[N];
long long ksm(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % mo;
a = a * a % mo;
b >>= 1;
}
return ret;
}
long long C(int n, int m) {
if (n < m) return 0;
return fac[n] * ifac[m] % mo * ifac[n - m] % mo;
}
void calcS(long long &s, int k) {
for (int i = 0; i <= k; i += 1)
(s += ((i & 1) ? -1 : 1) * C(k, i) % mo * ksm(k - i, n - 1)) %= mo;
s = s * ifac[k] % mo;
}
int main() {
n = gi();
k = gi();
for (int i = 1; i <= n; i += 1) a[i] = gi();
fac[0] = ifac[0] = 1;
for (int i = 1; i <= n; i += 1) fac[i] = fac[i - 1] * i % mo;
ifac[n] = ksm(fac[n], mo - 2);
for (int i = n; i >= 1; i -= 1) ifac[i - 1] = ifac[i] * i % mo;
long long s1 = 0, s2 = 0;
calcS(s1, k - 1);
calcS(s2, k);
long long ans = 0;
for (int i = 1; i <= n; i += 1)
(ans += s1 * a[i] + s2 * (n - 1 + k) % mo * a[i]) %= mo;
cout << (ans + mo) % mo;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, a, b, c, r, l, d;
cin >> t;
while (t--) {
cin >> a >> b >> c >> r;
if (a > b) swap(a, b);
l = c - r;
r = c + r;
if (r <= a || l >= b) {
cout << b - a << endl;
continue;
}
if (l >= a && r <= b) {
cout << l - a + b - r << endl;
continue;
}
if (l < a && r > b) {
cout << "0" << endl;
continue;
}
if (l >= a && r > b) {
cout << l - a << endl;
continue;
}
if (l < a && r >= a && r <= b) {
cout << b - r << endl;
continue;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline bool query(int x, int y) {
printf("1 %d %d\n", x, y);
fflush(stdout);
string s;
cin >> s;
return s == "TAK";
}
inline int find(int l, int r) {
int mid = (l + r) >> 1;
while (l < r) {
mid = (l + r) >> 1;
if (query(mid, mid + 1))
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
int n, K;
scanf("%d%d", &n, &K);
int p1 = find(1, n), p2;
if (p1 == 1)
p2 = find(2, n);
else if (p1 == n)
p2 = find(1, n - 1);
else {
p2 = find(1, p1 - 1);
if (!query(p2, p1)) p2 = find(p1 + 1, n);
}
printf("2 %d %d\n", p1, p2);
fflush(stdout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[300010];
long long n, mx;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
if (a[i].first <= mx) {
a[i].first = mx + 1;
mx++;
} else {
mx = a[i].first;
}
}
for (int i = 1; i <= n; i++) {
swap(a[i].first, a[i].second);
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
cout << a[i].second << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
if (e == 0) return 1;
if (e % 2 == 0) {
T t = bigmod(p, e / 2, M);
return (t * t) % M;
}
return (bigmod(p, e - 1, M) * p) % M;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T multimod(T a, T b, T m) {
T ans = 0ll;
a %= m, b %= m;
while (b) {
if (b & 1ll) ans = m - ans > a ? (ans + a) : (ans + a - m);
b >>= 1ll;
a = (m - a) > a ? a + a : a + a - m;
}
return (T)ans;
}
int ans;
bool vis[(200000 + 7)];
int main() {
int j, i;
int t, n, u, k, v, cases = 1, m;
cin >> n;
string str;
cin >> str;
for (i = 0; i < n && str[i] == '<'; i++) {
vis[i] = 1;
}
for (i = n - 1; i >= 0 && str[i] == '>'; i--) {
vis[i] = 1;
}
for (i = 0; i < n; i++) ans += vis[i];
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int q[100005], p[100005], vis[100005];
int main() {
int n, t;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
int flag = 0;
int cnt = 0;
memset(vis, 0, sizeof(vis));
int i, j;
for (i = 1; i <= n; i++) {
scanf("%d", &q[i]);
vis[q[i]]++;
}
for (i = 1; i <= n; i++) {
if (vis[q[i]] == 1)
p[i] = q[i];
else if (vis[q[i]] > 1) {
p[i] = q[i];
int tmp = vis[q[i]];
for (j = q[i]; j > 0; j--) {
if (!vis[j]) {
p[++i] = j;
flag = 1;
vis[j] = 1;
tmp--;
}
if (tmp == 1) break;
}
if (!flag) cnt = 1;
flag = 0;
}
}
if (cnt)
printf("-1\n");
else
for (i = 1; i <= n; i++) {
if (i == n)
printf("%d\n", p[i]);
else
printf("%d ", p[i]);
}
}
}
| 2 |
#include <bits/stdc++.h>
const long double PI = acos(-1);
const long long N = 1e5 + 5;
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, ans = 0;
cin >> n >> m;
pair<long long, long long> a[m + 1];
map<int, int> mp;
for (int i = 0; i < m; i++) {
cin >> a[i].first >> a[i].second;
mp[a[i].first]++;
mp[a[i].second]++;
}
bool k = 1;
vector<long long> v;
while (k) {
k = 0;
for (int i = 0; i < m; i++) {
if (mp[a[i].first] == 1 || mp[a[i].second] == 1) {
v.push_back(a[i].first);
v.push_back(a[i].second);
k = 1;
}
}
for (; v.size() > 0;) {
mp[v[0]]--;
v.erase(v.begin());
}
if (k) ans++;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[1000001];
long long int dp1[1000001];
long long int inv[1000001];
void solve() {
int n;
cin >> n;
string a, b;
cin >> a >> b;
for (int i = 0; i < n; i++) {
if (a[i] == '1' && b[i] == '1') {
cout << "NO";
return;
}
}
cout << "YES";
}
void read_input() {}
void case_number() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
case_number();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long ask1(int i, int j, int k) {
cout << 1 << ' ' << i << ' ' << j << ' ' << k << endl;
long long get;
cin >> get;
return get;
}
int ask2(int i, int j, int k) {
cout << 2 << ' ' << i << ' ' << j << ' ' << k << endl;
int get;
cin >> get;
return get;
}
int main() {
int n;
cin >> n;
vector<pair<long long, int>> up, down;
for (int i = 3; i <= n; i++) {
long long sz = ask1(1, 2, i);
if (ask2(1, 2, i) == 1)
up.push_back({sz, i});
else
down.push_back({sz, i});
}
sort(up.begin(), up.end());
sort(down.begin(), down.end());
vector<int> upord(up.size()), downord(down.size());
int l = 0, r = int(up.size()) - 1;
for (int i = 0; i < int(up.size()) - 1; i++) {
if (ask2(1, up[i].second, up.back().second) == 1)
upord[l] = up[i].second, l++;
else
upord[r] = up[i].second, r--;
}
for (int i = 0; i < int(up.size()); i++)
if (upord[i] == 0) {
upord[i] = up.back().second;
break;
}
l = 0;
r = int(down.size()) - 1;
for (int i = 0; i < int(down.size()) - 1; i++) {
if (ask2(1, down[i].second, down.back().second) == 1)
downord[l] = down[i].second, l++;
else
downord[r] = down[i].second, r--;
}
for (int i = 0; i < int(down.size()); i++)
if (downord[i] == 0) {
downord[i] = down.back().second;
break;
}
cout << 0 << ' ';
cout << 1 << ' ';
for (int first : downord) cout << first << ' ';
cout << 2 << ' ';
for (int first : upord) cout << first << ' ';
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1000001], n, mx, mxi, q;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> q;
a[q]++;
if (a[q] > mx) {
mx = a[q];
mxi = q;
}
}
cout << mxi;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b;
cin >> a >> b;
if (b == 0) {
cout << 1 << '\n';
return;
}
if (a == 0) {
cout << 0.5 << '\n';
return;
}
if (a <= b * 4) {
cout << fixed << setprecision(9) << (long double)(a + 8 * b) / (16 * b)
<< '\n';
} else {
cout << fixed << setprecision(8) << 1 - (long double)b / a << '\n';
}
}
int main() {
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt[1111];
int main() {
string s;
string t = "Bulbasaur";
int ans = 1e9;
cin >> s;
for (int i = 0; i < s.size(); ++i) {
cnt[s[i]]++;
}
cnt['u'] /= 2;
cnt['a'] /= 2;
for (int i = 0; i < t.size(); i++) {
ans = min(ans, cnt[t[i]]);
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x1[110];
int botva[110];
int x2[110];
int y2[110];
long double xc[110];
long double yc[110];
int m[110];
const long double eps = 1e-05;
bool inside(long double x1, long double botva, long double x2, long double y2,
long double a, long double b) {
if (a < x1 - eps || a > x2 + eps) return false;
if (b < botva - eps || b > y2 + eps) return false;
cerr << "!!!!!!" << endl;
return true;
}
bool check(int k) {
long double x = 0, y = 0;
int m = 0;
for (int i = k; i >= 0; i--) {
x = (x * m + xc[i] * ::m[i]) / (m + ::m[i]);
y = (y * m + yc[i] * ::m[i]) / (m + ::m[i]);
m += ::m[i];
if (i == 0) {
if (!inside(x1[i], botva[i], x2[i], y2[i], x, y)) return false;
} else {
if (!inside(max(x1[i], x1[i - 1]), max(botva[i], botva[i - 1]),
min(x2[i], x2[i - 1]), min(y2[i], y2[i - 1]), x, y))
return false;
}
}
return true;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d %d", &x1[i], &botva[i], &x2[i], &y2[i]);
int a = abs(x2[i] - x1[i]);
m[i] = a * a * a;
xc[i] = (x1[i] + x2[i]) / 2.0;
yc[i] = (botva[i] + y2[i]) / 2.0;
if (x1[i] > x2[i]) swap(x1[i], x2[i]);
if (botva[i] > y2[i]) swap(botva[i], y2[i]);
if (!check(i)) {
printf("%d\n", i);
return 0;
}
}
printf("%d\n", n);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ob(int i) {
int s = 0;
while (i > 0) s = s * 10 + i % 10, i /= 10;
return s;
}
bool f(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
int main() {
int n, kol = 0;
cin >> n;
for (int i = 2;; i++) {
if (f(i) && f(ob(i)) && i != ob(i)) kol++;
if (kol == n) {
cout << i;
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> a;
vector<vector<int>> ans;
int check(int x, int p, int i) {
int cap;
if (a[x].size() > 2)
return -1;
else if (a[x].size() == 2) {
ans[i].push_back(x);
if (a[x][0] != p)
cap = check(a[x][0], x, i);
else
cap = check(a[x][1], x, i);
} else if (a[x].size() == 1) {
ans[i].push_back(x);
return 1;
}
return cap;
}
int main() {
int t = 1;
while (t--) {
int n;
cin >> n;
a.resize(n + 1);
int u, v;
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
int m = 1;
for (int i = 1; i < (n - 1); i++) {
cin >> u >> v;
a[u].push_back(v);
a[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (a[i].size() > a[m].size()) m = i;
}
int c = 1;
int l = a[m].size();
ans.resize(l);
for (int i = 0; i < a[m].size(); i++) {
ans[i].push_back(m);
c = check(a[m][i], m, i);
if (c == -1) break;
}
if (c == 1) {
cout << "Yes\n";
cout << l << endl;
for (int i = 0; i < ans.size(); i++) {
int j = ans[i].size();
cout << ans[i][0] << " " << ans[i][j - 1];
cout << endl;
}
} else
cout << "No\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void print(vector<T> v) {
cerr << "[";
if ((int)((v).size()) != 0) cerr << v[0];
for (__typeof((int)((v).size())) i = (1); i < ((int)((v).size())); ++i)
cerr << "," << v[i];
cerr << "]\n";
}
template <class T>
string i2s(T &x) {
ostringstream o;
o << x;
return o.str();
}
vector<string> split(string &s, char c = ' ') {
vector<string> all;
int p = 0, np;
while (np = s.find(c, p), np >= 0) {
if (np != p) all.push_back(s.substr(p, np - p));
p = np + 1;
}
if (p < (int)((s).size())) all.push_back(s.substr(p));
return all;
}
int n;
vector<int> d;
void readData() {
scanf("%d", &n);
d.resize(n);
for (__typeof(n) i = (0); i < (n); ++i) scanf("%d", &(d[i]));
sort(d.begin(), d.end(), greater<int>());
}
vector<int> r;
vector<int> par;
int slack;
int _solve(int ind) {
if (d[ind] == 1) {
return 1;
}
int start = 0;
if (ind > 1 && d[ind - 1] == d[ind]) start = par[ind - 1];
for (int p = start; p < ind; p++) {
if (r[p] > d[ind] + 1 || (r[p] == d[ind] + 1 && r[p] != d[p])) {
r[p] -= d[ind];
par[ind] = p;
if (_solve(ind + 1)) return 1;
r[p] += d[ind];
}
}
return 0;
}
int solve() {
for (__typeof(n) i = (0); i < (n); ++i)
if (d[i] == 2) return 0;
if (n == 1 && d[0] == 1) return 1;
if (d[0] != n) return 0;
r = d;
par = vector<int>(n);
slack = 0;
return _solve(1);
}
int main(int argc, char *argv[]) {
readData();
if (solve())
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> divisors;
int gcd(int m, int n) {
while (n != 0) {
int t = m % n;
m = n;
n = t;
}
return m;
}
void get_divisors(int g) {
int rt = sqrt(g);
for (int i = 1; i <= rt; ++i) {
if (g % i == 0) {
divisors.push_back(i);
divisors.push_back(g / i);
}
}
if (divisors.back() == rt) divisors.pop_back();
sort(divisors.begin(), divisors.end());
}
int main() {
int a, b;
scanf("%d %d", &a, &b);
get_divisors(gcd(a, b));
int n;
scanf("%d", &n);
int low, high;
while (n--) {
scanf("%d %d", &low, &high);
int idx =
upper_bound(divisors.begin(), divisors.end(), high) - divisors.begin();
printf("%d\n",
((idx > 0 && low <= divisors[idx - 1]) ? divisors[idx - 1] : -1));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[5005], pre[5005];
int n;
void input() {
int i, j, a, b, k;
int l, r, dist;
scanf("%d %d %d %d", &n, &a, &b, &k);
dp[a] = 1;
for ((i) = (1); (i) <= (n); (i)++) pre[i] = pre[i - 1] + dp[i];
for ((i) = 0; (i) < (k); (i)++) {
for ((j) = (1); (j) <= (n); (j)++) {
dist = abs(j - b);
if (j < b) {
dp[j] = pre[j - 1];
dp[j] += (pre[j + dist / 2 - (dist % 2 == 0)] - pre[j] + 1000000007) %
1000000007;
dp[j] %= 1000000007;
} else if (j > b) {
dp[j] = (pre[n] - pre[j] + 1000000007) % 1000000007;
dp[j] += (pre[j - 1] - pre[j - dist / 2 - dist % 2] + 1000000007) %
1000000007;
dp[j] %= 1000000007;
}
}
for ((j) = (1); (j) <= (n); (j)++)
pre[j] = (pre[j - 1] + dp[j]) % 1000000007;
}
printf("%d", pre[n]);
}
int main() {
input();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long quick(int o, int p) {
long long oo = o * 1ll, pp = p * 1ll, ans = 1;
while (pp) {
if (pp & 1) ans = (ans * oo) % 1000000007;
pp /= 2;
oo = (oo * oo) % 1000000007;
}
return ans;
}
int i, j, k, l, s, m, n, f[100005];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
char c = getchar();
while (c != 'A' && c != 'C' && c != 'G' && c != 'T') c = getchar();
if (c == 'A') f[1]++;
if (c == 'C') f[2]++;
if (c == 'G') f[3]++;
if (c == 'T') f[4]++;
}
int mm = 0, tt = 0;
for (i = 1; i <= 4; i++) {
if (f[i] > mm) {
mm = f[i];
tt = 1;
} else if (f[i] == mm)
tt++;
}
printf("%I64d\n", quick(tt, n));
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5;
long long a[maxN];
long long mn[maxN];
long long mx[maxN];
long long rev_mn[maxN];
long long rev_mx[maxN];
int main() {
int n;
long long p, q, r;
cin >> n >> p >> q >> r;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
mn[0] = a[0];
mx[0] = a[0];
for (int i = 1; i < n; i++) {
mn[i] = min(a[i], mn[i - 1]);
mx[i] = max(a[i], mx[i - 1]);
}
rev_mn[n - 1] = a[n - 1];
rev_mx[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
rev_mn[i] = min(a[i], rev_mn[i + 1]);
rev_mx[i] = max(a[i], rev_mx[i + 1]);
}
long long ans = 0;
bool was = false;
for (int i = 0; i < n; i++) {
long long now = q * a[i];
if (p >= 0) {
now += p * mx[i];
} else {
now += p * mn[i];
}
if (r >= 0) {
now += r * rev_mx[i];
} else {
now += r * rev_mn[i];
}
if (was) {
ans = max(ans, now);
} else {
ans = now;
was = true;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const double PI = 3.141592653528;
const long long INF = 10000000000000000;
int v[1111111];
const int N = 100000;
int lp[N + 1];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, a, b;
scanf("%d%d%d", &n, &a, &b);
for (int i = 1; i <= n; ++i) scanf("%d", &v[i]);
vector<int> pr;
for (int i = 2; i <= N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (int j = 0; j < (int)pr.size() && pr[j] <= lp[i] && i * pr[j] <= N; ++j)
lp[i * pr[j]] = pr[j];
}
int i0 = 0;
set<int> st;
for (int i = -1; i <= 1; ++i) {
int p = v[1] + i;
for (int j = 0; j < pr.size(); ++j) {
if (p % pr[j] == 0) {
st.insert(pr[j]);
while (p % pr[j] == 0) p /= pr[j];
}
}
if (p != 1) st.insert(p);
}
for (int i = -1; i <= 1; ++i) {
int p = v[n] + i;
for (int j = 0; j < pr.size(); ++j) {
if (p % pr[j] == 0) {
st.insert(pr[j]);
while (p % pr[j] == 0) p /= pr[j];
}
}
if (p != 1) st.insert(p);
}
long long mn = 1ll * (n - 1) * a;
for (set<int>::iterator it = st.begin(); it != st.end(); ++it) {
int p = *it;
bool ok = 1;
for (int k = 1; k <= n; ++k)
if (v[k] % p != 0) ok = 0;
if (ok) {
mn = 0;
break;
}
vector<vector<long long> > dp(n + 1, vector<long long>(3, INF));
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
for (int k = 1; k <= n; ++k) {
int mod = v[k] % p;
if (mod == 0) {
dp[k][0] = dp[k - 1][0];
dp[k][1] = min(dp[k - 1][0], dp[k - 1][1]) + a;
dp[k][2] = min(dp[k - 1][2], dp[k - 1][1]);
} else {
if (mod != 1 && mod != p - 1)
dp[k][1] = min(dp[k - 1][0] + a, dp[k - 1][1] + a);
else {
dp[k][0] = dp[k - 1][0] + b;
dp[k][2] = min(dp[k - 1][1], dp[k - 1][2]) + b;
dp[k][1] = min(dp[k - 1][1], dp[k - 1][0]) + a;
}
}
for (int l = 0; l < 3; ++l) dp[k][l] = min(dp[k][l], INF);
}
mn = min(mn, min(dp[n][0], min(dp[n][1], dp[n][2])));
}
printf("%lld", mn);
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.