solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
struct Point {
long long x, y;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
bool operator<(const Point& o) const {
return x < o.x || (x == o.x && y < o.y);
}
void readin() { scanf("%lld%lld", &x, &y); }
} p[100055];
long long preB[100055], preS[100055], sufB[100055], sufS[100055];
bool jg(int i, int j, long long D) {
if (i == 1 && j == n + 1) return 1;
long long a = (1LL << 60), b = -(1LL << 60);
if (i - 1 >= 1) {
a = min(a, preS[i - 1]);
b = max(b, preB[i - 1]);
}
if (j <= n) {
a = min(a, sufS[j]);
b = max(b, sufB[j]);
}
if ((b - a) * (b - a) <= D) {
long long t1 = max(abs(a), abs(b));
long long t2 = max(abs(p[i].x), abs(p[j - 1].x));
if (t1 * t1 + t2 * t2 <= D) return 1;
}
return 0;
}
bool ck(long long D) {
if ((preB[n] - preS[n]) * (preB[n] - preS[n]) <= D) return 1;
for (int i = 1, j = 1; i <= n; i++) {
if (p[i].x > 0) break;
for (; j <= n && abs(p[j].x) <= abs(p[i].x); j++) {
long long dis = p[j].x - p[i].x;
if (dis * dis > D) break;
}
while (j > i && abs(p[j - 1].x) > abs(p[i].x)) j--;
if (jg(i, j, D)) return 1;
}
for (int j = n, i = n; j; j--) {
if (p[j].x < 0) break;
for (; i > 0 && abs(p[i].x) <= abs(p[j].x); i--) {
long long dis = p[j].x - p[i].x;
if (dis * dis > D) break;
}
while (j > i && abs(p[i + 1].x) > abs(p[j].x)) i++;
if (jg(i + 1, j + 1, D)) return 1;
}
return 0;
}
void fmain() {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) p[i].readin();
sort(p + 1, p + n + 1);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
if (i == 1)
preB[i] = preS[i] = p[i].y;
else {
preB[i] = max(p[i].y, preB[i - 1]);
preS[i] = min(p[i].y, preS[i - 1]);
}
}
for (int i = n; i; i--) {
if (i == n)
sufB[i] = sufS[i] = p[i].y;
else {
sufB[i] = max(p[i].y, sufB[i + 1]);
sufS[i] = min(p[i].y, sufS[i + 1]);
}
}
long long l = 0, r = 1e17;
while (l + 1 < r) {
long long mid = (l + r) / 2;
if (ck(mid))
r = mid;
else
l = mid + 1;
}
printf("%lld\n", ck(l) ? l : r);
}
int main() {
fmain();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 505;
bool dp[MAX][MAX][MAX];
int main() {
int n, K;
cin >> n >> K;
dp[0][0][0] = true;
for (int i = 1; i <= n; i++) {
int t;
cin >> t;
for (int j = 0; j <= K; j++) {
for (int k = 0; k <= j; k++) {
if (!dp[i - 1][j][k]) continue;
dp[i][j][k] = true;
if (j + t <= K) {
dp[i][j + t][k] = dp[i][j + t][k + t] = true;
}
}
}
}
vector<int> ans;
for (int i = 0; i <= K; i++)
if (dp[n][K][i]) ans.push_back(i);
printf("%d\n", ans.size());
for (auto x : ans) printf("%d ", x);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = int(2e5) + 10;
int n;
vector<int> E[MAX_N];
void addEdge(int u, int v) { E[u].push_back(v), E[v].push_back(u); }
int col[MAX_N];
void dfs(int u, int c) {
if (col[u] != -1) return;
col[u] = c;
for (vector<int>::iterator e = E[u].begin(); e != E[u].end(); ++e) {
dfs(*e, 1 - c);
}
}
int main() {
cin >> n;
vector<pair<int, int> > events;
for (int i = 0; i < n; ++i) {
int l, r;
scanf("%d%d", &l, &r);
l *= 2, r = r * 2 + 1;
addEdge(i * 2, i * 2 + 1);
events.push_back(make_pair(l, 2 * i));
events.push_back(make_pair(r, 2 * i + 1));
}
sort(events.begin(), events.end());
for (int i = 0; i < n; ++i) {
addEdge(events[i * 2].second, events[i * 2 + 1].second);
}
memset(col, -1, sizeof col);
for (int i = 0; i < n * 2; ++i) {
if (col[i] == -1) dfs(i, 0);
}
for (int i = 0; i < n; ++i) {
printf("%d ", col[i * 2]);
}
puts("");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
cout << 2 * min(n + k, min(m + k, (n + m + k) / 2)) << endl;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using db = double;
using ld = long double;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<vector<T>>;
constexpr ll mod = 1000000007;
constexpr ll INF = 1000000099;
constexpr ll LINF = (ll)(1e18 + 99);
const ld PI = acos((ld)-1);
const vector<ll> dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};
template <typename T, typename U>
inline bool chmin(T& t, const U& u) {
if (t > u) {
t = u;
return 1;
}
return 0;
}
template <typename T, typename U>
inline bool chmax(T& t, const U& u) {
if (t < u) {
t = u;
return 1;
}
return 0;
}
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
inline void yes() { cout << "Yes" << '\n'; }
inline void no() { cout << "No" << '\n'; }
template <typename T, typename Y>
inline T mpow(T a, Y n) {
T res = 1;
for (; n; n >>= 1) {
if (n & 1) res = res * a;
a = a * a;
}
return res;
}
template <typename T>
V<T> prefix_sum(const V<T>& v) {
int n = v.size();
V<T> ret(n + 1);
for (ll i = 0; i < (ll)(n); ++i) ret[i + 1] = ret[i] + v[i];
return ret;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& vec) {
for (auto&& x : vec) is >> x;
return is;
}
template <typename T, typename Y>
ostream& operator<<(ostream& os, const pair<T, Y>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const V<T>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
template <typename... Args>
void debug(Args&... args) {
for (auto const& x : {args...}) {
cerr << x << ' ';
}
cerr << '\n';
}
template <typename T>
struct SCC {
int n, now = 0;
const vector<vector<T>>& e;
vector<bool> used;
vector<int> ind, low, ord, st;
vector<vector<int>> grps, G;
void dfs(int v) {
low[v] = now;
ord[v] = now;
now++;
st.push_back(v);
used[v] = true;
for (auto i : e[v]) {
if (ord[i] == -1) {
dfs(i);
low[v] = min(low[v], low[i]);
} else if (used[i]) {
low[v] = min(low[v], ord[i]);
}
}
if (low[v] == ord[v]) {
vector<int> gr;
while (1) {
int u = st.back();
st.pop_back();
gr.push_back(u);
if (u == v) break;
}
for (int i : gr) used[i] = false;
grps.push_back(gr);
}
}
SCC(const vector<vector<T>>& _e)
: n(_e.size()), e(_e), used(n, false), low(n), ord(n, -1) {
ind = vector<int>(n, 0);
for (int i = 0; i < n; i++) {
if (ord[i] == -1) dfs(i);
}
reverse(grps.begin(), grps.end());
for (int i = 0; i < (int)grps.size(); i++) {
for (auto&& x : grps[i]) {
ind[x] = i;
}
}
G.resize(grps.size());
for (int i = 0; i < n; i++) {
for (int j = 0; j < (int)e[i].size(); j++) {
if (ind[i] != ind[e[i][j]]) {
G[ind[i]].push_back(ind[e[i][j]]);
}
}
}
}
vector<vector<int>>& get_scc() { return G; }
};
struct TwoSat {
vector<vector<int>> e;
vector<bool> res;
void add_edge(int a, bool aflag, int b, bool bflag) {
e[2 * a + !aflag].push_back(2 * b + bflag);
e[2 * b + !bflag].push_back(2 * a + aflag);
}
bool judge() {
SCC<int> scc(e);
for (int i = 0; i < (int)res.size(); ++i) {
if (scc.ind[2 * i] == scc.ind[2 * i + 1]) {
return false;
}
res[i] = (scc.ind[2 * i] < scc.ind[2 * i + 1]);
}
return true;
}
TwoSat(int n) {
e = vector<vector<int>>(2 * n);
res = vector<bool>(n);
}
};
signed main() {
cin.tie(0);
cerr.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n, a, b;
cin >> n >> a >> b;
V<int> v(n);
cin >> v;
unordered_set<int> se;
for (ll i = 0; i < (ll)(n); ++i) {
se.insert(v[i]);
}
map<int, int> id;
for (ll i = 0; i < (ll)(n); ++i) id[v[i]] = i;
TwoSat tst(n);
for (ll i = 0; i < (ll)(n); ++i) {
if (se.count(a - v[i])) {
if (se.count(b - v[i]))
tst.add_edge(id[a - v[i]], true, id[b - v[i]], false);
else
tst.add_edge(id[a - v[i]], true, id[a - v[i]], true);
} else if (se.count(b - v[i])) {
tst.add_edge(id[b - v[i]], false, id[b - v[i]], false);
} else {
cout << "NO" << '\n';
return 0;
}
}
if (!tst.judge()) {
cout << "NO" << '\n';
return 0;
}
cout << "YES" << '\n';
for (ll i = 0; i < (ll)(n); ++i) {
if (tst.res[id[v[i]]]) {
cout << 0 << " ";
} else {
cout << 1 << " ";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> A[200005];
pair<long long, long long> B[200005];
long long G[200005];
long long m, k;
long long n, s;
int dp[200005];
int f(int pos) {
if (pos == m) return -2;
if (dp[pos] != -1) {
return dp[pos];
}
int i = f(pos + 1) + 1;
if (i == -1) i++;
while (i < k) {
if (A[pos].first + B[i].second <= s)
i++;
else {
i--;
break;
}
}
if (i == k) i = k - 1;
if (i == -1) i = -2;
dp[pos] = i;
return i;
}
int main() {
long long x;
cin >> n >> m >> k >> x >> s;
memset(dp, -1, sizeof dp);
for (int i = 0; i < m; i++) {
cin >> G[i];
}
long long y;
int o = 0;
for (int i = 0; i < m; i++) {
cin >> y;
if (y <= s)
A[i] = pair<long long, long long>(y, G[o]);
else {
m--;
i--;
}
o++;
}
for (int i = 0; i < k; i++) {
cin >> G[i];
}
o = 0;
for (int i = 0; i < k; i++) {
cin >> y;
if (y <= s && ((o > 0 && G[o - 1] < G[o]) || o == 0))
B[i] = pair<long long, long long>(G[o], y);
else {
k--;
i--;
}
o++;
}
sort(A, A + m);
sort(B, B + k);
priority_queue<pair<int, int> > C;
for (int i = 0; i < m; i++) {
C.push(pair<int, int>(f(i), i));
}
long long mint = n * x;
long long minD;
pair<int, int> h, g;
if (!C.empty()) {
h = C.top();
C.pop();
minD = A[h.second].second;
while (!C.empty()) {
g = C.top();
C.pop();
if (h.first == g.first) {
minD = min(minD, min(A[h.second].second, A[g.second].second));
} else {
mint = min(mint, (n - B[h.first].first) * minD);
minD = A[g.second].second;
}
h = pair<int, int>(g.first, g.second);
}
if (h.first != -2)
mint = min(mint, (n - B[h.first].first) * minD);
else
mint = min(mint, n * minD);
}
int j = -1;
for (int i = k - 1; i >= 0; i--) {
if (B[i].second <= s) {
j = i;
break;
}
}
if (j != -1) {
mint = min(mint, (n - B[j].first) * x);
}
cout << mint << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
string s;
cin >> a >> s;
if (a > 2) {
for (int i = a - 2; i >= 0; i -= 2) {
cout << s[i];
}
if (a % 2 == 0)
for (int i = 1; i < a; i += 2) {
cout << s[i];
}
else
for (int i = 0; i < a; i += 2) {
cout << s[i];
}
} else
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (abs(c - d) > 1) {
cout << -1 << '\n';
return 0;
}
string ans;
long long mn = min(c, d);
for (long long i = 0; i < mn; i++) {
ans += "47";
a--;
b--;
}
if (a) {
ans += "4";
a--;
if (c > d) {
ans += "7";
b--;
}
if (d > c) {
ans = "7" + ans;
b--;
}
} else {
ans = "7" + ans;
b--;
if (c > d) {
ans = "4" + ans;
a--;
}
if (d > c) {
ans += "4";
a--;
}
}
if (a < 0 or b < 0) {
cout << -1 << '\n';
return 0;
}
long long first = -1;
for (long long i = 0; i < ans.size(); i++) {
if (ans[i] == '4' and first == -1) first = i;
}
long long sz = ans.size();
ans = ans.substr(0, first) + string(a, '4') + ans.substr(first, sz - first);
sz = ans.size();
long long last = sz;
for (long long i = sz - 1; i >= 0; i--) {
if (ans[i] == '7' and last == sz) last = i;
}
ans = ans.substr(0, last) + string(b, '7') + ans.substr(last, sz - last);
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << n << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1000005;
int q;
int n;
int C(long long x) { return x <= (n - x) * (n - x - 1) / 2; }
int main() {
scanf("%d", &q);
for (int cas = (0); cas < (q); cas++) {
scanf("%d", &n);
long long l = 0, r = n;
while (r - l > 1) {
long long m = l + r >> 1;
if (C(m))
l = m;
else
r = m;
}
long long ans = (min(l * 2LL, l + 1LL * ((n - l) * (n - l - 1)) / 2));
if (l + 1 < n)
ans = max(ans, min(2LL * (l + 1),
l + 1 + 1LL * ((n - l - 1) * (n - l - 2)) / 2));
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int maxn = 1e6 + 7;
int a[maxn];
vector<int> v;
map<int, int> dp[2003];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
a[i] -= n;
v.push_back(a[i]);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
dp[0][0] = 1;
map<int, int>::iterator it;
for (int i = 1; i <= 1002; i++) {
for (it = dp[i - 1].begin(); it != dp[i - 1].end(); it++) {
for (int j = 0; j < v.size(); j++) {
if (abs(it->first + v[j]) > 1000) continue;
dp[i][it->first + v[j]] = 1;
}
}
if (dp[i].count(0)) {
printf("%d\n", i);
return 0;
}
}
printf("-1\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = int(2e5);
const int MOD = int(360);
const int oo = INT_MAX;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k;
while (cin >> n >> k) {
long long a, b, c;
a = n / 2LL / (k + 1);
b = a * k;
c = n - b - a;
cout << a << ' ' << b << ' ' << c << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> adj[N];
int sum1[N], now1, wow, cac1, level[N];
bool used[N];
void dfs(int x, int p) {
if (level[x] == now1) {
sum1[x]++;
}
for (int i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != p) {
level[adj[x][i]] = level[x] + 1;
dfs(adj[x][i], x);
sum1[x] += sum1[adj[x][i]];
}
}
}
void dfs1(int x, int p) {
sum1[x] = 0;
if (level[x] == now1) {
sum1[x]++;
}
for (int i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != p && !used[adj[x][i]]) {
dfs1(adj[x][i], x);
sum1[x] += sum1[adj[x][i]];
}
}
}
int findcen(int x, int p, int sz) {
for (int i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != p && sum1[adj[x][i]] > sz / 2 && !used[adj[x][i]]) {
return findcen(adj[x][i], x, sz);
}
}
return x;
}
void findans(int x, int p, int sz) {
if (sz == 1) {
cac1 = x;
return;
}
dfs1(x, x);
int mid = findcen(x, x, sz);
used[mid] = true;
cout << "d " << mid << endl;
fflush(stdout);
cin >> wow;
if (wow + level[mid] == now1) {
if (wow == 0) {
cout << "! " << mid << endl;
fflush(stdout);
exit(0);
}
cout << "s " << mid << endl;
fflush(stdout);
cin >> wow;
findans(wow, wow, sum1[wow]);
} else {
findans(x, x, sz - sum1[mid]);
}
}
int dfs2(int x, int p) {
if (level[x] == now1) {
return x;
}
int i, j;
for (i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != p && !used[adj[x][i]]) {
j = dfs2(adj[x][i], x);
if (j != -1) {
return j;
}
}
}
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, i, j, k;
cin >> n;
for (i = 1; i < n; i++) {
cin >> j >> k;
adj[j].push_back(k);
adj[k].push_back(j);
}
cout << "d 1" << endl;
fflush(stdout);
cin >> now1;
dfs(1, 1);
findans(1, 1, sum1[1]);
i = dfs2(cac1, cac1);
cout << "! " << i << endl;
fflush(stdout);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p, i, sc, L, R;
char s[555123];
int st[555123];
int g[555123];
int pr[555123];
char t[555123];
int ne[555123];
int fir;
char c;
int main() {
scanf("%d%d%d", &n, &m, &p);
scanf("%s", s + 1);
scanf("%s", t + 1);
for (int i = 1; i <= n; i++) {
pr[i] = i - 1;
ne[i] = i + 1;
}
pr[1] = ne[n] = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '(')
st[++sc] = i;
else {
g[st[sc]] = i;
g[i] = st[sc];
sc--;
}
}
fir = 1;
for (int i = 1; i <= m; i++) {
c = t[i];
if (c == 'L') {
p = pr[p];
} else if (c == 'R') {
p = ne[p];
} else if (c == 'D') {
if (g[p] > p) {
int target = g[p];
L = pr[p];
while (true) {
if (p == target) break;
if (fir == p) fir = ne[p];
p = ne[p];
}
if (fir == p) fir = ne[p];
R = ne[p];
ne[L] = R;
pr[R] = L;
if (R != 0)
p = R;
else
p = L;
} else {
int target = p;
p = g[p];
L = pr[p];
while (true) {
if (p == target) break;
if (fir == p) fir = ne[p];
p = ne[p];
}
if (fir == p) fir = ne[p];
R = ne[p];
ne[L] = R;
pr[R] = L;
if (R != 0)
p = R;
else
p = L;
}
}
}
while (fir != 0) {
putchar(s[fir]);
fir = ne[fir];
}
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[] = {2, 3, 5, 7, 11, 13, 17, 19, 21, 23,
29, 31, 37, 41, 43, 47, 51, 59, 61, 67};
int isPrime(int i) {
int t = a[i++];
string str;
if (t * t < 101) {
cout << t * t << endl;
fflush(stdout);
cin >> str;
if (str == "yes") return 0;
}
while (i < 18) {
cout << a[i] << endl;
fflush(stdout);
cin >> str;
if (str == "yes") return 0;
++i;
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
string str;
int i = 0;
cout << a[i] << endl;
fflush(stdout);
while (i < 18) {
cin >> str;
if (str == "yes") {
if (isPrime(i)) break;
cout << "composite\n";
fflush(stdout);
return 0;
} else {
i++;
if (i == 18) break;
cout << a[i] << endl;
fflush(stdout);
}
}
cout << "prime\n";
fflush(stdout);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
int m, n, key = 0;
int maxm = 0;
cin >> m >> n;
while (m--) {
cin >> c;
if (c == '.') {
key = 1;
} else {
key++;
}
maxm = max(maxm, key);
}
if (maxm <= n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans;
bool flag = false;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '.') {
if (s[i - 1] == '9') {
cout << "GOTO Vasilisa." << endl;
return 0;
} else if (s[i + 1] >= '5') {
flag = true;
}
ans = i;
}
}
if (flag)
for (int i = 0; i < ans; i++) {
if (i != ans - 1)
cout << s[i];
else
cout << s[i] - '0' + 1;
}
else
for (int i = 0; i < ans; i++) cout << s[i];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long c = 1, ans = 0;
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = n - 1; i >= 1; --i) {
if (a[i - 1] > a[i]) {
cout << i;
return 0;
}
}
cout << 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, mx, baga, f[100005], B[100005], MX[100005], MN[100005], V[100005],
M[100005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &f[i]);
}
for (int i = 1; i <= 100000; i++) M[i] = 1000000;
for (int i = 1; i <= n; i++) {
int E = 0, T = f[i];
while (E + 1 < T) {
int d = E + (T - E) / 2;
if (M[d] >= f[i])
T = d;
else
E = d;
}
B[i] = E + 1;
M[E + 1] = min(f[i], M[E + 1]);
mx = max(mx, E + 1);
}
MX[mx + 1] = 100000000;
MN[n + 1] = 100000000;
for (int i = n; i >= 1; i--) {
V[i] = 1;
MN[i] = MN[i + 1];
if (MX[B[i] + 1] > f[i]) {
MN[i] = min(MN[i], f[i]);
MX[B[i]] = max(MX[B[i]], f[i]);
V[i] = 2;
}
}
baga = 0;
for (int i = 1; i <= n; i++) {
if (V[i] == 1) {
continue;
}
if (f[i] > baga && f[i] < MN[i + 1]) V[i] = 3;
baga = max(baga, f[i]);
}
for (int i = 1; i <= n; i++) printf("%d", V[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxm = 1e3 + 5;
const int mod = 1e9 + 7;
int a[21][21], g[21][26], u[21][26];
int f[(1 << 20) + 5];
char ch[21][21];
inline void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", ch[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
for (int j = 0; j < m; j++) {
int sum = 0;
for (int k = 0; k < 26; k++) {
int Max = 0;
g[j][k] = u[j][k] = 0;
for (int i = 0; i < n; i++)
if (ch[i][j] - 'a' == k) {
u[j][k] += a[i][j];
Max = max(Max, a[i][j]);
g[j][k] |= (1 << i);
}
u[j][k] -= Max;
}
}
memset(f, 0x3f, sizeof f);
f[0] = 0;
int tot = (1 << n);
for (int s = 0; s < tot; s++) {
for (int i = 0; i < n; i++) {
int T = (1 << i);
if (!(s & T)) {
for (int j = 0; j < m; j++) {
f[s | T] = min(f[s | T], f[s] + a[i][j]);
int c = ch[i][j] - 'a';
f[s | g[j][c]] = min(f[s | g[j][c]], f[s] + u[j][c]);
}
break;
}
}
}
printf("%d\n", f[tot - 1]);
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
constexpr int N = 200005;
constexpr ll INF = 1ll << 60;
int n, k, q[N];
ll u[N];
ld v[N], cur[N], nxt[N];
inline ld f(int i, int j) { return cur[i] + u[i] * v[j]; }
inline ld cross(ll x0, ld y0, ll x1, ld y1, ll x2, ld y2) {
return (x1 - x0) * (y2 - y1) - (x2 - x1) * (y1 - y0);
}
inline bool convex(int i, int j, int k) {
return cross(u[i], cur[i], u[j], cur[j], u[k], cur[k]) >= 0;
}
int main() {
scanf("%d%d", &n, &k);
int x;
ld inv, tot = 0;
for (auto i = (0); i < (n); i++) {
scanf("%d", &x);
inv = 1.0l / x;
u[i + 1] = u[i] + x;
v[i + 1] = v[i] + inv;
tot += u[i + 1] * inv;
}
for (auto _ = (1); _ < (k); _++) {
int q0 = 0, q1 = 0;
for (auto i = (0); i < (n); i++) cur[i] -= u[i] * v[i];
for (auto i = (1); i < (n + 1); i++) {
while (q0 + 1 < q1 && convex(q[q1 - 2], q[q1 - 1], i - 1)) q1--;
q[q1++] = i - 1;
while (q0 + 1 < q1 && f(q[q0], i) <= f(q[q0 + 1], i)) q0++;
nxt[i] = f(q[q0], i);
}
swap(cur, nxt);
}
printf("%Lf\n", tot - cur[n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int N = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n + 4), vis(n + 4), idx(n + 4), a1(n + 4);
for (int i = 1; i <= n; i++) {
cin >> a[i];
vis[a[i]] = 1;
if (a[i]) {
idx[i] = 1;
}
}
a1 = a;
for (int i = 1; i <= n; i++) {
if (!vis[i] && !idx[i]) {
vis[i] = 1;
a1[i] = i;
}
}
deque<int> order;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
order.push_back(i);
}
}
for (int i = 1; i <= n; i++) {
if (!a1[i]) {
a1[i] = order.back();
order.pop_back();
}
}
for (int i = 1; i <= n; i++) {
if (!a[i]) {
order.push_back(a1[i]);
}
}
int u = order.front();
order.pop_front();
order.push_back(u);
for (int i = 1; i <= n; i++) {
if (a[i]) {
cout << a[i] << " ";
} else {
cout << order.front() << " ";
order.pop_front();
}
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
const int MAXN = 200010;
struct Tedge {
int p, v, next;
};
int n;
int a[MAXN];
Tedge edge[MAXN * 2];
int f[MAXN], q[MAXN], fe[MAXN];
int dp[MAXN], dp2[MAXN];
void init() {
scanf("%d", &n);
memset(a, 0xff, sizeof(a));
int len = 0, s, t;
for (int i = 1; i < n; ++i) {
scanf("%d %d", &s, &t);
edge[++len].p = t;
edge[len].v = 1;
edge[len].next = a[s];
a[s] = len;
edge[++len].p = s;
edge[len].v = 0;
edge[len].next = a[t];
a[t] = len;
}
}
void bfs() {
int i, k, st, ed;
st = 0;
ed = 1;
q[1] = 1;
memset(f, 0xff, sizeof(f));
f[1] = 0;
while (st < ed) {
k = q[++st];
for (int i = a[k]; i != -1; i = edge[i].next)
if (f[edge[i].p] == -1) {
fe[edge[i].p] = edge[i].v;
f[edge[i].p] = k;
q[++ed] = edge[i].p;
}
}
}
void solve() {
int ii, i, k;
memset(dp, 0, sizeof(dp));
memset(dp2, 0, sizeof(dp2));
for (ii = n; ii > 1; --ii) {
k = q[ii];
dp[f[k]] += dp[k];
if (fe[k] == 0) ++dp[f[k]];
}
for (ii = 2; ii <= n; ++ii) {
k = q[ii];
dp2[k] = dp2[f[k]] + dp[f[k]] - dp[k];
if (fe[k] == 0)
--dp2[k];
else
++dp2[k];
}
int mini = n;
for (i = 1; i <= n; ++i)
if (dp[i] + dp2[i] < mini) mini = dp[i] + dp2[i];
printf("%d\n", mini);
for (i = 1; i <= n; ++i)
if (dp[i] + dp2[i] == mini) printf("%d ", i);
printf("\n");
}
int main() {
init();
bfs();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
string s[3];
cin >> s[0] >> s[1] >> s[2];
sort(s, s + 3);
if (s[0] == s[1] && s[1] == s[2]) {
cout << "0" << endl;
return 0;
}
if ((s[1][0] - s[0][0] == 1 && s[1][1] == s[0][1]) &&
(s[2][0] - s[1][0] == 1 && s[2][1] == s[1][1])) {
cout << "0" << endl;
return 0;
}
if ((s[1][0] - s[0][0] == 1 && s[1][1] == s[0][1]) ||
(s[2][0] - s[1][0] == 1 && s[2][1] == s[1][1]) ||
(s[2][0] - s[0][0] == 1 && s[2][1] == s[0][1])) {
cout << "1" << endl;
return 0;
}
if (s[1] == s[0] || s[2] == s[0] || s[1] == s[2]) {
cout << "1" << endl;
return 0;
}
if ((s[1][0] - s[0][0] == 2 && s[1][1] == s[0][1]) ||
(s[2][0] - s[1][0] == 2 && s[2][1] == s[1][1]) ||
(s[2][0] - s[0][0] == 2 && s[2][1] == s[0][1])) {
cout << "1" << endl;
return 0;
}
cout << "2";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<set<string> > N, F;
vector<pair<string, string> > ans;
set<string> p;
for (int i = 0; i < 26; ++i) {
N.push_back(p);
F.push_back(p);
}
int n, k, c;
cin >> n;
c = (int)'A';
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
k = (int)s[0];
N[k - c].insert(s);
}
for (int i = 0; i < n; ++i) {
cin >> s;
k = (int)s[0];
F[k - c].insert(s);
}
queue<string> qN, qF;
set<string>::iterator el, el1;
for (int i = 0; i < 26; ++i) {
if (N[i].size() <= F[i].size()) {
while (N[i].size() < F[i].size() && !qN.empty()) {
el = F[i].begin();
ans.push_back(make_pair(qN.front(), *el));
F[i].erase(el);
qN.pop();
}
while (!N[i].empty()) {
el = F[i].begin();
el1 = N[i].begin();
ans.push_back(make_pair(*el1, *el));
F[i].erase(el);
N[i].erase(el1);
}
while (!F[i].empty()) {
el = F[i].begin();
qF.push(*el);
F[i].erase(el);
}
} else {
while (F[i].size() < N[i].size() && !qF.empty()) {
el = N[i].begin();
ans.push_back(make_pair(*el, qF.front()));
N[i].erase(el);
qF.pop();
}
while (!F[i].empty()) {
el = F[i].begin();
el1 = N[i].begin();
ans.push_back(make_pair(*el1, *el));
F[i].erase(el);
N[i].erase(el1);
}
while (!N[i].empty()) {
el = N[i].begin();
qN.push(*el);
N[i].erase(el);
}
}
}
sort(ans.begin(), ans.end());
int i;
for (i = 0; i < ans.size() - 1; ++i)
cout << ans[i].first << " " << ans[i].second << ", ";
cout << ans[i].first << " " << ans[i].second;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
double powTab[100009];
double modPow(double n, int k) {
double r = 1;
while (k) {
if (k & 1) {
r = (r * n);
}
n = (n * n);
k >>= 1;
}
return r;
}
int main(int argc, char const *argv[]) {
int m;
scanf("%d%d", &m, &n);
double ans = 0;
for (int i = 1; i <= m; i++) {
ans +=
(double)i * (modPow(i / (double)m, n) - modPow((i - 1) / (double)m, n));
}
printf("%.9lf\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
const int MOD = 1e9 + 7;
const int MAX_N = 1e2 + 5;
const int D = 10;
int arr[MAX_N], dp[MAX_N][D], C[MAX_N][MAX_N];
int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
if (a < 0) a += MOD;
return a;
}
int mult(int a, int b) {
long long res = 1LL * a * b;
if (res >= MOD) res %= MOD;
return res;
}
int solve(int restantes, int digito) {
if (restantes == 0) {
return digito > 10 ? 1 : arr[digito] > 0 ? 0 : solve(0, digito + 1);
}
if (digito >= 10) {
return 0;
}
int &res = dp[restantes][digito];
if (~res) {
return res;
}
res = 0;
for (int i = max(0, arr[digito]); i <= restantes; i++) {
res = add(res, mult(C[restantes][i], solve(restantes - i, digito + 1)));
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
C[0][0] = 1;
C[1][0] = C[1][1] = 1;
for (int i = 2; i < MAX_N; i++) {
C[i][0] = 1;
for (int j = 1; j < MAX_N; j++) {
C[i][j] = add(C[i - 1][j], C[i - 1][j - 1]);
}
}
int n;
cin >> n;
const int d = 10;
int s = 0;
for (int i = 0; i < d; i++) {
cin >> arr[i];
s += arr[i];
}
int ans = 0;
for (int i = max(1, s); i <= n; i++) {
for (int primeiro = 1; primeiro < d; primeiro++) {
memset(dp, -1, sizeof(dp));
--arr[primeiro];
ans = add(ans, solve(i - 1, 0));
++arr[primeiro];
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int d[100010], c[100010], a[1000010];
int main() {
int n, l = 0;
long long area = (long long)0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &d[i]);
c[i]++;
}
sort(d, d + n);
for (int i = n - 1; i >= 0; i--) {
if (c[i] != 0) {
if (d[i] == d[i - 1] || d[i] - d[i - 1] == 1) {
a[l] = d[i - 1];
c[i - 1]--;
l++;
}
}
}
for (int i = 0; i < l; i++) {
area += (long long)a[i] * (long long)a[i + 1];
i++;
}
printf("%I64d", area);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
int t; cin>>t;
while(t--){
int n, k;
cin>>n>>k;
int h[n];
for(int i = 0; i<n; i++)
cin>>h[i];
int mn = h[0], mx = h[0];
int chk = 1;
for(int i = 1; i<n; i++){
mn -=(k-1);
mx +=(k-1);
mn = max(mn, h[i]), mx = min(mx, h[i]+k-1);
if(mn>mx) chk = 0;
}
cout<<(chk&&(mn==h[n-1])?"yes\n":"no\n");
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int onitan(long long z) {
int senpai = 0;
while (z > 0) {
senpai += z % 10;
z /= 10;
}
return senpai;
}
int main() {
long long n;
cin >> n;
int ans = 9;
if (n < 10) {
cout << n;
return 0;
}
long long k1 = 9;
while (k1 * 10 + 9 <= n) {
k1 *= 10;
k1 += 9;
ans += 9;
}
n -= k1;
cout << ans + onitan(n);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
int n, elm, m;
cin >> n;
int prefixsum = 0;
for (int i = 0; i < n; ++i) {
cin >> elm;
prefixsum += elm;
v.push_back(prefixsum);
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> elm;
int ans = lower_bound(v.begin(), v.end(), elm) - v.begin();
cout << ans + 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
while (cin >> str) {
long long sum = 0, heavy = 0;
string temp;
for (int i = 0; i < str.size(); i++) {
temp = str.substr(i, 5);
if (temp == "heavy")
heavy++, i += 4;
else if (temp == "metal")
sum += heavy, i += 4;
}
cout << sum << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, r, dv;
vector<int> t, d;
void gentest(int s) {
freopen("input.txt", "w", stdout);
printf("%d\n", s);
for (int(i) = 0; (i) < (s); ++(i)) printf("%d ", rand() % 2000 - 1000);
printf("\n");
exit(0);
}
int main() {
scanf("%d", &n);
t.clear();
t.resize(n);
m = 0;
for (int(i) = 0; (i) < (n); ++(i)) scanf("%d", &t[i]);
d.clear();
for (int i = 1; i * i <= n; i++) {
if (n % i != 0) continue;
if (n / i >= 3) d.push_back(i);
if (i >= 3) d.push_back(n / i);
}
for (int(i) = 0; (i) < (n); ++(i)) m += t[i];
for (int(i) = 0; (i) < (int((d).size())); ++(i)) {
dv = d[i];
for (int(i) = 0; (i) < (dv); ++(i)) {
r = 0;
for (int(j) = 0; (j) < (n / dv); ++(j)) r += t[i + j * dv];
if (r > m) m = r;
}
}
printf("%d\n", m);
return 0;
}
| 2 |
#include <bits/stdc++.h>
template <typename Y>
inline bool updmin(Y &a, Y b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename Y>
inline bool updmax(Y &a, Y b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename Y>
inline Y abs(Y a) {
if (a < 0) a = -a;
return a;
}
template <typename Y>
inline Y sqr(Y a) {
return a * a;
}
int read() {
int w = 1, q = 0, ch = ' ';
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') w = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) q = q * 10 + ch - 48;
return q * w;
}
inline void FileIO() {
freopen(
""
".in",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
const int maxn = 10080;
const long long M = 1e9;
int n, m, U[maxn], V[maxn];
long long a[maxn], b[maxn], c[maxn], d[maxn];
namespace fa {
const long long inf = 1ll << 60;
int e_num = 1, S, T;
int hed[maxn], dep[maxn];
long long deg[maxn];
struct Edge {
int from, to, nxt;
long long c;
} edge[maxn * 4];
void addedge(int from, int to, long long c) {
edge[++e_num] = (Edge){from, to, hed[from], c};
hed[from] = e_num;
}
void adde(int from, int to, long long c) {
addedge(from, to, c);
addedge(to, from, 0);
}
void clear() {
e_num = 1;
memset(hed, 0, sizeof hed);
}
std::queue<int> q;
bool bfs() {
while (!q.empty()) {
q.pop();
}
q.push(S);
memset(dep, 0, sizeof(dep));
dep[S] = 1;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = hed[cur]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (!dep[to] && edge[i].c) {
dep[to] = dep[cur] + 1;
q.push(to);
}
}
}
return dep[T];
}
long long dfs(int x, long long flow) {
if (x == T) return flow;
long long ret = 0;
for (int i = hed[x]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (dep[to] == dep[x] + 1 && edge[i].c) {
long long tmp = dfs(to, std::min(flow, edge[i].c));
edge[i].c -= tmp;
edge[i ^ 1].c += tmp;
flow -= tmp;
ret += tmp;
if (!flow) {
break;
}
}
}
if (!ret) dep[x] = 0;
return ret;
}
long long dinic() {
long long ret = 0;
while (bfs()) {
ret += dfs(S, inf);
}
return ret;
}
long long check(long long t) {
long long suml = 0;
clear();
S = 0, T = n + 1;
memset(deg, 0, sizeof deg);
for (int i = 1; i <= m; i++) {
long long l = a[i] * t + b[i];
long long r = c[i] * t + d[i];
deg[U[i]] -= l;
deg[V[i]] += l;
adde(U[i], V[i], r - l);
}
for (int i = 1; i <= n; i++) {
if (deg[i] > 0) {
suml += deg[i];
adde(S, i, deg[i]);
} else {
adde(i, T, -deg[i]);
}
}
long long d = dinic();
return suml - d;
}
} // namespace fa
long long L, R, ans1, ans2;
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
U[i] = read();
V[i] = read();
a[i] = read();
b[i] = read() * M;
c[i] = read();
d[i] = read() * M;
}
L = 0, R = M;
while (L < R) {
long long mid = (L + R) >> 1;
long long delta = fa::check(mid + 1) - fa::check(mid);
if (delta >= 0) {
R = mid;
} else {
L = mid + 1;
}
}
ans1 = L;
if (fa::check(ans1) != 0) {
puts("0");
return 0;
}
L = 0, R = M;
while (L < R) {
long long mid = (L + R + 1) >> 1;
long long delta = fa::check(mid) - fa::check(mid - 1);
if (delta <= 0) {
L = mid;
} else {
R = mid - 1;
}
}
ans2 = R;
printf("%.10lf\n", (double)(ans2 - ans1) / (double)M);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool mark[10][200010];
long long memo[10][200010];
vector<int> t[4][200010];
long long dp(int turn, int cards) {
if (turn == n) return 0;
long long& ans = memo[cards][turn];
if (mark[cards][turn]) return ans;
mark[cards][turn] = true;
ans = dp(turn + 1, cards);
long long dmg;
if (t[3][turn].size()) {
dmg = t[3][turn][0];
if (cards == 9) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 1) % 10) + dmg);
}
if (t[1][turn].size()) {
int l = t[1][turn].size();
dmg = t[1][turn][0];
if (cards == 9) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 1) % 10) + dmg);
if (l >= 2) {
dmg = t[1][turn][0];
if (cards >= 8) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 2) % 10) + dmg + t[1][turn][1]);
}
if (l >= 3) {
dmg = t[1][turn][0];
if (cards >= 7) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 3) % 10) + dmg + t[1][turn][1] +
t[1][turn][2]);
}
}
if (t[2][turn].size()) {
dmg = t[2][turn][0];
if (cards == 9) dmg *= 2LL;
ans = max(ans, dp(turn + 1, (cards + 1) % 10) + dmg);
if (t[1][turn].size()) {
long long a = t[2][turn][0], b = t[1][turn][0];
if (cards >= 8 && a > b) {
a *= 2LL;
} else if (cards >= 8) {
b *= 2LL;
}
dmg = a + b;
ans = max(ans, dp(turn + 1, (cards + 2) % 10) + dmg);
}
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int ci, di;
scanf("%d %d", &ci, &di);
t[ci][i].push_back(di);
}
for (int j = 1; j <= 3; j++)
sort(t[j][i].begin(), t[j][i].end(), greater<int>());
}
printf("%lld\n", dp(0, 0));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void EnableFileIO(const string& fileName, bool local = 0) {
if (fileName.empty()) return;
if (local) {
freopen((fileName + ".in").c_str(), "r", stdin);
freopen((fileName + ".out").c_str(), "w", stdout);
return;
}
freopen((fileName + ".in").c_str(), "r", stdin);
freopen((fileName + ".out").c_str(), "w", stdout);
}
const int INF = (1 << 30) - 1;
const long long LINF = (1LL << 61) - 1;
const double EPS = 1e-10, PI = acos(-1);
const int N = 2e3 + 100, P = 1e6 + 3;
int n, l;
string s;
vector<int> v;
long long f[N][N], sum[N];
int main() {
cin >> s;
l = (int)s.length();
for (int i = 0, buff = 0; i < l; i++) {
if (!isdigit(s[i])) {
++buff;
} else {
if (buff) v.push_back(buff), buff = 0;
}
if ((i == l - 1 && buff) ||
((!i || !isdigit(s[i - 1])) && (s[i] == '*' || s[i] == '/'))) {
cout << 0 << endl;
return 0;
}
}
n = (int)v.size();
f[0][0] = 1;
for (int i = 0; i < n; i++) {
memset(sum, 0, sizeof sum);
for (int j = 0; j < l; j++) sum[j] = ((j ? sum[j - 1] : 0) + f[i][j]) % P;
for (int j = 0; j < l; j++) {
f[i + 1][j] =
(sum[l - 1] - (j - v[i] - 1 >= 0 ? sum[j - v[i] - 1] : 0) + P) % P;
}
}
cout << f[n][0] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int INF = 0x3f3f3f3f;
const double inf = 0x3f3f3f3f3f3f;
const long long LNF = 0x3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-8;
const int maxn = 1e2 + 100;
const int mod = 1e9 + 7;
const int dr[] = {-1, 0, 1, 0};
const int dc[] = {0, 1, 0, -1};
const char *Hex[] = {"0000", "0001", "0010", "0011", "0100", "0101",
"0110", "0111", "1000", "1001", "1010", "1011",
"1100", "1101", "1110", "1111"};
int n, m;
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int monn[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
inline int Min(int a, int b) { return a < b ? a : b; }
inline int Max(int a, int b) { return a > b ? a : b; }
inline long long Min(long long a, long long b) { return a < b ? a : b; }
inline long long Max(long long a, long long b) { return a > b ? a : b; }
inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline int lcm(int a, int b) { return a * b / gcd(a, b); }
inline bool is_in(int r, int c) { return r >= 0 && r < n && c >= 0 && c < m; }
struct Node {
int l, r;
Node() {}
Node(int ll, int rr) : l(ll), r(rr) {}
bool operator<(const Node &p) const { return l < p.l; }
};
Node a[205];
int main() {
while (scanf("%d", &n) == 1) {
int s, d;
int cnt = 1;
a[0] = Node(0, 0);
cin >> s >> d;
printf("%d %d\n", s, s + d - 1);
a[cnt++] = Node(s, s + d - 1);
for (int i = 1; i < n; ++i) {
cin >> s >> d;
--d;
sort(a, a + cnt);
if (a[cnt - 1].r < s) {
printf("%d %d\n", s, s + d);
a[cnt++] = Node(s, s + d);
continue;
}
bool ok = false;
for (int j = 0; j < cnt - 1; ++j) {
if (s > a[j].r && s + d < a[j + 1].l) {
ok = true;
printf("%d %d\n", s, s + d);
a[cnt++] = Node(s, s + d);
break;
}
}
if (!ok) {
bool ok1 = false;
for (int j = 1; j < cnt; ++j) {
if (a[j].l - a[j - 1].r > d + 1) {
printf("%d %d\n", a[j - 1].r + 1, a[j - 1].r + d + 1);
a[cnt++] = Node(a[j - 1].r + 1, a[j - 1].r + d + 1);
ok1 = true;
break;
}
}
if (!ok1) {
printf("%d %d\n", a[cnt - 1].r + 1, a[cnt - 1].r + 1 + d);
a[cnt] = Node(a[cnt - 1].r + 1, a[cnt - 1].r + d + 1);
++cnt;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
char a[510][510];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int count = 0;
for (int i = 1; i < n - 1; ++i) {
for (int j = 1; j < n - 1; ++j) {
int num = 0;
if (i - 1 >= 0 && j - 1 >= 0) {
if (a[i - 1][j - 1] == 'X') num += 1;
}
if (i - 1 >= 0 && j + 1 < n) {
if (a[i - 1][j + 1] == 'X') num += 1;
}
if (i + 1 < n && j - 1 >= 0) {
if (a[i + 1][j - 1] == 'X') num += 1;
}
if (i + 1 < n && j + 1 < n) {
if (a[i + 1][j + 1] == 'X') num += 1;
}
if (a[i][j] == 'X') {
num += 1;
}
if (num == 5) count++;
}
}
cout << count << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int w, h;
scanf("%d%d", &w, &h);
int u1, d1, u2, d2;
scanf("%d%d%d%d", &u1, &d1, &u2, &d2);
for (register int i = h; i >= (d1 > d2 ? d1 : d2); --i) w += i;
w -= (d1 > d2 ? u1 : u2);
if (w < 0) w = 0;
for (register int i = (d1 > d2 ? d1 : d2) - 1; i >= (d1 < d2 ? d1 : d2); --i)
w += i;
w -= (d1 < d2 ? u1 : u2);
if (w < 0) w = 0;
for (register int i = (d1 < d2 ? d1 : d2) - 1; i >= 1; --i) w += i;
printf("%d\n", w);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt = 0, t = 0;
string q;
char tmp = '\0';
cin >> tt >> t;
cin >> q;
for (int i = 0; i < t; ++i) {
for (int j = 0; j < q.length() - 1; ++j) {
if (q[j] == 'B' && q[j + 1] == 'G') {
tmp = q[j];
q[j] = q[j + 1];
q[j + 1] = tmp;
++j;
}
}
}
cout << q;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double EPS = 1e-24;
const long long int MOD = 1000000007ll;
const double PI = 3.14159265359;
int INF = 2147483645;
template <class T>
T Max2(T a, T b) {
return a < b ? b : a;
}
template <class T>
T Min2(T a, T b) {
return a < b ? a : b;
}
template <class T>
T Max3(T a, T b, T c) {
return Max2(Max2(a, b), c);
}
template <class T>
T Min3(T a, T b, T c) {
return Min2(Min2(a, b), c);
}
template <class T>
T Max4(T a, T b, T c, T d) {
return Max2(Max2(a, b), Max2(c, d));
}
template <class T>
T Min4(T a, T b, T c, T d) {
return Min2(Min2(a, b), Max2(c, d));
}
template <class T>
void Swap(T& a, T& b) {
T temp;
temp = a;
a = b;
b = temp;
}
using namespace std;
int N, P;
vector<pair<int, int> > G[1010];
vector<pair<pair<int, int>, int> > ans;
int x, y, z;
bool vis[1010];
bool in[1010];
bool out[1010];
void dfs(int u) {
vis[u] = true;
bool tap = true;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first;
z = Min2(z, G[u][i].second);
tap = false;
dfs(v);
}
if (tap) y = u;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> P;
for (int i = 1; i <= P; i++) {
int a, b, d;
cin >> a >> b >> d;
G[a].push_back({b, d});
out[a] = true;
in[b] = true;
}
for (int i = 1; i <= N; i++)
if (out[i] && !in[i]) {
x = i;
z = 10000000;
dfs(i);
ans.push_back({{x, y}, z});
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first.first << " " << ans[i].first.second << " "
<< ans[i].second << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int D[110], n, s;
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++) {
int h, m;
cin >> h >> m;
D[i] = h * 60 + m;
}
D[n] = 0x3f3f3f3f;
int resph, respm, resp, ind = 1;
if (s >= D[0])
for (int i = 0; i < n; i++) {
if (D[i + 1] - D[i] > 2 * s + 1 && ind) {
resp = D[i] + s + 1;
ind = 0;
}
}
else
resp = 0;
respm = resp % 60;
resph = (resp - respm) / 60;
cout << resph << " " << respm << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long int x, y, z;
int a[111111], b[111111], c[111111];
set<int> st;
vector<int> v;
bool isprime(int x) {
if (x == 2) return true;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
int main() {
cin >> n;
if (n > 1000) {
int ost;
for (int i = 300; i >= 0; i++) {
if (isprime(n - i)) {
ost = i;
v.push_back(n - i);
break;
}
}
for (int i = 2; i < ost / 2; i++) {
if (isprime(i) && isprime(ost - i)) {
v.push_back(i);
v.push_back(ost - i);
break;
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
} else if (n == 3) {
cout << 1 << endl;
cout << 3;
} else if (n == 4) {
cout << 2 << endl;
cout << 2 << " " << 2;
} else if (n == 5) {
cout << 2 << endl;
cout << 2 << " " << 3;
} else if (n == 6) {
cout << 2 << endl;
cout << 3 << " " << 3;
} else {
n -= 3;
v.push_back(3);
for (int i = 2; i <= n / 2; i++) {
if (isprime(i) && isprime(n - i)) {
v.push_back(i);
v.push_back(n - i);
break;
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
namespace myland {
using namespace std;
namespace _abbr {}
using namespace _abbr;
namespace _constant {
const double EPS(1e-8);
const double PI(acos(-1.0));
const int INF(0x3f3f3f3f);
const long long INFL(0x3f3f3f3f3f3f3f3fll);
const int MOD(1e9 + 7);
const int dx[] = {-1, 0, 1, 0, -1, 1, 1, -1},
dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
} // namespace _constant
using namespace _constant;
namespace _solve {}
using namespace _solve;
namespace _calculate {
bool odd(long long x) { return x & 1; }
bool even(long long x) { return (x & 1) ^ 1; }
bool posi(long long x) { return x > 0; }
bool nega(long long x) { return x < 0; }
bool zero(long long x) { return x == 0; }
bool prime(long long x) {
if (x < 2) return 0;
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
long long droot(long long x) { return 1 + (x - 1) % 9; }
long long upd(long long a, long long b) { return a % b ? a / b + 1 : a / b; };
long long random(long long a, long long b) {
return a + rand() * rand() % (b - a + 1);
};
long long bitn(long long x) {
long long c = 0;
while (x) c++, x >>= 1;
return c;
}
template <class T>
T sqr(T x) {
return x * x;
}
long long qpow(long long a, long long n, long long mod = MOD) {
long long res(1);
while (n) {
if (n & 1) (res *= a) %= mod;
(a *= a) %= mod;
n >>= 1;
}
return res % mod;
}
long long inv(long long a, long long mod = MOD) { return qpow(a, mod - 2); }
template <class T>
void tomin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
void tomax(T& a, T b) {
if (b > a) a = b;
}
} // namespace _calculate
using namespace _calculate;
namespace _simple_algo {
long long sol(const string& s) {
long long x = 0;
for (char c : s) x = x * 10 + c - 48;
return x;
}
string los(long long x) {
string s = "";
if (x == 0) return "0";
while (x) s = char(x % 10 + 48) + s, x /= 10;
return s;
}
bool pal(const string& s) {
int l = s.size();
for (int i = 0, j = l - 1; i < j; i++, j--)
if (s[i] != s[j]) return 0;
return 1;
}
} // namespace _simple_algo
using namespace _simple_algo;
namespace _io {
template <class T>
void rd(T& x) {
cin >> x;
}
string srd() {
string s;
cin >> s;
return s;
}
long long rd() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void rd(int& x) { x = rd(); }
void rd(long long& x) { x = rd(); }
template <class A, class B>
void rd(pair<A, B>& p) {
cin >> p.first >> p.second;
}
template <class A, class B>
void rd(A& a, B& b) {
rd(a), rd(b);
}
template <class A, class B, class C>
void rd(A& a, B& b, C& c) {
rd(a, b);
rd(c);
}
template <class T>
void wt(const T& x) {
cout << x << endl;
}
template <class T>
void wt(const T& x, char c) {
cout << x << c;
}
template <class T>
void wt(const T& x, const string& s) {
cout << x << s;
}
template <class T>
void wt(const T& x, int rnd) {
cout << fixed << setprecision(rnd) << x << endl;
}
template <class T>
void wt(const vector<T>& v) {
for (T x : v) wt(x, ' ');
wt("");
}
template <class A, class B>
void wt(const pair<A, B>& make_pair) {
cout << make_pair.first << ' ' << make_pair.second << endl;
}
} // namespace _io
using namespace _io;
} // namespace myland
using namespace myland;
const int N = 5e5 + 5;
struct segt {
struct seg {
int l, r;
bool tag, col;
};
seg t[N << 2];
void push_up(int x) {
if (t[x << 1].tag && t[x << 1 | 1].tag &&
t[x << 1].col == t[x << 1 | 1].col) {
t[x].tag = 1;
t[x].col = t[x << 1].col;
} else {
t[x].tag = 0;
}
}
void push_down(int x) {
if (t[x].tag) {
t[x << 1].tag = t[x << 1 | 1].tag = 1;
t[x << 1].col = t[x << 1 | 1].col = t[x].col;
}
}
void build(int x, int l, int r) {
t[x] = seg({l, r, 1, 0});
if (l == r) return;
build(x << 1, l, ((t[x].l + t[x].r) / 2));
build(x << 1 | 1, ((t[x].l + t[x].r) / 2) + 1, r);
}
void update(int x, int l, int r, bool v) {
int L = t[x].l, R = t[x].r;
if (l <= L && R <= r) {
t[x].col = v;
t[x].tag = 1;
return;
}
push_down(x);
if (l <= ((t[x].l + t[x].r) / 2)) update(x << 1, l, r, v);
if (r > ((t[x].l + t[x].r) / 2)) update(x << 1 | 1, l, r, v);
push_up(x);
}
bool query(int x, int p) {
if (t[x].tag) return t[x].col;
push_down(x);
if (p <= ((t[x].l + t[x].r) / 2))
return query(x << 1, p);
else
return query(x << 1 | 1, p);
}
};
struct e {
int v, nxt;
};
int n(rd()), u, v, op, p;
int idx(1), head[N];
e edge[N << 1];
int fa[N], son[N], siz[N], top[N], pos_idx, pos[N], lsp[N];
segt T;
void dfs1(int u) {
siz[u] = 1;
son[u] = -1;
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].v;
if (v == fa[u]) continue;
fa[v] = u;
dfs1(v);
siz[u] += siz[v];
if (son[u] == -1 || siz[v] > siz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int top_idx) {
lsp[u] = pos[u] = ++pos_idx;
top[u] = top_idx;
if (son[u] != -1) dfs2(son[u], top[u]), lsp[u] = lsp[son[u]];
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].v;
if (v != fa[u] && v != son[u]) dfs2(v, v), lsp[u] = lsp[v];
}
}
void update(int p) {
int f = top[p];
while (f) {
T.update(1, pos[f], pos[p], 0);
p = fa[f];
f = top[p];
}
}
int main() {
for (int cas = 1, tms = (n - 1); cas <= tms; cas++) {
rd(u, v);
edge[idx] = e({v, head[u]});
head[u] = idx++;
edge[idx] = e({u, head[v]});
head[v] = idx++;
}
dfs1(1);
dfs2(1, 1);
T.build(1, 1, n);
for (int cas = 1, tms = (rd()); cas <= tms; cas++) {
rd(op, p);
if (op == 1)
T.update(1, pos[p], lsp[p], 1);
else if (op == 2)
update(p);
else
wt(T.query(1, pos[p]));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ar[2000], ind;
int init() {
ar[0] = 0;
ind = 1;
char tmp[10];
int ind2;
for (int i = 1; i <= 9; i++) {
for (int j = i; j >= 0; j--) {
ind2 = 0;
tmp[i] = 0;
while (ind2 < j) tmp[ind2++] = '4';
while (ind2 < i) tmp[ind2++] = '7';
do {
sscanf(tmp, "%d", &ar[ind++]);
} while (next_permutation(tmp, tmp + i));
}
}
ar[ind] = 1000000001;
sort(ar, ar + ind);
return 0;
}
int solve() {
int pl, pr, vl, vr, k;
scanf("%d %d %d %d %d", &pl, &pr, &vl, &vr, &k);
int cur = 0;
long long cnt = 0;
int l1, l2, u1, u2, kak1, kak2;
long long pp, vv;
for (int i = 1; i < ind; i++) {
if (i + k > ind) break;
l1 = ar[i - 1] + 1;
l2 = ar[i];
u1 = ar[i + k - 1];
u2 = ar[i + k] - 1;
pp = min(l2, pr) - max(l1, pl) + 1;
if (pp < 0) pp = 0;
vv = min(u2, vr) - max(u1, vl) + 1;
if (vv < 0) vv = 0;
cnt += pp * vv;
pp = min(u2, pr) - max(u1, pl) + 1;
if (pp < 0) pp = 0;
vv = min(l2, vr) - max(l1, vl) + 1;
if (vv < 0) vv = 0;
cnt += pp * vv;
kak1 = max(l1, u1);
kak2 = min(u2, l2);
pp = min(kak2, pr) - max(kak1, pl) + 1;
if (pp < 0) pp = 0;
vv = min(kak2, vr) - max(kak1, vl) + 1;
if (vv < 0) vv = 0;
cnt -= pp * vv;
}
long long all1 = (pr - pl + 1);
long long all2 = (vr - vl + 1);
long long all = all1 * all2;
double sol = 1.0 * cnt / all;
if (sol > 1.0) sol = 1.0;
if (sol < 0) sol = 0.0;
printf("%.12lf\n", sol);
return 0;
}
int main() {
init();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
int t;
for (cin >> t; t--;) {
int a, b;
cin >> a >> b;
if (gcd(a, b) == 1)
cout << "Finite" << '\n';
else
cout << "Infinite" << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mo(long long a) { return a % (long long)(1e9 + 7); }
long long po(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y >>= 1;
x = (x * x) % p;
}
return res % p;
}
vector<vector<long long>> g;
long long n, m, q;
struct dsu {
int n;
vector<long long> a, rank, dia;
void init(long long si) {
n = si;
a.resize(n);
rank.resize(n);
dia.resize(n);
for (long long i = 0; i < n; i++) {
rank[i] = 1;
a[i] = i;
dia[i] = 0;
}
}
long long get(long long i) { return a[i] = ((i == a[i]) ? i : get(a[i])); }
void unio(long long i, long long j) {
long long x = get(i), y = get(j);
if (x == y) return;
if (rank[x] == rank[y]) rank[x]++;
if (rank[y] > rank[x]) swap(x, y);
a[y] = x;
dia[x] = max({dia[x], dia[y], (dia[x] + 1) / 2 + (dia[y] + 1) / 2 + 1});
}
};
vector<long long> vis, dist, vis2;
long long root;
dsu ds;
void dfs(long long par, long long is) {
vis[par] = 1;
if (dist[root] < dist[par]) root = par;
for (long long e : g[par]) {
if (!vis[e]) {
ds.unio(par, e);
dist[e] = dist[par] + 1;
dfs(e, is);
}
}
if (is) vis[par] = 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> q;
g.assign(n, {});
vis.assign(n, 0);
dist.assign(n, 0);
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
ds.init(n);
for (long long i = 0; i < n; i++) {
if (!vis[i]) {
root = i;
dist[root] = 0;
dfs(i, 1);
dist[root] = 0;
dfs(root, 0);
ds.dia[ds.get(i)] = dist[root];
}
}
while (q--) {
long long op;
cin >> op;
if (op == 1) {
long long x;
cin >> x;
x--;
cout << ds.dia[ds.get(x)] << "\n";
} else {
long long x, y;
cin >> x >> y;
x--;
y--;
ds.unio(x, y);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int maxn = 1000000 + 10;
int pre[maxn], x[maxn], y[maxn], f[maxn];
int main() {
int n, tmp;
scanf("%d", &n);
pre[1] = -1;
for (int i = 2; i <= n + 1; ++i) {
scanf("%d", &pre[i]);
for (int cur = i; cur != 1; cur = pre[cur]) {
tmp = ((x[cur]) > (y[cur] + 1) ? (x[cur]) : (y[cur] + 1));
if (tmp <= f[cur]) {
break;
}
f[cur] = tmp;
if (tmp > x[pre[cur]])
x[pre[cur]] = tmp;
else if (tmp > y[pre[cur]])
y[pre[cur]] = tmp;
}
printf("%d ", ((x[1]) > (y[1]) ? (x[1]) : (y[1])));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, ans1, ans2;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a, ans1 |= a;
for (int i = 0; i < n; i++) cin >> b, ans2 |= b;
cout << ans1 + ans2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e4 + 10;
int n, comp = 0;
;
string a[maxn], b[maxn], x;
vector<int> g[maxn], bg[maxn], myStack;
int mark[maxn], ans[maxn];
void dfs(int u) {
mark[u] = true;
for (int i = 0; i < bg[u].size(); i++)
if (!mark[bg[u][i]]) dfs(bg[u][i]);
myStack.push_back(u);
return;
}
void back_dfs(int u) {
mark[u] = comp;
for (int i = 0; i < g[u].size(); i++)
if (mark[g[u][i]] == -1) back_dfs(g[u][i]);
}
void find_comps() {
memset(mark, 0, sizeof mark);
for (int i = 0; i < 4 * n; i++) {
if (!mark[i]) dfs(i);
}
memset(mark, -1, sizeof mark);
comp = 0;
while (myStack.size() != 0) {
myStack.pop_back();
int tmp = *(myStack.end());
if (mark[tmp] == -1) {
back_dfs(tmp);
comp++;
}
}
for (int i = 0; i < 2 * n; i++) {
if (mark[2 * i] == mark[2 * i + 1]) {
cout << "-1\n";
exit(0);
}
ans[i] = mark[2 * i] < mark[2 * i + 1];
}
int cnt = 0;
for (int i = 0; i < 2 * n; i++) cnt += ans[i];
cout << cnt << "\n";
for (int i = 0; i < 2 * n; i++) {
if (ans[i]) {
if (i < n)
cout << "row " << i << "\n";
else
cout << "col " << i - n << "\n";
}
}
exit(0);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
cin >> x;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == b[i][j]) {
if (x[i] == '0' && x[j] == '0')
continue;
else if (x[i] == '0' && x[j] == '1') {
g[2 * i].push_back(2 * i + 1);
bg[2 * i + 1].push_back(2 * i);
} else if (x[i] == '1' && x[j] == '0') {
j += n;
g[2 * j].push_back(2 * j + 1);
bg[2 * j + 1].push_back(2 * j);
j -= n;
} else {
j += n;
g[2 * i].push_back(2 * j);
g[2 * j + 1].push_back(2 * i + 1);
g[2 * i + 1].push_back(2 * j + 1);
g[2 * j].push_back(2 * i);
bg[2 * j].push_back(2 * i);
bg[2 * i + 1].push_back(2 * j + 1);
bg[2 * j + 1].push_back(2 * i + 1);
bg[2 * i].push_back(2 * j);
j -= n;
}
} else {
if (x[i] == '0' && x[j] == '0') {
cout << "-1\n";
return 0;
} else if (x[i] == '0' && x[j] == '1') {
g[2 * i + 1].push_back(2 * i);
bg[2 * i].push_back(2 * i + 1);
} else if (x[i] == '1' && x[j] == '0') {
j += n;
g[2 * j + 1].push_back(2 * j);
bg[2 * j].push_back(2 * j + 1);
j -= n;
} else {
j += n;
g[2 * i + 1].push_back(2 * j);
g[2 * j + 1].push_back(2 * i);
g[2 * i].push_back(2 * j + 1);
g[2 * j].push_back(2 * i + 1);
bg[2 * j].push_back(2 * i + 1);
bg[2 * i].push_back(2 * j + 1);
bg[2 * j + 1].push_back(2 * i);
bg[2 * i + 1].push_back(2 * j);
j -= n;
}
}
}
}
find_comps();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ans[1111111], U, tans[1111111];
int N;
map<pair<int, int>, int> m;
int M = 0;
vector<int> v[1111111];
pair<int, int> c[1111111];
long double s(int A, int B, int C) {
return (((long double)1.0) / c[B].first - ((long double)1.0) / c[A].first) *
(((long double)1.0) / c[C].second -
((long double)1.0) / c[A].second) -
(((long double)1.0) / c[B].second - ((long double)1.0) / c[A].second) *
(((long double)1.0) / c[C].first -
((long double)1.0) / c[A].first);
}
void convex_hull() {
sort(c, c + N);
U = 0;
for (int i = 0; i < (N); i++) {
while ((U && c[tans[U - 1]].second <= c[i].second) ||
(U > 1 && s(i, tans[U - 1], tans[U - 2]) < -1e-15))
U--;
tans[U] = i;
ans[U++] = m[c[i]];
}
}
vector<int> t;
int main(int argc, char *argv[]) {
int M;
scanf("%d", &M);
for (int i = 0; i < (M); i++) {
scanf("%d%d", &c[N].first, &c[N].second);
pair<int, int> p = c[N];
if (!m.count(p)) m[p] = N++;
v[m[p]].push_back(i);
}
convex_hull();
for (int i = 0; i < (U); i++)
t.insert(t.end(), v[ans[i]].begin(), v[ans[i]].end());
sort(t.begin(), t.end());
for (int i = 0; i < (t.size()); i++) {
if (i) printf(" ");
printf("%d", t[i] + 1);
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
class Hopcroft {
vector<vector<int>> g;
vector<int> U, dist;
int inf = 1e9;
bool bfs() {
queue<int> q;
for (int u : U)
if (match[u] == nil)
dist[u] = 0, q.push(u);
else
dist[u] = inf;
dist[nil] = inf;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u != nil)
for (int v : g[u])
if (dist[match[v]] == inf) {
dist[match[v]] = dist[u] + 1;
q.push(match[v]);
}
}
return (dist[nil] != inf);
}
bool dfs(int u) {
if (u == nil) return true;
for (int v : g[u])
if (dist[match[v]] == dist[u] + 1 and dfs(match[v])) {
match[v] = u, match[u] = v;
return true;
}
dist[u] = inf;
return false;
}
public:
vector<int> match;
int nil, isPerfect, matchSize = 0;
Hopcroft(vector<vector<int>> &gg, vector<int> &UU) {
g = gg;
U = UU;
nil = g.size();
match.assign(g.size() + 1, nil);
dist.assign(g.size() + 1, inf);
while (bfs())
for (int u : U)
if (match[u] == nil and dfs(u)) matchSize++;
isPerfect = (matchSize == U.size() and g.size() == U.size() * 2);
}
};
int G[610][610];
const int inf = 1e8;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int v, e, n, k;
cin >> v >> e >> n >> k;
for (int i = 0; i < v; ++i) {
for (int j = 0; j < v; ++j) {
G[i][j] = i == j ? 0 : inf;
}
}
vector<int> C(n);
for (int l = 0; l < n; ++l) cin >> C[l], C[l]--;
for (int i = 0; i < e; ++i) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
G[u][v] = min(G[u][v], w);
G[v][u] = min(G[v][u], w);
}
for (int k = 0; k < v; ++k) {
for (int i = 0; i < v; ++i) {
for (int j = 0; j < v; ++j) {
G[i][j] = min(G[i][j], G[i][k] + G[k][j]);
}
}
}
int L = 0, R = 1731311, ans = -1;
while (L <= R) {
int M = (L + R) / 2;
vector<vector<int>> g(n + v);
vector<int> u(n);
for (int i = 0; i < n; i++) u[i] = i;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < v; ++j) {
if (G[C[i]][j] <= M) {
g[i].push_back(j + n);
g[j + n].push_back(i);
}
}
}
Hopcroft hopcroft(g, u);
int flow = hopcroft.matchSize;
if (flow >= k) {
ans = M;
R = M - 1;
} else
L = M + 1;
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> adj;
vector<int> dis, mark, cover;
int ans = 0;
void dfs(int u, int p = 0) {
dis[u] = dis[p] + 1;
int m = 0, c = 0;
for (auto &v : adj[u])
if (v != p) {
dfs(v, u);
m += mark[v];
c += cover[v];
}
if (m > 0) cover[u] = 1;
if ((adj[u].size() > 1) && (c != adj[u].size() - 1)) {
mark[u] = cover[u] = 1;
ans += 1;
}
if (dis[u] <= 1 && mark[u] == 1) {
ans -= 1;
}
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
adj.resize(n + 1);
dis.resize(n + 1);
mark.resize(n + 1);
cover.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dis[0] = -1;
dfs(1, 0);
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long t, m, n, i, j, k;
int main() {
ios::sync_with_stdio(0);
cin >> t;
while (t--) {
cin >> n;
if ((n / 2) & 1)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 1; i <= n / 2; i++) {
cout << i * 2 << " ";
}
for (int i = 1; i < n / 2; i++) {
cout << 1 + 2 * (i - 1) << " ";
}
cout << 2 * (n / 2) + (n / 2 - 1) << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
string s;
cin >> s;
long long bob = 0;
long long answer1 = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'B') bob = bob + a[i];
}
answer1 = bob;
long long x = bob;
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
bob = bob + a[i];
else
bob = bob - a[i];
answer1 = max(answer1, bob);
}
bob = x;
for (int i = n - 1; i >= 0; i--) {
{
if (s[i] == 'A')
bob = bob + a[i];
else
bob = bob - a[i];
answer1 = max(answer1, bob);
}
}
cout << answer1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void CIN(T &a) {
cin >> a;
}
template <class T>
void CIN(T &a, T &b) {
cin >> a >> b;
}
template <class T>
void CIN(T &a, T &b, T &c) {
cin >> a >> b >> c;
}
template <class T>
void CIN(T &a, T &b, T &c, T &d) {
cin >> a >> b >> c >> d;
}
template <class T>
void PI(T a) {
cout << a << endl;
}
template <class T>
void PI(T a, T b) {
cout << a << " " << b << endl;
}
template <class T>
void PIS(T a) {
cout << a << " ";
}
template <class T>
T abs(T a) {
return a < 0 ? -a : a;
}
const int inf = 0x7fffffff;
int n, nxt[300010][26];
char s[300010];
bool v[26];
long long ans[27];
int main() {
cin >> s;
n = strlen(s);
int i, j;
for (i = 0; i < (int)(26); ++i) nxt[n][i] = n;
for (i = n - 1; i >= 0; --i) {
for (j = 0; j < (int)(26); ++j) nxt[i][j] = nxt[i + 1][j];
if (i != n - 1) nxt[i][s[i + 1] - 'a'] = i + 1;
}
for (i = 0; i < (int)(n); ++i) {
memset(v, 0, sizeof(v));
v[s[i] - 'a'] = 1;
int k = i, d = 1;
while (k < n) {
int minn = n, tmp;
for (j = 0; j < (int)(26); ++j)
if (!v[j] && nxt[k][j] < minn) {
minn = nxt[k][j];
tmp = j;
}
v[tmp] = 1;
ans[d++] += minn - k;
k = minn;
}
}
memset(v, 0, sizeof(v));
for (i = 0; i < (int)(n); ++i) v[s[i] - 'a'] = 1;
int tot = 0;
for (i = 0; i < (int)(26); ++i) tot += v[i];
PI(tot);
for (i = 1; i <= (int)(tot); ++i) PI(ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
long long int n, m;
vector<long long int> adj[1];
bool visited[1];
long long int start[1];
long long int end[1];
long long int parent[1];
long long int level[1];
vector<long long int> dfs_order;
void dfs(long long int node) {
visited[node] = true;
for (long long int next : adj[node]) {
if (!visited[next]) {
parent[next] = node;
level[next] = level[node] + 1;
dfs(next);
}
}
}
long long int dist[1];
void bfs(long long int start) {
memset(dist, -1, sizeof dist);
queue<long long int> q;
dist[start] = 0;
q.push(start);
while (!q.empty()) {
long long int v = q.front();
q.pop();
for (long long int e : adj[v]) {
if (dist[e] == -1) {
dist[e] = dist[v] + 1;
q.push(e);
}
}
}
}
long long int lift(long long int a, long long int dist,
vector<vector<long long int>> &up) {
for (long long int i = 0; i < 20; i++) {
if (dist & (1 << i)) {
a = up[a][i];
}
}
return a;
}
void preprocesslift(vector<vector<long long int>> &up) {
for (long long int j = 1; j < 20; j++) {
for (long long int i = 1; i <= n; i++) {
if (up[i][j - 1] != -1) {
up[i][j] = up[up[i][j - 1]][j - 1];
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t > 0) {
long long int x;
cin >> n;
multiset<long long int> s;
long long int mn = numeric_limits<long long int>::max();
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
mn = min(mn, x);
s.insert(x);
}
long long int temp = 0;
while (s.size() > 1) {
long long int x = *s.begin() + temp;
mn = max(mn, *s.begin() + temp);
temp += -x;
s.erase(s.begin());
}
mn = max(mn, *s.begin() + temp);
cout << mn << "\n";
t--;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long maxn = -1e9;
long long minn = 1e15;
long long mod = 1e9 + 7;
const int maxx = 1e6 + 5;
const int base = 311;
long long isp[maxx];
long long a[maxx];
void sieve() {
for (int i = 1; i <= 1e6; i++) isp[i] = 1;
isp[1] = 0;
for (int i = 2; i * i <= 1e6; i++) {
if (isp[i] == 1) {
for (int j = i * i; j <= 1e6; j += i) {
isp[j] = 0;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
sieve();
long long ans = 1e9;
for (int i = 2; i * i <= n; i++) {
if ((n % i) == 0) {
long long x = i, y = n / i;
if (isp[x] == 1) {
for (int j = n - x + 1; j <= n; j++) {
for (int k = 2; k * k <= j; k++) {
if ((j % k) == 0) {
long long g = k, h = j / k;
if (isp[g] == 1) ans = min(ans, j - g + 1);
if (isp[h] == 1) ans = min(ans, j - h + 1);
}
}
}
}
if (isp[y] == 1) {
for (int j = n - y + 1; j <= n; j++) {
for (int k = 2; k * k <= j; k++) {
if ((j % k) == 0) {
long long g = k, h = j / k;
if (isp[g] == 1) ans = min(ans, j - g + 1);
if (isp[h] == 1) ans = min(ans, j - h + 1);
}
}
}
}
}
}
cout << ans << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void write(T x) {
int i = 20;
char buf[21];
buf[20] = '\n';
do {
buf[--i] = x % 10 + '0';
x /= 10;
} while (x);
do {
putchar(buf[i]);
} while (buf[i++] != '\n');
}
template <typename T>
inline T readInt() {
T n = 0, s = 1;
char p = getchar();
if (p == '-') s = -1;
while ((p < '0' || p > '9') && p != EOF && p != '-') p = getchar();
if (p == '-') s = -1, p = getchar();
while (p >= '0' && p <= '9') {
n = (n << 3) + (n << 1) + (p - '0');
p = getchar();
}
return n * s;
}
long long prevst, ans, cur, lastf;
int main() {
string s;
cin >> s;
long long len = s.size(), i;
for (i = 0; i < len; i++)
if (s[i] == 'F') {
prevst = 0;
ans = i;
lastf = i;
cur++;
i++;
break;
}
for (; i < len; i++) {
if (s[i] == 'F') {
long long t = i - lastf - 1;
if (i - t == cur) {
ans = t;
cur++;
lastf = i;
prevst = 0;
continue;
} else {
if (t <= prevst) {
ans = prevst + 1 + lastf + 1 - cur;
prevst = ans - (i - cur);
lastf = i;
cur++;
} else {
prevst = 0;
lastf = i;
ans = i - cur;
cur++;
}
}
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
const double PI = 2 * acos(0.0);
const double eps = 1e-9;
const int infi = 1e9;
const long long Linfi = (long long)1e18;
const long long MOD = 1000000007;
int n, m, u, v;
int val[100005], parent[100005], xet[100005];
vector<int> adj[100005];
vector<pair<int, int> > node;
int findset(int i) {
if (parent[i] < 0) return i;
parent[i] = findset(parent[i]);
return parent[i];
}
void Union(int x, int y) {
int u, v;
u = findset(x);
v = findset(y);
if (x == y) return;
if (parent[u] < parent[v]) {
parent[u] += parent[v];
parent[v] = u;
} else {
parent[v] += parent[u];
parent[u] = v;
}
}
void solve() {
for (int i = 1; i <= n; i++) parent[i] = -1;
for (int i = 1; i <= n; i++) xet[i] = 0;
sort(node.begin(), node.end(), greater<pair<int, int> >());
long long total = 0;
for (int i = 0; i < node.size(); i++) {
u = node[i].second;
int sum = 0;
long long cntG = 0;
for (int j = 0; j < adj[u].size(); j++) {
v = adj[u][j];
if (xet[v] == 0) continue;
int r1 = findset(u), r2 = findset(v);
if (r1 == r2) continue;
cntG += 1LL * sum * (-parent[r2]);
if (xet[v] == 1) sum -= parent[r2];
Union(r1, r2);
}
xet[u] = 1;
total += 1LL * val[u] * (cntG + sum);
}
double ans = 2.0 * total / n / (n - 1);
printf("%.4lf\n", ans);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
node.push_back(pair<int, int>(val[i], i));
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> get(int d, int l) {
int x = min(abs(d) + 1, l);
if (d < 0)
return {1, x};
else
return {x, 1};
}
int main() {
int n, d, l;
cin >> n >> d >> l;
int element = 0;
if (n % 2) {
if (d > 0) {
element = min(d, l);
d -= element;
} else {
element = 1;
d--;
}
}
deque<int> dq;
if (element) n--;
for (int i = 0; i < n; ++ ++i) {
pair<int, int> x = get(d, l);
d -= (x.first - x.second);
dq.push_back(x.first);
dq.push_back(x.second);
}
if (element) dq.push_back(element);
if (d) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < dq.size(); i++) cout << dq[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
const ld PI = 4 * atanl(1);
const ld EPS = 1e-12;
const int MN = 1e5 + 10;
struct vec {
public:
int x, y;
void in() { scanf("%d%d", &x, &y); }
ld mag() const { return hypotl(x, y); }
ld ang() const { return atan2l(y, x); }
};
struct Evt {
public:
ld t;
int v;
Evt(ld _t = 0, int _v = 0) : t(_t), v(_v) {}
bool operator<(const Evt& o) const { return t < o.t; }
};
struct BIT {
public:
int a[MN * 2], L;
void reset(int _L) {
memset(a, 0, L * sizeof *a);
L = _L;
}
void upd(int n, int v) {
for (++n; n <= L; n += -n & n) a[n - 1] += v;
}
int qry(int n) {
int f = 0;
for (; n; n -= -n & n) f += a[n - 1];
return f;
}
int qry(int l, int r) { return qry(r) - qry(l); }
};
int N, p[MN];
ll K;
vec a[MN];
std::vector<Evt> evt;
BIT bit;
ll count(ld d) {
ll f = (ll)N * (N - 1) / 2;
int ctr = 0;
for (int i = 0; i < N; ++i)
if (d < a[i].mag()) {
ld m = a[i].ang();
ld dif = acosl(d / a[i].mag());
ld s = m - dif, e = m + dif;
if (s + EPS < 0) s += 2 * PI, e += 2 * PI;
if (2 * PI < e + EPS) e -= 2 * PI;
if (e < s) std::swap(s, e);
evt.push_back({s, ctr});
evt.push_back({e, ctr});
ctr++;
}
std::sort(evt.begin(), evt.end());
memset(p, -1, ctr * sizeof *p);
bit.reset(ctr * 2);
for (int i = 0; i < evt.size(); ++i) {
int v = evt[i].v;
if (~p[v])
bit.upd(p[v], -1), f -= bit.qry(p[v] + 1, i);
else
p[v] = i, bit.upd(i, 1);
}
evt.clear();
return f;
}
int main() {
scanf("%d%lld", &N, &K);
for (int i = 0; i < N; ++i) a[i].in();
ld l = -logl(1e8), r = logl(2e4), m;
for (int i = 0; i < 100; ++i) {
ld m = (r + l) / 2;
if (count(exp(m)) < K)
l = m;
else
r = m;
}
printf("%.9lf\n", (double)exp(r));
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010, SQ = 550;
int n, m, q, k, u, v, x, y, t, a, b;
long long A[MAXN];
int B[SQ][MAXN];
int id[MAXN], ts;
long long ans[MAXN], lazy[MAXN];
bool big[MAXN], mark[MAXN];
vector<int> S[MAXN], vec;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 1; i <= m; i++) {
cin >> k;
S[i].resize(k);
for (int j = 0; j < k; j++) cin >> S[i][j];
big[i] = (k > SQ);
if (!big[i]) continue;
vec.push_back(i);
id[i] = ++ts;
for (int j : S[i]) ans[i] += A[j];
}
for (int i : vec) {
for (int j : S[i]) mark[j] = 1;
for (int j = 1; j <= m; j++)
for (int k : S[j]) B[id[i]][j] += mark[k];
for (int j : S[i]) mark[j] = 0;
}
while (q--) {
char ch;
cin >> ch >> k;
if (ch == '?') {
if (big[k])
cout << ans[k] << '\n';
else {
long long res = 0;
for (int j : S[k]) res += A[j];
for (int j : vec) res += lazy[j] * B[id[j]][k];
cout << res << '\n';
}
continue;
}
cin >> x;
if (big[k])
lazy[k] += x;
else {
for (int j : S[k]) A[j] += x;
}
for (int j : vec) ans[j] += 1ll * B[id[j]][k] * x;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long int myRand(long long int B) { return (long long unsigned)rng() % B; }
const int N = 1500;
int _a[N][N];
void init(int n, int m) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &_a[i][j]);
}
int _cnt = 0;
int force_ask(int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
int ans;
scanf("%d", &ans);
return ans;
}
map<pair<int, int>, int> mem;
int ask(int x, int y) {
if (mem.count(make_pair(x, y)) == 0) mem[make_pair(x, y)] = force_ask(x, y);
return mem[make_pair(x, y)];
}
vector<int> reduce(vector<int> rows, vector<int> cols) {
vector<int> ans;
42;
int i = 0;
for (int c : cols) {
42;
if (ans.empty()) {
ans.push_back(c);
continue;
}
while (!ans.empty() && ask(rows[i], ans.back()) > ask(rows[i], c)) {
ans.pop_back();
i--;
}
if (ans.size() == rows.size())
continue;
else {
ans.push_back(c);
i++;
}
}
42;
return ans;
}
vector<int> solve(vector<int> rows, vector<int> cols) {
if ((int)cols.size() > (int)rows.size()) cols = reduce(rows, cols);
int n = (int)rows.size();
int m = (int)cols.size();
vector<int> nrows;
for (int i = 1; i < n; i += 2) nrows.push_back(rows[i]);
vector<int> nans;
if (!nrows.empty()) nans = solve(nrows, cols);
vector<int> ans;
int ptr = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 1) {
ans.push_back(nans[i / 2]);
continue;
}
int nptr = m - 1;
if (i + 1 < n) {
nptr = ptr;
while (cols[nptr] < nans[i / 2]) nptr++;
}
int bst = ptr;
for (int j = ptr; j <= nptr; j++)
if (ask(rows[i], cols[j]) < ask(rows[i], cols[bst])) bst = j;
ans.push_back(cols[bst]);
ptr = nptr;
}
return ans;
}
int main(int, char **) {
int n, m;
scanf("%d%d", &n, &m);
vector<int> rows, cols;
for (int i = 1; i <= n; i++) rows.push_back(i);
for (int i = 1; i <= m; i++) cols.push_back(i);
vector<int> mins = solve(rows, cols);
int bst = 0;
for (int i = 0; i < n; i++)
if (ask(rows[i], mins[i]) < ask(rows[bst], mins[bst])) bst = i;
42;
printf("! %d\n", ask(rows[bst], mins[bst]));
fflush(stdout);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse2")
using namespace std;
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
long long int Modular_Exponentiation(long long int x, long long int n,
long long int M) {
if (n == 0) return 1;
if (n % 2)
return (x * Modular_Exponentiation((x * x) % M, n / 2, M)) % M;
else
return (Modular_Exponentiation((x * x) % M, n / 2, M)) % M;
}
void solve() {
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i < n; ++i) cin >> arr[i];
if (n < 10) {
cout << "0 0 0\n";
return;
}
long long int i = 0;
while (i < (n / 2) and arr[i] == arr[0]) i++;
long long int g = i;
if (g > (n - 4) / 6) {
cout << "0 0 0\n";
return;
}
long long int j = 2 * i;
while (j < (n / 2) and arr[j] == arr[2 * i]) j++;
long long int second = (j - i);
long long int b = 0;
long long int k = (n / 2) - 1;
if (arr[k] == arr[k + 1]) {
i = k;
while (i >= j and arr[i] == arr[k]) i--;
b = (i - j + 1);
} else
b = (n / 2 - j);
if (b <= g) {
cout << "0 0 0\n";
return;
}
cout << g << " " << second << " " << b << "\n";
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
while (T--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int mod[2] = {998244353, 7340033}, primitive[2] = {15311432, 2187},
offset[2] = {23, 20};
template <int which>
int lgput(int x, int y, int r = 1) {
while (y) {
if (y % 2) r = ((ll)r * x) % mod[which];
x = ((ll)x * x) % mod[which];
y /= 2;
}
return r;
}
template <int which>
void ntt(vector<int>& v, bool inv = false) {
assert(__builtin_popcount(v.size()) == 1);
const int n = v.size(), lg = __builtin_ctz(n);
for (int i = 1, ir = (1 << (lg - 1)); i < n - 1; ++i) {
if (i < ir) swap(v[i], v[ir]);
int j = (1 << (lg - 1));
while (ir & j) {
ir ^= j;
j /= 2;
}
ir ^= j;
}
static vector<int> w;
w.resize(n);
for (int len = 2; len <= n; len *= 2) {
int w0 = (inv ? lgput<which>(primitive[which], (1 << offset[which]) / len)
: lgput<which>(lgput<which>(primitive[which], mod[which] - 2),
(1 << offset[which]) / len));
w[0] = 1;
for (int i = 1; i < len; ++i) w[i] = ((ll)w[i - 1] * w0) % mod[which];
for (int st = 0; st < n; st += len) {
for (int i = 0; i < len / 2; ++i) {
int tmp = ((ll)w[i] * v[st + i + len / 2]) % mod[which];
v[st + i + len / 2] = v[st + i] - tmp;
if (v[st + i + len / 2] < 0) v[st + i + len / 2] += mod[which];
v[st + i] = v[st + i] + tmp;
if (v[st + i] >= mod[which]) v[st + i] -= mod[which];
}
}
}
int tmp = lgput<which>(n, mod[which] - 2);
if (inv)
for (auto& x : v) x = ((ll)x * tmp) % mod[which];
}
template <int which>
vector<int> inner_convolute(vector<int> a, vector<int> b) {
while (__builtin_popcount(a.size()) != 1) a.push_back(0);
while (__builtin_popcount(b.size()) != 1) b.push_back(0);
a.resize(2 * a.size(), 0);
b.resize(2 * b.size(), 0);
ntt<which>(a);
ntt<which>(b);
for (int i = 0; i < (int)a.size(); ++i) a[i] = ((ll)a[i] * b[i]) % mod[which];
ntt<which>(a, true);
return a;
}
constexpr long long m = (long long)mod[0] * mod[1];
long long add(long long x, ll y) {
if (x + y >= m) return x + y - m;
return x + y;
}
ll times(ll x, ll y) {
ll r = 0;
while (y) {
if (y % 2) r = add(r, x);
x = add(x, x);
y /= 2;
}
return r;
}
vector<long long> convolute(vector<int> a, vector<int> b) {
auto p = inner_convolute<0>(a, b);
auto q = inner_convolute<1>(a, b);
vector<long long> ret(max(p.size(), q.size()));
for (int i = 0; i < p.size() || i < q.size(); ++i) {
int vp = (i < p.size() ? p[i] : 0), vq = (i < q.size() ? q[i] : 0);
const ll m2 = 96127235, m1 = m - 706818;
ret[i] = (times(vp, (ll)mod[1] * m2) + times(vq, times(mod[0], m1))) % m;
}
return ret;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> cnt(n + 1, 0);
cnt[0] = 1;
int cur_cnt = 0;
for (int i = 1, x; i <= n; ++i) {
cin >> x;
cur_cnt += (x < k ? 1 : 0);
++cnt[cur_cnt];
}
vector<int> revcnt = cnt;
reverse(begin(revcnt), end(revcnt));
auto ret = convolute(cnt, revcnt);
long long ret0 = 0;
for (int i = 0; i < cnt.size(); ++i)
ret0 += ((long long)cnt[i] * cnt[i] - cnt[i]) / 2;
cout << ret0 << ' ';
for (int i = n + 1; i < 2 * n + 1; ++i) cout << ret[i] << ' ';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 1;
int n, m, k, ans;
int du[MAX], X[MAX], Y[MAX], Ans[MAX];
vector<int> ve[MAX];
bool use[MAX];
void work(int x) {
queue<int> qu;
qu.push(x), use[x] = 1, --ans;
while (!qu.empty()) {
int tt = qu.front();
qu.pop();
for (int i = 0; i < ve[tt].size(); ++i) {
int y = ve[tt][i];
if (use[y]) continue;
--du[y];
if (du[y] < k) --ans, use[y] = 1, qu.push(y);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
ans = n;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &X[i], &Y[i]);
++du[X[i]], ++du[Y[i]], ve[X[i]].push_back(Y[i]), ve[Y[i]].push_back(X[i]);
}
for (int i = 1; i <= n; ++i)
if (du[i] < k && !use[i]) work(i);
Ans[m] = ans;
for (int i = m; i >= 1; --i) {
if (!use[Y[i]]) --du[X[i]];
if (!use[X[i]]) --du[Y[i]];
ve[X[i]].pop_back(), ve[Y[i]].pop_back();
if (du[X[i]] < k && !use[X[i]]) work(X[i]);
if (du[Y[i]] < k && !use[Y[i]]) work(Y[i]);
Ans[i - 1] = ans;
}
for (int i = 1; i <= m; ++i) printf("%d\n", Ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool flag[26];
int n, k;
string s;
bool allVisited() {
for (int i = 0; i < k; i++)
if (!flag[i]) return false;
return true;
}
int main() {
cin >> k >> s;
n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] != '?') {
if (s[n - i - 1] == '?')
s[n - i - 1] = s[i];
else if (s[n - i - 1] != s[i]) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
}
}
for (int i = 0; i < n; i++) {
if (s[i] >= 'a' && s[i] <= 'z') flag[s[i] - 'a'] = true;
}
int c = k - 1;
for (int i = n / 2; i >= 0; i--) {
if (s[i] == '?') {
while (flag[c] && c >= 0) c--;
if (c >= 0) {
s[i] = s[n - 1 - i] = 'a' + c;
flag[c] = true;
}
if (c < 0) s[i] = s[n - 1 - i] = 'a';
}
}
if (allVisited())
cout << s << endl;
else
cout << "IMPOSSIBLE" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int k = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) k = k * 10 + c - '0';
return k * f;
}
const int N = 105;
bitset<150> st[5000];
map<int, int> mp;
int n, m, tot, a[N], b[N], v[N][N];
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) a[i] = read() * 2;
for (int i = 1; i <= m; i++) b[i] = read() * 2;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int k = (a[i] + b[j]) / 2;
if (mp[k])
v[i][j] = mp[k];
else
mp[k] = ++tot, v[i][j] = tot;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
st[v[i][j]].set(i), st[v[i][j]].set(j + n);
}
int ans = 0;
for (int i = 1; i <= tot; i++)
for (int j = i; j <= tot; j++) {
int x = (st[i] | st[j]).count();
ans = max(ans, x);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (int)500 + 5;
const int inf = (int)1e9;
const double EPS = 1e-9;
const long long mod = 1000000007ll;
int nCr[1015][1015];
int seg[1015];
int x[1015];
long long pow2[1015];
int main() {
cin.sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < 1015; ++i)
for (int j = 0; j < 1015; ++j)
nCr[i][j] =
(j == 0) ? 1
: ((i == 0) ? 0 : (nCr[i - 1][j - 1] + nCr[i - 1][j])) % mod;
pow2[0] = pow2[1] = 1;
for (int i = 2; i < 1015; i++) pow2[i] = (pow2[i - 1] * 2) % mod;
for (int i = 0; i < m; i++) cin >> x[i];
sort(x, x + m);
long long ret = 1;
int cur_seg = 0;
seg[cur_seg++] = x[0] - 1;
for (int i = 1; i < m; i++) seg[cur_seg++] = x[i] - x[i - 1] - 1;
seg[cur_seg++] = n - x[m - 1];
for (int i = 1; i < cur_seg - 1; i++) {
ret = (ret * pow2[seg[i]]) % mod;
}
int sum = seg[0];
for (int i = 1; i < cur_seg; i++) {
sum += seg[i];
ret = (ret * nCr[sum][seg[i]]) % mod;
}
cout << ret;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, s, i, c = 0, deg[1000009] = {0};
cin >> n >> s;
for (i = 0; i < n - 1; i++) {
long long int a, b;
cin >> a >> b;
deg[a]++;
deg[b]++;
}
for (i = 0; i < 1000009; i++) {
if (deg[i] == 1) c++;
}
double ans = (2.0 * s) / c;
cout.precision(18);
cout << fixed << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
void solve() {
long long n;
cin >> n;
;
long long k;
cin >> k;
;
vector<long long> arr(n);
for (long long i = 0; i < (long long)n; i++) {
cin >> arr[i];
};
vector<vector<long long> > rem(10);
long long points = 0;
for (long long i = 0; i < (long long)n; i++) {
if (arr[i] != 100) rem[arr[i] % 10].push_back(arr[i]);
points += (arr[i] / 10);
}
long long i = 9;
while (i >= 1 and k > 0) {
long long m = ((long long)rem[i].size()), j = 0, t = (10 - i);
while (j < m and k - t >= 0) {
k -= t;
points++;
rem[i][j] += t;
if (rem[i][j] != 100) rem[0].push_back(rem[i][j]);
j++;
}
i--;
}
long long req = 0;
for (long long i = 0; i < (long long)((long long)rem[0].size()); i++) {
req += (100 - rem[0][i]) / 10;
}
points += min(req, k / 10);
cout << points;
cout << '\n';
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[100100];
int main() {
string s;
cin >> s;
int k = s.length(), i, c = 0, ans;
int u = -1, l = k;
int uppercase = 0, lowercase = 0;
for (i = 0; i < k; i++) {
if (s[i] >= 65 && s[i] <= 90) {
u = i;
uppercase++;
} else if (s[i] >= 97 && s[i] <= 122) {
if (c < 1) {
l = i;
c++;
}
lowercase++;
}
}
int t1 = 0;
int t2 = 0;
for (i = 0; i < u; i++) {
if (s[i] >= 97 && s[i] <= 122) t1++;
}
for (i = l + 1; i < k; i++) {
if (s[i] >= 65 && s[i] <= 90) t2++;
}
int temp1 = uppercase, temp2 = lowercase, x;
dp[0] = min(t1, t2);
for (i = 1; i < k; i++) {
if (s[i - 1] >= 65 && s[i - 1] <= 90) {
uppercase--;
} else if (s[i - 1] >= 97 && s[i - 1] <= 122)
lowercase--;
dp[i] = min(temp2 - lowercase + uppercase, dp[i - 1]);
}
printf("%d", dp[k - 1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
T ext_gcd(T a, T b, T& first, T& second) {
if (b == 0) {
first = 1, second = 0;
return a;
}
T d = ext_gcd(b, a % b, second, first);
second -= first * (a / b);
return d;
}
template <typename T>
T inverse(T a, T n) {
T first, second;
T t = ext_gcd(a, n, first, second);
if (t != 1) return -1;
return (first % n + n) % n;
}
template <typename T>
T Q_mul(T a, T b, T Mod) {
T ret;
for (ret = 0; b; b >>= 1, a = (a + a) % Mod)
if (b & 1) ret = (ret + a) % Mod;
return ret;
}
template <typename T>
T quick_pow_mod(T a, T b, T Mod) {
T ret;
for (ret = 1; b; b >>= 1, (a *= a) %= Mod)
if (b & 1) (ret *= a) %= Mod;
return ret;
}
template <typename T>
T quick_pow(T a, T b) {
T ret;
for (ret = 1; b; b >>= 1, a *= a)
if (b & 1) ret *= a;
return ret;
}
double combination(int n, int r) {
if (r < n - r) return combination(n, n - r);
double s = 1.0;
for (int i = 1; i <= int(n - r); ++i) s *= (r + i), s /= i;
return s;
}
template <typename T>
inline void read(T& v) {
T ret = 0, sgnv = 1;
char p;
while (!isdigit(p = getchar()))
if (p == '-') sgnv = -1;
do ret = (ret << 3) + (ret << 1) + p - '0';
while (isdigit(p = getchar()));
v = sgnv * ret;
}
const int maxn = 1e5 + 5;
struct Edge {
int v, w, next;
} edge[2 * maxn];
int head[maxn], sz[maxn], dp[maxn], tree[maxn], n, l, w, cnt, tot;
bool vis[maxn];
pair<pair<int, int>, int> p[maxn];
long long ans;
inline int lowbit(int first) { return first & -first; }
void init() { memset(tree + 1, 0, sizeof(int) * n); }
void update(int first, int d) {
for (int i = first; i <= n; i += lowbit(i)) tree[i] += d;
}
int query(int first) {
int s = 0;
for (int i = first; i; i -= lowbit(i)) s += tree[i];
return s;
}
inline void addedge(int u, int v, int w) {
edge[cnt].v = v, edge[cnt].w = w, edge[cnt].next = head[u], head[u] = cnt++;
}
int getroot(int u, int fa, int n) {
int v, root = -1, tmp;
dp[u] = 0, sz[u] = 1;
for (int i = head[u]; ~i; i = edge[i].next) {
if ((v = edge[i].v) == fa || vis[v]) continue;
tmp = getroot(v, u, n), sz[u] += sz[v], dp[u] = max(dp[u], sz[v]);
if (root == -1 || dp[tmp] < dp[root]) root = tmp;
}
dp[u] = max(dp[u], n - sz[u]);
if (root == -1 || dp[u] < dp[root]) root = u;
return root;
}
void dfs(int u, int fa, int first, int second) {
++first, p[tot++] = make_pair(make_pair(w - second, l - first), 1);
for (int i = head[u]; ~i; i = edge[i].next)
if (edge[i].v != fa && !vis[edge[i].v])
dfs(edge[i].v, u, first, second + edge[i].w);
}
void daq(int u) {
int v;
vis[u] = true, p[tot++] = make_pair(make_pair(0, 1), 0);
for (int i = head[u]; ~i; i = edge[i].next)
if (!vis[v = edge[i].v]) {
dfs(v, u, 1, edge[i].w);
sort(p, p + tot);
for (int j = 0; j < int(tot); ++j) {
if (p[j].second) {
if (p[j].first.second > 0) ans += query(p[j].first.second);
p[j].second = 2, p[j].first.first = w - p[j].first.first,
p[j].first.second = l - p[j].first.second;
} else
update(p[j].first.second, 1);
}
for (int j = 0; j < int(tot); ++j) {
if (p[j].second == 0)
update(p[j].first.second, -1);
else if (p[j].second == 2)
p[j].second = 0;
}
}
tot = 0;
for (int i = head[u]; ~i; i = edge[i].next)
if (!vis[v = edge[i].v]) daq(getroot(v, u, sz[v]));
}
int main() {
int u, v;
read(n), read(l), read(w), l += 2, memset(head + 1, -1, sizeof(int) * n);
for (int i = 1; i <= int(n - 1); ++i)
read(u), read(v), addedge(u, i + 1, v), addedge(i + 1, u, v);
daq(getroot(1, 0, n)), printf("%I64d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101010;
int n, k;
int f[N][2];
vector<pair<int, int> > G[N];
void dfs(int u, int pre) {
vector<pair<int, int> > a;
for (auto v : G[u])
if (v.first != pre) {
dfs(v.first, u);
a.push_back(
make_pair(-v.second - f[v.first][0], -v.second - f[v.first][1]));
}
f[u][0] = f[u][1] = 0;
sort(a.begin(), a.end());
for (int i = min((int)a.size(), k - 1) - 1; i >= 0; --i) {
f[u][0] -= a[i].first;
}
int to = min((int)a.size(), k);
int sum = 0;
for (int i = (0); i < (to); i++) sum -= a[i].first;
for (int i = (0); i < ((int)a.size()); i++) {
int t = sum - a[i].second;
if (i < to) {
t += a[i].first;
} else {
t += a[to - 1].first;
}
f[u][1] = max(f[u][1], t);
}
}
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = (0); i < (n + 1); i++) G[i].clear();
for (int i = (1); i < (n); i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u].push_back(make_pair(v, w));
G[v].push_back(make_pair(u, w));
}
dfs(0, 0);
printf("%d\n", max(f[0][0], f[0][1]));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int const lim = 35;
int inp[lim + 3];
bool vis[40][330][330][2][2][6];
bool done[330][330];
int n;
long long ans = 0;
void dfs(int lev, int i, int j, int xx, int yy, int add) {
if (lev == n) return;
if (vis[lev][i][j][xx + 1][yy + 1][add]) return;
vis[lev][i][j][xx + 1][yy + 1][add] = true;
if (!done[i][j]) ans++;
done[i][j] = true;
if (add) return dfs(lev, i + xx, j + yy, xx, yy, add - 1);
if (!xx) {
dfs(lev + 1, i + 1, j + yy, 1, yy, inp[lev + 1] - 1);
dfs(lev + 1, i - 1, j + yy, -1, yy, inp[lev + 1] - 1);
return;
} else if (!yy) {
dfs(lev + 1, i + xx, j + 1, xx, 1, inp[lev + 1] - 1);
dfs(lev + 1, i + xx, j - 1, xx, -1, inp[lev + 1] - 1);
return;
} else {
dfs(lev + 1, i + xx, j, xx, 0, inp[lev + 1] - 1);
dfs(lev + 1, i, j + yy, 0, yy, inp[lev + 1] - 1);
return;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &inp[i]);
}
dfs(0, 155, 155, 0, 1, inp[0] - 1);
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, m, i;
scanf("%d%d", &n, &m);
m %= (n * (n + 1) / 2);
for (i = 1; i <= m; i++) m -= i;
printf("%d\n", m);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define sz(x) ((int)(x).size())
#define MULTIPLE_CASES
const ll MOD = 1e9+7;
void solve()
{
int n, m;
cin >> n >> m;
int cnt = 0;
ll ans = 1;
for(int i = 0; i < n; ++i)
{
string s;
cin >> s;
for(char c : s)
{
if(c == '#')
{
cnt++;
ans = (ans * 2) % MOD;
}
}
}
if(cnt == n*m) ans = (ans - 1 + MOD) % MOD;
cout << ans << "\n";
}
int main()
{
cin.tie(0);
ios_base::sync_with_stdio(false);
#ifdef MULTIPLE_CASES
int t;
cin >> t;
for(int i = 0; i < t; ++i)
{
solve();
}
#else
solve();
#endif
} | 7 |
#include <bits/stdc++.h>
using namespace std;
int a[200010];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
vector<int> x, y;
x.push_back(a[0]);
y.push_back(a[n - 1]);
int xx = 0, yy = n - 1;
for (int i = 1; i < n; ++i)
if (a[i] > a[i - 1])
x.push_back(a[i]);
else {
xx = i - 1;
break;
}
for (int i = n - 2; i >= 0; --i)
if (a[i] > a[i + 1])
y.push_back(a[i]);
else {
yy = i + 1;
break;
}
bool overlap = (xx == yy);
int i = 0, j = 0, lenx = x.size(), leny = y.size();
bool alice = true;
while (i < lenx && j < leny) {
if (x[i] == y[j]) {
if (((lenx - i) % 2 == 0) && ((leny - j) % 2 == 0)) alice = !alice;
break;
} else if (x[i] > y[j]) {
if ((lenx - i) % 2 == 1) break;
alice = !alice;
j++;
} else if (x[i] < y[j]) {
if ((leny - j) % 2 == 1) break;
alice = !alice;
i++;
}
}
if (i == lenx) {
int t = leny - j - overlap;
if (t % 2 == 0) alice = !alice;
} else if (j == leny) {
int t = lenx - i - overlap;
if (t % 2 == 0) alice = !alice;
}
cout << (alice ? "Alice" : "Bob") << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, h;
long long ans;
void kh(long long l, long long r, bool turn) {
if (l == r) return;
long long mid = (l + r) / 2;
if (!turn) {
if (n <= mid) {
ans++;
kh(l, mid, !turn);
} else {
long long x = (mid - l + 1);
while (x >= 1) {
ans += x;
x /= 2;
}
ans++;
kh(mid + 1, r, turn);
}
} else {
if (n > mid) {
ans++;
kh(mid + 1, r, !turn);
} else {
long long x = (mid - l) + 1;
while (x >= 1) {
ans += x;
x /= 2;
}
ans++;
kh(l, mid, turn);
}
}
}
int main() {
cin >> h >> n;
kh(1, powl(2, h), 0);
cout << ans << endl;
return 0;
}
| 4 |
using namespace std;
#include <iostream>
#include <cstring>
#define MAXN 305
int N,cnt[3][2];
char arr[MAXN][MAXN];
void solve() {
cin >> N;
int K = 0;
memset(cnt,0,sizeof(cnt));
for(int i = 0;i < N;++i) {
string str;
cin >> str;
for(int j = 0;j < N;++j) {
arr[i][j] = str[j];
if(arr[i][j] == 'X') {
K++;
cnt[(i + j) % 3][0]++;
}else if(arr[i][j] == 'O') {
K++;
cnt[(i + j) % 3][1]++;
}
}
}
for(int a = 0;a < 3;++a) {
for(int b = 0;b < 3;++b) {
if(a == b) continue;
if(cnt[a][0] + cnt[b][1] <= K / 3) {
for(int i = 0;i < N;++i) {
for(int j = 0;j < N;++j) {
if((i + j) % 3 == a && arr[i][j] != '.') {
arr[i][j] = 'O';
}else if((i + j) % 3 == b && arr[i][j] != '.') {
arr[i][j] = 'X';
}
cout << arr[i][j];
}
cout << endl;
}
return;
}
}
}
}
int main() {
int T;
cin >> T;
while(T--) solve();
} | 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 2000000 + 5;
inline int mul(int64_t a, int64_t b) { return static_cast<int>(a * b % MOD); }
inline int add(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
inline int sub(int a, int b) { return a - b < 0 ? a - b + MOD : a - b; }
int jie[N], inv_jie[N], inv[N];
inline int qPow(int a, int b) {
if (b < 0) {
a = inv[a];
b = -b;
}
int ret = 1;
while (b) {
if (b & 1) ret = mul(ret, a);
b >>= 1;
a = mul(a, a);
}
return ret;
}
inline int comb(int a, int b) {
return mul(jie[a], mul(inv_jie[b], inv_jie[a - b]));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
jie[0] = 1;
for (int i = 1; i < N; ++i) jie[i] = mul(jie[i - 1], i);
inv_jie[N - 1] = qPow(jie[N - 1], MOD - 2);
for (int i = N - 2; i >= 0; --i) inv_jie[i] = mul(inv_jie[i + 1], i + 1);
for (int i = 1; i < N; ++i) inv[i] = mul(inv_jie[i], jie[i - 1]);
int n, m, ans = 0;
cin >> n >> m;
for (int len = 1; len <= min(n - 1, m); ++len) {
int lay = m - len;
int make_equal = comb(lay + len - 1, lay);
int trees = mul(len + 1, qPow(n, n - len - 2));
int arbitrary_weight = qPow(m, n - len - 1);
int connect = mul(comb(n - 2, len - 1), jie[len - 1]);
ans = add(ans, mul(mul(make_equal, connect), mul(trees, arbitrary_weight)));
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int maxn = 100000 + 5;
double dp[maxn];
struct cake {
double v;
int id;
} c[maxn];
bool cmp(cake a, cake b) {
if (a.v < b.v)
return true;
else if (fabs(a.v - b.v) < 1e-6)
return a.id > b.id;
else
return false;
}
double cal(double r, double h) { return PI * r * r * h; }
double t[4 * maxn];
void modify(int pos, double val, int l, int r, int x) {
if (l == r && l == pos) {
t[x] = val;
return;
}
int m = (l + r) / 2;
if (pos <= m)
modify(pos, val, l, m, x << 1);
else
modify(pos, val, m + 1, r, x << 1 | 1);
t[x] = max(t[x << 1], t[x << 1 | 1]);
}
double query(int L, int R, int l, int r, int x) {
if (L == l && R == r) {
return t[x];
}
int m = l + (r - l) / 2;
if (R <= m)
return query(L, R, l, m, x << 1);
else if (L > m)
return query(L, R, m + 1, r, x << 1 | 1);
else
return max(query(L, m, l, m, x << 1),
query(m + 1, R, m + 1, r, x << 1 | 1));
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
double r, h;
scanf("%lf %lf", &r, &h);
c[i].v = cal(r, h);
c[i].id = i;
}
sort(c + 1, c + n + 1, cmp);
double ans = -1;
for (int i = 1; i <= n; i++) {
double last = query(1, c[i].id, 1, n, 1);
dp[c[i].id] = last + c[i].v;
if (dp[c[i].id] > ans) ans = dp[c[i].id];
modify(c[i].id, dp[c[i].id], 1, n, 1);
}
printf("%.9lf\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long D[500010];
long long head[500010];
long long n, k, d;
long long a[500010];
int main() {
cin >> n >> k >> d;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
if (a[k] - a[1] <= d) {
D[k] = 1;
head[k] = 1;
}
for (int end = k + 1; end <= n; end++) {
int start = end - k + 1;
if (a[end] - a[start] <= d && D[start - 1] == 1) {
D[end] = 1;
head[end] = start;
continue;
}
if (D[end - 1] == 1 && a[end] - a[head[end - 1]] <= d) {
D[end] = 1;
head[end] = head[end - 1];
}
}
if (D[n] == 1) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int n, m, c;
int inc, dec, a[1010], b[1010];
int work(int x, int *cnt, int *arr, short isInc) {
int head = 1, tail = *cnt, mid;
if (*cnt == 0 || (isInc && arr[*cnt] <= x) || (!isInc && arr[*cnt] >= x)) {
arr[++(*cnt)] = x;
return *cnt;
}
while (head < tail) {
mid = (head + tail) >> 1;
if ((isInc && arr[mid] > x) || (!isInc && arr[mid] < x))
tail = mid;
else
head = mid + 1;
}
arr[head] = x;
return head;
}
int main() {
int x;
memset(a, 60, sizeof(a));
scanf("%d%d%d", &n, &m, &c);
while (m--) {
scanf("%d", &x);
if (x <= c / 2)
printf("%d\n", work(x, &inc, a, 1));
else
printf("%d\n", n - work(x, &dec, b, 0) + 1);
fflush(stdout);
if (inc + dec >= n) break;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.14159265358979323;
const long long mx64 = 9223372036854775807;
const int mx32 = 2147483647;
const short int mx16 = 32767;
const long long mod_1 = 1000000007;
const long long mod_2 = 1000000009;
const long long mod_3 = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<int> pow2(32, 0);
pow2[1] = 1;
for (int i = 2; i <= 31; i++) {
pow2[i] = pow2[i - 1] * 2;
}
char ansjd;
string status;
cin >> status;
while (status == "start") {
int x, y, ind;
for (ind = 1; ind <= 31; ind++) {
x = pow2[ind - 1];
y = pow2[ind];
cout << "? " << x << " " << y << "\n";
cout.flush();
cin >> ansjd;
if (ansjd == 'x') {
break;
}
}
int l = x + 1;
int r = y;
int mid = (l + r) / 2;
while (l < r) {
cout << "? " << x << " " << mid << "\n";
cout.flush();
cin >> ansjd;
if (ansjd == 'y') {
l = mid + 1;
} else {
r = mid;
}
mid = (l + r) / 2;
}
cout << "! " << l << "\n";
cout.flush();
cin >> status;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long dp[100100][11][4];
long long dyn[100100][15][4], n, m, k, x;
vector<int> v[100100];
void dfs(int root, int par) {
int tp = -1;
for (int i = 0; i < (int)v[root].size(); i++) {
if (v[root][i] != par)
dfs(v[root][i], root);
else
tp = i;
}
if (tp != -1) {
swap(v[root][tp], v[root].back());
v[root].pop_back();
}
for (int i = 0; i <= (int)v[root].size(); i++)
for (int j = 0; j <= x; j++) dyn[i][j][0] = dyn[i][j][1] = dyn[i][j][2] = 0;
dyn[0][0][0] = 1;
dyn[0][0][2] = 1;
dyn[0][0][1] = 1;
int child = v[root].size();
for (int i = 0; i <= x; i++) {
for (int j = 1; j <= child; j++) {
for (int tmp = 0; tmp <= i; tmp++) {
dyn[j][i][2] = (dyn[j][i][2] +
dyn[j - 1][tmp][2] * (dp[v[root][j - 1]][i - tmp][2] +
dp[v[root][j - 1]][i - tmp][0])) %
mod;
dyn[j][i][1] = (dyn[j][i][1] +
dyn[j - 1][tmp][1] * dp[v[root][j - 1]][i - tmp][0]) %
mod;
dyn[j][i][0] = (dyn[j][i][0] +
dyn[j - 1][tmp][0] * (dp[v[root][j - 1]][i - tmp][2] +
dp[v[root][j - 1]][i - tmp][1] +
dp[v[root][j - 1]][i - tmp][0])) %
mod;
}
}
dp[root][i][2] = (dyn[child][i][2] * (m - k)) % mod;
if (i > 0) dp[root][i][1] = dyn[child][i - 1][1];
dp[root][i][0] = (dyn[child][i][0] * (k - 1)) % mod;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i < n; i++) {
int u1, u2;
cin >> u1 >> u2;
v[u1].push_back(u2);
v[u2].push_back(u1);
}
cin >> k >> x;
dfs(1, 0);
long long ans = 0;
for (int i = 0; i <= x; i++) {
ans = (ans + dp[1][i][1] + dp[1][i][0] + dp[1][i][2]) % mod;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 4e18;
const long double pai = acos(-1);
long long n;
long long a[200009], val[200009], p[200009];
long long crnt[200009];
long long tree[800009], lzy[800009];
void build(long long node, long long l, long long r) {
if (l == r) {
tree[node] = crnt[l];
return;
}
build(node * 2, l, (l + r) / 2);
build(node * 2 + 1, (l + r) / 2 + 1, r);
tree[node] = min(tree[node * 2], tree[node * 2 + 1]);
}
void lzyUPD(long long node, long long l, long long r) {
tree[node] += lzy[node];
if (l != r) {
lzy[node * 2] += lzy[node];
lzy[node * 2 + 1] += lzy[node];
}
lzy[node] = 0;
}
void upd(long long node, long long l, long long r, long long s, long long e,
long long x) {
if (l > r) return;
lzyUPD(node, l, r);
if (s > r || e < l) return;
if (s <= l && e >= r) {
lzy[node] += x;
lzyUPD(node, l, r);
return;
}
upd(node * 2, l, (l + r) / 2, s, e, x);
upd(node * 2 + 1, (l + r) / 2 + 1, r, s, e, x);
tree[node] = min(tree[node * 2], tree[node * 2 + 1]);
}
long long query(long long node, long long l, long long r, long long s,
long long e) {
lzyUPD(node, l, r);
if (s > r || e < l) return inf;
if (s <= l && e >= r) return tree[node];
return min(query(node * 2, l, (l + r) / 2, s, e),
query(node * 2 + 1, (l + r) / 2 + 1, r, s, e));
}
int main() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i], p[a[i]] = i;
for (long long i = 0; i < n; i++) cin >> val[i];
long long sum = 0, xxx = val[p[1]];
for (long long i = 0; i < n; i++) {
if (a[i] == 1)
xxx = 0;
else
sum += val[i];
crnt[i] = xxx + sum;
}
build(1, 0, n - 1);
long long ans = query(1, 0, n - 1, 0, n - 2);
ans = min(ans, min(val[0], val[n - 1]));
for (long long i = 2; i <= n; i++) {
long long x = p[i];
upd(1, 0, n - 1, x, n - 1, -val[x]);
upd(1, 0, n - 1, 0, x - 1, val[x]);
ans = min(ans, query(1, 0, n - 1, 0, n - 2));
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, x, r, j, k, ans = 0, c = 0, error = 0;
cin >> n >> k;
long long a[n + 1];
long long b[n + 1][2];
for (i = 0; i <= n; i++) {
b[i][0] = 0;
b[i][1] = 0;
a[i] = 0;
}
ans = (n - 2) * 3 + 4;
for (i = 0; i < k; i++) {
cin >> x;
if (a[x] == 0) ans--;
if (b[x][0] == 0 && a[x - 1] == 1) {
ans--;
b[x][0] = 1;
}
if (b[x][1] == 0 && a[x + 1] == 1) {
ans--;
b[x][1] = 1;
}
a[x] = 1;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000000;
int per[6][3] = {{0, 1, 2}, {0, 2, 1}, {1, 0, 2},
{1, 2, 0}, {2, 0, 1}, {2, 1, 0}};
vector<vector<int> > P(8, vector<int>(3));
vector<vector<int> > p(8, vector<int>(3));
bool Orto(vector<int>& a, vector<int>& b, vector<int>& c) {
long long ska = 0;
for (int i = 0; i < 3; ++i)
ska += (long long)(b[i] - a[i]) * (long long)(c[i] - a[i]);
return (ska == 0);
}
long long Dl(vector<int>& a, vector<int>& b) {
long long d = 0;
for (int i = 0; i < 3; ++i)
d += (long long)(a[i] - b[i]) * (long long)(a[i] - b[i]);
return d;
}
void Spr() {
long long D = INF;
for (int i = 0; i < 8; ++i)
for (int j = i + 1; j < 8; ++j) D = min(D, Dl(p[i], p[j]));
for (int i = 0; i < 8; ++i) {
vector<int> nr;
for (int j = 0; j < 8; ++j)
if (Dl(p[i], p[j]) == D) nr.push_back(j);
if (!(nr.size() == 3 && Orto(p[i], p[nr[0]], p[nr[1]]) &&
Orto(p[i], p[nr[0]], p[nr[2]]) && Orto(p[i], p[nr[1]], p[nr[2]])))
return;
}
cout << "YES" << endl;
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 3; ++j) cout << p[i][j] << " ";
cout << endl;
}
exit(0);
}
void gen(int nr, int x) {
for (int i = 0; i < 3; ++i) p[nr][i] = P[nr][per[x][i]];
if (nr == 7) {
Spr();
return;
}
for (int i = 0; i < 6; ++i) gen(nr + 1, i);
}
int main() {
ios_base::sync_with_stdio(0);
for (int i = 0; i < 8; ++i)
for (int j = 0; j < 3; ++j) cin >> P[i][j];
for (int i = 0; i < 6; ++i) gen(0, i);
cout << "NO";
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int Mod = (int)1e9 + 7;
const int MX = 1073741822;
const long long MXLL = 4611686018427387903;
const int Sz = 1110111;
using namespace std;
inline void Read_rap() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
}
string s;
int k;
inline long long binpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1ll) res = (res * a) % Mod;
b >>= 1;
a = (a * a) % Mod;
}
return res;
}
struct matrix {
long long a[2][2];
int n;
matrix() {
n = 2;
memset(a, 0, sizeof a);
}
inline matrix operator*(matrix &b) {
matrix c;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
c.a[i][j] = (c.a[i][j] + a[i][k] * b.a[k][j]) % Mod;
return c;
}
inline void show() {
for (int i = 0; i < n; i++, cout << endl)
for (int j = 0; j < n; j++) cout << a[i][j] << ' ';
}
};
inline void binpow(matrix &a, matrix b, long long n) {
while (n) {
if (n & 1) a = a * b;
b = b * b;
n >>= 1;
}
}
int main() {
Read_rap();
cin >> s;
cin >> k;
long long pw = 1, a = 0;
for (int i = 0; i < (int)(s.size()); i++) {
if (s[i % (int)(s.size())] == '0' || s[i % (int)(s.size())] == '5')
a = (a + pw) % Mod;
pw = (pw * 2) % Mod;
}
matrix res, con;
res.a[0][1] = a;
con.a[0][0] = pw;
con.a[1][0] = 1;
con.a[0][1] = 0;
con.a[1][1] = 1;
binpow(res, con, k);
cout << res.a[0][0];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int cnt = 0;
for (int i = 2 * n + 2; i <= 4 * n && cnt < n; i += 2) {
cout << i << " ";
cnt++;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline bool is_vowel(char a) {
if (a == 'A' || a == 'E' || a == 'I' || a == 'O' || a == 'U' || a == 'Y' ||
a == '0') {
return true;
}
return false;
}
int main(void) {
string edge = "0";
string str, s;
cin >> str;
s = str + edge;
int min = 0, jump_ability = 0;
for (auto c : s) {
if (!is_vowel(c)) {
jump_ability++;
} else {
jump_ability++;
min = max(min, jump_ability);
jump_ability = 0;
}
}
cout << min;
return EXIT_SUCCESS;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a;
int i = 1;
bool open = 0;
while (i <= 5) {
cin >> b;
if (b[0] == a[0] or b[1] == a[1]) {
open = 1;
break;
}
i++;
}
if (open == 1)
cout << "Yes";
else
cout << "No";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, rb, cb, rd, cd;
scanf("%d%d%d%d%d%d", &n, &m, &rb, &cb, &rd, &cd);
int ans = 0;
int dr = 1, dc = 1;
while (rb != rd && cb != cd) {
if (rb + dr < 1 || rb + dr > n) dr *= -1;
if (cb + dc < 1 || cb + dc > m) dc *= -1;
rb += dr;
cb += dc;
ans++;
}
printf("%d\n", ans);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
double a[N];
int n, q;
void add(int x, double y) {
for (; x <= n; x += x & -x) a[x] += y;
}
double sig(int x) {
if (x == 0) return 0;
double r = 0;
for (; x; x -= x & -x) r += a[x];
return r;
}
double ask(int l, int r) {
if (l > r) return 0;
return sig(r) - sig(l - 1);
}
vector<int> g[N];
int l[N], r[N], tot, pos[N], fa[N];
void bfs() {
queue<int> q;
q.push(1);
pos[1] = ++tot;
while (q.size()) {
int u = q.front();
q.pop();
l[u] = tot + 1;
for (int v : g[u])
if (v != fa[u]) fa[v] = u, pos[v] = ++tot, r[u] = tot, q.push(v);
}
}
double val[N];
double query(int u, double d) {
double res = 0;
if (fa[u]) res += d * ask(pos[fa[u]], pos[fa[u]]);
res += d * ask(l[u], r[u]);
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lf", &val[i]);
for (int i = 1, u, v; i < n; ++i)
scanf("%d%d", &u, &v), ++u, ++v, g[u].push_back(v), g[v].push_back(u);
bfs();
double ans = 0;
for (int i = 1; i <= n; ++i) {
val[i] = 1 - val[i];
double delta = val[i] - ask(pos[i], pos[i]);
ans += delta;
ans -= query(i, delta);
add(pos[i], delta);
}
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
int u;
double val;
scanf("%d%lf", &u, &val), ++u;
val = 1 - val;
double delta = val - ask(pos[u], pos[u]);
ans += delta;
ans -= query(u, delta);
add(pos[u], delta);
printf("%.5lf\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dp[200001][3];
using namespace std;
set<pair<pair<int, int>, int>> s[1001][1001];
int main() {
int n, m;
cin >> n;
int x, y;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
s[(x - 1) / 1000][(y - 1) / 1000].insert(make_pair(make_pair(x, y), i));
}
for (int i = 0; i < 1001; i++) {
if (i & 1)
for (int j = 0; j < 1001; j++)
for (auto it : s[i][j]) cout << it.second + 1 << " ";
else
for (int j = 1000; j >= 0; j--)
for (auto it = s[i][j].rbegin(); it != s[i][j].rend(); it++)
cout << (*it).second + 1 << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, l, r;
scanf("%d %d %d", &n, &l, &r);
l--;
r--;
int a[n], b[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
bool result = true;
for (int i = 0; i < l; i++)
if (a[i] != b[i]) result = false;
for (int i = r + 1; i < n; i++)
if (a[i] != b[i]) result = false;
if (result)
printf("TRUTH");
else
printf("LIE");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using ii = pair<int, int>;
template <class A, class B>
ostream& operator<<(ostream& os, pair<A, B> p) {
return os << p.first << " " << p.second;
}
template <class A, class B>
istream& operator>>(istream& is, pair<A, B>& p) {
return is >> p.first >> p.second;
}
const int oo = 0x3f3f3f3f;
const ll OO = ll(oo) * oo;
const int N = 200005;
ll dp[N][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
ll a, b;
cin >> a >> b;
string s;
cin >> s;
s += '0';
dp[0][0] = b;
dp[0][1] = OO;
for (int i = 1; i < n + 1; i++) {
if (s[i - 1] == '0' && s[i] == '0') {
dp[i][0] = min(dp[i - 1][1] + 2 * a + b, dp[i - 1][0] + a + b);
} else {
dp[i][0] = OO;
}
dp[i][1] = min(dp[i - 1][0] + 2 * a + 2 * b, dp[i - 1][1] + a + 2 * b);
}
cout << dp[n][0] << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e17;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
const char dir[4] = {'U', 'R', 'D', 'L'};
inline int mabs(int x) { return (x > 0 ? x : -x); }
const int N = 400010;
int arr[N];
long long when[N], dist[N], qt[N];
int pv[55][N];
long long pt[55][N];
int xa[N], ya[N], xb[N], yb[N], arrd[N];
int wx[N], wy[N], wd[N];
int n, b, q;
bool swapx[N], swapy[N];
int ke;
int e[N], el[N], er[N], en[N], rght[N];
bool good[N];
void Sort(int l, int r) {
int i = l, j = r;
int x = e[(l + r) >> 1];
int xx = el[(l + r) >> 1];
do {
while (e[i] < x || e[i] == x && el[i] > xx) i++;
while (x < e[j] || x == e[j] && xx > el[j]) j--;
if (i <= j) {
int tmp = e[i];
e[i] = e[j];
e[j] = tmp;
tmp = el[i];
el[i] = el[j];
el[j] = tmp;
tmp = er[i];
er[i] = er[j];
er[j] = tmp;
tmp = en[i];
en[i] = en[j];
en[j] = tmp;
i++;
j--;
}
} while (i <= j);
if (l < j) Sort(l, j);
if (i < r) Sort(i, r);
}
bool push[N];
int tree[N];
void build(int x, int l, int r) {
push[x] = false;
tree[x] = 0;
if (l < r) {
build(x + x, l, (l + r) >> 1);
build(x + x + 1, ((l + r) >> 1) + 1, r);
}
}
void put(int x, int l, int r, int ll, int rr, int v) {
if (l >= ll && r <= rr) {
push[x] = true;
tree[x] = v;
return;
}
if (push[x]) {
push[x + x] = true;
push[x + x + 1] = true;
tree[x + x] = tree[x];
tree[x + x + 1] = tree[x];
push[x] = false;
}
int y = (l + r) >> 1;
if (ll <= y) put(x + x, l, y, ll, rr, v);
if (rr > y) put(x + x + 1, y + 1, r, ll, rr, v);
}
int get(int x, int l, int r, int p) {
if (l == r || push[x]) return tree[x];
int y = (l + r) >> 1;
if (p <= y) return get(x + x, l, y, p);
return get(x + x + 1, y + 1, r, p);
}
void get_next_all() {
for (int i = 1; i <= n; i++) {
swapx[i] = false;
swapy[i] = false;
if (xa[i] > xb[i]) {
int tmp = xa[i];
xa[i] = xb[i];
xb[i] = tmp;
swapx[i] = true;
}
if (ya[i] > yb[i]) {
int tmp = ya[i];
ya[i] = yb[i];
yb[i] = tmp;
swapy[i] = true;
}
}
for (int i = 1; i <= n + q; i++) {
if (wx[i] < 0 || wy[i] < 0 || wx[i] > b || wy[i] > b) {
good[i] = false;
arr[i] = 0;
} else
good[i] = true;
}
{
for (int i = 1; i <= n; i++) {
e[i - 1] = xa[i];
el[i - 1] = ya[i];
er[i - 1] = yb[i];
en[i - 1] = i;
rght[i] = xb[i];
}
ke = n;
for (int i = 1; i <= n + q; i++) {
if (wd[i] == 3 && good[i]) {
e[ke] = wx[i];
el[ke] = ~wy[i];
en[ke] = i;
ke++;
}
}
Sort(0, ke - 1);
build(1, 0, b);
for (int i = 0; i < ke; i++)
if (el[i] >= 0) {
put(1, 0, b, el[i], er[i], en[i]);
} else {
int num = get(1, 0, b, ~el[i]);
arr[en[i]] = num;
when[en[i]] = e[i] - rght[num];
}
}
{
for (int i = 1; i <= n; i++) {
e[i - 1] = -xb[i];
el[i - 1] = ya[i];
er[i - 1] = yb[i];
en[i - 1] = i;
rght[i] = -xa[i];
}
ke = n;
for (int i = 1; i <= n + q; i++) {
if (wd[i] == 1 && good[i]) {
e[ke] = -wx[i];
el[ke] = ~wy[i];
en[ke] = i;
ke++;
}
}
Sort(0, ke - 1);
build(1, 0, b);
for (int i = 0; i < ke; i++)
if (el[i] >= 0) {
put(1, 0, b, el[i], er[i], en[i]);
} else {
int num = get(1, 0, b, ~el[i]);
arr[en[i]] = num;
when[en[i]] = e[i] - rght[num];
}
}
{
for (int i = 1; i <= n; i++) {
e[i - 1] = ya[i];
el[i - 1] = xa[i];
er[i - 1] = xb[i];
en[i - 1] = i;
rght[i] = yb[i];
}
ke = n;
for (int i = 1; i <= n + q; i++) {
if (wd[i] == 2 && good[i]) {
e[ke] = wy[i];
el[ke] = ~wx[i];
en[ke] = i;
ke++;
}
}
Sort(0, ke - 1);
build(1, 0, b);
for (int i = 0; i < ke; i++)
if (el[i] >= 0) {
put(1, 0, b, el[i], er[i], en[i]);
} else {
int num = get(1, 0, b, ~el[i]);
arr[en[i]] = num;
when[en[i]] = e[i] - rght[num];
}
}
{
for (int i = 1; i <= n; i++) {
e[i - 1] = -yb[i];
el[i - 1] = xa[i];
er[i - 1] = xb[i];
en[i - 1] = i;
rght[i] = -ya[i];
}
ke = n;
for (int i = 1; i <= n + q; i++) {
if (wd[i] == 0 && good[i]) {
e[ke] = -wy[i];
el[ke] = ~wx[i];
en[ke] = i;
ke++;
}
}
Sort(0, ke - 1);
build(1, 0, b);
for (int i = 0; i < ke; i++)
if (el[i] >= 0) {
put(1, 0, b, el[i], er[i], en[i]);
} else {
int num = get(1, 0, b, ~el[i]);
arr[en[i]] = num;
when[en[i]] = e[i] - rght[num];
}
}
for (int i = 1; i <= n + q; i++) {
if (arr[i] == 0) when[i] = inf;
if (when[i] < 0) when[i] = 0;
}
for (int i = 1; i <= n; i++) {
if (swapx[i]) {
int tmp = xa[i];
xa[i] = xb[i];
xb[i] = tmp;
}
if (swapy[i]) {
int tmp = ya[i];
ya[i] = yb[i];
yb[i] = tmp;
}
}
}
int main() {
scanf("%d %d", &n, &b);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d %d", xa + i, ya + i, xb + i, yb + i);
if (yb[i] > ya[i])
arrd[i] = 0;
else if (xb[i] > xa[i])
arrd[i] = 1;
else if (yb[i] < ya[i])
arrd[i] = 2;
else
arrd[i] = 3;
wx[i] = xb[i] + dx[arrd[i]];
wy[i] = yb[i] + dy[arrd[i]];
wd[i] = arrd[i];
}
scanf("%d", &q);
for (int i = n + 1; i <= n + q; i++) {
char foo;
scanf("%d %d %c %I64d", wx + i, wy + i, &foo, qt + i);
wd[i] = 0;
for (int j = 0; j < 4; j++)
if (foo == dir[j]) wd[i] = j;
}
get_next_all();
for (int i = 1; i <= n + q; i++)
if (arr[i] == 0)
dist[i] = inf;
else
dist[i] = mabs(wx[i] - xb[arr[i]]) + mabs(wy[i] - yb[arr[i]]);
arr[0] = 0;
when[0] = inf;
dist[0] = inf;
for (int i = 0; i <= n; i++) pv[0][i] = arr[i], pt[0][i] = dist[i] + 1;
for (int j = 1; j <= 50; j++)
for (int i = 0; i <= n; i++) {
pv[j][i] = pv[j - 1][pv[j - 1][i]];
pt[j][i] = pt[j - 1][i] + pt[j - 1][pv[j - 1][i]];
if (pt[j][i] > inf) pt[j][i] = inf;
}
for (int i = n + 1; i <= n + q; i++) {
if (qt[i] <= dist[i]) {
if (qt[i] <= when[i]) {
long long ax = wx[i] + dx[wd[i]] * qt[i];
long long ay = wy[i] + dy[wd[i]] * qt[i];
if (ax < 0) ax = 0;
if (ay < 0) ay = 0;
if (ax > b) ax = b;
if (ay > b) ay = b;
printf("%d %d\n", (int)ax, (int)ay);
continue;
}
long long ax = wx[i] + dx[wd[i]] * when[i];
long long ay = wy[i] + dy[wd[i]] * when[i];
ax += dx[arrd[arr[i]]] * (qt[i] - when[i]);
ay += dy[arrd[arr[i]]] * (qt[i] - when[i]);
if (ax < 0) ax = 0;
if (ay < 0) ay = 0;
if (ax > b) ax = b;
if (ay > b) ay = b;
printf("%d %d\n", (int)ax, (int)ay);
continue;
}
qt[i] -= dist[i];
int where = arr[i];
for (int j = 50; j >= 0; j--)
if (pt[j][where] <= qt[i]) {
qt[i] -= pt[j][where];
where = pv[j][where];
}
if (arr[where] == 0 || qt[i] <= when[where] + 1) {
long long ax = xb[where] + dx[arrd[where]] * qt[i];
long long ay = yb[where] + dy[arrd[where]] * qt[i];
if (ax < 0) ax = 0;
if (ay < 0) ay = 0;
if (ax > b) ax = b;
if (ay > b) ay = b;
printf("%d %d\n", (int)ax, (int)ay);
continue;
}
int ax = xb[where] + dx[arrd[where]] * (when[where] + 1);
int ay = yb[where] + dy[arrd[where]] * (when[where] + 1);
ax += dx[arrd[arr[where]]] * (qt[i] - (when[where] + 1));
ay += dy[arrd[arr[where]]] * (qt[i] - (when[where] + 1));
printf("%d %d\n", ax, ay);
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.