solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
char c[8][8];
int i, j, a = 8, b = 8, k;
for (i = 0; i < 8; ++i)
for (j = 0; j < 8; ++j) cin >> c[i][j];
for (i = 0; i < 8; ++i) {
for (j = 0; j < 8; ++j) {
if (c[i][j] == 'B') {
for (k = i + 1; k < 8; ++k)
if (c[k][j] == 'W') break;
if (k == 8 && 7 - i < b) b = 7 - i;
} else if (c[i][j] == 'W') {
for (k = i - 1; k >= 0; --k)
if (c[k][j] == 'B') break;
if (k == -1 && i < a) a = i;
}
}
}
if (a <= b)
cout << "A";
else
cout << "B";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > remaining;
struct lex_compare {
bool operator()(const int& lhs, const int& rhs) const {
if (remaining[lhs].size() != remaining[rhs].size())
return (remaining[lhs].size() > remaining[rhs].size());
return (lhs > rhs);
}
};
void solve() {
int n, first, second;
cin >> n >> first >> second;
remaining.assign(n + 1, {});
set<int, lex_compare> ms;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
v[i]--;
}
vector<int> ans(n, -1);
for (int i = 0; i < n; ++i) {
remaining[v[i]].push_back(i);
}
for (int i = 0; i <= n; ++i) ms.insert(i);
int free = -1;
for (int i = 0; i <= n; ++i)
if (!remaining[i].size()) free = i;
for (int i = 0; i < first; ++i) {
auto it = ms.begin();
auto num = (*it);
ms.erase(it);
int index = remaining[num].back();
remaining[num].pop_back();
ans[index] = num;
ms.insert(num);
}
vector<int> rw;
int tp = -1;
for (auto el : ms) {
if (tp == -1) tp = remaining[el].size();
for (auto first : remaining[el]) {
rw.push_back(first);
}
}
vector<pair<int, int> > stay;
for (int i = 0; i < rw.size(); ++i) {
int a = rw[i];
int b = rw[(i + tp) % rw.size()];
if (v[a] != v[b]) {
stay.push_back(make_pair(b, a));
}
}
if (stay.size() < second - first) {
cout << "NO\n";
return;
}
cout << "YES\n";
for (int i = 0; i < second - first; ++i) {
int a = stay[i].second, b = stay[i].first;
ans[b] = v[a];
}
for (int i = 0; i < n; ++i)
if (ans[i] == -1) ans[i] = free;
for (auto first : ans) cout << first + 1 << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; ++i) solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;
using Graph = vector<vector<vector<pair<int, int>>>>;
void solve(int test_number) {
test_number = test_number;
int n, m;
cin >> n >> m;
vector<string> grid(n);
for (int i = 0; i < n; ++i) cin >> grid[i];
Graph g(n, vector<vector<pair<int, int>>>(m));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
grid[i][j] = (grid[i][j] == 'X');
g[i][j] = vector<pair<int, int>>();
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (!grid[i][j]) continue;
int count = grid[i + 1][j] + grid[i - 1][j];
count += grid[i][j + 1] + grid[i][j - 1];
if (count & 1) {
cout << "NO" << '\n';
return;
}
for (int x = -1; x <= 1; x += 2)
for (int y = -1; y <= 1; y += 2) {
if (!grid[i + x][j] && !grid[i][j + y]) {
g[i + x][j].emplace_back(i, j + y);
g[i][j + y].emplace_back(i + x, j);
}
}
if (count > 0) {
if (!grid[i + 1][j] && !grid[i - 1][j]) {
g[i + 1][j].emplace_back(i - 1, j);
g[i - 1][j].emplace_back(i + 1, j);
}
if (!grid[i][j + 1] && !grid[i][j + 1]) {
g[i][j + 1].emplace_back(i, j - 1);
g[i][j - 1].emplace_back(i, j + 1);
}
}
}
vector<vector<int>> sol(n, vector<int>(m, -1));
function<void(int, int)> two_color_component = [&](int i, int j) {
for (auto [ui, uj] : g[i][j]) {
if (sol[ui][uj] == -1) {
sol[ui][uj] = (sol[i][j] == 1) ? 4 : 1;
two_color_component(ui, uj);
}
}
};
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (grid[i][j]) continue;
if (sol[i][j] == -1) {
sol[i][j] = 4;
two_color_component(i, j);
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (grid[i][j]) {
int count = grid[i + 1][j] + grid[i - 1][j];
count += grid[i][j + 1] + grid[i][j - 1];
sol[i][j] = 5 * (4 - count) / 2;
}
}
cout << "YES" << '\n';
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << sol[i][j] << " ";
}
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
for (int i = 1; i <= T; ++i) solve(i);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n, m;
long long a[N], b[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (long long i = 1; i <= m; i++) {
cin >> b[i];
auto it = lower_bound(a + 1, a + n + 1, b[i]);
long long ans = it - a;
cout << ans << " " << b[i] - a[ans - 1] << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 123;
const int mod = 1e9 + 7;
const int INF = 1e9 + 1;
const long long INFL = 1e18 + 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, sz = 1, k;
struct bor {
int nxt[30];
int win, lose;
} T[7 * N];
inline void add(string s) {
int v = 1;
for (int i = 0; i < s.size(); i++) {
int to = s[i] - 'a' + 1;
if (!T[v].nxt[to]) T[v].nxt[to] = ++sz;
v = T[v].nxt[to];
}
}
inline void dfs1(int v = 1) {
T[v].win = 0;
for (int i = 1; i <= 26; i++) {
if (T[v].nxt[i]) {
dfs1(T[v].nxt[i]);
if (!T[T[v].nxt[i]].win) T[v].win = 1;
}
}
}
inline void dfs2(int v = 1) {
bool ok = 0;
T[v].lose = 0;
for (int i = 1; i <= 26; i++) {
if (T[v].nxt[i]) {
ok = 1;
dfs2(T[v].nxt[i]);
if (!T[T[v].nxt[i]].lose) T[v].lose = 1;
}
}
if (!ok) T[v].lose = 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
add(s);
}
dfs1();
dfs2();
if (T[1].win == 0)
cout << "Second";
else if (T[1].win == 1 && T[1].lose == 1)
cout << "First";
else {
if (k % 2 == 1)
cout << "First";
else
cout << "Second";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int namenod[300007];
bool root[300007];
vector<vector<int>> adj;
set<int> roots;
vector<int> topological;
int color[300007] = {0};
bool nocyc(int x) {
bool b = true;
for (auto nxt : adj[x]) {
if (color[nxt] == 0)
color[nxt] = 1, b &= nocyc(nxt);
else if (color[nxt] == 1) {
return 0;
}
}
color[x] = 2;
return b;
}
void toposon(int nod, bool vis[], stack<int> &stk) {
vis[nod] = 1;
for (auto nxt : adj[nod]) {
if (!vis[nxt]) {
toposon(nxt, vis, stk);
}
}
stk.push(nod);
}
void topo() {
stack<int> stk;
bool vis[300007] = {};
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
toposon(i, vis, stk);
}
}
while (!stk.empty()) {
topological.push_back(stk.top());
stk.pop();
}
}
int main() {
cin >> n >> m;
adj.resize(n + 3);
string s;
cin >> s;
for (int i = 0; i < n; ++i) {
namenod[i + 1] = s[i] - 'a';
}
int x, y;
for (int i = 1; i <= n; ++i) root[i] = 1;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
if (x == y) return puts("-1"), 0;
adj[x].push_back(y);
root[y] = 0;
}
for (int r = 1; r <= n; ++r) {
roots.insert(r);
if (!nocyc(r)) return puts("-1"), 0;
}
topo();
int dis[300007];
int greed = 0;
for (int c = 0; c < 26; ++c) {
memset(dis, -1, sizeof dis);
for (auto r : roots) {
namenod[r] != c ? dis[r] = 0 : dis[r] = 1;
}
for (int i = 0; i < n; ++i) {
int nod = topological[i];
if (dis[nod] != -1) {
for (auto nxt : adj[nod]) {
int tem = 0;
if (namenod[nxt] == c) tem++;
if (dis[nod] + tem > dis[nxt]) dis[nxt] = dis[nod] + tem;
}
}
}
for (int i = 1; i <= n; ++i) {
greed = max(greed, dis[i]);
}
}
cout << greed;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
int ans;
cin >> n;
if (n == 9) {
ans = 1;
} else
ans = (n + 1) / 10;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> b(n), a(n);
vector<vector<long long> > c(60);
for (int i = 0; i < n; i++) {
scanf("%lld", &b[i]);
c[63 - __builtin_clzll(b[i])].push_back(b[i]);
}
long long now = 0;
for (int i = 0; i < n; i++) {
bool ok = 0;
for (int j = 0; j < 60; j++) {
if ((now >> j & 1) || c[j].empty()) continue;
now ^= a[i] = c[j].back();
c[j].pop_back();
ok = 1;
break;
}
if (!ok) return cout << "No\n", 0;
}
cout << "Yes\n";
for (int i = 0; i < n; i++) cout << a[i] << " \n"[i == n - 1];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
vector<long long> primes;
vector<long long> vis(1000005, 0);
void sieve(long long n) {
primes.clear();
vis.clear();
for (long long i = 2; i * i <= n; i++) {
if (!vis[i]) {
for (long long j = i * i; j <= n; j += i) {
vis[j] = 1;
}
}
}
for (long long i = 2; i <= n; i++) {
if (!vis[i]) primes.push_back(i);
}
}
long long factorize(long long n) {
long long cnt = 0;
for (auto x : primes) {
if (n < x) break;
while (n % x == 0) {
n = n / x;
cnt++;
}
}
if (n > 1) cnt++;
return cnt;
}
bool compare(pair<long long, long long> a, pair<long long, long long> b) {
return a.second < b.second;
}
void remove_duplicates(vector<long long> &v) {
long long i = 0;
while (i < v.size() - 1) {
if (v[i] == v[i + 1])
v.erase(v.begin() + i, v.begin() + i + 1);
else
i++;
}
return;
}
unordered_map<long long, unordered_map<long long, long long> > ncrmap;
long long nCr(long long n, long long r) {
if (ncrmap[n].find(ncrmap[n][r]) == ncrmap[n].end()) {
if (n < r) return ncrmap[n][r] = 0;
if (n == r) return ncrmap[n][r] = 1;
if (r == 1) return ncrmap[n][r] = n;
if (r == 0) return ncrmap[n][r] = 1;
ncrmap[n][r] = nCr(n - 1, r - 1) + nCr(n - 1, r);
}
return ncrmap[n][r];
}
void solve() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
sieve(1000005);
long long t = 1;
cin >> t;
cout << endl;
vector<pair<long long, long long> > q(t);
for (long long i = 0; i < t; i++) {
cin >> q[i].first;
q[i].second = i;
}
vector<long long> ans(t);
sort(q.begin(), q.end());
long long i = 0;
for (i = 0; i < t; i++) {
long long num = q[i].first;
auto prevtp =
upper_bound(primes.begin(), primes.end(), num) - primes.begin();
long long pp = 0;
auto prevpp =
upper_bound(primes.begin(), primes.end(), sqrt(num)) - primes.begin();
ans[q[i].second] = prevtp - prevpp + 1;
}
for (long long i = 0; i < t; i++) cout << ans[i] << " ";
}
int32_t main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n, k;
int st[N], en[N];
int mem[N];
int tot[N][N];
vector<int> sp;
vector<pair<int, int> > v;
int cost(int x, int y) {
if (x >= y) return 0;
int &ret = tot[x][y];
if (ret != -1) return ret;
ret = 0;
for (int i = 0; i < k; i++) {
int a = v[i].first, b = v[i].second, c = sp[x], d = sp[y];
if (a > c) {
swap(a, c);
swap(b, d);
}
if (c < b && b < d) ret++;
}
ret += cost(x + 1, y - 1);
return ret;
}
int go(int ind) {
if (ind >= sp.size()) return 0;
int &ret = mem[ind];
if (ret != -1) return ret;
ret = -(1 << 30);
for (int en = ind + 1; en < sp.size(); en += 2) {
int len = (en - ind + 1) / 2;
ret = max(ret, cost(ind, en) + go(en + 1) + len * (len - 1) / 2);
}
return ret;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &k);
memset(st, -1, sizeof st);
memset(en, -1, sizeof en);
memset(mem, -1, sizeof mem);
sp.clear();
v.clear();
memset(tot, -1, sizeof tot);
for (int i = 0; i < k; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
if (x > y) swap(x, y);
st[x] = y;
en[y] = x;
v.push_back({x, y});
}
n *= 2;
for (int i = 0; i < n; i++) {
if (st[i] == -1 && en[i] == -1) sp.push_back(i);
}
for (int i = 0; i < sp.size() / 2; i++) {
v.push_back({sp[i], sp[i + sp.size() / 2]});
}
sort(v.begin(), v.end());
int ans = 0;
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j < v.size(); j++) {
if (v[j].first < v[i].second && v[i].second < v[j].second) ans++;
}
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
void print_time() {}
template <typename T>
void update_max(T& x, T y) {
x = max(x, y);
}
template <typename T>
void update_min(T& x, T y) {
x = min(x, y);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class T>
ostream& operator<<(ostream& out, vector<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class T>
ostream& operator<<(ostream& out, set<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class L, class R>
ostream& operator<<(ostream& out, map<L, R> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
int main() {
cout << fixed << setprecision(20);
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
long long suma = 0;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
suma += a[i];
}
long long black = 0;
for (long long i = 0; i < n; ++i) {
black += (a[i] + (i & 1)) / 2;
}
cout << min(black, suma - black);
print_time();
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long val = 1e9 + 7;
using namespace std;
const int INF = 1e9;
void solve() {
int n;
cin >> n;
vector<int> v(n);
map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> v[i];
m[v[i]]++;
}
int max = 0, maxindx = 0;
for (int i = 0; i < n; i++) {
if (m[v[i]] > max) {
max = m[v[i]];
maxindx = i;
}
}
vector<pair<pair<int, int>, int>> res;
for (int i = maxindx; i >= 1; i--) {
int x = 1;
if (v[i] == v[i] - 1) continue;
if (v[i] < v[i - 1]) {
x = 2;
} else if (v[i] > v[i - 1]) {
x = 1;
}
v[i - 1] = v[i];
res.push_back(make_pair(make_pair(i - 1, i), x));
}
for (int i = maxindx; i < n - 1; i++) {
int x = 1;
if (v[i] == v[i + 1]) continue;
if (v[i] < v[i + 1])
x = 2;
else if (v[i] > v[i + 1])
x = 1;
v[i + 1] = v[i];
res.push_back(make_pair(make_pair(i + 1, i), x));
}
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) {
cout << res[i].second << " " << res[i].first.first + 1 << " "
<< res[i].first.second + 1 << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void s() {
int n, i, j, d, b, B, best;
cin >> n;
vector<int> a[n + 1], ans(n + 1, INT_MAX);
for (i = 1; i <= n; i++) {
cin >> b;
a[b].push_back(i);
}
for (i = 1; i <= n; i++) {
if (a[i].empty() == 1) continue;
a[i].insert(a[i].begin(), 0);
a[i].push_back(n + 1);
d = a[i].size();
best = 0;
for (j = 0; j < d - 1; j++) best = max(a[i][j + 1] - a[i][j], best);
ans[best] = min(i, ans[best]);
}
for (i = 2; i <= n; i++) ans[i] = min(ans[i], ans[i - 1]);
for (i = 1; i <= n; i++) cout << (ans[i] == INT_MAX ? -1 : ans[i]) << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) s();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n;
long long k;
struct mat {
long long m[17][17];
void clr() {
for (long long i = 0; i < 16; i++) {
for (long long j = 0; j < 16; j++) {
m[i][j] = 0;
if (j >= i - 1 && j <= i + 1) {
m[i][j] = 1;
}
}
}
}
void clr2() {
for (long long i = 0; i < 16; i++) {
for (long long j = 0; j < 16; j++) {
m[i][j] = 0;
if (i == j) m[i][j] = 1;
}
}
}
} A, B, pre;
mat mul(mat A, mat B, long long len) {
mat C;
memset(C.m, 0, sizeof(C.m));
for (int i = 0; i <= len; i++) {
for (int j = 0; j <= len; j++) {
for (int k = 0; k <= len; k++) {
C.m[i][j] = (C.m[i][j] + A.m[i][k] * B.m[k][j]) % mod;
}
}
}
return C;
}
mat quick_pow(mat A, long long len, int y) {
mat B;
memset(B.m, 0, sizeof(B.m));
B.clr2();
while (len) {
if (len & 1) B = mul(B, A, y);
A = mul(A, A, y);
len >>= 1;
}
return B;
}
int main() {
scanf("%I64d%I64d", &n, &k);
memset(pre.m, 0, sizeof(pre.m));
memset(A.m, 0, sizeof(A.m));
A.clr();
long long flag = 0;
pre.m[0][0] = 1;
long long L, R;
int y;
for (int i = 0; i < n; i++) {
scanf("%I64d%I64d%d", &L, &R, &y);
if (R > k) {
R = k;
flag = 1;
}
B = quick_pow(A, R - L, y);
for (long long j = y + 1; j <= 15; j++) pre.m[j][0] = 0;
B = mul(B, pre, y);
for (long long j = 0; j <= y; j++) {
pre.m[j][0] = B.m[j][0];
}
if (flag == 1) break;
}
printf("%d\n", B.m[0][0]);
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("popcnt")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int N = 3e5 + 12;
const long long Mod = 1e9 + 7;
const long long oo = 1e18;
mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
int ntest, n;
int d[N], p[2], ret[N];
void Print(int a, int b, int c) {
cout << "? " << a << " " << b << " " << c << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> ntest;
while (ntest--) {
cin >> n;
int pos = 1;
for (int i = 1; i <= n; i += 3) {
Print(i, i + 1, i + 2);
cin >> d[i];
if (i > 1 && d[i] != d[i - 3]) pos = i - 3;
}
for (int _ = pos + 1, __ = pos + 2, i = _; i <= __; i++) {
Print(i, i + 1, i + 2);
cin >> d[i];
}
for (int _ = pos, __ = pos + 2, i = _; i <= __; i++) {
if (d[i] == d[i + 1]) continue;
p[d[i]] = i, p[d[i + 1]] = i + 3;
ret[i] = d[i];
ret[i + 3] = d[i + 1];
}
for (int _ = pos, __ = pos + 5, i = _; i <= __; i++) {
if (i == p[0] || i == p[1]) continue;
Print(p[0], p[1], i);
int val;
cin >> val;
ret[i] = val;
}
for (int i = 1; i <= n; i += 3) {
if (i == pos || i == pos + 3) continue;
if (d[i] == 1) {
Print(i, i + 1, p[0]);
int x;
cin >> x;
if (x == 1) {
ret[i] = ret[i + 1] = 1;
Print(p[0], p[1], i + 2);
int val;
cin >> val;
ret[i + 2] = val;
} else {
ret[i + 2] = 1;
Print(p[0], p[1], i);
int val;
cin >> val;
ret[i] = val;
ret[i + 1] = 1 - val;
}
} else {
Print(i, i + 1, p[1]);
int x;
cin >> x;
if (x == 0) {
ret[i] = ret[i + 1] = 0;
Print(p[0], p[1], i + 2);
int val;
cin >> val;
ret[i + 2] = val;
} else {
ret[i + 2] = 0;
Print(p[0], p[1], i);
int val;
cin >> val;
ret[i] = val;
ret[i + 1] = 1 - val;
}
}
}
vector<int> v;
for (int _ = 1, __ = n, i = _; i <= __; i++)
if (ret[i] == 0) v.push_back(i);
cout << "! " << v.size() << " ";
for (auto x : v) cout << x << " ";
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int O = 100005;
typedef struct E {
int n, v;
} E;
E edge[2 * O];
int Adj[O], tot;
void addedge(int u, int v) {
edge[tot].v = v;
edge[tot].n = Adj[u]++;
Adj[u] = tot++;
edge[tot].v = u;
edge[tot].n = Adj[v]++;
Adj[v] = tot++;
}
int n, u, v, sum;
int a[O];
int goal[O];
int vis[O];
int draw[O], top;
void DFS(int u, int p, int gp) {
if (a[u] != goal[u] && gp % 2 == 0 || a[u] == goal[u] && gp % 2) {
sum++;
gp++;
draw[top++] = u;
}
for (int i = Adj[u]; ~i; i = edge[i].n) {
int v = edge[i].v;
if (vis[v]) return;
vis[v] = 1;
DFS(v, gp, p);
}
}
int main() {
scanf("%d", &n);
memset(vis, 0, sizeof(vis));
memset(Adj, -1, sizeof(Adj));
tot = 0;
sum = 0;
top = 0;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
addedge(u, v);
}
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", goal + i);
DFS(1, 0, 0);
printf("%d\n", sum);
for (int i = 0; i < top; i++) printf("%d\n", draw[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
n = n / 3 + (n % 3 == 2);
printf("%d %d\n", n / 12, n % 12);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
long int a, b, c, d, ans;
int T, i;
scanf("%d", &T);
for (i = 1; i <= T; i++) {
scanf("%ld %ld %ld", &a, &b, &c);
if (a > c) {
printf("%ld\n", c);
} else {
d = b / c;
d = d + 1;
ans = c * d;
printf("%ld\n", ans);
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7f7f7f7f;
int n, m;
int ans, f1[105][55][2], f2[105][55][2];
char s[105];
int main() {
memset(f1, -INF, sizeof(f1));
memset(f2, INF, sizeof(f2));
scanf("%s%d", s + 1, &m);
n = strlen(s + 1);
f1[0][0][0] = f1[0][0][1] = f2[0][0][0] = f2[0][0][1] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= min(i, m); j++)
if (s[i] == 'F') {
f1[i][j][0] = max(f1[i][j][0], f1[i - 1][j][0] + 1);
f1[i][j][1] = max(f1[i][j][1], f1[i - 1][j][1] - 1);
f1[i][j + 1][0] = max(f1[i][j + 1][0], f1[i - 1][j][1]);
f1[i][j + 1][1] = max(f1[i][j + 1][1], f1[i - 1][j][0]);
f2[i][j][0] = min(f2[i][j][0], f2[i - 1][j][0] + 1);
f2[i][j][1] = min(f2[i][j][1], f2[i - 1][j][1] - 1);
f2[i][j + 1][0] = min(f2[i][j + 1][0], f2[i - 1][j][1]);
f2[i][j + 1][1] = min(f2[i][j + 1][1], f2[i - 1][j][0]);
} else if (s[i] == 'T') {
f1[i][j][0] = max(f1[i][j][0], f1[i - 1][j][1]);
f1[i][j][1] = max(f1[i][j][1], f1[i - 1][j][0]);
f1[i][j + 1][0] = max(f1[i][j + 1][0], f1[i - 1][j][0] + 1);
f1[i][j + 1][1] = max(f1[i][j + 1][1], f1[i - 1][j][1] - 1);
f2[i][j][0] = min(f2[i][j][0], f2[i - 1][j][1]);
f2[i][j][1] = min(f2[i][j][1], f2[i - 1][j][0]);
f2[i][j + 1][0] = min(f2[i][j + 1][0], f2[i - 1][j][0] + 1);
f2[i][j + 1][1] = min(f2[i][j + 1][1], f2[i - 1][j][1] - 1);
}
if (m % 2 == 0) {
for (int i = 0; i <= m; i += 2) {
ans = max(ans, max(f1[n][i][0], f1[n][i][1]));
ans = max(ans, max(-f2[n][i][0], -f2[n][i][1]));
}
} else {
for (int i = 1; i <= m; i += 2) {
ans = max(ans, max(f1[n][i][0], f1[n][i][1]));
ans = max(ans, max(-f2[n][i][0], -f2[n][i][1]));
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#include <cmath>
#include <regex>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define ba back
#define ppb pop_back
#define eb emplace_back
#define eps 1e-6
#define vec vector<long long int>
#define sz(x) (int((x.size())))
#define all(x) (x).begin(),(x).end()
#define FAST ios_base :: sync_with_stdio (false); cin.tie (NULL)
#define ll long long
#define loop(i,s,n) for(int i=s;i<n;i++)
using namespace std;
//-----------------------------------------------------------------------------------------------------------------
const ll M = 1e9 + 7;
const ll N = 2e5 + 5;
const ll inf = 2e18;
ll mod(ll x){ return (x%M);}
ll mod_minus(ll a, ll b){ ll ans= (mod(a)-mod(b)); if(ans<0) ans=mod(ans+M); return ans;}
ll mod_mul(ll a,ll b){ return mod(mod(a)*mod(b));}
ll mod_add(ll a,ll b){ return mod(a+b);}
ll power(ll a,ll n){
if(n==0) return 1;
else if(n==1) return a;
ll R=power(a,n/2)%M;
if(n%2==0) { return mod(mod_mul(R,R)); }
else { return mod(mod_mul(mod_mul(R,a),mod(R))); }
}
ll mod_inv(ll n){ return power(n,M-2);}
// only if M is prime
ll mod_div(ll a,ll b){
ll ans=mod(a); ll b1=power(b,M-2);
ans= mod(mod_mul(ans,b1));
return ans;
}
ll fact_mod(ll n){
vec fact(n+1);
fact[0]=1;
loop(i,1,n+1){
fact[i]=mod_mul(fact[i-1],i);
}
return fact[n];
}
unsigned long long nCr_mod(unsigned long long n, ll r)
{
if (r == 0)
return 1;
unsigned long long fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = (fac[i - 1] * i) % M;
return (fac[n] * mod_inv(fac[r]) % M * mod_inv(fac[n - r]) % M) % M;
}
//--------------------------------------------------------------------------------------------------------------
void solve(){
ll n;
cin>>n;
ll a[n];
ll sum=0;
loop(i,0,n){
cin>>a[i];
sum+=a[i];
}
sort(a,a+n);
ll mx=a[n-1],mn=a[0];
ll z=(n-1)-sum%(n-1);
if(z==(n-1)){
z=0;
}
sum+=z;
if(mx<=sum/(n-1)){
cout<<z<<endl;
return;
}
cout<<mx*(n-1)-sum+z<<endl;
}
int main(){
FAST;
int t;
cin>>t;
while(t--){
solve();
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int n, in[24], dp[1 << 24];
int dfs(int status, int idx) {
if (dp[status]) return dp[status];
if (status == 1) return 1;
int cnt = 0, res = 100000;
for (int i = 0; i <= 24; i++)
if ((1 << i) & status) cnt++;
for (int i = 0; i < idx; i++)
for (int j = 0; j <= i; j++)
if (in[i] + in[j] == in[idx]) {
int v =
dfs(status & ~(1 << idx) | (1 << (idx - 1)) | (1 << i) | (1 << j),
idx - 1);
res = min(res, max(cnt, v));
}
return dp[status] = res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", in + i);
int ac = dfs(1 << (n - 1), n - 1);
if (ac >= 100000)
puts("-1");
else
printf("%d\n", ac);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(char ch) {
string s;
s += ch;
return s;
}
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
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;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int maxn = 2e5 + 5;
const long long mod = 1e9 + 7;
vector<long long> fac(maxn), invfac(maxn);
long long expmod(long long x, long long n, long long mod) {
if (n == 0)
return 1;
else if (n % 2 == 0) {
long long temp = expmod(x, n / 2, mod);
return (temp * temp) % mod;
} else {
return (expmod(x, n - 1, mod) * x) % mod;
}
}
long long modinv(long long x, long long mod) { return expmod(x, mod - 2, mod); }
void find_fac() {
fac[0] = 1;
invfac[0] = 1;
for (int i = 1; i < maxn; i++) {
fac[i] = fac[i - 1] * i % mod;
invfac[i] = invfac[i - 1] * modinv(i, mod) % mod;
}
}
long long C(int n, int k) {
if (k > n)
return 0;
else {
return fac[n] * invfac[k] % mod * invfac[n - k] % mod;
}
}
void no() {
cout << "-1\n";
exit(0);
}
void solve() {
int n, m;
cin >> n >> m;
int a = n, b = m;
if (n > m) swap(n, m);
if (n == 1 && m == 2 || n == 1 && m == 3 || n == 2 && m == 2) {
no();
} else {
vector<vector<int> > ans(n, vector<int>(m));
int it = n * m;
if (it % 2 == 0) it--;
for (int j = (int)0; j < (int)m; j++) {
for (int i = (int)0; i < (int)n; i++) {
ans[i][j] = it;
if (it == 1) {
it = n * m;
if (it % 2 == 1) it--;
} else {
it -= 2;
}
}
}
if (n == a) {
for (int i = (int)0; i < (int)n; i++) {
for (int j = (int)0; j < (int)m; j++) {
cout << ans[i][j] << " ";
}
cout << "\n";
}
} else {
for (int j = (int)0; j < (int)m; j++) {
for (int i = (int)0; i < (int)n; i++) {
cout << ans[i][j] << " ";
}
cout << "\n";
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
int t = 1;
for (int tc = 1; tc <= t; tc++) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, valore, inizio, massimo = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> valore;
if (i == 1) inizio = valore;
if (valore < k) massimo = max(massimo, i + inizio - 1 - valore);
}
cout << massimo + k - inizio;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char x[110], y[110], z[110];
cin >> x;
cin >> y;
int i, len = strlen(x);
for (i = 0; i < len; i++) {
if (x[i] < y[i]) {
cout << -1;
return 0;
} else if (x[i] == y[i])
z[i] = x[i];
else
z[i] = y[i];
}
z[i] = '\0';
cout << z;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
double ret = 1;
if (m > (n + k)) {
ret = 0;
} else {
for (int i = 0; i <= k; i++) {
ret = ret * (m - i) / (n + i + 1);
}
ret = 1 - ret;
}
printf("%.9lf\n", ret);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
long long ncr(long long n, long long r) {
long long res = 1;
if (r > n) return 0;
if (r > n - r) r = n - r;
for (long long i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
struct cor {
int x, y;
};
bool pcheck(long long a) {
if (a == 2) return true;
for (long long i = 2; i <= sqrt(a); i++) {
if (a % i) continue;
return false;
}
return true;
}
const int MaxN = 2e5 + 10;
const int MAXN = 120 * 1000;
int cD(long long n) { return floor(log10(n) + 1); }
long long front[MaxN] = {0}, back[MaxN] = {0};
long long last = 1000000000007;
long long n, k, x, y, x2, x3, sum = 0, sum2 = 0, i, j, g, t, ans = 0, mid;
long long d1 = 0, d2 = 0;
long long q, c, r;
vector<pair<int, int>> p;
string s2, s;
char ccc[100];
long long n1, n2, nc, pc, m, h, zc, l, l2, l3, l4;
vector<long long> v;
long long an, bn, cn, dn;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
if (n & 1)
cout << "contest\n";
else
cout << "home\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<string> coef;
long long cast(string &s) {
int v = 0;
if (s[0] != '-') {
for (int i = 0; i < s.length(); ++i) v = 10 * v + s[i] - '0';
return v;
} else {
for (int i = 1; i < s.length(); ++i) v = 10 * v + s[i] - '0';
return -v;
}
}
long long edge = (1LL << 63) - 1;
int main() {
::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
long long k;
cin >> n >> k;
int calc = 0;
coef.resize(n + 1);
for (int i = 0; i < n + 1; ++i) {
string s;
cin >> s;
coef[i] = s;
if (s == "?") ++calc;
}
int moves = n + 1 - calc;
if (calc == 0) {
if (k == 0) {
if (coef[0] == "0")
cout << "Yes";
else
cout << "No";
return 0;
}
long long keep = 0;
for (int i = n; i >= 0; --i) {
long long val = cast(coef[i]);
if (abs(keep) >= edge / abs(k)) break;
keep *= k;
keep += val;
if (abs(keep) >= (long long)(i + 1) * 100000LL) break;
}
if (keep != 0) {
cout << "No";
return 0;
} else {
cout << "Yes";
return 0;
}
}
if (k == 0) {
if (coef[0] != "?" && coef[0] != "0") {
cout << "No";
return 0;
}
if (coef[0] == "?" && moves % 2 == 0) {
cout << "No";
return 0;
}
cout << "Yes";
} else {
if (moves % 2 == 0) {
if (calc % 2 == 0) {
cout << "Yes";
return 0;
} else {
cout << "No";
return 0;
}
} else {
if (calc % 2 == 0) {
cout << "No";
return 0;
} else {
cout << "Yes";
return 0;
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k, i, a, b, c, d;
long long int sum;
long long int s[300000];
while (scanf("%lld %lld %lld", &n, &m, &k) != EOF) {
sum = 0;
for (i = 0; i < n; i++) {
scanf("%lld", &s[i]);
}
sort(s, s + n);
a = s[n - 1];
b = s[n - 2];
c = m / (k + 1);
d = m % (k + 1);
sum = (a * k + b) * c + a * d;
printf("%lld\n", sum);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
vector<pair<pair<long long int, long long int>, long long int> > vp;
map<long long int, long long int> mp, mpp;
vector<long long int> v, v1, v2;
long long int dp[N], visit[N];
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " ";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, val, k, d, mi = 1e9, mx(0);
long long int sum(0), ct(0), p(0), q(0);
string s;
cin >> n >> m;
long long int a[n];
if (n == 2 and m == 1) {
cout << 2 << ' ' << 2 << endl;
cout << 1 << ' ' << 2 << ' ' << 2;
return 0;
}
vp.push_back({{1, n}, 2});
if (m >= n) vp.push_back({{n - 1, n}, 1000000000});
val = p = 1002581;
for (int i = 1; i < n - 2; i++) {
vp.push_back({{i, i + 1}, 1});
val--;
}
m = m - n;
if (m > 0) {
for (int i = 1; i <= n; i++) {
for (int j = i + 2; j <= n; j++) {
if (!(i == 1 and j == n)) {
vp.push_back({{i, j}, 1000000000});
m--;
if (m == 0) {
break;
}
}
}
if (m == 0) {
break;
}
}
}
vp.push_back({{n - 2, n - 1}, val});
cout << 2 << ' ' << p + 2 << endl;
for (auto it : vp) {
cout << it.first.first << ' ' << it.first.second << ' ' << it.second
<< endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const long long inf64 = 1e18;
const long long MOD = inf + 7;
const long long N = 1e5 + 5;
const long long LG = 35;
long long mn[N][LG];
long long sum[N][LG];
long long par[N][LG];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (long long i = 0; i < N; i++)
for (long long j = 0; j < LG; j++) mn[i][j] = LLONG_MAX;
long long n, k;
cin >> n >> k;
long long p[n], w[n];
for (long long i = 0; i < n; i++) {
cin >> p[i];
}
for (long long i = 0; i < n; i++) {
cin >> w[i];
mn[i][0] = w[i];
sum[i][0] = w[i];
par[i][0] = p[i];
}
for (long long i = 1; i < LG; i++) {
for (long long j = 0; j < n; j++) {
par[j][i] = par[par[j][i - 1]][i - 1];
sum[j][i] += sum[par[j][i - 1]][i - 1] + sum[j][i - 1];
mn[j][i] = min(mn[par[j][i - 1]][i - 1], mn[j][i - 1]);
}
}
for (long long i = 0; i < n; i++) {
long long res = 0, mini = LLONG_MAX;
long long node = i;
for (long long j = 0; j < LG; j++) {
if (k >> j & 1) {
res += sum[node][j];
mini = min(mini, mn[node][j]);
node = par[node][j];
}
}
cout << res << " " << mini << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
vector<int> C[2][2];
int n;
char str[10];
void solve() {
int c = 0;
long long ans = 0;
for (int k = 0; k < C[1][1].size(); k++) ans += C[1][1][k], c++;
while (!C[0][1].empty() && !C[1][0].empty()) {
ans += C[0][1].back() + C[1][0].back();
C[0][1].pop_back();
C[1][0].pop_back();
}
int curi, curj;
if (C[0][1].empty())
curi = 1, curj = 0;
else
curi = 0, curj = 1;
int rem = c;
for (int k = 0; k < C[curi][curj].size(); k++)
C[0][0].push_back(C[curi][curj][k]);
sort(((C[0][0]).begin()), ((C[0][0]).end()));
while (!C[0][0].empty() && rem > 0) {
rem--;
ans += C[0][0].back();
C[0][0].pop_back();
}
printf("%lld\n", ans);
}
int main() {
read_file();
while (scanf("%d", &n) != -1) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) C[i][j].clear();
for (int i = 0; i < n; i++) {
int x;
scanf(" %s %d", str, &x);
str[0] -= '0';
str[1] -= '0';
C[str[0]][str[1]].push_back(x);
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) sort(((C[i][j]).begin()), ((C[i][j]).end()));
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vec = vector<T>;
template <typename Iter>
ostream &_IterOutput_(ostream &o, Iter b, Iter e, const string ss = "",
const string se = "") {
o << ss;
for (auto it = b; it != e; it++) o << (it == b ? "" : ", ") << *it;
return o << se;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &o, pair<T1, T2> &pair) {
return o << "(" << pair.first << ", " << pair.second << ")";
}
template <typename T>
ostream &operator<<(ostream &o, const vector<T> &vec) {
return _IterOutput_(o, begin(vec), end(vec), "[", "]");
}
template <typename T>
ostream &operator<<(ostream &o, const set<T> &st) {
return _IterOutput_(o, begin(st), end(st), "{", "}");
}
template <typename T, size_t N>
ostream &operator<<(ostream &o, const array<T, N> &arr) {
return _IterOutput_(o, begin(arr), end(arr), "|", "|");
}
inline int lb(int a) { return a & (-a); }
const int MX = 812345;
struct BIT {
int v[MX];
int qry(int a) {
a += 2;
int res = 0;
while (a) {
res = max(res, v[a]);
a -= lb(a);
}
return res;
}
void chg(int a, int vv) {
a += 2;
while (a < MX) {
v[a] = max(v[a], vv);
a += lb(a);
}
}
void init() { memset((v), 0, sizeof(v)); }
} b1;
int N, Q;
vec<int> ip;
vec<pair<int, int> > qry;
vector<pair<int, int> > qq[MX];
vec<int> vs;
int lans[MX], rans[MX];
bool isinp[MX];
int dp[MX];
bool cvt[MX];
int anscnt[MX];
int a1[MX], a2[MX];
int32_t main() {
do {
ios_base::sync_with_stdio(0);
cin.tie(0);
} while (0);
cin >> N >> Q;
ip.resize(N);
for (int(i) = 0; (i) < (N); (i)++) {
cin >> ip[i];
vs.push_back(ip[i]);
}
qry.resize(Q);
for (int(i) = 0; (i) < (Q); (i)++) {
int a, b;
cin >> a >> b;
a--;
vs.push_back(b);
qry[i] = {a, b};
}
sort(begin(vs), end(vs));
vs.resize(unique(begin(vs), end(vs)) - vs.begin());
for (auto &x : ip) x = lower_bound(begin(vs), end(vs), x) - vs.begin();
for (int(i) = 0; (i) < (Q); (i)++) {
auto p = qry[i];
int t = lower_bound(begin(vs), end(vs), p.second) - vs.begin();
p.second = t;
qq[p.first].push_back({t, i});
}
int totans = 0;
for (int i = 0; i < N; i++) {
int v = ip[i];
int bv = b1.qry(v - 1) + 1;
dp[i] = bv;
b1.chg(v, bv);
totans = max(totans, bv);
}
static int tmp[MX];
for (int i = N - 1; i >= 0; i--) {
int v = ip[i];
int d = dp[i];
if (d == totans) {
cvt[i] = 1;
anscnt[d]++;
tmp[d] = max(tmp[d], v);
} else {
int cc = tmp[d + 1];
if (cc > v) {
cvt[i] = 1;
anscnt[d]++;
tmp[d] = max(tmp[d], v);
}
}
}
for (int(i) = 0; (i) < (N); (i)++) {
if (cvt[i] and anscnt[dp[i]] == 1) isinp[i] = 1;
;
}
b1.init();
for (int(i) = 0; (i) < (N); (i)++) {
for (auto q : qq[i]) {
int qv = q.first, qid = q.second;
a1[qid] = b1.qry(qv - 1);
}
b1.chg(ip[i], b1.qry(ip[i] - 1) + 1);
}
b1.init();
int MAG = N + Q;
for (int(i) = (N - 1); (i) != (-1); (i) += ((-1) > (N - 1) ? 1 : -1)) {
for (auto q : qq[i]) {
int qv = q.first, qid = q.second;
a2[qid] = b1.qry(MAG - (qv + 1));
}
b1.chg(MAG - ip[i], b1.qry(MAG - (ip[i] + 1)) + 1);
}
for (int(i) = 0; (i) < (Q); (i)++) {
auto q = qry[i];
int j = q.first;
int ans;
if (isinp[j]) {
ans = max(totans - 1, a1[i] + a2[i] + 1);
;
} else {
ans = max(totans, a1[i] + a2[i] + 1);
}
cout << ans << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b;
cin >> a >> b;
if (a % b == 0) {
cout << a % b << endl;
} else {
cout << (b - a % b) << endl;
}
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define For(i,x,y) for (register int i=(x);i<=(y);i++)
#define FOR(i,x,y) for (register int i=(x);i<(y);i++)
#define Dow(i,x,y) for (register int i=(x);i>=(y);i--)
#define Debug(v) for (auto i:v) cout<<i<<" ";puts("")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ep emplace_back
#define siz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define fil(a,b) memset((a),(b),sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pa;
typedef pair<ll,ll> PA;
typedef vector<int> poly;
inline ll read(){
ll x=0,f=1;char c=getchar();
while ((c<'0'||c>'9')&&(c!='-')) c=getchar();
if (c=='-') f=-1,c=getchar();
while (c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
const int N = 1e5+10, M = 1010;
int n,q,B,a[N],id[N],cnt[M];
int b[M],tag[M<<2];
pa mn[M<<2];
inline void Build(int u,int l,int r){
tag[u]=0;
if (l==r) return mn[u]=mp(b[l],l),void(0);
int mid=l+r>>1;
Build(u<<1,l,mid),Build(u<<1^1,mid+1,r);
mn[u]=min(mn[u<<1],mn[u<<1^1]);
}
inline void update(int u,int l,int r,int ql){
if (l>ql) return tag[u]--,mn[u].fi--,void(0);
if (l==r) return mn[u]=mp(1e9,l),void(0);
int mid=l+r>>1;
update(u<<1^1,mid+1,r,ql);
if (ql<=mid) update(u<<1,l,mid,ql);
mn[u]=min(mn[u<<1],mn[u<<1^1]),mn[u].fi+=tag[u];
}
int v[M][M];
inline void ReBuild(int id){
int l=(id-1)*B+1,r=min(id*B,n),cnt=0;
For(i,l,r) b[++cnt]=a[i];
Build(1,1,cnt);
For(i,1,cnt){
int tmp=mn[1].fi;
v[id][i]=max(tmp,v[id][i-1]),update(1,1,cnt,mn[1].se);
}
}
inline int Query(int x){
int y=a[x];
For(i,x+1,min(id[x]*B,n)) y+=(y>=a[i]);
For(i,id[x]+1,id[n]){
int tmp=upper_bound(v[i]+1,v[i]+cnt[i]+1,y)-v[i]-1;
y+=tmp;
}
return n-y;
}
int main(){
n=read(),B=200;
For(i,1,n) a[i]=read(),id[i]=(i-1)/B+1,cnt[id[i]]++;
For(i,1,id[n]) ReBuild(i);
q=read();
while (q--){
int op=read(),x=read();
if (op==1){
int y=read();
a[x]=y,ReBuild(id[x]);
} else {
printf("%d\n",Query(x));
}
}
} | 12 |
#include <bits/stdc++.h>
using namespace std;
char str[100010];
int cnt[3];
int aux;
int l, r;
int main() {
scanf("%s", str);
int tam = strlen(str);
cnt[0] = cnt[1] = cnt[2] = 0;
for (int i = 0; i < tam; i++) {
if (str[i] == '?')
cnt[2]++;
else
cnt[str[i] - '0']++;
}
if (str[tam - 1] == '?')
aux = 2;
else
aux = str[tam - 1] - '0';
int aa = (tam - 1) / 2;
int bb = (tam - 2) / 2;
if (aa >= cnt[1]) puts("00");
r = aa + 1 - cnt[1];
l = bb + 1 - cnt[0];
if (r >= 0 && l >= 0) {
if (aux == 1)
puts("01");
else if (aux == 0)
puts("10");
else {
if (r >= 1) puts("01");
if (l >= 1) puts("10");
}
}
if (bb >= cnt[0]) puts("11");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4003, P = 1e9 + 9;
int n, w, b, jc[N << 1];
inline void in(register int &x) {
int f = 0;
x = 0;
char c = getchar();
while (c < '0' || c > '9') f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x = f ? -x : x;
}
inline int mi(register int x, register int k) {
register int s = 1;
while (k) {
if (k & 1) s = (long long)s * x % P;
x = (long long)x * x % P, k >>= 1;
}
return s;
}
inline int inv(register int x) { return mi(x, P - 2); }
inline int C(register int m, register int n) {
return (long long)jc[n] * inv(jc[n - m]) % P * inv(jc[m]) % P;
}
int main() {
in(n), in(w), in(b), jc[0] = 1;
for (register int i = 1; i <= w + b; ++i)
jc[i] = (long long)jc[i - 1] * i % P;
printf("%d\n",
(long long)C(n - 3, w + b - 3) * (w - 1) % P * jc[w] % P * jc[b] % P);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, t1, t2;
int main() {
cin >> a >> b >> c >> d;
t1 = max(3 * a / 10, a - (a / 250) * c);
t2 = max(3 * b / 10, b - (b / 250) * d);
if (t1 > t2) {
cout << "Misha";
return 0;
}
if (t1 < t2) {
cout << "Vasya";
return 0;
}
cout << "Tie";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[200], b[200];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
printf("0 ");
b[1] = a[1];
for (int i = 2; i <= n; ++i) {
int t = m - a[i];
sort(b + 1, b + i);
int j = 1;
while (t >= b[j] && j < i) {
t -= b[j];
++j;
}
printf("%d ", i - j);
for (j = 1; j <= i; ++j) b[i] = a[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a = -1, b, c;
for (int i = 0; i <= 100; i++) {
for (int j = 0; j <= 100; j++) {
for (int k = 0; k <= 100; k++) {
if (3 * i + 5 * j + 7 * k == n) {
a = i, b = j, c = k;
}
}
}
}
if (a != -1)
cout << a << " " << b << " " << c << "\n";
else
cout << "-1\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[5555];
long long h1[5555], h2[5555];
long long pw[5555];
int n;
int is[5555][5555] = {};
void pre() {
pw[0] = 1;
for (int i = 1; i < n + 1; i++) pw[i] = pw[i - 1] * 230617;
h1[0] = 0;
for (int i = 0; i < n; i++) h1[i + 1] = h1[i] * 230617 + s[i];
h2[0] = 0;
for (int i = n - 1; i >= 0; i--) h2[n - i] = h2[n - i - 1] * 230617 + s[i];
}
long long hs1(int i, int j) { return h1[j + 1] - h1[i] * pw[j - i + 1]; }
long long hs2(int i, int j) { return h2[j + 1] - h2[i] * pw[j - i + 1]; }
bool palin(int i, int j) { return hs1(i, j) == hs2(n - j - 1, n - i - 1); }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
scanf("%s", s);
n = strlen(s);
pre();
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
if (palin(i, j)) is[i][j] = 1;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) is[i][j] += is[i][j - 1];
for (int i = 1; i < n; i++)
for (int j = i - 1; j < n; j++) is[i][j] += is[i - 1][j];
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
printf("%d\n", is[r][r] - (l == 0 ? 0 : is[l - 1][r]));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long MOD) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
const int maxn = 1e5 + 10;
const int maxa = 1e4 + 10;
struct Point {
int v, id;
bool operator<(const Point& rhs) const { return rhs.v < this->v; }
} a[maxn];
int n, sum1, sum2;
vector<int> v1, v2;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i].v);
a[i].id = i;
}
sort(a, a + n);
for (int i = 0; i + 1 < n; i += 2) {
if (sum1 < sum2) {
sum1 += a[i + 1].v;
v1.push_back(a[i + 1].id);
sum2 += a[i].v;
v2.push_back(a[i].id);
} else {
sum1 += a[i].v;
v1.push_back(a[i].id);
sum2 += a[i + 1].v;
v2.push_back(a[i + 1].id);
}
}
if (n & 1) {
if (sum1 < sum2) {
sum1 += a[n - 1].v;
v1.push_back(a[n - 1].id);
} else {
sum2 += a[n - 1].v;
v2.push_back(a[n - 1].id);
}
}
printf("%d\n", (int)v1.size());
for (int c : v1) printf("%d ", c + 1);
printf("\n");
printf("%d\n", (int)v2.size());
for (int c : v2) printf("%d ", c + 1);
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int parent[500500];
int siz[500500];
int findRoot(int x) {
if (parent[x] == x) return x;
return parent[x] = findRoot(parent[x]);
}
void unite(int x, int y) {
int rx = findRoot(x);
int ry = findRoot(y);
if (rx == ry) return;
parent[rx] = ry;
siz[ry] += siz[rx];
}
int findSize(int x) { return siz[findRoot(x)]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
parent[i] = i;
siz[i] = 1;
}
int k, x, y;
for (int i = 0; i < m; i++) {
cin >> k;
for (int j = 0; j < k; j++) {
if (j == 0)
cin >> x;
else {
cin >> y;
int rx = findRoot(x), ry = findRoot(y);
if (rx == ry) continue;
parent[rx] = ry;
siz[ry] += siz[rx];
x = y;
}
}
}
for (int i = 1; i <= n; i++) cout << siz[findRoot(i)] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int m, n, x, y;
int main() {
cin >> n >> m;
if ((min(n - m, m) >= 2 && m < 4) || (min(n - m, m) >= 1 && m < 3))
cout << -1 << endl;
else {
x = 0;
y = 12345;
for (long i = 1; i <= m; i++) {
cout << x << " " << y << endl;
x -= m - i + 1;
y++;
}
x = 0;
y = -12345;
for (long i = 1; i <= n - m; i++) {
cout << x << " " << y << endl;
x -= m - i + 1;
y--;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T inline sqr(T x) {
return x * x;
}
template <class T>
inline T myAbs(T a) {
return a > 0 ? a : -a;
}
struct lol {
int m, v, n;
double h;
};
vector<lol> a;
bool compr(lol a, lol b) {
if (a.m == b.m) return a.v > b.v;
return a.m > b.m;
}
int main() {
int n, k, h;
vector<int> res, our;
cin >> n >> k >> h;
a.resize(n);
res.resize(k);
our.resize(k);
for (int i = 0; i < (int)(n); ++i) {
scanf("%d", &a[i].m);
}
for (int i = 0; i < (int)(n); ++i) {
scanf("%d", &a[i].v);
a[i].n = i + 1;
}
double l = 0;
double r = 2000000000.0;
bool yes = false;
sort(a.begin(), a.end(), compr);
for (int test = 0; test < (int)(500); ++test) {
double t = (l + r) / 2;
for (int i = 0; i < (int)(n); ++i) {
a[i].h = 1.0 * t * a[i].v;
}
int j = k;
res.clear();
res.resize(k);
for (int i = 0; i < (int)(n); ++i) {
if (j == 0) break;
if (a[i].h >= j * h) res[j - 1] = a[i].n, --j;
}
if (j > 0) {
l = t;
} else {
r = t;
our = res;
}
}
for (int i = 0; i < (int)(k - 1); ++i) {
cout << our[i] << " ";
}
cout << our[k - 1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x[100100], y[100100], t[100100];
int dp[100100];
int r, n;
int dis(int i, int j) { return abs(x[i] - x[j]) + abs(y[i] - y[j]); }
int main() {
ios::sync_with_stdio(false);
cin >> r >> n;
for (int i = (1); i <= (n); i++) cin >> t[i] >> x[i] >> y[i];
x[0] = y[0] = 1, t[0] = dp[0] = 0;
int mx = -0x3f3f3f3f, pos = -1;
for (int i = (1); i <= (n); i++) {
int j = i - 1;
dp[i] = -0x3f3f3f3f;
while (j >= 0 && t[i] - t[j] < 2 * r) {
if (dis(i, j) <= t[i] - t[j]) dp[i] = max(dp[i], dp[j] + 1);
j--;
}
for (int k = (pos + 1); k <= (j); k++) mx = max(mx, dp[k] + 1);
pos = j;
dp[i] = max(dp[i], mx);
}
int ans = 0;
for (int i = (1); i <= (n); i++) ans = max(ans, dp[i]);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 7;
const long long INF = (long long)1e18;
int n;
int m;
vector<pair<int, int>> g[N];
long long dist[N];
int par[N];
int t[N];
int root(int x) {
if (t[x] == x) {
return x;
} else {
return t[x] = root(t[x]);
}
}
void unite(int x, int y) { t[root(x)] = root(y); }
struct T {
int x;
long long d;
};
bool operator<(T a, T b) { return a.d > b.d; }
struct edge {
int x;
int y;
long long d;
};
bool operator<(edge a, edge b) { return a.d < b.d; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y, z;
cin >> x >> y >> z;
g[x].push_back({y, z});
g[y].push_back({x, z});
}
for (int i = 1; i <= n; i++) {
t[i] = i;
dist[i] = INF;
}
priority_queue<T> pq;
int cnt;
cin >> cnt;
for (int i = 1; i <= cnt; i++) {
int portal;
cin >> portal;
dist[portal] = 0;
par[portal] = portal;
pq.push({portal, 0});
}
while (!pq.empty()) {
int x = pq.top().x;
long long d = pq.top().d;
pq.pop();
if (d != dist[x]) {
continue;
}
for (auto &it : g[x]) {
int y = it.first;
long long dy = dist[x] + it.second;
if (dy < dist[y]) {
dist[y] = dy;
par[y] = par[x];
pq.push({y, dy});
}
}
}
vector<edge> e;
for (int i = 1; i <= n; i++) {
for (auto &it : g[i]) {
int j = it.first;
int c = it.second;
if (par[i] != par[j]) {
e.push_back({par[i], par[j], c + dist[i] + dist[j]});
}
}
}
long long sol = dist[1];
sort(e.begin(), e.end());
for (auto &it : e) {
if (root(it.x) != root(it.y)) {
unite(it.x, it.y);
sol += it.d;
}
}
cout << sol << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
static char buf[1000000], *p1 = buf, *p2 = buf;
inline void read(long long &x) {
int f = 1;
x = 0;
char c =
p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
x *= f;
}
inline long long gcd(long long x, long long y) {
if (!y) return x;
return gcd(y, x % y);
}
int main() {
long long a, b, c, t, g;
read(t);
while (t--) {
read(a);
read(b);
read(c);
g = gcd(a, b);
a /= g;
b /= g;
if (a > b) swap(a, b);
if ((c - 1) * a + 1 >= b)
puts("OBEY");
else
puts("REBEL");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int i = 1, j = n;
bool left = true;
while (k > 1 && i < j) {
if (left)
cout << i++ << " ";
else
cout << j-- << " ";
left = !left;
k--;
}
if (left)
while (i <= j) {
cout << i << " ";
i++;
}
else
while (i <= j) {
cout << j << " ";
j--;
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[10000000] = {0}, su[1000005];
void fun() {
int i, j;
for (i = 2; i < 1400000; i++)
for (j = 2; j * i <= 1400000; j++) a[i * j] = 1;
j = 0;
for (i = 2; i < 1400000; i++)
if (a[i] == 0) su[j++] = i;
}
int main() {
int n;
fun();
while (cin >> n) {
int i;
for (i = 0; i < n; i++) printf("%d ", su[i]);
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> x(n), y(n), z(n), ind(n);
for (int i = int(0); i <= int(n - 1); i++) ind[i] = i + 1;
for (int i = int(0); i <= int(n - 1); i++) {
scanf("%lld%lld%lld", &x[i], &y[i], &z[i]);
}
long long mm, idx, val, j;
for (int i = int(1); i <= int(n / 2); i++) {
mm = 1000000000000000000;
j = 1;
while (j < x.size()) {
val = (x[0] - x[j]) * (x[0] - x[j]) + (y[0] - y[j]) * (y[0] - y[j]) +
(z[0] - z[j]) * (z[0] - z[j]);
if (val < mm) {
mm = val;
idx = j;
}
j++;
}
cout << ind[0] << " " << ind[idx] << endl;
if (i < n / 2) {
x.erase(x.begin() + idx);
x.erase(x.begin());
y.erase(y.begin() + idx);
y.erase(y.begin());
z.erase(z.begin() + idx);
z.erase(z.begin());
ind.erase(ind.begin() + idx);
ind.erase(ind.begin());
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
char work[105];
int len, n, dp[2][105 << 1][105][52];
int dfs(bool dre, int pos, int i, int cn) {
if (cn < 0) return 0;
if (!work[i]) return cn > 0 ? 0 : abs(pos);
int &ret = dp[dre][pos + 100][i][cn];
if (ret != -1) return ret;
int mv = dre ? 1 : -1;
return ret = max(dfs(dre, pos + mv, i + 1, cn - (work[i] != 'F')),
dfs(!dre, pos, i + 1, cn - (work[i] != 'T')));
}
int main(void) {
int ans = 0;
scanf("%s%d", work, &n);
memset(dp, -1, sizeof(dp));
for (; n >= 0; n -= 2) ans = max(ans, dfs(1, 0, 0, n));
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
int a[N], b[N];
for (int i = 0; i < N; i++) {
scanf("%d%d", &a[i], &b[i]);
}
int fst = b[0], sum = a[0], rslt = 0;
for (int i = 1; i < N; i++) {
if (b[i] < fst) {
rslt += sum * fst;
fst = b[i], sum = a[i];
} else
sum += a[i];
}
rslt += sum * fst;
printf("%d\n", rslt);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a;
cin >> a;
if (a % 10 == 9) {
cout << a / 10 + 1 << endl;
return;
}
cout << a / 10 << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long ret = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret * f;
}
const long long maxn = 100005;
long long n, ans = 1, first = 1;
string s, now;
signed main() {
n = read();
long long zero = 0;
s = "1";
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
for (long long i = 1; i <= n; i++) {
now = "";
bool flg = true, hav1 = false;
long long zn = 0;
while (ch >= '0' && ch <= '9') {
now = now + ch;
if (ch != '0' && ch != '1') {
flg = false;
} else if (ch == '1') {
if (hav1)
flg = false;
else
hav1 = true;
} else
zn++;
ch = getchar();
}
if (flg && zn == 1 && hav1 == false) {
cout << 0 << endl;
return 0;
}
if (flg)
zero += zn;
else
s = now;
if (i == n) break;
while (ch < '0' || ch > '9') ch = getchar();
}
cout << s;
for (long long i = 1; i <= zero; i++) putchar('0');
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
const double EPS = 1e-9;
const int INT_INF = 1 << 31 - 1;
const long long I64_INF = 1ll << 63 - 1ll;
const double PI = acos(-1.0);
using namespace std;
long long solve(int len) {
if (len == 1 || len == 2) return 9LL;
long long pow = 1LL;
for (int i = 0; i < len - 2; i++) pow *= 10LL;
return 9LL * pow;
}
long long go(long long r) {
if (r <= 0) return 0;
int len = 0;
long long R = r;
long long c[20];
while (R) c[len] = R % 10LL, len++, R /= 10LL;
long long res = 0;
for (int i = 1; i < len; i++) res += solve(i);
for (int i = 0; i < (int)len / 2; i++) swap(c[i], c[len - i - 1]);
long long pow = 1LL;
for (int i = 0; i < len - 2; i++) pow *= 10LL;
res += (c[0] - 1LL) * pow;
long long mid = 0;
for (int i = 1; i <= len - 2; i++) mid = mid * 10LL + 1LL * c[i];
if (c[0] <= c[len - 1])
res += mid + 1LL;
else
res += mid;
return res;
};
bool ok(int a) {
int last = a % 10;
int first;
while (a) first = a % 10, a /= 10;
return first == last;
}
long long l, r;
int main() {
cin >> l >> r;
cout << go(r) - go(l - 1) << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int pv[10000010], phi[10000010], mn[10000010], np;
int cnt[10000010];
void pre() {
for (int i = 2; i < 10000010; i++) {
if (!mn[i]) {
pv[np++] = i;
mn[i] = i;
}
for (int j = 0; j < np && pv[j] * i < 10000010; j++) {
mn[i * pv[j]] = pv[j];
if (mn[i] == pv[j]) break;
}
}
for (int i = 1; i < 10000010; i++) phi[i] = i;
for (int i = 2; i < 10000010; i += 2) phi[i] >>= 1;
for (int i = 3; i < 10000010; i += 2) {
if (phi[i] == i) {
for (int j = i; j < 10000010; j += i) phi[j] -= phi[j] / i;
}
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pre();
int n;
cin >> n;
long long cnt0 = 1, cnt1 = 0, cnt2 = 0, cnt3 = 0;
long long tot = 1LL * n * (n - 1) / 2;
for (int i = 2; i <= n; i++) {
if (mn[i] == i && mn[i] > n / 2) cnt0++;
}
cnt0 = n - cnt0;
cnt0 = tot - cnt0 * (cnt0 - 1) / 2;
cnt1 = tot;
for (int i = 2; i <= n; i++) cnt1 -= phi[i];
for (int i = 2; i <= n; i++) cnt[mn[i]]++;
for (int i = n; i >= 2; i--) cnt[i] += cnt[i + 1];
long long tmp = 0;
for (int v = 2; v <= n; v++) {
int x = n / mn[v] + 1;
tmp += cnt[x];
if (mn[v] > n / mn[v]) tmp--;
}
cnt2 = tot - cnt1 - tmp / 2 - (n - 1);
cnt3 = tot - cnt0 - cnt1 - cnt2;
long long ans = cnt1 + 2 * cnt2 + 3 * cnt3;
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n == 1)
cout << "05" << endl;
else
cout << 25 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 10;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
bool pal(string s) {
for (int i = 0; i < s.size() / 2; i++) {
if (s[i] != s[s.size() - i - 1]) {
return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
for (int i = 0; i < t; i++) {
string s;
cin >> s;
if (pal(s)) {
cout << s << '\n';
continue;
}
bool d = false;
string l = "", r = "";
while (s[0] == s[s.size() - 1]) {
l += s[0], r = s[0] + r;
s = s.substr(1, s.size() - 2);
}
for (int j = s.size() - 1; j >= 0; j--) {
if (pal(s.substr(0, j))) {
cout << l + s.substr(0, j) + r;
d = true;
break;
}
if (pal(s.substr(s.size() - j, s.size()))) {
cout << l + s.substr(s.size() - j, s.size()) + r;
d = true;
break;
}
}
cout << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, i, j;
string s, s1;
cin >> s >> s1;
long long sum = 0;
for (i = 1; i <= s1.length() - 1; i++) {
char aa, bb;
aa = s1[i];
bb = s1[i - 1];
long long a, b;
a = s.find(aa);
b = s.find(bb);
sum += abs(a - b);
}
cout << sum << endl;
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long i64;
typedef unsigned long long ui64;
typedef vector<i64> vi;
typedef vector<vi> vvi;
typedef pair<i64, i64> pi;
#define pb push_back
#define sz(a) i64((a).size())
#define all(c) (c).begin(), (c).end()
#define REP(s, e, i) for(i=(s); i < (e); ++i)
inline void RI(i64 &i) {scanf("%lld", &(i));}
inline void RVI(vi &v) { for(i64 i=0;i<sz(v);++i) { RI(v[i]); } }
inline void RVVI(vvi &vv) { for(i64 i=0;i<sz(vv);++i) { RVI(vv[i]); } }
inline void WI(const i64 &i) {printf("%lld\n", i);}
inline void WVI(const vi &v, char sep=' ') { for(i64 i=0;i<sz(v);++i) { if(i != 0){ printf("%c", sep); } printf("%lld", v[i]);} printf("\n"); }
inline void WS(const string &s) { printf("%s\n", s.c_str()); }
inline void WB(bool b, const string &yes, const string &no) { if(b){ WS(yes);} else { WS(no);} }
inline void YESNO(bool b) { WB(b, "YES", "NO"); }
#define BUF_LENGTH 1000000
inline void RS(string &s) {static char buf[BUF_LENGTH]; scanf("%s", buf); s = buf;}
template<typename T> inline bool IN(T &S, const typename T::key_type &key) {
return S.find(key) != S.end();
}
int main(int argc, char *argv[]) {
i64 i, j, k;
i64 t, T;
RI(T);
REP(0, T, t) {
i64 n; RI(n);
unordered_multiset<i64> S;
REP(0, n, i) {
i64 a; RI(a);
S.insert(a);
}
vi ans;
i = 0;
while(IN(S, i)) {
ans.pb(i);
auto it = S.find(i);
assert(it != S.end());
S.erase(it);
++i;
}
for(auto &s: S) {
ans.pb(s);
}
WVI(ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, i, j, t, k, lie, m, n, o, s = 0, x, y, z, ar[100010];
vector<long long> v;
scanf("%lld %lld", &n, &x);
while (n--) {
scanf("%lld %lld", &a, &b);
if (a >= b)
s += b;
else {
s += a;
y = a * 2;
if (b >= y)
v.push_back(a);
else
v.push_back(b - a);
}
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
z = min(x, (long long)v.size());
for (i = 0; i < z; i++) s += v[i];
cout << s << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, res = 0, i, t, t2 = 1;
cin >> n;
vector<int> v;
for (long long int i = 0; i < n; i++) {
long long int a;
cin >> a;
v.push_back(a);
};
t = v[1] - v[0];
for (i = 2; i < n; i++) {
if ((v[i] - v[i - 1]) != t) t2 = 0;
}
if (t2 == 0)
cout << v[n - 1] << endl;
else
cout << (v[n - 1] + t) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MIN = 1e3 + 2;
const int MXN = 2e6 + 3;
const int INF = 1e9 + 7;
const int base = 1e9;
const long long LINF = 1e18 + 15;
const double EPS = 1e-9;
int n;
long long a[MXN], pref[MXN], mx = -1, id;
int mn = INF;
int s, f;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
cin >> s >> f;
int st = s;
s = f - s;
for (int i = n + 1; i < n * 2; ++i) {
a[i] = a[i - n];
}
for (int i = 1; i < n * 2; ++i) {
pref[i] = pref[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
if (pref[i + s - 1] - pref[i - 1] > mx) {
mx = pref[i + s - 1] - pref[i - 1];
id = i;
int d = id - 1;
if (st - d >= 1)
mn = st - d;
else
mn = n - (d - st);
} else if (pref[i + s - 1] - pref[i - 1] == mx) {
int d = i - 1;
if (st - d >= 1) {
if (st - d < mn) {
mn = st - d;
id = i;
}
} else {
if (n - (d - st) < mn) {
mn = n - (d - st);
id = i;
}
}
}
}
cout << mn;
return 0;
}
| 4 |
#include <bits/stdc++.h>
void divpow(int *x1, int *x2, int d, int p) {
int i;
for (i = 0; i < p; i++) {
if (*x1 % d == 0) {
*x1 /= d;
*x1 *= d - 1;
} else {
*x2 /= d;
*x2 *= d - 1;
}
}
}
int get_pow(long long *x, int d) {
int result = 0;
while (*x % d == 0) {
*x /= d;
result++;
}
return result;
}
int main() {
int a1, a2, b1, b2;
long long a, b;
int apow2, apow3, bpow2, bpow3;
int minutes;
scanf("%d %d\n", &a1, &a2);
scanf("%d %d\n", &b1, &b2);
a = a1 * (long long)a2;
b = b1 * (long long)b2;
apow2 = get_pow(&a, 2);
bpow2 = get_pow(&b, 2);
apow3 = get_pow(&a, 3);
bpow3 = get_pow(&b, 3);
if (a != b) {
printf("-1\n");
return 0;
}
minutes = 0;
if (apow3 > bpow3) {
minutes += apow3 - bpow3;
apow2 += apow3 - bpow3;
divpow(&a1, &a2, 3, apow3 - bpow3);
} else if (bpow3 > apow3) {
minutes += bpow3 - apow3;
bpow2 += bpow3 - apow3;
divpow(&b1, &b2, 3, bpow3 - apow3);
}
if (apow2 > bpow2) {
minutes += apow2 - bpow2;
divpow(&a1, &a2, 2, apow2 - bpow2);
} else if (bpow2 > apow2) {
minutes += bpow2 - apow2;
divpow(&b1, &b2, 2, bpow2 - apow2);
}
printf("%d\n%d %d\n%d %d\n", minutes, a1, a2, b1, b2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct chash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long power(long long a, long long n) {
long long res = 1;
while (n != 0) {
if (n % 2) {
res = res * a;
n--;
} else {
a = a * a;
n = n / 2;
}
}
return res;
}
long long powermod(long long a, long long n, long long m) {
long long res = 1;
while (n != 0) {
if (n % 2) {
res = (res % m * a % m) % m;
n--;
} else {
a = (a % m * a % m) % m;
n = n / 2;
}
}
return res % m;
}
void jiejue() {
int n, k;
cin >> n >> k >> ws;
string s;
cin >> s;
string t;
string x = "()";
if (k == s.length() / 2) {
while (k--) t += x;
} else {
k = k - 1;
while (k--) t += x;
int p = (s.length() - t.length()) / 2;
int q = p;
while (p--) t += '(';
while (q--) t += ')';
}
vector<pair<int, int>> op;
for (int i = 0; i < n - 1; i++) {
if (s[i] == t[i]) continue;
int j = i;
while (s[j] != t[i] && j < n) j++;
reverse(s.begin() + i, s.begin() + j + 1);
op.push_back(make_pair(i + 1, j + 1));
}
cout << op.size() << '\n';
for (int i = 0; i < op.size(); i++) {
cout << op[i].first << " " << op[i].second << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int teseuteu;
cin >> teseuteu;
while (teseuteu--) jiejue();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int arr[100010];
bool cmp(int a, int b) { return a % 10 > b % 10; }
int main() {
while (cin >> n >> k) {
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, cmp);
for (int i = 0; i < n; i++) {
int t = min(100, (arr[i] / 10 + 1) * 10) - arr[i];
if (k >= t) {
arr[i] += t;
k -= t;
} else
break;
}
for (int i = 0; i < n; i++) {
int t = min(k, 100 - arr[i]);
arr[i] += t;
k -= t;
if (k == 0) break;
}
int ans = 0;
for (int i = 0; i < n; i++) ans += arr[i] / 10;
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int e[25];
int f[1 << 22], pres[1 << 22], prep[1 << 22];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
e[u] |= 1 << (v - 1);
e[v] |= 1 << (u - 1);
}
if (m == n * (n - 1) / 2) {
cout << "0";
return 0;
}
for (int i = 1; i <= n; i++) e[i] |= 1 << (i - 1);
memset(f, 63, sizeof(f));
f[0] = 0;
for (int s = 0; s < (1 << n); s++) {
if (f[s] > 1e9) continue;
for (int i = 0; i < n; i++) {
if (s & (1 << i) || s == 0) {
if (f[s | e[i + 1]] > f[s] + 1)
f[s | e[i + 1]] = f[s] + 1, pres[s | e[i + 1]] = s,
prep[s | e[i + 1]] = i + 1;
}
}
}
cout << f[(1 << n) - 1] << "\n";
int t = (1 << n) - 1;
while (t) {
cout << prep[t] << " ";
t = pres[t];
}
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
map<char, int> S, T;
for (char i : s) S[i]++;
for (char i : t) T[i]++;
int cnt = 0;
for (pair<char, int> i : T) {
if (S.count(i.first) == 0) {
cout << -1;
return 0;
} else
cnt += min(S[i.first], T[i.first]);
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int 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;
}
inline long long read1() {
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;
}
const int N = 5e5 + 10;
vector<int> v[N];
bool used[N];
int ans[N], glub[N];
struct S {
int Xor = 0;
int add = 0;
int mx = 0;
unordered_map<int, int> m;
};
char s[N];
S dfs(int x, int cur = 0) {
S res;
res.m[0] = 0;
int nowAns = 0;
glub[x] = cur;
for (int to : v[x]) {
nowAns = max(nowAns, 1);
auto f = dfs(to, cur + 1);
nowAns = max(nowAns, ans[to]);
f.add++;
char c = s[to];
f.Xor ^= (1 << c);
if (f.m.size() > res.m.size()) swap(f, res);
for (auto p : f.m) {
int key = p.first ^ f.Xor ^ res.Xor;
int val = p.second + f.add + res.add;
if (val + res.mx <= nowAns) continue;
for (int mask = 0; mask < (1 << 22);) {
int what = key ^ mask;
auto it = res.m.find(what);
if (it != res.m.end()) nowAns = max(nowAns, val + it->second);
if (!mask)
mask++;
else
mask <<= 1;
}
}
for (auto p : f.m) {
int key = p.first ^ f.Xor ^ res.Xor;
int val = p.second + f.add - res.add;
res.mx = max(res.mx, val);
if (!res.m.count(key))
res.m[key] = val;
else
res.m[key] = max(res.m[key], val);
}
}
ans[x] = nowAns;
return res;
}
int main() {
int n = read();
for (int i = 1; i <= n - 1; i++) {
char c;
int x = read();
c = getchar();
x--;
v[x].push_back(i);
s[i] = c - 'a';
}
dfs(0);
for (int i = 0; i < (n); i++) printf("%d ", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
const long long int int_max = 1e18;
const long long int int_min = -1e18;
using namespace std;
vector<int> v[N];
long long int vis[N] = {0};
long long int sv[N];
int flg = 0;
long long int a[N];
void dfs(long long int k, long long int sum) {
vis[k] = 1;
long long int temp = 0, mn = INT_MAX;
for (long long int i : v[k]) {
if (!vis[i]) mn = min(mn, sv[i]);
}
if (mn == INT_MAX) {
if (sv[k] == -1) {
a[k] = 0;
sv[k] = sum;
} else
a[k] = sv[k] - sum;
} else {
if (sv[k] == -1) {
sv[k] = mn;
a[k] = sv[k] - sum;
} else
a[k] = sv[k] - sum;
}
for (long long int i : v[k]) {
if (!vis[i]) {
dfs(i, sv[k]);
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL);
long long int n;
cin >> n;
for (long long int i = 2; i <= n; i++) {
long long int p;
cin >> p;
v[p].push_back(i);
v[i].push_back(p);
}
for (long long int i = 1; i <= n; i++) cin >> sv[i];
dfs(1, 0);
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
if (a[i] < 0) flg = 1;
ans += a[i];
}
if (flg)
cout << -1 << '\n';
else
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char gchar() {
static char tbuf1[1000], *tmp_st = tbuf1, *tmp_ed = tbuf1;
if (tmp_st == tmp_ed) {
int len = fread(tbuf1, 1, 1000, stdin);
if (len == 0) return -1;
tmp_ed = tbuf1 + len;
tmp_st = tbuf1;
}
return *(tmp_st++);
}
inline bool gn(int &first) {
char c, sg = 0;
while (c = gchar(), (c > '9' || c < '0') && c != '-' && c != -1)
;
if (c == -1) return 0;
for ((c == '-' ? sg = 1, c = gchar() : 0), first = 0; c >= '0' && c <= '9';
c = gchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
return 1;
}
inline void print(int first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
int power(int a, int b, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % 998244353)
if (b & 1) ans = (long long)ans * a % 998244353;
return ans;
}
pair<int, pair<int, int> > p[1000000];
int id[1000000], N;
long long first, second, sx, sy, pre;
bool cmp(int u, int v) { return p[u].first < p[v].first; }
int main() {
int n, m;
gn(n), gn(m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
gn(p[N].first);
p[N].second = pair<int, int>(i, j);
id[N] = N;
N++;
}
}
sort(id, id + N, cmp);
gn(n), gn(m);
for (int i = 0, j = 0; i < N; i = j) {
long long s = 0, f = power(i, 998244353 - 2);
for (j = i; j < N && p[id[i]].first == p[id[j]].first; j++) {
long long X = p[id[j]].second.first, Y = p[id[j]].second.second;
int ans = (i * (((long long)(X) * (X)) + ((long long)(Y) * (Y))) + first +
second - 2LL * (X * sx + Y * sy) + pre) %
998244353;
if (ans < 0) ans += 998244353;
ans = ans * f % 998244353;
s += ans;
if (X == n && Y == m) {
print(ans);
return 0;
}
}
pre = (pre + s) % 998244353;
for (int k = i; k < j; k++) {
int X = p[id[k]].second.first, Y = p[id[k]].second.second;
sx += X, sy += Y;
first += ((long long)(X) * (X)), second += ((long long)(Y) * (Y));
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 3;
vector<pair<int, pair<int, int>>> s[N];
int n, p[N], c[N], ans[N], par[N], u, v, C, ch[N], mp[100005];
queue<int> q;
vector<pair<int, int>> adj[N];
void DFS(int node, int pr = 0, int capacity = 0) {
c[node] = capacity;
par[node] = pr;
for (int i = 0; i < adj[node].size(); ++i)
if (adj[node][i].first != pr)
++ch[node], DFS(adj[node][i].first, node, adj[node][i].second);
if (!ch[node]) q.push(node);
s[node].push_back({p[node], {node, 0}});
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", p + i);
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d%d", &u, &v, &C);
adj[u].push_back({v, C});
adj[v].push_back({u, C});
}
DFS(1);
int node, day;
pair<int, pair<int, int>> x;
while (q.front() != 1) {
u = q.front();
q.pop();
ch[par[u]]--;
if (!ch[par[u]]) q.push(par[u]);
sort(s[u].begin(), s[u].end());
for (int i = 0; i < s[u].size(); ++i) {
x = s[u][i];
node = x.second.first;
day = x.second.second;
while (mp[day] == c[u]) ++day;
mp[day]++;
ans[node] = day + 1;
s[par[u]].push_back({p[node], {node, ans[node]}});
}
for (int i = 0; i < s[u].size(); ++i) {
x = s[u][i];
node = x.second.first;
mp[ans[node] - 1]--;
}
s[u].clear();
}
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> s;
const int maxn = 1e5 + 5;
int b[maxn], a[maxn * 4];
int n, m;
int main() {
scanf("%d", &n);
int big = -1, small = 1e9 + 7;
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
a[i] = b[i];
big = max(big, a[i]);
small = min(small, a[i]);
}
if (small * 2 >= big) {
for (int i = 1; i <= n; i++) printf("-1 ");
printf("\n");
return 0;
}
m = n;
for (int i = 1; i <= n; i++) a[++m] = b[i];
for (int i = 1; i <= n; i++) a[++m] = b[i];
for (int i = 1; i <= n; i++) a[++m] = b[i];
int j = 1;
for (int i = 1; i <= n; i++) {
while (j <= m) {
int big = s.empty() ? -1 : *s.rbegin();
if (a[j] * 2 < big) break;
s.insert(a[j++]);
}
s.erase(s.find(a[i]));
printf("%d ", j - i);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double a, b, n, t;
cin >> a >> b;
cin >> n;
while (n--) {
cin >> t;
a -= b * t;
swap(a, b);
}
if (b == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 4 |
#include <bits/stdc++.h>
char a[200005], b[200005];
int cmp(char *p, char *q, int n) {
if (!strncmp(p, q, n)) return 1;
if (n % 2) return 0;
int temp = n / 2;
if (cmp(p, q, temp) && cmp(p + temp, q + temp, temp))
return 1;
else if (cmp(p + temp, q, temp) && cmp(p, q + temp, temp))
return 1;
return 0;
}
int main() {
while (~scanf("%s%s", a, b)) {
if (cmp(a, b, strlen(a)))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 5100, inf = 1e17, mod = 1e9 + 7;
vector<long long int> f[maxn];
long long int pref[maxn][maxn];
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
long long int n, m;
cin >> n >> m;
vector<long long int> mas(n, 0);
for (long long int d = 0; d < n; d++) {
cin >> mas[d];
mas[d]--;
}
for (long long int d = 0; d < m; d++) {
long long int f1, h1;
cin >> f1 >> h1;
f1--;
f[f1].push_back(h1);
}
for (long long int d = 0; d < n; d++) {
if (f[d].size() > 0) {
sort(f[d].begin(), f[d].end());
}
}
for (long long int d = 0; d < n; d++) {
pref[0][d] = 0;
}
for (long long int d = 1; d <= n; d++) {
for (long long int i = 0; i < n; i++) {
pref[d][i] = pref[d - 1][i];
}
pref[d][mas[d - 1]]++;
}
long long int max1 = 0, cnt = 1;
for (long long int d = 0; d <= n; d++) {
if (d == 0) {
long long int raz = 0;
long long int cnt1 = 1;
for (long long int i = 0; i < n; i++) {
long long int kol1 = pref[n][i] - pref[d][i];
long long int cnt2 = 1;
bool check1 = 0;
auto it1 = upper_bound(f[i].begin(), f[i].end(), kol1);
if (it1 != f[i].begin()) {
it1--;
long long int dist = (it1 - f[i].begin()) + 1;
cnt2 *= dist;
check1 = 1;
}
if (check1) {
raz += check1;
cnt1 *= cnt2;
cnt1 %= mod;
}
}
if (raz == max1) {
cnt += cnt1;
cnt %= mod;
}
if (raz > max1) {
max1 = raz;
cnt = cnt1;
}
continue;
}
long long int f1 = mas[d - 1];
long long int tkol = pref[d][f1];
bool check = 0;
auto it = lower_bound(f[f1].begin(), f[f1].end(), tkol);
if (it != f[f1].end()) {
if ((*it) == tkol) {
check = 1;
}
}
if (!check) {
continue;
}
long long int raz = 0;
long long int cnt1 = 1;
for (long long int i = 0; i < n; i++) {
long long int kol = pref[d][i];
long long int kol1 = pref[n][i] - pref[d][i];
auto it = upper_bound(f[i].begin(), f[i].end(), kol);
long long int cnt2 = 1;
long long int min1 = inf;
bool check = 0;
bool check1 = 0;
long long int cn = 0;
long long int dist1 = 0, dist2 = 0;
if (i != f1) {
if (it != f[i].begin()) {
--it;
dist1 = (it - f[i].begin()) + 1;
cnt2 *= dist1;
min1 = min(min1, dist1);
check = 1;
} else {
min1 = 0;
}
auto it1 = upper_bound(f[i].begin(), f[i].end(), kol1);
if (it1 != f[i].begin()) {
it1--;
dist2 = (it1 - f[i].begin()) + 1;
cnt2 *= dist2;
min1 = min(min1, dist2);
check1 = 1;
} else {
min1 = 0;
}
cnt2 -= min1;
long long int cn = check + check1;
if (dist1 == 1 && dist2 == 1) {
cn--;
cnt2 = 2;
}
raz += cn;
cnt1 *= cnt2;
cnt1 %= mod;
} else {
check = 1;
auto it = upper_bound(f[i].begin(), f[i].end(), kol1);
if (it != f[i].begin()) {
check1 = 1;
it--;
dist2 = (it - f[i].begin()) + 1;
if ((*it) >= tkol) {
dist2--;
}
if (dist2 == 0) {
check1 = 0;
} else {
cnt2 *= dist2;
}
}
if (check || check1) {
raz += check;
raz += check1;
cnt1 *= cnt2;
cnt1 %= mod;
}
}
}
if (raz == max1) {
cnt += cnt1;
cnt %= mod;
}
if (raz > max1) {
max1 = raz;
cnt = cnt1;
}
}
if (max1 == 0) {
cnt = 1;
}
cout << max1 << " " << cnt;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, p = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') p = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * p;
}
inline void File() {
freopen("C.in", "r", stdin);
freopen("C.out", "w", stdout);
}
const int N = 300 + 10, mod = 1e9 + 7;
int dp[N][N], C[N][N], n, a[N], m, sz[N];
int sum, ans, fac[N];
inline int add(int a, int b) { return a + b > mod ? a + b - mod : a + b; }
inline void Init() {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
for (int i = 0; i <= n; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j) C[i][j] = add(C[i - 1][j - 1], C[i - 1][j]);
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i)
if (a[i] ^ a[i - 1])
sz[++m] = 1;
else
++sz[m];
}
int main() {
n = read();
for (int i = 1, x; i <= n; ++i) {
x = read();
for (int j = 2; j * j <= x; ++j)
while (x % (j * j) == 0) x /= j * j;
a[i] = x;
}
Init();
dp[1][sz[1] - 1] = 1;
for (int i = 2; i <= m; ++i) {
sum += sz[i - 1];
for (int j = 0; j <= sum - 1; ++j) {
for (int k = 1; k <= sz[i]; ++k) {
int r = min(k, j);
for (int u = 0; u <= r; ++u)
dp[i][j - u + sz[i] - k] =
add(dp[i][j - u + sz[i] - k],
1ll * dp[i - 1][j] * C[sz[i] - 1][k - 1] % mod * C[j][u] %
mod * C[sum - j + 1][k - u] % mod);
}
}
}
int ans = dp[m][0];
for (int i = 1; i <= m; ++i) ans = 1ll * ans * fac[sz[i]] % mod;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[301], b[301];
int main() {
int n, k, sum = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) b[i] = i;
int cur;
for (int i = 1; i <= n; i++) {
cur = 1;
while (1) {
for (int j = n; j > cur; j--)
if (cur >= j - a[b[j]]) {
cur = j;
++sum;
break;
}
if (cur == n) break;
}
for (int j = 1; j <= n; j++) {
b[j] = b[j] - 1;
if (b[j] == 0) b[j] = n;
}
}
cout << sum;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
const int mod = 1000000007;
pair<long long, long long> a[N << 2];
long long xmult(pair<long long, long long> a, pair<long long, long long> b) {
return b.first * a.second - a.first * b.second;
}
pair<long long, long long> sum[N << 2];
long long sum1[N << 2], sum2[N << 2];
long long get_sum1(int first, int second) {
if (!first) return sum1[second];
return sum1[second] - sum1[first - 1];
}
long long get_sum2(int first, int second) {
if (!first) return sum2[second];
return sum2[second] - sum2[first - 1];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld%lld", &a[i].first, &a[i].second);
for (int i = n; i < 3 * n; i++) a[i] = a[i - n];
long long tot = 0;
for (int i = 0; i < n; i++) {
tot += xmult(a[i], a[i + 1]);
}
for (int i = 0; i < 3 * n; i++) {
if (!i)
sum[i] = a[i];
else
sum[i].first = sum[i - 1].first + a[i].first,
sum[i].second = sum[i - 1].second + a[i].second;
}
for (int i = 0; i + 1 < 3 * n; i++) {
long long p = xmult(a[i], a[i + 1]) % mod;
if (!i)
sum1[0] = p % mod;
else
sum1[i] = (sum1[i - 1] + p) % mod;
if (!i)
sum2[0] = (i + 1) * p % mod;
else
sum2[i] = (sum2[i - 1] + p * (i + 1)) % mod;
}
long long all = 0;
long long ans = 0;
for (int i = 0, j = 0; i < n; i++) {
while (true) {
unsigned long long tmp =
(unsigned long long)2 *
(all + xmult(a[j], a[j + 1]) + xmult(a[j + 1], a[i]));
if ((tmp <= tot && j + 1 < n) || tmp < tot) {
all += xmult(a[j], a[j + 1]);
j++;
} else
break;
}
ans = (ans + xmult(make_pair((sum[j].first - sum[i].first) % mod,
(sum[j].second - sum[i].second) % mod),
a[i])) %
mod;
ans = (ans + (j + 1) * get_sum1(i, j - 1) - get_sum2(i, j - 1)) % mod;
all -= xmult(a[i], a[i + 1]);
}
ans = 2 * ans % mod;
ans = (tot % mod * n % mod * (n - 3) % mod * (mod + 1) / 2 % mod - ans) % mod;
if (ans < 0) ans += mod;
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, inf = 0x3f3f3f3f;
void cmax(int& x, int y) {
if (x < y) {
x = y;
}
}
int n, q, size[N], heavy[N], top[N], dfn[N], depth[N], fa[N], dfn_cnt;
vector<int> graph[N];
void dfs1(int u, int pa) {
size[u] = 1;
for (auto v : graph[u]) {
fa[v] = u;
depth[v] = depth[u] + 1;
dfs1(v, u);
size[u] += size[v];
if (size[v] > size[heavy[u]]) {
heavy[u] = v;
}
}
}
void dfs2(int u, int t) {
top[u] = t;
dfn[u] = ++dfn_cnt;
if (heavy[u]) {
dfs2(heavy[u], t);
for (auto v : graph[u]) {
if (v != heavy[u]) {
dfs2(v, v);
}
}
}
}
struct state {
int sum, max_t;
state() {}
state(int sum, int max_t) : sum(sum), max_t(max_t) {}
state operator+(const state& a) const {
state result;
result.sum = sum + a.sum;
result.max_t = max(a.max_t, a.sum + max_t);
return result;
}
} seg_info_t[N << 2];
int cover_tag[N << 2];
void cover_t(int l, int r, int o, int v) {
cover_tag[o] = v;
seg_info_t[o] = state(v * (r - l + 1), v >= 0 ? v * (r - l + 1) : v);
}
void push_down(int l, int r, int o) {
if (cover_tag[o] != inf) {
int mid = l + r >> 1;
cover_t(l, mid, (o << 1), cover_tag[o]);
cover_t(mid + 1, r, (o << 1 | 1), cover_tag[o]);
cover_tag[o] = inf;
}
}
void build(int l, int r, int o) {
if (l == r) {
seg_info_t[o] = state(-1, -1);
} else {
int mid = l + r >> 1;
build(l, mid, (o << 1));
build(mid + 1, r, (o << 1 | 1));
seg_info_t[o] = seg_info_t[(o << 1)] + seg_info_t[(o << 1 | 1)];
}
}
void modify(int l, int r, int o, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
cover_t(l, r, o, v);
} else {
int mid = l + r >> 1;
push_down(l, r, o);
if (ql <= mid) {
modify(l, mid, (o << 1), ql, qr, v);
}
if (qr > mid) {
modify(mid + 1, r, (o << 1 | 1), ql, qr, v);
}
seg_info_t[o] = seg_info_t[(o << 1)] + seg_info_t[(o << 1 | 1)];
}
}
state query(int l, int r, int o, int ql, int qr) {
if (ql <= l && r <= qr) {
return seg_info_t[o];
} else {
int mid = l + r >> 1;
push_down(l, r, o);
if (qr <= mid) {
return query(l, mid, (o << 1), ql, qr);
} else if (ql > mid) {
return query(mid + 1, r, (o << 1 | 1), ql, qr);
} else {
return query(l, mid, (o << 1), ql, qr) +
query(mid + 1, r, (o << 1 | 1), ql, qr);
}
}
}
int query(int u) {
int result = -inf, sumv = 0;
for (; u; u = fa[top[u]]) {
int l = dfn[top[u]], r = dfn[u];
state x = query(1, n, 1, l, r);
cmax(result, sumv + x.max_t);
sumv += x.sum;
}
return result;
}
void modify_subtree(int u) {
int x = fa[u] ? query(fa[u]) : 0;
modify(1, n, 1, dfn[u], dfn[u], min(-x - 1, -1));
for (auto v : graph[u]) {
modify(1, n, 1, dfn[v], dfn[v] + size[v] - 1, -1);
}
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 2; i <= n; ++i) {
int x;
scanf("%d", &x);
graph[x].push_back(i);
}
dfs1(1, 0);
dfs2(1, 1);
build(1, n, 1);
memset(cover_tag, 0x3f, sizeof cover_tag);
for (int i = 1; i <= q; ++i) {
int type, x;
scanf("%d%d", &type, &x);
if (type == 1) {
int y = query(1, n, 1, dfn[x], dfn[x]).sum;
modify(1, n, 1, dfn[x], dfn[x], y + 1);
} else if (type == 2) {
modify_subtree(x);
} else {
printf("%s\n", query(x) >= 0 ? "black" : "white");
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int q;
for (cin >> q; q; q -= 1) {
int n, m, ok = 1, p = 0;
cin >> n >> m;
int L = m, H = m;
for (int i = 0; i < n; i += 1) {
int t, l, h;
cin >> t >> l >> h;
L -= (t - p);
H += (t - p);
p = t;
L = max(L, l);
H = min(H, h);
if (L > H) ok = 0;
}
cout << (ok ? "YES\n" : "NO\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void sprint(string s) {
for (int i = 0; i < s.size(); ++i) printf("%c", s[i]);
printf("\n");
}
int f(vector<int> x, vector<int> y, int t) {
int a = 0, b = 0;
reverse(x.begin(), x.end());
reverse(y.begin(), y.end());
int temp = 1;
for (int i = 0; i < x.size(); ++i) {
if (x[i] >= t) return 0;
a += x[i] * temp;
temp *= t;
}
temp = 1;
for (int i = 0; i < y.size(); ++i) {
if (y[i] >= t) return 0;
b += y[i] * temp;
temp *= t;
}
if (a <= 23 and b <= 59)
return 1;
else
return -1;
}
int main() {
string s;
cin >> s;
int x = s.find(":");
string a = s.substr(0, x);
string b = s.substr(x + 1, s.size() - x - 1);
bool t = 0;
for (int i = 0; i < a.size() - 1; ++i) {
if (a[i] != '0') t = 1;
}
if (!t) {
for (int i = 0; i < b.size() - 1; ++i) {
if (b[i] != '0') t = 1;
}
char c = a[a.size() - 1];
if (!t) {
if ((c - '0' >= 0 and c - '9' <= 0) or (c - 'A' >= 0 and c - 'N' <= 0)) {
printf("-1\n");
return 0;
}
}
}
vector<int> xx, y;
for (int i = 0; i < a.size(); ++i) {
if (a[i] - '0' >= 0 and a[i] - '9' <= 0)
xx.push_back(a[i] - '0');
else
xx.push_back(a[i] - 'A' + 10);
}
for (int i = 0; i < b.size(); ++i) {
if (b[i] - '0' >= 0 and b[i] - '9' <= 0)
y.push_back(b[i] - '0');
else
y.push_back(b[i] - 'A' + 10);
}
int tt = 2;
int tot = 0;
while (1) {
int temp = f(xx, y, tt);
if (temp == -1) break;
if (temp == 1) tot++, printf("%d ", tt);
tt++;
}
if (tot == 0) printf("0\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, x = 2;
cin >> n;
if ((n & 1LL) == 0)
cout << "4 " << n - 4 << '\n';
else
cout << "9 " << n - 9 << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m1, l, r;
cin >> m1 >> l >> r;
long long MIN, MAX;
MIN = (m1 - l) + (1 << l) - 1;
MAX = (m1 - r + 2) * (1 << (r - 1)) - 1;
cout << MIN << ' ' << MAX;
}
| 0 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const int N = 1e5 + 2;
int n, q, a[N], cnt[N], cnt4, cnt2;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = (1); i <= (n); ++i) {
cin >> a[i];
cnt[a[i]]++;
if (cnt[a[i]] == 4)
cnt2--, cnt4++;
else if (cnt[a[i]] > 4 && cnt[a[i]] % 2 == 0)
cnt2++;
else if (cnt[a[i]] == 2)
cnt2++;
}
cin >> q;
while (q--) {
char t;
int x;
cin >> t >> x;
if (t == '+') {
cnt[x]++;
if (cnt[x] == 4)
cnt2--, cnt4++;
else if (cnt[x] > 4 && cnt[x] % 2 == 0)
cnt2++;
else if (cnt[x] == 2)
cnt2++;
} else {
cnt[x]--;
if (cnt[x] == 3)
cnt4--, cnt2++;
else if (cnt[x] > 4 && cnt[x] % 2 == 1)
cnt2--;
else if (cnt[x] == 1)
cnt2--;
}
if (cnt4 >= 2 || (cnt4 == 1 && cnt2 >= 2))
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int K, M;
void solve() {
set<pair<int, int> > res;
for (int n = 0; n < 10000; n++) {
int d[4], t = n;
for (int i = 3; i >= 0; i--) {
d[i] = t % 10;
t /= 10;
}
set<int> dp[4][4];
for (int l = 1; l <= 4; l++) {
for (int i = 0; i + l <= 4; i++) {
int j = i + l - 1;
int w = 0;
for (int k = i; k <= j; k++) {
w = 10 * w + d[k];
}
dp[i][j].insert(w);
for (int k = i; k < j; k++) {
for (set<int>::iterator it = dp[i][k].begin(); it != dp[i][k].end();
it++) {
for (set<int>::iterator jt = dp[k + 1][j].begin();
jt != dp[k + 1][j].end(); jt++) {
int a = *it, b = *jt;
dp[i][j].insert(a * b);
dp[i][j].insert(a + b);
dp[i][j].insert(abs(a - b));
}
}
}
}
}
vector<int> x = vector<int>(dp[0][3].begin(), dp[0][3].end());
int cnt = x.size();
for (int i = 0; i < cnt; i++) {
int a = x[i];
int b = abs(K - a);
if (b < 10000) {
res.insert(make_pair(n, b));
if (res.size() == M) {
for (set<pair<int, int> >::iterator it = res.begin(); it != res.end();
it++) {
printf("%04d%04d\n", it->first, it->second);
}
cout << endl;
return;
}
}
}
}
}
int main() {
while (cin >> K >> M) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int mem[N];
void def(const int& m) {
int j, k, id;
int cnt1;
for (int i = (int)(0); i < (int)(m); ++i) {
if (mem[i] == -1) {
cnt1 = 0;
for (j = i; mem[j] == -1 and j < m; j++)
;
id = mem[j];
if (mem[j] == -1 or j == m) break;
for (k = j; mem[k] == id; k++) {
cnt1 += 1;
mem[k] = -1;
}
for (j = i; j < i + cnt1; j++) {
mem[j] = id;
}
i = j - 1;
}
}
}
string itoa(int a) {
string ret = "";
while (a) {
int v = a % 10;
ret += char(v + '0');
a /= 10;
}
reverse((ret).begin(), (ret).end());
return ret;
}
string all(const int& m, int& id, const int& val) {
if (val > m) return "NULL";
for (int i = (int)(0); i < (int)(m); ++i) {
if (mem[i] == -1) {
int cnt = 0;
for (int j = i; mem[j] == -1 and j < m; j++) {
cnt += 1;
}
if (cnt >= val) {
for (int j = i; j < i + val; j++) {
mem[j] = id;
}
id += 1;
return itoa(id - 1);
}
}
}
return "NULL";
}
string era(const int& m, const int& id, int val) {
if (val >= id or val <= 0) return "ILLEGAL_ERASE_ARGUMENT";
bool flag = true;
for (int i = (int)(0); i < (int)(m); ++i) {
if (mem[i] == val) {
flag = false;
mem[i] = -1;
}
}
if (flag) return "ILLEGAL_ERASE_ARGUMENT";
return "-1";
}
int main() {
int t, m, val;
int id = 1;
string cmd;
cin >> t >> m;
for (int i = (int)(0); i < (int)(m); ++i) mem[i] = -1;
for (int i = (int)(0); i < (int)(t); ++i) {
cin >> cmd;
if (cmd == "defragment") {
def(m);
} else {
cin >> val;
if (cmd == "alloc") {
cout << all(m, id, val) << endl;
} else {
string tmp = era(m, id, val);
if (tmp != "-1") cout << tmp << endl;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, ans;
string s;
int pref[502];
int main() {
cin >> n;
cin >> s;
ans = -1;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
swap(s[i], s[j]);
int mn = n + 1, cnt = 0;
for (int k = 0; k < n; k++) {
pref[k] = (s[k] == '(' ? 1 : -1) + (k == 0 ? 0 : pref[k - 1]);
if (mn > pref[k]) {
mn = pref[k];
cnt = 1;
} else if (mn == pref[k])
cnt++;
}
if (pref[n - 1] != 0) cnt = 0;
if (ans < cnt) {
ans = cnt;
x = i, y = j;
}
swap(s[i], s[j]);
}
cout << max(ans, 0) << "\n";
cout << x + 1 << " " << y + 1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, mx;
int a[100010];
vector<int> v, v2, v3;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
mx = -(1000 * 1000 * 1000);
for (__typeof(n) i = (1); i <= (n); i++) {
cin >> a[i];
if (a[i] > mx) mx = a[i];
}
for (__typeof(n) i = (1); i <= (n); i++) {
v.clear();
for (__typeof(n) j = (i); j <= (n); j++) {
int sum = 0;
v.push_back(a[j]);
sort((v).begin(), (v).end());
v2.clear();
for (__typeof(n) l = (1); l <= (n); l++)
if (l < i || l > j) v2.push_back(a[l]);
sort((v2).begin(), (v2).end());
reverse((v2).begin(), (v2).end());
int kp = min(k, ((int)((v).size())));
kp = min(kp, ((int)((v2).size())));
v3.clear();
for (__typeof(kp - 1) i = (0); i <= (kp - 1); i++) {
v3.push_back(v[i]);
v3.push_back(v2[i]);
}
sort((v3).begin(), (v3).end());
reverse((v3).begin(), (v3).end());
for (__typeof(kp - 1) l = (0); l <= (kp - 1); l++) sum += v3[l];
for (__typeof(((int)((v).size())) - 1) l = (kp);
l <= (((int)((v).size())) - 1); l++)
sum += v[l];
if (sum > mx) mx = sum;
}
}
cout << mx << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime(int n) {
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) return false;
return true;
}
int main() {
int k;
scanf("%d", &k);
int t = 2 * ((k) * (k));
vector<bool> A(t + 1, false);
A[1] = true;
int p = 1, cnt = 0;
while (cnt < k) {
do {
++p;
} while (!is_prime(p));
for (int i = p; i <= t; i += p)
if (!A[i] && A[i / p]) {
A[i] = true;
++cnt;
}
}
for (int i = t, j = k; j > 0; --i)
if (A[i]) printf("%d%c", i, --j == 0 ? '\n' : ' ');
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n(0);
scanf("%d", &n);
std::vector<std::pair<int, int>> bids(n, std::pair<int, int>(0, 0));
int temp(0);
for (int k = 0; k < n; k++) {
scanf("%d", &temp);
bids[k] = std::pair<int, int>(temp, k);
}
std::sort(bids.begin(), bids.end());
printf("%d %d\n", 1 + bids[n - 1].second, bids[n - 2].first);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[203][3][52][102];
int N = 0;
string commands = "";
int myabs(int px) {
if (px < 0) return -px;
return px;
}
int solve(int pos, int dir, int changed, int steps) {
if (steps == commands.size()) {
if (changed == N) return myabs(100 - pos);
return 0;
}
if (dp[pos][dir][changed][steps] != -1) return dp[pos][dir][changed][steps];
int res = 0;
if (dir == 0) {
if (commands[steps] == 'F') {
res = max(res, solve(pos + 1, dir, changed, steps + 1));
} else {
res = max(res, solve(pos, 1, changed, steps + 1));
}
} else {
if (commands[steps] == 'F') {
res = max(res, solve(pos - 1, dir, changed, steps + 1));
} else {
res = max(res, solve(pos, 0, changed, steps + 1));
}
}
int rem = N - changed;
for (int i = 1; i <= rem; i++) {
if ((i % 2) == 0) {
if (dir == 0) {
if (commands[steps] == 'F') {
res = max(res, solve(pos + 1, dir, changed + i, steps + 1));
} else {
res = max(res, solve(pos, 1, changed + i, steps + 1));
}
} else {
if (commands[steps] == 'F') {
res = max(res, solve(pos - 1, dir, changed + i, steps + 1));
} else {
res = max(res, solve(pos, 0, changed + i, steps + 1));
}
}
} else {
if (dir == 0) {
if (commands[steps] == 'F') {
res = max(res, solve(pos, 1, changed + i, steps + 1));
} else {
res = max(res, solve(pos + 1, 0, changed + i, steps + 1));
}
} else {
if (commands[steps] == 'F') {
res = max(res, solve(pos, 0, changed + i, steps + 1));
} else {
res = max(res, solve(pos - 1, dir, changed + i, steps + 1));
}
}
}
}
dp[pos][dir][changed][steps] = res;
return res;
}
int main() {
cin >> commands >> N;
memset(dp, -1, sizeof(dp));
int res = solve(100, 0, 0, 0);
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char sh[3], sm[3], th[3], tm[3];
sh[2] = sm[2] = th[2] = tm[2] = '\0';
char s[10], t[10];
cin >> s;
cin >> t;
sh[0] = s[0];
sh[1] = s[1];
sm[0] = s[3];
sm[1] = s[4];
th[0] = t[0];
th[1] = t[1];
tm[0] = t[3];
tm[1] = t[4];
int ish, ism, ith, itm;
ish = atoi(sh);
ism = atoi(sm);
ith = atoi(th);
itm = atoi(tm);
int ansh, ansm;
ansh = ish - ith;
ansm = ism - itm;
if (ansh < 0) ansh += 24;
if (ansm < 0) {
ansh--;
ansm += 60;
}
if (ansh < 0) ansh += 24;
char ah[3], am[3];
ah[2] = am[2] = '\0';
ah[0] = ansh / 10 + '0';
am[0] = ansm / 10 + '0';
ah[1] = ansh % 10 + '0';
am[1] = ansm % 10 + '0';
cout << ah << ":" << am;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int LINF = 0x3f3f3f3f3f3f3f3fll;
const int MAX = (int)1e5 + 10;
int main() {
ios::sync_with_stdio(false);
int n, m = INF;
int first[110];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> first[i];
}
int total;
for (int i = 0; i < n; i++) {
total = 0;
for (int j = 0; j < n; j++) {
total += (abs(i - j) + j + i + i + j + abs(j - i)) * first[j];
}
m = min(m, total);
}
cout << m << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
namespace Fastio {
enum io_flags {
ignore_int = 1 << 0,
char_enter = 1 << 1,
flush_stdout = 1 << 2,
flush_stderr = 1 << 3,
endline = char_enter | flush_stdout
};
enum number_type_flags {
output_double_stable = 1 << 0,
output_double_faster = 1 << 1
};
struct Reader {
char endch;
Reader() { endch = '\0'; }
Reader& operator>>(io_flags f) {
if (f & ignore_int) {
endch = getchar();
while ((!isdigit(endch)) && endch != '-' && endch != EOF)
endch = getchar();
while (isdigit(endch = getchar()))
;
}
return *this;
}
Reader& operator>>(char& ch) {
ch = getchar();
while (ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t') ch = getchar();
return *this;
}
Reader& operator>>(double& lf) {
bool flag = 0;
endch = getchar();
while ((!isdigit(endch)) && endch != '-' && endch != EOF) endch = getchar();
if (endch == '-') flag = 1, endch = getchar();
lf = endch & 15;
while (isdigit(endch = getchar())) lf = lf * 10 + (endch & 15);
if (endch == '.') {
double digit = 0.1;
while (isdigit(endch = getchar())) {
lf += (endch & 15) * digit;
digit *= 0.1;
}
}
if (flag) lf = -lf;
return *this;
}
template <typename Int>
Reader& operator>>(Int& d) {
bool flag = 0;
endch = getchar();
while ((!isdigit(endch)) && endch != '-' && endch != EOF) endch = getchar();
if (endch == '-') flag = 1, endch = getchar();
d = endch & 15;
while (isdigit(endch = getchar())) d = (d << 3) + (d << 1) + (endch & 15);
if (flag) d = -d;
return *this;
}
template <typename Int>
inline Int get() {
bool flag = 0;
endch = getchar();
while ((!isdigit(endch)) && endch != '-' && endch != EOF) endch = getchar();
if (endch == '-') flag = 1, endch = getchar();
Int d = endch & 15;
while (isdigit(endch = getchar())) d = (d << 3) + (d << 1) + (endch & 15);
if (flag) d = -d;
return d;
}
} read;
struct Writer {
Writer& operator<<(io_flags f) {
if (f & char_enter) putchar(10);
if (f & flush_stdout) fflush(stdout);
if (f & flush_stderr) fflush(stderr);
return *this;
}
Writer& operator<<(const char* ch) {
while (*ch) putchar(*(ch++));
return *this;
}
Writer& operator<<(const char ch) {
putchar(ch);
return *this;
}
template <typename Int>
Writer& operator<<(Int x) {
static char buffer[33];
static int top = 0;
if (!x) {
putchar('0');
return *this;
}
if (x < 0) putchar('-'), x = ~x + 1;
while (x) {
buffer[++top] = '0' | (x % 10);
x /= 10;
}
while (top) putchar(buffer[top--]);
return *this;
}
inline void operator()(double val, int eps_digit = 6, char endch = '\0',
number_type_flags flg = output_double_faster) {
if (flg & output_double_stable) {
static char output_format[10];
sprintf(output_format, "%%.%dlf", eps_digit);
printf(output_format, val);
} else if (flg & output_double_faster) {
if (val < 0) {
putchar('-');
val = -val;
}
double eps_number = 0.5;
for (int i = 1; i <= eps_digit; i++) eps_number /= 10;
val += eps_number;
(*this) << (long long)val;
val -= (long long)val;
putchar('.');
while (eps_digit--) {
val *= 10;
putchar((int)val | '0');
val -= (int)val;
}
} else {
(*this) << "1.#ERROR_NOT_IDENTIFIED_FLAG";
}
if (endch) putchar(endch);
}
} write;
} // namespace Fastio
using namespace Fastio;
namespace File_IO {
void init_IO() {
freopen("Forward, march!.in", "r", stdin);
freopen("Forward, march!.out", "w", stdout);
}
} // namespace File_IO
const int N = 2e6 + 7;
int n;
string s;
double f[N][2];
bool check(double dif) {
f[0][1] = (s[0] == 'L') - dif;
f[0][0] = (s[0] == 'R') - dif * 2;
f[0][1] = max(f[0][1], f[0][0] - dif);
f[0][0] = max(f[0][0], f[0][1] - dif);
for (int i = 1; i < n; i++) {
f[i][1] = f[i - 1][0] + (s[i] == 'L') - dif;
f[i][0] = f[i - 1][1] + (s[i] == 'R') - dif;
f[i][1] = max(f[i][1], f[i][0] - dif);
f[i][0] = max(f[i][0], f[i][1] - dif);
}
return f[n - 1][0] > 0;
}
signed main() {
string TmpBuffer;
cin >> TmpBuffer;
if (TmpBuffer.front() == TmpBuffer.back() && TmpBuffer.back() == 'R')
s += 'X';
for (int i = 0; i < TmpBuffer.size(); i++) {
s += TmpBuffer[i];
if (i + 1 < TmpBuffer.size() && TmpBuffer[i] != 'X' &&
TmpBuffer[i] == TmpBuffer[i + 1])
s += 'X';
}
if (s.front() != 'X' && s.front() == s.back() && s.front() == 'L') s += 'X';
n = s.size();
double l = 0, r = 1;
while (r - l > 1e-9) {
double mid = (l + r) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
int ans = (l + 1e-9) * 1e8;
printf("%d.%06d\n", ans / 1000000, ans % 1000000);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long K, D, T, cyc;
double ans, roa, lst;
int main() {
scanf("%lld%lld%lld", &K, &D, &T);
cyc = ((K - 1) / D + 1) * D;
roa = 0.5 * (cyc - K) + K;
ans += (long long)(T / roa) * cyc;
lst = T - (long long)(T / roa) * roa;
if (lst < K)
ans += lst;
else
ans = ans + K + 2.0 * (lst - K);
printf("%.1lf\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e6;
int t, n, k, l, r, sa, sk, c = 0, i, j;
int main() {
scanf("%d %d %d %d %d %d", &n, &k, &l, &r, &sa, &sk);
int ans[n + 5];
memset(ans, l, sizeof ans);
int left = sk / k;
int extra = 0;
extra = sk % k;
for (i = 0; i < k; i++)
if (extra)
printf(" %d", left + 1), extra--;
else
printf(" %d", left);
if (n > k) {
int right = sa - sk;
int k1 = n - k;
extra = right % k1;
right = right / k1;
for (i = k; i < n; i++)
if (extra)
printf(" %d", right + 1), extra--;
else
printf(" %d", right);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int x[110], y[110];
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
double dist = 0.0;
for (int i = 0; i < n - 1; i++)
dist += sqrt((x[i] - x[i + 1]) * (x[i] - x[i + 1]) +
(y[i] - y[i + 1]) * (y[i] - y[i + 1]));
cout << fixed << setprecision(7);
cout << dist * k / 50.0 << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int a[n], b[m], i, j, track = 0, flag = 0;
for (i = 0; i < n; ++i) cin >> a[i];
for (i = 0; i < m; ++i) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
if (a[i] == b[j]) {
track = b[j];
flag = 1;
break;
}
}
if (flag) break;
}
if (!flag)
cout << "NO\n";
else {
cout << "YES\n";
cout << "1 " << track << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long num[1501];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, m, l, r, ans = 0, i, j;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> num[i];
for (j = 1; j < i; j++)
if (num[j] > num[i]) ans++;
}
ans %= 2, cin >> m;
while (m--) {
cin >> l >> r;
ans = ans ^ ((r - l + 1) * (r - l) / 2 % 2);
if (ans % 2)
cout << "odd\n";
else
cout << "even\n";
}
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.