solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
namespace Suhaib_Templates {
using namespace std;
const long double PI = acos(-1);
const int di[8] = {0, 0, 1, -1, 1, 1, -1, -1};
const int dj[8] = {1, -1, 0, 0, 1, -1, 1, -1};
long long FirstTrue(long long l, long long r, function<bool(long long)> f) {
while (l < r) {
long long mid = l + (r - l) / 2;
f(mid) ? r = mid : l = mid + 1;
}
return l;
}
long long LastTrue(long long l, long long r, function<bool(long long)> f) {
while (l < r) {
long long mid = l + (r - l + 1) / 2;
f(mid) ? l = mid : r = mid - 1;
}
return l;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
template <class T>
void re(complex<T>& x);
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
void re(long double& x) {
string t;
re(t);
x = stold(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T>
void re(complex<T>& x) {
T a, b;
re(a, b);
x = cd(a, b);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.f, p.s);
}
template <class T>
void re(vector<T>& a) {
for (int i = (0); i < ((int)a.size()); i += (1)) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = (0); i < (SZ); i += (1)) re(a[i]);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr(x.first, ' ', x.second);
}
template <class T>
void prContain(const T& x) {
for (auto& a : x) pr(a, ' ');
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { cout << '\n'; }
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
} // namespace Suhaib_Templates
using namespace Suhaib_Templates;
int n, m;
char c[50][50];
int visited[50][50], vid;
bool valid(int i, int j) {
return i >= 0 && i < n && j >= 0 && j < m && visited[i][j] ^ vid &&
c[i][j] ^ '.';
}
void dfs(int i, int j) {
visited[i][j] = vid;
for (int d = (0); d < (4); d += (1)) {
int ni = i + di[d], nj = j + dj[d];
if (valid(ni, nj)) {
dfs(ni, nj);
}
}
}
void f(int n) {
pr(n);
exit(0);
}
void Suhaib_Sawalha() {
re(n, m);
int cnt = 0;
for (int i = (0); i < (n); i += (1))
for (int j = (0); j < (m); j += (1)) {
re(c[i][j]);
cnt += c[i][j] == '#';
}
if (cnt <= 2) f(-1);
for (int i = (0); i < (n); i += (1))
for (int j = (0); j < (m); j += (1)) {
if (c[i][j] ^ '#') continue;
c[i][j] = '.';
++vid;
bool first = true;
for (int x = (0); x < (n); x += (1))
for (int y = (0); y < (m); y += (1)) {
if (c[x][y] ^ '.' && visited[x][y] ^ vid) {
if (first)
dfs(x, y);
else
f(1);
first = false;
}
}
c[i][j] = '#';
}
f(2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Suhaib_Sawalha();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s, ans;
char tab[1000007];
int main() {
cin >> s;
int cnt(0);
for (int i = 0; i < s.size(); i++) {
if (cnt == 0) {
tab[cnt] = s[i];
cnt++;
} else {
if (tab[cnt - 1] == s[i])
cnt--;
else {
tab[cnt] = s[i];
cnt++;
}
}
}
for (int i = 0; i < cnt; i++) {
cout << tab[i];
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n > 2) {
cout << "2 10 ";
for (int i = 0; i < n - 2; i++) cout << "1 ";
} else
cout << (-1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[10], t, s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
a[s[i]] = -1;
}
for (int i = 0; i < m; i++) {
cin >> t;
if (a[t] == -1) a[t] = -2;
}
for (int i = 0; i < n; i++) {
if (a[s[i]] == -2) cout << s[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
struct SegmentTree {
struct Node {
bool hasCarry = 0;
int b = 0, e = 0;
U carry = U();
T val = T();
Node() {}
void join(const Node &l, const Node &r) {
val = l.val + r.val;
b = l.b;
e = r.e;
}
void update(const U &u) {
carry += u;
u(val);
hasCarry = 1;
}
void pushDown(Node &l, Node &r) {
if (!hasCarry) return;
l.update(carry.trim(0, r.e - r.b + 1));
r.update(carry.trim(l.e - l.b + 1, 0));
carry = U();
hasCarry = 0;
}
};
vector<Node> V;
int N;
SegmentTree(int N) : V(2 * N), N(N) {}
template <class I>
void create(const vector<I> &VEC, int b = 0, int e = -1) {
if (e == -1) e = N - 1;
int n = (((b) + (e)) | ((b) != (e)));
if (b == e) {
V[n].val = T(VEC[b]), V[n].b = b, V[n].e = e;
} else {
int m = (b + e) / 2;
create(VEC, b, m);
create(VEC, m + 1, e);
V[n].join(V[(((b) + (m)) | ((b) != (m)))],
V[(((m + 1) + (e)) | ((m + 1) != (e)))]);
}
}
T query(int i, int j, int b = 0, int e = -1) {
if (e == -1) e = N - 1;
int n = (((b) + (e)) | ((b) != (e)));
if (i <= b && e <= j) {
return V[n].val;
} else {
int m = (b + e) / 2;
V[n].pushDown(V[(((b) + (m)) | ((b) != (m)))],
V[(((m + 1) + (e)) | ((m + 1) != (e)))]);
if (i > m) return query(i, j, m + 1, e);
if (j <= m) return query(i, j, b, m);
return query(i, j, b, m) + query(i, j, m + 1, e);
}
}
void update(int i, int j, const U &v, int b = 0, int e = -1) {
if (e == -1) e = N - 1;
int n = (((b) + (e)) | ((b) != (e)));
if (i <= b && e <= j) {
V[n].update(v.trim(max(b - i, 0), max(j - e, 0)));
} else if (i > e || j < b)
return;
else {
int m = (b + e) / 2;
int l = (((b) + (m)) | ((b) != (m))),
r = (((m + 1) + (e)) | ((m + 1) != (e)));
V[n].pushDown(V[l], V[r]);
update(i, j, v, b, m);
update(i, j, v, m + 1, e);
V[n].join(V[l], V[r]);
}
}
};
struct Min {
int mi;
Min(int v = 2000000000) { mi = v; }
Min operator+(const Min &a) const {
Min r;
r.mi = min(mi, a.mi);
return r;
}
};
struct Replace {
int v;
Replace(int v = 0) : v(v) {}
Replace trim(int l, int r) const { return *this; }
void operator+=(const Replace &a) { v = a.v; }
void operator()(Min &a) const { a.mi = v; }
};
template <class Data>
struct HLD {
vector<int> P, LVL, SZ, PC;
vector<vector<int>> adj;
vector<vector<int>> groups;
vector<int> groupId;
vector<int> groupPos;
vector<SegmentTree<Min, Replace>> ST;
int N;
HLD(vector<vector<int>> adj, vector<Data> D) : adj(adj) {
N = adj.size();
P = PC = vector<int>(N, -1);
LVL = SZ = groupId = groupPos = vector<int>(N, -1);
for (int i = 0; i < N; ++i) {
if (groupId[i] == -1) {
if (SZ[i] == -1) initDfs(i);
groups.push_back(vector<int>());
vector<Data> V;
for (int j = i; j != -1; j = PC[j]) {
groups.back().push_back(j);
groupId[j] = groups.size() - 1;
groupPos[j] = groups.back().size() - 1;
V.push_back(D[j]);
}
ST.emplace_back(groups.back().size());
ST.back().create(V);
}
}
}
void initDfs(int u, int level = 0) {
LVL[u] = level;
SZ[u] = 1;
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (SZ[v] != -1) continue;
P[v] = u;
initDfs(v, level + 1);
SZ[u] += SZ[v];
}
for (int v : adj[u])
if (v != P[u] && SZ[v] * 2 > SZ[u] - 1) PC[u] = v;
}
int LCA(int u, int v) {
while (u != v && u != -1 && v != -1) {
if (LVL[v] < LVL[u]) swap(u, v);
if (groupId[u] == groupId[v]) return u;
bool vGoesUp = LVL[groups[groupId[u]][0]] < LVL[groups[groupId[v]][0]];
(vGoesUp ? v : u) = P[groups[groupId[(vGoesUp ? v : u)]][0]];
}
return u == v ? v : -1;
}
void update(int u, int v, int val, int debug = 0) {
while (u != v && u != -1 && v != -1) {
if (groupId[u] == groupId[v]) {
int pu = groupPos[u], pv = groupPos[v];
int g = groupId[u];
if (LVL[u] < LVL[v]) {
ST[g].update(pu + 1, pv, val);
} else {
ST[g].update(pv + 1, pu, val);
}
break;
}
if (LVL[groups[groupId[u]][0]] < LVL[groups[groupId[v]][0]]) {
int g = groupId[v], p = groupPos[v];
ST[g].update(0, p, val);
v = P[groups[g][0]];
} else {
int g = groupId[u], p = groupPos[u];
ST[g].update(0, p, val);
u = P[groups[g][0]];
}
}
}
Min path(int u, int v, int debug = 0) {
Min A, B;
while (u != v && u != -1 && v != -1) {
if (groupId[u] == groupId[v]) {
int pu = groupPos[u], pv = groupPos[v];
if (debug) cout << "same: " << pu << " " << pv << endl;
int g = groupId[u];
if (LVL[u] < LVL[v]) {
B = ST[g].query(pu + 1, pv) + B;
} else {
A = ST[g].query(pv + 1, pu) + A;
}
break;
}
if (LVL[groups[groupId[u]][0]] < LVL[groups[groupId[v]][0]]) {
int g = groupId[v], p = groupPos[v];
B = ST[g].query(0, p) + B;
if (debug) cout << v << "-->" << P[groups[g][0]] << endl;
v = P[groups[g][0]];
} else {
int g = groupId[u], p = groupPos[u];
A = ST[g].query(0, p) + A;
if (debug) cout << u << "-->" << P[groups[g][0]] << endl;
u = P[groups[g][0]];
}
}
return A + B;
}
};
vector<long long> A;
bool bf(int p, int u, int fv, vector<vector<int>> &adj,
vector<vector<int>> &dis) {
if (u == fv) return true;
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (v == p) continue;
if (bf(u, v, fv, adj, dis)) {
A.push_back(dis[u][i]);
return true;
}
}
return false;
}
struct DisjointSet {
vector<int> P;
DisjointSet(int N) : P(N, -1) {}
int find(int x) { return P[x] < 0 ? x : (P[x] = find(P[x])); }
bool join(int x, int y) {
if ((x = find(x)) == (y = find(y))) return false;
if (P[y] < P[x]) swap(x, y);
P[x] += P[y];
P[y] = x;
return true;
}
};
struct Edge {
int i, j, id, c;
bool operator<(const Edge e) const { return c < e.c; }
};
int main() {
int N, K, M;
cin >> N >> K >> M;
vector<Edge> O1(M), O2(K);
for (int i = 0; i < K; ++i) {
Edge &e = O2[i];
scanf("%d%d", &e.i, &e.j);
e.c = 0;
e.i--;
e.j--;
e.id = i;
}
for (int i = 0; i < M; ++i) {
Edge &e = O1[i];
scanf("%d%d%d", &e.i, &e.j, &e.c);
e.i--;
e.j--;
e.id = i;
}
sort(O1.begin(), O1.end());
sort(O2.begin(), O2.end());
DisjointSet DS(N);
vector<int> U(M);
for (Edge e : O2) {
DS.join(e.i, e.j);
}
long long ans = 0;
for (Edge e : O1) {
if (DS.join(e.i, e.j)) {
U[e.id] = 1;
}
}
reverse(O1.begin(), O1.end());
vector<vector<int>> adj(N);
for (Edge e : O2) {
DS.join(e.i, e.j);
adj[e.i].push_back(e.j);
adj[e.j].push_back(e.i);
}
set<pair<int, int>> S;
for (Edge e : O1) {
if (!U[e.id]) continue;
adj[e.i].push_back(e.j);
adj[e.j].push_back(e.i);
S.insert(make_pair(min(e.i, e.j), max(e.i, e.j)));
}
HLD<int> H(adj, vector<int>(N, 2000000000));
for (Edge e : O1) {
if (U[e.id]) continue;
int lc = H.LCA(e.i, e.j);
if (lc != -1) {
H.update(e.i, e.j, e.c);
}
}
for (int i = 0; i < N; ++i) {
if (H.P[i] != -1) {
if (S.count(make_pair(min(i, H.P[i]), max(i, H.P[i])))) continue;
int t = H.path(i, H.P[i]).mi;
if (t >= 2000000000) {
cout << -1 << endl;
return 0;
}
ans += t;
}
}
cout << ans << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans, len;
int main() {
cin >> n >> k;
ans = (n - 1) / k;
len = ans * 2;
if ((n - 1) % k <= 2)
len += ((n - 1) % k);
else
len += 2;
cout << len << endl;
for (int i = 2; i <= k + 1; ++i) cout << 1 << " " << i << endl;
for (int i = k + 2; i <= n; ++i) cout << i << " " << i - k << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
const int MAX_N = 2e5 + 10;
int a[MAX_N], c[MAX_N];
void init(int n) {
for (int i = 0; i <= n; i++) {
a[i] = 0;
c[i] = 0;
}
}
void solve() {
int n;
cin >> n;
init(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
int r = i, l;
if (a[i] > i) {
l = -1;
} else {
l = i - a[i];
}
l++;
c[l] += 1;
c[r + 1] -= 1;
}
}
for (int i = 1; i < n; i++) {
c[i] = c[i] + c[i - 1];
}
for (int i = 0; i < n; i++) {
if (c[i] > 0) {
cout << 1 << " ";
} else {
cout << 0 << " ";
}
}
cout << endl;
}
int main() {
ios::sync_with_stdio();
int T;
cin >> T;
while (T--) solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6;
long long a[N], m, w, h, n, H;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
cin >> m;
for (int i = 1; i <= m; i++) {
long long w, h;
scanf("%I64d%I64d", &w, &h);
long long ans = max(H, a[w]);
printf("%I64d\n", ans);
H = ans + h;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, k, mod, ans;
int inv[N], sum[N];
map<int, int> cnt;
map<int, int>::iterator it1, it2;
int read() {
int ret = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 0;
c = getchar();
}
while (isdigit(c)) ret = ret * 10 + (c ^ 48), c = getchar();
return f ? ret : -ret;
}
void up(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
int qpow(int x, int y) {
int res = 1;
x %= mod;
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1) res = (long long)res * x % mod;
return res;
}
void init() {
n = read();
k = read();
mod = read();
for (int i = 1; i < N; ++i)
sum[i] = inv[i] = qpow(i, mod - 2), up(sum[i], sum[i - 1]);
}
void divide(int l, int r, int dp) {
if (dp <= 1 || l == r) {
cnt[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
divide(l, mid, dp - 1);
divide(mid + 1, r, dp - 1);
}
int calc(int x, int y) {
int res = (long long)x * y % mod;
for (int i = 1; i <= x; ++i) up(res, -(sum[i + y] - sum[i]) * 2 % mod);
return res;
}
void solve() {
for (it1 = cnt.begin(); it1 != cnt.end(); ++it1) {
int t = it1->first, s = it1->second;
up(ans, (long long)t * (t - 1) % mod * inv[2] % mod * s % mod);
up(ans, (long long)s * (s - 1) % mod * inv[2] % mod * calc(t, t) % mod);
}
for (it1 = cnt.begin(); it1 != cnt.end(); ++it1)
for (it2 = cnt.begin(); it2 != cnt.end(); ++it2) {
int x = it1->first, y = it2->first;
if (x >= y) continue;
up(ans, (long long)calc(x, y) * it1->second % mod * it2->second % mod);
}
printf("%d\n", (long long)ans * inv[2] % mod);
}
int main() {
init();
divide(1, n, k);
solve();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int isPrime(long long int n) {
if (n < 2) return 0;
if (n < 4) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (int i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
long long int c[10], c1[10];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n, m, i, j, q = 1, ans = INT_MAX, k;
string s1, s2;
cin >> s1 >> s2;
n = s2.length();
m = s1.length();
for (i = 0; i < n; i++) c[s2[i] - '0']++;
c[2] = c[5] = c[2] + c[5];
c[6] = c[9] = c[6] + c[9];
for (i = 0; i < m; i++) c1[s1[i] - '0']++;
c1[2] = c1[5] = c1[2] + c1[5];
c1[6] = c1[9] = c1[6] + c1[9];
for (i = 0; i < 10; i++) {
if (c1[i]) ans = min(ans, c[i] / c1[i]);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
inline void add(int &x, const int y) { (x += y) >= mod && (x -= mod); }
inline int Add(int x, const int y) { return add(x, y), x; }
inline void sub(int &x, const int y) { (x -= y) < 0 && (x += mod); }
inline int Sub(int x, const int y) { return sub(x, y), x; }
inline void mul(int &x, const int y) { x = 1ll * x * y % mod; }
inline int Mul(const int x, const int y) { return 1ll * x * y % mod; }
inline int power(int a, int b, int c = 1) {
for (; b; b >>= 1, mul(a, a))
if (b & 1) mul(c, a);
return c;
}
const int N = (1 << 18) + 5;
int inv[N], fac[N], ifac[N];
inline void init(int n) {
for (int i = 0; i < 2; ++i) inv[i] = fac[i] = ifac[i] = 1;
for (int i = 2; i <= n; ++i) {
inv[i] = Mul(mod - mod / i, inv[mod % i]);
fac[i] = Mul(fac[i - 1], i);
ifac[i] = Mul(ifac[i - 1], inv[i]);
}
}
inline void dft(int *a, int n) {
for (int i = 0, j = 0; i < n; ++i) {
if (i < j) swap(a[i], a[j]);
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (int k = 1; k < n; k <<= 1) {
int wn = power(3, (mod - 1) / (k << 1));
for (int i = 0; i < n; i += k << 1)
for (int w = 1, j = 0; j < k; ++j, mul(w, wn)) {
int tmp = Mul(w, a[i + j + k]);
a[i + j + k] = Sub(a[i + j], tmp);
add(a[i + j], tmp);
}
}
}
inline void idft(int *a, int n) {
reverse(a + 1, a + n), dft(a, n);
int coef = power(n, mod - 2);
for (int i = 0; i < n; ++i) mul(a[i], coef);
}
inline std::vector<int> operator*(const std::vector<int> &a,
const std::vector<int> &b) {
static int x[N], y[N];
int len = a.size() + b.size() - 1, n = 1;
while (n < len) n <<= 1;
for (int i = 0; i < n; ++i)
x[i] = i < a.size() ? a[i] : 0, y[i] = i < b.size() ? b[i] : 0;
dft(x, n), dft(y, n);
for (int i = 0; i < n; ++i) mul(x[i], y[i]);
idft(x, n);
std::vector<int> c(len);
for (int i = 0; i < len; ++i) c[i] = x[i];
return c;
}
inline void read(std::vector<int> &a, int n) {
a.resize(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
}
inline void print(const std::vector<int> &a) {
for (int i = 0; i < a.size(); ++i)
printf("%d%c", a[i], i == a.size() - 1 ? '\n' : ' ');
}
int n;
long long m;
inline void trans(std::vector<int> f, std::vector<int> &g, int d) {
for (int i = 0; i <= n; ++i) mul(f[i], fac[i]);
reverse(f.begin(), f.end());
std::vector<int> h(n + 1);
for (int i = 0, p = 1; i <= n; ++i) h[i] = Mul(p, ifac[i]), mul(p, d);
g = f * h, g.resize(n + 1), reverse(g.begin(), g.end());
for (int i = 0; i <= n; ++i) mul(g[i], ifac[i]);
}
int main() {
scanf("%d%lld", &n, &m), m %= mod - 1, init(n + 1);
std::vector<int> f, g;
read(f, n + 1), trans(f, g, 1);
for (int i = 0; i <= n; ++i) mul(g[i], power(inv[i + 1], m));
trans(g, f, mod - 1), print(f);
return 0;
}
| 11 |
#include <bits/stdc++.h>
struct Area {
int l, r;
int lzt;
int has[30];
} p[200000];
int n, q;
int a[200000];
int blg[200000];
int tmp[30];
char cmd[1000000];
bool cmp(int x, int y) { return x < y; }
bool cmq(int x, int y) { return x > y; }
void P_sort(int x) {
if (!p[x].lzt) return;
if (p[x].lzt == 1) {
int t = 1;
for (int i = p[x].l; i <= p[x].r; i++) {
while (!p[x].has[t]) t++;
a[i] = t;
p[x].has[t]--;
}
}
if (p[x].lzt == -1) {
int t = 26;
for (int i = p[x].l; i <= p[x].r; i++) {
while (!p[x].has[t]) t--;
a[i] = t;
p[x].has[t]--;
}
}
p[x].lzt = 0;
return;
}
void build(int x) {
for (int i = 1; i <= 26; i++) p[x].has[i] = 0;
for (int i = p[x].l; i <= p[x].r; i++) p[x].has[a[i]]++;
return;
}
int main() {
scanf("%d%d", &n, &q);
if (n <= 1000) {
scanf("%s", cmd + 1);
for (int i = 1; i <= n; i++) a[i] = cmd[i] - 'a' + 1;
for (int i = 1; i <= q; i++) {
int l, r, op;
scanf("%d%d%d", &l, &r, &op);
if (l > r) std::swap(l, r);
if (op == 0)
std::sort(a + l, a + r + 1, cmq);
else
std::sort(a + l, a + r + 1, cmp);
}
for (int i = 1; i <= n; i++) printf("%c", a[i] + 'a' - 1);
puts("");
return 0;
}
scanf("%s", cmd + 1);
int stan = (sqrt(n));
for (int i = 1; i <= n; i++) {
a[i] = cmd[i] - 'a' + 1;
blg[i] = i / stan + 1;
p[blg[i]].has[a[i]]++;
if (blg[i] != blg[i - 1]) {
p[blg[i]].l = i;
p[blg[i - 1]].r = i - 1;
}
}
p[blg[n]].r = n;
while (q--) {
int l, r, op;
scanf("%d%d%d", &l, &r, &op);
if (l > r) std::swap(l, r);
if (blg[l] == blg[r]) {
if (op == 0)
std::sort(a + l, a + r + 1, cmq);
else
std::sort(a + l, a + r + 1, cmp);
continue;
}
memset(tmp, 0, sizeof(tmp));
P_sort(blg[l]);
build(blg[l]);
P_sort(blg[r]);
build(blg[r]);
for (int i = l; i <= p[blg[l]].r; i++) tmp[a[i]]++;
for (int i = p[blg[r]].l; i <= r; i++) tmp[a[i]]++;
for (int i = 1; i <= 26; i++)
for (int j = blg[l] + 1; j <= blg[r] - 1; j++) tmp[i] += p[j].has[i];
if (op == 0) {
int t = 26;
for (int i = l; i <= p[blg[l]].r; i++) {
while (!tmp[t]) t--;
tmp[t]--;
a[i] = t;
}
build(blg[l]);
for (int i = blg[l] + 1; i <= blg[r] - 1; i++) {
int len = p[i].r - p[i].l + 1;
for (int j = 1; j <= 26; j++) p[i].has[j] = 0;
while (tmp[t] < len) {
p[i].has[t] += tmp[t];
len -= tmp[t];
tmp[t] = 0;
t--;
}
if (len) {
p[i].has[t] += len;
tmp[t] -= len;
if (!tmp[t]) t--;
}
p[i].lzt = -1;
}
for (int i = p[blg[r]].l; i <= r; i++) {
while (!tmp[t]) t--;
tmp[t]--;
a[i] = t;
}
build(blg[r]);
} else {
int t = 1;
for (int i = l; i <= p[blg[l]].r; i++) {
while (!tmp[t]) t++;
tmp[t]--;
a[i] = t;
}
build(blg[l]);
for (int i = blg[l] + 1; i <= blg[r] - 1; i++) {
int len = p[i].r - p[i].l + 1;
for (int j = 1; j <= 26; j++) p[i].has[j] = 0;
while (tmp[t] < len) {
p[i].has[t] += tmp[t];
len -= tmp[t];
tmp[t] = 0;
t++;
}
if (len) {
p[i].has[t] += len;
tmp[t] -= len;
if (!tmp[t]) t++;
}
p[i].lzt = 1;
}
for (int i = p[blg[r]].l; i <= r; i++) {
while (!tmp[t]) t++;
tmp[t]--;
a[i] = t;
}
build(blg[r]);
}
}
for (int i = 1; i <= blg[n]; i++) P_sort(i);
for (int i = 1; i <= n; i++) printf("%c", a[i] + 'a' - 1);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int medias, compra, dias = 0;
cin >> medias >> compra;
while (medias > 0) {
medias = medias - 1;
dias = dias + 1;
if (dias % compra == 0) medias = medias + 1;
}
cout << dias;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (c == d) {
if (a >= c && b >= c && (a != c || b != c)) {
if (a - c == 0) {
cout << 7;
} else {
for (long long i = 0; i < a - c - 1; i++) {
cout << 4;
}
}
for (long long i = 0; i < c; i++) {
cout << 47;
}
if (a - c == 0) {
for (long long i = 0; i < b - c - 1; i++) {
cout << 7;
}
} else {
for (long long i = 0; i < b - c; i++) {
cout << 7;
}
cout << 4;
}
} else {
cout << -1;
}
} else if (c > d && c - d == 1 && a >= c && b >= c) {
for (long long i = 0; i < a - c; i++) cout << 4;
for (long long i = 0; i < c; i++) {
cout << 47;
}
for (long long i = 0; i < b - c; i++) cout << 7;
} else if (d > c && d - c == 1 && a >= d && b >= d) {
for (long long i = 0; i < d; i++) {
cout << 74;
if (i == 0) {
for (long long i = 0; i < a - d; i++) {
cout << 4;
}
}
if (i == d - 2) {
for (long long i = 0; i < b - d; i++) {
cout << 7;
}
}
}
} else {
cout << -1;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k = 1, n, m, a, i, j = 1;
bool t = true;
char c, h;
cin >> c;
while (cin >> h) {
if (h == c)
if (k != 5)
k++;
else {
k = 1;
j++;
}
else {
k = 1;
j++;
c = h;
}
}
cout << j;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int main() {
cin >> s >> t;
int ns = s.size();
int nt = t.size();
int ans = nt;
int i, j;
for (i = -nt; i < ns; i++) {
int now = nt;
for (j = 0; j < nt; j++) {
if (i + j >= 0 && i + j < ns && s[i + j] == t[j]) {
now--;
}
}
ans = min(ans, now);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool a[2001][2001], w[2001][2001];
int n, fi, fj, si, sj, dist, s, clr = 4;
inline bool val(int x, int y) { return (x > 0 && y > 0 && x < n && y < n); }
inline void clear(int x, int y) {
s = 0;
for (int i = 0; i < clr; i++)
for (int j = 0; j < clr; j++)
if (a[i + x][j + y]) s++;
if (s <= clr)
for (int i = 0; i < clr; i++)
for (int j = 0; j < clr; j++) a[i + x][j + y] = 0;
}
void dfs(int x, int y) {
w[x][y] = 1;
s++;
if (((x - fi) * (x - fi)) + ((y - fj) * (y - fj)) > dist)
dist = ((x - fi) * (x - fi)) + ((y - fj) * (y - fj));
if (val(x - 1, y) && a[x - 1][y] && !w[x - 1][y]) dfs(x - 1, y);
if (val(x + 1, y) && a[x + 1][y] && !w[x + 1][y]) dfs(x + 1, y);
if (val(x, y - 1) && a[x][y - 1] && !w[x][y - 1]) dfs(x, y - 1);
if (val(x, y + 1) && a[x][y + 1] && !w[x][y + 1]) dfs(x, y + 1);
}
int main() {
ios_base::sync_with_stdio(0);
int i, j, x, as = 0, ac = 0;
cin >> n;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) cin >> a[i][j];
for (i = 0; i < n; i += clr)
for (j = 0; j < n; j += clr) clear(i, j);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (!w[i][j] && a[i][j]) {
dist = s = 0;
fi = i, fj = j;
dfs(i, j);
if (dist < 200.0) {
a[i][j] = 0;
continue;
}
s *= 1.2;
double d = sqrt(dist), sq = ((d / sqrt(2.0)) * (d / sqrt(2.0))),
circ = ((d / 2.0) * (d / 2.0)) * M_PI;
if (abs(s - sq) < abs(s - circ))
as++;
else
ac++;
}
cout << ac << ' ' << as;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int q;
cin >> q;
while (q--) {
long long int n;
cin >> n;
cout << n - 1 << " " << 1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int maxn = 1e3 + 5;
string s[maxn];
char c[maxn][maxn];
int a[maxn];
map<char, int> mp;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c[i][j];
}
}
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
}
int maxn = -1;
long long ans = 0;
for (int i = 1; i <= m; i++) {
maxn = -1;
for (int j = 1; j <= n; j++) {
mp[c[j][i]]++;
maxn = max(maxn, mp[c[j][i]]);
}
mp['A'] = 0;
mp['B'] = 0;
mp['C'] = 0;
mp['D'] = 0;
mp['E'] = 0;
ans += a[i] * maxn;
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, m, min, max, a[109];
cin >> n;
cin >> m;
cin >> min;
cin >> max;
for (i = 0; i < m; i++) cin >> a[i];
int flag = 1;
sort(a, a + m);
if (a[0] < min) flag = 0;
if (a[m - 1] > max) flag = 0;
if ((n == m) && (a[0] > min || a[m - 1] < max)) flag = 0;
if ((n == (m + 1)) && (a[0] > min && a[m - 1] < max)) flag = 0;
if (flag)
cout << "Correct" << endl;
else
cout << "Incorrect" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
inline int getint() {
int x = 0, p = 1;
char c = getchar();
while (c <= 32) c = getchar();
if (c == 45) p = -p, c = getchar();
while (c > 32) x = x * 10 + c - 48, c = getchar();
return x * p;
}
using namespace std;
const int N = 1e5 + 5;
int n, m, k, p, a[N], h[N];
pair<long long, int> f[N];
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
pq;
inline bool isgood(int x) {
if (f[x].first - 1ll * a[x] * (m - 1 - f[x].second) >= h[x]) return true;
return false;
}
bool check(long long mid) {
while (pq.size()) pq.pop();
for (int(i) = 0; (i) < (n); (i)++) {
f[i] = make_pair(mid, -1);
pq.push(make_pair(mid / a[i] - 1, i));
}
for (int(i) = 0; (i) < (m); (i)++) {
for (int(j) = 0; (j) < (k); (j)++) {
while (pq.size() && isgood(pq.top().second)) pq.pop();
if (pq.empty()) break;
pair<long long, int> u = pq.top();
pq.pop();
if (u.first < i) return false;
int id = u.second;
long long now = f[id].first - 1ll * (i - f[id].second) * a[id] + p;
f[id] = make_pair(now, i);
pq.push(make_pair(min(1ll * m, now / a[id] + i), id));
}
}
for (int(i) = 0; (i) < (n); (i)++)
if (!isgood(i)) return false;
return true;
}
int main() {
n = getint();
m = getint();
k = getint();
p = getint();
for (int(i) = 0; (i) < (n); (i)++) h[i] = getint(), a[i] = getint();
long long lb = 0, rb = (long long)1e13;
while (rb - lb > 1) {
long long mid = (lb + rb) >> 1;
if (check(mid))
rb = mid;
else
lb = mid;
}
cout << rb << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int c[N], a[N][N], na[N];
int n;
int go(int S) {
int t = n;
int u[N] = {}, remain = n;
while (remain) {
int change = 1;
while (change) {
change = 0;
for (int i = 1; i <= n; i++) {
if (c[i] != S || u[i]) continue;
int fail = 0;
for (int j = 0; j < na[i]; j++)
if (!u[a[i][j]]) {
fail = 1;
break;
}
if (!fail) {
change = 1;
u[i] = 1;
--remain;
}
}
}
if (remain) {
++t;
S = S % 3 + 1;
}
}
return t;
}
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) {
scanf("%d", &na[i]);
for (int j = 0; j < na[i]; j++) scanf("%d", &a[i][j]);
}
int ans = 1000000;
for (int i = 1; i <= 3; i++) ans = min(ans, go(i));
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int arr[1000];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
sort(arr, arr + n);
printf("%d\n", arr[n - 1] - arr[0] + 1 - n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
inline int read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
int n, m, i, j, a[100005];
int np[100005];
vector<int> p, f;
int excgcd(int n, int m, int &x, int &y) {
if (m == 0) {
x = 1;
y = 0;
return n;
}
int ans = excgcd(m, n % m, y, x);
y = y - n / m * x;
return ans;
}
int main() {
for (i = 2; i <= 100000; i++) {
if (!np[i]) {
p.push_back(i);
for (j = i + i; j <= 100000; j += i) {
np[j] = 1;
}
}
}
cin >> n;
int t = n;
for (i = 0; i < p.size() and (p[i] * p[i]) <= t; i++) {
while (t % p[i] == 0) {
f.push_back(p[i]);
t /= p[i];
}
}
if (t > 1) {
f.push_back(t);
}
sort(f.begin(), f.end());
f.resize(unique(f.begin(), f.end()) - f.begin());
if (f.size() < 2) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
while (true) {
int x = f[0], y = f[1], xx, yy;
excgcd(x, y, xx, yy);
xx *= -1;
yy *= -1;
xx += n / x;
while (xx < 0) {
xx += n / x;
yy -= n / y;
}
while (yy < 0) {
xx -= n / x;
yy += n / y;
}
if (xx >= 0 and yy >= 0) {
vector<int> s1, s2;
if (xx > 0) {
s1.push_back(xx);
s2.push_back(n / x);
}
if (yy > 0) {
s1.push_back(yy);
s2.push_back(n / y);
}
cout << s1.size() << endl;
for (i = 0; i < s1.size(); i++) {
cout << s1[i] << ' ' << s2[i] << endl;
}
return 0;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int a[N];
int l[N];
int r[N];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
if (i == 0) {
l[i] = n - 1;
r[i] = i + 1;
} else if (i == n - 1) {
l[i] = i - 1;
r[i] = 0;
} else {
l[i] = i - 1;
r[i] = i + 1;
}
}
bool yes = false;
for (int i = 0; i < 5000; i++) {
for (int i = 0; i < n; i++) {
if (i % 2) {
a[i] = r[a[i]];
} else {
a[i] = l[a[i]];
}
}
bool isOK = true;
for (int i = 0; i < n - 1; i++)
if (a[i] != a[i + 1] - 1) {
isOK = false;
break;
}
if (isOK) {
yes = true;
puts("Yes");
break;
}
}
if (!yes) puts("No");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 10;
int belong[MAXN], block, num, L[MAXN], R[MAXN];
int n, q;
long long int a[MAXN], b[MAXN];
struct Node {
long long int lazy, Bsum, lazyb;
} Bval[400];
void build() {
block = (int)sqrt(n + 0.5);
num = n / block;
if (n % block) {
num++;
}
for (int i = 1; i <= num; i++) {
Bval[i].Bsum = 0;
Bval[i].lazy = 0;
Bval[i].lazyb = 0;
L[i] = (i - 1) * block + 1;
R[i] = i * block;
}
R[num] = n;
for (int i = 1; i <= n; i++) {
belong[i] = ((i - 1) / block) + 1;
}
}
void modify(int st, int ed, int val) {
if (belong[st] == belong[ed]) {
if (Bval[belong[st]].lazy) {
for (int i = L[belong[st]]; i <= R[belong[st]]; i++) {
a[i] = Bval[belong[st]].lazy;
}
Bval[belong[st]].lazy = 0;
}
for (int i = st; i <= ed; i++) {
Bval[belong[st]].Bsum += abs(a[i] - val);
b[i] += abs(a[i] - val);
a[i] = val;
}
return;
}
if (Bval[belong[st]].lazy) {
for (int i = L[belong[st]]; i <= R[belong[st]]; i++) {
a[i] = Bval[belong[st]].lazy;
}
Bval[belong[st]].lazy = 0;
}
for (int i = st; i <= R[belong[st]]; i++) {
Bval[belong[st]].Bsum += abs(val - a[i]);
b[i] += abs(val - a[i]);
a[i] = val;
}
for (int i = belong[st] + 1; i < belong[ed]; i++) {
if (Bval[i].lazy) {
Bval[i].lazyb += abs(val - Bval[i].lazy);
Bval[i].Bsum += (1LL * abs(Bval[i].lazy - val) * (R[i] - L[i] + 1));
Bval[i].lazy = val;
} else {
for (int j = L[i]; j <= R[i]; j++) {
b[j] += abs(a[j] - val);
Bval[i].Bsum += abs(a[j] - val);
a[j] = val;
}
Bval[i].lazy = val;
}
}
if (Bval[belong[ed]].lazy) {
for (int i = L[belong[ed]]; i <= R[belong[ed]]; i++) {
a[i] = Bval[belong[ed]].lazy;
}
Bval[belong[ed]].lazy = 0;
}
for (int i = L[belong[ed]]; i <= ed; i++) {
Bval[belong[ed]].Bsum += abs(val - a[i]);
b[i] += abs(val - a[i]);
a[i] = val;
}
}
long long int query(int st, int ed) {
long long int ans = 0;
if (belong[st] == belong[ed]) {
for (int i = st; i <= ed; i++) {
ans += (b[i] + Bval[belong[st]].lazyb);
}
return ans;
}
for (int i = st; i <= R[belong[st]]; i++) {
ans += (b[i] + Bval[belong[st]].lazyb);
}
for (int i = belong[st] + 1; i < belong[ed]; i++) {
ans += Bval[i].Bsum;
}
for (int i = L[belong[ed]]; i <= ed; i++) {
ans += (b[i] + Bval[belong[ed]].lazyb);
}
return ans;
}
int main() {
while (~scanf("%d%d", &n, &q)) {
for (int i = 1; i <= n; i++) {
a[i] = i;
b[i] = 0;
}
build();
int type, l, r, v;
for (int i = 1; i <= q; i++) {
scanf("%d", &type);
if (type == 1) {
scanf("%d%d%d", &l, &r, &v);
modify(l, r, v);
} else {
scanf("%d%d", &l, &r);
printf("%lld\n", query(l, r));
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int rec(int a, int b, int c, int d, int m) {
if (a > b || c > d) return 0;
if (a > c || (a == c && b > d)) return rec(c, d, a, b, m);
if (b >= d) return 1 + d - c;
if (a == c) return 1 + b - a;
if (a > m) return rec(a - m, b - m, c - m, d - m, m / 2);
if (c > m) return rec(a, b, c - m, d - m, m);
if (d < m) return rec(a, b, c, d, m / 2);
if (b < m) return max(rec(a, b, c, m - 1, m / 2), rec(a, b, 1, d - m, m / 2));
return max(1 + b - c, rec(a, m - 1, 1, d - m, m / 2));
}
int main() {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", rec(a, b, c, d, 1 << 29));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Max_N(100050);
const int Max_M(300050);
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class I>
inline void gi(I &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) putc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io::gi;
using io::print;
using io::putc;
int N, M, U[Max_M], V[Max_M], W[Max_M];
inline int get(int p) { return p <= N ? 0 : W[p - N]; }
inline int cmax(int a, int b) { return get(a) > get(b) ? a : b; }
struct edge {
edge(int _p, int _w) : p(_p), w(_w) {}
int p, w;
inline bool operator<(const edge &b) const {
return make_pair(w, p) < make_pair(b.w, b.p);
}
};
set<edge> exist;
int Father[Max_N], Size[Max_N], odd;
int Get_Father(int x) {
return Father[x] == x ? x : Father[x] = Get_Father(Father[x]);
}
struct Splay {
int v, Max, size, Sum;
Splay *ch[2], *fa;
bool Rev;
};
Splay *null, *ver[Max_N], *edg[Max_M];
inline void newnode(Splay *&u, int v) {
u = new Splay();
u->v = u->Max = v, u->size = u->Sum = (v && v <= N), u->Rev = false,
u->ch[0] = u->ch[1] = u->fa = null;
}
inline void pushup(Splay *&o) {
o->Max = cmax(o->v, cmax(o->ch[0]->Max, o->ch[1]->Max));
o->Sum = o->ch[0]->Sum + o->size + o->ch[1]->Sum;
}
inline void rotate(Splay *&o, int d) {
Splay *k = o->ch[d ^ 1];
o->ch[d ^ 1] = k->ch[d], k->ch[d] = o;
k->fa = o->fa, o->fa = k, o->ch[d ^ 1]->fa = o;
pushup(o), pushup(k), o = k;
}
inline void reverse(Splay *&o) { o->Rev = !o->Rev, swap(o->ch[0], o->ch[1]); }
inline void pushdown(Splay *&o) {
if (o->Rev) {
if (o->ch[0] != null) reverse(o->ch[0]);
if (o->ch[1] != null) reverse(o->ch[1]);
o->Rev = false;
}
}
Splay *Anc[Max_N + Max_M];
void splay(Splay *&o, int k) {
pushdown(o);
int d = (k ? Anc[k - 1] == o->ch[1] : -1);
if (d != -1) {
Splay *p = o->ch[d];
pushdown(p);
int d2 = (--k ? Anc[k - 1] == p->ch[1] : -1);
if (d2 != -1) {
splay(p->ch[d2], --k);
if (d == d2)
rotate(o, d ^ 1);
else
rotate(o->ch[d], d);
}
rotate(o, d ^ 1);
}
}
inline bool isroot(Splay *&u) { return u->fa->ch[0] != u && u->fa->ch[1] != u; }
void splay(Splay *&u) {
int Cnt(0);
for (; !isroot(u); u = u->fa) Anc[Cnt++] = u;
splay(u, Cnt);
}
void access(Splay *u) {
for (Splay *v = null; u != null; v = u, u = u->fa)
splay(u), u->size -= v->Sum, u->size += u->ch[1]->Sum, u->ch[1] = v,
pushup(u);
}
inline void move_to_root(Splay *&u) { access(u), splay(u), reverse(u); }
inline void Link(Splay *&u, Splay *&v) {
move_to_root(u), move_to_root(v), v->fa = u, u->size += v->Sum, pushup(u);
}
inline void Cut(Splay *&u, Splay *&v) {
move_to_root(u), access(v), splay(u), u->ch[1] = v->fa = null, pushup(u);
}
inline Splay *findroot(Splay *u) {
access(u), splay(u);
while (u->ch[0] != null) u = u->ch[0];
return u;
}
int main() {
newnode(null, 0);
gi(N), gi(M);
for (int u = 1; u <= N; ++u)
newnode(ver[u], u), Father[u] = u, Size[u] = 1, ++odd;
for (int i = 1, u, v, w, j, x, y; i <= M; ++i) {
gi(u), gi(v), gi(w), U[i] = u, V[i] = v, W[i] = w, newnode(edg[i], N + i);
if (findroot(ver[u]) != findroot(ver[v])) {
Link(ver[u], edg[i]), Link(ver[v], edg[i]), exist.insert(edge(i, w));
odd -= (Size[x = Get_Father(u)] & 1) + (Size[y = Get_Father(v)] & 1);
Father[y] = x, Size[x] += Size[y], odd += (Size[x] & 1);
} else {
move_to_root(ver[u]), access(ver[v]), splay(ver[u]);
if (get(ver[u]->Max) > w) {
j = ver[u]->Max - N;
Cut(ver[U[j]], edg[j]), Cut(ver[V[j]], edg[j]),
exist.erase(edge(j, W[j]));
Link(ver[u], edg[i]), Link(ver[v], edg[i]), exist.insert(edge(i, w));
}
}
if (odd == 0) {
for (int t;;) {
t = exist.rbegin()->p;
Cut(ver[U[t]], edg[t]), Cut(ver[V[t]], edg[t]);
move_to_root(ver[U[t]]);
if ((ver[U[t]]->Sum) & 1) {
Link(ver[U[t]], edg[t]), Link(ver[V[t]], edg[t]);
break;
} else
exist.erase(edge(t, W[t]));
}
print(exist.rbegin()->w);
} else
print(-1);
putc('\n');
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, m, X[N], Y[N];
char a[N];
void work() {
cin >> n >> m;
scanf("%s", a + 1);
int s = strlen(a + 1);
int xmn = 0, xmx = 0, ymn = 0, ymx = 0;
int x = 0, y = 0, t = s;
for (int i = 1; i <= s; i++) {
if (a[i] == 'L') y--;
if (a[i] == 'R') y++;
if (a[i] == 'U') x--;
if (a[i] == 'D') x++;
xmn = min(xmn, x);
xmx = max(xmx, x);
ymn = min(ymn, y);
ymx = max(ymx, y);
X[i] = xmn;
Y[i] = ymn;
if (xmx - xmn >= n || ymx - ymn >= m) {
t = i - 1;
break;
}
}
cout << -X[t] + 1 << " " << -Y[t] + 1 << endl;
}
int main() {
int T;
cin >> T;
while (T--) work();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long sum[101111 << 2], col[101111 << 2], add[101111 << 2], n, m, a, b, c,
t;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void pushdown(long long l, long long r, long long rt) {
if (add[rt]) {
long long mid = (l + r) >> 1;
sum[rt << 1] += (mid - l + 1) * add[rt];
sum[rt << 1 | 1] += (r - mid) * add[rt];
add[rt << 1] += add[rt];
add[rt << 1 | 1] += add[rt];
if (col[rt]) col[rt << 1] = col[rt << 1 | 1] = col[rt];
add[rt] = 0;
}
}
void pushup(long long rt) {
if (col[rt << 1] == col[rt << 1 | 1])
col[rt] = col[rt << 1];
else
col[rt] = 0;
sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void build(long long l, long long r, long long rt) {
if (l == r) {
col[rt] = l;
return;
}
long long mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
}
long long query(long long l, long long r, long long rt) {
if (a <= l && r <= b) return sum[rt];
long long ans = 0;
long long mid = (l + r) >> 1;
pushdown(l, r, rt);
if (a <= mid) ans += query(l, mid, rt << 1);
if (mid < b) ans += query(mid + 1, r, rt << 1 | 1);
return ans;
}
void update(long long l, long long r, long long rt) {
if (a <= l && r <= b && col[rt]) {
sum[rt] += (r - l + 1) * abs(col[rt] - c);
add[rt] += abs(col[rt] - c);
col[rt] = c;
return;
}
long long mid = (l + r) >> 1;
pushdown(l, r, rt);
if (a <= mid) update(l, mid, rt << 1);
if (mid < b) update(mid + 1, r, rt << 1 | 1);
pushup(rt);
}
int main() {
n = read(), m = read();
build(1, n, 1);
while (m--) {
t = read();
if (--t) {
a = read(), b = read();
printf("%I64d\n", query(1, n, 1));
} else {
a = read(), b = read(), c = read();
update(1, n, 1);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
int main() {
int n, k, i, x, s;
scanf("%d%d", &n, &k);
s = k;
for (i = 1; i <= n; i = i + 1) {
scanf("%d", &x);
s = gcd(s, x % k);
}
cout << k / s << endl;
for (i = 0; i < k; i = i + s) cout << i << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmax(T& l, const T r) {
l = max(l, r);
}
template <class T>
void chmin(T& l, const T r) {
l = min(l, r);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T extgcd(T a, T b, T& x, T& y) {
for (T u = y = 1, v = x = 0; a;) {
T q = b / a;
swap(x -= q * u, u);
swap(y -= q * v, v);
swap(b -= q * a, a);
}
return b;
}
template <class T>
T mod_inv(T a, T m) {
T x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
long long mod_pow(long long a, long long n, long long mod) {
long long ret = 1;
long long p = a % mod;
while (n) {
if (n & 1) ret = ret * p % mod;
p = p * p % mod;
n >>= 1;
}
return ret;
}
void reader(int& x) {
int k, m = 0;
x = 0;
for (;;) {
(k) = getchar_unlocked();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
(k) = getchar_unlocked();
if (k < '0' || k > '9') break;
x = x * 10 + k - '0';
}
if (m) x = -x;
}
void reader(long long& x) {
int k, m = 0;
x = 0;
for (;;) {
(k) = getchar_unlocked();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
(k) = getchar_unlocked();
if (k < '0' || k > '9') break;
x = x * 10 + k - '0';
}
if (m) x = -x;
}
int reader(char c[]) {
int i, s = 0;
for (;;) {
(i) = getchar_unlocked();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) break;
}
c[s++] = i;
for (;;) {
(i) = getchar_unlocked();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
template <class T, class S>
void reader(T& x, S& y) {
reader(x);
reader(y);
}
template <class T, class S, class U>
void reader(T& x, S& y, U& z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T& x, S& y, U& z, V& w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar_unlocked('-');
while (s--) putchar_unlocked(f[s] + '0');
putchar_unlocked(c);
}
void writer(long long x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar_unlocked('-');
while (s--) putchar_unlocked(f[s] + '0');
putchar_unlocked(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++) putchar_unlocked(c[i]);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++) putchar_unlocked(x[i]);
putchar_unlocked(c);
}
template <class T>
void writerLn(T x) {
writer(x, '\n');
}
template <class T, class S>
void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U>
void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T>
void writerArr(T x[], int n) {
if (!n) {
putchar_unlocked('\n');
return;
}
for (int i = 0; i < (n - 1); i++) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
const long long INF = numeric_limits<long long>::max() / 10;
struct edge {
int to;
long long cost;
edge() {}
edge(int to, long long cost) : to(to), cost(cost) {}
};
void dijkstra(int s, vector<pair<long long, int>::first_type>& cost_table,
vector<vector<edge>>& edges, vector<int>* _prev = NULL) {
cost_table.resize((int)edges.size());
fill(cost_table.begin(), cost_table.end(),
pair<long long, int>::first_type(INF));
if (_prev) _prev->resize((int)edges.size());
if (_prev) fill(_prev->begin(), _prev->end(), -1);
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
q.push(pair<long long, int>(0, s));
cost_table[s] = 0;
while (!q.empty()) {
pair<long long, int> p = q.top();
q.pop();
int v = p.second;
if (cost_table[v] < p.first) continue;
for (int i = 0; i < (int)edges[v].size(); i++) {
edge& e = edges[v][i];
if (cost_table[e.to] > cost_table[v] + e.cost) {
cost_table[e.to] = cost_table[v] + e.cost;
if (_prev) (*_prev)[e.to] = v;
q.push(pair<long long, int>(cost_table[e.to], e.to));
}
}
}
}
vector<vector<edge>> e;
map<pair<int, int>, int> e2id;
class UnionFind {
private:
int n;
vector<int> a;
public:
UnionFind(int n) : n(n), a(n, -1) {}
int find(int x) { return a[x] < 0 ? x : (a[x] = find(a[x])); }
bool same(int x, int y) { return find(x) == find(y); }
bool same(pair<int, int>& p) { return same(p.first, p.second); }
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return false;
if (a[x] > a[y]) swap(x, y);
a[x] += a[y];
a[y] = x;
n--;
return true;
}
bool unite(pair<int, int>& p) { return unite(p.first, p.second); }
int size() const { return n; }
int size(int x) { return -a[find(x)]; }
};
int main() {
int n, m;
reader(n, m);
e.resize(n);
vector<tuple<long long, int, int>> es;
for (int i = 0; i < (m); i++) {
int a, b, c;
reader(a, b, c);
a--;
b--;
e[a].emplace_back(b, c);
e[b].emplace_back(a, c);
es.emplace_back(c, a, b);
e2id[pair<int, int>(a, b)] = i + 1;
e2id[pair<int, int>(b, a)] = i + 1;
}
sort(es.begin(), es.end());
int s;
reader(s);
s--;
vector<pair<long long, int>::first_type> cost_table;
dijkstra(s, cost_table, e);
static bool connect_low[((int)1e5) * 3];
UnionFind uf(n);
long long ans = 0;
vector<int> anses;
for (auto& p : es) {
long long cst;
int from, to;
tie(cst, from, to) = p;
if (uf.same(from, to)) continue;
if (cost_table[from] > cost_table[to]) swap(from, to);
if (connect_low[to]) continue;
if (cost_table[to] - cost_table[from] == cst) {
connect_low[to] = true;
uf.unite(from, to);
ans += cst;
anses.push_back(e2id[pair<int, int>(from, to)]);
}
}
writerLn(ans);
if (((int)(anses).size())) writerArr(&anses[0], ((int)(anses).size()));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 62LL;
const long long mod = 1e9 + 7;
const long long maxn = 200200;
bool cmp(string s, string l) { return s + l < l + s; }
signed main() {
long long n;
cin >> n;
string a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, cmp);
sort(a, a + n);
sort(a, a + n, cmp);
for (long long i = 0; i < n; i++) cout << a[i];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
class SegTree {
public:
SegTree(int _n) : n(_n) {
x = vector<pair<LL, int>>(_n * 4);
sum = vector<LL>(_n * 4);
}
void Build(int t, int l, int r) {
if (l == r) {
x[t] = {0, l};
return;
}
int mid = (l + r) >> 1;
Build(t + t, l, mid);
Build(t + t + 1, mid + 1, r);
x[t] = min(x[t + t], x[t + t + 1]);
}
void Insert(int t, LL a, int l, int r, int p) {
if (l == r) {
sum[t] += a;
x[t].first += a;
return;
}
int mid = (l + r) >> 1;
if (p <= mid) Insert(t + t, a, l, mid, p);
if (mid + 1 <= p) Insert(t + t + 1, a, mid + 1, r, p);
sum[t] = sum[t + t] + sum[t + t + 1];
x[t] =
min(x[t + t], {sum[t + t] + x[t + t + 1].first, x[t + t + 1].second});
}
pair<LL, int> Query(int t, LL a, int l, int r, int p, int q, LL presum) {
int mid = (l + r) >> 1;
if (p <= l && r <= q) {
if (l == r) {
return {x[t].first + presum, x[t].second};
}
if (presum + x[t + t].first <= -a) {
return Query(t + t, a, l, mid, p, q, presum);
}
return Query(t + t + 1, a, mid + 1, r, p, q, presum + sum[t + t]);
}
pair<LL, int> ans = {1000000000000000000L, -1};
if (p <= mid) ans = min(ans, Query(t + t, a, l, mid, p, q, presum));
if (ans.first <= -a) return ans;
if (mid + 1 <= q)
ans =
min(ans, Query(t + t + 1, a, mid + 1, r, p, q, presum + sum[t + t]));
return ans;
}
LL GetSum(int t, int l, int r, int p) {
if (l == r) return x[t].first;
int mid = (l + r) >> 1;
if (p <= mid) return GetSum(t + t, l, mid, p);
return sum[t + t] + GetSum(t + t + 1, mid + 1, r, p);
}
int n;
vector<LL> sum;
vector<pair<LL, int>> x;
};
struct Query {
int t;
int a, b, c;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<Query> x(n);
map<int, int> h;
for (int i = 0; i < n; ++i) {
cin >> x[i].t;
if (x[i].t == 1) {
cin >> x[i].a >> x[i].b;
h[x[i].a] = 0;
} else if (x[i].t == 2) {
cin >> x[i].a;
h[x[i].a] = 0;
} else {
cin >> x[i].a >> x[i].b >> x[i].c;
h[x[i].a] = 0;
h[x[i].b] = 0;
}
}
const int L = 0, R = 1000000001;
h[L] = h[R] = 0;
int cnt = 0;
vector<int> rh{0};
for (auto& [a, b] : h) {
b = ++cnt;
rh.push_back(a);
}
SegTree tree(cnt);
tree.Build(1, 1, cnt);
map<int, int> s;
s[L] = s[R] = 0;
for (int i = 0; i < n; ++i) {
if (x[i].t == 1) {
int ha = h[x[i].a];
auto iter = s.lower_bound(x[i].a);
auto pt = *iter;
int ht = h[pt.first];
--iter;
auto ps = *iter;
tree.Insert(1, 1LL * (x[i].a - ps.first) * ps.second, 1, cnt, ha);
tree.Insert(1, -1LL * (pt.first - ps.first) * ps.second, 1, cnt, ht);
tree.Insert(1, 1LL * (pt.first - x[i].a) * x[i].b, 1, cnt, ht);
s.insert({x[i].a, x[i].b});
} else if (x[i].t == 2) {
int ha = h[x[i].a];
auto iter = s.find(x[i].a);
x[i].b = iter->second;
--iter;
auto ps = *iter;
tree.Insert(1, -1LL * (x[i].a - ps.first) * ps.second, 1, cnt, ha);
++iter;
++iter;
auto pt = *iter;
int ht = h[iter->first];
tree.Insert(1, 1LL * (pt.first - ps.first) * ps.second, 1, cnt, ht);
tree.Insert(1, -1LL * (pt.first - x[i].a) * x[i].b, 1, cnt, ht);
s.erase(x[i].a);
} else {
LL v = x[i].c;
if (v == 0) {
cout << x[i].a << '\n';
continue;
}
auto iter = s.lower_bound(x[i].a);
if (x[i].b <= iter->first) {
cout << -1 << '\n';
continue;
}
x[i].a = iter->first;
auto ps = *iter;
++iter;
auto pt = *iter;
v -= tree.GetSum(1, 1, cnt, h[x[i].a]);
auto mv = tree.Query(1, v, 1, cnt, h[ps.first], cnt, 0);
if (v + mv.first > 0) {
cout << -1 << '\n';
continue;
}
int pe = rh[mv.second];
auto ip = s.lower_bound(pe);
--ip;
if (ip->first >= x[i].b) {
cout << -1 << '\n';
continue;
}
v += tree.GetSum(1, 1, cnt, h[ip->first]);
if (v + 1LL * (x[i].b - ip->first) * ip->second <= 0) {
double dist = 1.0 * v / ip->second;
cout << fixed << setprecision(10) << ip->first - dist << '\n';
} else {
cout << -1 << '\n';
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
ifstream inf("input.txt");
long long a, b;
cin >> a >> b;
long long ans = 0;
for (int i = 1; i <= a; i++) ans = (ans + (i * b + 1)) % 1000000007;
long long j = 0;
for (int i = 1; i <= b - 1; i++) j = (j + (i * ans)) % 1000000007;
cout << j;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 401;
const int MOD = 1000000007;
struct matr {
long long a[8][8];
};
matr d, f, e;
int n;
void make() {
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) f.a[i][j] = d.a[i][j] = e.a[i][j] = 0;
d.a[0][1] = 1;
d.a[0][4] = 1;
d.a[1][0] = 1;
d.a[2][3] = 1;
d.a[2][6] = 1;
d.a[3][2] = 1;
d.a[4][5] = 1;
d.a[4][7] = 1;
d.a[5][1] = 1;
d.a[5][4] = 1;
d.a[6][5] = 1;
d.a[6][7] = 1;
d.a[7][3] = 1;
d.a[7][6] = 1;
for (int i = 0; i < 8; i++) f.a[0][i] = e.a[i][i] = 1;
}
void print(matr a) {
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) cout << a.a[i][j] << ' ';
cout << endl;
}
}
matr mul(matr a, matr b) {
matr c;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) {
c.a[i][j] = 0;
for (int z = 0; z < 8; z++) {
c.a[i][j] += a.a[i][z] * b.a[z][j];
if (c.a[i][j] >= MOD) c.a[i][j] %= MOD;
}
}
return c;
}
matr sum(matr a, matr b) {
matr c;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) c.a[i][j] = (a.a[i][j] + b.a[i][j]) % MOD;
return c;
}
matr sqr(matr a) { return mul(a, a); }
matr pow_(matr p, int n) {
if (n <= 1) return p;
if (n % 2 == 0) return sqr(pow_(p, n / 2));
return mul(p, sqr(pow_(p, n / 2)));
}
long long sum(matr a) {
long long ans = 0;
for (int i = 0; i < 8; i++) ans += a.a[0][i];
return ans;
}
long long solve_palin(int n) {
if (n == 1) return 4;
if (n == 2) return 4;
return sum(mul(f, pow_(d, n - 2)));
}
long long solve_one(int n) {
if (n == 1) return 4;
if (n == 2) return 4;
if (n % 2 == 0) return solve_palin(n) / 2;
return solve_palin(n) / 2 + solve_palin((n + 1) / 2);
}
matr clear(matr a) {
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) a.a[i][j] = 0;
return a;
}
int log_(int n) {
int l = 0;
while ((1 << l) <= n) l++;
return l - 1;
}
int log_less(int n) {
int l = 0;
while ((1 << l) - 1 < n) l++;
return l - 1;
}
int step_2(int n) { return (1 << n); }
matr magic_func(int n) {
if (n == 0) return e;
if (n == 1) return sum(d, e);
matr ans;
ans = clear(ans);
int w = log_less(n);
ans = sum(d, e);
for (int i = 1; i < w; i++) ans = mul(ans, sum(pow_(d, step_2(i)), e));
return sum(ans, mul(pow_(d, step_2(w)), magic_func(n - step_2(w))));
}
long long solve(int n) {
if (n == 1) return 4;
matr ans;
ans = clear(ans);
n -= 2;
ans = magic_func(n);
return sum(mul(f, ans)) + 4;
}
long long real_ans(int n) { return solve(n) / 2 + solve((n + 1) / 2) / 2; }
int l, r;
int main() {
cin >> l >> r;
make();
if (r == 1) {
cout << 4;
return 0;
}
if (l == r) {
cout << solve_one(l) % MOD;
return 0;
}
long long razn = 0;
if (l == 1) {
razn = 4;
l++;
}
if (l % 2 == 0) {
razn += solve_one(l);
l++;
}
if (r % 2 == 0) {
razn += solve_one(r);
--r;
}
cout << ((real_ans(r) - real_ans(l - 1) + razn) % MOD + MOD) % MOD;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void RD(int &x) { scanf("%d", &x); }
void RD(long long &x) { scanf("%I64d", &x); }
void RD(unsigned long long &x) { scanf("%I64u", &x); }
void RD(unsigned int &x) { scanf("%u", &x); }
void RD(double &x) { scanf("%lf", &x); }
void RD(int &x, int &y) { scanf("%d%d", &x, &y); }
void RD(long long &x, long long &y) { scanf("%I64d%I64d", &x, &y); }
void RD(unsigned int &x, unsigned int &y) { scanf("%u%u", &x, &y); }
void RD(double &x, double &y) { scanf("%lf%lf", &x, &y); }
void RD(int &x, int &y, int &z) { scanf("%d%d%d", &x, &y, &z); }
void RD(long long &x, long long &y, long long &z) {
scanf("%I64d%I64d%I64d", &x, &y, &z);
}
void RD(unsigned int &x, unsigned int &y, unsigned int &z) {
scanf("%u%u%u", &x, &y, &z);
}
void RD(double &x, double &y, double &z) { scanf("%lf%lf%lf", &x, &y, &z); }
void RD(char &x) { x = getchar(); }
void RD(char *s) { scanf("%s", s); }
void RD(string &s) { cin >> s; }
void PR(int x) { printf("%d\n", x); }
void PR(int x, int y) { printf("%d %d\n", x, y); }
void PR(long long x) { printf("%I64d\n", x); }
void PR(unsigned int x) { printf("%u\n", x); }
void PR(unsigned long long x) { printf("%I64u\n", x); }
void PR(double x) { printf("%.10lf\n", x); }
void PR(char x) { printf("%c\n", x); }
void PR(char *x) { printf("%s\n", x); }
void PR(string x) { cout << x << endl; }
const int mod = 1000000007;
const long long inf = ((long long)1) << 60;
const double dinf = 1000000000000000000.0;
const int INF = 1000000005;
const int N = 1005;
int a[N][N];
int n;
int main() {
RD(n);
int i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) RD(a[i][j]);
int ans = 0;
for (i = 1; i <= n; i++) {
int tmp = 0;
for (j = 1; j <= n; j++) tmp = (tmp + a[i][j] * a[j][i]) & 1;
ans += tmp;
ans &= 1;
}
string s = "";
int Q;
RD(Q);
while (Q--) {
int op, p;
RD(op);
int x, y;
if (op == 1 || op == 2) {
RD(x);
ans ^= 1;
} else {
if (ans)
s += "1";
else
s += "0";
}
}
PR(s);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 7005, K = 150005;
struct ope {
int x, y, v;
};
vector<ope> op[N];
int n, m, nxtl[K], nxtr[K];
void ppw() {
int k = 1, c = 2;
nxtl[1] = 1, nxtr[1] = 2;
for (int i = 2; i < K; ++i) {
if ((1 << k) == i) {
nxtl[i] = ++c;
nxtr[i] = ++c;
++k;
} else {
nxtl[i] = nxtr[i] = ++c;
}
}
}
int reply(int t, int x) {
set<int> s;
s.clear();
int l = x, r = x;
for (int i = t; i <= n; ++i) {
for (int j = 0; j < op[i].size(); ++j) {
if (op[i][j].x <= r && op[i][j].y >= l) s.insert(op[i][j].v);
}
if (i != n) l = nxtl[l], r = nxtr[r];
}
return s.size();
}
int main() {
int o, t, x;
ope u;
ppw();
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d", &o);
if (o == 1) {
scanf("%d%d%d%d", &t, &u.x, &u.y, &u.v);
op[t].push_back(u);
} else {
scanf("%d%d", &t, &x);
printf("%d\n", reply(t, x));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
vector<int> L, R;
int anc[21][N], dep[N], n;
void add(int fa, int x) {
dep[x] = dep[fa] + 1;
anc[0][x] = fa;
for (int i = 1; i <= 20; i++) anc[i][x] = anc[i - 1][anc[i - 1][x]];
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20; i >= 0; i--)
if (dep[x] - (1 << i) >= dep[y]) x = anc[i][x];
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (anc[i][x] != anc[i][y]) x = anc[i][x], y = anc[i][y];
return anc[0][x];
}
int len(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
int main() {
scanf("%d", &n);
int ans = 0;
L.push_back(1);
for (int i = 2; i <= n + 1; i++) {
int p;
scanf("%d", &p);
add(p, i);
int d1 = L.empty() ? 0 : len(L[0], i);
int d2 = R.empty() ? 0 : len(R[0], i);
int d = max(d1, d2);
if (d > ans) {
if (d1 == d) {
for (int j = 0; j < R.size(); j++)
if (len(R[j], i) == d) L.push_back(R[j]);
R.clear();
R.push_back(i);
} else {
for (int j = 0; j < L.size(); j++)
if (len(L[j], i) == d) R.push_back(L[j]);
L.clear();
L.push_back(i);
}
ans = d;
} else if (d == ans) {
if (d1 == d)
R.push_back(i);
else
L.push_back(i);
}
printf("%d\n", L.size() + R.size());
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 10, inf = 2e9 + 10, mod = 1e9 + 7, inv2 = (mod + 1) / 2;
int n, c[55], pos[55], c1[55];
void f(int l, int r, int num) {
for (int i = l; i <= r; ++i) {
int t = c[i];
c1[i + num] = t;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> c[i];
c1[i] = c[i];
pos[c[i]] = i;
}
int flag = n & 1;
vector<vector<int>> res;
for (int i = 1; i <= n; ++i) {
int id = pos[i];
vector<int> ans;
if (flag == 0) {
for (int j = i - 1; j > 0; --j) {
ans.push_back(1);
c1[n - j + 1] = j;
}
f(i, id, n - i - id + 1);
f(id + 1, n, -id);
if (id - i + 1) ans.push_back(id - i + 1);
if (n - id) ans.push_back(n - id);
if (ans.size() > 1) {
res.push_back(ans);
}
} else {
f(id, n - i + 1, i - id);
f(1, id - 1, n - id + 1);
if (id - 1) ans.push_back(id - 1);
if (n - i - id + 2) ans.push_back(n - i - id + 2);
for (int j = i - 1; j > 0; --j) {
ans.push_back(1);
c1[j] = j;
}
if (ans.size() > 1) {
res.push_back(ans);
}
}
for (int j = 1; j <= n; ++j) {
c[j] = c1[j];
pos[c[j]] = j;
}
flag ^= 1;
}
cout << res.size() << '\n';
for (auto x : res) {
cout << x.size() << ' ';
for (int i = 0; i < x.size(); ++i) cout << x[i] << " \n"[i == x.size() - 1];
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1);
long long t1, t2, t3, t4, t5;
vector<pair<long long, long long> > vv[200005];
int main() {
long long n, x;
cin >> n >> x;
long long l, r, m;
for (int i = 0; i < n; i++) {
cin >> l >> r >> m;
vv[r - l + 1].push_back({l, m});
}
for (int i = 0; i < x + 1; i++) sort(vv[i].begin(), vv[i].end());
long long ans = 20000000000;
t1 = t2 = ans;
for (int d = 1; d < x; d++) {
auto &u = vv[d], &v = vv[x - d];
t1 = t2;
for (int i = 0, j = 0; i < v.size(); i++) {
while (j < u.size() && d - 1 + u[j].first < v[i].first) {
if (t1 > u[j].second) t1 = u[j].second;
j++;
}
if (t1 != t2) {
t3 = t1 + v[i].second;
if (ans > t3) ans = t3;
}
}
}
if (ans == t2) ans = -1;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s[2] = {"I hate it", " I love it"};
string s_[2] = {"I hate that", " I love that"};
string tmp = "";
for (int i = 0; i < n; ++i) {
if (i % 2 == 0) {
if (n > 1 && i < n - 1)
tmp += s_[0];
else if (n == 1 || i == n - 1) {
tmp += s[0];
}
} else {
if (n > 1 && i < n - 1) {
tmp += s_[1];
if (i < n - 1) tmp += ' ';
} else if (n == 1 || i == n - 1) {
tmp += s[1];
}
}
}
cout << tmp << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
unordered_map<int, int> xCount, yCount;
map<pair<int, int>, int> count;
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
xCount[x]++;
yCount[y]++;
count[{x, y}]++;
}
long long ans = 0;
for (auto elem : xCount) {
long long c = elem.second;
ans += (c * (c - 1)) / 2;
}
for (auto elem : yCount) {
long long c = elem.second;
ans += (c * (c - 1)) / 2;
}
for (auto elem : count) {
long long c = elem.second;
ans -= (c * (c - 1)) / 2;
}
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void gn(T &x) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), x = 0; c >= '0' && c <= '9';
c = getchar())
x = (x << 1) + (x << 3) + c - '0';
if (sg) x = -x;
}
long long A[100010];
long long x[100010];
long long a[100010], b;
int id[100010];
int pos[100010];
int vst[100010];
int st;
int calc(long long *x, int n) {
int ed = 0;
for (int i = 1; i <= n; i++) {
pos[i] = i;
ed = max(ed, 64 - (__builtin_clzll(x[i])));
}
st = 1;
for (int i = 0; i < ed; i++) {
for (int j = st; j <= n; j++) {
if ((((x[j]) >> (i)) & 1)) {
swap(x[j], x[st]);
swap(pos[j], pos[st]);
for (int k = st + 1; k <= n; k++) {
if ((((x[k]) >> (i)) & 1)) x[k] ^= x[st];
}
st++;
break;
}
}
}
st--;
return st;
}
int main() {
int n;
scanf("%d", &n);
long long s = 0;
int ed = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &A[i]);
s ^= A[i];
ed = max(ed, 64 - (__builtin_clzll(A[i])));
}
for (int i = ed - 1; i >= 0; i--) {
if (!(((s) >> (i)) & 1)) {
for (int j = 1; j <= n; j++) x[j] = a[j] * 2 + (((A[j]) >> (i)) & 1);
x[n + 1] = b * 2 + 1;
int g = calc(x, n + 1);
for (int j = 1; j <= n; j++) x[j] = a[j] * 2 + (((A[j]) >> (i)) & 1);
int f = calc(x, n);
if (f == g) {
for (int j = 1; j <= n; j++) a[j] = a[j] * 2 + (((A[j]) >> (i)) & 1);
b = b * 2 + 1;
}
}
}
for (int i = ed - 1; i >= 0; i--) {
if ((((s) >> (i)) & 1)) {
for (int j = 1; j <= n; j++) x[j] = a[j] * 2 + (((A[j]) >> (i)) & 1);
x[n + 1] = b * 2;
int g = calc(x, n + 1);
for (int j = 1; j <= n; j++) x[j] = a[j] * 2 + (((A[j]) >> (i)) & 1);
int f = calc(x, n);
if (f == g) {
for (int j = 1; j <= n; j++) a[j] = a[j] * 2 + (((A[j]) >> (i)) & 1);
b = b * 2;
}
}
}
for (int i = 1; i <= n; i++) x[i] = a[i];
int be = calc(x, n);
for (int i = 1; i <= be; i++) id[i] = pos[i];
while (1) {
int flag = 0;
for (int i = 1; i <= be; i++) {
int m = 0;
for (int j = 1; j <= be; j++) {
if (j != i) x[++m] = a[id[j]];
}
x[++m] = b;
int g = calc(x, m);
m = 0;
for (int j = 1; j <= be; j++) {
if (j != i) x[++m] = a[id[j]];
}
int f = calc(x, m);
if (f == g) {
flag = 1;
swap(id[i], id[be]);
be--;
}
}
if (!flag) break;
}
for (int i = 1; i <= be; i++) vst[id[i]] = 1;
for (int i = 1; i <= n; i++) {
if (vst[i])
printf("%d ", 1);
else
printf("%d ", 2);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool plan[1005][1005];
int sumRow[1005][1005];
int sumCol[1005][1005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
memset(sumRow, 0, sizeof sumRow);
memset(sumCol, 0, sizeof sumCol);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> plan[i][j];
sumRow[i][j] += sumRow[i][j - 1] + plan[i][j];
sumCol[i][j] += sumCol[i - 1][j] + plan[i][j];
}
}
int count = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (plan[i][j] == 0) {
if (sumRow[i][j - 1] >= 1) {
count++;
}
if (sumRow[i][m] - sumRow[i][j] >= 1) {
count++;
}
if (sumCol[i - 1][j] >= 1) {
count++;
}
if (sumCol[n][j] - sumCol[i][j] >= 1) {
count++;
}
}
}
}
cout << count;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
long long int dp[55];
void compute() {
dp[0] = 1;
dp[1] = 1;
dp[2] = 2;
for (__typeof(53) i = (3) - ((3) > (53)); i != (53) - ((3) > (53));
i += 1 - 2 * ((3) > (53))) {
dp[i] = dp[i - 1] + dp[i - 2];
}
}
int main() {
compute();
cin >> n >> k;
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1))) {
if (k <= dp[n - i]) {
cout << i << " ";
} else {
cout << i + 1 << " " << i << " ";
k -= dp[n - i];
i++;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, a[3] = {0};
scanf("%d %d", &n, &x);
a[x] = 1;
n %= 6;
for (int i = n - 1; i >= 0; i--) {
if (i % 2)
swap(a[1], a[2]);
else
swap(a[0], a[1]);
}
for (int i = 0; i < 3; i++) {
if (a[i]) printf("%d\n", i);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 22) + 108;
int dp[N], pre[N], f[25], n, m, prn[N];
int main() {
int u, v;
memset(f, 0, sizeof(f));
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) f[i] |= (1 << (i - 1));
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
f[u] |= (1 << (v - 1));
f[v] |= (1 << (u - 1));
}
memset(dp, 0x3f3f3f3f, sizeof(dp));
for (int i = 1; i < (1 << n); ++i) {
int tmp = i;
for (int j = 1; j <= n; ++j)
if (i & (1 << (j - 1))) tmp &= f[j];
if (tmp == i) dp[i] = 0;
}
for (int i = 1; i < (1 << n); ++i)
for (int j = 1; j <= n; ++j) {
if ((i & (1 << (j - 1))) && dp[i] + 1 < dp[i | f[j]]) {
dp[i | f[j]] = dp[i] + 1;
pre[i | f[j]] = i;
prn[i | f[j]] = j;
}
}
printf("%d\n", dp[(1 << n) - 1]);
for (int i = (1 << n) - 1; pre[i]; i = pre[i]) printf("%d ", prn[i]);
puts("");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int len = s.length();
int a = ceil((double)len / 20);
int b = ceil((double)len / a);
int cnt = (a * b) - len;
cout << a << ' ' << b << endl;
int perA = ceil((double)cnt / a);
int pos = 0;
for (int i = 0; i < a; i++) {
int temp = perA;
for (int j = 0; j < b; j++) {
if (cnt > 0 && temp > 0) {
cout << '*';
cnt--;
temp--;
continue;
}
cout << s[pos];
pos++;
}
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using ld = long double;
mt19937 rnd(time(nullptr));
const lli inf = 1e18;
lli Bit(lli mask, lli i) { return (mask >> i) & 1; }
inline void Solve() {
lli n = 0, m = 0;
cin >> n >> m;
vector<string> data(n);
for (auto &it : data) cin >> it;
vector<vector<lli>> cost(n, vector<lli>(m));
for (lli i = 0; i < n; i++) {
for (lli j = 0; j < m; j++) cin >> cost[i][j];
}
vector<vector<pair<lli, lli>>> buffer(n, vector<pair<lli, lli>>(m));
for (lli i = 0; i < n; i++) {
for (lli j = 0; j < m; j++) {
lli mx = 0;
for (lli k = 0; k < n; k++) {
if (data[i][j] == data[k][j]) {
buffer[i][j].first |= (1 << k);
buffer[i][j].second += cost[k][j];
mx = max(mx, cost[k][j]);
}
}
buffer[i][j].second -= mx;
}
}
vector<lli> dp((1 << n), inf);
dp[0] = 0;
for (lli mask = 0; mask < (1 << n); mask++) {
if ((dp[mask] == inf) || (mask == (1 << n) - 1)) continue;
lli id = -1;
for (lli i = n - 1; i >= 0; i--) {
if (Bit(mask, i) == 0) {
id = i;
break;
}
}
for (lli i = 0; i < m; i++) {
lli mask1 = buffer[id][i].first, value = buffer[id][i].second;
dp[mask | mask1] = min(dp[mask | mask1], dp[mask] + value);
dp[mask | (1 << id)] = min(dp[mask | (1 << id)], dp[mask] + cost[id][i]);
}
}
cout << dp.back();
}
signed main() {
cout << fixed << setprecision(20);
Solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> dp(n, 0);
long long x = a[n - 1];
dp[n - 1] = x;
for (long long i = n - 2; i >= 0; i--) {
x += a[i];
dp[i] = max(dp[i + 1], x - dp[i + 1]);
}
cout << x - dp[0] << " " << dp[0] << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<int> x, y, z;
int xx = 0, yy = 0, zz = 0;
x.push_back(0);
y.push_back(0);
z.push_back(0);
for (char c : s) {
xx += (c == 'x');
yy += (c == 'y');
zz += (c == 'z');
x.push_back(xx);
y.push_back(yy);
z.push_back(zz);
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
vector<int> vc;
vc.push_back(x[r] - x[l - 1]);
vc.push_back(y[r] - y[l - 1]);
vc.push_back(z[r] - z[l - 1]);
sort(vc.begin(), vc.end());
if (r - l + 1 <= 2) {
cout << "YES" << endl;
continue;
}
if ((vc[0] != vc[1] && vc[1] != vc[2] && vc[2] != vc[0]) ||
vc[2] - vc[0] > 1) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = (int)3e5;
int n;
struct node {
int num, id;
bool operator<(const node& i) const {
if (num == i.num) return id < i.id;
return num < i.num;
}
} a[maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int temp;
cin >> temp;
a[i].id = i;
a[i].num = temp;
}
sort(a + 1, a + n + 1);
int ans = INF;
if (a[1].num == a[2].num) {
for (int i = 2; i <= n; i++) {
if (a[i].num != a[1].num)
break;
else
ans = min(ans, abs(a[i].id - a[i - 1].id));
}
} else {
for (int i = 2; i <= n; i++) {
if (a[i].num != a[2].num)
break;
else
ans = min(ans, abs(a[i].id - a[1].id));
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class c {
public:
int a[53] = {0};
void add(int x) {
if (a[x] == 0) {
cout << x << " ";
a[x] = 1;
}
}
};
int main() {
int t, x, n;
cin >> t;
for (int i = 0; i < t; i++) {
c s;
cin >> n;
for (int j = 0; j < 2 * n; j++) {
cin >> x;
s.add(x);
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int INF = ((1 << 30) - 1);
const long long LLINF = (((1LL << 60) - 1LL));
const double EPS = 1e-9;
const double PI = 3.14159265358979323846;
long long check(long long x, long long mod) { return ((x % mod) + mod) % mod; }
long long mulNumbers(long long a, long long b, long long mod) {
long long res = 0;
while (b) {
if (b & 1) {
res = check(res + a, mod);
}
a = check(a + a, mod);
b >>= 1;
}
return res;
}
vector<vector<long long> > mul(const vector<vector<long long> >& a,
const vector<vector<long long> >& b,
long long mod) {
vector<vector<long long> > res(2, vector<long long>(2));
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
for (int k = 0; k < 2; ++k) {
long long prod = mulNumbers(a[i][k], b[k][j], mod);
res[i][j] = check(res[i][j] + prod, mod);
}
}
}
return res;
}
vector<vector<long long> > toPower(vector<vector<long long> > M,
long long exponent, long long mod) {
vector<vector<long long> > res(2, vector<long long>(2));
res[0][0] = res[1][1] = check(1, mod);
while (exponent) {
if (exponent & 1) {
res = mul(res, M, mod);
}
M = mul(M, M, mod);
exponent >>= 1;
}
return res;
}
long long getRemain(long long index, long long mod) {
vector<vector<long long> > M(2, vector<long long>(2, check(1, mod)));
M[0][0] = 0;
vector<vector<long long> > Mpower = toPower(M, index, mod);
long long res = Mpower[0][1];
return res;
}
int main() {
long long remain;
cin >> remain;
long long curPeriod = 1;
long long curPower10 = 1;
vector<long long> curRemain(1, 0);
for (long long it = 1; it <= 13; ++it) {
cerr << "curPeriod"
<< ": " << curPeriod << endl;
;
for (int i = 0; i < curRemain.size(); ++i) {
cerr << curRemain[i] << " ";
}
cerr << endl;
long long nextPeriodMul;
for (long long m = 1;; ++m) {
long long a = getRemain(curPeriod * m, curPower10 * 10);
long long b = getRemain(curPeriod * m + 1, curPower10 * 10);
if (a == 0 && b == 1) {
nextPeriodMul = m;
break;
}
}
long long nextPeriod = curPeriod * nextPeriodMul;
long long needSteps = -1;
vector<long long> nextRemain;
for (int ID = 0; ID < curRemain.size(); ++ID) {
for (long long steps = 0; steps < nextPeriodMul; ++steps) {
if (getRemain(curPeriod * steps + curRemain[ID], curPower10 * 10) ==
check(remain, curPower10 * 10)) {
nextRemain.push_back(curPeriod * steps + curRemain[ID]);
}
}
}
curPower10 *= 10;
curPeriod = nextPeriod;
curRemain = nextRemain;
}
cout << (curRemain.empty()
? -1
: *min_element((curRemain).begin(), (curRemain).end()))
<< endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
const long double PI = acos(-1);
using namespace std;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
long long x;
cin >> x;
long long *arr = new long long[x];
long long e = INT_MAX;
for (int i = 0; i < x; i++) {
cin >> arr[i];
if (arr[i] < e) {
e = arr[i];
}
}
for (int i = 0; i < x; i++) {
if (arr[i] % e != 0) {
cout << "-1\n";
return 0;
}
}
cout << e << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--)
{
int n,k;
cin>>n>>k;
if(k==0)
{
for(int i=1;i<=n;i++)
cout<<i<<" ";
cout<<endl;
continue;
}
else if(n%2==0 && k>=(n/2))
{
cout<<-1<<endl;
continue;
}
else if(n%2!=0 && k>=(n/2)+1)
{
cout<<-1<<endl;
continue;
}
else
{
int arr[n+1];
arr[0]=0,arr[1]=1,arr[n]=n;
int count_peak=0,count_no=0;
bool flag=true;
int temp=3;
for(int i=2;i<=n-1;i+=2)
{
if(count_peak<k)
{
arr[i]=temp;
temp+=2;
count_peak++;
count_no++;
}
else
{
flag=false;
break;
}
/*if(flag==true)
break;
if(count==k)
flag=false;
*/
}
if(flag==true)
{
temp=2;
for(int i=3;i<=n;i+=2)
{
arr[i]=temp;
temp+=2;
}
}
else if(flag==false)
{
int temp1=0,temp2=0;
temp=2;
for(int i=3;i<=n;i+=2)
{
if(temp1<k)
{
arr[i]=temp;
temp+=2;
temp1++;
temp2=temp;
}
}
temp2+=2;
for(int i=temp;i<n+1;i++)
{
arr[i]=i;
}
}
for(int i=1;i<n+1;i++)
cout<<arr[i]<<" ";
cout<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 1;
const int INF = 1e9 + 7;
const int N = 401;
vector<pair<int, int> > edges[N];
vector<int> dijkstra(int s) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
Q;
vector<int> dist(N, INF), dad(N, -1);
Q.push(make_pair(0, s));
dist[s] = 0;
while (!Q.empty()) {
pair<int, int> p = Q.top();
Q.pop();
int here = p.second;
for (vector<pair<int, int> >::iterator it = edges[here].begin();
it != edges[here].end(); it++) {
if (dist[here] + it->first < dist[it->second]) {
dist[it->second] = dist[here] + it->first;
dad[it->second] = here;
Q.push(make_pair(dist[it->second], it->second));
}
}
}
return dist;
}
vector<pair<int, int> > e;
int rail[N][N];
inline void solve(void) {
int n, m, x, y, f = 0;
cin >> n >> m;
for (int i = (0); i < (m); i++) {
cin >> x >> y;
rail[x][y] = 1;
rail[y][x] = 1;
if ((x == 1 && y == n) || (x == n && y == 1)) {
f = 1;
}
}
for (int i = (1); i < (n + 1); i++)
for (int j = (i + 1); j < (n + 1); j++) {
if (rail[i][j] == 0 && f == 1)
edges[i].push_back(make_pair(1, j)),
edges[j].push_back(make_pair(1, i));
else if (rail[i][j] == 1 && f == 0)
edges[i].push_back(make_pair(1, j)),
edges[j].push_back(make_pair(1, i));
}
vector<int> ans = dijkstra(1);
if (ans[n] >= INF) ans[n] = -1;
cout << ans[n];
return;
}
void init() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
int main(int argc, const char* argv[]) {
init();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 15;
vector<int> adj[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cout << "1 ";
cout << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, per[101000];
map<pair<int, int>, int> fail;
int main(int argc, char** argv) {
srand(514);
scanf("%d%d", &n, &m);
for (int i = 0, u, v; i < m; i++) {
scanf("%d%d", &u, &v);
fail[make_pair(u, v)] = fail[make_pair(v, u)] = 1;
}
for (int i = 0; i < n; i++) per[i] = i + 1;
if (m > (long long)n * (n - 1) / 2 - m) {
puts("-1");
exit(0);
}
int sign = 1;
for (int T = 0, ed = max((int)(1e6 / n), 300); T < ed; T++) {
random_shuffle(per, per + n);
per[n] = per[0];
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!fail.count(make_pair(per[i], per[i + 1]))) cnt++;
}
if (cnt >= m) {
sign = 0;
for (int i = 0; i < n && m > 0; i++) {
if (!fail.count(make_pair(per[i], per[i + 1]))) {
printf("%d %d\n", per[i], per[i + 1]);
m--;
}
}
break;
}
}
if (sign) puts("-1");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int V, E, i, j, k, u, v, x, y, p, q, r, t, n;
vector<int> *g;
vector<bool> sn;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
int x1, x2, y1, y2, z1, z2;
while (t--) {
long long ans = 0;
cin >> x1 >> y1 >> z1 >> x2 >> y2 >> z2;
if (z1 >= y2) {
ans = y2 * 2;
i = (x1 + z1 - y2 - z2);
if (i < 0) ans += i * 2;
} else {
ans = z1 * 2;
i = x2 + y2 - z1 - y1;
if (i < 0) ans += i * 2;
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int pos[int((3 * 1e5 + 42)) + 42];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x;
cin >> n >> x;
if (x >= (1 << n)) {
int PewDiePie = 0;
cout << (1 << n) - 1 << endl;
while (PewDiePie < (1 << n) - 1) {
cout << (PewDiePie ^ (PewDiePie++)) << " ";
}
cout << endl;
} else {
set<int> S;
for (int i = 1; i <= (1 << n) - 1; i++) {
if (S.find(x ^ i) == S.end()) S.insert(i);
}
cout << S.size() - 1 << endl;
auto it = S.begin();
int Pewds = *it;
it++;
while (it != S.end()) {
cout << (Pewds ^ (*it)) << " ";
Pewds = *it;
it++;
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U> &l, const std::pair<T, U> &r) {
return {l.first + r.first, l.second + r.second};
}
typedef void (*callback_function)(void);
const long long ZERO = 0LL;
const long long INF64 = 1e18;
const long long INF32 = 1e9;
const long long MOD = 1e9 + 7;
const long double PI = acos(-1.0L);
const long double EPS = static_cast<long double>(1e-9);
inline long long Pow(long long a, long long k) {
long long s = 1;
for (; k; k >>= 1) {
k & 1 ? s = 1LL * s * a % MOD : 0;
a = 1LL * a * a % MOD;
}
return s;
}
const long long N = 1e6 + 7;
void input() {}
void output() {}
void preprocess() {}
void debug() {
if (true) {
}
}
void solve() {
long long n;
cin >> n;
long long res = 0;
map<long long, long long> cnt;
for (long long i = (0); i < (n); i++) {
string s;
cin >> s;
long long bit = 0;
for (char &ch : s) {
bit ^= (1 << (ch - 'a'));
}
res += cnt[bit];
for (long long i = (0); i < (26); i++) {
res += cnt[bit ^ (1 << i)];
}
cnt[bit]++;
}
cout << res << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
{
input();
solve();
output();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
char h[4] = {'1', '6', '8', '9'};
void ok(string x) {
reverse(((x).begin()), ((x).end()));
long long k = 1, m = 0;
for (int i = 0; i < ((int)((x).size())); i++, k *= 10) {
m += k * (x[i] - '0');
k %= 7;
m %= 7;
}
if (!m) reverse(((x).begin()), ((x).end())), cout << x, exit(0);
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
string s;
cin >> s;
int f[10] = {0};
string t = "";
for (int i = 0; i < ((int)((s).size())); i++) {
s[i] -= '0';
if ((s[i] == 1 || s[i] == 6 || s[i] == 8 || s[i] == 9) && !f[s[i]])
f[s[i]] = 1;
else
t += char(s[i] + '0');
}
do {
string tot = "";
for (int i = 0; i < 4; i++) tot += h[i];
tot += t;
ok(tot);
} while (next_permutation(h, h + 4));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
inline long long getint() {
long long summ = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch) && ch != '-'; ch = getchar())
;
if (ch == '-') f = -1, ch = getchar();
for (; isdigit(ch); ch = getchar())
summ = (summ << 3) + (summ << 1) + ch - 48;
return summ * f;
}
const long long M = 1e6 + 5, N = 3e5;
long long q[M], L[M], R[M], ch[M], inv[M];
long long n, m;
inline long long ksm(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
inline long long c(long long x, long long y) {
if (x > y || x < 0 || y < 0) return 0;
return q[y] * inv[x] % mod * inv[y - x] % mod;
}
long long s[N + 5][42];
long long a[M], b[M];
signed main() {
q[0] = 1;
for (long long i = 1; i <= N; i++) q[i] = q[i - 1] * i % mod;
inv[N] = ksm(q[N], mod - 2);
for (long long i = N - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
cin >> n >> m;
long long up = 0;
for (long long i = 1; i <= n; i++) {
L[i] = getint();
R[i] = getint();
up = max(up, R[i]);
ch[L[i]]++;
ch[R[i] + 1]--;
}
for (long long i = 1; i <= m; i++) a[i] = getint(), b[i] = getint();
for (long long i = 1; i <= up; i++) ch[i] += ch[i - 1];
for (long long i = 0; i <= 40; i++) {
for (long long j = 1; j <= n; j++)
s[j][i] = (s[j - 1][i] + c(j - i, ch[j] - i));
}
long long ans = 0;
for (long long i = 0; i < (1 << m); i++) {
long long l = 1, r = n, siz = 0;
set<long long> S;
for (long long j = 1; j <= m; j++) {
if (i & (1ll << (j - 1))) {
siz++;
l = max(l, max(L[a[j]], L[b[j]]));
r = min(r, min(R[a[j]], R[b[j]]));
S.insert(a[j]);
S.insert(b[j]);
}
}
if (l > r) continue;
long long sum = s[r][S.size()] - s[l - 1][S.size()];
sum %= mod;
if (siz & 1)
ans = (ans - sum) % mod;
else
ans = (ans + sum) % mod;
}
cout << (ans + mod) % mod;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int const mod = (1e9) + 7;
int const N = (1e5) + 5;
long long power(long long a, long long deg) {
long long res = 1;
while (deg) {
if (deg % 2 == 0) {
a = (a * a) % mod;
deg /= 2;
} else {
res = (res * a) % mod;
deg--;
}
}
return res;
}
int main() {
int k;
cin >> k;
int even = 1;
long long deg = 2;
for (int i = 0; i < k; ++i) {
long long a;
scanf("%I64d", &a);
even *= (a % 2 == 0 ? 0 : 1);
deg = (power(deg, a)) % mod;
}
deg = (deg * power(2, mod - 2)) % mod;
long long p = deg;
if (!even)
p = (p + 1) % mod;
else
p = (p - 1) % mod;
p = (p * power(3, mod - 2)) % mod;
long long q = deg;
cout << p << "/" << q;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[1005];
int before[1005];
vector<int> g;
bool used[1005];
int pos;
bool dp[1005];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
before[a[i]] = i;
}
pos = 1;
while (before[m]) m = before[m], pos--;
used[m] = true;
while (a[m]) m = a[m], pos++, used[m] = true;
for (int i = 1; i <= n; i++) {
if (before[i] == 0 && !used[i]) {
int sz = 1;
int t = i;
while (a[t]) t = a[t], sz++, used[t] = true;
g.push_back(sz);
}
}
dp[0] = true;
for (int i = 0; i < g.size(); i++) {
int sz = g[i];
for (int j = n; j >= sz; j--) {
if (dp[j - sz]) dp[j] = true;
}
}
for (int i = 0; i < n; i++) {
if (dp[i]) cout << i + pos << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
long long ans = 7 * min(a / 3, min(b / 2, c / 2));
if (ans) {
a -= ans / 7 * 3;
b -= ans / 7 * 2;
c -= ans / 7 * 2;
}
int ta = a, tb = b, tc = c;
int d[] = {1, 2, 3, 1, 3, 2, 1};
int m = 0;
for (int i = 0; i < 7; ++i) {
int t = 0;
int ta = a, tb = b, tc = c;
for (int j = i, k = 0; k < 7; ++k, j = (i + k) % 7) {
if (d[j] == 1) {
if (ta) {
ta--;
t++;
} else {
break;
}
} else if (d[j] == 2) {
if (tb) {
tb--;
t++;
} else
break;
} else {
if (tc) {
tc--;
t++;
} else
break;
}
}
m = max(m, t);
}
ans += m;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
template <class T>
inline void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
}; // namespace IO
using namespace IO;
const int N = 1000005;
int Q, n = 1e6, x[N];
long long y[N];
char opt;
struct T {
int L, R;
long long max, lazy;
} t[N << 2];
long long tt[N];
void pushup(int pos) { t[pos].max = max(t[pos << 1].max, t[pos << 1 | 1].max); }
void build(int pos, int L, int R) {
t[pos].L = L, t[pos].R = R;
if (L == R) {
t[pos].max = 1LL * L;
return;
}
int mid = (L + R) >> 1;
build(pos << 1, L, mid);
build(pos << 1 | 1, mid + 1, R);
pushup(pos);
}
void pushdown(int pos) {
if (t[pos].lazy) {
t[pos << 1].lazy += t[pos].lazy;
t[pos << 1 | 1].lazy += t[pos].lazy;
t[pos << 1].max += t[pos].lazy;
t[pos << 1 | 1].max += t[pos].lazy;
t[pos].lazy = 0;
}
}
void add(int pos, int L, int R, int y) {
if (L <= t[pos].L && t[pos].R <= R) {
t[pos].lazy += y;
t[pos].max += y;
return;
}
if (L > t[pos].R || R < t[pos].L) return;
pushdown(pos);
add(pos << 1, L, R, y);
add(pos << 1 | 1, L, R, y);
pushup(pos);
}
const long long INF = 1e18;
long long query(int pos, int L, int R) {
if (L <= t[pos].L && t[pos].R <= R) {
return t[pos].max;
}
if (L > t[pos].R || R < t[pos].L) return -INF;
pushdown(pos);
return max(query(pos << 1, L, R), query(pos << 1 | 1, L, R));
}
int lowbit(int x) { return x & -x; }
void addt(int x, long long y) {
while (x <= n) {
tt[x] += y, x += lowbit(x);
}
}
long long queryt(int x) {
long long res = 0;
while (x > 0) {
res += tt[x], x -= lowbit(x);
}
return res;
}
void Add(int x, long long y) {
addt(x, y);
add(1, x + 1, n, -y);
}
void Query(int x) { cout << queryt(x) + query(1, 1, x) - x << '\n'; }
int main() {
scanf("%d\n", &Q);
build(1, 1, n);
for (int i = (1); i <= (Q); ++i) {
scanf("%c", &opt);
if (opt == '+') {
scanf("%d %lld\n", &x[i], &y[i]);
Add(x[i], y[i]);
}
int temp;
if (opt == '-') {
scanf("%d\n", &temp);
Add(x[temp], -y[temp]);
}
if (opt == '?') {
scanf("%d\n", &temp);
Query(temp);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 105;
const int MAXN = 505;
const int MAXM = 1e5 + 5;
int n, k;
long long h[MAXN];
long long memo[MAXN][MAXN * MAXK];
int cardCnt[MAXM], demandCnt[MAXM];
long long calcState(int cards, int players) {
if (cards == 0 || players == 0) return 0;
if (memo[players][cards] != -1) return memo[players][cards];
long long answer = 0;
for (int i = 0; i <= min(k, cards); i++) {
answer = max(answer, h[i] + calcState(cards - i, players - 1));
}
memo[players][cards] = answer;
return answer;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long answer = 0;
cin >> n >> k;
for (int i = 0; i < n * k; i++) {
int x;
cin >> x;
cardCnt[x]++;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
demandCnt[x]++;
}
for (int i = 1; i <= k; i++) {
cin >> h[i];
}
memset(memo, -1, sizeof(memo));
for (int i = 1; i < MAXM; i++) {
answer += calcState(cardCnt[i], demandCnt[i]);
}
cout << answer << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200086;
const int inf = 2.1e9;
const long long Inf = 999999999999999999;
const int mod = 1000000007;
const double eps = 1e-6;
const double pi = acos(-1);
int num[maxn * 6];
long long pre[maxn], a[maxn], b[maxn];
long long rem[maxn * 6];
struct node {
int l, r;
int id;
} q[maxn];
long long ans[maxn];
long long anss;
int block;
int tot = 0;
bool cmp(node a, node b) {
if (a.l / block != b.l / block) {
return a.l < b.l;
}
return a.r < b.r;
}
int pre1[maxn], pre2[maxn], pre3[maxn];
int main() {
int n, m;
long long k;
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
if (a[i] == 1) {
pre[i] = pre[i - 1] + b[i];
} else
pre[i] = pre[i - 1] - b[i];
rem[++tot] = pre[i];
rem[++tot] = pre[i] + k;
rem[++tot] = pre[i] - k;
}
block = sqrt(n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
}
sort(q + 1, q + 1 + m, cmp);
int L = 1, R = 0;
anss = 0;
rem[++tot] = 0;
rem[++tot] = k;
rem[++tot] = -k;
sort(rem + 1, rem + 1 + tot);
tot = unique(rem + 1, rem + 1 + tot) - rem - 1;
for (int i = 0; i <= n; i++) {
pre1[i] = lower_bound(rem + 1, rem + tot + 1, pre[i]) - rem;
pre2[i] = lower_bound(rem + 1, rem + tot + 1, pre[i] + k) - rem;
pre3[i] = lower_bound(rem + 1, rem + tot + 1, pre[i] - k) - rem;
}
num[lower_bound(rem + 1, rem + tot + 1, 0) - rem] = 1;
for (int i = 1; i <= m; i++) {
while (L > q[i].l) {
L--;
int t = pre2[L - 1];
anss += num[t];
num[pre1[L - 1]]++;
}
while (L < q[i].l) {
int t = pre2[L - 1];
num[pre1[L - 1]]--;
anss -= num[t];
L++;
}
while (R > q[i].r) {
int t = pre3[R];
num[pre1[R]]--;
anss -= num[t];
R--;
}
while (R < q[i].r) {
R++;
int t = pre3[R];
anss += num[t];
num[pre1[R]]++;
}
ans[q[i].id] = anss;
}
for (int i = 1; i <= m; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:32000000")
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
int n, m;
int a[10][10];
bool issq(long long x) {
int sq = (int)(sqrt(x + .0) + .5);
return (long long)sq * sq == x;
}
bool check() {
bool ok = true;
for (int i = 0; i < n; ++i) {
long long v1 = 0;
for (int j = 0; j < m; ++j) {
v1 += a[i][j] * (long long)a[i][j];
}
ok &= issq(v1);
if (!ok) return ok;
}
for (int j = 0; j < m; ++j) {
long long v1 = 0;
for (int i = 0; i < n; ++i) {
v1 += a[i][j] * (long long)a[i][j];
}
ok &= issq(v1);
if (!ok) return ok;
}
return ok;
}
void rec(int i, int j) {
if (i == n) {
if (check()) {
for (int p1 = 0; p1 < n; ++p1) {
for (int p2 = 0; p2 < m; ++p2) printf("%d ", a[p1][p2]);
printf("\n");
}
printf("\n");
}
return;
}
int ni = i;
int nj = j + 1;
if (nj == m) nj = 0, ni++;
for (int iter = 0; iter < 9; ++iter) {
a[i][j] = iter + 1;
rec(ni, nj);
}
}
vector<int> solve(int n) {
if (n == 2) {
vector<int> r;
r.push_back(3);
r.push_back(4);
return r;
}
if (n % 2 == 0) {
vector<int> r;
for (int i = 0; i < n - 1; ++i) r.push_back(1);
r.push_back((n - 2) / 2);
return r;
} else {
vector<int> r;
for (int i = 0; i < n - 2; ++i) r.push_back(1);
r.push_back(2);
r.push_back((n + 1) / 2);
return r;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> v1 = solve(n);
vector<int> v2 = solve(m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int res = v1[i] * v2[j];
printf("%d ", res);
}
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& out, vector<T>& v) {
out << "[";
for (auto k : v) out << k << " ";
out << "]"
<< "\n";
return out;
}
struct vertex {
map<char, int> next, go;
int p, link, ini;
bool visto = false;
char pch;
long long peso = 0;
vertex(int p = -1, char pch = -1) : p(p), pch(pch), link(-1), peso(0) {}
};
vector<vertex> t;
void aho_init() {
t.clear();
t.push_back(vertex());
t.push_back(vertex());
}
const int maxn = 3e5;
vector<pair<int, int> > pos;
void add_string(string s, int ini) {
int v = ini;
t[v].ini = ini;
for (int i = 0; i < int(s.size()); i++) {
char c = s[i];
if (!t[v].next.count(c)) {
t[v].next[c] = t.size();
t.push_back(vertex(v, c));
}
v = t[v].next[c];
t[v].ini = ini;
pos.push_back({i, v});
}
t[v].peso++;
}
int go(int v, char c);
int get_link(int v) {
if (t[v].link < 0)
if (v < 2 || t[v].p < 2)
t[v].link = t[v].ini;
else
t[v].link = go(get_link(t[v].p), t[v].pch);
return t[v].link;
}
int go(int v, char c) {
if (!t[v].go.count(c))
if (t[v].next.count(c))
t[v].go[c] = t[v].next[c];
else
t[v].go[c] = v < 2 ? v : go(get_link(v), c);
return t[v].go[c];
}
long long der[maxn], rev[maxn];
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
string st, s = "";
cin >> st;
int n, m = st.size();
cin >> n;
aho_init();
for (int i = 0; i < int(n); i++) {
cin >> s;
add_string(s, 0);
reverse(s.begin(), s.end());
add_string(s, 1);
}
sort(pos.begin(), pos.end());
for (auto p : pos) {
int j = p.second;
if (t[j].visto) continue;
t[j].visto = true;
int l = get_link(j);
if (l >= 0) {
t[j].peso += t[l].peso;
}
}
int v = 0;
for (int i = 0; i < int(m); i++) {
v = go(v, st[i]);
der[i] = t[v].peso;
}
v = 1;
for (int i = int(m) - 1; i >= 0; i--) {
v = go(v, st[i]);
rev[i] = t[v].peso;
}
long long res = 0;
for (int i = 0; i < int(m - 1); i++) res += der[i] * rev[i + 1];
cout << res << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 100000000;
int N;
int G[510][510];
int rev[510];
int cur[510][510];
int len[510][510];
long long sum[510];
int main() {
istream& in = cin;
in >> N;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
in >> G[i][j];
}
}
for (int i = 0; i < N; i++) {
in >> rev[i];
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
cur[i][j] = -1;
len[i][j] = INF;
}
}
for (int add = N - 1; add >= 0; add--) {
int av = rev[add];
cur[av][av] = 0;
for (int i = 1; i <= N; i++) {
if (cur[i][i] == -1) continue;
cur[av][i] = G[av][i];
cur[i][av] = G[i][av];
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
que.push(make_pair(0, av));
len[av][av] = 0;
while (!que.empty()) {
pair<int, int> p = que.top();
que.pop();
int cost = p.first;
int v = p.second;
if (len[av][v] < cost) continue;
for (int to = 1; to <= N; to++) {
if (cur[v][to] == -1) continue;
if (cur[v][to] + cost < len[av][to]) {
len[av][to] = cur[v][to] + cost;
que.push(make_pair(len[av][to], to));
}
}
}
for (int i = 1; i <= N; i++) {
if (i == av || cur[i][i] == -1) continue;
len[i][av] = cur[i][av];
que.push(make_pair(len[i][av], i));
}
while (!que.empty()) {
pair<int, int> p = que.top();
que.pop();
int cost = p.first;
int v = p.second;
if (len[v][av] < cost) continue;
for (int from = 1; from <= N; from++) {
if (cur[from][from] == -1) continue;
if (len[from][v] + len[v][av] < len[from][av]) {
len[from][av] = len[from][v] + len[v][av];
que.push(make_pair(len[from][av], from));
}
}
}
for (int v = 1; v <= N; v++) {
for (int to = 1; to <= N; to++) {
if (cur[v][v] == -1 || cur[to][to] == -1) continue;
if (len[v][av] + len[av][to] < len[v][to]) {
len[v][to] = len[v][av] + len[av][to];
}
}
}
sum[add] = 0;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (cur[i][i] == -1 || cur[j][j] == -1) continue;
sum[add] += len[i][j];
}
}
}
for (int i = 0; i < N; i++) {
printf("%I64d ", sum[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAXN = 707;
bool dpl[MAXN][MAXN]{};
bool dpr[MAXN][MAXN]{};
bool g[MAXN][MAXN]{};
int a[MAXN];
int n;
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) g[i][j] = (gcd(a[i], a[j]) > 1);
for (int i = 1; i <= n; ++i) g[0][i] = g[i][n + 1] = true;
for (int i = 1; i <= n; ++i) {
dpl[i][i] = g[i][i + 1];
dpr[i][i] = g[i][i - 1];
}
for (int k = 1; k < n; ++k)
for (int i = 1; i + k <= n; ++i) {
int j = i + k;
dpl[i][j] = dpr[i][j] = false;
for (int r = i; r <= j; ++r) {
bool res = true;
if (i < r) res &= dpl[i][r - 1];
if (r < j) res &= dpr[r + 1][j];
if (g[r][j + 1]) dpl[i][j] |= res;
if (g[i - 1][r]) dpr[i][j] |= res;
}
}
puts(dpl[1][n] ? "Yes" : "No");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n;
vector<pair<int, int> > vec;
for (int i = 0; i < n; i++) {
cin >> x >> y;
vec.push_back(make_pair(x, y));
}
sort(vec.begin(), vec.end());
int mn = vec[0].second;
for (int i = 1; i < n; i++) {
if (mn > vec[i].second) {
mn = max(vec[i].first, mn);
} else {
mn = max(vec[i].second, mn);
}
}
cout << mn;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
for (int i = 1; i <= n / 2; i++)
for (int j = 1; j <= m; j++)
printf("%d %d\n", i, j), printf("%d %d\n", n + 1 - i, m + 1 - j);
if (n & 1) {
int md = (n + 1) / 2;
for (int j = 1; j <= m / 2; j++)
printf("%d %d\n", md, j), printf("%d %d\n", md, m + 1 - j);
if (m & 1) printf("%d %d\n", md, (m + 1) / 2);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, tot;
int a, b, T;
long long K;
typedef struct Ed {
int a, c, nxt;
friend int operator<(struct Ed x, struct Ed y) {
return x.c > y.c || x.c == y.c && x.a > y.a;
}
} E;
const double pi = 4 * atan(1);
long long mpow(long long x, long long y, long long p) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % p;
y = y >> 1;
x = x * x % p;
}
return res;
}
long long qpow(long long x, int y) {
long long res = 1;
int i = 0;
while (y) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
long long gcd(long long x, long long y) {
while (y) {
int r = x % y;
x = y;
y = r;
}
return x;
}
double mabs(double x) {
if (x < 0) return -x;
return x;
}
char s[1000];
int mcmp(int* x, int* y) { return (*x) < (*y); }
int q[1000];
int u[1000], v[1000];
int check(long long x, int l) {
long long K = 0, bt = 1;
long long cc = x;
long long qq[20];
int oo = 0;
while (x && l) {
K += x % 10 * bt;
x /= 10;
bt *= 10;
long long i = 0;
while (i * bt + K < 1989) {
++i;
}
long long tmp = i * bt + K;
--l;
while (1) {
int flag = 0;
for (int j = 0; j < oo && !flag; ++j)
if (tmp == qq[j]) {
flag = 1;
}
if (!flag) break;
++i;
tmp = i * bt + K;
}
if (l && tmp == cc) return 0;
qq[oo++] = tmp;
}
return 1;
}
int main(void) {
scanf("%d", &T);
for (int ci = 1; ci <= T; ++ci) {
scanf("%s", s);
n = strlen(s);
long long bt = n - 4;
bt = qpow(10, bt);
K = 0;
for (int i = 4; i < n; ++i) {
K *= 10;
K += s[i] - '0';
}
long long i = 0;
while (i * bt + K < 1989) {
++i;
}
long long tmp;
while (1) {
tmp = i * bt + K;
if (check(tmp, n - 4)) break;
++i;
}
printf("%I64d\n", tmp);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
const int M = 1e5 + 5;
int a[N];
struct query {
int qid, r;
};
vector<query> q[N];
int l[N];
ll ans[M];
int n, m;
ll dis[N];
ll sum[N];
vector<ll> d[N];
void merge(int u) {
int ls = u << 1, rs = ls | 1;
if (ls <= n && rs <= n)
merge(d[ls].begin(), d[ls].end(), d[rs].begin(), d[rs].end(),
back_inserter(d[u]));
else if (ls <= n)
copy(d[ls].begin(), d[ls].end(), back_inserter(d[u]));
}
int L[N], R[N], sz;
int node[N];
void calc(int u, ll offset, const int sign) {
for (int i = L[u]; i < R[u]; i++) {
for (auto x : q[node[i]]) {
ll r = x.r - (dis[node[i]] - offset) + offset;
int pos = lower_bound(d[u].begin(), d[u].end(), r) - d[u].begin();
ans[x.qid] += sign * (pos * r - sum[pos]);
}
}
}
void dfs(int u) {
node[sz] = u;
L[u] = sz++;
d[u].push_back(dis[u]);
for (int i = 0; i < 2; i++) {
int v = u * 2 + i;
if (v <= n) {
dfs(v);
calc(v, dis[u], -1);
}
}
R[u] = sz;
merge(u);
for (size_t i = 0; i < d[u].size(); i++) sum[i + 1] = sum[i] + d[u][i];
calc(u, dis[u], 1);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i < n; i++) cin >> l[i];
for (int i = 1; i <= n; i++) dis[i] = dis[i >> 1] + l[i - 1];
for (int i = 0; i < m; i++) {
int u, r;
cin >> u >> r;
q[u].push_back({i, r});
}
dfs(1);
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MaxN = 710;
int n;
char s[MaxN];
int p[MaxN];
void init() {
cin >> s + 1;
n = strlen(s + 1);
vector<int> Q;
Q.clear();
for (int i = 1; i <= n; ++i) {
if (s[i] == '(')
Q.push_back(i);
else {
p[p[i] = *Q.rbegin()] = i;
Q.pop_back();
}
}
}
long long F[MaxN][MaxN][3][3];
void solve(int x, int y) {
if (x + 1 == y) {
for (int i = 1; i <= 2; ++i) F[x][y][i][0] = F[x][y][0][i] = 1;
return;
}
if (p[x] == y) {
solve(x + 1, y - 1);
for (int k = 1; k <= 2; ++k)
for (int i = 0; i <= 2; ++i)
for (int j = 0; j <= 2; ++j) {
if (k != i) (F[x][y][k][0] += F[x + 1][y - 1][i][j]) %= MOD;
if (k != j) (F[x][y][0][k] += F[x + 1][y - 1][i][j]) %= MOD;
}
} else {
solve(x, p[x]);
solve(p[x] + 1, y);
for (int k = 1; k <= 2; ++k)
for (int i = 0; i <= 2; ++i)
for (int j = 0; j <= 2; ++j) {
(F[x][y][k][j] += F[x][p[x]][k][0] * F[p[x] + 1][y][i][j]) %= MOD;
if (k != i)
(F[x][y][0][j] += F[x][p[x]][0][k] * F[p[x] + 1][y][i][j]) %= MOD;
}
}
}
int main() {
init();
solve(1, n);
long long ans = 0;
for (int i = 0; i <= 2; ++i)
for (int j = 0; j <= 2; ++j) (ans += F[1][n][i][j]) %= MOD;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
int n;
long long a[MAXN], b[MAXN], ans, sum;
long long p[MAXN], q[MAXN], r[MAXN], s[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int j = 1; j <= n; j++) scanf("%I64d", &b[j]);
for (int i = 1; i <= n; i++) sum += a[i] * (i - 1);
for (int i = 1; i <= n; i++) sum += b[n - i + 1] * (n + i - 1);
ans = max(ans, sum);
sum = 0;
for (int i = 1; i <= n; i++) sum += b[i] * i;
for (int i = 1; i < n; i++) sum += a[n - i + 1] * (n + i);
ans = max(ans, sum);
sum = 0;
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1];
if (i & 1) {
p[i] += a[i] * (i * 2 - 2);
p[i] += b[i] * (i * 2 - 1);
} else {
p[i] += a[i] * (i * 2 - 1);
p[i] += b[i] * (i * 2 - 2);
}
}
for (int i = n; i >= 1; i--) s[i] = s[i + 1] + a[i] + b[i];
for (int i = n; i >= 1; i--) {
q[i] = q[i + 1] + s[i + 1] + a[i] + b[i] * (n - i + 1) * 2;
r[i] = r[i + 1] + s[i + 1] + b[i] + a[i] * (n - i + 1) * 2;
}
for (int i = 1; i <= n; i++) {
if (i & 1)
ans = max(ans, p[i] + r[i + 1] + s[i + 1] * (2 * i - 1));
else
ans = max(ans, p[i] + q[i + 1] + s[i + 1] * (2 * i - 1));
}
printf("%I64d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
long long a[N];
long long f[N];
set<long long> pr;
void check(long long num) {
long long st = num;
for (long long i = 2; i <= st / i; ++i) {
if (num % i == 0) {
pr.insert(i);
while (num % i == 0) num /= i;
}
}
if (num != 1) pr.insert(num);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
clock_t ttt = clock();
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
f[i] = a[i] + f[i - 1];
}
if (f[n] == 1) {
cout << -1 << '\n';
return 0;
}
check(f[n]);
long long ans = 1LL << 60;
for (auto &v : pr) {
if (f[n] % v != 0) continue;
long long cur = 0LL;
for (int i = 1; i < n; ++i) {
cur += min(f[i] % v, v - (f[i] % v));
}
ans = min(ans, cur);
}
cout << ans << '\n';
cerr << "Time taken " << (double)(clock() - ttt) / CLOCKS_PER_SEC
<< " seconds\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101010;
vector<int> List[maxn];
int ans[maxn], now[maxn], n, id;
int main() {
scanf("%d", &n);
for (int i = 1; i < 101010; i++) List[i].clear();
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
List[x].push_back(i);
}
memset(now, 0, sizeof(now));
int tot = 0;
for (id = 1; now[1] < List[1].size(); id++) {
for (int i = 1;; i++)
if (now[i] < List[i].size()) {
ans[List[i][now[i]]] = id;
now[i]++;
tot++;
} else
break;
}
if (tot != n)
cout << -1;
else {
cout << id - 1 << endl;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n == 2) {
cout << "2" << endl;
} else {
cout << "1" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
int Hash1[maxn], Hash2[maxn];
char h[25], a[25];
int n;
int main() {
scanf("%s%s", h, a);
scanf("%d", &n);
int aa, bb;
char ss1[5], ss2[5];
for (int i = 0; i < n; i++) {
scanf("%d%s%d%s", &aa, ss1, &bb, ss2);
if (ss1[0] == 'h') {
if (Hash1[bb] == -1) continue;
if (ss2[0] == 'r') {
printf("%s %d %d\n", h, bb, aa);
Hash1[bb] = -1;
} else {
Hash1[bb]++;
if (Hash1[bb] == 2) {
printf("%s %d %d\n", h, bb, aa);
Hash1[bb] = -1;
}
}
}
if (ss1[0] == 'a') {
if (Hash2[bb] == -1) continue;
if (ss2[0] == 'r') {
printf("%s %d %d\n", a, bb, aa);
Hash2[bb] = -1;
} else {
Hash2[bb]++;
if (Hash2[bb] == 2) {
printf("%s %d %d\n", a, bb, aa);
Hash2[bb] = -1;
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int L = 50500, C = 27, N = 11, root = 0, None = -987958798;
const char END = '{';
struct node {
int s[C], b[N], par, val;
} t[L * 22] = {};
char ch[L * 22] = {};
int n, l = 0, tot = 0, x[N] = {}, y[N] = {}, d[N] = {}, in[L * 22] = {},
q[L * 22] = {}, head = 0, tail = 0;
long long ans = 0;
void add(int p, int c) {
int np = ++tot;
t[np].val = t[p].val + 1;
while (p != None && t[p].s[c] == 0) t[p].s[c] = np, p = t[p].par;
if (p == None)
t[np].par = root;
else {
int q = t[p].s[c];
if (t[p].val + 1 == t[q].val)
t[np].par = q;
else {
int nq = ++tot;
t[nq] = t[q];
t[nq].val = t[p].val + 1;
t[q].par = t[np].par = nq;
for (int i = p; i != None && t[i].s[c] == q; i = t[i].par) t[i].s[c] = nq;
}
}
}
int main() {
t[root].par = None;
d[0] = ++l;
cin >> (ch + d[0]) >> n;
l += strlen(ch + d[0]);
for (int i = 1; i <= n; ++i) {
ch[l] = END;
d[i] = ++l;
cin >> (ch + d[i]) >> x[i] >> y[i];
l += strlen(ch + d[i]);
}
ch[l] = END;
for (int i = 1, p = root; i < l; p = t[p].s[ch[i++] - 'a'])
add(p, ch[i] - 'a');
for (int i = 0; i <= n; ++i)
for (int j = d[i], p = t[root].s[ch[j] - 'a']; ch[j] != END;
p = t[p].s[ch[++j] - 'a'])
++t[p].b[i];
for (int i = 1; i <= tot; ++i) ++in[t[i].par];
for (int i = 1; i <= tot; ++i)
if (!in[i]) q[++tail] = i;
for (int tmp = 1; tmp <= tot; ++tmp) {
int s = q[++head];
bool flag = t[s].b[0];
for (int i = 1; i <= n; ++i) flag &= x[i] <= t[s].b[i] && t[s].b[i] <= y[i];
if (flag) ans += t[s].val - t[t[s].par].val;
for (int i = 0; i <= n; ++i) t[t[s].par].b[i] += t[s].b[i];
if ((--in[t[s].par]) == 0) q[++tail] = t[s].par;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int pas = 0, tem, tem1;
int n;
cin >> n;
vector<int> parent(n + 1, 0);
int x, y;
vector<vector<int> > s(n + 1, (vector<int>(3)));
for (int i = 1; i <= n; i++) {
cin >> s[i][1] >> s[i][2];
}
for (int i = 1; i <= n; i++) {
if (parent[i] == 0) {
parent[i] = i;
pas++;
}
for (int j = i + 1; j <= n; j++) {
if ((s[i][1] == s[j][1]) || (s[i][2] == s[j][2]))
if (parent[j] == 0)
parent[j] = parent[i];
else {
if (parent[i] != parent[j]) {
tem = parent[j];
tem1 = parent[i];
for (int h = 1; h <= n; h++)
if (parent[h] == tem) parent[h] = tem1;
pas--;
}
}
}
}
pas--;
cout << pas;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int main(void) {
long long n;
scanf("%I64d", &n);
printf("%I64d\n", (n - 2) * (n - 2));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<string, int> address;
string server;
cin >> server;
address[server] = 1;
int cnt = 1;
auto itr = address.find(server);
while (1) {
string str1 = server.substr(0, server.length() - 1);
string str2 = server.substr(server.length() - 1, server.length());
server = str2 + str1;
itr = address.find(server);
if (itr->second == 1) break;
address[server] = 1;
cnt++;
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
vector<int> vals;
int val;
val = a + b + c;
vals.push_back(val);
val = a + b * c;
vals.push_back(val);
val = a * (b + c);
vals.push_back(val);
val = a * b * c;
vals.push_back(val);
val = (a + b) * c;
vals.push_back(val);
val = a * b + c;
vals.push_back(val);
sort(vals.begin(), vals.end());
cout << vals[vals.size() - 1] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1E9 + 7;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
int b, d, cnt[107];
string a, c;
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(15) << fixed;
cin >> b >> d >> a >> c;
int n = ((int)(a).size());
int m = ((int)(c).size());
for (int i = 0; i < (m); ++i) {
int poz = 0;
for (int j = 0; j < (n); ++j)
if (a[j] == c[(i + poz) % m]) poz++;
cnt[i] = poz;
}
int poz = 0;
for (int i = 0; i < (b); ++i) poz += cnt[poz % m];
cout << (poz / (m * d)) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t-- > 0) {
long long int n, m;
cin >> n >> m;
string s;
cin >> s;
while (m--) {
long long int a, b;
char c, d;
cin >> a >> b >> c >> d;
a--;
for (long long int i = a; i < b; i++) {
if (s[i] == c) s[i] = d;
}
}
cout << s << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
#define pb push_back
typedef long long ll;
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector <ll> vec(n);
vector <pair<ll, int>> add;
ll sum1 = 0, sum2 = 0;
for (int i = 0; i < n; ++i) {
cin >> vec[i];
sum1 += vec[i];
if (sum1 > sum2) {
add.pb({sum1, i});
sum2 = sum1;
}
}
vector <ll> add2;
for (auto it : add)
add2.pb(it.first);
while (m--) {
ll x;
cin >> x;
int pos = lower_bound(add2.begin(), add2.end(), x) - add2.begin();
if (pos < add2.size())
cout << add[pos].second << " ";
else {
if (sum1 <= 0)
cout << -1 << " ";
else {
ll l = 1, r = 2e9;
ll ans2 = -1;
while (l <= r){
ll mid = (l + r) >> 1;
ll temp = x - mid * sum1;
ll ans = n * mid - 1;
bool f = true;
if (temp > 0){
int pos = lower_bound(add2.begin(), add2.end(), temp) - add2.begin();
if (pos < add2.size())
ans += add[pos].second + 1;
else
f = false;
}
if (f){
ans2 = ans;
r = mid - 1;
}
else
l = mid + 1;
}
cout << ans2 << " ";
}
}
}
cout << endl;
}
} | 5 |
#include <bits/stdc++.h>
using std::sort;
long long n, v;
long long up[1010], down[1010];
long long numUp, numDown;
long long area[1010], ans[1010], tp;
long long tmp1[1010], num1;
long long tmp2[1010], num2;
inline long long cmp(long long x, long long y) { return area[x] < area[y]; }
signed main() {
ans[++tp] = 1;
scanf("%lld", &n);
for (long long i = 3; i <= n; ++i) {
printf("1 1 2 %lld\n", i);
fflush(stdout);
scanf("%lld", area + i);
printf("2 1 2 %lld\n", i);
fflush(stdout);
scanf("%lld", &v);
if (~v)
up[++numUp] = i;
else
down[++numDown] = i;
}
long long mx(0);
for (long long i = 1; i <= numDown; ++i)
if (area[down[i]] > area[mx]) mx = down[i];
for (long long i = 1; i <= numDown; ++i)
if (down[i] != mx) {
printf("2 1 %lld %lld\n", mx, down[i]);
fflush(stdout);
scanf("%lld", &v);
if (~v)
tmp2[++num2] = down[i];
else
tmp1[++num1] = down[i];
}
sort(tmp1 + 1, tmp1 + num1 + 1, cmp);
sort(tmp2 + 1, tmp2 + num2 + 1, cmp);
for (long long i = 1; i <= num1; ++i) ans[++tp] = tmp1[i];
if (mx) ans[++tp] = mx;
for (long long i = num2; i; --i) ans[++tp] = tmp2[i];
ans[++tp] = 2;
mx = num1 = num2 = 0;
for (long long i = 1; i <= numUp; ++i)
if (area[up[i]] > area[mx]) mx = up[i];
for (long long i = 1; i <= numUp; ++i)
if (up[i] != mx) {
printf("2 1 %lld %lld\n", mx, up[i]);
fflush(stdout);
scanf("%lld", &v);
if (~v)
tmp2[++num2] = up[i];
else
tmp1[++num1] = up[i];
}
sort(tmp1 + 1, tmp1 + num1 + 1, cmp);
sort(tmp2 + 1, tmp2 + num2 + 1, cmp);
for (long long i = 1; i <= num1; ++i) ans[++tp] = tmp1[i];
if (mx) ans[++tp] = mx;
for (long long i = num2; i; --i) ans[++tp] = tmp2[i];
printf("0 ");
for (long long i = 1; i <= tp; ++i) printf("%lld ", ans[i]);
putchar('\n');
fflush(stdout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int a[MAXN << 1];
int b[MAXN], dp[MAXN], pre[MAXN];
long long sum[MAXN << 1];
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n + 1; i <= n + n; i++) a[i] = a[i - n];
for (int i = 1; i <= n + n; i++) sum[i] = sum[i - 1] + a[i];
while (q--) {
long long v;
cin >> v;
int l = 1, r = 1;
while (1) {
if (r - l >= n || sum[r] - sum[l - 1] > v) {
b[l++] = r - 1;
if (l > n) break;
} else
r++;
}
int ans = 100000000;
for (int i = n; i >= 1; i--) {
int r = b[i];
if (r >= n) {
dp[i] = 1;
pre[i] = r + 1 - n;
if (pre[i] >= i) ans = min(ans, dp[i]);
} else {
dp[i] = dp[r + 1] + 1;
pre[i] = pre[r + 1];
if (pre[i] >= i) ans = min(ans, dp[i]);
}
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n = 0, m = 0;
int base = 1234987;
int steps = -1e8;
int nxt;
int poi(int x, int y) {
printf("0 %d %d\n", x, y);
fflush(stdout);
int answer;
scanf("%d", &answer);
return answer;
}
int ans[2][123456];
int main() {
while (steps <= 1e8) {
int liblibal = poi(steps, steps);
if (liblibal) nxt = liblibal;
if (!liblibal) {
if (poi(steps, base) == 0) ans[0][++n] = steps;
if (poi(base, steps) == 0) ans[1][++m] = steps;
nxt = 1;
if (steps + 1000 <= 1e8 && poi(steps + 1000, steps + 1000) == 1000)
nxt = 1000;
}
steps += nxt;
}
cout << 1 << " " << n << " " << m << endl;
for (int i = 1; i <= n; i++) printf("%d ", ans[0][i]);
cout << endl;
for (int i = 1; i <= m; i++) printf("%d ", ans[1][i]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
bool p[N];
int n, a[N], sorted[N], fmove[N], pos[N];
vector<int> pr;
vector<pair<int, int> > ans;
void mswap(int i, int j) {
ans.push_back(make_pair(i, j));
pos[a[i]] = j;
pos[a[j]] = i;
swap(a[i], a[j]);
}
int main() {
p[1] = true;
for (int i = 2; i * i < N; ++i)
if (!p[i])
for (int j = i * i; j < N; j += i) p[j] = true;
cin >> n;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
--a[i];
pos[a[i]] = i;
}
for (int i = 2; i <= n + 1; ++i)
if (!p[i]) pr.push_back(i);
for (int l = 2; l <= n + 1; ++l) {
if (!p[l]) {
fmove[l] = l;
continue;
}
if (l % 2 == 0) continue;
for (int i = 0; i < pr.size() && pr[i] < l; ++i)
if (!p[l - pr[i] + 1]) {
fmove[l] = pr[i];
break;
}
assert(fmove[l] != 0);
}
for (int i = 0; i < n; ++i)
if (i != a[i]) {
int len = pos[i] - i + 1;
if (fmove[len] == len) {
mswap(i, pos[i]);
continue;
}
if (len % 2 == 0) {
mswap(pos[i] - 1, pos[i]);
--len;
}
if (fmove[len] == len)
mswap(i, pos[i]);
else {
int to = pos[i] - fmove[len] + 1;
mswap(to, pos[i]);
mswap(i, to);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i)
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> ar;
vector<int> br;
vector<int> cr;
int i, j, k;
if (n % 2 == 0) {
cout << "-1" << endl;
return 0;
}
for (i = 0; i < n; i++) {
if (i != n - 1) {
ar.push_back(i);
br.push_back(i + 1);
cr.push_back((i + i + 1) % n);
} else {
ar.push_back(i);
br.push_back(0);
cr.push_back(i);
}
}
for (i = 0; i < n; i++) cout << ar[i] << " ";
cout << endl;
for (i = 0; i < n; i++) cout << br[i] << " ";
cout << endl;
for (i = 0; i < n; i++) cout << cr[i] << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
getline(cin, s);
s += ' ';
int madj = 0, wadj = 0, mn = 0, wn = 0, mv = 0, wv = 0;
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == ' ') {
cnt++;
if (i >= 4) {
if (s.substr(i - 4, 4) == "lios") {
madj++;
t += 'a';
continue;
}
}
if (i >= 5) {
if (s.substr(i - 5, 5) == "liala") {
wadj++;
t += 'a';
continue;
}
}
if (i >= 3) {
if (s.substr(i - 3, 3) == "etr") {
mn++;
t += 'n';
continue;
}
}
if (i >= 4) {
if (s.substr(i - 4, 4) == "etra") {
wn++;
t += 'n';
continue;
}
}
if (i >= 6) {
if (s.substr(i - 6, 6) == "initis") {
mv++;
t += 'v';
continue;
}
}
if (i >= 6) {
if (s.substr(i - 6, 6) == "inites") {
wv++;
t += 'v';
continue;
}
}
cout << "NO";
return 0;
}
}
if (cnt == 1) {
cout << "YES";
return 0;
}
if ((madj >= 0 && mn == 1 && mv >= 0 && wadj == 0 && wn == 0 && wv == 0) ||
(madj == 0 && mn == 0 && mv == 0 && wadj >= 0 && wn == 1 && wv >= 0)) {
for (int i = 1; i < t.size(); i++) {
if (t[i] == 'a' && (t[i - 1] == 'n' || t[i - 1] == 'v')) {
cout << "NO";
return 0;
}
if (t[i] == 'n' && t[i - 1] == 'v') {
cout << "NO";
return 0;
}
if (t[i] == 'v' && t[i - 1] == 'a') {
cout << "NO";
return 0;
}
}
if (t[t.size() - 1] == 'a') {
cout << "NO";
return 0;
} else {
cout << "YES";
return 0;
}
} else {
cout << "NO";
return 0;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 10;
const long long mod = 1e9 + 7;
vector<int> c[3];
bool inc(int ii, vector<int> c) {
for (int i = 0; i < c.size(); i++) {
if (ii == c[i]) return true;
}
return false;
}
bool isin(string k) {
if (k.size() == 1) {
for (int i = 0; i < 3; i++) {
if (c[i].size() > 0) {
if (inc(k[0] - '0', c[i])) return true;
}
}
} else if (k.size() == 2) {
if (c[0].size() == 6 && c[1].size() == 6) {
if (inc(k[0] - '0', c[0]) && inc(k[1] - '0', c[1])) return true;
if (inc(k[0] - '0', c[1]) && inc(k[1] - '0', c[0])) return true;
}
if (c[1].size() == 6 || c[2].size() == 6) {
if (inc(k[0] - '0', c[1]) && inc(k[1] - '0', c[2])) return true;
if (inc(k[0] - '0', c[2]) && inc(k[1] - '0', c[1])) return true;
}
if (c[0].size() == 6 || c[2].size() == 6) {
if (inc(k[0] - '0', c[0]) && inc(k[1] - '0', c[2])) return true;
if (inc(k[0] - '0', c[2]) && inc(k[1] - '0', c[0])) return true;
}
} else if (k.size() == 3) {
if (c[0].size() != 6 || c[1].size() != 6 || c[2].size() != 6) return false;
if (inc(k[0] - '0', c[0]) && inc(k[1] - '0', c[1]) && inc(k[2] - '0', c[2]))
return true;
if (inc(k[0] - '0', c[0]) && inc(k[2] - '0', c[1]) && inc(k[1] - '0', c[2]))
return true;
if (inc(k[1] - '0', c[0]) && inc(k[0] - '0', c[1]) && inc(k[2] - '0', c[2]))
return true;
if (inc(k[1] - '0', c[0]) && inc(k[2] - '0', c[1]) && inc(k[0] - '0', c[2]))
return true;
if (inc(k[2] - '0', c[0]) && inc(k[0] - '0', c[1]) && inc(k[1] - '0', c[2]))
return true;
if (inc(k[2] - '0', c[0]) && inc(k[1] - '0', c[1]) && inc(k[0] - '0', c[2]))
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 6; j++) {
int ai;
cin >> ai;
c[i].push_back(ai);
}
}
for (int i = 1; i <= 999; i++) {
if (!isin(to_string(i))) {
cout << i - 1;
return 0;
}
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.