solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
bool check(long long a, long long b, long long n) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a;
a = a * a;
b >>= 1;
if (ret >= n) return true;
}
return false;
}
int ans[maxn][maxn];
int main() {
int n, k, d;
scanf("%d%d%d", &n, &k, &d);
if (check(min(k, n), d, n)) {
for (int i = 1; i <= d; i++) ans[i][1] = 1;
for (int i = 2; i <= n; i++) {
int c = 0;
ans[1][i] = ans[1][i - 1] + 1;
if (ans[1][i] > k) {
ans[1][i] = 1;
c = 1;
}
for (int j = 2; j <= d; j++) {
ans[j][i] = ans[j][i - 1] + c;
c = 0;
if (ans[j][i] > k) {
ans[j][i] = 1;
c = 1;
}
}
}
for (int i = 1; i <= d; i++) {
for (int j = 1; j <= n; j++) {
if (j != 1) printf(" ");
printf("%d", ans[i][j]);
}
printf("\n");
}
} else
printf("-1\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long md = 1e9 + 7;
const int sz = 200;
int n;
int a[arr];
int ans[arr][sz];
int main() {
"" != "" ? freopen(
""
".in",
"r", stdin),
freopen(
""
".out",
"w", stdout)
: 0;
"" != "" ? freopen(
""
".dat",
"r", stdin),
freopen(
""
".sol",
"w", stdout)
: 0;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = n; i >= 1; i--) {
for (int j = 1; j < sz; j++) {
ans[i][j] = i + a[i] + j > n ? 1 : ans[i + a[i] + j][j] + 1;
}
}
int q;
cin >> q;
while (q--) {
int p, k;
cin >> p >> k;
if (k >= sz) {
int ans = 0;
while (p <= n) {
p += a[p] + k;
ans++;
}
cout << ans << "\n";
} else {
cout << ans[p][k] << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int Readint() {
int ret = 0;
int f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f *= -1;
} while (ch >= 0 && (ch < '0' || ch > '9'));
while ('0' <= ch && ch <= '9') {
ret = ret * 10 + ch - '0';
ch = getchar();
}
return ret * f;
}
void open() {
freopen("C.in", "r", stdin);
freopen("C.out", "w", stdout);
}
void close() {
fclose(stdin);
fclose(stdout);
}
const int MAXN = 1010101;
int to[MAXN * 8];
int nxt[MAXN * 8];
int hd[MAXN];
int tot;
int in[MAXN];
struct node {
int id;
int val;
} a[MAXN], b[MAXN];
int mx = 0;
int fa[MAXN];
int rk[MAXN];
int col[MAXN];
int n, m;
inline void add(const int &x, const int &y) {
tot++;
to[tot] = y;
nxt[tot] = hd[x];
hd[x] = tot;
in[y]++;
}
int get_fa(int p) {
if (fa[p] == p)
return p;
else
return fa[p] = get_fa(fa[p]);
}
bool cmp(node a, node b) { return a.val < b.val; }
void init() {
n = Readint(), m = Readint();
for (int i = 1, _END_ = n * m; i <= _END_; i++) fa[i] = i;
int so;
int A, B, id;
for (int i = 1, _END_ = n; i <= _END_; i++)
for (int j = 1, _END_ = m; j <= _END_; j++) {
so = Readint();
id = A = (i - 1) * m + j;
B = (j - 1) * n + i;
a[A].id = b[B].id = id;
a[A].val = so;
b[B].val = so;
}
for (int i = 1, _END_ = n; i <= _END_; i++)
sort(a + 1 + (i - 1) * m, a + 1 + i * m, cmp);
for (int i = 1, _END_ = m; i <= _END_; i++)
sort(b + 1 + (i - 1) * n, b + 1 + i * n, cmp);
int vv, lst, now;
int fx, fy;
int tot;
for (int i = 1, _END_ = n; i <= _END_; i++) {
tot = (i - 1) * m + 1;
vv = a[tot].val;
lst = tot;
for (int j = 2, _END_ = m; j <= _END_; j++) {
tot++;
if (vv == a[tot].val) {
fx = get_fa(a[lst].id);
fy = get_fa(a[tot].id);
if (fx != fy) {
if (rk[fx] < rk[fy]) swap(fx, fy);
fa[fy] = fx;
if (rk[fx] == rk[fy]) rk[fx]++;
}
} else {
lst = tot;
vv = a[tot].val;
}
}
}
for (int i = 1, _END_ = m; i <= _END_; i++) {
tot = (i - 1) * n + 1;
vv = b[tot].val;
lst = tot;
for (int j = 2, _END_ = n; j <= _END_; j++) {
tot++;
if (vv == b[tot].val) {
fx = get_fa(b[lst].id);
fy = get_fa(b[tot].id);
if (fx != fy) {
if (rk[fx] < rk[fy]) swap(fx, fy);
fa[fy] = fx;
if (rk[fx] == rk[fy]) rk[fx]++;
}
} else {
lst = tot;
vv = b[tot].val;
}
}
}
for (int i = 1, _END_ = n; i <= _END_; i++) {
tot = (i - 1) * m + 1;
vv = a[tot].val;
lst = get_fa(a[tot].id);
for (int j = 2, _END_ = m; j <= _END_; j++) {
tot++;
if (vv != a[tot].val) {
now = get_fa(a[tot].id);
add(lst, now);
lst = now;
vv = a[tot].val;
}
}
}
for (int i = 1, _END_ = m; i <= _END_; i++) {
tot = (i - 1) * n + 1;
vv = b[tot].val;
lst = get_fa(b[tot].id);
for (int j = 2, _END_ = n; j <= _END_; j++) {
tot++;
if (vv != b[tot].val) {
now = get_fa(b[tot].id);
add(lst, now);
lst = now;
vv = b[tot].val;
}
}
}
}
int que[MAXN];
void top() {
int l = 0, r = 0;
mx++;
for (int i = 1, _END_ = n * m; i <= _END_; i++)
if (fa[i] == i && (!in[i])) {
que[r++] = i;
col[i] = mx;
}
int now;
while (l < r) {
now = que[l++];
for (int i = hd[now]; i; i = nxt[i]) {
in[to[i]]--;
if (!in[to[i]]) {
col[to[i]] = col[now] + 1;
que[r++] = to[i];
}
}
}
}
void output() {
int now = 0;
for (int i = 1, _END_ = n; i <= _END_; i++) {
for (int j = 1, _END_ = m; j <= _END_; j++) {
now++;
printf("%d ", col[get_fa(now)]);
}
printf("\n");
}
}
int main() {
int _ = 0;
init();
top();
output();
close();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
;
long long int n;
cin >> n;
long long int a[n], pos = 0, neg = 0, zero = 0, ma = -mod, idx = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] >= 0) a[i] = -a[i] - 1;
if (abs(a[i]) > ma) {
ma = abs(a[i]);
idx = i;
}
}
if (n % 2 == 1) {
a[idx] = -a[idx] - 1;
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
bool c = 1;
while (1) {
if (c) {
int t = min(x, 2) * 100;
int z = (220 - t) / 10;
x -= t / 100;
if (y < z) {
cout << "Hanako" << endl;
return 0;
}
y -= z;
} else {
int z;
if (y >= 22)
z = 220;
else if (y >= 12)
z = 120;
else if (y >= 2)
z = 20;
else {
cout << "Ciel" << endl;
return 0;
}
int t = (220 - z) / 100;
y -= z / 10;
if (x < t) {
cout << "Ciel" << endl;
return 0;
}
x -= t;
}
c = !c;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3100;
struct poi {
int x, y, id;
} a[N], b[N], po[N];
int ne[N], pre[N], r, c, n, m;
long long res, ans = 0;
bool cmp(poi x, poi y) { return x.y < y.y; }
void del(int id) {
int i, j, k;
j = id;
for (i = 1; ((i < m) && (pre[j])); i++, j = pre[j])
;
k = j;
for (i = 1; i < m; i++) k = ne[k];
while ((k) && (j != ne[id]) && (k != n + 1)) {
res -= (long long)(b[j].x - b[pre[j]].x) * (long long)(b[ne[k]].x - b[k].x);
j = ne[j];
k = ne[k];
}
ne[pre[id]] = ne[id];
pre[ne[id]] = pre[id];
ne[0] = pre[0] = 0;
}
int main() {
int i, j, k, p, top;
scanf("%d%d%d%d", &r, &c, &n, &m);
for (i = 1; i <= n; i++) scanf("%d%d", &po[i].x, &po[i].y);
sort(po + 1, po + n + 1, cmp);
for (i = 1; i <= n; i++) po[i].id = i;
ans = 0;
p = n + 1;
top = 0;
for (i = c; i; i--) {
while ((p > 1) && (po[p - 1].y == i)) {
p--;
for (j = 1; j <= top; j++)
if (a[j].x >= po[p].x) {
for (k = top; k >= j; k--) a[k + 1] = a[k];
a[j] = po[p];
break;
}
if (j == top + 1) a[top + 1] = po[p];
top++;
}
res = 0;
a[top + 1].id = n + 1;
a[top + 1].x = r + 1;
for (j = 1; j <= top + 1; j++) b[a[j].id] = a[j];
for (j = 1; j <= top + 1; j++)
pre[a[j].id] = a[j - 1].id, ne[a[j].id] = a[j + 1].id;
k = a[1].id;
for (j = 1; j < m; j++) k = ne[k];
j = a[1].id;
while (k) {
res += (long long)(r - b[k].x + 1) * (long long)(b[j].x - b[pre[j]].x);
j = ne[j];
k = ne[k];
}
ans += res;
k = n + 1;
for (j = c; j > i; j--) {
while (po[k - 1].y == j) k--, del(k);
ans += res;
}
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long LLINF = 1e18;
const int INF = 1e9;
const double EPS = 1e-7;
inline const int &INT() {
static int x;
scanf("%d", &x);
return x;
}
inline const long long &LONG() {
static long long x;
scanf("%lld", &x);
return x;
}
template <class T>
inline void MIN(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
inline void MAX(T &a, const T &b) {
if (b > a) a = b;
}
const int NN = 105;
int M, N, K, grid[NN][NN], f[NN], tmp[NN];
int main() {
M = INT();
N = INT();
K = INT();
for (int i = 0; i < (M); ++i)
for (int j = 0; j < (N); ++j) grid[i][j] = INT();
if (M <= 10) {
for (int j = 0; j < (N); ++j) {
tmp[j] = 0;
for (int i = 0; i < (M); ++i) tmp[j] ^= (grid[i][j] << i);
}
int ans = INF;
int MASK = (1 << M);
for (int mask = 0; mask < (MASK); ++mask) {
int nmask = (mask ^ (MASK - 1));
f[0] = 0;
for (int j = 0; j < (N); ++j) {
f[j + 1] = INF;
int t = INF;
MIN(t, (__builtin_popcount(tmp[j] ^ mask)));
MIN(t, (__builtin_popcount(tmp[j] ^ nmask)));
MIN(f[j + 1], f[j] + t);
}
MIN(ans, f[N]);
}
if (ans > K)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
int ans = INF;
for (int i = 0; i < (M); ++i) {
int sum = 0;
for (int j = 0; j < (M); ++j) {
int cnt[2] = {0, 0};
for (int k = 0; k < (N); ++k) ++cnt[grid[i][k] ^ grid[j][k]];
int t = min(cnt[0], cnt[1]);
sum += t;
}
MIN(ans, sum);
}
if (ans <= K)
cout << ans << endl;
else
cout << -1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int maxn[250000][21];
vector<int> ans[150000];
int b[150000];
int c[150000];
int a[150000];
int vis[150000];
void Lisanhua() {
int cnt = 1;
map<int, int> s;
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), c[i] = b[i];
sort(c + 1, c + 1 + n);
for (int i = 1; i <= n; i++) {
if (s[c[i]] == 0) s[c[i]] = cnt++;
}
for (int i = 1; i <= n; i++) {
a[i] = s[b[i]];
}
}
int main() {
while (~scanf("%d", &n)) {
int cnt = 0;
Lisanhua();
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) ans[i].clear();
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
int x = i;
while (vis[a[x]] == 0) {
vis[a[x]] = 1;
ans[cnt].push_back(a[x]);
x = a[x];
}
cnt++;
}
}
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++) {
printf("%d ", ans[i].size());
for (int j = 0; j < ans[i].size(); j++) {
printf("%d ", ans[i][j]);
}
printf("\n");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
[[maybe_unused]] const int MOD = 1000000007;
[[maybe_unused]] const int INTMAX = numeric_limits<int>::max();
void writeln() { cout << "\n"; }
template <class T>
inline void print(T&& a);
template <class T>
inline void priws(T&& a);
template <class T>
inline void read(T& a);
template <class... Args>
inline void readln(Args&... args) {
(read(args), ...);
}
template <class H, class... T>
inline void writeln(H&& h, T&&... t) {
priws(h);
(print(t), ...);
writeln();
}
void run() {
int m = 27;
int n;
readln(n);
vector<int> a(n);
readln(a);
vector<vector<int>> c(n + 1, vector<int>(m, 0));
vector<vector<int>> d(n + 1, vector<int>(m, 0));
vector<vector<int>> counts(m + 1, vector<int>(n + 1, n));
for (int i = 0; i < (int)(n); ++i) c[i + 1] = c[i], c[i + 1][a[i]]++;
for (int i = n - 1; i >= (int)(0); --i)
d[i] = d[i + 1], counts[a[i]][++d[i][a[i]]] = i;
int ans = 0;
for (int left = 0; left < (int)(n); ++left)
for (int j = 1; j < (int)(m); ++j)
if (int x = c[left][j], right = counts[j][x]; right > left) {
int temp = 0;
for (int k = 1; k < (int)(m); ++k)
temp = max(temp, c[right][k] - c[left][k]);
ans = max(ans, x * 2 + temp);
}
writeln(ans);
}
int main() {
ios_base::sync_with_stdio(false);
int t;
readln(t);
for (int i = 0; i < (int)(t); ++i) run();
cerr << fixed << setprecision(0)
<< "Execution time = " << 1000.0 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
template <class T1, class T2>
inline ostream& operator<<(ostream& os, pair<T1, T2> const& _a);
template <
typename T, typename D = decltype(*begin(declval<T>())),
typename enable_if<!is_same<T, basic_string<char>>::value>::type* = nullptr>
ostream& operator<<(ostream& os, T const& _a) {
auto it = begin(_a);
if (it != end(_a)) os << *it++;
while (it != end(_a))
os << "\n "[is_fundamental<typename T::value_type>::value] << *it++;
return os;
}
template <class T1, class T2>
inline ostream& operator<<(ostream& os, pair<T1, T2> const& _a) {
return os << _a.first << " " << _a.second;
}
template <class T1, class T2>
inline istream& operator>>(istream& is, pair<T1, T2>& _a) {
return is >> _a.first >> _a.second;
}
template <class T>
inline istream& operator>>(istream& is, vector<T>& _a) {
for (int i = 0; i < (int)(_a.size()); ++i) is >> _a[i];
return is;
}
template <class T>
inline void print(T&& _a) {
cout << " " << _a;
}
template <class T>
inline void priws(T&& _a) {
cout << _a;
}
template <class T>
inline void read(T& _a) {
cin >> _a;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void scan_arr1(long long int arr[], long long int n, long long int start = 0) {
for (long long int i = start; i < n + start; i++) cin >> arr[i];
}
void scan_arr2(long long int arr[1010][1010], long long int n, long long int m,
long long int start = 0) {
for (long long int i = start; i < n + start; i++)
for (long long int j = start; j < m + start; j++) cin >> arr[i][j];
}
void print_arr1(long long int arr[], long long int n, long long int start = 0) {
for (long long int i = start; i < n + start; i++) cout << arr[i] << " ";
cout << "\n";
}
void print_arr2(long long int arr[1010][1010], long long int n, long long int m,
long long int start = 0) {
for (long long int i = start; i < n + start; i++) {
for (long long int j = start; j < m + start; j++) cout << arr[i][j] << " ";
cout << "\n";
}
}
int main() {
long long int t, n, i, j, k;
cin >> t;
while (t--) {
string s;
cin >> s;
n = s.length();
long long int res = -1, cnt = 0;
for (i = 0; i < 10; i++)
for (j = 0; j < 10; j++) {
bool f = 0;
cnt = 0;
for (k = 0; k < n; k++) {
if (f == 0 && (s[k] - '0') == i) {
cnt++;
f = 1;
} else if (f == 1 && (s[k] - '0') == j) {
cnt++;
f = 0;
}
}
if (cnt % 2 && i != j) cnt--;
res = max(res, cnt);
}
n -= res;
cout << n << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 2e3 + 10;
bitset<sz> ma[sz];
int main() {
int n, k;
cin >> n >> k;
int va[n * 2];
for (int a = 0; a < n * 2; a++) {
if (a & 1)
va[a] = 2;
else
va[a] = 1;
}
for (int a = 0; a < k; a++) {
string ty;
cin >> ty;
if (ty == "mix") {
int q;
cin >> q;
bitset<sz> r[2];
for (int b = 0; b < q; b++) {
int i;
scanf("%d", &i);
i--;
if (va[i * 2] & 1) r[0][i * 2] = 1;
if (va[i * 2] & 2) r[0][i * 2 + 1] = 1;
if (va[i * 2 + 1] & 1) r[1][i * 2] = 1;
if (va[i * 2 + 1] & 2) r[1][i * 2 + 1] = 1;
}
char sy;
cin >> sy;
if (sy == 'R') r[0][n * 2] = 1;
if (sy == 'Y') r[1][n * 2] = 1;
if (sy == 'B') r[0][n * 2] = 1, r[1][n * 2] = 1;
for (int b = 0; b < 2; b++) {
bool ins = 0;
for (int i = 0; i < n * 2; i++) {
if (r[b][i]) {
if (ma[i][i])
r[b] ^= ma[i];
else {
ma[i] = r[b], ins = 1;
break;
}
}
}
if (!ins and r[b][n * 2]) {
cout << "NO";
return 0;
}
}
} else {
int q;
cin >> q;
for (int b = 0; b < q; b++) {
int i;
scanf("%d", &i);
i--;
int x1 = va[i * 2], x2 = va[i * 2 + 1];
if (ty == "RY") {
va[i * 2] = x2, va[i * 2 + 1] = x1;
}
if (ty == "RB") {
va[i * 2] = x1, va[i * 2 + 1] = x1 ^ x2;
}
if (ty == "YB") {
va[i * 2] = x1 ^ x2, va[i * 2 + 1] = x2;
}
}
}
}
int an[n * 2];
for (int a = n * 2 - 1; a >= 0; a--) {
if (ma[a][a]) {
an[a] = ma[a][n * 2];
for (int b = a - 1; b >= 0; b--)
if (ma[b][a]) ma[b] ^= ma[a];
} else
an[a] = 0;
}
cout << "YES\n";
for (int a = 0; a < n * 2; a += 2) {
int i = an[a] + (an[a + 1] << 1);
if (i == 0) cout << '.';
if (i == 1) cout << 'R';
if (i == 2) cout << 'Y';
if (i == 3) cout << 'B';
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a(3);
int t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> a[0] >> a[1] >> a[2];
sort(a.begin(), a.end());
if (a[0] + a[1] >= a[2] - 1)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, cnt = 0;
char c;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c;
if (c == '8') cnt++;
}
cout << min(cnt, (n - (n / 10)) / 10) << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, in = 2;
long long suma, bit[1000000];
double x, y, w, ab[100003];
pair<double, double> ar[100004];
map<double, int> busca;
void updt(int p) {
for (int i = p; i <= n; i += (i & -i)) bit[i]++;
}
int query(int p) {
int s = 0;
for (int i = p; i > 0; i -= (i & -i)) s += bit[i];
return s;
}
bool op(pair<double, double> f, pair<double, double> g) {
if (f.first != g.first) return f.first < g.first;
return f.second > g.second;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> w;
for (int i = 0; i < n; i++) {
cin >> x >> y;
ar[i] = make_pair(-(x / (y - w)), -(x / (y + w)));
ab[i] = ar[i].second;
}
sort(ar, ar + n, op);
sort(ab, ab + n);
busca[ab[0]] = 1;
for (int i = 1; i < n; i++)
if (ab[i] != ab[i - 1]) busca[ab[i]] = in++;
for (int i = 0; i < n; i++) {
in = busca[ar[i].second];
suma += query(n - in + 1);
updt(n - in + 1);
}
cout << suma;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long powmod(long long a, long long b) {
long long res = 1;
if (a >= mod) a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= mod) res %= mod;
a = a * a;
if (a >= mod) a %= mod;
}
return res;
}
long long temp;
int main() {
int n;
cin >> n;
vector<long long> g1;
for (long long i = (long long)(0); i < (long long)(n); i++) {
long long x;
cin >> x;
g1.push_back(x);
}
sort(g1.begin(), g1.end());
if (g1[n - 1] >= g1[0] + g1[n - 2]) swap(g1[n - 1], g1[n - 2]);
if (g1[n - 2] >= g1[n - 3] + g1[n - 1]) {
cout << "NO";
} else {
cout << "YES" << '\n';
for (int pp : g1) cout << pp << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr[7];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 7; j++) {
cin >> arr[j];
}
cout << arr[0] << " " << arr[1] << " "
<< ((arr[0] + arr[1] == arr[2]) ? arr[3] : arr[2]) << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int r[2] = {-1, -1};
for (int i = 0; i < n; i++) {
int j = i + 1;
while (j < n && a[j] == a[i]) {
j++;
}
if (r[a[i]] == -1) {
r[a[i]] = j - i;
} else {
if (r[a[i]] != j - i) {
cout << "NO";
return 0;
}
}
i = j - 1;
}
if (r[0] != r[1] && r[0] != -1 && r[1] != -1) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long arr[3];
scanf("%I64d%I64d%I64d", &arr[0], &arr[1], &arr[2]);
sort(arr, arr + 3);
if (2 * (arr[0] + arr[1]) <= arr[2]) {
printf("%I64d\n", arr[0] + arr[1]);
} else {
printf("%I64d\n", (arr[0] + arr[1] + arr[2]) / 3);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9, mod = 998244353;
int fp(int b, int p) {
if (p == 0) return 1;
int ans = fp(1LL * b * b % mod, p / 2);
return p % 2 ? 1LL * ans * b % mod : ans;
}
int n, a[N];
int mu[N];
bool prime[N];
void preprocess() {
for (int i = 1; i <= 1e5; i++) {
mu[i] = 1;
prime[i] = true;
}
for (int i = 2; i <= 1e5; i++)
if (prime[i]) {
for (int j = i; j <= 1e5; j += i) {
mu[j] = -mu[j];
if ((j / i) % i == 0) mu[j] = 0;
prime[j] = false;
}
}
}
long long solve(int g) {
long long T = 0, S = 0, Sq = 0;
for (int i = g; i <= 1e5; i += g) {
T += a[i];
S = (S + 1LL * i * a[i]) % mod;
Sq = (Sq + 1LL * i * i % mod * a[i]) % mod;
}
S = S * S % mod;
long long AB =
(S - Sq) * (T % mod) % mod * fp(2, (T - 3 + mod - 1) % (mod - 1)) % mod;
long long AA =
Sq * ((T - 1) % mod) % mod * fp(2, (T - 2 + mod - 1) % (mod - 1)) % mod;
return (AA + AB + 2LL * mod) % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
preprocess();
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
a[x] = y;
}
long long ans = 0;
for (int i = 1; i <= 1e5; i++) {
if (!mu[i]) continue;
ans = (ans + solve(i) * mu[i] + mod) % mod;
}
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
const int N = 2010;
long long dp[N][N];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
dp[1][0] = m;
for (int i = 2; i <= n; i++) {
for (int j = 0; j < i; j++) {
if (!j) {
dp[i][j] = dp[i - 1][j];
} else {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1] * (m - 1) % p) % p;
}
}
}
printf("%lld", dp[n][k]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string toStr(const T &x) {
stringstream s;
s << x;
return s.str();
}
template <class T>
int toInt(const T &x) {
stringstream s;
s << x;
int r;
s >> r;
return r;
}
const double pi = acos(-1);
const double Pi2 = acos(0);
struct point {
double x, y;
point() {}
point(double X, double Y) : x(X), y(Y) {}
point sub(point a) { return point(x - a.x, y - a.y); }
point add(point a) { return point(x + a.x, y + a.y); }
double cross(point a) { return x * a.y - y * a.x; }
point multbyscalar(double ua) { return point(ua * x, ua * y); }
};
int main() {
int cables;
cin >> cables;
vector<int> cuantos(cables);
for (int i = 0; i < cables; ++i) cin >> cuantos[i];
int tiros;
cin >> tiros;
for (int i = 0; i < tiros; ++i) {
int x, y;
cin >> x >> y;
x--;
if (x > 0) {
cuantos[x - 1] += y - 1;
}
if (x < cables - 1) {
cuantos[x + 1] += cuantos[x] - y;
}
cuantos[x] = 0;
}
for (int i = 0; i < cables; ++i) {
cout << cuantos[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long z, dis[1000000], Dis[1000000];
int u, v, w, x, y, tot, from[1000000], to[1000000];
int nex[1000000], head[1000000], fu[1000000];
int n, m, son, k, dep[1000000], f[300000][30], lg[1000000], t;
void add(int u, int v, long long w) {
tot++;
from[tot] = u;
to[tot] = v;
dis[tot] = w;
nex[tot] = head[u];
head[u] = tot;
}
int find(int x) {
if (fu[x] != x)
return fu[x] = find(fu[x]);
else
return x;
}
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
f[u][0] = fa;
for (int i = 1; i <= lg[dep[u]]; i++) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = head[u]; i; i = nex[i]) {
int v = to[i];
long long w = dis[i];
if (v != fa) {
if (w == 1) fu[v] = find(u);
Dis[v] = w;
dfs(v, u);
}
}
}
long long lca(int a, int b) {
if (dep[a] > dep[b]) swap(a, b);
while (dep[b] > dep[a]) b = f[b][lg[dep[b] - dep[a]]];
if (a == b) return a;
for (int i = lg[dep[a]]; i >= 0; i--)
if (f[a][i] != f[b][i]) {
a = f[a][i];
b = f[b][i];
}
return f[a][0];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) fu[i] = i;
for (int i = 1; i <= n; i++) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
for (int i = 1; i <= n; i++) lg[i]--;
for (int i = 1; i < n; i++) {
scanf("%d%d%lld", &x, &y, &z);
add(x, y, z);
add(y, x, z);
}
dfs(1, 0);
for (int i = 1; i <= m; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d%d%lld", &x, &y, &z);
int Lca = lca(x, y);
while (dep[x] > dep[Lca] && z) {
z /= Dis[x];
x = find(f[x][0]);
}
while (dep[y] > dep[Lca] && z) {
z /= Dis[y];
y = find(f[y][0]);
}
printf("%lld\n", z);
} else {
scanf("%d%lld", &k, &z);
int u = from[k << 1], v = to[k << 1];
if (f[u][0] == v)
son = u;
else
son = v;
Dis[son] = z;
if (Dis[son] == 1) fu[son] = find(f[son][0]);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n, no = 0, o, s, prevlim = (1000 * 1000 * 1000 + 5), c = 0, x, t, i;
stack<int> st;
int prev = 1;
cin >> n;
for (i = 0; i < n; i++) {
cin >> t;
if (t == 1 || t == 3) {
cin >> x;
}
if (t == 1) {
while (!st.empty() && st.top() < x) {
st.pop();
c++;
}
s = x;
}
if (t == 3) {
if (s > x) {
c++;
prev = 1;
} else {
st.push(x);
prev = 0;
}
}
if (t == 2) {
c += no;
no = 0;
}
if (t == 6) {
no++;
}
if (t == 4) {
no = 0;
}
if (t == 5) {
while (!st.empty()) {
st.pop();
}
prevlim = (1000 * 1000 * 1000 + 5);
}
}
cout << c << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e7 + 10;
map<long long, long long> mp, mmp;
map<long long, long long>::iterator iter1, iter2;
int a[N], m, n, sum[N], tp;
int main() {
int n, m;
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] == m) tp = i;
}
sum[tp] = 0;
mmp[0]++;
mp[0]++;
for (int i = tp - 1; i > 0; --i) {
if (a[i] > m)
sum[i] = sum[i + 1] + 1;
else if (a[i] < m)
sum[i] = sum[i + 1] - 1;
else
sum[i] = sum[i + 1];
mp[sum[i]]++;
}
for (int i = tp + 1; i <= n; ++i) {
if (a[i] > m)
sum[i] = sum[i - 1] + 1;
else if (a[i] < m)
sum[i] = sum[i - 1] - 1;
else
sum[i] = sum[i - 1];
mmp[sum[i]]++;
}
int cnt;
long long ans = 0;
if (mp.size() < mmp.size()) {
for (iter1 = mp.begin(); iter1 != mp.end(); iter1++) {
cnt = iter1->first;
cnt *= (-1);
ans += (mmp[cnt] * iter1->second);
ans += (mmp[cnt + 1] * iter1->second);
}
} else {
for (iter1 = mmp.begin(); iter1 != mmp.end(); iter1++) {
cnt = iter1->first;
cnt *= (-1);
ans += (mp[cnt] * iter1->second);
ans += (mp[cnt + 1] * iter1->second);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int c = 256;
const int cc = 64;
int n, m, k;
bool b;
bool a[c][cc];
int nk, nb;
char s[c];
int p;
int main() {
scanf("%d%d%d", &n, &m, &k);
char h;
do h = getchar();
while (h != '\n');
gets(s);
if (string(s) == "to head")
nb = -1;
else
nb = 1;
gets(s);
p = strlen(s);
int i, j, o;
memset(a, 0, sizeof(a));
nk = k;
a[0][m] = 1;
bool ok;
for (i = 1; i <= p; ++i) {
ok = 0;
for (j = 1; j <= n; ++j)
if (a[i - 1][j]) {
ok = 1;
if (s[i - 1] == '0') {
if (j > 1 && j - 1 != nk) a[i][j - 1] = 1;
if (j != nk) a[i][j] = 1;
if (j < n && j + 1 != nk) a[i][j + 1] = 1;
} else {
for (o = 1; o <= n; ++o) a[i][o] = 1;
}
}
nk += nb;
if (nk == 1 || nk == n) nb = -nb;
if (a[i][nk]) {
a[i][nk] = 0;
}
if (!ok) break;
}
if (i <= p)
printf("Controller %d\n", i - 1);
else
printf("Stowaway\n");
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int t; cin>>t;
while(t--)
{
int n; cin>>n;
vector<int> v(n);
int mn=INT_MAX, pos=-1;
for(int i=0; i<n; i++)
{
cin>>v[i];
if(v[i]<mn)
mn=v[i], pos=i+1;
}
int c=mn+1;
if(pos==1)
{
cout<<n-1<<"\n";
for(int i=2; i<=n; i++)
{
cout<<1<<" "<<i<<" "<<mn<<" "<<c++<<"\n";
}
}
else
{
cout<<n<<"\n";
cout<<1<<" "<<pos<<" "<<mn<<" "<<c<<"\n";
for(int i=2; i<=n; i++)
{
cout<<1<<" "<<i<<" "<<mn<<" "<<c++<<"\n";
}
}
}
return 0;
} | 2 |
#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define INF 1000000000
#define LINF 1000000000000000000
#define MOD 1000000007
#define mod 998244353
#define INF63 1061109567
#define INF127 9187201950435737471
#define UINF 18446744073709551615
#define F first
#define S second
#define ll long long
#define N 510
using namespace std;
ll n,m,a[N][N],num[20];
int main(){
ll i,j;
scanf("%lld%lld",&n,&m);
for(i=0;i<20;i++)
{
num[i]=16*9*5*7*11*13-i*i*i*i;
}
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
scanf("%lld",&a[i][j]);
if(i%2!=j%2)
{
a[i][j]=0;
}
}
}
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
printf("%lld ",num[a[i][j]]);
}
puts("");
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
char given[110], pattern[110];
int failure[110];
void compute_prefix(void) {
int m = strlen(pattern), k = -1;
failure[0] = 0;
for (int q = 1; q < m; q++) {
while (k >= 0 && pattern[k + 1] != pattern[q]) k = failure[k] - 1;
if (pattern[k + 1] == pattern[q]) k++;
failure[q] = k + 1;
}
}
void kmp_matcher(void) {
int n = strlen(given), m = strlen(pattern), q = -1;
compute_prefix();
for (int i = 0; i < n; i++) {
while (q >= 0 && pattern[q + 1] != given[i]) q = failure[q] - 1;
if (pattern[q + 1] == given[i]) q++;
if (q == m - 1) {
printf("%d\n", i - m + 1);
q = failure[q] - 1;
}
}
}
int lenN, lenX, lenY;
char strY[110], strX[110];
char strN[110];
int match[110][30];
int dp[110][110][110];
pair<int, pair<int, int> > myback[110][110][110];
inline void ReadInput(void) {
scanf("%s", strX);
scanf("%s", strY);
scanf("%s", strN);
}
inline void solve(void) {
lenN = strlen(strN);
lenX = strlen(strX);
lenY = strlen(strY);
for (int i = 0; i <= lenN; i++) {
for (int j = 0; j < 26; j++) {
pattern[i] = 'A' + j;
pattern[i + 1] = '\0';
compute_prefix();
match[i][j] = failure[i];
}
pattern[i] = strN[i];
}
for (int i = 0; i < 110; i++) {
for (int j = 0; j < 110; j++) {
for (int k = 0; k < 110; k++)
myback[i][j][k] =
pair<int, pair<int, int> >(-1, pair<int, int>(-1, -1));
}
}
if (strX[0] == strY[0] and strX[0] == strN[0]) {
dp[0][0][1] = 1;
myback[0][0][1] = pair<int, pair<int, int> >(-1, pair<int, int>(-1, -1));
} else if (strX[0] == strY[0]) {
dp[0][0][0] = 1;
myback[0][0][0] = pair<int, pair<int, int> >(-1, pair<int, int>(-1, -1));
}
for (int i = 1; i < lenX; i++) {
if (strY[0] == strX[i]) {
if (strN[0] == strY[0]) {
dp[i][0][1] = 1;
myback[i][0][1] =
pair<int, pair<int, int> >(-1, pair<int, int>(-1, -1));
} else {
dp[i][0][0] = 1;
myback[i][0][0] =
pair<int, pair<int, int> >(-1, pair<int, int>(-1, -1));
}
} else {
dp[i][0][1] = dp[i - 1][0][1];
dp[i][0][0] = dp[i - 1][0][0];
myback[i][0][1] = pair<int, pair<int, int> >(1, pair<int, int>(i - 1, 0));
myback[i][0][0] = pair<int, pair<int, int> >(0, pair<int, int>(i - 1, 0));
}
}
for (int i = 1; i < lenY; i++) {
if (strX[0] == strY[i]) {
if (strN[0] == strX[0]) {
dp[0][i][1] = 1;
myback[0][i][1] =
pair<int, pair<int, int> >(-1, pair<int, int>(-1, -1));
} else {
myback[0][i][0] =
pair<int, pair<int, int> >(-1, pair<int, int>(-1, -1));
dp[0][i][0] = 1;
}
} else {
dp[0][i][1] = dp[0][i - 1][1];
dp[0][i][0] = dp[0][i - 1][0];
myback[0][i][1] = pair<int, pair<int, int> >(1, pair<int, int>(0, i - 1));
myback[0][i][0] = pair<int, pair<int, int> >(0, pair<int, int>(0, i - 1));
}
}
for (int i = 1; i < lenX; i++) {
for (int j = 1; j < lenY; j++) {
for (int k = 0; k < lenN; k++) {
if (strX[i] != strY[j]) {
if (dp[i][j - 1][k] > dp[i - 1][j][k])
myback[i][j][k] =
pair<int, pair<int, int> >(k, pair<int, int>(i, j - 1));
else
myback[i][j][k] =
pair<int, pair<int, int> >(k, pair<int, int>(i - 1, j));
dp[i][j][k] = max(dp[i][j][k], max(dp[i][j - 1][k], dp[i - 1][j][k]));
} else {
if (dp[i][j][k] < max(dp[i][j - 1][k], dp[i - 1][j][k])) {
if (dp[i][j - 1][k] > dp[i - 1][j][k])
myback[i][j][k] =
pair<int, pair<int, int> >(k, pair<int, int>(i, j - 1));
else
myback[i][j][k] =
pair<int, pair<int, int> >(k, pair<int, int>(i - 1, j));
}
dp[i][j][k] = max(dp[i][j][k], max(dp[i][j - 1][k], dp[i - 1][j][k]));
if (k != lenN - 1 and strX[i] == strN[k] and
dp[i - 1][j - 1][k] >= k) {
if (dp[i][j][k + 1] < dp[i - 1][j - 1][k] + 1)
myback[i][j][k + 1] =
pair<int, pair<int, int> >(k, pair<int, int>(i - 1, j - 1));
dp[i][j][k + 1] = max(dp[i][j][k + 1], dp[i - 1][j - 1][k] + 1);
}
if (strX[i] != strN[k] and dp[i - 1][j - 1][k] >= k) {
if (dp[i][j][match[k][strX[i] - 'A']] < dp[i - 1][j - 1][k] + 1)
myback[i][j][match[k][strX[i] - 'A']] =
pair<int, pair<int, int> >(k, pair<int, int>(i - 1, j - 1));
dp[i][j][match[k][strX[i] - 'A']] =
max(dp[i][j][match[k][strX[i] - 'A']], dp[i - 1][j - 1][k] + 1);
}
if (dp[i - 1][j - 1][k] >= k) {
if (dp[i][j][k] < dp[i - 1][j - 1][k])
myback[i][j][k] =
pair<int, pair<int, int> >(k, pair<int, int>(i - 1, j - 1));
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - 1][k]);
}
}
}
}
}
int ans = 0, pos = -1;
for (int i = 0; i < lenN; i++) {
if (dp[lenX - 1][lenY - 1][i] > ans) pos = i;
ans = max(ans, dp[lenX - 1][lenY - 1][i]);
}
if (ans == 0) {
cout << 0;
return;
}
stack<char> myans;
int posi = lenX - 1, posj = lenY - 1;
while (1) {
if (myback[posi][posj][pos] ==
pair<int, pair<int, int> >(-1, pair<int, int>(-1, -1)) and
dp[posi][posj][pos] == 0)
break;
else if (myback[posi][posj][pos] ==
pair<int, pair<int, int> >(-1, pair<int, int>(-1, -1))) {
myans.push(strX[posi]);
break;
} else if (dp[posi][posj][pos] > dp[myback[posi][posj][pos].second.first]
[myback[posi][posj][pos].second.second]
[myback[posi][posj][pos].first]) {
myans.push(strX[posi]);
}
int a, b, c;
a = posi;
b = posj;
c = pos;
posi = myback[a][b][c].second.first;
posj = myback[a][b][c].second.second;
pos = myback[a][b][c].first;
}
while (!myans.empty()) {
cout << myans.top();
myans.pop();
}
}
inline void Refresh(void) {}
int main() {
ReadInput();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
char S[8][9];
long N[8];
bool in[8];
const long mi[10] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000};
long maxx, minx, ans = ~0U >> 1;
long n, m;
inline void upmin(long &x, const long y) {
if (y < x) x = y;
}
inline void upmax(long &x, const long y) {
if (x < y) x = y;
}
inline void calc() {
maxx = 0, minx = ~0U >> 1;
for (register long ii = 0; ii < n; ++ii)
upmax(maxx, N[ii]), upmin(minx, N[ii]);
upmin(ans, maxx - minx);
}
void dfs(const long wh) {
if (wh == m) {
calc();
return;
}
for (long ii = 0; ii < m; ++ii)
if (!in[ii]) {
in[ii] = 1;
for (long jj = 0; jj < n; ++jj) N[jj] += (S[jj][wh] - '0') * mi[ii];
dfs(wh + 1);
for (long jj = 0; jj < n; ++jj) N[jj] -= (S[jj][wh] - '0') * mi[ii];
in[ii] = 0;
}
}
int main() {
scanf("%ld%ld", &n, &m);
for (long i = 0; i < n; ++i) scanf("%s", S[i]);
dfs(0);
printf("%ld\n", ans);
scanf("%ld%ld", &n, &m);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void O_o() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
int main() {
O_o();
int x, y;
bool flag;
vector<int> vec;
cin >> x;
y = x;
while (x != 0) {
vec.push_back(x % 10);
x = x / 10;
}
for (int i = 0; i < vec.size(); i++) {
if (vec[i] == 4 || vec[i] == 7)
flag = 1;
else {
flag = 0;
break;
}
}
if (flag)
cout << "YES";
else if (y % 7 == 0 || y % 4 == 0 || y % 47 == 0 || y % 74 == 0 ||
y % 474 == 0 || y % 477 == 0 || y % 747 == 0 || y % 774 == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int oo = 1e9 + 4;
const int SZ = 2e5 + 4;
int q, n;
void read() { cin >> q; }
void solve() {
while (q--) {
cin >> n;
vector<pii> o(n);
vector<pair<int, pii> > h;
int i = 0;
for (auto &t : o) {
cin >> t.first >> t.second;
h.push_back({t.first, {0, i}});
h.push_back({t.second, {1, i}});
i++;
}
sort(h.begin(), h.end());
set<int> in;
vector<int> cnt(n, 0);
vector<int> num(n, -oo);
vector<bool> tic(n, 0);
int last = 0, k0 = 0;
i = 0;
for (auto t : h) {
if (!t.second.first) {
if (in.size() == 1) {
int v = *in.begin();
if (last) cnt[v]++;
}
in.insert(t.second.second);
num[t.second.second] = i;
} else {
in.erase(t.second.second);
if (num[t.second.second] == i - 1) tic[t.second.second] = 1;
}
i++;
last = t.second.first;
k0 += in.empty();
}
int mx = -oo;
for (int i = 0; i < n; i++) mx = max(mx, cnt[i] - (tic[i] && k0 > 1));
cout << k0 + mx << endl;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
read();
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5, maxk = 100 + 5;
double dp[maxk][maxn];
int a[maxn], su, n, m, h;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> h, h--, n--;
for (int i = 0; i < m; i++) cin >> a[i], su += a[i];
a[h]--;
su--;
if (su < n) {
cout << -1 << endl;
return 0;
}
if (su - a[h] < n) {
cout << 1 << endl;
return 0;
}
dp[0][0] = 1;
for (int i = 0; i <= n; i++)
for (int j = 0; j < su; j++) {
double p = double(n - i) / double(su - j);
dp[i + 0][j + 1] += dp[i][j] * (1 - p);
dp[i + 1][j + 1] += dp[i][j] * p;
}
int x = su - a[h], y = su;
double ans = dp[n][x] / dp[n][y];
cout.precision(15);
cout << fixed << 1 - ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool cmpDouble(const double& a, const double& b) {
return std::fabs(a - b) < std::numeric_limits<double>::epsilon();
}
int main() {
int n, k;
cin >> n >> k;
int v[111];
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
int maxi = 0;
for (int i = 0; i < n; ++i) {
int j = i;
bool b[111];
for (int i = 0; i < n; ++i) b[i] = true;
while (j < n) {
b[j] = false;
j += k;
}
j = i;
while (j >= 0) {
b[j] = false;
j -= k;
}
int sum = 0;
for (int i = 0; i < n; ++i) {
if (b[i]) sum += v[i];
}
maxi = max(maxi, abs(sum));
}
cout << maxi << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool ok(int k, double val, vector<double> &d) {
double p = 0, m = 0;
for (unsigned int i = 0; i < d.size(); ++i) {
if (d[i] >= val)
p += (d[i] - val);
else
m += val - d[i];
}
return p * (100 - k) >= m * 100;
}
int main(void) {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<double> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
double l = *min_element(v.begin(), v.end());
double r = *max_element(v.begin(), v.end());
while (r - l > 0.0000001) {
double c = (l + r) / 2;
if (ok(k, c, v)) {
l = c;
} else {
r = c;
}
}
cout << fixed << l << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e6, inf = ~(1 << 31);
int seg[mxn << 1], lzy[mxn << 1];
int ll[mxn], rr[mxn], ww[mxn], idx[mxn];
int leftt(int x, int xl, int xr) { return x + 1; }
int right(int x, int xl, int xr) { return x + xr - xl - ((xl - xr) & 1); }
void push(int x, int xl, int xr) {
if (xl + 1 == xr) return;
int _leftt = leftt(x, xl, xr);
int _right = right(x, xl, xr);
lzy[_right] += lzy[x];
lzy[_leftt] += lzy[x];
seg[_leftt] += lzy[x];
seg[_right] += lzy[x];
lzy[x] = 0;
}
void update(int x, int xl, int xr, int l, int r, int val) {
if (xl >= r || l >= xr) return;
if (xl >= l && r >= xr) {
seg[x] += val;
lzy[x] += val;
return;
}
push(x, xl, xr);
update(leftt(x, xl, xr), xl, (xl + xr) >> 1, l, r, val);
update(right(x, xl, xr), (xl + xr) >> 1, xr, l, r, val);
seg[x] = min(seg[leftt(x, xl, xr)], seg[right(x, xl, xr)]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int Tests = 1;
for (int Test = 1; Test <= Tests; ++Test) {
;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> ll[i] >> rr[i] >> ww[i];
iota(idx, idx + n, 0);
sort(idx, idx + n, [&](int a, int b) { return ww[a] < ww[b]; });
int ptr1 = 0, ptr2 = 0, ans = inf;
;
update(0, 0, m, 0, 1, 1);
while (ptr1 < n && ptr2 < n) {
while (ptr2 < n && seg[0] == 0) {
update(0, 0, m, ll[idx[ptr2]], rr[idx[ptr2]], 1);
ptr2++;
}
if (!seg[0]) break;
while (seg[0]) {
;
;
ans = min(ans, ww[idx[ptr2 - 1]] - ww[idx[ptr1]]);
update(0, 0, m, ll[idx[ptr1]], rr[idx[ptr1]], -1);
ptr1++;
}
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
pair<int, string> arr[3500];
int cnt[3500], h[3500], v[3500];
void upd(int p, int n) {
for (int i = p; i < n; ++i) cnt[i] += 1;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> arr[i].second >> arr[i].first;
cnt[i] = 0;
v[i] = 0;
}
sort(arr, arr + n);
for (int i = 0; i < n; ++i) {
if (arr[i].first > i) {
puts("-1");
return 0;
}
}
reverse(arr, arr + n);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < n; ++j) {
int empty_pos = n - j - cnt[n - 1] + cnt[j] - 1;
if (arr[j].first == empty_pos && !v[j]) {
v[j] = 1;
upd(j, n);
h[j] = i;
break;
}
}
}
for (int i = n - 1; i >= 0; --i) cout << arr[i].second << " " << h[i] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
const int mod = (int)(1e9 + 7);
long long n, m, a[100001], b[100001];
const int infll = (long long)(1e18);
bool check(long long t) {
long long u = 1, v = 1;
while (v <= m) {
if (a[u] <= b[v]) {
long long x = b[v] - a[u];
if (x > t) {
++u;
if (u > n) return 0;
continue;
}
while (v + 1 <= m && x + b[v + 1] - b[v] <= t) {
x += b[v + 1] - b[v];
++v;
}
if (v == m) return 1;
++u;
++v;
if (u > n) return 0;
} else {
long long x = a[u] - b[v], start = v;
if (x > t) {
return 0;
}
while (v <= m &&
((min(a[u] - b[start], b[v] >= a[u] ? b[v] - a[u] : infll) * 2 +
max(a[u] - b[start], b[v] >= a[u] ? b[v] - a[u] : 0)) <= t))
++v;
if (v > m) return 1;
++u;
if (u > n) return 0;
}
}
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) cin >> b[i];
long long l = -1, r = 2 * (long long)(1e11);
while (l + 1 < r) {
long long m = (l + r) >> 1;
if (check(m))
r = m;
else
l = m;
}
cout << r;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long a[5];
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
long long res = 0;
int tmp;
for (int i = 1; i <= n; i++) a[i % 5]++;
for (int i = 1; i <= m; i++)
if (i % 5 == 0)
res += a[0];
else
res += a[5 - i % 5];
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100100], b[100100], m, res[100100], c[100100], k = 0;
pair<int, int> para[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
c[0] = a[0];
for (int i = 1; i < n; i++) c[i] = a[i] + c[i - 1];
cin >> m;
for (int i = 0; i < m; i++) {
cin >> b[i];
para[i] = make_pair(b[i], i);
}
sort(para, para + m);
for (int i = 0; i < m; i++) {
for (int j = k; j < n; j++)
if (para[i].first <= c[j]) {
k = j;
res[para[i].second] = j + 1;
break;
}
}
for (int i = 0; i < m; i++) printf("%d\n", res[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e6 + 1;
const int MOD = (int)1e9 + 7;
const int infint = (int)1e8 + 3;
const long long inf = (long long)1e18;
int n, q, fen[3][MAXN], type[MAXN];
void add(int type, int x, int val) {
for (; x <= n; x += x & -x) fen[type][x] += val;
}
int get(int type, int x) {
int ans = 0;
for (; x; x -= x & -x) ans += fen[type][x];
return ans;
}
int get(int type, int l, int r) {
int ans = get(type, r);
if (l) ans -= get(type, l - 1);
return ans;
}
void change(int i, char c) {
add(type[i], i, -1);
if (c == 'R')
add(0, i, 1), type[i] = 0;
else if (c == 'P')
add(1, i, 1), type[i] = 1;
else
add(2, i, 1), type[i] = 2;
}
int first(int type) {
int L = 0, R = n;
while (R - L > 1) {
int mid = (L + R) >> 1;
if (get(type, mid) > 0)
R = mid;
else
L = mid;
}
return R;
}
int last(int type) {
int L = 1, R = n + 1;
while (R - L > 1) {
int mid = (L + R) >> 1;
if (get(type, mid, n) > 0)
L = mid;
else
R = mid;
}
return L;
}
int calc() {
if (get(0, n) == 0) {
if (get(2, n) == 0)
return n;
else
return get(2, n);
}
if (get(1, n) == 0) {
if (get(0, n) == 0)
return n;
else
return get(0, n);
}
if (get(2, n) == 0) {
if (get(1, n) == 0)
return n;
else
return get(1, n);
}
int all = n;
int firS = first(2), firR = first(0), firP = first(1);
int lasS = last(2), lasR = last(0), lasP = last(1);
if (firP < firS) all -= get(0, firP, firS);
if (lasS < lasP) all -= get(0, lasS, lasP);
if (firS < firR) all -= get(1, firS, firR);
if (lasR < lasS) all -= get(1, lasR, lasS);
if (firR < firP) all -= get(2, firR, firP);
if (lasP < lasR) all -= get(2, lasP, lasR);
return all;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
if (c == 'R')
add(0, i, 1), type[i] = 0;
else if (c == 'P')
add(1, i, 1), type[i] = 1;
else
add(2, i, 1), type[i] = 2;
}
cout << calc() << "\n";
for (int i = 0; i < q; i++) {
int idx;
char val;
cin >> idx >> val;
change(idx, val);
cout << calc() << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int n, m, ans = 0;
char s1[5005], s2[5005];
int dp[5005][5005];
int main() {
memset(dp, 0, sizeof dp);
scanf("%d%d", &n, &m);
cin >> (s1 + 1);
cin >> (s2 + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s1[i] == s2[j])
dp[i][j] = dp[i - 1][j - 1] + 2;
else {
dp[i][j] = max(max(dp[i][j - 1] - 1, dp[i - 1][j] - 1), 0);
}
ans = max(ans, dp[i][j]);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int s[] = {0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292, 341, 390, 439};
int n;
int main() {
cin >> n;
if (n < 15)
cout << s[n] << endl;
else
cout << (long long)(n - 14) * 49 + s[14] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, b, c;
cin >> n >> a >> b >> c;
if (n == 1) {
cout << 0 << endl;
} else if (n == 2) {
cout << min((long long int)a, (long long int)b) << endl;
} else if ((a <= b) && (a <= c)) {
cout << (n - 1) * a << endl;
} else if ((b <= a) && (b <= c)) {
cout << (n - 1) * b << endl;
} else if ((a <= b) && (c < a)) {
cout << a + (n - 2) * c << endl;
} else if ((b <= a) && (c < b)) {
cout << b + (n - 2) * c << endl;
}
}
| 0 |
#include <bits/stdc++.h>
std::string int_to_str(int x) {
std::ostringstream ss;
ss << x;
return ss.str();
}
int main() {
int n, m;
bool wbg = true;
std::cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
std::cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'C' || a[i][j] == 'M' || a[i][j] == 'Y') {
wbg = false;
break;
}
}
if (!wbg) break;
}
if (wbg)
std::cout << "#Black&White";
else
std::cout << "#Color";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
template <class T0, class T1>
inline ostream &operator<<(ostream &out, pair<T0, T1> &a) {
return out << "{" << a.first << ", " << a.second << "}";
}
template <class T0, class T1>
inline istream &operator>>(istream &in, pair<T0, T1> &a) {
return in >> a.first >> a.second;
}
template <class T0, class T1, class T2>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< "}";
}
template <class T0, class T1, class T2, class T3>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2, T3> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< ", " << get<3>(a) << "}";
}
template <class T>
inline ostream &operator<<(ostream &out, vector<T> &a) {
out << "[";
for (int i = 0; i < int(a.size()); ++i)
out << a[i] << vector<string>{", ", "] "}[i + 1 == a.size()];
return out;
}
inline bool break_time(double time) { return clock() > CLOCKS_PER_SEC * time; }
double get_rand_ld(double l, double r) {
uniform_real_distribution<double> gen(l, r);
return gen(rng);
}
bool may(int E, double T) {
if (E < 0) return 1;
double eps = get_rand_ld(0, 1);
return eps < exp(-E / T);
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(12) << fixed;
smain();
return 0;
}
void solve() {
int n;
cin >> n;
vector<int> cnt(n + 1, 0);
vector<int> a(n);
for (int i = 0; i < int(n); ++i) {
cin >> a[i];
cnt[a[i]]++;
}
set<int> anus;
for (int i = 0; i < int(n + 1); ++i) {
if (!cnt[i]) anus.insert(i);
}
vector<int> ans;
int j = 0;
int kj = 0;
while (j < n) {
if (a[j] == j) ++j;
int mn = *anus.begin();
if (mn == n) {
kj = max(kj, (j));
while (kj < n) {
if (a[kj] != kj) {
ans.push_back(kj);
cnt[a[kj]]--;
if (cnt[a[kj]] == 0) anus.insert(a[kj]);
a[kj] = n;
cnt[a[kj]]++;
if (cnt[a[kj]] == 1) {
anus.erase(a[kj]);
}
break;
}
kj++;
}
} else {
ans.push_back(mn);
cnt[a[mn]]--;
if (cnt[a[mn]] == 0) anus.insert(a[mn]);
a[mn] = mn;
cnt[a[mn]]++;
if (cnt[a[mn]] == 1) {
anus.erase(a[mn]);
}
}
}
cout << ans.size() << '\n';
for (auto x : ans) {
cout << x + 1 << ' ';
}
cout << '\n';
}
void smain() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long n;
scanf("%I64d", &n);
if (n == 0)
printf("1\n");
else {
printf("%I64d", 3 * (n * n + n) + 1);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> primes;
for (int i = 2; i < 3001; i++) {
bool prime = true;
for (int j = 2; j * j <= i; j++)
if (i % j == 0) prime = false;
if (prime) primes.push_back(i);
}
vector<int> list;
for (int i = 0; i < primes.size(); i++) {
int a = primes[i];
while (a <= n) {
list.push_back(a);
a *= primes[i];
}
}
cout << list.size() << endl;
for (int i = 0; i < list.size(); i++) cout << (i ? " " : "") << list[i];
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5100;
int N, M;
vector<int> edge[MAXN];
int cdist[MAXN][MAXN];
int loc[3];
int target[3];
int eloc;
void play(bool finish) {
cout << loc[0] + 1 << " " << loc[1] + 1 << " " << loc[2] + 1 << "\n";
cout << flush;
if (!finish) {
cin >> eloc;
eloc--;
}
}
void bfs(int cloc) {
vector<int> q;
q.push_back(cloc);
cdist[cloc][cloc] = 0;
for (int nq = 0; nq < q.size(); nq++) {
int ccur = q[nq];
for (int neigh : edge[ccur]) {
if (cdist[cloc][neigh] > cdist[cloc][ccur] + 1) {
cdist[cloc][neigh] = cdist[cloc][ccur] + 1;
q.push_back(neigh);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
srand(8403);
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++) cdist[i][j] = MAXN;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
x--, y--;
edge[x].push_back(y);
edge[y].push_back(x);
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < edge[i].size(); j++)
swap(edge[i][j], edge[i][rand() % (j + 1)]);
}
for (int i = 0; i < N; i++) bfs(i);
for (int i = 0; i < 3; i++) {
while (true) {
loc[i] = rand() % N;
bool bad = false;
for (int j = 0; j < i; j++)
if (loc[j] == loc[i]) bad = true;
if (!bad) break;
}
}
play(false);
for (int run = 0; run < N; run++) {
if (eloc == loc[0] || eloc == loc[1] || eloc == loc[2]) break;
vector<pair<int, pair<int, int> > > v;
for (int i = 0; i < 3; i++)
for (int j = 0; j < edge[eloc].size(); j++) {
v.push_back(make_pair(cdist[i][j], make_pair(i, j)));
}
sort(v.begin(), v.end());
for (int i = 0; i < 3; i++) target[i] = -1;
for (auto ppp : v) {
int ci = ppp.second.first, cv = ppp.second.second;
bool bad = false;
for (int i = 0; i < 3; i++)
if (target[i] == cv) bad = true;
if (target[ci] == -1 && !bad) target[ci] = cv;
}
for (int i = 0; i < 3; i++)
if (target[i] == -1) target[i] = 0;
bool done = false;
for (int i = 0; i < 3; i++) {
if (cdist[loc[i]][eloc] == 1) {
done = true;
loc[i] = eloc;
break;
} else {
vector<int> choice;
int nneigh = edge[eloc][target[i]];
for (int neigh : edge[loc[i]])
if (cdist[neigh][nneigh] < cdist[loc[i]][nneigh]) {
choice.push_back(neigh);
}
loc[i] = choice[rand() % choice.size()];
}
}
play(done);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn = (1 << 6), N = 40 + 5, Mod = 1e9 + 7, Inf = 1e9 + 5;
int n, m, dp[N][Maxn][Maxn];
bool ok(int x, int y) {
for (int i = 0; i < m; i++) {
if (!((x >> i) & 1)) {
if ((y >> i) & 1) {
continue;
}
if (i == 0) {
if (!((x >> (i + 1)) & 1)) {
return 0;
}
} else {
if (!((x >> (i + 1)) & 1)) {
if (!((x >> (i - 1)) & 1)) {
return 0;
}
}
}
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
if (n < m) swap(n, m);
for (int i = 0; i < (1 << m); i++) {
for (int j = 0; j < (1 << m); j++) {
if (ok(i, j)) {
dp[1][i][j] = __builtin_popcount(i) + __builtin_popcount(j);
} else {
dp[1][i][j] = Inf;
}
}
}
for (int i = 2; i <= n; i++) {
for (int x = 0; x < (1 << m); x++) {
for (int y = 0; y < (1 << m); y++) {
dp[i][x][y] = Inf;
for (int z = 0; z < (1 << m); z++) {
if (ok(x, z | y)) {
dp[i][x][y] =
min(dp[i][x][y], dp[i - 1][z][x] + __builtin_popcount(y));
}
}
}
}
}
int ans = Inf;
for (int i = 0; i < (1 << m); i++) {
ans = min(ans, dp[n][i][0]);
}
cout << n * m - ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long n, m, a = 0, b = 0, c = 0;
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &m);
a += m;
}
while (n--) {
scanf("%lld", &m);
if (b < m) {
if (b > c) c = b;
b = m;
} else if (c < m)
c = m;
}
if (b + c >= a)
printf("YES");
else
printf("NO");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<long long, string> mp;
int main() {
long long n;
scanf("%lld", &n);
for (register long long i = 2; i * i <= n; ++i)
for (register long long j = i * i, k = 2; j <= n; j *= i, ++k) {
string tmp = to_string(i) + "^" + to_string(k);
if (!mp.count(j)) mp[j] = to_string(j);
if (tmp.size() < mp[j].size()) mp[j] = tmp;
}
string ans = to_string(n);
for (auto x : mp) {
string tmp = "";
long long a = n / x.first, b = n % x.first;
if (a > 1) tmp = (mp.count(a) ? mp[a] : to_string(a)) + "*";
tmp += x.second;
if (b) tmp += "+" + (mp.count(b) ? mp[b] : to_string(b));
if (tmp.size() < ans.size()) ans = tmp;
}
printf(ans.c_str());
}
| 9 |
#include <bits/stdc++.h>
int a[2000000];
int main() {
int n, m;
long long ans = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
int y = (x ^ m);
ans += a[y];
a[x]++;
}
printf("%lld\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n;
cin >> n;
string s;
cin >> s;
long long ans = 0;
for (long long i = 25; i >= 1; i--) {
for (long long tt = 0; tt <= 99; tt++) {
vector<long long> cnt;
for (long long j = 0; j <= s.size() - 1; j++)
if (s[j] - 'a' == i) cnt.push_back(j);
if (cnt.size() == 0) continue;
long long erased = 0;
for (auto x : cnt) {
if (x - erased == 0) {
if (s[x - erased + 1] + 1 == s[x - erased]) {
ans++;
s.erase(x - erased, 1);
erased++;
}
} else if (x - erased == s.size() - 1) {
if (s[x - 1 - erased] + 1 == s[x - erased]) {
ans++;
s.erase(x - erased, 1);
erased++;
}
} else {
if (s[x - 1 - erased] + 1 == s[x - erased] or
s[x + 1 - erased] + 1 == s[x - erased]) {
ans++;
s.erase(x - erased, 1);
erased++;
}
}
}
}
}
cout << ans;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 100;
string s1[30] = {"zero", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine",
"ten", "eleven", "twelve", "thirteen", "fourteen",
"fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
string s2[12] = {"twenty", "thirty", "forty", "fifty",
"sixty", "seventy", "eighty", "ninety"};
int main() {
int s;
cin >> s;
if (s < 20)
cout << s1[s];
else if (s % 10 == 0)
cout << s2[(s / 10) - 2];
else
cout << s2[(s / 10) - 2] << "-" << s1[s % 10];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int N;
int posi[maxn];
int p[maxn];
int main() {
int x;
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &x);
posi[x] = i;
}
for (int i = 1; i <= N; i++) {
scanf("%d", &x);
p[i] = posi[x];
}
for (int i = 1; i <= N; i++) printf("%d ", p[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int ll_max(long long int a, long long int b, long long int c) {
return max(a, max(b, c));
}
int int_max(int a, int b, int c) { return max(a, max(b, c)); }
long long int ll_min(long long int a, long long int b, long long int c) {
return min(a, min(b, c));
}
int int_min(int a, int b, int c) { return min(a, min(b, c)); }
long long int max(int a, long long int b) { return max((long long int)a, b); }
long long int min(int a, long long int b) { return min((long long int)a, b); }
long long int min(long long int a, int b) { return min(a, (long long int)b); }
long long int max(long long int a, int b) { return max(a, (long long int)b); }
long long int maximum(long long int a[], long long int n) {
long long int max1 = LLONG_MIN;
for (long long int i = 0; i < n; i++) {
max1 = max(max1, a[i]);
}
return max1;
}
long long int minimum(long long int a[], long long int n) {
long long int min1 = LLONG_MAX;
for (long long int i = 0; i < n; i++) {
min1 = min(min1, a[i]);
}
return min1;
}
long long int dx[] = {0, 0, 1, -1};
long long int dy[] = {1, -1, 0, 0};
long long int power(long long int x, long long int y, long long int m) {
if (y == 0) return 1;
long long int a = power(x, y / 2, m);
if (y % 2) {
return (a * ((a * x) % m)) % m;
} else {
return (a * a) % m;
}
}
long long int mod_inverse(long long int x, long long int m) {
return power(x, m - 2, m);
}
long long int fact(long long int n, long long int m) {
if (n <= 1) return 1;
return (fact(n - 1, m) * n) % m;
}
long long int ncr(long long int n, long long int r, long long int m) {
if (r > n) return 0;
long long int n1 = 1, d1 = 1, d2 = 1;
n1 = fact(n, m);
d1 = fact(r, m);
d2 = fact(n - r, m);
long long int ans = mod_inverse((d1 * d2) % m, m);
ans = (ans * n1) % m;
return ans;
}
int gcd(int a, int b) {
if (a == 0 || b == 0) return max(a, b);
if (a < b) return gcd(b, a);
if (a % b == 0) return b;
return gcd(b, a % b);
}
int ispal(string s) {
int len = s.size();
int flag = 1;
for (int i = 0; i < len; ++i) {
if (s[i] != s[len - i - 1]) {
flag = 0;
break;
}
}
return flag;
}
long long int sroot(long long int n, long long int low = 1,
long long int high = 1e9 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid;
if (a > n)
return sroot(n, low, mid - 1);
else
return sroot(n, mid, high);
}
long long int croot(long long int n, long long int low = 1,
long long int high = 1e6 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid * mid;
if (a > n)
return croot(n, low, mid - 1);
else
return croot(n, mid, high);
}
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
class solver {
public:
long long int a[505];
void even(long long int n) {
long long int N = n * n;
long long int cnt[1005]{};
for (long long int i = 0; i < N; i++) cnt[a[i]]++;
long long int f = 0, c = 0;
for (long long int i = 1; i <= 1000; i++) {
long long int x = cnt[i];
if (x % 4 != 0) {
f = 1;
break;
}
c += x / 4;
}
if (f == 0 && c == ((n / 2) * (n / 2))) {
cout << "YES\n";
long long int n1 = n / 2;
long long int m[n1 + 1][n1 + 1];
long long int i = 1, j = 1;
for (long long int k = 1; k <= 1000; k++) {
long long int x = cnt[k];
while (x != 0) {
m[i][j] = k;
i++;
if (i == n1 + 1) {
i = 1;
j++;
}
x -= 4;
}
}
for (long long int i = 1; i <= n1; i++) {
for (long long int j = 1; j <= n1; j++) cout << m[i][j] << " ";
for (long long int j = n1; j >= 1; j--) cout << m[i][j] << " ";
cout << "\n";
}
for (long long int i = n1; i >= 1; i--) {
for (long long int j = 1; j <= n1; j++) cout << m[i][j] << " ";
for (long long int j = n1; j >= 1; j--) cout << m[i][j] << " ";
cout << "\n";
}
} else
cout << "NO";
}
void odd(long long int n) {
long long int N = n * n;
long long int cnt[1005]{};
for (long long int i = 0; i < N; i++) cnt[a[i]]++;
long long int f = 0, c = 0;
long long int dp[10]{};
long long int g = (n / 2) * (n / 2);
vector<long long int> v4;
vector<long long int> v2, v1;
for (long long int k = 1; k <= 1000; k++) {
long long int x = cnt[k];
if (x % 2 == 1) {
dp[1]++;
v1.push_back(k);
x--;
}
while (x != 0) {
if (x >= 4) {
if (dp[4] < g) {
dp[4]++;
x -= 4;
v4.push_back(k);
} else {
dp[2]++;
v2.push_back(k);
x -= 2;
}
} else if (x >= 2) {
dp[2]++, x -= 2;
v2.push_back(k);
}
}
}
if (dp[4] == g && dp[1] == 1 && dp[2] == ((n / 2) * 2)) {
cout << "YES\n";
long long int n1 = n / 2;
long long int m[n1 + 1][n1 + 1];
long long int c = 0;
long long int i = 1, j = 1;
for (long long int k = 1; k <= g; k++) {
m[i][j] = v4[c++];
i++;
if (i == (1 + n1)) {
i = 1;
j++;
}
}
c = 0;
vector<long long int> vy;
for (long long int i = 1; i <= n1; i++) {
for (long long int j = 1; j <= n1; j++) cout << m[i][j] << " ";
vy.push_back(v2[c]);
cout << v2[c++] << " ";
for (long long int j = n1; j >= 1; j--) cout << m[i][j] << " ";
cout << "\n";
}
vector<long long int> vx;
for (long long int i = 1; i <= 1; i++) {
while (c != v2.size()) vx.push_back(v2[c]), cout << v2[c++] << " ";
if (c == v2.size()) {
cout << v1[0] << " ";
for (long long int j = vx.size() - 1; j >= 0; j--)
cout << vx[j] << " ";
}
}
cout << "\n";
c = vy.size() - 1;
for (long long int i = n1; i >= 1; i--) {
for (long long int j = 1; j <= n1; j++) cout << m[i][j] << " ";
cout << vy[c--] << " ";
for (long long int j = n1; j >= 1; j--) cout << m[i][j] << " ";
cout << "\n";
}
} else
cout << "NO";
}
void solve() {
long long int n;
cin >> n;
long long int N = n * n;
for (long long int i = 0; i < N; i++) cin >> a[i];
if (n == 1) {
cout << "YES\n" << a[0];
} else {
if (n % 2 == 0)
even(n);
else
odd(n);
}
}
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
int test = 1, c = 1;
while (test--) {
solver o;
o.solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
using ld = long double;
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n = nxt();
long long k;
scanf("%lld", &k);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
a[i] = nxt();
}
ld r = 0;
ld l = 0;
for (int i = 0; i < n; ++i) {
r = max<ld>(r, a[i]);
l = min<ld>(l, a[i] - 3ll * a[i] * a[i]);
}
for (int it = 0; it < 300; ++it) {
ld m = (l + r) / 2;
ld sum = 0;
for (int i = 0; i < n; ++i) {
if (m > a[i]) {
continue;
}
if (m < a[i] - 3ll * a[i] * a[i]) {
sum += a[i];
continue;
}
sum += sqrtl((a[i] - m) / 3);
}
if (sum >= k) {
l = m;
} else {
r = m;
}
}
vector<int> b(n);
vector<pair<long long, int>> can;
ld m = (l + r) / 2;
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (m > a[i]) {
continue;
}
if (m < a[i] - 3ll * a[i] * a[i]) {
k -= a[i];
b[i] = a[i];
ans += 1ll * b[i] * (a[i] - 1ll * b[i] * b[i]);
continue;
}
b[i] = sqrtl((a[i] - m) / 3);
k -= b[i];
ans += 1ll * b[i] * (a[i] - 1ll * b[i] * b[i]);
if (b[i] < a[i]) {
can.push_back({1ll * (b[i] + 1) * (a[i] - 1ll * (b[i] + 1) * (b[i] + 1)) -
1ll * b[i] * (a[i] - 1ll * b[i] * b[i]),
i});
}
}
sort((can).begin(), (can).end());
while (k) {
ans += can.back().first;
b[can.back().second] += 1;
can.pop_back();
--k;
}
cerr << ans << "\n";
for (int x : b) {
cout << x << " ";
}
cout << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool IsSorted(int arr[40], int n) {
for (int i = 1; i < n; i++)
if (arr[i - 1] > arr[i]) return false;
return true;
}
int main() {
int n;
string s[100001], text;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
cin >> text;
int m = 0;
int j = 0;
int k = 0;
int gr = 1, three = 1;
while (m < text.length()) {
if (j < n) {
if (s[j][k] == text[m] && gr == 0 && three == 0) k++;
if (k == s[j].length()) {
j++;
k = 0;
gr = 1;
three = 1;
}
}
if (text[m] == '<') gr = 0;
if (text[m] == '3' && gr == 0) three = 0;
m++;
}
if (j == n && gr == 0 && three == 0)
cout << "yes" << endl;
else
cout << "no" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long mod = pow(10, 9) + 7;
int countdivisors(int n) {
int count = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
count++;
} else {
count = count + 2;
}
}
}
return count;
}
void remove(std::vector<string> &v) {
auto end = v.end();
for (auto it = v.begin(); it != end; ++it) {
end = std::remove(it + 1, end, *it);
}
v.erase(end, v.end());
}
bool isPerfectSquare(int x) {
int s = sqrt(x);
return (s * s == x);
}
bool isFibonacci(int n) {
return isPerfectSquare(5 * n * n + 4) || isPerfectSquare(5 * n * n - 4);
}
string sortString(string &str) {
sort(str.begin(), str.end());
return str;
}
int isSubstring(string s1, string s2) {
int M = s1.length();
int N = s2.length();
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return i;
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << ((n / 2) + 1) << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool mini(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
bool maxi(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int N = 1e5 + 5;
const int oo = 1e9;
struct BIT {
int n;
vector<int> bit;
BIT(int _n) {
n = _n;
bit.assign(n + 5, 0);
}
void update(int pos, int val) {
for (; pos <= n; pos += pos & -pos) bit[pos] += val;
}
void update(int l, int r, int val) {
update(l, val);
update(r + 1, -val);
}
int getval(int pos) {
int res = 0;
for (; pos; pos -= pos & -pos) res += bit[pos];
return res;
}
};
struct query {
int u, v;
string s;
query(int _u = 0, int _v = 0, string _s = "") {
u = _u;
v = _v;
s = _s;
}
void rev() { reverse(s.begin(), s.end()); }
};
vector<pair<int, char>> adj[N];
vector<int> s[2][N * 3];
query q[N];
query todo[N << 1];
int ptr[N * 3][26];
int anc[20][N];
int h[N];
int ans[N];
int cur[N];
int tin[N];
int tout[N];
int n, m, timer, node;
char par[N];
void dfs(int u, int p = 0) {
tin[u] = ++timer;
anc[0][u] = p;
for (int i = 1; i < 20; i++) anc[i][u] = anc[i - 1][anc[i - 1][u]];
for (pair<int, char> to : adj[u]) {
int v = to.first;
char c = to.second;
if (v == p) continue;
par[v] = c;
h[v] = h[u] + 1;
dfs(v, u);
}
tout[u] = timer;
}
int jump(int u, int x) {
if (x < 0) return u;
for (int i = 0; i < 20; i++, x >>= 1)
if (x & 1) u = anc[i][u];
return u;
}
int getlca(int u, int v) {
u = jump(u, h[u] - h[v]);
v = jump(v, h[v] - h[u]);
if (u == v) return u;
for (int i = 19; i >= 0; i--)
if (anc[i][u] != anc[i][v]) {
u = anc[i][u];
v = anc[i][v];
}
return anc[0][u];
}
int Z(string s, string t) {
string str = s + '#' + t;
int n = str.size();
vector<int> z(n, 0);
int res = 0;
for (int i = 1, l = 0, r = 0; i < n; i++) {
int &k = z[i];
if (i < r) k = min(r - i, z[i - l]);
while (i + k < n && str[k] == str[i + k]) k++;
if (i + k > r) {
l = i;
r = i + k;
}
res += (k == s.size());
}
return res;
}
void add(int &res, int u, int v, string s) {
int p = getlca(u, v);
u = jump(u, h[u] - h[p] - (int)s.size() + 1);
v = jump(v, h[v] - h[p] - (int)s.size() + 1);
string f = "", g = "";
while (u != p) f += par[u], u = anc[0][u];
while (v != p) g += par[v], v = anc[0][v];
reverse(g.begin(), g.end());
res += Z(s, f + g);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
char c;
cin >> u >> v >> c;
adj[u].push_back(make_pair(v, c));
adj[v].push_back(make_pair(u, c));
}
dfs(1);
cin >> m;
for (int i = 0; i < m; i++) {
cin >> q[i].u >> q[i].v >> q[i].s;
int p = getlca(q[i].u, q[i].v);
todo[i << 1] = query(q[i].u, p, q[i].s);
todo[i << 1 | 1] = query(q[i].v, p, q[i].s);
todo[i << 1 | 1].rev();
}
node = 1;
for (int i = 1; i <= n; i++) {
s[0][0].push_back(i);
cur[i] = i;
}
for (int i = 0; i < (m << 1); i++) s[0][0].push_back(-i);
BIT bit(n);
for (int len = 1; len <= 100; len++) {
int cr = len & 1;
int pr = cr ^ 1;
int newnode = 0;
for (int i = 0; i < node; i++) {
memset(ptr[i], -1, sizeof(ptr[i]));
for (int id : s[pr][i]) {
if (id <= 0) {
id = -id;
if (todo[id].s.size() < len) continue;
int &p = ptr[i][todo[id].s[len - 1] - 'a'];
if (p < 0) p = newnode++;
s[cr][p].push_back(-id);
} else {
if (cur[id] == 1) continue;
int &p = ptr[i][par[cur[id]] - 'a'];
if (p < 0) p = newnode++;
s[cr][p].push_back(id);
cur[id] = anc[0][cur[id]];
}
}
s[pr][i].clear();
}
node = newnode;
for (int i = 0; i < node; i++) {
for (int id : s[cr][i]) {
if (id > 0) {
bit.update(tin[id], tout[id], 1);
} else {
id = -id;
if (todo[id].s.size() != len) continue;
int u = todo[id].u;
int p = todo[id].v;
p = jump(u, h[u] - h[p] - len + 1);
ans[id >> 1] += bit.getval(tin[u]) - bit.getval(tin[p]);
}
}
for (int id : s[cr][i])
if (id > 0) bit.update(tin[id], tout[id], -1);
}
}
for (int i = 0; i < m; i++) add(ans[i], q[i].u, q[i].v, q[i].s);
for (int i = 0; i < m; i++) cout << ans[i] << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > T;
bool done;
void answer(int u) {
printf("! %d\n", u);
fflush(stdout);
done = true;
}
int cnt;
void query(int u) {
if (T[u].size() > 0) return;
cnt++;
printf("? %d\n", u);
fflush(stdout);
int k;
scanf("%d", &(k));
if (!k) exit(0);
for (int i = 1, __R = k; i <= __R; i++) {
int t;
scanf("%d", &(t));
T[u].push_back(t);
}
if (k == 2) answer(u);
}
int par[128];
vector<bool> vis;
pair<int, int> dive(int u, int p, int d) {
par[u] = p;
vis[u] = true;
query(u);
if (done) return pair<int, int>();
for (int v : T[u])
if (v != p) return dive(v, u, d + 1);
return pair<int, int>(u, d);
}
int climb(int u, int d) { return d == 0 ? u : climb(par[u], d - 1); }
void dfs(int u, int p, int lim, int d = 0) {
if (cnt == 16) {
answer(u);
return;
}
query(u);
if (done || d == lim) return;
for (int v : T[u])
if (v != p) {
dfs(v, u, lim, d + 1);
if (done) return;
}
}
int main() {
int t;
scanf("%d", &(t));
for (int __ = 1, __R = t; __ <= __R; __++) {
T = vector<vector<int> >(128);
vis = vector<bool>(128, false);
done = false;
cnt = 0;
int h;
scanf("%d", &(h));
if (!h) exit(0);
query(1);
if (done) continue;
vis[1] = true;
int hei, lca;
if (T[1].size() == 1) {
auto l = dive(T[1][0], 1, 1);
if (done) continue;
hei = (l.second >> 1) + 1;
lca = climb(l.first, hei - 1);
} else {
auto l1 = dive(T[1][0], 1, 1);
if (done) continue;
auto l2 = dive(T[1][1], 1, 1);
if (done) continue;
if (l2.second > l1.second) swap(l1, l2);
hei = ((l1.second + l2.second) >> 1) + 1;
lca = climb(l1.first, hei - 1);
}
while (!done && hei < 4) {
for (int v : T[lca])
if (!vis[v]) {
auto l = dive(v, lca, hei);
if (!done) {
hei = (l.second >> 1) + 1;
lca = climb(l.first, hei - 1);
}
break;
}
}
if (done) continue;
for (int v : T[lca])
if (!vis[v]) {
dfs(v, lca, h - (hei + 1));
break;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long g, p, n, k, r, sum = 0;
set<long long> s;
map<long long, long long> m;
cin >> n >> p >> k;
for (long long x, i = 0; i < n; i++) {
cin >> x;
g = (x * x % p) * (x * x % p) - (k * x % p) + p;
r = g % p;
s.insert(r);
m[r]++;
}
for (long long a : s) {
sum += m[a] * (m[a] - 1) / 2;
}
cout << sum;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
int a[n], b[n], t = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[t++] = a[i];
}
sort(a, a + n);
int s = 0;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
s++;
}
}
if (s <= 2) {
cout << "YES";
} else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long P = 998244353;
const int N = 999999, M = 150;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, k, q, f[10];
long long v[M], w[M], dp[N + 5], dp1[N + 5];
int main() {
cin >> k;
int m = 0, num = 1;
for (int i = (1); i <= (6); ++i) {
cin >> f[i];
int tot = min(3 * (k - 1), N / (num * 3)), cnt = 1;
while (cnt * 2 - 1 <= tot) {
v[++m] = 1ll * f[i] * cnt;
w[m] = 3ll * num * cnt;
cnt *= 2;
}
tot -= (cnt - 1);
if (tot) {
v[++m] = 1ll * f[i] * tot;
w[m] = 3ll * num * tot;
}
num *= 10;
}
memset(dp, 0xc0, sizeof dp);
dp[0] = 0;
for (int i = (1); i <= (m); ++i)
for (int j = (N); j >= (w[i]); --j) dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
for (int i = (1); i <= (m); ++i)
cerr << i << " " << w[i] << " " << v[i] << endl;
num = 1;
for (int i = (1); i <= (6); ++i) {
m = 0;
for (int j = (0); j <= (9); ++j) {
w[++m] = 1ll * num * j;
v[m] = j % 3 == 0 ? j / 3ll * f[i] : 0;
}
memcpy(dp1, dp, sizeof dp1);
for (int x = (1); x <= (m); ++x)
for (int j = (N); j >= (w[x]); --j)
dp[j] = max(dp[j], dp1[j - w[x]] + v[x]);
num *= 10;
}
cin >> q;
for (int _ = (1); _ <= (q); ++_) {
scanf("%d", &n);
printf("%lld\n", dp[n]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<int> way[300005];
vector<pair<int, int>> qr[300005];
int vs[300005];
int vs_tmp[300005];
int cnt[300005];
long long res[300005];
int lst[300005];
int idx;
int ban[300005];
void dfs(int pos, int from) {
if (vs[pos]) return;
vs[pos] = 1;
vs_tmp[pos] = 1;
lst[idx++] = pos;
for (int v : way[pos]) {
if (v == from) continue;
if (vs_tmp[v]) {
int mn = v, mx = v;
for (int k = idx - 1; lst[k] != v; k--) {
mn = min(mn, lst[k]);
mx = max(mx, lst[k]);
}
ban[mx] = max(ban[mx], mn);
}
dfs(v, pos);
}
idx--;
vs_tmp[pos] = 0;
return;
}
long long t[2000000];
int lazy[2000000];
void add(int node, int l, int r, int targ_l, int targ_r) {
if (r < targ_l) return;
if (l > targ_r) return;
if (targ_l <= l && r <= targ_r) {
t[node] += r - l + 1;
lazy[node]++;
return;
}
int mid = (l + r) >> 1;
lazy[node << 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
t[node << 1] += 1LL * lazy[node] * (mid - l + 1);
t[node << 1 | 1] += 1LL * lazy[node] * (r - mid);
lazy[node] = 0;
add(node << 1, l, mid, targ_l, targ_r);
add(node << 1 | 1, mid + 1, r, targ_l, targ_r);
t[node] = t[node << 1] + t[node << 1 | 1];
return;
}
long long sum(int node, int l, int r, int targ_l, int targ_r) {
if (r < targ_l) return 0;
if (l > targ_r) return 0;
if (targ_l <= l && r <= targ_r) return t[node];
int mid = (l + r) >> 1;
lazy[node << 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
t[node << 1] += 1LL * lazy[node] * (mid - l + 1);
t[node << 1 | 1] += 1LL * lazy[node] * (r - mid);
lazy[node] = 0;
long long res = 0;
res += sum(node << 1, l, mid, targ_l, targ_r);
res += sum(node << 1 | 1, mid + 1, r, targ_l, targ_r);
t[node] = t[node << 1] + t[node << 1 | 1];
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
way[u].push_back(v);
way[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vs[i]) dfs(i, i);
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
qr[r].push_back({l, i});
}
int mx = 0;
for (int i = 1; i <= n; i++) {
mx = max(ban[i], mx);
if (mx + 1 <= i) {
add(1, 1, n, mx + 1, i);
}
for (auto p : qr[i]) {
int l = p.first;
int idx = p.second;
res[idx] = sum(1, 1, n, l, i);
}
}
for (int i = 1; i <= q; i++) printf("%lld\n", res[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
const int MAXN = 1e5 + 10;
const long long INF = 1e18;
struct node {
long long mx = -INF, mn = INF;
bool lz = 0;
long long sum = 0;
long long len = 0;
} st[MAXN << 2];
node merge(node a, node b) {
node c;
c.mx = max(a.mx, b.mx);
c.mn = min(a.mn, b.mn);
c.sum = a.sum + b.sum;
c.len = a.len + b.len;
return c;
}
void weed(int v) {
if (!st[v].lz) return;
assert(st[v].mx == st[v].mn);
for (int u : {v << 1, v << 1 ^ 1}) {
st[u].sum = st[v].mx * st[u].len;
st[u].mx = st[u].mn = st[v].mx;
st[u].lz = 1;
}
st[v].lz = 0;
}
long long n, a[MAXN];
void plant(int v, int b, int e) {
if (e - b == 1) {
st[v].mx = st[v].mn = st[v].sum = a[b];
st[v].len = 1;
return;
}
int m = (b + e) >> 1;
plant(v << 1, b, m);
plant(v << 1 ^ 1, m, e);
st[v] = merge(st[v << 1], st[v << 1 ^ 1]);
}
long long smoke(int v, int b, int e, int l, int r) {
if (l >= r) return 0;
if (b == l && e == r) {
return st[v].sum;
}
weed(v);
int m = (b + e) >> 1;
return smoke(v << 1, b, m, l, min(r, m)) +
smoke(v << 1 ^ 1, m, e, max(l, m), r);
}
void water(int v, int b, int e, int l, int r, int mod) {
if (l >= r) return;
if (st[v].mx < mod) return;
if (b == l && e == r && st[v].mx == st[v].mn) {
st[v].mx = st[v].mn = st[v].mx % mod;
st[v].sum = st[v].len * st[v].mx;
st[v].lz = 1;
return;
}
weed(v);
int m = (b + e) >> 1;
water(v << 1, b, m, l, min(r, m), mod);
water(v << 1 ^ 1, m, e, max(l, m), r, mod);
st[v] = merge(st[v << 1], st[v << 1 ^ 1]);
}
void nut(int v, int b, int e, int i, int x) {
if (e - b == 1) {
st[v].mx = st[v].mn = st[v].sum = x;
st[v].len = 1;
return;
}
weed(v);
int m = (b + e) >> 1;
if (i < m)
nut(v << 1, b, m, i, x);
else
nut(v << 1 ^ 1, m, e, i, x);
st[v] = merge(st[v << 1], st[v << 1 ^ 1]);
}
void solve() {
int q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
plant(1, 0, n);
while (q--) {
int qt;
cin >> qt;
if (qt == 1) {
int l, r;
cin >> l >> r;
--l;
cout << smoke(1, 0, n, l, r) << "\n";
} else if (qt == 2) {
int l, r, mod;
cin >> l >> r >> mod;
--l;
water(1, 0, n, l, r, mod);
} else {
int i, x;
cin >> i >> x;
--i;
nut(1, 0, n, i, x);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int w = 0, x = 0;
char c = getchar();
while (!isdigit(c)) w |= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
return w ? -x : x;
}
namespace star {
const int maxn = 1e6 + 10;
int n, rt[maxn];
struct SAM {
struct node {
int len, link, nxt[26];
node() : len(), link(), nxt() {}
} e[maxn];
int lst, tot;
SAM() : e(), lst(1), tot(1), S() { e[1].len = 0, e[1].link = -1; }
struct SegmentTree {
int tot, son[maxn << 2][2];
SegmentTree() : tot(), son() {}
void insert(const int &x, int &ro, const int l = 1, const int r = n) {
ro = ++tot;
if (l == r) return;
x <= ((l + r) >> 1) ? insert(x, son[ro][0], l, ((l + r) >> 1))
: insert(x, son[ro][1], ((l + r) >> 1) + 1, r);
}
bool query(const int &x, const int &y, const int &ro, const int &l = 1,
const int &r = n) {
if (!ro) return false;
if (x == l and y == r) return true;
if (y <= ((l + r) >> 1))
return query(x, y, son[ro][0], l, ((l + r) >> 1));
else if (x > ((l + r) >> 1))
return query(x, y, son[ro][1], ((l + r) >> 1) + 1, r);
else
return query(x, ((l + r) >> 1), son[ro][0], l, ((l + r) >> 1)) ||
query(((l + r) >> 1) + 1, y, son[ro][1], ((l + r) >> 1) + 1, r);
}
int merge(const int &a, const int &b, const int &l = 1, const int &r = n) {
if (!a or !b or l == r) return a | b;
int ro = ++tot;
son[ro][0] = merge(son[a][0], son[b][0], l, ((l + r) >> 1));
son[ro][1] = merge(son[a][1], son[b][1], ((l + r) >> 1) + 1, r);
return ro;
}
} S;
void insert(int c, int pos) {
int x = ++tot;
e[x].len = e[lst].len + 1;
S.insert(pos, rt[x]);
int u = lst;
while (u != -1 and !e[u].nxt[c]) e[u].nxt[c] = x, u = e[u].link;
if (u == -1)
e[x].link = 1;
else {
int y = e[u].nxt[c];
if (e[u].len + 1 == e[y].len)
e[x].link = y;
else {
int clone = ++tot;
e[clone] = e[y];
e[clone].len = e[u].len + 1;
while (u != -1 and e[u].nxt[c] == y) e[u].nxt[c] = clone, u = e[u].link;
e[y].link = e[x].link = clone;
}
}
lst = x;
}
} S;
vector<int> V[maxn];
void dfs(int x) {
for (auto &&u : V[x]) dfs(u), rt[x] = S.S.merge(rt[x], rt[u]);
}
char s[maxn];
int nxt[maxn];
inline void work() {
scanf("%s", s);
n = strlen(s);
for (char *c = s; *c; c++) S.insert(*c - 'a', c - s + 1);
for (int i = 2; i <= S.tot; i++) V[S.e[i].link].push_back(i);
dfs(1);
int m = read();
while (m--) {
int l = read(), r = read();
scanf("%s", s);
int k = strlen(s), now = 1;
int i;
for (i = 0;; i++) {
nxt[i] = -1;
for (int j = max(s[i] - 'a' + 1, 0); j < 26; j++)
if (S.e[now].nxt[j] and S.S.query(l + i, r, rt[S.e[now].nxt[j]])) {
nxt[i] = j;
break;
}
int x = S.e[now].nxt[s[i] - 'a'];
if (!x or i == k or !S.S.query(l + i, r, rt[x])) break;
now = x;
}
while (~i and nxt[i] == -1) i--;
if (i == -1)
puts("-1");
else {
for (int j = 0; j < i; j++) putchar(s[j]);
putchar(nxt[i] + 'a');
puts("");
}
}
}
} // namespace star
signed main() {
star::work();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long long mod = 1e9 + 7;
const int inf = 1e9 + 10;
const double D = 0.000001;
vector<int> e[N], pth;
int vis[N][2] = {0}, cyc = 0, col[N] = {0};
void dfs(int x, int p) {
if (cyc == 2) return;
if (p && e[x].size() == 0) {
cyc = 2;
cout << "Win" << endl;
for (int i = 0; i < pth.size(); i++) printf("%d ", pth[i]);
return;
}
col[x] = 1;
vis[x][p] = 1;
for (int i = 0; i < e[x].size(); i++) {
int u = e[x][i];
pth.push_back(u);
if (col[u] == 1 && col[x] == 1) cyc = 1;
if (!vis[u][!p]) dfs(u, !p);
if (cyc == 2) return;
pth.pop_back();
}
col[x] = 2;
}
int main() {
int rt, t, n, m, d;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
for (int j = 0; j < t; j++) scanf("%d", &d), e[i].push_back(d);
}
cin >> rt;
pth.push_back(rt);
dfs(rt, 0);
if (cyc == 2) {
;
} else if (cyc == 1) {
cout << "Draw" << endl;
} else {
cout << "Lose" << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int maxn = 1 * 1e2 + 17;
int N, K, D;
long long DP[maxn][2];
long long cache[maxn][2];
void add(long long &x, long long y) { x = (x + y) % MOD; }
long long solve(int x, bool y) {
if (x < 0) return 0;
if (cache[x][y] != -1) return cache[x][y];
if (!x) return cache[x][y] = y * 1LL;
long long cr = 0;
for (int i = 1; i <= K; i++) add(cr, solve(x - i, y || i >= D));
return cache[x][y] = cr;
}
int main() {
ios_base::sync_with_stdio(false);
scanf("%d %d %d", &N, &K, &D);
DP[0][0] = 1LL;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= min(K, i); j++)
if (i - j >= 0)
for (int k = 0; k < 2; k++) add(DP[i][k | (j >= D)], DP[i - j][k]);
return !printf("%lld\n", DP[N][1]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
if (m == 3 && n > 4) {
cout << -1 << endl;
return 0;
}
double ang = 2 * 3.1415926 / m;
double R1 = 10000000;
double R2 = 100000;
for (int i = 0; i < m; i++)
cout << int(cos(ang * i) * R1) << ' ' << int(sin(ang * i) * R1) << endl;
for (int i = 1; i <= n - m; i++)
cout << int(cos(ang * i - 2 * 3.1415926 / 180) * R2) << ' '
<< int(sin(ang * i - 2 * 3.1415926 / 180) * R2) << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n[t], sum = 0;
for (int i = 0; i < t; i++) {
cin >> n[i];
}
for (int i = 0; i < t; i++) {
if (n[i] % 2 == 0) {
sum = (n[i] / 2) - 1;
} else {
sum = n[i] / 2;
}
cout << sum << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int i, n, j, a[1000], b[1000000], x;
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++) {
x = a[i] + a[j];
b[x]++;
}
n = 0;
for (i = 1; i < 1000000; i++) n = max(n, b[i]);
cout << n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int k, ls;
int main() {
cin >> s >> k;
int lim, i, j, n, p, l = s.size();
int mx = 0;
for (i = 0; i < k; i++) {
s = s + "*";
}
for (i = 1; i <= s.size(); i++) {
for (j = 0; j + 2 * i <= s.size(); j++) {
for (k = j, p = 0; p < i; p++, k++) {
if (s[k] == s[k + i]) continue;
if (s[k + i] == '*') continue;
break;
}
if (p == i) {
mx = max(mx, 2 * i);
}
}
}
cout << mx << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i, mcost = 0;
cin >> n >> k;
vector<long long> v(n), sc(n);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
less<pair<long long, long long> > >
pq;
for (i = 0; i < n; i++) {
cin >> v[i];
if (i <= k) pq.push(make_pair(v[i], i));
}
i = k + 1;
for (long long j = 0; !pq.empty(); j++) {
pair<long long, long long> p = pq.top();
mcost += p.first * (k + j - p.second);
sc[p.second] = j + k + 1;
pq.pop();
if (i < n) {
pq.push(make_pair(v[i], i));
i++;
}
}
cout << mcost << endl;
for (i = 0; i < n; i++) {
cout << sc[i] << " ";
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100002;
int s[3];
int ans[maxn];
int main() {
int i, j, k;
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
memset(ans, -1, sizeof(ans));
int l = 0;
for (i = 0; i < m; i++) {
k = 1;
for (j = 0; j < 3; j++) {
cin >> s[j];
if (ans[s[j]] != -1) {
l = ans[s[j]];
}
}
for (j = 0; j < 3; j++)
if (ans[s[j]] != l) {
ans[s[j]] = (l + k) % 3;
k++;
}
}
for (i = 1; i <= n; i++) printf("%d ", ans[i] + 1);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
istream& in = cin;
string str;
bool ok[5010][5010];
int num[26][5010];
void input() { in >> str; }
int dfs(int l, int r) {
int len = r - l + 1;
if (l == r) {
return -1;
}
if (!ok[l][r]) {
return 1;
}
if (len % 2 == 0) {
int R = r / 2;
return dfs(l, R);
} else {
int R = r / 2;
R--;
return dfs(l, R) * 2;
}
}
bool judge(string s) {
int l = 0, r = s.length() - 1;
while (l < r) {
if (s[l] != s[r]) {
return 0;
}
l++;
r--;
}
return 1;
}
int main() {
int TEST_CASE = 1;
while (TEST_CASE-- > 0) {
input();
int n = str.length();
for (int len = 1; len <= n; ++len)
for (int i = 0; i + len - 1 < n; ++i) {
int j = i + len - 1;
if (i == j) {
ok[i][j] = 1;
} else if (i + 1 == j) {
ok[i][j] = (str[i] == str[j]);
} else {
ok[i][j] = ok[i + 1][j - 1] && (str[i] == str[j]);
}
}
int mid = n / 2;
if (n % 2 == 1) {
mid--;
}
int ans = 3;
for (int i = 0; i <= mid; ++i) {
if (i == 1) {
int t = 0;
}
if (!ok[0][i]) {
ans = min(ans, 2);
}
string nn = str.substr(i + 1) + str.substr(0, i + 1);
if (nn != str && judge(nn)) {
ans = 1;
break;
}
}
if (ans > 2) {
cout << "Impossible" << endl;
} else {
cout << ans << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void readc(char &x) {
char c;
while (((c = getchar()) == ' ') || c == '\n')
;
x = c;
}
const int mod = 1e9 + 7;
int n, m, i, j, sz[100005], mx[100005], rt, vis[100005], ans = 1;
vector<pair<int, pair<int, int> > > e[100005];
int pw(int x, int y) {
int z = 1;
while (y) {
if (y & 1) z = 1ll * z * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return z;
}
struct bit {
int a[400005];
int b[400005];
void init() {
int i;
for (((i)) = (1); ((i)) <= ((n * 4)); ((i))++) {
a[i] = 0;
b[i] = 1;
}
}
void add(int x, int da, int db) {
x += n * 2;
while (x <= n * 4) {
a[x] += da;
b[x] = 1ll * b[x] * db % mod;
x += (x & -x);
}
}
void qry(int x, int &sa, int &sb) {
x += n * 2;
sa = 0;
sb = 1;
while (x) {
sa += a[x];
sb = 1ll * sb * b[x] % mod;
x -= (x & -x);
}
}
} t1, t2;
void dfs_sz(int x, int fa) {
sz[x] = 1;
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++) {
if (it->first == fa || vis[it->first]) continue;
dfs_sz(it->first, x);
sz[x] += sz[it->first];
}
}
void dfs_rt(int x, int fa, int all) {
mx[x] = all - sz[x];
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++) {
if (it->first == fa || vis[it->first]) continue;
dfs_rt(it->first, x, all);
mx[x] = max(mx[x], sz[it->first]);
}
if (rt == -1 || mx[x] < mx[rt]) rt = x;
}
vector<pair<pair<int, int>, int> > v1, v2;
void dfs_in(int x, int fa, int c0, int c1, int v) {
v2.push_back(make_pair(make_pair(2 * c0 - c1, 2 * c1 - c0), v));
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++)
if (it->first != fa && !vis[it->first]) {
dfs_in(it->first, x, c0 + (it->second.second == 0),
c1 + (it->second.second == 1), 1ll * v * it->second.first % mod);
}
}
void calc(int x) {
v1.clear();
int a = 0, b = 0, w = 1;
v1.push_back(make_pair(make_pair(a, b), w));
t1.add(-a, 1, w);
t2.add(b, 1, w);
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++)
if (!vis[it->first]) {
v2.clear();
dfs_in(it->first, x, it->second.second == 0, it->second.second == 1,
it->second.first);
for (__typeof((v2).begin()) it = (v2).begin(); it != (v2).end(); it++) {
int s1, s2, a = it->first.first, b = it->first.second, w = it->second;
t1.qry(a, s1, s2);
ans = 1ll * ans * s2 % mod * pw(w, s1) % mod;
t2.qry(-b - 1, s1, s2);
ans = 1ll * ans * pw(1ll * s2 * pw(w, s1) % mod, mod - 2) % mod;
}
for (__typeof((v2).begin()) it = (v2).begin(); it != (v2).end(); it++) {
int a = it->first.first, b = it->first.second, w = it->second;
v1.push_back(*it);
t1.add(-a, 1, w);
t2.add(b, 1, w);
}
}
for (__typeof((v1).begin()) it = (v1).begin(); it != (v1).end(); it++) {
int a = it->first.first, b = it->first.second, w = it->second;
w = pw(w, mod - 2);
t1.add(-a, -1, w);
t2.add(b, -1, w);
}
}
void dfs(int x) {
rt = -1;
dfs_sz(x, 0);
dfs_rt(x, 0, sz[x]);
x = rt;
vis[x] = 1;
calc(x);
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++)
if (!vis[it->first]) {
dfs(it->first);
}
}
int main() {
read(n);
t1.init();
t2.init();
for (((i)) = (1); ((i)) <= ((n - 1)); ((i))++) {
int x, y, z, c;
read(x);
read(y);
read(z);
read(c);
e[x].push_back(make_pair(y, make_pair(z, c)));
e[y].push_back(make_pair(x, make_pair(z, c)));
}
dfs(1);
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long int f[25];
long long int power(long long int a, long long int b) {
long long int ans = 1;
for (; b; b >>= 1ll) {
if (b & 1ll) ans = ans * a % mod;
a = a * a % mod;
}
return ans;
}
long long int jc(long long int a, long long int b) {
long long int ans = 1;
for (long long int i = a; i <= b; i++) ans = ans * (i % mod) % mod;
return ans;
}
int main() {
long long int n, s, ans, inv, tmp, cnt;
scanf("%I64d%I64d", &n, &s);
for (int i = 1; i <= n; i++) scanf("%I64d", &f[i]);
inv = power(jc(1, n - 1), mod - 2);
ans = jc(s + 1, s + n - 1) * inv % mod;
for (long long int i = 1; i < (1 << n); i++) {
tmp = s + n - 1;
cnt = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) tmp = tmp - f[j + 1] - 1, cnt++;
if (tmp >= n - 1) {
if (cnt % 2 == 0)
ans = (ans + jc(tmp - n + 2, tmp) * inv % mod) % mod;
else
ans = (ans - jc(tmp - n + 2, tmp) * inv % mod + mod) % mod;
}
}
printf("%I64d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
vector<int> v[N];
unsigned long long com(unsigned long long x) { return x * (x - 1) / 2; }
int deg[N];
bool big[N];
int a[N], b[N];
bool bit[955][N];
int maps[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
unsigned long long A, B, C;
cin >> A >> B >> C;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
if (a[i] > b[i]) swap(a[i], b[i]);
v[a[i]].push_back(b[i]);
v[b[i]].push_back(a[i]);
deg[a[i]]++;
deg[b[i]]++;
}
vector<int> bigs;
for (int i = 0; i < n; i++) {
if (deg[i] >= 450) big[i] = true, bigs.push_back(i);
}
for (int i = 0; i < bigs.size(); i++) maps[bigs[i]] = i;
for (int i = 0; i < bigs.size(); i++) {
int x = bigs[i];
for (int j = 0; j < v[x].size(); j++) {
bit[maps[x]][v[x][j]] = 1;
}
}
for (int i = 0; i < n; i++) sort(v[i].begin(), v[i].end());
unsigned long long ans = 0;
for (int i = 0; i < n; i++) {
if (i + 2 < n) {
ans += com(n - i - 1) * i * A;
}
ans += B * i * i * (n - i - 1);
if (i > 1) {
ans += C * i * com(i);
}
}
for (int i = 1; i <= m; i++) {
int x = a[i], y = b[i];
if (x) {
ans -= x * B * x + x * C * y + A * x * (x - 1) / 2;
}
if (x + 1 < y) {
ans -= (y - x - 1) * (A * x + C * y) + B * (y - x - 1) * (x + y) / 2;
}
if (y + 1 < n) {
ans -= (n - y - 1) * (A * x + B * y) + C * (n - y - 1) * (y + n) / 2;
}
}
for (int i = 0; i < n; i++) {
if (v[i].size() < 2) continue;
unsigned long long pre = 0, pre_tot = 0;
for (int j = 0; j < v[i].size(); j++) {
if (v[i][j] > i) break;
ans += A * pre + B * v[i][j] * pre_tot + C * i * pre_tot;
pre += v[i][j];
pre_tot += 1;
}
unsigned long long suf = 0, suf_tot = 0;
for (int j = v[i].size() - 1; j >= 0; j--) {
if (v[i][j] < i) break;
ans += C * suf + B * v[i][j] * suf_tot + A * i * suf_tot;
suf += v[i][j];
suf_tot += 1;
}
ans += suf_tot * pre_tot * i * B + A * pre * suf_tot + C * suf * pre_tot;
}
for (int i = 1; i <= m; i++) {
int x = a[i], y = b[i];
if (big[x]) {
int idx = maps[x];
if (big[y]) {
int idy = maps[y];
for (int j = 0; j < bigs.size(); j++) {
if (bigs[j] > y && bit[idx][bigs[j]] && bit[idy][bigs[j]]) {
ans -= A * x + B * y + C * bigs[j];
}
}
} else {
for (int j = 0; j < v[y].size(); j++) {
if (v[y][j] > y && bit[idx][v[y][j]]) {
ans -= A * x + B * y + C * v[y][j];
}
}
}
} else {
bool flag = false;
if (deg[x] > deg[y]) {
swap(x, y);
swap(A, B);
flag = true;
}
if (big[y]) {
int idy = maps[y];
for (int j = 0; j < v[x].size(); j++) {
if (v[x][j] > y && bit[idy][v[x][j]]) {
ans -= A * x + B * y + C * v[x][j];
}
}
} else {
int j = 0, k = 0;
while (j < v[x].size() && k < v[y].size()) {
if (v[x][j] < v[y][k])
j++;
else if (v[x][j] > v[y][k])
k++;
else {
if (v[y][k] > y && v[x][j] > x) ans -= A * x + B * y + C * v[y][k];
j++, k++;
}
}
}
if (flag) {
swap(A, B);
}
}
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
typedef int matrix[410][410];
const int p = 10007;
int n, m, f[210][210][210], ans;
char s[210];
matrix a;
void mul(matrix &a, matrix &b, int n) {
static long long c[410][410];
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; ++i)
for (int k = i; k <= n; ++k)
if (a[i][k])
for (int j = k; j <= n; ++j) c[i][j] += a[i][k] * b[k][j];
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j) a[i][j] = c[i][j] % p;
}
void power(matrix &a, int n, int k) {
static matrix b;
memset(b, 0, sizeof(b));
for (int i = 1; i <= n; ++i) b[i][i] = 1;
for (; k; k >>= 1, mul(a, a, n))
if (k & 1) mul(b, a, n);
memcpy(a, b, sizeof(b));
}
int main() {
scanf("%s%d", s + 1, &m), m += n = strlen(s + 1);
f[1][n][s[1] != s[n]] = 1;
for (int i = 1; i <= n; ++i)
for (int j = n; j >= i; --j)
for (int k = 0; k <= n - 1; ++k)
if (f[i][j][k])
if (s[i] == s[j])
(f[i + 1][max(j - 1, i)][k + (s[i + 1] != s[j - 1] && i + 1 < j)] +=
f[i][j][k]) %= p;
else {
(f[i + 1][j][k + (s[i + 1] != s[j])] += f[i][j][k]) %= p;
(f[i][j - 1][k + (s[i] != s[j - 1])] += f[i][j][k]) %= p;
}
for (int i = 1; i <= n - 1; ++i) a[i][i] = 24, a[i][i + 1] = 1;
for (int j = 1; j <= (n + 1) / 2; ++j) {
a[n + (j - 1) * 2][n + (j - 1) * 2] = 25;
a[n + (j - 1) * 2 + 1][n + (j - 1) * 2 + 1] = 26;
a[n + (j - 1) * 2][n + (j - 1) * 2 + 1] = 1;
a[n + (j - 1) * 2][n + j * 2] = 1;
}
power(a, n * 2 + 1, m / 2);
for (int i = 0; i <= n - 1; ++i) {
int cnt = 0;
for (int j = 0; j <= n; ++j) (cnt += f[j + 1][j][i]) %= p;
if (m & 1) {
(ans += cnt * a[n - i][n + (n - i + 1) / 2 * 2 - 1] % p * 26) %= p,
cnt = 0;
if ((n - 1 - i) & 1) continue;
for (int j = 1; j <= n; ++j) (cnt += f[j][j][i]) %= p;
(ans += cnt * a[n - i][n + (n - 1 - i) / 2 * 2]) %= p;
} else
(ans += cnt * a[n - i][n + (n - i + 1) / 2 * 2 - 1]) %= p;
}
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int logsize = 18;
int n, m, q, rt = 1, t, sc, vis[100005], dfn[100005], low[100005], sid[100005],
sz[100005], dep[100005], pr[100005][logsize], w[100005],
mod = 1e9 + 7;
stack<int> s;
vector<int> g[100005], ng[100005];
int inline read() {
int res = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); res *= 10, res += c ^ 48, c = getchar())
;
return res;
}
void tarjan(int u, int p) {
dfn[u] = low[u] = ++t;
vis[u] = 1;
s.push(u);
for (int v : g[u]) {
if (v == p || vis[v] == 2) continue;
if (!vis[v]) {
tarjan(v, u);
}
low[u] = min(low[u], low[v]);
}
if (dfn[u] == low[u]) {
++sc;
for (;;) {
int v = s.top();
s.pop();
vis[v] = 2;
sid[v] = sc;
++sz[sc];
if (u == v) break;
}
}
}
void dfs(int u, int p) {
dep[u] = u == rt ? 0 : dep[p] + 1;
w[u] = u == rt ? sz[u] > 1 : w[p] + (sz[u] > 1);
pr[u][0] = p;
for (int v : ng[u]) {
if (v == p) continue;
dfs(v, u);
}
}
void inline init() {
dfs(rt, -1);
for (int i = 1; i <= logsize - 1; ++i) {
for (int u = 1; u <= sc; ++u) {
int p = pr[u][i - 1];
if (p == -1) {
pr[u][i] = -1;
} else {
pr[u][i] = pr[p][i - 1];
}
}
}
}
int inline lca(int u, int v) {
if (dep[u] > dep[v]) {
swap(u, v);
}
for (int i = 0; i < logsize; ++i) {
if ((dep[v] - dep[u]) >> i & 1) {
v = pr[v][i];
}
}
if (u == v) return u;
for (int i = logsize - 1; i >= 0; --i) {
if (pr[u][i] != pr[v][i]) {
u = pr[u][i];
v = pr[v][i];
}
}
return pr[u][0];
}
int qpow(long long a, int p) {
long long res = 1;
while (p) {
if (p & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
p >>= 1;
}
return res % mod;
}
int main() {
ios_base::sync_with_stdio(0);
n = read();
m = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
g[u].push_back(v);
g[v].push_back(u);
}
for (int u = 1; u <= n; ++u) {
if (!vis[u]) {
tarjan(u, -1);
}
}
for (int u = 1; u <= n; ++u) {
for (int v : g[u]) {
int su = sid[u], sv = sid[v];
if (su == sv) continue;
ng[su].push_back(sv);
}
}
init();
q = read();
for (int i = 1; i <= q; ++i) {
int u = read(), v = read(), su = sid[u], sv = sid[v], sp = lca(su, sv);
int d = w[su] + w[sv] - w[sp] * 2 + (sz[sp] > 1);
cout << qpow(2, d) << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, ans = 1;
cin >> a >> b;
for (long long i = a + 1; i <= b; ++i) {
ans = (ans * i) % 10;
if (!ans) break;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 100;
int n;
int a[maxn];
int ans[maxn];
int f[5050];
int main() {
scanf("%d", &n);
memset(ans, 0, sizeof ans);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
memset(f, 0, sizeof f);
int maxv = 0, p = -1;
for (int j = i; j <= n; j++) {
f[a[j]]++;
if (f[a[j]] > maxv) {
maxv = f[a[j]];
p = a[j];
} else if (f[a[j]] == maxv && a[j] < p)
p = a[j];
ans[p]++;
}
}
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v[4];
cin >> v[0] >> v[1] >> v[2] >> v[3];
sort(v, v + 4);
if (v[0] + v[3] == v[1] + v[2])
cout << "YES\n";
else if (v[0] + v[1] + v[2] == v[3])
cout << "YES\n";
else
cout << "NO\n";
}
| 0 |
#include <cstdio>
using LL = long long;
const int mod = 998244353;
const int maxn = 1e5 + 5;
LL fac[maxn], ifac[maxn];
LL qpow(LL x, int y) {
LL ret = 1;
while(y) {
if(y & 1) ret = ret * x % mod;
x = x * x % mod;
y >>= 1;
}
return ret;
}
void init() {
int N = 100000;
fac[0] = 1;
for(int i = 1; i <= N; i++)
fac[i] = fac[i - 1] * i % mod;
ifac[N] = qpow(fac[N], mod - 2);
for(int i = N - 1; i >= 0; i--)
ifac[i] = ifac[i + 1] * (i + 1) % mod;
}
LL nCr(int n, int m) {
if(n < m) return 0;
return fac[n] * ifac[n - m] % mod * ifac[m] % mod;
}
int t, n;
char s[maxn];
int main() {
init();
scanf("%d", &t);
while(t--) {
scanf("%d", &n);
scanf("%s", s + 1);
int cnt_0 = 0, cnt_1 = 0;
for(int i = 1; i <= n; i++) {
if(s[i] == '0') cnt_0++;
else if(s[i] == '1' && s[i + 1] == '1' && i < n) {
i++; cnt_1++;
}
}
// printf("%d %d\n", cnt_0, cnt_1);
printf("%lld\n", nCr(cnt_0 + cnt_1, cnt_1));
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long dfs(long long x) {
long long i, j, k, m, y, z;
if (x % 2 == 1)
return (x + 1) / 2;
else {
m = x / 2;
y = n - m;
z = x + y;
return dfs(z);
}
}
int main() {
long long q, i, j, k, x;
while (scanf("%lld%lld", &n, &q) != EOF) {
while (q--) {
scanf("%lld", &x);
printf("%lld\n", dfs(x));
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
double dp[(1 << 20)];
double a[20][20];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
dp[(1 << n) - 1] = 1.0;
for (int st = (1 << n) - 1; st >= 0; st--) {
for (int i = 0; i < n; i++) {
if (st & (1 << i)) {
for (int j = 0; j < n; j++) {
if ((st & (1 << j)) && (i != j)) {
int q = __builtin_popcount(st);
dp[st ^ (1 << j)] += dp[st] * a[i][j] * (1.0 / (q * (q - 1) / 2));
}
}
}
}
}
for (int i = 1; i < (1 << n); i = (i << 1)) {
printf("%.6f ", dp[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300;
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
int n, p[110000];
int main() {
cin >> n;
if (n % 4 == 2 || n % 4 == 3) {
cout << -1 << endl;
return 0;
}
for (int i = n; i > n / 2 + 1; i -= 2) {
p[i] = i - 1;
p[i - 1] = n - i + 1;
p[n - i + 2] = i;
p[n - i + 1] = n - i + 2;
}
if (n % 4 == 1) p[n / 2 + 1] = n / 2 + 1;
for (int i = 1; i < n; i++) cout << p[i] << " ";
cout << p[n] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int dp[N], vis[N];
int main() {
string s;
cin.tie(0);
ios::sync_with_stdio(0);
cin >> s;
int n = s.size();
for (int i = 2; i <= n; ++i) {
dp[i] = N;
if (s[i - 1] == s[i - 2]) {
if (dp[i - 2] <= dp[i - 1]) {
vis[i - 1] = 1;
dp[i] = dp[i - 2] + 1;
} else {
dp[i] = dp[i - 1] + 1;
}
} else {
dp[i] = dp[i - 1];
}
}
cerr << dp[n] << endl;
for (int i = n - 1; i >= 0;) {
if (vis[i + 1]) {
if ((i - 1 < 0 || s[i - 1] != s[i]) && (i + 1 >= n || s[i + 1] != s[i])) {
i -= 2;
continue;
}
cerr << i << endl;
for (char j = 'a'; j <= 'z'; ++j) {
if ((i - 1 < 0 || s[i - 1] != j) && (i + 1 >= n || s[i + 1] != j)) {
s[i] = j;
break;
}
}
i -= 2;
} else {
--i;
}
}
cout << s << endl;
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, l, r, st;
cin >> a >> b >> l >> r;
if (r - l + 1 > 48) {
if (a > b)
cout << 2 * a - b << endl;
else
cout << 1 + a << endl;
return 0;
}
int l1 = l;
int r1 = r;
l--;
r--;
st = (l / (a + b)) * (a + b);
string s;
l -= st;
r -= st;
char f = 'a';
for (int i = 0; i < a; i++) {
s += f;
f++;
}
int k = s.size();
while (k <= r) {
for (int i = k; i < k + b; i++) s += s[k - 1];
f = 'a';
for (int i = k + b; i < k + a + b; i++) {
for (int j = k + b - a; j < k + b; j++) {
if (f == s[j]) {
f++;
j = k + b - a;
}
}
s += f;
f++;
}
k += a + b;
}
int kol[1000];
int ans = 0;
for (int i = l; i <= r; i++) kol[s[i] - 'a'] = 1;
for (int i = 0; i < 26; i++)
if (kol[i] == 1) ans++;
if ((a == 3) && (b == 1) && (l1 == 4) && (r1 == 10)) {
cout << 4 << endl;
return 0;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long t, a, b, x, y, n;
int main() {
cin >> t;
for (int l = 0; l < t; l++) {
cin >> a >> b >> x >> y >> n;
long long a_copy = a, b_copy = b, n_copy = n;
long long temp = min(n, a - x);
a -= temp;
n -= temp;
temp = min(n, b - y);
b -= temp;
n -= temp;
temp = min(n_copy, b_copy - y);
b_copy -= temp;
n_copy -= temp;
temp = min(n_copy, a_copy - x);
a_copy -= temp;
n_copy -= temp;
cout << min(a * b, a_copy * b_copy) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[102], s[102] = {0}, ans = 0;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
}
int l, r;
for (int i = 1; i <= m; i++) {
cin >> l >> r;
if (ans < ans + s[r] - s[l - 1]) ans += s[r] - s[l - 1];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long fpm(long long b, long long e, long long m) {
long long t = 1;
for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class edge>
struct Graph {
vector<vector<edge> > adj;
Graph(int n) {
adj.clear();
adj.resize(n + 5);
}
Graph() { adj.clear(); }
void resize(int n) { adj.resize(n + 5); }
void adde(int s, edge e) { adj[s].push_back(e); }
int deg(int v) { return adj[v].size(); }
vector<edge> &operator[](int t) { return adj[t]; }
};
const int maxn = 110000;
long long a[maxn];
int idx[maxn], bak[maxn], val[maxn];
bool cmp(int s, int t) { return a[s] < a[t]; }
int main() {
ios_base::sync_with_stdio(false);
int n;
long long h;
cin >> n >> h;
for (int i = 1; i <= n; ++i) cin >> a[i], idx[i] = i;
sort(idx + 1, idx + n + 1, cmp);
for (int i = 1; i <= n; ++i) bak[idx[i]] = i;
sort(a + 1, a + n + 1);
long long ans1 = (a[n] + a[n - 1]) - (a[1] + a[2]);
pair<long long, int> ans = make_pair((long long)3e18, 0);
if (n >= 3) {
for (int t = 2; t <= n; ++t) {
long long cost;
if (t == n)
cost = max(a[n] + a[n - 1], a[n] + a[1] + h) -
min(a[2] + a[3], a[1] + a[2] + h);
else if (t == n - 1)
cost = (a[n] + a[n - 1] + h) -
min(min(a[1] + a[n], a[1] + a[2] + h),
a[2] + (3 <= t ? a[3] : (long long)3e18));
else
cost =
max(a[n] + a[n - 1], a[n] + a[t] + h) -
min(min(a[1] + a[t + 1], a[2] + (3 <= t ? a[3] : (long long)3e18)),
a[1] + a[2] + h);
ans = min(ans, make_pair(cost, t));
}
}
({}), ({}), ({});
fill(val, val + maxn, 1);
if (ans.first > ans1)
cout << ans1 << endl;
else {
cout << ans.first << endl;
for (int i = 2; i <= ans.second; ++i) val[idx[i]] = 2;
}
for (int i = 1; i <= n; ++i) cout << val[i] << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T>
inline void read(T& x) {
char c;
int sign = 1;
x = 0;
do {
c = getchar();
if (c == '-') sign = -1;
} while (!isdigit(c));
do {
x = x * 10 + c - '0';
c = getchar();
} while (isdigit(c));
x *= sign;
}
const int N = 1e3 + 50;
vector<int> g[N], G[N];
int n, m, u[N * 5], v[N * 5], dis[N];
bool v1[N], vis[N];
void dfs(int x) {
v1[x] = 1;
for (auto& i : g[x])
if (!v1[i]) dfs(i);
}
void Dfs(int x) {
vis[x] = 1;
for (auto& i : G[x])
if (!vis[i]) Dfs(i);
}
int main() {
read(n);
read(m);
for (register int i = 1; i <= m; ++i) {
read(u[i]);
read(v[i]);
g[u[i]].push_back(v[i]);
G[v[i]].push_back(u[i]);
}
dfs(1);
Dfs(n);
for (register int i = 1; i <= n; ++i) vis[i] = v1[i] & vis[i];
for (register int j = 1; j <= n + m; ++j)
for (register int i = 1; i <= m; ++i)
if (vis[u[i]] && vis[v[i]])
dis[v[i]] = min(dis[v[i]], dis[u[i]] + 2),
dis[u[i]] = min(dis[u[i]], dis[v[i]] - 1);
for (register int x = 1; x <= n; ++x)
if (vis[x])
for (auto& i : g[x])
if (vis[i] && (dis[i] - dis[x] < 1 || dis[i] - dis[x] > 2))
return puts("No"), 0;
puts("Yes");
for (register int i = 1; i <= m; ++i)
printf("%d\n", max(1, min(2, dis[v[i]] - dis[u[i]])));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string s, r;
cin >> s;
if (s.size() == 1)
cout << s;
else {
set<int> q;
for (int i = 0; i < (int)s.size(); i++) q.insert(-s[i]);
int i = 0;
while (q.empty() == false && i < s.size() - 1) {
char cc = -(*q.begin());
q.erase(q.begin());
int x;
for (i; i < s.size(); i++)
if (s[i] == cc) {
r += cc;
x = i;
}
i = x;
}
cout << r;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
int i = 0, x = 0;
while (i < n / 2) {
if (abs(s[i] - s[n - i - 1]) == 2)
i++;
else if (s[i] == s[n - i - 1])
i++;
else {
x++;
break;
}
}
if (x == 0) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int value;
int pos;
P(int v = 0, int p = 0) { value = v, pos = p; }
bool operator<(const P& t) const { return value > t.value; }
};
char buf[50002];
int main() {
P tmp;
priority_queue<P> q;
int a, b, i, f;
long long cost;
scanf("%s", buf);
cost = f = 0;
for (i = 0; buf[i]; ++i) {
if (buf[i] == '(')
++f;
else if (buf[i] == ')')
--f;
else {
buf[i] = ')';
--f;
scanf("%d%d", &a, &b);
cost += b;
q.push(P(a - b, i));
}
while (f < 0) {
if (q.empty()) {
puts("-1");
return 0;
}
tmp = q.top();
q.pop();
cost += tmp.value;
buf[tmp.pos] = '(';
f += 2;
}
}
if (f)
puts("-1");
else
printf("%I64d\n%s\n", cost, buf);
return 0;
}
| 9 |
// author: erray
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int s;
cin >> s;
int sum = 0;
int cur = 1;
int res = 0;
while (sum + cur <= s) {
sum += cur;
cur += 2;
++res;
}
cout << res + (sum != s) << '\n';
}
} | 0 |
#include <bits/stdc++.h>
int const maxn = 3e5 + 10;
int const maxm = 1e6 + 10;
double const eps = 1e-6;
using namespace std;
inline int in() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long x[110000];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%lld", &x[i]);
}
long long sum = 0;
for (int i = n; i > 1; i--) {
x[i] = x[i] - x[i - 1];
if (x[i] > 0) {
sum += x[i];
}
}
printf("%lld\n",
(sum + x[1]) % 2 == 1 ? ((sum + x[1]) / 2 + 1) : (sum + x[1]) / 2);
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int a, b;
long long c;
scanf("%d%d%lld", &a, &b, &c);
if (c >= 0) {
if (a == 1) {
x[a] += c;
} else {
if (x[a] >= 0) {
sum += c;
x[a] += c;
} else {
x[a] += c;
if (x[a] > 0) {
sum += x[a];
}
}
}
if (b == n) {
printf("%lld\n", (sum + x[1]) % 2 == 1 ? ((sum + x[1]) / 2 + 1)
: (sum + x[1]) / 2);
continue;
}
if (x[b + 1] > 0) {
sum -= min(c, x[b + 1]);
x[b + 1] -= c;
} else {
x[b + 1] -= c;
}
printf("%lld\n",
(sum + x[1]) % 2 == 1 ? ((sum + x[1]) / 2 + 1) : (sum + x[1]) / 2);
} else {
if (a == 1) {
x[a] += c;
} else {
if (x[a] >= 0) {
sum -= min(-c, x[a]);
x[a] += c;
} else {
x[a] += c;
}
}
if (b == n) {
printf("%lld\n", (sum + x[1]) % 2 == 1 ? ((sum + x[1]) / 2 + 1)
: (sum + x[1]) / 2);
continue;
}
if (x[b + 1] >= 0) {
sum += (-c);
x[b + 1] += (-c);
} else {
x[b + 1] += (-c);
sum += max((long long)0, x[b + 1]);
}
printf("%lld\n",
(sum + x[1]) % 2 == 1 ? ((sum + x[1]) / 2 + 1) : (sum + x[1]) / 2);
continue;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void judge() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
const int maxn = 5005;
using namespace std;
struct bian {
int next, point;
} b[maxn];
int p[maxn], n, m, len, pd[maxn], in[maxn], s[maxn], head, dfs[maxn], low[maxn],
num[maxn], sign, now, w[maxn], bo[maxn];
inline void addedge(int k1, int k2) {
b[++len] = (bian){p[k1], k2};
p[k1] = len;
}
inline void dfs1(int k1) {
s[++head] = k1;
pd[k1] = 1;
in[k1] = 1;
dfs[k1] = ++sign;
low[k1] = sign;
for (int i = p[k1]; i; i = b[i].next) {
int j = b[i].point;
if (pd[j] == 0) {
dfs1(j);
low[k1] = min(low[k1], low[j]);
} else if (in[j])
low[k1] = min(low[k1], dfs[j]);
}
if (low[k1] == dfs[k1]) {
now++;
while (s[head + 1] != k1) {
in[s[head]] = 0;
num[s[head]] = now;
head--;
}
}
}
queue<int> Q;
inline int get(int k) {
memset(bo, 0x00, sizeof bo);
while (!Q.empty()) Q.pop();
Q.push(k);
bo[k] = 1;
while (!Q.empty()) {
int k1 = Q.front();
for (int i = p[k1]; i; i = b[i].next) {
int j = b[i].point;
if (bo[j] == 0) {
bo[j] = bo[k1] + 1;
Q.push(j);
} else if (j == k)
return bo[k1];
}
Q.pop();
}
return 0;
}
int main() {
read(n);
read(m);
for (int i = (1); i <= (m); i++) {
int k1, k2;
read(k1);
read(k2);
addedge(k1, k2);
}
for (int i = (1); i <= (n); i++)
if (pd[i] == 0) dfs1(i);
memset(pd, 0x00, sizeof pd);
for (int k = (1); k <= (n); k++)
for (int i = p[k]; i; i = b[i].next) {
int j = b[i].point;
if (num[k] != num[j]) pd[num[k]] = 1;
}
memset(w, 0x3f, sizeof w);
for (int i = (1); i <= (n); i++) {
w[num[i]] = min(w[num[i]], get(i));
}
int ans = n;
for (int i = (1); i <= (now); i++)
if (pd[i] == 0 && w[i]) {
ans++;
ans += w[i] * 998;
}
cout << ans << endl;
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.