solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1004006;
const int M = 1000006;
const long long oo = 1.5e18;
long long vet[N];
int sz;
long long sq(long long n) {
long long ans = max((long long)sqrt((long double)n) - 2, 1LL);
while ((ans + 1) * (ans + 1) <= n) ans++;
return ans;
}
long long is_square(long long n) {
long long x = sq(n);
return x * x == n;
}
long long solve(long long n) {
long long ans = n - sq(n);
ans -= int(upper_bound(vet, vet + sz, n) - vet);
return ans;
}
int main() {
for (int i = 2; i < M; i++) {
long long b = 1LL * i * i * i, lim = oo / i;
while (1) {
if (!is_square(b)) vet[sz++] = b;
if (b > lim) break;
b *= i;
}
}
sort(vet, vet + sz);
sz = int(unique(vet, vet + sz) - vet);
int t;
long long n;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%lld", &n);
printf("%lld\n", solve(n));
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j;
unsigned long long h1[2], h2[2], e[2] = {1000000007, 1000000009}, p[2];
string s, t;
int main() {
ios::sync_with_stdio(false);
;
cin >> n >> s >> t;
n--;
for (i = 0; i < n; i++) {
if (s[i] == 'W')
s[i] = 'E';
else if (s[i] == 'S')
s[i] = 'N';
else if (s[i] == 'E')
s[i] = 'W';
else if (s[i] == 'N')
s[i] = 'S';
}
p[0] = p[1] = 1;
for (i = n - 1; ~i; i--) {
for (j = 0; j <= 1; j++) {
h1[j] = h1[j] * e[j] + t[i];
h2[j] = h2[j] + p[j] * s[i];
p[j] *= e[j];
}
if (h1[1] == h2[1] && h1[0] == h2[0]) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 2000;
int n, m;
int a[maxN][maxN];
int used[maxN][maxN];
bool visited[maxN][maxN];
bool valid(int x, int y) { return 0 <= x && x < n && 0 <= y && y < m; }
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
void dfs(int x, int y, int color) {
if (used[x][y]) {
return;
}
used[x][y] = color;
for (int i = 0; i < 4; ++i) {
if (valid(x + dx[i], y + dy[i]) && a[x + dx[i]][y + dy[i]] == 1) {
dfs(x + dx[i], y + dy[i], color);
}
}
}
map<int, int> rays;
void calculateRays() {
const int side = 2;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (visited[i][j] || a[i][j] == 0) {
continue;
}
int ones = 0, zeroes = 0;
bool seen = false;
for (int x = -side; x <= side; ++x) {
for (int y = -side; y <= side; ++y) {
if (valid(i + x, j + y)) {
if (a[i + x][j + y] == 1) {
++ones;
} else {
++zeroes;
}
if (visited[i + x][j + y]) {
seen = true;
}
}
}
}
if (ones == 9) {
++rays[used[i][j]];
for (int x = -side; x <= side; ++x) {
for (int y = -side; y <= side; ++y) {
if (valid(i + x, j + y)) {
visited[i + x][j + y] = true;
}
}
}
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
int colors = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 1 && !used[i][j]) {
++colors;
dfs(i, j, colors);
}
}
}
calculateRays();
printf("%d\n", colors);
vector<int> cnt;
for (map<int, int>::iterator it = rays.begin(); it != rays.end(); ++it) {
cnt.push_back(it->second);
}
sort(cnt.begin(), cnt.end());
for (int i = 0; i < cnt.size(); ++i) {
printf("%d ", cnt[i]);
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 3e5 + 5;
int nxt[nax][20];
int reach[20];
int main() {
int n, q;
cin >> n >> q;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
for (int bit = 0; bit < 19; bit++) reach[bit] = n;
for (int i = n - 1; i >= 0; i--) {
for (int bit = 0; bit < 19; bit++) {
nxt[i][bit] = n;
}
for (int bit = 0; bit < 19; bit++) {
if (arr[i] & (1 << bit)) {
nxt[i][bit] = min(nxt[i][bit], reach[bit]);
if (reach[bit] < n) {
for (int j = 0; j < 19; j++) {
nxt[i][j] = min(nxt[i][j], nxt[reach[bit]][j]);
}
}
reach[bit] = i;
}
}
}
while (q--) {
int x, y;
cin >> x >> y;
x--;
y--;
bool res = false;
for (int bit = 0; bit < 19; bit++) {
if (arr[y] & (1 << bit)) {
if (nxt[x][bit] <= y) {
res = true;
break;
}
}
}
(res ? cout << "Shi\n" : cout << "Fou\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[10000 + 5];
int main() {
int n, k;
cin >> n >> k;
for (int i = (1), _b = (n); i <= _b; i++) a[i] = 1;
a[n] = 0;
int lim = n - 2;
if (n == 2) {
for (int i = (1), _b = (k); i <= _b; i++) printf("2 2\n");
return 0;
}
if (n == 1) {
for (int i = (1), _b = (k); i <= _b; i++) puts("1");
return 0;
}
for (int i = (1), _b = (k); i <= _b; i++) {
bool check = false;
for (int j = (1), _b = (lim); j <= _b; j++) {
if (a[j] * 2 < n - j) {
a[j] *= 2;
printf("%d ", j);
} else {
check = true;
int tmp = n - j - a[j];
printf("%d ", n - tmp);
a[j] = n - j;
}
}
for (int j = (lim + 1), _b = (n - 1); j <= _b; j++) printf("%d ", n);
printf("%d\n", n);
lim--;
lim = max(1, lim);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[4], b[4], x[4], y[4];
pair<int, int> rot(pair<int, int> cur, int a, int b) {
int difx = cur.first - a;
int dify = cur.second - b;
swap(difx, dify);
difx *= -1;
return make_pair(a + difx, b + dify);
}
long long dist(int a, int b, int c, int d) {
return (a - c) * (a - c) + (b - d) * (b - d);
}
bool square(vector<pair<int, int> > g) {
sort(g.begin(), g.end());
int m = unique(g.begin(), g.end()) - g.begin();
if (m != 4) return 0;
swap(g[3], g[2]);
long long s = -1;
for (int i = 0; i < 4; ++i) {
long long r = dist(g[i].first, g[i].second, g[(i + 1) % 4].first,
g[(i + 1) % 4].second);
if (r == 0) return 0;
if (s == -1) s = r;
if (s != r) return 0;
}
swap(g[2], g[3]);
return dist(g[0].first, g[0].second, g[3].first, g[3].second) &&
dist(g[0].first, g[0].second, g[3].first, g[3].second) ==
dist(g[1].first, g[1].second, g[2].first, g[2].second);
}
int main() {
cin >> n;
while (n--) {
for (int i = 0; i < 4; ++i) cin >> x[i] >> y[i] >> a[i] >> b[i];
vector<pair<int, int> > v[4];
int res = 99;
for (int i = 0; i < 4; ++i) {
v[i].push_back(make_pair(x[i], y[i]));
for (int j = 0; j < 3; ++j) v[i].push_back(rot(v[i].back(), a[i], b[i]));
}
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
for (int k = 0; k < 4; ++k) {
for (int l = 0; l < 4; ++l) {
vector<pair<int, int> > g;
g.push_back(v[0][i]);
g.push_back(v[1][j]);
g.push_back(v[2][k]);
g.push_back(v[3][l]);
if (square(g)) res = min(res, i + j + k + l);
}
}
}
}
if (res == 99) res = -1;
cout << res << endl;
}
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
#pragma GCC optimize("O4")
using namespace std;
int ans = 0;
vector<int> g[300005];
int arr[300005];
bool used[300005];
int n;
int k1 = 0, k2 = 0;
pair<int, int> dfs(int v) {
used[v] = 1;
pair<int, int> ret;
for (auto &to : g[v]) {
if (!used[to]) {
pair<int, int> t = dfs(to);
ans += ((!t.first || !t.second) && (!(k1 - t.first) || !(k2 - t.second)));
ret.first += t.first, ret.second += t.second;
}
}
ret.first += arr[v] == 1;
ret.second += arr[v] == 2;
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
k1 += arr[i] == 1;
k2 += arr[i] == 2;
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tos(T a) {
stringstream ss;
string ret;
ss << a;
ss >> ret;
return ret;
}
void read(int &_a) { int temp = scanf("%d", &_a); }
void read(int &_a, int &_b) { int temp = scanf("%d %d", &_a, &_b); }
void read(int &_a, int &_b, int &_c) {
int temp = scanf("%d %d %d", &_a, &_b, &_c);
}
const int SZ = 2e5 + 7;
int A[SZ], N;
int main() {
int T;
read(T);
while (T--) {
read(N);
for (int(x) = (0); (x) < (N); (x)++) read(A[x]);
int ans, tp;
ans = 0;
tp = 0;
for (int x = N - 2; x >= 0; x--) {
if (A[x] == A[x + 1]) continue;
if (!tp) {
if (A[x] < A[x + 1]) tp = 1;
} else {
if (A[x] > A[x + 1]) ans = x + 1;
}
if (ans) break;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 105;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
void vecdisp(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
}
void arrdisp(long long a[], long long n) {
for (long long i = 0; i < n; i++) cout << a[i] << " ";
}
void sarrdisp(string s[], long long n) {
for (long long i = 0; i < n; i++) cout << s[i] << "\n";
}
void twodarrdisp(long long *a, long long r, long long c) {
for (long long i = 0; i < r; i++) {
for (long long j = 0; j < c; j++) cout << (*((a + i * c) + j)) << " ";
cout << "\n";
}
}
void setdisp(set<long long> s) {
for (auto it = s.begin(); it != s.end(); ++it) cout << " " << *it;
}
long long nod(long long a) {
long long c = 0;
set<long long> s;
while (a > 0) {
++c;
s.insert(a % 10);
a /= 10;
}
if (s.size() == c)
return 1;
else
return 0;
}
long long sod(long long a) {
long long c = 0;
while (a > 0) {
c += a % 10;
a /= 10;
}
return c;
}
bool isComposite(long long n) {
if (n <= 1) return false;
if (n <= 3) return false;
if (n % 2 == 0 || n % 3 == 0) return true;
for (long long i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) return true;
}
return false;
}
long long countDivisors(long long n) {
long long cnt = 0;
for (long long i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)
cnt++;
else
cnt += 2;
}
}
return cnt;
}
long long isPalindrome(string s) {
long long l = s.size();
long long flag = 0;
for (long long i = 0; i < l; i++) {
if (s[i] != s[l - i - 1]) {
flag = 1;
break;
}
}
if (flag)
return 0;
else
return 1;
}
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (a[0] + k >= a[n - 1] - k)
cout << (a[0] + k) << "\n";
else
cout << -1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 0;
if (!t) cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int k;
cin >> s >> k;
int len = s.length();
set<char> sa;
for (int i = 0; i < len; i++) {
sa.insert(s[i]);
}
if (len < k) {
cout << "impossible";
} else {
int size = sa.size();
if (size >= k) {
cout << "0";
} else {
cout << k - size;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
void Print() { cout << endl; }
template <typename T1, typename... T>
void Print(const T1 &t1, const T &...t) {
cout << t1 << " ";
Print(t...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class Iterator>
ostream &output_cantainer(ostream &os, Iterator first, Iterator last,
bool space = true) {
if (space) {
for (Iterator it = first; it != last; it++) {
os << (*it) << ' ';
}
os << endl;
} else
for (Iterator it = first; it != last; it++) {
os << (*it) << endl;
}
return os;
}
const int N = 2e5 + 4;
int a[N], par[N], dep[N];
LL v[N << 2];
int n, nxt, s[N], e[N];
vector<int> ed[N];
void update(int id, int l, int r, int x, int y, int val) {
if (l > y || r < x) return;
if (x <= l && r <= y) {
v[id] += val;
return;
}
int m = (l + r) >> 1;
update(id << 1, l, m, x, y, val);
update(id << 1 | 1, m + 1, r, x, y, val);
}
LL query(int id, int l, int r, int x) {
if (l == r) return v[id];
int m = (l + r) >> 1;
if (x <= m) return v[id] + query(id << 1, l, m, x);
return v[id] + query(id << 1 | 1, m + 1, r, x);
}
void dfs(int x) {
s[x] = nxt + 1;
for (int to : ed[x]) {
if (par[x] == to) continue;
dep[to] = dep[x] + 1;
par[to] = x;
dfs(to);
}
e[x] = ++nxt;
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 0; i < n - 1; i++) {
int s, t;
scanf("%d%d", &s, &t);
ed[s].push_back(t);
ed[t].push_back(s);
}
dfs(1);
while (m--) {
int op;
scanf("%d", &op);
if (op == 1) {
int x, y;
scanf("%d%d", &x, &y);
update(1, 1, n, s[x], e[x], (dep[x] & 1) ? -y : y);
} else {
int x;
scanf("%d", &x);
LL val = query(1, 1, n, e[x]);
printf("%lld\n", (dep[x] & 1) ? (a[x] - val) : (a[x] + val));
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2200000, mod = 1000000007;
int n, k, ans = 0, f[maxn] = {}, s[maxn] = {};
int fact[maxn] = {}, invfact[maxn] = {};
int powmod(int a, int b, int p) {
int ans = (a != 0);
if (b == 0) return ans % p;
for (; b; b >>= 1) {
if (b & 1) ans = (1LL * ans * a) % p;
a = (1LL * a * a) % p;
}
return ans % p;
}
int getinv(int x) { return powmod(x, mod - 2, mod); }
int main() {
scanf("%d%d", &n, &k);
fact[0] = invfact[0] = 1;
for (int i = 1; i < maxn; i++) fact[i] = (1LL * fact[i - 1] * i) % mod;
invfact[maxn - 1] = getinv(fact[maxn - 1]);
for (int i = maxn - 2; i >= 1; i--)
invfact[i] = (1LL * invfact[i + 1] * (i + 1)) % mod;
if (n <= k - 1) return printf("0"), 0;
f[0] = s[0] = 1;
for (int i = 1; i <= n; i++) {
if (i - k - 1 >= 0)
f[i] = (1LL * fact[i - 1] * (s[i - 1] - s[i - k - 1] + mod) % mod) % mod;
else
f[i] = (1LL * fact[i - 1] * s[i - 1]) % mod;
s[i] = (s[i - 1] + (1LL * f[i] * invfact[i]) % mod) % mod;
}
ans = fact[n];
for (int i = 1; i <= n; i++)
ans = (ans -
((1LL * f[i - 1] * fact[n - 1]) % mod * 1LL * invfact[i - 1]) % mod +
mod) %
mod;
printf("%d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int a[N][N], n, i, j, x, fl;
vector<int> ans;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
fl = 0;
for (j = 1; j <= n; j++) {
scanf("%d", &x);
if ((x == 1) || (x == 3)) {
fl = 1;
}
}
if (!fl) {
ans.push_back(i);
}
}
printf("%d\n", (int(ans.size())));
for (i = 0; i < (int(ans.size())); i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long n, len, girl, boy, x;
set<long long> st;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
bool g = 0, b = 0;
cin >> n >> len >> girl >> boy;
for (int i = 0; i < n; ++i) cin >> x, st.insert(x);
for (auto it : st)
b |= (st.find(it + boy) != st.end()), g |= (st.find(it + girl) != st.end());
long long small = *st.begin();
if (g && b)
cout << 0;
else if (b) {
if (small + girl <= len)
cout << "1\n" << small + girl;
else
cout << "2\n0 " << girl;
} else if (g) {
if (small + boy <= len)
cout << "1\n" << small + boy;
else
cout << "2\n0 " << boy;
} else {
set<long long> bx, gx;
for (auto it : st)
bx.insert(it + boy), bx.insert(it - boy), gx.insert(it + girl),
gx.insert(it - girl);
for (auto it : bx)
if (it >= 0 && it <= len && gx.find(it) != gx.end())
return cout << "1\n" << it, 0;
if (small + boy <= len && small + girl <= len)
cout << "2\n" << small + boy << ' ' << small + girl;
else
cout << "3\n0 " << boy << ' ' << girl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int palindrome(string s)
{
string c=s;
reverse(s.begin(),s.end());
if(strcmp(c.c_str(), s.c_str()))
{
return 0;
}else{
return 1;
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t=1;
int n;
string s;
cin>>t;
for(int z=0;z<t;z++)
{
cin>>n;
cin>>s;
int x = count(s.begin(),s.end(),'0');
if(palindrome(s))
{
if(s.length()%2==1 && s[s.length()/2]=='0' && x>1)
{
cout<<"ALICE\n";
}else{
cout<<"BOB\n";
}
}else{
if(x%2==1)
{
cout<<"ALICE\n";
}else{
if(s.length()%2==1 && s[s.length()/2]=='0' && x==2)
{
cout<<"DRAW\n";
}else{
cout<<"ALICE\n";
}
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long N = 300005;
int n, q, m;
set<pair<int, int> > s;
pair<int, int> v[N];
bool ok(int x, int y) {
for (int i = 1; i < m; ++i) {
int x1, y1;
tie(x1, y1) = v[i];
if (x1 != x && y1 != x && x1 != y && y1 != y) {
return false;
}
}
return true;
}
void solve() {
cin >> n >> m;
int x, y;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
v[i] = {x, y};
}
for (auto x : {v[0].first, v[0].second}) {
if (ok(x, -1)) {
cout << "YES\n";
return;
}
for (int i = 1; i < m; ++i) {
int x1, y1;
tie(x1, y1) = v[i];
if (x != x1 && x != y1) {
if (ok(x, x1) || ok(x, y1)) {
cout << "YES\n";
return;
}
break;
}
}
}
cout << "NO\n";
}
int main(int argc, char* argv[]) {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int m;
cin >> m;
int mx = 0;
vector<int> a(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
mx = max(mx, a[i]);
}
int ans_mn = mx;
int ans_mx = mx + m;
int sum = 0;
for (int i = 0; i < n; i++) {
sum += mx - a[i];
}
if (m > sum) {
m -= sum;
int up = m / n;
ans_mn += up;
m -= up * n;
if (m > 0) ans_mn++;
}
cout << ans_mn << " " << ans_mx << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
char o, f = 1;
while (o = getchar(), o < 48)
if (o == 45) f = -f;
do x = (x << 3) + (x << 1) + (o ^ 48);
while (o = getchar(), o > 47);
return x * f;
}
const int maxn = 1e5 + 5;
long long n, m, sx, sy, fx, fy, x[maxn], y[maxn];
long long ans, vis[maxn], mp[maxn], dis[maxn];
struct point {
long long x, y, id;
} p[maxn], t[maxn];
bool cmp1(point a, point b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
bool cmp2(point a, point b) {
if (a.y != b.y) return a.y < b.y;
return a.x < b.x;
}
struct node {
long long id, dis;
bool operator<(const node a) const { return dis > a.dis; }
};
long long calc(long long a, long long b, long long c, long long d) {
return min(abs(a - c), abs(b - d));
}
void dij() {
priority_queue<node> q;
int d = 0;
for (int i = 1; i <= m; i++) {
dis[i] = min(abs(p[i].x - sx), abs(p[i].y - sy));
q.push({i, dis[i]});
}
while (!q.empty()) {
node e1 = q.top();
q.pop();
if (vis[e1.id]) continue;
vis[e1.id] = 1;
int pos = e1.id - 1;
if (pos != 0) {
if (dis[pos] >
dis[pos + 1] + calc(p[pos].x, p[pos].y, p[pos + 1].x, p[pos + 1].y)) {
dis[pos] =
dis[pos + 1] + calc(p[pos].x, p[pos].y, p[pos + 1].x, p[pos + 1].y);
q.push({pos, dis[pos]});
}
}
pos = e1.id;
if (pos != m) {
if (dis[pos + 1] >
dis[pos] + calc(p[pos].x, p[pos].y, p[pos + 1].x, p[pos + 1].y)) {
dis[pos + 1] =
dis[pos] + calc(p[pos].x, p[pos].y, p[pos + 1].x, p[pos + 1].y);
q.push({pos + 1, dis[pos + 1]});
}
}
pos = mp[e1.id] - 1;
if (pos != 0) {
if (dis[t[pos].id] >
dis[t[pos + 1].id] +
calc(t[pos].x, t[pos].y, t[pos + 1].x, t[pos + 1].y)) {
dis[t[pos].id] = dis[t[pos + 1].id] +
calc(t[pos].x, t[pos].y, t[pos + 1].x, t[pos + 1].y);
q.push({t[pos].id, dis[t[pos].id]});
}
}
pos = mp[e1.id];
if (pos != m) {
if (dis[t[pos + 1].id] >
dis[t[pos].id] +
calc(t[pos].x, t[pos].y, t[pos + 1].x, t[pos + 1].y)) {
dis[t[pos + 1].id] = dis[t[pos].id] + calc(t[pos].x, t[pos].y,
t[pos + 1].x, t[pos + 1].y);
q.push({t[pos + 1].id, dis[t[pos + 1].id]});
}
}
}
}
int main() {
n = rd();
m = rd();
p[0].x = -1e9;
p[0].y = -1e9;
sx = rd();
sy = rd();
fx = rd();
fy = rd();
for (int i = 1; i <= m; i++) {
p[i].x = rd();
p[i].y = rd();
}
ans = abs(sx - fx) + abs(sy - fy);
sort(p + 1, p + m + 1, cmp1);
for (int i = 1; i <= m; i++) {
p[i].id = i;
t[i] = p[i];
}
sort(t + 1, t + m + 1, cmp2);
for (int i = 1; i <= m; i++) mp[t[i].id] = i;
dij();
for (int i = 1; i <= m; i++)
ans = min(ans, dis[i] + abs(p[i].x - fx) + abs(p[i].y - fy));
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const long long LINF = 1e18;
const int MOD = 1e9 + 7;
const long double EPS = 1e-9;
int n, q;
int diff[2];
int nres[1000000];
int main() {
ios_base::sync_with_stdio(false);
scanf("%d%d", &n, &q);
for (int i = 0; i < q; i++) {
int t;
scanf("%d", &t);
if (t == 1) {
int d;
scanf("%d", &d);
diff[0] = (n + d + diff[0]) % n;
diff[1] = (n + d + diff[1]) % n;
} else {
if (diff[0] & 1) {
diff[0] = (n - 1 + diff[0]) % n;
diff[1] = (n + 1 + diff[1]) % n;
} else {
diff[0] = (n + 1 + diff[0]) % n;
diff[1] = (n - 1 + diff[1]) % n;
}
}
}
for (int i = 0; i < n; i++) {
int xpos = (i + diff[i & 1]) % n;
nres[xpos] = i + 1;
}
for (int i = 0; i < n; i++) {
cout << nres[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long dp[55][55][55];
long long C[55][55];
int a[55];
int main() {
int N, p;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", a + i);
scanf("%d", &p);
memset(dp, 0, sizeof(dp));
dp[0][0][0] = 1;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k <= p; k++) {
dp[i + 1][j][k] += dp[i][j][k];
int nxt = k + a[i];
if (nxt > p) continue;
dp[i + 1][j + 1][nxt] += dp[i][j][k];
}
}
}
memset(C, 0, sizeof(C));
for (int i = 1; i <= N; i++) {
C[i][0] = 1;
C[i][i] = 1;
}
for (int i = 2; i <= N; i++) {
for (int j = 1; j < i; j++) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
double ans = 0;
for (int i = 1; i <= p; i++) {
for (int j = 1; j <= N; j++) {
ans += (double)dp[N][j][i] / C[N][j];
}
}
printf("%.9f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <class X, class Y>
bool umin(X &x, const Y &y) {
X eps = 1e-9;
if (x > y + eps) {
x = y;
return true;
} else
return false;
}
template <class X, class Y>
bool umax(X &x, const Y &y) {
X eps = 1e-9;
if (x + eps < y) {
x = y;
return true;
} else
return false;
}
const int d4i[4] = {-1, 0, 1, 0}, d4j[4] = {0, 1, 0, -1};
const int d8i[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
d8j[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const ll mxN = 2e5 + 5, MOD = 1e9 + 7, oo = 1e18, base = 311;
void process() {
int n;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
s1 = "#" + s1, s2 = "#" + s2;
int answer = 0;
for (int i = 1; i < n; i++) {
if (s1[i] == s2[i + 1] && s1[i + 1] == s2[i] && s1[i] != s1[i + 1]) {
swap(s1[i], s1[i + 1]);
answer++;
}
}
for (int i = 1; i <= n; i++) answer += (s1[i] != s2[i]);
cout << answer;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
process();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
long long score, sum = 0;
cin >> n;
vector<int> ara(n);
for (int i = 0; i < n; i++) {
cin >> ara[i];
sum += ara[i];
}
sort(ara.begin(), ara.end());
reverse(ara.begin(), ara.end());
score = sum;
for (int i = n - 1; i >= 0; i--) {
sum -= ara[i];
score += (ara[i] + sum);
}
score -= ara[0];
cout << score << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular& operator-=(const Modular& other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular& operator+=(const U& other) {
return *this += Modular(other);
}
template <typename U>
Modular& operator-=(const U& other) {
return *this -= Modular(other);
}
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type&
operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) {
return *this *= Modular(inverse(other.value, mod()));
}
template <typename U>
friend const Modular<U>& abs(const Modular<U>& v) {
return v;
}
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
constexpr int md = 998244353;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] != a[(i + 1) % n]) {
++cnt;
}
}
if (cnt == 0) {
cout << 0 << '\n';
return 0;
}
vector<Mint> fact(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i;
}
vector<Mint> inv_fact(n + 1);
for (int i = 0; i <= n; i++) {
inv_fact[i] = 1 / fact[i];
}
auto C = [&](int N, int K) {
if (K < 0 || K > N) {
return Mint(0);
}
return fact[N] * inv_fact[K] * inv_fact[N - K];
};
Mint ans = 0;
for (int s = 1; s <= cnt; s++) {
Mint cur = C(cnt, s);
if (s % 2 == 1) {
cur *= power(Mint(2), s - 1);
} else {
cur *= (power(Mint(2), s) - C(s, s / 2)) / 2;
}
cur *= power(Mint(k - 2), cnt - s);
ans += cur;
}
ans *= power(Mint(k), n - cnt);
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 3;
const long long INFF = (long long)1e18;
int cnt[N];
bool ck[N];
int main() {
for (int i = 2; i < N; i++) {
if (ck[i]) continue;
for (int j = i; j < N; j += i) ck[j] = true;
cnt[i]++;
if (i <= 1000) {
cnt[i * i]--;
}
}
cnt[1] = 1;
for (int i = 1; i < N; i++) cnt[i] += cnt[i - 1];
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
printf("%d\n", cnt[n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000 * 1000 * 1000;
const double EPS = 1e-9;
const int MAXN = 101;
int a[MAXN][MAXN];
int csum[MAXN], rsum[MAXN];
bool cans[MAXN], rans[MAXN];
int main() {
int N, M;
scanf("%d%d", &N, &M);
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j) {
scanf("%d", &a[i][j]);
csum[j] += a[i][j];
rsum[i] += a[i][j];
}
for (;;) {
bool check = false;
for (int i = 0; i < N; ++i)
if (rsum[i] < 0) {
rsum[i] *= -1;
for (int j = 0; j < M; ++j) {
csum[j] -= 2 * a[i][j];
a[i][j] *= -1;
}
check = true;
rans[i] ^= true;
break;
}
if (check) continue;
for (int j = 0; j < M; ++j)
if (csum[j] < 0) {
csum[j] *= -1;
for (int i = 0; i < N; ++i) {
rsum[i] -= 2 * a[i][j];
a[i][j] *= -1;
}
check = true;
cans[j] ^= true;
break;
}
if (check) continue;
break;
}
int cntr = 0;
for (int i = 0; i < N; ++i)
if (rans[i]) {
++cntr;
}
printf("%d ", cntr);
for (int i = 0; i < N; ++i)
if (rans[i]) {
printf("%d ", i + 1);
}
puts("");
int cntc = 0;
for (int j = 0; j < M; ++j)
if (cans[j]) {
++cntc;
}
printf("%d ", cntc);
for (int j = 0; j < M; ++j)
if (cans[j]) {
printf("%d ", j + 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, x, y, z, m, Q, mx, used[200500], w[200500], W[200500], start;
vector<int> g[200500], verts, leafs, ned;
set<int> f[200500];
vector<pair<pair<int, int>, int> > ans;
void dfs(int v, int p = -1) {
w[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to != p) {
dfs(to, v);
w[v] += w[to];
}
}
if (w[v] == n / 2 && n % 2 == 0) {
x = v, y = p;
}
if (w[v] > mx && w[v] <= n / 2) {
mx = w[v];
z = p;
}
if (n - w[v] > mx && n - w[v] <= n / 2) {
mx = n - w[v];
z = v;
}
}
void dfs_prepare(int v, int p) {
verts.push_back(v);
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to != p) {
f[v].insert(to);
f[to].insert(v);
dfs_prepare(to, v);
}
}
}
void dfs_mag(int v, int p = -1) {
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to != p) {
f[v].insert(to);
f[to].insert(v);
verts.push_back(v);
dfs_prepare(to, v);
for (int j = 0; j < verts.size(); j++) {
if (f[verts[j]].size() == 1) leafs.push_back(verts[j]);
}
int cur = v, prev = -1;
while (leafs.size() != 2) {
for (auto itr = f[cur].begin(); itr != f[cur].end(); itr++) {
int To = *itr;
if (To != prev) {
if (f[To].size() > 2) {
int t = leafs.back();
leafs.pop_back();
f[cur].erase(To);
f[To].erase(cur);
f[cur].insert(t);
f[t].insert(cur);
ans.push_back(make_pair(make_pair(cur, To), t));
prev = cur;
cur = t;
break;
} else {
prev = cur;
cur = To;
break;
}
}
}
}
cur = v;
ned.push_back(v);
cur = (*(f[cur].begin()));
ned.push_back(cur);
prev = v;
while (f[cur].size() != 1) {
for (auto itr = f[cur].begin(); itr != f[cur].end(); itr++) {
if ((*itr) != prev) {
ned.push_back(*itr);
prev = cur;
cur = *itr;
break;
}
}
}
int siz = ned.size();
for (int j = siz - 3; j >= 0; j--) {
ans.push_back(make_pair(make_pair(ned[j], ned[j + 1]), ned.back()));
}
for (int j = 0; j < verts.size(); j++) {
f[verts[j]].clear();
}
ned.clear();
leafs.clear();
verts.clear();
}
}
}
int main() {
cin >> n;
for (i = 0; i < n - 1; i++) {
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
mx = 0;
x = -1, y = -1;
dfs(1);
if (x != -1) {
dfs_mag(y, x);
dfs_mag(x, y);
} else
dfs_mag(z, -1);
cout << ans.size() << endl;
for (i = 0; i < ans.size(); i++) {
printf("%d %d %d\n", ans[i].first.first, ans[i].first.second,
ans[i].second);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10009;
int n;
vector<pair<int, int> > vs[N], hs[N];
int f[N];
vector<int> d[N];
void upd(int pos, int x) {
for (; pos < N; pos |= pos + 1) f[pos] += x;
}
int get(int pos) {
int res = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) res += f[pos];
return res;
}
int get(int l, int r) { return get(r) - get(l - 1); }
const int D = 5001;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 += D, y1 += D, x2 += D, y2 += D;
if (y1 == y2)
hs[y1].push_back(make_pair(min(x1, x2), max(x1, x2)));
else
vs[x1].push_back(make_pair(min(y1, y2), max(y1, y2)));
}
long long res = 0;
for (int y = 1; y < N; ++y)
for (auto s : hs[y]) {
for (int i = 0; i < N; ++i) d[i].clear();
memset(f, 0, sizeof f);
int l = s.first, r = s.second;
for (int x = l; x <= r; ++x)
for (auto s2 : vs[x])
if (s2.first <= y && s2.second > y) {
d[s2.second].push_back(x);
upd(x, 1);
}
for (int y2 = y + 1; y2 < N; ++y2) {
for (auto s2 : hs[y2]) {
int cur = get(s2.first, s2.second);
res += cur * (cur - 1) / 2;
}
for (auto x : d[y2]) upd(x, -1);
}
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
inline void in(int &MAGNUS) { scanf("%d", &MAGNUS); }
inline void out(int MAGNUS) { printf("%d\n", MAGNUS); }
inline void in(int &MAGNUS, int &CLAR) { scanf("%d%d", &MAGNUS, &CLAR); }
inline void out(int MAGNUS, int CLAR) { printf("%d %d\n", MAGNUS, CLAR); }
inline void inl(long long &LIV) { scanf("%lld", &LIV); }
inline void inl(long long &LIV, long long &MART) {
scanf("%lld%lld", &LIV, &MART);
}
inline void outl(long long LIV) { printf("%lld\n", LIV); }
inline void outl(long long LIV, long long MART) {
printf("%lld %lld\n", LIV, MART);
}
using namespace std;
int L, N;
int many[1000005];
struct point {
int x, y;
} p[255];
struct segment {
point a, b;
segment() {}
segment(point _a, point _b) { a = _a, b = _b; }
pair<int, int> gradient() {
int x1 = a.x, y1 = a.y;
int x2 = b.x, y2 = b.y;
int dx = x2 - x1;
int dy = y2 - y1;
return make_pair(dx, dy);
}
};
bool inLine(segment a, segment b) { return a.gradient() == b.gradient(); }
int main() {
in(L, N);
for (int i = 1; i <= N; i++) in(p[i].x, p[i].y);
memset(many, 0, sizeof(many));
for (int i = 1; i <= N; i++) {
for (int j = i + 1; j <= N; j++) {
pair<int, int> gradient = segment(p[i], p[j]).gradient();
long long dx = gradient.first;
long long dy = gradient.second;
if (dy == 0) continue;
if (dy < 0) dy = -dy, dx = -dx;
long long tmp = (long long)p[i].y * dx;
if (tmp % dy != 0) continue;
long long d = tmp / dy;
long long x = (long long)p[i].x - d;
if (x < 1 || x > L) continue;
int pointsOnLine = 2;
for (int k = j + 1; k <= N; k++) {
int dx2 = p[i].x - p[k].x;
int dy2 = p[i].y - p[k].y;
pointsOnLine += ((long long)dx2 * dy == (long long)dy2 * dx);
}
many[x] = max(many[x], pointsOnLine);
}
}
int ans = 0;
for (int i = 1; i <= L; i++) ans += max(1, many[i]);
out(ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> vec(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
vec[u - 1].push_back(v - 1);
vec[v - 1].push_back(u - 1);
}
int count = 0;
for (int i = 0; i < n; i++) {
if (vec[i].size() == 1) count++;
}
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n, l, r;
cin >> n >> l >> r;
int arr[n + 2], a[n + 2], pos[n + 2], ans[n + 2];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
cin >> pos[i];
a[pos[i]] = arr[i];
}
int mx = l - r - 3;
for (int i = 1; i <= n; i++) {
if (mx + 1 > r - a[i]) {
cout << "-1";
return 0;
}
mx = max(mx + 1, l - a[i]);
ans[i] = a[i] + mx;
}
for (int i = 0; i < n; i++) cout << ans[pos[i]] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int QW = 1e5 + 9;
const int mod = 998244353;
const long long inf = 3e9;
vector<pair<int, int> > v;
vector<int> ans;
int i;
int a[QW], n, j;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
v.push_back(make_pair(a[n], n));
ans.push_back(-1);
for (i = n - 1; i >= 1; i--) {
if (a[i] <= v.back().first) {
ans.push_back(-1);
if (a[i] != v.back().first) v.push_back(make_pair(a[i], i));
} else {
for (int in = 0; in < v.size(); in++) {
if (a[i] > v[in].first) {
ans.push_back((v[in].second - i) - 1);
break;
}
}
}
}
for (i = ans.size() - 1; i >= 0; i--) {
cout << ans[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int CN = 4e5 + 5;
const int P = 998244353;
int read() {
int s = 0, ne = 1;
char c = getchar();
while (c < '0' || c > '9') ne = c == '-' ? -1 : 1, c = getchar();
while (c >= '0' && c <= '9') s = (s << 1) + (s << 3) + c - '0', c = getchar();
return s * ne;
}
int qp(int a, int b) {
int r = 1;
while (b) {
if (b & 1) r = 1ll * r * a % P;
a = 1ll * a * a % P;
b >>= 1;
}
return r;
}
class ANTI {
public:
int a, b;
} Q[50];
class SGT {
public:
int tag[CN << 2];
SGT() { memset(tag, 0, sizeof(tag)); }
void pd(int k) {
tag[k << 1] += tag[k], tag[k << 1 | 1] += tag[k], tag[k] = 0;
}
void md(int l, int r, int k, int s, int t) {
if (s <= l && r <= t) return (void)(tag[k]++);
int m = (l + r) >> 1;
if (tag[k]) pd(k);
if (s <= m) md(l, m, k << 1, s, t);
if (m < t) md(m + 1, r, k << 1 | 1, s, t);
}
int qu(int l, int r, int k, int p) {
if (l == r) return tag[k];
int m = (l + r) >> 1;
if (tag[k]) pd(k);
if (p <= m)
return qu(l, m, k << 1, p);
else
return qu(m + 1, r, k << 1 | 1, p);
}
} D;
int n, m, L[CN], R[CN], f[CN][50], cnt[CN];
int fac[CN], ifac[CN];
int C(int n, int m) {
return n < m || n < 0 || m < 0
? 0
: 1ll * fac[n] * (1ll * ifac[m] * ifac[n - m] % P) % P;
}
set<int> T;
int bits(int x) {
int r = 0;
while (x) r += x & 1, x >>= 1;
return r;
}
int si(int l, int r) {
int s = T.size();
return l > r ? 0 : (f[r][s] - f[l - 1][s] + P) % P;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++)
L[i] = read(), R[i] = read(), D.md(1, n, 1, L[i], R[i]);
for (int i = 0; i < m; i++) Q[i].a = read(), Q[i].b = read();
fac[0] = ifac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % P;
ifac[n] = qp(fac[n], P - 2);
for (int i = n - 1; i; i--) ifac[i] = 1ll * (i + 1) * ifac[i + 1] % P;
for (int i = 1; i <= n; i++) cnt[i] = D.qu(1, n, 1, i);
for (int k = 0; k <= (m << 1); k++)
for (int i = 1; i <= n; i++)
f[i][k] = (f[i - 1][k] + C(cnt[i] - k, i - k)) % P;
int ans = 0;
for (int S = 0; S < (1 << m); S++) {
int b = bits(S), k = b & 1 ? -1 : 1, l = 1, r = n;
T.clear();
for (int i = 0; i < m; i++)
if (S & (1 << i))
T.insert(Q[i].a), T.insert(Q[i].b),
l = max(l, max(L[Q[i].a], L[Q[i].b])),
r = min(r, min(R[Q[i].a], R[Q[i].b]));
ans = (((ans + k * si(l, r)) % P) + P) % P;
}
printf("%d", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4005;
int n;
int v[N];
int d[N];
long long p[N];
bool done[N];
vector<int> ans;
int main() {
memset(done, 0, sizeof(done));
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d %d %lld", v + i, d + i, p + i);
}
for (int i = 1; i <= n; ++i) {
if (done[i]) {
continue;
}
ans.emplace_back(i);
int ctr = 0;
for (int j = i + 1; j <= n; ++j) {
if (!done[j]) {
if (ctr == v[i]) {
break;
}
p[j] -= v[i] - ctr;
++ctr;
}
}
long long tot = 0;
for (int j = i + 1; j <= n; ++j) {
if (!done[j]) {
p[j] -= tot;
if (p[j] < 0) {
done[j] = 1;
tot += d[j];
}
}
}
}
cout << ans.size() << endl;
for (int x : ans) {
cout << x << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int cont = 0, k = 0, res = 0;
for (int i = 0; i < s.size(); i++) {
if (i == 0) {
cont = abs('a' - s[i]);
if (cont == 25) {
res += 1;
} else {
k = 26 - abs('a' - s[i]);
res += min(cont, k);
k = 1000000000, cont = 1000000000;
}
} else {
cont = abs(s[i] - s[i - 1]);
if (cont > 12) {
k = 26 - abs(s[i] - s[i - 1]);
}
res += min(cont, k);
k = 1000000000, cont = 1000000000;
}
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N5 = 1e5 + 15;
int n, m, sz, y[N5], x[N5], t[N5 << 2], a[N5], b[N5], type;
void upd(int v, int tl, int tr, int l, int r, int x) {
if (l <= tl && tr <= r) {
t[v] = x;
return;
}
int tm = (tl + tr) >> 1;
if (l <= tm) upd(v << 1, tl, tm, l, r, x);
if (r > tm) upd(v << 1 | 1, tm + 1, tr, l, r, x);
}
int get(int v, int tl, int tr, int x) {
if (tl == tr) return t[v];
int tm = (tl + tr) >> 1;
if (x <= tm)
return max(t[v], get(v << 1, tl, tm, x));
else
return max(t[v], get(v << 1 | 1, tm + 1, tr, x));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &type, &x[i]);
if (type == 1) {
scanf("%d%d", &y[i], &sz);
upd(1, 1, n, y[i], y[i] + sz - 1, i);
} else {
int p = x[i];
int ind = get(1, 1, n, p);
printf("%d\n", ind ? a[p + x[ind] - y[ind]] : b[p]);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int em(long long int x, long long int Mod, long long int n) {
if (n == 0)
return 1ll;
else if (n % 2 == 0)
return em((x % Mod * x % Mod) % Mod, Mod, n / 2) % Mod;
else
return (x % Mod * em((x % Mod * x % Mod) % Mod, Mod, (n - 1) / 2)) % Mod;
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, i, j, k, l;
cin >> n >> m;
char arr[n + 2][m + 2];
long long int s1[n + 2][m + 2], s2[n + 2][m + 2];
memset((s1), 0, sizeof(s1));
for (long long int i = (long long int)1; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)1; j < (long long int)m + 1; j++) {
cin >> arr[i][j];
if (arr[i][j] == 'X') s1[i][j] = 1;
}
}
for (long long int j = (long long int)1; j < (long long int)m + 1; j++)
s1[1][j] += s1[1][j - 1];
for (long long int j = (long long int)1; j < (long long int)n + 1; j++)
s1[j][1] += s1[j - 1][1];
for (long long int i = (long long int)2; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)2; j < (long long int)m + 1; j++)
s1[i][j] += s1[i - 1][j] + s1[i][j - 1] - s1[i - 1][j - 1];
}
long long int lo = 0, hi = max(n, m) + 1;
long long int ans[n + 2][m + 2], canbe[n + 2][m + 2], dis = -1;
while (lo <= hi) {
long long int mid = (lo + hi) / 2;
memset((s2), 0, sizeof(s2));
memset((canbe), 0, sizeof(canbe));
for (long long int i = (long long int)mid + 1; i < (long long int)n + 1;
i++) {
for (long long int j = (long long int)mid + 1; j < (long long int)m + 1;
j++) {
long long int hx, hy, lx, ly;
if (i + mid > n || j + mid > m) continue;
hx = i + mid;
hy = j + mid;
lx = i - mid;
ly = j - mid;
if (arr[i][j] == 'X' &&
(s1[hx][hy] - s1[hx][ly - 1] - s1[lx - 1][hy] +
s1[lx - 1][ly - 1]) == (hx - lx + 1) * (hy - ly + 1))
canbe[i][j] = s2[i][j] = 1;
}
}
for (long long int j = (long long int)1; j < (long long int)m + 1; j++)
s2[1][j] += s2[1][j - 1];
for (long long int j = (long long int)1; j < (long long int)n + 1; j++)
s2[j][1] += s2[j - 1][1];
for (long long int i = (long long int)2; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)2; j < (long long int)m + 1; j++)
s2[i][j] += s2[i - 1][j] + s2[i][j - 1] - s2[i - 1][j - 1];
}
long long int flag = 1;
for (long long int i = (long long int)1; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)1; j < (long long int)m + 1; j++) {
long long int hx, hy, lx, ly;
hx = min(n, i + mid);
hy = min(m, j + mid);
lx = max(1ll, i - mid);
ly = max(1ll, j - mid);
if (arr[i][j] == 'X' && (s2[hx][hy] - s2[hx][ly - 1] - s2[lx - 1][hy] +
s2[lx - 1][ly - 1]) < 1) {
flag = 0;
break;
}
}
}
if (flag == 0)
hi = mid - 1;
else {
if (mid > dis) {
dis = mid;
for (long long int i = (long long int)1; i < (long long int)n + 1;
i++) {
for (long long int j = (long long int)1; j < (long long int)m + 1;
j++)
ans[i][j] = canbe[i][j];
}
}
lo = mid + 1;
}
}
cout << dis << "\n";
for (long long int i = (long long int)1; i < (long long int)n + 1; i++) {
for (long long int j = (long long int)1; j < (long long int)m + 1; j++) {
if (ans[i][j] == 1)
cout << "X";
else
cout << ".";
}
cout << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int c = 55;
struct rec {
string name;
int a, b, c;
};
int n;
char h;
rec a[c];
char temp[c];
string s[c];
bool operator<(const rec &a, const rec &b) {
if (a.a != b.a) return a.a > b.a;
if (a.b != b.b) return a.b > b.b;
if (a.c != b.c) return a.c > b.c;
return 0;
}
int main() {
int i, j, k1, k2, c1, c2;
scanf("%d", &n);
do h = getchar();
while (h != '\n');
for (i = 1; i <= n; ++i) {
gets(temp);
a[i].name = temp;
}
string t1, t2;
for (i = 1; i <= n * (n - 1) / 2; ++i) {
scanf("%s", temp);
t1 = "";
t2 = "";
for (j = 0; temp[j] != '-'; ++j) t1 += temp[j];
for (j = j + 1; temp[j] > 0; ++j) t2 += temp[j];
for (k1 = 1; k1 <= n; ++k1)
if (a[k1].name == t1) break;
for (k2 = 1; k2 <= n; ++k2)
if (a[k2].name == t2) break;
scanf("%d:%d", &c1, &c2);
do h = getchar();
while (h != '\n' && !feof(stdin));
if (c1 > c2)
a[k1].a += 3;
else if (c1 < c2)
a[k2].a += 3;
else {
a[k1].a++;
a[k2].a++;
}
a[k1].b += c1 - c2;
a[k2].b += c2 - c1;
a[k1].c += c1;
a[k2].c += c2;
}
sort(a + 1, a + n + 1);
for (i = 1; i <= n / 2; ++i) s[i] = a[i].name;
sort(s + 1, s + n / 2 + 1);
for (i = 1; i <= n / 2; ++i) printf("%s\n", s[i].c_str());
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[30];
int n, k;
string str, s1;
char xl[30], mm;
int main() {
cin >> n >> k;
cin >> str;
for (int i = 0; i < n; i++) {
int tmp = str[i] - 'a' + 1;
a[tmp] = 1;
}
int cnt = 0;
for (int i = 0; i <= 29; i++) {
if (a[i] == 1) {
char tmp = i - 1 + 'a';
xl[++cnt] = tmp;
mm = tmp;
}
}
if (k > n) {
cout << str;
for (int i = 1; i <= k - n; i++) cout << xl[1];
cout << endl;
} else {
s1 = str;
for (int i = k - 1; i >= 0; i--) {
if (s1[i] == mm)
s1[i] = xl[1];
else {
int tmp = s1[i] - 'a' + 1;
for (int j = tmp + 1;; j++) {
if (a[j] == 1) {
s1[i] = j + 'a' - 1;
break;
}
}
break;
}
}
for (int i = 0; i < k; i++) cout << s1[i];
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long n, p[long(3000)], s[long(3000)], ans, L[long(3000)], R[long(3000)];
vector<pair<long, long> > res;
int main() {
scanf("%ld", &n);
long x;
for (long i = 1; i <= n; ++i) scanf("%ld", &x), p[i] = x;
for (long i = 1; i <= n; ++i) scanf("%ld", &x), s[x] = i;
while (1) {
long ok = 0;
for (long i = 1; i <= n; ++i)
if (s[p[i]] > i)
L[i] = i;
else
L[i] = L[i - 1];
for (long i = n; i >= 1; --i)
if (s[p[i]] < i)
R[i] = i;
else
R[i] = R[i + 1];
for (long i = 1; i <= n; ++i)
if (s[p[i]] < i && R[L[i]] == i) {
swap(p[i], p[L[i]]);
res.push_back(make_pair(i, L[i]));
ans += abs(i - L[i]);
ok = 1;
}
if (!ok) break;
}
printf("%ld\n%ld\n", ans, long(res.size()));
for (long i = 0; i < res.size(); ++i)
printf("%ld %ld\n", res[i].first, res[i].second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long large = 2000000000000000000LL;
vector<int> per;
int f(int x) { return x == per[x] ? x : per[x] = f(per[x]); }
vector<vector<pair<int, int> > > adj;
int sz = 17;
vector<int> lv;
vector<pair<int, int> > pa;
void dfs(int u, int parent, int lvl, int w) {
lv[u] = lvl;
pa[u] = pair<int, int>(parent, w);
for (int j = 0; j < (int)adj[u].size(); j++) {
int v = adj[u][j].first;
if (v != parent) dfs(v, u, lvl + 1, adj[u][j].second);
}
}
void get(int u, int v, vector<long long> &a) {
if (lv[u] < lv[v]) swap(u, v);
while (lv[u] > lv[v]) {
a[pa[u].second]++;
u = pa[u].first;
}
while (u != v) {
a[pa[u].second]++;
a[pa[v].second]++;
u = pa[u].first;
v = pa[v].first;
}
}
long long rev = (mod + 1) / 2;
void FWT(vector<long long> &a, int sz) {
int n = (1 << sz);
for (int d = 1; d < n; d <<= 1)
for (int m = d << 1, i = 0; i < n; i += m)
for (int j = 0; j < d; j++) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = (x + y) % mod, a[i + j + d] = (x - y + mod) % mod;
}
}
void UFWT(vector<long long> &a, int sz) {
int n = (1 << sz);
for (int d = 1; d < n; d <<= 1)
for (int m = d << 1, i = 0; i < n; i += m)
for (int j = 0; j < d; j++) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = 1LL * (x + y) * rev % mod,
a[i + j + d] = (1LL * (x - y) * rev % mod + mod) % mod;
}
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
adj.assign(n, vector<pair<int, int> >());
per.assign(n, -1);
for (int i = 0; i < n; i++) per[i] = i;
vector<pair<pair<int, int>, int> > e;
int ans = 0;
for (int i = 0; i < m; i++) {
int x, y, w;
cin >> x >> y >> w;
x--;
y--;
ans ^= w;
if (f(x) != f(y)) {
adj[x].push_back(pair<int, int>(y, w));
adj[y].push_back(pair<int, int>(x, w));
per[f(x)] = f(y);
} else {
e.push_back(pair<pair<int, int>, int>(pair<int, int>(x, y), w));
}
}
lv.assign(n, -1);
pa.assign(n, pair<int, int>());
dfs(0, -1, 0, 0);
vector<long long> t;
vector<long long> p;
vector<long long> a(1 << sz, 0);
for (int i = 0; i < (int)e.size(); i++) {
a.assign(1 << sz, 0);
get(e[i].first.first, e[i].first.second, a);
a[e[i].second]++;
vector<long long> b = a;
for (int j = 0; j < (1 << sz); j++)
if (a[j]) b[j] = 1;
FWT(a, sz);
FWT(b, sz);
if (t.size() == 0)
t = a;
else {
for (int j = 0; j < (1 << sz); j++) t[j] = t[j] * a[j] % mod;
}
if (p.size() == 0)
p = b;
else
for (int j = 0; j < (1 << sz); j++) p[j] = p[j] * b[j] % mod;
}
UFWT(t, sz);
UFWT(p, sz);
pair<int, int> f = pair<int, int>(1000000000, 0);
for (int i = 0; i < (1 << sz); i++) {
if (p[i] > 0) {
f = min(f, pair<int, int>(i ^ ans, t[i]));
}
}
cout << f.first << " " << f.second << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long Llinf = LLONG_MAX;
const int Inf = INT_MAX;
const int Maxn = 1e5 + 10;
const int Mod = 1e9 + 7;
char* c = new char[Maxn];
string GetString() {
scanf("%s", c);
return string(c);
}
int n;
int a[Maxn];
long long tp[Maxn];
long long pref[Maxn], suff[Maxn];
long long ans;
void Clear() {
for (int i = 0; i < n; i++) tp[i] = 1ll * a[i];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
Clear();
for (int i = 1; i < n; i++)
if (tp[i - 1] >= tp[i])
pref[i] = tp[i - 1] - tp[i] + 1, tp[i] = tp[i - 1] + 1;
for (int i = n - 2; i >= 0; i--)
if (a[i] <= a[i + 1]) suff[i] = a[i + 1] - a[i] + 1, a[i] = a[i + 1] + 1;
for (int i = 1; i < n; i++) pref[i] = pref[i] + pref[i - 1];
for (int i = n - 2; i >= 0; i--) suff[i] = suff[i] + suff[i + 1];
ans = suff[0];
for (int i = 0; i < n - 1; i++)
ans = min(ans, 1ll * pref[i] + suff[i + 1] + (tp[i] == a[i + 1]));
printf("%I64d\n", min(ans, pref[n - 1]));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> G, H;
vector<int> ord, comp;
vector<bool> V;
struct SCC {
int n, c;
SCC(int n) : n(n) {
G.resize(n);
H.resize(n);
for (int i = 0; i < n; i++) {
G[i].reserve(n);
H[i].reserve(n);
G[i].clear();
H[i].clear();
}
ord.reserve(n);
ord.clear();
};
void add_edge(int u, int v) {
G[u].push_back(v);
H[v].push_back(u);
}
void dfs1(int v) {
V[v] = true;
for (auto& u : G[v])
if (!V[u]) dfs1(u);
ord.push_back(v);
}
void dfs2(int v) {
comp[v] = c;
for (auto& u : H[v])
if (comp[u] == -1) dfs2(u);
}
vector<int> scc() {
V.assign(n, 0);
for (int i = 0; i < n; i++)
if (!V[i]) dfs1(i);
comp.assign(n, -1);
c = 0;
for (int i = 0; i < n; i++) {
int v = ord[n - 1 - i];
if (comp[v] == -1) dfs2(v), c++;
}
return comp;
}
vector<vector<int>> dag() {
set<pair<int, int>> S;
vector<vector<int>> dag(c);
for (int a = 0; a < n; a++) {
for (auto& b : G[a]) {
if (comp[a] == comp[b]) continue;
if (!S.count({comp[a], comp[b]})) {
dag[comp[a]].push_back(comp[b]);
S.insert({comp[a], comp[b]});
}
}
}
return dag;
}
};
int VAR(int i) { return 2 * i; }
int NOT(int i) { return i ^ 1; }
struct SAT {
int n;
SCC scc;
SAT(int n) : n(n), scc(2 * n) {}
void add_or(int a, int b) {
if (a == NOT(b)) return;
scc.add_edge(NOT(a), b);
scc.add_edge(NOT(b), a);
}
void add_true(int a) { add_or(a, a); }
void add_false(int a) { add_or(NOT(a), NOT(a)); }
void add_xor(int a, int b) {
add_or(a, b);
add_or(NOT(a), NOT(b));
}
void add_imply(int a, int b) { add_or(NOT(a), b); }
bool solve() {
auto comp = scc.scc();
for (int i = 0; i < 2 * n; i += 2) {
if (comp[i] == comp[i + 1]) return false;
}
return true;
}
};
struct Rule {
int pos1, pos2;
char t1, t2;
void read() {
cin >> pos1 >> t1 >> pos2 >> t2;
pos1 = VAR(pos1 - 1);
pos2 = VAR(pos2 - 1);
if (t1 == 'C') pos1 = NOT(pos1);
if (t2 == 'C') pos2 = NOT(pos2);
}
};
string alpha, s;
int l, n, m;
bool vowel[256];
Rule rule[4 * 200 * 199];
char next_vowel[256], next_cons[256];
char min_v, min_c;
bool check_str(int pl, bool next_greater = true) {
SAT sat(2 * n);
if (!min_c) {
for (int i = 0; i < n; i++) {
sat.add_true(VAR(i));
}
} else if (!min_v) {
for (int i = 0; i < n; i++) {
sat.add_false(VAR(i));
}
}
for (int i = 0; i < m; i++) {
sat.add_imply(rule[i].pos1, rule[i].pos2);
}
for (int i = 0; i < pl; i++) {
if (vowel[s[i]]) {
sat.add_true(VAR(i));
} else {
sat.add_false(VAR(i));
}
}
if (pl < n && next_greater) {
char ch = s[pl];
if (!next_vowel[ch] && !next_cons[ch]) {
return false;
}
if (next_vowel[ch] && !next_cons[ch]) {
sat.add_true(VAR(pl));
}
if (!next_vowel[ch] && next_cons[ch]) {
sat.add_false(VAR(pl));
}
}
return sat.solve();
}
bool try_ch(int pos, char ch) {
if (!ch) return false;
char old = s[pos];
s[pos] = ch;
bool res = check_str(pos + 1, false);
s[pos] = old;
return res;
}
string build_soln(int pl) {
if (pl >= n) return s;
string ans = s;
char ch = 127;
if (try_ch(pl, next_vowel[s[pl]])) {
ch = min(ch, next_vowel[s[pl]]);
}
if (try_ch(pl, next_cons[s[pl]])) {
ch = min(ch, next_cons[s[pl]]);
}
ans[pl] = ch;
for (int i = pl + 1; i < n; i++) {
ch = 127;
s = ans;
if (try_ch(i, min_v)) {
ch = min(ch, min_v);
}
if (try_ch(i, min_c)) {
ch = min(ch, min_c);
}
ans[i] = ch;
}
return ans;
}
int main() {
cin >> alpha;
l = alpha.length();
for (int i = 0; i < l; i++) {
vowel[i + 'a'] = alpha[i] == 'V';
}
min_v = min_c = 0;
for (int i = 'a' + l - 1; i >= 'a'; i--) {
next_vowel[i] = min_v;
next_cons[i] = min_c;
if (vowel[i]) {
min_v = i;
} else {
min_c = i;
}
}
cin >> n >> m;
for (int i = 0; i < m; i++) {
rule[i].read();
}
cin >> s;
int prefix_len = n;
while (prefix_len >= 0 && !check_str(prefix_len)) {
prefix_len--;
}
if (prefix_len < 0) {
cout << -1 << endl;
return 0;
}
cout << build_soln(prefix_len) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> a;
for (int e = 0; e < n; e++) {
int y;
cin >> y;
a.push_back(y);
};
sort(a.begin(), a.end());
int ct3 = 0;
for (int i = 0; i < n; i++) {
if (a[i] == a[2]) ct3++;
}
if (a[0] == a[2])
cout << (long long)(ct3) * (ct3 - 1) * (ct3 - 2) / 6 << "\n";
else if (a[1] == a[2])
cout << (long long)(0.5 * (ct3) * (ct3 - 1)) << "\n";
else
cout << ct3 << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> sum(n + 1, 0);
vector<pair<int, int> > adj[n + 1];
vector<pair<int, int> > edges;
for (int i = 0; i < m; i++) {
int u, v, f;
cin >> u >> v >> f;
adj[u].push_back(pair<int, int>(v, f));
adj[v].push_back(pair<int, int>(u, f));
sum[v] += f;
sum[u] += f;
edges.push_back(pair<int, int>(u, v));
}
sum[1] = 0;
for (int i = 2; i < n; i++) sum[i] /= 2;
map<pair<int, int>, int> M;
queue<int> Q;
Q.push(1);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
if (u == n) continue;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i].first;
int fv = adj[u][i].second;
if (M[pair<int, int>(u, v)] || M[pair<int, int>(v, u)]) continue;
M[pair<int, int>(u, v)] = 1;
sum[v] -= fv;
if (sum[v] == 0) Q.push(v);
}
}
for (int i = 0; i < edges.size(); i++) {
if (M[edges[i]])
cout << 0 << endl;
else
cout << 1 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = -1e18;
const long long INF = 1e18;
long long n, a[1010], ans, dp[1010], cnt;
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[1] = 2;
for (int i = 2; i <= n; i++) {
cnt = 2;
for (int j = a[i]; j <= i; j++) {
cnt += dp[j];
cnt = cnt % mod;
}
cnt = cnt % mod;
dp[i] = cnt;
}
for (int i = 1; i <= n; i++) {
ans += dp[i];
ans = ans % mod;
}
cout << ans;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int a) {
if (a == 0 || a == 1) return false;
for (int i = 2; i <= sqrt((double)a) + 1; i++) {
if (a % i == 0 && a != i) return false;
}
return true;
}
struct bottle {
int a;
int b;
};
int main() {
int n, m;
cin >> n >> m;
int arr[100001];
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < m; i++) {
int a;
cin >> a;
if (a == 1) {
int x, y;
cin >> x >> y;
arr[x - 1] = y - ans;
}
if (a == 2) {
int x;
cin >> x;
ans += x;
}
if (a == 3) {
int x;
cin >> x;
cout << arr[x - 1] + ans << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (k - 1 >= 0 && k != n) {
if (a[k] == a[k - 1]) {
cout << "-1";
} else
cout << a[k - 1];
} else {
if (k == n)
cout << a[n - 1];
else if (k == 0) {
if (a[0] - 1 > 0)
cout << a[0] - 1;
else
cout << "-1";
} else
cout << "-1";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef vector<pair<long long int, long long int> > pairsvector;
void printvictor(vector<long long int> v) {
for (long long int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
}
void printPQ(priority_queue<long long int> pq) {
while (!pq.empty()) {
cout << pq.top() << " ";
pq.pop();
}
std::cout << '\n';
}
template <class T>
string toStr(const T &x) {
stringstream s;
s << x;
return s.str();
}
template <class T>
long long int toInt(const T &x) {
stringstream s;
s << x;
long long int r;
s >> r;
return r;
}
bool isprime(long long int n) {
if (n == 2) return true;
if (n < 2 || n % 2 == 0) return false;
for (long long int i = 3; i * i <= n; i += 2) {
if (n % i == 0) return false;
}
return true;
}
vector<long long int> generate_divisors(long long int n) {
vector<long long int> v;
long long int i;
for (i = 1; i <= n; ++i)
if (n % i == 0) v.push_back(i);
return v;
}
long long int BinaryToDec(string binary) {
long long int arr[binary.length()];
long long int sum = 0;
for (long long int i = 0; i < binary.length(); i++) arr[i] = pow(2, i);
reverse(binary.begin(), binary.end());
for (long long int i = 0; i < binary.length(); i++)
if (toInt(binary[i]) == 1) sum += arr[i];
return sum;
}
string DecToBinary(long long int decimal) {
string binary = "";
while (true) {
if (decimal % 2 == 0)
binary += '0';
else
binary += '1';
if (decimal == 1) break;
decimal /= 2;
}
reverse(binary.begin(), binary.end());
return binary;
}
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, a;
cin >> n >> a;
std::vector<long long int> yvector(n);
for (long long int i = 0; i < n; i++) cin >> yvector[i];
sort(yvector.begin(), yvector.end());
if (n == 1) {
cout << 0 << endl;
return 0;
}
if (a == yvector[0]) {
if (n > 1)
cout << abs(a - yvector[n - 2]) << "\n";
else
cout << 0 << "\n";
} else if (a == yvector[n - 1]) {
if (n > 1)
cout << abs(a - yvector[1]) << "\n";
else
cout << 0 << "\n";
} else {
long long int result =
abs(a - yvector[n - 2]) + abs(yvector[n - 2] - yvector[0]);
result =
min(result, abs(a - yvector[0]) + abs(yvector[0] - yvector[n - 2]));
result =
min(result, abs(a - yvector[n - 1]) + abs(yvector[n - 1] - yvector[1]));
result =
min(result, abs(a - yvector[1]) + abs(yvector[1] - yvector[n - 1]));
cout << result << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int copies, original;
cin >> copies >> original;
if (original == 1 && copies == 0) {
cout << "Yes";
} else if (original > 1) {
int copies_made = 0;
copies_made = original - 1;
if (copies < copies_made) {
cout << "No";
} else if ((copies - copies_made) % 2 == 0) {
cout << "Yes";
} else {
cout << "No";
}
} else {
cout << "No";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k = 5000;
int d[5005];
int cnt[5005];
vector<int> pr;
int id[5005];
int fac[5005][1005];
int s[5005][1005];
void sieve(void) {
for (int i = 2; i <= k; ++i)
if (!d[i]) {
id[i] = pr.size();
pr.push_back(i);
for (int j = i; j <= k; j += i)
if (!d[j]) d[j] = i;
}
for (int i = 1; i <= k; ++i) {
for (int j = 0; j < pr.size(); ++j) fac[i][j] = fac[i - 1][j];
int tmp = i;
while (tmp > 1) {
int t = d[tmp];
++fac[i][id[t]];
tmp /= t;
}
for (int j = 0; j < pr.size(); ++j) s[i][j] = fac[i][j] + s[i][j - 1];
}
}
int f[1005];
long long solve(void) {
long long ans = 0;
int rem = 0;
for (int i = 0; i < pr.size(); ++i) rem += f[i];
vector<int> cand(k, 0);
iota(cand.begin(), cand.end(), 1);
int l = 1, r = k;
for (int i = pr.size() - 1; i >= 0; --i) {
rem -= f[i];
while (l <= r && fac[l][i] < f[i]) {
ans +=
1ll * cnt[l] * (rem + (i ? s[l][i - 1] : 0) + abs(fac[l][i] - f[i]));
++l;
}
while (r >= l && fac[r][i] > f[i]) {
ans +=
1ll * cnt[r] * (rem + (i ? s[r][i - 1] : 0) + abs(fac[r][i] - f[i]));
--r;
}
}
return ans;
}
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
int x;
for (int i = 1; i <= n; ++i) {
cin >> x;
if (x == 0) x = 1;
++cnt[x];
}
sieve();
long long ans = 1e18;
for (int i = 1; i <= k; ++i) {
for (int j = 0; j < pr.size(); ++j) f[j] = fac[i][j];
ans = min(ans, solve());
}
for (int i = 1; i < k; ++i) {
int flg = 0;
for (int j = pr.size() - 1; j >= 0; --j) {
if (flg)
f[j] = 0;
else if (fac[i][j] != fac[i + 1][j]) {
flg = 1;
f[j] = min(fac[i][j], fac[i + 1][j]);
} else
f[j] = fac[i][j];
}
ans = min(ans, solve());
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
cin >> n;
s.resize(n);
for (int i = 0; i < n; i += 4) s[i] = 'a';
for (int i = 1; i < n; i += 4) s[i] = 'b';
for (int i = 2; i < n; i += 4) s[i] = 'c';
for (int i = 3; i < n; i += 4) s[i] = 'd';
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
double pr[32][32];
double dp[1 << 18];
bool calc[1 << 18];
double back(int mask, int m) {
if (calc[mask]) return dp[mask];
int i, j;
double r = 0;
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
if (((mask >> i) & 1) && (!((mask >> j) & 1))) {
r += pr[i][j] * back(mask | (1 << j), m + 1);
}
}
}
r /= ((m + 1) * m) / 2;
calc[mask] = true;
dp[mask] = r;
return r;
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
scanf("%lf", &(pr[i][j]));
}
}
calc[(1 << n) - 1] = true;
dp[(1 << n) - 1] = 1.;
for (i = 0; i < n; ++i) {
printf("%.6lf ", back(1 << i, 1));
}
putchar('\n');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int test;
cin >> test;
while (test--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cout << 2 * (i + n) << " ";
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int size = 1e6 + 527;
int n, m, u, v, cnt;
int *f[size];
int p[size], t[size], dep[size];
int ans[size], son[size], head[size];
int *e = p + 1;
struct Edge {
int v, nxt;
} edge[size << 1];
void add(int u, int v) {
edge[++cnt] = (Edge){v, head[u]};
head[u] = cnt;
}
void dfs(int x, int fa) {
dep[x] = t[x] = dep[fa] + 1;
for (int i = head[x]; i; i = edge[i].nxt)
if (edge[i].v != fa) {
dfs(edge[i].v, x);
if (t[edge[i].v] > t[x]) t[x] = t[edge[i].v], son[x] = edge[i].v;
}
}
void Dfs(int x, int fa) {
if (son[x]) f[son[x]] = f[x] + 1, Dfs(son[x], x), ans[x] = ans[son[x]] + 1;
f[x][0] = 1;
for (int i = head[x]; i; i = edge[i].nxt)
if (edge[i].v != fa && edge[i].v != son[x]) {
f[edge[i].v] = e;
e += t[edge[i].v] - dep[edge[i].v] + 1;
Dfs(edge[i].v, x);
m = t[edge[i].v] - dep[edge[i].v];
for (int j = 0; j <= m; j++) {
f[x][j + 1] += f[edge[i].v][j];
if (f[x][j + 1] > f[x][ans[x]] ||
f[x][j + 1] == f[x][ans[x]] && j + 1 < ans[x])
ans[x] = j + 1;
}
}
if (f[x][ans[x]] == 1) ans[x] = 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 0);
f[1] = e, e += t[1] - dep[1] + 1;
Dfs(1, 0);
for (int i = 1; i <= n; i++) printf("%d\n", ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 6e2 + 10;
int cost[N][N];
map<string, int> ms;
int main() {
int n, a, b, k, f;
cin >> n >> a >> b >> k >> f;
int m = 0;
int pre = 0;
memset((cost), (0), sizeof(cost));
for (int i = 1; i <= n; i++) {
string s1, s2;
cin >> s1 >> s2;
if (!ms.count(s1)) ms[s1] = ++m;
if (!ms.count(s2)) ms[s2] = ++m;
int x = ms[s1], y = ms[s2];
if (x == pre)
cost[x][y] += b;
else
cost[x][y] += a;
pre = y;
}
vector<int> v;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
ans += cost[i][j] + cost[j][i];
if (cost[i][j] + cost[j][i] > f) {
v.push_back(cost[i][j] + cost[j][i] - f);
}
}
}
if (!v.empty()) sort(v.rbegin(), v.rend());
for (auto &x : v) {
if (k == 0) break;
ans -= x;
k--;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[400005], c[400005];
vector<long long> v[400005];
long long fa[400005];
bool p[400005];
long long an[400005], nn;
long long ans;
long long at[400005], fk;
void rd() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) {
cin >> fa[i];
if (fa[i] != -1) v[fa[i]].push_back(i);
}
}
void dfs(long long x) {
for (long long i = 0; i < v[x].size(); i++) {
long long y = v[x][i];
dfs(y);
}
if (a[x] + c[x] > 0) {
nn++;
an[nn] = x;
p[x] = 1;
c[fa[x]] += c[x] + a[x];
ans += a[x] + c[x];
} else {
fk++;
at[fk] = x;
}
}
signed main() {
rd();
for (long long i = 1; i <= n; i++)
if (fa[i] == -1) dfs(i);
for (long long i = 1; i <= n; i++)
if (p[i] == 0) {
p[i] = 1;
ans += a[i] + c[i];
}
cout << ans << "\n";
for (long long i = 1; i <= nn; i++) cout << an[i] << " ";
for (long long i = fk; i >= 1; i--) cout << at[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long x = 0, y = 0, z = 0;
while (n--) {
long long a, b, c;
cin >> a >> b >> c;
x += a;
y += b;
z += c;
}
if (x == 0 && y == 0 && z == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, f[N], g[N];
char _s[2][N], s[N];
inline void U(int &a, int &b, int c, int d) {
if (c < a) a = c, b = d;
}
namespace PaT {
int c[N][26], link[N], len[N], slink[N], diff[N], sf[N][2], sg[N][2], last,
size;
inline void Init() {
link[0] = 1;
len[1] = -1;
size = 2;
}
inline int GetLink(int v, int pos) {
while (s[pos - len[v] - 1] != s[pos]) v = link[v];
return v;
}
inline void Append(int pos) {
int d = s[pos] - 'a';
last = GetLink(last, pos);
if (!c[last][d]) {
len[size] = len[last] + 2;
link[size] = c[GetLink(link[last], pos)][d];
diff[size] = len[size] - len[link[size]];
slink[size] =
(diff[size] == diff[link[size]] ? slink[link[size]] : link[size]);
c[last][d] = size++;
}
last = c[last][d];
f[pos] = 1e9;
if ((~pos & 1) && s[pos] == s[pos - 1]) f[pos] = f[pos - 2], g[pos] = pos - 2;
for (int v = last; len[v] > 0; v = slink[v]) {
int tmp = len[slink[v]] + diff[v];
sf[v][tmp & 1] = f[pos - tmp];
sg[v][tmp & 1] = pos - tmp;
sf[v][~tmp & 1] = 1e9;
if (diff[v] == diff[link[v]]) {
U(sf[v][0], sg[v][0], sf[link[v]][diff[v] & 1], sg[link[v]][diff[v] & 1]);
U(sf[v][1], sg[v][1], sf[link[v]][~diff[v] & 1],
sg[link[v]][~diff[v] & 1]);
}
U(f[pos], g[pos], sf[v][0] + 1, sg[v][0]);
}
}
} // namespace PaT
int main() {
scanf("%s%s", _s[0], _s[1]);
n = strlen(_s[0]) << 1;
for (int i = 0; i < n; ++i) s[i + 1] = _s[i & 1][i >> 1];
PaT::Init();
for (int i = 1; i <= n; ++i) PaT::Append(i);
if (f[n] == 1e9) return puts("-1"), 0;
printf("%d\n", f[n]);
while (n) {
if (g[n] + 2 != n || s[n] != s[n - 1])
printf("%d %d\n", (g[n] >> 1) + 1, n >> 1);
n = g[n];
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct task {
long dif, id;
};
task tasks[3000];
int dem[3000];
int dem3, dem21, dem20;
long n;
bool cmp(task x, task y) { return x.dif < y.dif; }
int main() {
memset(dem, 0, sizeof(dem));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> tasks[i].dif;
dem[tasks[i].dif] += 1;
tasks[i].id = i;
}
dem3 = -1;
dem20 = -1;
dem21 = -1;
for (int i = 1; i <= 2000; i++) {
if (dem[i] >= 3) dem3 = i;
if (dem[i] == 2) {
if (dem20 > 0)
dem21 = i;
else
dem20 = i;
}
}
sort(tasks + 1, tasks + n + 1, cmp);
if (dem3 > 0) {
cout << "YES" << endl;
bool found;
long i;
i = 1;
found = false;
while (i <= n) {
if ((tasks[i].dif == dem3) && found == false) {
cout << tasks[i].id << " " << tasks[i + 1].id << " " << tasks[i + 2].id
<< " ";
i += 3;
found = true;
} else {
cout << tasks[i].id << " ";
i += 1;
}
}
cout << endl;
i = 1;
found = false;
while (i <= n) {
if ((tasks[i].dif == dem3) && found == false) {
cout << tasks[i + 1].id << " " << tasks[i + 2].id << " " << tasks[i].id
<< " ";
i += 3;
found = true;
} else {
cout << tasks[i].id << " ";
i += 1;
}
}
cout << endl;
i = 1;
found = false;
while (i <= n) {
if ((tasks[i].dif == dem3) && found == false) {
cout << tasks[i + 2].id << " " << tasks[i].id << " " << tasks[i + 1].id
<< " ";
i += 3;
found = true;
} else {
cout << tasks[i].id << " ";
i += 1;
}
}
cout << endl;
} else {
bool found0, found1;
if (dem21 < 0)
cout << "NO";
else {
cout << "YES" << endl;
found0 = false;
found1 = false;
for (int i = 1; i <= n; i++) {
if ((tasks[i].dif == dem20) && (found0 == false)) {
cout << tasks[i].id << " " << tasks[i + 1].id << " ";
found0 = true;
i += 1;
} else {
if ((tasks[i].dif == dem21) && (found1 == false)) {
cout << tasks[i].id << " " << tasks[i + 1].id << " ";
found1 = true;
i += 1;
} else
cout << tasks[i].id << " ";
}
}
cout << endl;
found0 = false;
found1 = false;
for (int i = 1; i <= n; i++) {
if ((tasks[i].dif == dem20) && (found0 == false)) {
cout << tasks[i].id << " " << tasks[i + 1].id << " ";
found0 = true;
i += 1;
} else {
if ((tasks[i].dif == dem21) && (found1 == false)) {
cout << tasks[i + 1].id << " " << tasks[i].id << " ";
found1 = true;
i += 1;
} else
cout << tasks[i].id << " ";
}
}
cout << endl;
found0 = false;
found1 = false;
for (int i = 1; i <= n; i++) {
if ((tasks[i].dif == dem20) && (found0 == false)) {
cout << tasks[i + 1].id << " " << tasks[i].id << " ";
found0 = true;
i += 1;
} else {
if ((tasks[i].dif == dem21) && (found1 == false)) {
cout << tasks[i].id << " " << tasks[i + 1].id << " ";
found1 = true;
i += 1;
} else
cout << tasks[i].id << " ";
}
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string ch1, ch2, ch3, ch4;
cin >> ch1 >> ch2 >> ch3;
ch4 = ch1 + ch2;
sort(ch3.begin(), ch3.end());
sort(ch4.begin(), ch4.end());
ch3 == ch4 ? cout << "YES" : cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct obj {
int r, c, x;
};
obj mat[101][101];
int n, m, q;
pair<int, int> pos[101][101];
void shiftRow(int r);
void shiftCol(int c);
int main() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
mat[i][j].r = i;
mat[i][j].c = j;
mat[i][j].x = 0;
pos[i][j].first = i;
pos[i][j].second = j;
}
}
while (q--) {
int t, r, c, x;
cin >> t;
if (t == 1) {
cin >> r;
shiftRow(r - 1);
} else if (t == 2) {
cin >> c;
shiftCol(c - 1);
} else {
cin >> r >> c >> x;
mat[r - 1][c - 1].x = x;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
pair<int, int> ind = pos[i][j];
cout << mat[ind.first][ind.second].x << " ";
}
cout << "\n";
}
return 0;
}
void shiftRow(int r) {
obj prev, temp;
prev = mat[r][m - 1];
for (int i = m - 1; i >= 0; i--) {
temp = mat[r][(i - 1 + m) % m];
mat[r][(i - 1 + m) % m] = prev;
pos[prev.r][prev.c].first = r;
pos[prev.r][prev.c].second = (i - 1 + m) % m;
prev = temp;
}
}
void shiftCol(int c) {
obj prev, temp;
prev = mat[n - 1][c];
for (int i = n - 1; i >= 0; i--) {
temp = mat[(i - 1 + n) % n][c];
mat[(i - 1 + n) % n][c] = prev;
pos[prev.r][prev.c].first = (i - 1 + n) % n;
pos[prev.r][prev.c].second = c;
prev = temp;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2010;
int const inf = 1e9;
int dp[N][N], cums[27][N], cumt[27][N];
int n;
int _count(int wh, char ch, int l, int r) {
if (l > r) return 0;
r = min(r, n);
l = min(l, n);
if (wh == 1) return cums[ch - 'a'][r] - cums[ch - 'a'][l - 1];
return cumt[ch - 'a'][r] - cumt[ch - 'a'][l - 1];
}
void solve() {
cin >> n;
memset(cums, 0, sizeof cums);
memset(cumt, 0, sizeof cumt);
string s, t;
cin >> s >> t;
map<char, int> cnt;
for (auto &x : s) cnt[x]++;
for (auto &x : t) cnt[x]--;
for (auto x : cnt) {
if (x.second != 0) {
cout << "-1\n";
return;
}
}
s = '#' + s, t = '#' + t;
for (int ch = 0; ch < 27; ch++) {
for (int i = 1; i <= n; i++) {
cums[ch][i] = cums[ch][i - 1] + (s[i] - 'a' == ch);
cumt[ch][i] = cumt[ch][i - 1] + (t[i] - 'a' == ch);
}
}
for (int i = 0; i <= n; i++) {
for (int j = i; j <= n; j++) {
if (!i) {
dp[i][j] = 0;
continue;
}
dp[i][j] = inf;
int &r = dp[i][j];
r = min(r, dp[i - 1][j] + 1);
if (s[i] == t[j]) r = min(r, dp[i - 1][j - 1]);
if (_count(1, t[j], i + 1, n) > _count(2, t[j], j + 1, n)) {
r = min(r, dp[i][j - 1]);
}
}
}
cout << dp[n][n] << '\n';
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int const N = 30 + 20;
int t, n, p;
bool mark[N][N];
int main() {
cin >> t;
while (t--) {
cin >> n >> p;
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++) mark[i][j] = mark[j][i] = 0;
for (int i = 0; i < n; i++) {
cout << i + 1 << ' ' << (i + 1) % n + 1 << '\n';
mark[i][(i + 1) % n] = mark[(i + 1) % n][i] = 1;
cout << i + 1 << ' ' << (i + 2) % n + 1 << '\n';
mark[i][(i + 2) % n] = mark[(i + 2) % n][i] = 1;
}
for (int i = 0; i < n; i++) {
if (!p) break;
for (int j = i + 1; j < n; j++) {
if (!p) break;
if (!mark[i][j]) {
cout << i + 1 << ' ' << j + 1 << '\n';
mark[i][j] = mark[j][i] = 1;
p--;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int T, n, i, j, x, flag, count = 0, min, l;
string s;
cin >> s;
long long int a[7] = {0};
l = s.length();
for (i = 0; i < l; i++) {
if (s[i] == 'B')
a[0]++;
else if (s[i] == 'u')
a[1]++;
else if (s[i] == 'l')
a[2]++;
else if (s[i] == 'b')
a[3]++;
else if (s[i] == 'a')
a[4]++;
else if (s[i] == 's')
a[5]++;
else if (s[i] == 'r')
a[6]++;
}
a[1] = a[1] / 2;
a[4] = a[4] / 2;
min = 100000;
for (i = 0; i < 7; i++) {
if (a[i] < min) min = a[i];
}
cout << min << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void fileio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
}
int n;
int main() {
fileio();
cin >> n;
if (n % 2 == 0) {
cout << "white" << '\n';
if (n == 2)
cout << "1 2";
else
cout << "1 2";
} else
cout << "black";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[200009], c[200009];
vector<int> v[200009];
set<pair<int, int> > s;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 0, x; i < n; i++) {
cin >> x;
x--;
a[x]++;
}
for (int i = 0; i < k; i++) {
cin >> c[i];
}
s.insert({0, 0});
int cur = 1;
for (int i = k; i >= 0; i--) {
while (a[i]) {
auto it = s.begin();
pair<int, int> p = *it;
if (p.first == c[i]) break;
s.erase(p);
int x = p.second;
while (p.first < c[i] && a[i] > 0) {
p.first++;
a[i]--;
v[x].push_back(i + 1);
}
s.insert(p);
}
while (a[i]) {
pair<int, int> p = {0, cur};
p.first += min(a[i], c[i]);
a[i] -= p.first;
for (int j = 0; j < p.first; j++) v[cur].push_back(i + 1);
s.insert(p);
cur++;
}
}
cout << cur << "\n";
for (int i = 0; i < cur; i++) {
cout << v[i].size() << " ";
for (int j = 0; j < v[i].size(); j++) cout << v[i][j] << " ";
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 100001;
const int P = 17;
int n, p, a[P], dp[1 << P][P][P], fr[P], ln[1 << P], ans[1 << P];
bool bad[1 << P];
char tmp[N];
int calc(int msk) {
int &ret = ans[msk];
if (ret != -1) return ret;
ret = ln[msk];
for (int j = 0; j < p; ++j)
if ((msk & (1 << j)) == 0 && !bad[msk ^ (1 << j)])
ret = min(ret, calc(msk ^ (1 << j)));
return ret;
}
int main() {
memset(ans, -1, sizeof ans);
scanf("%d%d%s", &n, &p, tmp);
for (int i = 0; i < n; ++i) fr[tmp[i] - 'a']++;
for (int msk = 0; msk < (1 << p); ++msk)
for (int bt = 0; bt < p; ++bt)
if ((msk & (1 << bt)) == 0) ln[msk] += fr[bt];
for (int i = 0; i < p; ++i)
for (int bt, j = 0; j < p; ++j) {
scanf("%d", &bt);
bt = (1 << j) * (bt);
a[i] |= bt;
}
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) {
if (((1 << j) & a[i]) > 0) continue;
int idx = -1;
for (int k = 0; k < n && idx == -1; ++k)
if (tmp[k] - 'a' == i) idx = k;
if (idx == -1) continue;
for (int msk = 0, k = idx; k < n; ++k) {
int cr = (1 << (tmp[k] - 'a'));
msk |= cr;
if (tmp[k] - 'a' == j && k != idx) {
int fn = msk;
if ((fn & (1 << i))) fn ^= (1 << i);
if ((fn & (1 << j))) fn ^= (1 << j);
dp[fn][i][j] = 1;
}
if (tmp[k] == (i + 'a')) msk = 0;
}
}
for (int msk = 0; msk < (1 << p); ++msk)
for (int i = 0; i < p; ++i)
for (int j = 0; j < p; ++j) {
for (int bt = 0; bt < p; ++bt) {
if (bt == i || bt == j || (msk & (1 << bt)) > 0) continue;
dp[msk ^ (1 << bt)][i][j] |= dp[msk][i][j];
}
bad[msk] |= dp[msk][i][j];
}
printf("%d\n", calc(0));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7, N = 1e5 + 5;
long long solve() {
long long n, ans = 0;
cin >> n;
long long a[n];
for (long long i = (long long)0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << "1 1" << '\n' << -1 * a[0] << '\n';
cout << "1 1" << '\n' << 0 << '\n';
cout << "1 1" << '\n' << 0 << '\n';
return 1;
}
cout << n << " " << n << '\n' << -1 * a[n - 1] << '\n';
cout << "1 " << n << '\n';
for (long long i = (long long)0; i < n - 1; i++) {
cout << -1 * a[i] * n << " ";
}
cout << 0 << '\n';
cout << "1 " << n - 1 << '\n';
for (long long i = (long long)0; i < n - 1; i++) {
cout << a[i] * (n - 1) << " ";
}
cout << '\n';
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 999999999 + 1;
pair<double, double> a[1000];
int main() {
int n, t;
cin >> n >> t;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a, a + n);
int ans = 2;
for (int i = 1; i < n; i++)
if (a[i].first - a[i - 1].first - 0.5 * (a[i].second + a[i - 1].second) ==
t)
ans++;
else if (a[i].first - a[i - 1].first -
0.5 * (a[i].second + a[i - 1].second) >
t)
ans += 2;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize "trapv"
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ", ";
err(++it, args...);
}
long long int power(long long int x, long long int b,
long long int modh = 1000000007) {
long long int p = 1;
while (b > 0) {
if (b & 1) {
p = p * x;
p %= modh;
}
b >>= 1;
x *= x;
x %= modh;
}
return p % modh;
}
std::vector<long long int> fact;
void fact_pre(long long int n = 2000005) {
fact.resize(n, 1LL);
for (long long int i = 2; i < n; i++)
fact[i] = (fact[i - 1] * i) % 1000000007;
}
long long int ncr(long long int n, long long int r) {
if (r > n) return 0;
return (fact[n] *
power((fact[n - r] * fact[r]) % 1000000007, 1000000007 - 2)) %
1000000007;
}
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
long long int rng(long long int lim, long long int s = 0) {
uniform_int_distribution<long long int> uid(s, lim - 1);
return uid(rang);
}
struct ppp {
long long int first, second, tt, fo;
};
long long int bsleft(vector<long long int> &arr, long long int c) {
long long int l = -1, r = arr.size();
while (r - l > 1) {
long long int mid = (r + l) / 2;
if (arr[mid] <= c) {
l = mid;
} else {
r = mid;
}
}
return l;
}
struct lex_compare {
bool operator()(const pair<long long int, long long int> &p1,
const pair<long long int, long long int> &p2) {
if (p1.second != p2.second) {
return p1.second < p2.second;
} else {
return p1.first < p2.first;
}
}
};
inline void add(long long int &x, long long int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
return;
}
inline long long int sub(long long int x, long long int y) {
x -= y;
if (x < 0) x += 1000000007;
return x;
}
string bitform(long long int x) {
string s = "";
while (x > 0) {
s += (char('0' + x % 2));
x /= 2;
}
reverse(s.begin(), s.end());
return s;
}
void solve(long long int t = 0) {
long long int n;
cin >> n;
string ans = "";
for (long long int i = 0; i < n - 2; i++) {
string s;
cin >> s;
if (ans.size()) {
if (s[0] == ans.back()) {
ans += s[1];
} else {
ans += s[0];
ans += s[1];
}
} else
ans += s;
}
if (ans.size() != n) ans += 'a';
cout << ans << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
t = 1;
cin >> t;
for (long long int i = 1; i < t + 1; i++) {
solve(i);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
cout << a[i] + a[i + 1] << " ";
}
cout << a[n - 1];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string S;
cin >> S;
int L = S.length();
bool haszero = false;
int sum = 0, temp, haseven = 0;
char c;
for (int i = 0; i < S.length(); i++) {
c = S[i];
temp = c - '0';
if (temp % 2 == 0) {
haseven++;
}
if (temp == 0) {
haszero = true;
}
sum += temp;
}
if (sum % 3 || (!haszero) || haseven <= 1) {
cout << "cyan\n";
} else
cout << "red\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int N;
cin >> N;
while (N--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
register int x, op = 1, c;
while (c = getchar(), c < '0' || c > '9')
if (c == '-') op = -op;
x = c ^ 48;
while (c = getchar(), c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48);
return x * op;
}
int head[300001], nxt[600001], ver[600001], tot = 0;
void add(int x, int y) { ver[++tot] = y, nxt[tot] = head[x], head[x] = tot; }
int n, m;
int ans = 0;
struct edge {
edge* nxt;
int ver;
} * h[300001];
int dg[300001] = {0};
void add_edge(int x, int y) {
edge* p = new edge;
p->nxt = h[x], p->ver = y;
h[x] = p;
dg[y]++;
}
queue<int> q;
bool b[300001] = {0};
int f[300001] = {0};
void check(int x, int y, int w) {
for (edge* i = h[y]; i; i = i->nxt)
if (dg[i->ver] == 1) return void(b[x] = 1);
f[x] += w;
}
int cnt = 0;
void topo() {
for (int i = 1; i <= n; i++)
if (!dg[i]) q.push(i), cnt++;
while (!q.empty()) {
int x = q.front();
q.pop();
if (q.empty()) f[x] += n - cnt;
if (q.size() == 1) check(x, q.front(), n - cnt);
for (edge* i = h[x]; i; i = i->nxt)
if (!(--dg[i->ver])) q.push(i->ver), cnt++;
}
}
int main() {
n = gi(), m = gi();
for (int i = 1, x, y; i <= m; i++) x = gi(), y = gi(), add(x, y);
for (int x = 1; x <= n; x++)
for (int i = head[x]; i; i = nxt[i]) add_edge(x, ver[i]);
topo();
cnt = 0;
for (int i = 1; i <= n; i++) h[i] = NULL;
for (int x = 1; x <= n; x++)
for (int i = head[x]; i; i = nxt[i]) add_edge(ver[i], x);
topo();
for (int i = 1; i <= n; i++)
if (!b[i] && f[i] >= n - 2) ans++;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long a = 0, po = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') po = -1, ch = getchar();
while (isdigit(ch)) a = (a << 1) + (a << 3) + ch - '0', ch = getchar();
return a * po;
}
long long a[10];
long long b[] = {1, 10, 100, 1000, 10000,
100000, 1000000, 10000000, 100000000, 1000000000};
signed main() {
long long t = read();
while (t--) {
long long s = read();
long long n = read();
long long c = s;
long long temp = 0;
memset(a, 0, sizeof(a));
if (n == 1)
cout << s << "\n";
else {
for (long long i = 9; i >= 0; i--) {
a[i] = c / b[i];
c = c - a[i] * b[i];
}
for (long long i = 9; i >= 0; i--) {
if (a[i] != 0) {
temp = i;
break;
}
}
for (long long i = temp; i >= 0; i--) {
if (a[i] >= n) {
for (long long j = 1; j < n; j++) {
cout << b[i] << " ";
}
cout << (s - (n - 1) * b[i]);
if (t) cout << " ";
cout << "\n";
break;
} else {
if ((s - a[i] * b[i]) >= (n - a[i])) {
for (long long j = 1; j <= a[i]; j++) {
cout << b[i] << " ";
}
s -= a[i] * b[i];
n -= a[i];
} else {
for (long long j = 1; s - b[i] >= n - 1; j++) {
cout << b[i] << " ";
n--;
a[i]--;
s -= b[i];
}
a[i - 1] += a[i] * 10;
}
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
vector<pair<string, long long> > widgets;
vector<pair<long long, long long> > sizes;
vector<pair<long long, long long> > params;
vector<long long> v[110];
bool parents[110];
bool vis[110];
vector<pair<string, long long> > print;
void dfs(long long k) {
vis[k] = true;
long long sum = 0;
long long m = 0;
for (long long i = 0; i < v[k].size(); i++) {
if (widgets[v[k][i]].second != 0 && !vis[v[k][i]]) dfs(v[k][i]);
if (widgets[k].second == 2) {
sum += sizes[v[k][i]].first;
m = max(m, sizes[v[k][i]].second);
} else {
sum += sizes[v[k][i]].second;
m = max(m, sizes[v[k][i]].first);
}
}
sum += (v[k].size() - 1) * params[k].first;
sum += 2 * params[k].second;
m += 2 * params[k].second;
if (widgets[k].second == 1) swap(sum, m);
if (v[k].size() == 0) {
sum = 0;
m = 0;
}
sizes[k].first = sum;
sizes[k].second = m;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
vis[i] = false;
parents[i] = false;
string s, s2;
cin >> s;
if (s == "Widget" || s == "VBox" || s == "HBox") {
cin >> s2;
if (s == "Widget") {
long long sk1 = s2.find("(");
long long sk2 = s2.find(",");
long long sk3 = s2.find(")");
long long x1 = 0, x2 = 0;
string str1, str2;
string nme = s2.substr(0, sk1);
str1 = s2.substr(sk1 + 1, sk2 - sk1 - 1);
str2 = s2.substr(sk2 + 1, sk3 - sk2 - 1);
for (long long j = 0; j < str1.length(); j++)
x1 = x1 * 10 + str1[j] - '0';
for (long long j = 0; j < str2.length(); j++)
x2 = x2 * 10 + str2[j] - '0';
widgets.push_back(make_pair(nme, 0));
sizes.push_back(make_pair(x1, x2));
params.push_back(make_pair(0, 0));
} else {
if (s == "VBox")
widgets.push_back(make_pair(s2, 1));
else {
widgets.push_back(make_pair(s2, 2));
}
sizes.push_back(make_pair(0, 0));
params.push_back(make_pair(0, 0));
}
}
if (s.find(".set_spacing(") != -1) {
string str1 = s.substr(s.find("(") + 1, s.find(")") - s.find("(") - 1);
long long x1 = 0;
for (long long j = 0; j < str1.length(); j++)
x1 = x1 * 10 + str1[j] - '0';
string str2 = s.substr(0, s.find(".set_spacing("));
for (long long j = 0; j < widgets.size(); j++)
if (widgets[j].first == str2) params[j].first = x1;
}
if (s.find(".set_border(") != -1) {
string str1 = s.substr(s.find("(") + 1, s.find(")") - s.find("(") - 1);
long long x1 = 0;
for (long long j = 0; j < str1.length(); j++)
x1 = x1 * 10 + str1[j] - '0';
string str2 = s.substr(0, s.find(".set_border("));
for (long long j = 0; j < widgets.size(); j++)
if (widgets[j].first == str2) params[j].second = x1;
}
if (s.find(".pack(") != -1) {
string str1 = s.substr(0, s.find(".pack("));
string str2 = s.substr(s.find("(") + 1, s.find(")") - s.find("(") - 1);
long long x1, x2;
for (long long j = 0; j < widgets.size(); j++) {
if (widgets[j].first == str1) x1 = j;
if (widgets[j].first == str2) x2 = j;
}
v[x1].push_back(x2);
parents[x2] = true;
}
}
for (long long i = 0; i < widgets.size(); i++)
if (widgets[i].second != 0 && !parents[i]) {
dfs(i);
}
for (long long i = 0; i < widgets.size(); i++) {
print.push_back(make_pair(widgets[i].first, i));
}
sort(print.begin(), print.end());
for (long long i = 0; i < print.size(); i++) {
cout << print[i].first << " " << sizes[print[i].second].first << " "
<< sizes[print[i].second].second << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char cuv[15][150];
int main() {
int n, i, L;
ifstream f("date.in");
cin >> n;
cin.get();
for (i = 1; i <= n; ++i) {
cin.getline(cuv[i] + 1, 140);
L = strlen(cuv[i] + 1);
if (cuv[i][1] == 'm' && cuv[i][2] == 'i' && cuv[i][3] == 'a' &&
cuv[i][4] == 'o' && cuv[i][5] == '.') {
if (cuv[i][L] == '.' && cuv[i][L - 1] == 'a' && cuv[i][L - 2] == 'l' &&
cuv[i][L - 3] == 'a' && cuv[i][L - 4] == 'l')
cout << "OMG>.< I don't know!\n";
else
cout << "Rainbow's\n";
} else if (cuv[i][L] == '.' && cuv[i][L - 1] == 'a' &&
cuv[i][L - 2] == 'l' && cuv[i][L - 3] == 'a' &&
cuv[i][L - 4] == 'l')
cout << "Freda's\n";
else
cout << "OMG>.< I don't know!\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, d;
int a[100010];
int Anss = 0;
int Maxx = 0;
int Minn = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 0) {
if (Maxx < 0) {
Anss++;
Minn = 0;
Maxx = d;
} else {
Minn = max(Minn, 0);
}
} else {
Minn += a[i];
Maxx = min(Maxx + a[i], d);
if (Minn > Maxx) {
cout << "-1";
return 0;
}
}
}
cout << Anss;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k[110], v[110][110], t[110][110], res, s, i, j;
int ktra(long long &s1, long long &s2, long long f1, long long f2, int &p) {
int res = ((s1 - s2) * (f1 - f2) < 0) || ((s1 == s2) && (p * (f1 - f2) < 0));
if (f1 > f2) p = 1;
if (f1 < f2) p = -1;
s1 = f1;
s2 = f2;
return res;
}
int tinh(int i, int j) {
long long s1 = 0, s2 = 0;
int i1 = 0, i2 = 0, t1 = t[i][0], t2 = t[j][0], d = 0, tt, p = 0;
while (s1 < s && s2 < s) {
tt = min(t1, t2);
d += ktra(s1, s2, s1 + tt * v[i][i1], s2 + tt * v[j][i2], p);
t1 -= tt;
t2 -= tt;
if (t1 == 0 && i1 < k[i] - 1) t1 = t[i][++i1];
if (t2 == 0 && i2 < k[j] - 1) t2 = t[j][++i2];
}
return d;
}
int main() {
cin >> n >> s;
for (i = 0; i < n; i++) {
cin >> k[i];
for (j = 0; j < k[i]; j++) cin >> v[i][j] >> t[i][j];
}
res = 0;
for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++) res += tinh(i, j);
cout << res;
}
| 7 |
#include <bits/stdc++.h>
const long long mod = 998244353;
int a[200005];
int have[200005];
int sum[200005];
int bit[200005];
long long f[200005];
long long dp[200005];
void change(int p, int v, int n) {
while (p <= n) {
bit[p] += v;
p += p & -p;
}
}
int ask(int p) {
int res = 0;
while (p != 0) {
res += bit[p];
p -= p & -p;
}
return res;
}
long long partOne(int n) {
long long res = 0;
for (int i = n; i >= 1; i--) {
if (a[i] != -1) {
long long add = ask(a[i] - 1);
res += add;
change(a[i], 1, n);
}
}
return res;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2) res = res * a % mod;
a = a * a % mod;
b /= 2;
}
return res;
}
long long inv(long long u) { return power(u, mod - 2); }
int main() {
int n;
scanf("%d", &n);
f[0] = 1;
for (int i = 1; i <= n; i++) f[i] = f[i - 1] * (long long)i % mod;
int empty = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != -1)
have[a[i]] = 1;
else
empty++;
}
if (empty == 0)
printf("%lld\n", partOne(n) % mod);
else {
sum[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + (have[i] == 0);
}
long long preEmpty = 0;
long long all = 0;
for (int i = 1; i <= n; i++) {
if (a[i] != -1) {
long long small = sum[a[i] - 1];
long long big = sum[n] - sum[a[i]];
long long suEmpty = empty - preEmpty;
long long add = big * preEmpty % mod * f[empty - 1] % mod;
all = (all + add) % mod;
add = small * suEmpty % mod * f[empty - 1] % mod;
all = (all + add) % mod;
} else
preEmpty++;
}
dp[1] = 0;
for (long long i = 2; i <= empty; i++) {
dp[i] = dp[i - 1] * i % mod;
long long add = (i * (i - 1) / 2ll) % mod;
add = add * f[i - 1] % mod;
dp[i] = (dp[i] + add) % mod;
}
all = (all + dp[empty]) % mod;
long long ans = (all * inv(f[empty]) % mod + partOne(n) % mod) % mod;
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int fast_power(long long int base, long long int power,
long long int mod) {
long long int result = 1;
while (power > 0) {
if (power & 1) result = (result * base) % mod;
base = (base * base) % mod;
power >>= 1;
}
return result;
}
long long int scan() {
long long int t = 0;
char c, ch;
ch = getchar();
if (ch == '-')
c = getchar();
else
c = ch;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
t = (t << 3) + (t << 1) + c - '0';
c = getchar();
}
if (ch == '-')
return -t;
else
return t;
}
int main() {
long long int n, m;
n = scan(), m = scan();
long long int a[n][n], ans = -1;
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= n - 1; j++) a[i][j] = 0;
for (int i = 0; i <= m - 1; i++) {
long long int x, y;
x = scan(), y = scan();
if (ans == -1)
for (int j = x - 1; j <= x + 1; j++)
for (int k = y - 1; k <= y + 1; k++) {
if (j < n && k < n) {
a[j][k]++;
if (a[j][k] == 9) ans = i + 1;
}
}
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, w, start = 0, k;
long long int MAX = 1e18;
vector<vector<int> > wait(100005);
vector<vector<pair<int, int> > > adj(100005);
void binarySearch(int v, long long int& d) {
if (v == n - 1 or wait[v].size() == 0) {
return;
}
int low = 0, high = wait[v].size() - 1, mid;
while (low <= high) {
mid = (low + high) >> 1;
if (wait[v][mid] == d) {
++d;
++mid;
while (mid <= wait[v].size() - 1 and
wait[v][mid] == wait[v][mid - 1] + 1) {
++d;
++mid;
}
return;
} else if (wait[v][mid] > d) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return;
}
int main(void) {
ios ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i <= m - 1; ++i) {
cin >> a >> b >> w;
--a;
--b;
adj[a].push_back({b, w});
adj[b].push_back({a, w});
}
for (int i = 0; i <= n - 1; ++i) {
cin >> k;
for (int j = 1; j <= k; ++j) {
cin >> w;
wait[i].emplace_back(w);
}
}
set<pair<long long int, int> > s;
vector<long long int> dist(n, MAX);
vector<int> present(n, 1);
dist[start] = 0;
s.insert({dist[start], start});
while (!s.empty()) {
auto c = *(s.begin());
s.erase(c);
int v = c.second;
present[v] = 0;
binarySearch(v, dist[v]);
for (auto e : adj[v]) {
int u = e.first;
w = e.second;
if (present[u] and dist[u] > dist[v] + 1LL * w) {
s.erase({dist[u], u});
dist[u] = dist[v] + 1LL * w;
s.insert({dist[u], u});
}
}
}
if (dist[n - 1] == MAX) {
cout << -1 << endl;
} else {
cout << dist[n - 1] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5;
int n;
int dp[maxN], ans[maxN];
vector<pair<pair<int, int>, int> > vec;
int nxt[maxN];
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
vec.push_back({{a, b}, i});
}
sort(vec.begin(), vec.end());
dp[vec.size() - 1] = 1;
ans[vec[vec.size() - 1].second] = 1;
for (int i = vec.size() - 2; i >= 0; i--) {
dp[i] = 1;
for (int j = i + 1; j < vec.size(); j += nxt[j] + 1) {
if (vec[i].first.first + vec[i].first.second - 1 >= vec[j].first.first) {
dp[i] = max(dp[i], j - i + dp[j]);
nxt[i] += nxt[j] + 1;
} else
break;
}
ans[vec[i].second] = dp[i];
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
}
| 7 |
#include <bits/stdc++.h>
const double PI = 3.14;
using namespace std;
void R() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const double EPS = 1e-6;
const int N = 1e7 + 3;
int DCNP(double a, double b) {
if (fabs(a - b) < EPS) return 0;
return (a < b ? -1 : 1);
}
int gcd(int x, int y) { return (!y) ? x : gcd(y, x % y); }
int main() {
R();
int a, b, q, m, n;
cin >> a >> b >> q;
vector<int> ans;
n = gcd(a, b);
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
ans.push_back(i);
m = n / i;
if (i != m && n % m == 0) ans.push_back(m);
}
}
sort(ans.begin(), ans.end());
while (q--) {
int l, r;
cin >> l >> r;
auto it = upper_bound(ans.begin(), ans.end(), r) - ans.begin();
--it;
if (it >= 0 && it < ans.size() && ans[it] >= l && ans[it] <= r)
cout << ans[it] << "\n";
else
cout << "-1\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int MAXV = 5000 * 5000 * 2, k;
int pr[] = {2, 3, 5, 7, 11, 13, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61}, n;
vector<int> d;
void go(int i, int x, int N) {
if (i == N) {
d.push_back(x);
return;
}
while (x <= MAXV) go(i + 1, x, N), x *= pr[i];
}
int main() {
scanf("%d", &k);
MAXV = k * k * 2;
n = sizeof(pr) / 4;
for (int i = 0; i < n; ++i) {
d.clear();
go(0, 1, i + 1);
if ((int)d.size() < 2 * k) continue;
sort(d.begin(), d.end());
for (vector<int>::reverse_iterator it = d.rbegin(); k; ++it, --k)
printf("%d ", *it);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int inclus(int n, int* t, int m) {
int i;
for (i = 0; i < m; i++) {
if (t[i] == n) return 1;
}
return 0;
}
int main() {
int n, m, i;
scanf("%d %d", &n, &m);
int s[10], t[10];
for (i = 0; i < n; i++) {
scanf("%d", &s[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &t[i]);
}
for (i = 0; i < n; i++) {
if (inclus(s[i], t, m)) printf("%d ", s[i]);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int solve();
void precomp();
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
if (0) cin >> t;
precomp();
while (t--) solve();
}
void precomp() { return; }
int n;
vector<pair<int, int> > v[200005];
int l[200005], r[200005], ans[200005];
priority_queue<pair<int, int> > pq;
vector<pair<int, int> > swp;
int solve() {
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
l[i] = a, r[i] = b;
v[a].push_back({b, i});
}
for (int i = 1; i <= n; i++) {
for (pair<int, int> j : v[i]) pq.push({-j.first, j.second});
int nw = pq.top().second;
pq.pop();
ans[nw] = i;
if (!pq.empty()) swp.push_back({nw, pq.top().second});
}
for (pair<int, int> i : swp) {
swap(ans[i.first], ans[i.second]);
if (l[i.first] <= ans[i.first] && ans[i.first] <= r[i.first] &&
l[i.second] <= ans[i.second] && ans[i.second] <= r[i.second]) {
cout << "NO\n";
for (int j = 0; j < n; j++) cout << ans[j] << " ";
cout << endl;
swap(ans[i.first], ans[i.second]);
for (int j = 0; j < n; j++) cout << ans[j] << " ";
cout << endl;
return 0;
}
swap(ans[i.first], ans[i.second]);
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 75;
const int INF = numeric_limits<int>::max();
void read(int &x) {
x = 0;
char ch = getchar();
int f = 1;
while (!isdigit(ch)) (ch == '-' ? f = -1 : 0), ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
void upd(long long &x, long long y) { x += y; }
int n, h;
long long ans, f[40][40][40], c[N][N];
signed main() {
read(n);
read(h);
for (int i = 0; i <= n; ++i) c[i][0] = 1;
for (int i = 1; i <= n << 1; ++i)
for (int j = 1; j <= n << 1; ++j) c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
f[1][1][1] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 1; k <= n; ++k) {
if (j == n && i >= h) ans += f[i][j][k];
for (int x = min(n - j, k * 2); x; --x) {
upd(f[i + 1][j + x][x], f[i][j][k] * c[2 * k][x]);
}
}
printf("%I64d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main(int argc, char *argv[]) {
char str[105];
int n, m, ret[105], i, j;
scanf("%d\n%s", &n, str + 1);
str[0] = str[++n] = 'W';
for (i = 1, j = 0, m = 0; i <= n; ++i) {
if (str[i] != str[i - 1]) {
if (str[j] == 'B') ret[++m] = i - j;
j = i;
}
}
printf("%d\n", m);
for (i = 1; i <= m; ++i) {
printf("%d%c", ret[i], i < m ? ' ' : '\n');
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> prime_disvor;
for (long long p = 2; p * p <= n; p++) {
if (n % p == 0) {
prime_disvor.push_back(p);
}
while (n % p == 0) {
n /= p;
}
}
if (n > 1) {
prime_disvor.push_back(n);
}
if (prime_disvor.size() == 1) {
cout << prime_disvor.front() << endl;
} else if (prime_disvor.size() > 1) {
cout << 1 << endl;
} else {
cout << n << endl;
}
return 0;
}
| 3 |
// did we make our happiness costly or we are greedy
#include<bits/stdc++.h>
using namespace std;
//faster
#define faster \
ios_base::sync_with_stdio(false);\
cin.tie(NULL); \
cout.tie(NULL); \
cerr.tie(NULL);
#define LL long long // LL long long
#define N "\n" // N "\"
#define S " " // S " "
#define D " d\n"
#define PII pair<int,int> // PII pair<int,int>
#define PLL pair<long long, long long> // PLL pair<LL,LL>
#define TC int tc_; cin>>tc_; for(int tc=1; tc<=tc_;tc++ ) // TC tc
#define SZ(a) sizeof(a)/sizeof(a[0]) // SZ(a) sizeof(a)/sizeof(a[0])
#define LB(a,b,c) (lower_bound(a,b,c)-a) // LB(a,b,c) lower_bound(a,b,c)-a # >=c
#define UB(a,b,c) (upper_bound(a,b,c)-a) // UB(a,b,c) upper_bound(a,b,c)-a # >c
#define PC __builtin_popcount // PC __builtin_popcount
#define YES "YES\n" // YES "YES\n"
#define NOP "NO\n" // NO "NO\n"
#define SP(x) fixed << setprecision(x) // SP(x) fixed << setprecision(x)
// bool binary_search(begin , end , val , com)
template<typename T>
bool bs_com(T i, T j)
{
return i<j;
}
// sort(a,a+n,com_asc)
template<typename T> bool sort_asc (T a, T b)
{
return a.first<b.first;
}
template<typename T> bool sort_des (T a, T b)
{
return a>b;;
}
// priority_queue< T, vector<T>, pq_des > pq
struct pq_des
{
bool operator()(int const& p1, int const& p2)
{
return p1<p2;
}
};
struct pq_asc
{
bool operator()(int const& p1, int const& p2)
{
return p1>p2;
}
};
// vector< vector<int> > vec(10, vector<int> (5, -1) );
// LL -9*10^18->9*10^18
LL powm(LL a, LL b,LL mod)
{
// (a^b) %mod
LL res = 1;
while (b > 0)
{
if (b & 1)
res = (res * a) %mod;
a = (a * a) %mod;
b >>= 1;
}
return res;
}
bool is_prime(LL a)
{
for(LL i=2; i*i<=a; i++)
{
if(a%i==0)return false;
}
return true;
}
LL gcd(LL x, LL y)
{
return y?gcd(y, x%y):x;
}
LL lcm(LL x, LL y)
{
return x/gcd(x,y)*y;
}
//-###########################################THE##########################################################################################################################
//-###########################################COOK#########################################################################################################################
const int MX=5e6+16;
bitset<MX> has;
PII g[MX];
void solve()
{
int n;
cin>>n;
vector<int> a(n);
for(int i=0;i<n;i++)
{
cin>>a[i];
}
for(int i=1;i<n;i++)
{
for(int j=0; j<i ;j++)
{
int sum=a[i]+a[j];
if(!has[sum])
{
has[sum]=1;
g[sum]=make_pair(j,i);
}
else
{
if(i==g[sum].first || i==g[sum].second || j==g[sum].first || j==g[sum].second)
continue;
cout<<YES;
cout<<j+1<<S<<i+1<<S<<g[sum].first+1<<S<<g[sum].second+1<<N;
exit(0);
}
}
}
cout<<NOP;
}
void process()
{
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif // ONLINE_JUDGE
faster;
////////////////////////
//process();
solve();
return 0;
}
/*
never use "data" as variable name in cf
never use ceil() floor()
bit operation -> decimal*decimal , *= &(and) |(or) ^(xor)
bitset<32>(decimal or ascii) return binary digits
sort() O(nlogn) hybrid of quick,heap,insert, compare(i,j) - true->swap, i-latter, j-nearer
never use <= >= sign in sort.com always use < >
*/
| 5 |
#include <bits/stdc++.h>
struct link {
int data;
link *next;
};
void insert(int x, link *&l) {
link *p;
p = new link;
p->data = x;
p->next = l;
l = p;
}
void write(link *l) {
if (l != NULL) {
write(l->next);
printf("%d ", l->data);
}
}
int n, i, j, f[1001], x;
link *g[1001];
long long all;
int main() {
memset(f, 0, sizeof(f));
scanf("%d", &n);
all = 0;
for (i = 0; i <= 1000; i++) g[i] = NULL;
for (i = 1; i <= n; i++) {
scanf("%d", &x);
insert(i, g[x]);
f[x]++;
all += x;
}
if (f[all / n] == 0 || all / n != all * 1.0 / n) {
printf("0\n");
return 0;
}
all = all / n;
printf("%d\n", f[all]);
write(g[all]);
putchar('\n');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[101];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
vector<int> res;
for (int i = n - 1; i >= 0; --i) {
if (arr[i] > 0) res.push_back(arr[i]);
}
for (int i = 0; i < n - 1; i += 2) {
if (arr[i] < 0 && arr[i + 1] < 0) {
res.push_back(arr[i]);
res.push_back(arr[i + 1]);
}
}
if (res.size() == 0) {
res.push_back(arr[n - 1]);
}
for (int i = 0; i < res.size(); i++) {
cout << res[i];
if (i == res.size() - 1)
cout << "\n";
else
cout << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
ll n;
cin >> n;
if (n <= 3) {
cout << n << "\n";
continue;
}
ll shift = 1;
ll sum = n - 3;
ll p = 4;
while (sum > 3 * p) {
sum -= 3 * p;
shift++;
p = p * 4;
}
ll a = (ll)1 << (2 * shift);
ll b = (ll)2 << (2 * shift);
ll c = (ll)3 << (2 * shift);
shift--;
p = p / 4;
ll array[4][3] = {{0, 0, 0}, {1, 2, 3}, {2, 3, 1}, {3, 1, 2}};
int idx = sum % 3;
if (idx > 0) sum += (3 - idx);
sum = sum / 3;
while (shift >= 0) {
int i = 1;
while (sum > i * p) i++;
sum -= ((i - 1) * p);
a += (array[i - 1][0]) << (2 * shift);
b += (array[i - 1][1]) << (2 * shift);
c += (array[i - 1][2]) << (2 * shift);
p = p / 4;
shift--;
}
if (idx == 0)
idx = 2;
else
idx--;
if (idx == 0)
cout << a << "\n";
else if (idx == 1)
cout << b << "\n";
else
cout << c << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T BM(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
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 MDINV(T a, T M) {
return BM(a, M - 2, M);
}
template <class T>
inline T PW(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>
string NTS(T Number) {
stringstream ss;
ss << Number;
return ss.str();
}
template <class T>
T stringtonumber(const string &Text) {
istringstream ss(Text);
T result;
return ss >> result ? result : 0;
}
template <class T>
bool ISLEFT(T a, T b, T c) {
if (((a.first - b.first) * (b.second - c.second) -
(b.first - c.first) * (a.second - b.second)) < 0.0)
return 1;
else
return 0;
}
long long int ar[5005];
double ans[20000ll + 3];
void bit(long long int x, double val) {
while (x <= 20000ll) {
ans[x] += val;
x += x & -x;
}
}
double qu(long long int x) {
double ho = 0;
while (x > 0) {
ho += ans[x];
x -= (x & -x);
}
return ho;
}
int main() {
int n, m;
scanf("%d", &n);
int a[n + 2];
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
long long int res = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int x = a[j] - a[i];
ar[x]++;
res++;
}
}
for (int i = 1; i <= 5000; i++) {
for (int j = 1; j <= 5000; j++) {
long long int p = res * res;
long long int x = ar[i] * ar[j];
double co = (double)x / (double)p;
bit(i + j, co);
}
}
double sum = 0;
for (int i = 1; i <= 5000; i++) {
double xo = (double)ar[i] / (double)res;
double co = qu(i - 1);
sum += xo * co;
}
printf("%.10lf\n", sum);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int L, R;
cin >> L >> R;
L == R ? printf("%lld\n", R) : printf("2\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, cf = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') cf = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
if (cf < 0)
return -x;
else
return x;
}
int G[55];
template <class T>
inline void write(T x) {
int g = 0;
do {
G[++g] = x % 10;
x /= 10;
} while (x);
for (int i = g; i >= 1; --i) putchar('0' + G[i]);
putchar('\n');
}
int a[100010];
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int qwq = 0;
for (int i = 2; i <= n; i++) {
if (a[i] != a[i - 1]) {
qwq++;
}
}
if (k == 1) {
if (qwq == 0)
cout << 1 << endl;
else
cout << -1 << endl;
} else {
qwq++;
if (k >= qwq)
cout << 1 << endl;
else {
qwq -= k;
cout << 1 + qwq / (k - 1) + ((qwq % (k - 1)) ? 1 : 0) << endl;
}
}
}
return 0;
cout << "UUZ ate it." << endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
const int N = 200005;
map<long long, long long> dp;
long long a[N], n;
int main() {
scanf("%lld", &n);
for (register int i = 1; i <= n; i++) scanf("%lld", &a[i]);
dp[a[1] - 1] = 0;
for (register int i = 2; i <= n; i++) {
map<long long, long long>::iterator it = dp.lower_bound(a[i]);
for (; it != dp.end(); dp.erase(it++)) {
long long x = it->first, y = it->second;
ckmax(dp[x % a[i]], y + 1ll * (i - 1) * (x - x % a[i]));
ckmax(dp[a[i] - 1], y + 1ll * (i - 1) * ((x + 1) / a[i] - 1) * a[i]);
}
}
long long ans = 0;
map<long long, long long>::iterator it = dp.begin();
for (; it != dp.end(); it++) {
ckmax(ans, it->first * n + it->second);
}
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const long long MOD = 1000000007;
const double eps = 1e-10;
int a[MAXN];
int arrM[MAXN][MAXN];
int ask[MAXN];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i] == j) {
arrM[j][i] = arrM[j][i - 1] + 1;
} else
arrM[j][i] = arrM[j][i - 1];
}
}
for (int i = 1; i <= m; i++) {
scanf("%d", &ask[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
bool ok = true;
for (int k = 1; k <= m; k++) {
if (ask[k] != arrM[k][j] - arrM[k][i - 1]) {
ok = false;
break;
}
}
if (ok) {
puts("YES");
return 0;
}
}
}
puts("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
string s;
unordered_set<string> ans;
void rot2(string& t0, string& t) {
for (int i = 0; i < 4; i++) {
t0 = min(t0, t);
rotate(t.begin() + 2, t.begin() + 3, t.end());
}
}
void rot() {
string t = s, t0 = s;
for (int i = 0; i < 4; i++) {
rot2(t0, t);
char c = t[0];
t[0] = t[2];
t[2] = t[1];
t[1] = t[4];
t[4] = c;
}
for (int i = 0; i < 4; i++) {
rot2(t0, t);
char c = t[0];
t[0] = t[3];
t[3] = t[1];
t[1] = t[5];
t[5] = c;
}
ans.insert(t0);
}
void perm(int i) {
if (i == 6) {
rot();
return;
}
for (int j = i; j < 6; j++) {
swap(s[i], s[j]);
perm(i + 1);
swap(s[i], s[j]);
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
cin >> s;
perm(0);
cout << ans.size() << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int _w;
int n, cnt[N], mx, bound;
int dis(int a, int b, int c, int d) { return abs(a - c) + abs(b - d); }
int dc(int r, int c, int x, int y) {
int d = 0;
d = max(d, dis(1, 1, x, y));
d = max(d, dis(1, c, x, y));
d = max(d, dis(r, 1, x, y));
d = max(d, dis(r, c, x, y));
return d;
}
int tmp[N];
void add(int y, int v, int c) {
++tmp[v], --tmp[v + 1];
if (y != 1) ++tmp[v + 1], --tmp[v + y];
if (y != c) ++tmp[v + 1], --tmp[v + c - y + 1];
}
void check(int r, int c, int x, int y) {
if (x < 1 || y < 1 || x > r || y > c) return;
if (dc(r, c, x, y) != mx) return;
for (int i = 0; i <= mx; ++i) tmp[i] = 0;
add(y, 0, c);
for (int i = 1; x - i >= 1; ++i) add(y, i, c);
for (int i = 1; x + i <= r; ++i) add(y, i, c);
for (int i = 1; i <= mx; ++i) tmp[i] += tmp[i - 1];
bool flag = true;
for (int i = 0; i <= mx; ++i)
if (tmp[i] != cnt[i]) {
flag = false;
break;
}
if (flag) {
printf("%d %d\n", r, c);
printf("%d %d\n", x, y);
exit(0);
}
}
void solve(int r, int c) {
for (int i = 1; i <= c; ++i) {
check(r, c, bound, i);
check(r, c, r - bound + 1, i);
}
for (int i = 1; i <= r; ++i) {
check(r, c, i, bound);
check(r, c, i, c - bound + 1);
}
}
int main() {
_w = scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
_w = scanf("%d", &x);
++cnt[x];
mx = max(mx, x);
}
if (cnt[0] != 1) return puts("-1"), 0;
for (int i = 1;; ++i)
if (cnt[i] != i * 4) {
bound = i;
break;
}
for (int i = 1; i * i <= n; ++i)
if (n % i == 0) {
int j = n / i;
solve(i, j);
}
return puts("-1"), 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.