solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100008;
int n, m, pp, x, y, c;
int tot, start[maxn];
bool in[maxn];
struct arr {
int a, next;
} e[maxn << 1];
void Add(int x, int y) {
e[++tot].a = y;
e[tot].next = start[x];
start[x] = tot;
e[++tot].a = x;
e[tot].next = start[y];
start[y] = tot;
}
void Dfs(int u) {
in[u] = 1;
c++;
for (int i = start[u], v; v = e[i].a, i; i = e[i].next)
if (!in[v]) Dfs(v);
}
int power(int x, int n) {
int ans = 1, tmp = x;
while (n) {
if (n & 1) ans = (long long)ans * tmp % pp;
tmp = (long long)tmp * tmp % pp;
n >>= 1;
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &pp);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
Add(x, y);
}
int d = 0, sum = 0, s = 1;
for (int i = 1; i <= n; i++)
if (!in[i]) {
c = 0;
Dfs(i);
sum += c;
if (sum >= pp) sum -= pp;
s = (long long)s * c % pp;
d++;
}
if (d == 1)
printf("%d\n", 1 % pp);
else
printf("%d\n", (long long)power(sum, d - 2) * s % pp);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, m;
cin >> n >> m;
vector<long long> v(n);
long long sum = 0;
for (int i = 0; i < n; ++i) {
cin >> v[i];
if (i > 0) sum += v[i - 1];
sort(v.begin(), v.begin() + i);
long long d = m - v[i];
long long cop = sum, k = 0;
for (int j = i - 1; j >= 0; --j)
if (cop > d) {
cop -= v[j];
k++;
}
cout << k << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
ifstream fi("");
ofstream fo("");
int main() {
int n, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) a[i] *= 100000000000;
long long l = 0, r = 100000000000000;
long long mid, sum;
while (l != r) {
mid = (l + r + 1) / 2;
sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] > mid)
sum += ((a[i] - mid) / 100) * (100 - k);
else
sum -= (mid - a[i]);
}
if (sum == 0) {
cout << setprecision(9) << fixed << (double)mid / 100000000000 << endl;
return 0;
}
if (sum > 0)
l = mid;
else
r = mid - 1;
}
cout << setprecision(9) << fixed << (double)l / 100000000000 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char start, end;
cin >> start >> end;
int n;
cin >> n;
int mapa[120];
mapa[0] = 'v';
mapa[1] = '<';
mapa[2] = '^';
mapa[3] = '>';
mapa['v'] = 0;
mapa['<'] = 1;
mapa['^'] = 2;
mapa['>'] = 3;
int ans = 0;
if ((mapa[start] + n) % 4 == mapa[end]) ans++;
if ((mapa[start] + 4 - (n % 4)) % 4 == mapa[end]) ans--;
if (ans < 0) printf("ccw\n");
if (ans > 0) printf("cw\n");
if (!ans) printf("undefined\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e60;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
inline char mygetchar() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
template <typename T>
void chkmax(T &x, const T &y) {
if (y > x) x = y;
return;
}
template <typename T>
void chkmin(T &x, const T &y) {
if (y < x) x = y;
return;
}
void TZL();
void RANK1();
int main() {
TZL();
RANK1();
return 0;
}
const int N = 1e5 + 100;
int n;
long long x[N], y[N], ans;
long long mxl[N], mxr[N], mnl[N], mnr[N];
void TZL() {
static pair<long long, long long> a[N];
long long mxx = -linf, mnx = linf, mxy = -linf, mny = linf;
bool f = 0;
scf(n);
for (int i = 0, _end_ = (n); i < _end_; ++i) {
long long x, y;
scf(x, y);
f |= (x && y);
a[i] = make_pair(x, y);
chkmax(mxx, x);
chkmin(mnx, x);
chkmax(mxy, y);
chkmin(mny, y);
}
if (!f) {
puts("0");
exit(0);
}
ans = min(((mxx - mnx) * (mxx - mnx)), ((mxy - mny) * (mxy - mny)));
a[n] = make_pair(0, 0);
sort(a, a + n + 1);
n = unique(a, a + n + 1) - a;
for (int i = 0, _end_ = (n); i < _end_; ++i)
x[i] = a[i].first, y[i] = a[i].second;
mxl[0] = mnl[0] = y[0];
for (int i = (1), _end_ = (n - 1); i <= _end_; ++i)
mxl[i] = max(mxl[i - 1], y[i]), mnl[i] = min(mnl[i - 1], y[i]);
mxr[n - 1] = mnr[n - 1] = y[n - 1];
for (int i = (n - 1) - 1; i >= 0; --i)
mxr[i] = max(mxr[i + 1], y[i]), mnr[i] = min(mnr[i + 1], y[i]);
return;
}
long long D;
bool check() {
int j = lower_bound(x, x + n, 0) - x;
for (int i = j - 1; ~i; --i) {
if (((x[i]) * (x[i])) > D) return 0;
while (j < n && x[j] <= -x[i] && ((x[j] - x[i]) * (x[j] - x[i])) <= D) ++j;
while (x[j - 1] > -x[i] || ((x[j - 1] - x[i]) * (x[j - 1] - x[i])) > D) --j;
long long mx = mxr[j], mn = mnr[j];
if (i) chkmax(mx, mxl[i - 1]), chkmin(mn, mnl[i - 1]);
if (max(((mx - mn) * (mx - mn)),
max(((mx) * (mx)), ((mn) * (mn))) + ((x[i]) * (x[i]))) <= D)
return 1;
}
return 0;
}
void RANK1() {
for (int _ = 0, _end_ = (2); _ < _end_; ++_) {
long long lb = 0, rb = ans;
while (lb <= rb) {
D = lb + rb >> 1;
if (check())
rb = D - 1;
else
lb = D + 1;
}
chkmin(ans, lb);
for (int i = 0, _end_ = (n); i < _end_; ++i) x[i] = -x[i];
reverse(x, x + n);
reverse(y, y + n);
mxl[0] = mnl[0] = y[0];
for (int i = (1), _end_ = (n - 1); i <= _end_; ++i)
mxl[i] = max(mxl[i - 1], y[i]), mnl[i] = min(mnl[i - 1], y[i]);
mxr[n - 1] = mnr[n - 1] = y[n - 1];
for (int i = (n - 1) - 1; i >= 0; --i)
mxr[i] = max(mxr[i + 1], y[i]), mnr[i] = min(mnr[i + 1], y[i]);
}
printf("%lld\n", ans);
return;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, vector<T> v) {
for (long long i = (0); i < ((long long)(v).size()); i++)
os << (i ? " " : "") << v[i];
return os;
}
const bool debug = 1;
const long long OFF = 25000;
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
map<long long, vector<pair<long long, long long>>> kills;
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
for (long long i = (0); i < (n); i++) cin >> a[i];
for (long long i = (0); i < (m); i++) cin >> b[i];
for (long long i = (0); i < (n); i++)
for (long long j = (0); j < (m); j++) {
long long sum = a[i] + b[j];
kills[sum].push_back({0, i});
kills[sum].push_back({1, j});
}
for (auto &p : kills) {
sort(p.second.begin(), p.second.end());
p.second.resize(unique(p.second.begin(), p.second.end()) -
p.second.begin());
}
long long best = 0;
for (auto &p : kills) {
for (auto &q : kills) {
auto &v1 = p.second, &v2 = q.second;
long long cnt = (long long)(v1).size() + (long long)(v2).size();
auto it1 = v1.begin(), it2 = v2.begin();
while (it1 != v1.end() && it2 != v2.end()) {
if (*it1 == *it2) cnt--;
if (*it1 < *it2)
it1++;
else
it2++;
}
best = max(best, cnt);
}
}
cout << best << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500, big = 1e8;
int n, K, ans = big, anss;
int es = 1, he[maxn], to[maxn * 2], ne[maxn * 2];
int f[maxn][maxn];
bool c[maxn] = {0};
vector<pair<int, int> > fr[maxn][maxn];
void ins(int first, int second) {
to[++es] = second, ne[es] = he[first], he[first] = es;
}
void dfs(int first, int fa) {
int i, j, k;
f[first][1] = 0;
for (i = 2; i <= K; i++) f[first][i] = big;
for (i = he[first]; i; i = ne[i])
if (to[i] != fa) {
dfs(to[i], first);
for (j = K; j; j--) {
if (f[first][j] != big) f[first][j]++;
for (k = 1; k < j; k++)
if (f[first][j - k] + f[to[i]][k] < f[first][j]) {
int t;
f[first][j] = f[first][j - k] + f[to[i]][k];
fr[first][j].clear();
for (t = 0; t < fr[first][j - k].size(); t++)
fr[first][j].push_back(fr[first][j - k][t]);
fr[first][j].push_back(make_pair(to[i], k));
}
}
}
if (f[first][K] + (first != 1) < ans)
ans = f[first][K] + (first != 1), anss = first;
}
void print(int first, int k) {
int i;
c[first] = 1;
for (i = 0; i < fr[first][k].size(); i++)
print(fr[first][k][i].first, fr[first][k][i].second);
for (i = he[first]; i; i = ne[i])
if (!c[to[i]]) printf("%d ", i / 2);
}
int main() {
int i, j, first, second;
scanf("%d%d", &n, &K);
for (i = 1; i < n; i++)
scanf("%d%d", &first, &second), ins(first, second), ins(second, first);
dfs(1, 0);
printf("%d\n", ans);
print(anss, K);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
long long i;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] + a[1] <= a[n - 1])
cout << 1 << " " << 2 << " " << n << "\n";
else
cout << -1 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > adj[100050];
map<int, bool> vis;
multiset<long long int> st;
void dfs(int s, int cost) {
vis[s] = true;
if (adj[s].size() == 1 && s != 0) st.insert(cost);
for (int i = 0; i < adj[s].size(); ++i) {
if (vis[adj[s][i].first] == false) {
int cost2 = cost + adj[s][i].second;
dfs(adj[s][i].first, cost2);
}
}
}
void initialize(int n) {
for (int i = 0; i < n + 1; ++i) {
vis[i] = false;
}
}
int main() {
long long int n;
cin >> n;
for (long long int i = 0; i < n - 1; i++) {
int a, b, c;
cin >> a >> b >> c;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
int cost = 0;
initialize(n);
dfs(0, cost);
for (auto a : st) cost = a;
cout << cost << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int ch[20005][13];
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
int u;
scanf("%d", &u);
ch[i][j] = u;
}
}
int noti[13];
for (int i = (0); i < (m); i++) noti[i] = 0;
int guy[20005];
for (int i = (0); i < (n); i++) guy[i] = 0;
for (int i = (0); i < (k); i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
noti[v]++;
guy[u]--;
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++)
if (ch[i][j]) guy[i] += noti[j];
}
for (int i = (0); i < (n); i++) printf("%d ", guy[i]);
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, cost;
edge(int to = 0, int cost = 0) : to(to), cost(cost) {}
};
vector<edge> vec[100005];
vector<int> gt[100005];
int nd[100005], cmb[100005];
int sum[100005], gl[100005];
int pos[100005];
int n;
void dfs(int v = 0, int p = -1) {
nd[v] = 1;
for (int i = 0; i < vec[v].size(); i++) {
int to = vec[v][i].to;
if (to != p) {
dfs(to, v);
nd[v] += nd[to];
}
}
}
pair<int, int> center(int v = 0, int p = -1) {
int mx = n - nd[v];
pair<int, int> ret = pair<int, int>(n * 2, -1);
for (int i = 0; i < vec[v].size(); i++) {
int to = vec[v][i].to;
if (to != p) {
pair<int, int> p = center(to, v);
ret = min(ret, p);
mx = max(mx, nd[to]);
}
}
ret = min(ret, pair<int, int>(mx, v));
return ret;
}
void color(int v, int p, int k) {
cmb[v] = k;
gt[k].push_back(v);
for (int i = 0; i < vec[v].size(); i++) {
int to = vec[v][i].to;
if (to != p) {
color(to, v, k);
}
}
}
long long int get(int v, int p, long long int d) {
long long int ret = d;
for (int i = 0; i < vec[v].size(); i++) {
edge e = vec[v][i];
if (e.to != p) {
ret += get(e.to, v, d + e.cost);
}
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
vec[a].push_back(edge(b, c));
vec[b].push_back(edge(a, c));
}
if (n == 1) {
puts("0");
puts("1");
return 0;
}
dfs();
int ct = center().second;
int sz = 0;
cmb[ct] = sz;
gt[sz++].push_back(ct);
for (int i = 0; i < vec[ct].size(); i++) {
int to = vec[ct][i].to;
color(to, ct, sz++);
}
set<pair<int, int> > st, gd;
set<pair<int, int> >::iterator it;
for (int i = 0; i < sz; i++) {
sort(gt[i].begin(), gt[i].end());
sum[i] = gt[i].size() * 2;
st.insert(pair<int, int>(sum[i], i));
pos[i] = 0;
gd.insert(pair<int, int>(gt[i][0], i));
}
for (int i = 0; i < n; i++) {
int c = cmb[i];
st.erase(pair<int, int>(sum[c], c));
sum[c]--;
it = st.end();
it--;
pair<int, int> p = *it;
if (p.first == n - i && p.second != 0) {
int d = p.second;
st.erase(it);
gd.erase(pair<int, int>(gt[d][pos[d]], d));
gl[i] = gt[d][pos[d]++];
sum[d]--;
st.insert(pair<int, int>(sum[d], d));
if (pos[d] < gt[d].size()) gd.insert(pair<int, int>(gt[d][pos[d]], d));
} else {
it = gd.begin();
if (it->second == c && c != 0) it++;
int d = it->second;
st.erase(pair<int, int>(sum[d], d));
gd.erase(it);
gl[i] = gt[d][pos[d]++];
sum[d]--;
st.insert(pair<int, int>(sum[d], d));
if (pos[d] < gt[d].size()) gd.insert(pair<int, int>(gt[d][pos[d]], d));
}
st.insert(pair<int, int>(sum[c], c));
}
printf("%I64d\n", get(ct, -1, 0) * 2LL);
for (int i = 0; i < n; i++) {
if (i != 0) printf(" ");
printf("%d", gl[i] + 1);
}
puts("");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int nums[n];
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
nums[i] = 60 * a + b;
}
if (nums[0] >= s + 1) {
cout << "0 0";
return 0;
}
int counter = 0;
while (counter < n - 1) {
int diff = nums[counter + 1] - nums[counter];
if (diff >= 2 * s + 2) {
int sum = nums[counter] + s + 1;
cout << sum / 60 << " " << sum % 60;
return 0;
}
counter++;
}
int sum = nums[counter] + s + 1;
cout << sum / 60 << " " << sum % 60;
}
| 1 |
#include <bits/stdc++.h>
inline int read() {
char c = getchar();
int x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - 48, c = getchar();
return x;
}
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
int pre[maxn], fac[maxn], ifac[maxn], inv[maxn], f[maxn];
int n, m;
inline int C(int n, int m) {
if (n < m) return 0;
return 1ll * fac[n] * ifac[n - m] % mod * ifac[m] % mod;
}
inline int qm(int x) { return x >= mod ? x - mod : x; }
inline int dqm(int x) { return x < 0 ? x + mod : x; }
inline int calc(int l, int r) {
if (l <= 0) return pre[r];
return dqm(pre[r] - pre[l - 1]);
}
int main() {
n = read(), m = read();
fac[0] = ifac[0] = inv[1] = 1;
for (register int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
for (register int i = 2; i <= n; i++)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
for (register int i = 1; i <= n; i++)
ifac[i] = 1ll * ifac[i - 1] * inv[i] % mod;
f[0] = 1;
pre[0] = 1;
for (register int i = 1; i < n; i++) {
f[i] = 1ll * calc(i - m, i - 1) * fac[i - 1] % mod;
pre[i] = qm(pre[i - 1] + 1ll * f[i] * ifac[i] % mod);
}
int ans = 0;
for (register int i = 1; i <= n; i++)
ans = qm(ans + 1ll * f[i - 1] * C(n - 1, i - 1) % mod * fac[n - i] % mod);
printf("%d\n", dqm(fac[n] - ans));
return 0;
}
| 8 |
#include <bits/stdc++.h>
template <typename T>
void MACRO_VAR_Scan(T& t) {
std::cin >> t;
}
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First& first, Rest&... rest) {
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
template <typename T>
void MACRO_VEC_ROW_Init(int n, T& t) {
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First& first, Rest&... rest) {
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T>
void MACRO_VEC_ROW_Scan(int p, T& t) {
std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First& first, Rest&... rest) {
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
template <typename T>
inline T CHMAX(T& a, const T b) {
return a = (a < b) ? b : a;
}
template <typename T>
inline T CHMIN(T& a, const T b) {
return a = (a > b) ? b : a;
}
void CHECKTIME(std::function<void()> f) {
auto start = std::chrono::system_clock::now();
f();
auto end = std::chrono::system_clock::now();
auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start))
.count();
std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n";
}
template <class T>
std::vector<std::vector<T>> VV(int n, int m, T init = T()) {
return std::vector<std::vector<T>>(n, std::vector<T>(m, init));
}
template <typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = 1 << 30;
constexpr int INFINT_LIM = (1LL << 31) - 1;
constexpr ll INFLL = 1LL << 60;
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);
constexpr double EPS = 1e-9;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
template <class T, size_t N>
void FILL(T (&a)[N], const T& val) {
for (auto& x : a) x = val;
}
template <class ARY, size_t N, size_t M, class T>
void FILL(ARY (&a)[N][M], const T& val) {
for (auto& b : a) FILL(b, val);
}
template <class T>
void FILL(std::vector<T>& a, const T& val) {
for (auto& x : a) x = val;
}
template <class ARY, class T>
void FILL(std::vector<std::vector<ARY>>& a, const T& val) {
for (auto& b : a) FILL(b, val);
}
int popCount(unsigned long long x) {
x = ((x & 0xaaaaaaaaaaaaaaaaUL) >> 1) + (x & 0x5555555555555555UL);
x = ((x & 0xccccccccccccccccUL) >> 2) + (x & 0x3333333333333333UL);
x = ((x & 0xf0f0f0f0f0f0f0f0UL) >> 4) + (x & 0x0f0f0f0f0f0f0f0fUL);
x = ((x & 0xff00ff00ff00ff00UL) >> 8) + (x & 0x00ff00ff00ff00ffUL);
x = ((x & 0xffff0000ffff0000UL) >> 16) + (x & 0x0000ffff0000ffffUL);
x = ((x & 0xffffffff00000000UL) >> 32) + (x & 0x00000000ffffffffUL);
return x;
}
int calc(std::vector<ll> a, std::vector<ll> b) {
int n = a.size(), m = b.size();
int res = 0;
for (int i = 0; i < int(n); ++i) a[i] = -a[i] - 30000;
std::reverse((a).begin(), (a).end());
std::vector<ll> bit;
std::vector<ll> bit2;
while (true) {
int dist = INFINT;
ll bi = 0;
ll bi2 = 0;
for (int i = 0; i < int(n); ++i) {
auto it = std::upper_bound((b).begin(), (b).end(), a[i]);
if (it == b.end()) continue;
int t = *it - a[i];
CHMIN(dist, t);
}
if (dist == INFINT) break;
for (int i = 0; i < int(n); ++i) a[i] += dist;
for (int i = 0; i < int(n); ++i) {
auto it = std::lower_bound((b).begin(), (b).end(), a[i]);
if (it != b.end() && *it == a[i]) bi |= 1LL << i;
}
for (int i = 0; i < int(m); ++i) {
auto it = std::lower_bound((a).begin(), (a).end(), b[i]);
if (it != a.end() && *it == b[i]) bi2 |= 1LL << i;
}
bit.emplace_back(bi);
bit2.emplace_back(bi2);
}
for (int i = 0; i < int(bit.size()); ++i)
for (int j = (i); j < (bit.size()); ++j) {
CHMAX(res, popCount(bit[i] | bit[j]) + popCount(bit2[i] | bit2[j]));
}
return res;
}
namespace MY {
int calc(ll n, ll m, std::vector<ll> a, std::vector<ll> b) {
std::sort((a).begin(), (a).end());
std::sort((b).begin(), (b).end());
int ans = 0;
ans += ::calc(a, b);
return ans;
}
} // namespace MY
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
;
int n, m;
MACRO_VAR_Scan(n, m);
;
std::vector<ll> a(n);
for (auto& i : a) std::cin >> i;
;
std::vector<ll> b(m);
for (auto& i : b) std::cin >> i;
;
std::cout << (MY::calc(n, m, a, b));
std::cout << "\n";
;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[52], k;
int n, ans[52];
int main() {
cin >> n >> k;
a[0] = a[1] = 1;
a[2] = 2;
for (int i = 3; i <= n; i++) a[i] = a[i - 1] + a[i - 2];
int pos = 1;
while (pos <= n) {
if (k <= a[n - pos]) {
ans[pos] = pos;
pos++;
} else {
ans[pos] = pos + 1;
ans[pos + 1] = pos;
k -= a[n - pos];
pos += 2;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const long long MAXN = 1e6 + 10;
const long long INF = 8e18;
const long long MOD = 1e9 + 7;
int n;
vector<pair<int, int>> v, vt;
vector<vector<bool>> ans, ans2;
bool DEBUG_MODE;
inline bool BET(int l, int r, int m) {
m--;
return m >= l && m <= r;
}
inline void Majik(int L, int R) {
vt = v;
int ptr = R;
for (int i = L; i <= R; i++) {
ans.push_back({});
ans.rbegin()->resize(n);
for (int j = L; j <= min(R, n - 1); j++) {
if (v[j].first >= i - L) ans[i][j] = 1;
}
for (int j = R + 1; j < n; j++) {
if (v[j].first > 1) {
ans[i][j] = 1;
v[j].first--;
}
}
}
for (int i = min(R, n - 1); i >= L; i--) {
ptr = min(ptr, L + v[i].first + 1);
ans[ptr][i] = 0;
ptr--;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back({x, i});
if (n == 1000 && i == 1 && v.back().first == 7) DEBUG_MODE = true;
}
sort((v).begin(), (v).end());
int L = 0;
for (int i = 0; i < n; i++) {
if (v[i].first < i + 1 - L) {
Majik(L, i);
L = i + 1;
}
}
Majik(L, n);
for (int i = 0; i < (int)ans.size(); i++) {
if (find((ans[i]).begin(), (ans[i]).end(), true) == ans[i].end()) continue;
ans2.push_back({});
ans2.rbegin()->resize(n);
for (int j = 0; j < n; j++) ans2[ans2.size() - 1][v[j].second] = ans[i][j];
}
cout << ans2.size() << '\n';
for (auto e : ans2) {
for (auto e2 : e) {
cout << int(e2);
}
cout << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int size(const T &x) {
return x.size();
}
const int INF = ~(1 << 31);
const double pi = acos(-1);
const double EPS = 1e-9;
bool isprime(int n) {
if (n == 1) return false;
if (n == 2) return true;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
vector<int> factors(int n) {
vector<int> ans;
int z = 2;
while (z * z <= n) {
if (n % z == 0) {
ans.push_back(z);
n /= z;
} else
z++;
}
if (n > 1) ans.push_back(n);
return ans;
}
int main() {
cin.sync_with_stdio(false);
long long x1;
cin >> x1;
long long mx = x1;
if (isprime(x1)) {
cout << x1 << endl;
return 0;
}
for (int i = x1; i >= 0; i--) {
if (x1 % i == 0 && isprime(i)) {
int ans = INF;
for (int j = x1; j > x1 - i; j--) {
vector<int> facts = factors(j);
for (auto it = (facts).begin(); it != (facts).end(); ++it) {
if (*it == j) continue;
ans = min(ans, j - *it + 1);
}
}
cout << ans << endl;
break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solution();
template <class T>
T GCD(T a, T b) {
if (a == 0) return b;
return GCD(b % a, a);
}
template <class T>
T modpow(T x, T p) {
T res = 1;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p /= 2;
}
return res;
}
template <class T>
void print(T a[], long long n) {
for (long long i = 0; i < n; i++) std::cout << a[i] << ' ';
cout << endl;
}
template <class T>
void printc(T c) {
for (auto const& v : c) std::cout << v << ' ';
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solution();
return 0;
}
int parents[2002];
bool d[2002][2002];
vector<int> group;
int find(int x) {
while (x != parents[x]) {
parents[x] = parents[parents[x]];
x = parents[x];
}
return x;
}
void solution() {
long long n;
cin >> n;
for (int i = 1; i <= n; i++) {
parents[i] = i;
}
long long k, m;
cin >> k;
for (long long i = 0; i < k; ++i) {
int u, v;
cin >> u >> v;
int p1 = find(u), p2 = find(v);
if (p1 == p2) continue;
parents[p1] = p2;
}
unordered_map<int, int> g;
for (int i = 1; i <= n; i++) {
int p = find(i);
g[p] += 1;
}
cin >> m;
for (long long i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
int p1 = find(u), p2 = find(v);
if (p1 == p2) {
g.erase(p1);
}
}
int ans = 0;
for (auto& i : g) {
ans = max(ans, i.second);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a;
vector<int> b;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(x);
}
for (int j = 0; j < m; j++) {
int y;
cin >> y;
b.push_back(y);
}
for (int i = 0; i < n - m; i++) b.push_back(0);
int item = 0;
for (int k = 0; k < n;) {
if (b[k] >= a[k]) {
item++;
} else if (b[k] < a[k]) {
a.erase(a.begin() + k);
k--;
n--;
}
k++;
}
cout << item;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 11;
const double pi = acos(-1.0);
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const unsigned long long B = 100000007ULL;
char S[3][MAXN];
int len[3];
unsigned long long H[3][MAXN], B_[MAXN];
inline void init_hash() {
for (int(i) = (0); (i) < (3); (i)++) {
for (int(j) = (1); (j) < (len[i] + 1); (j)++) {
H[i][j] = H[i][j - 1] * B + S[i][j];
}
}
int n = max(max(len[0], len[1]), len[2]);
B_[0] = 1;
for (int(i) = (1); (i) < (n + 1); (i)++) B_[i] = B_[i - 1] * B;
}
inline unsigned long long hashs(unsigned long long *h, int l, int d) {
return h[l + d - 1] - h[l - 1] * B_[d];
}
bool contain(int a, int b) {
if (len[a] < len[b]) return 0;
unsigned long long hb = H[b][len[b]];
for (int i = 1; i + len[b] <= len[a]; i++)
if (hashs(H[a], i, len[b]) == hb) return 1;
return 0;
}
int overlap(int a, int b) {
int ans = 0;
for (int(i) = (1); (i) < (min(len[a], len[b]) + 1); (i)++)
if (hashs(H[a], len[a] - i + 1, i) == hashs(H[b], 1, i)) ans = i;
return ans;
}
int solve() {
int ans = len[1] + len[2] + len[0];
for (int(i) = (0); (i) < (2); (i)++)
for (int(j) = (i + 1); (j) < (3); (j)++)
if (contain(i, j) || contain(j, i)) {
int x = len[i] > len[j] ? i : j;
int y = 3 - i - j;
if (contain(x, y) || contain(y, x)) return max(len[x], len[y]);
return len[x] + len[y] - max(overlap(x, y), overlap(y, x));
}
int id[3] = {0, 1, 2};
do
ans = min(ans, len[0] + len[1] + len[2] - overlap(id[0], id[1]) -
overlap(id[1], id[2]));
while (next_permutation(id, id + 3));
return ans;
}
int main() {
for (int(i) = (0); (i) < (3); (i)++) scanf("%s", S[i] + 1);
for (int(i) = (0); (i) < (3); (i)++) len[i] = strlen(S[i] + 1);
init_hash();
printf("%d\n", solve());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int conversion(string p) {
int o;
o = atoi(p.c_str());
return o;
}
string toString(int h) {
stringstream ss;
ss << h;
return ss.str();
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
long long toi(string p) {
long long x;
istringstream in(p);
in >> x;
return x;
}
int k, mul = 1, lab[11][11];
string go(int n) {
string ans = "";
while (n / k > 0) {
ans += toString(n % k);
n /= k;
}
ans += toString(n % k);
reverse(ans.begin(), ans.end());
return ans;
}
int main() {
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++) {
lab[i][j] = j * mul;
}
mul++;
}
while (cin >> k) {
for (int i = 1; i <= k - 1; i++) {
for (int j = 1; j <= k - 1; j++) {
cout << go(lab[i][j]) << " ";
}
cout << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1;
string s, t;
int dp[10003], tmp[10003];
void init() {
memset(tmp, -1, sizeof tmp);
int hit = 0, num = 0;
for (int i = 0; i < s.size(); i++) {
char c = s[i];
if (c == t[0]) {
hit++;
dp[i] = num;
} else if (c == '.') {
if (hit) hit--, num++;
} else
hit++;
}
}
void print() {
for (int i = 0; i < s.size(); i++) cout << dp[i] << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, -1, sizeof dp);
cin >> s >> t;
s += "A";
t += "A";
init();
for (int i = 1; i < t.size(); i++) {
int afi = 0, ase = 0;
int mx = -INF;
vector<pair<int, int> > vec;
for (int j = 0; j < s.size(); j++) {
if (mx == -INF && vec.size() == 0 && dp[j] == -1) continue;
if (s[j] != '.') {
ase++;
if (mx != -INF) {
if (!vec.size() || vec.back().first + afi < mx) {
vec.push_back({mx - afi, 1 - ase});
mx = -INF;
}
}
if (s[j] == t[i]) {
if (vec.size())
tmp[j] = max(vec.back().first + afi, mx);
else
tmp[j] = mx;
}
if (dp[j] != -1) mx = max(mx, dp[j]);
} else {
if (vec.size() == 0) continue;
ase--;
afi++;
if (vec.back().second + ase == 0) {
mx = max(mx, vec.back().first + afi);
vec.pop_back();
}
}
}
for (int j = 0; j < s.size(); j++) {
dp[j] = tmp[j];
tmp[j] = -1;
}
}
int ans = 0;
for (int j = 0; j < s.size(); j++) ans = max(ans, dp[j]);
cout << s.size() - 2 * ans - t.size() << "\n";
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
void qread(int &x) {
int neg = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = 10 * x + c - '0', c = getchar();
x *= neg;
}
const int maxn = 5005;
int n, T;
double dp[maxn][maxn], pw[maxn], ans;
int main() {
scanf("%d%d", &n, &T);
dp[0][0] = 1;
for (int(i) = 0; (i) < n; i++) {
int x, t;
scanf("%d%d", &x, &t);
double p = double(x) / 100.0;
double coef = 1.0;
for (int(j) = 1; (j) <= t - 1; j++) coef *= (1 - p);
double tmp = dp[i][0] * p;
for (int(j) = 1; (j) <= T; j++) {
if (j - t >= 0) tmp -= coef * dp[i][j - t] * p;
dp[i + 1][j] += tmp;
if (j - t >= 0) dp[i + 1][j] += dp[i][j - t] * coef;
tmp = tmp * (1 - p) + dp[i][j] * p;
ans += dp[i + 1][j];
}
}
printf("%.10lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
long long sum(long long n, long long k) {
long long r = 0;
while (n > 0) {
long long curr = std::min(n, k);
r += curr;
n -= curr;
n -= n / 10;
}
return r;
}
long long solve(long long n) {
long long low = 0, high = n;
while (high - low > 1) {
long long mid = (low + high) / 2;
if (2 * sum(n, mid) >= n) {
high = mid;
} else {
low = mid;
}
}
return high;
}
long long slow(long long n) {
for (long long k = 1; k <= n; ++k) {
if (2 * sum(n, k) >= n) {
return k;
}
}
throw 1;
}
void test() {
for (long long n = 1; n <= 100; ++n) {
assert(slow(n) == solve(n));
}
std::cout << "ok!";
std::exit(0);
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
std::cerr.tie(0);
long long n;
std::cin >> n;
std::cout << solve(n);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long pow_mod(long long x, long long n, long long mod) {
long long ret = 1LL;
while (n) {
if (n & 1) ret = ret * x % mod;
x = x * x % mod;
n >>= 1;
}
return ret;
}
const int inf = 0x3f3f3f3f;
const long long INF = (1LL << 62) - 1;
const int N = 1e5 + 5;
int n, m;
long long sum[N << 2], Max[N << 2];
void PushUp(int rt) {
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
Max[rt] = max(Max[rt << 1], Max[rt << 1 | 1]);
}
void build(int l, int r, int rt) {
if (l == r) {
scanf("%lld", &sum[rt]);
Max[rt] = sum[rt];
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
PushUp(rt);
}
void update_pt(int p, int v, int l, int r, int rt) {
if (l == r) {
Max[rt] = sum[rt] = v;
return;
}
int m = (l + r) >> 1;
if (p <= m)
update_pt(p, v, l, m, rt << 1);
else
update_pt(p, v, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
void update_mod(int L, int R, long long mod, int l, int r, int rt) {
int m = (l + r) >> 1;
if (L <= l && r <= R) {
long long mx = Max[rt];
if (mx < mod) return;
if (l == r) {
sum[rt] %= mod;
Max[rt] %= mod;
return;
} else {
update_mod(L, R, mod, l, m, rt << 1);
update_mod(L, R, mod, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
}
if (L <= m) update_mod(L, R, mod, l, m, rt << 1);
if (R > m) update_mod(L, R, mod, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
long long query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return sum[rt];
}
int m = (l + r) >> 1;
long long ret = 0;
if (L <= m) ret += query(L, R, l, m, rt << 1);
if (R > m) ret += query(L, R, m + 1, r, rt << 1 | 1);
return ret;
}
int main() {
scanf("%d%d", &n, &m);
build(1, n, 1);
while (m--) {
int op, l, r, x;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &l, &r);
printf("%lld\n", query(l, r, 1, n, 1));
} else if (op == 2) {
scanf("%d%d%d", &l, &r, &x);
update_mod(l, r, x, 1, n, 1);
} else {
scanf("%d%d", &l, &x);
update_pt(l, x, 1, n, 1);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
char B[3][109];
int vis[3][109][309];
int xs, ys;
struct node {
int x, y, ti;
node() { x = y = ti = 0; }
node(int a, int b, int c) { x = a, y = b, ti = c; }
};
int n;
bool BFS() {
queue<node> q;
q.push(node(xs, ys, 0));
while (!q.empty()) {
node cur = q.front();
q.pop();
if (cur.y >= (n - 1)) return 1;
if ((B[cur.x][cur.y + 1] == '.' || B[cur.x][cur.y + 1] == 0) &&
(B[cur.x][cur.y + 2] == '.' || B[cur.x][cur.y + 2] == 0) &&
(B[cur.x][cur.y + 3] == '.' || B[cur.x][cur.y + 3] == 0) &&
!vis[cur.x][cur.y + 3][cur.ti + 2]) {
vis[cur.x][cur.y + 3][cur.ti + 2] = 1;
q.push(node(cur.x, cur.y + 3, cur.ti + 2));
}
if (cur.x) {
if ((B[cur.x][cur.y + 1] == '.' || B[cur.x][cur.y + 1] == 0) &&
(B[cur.x - 1][cur.y + 3] == '.' || B[cur.x - 1][cur.y + 3] == 0) &&
(B[cur.x - 1][cur.y + 1] == '.' || B[cur.x - 1][cur.y + 1] == 0) &&
(B[cur.x - 1][cur.y + 2] == '.' || B[cur.x - 1][cur.y + 2] == 0) &&
!vis[cur.x - 1][cur.y + 3][cur.ti + 2]) {
vis[cur.x - 1][cur.y + 3][cur.ti + 2] = 1;
q.push(node(cur.x - 1, cur.y + 3, cur.ti + 2));
}
}
if (cur.x < 2) {
if ((B[cur.x][cur.y + 1] == '.' || B[cur.x][cur.y + 1] == 0) &&
(B[cur.x + 1][cur.y + 3] == '.' || B[cur.x + 1][cur.y + 3] == 0) &&
(B[cur.x + 1][cur.y + 1] == '.' || B[cur.x + 1][cur.y + 1] == 0) &&
(B[cur.x + 1][cur.y + 2] == '.' || B[cur.x + 1][cur.y + 2] == 0) &&
!vis[cur.x + 1][cur.y + 3][cur.ti + 2]) {
vis[cur.x + 1][cur.y + 3][cur.ti + 2] = 1;
q.push(node(cur.x + 1, cur.y + 3, cur.ti + 2));
}
}
}
return 0;
}
int main(int argc, char** argv) {
int t, k;
cin >> t;
while (t--) {
memset(B, 0, sizeof B);
memset(vis, 0, sizeof vis);
cin >> n >> k;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
cin >> B[i][j];
if (B[i][j] == 's') xs = i, ys = j;
}
}
if (BFS())
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int mod = 1e13 + 7;
const int B = sqrt(1e5);
int n, m;
bool used[N];
vector<int> v[N];
vector<int> ans;
void dfs(int x) {
used[x] = true;
for (auto y : v[x]) {
if (used[y]) continue;
dfs(y);
}
ans.push_back(x);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
if (!used[i]) dfs(i);
}
for (auto x : ans) cout << x << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long gi() {
long long x = 0;
bool f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
inline void pi(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) pi(x / 10);
putchar(48 + x % 10);
}
inline void pin(long long x) {
pi(x);
putchar('\n');
}
inline void pib(long long x) {
pi(x);
putchar(' ');
}
const long long N = 5e5 + 5, mo = 1e9 + 7;
long long fa[N], n, m;
long long find(long long x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
inline void mer(long long x, long long y) { fa[find(x)] = find(y); }
signed main() {
n = gi(), m = gi();
for (register long long i = (0); i <= (n * 2 + 3); ++i) fa[i] = i;
for (register long long i = (1); i <= (m); ++i) {
long long x = gi(), y = gi();
char s[10];
scanf("%s", s);
long long l = abs(y - x),
r = ((x + y) < (2 * n - (x + y - 2)) ? (x + y)
: (2 * n - (x + y - 2))),
chk = s[0] == 'o';
mer(l * 2, 2 * r + chk);
mer(l * 2 + 1, 2 * r + (chk ^ 1));
}
for (register long long i = (0); i <= (n + 1); ++i)
if (find(2 * i) == find(2 * i + 1)) {
puts("0");
return 0;
}
long long ans = 1, cnt = 0;
for (register long long i = (0); i <= (2 * n + 3); ++i) cnt += fa[i] == i;
cnt = (cnt - 4) / 2;
for (register long long i = (1); i <= (cnt); ++i) ans = 2 * ans % mo;
pin(ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, b[100005], c[100005], id[200005], cnt = 0, du[100005], a[100005],
cntt = 0;
multiset<long long> e[200005];
void dfs(long long u) {
if (du[u] == 0) {
a[++cntt] = u;
return;
}
for (multiset<long long>::iterator it = e[u].begin(); it != e[u].end();
it = e[u].begin()) {
long long v = *it;
e[u].erase(it);
e[v].erase(e[v].find(u));
du[u]--;
du[v]--;
dfs(v);
}
a[++cntt] = u;
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i < n; i++) {
scanf("%lld", &b[i]);
id[++cnt] = b[i];
}
for (long long i = 1; i < n; i++) {
scanf("%lld", &c[i]);
id[++cnt] = c[i];
}
for (long long i = 1; i < n; i++) {
if (b[i] > c[i]) return puts("-1") * 0;
}
sort(id + 1, id + cnt + 1);
cnt = unique(id + 1, id + cnt + 1) - id - 1;
for (long long i = 1; i < n; i++) {
long long u = lower_bound(id + 1, id + cnt + 1, b[i]) - id;
long long v = lower_bound(id + 1, id + cnt + 1, c[i]) - id;
e[u].insert(v);
e[v].insert(u);
du[u]++;
du[v]++;
}
long long tot = 0, flag = 0, odd;
for (long long i = 1; i <= n; i++) {
if (du[i] & 1) tot++, odd = i;
if (tot > 2) {
flag = 1;
break;
}
}
if (flag || tot == 1) return puts("-1") * 0;
if (!tot)
dfs(1);
else
dfs(odd);
if (cntt != n) return puts("-1") * 0;
for (long long i = 1; i <= cntt; i++) {
printf("%lld ", id[a[i]]);
}
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1510, TN = 2000010;
int f[N][N], a[TN], n, m, rd[N];
vector<int> g;
stack<int> st;
bool check(int x) {
int pos = 0;
if (x & 1)
pos = (x * (x - 1) >> 1) + 1;
else
pos = (x * x >> 1);
return pos <= n;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int s;
s = (int)sqrt((n << 1) - 1) + 1;
for (int i = 1; i <= m; ++i) {
int x;
cin >> x >> x;
g.push_back(x);
}
sort(g.rbegin(), g.rend());
int pos = 0;
for (int l = 1, r = min(s, m), mid = (l + r) >> 1; l <= r; mid = (l + r) >> 1)
if (check(mid))
l = mid + 1, pos = mid;
else
r = mid - 1;
long long ans = 0;
for (int i = 1; i <= pos; ++i) ans += g[i - 1];
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e5 + 50;
vector<pair<long long, long long> > v[MAX];
set<pair<long long, pair<long long, long long> > > sd1[MAX];
long long fad1[MAX];
void dfs1(long long x, long long p) {
long long a, b, c, i, j;
fad1[x] = 0;
sd1[x].clear();
for (auto z : v[x]) {
if (z.first == p) continue;
dfs1(z.first, x);
fad1[x] = max(fad1[x], (fad1[z.first] + z.second));
sd1[x].insert({(fad1[z.first] + z.second), {z.second, z.first}});
}
}
long long find1() {
long long a, b, c, i, j;
a = 1;
pair<long long, pair<long long, long long> > X, Y;
while (true) {
if (sd1[a].size() == 0) break;
auto z = sd1[a].end();
--z;
X = *z;
if (z == sd1[a].begin())
c = 0;
else {
--z;
c = (*z).first;
}
if (X.first > max((X.first - X.second.first), (c + X.second.first))) {
sd1[X.second.second].insert({(c + X.second.first), {X.second.first, a}});
a = X.second.second;
} else
break;
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(25);
long long a, b, c, d, e, f, i, j, k;
long long N, K;
cin >> N >> K;
for (i = 0; i < N - 1; i++) {
cin >> a >> b >> c;
v[a].push_back({b, c});
v[b].push_back({a, c});
}
if (N == 1) {
cout << 0;
return 0;
}
dfs1(1, -1);
a = find1();
dfs1(a, -1);
set<pair<long long, long long> > ss;
auto z = sd1[a].end();
z--;
ss.insert({(*z).first, (*z).second.second});
sd1[a].erase(z);
if (sd1[a].size() > 0) {
z = sd1[a].end();
z--;
ss.insert({(*z).first, (*z).second.second});
sd1[a].erase(z);
}
set<long long> rem;
for (auto z1 : sd1[a]) rem.insert(z1.first);
K--;
while (K > 0 && (!ss.empty())) {
auto Z = *(--ss.end());
ss.erase(Z);
a = Z.second;
if (sd1[a].size() > 0) {
auto z1 = --sd1[a].end();
ss.insert({(*z1).first, (*z1).second.second});
sd1[a].erase(z1);
}
for (auto z2 : sd1[a]) {
rem.insert(z2.first);
}
K--;
}
long long ans = 0;
if (!rem.empty()) (ans = max(ans, *(--rem.end())));
if (!ss.empty()) (ans = max(ans, (*(--ss.end())).first));
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char a[10000000];
int aa[10000000];
int main() {
int n;
while (~scanf("%d", &n)) {
scanf("%s", a);
for (int i = 0; i < n; i++) {
scanf("%d", &aa[i]);
}
int rr = 0;
int ll = 0;
for (int i = 0; i < n; i++) {
if (rr == 0) {
if (a[i] == 'R') {
rr = 1;
}
} else {
if (a[i] == 'L') {
ll = 1;
}
}
}
if (rr == 1 && ll == 1) {
int output = 0x3f3f3f3f;
int posr = -1;
for (int i = 0; i < n; i++) {
if (a[i] == 'R') {
posr = i;
} else {
if (posr == -1)
continue;
else {
output = min(output, (aa[i] - aa[posr]) / 2);
}
}
}
printf("%d\n", output);
} else
printf("-1\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
vector<int> adj1[N], adj2[N];
int bad_col[N];
int comp[N];
int vis[N], col[N];
bool dfs(int x, int c) {
vis[x] = c;
bool ans = true;
for (int ch : adj1[x]) {
if (!vis[ch]) {
comp[ch] = comp[x];
if (!dfs(ch, 3 - c)) {
ans = false;
}
} else {
if (vis[x] == vis[ch]) {
ans = false;
}
}
}
return ans;
}
set<pair<int, int>> new_adj[N][3];
map<pair<int, int>, set<pair<pair<int, int>, pair<int, int>>>> edges;
int new_vis[N][3];
vector<pair<int, int>> roll_back;
bool bp(pair<int, int> x, int c) {
new_vis[x.first][x.second] = c;
roll_back.push_back(x);
bool ans = true;
for (auto ch : new_adj[x.first][x.second]) {
if (!new_vis[ch.first][ch.second]) {
if (!bp(ch, 3 - c)) {
ans = false;
}
} else if (new_vis[ch.first][ch.second] == c) {
ans = false;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
cin >> col[i];
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
if (col[a] == col[b]) {
adj1[a].push_back(b);
adj1[b].push_back(a);
} else {
adj2[a].push_back(b);
adj2[b].push_back(a);
}
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
comp[i] = i;
if (!dfs(i, 1)) {
bad_col[col[i]] = 1;
cnt++;
}
}
}
long long ans = 1ll * cnt * (k - cnt) + 1ll * cnt * (cnt - 1) / 2;
for (int i = 0; i < n; ++i) {
if (!bad_col[col[i]]) {
for (int x : adj1[i]) {
if (!(comp[i] == comp[x] && vis[i] == vis[x])) {
new_adj[comp[i]][vis[i]].insert({comp[x], vis[x]});
}
}
}
}
for (int i = 0; i < n; ++i) {
if (!bad_col[col[i]]) {
for (int x : adj2[i]) {
if (!bad_col[col[x]]) {
int c1 = col[i], c2 = col[x];
int cc1 = comp[i], cc2 = comp[x];
int x1 = vis[i], x2 = vis[x];
if (c1 > c2) {
swap(c1, c2);
swap(cc1, cc2);
swap(x1, x2);
}
edges[{c1, c2}].insert({{cc1, x1}, {cc2, x2}});
}
}
}
}
for (auto &[c1c2, v] : edges) {
for (auto [x, y] : v) {
new_adj[x.first][x.second].insert(y);
new_adj[y.first][y.second].insert(x);
}
bool ok = 0;
for (auto [x, y] : v) {
if (!new_vis[x.first][x.second]) {
ok |= (!bp(x, 1));
}
if (!new_vis[y.first][y.second]) {
ok |= (!bp(y, 1));
}
}
ans += ok;
for (auto [x, y] : v) {
new_adj[x.first][x.second].erase(y);
new_adj[y.first][y.second].erase(x);
}
for (auto [a, b] : roll_back) {
new_vis[a][b] = 0;
}
roll_back.clear();
}
cout << 1ll * k * (k - 1) / 2 - ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int T, N;
char s[100010];
char gao(int x) {
if (x == 0) return 'a';
if (x == 1) return 'A';
return '1';
}
char tp(char c) {
if (c >= 'a' && c <= 'z') return 0;
if (c >= 'A' && c <= 'Z') return 1;
return 2;
}
bool ok() {
int v = 0;
for (int i = 1; i <= N; i++) v |= (1 << tp(s[i]));
return (v == 7);
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%s", s + 1);
N = strlen(s + 1);
if (ok()) goto END;
for (int i = 1; i <= N; i++)
for (int j = 0; j < 3; j++) {
char tmp = s[i];
s[i] = gao(j);
if (ok()) {
goto END;
}
s[i] = tmp;
}
for (int i = 1; i <= N; i++)
for (int k = i + 1; k <= N; k++)
for (int j = 0; j < 3; j++)
for (int l = j + 1; l < 3; l++) {
char tmp1 = s[i], tmp2 = s[k];
s[i] = gao(j);
s[k] = gao(l);
if (ok()) {
goto END;
}
s[i] = tmp1;
s[k] = tmp2;
}
for (int i = 1; i <= 3; i++) s[i] = gao(i - 1);
END:
printf("%s\n", s + 1);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n & 1)
puts("black");
else
puts("white"), puts("1 2");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 10 * 1000 + 10;
pair<int, int> arr[Maxn];
set<pair<int, int> > s;
int n;
void solve(int st, int en) {
if (st == en) return;
int m = (st + en) / 2;
for (int i = st; i <= en; i++)
s.insert(make_pair(arr[m].first, arr[i].second));
solve(st, m);
solve(m + 1, en);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
s.insert(arr[i]);
}
sort(arr, arr + n);
solve(0, n - 1);
cout << s.size() << endl;
for (set<pair<int, int> >::iterator it = s.begin(); it != s.end(); it++)
cout << it->first << " " << it->second << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long INF = 1e9;
const int N = 200031;
int n, p[N], b[N], cycles;
int used[N];
void dfs(int v) {
if (used[v]) return;
used[v] = 1;
dfs(p[v]);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
for (int i = 1; i <= n; i++) {
if (used[i]) continue;
dfs(i);
++cycles;
}
if (cycles == 1) cycles = 0;
int s = 0;
for (int i = 1; i <= n; i++) s += b[i];
s %= 2;
if (s == 0) ++cycles;
cout << cycles << endl;
cin.get();
cin.get();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
scanf("%d", &k);
string str;
cin >> str;
bool used[k];
for (int i = 0; i < k; ++i) used[i] = false;
int left = 0, right = str.size() - 1;
bool ans = true;
while (left <= right) {
char ch_left = str[left];
char ch_right = str[right];
if (ch_left == '?' && ch_right == '?') {
left++;
right--;
continue;
}
if (ch_left != '?' && ch_right == '?') {
ch_right = ch_left;
str[right] = ch_right;
used[ch_right - 'a'] = true;
}
if (ch_left == '?' && ch_right != '?') {
ch_left = ch_right;
str[left] = ch_left;
used[ch_left - 'a'] = true;
}
if (ch_left != '?' && ch_right != '?' && ch_left != ch_right) {
ans = false;
break;
}
if (ch_left != '?' && ch_right != '?' && ch_left == ch_right) {
used[ch_right - 'a'] = true;
used[ch_left - 'a'] = true;
}
left++;
right--;
}
if (str.size() % 2 == 0) {
right = str.size() / 2;
left = right - 1;
} else
left = right = str.size() / 2;
if (ans)
while (left >= 0 && right <= str.size() - 1) {
char ch_left = str[left];
char ch_right = str[right];
if (ch_left == '?' && ch_right == '?') {
char temp = '0';
for (int i = k - 1; i >= 0; --i) {
if (!used[i]) {
temp = i + 'a';
used[i] = true;
break;
}
}
if (temp != '0') {
str[left] = temp;
str[right] = temp;
}
}
left--;
right++;
}
for (int i = 0; i < str.size(); ++i)
if (str[i] == '?') str[i] = 'a';
bool ans1 = true;
for (int j = 0; j < k; j++)
if (!used[j]) ans1 = false;
if (!ans) {
printf("IMPOSSIBLE\n");
} else if (!ans1) {
printf("IMPOSSIBLE\n");
} else if (ans1)
cout << str << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int tree[64][64];
int main() {
int n, m;
cin >> n >> m;
int i, j;
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) cin >> tree[i][j];
int a, b;
cin >> a >> b;
int ans = 64 * 64;
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) {
int k, p;
if (i + a > n || j + b > m) continue;
int tmp = 0;
for (k = i; k < i + a; ++k)
for (p = j; p < j + b; ++p)
if (tree[k][p]) ++tmp;
if (ans > tmp) ans = tmp;
}
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) {
int k, p;
if (i + b > n || j + a > m) continue;
int tmp = 0;
for (k = i; k < i + b; ++k)
for (p = j; p < j + a; ++p)
if (tree[k][p]) ++tmp;
if (ans > tmp) ans = tmp;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1001], minn = 998244353;
string s;
int main() {
cin >> n >> s;
s = ' ' + s;
a[0] = 1;
for (int i = 1; i <= n; i++)
if (s[i] == 'L') {
a[i] = 1;
if (a[i - 1] == 1) {
a[i - 1]++;
for (int j = i - 1; j >= 0; j--)
if (s[j] == '=')
a[j - 1] = a[j];
else if (s[j] == 'L' && a[j - 1] == a[j])
a[j - 1]++;
else
break;
}
} else if (s[i] == 'R')
a[i] = a[i - 1] + 1;
else
a[i] = a[i - 1];
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i;
cin >> n;
vector<long long> a;
long long max = -1, p = -1, ans = -1;
for (i = 0; i < n; i++) {
long long p;
cin >> p;
a.push_back(p);
}
int r = max_element(a.begin(), a.end()) - a.begin();
if (a[r] == 1) {
a[r] = 2;
} else
a[r] = 1;
sort(a.begin(), a.end());
for (i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e6 + 10;
int n, m;
int a[mx], b[mx];
long long pre[mx], cnt[mx];
vector<int> pri;
vector<long long> g;
bool vis[mx];
void init() {
for (int i = 2; i < mx; i++) {
if (!vis[i]) pri.push_back(i);
for (int j : pri) {
if (j * i >= mx) break;
vis[j * i] = 1;
if (i % j == 0) break;
}
}
}
long long get_ans(long long val) {
long long sum = 0;
for (int i = 1; i <= n; i++) {
b[i] = a[i] % val;
sum += b[i];
pre[i] = pre[i - 1] + 1ll * b[i] * i;
cnt[i] = cnt[i - 1] + b[i];
}
long long siz = sum / val;
long long ans = 0, pv = 0, ret = 0;
int pp = 1;
for (int i = 1; i <= siz; i++, ret += val) {
int midk = lower_bound(cnt + pp, cnt + 1 + n, ret + (val + 1) / 2) - cnt;
int k = lower_bound(cnt + midk, cnt + n + 1, ret + val) - cnt;
long long mv = max(0ll, cnt[k] - (ret + val));
long long lv = pre[midk] - pv;
ans += midk * (cnt[midk] - ret) - lv;
long long rv = pre[k] - mv * k - pre[midk];
ans += rv - midk * (cnt[k] - cnt[midk] - mv);
pv = pre[k] - mv * k, pp = k;
}
return ans;
}
int main() {
scanf("%d", &n);
init();
long long sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
sum += a[i];
}
long long tmp = sum, ans = 2e18;
for (int i : pri) {
if (tmp % i == 0) g.push_back(i);
while (tmp % i == 0) tmp /= i;
}
if (tmp != 1) g.push_back(tmp);
for (long long i : g) {
ans = min(ans, get_ans(i));
}
printf("%lld\n", ans == 2e18 ? -1 : ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
char s[N];
int cnt[N];
int ans, pos;
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 1; i < len; ++i)
if (s[i] == s[i - 1])
cnt[pos]++;
else
++pos;
if (s[len - 1] == s[0]) {
cnt[pos]++;
for (int i = 1; i <= pos; ++i)
if (cnt[i])
++ans;
else {
if (i + 1 <= pos) ++ans;
++i;
}
} else {
for (int i = 0; i <= pos; ++i)
if (cnt[i])
++ans;
else {
if (i + 1 <= pos) ++ans;
++i;
}
}
printf("%d\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> u, l;
int main() {
int n, t;
scanf("%d%d", &n, &t);
while (t--) {
int x, y, saber = 0;
char ch;
cin >> x >> y >> ch;
map<int, int>::iterator it;
if (ch == 'U') {
if (u.count(x)) {
printf("0\n");
continue;
}
it = u.lower_bound(x);
if (it == u.end()) {
saber = y;
} else {
saber = y - (it->second);
}
cout << saber << endl;
u[x] = y - saber;
l[y] = x;
} else {
it = l.lower_bound(y);
if (l.count(y)) {
printf("0\n");
continue;
}
if (it == l.end()) {
saber = x;
} else {
saber = x - (it->second);
}
cout << saber << endl;
u[x] = y;
l[y] = x - saber;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, head[100010], o = 0, sz[100010], rt = 0, mx[100010], bel[100010];
long long dis[100010], ans;
set<int> all[100010], mn;
set<pair<int, int> > s;
struct edge {
int to, link, w;
} e[200010];
void add_edge(int u, int v, int w) {
e[++o].to = v, e[o].link = head[u], head[u] = o, e[o].w = w;
e[++o].to = u, e[o].link = head[v], head[v] = o, e[o].w = w;
}
void dfs(int u, int pre) {
sz[u] = 1;
for (int i = head[u]; i; i = e[i].link) {
if (e[i].to == pre) continue;
dis[e[i].to] = dis[u] + e[i].w;
dfs(e[i].to, u);
mx[u] = max(mx[u], sz[e[i].to]);
sz[u] += sz[e[i].to];
}
mx[u] = max(mx[u], n - sz[u]);
if (mx[u] < mx[rt] || !rt) rt = u;
}
void dfs(int u, int pre, int now) {
bel[u] = now;
if (bel[u]) all[bel[u]].insert(u);
for (int i = head[u]; i; i = e[i].link) {
if (e[i].to == pre) continue;
dfs(e[i].to, u, now ? now : e[i].to);
if (u == rt) {
s.insert(make_pair(sz[e[i].to] = all[e[i].to].size() * 2, e[i].to));
mn.insert(*all[e[i].to].begin());
}
}
}
int find(int now) {
int res;
if ((*s.rbegin()).first == n - now + 1 && (*s.rbegin()).second != bel[now]) {
res = *all[(*s.rbegin()).second].begin();
} else {
res = (bel[*mn.begin()] != bel[now] || rt == now) ? *mn.begin()
: *next(mn.begin());
}
mn.erase(res);
if (bel[now]) {
s.erase(make_pair(sz[bel[now]], bel[now]));
sz[bel[now]]--;
s.insert(make_pair(sz[bel[now]], bel[now]));
}
if (bel[res]) {
all[bel[res]].erase(res);
if (!all[bel[res]].empty()) mn.insert(*all[bel[res]].begin());
s.erase(make_pair(sz[bel[res]], bel[res]));
sz[bel[res]]--;
s.insert(make_pair(sz[bel[res]], bel[res]));
}
return res;
}
int main() {
scanf("%d", &n);
if (n == 1) return puts("0\n1"), 0;
for (int i = 1, u, v, w; i < n; i++)
scanf("%d%d%d", &u, &v, &w), add_edge(u, v, w);
dfs(1, 0);
dis[rt] = 0;
dfs(rt, 0);
for (int i = 1; i <= n; i++) ans += 2 * dis[i];
printf("%lld\n", ans);
dfs(rt, 0, 0), mn.insert(rt);
for (int i = 1; i <= n; i++) printf("%d ", find(i));
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[111][4];
int n, m, x;
int main() {
int order[4] = {1, 0, 2, 3};
cin >> n >> m;
int cnt = m;
memset(a, -1, sizeof a);
int x = 0;
for (int i = 0; i < n && cnt; i++) {
for (int j = 0; j < 2 && cnt; j++) {
cnt--;
a[i][j == 0 ? 0 : 3] = ++x;
}
}
for (int i = 0; i < n && cnt; i++) {
for (int j = 0; j < 2 && cnt; j++) {
cnt--;
a[i][j == 0 ? 1 : 2] = ++x;
}
}
int ind = 1;
vector<int> v;
for (int i = 0; i < n && m; i++) {
for (int j = 0; j < 4; j++) {
if (a[i][order[j]] != -1) {
v.push_back(a[i][order[j]]);
m--;
}
}
}
for (int i = 0; i < v.size(); i++) {
printf("%d ", v[i]);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int b, k, a[100005], w;
int main() {
cin >> b >> k;
for (int i = 1; i <= k; i++) {
cin >> a[i];
}
if (b % 2 == 1)
b = 1;
else
b = 0;
if (b == 0) {
if (a[k] % 2 == 1) w++;
}
for (int i = 1; i <= k; i++)
if (a[i] * b % 2 == 1) w++;
if (w % 2 == 1)
cout << "odd" << endl;
else
cout << "even" << endl;
}
| 0 |
#include <bits/stdc++.h>
long long l, r;
int a[70];
int b[70];
int main() {
int t1, t2, i;
long long ans;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
scanf("%I64d%I64d", &l, &r);
t1 = 0;
while (l) {
a[t1] = l & 1;
l >>= 1;
t1++;
}
t1--;
t2 = 0;
while (r) {
b[t2] = r & 1;
r >>= 1;
t2++;
}
t2--;
while (t2 >= 0 && a[t2] == b[t2]) t2--;
if (t2 < 0)
puts("0");
else {
t2++;
ans = 1;
for (i = 1; i <= t2; i++) ans = ans * 2;
ans--;
printf("%I64d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long R = 7 + 1e9, NUMTESTCASE;
const int NN = 10 + 1e6;
const double pi = acos(-1.0);
int di[4] = {1, 0, -1, 0}, dj[4] = {0, 1, 0, -1},
DI[8] = {1, 1, 0, -1, -1, -1, 0, 1}, DJ[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
int n, m, pos;
int main() {
cin >> n >> m >> pos;
m -= n;
int nl = 1, nr = 1, ans = 1;
if (pos == 1) nl = 0;
if (pos == n) nr = 0;
while (m > 0) {
if (nl == pos - 1 && nr == n - pos) {
ans += m / n + (bool)(m % n);
break;
}
m -= nl;
m -= nr;
m--;
nr = min(nr + 1, n - pos);
nl = min(nl + 1, pos - 1);
ans++;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e8;
long long mem[10][1005];
int n, m, c, d, arr[15], brr[15], crr[15], drr[15];
long long dp(int i, int rem) {
if (i > m || rem <= 0) return 0;
if (i == m) return (rem / c) * d;
long long &ret = mem[i][rem];
if (~ret) return ret;
ret = dp(i + 1, rem);
long long sz = arr[i], x = 0;
while (sz - brr[i] >= 0 && rem - crr[i] >= 0) {
sz -= brr[i];
rem -= crr[i];
x++;
ret = max(ret, x * drr[i] + dp(i + 1, rem));
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(mem, -1, sizeof mem);
cin >> n >> m >> c >> d;
for (int i = 0; i < m; i++) {
cin >> arr[i] >> brr[i] >> crr[i] >> drr[i];
}
cout << dp(0, n);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
if (n == 1 && v[0] % 2 != 0) {
cout << -1 << endl;
continue;
}
int even = -1;
for (int i = 0; i < n; i++) {
if (v[i] % 2 == 0) {
even = i;
break;
}
}
if (even == -1) {
cout << 2 << endl;
cout << 1 << " " << 2 << endl;
} else {
cout << 1 << endl;
cout << even + 1 << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
long long _gcd(long long a, long long b) {
if (b == 0) return a;
_gcd(b, a % b);
}
int main() {
int n, s, x, y, res = -1;
cin >> n >> s;
for (int i = 0; i < n; ++i) {
cin >> x >> y;
if (y != 0) x++;
if (x <= s) {
int p = 100 - y;
if (y == 0) p = 0;
res = ((p < res) ? (res) : (p));
}
}
cout << res;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long l;
typedef long long ll;
# define MOD 1000000007
# define PI 3.14
#define vi vector<int>
#define vl vector<l>
#define vll vector<ll>
#define pb push_back
#define pob pop_back
#define f first
#define s second
#define ml map<l,l>
#define mll map<ll,ll>
#define mcl map<char,ll>
# define umll unorderd_map<ll,ll>
# define umcl unordered_map<char,l>
#define pll pair<ll,ll>
# define forl(i,range) for(l i=0;i<range;i++)
# define forll(i,range) for(ll i=0;i<range;i++)
// int ans=upper_bound(start,end ,value)-start;
// auto itr=uper_bound(start,end ,value)-vector.begin();
ll hcf(ll x, ll y) { //returns gcd of two long long ints
if (x == 0) return y;
return hcf(y % x, x);
}
ll lcm(ll a,ll b){
return((a*b)/hcf(a,b));
}
vll all_prime(ll n)
{ vll sieve(n+1,0);
for (ll x = 2; x <= n; x++)
{
if (sieve[x]) continue;
for (int u = 2*x; u <= n; u += x)
{
if(sieve[u]==0)
{
sieve[u]=x;
}
}
}
return sieve;
}
ll power(ll x,ll n)
{
if(n==0)return 1;
ll temp=power(x,n/2);
if(n%2==0) return temp*temp;
else return x*temp*temp;
}
/* ************************************************************************************************************** */
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll t;
cin>>t;
while(t--){
ll n,m,inc=0;
double prod=1;
cin>>n>>m;
ll sum=n;
ll a[n];
forll(i,n){cin>>a[i];}
ll r[m];
double p[m];
forll(i,m)
{cin>>r[i]>>p[i];}
for(ll i=n-1;i>-1;i--)
{
if(i+1==a[i]){
inc++;
sum=i;
}else break;
}
if(inc==n)
{inc=1;cout<<fixed<<setprecision(6)<<float(inc)<<"\n";}
else {
forll(i,m)
{ if(r[i]>=sum){ prod=prod*(1-p[i]);}}
cout<<fixed<<setprecision(6)<<1-prod<<"\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x;
scanf("%d", &x);
return x;
}
int readln() {
int x;
scanf("%d\n", &x);
return x;
}
const int MAX_N = 2 * int(1e5) + 5;
const int MAX_LOG = 19;
struct Node {
int sum;
Node *pLeft, *pRight;
Node(int sum, Node* pLeft, Node* pRight)
: sum(sum), pLeft(pLeft), pRight(pRight){};
};
int n, m, logN, pos, posLeft, posRight, value;
int a[MAX_N], h[MAX_N], start[MAX_N], finish[MAX_N];
int p[MAX_LOG][MAX_N];
vector<int> e[MAX_N];
Node* root[MAX_N];
bool ok[MAX_N];
void dfs(int u) {
ok[u] = false;
for (int i = 1; i <= logN; ++i)
if (h[u] - (1 << i) > 0)
p[i][u] = p[i - 1][p[i - 1][u]];
else
p[i][u] = -1;
start[u] = ++m;
for (int i = 0, sz = (int)e[u].size(); i < sz; ++i) {
int v = e[u][i];
if (ok[v]) {
p[0][v] = u;
h[v] = h[u] + 1;
dfs(v);
}
}
finish[u] = ++m;
}
int lca(int u, int v) {
if (h[u] < h[v]) return lca(v, u);
if (h[u] > h[v])
for (int i = logN; i >= 0; --i)
if (h[u] - (1 << i) >= h[v]) u = p[i][u];
if (u == v) return u;
for (int i = logN; i >= 0; --i)
if (p[i][u] != p[i][v]) {
u = p[i][u];
v = p[i][v];
}
return p[0][u];
}
inline int getSum(Node* p) { return p ? p->sum : 0; }
inline Node* getLeft(Node* p) { return p ? p->pLeft : NULL; }
inline Node* getRight(Node* p) { return p ? p->pRight : NULL; }
Node* build_tree(int l, int r) {
if (l > r) return NULL;
if (l == r) return new Node(0, NULL, NULL);
int mid = (l + r) >> 1;
return new Node(0, build_tree(l, mid), build_tree(mid + 1, r));
}
Node* update(Node* p, int l, int r) {
if (l > r) return NULL;
if (l > pos || r < pos) return p;
if (l == r) return new Node(value, NULL, NULL);
int mid = (l + r) >> 1;
Node* q =
new Node(0, update(getLeft(p), l, mid), update(getRight(p), mid + 1, r));
q->sum = getSum(getLeft(q)) + getSum(getRight(q));
return q;
}
int get(Node* a, Node* b, int l, int r) {
if (l > r || l > posRight || r < posLeft) return 0;
if (posLeft <= l && r <= posRight) return getSum(b) - getSum(a);
int mid = (l + r) >> 1;
return get(getLeft(a), getLeft(b), l, mid) +
get(getRight(a), getRight(b), mid + 1, r);
}
int f(int y1, int y2, int u, int v) {
if (u == -1 || v == -1 || h[u] > h[v]) return 0;
posLeft = start[u], posRight = start[v];
return (h[v] - h[u] + 1) - get(root[y1 - 1], root[y2], 1, m);
}
int findKth(int y1, int y2, int k, int u, int root) {
if (root == -1 || u == -1 || h[root] > h[u]) return -1;
if (k == 1 && a[u] < y1) return u;
for (int i = logN; i >= 0; --i) {
int v = p[i][u];
if (v < 0 || h[v] < h[root]) continue;
int c = f(y1, y2, v, u);
if (c < k) {
k = k - c + (a[v] < y1);
u = v;
}
}
return p[0][u];
}
int solve(int i, int u, int v, int k, int y) {
int r = lca(u, v), pu = p[0][u], pv = p[0][v];
int cu = f(y + 1, i, r, pu) - (a[r] <= y);
if (cu >= k) return findKth(y + 1, i, k, pu, r);
k -= max(cu, 0);
int cv = f(y + 1, i, r, pv) - (r == u && a[r] <= y);
if (cv < k) return -1;
return findKth(y + 1, i, cv - k + 1, pv, r);
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
int r = read();
e[r].push_back(i);
}
logN = 0;
while ((1 << logN) <= n) ++logN;
memset(ok, (true), sizeof(ok));
memset(a, (0), sizeof(a));
int u = e[0][0];
p[0][u] = -1;
h[u] = 1;
m = 0;
dfs(u);
root[0] = build_tree(1, m);
int nQ = read();
for (int i = 1; i <= nQ; ++i) {
int t = read();
if (t == 1) {
int c = read();
a[c] = i;
pos = start[c], value = 1;
Node* tmp = update(root[i - 1], 1, m);
pos = finish[c], value = -1;
root[i] = update(tmp, 1, m);
} else {
root[i] = root[i - 1];
int a, b, k, y;
scanf("%d%d%d%d", &a, &b, &k, &y);
printf("%d\n", solve(i, a, b, k, y));
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> pos;
for (long long i = 0; i < n; i++) {
if (a[i]) {
pos.push_back(i);
}
}
if (pos.size() == 0)
cout << 0;
else {
long long ans = 1;
for (long long i = 0; i < pos.size() - 1; i++)
ans = ans * (pos[i + 1] - pos[i]);
cout << ans;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e7 + 100;
int main() {
long long x[3], y[3], z[3];
for (int a = 0; a < 3; a++) {
scanf("%lld%lld%lld", &x[a], &y[a], &z[a]);
}
long long needspeed = y[0] / x[0];
if (z[0] <= needspeed) {
printf("0\n");
return 0;
}
long long speed1 = y[1], speed2 = y[2];
if (speed1 > needspeed && speed2 > needspeed) {
printf("-1\n");
return 0;
}
if (speed1 > speed2) {
swap(speed1, speed2);
swap(x[1], x[2]);
swap(y[1], y[2]);
swap(z[1], z[2]);
}
long long n = x[0] / x[1] + 1;
long long ans = 1e17;
for (long long a = 0; a <= n; a++) {
long long num = z[1] * a;
if (z[0] <= y[2]) {
if (a * x[1] * y[1] + (x[0] - x[1] * a) * z[0] <= y[0])
ans = min(num, ans);
continue;
}
long long l = 0, r = 1e7;
while (l <= r) {
long long mid = (l + r) / 2;
if (((x[0] - a * x[1] - x[2] * mid) <= 0 &&
a * x[1] * y[1] + (x[0] - a * x[1]) * y[2] <= y[0]) ||
y[0] - a * x[1] * y[1] - mid * x[2] * y[2] >=
max((long long)0, (x[0] - a * x[1] - x[2] * mid) * z[0])) {
r = mid - 1;
ans = min(num + mid * z[2], ans);
} else
l = mid + 1;
}
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long les[300005], cur[300005], mor[300005], freq[300005], ans[300005],
arr[300005];
vector<long long> v;
int block_size;
long long cnt, k;
struct info {
int l, r, id;
} query[300005];
bool cmp(info a, info b) {
int block1 = a.l / block_size, block2 = b.l / block_size;
if (block1 != block2) return block1 < block2;
return a.r > b.r;
}
void addLeft(int idx) {
idx--;
cnt += freq[mor[idx]];
freq[cur[idx]]++;
}
void addRight(int idx) {
cnt += freq[les[idx]];
freq[cur[idx]]++;
}
void rmvLeft(int idx) {
idx--;
freq[cur[idx]]--;
cnt -= freq[mor[idx]];
}
void rmvRight(int idx) {
freq[cur[idx]]--;
cnt -= freq[les[idx]];
}
int main() {
int n, q;
long long x;
scanf("%d %lld", &n, &k);
block_size = sqrt(n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
if (arr[i] == 2) arr[i] = -1;
}
arr[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
arr[i] *= x;
arr[i] += arr[i - 1];
}
for (int i = 0; i <= n; i++) {
v.push_back(arr[i]);
v.push_back(arr[i] + k);
v.push_back(arr[i] - k);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 0; i <= n; i++) {
cur[i] = lower_bound(v.begin(), v.end(), arr[i]) - v.begin();
les[i] = lower_bound(v.begin(), v.end(), arr[i] - k) - v.begin();
mor[i] = lower_bound(v.begin(), v.end(), arr[i] + k) - v.begin();
}
freq[cur[0]] = 1;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d", &query[i].l, &query[i].r);
query[i].id = i;
}
sort(query + 1, query + q + 1, cmp);
int L = 1, R = 0;
for (int i = 1; i <= q; i++) {
while (query[i].l > L) rmvLeft(L++);
while (query[i].r > R) addRight(++R);
while (query[i].l < L) addLeft(--L);
while (query[i].r < R) rmvRight(R--);
ans[query[i].id] = cnt;
}
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a;
string b;
inline bool check(int a) {
string t;
while (a) {
if (a % 10 == 4) {
t += '4';
} else if (a % 10 == 7) {
t += '7';
}
a /= 10;
}
reverse(t.begin(), t.end());
return t == b;
}
int main() {
ios_base ::sync_with_stdio(false);
cin >> a >> b;
for (int i = a + 1;; ++i) {
if (check(i)) {
cout << i;
break;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const long long mod = 1e9 + 7;
const int maxn = 3030;
const int inf = 1e9;
int n, m;
vector<int> g[maxn];
int dist[maxn][maxn];
int farthest[maxn][3], farthestr[maxn][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dist[i][j] = inf;
}
dist[i][i] = 0;
}
for (int x = 1; x <= n; x++) {
queue<int> qq;
qq.push(x);
while (qq.size()) {
int at = qq.front();
qq.pop();
for (int to : g[at]) {
if (dist[x][to] == inf) {
dist[x][to] = dist[x][at] + 1;
qq.push(to);
}
}
}
}
memset(farthest, -1, sizeof(farthest));
memset(farthestr, -1, sizeof(farthestr));
for (int at = 1; at <= n; at++) {
for (int to = 1; to <= n; to++) {
if (at == to) continue;
if (dist[at][to] == inf) continue;
int cur = to;
for (int k = 0; k < 3; k++) {
if (farthest[at][k] == -1 ||
dist[at][farthest[at][k]] < dist[at][cur]) {
swap(farthest[at][k], cur);
}
}
}
for (int to = 1; to <= n; to++) {
if (at == to) continue;
if (dist[at][to] == inf) continue;
int cur = at;
for (int k = 0; k < 3; k++) {
if (farthestr[to][k] == -1 ||
dist[farthestr[to][k]][to] < dist[cur][to]) {
swap(farthestr[to][k], cur);
}
}
}
}
vector<int> ans;
int distans = -inf;
for (int b = 1; b <= n; b++) {
for (int c = 1; c <= n; c++) {
if (b == c) continue;
if (dist[b][c] == inf) continue;
for (int aa = 0; aa < 3; aa++) {
int a = farthestr[b][aa];
if (a == -1) continue;
if (a == c || a == b) continue;
for (int dd = 0; dd < 3; dd++) {
int d = farthest[c][dd];
if (d == -1) continue;
if (a == d) continue;
if (d == b || d == c) continue;
int walk = dist[a][b] + dist[b][c] + dist[c][d];
if (walk > distans) {
ans.clear();
ans.push_back(a);
ans.push_back(b);
ans.push_back(c);
ans.push_back(d);
distans = walk;
}
}
}
}
}
cerr << distans << endl;
assert(ans.size());
for (int i : ans) cout << i << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int c[100005];
struct node {
int f;
int t;
};
int main() {
vector<int> v[100005];
vector<node> v2;
int n, k, cnt = 0, d;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int d;
cin >> d;
if (d == 0) {
cnt++;
}
v[d].push_back(i);
}
if (cnt != 1) {
cout << "-1" << '\n';
return 0;
}
for (int i = 1; i < 100005; i++) {
int cx = 0, in = 0;
for (int j = 0; j < v[i].size(); j++) {
while (in < v[i - 1].size() && c[v[i - 1][in]] >= k) {
in++;
}
if (in == v[i - 1].size()) {
cout << "-1" << '\n';
return 0;
}
node x;
x.f = v[i - 1][in];
x.t = v[i][j];
c[v[i - 1][in]]++;
c[v[i][j]]++;
v2.push_back(x);
}
}
cout << v2.size() << "\n";
for (int i = 0; i < v2.size(); i++) {
cout << v2[i].f << " " << v2[i].t << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, K;
bool a[6][105];
int main() {
cin >> n >> K;
int mid = (1 + n) / 2;
if (K % 2 == 0) {
int k = K / 2;
for (int i = 1; i <= (1 + k) / 2; i++)
a[2][mid - i + 1] = 1, a[3][mid - i + 1] = 1;
for (int i = 1; i <= k - (1 + k) / 2; i++)
a[2][mid + i] = 1, a[3][mid + i] = 1;
} else if (K <= n - 2) {
int k = K;
for (int i = 1; i <= (1 + k) / 2; i++) a[2][mid - i + 1] = 1;
for (int i = 1; i <= k - (1 + k) / 2; i++) a[2][mid + i] = 1;
} else {
for (int i = 2; i <= n - 1; i++) a[2][i] = a[3][i] = 1;
int k = n - K + n - 4;
for (int i = 1; i <= (1 + k) / 2; i++) a[3][mid - i + 1] = 0;
for (int i = 1; i <= k - (1 + k) / 2; i++) a[3][mid + i] = 0;
}
puts("YES");
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++)
if (a[i][j])
cout << '#';
else
cout << '.';
puts("");
}
}
| 4 |
#include <bits/stdc++.h>
double t1, t2, t0;
int dblcmp(double n) { return n < -1e-12 ? -1 : n > 1e-12; }
double fun(int y1, int y2) { return (t1 * y1 + t2 * y2) / (y1 + y2); }
int main() {
int x1, x2;
while (scanf("%lf %lf %d %d %lf", &t1, &t2, &x1, &x2, &t0) != EOF) {
if (dblcmp(t1 - t2) == 0) {
printf("%d %d\n", x1, x2);
} else if (dblcmp(t1 - t0) == 0) {
printf("%d %d\n", x1, 0);
} else if (dblcmp(t2 - t0) == 0) {
printf("%d %d\n", 0, x2);
} else {
int y1 = -1;
int y2 = -1;
double delta = 1e30;
for (int j = 1; j <= x2; j++) {
int i = 0;
double delta_tmp = fun(i, j) - t0;
if (dblcmp(delta_tmp) < 0) {
continue;
} else if (dblcmp(delta_tmp - delta) < 0) {
delta = delta_tmp;
y1 = i;
y2 = j;
} else if (dblcmp(delta_tmp - delta) == 0) {
if (i + j > y1 + y2) {
y1 = i;
y2 = j;
}
}
}
for (int i = 1; i <= x1; i++) {
int j = (int)((t0 - t1) / (t2 - t0) * i) - 1;
if (j < 0) {
j = 0;
}
while (j <= x2 && dblcmp(fun(i, j) - t0) < 0) {
j++;
}
if (j > x2) {
continue;
}
double delta_tmp = fun(i, j) - t0;
if (dblcmp(delta_tmp - delta) < 0) {
delta = delta_tmp;
y1 = i;
y2 = j;
} else if (dblcmp(delta_tmp - delta) == 0) {
if (i + j > y1 + y2) {
y1 = i;
y2 = j;
}
}
}
printf("%d %d\n", y1, y2);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MOD = 1000000007;
int n;
int f[4 * MAXN];
int x[MAXN], y[MAXN];
map<int, set<pair<int, int>>> xs, ys;
bool visited[MAXN];
int ADD(long long a, long long b) { return (a + b) % MOD; }
int MUL(long long a, long long b) { return a * b % MOD; }
int EXP(long long b, int e) {
if (!e) return 1;
if (e % 2)
return MUL(b, EXP(b, e - 1));
else
return EXP(MUL(b, b), e / 2);
}
int DIV(long long a, long long b) { return MUL(a, EXP(b, MOD - 2)); }
int C(int n, int k) { return DIV(f[n], MUL(f[n - k], f[k])); }
int solve(const vector<int>& p) {
vector<int> a, b;
for (const int& i : p) {
a.push_back(x[i]);
b.push_back(y[i]);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
a.erase(unique(a.begin(), a.end()), a.end());
b.erase(unique(b.begin(), b.end()), b.end());
int r = 0;
for (int i = 0; i <= p.size() && i <= a.size() + b.size(); ++i) {
r = ADD(r, C(a.size() + b.size(), i));
}
return r;
}
void dfs(int node, vector<int>& c) {
visited[node] = true;
c.push_back(node);
auto it = xs[y[node]].lower_bound(pair<int, int>(x[node], -1));
if (it != xs[y[node]].begin()) {
it--;
if (!visited[it->second]) dfs(it->second, c);
}
it = xs[y[node]].upper_bound(pair<int, int>(x[node], MAXN));
if (it != xs[y[node]].end()) {
if (!visited[it->second]) dfs(it->second, c);
}
it = ys[x[node]].lower_bound(pair<int, int>(y[node], -1));
if (it != ys[x[node]].begin()) {
it--;
if (!visited[it->second]) dfs(it->second, c);
}
it = ys[x[node]].upper_bound(pair<int, int>(y[node], MAXN));
if (it != ys[x[node]].end()) {
if (!visited[it->second]) dfs(it->second, c);
}
}
int main() {
f[0] = 1;
for (int i = 1; i < 4 * MAXN; ++i) f[i] = MUL(i, f[i - 1]);
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x[i], &y[i]);
xs[y[i]].emplace(pair<int, int>(x[i], i));
ys[x[i]].emplace(pair<int, int>(y[i], i));
}
int sol = 1;
for (int i = 0; i < n; ++i) {
if (!visited[i]) {
vector<int> c;
dfs(i, c);
sol = MUL(sol, solve(c));
}
}
printf("%d", sol);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double INF = 1000000000;
const long long INFll = 1ll * INF * INF;
const long double ldINF = 1e+018;
const long double EPS = 0.000000001;
const int sdx[4] = {-1, 0, 1, 0};
const int sdy[4] = {0, 1, 0, -1};
const int MOD = 1000000007;
int n, m, cnt1 = 0, cnt2 = 0;
vector<int> p(int x) {
vector<int> v;
while (x > 0) {
v.push_back(x % 7);
x /= 7;
}
return v;
}
bool check(vector<int> a, vector<int> b) {
bool f = true;
vector<int> used(7, 0);
for (int i = 0; i < cnt1 - a.size(); i++) used[0]++;
for (int i = 0; i < cnt2 - b.size(); i++) used[0]++;
for (int i = 0; i < a.size(); i++) used[a[i]]++;
for (int i = 0; i < b.size(); i++) used[b[i]]++;
for (int i = 0; i < 7; i++)
if (used[i] > 1) f = false;
return f;
}
int main() {
cin >> n >> m;
int x = n - 1, y = m - 1;
if (x == 0) cnt1 = 1;
if (y == 0) cnt2 = 1;
while (x > 0) {
cnt1++;
x /= 7;
}
while (y > 0) {
cnt2++;
y /= 7;
}
if (cnt1 + cnt2 > 7) {
cout << 0 << endl;
return 0;
}
long long ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (check(p(i), p(j))) ans++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, mod = 1e9 + 7;
const int N = 2e5 + 5;
int aa, bb, ST[4 * N], n, m, i, j, k, ans[N];
pair<int, int> a[N];
pair<pair<int, int>, pair<int, int> > q[N];
vector<pair<pair<int, int>, pair<int, int> > > qu[N];
vector<int> v[N], v2[N];
int update(int k, int bas, int son, int x, int y) {
if (bas > x || son < x) return ST[k];
if (bas == son && bas == x) {
ST[k] = y;
return ST[k];
}
return ST[k] = max(update((k + k), bas, (bas + son >> 1), x, y),
update((k + k + 1), (bas + son >> 1) + 1, son, x, y));
}
int query(int k, int bas, int son, int x, int y) {
if (bas > y || son < x) return 0;
if (x <= bas && son <= y) return ST[k];
return max(query((k + k), bas, (bas + son >> 1), x, y),
query((k + k + 1), (bas + son >> 1) + 1, son, x, y));
}
void solve() {
for (int i = 1; i <= aa; i++) {
sort(v2[i].begin(), v2[i].end());
sort(v[i].begin(), v[i].end());
if (v2[i].empty())
update(1, 1, bb, i, inf);
else
update(1, 1, bb, i, v2[i].front());
}
int cur;
for (int i = 1; i <= aa; i++) {
for (__typeof(qu[i].begin()) it = qu[i].begin(); it != qu[i].end(); it++) {
if (query(1, 1, bb, it->first.first, it->first.second) <=
it->second.first) {
ans[it->second.second] = 1;
}
}
for (__typeof(v[i].begin()) it = v[i].begin(); it != v[i].end(); it++) {
cur = upper_bound(v2[*it].begin(), v2[*it].end(), i) - v2[*it].begin();
if (cur == v2[*it].size())
cur = inf;
else
cur = v2[*it][cur];
update(1, 1, bb, *it, cur);
}
}
}
int main() {
scanf("%d %d %d %d", &bb, &aa, &n, &m);
aa = 100000;
bb = 100000;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
v[a[i].first].push_back(a[i].second);
v2[a[i].second].push_back(a[i].first);
}
for (int i = 1; i <= m; i++) {
scanf("%d %d %d %d", &q[i].first.first, &q[i].first.second,
&q[i].second.first, &q[i].second.second);
qu[q[i].first.first].push_back(
make_pair(make_pair(q[i].first.second, q[i].second.second),
make_pair(q[i].second.first, i)));
}
solve();
for (int i = 1; i <= aa; i++) {
v[i].clear();
v2[i].clear();
qu[i].clear();
}
swap(aa, bb);
for (int i = 1; i <= n; i++) {
swap(a[i].first, a[i].second);
v[a[i].first].push_back(a[i].second);
v2[a[i].second].push_back(a[i].first);
}
for (int i = 1; i <= m; i++) {
swap(q[i].first.first, q[i].first.second);
swap(q[i].second.first, q[i].second.second);
qu[q[i].first.first].push_back(
make_pair(make_pair(q[i].first.second, q[i].second.second),
make_pair(q[i].second.first, i)));
}
solve();
for (int i = 1; i <= m; i++) {
if (ans[i])
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
inline int read() {
char c;
int x;
for (c = getchar(); !isdigit(c); c = getchar())
;
for (x = 0; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return x;
}
const int N = 5e5 + 5;
int n, m, tot, ans, a[N], b[N], pre[N], suf[N];
int tms, dfn[N], low[N], vol, stc[N], num, col[N];
bool ins[N];
std::vector<int> e[N], adj[N], used;
bool compare(int i, int j) { return a[i] < a[j]; }
inline int get(int u, int x) { return u * 2 + x; }
inline void link(int u, int x, int v, int y) {
e[get(u, x)].push_back(get(v, y));
e[get(v, y ^ 1)].push_back(get(u, x ^ 1));
}
void tarjan(int u) {
dfn[u] = low[u] = tms++;
stc[++vol] = u;
int pos = vol;
ins[u] = true;
for (auto v : e[u]) {
if (dfn[v] == -1) {
tarjan(v);
low[u] = std::min(low[u], low[v]);
} else if (ins[v]) {
low[u] = std::min(low[u], dfn[v]);
}
}
if (dfn[u] == low[u]) {
for (int i = pos; i <= vol; i++) {
int u = stc[i];
ins[u] = false;
col[u] = num;
}
vol = pos - 1;
num++;
}
}
bool check(int mid) {
num = 0;
tot = m;
for (int u = 0; u < m * 10; u++) {
e[u].clear();
dfn[u] = -1;
}
for (int s = 1; s <= n; s++) {
for (int _ = 1; _ < adj[s].size(); _++) {
int i = adj[s][_], j = adj[s][_ - 1];
if (a[i] != a[j]) {
continue;
}
link(i, 1, j, 0);
}
for (int _ = 0; _ < adj[s].size(); _++) {
int i = adj[s][_];
if (b[i] > mid) {
link(i, 0, i, 1);
}
pre[i] = ++tot;
suf[i] = ++tot;
}
for (int _ = 0; _ < adj[s].size(); _++) {
int i = adj[s][_];
link(i, 0, pre[i], 0);
if (i != adj[s].front()) {
int j = adj[s][_ - 1];
link(pre[j], 0, i, 1);
link(pre[j], 0, pre[i], 0);
}
link(i, 0, suf[i], 0);
if (i != adj[s].back()) {
int j = adj[s][_ + 1];
link(suf[j], 0, i, 1);
link(suf[j], 0, suf[i], 0);
}
}
}
for (int u = 0; u < m * 10; u++) {
if (dfn[u] == -1) {
tarjan(u);
}
}
for (int i = 0; i < m * 5; i++) {
if (col[get(i, 0)] == col[get(i, 1)]) {
return false;
}
}
return true;
}
int main() {
n = read();
m = read();
for (int i = 0; i < m; i++) {
int u = read(), v = read();
a[i] = read();
b[i] = read();
adj[u].push_back(i);
adj[v].push_back(i);
}
for (int s = 1; s <= n; s++) {
std::sort(adj[s].begin(), adj[s].end(), compare);
for (int _ = 2; _ < adj[s].size(); _++) {
int i = adj[s][_], j = adj[s][_ - 1], k = adj[s][_ - 2];
if (a[i] == a[j] && a[j] == a[k]) {
printf("No\n");
exit(0);
}
}
}
for (int l = 0, r = 1e9, mid; l <= r;) {
mid = l + r >> 1;
if (check(mid)) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
}
if (!check(ans)) {
printf("No\n");
exit(0);
}
for (int i = 0; i < m; i++) {
if (col[get(i, 0)] < col[get(i, 1)]) {
used.push_back(i);
}
}
printf("Yes\n%d %d\n", ans, used.size());
for (auto i : used) {
printf("%d ", i + 1);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long fast_pow(long long base, long long n, long long m) {
if (n == 0) return 1;
if (n == 1) return base;
long long halfn = fast_pow(base, n / 2, m);
if (n % 2 == 0)
return (halfn * halfn) % m;
else
return (((halfn * halfn) % m) * base) % m;
}
long long findMMI_fermat(long long n, long long m) {
return fast_pow(n, m - 2, m);
}
signed main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
vector<long long> a(n);
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
cin >> a[i];
long long k = a[0] % 2;
long long f = 1;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
if (k != a[i] % 2) {
f = 0;
break;
}
}
if (!f)
cout << "NO" << '\n';
else
cout << "YES" << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char e[101][101], c[101], f[101], s[101], d[101];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
int i, j, k, cc = 0, dd = 0;
for (i = 0; i < n; i++) scanf("%s", e[i]);
memset(c, 0, sizeof(c));
memset(d, 0, sizeof(d));
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (e[i][j] == '.') {
c[i]++;
d[j]++;
}
for (i = 0; i < n; i++)
if (c[i] == 0) break;
if (i < n) cc++;
for (i = 0; i < n; i++)
if (d[i] == 0) break;
if (i < n) dd++;
if (cc == 1 && dd == 1)
printf("-1\n");
else {
memset(s, 0, sizeof(s));
if (cc == 0)
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (e[i][j] == '.') {
printf("%d %d\n", i + 1, j + 1);
break;
}
}
else
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (e[j][i] == '.') {
printf("%d %d\n", j + 1, i + 1);
break;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 1;
long long int n, q, a[N], k;
vector<long long int> v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) v.push_back(a[i] - a[i - 1]);
long long int ans = a[n - 1] - a[0];
sort(v.begin(), v.end(), greater<int>());
for (int i = 0; i < k - 1; i++) ans -= v[i];
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = (int)2e5;
int main() {
int n;
scanf("%d", &n);
int p[MAX_N] = {}, a[MAX_N] = {}, b[MAX_N] = {};
for (int i = 0; i < n; i++) scanf("%d", p + i);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", b + i);
vector<int> prs[3][3] = {};
for (int i = 0; i < n; i++) {
a[i]--, b[i]--;
if (b[i] < a[i]) swap(a[i], b[i]);
prs[a[i]][b[i]].push_back(p[i]);
}
for (int i = 0; i < 3; i++)
for (int j = i; j < 3; j++)
sort(prs[i][j].begin(), prs[i][j].end(), greater<int>());
int m;
scanf("%d", &m);
while (m--) {
int c;
scanf("%d", &c);
c--;
int ri = -1, rj = -1;
for (int i = 0; i <= c; i++) {
if (!prs[i][c].empty()) {
if ((ri == -1 && rj == -1) || (prs[i][c].back() < prs[ri][rj].back())) {
ri = i;
rj = c;
}
}
}
for (int i = c; i < 3; i++) {
if (!prs[c][i].empty()) {
if ((ri == -1 && rj == -1) || (prs[c][i].back() < prs[ri][rj].back())) {
ri = c;
rj = i;
}
}
}
if (ri == -1 && rj == -1)
printf("-1 ");
else {
printf("%d ", prs[ri][rj].back());
prs[ri][rj].pop_back();
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt;
bool flag;
char vis[105];
int num[105];
int main() {
while (~scanf("%d", &n)) {
flag = false;
scanf("%s", vis);
memset(num, 0, sizeof(num));
for (int i = 0; i < n; i++) {
if (vis[i] == '*') num[i] = 1;
}
cnt = (n + 1) / 4;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= cnt; j++) {
if (num[i] && num[i + j] && num[i + 2 * j] && num[i + 3 * j] &&
num[i + 4 * j]) {
flag = true;
break;
}
}
}
if (flag)
puts("yes");
else
puts("no");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000;
int n, x, sum;
int num[MAXN], belong[MAXN], front[MAXN], back[MAXN], size[MAXN];
bool f[MAXN];
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; ++i) scanf("%d", &front[i]), back[front[i]] = i;
for (int i = 1; i <= n; ++i)
if (!front[i]) {
++sum;
for (int j = i; j; j = back[j]) belong[j] = sum, num[j] = ++size[sum];
}
memset(f, 0, sizeof(f));
f[0] = 1;
for (int i = 1; i <= sum; ++i)
if (i != belong[x])
for (int j = n; j >= size[i]; --j) f[j] |= f[j - size[i]];
for (int i = 0; i < n; ++i)
if (f[i]) printf("%d\n", i + num[x]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, unsigned long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) {
res = res * x;
}
y = y >> 1;
x = x * x;
}
return res;
}
long long powermod(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) {
res = (res * x) % p;
}
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long Mod(long long x, long long m) { return (x % m + m) % m; }
long long min(long long a, long long b) { return a < b ? a : b; }
long long max(long long a, long long b) { return a > b ? a : b; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long mxn = 1e5 + 5;
long long n;
string s;
long long val[mxn];
long long dp[mxn][4];
string a = "hard";
long long solve(long long ind, long long cur) {
if (cur >= a.size()) {
return 1000000000000000000;
}
if (ind >= n) {
return 0;
}
if (dp[ind][cur] != -1) {
return dp[ind][cur];
}
long long res = 1000000000000000000;
res = min(res, solve(ind + 1, cur + (s[ind] == a[cur])));
res = min(res, val[ind] + solve(ind + 1, cur));
return dp[ind][cur] = res;
}
int32_t main() {
for (long long i = 0; i < mxn; i++) {
for (long long j = 0; j < 4; j++) {
dp[i][j] = -1;
}
}
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n;
cin >> s;
for (long long i = 0; i < n; i++) {
cin >> val[i];
}
cout << solve(0, 0);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int arr[maxn];
int dp[maxn][maxn];
int main() {
int n, q;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &dp[1][i]);
for (int i = 2; i <= n; i++) {
for (int j = i; j <= n; j++) {
dp[i][j] = dp[i - 1][j - 1] ^ dp[i - 1][j];
}
}
for (int i = 2; i <= n; i++) {
for (int j = i; j <= n; j++) {
dp[i][j] = max({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j]});
}
}
scanf("%d", &q);
int l, r;
for (int i = 1; i <= q; i++) {
scanf("%d %d", &l, &r);
printf("%d\n", dp[r - l + 1][r]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int check(int t, int n) {
if (n <= 0) return false;
int cnt1 = 0;
for (int i = 1; i <= n; i <<= 1) {
if (n & i) ++cnt1;
}
return t >= cnt1 && t <= n;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, p;
cin >> n >> p;
for (int t = 1; t < 1000; t++) {
if (check(t, n - p * t)) {
cout << t;
return 0;
}
}
cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
if (b == 0) return a;
return gcd(b, a % b);
}
long long int t, q, n, total = 0;
long long int C[5100][5100];
long long int ans[100050];
string s;
void prec() {
for (int i = (0); i < (5001); i++) {
for (int j = (0); j < (min(i, 5001) + 1); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000007;
}
}
}
}
std::vector<int> t1, t2;
int mi = 1000000;
void solve() {
cin >> n;
int t, w;
if (n == 1) {
scanf("%d %d", &t, &w);
cout << t;
} else {
long long int s1 = 0, s2 = 0;
int l1 = 0, l2 = 0;
for (int i = (0); i < (n); i++) {
scanf("%d %d", &t, &w);
if (t == 1) {
t1.push_back(w);
l1++;
s1 += w;
} else {
l2++;
t2.push_back(w);
s2 += w;
}
}
sort(t1.rbegin(), t1.rend());
sort(t2.rbegin(), t2.rend());
for (int i = (0); i < (t1.size()); i++)
;
for (int i = (0); i < (t2.size()); i++)
;
int temp = 0;
for (int i = (0); i < (l1 + 1); i++) {
for (int j = (0); j < (l2 + 1); j++) {
int ti = i + 2 * j;
int sum = 0;
for (int k = (0); k < (i); k++) {
sum += t1[k];
}
for (int k = (0); k < (j); k++) {
sum += t2[k];
}
sum = (s1 + s2 - sum);
if (sum <= ti) {
mi = min(mi, ti);
}
}
}
cout << mi;
}
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10005];
bool vis[10005][1005];
long long dis[10005][1005];
const long long inf = 1e18 + 7;
struct node {
int pos;
int step;
};
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
}
int g, r;
scanf("%d%d", &g, &r);
sort(a + 1, a + 1 + m);
deque<node> q;
dis[1][0] = 0;
q.push_front(node{1, 0});
vis[1][0] = true;
long long ans = -1;
while (!q.empty()) {
node fa = q.front();
q.pop_front();
if (fa.step == 0) {
long long tmp = n - a[fa.pos];
if (tmp <= g) {
tmp = dis[fa.pos][fa.step] * (g + r) + tmp;
if (ans == -1 || tmp < ans) {
ans = tmp;
}
}
}
if (fa.step == g) {
if (!vis[fa.pos][0]) {
vis[fa.pos][0] = true;
dis[fa.pos][0] = dis[fa.pos][fa.step] + 1;
q.push_back(node{fa.pos, 0});
}
continue;
}
if (fa.pos > 1) {
int pos = fa.pos - 1;
int step = fa.step + a[fa.pos] - a[pos];
if (step <= g && !vis[pos][step]) {
vis[pos][step] = true;
dis[pos][step] = dis[fa.pos][fa.step];
q.push_front(node{pos, step});
}
}
if (fa.pos < m) {
int pos = fa.pos + 1;
int step = fa.step + a[pos] - a[fa.pos];
if (step <= g && !vis[pos][step]) {
vis[pos][step] = true;
dis[pos][step] = dis[fa.pos][fa.step];
q.push_front(node{pos, step});
}
}
}
printf("%lld\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5, M = 1e6 + 5;
long long mod = 1e9 + 7, mod1 = 998244353, mod2 = 1e9 + 9, inf = 1e9 + 7;
long long infll = 1e18 + 7;
string s;
vector<string> a;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s;
string t = "";
for (auto v : s) {
t += v;
if (v == '>') {
a.push_back(t);
t = "";
}
}
a.push_back(t);
long long x = 0;
for (auto v : a) {
if (v.length() == 4) x--;
for (long long i = 0; i < 2 * x; i++) cout << ' ';
cout << v << '\n';
if (v.length() == 3) x++;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
ll power(ll n,ll k)
{
ll s=n;
for(int i=1;i<k;i++)
{
s=(s*n)%(1000000007);
}
return s;
}
int main()
{
ll t;
cin>>t;
while(t--)
{
ll n,f=0,k;
cin>>n>>k;
cout<<power(n,k)<<endl;
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
map<string, int> q;
int n;
string s[70001];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
set<string> sub;
for (int j = 0; j < 9; j++) {
string ss = "";
for (int k = 1; k <= 9 - j; k++) {
ss = ss + s[i][j + k - 1];
sub.insert(ss);
}
}
for (const auto &j : sub) {
q[j]++;
}
}
for (int i = 0; i < n; i++) {
int u = 0;
for (int k = 1; k <= 9; k++) {
for (int j = 0; j + k < 10; j++) {
string subs = s[i].substr(j, k);
if (q[subs] == 1) {
cout << subs << endl;
u = 1;
}
if (u != 0) break;
}
if (u != 0) break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
vector<bool> v(n + 1, true);
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
v[a] = 0;
v[b] = 0;
}
for (int i = 1; i <= n; i++) {
if (v[i] == 1) {
cout << n - 1 << '\n';
for (int j = 1; j <= n; j++) {
if (j == i) continue;
cout << i << ' ' << j << '\n';
}
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
for (int i = 0; i <= s.size(); ++i)
for (int j = 'a'; j <= 'z'; ++j) {
string t = s.substr(0, i) + (char(j)) + s.substr(i);
if (t == string(t.rbegin(), t.rend())) {
cout << t;
return 0;
}
}
cout << "NA";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a, ans;
map<int, int> l;
map<int, int> r;
set<int> num;
int main() {
cin >> n >> a;
num.insert(a);
for (int i = 2; i <= n; i++) {
cin >> a;
set<int>::iterator it = num.upper_bound(a);
if (it != num.end() && l[*it] == 0) {
l[*it] = a;
ans = *it;
} else {
it--;
r[*it] = a;
ans = *it;
}
cout << ans << " ";
num.insert(a);
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
const int N = 1e5 + 10;
const int MOD = 1e9 + 7;
const long double eps = 1e-12;
int n;
long double s[N], f[N], SumS, SumF, res;
int sz[N];
vector<int> e[N];
void dfs(int v, int p) {
sz[v] = 1;
for (int i = 0; i < e[v].size(); i++) {
int u = e[v][i];
if (u == p) continue;
dfs(u, v);
sz[v] += sz[u];
s[v] += s[u];
res += f[v] * s[u] * sz[u];
}
res += (1 - s[v]) * f[v] * (n - sz[v]);
}
int main() {
n = in();
for (int i = 1; i < n; i++) {
int a = in(), b = in();
a--, b--;
e[a].push_back(b);
e[b].push_back(a);
}
for (int i = 0; i < n; i++) {
s[i] = in(), f[i] = in();
SumS += s[i], SumF += f[i];
}
for (int i = 0; i < n; i++) s[i] = s[i] / SumS, f[i] = f[i] / SumF;
dfs(0, 0);
cout.precision(10);
cout << fixed << res;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int INF = 0x3f3f3f3f;
map<long long, long long> mp;
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long cmd, u, v, w;
scanf("%lld", &cmd);
if (cmd == 1) {
scanf("%lld%lld%lld", &u, &v, &w);
while (u != v) {
while (u > v) {
mp[u] += w;
u /= 2;
}
while (v > u) {
mp[v] += w;
v /= 2;
}
}
} else {
scanf("%lld%lld", &u, &v);
long long ans = 0;
while (u != v) {
while (u > v) {
ans += mp[u];
u /= 2;
}
while (v > u) {
ans += mp[v];
v /= 2;
}
}
printf("%lld\n", ans);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x[505], y[505], rod[505], ans[505];
bool vis[505], flag;
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &rod[i]);
}
for (int i = 0; i < 2; i++) {
memset(ans, -1, sizeof(ans));
memset(vis, false, sizeof(vis));
flag = true;
for (int j = i; j < n; j += 2) {
int d =
(abs(x[j] - x[(j + n - 1) % n]) + abs(y[j] - y[(j + n - 1) % n])) +
(abs(x[j] - x[(j + 1) % n]) + abs(y[j] - y[(j + 1) % n]));
for (int k = 0; k < m; k++) {
if (rod[k] == d && !vis[k]) {
vis[k] = true;
ans[j] = k + 1;
break;
}
}
if (ans[j] == -1) {
flag = false;
break;
}
}
if (flag) break;
}
if (!flag)
printf("NO");
else {
printf("YES\n%d", ans[0]);
for (int i = 1; i < n; i++) printf(" %d", ans[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
void in(vector<long long int> &v) {
for (long long int i = 0; i < v.size(); i++) cin >> v[i];
}
void out(vector<long long int> v) {
for (long long int i = 0; i < v.size(); i++) cout << v[i] << ' ';
cout << '\n';
}
void solve() {
long int n, k;
cin >> n >> k;
vector<long long int> a(n), b;
set<long long int> s;
in(a);
for (long long int i = 0; i < n; i++) b.push_back(a[i]);
sort(b.begin(), b.end());
vector<long long int> ans;
for (long long int i = 0; i < n; i++) {
long long int j = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
ans.push_back(j);
}
vector<long long int> v(n, 0);
while (k--) {
long long int x, y;
cin >> x >> y;
if (a[x - 1] > a[y - 1]) v[x - 1]--;
if (a[x - 1] < a[y - 1]) v[y - 1]--;
}
for (long long int i = 0; i < ans.size(); i++) {
ans[i] += v[i];
if (ans[i] < 0) ans[i] = 0;
}
for (auto element : ans) cout << element << " ";
cout << '\n';
;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> G[2010];
int pre[2010], low[2010], idx[2010], dfn, cnt;
stack<int> S;
void dfs(int x) {
pre[x] = low[x] = ++dfn;
S.push(x);
for (int i = 0; i < G[x].size(); i++) {
int nxt = G[x][i];
if (!pre[nxt]) {
dfs(nxt);
low[x] = min(low[x], low[nxt]);
} else if (!idx[nxt]) {
low[x] = min(low[x], pre[nxt]);
}
}
if (low[x] == pre[x]) {
cnt++;
while (1) {
int nxt = S.top();
S.pop();
idx[nxt] = cnt;
if (x == nxt) break;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1, tmp; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &tmp);
if (tmp > 0 && i != j) G[i].push_back(j);
}
}
dfn = cnt = 0;
memset(pre, 0, sizeof pre);
memset(low, 0, sizeof low);
for (int i = 1; i <= n; i++) {
if (!pre[i]) {
dfs(i);
}
}
if (cnt == 1)
puts("YES");
else
puts("NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[200001], BIT[200001];
pair<int, int> p[200001];
pair<int, pair<int, int> > q[200001];
void update(int i, int n, int val) {
while (i <= n) {
BIT[i] += val;
i += i & -i;
}
}
int get(int i) {
int ret = 0;
while (i) {
ret += BIT[i];
i -= i & -i;
}
return ret;
}
bool comp(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
return a.second.first < b.second.first;
}
int main() {
int n, m, i, cnt = 0, l, r, mid, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", a + i);
p[i].first = -a[i];
p[i].second = i;
}
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &q[i].second.first, &q[i].second.second);
q[i].first = i;
}
sort(p + 1, p + n + 1);
sort(q, q + m, comp);
for (i = 0; i < m; i++) {
while (cnt < q[i].second.first) {
update(p[++cnt].second, n, 1);
}
l = 1;
r = n;
while (l <= r) {
mid = (l + r) >> 1;
if (get(mid) >= q[i].second.second) {
k = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
q[i].second.second = a[k];
}
sort(q, q + m);
for (i = 0; i < m; i++) {
if (i) printf("\n");
printf("%d", q[i].second.second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000000;
int main(int argc, char** argv) {
long long n, a, b;
cin >> n >> a >> b;
long long x = min(a, b);
long long sq = pow(6 * n, 0.5) + 1;
long long mx = M * M;
long long ra = a, rb = b;
for (int i = x; i <= sq; i++) {
long long sec;
sec = 6 * n / i + !((6 * n) % i == 0);
if (sec < max(a, b)) sec = max(a, b);
if (i * sec < mx) mx = i * sec, ra = i, rb = sec;
}
mx = ra * rb;
cout << mx << endl;
if (a > b) swap(ra, rb);
cout << ra << " " << rb;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str, t;
cin >> str;
t = str;
for (int(i) = (1); (i) < (int)(((int)(t).size())); (i)++) {
if (t[i] == t[i - 1]) {
char c = 'a';
while (t[i - 1] == c || (i + 1 < ((int)(t).size()) && t[i + 1] == c)) c++;
t[i] = c;
}
}
cout << t << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum, limit, x = 0;
vector<int> s;
vector<pair<int, int>> lowbit;
cin >> sum >> limit;
for (int i = 1; i <= limit; i++) lowbit.push_back(make_pair(i & -i, i));
sort(lowbit.begin(), lowbit.end());
for (int i = lowbit.size() - 1; i >= 0; i--) {
if (x + lowbit[i].first <= sum) {
x += lowbit[i].first;
s.push_back(lowbit[i].second);
}
}
if (x != sum) {
cout << -1;
} else {
cout << s.size() << endl;
for (int i = 0; i < s.size(); i++) cout << s[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int K, n[4], t[4];
int main() {
ios::sync_with_stdio(false);
cin >> K;
for (int i = 1; i <= 3; ++i) {
cin >> n[i];
}
for (int i = 1; i <= 3; ++i) {
cin >> t[i];
}
multiset<int> mySet[4];
for (int i = 1; i <= 3; ++i) {
for (int j = 1; j <= n[i]; ++j) {
mySet[i].insert(0);
}
}
for (int k = 1; k <= K; ++k) {
int cand = *mySet[1].begin();
int sum = t[1];
for (int i = 2; i <= 3; ++i) {
int currCand = *mySet[i].begin();
int x = cand + sum;
if (x < currCand) {
cand += currCand - x;
}
sum += t[i];
}
sum = 0;
for (int i = 1; i <= 3; ++i) {
sum += t[i];
mySet[i].erase(mySet[i].begin());
mySet[i].insert(cand + sum);
}
}
auto it = mySet[3].end();
--it;
cout << *it << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long INF = (long long)1e12 + 10;
long long dp[200005];
long long leftMost[200005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
dp[i] = INF;
}
int pos = 0;
for (int i = 0; i < n; i++) {
while (pos < n) {
if (s[pos] == '1') {
if (pos >= i || i - pos <= k) {
break;
} else {
pos++;
}
} else
pos++;
}
leftMost[i] = pos;
}
dp[n] = 0;
for (int i = n - 1; i >= 0; i--) {
dp[i] = min(dp[i], dp[i + 1] + i + 1);
if (leftMost[i] != n && abs(leftMost[i] - i) <= k) {
dp[max(leftMost[i] - k, 0LL)] =
min(dp[max(leftMost[i] - k, 0LL)], leftMost[i] + 1 + dp[i + 1]);
}
}
cout << dp[0] << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int vis[100000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, ans = 0;
cin >> n >> m;
queue<pair<int, int>> q;
q.push({n, 0});
while (!q.empty()) {
int x = q.front().first, cnt = q.front().second;
q.pop();
if (x > 10000 || x < 0 || vis[x]) continue;
vis[x] = 1;
if (x == m) {
cout << cnt << '\n';
return 0;
}
q.push({x * 2, cnt + 1});
q.push({x - 1, cnt + 1});
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool nl[100001], inr[100001];
pair<bool, int> ms[100000];
int main() {
int n, m, sz = 0;
scanf("%d%d", &n, &m);
char in[3];
for (int i = 0; i < m; ++i) {
int t;
scanf("%s%d", in, &t);
bool out = in[0] == '-';
if (out && inr[t] == false) ++sz;
inr[t] = true;
ms[i] = make_pair(out, t);
}
int z = -1;
for (int i = 0; i < m; ++i) {
bool out;
int t;
tie(out, t) = ms[i];
if (out && sz != 1)
nl[t] = true;
else if (out)
z = t;
if (!out && sz != 0)
nl[t] = true;
else if (!out) {
if (z != -1 && z != t) nl[z] = true, nl[t] = true;
z = -1;
}
if (out)
--sz;
else
++sz;
}
vector<int> an;
for (int i = 1; i < n + 1; ++i)
if (!nl[i]) an.push_back(i);
printf("%d\n", an.size());
for (int i = 0; i < an.size(); ++i) printf("%d ", an[i]);
}
| 5 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll t;
cin>>t;
while(t--){
ll d,k;
cin>>d>>k;
ll x=0,y=0;
bool check=false;
ll player=0;
while((x*x)+(y*y)<=(d*d)){
if (player%2==0){
x+=k;
player++;
}else{
y+=k;
player++;
}
}
if (player%2==0){
cout<<"Ashish\n";
}else{
cout<<"Utkarsh\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> adj, v;
void dfs(long long n, long long p) {
for (long long i = 0; i < adj[n].size(); i++) {
long long nxt = adj[n][i];
if (nxt == p) {
continue;
}
v[n].push_back(nxt);
dfs(nxt, n);
}
}
long long dda = 0;
long long sdfs(long long i) {
long long len = v[i].size();
if (len == 0) return 0;
if (len == 1) return 1 + sdfs(v[i][0]);
long long da1 = 0, da2 = 0;
for (long long ii = 0; ii < len; ii++) {
long long now = 1 + sdfs(v[i][ii]);
if (now > da1) {
da2 = da1;
da1 = now;
} else if (now > da2)
da2 = now;
}
if (da1 + da2 > dda) dda = da1 + da2;
return da1;
}
long long dist = 0;
void chk(long long a, long long p, long long d, long long b) {
if (a == b) {
dist = d;
return;
}
for (long long i = 0; i < adj[a].size(); i++) {
long long nxt = adj[a][i];
if (nxt == p) {
continue;
}
chk(nxt, a, d + 1, b);
}
}
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long TEST_CASE;
cin >> TEST_CASE;
for (long long TEST_NUM = 1; TEST_NUM <= TEST_CASE; TEST_NUM++) {
long long n, a, b, da, db;
cin >> n >> a >> b >> da >> db;
dda = 0;
adj = vector<vector<long long>>(n + 1);
v = vector<vector<long long>>(n + 1);
for (long long i = 1, x, y; i < n; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
if (2 * da >= db) {
cout << "Alice" << '\n';
continue;
}
chk(a, 0, 0, b);
if (dist <= da) {
cout << "Alice" << '\n';
continue;
}
dfs(1, 0);
long long rst = sdfs(1);
rst = max(rst, dda);
if (rst > 2 * da) {
cout << "Bob" << '\n';
} else {
cout << "Alice" << '\n';
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1000 * 100 + 100;
int a[maxN];
int b[maxN];
int que[maxN];
int L[maxN], R[maxN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) b[i] = abs(a[i] - a[i + 1]);
int en = 0;
for (int i = 0; i < n - 1; i++) {
while (en && b[que[en - 1]] < b[i]) en--;
if (en == 0)
L[i] = -1;
else
L[i] = que[en - 1];
que[en++] = i;
}
en = 0;
for (int i = n - 2; i >= 0; i--) {
while (en && b[que[en - 1]] <= b[i]) en--;
if (en == 0)
R[i] = n - 1;
else
R[i] = que[en - 1];
que[en++] = i;
}
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--;
if (r - l == 1)
cout << 0 << '\n';
else {
r--;
long long ans = 0;
for (int j = l; j < r; j++) {
ans += (min(r, R[j]) - j) * 1ll * (j - max(l - 1, L[j])) * 1LL * b[j];
}
cout << ans << '\n';
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
namespace BST {
int cnt, s, a;
struct Node {
int size, value;
Node *left, *right;
Node(int s, int v, Node *a, Node *b) : size(s), value(v), left(a), right(b) {}
Node() {}
} * root[1000000], *father, *st[1000000], t[1000000], *null;
inline void maintain(register Node *cur) {
if (cur->left->size > cur->right->size * 4)
cur->right =
(&(*st[cnt++] = Node(cur->left->right->size + cur->right->size,
cur->right->value, cur->left->right, cur->right))),
st[--cnt] = cur->left, cur->left = cur->left->left;
if (cur->right->size > cur->left->size * 4)
cur->left = (&(*st[cnt++] = Node(cur->left->size + cur->right->left->size,
cur->right->left->value, cur->left,
cur->right->left))),
st[--cnt] = cur->right, cur->right = cur->right->right;
}
int find(int x, Node *cur) {
if (cur->size == 1) return cur->value;
return x > cur->left->size ? find(x - cur->left->size, cur->right)
: find(x, cur->left);
}
int Rank(int x, Node *cur) {
if (cur->size == 1) return 1;
return x > cur->left->value ? Rank(x, cur->right) + cur->left->size
: Rank(x, cur->left);
}
void insert(int x, Node *cur) {
if (cur->size == 1)
cur->left = (&(*st[cnt++] = Node(1, min(cur->value, x), null, null))),
cur->right = (&(*st[cnt++] = Node(1, max(cur->value, x), null, null)));
else
insert(x, x > cur->left->value ? cur->right : cur->left);
if (cur->left->size)
cur->size = cur->left->size + cur->right->size,
cur->value = cur->right->value;
maintain(cur);
}
void erase(int x, Node *cur) {
if (cur->size == 1)
*father = cur == father->left ? *father->right : *father->left;
else
father = cur, erase(x, x > cur->left->value ? cur->right : cur->left);
if (cur->left->size)
cur->size = cur->left->size + cur->right->size,
cur->value = cur->right->value;
maintain(cur);
}
void init() {
null = new Node(0, 0, 0, 0);
for (int i = 0; i < 1000000; ++i)
st[i] = &t[i], root[i] = new Node(1, 0x7f7f7f7f, null, null);
}
} // namespace BST
int head[200006], nex[200006 << 1], to[200006 << 1], ecn = 0;
void ade(int u, int v) { nex[++ecn] = head[u], to[ecn] = v, head[u] = ecn; }
int fa[200006], siz[200006], hea[200006], dep[200006], top[200006], tig[200006],
bac[200006], en[200006], clo;
void dfs(int u, int faa) {
siz[u] = 1, dep[u] = dep[faa] + 1;
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
if (v == faa) continue;
fa[v] = u;
dfs(v, u);
siz[u] += siz[v];
if (!hea[u] || siz[v] > siz[hea[u]]) hea[u] = v;
}
}
void dfss(int u, int too) {
tig[u] = ++clo, bac[clo] = u, en[too] = u, top[u] = too;
if (!hea[u]) return;
dfss(hea[u], too);
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
if (v == fa[u] || v == hea[u]) continue;
dfss(v, v);
}
}
int col[200006];
struct node {
int l, r;
node(int L = 0, int R = 0) : l(L), r(R) {}
} T[200006 << 2], red(0x3f3f3f3f, 0x3f3f3f3f), blu(-0x3f3f3f3f, -0x3f3f3f3f);
int rec[200006];
bool judge(int u, int k, int d) {
int B = BST ::Rank(k + 1, BST ::root[u]) - 1;
int R = BST ::Rank(0x7f7f7f7f, BST ::root[u]) - 1 - B;
return k >= R - B - d;
}
void update(int u, int &k, int d) {
while (!judge(u, k, d)) ++k;
while (judge(u, k - 1, d)) --k;
}
void work(int rt, int u) {
if (col[u] == 0) {
T[rt] = red;
} else if (col[u] == 1) {
T[rt] = blu;
} else {
update(u, T[rt].l, 1);
update(u, T[rt].r, -1);
}
}
node merge(node a, node b) {
node ret;
ret.l = min(max(b.l, a.l), a.r);
ret.r = min(max(b.r, a.l), a.r);
return ret;
}
void pushup(int rt) { T[rt] = merge(T[rt << 1], T[rt << 1 | 1]); }
node query(int rt, int l, int r, int L, int R) {
if (l == L && r == R) return T[rt];
int m = l + r >> 1;
if (R <= m) return query(rt << 1, l, m, L, R);
if (L > m) return query(rt << 1 | 1, m + 1, r, L, R);
return merge(query(rt << 1, l, m, L, m),
query(rt << 1 | 1, m + 1, r, m + 1, R));
}
void build(int rt, int l, int r) {
if (l == r) {
int u = bac[l];
work(rt, u);
if (u == top[u] && fa[u])
BST ::insert((rec[u] = (query(1, 1, n, l, tig[en[u]])).l),
BST ::root[fa[u]]);
return;
}
int mid = l + r >> 1;
build(rt << 1 | 1, mid + 1, r), build(rt << 1, l, mid);
pushup(rt);
}
void mdfy(int rt, int l, int r, int p) {
if (l == r) {
work(rt, bac[l]);
return;
}
int m = l + r >> 1;
if (p <= m)
mdfy(rt << 1, l, m, p);
else
mdfy(rt << 1 | 1, m + 1, r, p);
pushup(rt);
}
void modify(int x, int c) {
col[x] = c;
while (x) {
mdfy(1, 1, n, tig[x]);
x = top[x];
if (fa[x] != 0) {
BST ::erase(rec[x], BST ::root[fa[x]]);
BST ::insert(rec[x] = (query(1, 1, n, tig[x], tig[en[x]]).l),
BST ::root[fa[x]]);
}
x = fa[x];
}
}
int main() {
BST ::init();
cin >> n >> k;
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
ade(u, v), ade(v, u);
}
for (int i = 1; i <= n; ++i) scanf("%d", &col[i]);
dfs(1, 1);
dfss(1, 1);
build(1, 1, n);
int q, opt, v, c;
cin >> q;
while (q--) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d", &v);
printf("%d\n", (query(1, 1, n, tig[v], tig[en[top[v]]]).l) <= -k);
} else if (opt == 2) {
scanf("%d%d", &v, &c);
modify(v, c);
} else {
scanf("%d", &c);
k = c;
}
}
}
| 13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.