solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int h, w;
void paint(bitset<400>& s, int y1, int y2, int x1, int x2) {
for (int i = y1; i <= y2; ++i) s[i * w + x1] = s[i * w + x2] = true;
for (int i = x1; i <= x2; ++i) s[y1 * w + i] = s[y2 * w + i] = true;
}
int main() {
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; ++i) cin >> s[i];
vector<bool> checkY(h, true), checkX(w, true);
int tmp = 0;
for (int i = 1; i < h; ++i) {
if (s[i] == s[i - 1]) {
++tmp;
if (tmp >= 5) checkY[i - 1] = false;
} else {
tmp = 0;
}
}
tmp = 0;
for (int i = 1; i < w; ++i) {
bool same = true;
for (int j = 0; j < h; ++j) {
if (s[j][i] != s[j][i - 1]) same = false;
}
if (same) {
++tmp;
if (tmp >= 5) checkX[i - 1] = false;
} else {
tmp = 0;
}
}
for (int i = 0; i < h; ++i) {
if (s[i] == string(w, '.'))
checkY[i] = false;
else
break;
}
for (int i = h - 1; i >= 0; --i) {
if (s[i] == string(w, '.'))
checkY[i] = false;
else
break;
}
for (int i = 0; i < w; ++i) {
bool remove = true;
for (int j = 0; j < h; ++j) {
if (s[j][i] == '#') remove = false;
}
if (remove)
checkX[i] = false;
else
break;
}
for (int i = w - 1; i >= 0; --i) {
bool remove = true;
for (int j = 0; j < h; ++j) {
if (s[j][i] == '#') remove = false;
}
if (remove)
checkX[i] = false;
else
break;
}
bitset<400> bs;
int k = 0;
for (int i = 0; i < h; ++i) {
if (!checkY[i]) continue;
for (int j = 0; j < w; ++j) {
if (checkX[j]) {
if (k >= 400) {
cout << "NO" << endl;
return 0;
}
bs[k] = (s[i][j] == '#');
++k;
}
}
}
vector<int> originalY, originalX;
for (int i = 0; i < h; ++i) {
if (checkY[i]) originalY.push_back(i + 1);
}
for (int i = 0; i < w; ++i) {
if (checkX[i]) originalX.push_back(i + 1);
}
h = originalY.size();
w = originalX.size();
if (h >= 20 || w >= 20) {
cout << "NO" << endl;
return 0;
}
int y1 = 0;
for (int y2 = 2; y2 < h; ++y2) {
for (int y3 = 0; y3 < h; ++y3) {
for (int y4 = y3 + 2; y4 < h; ++y4) {
if (y2 != h - 1) y4 = h - 1;
for (int x1 = 0; x1 < w; ++x1) {
for (int x3 = 0; x3 < w; ++x3) {
if (x1 != 0 && x3 != 0) break;
for (int x2 = x1 + 2; x2 < w; ++x2) {
for (int x4 = x3 + 2; x4 < w; ++x4) {
if (x2 != w - 1) x4 = w - 1;
bitset<400> bs1;
paint(bs1, y1, y2, x1, x2);
paint(bs1, y3, y4, x3, x4);
if (bs1 == bs) {
cout << "YES" << endl;
cout << originalY[y1] << ' ' << originalX[x1] << ' '
<< originalY[y2] << ' ' << originalX[x2] << endl;
cout << originalY[y3] << ' ' << originalX[x3] << ' '
<< originalY[y4] << ' ' << originalX[x4] << endl;
return 0;
}
}
}
}
}
}
}
}
cout << "NO" << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, a[300001], ans, k, j, b, c, d;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 1; i <= n * 2; i++) {
cin >> a[i];
s += a[i] - '0';
}
while (s.size() > 0) {
for (i = 1; i < s.size(); i++) {
if (s[i] == s[0]) {
k = i;
break;
}
}
ans += k - 1;
s.erase(k, 1);
s.erase(0, 1);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
while (a--) {
int b;
cin >> b;
vector<int> vj = {};
bool avuna = true;
while (b--) {
int c;
cin >> c;
vj.push_back(c);
}
sort(vj.begin(), vj.end());
for (int i = 0; i < vj.size() - 1; i++) {
if (vj[i] == vj[i + 1] || ((vj[i] + 1) == vj[i + 1])) {
} else {
avuna = false;
}
}
avuna == true ? cout << "YES" << endl : cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[100], b[100], x = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
for (int i = 0; i < n; i++) {
x = 0;
while (a[i] > 0) {
if (a[i] % b[i] == 0) {
a[i] = a[i] / b[i];
x++;
} else {
x = x + (a[i] % b[i]);
a[i] = a[i] - (a[i] % b[i]);
}
}
cout << x << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, K;
int mo[2005];
int vis[2005];
int Pri[2005];
int mark[2005][2005];
int GCD(int a, int b) {
if (mark[a][b]) return mark[a][b];
if (!b) return a;
int t = GCD(b, a % b);
return mark[a][b] = mark[b][a] = t;
}
void Init() {
int top = 0;
mo[1] = 1;
for (int i = (2), i_end_ = (2005 - 5); i <= i_end_; i++) {
if (!vis[i]) {
Pri[++top] = i;
mo[i] = -1;
}
for (int j = 1; j <= top && Pri[j] * i <= 2005 - 5; j++) {
int t = Pri[j] * i;
vis[t] = 1;
if (i % Pri[j])
mo[t] = -mo[i];
else {
mo[t] = 0;
break;
}
}
}
}
int main() {
Init();
scanf("%d%d%d", &n, &m, &K);
long long ans = 0;
for (int k = (1), k_end_ = (K); k <= k_end_; k++) {
long long tot = 0;
for (int d = (1), d_end_ = (min(n, m)); d <= d_end_; d++) {
if (!mo[d]) continue;
long long res1 = 0, res2 = 0;
for (int i = (1), i_end_ = (n / d); i <= i_end_; i++) {
res1 = res1 + (n / d / i) * (GCD(d * i, k) == 1);
res1 %= 1073741824;
}
for (int j = (1), j_end_ = (m / d); j <= j_end_; j++) {
res2 = res2 + (m / d / j) * (GCD(d * j, k) == 1);
res2 %= 1073741824;
}
tot = (tot + res1 * res2 * mo[d]) % 1073741824;
}
ans = (ans + tot * (K / k)) % 1073741824;
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 7;
int a[N], suff[N];
int main() {
int n;
string s;
cin >> n >> s;
for (int i = 1; i <= n; i++) {
a[i] = a[i - 1] + (s[i - 1] == '(') - (s[i - 1] == ')');
}
int cnt = 0;
suff[n] = a[n];
for (int i = n - 1; i >= 1; i--) {
suff[i] = min(a[i], suff[i + 1]);
}
for (int i = 1; i <= n; i++) {
if (s[i - 1] == '(') {
if (a[n] == +2 && suff[i] - 2 >= 0) ++cnt;
} else {
if (a[n] == -2 && suff[i] + 2 >= 0) ++cnt;
}
if (a[i] < 0) break;
}
cout << cnt << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int chh;
const int N = 2000, MOD = 1000000007;
int n, k;
int a[N];
inline void in(int &t) {
int n = 0, s = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') s = -1, ch = getchar();
while (ch >= '0' && ch <= '9') n = n * 10 + ch - '0', ch = getchar();
t = n * s;
}
long long power(long long a, long long b, long long n) {
long long res = 1;
for (; b; b >>= 1, a = a * a % n)
if (b & 1) res = res * a % n;
return res;
}
long long cal(long long n, long long r, long long p) {
long long i, res = 1, re;
for (i = 1; i <= r; i++) {
res = res * (n - i + 1) % p;
re = power(i, p - 2, p);
res = res * re % p;
}
return res;
}
long long lucas(long long n, long long m, long long p) {
if (n < m)
return 0;
else
return cal(n, m, p);
}
int val[N], ans[N];
int main() {
int i, j, t;
long long tmp, tt;
in(n), in(k);
for (i = 0; i < n; i++) in(val[i]);
for (i = 0; i < n; i++) a[i] = (int)cal(k - 1 + i, i, MOD);
for (i = 0; i < n; i++) {
ans[i] = 0;
for (j = i; j >= 0; j--) {
ans[i] = ((long long)ans[i] + (long long)a[i - j] * val[j]) % MOD;
}
}
for (i = 0; i < n - 1; i++) printf("%d ", ans[i]);
printf("%d\n", ans[n - 1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3000005;
int a[N], b[N], c[N], s[N], n, m, q;
vector<int> v;
struct node {
int sum, tag, val;
} tr[N];
void pushdown(int k) {
if (tr[k].tag == 0) {
tr[k].tag = -1;
tr[k << 1].tag = tr[k << 1 | 1].tag = 0;
tr[k << 1].val = 0;
tr[k << 1 | 1].val = 0;
}
if (tr[k].tag == 1) {
tr[k].tag = -1;
tr[k << 1].tag = tr[k << 1 | 1].tag = 1;
tr[k << 1].val = tr[k << 1].sum;
tr[k << 1 | 1].val = tr[k << 1 | 1].sum;
}
}
void build(int k, int l, int r) {
tr[k].tag = -1;
if (l == r) {
tr[k].sum = tr[k].val = s[l];
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
tr[k].sum = tr[k << 1].sum + tr[k << 1 | 1].sum;
tr[k].val = tr[k << 1].val + tr[k << 1 | 1].val;
}
void update(int k, int l, int r, int a, int b, int v) {
if (l == a && r == b) {
tr[k].val = tr[k].sum * v;
tr[k].tag = v;
return;
}
pushdown(k);
int mid = l + r >> 1;
if (b <= mid)
update(k << 1, l, mid, a, b, v);
else if (a > mid)
update(k << 1 | 1, mid + 1, r, a, b, v);
else
update(k << 1, l, mid, a, mid, v),
update(k << 1 | 1, mid + 1, r, mid + 1, b, v);
tr[k].val = tr[k << 1].val + tr[k << 1 | 1].val;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
v.push_back(a[i]);
v.push_back(b[i] + 1);
c[i]--;
}
v.push_back(1);
v.push_back(n + 1);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
m = v.size();
for (int i = 0; i < v.size() - 1; i++) s[i + 1] = v[i + 1] - v[i];
for (int i = 1; i <= q; i++) {
a[i] = lower_bound(v.begin(), v.end(), a[i]) - v.begin() + 1;
b[i] = lower_bound(v.begin(), v.end(), b[i] + 1) - v.begin();
}
build(1, 1, m);
for (int i = 1; i <= q; i++) {
update(1, 1, m, a[i], b[i], c[i]);
printf("%d\n", tr[1].val);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long findbit(long long x, long long y) {
if (x & (1 << (y - 1)))
return 1;
else
return 0;
}
int checkprime(int x) {
if (x == 2) return 1;
if (x % 2 == 0) return 0;
for (int j = 3; j <= sqrt(x); j += 2)
if (x % j == 0) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
bool flag = true;
if (a * c != b * d) {
cout << "NO" << endl;
continue;
}
int s;
for (s = 1; s < b; s++) {
if (s * a % b == 0) break;
}
vector<vector<int> > v(a, vector<int>(b, 0));
for (int i = 0, dx = 0; i < a; i++, dx += s) {
for (int j = 0; j < c; j++) {
v[i][(j + dx) % b] = 1;
}
}
cout << "YES" << endl;
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
cout << v[i][j];
}
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int B = 255;
using std::max;
const int MAXN = 2e5 + 7;
int n, m;
int a[MAXN];
int home[MAXN], nxt[MAXN], to[MAXN], ccnt;
inline void ct(int x, int y) {
ccnt++;
nxt[ccnt] = home[x];
to[ccnt] = y;
home[x] = ccnt;
}
int dep[MAXN], fa[MAXN];
inline void dfs(int u, int F) {
fa[u] = F;
for (int i = home[u]; i; i = nxt[i]) {
int v = to[i];
if (v == F) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
}
return;
}
int ch[MAXN][2], T, f[MAXN][B + 10], gp[MAXN];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1, x, y; i < n; ++i) {
scanf("%d%d", &x, &y);
ct(x, y);
ct(y, x);
}
dfs(1, 0);
for (int i = 1, x; i <= n; ++i) {
if (dep[i] >= B) {
x = i;
ch[0][0] = 0;
ch[0][1] = 0;
T = 0;
for (int j = 0; j <= B; ++j, x = fa[x]) {
int t = a[x] ^ j;
int nw = 0;
for (int k = 16; k >= 0; --k) {
int c = (t >> k) & 1;
if (!ch[nw][c]) {
ch[nw][c] = ++T;
ch[T][0] = ch[T][1] = 0;
}
nw = ch[nw][c];
}
}
for (int j = 0; j <= B; ++j) {
int t = j << 8;
int nw = 0, S = 0;
for (int k = 16; k >= 0; --k) {
int c = (t >> k) & 1;
if (ch[nw][c ^ 1]) {
nw = ch[nw][c ^ 1];
S += (1 << k);
} else
nw = ch[nw][c];
}
f[i][j] = S;
}
gp[i] = x;
}
}
for (int i = 1, x, y; i <= m; ++i) {
scanf("%d%d", &x, &y);
int ans = 0;
int qwq = 0;
int st = dep[y];
while (dep[y] - dep[x] >= B) {
ans = max(f[y][qwq], ans);
++qwq;
y = gp[y];
}
for (qwq = qwq * 256; y != fa[x]; qwq++) {
ans = max(ans, a[y] ^ qwq);
y = fa[y];
}
printf("%d\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
bool qwq(vector<int>& ans, vector<int>& l, vector<int>& r, int pos) {
int cntl = 0, cntr = 0;
for (int i = 0; i < pos; ++i) {
cntl += ans[i] > ans[pos];
}
for (int i = pos + 1; i < (int)ans.size(); ++i) {
cntr += ans[i] > ans[pos];
}
return ((cntl == l[pos]) && (cntr == r[pos]));
}
bool check(vector<int>& ans, vector<int>& l, vector<int>& r) {
for (int i = 0; i < (int)ans.size(); ++i) {
if (!qwq(ans, l, r, i)) return false;
}
return true;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> l, r;
for (int a, i = 1; i <= n; ++i) {
cin >> a;
l.push_back(a);
}
for (int a, i = 1; i <= n; ++i) {
cin >> a;
r.push_back(a);
}
vector<int> ans;
int sign = true;
for (int i = 0; i < n; ++i) {
int tmp = n - (l[i] + r[i]);
ans.push_back(tmp);
if (tmp <= 0) sign = false;
}
if (!sign || !check(ans, l, r)) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int i = 0; i < n; ++i) {
cout << ans[i] << (i == n - 1 ? '\n' : ' ');
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 123, inf = 1e9, mod = 1e9 + 7;
const long long INF = 1e18;
void solve() {
long long a, b, c, d;
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
long long x = (c + d - 1) / d;
if (a - c * b > 0) printf("-1\n");
if (a - c * b == 0) printf("%lld\n", x * c * b - x * (x - 1) / 2 * d * b);
if (a - c * b < 0) {
long long y = (a + a + d * b) / (d * b + d * b);
y = min(y, x);
long long ans = 0;
for (long long i = max(0ll, y - 100); i <= min(x, y + 100); i++) {
ans = max(ans, i * a - i * (i - 1) / 2 * d * b);
}
printf("%lld\n", ans);
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans;
int t, p;
cin >> t;
while (t--) {
cin >> n;
ans = n * (n + 1) / 2;
p = 1;
while (p <= n) {
ans -= 2 * p;
p *= 2;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
const int maxn = 3 * 100 + 5;
const int INF = 1e9 + 7;
vector<int> Adj[maxn], Adj1[maxn];
long long a[maxn], visit[maxn], val[maxn];
long long f = 0, curr;
void dfs(int node) {
visit[node] = 1;
for (int i = (0); i < (Adj[node].size()); i++) {
int u = Adj[node][i];
if (visit[u] && u == curr) {
f = 1;
}
if (!visit[u]) dfs(u);
}
return;
}
long long ret = 0;
void dfs1(int node, int lev) {
for (int i = (0); i < (Adj[node].size()); i++) {
int u = Adj[node][i];
ret += a[u];
dfs1(u, lev + 1);
}
}
long long chk[maxn];
long long dp[302][100001];
inline void solve(void) {
long long n, q, t, x, y;
cin >> n >> q >> t;
for (int i = (1); i < (n + 1); i++) cin >> a[i];
for (int i = (0); i < (q); i++) {
cin >> x >> y;
Adj[y].push_back(x);
Adj1[x].push_back(y);
chk[x] = 1;
}
for (int i = (1); i < (n + 1); i++) {
if (!visit[i]) {
curr = i;
dfs(i);
}
}
if (f) {
cout << "0\n";
return;
}
for (int i = (1); i < (n + 1); i++) {
ret = a[i];
dfs1(i, 1);
val[i] = ret;
}
for (int i = 1; i <= n; i++) {
if (chk[i] == 1) {
t -= val[i];
}
}
if (t < 0) {
cout << "0\n";
return;
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int k = 0; k <= t; k++) {
dp[i][k] = dp[i - 1][k];
if (k >= val[i]) dp[i][k] = (dp[i][k] + dp[i][k - val[i]]) % 1000000007;
}
}
cout << dp[n][t];
return;
}
void init() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
int main(int argc, const char *argv[]) {
init();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int maxn = 1 << 17;
const int inf = 1000000007;
const int mod = 1000000007;
string s;
int fastsolve() {
int n = s.length();
if (s == "MFFFM") s = s;
int a = -2, t = 0, cnt = 0;
int was = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'F') {
if (was == 2) {
int when = i - a - 1;
int nt = max(0, t - when + 1);
ans = max(ans, i - cnt + nt);
t = nt;
}
a = i;
cnt += s[i] == 'F';
if (was == 1) {
ans = i - cnt + 1;
was = 2;
}
} else
was = max(was, 1);
}
return ans;
if (cnt == 0 || cnt == n) return 0;
return t + a - cnt + 1;
}
void gen() {
int n = rand() % 100 + 1;
s = "";
for (int i = 0; i < n; i++) {
if (rand() % 2)
s += 'F';
else
s += 'M';
}
}
int slowsolve() {
string S = s;
int n = S.length();
for (int ans = 0; ans < 1e9; ans++) {
bool ok = 1;
for (int i = n - 1; i > 0; i--) {
if (S[i] == 'F' && S[i - 1] == 'M') {
swap(S[i], S[i - 1]);
i--;
ok = 0;
}
}
if (ok) return ans;
}
}
void stress(bool f) {
if (!f) return;
for (int it = 0; it < 10000; it++) {
gen();
int ans1 = fastsolve();
int ans2 = slowsolve();
if (ans1 != ans2) {
cout << ans1 << " " << ans2 << endl << s << endl;
break;
}
cerr << it << " " << s.length() << " " << ans1 << endl;
}
exit(0);
}
int main() {
stress(0);
while (cin >> s) {
cout << fastsolve() << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
const int maxn = 2e5 + 10;
const int maxm = 1e6 + 10;
const long long mod = 998244353;
int p[maxn], b[maxn], du[maxn];
vector<int> vec;
int vis[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
b[i] = p[i];
if (i != p[i])
du[i]++;
else
vec.push_back(i);
}
if (vec.size() == 0) {
int now = 1;
while (!vis[p[now]]) {
vis[now] = 1;
now = p[now];
}
p[now] = now;
int rt = now;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
now = i;
while (1) {
vis[now] = i;
if (vis[p[now]] && vis[p[now]] != i)
break;
else if (vis[p[now]] == i) {
p[now] = rt;
break;
}
now = p[now];
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (p[i] != b[i]) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
return 0;
}
int rt = -1;
for (int i = 0; i < vec.size(); i++)
if (du[vec[i]] == 0) rt = vec[i];
if (rt == -1) {
for (int i = 1; i <= n; i++)
if (du[i] == 0) rt = i;
}
p[rt] = rt;
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
int now = i;
while (1) {
vis[now] = i;
if (vis[p[now]] && vis[p[now]] != i)
break;
else if (vis[p[now]] == i) {
p[now] = rt;
break;
}
now = p[now];
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (p[i] != b[i]) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 1e6 + 5;
const int INF = 0x7fffffff;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
int n, in[maxn];
long long w[maxn], ans, dp[maxn];
int used[maxn];
struct two {
long long to, c;
};
int k;
vector<two> G[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
}
two t;
for (int i = 0; i < n - 1; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
t.c = c;
t.to = v;
G[u].push_back(t);
t.to = u;
G[v].push_back(t);
in[u]++;
in[v]++;
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (in[i] <= 1) {
q.push(i);
}
}
long long max1 = 0, max2 = 0;
long long ans = 0;
while (q.size()) {
int node = q.front();
q.pop();
max1 = max2 = 0;
for (auto i : G[node]) {
if (used[i.to] == 1) {
long long temp = dp[i.to] - i.c;
if (temp > max1) {
swap(max1, temp);
}
if (temp > max2) {
swap(max2, temp);
}
} else {
in[i.to]--;
if (in[i.to] <= 1) {
q.push(i.to);
}
}
}
used[node] = 1;
long long temp = max1 + max2 + w[node];
ans = max(ans, temp);
dp[node] = temp - max2;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > h;
int main() {
long long int n;
cin >> n;
long long int a, b;
for (long long int i = 0; i < ((long long int)(n)); i++) {
cin >> a >> b;
h.push_back(make_pair(a, b));
}
sort((h).begin(), (h).end());
long long int ma = h[0].second;
long long int res = 0;
for (long long int i = (long long int)(1); i < ((long long int)(n)); i++) {
if (h[i].second < ma)
res++;
else
ma = h[i].second;
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dis(int a, int b, int c, int d) {
return (a - b) * (a - b) + (c - d) * (c - d);
}
int main() {
int n, m, d, t, x, y, shift = 0, check = 0, ans = 0;
int cap[128] = {0}, lo[28] = {0};
char s[500005], a[31][31];
scanf("%d%d%d", &n, &m, &d);
for (int i = 0; i < n; i++) {
scanf("%s", &a[i]);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (a[i][j] == 'S') {
shift = 1;
for (x = 0; x < n; x++)
for (y = 0; y < m; y++) {
if (dis(i, x, j, y) <= d * d) cap[(int)a[x][y]] = 1;
}
} else
lo[(int)a[i][j]] = 1;
}
cin >> t;
cin >> s;
for (int i = 0; s[i]; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') {
if (shift == 0 || lo[s[i] + 32] == 0) {
check = 1;
break;
}
ans = ans + !cap[s[i] + 32];
} else if (lo[(int)s[i]] == 0) {
check = 1;
break;
}
}
if (check)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int len = s.length();
int flag = 0;
int first, second;
for (int i = 0; i < len; i++) {
if (s[i] == 'a' && !flag) continue;
if (flag && s[i] == 'a') break;
flag = 1;
int aa = (int)s[i];
aa--;
s[i] = (char)aa;
}
if (!flag) {
s[len - 1] = 'z';
}
cout << s;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
string s;
cin >> s;
int n;
cin >> n;
bool fl2, fl1;
fl1 = fl2 = false;
while (n--) {
string tpl;
cin >> tpl;
if (tpl == s) {
cout << "YES";
return 0;
}
if (tpl[0] == s[1]) {
fl2 = true;
}
if (tpl[1] == s[0]) {
fl1 = true;
}
if (fl1 && fl2) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans = 0, i, n;
map<char, int> class_1;
map<char, int> class_2;
cin >> n;
string names[n];
for (i = 0; i < n; i++) {
cin >> names[i];
}
for (i = 0; i < n; i++) {
if (class_1[names[i][0]] > class_2[names[i][0]])
class_2[names[i][0]]++;
else
class_1[names[i][0]]++;
}
for (map<char, int>::iterator it = class_1.begin(); it != class_1.end();
it++) {
if (it->second != 0) {
ans += it->second * (it->second - 1) / 2;
}
}
for (map<char, int>::iterator it = class_2.begin(); it != class_2.end();
it++) {
if (it->second != 0) {
ans += it->second * (it->second - 1) / 2;
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 11;
const int MAXN = 1e5 + 5;
const int LG = 20;
const int INF = 1e9;
using ll = long long int;
using ull = unsigned long long int;
const ll MOD2 = 998244353;
const ll MOD1 = 1e9 + 7LL;
ll *inv;
template <typename T>
T power(T a, T b, T mod = MOD1) {
T r = 1LL;
while (b) {
if (b & 1LL) {
r = (r * a) % mod;
}
a = (a * a) % mod;
b >>= 1LL;
}
return r;
}
void inversions() {
inv = new ll[maxn];
inv[0] = 0;
for (int i = 1; i < maxn; ++i) {
inv[i] = power((ll)i, MOD1 - 2LL);
}
}
template <typename T>
T gcd(T a, T b) {
while (b) {
T t = b % a;
a = b;
b = t;
}
return a;
}
ll fact[MAXN * 5];
void computefact() {
fact[0] = 1;
for (ll i = 1; i < MAXN * 5; ++i) {
fact[i] = (fact[i - 1] * i) % MOD2;
}
}
ll ncr(ll n, ll r) {
if (n < r) return 0;
ll answer = fact[n];
answer = (answer * power<ll>(fact[r], MOD2 - 2LL, MOD2)) % MOD2;
answer = (answer * power<ll>(fact[n - r], MOD2 - 2LL, MOD2)) % MOD2;
return answer;
}
void test() {
vector<int> arr({3, 9, 6, 12, 36});
for (int num = 123; num <= 124254; ++num) {
int val = num;
for (int m : arr) val %= m;
do {
int tmp = num;
for (int m : arr) tmp %= m;
if (tmp != val) {
cerr << "For X = " << num << " ";
for (int m : arr) cerr << m << " ";
cerr << "\n";
}
} while (next_permutation(arr.begin(), arr.end()));
reverse(arr.begin(), arr.end());
}
}
ll countMultiples(ll l, ll r, ll of) { return (r / of) - (l - 1) / of; }
int main() {
computefact();
int n, k;
scanf("%d", &n);
scanf("%d", &k);
ll answer = 0;
for (int i = 1; i <= n; ++i) {
ll N = countMultiples(i + 1, n, i);
if (N >= k - 1) {
answer = (answer + ncr(N, k - 1)) % MOD2;
}
}
printf("%lld", answer);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a, b, p, m;
int main() {
cin >> a >> b;
if (a == 5) {
cout << ">...v" << endl
<< "v.<.." << endl
<< "..^.." << endl
<< ">...." << endl
<< "..^.<" << endl
<< "1 1";
}
if (a == 3) {
cout << ">vv" << endl << "^<." << endl << "^.<" << endl << "1 3";
}
if (a == 100) {
for (int i = 0; i < 100; i++) {
if (i == 0) {
cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.>.>.>.>.>.>.>.>.>.>.>.>.>"
".>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.v.v.v.v"
<< endl;
} else if (i == 99) {
cout << "^.^.^.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<."
"<.<.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
<< endl;
} else if (i % 2 == 0) {
cout << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.>.>.>.>.>.>.>.>.>.>.>.>.>"
".>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>v."
<< endl;
} else if (i % 2 == 1) {
cout << "^v<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<."
"<.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<."
<< endl;
}
}
cout << "100 99";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > tim;
long long fac[300005] = {}, ans = 0;
long long power(long long x, long long y) {
long long res = 1;
x = x % 998244353;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res;
}
void calfac(long long n, long long k) {
long long i, j;
fac[k] = 1;
for (i = k + 1; i <= n; i++) {
fac[i] = (fac[i - 1] * i) % 998244353;
fac[i] = (fac[i] * (power(i - k, 998244353 - 2) % 998244353)) % 998244353;
}
}
bool cmp(const pair<long long, long long>& x,
const pair<long long, long long>& y) {
if (x.first != y.first) return x.first < y.first;
return x.second > y.second;
}
int main() {
long long n, k, i, j, x, y, cnt = 0, m;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> x >> y;
tim.push_back(make_pair(x, i));
tim.push_back(make_pair(y, -i));
}
sort(tim.begin(), tim.end(), cmp);
calfac(n, k - 1);
m = tim.size();
for (i = 0; i < m; i++) {
if (tim[i].second < 0)
cnt--;
else {
cnt++;
if (cnt >= k) ans = (ans + fac[cnt - 1]) % 998244353;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
long long int pre = 0;
int counter = 0;
while (counter < n && arr[counter] != 0) {
pre++;
counter++;
}
long long int post = 0;
counter = n - 1;
while (counter >= 0 && arr[counter] != 0) {
counter--;
post++;
}
counter = 0;
long long int mx = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == 0) {
if (mx < counter) mx = counter;
counter = 0;
} else {
counter++;
}
}
if (counter > mx) mx = counter;
if (mx < pre + post) mx = pre + post;
cout << mx << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[100100] = {0};
bool sp[100100] = {0};
long long ans = 0;
long long sum = 0;
cin >> a[1];
sum += a[1];
for (long long i = 2; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
long long sumk = 0;
for (long long i = 1; i <= k; i++) {
long long d;
cin >> d;
sp[d] = true;
sumk += a[d];
}
if (n == 1) {
cout << 0 << endl;
exit(0);
}
if (n == 2) {
cout << a[1] * a[2] << endl;
exit(0);
}
long long y;
for (long long i = 1; i <= n; i++) {
if (sp[i]) {
ans += a[i] * (sum - a[i]);
} else {
if (i == 1) {
ans += a[1] * a[2] + a[1] * a[n];
y = sumk;
if (sp[2]) y = y - a[2];
if (sp[n]) y = y - a[n];
ans += a[1] * y;
} else if (i == n) {
ans += a[n] * a[n - 1] + a[n] * a[1];
y = sumk;
if (sp[1]) y = y - a[1];
if (sp[n - 1]) y = y - a[n - 1];
ans += a[n] * y;
} else {
ans += a[i] * a[i - 1] + a[i] * a[i + 1];
y = sumk;
if (sp[i - 1]) y = y - a[i - 1];
if (sp[i + 1]) y = y - a[i + 1];
ans += a[i] * y;
}
}
}
cout << ans / 2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
int arr[n];
int Min = INT_MAX;
long int count = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
Min = min(Min, arr[i]);
}
for (int i = 0; i < n; i++) {
count += (arr[i] - Min);
arr[i] = Min;
}
if (count % n == 0)
cout << n;
else
cout << n - 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[50], b[50], n;
string s, s1;
char c, o;
bool u, v;
int k, kt, k2;
long long rs;
int main() {
cin >> n;
k2 = 26;
while (n--) {
cin >> c >> s;
if (v && ((c == '!') || c == '?'))
rs++;
else {
switch (c) {
case '!': {
k++;
k2 = 0;
for (int i = 0; i < s.size(); i++) {
if (a[(int)s[i] - 'a'] == k - 1) {
a[(int)s[i] - 'a'] = k;
k2++;
}
}
if (k2 == 1) {
v = 1;
}
break;
}
case '.': {
for (int i = 0; i < s.size(); i++) {
if (a[(int)s[i] - 'a'] == k) k2--;
a[(int)s[i] - 'a'] = -1;
}
if (k2 == 1) {
v = 1;
}
break;
}
case '?': {
if (a[(int)s[0] - 'a'] == k) {
k2--;
a[(int)s[0] - 'a'] = -1;
}
if (k2 == 1) {
v = 1;
}
break;
}
}
}
}
if (v) rs--;
cout << rs;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int h, m, s, t1, t2;
int a;
int main() {
scanf("%d%d%d%d%d", &h, &m, &s, &t1, &t2);
h = h * 3600 + m * 60 + s;
m = m * 720 + s * 12;
s = s * 720;
t1 = t1 * 3600;
t2 = t2 * 3600;
h %= 43200;
m %= 43200;
s %= 43200;
t1 %= 43200;
t2 %= 43200;
for (int i = t1;; i = (i + 1) % 43200) {
if (i == h || i == m || i == s) break;
if (i == t2) {
a = 1;
break;
}
}
for (int i = t1;; i--) {
if (i < 0) i += 43200;
if (i == h || i == m || i == s) break;
if (i == t2) {
a = 1;
break;
}
}
if (a)
puts("YES");
else
puts("NO");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, l, n, m, s, an, sum;
const int N = 110000;
char a[100100];
class arr {
public:
int v, x;
} b[N];
bool com(const arr &o, const arr &p) { return o.v < p.v; }
int main() {
int x;
scanf("%d", &x);
getchar();
scanf("%s", a + 1);
n = strlen(a + 1);
a[n + 1] = 'b';
int s = 0;
for (i = 1; i <= n;) {
s++;
int ff;
if (a[i] == '-')
ff = -1;
else
ff = 1;
if ((i == 1) && (ff == 1))
i = i;
else
i++;
int ss = 0;
if ((a[i] >= '0') && (a[i] <= '9')) {
while ((a[i] >= '0') && (a[i] <= '9')) {
ss = ss * 10 + a[i] - '0';
i++;
}
i++;
} else
ss = 1;
b[s].v = ss * ff;
if (a[i] == 'a')
b[s].x = 0;
else
b[s].x = 1;
i += 3;
}
sort(&b[1], &b[s + 1], com);
an = 0;
for (i = 1; i <= s; i++) {
if (b[i].x == 0) {
an += b[i].v * x;
x++;
} else {
x++;
an += b[i].v * x;
}
}
printf("%d", an);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long s[10001], a[10001], p[10001];
int main() {
long long n, c, cut = 0;
scanf("%lld%lld", &n, &c);
for (int i = 1; i <= n; i++) {
scanf("%lld", &p[i]);
cut += p[i];
}
for (int i = 1; i <= n; i++) {
long long s;
scanf("%lld", &s);
a[i] = s + (n - i) * c - p[i];
}
long long ans = cut;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
cut += a[i] - c * (i - 1);
ans = min(ans, cut);
}
printf("%lld", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int const maxn = 200005;
int p[maxn];
long long prevedge[maxn];
int hei[maxn];
long long ed[maxn];
vector<pair<int, int> > tree[maxn];
void dfs(int v, int pre = 1, int h = 0) {
p[v] = pre;
hei[v] = h;
for (int i = 0; i < tree[v].size(); ++i)
if (tree[v][i].first != pre) {
prevedge[tree[v][i].first] = tree[v][i].second;
dfs(tree[v][i].first, v, h + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
cin >> ed[i];
tree[x].push_back(make_pair(y, i));
tree[y].push_back(make_pair(x, i));
}
prevedge[1] = 0;
ed[0] = 1;
dfs(1);
for (int i = 0; i < m; ++i) {
int type = 0;
cin >> type;
if (type == 2) {
int num;
long long x;
cin >> num >> x;
ed[num] = x;
} else {
int a, b;
long long y;
cin >> a >> b >> y;
while (y > 0 && a != b) {
if (hei[a] < hei[b]) swap(a, b);
int na = a;
while (na != 1 && ed[prevedge[na]] == 1) na = p[na];
while (a != na) {
int tmp = p[a];
p[a] = na;
a = tmp;
}
if (a == b) break;
if (hei[a] >= hei[b]) {
y /= ed[prevedge[a]];
a = p[a];
}
}
cout << y << "\n";
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bitset<100005> vis;
vector<pair<int, int> > adj[100005];
pair<int, int> clause[100005];
pair<long long, long long> add(pair<long long, long long> a,
pair<long long, long long> b) {
return pair<long long, long long>((a.first + b.first) % 1000000007,
(a.second + b.second) % 1000000007);
}
pair<long long, long long> rev(pair<long long, long long> a) {
return pair<long long, long long>(a.second, a.first);
}
pair<long long, long long> chain(vector<int> eq, bool a0, bool a1, bool b0,
bool b1) {
int n = eq.size();
pair<long long, long long> if0[n + 2], if1[n + 2];
if0[0] = if1[0] = pair<long long, long long>(1, 0);
if (a0) if1[0] = pair<long long, long long>(0, 0);
if (a1) if0[0] = pair<long long, long long>(0, 0);
for (int i = 0; i <= n; i++) {
if0[i + 1] = add(if0[i], rev(if1[i]));
if1[i + 1] = add(rev(if0[i]), rev(if1[i]));
if (i < n && !eq[i]) swap(if0[i + 1], if1[i + 1]);
}
if (b0) if1[n + 1] = pair<long long, long long>(0, 0);
if (b1) if0[n + 1] = pair<long long, long long>(0, 0);
return add(if0[n + 1], if1[n + 1]);
}
pair<long long, long long> cycle(vector<int> eq) {
bool last_eq = eq.back();
eq.pop_back();
if (last_eq)
return add(chain(eq, true, false, true, false),
chain(eq, false, true, false, true));
else
return add(chain(eq, true, false, false, true),
chain(eq, false, true, true, false));
}
int id(int a) { return abs(a) - 1; }
void dfs_chain(int i, vector<int> &eq, bool &b0) {
vis[i] = true;
b0 = (clause[i].second == -1);
for (pair<int, int> p : adj[i])
if (!vis[p.first]) {
eq.push_back(p.second);
dfs_chain(p.first, eq, b0);
}
}
pair<long long, long long> make_chain(int i) {
bool a0 = (clause[i].second == -1), a1 = false, b0, b1 = false;
vector<int> eq;
dfs_chain(i, eq, b0);
return chain(eq, a0, a1, b0, b1);
}
void dfs_cycle(int i, int start, int par, vector<int> &eq) {
if (vis[i]) return;
vis[i] = true;
for (pair<int, int> p : adj[i])
if (p.first != par) {
eq.push_back(p.second);
dfs_cycle(p.first, start, i, eq);
return;
}
if (adj[i][0].first == i) return;
eq.clear();
for (pair<int, int> p : adj[i]) eq.push_back(p.second);
}
pair<long long, long long> make_cycle(int i) {
vector<int> eq;
dfs_cycle(i, i, -1, eq);
return cycle(eq);
}
pair<long long, long long> acc(pair<long long, long long> a,
pair<long long, long long> b) {
return pair<long long, long long>(
(a.first * b.first + a.second * b.second) % 1000000007,
(a.first * b.second + a.second * b.first) % 1000000007);
}
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int> > appear[m];
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (k == 1) {
int a;
cin >> a;
clause[i] = pair<int, int>(id(a), -1);
appear[id(a)].push_back(pair<int, int>(i, a >= 0));
} else {
int a, b;
cin >> a >> b;
clause[i] = pair<int, int>(id(a), id(b));
appear[id(a)].push_back(pair<int, int>(i, a >= 0));
appear[id(b)].push_back(pair<int, int>(i, b >= 0));
}
}
vector<pair<long long, long long> > poss_acc;
for (int i = 0; i < m; i++) {
if (appear[i].size() == 0)
poss_acc.push_back(pair<long long, long long>(2, 0));
else if (appear[i].size() == 2) {
int a = appear[i][0].first, b = appear[i][1].first;
bool eq = (appear[i][0].second == appear[i][1].second);
adj[a].push_back(pair<int, int>(b, eq));
adj[b].push_back(pair<int, int>(a, eq));
}
}
for (int i = 0; i < n; i++) {
if (adj[i].size() == 0) {
if (clause[i].second == -1)
poss_acc.push_back(pair<long long, long long>(1, 1));
else
poss_acc.push_back(pair<long long, long long>(1, 3));
}
if (!vis[i] && adj[i].size() == 1) poss_acc.push_back(make_chain(i));
}
for (int i = 0; i < n; i++)
if (!vis[i] && adj[i].size() == 2) poss_acc.push_back(make_cycle(i));
pair<long long, long long> total = pair<long long, long long>(1, 0);
for (pair<long long, long long> p : poss_acc) total = acc(total, p);
cout << total.second << endl;
}
| 10 |
#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#define DEBUG
#include <bits/headerfile.hpp>
#else
#define zqy1018zqy1018zqy1018zqy1018zqy1018 123
#endif
#define INF 2000000000
#define MOD 1000000007
#define MAXN 200005
#define REP(temp, init_val, end_val) for (int temp = init_val; temp <= end_val; ++temp)
#define REPR(temp, init_val, end_val) for (int temp = init_val; temp >= end_val; --temp)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> intpair;
int read(){
int f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9'){if(c == '-') f = -f; c = getchar();}
while (c >= '0' && c <= '9')x = x * 10 + c - '0', c = getchar();
return f * x;
}
inline int lowbit(int x){
return x & (-x);
}
inline int modadd(int x, int y){
return (x + y >= MOD ? x + y - MOD: x + y);
}
inline int sgn(int x){
return (x < 0 ? -1: (x > 0 ? 1: 0));
}
template<typename T>
T gcd(T a, T b){
return (!b) ? a: gcd(b, a % b);
}
int poww(int a, int b){
int res = 1;
while (b > 0){
if (b & 1) res = 1ll * res * a % MOD;
a = 1ll * a * a % MOD, b >>= 1;
}
return res;
}
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
const int ddx[] = {-1, -1, -1, 0, 0, 1, 1, 1}, ddy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
/*--------------------------------------------------------------------*/
/*--------------------------------------------------------------------*/
int n, m;
int a[1005][1005];
ll sum[1005], sum2[1005];
inline ll sqr(int x){
return 1ll * x * x;
}
void init(){
m = read(), n = read();
REP(i, 1, n){
sum[i] = 0;
sum2[i] = 0;
REP(j, 1, m)
a[i][j] = read(), sum[i] += 1ll * a[i][j], sum2[i] += sqr(a[i][j]);
}
}
void solve(){
// get y
ll v = (sum[n] - sum[1]) / (n - 1);
int y;
ll diff = 0;
REP(i, 2, n - 1){
if (sum[i] - sum[i - 1] != v){
y = i;
diff = sum[i] - sum[i - 1] - v;
break;
}
}
// get mod
ll vv2;
if (y <= 3){
// y + 1, y + 2, y + 3
vv2 = sum2[y + 3] + sum2[y + 1] - 2 * sum2[y + 2];
} else {
vv2 = sum2[0 + 3] + sum2[0 + 1] - 2 * sum2[0 + 2];
}
ll ori = sum2[y];
ll p;
REP(i, 1, m){
ll tt = a[y][i] - diff;
if (tt <= 0) continue;
ll ns = ori - sqr(a[y][i]) + tt * tt;
if (sum2[y + 1] + sum2[y - 1] - 2 * ns == vv2){
p = tt;
break;
}
}
cout << y - 1 << " " << p << endl;
}
int main(){
int T = 1;
while (T--){
init();
solve();
}
return 0;
} | 11 |
#include <bits/stdc++.h>
struct BIT_2D {
int n, m;
std::vector<int> num[5001];
void set(int a, int b) {
n = a, m = b;
for (int i = 1; i <= n; i++) num[i].resize(m + 1);
}
void update(int x, int y, int delta) {
for (; x <= n; x += x & -x) {
for (int tem = y; tem <= m; tem += tem & -tem) {
num[x][tem] += delta;
}
}
}
int query(int x, int y) {
int tot = 0;
for (; x; x -= x & -x)
for (int tem = y; tem; tem -= tem & -tem) tot += num[x][tem];
return tot;
}
} A, B, C;
int N, Q, opt, t1, t2, t3, t4;
int main() {
scanf("%d%d", &N, &Q);
A.set(N, N);
B.set(N, N << 1);
C.set(N, N << 1);
for (int i = 1; i <= Q; i++) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%d%d%d", &t1, &t2, &t3, &t4);
int flag = 1;
if (t1 == 3) {
A.update(t2 - t4, t3, 1);
A.update(t2 + 1, t3, -1);
A.update(t2 - t4, t3 + t4 + 1, -1);
A.update(t2 + 1, t3 + t4 + 1, 1);
t1 = 2, t2 -= t4, t3 += t4, flag = -1, --t4;
}
if (t1 == 4) {
A.update(t2 - t4, t3 - t4, 1);
A.update(t2 + 1, t3 - t4, -1);
A.update(t2 - t4, t3 + 1, -1);
A.update(t2 + 1, t3 + 1, 1);
t1 = 1, t2 -= t4, t3 -= t4, flag = -1, --t4;
}
if (t1 == 1) {
A.update(t2, t3, flag);
A.update(t2 + t4 + 1, t3, -flag);
B.update(t2, t2 + t3 + t4 + 1, -flag);
B.update(t2 + t4 + 1, t2 + t3 + t4 + 1, flag);
}
if (t1 == 2) {
A.update(t2, t3 + 1, -flag);
A.update(t2 + t4 + 1, t3 + 1, flag);
C.update(t2, -t2 + t3 - t4 + N, flag);
C.update(t2 + t4 + 1, -t2 + t3 - t4 + N, -flag);
}
} else {
scanf("%d%d", &t1, &t2);
printf("%d\n",
A.query(t1, t2) + B.query(t1, t1 + t2) + C.query(t1, t2 - t1 + N));
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
map<pair<long long int, long long int>, long long> m;
void solve() {
cout << setprecision(15);
long long a, aa, b, bb, t, tt;
cin >> a >> aa >> b >> bb >> t >> tt;
long long tes;
cin >> tes;
double sum = 0;
vector<pair<double, pair<long long int, long long int>>> va;
vector<pair<double, pair<long long int, long long int>>> vb;
for (long long i = 0; i <= tes - 1; i++) {
long long x, y;
cin >> x >> y;
double disa = sqrt((x - a) * (x - a) + (y - aa) * (y - aa)) -
sqrt((x - t) * (x - t) + (y - tt) * (y - tt));
double disb = -sqrt((x - t) * (x - t) + (y - tt) * (y - tt)) +
sqrt((x - b) * (x - b) + (y - bb) * (y - bb));
sum += 2 * sqrt((x - t) * (x - t) + (y - tt) * (y - tt));
va.push_back({disa, {x, y}});
vb.push_back({disb, {x, y}});
}
sort((va).begin(), (va).end());
sort((vb).begin(), (vb).end());
double ans = 0;
if (tes == 1) {
cout << sum + min(va[0].first, vb[0].first);
} else {
if (va[0].second.first != vb[0].second.first ||
va[0].second.second != vb[0].second.second) {
ans = sum + va[0].first + vb[0].first;
} else {
if (va[0].first + vb[1].first < va[1].first + vb[0].first) {
ans = sum + va[0].first + vb[1].first;
} else {
ans = sum + vb[0].first + va[1].first;
}
}
ans = min(ans, min(sum + va[0].first, sum + vb[0].first));
cout << ans;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int id, price, type;
data(int x, int y, int z) {
id = x;
price = y;
type = z;
}
bool operator<(const data &d) const {
if (d.price < price) {
return true;
}
if (d.price == price) {
return true;
}
return false;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<data> V;
int cnt = 0;
vector<pair<int, pair<int, int> > > S;
for (int i = 1; i <= n; i++) {
int c, t;
cin >> c >> t;
if (t == 1) {
++cnt;
S.push_back({c, {t, i}});
continue;
}
data D(i, c, t);
V.push_back(D);
}
sort(V.begin(), V.end());
sort(S.begin(), S.end());
int X = min(k - 1, cnt);
long double cost = 0.0;
vector<int> ans[1005];
int pos = 1;
int tot = 0;
int Y = X;
while (X--) {
int c = S.back().first;
int i = S.back().second.second;
ans[pos].push_back(i);
cost += (double)c / 2.00;
tot++;
pos++;
S.pop_back();
}
int kk = k;
if (S.size()) {
int mn = 1e8;
mn = min(S.front().first, ((V.size()) ? V.back().price : (int)1e8));
cost += (double)mn / 2.00;
if (S.front().first == mn) {
ans[pos].push_back(S.front().second.second);
for (int i = 1; i < S.size(); i++) {
cost += S[i].first;
ans[pos].push_back(S[i].second.second);
}
for (int i = 0; i < V.size(); i++) {
cost += V[i].price;
ans[pos].push_back(V[i].id);
}
} else {
ans[pos].push_back(V.back().id);
V.pop_back();
for (int i = 0; i < S.size(); i++) {
cost += S[i].first;
ans[pos].push_back(S[i].second.second);
}
for (int i = 0; i < V.size(); i++) {
cost += V[i].price;
ans[pos].push_back(V[i].id);
}
}
} else {
k -= Y;
int rem = (n - tot) / k + ((n - tot) % k);
int c = 0;
bool flag = false;
for (int i = 0; i < V.size(); i++) {
cost += V[i].price;
c++;
ans[pos].push_back(V[i].id);
if (c >= rem) {
if (!flag) {
rem -= ((n - tot) % k);
flag = true;
}
c = 0;
pos++;
}
}
}
cout << fixed << setprecision(1) << cost << endl;
for (int i = 1; i <= pos; i++) {
if (ans[i].size() == 0) {
continue;
}
cout << ans[i].size() << " ";
for (auto ii : ans[i]) {
cout << ii << " ";
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> dfs(int idx, vector<vector<long long>> &adj,
vector<int> &vals, vector<bool> &visited) {
if (adj[idx].size() == 0) {
pair<long long, long long> ret(min(0, vals[idx]), max(0, vals[idx]));
}
pair<long long, long long> ret(min(0, vals[idx]), max(0, vals[idx]));
for (int i = 0; i < adj[idx].size(); i++) {
if (visited[adj[idx][i]]) continue;
visited[adj[idx][i]] = true;
pair<long long, long long> got = dfs(adj[idx][i], adj, vals, visited);
ret.first = min(ret.first, got.first);
ret.second = max(ret.second, got.second);
}
if (ret.second + ret.first < vals[idx]) {
ret.second += vals[idx] - ret.second - ret.first;
} else if (ret.second + ret.first > vals[idx]) {
ret.first += vals[idx] - ret.second - ret.first;
}
return ret;
}
int main() {
int n;
cin >> n;
vector<vector<long long>> adj(n, vector<long long>());
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
vector<int> vals(n);
for (int i = 0; i < n; i++) cin >> vals[i];
vector<bool> visited(n, false);
visited[0] = true;
pair<long long, long long> root = dfs(0, adj, vals, visited);
cout << abs(root.first - root.second) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void redirect_input() { freopen("./input.txt", "r", stdin); }
void redirect_output() { freopen("./output.txt", "w", stdout); }
const int maxn = 5e5 + 100;
const long long inf = 0x3f3f3f3f3f3f3f3f;
double sum[maxn], psum[maxn];
char buffer[maxn];
bool tag[500] = {0};
void solve() {
sum[0] = psum[0] = 0;
tag['I'] = tag['E'] = tag['A'] = tag['O'] = tag['U'] = tag['Y'] = 1;
for (int i = 1; i < maxn; i++) sum[i] = sum[i - 1] + (1.0 / i);
for (int i = 1; i < maxn; i++) psum[i] = psum[i - 1] + sum[i];
cin >> (buffer + 1);
int len = strlen(buffer + 1);
double ans = 0;
for (int i = 1; i <= len; i++) {
if (tag[buffer[i]]) {
ans += psum[len] - psum[len - i] - psum[i - 1];
}
}
cout << fixed << setprecision(10) << ans << endl;
}
signed main() {
ios::sync_with_stdio(false), cin.tie(NULL);
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, t = 29, d;
cin >> a >> b >> c;
d = max(a, b);
d = max(d, c);
if (d % 2 == 0)
d /= 2;
else
d = (d / 2) + 1;
d *= 3;
for (int i = 0; i < d; i++) {
if (a + b + c == 0) break;
if (i % 3 == 0) {
if (a == 1) a--;
if (a >= 2) a -= 2;
}
if (i % 3 == 1) {
if (b == 1) b--;
if (b >= 2) b -= 2;
}
if (i % 3 == 2) {
if (c == 1) c--;
if (c >= 2) c -= 2;
}
t++;
}
cout << t << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, k;
int cc[N][N];
int cc_size[N * N], when_added[N * N], nCC;
char a[N][N];
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
bool inside(int x, int y) { return max(x, y) <= n && min(x, y) >= 1; }
void DFS(int x, int y, int curr_cc) {
cc[x][y] = curr_cc;
++cc_size[curr_cc];
for (int i = 0, _b = (3); i <= _b; i++) {
int x2 = x + dx[i];
int y2 = y + dy[i];
if (cc[x2][y2] == 0 && a[x2][y2] == '.' && inside(x2, y2)) {
DFS(x2, y2, curr_cc);
}
}
}
int cinsert(int x, int y, int &res, int curr_time) {
if (inside(x, y) && a[x][y] == '.') {
if (when_added[cc[x][y]] != curr_time) {
res += cc_size[cc[x][y]];
when_added[cc[x][y]] = curr_time;
}
}
}
int main() {
cin >> n >> k;
for (int x = 1, _b = (n); x <= _b; x++) {
for (int y = 1, _b = (n); y <= _b; y++) {
cin >> a[x][y];
}
}
for (int x = 1, _b = (n); x <= _b; x++) {
for (int y = 1, _b = (n); y <= _b; y++) {
if (cc[x][y] == 0 && a[x][y] == '.') {
DFS(x, y, ++nCC);
}
}
}
int best_res = 0;
int curr_time = 1;
for (int y_low = 1, _b = (n - k + 1); y_low <= _b; y_low++) {
for (int x = 1, _b = (k); x <= _b; x++) {
for (int y = y_low, _b = (y_low + k - 1); y <= _b; y++) {
cc_size[cc[x][y]]--;
}
}
for (int x_low = 1, _b = (n - k + 1); x_low <= _b; x_low++) {
int res = k * k;
for (int x = x_low, _b = (x_low + k - 1); x <= _b; x++) {
cinsert(x, y_low - 1, res, curr_time);
cinsert(x, y_low + k, res, curr_time);
}
for (int y = y_low, _b = (y_low + k - 1); y <= _b; y++) {
cinsert(x_low - 1, y, res, curr_time);
cinsert(x_low + k, y, res, curr_time);
}
++curr_time;
best_res = max(best_res, res);
if (x_low + k - 1 != n) {
for (int y = y_low, _b = (y_low + k - 1); y <= _b; y++) {
++cc_size[cc[x_low][y]];
--cc_size[cc[x_low + k][y]];
}
}
}
for (int x = n - k + 1, _b = (n); x <= _b; x++) {
for (int y = y_low, _b = (y_low + k - 1); y <= _b; y++) {
++cc_size[cc[x][y]];
}
}
}
cout << best_res;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("in.in");
ofstream fout("out.out");
const int N = 2000 + 10, K = 12;
const long long mod = 1e9 + 7;
int n, k, c, a[N];
long long dp[N][1 << K][2];
long long calc(int i, int mask, int f) {
mask %= c;
long long &res = dp[i][mask][f];
if (res != -1) return res;
if (i == n) return res = f;
if (!a[i]) {
res = calc(i + 1, mask + 2, (f || mask >= c - 2));
if (mask & 2)
res += calc(i + 1, 4, f);
else
res += calc(i + 1, mask + 4, (f || mask >= c - 4));
res %= mod;
return res;
}
if (a[i] == 2) return res = calc(i + 1, mask + 2, (f || mask >= c - 2));
if (mask & 2) return res = calc(i + 1, 4, f);
return res = calc(i + 1, mask + 4, (f || mask >= c - 4));
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
memset(dp, -1, sizeof dp);
c = 1 << k;
cout << calc(0, 0, 0) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int book[101];
int pd(int n) {
if (n == 1) return 1;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 1;
}
return 0;
}
int main(void) {
int T;
cin >> T;
for (int i = 1; i < 100; i++) book[i] = pd(i);
while (T--) {
int k, t = 0;
cin >> k;
char ch[N];
cin >> ch;
for (int i = 0; i < k; i++) {
if (book[ch[i] - '0']) {
cout << 1 << endl;
cout << ch[i] << endl;
t = 1;
break;
}
}
if (!t) {
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
int ans = (ch[i] - '0') * 10 + (ch[j] - '0');
if (book[ans]) {
cout << 2 << endl;
cout << ch[i] << ch[j] << endl;
t = 1;
break;
}
}
if (t) break;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[1 << 20];
int64_t r = 0;
int i = -1, h = 0;
cin >> s;
while (s[++i])
if (s[i] == 'h' && s[i + 1] == 'e' && s[i + 2] == 'a' && s[i + 3] == 'v' &&
s[i + 4] == 'y')
h++, i += 4;
else if (s[i] == 'm' && s[i + 1] == 'e' && s[i + 2] == 't' &&
s[i + 3] == 'a' && s[i + 4] == 'l')
r += (int64_t)h, i += 4;
cout << r << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18 + 5;
long long fastPow(long long x, int p) {
long long answer = 1, current = x;
while (p != 0) {
if (p % 2 != 0) {
if (answer > inf / current + 1) return inf;
answer *= current;
}
p /= 2;
if (current <= inf / current + 1)
current *= current;
else
current = inf;
}
return answer;
}
long long dp[70];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
memset(dp, 0, sizeof(dp));
dp[1] = n - 1;
long long lastAns = n;
for (int p = 2; p < 65; p++) {
long long l = 1, r = lastAns, mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (fastPow(mid, p) <= n)
l = mid;
else
r = mid - 1;
}
if (fastPow(r, p) <= n)
lastAns = r;
else
lastAns = l;
dp[p] = lastAns - 1;
}
for (int i = 64; i >= 2; i--) {
for (int d = 1; d * d <= i; d++) {
if (i % d == 0) {
dp[d] -= dp[i];
if (d != 1 && i / d != d) dp[i / d] -= dp[i];
}
}
}
cout << dp[1] << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > data;
vector<vector<int> > sticks;
vector<int> h;
int dfs(int vertex, int last) {
int longest = 0;
for (int i = 0; i < data[vertex].size(); ++i) {
int to = data[vertex][i];
if (to == last) continue;
int len = dfs(to, vertex) + 1;
sticks[vertex].push_back(len);
longest = max(longest, len);
}
h[vertex] = longest;
return longest;
}
void dfs2(int vertex, int last, int fup) {
if (vertex != 0) {
sticks[vertex].push_back(fup);
}
fup++;
int mx1 = -100, mx2 = -100;
for (int i = 0; i < data[vertex].size(); ++i) {
int to = data[vertex][i];
if (to == last) continue;
if (h[to] + 1 > mx1) {
mx2 = mx1;
mx1 = h[to] + 1;
} else
mx2 = max(mx2, h[to] + 1);
}
for (int i = 0; i < data[vertex].size(); ++i) {
int to = data[vertex][i];
if (to == last) continue;
if (h[to] + 1 != mx1) {
dfs2(to, vertex, max(fup, mx1 + 1));
} else
dfs2(to, vertex, max(fup, mx2 + 1));
}
}
int dfslong, dfslen;
void dfs3(int vertex, int last, int d) {
if (d > dfslen) {
dfslen = d, dfslong = vertex;
}
for (int i = 0; i < data[vertex].size(); ++i) {
int to = data[vertex][i];
if (to == last) continue;
dfs3(to, vertex, d + 1);
}
}
int find_diameter() {
dfslong = 0, dfslen = 0;
dfs3(0, -1, 0);
int Q = dfslong;
dfs3(dfslong, -1, 0);
return dfslen;
}
vector<bool> deleted;
void dlt(int first) { deleted[first] = true; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
data.assign(n, {});
sticks.assign(n, {});
h.assign(n, {});
deleted.assign(n, false);
vector<pair<int, int> > edges;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
u--, v--;
data[u].push_back(v), data[v].push_back(u);
edges.push_back({u, v});
}
dfs(0, -1);
dfs2(0, -1, 0);
for (int i = 0; i < n; ++i) {
sort(sticks[i].begin(), sticks[i].end(), greater<int>());
}
vector<pair<int, int> > kek;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < sticks[i].size(); ++j) {
kek.push_back({sticks[i][j], i});
}
}
sort(kek.begin(), kek.end());
int d = find_diameter();
for (int i = 0; i < n; ++i) {
if (data[i].size() <= 2) dlt(i);
}
set<pair<int, int> > W;
for (int i = 0; i < n; ++i) {
W.insert({-sticks[i].size(), i});
}
auto thtol = W.begin();
cout << -(*thtol).first + 1 << " ";
int u = 0;
vector<int> stake;
for (int k = 2; k <= n; ++k) {
if (k > d) {
cout << 1 << " ";
continue;
}
if (k % 2 == 0) {
while (u < kek.size() && kek[u].first < k / 2) {
stake.push_back(kek[u++].second);
}
for (int i = 0; i < stake.size(); ++i) {
int T = stake[i];
W.erase(W.find({-sticks[T].size(), T}));
while (sticks[T].size() && sticks[T].back() < k / 2)
sticks[T].pop_back();
if (sticks[T].size() <= 2) dlt(T);
W.insert({-sticks[T].size(), T});
}
auto aaa = W.begin();
int tut = max(2, -(*aaa).first);
int st = 0;
while (st < edges.size()) {
int A = edges[st].first, B = edges[st].second;
if (deleted[A] || deleted[B]) {
swap(edges[st], edges.back());
edges.pop_back();
continue;
}
tut = max(tut, (int)(sticks[A].size() + sticks[B].size() - 2));
st++;
}
cout << tut << " ";
stake.clear();
} else {
while (u < kek.size() && kek[u].first < (k + 1) / 2) {
stake.push_back(kek[u++].second);
}
for (int i = 0; i < stake.size(); ++i) {
int T = stake[i];
W.erase(W.find({-sticks[T].size(), T}));
while (sticks[T].size() > 1 &&
sticks[T][sticks[T].size() - 2] < (k + 1) / 2)
sticks[T].pop_back();
if (sticks[T].size() <= 2) dlt(T);
W.insert({-sticks[T].size(), T});
}
auto aaa = W.begin();
int tut = max(2, -(*aaa).first);
cout << tut << " ";
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500 + 7;
long long mod = 1e9 + 7;
bool solve(long long l, long long r, long long mx, long long& ans) {
if (r - l + 1 > mx) {
return false;
}
ans = -l + 1;
return true;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
string s;
cin >> s;
int x = 0, y = 0, mnx = 0, mxx = 0, mny = 0, mxy = 0;
long long ansX = 1, ansY = 1;
for (auto i : s) {
x += i == 'D';
x -= i == 'U';
y += i == 'R';
y -= i == 'L';
mnx = min(x, mnx);
mxx = max(x, mxx);
mny = min(y, mny);
mxy = max(y, mxy);
long long tmpX, tmpY;
if (solve(mnx, mxx, n, tmpX) && solve(mny, mxy, m, tmpY)) {
ansX = tmpX, ansY = tmpY;
continue;
}
break;
}
cout << ansX << " " << ansY << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
string s;
int fst = 1;
int main() {
cout.flags(ios::fixed);
cout.precision(2);
cin >> s;
s += " ";
cout << s[0];
for (int i = 1; i < s.size(); i++) {
if (s[i] == ' ') break;
if (s[i] == 'd' && s[i + 1] == 'o' && s[i + 2] == 't' && s[i + 3] != ' ') {
cout << '.';
i += 2;
continue;
}
if (s[i] == 'a' && s[i + 1] == 't' && fst && s[i + 2] != ' ') {
fst = 0;
cout << "@";
i++;
continue;
}
cout << s[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[1010];
vector<pair<int, int> > mas;
bool used[1010];
int cost[1010];
void Solve() {
int i, j, k, n, m;
scanf("%d%d", &(n), &(m));
for (i = 0; i < n; i++) {
int a;
scanf("%d", &(a));
mas.push_back(make_pair(a, i));
cost[i] = a;
}
while (m--) {
int a, b;
scanf("%d%d", &(a), &(b));
a--, b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
sort(mas.begin(), mas.end());
reverse(mas.begin(), mas.end());
long long res = 0;
for (i = 0; i < n; i++) {
int u = mas[i].second;
for (j = 0; j < edge[u].size(); j++) {
int v = edge[u][j];
if (!used[v]) {
res += cost[v];
}
}
used[u] = true;
}
printf("%I64d", res);
}
int main() {
Solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5;
set<char> tree[4 * N + 7];
int n;
void build(const string &s, int node = 1, int tl = 0, int tr = n - 1) {
if (tl == tr) return void(tree[node].insert(s[tl]));
int mid = (tl + tr) / 2;
build(s, node * 2, tl, mid);
build(s, node * 2 + 1, mid + 1, tr);
for (auto x : tree[node * 2]) tree[node].insert(x);
for (auto x : tree[node * 2 + 1]) tree[node].insert(x);
}
void query(set<char> &res, int l, int r, int node = 1, int tl = 0,
int tr = n - 1) {
if (l > r) return;
if (tl == l && tr == r) {
res.insert(tree[node].begin(), tree[node].end());
return;
}
int mid = (tl + tr) / 2;
query(res, l, min(r, mid), node * 2, tl, mid);
query(res, max(l, mid + 1), r, node * 2 + 1, mid + 1, tr);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
n = (int)s.size();
build(s);
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
l--;
r--;
set<char> st;
query(st, l, r);
if (l == r)
cout << "Yes" << '\n';
else if (st.size() == 1)
cout << "No" << '\n';
else if (st.size() == 2 && s[l] == s[r])
cout << "No" << '\n';
else
cout << "Yes" << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int DIV = 1000000007;
int main(int argc, char* argv[]) {
FILE* f = stdin;
int n, x, y, x1 = -2000, y1 = -2000, x2 = -2000, y2 = -2000;
fscanf(f, "%d\n", &n);
for (int i = 0; i < n; i++) {
fscanf(f, "%d %d\n", &x, &y);
if (i == 0) {
x1 = x;
y1 = y;
} else {
if (x != x1) x2 = x;
if (y != y1) y2 = y;
}
}
if (x1 > -2000 && x2 > -2000 && y1 > -2000 && y2 > -2000)
printf("%d", abs(x2 - x1) * abs(y2 - y1));
else
printf("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const char *fin = "";
const char *fon = "";
const int OO = (int)(1e9 + 7);
const int MAXN = (int)(1e3 + 3);
const int MAXB = (int)(1e4 + 5);
long long f[MAXB];
long long maxE[MAXB];
long long w, b, x;
int c[MAXN];
int cost[MAXN];
int n;
int s;
void Sol() {
f[0] = w;
maxE[0] = w;
for (int i = 1; i <= s; ++i) {
f[i] = -1;
maxE[i] = maxE[i - 1] + b;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= s; ++j)
if (f[j] != -1) f[j] = min(f[j] + x, maxE[j]);
for (int j = s; j >= 1; --j) {
for (int k = 1; k <= c[i]; ++k) {
if (j - k < 0) break;
if (f[j - k] >= k * cost[i])
f[j] = min(maxE[j], max(f[j], f[j - k] - 1LL * k * cost[i]));
}
}
}
for (int i = s; i >= 0; --i)
if (f[i] != -1) {
cout << i << '\n';
return;
}
}
void Inp() {
cin >> n >> w >> b >> x;
for (int i = 1; i <= n; ++i) {
cin >> c[i];
s += c[i];
}
for (int i = 1; i <= n; ++i) cin >> cost[i];
Sol();
}
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
Inp();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2009000999;
const double eps = 1e-3;
const int maxn = 2e3 + 55;
const int maxk = 55;
const int base = 1e9 + 7;
const long long basell = 1e18 + 3;
const long double PI = acos(-1.0);
string itosm(long long x) {
if (x == 0) return "0";
string ans = "";
while (x > 0) {
ans += ((x % 10) + '0');
x /= 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
long long stoim(string str) {
long long ans = 0;
long long k = 1;
for (int i = str.length() - 1; i >= 0; i--) {
ans += (str[i] - '0') * k;
k *= 10;
}
return ans;
}
int dp[maxn];
int main() {
ios_base::sync_with_stdio(0);
;
int n, k;
cin >> k >> n;
vector<int> c;
for (int i = 0; i <= maxn; i++) dp[i] = inf;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (dp[a - k + 1000] == inf) c.push_back(a - k + 1000);
dp[a - k + 1000] = 1;
}
int ii;
for (int i = 0; i < c.size(); i++) {
ii = i;
i = c[i];
if (dp[i] != inf) {
for (int j = 0; j < c.size(); j++) {
if (j == ii) continue;
int jj = j;
j = c[j];
if ((j > 1000) == (i > 1000)) {
j = jj;
continue;
}
if (dp[i + j - 1000] == inf) c.push_back(i + j - 1000);
dp[i + j - 1000] = min(dp[i + j - 1000], dp[i] + dp[j]);
j = jj;
}
}
i = ii;
}
if (dp[1000] == inf) dp[1000] = -1;
cout << dp[1000];
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const double pi = 3.14159265359;
const double eps = 1e-9;
const int mod = 1e9 + 7;
const int mod1 = 1e9 + 9;
const int INF = 1e9;
const long long INFLL = 2e18;
int max_del(int n) {
if (n % 2 == 0) return n / 2;
int res = 1;
for (int i = 3; i * i <= n; i++)
if (n % i == 0) res = i;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> erat(1000000), primes;
for (int i = 2; i < 100000; i++)
if (!erat[i]) {
primes.push_back(i);
for (int j = i + i; j < 100000; j += i) erat[j] = 1;
}
int ans = INF;
for (auto i : primes)
if (i > n)
break;
else if (i != n - 1)
ans = min(ans, 1 + max_del(n - i));
ans = min(ans, max_del(n));
ans = min(ans, 3);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int l[10] = {0};
void open() {
freopen("sticks.in", "r", stdin);
freopen("sticks.out", "w", stdout);
}
void close() {
fclose(stdin);
fclose(stdout);
}
void work(int k) {
int i;
if (l[k] == 6) {
printf("Elephant");
return;
}
for (i = 1; i <= 9; i++)
if (l[i] == 2) {
printf("Elephant");
return;
}
printf("Bear");
}
void init() {
int i, a;
for (i = 1; i <= 6; i++) {
scanf("%d", &a);
l[a]++;
}
for (i = 1; i <= 9; i++)
if (l[i] >= 4) {
work(i);
return;
}
printf("Alien");
}
int main() {
init();
close();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long> q;
long long x;
int n, k, y;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < k; ++i) q.push(0);
while (n--) {
cin >> x >> y;
x = max(x, -q.top()) + y;
printf("%I64d\n", x);
q.pop();
q.push(-x);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1050;
char S[N][N];
int a1[N * N], b1[N * N], a2[N * N], b2[N * N];
char ch[N * N];
int n, m, k;
long long minn, ans[N][N], g[N][N], s[27][N][N];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) {
scanf("%s", S[i] + 1);
}
for (int i = 1; i <= k; ++i) {
scanf("%d%d%d%d", &a1[i], &b1[i], &a2[i], &b2[i]);
cin >> ch[i];
s[ch[i] - 'a'][a1[i]][b1[i]]++;
s[ch[i] - 'a'][a1[i]][b2[i] + 1]--;
s[ch[i] - 'a'][a2[i] + 1][b1[i]]--;
s[ch[i] - 'a'][a2[i] + 1][b2[i] + 1]++;
g[a1[i]][b1[i]]++;
g[a1[i]][b2[i] + 1]--;
g[a2[i] + 1][b1[i]]--;
g[a2[i] + 1][b2[i] + 1]++;
}
for (int i = 0; i < 26; ++i)
for (int x = 1; x <= n; ++x)
for (int y = 1; y <= m; ++y)
s[i][x][y] += s[i][x - 1][y] + s[i][x][y - 1] - s[i][x - 1][y - 1];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
g[i][j] += g[i - 1][j] + g[i][j - 1] - g[i - 1][j - 1];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) s[S[i][j] - 'a'][i][j] += k - g[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
for (int q = 0; q < 26; ++q) {
int x = abs(S[i][j] - 'a' - q);
ans[i][j] += x * s[q][i][j];
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
ans[i][j] += ans[i - 1][j] + ans[i][j - 1] - ans[i - 1][j - 1];
minn = 100000000000000LL;
for (int i = 0; i < 26; ++i)
for (int x = 1; x <= n; ++x)
for (int y = 1; y <= m; ++y)
s[i][x][y] += s[i][x - 1][y] + s[i][x][y - 1] - s[i][x - 1][y - 1];
for (int i = 1; i <= k; ++i) {
long long tot = ans[n][m] - ans[a2[i]][b2[i]] + ans[a1[i] - 1][b2[i]] +
ans[a2[i]][b1[i] - 1] - ans[a1[i] - 1][b1[i] - 1];
for (int q = 0; q < 26; ++q) {
int x = abs(ch[i] - 'a' - q);
tot += x * (s[q][a2[i]][b2[i]] - s[q][a1[i] - 1][b2[i]] -
s[q][a2[i]][b1[i] - 1] + s[q][a1[i] - 1][b1[i] - 1]);
}
minn = min(tot, minn);
}
printf("%lld\n", minn);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long powmod(long long a, long long b, long long MOD) {
long long ans = 1;
while (b) {
if (b % 2) ans = ans * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ans;
}
inline void getInt(int* p);
const int maxn = 1000010;
const int inf = 0x3f3f3f3f;
char a[maxn][8];
char s[maxn];
int main() {
for (int i = 0; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
for (int k = 0; k <= 9; k++) {
for (int x = 0; x <= 9; x++) {
for (int y = 0; y <= 9; y++) {
for (int z = 0; z <= 9; z++) {
a[i * 100000 + j * 10000 + k * 1000 + x * 100 + y * 10 + z][0] =
'0' + i;
a[i * 100000 + j * 10000 + k * 1000 + x * 100 + y * 10 + z][1] =
'0' + j;
a[i * 100000 + j * 10000 + k * 1000 + x * 100 + y * 10 + z][2] =
'0' + k;
a[i * 100000 + j * 10000 + k * 1000 + x * 100 + y * 10 + z][3] =
'0' + x;
a[i * 100000 + j * 10000 + k * 1000 + x * 100 + y * 10 + z][4] =
'0' + y;
a[i * 100000 + j * 10000 + k * 1000 + x * 100 + y * 10 + z][5] =
'0' + z;
}
}
}
}
}
}
cin >> s;
int ans = inf;
for (int i = 0; i <= 1000000; i++) {
if (a[i][0] + a[i][1] + a[i][2] == a[i][3] + a[i][4] + a[i][5]) {
int cnt = 0;
for (int j = 0; j <= 5; j++) {
if (a[i][j] != s[j]) {
cnt++;
}
}
ans = min(ans, cnt);
}
}
cout << ans << endl;
return 0;
}
inline void getInt(int* p) {
char ch;
do {
ch = getchar();
} while (ch == ' ' || ch == '\n');
if (ch == '-') {
*p = -(getchar() - '0');
while ((ch = getchar()) >= '0' && ch <= '9') {
*p = *p * 10 - ch + '0';
}
} else {
*p = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') {
*p = *p * 10 + ch - '0';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long bin_pow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long t = bin_pow(a, b / 2);
return t * t % 1000000007;
} else
return a * bin_pow(a, b - 1) % 1000000007;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1, n, m, k = 0, x = 0, y = 0, z = 0, sum = 0, l = 0, r = 0,
ans = 0, mn = LLONG_MAX, mx = LLONG_MIN;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
cout << "1 1\n" << -a[0] << "\n";
a[0] = 0;
if (n != 1) {
cout << "2 " << n << "\n";
for (int i = 1; i < n; i++) {
z = abs(a[i]) % n;
cout << (n - 1) * (abs(a[i]) / a[i]) * z << " ";
a[i] += (abs(a[i]) / a[i]) * z * (n - 1);
}
cout << "\n";
cout << "1 " << n << "\n";
for (int i = 0; i < n; i++) cout << -a[i] << " ";
} else {
cout << "1 1\n" << 0 << "\n";
cout << "1 1\n" << 0 << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
int count = 0;
cin >> x >> y;
while ((y > 1 && x > 1) || (y > 21) || (y > 11 && x == 1)) {
if ((count & 1) == 0) {
if (x > 1) {
y -= 2;
x -= 2;
} else if (x == 1) {
y -= 12;
x--;
} else
y -= 22;
} else {
if (y > 21)
y -= 22;
else if (y > 11) {
y -= 12;
x--;
} else {
x -= 2;
y -= 2;
}
}
count++;
}
if ((count & 1) == 0)
cout << "Hanako" << endl;
else
cout << "Ciel" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 5;
const int N = 1e6 + 5;
long long ans = 0;
int main() {
int n;
cin >> n;
int a[n + 1];
for (int(i) = (0); (i) < (n); i++) {
cin >> a[i];
}
sort(a, a + n);
int x;
x = (n - 1) / 2;
cout << a[x];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
size_t testCount;
cin >> testCount;
for (size_t testIndex = 0; testIndex < testCount; ++testIndex) {
size_t m, k;
cin >> m >> k;
vector<uint32_t> ration(k);
vector<uint32_t> rationStock(k);
for (size_t i = 0; i < k; ++i) {
cin >> ration[i];
}
vector<pair<uint32_t, uint32_t>> requests;
for (size_t i = 0; i < m - 1; ++i) {
size_t request, sureEmpty;
cin >> request >> sureEmpty;
requests.emplace_back(request, sureEmpty);
if (request > 0) {
++rationStock[request - 1];
}
}
uint32_t acc = 0;
bool hasEmpty = false;
for (auto &r : requests) {
size_t request = r.first;
size_t sureEmpty = r.second;
if (sureEmpty && !hasEmpty) {
uint32_t minRation = 9999999;
for (size_t j = 0; j < k; ++j) {
if (ration[j] < minRation && rationStock[j] == 0) {
minRation = ration[j];
}
}
for (size_t j = 0; j < k; ++j) {
if (ration[j] <= acc && rationStock[j] == 0) {
ration[j] -= minRation;
}
}
acc -= minRation;
hasEmpty = true;
}
if (request > 0) {
size_t j = request - 1;
--rationStock[j];
if (ration[j] > 0) {
--ration[j];
if (ration[j] == 0) {
hasEmpty = true;
}
}
} else {
++acc;
}
}
for (size_t i = 0; i < k; ++i) {
cout << (ration[i] <= acc ? "Y" : "N");
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<char> x;
string a;
int ans;
bool str(char a) { return (tolower(a) == a); }
bool big(char a) { return (toupper(a) == a); }
int main() {
cin >> a >> a;
for (auto i = 0; i < a.size(); ++i) {
if (str(a[i])) {
int cnt = 1;
x.emplace(a[i]);
for (int j = i + 1; j < a.size(); j++) {
if (big(a[j]))
break;
else {
int one = x.size();
x.emplace(a[j]);
if (x.size() != one) cnt++;
}
}
ans = max(ans, cnt);
x.clear();
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n > 36) return cout << -1, 0;
for (int i = 0; i < n / 2; i++) cout << 8;
if (n % 2) cout << 4;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int WALL = 1;
const int CELL = 0;
const int INF = 1e9;
int n, m, k;
pair<int, int> start, finish;
int square[1005][1005], dist[1024][1024];
void bfs() {
memset(dist, 0x33, sizeof(dist));
dist[start.first][start.second] = 0;
queue<pair<int, int>> q;
q.push(start);
static const int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
while (!q.empty()) {
pair<int, int> pos = q.front();
q.pop();
int x = pos.first, y = pos.second;
int d = dist[x][y];
for (int i = 0; i < 4; i++) {
for (int kk = 1; kk <= k; kk++) {
int dx = x + dir[i][0] * kk, dy = y + dir[i][1] * kk;
if (dx < 0 || dx >= n || dy < 0 || dy >= m) break;
if (square[dx][dy] == WALL) break;
if (d + 1 < dist[dx][dy]) {
dist[dx][dy] = d + 1;
q.push({dx, dy});
if (dx == finish.first && dy == finish.second) {
printf("%d\n", d + 1);
exit(0);
}
}
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
char z[1005];
scanf("%s", &z);
for (int j = 0; j < m; j++) {
switch (z[j]) {
case '#':
square[i][j] = WALL;
break;
case '.':
square[i][j] = CELL;
break;
}
}
}
int x, y, x1, y1;
scanf("%d%d%d%d", &x, &y, &x1, &y1);
x--;
y--;
x1--;
y1--;
start = {x, y};
finish = {x1, y1};
bfs();
if (dist[finish.first][finish.second] > 2 * n * m)
printf("%d\n", -1);
else
printf("%d\n", dist[finish.first][finish.second]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a, b;
cin >> n >> m >> a >> b;
if (b > m * a) {
b = m * a;
}
long long ans = (n / m) * b + (n % m) * a;
if (ans > (n / m) * b + (((n % m) + (m - 1)) / m) * b) {
ans = (n / m) * b + (((n % m) + (m - 1)) / m) * b;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &num) {
num = 0;
int w = 1;
char ch = getchar();
if (ch == '-') w = -1;
while (ch < '0' || ch > '9') {
ch = getchar();
if (ch == '-') w = -1;
}
while ((ch >= '0' && ch <= '9')) num = num * 10 + ch - '0', ch = getchar();
num = num * w;
}
template <typename T, typename... Args>
void read(T &num, Args &...args) {
read(num), read(args...);
}
const long long N = 1e5;
long long f[N + 5];
long long a[N + 5], c[N + 5], t, d, n, m;
bool cmp(long long a, long long b) {
if (c[a] != c[b]) return c[a] < c[b];
return a < b;
}
int main() {
read(n, m);
for (long long i = 1; i <= n; i++) read(a[i]);
for (long long i = 1; i <= n; i++) read(c[i]);
for (long long i = 1; i <= n; i++) f[i] = i;
long long cnt = 1;
sort(f + 1, f + n + 1, cmp);
for (long long i = 1; i <= m; i++) {
read(t, d);
long long sum = 0;
if (a[t] >= d) {
a[t] -= d;
sum += c[t] * d;
d = 0;
} else {
d -= a[t];
sum += a[t] * c[t];
a[t] = 0;
}
while (cnt <= n) {
if (a[f[cnt]] > d) {
a[f[cnt]] -= d;
sum += d * c[f[cnt]];
d = 0;
break;
} else {
d -= a[f[cnt]];
sum += a[f[cnt]] * c[f[cnt]];
a[f[cnt]] = 0;
cnt++;
}
}
if (d != 0)
printf("0\n");
else
printf("%lld\n", sum);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const long double eps = 1e-10;
const int step[8][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {1, 1}, {1, -1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <typename t, typename t1>
t min1(t a, t1 b) {
return a < b ? a : b;
}
template <typename t, typename... arg>
t min1(t a, arg... arr) {
return min1(a, min1(arr...));
}
template <typename t, typename t1>
t max1(t a, t1 b) {
return a > b ? a : b;
}
template <typename t, typename... arg>
t max1(t a, arg... arr) {
return max1(a, max1(arr...));
}
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / max(abs1(a), abs1(b)) < eps)
return 0;
if (a < b) return -1;
return 1;
}
template <typename t>
inline int jud(t a, t b) {
if (a < b) return -1;
if (a == b) return 0;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
if (na == 0) return 0;
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
template <class T>
inline T lowb(T num) {
return num & (-num);
}
inline int bitnum(unsigned int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(int nValue) { return __builtin_popcount(nValue); }
inline int bitnum(unsigned long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitnum(long long nValue) {
return __builtin_popcount(nValue) + __builtin_popcount(nValue >> 32);
}
inline int bitmaxl(unsigned int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(unsigned long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
inline int bitmaxl(long long a) {
int temp = a >> 32;
if (temp) return 32 - __builtin_clz(temp) + 32;
return bitmaxl(int(a));
}
long long pow(long long n, long long m, long long mod = 0) {
if (m < 0) return 0;
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
template <class t1, class t2>
inline void add(t1 &a, t2 b, int mod = -1) {
if (mod == -1) mod = 1000000007;
a += b;
while (a >= mod) a -= mod;
while (a < 0) a += mod;
}
template <class t>
void output1(t arr) {
for (int i = 0; i < (int)arr.size(); i++) cerr << arr[i] << ' ';
cerr << endl;
}
template <class t>
void output2(t arr) {
for (int i = 0; i < (int)arr.size(); i++) output1(arr[i]);
}
const int maxn = 300010;
int st[maxn * 2];
int lst, rst;
long long t[maxn], loc[maxn], cnt;
pair<long long, long long> sum[maxn];
int n, m;
pair<long long, long long> operator-(const pair<long long, long long> a,
const pair<long long, long long> b) {
return {a.first - b.first, a.second - b.second};
}
double operator*(const pair<long long, long long> a,
const pair<long long, long long> b) {
return 1.0 * a.first * b.second - 1.0 * a.second * b.first;
}
inline pair<long long, long long> GetSum(int l, int r) {
if (l > 0)
return sum[r] - sum[l - 1];
else
return sum[r];
}
inline pair<long long, long long> GetPoint(int rt, int no) {
auto sum = GetSum(t[no], rt);
return make_pair(loc[no], sum.first + sum.second * loc[no]);
}
inline int Jud(int a, int b, int c, int rt) {
const pair<long long, long long> pa = GetPoint(rt, a), pb = GetPoint(rt, b),
pc = GetPoint(rt, c);
return (pa - pb) * (pc - pb) < 0;
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d", &n, &m);
int be = 0, en = n - 1;
lst = maxn, rst = lst;
t[0] = 0, loc[0] = 0;
cnt = 1;
st[lst] = 0;
for (int i = 0; i < m; i++) {
int cate;
scanf("%d", &cate);
int rt = i + 1;
sum[rt] = sum[rt - 1];
if (cate == 1) {
int radd;
scanf("%d", &radd);
be -= radd;
st[--lst] = cnt;
rst = lst;
t[cnt] = i + 1;
loc[cnt] = be;
cnt++;
} else if (cate == 2) {
int radd;
scanf("%d", &radd);
st[++rst] = cnt;
t[cnt] = i + 1;
loc[cnt] = en + 1;
cnt++;
en += radd;
while (rst - lst >= 2 && !Jud(st[rst - 2], st[rst - 1], st[rst], rt)) {
st[rst - 1] = st[rst];
rst--;
}
} else if (cate == 3) {
int a, b;
scanf("%d%d", &a, &b);
sum[rt].first += a + 1ll * b * (-be);
sum[rt].second += b;
}
while (rst > lst &&
GetPoint(rt, st[rst - 1]).second <= GetPoint(rt, st[rst]).second) {
rst--;
}
printf("%lld %lld\n", loc[st[rst]] - be + 1, GetPoint(rt, st[rst]).second);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, i;
cin >> n >> k;
a = (n - k) / 2;
int t = a;
for (i = 0; i < n; i++) {
if (t) {
cout << "0";
t--;
} else {
cout << "1";
t = a;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 20;
int dis[N][8], d[8][8], val[N], n;
vector<int> G[8];
char S[N];
queue<int> q;
inline void push(int v, int c, int D) {
if (dis[v][c] <= D) return;
dis[v][c] = D, q.push(v);
}
void BFS(int c) {
dis[n + c][c] = 0;
q.push(n + c);
while (!q.empty()) {
int o = q.front();
q.pop();
if (o >= n)
for (int v : G[o - n]) push(v, c, dis[o][c]);
else {
if (o) push(o - 1, c, dis[o][c] + 1);
if (o < n - 1) push(o + 1, c, dis[o][c] + 1);
push(val[o] + n, c, dis[o][c] + 1);
}
}
}
int mask[N], cnt[8][256];
long long ans[20];
int main() {
int Case = 1;
while (Case--) {
scanf("%d%s", &n, S);
for (int i = 0; i <= 7; i++) G[i].clear();
for (int i = 0; i <= n - 1; i++)
val[i] = S[i] - 'a', G[val[i]].push_back(i), mask[i] = 0;
memset(dis, 0x1f, sizeof dis), memset(d, 0x1f, sizeof d);
memset(cnt, 0, sizeof cnt), memset(ans, 0, sizeof ans);
for (int c = 0; c <= 7; c++) BFS(c);
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= 7; j++) d[val[i]][j] = min(d[val[i]][j], dis[i][j]);
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= 7; j++) mask[i] |= (dis[i][j] - d[val[i]][j]) << j;
for (int i = 0; i <= n - 1; i++) {
for (int j = 1; j <= min(i, 7); j++) {
int mind = j;
for (int c = 0; c <= 7; c++)
mind = min(mind, dis[i][c] + dis[i - j][c] + 1);
ans[mind]++;
}
for (int j = 0; j <= 7; j++) {
int mind = 1e9, st = 0;
for (int c = 0; c <= 7; c++) mind = min(mind, dis[i][c] + 1 + d[j][c]);
if (mind > 17) continue;
for (int c = 0; c <= 7; c++)
if (dis[i][c] + 1 + d[j][c] == mind) st |= 1 << c;
ans[mind + 1] += cnt[j][st], ans[mind] += cnt[j][0] - cnt[j][st];
}
if (i >= 7) {
int s = mask[i - 7];
for (int j = s;; j = (j - 1) & s) {
cnt[val[i - 7]][j]++;
if (!j) break;
}
}
}
ans[0] = n;
for (int i = 17; i >= 0; i--)
if (ans[i]) {
cout << i << ' ' << ans[i] << endl;
break;
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, jwb;
string s;
cin >> n;
jwb = n;
cin >> s;
for (int i = 1; i < n; ++i) {
if (s[i] != s[i - 1]) {
int j = i;
while (j < n && s[j] != s[j - 1]) ++j;
--j;
--jwb;
jwb -= (j - i) / 2;
i = j;
}
}
cout << jwb << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
vector<bool> win(n, true);
for (long long i = n - 2; i >= 0; i--) {
if (win[i + 1]) {
if (a[i] == 1) win[i] = false;
}
}
if (win[0])
cout << "First\n";
else
cout << "Second\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, cursor;
string s;
cin >> n >> cursor;
cin >> s;
int cost = 0;
for (int i = 0; i < n / 2; i++) {
vector<char> arr(2);
arr[0] = s[i];
arr[1] = s[n - i - 1];
sort(arr.begin(), arr.begin() + 2);
cost += min(arr[1] - arr[0], 'z' - arr[1] + 1 + arr[0] - 'a');
}
cursor -= 1;
int end = n / 2 - 1;
int start = 0;
while (start < n && s[start] == s[n - start - 1]) {
++start;
}
while (end > 0 && s[end] == s[n - end - 1]) {
--end;
}
if (start > end) {
cout << 0;
return 0;
}
if (cursor >= n / 2) {
cursor = n - cursor - 1;
}
cost += min(abs(end - cursor), abs(cursor - start)) + end - start;
cout << cost;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 1][n + 1];
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < n + 1; j++) cin >> arr[i][j];
int rem[n + 1];
for (int i = 1; i < n + 1; i++) cin >> rem[i];
reverse(rem + 1, rem + n + 1);
vector<long long> ans;
for (int k = 1; k <= n; k++) {
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 1; j++) {
arr[i][j] = min(arr[i][j], arr[i][rem[k]] + arr[rem[k]][j]);
}
}
long long sum = 0;
for (int i = 1; i < k + 1; i++)
for (int j = 1; j < k + 1; j++) sum += arr[rem[i]][rem[j]];
ans.push_back(sum);
}
for (int i = n - 1; i >= 0; i--) cout << ans[i] << " ";
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Rect {
int a, b;
Rect(int aa, int bb) : a(aa), b(bb) {}
Rect() : Rect(0, 0) {}
bool into(const Rect& other) { return a <= other.a && b <= other.b; }
int area() const { return a * b; }
void read() { cin >> a >> b; }
Rect turn() const { return Rect(b, a); }
};
int n;
Rect field, rects[102];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
field.read();
for (int i = 0; i < n; ++i) {
rects[i].read();
}
int result = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
for (int m = 0; m < 4; ++m) {
Rect x = ((m & 1) ? rects[i] : rects[i].turn());
Rect y = ((m & 2) ? rects[j] : rects[j].turn());
if (!x.into(field) || !y.into(field)) {
continue;
}
if (y.into(Rect(field.a - x.a, field.b)) ||
y.into(Rect(field.a, field.b - x.b))) {
result = max(result, x.area() + y.area());
}
}
}
}
cout << result;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.push_back(move(x));
return v;
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
int N;
long long L;
int A[213];
string lines[213];
int M;
int g[213][26];
int f[213];
int out[213];
long long dp[48][213][213];
long long ans[2][213][213];
int aho_corasick() {
memset(g, -1, sizeof g);
memset(out, 0, sizeof out);
int nodes = 1;
for (int i = 0; i < N; i++) {
int cur = 0;
for (int j = 0; j < lines[i].size(); j++) {
if (g[cur][lines[i][j] - 'a'] == -1) {
g[cur][lines[i][j] - 'a'] = nodes++;
}
cur = g[cur][lines[i][j] - 'a'];
}
out[cur] += A[i];
}
for (int i = 0; i < 26; i++) {
if (g[0][i] == -1) {
g[0][i] = 0;
}
}
memset(f, -1, sizeof f);
queue<int> q;
for (int ch = 0; ch < 26; ch++) {
if (g[0][ch] != 0) {
f[g[0][ch]] = 0;
q.push(g[0][ch]);
}
}
while (!q.empty()) {
int state = q.front();
q.pop();
for (int ch = 0; ch < 26; ch++) {
if (g[state][ch] == -1) continue;
int fail = f[state];
while (g[fail][ch] == -1) {
fail = f[fail];
}
f[g[state][ch]] = g[fail][ch];
out[g[state][ch]] += out[f[g[state][ch]]];
q.push(g[state][ch]);
}
}
return nodes;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N >> L;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> lines[i];
}
M = aho_corasick();
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
ans[0][i][j] = (-(1LL << 60));
for (int k = 0; k < 48; k++) {
dp[k][i][j] = (-(1LL << 60));
}
}
}
for (int i = 0; i < M; i++) {
ans[0][i][i] = 0;
for (int ch = 0; ch < 26; ch++) {
int nex = i;
while (g[nex][ch] == -1) {
nex = f[nex];
}
dp[0][i][g[nex][ch]] = out[g[nex][ch]];
}
}
for (int lg = 1; lg < 48; lg++) {
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
for (int k = 0; k < M; k++) {
dp[lg][i][j] = max(dp[lg][i][j], dp[lg - 1][i][k] + dp[lg - 1][k][j]);
}
}
}
}
int d = 0;
for (int lg = 48 - 1; lg >= 0; lg--) {
long long x = (1LL << lg);
if (L - x >= 0) {
L -= x;
d ^= 1;
for (int i = 0; i < M; i++) {
for (int j = 0; j < M; j++) {
ans[d][i][j] = (-(1LL << 60));
for (int k = 0; k < M; k++) {
ans[d][i][j] = max(ans[d][i][j], ans[!d][i][k] + dp[lg][k][j]);
}
}
}
}
}
long long finalans = (-(1LL << 60));
for (int i = 0; i < M; i++) {
finalans = max(finalans, ans[d][0][i]);
}
cout << finalans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long f(int count) {
long long fac{1};
while (count) fac *= count--;
return fac;
}
int main() {
int n;
cin >> n;
string str;
vector<int> counter(26);
while (n--) {
cin >> str;
counter[str[0] - 'a']++;
}
long long answer{0};
for (auto count : counter) {
auto c1 = count / 2;
auto c2 = ++count / 2;
if (c1 > 0) answer += (c1 * (c1 - 1)) / 2;
if (c2 > 0) answer += (c2 * (c2 - 1)) / 2;
}
cout << answer << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[300], b[300];
int dp[(1 << 24) + 3][3], dist[300][300];
int distanceCalc(int x1, int x2, int y1, int y2) {
return pow(x1 - x2, 2) + pow(y1 - y2, 2);
}
int solve(int mask) {
if (mask >= (1 << n) - 1) return 0;
if (dp[mask][0] != 1000000000) return dp[mask][0];
for (int j = 0; j < n; j++) {
if ((1 << j) & mask) continue;
dp[mask][0] = dist[j][j] + solve(mask | (1 << j));
dp[mask][1] = dp[mask][2] = j;
for (int k = j + 1; k < n; k++) {
if ((1 << k) & mask) continue;
int result = solve(mask | (1 << j) | (1 << k)) + dist[j][k];
if (result < dp[mask][0]) {
dp[mask][2] = k;
dp[mask][0] = result;
}
}
break;
}
return dp[mask][0];
}
void printPath() {
printf("0 ");
int mask = 0;
while (mask < (1 << n) - 1) {
int aux = mask;
printf("%d ", dp[mask][1] + 1);
aux += (1 << dp[mask][1]);
if (dp[mask][1] != dp[mask][2])
printf("%d ", dp[mask][2] + 1), aux += (1 << dp[mask][2]);
mask = aux;
printf("0 ");
}
}
int main() {
int xIni, yIni;
while (scanf("%d %d", &xIni, &yIni) != EOF) {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", &a[i], &b[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j <= i; j++)
dist[i][j] = dist[j][i] = distanceCalc(a[i], a[j], b[i], b[j]) +
distanceCalc(a[i], xIni, b[i], yIni) +
distanceCalc(a[j], xIni, b[j], yIni);
dp[0][0] = 0;
for (int i = 0; i < (1 << n); i++) dp[i][0] = 1000000000;
solve(0);
printf("%d\n", dp[0][0]);
printPath();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int a, b, c;
cin >> a;
if (a == 0) {
cout << 1 << "\n";
return 0;
} else if (a % 4 == 1) {
cout << 8 << "\n";
return 0;
} else if (a % 4 == 2) {
cout << 4 << "\n";
return 0;
} else if (a % 4 == 3) {
cout << 2 << "\n";
return 0;
} else {
cout << 6 << "\n";
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[300009];
int cnt[2][(1 << 20)];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
cnt[1][0] = 1;
int x = 0;
long long res = 0;
for (int i = 0; i < n; ++i) {
x ^= a[i];
res += cnt[i % 2][x];
++cnt[i % 2][x];
}
cout << res;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n = 0;
string s1, s2;
int main() {
cin >> n;
cin >> s1 >> s2;
int m = s1.length();
int k = s2.length();
int k1 = 0;
int k2 = 0;
for (int i = 0; i < n; i++) {
if (s1[i % m] != s2[i % k]) {
if (s1[i % m] == 'R' && s2[i % k] == 'S') {
k1 += 1;
}
if (s1[i % m] == 'S' && s2[i % k] == 'P') {
k1 += 1;
}
if (s1[i % m] == 'P' && s2[i % k] == 'R') {
k1 += 1;
}
if (s2[i % k] == 'R' && s1[i % m] == 'S') {
k2 += 1;
}
if (s2[i % k] == 'S' && s1[i % m] == 'P') {
k2 += 1;
}
if (s2[i % k] == 'P' && s1[i % m] == 'R') {
k2 += 1;
}
}
if (i + 1 == m * k) {
int div = n / (m * k);
int mod = n % (m * k);
k1 *= div;
k2 *= div;
i += m * k * (div - 1);
if (m * k == 1) break;
}
}
cout << k2 << endl << k1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void debug() { cout << endl; }
template <typename T, typename... E>
void debug(T t, E... e) {
cout << t << (sizeof...(e) ? " " : "");
debug(e...);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, p;
cin >> n >> p;
vector<int> range;
vector<int> mult;
for (int i = int(0); i < int(n); ++i) {
int l, r;
cin >> l >> r;
range.push_back((r - l + 1));
mult.push_back((r / p) - ((l - 1) / p));
}
vector<double> prob(n);
for (int i = int(0); i < int(n); ++i) {
int nxt = (i + 1) % n;
int prv = (i - 1 + n) % n;
long long a = range[i] - mult[i];
long long b = range[nxt] - mult[nxt];
prob[i] = 1.0 - (double)(a * b) / (1ll * range[i] * range[nxt]);
b = range[prv] - mult[prv];
prob[i] += 1.0 - (double)(a * b) / (1ll * range[i] * range[prv]);
}
double ans = 0.0;
for (int i = int(0); i < int(n); ++i) {
ans += prob[i];
}
ans *= 1000;
cout << fixed << setprecision(10) << ans << "\n";
}
| 4 |
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
#include <cstring>
#include <cmath>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <ctime>
#include <limits>
#include <queue>
#include <set>
#include <map>
using namespace std;
#define MAX 2000000000ll
#define F(a, b) f[a + 1][b + 1]
#define SetBreak(a, b) if (i == a && j == b)
#define eps 1e-9
#define CLOCKS_PER_SECOND ((clock_t)1000)
#define ll_max numeric_limits<long long>::max();
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define sz(x) (int)(x).size()
//#define max(a,b) ((a) < (b) ? (b) : (a))
#define min(a,b) ((a) > (b) ? (b) : (a))
#define Access(v, pos) (((v) >> (pos)) & 1)
#define ValidPos(a,b) ((a) >= 0 && (a) < n && (b) >= 0 && (b) < m)
#define Serialize(a,b) ((a) * m + (b))
#define For(i,j) for( int (i) = 1 ; (i) <= (j) ; ++(i) )
#define Fork(i,j,k) for( int (i) = (k) ; (i) <= (j) ; ++(i) )
#define For0(i,j) for( int (i) = 0 ; (i) < (j) ; ++(i) )
#define For0k(i,j,k) for( int (i) = (k); (i) < (j) ; ++(i) )
typedef long long ll;
typedef vector<int> vci;
typedef pair<int, int> pii;
template <typename T> void UpdateMax(T& a, T b) {if (a < b) a = b;}
template <typename T> void UpdateMin(T& a, T b) {if (a > b) a = b;}
template<typename T>
inline void read(T &x)
{
x = 0; char c = getchar(); int flag = 1;
while(!isdigit(c)) {if (c == '-') flag = -1; c = getchar();}
while(isdigit(c)) {x = x * 10 + c - '0'; c = getchar();}
x *= flag;
}
template<typename T>
void Unique(vector<T>& vec)
{
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
template<typename T>
void Relabel(vector<T>& vec, T& value)
{
value = lower_bound(vec.begin(), vec.end(), value) - vec.begin() + 1;
}
template <typename T, typename V> void Print(const pair<T, V>& x) { cout<<x.first<<" @ "<<x.second<<" | "; }
template <typename T> void Print(const T& x) { cout<<x<<" "; }
template <typename T> void Pcon(const T& x) { cout<<"\nsize: "<<x.size()<<endl; for (const auto& item : x) Print(item); }
std::vector<int> LABS;
template <typename T> void Print(const T* x, int offset, int loop)
{
for (int i = 0; i <= loop; i++)
{
cout<<"[";
for (int item : LABS)
cout<<item - offset<<",";
cout<<i - offset<<"]:";
cout<<x[i]<<" ";
}
}
template <typename T, typename... Args>
void Print(const T* f, int offset, int loop, Args... args)
{
for (int i = 0; i <= loop; i++)
{
LABS.push_back(i);
Print(f[i], offset, args...);
cout<<endl;
LABS.pop_back();
}
}
template <typename T, typename V>
bool Has(T& cluster, const V& item)
{
return cluster.find(item) != cluster.end();
}
int Logn(ll x) { int cnt = 0; while (x) { ++cnt; x >>= 1; } return cnt; }
//////////////////////////////////////////////////////
const int MOD = 1e9 + 7;
const int N = 5e5 + 5;
const int dir[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {1, 0}};
struct Edg {int x, y, z;friend bool operator < (const Edg& lhs, const Edg& rhs){return lhs.z < rhs.z;}} edg[N];
bool vis[N], used[N];
clock_t start_time;
int t, n, m, a[N];
//////////////////////////////////////////////////////
inline void SetClock() { start_time = clock(); }
bool TimeOut(size_t ms) { if (1000*(clock() - start_time) >= ms * CLOCKS_PER_SECOND) return true; return false; }
inline pii DeSerialize(int c) { return {(c) / m, (c) % m}; }
template <typename T, typename V>
inline void Add(T& v, const V& delta) { v += delta; if (v >= MOD) v -= MOD; }
template <typename T, typename V>
inline void Dec(T& v, const V& delta) { v -= delta; if (v < 0) v += MOD; }
//////////////////////////////////////////////////////
template <typename ValueType>
class SegTree
{
public:
void Init(int n)
{
this->n = n;
memset(val, 0, sizeof(int) * (4 * n + 1));
memset(val2, 0, sizeof(int) * (4 * n + 1));
memset(lazy, 0, sizeof(bool) * (4 * n + 1));
}
ValueType Sum(int x, int y)
{
if (x > y) return 0;
return Sum(1, 1, n, x, y);
}
public:
void PushDown(int u)
{
if (!lazy[u]) return;
lazy[2*u] = lazy[2*u+1] = true;
val[2 * u] = 1 + val2[2 * u];
val[2 * u + 1] = 1 + val2[2 * u + 1];
lazy[u] = false;
}
void Update(int u)
{
val[u] = max(val[2*u], val[2*u + 1]);
val2[u] = max(val2[2*u], val2[2*u + 1]);
}
void Set(int u, int left, int right,
int x, int y, ValueType value)
{
if (left == x && right == y)
{
lazy[u] = value;
val[u] = val2[u] + value;
return;
}
PushDown(u);
int mid = (left+right)>>1;
if (y <= mid)
{
Set(2*u, left, mid, x, y, value);
}
else if (x <= mid)
{
Set(2*u, left, mid, x, mid, value);
Set(2*u+1, mid+1, right, mid+1, y, value);
}
else
{
Set(2*u+1, mid+1, right, x, y, value);
}
//Update(u);
val[u] = max(val[2*u], val[2*u + 1]);
val2[u] = max(val2[2*u], val2[2*u + 1]);
}
void SetValue(int u, int left, int right,
int x, int y, ValueType value)
{
if (left == x && right == y)
{
lazy[u] = 0;
val[u] = val2[u] = value;
return;
}
PushDown(u);
int mid = (left+right)>>1;
if (y <= mid)
{
SetValue(2*u, left, mid, x, y, value);
}
else if (x <= mid)
{
SetValue(2*u, left, mid, x, mid, value);
SetValue(2*u+1, mid+1, right, mid+1, y, value);
}
else
{
SetValue(2*u+1, mid+1, right, x, y, value);
}
Update(u);
}
ValueType Sum(int u, int left, int right, int x, int y)
{
if (left == x && right == y)
{
return val[u];
}
PushDown(u);
int mid = (left+right)>>1;
if (y <= mid)
{
return Sum(2*u, left, mid, x, y);
}
else if (x <= mid)
{
return max(Sum(2*u, left, mid, x, mid),
Sum(2*u+1, mid+1, right, mid+1, y));
}
else
{
return Sum(2*u+1, mid+1, right, x, y);
}
}
private:
ValueType val[4*N], val2[4*N];
bool lazy[4*N];
int n;
};
SegTree<int> mSegTree;
int main()
{
srand(time(0));
SetClock();
cin.sync_with_stdio(false);
//freopen("test.in", "r", stdin);
read(t);
while (t--) {
read(n);
For(i, n) {
read(a[i]);
}
mSegTree.Init(n);
ll ans = 0;
for (int i = 1; i <= n; ++i) {
int tmp = mSegTree.Sum(1, a[i]) + 1;
mSegTree.SetValue(1, 1, n,
a[i], a[i], tmp);
if (a[i] > 1) {
mSegTree.Set(1, 1, n,
1, a[i] - 1, 1);
}
}
cout<<mSegTree.Sum(1, n)<<endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, ans;
char c;
cin >> n >> c;
if (c == 'f') {
if (n % 4 == 1 || n % 4 == 2) {
ans = (n / 2) * 6 + (n - 1) + c - 101;
} else {
ans = ((n / 2) - 1) * 6 + (n - 3) + c - 101;
}
} else if (c == 'e') {
if (n % 4 == 1 || n % 4 == 2) {
ans = (n / 2) * 6 + (n - 1) + c - 99;
} else {
ans = ((n / 2) - 1) * 6 + (n - 3) + c - 99;
}
} else if (c == 'd') {
if (n % 4 == 1 || n % 4 == 2) {
ans = (n / 2) * 6 + (n - 1) + c - 97;
} else {
ans = ((n / 2) - 1) * 6 + (n - 3) + c - 97;
}
} else {
if (n % 4 == 1 || n % 4 == 2) {
ans = (n / 2) * 6 + (n - 1) + c - 93;
} else {
ans = ((n / 2) - 1) * 6 + (n - 3) + c - 93;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
n = unique(a, a + n) - a;
int ans = a[n - 1];
for (int i = 0; i < n; i++) {
int j = i - 1;
while (j >= 0 && a[i] % a[j] == 0) j--;
if (j >= 0) {
ans = (a[i] + a[j] > ans) ? a[i] + a[j] : ans;
int k = j - 1;
while (k >= 0 && (a[i] % a[k] == 0 || a[j] % a[k] == 0)) k--;
if (k >= 0) {
ans = (ans > a[i] + a[j] + a[k]) ? ans : a[i] + a[j] + a[k];
}
}
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 7;
int n;
pair<int, int> a[maxn];
int ans[maxn];
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
int l, r;
cin >> l >> r;
a[2 * i - 1] = make_pair(l, -i);
a[2 * i] = make_pair(r, i);
ans[i] = 0;
}
sort(a + 1, a + 2 * n + 1);
multiset<int> s;
int c = 0;
for (int i = 1; i <= 2 * n; i++) {
if (a[i].second < 0) {
s.insert(-a[i].second);
} else {
s.erase(s.find(a[i].second));
}
if (s.size() == 0) {
c++;
}
if (s.size() == 1 && a[i].second > 0 && a[i + 1].second < 0 &&
a[i + 1].first > a[i].first) {
ans[*s.begin()]++;
}
if (s.size() == 1 && a[i].second < 0 && a[i + 1].second > 0)
ans[*s.begin()] = -1;
}
int Ans = -n;
for (int i = 1; i <= n; i++) Ans = max(Ans, ans[i]);
cout << c + Ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int K = 50010;
int n, k, li, ri, lfv, lsv, rfv, rsv;
inline int question(int i) {
fflush(stdout);
cout << "? " << i << endl;
cin >> i;
return i;
}
int main() {
cin >> n;
if (n % 4 != 0) {
fflush(stdout);
cout << "! -1";
return 0;
}
k = n / 2;
li = 1;
ri = k + 1;
lfv = rsv = question(li);
lsv = rfv = question(ri);
if (lfv == lsv) {
fflush(stdout);
cout << "! " << li;
return 0;
}
while (1) {
int i = (ri + li) / 2;
int fv = question(i);
int sv = question(i + k);
if (fv == sv) {
fflush(stdout);
cout << "! " << i;
return 0;
}
if (sv > fv == lsv > lfv) {
lsv = sv;
lfv = fv;
li = i;
} else {
rsv = sv;
rfv = fv;
ri = i;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long base = 233;
const long long ff = 2e6 + 1;
const long long mod = 998244353;
long long b[ff], c[ff], top, ans;
struct node {
long long pos, va;
} q[ff];
bool cmp(node x, node y) { return x.va > y.va; }
void init() {
long long n, k;
cin >> n >> k;
k = min(k, n);
for (long long i = 1; i <= n; ++i) q[i].pos = i, scanf("%lld", &q[i].va);
sort(q + 1, q + 1 + n, cmp);
for (long long i = 1; i <= k; ++i) b[q[i].pos] = 1, ans += q[i].va;
long long ps = n + 1, ans2 = 1;
for (long long i = 1; i <= n; ++i)
if (b[i]) {
ps = i;
break;
}
for (long long i = ps + 1; i <= n; ++i)
if (b[i]) {
ans2 = ans2 * (i - ps) % mod;
ps = i;
}
cout << ans << " " << ans2 % mod;
}
signed main() {
long long T = 1;
while (T--) init();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100000;
const int L = 5;
int pw10[L];
vector<int> primes[L][M];
int m;
int row[L];
int mat[L][L];
int numLen(int x) {
int ret = 0;
for (; x; x /= 10) ret++;
return ret;
}
int digitAt(int x, int p) { return (x / pw10[p]) % 10; }
int bruteForce(int r) {
int pref = 0;
for (int i = 0; i < r; i++) pref = 10 * pref + mat[r][i];
int l = r + L - m - 1;
vector<int>& ps = primes[l][pref];
int ret = 0;
for (int i = 0; i < ps.size(); i++) {
if (r + 1 < m) {
row[r] = ps[i];
for (int x = row[r], j = 0; j < m - r; j++) {
mat[r][m - 1 - j] = mat[m - 1 - j][r] = x % 10;
x /= 10;
}
ret += bruteForce(r + 1);
} else
ret++;
}
return ret;
}
int main() {
pw10[0] = 1;
for (int i = 1; i < L; i++) pw10[i] = pw10[i - 1] * 10;
for (int i = 2; i < M; i++) {
bool prime = true;
for (int j = 2; j * j <= i; j++)
if (i % j == 0) {
prime = false;
break;
}
if (prime) {
for (int j = 0; j < L; j++) {
int pref = i / pw10[L - j - 1];
primes[j][pref].push_back(i);
}
}
}
int testCnt;
cin >> testCnt;
for (int test = 0; test < testCnt; test++) {
cin >> row[0];
m = numLen(row[0]);
for (int x = row[0], j = 0; j < m; j++) {
mat[0][m - 1 - j] = mat[m - 1 - j][0] = x % 10;
x /= 10;
}
cout << bruteForce(1) << '\n';
}
cerr << (double)(clock()) << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const ld pi = acos(0) * 2;
template <typename T>
inline void read(T &x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
int n, b;
int p[2750132];
vector<int> primes;
int c[2750132];
vector<int> a;
int main() {
primes.push_back(0);
for (int i = (2); i <= (2750131); i++)
if (p[i] == 0) {
primes.push_back(i);
for (int j = i; j <= 2750131; j += i)
if (!p[j]) p[j] = i;
}
read(n);
for (int i = (1); i <= (n * 2); i++) {
read(b);
c[b]++;
}
for (int i = (2750131); i >= (2); i--)
if (p[i] != i)
if (c[i]) {
for (int x = (1); x <= (c[i]); x++) a.push_back(i);
c[i / p[i]] -= c[i];
}
for (int i = (2); i <= (2750131); i++)
if (p[i] == i)
if (c[i]) {
for (int x = (1); x <= (c[i]); x++) a.push_back(i);
c[primes[i]] -= c[i];
}
for (int x : a) {
write(x);
putchar(' ');
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long mod = 1e9 + 7.3;
int n;
double P[N], f[N], A[N], B[N];
char ch[N << 2];
double F(double X) { return 3.0 * X * X + 3.0 * X + 1; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lf", P + i);
for (int i = 1; i <= n; i++) {
A[i] = (A[i - 1] + 1) * P[i];
B[i] = B[i - 1] + (2 * A[i - 1] + 1) * P[i];
}
printf("%.6lf\n", B[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[20007];
int main() {
ios_base::sync_with_stdio(0);
int t = 1;
while (t--) {
int n;
cin >> n;
map<int, int> mp;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
mp[x] = y;
if (mp[x] == -1 * mp[x + y]) {
cout << "YES";
return 0;
}
}
cout << "NO"
<< "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
void reverseQueue() {
stack<int> Stack;
while (!q.empty()) {
Stack.push(q.front());
q.pop();
}
while (!Stack.empty()) {
q.push(Stack.top());
Stack.pop();
}
}
int main() {
map<int, int> m;
int n, k;
cin >> n >> k;
while (n--) {
int a;
cin >> a;
if (m[a] == 0) {
if (q.size() == k) {
m[q.front()] = 0;
q.pop();
q.push(a);
m[a] = 1;
} else {
q.push(a);
m[a] = 1;
}
}
}
cout << q.size() << endl;
reverseQueue();
while (!q.empty()) {
cout << q.front() << " ";
q.pop();
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
long long ans = 0;
int n;
int x1, y1, x2, y2;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
ans += (x2 - x1 + 1) * (y2 - y1 + 1);
}
printf("%lld", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
pair<char, string> ev[N];
int n;
int solve(char le) {
set<char> st;
for (int i = ('a'); i <= ('z'); i++) {
st.insert(i);
}
int need = 0, has = 0;
bool found = false;
for (int i = (1); i <= (n); i++) {
if (ev[i].first == '.') {
for (auto c : ev[i].second) {
st.erase(c);
}
} else if (ev[i].first == '!') {
has++;
set<char> keep;
for (auto c : ev[i].second) {
keep.insert(c);
}
for (int c = ('a'); c <= ('z'); c++) {
if (keep.find(c) == keep.end()) {
st.erase(c);
}
}
} else if (i != n && ev[i].first == '?') {
char gu = ev[i].second[0];
if (gu == le) {
return -1;
} else {
st.erase(gu);
}
has++;
} else if (!found && i == n && ev[i].first == '?') {
return 0;
}
if (st.find(le) == st.end()) return -1;
if (!found && (int)(st).size() == 1 && *(st.begin()) == le) {
found = true;
need = has;
}
}
if (!found) return -1;
return has - need;
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = (1); i <= (n); i++) {
cin >> ev[i].first >> ev[i].second;
}
int ans = -1;
for (int c = ('a'); c <= ('z'); c++) {
ans = max(ans, solve(c));
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char a = getchar();
for (; a > '9' || a < '0'; a = getchar())
if (a == '-') f = -1;
for (; a >= '0' && a <= '9'; a = getchar()) x = x * 10 + a - '0';
return x * f;
}
const double PI = acos(-1);
int n, R, r;
int main() {
n = read();
R = read();
r = read();
double alpha = 2 * PI / n / 2;
double tr = R / (1 + 1 / sin(alpha));
if (r - 1e-8 <= tr || (sin(alpha) <= 1e-8 && R >= r))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int qry(int a, int b, int c) {
cout << "? " << a << " " << b << " " << c << "\n";
fflush(stdout);
int q;
cin >> q;
return q;
}
int main() {
int test;
cin >> test;
while (test--) {
int n;
cin >> n;
vector<int> inf(n / 3);
int imp, cr;
for (int i = 1; i <= n; i += 3) {
int q = qry(i, i + 1, i + 2);
inf[(i - 1) / 3] = q;
if (q == 0) {
imp = i;
} else {
cr = i;
}
}
int ci = 0, cc = 0;
for (int j = 1; j <= 2; j++) {
if (qry(imp, cr, imp + j) == 0)
ci++;
else
cc++;
if (qry(imp, cr, cr + j) == 0)
ci++;
else
cc++;
}
if (ci == 4) {
cr++;
}
if (cc == 4) {
imp++;
}
int ni, nc;
if (qry(imp, cr, imp + 1) == 0) {
ni = imp + 1;
} else {
ni = imp;
}
if (qry(cr, imp, cr + 1) == 1) {
nc = cr + 1;
} else {
nc = cr;
}
imp = ni;
cr = nc;
vector<int> res(n + 1, -1);
res[imp] = 0;
res[cr] = 1;
for (int i = 1; i <= n; i += 3) {
if (inf[(i - 1) / 3] == 0) {
if (qry(i, i + 1, cr) == 0) {
res[i] = 0;
res[i + 1] = 0;
if (qry(cr, i, i + 2) == 0) {
res[i + 2] = 0;
} else {
res[i + 2] = 1;
}
} else {
res[i + 2] = 0;
if (qry(i + 2, cr, i) == 0) {
res[i] = 0;
res[i + 1] = 1;
} else {
res[i] = 1;
res[i + 1] = 0;
}
}
} else {
if (qry(i, i + 1, imp) == 1) {
res[i] = 1;
res[i + 1] = 1;
if (qry(imp, i, i + 2) == 1) {
res[i + 2] = 1;
} else {
res[i + 2] = 0;
}
} else {
res[i + 2] = 1;
if (qry(i + 2, imp, i) == 1) {
res[i] = 1;
res[i + 1] = 0;
} else {
res[i] = 0;
res[i + 1] = 1;
}
}
}
}
int k = 0;
for (int i = 1; i <= n; i++) {
if (res[i] == 0) k++;
}
cout << "! " << k;
for (int i = 1; i <= n; i++) {
if (res[i] == 0) cout << " " << i;
}
cout << "\n";
fflush(stdout);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long dis[300050][2];
map<pair<int, int>, int> edge;
vector<pair<int, int> > adj[300050];
struct node {
long long d[2];
int id;
bool operator<(const node &x) const { return d[0] > x.d[0]; }
} ver[300050];
struct Node {
long long d;
int id;
bool operator<(const Node &x) const { return d > x.d; }
};
set<Node> s;
void dfs(int u, int fa, long long d, int ty) {
dis[u][ty] = d;
for (vector<pair<int, int> >::iterator it = adj[u].begin();
it != adj[u].end(); ++it) {
if (it->first != fa) dfs(it->first, u, d + it->second, ty);
}
}
int main() {
int u, v, w;
scanf("%d%d", &n, &m);
for (register int i = 1; i < n; ++i) {
scanf("%d%d%d", &u, &v, &w), adj[u].push_back(make_pair(v, w)),
adj[v].push_back(make_pair(u, w));
edge[make_pair(v, u)] = 1, edge[make_pair(u, v)] = 1;
}
dfs(1, 0, 0, 0), dfs(n, 0, 0, 1);
for (register int i = 1; i <= n; ++i) ver[i] = node{dis[i][0], dis[i][1], i};
sort(ver + 1, ver + n + 1);
long long qwq = 0;
for (register int i = 1; i <= n; ++i) {
for (set<Node>::iterator it = s.begin(); it != s.end(); ++it) {
if (edge.find(make_pair(it->id, ver[i].id)) != edge.end()) continue;
qwq = max(qwq, ver[i].d[0] + it->d);
break;
}
s.insert(Node{ver[i].d[1], ver[i].id});
}
while (m--) {
scanf("%d", &w);
cout << min(qwq + w, dis[n][0]) << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int n, m, p, k;
int s = 0;
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= m; i++) {
int t;
scanf("%d", &t);
if (i == p) k = t;
s += t;
}
if (s < n) {
printf("-1.0");
return 0;
}
n--;
s--;
k--;
double ans = 1;
for (int i = 0; i < k; i++) ans *= (double)(s - n - i) / (s - i);
printf("%.8llf", 1 - ans);
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.