solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int countSetBits(unsigned int n) {
unsigned int count1 = 0;
while (n) {
count1++;
n >>= 1;
}
return count1;
}
int main() {
std::ios_base::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
int army[m + 2];
for (int i = 1; i <= m + 1; i++) {
cin >> army[i];
}
int fedor_bits = countSetBits(army[m + 1]);
int ans = 0;
for (int i = 1; i <= m; i++) {
int cnt = 0;
int fedor = army[m + 1];
int curr = army[i];
int j = 0;
int curr_bits = countSetBits(curr);
while (j < max(curr_bits, fedor_bits)) {
int a = fedor % 2;
int b = curr % 2;
if (fedor % 2 != curr % 2) {
cnt++;
}
fedor >>= 1;
curr >>= 1;
j++;
}
if (cnt <= k) ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int diffr(int n) {
vector<int> d;
while (n != 0) {
d.push_back(n % 10);
for (int i = 0; i + 1 < d.size(); i++)
if (d[i] == n % 10) return 0;
n /= 10;
}
return 1;
}
int main() {
int l, r;
cin >> l >> r;
if (diffr(l)) {
cout << l;
return 0;
}
if (diffr(r)) {
cout << r;
return 0;
}
int e = 0;
for (int i = l + 1; i < r; i++)
if (diffr(i)) {
e = 1;
cout << i;
return 0;
}
if (!e) cout << -1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, t, cnt[100];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t;
++cnt[t];
}
for (int i = 1; i <= 50; i++)
if (cnt[i]) {
cout << (cnt[i] <= n / 2 ? "Alice" : "Bob") << endl;
return 0;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, x, y, T, ans, big, cas, num, len;
bool flag;
double a[200005];
double chk(double x) {
double pre, pre2, ans, ans2;
ans = 0;
ans2 = 0;
pre = 0;
pre2 = 0;
for (int i = 1; i <= n; i++) {
pre += a[i] - x;
ans = max(ans, fabs(pre));
pre = max(pre, 0.0);
pre2 += a[i] - x;
ans2 = max(ans2, fabs(pre2));
pre2 = min(pre2, 0.0);
}
return max(fabs(ans), fabs(ans2));
}
int main() {
scanf("%d", &n);
double mx = -0x3fffffff, mi = 0x3fffffff;
for (i = 1; i <= n; i++) {
scanf("%lf", &a[i]);
mx = max(mx, a[i]);
mi = min(mi, a[i]);
}
double l = mi, r = mx;
for (int i = 1; i <= 100; i++) {
double m1 = (r + 2 * l) / 3;
double m2 = (2 * r + l) / 3;
if (chk(m1) < chk(m2))
r = m2;
else
l = m1;
}
printf("%.12lf\n", chk(l));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e5 + 10;
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return {a.first + b.first, a.second + b.second};
}
pair<pair<int, int>, pair<pair<int, int>, pair<int, int> > > ans1, ans2;
vector<int> N[Max];
bool seen[Max];
pair<int, int> lowl[Max];
int blue[Max];
pair<pair<int, int>, pair<int, int> > dp[Max];
void DFS1(int v) {
seen[v] = true;
vector<int> C;
lowl[v] = {0, v};
for (auto u : N[v])
if (!seen[u]) {
DFS1(u);
C.push_back(u);
lowl[v] = max(lowl[u] + pair<int, int>{1, 0}, lowl[v]);
blue[v] += blue[u];
}
if (blue[v]) {
for (auto u : C)
if (blue[u])
dp[v] = max(
pair<pair<int, int>, pair<int, int> >{
dp[u].first + pair<int, int>{1, 2}, dp[u].second},
dp[v]);
} else if (C.size() > 1) {
blue[v]++;
pair<int, int> mx1 = {-1, 0};
pair<int, int> mx2 = {-1, 0};
for (auto u : C)
if (lowl[u] > mx1) {
mx2 = mx1;
mx1 = lowl[u];
} else if (lowl[u] > mx2)
mx2 = lowl[u];
mx1 = mx1 + pair<int, int>{1, 0};
mx2 = mx2 + pair<int, int>{1, 0};
dp[v] = {{0, mx1.first + mx2.first}, {mx1.second, mx2.second}};
}
int childblue = 0;
for (auto u : C)
if (blue[u]) childblue++;
if (childblue > 1) {
pair<pair<int, int>, pair<pair<int, int>, pair<int, int> > > ans;
pair<pair<int, int>, pair<int, int> > mx1;
pair<pair<int, int>, pair<int, int> > mx2;
for (auto u : C)
if (dp[u] > mx1) {
mx2 = mx1;
mx1 = dp[u];
} else if (dp[u] > mx2)
mx2 = dp[u];
mx1 = {mx1.first + pair<int, int>{1, 2}, mx1.second};
mx2 = {mx2.first + pair<int, int>{1, 2}, mx2.second};
ans = make_pair(pair<int, int>{mx1.first.first + mx2.first.first,
mx1.first.second + mx2.first.second},
pair<pair<int, int>, pair<int, int> >{
pair<int, int>{mx1.second.first, mx2.second.first},
pair<int, int>{mx1.second.second, mx2.second.second}});
ans1 = max(ans1, ans);
}
}
pair<int, int> topl[Max];
pair<pair<int, int>, pair<pair<int, int>, pair<int, int> > > mrg(
pair<pair<int, int>, pair<int, int> > a, pair<int, int> b,
pair<int, int> c) {
return make_pair(
pair<int, int>{a.first.first + 1, a.first.second + 2 + b.first + c.first},
make_pair(pair<int, int>{a.second.first, b.second},
pair<int, int>{a.second.second, c.second}));
}
int root = 0;
void DFS2(int v) {
seen[v] = true;
vector<int> C;
for (int u : N[v])
if (!seen[u]) C.push_back(u);
vector<pair<int, int> > prfmx;
vector<pair<int, int> > sufmx;
prfmx.push_back({0, 0});
pair<int, int> suf = {0, 0};
pair<int, int> prf = {0, 0};
for (int i = 0; i < C.size(); i++) {
prf = max(prf, lowl[C[i]]);
prfmx.push_back(prf);
}
for (int i = C.size(); i--;) {
suf = max(suf, lowl[C[i]]);
sufmx.push_back(suf);
}
reverse(sufmx.begin(), sufmx.end());
sufmx.push_back({0, 0});
for (int i = 0; i < C.size(); i++)
topl[C[i]] = max(max(prfmx[i], sufmx[i + 1]) + pair<int, int>{2, 0},
topl[v] + pair<int, int>{1, 0});
for (auto u : C) DFS2(u);
bool childblue = false;
for (auto u : C) childblue |= blue[u];
if (childblue && C.size() > 1 && v != root || C.size() >= 3) {
pair<pair<pair<int, int>, pair<int, int> >, int> mx[3];
pair<pair<int, int>, int> m[3];
for (auto u : C) {
if (blue[u]) {
pair<pair<pair<int, int>, pair<int, int> >, int> a1 = {dp[u], u};
if (a1 > mx[0]) {
mx[2] = mx[1];
mx[1] = mx[0];
mx[0] = a1;
} else if (a1 > mx[1]) {
mx[2] = mx[1];
mx[1] = a1;
} else if (a1 > mx[2])
mx[2] = a1;
}
pair<pair<int, int>, int> a2 = {lowl[u], u};
if (a2 > m[0]) {
m[2] = m[1];
m[1] = m[0];
m[0] = a2;
} else if (a2 > m[1]) {
m[2] = m[1];
m[1] = a2;
} else if (a2 > m[2])
m[2] = a2;
}
if (v != root) {
pair<pair<int, int>, pair<pair<int, int>, pair<int, int> > > ans;
if (mx[0].second != m[0].second)
ans = mrg(mx[0].first, m[0].first, topl[v]);
else
ans = max(mrg(mx[0].first, m[1].first, topl[v]),
mrg(mx[1].first, m[0].first, topl[v]));
ans2 = max(ans2, ans);
}
if (C.size() >= 3) {
pair<pair<int, int>, pair<pair<int, int>, pair<int, int> > > ans;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int k = j + 1; k < 3; k++)
if (mx[i].second != m[j].second && mx[i].second != m[k].second)
ans = max(ans, mrg(mx[i].first, m[j].first, m[k].first));
ans2 = max(ans2, ans);
}
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
N[a].push_back(b);
N[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (N[i].size() > 1) {
root = i;
break;
}
DFS1(root);
for (int i = 1; i <= n; i++) seen[i] = false;
topl[root] = {-6 * n, -2};
DFS2(root);
pair<pair<int, int>, pair<pair<int, int>, pair<int, int> > > ans =
max(ans1, ans2);
cout << '\n';
cout << ans.second.first.first << " " << ans.second.first.second << '\n';
cout << ans.second.second.first << " " << ans.second.second.second << '\n';
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <class T>
using vec = std::vector<T>;
bool __hack = std::ios::sync_with_stdio(false);
auto __hack1 = cin.tie(nullptr);
struct Input {
Input(istream &in) : in(&in) {}
template <class T>
T next() const {
T x;
*in >> x;
return x;
}
int ni() const { return next<int>(); }
istream *in;
};
Input in(cin);
class Output {
private:
ostream *out;
template <typename T>
void printSingle(const T &value) {
*out << value;
}
public:
Output(ostream &out) : out(&out) {}
inline void print() {}
template <typename T, typename... Ts>
inline void print(const T &f, const Ts &...args) {
printSingle(f);
if (sizeof...(args) != 0) {
*out << ' ';
print(args...);
}
}
template <typename... Ts>
inline void println(const Ts &...args) {
print(args...);
*out << '\n';
}
template <typename... Ts>
inline void operator()(const Ts &...args) {
println(args...);
}
template <typename T>
ostream &operator<<(const T &x) {
*out << x;
return *out;
}
};
Output out(cout);
namespace template_util {
constexpr int bytecount(uint64_t x) { return x ? 1 + bytecount(x >> 8) : 0; }
template <int N>
struct bytetype {};
template <uint64_t N>
struct minimal_uint : bytetype<bytecount(N)> {};
} // namespace template_util
void solveOne() {
auto n = in.ni();
auto m = in.ni();
vec<pair<int, int>> edges(m);
for (int i = 0; i < (m); ++i) {
auto x = in.ni() - 1;
auto y = in.ni() - 1;
if (x > y) swap(x, y);
edges[i] = {x, y};
}
vec<int> used(3 * n, 0);
vec<int> takenEdges;
for (int i = 0; i < (m); ++i) {
if (!used[edges[i].first] && !used[edges[i].second]) {
takenEdges.push_back(i);
used[edges[i].first] = true;
used[edges[i].second] = true;
}
if (takenEdges.size() == n) {
out("Matching");
for (const auto &e : takenEdges) {
out << e + 1 << " ";
}
out();
return;
}
}
out("IndSet");
int cnt = 0;
for (int i = 0; i < (3 * n); ++i) {
if (!used[i]) {
out << i + 1 << " ";
++cnt;
}
if (cnt == n) break;
}
out();
}
void solve(istream &inStream, ostream &outStream) {
in = Input(inStream);
out = Output(outStream);
auto tests = in.ni();
while (tests--) {
solveOne();
}
}
int main() {
solve(cin, cout);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long Set(long long N, long long pos) { return N = N | (1 << pos); }
long long reset(long long N, long long pos) { return N = N & ~(1 << pos); }
bool check(long long N, long long pos) { return (bool)(N & (1 << pos)); }
void CI(long long &_x) { cin >> _x; }
void CO(long long &_x) { cout << _x; }
template <typename T>
void getarray(T a[], long long n) {
for (long long i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void prLLIarray(T a[], long long n) {
for (long long i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
const double EPS = 1e-9;
const long long INF = 0x7f7f7f7f;
long long dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
long long dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
long long dr4[4] = {0, 0, 1, -1};
long long dc4[4] = {-1, 1, 0, 0};
long long kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
long long kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
string s1, s2, s3;
int lcp[2105][2105];
int lcp_rev[2105][2105];
int main() {
cin >> s1 >> s2;
s3 = s1;
reverse(s3.begin(), s3.end());
for (int i = s2.size() - 1; i >= 0; i--) {
for (int j = s1.size() - 1; j >= 0; j--)
if (s2[i] == s1[j]) {
lcp[i][j] = 1 + lcp[i + 1][j + 1];
}
for (int j = s3.size() - 1; j >= 0; j--)
if (s2[i] == s3[j]) {
lcp_rev[i][j] = 1 + lcp_rev[i + 1][j + 1];
}
}
vector<pair<int, int> > V;
for (int i = 0; i < s2.size();) {
int maxi = -1, temp;
int pos;
for (int j = 0; j < s1.size(); j++) {
if (maxi < lcp[i][j]) {
pos = j;
maxi = lcp[i][j];
temp = 1;
}
if (maxi < lcp_rev[i][j]) {
pos = j;
maxi = lcp_rev[i][j];
temp = 2;
}
}
int j = pos;
if (maxi == 0) {
puts("-1");
return 0;
}
if (temp == 1) {
V.push_back(make_pair(j + 1, j + maxi));
} else {
int sz = s1.size();
V.push_back(make_pair(sz - j, sz - j - maxi + 1));
}
i += maxi;
}
cout << V.size() << "\n";
for (int i = 0; i < V.size(); i++)
cout << V[i].first << " " << V[i].second << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, t;
cin >> n >> k >> t;
if (t <= k) {
cout << t << endl;
} else if (t > k && t <= n) {
cout << k << endl;
} else {
cout << k - abs(n - t) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
int n, q;
int nxt[maxn][20];
int mx[maxn];
vector<pair<int, int> > v;
void update(int x, int v) {
while (x < maxn) {
mx[x] = max(mx[x], v);
x += x & (-x);
}
}
int query(int x) {
int ret = x;
while (x) {
ret = max(ret, mx[x]);
x -= x & (-x);
}
return ret;
}
int getpa(int x, int p) {
int cur = 0;
int ret = x;
while (p) {
if (p & 1) {
ret = nxt[ret][cur];
}
cur++;
p >>= 1;
}
return ret;
}
void init() {
cin >> n >> q;
while (n--) {
int add1, add2;
cin >> add1 >> add2;
add1++, add2++;
update(add1, add2);
}
for (int i = 1; i <= 500001; i++) {
nxt[i][0] = query(i);
}
for (int i = 1; i <= 19; i++) {
for (int j = 1; j <= 500001; j++) {
nxt[j][i] = nxt[nxt[j][i - 1]][i - 1];
}
}
}
void solve() {
while (q--) {
int x, y;
cin >> x >> y;
x++, y++;
if (getpa(x, 500000) < y) {
cout << -1 << '\n';
continue;
}
int l = 0, r = 500000;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (getpa(x, mid) >= y) {
r = mid;
} else {
l = mid;
}
}
cout << r << '\n';
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
init();
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inv = 1000000000;
const int minv = -inv;
char process(long long a, long long b) {
if (a == 0ll) return 'L';
if (process(b % a, a) == 'L')
return 'W';
else {
long long k = (b - (b % a)) / a;
if ((k % (a + 1ll)) % 2ll)
return 'L';
else
return 'W';
}
}
int main() {
int T;
scanf("%d", &T);
for (int z = 0; z < T; ++z) {
long long a, b;
cin >> a;
cin >> b;
if (a > b) swap(a, b);
if (process(a, b) == 'L')
printf("Second\n");
else
printf("First\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
int n, up;
int B[2];
deque<int> v[3];
using P = pair<int, int>;
vector<P> que;
void move(int id, int c) {
if (c > B[id] || int(v[id].size()) < c) {
throw 1;
}
que.push_back(P(id + 1, c));
deque<int> buf;
for (int i = 0; i < c; i++) {
buf.push_front(v[id].front());
v[id].pop_front();
}
for (int i = 0; i < c; i++) {
v[id + 1].push_front(buf.front());
buf.pop_front();
}
}
void dfs() {
int sz[3] = {int(v[0].size()), int(v[1].size()), int(v[2].size())};
if (sz[2] == n) return;
if (!sz[0] && !sz[1]) throw 1;
for (int i = 1; i < sz[1]; i++) {
if (v[1][i - 1] + 1 < v[1][i]) {
throw 1;
}
}
int m = 0;
for (int d : v[1]) {
m = max(m, d);
}
if (m == up) {
int c = 0;
while (v[1][c] != up) c++;
move(1, c + 1);
up -= c + 1;
dfs();
return;
}
int mi = v[0][0], ma = v[0][0];
bool di = false;
int co = 0;
int r = sz[0];
int fr = -1;
for (int i = 1; i < sz[0]; i++) {
if (v[0][i - 1] + 1 < v[0][i]) {
r = i;
break;
}
if (v[0][i - 1] > v[0][i]) {
if (fr == -1) {
fr = i;
}
co++;
}
mi = min(mi, v[0][i]);
ma = max(ma, v[0][i]);
}
co++;
if (co == 1) {
fr = r;
}
if (ma == up) {
move(0, 1);
dfs();
return;
}
if (sz[1] && mi < v[1][0]) {
int c = 0;
while (c < r && v[0][c] != v[1][0] - 1) {
c++;
}
if (v[0][c] == v[1][0] - 1) c++;
move(0, c);
dfs();
return;
}
if (ma - mi + 1 != r) {
move(0, r);
dfs();
return;
}
int u = (ma - m);
if (co >= 3) {
if (u <= B[1] || r <= min(B[0], B[1])) {
move(0, fr);
} else {
move(0, r);
}
dfs();
return;
}
if (fr <= B[0] && r - fr <= B[0] && u <= B[1]) {
move(0, fr);
dfs();
return;
}
if (co == 1) {
if (fr <= min(B[1], B[0])) {
move(0, fr);
} else {
move(0, 1);
}
dfs();
return;
}
int bi = m + B[1];
if (r - fr < B[1]) {
move(0, min(B[0], min(fr, B[1] - (r - fr))));
dfs();
return;
}
if (r - fr == B[1] && r <= B[0]) {
move(0, r);
dfs();
return;
}
move(0, min(B[0], fr + B[1]));
dfs();
return;
}
int main() {
cin >> n >> B[0] >> B[1];
up = n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v[0].push_back(x);
}
try {
dfs();
cout << "YES" << endl;
cout << que.size() << endl;
for (auto p : que) {
cout << p.first << " " << p.second << endl;
}
} catch (int a) {
cout << "NO" << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
vector<long long> v, ans;
long long floyd[505][505] = {};
bool vis[505] = {};
int main() {
ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
;
int n;
cin >> n;
for (int i = 1; i <= (int)n; ++i)
for (int j = 1; j <= (int)n; ++j) cin >> floyd[i][j];
for (int i = 1; i <= (int)n; ++i) {
int x;
cin >> x;
v.push_back(x);
}
reverse(v.begin(), v.end());
for (auto u : v) {
long long answer = 0;
vis[u] = true;
for (int i = 1; i <= (int)n; ++i)
for (int j = 1; j <= (int)n; ++j)
floyd[i][j] = min(floyd[i][j], floyd[i][u] + floyd[u][j]);
for (int i = 1; i <= (int)n; ++i)
for (int j = 1; j <= (int)n; ++j)
if (vis[i] && vis[j]) answer += floyd[i][j];
ans.push_back(answer);
}
reverse(ans.begin(), ans.end());
for (auto u : ans) cout << u << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2000 * 1000 * 1000;
const int MAXN = 1010;
const int MAXM = 30010;
template <typename T>
inline T sqr(T n) {
return n * n;
}
int n, m;
vector<int> g[MAXN];
bool used[MAXN];
int tin[MAXN], tout[MAXN], fup[MAXN];
int parent[MAXN];
int timer;
int from[MAXM], to[MAXM], cost[MAXM];
int lastEdge, blockedEdge = -1;
bool isBridge[MAXM];
int getTo(int idx, int v) {
if (v == from[idx]) {
return to[idx];
}
return from[idx];
}
void dfs(int v) {
used[v] = true;
fup[v] = tin[v] = timer++;
for (int idx : g[v]) {
if (idx == blockedEdge || idx == parent[v]) {
continue;
}
int dest = getTo(idx, v);
if (!used[dest]) {
parent[dest] = idx;
dfs(dest);
fup[v] = min(fup[v], fup[dest]);
if (tin[v] < fup[dest]) {
isBridge[idx] = true;
}
} else {
fup[v] = min(fup[v], tin[dest]);
}
}
tout[v] = timer++;
}
int main() {
scanf("%d%d", &n, &m);
int s, t;
scanf("%d%d", &s, &t);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &from[lastEdge], &to[lastEdge], &cost[lastEdge]);
g[from[lastEdge]].push_back(lastEdge);
g[to[lastEdge]].push_back(lastEdge);
lastEdge++;
}
parent[s] = -1;
dfs(s);
if (!used[t]) {
puts("0");
puts("0");
return 0;
}
vector<int> edges;
int v = t;
while (v != s) {
edges.push_back(parent[v]);
v = getTo(parent[v], v);
}
int ansCost = INF + 100;
vector<int> ans;
for (int idx : edges) {
if (isBridge[idx] && cost[idx] < ansCost) {
ansCost = cost[idx];
ans = {idx + 1};
}
}
for (int idx : edges) {
blockedEdge = idx;
memset(used, false, sizeof used);
memset(isBridge, false, sizeof isBridge);
memset(parent, 255, sizeof parent);
timer = 0;
dfs(s);
if (!used[t]) {
continue;
}
int v = t;
while (v != s) {
if (isBridge[parent[v]] && cost[parent[v]] + cost[idx] < ansCost) {
ansCost = cost[parent[v]] + cost[idx];
ans = {idx + 1, parent[v] + 1};
}
v = getTo(parent[v], v);
}
}
if (ansCost == INF + 100) {
puts("-1");
return 0;
}
printf("%d\n", ansCost);
printf("%d\n", (int)ans.size());
for (int x : ans) {
printf("%d ", x);
}
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 5e5 + 100;
int a[maxx], n, k;
inline int check_min(int x) {
long long sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] > x) break;
sum += x - a[i];
}
if (sum > k)
return 0;
else
return 1;
}
inline int check_max(int x) {
long long sum = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] < x) break;
sum += a[i] - x;
}
if (sum > k)
return 0;
else
return 1;
}
inline void slove() {
scanf("%d%d", &n, &k);
long long sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
sum += a[i];
}
sort(a, a + n);
int al, ar;
if (sum % n == 0)
al = sum / n, ar = sum / n;
else
al = sum / n, ar = sum / n + 1;
int l = a[0], r = al;
int ansl = a[0], ansr = a[0];
while (r >= l) {
int mid = (r + l) >> 1;
if (check_min(mid)) {
ansl = mid;
l = mid + 1;
} else
r = mid - 1;
}
l = ar, r = a[n - 1];
while (r >= l) {
int mid = (r + l) >> 1;
if (check_max(mid)) {
ansr = mid;
r = mid - 1;
} else
l = mid + 1;
}
printf("%d\n", ansr - ansl);
}
int main() {
slove();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int size[300005], cen[300005], fa[300005];
vector<int> son[300005];
void dfs(int x) {
vector<int>::iterator it;
cen[x] = x;
size[x] = 1;
for (it = son[x].begin(); it != son[x].end(); ++it)
dfs(*it), size[x] += size[*it];
for (it = son[x].begin(); it != son[x].end(); ++it)
if (size[*it] * 2 > size[x]) cen[x] = cen[*it];
while ((size[x] - size[cen[x]]) * 2 > size[x]) cen[x] = fa[cen[x]];
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
fa[1] = 1;
for (int i = 2; i <= n; ++i) {
scanf("%d", &fa[i]);
son[fa[i]].push_back(i);
}
dfs(1);
for (int i = 1; i <= q; ++i) {
int qu;
scanf("%d", &qu);
printf("%d\n", cen[qu]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = 0;
cin >> n >> m;
int last = 0;
for (int i = 1; i <= m; ++i) {
string s;
cin >> s;
bool flag = false;
for (int j = 0; j < s.size(); ++j)
if (s[j] == '0') flag = true;
if (!flag)
last = i;
else
ans = max(ans, i - last);
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const char ln = '\n';
int main() {
int n;
cin >> n;
cout << 3 * n + 4 << ln;
cout << -1 << ' ' << -1 << ln;
cout << 0 << ' ' << -1 << ln;
for (int i = 0; i < n; ++i) {
cout << i - 1 << ' ' << i << ln;
cout << i << ' ' << i << ln;
cout << i + 1 << ' ' << i << ln;
}
cout << n - 1 << ' ' << n << ln;
cout << n << ' ' << n << ln;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int N;
int isok(char str1[], char str2[], int L, int R) {
int ok = 1;
for (int i = L + 1; i <= R; i++)
if (str1[i] != str2[i - 1]) ok = 0;
return ok;
}
int main() {
char str1[maxn], str2[maxn];
while (~scanf("%d", &N)) {
int pos1, pos2;
scanf("%s", str1);
scanf("%s", str2);
for (int i = 0; i < N; i++)
if (str1[i] != str2[i]) {
pos1 = i;
break;
}
for (int i = N - 1; i >= 0; i--)
if (str1[i] != str2[i]) {
pos2 = i;
break;
}
int ans = 0;
ans += isok(str1, str2, pos1, pos2);
ans += isok(str2, str1, pos1, pos2);
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<int, pair<int, int> > mp;
vector<int> ans;
int main() {
cin >> n >> m;
int distinct = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
mp[x] = make_pair(mp[x].first + 1, i + 1);
}
bool possible = true, ambiguity = false;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (mp[x].first == 0)
possible = false;
else if (mp[x].first > 1)
ambiguity = true;
else
ans.push_back(mp[x].second);
}
if (possible && !ambiguity) {
cout << "Possible\n";
for (int i = 0; i < m; i++) cout << ans[i] << " ";
} else if (possible && ambiguity)
cout << "Ambiguity";
else
cout << "Impossible";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 123;
bitset<maxn> s[7];
int n, m, t, num[maxn], a[11];
int dfs(int cnt, int pos) {
int ans = 1;
for (int i = 0; i < cnt; i++) ans = (long long)ans * num[a[i]] % 1000000007;
if (cnt < 6) {
for (int i = pos; i <= m / 2; i++) {
if (!num[i] || s[cnt][i] || s[cnt][m - i]) continue;
a[cnt] = i;
s[cnt + 1] = s[cnt];
s[cnt + 1] |= s[cnt] << i;
s[cnt + 1] |= s[cnt] >> i;
s[cnt + 1] |= s[cnt] << (m - i);
s[cnt + 1] |= s[cnt] >> (m - i);
ans += dfs(cnt + 1, i + 1);
if (ans >= 1000000007) ans -= 1000000007;
}
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &t);
while (t--) {
int x;
scanf("%d", &x);
x %= m;
x = min(x, m - x);
num[x]++;
}
s[0][0] = 1;
printf("%d\n", dfs(0, 1));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
long long n, A, cf, cm, m;
struct P {
long long x, id;
void read(int px) {
cin >> x;
id = px;
}
} p[N];
bool cmp1(const P a, const P b) { return a.x > b.x; }
bool cmp2(const P a, const P b) { return a.id < b.id; }
long long co[N], sum[N], sum2[N];
int main() {
cin >> n >> A >> cf >> cm >> m;
for (int i = 1; i <= n; ++i) p[i].read(i);
sort(p + 1, p + n + 1, cmp1);
for (int i = 1; i <= n; ++i) {
co[i] = A - p[i].x;
sum[i] = sum[i - 1] + co[i];
}
sum2[n + 1] = 0;
for (int i = n; i >= 1; --i) sum2[i] = sum2[i + 1] + p[i].x;
long long ans = 0, cx;
int px = 0, py = n + 1, tmpy = 0;
p[0].x = A;
for (int i = 0; i <= n && sum[i] <= m; ++i) {
long long ls = m - sum[i];
tmpy = max(i + 1, tmpy);
while (tmpy < n && (p[tmpy].x * (n - tmpy + 1) > (sum2[tmpy] + ls))) tmpy++;
long long mx = (tmpy > n ? p[n].x : (sum2[tmpy] + ls) / (n - tmpy + 1));
long long cnt = i;
if (mx >= A) {
mx = A;
cnt += (n - tmpy + 1);
}
long long tmpans = cf * cnt + cm * mx;
if (tmpans > ans) {
ans = tmpans;
px = i;
py = tmpy;
cx = mx;
}
}
for (int i = 1; i <= n; ++i) {
if (i <= px) p[i].x = A;
if (i >= py) p[i].x = cx;
}
sort(p + 1, p + n + 1, cmp2);
cout << ans << endl;
for (int i = 1; i <= n; ++i) cout << p[i].x << ' ';
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s;
vector<int> v;
int res;
int main() {
cin >> s;
int n = s.size();
for (int i = 3; i < n; i++) {
if (s[i - 3] == 'b' && s[i - 2] == 'e' && s[i - 1] == 'a' && s[i] == 'r')
v.push_back(i - 3);
}
for (int i = 0; i < v.size(); i++) {
if (!i) {
res += (v[i] + 1) * (n - v[i] - 3);
} else {
res += (v[i] - v[i - 1]) * (n - v[i] - 3);
}
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool is_pali(string s) {
string temp = s;
reverse(temp.begin(), temp.end());
if (s == temp)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
char input[12], output[12];
cin >> input;
string s;
int length = (int)strlen(input);
bool ok = false;
for (int i = 0; i <= 25 && !ok; i++) {
memset(output, '\0', sizeof(output));
for (int j = 0; j <= length; j++) {
for (int k = 0, m = 0; k <= length; k++) {
if (k == j)
output[k] = (char)(i + 97);
else {
output[k] = input[m];
m++;
}
}
output[length + 1] = '\0';
s = output;
if (is_pali(s)) {
cout << s << endl;
return 0;
}
}
}
cout << "NA" << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("O4,unroll-loops,no-stack-protector")
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
char str[50], sorted[50];
int n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str[i];
sorted[i] = str[i];
}
sort(sorted, sorted + n);
for (int i = 0; i < n; i++) {
if (sorted[i] != str[i]) ans++;
}
cout << ans << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int N = 0;
long long p, q, x;
int n;
int main() {
cin >> p >> q >> n;
for (auto T = 1; T <= n; T++) {
cin >> x;
if (q == 0) {
printf("NO");
return 0;
}
if (x > p / q) {
printf("NO");
return 0;
}
p -= x * q;
if (p > q) {
printf("NO");
return 0;
}
swap(p, q);
}
if (q == 0)
printf("YES");
else
printf("NO");
}
| 4 |
#include <bits/stdc++.h>
bool notp[100000];
int ans, val[9], p[9], n, dp[6][100000];
void dfs(int r, int c) {
if (r == n) {
int t = 1;
for (int i = 1; i < n; ++i) t *= dp[n - 1 - i][val[i]];
ans += t;
return;
}
if (c == n) {
dfs(r + 1, r + 2);
return;
}
for (int i = 0; i < 10; ++i) {
val[r] += i * p[n - 1 - c];
val[c] += i * p[n - 1 - r];
dfs(r, c + 1);
val[r] -= i * p[n - 1 - c];
val[c] -= i * p[n - 1 - r];
}
}
int main() {
int T;
char s[9];
p[0] = 1;
for (int i = 1; i < 7; ++i) p[i] = p[i - 1] * 10;
for (int i = 2; i < 100000; ++i)
if (!notp[i]) {
if (i < 316)
for (int j = i * i; j < 100000; j += i) notp[j] = 1;
for (int j = 0; j < 6; ++j) dp[j][i / p[j + 1] * p[j + 1] + i % p[j]]++;
}
while (scanf("%d", &T) != EOF) {
while (T--) {
scanf("%s", s);
ans = val[0] = 0;
for (n = 0; s[n]; ++n) val[0] = val[0] * 10 + s[n] - '0';
for (int i = 1; i < n; ++i) val[i] = (s[i] - '0') * p[n - 1];
dfs(1, 2);
printf("%d\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) putchar('1');
puts("");
for (int i = 1; i < n; ++i) putchar('8');
puts("9");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long ans, p;
int main() {
scanf("%d", &n);
p = 2;
for (int i = 1; i <= n; i++) {
cout << (long long)i * (i + 1) * (i + 1) - p / i << endl;
p = (long long)i * (i + 1);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Pair {
string colour{" "};
string name{" "};
};
int last(int a[], int m, int n) {
int j = 0;
for (int i = 0; i < n; i++) {
if (a[i] == m) {
j = i;
}
}
return j + 1;
}
int main() {
int n, m;
cin >> n >> m;
int a[n];
int b[m];
int c[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
int k = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j]) {
c[k] = a[i];
++k;
break;
}
}
}
for (int i = 0; i < k; i++) {
cout << c[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (true) {
if (a > b) swap(a, b);
if (a == 0) return b;
long long p = b % a, q = a;
a = p;
b = q;
}
}
long long powerMod(long long x, long long y) {
long long res = 1;
x %= 998244353;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res % 998244353;
}
vector<int> tree;
vector<int> a;
void upd(int idx, int v) {
for (; idx < tree.size(); idx += (idx & (-idx))) {
tree[idx] += v;
}
}
void updr(int start, int end, int v) {
upd(start, v);
upd(end + 1, -v);
}
int query(int idx) {
int sum = 0;
for (; idx > 0; idx -= (idx & (-idx))) {
sum += tree[idx];
}
return sum;
}
int get_max_left(int right) {
int l = 1, m, answer = 0;
int r = right;
while (l <= r) {
m = l + (r - l) / 2;
if (query(m) >= a[right]) {
answer = m;
l = m + 1;
} else
r = m - 1;
}
return answer;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int n, q, i, j, k, l, p;
cin >> n >> q;
a.resize(n + 1);
tree.resize(n + 2, 0);
for (i = 1; i <= n; i++) {
cin >> a[i];
a[i] = i - a[i];
}
vector<vector<pair<int, int> > > queries(n + 1);
for (i = 0; i < q; i++) {
cin >> j >> k;
k = n - k;
queries[k].push_back({j + 1, i});
}
vector<int> answers(q);
for (i = 1; i <= n; i++) {
if (a[i] >= 0) {
l = get_max_left(i);
if (l) updr(1, l, 1);
}
for (auto ii : queries[i]) {
answers[ii.second] = query(ii.first);
}
}
for (auto i : answers) {
cout << i << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void dfs(long long v, vector<long long>& h, vector<vector<long long>>& g,
long long p = -1) {
for (auto u : g[v]) {
if (u == p) continue;
h[u] = h[v] + 1;
dfs(u, h, g, v);
}
}
void solve() {
long long n, a, b, da, db;
cin >> n >> a >> b >> da >> db;
--a, --b;
vector<vector<long long>> g(n);
for (long long i = 1; i < n; ++i) {
long long x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
vector<long long> h(n);
dfs(a, h, g);
long long v0 = a;
for (long long i = 0; i < n; ++i) {
if (h[i] > h[v0]) {
v0 = i;
}
}
if (h[b] <= da) {
cout << "Alice\n";
return;
}
h[v0] = 0;
dfs(v0, h, g);
long long d = 0;
for (long long i = 0; i < n; ++i) {
d = max(d, h[i]);
}
if (2 * da >= min(db, d)) {
cout << "Alice\n";
return;
}
cout << "Bob\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tt;
cin >> tt;
while (tt--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 30, Mod = 1e9 + 7;
const long long SQ = 330;
set<long long> G[N];
set<pair<long long, long long> > second;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
long long n, q;
cin >> n >> q;
long long res = 0;
long long ans = 0;
for (int i = 0; i < q; i++) {
long long t, x;
cin >> t >> x;
if (t == 1) {
G[x].insert(++res);
second.insert({res, x});
}
if (t == 2) {
for (auto u : G[x]) second.erase({u, x});
G[x].clear();
}
if (t == 3) {
vector<pair<long long, long long> > vec;
for (auto it = second.begin(); it != second.end(); it++) {
auto f = *it;
if (f.first > x) break;
vec.push_back(f);
G[f.second].erase(f.first);
}
for (auto u : vec) second.erase(u);
}
cout << second.size() << '\n';
}
return (0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class DebugStream {
} LOG;
template <typename T>
DebugStream &operator<<(DebugStream &s, const T &) {
return s;
}
const int maxN = 1e5 + 9, maxV = 1e6 + 9, MOD = 1e9 + 7, SQ = 335, lg = 20,
bs = 29;
string st;
int n, dp[maxN][11];
const int key[11] = {-1, 9, 9, 10, 1, 4, 8, 2, 8, 4, 1};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> st;
n = st.size();
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = st[i] - '0' + 1; j < 11; j++) {
int newK = (j + key[j] + st[i] - '0') % 11;
dp[i][j] = dp[i + 1][newK] + 1;
}
if (st[i] != '0') ans += dp[i + 1][st[i] - '0'] + 1;
}
cout << ans << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long x, y, n;
cin >> x >> y >> n;
long long k;
k = n / x;
while (k < n) {
if ((k * x) + y <= n) {
break;
} else {
k--;
}
}
cout << k * x + y << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
long long a[120000];
long long b[120000];
vector<pair<int, long long> > eds[120000];
int n;
long long mul(long long a, long long b) {
if (a == 0) return 0;
if (INF / a < b) return INF;
return a * b;
}
long long dfs1(int v) {
long long hv = b[v];
long long nd = a[v];
for (auto e : eds[v]) {
long long x = dfs1(e.first);
if (x < 0) {
nd = min(INF, nd + mul(-x, e.second));
} else {
hv += x;
}
}
return hv - nd;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%lld", b + i);
for (int i = 0; i < n; ++i) scanf("%lld", a + i);
for (int i = 1; i < n; ++i) {
int x;
long long k;
scanf("%d%lld", &x, &k);
--x;
eds[x].push_back(make_pair(i, k));
}
long long ans = dfs1(0);
if (ans < 0)
cout << "NO\n";
else
cout << "YES\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int N = 2e5 + 10;
const ll inf = 1e15 + 42;
const ll mod = 1000000007;
void testCase() {
int n, m, p;
cin >> n >> m >> p;
int ans = 0;
int flg = 1;
for (int i = 0; i < n; i++) {
int v;
cin >> v;
if (flg && v % p != 0) {
ans += i;
flg = 0;
}
}
flg = 1;
for (int i = 0; i < m; i++) {
int v;
cin >> v;
if (flg && v % p != 0) {
ans += i;
flg = 0;
}
}
cout << ans << "\n";
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
testCase();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("abc.in");
vector<long> v;
string str[] = {" popQueue", " popStack", " popFront"};
long n, i, x, mx[3], j;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
if (x != 0) {
v.push_back(x);
if (x > mx[2]) {
mx[0] = mx[1];
mx[1] = mx[2];
mx[2] = x;
} else if (x > mx[1]) {
mx[0] = mx[1];
mx[1] = x;
} else if (x > mx[0])
mx[0] = x;
} else {
int cnt = 3;
if (mx[0] == 0) cnt--;
if (mx[1] == 0) cnt--;
if (mx[2] == 0) cnt--;
for (j = 0; j < v.size(); j++) {
if (v[j] == mx[0]) {
cout << "pushFront\n";
mx[0] = 0;
} else if (v[j] == mx[1]) {
cout << "pushStack\n";
mx[1] = 0;
} else if (v[j] == mx[2]) {
cout << "pushQueue\n";
mx[2] = 0;
} else
cout << "pushBack\n";
}
cout << cnt;
for (j = 0; j < cnt; j++) cout << str[j];
if (i != n) cout << '\n';
v.clear();
}
}
if (v.size() != 0)
for (i = 1; i <= v.size(); i++) cout << "pushBack\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> suf(1000010);
vector<int> val(1000010);
const int inf = 1 << 30;
struct lazy_segtree {
vector<int> value;
vector<int> lazy;
int sz;
void init(int n) {
sz = 1;
while (sz < n) sz <<= 1;
value.assign(2 * sz, inf);
lazy.assign(2 * sz, 0);
}
void build(vector<int> &a, int x, int lx, int rx) {
if (rx - lx == 1) {
if (lx < a.size()) value[x] = a[lx];
return;
}
int mid = (lx + rx) >> 1;
build(a, 2 * x + 1, lx, mid);
build(a, 2 * x + 2, mid, rx);
value[x] = min(value[2 * x + 1], value[2 * x + 2]);
}
void build(vector<int> &a) { build(a, 0, 0, sz); }
void pushdown(int x, int lx, int rx) {
value[x] += lazy[x];
if (rx - lx != 1) {
lazy[2 * x + 1] += lazy[x];
lazy[2 * x + 2] += lazy[x];
}
lazy[x] = 0;
}
void set(int l, int r, int v, int x, int lx, int rx) {
pushdown(x, lx, rx);
if (lx >= r || rx <= l) return;
if (lx >= l && rx <= r) {
lazy[x] += v;
pushdown(x, lx, rx);
return;
}
int mid = (lx + rx) >> 1;
set(l, r, v, 2 * x + 1, lx, mid);
set(l, r, v, 2 * x + 2, mid, rx);
value[x] = min(value[2 * x + 1], value[2 * x + 2]);
}
void set(int l, int r, int v) { set(l, r, v, 0, 0, sz); }
int calc(int x, int lx, int rx) {
pushdown(x, lx, rx);
if (rx - lx == 1) {
if (value[x] < 0)
return lx;
else
return -1;
}
int mid = (lx + rx) >> 1;
pushdown(2 * x + 1, lx, mid);
pushdown(2 * x + 2, mid, rx);
if (value[x] >= 0) return -1;
if (value[2 * x + 2] < 0)
return calc(2 * x + 2, mid, rx);
else
return calc(2 * x + 1, lx, mid);
}
int calc() { return calc(0, 0, sz); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(n), b(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
val[a[i]]--;
}
for (int i = 0; i < m; i++) {
cin >> b[i];
val[b[i]]++;
}
suf[1000010 - 1] = val[1000010 - 1];
for (int i = 1000010 - 2; i >= 0; i--) suf[i] = suf[i + 1] + val[i];
lazy_segtree s;
s.init(1000010);
s.build(suf);
int q;
cin >> q;
while (q--) {
int op;
cin >> op;
if (op == 1) {
int i, x;
cin >> i >> x;
i--;
s.set(0, a[i] + 1, 1);
a[i] = x;
s.set(0, a[i] + 1, -1);
} else {
int i, x;
cin >> i >> x;
i--;
s.set(0, b[i] + 1, -1);
b[i] = x;
s.set(0, b[i] + 1, 1);
}
cout << s.calc() << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long k[100005];
vector<int> Ed[100005];
int St, n;
void Add(int u, int v) {
Ed[u].push_back(v);
Ed[v].push_back(u);
}
long long Dp(int u, int fa) {
k[u]--;
vector<long long> R;
long long res = 0;
long long Ret = 0;
for (int i = 0; i < Ed[u].size(); i++)
if (Ed[u][i] != fa) {
long long P = Dp(Ed[u][i], u);
R.push_back(P);
res += k[Ed[u][i]];
}
sort(R.begin(), R.end());
for (int i = R.size() - 1; i >= 0 && k[u]; i--) Ret += 2, Ret += R[i], k[u]--;
Ret += min(res, k[u]) * 2, k[u] -= min(res, k[u]);
return Ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", k + i);
for (int i = 1, u, v; i < n; i++) scanf("%d%d", &u, &v), Add(u, v);
scanf("%d", &St);
k[St]++;
printf("%I64d\n", Dp(St, 0));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
else if (a % b == 0)
return b;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
void test_case() {
int n, k;
cin >> n >> k;
std::vector<int> v(n);
for (int i = 0; i < (n); i++) {
cin >> v[i];
}
std::vector<int> v1(k);
for (int i = 0; i < (k); i++) {
cin >> v1[i];
}
sort(v1.begin(), v1.end(), greater<int>());
int p = 0;
for (int i = 0; i < n; i++) {
if (v[i] == 0) {
v[i] = v1[p];
p++;
}
}
bool flag = false;
for (int i = 1; i < n; i++) {
if (v[i - 1] > v[i]) {
flag = true;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return;
}
int main() {
int t;
t = 1;
while (t--) {
test_case();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return f * x;
}
int n, a[100003], mx;
long long ans, f[100003], s;
long long pow_mod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
b >>= 1;
a = a * a % 1000000007;
}
return ans;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read(), s += a[i], mx = max(mx, a[i]);
f[1] =
(s - 1) * (s - 1) % 1000000007 * pow_mod(s, 1000000007 - 2) % 1000000007;
f[2] = (2 * f[1] - 1 + 1000000007) % 1000000007;
for (int i = 2; i < mx; ++i) {
long long x = (f[i - 1] - f[i] + 1000000007) % 1000000007;
x = (x + (s - 1) * pow_mod(s - i, 1000000007 - 2) % 1000000007) %
1000000007;
f[i + 1] = (f[i] - x + 1000000007) % 1000000007;
}
for (int i = 1; i <= n; ++i) ans = (ans + f[a[i]]) % 1000000007;
cout << ans << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n % 2 == 0)
for (i = 0; i < n / 2; ++i) cout << '1';
else {
cout << '7';
for (i = 0; i < (n - 3) / 2; ++i) cout << '1';
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int mod = 998244353;
vector<vector<vector<int> > > dp(2,
vector<vector<int> >(205, vector<int>(2, 0)));
vector<vector<vector<int> > > sum(2,
vector<vector<int> >(205, vector<int>(2, 0)));
int a[N];
int n;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
a[0] = a[n + 1] = 0;
for (int p = 200; p >= 0; --p) {
dp[(n + 1) & 1][p][0] = 0;
dp[(n + 1) & 1][p][1] = 1;
sum[(n + 1) & 1][p][1] =
(sum[(n + 1) & 1][p + 1][1] + dp[(n + 1) & 1][p][1]) % mod;
}
for (int i = n; i > 0; i--) {
int idx = i & 1;
for (int p = 200; p >= 0; p--) {
if (a[i] != -1) {
if (p > a[i]) {
dp[idx][p][0] = 0;
} else if (p < a[i]) {
dp[idx][p][0] = dp[idx ^ 1][a[i]][0];
} else
dp[idx][p][0] = dp[idx ^ 1][a[i]][1];
} else {
dp[idx][p][0] = sum[idx ^ 1][p + 1][0];
if (p > 0) dp[idx][p][0] = (dp[idx][p][0] + dp[idx ^ 1][p][1]) % mod;
}
sum[idx][p][0] = (sum[idx][p + 1][0] + dp[idx][p][0]) % mod;
if (a[i] != -1) {
if (p >= a[i]) {
dp[idx][p][1] = dp[idx ^ 1][a[i]][1];
} else
dp[idx][p][1] = dp[idx ^ 1][a[i]][0];
} else {
dp[idx][p][1] = (sum[idx ^ 1][p + 1][0] + sum[idx ^ 1][1][1]) % mod -
sum[idx ^ 1][p + 1][1];
dp[idx][p][1] = (dp[idx][p][1] + mod) % mod;
}
sum[idx][p][1] = (sum[idx][p + 1][1] + dp[idx][p][1]) % mod;
}
}
cout << dp[1][1][0];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
long long int n, Q;
cin >> n >> Q;
while (Q--) {
long long int q;
cin >> q;
while (q % 2 != 1) {
q = n + q / 2;
}
cout << (q + 1) / 2 << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int a[maxn];
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int ok = 0;
for (int i = 1; i <= n; i++) {
for (int j = n; j > i + 1; j--) {
if (a[i] == a[j]) {
ok = 1;
break;
}
}
}
cout << (ok ? "YES" : "NO") << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long i, k, t, n, d, j, a[100005], s;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n - 2; i++) {
t = upper_bound(a + i, a + n + 1, a[i] + k) - a - i - 1;
s = s + t * (t - 1) / 2;
}
cout << s << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long int a, b, c, l;
int main() {
ios::sync_with_stdio(false);
cin >> a >> b >> c >> l;
unsigned long long int ans = ((l + 3) * (l + 2) * (l + 1)) / (6);
for (int i = 0; i <= l; i++) {
if (a + i >= b + c) {
unsigned long long int x =
((a + i - b - c) < (l - i) ? (a + i - b - c) : (l - i));
ans -= ((x + 2) * (x + 1)) / (2);
}
}
for (int i = 0; i <= l; i++) {
if (b + i >= a + c) {
unsigned long long int x =
((b + i - a - c) < (l - i) ? (b + i - a - c) : (l - i));
ans -= ((x + 2) * (x + 1)) / (2);
}
}
for (int i = 0; i <= l; i++) {
if (c + i >= b + a) {
unsigned long long int x =
((c + i - a - b) < (l - i) ? (c + i - a - b) : (l - i));
ans -= ((x + 2) * (x + 1)) / (2);
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename t1, typename t2>
inline bool upmax(t1 &a, t2 b) {
if (a < (t1)b) {
a = (t1)b;
return true;
} else
return false;
}
template <typename t1, typename t2>
inline bool upmin(t1 &a, t2 b) {
if (a > (t1)b) {
a = (t1)b;
return true;
} else
return false;
}
template <typename T>
inline bool pal(T &x) {
int n = (int((x.size())));
for (int i = 0; i < n / 2; i++) {
if (x[i] != x[n - i - 1]) return 0;
}
return 1;
}
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
inline T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
int month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
inline long long mp(long long a, long long b) { return (a << 31) + b; }
class PQ_compare {
public:
bool operator()(const int a, const int b) const { return 1; }
};
const int INF = 1000000404;
const long long LINF = 4000000000000000404ll;
const long long MOD = 1000000007ll;
const long double PI = acos(-1.0);
const long double EPS = 1e-9;
int SQ = 404;
int a[411111];
int last[411111];
int nxt[411111];
int sdgdf[411111];
void solve() {
int n, k;
cin >> n >> k;
for (int i = 1; i < n + 1; i++) nxt[i] = INF;
for (int i = 1; i < n + 1; i++) {
cin >> a[i];
if (last[a[i]] == 0) {
} else {
nxt[last[a[i]]] = i;
}
last[a[i]] = i;
}
int ans = 0;
set<int> now;
set<pair<int, int> > s;
for (int i = 1; i < n + 1; i++) {
if (!now.count(a[i])) {
ans++;
if ((int((now.size()))) < k) {
now.insert(a[i]);
s.insert(make_pair(-nxt[i], a[i]));
} else {
int v = s.begin()->second;
s.erase(s.begin());
now.erase(v);
now.insert(a[i]);
s.insert(make_pair(-nxt[i], a[i]));
}
sdgdf[a[i]] = -nxt[i];
} else {
s.erase(make_pair(sdgdf[a[i]], a[i]));
sdgdf[a[i]] = -nxt[i];
s.insert(make_pair(-nxt[i], a[i]));
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s;
string s0 = s;
auto p = unique(s0.begin(), s0.end());
if (p == s0.begin() + 1) {
cout << -1 << endl;
} else {
sort(s.begin(), s.end());
cout << s << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace TYC {
const int N = 1000 + 5, DIGIT = 10, INF = 0x3f3f3f3f;
int n, len, F[N][N], Val[DIGIT], Cnt[DIGIT], Sum[DIGIT], B[N][N], Id[N],
Bask[DIGIT], Q[N], T[N], OK[N][DIGIT], L[N];
char S[N];
inline int ctoi(int *v) {
int t = strlen(S + 1);
reverse(S + 1, S + 1 + t);
for (int i = 1; i <= t; i++)
if (S[i] == '?')
v[i] = DIGIT + 1;
else
v[i] = S[i] - '0';
return t;
}
inline void radix_sort(const int p) {
for (int i = 1; i <= n; i++) T[i] = B[Id[i]][p];
memset(Bask, 0, sizeof(Bask));
for (int i = 1; i <= n; i++) Bask[T[i]]++;
for (int i = 1; i < DIGIT; i++) Bask[i] += Bask[i - 1];
for (int i = n; i; i--) Q[Bask[T[i]]--] = Id[i];
memcpy(Id, Q, sizeof(int[n + 1]));
}
void work() {
scanf("%s%d", S + 1, &n);
len = strlen(S + 1);
int al = len;
reverse(S + 1, S + 1 + len);
for (int i = 1; i <= len; i++)
if (S[i] == '?')
fill(OK[i], OK[i] + DIGIT, 1);
else
OK[i][S[i] - '0'] = 1;
OK[len][0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", S + 1);
len = max(len, L[i] = ctoi(B[i]));
L[i] = max(L[i], al);
Id[i] = i;
}
++len;
for (int i = al + 1; i <= len; i++) OK[i][0] = 1;
for (int i = 0; i < DIGIT; i++) scanf("%d", &Val[i]);
for (int i = 0; i <= len; i++)
for (int j = 0; j <= n; j++) F[i][j] = -INF;
F[0][0] = 0;
for (int p = 1; p <= len; p++) {
for (int c = 0; c < DIGIT; c++)
if (OK[p][c]) {
Cnt[c] = Sum[c] = 0;
for (int i = 1, v; i <= n; i++)
if (L[i] >= p) {
v = B[i][p] + c;
Cnt[c] += (v >= DIGIT);
Sum[c] += Val[v % DIGIT];
}
}
for (int i = 0, now = n; i <= n; i++) {
if (F[p - 1][i] != -INF) {
for (int c = 0; c < DIGIT; c++)
if (OK[p][c]) F[p][Cnt[c]] = max(F[p][Cnt[c]], F[p - 1][i] + Sum[c]);
}
if (i != n) {
while (now && L[Id[now]] < p - 1) now--;
if (!now) break;
int v = B[Id[now]][p];
for (int c = 0; c < DIGIT; c++)
if (OK[p][c]) {
Cnt[c] += (v + c == 9);
if (L[Id[now]] > p - 1) Sum[c] -= Val[(v + c) % DIGIT];
Sum[c] = Sum[c] + Val[(v + c + 1) % DIGIT];
}
now--;
}
}
radix_sort(p);
}
int ans = 0;
for (int i = 0; i <= n; i++) ans = max(ans, F[len][i]);
printf("%d\n", ans);
}
} // namespace TYC
int main() {
TYC::work();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
int m[102][102];
cin >> n >> a >> b;
if (n > a * b) {
cout << -1;
return 0;
}
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++) m[i][j] = 0;
int p = 2, np = 1;
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++)
if ((i + j) % 2 == 1 && p <= n) {
m[i][j] = p;
p += 2;
} else if ((i + j) % 2 == 0 && np <= n) {
m[i][j] = np;
np += 2;
} else {
m[i][j] = 0;
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) cout << m[i][j] << " ";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int S = 300003;
int n, m, tp = 0;
long long x[S], y[S], k, b, su = 0, xx, yy;
inline long long Y(int i) { return y[i] + k * (x[i] - 1) + b; }
int main() {
scanf("%d%d", &n, &m);
tp = 1;
x[1] = 1;
y[1] = 0;
k = b = 0;
su = n;
for (int i = 1, o, u, v; i <= m; ++i) {
scanf("%d%d", &o, &u);
while (tp > 1 && Y(tp) >= Y(tp - 1)) --tp;
if (o == 1) {
k = b = 0;
tp = 1;
x[1] = 1;
y[1] = 0;
su += u;
} else if (o == 2) {
xx = su + 1;
yy = -su * k - b;
while (tp > 1 && double(Y(tp) - Y(tp - 1)) / (x[tp] - x[tp - 1]) >=
double(-Y(tp)) / (xx - x[tp]))
--tp;
++tp;
x[tp] = xx;
y[tp] = yy;
su += u;
} else {
scanf("%d", &v);
b += u;
k += v;
}
while (tp > 1 && Y(tp) >= Y(tp - 1)) --tp;
printf("%lld %lld\n", x[tp], y[tp] + k * (x[tp] - 1) + b);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 69;
const int maxm = 20039;
int n, m, k;
int dp[maxn][maxm];
struct SegTree {
struct SegNode {
int l, r;
long long add;
long long max;
} tree[maxm << 2];
void memst() { memset(tree, 0, sizeof(tree)); }
void build(int p, int l, int r, int i) {
tree[p].l = l, tree[p].r = r;
if (l == r) {
tree[p].max = dp[i][l];
return;
}
int mid = (l + r) / 2;
build(p * 2, l, mid, i);
build(p * 2 + 1, mid + 1, r, i);
tree[p].max = max(tree[p * 2].max, tree[p * 2 + 1].max);
}
void spread(int p) {
if (tree[p].add) {
tree[p * 2].max += tree[p].add;
tree[p * 2 + 1].max += tree[p].add;
tree[p * 2].add += tree[p].add;
tree[p * 2 + 1].add += tree[p].add;
tree[p].add = 0;
}
}
void change(int p, int l, int r, long long d) {
if (l <= tree[p].l && r >= tree[p].r) {
tree[p].max += d;
tree[p].add += d;
return;
}
spread(p);
int mid = (tree[p].l + tree[p].r) / 2;
if (l <= mid) change(p * 2, l, r, d);
if (r > mid) change(p * 2 + 1, l, r, d);
tree[p].max = max(tree[p * 2].max, tree[p * 2 + 1].max);
}
long long ask4max(int p, int l, int r) {
if (l <= tree[p].l && r >= tree[p].r) return tree[p].max;
spread(p);
int mid = (tree[p].l + tree[p].r) / 2;
long long val = -0x3f3f3f3f;
if (l <= mid) val = max(val, ask4max(p * 2, l, r));
if (r > mid) val = max(val, ask4max(p * 2 + 1, l, r));
return val;
}
} T;
struct pres {
long long n;
long long m;
long long A[maxn][maxm];
long long S[maxn][maxm];
void getsum() {
for (int i = (1); i < n + 1; i++)
for (int j = (1); j < m + 1; j++)
S[i][j] = S[i - 1][j] + S[i][j - 1] - S[i - 1][j - 1] + A[i][j];
}
long long lefttopasksum(long long x, long long y, long long r1,
long long r2) {
long long tot = S[min(n, x + r1 - 1)][min(m, y + r2 - 1)];
tot -= S[x - 1][min(m, y + r2 - 1)];
tot -= S[min(n, x + r1 - 1)][y - 1];
tot += S[x - 1][y - 1];
return tot;
}
} P;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
P.n = n + 1, P.m = m;
memset(P.A, 0, sizeof(P.A));
for (int i = (1); i < n + 1; i++)
for (int j = (1); j < m + 1; j++) cin >> P.A[i][j];
P.getsum();
for (int i = (1); i < n + 1; i++) {
if (i != 1) {
T.memst();
T.build(1, 1, m, i - 1);
for (int j = (1); j < k + 1; j++)
T.change(1, j, j, -P.lefttopasksum(i, j, 1, k - j + 1));
}
for (int j = (1); j < m - k + 2; j++) {
int val = P.lefttopasksum(i, j, 2, k);
if (i == 1) {
dp[i][j] = val;
continue;
}
if (j != 1) {
T.change(1, max(1, j - k), j - 1, P.A[i][j - 1]);
T.change(1, j, j + k - 1, -P.A[i][j + k - 1]);
}
dp[i][j] = T.ask4max(1, 1, m) + val;
}
}
printf("%d", *max_element(dp[n] + 1, dp[n] + m + 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
cin >> test;
while (test--) {
char str[10000], cpy[10000], st[10000];
cin >> str;
int ln = strlen(str), ck = 0;
for (int i = 0, j = ln - 1; i < ln; i++, j--) {
cpy[j] = str[i];
}
for (int i = 0; i < ln; i++) {
if (str[i] == cpy[i]) {
ck = 1;
} else {
ck = 0;
cout << str << endl;
break;
}
}
if (ck) {
strcpy(st, str);
sort(str, str + ln);
if (!strcmp(str, st))
printf("-1\n");
else
cout << str << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << "a\na\nb\nb\n";
return 0;
}
for (int k = 0; k < 2; ++k) {
for (int i = 0; i < n - 1; i += 2) {
if (i % 4)
cout << char('a' + k) << char('a' + k);
else
cout << char('c' + k) << char('c' + k);
}
if (n % 2 == 1) cout << 'z';
cout << endl;
}
for (int k = 0; k < 2; ++k) {
cout << 'k';
for (int i = 1; i < n - 1; i += 2) {
if (i % 4 == 1)
cout << char('e' + k) << char('e' + k);
else
cout << char('g' + k) << char('g' + k);
}
if (n % 2 == 0) cout << 'x';
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
bitset<N> b;
int p[N];
int cnt[N];
bool was[N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", p + i);
p[i]--;
was[i] = false;
}
for (int i = 1; i <= n; i++) {
cnt[i] = 0;
}
int c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (was[i]) {
continue;
}
int x = i;
int len = 0;
while (!was[x]) {
was[x] = true;
x = p[x];
len++;
}
c1 += len % 2;
c2 += len / 2;
cnt[len]++;
}
b.set(n);
for (int i = 1; i <= n; i++) {
if (cnt[i] == 0) {
continue;
}
int j = 1;
while (cnt[i] > 0) {
j = min(j, cnt[i]);
int u = i * j;
b |= (b >> u);
cnt[i] -= j;
j *= 2;
}
}
int ans_min = k;
if (!b.test(n - k)) {
ans_min++;
}
int ans_max = 0;
ans_max += 2 * min(k, c2);
k -= min(k, c2);
ans_max += min(k, c1);
printf("%d %d\n", ans_min, ans_max);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
template <class T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <class T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
template <class T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
const int maxn = 100005;
const int N = 1000005;
double hh, mm;
int h, c;
int n, d;
int t;
double ans;
int main() {
cin >> hh >> mm;
cin >> h >> d >> c >> n;
if (hh < 20) {
t = (20 - hh) * 60 - mm;
if ((h + t * d) % n)
t = (h + t * d) / n + 1;
else
t = (h + t * d) / n;
ans = double(t * 0.8 * c);
if (h % n)
t = h / n + 1;
else
t = h / n;
ans = min(ans, double(t * c));
} else {
if (h % n)
t = h / n + 1;
else
t = h / n;
ans = double(t * c * 0.8);
}
printf("%.4f", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, q = 4127, x = 0, Equal = 0;
cin >> n;
pair<int, int> p[n];
for (int i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
if (q >= p[i].first) {
x++, q = p[i].first;
}
if (p[i].first == p[i].second) Equal++;
}
if (Equal == n && x == n)
cout << "maybe";
else if (Equal == n && x != n)
cout << "unrated";
else
cout << "rated";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int data = 0, m = 1;
char ch = 0;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') {
m = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
data = (data << 1) + (data << 3) + (ch ^ 48);
ch = getchar();
}
return (m) ? data : -data;
}
int prm[200005], tot;
bool Is[200005];
int nI, mod, Q;
int n, m, Cprm[200005], ID[200005], Prod[200005], cnt[200005][12],
sum[200005 << 2][12], ans[200005 << 2], ans1[200005 << 2], tag[200005 << 2];
inline int Pow(int ts, int js) {
int al = 1;
while (js) {
if (js & 1) al = 1ll * al * ts % mod;
ts = 1ll * ts * ts % mod;
js >>= 1;
}
return al;
}
void Exgcd(int a, int b, int &x, int &y) {
if (!b) {
x = 1;
y = 0;
return;
}
Exgcd(b, a % b, y, x);
y = y - (a / b) * x;
}
inline int Inv(int a) {
int x, y;
Exgcd(a, mod, x, y);
return (x % mod + mod) % mod;
}
inline void Sieve(int N) {
Prod[1] = 1;
for (int i = 2; i <= N; i++) {
if (!Is[i]) prm[++tot] = i;
for (int j = 1; j <= tot && prm[j] * i <= N; j++) {
Is[i * prm[j]] = true;
if (i % prm[j] == 0) break;
}
Prod[i] = 1;
}
int px = mod;
for (int j = 1; prm[j] * prm[j] <= px && j <= tot; j++)
if (px % prm[j] == 0) {
ID[prm[j]] = ++nI;
Cprm[nI] = prm[j];
while (px % prm[j] == 0) px /= prm[j];
}
if (px != 1 && px <= N) ID[px] = ++nI, Cprm[nI] = px;
for (int i = 1; i <= N; i++) {
int x = i;
for (int j = 1; prm[j] * prm[j] <= x && j <= tot; j++)
if (x % prm[j] == 0) {
int c = 0, lv = 1;
while (x % prm[j] == 0) lv *= prm[j], x /= prm[j], ++c;
if (ID[prm[j]])
cnt[i][ID[prm[j]]] = c;
else
Prod[i] = 1ll * Prod[i] * lv % mod;
}
if (x != 1) {
if (!ID[x])
Prod[i] = 1ll * Prod[i] * x % mod;
else
cnt[i][ID[x]]++;
}
}
return;
}
inline void PushUp(int o) { ans[o] = (ans[o << 1] + ans[o << 1 | 1]) % mod; }
inline void Add(int o, int v, int v1, int *P) {
tag[o] = 1ll * tag[o] * v % mod;
ans[o] = 1ll * ans[o] * v % mod;
ans1[o] = 1ll * ans1[o] * v1 % mod;
for (int j = 1; j <= nI; j++) sum[o][j] += P[j];
return;
}
inline void PushDown(int o) {
if (tag[o] == 1) return;
Add(o << 1, tag[o], ans1[o], sum[o]);
Add(o << 1 | 1, tag[o], ans1[o], sum[o]);
tag[o] = 1;
ans1[o] = 1;
for (int j = 1; j <= nI; j++) sum[o][j] = 0;
return;
}
void Build(int o, int l, int r) {
tag[o] = ans1[o] = 1;
for (int j = 1; j <= nI; j++) sum[o][j] = 0;
if (l == r) {
int tmp = gi();
for (int j = 1; j <= nI; j++) sum[o][j] = cnt[tmp][j];
ans[o] = tmp % mod;
ans1[o] = Prod[tmp];
return;
}
int mid = (l + r) >> 1;
Build(o << 1, l, mid);
Build(o << 1 | 1, mid + 1, r);
PushUp(o);
}
void Insert(int o, int l, int r, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
Add(o, v, Prod[v], cnt[v]);
return;
}
int mid = (l + r) >> 1;
PushDown(o);
if (ql <= mid) Insert(o << 1, l, mid, ql, qr, v);
if (qr > mid) Insert(o << 1 | 1, mid + 1, r, ql, qr, v);
PushUp(o);
}
void Delete(int o, int l, int r, int ps, int v) {
if (l == r) {
for (int j = 1; j <= nI; j++) sum[o][j] -= cnt[v][j];
ans1[o] = 1ll * ans1[o] * Inv(Prod[v]) % mod;
ans[o] = ans1[o];
for (int j = 1; j <= nI; j++)
ans[o] = 1ll * ans[o] * Pow(Cprm[j], sum[o][j]) % mod;
return;
}
int mid = (l + r) >> 1;
PushDown(o);
if (ps <= mid)
Delete(o << 1, l, mid, ps, v);
else
Delete(o << 1 | 1, mid + 1, r, ps, v);
PushUp(o);
}
int Query(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return ans[o];
int mid = (l + r) >> 1;
PushDown(o);
int ret = 0;
if (ql <= mid) ret = (ret + Query(o << 1, l, mid, ql, qr)) % mod;
if (qr > mid) ret = (ret + Query(o << 1 | 1, mid + 1, r, ql, qr)) % mod;
return ret;
}
int main() {
n = gi();
mod = gi();
Sieve(100000);
Build(1, 1, n);
int op, l, r, x;
Q = gi();
while (Q--) {
op = gi();
l = gi();
r = gi();
if (op == 1)
x = gi(), Insert(1, 1, n, l, r, x);
else if (op == 2)
Delete(1, 1, n, l, r);
else if (op == 3)
printf("%d\n", Query(1, 1, n, l, r));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 23;
const int MOD = 1e9 + 9;
const int MAXN = 1e5 + 100;
int f[MAXN];
int cntf[MAXN];
int b[MAXN];
int cntb[MAXN];
int pos[MAXN];
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> f[i];
cntf[f[i]] += 1;
pos[f[i]] = i;
}
bool impos = false, amb = false;
for (int i = 1; i <= m; ++i) {
cin >> b[i];
if (cntf[b[i]] == 0) impos = true;
cntb[b[i]] += 1;
if (cntf[b[i]] > 1) amb = true;
}
if (impos) {
cout << "Impossible\n";
return 0;
}
if (amb) {
cout << "Ambiguity\n";
return 0;
}
stringstream ss;
ss << "Possible\n";
for (int i = 1; i <= m; ++i) {
ss << pos[b[i]] << " ";
}
cout << ss.str() << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& x) {
register int c = getchar(), f = 1;
x = 0;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
x *= f;
}
inline bool cmp(long long a, long long b) { return a > b; }
int n, v[100005], t[100005];
long long pre[100005], ans[100005], cnt[100005], mul[100005];
int main(void) {
read(n);
for (int i = 1; i <= n; ++i) read(v[i]);
for (int i = 1; i <= n; ++i) read(t[i]);
for (int i = 1; i <= n; ++i) pre[i] = pre[i - 1] + t[i];
for (int i = 1; i <= n; ++i) {
int r = lower_bound(pre + i, pre + 1 + n, v[i] + pre[i - 1]) - pre;
cnt[r] += v[i] - pre[r - 1] + pre[i - 1];
--mul[r], ++mul[i];
}
for (int i = 1; i <= n; ++i)
mul[i] += mul[i - 1], ans[i] = t[i] * mul[i] + cnt[i];
for (int i = 1; i <= n; ++i) printf("%I64d ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool visited[50][50];
bool v[50], c[50];
vector<int> a[50], b[50];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int l, r;
for (int i = 0; i < m; i++) {
cin >> l >> r;
if (!visited[l][r]) {
a[l].push_back(r);
if (!visited[l][l]) {
a[l].push_back(l);
}
visited[l][r] = true;
visited[l][l] = true;
}
if (!visited[r][l]) {
a[r].push_back(l);
if (!visited[r][r]) {
a[r].push_back(r);
}
visited[r][l] = true;
visited[r][r] = true;
}
for (int j = 0; j < a[l].size(); j++) {
if (!visited[r][a[l][j]]) {
a[r].push_back(a[l][j]);
visited[r][a[l][j]] = true;
}
if (!visited[a[l][j]][r]) {
a[a[l][j]].push_back(r);
visited[a[l][j]][r] = true;
}
}
for (int j = 0; j < a[r].size(); j++) {
if (!visited[l][a[r][j]]) {
a[l].push_back(a[r][j]);
visited[l][a[r][j]] = true;
}
if (!visited[a[r][j]][l]) {
a[a[r][j]].push_back(l);
visited[a[r][j]][l] = true;
}
}
}
int num = n / 3;
for (int i = 1; i <= n; i++) {
if (a[i].size() > 3) {
cout << -1;
return 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < a[i].size(); j++) {
if (!v[a[i][j]]) {
b[i].push_back(a[i][j]);
v[a[i][j]] = true;
}
}
}
int u = 0;
for (int i = 1; i <= n; i++) {
if (b[i].size() > 0) {
u++;
}
}
if (u > num) {
cout << -1;
return 0;
}
u = 0;
for (int i = 1; i <= n; i++) {
int e = 0;
if (b[i].size() > 0) {
u++;
for (int j = 0; j < b[i].size(); j++) {
if (!c[b[i][j]]) {
cout << b[i][j] << " ";
c[b[i][j]] = 1;
e++;
}
}
if (e < 3) {
for (int j = 1; j <= n; j++) {
if (!c[j] && !v[j]) {
cout << j << " ";
e++;
c[j] = 1;
v[i] = 1;
if (e == 3) break;
}
}
}
cout << "\n";
}
}
if (u < num) {
while (u < num) {
int e = 0;
for (int j = 1; j <= n; j++) {
if (!c[j] && !v[j]) {
cout << j << " ";
e++;
c[j] = 1;
v[j] = 1;
if (e == 3) break;
}
}
cout << "\n";
u++;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int maxn = 2e5 + 1;
int n, k;
vector<vector<int>> tree(maxn);
vector<vector<long long>> dp(maxn, vector<long long>(5)),
dp2(maxn, vector<long long>(5)), dp3(maxn, vector<long long>(5)),
dp4(maxn, vector<long long>(5));
void dfs(int x, int p = -1) {
dp2[x][0]++;
for (int y : tree[x]) {
if (y == p) continue;
dfs(y, x);
}
if (p != -1) {
if (k == 1) {
dp2[p][0] += dp2[x][0];
dp[p][0] += dp[x][0] + dp2[x][0];
} else {
for (int i = 1; i <= k - 1; i++) {
dp[p][(i + 1) % k] += dp[x][i];
dp2[p][(i + 1) % k] += dp2[x][i];
}
dp[p][1] += dp[x][0] + dp2[x][0];
dp2[p][1] += dp2[x][0];
}
}
}
void dfs2(int x, int p = -1) {
for (int y : tree[x]) {
if (y == p) continue;
if (k == 1) {
dp3[y][0] = dp3[x][0] + n - 2 * dp2[y][0];
} else {
for (int i = 1; i <= k - 1; i++) {
int j = (i + 1) % k;
dp3[y][j] =
dp3[x][i] - dp[y][i - 1] + dp[y][j] - (i == 1 ? dp2[y][i - 1] : 0);
dp4[y][j] = dp4[x][i] - dp2[y][i - 1] + dp2[y][j];
}
dp3[y][1] =
dp3[x][0] + dp4[x][0] - dp2[y][k - 1] - dp[y][k - 1] + dp[y][1];
dp4[y][1] = dp4[x][0] - dp2[y][k - 1] + dp2[y][1];
}
dfs2(y, x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
tree[x].push_back(y);
tree[y].push_back(x);
}
dfs(1);
for (int i = 0; i < k; i++) {
dp3[1][i] = dp[1][i];
dp4[1][i] = dp2[1][i];
}
dfs2(1);
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; j++) {
ans += dp3[i][j];
}
}
cout << ans / 2 << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[100010];
int n;
bool v[100010];
char a[100010];
int t = 0;
void tle() {
while (1)
;
}
bool ff() {
for (int i = 0; i < t / 2; i++)
if (a[i] < '7') return 1;
for (int i = t / 2; i < t; i++)
if (a[i] > '4') return 0;
return 1;
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = n - 1; i >= 0; i--)
if (s[i] > '7')
v[i] = 1;
else if (s[i] < '7')
v[i] = 0;
else if (v[i + 1])
v[i] = 1;
if (v[0]) {
for (int i = 0; i <= n; i++) a[t++] = '4';
} else {
bool F = 0;
for (int i = 0; i < n; i++)
if (F)
a[t++] = '4';
else if (s[i] < '4') {
a[t++] = '4';
F = 1;
} else if (s[i] == '4') {
if (v[i + 1])
a[t++] = '7', F = 1;
else
a[t++] = '4';
} else if (s[i] < '7') {
a[t++] = '7';
F = 1;
} else if (s[i] == '7') {
if (v[i + 1])
tle();
else
a[t++] = '7';
} else
tle();
}
if (t & 1) {
t++;
for (int i = 0; i < t / 2; i++) a[i] = '4';
for (int i = t / 2; i < t; i++) a[i] = '7';
printf("%s\n", a);
return 0;
}
if (!ff()) {
t++;
for (int i = 0; i < t; i++) a[i] = '4';
}
if (t & 1) {
t++;
for (int i = 0; i < t / 2; i++) a[i] = '4';
for (int i = t / 2; i < t; i++) a[i] = '7';
printf("%s\n", a);
return 0;
}
int z = 0;
for (int i = 0; i < t; i++)
if (a[i] == '4')
z++;
else
z--;
if (z == 0) {
printf("%s\n", a);
return 0;
}
for (int i = t - 1; i >= 0;) {
if (z == 0) break;
if (z > 0) {
if (a[i] == '4') a[i] = '7', z -= 2;
i--;
} else if (z < 0) {
if (a[i] == '7') {
int j = i;
while (a[j] == '7') a[j] = '4', z += 2, j--;
a[j] = '7', z -= 2;
if (z < 0) i = j;
if (z > 0) i = t;
} else
i--;
}
}
printf("%s\n", a);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int h1, h2;
int a, b;
int ans = 0;
int main() {
scanf("%d%d", &h1, &h2);
scanf("%d%d", &a, &b);
h1 += a * 8;
if (h1 >= h2)
printf("0\n");
else if (h1 < h2 && b >= a)
printf("-1\n");
else if (h1 < h2 && b < a) {
int num1 = (h2 - h1) % ((a - b) * 12);
if (num1 == 0)
printf("%d\n", (h2 - h1) / ((a - b) * 12));
else
printf("%d\n", (h2 - h1) / ((a - b) * 12) + 1);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
double A[200000], B[200000];
int i, j, n, m;
double p;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%lf", &p);
B[i] = p * (B[i - 1] + 1);
A[i] = (A[i - 1] + 2 * B[i - 1] + 1) * p + (1 - p) * A[i - 1];
}
printf("%.9lf\n", A[n]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 16) + 5;
const int INF = 0x3f3f3f3f;
int dp[maxn][16][16];
int n, m;
int a[20][10005];
int pre[20][20];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
memset(pre, INF, sizeof pre);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) continue;
for (int k = 0; k < m; ++k) {
pre[i][j] = min(pre[i][j], abs(a[i][k] - a[j][k]));
}
}
}
for (int i = 0; i < n; ++i) dp[1 << i][i][i] = INF;
int need = (1 << n) - 1;
for (int i = 1; i <= need; ++i) {
for (int xx = 0; xx < n; ++xx) {
for (int j = 0; j < n; ++j) {
if ((i & (1 << j)) == 0) continue;
int front = i ^ (1 << j);
for (int k = 0; k < n; ++k) {
if ((front & (1 << k)) == 0) continue;
dp[i][j][xx] = max(dp[i][j][xx], min(dp[front][k][xx], pre[k][j]));
}
}
}
}
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int tmp = dp[need][i][j];
for (int k = 0; k < m - 1; ++k) {
tmp = min(tmp, abs(a[i][k] - a[j][k + 1]));
}
res = max(res, tmp);
}
}
printf("%d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = INT_MAX;
const long long INF = LLONG_MAX;
const int MOD = 1000000007;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
if (k == 0) {
if (n % 2 == 0) {
cout << "YES\n";
} else {
cout << "NO\n";
}
} else {
if (n % 2 == 0 && m % 2 == 0) {
if (k % 2 == 0) {
cout << "YES\n";
} else {
cout << "NO\n";
}
} else if (n % 2 != 0 && m % 2 == 0) {
int u = m / 2;
if (k > n * m) {
cout << "NO\n";
} else {
int x = 0;
for (int i = u; i > 0; --i) {
int h = u - i;
for (int j = 1; j * i <= k; ++j) {
if (h != 0) {
if ((k - (j * i)) % h == 0 && ((k - (j * i)) / h) % 2 != 0 &&
j % 2 != 0 && j <= n && ((k - (j * i)) / h) <= n) {
x = 1;
j = k;
i = -1;
break;
}
} else {
if (j <= n && j * i == k && j % 2 != 0) {
x = 1;
j = k;
i = -1;
break;
}
}
}
}
if (x == 1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
} else if (n % 2 == 0 && m % 2 != 0) {
int u = (m - 1) / 2;
if (k > u * n) {
cout << "NO\n";
} else if (k == u * n) {
cout << "YES\n";
} else {
int x = 0;
for (int i = u; i > 0; --i) {
int h = u - i;
for (int j = 1; i * j <= k; ++j) {
if (h != 0) {
if ((k - (i * j)) % h == 0 && ((k - (i * j)) / h) % 2 == 0 &&
j % 2 == 0 && j <= n && (k - (i * j) / h && h != 0) <= n) {
x = 1;
i = -1;
j = k;
break;
}
} else {
if (i * j == k && j % 2 == 0) {
x = 1;
j = k;
i = -1;
break;
}
}
}
}
if (x == 1) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
} else {
cout << "NO\n";
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long* arr = new long long[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
if (n == 1) {
cout << "+";
return 0;
}
vector<int> v1;
vector<int> v2;
map<int, char> v;
v[n - 1] = '1';
v[n - 2] = '2';
long long s1 = arr[n - 1];
long long s2 = arr[n - 2];
for (long long i = n - 3; i >= 0; i--) {
if (s1 > s2) {
s2 += arr[i];
v[i] = '2';
} else {
s1 += arr[i];
v[i] = '1';
}
}
char op1 = '+';
char op2 = '-';
if (s1 < s2) {
swap(op1, op2);
}
string ans = "";
for (int i = 0; i < n; i++) {
if (v[i] == '1')
ans += op1;
else
ans += op2;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int m = t.length();
int n = s.length();
int pre[m];
int suf[m];
int counter = 0;
for (int i = 0; i < n; i++) {
if (s[i] == t[counter]) {
pre[counter] = i + 1;
counter++;
}
if (counter == m) break;
}
counter = m - 1;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == t[counter]) {
suf[counter] = n - i;
counter--;
}
if (counter < 0) break;
}
int ans = max(n - suf[0], n - pre[m - 1]);
for (int i = 1; i < m; i++) {
ans = max(ans, n - suf[i] - pre[i - 1]);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
if (arr[i] % 2 == 0) arr[i] -= 1;
cout << arr[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M, X, Y;
int p1, p2, p3, p4;
int main() {
p1 = -2001000000;
p2 = -p1;
p3 = p1;
p4 = p2;
scanf("%d%d", &N, &M);
scanf("%d", &N);
for (int(i) = 0; (i) < (N); (i)++) {
scanf("%d%d", &X, &Y);
p1 = max(p1, X + Y);
p2 = min(p2, X + Y);
p3 = max(p3, X - Y);
p4 = min(p4, X - Y);
}
long long res = 1145141919810100081LL;
int pos = -1;
scanf("%d", &M);
for (int(i) = 0; (i) < (M); (i)++) {
scanf("%d%d", &X, &Y);
long long s1 = X + Y, s2 = X - Y;
long long dist = max(max(llabs(s1 - p1), llabs(s1 - p2)),
max(llabs(s2 - p3), llabs(s2 - p4)));
if (dist < res) res = dist, pos = i + 1;
}
cout << res << endl << pos << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int const e = 1e5;
int main() {
long long x, y, m, mv = 0, s, temp = 0;
cin >> x >> y >> m;
if (x <= 0 && y <= 0 && m > 0) {
cout << "-1";
return 0;
}
if ((x < 0 && x < m) && (y < 0 && y < m)) {
cout << "-1";
return 0;
}
if (max(x, y) < m)
if (m > 0)
if (x < 0 && y > 0) {
temp = (x / y) * -1;
x = x % y;
} else if (y < 0 && x > 0) {
temp = (y / x) * -1;
y = y % x;
}
while (max(x, y) < m) {
s = min(x, y);
if (s == x)
x += y;
else
y += x;
mv++;
}
cout << mv + temp;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 3e5 + 5;
long long a[maxn];
int n;
long long MAX(long long x, long long y) { return x > y ? x : y; }
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
}
long long maxnum = 0;
for (int i = 2; i <= n; ++i) {
maxnum = MAX(maxnum, a[i] * a[i - 1]);
}
printf("%lld\n", maxnum);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
if (a == b) {
cout << "-1\n";
} else {
cout << max(a.length(), b.length()) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, before, after, isRated = 0;
cin >> n;
pair<int, int> arr[1000];
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
if (arr[i].first < arr[i].second || arr[i].first > arr[i].second)
isRated = 1;
}
if (isRated != 1) {
for (int i = 0; i < n; i++) {
if (i != n - 1) {
if (arr[i].first >= arr[i + 1].first &&
arr[i].second >= arr[i + 1].second)
isRated = 2;
else {
isRated = 0;
break;
}
}
}
}
if (isRated == 1)
cout << "rated\n";
else if (isRated == 0)
cout << "unrated\n";
else
cout << "maybe\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, ans, top;
char mp[1005][1005];
int num[1005][1005];
int rr[1000005], cc[1000005];
const int dr[] = {-1, 0, 1, 0};
const int dc[] = {0, 1, 0, -1};
void DFS(int r, int c) {
if (mp[r][c] == '*') {
++ans;
return;
}
if (num[r][c] != 0) return;
num[r][c] = 1;
rr[++top] = r;
cc[top] = c;
for (int i = 0; i < 4; ++i) DFS(r + dr[i], c + dc[i]);
num[r][c] = ans;
}
int main() {
int i, j;
memset(mp, 0, sizeof(mp));
while (3 == scanf("%d%d%d", &n, &m, &k)) {
memset(num, 0, sizeof(num));
for (i = 1; i <= n; ++i) scanf("%s", &mp[i][1]);
for (i = 2; i <= n; ++i) {
for (j = 2; j <= m; ++j)
if (num[i][j] == 0 && mp[i][j] == '.') {
ans = 0;
top = -1;
DFS(i, j);
for (; top >= 0; --top) num[rr[top]][cc[top]] = ans;
}
}
while (k--) {
scanf("%d%d", &x, &y);
printf("%d\n", num[x][y]);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e9 + 7;
vector<pair<long long, long long>> adj[101];
map<pair<long long, long long>, long long> mp;
map<long long, long long> ans;
long long start, dest;
void dfs(long long node, long long col) {
mp[{node, col}] = 1;
if (node == dest) ans[col]++;
for (auto child : adj[node]) {
if (mp[{child.first, child.second}] == 0 &&
(child.second == col || col == -1)) {
dfs(child.first, child.second);
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long u, v, c;
cin >> u >> v >> c;
adj[u].push_back({v, c});
adj[v].push_back({u, c});
}
long long q;
cin >> q;
while (q--) {
ans.clear();
mp.clear();
cin >> start >> dest;
dfs(start, -1);
long long temp = 0;
for (auto x : ans) {
if (x.second != 0) temp++;
}
cout << temp << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
string ods = "", evs = "";
for (auto ch : s) (int)(ch - '0')& 1 ? ods += ch : evs += ch;
string res = "";
int oi = 0, ei = 0;
while (oi < ods.length() && ei < evs.length()) {
if (ods[oi] < evs[ei]) {
res += ods[oi];
oi++;
} else {
res += evs[ei];
ei++;
}
}
while (oi < ods.length()) {
res += ods[oi];
oi++;
}
while (ei < evs.length()) {
res += evs[ei];
ei++;
}
cout << res << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, max = -1, index;
cin >> n >> m;
long long arr[m][n];
long long arr1[n];
for (long long i = 0; i < n; i++) {
arr1[i] = 0;
}
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < n; j++) {
cin >> arr[i][j];
if (arr[i][j] > max) {
max = arr[i][j];
index = j;
}
}
arr1[index]++;
max = -1;
}
max = -1;
index = 0;
for (long long i = 0; i < n; i++) {
if (arr1[i] > max) {
max = arr1[i];
index = i + 1;
}
}
cout << index << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx,avx2,sse3,ssse3,sse4.1,sse4.2,tune=native")
#pragma GCC optimize(3)
#pragma GCC optimize("O3")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
const long long N = 5e3 + 10, MOD = 1e15 + 9, p = 29;
long long hh[N][N];
string s;
void cnt(int i) {
long long h = 0;
for (int j = i; j < s.size(); j++) {
h = (h * p + s[j]) % MOD;
hh[i][j - i + 1] = h;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a, b;
cin >> n >> a >> b >> s;
for (int i = 0; i < n; i++) {
cnt(i);
}
for (int i = 1; i <= n; i++) {
unordered_map<long long, int> mp;
for (int j = 0; j < n - i + 1; j++) {
mp[hh[j][i]] = 1e9;
}
for (int j = 0; j < n - i + 1; j++) {
mp[hh[j][i]] = min(j, mp[hh[j][i]]);
hh[j][i] = mp[hh[j][i]];
}
}
vector<int> dp(n, 1e9);
dp[0] = a;
for (int i = 0; i < n; i++) {
if (i != 0) dp[i] = min(dp[i - 1] + a, dp[i]);
if (i != n - 1) {
i++;
for (int j = i; j < n; j++) {
if (hh[i][j - i + 1] + j - i + 1 <= i) {
dp[j] = min(dp[j], dp[i - 1] + b);
}
}
i--;
}
}
cout << dp[n - 1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int binary_exp(long long int a, long long int n) {
long long int i = 1;
while (n > 0) {
if (n % 2 == 1) i = (i * a) % 1000000007;
a = (a * a) % 1000000007;
n /= 2;
}
return i;
}
long long int IsPrime(long long int n) {
if (n == 0 || n == 1) return n;
if (n % 2 == 0) return (long long int)2;
if (n % 3 == 0)
return (long long int)3;
else {
for (long long int i = 5; i * i <= n; i += 6) {
if (n % i == 0) return i;
if (n % (i + 2) == 0) return (i + 2);
}
return n;
}
}
void solve() {
int n, i, j, k, a, b, mex = 1, ans = 0;
cin >> n;
int ind[n + 1];
bool vis[n + 1];
memset(vis, false, sizeof(vis));
for (i = 1; i <= n; i++) {
cin >> k;
ind[k] = i;
}
for (i = 1; i <= n; i++) {
cin >> k;
vis[ind[k]] = true;
while (mex <= n && vis[mex]) mex++;
if (ind[k] > mex) ans++;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
int t = 1;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using std::pair;
using std::set;
using std::vector;
struct node {
int l, r;
mutable long long v;
node(int l, int r = -1, long long v = 0) : l(l), r(r), v(v) {}
bool operator<(const node &a) const { return l < a.l; }
};
set<node> s;
long long qpow(long long a, long long b, long long mo) {
long long ans = 1, base = a % mo;
while (b) {
if (b & 1) ans = ans * base % mo;
base = base * base % mo;
b >>= 1;
}
return ans;
}
set<node>::iterator split(int pos) {
set<node>::iterator it = s.lower_bound(node(pos));
if (it != s.end() && it->l == pos) return it;
it--;
int l = it->l, r = it->r;
long long v = it->v;
s.erase(it);
s.insert(node(l, pos - 1, v));
return s.insert(node(pos, r, v)).first;
}
void add(int l, int r, long long num) {
set<node>::iterator itr = split(r + 1), itl = split(l);
for (; itl != itr; itl++) itl->v += num;
}
void assign_num(int l, int r, long long num) {
set<node>::iterator itr = split(r + 1), itl = split(l);
s.erase(itl, itr);
s.insert(node(l, r, num));
}
long long get_kth(int l, int r, long long k) {
vector<pair<long long, int> > vec;
set<node>::iterator itr = split(r + 1), itl = split(l);
vec.clear();
for (; itl != itr; itl++)
vec.push_back(pair<long long, int>(itl->v, itl->r - itl->l + 1));
std::sort(vec.begin(), vec.end());
for (vector<pair<long long, int> >::iterator it = vec.begin();
it != vec.end(); it++) {
k -= it->second;
if (k <= 0) return it->first;
}
return -1LL;
}
long long get_pow(int l, int r, long long p, long long mo) {
long long ans = 0;
set<node>::iterator itr = split(r + 1), itl = split(l);
for (; itl != itr; itl++)
ans = (ans + (itl->r - itl->l + 1) * qpow(itl->v, p, mo)) % mo;
return ans;
}
int n, m;
long long seed, vmax;
long long rnd() {
long long ret = seed;
seed = (seed * 7 + 13) % 1000000007;
return ret;
}
void get_data() {
for (int i = 1; i <= n; i++) {
long long num = (rnd() % vmax) + 1;
s.insert(node(i, i, num));
}
}
int main() {
scanf("%d%d", &n, &m);
scanf("%lld%lld", &seed, &vmax);
get_data();
while (m--) {
int opt = (rnd() % 4) + 1;
int l = (rnd() % n) + 1;
int r = (rnd() % n) + 1;
if (l > r) std::swap(l, r);
long long x = opt == 3 ? ((rnd() % (r - l + 1)) + 1) : ((rnd() % vmax) + 1);
switch (opt) {
case 1:
add(l, r, x);
break;
case 2:
assign_num(l, r, x);
break;
case 3:
printf("%lld\n", get_kth(l, r, x));
break;
case 4: {
long long y = (rnd() % vmax) + 1;
printf("%lld\n", get_pow(l, r, x, y));
break;
}
}
}
}
| 9 |
#include<iostream>
using namespace std;
int f(int a, int b, int k){
int c=0, q=1;
while(a>0 or b>0){
c += ((a%k)+k-(b%k))%k*q;
q *= k;
a /= k;
b /= k;
}
return c;
}
int g(int a, int b, int k){
int c=0, q=1;
while(a>0 or b>0){
c += (a+b)%k*q;
q *= k;
a /= k;
b /= k;
}
return c;
}
int main(){
int t, r, n, k, y, s, pos;
cin >> t;
while(t--){
cin >> n >> k;
s = y = 0;
pos = -1;
for (int i=0;i<n;i++){
if (pos==1) y = f(s, i, k);
else y = g(s, i, k);
cout << y << endl;
cin >> r;
if (r==1) break;
s = f(y, s, k);
//cerr << "haiya " << s << endl;
pos *= -1;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
int a[101];
int sum = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
int time = 0;
for (int i = 0; i < n; ++i) {
if ((sum - a[i]) % 2 == 0) time++;
}
cout << time << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000100;
const long long P1 = 998244353;
const long long P2 = 1004535809;
const long long E = 3;
long long a[maxn], b[maxn], c[maxn];
int rev[maxn];
int n, k, lim;
long long qpow(long long a, long long b, long long mod) {
long long res = 1;
for (; b > 0; b >>= 1, a = a * a % mod)
if (b & 1) res = res * a % mod;
return res;
}
long long inv(long long a, long long mod) { return qpow(a, mod - 2, mod); }
void Init(int tot) {
lim = 1;
while (lim <= tot) lim <<= 1;
rev[0] = 0;
for (register int i = 1; i < lim; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) * (lim >> 1));
return;
}
void FFT(long long *A, long long G, long long mod) {
for (register int i = 0; i < lim; i++)
if (i < rev[i]) swap(A[i], A[rev[i]]);
for (register int i = 2; i <= lim; i <<= 1) {
long long wn = qpow(G, (mod - 1) / i, mod);
for (register int j = 0; j < lim; j += i) {
long long w = 1;
for (register int k = 0; k < (i >> 1); k++, w = w * wn % mod) {
long long x = A[j + k], y = A[j + k + (i >> 1)] * w % mod;
A[j + k] = (x + y) % mod;
A[j + k + (i >> 1)] = (x - y + mod) % mod;
}
}
}
return;
}
void DFT(long long *A, long long G, long long mod) {
FFT(A, G, mod);
return;
}
void IDFT(long long *A, long long G, long long mod) {
FFT(A, G, mod);
long long ilim = inv(lim, mod);
for (register int i = 0; i < lim; i++) A[i] = A[i] * ilim % mod;
return;
}
void Polypow(long long *A, long long *C, long long k, long long G,
long long mod) {
long long IG = inv(G, mod);
for (int i = 0; i < lim; i++) C[i] = A[i];
DFT(C, G, mod);
for (int i = 0; i < lim; i++) C[i] = qpow(C[i], k, mod);
IDFT(C, IG, mod);
return;
}
signed main() {
scanf("%d%d", &n, &k);
int num, mnu = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &num);
a[num] = 1;
mnu = max(num, mnu);
}
Init(mnu * k);
Polypow(a, b, k, E, P1);
Polypow(a, c, k, E, P2);
for (int i = 0; i < lim; i++) {
if (b[i] == 0 && c[i] == 0) continue;
printf("%d ", i);
}
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct g {
int f, b;
} a[110000];
int q[110000], b[110000], cp[110000], cb[110000];
bool cmp(g &x, g &y) { return x.f < y.f; }
bool cmp2(g &x, g &y) { return x.b < y.b || x.b == y.b && x.f < y.f; }
int main() {
int h, l, r, i, flag = 0, j, h1, n, ans = 10000000;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d%d", &a[i].f, &a[i].b);
a[n].f = a[n].b = -1000;
sort(a, a + n, cmp);
h = 0;
for (i = 0; i < n; i++) cp[i] = cb[i] = 1;
for (i = 0; i < n; i++) {
if (a[i].f == a[i + 1].f) {
q[h] = a[i].f;
cp[h]++;
} else {
q[h] = a[i].f;
h++;
}
}
h1 = 0;
sort(a, a + n, cmp2);
for (i = 0; i < n; i++) {
if (a[i].b == a[i + 1].b) {
b[h1] = a[i].b;
cb[h1]++;
if (a[i].b == a[i].f) cb[h1]--;
} else {
b[h1] = a[i].b;
if (a[i].b == a[i].f) cb[h1]--;
h1++;
}
}
for (i = 0; i < h; i++) {
if (cp[i] >= n / 2 + n % 2) {
flag = 1;
ans = 0;
break;
}
l = 0;
r = h1 - 1;
while (r - l > 1) {
if (b[(l + r) / 2] >= q[i])
r = (l + r) / 2;
else
l = (l + r) / 2;
}
if (b[l] == q[i]) {
if (cb[l] + cp[i] >= n / 2 + n % 2 && n / 2 + n % 2 - cp[i] < ans) {
flag = 1;
ans = n / 2 + n % 2 - cp[i];
}
}
if (b[r] == q[i]) {
if (cb[r] + cp[i] >= n / 2 + n % 2 && n / 2 + n % 2 - cp[i] < ans) {
flag = 1;
ans = n / 2 + n % 2 - cp[i];
}
}
}
if (flag)
printf("%d\n", ans);
else {
for (i = 0; i < h1; i++) {
if (cb[i] >= n / 2 + n % 2) {
ans = n / 2 + n % 2;
flag = 1;
}
}
if (flag)
printf("%d\n", ans);
else
printf("-1\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Iter>
ostream& _out(ostream& s, Iter a, Iter b) {
for (auto it = a; it != b; it++) s << (it == a ? "" : " ") << *it;
return s;
}
template <typename A, typename B>
ostream& operator<<(ostream& s, pair<A, B>& p) {
return s << "(" << p.first << " , " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T>& v) {
return _out(s, v.begin(), v.end());
}
inline long long rit() {
int key = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') key = -1;
c = getchar();
}
long long x = 0;
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * key;
}
int __ = 1;
void init() {}
void read() {}
void solve() {}
vector<int> G[100010];
vector<int> get_val(int l, int r, int cnt) {
vector<int> box;
if (l >= 0 && r >= 0) {
for (int i = 0; i < cnt; i++) box.push_back(l + i + 1);
}
if (l <= 0 && r <= 0) {
for (int i = 0; i < cnt; i++) box.push_back(r - i - 1);
reverse(box.begin(), box.end());
}
if (r > 0 && l < 0) {
int pos = cnt / 2;
if (-pos <= l) pos -= l + pos + 1;
if (cnt - pos - 1 >= r) pos += cnt - pos - 1 - r + 1;
int start = -pos;
for (int i = 0; i < cnt; i++) box.push_back(start + i);
}
return box;
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < k; i++) G[i].push_back(-0x3f3f3f3f);
for (int i = 0; i < n; i++) {
int pos = i % k;
string s;
int x;
cin >> s;
if (s == "?")
x = -0x3f3f3f3f - 1;
else {
stringstream ss(s);
ss >> x;
}
G[pos].push_back(x);
}
for (int i = 0; i < k; i++) G[i].push_back(0x3f3f3f3f);
for (int i = 0; i < k; i++) {
for (int j = 1; j < G[i].size() - 1; j++) {
if (G[i][j] == -0x3f3f3f3f - 1) {
int id = j;
while (id + 1 < G[i].size() - 1 && G[i][id + 1] == -0x3f3f3f3f - 1)
id++;
vector<int> v = get_val(G[i][j - 1], G[i][id + 1], id - j + 1);
for (int k = j; k <= id; k++) G[i][k] = v[k - j];
}
}
}
int ok = 1;
for (int i = 0; i < k; i++)
for (int j = 1; j < G[i].size() - 1; j++) {
if (G[i][j] == -0x3f3f3f3f - 1 || G[i][j] <= G[i][j - 1]) ok = 0;
}
if (ok == 0) {
printf("Incorrect sequence\n");
return 0;
}
for (int i = 0; i < k; i++) {
reverse(G[i].begin(), G[i].end());
G[i].pop_back();
}
int now = 0;
for (int i = 0; i < n; i++) {
printf("%d ", G[now].back());
G[now].pop_back();
now = (now + 1) % k;
}
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
string s;
cin >> s;
long long int n = s.length(), i;
stack<char> a;
for (i = 0; i < n; i++) {
if (a.empty())
a.push(s[i]);
else {
if (a.top() == s[i])
a.pop();
else
a.push(s[i]);
}
}
if (a.size() != 0)
cout << "No";
else
cout << "Yes";
}
| 4 |
#include <bits/stdc++.h>
long long power(long long a, long long b, long long c) {
long long ans = 1;
a = (a % c);
while (b > 0) {
if (b & 1) {
ans = (ans * a) % c;
}
b = b >> 1;
a = (a * a) % c;
}
return ans;
}
using namespace std;
int main() {
vector<string> s;
for (int i = 0; i < 3; i++) {
string a;
cin >> a;
s.push_back(a);
}
vector<int> n;
set<int> ns;
set<char> nc;
vector<char> c;
vector<pair<char, int>> p;
for (int i = 0; i < 3; i++) {
n.push_back(s[i][0] - '0');
c.push_back(s[i][1]);
ns.insert(s[i][0] - '0');
nc.insert(s[i][1]);
p.push_back({s[i][1], s[i][0] - '0'});
}
if (nc.size() == 3)
cout << 2;
else if (nc.size() == 1) {
if (ns.size() == 1)
cout << 0;
else if (ns.size() == 2)
cout << 1;
else {
sort(n.begin(), n.end());
int c = 1;
int g = n[1] - n[0];
int h = n[2] - n[1];
if (g == h && g == 1)
cout << 0;
else if (g == 1 || h == 1)
cout << 1;
else if (g == 2 || h == 2)
cout << 1;
else
cout << 2;
}
} else if (nc.size() == 2) {
if (ns.size() == 1)
cout << 1;
else {
sort(p.begin(), p.end());
if (p[0].first == p[1].first) {
if (abs(p[0].second - p[1].second) < 3)
cout << 1;
else
cout << 2;
} else if (p[1].first == p[2].first) {
if (abs(p[1].second - p[2].second) < 3)
cout << 1;
else
cout << 2;
} else if (p[0].first == p[2].first) {
if (abs(p[0].second - p[2].second) < 3)
cout << 1;
else
cout << 2;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mx = 520;
int ar[mx], br[mx];
int dp[mx][mx], vis[mx][mx];
int n, m;
int solve(int a, int b) {
if (a >= n) return b;
if (vis[a][b]) return dp[a][b];
int ret = 1e9;
for (int i = 0; i < m; i++) ret = min(ret, solve(a + 1, b | (ar[a] & br[i])));
vis[a][b] = 1;
return dp[a][b] = ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> ar[i];
for (int i = 0; i < m; i++) cin >> br[i];
cout << solve(0, 0) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
static void redirect(int argc, const char **argv) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
cin.exceptions(ios::failbit);
}
template <typename Node>
class SegmentTree {
public:
private:
std::size_t N;
std::size_t offset;
mutable std::vector<Node> nodes;
void push_down(std::size_t idx, int L, int R) const {
if (idx < offset)
nodes[idx].push_down(L, R, nodes[2 * idx], nodes[2 * idx + 1]);
}
template <typename Op>
auto query(std::size_t cur, std::size_t L, std::size_t R, std::size_t A,
std::size_t B, const Op &op) const
-> decltype(nodes[0].query(L, R, op)) {
assert(A < R && B > L && A < B);
if (A <= L && B >= R)
return nodes[cur].query(L, R, op);
else {
std::size_t M = (L + R) / 2;
push_down(cur, L, R);
if (B <= M)
return query(2 * cur, L, M, A, B, op);
else if (A >= M)
return query(2 * cur + 1, M, R, A, B, op);
else {
auto left = query(2 * cur, L, M, A, B, op);
auto right = query(2 * cur + 1, M, R, A, B, op);
return op(left, right);
}
}
}
template <typename T, typename Op>
void apply(std::size_t cur, std::size_t L, std::size_t R, std::size_t A,
std::size_t B, const T &value, const Op &op) {
assert(A < R && B > L && A < B);
push_down(cur, L, R);
if (A <= L && B >= R)
nodes[cur].apply(L, R, value, op);
else {
std::size_t M = (L + R) / 2;
if (A < M) apply(2 * cur, L, M, A, B, value, op);
if (B > M) apply(2 * cur + 1, M, R, A, B, value, op);
nodes[cur].update(L, R, nodes[2 * cur], nodes[2 * cur + 1]);
}
}
void prepare(std::size_t N) {
this->N = N;
offset = 1;
while (offset < N) offset *= 2;
nodes.resize(2 * offset);
}
void pull_up() {
for (std::size_t i = 0; i < offset; i++) nodes[i + offset].init(i);
for (std::size_t step = 2; step <= offset; step <<= 1) {
int base = offset / step;
for (int i = base; i < base * 2; i++)
nodes[i].update(i * step, (i + 1) * step, nodes[2 * i],
nodes[2 * i + 1]);
}
}
public:
explicit SegmentTree(std::size_t N) {
prepare(N);
pull_up();
}
std::size_t size() const { return N; }
template <typename Op>
auto query(std::size_t a, std::size_t b, const Op &op = Op()) const
-> decltype(query(1, 0, offset, a, b, op)) {
assert(a < b && b <= N);
return query(1, 0, offset, a, b, op);
}
template <typename T, typename Op>
void apply(std::size_t a, std::size_t b, const T &value,
const Op &op = Op()) {
assert(a <= b && b <= N);
if (a < b) apply(1, 0, offset, a, b, value, op);
}
};
template <typename T>
class op_max {
public:
T operator()(const T &a, const T &b) const { return std::max(a, b); }
};
template <typename T>
struct add_max {
T add{};
T max{};
size_t max_pos{};
void push_down(size_t L, size_t R, add_max &left, add_max &right) {
left.add += add;
left.max += add;
right.add += add;
right.max += add;
add = T();
}
void update(size_t L, size_t R, const add_max &left, const add_max &right) {
assert(add == T());
max = std::max(left.max, right.max);
if (right.max > left.max)
max_pos = right.max_pos;
else
max_pos = left.max_pos;
}
void apply(size_t L, size_t R, const T &value, const std::plus<T> &op) {
add += value;
max += value;
}
pair<T, size_t> query(size_t L, size_t R,
const op_max<pair<T, size_t>> &op) const {
return make_pair(max, max_pos);
}
void init(size_t pos) { max_pos = pos; }
add_max() = default;
explicit add_max(const T &value) : add(value), max(value) {}
};
struct pnt {
long long x, y, c;
bool operator<(const pnt &other) const { return x < other.x; }
};
int main(int argc, const char **argv) {
redirect(argc, argv);
int N;
cin >> N;
vector<pnt> pnts(N);
map<long long, int> ys;
for (int i = 0; i < N; i++) {
cin >> pnts[i].x >> pnts[i].y >> pnts[i].c;
if (pnts[i].x > pnts[i].y) swap(pnts[i].x, pnts[i].y);
ys[pnts[i].x] = -1;
ys[pnts[i].y] = -1;
}
sort(begin(pnts), end(pnts));
int Y = ((long long)(ys).size());
vector<long long> y;
y.reserve(Y);
for (auto &e : ys) {
e.second = ((long long)(y).size());
y.push_back(e.first);
}
SegmentTree<add_max<long long>> tree(Y);
for (int i = 0; i < Y; i++) tree.apply(i, i + 1, -y[i], plus<long long>());
int p = N;
long long ans = 0;
long long ans_x = 1000000001, ans_y = 1000000001;
while (p > 0) {
int q = p;
long long x = pnts[q - 1].x;
while (p > 0 && pnts[p - 1].x == x) p--;
for (int i = p; i < q; i++)
tree.apply(ys[pnts[i].y], Y, pnts[i].c, plus<long long>());
auto score = tree.query(ys[x], Y, op_max<pair<long long, size_t>>());
score.first += x;
if (score.first > ans) {
ans = score.first;
ans_x = x;
ans_y = y[score.second];
}
}
cout << ans << '\n'
<< ans_x << ' ' << ans_x << ' ' << ans_y << ' ' << ans_y << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n;
struct Node {
int v, fr;
} dp[N], g[N];
inline bool operator<(const Node &a, const Node &b) {
return a.v == b.v ? a.fr < b.fr : a.v < b.v;
}
struct Data {
int s, d, sz;
inline int v() { return s + d * (sz - 1); }
} se[2][505];
int tp[2];
int al[N], ar[N], atp;
void ins1(Data *b, int &hd, int s) {
if (!hd) {
b[++hd] = {s, INT_MAX >> 1, 1};
} else {
int del = s - b[hd].v();
if (del == b[hd].d)
++b[hd].sz;
else
b[++hd] = {s, del, 1};
}
}
void ins2(Data *b, int &hd, const Data &p) {
if (b[hd].d == p.d)
b[hd].sz += p.sz;
else
b[++hd] = p;
}
char ss[N], ss1[N / 2], ss2[N / 2];
void trs(Data *a, int tp, Data *b, int &hd, char c) {
hd = 0;
for (int i = 1; i <= tp; i++)
if (ss[a[i].s - 1] == c) {
ins1(b, hd, a[i].s - 1);
if (a[i].sz != 1) ins2(b, hd, {a[i].s + a[i].d - 1, a[i].d, a[i].sz - 1});
}
}
int main() {
ios::sync_with_stdio(false);
cin >> (ss1 + 1) >> (ss2 + 1);
n = strlen(ss1 + 1);
for (int i = 1; i <= n; i++) ss[i << 1] = ss1[i];
for (int i = 1; i <= n; i++) ss[i * 2 - 1] = ss2[i];
n <<= 1;
ss[0] = '#';
for (int i = 1; i <= n; i++) g[i] = {INT_MAX >> 1, 0};
for (int i = 1; i <= n; i++) dp[i] = {INT_MAX >> 1, 0};
for (int i = 1, p = 1, q = 0; i <= n; i++, p ^= 1, q ^= 1) {
trs(se[q], tp[q], se[p], tp[p], ss[i]);
if (ss[i] == ss[i - 1]) ins1(se[p], tp[p], i - 1);
if (i & 1) continue;
if (ss[i] == ss[i - 1]) dp[i] = min(dp[i], {dp[i - 2].v, i - 2});
Data *a = se[p];
for (int j = 1; j <= tp[p]; j++) {
Node ret = {INT_MAX >> 1, 0};
int ed = a[j].v() - 1;
if (a[j].sz == 1)
ret = min(Node{dp[ed].v + 1, ed}, ret);
else {
ret = min(Node{dp[ed].v + 1, ed}, g[a[j].s - a[j].d]);
}
if (a[j].s - a[j].d >= 0) g[a[j].s - a[j].d] = ret;
dp[i] = min(dp[i], ret);
}
}
if (dp[n].v == INT_MAX >> 1) {
cout << -1 << endl;
return 0;
}
for (int p = n; p > 0; p = dp[p].fr)
if (dp[p].fr < p - 2) {
al[++atp] = dp[p].fr + 1;
ar[atp] = p;
}
cout << atp << endl;
for (int i = 1; i <= atp; i++)
cout << (al[i] + 1) / 2 << ' ' << (ar[i] + 1) / 2 << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, x2, y1, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
int ab = (((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
int bc = (((x3 - x2) * (x3 - x2)) + ((y3 - y2) * (y3 - y2)));
int ac = (((x3 - x1) * (x3 - x1)) + ((y3 - y1) * (y3 - y1)));
if ((ab) == ((bc) + (ac)) || (bc) == ((ab) + (ac)) || (ac) == ((ab) + (bc))) {
cout << "RIGHT";
return 0;
} else {
int x4;
int y4;
int d[3] = {-1, 0, 1}, dy[3] = {-1, 0, 1};
for (int i = 0; i < 3; i++) {
x4 = x1 + d[i];
for (int j = 0; j < 3; j++) {
int w = 0;
if (d[i] == 0) {
w = dy[j];
}
y4 = y1 + w;
ab = (((x2 - x4) * (x2 - x4)) + ((y2 - y4) * (y2 - y4)));
bc = (((x3 - x2) * (x3 - x2)) + ((y3 - y2) * (y3 - y2)));
ac = (((x3 - x4) * (x3 - x4)) + ((y3 - y4) * (y3 - y4)));
if (((ab) == ((bc) + (ac)) || (bc) == ((ab) + (ac)) ||
(ac) == ((ab) + (bc))) &&
(ab != 0 && ac != 0 && bc != 0)) {
cout << "ALMOST";
return 0;
}
}
}
for (int i = 0; i < 3; i++) {
x4 = x2 + d[i];
for (int j = 0; j < 3; j++) {
int w = 0;
if (d[i] == 0) {
w = dy[j];
}
y4 = y2 + w;
ab = (((x4 - x1) * (x4 - x1)) + ((y4 - y1) * (y4 - y1)));
bc = (((x3 - x4) * (x3 - x4)) + ((y3 - y4) * (y3 - y4)));
ac = (((x3 - x1) * (x3 - x1)) + ((y3 - y1) * (y3 - y1)));
if (((ab) == ((bc) + (ac)) || (bc) == ((ab) + (ac)) ||
(ac) == ((ab) + (bc))) &&
(ab != 0 && ac != 0 && bc != 0)) {
cout << "ALMOST";
return 0;
}
}
}
for (int i = 0; i < 3; i++) {
x4 = x3 + d[i];
for (int j = 0; j < 3; j++) {
int w = 0;
if (d[i] == 0) {
w = dy[j];
}
y4 = y3 + w;
ab = (((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)));
bc = (((x4 - x2) * (x4 - x2)) + ((y4 - y2) * (y4 - y2)));
ac = (((x4 - x1) * (x4 - x1)) + ((y4 - y1) * (y4 - y1)));
if (((ab) == ((bc) + (ac)) || (bc) == ((ab) + (ac)) ||
(ac) == ((ab) + (bc))) &&
(ab != 0 && ac != 0 && bc != 0)) {
cout << "ALMOSt";
return 0;
}
}
}
cout << "NEITHER";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long pw(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1, (a *= a) %= n)
if (b & 1) (res *= a) %= n;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n == 4) {
cout << "YES\n";
cout << 1 << ' ' << 3 << ' ' << 2 << ' ' << 4 << '\n';
return 0;
}
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return cout << "NO", 0;
cout << "YES\n";
cout << 1 << ' ';
for (long long i = 2; i < n; i++) cout << (i * pw(i - 1, n - 2)) % n << ' ';
if (n > 1) cout << n << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> logr;
vector<vector<vector<vector<int>>>> sparse;
int x4, y4, x2, y2;
int check(int m) {
int x3 = x4 + m - 1;
int y3 = y4 + m - 1;
if (x3 > x2 || y3 > y2) return false;
int i = logr[x2 - x3];
int j = logr[y2 - y3];
int res = max(max(sparse[i][j][x3][y3], sparse[i][j][x2 - (1 << i) + 1][y3]),
max(sparse[i][j][x3][y2 - (1 << j) + 1],
sparse[i][j][x2 - (1 << i) + 1][y2 - (1 << j) + 1]));
return res >= m;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
logr.resize(max(n, m) + 1, 0);
for (int i = 2; i < int(logr.size()); i++) {
logr[i] = logr[i / 2] + 1;
}
vector<vector<int>> b(n + 1, vector<int>(m + 1));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> b[i][j];
}
}
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (b[i][j] == 0) continue;
dp[i][j] = min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
}
}
sparse.resize(logr[n] + 1,
vector<vector<vector<int>>>(
logr[m] + 1, vector<vector<int>>(n, vector<int>(m, -1e9))));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sparse[0][0][i][j] = dp[i + 1][j + 1];
}
}
for (int i = 0; i <= logr[n]; i++) {
for (int j = 0; j <= logr[m]; j++) {
if (i == 0 && j == 0) continue;
for (int x = 0; x <= n - (1 << i); x++) {
for (int y = 0; y <= m - (1 << j); y++) {
int e = max(i - 1, 0);
int g = max(j - 1, 0);
sparse[i][j][x][y] =
max(max(sparse[e][g][x][y],
sparse[e][g][x + (i == 0 ? 0 : (1 << e))][y]),
max(sparse[e][g][x][y + (j == 0 ? 0 : (1 << g))],
sparse[e][g][x + (i == 0 ? 0 : (1 << e))]
[y + (j == 0 ? 0 : (1 << g))]));
}
}
}
}
int t;
cin >> t;
while (t--) {
cin >> x4 >> y4 >> x2 >> y2;
x4--;
y4--;
x2--;
y2--;
int L = 0;
int R = min(x2 - x4, y2 - y4) + 2;
while (R - L > 1) {
int m = (R + L) / 2;
if (check(m))
L = m;
else
R = m;
}
cout << L << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, x[N], y[N], c[N];
bool vis[N];
vector<int> e[N];
void dfs(int u, int col) {
c[u] = col;
vis[u] = 1;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (!c[v]) dfs(v, 3 - col);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x[i], &y[i]);
e[x[i]].push_back(y[i]);
e[y[i]].push_back(x[i]);
}
for (int i = 1; i <= n; i++) {
e[i * 2 - 1].push_back(i * 2);
e[i * 2].push_back(i * 2 - 1);
}
for (int i = 1; i <= n * 2; i++)
if (!vis[i]) dfs(i, 1);
for (int i = 1; i <= n; i++) printf("%d %d\n", c[x[i]], c[y[i]]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int maxn = 5e5 + 5;
const int N = 1e5 + 5, M = N * 2;
bool l2et, sa7;
int n, t, x, a[maxn], fen;
int mx, nxt[maxn], last;
vector<int> idx[maxn];
int tree[1 << 20];
void build(int i, int l, int r) {
if (l == r) {
tree[i] = a[l + 1];
return;
}
int mid = (l + r) / 2;
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
tree[i] = max(tree[i * 2], tree[i * 2 + 1]);
}
int GetMax(int i, int l, int r, int a, int b) {
if (a > r || b < l) return 0;
if (a <= l && r <= b) return tree[i];
int mid = (l + r) / 2;
return max(GetMax(i * 2, l, mid, a, b), GetMax(i * 2 + 1, mid + 1, r, a, b));
}
int vis[maxn], vid;
int main() {
scanf("%d", &t);
while (t--) {
++vid;
sa7 = true;
scanf("%d", &n);
for (int i = n + 1; i; --i) idx[i].clear();
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
a[i] = -1;
nxt[i] = x;
if (~x) idx[x].push_back(i), vis[i] = vid;
}
for (int i = 1; i <= n; ++i)
if (~nxt[i] && vis[nxt[i]] != vid && !(~nxt[nxt[i]]))
idx[nxt[i] + 1].push_back(nxt[i]), vis[nxt[i]] = vid;
fen = n;
for (int i = n + 1; i; --i) {
sort(idx[i].begin(), idx[i].end());
for (auto j : idx[i]) a[j] = fen--;
}
for (int i = n; i; --i)
if (!(~a[i])) a[i] = fen--;
build(1, 0, n - 1);
for (int i = 1; i <= n && sa7; ++i)
if (i <= nxt[i] - 2 && GetMax(1, 0, n - 1, i, nxt[i] - 2) > a[i])
sa7 = false;
if (!sa7) {
puts("-1");
continue;
}
for (int i = 1; i <= n; ++i) printf("%d%c", a[i], " \n"[i == n]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
const int N = 1e6 + 5, LG = 22;
int n, m, A[N], M[N], P[N << 1], FEN[1 << LG];
void Add(int p, int x) {
for (p++; p < (1 << LG); p += p & -p) FEN[p] += x;
}
int Get(int x) {
int idx = 0, sum = 0;
for (int i = LG - 1; i >= 0; i--)
if (FEN[idx ^ (1 << i)] + sum < x) idx ^= (1 << i), sum += FEN[idx];
return idx;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
mt19937 Rnd(time(0));
cin >> n >> m;
for (int i = 1; i <= n; i++) Add(m + i - 1, 1), P[m + i - 1] = i;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
int k = Get(y);
if (M[x] && M[x] != P[k]) return cout << -1 << '\n', 0;
M[x] = P[m - i] = P[k];
Add(k, -1), Add(m - i, +1);
}
vector<int> V;
for (int i = 1; i <= n; i++) {
if (!M[i])
V.push_back(i);
else if (A[M[i]])
return cout << -1 << '\n', 0;
else
A[M[i]] = i;
}
reverse(V.begin(), V.end());
for (int i = 1; i <= n; i++) {
if (A[i])
cout << A[i] << ' ';
else
cout << V.back() << ' ', V.pop_back();
}
cout << '\n';
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.