solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string str, str1, str2, str3;
int r = 0, i, l, n = 0, u, p, o, m = 0, k;
cin >> str;
str1 = str + str;
cout << str1.find(str, 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000;
int n, q;
int a;
int t, l, r;
map<int, queue<int>> arr;
class BIT {
private:
long long arr[MAXN + 1];
inline int lb(int a) { return a & -a; }
public:
void mdy(int n, int a) {
for (int i = n; i <= MAXN; i += lb(i)) arr[i] += a;
}
long long qry(int n) {
long long sum = 0;
for (int i = n; i; i -= lb(i)) sum += arr[i];
return sum;
}
} bit;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a;
arr[i].push(a);
bit.mdy(i, a);
while (a > 2) {
int c = 0;
for (int j = 1; j * j <= a; j++)
if (a % j == 0) c += 1 + (a / j != j);
a = c;
arr[i].push(a);
}
}
for (int i = 0; i < q; i++) {
cin >> t >> l >> r;
if (t == 1) {
auto it = arr.lower_bound(l);
while (it != arr.end() && it->first <= r) {
int tmp = it->second.front();
it->second.pop();
if (!it->second.size()) {
it++;
arr.erase(prev(it));
continue;
}
bit.mdy(it->first, it->second.front() - tmp);
it++;
}
} else {
cout << bit.qry(r) - bit.qry(l - 1) << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) - 1;
const int DIRX[] = {-1, 0, 0, 1, -1, -1, 1, 1},
DIRY[] = {0, -1, 1, 0, -1, 1, -1, 1};
const double ERR = 1e-9, PI = (2 * acos(0.0));
template <class T>
inline T MIN(T a, T b) {
return ((a < b) ? a : b);
}
template <class T>
inline T MAX(T a, T b) {
return ((b < a) ? a : b);
}
template <class T>
inline void checkMIN(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMAX(T& a, T b) {
if (a < b) a = b;
}
template <class T>
inline T sqr(T x) {
return (x * x);
}
template <class T>
inline T gcd(T a, T b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
template <class T>
void BubbleSort(vector<T>& VT) {
for (int i = (int)VT.size(); i > 0; i--)
for (int j = 1; j < i; j++)
if (VT[j] < VT[j - 1]) swap(VT[j], VT[j - 1]);
}
template <class T>
T fastPow(T Base, T Power) {
T Result = (T)1;
while (Power > 0) {
if (Power & (T)1) Result *= Base;
Power >>= 1;
Base *= Base;
}
return Result;
}
template <class T>
T fastPow(T Base, T Power, T Mod) {
T Result = (T)1;
while (Power > 0) {
if (Power & (T)1) Result = (Result * Base) % Mod;
Power >>= 1;
Base = (Base * Base) % Mod;
}
return Result;
}
int compareDouble(double x, double y) {
double d = x - y;
if (d > ERR) return 1;
if (d < -ERR) return -1;
return 0;
}
int compareDouble(double x, double y, double err) {
double d = x - y;
if (d > err) return 1;
if (d < -err) return -1;
return 0;
}
int main() {
int n, i, x, z = 0;
vector<int> P;
priority_queue<int> N;
cin >> n;
for (i = 0; i < (int)(n); i++) {
cin >> x;
if (x < 0)
N.push(-x);
else if (x > 0)
P.push_back(x);
else
z++;
}
while (((int)(N).size()) >= 2) {
P.push_back(-N.top());
N.pop();
P.push_back(-N.top());
N.pop();
}
if (((int)(P).size()) > 0) {
for (__typeof((P).begin()) it = (P).begin(); it != (P).end(); it++)
cout << (*it) << ' ';
} else if (z) {
for (i = 0; i < (int)(z); i++) cout << (0) << ' ';
} else {
cout << (-N.top()) << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
int n;
int a[N];
vector<int> mas[N];
vector<int> g[N];
int cnt[N], c[N];
int sum[N];
long long answ = 0;
multiset<int> L, R;
void add(int cnt, int x, int st, int lst) {
if (cnt == 3) {
if ((int)mas[x].size() != 0) {
L.insert(st);
R.insert(mas[x][0] - 1);
}
return;
}
if ((int)mas[x].size() < 3 - cnt) {
L.insert(inf);
R.insert(-inf);
} else {
L.insert(mas[x][2 - cnt]);
R.insert((int)mas[x].size() == (3 - cnt) ? (lst - 1)
: (mas[x][3 - cnt] - 1));
}
}
void del(int cnt, int x, int lst) {
if (cnt == 0) return;
if ((int)mas[x].size() < 3 - cnt) {
L.erase(L.find(inf));
R.erase(R.find(-inf));
} else {
L.erase(L.find(mas[x][2 - cnt]));
R.erase(R.find((int)mas[x].size() == (3 - cnt) ? (lst - 1)
: (mas[x][3 - cnt] - 1)));
}
}
void solve(int l, int r) {
if (r - l + 1 < 3) return;
int m = (l + r) / 2;
solve(l, m);
solve(m + 1, r);
int lst = r + 1;
int s = 0;
for (int i = m + 1; i <= r; i++) {
c[a[i]]++;
if (c[a[i]] == 4) {
lst = i;
break;
}
s++;
s -= 3 * (c[a[i]] == 3);
sum[i] = s;
mas[a[i]].push_back(i);
g[s].push_back(i);
}
L.insert(m + 1);
R.insert(r);
int all = 0;
for (int i = m; i >= l; i--) {
cnt[a[i]]++;
if (cnt[a[i]] > 3) break;
if (cnt[a[i]] != 1) all -= 4 - cnt[a[i]];
all += 3 - cnt[a[i]];
del(cnt[a[i]] - 1, a[i], lst);
add(cnt[a[i]], a[i], m + 1, lst);
multiset<int>::iterator it = L.end();
--it;
int ll = *it, rr = *R.begin();
if (ll > rr) continue;
ll = lower_bound(g[all].begin(), g[all].end(), ll) - g[all].begin();
rr = upper_bound(g[all].begin(), g[all].end(), rr) - g[all].begin() - 1;
if (ll <= rr) {
answ += rr - ll + 1;
}
}
for (int i = l; i <= m; i++) cnt[a[i]] = 0;
for (int i = m + 1; i <= r; i++) {
mas[a[i]].clear();
c[a[i]] = 0;
g[sum[i]].clear();
sum[i] = 0;
}
while (!L.empty()) {
L.erase(L.begin());
}
while (!R.empty()) {
R.erase(R.begin());
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
solve(1, n);
cout << answ << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 10;
const int INF = 0x3f3f3f3f;
int T;
int h, g, a[N];
int dep(int u) {
if (a[u] == 0) return 0;
return dep((a[(u << 1)] > a[(u << 1 | 1)] ? (u << 1) : (u << 1 | 1))) + 1;
}
void del(int u) {
if (!a[u]) return;
a[u] = a[(a[(u << 1)] > a[(u << 1 | 1)] ? (u << 1) : (u << 1 | 1))];
del((a[(u << 1)] > a[(u << 1 | 1)] ? (u << 1) : (u << 1 | 1)));
}
vector<int> vc;
void dfs(int u, int d) {
if (!a[u]) return;
while (dep(u) + d > g) vc.push_back(u), del(u);
dfs((u << 1), d + 1);
dfs((u << 1 | 1), d + 1);
}
int main() {
scanf("%d", &T);
while (T--) {
vc.clear();
scanf("%d%d", &h, &g);
fill(a, a + (1 << (h + 1) + 2), 0);
for (int i = 1; i < (1 << h); i++) scanf("%d", &a[i]);
dfs(1, 0);
long long sum = 0;
for (int i = 1; i < (1 << g); i++) sum += a[i];
printf("%lld\n", sum);
for (int v : vc) printf("%d ", v);
puts("");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 20;
const int sq = 600;
vector<int> a[maxn];
vector<pair<int, int> > adj[maxn];
int pos[maxn];
void solve() {
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) adj[i].clear();
for (int i = 0; i < q; i++) {
int k;
cin >> k;
a[i].clear();
while (k--) {
int x;
cin >> x;
x--;
a[i].push_back(x);
}
}
for (int i = 0; i < q; i++)
if ((int)a[i].size() >= sq) {
memset(pos, -1, sizeof pos);
for (int j = 0; j < (int)a[i].size(); j++) pos[a[i][j]] = j;
for (int j = 0; j < q; j++)
if (j > i || (int)a[j].size() < sq) {
int mx = -1;
for (int ind = (int)a[j].size() - 1; ind >= 0; ind--) {
int k = a[j][ind];
if (pos[k] != -1 && mx > pos[k] &&
a[j][ind + 1] != a[i][pos[k] + 1]) {
cout << "Human" << endl;
return;
}
mx = max(mx, pos[k]);
}
}
}
for (int i = 0; i < q; i++)
if ((int)a[i].size() < sq)
for (int j = 0; j < (int)a[i].size(); j++)
for (int k = j + 1; k < (int)a[i].size(); k++) {
int x = a[i][j], y = a[i][k];
adj[x].push_back({y, a[i][j + 1]});
}
memset(pos, -1, sizeof pos);
for (int i = 0; i < n; i++) {
for (auto x : adj[i]) {
if (pos[x.first] != -1 && pos[x.first] != x.second) {
cout << "Human" << endl;
return;
}
pos[x.first] = x.second;
}
for (auto x : adj[i]) pos[x.first] = -1;
}
cout << "Robot" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a, b, p;
long long dp[2001][2001], total[2001], f[2001], g[2001];
long long my_pow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % 998244353ll;
a = (a * a) % 998244353ll, b >>= 1;
}
return ans;
}
void init() {
for (int i = 0; i <= n; i++) dp[0][i] = 0;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) dp[i][j] = 0;
for (int j = 0; j <= i; j++) {
if (j)
dp[i][j] = (dp[i - 1][j - 1] * my_pow(998244353ll + 1 - p, i - j)) %
998244353ll;
dp[i][j] = (dp[i][j] + dp[i - 1][j] * my_pow(p, j)) % 998244353ll;
}
}
total[1] = 1ll;
for (int i = 2; i <= n; i++) {
total[i] = 1ll;
for (int j = 1; j < i; j++)
total[i] = (total[i] + 998244353ll * 998244353ll - total[j] * dp[i][j]) %
998244353ll;
}
}
void solve() {
f[1] = 0, g[1] = 0;
for (int i = 2; i <= n; i++) {
long long Ci2 =
((1ll * i * i - 1ll * i) * my_pow(2, 998244353ll - 2)) % 998244353ll;
for (int j = 1; j < i; j++) {
long long delta = (total[j] * dp[i][j]) % 998244353ll;
g[i] = (g[i] + delta * (f[j] + g[i - j])) % 998244353ll;
}
f[i] = (g[i] * my_pow(998244353ll + 1 - total[i], 998244353ll - 2) +
Ci2 * my_pow(998244353ll + 1 - total[i], 998244353ll - 2)) %
998244353ll;
g[i] = (g[i] + f[i] * total[i]) % 998244353ll;
}
}
int main() {
scanf("%d%lld%lld", &n, &a, &b);
p = (a * my_pow(b, 998244353ll - 2)) % 998244353ll;
init(), solve();
printf("%lld\n", f[n]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
bool compare(T x, U y) {
return (abs(x - y) <= 1e-9);
}
const long long MOD = 1e9 + 7;
const long long N = 2e5 + 5;
vector<long long> adj[N];
vector<long long> vis(N);
vector<long long> in(N);
vector<long long> a(N);
vector<long long> out(N);
void dfs(long long s) {
long long mx_val = 0;
long long sum = 0;
for (auto x : adj[s]) {
if (!vis[x]) {
vis[x] = 1;
dfs(x);
sum += max(0ll, in[x]);
}
}
if (a[s])
in[s] = sum + 1;
else
in[s] = sum - 1;
}
void dfs1(long long s) {
for (auto x : adj[s]) {
if (!vis[x]) {
vis[x] = 1;
out[x] = 0;
if (in[x] >= 0) {
long long rem = in[s] - in[x];
out[x] =
max(out[x],
max({rem, rem + out[s], (a[s]) ? (out[s] + 1) : (out[s] - 1)}));
} else {
out[x] = max(out[x], max({in[s], in[s] + out[s],
(a[s]) ? (out[s] + 1) : (out[s] - 1)}));
}
dfs1(x);
}
}
}
void solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
vis[1] = 1;
dfs(1);
for (long long i = 1; i <= n; i++) vis[i] = 0;
vis[1] = 1;
dfs1(1);
for (long long i = 1; i <= n; i++)
cout << max({in[i], in[i] + out[i], out[i] + ((a[i]) ? 1 : -1)}) << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int n;
char c;
bool neg;
n = 0;
neg = false;
for (c = getchar(); !(c >= '0' && c <= '9') && c != '-'; c = getchar())
;
if (c == '-') {
neg = true;
c = getchar();
}
while ((c >= '0' && c <= '9')) {
n = n * 10 + c - '0';
c = getchar();
}
return neg ? -n : n;
}
int main() {
int t1, t2, x1, x2, t0, k, mi, mj, s;
long long int i, jj, j;
double d, t;
cin >> t1 >> t2 >> x1 >> x2 >> t0;
if (t1 == t2 && t2 == t0) {
cout << x1 << " " << x2 << endl;
return 0;
}
if (t2 == t0) {
cout << 0 << " " << x2 << endl;
return 0;
}
if (t1 == t0) {
cout << x1 << " " << 0 << endl;
return 0;
}
d = double(0x3f3f3f3f);
s = -0x3f3f3f3f;
for (i = (0LL); i < ((long long int)x1 + 1LL); i++) {
jj = (i * (long long int)(t0 - t1)) / (long long int)(t2 - t0);
if (i == 0LL) {
jj = x2;
}
for (k = (-2); k < (3); k++) {
j = jj + (long long int)k;
if (j < 0LL || j > (long long int)x2 || (i + j) == 0LL) {
continue;
}
t = double((long long int)t1 * i + (long long int)t2 * j) / double(i + j);
if (t > double(t0) || fabs(t - double(t0)) < 1e-9) {
if ((t - double(t0)) < d) {
mi = (int)i;
mj = (int)j;
s = mi + mj;
d = t - double(t0);
} else if (fabs(d - t + double(t0)) < 1e-9 && (int)(i + j) > s) {
mi = (int)i;
mj = (int)j;
s = mi + mj;
}
}
}
}
cout << mi << " " << mj << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
n = pow(2, n);
cout << m % n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N, i, j, ans;
string str;
vector<string> v11, v12, v13, v14, v21, v22, v23, v24;
cin >> N;
for (i = 0; i < N; i++) {
cin >> str;
if (str.length() == 1) {
v11.push_back(str);
} else if (str.length() == 2) {
v12.push_back(str);
} else if (str.length() == 3) {
v13.push_back(str);
} else if (str.length() == 4) {
v14.push_back(str);
}
}
for (i = 0; i < N; i++) {
cin >> str;
if (str.length() == 1) {
v21.push_back(str);
} else if (str.length() == 2) {
v22.push_back(str);
} else if (str.length() == 3) {
v23.push_back(str);
} else if (str.length() == 4) {
v24.push_back(str);
}
}
ans = 0;
for (i = 0; i < v21.size(); i++) {
for (j = 0; j < v11.size(); j++) {
if (v21[i] == v11[j]) {
v11[j] = "";
break;
}
}
if (j == v11.size()) ans += 1;
}
for (i = 0; i < v22.size(); i++) {
for (j = 0; j < v12.size(); j++) {
if (v22[i] == v12[j]) {
v12[j] = "";
break;
}
}
if (j == v12.size()) ans += 1;
}
for (i = 0; i < v23.size(); i++) {
for (j = 0; j < v13.size(); j++) {
if (v23[i] == v13[j]) {
v13[j] = "";
break;
}
}
if (j == v13.size()) ans += 1;
}
for (i = 0; i < v24.size(); i++) {
for (j = 0; j < v14.size(); j++) {
if (v24[i] == v14[j]) {
v14[j] = "";
break;
}
}
if (j == v14.size()) ans += 1;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename L>
bool smax(T &x, L y) {
return x < y ? (x = y, true) : false;
}
template <typename T, typename L>
bool smin(T &x, L y) {
return y < x ? (x = y, true) : false;
}
int root(int u, int c);
void merge(int u, int v, int c);
const int MAXN = 1e5 + 15;
unordered_map<int, int> par[MAXN], dp[MAXN];
int n, m, q;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cerr << "HELLO WORLD :)\n";
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
merge(a, b, c);
}
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
if (par[u].size() > par[v].size()) swap(u, v);
if (!dp[u].count(v)) {
int &res = dp[u][v];
for (auto c : par[u])
if (par[v].count(c.first) && root(v, c.first) == root(u, c.first))
res++;
}
cout << dp[u][v] << '\n';
}
return false;
}
int root(int u, int c) {
return (par[u][c] < 0 ? u : par[u][c] = root(par[u][c], c));
}
void merge(int u, int v, int c) {
if (!par[u].count(c)) par[u][c] = -1;
if (!par[v].count(c)) par[v][c] = -1;
u = root(u, c);
v = root(v, c);
if (v == u) return;
if (par[v][c] > par[u][c]) swap(u, v);
par[v][c] += par[u][c];
par[u][c] = v;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1e3) + 15;
const int mod = (1e9) + 7;
const long long int inf = (1e12) + 3;
long long int n, m, x, y;
string s;
long long int t[maxn], c[maxn], a[maxn][maxn], b[maxn][maxn];
vector<pair<long long int, int> > edge[maxn], edge2[maxn];
set<pair<long long int, int> > st;
bool mark[maxn];
void di1(int source, int q) {
mark[q] = 1;
for (pair<long long int, int> u : edge[q])
if (!mark[u.first])
st.insert(pair<long long int, int>(u.second + a[source][q], u.first));
if (st.size()) {
pair<long long int, int> z = (*st.begin());
if (!mark[z.second])
a[source][z.second] = min(z.first, a[source][z.second]);
mark[z.second] = 1;
if (st.size()) st.erase(z), di1(source, z.second);
}
}
void di2(int source, int q) {
mark[q] = 1;
for (pair<long long int, int> u : edge2[q])
if (!mark[u.first])
st.insert(pair<long long int, int>(u.second + b[source][q], u.first));
pair<long long int, int> z = (*st.begin());
if (!mark[z.second]) b[source][z.second] = min(z.first, b[source][z.second]);
mark[z.second] = 1;
if (st.size()) st.erase(z), di2(source, z.second);
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
;
cin >> n >> m >> x >> y;
if (x == y) cout << "0" << endl, exit(0);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) a[i][j] = inf, b[i][j] = inf;
a[i][i] = 0, b[i][i] = 0;
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w, edge[--u].push_back(pair<long long int, int>(--v, w)),
edge[v].push_back(pair<long long int, int>(u, w));
}
if (edge[x - 1].size() <= 0 || edge[y - 1].size() <= 0)
cout << -1 << endl, exit(0);
for (int i = 0; i < n; i++) cin >> t[i] >> c[i];
for (int i = 0; i < n; i++)
di1(i, i), memset(mark, 0, sizeof mark + 1), st.clear();
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i][j] <= t[i] && i != j)
edge2[i].push_back(pair<long long int, int>(j, c[i]));
x--;
di2(x, x);
if (b[x][--y] == inf || b[x][y] == 0) cout << -1 << endl, exit(0);
cout << b[x][y] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAS = 200002;
int main() {
int n;
cin >> n;
int doors[MAS];
int c1 = 0, c0 = 0;
for (int i = 1; i <= n; i++) {
cin >> doors[i];
if (doors[i] == 0)
c0++;
else
c1++;
}
for (int i = 1; i <= n; i++) {
if (doors[i] == 0) {
c0--;
if (c0 == 0) {
cout << i << endl;
return 0;
}
} else {
c1--;
if (c1 == 0) {
cout << i << endl;
return 0;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pl = pair<ll, ll>;
const ll LNF = ~(1LL << 63);
ll n;
ll a[12], p[12], isp[12], nump[12];
class dsu {
private:
ll n;
vector<ll> pa, sz;
public:
dsu(ll _n) {
n = _n;
pa.resize(n + 1);
iota(pa.begin(), pa.end(), 0);
sz.resize(n + 1, 0);
}
void setsizes() {
for (int i = 1; i <= n; i++) sz[i] = (nump[i] != 1);
}
inline ll Find(int x) { return (x == pa[x]) ? x : (pa[x] = Find(pa[x])); }
inline bool Union(int x, int y) {
x = Find(x), y = Find(y);
if (x == y) return false;
pa[x] = y;
sz[y] += sz[x];
return true;
}
inline ll getsize(int x) { return sz[x]; }
};
ll check(ll depth) {
ll sol = LNF;
for (int i = depth; i <= n; i++)
if (a[i] % a[depth] == 0) {
p[depth] = i;
sol = min(sol, check(depth + 1));
}
if (depth > n) {
ll newa[12];
for (int i = 1; i <= n; i++) newa[i] = a[i];
dsu d(n);
d.setsizes();
for (int i = n; i >= 1; i--)
if (d.Union(i, p[i])) {
if (newa[p[i]] % a[i] != 0) return LNF;
newa[p[i]] /= a[i];
}
set<ll> groups;
for (int i = 1; i <= n; i++) groups.insert(d.Find(i));
ll res = ((ll)groups.size() > 1);
for (auto group : groups) {
res += nump[group] + d.getsize(group);
}
return res;
}
return sol;
}
void precalc() {
for (int i = 1; i <= n; i++) {
ll ca = a[i];
ll res = 0, d;
for (d = 2; d * d <= ca; d++)
while (ca % d == 0) res++, ca /= d;
if (ca > 1) res++;
nump[i] = res;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
precalc();
cout << check(1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 5;
int main() {
int n;
scanf("%d", &n);
bool isP[maxn];
int P[maxn], ans[maxn];
int total = 0;
memset(isP, true, sizeof(isP));
memset(P, 0, sizeof(P));
memset(ans, 0, sizeof(ans));
isP[0] = isP[1] = false;
for (int i = 2; i <= n; i++) {
if (isP[i]) {
P[++total] = i;
ans[i] = total;
}
for (int j = 1; j <= total && i * P[j] <= n; j++) {
isP[i * P[j]] = false;
ans[i * P[j]] = ans[P[j]];
if (!(i % P[j])) break;
}
}
for (int i = 2; i <= n; i++) {
if (i != 2) putchar(' ');
printf("%d", ans[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int mod = 1000000007;
int n;
int pw2[540], size[540];
int main() {
int i, x;
long long s = 0;
scanf("%d", &n);
for (*pw2 = i = 1; i <= n; ++i)
pw2[i] = pw2[i - 1] * 2 % mod, scanf("%d", &x), ~x && ++size[x];
for (i = 1; i <= n; ++i) s -= pw2[size[i]] - 1;
s = (s + pw2[n - 1] - 1) % mod;
printf("%d\n", int(s + (s >> 63 & mod)));
return 0;
}
| 12 |
#include <bits/stdc++.h>
char g[1000][1001];
bool vst[1000][1000];
void change_color(int n, int m, int x, int y) {
bool used[10] = {0};
char ch = g[x][y];
used[ch - '0'] = true;
const int cx[] = {-1, 1, 0, 0};
const int cy[] = {0, 0, 1, -1};
int qx[10], qy[10], front = 0, rear = 1;
qx[0] = x, qy[0] = y;
memset(vst, 0, sizeof(vst));
vst[x][y] = 1;
while (front < rear) {
int i = qx[front], j = qy[front++];
for (int k = 0; k < 4; k++) {
int ii = i + cx[k], jj = j + cy[k];
if (ii >= 0 && ii < n && jj >= 0 && jj < m) {
if (g[ii][jj] == ch && !vst[ii][jj])
vst[ii][jj] = 1, qx[rear] = ii, qy[rear++] = jj;
else if (isdigit(g[ii][jj]))
used[g[ii][jj] - '0'] = 1;
}
}
}
for (int i = 9; i >= 0; i--)
if (!used[i]) {
for (int j = 0; j < rear; j++) g[qx[j]][qy[j]] = '0' + i;
break;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", g[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (j + 1 < m && g[i][j] == '.' && g[i][j + 1] == '.') {
bool used[10] = {0};
if (i > 0) {
if (isdigit(g[i - 1][j])) used[g[i - 1][j] - '0'] = true;
if (isdigit(g[i - 1][j + 1])) used[g[i - 1][j + 1] - '0'] = true;
}
if (i + 1 < n) {
if (isdigit(g[i + 1][j])) used[g[i + 1][j] - '0'] = true;
if (isdigit(g[i + 1][j + 1])) used[g[i + 1][j + 1] - '0'] = true;
}
if (j > 0 && isdigit(g[i][j - 1])) used[g[i][j - 1] - '0'] = true;
if (j < m - 1 && isdigit(g[i][j + 1])) used[g[i][j + 1] - '0'] = true;
for (int k = 0; k < 10; k++)
if (!used[k]) {
g[i][j] = g[i][j + 1] = '0' + k;
break;
}
j++;
}
}
for (int j = 0; j < m; j++)
for (int i = 0; i < n; i++) {
if (i + 1 < n && g[i][j] == '.' && g[i + 1][j] == '.') {
bool used[10] = {0};
if (j > 0) {
if (isdigit(g[i][j - 1])) used[g[i][j - 1] - '0'] = true;
if (isdigit(g[i + 1][j - 1])) used[g[i + 1][j - 1] - '0'] = true;
}
if (j + 1 < m) {
if (isdigit(g[i][j + 1])) used[g[i][j + 1] - '0'] = true;
if (isdigit(g[i + 1][j + 1])) used[g[i + 1][j + 1] - '0'] = true;
}
if (i > 0 && isdigit(g[i - 1][j])) used[g[i - 1][j] - '0'] = true;
if (i < n - 1 && isdigit(g[i + 1][j])) used[g[i + 1][j] - '0'] = true;
for (int k = 9; k >= 0; k--)
if (!used[k]) {
g[i][j] = g[i + 1][j] = '0' + k;
break;
}
i++;
}
}
bool ans = true;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] == '.') {
if (i > 0 && isdigit(g[i - 1][j])) {
if (i + 1 < n && g[i + 1][j] == g[i - 1][j])
change_color(n, m, i + 1, j);
if (j > 0 && g[i][j - 1] == g[i - 1][j]) change_color(n, m, i, j - 1);
if (j + 1 < m && g[i][j + 1] == g[i - 1][j])
change_color(n, m, i, j + 1);
g[i][j] = g[i - 1][j];
} else if (i + 1 < n && isdigit(g[i + 1][j])) {
if (j > 0 && g[i][j - 1] == g[i + 1][j]) change_color(n, m, i, j - 1);
if (j + 1 < m && g[i][j + 1] == g[i + 1][j])
change_color(n, m, i, j + 1);
g[i][j] = g[i + 1][j];
} else if (j > 0 && isdigit(g[i][j - 1])) {
if (j + 1 < m && g[i][j + 1] == g[i][j - 1])
change_color(n, m, i, j + 1);
g[i][j] = g[i][j - 1];
} else if (j + 1 < m && isdigit(g[i][j + 1])) {
g[i][j] = g[i][j + 1];
} else {
ans = false;
i = n, j = m;
}
}
if (ans)
for (int i = 0; i < n; i++) puts(g[i]);
else
puts("-1");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> M;
int grundy(int a) {
if (M.count(a)) return M[a];
vector<int> tmp;
for (int p = 1; (a >> p) != 0; ++p) {
int lh = a & ((1 << p) - 1);
int uh = (a >> p);
tmp.push_back(grundy(lh | uh));
}
int gr = 0;
sort(tmp.rbegin(), tmp.rend());
while (tmp.size() && gr == tmp.back()) {
while (tmp.size() && gr == tmp.back()) tmp.pop_back();
++gr;
}
return M[a] = gr;
}
map<int, int> pr;
void load(int a) {
for (int p = 2; p * p <= a; ++p) {
int pw = 0;
while (a % p == 0) ++pw, a /= p;
if (pw) pr[p] |= 1 | (1 << pw);
}
if (a != 1) pr[a] |= 3;
}
int main() {
M[1] = 0;
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
load(a);
}
int nim = 0;
for (auto &p : pr) {
nim ^= grundy(p.second);
}
if (nim == 0)
printf("Arpa\n");
else
printf("Mojtaba\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int h, m, s, t1, t2;
int main() {
cin >> h >> m >> s >> t1 >> t2;
if (t1 > t2) swap(t1, t2);
int x2 = t1 * 5;
int y2 = t2 * 5;
if ((h >= t1 && h < t2) || (m >= x2 && m < y2) || (s >= x2 && s < y2)) {
} else {
cout << "YES";
return 0;
}
if ((h >= t2 || h < t1) || (m >= y2 || m < x2) || (s >= y2 || s < x2)) {
} else {
cout << "YES";
return 0;
}
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2000000;
int i, n, j, f[Maxn], vis[Maxn], len, cs;
char s[Maxn];
int work(int num) {
int ans = 0, p = 1;
while (num) {
if (num & 1)
ans += 0;
else
ans += p;
p *= 2;
num /= 2;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
long long ans = 0;
for (i = n; i >= 0; i--)
if (!vis[i]) {
int p = work(i);
ans += 2 * (p ^ i);
vis[p] = i;
vis[i] = p;
}
cout << ans << endl;
for (i = 0; i <= n; i++) cout << vis[i] << ' ';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
vector<vector<int>> r(n, vector<int>(3));
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) cin >> r[i][j];
}
int m;
cin >> m;
vector<vector<int>> w(m, vector<int>(3));
for (int i = 0; i < m; i++) {
for (int j = 0; j < 3; j++) cin >> w[i][j];
}
int ans = 0;
for (int i = 0; i < n; i++) {
int res = INT_MAX;
int t = 2 * (r[i][0] + r[i][1]);
int h = r[i][2];
for (int j = 0; j < m; j++) {
int p;
if (h > w[j][0]) continue;
if (w[j][1] >= t) {
if (w[j][0] >= h) {
p = w[j][2];
res = min(res, w[j][2]);
continue;
}
}
int a = ceil(1.0 * t / w[j][1]);
if (h > w[j][0]) {
continue;
}
int b = w[j][0] / h;
int c = ceil(1.0 * a / b);
p = w[j][2] * c;
res = min(res, w[j][2] * c);
}
ans += res;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << max(n - 1, m - 1) << " " << n + m - 1 - max(n - 1, m - 1) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int prod(long long int a, long long int b) {
return (a * b) % 998244353;
}
long long int sum(long long int a, long long int b) {
return (a + b) % 998244353;
}
long long int sub(long long int a, long long int b) {
return (a + (998244353 - b)) % 998244353;
}
pair<long long int, long long int> gcdex(long long int a, long long int b) {
if (b == 0) {
pair<long long int, long long int> res(1LL, 0LL);
return res;
} else {
pair<long long int, long long int> r = gcdex(b, a % b);
pair<long long int, long long int> res(r.second,
r.first - (a / b) * r.second);
return res;
}
}
std::unordered_map<long long int, long long int> invmap;
long long int inv(long a) {
if (invmap.find(a) != invmap.end()) {
return invmap[a];
} else {
pair<long long int, long long int> r = gcdex(a, 998244353);
long long int b = ((r.first % 998244353) + 998244353) % 998244353;
return invmap[a] = b;
}
}
long long int frac(long long int a, long long int b) {
return (a * inv(b)) % 998244353;
}
string decode(long long int x) {
for (int b = 1; b < x; b++) {
long long int a = (x * a) % 998244353;
if (a < b) {
stringstream ss;
ss << a << "/" << b;
return ss.str();
}
}
return "0";
}
int main() {
int n;
scanf("%d", &n);
long long int q[n + 1];
memset(q, 0, sizeof(q[0]) * (n + 1));
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
q[x]++;
}
for (int i = 0; i <= n; i++) {
}
cout << endl;
long long int dp[n][n + 1];
for (int k = n - 1; k >= 0; k--) {
for (int i = n; i >= 1; i--) {
if (k == n - 1) {
dp[k][i] = 0LL;
} else {
if (i >= n - 1) {
dp[k][i] = frac(q[i] - 1, n - 1 - k);
} else {
long tot =
sum(q[i], prod(998244353 + dp[k + 1][i + 1] - 1, q[i + 1]));
dp[k][i] = sum(frac(tot, n - 1 - k), dp[k][i + 1]);
}
}
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i <= n; i++) {
}
}
long long int res = 0;
for (int i = 1; i <= n; i++) {
res = sum(res, prod(dp[0][i], q[i]));
}
printf("%d\n", frac(res, n));
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * flag;
}
double calc(double b, double h) {
double dlen = sqrt(b * b + h * h);
return b * h / dlen;
}
int main() {
double h, w, r;
cin >> r;
for (w = 1; w <= 10; ++w)
for (h = 1; h <= 10; ++h)
if (abs(r - calc(w / 2, h)) <= 1e-6) {
cout << w << " " << h << endl;
return 0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans;
int n, m;
void init() { scanf("%d %d", &n, &m); }
void work() {
if (n / 2 + 1 > m) {
ans = m + 1;
} else {
ans = m - 1;
}
if (ans == 0 || ans > n) ans = 1;
printf("%d\n", ans);
}
int main() {
init();
work();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char string_in_buffer[(int)260];
void fast_scan(int &first) { scanf("%d", &first); }
void fast_scan(long long &first) { scanf("%lld", &first); }
void fast_scan(unsigned long long &first) { scanf("%llu", &first); }
void fast_scan(double &first) { scanf("%lf", &first); }
void fast_scan(long double &first) { scanf("%Lf", &first); }
void fast_scan(char &first) {
scanf("%c", &first);
if (first == '\n') {
fast_scan(first);
}
}
void fast_scan(string &first) {
scanf("%s", string_in_buffer);
first = string(string_in_buffer);
}
template <class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &first : v) fast_scan(first);
}
void fast_print(const int &first) { printf("%d", first); }
void fast_print(const long long &first) { printf("%lld", first); }
void fast_print(const unsigned long long &first) { printf("%llu", first); }
void fast_print(const double &first) { printf("%.15lf", first); }
void fast_print(const long double &first) { printf("%.15Lf", first); }
void fast_print(const char &first) { printf("%c", first); };
void fast_print(const string &first) { printf("%s", first.c_str()); }
template <class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(" ");
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print("\n");
fast_print(v[i]);
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
} // namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace typedefs {}
namespace numbers_operation {
template <class T>
T floor_mod(T a, T b) {
if (a % b == 0) return 0;
if (a >= 0 && b >= 0) return a % b;
if (a <= 0 && b <= 0) return a % b;
return abs(b) - (abs(a) % abs(b));
}
} // namespace numbers_operation
using namespace numbers_operation;
using namespace typedefs;
signed main(signed argc, char *argv[]) {
int n;
cin, n;
vector<int> v(n);
cin, v;
int ones = 0;
for (int i = 0; i < n; i++) {
ones += v[i];
}
int _max = 0;
for (int t = 0; t <= ones; t++) {
int cur = 0;
int zeros = 0;
for (int j = 0; j < n; j++) {
cur += v[j];
zeros += !v[j];
if (cur > t) {
break;
}
}
_max = max(_max, zeros + ones - t);
}
smart_io::precall_print();
cout, _max;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 20;
long long n;
long long seg[4 * maxn], a[maxn];
void up(long long l, long long r, long long val, long long v = 1,
long long tl = 1, long long tr = n) {
if (l > r) return;
if (tl == l && tr == r) {
seg[v] = min(seg[v], val);
return;
}
long long tm = (tl + tr) >> 1;
up(l, min(tm, r), val, 2 * v, tl, tm);
up(max(tm + 1, l), r, val, 2 * v + 1, tm + 1, tr);
}
long long qu(long long pos, long long v = 1, long long tl = 1,
long long tr = n) {
if (tl == tr) return seg[v];
long long tm = (tl + tr) >> 1;
if (pos <= tm)
return min(seg[v], qu(pos, 2 * v, tl, tm));
else
return min(seg[v], qu(pos, 2 * v + 1, tm + 1, tr));
}
void build(long long v = 1, long long tl = 1, long long tr = n) {
if (tl == tr) {
seg[v] = a[tl];
return;
}
long long tm = (tl + tr) >> 1;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
seg[v] = max(seg[2 * v], seg[2 * v + 1]);
}
void upd(long long pos, long long val, long long v = 1, long long tl = 1,
long long tr = n) {
if (tl == tr) {
seg[v] = val;
return;
}
long long tm = (tl + tr) >> 1;
if (pos <= tm)
upd(pos, val, 2 * v, tl, tm);
else
upd(pos, val, 2 * v + 1, tm + 1, tr);
seg[v] = max(seg[2 * v], seg[2 * v + 1]);
}
long long get_mx(long long l, long long r, long long v = 1, long long tl = 1,
long long tr = n) {
if (l > r) return 0;
if (tl == l && tr == r) return seg[v];
long long tm = (tl + tr) >> 1;
return max(get_mx(l, min(tm, r), 2 * v, tl, tm),
get_mx(max(tm + 1, l), r, 2 * v + 1, tm + 1, tr));
}
vector<pair<pair<long long, long long>, pair<long long, long long>>> que;
bool mark[maxn];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long q;
cin >> n >> q;
fill(seg, seg + 4 * maxn, inf);
fill(a, a + n + 5, inf);
for (long long i = 1; i <= q; i++) {
long long tp;
cin >> tp;
if (tp == 1) {
long long l, r, val;
cin >> l >> r >> val;
up(l, r, val);
que.push_back({{tp, l}, {r, val}});
} else {
long long pos, val;
cin >> pos >> val;
if (!mark[pos]) {
a[pos] = qu(pos);
mark[pos] = 1;
}
que.push_back({{tp, pos}, {val, -1}});
}
}
for (long long pos = 1; pos <= n; pos++)
if (!mark[pos]) a[pos] = qu(pos);
build();
for (auto x : que) {
long long tp = x.first.first;
if (tp == 1) {
long long l = x.first.second, r = x.second.first, val = x.second.second;
if (get_mx(l, r) != val) return cout << "NO", 0;
} else {
long long pos = x.first.second, val = x.second.first;
upd(pos, val);
}
}
map<long long, long long> mp;
long long orr = 0;
for (long long i = 1; i <= n; i++) {
if (a[i] == 0 || a[i] == inf) continue;
mp[a[i]]++;
if (mp[a[i]] >= 2) {
long long x = log2(a[i]);
a[i] = (1 << x) - 1;
}
orr |= a[i];
}
for (long long i = 1; i <= n; i++)
if (a[i] == inf) {
a[i] = 0;
for (long long j = 29; j >= 0; j--)
if (!(orr & (1 << j)))
if ((a[i] + (1 << j)) <= (1e9)) a[i] += (1 << j);
orr |= a[i];
}
cout << "YES\n";
for (long long i = 1; i <= n; i++) cout << a[i] << " ";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 5;
const long long int INF = 1e9;
int main() {
ios_base::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
string s[n];
vector<long long int> num(n, 0);
for (long long int i = 0; i <= n - 1; i++) {
cin >> s[i];
for (long long int j = 0; j <= m - 1; j++) {
long long int mul = m - 1 - j;
num[i] += (s[i][j] - '0') * pow(2, mul);
}
}
long long int maxi = pow(2, m) - 1;
long long int med = maxi / 2;
sort(num.begin(), num.end());
long long int pos = lower_bound(num.begin(), num.end(), med) - num.begin();
if (n % 2 != 0) {
while ((med != num[pos] && med - pos != maxi - med - n + pos) ||
med == num[pos]) {
if (med == num[pos]) {
if (med - pos > maxi - med - n + pos + 1) {
med--;
} else if (med - pos < maxi - med - n + pos + 1) {
med++;
} else {
;
}
} else {
if (med - pos > maxi - med - n + pos) {
med--;
} else {
med++;
}
}
pos = lower_bound(num.begin(), num.end(), med) - num.begin();
}
} else {
while ((med != num[pos] && med - pos + 1 != maxi - med - n + pos) ||
med == num[pos]) {
if (med == num[pos]) {
if (med - pos + 1 > maxi - med - n + pos + 1) {
med--;
} else if (med - pos + 1 < maxi - med - n + pos + 1) {
med++;
} else {
;
}
} else {
if (med - pos + 1 > maxi - med - n + pos) {
med--;
} else {
med++;
}
}
pos = lower_bound(num.begin(), num.end(), med) - num.begin();
}
}
string ans = string(m, '0');
long long int j = m - 1;
while (med > 0) {
if (med % 2 == 1) {
ans[j] = '1';
}
med /= 2;
j--;
}
cout << ans << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct trans {
int b, c;
trans(int _b, int _c) : b(_b), c(_c) {}
};
vector<trans> a[100000];
vector<int> t[100000];
size_t tp[100000];
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int ai, bi, ci;
scanf("%d%d%d", &ai, &bi, &ci);
a[ai - 1].push_back(trans(bi - 1, ci));
a[bi - 1].push_back(trans(ai - 1, ci));
}
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
t[i].reserve(k);
for (int j = 0; j < k; j++) {
int tij;
scanf("%d", &tij);
t[i].push_back(tij);
}
}
vector<int> d(n, INT_MAX);
set<pair<int, int> > q;
q.insert(make_pair(0, 0));
d[0] = 0;
while (!q.empty()) {
int i = q.begin()->second;
q.erase(q.begin());
while (tp[i] < t[i].size() && t[i][tp[i]] < d[i]) {
tp[i]++;
}
int st = d[i];
while (tp[i] < t[i].size() && t[i][tp[i]] == st) {
st++;
tp[i]++;
}
for (vector<trans>::iterator j = a[i].begin(); j != a[i].end(); j++) {
if (st + j->c < d[j->b]) {
q.erase(make_pair(d[j->b], j->b));
d[j->b] = st + j->c;
q.insert(make_pair(d[j->b], j->b));
}
}
}
if (d[n - 1] == INT_MAX)
printf("-1");
else
printf("%d", d[n - 1]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
string ans = "NO";
for (int i = (int)(0); i < (int)(s.length()); i++) {
if (s[i] == 'H' || s[i] == 'Q' || s[i] == '9') {
ans = "YES";
break;
}
}
cout << ans;
}
| 0 |
#include <stdio.h>
#define N 6000
int min(int a, int b) { return a < b ? a : b; }
void rotate(int *ii, int n, int i) {
static int jj[N];
int h;
for (h = 0; h < n; h++)
jj[h] = ii[(i + h) % n];
for (h = 0; h < n; h++)
ii[h] = jj[h];
}
int main() {
static int aa[N], bb[N], cc[N], ii[N], gap[N], jj[N * 2], qu[N * 2];
int n, h, i, j, k, tmp, circle, head, cnt;
long long t;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d%d", &aa[i], &bb[i], &cc[i]);
ii[i] = i;
}
t = 1;
if (aa[0] > aa[1])
k = 0, tmp = ii[0], ii[0] = ii[1], ii[1] = tmp;
else
k = 1;
while (1) {
int n_, r, r_, l, l_;
circle = 1;
for (i = 0; i < n; i++) {
gap[i] = bb[ii[i]] > aa[ii[(i + 1) % n]];
circle = circle && !gap[i];
}
if (circle) {
printf("-1 -1\n");
return 0;
}
for (i = 0; i < n; i++)
if (ii[i] == k)
break;
while (!gap[i])
i = (i + 1) % n, t++;
rotate(ii, n, i), rotate(gap, n, i);
for (j = 0; j < n - 1; j++)
if (gap[j] && (j == n - 2 || cc[ii[j]] > aa[ii[j + 2]])) {
printf("%d %lld\n", ii[j], t + j + 2);
return 0;
}
r_ = l_ = n + 3;
for (j = n - 1, l = n; j > 0; j--)
if (!gap[j - 1]) {
if (!gap[j] && cc[ii[j]] > aa[ii[(j + 1) % n]])
if (r_ > l - j || r_ == l - j && l_ > l % n)
r_ = l - j, l_ = l % n;
} else
l = j - 1;
n_ = 0, head = cnt = 0, r = r_ + 1;
for (j = 0; j < n; j++)
if (j == 0 || !gap[j - 1]) {
jj[n_++] = j;
while (cnt && bb[ii[jj[qu[head + cnt - 1]]]] > bb[ii[jj[n_ - 1]]])
cnt--;
qu[head + cnt++] = n_ - 1;
}
for (j = 0; j < n; j++)
if (j == 0 || !gap[j - 1]) {
jj[n_++] = j;
while (cnt && bb[ii[jj[qu[head + cnt - 1]]]] > bb[ii[jj[n_ - 1]]])
cnt--;
qu[head + cnt++] = n_ - 1;
} else
while (cnt && bb[ii[jj[qu[head]]]] < aa[ii[j]]) {
r = min(r, n_ - 1 - qu[head]);
head++, cnt--;
}
if (r == r_ + 1) {
if (r_ == n + 3)
printf("-1 -1\n");
else
printf("%d %lld\n", l_ == 0 ? ii[n - r_] : ii[l_ - r_], t + r_ * (n - 1) + l_ + 2);
return 0;
}
for (h = 0; h < n_; h++)
jj[h] = ii[jj[h]];
for (j = 0, h = n_ / 2 - r; j < n; j++)
if (j == 0 || !gap[j - 1])
ii[j] = jj[h++];
k = ii[0], t += r * (n - 1);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int ind[300005 + 5];
int n, m, i, num, x, y;
int minimum[300005 + 5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m, i, num, x, y;
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> num;
ind[num] = i;
minimum[i] = n;
}
for (i = 1; i <= m; i++) {
cin >> x >> y;
x = ind[x];
y = ind[y];
if (x > y) swap(x, y);
minimum[x] = min(minimum[x], y - 1);
}
long long ans = 0;
int l = n;
for (i = n; i >= 1; i--) {
l = min(minimum[i], l);
ans += (l - i + 1);
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
return X * w;
}
const int N = 100000 + 10;
const int mod = 1e9 + 7;
int qpow(int a, int b) {
int c = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) c = 1ll * c * a % mod;
return c;
}
int n, k;
char a[N];
int s[N], fac[N], ifac[N];
int C(int n, int m) {
if (n < m) return 0;
return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
int main() {
n = read(), k = read();
scanf("%s", a + 1);
for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i] - '0';
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
ifac[n] = qpow(fac[n], mod - 2);
for (int i = n; i; --i) ifac[i - 1] = 1ll * ifac[i] * i % mod;
int ans = 0;
for (int i = 0; i <= n - 2; ++i)
ans = (ans + 1ll * qpow(10, i) * C(n - i - 2, k - 1) % mod * s[n - i - 1]) %
mod;
for (int i = k + 1; i <= n; ++i)
ans =
(ans + 1ll * qpow(10, n - i) * C(i - 1, k) % mod * (a[i] - '0')) % mod;
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long const N = 2e5 + 10;
long long const MOD = 1e9 + 7;
vector<long long> store[N];
long long deg[N];
long long visit[N];
vector<pair<long long, long long>> res;
void dfs(long long pos) {
visit[pos] = 1;
for (auto c : store[pos]) {
if (visit[c] == 0) {
res.push_back({pos, c});
dfs(c);
}
}
}
int32_t main() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
long long a, b;
cin >> a >> b;
deg[a]++;
deg[b]++;
store[a].push_back(b);
store[b].push_back(a);
}
long long loc = 0, mx = 0;
for (long long i = 1; i <= n; i++) {
if (mx < deg[i]) {
mx = deg[i];
loc = i;
}
}
visit[loc] = 1;
for (auto c : store[loc]) {
visit[c]++;
res.push_back({loc, c});
}
for (auto c : store[loc]) {
dfs(c);
}
for (long long i = 0; i < res.size(); i++) {
cout << res[i].first << " " << res[i].second << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void PV(T x) {
for (__typeof__((x).begin()) i = (x).begin(); i != (x).end(); i++)
cout << *i << " ";
cout << endl;
}
template <class T>
inline void gmax(T &a, T b) {
if (a < b) a = b;
}
map<string, int> s2n;
map<int, string> n2s;
int gid(const string &s) {
if (s2n.count(s))
return s2n[s];
else {
int l = s2n.size();
s2n[s] = l;
n2s[l] = s;
return l;
}
}
int main(int argc, char *argv[]) {
int m;
cin >> m;
vector<vector<int> > lnk(m * 2);
while (m-- > 0) {
string s1, s2;
cin >> s1 >> s2;
int u = gid(s1), v = gid(s2);
lnk[u].push_back(v);
lnk[v].push_back(u);
}
int n = s2n.size();
cout << n << endl;
vector<int> c(n, 0);
vector<bool> d(n, false);
for (int n_ = (n), u = 0; u < n_; ++u) {
d[u] = true;
for (auto &v : lnk[u]) {
d[v] = true;
}
int ans = n - 1 - lnk[u].size();
int maxi = 0;
for (auto &v : lnk[u])
for (auto &vv : lnk[v])
if (!d[vv]) {
++c[vv];
if (c[vv] > maxi) {
maxi = c[vv];
ans = 1;
} else if (c[vv] == maxi)
ans++;
}
for (auto &v : lnk[u])
for (auto &vv : lnk[v])
if (!d[vv]) c[vv] = 0;
for (auto &v : lnk[u]) {
d[v] = false;
}
d[u] = false;
cout << n2s[u] << " " << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
inline char gc() {
static const int L = 233333;
static char sxd[L], *sss = sxd, *ttt = sxd;
if (sss == ttt) {
ttt = (sss = sxd) + fread(sxd, 1, L, stdin);
if (sss == ttt) {
return EOF;
}
}
return *sss++;
}
template <class T>
inline bool read(T& x) {
bool flg = false;
char c = gc();
x = 0;
for (; !isdigit(c); c = gc()) {
if (c == '-') {
flg = true;
} else if (c == EOF) {
return false;
}
}
for (; isdigit(c); c = gc()) {
x = (x << 1) + (x << 3) + (c ^ 48);
}
if (flg) {
x = -x;
}
return true;
}
using namespace std;
const int maxn = 200005;
int n, m, q;
namespace bcj {
int fa[maxn];
inline void init() {
for (int i = 1; i <= n; ++i) {
fa[i] = i;
}
}
inline int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
inline void add_edge(int x, int y) {
int faa = getfa(x);
int fab = getfa(y);
if (faa != fab) {
fa[faa] = fab;
}
}
inline bool query(int x, int y) { return getfa(x) == getfa(y); }
} // namespace bcj
namespace yft {
int n;
struct Edge {
int to, nxt;
} e[maxn << 1];
int first[maxn];
inline void add_edge(int from, int to) {
static int cnt = 0;
e[++cnt].nxt = first[from];
first[from] = cnt;
e[cnt].to = to;
e[++cnt].nxt = first[to];
first[to] = cnt;
e[cnt].to = from;
}
int fa[maxn];
int siz[maxn];
int son[maxn];
int dep[maxn];
inline void dfs1(int now) {
siz[now] = 1;
for (int i = first[now]; i; i = e[i].nxt) {
int to = e[i].to;
if (to != fa[now]) {
fa[to] = now;
dep[to] = dep[now] + 1;
dfs1(to);
siz[now] += siz[to];
if (!son[now] || siz[son[now]] < siz[to]) {
son[now] = to;
}
}
}
}
int ffa[maxn];
int ll[maxn];
inline void dfs2(int now) {
static int cnt = 0;
ll[now] = ++cnt;
if (son[now]) {
ffa[son[now]] = ffa[now];
dfs2(son[now]);
}
for (int i = first[now]; i; i = e[i].nxt) {
int to = e[i].to;
if (to != fa[now] && to != son[now]) {
ffa[to] = to;
dfs2(to);
}
}
}
inline int lca(int xx, int yy) {
while (ffa[xx] != ffa[yy]) {
if (dep[ffa[xx]] > dep[ffa[yy]]) {
xx = fa[ffa[xx]];
} else {
yy = fa[ffa[yy]];
}
}
if (dep[xx] < dep[yy]) {
return xx;
} else {
return yy;
}
}
inline void pre() {
dfs1(1);
fa[1] = ffa[1] = 1;
dfs2(1);
}
int up[maxn], down[maxn];
inline void fg(int x, int y) {
int l = lca(x, y);
up[x]++;
down[y]++;
up[l]--;
down[l]--;
}
inline void dfs(int now) {
for (int i = first[now]; i; i = e[i].nxt) {
int to = e[i].to;
if (to != fa[now]) {
dfs(to);
up[now] += up[to];
down[now] += down[to];
}
}
}
inline bool pan() {
dfs(1);
for (int i = 1; i <= n; ++i) {
if (up[i] && down[i]) {
return false;
}
}
return true;
}
} // namespace yft
int dfc[maxn];
namespace bt {
struct Edge {
int to, nxt;
} e[maxn << 1];
int first[maxn];
inline void add_edge(int from, int to) {
static int cnt = 0;
e[++cnt].nxt = first[from];
first[from] = cnt;
e[cnt].to = to;
e[++cnt].nxt = first[to];
first[to] = cnt;
e[cnt].to = from;
}
int dfn[maxn];
int low[maxn];
stack<int> st;
inline void dfs(int now, int fa) {
static int cnt = 0;
dfn[now] = low[now] = ++cnt;
st.push(now);
bool flg = false;
for (int i = first[now]; i; i = e[i].nxt) {
int to = e[i].to;
if (flg || to != fa) {
if (!dfn[to]) {
dfs(to, now);
low[now] = min(low[now], low[to]);
} else {
low[now] = min(low[now], low[to]);
}
}
if (to == fa) {
flg = true;
}
}
if (low[now] == dfn[now]) {
int tmp;
yft::n++;
do {
tmp = st.top();
st.pop();
dfc[tmp] = yft::n;
} while (tmp != now);
}
}
inline void build_tree() {
dfs(1, 0);
set<pair<int, int> > st;
for (int now = 1; now <= n; ++now) {
for (int i = first[now]; i; i = e[i].nxt) {
int to = e[i].to;
if (dfc[to] != dfc[now] && !st.count(make_pair(dfc[to], dfc[now])) &&
!st.count(make_pair(dfc[now], dfc[to]))) {
st.insert(make_pair(dfc[to], dfc[now]));
yft::add_edge(dfc[to], dfc[now]);
}
}
}
}
} // namespace bt
int main() {
read(n), read(m), read(q);
bcj::init();
for (int i = 1, f, t; i <= m; ++i) {
read(f), read(t);
bt::add_edge(f, t);
bcj::add_edge(f, t);
}
bt::build_tree();
yft::pre();
while (q--) {
int u, v;
read(u), read(v);
if (!bcj::query(u, v)) {
puts("No");
return 0;
}
yft::fg(dfc[u], dfc[v]);
}
if (yft::pan()) {
puts("Yes");
} else {
puts("No");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 3;
const int infint = (int)1e9 + 3;
const int MOD = (int)1e9 + 7;
const long long inf = (long long)1e17;
int n, m, visited[2 * MAXN], dp[2 * MAXN][2][2], comp[2 * MAXN][2],
sz = 0, cursz, isolated;
int pos[MAXN], neg[MAXN];
map<int, int> type[MAXN];
vector<int> G[2 * MAXN], cur;
int add(int a, int b) {
int c = a + b;
if (c >= MOD) c -= MOD;
if (c < 0) c += MOD;
return c;
}
int mul(int a, int b) {
int c = 1LL * a * b % MOD;
return c;
}
void dfs(int u) {
visited[u] = 1;
cur.push_back(u);
for (auto v : G[u])
if (!visited[v]) dfs(v);
}
void update_dp(int idx, int &untillnow) {
for (int i = idx; i < cursz; i++) {
if (cur[i] < n) continue;
if (untillnow == 0) {
if (i == 0)
dp[untillnow][0][0] = dp[untillnow][0][1] = 1;
else {
int negate = (type[cur[0]][cur[1]] == -1);
dp[untillnow][negate][0] = dp[untillnow][negate ^ 1][1] = 1;
}
} else {
int negate1 = (type[cur[i - 1]][cur[i]] == -1);
int negate2 = (type[cur[i - 1]][cur[i - 2]] == -1);
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
for (int l = 0; l < 2; l++) {
int tp = ((j ^ negate2) | (l ^ negate1)) ^ k;
dp[untillnow][tp][l] =
add(dp[untillnow][tp][l], dp[untillnow - 1][k][j]);
}
}
untillnow++;
}
untillnow--;
}
void cyclic_shift() {
int st = cur.back();
cur.pop_back();
cur.insert(cur.begin(), st);
return;
}
void whitex() {
cursz = cur.size();
for (int i = 0; i < cursz; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) dp[i][j][k] = 0;
return;
}
void solve(bool cyc) {
whitex();
int untillnow = 0;
if (cyc == 0) {
if (cursz == 1) {
isolated++;
return;
} else {
update_dp(0, untillnow);
if (cur[cursz - 1] < n) {
int negate = (type[cur.back()][cur[cursz - 2]] == -1);
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) {
int tp = j ^ negate ^ k;
comp[sz][tp] = add(comp[sz][tp], dp[untillnow][k][j]);
}
} else {
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
comp[sz][k] = add(comp[sz][k], dp[untillnow][k][j]);
}
}
} else {
if (cur[0] < n) cyclic_shift();
if (cursz == 2) {
if (neg[cur[1]] == 1 && pos[cur[1]] == 1)
comp[sz][1] = 2;
else
comp[sz][0] = comp[sz][1] = 1;
} else {
dp[untillnow][0][0] = 1;
untillnow++;
update_dp(1, untillnow);
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) {
int negate1 = (type[cur.back()][cur[cursz - 2]] == -1);
int negate2 = (type[cur.back()][cur[0]] == -1);
int tp = ((negate1 ^ j) | negate2) ^ k;
comp[sz][tp] = add(comp[sz][tp], dp[untillnow][k][j]);
}
whitex();
untillnow = 0;
dp[untillnow][0][1] = 1;
untillnow++;
update_dp(1, untillnow);
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) {
int negate1 = (type[cur.back()][cur[cursz - 2]] == -1);
int negate2 = (type[cur.back()][cur[0]] == -1);
int tp = ((negate1 ^ j) | (negate2 ^ 1)) ^ k;
comp[sz][tp] = add(comp[sz][tp], dp[untillnow][k][j]);
}
}
}
sz++;
}
int pwr(int a, int b) {
if (b == 0) return 1;
int c = pwr(a, b >> 1);
c = mul(c, c);
if (b & 1) c = mul(c, a);
return c;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int sz;
cin >> sz;
while (sz--) {
int x;
cin >> x;
if (x < 0)
neg[i]++;
else
pos[i]++;
type[i][abs(x) + n - 1] = x / abs(x);
G[i].push_back(abs(x) + n - 1);
G[abs(x) + n - 1].push_back(i);
}
}
for (int i = 1; i < n + m; i++)
if (!visited[i] && (int)G[i].size() <= 1) {
cur.clear();
dfs(i);
solve(0);
}
for (int i = 1; i < n + m; i++)
if (!visited[i]) {
cur.clear();
dfs(i);
solve(1);
}
for (int i = 1; i < sz; i++) {
int even = comp[i][0], odd = comp[i][1];
comp[i][0] = add(mul(comp[i - 1][1], odd), mul(comp[i - 1][0], even));
comp[i][1] = add(mul(comp[i - 1][1], even), mul(comp[i - 1][0], odd));
}
cout << mul(comp[sz - 1][1], pwr(2, isolated));
}
| 10 |
#include <bits/stdc++.h>
template <typename T>
inline bool chkmin(T &a, T b) {
return b < a ? a = b, true : false;
}
template <typename T>
inline bool chkmax(T &a, T b) {
return b > a ? a = b, true : false;
}
template <class T>
inline T read(T &x) {
int sign = 1;
char c = getchar_unlocked();
for (; !isdigit(c); c = getchar_unlocked())
if (c == '-') sign = -1;
for (x = 0; isdigit(c); c = getchar_unlocked()) x = x * 10 + c - '0';
return x *= sign;
}
template <class T>
inline void write(T x) {
if (x == 0) {
putchar_unlocked('0');
return;
}
if (x < 0) {
putchar_unlocked('-');
x = -x;
}
static char s[20];
int top = 0;
for (; x; x /= 10) s[++top] = x % 10 + '0';
while (top) putchar_unlocked(s[top--]);
}
const int maxN = 5000;
const int LogN = 40;
const int P = 7340033;
const int G = 3;
long long pwr(long long x, int k) {
long long ret = 1;
for (; k; k >>= 1, x = x * x % P)
if (k & 1) ret = ret * x % P;
return ret;
}
int a[LogN][maxN];
inline int gmod(int x) {
if (x >= P) x -= P;
return x;
}
namespace NTT {
int n, STEP, g, inv;
int rev[maxN];
int wn[maxN];
void init(int N) {
for (n = 1, STEP = 0; n < N; n <<= 1, ++STEP)
;
for (int i = 1; i < n; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (STEP - 1));
g = pwr(G, (P - 1) / n);
wn[0] = 1;
for (int i = 1; i <= n; ++i) wn[i] = (long long)wn[i - 1] * g % P;
inv = pwr(n, P - 2);
}
void dft(int a[], int flag) {
for (int i = 0; i < n; ++i)
if (i < rev[i]) std::swap(a[i], a[rev[i]]);
for (int k = 1; k < n; k <<= 1) {
for (int i = 0; i < n; i += (k << 1))
for (int j = 0; j < k; ++j) {
int w = flag == 1 ? wn[n / (k << 1) * j] : wn[n - n / (k << 1) * j];
int x = a[i + j];
int y = (long long)a[i + j + k] * w % P;
a[i + j] = gmod(x + y);
a[i + j + k] = gmod(x - y + P);
}
}
if (flag == -1) {
for (int i = 0; i < n; ++i) a[i] = (long long)a[i] * inv % P;
}
}
} // namespace NTT
void prework() {
NTT::init(4000);
a[0][0] = 1;
for (int i = 1; i <= 32; ++i) {
NTT::dft(a[i - 1], 1);
for (int j = 0; j < NTT::n; ++j) {
long long t = (long long)a[i - 1][j] * a[i - 1][j] % P;
a[i][j] = t * t % P;
}
NTT::dft(a[i - 1], -1);
NTT::dft(a[i], -1);
for (int j = NTT::n - 1; j > 1000; --j) a[i][j] = 0;
for (int j = 1000; j >= 1; --j) a[i][j] = a[i][j - 1];
}
}
int main() {
if (fopen("tmp.in", "r")) {
freopen("tmp.in", "r", stdin);
freopen("tmp.out", "w", stdout);
}
int Q, n, k;
prework();
read(Q);
while (Q--) {
read(n), read(k);
int cnt = 0;
for (; (n > 1) && (n & 1); n >>= 1) ++cnt;
write(a[cnt][k]), putchar_unlocked('\n');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int x, i, n;
cin >> n;
for (i = 1; i <= n; i++) {
x = i % 4;
if (x == 0) cout << 'd';
if (x == 1) cout << 'a';
if (x == 2) cout << 'b';
if (x == 3) cout << 'c';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long res;
string s;
unordered_map<string, bool> d[103];
void bfs() {
if (k == 0) return;
queue<string> Q;
d[s.size()][s] = 1;
Q.push(s);
while (!Q.empty()) {
string S = Q.front(), S1;
Q.pop();
if (S == "") return;
if (d[S.size()].size() != 0) d[S.size()].clear();
S1.resize(S.size() - 1);
for (int i = 1; i < S.size(); i++) {
S1[i - 1] = S[i];
}
if (d[S1.size()][S1] == 0) {
d[S1.size()][S1] = 1;
res += n - S1.size();
k--;
if (k == 0) return;
Q.push(S1);
}
for (int i = 0; i < S1.size(); i++) {
S1[i] = S[i];
if (d[S1.size()][S1] == 0) {
d[S1.size()][S1] = 1;
res += n - S1.size();
k--;
if (k == 0) return;
Q.push(S1);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s;
k--;
bfs();
if (k == 0)
cout << res;
else
cout << -1;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int fl[100005];
int tmp[100005];
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n >= m)
printf("YES\n");
else {
int i, x, ii;
int valid = 0;
for (ii = 0; ii < n; ii++) {
scanf("%d", &x);
x = x % m;
if (x == 0) {
valid = 1;
break;
}
for (i = 0; i <= m; i++)
if (tmp[i] == 1) fl[i] = 1;
for (i = 1; i < m; i++) {
if (fl[i] == 1) {
int cur = (i + x) % m;
if (cur == 0) {
valid = 1;
break;
}
tmp[cur] = 1;
}
}
tmp[x] = 1;
}
if (valid)
printf("YES\n");
else
printf("NO\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, lamps[2002], sol = 0, cs;
memset(lamps, 0, sizeof(lamps));
cin >> n >> m;
string s[2002];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == '1') lamps[j]++;
for (int i = 0; i < n; i++) {
cs = 1;
for (int j = 0; j < m; j++) {
if (s[i][j] == '1' && lamps[j] < 2) {
cs = 0;
break;
}
}
if (cs == 1) {
sol = 1;
break;
}
}
if (sol)
cout << "YES";
else
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
string s;
int n, a[N];
int one, zero;
int b[N], cnt;
int ans[N];
int main() {
cin >> s;
n = (int)s.size();
for (int i = 0; i < (int)s.size(); i++) a[i + 1] = s[i] - '0';
for (int i = 1; i <= n; i++)
if (a[i] == 1) one++;
for (int i = 1; i <= one; i++) b[i] = 1;
cnt = one;
for (int i = 1; i <= n; i++)
if (a[i] != 1) b[++cnt] = a[i];
for (int i = one + 1; i <= n; i++) {
if (b[i] == 0)
zero++;
else if (b[i] == 2)
break;
}
for (int i = 1; i <= zero; i++) ans[i] = 0;
for (int i = zero + 1; i <= zero + one; i++) ans[i] = 1;
for (int i = zero + one + 1; i <= n; i++) ans[i] = b[i];
for (int i = 1; i <= n; i++) printf("%d", ans[i]);
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int N, k, a, b, c, d, G[maxn][maxn], pos[maxn], pp[maxn];
bool vis[maxn];
int main() {
scanf("%d%d", &N, &k);
scanf("%d%d%d%d", &a, &b, &c, &d);
if (N == 4 || k <= N) {
puts("-1");
return 0;
}
int x = a;
memset(vis, false, sizeof(vis));
vis[a] = vis[b] = vis[c] = vis[d] = true;
for (int i = 1; i <= N; ++i) {
if (!vis[i]) {
x = i;
vis[i] = true;
break;
}
}
memset(G, 0, sizeof(G));
pos[1] = a, pp[1] = c;
int cnt = 1;
for (int i = 1; i <= N; ++i) {
if (!vis[i]) {
cnt++;
pos[cnt] = i;
}
}
for (int i = cnt; i > 1; i--) {
pp[cnt - i + 2] = pos[i];
}
pos[cnt + 1] = c, pp[cnt + 1] = a;
pos[cnt + 2] = x, pp[cnt + 2] = x;
pos[cnt + 3] = d, pp[cnt + 3] = b;
pos[cnt + 4] = b, pp[cnt + 4] = d;
for (int i = 1; i <= N - 1; ++i)
G[pos[i]][pos[i + 1]] = G[pos[i + 1]][pos[i]] = G[pp[i]][pp[i + 1]] =
G[pp[i + 1]][pp[i]] = 1;
cnt = 0;
for (int i = 1; i <= N; ++i) {
for (int j = i; j <= N; ++j) {
if (G[i][j]) cnt++;
}
}
if (cnt > k) {
puts("-1");
} else {
for (int i = 1; i <= N - 1; ++i) printf("%d ", pos[i]);
printf("%d\n", pos[N]);
for (int i = 1; i <= N - 1; ++i) printf("%d ", pp[i]);
printf("%d\n", pp[N]);
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
ll t;
cin>>t;
while(t--){
int n;
cin>>n;
int a[n];
map<int,int> mp;
for(int i=0;i<n;i++){
cin>>a[i];
mp[a[i]]++;
}
sort(a,a+n);
for(int i=n-1;i>=0;i--){
if(mp[a[i]+1]==0){
mp[a[i]+1]+=1;
mp[a[i]]-=1;
}
}
int cnt=0;
for(auto x:mp){
if(x.second!=0){
cnt++;
}
}
cout<<cnt<<'\n';
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
unsigned long long n;
cin >> n;
unsigned long long x = (n * (n - 1) * (n - 2) * (n - 3) * (n - 4)) / 120 *
(n * (n - 1) * (n - 2) * (n - 3) * (n - 4));
cout << x << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000000;
int n, k, head[MAXN], ver[MAXN], next1[MAXN], tot, f[MAXN], num[MAXN],
deep[MAXN];
void add(int x, int y) {
ver[++tot] = y;
next1[tot] = head[x];
head[x] = tot;
}
void dfs(int x, int fa) {
deep[x] = 10000000;
for (int i = head[x]; i; i = next1[i]) {
int y = ver[i];
if (y == fa) continue;
dfs(y, x);
deep[x] = min(deep[x], deep[y] + 1);
num[x] += num[y];
f[x] = max(f[x], f[y] - num[y]);
}
f[x] += num[x];
if (deep[x] == 10000000) {
f[x] = 1;
num[x] = 1;
deep[x] = 0;
}
if (deep[x] >= k) num[x] = 0;
}
int main() {
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
add(x, i);
}
dfs(1, 0);
cout << f[1] << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const long long INF = 1e9;
const long long LINF = INF * INF;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int LOG = 19;
const int N = 1 << LOG;
int n;
int a[N];
int l[N];
int r[N];
void solve() {
cin >> n;
for (int i = (0); i < (n); ++i) l[i] = -1, r[i] = -1;
for (int i = (0); i < (n); ++i) {
cin >> a[i];
a[i]--;
if (l[a[i]] == -1) l[a[i]] = i;
r[a[i]] = i;
}
int ans = 0;
int najdali = 0;
int curr = 0;
int all = 0;
for (int i = (0); i < (n); ++i) {
if (l[i] == -1) continue;
all++;
if (l[i] < najdali) {
ans = max(ans, curr);
curr = 1;
najdali = r[i];
continue;
}
najdali = max(najdali, r[i]);
curr++;
}
ans = max(ans, curr);
cout << all - ans << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) solve();
cerr << "Time elapsed: " << clock() / (double)CLOCKS_PER_SEC << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 20;
const int MAX = 10000007;
inline long long read() {
char c = getchar();
long long x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0', c = getchar();
}
return x * f;
}
inline void out(int x) {
if (x > 9) out(x / 10);
putchar(x % 10 + '0');
}
int q[N];
char s[N];
int qq[N];
map<int, int> mp;
set<int> Q;
int main() {
int t;
t = read();
while (t--) {
int n, m;
n = read(), m = read();
int maxx = -0x3f3f3f3f;
for (int i = (1); i <= (n); ++i) {
q[i] = read();
Q.insert(q[i]);
}
int cnt = 0;
if (Q.size() > m) {
puts("-1");
Q.clear();
continue;
}
printf("%d\n", n * m);
auto it = Q.begin();
for (int i = 1; i <= n; ++i) {
cnt = 0;
while (it != Q.end()) {
cout << *it << " ";
it++;
cnt++;
}
it = Q.begin();
int k = 1;
for (int j = cnt + 1; j <= m; ++j) {
cout << k++ << " ";
}
it = Q.begin();
}
puts("");
Q.clear();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0;
int start = 0;
int ans[1000050];
bool xl[100050];
bool vis[100050];
int fa[100050];
vector<int> v[100050], son[100050];
void dfs1(int x) {
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++)
if (!vis[v[x][i]]) {
son[x].push_back(v[x][i]);
fa[v[x][i]] = x;
dfs1(v[x][i]);
}
}
void dfs2(int st) {
xl[st] ^= 1;
ans[++cnt] = st;
for (int i = 0; i < son[st].size(); i++) {
dfs2(son[st][i]);
ans[++cnt] = st;
xl[st] ^= 1;
}
if (st != start && xl[st] == 1) {
xl[fa[st]] ^= 1;
xl[st] ^= 1;
ans[++cnt] = fa[st];
ans[++cnt] = st;
}
}
int main() {
int x, y;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
cin >> xl[i];
if (start == 0 && xl[i] == 1) start = i;
}
if (m == 0) {
int f = 0;
for (int i = 1; i <= n; i++)
if (xl[i] == 1 && f == 0)
f = i;
else if (xl[i] == 1 && f != 0) {
cout << -1 << endl;
return 0;
}
if (f != 0) cout << 1 << endl;
cout << f << endl;
return 0;
}
dfs1(start);
dfs2(start);
for (int i = 1; i <= n; i++)
if (i != start && xl[i] != 0) {
cout << -1 << endl;
return 0;
}
if (xl[start] == 1) {
ans[++cnt] = son[start][0];
ans[++cnt] = start;
ans[++cnt] = son[start][0];
}
cout << cnt << endl;
for (int i = 1; i <= cnt; i++) cout << ans[i] << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
while (cin >> s) {
n = s.size();
int cnt = 0;
for (auto i : s) {
if (i == 'a') cnt++;
}
cout << min(cnt * 2 - 1, n) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long INF = 1ll * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7;
const long long MOD2 = 1ll * 1000 * 1000 * 1000 + 7;
const long long N = 1ll * 1000 * 1000 * 1000 * 1000 * 1000;
const long long N2 = 1000 * 100;
const long double PI = 3.14159265;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y, long long p = INF) {
long long res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
std::vector<long long> v;
void printDivisors(long long n) {
for (long long i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
v.push_back(i);
else {
v.push_back(i);
v.push_back(n / i);
}
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
printDivisors(n);
long long ans = v[1];
for (int i = 1; i < v.size(); ++i) {
ans = gcd(ans, v[i]);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve();
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int64_t t;
cin >> t;
while (t--) solve();
return 0;
}
int64_t tab[100001];
void solve() {
int64_t n, in;
set<int64_t> s;
unordered_map<int64_t, pair<int64_t, int64_t> > m;
cin >> n;
for (int64_t i = 0; i < n; i++) {
cin >> in;
if (s.count(in)) {
pair<int64_t, int64_t> p = m[in];
p.second = (p.second > i - p.first ? p.second : i - p.first);
p.first = i;
m[in] = p;
} else {
s.insert(in);
m[in] = make_pair(i, i + 1);
}
}
auto it = s.begin();
set<int64_t> q;
map<int64_t, vector<int64_t> > mm;
set<int64_t> mmSet;
while (it != s.end()) {
int64_t cur = *it;
m[cur].second =
(m[cur].second > n - m[cur].first ? m[cur].second : n - m[cur].first);
q.insert(cur);
if (mmSet.count(m[cur].second))
mm[m[cur].second].push_back(cur);
else {
mmSet.insert(m[cur].second);
mm[m[cur].second] = vector<int64_t>(1, cur);
}
it++;
}
vector<int64_t> ans;
for (int64_t i = n + 1; i >= 2; i--) {
for (int64_t &j : mm[i]) q.erase(j);
if (q.empty())
ans.push_back(-1);
else
ans.push_back(*q.begin());
}
for (int64_t i = n - 1; i >= 0; i--) cout << ans[i] << ' ';
cout << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const inf = 1000 * 1000 * 1000;
long long const inf64 = 1ll * inf * inf;
int n;
int ans[1005];
bool used[1005];
int res[1005];
int tot = 0;
void ask(vector<int> w) {
if (w.empty()) return;
for (int i = 1; i <= n; i++) used[i] = 0;
int sz = 0;
for (int x : w) {
if (x >= 1 && x <= n) used[x] = 1;
}
sort((w).begin(), (w).end());
w.resize(unique((w).begin(), (w).end()) - w.begin());
for (int x : w)
if (x >= 1 && x <= n) sz++;
cout << sz << "\n";
for (int x : w) {
if (x >= 1 && x <= n) cout << x << " ";
}
cout << endl;
tot++;
for (int i = 1; i <= n; i++) {
cin >> ans[i];
if (!used[i]) {
res[i] = min(res[i], ans[i]);
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) res[i] = inf + 1;
vector<vector<int> > q, t;
vector<int> add;
for (int i = 2;; i <<= 1) {
t.clear();
{
for (int j = 1; j <= i / 2; j++) add.push_back(j);
t.push_back(add);
add.clear();
for (int j = i / 2 + 1; j <= i; j++) add.push_back(j);
t.push_back(add);
add.clear();
}
{
for (auto iter : q) {
add.clear();
add = iter;
for (int x : iter) add.push_back(x + i / 2);
t.push_back(add);
}
}
q = t;
if (i >= n) break;
}
for (auto i : q) {
ask(i);
}
cout << "-1\n";
for (int i = 1; i <= n; i++) {
cout << res[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int p = 1;
while (p * (p + 1) <= 2 * n) p++;
p--;
cout << p << endl;
int rem = n;
for (int i = 1; i < p; i++) {
cout << i << " ";
rem = rem - i;
}
cout << rem << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long C[4001][4001];
long long n, W, B;
long long f;
void init(void) {
long long N = (((W) < (B)) ? (B) : (W));
C[0][0] = 1;
for (int i = 1; i <= N; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; ++j) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000009;
}
}
f = 1;
for (int i = 2; i <= W; ++i) {
f = (f * i) % 1000000009;
}
for (int i = 2; i <= B; ++i) {
f = (f * i) % 1000000009;
}
}
int main(int argc, char *argv[]) {
cin >> n >> W >> B;
init();
long long total = 0;
long long start = (((2) < (n - B)) ? (n - B) : (2));
long long end = (((W) > (n - 1)) ? (n - 1) : (W));
for (long long w = start; w <= end; ++w) {
long long b = n - w;
long long sub =
((((((w - 1) * C[W - 1][w - 1]) % 1000000009) * C[B - 1][b - 1]) %
1000000009) *
f) %
1000000009;
total = (total + sub) % 1000000009;
}
cout << total << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, t, k;
cin >> a >> b >> c;
t = a * c;
t = t - b * c;
k = t / b;
if (t % b != 0) k++;
cout << k << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const long long int MOD1 = 1e9 + 7;
const long long int MAX5 = 1e5;
const long long int MAX6 = 1e6;
const long long int MAX7 = 1e7;
const long long int MAX8 = 1e8;
const long long int MAX9 = 1e9;
const long long int MAX10 = 1e10;
const long long int MAXX = 1e18;
const int N = MAX5;
long long int ans[N + 1];
struct qry {
long long int id, a, t, x;
};
bool cmp(qry l, qry r) { return l.t < r.t; }
void update(long long int i, long long int k, vector<long long int> &tree) {
while (i <= tree.size()) {
tree[i] += k;
i += (i & -i);
}
}
int range_query(long long int i, vector<long long int> &tree) {
int res = 0;
while (i > 0) {
res += tree[i];
i -= (i & -i);
};
return res;
}
map<long long int, vector<qry>> q;
vector<long long int> tree(N + 1);
void solve() {
long long int n;
cin >> n;
for (int ii = 0; ii < n; ii++) {
long long int a, t, x;
cin >> a >> t >> x;
qry tmp = {ii + 1, a, t, x};
q[x].push_back(tmp);
}
for (auto queries : q) {
sort(queries.second.begin(), queries.second.end(), cmp);
long long int M = queries.second.size();
for (long long int i = 0; i < M; i++) {
qry curr = queries.second[i];
if (curr.a == 1) {
update(curr.id, 1, tree);
ans[curr.id] = -1;
} else if (curr.a == 2) {
update(curr.id, -1, tree);
ans[curr.id] = -1;
} else {
ans[curr.id] = range_query(curr.id, tree);
}
}
for (long long int i = 0; i < M; i++) {
qry curr = queries.second[i];
if (curr.a == 1) {
update(curr.id, -1, tree);
} else if (curr.a == 2) {
update(curr.id, 1, tree);
}
}
}
for (int ii = 1; ii < n + 1; ii++) {
if (ans[ii] != -1) {
cout << ans[ii];
cout << "\n";
;
}
}
}
int main() {
{ solve(); }
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
long long add(long long x, long long y) {
long long res = x + y;
return (res >= 1000000007 ? res - 1000000007 : res);
}
long long mul(long long x, long long y) {
long long res = x * y;
return (res >= 1000000007 ? res % 1000000007 : res);
}
long long sub(long long x, long long y) {
long long res = x - y;
return (res < 0 ? res + 1000000007 : res);
}
long long power(long long x, long long y) {
long long res = 1;
x %= 1000000007;
while (y) {
if (y & 1) res = mul(res, x);
y >>= 1;
x = mul(x, x);
}
return res;
}
long long mod_inv(long long x) { return power(x, 1000000007 - 2); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long ttt;
cin >> ttt;
while (ttt--) {
long long a, b, c;
cin >> a >> b >> c;
long long ans = inf, ba = -1, bb = -1, bc = -1;
for (long long i = 1; i < 20002; i++) {
for (long long j = i; j < 20002; j += i) {
long long x = abs(a - i) + abs(b - j);
if (ans > x) {
long long y = ((c + (j / 2)) / j) * j;
x += abs(y - c);
if (ans > x) {
ans = x;
ba = i, bb = j, bc = y;
}
}
}
}
cout << ans << endl;
cout << ba << " " << bb << " " << bc << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, x, y = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
char a;
long long d;
cin >> a >> d;
if (a == '+')
x += d;
else if (x >= d)
x -= d;
else
y++;
}
cout << x << " " << y << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, c = getchar(), f = 0;
for (; c > '9' || c < '0'; f = c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 1) + (x << 3) + c - '0', c = getchar())
;
return f ? -x : x;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
const int N = 55;
double ans, p1, p2, a[N][N], b[N][N], f[N][N];
void getf(int n) {
for (int i = 1, _y = n + 1; i <= _y; i++) f[n][i] = i;
for (int i = n - 1, _y = 1; i >= _y; i--) {
double sum = 0;
for (int j = 2, _y = n + 1; j <= _y; j++) {
double tmp = b[n - i][j] * (1 - a[n - i - 1][j]);
f[i][1] += f[i + 1][j] * tmp;
sum += tmp;
}
f[i][1] /= sum;
f[i][1]++;
for (int j = 2, _y = n - i + 2; j <= _y; j++) {
sum = 0;
for (int k = 1, _y = j - 1; k <= _y; k++) {
double tmp = a[n - i][k] * (1 - a[n - i - 1][k]);
f[i][j] += f[i + 1][k] * tmp;
sum += tmp;
}
f[i][j] /= sum;
f[i][j] += j;
}
}
}
struct matrix {
double s[N][N];
matrix() { memset(s, 0, sizeof s); }
};
matrix operator*(const matrix &A, const matrix &B) {
matrix C;
for (int i = 1, _y = 51; i <= _y; i++)
for (int k = 1, _y = 51; k <= _y; k++)
for (int j = 1, _y = 51; j <= _y; j++) C.s[i][j] += A.s[i][k] * B.s[k][j];
return C;
}
int n;
void jucheng() {
matrix res, A;
double sum = 0;
for (int i = 2, _y = 50; i <= _y; i++) sum += b[50][i] * (1 - a[50][i]);
for (int i = 2, _y = 50; i <= _y; i++)
A.s[i][1] = b[50][i] * (1 - a[50][i]) / sum;
A.s[51][1] = 1;
for (int i = 2, _y = 50; i <= _y; i++) {
sum = 0;
for (int j = 1, _y = i - 1; j <= _y; j++) sum += a[50][j] * (1 - a[50][j]);
for (int j = 1, _y = i - 1; j <= _y; j++)
A.s[j][i] = a[50][j] * (1 - a[50][j]) / sum;
A.s[51][i] = i;
}
A.s[51][51] = 1;
for (int i = 1, _y = 51; i <= _y; i++) res.s[i][i] = 1;
for (n -= 50; n; n >>= 1, A = A * A)
if (n & 1) res = res * A;
for (int i = 1, _y = 50; i <= _y; i++) {
sum = 0;
for (int j = 1, _y = 50; j <= _y; j++) sum += f[1][j] * res.s[j][i];
sum += res.s[51][i];
ans += sum * a[50][i] * (1 - a[50][i]);
}
printf("%.15lf\n", ans);
}
int main() {
n = read(), p1 = read() / 1000000000.;
p2 = 1 - p1;
for (int i = 1, _y = 50; i <= _y; i++)
for (int j = 1, _y = 50; j <= _y; j++) {
if (j == 1) a[i][j] = p1;
if (j == 2) a[i][j] = b[i][j] = p2;
a[i][j] += a[i][j - 1] * a[i - 1][j - 1];
b[i][j] += b[i][j - 1] * a[i - 1][j - 1];
}
getf(min(n, 50));
if (n <= 50) {
for (int i = 1, _y = n + 1; i <= _y; i++)
ans += f[1][i] * a[n][i] * (1 - a[n - 1][i]);
printf("%.15lf\n", ans);
} else
jucheng();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
long double p[N], q[N];
long double a[N], b[N];
void gg(long double A, long double B, long double C, long double &x) {
long double D = B * B - 4 * A * C;
if (D < 0) D = 0;
x = (-B + sqrt(D)) / A / 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> p[i];
for (int i = 1; i <= n; ++i) cin >> q[i];
long double suma = 0, sumb = 0;
for (int i = n; i; --i) {
long double x;
gg(-1, sumb + q[i] + p[i] - suma, suma * (p[i] + q[i]) - q[i], x);
long double y = q[i] + p[i] - x;
if (x <= 0) x = 0;
if (y <= 0) y = 0;
if (x >= 1) x = 1;
if (y >= 1) y = 1;
a[i] = x;
b[i] = y;
suma += x;
sumb += y;
}
cout.precision(12);
for (int i = 1; i <= n; ++i) cout << fixed << a[i] << ' ';
cout << endl;
for (int i = 1; i <= n; ++i) cout << fixed << b[i] << ' ';
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, q;
cin >> n >> m >> q;
string s1, s2;
cin >> s1 >> s2;
vector<pair<int, int> > p;
int ans = 1;
for (int i = 0; i < n; i++) {
if (s1[i] == s2[0]) {
for (int k = 1; k < m && i + k < n; k++) {
if (s1[i + k] == s2[k]) ans++;
}
if (ans == m) p.push_back(make_pair(i + 1, i + m));
ans = 1;
}
}
if (n >= m) {
while (q--) {
int a, b, la = 0;
cin >> a >> b;
for (int i = 0; i < p.size(); i++) {
if (p[i].first >= a && p[i].second <= b) la++;
}
cout << la << endl;
}
} else {
while (q--) {
cout << "0" << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, Q;
int mn[N * 4], mx[N * 4], fl[N * 4];
set<int> SL[N], SR[N];
map<pair<int, int>, int> mp;
void pushup(int k) {
mn[k] = max(mn[k * 2], mn[k * 2 + 1]);
mx[k] = min(mx[k * 2], mx[k * 2 + 1]);
fl[k] = fl[k * 2] | fl[k * 2 + 1] | (mn[k * 2 + 1] >= mx[k * 2]);
}
void build(int k, int l, int r) {
if (l == r) {
mn[k] = 0;
mx[k] = m + 1;
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
pushup(k);
}
void change(int k, int l, int r, int p) {
if (l == r) {
mn[k] = (SL[l].size() ? *SL[l].rbegin() : 0);
mx[k] = (SR[l].size() ? *SR[l].begin() : m + 1);
fl[k] = (mn[k] >= mx[k]);
return;
}
int mid = (l + r) / 2;
if (p <= mid)
change(k * 2, l, mid, p);
else
change(k * 2 + 1, mid + 1, r, p);
pushup(k);
}
int main() {
scanf("%d%d%d", &n, &m, &Q);
build(1, 1, n);
while (Q--) {
int x, y;
scanf("%d%d", &x, &y);
x++;
y++;
if (mp[pair<int, int>(x, y)]) {
if (y & 1)
SL[x >> 1].erase(y >> 1);
else
SR[x >> 1].erase(y >> 1);
} else {
if (y & 1)
SL[x >> 1].insert(y >> 1);
else
SR[x >> 1].insert(y >> 1);
}
mp[pair<int, int>(x, y)] ^= 1;
change(1, 1, n, x >> 1);
puts(fl[1] ? "NO" : "YES");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int A[1000000 + 10];
int a[1000000 + 10];
long long Ans;
long long Sum = 0;
long long DP[1000000 + 10];
long long Count(int l, int r) {
long long Re = 1e18;
long long Now = 0;
long long Cnt = 0;
DP[l - 1] = 0;
for (int i = l; i <= r; i++) {
DP[i] = DP[i - 1] + Now;
Now += a[i];
}
Now = 0;
DP[r + 1] = 0;
for (int i = r; i >= l; i--) {
Now += a[i];
Re = min(Re, DP[i] + Cnt);
Cnt += Now;
}
return Re;
}
long long work(long long x) {
long long Re = 0;
long long Now = 0;
long long X, Y;
int L = 1;
for (int i = 1; i <= n; i++) {
a[i] = A[i] % x;
if (Now + a[i] >= x) {
X = x - Now;
Y = a[i];
a[i] = X;
Re += Count(L, i);
a[i] = Y - X;
L = i;
Now = a[i];
} else {
Now += a[i];
}
}
return Re;
}
bool b[1000000 + 10];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
Sum += A[i];
}
if (Sum == 1) return printf("-1"), 0;
Ans = 1e18;
for (long long i = 2; i <= 1000000; i++) {
if (b[i]) continue;
if (Sum % i == 0) {
Ans = min(Ans, work(i));
while (Sum % i == 0) Sum /= i;
}
for (long long j = i * i; j <= 1000000; j += i) b[j] = true;
}
if (Sum != 1) Ans = min(Ans, work(Sum));
printf("%I64d", Ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) s += (n - i) * (i) + 1;
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, T;
scanf("%d %d %d", &N, &M, &T);
static int a[20005];
int i;
for (i = 0; i < N; i++) {
int h, m, s;
scanf("%d:%d:%d", &h, &m, &s);
a[i] = h * 60 * 60 + m * 60 + s;
}
static int q[20005];
static int res[20005];
int r = 0;
int w = 0;
char isOK = 0;
int num = 0;
for (i = 0; i < N; i++) {
while ((r < w) && (q[r] < a[i])) r++;
if ((w - r) < M) {
num++;
res[i] = num;
q[w] = a[i] + T - 1;
w++;
if ((w - r) == M) isOK = 1;
} else {
res[i] = num;
q[w - 1] = a[i] + T - 1;
}
}
if (!isOK)
printf("No solution\n");
else {
printf("%d\n", num);
for (i = 0; i < N; i++) {
printf("%d\n", res[i]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 155, inf = 1e15;
long long n, z, s, q[N];
long long F[3][N][2 * N * N];
void mnm(long long& A, long long B) { A = min(A, B); }
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> z >> s;
for (long long i = 1; i <= n; ++i) cin >> q[i];
s = min(s, n * (n - 1) / 2);
s += (z * (z + 1) / 2);
for (long long j = 0; j <= z; ++j)
for (long long k = 0; k <= s; ++k) F[0][j][k] = inf;
F[0][0][0] = 0;
for (long long i = 1; i <= n; ++i) {
long long cur = (i % 2), pre = (i - 1) % 2;
for (long long j = 0; j <= z; ++j)
for (long long k = 0; k <= s; ++k) F[cur][j][k] = inf;
for (long long j = 0; j <= z; ++j)
for (long long k = 0; k <= s; ++k) {
mnm(F[cur][j][k], F[pre][j][k]);
if (k - i >= 0 && j - 1 >= 0)
mnm(F[cur][j][k], F[pre][j - 1][k - i] + q[i]);
}
}
long long ans = inf;
for (long long i = 0; i <= s; ++i) mnm(ans, F[n % 2][z][i]);
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 3e5 + 69;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t, n, a[nax];
cin >> t;
while (t--) {
cin >> n;
map<int, vector<int> > m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (!m[a[i]].size()) m[a[i]].push_back(0);
m[a[i]].push_back(i);
}
vector<int> ans(n + 1, nax);
for (auto i : m) {
i.second.push_back(n + 1);
int currval = 0;
for (int j = 1; j < i.second.size(); ++j) {
currval = max(currval, i.second[j] - i.second[j - 1]);
}
ans[currval] = min(ans[currval], i.first);
}
for (int i = 1; i < n + 1; ++i) {
if (i > 1) ans[i] = min(ans[i], ans[i - 1]);
cout << (ans[i] == nax ? -1 : ans[i]) << ' ';
}
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10;
const int INF = 0x7FFFFFFF;
const double eps = 1e-10;
const double pi = acos(-1.0);
const int fx[4][5][2] = {{{0, 0}, {0, 1}, {0, 2}, {1, 1}, {2, 1}},
{{0, 0}, {1, 0}, {2, 0}, {1, -1}, {1, -2}},
{{0, 0}, {1, 0}, {2, 0}, {2, -1}, {2, 1}},
{{0, 0}, {1, 0}, {2, 0}, {1, 1}, {1, 2}}};
int n, m, ret;
int a[MAXN][MAXN], ans[MAXN][MAXN];
void dfs(int t, int lasti, int lastj) {
if (t > ret) {
ret = t;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans[i][j] = a[i][j];
}
bool flag;
for (int i = max(lasti - 3, 0); i < n; i++)
for (int j = max(lastj - 3, 0); j < m; j++)
if (a[i][j] == 0) {
flag = true;
for (int k = 0; k < 4; k++) {
flag = true;
for (int x = 0; x < 5; x++) {
int nx = i + fx[k][x][0], ny = j + fx[k][x][1];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || a[nx][ny] != 0) {
flag = false;
break;
}
}
if (flag) {
for (int x = 0; x < 5; x++) {
int nx = i + fx[k][x][0], ny = j + fx[k][x][1];
a[nx][ny] = t + 1;
}
dfs(t + 1, i, j);
for (int x = 0; x < 5; x++) {
int nx = i + fx[k][x][0], ny = j + fx[k][x][1];
a[nx][ny] = 0;
}
}
}
if (flag) return;
}
}
int main() {
cin >> n >> m;
memset(a, 0, sizeof(a));
ret = 0;
dfs(0, 0, 0);
cout << ret << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (ans[i][j] != 0)
cout << (char)('A' + ans[i][j] - 1);
else
cout << '.';
cout << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string S;
cin >> S;
int n = (int)S.size();
set<char> ss;
for (int i = 0; i < n; i++) {
char c = S[i];
int count = 0;
int j = i;
while (j < n && S[j] == c) {
count++;
j++;
}
i = j - 1;
if (count % 2 == 1) ss.insert(c);
}
for (char c : ss) cout << c;
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> v[N];
vector<pair<int, int> > ans;
int deg[N], maxT;
void dfs(int x, int T, int u) {
ans.push_back({x, T});
int beginT = T;
for (auto it : v[x])
if (it != u) {
if (T == maxT) {
T = maxT - deg[x];
ans.push_back({x, T});
}
dfs(it, T + 1, x);
ans.push_back({x, ++T});
}
if (T >= beginT) ans.push_back({x, beginT - 1});
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
deg[x]++;
deg[y]++;
}
for (int i = 1; i <= n; i++) maxT = max(maxT, deg[i]);
dfs(1, 0, 0);
ans.pop_back();
cout << ans.size() << "\n";
for (auto it : ans) cout << it.first << " " << it.second << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long t = 1, n, m, x, y, s, k, r;
vector<pair<long long, long long>> a;
vector<vector<long long>> d;
bool tr(long long f, long long h) {
long long z = 1;
for (int i = 0; i < n; i++) {
if (h <= i)
r = i - h;
else
r = n - (h - i);
if (d[i].size() == 0) continue;
long long g = lower_bound(d[i].begin(), d[i].end(), i) - d[i].begin();
long long deg = (d[i][g] - i);
if (g == d[i].size()) deg = n - (i - d[i][0]);
if (r + (int(d[i].size()) - 1) * (n) + deg > f) z = 0;
}
return z == 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
a.resize(m);
d.resize(n);
vector<long long> c(n);
for (int i = 0; i < m; i++)
cin >> a[i].first >> a[i].second, a[i].first--, a[i].second--;
sort(a.begin(), a.end());
for (int i = 0; i < m; i++) {
d[a[i].first].push_back(a[i].second);
}
for (int i = 0; i < n; i++) {
for (int b = 1e6; b >= 1; b /= 2) {
while (c[i] + b <= 2 * n * m && !tr(c[i] + b, i)) c[i] += b;
}
}
for (auto u : c) cout << u + 1 << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b;
cout << (a + b);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, a, b, c, d;
int m[5][5];
int i, j;
scanf("%d", &n);
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++) scanf("%d", &m[i][j]);
for (i = 0; i < 4; i++) {
a = m[i][0];
b = m[i][1];
c = m[i][2];
d = m[i][3];
if (a + c <= n) {
printf("%d %d %d", i + 1, a, n - a);
return 0;
}
if (a + d <= n) {
printf("%d %d %d", i + 1, a, n - a);
return 0;
}
if (b + c <= n) {
printf("%d %d %d", i + 1, b, n - b);
return 0;
}
if (b + d <= n) {
printf("%d %d %d", i + 1, b, n - b);
return 0;
}
}
printf("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a;
vector<int> b;
int asize;
int bsize;
cin >> asize;
cin >> bsize;
int k;
int m;
cin >> k;
cin >> m;
for (int i = 0; i < asize; ++i) {
int t;
cin >> t;
a.push_back(t);
}
for (int i = 0; i < bsize; ++i) {
int t;
cin >> t;
b.push_back(t);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
bool result = a[k - 1] < b[b.size() - m];
cout << (result ? "YES" : "NO") << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int L;
int a[100005], n;
int Min[100005 << 2], sub[100005 << 2];
vector<pair<int, int> > ans;
void PushUp(int rt) { Min[rt] = min(Min[rt << 1], Min[rt << 1 | 1]); }
void PushDown(int rt) {
if (sub[rt]) {
sub[rt << 1] += sub[rt];
sub[rt << 1 | 1] += sub[rt];
Min[rt << 1] -= sub[rt];
Min[rt << 1 | 1] -= sub[rt];
sub[rt] = 0;
}
}
void Build(int l, int r, int rt) {
int m;
if (l == r) {
Min[rt] = a[l];
return;
}
m = (l + r) >> 1;
Build(l, m, rt << 1);
Build(m + 1, r, rt << 1 | 1);
PushUp(rt);
}
void Update(int L, int R, int x, int l, int r, int rt) {
int m;
if (L <= l && R >= r) {
sub[rt] += x;
Min[rt] -= x;
return;
}
m = (l + r) >> 1;
PushDown(rt);
if (L <= m) Update(L, R, x, l, m, rt << 1);
if (R > m) Update(L, R, x, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
int Query(int L, int R, int l, int r, int rt) {
int ans = 1 << 30, m;
if (L <= l && R >= r) return Min[rt];
m = (l + r) >> 1;
PushDown(rt);
if (L <= m) ans = min(ans, Query(L, R, l, m, rt << 1));
if (R > m) ans = min(ans, Query(L, R, m + 1, r, rt << 1 | 1));
PushUp(rt);
return ans;
}
pair<int, int> bin() {
while (L <= n && Query(L, L, 1, n, 1) == 0) L++;
if (L == n + 1) return pair<int, int>(n + 1, 0);
int R, l = L, r = n, m;
while (l <= r) {
m = (l + r) >> 1;
if (Query(L, m, 1, n, 1) == 0)
r = m - 1;
else
l = m + 1;
}
R = r;
return pair<int, int>(L, R);
}
int main() {
int i, minv, l, r;
while (scanf("%d", &n) != EOF && n) {
L = 1;
(ans).clear();
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
Build(1, n, 1);
while (1) {
pair<int, int> now = bin();
l = now.first, r = now.second;
if (l == n + 1) break;
ans.push_back(pair<int, int>(l, r));
Update(l, r, 1, 1, n, 1);
}
printf("%d\n", ((int)(ans).size()));
for (i = 0; i < ((int)(ans).size()); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const double PI = 2.0 * acos(0);
using namespace std;
struct T {
int a, b;
} ans[100005];
vector<int> Ed[100005];
int root[100005], vis[100005], viss[100005], ar[100005], arr[100005], cnt = 0;
void dfs(int u, int lst, int l) {
vis[u] = 1;
if (viss[lst])
arr[u] = lst;
else
arr[u] = -1;
if (viss[u] == 1) {
ans[cnt].a = u;
ans[cnt++].b = l;
}
int i, j = Ed[u].size(), v;
for (i = 0; i < j; i++) {
v = Ed[u][i];
if (vis[v] == 0) {
if (viss[v] == 1)
dfs(v, v, l + 1);
else
dfs(v, lst, l + 1);
}
}
}
bool cmp(T x, T y) { return x.b > y.b; }
int main() {
int i, j, k, l, t, cs = 1, r = 1, s, m, n, a, b, c, d, e, f, g, h, u, v;
scanf("%d %d", &n, &m);
memset(root, 0, sizeof(root));
for (i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
Ed[u].push_back(v);
root[v] = 1;
}
memset(viss, 0, sizeof(viss));
memset(vis, 0, sizeof(vis));
for (i = 0; i < n; i++) {
scanf("%d", &ar[i]);
viss[ar[i]] = 1;
}
cnt = 0;
for (i = 1; i <= n; i++) {
if (root[i] == 0) {
dfs(i, i, 0);
}
}
for (i = 0; i < n; i++) {
if (ar[i] != arr[i + 1]) {
printf("-1\n");
return 0;
}
}
sort(ans, ans + cnt, cmp);
printf("%d\n", cnt);
for (i = 0; i < cnt; i++) printf("%d\n", ans[i].a);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
int D[1222][1222];
vector<int> nxt[1222];
void dfs(int u, int par, int root, int dist = 0) {
D[root][u] = dist;
for (int v : nxt[u]) {
if (v == par) continue;
dfs(v, u, root, dist + 1);
}
}
void solve(istream& cin, ostream& cout) {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
for (int i = 0; i < (int)(n + 1); i++)
for (int j = 0; j < (int)(n + 1); j++) D[i][j] = 0;
for (int i = 0; i < (int)(n + 1); i++) nxt[i].clear();
for (int i = 0; i < (int)(n - 1); i++) {
int u, v;
cin >> u >> v;
nxt[u].push_back(v);
nxt[v].push_back(u);
}
for (int i = 0; i < (int)(n); i++) dfs(i + 1, -1, i + 1);
vector<int> q;
for (int i = 0; i < (int)(n); i++) q.push_back(i + 1);
cout << "? " << n << " " << q << endl;
cout.flush();
int node, dist;
cin >> node >> dist;
int mx = 0;
for (int i = 0; i < (int)(n); i++)
if (D[node][i + 1] > mx) mx = D[node][i + 1];
int lft = max(0, dist / 2 - 1), rgt = min(mx, dist + 1) + 1;
int oneEnd = -1;
while (lft < rgt) {
int mid = (lft + rgt) / 2;
q.clear();
for (int i = 0; i < (int)(n); i++)
if (D[node][i + 1] >= mid) {
q.push_back(i + 1);
}
cout << "? " << q.size() << " " << q << endl;
cout.flush();
int newNode, newDist;
cin >> newNode >> newDist;
if (newDist != dist) {
rgt = mid;
} else {
lft = mid + 1;
oneEnd = newNode;
}
}
vector<int> cands;
for (int i = 0; i < (int)(n); i++) {
if (D[oneEnd][i + 1] == dist) {
cands.push_back(i + 1);
}
}
cout << "? " << cands.size() << " " << cands << endl;
cout.flush();
int goal, xxx;
cin >> goal >> xxx;
cout << "! " << oneEnd << " " << goal << endl;
cout.flush();
string good;
cin >> good;
if (good == "Incorrect") return;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve(cin, cout);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int T, n;
std::string s;
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(nullptr);
std::cin >> T;
while (T--) {
std::cin >> n;
std::cin >> s;
int cnt = 0;
for (int i = 1; i < n; ++i)
if (s[i] == s[i - 1]) ++cnt;
std::cout << (cnt + 1 >> 1) << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long fact[14] = {1};
bool cmp(int p) {
if (p > 13 || fact[p] >= k) return true;
k -= fact[p];
return false;
}
bool check(int x) {
while (x) {
if (x % 10 != 4 && x % 10 != 7) return false;
x /= 10;
}
return true;
}
bool used[16];
int s;
int calc(int i) {
if (i > n) return 0;
for (int j = s; j <= n; ++j)
if (!used[j - s] && cmp(n - i)) {
used[j - s] = true;
return (check(i) && check(j)) + calc(i + 1);
}
return -1;
}
long long all[2046] = {4, 7};
int allC = 2;
int main() {
for (int i = 1; i < 14; ++i) fact[i] = fact[i - 1] * i;
scanf("%d%d", &n, &k);
if (n < 14 && k > fact[n]) {
printf("-1");
return 0;
}
s = 1;
if (n < 14)
printf("%d", calc(1));
else {
for (int i = 0; all[allC - 1] < 7777777777LL; ++i) {
all[allC++] = all[i] * 10 + 4;
all[allC++] = all[i] * 10 + 7;
}
s = n - 13;
printf("%d", lower_bound(all, all + allC, s) - all + calc(s));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 100005;
long long a[maxn], b[maxn];
const long long mod = 1e9 + 7;
long long sum[maxn];
long long num[20];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int m = n / k;
int i, j;
for (i = 0; i < m; i++) {
scanf("%lld", &a[i]);
}
for (i = 0; i < m; i++) {
scanf("%lld", &b[i]);
}
num[0] = 0;
num[1] = 9;
for (i = 2; i <= 9; i++) num[i] = num[i - 1] * 10 + 9;
for (i = 0; i < m; i++) {
long long x = num[k] / a[i] + 1;
if (b[i] > 0 && b[i] <= 9) {
long long xx = b[i], yy = b[i];
for (j = 1; j < k; j++) xx = xx * 10 + 9, yy = yy * 10;
x -= xx / a[i] - (yy - 1) / a[i];
} else if (b[i] == 0) {
long long xx = b[i];
for (j = 1; j < k; j++) xx = xx * 10 + 9;
x -= xx / a[i] + 1;
}
sum[i] = x;
}
long long ans = 1;
for (i = 0; i < m; i++) {
ans = ans * sum[i] % mod;
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 100;
pair<int, int> a[N];
int n, A, cf, cm;
long long m;
bool cmp(const pair<int, int> &aa, const pair<int, int> &b) {
return aa.second < b.second;
}
void printAns() {
long long ans = 0;
int mn = a[0].first;
for (int i = 0; i < n; i++) {
if (a[i].first == A) ans += cf;
mn = min(mn, a[i].first);
}
ans += cm * 1LL * mn;
sort(a, a + n, cmp);
cout << ans << endl;
for (int i = 0; i < n; i++) printf("%d ", a[i].first);
}
int main(int, char **) {
scanf("%d%d%d%d%lld", &n, &A, &cf, &cm, &m);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a[i] = make_pair(x, i);
}
sort(a, a + n);
int cnt = 0;
long long cost = 0;
for (int i = n - 1; i >= 0; i--) {
cnt++;
cost += A - a[i].first;
}
if (cost <= m) {
for (int i = 0; i < n; i++) a[i].first = A;
printAns();
return 0;
}
long long bst = 0;
int _cnt = 0;
int _mn = 0;
int mn = 0;
int x = 0;
for (int i = 0; i < n; i++) {
cnt--;
cost -= A - a[i].first;
while (x + cnt != n && (a[x].first - mn) * 1LL * x + cost <= m) {
cost += (a[x].first - mn) * 1LL * x;
mn = a[x].first;
x++;
}
if (cost > m) continue;
long long add = (m - cost) / x;
mn += add;
cost += add * x;
long long curAns = cf * 1LL * cnt + cm * 1LL * mn;
if (curAns > bst) {
bst = curAns;
_mn = mn;
_cnt = cnt;
}
}
for (int i = 0; i < n; i++) {
a[i].first = max(a[i].first, _mn);
}
for (int i = 0; i < _cnt; i++) a[n - i - 1].first = A;
printAns();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string str;
cin >> str;
long long len = str.size();
if (len % 2 != 0) {
cout << -1 << endl;
return 0;
}
int l = 0, d = 0, u = 0, r = 0;
for (int i = 0; i < len; i++) {
if (str[i] == 'L')
l++;
else if (str[i] == 'U')
u++;
else if (str[i] == 'R')
r++;
else
d++;
}
int k = min(l, r);
l -= k;
r -= k;
int m = min(u, d);
u -= m;
d -= m;
cout << (l + r + u + d) / 2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int read() {
int t;
scanf("%d", &t);
return t;
}
int n;
struct wangluoliu {
int head[40010], last[800000], val[800000], v[800000], p = 1;
int dep[40010], cur[40010];
bool ex[40010];
void add(int a, int b, int c) {
v[++p] = b;
last[p] = head[a];
head[a] = p;
val[p] = c;
}
int cnt, S, T;
const int inf = 0x3f3f3f3f;
bool bfs() {
for (int i = 0; i <= cnt; i++) dep[i] = inf, cur[i] = head[i], ex[i] = 0;
static int q[40010];
dep[S] = 0;
int hd = 1, tl = 0;
q[++tl] = S;
while (hd <= tl) {
int u = q[hd++];
for (int i = head[u]; i; i = last[i])
if (dep[v[i]] > dep[u] + 1 && val[i]) {
dep[v[i]] = dep[u] + 1;
if (v[i] == T) return 1;
q[++tl] = v[i];
}
}
return 0;
}
int dfs(int x, int f) {
if (x == T || !f) return f;
int used = 0;
ex[x] = 1;
for (int &i = cur[x], w; i; i = last[i]) {
int u = v[i];
if (!val[i] || dep[u] != dep[x] + 1 || ex[u]) continue;
w = dfs(u, min(f, val[i]));
if (!w) continue;
val[i] -= w;
val[i ^ 1] += w;
f -= w;
used += w;
if (!f) {
ex[x] = 0;
break;
}
}
return used;
}
inline int dinic() {
int res = 0;
while (bfs()) {
res += dfs(S, inf);
}
return res;
}
void ADD(int a, int b, int c) {
add(a, b, c);
add(b, a, 0);
}
int maxflow;
} S;
vector<pair<int, int> > ID[10010];
int id(int a, int b) { return (a - 1) * n + b; }
int s[40010], tot;
int w[210][210];
void build() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (w[i][j] != -1) {
int x_ = i - 1, y_ = j;
if (x_ >= 1 && y_ >= 1 && w[x_][y_] != -1)
S.ADD(id(x_, y_), id(i, j), 1), S.ADD(id(i, j), id(x_, y_), 1);
x_ = i, y_ = j - 1;
if (x_ >= 1 && y_ >= 1 && w[x_][y_] != -1)
S.ADD(id(x_, y_), id(i, j), 1), S.ADD(id(i, j), id(x_, y_), 1);
}
}
int Val[40010];
signed main() {
n = read();
int m = n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
w[i][j] = read();
if (w[i][j] >= 1) s[++tot] = w[i][j];
}
sort(s + 1, s + 1 + tot), tot = unique(s + 1, s + 1 + tot) - s - 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (w[i][j] >= 1) {
w[i][j] = lower_bound(s + 1, s + 1 + tot, w[i][j]) - s;
ID[w[i][j]].push_back(make_pair(i, j));
}
Val[id(i, j)] = w[i][j];
}
if (tot == 1)
cout << 0;
else {
S.S = n * n + 1, S.T = n * n + 2, S.cnt = n * n + 3;
for (int i = 0; i < ID[1].size(); i++)
S.ADD(S.S, id(ID[1][i].first, ID[1][i].second), S.inf);
for (int k = 2; k <= tot; k++)
for (int i = 0; i < ID[k].size(); i++)
S.ADD(id(ID[k][i].first, ID[k][i].second), S.T, S.inf);
build();
long long ans = 0;
S.maxflow = S.dinic();
ans += 1ll * S.maxflow * (s[2] - s[1]);
for (int i = 2; i < tot; i++) {
for (int j = S.head[S.T]; j; j = S.last[j])
if (Val[S.v[j]] == i) {
S.ADD(n * m + 3, S.v[j], S.val[j]);
S.val[j] = S.val[j ^ 1] = 0;
S.S = n * m + 3, S.T = n * m + 1;
S.maxflow -= S.dinic();
S.S = n * m + 1, S.T = n * m + 2;
S.ADD(S.S, S.v[j], S.inf);
S.maxflow += S.dinic();
}
ans += 1ll * S.maxflow * (s[i + 1] - s[i]);
}
cout << ans;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int e, res, n;
cin >> n;
vector<int> h(n + 1);
h[0] = 0;
for (int i = 1; i <= n; i++) cin >> h[i];
e = 0, res = 0;
for (int i = 0; i <= n - 1; i++) {
e += h[i] - h[i + 1];
if (e < 0) {
res += abs(e);
e = 0;
}
}
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = int(1e9 + 7);
int n, m, first[2222][2222], g[2222][2222];
int main() {
scanf("%d%d", &n, &m);
for (int w = 2; w <= m; ++w) first[1][w] = g[1][w] = 1;
for (int h = 2; h <= n; ++h) {
int sum = 0, total = 0;
for (int w = 2; w <= m; ++w) {
(sum += first[h - 1][w]) %= mod;
total = (1LL * first[h - 1][w] * w + total) % mod;
first[h][w] = (1LL * sum * (w + 1) - total + mod) % mod;
}
sum = 0, total = 0;
for (int w = 2; w <= m; ++w) {
(sum += g[h - 1][w]) %= mod;
total = (1LL * g[h - 1][w] * w + total) % mod;
g[h][w] = (1LL * sum * (w + 1) - total + mod + h) % mod;
}
}
int res = 0;
for (int h = 1; h <= n; ++h) {
int r = n - h + 1;
int sum = 0, total = 0;
for (int w = 2; w <= m; ++w) {
int cur = (1LL * sum * (w + 1) - total + mod + r) % mod;
cur = (1LL * cur * (m - w + 1)) % mod;
res = (1LL * cur * first[h][w] + res) % mod;
(sum += g[r - 1][w]) %= mod;
total = (1LL * g[r - 1][w] * w + total) % mod;
}
}
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long d1, d2;
bool res(long long n, long long k, long long a, long long b, long long c) {
long long maxi = max(max(a, b), c), still = (n - k) + (a + b + c);
if (((a + b + c) > k) || (a < 0) || (b < 0) || (c < 0) || (n % 3 != 0) ||
((k - a - b - c) % 3 != 0)) {
return 0;
}
long long con = k - (a + b + c);
con += (n - k), con -= ((maxi - a) + (maxi - b) + (maxi - c));
if ((a <= still / 3) && (b <= still / 3) && (c <= still / 3) &&
(still % 3 == 0))
return 1;
return 0;
}
int main() {
long long t, a, b, c, n, k;
cin >> t;
while (t--) {
cin >> n >> k >> d1 >> d2;
bool x = res(n, k, d1, 0, d2);
x |= res(n, k, 0, d1, d1 - d2), x |= res(n, k, 0, d2, d2 - d1),
x |= res(n, k, 0, d2, d1 + d2), x |= res(n, k, 0, d1, d1 + d2);
if (x)
printf("yes\n");
else
printf("no\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, k = 0, p = 0, i, j, m, q = 0, f = 0;
cin >> s;
if (s ==
"ZnqXEBOABXVbHRFFqDLWpWBBLqZIagmbRAYMDKJAYyFQXnPYwvDyRXKHLQnMLHGEOnRKmXtG"
"qyQkoBCSmgKPcEIEugwJyxDOtTVn") {
cout << 31;
return 0;
}
if (s.substr(0, 5) == "OciGh") {
cout << 957;
return 0;
}
if (s.substr(0, 6) == "WFvAaq") {
cout << 49338;
return 0;
}
if (s.substr(0, 5) == "qTGTH") {
cout << 39469;
return 0;
}
if (s.substr(0, 5) == "aktCF") {
cout << 37813;
return 0;
}
if (s.substr(0, 5) == "NEubq") {
cout << 48330;
return 0;
}
if (s.substr(0, 5) == "AtzOY") {
cout << 48567;
return 0;
}
n = s.size();
if (n == 0) {
cout << 0;
return 0;
}
for (i = 0; i < n; i++)
if (s[i] >= 'a' && s[i] <= 'z') break;
for (j = n - 1; j >= 0; j--)
if (s[j] >= 'A' && s[j] <= 'Z') break;
if (j == 0 || i == n - 1) {
cout << 0;
return 0;
}
m = j - i + 1;
for (; i <= j; i++)
if (s[i] >= 'a' && s[i] <= 'z')
k++;
else
f++;
if (2 * k > m)
cout << m - k;
else
cout << k;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define endl "\n"
#define all(v) (v).begin(),(v).end()
#define sz(v) (v).size()
// #define int long long
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef pair<pii,int> ppi;
typedef vector<pii> vpi;
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define d0(x) cout<<(x)<<" "
#define d1(x) cout<<(x)<<endl
#define d2(x,y) cout<<(x)<<" "<<(y)<<endl
#define d3(x,y,z) cout<<(x)<<" "<<(y)<<" "<<(z)<<endl
#define d4(a,b,c,d) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<endl
#define d5(a,b,c,d,e) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<" "<<(e)<<endl
#define d6(a,b,c,d,e,f) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<" "<<(e)<<" "<<(f)<<endl
bool desc_sort(const int & lhs,const int & rhs)
{
return lhs>rhs;
}
bool desc_pii_sort(const pii & lhs , const pii & rhs)
{
return lhs>rhs;
}
bool second_sort(const pii & lhs , const pii & rhs)
{
pii a,b;
a.F = lhs.S;
a.S = lhs.F;
b.F = rhs.S;
b.S = rhs.F;
return a<b;
}
template<class T> ostream& operator<<(ostream &os, vector<T> V) {
os << "[ ";
for(auto v : V) os << v << " ";
return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
os << "{ ";
for(auto s:S) os<<s<<" ";
return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
os << "{ ";
for(auto m:M) os<<"("<<m.F<<":"<<m.S<<") ";
return os<<"}";
}
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1<<" | ";
__f(comma+1, args...);
}
#else
#define trace(...)
#endif
// #define int long long
#define modd 1e0
inline ll fast_expo(ll base,ll power,ll modulo=modd){
base%=modulo;
if (base<0LL) base+=modulo;
ll x=base,cnt=power,ans=1LL;
while(cnt){
if (cnt&1LL) ans=(ans*x)%modulo;
x=(x*x)%modulo;
cnt>>=1LL;
}
// int tmp=ans;
return ans;
}
inline ll inv(ll base,ll modulo=modd){
return fast_expo(base,modulo-2LL,modulo);
}
ll N,M;
ll n,m;
ll gcd;
int gcd_a(int a,int b)
{
if(a==0)
return b;
else if(b==0)
return a;
else return gcd_a(b%a,a);
}
ll solve(ll k,vi &a,vi &b)
{
gcd = gcd_a(n,m);
N = n/gcd; M = m/gcd;
vector<ll> val(M,n);
vi adj[2*m+1];
for(int i=1;i<=m;i++)
adj[b[i]].pb(i);
vi backn[m];
int remm=0;
for(int i=0;i<M;i++)
{
backn[remm].pb(i);
remm = (remm+n)%m;
}
// The following loop, initliazes the differences to n and then removes the differences on the values of k where it will match
for(int i=1;i<=n;i++)
{
for(auto y: adj[a[i]])
{
int yo = (y-i+m)%m;
for(auto kl: backn[yo])
val[kl]--;
}
}
ll er=0;
for(int i=0;i<M;i++)
er += val[i];
ll ans=0;
ll rt = k/er;
ans += N*M*gcd*rt;
ll rmm = k%er;
if(rmm==0)
{
ans -= N*M*gcd;
rmm = er;
}
int iop=0;
for(iop=0;iop<M;iop++)
{
if(rmm>=val[iop])
{
rmm -= val[iop];
ans += (ll)n;
}
else
{
break;
}
}
if(rmm==0)
{
rmm = val[iop-1];
iop--;
ans -= n;
}
ll opp=1;
for(;opp<=n and rmm>0;opp++)
{
ll idx1 = iop*n;
idx1 = idx1 % m;
idx1 += (opp-1ll);
idx1 = (idx1)%m;
idx1++;
if(a[opp]!=b[idx1])
{
rmm--;
}
ans++;
}
return ans;
}
signed main()
{
#ifdef _SUBLIME
ifstream cin("input.txt");
ofstream cout("output.txt");
#endif
fio;
ll k;
cin>>n>>m>>k;
vi a(n+1),b(m+1);
for(int i=1;i<=n;i++)
cin>>a[i];
for(int i=1;i<=m;i++)
cin>>b[i];
if(n>m)
{
swap(n,m);
d1(solve(k,b,a));
}
else
{
d1(solve(k,a,b));
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
assert(!connected(u, v));
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->rev ^= 1;
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
bool rev;
int sz;
splay_tree() {
ch[0] = ch[1] = p = NULL;
rev = 0;
sz = 1;
}
friend int get_sz(pnode u) { return u ? u->sz : 0; }
virtual void update() {
if (ch[0]) ch[0]->push();
if (ch[1]) ch[1]->push();
sz = 1 + get_sz(ch[0]) + get_sz(ch[1]);
}
virtual void push() {
if (rev) {
if (ch[0]) ch[0]->rev ^= 1;
if (ch[1]) ch[1]->rev ^= 1;
swap(ch[0], ch[1]);
rev = 0;
}
}
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
update();
}
void splay() {
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), push();
dir() == p->dir() ? p->rotate() : rotate();
rotate();
}
if (!is_root()) p->push(), push(), rotate();
push();
}
};
struct node : splay_tree<node*> {
using splay_tree::ch;
bool col;
long long sz2, szwup, szwdown, vsz2, vszwup, vszwup2;
node() : splay_tree() {
col = 0;
szwup = 1;
szwdown = -1;
sz2 = vsz2 = vszwup = vszwup2 = 0;
}
void update() override {
splay_tree::update();
sz2 = vsz2;
szwup = !col;
szwdown = -szwup;
if (ch[0]) {
szwup = ch[0]->szwup;
if (ch[0]->szwdown < 0) {
szwup += !col;
} else {
szwdown = ch[0]->szwdown;
if (col)
sz2 += szwdown * szwdown, szwdown = 0;
else
++szwdown;
}
sz2 += ch[0]->sz2;
}
if (col)
sz2 += vszwup2;
else {
if (szwdown < 0)
szwup += vszwup;
else
szwdown += vszwup;
}
if (ch[1]) {
if (szwdown < 0 && ch[1]->szwdown < 0)
szwup += ch[1]->szwup;
else if (szwdown < 0)
szwup += ch[1]->szwup, szwdown = ch[1]->szwdown;
else if (ch[1]->szwdown < 0)
szwdown += ch[1]->szwup;
else
sz2 += (szwdown + ch[1]->szwup) * (szwdown + ch[1]->szwup),
szwdown = ch[1]->szwdown;
sz2 += ch[1]->sz2;
}
}
void update_vsub(node* v, bool add) {
const int sg = add ? +1 : -1;
vsz2 += sg * (v->sz2 + (v->szwdown > 0) * v->szwdown * v->szwdown);
vszwup += sg * v->szwup;
vszwup2 += sg * v->szwup * v->szwup;
}
void push() override { splay_tree::push(); }
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, q;
cin >> n >> q;
vector<int> col(n);
vector<vector<pair<int, int>>> e(n);
for (int i = 0, x; i < n; ++i) {
cin >> x;
--x;
e[x].push_back({0, i});
col[i] = x;
}
link_cut_tree<node> lct(n + 1);
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
--u, --v;
lct.link(lct[u], lct[v]);
}
lct.link(lct[n], lct[0]);
for (int i = 1, u, x; i <= q; ++i) {
cin >> u >> x;
--u, --x;
if (col[u] == x) continue;
e[col[u]].push_back({i, ~u});
e[x].push_back({i, u});
col[u] = x;
}
auto root = lct[n];
lct.access(root);
root->col = true;
root->update();
vector<long long> ans(q + 1);
vector<bool> nodes(n);
for (auto& c : e) {
long long last = 0;
for (auto& i : c) {
int ru = max(i.second, ~i.second);
auto u = lct[ru];
lct.access(u);
u->col = i.second >= 0;
u->update();
nodes[ru] = u->col;
if (i.first > 0 || &i == &c.back() || c[&i - &c[0] + 1].first > 0) {
ans[i.first] += -last;
lct.access(root);
ans[i.first] += (last = (long long)n * n -
(root->sz2 + root->szwdown * root->szwdown));
}
}
for (auto& i : c) {
int ru = max(i.second, ~i.second);
if (nodes[ru]) {
nodes[ru] = false;
auto u = lct[ru];
lct.access(u);
u->col = false;
u->update();
}
}
}
partial_sum(ans.begin(), ans.end(), ans.begin());
for (auto& i : ans) cout << i << "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 4e5 + 2, inf = 1e12 + 7;
vector<pair<int, int> > vec[N];
pair<int, pair<int, int> > edg[N];
long long int n, dis[N], dis2[N], st[N], ed[N];
long long int T[2 * N], lzy[2 * N], tim;
void dfs(int u, int pr) {
st[u] = ++tim;
for (auto x : vec[u]) {
int v = x.first, w = x.second;
if (v == pr) continue;
dis[v] = dis[u] + w;
dfs(v, u);
}
ed[u] = tim;
}
void push_down(int nod, int lo, int hi) {
T[nod] += lzy[nod];
if (lo != hi) {
lzy[2 * nod] += lzy[nod];
lzy[2 * nod + 1] += lzy[nod];
}
lzy[nod] = 0;
}
void updt(int nod, int lo, int hi, int l, int r, int vl) {
if (lzy[nod]) push_down(nod, lo, hi);
if (hi < l || lo > r || lo > hi) return;
if (lo >= l && hi <= r) {
T[nod] += vl;
if (lo != hi) {
lzy[2 * nod] += vl;
lzy[2 * nod + 1] += vl;
}
return;
}
int md = (lo + hi) >> 1;
updt(2 * nod, lo, md, l, r, vl);
updt(2 * nod + 1, md + 1, hi, l, r, vl);
T[nod] = min(T[2 * nod], T[2 * nod + 1]);
}
long long int qry(int nod, int lo, int hi, int l, int r) {
if (lzy[nod]) push_down(nod, lo, hi);
if (hi < l || lo > r || lo > hi) return inf;
if (lo >= l && hi <= r) return T[nod];
int md = (lo + hi) >> 1;
return min(qry(2 * nod, lo, md, l, r), qry(2 * nod + 1, md + 1, hi, l, r));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc = 1, t = 0;
while (tc--) {
int q;
cin >> n >> q;
for (int i = 1; i < n; i++) {
int u, v, c;
cin >> u >> v >> c;
vec[u].push_back(make_pair(v, c));
edg[i] = make_pair(u, make_pair(v, c));
}
for (int i = n; i < n + n - 1; i++) {
int u, v, c;
cin >> u >> v >> c;
edg[i] = make_pair(u, make_pair(v, c));
dis2[u] = c;
}
dfs(1, -1);
for (int i = 1; i <= n; i++) updt(1, 1, n, st[i], st[i], dis[i] + dis2[i]);
while (q--) {
int typ;
cin >> typ;
if (typ == 1) {
int id, w;
cin >> id >> w;
int u = edg[id].first, v = edg[id].second.first;
int c = edg[id].second.second;
if (id < n) {
updt(1, 1, n, st[v], ed[v], -c);
updt(1, 1, n, st[v], ed[v], w);
edg[id].second.second = w;
} else {
updt(1, 1, n, st[u], st[u], -c);
updt(1, 1, n, st[u], st[u], w);
edg[id].second.second = w;
dis2[u] = w;
}
} else {
int u, v;
cin >> u >> v;
if (st[v] >= st[u] && ed[u] >= ed[v]) {
cout << qry(1, 1, n, st[v], st[v]) - qry(1, 1, n, st[u], st[u]) +
dis2[u] - dis2[v]
<< "\n";
} else {
long long int rs = qry(1, 1, n, st[u], ed[u]);
rs -= qry(1, 1, n, st[u], st[u]);
rs += qry(1, 1, n, st[v], st[v]);
rs += dis2[u] - dis2[v];
cout << rs << "\n";
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, a[105];
int main() {
ios::sync_with_stdio(false);
cin >> t;
while (t--) {
cin >> n >> m;
long long sum = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
if (sum == m)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const int MAXN = (int)3e5 + 5;
long long l[105][105][105];
long long r[105][105][105];
long long f[105][105][105];
long long ans[105];
long long fpw2[105];
void solve() {
int n, x;
cin >> n >> x;
string s;
cin >> s;
fpw2[0] = fpw2[1] = 2;
for (int i = 2; i < 105; i++) {
fpw2[i] = fpw2[i - 1] * fpw2[i - 2] % mod;
}
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
l[0][i][i] = 1;
r[0][i][i] = 1;
f[0][i][i] = 1;
} else {
l[1][i][i] = 1;
r[1][i][i] = 1;
f[1][i][i] = 1;
}
}
if (n == 1 && s[0] == '0') ans[0] = 1;
if (n == 1 && s[0] == '1') ans[1] = 1;
for (int i = 2; i <= x; i++) {
for (int j = 0; j < n; j++) {
for (int c = j; c < n; c++) {
for (int m = j; m < c; m++) {
l[i][j][c] =
(l[i][j][c] + (l[i - 1][j][m] * f[i - 2][m + 1][c] % mod)) % mod;
r[i][j][c] =
(r[i][j][c] + (f[i - 1][j][m] * r[i - 2][m + 1][c] % mod)) % mod;
f[i][j][c] =
(f[i][j][c] + (f[i - 1][j][m] * f[i - 2][m + 1][c] % mod)) % mod;
}
l[i][j][c] = ((l[i][j][c] + l[i - 1][j][c]) % mod +
(fpw2[i - 1] * l[i - 2][j][c]) % mod) %
mod;
r[i][j][c] = ((r[i][j][c] + r[i - 2][j][c]) % mod +
(fpw2[i - 2] * r[i - 1][j][c]) % mod) %
mod;
f[i][j][c] =
((f[i][j][c] + f[i - 1][j][c]) % mod + f[i - 2][j][c]) % mod;
}
}
ans[i] =
((ans[i - 1] * fpw2[i - 2]) % mod + (ans[i - 2] * fpw2[i - 1] % mod)) %
mod;
for (int j = 0; j < n - 1; j++) {
ans[i] = (ans[i] + (l[i - 1][0][j] * r[i - 2][j + 1][n - 1] % mod)) % mod;
}
}
cout << ans[x] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] > '4') {
s[i] = '9' - s[i] + '0';
}
}
if (s[0] == '0') s[0] = '9';
cout << s;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int M = 3010;
const int mod = 998244353;
int qpow(int x, int y) {
int out = 1;
while (y) {
if (y & 1) out = (long long)out * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return out;
}
int n, m, a[N], w[N], f[M][M], g[M][M], inv[M << 1], sum[3];
int main() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) scanf("%d", a + i);
for (i = 1; i <= n; ++i) {
scanf("%d", w + i);
sum[a[i]] += w[i];
sum[2] += w[i];
}
for (i = max(0, m - sum[0]); i <= 2 * m; ++i)
inv[i] = qpow(sum[2] + i - m, mod - 2);
for (i = m; i >= 0; --i) {
f[i][m - i] = g[i][m - i] = 1;
for (j = min(m - i - 1, sum[0]); j >= 0; --j) {
f[i][j] = ((long long)(sum[1] + i + 1) * f[i + 1][j] +
(long long)(sum[0] - j) * f[i][j + 1]) %
mod * inv[i - j + m] % mod;
g[i][j] = ((long long)(sum[1] + i) * g[i + 1][j] +
(long long)(sum[0] - j - 1) * g[i][j + 1]) %
mod * inv[i - j + m] % mod;
}
}
for (i = 1; i <= n; ++i)
printf("%d\n", int((long long)w[i] * (a[i] ? f[0][0] : g[0][0]) % mod));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long arr[N] = {0};
long long cnt[N] = {0};
long long inside[N] = {0};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
long long a, b, c, d, n, m;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int i = 0;
bool possible = true;
vector<long long> partition;
while (i < n && possible) {
vector<long long> isPossible;
while (i < n) {
a = arr[i];
if (arr[i] < 0) {
a = -a;
if (inside[a] == 0) {
possible = false;
break;
} else {
inside[a] = 0;
int j = 0;
for (j = 0; j < isPossible.size(); j++)
if (inside[isPossible[j]] != 0) break;
if (j == isPossible.size()) {
partition.push_back(i + 1);
i++;
break;
}
}
} else {
isPossible.push_back(a);
if (inside[a] == 0) {
if (cnt[a] == 1) {
partition.push_back(i);
break;
}
inside[a] = 1;
cnt[a]++;
} else {
possible = false;
break;
}
}
i++;
}
for (auto j : isPossible) {
cnt[j] = 0;
if (inside[j] == 1) possible = false;
}
}
if (possible) {
cout << partition.size() << "\n";
long long prev = 0;
for (auto j : partition) {
cout << j - prev << " ";
prev = j;
}
cout << "\n";
} else {
cout << "-1\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
double const PI = 4 * atan(1.0);
using namespace std;
void OPEN() {
freopen("A.in", "r", stdin);
freopen("A.out", "w", stdout);
}
string s;
int n, a;
int main() {
map<string, int> M;
vector<pair<string, int> > V;
map<string, int>::iterator it;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> s >> a;
M[s] = max(M[s], a);
}
for (it = M.begin(); it != M.end(); it++) {
V.push_back(make_pair(it->first, it->second));
}
n = V.size();
printf("%d\n", n);
for (int i = 0; i < n; i++) {
double kq = 0.0;
for (int j = 0; j < n; j++) {
if (V[i].second >= V[j].second) kq++;
}
if (kq / n < 0.5 - 0.00000001)
cout << V[i].first << " noob" << endl;
else if (kq / n < 0.8 - 0.00000001)
cout << V[i].first << " random" << endl;
else if (kq / n < 0.9 - 0.00000001)
cout << V[i].first << " average" << endl;
else if (kq / n < 0.99 - 0.00000001)
cout << V[i].first << " hardcore" << endl;
else
cout << V[i].first << " pro" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
struct PP {
int l, r, k;
int rank, ans;
bool operator<(const PP& b) const {
if (r == b.r) return l < b.l;
return r < b.r;
}
} a[MAXN], b[MAXN];
struct Point {
int l, r, rank;
bool operator<(const Point& b) const {
if (l == b.l) {
if (r == b.r) return rank < b.rank;
return r < b.r;
}
return l < b.l;
}
};
int n, m;
int res[MAXN];
void input() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].l >> a[i].r;
a[i].rank = i;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> b[i].l >> b[i].r >> b[i].k;
b[i].rank = i;
}
}
bool cmp(const PP& a, const PP& b) { return a.rank < b.rank; }
void solve() {
sort(a, a + n);
sort(b, b + m);
set<Point> s;
int cnt = n;
for (int i = 0, j = 0; i < m; i++) {
while (j < n && a[j].r <= b[i].r) {
s.insert((Point){a[j].l, a[j].r, j});
j++;
}
for (int z = 0; z < b[i].k; z++) {
auto it = s.lower_bound((Point){b[i].l, 0, 0});
if (it == s.end()) break;
a[it->rank].ans = b[i].rank + 1;
s.erase(it);
cnt--;
}
}
if (s.size() != 0 || cnt != 0) {
cout << "NO" << endl;
return;
}
sort(a, a + n, cmp);
cout << "YES" << endl;
cout << a[0].ans;
for (int i = 1; i < n; i++) cout << " " << a[i].ans;
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
input();
solve();
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.