solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 100 + 10;
char mat[N][N];
char flip(char ch) {
if (ch == '1') return '0';
return '1';
}
void update(long long a, long long b, long long c, long long d, long long e,
long long f) {
mat[a][b] = flip(mat[a][b]);
mat[c][d] = flip(mat[c][d]);
mat[e][f] = flip(mat[e][f]);
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
t = 1;
cin >> t;
for (long long tc = 0; tc < t; tc++) {
long long n, m;
cin >> n >> m;
memset(mat, '0', sizeof(mat));
for (long long i1 = 0; i1 < n; i1++) {
for (long long j1 = 0; j1 < m; j1++) cin >> mat[i1][j1];
}
long long cnt = 0;
vector<vector<long long> > ans;
for (long long i = 0; i + 2 < n; i++) {
for (long long j = 0; j < m; j++) {
if (mat[i][j] == '1') {
cnt++;
if (j + 1 < m) {
update(i, j, i + 1, j, i + 1, j + 1);
ans.push_back({i, j, i + 1, j, i + 1, j + 1});
} else {
update(i, j, i + 1, j, i + 1, j - 1);
ans.push_back({i, j, i + 1, j, i + 1, j - 1});
}
}
}
}
for (long long j = 0; j + 1 < m; j++) {
if (mat[n - 2][j] == '1' && mat[n - 1][j] == '1') {
ans.push_back({n - 2, j, n - 1, j, n - 1, j + 1});
update(n - 2, j, n - 1, j, n - 1, j + 1);
} else if (mat[n - 2][j] == '1' && mat[n - 1][j] == '0') {
ans.push_back({n - 2, j, n - 2, j + 1, n - 1, j + 1});
update(n - 2, j, n - 2, j + 1, n - 1, j + 1);
} else if (mat[n - 2][j] == '0' && mat[n - 1][j] == '1') {
ans.push_back({n - 1, j, n - 1, j + 1, n - 2, j + 1});
update(n - 1, j, n - 1, j + 1, n - 2, j + 1);
}
}
if (mat[n - 2][m - 1] == '1' && mat[n - 1][m - 1] == '1') {
ans.push_back({n - 1, m - 2, n - 2, m - 2, n - 2, m - 1});
ans.push_back({n - 1, m - 1, n - 1, m - 2, n - 2, m - 2});
} else if (mat[n - 2][m - 1] == '1' && mat[n - 1][m - 1] == '0') {
ans.push_back({n - 2, m - 1, n - 1, m - 1, n - 1, m - 2});
ans.push_back({n - 1, m - 2, n - 2, m - 2, n - 2, m - 1});
ans.push_back({n - 2, m - 2, n - 2, m - 1, n - 1, m - 1});
} else if (mat[n - 2][m - 1] == '0' && mat[n - 1][m - 1] == '1') {
ans.push_back({n - 2, m - 1, n - 1, m - 1, n - 1, m - 2});
ans.push_back({n - 1, m - 2, n - 2, m - 2, n - 1, m - 1});
ans.push_back({n - 2, m - 2, n - 2, m - 1, n - 1, m - 1});
}
cout << (long long)ans.size() << '\n';
for (auto w : ans) {
for (auto v : w) cout << (1 + v) << " ";
cout << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
long long int n, m;
cin >> n >> m;
if (n % 10 == 0) {
cout << "1";
} else if (n % 10 == m) {
cout << "1";
} else {
long long int temp;
for (int i = 2;; ++i) {
temp = n * i;
if (temp % 10 == 0) {
cout << i;
break;
} else if (temp % 10 == m) {
cout << i;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MAX = 2e5 + 5;
const long long MAX2 = 11;
const long long MOD = 998244353;
const long long MOD2 = 1000000006;
const long long INF = 2e18;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 316;
int n, q, push_front[MAX], le[MAX], ri[MAX], l[MAX], r[MAX], cl[MAX], jlh[MAX],
cnt, a, b, len, id, ls;
long long hs[MAX], x[MAX], key, tmp, pj, t2;
bool z[MAX], st;
char c;
pair<long long, int> res;
inline pair<long long, int> f(int a, int b) {
if (a > b) return {0, 0};
int len = b - a + 1;
return {x[b] - x[a - 1] * hs[len], len};
}
inline pair<long long, int> comp(int a, int b) {
tmp = pj = st = 0;
if (z[a]) {
if (ri[a] - a + 1 & 1) ++pj;
a = ri[a] + 1;
}
if (z[b]) {
if (b - le[b] + 1 & 1) st = 1;
b = le[b] - 1;
}
if (cl[a] == cl[b]) {
tmp = l[a] + r[b] - jlh[cl[a]];
if (st) tmp *= key;
return {tmp, 1 + pj + st};
}
res = f(cl[a] + 1, cl[b] - 1);
tmp = (l[a] * hs[res.second] + res.first) * key + r[b];
if (st) tmp *= key;
return {tmp, cl[b] - cl[a] + 1 + pj + st};
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
key = 2000003153;
cin >> n;
hs[0] = 1;
for (int i = 1; i <= n; ++i) {
cin >> c, z[i] = (c == '1'), push_front[i] = push_front[i - 1] + z[i],
hs[i] = hs[i - 1] * key;
if (z[i]) {
st ^= 1;
if (le[i - 1])
le[i] = le[i - 1];
else
le[i] = i;
} else {
if (st) {
jlh[id] = cnt;
x[id] = x[id - 1] * key + cnt;
st = cnt = 0;
}
if (cnt == 0) ++id;
++cnt, r[i] = cnt;
cl[i] = id;
}
}
if (cnt) x[id] = x[id - 1] * key + cnt, jlh[id] = cnt;
ls = id;
cnt = 0;
for (int i = n; i >= 1; --i) {
if (z[i]) {
if (ri[i + 1])
ri[i] = ri[i + 1];
else
ri[i] = i;
} else {
if (cl[i] != ls) cnt = 0, ls = cl[i];
l[i] = ++cnt;
}
}
cin >> q;
while (q--) {
cin >> a >> b >> len;
if (push_front[a + len - 1] - push_front[a - 1] !=
push_front[b + len - 1] - push_front[b - 1]) {
cout << "No\n";
continue;
}
if (push_front[a + len - 1] - push_front[a - 1] == 0 ||
push_front[a + len - 1] - push_front[a - 1] == len) {
cout << "Yes\n";
continue;
}
if (comp(a, a + len - 1) == comp(b, b + len - 1))
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double EPS = 1e-6;
const int MOD = (int)1e9 + 7;
long long Bigmod(long long b, long long p, long long m) {
if (p == 0) return 1LL;
if (p % 2 == 0) {
long long c = Bigmod(b, p / 2, m);
return ((c % m) * (c % m)) % m;
} else
return ((b % m) * (Bigmod(b, p - 1, m))) % m;
}
long long ModInverse(long long a, long long M) { return Bigmod(a, M - 2, M); }
template <class T>
inline T GCD(T x, T y) {
if (y == 0) return x;
return GCD(y, x % y);
}
template <class T>
inline T LCM(T x, T y) {
return ((x / GCD(x, y)) * y);
}
bool Reverse(long long a, long long b) { return a > b; }
bool Compare(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int Grid[n + 1][n + 1], Odd = 1, Even = 2, TotalEven = (n * n) / 2;
Grid[(n + 1) / 2][(n + 1) / 2] = Odd, Odd += 2;
for (int i = 1; i <= n; i++) {
if (i == (n + 1) / 2) continue;
Grid[i][(n + 1) / 2] = Odd, Odd += 2;
Grid[(n + 1) / 2][i] = Odd, Odd += 2;
}
for (int i = 1; i <= n / 2; i++) {
for (int j = 1; j <= n / 2; j++) {
if (TotalEven > 0) {
Grid[i][j] = Even, Even += 2;
Grid[i][n + 1 - j] = Even, Even += 2;
Grid[n + 1 - i][j] = Even, Even += 2;
Grid[n + 1 - i][n + 1 - j] = Even, Even += 2;
TotalEven -= 4;
} else {
Grid[i][j] = Odd, Odd += 2;
Grid[i][n + 1 - j] = Odd, Odd += 2;
Grid[n + 1 - i][j] = Odd, Odd += 2;
Grid[n + 1 - i][n + 1 - j] = Odd, Odd += 2;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << Grid[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 123;
vector<pair<int, int> > nen;
pair<int, int> a[N];
struct node {
int mx1, mx2, sz, ed;
} lt[2 * N];
int par[2 * N], n, res[2 * N], cnt, vt, ok[6];
int get(int u) {
if (u == par[u]) return u;
return par[u] = get(par[u]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i].first >> a[i].second;
nen.push_back(pair<int, int>(a[i].first, i));
nen.push_back(pair<int, int>(a[i].second, i));
}
nen.push_back(pair<int, int>(-1, -1));
sort(nen.begin(), nen.end());
cnt = 0;
for (int i = 1; i < nen.size(); ++i) {
if (nen[i].first != nen[i - 1].first) ++cnt, res[cnt] = nen[i].first;
if (a[nen[i].second].first == nen[i].first) a[nen[i].second].first = cnt;
if (a[nen[i].second].second == nen[i].first) a[nen[i].second].second = cnt;
}
for (int i = 1; i <= cnt; ++i) par[i] = i, lt[i].mx1 = i, lt[i].sz = 1;
int u, v;
for (int i = 1; i <= n; ++i) {
u = get(a[i].first);
v = get(a[i].second);
if (u == v) {
lt[u].ed += 1;
if (lt[u].sz < lt[u].ed) {
cout << -1;
return 0;
}
continue;
}
par[v] = u;
lt[u].sz += lt[v].sz;
lt[u].ed += lt[v].ed + 1;
if (lt[u].sz < lt[u].ed) {
cout << -1;
return 0;
}
ok[1] = lt[u].mx1;
ok[2] = lt[u].mx2;
ok[3] = lt[v].mx1;
ok[4] = lt[v].mx2;
sort(ok + 1, ok + 5);
lt[u].mx1 = ok[4];
lt[u].mx2 = ok[3];
}
for (int i = 1; i <= cnt; ++i) {
if (i == get(i)) {
if (lt[i].ed == lt[i].sz - 1)
vt = max(vt, lt[i].mx2);
else
vt = max(vt, lt[i].mx1);
}
}
cout << res[vt];
return 0;
}
| 16 |
#include<bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0); cin.tie(0);
int N, M; cin >> N >> M;
const int MOD = 1e9 + 7;
int tot = 1;
vector<int> ans;
vector<int> par(M); iota(par.begin(), par.end(), 0);
vector<bool> good(M);
auto get_par = [&](int v) {
while (v != par[v]) {
v = par[v] = par[par[v]];
}
return v;
};
auto merge = [&](int v, int u) {
v = get_par(v);
u = get_par(u);
if (v != u) {
par[u] = v;
if (good[u]) good[v] = true;
return true;
} else return false;
};
for (int i = 0; i < N; ++i) {
int sz; cin >> sz;
vector<int> A(sz);
for (int &a : A) cin >> a, --a;
if (sz == 1) {
int a = A[0];
if (!good[get_par(a)]) {
good[get_par(a)] = true;
tot += tot;
if (tot >= MOD) tot -= MOD;
ans.emplace_back(i);
}
} else {
int a = A[0], b = A[1];
if ((!good[get_par(a)] || !good[get_par(b)]) && merge(a, b)) {
tot += tot;
if (tot >= MOD) tot -= MOD;
ans.emplace_back(i);
}
}
}
cout << tot << ' ' << int(ans.size()) << '\n';
for (int i : ans) cout << i + 1 << ' ';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
double p;
double f[2001][2001];
int main() {
cin >> n >> p >> t;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= t; ++j)
f[i][j] = p * (f[i - 1][j - 1] + 1) + (1 - p) * f[i][j - 1];
printf("%.6lf", f[n][t]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void rset();
void init_test();
void solve();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(20);
init_test();
return 0;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
template <typename T>
void MACRO_rdv2_Init(int n, T& t) {
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_rdv2_Init(int n, First& first, Rest&... rest) {
first.resize(n);
MACRO_rdv2_Init(n, rest...);
}
template <typename T>
void MACRO_rdv2_Scan(int p, T& t) {
std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_rdv2_Scan(int p, First& first, Rest&... rest) {
std::cin >> first[p];
MACRO_rdv2_Scan(p, rest...);
}
template <typename T>
void wrv(const vector<T>& v) {
for (int(__ii) = (0); (__ii) < (((int)v.size())); ++(__ii)) {
if (__ii) cout << ' ';
cout << v[__ii];
}
cout << '\n';
}
template <typename T>
void wrm(const vector<vector<T>>& v) {
for (int(__ii) = (0); (__ii) < (((int)v.size())); ++(__ii)) {
for (int(__jj) = (0); (__jj) < (v[__ii].size()); ++(__jj)) {
if (__jj) cout << ' ';
cout << v[__ii][__jj];
}
cout << '\n';
}
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void wr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void wr(const Head& head, const Tail&... tail) {
cout << head << ' ';
wr(tail...);
}
template <typename T>
void wrf(const T& x) {
cout << x << endl;
}
template <typename Head, typename... Tail>
void wrf(const Head& head, const Tail&... tail) {
cout << head << ' ';
wrf(tail...);
}
template <typename T>
void debug_out(const T& x) {
cerr << x << '\n';
}
template <typename Head, typename... Tail>
void debug_out(const Head& head, const Tail&... tail) {
cerr << head << ' ';
debug_out(tail...);
}
template <typename... T>
void err(const T&... cod) {
wr(cod...);
exit(0);
}
bool can(int n, int len, vector<pair<int, int>>& v) {
int cur = 0;
for (int(i) = (0); (i) < (((int)v.size())); ++(i))
if (v[i].first > len) return false;
for (int(i) = (0); (i) < (((int)v.size())); ++(i)) {
if (v[i].second == 0) {
--n;
cur = v[i].first;
} else {
if (cur + v[i].first <= len)
cur += v[i].first;
else
--n, cur = v[i].first;
}
}
return n > 0;
}
void solve() {
int n;
sc(n);
cin.ignore();
string a;
getline(cin, a);
vector<pair<int, int>> v;
int s = 0;
char lst = ' ';
for (int(i) = (0); (i) < (((int)a.size())); ++(i)) {
if (a[i] == '-' || a[i] == ' ' || i == ((int)a.size()) - 1) {
if (lst == ' ')
v.emplace_back(s + 1, 1);
else
v.emplace_back(s + 1, 1);
s = 0;
lst = a[i];
} else {
++s;
}
}
int low = 0, high = ((int)a.size()) + 1;
while (low + 1 < high) {
int mid = (low + high) / 2;
if (can(n, mid, v))
high = mid;
else
low = mid;
}
wr(high);
}
void init_test() {
int qq = 1;
while (qq--) solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, N = 100005;
inline void read(int &x) {
char ch;
int t = 0;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') t = 1;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - 48, ch = getchar())
;
if (t) x = -x;
}
int a[N], b[N];
vector<int> v[N];
int main() {
int n, m, i, j, k, t, l, r, x, y, s;
long long ans;
while (~scanf("%d", &n)) {
memset(v, 0, sizeof v);
for (i = 0; i < n; i++) read(a[i]);
for (i = 0; i < n; i++) v[a[i]].push_back(i);
for (s = m = 0, i = 1; i <= n; i++) {
if ((v[i].size())) b[m++] = i;
if ((v[i].size()) & 1) {
if (s) break;
s = i;
}
}
if (i <= n) {
printf("0\n");
continue;
}
for (k = 0; k < n / 2; k++)
if (a[k] != a[n - k - 1]) break;
if (k == n / 2) {
printf("%lld\n", (long long)n * (n + 1) >> 1);
continue;
}
for (y = n + 1, i = x = 0; i < m; i++) {
t = b[i];
if (!((v[t].size()) & 1))
l = (v[t].size()) / 2 - 1, r = l + 1;
else
l = r = (v[t].size()) / 2;
while (l >= 0 && v[t][l] + v[t][r] == n - 1) l--, r++;
if (l < 0) continue;
x = max(x, v[t][l]);
y = min(y, v[t][r]);
}
l = n - k - 1 - x;
r = y - k;
ans = (long long)l * (k + 1) + (long long)r * (k + 1) +
(long long)(k + 1) * (k + 1);
printf("%lld\n", ans);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
cout << 1 << " " << n - 1 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long min(long long a, long long b) {
if (a >= b)
return b;
else
return a;
}
int main() {
string s;
cin >> s;
long long len = s.length();
char ch = 'a';
long long count = 0, rotation = 0;
for (int i = 0; i < len; i++) {
count = s[i] - ch;
if (count < 0) count = count * (-1);
ch = s[i];
count = min(count, 26 - count);
rotation = rotation + count;
}
cout << rotation;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int e = 100 + 2;
const int e1 = 1e6;
const long long mod = 1e9 + 7;
int dist[e][e];
int v[e1];
int mark[e1], trace[e1], dp[e1];
void track(int x) {
if (!x) return;
track(trace[x]);
cout << v[x] << " ";
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
s = ' ' + s;
for (int j = 1; j <= n; j++) {
if (s[j] == '1') {
dist[i][j] = 1;
} else {
dist[i][j] = 1000;
}
}
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> v[i];
dp[i] = 1e6 + 7;
}
dp[1] = 1;
for (int k = 1; k <= n; k++) {
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= n; i++) {
if (dist[i][k] != 1000 && dist[k][j] != 1000) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (v[i] == j) continue;
if (mark[j] == 0) continue;
if (dist[j][v[i]] == 1000 || dist[j][v[i]] < i - mark[j]) continue;
if (dp[i] > dp[mark[j]] + 1) {
dp[i] = dp[mark[j]] + 1;
trace[i] = mark[j];
}
}
mark[v[i]] = i;
}
cout << dp[m] << "\n";
track(m);
}
| 9 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
template <class T>
class SegmentTree {
private:
int _size = 1;
T _def;
std::vector<T> _nodes;
std::function<T(T, T)> _op;
std::function<T(T, T)> _update_op;
public:
SegmentTree(int size, T default_value, std::function<T(T, T)> op,
std::function<T(T, T)> update_op)
: _def(default_value), _op(op), _update_op(update_op) {
while (_size < size) _size *= 2;
_nodes = std::vector<T>(2 * _size, default_value);
}
SegmentTree(std::vector<T> nodes, T default_value, std::function<T(T, T)> op,
std::function<T(T, T)> update_op)
: _def(default_value), _op(op), _update_op(update_op) {
int real_size = nodes.size();
while (_size < real_size) _size *= 2;
_nodes = std::vector<T>(2 * _size, default_value);
for (int i = 0; i < real_size; ++i) _nodes[i + _size] = nodes[i];
for (int i = _size - 1; i >= 0; --i)
_nodes[i] = _op(_nodes[i * 2], _nodes[i * 2 + 1]);
}
T find(int l, int r) { return find(l, r, 1, 0, _size); }
T find(int l, int r, int index, int cover_l, int cover_r) {
if (cover_r <= l || r <= cover_l) return _def;
if (l <= cover_l && cover_r <= r) return _nodes[index];
return _op(find(l, r, index * 2, cover_l, (cover_l + cover_r) >> 1),
find(l, r, index * 2 + 1, (cover_l + cover_r) >> 1, cover_r));
}
void update(int index, T value) {
index += _size;
_nodes[index] = _update_op(_nodes[index], value);
while (index > 0) {
index >>= 1;
_nodes[index] = _op(_nodes[index * 2], _nodes[index * 2 + 1]);
}
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll max_t = 10010;
auto cnt_segt = SegmentTree<ll>(
max_t, 0, [](ll x, ll y) { return x + y; },
[](ll x, ll y) { return x + y; });
auto sum_segt = SegmentTree<ll>(
max_t, 0, [](ll x, ll y) { return x + y; },
[](ll x, ll y) { return x + y; });
ll n, m, k;
cin >> n >> m >> k;
vector<pair<ll, ll>> a, b, both, gomi;
ll t, al, bl;
for (ll i = 1, iLen = (n + 1); i < iLen; ++i) {
cin >> t >> al >> bl;
if (al && bl)
both.emplace_back(t, i);
else if (al)
a.emplace_back(t, i);
else if (bl)
b.emplace_back(t, i);
else
gomi.emplace_back(t, i);
}
if (min(a.size(), b.size()) + both.size() < k) {
cout << -1 << endl;
return 0;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(both.begin(), both.end());
vector<ll> a_acc(a.size() + 1), b_acc(b.size() + 1),
both_acc(both.size() + 1);
for (ll i = 1, iLen = (a_acc.size()); i < iLen; ++i)
a_acc[i] += a[i - 1].first + a_acc[i - 1];
for (ll i = 1, iLen = (b_acc.size()); i < iLen; ++i)
b_acc[i] += b[i - 1].first + b_acc[i - 1];
for (ll i = 1, iLen = (both_acc.size()); i < iLen; ++i)
both_acc[i] += both[i - 1].first + both_acc[i - 1];
for (ll i = k + 1, iLen = (a.size()); i < iLen; ++i)
cnt_segt.update(a[i].first, 1);
for (ll i = k + 1, iLen = (b.size()); i < iLen; ++i)
cnt_segt.update(b[i].first, 1);
for (ll i = 0, iLen = (both.size()); i < iLen; ++i)
cnt_segt.update(both[i].first, 1);
for (ll i = 0, iLen = (gomi.size()); i < iLen; ++i)
cnt_segt.update(gomi[i].first, 1);
for (ll i = 1, iLen = (max_t); i < iLen; ++i)
sum_segt.update(i, cnt_segt.find(i, i + 1) * i);
ll inf = 1LL << 60, ans = 1LL << 60, ans_i = 0;
for (ll i = 0, iLen = (k + 1); i < iLen; ++i) {
if (k - i < a.size()) {
cnt_segt.update(a[k - i].first, 1);
sum_segt.update(a[k - i].first, a[k - i].first);
}
if (k - i < b.size()) {
cnt_segt.update(b[k - i].first, 1);
sum_segt.update(b[k - i].first, b[k - i].first);
}
if (0 < i && i < both.size()) {
cnt_segt.update(both[i - 1].first, -1);
sum_segt.update(both[i - 1].first, -both[i - 1].first);
}
if (a.size() < k - i || b.size() < k - i || both.size() < i) continue;
ll total = 2 * (k - i) + i;
ll lack = m - total;
if (lack < 0 || lack > cnt_segt.find(0, max_t)) continue;
ll val = both_acc[i] + a_acc[k - i] + b_acc[k - i];
ll num = 0, ng = -1, ok = max_t + 1;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (lack <= cnt_segt.find(0, mid))
ok = mid;
else
ng = mid;
}
val += sum_segt.find(0, ok) - (cnt_segt.find(0, ok) - lack) * (ok - 1);
if (ans > val) {
ans = val;
ans_i = i;
}
}
if (ans == inf) {
cout << -1 << endl;
return 0;
}
vector<ll> ans_v;
for (ll i = 0, iLen = (a.size()); i < iLen; ++i) {
if (i < k - ans_i)
ans_v.emplace_back(a[i].second);
else
gomi.push_back(a[i]);
}
for (ll i = 0, iLen = (b.size()); i < iLen; ++i) {
if (i < k - ans_i)
ans_v.emplace_back(b[i].second);
else
gomi.push_back(b[i]);
}
for (ll i = 0, iLen = (both.size()); i < iLen; ++i) {
if (i < ans_i)
ans_v.emplace_back(both[i].second);
else
gomi.push_back(both[i]);
}
sort(gomi.begin(), gomi.end());
for (ll i = 0, iLen = (m - (2 * (k - ans_i) + ans_i)); i < iLen; ++i)
ans_v.emplace_back(gomi[i].second);
cout << ans << endl;
for (auto &i : ans_v) cout << i << " ";
cout << endl;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
void read(T &x) {
char ch;
x = 0;
int f = 1;
while (isspace(ch = getchar_unlocked()))
;
if (ch == '-') ch = getchar_unlocked(), f = -1;
do x = x * 10 + (ch - '0');
while (isdigit(ch = getchar_unlocked()));
x *= f;
}
template <class T, class... A>
void read(T &x, A &...args) {
read(x);
read(args...);
}
const int N = 2005;
const int M = 1000000007;
char s[N], t[N];
int way[N][N * 2], sum[N][N * 2];
void inc(int &x, int y) {
if ((x += y) >= M) x -= M;
}
int main() {
int T;
read(T);
while (T--) {
int n;
read(n);
memset(way, 0, (n + 1) * sizeof(way[0]));
memset(sum, 0, (n + 1) * sizeof(sum[0]));
scanf("%s%s", s, t);
for (int i = 1; i < n; i += 2) {
if (s[i] != '?') s[i] ^= 1;
if (t[i] != '?') t[i] ^= 1;
}
way[0][N] = 1;
for (int i = 0; i < n; ++i) {
vector<int> cs, ct;
if (s[i] == '0')
cs = {0};
else if (s[i] == '1')
cs = {1};
else
cs = {0, 1};
if (t[i] == '0')
ct = {0};
else if (t[i] == '1')
ct = {-1};
else
ct = {0, -1};
for (int x : cs)
for (int y : ct)
for (int j = N - i; j <= N + i; ++j) {
inc(way[i + 1][j + x + y], way[i][j]);
sum[i + 1][j + x + y] = (sum[i + 1][j + x + y] + sum[i][j] +
(ll)abs(j - N + x + y) * way[i][j]) %
M;
}
}
printf("%d\n", sum[n][N]);
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v[100002];
const int h_num = 2;
long long int B[] = {1011235817, 1011235817, 1011235817, 987654347, 1011235817,
1021328611, 987654347, 1011235817, 1000000007};
struct HASH {
vector<long long int> val;
bool emp;
HASH(int v_ = 0) {
val.assign(h_num, 0);
emp = false;
for (int i = 0; i < h_num; i++) {
val[i] = v_;
}
}
vector<long long int> get() { return val; }
};
HASH R[100002];
HASH operator*(const HASH &a, const HASH &b) {
if (a.emp) {
return b;
}
if (b.emp) {
return a;
}
HASH r;
for (int i = 0; i < h_num; i++) {
r.val[i] = a.val[i] * b.val[i];
if (r.val[i] >= B[i]) r.val[i] %= B[i];
}
return r;
}
HASH operator+(const HASH &a, HASH &b) {
if (a.emp) {
return a;
}
if (b.emp) {
return b;
}
HASH r;
for (int i = 0; i < h_num; i++) {
r.val[i] = a.val[i] + b.val[i];
if (r.val[i] >= B[i]) {
r.val[i] %= B[i];
}
}
return r;
}
HASH h[100002];
map<vector<long long int>, int> tmp;
int dep[100002];
inline void dfs(int b, int pr = -1) {
vector<HASH> vv;
for (int i = 0; i < v[b].size(); i++) {
if (pr != v[b][i]) {
dfs(v[b][i], b);
dep[b] = max(dep[b], dep[v[b][i]] + 1);
}
}
for (int i = 0; i < v[b].size(); i++) {
if (pr != v[b][i]) {
vv.push_back(h[v[b][i]] + R[dep[b]]);
}
}
if (vv.size() == 0) {
h[b] = HASH(1);
return;
}
HASH sum = vv[0];
for (int i = 1; i < vv.size(); i++) {
sum = sum * vv[i];
}
h[b] = sum;
return;
}
int maxt;
int idd;
inline void dfs2(int b, int pr, map<vector<long long int>, int> &mp, HASH par2,
int par_dep) {
par_dep++;
mp[h[b].get()]--;
if (mp[h[b].get()] == 0) {
mp.erase(h[b].get());
}
vector<HASH> vv[2];
vector<HASH> im1[2];
vector<HASH> im2[2];
vector<int> H;
H.push_back(par_dep);
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] != pr) {
H.push_back(dep[v[b][i]] + 1);
}
}
sort(H.begin(), H.end(), greater<int>());
if (H.size() == 1) {
H.push_back(H.back());
}
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] != pr) {
for (int j = 0; j < 2; j++) {
vv[j].push_back(h[v[b][i]] + R[H[j]]);
}
}
}
for (int j = 0; j < 2; j++) {
im1[j] = im2[j] = vv[j];
}
for (int j = 0; j < 2; j++) {
for (int i = 1; i < im1[j].size(); i++) {
im1[j][i] = im1[j][i] * im1[j][i - 1];
}
for (int i = (int)(im2[j].size()) - 2; i >= 0; i--) {
im2[j][i] = im2[j][i] * im2[j][i + 1];
}
}
HASH par[2];
par[0] = par2 + R[H[0]];
par[1] = par2 + R[H[1]];
HASH cur[2];
cur[0] = par[0];
cur[1] = par[1];
for (int j = 0; j < 2; j++) {
if (im1[j].size()) {
cur[j] = cur[j] * im1[j].back();
}
}
mp[cur[0].get()]++;
if (maxt < mp.size()) {
maxt = mp.size();
idd = b;
}
if (maxt == mp.size()) {
idd = min(idd, b);
}
mp[cur[0].get()]--;
if (mp[cur[0].get()] == 0) {
mp.erase(cur[0].get());
}
int id = -1;
for (int i = 0; i < v[b].size(); i++) {
if (v[b][i] == pr) continue;
id++;
HASH go;
go.emp = true;
int flag = 0;
if (H[0] == dep[v[b][i]] + 1) {
flag++;
}
if (id) {
go = go * im1[flag][id - 1];
}
if (id + 1 < im2[flag].size()) {
go = go * im2[flag][id + 1];
}
go = go * par[flag];
if (go.emp == true) {
go = HASH(1);
}
mp[go.get()]++;
dfs2(v[b][i], b, mp, go, H[flag]);
mp[go.get()]--;
if (mp[go.get()] == 0LL) {
mp.erase(go.get());
}
}
mp[h[b].get()]++;
}
bool use[5000000];
vector<int> pr;
int main() {
for (int i = 2; i < 5000000; i++) {
if (use[i] == false) {
for (int j = i * 2; j < 5000000; j += i) {
use[j] = true;
}
pr.push_back(i);
}
}
cin >> n;
if (n == 1) {
cout << 1 << endl;
return 0;
}
for (int i = 0; i < 100002; i++) {
for (int j = 0; j < h_num; j++) {
R[i].val[j] = pr[rand() % pr.size()];
}
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
int root = 0;
dfs(root);
for (int i = 0; i < n; i++) {
tmp[h[i].get()]++;
}
HASH f;
f.emp = true;
dfs2(root, -1, tmp, f, -1);
cout << idd + 1 << endl;
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int a, s, d[28], f[28], g[28], h, j, k, l, i, n, m;
string pas;
void dfs(int idx) {
pas += (char)(idx + 96);
h++;
if (!d[idx]) return;
dfs(d[idx]);
}
string x;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
if (x.size() == 1) g[x[0] - 96] = 1;
for (a = 0; a < x.size() - 1; a++) {
if (d[x[a] - 96] && d[x[a] - 96] != x[a + 1] - 96) {
cout << "NO";
return 0;
}
if (f[x[a + 1] - 96] && f[x[a + 1] - 96] != x[a] - 96) {
cout << "NO";
return 0;
}
d[x[a] - 96] = x[a + 1] - 96;
f[x[a + 1] - 96] = x[a] - 96;
}
}
for (i = 1; i <= 26; i++) {
if (!f[i] && (d[i] || g[i])) dfs(i);
if (!d[i] && !f[i] && !g[i]) h++;
}
if (h != 26)
cout << "NO";
else
cout << pas;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 32;
int n, m;
int deg[maxn];
bool g[maxn][maxn];
bool vis[maxn][4];
bool placed[maxn];
pair<long long, long long> p[maxn];
void dfs(int i, long long len) {
placed[i] = true;
for (int j = 1; j <= n; ++j)
if (!placed[j] && g[i][j]) {
if (!vis[i][0]) {
vis[i][0] = vis[j][2] = true;
p[j] = {p[i].first + len, p[i].second};
dfs(j, len >> 1);
} else if (!vis[i][1]) {
vis[i][1] = vis[j][3] = true;
p[j] = {p[i].first, p[i].second + len};
dfs(j, len >> 1);
} else if (!vis[i][2]) {
vis[i][2] = vis[j][0] = true;
p[j] = {p[i].first - len, p[i].second};
dfs(j, len >> 1);
} else if (!vis[i][3]) {
vis[i][3] = vis[j][1] = true;
p[j] = {p[i].first, p[i].second - len};
dfs(j, len >> 1);
} else
puts("WTF???");
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
if (++deg[u] > 4) return puts("NO"), 0;
if (++deg[v] > 4) return puts("NO"), 0;
g[u][v] = g[v][u] = true;
}
p[1] = {0, 0};
dfs(1, 1ll << 58);
puts("YES");
for (int i = 1; i <= n; ++i) printf("%lld %lld\n", p[i].first, p[i].second);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int stuff[64];
int main() {
int N, W, M;
cin >> N >> W >> M;
W *= M;
for (int i = 0; i < N; i++) stuff[i] = W;
int per = (N * W) / M;
bool p = true;
;
int idx = 0;
vector<vector<pair<int, int> > > v(M);
int idxCnt = 0;
for (int i = 0; i < M; i++) {
int rem = per;
while (rem > 0) {
if (stuff[idx] == 0) {
idx += 1;
idxCnt = 0;
}
if (idxCnt == 2) {
p = false;
break;
}
if (stuff[idx] < rem) {
v[i].push_back(make_pair(stuff[idx], idx));
rem -= stuff[idx];
stuff[idx] = 0;
idx += 1;
idxCnt = 0;
} else {
v[i].push_back(make_pair(rem, idx));
stuff[idx] -= rem;
rem -= rem;
idxCnt += 1;
}
}
}
if (p) {
cout << "YES" << endl;
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < v[i].size(); j++)
printf("%d %0.9lf ", v[i][j].second + 1, v[i][j].first / (double)M);
cout << endl;
}
} else {
cout << "NO" << endl;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
int tg[4 * 100007];
pair<int, int> t[4 * 1000007];
pair<int, int> combine(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first) return a;
if (b.first < a.first) return b;
return make_pair(a.first, a.second + b.second);
}
void build(vector<int> &a, int v, int tl, int tr) {
if (tl == tr)
t[v] = make_pair(a[tl], 1);
else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
pair<int, int> get_max(int v, int tl, int tr, int l, int r) {
if (l > r) return make_pair(1e9 + 7, 0);
if (l == tl && r == tr) return t[v];
int tm = (tl + tr) / 2;
return combine(get_max(v * 2, tl, tm, l, min(r, tm)),
get_max(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void buildg(vector<int> &a, int v, int tl, int tr) {
if (tl == tr)
tg[v] = a[tl];
else {
int m = (tl + tr) / 2;
buildg(a, v * 2, tl, m);
buildg(a, v * 2 + 1, m + 1, tr);
tg[v] = gcd(tg[v * 2], tg[v * 2 + 1]);
}
}
int sumg(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return tg[v];
int m = (tl + tr) / 2;
return gcd(sumg(v * 2, tl, m, l, min(r, m)),
sumg(v * 2 + 1, m + 1, tr, max(l, m + 1), r));
}
int main() {
ios_base::sync_with_stdio(0);
while (cin >> n) {
vector<int> am(n, 0);
vector<int> ag(n, 0);
for (auto i = 0; i < (n); i++) {
int temp;
cin >> temp;
am[i] = temp;
ag[i] = temp;
}
buildg(ag, 1, 0, n - 1);
build(am, 1, 0, n - 1);
int q;
cin >> q;
for (auto i = 0; i < (q); i++) {
int l, r;
cin >> l >> r;
l--, r--;
pair<int, int> mm = get_max(1, 0, n - 1, l, r);
int gg = sumg(1, 0, n - 1, l, r);
if (mm.first != gg) {
cout << r - l + 1 << endl;
continue;
}
cout << r - l + 1 - mm.second << endl;
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, i, j, k, a, b, c, s, aa, bb;
cin >> n >> m;
vector<vector<int>> x(n, vector<int>(m));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) cin >> x[i][j];
}
a = 0;
b = 1000000000;
while (a < b) {
c = (a + b + 1) / 2;
vector<int> d(1 << m, -1);
for (i = 0; i < n; i++) {
s = 0;
for (j = 0; j < m; j++) {
if (x[i][j] >= c) s += 1 << j;
}
if (d[s] == -1) d[s] = i;
}
bool solved = false;
for (i = 0; i < (1 << m); i++) {
if (d[i] == -1) continue;
for (j = i; j < (1 << m); j++) {
if (d[j] == -1) continue;
if ((i | j) == ((1 << m) - 1)) {
solved = true;
aa = d[i];
bb = d[j];
goto outer;
}
}
}
outer:;
if (solved)
a = c;
else
b = c - 1;
}
c = a;
vector<int> d(1 << m, -1);
for (i = 0; i < n; i++) {
s = 0;
for (j = 0; j < m; j++) {
if (x[i][j] >= c) s += 1 << j;
}
if (d[s] == -1) d[s] = i;
}
bool solved = false;
for (i = 0; i < (1 << m); i++) {
if (d[i] == -1) continue;
for (j = i; j < (1 << m); j++) {
if (d[j] == -1) continue;
if ((i | j) == ((1 << m) - 1)) {
solved = true;
aa = d[i];
bb = d[j];
}
}
}
cout << aa + 1 << " " << bb + 1 << "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long n) {
if (n < 0) return 0;
return n * (n + 1) / 2;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long A, B, C, D;
cin >> A >> B >> C >> D;
long long ans = 0;
for (long long i = C; i <= D; ++i) {
long long new_C = i - A;
long long val = min(C, new_C) - B + 1;
long long k = max(0ll, new_C - C);
long long z = min(k, B - A + 1);
long long t = val * z;
t += f(val) - f(val - (B - A + 1 - z));
long long x = (B - A + 1) * (C - B + 1);
ans += (B - A + 1) * (C - B + 1) - t;
}
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353, g = 3, N = 5e5 + 10;
int n, x, y, nv[200010], a[19][N], rv[N], len, L, ivg;
inline int ad(int x, int y) {
x += y;
return x >= mod ? x - mod : x;
}
inline int dc(int x, int y) {
x -= y;
return x < 0 ? x + mod : x;
}
inline int fp(int x, int y) {
if (!x) return 0;
int re = 1;
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1) re = (long long)re * x % mod;
return re;
}
inline void ntt(int *e, int pr) {
int i, j, k, ix, iy, ori, pd, G = pr ? g : ivg;
for (i = 1; i < len; ++i)
if (i < rv[i]) swap(e[i], e[rv[i]]);
for (i = 1; i < len; i <<= 1) {
ori = fp(G, (mod - 1) / (i << 1));
for (j = 0; j < len; j += (i << 1)) {
pd = 1;
for (k = 0; k < i; ++k, pd = (long long)pd * ori % mod) {
ix = e[j + k];
iy = (long long)pd * e[i + j + k] % mod;
e[j + k] = ad(ix, iy);
e[i + j + k] = dc(ix, iy);
}
}
}
if (pr) return;
G = fp(len, mod - 2);
for (i = 0; i < len; ++i) e[i] = (long long)e[i] * G % mod;
}
void sol(int l, int r, int d) {
if (l == r) {
a[d][0] = l;
a[d][1] = 1;
return;
}
int i, j, lim, mid = (l + r) >> 1;
sol(l, mid, d + 1);
lim = mid - l + 1;
memcpy(a[d], a[d + 1], sizeof(int) * (lim + 1));
sol(mid + 1, r, d + 1);
for (len = 1, L = 0, lim = r - l + 1; len <= lim; len <<= 1) L++;
for (i = 1; i < len; ++i) rv[i] = ((rv[i >> 1] >> 1) | ((i & 1) << (L - 1)));
for (i = mid - l + 2; i < len; ++i) a[d][i] = 0;
for (i = r - mid + 1; i < len; ++i) a[d + 1][i] = 0;
ntt(a[d], 1);
ntt(a[d + 1], 1);
for (i = 0; i < len; ++i) a[d][i] = (long long)a[d][i] * a[d + 1][i] % mod;
ntt(a[d], 0);
}
int main() {
int i, C = 1, lim;
nv[0] = nv[1] = 1;
scanf("%d%d%d", &n, &x, &y);
ivg = fp(g, mod - 2);
if ((n - 1 < x + y - 2) || (!x) || (!y)) {
puts("0");
return 0;
}
if (n == 1) {
puts("1");
return 0;
}
sol(0, n - 2, 0);
lim = x + y - 2;
x = min(x, y);
for (i = 2; i < x; ++i)
nv[i] = (long long)(mod - mod / i) * nv[mod % i] % mod;
for (i = 1; i < x; ++i)
C = (long long)C * (lim - i + 1) % mod * (long long)nv[i] % mod;
printf("%d", (long long)C * a[0][lim] % mod);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
double f[1005][1005], C[1005], A[1005];
int main() {
scanf("%d%d%d%d", &n, &m, &x, &y);
if (m == 1) {
double ans = 0;
for (int i = n - 1; i >= x; i--) ans += 2;
printf("%.4f", ans);
return 0;
}
for (int i = n - 1; i >= x; i--) {
for (int j = 1; j <= m; j++) C[j] = f[i + 1][j] + 4.0;
C[1] = f[i + 1][1] + 3.0, C[m] = f[i + 1][m] + 3.0;
A[1] = 2.0;
for (int j = 2; j <= m - 1; j++) {
C[j] = C[j] + C[j - 1] / A[j - 1];
A[j] = 3.0 - 1.0 / A[j - 1];
}
f[i][m] = (C[m - 1] / A[m - 1] + C[m]) / (2.0 - 1.0 / A[m - 1]);
for (int j = m - 1; j >= 1; j--) f[i][j] = (C[j] + f[i][j + 1]) / A[j];
}
printf("%.4f", f[x][y]);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, xx[8005], a[8005], flag, vis[8005];
vector<long long> v;
int cmp(long long x, long long y) { return x > y; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
int n1, n2, n3, flag = 0;
cin >> n1 >> n2 >> n3;
if (n1 > 0) {
cout << 0;
for (int i = 0; i < n1; i++) cout << 0;
}
if (n2 > 0) {
if (n1 > 0) {
cout << 1;
n2--;
if (n2 % 2) flag = 1;
for (int i = 0; i < n2 / 2; i++) cout << "01";
} else {
if (n2 % 2 == 0) flag = 1;
for (int i = 0; i < (n2 + 1) / 2; i++) cout << "01";
}
if (n1 > 0) n2++;
}
if (n3 > 0) {
if (n2 > 0)
for (int i = 0; i < n3; i++) cout << 1;
else {
cout << 1;
for (int i = 0; i < n3; i++) cout << 1;
}
}
if (flag) cout << 0;
cout << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200001], v1;
int main() {
int n, m, x, mx1 = -1, mx = -1;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &m);
mx = -1;
for (int j = 0; j < m; j++) {
scanf("%d", &x);
v[i].push_back(x);
if (mx < x) {
mx = x;
}
if (mx1 < x) mx1 = x;
}
v1.push_back(mx);
}
long long int sum = 0, tmp;
for (int i = 0; i < n; i++) {
if (v1[i] == mx1)
continue;
else {
tmp = mx1 - v1[i];
sum += tmp * v[i].size();
}
}
printf("%I64d\n", sum);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, a, b, x, y, i, p[100005], t[100005];
int main() {
cin >> n >> m >> k;
while (i < n) {
cin >> p[i];
t[p[i]] = i;
i++;
}
i = 0;
while (i < m) {
cin >> x;
if (t[x] != 0) {
y += t[x] / k;
t[x]--;
t[p[t[x]]]++;
swap(p[t[x]], p[t[x] + 1]);
}
i++;
}
cout << y + m;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
long long nw = sum / n;
if (sum % n != 0) nw++;
cout << nw << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-10;
template <typename T, typename S>
vector<T>& operator<<(vector<T>& a, S b) {
a.push_back(b);
return a;
}
template <typename T>
void operator>>(vector<T>& a, int b) {
while (b--)
if (!a.empty()) a.pop_back();
}
bool isprime(int n) {
if (n < 2) return false;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
long long b_pow(long long x, long long n) {
return n ? b_pow(x * x, n / 2) * (n % 2 ? x : 1) : 1ll;
}
string itos(int n) {
stringstream ss;
ss << n;
return ss.str();
}
string x[10];
int R[10];
int L[10];
int main() {
string s;
cin >> s;
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> x[i] >> L[i] >> R[i];
}
set<int> v;
int ans = 0;
for (int i = 0; i < s.size(); i++) {
for (int j = i; j < s.size(); j++) {
unsigned long long y = 0;
int len = j - i + 1;
for (int k = 0; k < len; k++) y = y * 8999 + s[i + k];
if (v.count(y)) continue;
unsigned long long big = 1;
for (int k = 0; k < len; k++) big *= 8999;
int bad = 0;
for (int k = 0; k < N; k++) {
if (len > x[k].size()) {
if (0 < L[k] || 0 > R[k]) {
bad = 1;
break;
}
continue;
}
int cnt = 0;
unsigned long long sub = 0;
for (int l = 0; l < len; l++) sub = sub * 8999 + x[k][l];
if (sub == y) cnt++;
for (int l = len; l < x[k].size(); l++) {
sub = sub * 8999 + x[k][l];
sub -= big * x[k][l - len];
if (sub == y) {
cnt++;
}
}
if (cnt < L[k] || cnt > R[k]) {
bad = 1;
break;
}
}
if (!bad) {
ans++;
v.insert(y);
}
}
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char ch, last;
int n, a, b, rez;
int main() {
cin >> n >> a >> b;
last = '*';
for (int i = 1; i <= n; i++) {
cin >> ch;
if (ch == '.') {
if (last == 'a') {
if (b > 0)
b--;
else {
last = '*';
continue;
}
rez++;
last = 'b';
} else if (last == 'b') {
if (a > 0)
a--;
else {
last = '*';
continue;
}
rez++;
last = 'a';
} else if (last == '*') {
if (a > b && a > 0) {
rez++;
a--;
last = 'a';
} else if (b >= a && b > 0) {
rez++;
b--;
last = 'b';
}
}
} else
last = '*';
}
cout << rez;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int nos[2048];
bool used[2048];
int main() {
int N;
cin >> N;
vector<pair<int, int> > v(N);
for (int i = 0; i < N; i++) {
int x;
cin >> x;
nos[i] = abs(x);
v[i] = make_pair(nos[i], i);
}
sort(v.rbegin(), v.rend());
int total = 0;
int idx = 0;
while (idx < N) {
vector<int> indices;
int curr = v[idx].first;
while (idx < N && v[idx].first == curr) {
indices.push_back(v[idx].second);
used[v[idx].second] = true;
idx += 1;
}
vector<int> poscount(indices.size()), negcount(indices.size());
for (int i = 0; i < indices.size(); i++) {
int idx = indices[i];
for (int j = 0; j < N; j++) {
if (used[j]) continue;
if (j < idx) {
if (nos[j] > nos[idx]) poscount[i] += 1;
if (nos[j] > -nos[idx]) negcount[i] += 1;
}
if (j > idx) {
if (nos[j] < nos[idx]) poscount[i] += 1;
if (nos[j] < -nos[idx]) negcount[i] += 1;
}
}
}
for (int i = 0; i < indices.size(); i++)
total += min(poscount[i], negcount[i]);
}
cout << total << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
struct comp {
bool operator()(pair<int, int> a, pair<int, int> b) const {
if (a.first != b.first) return a.first > b.first;
return a.second < b.second;
};
};
int aft[300000], bef[300000];
int n, m;
map<int, int> maps;
set<pair<int, int>, comp> s;
set<int> sets;
void add(int id) {
if (s.empty()) s.insert(pair<int, int>(1, 0));
typeof(s.begin()) now = s.begin();
int ret = maps[id] = now->first + now->second;
sets.insert(ret);
typeof(sets.begin()) pos = sets.upper_bound(ret);
bef[ret] = (now->second < 1 ? -1 : now->second);
aft[ret] = (pos == sets.end() ? -1 : *pos);
if (!(now->second < 1)) aft[now->second] = ret;
if (!(pos == sets.end())) bef[*pos] = ret;
cout << ret << endl;
s.erase(now);
if (bef[ret] == -1 and ret > 1) s.insert(pair<int, int>(ret - 1, 2 - ret));
if (bef[ret] != -1 and (bef[ret] + ret) / 2 > bef[ret])
s.insert(pair<int, int>((bef[ret] + ret) / 2 - bef[ret], bef[ret]));
if (aft[ret] == -1 and n > ret) s.insert(pair<int, int>(n - ret, ret));
if (aft[ret] != -1 and (aft[ret] + ret) / 2 > ret)
s.insert(pair<int, int>((aft[ret] + ret) / 2 - ret, ret));
if (aft[ret] == -1 and bef[ret] != -1)
if (n > bef[ret]) s.erase(pair<int, int>(n - bef[ret], bef[ret]));
if (aft[ret] != -1 and bef[ret] == -1)
if (aft[ret] > 1) s.erase(pair<int, int>(aft[ret] - 1, 2 - aft[ret]));
if (aft[ret] != -1 and bef[ret] != -1)
if (aft[ret] > bef[ret])
s.erase(pair<int, int>(aft[ret] - bef[ret], bef[ret]));
}
void rem(int id) {
int ret = maps[id];
if (bef[ret] == -1 and ret > 1) s.erase(pair<int, int>(ret - 1, 2 - ret));
if (bef[ret] != -1 and (bef[ret] + ret) / 2 > bef[ret])
s.erase(pair<int, int>((bef[ret] + ret) / 2 - bef[ret], bef[ret]));
if (aft[ret] == -1 and n > ret) s.erase(pair<int, int>(n - ret, ret));
if (aft[ret] != -1 and (aft[ret] + ret) / 2 > ret)
s.erase(pair<int, int>((aft[ret] + ret) / 2 - ret, ret));
if (aft[ret] == -1 and bef[ret] != -1)
if (n > bef[ret]) s.insert(pair<int, int>(n - bef[ret], bef[ret]));
if (aft[ret] != -1 and bef[ret] == -1)
if (aft[ret] > 1) s.insert(pair<int, int>(aft[ret] - 1, 2 - aft[ret]));
if (aft[ret] != -1 and bef[ret] != -1)
if ((aft[ret] + bef[ret]) / 2 > bef[ret])
s.insert(pair<int, int>((aft[ret] + bef[ret]) / 2 - bef[ret], bef[ret]));
sets.erase(ret);
if (bef[ret] != -1)
if (aft[ret] != -1)
aft[bef[ret]] = aft[ret];
else
aft[bef[ret]] = -1;
if (aft[ret] != -1)
if (bef[ret] != -1)
bef[aft[ret]] = bef[ret];
else
bef[aft[ret]] = -1;
bef[ret] = -1;
aft[ret] = -1;
}
int main() {
cin >> n >> m;
memset(aft, -1, sizeof(aft));
memset(bef, -1, sizeof(bef));
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
if (a == 1)
add(b);
else
rem(b);
}
}
| 14 |
#include <bits/stdc++.h>
using namespace ::std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string a, b;
vector<int> ans;
cin >> a >> b;
for (int i = n - 1; i > 0; i--)
if (a[i] != b[i]) {
if (a[i] != a[0]) ans.push_back(1), a[0] = !(a[0] - '0') + '0';
ans.push_back(i + 1);
for (int j = 0; j <= i; j++) a[j] = !(a[j] - '0') + '0';
string tmp = a.substr(0, i + 1);
reverse(tmp.begin(), tmp.end());
a = tmp + (i != n - 1 ? a.substr(i + 1) : "");
}
if (a[0] != b[0]) ans.push_back(1);
cout << ans.size() << ' ';
for (auto c : ans) cout << c << ' ';
cout << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, M = 1e9 + 7;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1), EPS = 1e-9;
const int N = 101;
long long b[N];
long long o;
int n, k;
long long fastmod(long long a, long long m = M) {
return (-m < a and a < m) ? a : a % m;
}
long long fastmul(long long a, long long b, long long m = M) {
if (b == 0) return 0;
if (a * b / b == a) return fastmod(a * b, m);
long long r = 0;
while (b) {
if (b & 1) r = fastmod(r + a, m);
a = fastmod(a + a, m);
b /= 2;
}
return r;
}
template <int m = M>
struct modArit {
int v;
modArit(int v = 0) : v(fastmod(v, m)) {}
modArit<m> operator+(modArit<m> r) const { return modArit<m>(v + r.v); }
modArit<m> operator-(modArit<m> r) const { return modArit<m>(v - r.v); }
modArit<m> operator*(modArit<m> r) const {
return modArit<m>(fastmul(v, r.v, m));
}
modArit<m> operator/(modArit<m> r) const { return *this * inv(r); }
modArit<m> operator/(int r) const { return modArit<m>(v / r); }
};
template <int n, int m, class T = modArit<>>
struct Matrix {
T a[N][N] = {};
Matrix(int d = 0) {
for (int i = 0; i < n; i++) a[i][i] = d;
}
template <int mm>
Matrix<n, mm, T> operator*(const Matrix<m, mm, T> r) {
Matrix<n, mm, T> ans;
for (int i = 0; i < n; i++)
for (int j = 0; j < mm; j++)
for (int k = 0; k < m; k++)
ans.a[i][j] = ans.a[i][j] + a[i][k] * r.a[k][j];
return ans;
}
};
template <class T>
T fexp(T b, long long e) {
T r = 1;
while (e) {
if (e & 1) r = r * b;
b = b * b, e /= 2;
}
return r;
}
template <int m>
modArit<m> inv(modArit<m> x) {
return fexp(x, m - 2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
auto f = inv<M>((n * (n - 1) / 2));
for (int i = 0; i < n; i++) {
cin >> b[i];
if (b[i]) o++;
}
Matrix<N, N> m;
auto t = min(n - o, o);
modArit<> nn = n, oo = o;
for (int i = 0; i <= t; i++) {
modArit<> ii = i;
m.a[i][i] = (nn * (nn - 1) / 2 - ii * ii - (oo - ii) * (nn - oo - ii)) * f;
if (i > 0) m.a[i][i - 1] = ii * ii * f;
m.a[i][i + 1] = (oo - ii) * (nn - oo - ii) * f;
}
Matrix<N, N> a = fexp(m, k);
int id = 0;
for (int i = 0; i < n - o; i++)
if (b[i]) id++;
cout << fexp(m, k).a[id][0].v << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int p[N], h[N], vis[N];
vector<int> ar[N];
int dfs(int node, int par) {
vis[node] = 1;
for (int child : ar[node]) {
if (vis[child] == 0) {
p[node] += dfs(child, node);
}
}
return p[node];
}
int main() {
int n, k, t, m, z;
cin >> t;
while (t--) {
string s;
cin >> s;
int n = s.length();
int ans = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
int cur = 0, v = 0;
for (int k = 0; k < n; k++) {
int c = s[k] - '0';
if (!cur && c == i) {
v++;
cur ^= 1;
continue;
}
if (cur && c == j) {
v++;
cur ^= 1;
}
}
if (!cur || i == j)
ans = max(ans, v);
else
ans = max(ans, v - 1);
}
}
cout << n - ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 111;
int cnt[MAX_N][MAX_N];
vector<int> l;
vector<pair<int, int> > gr[MAX_N];
int used[MAX_N];
inline void add(int v, int u, int c) { gr[v].push_back({u, c}); }
void dfs(int v, int c) {
for (int i = 0; i < (int)l.size(); ++i) ++cnt[l[i]][v], ++cnt[v][l[i]];
l.push_back(v);
used[v] = c;
for (int i = 0; i < (int)gr[v].size(); ++i) {
if (gr[v][i].second != c) continue;
int to = gr[v][i].first;
if (used[to] == c) continue;
dfs(to, c);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int v, u, c;
cin >> v >> u >> c;
add(v, u, c);
add(u, v, c);
}
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
if (used[j] < i) {
l.clear();
dfs(j, i);
}
}
}
int q;
cin >> q;
while (q-- > 0) {
int v, u;
cin >> v >> u;
cout << cnt[v][u] << '\n';
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
const long long mod = 1e9 + 7;
const long double eps = 1e-10;
const int inf = 1e6;
int n, d;
long long k;
long long a[maxn];
long long ac[maxn];
long long bc[maxn];
long long b[maxn];
bool check(long long t) {
memset(b, 0, sizeof(b));
long long used = 0;
long long cur = 0;
for (int i = 0; i < n; ++i) {
cur += ac[i];
long long need = max(0ll, t - cur);
int addPos = i + d * 2;
cur += need;
used += need;
if (used > k) return false;
if (addPos < n) b[addPos] += need;
cur -= b[i];
cur -= bc[i];
}
return used <= k;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> d >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
int lp = max(0, i - d);
int rp = min(n - 1, i + d);
ac[lp] += a[i];
bc[rp] += a[i];
}
long long l = *min_element(a, a + n);
long long r = k + accumulate(a, a + n, 0ll);
while (l + 1 < r) {
long long m = l + (r - l) / 2;
if (check(m))
l = m;
else
r = m - 1;
}
if (check(r))
cout << r << "\n";
else
cout << l << "\n";
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, count = 0;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '1') count++;
if (s[i] == '0') {
cout << count;
count = 0;
}
}
cout << count;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, p;
cin >> n >> k;
char str[n];
scanf("%s", str);
for (long long int i = 0; i < n; i++) {
if (k == 0) break;
if (i != n - 1)
if (str[i] == '4' && str[i + 1] == '7') {
if (i > 0 && i % 2 == 1 && str[i - 1] == '4') {
if (k % 2 == 1) {
str[i] = '7';
}
break;
}
if (i % 2 == 0)
str[i + 1] = '4';
else {
str[i] = '7';
i = -2;
}
k--;
}
}
cout << str;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000001];
int main() {
long long n;
cin >> n;
cout << n * (n + 1) << endl;
for (int i = n; i >= 0; i--) {
int x = 0;
if (a[i]) continue;
for (int j = 0; j <= 32; j++) {
if ((1ll << (j)) > i) {
x = j;
break;
}
}
int y = i ^ ((1ll << (x)) - 1);
a[i] = y;
a[y] = i;
}
for (int i = 0; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string word;
stack<char> f;
void print() {
if (f.empty()) return;
char ch = f.top();
f.pop();
print();
cout << ch;
}
int main() {
cin >> word;
for (int i = 0; i < word.length(); i++) {
if (f.empty()) {
f.push(word[i]);
} else {
if (word[i] == f.top())
f.pop();
else
f.push(word[i]);
}
}
print();
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct P {
long long x, y;
P operator-(const P &a) const { return (P){x - a.x, y - a.y}; }
long long operator*(const P &a) const {
return 1ll * x * a.y - 1ll * y * a.x;
}
bool operator<(const P &a) const { return x == a.x ? y < a.y : x < a.x; }
} a[N];
int n;
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n); i++) {
scanf("%lld%lld", &a[i].x, &a[i].y);
a[i].y -= 1ll * a[i].x * a[i].x;
}
sort(a + 1, a + n + 1);
int top = 1;
for (int i = (int)(2); i <= (int)(n); i++) {
for (; top > 1 && (a[top] - a[top - 1]) * (a[i] - a[top - 1]) >= 0; --top)
;
a[++top] = a[i];
}
int ans = 0;
for (int i = (int)(2); i <= (int)(top); i++) ans += (a[i].x != a[i - 1].x);
printf("%d\n", ans);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 99999999;
const int N = 100010;
const int M = 5005;
int f[M], a[N], b[N];
vector<int> v[N];
int main() {
int n, m, s, e;
cin >> n >> m >> s >> e;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
cin >> b[i];
v[b[i]].push_back(i);
}
for (int i = 0; i < N; i++) v[i].push_back(INF);
f[0] = 0;
for (int i = 1; i < M; i++) f[i] = INF - 1;
int ans = 0, limit = s / e;
for (int i = 1; i <= n; i++) {
for (int j = limit; j > 0; j--) {
f[j] = min(f[j], *upper_bound(v[a[i]].begin(), v[a[i]].end(), f[j - 1]));
if (i + f[j] + e * j <= s) ans = max(ans, j);
}
}
cout << ans << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
long long X, Y;
long long dx, dy;
string cmd;
int mx[] = {0, 0, -1, 1};
int my[] = {1, -1, 0, 0};
pair<long long, long long> rax, ray;
int main() {
cin >> X >> Y;
cin >> cmd;
if (X == 0 && Y == 0) {
cout << "Yes" << endl;
return 0;
}
for (int i = (0); i < (int((cmd).size())); i++) {
switch (cmd[i]) {
case 'U':
cmd[i] = 0;
break;
case 'D':
cmd[i] = 1;
break;
case 'L':
cmd[i] = 2;
break;
case 'R':
cmd[i] = 3;
break;
}
}
dx = dy = 0;
rax = ray = pair<long long, long long>(0, 0);
for (int i = (0); i < (int((cmd).size())); i++) {
dx += mx[cmd[i]];
dy += my[cmd[i]];
rax = pair<long long, long long>(min(rax.first, dx), max(rax.second, dx));
ray = pair<long long, long long>(min(ray.first, dy), max(ray.second, dy));
if (X == dx && Y == dy) {
cout << "Yes" << endl;
return 0;
}
}
if (dx == 0 && dy == 0) {
cout << "No" << endl;
return 0;
}
int m = max(min(abs(X - rax.first), abs(X - rax.second)) / max(1LL, abs(dx)),
min(abs(Y - ray.first), abs(Y - ray.second)) / max(1LL, abs(dy)));
m = max(0, m - 101);
int x = m * dx;
int y = m * dy;
for (int j = (0); j < (202); j++) {
for (int i = (0); i < (int((cmd).size())); i++) {
x += mx[cmd[i]];
y += my[cmd[i]];
if (X == x && Y == y) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int cnt[26] = {0};
int i, tmp;
map<int, int> m;
char in[7];
m[6] = 1;
m[15] = 1;
m[24] = m[33] = 2;
m[114] = 2;
m[123] = 3;
m[222] = 6;
m[1113] = 5;
m[1122] = 8;
m[11112] = 15;
m[111111] = 30;
cin >> in;
for (i = 0; in[i] != 0; i++) cnt[in[i] - 'A']++;
sort(cnt, cnt + 26);
for (i = 0; !cnt[i]; i++)
;
for (tmp = 0; i < 26; i++) tmp = (tmp * 10 + cnt[i]);
cout << m[tmp] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int i;
double ans = 0;
string t = "";
for (i = 0; i < s.length(); i++) {
if (s[i] == '.') {
if (s[i + 3] >= '0' && s[i + 3] <= '9' && (i + 3 < s.length())) continue;
t += s[i];
} else
t += s[i];
}
double temp = 0;
for (i = 0; i < t.length(); i++) {
if (t[i] >= 'a' && t[i] <= 'z') {
ans += temp;
temp = 0;
} else if (t[i] == '.') {
double num = (t[i + 1] - '0') * 10 + (t[i + 2] - '0');
temp += (num / 100);
i += 2;
} else {
temp = temp * 10 + (t[i] - '0');
}
}
ans += temp;
ans *= 100;
t = "";
long long val = ans;
if (val % 100) {
t = char(val % 10 + '0');
val /= 10;
t = char(val % 10 + '0') + t;
val /= 10;
} else
val /= 100;
if (val == 0) t = '.' + t;
while (val) {
if (t != "") t = '.' + t;
long long num = val % 1000;
t = char(num % 10 + '0') + t;
num /= 10;
t = char(num % 10 + '0') + t;
num /= 10;
t = char(num % 10 + '0') + t;
num /= 10;
val /= 1000;
}
s = "";
i = 0;
while (t[i] == '0') i++;
if (t[i] == '.') s = '0';
for (i = i; i < t.length(); i++) s = s + t[i];
cout << s << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, b;
cin >> n;
m = (n / 7) * 2;
b = n % 7;
switch (b) {
case 0:
cout << m << " " << m;
return 0;
case 1:
cout << m << " " << m + 1;
return 0;
case 2:
cout << m << " " << m + 2;
return 0;
case 3:
cout << m << " " << m + 2;
return 0;
case 4:
cout << m << " " << m + 2;
return 0;
case 5:
cout << m << " " << m + 2;
return 0;
case 6:
cout << m + 1 << " " << m + 2;
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const long double PI = acos(0.0) * 2.0;
mt19937_64 rng((unsigned long long)new char);
const int mod = 1e9 + 7;
const long long INF = 9e18;
const int maxn = 510;
char s[maxn][maxn];
long long dp[2][maxn][maxn];
inline void add(long long& x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
int n, m;
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = (1); i < (n + 1); ++i)
for (int j = (1); j < (m + 1); ++j) cin >> s[i][j];
if (s[1][1] != s[n][m]) return cout << 0, 0;
int now = 0;
dp[now][1][n] = 1;
int ls = (n + m) / 2;
for (int step = 2; step <= ls; ++step) {
now ^= 1;
memset(dp[now], 0, sizeof(dp[now]));
for (int x = max(1, step + 1 - m); x <= min(step, n); ++x)
for (int y = max(1, n + 1 - step); y <= min(n + m - step, n); ++y) {
if (s[x][step + 1 - x] != s[y][n + m - step + 1 - y]) continue;
long long& a = dp[now][x][y];
add(a, dp[now ^ 1][x][y]);
add(a, dp[now ^ 1][x - 1][y]);
add(a, dp[now ^ 1][x - 1][y + 1]);
add(a, dp[now ^ 1][x][y + 1]);
}
}
long long ans = 0;
int step = ls;
for (int x = max(1, step + 1 - m); x <= min(step, n); ++x)
for (int y = max(1, n + 1 - step); y <= min(n + m - step, n); ++y) {
if ((n + m) & 1) {
if (x == y || y == x + 1) add(ans, dp[now][x][y]);
} else {
if (x == y) add(ans, dp[now][x][y]);
}
}
cout << ans;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long dyn[5007][5007];
long long A[300007];
int main() {
int N, K;
scanf("%d %d ", &N, &K);
;
for (int i = (0); i < (N); i++) cin >> A[i];
sort(A, A + N);
int len = (N - 1) / K + 1;
int shortsCnt = (K - N % K) % K;
for (int groups = (1); groups < (K); groups++) {
for (int shorts = (0); shorts < (min(groups, shortsCnt) + 1); shorts++) {
dyn[groups][shorts] = dyn[groups - 1][shorts];
if (shorts > 0)
dyn[groups][shorts] =
max(dyn[groups][shorts], dyn[groups - 1][shorts - 1]);
dyn[groups][shorts] +=
A[groups * len - shorts] - A[groups * len - shorts - 1];
}
}
long long saved = dyn[K - 1][shortsCnt];
if (shortsCnt > 0) saved = max(saved, dyn[K - 1][shortsCnt - 1]);
cout << A[N - 1] - A[0] - saved << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[500001];
int dist[500001];
bool visited[500001];
int bfs(int i) {
queue<int> q;
q.push(i);
visited[i] = true;
vector<pair<int, int>> time;
while (!q.empty()) {
int temp = q.front();
q.pop();
for (int j = 0; j < adj[temp].size(); j++) {
if (!visited[adj[temp][j]]) {
visited[adj[temp][j]] = true;
q.push(adj[temp][j]);
dist[adj[temp][j]] = dist[temp] + 1;
}
}
if (adj[temp].size() == 1 && temp != 1) {
time.push_back({dist[temp], temp});
}
}
sort(time.begin(), time.end());
int maxi = time[0].first;
time[0].second = maxi;
for (int i = 1; i < time.size(); i++) {
time[i].second = max(dist[time[i].second], time[i - 1].second + 1);
maxi = max(maxi, time[i].second);
}
return maxi;
}
int main(int argc, char const *argv[]) {
int n;
cin >> n;
int x, y;
for (int i = 1; i <= n - 1; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
visited[1] = true;
int maxi = 0;
for (int i = 0; i < adj[1].size(); i++) {
int temp = bfs(adj[1][i]);
maxi = max(maxi, temp + 1);
}
cout << maxi;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 300005;
const int INF = (int)1e9;
struct Node {
int p;
int link = -1;
int go[26], nxt[26];
bool leaf;
char pch;
Node(int p = -1, char pch = '$') : p(p), pch(pch) {
fill(go, go + 26, -1);
fill(nxt, nxt + 26, -1);
}
};
vector<Node> aho(1);
int N, M, S, A[maxN], in2aho[maxN], aho2in[maxN], seg[maxN * 4];
int sz[maxN], heavy[maxN], par[maxN], aho2seg[maxN], seg2aho[maxN], top[maxN];
multiset<int> sus[maxN];
vector<int> graph[maxN];
int add_string(string& s) {
int v = 0;
for (char ch : s) {
int c = ch - 'a';
if (aho[v].nxt[c] == -1) {
aho[v].nxt[c] = aho.size();
aho.emplace_back(v, ch);
}
v = aho[v].nxt[c];
}
aho[v].leaf = true;
sus[v].insert(0);
return v;
}
int get_go(int, char);
int get_link(int v) {
if (aho[v].link == -1) {
if (v == 0 || aho[v].p == 0)
aho[v].link = 0;
else
aho[v].link = get_go(get_link(aho[v].p), aho[v].pch);
if (v != 0) graph[aho[v].link].push_back(v);
}
return aho[v].link;
}
int get_go(int v, char ch) {
int c = ch - 'a';
if (aho[v].go[c] == -1) {
if (aho[v].nxt[c] != -1)
aho[v].go[c] = aho[v].nxt[c];
else
aho[v].go[c] = v == 0 ? 0 : get_go(get_link(v), ch);
}
return aho[v].go[c];
}
int get_max(multiset<int>& ms) {
if (ms.empty()) return -1;
return *ms.rbegin();
}
void build(int n, int l, int r) {
if (l == r) {
seg[n] = get_max(sus[seg2aho[l]]);
return;
}
int m = (l + r) / 2;
build(n * 2, l, m);
build(n * 2 + 1, m + 1, r);
seg[n] = max(seg[n * 2], seg[n * 2 + 1]);
}
void update(int n, int l, int r, int i) {
if (l > i || r < i) return;
if (l == r && l == i) {
seg[n] = get_max(sus[seg2aho[l]]);
return;
}
int m = (l + r) / 2;
update(n * 2, l, m, i);
update(n * 2 + 1, m + 1, r, i);
seg[n] = max(seg[n * 2], seg[n * 2 + 1]);
}
int query(int n, int l, int r, int ql, int qr) {
if (l > qr || r < ql) return -1;
if (ql <= l && r <= qr) return seg[n];
int m = (l + r) / 2;
int lval = query(n * 2, l, m, ql, qr);
int rval = query(n * 2 + 1, m + 1, r, ql, qr);
return max(lval, rval);
}
void dfs1(int n) {
if (n == 0) par[n] = -1;
sz[n] = 1;
heavy[n] = -1;
for (int v : graph[n]) {
par[v] = n;
dfs1(v);
sz[n] += sz[v];
if (heavy[n] == -1 || sz[heavy[n]] < sz[v]) {
heavy[n] = v;
}
}
}
int dfs2(int n, int m, int t) {
aho2seg[n] = t;
seg2aho[t] = n;
top[n] = m;
if (heavy[n] != -1) t = dfs2(heavy[n], m, t + 1);
for (int v : graph[n]) {
if (v == heavy[n]) continue;
t = dfs2(v, v, t + 1);
}
return t;
}
int to_root(int v) {
int ans = -1;
while (v != -1) {
ans = max(ans, query(1, 1, S, aho2seg[top[v]], aho2seg[v]));
v = par[top[v]];
}
return ans;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
for (int i = 1; i <= N; ++i) {
string s;
cin >> s;
in2aho[i] = add_string(s);
aho2in[in2aho[i]] = i;
}
for (int i = 0; i < (int)aho.size(); ++i) get_link(i);
dfs1(0);
S = dfs2(0, 0, 1);
build(1, 1, S);
for (int j = 0; j < M; ++j) {
int op;
cin >> op;
if (op == 1) {
int i, x;
cin >> i >> x;
multiset<int>& ms = sus[in2aho[i]];
ms.erase(ms.find(A[i]));
ms.insert(x);
A[i] = x;
update(1, 1, S, aho2seg[in2aho[i]]);
} else {
string q;
cin >> q;
int v = 0;
int ans = -1;
for (char ch : q) {
v = get_go(v, ch);
ans = max(ans, to_root(v));
}
printf("%d\n", ans);
}
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
#pragma GCC optimize("O3")
using namespace std;
int n, I;
long long arr[400005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
cout.precision(8);
srand(time(0));
cin >> n >> I;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int power = 8 * I / n;
long long len = 1;
for (int i = 0; i < power && len <= 1e9; i++) {
len *= 2;
}
int ans = 1000000007;
int t = 1;
for (int l = 0, r = 0; l < n; l++) {
if (l && arr[l] != arr[l - 1]) {
t--;
}
while (r + 1 < n && t < len || (t == len && arr[r] == arr[r + 1])) {
t += arr[r] != arr[r + 1];
r++;
}
ans = min(ans, n - (r - l + 1));
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
string to_string(string s) { return '"' + s + '"'; }
string to_string(char s) { return string(1, s); }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = 1;
string r = "{";
for (const auto &x : v) {
if (!f) r += ", ";
f = 0;
r += to_string(x);
}
return r + "}";
}
void debug_out() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << " " << to_string(H);
debug_out(T...);
}
inline int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline int mul(int a, int b) { return (int)((long long)a * b % MOD); }
inline int binpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b /= 2;
}
return res;
}
inline int inv(int a) { return binpow(a, MOD - 2); }
int gcd(int a, int b, int &x, int &y) {
if (a == 0) {
x = 0, y = 1;
return b;
}
int x1, y1;
int d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
const int N = 3e5 + 5;
int n, m, a[N];
bool F(int x) {
int prev = 0;
for (int i = 0; i < n; ++i) {
if (a[i] + x >= m && prev <= a[i] + x - m) continue;
if (prev > a[i] + x) {
return false;
}
prev = max(prev, a[i]);
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i];
int low = -1, high = m - 1;
while (high - low > 1) {
int mid = (low + high) / 2;
F(mid) ? high = mid : low = mid;
}
cout << high << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<int> G[200005];
int Next[200005];
int Array[200005];
int Sz[200005], Size[200005];
int sum, cnt;
bool Blocked[200005];
struct Solution {
int x, y, y2;
} S[400005];
bool first;
int End[200005], Start[200005];
int aux, source;
unordered_set<int> X[200005];
void Read() {
scanf("%d", &N);
for (int i = 2; i <= N; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
X[x].insert(y);
X[y].insert(x);
}
}
void DFS(int node, int father) {
Sz[node] = 1;
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i];
if (neighb == father || Blocked[neighb] == 1) continue;
DFS(neighb, node);
Sz[node] += Sz[neighb];
}
}
int findCentroid(int node, int father, int size) {
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i];
if (neighb == father || Blocked[neighb] == 1) continue;
if (Sz[neighb] > size / 2) return findCentroid(neighb, node, size);
}
return node;
}
void makeBamboo(int node, int father) {
int f = father;
int ct = 0;
int last = node, p;
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i];
if (neighb == father) continue;
makeBamboo(neighb, node);
p = neighb;
if (ct == 0) Start[node] = End[neighb];
last = End[neighb];
ct++;
}
if (ct == 0)
End[node] = Start[node] = node;
else {
End[node] = last;
if (ct == 1) {
Next[father] = node;
Next[node] = Start[p];
Start[node] = node;
return;
}
Next[node] = Start[p];
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i];
if (neighb == father || End[neighb] == End[node]) continue;
++cnt;
S[cnt].x = f;
S[cnt].y = node;
S[cnt].y2 = End[neighb];
if (f == source) aux = End[neighb];
X[f].erase(node);
X[node].erase(f);
X[f].insert(End[neighb]);
X[End[neighb]].insert(f);
Next[f] = End[neighb];
f = Start[neighb];
Next[f] = node;
}
}
}
void makeStar(int node) {
int ct = 0;
int ind = 0;
Array[++ind] = source;
Array[++ind] = aux;
node = aux;
bool ok = 1;
while (X[node].size() == 2) {
ok = 0;
auto it = X[node].begin();
int n = *it;
if (Array[ind - 1] == n) {
it = next(it);
n = *it;
}
Array[++ind] = n;
node = n;
}
for (int i = ind - 2; i >= 1; i--) {
++cnt;
S[cnt].x = Array[i];
S[cnt].y = Array[i + 1];
S[cnt].y2 = Array[ind];
}
}
int main() {
Read();
int root = 1;
DFS(root, 0);
bool ok = 0;
int center = findCentroid(root, 0, Sz[root]);
for (int i = 0; i < G[center].size(); i++) {
int neighb = G[center][i];
if (Sz[neighb] == N - Sz[neighb]) {
ok = 1;
Blocked[center] = 1;
Blocked[neighb] = 1;
int node = center;
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i];
int from = center;
aux = neighb;
source = node;
if (Blocked[neighb] == 1) continue;
makeBamboo(neighb, node);
makeStar(node);
}
node = neighb;
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i];
int from = center;
aux = neighb;
source = node;
if (Blocked[neighb] == 1) continue;
makeBamboo(neighb, node);
makeStar(node);
}
break;
}
}
if (ok == 0) {
int node = center;
for (int i = 0; i < G[node].size(); i++) {
int neighb = G[node][i];
int from = center;
aux = neighb;
source = node;
if (Blocked[neighb] == 1) continue;
makeBamboo(neighb, node);
makeStar(node);
}
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) {
printf("%d %d %d\n", S[i].x, S[i].y, S[i].y2);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int P = 1000000009;
int n, a, b, k;
long long ans = 0, part;
char s[N];
void exGcd(int a, int b, int& x, int& y);
int rev(int a);
int mpow(int x, int k);
int main() {
scanf("%d%d%d%d", &n, &a, &b, &k);
scanf("%s", s);
long long ra = rev(a), rb = rev(b), an = mpow(a, n), bn = 1;
for (int i = 0; i < k; ++i) {
if (s[i] == '+')
part = (part + (long long)an * bn) % P;
else
part = (part + (long long)(P - 1) * an % P * bn % P) % P;
an = (long long)an * ra % P;
bn = (long long)bn * b % P;
}
long long cyc = (n + 1) / k;
long long rat = (long long)mpow(ra, k) * mpow(b, k) % P;
if (rat != 1)
ans = part * (long long)(1 + P - (long long)mpow(rat, cyc)) % P *
rev((1 + P - (long long)rat) % P) % P;
else
ans = part * (long long)cyc % P;
if (ans < 0) ans += P;
printf("%I64d\n", ans);
return 0;
}
int mpow(int x, int k) {
int ret = 1;
while (k) {
if (k & 1) ret = (long long)ret * x % P;
x = (long long)x * x % P;
k >>= 1;
}
return ret;
}
int rev(int a) {
int x, y;
exGcd(a, P, x, y);
if (x < 0) x += P;
return x;
}
void exGcd(int a, int b, int& x, int& y) {
if (!b) {
x = 1;
y = 0;
return;
}
exGcd(b, a % b, y, x);
y -= a / b * x;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int nf, ne, ns, rf, re, rs, df, de, xm;
double ans;
double cold[25], wf[25], we[25], f[25][25][25], cve[25][25], cvf[25][25];
void dp() {
int i, j;
for (i = 1; i <= xm; ++i) {
wf[i] = 0;
for (j = 1; j <= xm; ++j) wf[i] += cold[j] * cvf[j][i];
}
for (i = 1; i <= xm; ++i) {
we[i] = 0;
for (j = 1; j <= xm; ++j) we[i] += cold[j] * cve[j][i];
}
for (i = (0); i <= xm; ++i)
for (j = (0); j <= (nf); ++j)
for (int k = (0); k <= (ne); k++) f[i][j][k] = -1e100;
f[0][nf][ne] = 0;
for (int n = (0); n <= (xm - 1); n++)
for (int a = (0); a <= (nf); a++)
for (int b = (0); b <= (ne); b++)
if (f[n][a][b] >= -1e-9)
for (int ua = (0); ua <= (2); ua++)
for (int ub = (0); ub <= (2); ub++)
if (ua + ub + cold[n + 1] <= 2 && ua <= a && ub <= b)
f[n + 1][a - ua][b - ub] =
max(f[n + 1][a - ua][b - ub],
f[n][a][b] + ua * wf[n + 1] + ub * we[n + 1]);
ans = max(ans, f[xm][0][0]);
}
void dfs(int cur) {
if (cur > xm) {
dp();
return;
}
cold[cur] = 0;
dfs(cur + 1);
if (ns) {
cold[cur] = 1;
ns--;
dfs(cur + 1);
if (ns) {
cold[cur] = 2;
ns--;
dfs(cur + 1);
ns++;
}
ns++;
}
}
double get(double x1, double ra1, double x2, double ra2) {
double l1 = x1 - sqrt(ra1 * ra1 - 1), r1 = x1 + sqrt(ra1 * ra1 - 1);
double l2 = x2 - sqrt(ra2 * ra2 - 1), r2 = x2 + sqrt(ra2 * ra2 - 1);
l1 = max(l1, l2);
r1 = min(r1, r2);
if (l1 + 1e-9 > r1)
return 0;
else
return r1 - l1;
}
int main() {
int i, j;
scanf("%d%d%d%d%d%d%d%d", &nf, &ne, &ns, &rf, &re, &rs, &df, &de);
xm = (nf + ne + ns + 1) / 2;
for (i = 1; i <= xm; ++i)
for (j = 1; j <= xm; ++j) cvf[i][j] = get(i, rs, j, rf) * df;
for (i = 1; i <= xm; ++i)
for (j = 1; j <= xm; ++j) cve[i][j] = get(i, rs, j, re) * de;
ans = -1e100;
dfs(1);
ans += sqrt(rf * rf - 1) * 2 * nf * df + sqrt(re * re - 1) * 2 * ne * de;
printf("%.16lf\n", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int t[1000 * 1000 + 10];
int sp[1000 * 1000 + 10];
int suma(int i, int j) { return sp[j] - sp[i - 1]; }
int policz(int i, int aktw, int zos) {
if (zos == 0) return aktw;
return aktw + suma(i + 1, i + zos);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n, k, z;
cin >> n >> k >> z;
for (int i = 1; i <= n; i++) {
cin >> t[i];
sp[i] = sp[i - 1] + t[i];
}
int wynik = t[1];
int akt = t[1];
for (int i = 2; i <= n; i++) {
int aktwyn = 0;
akt += t[i];
aktwyn = akt;
int zostalo = k - i + 1;
if (zostalo == 0) {
wynik = max(wynik, aktwyn);
break;
}
for (int j = 1; j <= z; j++) {
if (zostalo == 0) break;
aktwyn += t[i - 1];
zostalo--;
if (zostalo == 0) break;
aktwyn += t[i];
zostalo--;
wynik = max(wynik, policz(i, aktwyn, zostalo));
}
if (zostalo == 0) {
wynik = max(wynik, aktwyn);
continue;
}
aktwyn += suma(i + 1, i + zostalo);
wynik = max(wynik, aktwyn);
}
cout << wynik << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 2e5 + 4;
int n, idx[N], ans[N];
char s[4];
set<int> s1, s2;
int main() {
n = read();
for (int i = 1; i <= (n << 1); i++) {
scanf("%s", s);
if (s[0] == '+') {
s1.insert(i);
} else {
idx[read()] = i;
s2.insert(i);
}
}
for (int i = 1, x; i <= n; i++) {
x = idx[i];
auto it1 = s1.lower_bound(x);
auto it2 = s2.lower_bound(x);
if (it1 == s1.begin()) {
puts("NO");
return (0 - 0);
}
--it1;
if (it2 != s2.begin() && (*(--it2)) > (*it1)) {
puts("NO");
return (0 - 0);
}
ans[*it1] = i;
s1.erase(it1);
s2.erase(x);
}
puts("YES");
for (int i = 1; i <= (n << 1); i++)
if (ans[i]) cout << ans[i] << " ";
return (0 - 0);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int cnt[30];
int main() {
int T;
cin >> T;
while (T--) {
memset(cnt, 0, sizeof(cnt));
int n;
cin >> n;
for (int i = 1, x; i <= n; i++) {
cin >> x;
for (int j = 0; j < 30; j++) {
cnt[j] += bool(x & (1 << j));
}
}
int g = 0;
for (int i = 0; i < 30; i++) {
if (cnt[i]) {
g = gcd(g, cnt[i]);
}
}
for (int k = 1; k <= n; k++) {
if (g % k == 0) {
cout << k << " ";
}
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long n, L;
scanf("%lld %lld", &n, &L);
vector<long long> C(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &C[i]);
i > 0 ? C[i] = min(C[i], C[i - 1] * 2) : NULL;
}
long long ans = LLONG_MAX;
long long sum = 0;
for (int i = n - 1; i >= 0; i--) {
long long need = L / (1 << i);
sum += need * C[i];
L -= need * (1 << i);
ans = min(ans, sum + (L > 0) * C[i]);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
char s[110][10010];
int dis[110][10010];
int n, m;
bool check() {
for (int i = 1; i <= n; i++) {
bool flag = 0;
for (int j = 0; j < m; j++) {
if (s[i][j] == '1') flag = 1;
}
if (!flag) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i]);
}
if (check()) return puts("-1"), 0;
memset(dis, inf, sizeof(dis));
for (int i = 1; i <= n; i++) {
int last = -1;
for (int j = 0; j < m; j++) {
if (s[i][j] == '1') {
dis[i][j] = 0;
last = j;
} else if (last != -1) {
dis[i][j] = min(dis[i][j], j - last);
}
}
last = m;
for (int j = m - 1; j >= 0; j--) {
if (s[i][j] == '1') {
dis[i][j] = 0;
last = j;
} else if (last != m) {
dis[i][j] = min(dis[i][j], last - j);
}
}
for (int j = 0; j < m; j++) {
if (s[i][j] == '1') {
last = j;
break;
}
}
for (int j = m - 1; j >= 0; j--) {
dis[i][j] = min(dis[i][j], last + m - j);
}
for (int j = m - 1; j >= 0; j--) {
if (s[i][j] == '1') {
last = j;
break;
}
}
for (int j = 0; j < m; j++) {
dis[i][j] = min(dis[i][j], m - 1 - last + 1 + j);
}
}
int ans = inf;
for (int i = 0; i < m; i++) {
int tmp = 0;
for (int j = 1; j <= n; j++) {
tmp += dis[j][i];
}
ans = min(ans, tmp);
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long msb(long long x) { return 63 - __builtin_clzll(x); }
long long f(long long x) {
if (x == 1) {
return 0;
}
long long p = 1ll << msb(x);
if (x - p > 0) {
long long y = x - p;
return p + f(p) + f(y);
} else {
return 2 * f(x / 2) + x / 2;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
long long ans = f(n);
cout << ans << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int pos(long long int n) {
if (n >= 0) {
return n;
}
return -n;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
long long int a[100005];
bool visited[100005];
map<long long int, long long int> m[100005];
vector<long long int> graph[100005];
long long int answer = 0;
long long int pr = 1000000007;
void dfs(long long int n, long long int p) {
visited[n] = 1;
m[n][a[n]]++;
map<long long int, long long int>::iterator it;
if (p != 0) {
for (it = m[p].begin(); it != m[p].end(); it++) {
m[n][gcd(a[n], it->first)] += it->second;
}
}
for (it = m[n].begin(); it != m[n].end(); it++) {
answer += it->first * it->second;
if (answer >= p) {
answer %= pr;
}
}
for (long long int i = 0; i < graph[n].size(); i++) {
if (visited[graph[n][i]]) {
continue;
}
dfs(graph[n][i], n);
}
return;
}
signed main() {
long long int n;
cin >> n;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < n - 1; i++) {
long long int a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
dfs(1, 0);
cout << answer;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
if (n < 3)
cout << "No" << '\n';
else {
cout << "Yes" << '\n';
vector<int> v1, v2;
for (int i = (1); i < (n + 1); ++i)
if (i & 1)
v1.push_back(i);
else
v2.push_back(i);
cout << v1.size() << " ";
for (int x : v1) cout << x << " ";
cout << '\n';
cout << v2.size() << " ";
for (int x : v2) cout << x << " ";
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct neededLetter {
int A, C, T, G;
};
int n;
string s;
neededLetter diff[55];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> s;
for (int i = 0; i < n; ++i) {
diff[i].A = s[i] - 'A';
diff[i].C = s[i] - 'C';
diff[i].T = s[i] - 'T';
diff[i].G = s[i] - 'G';
if (diff[i].C < 0) {
diff[i].C += 26;
}
if (diff[i].T < 0) {
diff[i].T += 26;
}
if (diff[i].G < 0) {
diff[i].G += 26;
}
diff[i].A = min(diff[i].A, 'A' - s[i] < 0 ? 'A' - s[i] + 26 : 'A' - s[i]);
diff[i].C = min(diff[i].C, 'C' - s[i] < 0 ? 'C' - s[i] + 26 : 'C' - s[i]);
diff[i].T = min(diff[i].T, 'T' - s[i] < 0 ? 'T' - s[i] + 26 : 'T' - s[i]);
diff[i].G = min(diff[i].G, 'G' - s[i] < 0 ? 'G' - s[i] + 26 : 'G' - s[i]);
}
int ans = 100000005;
for (int i = 0; i < n - 3; ++i) {
int currentCost = diff[i].A + diff[i + 1].C + diff[i + 2].T + diff[i + 3].G;
ans = min(ans, currentCost);
}
cout << ans << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int s, x1, x2, t1, t2, p, d, ans;
int main() {
cin >> s >> x1 >> x2 >> t1 >> t2 >> p >> d;
if (x1 > p) {
ans = (x1 - (p * d)) * t1;
d = 1;
}
if (p > x1) {
ans = ((d == -1) ? p - x1 : 2 * s - (x1 + p)) * t1;
d = -1;
}
if (x2 > x1) {
ans += (x2 - (d * x1)) * t1;
d = 1;
}
if (x1 > x2) {
ans += ((d == -1) ? x1 - x2 : 2 * s - (x1 + x2)) * t1;
d = -1;
}
cout << min(abs(x1 - x2) * t2, ans) << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[500][500];
int main() {
int n, t;
while (scanf("%d%d", &n, &t) == 2) {
memset(a, 0, sizeof(a));
a[200][200] = n;
int sz = 0;
while (1) {
bool flag = true;
for (int i = 200 - sz; i <= 200 + sz; i++)
for (int j = 200 - sz; j <= 200 + sz; j++)
if (a[i][j] >= 4) {
flag = false;
if (max(abs(i - 200), abs(j - 200)) == sz) sz++;
a[i - 1][j] += a[i][j] / 4;
a[i + 1][j] += a[i][j] / 4;
a[i][j - 1] += a[i][j] / 4;
a[i][j + 1] += a[i][j] / 4;
a[i][j] %= 4;
}
if (flag) break;
}
int x, y;
while (t--) {
scanf("%d%d", &x, &y);
if (x < -200 || y < -200 || x > 200 || y > 200)
printf("0\n");
else
printf("%d\n", a[x + 200][y + 200]);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int r, c, n, k, a[60][60], x, y, ans, ans1;
int main() {
cin >> r >> c >> n >> k;
for (long long int i = 1; i <= n; i++) {
cin >> x >> y;
a[x][y] = 1;
}
for (long long int i = 1; i <= r; i++) {
for (long long int j = 1; j <= i; j++) {
for (long long int q = 1; q <= c; q++) {
for (long long int w = 1; w <= q; w++) {
for (long long int e = j; e <= i; e++) {
for (long long int t = w; t <= q; t++) {
if (a[e][t]) ans++;
}
}
if (ans >= k) ans1++;
ans = 0;
}
}
}
}
cout << ans1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long double PI = 3.141592653589793238462643383279502884197;
priority_queue<int, vector<int>, greater<int> > pq;
vector<int> v[100000];
long long vec[100000];
pair<long long, long long> dp[100000];
void go(int o, int pa) {
for (int i = 0; i < (int)(v[o]).size(); i++) {
if (v[o][i] == pa) continue;
go(v[o][i], o);
}
long long val = vec[o] - dp[o].first - dp[o].second;
if (val < 0)
dp[pa] = {max(dp[pa].first, dp[o].first),
min(dp[pa].second, dp[o].second + val)};
else
dp[pa] = {max(dp[pa].first, dp[o].first + val),
min(dp[pa].second, dp[o].second)};
}
int main() {
int n;
scanf("%d", &n);
int a, b;
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &a, &b);
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 0; i < n; i++) scanf("%lld", &vec[i]);
go(0, 0);
printf("%lld", dp[0].first - dp[0].second);
}
| 10 |
#include <bits/stdc++.h>
const int factor_N = 10000005;
using namespace std;
int read() {
char c = getchar();
int x = 0, f = 1;
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
return x * f;
}
struct Node {
int t, a, b;
};
const int N = 2e5 + 5;
int n, k;
int a[N], b[N], c[N];
int cnta, cntb, cntc, t, aa, bb;
int ans;
int main() {
n = read();
k = read();
for (int i = (1); i <= (n); ++i) {
t = read();
aa = read();
bb = read();
if (aa == 0 && bb != 0)
a[++cnta] = t;
else if (aa != 0 && bb == 0)
b[++cntb] = t;
else if (aa == 1 && bb == 1)
c[++cntc] = t;
}
if (cnta + cntc < k || cntb + cntc < k) {
cout << -1 << endl;
return 0;
}
sort(a + 1, a + 1 + cnta);
sort(b + 1, b + 1 + cntb);
sort(c + 1, c + 1 + cntc);
int t = min(cnta, cntb);
for (int i = 1; i <= k && i <= t; ++i) ans += a[i];
for (int i = 1; i <= k && i <= t; ++i) ans += b[i];
if (t < k) {
for (int i = 1; i <= k - t; ++i) ans += c[i];
int tt = k - t + 1;
while (c[tt] < a[t] + b[t] && tt <= cntc)
ans -= a[t], ans -= b[t], ans += c[tt], tt++, t--;
cout << ans << endl;
return 0;
}
int tt = 1;
while (c[tt] < a[k] + b[k] && tt <= cntc) {
ans -= a[k];
ans -= b[k];
ans += c[tt];
tt++;
k--;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int mp[500];
int n, a, b;
while (~scanf("%d%d%d", &n, &a, &b)) {
if (a > b) swap(a, b);
for (int i = 1; i <= n; i++) mp[i] = i;
int ans = 0;
int p = 1;
int flag = 0;
while (1) {
ans++;
for (int i = 2; i <= n; i += 2) {
if (mp[i - 1] == a && mp[i] == b) flag = 1;
if (mp[i - 1] == b && mp[i] == a) flag = 1;
if (flag == 1) break;
if (flag == 1) break;
if (mp[i] == a || mp[i - 1] == a)
mp[p++] = a;
else if (mp[i] == b || mp[i - 1] == b)
mp[p++] = b;
else
mp[p++] = mp[i];
}
if (flag == 1) break;
n = n / 2;
p = 1;
}
if (n != 2)
printf("%d\n", ans);
else
printf("Final!\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a = 0, b = 0, c, d, e, f = 0, l, g, m, n, k, i, j, t, p, q;
cin >> n;
for (i = 0; i < n; i++) {
f = 0;
cin >> a >> b;
c = abs(a - b);
f += c / 5;
c = c % 5;
f += c / 2;
c = c % 2;
f += c;
cout << f << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, x;
cin >> n >> x;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (a[i] > b[i]) {
swap(a[i], b[i]);
}
}
int cnt[1001];
for (int i = 0; i < 1001; i++) {
cnt[i] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = a[i]; j <= b[i]; j++) {
cnt[j]++;
}
}
bool ans = false;
int hld;
int small = 1e5;
for (int i = 0; i < 1001; i++) {
if (cnt[i] == n) {
ans = true;
hld = i;
small = min(small, abs(x - hld));
}
}
if (ans) {
cout << small;
} else {
cout << -1;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int h, w;
char grid[1501][1501];
bool viz[1501][1501];
pair<int, int> where[1501][1501];
const int di[] = {-1, 0, 1, 0}, dj[] = {0, 1, 0, -1};
int mod(int a, int b) {
int res = a % b;
if (res < 0) res += b;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> h >> w;
for (int row = 0; row < h; ++row) cin >> grid[row];
vector<pair<int, int> > Q;
for (int row = 0; row < h; ++row)
for (int col = 0; col < w; ++col)
if (grid[row][col] == 'S') {
viz[row][col] = true;
where[row][col] = make_pair(row, col);
Q.emplace_back(row, col);
break;
}
for (int i = 0; i < (int)Q.size(); ++i) {
int row = Q[i].first, col = Q[i].second;
for (int dir = 0; dir < 4; ++dir) {
int rv = row + di[dir], cv = col + dj[dir];
if (grid[mod(rv, h)][mod(cv, w)] == '#') continue;
if (!viz[mod(rv, h)][mod(cv, w)]) {
viz[mod(rv, h)][mod(cv, w)] = true;
where[mod(rv, h)][mod(cv, w)] = make_pair(rv, cv);
Q.emplace_back(rv, cv);
} else {
if (where[mod(rv, h)][mod(cv, w)] == make_pair(rv, cv)) continue;
cout << "Yes";
return 0;
}
}
}
cout << "No";
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
if (arr[0] < arr[n - 1])
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int mod = 1e9 + 9;
struct Node {
int x, y;
Node() {}
Node(int x, int y) : x(x), y(y) {}
bool operator<(const Node& a) const {
if (x != a.x) return x < a.x;
return y < a.y;
}
};
int n;
Node a[MAXN];
int vis[MAXN];
map<Node, int> mp;
long long pow(int a, int b) {
long long res = 1, tmp = a;
while (b) {
if (b & 1) res = res * tmp % mod;
tmp = tmp * tmp % mod;
b >>= 1;
}
return res;
}
bool check(Node a) {
Node t1 = Node(a.x - 1, a.y + 1);
Node t2 = Node(a.x, a.y + 1);
Node t3 = Node(a.x + 1, a.y + 1);
Node t11 = Node(a.x - 2, a.y);
Node t12 = Node(a.x - 1, a.y);
Node t21 = Node(a.x - 1, a.y);
Node t22 = Node(a.x + 1, a.y);
Node t31 = Node(a.x + 1, a.y);
Node t32 = Node(a.x + 2, a.y);
if (mp[t1]) {
if (!mp[t11] && !mp[t12]) return 0;
}
if (mp[t2]) {
if (!mp[t21] && !mp[t22]) return 0;
}
if (mp[t3]) {
if (!mp[t31] && !mp[t32]) return 0;
}
return 1;
}
void topo() {
int ans = 0;
int now = 0;
int x = n;
memset(vis, 0, sizeof vis);
priority_queue<int> q1;
priority_queue<int, vector<int>, greater<int> > q2;
for (int i = (0); i < (n); ++i)
if (check(a[i])) {
q1.push(i), q2.push(i);
}
while (!now && !q1.empty() || now && !q2.empty()) {
int u;
if (!now) {
u = q1.top();
q1.pop();
} else {
u = q2.top();
q2.pop();
}
if (vis[u]) continue;
if (!check(a[u])) continue;
now ^= 1;
vis[u] = 1;
ans = (ans + u * pow(n, --x)) % mod;
mp[a[u]] = 0;
Node t1 = Node(a[u].x - 1, a[u].y - 1);
Node t2 = Node(a[u].x, a[u].y - 1);
Node t3 = Node(a[u].x + 1, a[u].y - 1);
if (mp[t1] && check(t1)) q1.push(mp[t1] - 1), q2.push(mp[t1] - 1);
if (mp[t2] && check(t2)) q1.push(mp[t2] - 1), q2.push(mp[t2] - 1);
if (mp[t3] && check(t3)) q1.push(mp[t3] - 1), q2.push(mp[t3] - 1);
}
printf("%d\n", ans);
}
void solve() {
mp.clear();
for (int i = (0); i < (n); ++i) {
scanf("%d%d", &a[i].x, &a[i].y);
mp[a[i]] = i + 1;
}
topo();
}
int main() {
while (~scanf("%d", &n)) solve();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
char ch, B[1 << 20], *S = B, *T = B;
int aa, bb;
int rd() {
while (ch = (S == T && (T = (S = B) + fread(B, 1, 1 << 20, stdin), S == T)
? 0
: *S++),
!(ch >= '0' && ch <= '9') && ch != '-')
;
ch == '-' ? aa = bb = 0 : (aa = ch - '0', bb = 1);
while (ch = (S == T && (T = (S = B) + fread(B, 1, 1 << 20, stdin), S == T)
? 0
: *S++),
(ch >= '0' && ch <= '9'))
aa = aa * 10 + ch - '0';
return bb ? aa : -aa;
}
const int MAXN = 2e5 + 10;
const int BASE = 233;
char s[MAXN];
int n, a[MAXN], tot, flag[MAXN], cnt[MAXN];
long long power[MAXN], Hash[MAXN];
long long get(int l, int r) {
int len = r - l + 1;
return 1ll * Hash[r] - Hash[l - 1] * power[len];
}
long long check(int l, int r) {
int L = lower_bound(a + 1, a + tot + 1, l) - a;
int R = upper_bound(a + 1, a + tot + 1, r) - a - 1;
if (L <= R) {
long long x = (a[L] - l) & 1, v = x * power[R - L];
if (L < R) v += get(L + 1, R);
return v;
}
return 0;
}
inline void work() {
power[0] = 1;
for (register int i = 1; i < MAXN; ++i) power[i] = power[i - 1] * BASE;
scanf("%d%s", &n, s + 1);
int digit = 0;
for (register int i = 1; i <= n; ++i) {
cnt[i] = cnt[i - 1];
if (s[i] == '1')
digit++;
else {
flag[++tot] = digit & 1;
digit = 0;
a[tot] = i;
++cnt[i];
}
}
for (register int i = 1; i <= tot; ++i)
Hash[i] = Hash[i - 1] * BASE + flag[i];
int q;
scanf("%d", &q);
while (q--) {
int l1, l2, len, r1, r2;
scanf("%d%d%d", &l1, &l2, &len);
r1 = l1 + len - 1;
r2 = l2 + len - 1;
if (cnt[r1] - cnt[l1 - 1] == cnt[r2] - cnt[l2 - 1] &&
check(l1, r1) == check(l2, r2))
printf("Yes\n");
else
printf("No\n");
}
}
int main() {
work();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110000;
inline int read() {
int rtn = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) rtn = (rtn << 1) + (rtn << 3) + ch - '0';
return rtn * f;
}
int n, fa[maxn], color[maxn], ans;
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) fa[i] = read();
for (int i = 1; i <= n; i++) color[i] = read();
for (int i = 1; i <= n; i++)
if (color[i] != color[fa[i]]) ans++;
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i;
cin >> n;
long long a[n], b[n];
for (i = 0; i < n; i++) cin >> a[i] >> b[i];
for (i = 0; i < n; i++) {
if (a[i] - b[i] != 0) {
cout << "rated";
return 0;
}
}
long long flag = 0;
for (i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1]) {
flag = 1;
break;
}
}
if (flag == 0)
cout << "maybe";
else
cout << "unrated";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
int b[1000000];
int dp[2][1000000];
int n, k;
int tables(int l, int r) {
if (l >= n) return 0;
if (l < 0) l = 0;
if (r < 0) return 0;
if (r >= n) r = n - 1;
if (r < l) return 0;
if (l == 0) return b[r];
return b[r] - b[l - 1];
}
int test(int stage, int i) {
if (i >= n) return 0;
if (dp[stage][i] != -1) return dp[stage][i];
int cont, upg;
if (stage == 0) {
cont = (a[i] == 1) + test(stage, i + 1);
upg = (a[i] == 0) + tables(i + 1, i + k - 1) + test(stage + 1, i + k);
} else {
cont = (a[i] == 0) + tables(i + 1, i + k - 1) + test(stage, i + k);
upg = tables(i, n - 1);
}
dp[stage][i] = min(cont, upg);
return dp[stage][i];
}
void solve() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) dp[0][i] = -1;
for (int i = 0; i < n; i++) dp[1][i] = -1;
char c;
scanf("%c", &c);
for (int i = 0; i < n; i++) {
scanf("%c", &c);
if (c == '0')
a[i] = 0;
else
a[i] = 1;
}
scanf("%c", &c);
b[0] = a[0];
for (int i = 1; i < n; i++) {
b[i] = b[i - 1] + a[i];
}
printf("%d\n", test(0, 0));
}
int main() {
int q;
scanf("%d", &q);
while (q--) solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
double x, y, ang;
bool operator<(const edge& p) const { return ang < p.ang; }
} a[100008];
int main() {
int i, j, k, l, n, m, t, x, y;
cin >> n;
for (i = 0; i < n; i++) {
scanf("%lf %lf", &a[i].x, &a[i].y);
if (a[i].x < 0 && a[i].y == 0) {
a[i].ang = 180.00;
continue;
}
a[i].ang = atan(a[i].y / a[i].x) * 180 / 3.14159265359;
if (a[i].x < 0 && a[i].y >= 0)
a[i].ang = 180.00 + a[i].ang;
else if (a[i].x < 0 && a[i].y < 0)
a[i].ang = 180.00 + a[i].ang;
else if (a[i].x >= 0 && a[i].y < 0)
a[i].ang = 360.00 + a[i].ang;
if (a[i].ang == 360.00) a[i].ang = 0.00;
}
if (n == 1) {
printf("%lf\n", 0.00);
return 0;
}
if (n == 2) {
printf("%.10lf\n",
min(abs(a[0].ang - a[1].ang), 360.00 - abs(a[0].ang - a[1].ang)));
return 0;
}
sort(a, a + n);
double mi, d;
mi = 360.00 - abs(a[0].ang - a[n - 1].ang);
for (i = 0; i < n - 1; i++) {
d = abs(a[i].ang - a[i + 1].ang);
if (d > mi) mi = d;
}
printf("%.10lf\n", 360.00 - mi);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 57;
const int Mod = 1000000007;
int n, K, C[maxN][maxN];
int F[maxN][maxN][2];
void Plus(int &x, int y);
int main() {
scanf("%d%d", &n, &K);
F[1][0][0] = 1;
F[0][0][1] = 1;
for (int i = 0; i <= n; i++)
for (int j = C[i][0] = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % Mod;
for (int i = 2; i <= n; i++)
for (int j = 0; j <= K; j++) {
for (int sz = i - 1; sz >= i - 1 - sz; sz--)
for (int mt = 0; mt <= j; mt++) {
if (mt * 2 > sz || (j - mt) * 2 > i - 1 - sz) continue;
int c = 1ll * ((sz == i - 1 - sz) ? C[i - 2][sz - 1] : C[i - 1][sz]) *
((i == n) ? 1 : i) % Mod;
Plus(F[i][j][0],
1ll * F[sz][mt][1] * F[i - sz - 1][j - mt][1] % Mod * c % Mod);
}
for (int sz = i - 1; sz >= i - 1 - sz; sz--)
for (int mt = 0; mt < j; mt++) {
if (mt * 2 > sz || (j - mt - 1) * 2 > i - sz - 1) continue;
int c = 1ll * ((sz == i - 1 - sz) ? C[i - 2][sz - 1] : C[i - 1][sz]) *
((i == n) ? 1 : i) % Mod;
Plus(F[i][j][1], 1ll * F[sz][mt][0] * F[i - sz - 1][j - mt - 1][0] %
Mod * c % Mod);
Plus(F[i][j][1], 1ll * F[sz][mt][1] * F[i - sz - 1][j - mt - 1][0] %
Mod * c % Mod);
Plus(F[i][j][1], 1ll * F[sz][mt][0] * F[i - sz - 1][j - mt - 1][1] %
Mod * c % Mod);
}
}
printf("%d\n", (F[n][K][0] + F[n][K][1]) % Mod);
return 0;
}
void Plus(int &x, int y) {
x += y;
if (x >= Mod) x -= Mod;
return;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
if (f) return x;
return -x;
}
const int N = 1e5;
const int M = 2.5e5;
struct AEdge {
int u, v;
} ae[M + 3];
struct Edge {
int u, v, nxt;
} e[(M << 1) + 3];
int fe[N + 3];
int dgr[N + 3];
int ans[M + 3];
int vis[M + 3];
int n, m, en, tp;
void addedge(int u, int v) {
en++;
e[en].v = v;
e[en].u = u;
e[en].nxt = fe[u];
fe[u] = en;
}
void dfs(int u) {
for (int i = fe[u]; i; i = fe[u]) {
fe[u] = e[i].nxt;
if (vis[i >> 1]) continue;
vis[i >> 1] = true;
dfs(e[i].v);
ans[++tp] = i;
}
}
int main() {
scanf("%d%d", &n, &m);
en = 1;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &ae[i].u, &ae[i].v);
dgr[ae[i].u]++;
dgr[ae[i].v]++;
}
int tmp = 0;
for (int i = 1; i <= n; i++) {
if (dgr[i] & 1) {
if (tmp == 0) {
tmp = i;
} else {
ae[++m].u = tmp, ae[m].v = i;
tmp = 0;
}
}
}
if (m & 1) {
ae[++m].u = 1, ae[m].v = 1;
}
for (int i = 1; i <= m; i++) {
addedge(ae[i].u, ae[i].v);
addedge(ae[i].v, ae[i].u);
}
dfs(ae[1].v);
printf("%d\n", m);
for (int i = 1; i <= tp; i++) {
if (i & 1)
printf("%d %d\n", e[ans[i]].v, e[ans[i]].u);
else
printf("%d %d\n", e[ans[i]].u, e[ans[i]].v);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
inline void read(long long &x) {
long long w = 1;
x = 0;
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();
}
x *= w;
}
struct road {
long long to, val;
};
vector<road> side[300010];
long long fa[300010], dep[300010], siz[300010], maxdep[300010];
bool used[300010];
void dfs(long long x) {
siz[x] = 1;
maxdep[x] = dep[x];
for (long long i = 0; i < side[x].size(); i++) {
long long to = side[x][i].to;
long long val = side[x][i].val;
if (to == fa[x]) continue;
dep[to] = dep[x] + val;
fa[to] = x;
dfs(to);
siz[x] += siz[to];
maxdep[x] = max(maxdep[x], dep[to]);
}
}
signed main() {
long long n, m, a, b, c;
read(n);
read(m);
for (long long i = 1; i < n; i++) {
read(a);
read(b);
read(c);
side[a].push_back((road){b, c});
side[b].push_back((road){a, c});
}
fa[1] = 1;
dfs(1);
long long now = n, maxx = -9999999999999999, ladep = -9999999999999,
ladep2 = -9999999999999;
while (1) {
long long tofa, sizz = 0;
used[now] = 1;
maxx = max(ladep2, maxx);
for (long long i = 0; i < side[now].size(); i++) {
long long to = side[now][i].to;
long long val = side[now][i].val;
if (to == fa[now]) {
tofa = val;
continue;
}
if (used[to]) continue;
maxx = max(maxdep[to] - dep[now] + ladep, maxx);
sizz += siz[to];
ladep = max(ladep, maxdep[to] - dep[now]);
}
if (sizz > 1) maxx = 99999999999999999;
ladep2 = max(ladep, ladep2);
ladep2 -= tofa;
ladep = max(0ll, ladep);
ladep -= tofa;
if (now == 1) break;
now = fa[now];
}
for (long long i = 1; i <= m; i++) {
read(a);
cout << dep[n] + min(0ll, maxx + a) << "\n";
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n == 1) {
scanf("%d", &n);
printf("%d\n", n);
printf("%s\n", string(n, 'a').c_str());
return 0;
}
vector<pair<int, char>> v(n);
int odd = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i].first);
odd += (v[i].first & 1);
v[i].second = char(i + 'a');
}
if (odd <= 1) {
int g = 1;
for (int i = 100000; i >= 1; i--) {
int c = 0;
for (int j = 0; j < (int)v.size(); j++) {
c += (v[j].first % i == 0);
}
if (c == (int)v.size()) {
g = i;
break;
}
}
printf("%d\n", g);
if (g % 2 == 0) {
string str = "";
for (int j = 0; j < (int)v.size(); j++) {
for (int k = 0; k < v[j].first / g; k++) {
str += v[j].second;
}
}
string sstr = str;
reverse((sstr).begin(), (sstr).end());
for (int i = 1; i <= g; i++)
printf("%s", (i & 1 ? str.c_str() : sstr.c_str()));
printf("\n");
} else {
string str = "";
int pos = -1;
for (int j = 0; j < (int)v.size(); j++) {
for (int k = 1; 2 * k <= v[j].first / g; k++) {
str += v[j].second;
}
if (v[j].first & 1) pos = j;
}
string sstr = str;
reverse((str).begin(), (str).end());
if (pos != -1) str += v[pos].second;
str += sstr;
for (int i = 1; i <= g; i++) printf("%s", str.c_str());
printf("\n");
}
} else {
printf("0\n");
for (int i = 0; i < n; i++) {
for (int j = 0; j < v[i].first; j++) {
printf("%c", v[i].second);
}
}
printf("\n");
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int a[maxn], b[maxn];
long long dp[maxn];
int main() {
int n;
int maxn = 0;
long long ans;
while (cin >> n) {
memset(b, 0, sizeof(b));
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]]++;
maxn = max(maxn, a[i]);
}
dp[1] = b[1];
dp[0] = 0;
for (int i = 2; i <= maxn; i++)
dp[i] = max(dp[i - 1], dp[i - 2] + (long long)i * b[i]);
ans = 0;
for (int i = 1; i <= maxn; i++) ans = max(ans, dp[i]);
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
string s, c;
getchar();
while (T--) {
getline(cin, s, ' ');
getline(cin, c, '\n');
bool f = false;
string a = s;
sort(a.begin(), a.end());
int m = min(s.length(), c.length());
int ci = s.length();
for (int i = 0; i < a.length(); i++) {
if (s[i] != a[i]) {
for (int j = s.length() - 1; j > i; j--) {
if (s[j] == a[i]) {
swap(s[i], s[j]);
f = true;
break;
}
}
if (f) break;
}
}
if (s < c)
cout << s << endl;
else
cout << "---" << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, x, y, c = 0, d = 0;
cin >> n;
vector<long long int> v(n);
for (i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
x = v[0];
y = v[n - 1];
for (i = 0; i < n; i++) {
if (v[i] == x) c++;
if (v[i] == y) d++;
}
cout << y - x << " ";
if (x == y)
cout << n * (n - 1) / 2;
else
cout << c * d;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int T, ans = 0, len1, len2, len3, a[30], b[30];
string s, t, p;
inline int read() {
int red = 0, f_f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f_f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') red = red * 10 + ch - '0', ch = getchar();
return red * f_f;
}
int main() {
T = read();
while (T--) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
ans = 0;
cin >> s >> t >> p;
len1 = s.length(), len2 = t.length(), len3 = p.length();
for (int i = 0; i < len3; i++) a[p[i] - 'a']++;
int pos = 0, flg = 1;
for (int i = 0; i < len2; i++) {
if (pos < len1 && t[i] == s[pos])
pos++;
else if (a[t[i] - 'a'])
a[t[i] - 'a']--;
else {
flg = 0;
break;
}
}
if (flg && pos == len1)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long add = 1, t, h, n, i, j, mn = 100003LL * 100003LL, k, mx = 0, rz = 0,
tot, m, obj, st, cnt = 0, cnti = 0, s = 0, nri = 0, a[4], b = 0,
c = 0, a2, b2, a3, b3;
n = 500;
m = 1000000;
cout << n << '\n';
int r = m, x = m / 2;
cout << x << ' ' << r << '\n';
for (i = 1; i < n - 1; ++i) {
x += 2 * (n - i) + 1;
r = n - i;
cout << x << ' ' << r << '\n';
}
cout << m << ' ' << m << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int bigp = 10000007;
int H, Q, N, V, E, p, xc, yc, dg;
int hash1[15000005], hash2[15000005];
char st[10];
double ans;
void mplus(int S, int E) {
int e = S % bigp;
while ((hash1[e] != 0) && (hash1[e] != S)) ++e;
hash1[e] = S;
hash2[e] += E;
}
int getsize(int S) {
int e = S % bigp;
while ((hash1[e] != 0) && (hash1[e] != S)) ++e;
if (hash1[e] == 0)
return 0;
else
return hash2[e];
}
int main() {
scanf("%d %d", &H, &Q);
N = 1 << H;
memset(hash1, 0, sizeof(hash1));
memset(hash2, 0, sizeof(hash2));
for (int sc = 1; sc <= Q; sc++) {
scanf("%s", st);
if (st[0] == 'd') {
p = 1;
ans = 0;
dg = 0;
double t = 0.5;
for (int i = 1; i <= H; i++) {
xc = getsize(p * 2);
yc = getsize(p * 2 + 1);
if (xc >= yc) {
ans += double(max(getsize(p) - yc, dg)) * t;
dg = max(dg, getsize(p) - xc);
p = p * 2;
} else {
ans += double(max(getsize(p) - xc, dg)) * t;
dg = max(dg, getsize(p) - yc);
p = p * 2 + 1;
}
t *= 0.5;
}
t *= 2;
ans += double(max(getsize(p), dg)) * t;
printf("%.10lf\n", ans);
} else {
scanf("%d %d", &V, &E);
while (V > 0) {
mplus(V, E);
V /= 2;
}
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
struct segtree {
int64_t n;
vector<pair<int64_t, int64_t>> seg;
segtree(int64_t n)
: n(n), seg(2 * n, {(int64_t)(1e17 + 1), (int64_t)(1e17 + 1)}) {}
pair<int64_t, int64_t> f(pair<int64_t, int64_t> a, pair<int64_t, int64_t> b) {
return min(a, b);
}
void update(int64_t nv, int64_t i) {
for (seg[i += n] = {nv, i}; i > 1; i >>= 1) {
seg[i >> 1] = f(seg[i], seg[i ^ 1]);
}
}
pair<int64_t, int64_t> query(int64_t l, int64_t r) {
pair<int64_t, int64_t> cur = {(int64_t)(1e17 + 1), (int64_t)(1e17 + 1)};
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) cur = f(cur, seg[l++]);
if (r & 1) cur = f(cur, seg[--r]);
}
return cur;
}
};
vector<int64_t> v((int64_t)(5e5 + 5)), p((int64_t)(5e5 + 5));
vector<pair<int64_t, int64_t>> qs[(int64_t)(5e5 + 5)];
segtree seg((int64_t)(5e5 + 5));
void solve() {
int64_t n;
cin >> n;
for (int64_t i = 1; i <= n; i++) cin >> v[i];
int64_t q;
cin >> q;
vector<int64_t> ans(q);
for (int64_t i = 0; i < q; i++) {
int64_t l, r;
cin >> l >> r;
qs[r].push_back({l, i});
}
for (int64_t i = 1; i <= n; i++) {
seg.update(p[v[i]], i);
seg.update((int64_t)(1e17 + 1), p[v[i]]);
p[v[i]] = i;
for (auto [l, id] : qs[i]) {
auto k = seg.query(l, i);
if (l > k.first) ans[id] = v[k.second];
}
}
for (auto x : ans) cout << x << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64_t t = 1;
while (t--) solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, b[1005];
long long a[1005];
vector<int> A, B, ansA, ansB;
vector<pair<long long, long long> > tA, tB;
long long qry(int x, int y, int z, int w) {
printf("%d %d %d %d\n", x, y, z, w);
fflush(stdout);
long long ret;
scanf("%lld", &ret);
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 3; i <= n; i++) {
if (qry(2, 1, i, 2) == 1)
A.push_back(i);
else
B.push_back(i);
}
if (A.size()) {
int m = A.size();
for (int i = 0; i < m; i++) a[i] = qry(1, 1, 2, A[i]);
int pos = -1;
for (int i = 0; i < m; i++)
if (pos == -1 || a[i] > a[pos]) pos = i;
tA.clear();
tB.clear();
for (int i = 0; i < m; i++) {
if (pos == i) continue;
if (qry(2, 1, A[pos], A[i]) == -1)
tA.push_back((pair<long long, long long>){a[i], A[i]});
else
tB.push_back((pair<long long, long long>){a[i], A[i]});
}
sort(tA.begin(), tA.end());
sort(tB.begin(), tB.end());
reverse(tB.begin(), tB.end());
for (auto x : tA) ansA.push_back(x.second);
ansA.push_back(A[pos]);
for (auto x : tB) ansA.push_back(x.second);
}
if (B.size()) {
int m = B.size();
for (int i = 0; i < m; i++) a[i] = qry(1, 1, 2, B[i]);
int pos = -1;
for (int i = 0; i < m; i++)
if (pos == -1 || a[i] > a[pos]) pos = i;
tA.clear();
tB.clear();
for (int i = 0; i < m; i++) {
if (pos == i) continue;
if (qry(2, 2, B[pos], B[i]) == -1)
tA.push_back((pair<long long, long long>){a[i], B[i]});
else
tB.push_back((pair<long long, long long>){a[i], B[i]});
}
sort(tA.begin(), tA.end());
sort(tB.begin(), tB.end());
reverse(tB.begin(), tB.end());
for (auto x : tA) ansB.push_back(x.second);
ansB.push_back(B[pos]);
for (auto x : tB) ansB.push_back(x.second);
}
printf("0 1 ");
for (auto x : ansA) printf("%d ", x);
printf("2 ");
for (auto x : ansB) printf("%d ", x);
puts("");
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a;
cin >> b;
cin >> c;
if (a <= b && a <= c) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
vector<vector<long long> > v(300005);
long long vis[300005];
long long ct;
long long pmod(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
n /= 2;
}
return res % mod;
}
void dfs(long long root) {
ct++;
vis[root] = 1;
vector<long long> j = v[root];
for (long long i = 0; i < j.size(); i++) {
if (vis[j[i]] == 0) {
dfs(j[i]);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
long long ans = 1;
long long a, b, c;
for (long long i = 0; i < n - 1; i++) {
cin >> a >> b >> c;
if (c == 0) {
v[a].push_back(b);
v[b].push_back(a);
}
}
ans = pmod(n, k);
long long x = 0;
for (long long i = 1; i <= n; i++) {
if (vis[i] == 0) {
ct = 0;
dfs(i);
ans -= pmod(ct, k);
ans += mod;
ans %= mod;
}
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int ara[n + 5][m + 5];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> ara[i][j];
}
}
vector<int> vr[n + 5], vc[m + 5];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
vr[i].push_back(ara[i][j]);
}
sort(vr[i].begin(), vr[i].end());
vr[i].erase(unique(vr[i].begin(), vr[i].end()), vr[i].end());
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
vc[i].push_back(ara[j][i]);
}
sort(vc[i].begin(), vc[i].end());
vc[i].erase(unique(vc[i].begin(), vc[i].end()), vc[i].end());
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int xi =
lower_bound(vr[i].begin(), vr[i].end(), ara[i][j]) - vr[i].begin();
int yi =
lower_bound(vc[j].begin(), vc[j].end(), ara[i][j]) - vc[j].begin();
int interi = max(xi, yi);
int intere = max(vr[i].size() - xi, vc[j].size() - yi);
cout << intere + interi << ' ';
}
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[101000], cnt1[201000], cnt2[201000], chand1[101000], chand2[101000];
int check(int t) {
int i = 0, j = 0, o = 0, d = 0;
bool ch = 1;
while (ch) {
ch = 0;
if (cnt1[i + t] < cnt2[j + t] && i + t <= chand1[n - 1]) {
o++;
j = chand2[cnt1[i + t]];
i += t;
ch = 1;
} else if (cnt1[i + t] > cnt2[j + t] && j + t <= chand2[n - 1]) {
d++;
i = chand1[cnt2[j + t]];
j += t;
ch = 1;
}
}
if (i == chand1[n - 1] && o > d && cnt1[i] == n - 1) return o;
if (j == chand2[n - 1] && d > o && cnt2[j] == n - 1) return d;
return -1;
}
int main() {
cin >> n;
fill(cnt1, cnt1 + n + n, 1000000);
fill(cnt2, cnt2 + n + n, 1000000);
int k = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
k++;
cnt1[k] = i;
} else
cnt2[i - k + 1] = i;
chand1[i] = k;
chand2[i] = i - k + 1;
}
vector<pair<int, int> > ans;
for (int i = 1; i <= n; i++) {
int k = check(i);
if (k != -1) ans.push_back(make_pair(k, i));
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s, l, ok[100005], x[100005];
int used[100005];
vector<int> g[100005];
vector<int> gg[100005];
void dfs(int v) {
used[v] = l;
ok[l]++;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to]) {
dfs(to);
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (used[i] == 0) {
l++;
dfs(i);
}
}
cin >> s;
for (int i = 1; i <= s; i++) {
int k, q;
cin >> k >> q;
if (used[k] == used[q]) {
x[used[q]] = 1;
}
}
int ans = 0;
for (int i = 1; i <= l; i++) {
if (x[i] == 0) {
ans = max(ans, ok[i]);
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int nn, n, m, sum;
int limit[203][203];
int flow[203][203];
void maxflow() {
int i, j, delta, x;
int last[203];
bool check[203];
do {
memset(last, 0, sizeof(last));
memset(check, false, sizeof(check));
last[1] = 203;
do {
i = 0;
do {
i++;
if (i >= n || (last[i] != 0 && !check[i])) break;
} while (true);
if (i >= n) break;
for (j = 1; j < n; j++)
if (last[j] == 0)
if (flow[i][j] < limit[i][j])
last[j] = i;
else if (flow[j][i] > 0)
last[j] = -i;
check[i] = true;
} while (last[n - 1] == 0);
if (last[n - 1] == 0) break;
delta = 99999999;
i = n - 1;
do {
j = i;
if (last[j] < 0)
i = -last[j];
else
i = last[j];
if (last[j] > 0)
x = limit[i][j] - flow[i][j];
else
x = flow[j][i];
if (x < delta) delta = x;
} while (i != 1);
i = n - 1;
do {
j = i;
if (last[j] < 0)
i = -last[j];
else
i = last[j];
if (last[j] > 0)
flow[i][j] += delta;
else
flow[j][i] -= delta;
} while (i != 1);
} while (true);
}
inline bool check() {
int s;
s = 0;
for (int j = 2; j < 2 + nn; j++)
if (flow[1][j] > 0) s += flow[1][j];
if (s == sum) return true;
return false;
}
inline void print() {
for (int i = 2; i < 2 + nn; i++) {
for (int j = 2 + nn; j < 2 + (nn << 1); j++)
if (flow[i][j] > 0)
printf("%d ", flow[i][j]);
else
printf("0 ");
puts("");
}
}
inline bool build() {
int s1, s2;
s1 = s2 = 0;
memset(limit, 0, sizeof(limit));
memset(flow, 0, sizeof(flow));
scanf("%d%d", &n, &m);
nn = n;
for (int j = 2; j <= n + 1; j++) {
scanf("%d", &limit[1][j]);
s1 += limit[1][j];
limit[j][j + n] = 100;
}
n = (n << 1) + 1;
for (int i = n - nn + 1; i <= n; i++) {
scanf("%d", &limit[i][n + 1]);
s2 += limit[i][n + 1];
}
n += 2;
if (s1 != s2) return false;
sum = s1;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
limit[x + 1][y + 1 + nn] = 100;
limit[y + 1][x + 1 + nn] = 100;
}
return true;
}
int main() {
if (!build())
puts("NO");
else {
maxflow();
if (check()) {
puts("YES");
print();
} else
puts("NO");
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, counter = 0;
vector<int> U, num, dfs_num, dfs_low, vis1, vis2;
vector<vector<int> > adj, adj2, scc;
stack<int> st;
void tarjanSCC(int v) {
dfs_num[v] = dfs_low[v] = counter++;
st.push(v);
vis1[v] = vis2[v] = 1;
for (int i = 0; i < adj[v].size(); ++i) {
if (dfs_num[adj[v][i]] == -1) tarjanSCC(adj[v][i]);
if (vis1[adj[v][i]]) dfs_low[v] = min(dfs_low[v], dfs_low[adj[v][i]]);
}
if (dfs_low[v] == dfs_num[v]) {
vector<int> aux;
while (true) {
int v2 = st.top();
st.pop();
aux.push_back(v2);
vis1[v2] = 0;
if (v == v2) break;
}
scc.push_back(aux);
}
}
void solve() {
dfs_num = dfs_low = vector<int>(n, -1);
vis1 = vis2 = vector<int>(n);
for (int i = 0; i < n; ++i) {
if (!vis2[i]) tarjanSCC(i);
}
vector<int> ind(n);
for (int i = 0; i < scc.size(); ++i) {
for (int j = 0; j < scc[i].size(); ++j) {
ind[scc[i][j]] = i;
}
}
adj2 = vector<vector<int> >(scc.size());
for (int i = 0; i < n; ++i) {
for (int j = 0; j < adj[i].size(); ++j) {
if (ind[adj[i][j]] != ind[i]) {
adj2[ind[i]].push_back(ind[adj[i][j]]);
}
}
}
}
vector<int> ANS, vis;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> h;
U = vector<int>(n);
adj = vector<vector<int> >(n);
for (int i = 0; i < n; ++i) cin >> U[i];
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
if ((U[a] + 1) % h == U[b]) adj[a].push_back(b);
if ((U[b] + 1) % h == U[a]) adj[b].push_back(a);
}
solve();
vis = ANS = vector<int>(adj2.size(), -1);
int mn = 1e9;
for (int i = 0; i < adj2.size(); ++i) {
if (adj2[i].size() == 0) {
mn = min(mn, (int)scc[i].size());
}
}
cout << mn << "\n";
for (int i = 0; i < adj2.size(); ++i) {
if (adj2[i].size() == 0 && mn == scc[i].size()) {
for (int j = 0; j < scc[i].size(); ++j) {
cout << scc[i][j] + 1 << " ";
}
cout << "\n";
break;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[100001], maxi[100001];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i >= 0; i--) {
maxi[i] = max(maxi[i + 1], a[i]);
}
for (int i = 0; i < n; i++) {
cout << max(maxi[i + 1] - a[i] + 1, 0) << ' ';
}
}
| 3 |
Subsets and Splits