solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, hc, hp;
cin >> n >> hp;
t = hp + 1;
n--;
while (n--) {
cin >> hc;
t += abs(hp - hc) + 2;
hp = hc;
}
cout << t;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int pos[600006];
queue<int> q;
vector<int> adj;
int A(int k) { return k + 2000; }
int main() {
ios_base::sync_with_stdio(false);
int n, k, p;
cin >> n >> k;
for (int i = 0; i < k; i++) {
cin >> p;
if (pos[A(p - n)] == 1) continue;
adj.push_back((p - n));
pos[A(p - n)] = 1;
q.push(A(p - n));
}
while (!q.empty()) {
p = q.front();
q.pop();
for (int i = 0; i < adj.size(); i++) {
int nxt = p + adj[i];
if (nxt < A(-1000) || nxt > A(1000) || pos[nxt] != 0) continue;
pos[nxt] = pos[p] + 1;
q.push(nxt);
}
}
if (pos[A(0)] == 0)
cout << "-1\n";
else
cout << pos[A(0)] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int M = 55;
const int inf = 1e9;
string alpha;
struct aho_corasick {
vector<map<char, int>> trie;
vector<int> cnt;
vector<int> link;
int new_node() {
trie.push_back(map<char, int>());
cnt.push_back(0);
link.push_back(0);
return (int)(trie).size() - 1;
}
aho_corasick() { new_node(); }
void insert(string &s, int add, int x = 0) {
for (int i = (0); i <= (((int)(s).size()) - 1); i += (+1)) {
if (!trie[x].count(s[i])) {
trie[x][s[i]] = new_node();
}
x = trie[x][s[i]];
}
cnt[x] += add;
}
int suffix(int x, char c) {
while (x && !trie[x][c]) {
x = link[x];
}
return trie[x][c];
}
void build_links() {
queue<int> q;
q.push(0);
while (!q.empty()) {
int x = q.front();
q.pop();
for (char c : alpha) {
int &y = trie[x][c];
if (y == 0) {
y = trie[link[x]][c];
continue;
}
link[y] = x ? suffix(link[x], c) : 0;
cnt[y] += cnt[link[y]];
q.push(y);
}
}
}
};
aho_corasick aho;
int dp[N][2 * M];
string code, s, t;
template <typename T>
void umax(T &a, T b) {
a = max(a, b);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0), cout.precision(15);
for (int c = ('a'); c <= ('z'); c += (+1)) {
alpha.push_back(char(c));
}
cin >> code >> s >> t;
aho.insert(s, +1);
aho.insert(t, -1);
aho.build_links();
for (int i = (0); i <= (((int)(code).size() + 1) - 1); i += (+1)) {
for (int x = (0); x <= (((int)(aho.trie).size() + 1) - 1); x += (+1)) {
dp[i][x] = -inf;
}
}
dp[0][0] = 0;
for (int i = (0); i <= (((int)(code).size()) - 1); i += (+1)) {
for (int x = (0); x <= (((int)(aho.trie).size()) - 1); x += (+1)) {
if (code[i] == '*') {
for (char c : alpha) {
int y = aho.trie[x][c];
umax(dp[i + 1][y], dp[i][x] + aho.cnt[y]);
}
} else {
int y = aho.trie[x][code[i]];
umax(dp[i + 1][y], dp[i][x] + aho.cnt[y]);
}
}
}
int ans = -inf;
for (int x = (0); x <= (((int)(aho.trie).size()) - 1); x += (+1)) {
umax(ans, dp[(int)(code).size()][x]);
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void read(long long &x) {
char ch;
bool flag = false;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') flag = true;
for (x = 0; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
x = flag ? -x : x;
}
inline void write(long long x) {
static const long long maxlen = 100;
static char s[maxlen];
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
long long len = 0;
for (; x; x /= 10) s[len++] = x % 10 + '0';
for (long long i = len - 1; i >= 0; --i) putchar(s[i]);
}
long long n;
long long a[4001000], cnt;
char s[4001000];
long long ans = 1;
priority_queue<long long, vector<long long>, less<long long> > L;
priority_queue<long long, vector<long long>, greater<long long> > R;
const long long P = 1e9 + 7;
void ADD(long long x) {
for (long long i = 1; i <= cnt; i++) {
if (a[i] < x) {
L.push(a[i]);
} else if (a[i] > x) {
R.push(a[i]);
}
}
cnt = 0;
}
void doit(long long x) {
if (L.size()) {
if (x < L.top()) {
ans = 0;
return;
}
if (x == L.top()) {
L.pop();
ADD(x);
return;
}
}
if (R.size()) {
if (x > R.top()) {
ans = 0;
return;
}
if (x == R.top()) {
R.pop();
ADD(x);
return;
}
}
ans = (ans * 2ll) % P;
ADD(x);
}
int main() {
scanf("%I64d", &n);
ans = 1;
for (long long i = 1; i <= n; i++) {
scanf("%s", s);
long long x;
scanf("%I64d", &x);
if (s[1] == 'D')
a[++cnt] = x;
else
doit(x);
}
long long tmp = 0;
long long L_MAX = -1e9;
long long R_MIN = 1e9;
if (L.size()) L_MAX = max(L_MAX, (long long)L.top());
if (R.size()) R_MIN = min(R_MIN, (long long)R.top());
for (int i = 1; i <= cnt; i++)
if ((a[i] > L_MAX) && (a[i] < R_MIN)) tmp++;
ans = 1ll * ans * (tmp + 1ll) % P;
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename... As>
struct tpl : public std::tuple<As...> {
using std::tuple<As...>::tuple;
tpl() {}
tpl(std::tuple<As...> const& b) { std::tuple<As...>::operator=(b); }
template <typename T = tuple<As...>>
typename tuple_element<0, T>::type const& x() const {
return get<0>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<0, T>::type& x() {
return get<0>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<1, T>::type const& y() const {
return get<1>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<1, T>::type& y() {
return get<1>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<2, T>::type const& z() const {
return get<2>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<2, T>::type& z() {
return get<2>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<3, T>::type const& w() const {
return get<3>(*this);
}
template <typename T = tuple<As...>>
typename tuple_element<3, T>::type& w() {
return get<3>(*this);
}
};
using lli = long long int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using max_queue = priority_queue<T>;
template <size_t... I>
struct my_index_sequence {
using type = my_index_sequence;
static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J>
struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...>>
: my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
: concat<typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>::type {};
template <>
struct make_index_sequence<0> : my_index_sequence<> {};
template <>
struct make_index_sequence<1> : my_index_sequence<0> {};
} // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream& s, T const& a, my_index_sequence<I...>) {
using swallow = int[];
(void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T>
ostream& print_collection(ostream& s, T const& a);
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a);
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a);
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a);
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, multiset<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
namespace std {
namespace {
template <class T>
inline void hash_combine(size_t& seed, T const& v) {
seed ^= hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class Tuple, size_t Index = tuple_size<Tuple>::value - 1>
struct HashValueImpl {
static void apply(size_t& seed, Tuple const& tuple) {
HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
hash_combine(seed, get<Index>(tuple));
}
};
template <class Tuple>
struct HashValueImpl<Tuple, 0> {
static void apply(size_t& seed, Tuple const& tuple) {
hash_combine(seed, get<0>(tuple));
}
};
} // namespace
template <typename... TT>
struct hash<tuple<TT...>> {
size_t operator()(tuple<TT...> const& tt) const {
size_t seed = 0;
HashValueImpl<tuple<TT...>>::apply(seed, tt);
return seed;
}
};
template <typename... TT>
struct hash<tpl<TT...>> {
size_t operator()(tpl<TT...> const& tt) const {
size_t seed = 0;
HashValueImpl<tuple<TT...>>::apply(seed, tt);
return seed;
}
};
} // namespace std
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
lli n;
cin >> n;
vi A(n);
for (lli i = 0; i < (lli)(n); ++i) cin >> A[i];
vi S(n + 1);
for (lli i = 0; i < (lli)(n); ++i) S[i + 1] = S[i] + A[i];
vi L(n + 1), R(n + 1);
vi LI(n + 1), RI(n + 1);
{
pii cb = make_tuple(S[0], 0);
for (lli j = 0; j < (lli)(n + 1); ++j) {
cb = max(cb, pii(2 * S[j] - S[0], j));
L[j] = cb.x() - S[j];
LI[j] = cb.y();
}
}
{
pii cb = make_tuple(S[n], n);
for (lli j = (n); j >= (lli)(0); --j) {
cb = max(cb, pii(2 * S[j] - S[n], j));
R[j] = cb.x() - S[j];
RI[j] = cb.y();
}
}
pii ans = make_tuple(L[0] + R[0], 0);
for (lli i = 0; i < (lli)(n + 1); ++i) ans = max(ans, pii(L[i] + R[i], i));
cout << LI[ans.y()] << " " << ans.y() << " " << RI[ans.y()] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
struct graph {
vector<vector<int> > adj;
vector<int> val;
vector<bool> visited;
vector<int> us;
vector<int> vs;
vector<int> ws;
graph(int n) : adj(n), val(n) {}
void add_edge(int u, int v, int w) {
adj[u].push_back((int)visited.size());
adj[v].push_back((int)visited.size());
us.push_back(u);
vs.push_back(v);
ws.push_back(w);
visited.push_back(0);
}
long long ans = 0;
void getans(int u, long long curans = 0) {
long long temp = val[u];
val[u] = 0;
curans += temp;
ans = max(ans, curans);
for (auto i : adj[u]) {
if (!visited[i]) {
visited[i] = 1;
getans(us[i] ^ vs[i] ^ u, curans + ws[i]);
visited[i] = 0;
}
}
val[u] = temp;
}
};
vector<int> edges[4][4];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int u, v, w;
cin >> u >> w >> v;
u--;
v--;
if (u > v) swap(u, v);
edges[u][v].push_back(w);
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++)
sort((edges[i][j]).begin(), (edges[i][j]).end());
}
long long ans = 0;
for (int s = 0; s < 4; s++) {
graph g(4);
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (i == j) {
g.val[i] =
accumulate((edges[i][j]).begin(), (edges[i][j]).end(), 0LL);
} else {
if (edges[i][j].empty()) continue;
if ((int)edges[i][j].size() == 1)
g.add_edge(i, j, edges[i][j][0]);
else if ((int)edges[i][j].size() % 2 == 0) {
g.add_edge(
i, j,
accumulate((edges[i][j]).begin(), (edges[i][j]).end(), 0LL) -
edges[i][j][0]);
g.add_edge(i, j, edges[i][j][0]);
} else {
g.add_edge(
i, j,
accumulate((edges[i][j]).begin(), (edges[i][j]).end(), 0LL));
g.add_edge(i, j, -edges[i][j][0]);
}
}
}
}
g.getans(s);
ans = max(ans, g.ans);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("tune=native")
using namespace std;
const int DEBUG = 0;
mt19937 gen(
(unsigned)chrono::high_resolution_clock::now().time_since_epoch().count());
#pragma comment(linker, "/STACK:67108864")
int dp[1001][52][52];
string big, s, t;
int posa[52][26];
int posb[52][26];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.setf(cout.fixed);
cout.precision(10);
cin >> big >> s >> t;
for (int i = 0; i <= s.size(); i++) {
for (int j = 0; j < 26; j++) {
string temp = s.substr(0, i);
temp += char(j + 'a');
for (int len = 1; len <= temp.size(); len++)
if (temp.substr(temp.size() - len, len) == s.substr(0, len))
posa[i][j] = len;
}
}
for (int i = 0; i <= t.size(); i++) {
for (int j = 0; j < 26; j++) {
string temp = t.substr(0, i);
temp += char(j + 'a');
for (int len = 1; len <= temp.size(); len++)
if (temp.substr(temp.size() - len, len) == t.substr(0, len))
posb[i][j] = len;
}
}
s = "#" + s;
t = "#" + t;
big = "#" + big;
for (int i = 0; i < big.size(); i++)
for (int j = 0; j < s.size(); j++)
for (int k = 0; k < t.size(); k++) dp[i][j][k] = -1000000000;
dp[0][0][0] = 0;
for (int len = 1; len < big.size(); len++)
for (int pa = 0; pa < s.size(); pa++)
for (int pb = 0; pb < t.size(); pb++)
for (int c = 0; c < 26; c++) {
if (big[len] != '*' && c + 'a' != big[len]) continue;
int add = 0;
if (posa[pa][c] == s.size() - 1) add++;
if (posb[pb][c] == t.size() - 1) add--;
dp[len][posa[pa][c]][posb[pb][c]] =
max(dp[len][posa[pa][c]][posb[pb][c]], dp[len - 1][pa][pb] + add);
}
int res = -1000000000;
for (int i = 0; i < s.size(); i++)
for (int j = 0; j < t.size(); j++) res = max(res, dp[big.size() - 1][i][j]);
cout << res;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > transpose(const vector<vector<long long> >& a) {
int n = (int)a.size();
int m = (int)a[0].size();
vector<vector<long long> > b(m, vector<long long>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
b[j][i] = a[i][j];
}
}
return move(b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<long long> > a(n, vector<long long>(m));
vector<long long> rs(n, 0), cs(m, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
rs[i] += a[i][j];
cs[j] += a[i][j];
}
}
long long ans = 0;
{
priority_queue<long long> pq;
for (int i = 0; i < n; i++) {
pq.push(rs[i]);
}
for (int i = 0; i < 4 && !pq.empty(); i++) {
ans += pq.top();
pq.pop();
}
}
{
priority_queue<long long> pq;
for (int j = 0; j < m; j++) {
pq.push(cs[j]);
}
long long tmp = 0;
for (int i = 0; i < 4 && !pq.empty(); i++) {
tmp += pq.top();
pq.pop();
}
ans = max(ans, tmp);
}
{
for (int i = 0; i < n; i++) {
priority_queue<long long> pq;
long long tmp = rs[i];
for (int j = 0; j < m; j++) {
pq.push(cs[j] - a[i][j]);
}
for (int j = 0; j < 3 && !pq.empty(); j++) {
tmp += pq.top();
pq.pop();
}
ans = max(ans, tmp);
}
for (int j = 0; j < m; j++) {
priority_queue<long long> pq;
long long tmp = cs[j];
for (int i = 0; i < n; i++) {
pq.push(rs[i] - a[i][j]);
}
for (int i = 0; i < 3 && !pq.empty(); i++) {
tmp += pq.top();
pq.pop();
}
ans = max(ans, tmp);
}
}
{
if (n > m) {
swap(n, m);
a = transpose(a);
rs.assign(n, 0);
cs.assign(m, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
rs[i] += a[i][j];
cs[j] += a[i][j];
}
}
}
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
priority_queue<long long> pq;
long long tmp = rs[i] + rs[j];
for (int k = 0; k < m; k++) {
pq.push(cs[k] - a[i][k] - a[j][k]);
}
for (int k = 0; k < 2 && !pq.empty(); k++) {
tmp += pq.top();
pq.pop();
}
ans = max(ans, tmp);
}
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class heap : public priority_queue<T, vector<T>, greater<T> > {};
long long powm(long long a, int e) {
long long ans = 1;
while (e) {
if (e & 1) ans *= a;
a *= a;
e >>= 1;
}
return ans;
}
int main(void) {
long long n;
scanf("%lld", &n);
long long ans = 2 * 4 * 3 * powm(4, n - 3);
if (n > 3) ans += (n - 3) * 4 * 3 * 3 * powm(4, n - 4);
printf("%lld\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
vector<pair<pair<int, int>, int> > son[N];
vector<int> bcc_node[N], bcc_edge[N], ans;
stack<pair<pair<int, int>, int> > s;
vector<int> node;
int bcc_cnt, belong[N], is_cnt[N], now_time, tin[N], low[N];
void dfs(int o, int fa) {
tin[o] = low[o] = ++now_time;
int ch = 0;
for (int i = 0; i < son[o].size(); ++i) {
int v = son[o][i].first.first;
if (v == fa) continue;
pair<pair<int, int>, int> edge = {{o, v}, son[o][i].second};
if (!tin[v]) {
s.push(edge);
dfs(v, o);
low[o] = min(low[o], low[v]);
if (low[v] >= tin[o]) {
ch++;
is_cnt[o] = true;
bcc_node[++bcc_cnt].clear();
bcc_edge[bcc_cnt].clear();
while (true) {
pair<pair<int, int>, int> now = s.top();
s.pop();
bcc_edge[bcc_cnt].push_back(now.second);
if (belong[now.first.first] != bcc_cnt) {
belong[now.first.first] = bcc_cnt;
bcc_node[bcc_cnt].push_back(now.first.first);
}
if (belong[now.first.second] != bcc_cnt) {
belong[now.first.second] = bcc_cnt;
bcc_node[bcc_cnt].push_back(now.first.second);
}
if (now.first.first == o && now.first.second == v) break;
}
}
} else if (tin[v] < tin[o]) {
s.push(edge);
low[o] = min(tin[v], low[o]);
}
}
if (!fa && ch == 1) is_cnt[o] = false;
}
int main() {
int n, m, u, v;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
son[u].push_back({{v, u}, i});
son[v].push_back({{u, v}, i});
}
for (int i = 1; i <= n; i++) dfs(i, i);
for (int i = 1; i <= bcc_cnt; i++)
if (bcc_node[i].size() == bcc_edge[i].size()) {
for (auto v : bcc_edge[i]) node.push_back(v);
}
cout << node.size() << endl;
sort(node.begin(), node.end());
for (int i = 0; i < node.size(); i++) cout << node[i] << ' ';
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 303030, P = 1e9 + 9;
int n, m;
int a[N], f[N], s[N], s2[N];
int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
int mul(int a, int b) { return 1ll * a * b % P; }
void init() {
f[1] = f[2] = 1;
for (int i = (3); i < (N); ++i) f[i] = add(f[i - 1], f[i - 2]);
for (int i = (1); i < (N); ++i)
s[i] = add(s[i - 1], f[i]), s2[i - 1] = sub(s[i], 1);
}
int sum[N << 2], la[3][N << 2];
void up(int rt) { sum[rt] = add(sum[rt << 1], sum[rt << 1 | 1]); }
void build(int l, int r, int rt) {
if (l == r) {
sum[rt] = a[l];
return;
}
int mid = l + r >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
up(rt);
}
void gao(int l, int r, int x, int y, int rt) {
la[1][rt] = add(la[1][rt], x);
la[2][rt] = add(la[2][rt], y);
sum[rt] = add(sum[rt], mul(x, s[r - l + 1]));
sum[rt] = add(sum[rt], mul(y, s2[r - l + 1]));
}
void down(int l, int r, int rt, int mid) {
gao(l, mid, la[1][rt], la[2][rt], rt << 1);
int t = mid - l;
int t1 = add(mul(la[1][rt], f[t]), mul(la[2][rt], f[t + 1]));
int t2 = add(mul(la[1][rt], f[t + 1]), mul(la[2][rt], f[t + 2]));
gao(mid + 1, r, t1, t2, rt << 1 | 1);
la[1][rt] = la[2][rt] = 0;
}
void upd(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
int o = l - L + 1;
if (o == 1) {
gao(l, r, 1, 0, rt);
} else if (o == 2) {
gao(l, r, 0, 1, rt);
} else {
gao(l, r, f[o - 2], f[o - 1], rt);
}
return;
}
int mid = l + r >> 1;
down(l, r, rt, mid);
if (L <= mid) upd(L, R, l, mid, rt << 1);
if (R > mid) upd(L, R, mid + 1, r, rt << 1 | 1);
up(rt);
}
int qry(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return sum[rt];
int mid = l + r >> 1, ans = 0;
down(l, r, rt, mid);
if (L <= mid) ans = add(ans, qry(L, R, l, mid, rt << 1));
if (R > mid) ans = add(ans, qry(L, R, mid + 1, r, rt << 1 | 1));
up(rt);
return ans;
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
cin >> n >> m;
for (int i = (1); i < (n + 1); ++i) cin >> a[i];
init();
build(1, n, 1);
while (m--) {
int o, l, r;
cin >> o >> l >> r;
if (o == 1) {
upd(l, r, 1, n, 1);
} else {
cout << qry(l, r, 1, n, 1) << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pr1(T a) {
cout << a;
cout << '\n';
}
template <class T, class T2>
void pr2(T a, T2 b) {
cout << a << ' ' << b;
cout << '\n';
}
template <class T, class T2, class T3>
void pr3(T a, T2 b, T3 c) {
cout << a << ' ' << b << ' ' << c;
cout << '\n';
}
template <class T>
void PR(T a, int n) {
for (int i = (int)(0); i < (int)(n); i++) {
if (i) cout << ' ';
cout << a[i];
}
cout << '\n';
}
bool check(int n, int m, int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m;
}
const long long MAX = 1000000007, MAXL = 1LL << 60, dx[4] = {-1, 0, 1, 0},
dy[4] = {0, 1, 0, -1};
void Main() {
double d, h, v, e;
cin >> d >> h >> v >> e;
double r = d / 2;
double t = v / (r * r * M_PI);
double ans = h / (t - e);
if (ans < 0)
pr1("NO");
else {
printf("YES\n");
printf("%.10f\n", ans);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Main();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[52][52][52][52], l[52][52], r[52][52], u[52][52], d[52][52], n;
char c;
bool ma[52][52];
int dfs(int x_1, int y_1, int x_2, int y_2) {
int ii = x_1, jj = y_1, ll = x_2, kk = y_2;
if (dp[x_1][y_1][x_2][y_2]) return dp[x_1][y_1][x_2][y_2];
while (r[x_1][y_1] > y_2 && x_1 <= x_2) x_1++;
if (x_1 > x_2) return dp[ii][jj][ll][kk] = 0;
while (d[x_1][y_1] > x_2 && y_1 <= y_2) y_1++;
if (y_1 > y_2) return dp[ii][jj][ll][kk] = 0;
while (l[x_2][y_2] < y_1 && x_2 >= x_1) x_2--;
if (x_1 > x_2) return dp[ii][jj][ll][kk] = 0;
while (u[x_2][y_2] < x_1 && y_2 >= y_1) y_2--;
if (y_1 > y_2) return dp[ii][jj][ll][kk] = 0;
int tmp = max(x_2 - x_1 + 1, y_2 - y_1 + 1);
for (int k = x_1; k < x_2; k++) {
tmp = min(tmp, dfs(x_1, y_1, k, y_2) + dfs(k + 1, y_1, x_2, y_2));
}
for (int k = y_1; k < y_2; k++) {
tmp = min(tmp, dfs(x_1, y_1, x_2, k) + dfs(x_1, k + 1, x_2, y_2));
}
return dp[ii][jj][ll][kk] = tmp;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) scanf(" %c", &c), ma[i][j] = (c == '#');
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) l[i][j] = (ma[i][j] ? j : l[i][j - 1]);
for (int j = n; j >= 1; j--) r[i][j] = (ma[i][j] ? j : r[i][j + 1]);
}
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= n; i++) u[i][j] = (ma[i][j] ? i : u[i - 1][j]);
for (int i = n; i >= 1; i--) d[i][j] = (ma[i][j] ? i : d[i + 1][j]);
}
printf("%d\n", dfs(1, 1, n, n));
}
| 7 |
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,abm,mmx,tune=native")
#include<vector>
#include<iostream>
#include<stack>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<string>
#include<tuple>
#include<bitset>
#include<queue>
#include<unordered_map>
#include<random>
#include<ctime>
//#include<complex>
#include<numeric>
typedef long long ll;
typedef long double ld;
typedef unsigned short us;
typedef unsigned long long ull;
//typedef complex<double> base;
using namespace std;
ll gcd(ll i, ll j) {
if (j == 0)return i;
else return gcd(j, i % j);
}
#ifdef _DEBUG
int __builtin_popcount(int x) { return x ? (__builtin_popcount(x >> 1) + (x & 1)) : 0; }
#endif
template<typename T> inline T getint() {
T val = 0;
char c;
bool neg = false;
while ((c = getchar()) && !(c >= '0' && c <= '9')) {
neg |= c == '-';
}
do {
val = (val * 10) + c - '0';
} while ((c = getchar()) && (c >= '0' && c <= '9'));
return val * (neg ? -1 : 1);
}
//#define int long long
const ll INF = 1e9 + 100;
const int mod = 1000000007;
const ld eps = 1e-6, pi = acosl(-1);
const ll maxN = 10010, maxT = 10010, A = 179, mid = 150;
mt19937 mt_rand(time(0));
ll bp(ll et, ll b) {
b %= mod - 1;
ll res = 1;
for (int i = 30; i >= 0; --i) {
res = (res * res) % mod;
if ((b & (1 << i)) != 0)res = (res * et) % mod;
}
return res;
}
void panic() {
cout << "-1\n";
exit(0);
}
int pl(const int& a, const int& b) {
int r = a + b;
if (r >= mod)r -= mod;
return r;
}
void solve() {
int n;
cin >> n;
vector<int>c(n), b(n - 1);
for (auto& x : c)
cin >> x;
for (auto& x : b)
cin >> x;
vector<vector<ll>>dp(n + 1, vector<ll>(maxN));
dp[0][0] = 1;
int q;
cin >> q;
ll x;
cin >> x;
ll d = 0, s = 0;
for (int i = 0; i < n; ++i) {
if (i) {
d += b[i - 1];
s += d;
}
ll vv = x * (i + 1) + s;
ll cc = c[i];
for (int j = maxN - cc - 1; j >= 0; --j) {
for (int k = j + cc; k >= j && k >= vv; --k) {
dp[i + 1][k] = pl(dp[i + 1][k], dp[i][j]);
}
}
}
ll ans = 0;
for (int i = 0; i < maxN; ++i)
ans = pl(ans, dp[n][i]);
cout << ans << "\n";
}
int32_t main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cout.precision(20);
//srand(time(0));
#ifdef _DEBUG
freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);
#else
//freopen("gymnasts.in", "r", stdin); freopen("gymnasts.out", "w", stdout);
#endif
int t = 1;
//cin >> t;
while (t--) {
solve();
}
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v[2100];
int bSearch(int ind, int val) {
int ret = -1;
int s = 0;
int e = v[ind].size() - 1;
while (s <= e) {
int m = (s + e) / 2;
if (v[ind][m] < val) {
ret = m;
s = m + 1;
} else {
e = m - 1;
}
}
return ret + 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int l;
scanf("%d", &l);
v[i].push_back(l);
}
sort(v[i].begin(), v[i].end());
}
v[n] = v[0];
v[n + 1] = v[1];
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < v[i].size(); j++) {
int a = v[i][j - 1];
int b = v[i][j];
if (bSearch(i - 1, b) - bSearch(i - 1, a) !=
bSearch(i + 1, b) - bSearch(i + 1, a))
ans++;
}
}
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
clock_t __stt;
inline void TStart() { __stt = clock(); }
inline void TReport() {
printf("\nTaken Time : %.3lf sec\n",
(double)(clock() - __stt) / CLOCKS_PER_SEC);
}
template <typename T>
T MIN(T a, T b) {
return a < b ? a : b;
}
template <typename T>
T MAX(T a, T b) {
return a > b ? a : b;
}
template <typename T>
T ABS(T a) {
return a > 0 ? a : (-a);
}
template <typename T>
void UMIN(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
void UMAX(T &a, T b) {
if (b > a) a = b;
}
const int MOD = 998244353;
int n, a[2005][2005], f[2005][2005], C[2005][2005], fac[2005], cr[2005], res;
bool got[2005], gotu[2005];
struct BIT {
int arr[2005];
void init() { memset(arr, 0, sizeof(arr)); }
void add(int p, int v) {
++p;
while (p <= n) {
arr[p] += v;
p += (p & (-p));
}
}
int sum(int p) {
++p;
int r = 0;
while (p) {
r += arr[p];
p -= (p & (-p));
}
return r;
}
} G[4];
int gs(int d) { return 2 * (int)gotu[d] + (int)got[d]; }
int main() {
int i, j, k, cdd;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
scanf("%d", &a[i][j]);
--a[i][j];
}
}
for (i = 0; i <= n; ++i) C[i][0] = 1;
for (i = 1; i <= n; ++i) {
for (j = 1; j <= n; ++j) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % (long long)MOD;
}
}
fac[0] = 1;
for (i = 1; i <= n; ++i) {
fac[i] = (long long)fac[i - 1] * (long long)i % (long long)MOD;
}
f[0][0] = 1;
for (i = 1; i <= n; ++i) {
f[i][0] = fac[i];
for (j = 1; j < i; ++j) {
f[i][j] = (long long)f[i - 1][j] * (long long)(i - j) % (long long)MOD;
f[i][j] += (long long)f[i - 1][j - 1] * (long long)j % (long long)MOD;
f[i][j] %= MOD;
}
if (i > 1)
f[i][i] =
(long long)f[i - 1][i - 2] * (long long)(i - 1) % (long long)MOD;
}
for (i = 0; i < n; ++i) {
int dw = 1;
for (j = i + 1; j < n; ++j) {
dw = (long long)dw * (long long)f[n][n] % (long long)MOD;
}
memset(got, 0, sizeof(got));
if (i)
for (j = n - 1; j >= 0; --j) {
cr[j] = 0;
if (got[a[i - 1][j]]) ++cr[j];
if (got[a[i][j]]) ++cr[j];
got[a[i][j]] = 1;
got[a[i - 1][j]] = 1;
if (j < n - 1) cr[j] += cr[j + 1];
}
memset(got, 0, sizeof(got));
memset(gotu, 0, sizeof(gotu));
for (j = 0; j < 4; ++j) {
G[j].init();
}
for (j = 0; j < n; ++j) G[0].add(j, 1);
for (j = 0; j < n - 1; ++j) {
if (i) {
G[gs(a[i - 1][j])].add(a[i - 1][j], -1);
gotu[a[i - 1][j]] = 1;
G[gs(a[i - 1][j])].add(a[i - 1][j], 1);
}
if (i) {
cdd = G[0].sum(a[i][j] - 1);
int crs = cr[j + 1] + (int)(!gotu[a[i][j]]) - 1;
res += (long long)cdd * (long long)dw % (long long)MOD *
(long long)f[n - j - 1][crs] % (long long)MOD;
res %= MOD;
cdd = G[2].sum(a[i][j] - 1);
if (a[i - 1][j] < a[i][j] && !got[a[i - 1][j]]) --cdd;
crs = cr[j + 1] + (int)(!gotu[a[i][j]]);
res += (long long)cdd * (long long)dw % (long long)MOD *
(long long)f[n - j - 1][crs] % (long long)MOD;
} else {
res += (long long)G[0].sum(a[i][j] - 1) * (long long)fac[n - j - 1] %
(long long)MOD * (long long)dw % (long long)MOD;
}
res %= MOD;
{
G[gs(a[i][j])].add(a[i][j], -1);
got[a[i][j]] = 1;
G[gs(a[i][j])].add(a[i][j], 1);
}
}
}
printf("%d\n", res);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool i1, i2, i3, i4;
cin >> i1 >> i2 >> i3 >> i4;
cout << int(((i1 ^ i2) & (i3 | i4)) ^ ((i2 & i3) | (i1 ^ i4)));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string data[30];
bool able(int x, int y, int hang, int lie) {
for (int i = 0; i < hang; ++i)
for (int j = 0; j < lie; ++j)
if (data[i + x][j + y] == '1') return false;
return true;
}
int main() {
int hang;
int lie;
cin >> hang;
cin >> lie;
for (int i = 0; i < hang; ++i) cin >> data[i];
int res = -1;
for (int i = 0; i < hang; ++i)
for (int j = 0; j < lie; ++j)
for (int k = 1; k <= hang - i; ++k)
for (int l = 1; l <= lie - j; ++l)
if (able(i, j, k, l)) res = max(res, (k + l) << 1);
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(char c) {
string s(1, c);
return "'" + s + "'";
}
template <class T>
string to_string(vector<T> v) {
string s = "{";
bool first = true;
for (T x : v) {
if (!first) s += ", ";
s += to_string(x);
first = false;
}
s += "}";
return s;
}
template <class T>
string to_string(set<T> v) {
string s = "{";
bool first = true;
for (T x : v) {
if (!first) s += ", ";
s += to_string(x);
first = false;
}
s += "}";
return s;
}
template <class T>
string to_string(unordered_set<T> v) {
string s = "{";
bool first = true;
for (T x : v) {
if (!first) s += ", ";
s += to_string(x);
first = false;
}
s += "}";
return s;
}
template <class T>
string to_string(multiset<T> v) {
string s = "{";
bool first = true;
for (T x : v) {
if (!first) s += ", ";
s += to_string(x);
first = false;
}
s += "}";
return s;
}
template <class T1, class T2>
string to_string(pair<T1, T2> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <class T1, class T2>
string to_string(unordered_map<T1, T2> m) {
string s = "{";
bool first = true;
for (auto x : m) {
if (!first) s += ", ";
s += "(" + to_string(x.first) + " -> " + to_string(x.second) + ")";
first = false;
}
s += "}";
return s;
}
template <class T1, class T2>
string to_string(map<T1, T2> m) {
string s = "{";
bool first = true;
for (auto x : m) {
if (!first) s += ", ";
s += "(" + to_string(x.first) + " -> " + to_string(x.second) + ")";
first = false;
}
s += "}";
return s;
}
int m, n;
bool can_joy(vector<vector<int>> p, ll joy) {
bool flag1 = false;
for (int i = 0; i < m; i++) {
int found = 0;
for (int j = 0; j < n; j++) {
found += p[i][j] >= joy;
}
if (found >= 2) {
flag1 = true;
break;
}
}
if (!flag1) return false;
bool flag2;
for (int j = 0; j < n; j++) {
flag2 = false;
for (int i = 0; i < m; i++) {
flag2 |= p[i][j] >= joy;
}
if (!flag2) return false;
}
return true;
}
void solve() {
cin >> m >> n;
vector<vector<int>> p(m, vector<int>(n));
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> p[i][j];
}
}
ll l = 1, r = 1e14, mid;
while (l < r) {
;
;
mid = l + (r - l + 1) / 2;
bool b = can_joy(p, mid);
if (b)
l = mid;
else
r = mid - 1;
}
assert(l == r);
cout << l << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, T;
vector<pair<int, int> > ans;
set<pair<int, int> > s;
vector<int> ady[200005];
void solve(int x, int t, int p) {
ans.push_back({x, t});
int in = t;
int sons = ady[x].size() - (p != 0);
for (auto v : ady[x]) {
if (v == p) continue;
if (in == T) {
in = t - sons - 1;
ans.push_back({x, in});
}
in++;
solve(v, in, x);
ans.push_back({x, in});
sons--;
}
if (in > t - 1 && x != 1) {
in = t - 1;
ans.push_back({x, in});
}
return;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> N;
for (int i = 1; i < N; i++) {
int u, v;
cin >> u >> v;
ady[u].push_back(v);
ady[v].push_back(u);
}
for (int i = 1; i <= N; i++) T = max(T, (int)ady[i].size());
solve(1, 0, 0);
for (auto v : ans) s.insert(v);
if (s.size() != ans.size()) {
cout << "RIP\n";
}
cout << ans.size() << "\n";
for (auto v : ans) cout << v.first << " " << v.second << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void open() { freopen("data.txt", "r", stdin); }
void out() { freopen("out.txt", "w", stdout); }
const int maxn = 301010;
const int MOD = 1e9 + 7;
int dp[maxn];
int arr[maxn], sum[maxn];
int n, k;
bool check(int x) {
memset(dp, 0, sizeof(dp));
memset(sum, 0, sizeof(sum));
dp[0] = 1;
sum[0] = 1;
int j;
for (int i = 1; i < (n + 1); ++i) {
if (i < k) {
dp[i] = 0;
sum[i] = sum[i - 1];
continue;
}
j = lower_bound(arr, arr + n + 1, arr[i] - x) - arr;
if (j > i - k + 1)
dp[i] = 0;
else if (j <= 1)
dp[i] = 1;
else if (sum[i - k] > sum[j - 2])
dp[i] = 1;
sum[i] = sum[i - 1] + dp[i];
}
return dp[n];
}
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = 1; i < (n + 1); ++i) scanf("%d", &arr[i]);
sort(arr + 1, arr + 1 + n);
int l = 0, r = arr[n] - arr[1] + 10, ans;
while (l <= r) {
int m = (l + r) >> 1;
if (check(m)) {
ans = m;
r = m - 1;
} else
l = m + 1;
}
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, l;
long double x = 0.0;
cin >> n >> l;
int a[n];
for (int i = 0; i < n; i++) {
int b;
cin >> b;
a[i] = b;
}
sort(a, a + n);
for (int i = 0; i < n - 1; i++) {
long double d = 0;
if (a[i] < a[i + 1]) d = ((a[i + 1] - a[i]) / 2.0);
if (x < d) x = d;
}
if ((l - a[n - 1]) > x) x = (l - a[n - 1]);
if (a[0] > x) x = a[0];
cout << fixed << setprecision(10) << x;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long cl(long double a) {
if (a > (long long)a) {
return (long long)a + 1;
} else {
return (long long)a;
}
}
long long flr(long double a) {
if (a < 0.0) {
return (long long)a - 1;
}
return (long long)a;
}
long long n, m;
const long long M = 1e5 + 100;
vector<pair<long long, long long> > a;
long long comp(long long num) {
long long s = 0, e = m - 1;
long long ans = -1;
while (s <= e) {
long long mid = (s + e) / 2;
if (a[mid].first >= num) {
ans = mid;
e = mid - 1;
} else {
s = mid + 1;
}
}
return ans;
}
void solve() {
cin >> n;
cin >> m;
a.clear();
a.resize(m);
for (long long i = 0; i < m; i++) {
cin >> a[i].first;
cin >> a[i].second;
}
sort(a.begin(), a.end());
long long pre[m];
pre[m - 1] = a[m - 1].first;
for (long long i = m - 2; i >= 0; i--) {
pre[i] = pre[i + 1] + a[i].first;
}
long long ans = 0;
for (long long i = 0; i < m; i++) {
long long cur = a[i].first;
long long j = comp(a[i].second);
long long ext = 0, op = 0;
long long r = n - 1;
if (r == 0) {
ans = max(ans, cur);
continue;
}
if (j != -1 && j <= i) {
cur = 0;
r++;
}
if (j == -1) {
cur += r * a[i].second;
ans = max(ans, cur);
} else if (m - j >= r) {
cur += pre[m - r];
ans = max(ans, cur);
} else {
long long rem = r - (m - j);
cur += pre[j] + rem * a[i].second;
ans = max(ans, cur);
}
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
cin >> t;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int main() {
cin >> n >> m;
if (n == 1 || m == 1)
ans = n * m;
else if (n == 2) {
ans = ((m / 4)) * 4;
m = m % 4;
if (m > 2) m = 2;
ans += m * 2;
} else if (m == 2) {
ans = ((n / 4)) * 4;
n = n % 4;
if (n > 2) n = 2;
ans += n * 2;
} else {
ans = (n * m) / 2 + (n * m) % 2;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double pi = 2 * acos(0.0);
const long long MX = 2e5 + 7;
long long a[MX], b[MX];
vector<long long> v[MX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
long long t;
cin >> t;
while (t--) {
ll n;
cin >> n;
string s, m, z;
cin >> s;
ll p = n + 1, q = -2;
ll count = 0;
for (ll i = 0; i < n; i++) {
if (s[i] == '0') {
m.push_back(s[i]);
} else {
p = i;
break;
}
}
for (ll i = n - 1; i >= p; i--) {
if (s[i] == '1') {
z.push_back(s[i]);
} else {
q = i;
break;
}
}
for (ll i = p; i <= q; i++) {
if (s[i] == '0') {
m.push_back(s[i]);
break;
}
}
cout << m + z << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[3];
int dp[301][301];
int dfs(int a, int b) {
if (dp[a][b] != 0) return dp[a][b] - 1;
int res = 1;
for (int i = 1; i <= a; i++) res = min(res, dfs(a - i, b));
for (int i = 1; i <= b; i++) res = min(res, dfs(a, b - i));
for (int i = 1; i <= min(a, b); i++) res = min(res, dfs(a - i, b - i));
res = 1 - res;
dp[a][b] = res + 1;
return res;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int f = 0;
if (n == 1) f = a[0];
if (n == 2) f = dfs(a[0], a[1]);
if (n == 3) f = a[0] ^ a[1] ^ a[2];
printf(f ? "BitLGM" : "BitAryo");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void Solve() {
int n, k;
cin >> n >> k;
int l1, r1, l2, r2;
cin >> l1 >> r1 >> l2 >> r2;
if (l1 > l2) {
swap(l1, l2);
swap(r1, r2);
}
vector<int> need(2, 0);
long long exist_is = 0;
int is = 0;
if (l2 >= r1) {
need[0] = l2 - r1;
need[1] = r2 - l1;
} else {
need[0] = 0;
need[1] = abs(l2 - l1) + abs(r2 - r1);
exist_is = min(r1, r2) - max(l1, l2);
}
exist_is = exist_is * 1LL * n;
if (exist_is >= k) {
printf("0\n");
return;
}
int left = k - (int)exist_is;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (left == 0) {
break;
}
long long this_step = need[0];
int cut = min(need[1], left);
this_step += cut;
if (i >= 1) {
if (cut * 2LL < this_step) {
break;
}
}
ans += this_step;
left -= cut;
}
if (left > 0) {
ans += (left * 2LL);
}
printf("%lld\n", ans);
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
Solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, M, sz, h;
int a[200001];
int b[200001];
int c[200001];
int main() {
cin >> N;
for (int j = 0; j < N; j++) {
cin >> M;
for (int i = 1; i <= M; i++) {
cin >> c[i];
}
sz = 1;
for (int i = 1; i <= M; i++) {
if ((a[i] == 0) && (a[c[i]] == 0)) {
a[i] = sz;
b[a[i]]++;
h = i;
while (a[c[h]] != sz) {
a[c[h]] = sz;
h = c[c[h]];
b[a[i]]++;
}
sz++;
} else {
if (a[c[i]] == 0) {
a[c[i]] = a[i];
b[a[i]]++;
}
if (a[i] == 0) {
a[i] = a[c[i]];
b[a[c[i]]]++;
}
}
}
for (int i = 1; i <= M; i++) {
cout << b[a[i]] << " ";
}
cout << '\n';
for (int i = 1; i <= M; i++) {
a[i] = 0;
b[i] = 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void printReverse(int u, vector<int> &tr) {
if (u == -1) {
return;
}
printReverse(tr[u] - 1, tr);
cout << u + 1 << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(n), tr(n);
pair<int, int> mx = {0, 0};
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
map<int, pair<int, int> > f;
for (int i = 0; i < n; ++i) {
if (!f.count(a[i] - 1)) {
if (!f.count(a[i])) {
f[a[i]] = {1, i};
}
} else if (!f.count(a[i]) || f[a[i]].first < f[a[i] - 1].first + 1) {
f[a[i]] = {f[a[i] - 1].first + 1, i};
tr[i] = f[a[i] - 1].second + 1;
}
if (mx.first < f[a[i]].first) {
mx = {f[a[i]].first, i};
}
}
cout << mx.first << '\n';
printReverse(mx.second, tr);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
long long x = 0;
int n = 1;
char c = getchar();
while (!isdigit(c)) {
n = (c == '-') ? -1 : 1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * n;
}
const int MIF = 1e9 + 7;
const int N = 1000006, L = 100005, MOD = MIF;
int n, l, M;
int a[N], b[N], c[N];
long long res;
struct matrix {
long long m[105][105];
matrix operator*(matrix b) {
matrix c;
for (int i = 0; i <= M - 1; i++)
for (int j = 0; j <= M - 1; j++) {
c.m[i][j] = 0;
for (int t = 0; t <= M - 1; t++)
c.m[i][j] = (c.m[i][j] + m[i][t] * b.m[t][j]) % MOD;
}
return c;
}
matrix operator^(long long x) {
matrix res = *this, mul = *this;
x--;
for (; x > 0; x >>= 1, mul = mul * mul)
if (x & 1) res = res * mul;
return res;
}
};
matrix BASE, f0;
int main() {
n = in(), l = in(), M = in();
for (int i = 1; i <= n; i++) a[i] = in();
for (int i = 1; i <= n; i++) b[i] = in();
for (int i = 1; i <= n; i++) c[i] = in();
for (int mm = 0; mm <= M - 1; mm++)
for (int i = 1; i <= n; i++) BASE.m[(mm + b[i]) % M][mm]++;
for (int i = 1; i <= n; i++) f0.m[a[i] % M][0]++;
if (l > 2) {
BASE = BASE ^ (l - 2);
f0 = BASE * f0;
}
for (int i = 1; i <= n; i++)
res = (res + f0.m[(M * M - b[i] - c[i]) % M][0]) % MOD;
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10;
const int mod = 1e9 + 7;
int isprime[maxn];
int main() {
int n;
cin >> n;
int a, b;
a = b = 0;
for (int i = 0; i < n; i++) {
int g;
cin >> g;
if (g == 1)
a++;
else
b++;
}
if (a == 0) {
for (int i = 0; i < b; i++) {
cout << 2 << " ";
}
} else if (b == 0) {
for (int i = 0; i < a; i++) {
cout << 1 << " ";
}
} else {
cout << "2 1 ";
for (int i = 0; i < b - 1; i++) {
cout << 2 << " ";
}
for (int i = 0; i < a - 1; i++) {
cout << 1 << " ";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
long long int p[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios::sync_with_stdio(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
sort(p, p + n);
long long int l = 0, r = n - 1;
long long int ans = 0;
while (l < r) {
long long int dif = abs(p[r] - p[l]);
ans += 2 * dif;
l += m;
r -= m;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
long long dif[300005], v[300005];
long long ans = 0;
long long tbl[300005][20][3];
void rec(int l, int r) {
if (r - l < 1) {
return;
}
int k = 31 - __builtin_clz(r - l);
int idx = (dif[tbl[l][k][0]] > dif[tbl[r - 1 - (1 << k) + 1][k][0]]
? tbl[l][k][0]
: tbl[r - 1 - (1 << k) + 1][k][0]);
k = 31 - __builtin_clz(r - idx);
long long rht = max(tbl[idx][k][1], tbl[r - (1 << k) + 1][k][1]);
k = 31 - __builtin_clz(idx - 1 - l + 1);
long long lft = min(tbl[l - 1][k][2], tbl[idx - 1 - (1 << k) + 1][k][2]);
ans = max(ans, rht - lft - dif[idx]);
rec(l, idx);
rec(idx + 1, r);
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> dif[i] >> v[i];
v[i] -= K;
v[i] *= -1;
ans = max(ans, v[i]);
v[i] += v[i - 1];
tbl[i][0][0] = i;
tbl[i][0][1] = tbl[i][0][2] = v[i];
}
for (int i = 1; i <= N; i++) {
dif[i] = (dif[i + 1] - dif[i]) * (dif[i + 1] - dif[i]);
}
for (int d = 1; d < 20; d++) {
for (int i = 1; i < N - (1 << d) + 1; i++) {
tbl[i][d][0] =
dif[tbl[i][d - 1][0]] > dif[tbl[i + (1 << (d - 1))][d - 1][0]]
? tbl[i][d - 1][0]
: tbl[i + (1 << (d - 1))][d - 1][0];
}
for (int i = 0; i <= N - (1 << d) + 1; i++) {
tbl[i][d][1] = max(tbl[i][d - 1][1], tbl[i + (1 << (d - 1))][d - 1][1]);
tbl[i][d][2] = min(tbl[i][d - 1][2], tbl[i + (1 << (d - 1))][d - 1][2]);
}
}
rec(1, N);
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, i = 0;
cin >> a >> b;
while (a <= b) {
a = a * 3;
b = b * 2;
i = i + 1;
}
cout << i;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 300;
const int C = 1001;
const int Q = 2000001;
struct Event {
int t, x, y;
};
struct DSU {
int find(int u) {
if (parent[u] != u) {
parent[u] = find(parent[u]);
}
return parent[u];
}
void add(int u) { size++, parent[u] = u; }
void merge(int a, int b) {
if (find(a) != find(b)) {
size--, parent[find(a)] = find(b);
}
}
int size, parent[N * N];
} dsu;
int n, m, q, color[N][N], now, timestamp[N][N], result[Q];
std::set<int> cs;
std::map<int, std::vector<Event>> enters, leaves;
int id(int x, int y) { return x * m + y; }
void add(int x, int y) {
static int DELTA_X[] = {-1, 0, 0, 1};
static int DELTA_Y[] = {0, -1, 1, 0};
timestamp[x][y] = now;
dsu.add(id(x, y));
for (int k = 0; k < 4; ++k) {
int xx = x + DELTA_X[k];
int yy = y + DELTA_Y[k];
if (0 <= xx && xx < n && 0 <= yy && yy < m && timestamp[xx][yy] == now) {
dsu.merge(id(x, y), id(xx, yy));
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
cs.insert(0);
for (int i = 0, x, y, c; i < q; ++i) {
scanf("%d%d%d", &x, &y, &c);
x--, y--;
if (color[x][y] != c) {
cs.insert(c);
enters[c].push_back(Event{i, x, y});
leaves[color[x][y]].push_back(Event{i, x, y});
color[x][y] = c;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
leaves[color[i][j]].push_back(Event{q, i, j});
}
}
now = 0;
for (int c : cs) {
now++, dsu.size = 0;
int pre_size_fwd = 0;
for (int i = 0; i + 1 < static_cast<int>(enters[c].size()); ++i) {
auto e = enters[c][i];
add(e.x, e.y);
result[e.t] += dsu.size - pre_size_fwd;
pre_size_fwd = dsu.size;
}
if (!leaves[c].empty()) {
now++, dsu.size = 0;
int pre_size_bwd = 0;
for (int i = leaves[c].size(); i--;) {
auto e = leaves[c][i];
add(e.x, e.y);
result[e.t] += pre_size_bwd - dsu.size;
pre_size_bwd = dsu.size;
}
result[c ? enters[c].back().t : 0] += pre_size_bwd - pre_size_fwd;
}
}
for (int i = 0, sum = 0; i < q; ++i) {
sum += result[i];
printf("%d\n", sum);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
const int dx[] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy[] = {1, 0, -1, 1, -1, 1, 0, -1};
int n, m;
char a[maxn][maxn];
int use[maxn][maxn];
int t = 0;
int ans = 0, cur;
int stx[maxn * maxn];
int sty[maxn * maxn];
bool good;
int kol;
void dfs(int i, int j) {
use[i][j] = t;
int x, y;
for (int z = (0); z < ((8)); ++z) {
x = i + dx[z], y = j + dy[z];
if (a[x][y] == '1') {
if (use[x][y] < t) {
use[x][y] = t;
stx[cur] = x, sty[cur] = y;
cur++;
}
continue;
}
if (a[x][y] == '0') {
if (use[x][y] == 0) dfs(x, y);
continue;
}
good = 0;
}
}
void dfs2(int i, int j) {
use[i][j] = t;
if (a[i + 1][j] == '1' && (use[i + 1][j] == t - 1)) dfs2(i + 1, j);
if (a[i - 1][j] == '1' && (use[i - 1][j] == t - 1)) dfs2(i - 1, j);
if (a[i][j + 1] == '1' && (use[i][j + 1] == t - 1)) dfs2(i, j + 1);
if (a[i][j - 1] == '1' && (use[i][j - 1] == t - 1)) dfs2(i, j - 1);
}
int main() {
memset(a, '#', sizeof(a));
memset(use, 0, sizeof(use));
scanf("%d%d ", &n, &m);
for (int i = (1); i < (n + 1); ++i)
for (int j = (1); j < (m + 1); ++j) scanf("%c ", &a[i][j]);
for (int i = (1); i < (n); ++i)
for (int j = (1); j < (m); ++j)
if (a[i][j] == '1' && a[i + 1][j] == '1' && a[i][j + 1] == '1' &&
a[i + 1][j + 1] == '1')
ans = 4;
for (int i = (1); i < (n + 1); ++i)
for (int j = (1); j < (m + 1); ++j)
if (a[i][j] == '0' && use[i][j] == 0) {
good = 1;
cur = 0;
t++;
dfs(i, j);
if ((!good) || ans >= cur) continue;
t++;
dfs2(stx[0], sty[0]);
for (int q = (0); q < ((cur)); ++q) {
if (use[stx[q]][sty[q]] < t) {
good = 0;
break;
}
kol = 0;
if (use[stx[q] + 1][sty[q]] == t) kol++;
if (use[stx[q] - 1][sty[q]] == t) kol++;
if (use[stx[q]][sty[q] + 1] == t) kol++;
if (use[stx[q]][sty[q] - 1] == t) kol++;
if (kol != 2) {
good = 0;
break;
}
}
if (good) ans = cur;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define eb emplace_back
#define ll long long
#define pll pair<ll,ll>
#define ff first
#define ss second
#define endl "\n"
const ll maxn=5e2+10;
const ll mod =1e9+7 ;
const ll base=500;
ll x[maxn];
ll y[maxn];
ll get2(ll x,ll y,ll x1,ll y1)
{
return abs(x-x1)+abs(y-y1);
}
ll get1(ll x,ll y,ll x1,ll y1,ll x2,ll y2,ll x3,ll y3)
{
return min(get2(x,y,x2,y2)+get2(x1,y1,x3,y3),get2(x1,y1,x2,y2)+get2(x,y,x3,y3));
}
ll get(ll x,ll y,ll x1,ll y1,ll x2,ll y2,ll x3,ll y3)
{
if (x==x1)
{
ll len=abs(y-y1);
return min(get1(x+len,y,x1+len,y1,x2,y2,x3,y3),get1(x-len,y,x1-len,y1,x2,y2,x3,y3));
}
else
{
ll len=abs(x-x1);
return min(get1(x,y+len,x1,y1+len,x2,y2,x3,y3),get1(x,y-len,x1,y1-len,x2,y2,x3,y3));
}
}
ll b[maxn];
ll que1(vector<pll> vt)
{
for (int i=1;i<=4;i++)
{
b[i]=i;
}
ll ans=1e15;
do
{
ll p=0;
for (int i=0;i<4;i++)
{
p+=get2(vt[i].ff,vt[i].ss,x[b[i+1]],y[b[i+1]]);
}
/*for (int i=1;i<=4;i++)
{
cout <<b[i]<<" "<<vt[i-1].ff<<" "<<vt[i-1].ss<<" ";
}
cout <<endl;*/
ans=min(ans,p);
}while (next_permutation(b+1,b+4+1));
return ans;
}
ll ax[5]={1,-1,1,-1};
ll ay[5]={1,-1,-1,1};
ll que(ll x,ll y,ll len)
{
ll ans=1e15;
for (int i=0;i<4;i++)
{
vector<pll> vt;
vt.pb(make_pair(x,y));
vt.pb(make_pair(x+ax[i]*len,y));
vt.pb(make_pair(x,y+ay[i]*len));
vt.pb(make_pair(x+ax[i]*len,y+ay[i]*len));
ans=min(ans,que1(vt));
}
return ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("t.inp", "r"))
{
freopen("test.inp", "r", stdin);
freopen("test.ans", "w", stdout);
}
ll t;
cin>> t;
while (t--)
{
vector<ll> vt1;
vector<ll> vt2;
vector<pll> vt;
for (int i=1;i<=4;i++)
{
cin>>x[i]>> y[i];
vt1.pb(x[i]);
vt2.pb(y[i]);
vt.pb(make_pair(x[i],y[i]));
}
ll ans=1e16;
//cout <<que1(vt)<<endl;
/* for (int i=1;i<=4;i++)
{
for (int j=1;j<=4;j++)
{
if (i==j) continue;
ll cnt=0;
ll x2,y2;
ll x3,y3;
for (int t=1;t<=4;t++)
{
if (t==i||t==j) continue;
cnt++;
if (cnt==1)
{
x2=x[t];
y2=y[t];
}
else
{
x3=x[t];
y3=y[t];
}
}
ans=min(ans,get(x[i],y[i],x[i],y[j],x2,y2,x3,y3)+abs(x[j]-x[i]));
ans=min(ans,get(x[i],y[i],x[j],y[i],x2,y2,x3,y3)+abs(y[j]-y[i]));
}
}*/
for(auto x1:vt1)
{
for(auto y1:vt2)
{
for (int i=1;i<=4;i++)
{
ll len=abs(x[i]-x1);
ans=min(ans,que(x1,y1,len));
len=abs(y[i]-y1);
ans=min(ans,que(x1,y1,len));
}
}
}
cout <<ans<<endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, n, m, u, v, d, sum = 0;
cin >> n >> m;
long long int hashi[n + 1];
memset(hashi, 0, sizeof(hashi));
for (i = 0; i < m; i++) {
cin >> u >> v >> d;
hashi[u] -= d;
hashi[v] += d;
}
vector<long long int> neg, pos;
for (i = 1; i <= n; i++) {
if (hashi[i] < 0) {
neg.push_back(i);
} else if (hashi[i] > 0) {
pos.push_back(i);
sum += hashi[i];
}
}
long long int np = 0, pp = 0;
vector<pair<long long int, pair<long long int, long long int> > > g;
while (sum) {
long long int mini = min(abs(hashi[neg[np]]), hashi[pos[pp]]);
g.push_back({neg[np], {pos[pp], mini}});
hashi[neg[np]] += mini;
hashi[pos[pp]] -= mini;
sum -= mini;
if (hashi[pos[pp]] == 0) {
pp++;
}
if (hashi[neg[np]] == 0) {
np++;
}
}
cout << g.size() << endl;
for (auto p : g) {
cout << p.first << " " << p.second.first << " " << p.second.second << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void init_ios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
const int N = 5 * (int)1e6 + 100;
int res[N], t, a, b, wyn[N];
vector<int> prime;
bool zloz[N];
int main() {
init_ios();
zloz[0] = zloz[1] = true;
for (int i = 2; i < 3000; ++i)
if (!zloz[i]) {
prime.push_back(i);
for (int j = 2 * i; j < 3000; j += i) zloz[j] = true;
}
res[1] = 0, res[2] = 1;
wyn[1] = 0, wyn[2] = 1;
for (int i = 3; i <= 5 * (int)1e6; ++i) {
wyn[i] = wyn[i - 1];
for (int j = 0; j < prime.size(); ++j)
if (i % prime[j] == 0) {
res[i] = 1 + res[i / prime[j]];
wyn[i] += 1 + res[i / prime[j]];
goto lec;
}
res[i] = 1;
wyn[i] += 1;
lec:
a = a;
}
cin >> t;
while (t--) {
cin >> a >> b;
cout << wyn[a] - wyn[b] << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int solve(string s) {
for (size_t i = 1; i <= s.size() / 4; i++) {
for (size_t j = 0; j <= s.size() - 4 * i + 1; j++) {
size_t k;
for (k = 0; k < 5; k++) {
if (j + i * k >= s.size() || s[j + i * k] == '.') break;
}
if (k == 5) return 1;
}
}
return 0;
}
int main() {
int n;
string s;
cin >> n >> s;
cout << (solve(s) == 1 ? "yes" : "no");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Jump {
int dest, steps;
};
const int N = 1e5 + 2;
const int BLOCK_SIZE = 320;
int a[N];
Jump f[N];
int bid[N];
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = BLOCK_SIZE; i < n; i += BLOCK_SIZE) ++bid[i];
partial_sum(bid, bid + n, bid);
bid[n] = -1;
auto calc = [&](int i) {
if (int v = i + a[i]; v >= n)
f[i] = {n, 1};
else if (bid[i] == bid[v] && f[v].dest != n)
f[i] = {f[v].dest, f[v].steps + 1};
else
f[i] = {v, 1};
};
for (int i = n - 1; i >= 0; --i) calc(i);
while (q--) {
int type, u, v;
cin >> type >> u;
--u;
if (type == 0) {
cin >> v;
a[u] = v;
for (int i = u; i >= 0 && bid[i] == bid[u]; --i) calc(i);
} else {
int jumps = 0;
while (f[u].dest < n) jumps += f[u].steps, u = f[u].dest;
cout << u + 1 << ' ' << jumps + 1 << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
int main() {
cin >> s;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == '0')
n++;
else {
if (n > 0)
n--;
else
s[i] = '0';
}
}
cout << s;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<string, string> a;
for (int i = 0; i < n; i++) {
string temp1, temp2;
cin >> temp1 >> temp2;
a.insert(pair<string, string>(temp2 + ";", temp1));
}
for (int i = 0; i < m; i++) {
string command, ip;
cin >> command >> ip;
if (a.count(ip)) {
cout << command << " " << ip << " "
<< "#" + a.find(ip)->second << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, i, noz = 0, ans = 0;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0) noz++;
}
for (i = 0; i < n; i++) {
if (a[i] == 0) {
noz--;
} else
ans += noz;
if (!noz) break;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int val[100010], vl[100010], vr[100010], res, far[100010], n, dl[100010],
tag[2][400010], sum[2][400010];
int tdl[2][100010];
map<int, int> mp;
int read() {
int tmp = 0, fh = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fh = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
tmp = tmp * 10 + c - '0';
c = getchar();
}
return tmp * fh;
}
void pushdown(int c, int now, int l, int r) {
int mid = (l + r) / 2;
if (tag[c][now]) {
int x = tag[c][now];
tag[c][now] = 0;
tag[c][now * 2] = tag[c][now * 2 + 1] = x;
sum[c][now * 2] = x * ((long long)mid - l + 1) % 1000000007;
sum[c][now * 2 + 1] = x * ((long long)r - mid) % 1000000007;
}
}
void modify(int c, int now, int l, int r, int left, int right, int x) {
if (l == left && r == right) {
tag[c][now] = x;
sum[c][now] = x * ((long long)r - l + 1) % 1000000007;
return;
}
pushdown(c, now, l, r);
int mid = (l + r) / 2;
if (left <= mid) modify(c, now * 2, l, mid, left, min(right, mid), x);
if (right >= mid + 1)
modify(c, now * 2 + 1, mid + 1, r, max(left, mid + 1), right, x);
sum[c][now] = (sum[c][now * 2] + sum[c][now * 2 + 1]) % 1000000007;
}
int query(int c, int now, int l, int r, int left, int right) {
if (l == left && r == right) return sum[c][now];
pushdown(c, now, l, r);
int mid = (l + r) / 2, res = 0;
if (left <= mid) res = query(c, now * 2, l, mid, left, min(right, mid));
if (right >= mid + 1)
res = (res + query(c, now * 2 + 1, mid + 1, r, max(left, mid + 1), right)) %
1000000007;
return res;
}
int get_S(int l, int r) {
return ((long long)l + r) * (r - l + 1) / 2 % 1000000007;
}
int get_res0() {
int res = 0;
for (int i = 1; i <= n; i++)
res = (res + (long long)i * get_S(i, far[i]) % 1000000007) % 1000000007;
return res;
}
int get_res1() {
int res = 0, pos = n + 1, lef = 1, righ = 0, sum = 0;
dl[0] = n + 1;
for (int i = n; i >= 1; i--) {
while (lef <= righ && vr[i] <= vr[dl[righ]]) {
sum = (sum -
(long long)vr[dl[righ]] * (dl[righ - 1] - dl[righ]) % 1000000007 +
1000000007) %
1000000007;
righ--;
}
dl[++righ] = i;
sum = (sum +
(long long)vr[dl[righ]] * (dl[righ - 1] - dl[righ]) % 1000000007 +
1000000007) %
1000000007;
for (int j = pos - 1; j >= far[i] + 1; j--) {
sum = (sum - vr[dl[lef]] + 1000000007) % 1000000007;
if (dl[lef] == j) lef++;
}
dl[0] = pos = far[i] + 1;
res = (res + (long long)sum * i % 1000000007) % 1000000007;
}
lef = 1;
righ = 0;
sum = 0;
pos = 0;
dl[0] = 0;
for (int i = 1; i <= n; i++) {
while (lef <= righ && vl[i] >= vl[dl[righ]]) {
sum = (sum -
(long long)vl[dl[righ]] * (dl[righ] - dl[righ - 1]) % 1000000007 +
1000000007) %
1000000007;
righ--;
}
dl[++righ] = i;
sum = (sum +
(long long)vl[dl[righ]] * (dl[righ] - dl[righ - 1]) % 1000000007 +
1000000007) %
1000000007;
while (far[pos + 1] < i) {
sum = (sum - vl[dl[lef]] + 1000000007) % 1000000007;
if (dl[lef] == pos + 1) lef++;
pos++;
}
dl[0] = pos;
res = (res + (long long)sum * i % 1000000007) % 1000000007;
}
return res;
}
int get_res2() {
int lef[2], righ[2], pos = n + 1, sum = 0, t1, t2, res = 0;
lef[0] = lef[1] = 1;
righ[0] = righ[1] = 0;
tdl[0][0] = tdl[1][0] = pos;
for (int i = n; i >= 1; i--) {
while (lef[0] <= righ[0] && vl[i] >= vl[tdl[0][righ[0]]]) {
t1 = tdl[0][righ[0] - 1];
t2 = tdl[0][righ[0]];
sum = (sum -
(long long)vl[t2] * query(1, 1, 1, n, t2, t1 - 1) % 1000000007 +
1000000007) %
1000000007;
righ[0]--;
}
tdl[0][++righ[0]] = i;
t1 = tdl[0][righ[0] - 1];
t2 = tdl[0][righ[0]];
sum =
(sum + (long long)vl[t2] * query(1, 1, 1, n, t2, t1 - 1) % 1000000007 +
1000000007) %
1000000007;
modify(0, 1, 1, n, t2, t1 - 1, vl[t2]);
while (lef[1] <= righ[1] && vr[i] <= vr[tdl[1][righ[1]]]) {
t1 = tdl[1][righ[1] - 1];
t2 = tdl[1][righ[1]];
sum = (sum -
(long long)vr[t2] * query(0, 1, 1, n, t2, t1 - 1) % 1000000007 +
1000000007) %
1000000007;
righ[1]--;
}
tdl[1][++righ[1]] = i;
t1 = tdl[1][righ[1] - 1];
t2 = tdl[1][righ[1]];
sum =
(sum + (long long)vr[t2] * query(0, 1, 1, n, t2, t1 - 1) % 1000000007 +
1000000007) %
1000000007;
modify(1, 1, 1, n, t2, t1 - 1, vr[t2]);
for (int j = pos - 1; j >= far[i] + 1; j--) {
sum = (sum -
(long long)vl[tdl[0][lef[0]]] * vr[tdl[1][righ[1]]] % 1000000007 +
1000000007) %
1000000007;
if (tdl[0][lef[0]] == j) lef[0]++;
if (tdl[1][lef[1]] == j) lef[1]++;
}
tdl[0][0] = tdl[1][0] = pos = far[i] + 1;
res = (res + sum) % 1000000007;
}
return res;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) val[i] = read();
for (int i = 1; i <= n; i++) {
if (mp.find(val[i]) == mp.end())
vl[i] = 1;
else
vl[i] = mp[val[i]] + 1;
mp[val[i]] = i;
}
mp.clear();
for (int i = n; i >= 1; i--) {
if (mp.find(val[i]) == mp.end())
vr[i] = n;
else
vr[i] = mp[val[i]] - 1;
mp[val[i]] = i;
}
mp.clear();
far[0] = 1;
mp[val[1]] = 1;
for (int i = 1; i <= n; i++) {
far[i] = far[i - 1];
if (i - 1) mp.erase(val[i - 1]);
while (far[i] < n && mp.find(val[far[i] + 1]) == mp.end()) {
far[i]++;
mp[val[far[i]]] = 1;
}
}
res = (((long long)get_res1() - get_res0() - get_res2()) % 1000000007 +
1000000007) %
1000000007;
printf("%d\n", res);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i = 0;
cin >> n;
long long a, b, c;
for (int i = 0; i < int(n); i++) {
cin >> a >> b >> c;
cout << (a + b + c) / 2 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<string> mat;
vector<vector<bool> > p;
int R, C;
int ans = 0;
void search(int x, int y) {
vector<pair<int, int> > v;
v.push_back({x, y});
p[x][y] = 1;
while (v.size() > 0) {
pair<int, int> now = v.back();
x = now.first;
y = now.second;
v.pop_back();
if (x > 0 && !p[x - 1][y] && mat[x - 1][y] == 'B') {
p[x - 1][y] = 1;
v.push_back({x - 1, y});
}
if (x + 1 < R && !p[x + 1][y] && mat[x + 1][y] == 'B') {
p[x + 1][y] = 1;
v.push_back({x + 1, y});
}
if (y > 0 && !p[x][y - 1] && mat[x][y - 1] == 'B') {
p[x][y - 1] = 1;
v.push_back({x, y - 1});
}
if (y + 1 < C && !p[x][y + 1] && mat[x][y + 1] == 'B') {
p[x][y + 1] = 1;
v.push_back({x, y + 1});
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> R >> C;
mat.resize(R);
p.resize(R);
for (int i = 0; i < R; i++) {
cin >> mat[i];
p[i].resize(C, 0);
}
for (int i = 0; i < R; i++) {
for (int j = 0; j < C; j++) {
if (mat[i][j] == 'B' && p[i][j] == 0) {
ans++;
search(i, j);
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double PI = 3.14159265359;
long long inf = 1000000000000000007;
long long mod = 1000000007;
long long mod1 = 998244353;
const bool multi = 1;
long long a[200007];
long long l[200007];
long long r[200007];
bool nie[200007];
long long DP[200007];
long long id[200007];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tt;
if (multi)
cin >> tt;
else
tt = 1;
while (tt--) {
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> vec;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
a[i] += 1000000000;
vec.push_back({a[i], 0});
}
for (long long i = 1; i <= m; i++) {
cin >> l[i] >> r[i];
l[i] += 1000000000;
r[i] += 1000000000;
vec.push_back({l[i], -i});
vec.push_back({r[i], i});
nie[i] = 0;
DP[i] = 0;
}
sort((vec).begin(), (vec).end());
set<pair<long long, long long>> act;
for (auto x : vec) {
if (x.second < 0)
act.insert({l[-x.second], -x.second});
else if (x.second == 0) {
for (auto y : act) nie[y.second] = 1;
act.clear();
} else {
act.erase({l[x.second], x.second});
while ((long long)(act).size() > 0) {
pair<long long, long long> p = *act.begin();
if (p.first > l[x.second]) break;
nie[p.second] = 1;
act.erase(p);
}
}
}
long long it = 0;
long long p1 = inf, p2 = inf, c1 = inf, c2 = inf;
long long pos = -inf;
for (auto x : vec) {
if (nie[abs(x.second)]) continue;
if (x.second == 0) {
p1 = min(DP[it + 1], c2 + 2 * x.first);
p2 = min(DP[it + 1], c1 + x.first);
DP[it + 1] = min(DP[it + 1], min(p1, p2));
pos = x.first;
} else if (x.second < 0) {
it++;
id[-x.second] = it;
DP[it + 1] = min(p1 + x.first - pos, p2 + 2 * (x.first - pos));
} else {
c1 = min(c1, DP[id[x.second]] - x.first);
c2 = min(c2, DP[id[x.second]] - 2 * x.first);
}
}
cout << DP[it + 1] << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4000002;
struct graph {
int v, nxt;
} edg[N];
int cnt, top;
int iter[N], vis[N], low[N], dfn[N], stk[N];
int min(int a, int b) { return a < b ? a : b; }
void init() {
cnt = 0;
memset(iter, -1, sizeof(iter));
}
void add(int u, int v) {
edg[cnt].v = v;
edg[cnt].nxt = iter[u];
iter[u] = cnt++;
}
void bfs(int k, int tot, int &num) {
vis[k] = 1;
low[k] = tot;
dfn[k] = tot;
stk[top++] = k;
for (int i = iter[k]; i != -1; i = edg[i].nxt) {
if (!vis[edg[i].v]) bfs(edg[i].v, ++tot, num);
if (vis[edg[i].v] == 1) low[k] = min(low[k], low[edg[i].v]);
}
if (dfn[k] == low[k]) {
num++;
while (top > 0 && stk[top] != k) {
top--;
low[stk[top]] = num;
vis[stk[top]] = 2;
}
}
}
int tarjan(int x) {
int num = 0, tot = 1;
top = 0;
memset(vis, 0, sizeof(vis));
memset(low, 0, sizeof(low));
for (int i = 1; i <= x; i++) {
if (vis[i] == 0) bfs(i, tot, num);
}
return num;
}
int main() {
int n, a;
scanf("%d", &n);
init();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &a);
if (i == j) continue;
if (a > 0) add(i, j);
}
}
int num = tarjan(n);
if (num == 1)
puts("YES");
else
puts("NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dp[607][302][302];
int map1[333][333];
int main() {
int n;
scanf("%d", &n);
int i, j, k;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) scanf("%d", &map1[i][j]);
for (i = 0; i <= n * 2; i++)
for (j = 0; j <= n; j++)
for (k = 0; k <= n; k++) dp[i][j][k] = -(1 << 20);
dp[1][0][0] = 0;
for (i = 2; i <= n * 2; i++)
for (j = 1; j <= i; j++)
for (k = 1; k <= i; k++) {
int c;
if (j == k)
c = map1[j][i - j];
else
c = map1[j][i - j] + map1[k][i - k];
dp[i][j][k] = max(max(dp[i - 1][j - 1][k - 1], dp[i - 1][j][k - 1]),
max(dp[i - 1][j - 1][k], dp[i - 1][j][k])) +
c;
}
printf("%d\n", dp[2 * n][n][n]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
if (n <= 2 ||
((x == n / 2 || x == (n / 2) + 1) && (y == n / 2 || y == (n / 2) + 1)))
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 2 |
#include <iostream>
#include <algorithm>
using namespace std;
const int NMAX = 1e5;
int v[NMAX];
void solve() {
int n, i, a, minimum = 2e9 + 1;
cin >> n;
for ( i = 0; i < n; i ++ ) {
cin >> v[i];
}
sort( v, v + n );
i = 1;
while ( i < n ) {
minimum = min( minimum, v[i] - v[i - 1] );
if ( minimum >= v[i] )
i ++;
else
break;
}
cout << i << '\n';
}
int main() {
int t;
cin >> t;
while ( t-- ) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long power(long long a, long long b) {
long long x = 1;
a = a % 998244353LL;
while (b) {
if (b & 1) x = (x * a) % 998244353LL;
a = (a * a) % 998244353LL;
b >>= 1;
}
return x;
}
inline long long inv(long long a) { return power(a, 998244353LL - 2); }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
const int N = 1e5 + 5;
long long dp[2][205][2];
long long n, a[N];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 2) {
if (a[0] == a[1]) {
if (a[0] == -1)
cout << "200\n";
else
cout << "1\n";
return 0;
} else if (a[0] == -1 || a[1] == -1) {
cout << "1\n";
return 0;
} else {
cout << "0\n";
return 0;
}
}
if (a[0] != -1 && a[1] != -1) {
if (a[0] > a[1]) {
cout << "0\n";
return 0;
}
}
if (a[n - 1] != -1 && a[n - 2] != -1) {
if (a[n - 1] > a[n - 2]) {
cout << "0\n";
return 0;
}
}
for (int i = 1; i < n - 1; i++) {
if (a[i - 1] != -1 && a[i + 1] != -1 && a[i] != -1) {
if (max(a[i - 1], a[i + 1]) < a[i]) {
cout << "0\n";
return 0;
}
}
}
if (a[0] != -1)
dp[0][a[0]][1] = 1;
else {
for (int i = 1; i <= 200; i++) dp[0][i][1] = 1;
}
for (int i = 1; i < n; i++) {
long long sum = 0, sum1 = 0;
for (int j = 1; j <= 200; j++) {
sum1 += (dp[0][j][1] + dp[0][j][0]);
sum += dp[0][j][0];
sum1 %= 998244353LL;
sum %= 998244353LL;
}
for (int j = 200; j > 0; j--) {
sum1 = (sum1 - dp[0][j][1] - dp[0][j][0] + 998244353LL + 998244353LL) %
998244353LL;
dp[1][j][1] = sum1;
}
for (int j = 1; j <= 200; j++) {
dp[1][j][0] = (sum + dp[0][j][1]) % 998244353LL;
sum = (sum + 998244353LL - dp[0][j][0]) % 998244353LL;
}
if (a[i] == -1) {
for (int j = 1; j <= 200; j++) {
dp[0][j][0] = dp[1][j][0];
dp[0][j][1] = dp[1][j][1];
}
} else {
for (int j = 1; j <= 200; j++) {
dp[0][j][0] = 0;
dp[0][j][1] = 0;
}
dp[0][a[i]][0] = dp[1][a[i]][0];
dp[0][a[i]][1] = dp[1][a[i]][1];
}
for (int j = 1; j <= 200; j++) {
dp[1][j][0] = 0;
dp[1][j][1] = 0;
}
}
long long ans = 0;
for (int j = 1; j <= 200; j++) {
ans += dp[0][j][0];
if (ans >= 998244353LL) ans -= 998244353LL;
}
ans %= 998244353LL;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
const double eps = 1e-6;
struct POINT {
double x, y;
POINT() {}
POINT(double _x, double _y) {
x = _x;
y = _y;
}
};
struct LINE {
double k, b;
LINE() {}
LINE(double _k, double _b) {
k = _k;
b = _b;
}
LINE(POINT u, POINT v) {
k = (u.y - v.y) / (u.x - v.x);
b = u.y - k * u.x;
}
double get_y(double x) { return k * x + b; }
};
bool equ(double x, double y) { return fabs(x - y) < eps; }
bool grt(double x, double y) { return x - y > eps; }
int n, k, an[N];
POINT a[N][N], b[N];
double ans;
POINT Inters(LINE l, LINE o) {
double x, y;
x = (l.b - o.b) / (o.k - l.k);
y = l.k * x + l.b;
return POINT(x, y);
}
void Insert(int x, int y, POINT u) {
for (int i = an[x]; i >= y; --i) a[x][i + 1] = a[x][i];
a[x][y] = u;
++an[x];
}
int main() {
cin >> n >> k;
for (int i = 0; i < k; ++i) {
an[i] = 2;
a[i][1] = POINT(i, 0);
a[i][2] = POINT(i + 1, 0);
}
for (int ii = 1; ii <= n; ++ii) {
ans = 0;
for (int i = 0; i <= k; ++i) {
int x;
cin >> x;
b[i] = POINT(i, x);
}
for (int i = 0; i < k; ++i) {
LINE l = LINE(b[i], b[i + 1]);
for (int j = 1; j < an[i]; ++j) {
POINT p = Inters(l, LINE(a[i][j], a[i][j + 1]));
if (grt(p.x, a[i][j].x) && grt(a[i][j + 1].x, p.x)) {
Insert(i, j + 1, p);
++j;
}
}
}
for (int i = 0; i < k; ++i) {
LINE l = LINE(b[i], b[i + 1]);
for (int j = 1; j <= an[i]; ++j) {
double _y = l.get_y(a[i][j].x);
if (grt(_y, a[i][j].y)) {
if (j > 1) ans += (_y - a[i][j].y) * (a[i][j].x - a[i][j - 1].x) / 2;
if (j < an[i])
ans += (_y - a[i][j].y) * (a[i][j + 1].x - a[i][j].x) / 2;
a[i][j].y = _y;
}
}
}
printf("%.10lf\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 200005;
const int mod = 1000000007;
void solve_case(int tc) {
int n;
cin >> n;
int inf = mod;
int lo = -inf, hi = inf;
int c, d;
bool ok = true;
bool all_one = true;
for (int i = 0; i < n; i++) {
cin >> c >> d;
if (d == 1) {
lo = max(1900, lo);
} else {
hi = min(hi, 1899);
}
lo += c;
hi += c;
if (lo > hi) {
ok = false;
}
if (d == 2) all_one = false;
}
if (ok) {
if (all_one) {
cout << "Infinity" << endl;
} else {
cout << hi << endl;
}
} else
cout << "Impossible" << endl;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int test_case = 1;
for (int tc = 1; tc <= test_case; tc++) {
solve_case(tc);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1[100000 + 100], b[100000 + 100], n, a;
scanf("%d%d", &n, &a);
int num1 = 1, num2 = 1;
for (int i = 1; i <= n; i += 2) a1[i] = num1++;
for (int i = n; i >= 1; i -= 2) b[i] = num2++;
if (a & 1)
printf("%d\n", a1[a]);
else
printf("%d\n", b[a]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int n, x;
int a[10000], b[10000], c[10000];
memset(c, 0, sizeof c);
memset(b, 0, sizeof b);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]]++;
}
for (int i = 1; i <= n; i++) {
if (b[a[i]] > 1) {
b[a[i]]--;
a[i] = 0;
}
}
for (int i = 1; i <= n; i++) {
if (a[i] > 0) v.push_back(a[i]);
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1) cout << " ";
}
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, int> mp;
int main() {
long long int tmp;
for (int i = 0; i < 1000008; i++) {
tmp = 1LL * i * i * i;
mp[tmp] = i;
}
int n, a, b;
scanf("%d", &n);
while (n--) {
scanf("%d%d", &a, &b);
tmp = 1LL * a * b;
if (mp.count(tmp)) {
tmp = mp[tmp];
int c, d;
c = a / tmp;
d = b / tmp;
if (1LL * c * c * d == a && 1LL * d * d * c == b)
printf("Yes\n");
else
printf("No\n");
} else {
printf("No\n");
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> M, M1;
map<int, int>::iterator it;
int a[100009], b[100009];
int main() {
int i, j, k, n, m, x, y;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
M[a[i]]++;
if (a[i] != b[i]) M[b[i]]++;
M1[a[i]]++;
}
int nn = n / 2;
if (n & 1) nn++;
m = 1 << 20;
for (it = M.begin(); it != M.end(); it++) {
if ((*it).second >= nn) {
m = min(m, nn - M1[(*it).first]);
if (m < 0) m = 0;
}
}
if (m < 1 << 20)
printf("%d\n", m);
else
printf("-1\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
std::vector<char> stupeni;
std::vector<char> raketa;
int n, k;
cin >> n >> k;
stupeni.resize(n);
string tmp;
cin >> tmp;
for (int i(0); i < tmp.size(); ++i) {
stupeni[i] = tmp[i];
}
sort(stupeni.begin(), stupeni.end());
raketa.push_back(stupeni[0]);
for (int i(1); i < n; ++i) {
if (raketa.size() == k) {
break;
}
if (stupeni[i] - raketa[raketa.size() - 1] > 1) {
raketa.push_back(stupeni[i]);
}
}
if (raketa.size() == k) {
int weight = 0;
for (auto ch : raketa) {
weight += ch - 96;
}
cout << weight;
} else {
cout << -1;
}
}
| 0 |
// #pragma GCC optimize("Ofast,unroll-all-loops")
#include <iostream>
#include <iomanip>
#include <math.h>
#include <vector>
#include <algorithm>
#define int long long
#define fi first
#define se second
#define pb push_back
#define len(x) (int)(x).size()
#define all(x) begin(x), end(x)
#define debug(x) cerr << #x << " = " << x << endl;
using namespace std;
const int N = 2e6 + 1;
bool LOCAL = 0;
int a[N];
int dp[N];
int w[N], mn[N], mx[N];
int r[N], ww[N], maxr[N];
int cn[N];
int solve(vector<int> a) {
int n, x, y, k;
n = a.size() - 1;
int p = n;
while (p > 1 && a[p] == a[p - 1])
--p;
--p;
if (p == 0)
return 0;
int len = n - p;
for (int i = 1; i <= n; ++i) {
mn[i] = N;
mx[i] = 0;
w[i] = 0;
ww[i] = 0;
}
for (int i = 1; i <= n; ++i) {
++w[a[i]];
mn[a[i]] = min(mn[a[i]], i);
mx[a[i]] = i;
}
w[a[n]] -= len;
for (int i = 1; i <= n; ++i)
if (w[i] > 0) {
r[mn[i]] = mx[i];
ww[mn[i]] = w[i];
}
for (int i = 1; i<= n + 1; ++i)
dp[i] = 0;
dp[1] = 0;
for (int i = 1; i <= n; ++i) {
dp[i + 1] = max(dp[i], dp[i + 1]);
if (ww[i] > 0) {
dp[r[i] + 1] = max(dp[i] + ww[i], dp[r[i] + 1]);
}
}
int ans = p - dp[n + 1];
int cnt = 0;
int cnta = 0;
cn[a[n]] = len;
for (int i = p; i >= 1; --i) {
ans = min(ans, i - 1 - dp[i] + (n - i) - cn[a[i]]);
++cn[a[i]];
}
return ans;
}
void run() {
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i <= n; ++i)
cin >> a[i];
cout << solve(a) << "\n";
}
const int LogN = 20;
int t[LogN];
int solve_stup(vector<int> v) {
for (int i = 0; i < v.size() - 1; ++i)
v[i] = v[i + 1];
v.pop_back();
int n = v.size();
int ans = n;
for (int mask = t[n - 1]; mask < t[n]; ++mask) {
bool good = 1;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
for (int l = j + 1; l < n; ++l)
if ((mask & t[i]) > 0 && (mask & t[j]) > 0 && (mask & t[l]) > 0 && v[i] == v[l] && v[i] != v[j]) {
good = 0;
}
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if ((((mask & t[i]) > 0) != ((mask & t[j]) > 0)) && v[i] != v.back() && v[i] == v[j]) {
good = 0;
}
for (int i = 0; i < n; ++i)
if (good) {
int na = 0;
int nm = mask;
while (nm > 0) {
na += nm % 2;
nm /= 2;
}
ans = min(ans, n - na);
}
}
return ans;
}
int cnn = 0;
void ttest() {
int cN = 10;
while (true) {
++cnn;
if (cnn % 1000 == 0)
cout << cnn << endl;
vector<int> a(cN + 1);
for (int i = 1; i <= cN; ++i)
a[i] = rand() % 5 + 1;
int ans1 = solve(a);
int ans2 = solve_stup(a);
if (ans1 != ans2) {
cout << cN << endl;
for (int i = 1; i <= cN; ++i)
cout << a[i] << ' ' ;
cout << endl;
cout << ans1 << ' ' << ans2;
exit(0);
}
}
}
signed main() {
if (LOCAL) {
freopen("input.txt", "r", stdin);
}
ios_base::sync_with_stdio(false);
cin.tie(0);
t[0] = 1;
for (int i = 1; i < LogN; ++i)
t[i] = t[i - 1] * 2;
int test = 1;
//ttest();
while (test--) {
run();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 109;
long long a[maxn], n, K, sum, ans;
bool check(long long x) {
long long res = 0;
for (int i = 1; i <= n; i++) res += (a[i] + x - 1) / x * x - a[i];
return res <= K;
}
int main() {
scanf("%I64d%I64d", &n, &K);
sum = K;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
sum += a[i];
}
for (long long i = 1; i <= sum; i++) {
i = sum / (sum / i);
if (check(i)) ans = i;
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k, x, a[222222], b[222222];
bool cmp(int i, int j) { return abs(a[i]) > abs(a[j]); }
int main() {
cin >> n >> k >> x;
int sign = 1;
for (int i = 0; i < n; i++) {
int j;
cin >> j;
a[i] = j;
b[i] = i;
sign *= ((a[i]) < 0 ? -1 : 1);
}
make_heap(b, b + n, cmp);
while (k--) {
int j = sign * ((a[b[0]]) < 0 ? -1 : 1);
a[b[0]] -= j * x;
sign = j * ((a[b[0]]) < 0 ? -1 : 1);
pop_heap(b, b + n, cmp);
push_heap(b, b + n, cmp);
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m, i, lp, rp, sw;
cin >> n >> m;
lp = (m / 2);
rp = lp + 1;
sw = (m % 2);
for (i = 0; i < n; i++) {
if ((sw == 0 && lp == 0) || (sw == 1 && rp == (m + 1))) {
lp = (m / 2);
rp = lp + 1;
sw = (m % 2);
}
if (sw) {
cout << rp << endl;
rp++;
} else {
cout << lp << endl;
lp--;
}
sw ^= 1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define mod 1e9 + 7
#define pi 3.1415926535897932384626433832795
#define FOR(a, c) for (int(a) = 0; (a) < (c); (a)++)
#define FORL(a, b, c) for (int(a) = (b); (a) <= (c); (a)++)
#define FORR(a, b, c) for (int(a) = (b); (a) >= (c); (a)--)
#define FORSQ(a, b, c) for (int(a) = (b); (a) * (a) <= (c); ++(a))
#define FOREACH(a, b) for (auto &(a) : (b))
#define f first
#define s second
#define pb push_back
#define pon pop_back
#define mp make_pair
#define ALL(v) v.begin(), v.end()
#define ALLA(arr, sz) arr, arr + sz
#define SIZE(v) (int)v.size()
#define SORT(v) sort(ALL(v))
#define REVERSE(v) reverse(ALL(v))
#define SORTA(arr, sz) sort(ALLA(arr, sz))
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<string, string> pss;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vii;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef priority_queue<ll> PQMAX;
typedef priority_queue<ll, vector<ll>,
greater<ll> > PQMIN;
typedef set<ll> set;
void solve(){
int n;
cin>>n;
cout<<n<<" ";
for(int i=1;i<n;i++){
cout<<i<<" ";
}
cout<<endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t;
cin >> t;
while (t--)
{
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
string s, t;
while (cin >> a >> s) {
c = 0;
for (b = 0; b < a; b++) {
if (s[b] == '-') {
if (c >= 1) {
c--;
}
} else {
c++;
}
}
cout << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 10000;
const double eps = 1e-9;
using namespace std;
int n, m, cur;
set<int> s;
void dfs(int x, int y) {
if (y == 0) {
int tmp = abs(abs(x) - n);
if (tmp < MAXN) {
if (s.size() < m) s.insert(cur * MAXN + tmp);
if (s.size() < m) s.insert(cur + MAXN * tmp);
}
return;
}
dfs(x + (y % 10), y / 10);
dfs(x - (y % 10), y / 10);
dfs(x * (y % 10), y / 10);
}
int main() {
scanf("%d", &(n)), scanf("%d", &(m));
for (int i = 0; i < MAXN; i++) {
cur = i;
dfs(i % 10, i / 10);
}
auto it = s.begin();
for (; it != s.end(); it++) printf("%08d\n", *it);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
long long a[MAXN];
long long n, y, z, t, m, f, x, d, c, e, l = 0;
string s, h, v;
set<int> k;
bool mark[1000];
char g;
int main() {
cin >> n >> m;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if ((((i * i) + j) == n) && (((j * j) + i) == m)) {
c++;
}
}
}
cout << c;
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 707;
typedef int Mat[MAXN][MAXN];
void mul(int n, const int a[MAXN][MAXN], const int b[MAXN][MAXN],
int c[MAXN][MAXN]) {
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; ++j) {
for (int k = 1; k <= n; ++k) {
c[i][j] += a[i][k] * b[j][k];
}
c[j][i] = c[i][j];
}
}
}
int c[MAXN];
Mat e, e2, e3;
int main() {
int n, m, a, b;
long long ans;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
e[a][b] = e[b][a] = 1;
++c[a];
++c[b];
}
ans = 0;
mul(n, e, e, e2);
mul(n, e, e2, e3);
for (int i = 1; i <= n; ++i) {
for (int k = 1; k <= n; ++k) {
ans += (long long)e3[i][k] * e2[k][i];
}
}
ans /= 10;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
if (e[i][j] == 0) {
continue;
}
a = c[i] + c[j];
for (int k = j + 1; k <= n; ++k) {
if (e[i][k] == 0 || e[j][k] == 0) {
continue;
}
ans -= a + c[k] - 3;
}
}
}
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, l, r, t, c, ans;
vector<pair<pair<int, int>, int> > v[105];
int main() {
scanf("%d%d", &m, &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d%d", &l, &r, &t, &c);
for (int j = l; j <= r; ++j) {
v[j].push_back(make_pair(make_pair(t, i), c));
}
}
for (int i = 1; i <= m; ++i) {
if (v[i].size()) {
sort(v[i].begin(), v[i].end());
ans += v[i][0].second;
}
}
printf("%d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, ok = 1;
char s[100001], OK[] = "AHIMOTUVWXY";
int main() {
int i, j;
cin.getline(s, 100001);
n = strlen(s);
for (i = 0; i < n && ok; ++i)
if (!strchr(OK, s[i])) ok = 0;
if (ok) {
i = 0;
j = n - 1;
while (i <= j && ok) {
if (s[i] != s[j]) ok = 0;
++i;
--j;
}
}
if (ok)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, a[N], t[N];
void upd(int pos) {
for (int i = pos; i <= n; i |= i + 1) {
t[i]++;
}
}
int get(int pos) {
int cur = 0;
for (int i = pos; i >= 1; i &= i + 1, i--) {
cur += t[i];
}
return cur;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
a[i] = i;
}
k = min(k, (n + 1) / 2);
for (int i = 1; i <= k; i++) {
swap(a[i], a[n - i + 1]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += get(n) - get(a[i]);
upd(a[i]);
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int minimum(int a, int b) {
if (a > b) {
return b;
} else {
return a;
}
}
class Flow_Graph {
public:
int capacities[203][203];
Flow_Graph() {
for (int j = 0; j < 203; j++) {
for (int t = 0; t < 203; t++) {
capacities[j][t] = 0;
}
}
}
int BFS(int source, int sink, int father[]) {
int visited[203];
for (int j = 0; j < 203; j++) {
visited[j] = 0;
}
queue<int> bfs_queue;
visited[source] = 1;
bfs_queue.push(source);
father[source] = -1;
while (bfs_queue.size() > 0) {
int next = bfs_queue.front();
bfs_queue.pop();
for (int i = 0; i < 203; i++) {
if (visited[i] == 0 && capacities[next][i] > 0) {
bfs_queue.push(i);
father[i] = next;
visited[i] = 1;
}
}
}
if (visited[sink] == 1) {
return 1;
} else {
return 0;
}
}
int max_flow(int source, int sink) {
int fathers[203];
int result = 0;
while (BFS(source, sink, fathers) == 1) {
int flow = 100000000;
for (int iterator = sink; iterator != source;
iterator = fathers[iterator]) {
int temp = fathers[iterator];
if (flow > capacities[temp][iterator]) {
flow = capacities[temp][iterator];
}
}
result = result + flow;
for (int iterator = sink; iterator != source;
iterator = fathers[iterator]) {
int temp = fathers[iterator];
capacities[temp][iterator] -= flow;
capacities[iterator][temp] += flow;
}
}
return result;
}
};
int main() {
Flow_Graph test;
int m, n;
cin >> n >> m;
int temp1, temp2;
int sum_people = 0, sum_nazri = 0;
for (int i = 0; i < n; i++) {
cin >> test.capacities[0][i + 1];
sum_people = sum_people + test.capacities[0][i + 1];
}
for (int i = 0; i < n; i++) {
cin >> test.capacities[n + i + 1][2 * n + 1];
sum_nazri = sum_nazri + test.capacities[n + i + 1][2 * n + 1];
}
for (int i = 0; i < m; i++) {
cin >> temp1 >> temp2;
test.capacities[temp1][temp2 + n] = 100000000;
test.capacities[temp2][temp1 + n] = 100000000;
}
for (int k = 0; k < n; k++) {
test.capacities[k + 1][k + n + 1] = 100000000;
}
if (test.max_flow(0, 2 * n + 1) == sum_nazri && sum_nazri == sum_people) {
cout << "YES" << endl;
for (int j = 1; j < n + 1; j++) {
for (int i = n + 1; i < 2 * n + 1; i++) {
cout << test.capacities[i][j] << " ";
}
cout << endl;
}
} else {
cout << "NO" << endl;
}
}
| 6 |
#include <bits/stdc++.h>
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int exp(long long int x, long long int y, long long int mod) {
long long int res = 1;
x = x % mod;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
long long int modinverse(long long int x, long long int mod) {
return exp(x, mod - 2, mod);
}
using namespace std;
const long long int inf = 0x3f3f3f3f3f3f3f3fll;
long long int dp[26][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n;
cin >> n;
for (long long int i = 0; i < n; i++) {
string s;
cin >> s;
long long int len = s.size();
char l = s[0] - 'a';
char r = s[len - 1] - 'a';
for (long long int j = 0; j < 26; j++) {
if (dp[j][l] != 0) dp[j][r] = max(dp[j][r], dp[j][l] + len);
}
dp[l][r] = max(dp[l][r], len);
}
long long int res = 0;
for (long long int i = 0; i < 26; i++) res = max(res, dp[i][i]);
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200005;
const double eps = 1e-8;
const double DINF = 1e100;
const int INF = 1000000006;
const long long LINF = 1000000000000000005ll;
int n;
int que[MaxN];
long long a[MaxN], b[MaxN];
long long f[MaxN];
bool check(int i, int j, int k) {
long double x1 = b[i] - b[j];
long double y1 = f[i] - f[j];
long double x2 = b[k] - b[j];
long double y2 = f[k] - f[j];
return x1 * y2 - x2 * y1 > eps;
}
long long calc(int i, long long k) { return f[i] + k * b[i]; }
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%I64d", a + i);
for (int i = 1; i <= n; ++i) scanf("%I64d", b + i);
f[1] = 0;
int front, tail;
que[front = tail = 0] = 1;
for (int i = 2; i <= n; ++i) {
while (front < tail) {
long long f1 = calc(que[front], a[i]);
long long f2 = calc(que[front + 1], a[i]);
if (f1 >= f2)
++front;
else
break;
}
f[i] = calc(que[front], a[i]);
while (front < tail && !check(que[tail - 1], que[tail], i)) --tail;
que[++tail] = i;
}
cout << f[n] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> find_max(int a[]) {
pair<int, int> m(a[0], 0);
for (int i = 1; i < n; i++) {
if (a[i] >= m.first) {
m.first = a[i];
m.second = i;
}
}
return m;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
int a[n], c = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int m = find_max(a).second;
while (m != 0) {
++c;
++a[0];
--a[m];
m = find_max(a).second;
}
cout << c;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int fact[1010], dfact[1010];
int mul(int a, int b) { return (long long)a * b % 1000000007; }
int sum(int a, int b) { return (a + b) % 1000000007; }
int sub(int a, int b) { return (a - b + 1000000007) % 1000000007; }
int bpow(int a, int n) {
int res(1);
while (n) {
if (n & 1) res = mul(res, a);
a = mul(a, a);
n >>= 1;
}
return res;
}
void pre_calc() {
fact[0] = dfact[0] = 1;
for (int i(1); i < 1010; ++i) {
fact[i] = mul(fact[i - 1], i);
dfact[i] = bpow(fact[i], 1000000007 - 2);
}
}
int C(int n, int k) { return mul(fact[n], mul(dfact[n - k], dfact[k])); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
pre_calc();
int m;
cin >> m;
int x[m + 2], y[m + 2], mx(0);
for (int i(1); i <= m; ++i) cin >> x[i], mx += x[i];
for (int i(1); i <= m; ++i) cin >> y[i];
int dp[2][++mx];
x[m + 1] = y[m + 1] = x[0] = y[0] = 0;
int cur(0), next(1);
memset(dp, 0, sizeof dp);
dp[cur][0] = 1;
for (int i(0); i <= m; ++i) {
memset(dp[next], 0, sizeof dp[next]);
for (int j(0); j < mx; ++j)
if (dp[cur][j])
for (int k(0); k <= min(j, y[i]); ++k)
if (j - k + x[i + 1] < mx)
dp[next][j - k + x[i + 1]] =
sum(dp[next][j - k + x[i + 1]], mul(dp[cur][j], C(j, k)));
swap(next, cur);
}
int ans(mul(dp[cur][0], fact[mx - 1]));
for (int i(1); i <= m; ++i) ans = mul(ans, dfact[x[i]]);
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long A[55], B[55];
void Init() {
A[0] = 1;
B[0] = 0;
A[1] = 2;
B[1] = 1;
A[2] = 3;
B[2] = 3;
for (int i = 3; i <= 50; i++) {
A[i] = A[i - 1] + A[i - 2];
B[i] = A[i - 3] + A[i - 1];
}
}
long long fun(string str) {
long long res = 1;
int len = str.length();
int ba = 0;
char start = 0;
for (int i = 0; i < len; i++) {
switch (str[i]) {
case 'B':
if (str[(i + 1) % len] == 'A') {
if (ba == 0) start = str[(i - 1 + len) % len];
ba++;
i++;
} else {
if (start == 'A') ba--, start = 0;
if (ba > 0) ba--;
res *= A[ba];
ba = 0;
}
break;
case 'A':
if (str[(i + 1) % len] == 'B' && str[(i + 2) % len] == 'B') return 0;
if (start == 'A') ba--, start = 0;
res *= A[ba];
ba = 0;
}
}
if (start == 'A') ba--, start = 0;
res *= A[ba];
return res;
}
int main() {
string str, tmp;
Init();
while (cin >> str) {
int len = str.length();
tmp = str + str;
int i = 0;
for (i = 0; i < len; i++) {
if (tmp[i] == tmp[i + len - 1]) {
str = string(tmp, i, len);
break;
}
}
if (i == len) {
cout << B[len / 2] << endl;
continue;
}
long long ans = fun(str);
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, p, d[100005], sum[100005], f[105][100005], s[100005], a[100005],
q[100005], head, tail, g[100005];
inline long long getint() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
void work() {
n = getint(), m = getint(), p = getint();
for (int i = 2; i <= n; ++i) d[i] = getint(), sum[i] = sum[i - 1] + d[i];
for (int i = 1; i <= m; ++i) {
int x, y;
x = getint(), y = getint();
a[i] = y - sum[x];
}
sort(a + 1, a + 1 + m);
for (int i = 1; i <= m; ++i) s[i] = s[i - 1] + a[i];
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= p; ++i) {
for (int j = 1; j <= m; ++j) g[j] = f[i - 1][j] + s[j];
head = 1, tail = 1;
q[1] = 0;
for (int j = 1; j <= m; ++j) {
while (head < tail &&
g[q[head + 1]] - g[q[head]] <= a[j] * (q[head + 1] - q[head]))
++head;
f[i][j] = min(f[i - 1][j], g[q[head]] + a[j] * (j - q[head]) - s[j]);
if (g[j] >= 0x3f3f3f3f3f3f3f3fll) continue;
while (head < tail && (g[j] - g[q[tail]]) * (q[tail] - q[tail - 1]) <=
(g[q[tail]] - g[q[tail - 1]]) * (j - q[tail]))
--tail;
q[++tail] = j;
}
}
cout << f[p][m] << endl;
}
int main() {
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline void chkmin(T1 &x, T2 y) {
if (y < x) x = y;
}
template <class T1, class T2>
inline void chkmax(T1 &x, T2 y) {
if (y > x) x = y;
}
const int BUF_SIZE = 1 << 20;
char buf[BUF_SIZE], *P1 = buf, *P2 = buf, obuf[BUF_SIZE], *PO = obuf;
inline char getc() {
if (P1 == P2) P2 = (P1 = buf) + fread(buf, 1, BUF_SIZE, stdin);
return P1 == P2 ? EOF : *P1++;
}
inline void read(int &x) {
register char ch = getc();
x = 0;
while (!isdigit(ch)) ch = getc();
while (isdigit(ch)) x = x * 10 + (ch ^ 48), ch = getc();
}
inline void flushO() {
fwrite(obuf, PO - obuf, 1, stdout);
PO = obuf;
}
inline void putc(char ch) {
if (PO == obuf + (BUF_SIZE)) flushO();
*PO++ = ch;
}
inline void prints(char s[]) {
for (char *ss = s; *ss != '\0'; ss++) putc(*ss);
}
inline void write(long long x) {
if (x > 9) write(x / 10);
putc(x % 10 ^ 48);
}
const int MOD = 1000000007;
inline int mo(int x) { return x >= MOD ? x - MOD : x; }
inline void pluseq(int &x, int y) { x = mo(x + y); }
inline int ksm(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % MOD)
if (b & 1) res = 1ll * res * a % MOD;
return res;
}
const int N = 5005;
int n, k, a[N], b[N], ans;
int main() {
scanf("%d%d", &n, &k);
b[0] = 1;
for (int i = 1; i <= (n); i++) {
scanf("%d", a + i);
for (int j = n; j >= (1); j--)
b[j] = (1ll * b[j] * a[i] - b[j - 1] + MOD) % MOD;
b[0] = 1ll * b[0] * a[i] % MOD;
}
int c = 1, np = 1, invn = ksm(n, MOD - 2);
for (int i = 0; i <= (min(n, k)); i++) {
ans = (ans + 1ll * c * b[i] % MOD * np) % MOD;
c = 1ll * c * (k - i) % MOD;
np = 1ll * np * invn % MOD;
}
printf("%d", mo(b[0] - ans + MOD));
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
double dp[55][55][5005], fac[55];
int a[55];
int main() {
int n, P, s = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s += a[i];
}
cin >> P;
double ans = 0.0;
if (s <= P) {
printf("%.6lf\n", 1.0 * n);
return 0;
} else {
fac[0] = 1.0;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * 1.0 * i;
for (int x = 1; x <= n; x++) {
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= n; i++) dp[i][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
for (int k = 0; k <= s && k <= P; k++) {
dp[i][j][k] += dp[i - 1][j][k];
if (i != x && k >= a[i]) dp[i][j][k] += dp[i - 1][j - 1][k - a[i]];
}
}
}
for (int j = 1; j <= n; j++) {
for (int k = P; k + a[x] > P; k--) {
ans += dp[n][j][k] * fac[j] * fac[n - j - 1] * j;
}
}
}
ans /= fac[n];
printf("%.6lf\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[3][3];
int sum = 0;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
scanf("%d", &arr[i][j]);
sum += arr[i][j];
}
}
sum /= 2;
arr[0][0] = sum - arr[0][1] - arr[0][2];
arr[1][1] = sum - arr[1][0] - arr[1][2];
arr[2][2] = sum - arr[2][1] - arr[2][0];
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) printf("%d ", arr[i][j]);
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int L;
string s;
cin >> L >> s;
int n = s.size();
if (n % L != 0) {
for (int i = 0; i < n; i += L) {
cout << 1;
for (int j = 1; j < L; j++) cout << 0;
}
cout << endl;
} else {
string ans;
for (int i = 0; i < n; i += L) ans += s.substr(0, L);
if (ans < s) {
ans.clear();
for (int i = L - 1;; i--)
if (s[i] == '9')
s[i] = '0';
else {
s[i]++;
break;
}
for (int i = 0; i < n; i += L) ans += s.substr(0, L);
} else if (ans == s) {
bool check = true;
for (int i = 0; i < L; i++)
if (s[i] != '9') check = false;
if (check) {
ans.clear();
for (int i = 0; i <= n; i += L) {
ans += '1';
for (int j = 1; j < L; j++) ans += '0';
}
} else {
ans.clear();
for (int i = L - 1;; i--)
if (s[i] == '9')
s[i] = '0';
else {
s[i]++;
break;
}
for (int i = 0; i < n; i += L) ans += s.substr(0, L);
}
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
template <typename X>
inline X abs(const X& a) {
return a < 0 ? -a : a;
}
template <typename X>
inline X sqr(const X& a) {
return a * a;
}
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long double EPS = 1e-9;
const long double PI = acos(-1.0);
const int N = 100 * 1000 + 13;
int n, u;
int a[N];
int idx1 = -1, idx2, idx3;
inline void read() {
scanf("%d%d", &n, &u);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
}
inline void solve() {
int k = 0;
for (int i = 0; i < n; i++) {
k = max(k, i);
while (k + 1 < n && a[k + 1] - a[i] <= u) {
k++;
}
if (k - i - 1 <= 0) {
continue;
}
int j = i + 1;
if (idx1 == -1 || (a[k] - a[j]) * 1ll * (a[idx3] - a[idx1]) >
(a[idx3] - a[idx2]) * 1ll * (a[k] - a[i])) {
idx1 = i, idx2 = j, idx3 = k;
}
}
if (idx1 == -1) {
cout << -1 << endl;
return;
}
cout.precision(20);
cout << (double)(a[idx3] - a[idx2]) / (a[idx3] - a[idx1]) << endl;
}
int main() {
srand(time(NULL));
cerr << setprecision(10) << fixed;
read();
solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
} else {
long long i = 3, j = 1;
long long sum = 0;
while (i <= n) {
sum += ((2 * i) + (2 * (i - 2))) * j;
j++;
i = i + 2;
}
cout << sum << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[50][50];
int main() {
int n;
cin >> n;
for (int i = 0; i < n / 2; i++) {
int l = n / 2 - i;
for (int j = 0; j < l; j++) {
int x1 = i, x2 = n - i - 1;
int y1 = j, y2 = n - j - 1;
a[x1][y1] = 1;
a[x1][y2] = 1;
a[x2][y1] = 1;
a[x2][y2] = 1;
}
}
int o = 1, e = 2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j]) {
printf("%d ", e);
e += 2;
} else {
printf("%d ", o);
o += 2;
}
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> aa, bb, cc, dd;
const int N = 5e3 + 10;
int n, na, nb, nc, nd;
int a[N], c[N];
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%1d", &a[i]);
for (int i = 0; i < n; i++) scanf("%1d", &c[i]);
for (int i = 0; i < n; i++) {
if (a[i] == 0 && c[i] == 0)
na++, aa.push_back(i + 1);
else if (a[i] == 0 && c[i] == 1)
nb++, bb.push_back(i + 1);
else if (a[i] == 1 && c[i] == 0)
nc++, cc.push_back(i + 1);
else
nd++, dd.push_back(i + 1);
}
for (int a = 0; a <= na; a++) {
for (int b = 0; b <= nb; b++) {
int c = n - 2 * (a + b) - nb - nd + b;
if (c >= 0 && c <= nc) {
int d = n / 2 - c - a - b;
if (d >= 0 && d <= nd) {
for (int i = 0; i < a; i++) printf("%d ", aa[i]);
for (int i = 0; i < b; i++) printf("%d ", bb[i]);
for (int i = 0; i < c; i++) printf("%d ", cc[i]);
for (int i = 0; i < d; i++) printf("%d ", dd[i]);
printf("\n");
return 0;
}
}
}
}
printf("-1\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, a;
void solve() {
vector<int> v;
for (int i = 1; i <= 250; ++i) {
cin >> a;
v.push_back(a);
}
sort((v).begin(), (v).end());
if (double(v[240] - v[10]) / (2 * v[124]) < 0.7)
cout << "poisson\n";
else
cout << "uniform\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> t;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, count = 0;
cin >> n >> d;
string s;
cin >> s;
int i = 0, j = 1, ind, f = 0, f1 = 0;
while (i < n && j < n) {
for (int i = j; i < j + d; i++) {
if (s[i] == '1') {
f = 1;
ind = i;
}
}
j = ind + 1;
i = j;
if (f) {
count++;
f = 0;
f1 = 1;
} else {
f1 = 0;
break;
}
}
if (f1)
cout << count;
else
cout << -1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int x, y, n;
cin >> x >> y >> n;
int qoutient = n / x;
int remainder = n % x;
if (remainder >= y)
cout << qoutient * x + y << endl;
else
cout << (qoutient - 1) * x + y << endl;
;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M, ans;
int A[3333], F[3333][3333];
bool B[3333], C[3333];
int main(int argc, char *argv[]) {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
}
for (int i = N; i > 0; i--) {
B[i] = B[i + 1];
B[i] |= A[i] == 100;
}
for (int i = N; i > 0; i--) {
C[i] = C[i + 1];
C[i] |= A[i] > 0;
}
for (int i = 1; i <= N + 2; i++)
for (int j = 1; j <= N + 2; j++) {
F[i][j] = 3333;
}
F[1][2] = 0;
for (int i = 1; i <= N; i++)
for (int j = i + 1; j <= N; j++) {
if (A[i] > 0 && !B[j]) {
F[i][j + 1] = min(F[i][j + 1], F[i][j] + 1);
}
if (C[j] && A[i] < 100) {
F[j][j + 1] = min(F[j][j + 1], F[i][j] + 1);
}
if (A[i] > 0 && C[j]) {
F[j + 1][j + 2] = min(F[j + 1][j + 2], F[i][j] + 1);
}
}
for (int i = 1; i <= N + 1; i++)
for (int j = i + 1; j <= N + 2; j++) {
ans += F[i][j] <= M;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
bool vis[maxn];
int p[maxn];
int main() {
int i, j, k, p1, p2, x0, x1, x2, n, m, cnt, x, ans;
scanf("%d", &x2);
memset(p, 0, sizeof(p));
for (i = 2; i <= x2; i++) {
if (p[i] == 0) {
p[i] = i;
for (j = i + i; j <= x2; j += i) p[j] = i;
}
}
x0 = x2;
p2 = p[x2];
if (p2 == 2 && p[x2 - 1] == x2 - 1) {
printf("%d\n", x2 - 1);
return 0;
}
for (i = x2 - p2 + 1; i < x2; i++) {
x1 = i;
p1 = p[x1];
if (x1 == p[x1]) continue;
x0 = min(x0, x1 - p1 + 1);
}
printf("%d\n", x0);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int b[400005], cnt[2750131 + 5];
int mark[2750131 + 5];
vector<int> prime;
void build() {
for (int i = 2; i <= 2750131; i++) mark[i] = i;
for (int i = 4; i <= 2750131; i += 2) mark[i] = 2;
for (int i = 3; i * i <= 2750131; i++)
if (mark[i] == i)
for (int j = i * i; j <= 2750131; j += i)
if (mark[j] == j) mark[j] = i;
for (int i = 2; i <= 2750131; i++)
if (mark[i] == i) prime.push_back(i);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
build();
for (int i = 1; i <= 2 * n; i++) {
cin >> b[i];
cnt[b[i]]++;
}
sort(b + 1, b + 1 + 2 * n, greater<int>());
vector<int> res;
for (int i = 1; i <= 2 * n; i++) {
if (b[i] > 200000 || cnt[b[i]] == 0) continue;
if (mark[b[i]] == b[i]) {
int next = prime[b[i] - 1];
if (cnt[next] != 0) {
cnt[next]--;
cnt[b[i]]--;
res.push_back(b[i]);
}
} else {
int next = b[i] / mark[b[i]];
if (cnt[next] != 0) {
cnt[next]--;
cnt[b[i]]--;
res.push_back(b[i]);
}
}
}
for (int i = 0; i < res.size(); i++) cout << res[i] << ' ';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e+5 + 4;
vector<int> adj[N];
long long int val[N], n, f[N], g[N];
void dfs(int v, int p) {
long long int fv = 0, gv = 0;
for (auto it : adj[v])
if (it != p) {
dfs(it, v);
fv = max(fv, f[it]);
gv = max(gv, g[it]);
}
f[v] = fv;
g[v] = gv;
if (val[v] + gv > fv)
f[v] = max(fv, gv + val[v]);
else if (val[v] + gv < fv)
g[v] = max(gv, -val[v] + f[v]);
return;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int l, r;
cin >> l >> r;
adj[l].push_back(r);
adj[r].push_back(l);
}
for (int i = 1; i <= n; i++) cin >> val[i];
dfs(1, 1);
cout << f[1] + g[1];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
n++;
int t[n];
bool test = true;
cin >> t[0];
int sum = t[0];
for (int i = 1; i < n; i++) {
cin >> t[i];
sum += t[i];
if (t[i - 1] != 1 && t[i] != 1) test = false;
}
if (test) {
cout << "perfect" << endl;
return 0;
}
vector<vector<int> > v;
v.resize(n);
int cursum = 0;
for (int i = 0; i < n; i++) {
if (i) cursum += t[i - 1];
for (int j = 1; j <= t[i]; j++) v[i].push_back(cursum + j - 1);
}
cout << "ambiguous" << endl;
int ans1[sum];
int ans2[sum];
int x = 1;
for (int i = 0; i < n; i++) {
if (!i)
for (int j = 0; j < v[i].size(); j++) {
ans1[v[i][j]] = v[i][j];
ans2[v[i][j]] = v[i][j];
}
else if (t[i - 1] != 1) {
for (int j = 0; j < v[i].size(); j++) {
ans1[v[i][j]] = v[i - 1][x] + 1;
ans2[v[i][j]] = v[i - 1][0] + 1;
x = (x + 1) % 2;
}
} else {
for (int j = 0; j < v[i].size(); j++) {
ans1[v[i][j]] = v[i - 1][0] + 1;
ans2[v[i][j]] = v[i - 1][0] + 1;
}
}
}
for (int i = 0; i < sum; i++) cout << ans1[i] << " ";
cout << endl;
for (int i = 0; i < sum; i++) cout << ans2[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long md = 1e9 + 7;
using namespace std;
long long p2[28];
int arr[3][8];
int ans[60];
int rm;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, ind, dup;
long long n, po, val, val2, ans_val;
for (int i = 0; i < 3; i++) {
arr[i][0] = 0;
}
arr[0][1] = 1;
arr[0][2] = 2;
arr[0][3] = 3;
arr[1][1] = 2;
arr[1][2] = 3;
arr[1][3] = 1;
arr[2][1] = 3;
arr[2][2] = 1;
arr[2][3] = 2;
long long tp = 1;
for (int i = 0; i < 27; i++) {
p2[i] = tp;
tp *= 4;
}
cin >> t;
while (t-- > 0) {
cin >> n;
rm = (n - 1) % 3;
po = 0;
while (n / p2[po] > 3) po++;
for (int i = 0; i < po + 1; i++) ans[i] = 0;
dup = po;
ans[po] = arr[rm][1];
ind = po - 1;
val = n - p2[po];
val = val / 3;
while (po > 0) {
val2 = val / p2[po - 1];
ans[ind] = arr[rm][val2];
ind--;
val = val % p2[po - 1];
po--;
}
ans_val = 0;
for (int i = 0; i < dup + 1; i++) ans_val += p2[i] * ans[i];
cout << ans_val << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 20);
const int64_t mod = (int64_t)1e9 + 7;
int n;
vector<int> G[MAXN];
int a[MAXN], to[MAXN];
bool has[MAXN];
void read() {
cin >> n;
for (int i = 1; i <= n; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
has[u] = 1;
}
n *= 2;
}
stack<int> st;
vector<vector<int>> scc;
int low[MAXN], disc[MAXN], comp[MAXN];
int dfs_time;
bool in_stack[MAXN];
void dfs(int u) {
low[u] = dfs_time;
disc[u] = dfs_time;
dfs_time++;
in_stack[u] = true;
st.push(u);
int sz = G[u].size(), v;
for (int i = 0; i < sz; i++) {
v = G[u][i];
if (disc[v] == -1) {
dfs(v);
low[u] = min(low[u], low[v]);
} else if (in_stack[v] == true)
low[u] = min(low[u], disc[v]);
}
if (low[u] == disc[u]) {
scc.push_back(vector<int>());
while (st.top() != u) {
scc[scc.size() - 1].push_back(st.top());
in_stack[st.top()] = false;
st.pop();
}
scc[scc.size() - 1].push_back(u);
in_stack[u] = false;
st.pop();
}
}
set<int> adj[MAXN];
int comp_sz[MAXN];
int in_deg[MAXN];
void tarjan() {
memset(comp_sz, 0, sizeof(comp_sz));
memset(comp, -1, sizeof(comp));
memset(disc, -1, sizeof(disc));
memset(low, -1, sizeof(low));
memset(in_stack, 0, sizeof(in_stack));
dfs_time = 0;
while (!st.empty()) st.pop();
for (int i = 1; i <= n; i++)
if (disc[i] == -1) dfs(i);
int sz = scc.size();
for (int i = 0; i < sz; i++)
for (int j = 0; j < (int)scc[i].size(); j++)
comp_sz[i]++, comp[scc[i][j]] = i;
for (int i = 1; i <= n; i++)
for (int v : G[i])
if (comp[v] != comp[i] &&
adj[comp[v]].find(comp[i]) == adj[comp[v]].end())
adj[comp[v]].insert(comp[i]), in_deg[comp[i]]++;
}
int64_t pow(int64_t x, int64_t p, int64_t MOD) {
if (p == 0) return 1;
if (p % 2 == 1) return (x * pow(x, p - 1, MOD)) % MOD;
int64_t half = pow(x, p / 2, MOD);
return (half * half) % MOD;
}
int64_t rec(int u) {
int64_t ret = 1;
for (int v : adj[u]) ret += rec(v);
return ret;
}
void solve() {
tarjan();
int64_t answer = 1;
for (int u = 0; u < (int)scc.size(); u++)
if (in_deg[u] == 0) {
if (comp_sz[u] == 1) {
if (!has[scc[u][0]])
answer = (answer * 1ll * rec(u)) % mod;
else
continue;
} else
answer = (answer * 2ll) % mod;
}
cout << answer << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next, v;
} e[100005 * 2];
int fl[100005], head[100005], vis[100005], dp[100005][2][2];
int n, tot = 1, m, u, v, del, pdu, pdv, an0, an1, cnt;
void add(int x, int y, int v) {
e[++tot] = (edge){y, head[x], v};
head[x] = tot;
}
void add(int x, int y, int v1, int v2) {
x = abs(x);
y = abs(y);
add(x, y, v1);
add(y, x, v2);
}
void dfs(int x, int pre) {
cnt -= 2;
vis[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
cnt++;
if (e[i].to == x) cnt++;
if (!vis[e[i].to])
dfs(e[i].to, i);
else if (i != (pre ^ 1)) {
u = x;
v = e[i].to;
del = i;
}
}
}
int check(int k1, int k2, int k3) {
if ((k3 & 2) == 0) k1 ^= 1;
if ((k3 & 1) == 0) k2 ^= 1;
return k1 | k2;
}
void treedp(int x, int fa) {
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa && (i ^ del) && (i ^ del ^ 1)) treedp(e[i].to, x);
memset(dp[x], 0, sizeof(dp[x]));
for (int w = 0; w < 2; w++) {
if (x == u && w != pdu) continue;
if (x == v && w != pdv) continue;
int ans0 = 1, ans1 = 0;
for (int i = head[x]; i; i = e[i].next) {
int to = e[i].to;
if (to == fa || !(i ^ del) || !(i ^ del ^ 1)) continue;
int an0 = ans0, an1 = ans1;
ans0 = 0;
ans1 = 0;
for (int w1 = 0; w1 < 2; w1++) {
int A = dp[to][w1][0], B = dp[to][w1][1];
if (check(w, w1, e[i].v)) swap(A, B);
ans0 = (ans0 + 1ll * A * an0 + 1ll * B * an1) % 1000000007;
ans1 = (ans1 + 1ll * A * an1 + 1ll * B * an0) % 1000000007;
}
}
if (fl[x] & (1 << w)) swap(ans0, ans1);
dp[x][w][0] = (dp[x][w][0] + ans0) % 1000000007;
dp[x][w][1] = (dp[x][w][1] + ans1) % 1000000007;
}
}
void solve(int x) {
cnt = 0;
del = -100;
dfs(x, -1);
int ans0 = 0, ans1 = 0;
if (del == -100) {
v = 0;
u = x;
pdu = 0;
pdv = 1;
treedp(x, 0);
ans0 = (ans0 + 1ll * dp[x][0][0] + dp[x][1][0]) % 1000000007;
ans1 = (ans1 + 1ll * dp[x][0][1] + dp[x][1][1]) % 1000000007;
pdu = 1;
treedp(x, 0);
ans0 = (ans0 + 1ll * dp[x][0][0] + dp[x][1][0]) % 1000000007;
ans1 = (ans1 + 1ll * dp[x][0][1] + dp[x][1][1]) % 1000000007;
} else {
for (pdu = 0; pdu < 2; pdu++)
for (pdv = 0; pdv < 2; pdv++) {
treedp(u, 0);
if (check(pdu, pdv, e[del].v))
swap(dp[u][0][0], dp[u][0][1]), swap(dp[u][1][0], dp[u][1][1]);
ans0 = (ans0 + 1ll * dp[u][0][0] + dp[u][1][0]) % 1000000007;
ans1 = (ans1 + 1ll * dp[u][0][1] + dp[u][1][1]) % 1000000007;
}
}
int k0 = an0, k1 = an1;
an0 = (1ll * k0 * ans0 + 1ll * k1 * ans1) % 1000000007;
an1 = (1ll * k0 * ans1 + 1ll * k1 * ans0) % 1000000007;
}
int main() {
scanf("%d%d", &m, &n);
for (; m; m--) {
int x, y;
scanf("%d", &x);
if (x == 1) {
scanf("%d", &y);
if (y > 0)
fl[y] |= 2;
else
fl[-y] |= 1;
} else {
scanf("%d%d", &x, &y);
if (x < 0 && y < 0) add(x, y, 0, 0);
if (x < 0 && y > 0) add(x, y, 1, 2);
if (x > 0 && y < 0) add(x, y, 2, 1);
if (x > 0 && y > 0) add(x, y, 3, 3);
}
}
an0 = 1;
an1 = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) solve(i);
printf("%d", an1);
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
inline int read() {
int x = 0;
int f = 0;
char ch = 0;
while (!isdigit(ch)) {
f |= (ch == '-') ? 1 : 0;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return f ? -x : x;
}
const int mod = 1e9 + 7;
int n, k, t;
inline long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int main() {
t = read();
while (t--) {
n = read();
k = read();
if (n & 1) {
long long ans = qpow(2, n - 1) + 1;
ans = qpow(ans, k);
printf("%lld\n", ans);
} else {
long long temp = (qpow(2, n - 1) - 1 + mod) % mod;
long long tmp = qpow(2, n);
long long ans = qpow(temp, k);
for (int i = 1; i <= k; ++i)
ans = (ans + (long long)qpow(temp, k - i) * qpow(tmp, i - 1)) % mod;
printf("%lld\n", ans);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 9;
struct edge {
int to, nxt;
} e[N * 2];
int hd[N], tot;
void add(int u, int v) {
e[++tot] = (edge){v, hd[u]};
hd[u] = tot;
}
int n, sz[N], msz[N];
void pre(int u, int fa) {
for (int i = hd[u], v; i; i = e[i].nxt)
if ((v = e[i].to) != fa) {
pre(v, u);
sz[u] += sz[v];
if (sz[v] > sz[msz[u]]) msz[u] = v;
}
sz[u]++;
}
int f[N][2], mx[N];
void dfs1(int u, int fa) {
for (int i = hd[u], v; i; i = e[i].nxt)
if ((v = e[i].to) != fa) {
dfs1(v, u);
int tmp = (sz[v] > n / 2 ? f[v][0] : sz[v]);
if (tmp > f[u][0])
f[u][1] = f[u][0], f[u][0] = tmp, mx[u] = v;
else if (tmp > f[u][1])
f[u][1] = tmp;
}
}
int g[N];
void dfs2(int u, int fa) {
for (int i = hd[u], v; i; i = e[i].nxt)
if ((v = e[i].to) != fa) {
int tmp = (n - sz[v] > n / 2 ? g[u] : n - sz[v]);
g[v] = max(g[v], tmp);
if (v == mx[u])
g[v] = max(g[v], f[u][1]);
else
g[v] = max(g[v], f[u][0]);
dfs2(v, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) scanf("%d%d", &u, &v), add(u, v), add(v, u);
pre(1, 0), dfs1(1, 0), dfs2(1, 0);
for (int i = 1; i <= n; i++) {
bool centroid = 1;
if (sz[msz[i]] > n / 2)
centroid = (sz[msz[i]] - f[i][0] <= n / 2);
else if (n - sz[i] > n / 2)
centroid = (n - sz[i] - g[i] <= n / 2);
cout << centroid << " ";
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.