solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, q, p[200010], last[200010];
int fi(int u) {
if (p[u] != u) p[u] = fi(p[u]);
return p[u];
}
void join(int u, int v) {
u = fi(u);
v = fi(v);
if (u == v) return;
p[v] = u;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
p[i] = i;
last[i] = i;
}
while (q--) {
int tmp, x, y;
cin >> tmp >> x >> y;
if (tmp == 1) {
join(x, y);
} else if (tmp == 2) {
int i = x;
for (i; i <= y; i++) {
int k = last[i];
last[i] = last[y];
join(x, i);
i = k;
}
} else {
x = fi(x);
y = fi(y);
if (x == y)
cout << "YES";
else
cout << "NO";
cout << '\n';
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1005;
struct node {
long long v = -1000000007, i, lazy;
void assign(long long val, long long index) {
v = val;
i = index;
lazy = 0;
}
void merge(node &l, node &r) {
if (l.v >= r.v) {
v = l.v;
i = l.i;
} else {
v = r.v;
i = r.i;
}
lazy = 0;
}
} zero;
class segtree {
node t[4 * maxn];
public:
void pushdown(long long v, long long tl, long long tr) {
if (t[v].lazy) {
long long ln = v * 2;
long long rn = v * 2 + 1;
long long tm = (tl + tr) / 2;
apply(ln, tl, tm, t[v].lazy);
apply(rn, tm + 1, tr, t[v].lazy);
t[v].lazy = 0;
}
}
void apply(long long v, long long tl, long long tr, long long val) {
if (tl != tr) {
t[v].lazy += val;
}
t[v].v += val;
}
void build(long long a[], long long v, long long tl, long long tr) {
if (tl == tr) {
t[v].assign(a[tl], tl);
return;
} else {
long long tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
t[v].merge(t[v * 2], t[v * 2 + 1]);
}
}
void build(long long a[]) { build(a, 1, 0, maxn - 1); }
node query(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > tr || r < tl) return zero;
if (l <= tl && tr <= r) {
return t[v];
}
pushdown(v, tl, tr);
long long tm = (tl + tr) / 2;
node a, b, ans;
a = query(v * 2, tl, tm, l, r);
b = query(v * 2 + 1, tm + 1, tr, l, r);
ans.merge(a, b);
return ans;
}
node query(long long l, long long r) { return query(1, 0, maxn - 1, l, r); }
void rupd(long long v, long long tl, long long tr, long long l, long long r,
long long val) {
if (l > tr || r < tl) return;
if (l <= tl && tr <= r) {
apply(v, tl, tr, val);
return;
}
pushdown(v, tl, tr);
long long tm = (tl + tr) / 2;
rupd(v * 2, tl, tm, l, r, val);
rupd(v * 2 + 1, tm + 1, tr, l, r, val);
t[v].merge(t[v * 2], t[v * 2 + 1]);
}
void rupd(long long l, long long r, long long val) {
rupd(1, 0, maxn - 1, l, r, val);
}
};
long long r[1005], c[1005];
long long a[1000005], b[1000005];
void solve() {
long long n, m, k, p;
cin >> n >> m >> k >> p;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
long long t;
cin >> t;
r[i] += t;
c[j] += t;
}
}
segtree row;
segtree column;
row.build(r);
column.build(c);
for (long long z = 1; z < k + 1; z++) {
node x = row.query(0, n - 1);
node y = column.query(0, m - 1);
a[z] = x.v + a[z - 1];
row.rupd(x.i, x.i, -p * m);
b[z] = y.v + b[z - 1];
column.rupd(y.i, y.i, -p * n);
}
long long ans = -1000000007 / 1000 * 1LL * 1000000007;
for (long long i = 0; i < k + 1; i++) {
long long t = a[i] + b[k - i] - i * (k - i) * p;
ans = max(t, ans);
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
long long t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct node {
int a, b, c, d, t;
bool operator<(const node &x) const { return d > x.d; }
} p[105];
int ans;
int dp[1001];
int main() {
while (~scanf("%d%d%d%d", &n, &m, &p[0].c, &p[0].d)) {
p[m + 1].a = 1000;
p[0].b = 0;
p[0].t = n / p[0].c;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &p[i].a, &p[i].b, &p[i].c, &p[i].d);
p[i].t = p[i].a / p[i].b;
}
ans = 0;
for (int j = 0; j < n; j++) dp[j] = 0;
for (int i = 0; i <= m; i++)
for (int j = 0; j < p[i].t; j++)
for (int k = n; k >= p[i].c; k--)
dp[k] = max(dp[k], dp[k - p[i].c] + p[i].d);
for (int i = 0; i <= n; i++) ans = max(ans, dp[i]);
printf("%d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
cout << n + 1 << '\n';
cout << 2 << ' ' << n << ' ' << 1 << '\n';
cout << 1 << ' ' << n << ' ' << 1000000 << '\n';
for (int i = 0; i < n - 1; i++) {
cout << 2 << ' ' << i + 1 << ' ' << 1000000 - i << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = (1e5) * 2 + 10;
const long long INF = 1e17 + 20;
long long a[max_n], p[max_n], c[max_n];
vector<int> k;
int main() {
ios ::sync_with_stdio(false);
int n, q;
cin >> n;
for (int i = 0; i < n; i++) cin >> c[i], a[i] = c[i];
c[n] = INF;
cin >> q;
for (int i = 0; i < n; i++) p[i] = i + 1;
for (int i = 0; i < q; i++) {
int x, u, v;
cin >> x;
if (x == 1) {
cin >> u >> v;
u--;
if (c[u] >= v)
c[u] -= v;
else {
v -= c[u];
c[u] = 0;
k.clear();
for (int j = p[u]; v;) {
if (c[j] <= v) {
k.push_back(j);
p[u] = p[j];
v -= c[j];
c[j] = 0;
j = p[j];
} else {
for (auto g : k) p[g] = j;
c[j] -= v;
v = 0;
}
}
}
} else {
cin >> u;
cout << a[u - 1] - c[u - 1] << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1000 + 5][1000 + 5];
int f(int i, int j) {
if (a[i - 1][j - 1] + a[i][j - 1] + a[i - 1][j] + a[i][j] == 4) return 1;
if (a[i][j - 1] + a[i + 1][j - 1] + a[i][j] + a[i + 1][j] == 4) return 1;
if (a[i - 1][j] + a[i - 1][j + 1] + a[i][j] + a[i][j + 1] == 4) return 1;
if (a[i][j] + a[i + 1][j] + a[i][j + 1] + a[i + 1][j + 1] == 4) return 1;
return 0;
}
int main() {
memset(a, sizeof(a), 0);
int n, m, k;
cin >> n >> m >> k;
int pd = 0;
int ii;
for (ii = 0; ii < k; ii++) {
int i, j;
scanf("%d%d", &i, &j);
a[i][j] = 1;
if (f(i, j) == 1) {
cout << (ii + 1) << endl;
pd = 1;
break;
}
}
if (pd == 0) cout << "0" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, dem, d[100010], kq[100010], dd[100010];
vector<int> a[100010];
void nhap() {
cin >> n;
int u, v;
for (int i = 1; i <= 2 * n; i++) {
scanf("%d%d", &u, &v);
a[u].push_back(v);
a[v].push_back(u);
}
}
void dfs(int x, int y, int z) {
int ok;
d[x] = y;
dd[y] = 1;
if (x == n - 1) dem = 1;
for (int i = 0; i < 4; i++)
if (!dd[a[y][i]]) {
ok = 0;
for (int j = 0; j < 4; j++)
if (a[z][j] == a[y][i]) {
ok = 1;
break;
}
if (ok) dfs(x + 1, a[y][i], y);
}
}
void cbi(int i, int j) {
memset(d, 0, sizeof(d));
memset(dd, 0, sizeof(dd));
dem = 0;
d[1] = 1;
d[2] = a[1][i];
d[n] = a[1][j];
dd[d[2]] = dd[d[n]] = dd[1] = 1;
}
void xuli() {
for (int i = 1; i <= n; i++)
if (a[i].size() != 4) {
cout << -1;
exit(0);
}
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++) {
cbi(i, j);
dfs(2, d[2], 1);
if (dem)
for (int k = 1; k <= n; k++) kq[k] = d[k];
}
}
void ghikq() {
if (kq[1])
for (int i = 1; i <= n; i++) printf("%d ", kq[i]);
else
cout << -1;
}
int main() {
nhap();
xuli();
ghikq();
return 0;
}
| 6 |
#include <bits/stdc++.h>
void readInt(int &n) {
char ch;
n = 0;
while (ch = getchar()) {
if (ch >= '0' && ch <= '9')
n = n * 10 + ch - 48;
else
break;
}
}
int main() {
int n, tmp;
int sum[3] = {0};
readInt(n);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n - i; j++) {
readInt(tmp);
sum[i] ^= tmp;
}
}
printf("%d\n%d\n", sum[0] ^ sum[1], sum[1] ^ sum[2]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5050;
const int inf = 0x37373737;
int L[N], R[N], size[N], tot, n, i, a, b, cnt, j, k;
int d[N], root;
int dp[N][N];
vector<pair<int, int> > vec[N];
vector<int> e[N];
void dfs(int x, int fa) {
int i, j, k;
if (e[x].size() == 1) size[x] = 1;
for (i = 0; i < e[x].size(); i++)
if (e[x][i] != fa) {
dfs(e[x][i], x);
for (j = size[x]; j >= 0; j--)
for (k = 0; k <= size[e[x][i]]; k++)
dp[x][j + k] = min(dp[x][j + k], dp[x][j] + dp[e[x][i]][k]);
size[x] += size[e[x][i]];
}
for (i = 0; i <= size[x]; i++)
dp[x][i] = min(dp[x][i], dp[x][size[x] - i] + 1);
}
int main() {
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
e[a].push_back(b);
e[b].push_back(a);
d[a]++;
d[b]++;
}
if (n == 2) {
printf("1");
return 0;
}
for (i = 1; i <= n; i++)
if (d[i] != 1) break;
root = i;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) dp[i][j] = inf;
dfs(root, 0);
printf("%d\n", dp[root][size[root] / 2]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
string p[] = {"", "2", "3", "322", "5", "53", "7", "7222", "7332"};
int main() {
int n;
cin >> n;
string s;
cin >> s;
string res;
for (int i = 0; i < (int)(n); ++i) {
if (s[i] == '0') continue;
res += p[s[i] - '1'];
}
sort(res.rbegin(), res.rend());
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 2) {
cout << "2\n1 2\n";
continue;
}
cout << "2\n";
cout << n << " " << n - 2 << "\n";
cout << n - 1 << " " << n - 1 << "\n";
int pos = n - 1, next = n - 3;
for (long long i = (0); i < (long long)(n - 3); i++) {
cout << pos << " " << next << "\n";
pos--;
next--;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
for (long long j = 0; j < t; j++) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (b >= a)
cout << b << "\n";
else {
if (c <= d)
cout << "-1\n";
else {
long long count = 0;
if ((a - b) % (c - d) == 0)
count = (a - b) / (c - d);
else
count = (a - b + c - d - 1) / (c - d);
cout << b + count * c << "\n";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int mat[101][101], k;
bool occupied(int x, int y, int m) {
int i;
if (y + m > k + 1) return true;
for (i = y; i < y + m; i++) {
if (mat[x][i]) return true;
}
return false;
}
int calc(int xc, int yc, int x, int y, int m) {
int i, res = 0;
res += (m)*fabs(x - xc);
for (i = y; i < y + m; i++) {
res += fabs(i - yc);
}
return res;
}
int main() {
int n, m, x, y, flag, res, tmp, j, yy, xx, xc, yc;
while (cin >> n >> k) {
memset(mat, 0, sizeof(mat));
xc = (k + 1) / 2;
yc = (k + 1) / 2;
while (n--) {
flag = 0;
cin >> m;
res = ((long long)1 << 30);
for (x = 1; x <= k; x++) {
for (y = 1; y <= k; y++) {
if (!occupied(x, y, m)) {
tmp = calc(xc, yc, x, y, m);
if (tmp < res) {
flag = 1;
res = tmp;
xx = x;
yy = y;
}
}
}
}
if (flag) {
cout << xx << " " << yy << " " << yy + m - 1 << endl;
for (j = yy; j < yy + m; j++) {
mat[xx][j] = 1;
}
} else
cout << -1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool vwl(char c) {
return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
}
string cnst(string a, string b, string c, string d) {
if (a == b && b == c && c == d) return "aaaa";
if (a == b && c == d && b != c) return "aabb";
if (b == c && a == d && b != a) return "abba";
if (a == c && b == d && a != b) return "abab";
return "NO";
}
void solve() {
int n, k;
cin >> n >> k;
vector<string> v(4 * n);
for (auto &x : v) cin >> x;
string p1, p2, p3, p4;
p1 = p2 = p3 = p4 = "b";
int ln = v[0].size(), now = 0;
for (int i = ln - 1; i >= 0; i--) {
if (vwl(v[0][i])) now++;
if (now == k) {
p1 = v[0].substr(i);
break;
}
}
if (p1 == "b") {
cout << "NO\n";
return;
}
ln = v[1].size(), now = 0;
for (int i = ln - 1; i >= 0; i--) {
if (vwl(v[1][i])) now++;
if (now == k) {
p2 = v[1].substr(i);
break;
}
}
if (p2 == "b") {
cout << "NO\n";
return;
}
ln = v[2].size(), now = 0;
for (int i = ln - 1; i >= 0; i--) {
if (vwl(v[2][i])) now++;
if (now == k) {
p3 = v[2].substr(i);
break;
}
}
if (p3 == "b") {
cout << "NO\n";
return;
}
ln = v[3].size(), now = 0;
for (int i = ln - 1; i >= 0; i--) {
if (vwl(v[3][i])) now++;
if (now == k) {
p4 = v[3].substr(i);
break;
}
}
if (p4 == "b") {
cout << "NO\n";
return;
}
string res = cnst(p1, p2, p3, p4);
if (res == "NO") {
cout << res + '\n';
return;
}
for (int i = 4; i < 4 * n; i += 4) {
string s1, s2, s3, s4;
s1 = s2 = s3 = s4 = "b";
now = 0, ln = v[i].size();
for (int j = ln - 1; j >= 0; j--) {
if (vwl(v[i][j])) now++;
if (now == k) {
s1 = v[i].substr(j);
break;
}
}
if (s1 == "b") {
cout << "NO\n";
return;
}
now = 0, ln = v[i + 1].size();
for (int j = ln - 1; j >= 0; j--) {
if (vwl(v[i + 1][j])) now++;
if (now == k) {
s2 = v[i + 1].substr(j);
break;
}
}
if (s2 == "b") {
cout << "NO\n";
return;
}
now = 0, ln = v[i + 2].size();
for (int j = ln - 1; j >= 0; j--) {
if (vwl(v[i + 2][j])) now++;
if (now == k) {
s3 = v[i + 2].substr(j);
break;
}
}
if (s3 == "b") {
cout << "NO\n";
return;
}
now = 0, ln = v[i + 3].size();
for (int j = ln - 1; j >= 0; j--) {
if (vwl(v[i + 3][j])) now++;
if (now == k) {
s4 = v[i + 3].substr(j);
break;
}
}
if (s4 == "b") {
cout << "NO\n";
return;
}
string cres = cnst(s1, s2, s3, s4);
if (res == "aaaa" && cres != "aaaa") {
res = cres;
continue;
}
if (cres == "aaaa") continue;
if (cres == "NO" || cres != res) {
cout << "NO\n";
return;
}
}
cout << res + '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000500;
long long segTree[4 * MAX], segTreeMax[4 * MAX];
int divisor[MAX];
vector<int> v;
void div() {
memset(divisor, 0, sizeof(divisor));
for (int i = 1; i < MAX; i++) {
for (int j = i; j < MAX; j += i) {
divisor[j]++;
}
}
}
void buildSegTree(int p, int l, int r) {
if (l == r) {
segTree[p] = v[r];
segTreeMax[p] = v[r];
} else {
int m = (l + r) / 2;
int lc = 2 * p;
int rc = lc + 1;
buildSegTree(lc, l, m);
buildSegTree(rc, m + 1, r);
segTree[p] = segTree[lc] + segTree[rc];
segTreeMax[p] = max(segTree[lc], segTree[rc]);
}
}
void updateSegTree(int p, int l, int r, int ql, int qr) {
if (segTreeMax[p] <= 2) {
return;
}
if (l == r) {
segTree[p] = segTreeMax[p] = divisor[segTreeMax[p]];
} else {
int m = (l + r) / 2;
int lc = 2 * p;
int rc = lc + 1;
if (qr <= m) {
updateSegTree(lc, l, m, ql, qr);
} else if (ql > m) {
updateSegTree(rc, m + 1, r, ql, qr);
} else {
updateSegTree(lc, l, m, ql, qr);
updateSegTree(rc, m + 1, r, ql, qr);
}
segTree[p] = segTree[lc] + segTree[rc];
segTreeMax[p] = max(segTreeMax[lc], segTreeMax[rc]);
}
}
long long querySegTree(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
return segTree[p];
} else {
int m = (l + r) / 2;
int lc = 2 * p;
int rc = lc + 1;
if (qr <= m) {
return querySegTree(lc, l, m, ql, qr);
} else if (ql > m) {
return querySegTree(rc, m + 1, r, ql, qr);
} else {
return querySegTree(lc, l, m, ql, qr) +
querySegTree(rc, m + 1, r, ql, qr);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
v.push_back(0);
for (int i = 0; i < n; i++) {
int aux;
cin >> aux;
v.push_back(aux);
}
buildSegTree(1, 1, n);
div();
for (int i = 0; i < m; i++) {
int command, ql, qr;
cin >> command >> ql >> qr;
if (command == 1) {
updateSegTree(1, 1, n, ql, qr);
} else {
cout << querySegTree(1, 1, n, ql, qr) << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator+(ostream& out, const vector<T>& vec) {
for (const auto& x : vec) {
out << x << " ";
}
out << "\n";
return out;
}
template <typename T>
ostream& operator*(ostream& out, const vector<T>& vec) {
for (const auto& x : vec) {
out + x;
}
return out;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& vec) {
for (auto& x : vec) {
in >> x;
}
return in;
}
const int N = 2e6 + 5;
const int mod = 1e9 + 7;
vector<int> g[N];
int vis[N];
long long e = 0;
long long v = 0;
void dfs(int u) {
v++;
vis[u] = 1;
e += g[u].size();
for (auto i : g[u]) {
if (!vis[i]) {
dfs(i);
}
}
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
e = 0, v = 0;
if (!vis[i]) {
dfs(i);
if (e / 2 == v - 1) {
ans++;
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int b[200005];
int c[200005];
int vis[200005];
int re[200005];
int len1, len2;
int main() {
int n;
scanf("%d", &n);
int flag = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (++vis[a[i]] > 2) flag = 1;
}
if (flag)
printf("NO\n");
else {
flag = 0;
b[len1++] = -1;
c[len2++] = 0x3f3f3f3f;
for (int i = 0; i < n; i++) {
if (a[i] >= c[len2 - 1] && a[i] <= b[len1 - 1]) {
flag = 1;
break;
}
if (a[i] == c[len2 - 1])
b[len1++] = a[i];
else if (a[i] == b[len1 - 1]) {
c[len2++] = a[i];
re[i] = 1;
} else if (a[i] >= a[i + 1]) {
if (a[i] < c[len2 - 1]) {
c[len2++] = a[i];
re[i] = 1;
} else
b[len1++] = a[i];
} else if (a[i] < a[i + 1]) {
if (a[i] > b[len1 - 1])
b[len1++] = a[i];
else {
c[len2++] = a[i];
re[i] = 1;
}
}
}
if (flag)
printf("NO\n");
else {
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d ", re[i]);
printf("\n");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int px(int i) {
for (int j = 2; (j * j) <= i; j++) {
if (i % j == 0) {
return j;
}
}
return i;
}
int main() {
ios_base::sync_with_stdio(false);
int p, y;
cin >> p >> y;
for (int i = y; i > p; i--) {
if (px(i) > p) {
cout << i;
return 0;
}
}
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
struct state {
int pos[3];
int who[3];
bool candrop[3], canmove[3], canpick[3];
};
bool operator<(const state &s1, const state &s2) {
int i = 0;
while (i < 3 && s1.pos[i] == s2.pos[i]) ++i;
if (i < 3) return s1.pos[i] < s2.pos[i];
i = 0;
while (i < 3 && s1.who[i] == s2.who[i]) ++i;
if (i < 3) return s1.who[i] < s2.who[i];
i = 0;
while (i < 3 && s1.candrop[i] == s2.candrop[i]) ++i;
if (i < 3) return s1.candrop[i] < s2.candrop[i];
i = 0;
while (i < 3 && s1.canmove[i] == s2.canmove[i]) ++i;
if (i < 3) return s1.canmove[i] < s2.canmove[i];
i = 0;
while (i < 3 && s1.canpick[i] == s2.canpick[i]) ++i;
if (i < 3) return s1.canpick[i] < s2.canpick[i];
return false;
}
set<state> used;
int lenmove[3], lendrop[3];
int ans = -1;
int ts;
int iter = 0;
void rec(state cur) {
iter++;
if (iter == 10000) {
iter = 0;
if (clock() - ts > 1000) printf("%d\n", ans), exit(0);
}
if (used.count(cur)) return;
used.insert(cur);
ans = max(ans, max(max(cur.pos[0], cur.pos[1]), cur.pos[2]));
int ubound = 0;
for (int i = 0; i < 3; ++i) ubound = max(cur.pos[i], ubound);
for (int i = 0; i < 3; ++i) {
if (cur.canmove[i]) ubound += lenmove[i];
if (cur.candrop[i]) ubound += lendrop[i];
}
if (ubound <= ans) return;
int d[3] = {-1, -1, -1};
for (int i = 0; i < 3; ++i)
if (cur.who[i] != -1) d[cur.who[i]] = i;
for (int i = 0; i < 3; ++i) {
if (d[i] != -1) continue;
if (cur.who[i] == -1) {
if (cur.canmove[i]) {
for (int dist = -lenmove[i]; dist <= lenmove[i]; ++dist) {
int newpos = cur.pos[i] + dist;
if (cur.pos[0] == newpos || cur.pos[1] == newpos ||
cur.pos[2] == newpos)
continue;
state to = cur;
to.pos[i] = newpos;
to.canmove[i] = false;
rec(to);
}
}
if (cur.canpick[i]) {
for (int j = 0; j < 3; ++j)
if (i != j) {
if (abs(cur.pos[i] - cur.pos[j]) == 1 && d[j] == -1) {
state to = cur;
to.canpick[i] = false;
to.who[i] = j;
to.pos[j] = cur.pos[i];
if (cur.who[j] != -1) to.pos[cur.who[j]] = cur.pos[i];
rec(to);
}
}
}
} else {
if (cur.candrop[i]) {
for (int dist = -lendrop[i]; dist <= lendrop[i]; ++dist) {
int newpos = dist + cur.pos[i];
if (cur.pos[0] == newpos || cur.pos[1] == newpos ||
cur.pos[2] == newpos)
continue;
state to = cur;
to.candrop[i] = false;
to.who[i] = -1;
to.pos[cur.who[i]] = newpos;
if (cur.who[cur.who[i]] != -1) {
to.pos[cur.who[cur.who[i]]] = newpos;
}
rec(to);
}
}
}
}
}
int main() {
ts = clock();
state start;
memset(start.candrop, 1, sizeof(start.candrop));
memset(start.canpick, 1, sizeof(start.canpick));
memset(start.canmove, 1, sizeof(start.canmove));
memset(start.who, -1, sizeof(start.who));
for (int i = 0; i < 3; ++i) {
scanf("%d%d%d", &start.pos[i], &lenmove[i], &lendrop[i]);
}
rec(start);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
long long x, y;
cin >> t;
for (int i = 1; i <= t; i++) {
cin >> x >> y;
if ((x - y) >= 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int powmod(long long int a, long long int b) {
if (b == 0) return 1;
long long int x = powmod(a, b / 2);
long long int y = (x * x) % 1000000007;
if (b % 2) return (a * y) % 1000000007;
return y % 1000000007;
}
int dp[110][4];
int a[110];
int n;
int rec(int i, int prev) {
if (i == n) return 0;
if (dp[i][prev] != -1) return dp[i][prev];
int ret = 1000000007;
if (a[i] == 0)
ret = min(ret, 1 + rec(i + 1, 0));
else if (a[i] == 1) {
ret = min(ret, 1 + rec(i + 1, 0));
if (prev != 1) ret = min(ret, rec(i + 1, 1));
} else if (a[i] == 2) {
ret = min(ret, 1 + rec(i + 1, 0));
if (prev != 2) ret = min(ret, rec(i + 1, 2));
} else if (a[i] == 3) {
ret = min(ret, 1 + rec(i + 1, 0));
if (prev != 1) ret = min(ret, rec(i + 1, 1));
if (prev != 2) ret = min(ret, rec(i + 1, 2));
}
dp[i][prev] = ret;
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
memset(dp, -1, sizeof(dp));
int ans = rec(0, 0);
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void move(char b[], int n, int i) {
for (int j = i; j < n - 1; ++j) {
b[j] = b[j + 1];
}
}
int main() {
int a[10];
char b[101];
char d[101];
int c;
int n, q, nd, nn;
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
for (int i = 0; i < q; ++i) {
for (int j = 0; j < 10; ++j) a[j] = 0;
int l, r;
cin >> l >> r;
nn = 0;
for (int j = l - 1; j < r; ++j) {
d[j - (l - 1)] = b[j];
if (d[j - (l - 1)] >= '0' && d[j - (l - 1)] <= '9') ++nn;
}
nd = r - l + 1;
int cp = 0;
char dp = '>';
while (1) {
if (nn <= 0 || cp < 0 || cp >= nd) {
break;
}
if (d[cp] == '<') {
dp = '<';
if (cp == 0) {
break;
}
if (d[cp - 1] == '>' || d[cp - 1] == '<') {
move(d, nd, cp);
--nd;
}
} else if (d[cp] == '>') {
dp = '>';
if (cp == nd - 1) {
break;
}
if (d[cp + 1] == '>' || d[cp + 1] == '<') {
move(d, nd, cp);
--cp;
--nd;
}
} else if (d[cp] >= '1' && d[cp] <= '9') {
++a[d[cp] - '0'];
--d[cp];
} else if (d[cp] == '0') {
++a[0];
move(d, nd, cp);
if (dp == '>') {
--cp;
}
--nn;
--nd;
}
if (dp == '<') {
--cp;
} else {
++cp;
}
}
for (int j = 0; j < 9; ++j) {
cout << a[j] << " ";
}
cout << a[9] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct course {
int start, finish;
};
course c[200001], p[200001];
int n, m;
bool cmp1(course x, course y) { return x.finish < y.finish; }
bool cmp2(course x, course y) { return x.start > y.start; }
int main() {
int i;
cin >> n;
for (i = 1; i <= n; i++) cin >> c[i].start >> c[i].finish;
cin >> m;
for (i = 1; i <= m; i++) cin >> p[i].start >> p[i].finish;
int d, dmax = 0;
sort(c + 1, c + n + 1, cmp1);
sort(p + 1, p + m + 1, cmp2);
d = p[1].start - c[1].finish;
if (d > dmax) dmax = d;
sort(p + 1, p + m + 1, cmp1);
sort(c + 1, c + n + 1, cmp2);
d = c[1].start - p[1].finish;
if (d > dmax) dmax = d;
cout << dmax;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int c[201];
vector<int> pre[201];
int n;
int solve(int current) {
bool mark[201] = {0};
int cnt = 0, ans = 0;
while (cnt < n) {
for (int i = 0; i < n; i++) {
if (mark[i]) continue;
if (c[i] != current + 1) continue;
bool all_pre_ok = true;
for (int j = 0; j < pre[i].size() && all_pre_ok; j++)
if (!mark[pre[i][j]]) all_pre_ok = false;
if (!all_pre_ok) continue;
cnt++;
mark[i] = 1;
i = -1;
}
current++;
current %= 3;
ans++;
}
return ans - 1;
}
int main() {
int a, b;
cin >> n;
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) {
cin >> a;
for (int j = 0; j < a; j++) {
cin >> b;
pre[i].push_back(b - 1);
}
}
cout << n + min(solve(0), min(solve(1), solve(2))) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, r;
cin >> a >> b >> r;
if (a >= 2 * r) {
if (b >= 2 * r) {
cout << "First";
} else {
cout << "Second";
}
} else {
cout << "Second";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int abs(int n) {
if (n > 0) {
return n;
} else {
return -n;
}
}
int binpow(int a, int n) {
int res = 1;
int base = a;
while (n != 0) {
if (n % 2 == 0) {
base *= base;
n /= 2;
} else {
res *= base;
n--;
}
}
return res;
}
int main() {
int N;
cin >> N;
int curb, curw;
priority_queue<pair<int, int> > w, b;
pair<int, int> A[N];
bool usedw = false, usedb = false;
int numw = -1, numb = -1;
int numbi = -1, numwi = -1;
bool usedwi = false, usedbi = false;
for (int i = 0; i < N; i++) {
cin >> A[i].first >> A[i].second;
if (A[i].first == 0 && !usedw && A[i].second != 0) {
usedw = true;
numw = i;
}
if (A[i].first == 1 && !usedb && A[i].second != 0) {
usedb = true;
numb = i;
}
if (A[i].first == 0 && !usedwi) {
usedwi = true;
numwi = i;
}
if (A[i].first == 1 && !usedbi) {
usedbi = true;
numbi = i;
}
}
for (int i = 0; i < N; i++) {
if (A[i].first == 0)
if (A[i].second != 0)
w.push(make_pair(A[i].second, i));
else {
if (numb >= 0)
cout << numb + 1 << " " << i + 1 << " " << 0 << endl;
else
cout << numbi + 1 << " " << i + 1 << " " << 0 << endl;
}
else {
if (A[i].second != 0)
b.push(make_pair(A[i].second, i));
else {
if (numb >= 0)
cout << numw + 1 << " " << i + 1 << " " << 0 << endl;
else {
if (i != numbi) cout << numwi + 1 << " " << i + 1 << " " << 0 << endl;
}
}
}
}
int cw, cb, lw = 0, lb = 1, lcw, lcb;
if (!w.empty() && !b.empty()) {
cw = w.top().first;
cb = b.top().first;
curw = w.top().second;
curb = b.top().second;
if (cw > cb) {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cb
<< endl;
w.pop();
b.pop();
w.push(make_pair(cw - cb, curw));
} else {
if (cw < cb) {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cw
<< endl;
w.pop();
b.pop();
b.push(make_pair(cb - cw, curb));
} else {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cw
<< endl;
w.pop();
b.pop();
lw = cw;
lb = cb;
lcw = curw;
lcb = curb;
}
}
}
while (!w.empty() && !b.empty()) {
cw = w.top().first;
cb = b.top().first;
curw = w.top().second;
curb = b.top().second;
if (cw > cb) {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cb
<< endl;
w.pop();
b.pop();
w.push(make_pair(cw - cb, curw));
} else {
if (cw < cb) {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cw
<< endl;
w.pop();
b.pop();
b.push(make_pair(cb - cw, curb));
} else {
cout << w.top().second + 1 << " " << b.top().second + 1 << " " << cw
<< endl;
if (lw == lb) {
cout << w.top().second + 1 << " " << lcb + 1 << " " << 0 << endl;
}
w.pop();
b.pop();
lw = cw;
lb = cb;
lcw = curw;
lcb = curb;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
if (k >= n * (n - 1) / 2) {
cout << "no solution\n";
return 0;
}
int curx = 0;
for (int i = n - 1; i >= 0; --i) {
cout << 0 << ' ' << curx << '\n';
curx += i;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005, Inf = 1e9;
inline int gi() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while ('0' <= c && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum;
}
int n, a[maxn], b[maxn], Id[maxn], vis[maxn];
long long v[maxn];
priority_queue<pair<long long, long long> > q;
bool cmp(int x, int y) { return v[x] == v[y] ? x > y : v[x] < v[y]; }
bool check(int T) {
priority_queue<pair<long long, long long> > tmp;
swap(q, tmp);
for (int i = 1; i <= 2 * n; ++i) Id[i] = i, vis[i] = 0;
for (int i = 1; i <= 2 * n; ++i) v[i] = b[i];
sort(Id + 1, Id + 2 * n + 1, cmp);
for (int i = 1; i <= 2 * n; ++i) {
q.push(make_pair((long long)T * a[Id[i]] + b[Id[i]], i));
if (Id[i] <= n) vis[Id[q.top().second]]++;
}
for (int i = 1; i <= 2 * n; ++i) v[i] = (long long)a[i] * T + b[i];
sort(Id + 1, Id + 2 * n + 1, cmp);
int cnt = 0;
for (int i = 1; i <= 2 * n; ++i) {
if (Id[i] > n) --cnt;
cnt += vis[Id[i]];
if (cnt > 0) return 0;
}
return 1;
}
struct edge {
int to, next, cap, cost;
} e[maxn * 50];
int h[maxn * 6], tot;
int S, T, pu[maxn * 6], pe[maxn * 6];
inline void add(int u, int v, int w, int f) {
e[++tot] = (edge){v, h[u], w, f};
h[u] = tot;
e[++tot] = (edge){u, h[v], 0, -f};
h[v] = tot;
}
queue<int> que;
int dis[maxn * 6];
bool spfa() {
static bool vis[maxn * 6];
memset(dis, 63, sizeof(int) * (T + 1));
memset(vis, 0, sizeof(bool) * (T + 1));
que.push(S);
vis[S] = true;
dis[S] = 0;
int u, v;
while (!que.empty()) {
u = que.front();
que.pop();
vis[u] = false;
for (int i = h[u]; ~i; i = e[i].next)
if (dis[v = e[i].to] > dis[u] + e[i].cost && e[i].cap) {
dis[v] = dis[u] + e[i].cost;
pe[v] = i;
pu[v] = u;
if (!vis[v]) que.push(v), vis[v] = true;
}
}
return dis[T] < 1e9;
}
int solve(int t) {
S = 6 * n + 1;
T = S + 1;
tot = -1;
memset(h, -1, sizeof(int) * (T + 1));
for (int i = 1; i <= n; ++i) {
add(S, i, 1, 0);
add(i, i + n, 1, 1);
add(i, i + 3 * n, 1 << 20, 0);
add(i + n, i + 3 * n, 1 << 20, 0);
add(i + 2 * n, i + 4 * n, 1 << 20, 0);
add(i + 2 * n, i + 5 * n, 1 << 20, 0);
add(i + 4 * n, i + 5 * n, 1, 1);
add(i + 5 * n, T, 1, 0);
}
for (int i = 1; i <= 2 * n; ++i) Id[i] = i, v[i] = b[i];
sort(Id + 1, Id + 2 * n + 1, cmp);
for (int i = 2 * n; i >= 2; --i) {
add(Id[i] + n, Id[i - 1] + n, 1 << 20, 0);
if (v[Id[i]] == v[Id[i - 1]])
add(Id[i - 1] + 1 * n, Id[i] + 1 * n, 1 << 20, 0);
}
for (int i = 1; i <= 2 * n; ++i) v[i] = (long long)a[i] * t + b[i];
sort(Id + 1, Id + 2 * n + 1, cmp);
for (int i = 2 * n; i >= 2; --i) {
add(Id[i] + 3 * n, Id[i - 1] + 3 * n, 1 << 20, 0);
if (v[Id[i]] == v[Id[i - 1]])
add(Id[i - 1] + 3 * n, Id[i] + 3 * n, 1 << 20, 0);
}
int cost = 0, flow = 0;
while (spfa()) {
int f = Inf, c = 0;
for (int i = T; i != S; i = pu[i]) {
f = min(f, e[pe[i]].cap);
c += e[pe[i]].cost;
}
cost += f * c;
flow += f;
for (int i = T; i != S; i = pu[i]) {
e[pe[i]].cap -= f;
e[pe[i] ^ 1].cap += f;
}
}
return cost;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 2 * n; ++i) scanf("%d%d", &a[i], &b[i]);
int l = 0, r = Inf;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (l == Inf)
puts("-1");
else
printf("%d %d\n", l, solve(l));
return 0;
}
| 13 |
#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; }
double PI = 3.1415926536;
const int inf = 1e9 + 7;
long long MAX(long long a, long long b) { return a > b ? a : b; }
long long MIN(long long a, long long b) { return a > b ? b : a; }
inline bool ispalindrome(string s) {
int n = s.length(), i = 0, j = n - 1;
while (i <= j) {
if (s[i] != s[j]) return false;
i++, j--;
}
return true;
}
inline bool isprime(long long n) {
if (n % 2 == 0) return false;
for (int i = 3; i * i <= n; i += 2)
if (n % i == 0) return false;
return true;
}
void solve() {
int n, k;
cin >> n >> k;
queue<int> q;
set<int> vals;
for (int i = 0; i < n; ++i) {
int id;
cin >> id;
if (!vals.count(id)) {
if (int(q.size()) >= k) {
int cur = q.front();
q.pop();
vals.erase(cur);
}
vals.insert(id);
q.push(id);
}
}
vector<int> res;
while (!q.empty()) {
res.push_back(q.front());
q.pop();
}
reverse(res.begin(), res.end());
cout << res.size() << "\n";
for (auto it : res) cout << it << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
void faster() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
void solve() {
long long n;
cin >> n;
vector<pair<long long, long long> > prs;
vector<long long> a;
vector<long long> b;
long long l, r;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
cin >> l >> r;
prs.emplace_back(make_pair(l, r));
a.emplace_back(l);
b.emplace_back(r);
}
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
sort((prs).begin(), (prs).end());
long long ans = 0;
long long mx = 0;
for (auto p : prs) {
l = p.first;
r = p.second;
if (r < mx)
ans++;
else
mx = r;
}
cout << ans << endl;
}
signed main() {
faster();
long long t = 1;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long ax[300000], ay[300000], x[300000], y[300000], n, J;
int main() {
int i, j, k;
while (cin >> n >> J) {
cin >> x[0] >> y[0];
for (i = 0; i < n; i++) {
cin >> ax[i] >> ay[i];
ax[i + n] = ax[i];
ay[i + n] = ay[i];
}
for (i = 1; i < 2 * n; i++) {
x[i] = 2 * ax[i - 1] - x[i - 1];
y[i] = 2 * ay[i - 1] - y[i - 1];
}
i = J % (2 * n);
cout << x[i] << " " << y[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return s == 0 ? 0 : cntbit(s >> 1) + (s & 1);
}
int n, m, k;
int a[105][105];
int solve1() {
int res = 1000000005;
for (int i = (1); i <= (m); ++i) {
int ret = 0, d;
for (int j = (1); j <= (m); ++j) {
int num = 0;
for (int t = (1); t <= (n); ++t) {
d = a[t][j] ^ a[t][i];
num += d;
}
ret += min(num, n - num);
}
res = min(res, ret);
}
return res;
}
int solve2() {
int res = 1000000005;
for (int mask = 0; mask < (1 << m); mask++) {
int ret = 0, d;
for (int i = (1); i <= (n); ++i) {
int num = 0;
for (int j = (1); j <= (m); ++j) {
d = a[i][j] ^ getbit(mask, j - 1);
num += d;
}
ret += min(num, m - num);
}
res = min(res, ret);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
int res = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
if (m > 10) {
res = solve1();
} else
res = solve2();
if (res > k)
cout << -1 << endl;
else
cout << res << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200020;
vector<int> p[N], a[N];
map<pair<int, pair<int, int> >, int> g;
int c, n, m, x, y, d[N], l[N], r[N];
string s[N];
void fs(int x, int y) {
p[y].push_back(x);
l[x] = c++, d[x] = y;
for (int &i : a[x]) fs(i, y + 1);
r[x] = c;
}
int Q(int x, int y) {
return lower_bound(p[x].begin(), p[x].end(), y,
[](int x, int y) { return l[x] < y; }) -
p[x].begin();
}
int wk(int x, int y) {
y += d[x];
int L = Q(y, l[x]), R = Q(y, r[x]);
set<string> q;
int &t = g[make_pair(y, pair<int, int>(L, R))];
if (t) return t;
for (int i = L; i < R; i++) q.insert(s[p[y][i]]);
return t = q.size();
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i] >> x, a[x].push_back(i);
fs(0, 0);
for (cin >> m; m--;) cin >> x >> y, cout << wk(x, y) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int pow(int a, int b) {
int i, k;
k = 1;
for (i = 1; i <= b; i++) k = k * a;
return k;
}
void chuyen1(string s) {
int R, C, i, d1, temp;
char c;
string s3 = "";
R = s.find('R');
C = s.find('C');
temp = 0;
for (i = C + 1; i <= s.length() - 1; i++) temp = temp * 10 + (s[i] - 48);
while (temp > 0) {
if ((temp % 26) != 0) {
d1 = temp % 26 + 64;
c = (char)(d1);
s3 = c + s3;
temp = temp / 26;
} else {
d1 = 26 + 64;
c = (char)(d1);
s3 = c + s3;
temp = temp / 26 - 1;
}
}
cout << s3;
for (i = 1; i < C; i++) cout << s[i];
cout << "\n";
}
void chuyen2(string s) {
int temp, i, k, j, tam;
i = 0;
while (s[i] >= 65 && s[i] <= 90) i++;
k = i - 1;
tam = k;
temp = 0;
for (j = 0; j <= k; j++) {
temp = temp + (s[j] - 64) * pow(26, tam);
tam--;
}
cout << 'R';
for (j = i; j <= s.length() - 1; j++) cout << s[j];
cout << 'C';
cout << temp;
cout << "\n";
}
int main() {
int n, i;
string s;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s;
if ((s[0] == 'R') && (s[1] >= '0') && (s[1] <= '9') &&
(s.find('C', 2) >= 0) && (s.find('C', 2) <= s.length()))
chuyen1(s);
else
chuyen2(s);
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define int ll
#define debug(v) cout << ">>" << #v << ':' << v << endl;
#define endl "\n"
#define pb push_back
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define umap unordered_map
#define pii pair<int , int>
#define all(v) v.begin() , v.end()
#define ld long double
#define min3(a1,b1,cost) min(a1,min(b1,cost))
#define min4(a1,b1,cost,d ) min(a1 , min(b1 , min(cost,d)))
#define max3(a1,b1,cost) max(a1 , max(b1,cost))
#define max4(a1,b1,cost,d) max(max(a1,b1) , max(cost,d))
#define vi vector<int>
#define x first
#define y second
#define dbg(a1,b1) cout<<a1<<" "<<b1<<endl;
#define mk make_pair
#define rep(i,j,n) for(int (i)=(j) ; i<(n) ; i++)
#define pq priority_queue
#define mn(v) *min_element(all(v))
#define maxa(v) *max_element(all(v));
#define vpii vector<pii>
int Set(int qq , int pos){return (qq|(1<<pos));}
int chk(int qq , int pos){return (qq&(1<<pos));}
int read(){
int a= 0; char c = getchar(); while(!isdigit(c)) c = getchar();
while(isdigit(c)){a = a * 10 + c - 48; c = getchar();} return a;
}
int dx[] = {0,0,-1,1};
int dy[] = {1,-1,0,0};
const int MOD = 1e9 + 7;
const int N = 2e5+10;
const int inf = 1e18;
const ld eps = 1e-12;
int n , h;
struct line
{
ll a, b, c;
ll operator()(pii p)
{
return a * p.x + b * p.y + c;
}
};
line get_line(pii a, pii b)
{
line l;
l.a = b.y - a.y;
l.b = a.x - b.x;
l.c = -l.a*a.x - l.b*a.y;
if(l.b < 0)
{
l.a = -l.a;
l.b = -l.b;
l.c = -l.c;
}
return l;
}
pair<ld,ld> intersection(line a, line b)
{
pair<ld,ld> p;
p.y = (1.0 * b.c * a.a - a.c * b.a)/(a.b * b.a - b.b * a.a);
p.x = -(1.0 * b.c * a.b - a.c * b.b)/(a.b * b.a - b.b * a.a);
return p;
}
vector<pair<ld,ld>> v(N);
void solve()
{
n = read();
h = read();
for(int i=0 ; i<n ; i++)v[i].x = read() , v[i].y = read();
pair<ld,ld> s = {v[n-1].x , v[n-1].y+h};
ld cur = 0;
cur = hypot(v[n-1].x - v[n-2].x , v[n-1].y - v[n-2].y);
pair<ld,ld> mx = v[n-2];
for(int i=n-3 ; i>=0 ; i--)
{
line L = get_line(mx , s);
if(L(v[i]) > 0)
{
pair<ld,ld> hk = intersection(L , get_line(v[i] , v[i+1]));
cur += hypot(v[i].x - hk.x , v[i].y - hk.y);
mx = v[i];
}
else if(L(v[i])==0)
{
if(L(v[i+1])==0)
cur += hypot(v[i+1].x - v[i].x , v[i+1].y - v[i].y);
}
}
cout<<cur<<endl;
}
signed main()
{
IOS
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
freopen("output.txt" , "w" , stdout);
#endif
cout<<fixed<<setprecision(12);
int t ; t=1;
while(t--)
{
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int Gcd(int a, int b) {
if (b == 0) return a;
return Gcd(b, a % b);
}
int Lcm(int a, int b) { return a / Gcd(a, b) * b; }
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 1e6 + 10;
const double EPS = 1e-9;
struct node {
long double a, t;
} p[maxn];
int dcmp(double a, double b) {
if (a > b) {
if (a - b < EPS)
return 0;
else
return 1;
} else {
if (b - a < EPS)
return 0;
else
return -1;
}
}
int cmp(node a, node b) { return a.t < b.t; }
int main() {
long long n = read(), T = read();
long double mx = 0, mn = 1e8;
long double sum1 = 0, sum2 = 0;
for (int i = 1; i <= n; i++) {
p[i].a = read();
sum1 += p[i].a;
}
for (int i = 1; i <= n; i++) {
p[i].t = read();
sum2 += p[i].a * p[i].t;
mx = max(p[i].t, mx);
mn = min(p[i].t, mn);
}
sort(p + 1, p + n + 1, cmp);
if (mx < T || mn > T) {
puts("0");
return 0;
}
int l = 1, r = n;
while (l <= r) {
if (dcmp(sum1 * T, sum2) == 0) {
printf("%.10Lf\n", sum1);
return 0;
} else if (dcmp(sum1 * T, sum2) == 1) {
sum1 -= p[l].a;
sum2 -= p[l].a * p[l].t;
if (dcmp(sum1 * T, sum2) == -1 || dcmp(sum1 * T, sum2) == 0) {
long double ans = (T * sum1 - sum2) / (p[l].t - T);
printf("%.10Lf\n", ans + sum1);
return 0;
} else {
l++;
}
} else {
sum1 -= p[r].a;
sum2 -= p[r].a * p[r].t;
if (dcmp(sum1 * T, sum2) == 1 || dcmp(sum1 * T, sum2) == 0) {
long double ans = (T * sum1 - sum2) / (p[r].t - T);
printf("%.10Lf\n", ans + sum1);
return 0;
} else {
r--;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long m, t, mod, n, a[2100000], b[2100000], d[110];
inline void fwt(long long a[], long long f) {
long long i, j, k;
for (i = 1; i < n; i <<= 1)
for (j = 0; j < n; j += (i << 1))
for (k = 0; k < i; k++) {
long long x = a[j + k], y = a[i + j + k];
a[j + k] = (x + y) % mod, a[i + j + k] = (x + mod - y) % mod;
}
if (f == -1)
for (i = 0; i < n; i++) a[i] /= n;
}
inline long long mul(long long x, long long y) {
long long res = (x * y - (long long)((long double)x / mod * y) * mod);
return res < 0 ? res + mod : res;
}
inline long long pw(long long x, long long p) {
long long res = 1;
while (p) {
if (p & 1) res = mul(res, x);
x = mul(x, x);
p >>= 1;
}
return res;
}
signed main() {
long long i, j, k;
scanf("%I64d%I64d%I64d", &m, &t, &mod);
n = (1ll << m);
mod *= n;
for (i = 0; i < n; i++) scanf("%I64d", &a[i]);
for (i = 0; i <= m; i++) scanf("%I64d", &d[i]);
for (i = 0; i < n; i++) {
k = 0;
for (j = 0; j < m; j++)
if ((1 << j) & i) k++;
b[i] = d[k];
}
fwt(a, 1), fwt(b, 1);
for (i = 0; i < n; i++) b[i] = pw(b[i], t);
for (i = 0; i < n; i++) a[i] = mul(a[i], b[i]);
fwt(a, -1);
mod /= n;
for (i = 0; i < n; i++) printf("%I64d\n", a[i] % mod);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const double EPS = 1e-9;
const int MAXN = 2e5 + 5;
int n, q, a[MAXN];
set<int> locs;
map<int, int> deltas;
void add_delta(int delta) { deltas[delta]++; }
void remove_delta(int delta) {
assert(deltas.find(delta) != deltas.end() && deltas[delta] > 0);
deltas[delta]--;
if (deltas[delta] == 0) {
deltas.erase(delta);
}
}
int max_delta() { return deltas.empty() ? 0 : deltas.rbegin()->first; }
int solve() {
if (deltas.empty()) {
return 0;
}
assert(int((locs).size()) >= 2);
return *(--locs.end()) - *locs.begin() - max_delta();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
locs.insert(a[i]);
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
add_delta(a[i] - a[i - 1]);
}
cout << solve() << '\n';
for (int qq = 0; qq < q; qq++) {
int type, x;
cin >> type >> x;
if (type == 0) {
assert(locs.find(x) != locs.end());
if (int((locs).size()) == 1) {
assert(deltas.empty());
} else {
auto l_it = locs.lower_bound(x);
auto r_it = locs.upper_bound(x);
if (l_it == locs.begin()) {
remove_delta(*r_it - x);
} else if (r_it == locs.end()) {
l_it--;
remove_delta(x - *l_it);
} else {
l_it--;
remove_delta(*r_it - x);
remove_delta(x - *l_it);
add_delta(*r_it - *l_it);
}
}
locs.erase(x);
} else {
assert(locs.find(x) == locs.end());
if (locs.empty()) {
assert(deltas.empty());
} else {
auto r_it = locs.upper_bound(x);
if (r_it == locs.end()) {
--r_it;
add_delta(x - *r_it);
} else if (r_it == locs.begin()) {
add_delta(*r_it - x);
} else {
auto l_it = r_it;
l_it--;
add_delta(*r_it - x);
add_delta(x - *l_it);
remove_delta(*r_it - *l_it);
}
}
locs.insert(x);
}
cout << solve() << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, l, x, y, a[100005];
set<long long> st;
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
cout.precision(10);
cout << fixed;
if (argc > 1 && fopen(argv[1], "r")) freopen(argv[1], "rt", stdin);
cin >> n >> l >> x >> y;
for (int i = 0; i < (int)(n); ++i) cin >> a[i], st.insert(a[i]);
bool fx = 0, fy = 0;
for (long long a1 : st) {
if (st.count(a1 - x) || st.count(a1 + x)) {
fx = 1;
break;
}
}
for (long long a1 : st) {
if (st.count(a1 - y) || st.count(a1 + y)) {
fy = 1;
break;
}
}
if (fx && fy)
cout << 0 << endl;
else if (fx)
cout << 1 << endl << y << endl;
else if (fy)
cout << 1 << endl << x << endl;
else {
for (long long a1 : st) {
long long a2 = a1 + x + y;
if (st.count(a2)) {
cout << 1 << endl << a1 + x << endl;
return 0;
}
a2 = a1 - x + y;
if (st.count(a2)) {
if (a1 + y <= l) {
cout << 1 << endl << a1 + y << endl;
return 0;
} else if (a1 - x >= 0) {
cout << 1 << endl << a1 - x << endl;
return 0;
}
}
a2 = a1 + x - y;
if (st.count(a2)) {
if (a1 + x <= l) {
cout << 1 << endl << a1 + x << endl;
return 0;
} else if (a1 - y >= 0) {
cout << 1 << endl << a1 - y << endl;
return 0;
}
}
a2 = y - x;
if (st.count(a2)) {
cout << 1 << endl << y << endl;
return 0;
}
}
cout << 2 << endl << x << " " << y << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
long long i, j, n, t, x, y, ans = 0, cnt = 0, l = 0, m, p, temp, max = 0, k;
string s;
boost();
cin >> n;
cin >> s;
temp = -1;
for (i = 0; i < n; i++) {
if (s[i] == '(')
cnt++;
else
cnt--;
if (cnt == 0) {
if (s[i] == ')')
temp = i;
else {
ans += i - temp;
temp = i;
}
}
}
if (cnt != 0)
cout << "-1";
else
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n, k;
cin >> n >> k;
int x = k / (n - 1);
int r = k - x * (n - 1);
cout << x * n + (r > 0 ? r : -1) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int x, y, z, i, j;
int count = 0, count1 = 0;
char str[10001];
scanf("%s", str);
x = strlen(str);
for (i = 0; str[i] != '\0'; i++) {
if (str[i] >= 'A' && str[i] <= 'Z') {
count++;
} else {
count1++;
}
}
if (count > count1) {
for (i = 0; str[i] != '\0'; i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
str[i] = str[i] - 32;
}
}
} else if (count <= count1) {
for (i = 0; str[i] != '\0'; i++) {
if (str[i] >= 'A' && str[i] <= 'Z') {
str[i] = str[i] + 32;
}
}
}
puts(str);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double PI = 3.1415926535897932384626433;
using namespace std;
struct edge {
long long to, cost;
edge() {}
edge(long long a, long long b) { to = a, cost = b; }
};
const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
const int mod = 998244353;
struct mint {
int x;
mint(long long y = 0) {
if (y < 0 || y >= mod) y = (y % mod + mod) % mod;
x = y;
}
mint(const mint &ope) { x = ope.x; }
mint operator-() { return mint(-x); }
mint operator+(const mint &ope) { return mint(x) += ope; }
mint operator-(const mint &ope) { return mint(x) -= ope; }
mint operator*(const mint &ope) { return mint(x) *= ope; }
mint operator/(const mint &ope) { return mint(x) /= ope; }
mint &operator+=(const mint &ope) {
x += ope.x;
if (x >= mod) x -= mod;
return *this;
}
mint &operator-=(const mint &ope) {
x += mod - ope.x;
if (x >= mod) x -= mod;
return *this;
}
mint &operator*=(const mint &ope) {
long long tmp = x;
tmp *= ope.x, tmp %= mod;
x = tmp;
return *this;
}
mint &operator/=(const mint &ope) {
long long n = mod - 2;
mint mul = ope;
while (n) {
if (n & 1) *this *= mul;
mul *= mul;
n >>= 1;
}
return *this;
}
mint inverse() { return mint(1) / *this; }
bool operator==(const mint &ope) { return x == ope.x; }
bool operator!=(const mint &ope) { return x != ope.x; }
bool operator<(const mint &ope) const { return x < ope.x; }
};
mint modpow(mint a, long long n) {
if (n == 0) return mint(1);
if (n % 2)
return a * modpow(a, n - 1);
else
return modpow(a * a, n / 2);
}
istream &operator>>(istream &is, mint &ope) {
long long t;
is >> t, ope.x = t;
return is;
}
ostream &operator<<(ostream &os, mint &ope) { return os << ope.x; }
ostream &operator<<(ostream &os, const mint &ope) { return os << ope.x; }
long long modpow(long long a, long long n, long long mod) {
if (n == 0) return 1;
if (n % 2)
return ((a % mod) * (modpow(a, n - 1, mod) % mod)) % mod;
else
return modpow((a * a) % mod, n / 2, mod) % mod;
}
vector<mint> fact, fact_inv;
void make_fact(int n) {
fact.resize(n + 1), fact_inv.resize(n + 1);
fact[0] = mint(1);
for (long long i = (1); (i) <= (n); (i)++) fact[i] = fact[i - 1] * mint(i);
fact_inv[n] = fact[n].inverse();
for (long long i = (n - 1); (i) >= (0); (i)--)
fact_inv[i] = fact_inv[i + 1] * mint(i + 1);
}
mint comb(int n, int k) {
if (n < 0 || k < 0 || n < k) return mint(0);
return fact[n] * fact_inv[k] * fact_inv[n - k];
}
mint perm(int n, int k) { return comb(n, k) * fact[k]; }
vector<int> prime, pvec;
void make_prime(int n) {
prime.resize(n + 1);
for (long long i = (2); (i) <= (n); (i)++) {
if (prime[i] == 0) pvec.push_back(i), prime[i] = i;
for (auto p : pvec) {
if (i * p > n || p > prime[i]) break;
prime[i * p] = p;
}
}
}
vector<int> qrime;
void make_qrime(int n) {
qrime.resize(n + 1);
for (long long i = (2); (i) <= (n); (i)++) {
int ni = i / prime[i];
if (prime[i] == prime[ni])
qrime[i] = qrime[ni] * prime[i];
else
qrime[i] = prime[i];
}
}
bool exceed(long long x, long long y, long long m) { return x >= m / y + 1; }
void mark() { cout << "*" << endl; }
void yes() { cout << "YES" << endl; }
void no() { cout << "NO" << endl; }
long long floor(long long a, long long b) {
if (b < 0) a *= -1, b *= -1;
if (a >= 0)
return a / b;
else
return -((-a + b - 1) / b);
}
long long ceil(long long a, long long b) {
if (b < 0) a *= -1, b *= -1;
if (a >= 0)
return (a + b - 1) / b;
else
return -((-a) / b);
}
long long modulo(long long a, long long b) {
b = abs(b);
return a - floor(a, b) * b;
}
long long sgn(long long x) {
if (x > 0) return 1;
if (x < 0) return -1;
return 0;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long arith(long long x) { return x * (x + 1) / 2; }
long long arith(long long l, long long r) { return arith(r) - arith(l - 1); }
long long digitnum(long long x, long long b = 10) {
long long ret = 0;
for (; x; x /= b) ret++;
return ret;
}
long long digitsum(long long x, long long b = 10) {
long long ret = 0;
for (; x; x /= b) ret += x % b;
return ret;
}
string lltos(long long x) {
string ret;
for (; x; x /= 10) ret += x % 10 + '0';
reverse((ret).begin(), (ret).end());
return ret;
}
long long stoll(string &s) {
long long ret = 0;
for (auto c : s) ret *= 10, ret += c - '0';
return ret;
}
template <typename T>
void uniq(T &vec) {
sort((vec).begin(), (vec).end());
vec.erase(unique((vec).begin(), (vec).end()), vec.end());
}
template <class S, class T>
pair<S, T> &operator+=(pair<S, T> &s, const pair<S, T> &t) {
s.first += t.first, s.second += t.second;
return s;
}
template <class S, class T>
pair<S, T> &operator-=(pair<S, T> &s, const pair<S, T> &t) {
s.first -= t.first, s.second -= t.second;
return s;
}
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
template <class T>
T dot(const pair<T, T> &s, const pair<T, T> &t) {
return s.first * t.first + s.second * t.second;
}
template <class T>
T cross(const pair<T, T> &s, const pair<T, T> &t) {
return s.first * t.second - s.second * t.first;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &vec) {
for (long long i = 0; (i) < (long long)(vec).size(); (i)++)
os << vec[i] << " ";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
for (long long i = 0; (i) < (long long)(vec).size(); (i)++)
os << vec[i] << " ";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, deque<T> &deq) {
for (long long i = 0; (i) < (long long)(deq).size(); (i)++)
os << deq[i] << " ";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &ope) {
os << "(" << ope.first << ", " << ope.second << ")";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &ope) {
os << "(" << ope.first << ", " << ope.second << ")";
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &ope) {
for (auto p : ope) os << "(" << p.first << ", " << p.second << "),";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, set<T> &ope) {
for (auto x : ope) os << x << " ";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, multiset<T> &ope) {
for (auto x : ope) os << x << " ";
return os;
}
template <typename T>
void outa(T a[], long long s, long long t) {
for (long long i = (s); (i) <= (t); (i)++) {
cout << a[i];
if (i < t) cout << " ";
}
cout << endl;
}
void dump_func() { cout << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
cout << head;
if (sizeof...(Tail) > 0) cout << " ";
dump_func(std::move(tail)...);
}
struct NTT_Convolution {
NTT_Convolution(){};
static int rev(int x, int n) {
int ret = 0;
for (int i = 0; i < n; i++) ret <<= 1, ret |= (x >> i) & 1;
return ret;
}
static void DFT(vector<mint> &f, vector<mint> &F, int n, mint root,
bool inv = false) {
int N = 1 << n;
F.resize(N);
for (int i = 0; i < N; i++) F[rev(i, n)] = f[i];
if (inv) root = root.inverse();
mint a, b, x, z;
for (int i = 0; i < n; i++) {
int l = 1 << i;
z = modpow(root, 1 << (n - (i + 1)));
for (int j = 0; j < N; j += l * 2) {
x = 1;
for (int k = j; k < j + l; k++) {
a = F[k], b = F[k + l] * x;
F[k] = a + b, F[k + l] = a - b, x *= z;
}
}
}
if (inv) {
mint Ninv = mint(N).inverse();
for (int i = 0; i < N; i++) F[i] *= Ninv;
}
}
static void conv(vector<mint> f, vector<mint> g, vector<mint> &dest) {
long long logf = 0, logg = 0, len = f.size() + g.size();
for (int i = f.size(); i; i /= 2) logf++;
for (int i = g.size(); i; i /= 2) logg++;
long long n = max(logf, logg) + 1, N = 1 << n;
f.resize(N), g.resize(N);
mint root = modpow(mint(3), 119 * (1 << 23 - n));
vector<mint> F, G;
DFT(f, F, n, root), DFT(g, G, n, root);
for (int i = 0; i < N; i++) F[i] *= G[i];
DFT(F, f, n, root, true);
f.resize(len - 1);
dest = f;
}
};
struct ConvolutionMerge {
int id;
vector<vector<mint> > vec;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
Q;
ConvolutionMerge() { init(); }
void init() {
id = 0;
vec.clear();
while (Q.size()) Q.pop();
vector<mint> f;
f.push_back(mint(1));
add(f);
}
void add(vector<mint> &f) {
Q.push(pair<long long, long long>(f.size(), id++));
vec.push_back(f);
}
void calc(vector<mint> &dest) {
while (Q.size() >= 2) {
long long u = Q.top().second;
Q.pop();
long long v = Q.top().second;
Q.pop();
NTT_Convolution::conv(vec[u], vec[v], vec[u]);
Q.push(pair<long long, long long>(vec[u].size(), u));
}
dest = vec[Q.top().second];
}
};
long long n;
vector<long long> G[250005];
ConvolutionMerge cm;
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
make_fact(300000);
cin >> n;
long long u, v;
for (long long i = (1); (i) <= (n - 1); (i)++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
for (long long i = (1); (i) <= (n); (i)++) {
long long deg = ((long long)(G[i]).size());
if (i != 1) deg--;
if (deg > 0) {
vector<mint> f;
f.push_back(mint(1));
f.push_back(mint(deg));
cm.add(f);
}
}
vector<mint> res;
cm.calc(res);
mint ans = 0;
for (long long i = 0; (i) < (long long)(res).size(); (i)++) {
mint tmp = fact[n - i] * res[i];
if (i % 2)
ans -= tmp;
else
ans += tmp;
}
dump_func(ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vector<long long> mult(32, 1);
for (int i = 0; i < 32; i++) mult[i] = (1 << i) + 1;
int t;
cin >> t;
while (t--) {
long long d, m, final = 1;
cin >> d >> m;
d++;
int x = logb(d);
for (int i = 0; i < x; i++) {
final *= (mult[i]) % m;
final %= m;
}
final *= (d - (1 << x) + 1) % m;
cout << (final % m - 1 + m) % m << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int SG(double x) { return x > -1E-8 ? x < 1E-8 ? 0 : 1 : -1; }
int c[1000000];
int main() {
int n, m, r, i, j, k, d;
long long md;
scanf("%d %d %d", &n, &m, &r);
for (i = 0; i < (n); i++) {
scanf("%d", &c[i]);
}
if (n % 2 == 0) {
puts("0");
return 0;
}
d = (n + 1) / 2;
md = (long long)(m / d) * (long long)r;
for (i = 0; i < n; i += 2) {
if (c[i] < md) md = c[i];
}
printf("%I64d\n", md);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000007;
long long n;
int m, l, z;
long long d[100];
int a[100][100];
int b[100][100];
void mul(int a[100][100], int b[100][100]) {
int w[100][100] = {};
for (int i = 0; i < m; i++) {
for (int k = 0; k < m; k++) {
if (a[i][k] == 0) {
continue;
}
for (int j = 0; j < m; j++) {
w[i][j] = (w[i][j] + (long long)a[i][k] * b[k][j]) % p;
}
}
}
memcpy(a, w, sizeof w);
}
int main() {
cin >> m >> n;
for (int i = 0; i < m; i++) {
cin >> d[i];
}
for (int i = 0; i < m; i++) {
a[0][i] = 1;
for (int j = 0; j < m; j++) {
b[i][j] = __builtin_popcountll(d[i] ^ d[j]) % 3 == 0;
}
}
for (n--; n > 0; n >>= 1) {
if (n & 1) {
mul(a, b);
}
mul(b, b);
}
for (int i = 0; i < m; i++) {
z = (z + a[0][i]) % p;
}
cout << z << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 123;
const int p = 37;
long long n, m, a[N], summ, need, minn, pl;
int main() {
cin >> n >> m;
for (long long i = 1; i <= m; ++i) {
long long x, d, now;
cin >> x >> d;
if (d < 0)
minn += d;
else
pl += d;
need += x;
}
for (long long i = 1; i <= n; ++i)
a[i] = need + pl * abs(1 - i) + minn * abs((n >> 1) + 1 - i);
for (long long i = 1; i <= n; ++i) summ += a[i];
cout.precision(12);
cout << (summ + 0.000000000000) / (n + 0.000000000000);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n == 2) {
printf("-1\n");
return 0;
}
printf("6\n10\n15\n");
for (int i = 4; i <= n; i++) {
printf("6");
for (int zero = 1; zero <= i - 4 + 1; zero++) printf("0");
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
string s;
const int inf = 2e9, mn = 2e5 + 10;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n;
vector<pair<int, int>> St(mn);
for (int i = 0; i < mn; i++) {
St[i].first = -1;
St[i].second = i;
}
for (int i = 0; i < n; i++) {
cin >> a;
St[a].first = n - i;
}
sort(St.begin(), St.end());
cout << St[mn - 1].second;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int MAXM = 200010;
const int INF = 0x3fffffff;
int n, tot, sz;
int a[MAXN], to[MAXM], _next[MAXM], head[MAXN], root[MAXN], depth[MAXN];
struct node {
int mn, lc, rc;
node() { mn = INF, lc = 0, rc = 0; }
} f[MAXN * 50];
void Add_Edge(int u, int v) {
to[++tot] = v, _next[tot] = head[u], head[u] = tot;
}
void Modify(int &rt, int l, int r, int x, int y) {
rt = ++sz;
if (l == r) {
f[rt].mn = y;
return;
}
int mid = (l + r) / 2;
if (x <= mid)
Modify(f[rt].lc, l, mid, x, y);
else
Modify(f[rt].rc, mid + 1, r, x, y);
f[rt].mn = y;
}
int Query(int rt, int l, int r, int s, int t) {
if (s <= l && t >= r) return f[rt].mn;
int mid = (l + r) / 2, ans = INF;
if (s <= mid) ans = Query(f[rt].lc, l, mid, s, t);
if (t > mid) ans = min(ans, Query(f[rt].rc, mid + 1, r, s, t));
return ans;
}
int Merge(int u, int v) {
if (!u) return v;
if (!v) return u;
int now = ++sz;
f[now].lc = Merge(f[u].lc, f[v].lc);
f[now].rc = Merge(f[u].rc, f[v].rc);
f[now].mn = min(f[u].mn, f[v].mn);
return now;
}
void dfs(int u, int d) {
depth[u] = d;
Modify(root[u], 1, n, depth[u], a[u]);
for (int i = head[u]; i; i = _next[i]) {
int v = to[i];
if (depth[v]) continue;
dfs(v, d + 1);
root[u] = Merge(root[u], root[v]);
}
}
void Print(int u, int l, int r) {
if (u == 0) return;
printf("%d %d %d\n", l, r, f[u].mn);
int mid = (l + r) / 2;
Print(f[u].lc, l, mid);
Print(f[u].rc, mid + 1, r);
}
int main() {
int r;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
Add_Edge(u, v), Add_Edge(v, u);
}
dfs(r, 1);
int q;
scanf("%d", &q);
int last = 0, x, k;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &k);
x = (x + last) % n + 1, k = (k + last) % n;
printf("%d\n", last = Query(root[x], 1, n, depth[x], depth[x] + k));
}
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 1e9 + 7;
const int N = 2e5 + 7;
const int M = 1e6 + 7;
vector<long long> vec, fb, fc;
long long a[N];
long long vis[M];
long long dp[N];
int getVal(long long first) {
return lower_bound(vec.begin(), vec.end(), first) - vec.begin();
}
signed main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
vec.push_back(a[i] - 1);
vec.push_back(a[i]);
vec.push_back(a[i] + 1);
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
long long sum = 0;
unsigned long long ans_1 = 0, ans_2 = 0;
for (int i = 1; i <= n; i++) {
sum += a[i];
int x1 = getVal(a[i] - 1), x2 = getVal(a[i]), x3 = getVal(a[i] + 1);
vis[x2]++;
dp[i] = a[i] * (long long)i + vis[x3] - vis[x1] - sum;
if (dp[i] < 0)
ans_1 += (unsigned long long)(-dp[i]);
else
ans_2 += (unsigned long long)dp[i];
}
if (ans_1 > ans_2) {
cout << "-" << ans_1 - ans_2 << "\n";
} else
cout << ans_2 - ans_1 << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
map<string, int> mid, pid;
std::vector<string> hostname;
vector<int> a[100000];
char s[1000];
int m_total = 0, p_total = 0;
int b[100000];
std::vector<std::vector<int> > ans;
bool cmp(int i, int j) { return a[i] < a[j]; }
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s", s);
int j = 7;
for (; s[j]; ++j)
if (s[j] == '/') break;
string host = "", path = "";
for (int k = 0; k < j; ++k) host += s[k];
for (int k = j; s[k]; ++k) path += s[k];
if (mid.count(host) == 0) {
mid[host] = m_total++;
hostname.push_back(host);
}
if (pid.count(path) == 0) {
pid[path] = p_total++;
}
a[mid[host]].push_back(pid[path]);
}
for (int i = 0; i < m_total; ++i) {
sort(a[i].begin(), a[i].end());
a[i].erase(unique(a[i].begin(), a[i].end()), a[i].end());
b[i] = i;
}
sort(b, b + m_total, cmp);
int l = 0;
for (int i = 1; i < m_total; ++i) {
if (a[b[i]] != a[b[l]]) {
if (i - l > 1) {
std::vector<int> v;
v.clear();
for (int j = l; j < i; ++j) v.push_back(b[j]);
ans.push_back(v);
}
l = i;
}
}
if (m_total - l > 1) {
std::vector<int> v;
v.clear();
for (int j = l; j < m_total; ++j) v.push_back(b[j]);
ans.push_back(v);
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i) {
for (int j = 0; j < ans[i].size(); ++j) {
printf("%s%c", hostname[ans[i][j]].c_str(),
j < ans[i].size() - 1 ? ' ' : '\n');
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, M, C;
vector<pair<int, pair<int, int> > > V;
int A[505][505], R[505][505];
int main() {
int x, y, t;
scanf("%d %d", &N, &M);
memset(A, 40, sizeof A);
for (int i = 1; i <= M; i++) {
scanf("%d %d %d", &x, &y, &t);
A[x][y] = A[y][x] = t;
V.push_back(make_pair(t, make_pair(x, y)));
}
for (int i = 1; i <= N; i++) A[i][i] = 0;
for (int k = 1; k <= N; k++)
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) A[i][j] = min(A[i][j], A[i][k] + A[k][j]);
for (int i = 1; i <= N; i++)
for (typeof(V.begin()) it = V.begin(); it != V.end(); it++) {
if (A[i][it->second.first] + it->first == A[i][it->second.second])
++R[i][it->second.second];
if (A[i][it->second.second] + it->first == A[i][it->second.first])
++R[i][it->second.first];
}
for (int i = 1; i <= N; i++)
for (int j = i + 1; j <= N; j++) {
int ans = 0;
for (int k = 1; k <= N; k++)
if (A[i][k] + A[k][j] == A[i][j]) ans += R[i][k];
printf("%d ", ans);
}
cerr << "\nTime: " << (double)clock() / CLOCKS_PER_SEC << " seconds." << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a[100], count = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i] >= a[k - 1] && a[i] != 0) count++;
}
cout << count << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool isvalid(int x, int y) { return x < n && x >= 0 && y < m && y >= 0; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
vector<int> fr(n, 5000), lr(n, -1), fc(m, 5000), lc(m, -1);
vector<string> s(n);
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == '#') {
fr[i] = min(fr[i], j);
fc[j] = min(fc[j], i);
lr[i] = max(lr[i], j);
lc[j] = max(lc[j], i);
}
int f = 1;
int C, R;
C = R = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (s[i][j] == '#') C = R = 1;
}
for (int i = 0; i < n; i++) {
if (lr[i] == -1) continue;
for (int j = fr[i]; j < lr[i]; j++)
if (s[i][j] == '.') {
f = 0;
break;
}
}
if (f)
for (int j = 0; j < m; j++) {
if (lc[j] == -1) continue;
for (int i = fc[j]; i < lc[j]; i++)
if (s[i][j] == '.') {
f = 0;
break;
}
}
if (f && C) {
for (int i = 0; i < n; i++) R &= (lr[i] != -1);
for (int i = 0; i < m; i++) C &= (lc[i] != -1);
}
if (R == 0 && C == 1) f = 0;
if (R == 1 && C == 0) f = 0;
if (!f) {
cout << -1 << '\n';
return 0;
}
int a[n][m];
memset(a, -1, sizeof a);
int ans = 0;
queue<pair<int, int> > Q;
int x, y;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (s[i][j] == '#' && a[i][j] == -1) {
ans++;
Q.push(make_pair(i, j));
while (!Q.empty()) {
auto X = Q.front();
Q.pop();
tie(x, y) = X;
if (a[x][y] != -1) continue;
a[x][y] = ans;
if (isvalid(x + 1, y))
if (a[x + 1][y] == -1 && s[x + 1][y] == '#')
Q.push(make_pair(x + 1, y));
if (isvalid(x - 1, y))
if (a[x - 1][y] == -1 && s[x - 1][y] == '#')
Q.push(make_pair(x - 1, y));
if (isvalid(x, y + 1))
if (a[x][y + 1] == -1 && s[x][y + 1] == '#')
Q.push(make_pair(x, y + 1));
if (isvalid(x, y - 1))
if (a[x][y - 1] == -1 && s[x][y - 1] == '#')
Q.push(make_pair(x, y - 1));
}
}
}
int k = 0;
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 500031;
int pr[N];
map<vector<pair<int, int> >, int> CNT;
int n, k;
vector<pair<int, int> > order, need;
long long ans;
int main() {
ios_base::sync_with_stdio(0);
pr[1] = 1;
for (int i = 2; i <= 100000; i++) {
if (pr[i] == 0)
for (int j = i; j <= 100000; j += i) {
pr[j] = i;
}
}
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int val;
cin >> val;
order.clear();
while (val > 1) {
int x = pr[val];
int cnt = 0;
while (val % x == 0) {
cnt++;
val /= x;
}
if (cnt % k) order.push_back(make_pair(x, cnt % k));
}
sort(order.begin(), order.end());
need = order;
for (int j = 0; j < need.size(); j++) {
need[j].second = (k - need[j].second) % k;
}
ans += CNT[need];
CNT[order]++;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int solve(int x, int y) {
int current[3] = {x, x, x};
int min_count = 1;
int count = 1;
current[0] = y;
while (1) {
if (current[1] != y) {
current[1] = current[2] - current[0] + 1;
++count;
if (current[1] < y) current[1] = y;
}
if (current[2] != y) {
current[2] = current[1] - current[0] + 1;
++count;
if (current[2] < y) current[2] = y;
}
if (current[1] == y && current[2] == y) break;
sort(current, current + 3);
}
min_count = count;
count = 1;
current[2] = y + y - 1;
current[0] = current[1] = y;
while (1) {
if (current[0] != x) {
current[0] = current[1] + current[2] - 1;
++count;
if (current[0] > x) current[0] = x;
}
if (current[1] != x) {
current[1] = current[0] + current[2] - 1;
++count;
if (current[1] > x) current[1] = x;
}
if (current[0] == x && current[1] == x) break;
sort(current, current + 3);
}
if (current[2] < x) count++;
min_count = min(count, min_count);
return min_count;
}
int main() {
int x, y;
cin >> x >> y;
cout << solve(x, y);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int n, m, ans = 0;
cin >> n >> m;
if (m > n) {
m ^= n;
n ^= m;
m ^= n;
}
for (int i = 1; i < m + 1; i++) {
ans += ((i % 5) + n) / 5;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a, b;
int ans = INT_MAX;
int derecha[301][301];
int izquierda[301][301];
int up[301][301];
int down[301][301];
int ground[301][301];
int distFila(int, int, int);
int distColumna(int, int, int);
int tp, tu, td;
int to(int h1, int h2) {
if (h1 == h2) return tp;
if (h1 < h2) return tu;
return td;
}
int main() {
int N, M;
int T;
scanf("%d %d %d\n", &N, &M, &T);
scanf("%d %d %d\n", &tp, &tu, &td);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
scanf("%d", ground[i] + j);
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (j == 0) {
derecha[i][j] = 0;
} else {
derecha[i][j] = derecha[i][j - 1] + to(ground[i][j - 1], ground[i][j]);
}
}
for (int j = M - 1; j >= 0; j--) {
if (j == M - 1) {
izquierda[i][j] = 0;
} else {
izquierda[i][j] =
izquierda[i][j + 1] + to(ground[i][j + 1], ground[i][j]);
}
}
}
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
if (j == 0) {
down[i][j] = 0;
} else {
down[i][j] = down[i][j - 1] + to(ground[j - 1][i], ground[j][i]);
}
}
for (int j = N - 1; j >= 0; j--) {
if (j == N - 1) {
up[i][j] = 0;
} else {
up[i][j] = up[i][j + 1] + to(ground[j + 1][i], ground[j][i]);
}
}
}
for (int i = 0; i < N; i++) {
for (int j = i + 2; j < N; j++) {
set<pair<int, int> > derecha;
for (int L = M - 3; L >= 0; L--) {
derecha.insert(
make_pair((distFila(i, 0, L + 2) + distColumna(L + 2, i, j) +
distFila(j, L + 2, 0)),
(L + 2)));
int tmp = -distColumna(L, j, i) + distFila(i, 0, L) + distFila(j, L, 0);
int buscar = T + tmp;
set<pair<int, int> >::iterator it =
derecha.lower_bound(make_pair((buscar), (0)));
if (it != derecha.begin()) {
it--;
}
for (int k = 0; k < 2 and it != derecha.end(); it++, k++) {
int finalValue = abs(((*it).first) - tmp - T);
if (finalValue < ans) {
ans = finalValue;
a = make_pair((i), (L));
b = make_pair((j), ((*it).second));
}
}
}
}
}
printf("%d %d %d %d\n", a.first + 1, a.second + 1, b.first + 1, b.second + 1);
return 0;
}
int distFila(int fila, int c1, int c2) {
if (c1 < c2) {
return derecha[fila][c2] - derecha[fila][c1];
} else {
return izquierda[fila][c2] - izquierda[fila][c1];
}
}
int distColumna(int columna, int f1, int f2) {
if (f1 < f2) {
return down[columna][f2] - down[columna][f1];
} else {
return up[columna][f2] - up[columna][f1];
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10;
const long long B = 98765431;
int a[N], b[N][N];
long long val[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++) b[i + 1][j] = (a[j] >= i);
for (int j = 1; j < i; j++) val[i + 1] = val[i + 1] * B + b[i + 1][j];
int p = 0;
for (int j = 1; j <= i; j++)
if (val[j] == val[i + 1]) p = j;
int x = min(a[i], i);
if (p) b[p][i] = 1, x--;
for (int j = 1; j <= i + 1; j++)
if (j != p) {
if (x)
b[j][i] = 1, x--;
else
b[j][i] = 0;
}
for (int j = 1; j <= i + 1; j++) val[j] = val[j] * B + b[j][i];
}
printf("%d\n", n + 1);
for (int i = 1; i <= n + 1; i++) {
for (int j = 1; j <= n; j++) printf("%d", b[i][j]);
printf("\n");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 100 + 10;
pair<pair<long long, long long>, long long> a[maxn];
long long n, d, s;
long long sum;
vector<pair<pair<long long, long long>, long long> > z, nz;
inline bool cmp(pair<pair<long long, long long>, long long> fi,
pair<pair<long long, long long>, long long> se) {
return fi.first.second < se.first.second;
}
long long tk = 0;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> d >> s;
for (int i = 1; i <= n; ++i) {
cin >> a[i].first.first >> a[i].first.second >> a[i].second;
sum += a[i].first.first;
if (a[i].first.first > 0) tk++;
if (a[i].second >= d) {
if (a[i].first.first == 0)
z.push_back(a[i]);
else
nz.push_back(a[i]);
}
}
sort(nz.begin(), nz.end(), cmp);
sort(z.begin(), z.end(), cmp);
if (nz.size() > 0) {
if (nz[0].first.second > s) {
long long Max = -1;
long long now = 0;
for (int i = 0; i < z.size(); ++i) {
if (now + z[i].first.second > s) {
Max = i;
break;
} else
now += z[i].first.second;
}
if (Max == -1) Max = z.size();
cout << Max << " ";
now = 0;
for (int i = 0; i < Max; ++i) now += z[i].first.second;
cout << now << endl;
} else {
long long cp = s;
long long t = sum - tk + 1;
if (t + tk >= n) {
cout << n << " " << nz[0].first.second << endl;
return 0;
}
s -= nz[0].first.second;
int i1, i2;
i1 = 1;
i2 = 0;
long long now = 0;
while (t + tk < n) {
long long Min = 100000000000000000ll;
if (i1 < nz.size()) Min = nz[i1].first.second;
if (i2 < z.size()) Min = min(Min, z[i2].first.second);
if (i1 < nz.size() && nz[i1].first.second == Min)
i1++;
else if (i2 < z.size() && z[i2].first.second == Min)
i2++;
if (Min > s)
break;
else {
s -= Min;
t++;
}
}
long long p1 = t + tk;
long long p2 = cp - s;
s = cp;
long long Max = -1;
now = 0;
for (int i = 0; i < z.size(); ++i) {
if (now + z[i].first.second > s) {
Max = i;
break;
} else
now += z[i].first.second;
}
if (Max == -1) Max = z.size();
now = 0;
for (int i = 0; i < Max; ++i) now += z[i].first.second;
if (p1 > Max)
cout << p1 << " " << p2 << endl;
else if (p1 == Max && p2 < now)
cout << p1 << " " << p2 << endl;
else
cout << Max << " " << now << endl;
}
} else {
long long Max = -1;
long long now = 0;
for (int i = 0; i < z.size(); ++i) {
if (now + z[i].first.second > s) {
Max = i;
break;
} else
now += z[i].first.second;
}
if (Max == -1) Max = z.size();
cout << Max << " ";
now = 0;
for (int i = 0; i < Max; ++i) now += z[i].first.second;
cout << now << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long exp(long long x, long long y, long long p) {
long long res = 1;
while (y) {
if (y % 2) res = (res * x % p) % p;
x = (x * x) % p;
y /= 2;
}
return res;
}
long long exp(long long x, long long y) {
long long res = 1;
while (y) {
if (y % 2) res = (res * x);
x = (x * x);
y /= 2;
}
return res;
}
long long a[100];
int main() {
long long n, m;
cin >> n >> m;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
if (n > m)
cout << 0 << endl;
else {
long long sum = 1;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
sum = sum * abs(a[i] - a[j]);
sum = sum % m;
}
}
cout << sum % m;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) {
long long a, b, c, d, e, f, i, j, k, m, n, o, x, y;
string s;
cin >> s;
long long cnt = 0;
n = s.size();
long long ans = 0;
for (i = n - 1; i >= 0; i--) {
if (s[i] == 'A')
cnt--;
else
cnt++;
if (cnt < 0) {
ans++;
cnt = 0;
}
}
cout << ans + cnt % 2 << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, m, r, k, t, s;
int a[61][61], b[61][61];
int dp[61][61][63];
int rec(int i, int j, int k) {
if (i == j) {
return 0;
}
if (k == 0) return 1e9;
if (dp[i][j][k] != -1) return dp[i][j][k];
int ans = b[i][j];
int p;
for (p = 1; p <= n; p++) {
ans = min(ans, b[i][p] + rec(p, j, k - 1));
}
dp[i][j][k] = ans;
return ans;
}
int main() {
cout.setf(ios ::fixed | ios ::showpoint);
cout.precision(9);
cin >> n >> m >> r;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) b[i][j] = 1e9;
for (t = 1; t <= m; t++) {
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) scanf("%d", &a[i][j]);
for (k = 1; k <= n; k++)
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) a[i][j] = min(a[i][j], a[i][k] + a[k][j]);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) b[i][j] = min(b[i][j], a[i][j]);
}
memset(dp, -1, sizeof(dp));
for (i = 1; i <= r; i++) {
scanf("%d%d%d", &s, &t, &k);
k = min(k, n);
printf("%d\n", rec(s, t, k + 1));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = INT_MAX;
const int ninf = INT_MIN;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(3);
int n;
cin >> n;
cout << n / 5 + ((n % 5) ? 1 : 0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 2e9;
const int nax = 505;
int n, m;
int memo[505][505][255];
char a[nax][nax];
int baris[2][4] = {{1, 0, 1, 0}, {-1, 0, 0, -1}};
int kolom[2][4] = {{0, 1, 0, 1}, {0, -1, -1, 0}};
int cek(int x, int y) { return x >= 1 && x <= n && y >= 1 && y <= m; }
int dp(int x, int y, int x2, int y2, int mov) {
if (!cek(x, y) || !cek(x2, y2)) {
return 0;
}
if (x > x2 || y > y2) {
return 0;
}
if (a[x][y] != a[x2][y2]) {
return 0;
}
if (abs(x2 - x) + abs(y2 - y) <= 1) {
return 1;
}
if (memo[x][x2][mov] != -1) {
return memo[x][x2][mov];
}
int ret = 0;
for (int i = 0; i < 4; i++) {
int nx = x + baris[0][i], nx2 = x2 + baris[1][i];
int ny = y + kolom[0][i], ny2 = y2 + kolom[1][i];
ret += dp(nx, ny, nx2, ny2, mov + 1);
ret %= mod;
}
return memo[x][x2][mov] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
memset(memo, -1, sizeof(memo));
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
cout << dp(1, 1, n, m, 0) << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 100;
int n, k, ans1, ans2;
int a[maxn], d[maxn];
long long sum[maxn], summax;
int main() {
while (~scanf("%d%d", &n, &k)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(sum, 0, sizeof(sum));
for (int i = n; i > n - k; i--) sum[n - k + 1] += a[i];
d[n - k + 1] = n - k + 1;
for (int i = n - k; i > 0; i--) {
sum[i] = sum[i + 1] + a[i] - a[i + k];
if (sum[i] >= sum[d[i + 1]])
d[i] = i;
else
d[i] = d[i + 1];
}
summax = 0;
ans1 = 0;
ans2 = 0;
for (int i = 1; i <= n - 2 * k + 1; i++)
if (sum[i] + sum[d[i + k]] > summax) {
summax = sum[i] + sum[d[i + k]];
ans1 = i;
ans2 = d[i + k];
}
printf("%d %d\n", ans1, ans2);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
long long int a;
long long int b;
} Struct;
bool Compare2(Struct s1, Struct s2) { return s1.b < s2.b; }
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
long long int n, r, avg, i, j, k, num = 0, ans = 0;
cin >> n >> r >> avg;
Struct A[n];
for (i = 0; i < n; i++) {
cin >> A[i].a >> A[i].b;
num += (avg - A[i].a);
}
sort(A, A + n, Compare2);
if (num <= 0)
cout << 0 << endl;
else {
i = 0;
while (num > 0 && i < n) {
if ((r - A[i].a) >= num) {
ans += A[i].b * num;
num = 0;
} else {
ans += A[i].b * (r - A[i].a);
num -= r - A[i].a;
i++;
}
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 998244353;
const int MAXN = 200055;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
priority_queue<int> que;
int h[MAXN], hid[MAXN], p[20];
struct Segment_Tree {
int mx[MAXN << 2];
void up(int x) { mx[x] = max(mx[x << 1], mx[x << 1 | 1]); }
void change(int x, int l, int r, int y, int z) {
if (l == r) {
mx[x] = z;
return;
}
int mid = (l + r) >> 1;
if (y <= mid)
change(x << 1, l, mid, y, z);
else
change(x << 1 | 1, mid + 1, r, y, z);
up(x);
}
int query(int x, int l, int r, int L, int R) {
if (l >= L && r <= R) return mx[x];
int mid = (l + r) >> 1;
if (R <= mid)
return query(x << 1, l, mid, L, R);
else if (L > mid)
return query(x << 1 | 1, mid + 1, r, L, R);
else
return max(query(x << 1, l, mid, L, mid),
query(x << 1 | 1, mid + 1, r, mid + 1, R));
}
} idtree, htree;
int main() {
int n = read(), m = read();
for (int Case = 1; Case <= m; Case++) {
int opt = read(), x, y;
if (opt == 1) {
x = read(), y = read() - Case + m;
h[x] = y, hid[y] = x, que.push(-x);
for (int i = y; i >= max(1, y - 9); i--)
if (hid[i])
idtree.change(1, 1, n, hid[i], 0), htree.change(1, 1, m + 10, i, 0);
for (int i = y; i >= max(1, y - 9); i--)
if (hid[i]) {
int t = idtree.query(1, 1, n, hid[i], n) + 1;
idtree.change(1, 1, n, hid[i], t);
htree.change(1, 1, m + 10, i, t);
}
} else if (opt == 2) {
x = read();
for (int i = 1; i <= x; i++) p[i] = -que.top(), que.pop();
for (int i = 1; i < x; i++) que.push(-p[i]);
for (int i = x; i >= 1; i--)
idtree.change(1, 1, n, p[i], 0), htree.change(1, 1, m + 10, h[p[i]], 0);
for (int i = x - 1; i >= 1; i--) {
int t = htree.query(1, 1, m + 10, h[p[i]], m + 10) + 1;
idtree.change(1, 1, n, p[i], t);
htree.change(1, 1, m + 10, h[p[i]], t);
}
hid[h[p[x]]] = 0, h[p[x]] = 0;
}
printf("%d\n", idtree.mx[1]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
inline bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
int drx[8] = {-2, -2, -1, -1, 1, 1, 2, 2};
int dcy[8] = {-1, 1, -2, 2, -2, 2, -1, 1};
int dirx[4] = {-1, 0, 1, 0};
int diry[4] = {0, -1, 0, 1};
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return a * b / gcd<T>(a, b);
}
template <class T>
inline T power(T b, T p) {
long long ans = 1;
while (p--) ans *= b;
return ans;
}
int main() {
long long n, m, num, tc, t = 1;
scanf("%lld", &tc);
while (tc--) {
scanf("%lld %lld", &n, &m);
scanf("%lld", &num);
string str;
cin >> str;
long long pos = str.length();
str[pos - 1] = 'X';
for (long long i = pos - 1; i > 0; --i) {
if (str[i] != str[i - 1]) {
if (str[i - 1] == 'A')
num -= n;
else
num -= m;
}
if (num < 0) break;
pos = i;
}
printf("%lld\n", pos);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
vector<int> a[2];
char ss[maxn];
int main() {
int n;
scanf("%d%s", &n, ss);
long long ans = 1LL * n * (n + 1) / 2 - n;
for (int i = 0; i < n; i++) {
int k = ss[i] - 'A';
if (a[!k].size() > 0) {
int p = a[!k].back();
if (p == i - 1) {
if (a[k].size() > 0) {
int len = p - a[k].back();
ans -= len;
} else {
ans -= p + 1;
}
} else {
ans--;
}
}
a[k].push_back(i);
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 502, M = 1000000007;
int n, m, p[N], w[N], i, j, k, c[N], d[N];
long long o, f[N], s[N], x[N], t[N], g[N], Ans;
void init() {
scanf("%d%d%lld", &n, &m, &o);
for (i = 1; i <= n; i++) scanf("%d", p + i);
for (i = 1; i <= m; i++) {
scanf("%d", w + i);
k = max(k, w[i]);
d[w[i]]++;
}
for (i = 1; i <= m; i++) c[k - w[i]]--;
c[k] = 1;
}
void qwq(long long *x, long long *y, long long *z) {
memset(t, 0, sizeof(t));
int i, j;
long long o;
for (i = 0; i < k; i++)
for (j = 0; j < k; j++) t[i + j] = (t[i + j] + x[i] * y[j]) % M;
for (i = k * 2 - 2; i >= k; i--) {
o = t[i];
for (j = 0; j <= k; j++) t[i - k + j] = (t[i - k + j] - o * c[j]) % M;
}
for (i = 0; i < k; i++) z[i] = t[i];
}
void work() {
for (i = 1; i <= n; i++) {
memset(s, 0, sizeof(s));
memset(x, 0, sizeof(x));
s[0] = 1;
if (k > 1)
x[1] = 1;
else
x[0] = -c[0];
while (p[i]) {
if (p[i] & 1) qwq(s, x, s);
p[i] >>= 1;
qwq(x, x, x);
}
for (j = 0; j < k; j++) f[j] = (f[j] + s[j]) % M;
}
memset(s, 0, sizeof(s));
s[0] = 1;
while (o) {
if (o & 1) qwq(s, f, s);
o >>= 1;
qwq(f, f, f);
}
g[0] = 1;
for (i = 0; i < k; i++)
for (j = 0; j <= i; j++) g[i] = (g[i] + g[i - j] * d[j]) % M;
for (i = 0; i < k; i++) Ans = (Ans + s[i] * g[i]) % M;
printf("%lld", (Ans + M) % M);
}
int main() {
init();
work();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
char rs[(1000 + 5)];
int f[(1000 + 5)][(1000 + 5)], s[(1000 + 5)], zt[(1000 + 5)], g[(1000 + 5)];
int main() {
int m, n;
scanf("%d%d", &m, &n);
for (int i = (1); i <= (int)(n); ++i) {
scanf("%s", rs + 1);
int len = strlen(rs + 1);
for (int j = (1); j <= (int)(len); ++j)
if (rs[j] == '1') zt[j] |= 1ll << i;
}
f[0][0] = s[0] = 1;
for (int i = (1); i <= (int)(m); ++i)
for (int j = (1); j <= (int)(i); ++j) {
f[i][j] = ((1ll * f[i - 1][j] * j % P) + f[i - 1][j - 1]) % P;
s[i] = (s[i] + f[i][j]) % P;
}
int ans = 1;
for (int i = (1); i <= (int)(m); ++i)
if (!g[i]) {
int siz = 0;
for (int j = (i); j <= (int)(m); ++j)
if (zt[i] == zt[j]) ++siz, g[j] = i;
ans = 1ll * ans * s[siz] % P;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[100001], ans[100001] = {0};
int main() {
int n, i;
cin >> n;
for (i = 1; i < n; i++) {
cin >> a[i];
ans[a[i]]++;
}
for (i = 1; i <= n; i++) {
if (ans[i] == 0) {
cout << i;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
vector<int> e[N];
int dep[N];
map<int, int> M[N];
int d[N];
bool flag;
long long ans;
void dfs1(int v, int p) {
for (auto u : e[v]) {
if (u == p) continue;
dep[u] = dep[v] + 1;
dfs1(u, v);
}
}
inline void upd(int &x, int y) {
if (y < x) x = y;
}
void dfs(int v, int p) {
for (auto u : e[v]) {
if (u == p) continue;
dfs(u, v);
if (flag) return;
if (M[v].size() < M[u].size()) swap(M[v], M[u]), swap(d[v], d[u]);
for (auto &it : M[u]) {
if (M[v].count(it.first - d[u] + d[v]))
upd(M[v][it.first - d[u] + d[v]], it.second);
else
M[v][it.first - d[u] + d[v]] = it.second;
}
}
if (v == 1) return;
while (!M[v].empty() && M[v].begin()->second >= dep[v])
M[v].erase(M[v].begin());
if (M[v].empty()) {
flag = true;
return;
}
auto it = M[v].begin();
ans += it->first - d[v];
d[v] = it->first;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
dfs1(1, 0);
for (int i = 1; i <= m; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
if (M[u].count(c))
upd(M[u][c], dep[v]);
else
M[u][c] = dep[v];
}
dfs(1, 0);
if (flag)
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool less0(pair<long long, long long> a, pair<long long, long long> b) {
return a.first * b.second < b.first * a.second;
}
bool equal(pair<long long, long long> a, pair<long long, long long> b) {
return a.first * b.second == b.first * a.second;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
pair<long long, long long> norm(pair<long long, long long> a) {
long long g = gcd(a.first, a.second);
a.first /= g;
a.second /= g;
return a;
}
pair<long long, long long> amb(pair<long long, long long> a,
pair<long long, long long> b) {
return make_pair(abs(a.first * b.second - b.first * a.second),
a.second * b.second);
}
int main() {
long long t1, t2, x1, x2, t0;
pair<long long, long long> mi = make_pair(999999999, 1);
cin >> t1 >> t2 >> x1 >> x2 >> t0;
pair<long long, long long> t00 = make_pair(t0, 1);
long long ansa = 0, ansb = x2;
if (t1 == t2) {
cout << x1 << " " << x2 << endl;
return 0;
}
if (t2 == t0) {
cout << 0 << " " << x2;
return 0;
}
double eps = 0.0000000001;
for (long long i = 0; i <= x1; i++) {
long long a = i * (t0 - t1);
long long b = t2 - t0;
long long j = (a + b - 1) / b;
if (i + j == 0 || j > x2) continue;
pair<long long, long long> te = make_pair(t1 * i + t2 * j, i + j);
te = norm(te);
pair<int, int> temp = amb(te, t00);
temp = norm(temp);
if (less0(temp, mi)) {
mi = temp;
ansa = i;
ansb = j;
} else if (equal(temp, mi) && i + j > ansa + ansb) {
ansa = i;
ansb = j;
}
}
cout << ansa << " " << ansb;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[200010][2];
long long x[200010];
long long t[200010];
long long ans[200010];
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n + m; i++) cin >> x[i];
for (long long i = 0; i < n + m; i++) cin >> t[i];
long long left = -10000000000000;
long long idx = -1;
for (long long i = 0; i < n + m; i++) {
if (t[i] == 1) {
left = x[i];
idx = i;
} else
a[i][0] = {left, idx};
}
long long right = 10000000000000;
idx = -1;
for (long long i = n + m - 1; i >= 0; i--) {
if (t[i] == 1) {
right = x[i];
idx = i;
} else
a[i][1] = {right, idx};
}
for (long long i = 0; i < n + m; i++) {
if (t[i] == 1) continue;
long long Ldis = x[i] - a[i][0].first;
long long Rdis = a[i][1].first - x[i];
if (Ldis <= Rdis)
ans[a[i][0].second]++;
else
ans[a[i][1].second]++;
}
for (long long i = 0; i < n + m; i++) {
if (t[i] == 1) cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const int inf = 1e9;
const ll inf64 = 1e18;
bool check(string a, string b) {
int n = (int) a.size();
int l = 0, r = 0;
while (l < n && a[l] == b[l]) l++;
while (r < n && a[n - 1 - r] == b[n - 1 - r]) r++;
if (l + r >= n) return true;
int ql = l, qr = n - r - 1;
int oka = 1, okb = 1;
for (int i = ql; i < qr; i++) {
if (a[i] < a[i + 1]) oka = 0;
if (b[i] < b[i + 1]) okb = 0;
}
return oka || okb;
}
ll solveNNS(vector<string> a) {
int n = (int) a.size();
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
int cost = 2;
if (check(a[i], a[j]))
cost = 1;
res += cost;
}
}
return res;
}
const int A = 26;
struct Trie {
struct Node {
vector<int> nxt = vector<int>(A, -1);
int par = -1;
int tin = 0;
int tout = 0;
};
vector<Node> t = {Node()};
int timer = 0;
int add_string(const string& s) {
int v = 0;
for (char c : s) {
c -= 'a';
if (t[v].nxt[c] == -1) {
t[v].nxt[c] = (int) t.size();
t.emplace_back();
t.back().par = v;
}
v = t[v].nxt[c];
}
return v;
}
int get(const string& s) {
int v = 0;
for (char c : s) {
c -= 'a';
v = t[v].nxt[c];
}
return v;
}
void dfs(int v) {
t[v].tin = timer++;
for (int c = 0; c < A; c++) {
int to = t[v].nxt[c];
if (to == -1)
continue;
dfs(to);
}
t[v].tout = timer++;
}
void build() {
dfs(0);
}
};
struct pt {
int x = 0;
int y = 0;
};
ll solveNSS(vector<string> a) {
sort(a.begin(), a.end());
for (int i = 0; i + 1 < (int) a.size(); i++)
assert(a[i] != a[i + 1]);
if (a.empty()) return 0;
int n = (int) a.size();
int k = (int) a[0].size();
ll res = 1ll * n * (n - 1);
ll cnt = 0;
Trie pref, suff;
vector<string> b = a;
for (int i = 0; i < n; i++) {
pref.add_string(a[i]);
reverse(b[i].begin(), b[i].end());
suff.add_string(b[i]);
}
pref.build();
suff.build();
vector<pt> ps(n);
for (int i = 0; i < n; i++) {
int u = pref.get(a[i]);
int v = suff.get(b[i]);
ps[i].x = pref.t[u].tin;
ps[i].y = suff.t[v].tin;
if (i > 0) assert(ps[i - 1].x <= ps[i].x);
}
vector<tuple<int, int, int, int, int>> recs;
for (int i = 0; i < n; i++) {
int pv = 0, sv = suff.get(b[i]);
// cout << i << " : \n";
int last_lx = 0;
int last_rx = 0;
for (int from = 0, r = -1, l = 0; l + 1 < k; pv = pref.t[pv].nxt[a[i][l] - 'a'], l++) {
while (r < l) {
sv = suff.t[sv].par;
r++;
}
while (r + 1 < k && a[i][r] >= a[i][r + 1]) {
sv = suff.t[sv].par;
r++;
}
{
int npv = pref.t[pv].nxt[a[i][l] - 'a'];
int lx = pref.t[pv].tin;
int rx = pref.t[npv].tin;
assert(last_lx <= lx); last_lx = lx;
assert(last_rx <= rx); last_rx = rx;
int ly = suff.t[sv].tin;
int ry = suff.t[sv].tout;
while (from < i && ps[from].x <= lx) from++;
for (int j = from; j < i; j++) {
if (lx < ps[j].x && ps[j].x < rx && ly < ps[j].y && ps[j].y < ry)
cnt++;
}
}
}
}
// cout << "cnt = " << cnt << "\n";
res -= cnt;
return res;
}
const int SQRT = (int) sqrt(2e5);
ll fast(int n, vector<string> a) {
vector<string> b(n);
for (int i = 0; i < n; i++) {
b[i] = a[i];
sort(b[i].begin(), b[i].end());
}
vector<int> perm(n);
for (int i = 0; i < n; i++)
perm[i] = i;
sort(perm.begin(), perm.end(), [&](int i, int j) {
return b[i] < b[j];
});
ll add = 0, res = 0;
for (int it = 0; it < n; it++) {
int jit = it;
vector<string> group;
while (jit < n && b[perm[it]] == b[perm[jit]]) {
group.push_back(a[perm[jit]]);
jit++;
}
jit--;
add += 1ll * (int) group.size() * (n - (int) group.size());
res += n < SQRT ? solveNNS(group) : solveNSS(group);
// res += solveNSS(group);
it = jit;
}
assert(add % 2 == 0);
res += 1337ll * add / 2;
return res;
}
ll slow(int n, vector<string> a) {
sort(a.begin(), a.end());
ll res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
{
string aa = a[i], bb = a[j];
sort(aa.begin(), aa.end());
sort(bb.begin(), bb.end());
if (aa != bb) {
res += 1337;
continue;
}
}
int l = 0, r = 0;
int sz = (int) a[i].size();
while (l < sz && a[i][l] == a[j][l]) l++;
while (r < sz && a[i][sz - 1 - r] == a[j][sz - 1 - r]) r++;
assert(l + r < sz);
int ql = l, qr = sz - r - 1;
int ok = 1;
for (int q = ql; q < qr; q++) {
if (a[i][q] < a[i][q + 1]) ok = 0;
}
if (ok) res++;
else res += 2;
}
}
return res;
}
void work() {
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
for (char& c : a[i])
c = 25 - (c - 'a') + 'a';
}
ll res = fast(n, a);
cout << res << "\n";
}
string gen_string(mt19937& rnd, int len, const int MAXC) {
string res(len, '?');
for (char& c : res)
c = rnd() % MAXC + 'a';
return res;
}
void test() {
mt19937 rnd(42);
const int MAXN = 10;
const int MAXL = 5;
const int MAXC = 3;
while (1) {
int n = rnd() % MAXN + 1;
int m = rnd() % MAXL + 1;
vector<string> a(n);
for (int i = 0; i < n; i++) {
if (i == 0 || rnd() % 2)
a[i] = gen_string(rnd, m, MAXC);
else {
a[i] = a[rnd() % i];
shuffle(a[i].begin(), a[i].end(), rnd);
}
}
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
n = (int) a.size();
shuffle(a.begin(), a.end(), rnd);
ll fs = fast(n, a);
ll sl = slow(n, a);
if (fs == sl) {
cout << "OK(" << fs << ")" << endl;
} else {
cout << "WA\n";
cout << "exp = " << sl << "\n";
cout << "fnd = " << fs << "\n";
cout << n << "\n";
for (int i = 0; i < n; i++)
cout << a[i] << "\n";
break;
}
}
}
int main() {
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
work();
// test();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char Map[25][25];
int id[25][25];
struct sss {
int x, y, v;
} G[500], B[500], X;
int n, m, g, b, p;
int st, ed;
pair<int, int> space[500];
int dx[4] = {-1, 0, 0, 1};
int dy[4] = {0, -1, 1, 0};
struct edge {
int to, rev;
int cap, flo;
edge() {}
edge(int t, int r, int c) : to(t), rev(r), cap(c), flo(0) {}
long long int rem() { return cap - flo; }
};
int lev[2000], nxt[2000];
vector<edge> _G[2000];
struct maxflow {
int N, second, T;
long long int flow;
maxflow(int N, int second = 0, int T = -1)
: N(N), second(second), T(T < 0 ? N + T : T) {
flow = 0;
for (int i = 0; i <= N; i++) _G[i].clear();
}
void addedge(int A, int B, int C) {
_G[A].push_back(edge(B, _G[B].size(), C)),
_G[B].push_back(edge(A, _G[A].size() - 1, 0));
}
void flood() {
while (BFS()) flow += DFS(second, 10000000);
}
bool BFS() {
fill(nxt, nxt + N, 0);
fill(lev, lev + N, -1);
queue<int> q;
lev[second] = 0, q.push(second);
while (q.size()) {
int i = q.front();
q.pop();
for (int j = 0; j < _G[i].size(); j++)
if (_G[i][j].rem() != 0 && lev[_G[i][j].to] == -1)
lev[_G[i][j].to] = lev[i] + 1, q.push(_G[i][j].to);
}
return lev[T] != -1;
}
long long int DFS(int i, long long int rem) {
if (i == T) return rem;
long long int all = rem;
for (int j = nxt[i]; j < _G[i].size(); j++, nxt[i]++) {
if (_G[i][j].rem() == 0 || lev[i] >= lev[_G[i][j].to]) continue;
long long int add = DFS(_G[i][j].to, min(rem, _G[i][j].rem()));
_G[i][j].flo += add, rem -= add;
_G[_G[i][j].to][_G[i][j].rev].flo -= add;
if (rem == 0) break;
}
return all - rem;
}
};
int check(long long int t) {
int i, j, k;
st = 0, ed = b + g + p + p + 1;
maxflow mf(ed + 1, st, ed);
for (i = 0; i < b; i++) {
mf.addedge(st, i + 1, 1);
}
for (i = 0; i < g; i++) {
mf.addedge(i + b + 1, ed, 1);
}
for (i = 0; i < b; i++) {
long long int vis[25][25];
for (j = 0; j < n; j++)
for (k = 0; k < m; k++) vis[j][k] = -1;
int nx = B[i].x, ny = B[i].y;
queue<pair<int, int> > q;
q.push(make_pair(nx, ny));
mf.addedge(i + 1, id[nx][ny] + 1 + b + g, 1);
vis[nx][ny] = 0;
while (!q.empty() && vis[nx][ny] <= t) {
nx = q.front().first;
ny = q.front().second;
q.pop();
for (j = 0; j < 4; j++) {
int mx = nx + dx[j], my = ny + dy[j];
if (mx < 0 || mx >= n || my < 0 || my > m || Map[mx][my] == '#' ||
vis[mx][my] != -1)
continue;
q.push(make_pair(mx, my));
vis[mx][my] = vis[nx][ny] + B[i].v;
if (vis[mx][my] <= t) mf.addedge(i + 1, id[mx][my] + 1 + b + g, 1);
}
}
}
for (i = 0; i < g; i++) {
long long int vis[25][25];
for (j = 0; j < n; j++)
for (k = 0; k < m; k++) vis[j][k] = -1;
int nx = G[i].x, ny = G[i].y;
queue<pair<int, int> > q;
q.push(make_pair(nx, ny));
mf.addedge(id[nx][ny] + 1 + p + b + g, i + b + 1, 1);
vis[nx][ny] = 0;
while (!q.empty() && vis[nx][ny] <= t) {
nx = q.front().first;
ny = q.front().second;
q.pop();
for (j = 0; j < 4; j++) {
int mx = nx + dx[j], my = ny + dy[j];
if (mx < 0 || mx >= n || my < 0 || my > m || Map[mx][my] == '#' ||
vis[mx][my] != -1)
continue;
q.push(make_pair(mx, my));
vis[mx][my] = vis[nx][ny] + G[i].v;
if (vis[mx][my] <= t)
mf.addedge(id[mx][my] + 1 + p + b + g, i + b + 1, 1);
}
}
}
for (i = 0; i < p; i++) {
int xx = space[i].first, yy = space[i].second;
mf.addedge(id[xx][yy] + 1 + b + g, id[xx][yy] + 1 + b + g + p, 1);
}
mf.flood();
if (mf.flow == g) return 1;
return 0;
}
int main(void) {
scanf("%d%d%d%d", &n, &m, &b, &g);
int i, j;
p = 0;
for (i = 0; i < n; i++) {
char s[25];
scanf("%s", s);
for (j = 0; j < m; j++) {
Map[i][j] = s[j];
if (Map[i][j] == '.') {
space[p].first = i, space[p].second = j, id[i][j] = p, p++;
}
}
}
scanf("%d%d%d", &X.x, &X.y, &X.v);
X.x--, X.y--;
for (i = 0; i < b; i++) {
scanf("%d%d%d", &B[i].x, &B[i].y, &B[i].v);
B[i].x--, B[i].y--;
}
for (i = 0; i < g; i++) {
scanf("%d%d%d", &G[i].x, &G[i].y, &G[i].v);
G[i].x--, G[i].y--;
}
if (g + 1 == b) {
G[g] = X;
g++;
} else if (b + 1 == g) {
B[b] = X;
b++;
} else {
printf("-1\n");
return 0;
}
long long int l = 0, r = 500000000000LL;
while (l <= r) {
long long int mid = (l + r) / 2;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
if (l >= 500000000000LL)
printf("-1\n");
else
printf("%I64d\n", l);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long INF64 = 1e18;
const double PI = acos(-1.0);
const double EPS = 1e-8;
const int MOD = 1000000007;
const int N = 110;
int n, m, q;
int ans[N][N];
int main() {
cin >> n >> m >> q;
vector<pair<pair<int, int>, pair<int, int> > > a(q);
for (int i = 0; i < int(q); i++) {
cin >> a[i].first.first >> a[i].first.second;
if (a[i].first.first == 3) {
cin >> a[i].second.first >> a[i].second.second;
}
}
for (int i = q - 1; i >= 0; i--) {
if (a[i].first.first == 1) {
int x = a[i].first.second - 1;
int val = ans[x][m - 1];
for (int j = m - 1; j > 0; j--) ans[x][j] = ans[x][j - 1];
ans[x][0] = val;
}
if (a[i].first.first == 2) {
int x = a[i].first.second - 1;
int val = ans[n - 1][x];
for (int j = n - 1; j > 0; j--) ans[j][x] = ans[j - 1][x];
ans[0][x] = val;
}
if (a[i].first.first == 3) {
int x = a[i].first.second - 1;
int y = a[i].second.first - 1;
int val = a[i].second.second;
ans[x][y] = val;
}
}
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(m); j++) cout << ans[i][j] << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
map<long long, int> mp[26];
char s[maxn];
int val[30];
int main() {
for (int i = 0; i < 26; i++) scanf("%d", &val[i]);
scanf("%s", s);
int len = strlen(s);
long long sum = 0;
long long ans = 0;
for (int i = 0; i < len; i++) {
ans += mp[s[i] - 'a'][sum];
sum += val[s[i] - 'a'];
mp[s[i] - 'a'][sum]++;
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n;
int i, j, x;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i < (n + 1) / 2) {
if (j >= ((n + 1) / 2) - (i - 1) && j <= ((n + 1) / 2) + (i - 1))
printf("D");
else
printf("*");
} else if (i == (n + 1) / 2)
printf("D");
else if (i > (n + 1) / 2) {
x = (n + 1) - i;
if (j >= ((n + 1) / 2) - (x - 1) && j <= ((n + 1) / 2) + (x - 1))
printf("D");
else
printf("*");
}
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int num, id, x, y;
bool operator<(const node &a) const { return num < a.num; }
} a[1000100];
int fa[1000100], res[1000100], nx[1000100], ny[1000100], tmp[1000100],
lx[1000100], ly[1000100];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int pos, i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
pos = ((i - 1) * m + j);
scanf("%d", &a[pos].num);
a[pos].id = pos;
a[pos].x = i;
a[pos].y = j;
fa[pos] = pos;
}
}
sort(a + 1, a + n * m + 1);
for (int i = 1, j; i <= n * m; i = j + 1) {
j = i;
while (j < n * m && a[j + 1].num == a[j].num) j++;
for (int k = i; k <= j; k++) {
int x = a[k].x, y = a[k].y;
if (!nx[x])
nx[x] = k;
else
fa[find(nx[x])] = fa[find(k)];
if (!ny[y])
ny[y] = k;
else
fa[find(ny[y])] = fa[find(k)];
}
for (int k = i; k <= j; k++) {
tmp[find(k)] = max(tmp[find(k)], max(lx[a[k].x], ly[a[k].y]) + 1);
}
for (int k = i; k <= j; k++) {
int x = a[k].x, y = a[k].y;
nx[x] = ny[y] = 0;
lx[x] = ly[y] = res[a[k].id] = tmp[find(k)];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d ", res[((i - 1) * m + j)]);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 7;
const int MOD = 1e9 + 7;
int fact[N], inv[N];
int add[N];
int com[N];
int l[N], r[N];
long long bpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
long long c(long long a, long long b) {
if (a > b) return 0;
return 1LL * fact[b] * inv[a] % MOD * inv[b - a] % MOD;
}
int main() {
ios::sync_with_stdio(false);
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = 1LL * fact[i - 1] * i % MOD;
inv[N - 1] = bpow(fact[N - 1], MOD - 2);
for (int i = N - 1; i > 0; i--) inv[i - 1] = 1LL * inv[i] * i % MOD;
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
com[2 * i] = l[i];
com[2 * i + 1] = ++r[i];
}
sort(com, com + 2 * n);
int cnt = unique(com, com + 2 * n) - com;
for (int i = 0; i < n; i++) {
l[i] = lower_bound(com, com + cnt, l[i]) - com;
r[i] = lower_bound(com, com + cnt, r[i]) - com;
add[l[i]]++;
add[r[i]]--;
}
int ps = 0;
long long ans = 0;
for (int i = 0; i + 1 < cnt; i++) {
ps += add[i];
ans = (ans + 1LL * c(k, ps) * (com[i + 1] - com[i]) % MOD) % MOD;
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void DATA(char *s, char *d) {
freopen(s, "r", stdin);
freopen(d, "w", stdout);
}
inline int input() {
int ret = 0;
bool isN = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') isN = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return isN ? -ret : ret;
}
inline void output(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
int len = 0, data[10];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
putchar('\n');
}
map<pair<int, int>, int> mp;
int n, p;
int a[300005], b[300005];
struct node {
int id, val;
} root[300005];
bool cmp(node i, node j) {
return i.val < j.val || (i.val == j.val && i.id < j.id);
}
long long ans;
inline int BS(int s, int t, int v) {
int mid;
int p = t + 1;
while (s <= t) {
mid = (s + t) >> 1;
if (root[mid].val >= v) p = min(p, mid);
if (root[mid].val < v)
s = mid + 1;
else
t = mid - 1;
}
return p;
}
int cnt[300005];
int main() {
ans = 0;
memset(cnt, 0, sizeof(cnt));
mp.clear();
n = input(), p = input();
for (int i = 1; i < n + 1; i++) root[i].id = i, root[i].val = 0;
for (int i = 1; i < n + 1; i++) {
a[i] = input(), b[i] = input();
if (a[i] > b[i]) swap(a[i], b[i]);
mp[pair<int, int>(a[i], b[i])]++;
root[a[i]].val++;
root[b[i]].val++;
}
for (map<pair<int, int>, int>::iterator it = mp.begin(); it != mp.end();
it++) {
{
int x = (*it).first.first;
int y = (*it).first.second;
if (root[x].val + root[y].val >= p &&
root[x].val + root[y].val - (*it).second < p)
ans--;
}
}
sort(root + 1, root + n + 1, cmp);
for (int i = 1; i < n; i++) {
{
int r = p - root[i].val;
int s = BS(i + 1, n, r);
ans += (n - s + 1) * 1LL;
}
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void getar(T a, int n, int m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
inline void getar(int *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d", a + ii);
}
}
inline void getar(pair<int, int> *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("d", &a[ii].first, &a[ii].second);
}
}
inline void getar(long long *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%I64d", a + ii);
}
}
inline void getv(vector<int> &a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d", &a[ii]);
}
}
inline void getv(vector<long long> &a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%I64d", &a[ii]);
}
}
inline void getv(vector<pair<int, int> > &a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d", &a[ii].first, &a[ii].second);
}
}
inline void getv(vector<pair<long long, long long> > &a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%I64d", &a[ii].first, &a[ii].second);
}
}
inline void getvv(vector<vector<int> > &a, int n, int m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
inline void printa(int *a, int i, int j) {
for (int ii = i; ii <= j; ii++) {
printf("%d ", a[ii]);
}
}
inline void printa(long long *a, int i, int j) {
for (int ii = i; ii <= j; ii++) {
printf("%I64d ", a[ii]);
}
}
inline void printv(vector<int> &a, int i, int j) {
for (int ii = i; ii <= j; ii++) {
printf("%d ", a[ii]);
}
}
inline void printv(vector<long long> &a, int n, int i, int j) {
for (int ii = i; ii <= j; ii++) {
printf("%I64d ", a[ii]);
}
}
inline long long max(long long a, long long b) { return (a > b) ? a : b; }
inline int max(int a, int b) { return (a > b) ? a : b; }
inline double max(double a, double b) { return (a > b) ? a : b; }
inline long long max(long long a, long long b, long long c) {
return max(a, max(b, c));
}
inline int max(int a, int b, int c) { return max(a, max(b, c)); }
inline double max(double a, double b, double c) { return max(a, max(b, c)); }
inline long long min(long long a, long long b) { return (a < b) ? a : b; }
inline int min(int a, int b) { return (a < b) ? a : b; }
inline double min(double a, double b) { return (a < b) ? a : b; }
inline long long min(long long a, long long b, long long c) {
return min(a, min(b, c));
}
inline int min(int a, int b, int c) { return min(a, min(b, c)); }
inline double min(double a, double b, double c) { return min(a, min(b, c)); }
inline long long pow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
inline long long powmod(long long x, long long n, long long _mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % _mod;
x = (x * x) % _mod;
n >>= 1;
}
return res;
}
inline long long gcd(long long a, long long b) {
long long t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline int gcd(int a, int b) {
int t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline long long lcm(int a, int b) { return a / gcd(a, b) * (long long)b; }
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long gcd(long long a, long long b, long long c) {
return gcd(gcd(a, b), c);
}
inline int gcd(int a, int b, int c) { return gcd(gcd(a, b), c); }
inline long long lcm(long long a, long long b, long long c) {
return lcm(lcm(a, b), c);
}
inline long long lcm(int a, int b, int c) {
return lcm(lcm(a, b), (long long)c);
}
inline int bits_count(int v) {
v = v - ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline int bits_count(long long v) {
long long t = v >> 32;
long long p = (v & ((1LL << 32) - 1));
return bits_count(t) + bits_count(p);
}
inline bool ispow2(int x) { return (x != 0 && (x & (x - 1)) == 0); }
const char nl = '\n';
void solve() {
int n;
cin >> n;
string s, res;
cin >> s;
for (int i = 0; i < n; i++) {
if ((int)res.size() % 2 == 0 || res.back() != s[i]) res += s[i];
}
if ((int)res.size() & 1) res.pop_back();
cout << n - (int)res.size() << nl << res << nl;
}
int main() {
clock_t clk = clock();
cerr << "Hey P..\n";
int t;
t = 1;
while (t--) solve();
cerr << "Look at the sky.\n";
cerr << "Time (in ms): " << (double)(clock() - clk) * 1000.0 / CLOCKS_PER_SEC
<< '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 110;
const int MAX_M = 20;
const long long INF = (1LL << 60);
struct Elem {
Elem() {}
Elem(int ruble, int monitor, int prob)
: ruble(ruble), monitor(monitor), prob(prob) {}
int ruble, monitor, prob;
bool operator<(const Elem &b) const { return monitor < b.monitor; }
} elem[MAX_N];
int n, m, price;
long long f[1 << MAX_M];
int main() {
scanf("%d%d%d", &n, &m, &price);
for (int i = 0; i < n; i++) {
int a, b, c, d, e = 0;
scanf("%d%d%d", &a, &b, &c);
for (int j = 0; j < c; j++) {
scanf("%d", &d);
d--;
e = e | (1 << d);
}
elem[i] = Elem(a, b, e);
}
long long ans = INF;
sort(elem, elem + n);
fill(f, f + (1 << m), INF);
f[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++) {
f[j | elem[i].prob] = min(f[j | elem[i].prob], f[j] + elem[i].ruble);
}
ans = min(ans, f[(1 << m) - 1] + 1LL * price * elem[i].monitor);
}
if (ans == INF)
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
long long n = s.length();
long long mi[26];
long long ma[26];
for (long long i = 0; i < 26; i++) {
mi[i] = 2000000000000000500;
ma[i] = -1;
}
for (long long i = 0; i < n; i++) {
long long key = (long long)s[i] - (long long)'a';
mi[key] = min(mi[key], i);
ma[key] = max(ma[key], i);
}
for (long long i = 0; i < n; i++) {
bool cc = false;
long long key = (long long)s[i] - (long long)'a';
for (long long j = 0; j < key; j++) {
if (mi[j] < i) cc = true;
}
if (cc) {
cout << "Ann" << endl;
} else {
cout << "Mike" << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct compare {
bool operator()(const pair<int, int> &a, const pair<int, int> &b) {
return a.first > b.first;
}
};
bool comp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) {
return a.second < b.second;
}
return a.first < b.first;
}
bool compp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) {
return a.second > b.second;
}
return a.first < b.first;
}
long long gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(int a, int b) { return (a / gcd(a, b)) * b; }
int mod_power(int a, int b) {
if (b == 0) {
return 1;
}
int temp = mod_power(a, b / 2);
temp %= 998244353;
temp *= temp;
temp %= 998244353;
if (b % 2 == 1) {
temp *= a;
temp %= 998244353;
}
return temp;
}
int st = 0;
int n, m;
int dp[2001][2001];
int vis[2001][2001];
string vec[2001];
int fill(int i, int j) {
if (i >= n || i < 0 || j >= m || j < 0) {
st = 0;
return 0;
}
if (vis[i][j]) {
st = st - vis[i][j] + 1;
return (dp[i][j] = st);
}
if (dp[i][j] != -1) {
st = 0;
return 0;
}
st++;
vis[i][j] = st;
int num = 0;
if (vec[i][j] == 'U') {
num = fill(i - 1, j);
}
if (vec[i][j] == 'D') {
num = fill(i + 1, j);
}
if (vec[i][j] == 'R') {
num = fill(i, j + 1);
}
if (vec[i][j] == 'L') {
num = fill(i, j - 1);
}
if (dp[i][j] != -1) {
st = 0;
} else {
dp[i][j] = st;
}
vis[i][j] = 0;
return st;
}
void dfs(int i, int j) {
if (i >= n || i < 0 || j >= m || j < 0) {
st = 0;
return;
}
if (dp[i][j] > 0) {
st += dp[i][j];
return;
}
if (vec[i][j] == 'U') {
dfs(i - 1, j);
} else if (vec[i][j] == 'D') {
dfs(i + 1, j);
} else if (vec[i][j] == 'R') {
dfs(i, j + 1);
} else {
dfs(i, j - 1);
}
st++;
dp[i][j] = st;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
dp[i][j] = -1;
vis[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dp[i][j] == -1) {
st = 0;
fill(i, j);
}
}
}
int ans = 0;
int x = 0;
int y = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (dp[i][j] == 0) {
st = 0;
dfs(i, j);
}
if (ans < dp[i][j]) {
ans = dp[i][j];
x = i;
y = j;
}
}
}
cout << x + 1 << " " << y + 1 << " " << ans << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
for (int t = 0; t < T; ++t) {
int n;
cin >> n;
string a, b;
vector<int> va, vb;
cin >> a >> b;
if (a == b) {
cout << 0 << endl;
continue;
}
if (a.length() == 1 && b.length() == 1) {
if (a == b) {
cout << 0 << endl;
} else {
cout << 1 << " " << 1 << endl;
}
continue;
}
for (int i = 0; i < n; ++i) {
va.push_back(a[i] - 48);
vb.push_back(!(b[n - i - 1] - 48));
}
vector<int> answer;
int index = 0;
int iteration = 0;
while (index <= n - 1) {
if (va[n - index - 1] == vb[n - index - 1]) {
index++;
continue;
}
if (va[0] == vb[n - index - 1]) {
answer.push_back(1);
va[0] = (va[0] == 0) ? 1 : 0;
} else {
answer.push_back(n - index);
int c[n - index];
for (int i = 0; i < n - index; ++i) {
c[i] = !va[n - index - 1 - i];
}
for (int i = 0; i < n - index; ++i) {
va[i] = c[i];
}
index++;
}
}
answer.push_back(va.size());
cout << answer.size() << " ";
for (int i = 0; i < answer.size(); ++i) {
cout << answer[i] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 2e5 + 10;
int str[N];
int _rank[N], pos[N];
int CNT[N], _next[N];
bool bh[N], b2h[N];
bool smaller_first_char(int a, int b) { return str[a] < str[b]; }
void suffixSort(int n) {
for (int i = 0; i < n; ++i) {
pos[i] = i;
}
sort(pos, pos + n, smaller_first_char);
for (int i = 0; i < n; ++i) {
bh[i] = i == 0 || str[pos[i]] != str[pos[i - 1]];
b2h[i] = false;
}
for (int h = 1; h < n; h <<= 1) {
int buckets = 0;
for (int i = 0, j; i < n; i = j) {
j = i + 1;
while (j < n && !bh[j]) j++;
_next[i] = j;
buckets++;
}
if (buckets == n) break;
for (int i = 0; i < n; i = _next[i]) {
CNT[i] = 0;
for (int j = i; j < _next[i]; ++j) {
_rank[pos[j]] = i;
}
}
CNT[_rank[n - h]]++;
b2h[_rank[n - h]] = true;
for (int i = 0; i < n; i = _next[i]) {
for (int j = i; j < _next[i]; ++j) {
int s = pos[j] - h;
if (s >= 0) {
int head = _rank[s];
_rank[s] = head + CNT[head]++;
b2h[_rank[s]] = true;
}
}
for (int j = i; j < _next[i]; ++j) {
int s = pos[j] - h;
if (s >= 0 && b2h[_rank[s]]) {
for (int k = _rank[s] + 1; !bh[k] && b2h[k]; k++) b2h[k] = false;
}
}
}
for (int i = 0; i < n; ++i) {
pos[_rank[i]] = i;
bh[i] |= b2h[i];
}
}
for (int i = 0; i < n; ++i) {
_rank[pos[i]] = i;
}
}
int height[N];
void getHeight(int n) {
for (int i = 0; i < n; ++i) _rank[pos[i]] = i;
height[0] = 0;
for (int i = 0, h = 0; i < n; ++i) {
if (_rank[i] > 0) {
int j = pos[_rank[i] - 1];
while (i + h < n && j + h < n && str[i + h] == str[j + h]) h++;
height[_rank[i]] = h;
if (h > 0) h--;
}
}
for (int i = 0; i < n - 1; i++) height[i] = height[i + 1];
height[n - 1] = 0;
}
const int logN = 21;
int ceillog[5 * N];
int RMQ[logN][N];
int lcp(int i, int j, int n) {
if (i > j) swap(i, j);
if (i == j) return n - pos[i];
j--;
int k = ceillog[j - i + 2] - 1;
assert(i + (1 << k) <= j + 1);
return min(RMQ[k][i], RMQ[k][j - (1 << k) + 1]);
}
char s1[N], s2[N];
int g[N], f[N], pref[N], store[N];
int tree[N << 1], lazy[N << 1];
set<int> okay;
int main() {
ceillog[1] = 0;
int k;
for (k = 1; (1 << k) < 5 * N; k++)
for (int i = (1 << (k - 1)) + 1; i <= (1 << k); i++) ceillog[i] = k;
for (int i = (1 << k); i < 5 * N; i++) ceillog[i] = k + 1;
scanf("%s", s1);
scanf("%s", s2);
int n1 = strlen(s1), n2 = strlen(s2);
string s = ((string)s1) + ((string)s2);
int n = s.length();
for (int i = 0; i < n; i++) str[i] = s[i] - 'a';
suffixSort(n);
getHeight(n);
for (int i = n - 1; i >= 0; i--) {
RMQ[0][i] = height[i];
for (int j = 1; i + (1 << j) <= n; j++)
RMQ[j][i] = min(RMQ[j - 1][i], RMQ[j - 1][i + (1 << (j - 1))]);
}
for (int i = 1; i <= n1; i++) {
f[i] = min(n1 - i + 1, lcp(_rank[i - 1], _rank[n1], n));
}
for (int i = 1; i <= n2; i++) {
int L = lcp(_rank[i + n1], _rank[n1], n);
g[i] = i < n2 ? min(n2 - i, lcp(_rank[i + n1], _rank[n1], n)) : 0;
}
long long ans = 0;
for (int i = 1; i <= n2; i++) okay.insert(i);
store[0] = n2;
for (int t = 1; t <= n2; t++) {
int mn = t + 1, mx = g[t] + t;
vector<int> deletions;
auto it = okay.upper_bound(t);
while (it != okay.end() && *it <= mx) {
deletions.push_back(*it);
it++;
}
for (auto it1 : deletions) okay.erase(it1);
store[t] = okay.size();
}
for (int i = 1; i <= n1; i++) {
int t_max = f[i + 1];
ans += store[t_max];
}
printf("%lld\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> fact;
int n, p;
void add(int x) { fact.push_back(x); }
int l[100010], r[100010];
int main() {
scanf("%d %d", &n, &p);
for (int i = 1; i * i <= p; i++)
if (p % i == 0) {
add(i);
if (i * i != p) add(p / i);
}
sort(fact.begin(), fact.end());
for (int i = 0; i < n; i++) scanf("%d %d", &l[i], &r[i]);
l[n] = l[0];
r[n] = r[0];
double ans = 0;
for (int k = 0; k < n; k++) {
vector<int> d(fact.size());
for (int i = fact.size() - 1; i >= 0; i--) {
d[i] = r[k] / fact[i] - (l[k] - 1) / fact[i];
for (int j = i + 1; j < fact.size(); j++)
if (fact[j] % fact[i] == 0) d[i] -= d[j];
}
double now = 0;
for (int i = 0; i < fact.size(); i++) {
int rp = p / fact[i];
now += (long long)d[i] * (r[k + 1] / rp - (l[k + 1] - 1) / rp);
}
now /= r[k] - l[k] + 1;
now /= r[k + 1] - l[k + 1] + 1;
ans += now;
}
printf("%.12lf\n", ans * 2000);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T gi() {
T f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f * x;
}
const int INF = 0x3f3f3f3f, N = 1000003, M = N << 1;
int n, a[N];
struct Node {
int l, r;
long long sum;
} stk[N];
int tp;
int main() {
n = gi<int>();
for (int i = 1; i <= n; i += 1) a[i] = gi<int>();
stk[tp = 1] = {1, 1, a[1]};
for (int i = 2; i <= n; i += 1) {
stk[++tp] = {i, i, a[i]};
while (tp > 1) {
Node x = stk[tp - 1], y = stk[tp];
if (1. * x.sum / (x.r - x.l + 1) > 1. * y.sum / (y.r - y.l + 1))
--tp, stk[tp] = {x.l, y.r, x.sum + y.sum};
else
break;
}
}
for (int i = 1; i <= tp; i += 1) {
double now = 1. * stk[i].sum / (stk[i].r - stk[i].l + 1);
for (int j = stk[i].l; j <= stk[i].r; j += 1) printf("%.12f\n", now);
}
return 0;
}
| 6 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<set>
#include<vector>
#include<ctime>
#include<cstring>
#include<map>
#include<queue>
#define mp make_pair
#define PII pair<int,int>
#define fi first
#define se second
#define pb push_back
using namespace std;
inline int read(){
int x=0,f=1;
char c=getchar();
while(!isdigit(c)){if(c=='-') f=-1;c=getchar();}
while(isdigit(c)){x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return f==1?x:~x+1;
}
int n;
int T;
int idx;
int a[300010],pos[300010];
vector<int>vec[300010];
int fa[300010],dep[300010];
int Dfn[300010],Pos[300010];
void dfs(int x,int f){
fa[x]=f;dep[x]=dep[f]+1;
for(int v:vec[x]){
if(v==f) continue ;
dfs(v,x);
}
}
long long solve(){
long long ans=0;
for(int i=1;i<T;++i){
// printf("i:%d,pos:%d,Pos:%d\n",i,pos[i],Pos[i]);
ans+=dep[pos[i]]-1;
}
return ans;
}
int in_t[300010],iidx;
int in[300010],out[300010],ot[300010];
int oidx;
void check(int x,int f){
in[x]=++idx;
if(a[x]>=T){
in_t[x]=++iidx;
}
auto cmp=[&](int x,int y){
return Dfn[x]<Dfn[y];
};
sort(vec[x].begin(),vec[x].end(),cmp);
for(int v:vec[x]){
if(v==f) continue ;
if(Dfn[v]!=idx+1) {
printf("NO\n");exit(0);
}
check(v,x);
}
ot[x]=++oidx;
out[x]=idx;
}
int main(){
n=read();
for(int i=1;i<=n;++i) a[i]=read(),pos[a[i]]=i;
for(int i=1;i<n;++i){
int u=read(),v=read();vec[u].pb(v),vec[v].pb(u);
}
dfs(1,0);
Dfn[1]=1;
int idx=1;
for(int i=1;i<=n;++i){
vector<int>st;
int p=pos[i];
while(!Dfn[p]){
st.pb(p);p=fa[p];
}
reverse(st.begin(),st.end());
for(int a:st){
Dfn[a]=++idx;
}
}
T=max(1,a[1]-1);
int ps=pos[T],cur=ps;
int ans=0;
while(ps!=1){
swap(a[ps],a[fa[ps]]);
swap(pos[a[ps]],pos[a[fa[ps]]]);
ps=fa[ps];
++ans;
}
idx=0;
check(1,0);
for(int i=1;i<=n;++i){
if(a[i]>=T){
if(a[i]!=in_t[i]+T-1){
printf("NO\n");exit(0);
}
}
else{
if(a[i]!=ot[i]){
printf("NO\n");exit(0);
}
}
if(ot[i]==T){
if(in[i]<in[cur]||out[i]>out[cur]){
printf("NO\n");exit(0);
}
}
}
printf("YES\n");
for(int i=1;i<=n;++i) Pos[Dfn[i]]=i;
printf("%lld\n",ans+solve());
for(int i=1;i<=n;++i) printf("%d ",Dfn[i]);
} | 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
for (int i = 1, _b = a; i <= _b; i++) {
int j = a / i;
if (b % i == 0 && c % j == 0 && b / i == c / j) {
printf("%d\n", 4 * (i + j + b / i));
return 0;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long tc = 1;
int main() {
ios::sync_with_stdio(0);
long long ten[20];
ten[0] = 1;
string nine[20];
for (int i = 1; i <= 18; i++) {
ten[i] = ten[i - 1] * 10;
nine[i] = nine[i - 1] + '9';
}
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long a[n + 5];
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << k + 1 << "\n";
continue;
}
long long seg[n + 5], baki = 19;
for (int i = n - 1; i >= 0; i--) {
seg[i] = baki - a[i];
baki = a[i];
}
string s;
for (int i = 0; i < n; i++) {
if (ten[seg[i]] - 1 > k || k == 0) {
cout << k + 1 << s << "\n";
break;
}
s += nine[seg[i]];
k -= (ten[seg[i]] - 1);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int A[100002];
int B[100002];
int pr[10000002];
int divA[10000002];
int divB[10000002];
void Solution(int n, int *X, int *Y) {
for (int i = 1; i <= n; i++) {
int ans = 1;
for (int j = X[i]; j > 1; j /= pr[j]) {
if (Y[pr[j]])
Y[pr[j]]--;
else
ans *= pr[j];
}
printf("%d", ans);
if (i < n) printf(" ");
}
printf("\n");
}
void Count_Divisors(int n, int *X, int *Y) {
for (int i = 1; i <= n; i++)
for (int j = X[i]; j > 1; j /= pr[j]) Y[pr[j]]++;
}
void Find_Divisors(void) {
for (int i = 2; i < 10000002; i++)
if (!pr[i])
for (int j = i; j < 10000002; j += i) pr[j] = i;
}
void Read(void) {
scanf("%d%d", &N, &M);
printf("%d %d\n", N, M);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]);
for (int i = 1; i <= M; i++) scanf("%d", &B[i]);
}
int main() {
Read();
Find_Divisors();
Count_Divisors(N, A, divA);
Count_Divisors(M, B, divB);
Solution(N, A, divB);
Solution(M, B, divA);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 1e6 + 10;
constexpr int MOD = 1e9 + 7;
long long n, k, q, val, phi[N], ans, c[N], cnt[N], fact[N];
long long mypow(long long a, long long b) {
return b ? (mypow(a * a % MOD, b >> 1) * (b & 1 ? a : 1)) % MOD : 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> q;
fact[0] = 1;
for (int i = 1; i <= 1e6; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
phi[i] += i;
for (int j = i + i; j <= 1e6; j += i) phi[j] -= phi[i];
}
for (int i = k; i <= 3e5; i++)
c[i] = (fact[i] * mypow(fact[k] * fact[i - k] % MOD, MOD - 2)) % MOD;
for (int i = 0; i < n + q; i++) {
cin >> val;
for (int j = 1; j * j <= val; j++) {
if (val % j == 0) {
ans = (ans + (c[cnt[j] + 1] - c[cnt[j]]) * phi[j]) % MOD;
cnt[j]++;
if (j * j != val) {
ans = (ans + (c[cnt[val / j] + 1] - c[cnt[val / j]]) * phi[val / j]) %
MOD;
cnt[val / j]++;
}
}
}
if (ans < 0) ans += MOD;
if (i >= n) cout << ans << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n;
int ans = -100000000;
for (int i = 0; i < n; i++) {
cin >> x;
if (x < 0) {
ans = max(ans, x);
} else {
int y = sqrt(x);
if (y * y != x) ans = max(ans, x);
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100001];
int bit[100001];
vector<int> poss[100001];
void update(int idx, int val) {
while (idx < 100001) {
bit[idx] += val;
idx += (idx & (-idx));
}
}
int query(int idx) {
int sum = 0;
while (idx > 0) {
sum += bit[idx];
idx -= (idx & (-idx));
}
return sum;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
poss[a[i]].push_back(i);
update(i, 1);
}
int curr = 0;
long long int ans = 0;
for (int i = 1; i < 100001; i++) {
if (poss[i].empty()) continue;
int ind =
lower_bound(poss[i].begin(), poss[i].end(), curr) - poss[i].begin();
if (ind == 0) {
ans += (query(poss[i].back()) - query(curr));
curr = poss[i].back();
} else {
ans += (query(n) - query(curr));
ind--;
ans += query(poss[i][ind]);
curr = poss[i][ind];
}
for (auto it : poss[i]) update(it, -1);
}
printf("%lld", ans);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.