solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
T POW(T B, T printf) {
if (printf == 0) return 1;
if (printf & 1)
return B * POW(B, printf - 1);
else
return SQR(POW(B, printf / 2));
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool Check(int N, int pos) { return (bool)(N & (1 << pos)); }
int ts, kk = 1;
int main() {
int(n);
scanf("%d", &n);
set<int> s;
bool flg = 0;
for (int i = 1; i <= n; i++) {
int(x);
scanf("%d", &x);
if (i == 1 && x == 753088) flg = 1;
s.insert(x);
}
int a, b;
scanf("%d%d", &a, &b);
int ans = 0;
while (a > b) {
int mx = 1;
vector<int> v;
for (auto x : s) {
if (a - (a % x) < b) {
v.push_back(x);
continue;
}
mx = max(mx, a % x);
if (x > a) break;
}
ans++;
a -= mx;
for (auto x : v) {
s.erase(x);
}
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double eps = 1e-7;
const int N = 2e5 + 10;
struct node {
long long x, b;
} c[N];
bool cmp(node n1, node n2) { return n1.x < n2.x; }
long long b[N];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
long long res = 0;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> b[i], res = max(res, b[i]);
for (int i = 1; i <= n; ++i) c[i].x = i - b[i], c[i].b = b[i];
sort(c + 1, c + n + 1, cmp);
for (int i = 1; i <= n; ++i) {
long long tmp = i;
long long tmp1 = c[tmp].b;
while (tmp + 1 <= n && c[tmp + 1].x == c[tmp].x) tmp++, tmp1 += c[tmp].b;
i = tmp;
res = max(res, tmp1);
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
namespace my_std {
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
inline T rnd(T l, T r) {
return uniform_int_distribution<T>(l, r)(rng);
}
template <typename T>
inline bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
inline bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
inline void read(T &t) {
t = 0;
char f = 0, ch = getchar();
double d = 0.1;
while (ch > '9' || ch < '0') f |= (ch == '-'), ch = getchar();
while (ch <= '9' && ch >= '0') t = t * 10 + ch - 48, ch = getchar();
if (ch == '.') {
ch = getchar();
while (ch <= '9' && ch >= '0') t += d * (ch ^ 48), d *= 0.1, ch = getchar();
}
t = (f ? -t : t);
}
template <typename T, typename... Args>
inline void read(T &t, Args &...args) {
read(t);
read(args...);
}
char __sr[1 << 21], __z[20];
int __C = -1, __zz = 0;
inline void Ot() { fwrite(__sr, 1, __C + 1, stdout), __C = -1; }
inline void print(int x) {
if (__C > 1 << 20) Ot();
if (x < 0) __sr[++__C] = '-', x = -x;
while (__z[++__zz] = x % 10 + 48, x /= 10)
;
while (__sr[++__C] = __z[__zz], --__zz)
;
__sr[++__C] = '\n';
}
void file() {}
inline void chktime() {}
long long ksm(long long x, int y) {
long long ret = 1;
for (; y; y >>= 1, x = x * x)
if (y & 1) ret = ret * x;
return ret;
}
} // namespace my_std
using namespace my_std;
int n, K;
struct pt {
long long x, y;
pt(long long X = 0, long long Y = 0) { x = X, y = Y; }
const pt operator+(const pt &a) const { return pt(x + a.x, y + a.y); }
const pt operator-(const pt &a) const { return pt(x - a.x, y - a.y); }
} a[422];
int nxt[422], pre[422];
long long Dot(pt a, pt b) { return a.x * b.x + a.y * b.y; }
long long Cross(pt a, pt b) { return a.x * b.y - a.y * b.x; }
int dp[422][422];
pair<int, int> pos[422][422];
int check(long long w) {
for (int i = (0); i <= (n - 1); i++)
for (int j = (0); j <= (n - 1); j++)
dp[i][j] = -1e7, pos[i][j] = make_pair(-1, -1);
for (int len = (2); len <= (n - 1); len++)
for (int i = (0); i <= (n - 1); i++) {
int j = (i + len) % n;
long long sum = 0;
for (int k = nxt[i]; k != j; k = nxt[k])
sum += abs(Cross(a[k] - a[pre[k]], a[k] - a[j]));
if (sum < w) continue;
dp[i][j] = 1;
for (int k = nxt[i]; k != j; k = nxt[k])
if (abs(Cross(a[k] - a[i], a[k] - a[j])) >= w &&
chkmax(dp[i][j], 1 + dp[i][k] + dp[k][j]))
pos[i][j] = make_pair(k, k);
int l = i, r = j;
long long cur = 0;
while (cur < w)
r = pre[r], cur += abs(Cross(a[r] - a[l], a[r] - a[nxt[r]]));
chkmax(dp[i][j], dp[l][r] + 1);
while (l != pre[j]) {
l = nxt[l];
if (pre[l] != r)
cur += abs(Cross(a[l] - a[pre[l]], a[l] - a[r]));
else
r = l, cur = sum;
while (r != j && cur - abs(Cross(a[r] - a[l], a[r] - a[nxt[r]])) >= w)
cur -= abs(Cross(a[r] - a[l], a[r] - a[nxt[r]])), r = nxt[r];
if (chkmax(dp[i][j], 1 + dp[l][r])) pos[i][j] = make_pair(l, r);
}
}
int mx = 0;
for (int l = (0); l <= (n - 1); l++)
for (int r = (l + 2); r <= (n - 1); r++)
chkmax(mx, dp[l][r] + dp[r][l] - 1);
return mx;
}
int main() {
file();
read(n, K);
for (int i = (0); i <= (n - 1); i++)
read(a[i].x, a[i].y), pre[i] = (i - 1 + n) % n, nxt[i] = (i + 1) % n;
if (K == 0) {
long long s = 0;
for (int i = (1); i <= (n - 2); i++)
s += abs(Cross(a[i] - a[i - 1], a[i] - a[n - 1]));
cout << s;
return 0;
}
long long l = 0, r = 1e18, ans = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid) >= K)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int INF = 0x3f3f3f3f;
const int M = 1000 + 5;
int main() {
int a[M], b[M], i, j, MAX, n;
while (~scanf("%d", &n)) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
for (i = 1; i <= n; i++) a[i] = a[i] | a[i - 1];
for (j = 1; j <= n; j++) b[j] = b[j] | b[j - 1];
MAX = -INF;
a[0] = a[n + 1] = b[0] = b[n + 1] = 0;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++)
MAX = ((MAX) > ((a[j] | a[i - 1]) + (b[j] | b[i - 1]))
? (MAX)
: ((a[j] | a[i - 1]) + (b[j] | b[i - 1])));
}
printf("%d\n", MAX);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
const long long maxn = 1005;
const long long maxm = 1000005;
const long long dd = 998244353;
long long n, m;
long long a[maxm], sav[maxm], dp[maxn][maxn], col[maxn][maxn], L[maxn], R[maxn];
vector<long long> t[maxn];
struct nod {
long long val, pos;
} uni[maxm];
inline bool cmp(nod x, nod y) { return x.val < y.val; }
inline long long read() {
long long ret = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -f;
ch = getchar();
}
while (isdigit(ch)) {
ret = ret * 10 + ch - '0';
ch = getchar();
}
return ret * f;
}
void scan() {
m = read();
n = read();
for (long long k = 1; k <= n; k++) {
uni[k].val = read();
uni[k].pos = k;
}
}
void prework() {
long long lst = 0;
sort(uni + 1, uni + n + 1, cmp);
for (long long k = 1; k <= n; k++) {
if (uni[k].val != uni[k - 1].val) lst++;
sav[uni[k].pos] = lst;
}
m = lst;
long long now = 0;
for (long long k = 1; k <= n; k++)
if (sav[k] != a[now]) a[++now] = sav[k];
n = now;
for (long long k = 1; k <= n; k++) t[a[k]].push_back(k);
for (long long k = 1; k <= m; k++)
L[k] = t[k][0], R[k] = t[k][t[k].size() - 1];
for (long long k = 1; k <= m; k++)
for (long long j = k + 1; j <= m; j++)
if ((L[j] <= R[k] && R[k] < R[j]) || (R[j] >= L[k] && L[k] > L[j])) {
puts("0");
exit(0);
}
for (long long k = 1; k <= n; k++) {
long long now = k;
for (long long j = k; j <= n; j++)
col[k][j] = a[j] > a[now] ? now : now = j;
}
}
void solve() {
for (long long k = 0; k <= n + 1; k++)
for (long long j = 0; j <= k; j++) dp[k][j] = 1;
dp[0][1] = dp[1][1];
for (long long k = 2; k <= n; k++) {
for (long long l = 1; l + k - 1 <= n; l++) {
long long r = l + k - 1;
long long x = col[l][r], siz = t[a[x]].size();
long long ll = L[a[x]], rr = R[a[x]];
long long ans1 = 0, ans2 = 0, ans3 = 1;
for (long long k = l - 1; k < ll; k++)
ans1 = (ans1 + dp[l][k] * dp[k + 1][ll - 1]) % dd;
for (long long k = r + 1; k > rr; k--)
ans2 = (ans2 + dp[k][r] * dp[rr + 1][k - 1]) % dd;
dp[l][r] = ans1 * ans2 % dd;
for (long long k = 0; k < siz - 1; k++)
ans3 = ans3 * dp[t[a[x]][k] + 1][t[a[x]][k + 1] - 1] % dd;
dp[l][r] = dp[l][r] * ans3 % dd;
}
}
printf("%lld\n", dp[1][n]);
}
signed main() {
scan();
prework();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
cout << s;
for (int i = s.size() - 1; i >= 0; i--) {
cout << s[i];
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int memo[6000][6000];
int f(int ind, int pos) {
if (ind == v.size()) return 0;
int res = 1e8;
int &ret = memo[ind][pos];
if (ret != -1) return ret;
if (pos != v[ind])
res = min(res, 1 + f(ind + 1, pos));
else
res = min(res, f(ind + 1, pos));
if (pos < v[ind]) res = min(res, f(ind + 1, v[ind]));
return ret = res;
}
int main() {
int n, m;
cin >> n >> m;
for (int(i) = 0; (i) < (n); (i)++) {
int k;
double t;
cin >> k >> t;
v.push_back(k);
}
for (int(i) = 0; (i) < (6000); (i)++)
for (int(j) = 0; (j) < (6000); (j)++) memo[i][j] = -1;
cout << f(0, 1) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, z;
long long c = 0;
map<long long, long long> x;
cin >> n;
while (n--) cin >> z, x[z]++;
for (int i = 1; i < 11; i++) c += x[i] * x[-i];
c += (x[0] * (x[0] - 1)) / 2;
cout << c << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long infl = 0x3f3f3f3f3f3f3f3fLL;
const int infi = 0x3f3f3f3f;
void solve() {
int n, i, a, dp[3], req1, req2, req3;
cin >> n;
dp[0] = dp[1] = dp[2] = infi;
dp[0] = 0;
for (i = 0; i < n; i++) {
cin >> a;
if (a == 0) {
req1 = min(dp[1], dp[2]);
dp[0] = min(dp[0], req1) + 1;
dp[1] = infi;
dp[2] = infi;
} else if (a == 1) {
req1 = min(dp[1], dp[2]);
req2 = min(dp[0], dp[2]);
dp[0] = min(dp[0], req1) + 1;
dp[1] = req2;
dp[2] = infi;
} else if (a == 2) {
req1 = min(dp[1], dp[2]);
req2 = min(dp[0], dp[1]);
dp[0] = min(dp[0], req1) + 1;
dp[1] = infi;
dp[2] = req2;
} else {
req1 = min(dp[1], dp[2]);
req2 = min(dp[0], dp[2]);
req3 = min(dp[0], dp[1]);
dp[0] = min(dp[0], req1) + 1;
dp[1] = req2;
dp[2] = req3;
}
}
int ans = min(dp[0], dp[1]);
ans = min(ans, dp[2]);
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
char t1[2][2], t2[2][2];
bool cmp() {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
if (t1[i][j] != t2[i][j]) return false;
return true;
}
void next() {
if (t1[0][0] == 'X') {
t1[0][0] = t1[1][0];
t1[1][0] = 'X';
} else if (t1[1][0] == 'X') {
t1[1][0] = t1[1][1];
t1[1][1] = 'X';
} else if (t1[1][1] == 'X') {
t1[1][1] = t1[0][1];
t1[0][1] = 'X';
} else if (t1[0][1] == 'X') {
t1[0][1] = t1[0][0];
t1[0][0] = 'X';
}
}
int main() {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) std::cin >> t1[i][j];
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) std::cin >> t2[i][j];
for (int i = 0; i < 64; i++) {
if (cmp()) {
std::cout << "YES";
return 0;
}
next();
}
std::cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int fst[100005], nxt[200005], v[200005], tol;
int c[100005];
int fa[100005], sz[100005], dep[100005], son[100005];
int top[100005], scc[100005], _scc;
int rscc[100005];
vector<int> City[100005];
void edge(int a, int b) {
v[tol] = b;
nxt[tol] = fst[a];
fst[a] = tol++;
}
void dfs1(int pa, int u, int deep) {
dep[u] = deep;
fa[u] = pa;
sz[u] = 1;
son[u] = -1;
for (int e = fst[u]; ~e; e = nxt[e]) {
if (v[e] == pa) continue;
dfs1(u, v[e], deep + 1);
sz[u] += sz[v[e]];
if (son[u] == -1 || sz[son[u]] < sz[v[e]]) {
son[u] = v[e];
}
}
}
void dfs2(int u) {
scc[u] = (++_scc);
rscc[_scc] = u;
if (~son[u]) {
top[son[u]] = top[u];
dfs2(son[u]);
}
for (int e = fst[u]; ~e; e = nxt[e]) {
if (v[e] == fa[u] || v[e] == son[u]) continue;
top[v[e]] = v[e];
dfs2(v[e]);
}
}
vector<int> S[400005];
void merge(vector<int>& a, vector<int>& b) {
vector<int> c;
c.clear();
int k = min(10, (int(a.size())) + (int(b.size())));
int s = 0, t = 0;
while (k--) {
if (s == (int(a.size())))
c.push_back(b[t++]);
else if (t == (int(b.size())))
c.push_back(a[s++]);
else if (a[s] < b[t])
c.push_back(a[s++]);
else
c.push_back(b[t++]);
}
a.clear();
for (int i = int(0); i < int((int(c.size()))); i++) a.push_back(c[i]);
}
void build(int l, int r, int o) {
S[o].clear();
if (l == r) {
merge(S[o], City[rscc[l]]);
return;
}
int mid = l + r >> 1;
build(l, mid, (o << 1));
build(mid + 1, r, ((o << 1) | 1));
merge(S[o], S[(o << 1)]);
merge(S[o], S[((o << 1) | 1)]);
}
vector<int> ans;
void query(int l, int r, int o, int L, int R) {
if (L <= l && r <= R) {
merge(ans, S[o]);
return;
}
int mid = l + r >> 1;
if (L <= mid) query(l, mid, (o << 1), L, R);
if (mid < R) query(mid + 1, r, ((o << 1) | 1), L, R);
}
void LCA(int u, int v) {
ans.clear();
int f1 = top[u], f2 = top[v];
while (f1 != f2) {
if (dep[f1] < dep[f2]) {
swap(u, v);
swap(f1, f2);
}
query(1, _scc, 1, scc[f1], scc[u]);
u = fa[f1];
f1 = top[u];
}
if (dep[u] > dep[v]) {
swap(u, v);
}
if (u) {
query(1, _scc, 1, scc[u], scc[v]);
} else if (scc[v] >= 2) {
query(1, _scc, 1, 2, scc[v]);
}
}
int main() {
int a, b;
tol = 0;
memset(fst, -1, sizeof(fst));
scanf("%d%d%d", &n, &m, &q);
for (int i = int(0); i < int(n - 1); i++) {
scanf("%d%d", &a, &b);
edge(a, b);
edge(b, a);
}
for (int i = int(1); i < int(m + 1); i++) {
scanf("%d", c + i);
City[c[i]].push_back(i);
}
dfs1(0, 1, 1);
_scc = 0;
top[1] = 1;
dfs2(1);
build(1, _scc, 1);
int v, u;
while (q--) {
scanf("%d%d%d", &v, &u, &a);
LCA(u, v);
a = min(a, (int(ans.size())));
printf("%d", a);
for (int i = int(0); i < int(a); i++) printf(" %d", ans[i]);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int MAXN = 100005;
struct tree1 {
private:
int mx;
int l;
int r;
tree1 *lson;
tree1 *rson;
public:
tree1() {
mx = 0;
lson = rson = NULL;
}
void build(int L, int R) {
l = L;
r = R;
if (l == r) return;
lson = new tree1;
rson = new tree1;
int mid = (l + r) / 2;
lson->build(l, mid);
rson->build(mid + 1, r);
}
void modify(int id, int k) {
if (l == r) {
mx = k;
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
mx = max(lson->mx, rson->mx);
}
int query(int L, int R) {
if (l >= L && r <= R) return mx;
int mid = (l + r) / 2;
if (R <= mid) return lson->query(L, R);
if (L > mid) return rson->query(L, R);
return max(lson->query(L, R), rson->query(L, R));
}
};
struct line {
int k;
int b;
line(int K = 0, int B = 0) {
k = K;
b = B;
}
int calc(int x) { return k * x + b; }
double cross(line t) { return (double)(t.b - b) / (k - t.k); }
};
struct tree {
bool tag;
int l;
int r;
line *L;
int cnt;
line *R;
int rcnt;
int mx;
tree *lson;
tree *rson;
tree() {
tag = false;
L = R = NULL;
cnt = rcnt = mx = 0;
lson = rson = NULL;
}
void fixup() {
static line tmp[MAXN];
l = lson->l;
r = rson->r;
if (L) delete L;
L = new line[lson->cnt + rson->cnt];
cnt = lson->cnt;
for (int i = 0; i < cnt; i++) L[i] = lson->L[i];
for (int i = 0; i < rson->cnt; i++) {
if (rson->L[i].k >= L[cnt - 1].k)
L[cnt - 1].b = (lson->r - lson->l + 1) + rson->L[i].b;
else {
L[cnt++] = rson->L[i];
L[cnt - 1].b += (lson->r - lson->l + 1);
}
}
if (R) delete R;
R = new line[lson->rcnt + rson->rcnt];
rcnt = rson->rcnt;
for (int i = 0; i < rcnt; i++) R[i] = rson->R[i];
for (int i = 0; i < lson->rcnt; i++) {
if (lson->R[i].k >= R[rcnt - 1].k)
R[rcnt - 1].b = (rson->r - rson->l + 1) + lson->R[i].b;
else {
R[rcnt++] = lson->R[i];
R[rcnt - 1].b += (rson->r - rson->l + 1);
}
}
mx = max(lson->mx, rson->mx);
int cur = 0, p = 0, s = 0;
memset(tmp, 0, sizeof(line) * rson->cnt);
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
for (int i = 0; i < lson->rcnt; i++) {
while (cur < rson->cnt && rson->L[cur].k < lson->R[i].k) {
line t = rson->L[cur++];
t.b = (t.b + 1) * t.k;
while (s > 1 && tmp[s - 2].cross(t) < tmp[s - 2].cross(tmp[s - 1])) s--;
if (p >= s) p = max(s - 1, 0);
tmp[s++] = t;
}
while (p < s - 1 &&
tmp[p].calc(lson->R[i].b) < tmp[p + 1].calc(lson->R[i].b))
p++;
while (p && tmp[p].calc(lson->R[i].b) < tmp[p - 1].calc(lson->R[i].b))
p--;
if (cur < rson->cnt)
mx = max(mx, (lson->R[i].b + rson->L[cur].b + 1) * lson->R[i].k);
mx = max(mx, tmp[p].calc(lson->R[i].b));
}
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
}
void build(int rL, int rR, int *a) {
tag = true;
l = rL;
r = rR;
if (l == r) {
mx = a[l] * 2;
L = new line[1];
R = new line[1];
cnt = rcnt = 1;
L[0] = R[0] = line(a[l], 1);
return;
}
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid, a);
rson->build(mid + 1, r, a);
fixup();
}
void modify(int id, int k) {
if (l == r) {
mx = k * 2;
L[0] = R[0] = line(k, 1);
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
fixup();
}
tree *query(int rL, int rR) {
if (l >= rL && r <= rR) return this;
int mid = (l + r) / 2;
if (rR <= mid) return lson->query(rL, rR);
if (rL > mid) return rson->query(rL, rR);
tree *temp = new tree;
temp->lson = lson->query(rL, rR);
temp->rson = rson->query(rL, rR);
temp->fixup();
return temp;
}
void query_clear() {
if (tag) return;
lson->query_clear();
rson->query_clear();
if (L) delete L;
if (R) delete R;
}
};
void print(int *a, int n) {
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
int N, q;
tree1 T1;
tree T;
char *s[MAXN], str[MAXN];
int len[MAXN], lcp[MAXN];
void init() {
scanf("%d %d", &N, &q);
T1.build(1, N);
for (int i = 1; i <= N; i++) {
scanf("%s", str);
len[i] = strlen(str);
s[i] = new char[len[i]];
memcpy(s[i], str, sizeof(char) * len[i]);
T1.modify(i, len[i]);
}
for (int i = 1; i < N; i++) {
int t = 0;
while (t < len[i] && t < len[i + 1] && s[i][t] == s[i + 1][t]) t++;
lcp[i] = t;
}
if (N > 1) T.build(1, N - 1, lcp);
}
int main() {
int ty, x, y;
init();
for (int i = 0; i < q; i++) {
scanf("%d %d", &ty, &x);
if (ty == 1) {
scanf("%d", &y);
int ans = T1.query(x, y);
if (x == y) {
printf("%d\n", ans);
continue;
}
tree *p = T.query(x, y - 1);
ans = max(ans, p->mx);
p->query_clear();
if (!p->l && !p->r) delete p;
std::cout << ans << std::endl;
} else {
scanf("%s", str);
len[x] = strlen(str);
s[x] = new char[len[x]];
memcpy(s[x], str, sizeof(char) * len[x]);
T1.modify(x, len[x]);
int t = 0;
if (x > 1) {
for (t = 0; t < len[x - 1] && t < len[x] && s[x - 1][t] == s[x][t]; t++)
;
lcp[x - 1] = t;
T.modify(x - 1, t);
}
if (x < N) {
for (t = 0; t < len[x] && t < len[x + 1] && s[x][t] == s[x + 1][t]; t++)
;
lcp[x] = t;
T.modify(x, t);
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0, k = 0;
cin >> n;
int* a = (int*)calloc(n, sizeof(int));
int* res = (int*)calloc(n, sizeof(int));
int* f = (int*)calloc(n, sizeof(int));
for (int i = 0; i < n; i++) {
cin >> a[i];
f[i] = 1;
}
for (int i = n - 1; i >= 0; i--) {
if (i - a[i] <= 0)
res[i] = i;
else
res[i] = a[i];
if (i == n - 1)
count = res[i];
else if (count > 0) {
f[i] = 0;
k++;
count--;
}
if (res[i] > count) count = res[i];
}
cout << n - k;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s[300];
long long prime(long long n) {
if (!n or n == 1) return false;
for (long long i = 2; i <= sqrt(n); i++)
if (n % i == 0) return 0;
return 1;
}
int32_t main() {
long long n;
cin >> n;
if (prime(n)) {
cout << 1 << endl;
cout << n << endl;
return 0;
}
if (prime(n - 2)) {
cout << 2 << endl;
cout << 2 << " " << n - 2;
return 0;
}
for (long long i = n - 3; i >= n / 2; i--) {
if (prime(i) and prime(n - i - 3)) {
cout << 3 << endl;
cout << 3 << " " << i << " " << n - i - 3 << endl;
return 0;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265358979323846;
const long long mod = 1e9;
const long long N = 5e6 + 500;
char s[N];
int a[] = {4, 7, 44, 47, 74, 77, 444, 447, 474, 477, 744, 747, 774, 777};
int lucky() {
int i;
for (int i = 0; i < s[i]; i++) {
if (s[i] != '4' || s[i] != '7') return 0;
}
return 1;
}
int main() {
int i, n;
scanf("%s", &s);
if (lucky())
puts("YES");
else {
sscanf(s, "%d", &n);
int fou = 1;
for (i = 0; i < 14; i++) {
if (n % a[i] == 0) {
puts("YES");
fou = 0;
break;
}
}
if (fou) puts("NO");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long v[maxn], t[maxn];
int n;
long long pre[maxn], ans[maxn];
int cnt[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", v + i);
for (int i = 1; i <= n; i++) {
scanf("%I64d", t + i);
pre[i] = pre[i - 1] + t[i];
}
for (int i = 1; i <= n; i++) {
int t1 = lower_bound(pre + i, pre + 1 + n, pre[i - 1] + v[i]) - pre;
cnt[i]++;
cnt[t1]--;
ans[t1] += v[i] - (pre[t1 - 1] - pre[i - 1]);
}
for (int i = 1; i <= n + 1; i++) cnt[i] += cnt[i - 1];
for (int i = 1; i <= n + 1; i++) ans[i] += cnt[i] * t[i];
printf("%I64d", ans[1]);
for (int i = 2; i <= n; i++) printf(" %I64d", ans[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int BUF = 1000000;
char buf[BUF], *p1, *p2;
inline char getChar() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, BUF, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long f = 0;
char c;
while (!isdigit(c = getChar())) {
}
do f = f * 10 + (c ^ 48);
while (isdigit(c = getChar()));
return f;
}
const int maxN = 100003, mod = 1e6;
long long m;
struct Vector {
long long x, y;
Vector() {}
Vector(long long x, long long y) : x(x), y(y) {}
friend bool operator<(const Vector& a, const Vector& b) { return a.x < b.x; }
} now;
set<Vector> hull;
set<Vector>::iterator it, L, R, tmp;
inline bool convex(Vector a, Vector b, Vector c) {
return (b.y - a.y) * (c.x - b.x) >= (c.y - b.y) * (b.x - a.x);
}
inline bool check(Vector a, Vector b, long long x, long long y) {
return m * (b.x - a.x) >= (a.y * b.x - b.y * a.x) * x + (b.y - a.y) * y;
}
int main() {
int n = read(), i, x, y, lst = 0;
m = read();
hull.insert(Vector(0, 0));
for (i = 1; i <= n; ++i) {
if (read() == 1) {
x = (read() + lst) % mod + 1, y = (read() + lst) % mod + 1,
now = Vector(x, y);
R = hull.lower_bound(now);
if (R != hull.end()) {
if ((*R).x == x) {
if (y >= (*R).y) continue;
hull.erase(R), R = hull.lower_bound(now);
if (R == hull.end()) goto GG;
}
L = hull.upper_bound(now), --L;
if (!convex(*L, now, *R)) {
if (L != hull.begin()) {
it = L, --it;
while (L != hull.begin() && convex(*it, *L, now))
tmp = L, --L, --it, hull.erase(tmp);
}
if (R != hull.end()) {
it = R, ++it;
while (it != hull.end() && convex(now, *R, *it))
tmp = R, ++R, ++it, hull.erase(tmp);
}
hull.insert(now);
}
} else {
GG:
L = hull.upper_bound(now), --L;
if (L != hull.begin()) {
it = L, --it;
while (L != hull.begin() && convex(*it, *L, now))
tmp = L, --L, --it, hull.erase(tmp);
}
hull.insert(now);
}
} else {
x = (read() + lst) % mod + 1, y = (read() + lst) % mod + 1;
R = hull.lower_bound(Vector(now.x = (y + x - 1) / x, 0));
if (R != hull.end()) {
L = R, --L;
if (check(*L, *R, x, y))
lst = i, printf("YES\n");
else
printf("NO\n");
} else
printf("NO\n");
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
struct SegmTree {
vector<pair<int, int> > t;
int sz;
SegmTree(int n = 0) {
sz = 1;
while (sz < n) sz *= 2;
t.assign(sz * 2, make_pair(-1, 0));
}
void put(int pos, int val) {
int v = sz + pos;
t[v] = make_pair(val, pos);
v /= 2;
while (v) {
t[v] = max(t[v * 2], t[v * 2 + 1]);
v /= 2;
}
}
pair<int, int> get_max(int l, int r) {
pair<int, int> res(-1, 0);
l += sz;
r += sz;
while (l <= r) {
res = max(res, t[l]);
res = max(res, t[r]);
l = (l + 1) / 2;
r = (r - 1) / 2;
}
return res;
}
};
const int MAXN = 1e5 + 10;
int a[MAXN];
int b[MAXN];
int c[MAXN];
int d[MAXN];
int n;
SegmTree T;
vector<pair<int, int> > x;
bool read() {
if (scanf("%d", &n) < 1) {
return false;
}
for (int i = 0; i < (int)n; ++i) {
scanf("%d%d%d%d", &a[i], &b[i], &c[i], &d[i]);
}
return true;
}
void build() {
for (int i = 0; i < (int)n; ++i) {
x.push_back(make_pair(c[i], i));
}
sort(begin(x), end(x));
T = SegmTree(((int)(x).size()));
for (int i = 0; i < (int)n; ++i) {
int pos = lower_bound(begin(x), end(x), make_pair(c[i], i)) - x.begin();
assert(pos < ((int)(x).size()));
assert(x[pos] == make_pair(c[i], i));
T.put(pos, d[i]);
}
}
vector<int> solve() {
build();
vector<int> nxt(n, -1);
vector<int> ps;
ps.push_back(n - 1);
int pos =
lower_bound(begin(x), end(x), make_pair(c[n - 1], n - 1)) - x.begin();
T.put(pos, -1);
for (int it = 0; !ps.empty(); ++it) {
for (int i : ps) {
if (a[i] == 0 && b[i] == 0) {
vector<int> ans;
for (int j = i; j != -1; j = nxt[j]) {
ans.push_back(j);
}
return ans;
}
}
vector<int> nps;
for (int i : ps) {
int low_x = a[i];
int low_y = b[i];
low_x = upper_bound(begin(x), end(x), make_pair(low_x, -1)) - x.begin();
while (1) {
pair<int, int> cur = T.get_max(low_x, ((int)(x).size()) - 1);
if (cur.first < low_y) {
break;
}
int id = x[cur.second].second;
nxt[id] = i;
nps.push_back(id);
T.put(cur.second, -1);
}
}
ps.swap(nps);
}
return {};
}
int main() {
while (read()) {
vector<int> ans = solve();
if (ans.empty()) {
puts("-1");
} else {
printf("%d\n", ((int)(ans).size()));
for (int i : ans) {
printf("%d ", i + 1);
}
puts("");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
struct node {
int sz;
int knd[2];
int len[2];
int slen[2];
int mx[2];
};
node operator+(const node& s, const node& t) {
node res;
res.sz = s.sz + t.sz;
res.knd[0] = s.knd[0];
res.knd[1] = t.knd[1];
if (s.len[0] < s.sz || s.knd[0] != t.knd[0])
res.len[0] = s.len[0];
else
res.len[0] = s.len[0] + t.len[0];
if (t.len[1] < t.sz || s.knd[1] != t.knd[1])
res.len[1] = t.len[1];
else
res.len[1] = s.len[1] + t.len[1];
if (res.len[1] != res.sz) {
if (s.len[0] == s.sz) {
if (s.knd[0] == t.knd[0])
res.slen[0] = t.slen[0];
else
res.slen[0] = t.len[0];
} else {
if (s.slen[0] + s.len[0] == s.sz && s.knd[0] != t.knd[0])
res.slen[0] = s.slen[0] + t.len[0];
else
res.slen[0] = s.slen[0];
}
if (t.len[1] == t.sz) {
if (s.knd[1] == t.knd[1])
res.slen[1] = s.slen[1];
else
res.slen[1] = s.len[1];
} else {
if (t.slen[1] + t.len[1] == t.sz && t.knd[1] != s.knd[1])
res.slen[1] = t.slen[1] + s.len[1];
else
res.slen[1] = t.slen[1];
}
} else
res.slen[0] = res.slen[1] = 0;
res.mx[0] = max(s.mx[0], t.mx[0]);
res.mx[1] = max(s.mx[1], t.mx[1]);
if (s.knd[1] == 1 && t.knd[0] == 0)
res.mx[0] = max(res.mx[0], s.len[1] + t.len[0]);
if (s.knd[1] == 0 && t.knd[0] == 1)
res.mx[1] = max(res.mx[1], s.len[1] + t.len[0]);
if (s.knd[1] == 1 && t.knd[0] == 1) {
res.mx[0] = max(res.mx[0], s.len[1] + t.len[0] + t.slen[0]);
res.mx[1] = max(res.mx[1], s.slen[1] + s.len[1] + t.len[0]);
}
if (s.knd[1] == 0 && t.knd[0] == 0) {
res.mx[0] = max(res.mx[0], s.slen[1] + s.len[1] + t.len[0]);
res.mx[1] = max(res.mx[1], s.len[1] + t.len[0] + t.slen[0]);
}
return res;
}
void operator~(node& s) {
s.knd[0] ^= 1;
s.knd[1] ^= 1;
swap(s.mx[0], s.mx[1]);
}
const int N = 5e5 + 7;
node seg[N * 4];
bool laz[N * 4];
int n, q;
string str;
void prep(int v = 1, int s = 1, int e = n + 1) {
if (e - s == 1) {
seg[v].len[0] = seg[v].len[1] = 1;
if (str[s - 1] == '>') seg[v].knd[0] = seg[v].knd[1] = 1;
seg[v].mx[0] = seg[v].mx[1] = seg[v].sz = 1;
return;
}
prep((v * 2), s, ((s + e) / 2));
prep((v * 2 + 1), ((s + e) / 2), e);
seg[v] = seg[(v * 2)] + seg[(v * 2 + 1)];
}
void spl(int v) {
for (int u = (v * 2); u <= (v * 2 + 1); u++)
if (laz[v]) {
~seg[u];
laz[u] ^= 1;
}
laz[v] = 0;
}
void rev(int l, int r, int v = 1, int s = 1, int e = n + 1) {
if (r <= s || e <= l) return;
if (l <= s && e <= r) {
~seg[v];
laz[v] ^= 1;
return;
}
spl(v);
rev(l, r, (v * 2), s, ((s + e) / 2));
rev(l, r, (v * 2 + 1), ((s + e) / 2), e);
seg[v] = seg[(v * 2)] + seg[(v * 2 + 1)];
}
node get(int l, int r, int v = 1, int s = 1, int e = n + 1) {
if (r <= s || e <= l) return seg[0];
if (l <= s && e <= r) {
return seg[v];
}
spl(v);
return get(l, r, (v * 2), s, ((s + e) / 2)) +
get(l, r, (v * 2 + 1), ((s + e) / 2), e);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
cin >> str;
prep();
while (q--) {
int l, r;
cin >> l >> r;
rev(l, r + 1);
node s = get(l, r + 1);
cout << s.mx[0] << ' ';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
int total = 0;
int current = 1;
int l, r;
for (int i = 0; i < n; i++) {
cin >> l >> r;
int temp = (l - current) / t;
current += (t * temp);
total += ((r - current) + 1);
current = r + 1;
}
cout << total << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100000];
int main() {
int n, h;
scanf("%d%d", &n, &h);
if (n == 2) {
printf("0\n1 1\n");
return 0;
}
int mi = 1000000000, mini;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
if (a[i] < mi) {
mi = a[i];
mini = i;
}
}
sort(a, a + n);
int Ma1 = a[n - 1] + a[n - 2], Mi1 = a[0] + a[1];
int Mi2 = min(a[2] + a[1], a[0] + a[1] + h);
int Ma2 = max(a[n - 2] + a[n - 1], a[0] + a[n - 1] + h);
if (Ma1 - Mi1 < Ma2 - Mi2) {
printf("%d\n", Ma1 - Mi1);
for (int i = 0; i < n; i++) printf("1 ");
puts("");
} else {
printf("%d\n", Ma2 - Mi2);
for (int i = 0; i < n; i++) {
if (i == mini)
printf("2 ");
else
printf("1 ");
}
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n, K, fac[1005], inv[1005], f[1005];
long long power(long long a, long long b) {
if (!b) return 1;
long long ret = power(a, b >> 1);
if (b & 1) return ret * ret % mod * a % mod;
return ret * ret % mod;
}
long long findinv(long long a) { return power(a, mod - 2); }
long long C(long long n, long long m) {
return fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int main() {
scanf("%lld%lld", &n, &K);
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % mod;
inv[n] = findinv(fac[n]);
for (int i = n; i >= 1; --i) inv[i - 1] = inv[i] * i % mod;
for (int i = 1; i <= n; ++i)
f[i] = power((power(K, i) - power(K - 1, i)) % mod, n);
long long ans = 0;
for (int i = 0; i <= n; ++i) {
long long flag = i % 2 ? -1 : 1;
ans += flag * C(n, i) % mod * power(K - 1, n * i) % mod * f[n - i] % mod;
ans %= mod;
}
ans = (ans + mod) % mod;
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
const int N = 1000006;
const long long M = 998244353;
using namespace std;
void debug(string var, int val) { cout << var << " : " << val << endl; }
int gcd(int f, int s) {
if (s == 0)
return f;
else
return gcd(s, f % s);
}
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
if (a % b != 0)
puts("NO");
else
puts("YES");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, maxm = (1 << 17), mod = 1e9 + 7, hash = 701;
const double PI = 3.14159265359, E = 2.71828;
long long a[maxn];
pair<long long, long long> d[maxn];
int main() {
ios::sync_with_stdio(0);
long long n, sum;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
sum = a[i], d[i] = make_pair((1 << 30), (1 << 30));
for (int j = i - 1; j >= 0; j--) {
if (sum >= d[j].second) {
if (d[j].first + i - j - 1 < d[i].first)
d[i].first = d[j].first + i - j - 1;
if (d[i].first == d[j].first + i - j - 1)
d[i].second = min(d[i].second, sum);
}
sum += a[j];
}
}
cout << d[n].first << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1ll << 62);
const long long mod = 1e9 + 7;
const int MX = 50;
int n, m, msk[MX], x, y, dp[(1 << 22)];
int DP(int mask) {
if (mask + 1 == (1 << n)) return 0;
int &ret = dp[mask];
if (ret != -1) return dp[mask];
ret = MX;
for (int i = 0; i < n; i++) {
if ((mask & (1 << i)) == 0) continue;
if (msk[i] == (1 << i)) continue;
ret = min(ret, DP(mask | msk[i]) + 1);
}
return ret;
}
void FDP(int mask) {
if (mask + 1 == (1 << n)) return;
int &ret = dp[mask];
for (int i = 0; i < n; i++) {
if ((mask & (1 << i)) == 0) continue;
if (msk[i] == (1 << i)) continue;
if (ret == DP(mask | msk[i]) + 1) {
cout << i + 1 << " ";
FDP(mask | msk[i]);
return;
}
}
return;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
msk[x] |= (1 << y);
msk[y] |= (1 << x);
}
for (int i = 0; i < n; i++) msk[i] |= (1 << i);
memset(dp, -1, sizeof(dp));
int ans = 50, idx;
for (int i = 0; i < n; i++) {
int ans1 = DP(msk[i]);
if (ans > ans1 + 1) {
ans = ans1 + 1;
idx = i;
}
}
if (m == n * (n - 1) / 2) {
puts("0");
return 0;
}
cout << ans << endl;
cout << idx + 1 << " ";
FDP(msk[idx]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const long long mod = (1e9) + 7;
const long long M = 998244353;
const double eps = 1e-6;
int n, cnt[110];
long long a[110], b[110], w[110], B[110], tmp;
void No() {
printf("-1\n");
exit(0);
}
int lg(long long x) { return (int)ceil(log(1.0 * x) / log(2.0)); }
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;
}
long long gcd(long long x, long long y) {
if (!x || !y) return x + y;
return gcd(y, x % y);
}
void solve1(int x) {
for (int i = 1; i <= n; i++) {
if (b[i] == 1 && a[i] != a[x]) No();
if (b[i] > 1) {
tmp = a[i];
while (1) {
if (tmp > a[x] / b[i]) No();
tmp *= b[i];
if (tmp == a[x]) break;
}
}
}
printf("%lld\n", a[x]);
exit(0);
}
void solve2(int x) {
long long t1 = a[1] % M, t2, t3;
int num = -1;
for (int i = 0; i < 400; i++) {
t2 = a[x] % M;
for (int j = 0; j < 400; j++) {
if (t1 == t2) {
t3 = t1, num = i;
break;
}
t2 = t2 * b[x] % M;
}
if (num != -1) break;
t1 = t1 * b[1] % M;
}
if (num == -1) No();
bool flag;
for (int i = 1; i <= n; i++) {
t1 = a[i] % M;
flag = 0;
for (int j = 0; j <= 100000; j++) {
if (t1 == t3) {
flag = 1;
break;
}
t1 = t1 * b[i] % M;
}
if (!flag) No();
}
tmp = a[1];
while (num--) tmp = tmp * b[1] % mod;
printf("%lld\n", tmp);
exit(0);
}
int main() {
srand(time(0));
read(n);
for (int i = 1; i <= n; i++) read(a[i]), read(b[i]);
for (int i = 1; i <= n; i++)
if (b[i] == 1) solve1(i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= lg(b[i]); j++) {
tmp = (long long)floor(pow(b[i], 1.0 / j) + 0.5);
if (fabs(pow(tmp, j) - b[i]) < eps) B[i] = j, w[i] = tmp;
}
}
for (int i = 2; i <= n; i++)
if (w[i] != w[1]) solve2(i);
int mx = 0;
for (int i = 1; i <= n; i++) {
while (a[i] % w[i] == 0) a[i] /= w[i], cnt[i]++;
mx = max(mx, cnt[i]);
}
for (int i = 2; i <= n; i++)
if (a[i] != a[1]) No();
long long Lcm = B[1], z, ans = cnt[1];
bool flag = 1;
for (int i = 2; i <= n; i++) {
flag = 0;
for (int j = 0; j < B[i]; j++)
if ((ans + Lcm * j) % B[i] == cnt[i] % B[i]) {
ans += Lcm * j;
flag = 1;
break;
}
if (!flag) No();
z = gcd(Lcm, B[i]);
Lcm = Lcm / z * B[i];
}
while (ans < mx) ans += Lcm;
printf("%lld\n", a[1] * ksm(w[1], ans) % mod);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, Q;
vector<pair<long long, pair<int, int> > > garland[2020];
long long contrib[2020][2020];
int x1[2020], x2[2020], Y1[2020], y2[2020];
int swi[1000001];
bool off[2020];
int iter = 0, z = 0;
long long tree[4020][4020];
int readint() {
char c;
while ((c = getchar()) < '0')
;
int res = c - '0';
while ((c = getchar()) >= '0') {
res = 10 * res + c - '0';
}
return res;
}
void printint(long long z) {
if (z < 0) {
putchar('-');
z = -z;
}
if (z == 0) {
putchar('0');
return;
}
char arr[20];
int ite = 0;
while (z) {
arr[ite] = (z % 10) + '0';
z /= 10;
ite++;
}
for (int i = ite - 1; i >= 0; i--) {
putchar(arr[i]);
}
}
void update(int x, int y, long long val) {
x += N;
y += M;
int tempy;
while (x <= 2 * N) {
tempy = y;
while (tempy <= 2 * M) {
tree[x][tempy] += val;
tempy += (tempy & -tempy);
}
x += (x & -x);
}
}
long long rect(int x1, int Y1, int x2, int y2) {
long long a, b, c, d;
long long x, y;
long long sum;
x = x2;
y = y2;
sum = 0ll;
x += N;
y += M;
while (x > 0) {
int tempy = y;
while (tempy > 0) {
sum += tree[x][tempy];
tempy -= tempy & -tempy;
}
x -= x & -x;
}
a = sum;
x = x2;
y = Y1 - 1;
sum = 0ll;
x += N;
y += M;
while (x > 0) {
int tempy = y;
while (tempy > 0) {
sum += tree[x][tempy];
tempy -= tempy & -tempy;
}
x -= x & -x;
}
b = sum;
x = x1 - 1;
y = y2;
sum = 0ll;
x += N;
y += M;
while (x > 0) {
int tempy = y;
while (tempy > 0) {
sum += tree[x][tempy];
tempy -= tempy & -tempy;
}
x -= x & -x;
}
c = sum;
x = x1 - 1;
y = Y1 - 1;
sum = 0ll;
x += N;
y += M;
while (x > 0) {
int tempy = y;
while (tempy > 0) {
sum += tree[x][tempy];
tempy -= tempy & -tempy;
}
x -= x & -x;
}
d = sum;
return a - b - c + d;
}
int32_t main() {
N = readint();
M = readint();
K = readint();
for (int i = 0; i < K; i++) {
int w;
w = readint();
for (int j = 0; j < w; j++) {
int a, b, c;
a = readint();
b = readint();
c = readint();
a--;
b--;
garland[i].push_back(make_pair(c, make_pair(a, b)));
}
}
Q = readint();
for (int i = 0; i < Q; i++) {
char c = 'Q';
while (c != 'S' && c != 'A') {
c = getchar();
}
if (c == 'S') {
c = getchar();
c = getchar();
c = getchar();
c = getchar();
c = getchar();
int x;
x = readint();
x--;
swi[i] = x;
} else {
c = getchar();
c = getchar();
swi[i] = -1;
x1[iter] = readint();
Y1[iter] = readint();
x2[iter] = readint();
y2[iter] = readint();
x1[iter]--;
Y1[iter]--;
x2[iter]--;
y2[iter]--;
iter++;
}
}
for (int i = 0; i < K; i++) {
for (int j = 0; j < garland[i].size(); j++) {
update(garland[i][j].second.first, garland[i][j].second.second,
garland[i][j].first);
}
for (int j = 0; j < iter; j++) {
contrib[i][j] = rect(x1[j], Y1[j], x2[j], y2[j]);
}
for (int j = 0; j < garland[i].size(); j++) {
update(garland[i][j].second.first, garland[i][j].second.second,
-garland[i][j].first);
}
}
for (int i = 0; i < Q; i++) {
long long ans = 0;
if (swi[i] != -1) {
off[swi[i]] ^= 1;
continue;
}
for (int j = 0; j < K; j++) {
if (!off[j]) {
ans += contrib[j][z];
}
}
z++;
printint(ans);
putchar('\n');
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, x, m;
cin >> n >> x >> m;
int rL = x, rR = x;
while (m--) {
int l, r;
cin >> l >> r;
if (rR < l || rL > r) {
continue;
}
rL = min(rL, l);
rR = max(rR, r);
}
cout << rR - rL + 1 << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t) {
t--;
unsigned long long a, k;
cin >> a >> k;
for (unsigned long long i = 2; i <= k; i++) {
int x = 10;
int y = -1;
unsigned long long z = a;
while (z) {
int k = z % 10;
x = min(x, k);
y = max(y, k);
z = z / 10;
}
if (x * y == 0) break;
a = a + x * y;
}
cout << a << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 2e5 + 4, inf = 0x3f3f3f3f;
namespace sz {
int n, t[N << 1];
inline void clear(int cn) {
n = cn;
for (int i = 1; i <= n; i++) t[i] = -inf;
}
inline void add(int x, int v) {
for (; x <= n; x += x & -x) t[x] = max(t[x], v);
}
inline int ask(int x) {
int ret = -inf;
for (; x; x -= x & -x) ret = max(ret, t[x]);
return ret;
}
} // namespace sz
int lim, tot;
namespace seg {
const int M = 4e6 + 4;
int ch[M][2], t[M];
void insert(int &p, int l, int r, int x) {
if (p <= lim) {
ch[++tot][0] = ch[p][0];
ch[tot][1] = ch[p][1];
t[tot] = t[p];
p = tot;
}
t[p]++;
if (l == r) return;
int mid = l + r >> 1;
if (x <= mid)
insert(ch[p][0], l, mid, x);
else
insert(ch[p][1], mid + 1, r, x);
}
int query(int p, int l, int r, int ql, int qr) {
if (!p || (ql <= l && r <= qr)) return t[p];
int mid = l + r >> 1;
if (qr <= mid) return query(ch[p][0], l, mid, ql, qr);
if (mid < ql) return query(ch[p][1], mid + 1, r, ql, qr);
return query(ch[p][0], l, mid, ql, qr) + query(ch[p][1], mid + 1, r, ql, qr);
}
} // namespace seg
struct poin {
int x, y, id;
} a[N], b[N], c[N << 1];
int d[N << 1], lx[N], ly[N], rt[N];
inline bool comp_x(const poin &a, const poin &b) {
return a.x == b.x ? (a.y == b.y ? a.id < b.id : a.y < b.y) : a.x < b.x;
}
inline bool comp_v(const poin &a, const poin &b) { return a.id < b.id; }
inline bool ask(int l1, int r1, int l2, int r2) {
l1 = lower_bound(lx + 1, lx + lx[0] + 1, l1) - lx;
r1 = upper_bound(lx + 1, lx + lx[0] + 1, r1) - lx - 1;
l2 = lower_bound(ly + 1, ly + ly[0] + 1, l2) - ly;
r2 = upper_bound(ly + 1, ly + ly[0] + 1, r2) - ly - 1;
return seg::query(rt[r1], 1, ly[0], l2, r2) !=
seg::query(rt[l1 - 1], 1, ly[0], l2, r2);
}
inline void findnear(int n) {
sort(c + 1, c + n + 1, comp_x);
for (int i = 1; i <= n; i++) d[i] = c[i].y;
sort(d + 1, d + n + 1);
int cn = unique(d + 1, d + n + 1) - d - 1;
sz::clear(cn);
for (int i = 1, r; i <= n; i++) {
r = lower_bound(d + 1, d + cn + 1, c[i].y) - d;
if (c[i].id) {
a[c[i].id].id = min(a[c[i].id].id, c[i].x + c[i].y - sz::ask(r));
} else {
sz::add(r, c[i].x + c[i].y);
}
}
}
int n, m;
vector<int> vec[N];
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
a[i].x = c[i].x = read();
a[i].y = c[i].y = read();
a[i].id = inf;
c[i].id = i;
}
for (int i = 1; i <= m; i++) {
b[i].x = c[i + n].x = read();
b[i].y = c[i + n].y = read();
}
findnear(n + m);
for (int i = 1; i <= n + m; i++) c[i].x = -c[i].x;
findnear(n + m);
for (int i = 1; i <= n + m; i++) c[i].y = -c[i].y;
findnear(n + m);
for (int i = 1; i <= n + m; i++) c[i].x = -c[i].x;
findnear(n + m);
for (int i = 1, u, v; i <= n; i++) {
u = a[i].x;
v = a[i].y;
a[i].x = u + v;
a[i].y = u - v;
}
for (int i = 1, u, v; i <= m; i++) {
u = b[i].x;
v = b[i].y;
b[i].x = u + v;
b[i].y = u - v;
}
for (int i = 1; i <= m; i++) {
lx[++lx[0]] = b[i].x;
ly[++ly[0]] = b[i].y;
}
lx[++lx[0]] = ly[++ly[0]] = inf;
lx[++lx[0]] = ly[++ly[0]] = -inf;
sort(lx + 1, lx + lx[0] + 1);
sort(ly + 1, ly + ly[0] + 1);
lx[0] = unique(lx + 1, lx + lx[0] + 1) - lx - 1;
ly[0] = unique(ly + 1, ly + ly[0] + 1) - ly - 1;
for (int i = 1, x; i <= m; i++) {
x = lower_bound(lx + 1, lx + lx[0], b[i].x) - lx;
vec[x].push_back(i);
}
for (int i = 1, y; i <= lx[0]; i++) {
rt[i] = rt[i - 1];
for (auto v : vec[i]) {
y = lower_bound(ly + 1, ly + ly[0] + 1, b[v].y) - ly;
seg::insert(rt[i], 1, ly[0], y);
}
lim = tot;
}
sort(a + 1, a + n + 1, comp_v);
int l = 0, r = inf / 2, mid, l1, r1, l2, r2, fl;
while (l < r) {
mid = l + r >> 1;
l1 = l2 = -inf / 4;
r1 = r2 = inf / 4;
fl = 0;
for (int i = n, d; i && l1 <= r1 && l2 <= r2; i--) {
d = mid - a[i].id;
if (d >= 0) {
fl = ask(l1 - d, r1 + d, l2 - d, r2 + d);
if (fl) break;
}
l1 = max(l1, a[i].x - mid);
r1 = min(r1, a[i].x + mid);
l2 = max(l2, a[i].y - mid);
r2 = min(r2, a[i].y + mid);
}
fl |= (l1 <= r1 && l2 <= r2);
if (fl)
r = mid;
else
l = mid + 1;
}
cout << r;
return (0 - 0);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long a[100010], b[101010] = {0};
char s[520][520] = {0};
int t, n, m;
int X[9] = {0, 1, 1, 1, 0, 0, -1, -1, -1},
Y[9] = {0, 1, 0, -1, 1, -1, 1, 0, -1};
int dfs(int x, int y, int &t) {
if (s[x][y] != '1') return 0;
s[x][y] = '2';
t++;
for (int i = 1; i <= 8; i++)
if (x + X[i] >= 0 && y + Y[i] >= 0 && x + X[i] < n && y + Y[i] < m)
dfs(x + X[i], y + Y[i], t);
return 0;
}
int check1(int x, int y, int l) {
if (x + l >= n || y + l >= m) return 0;
for (int i = 1; i <= l; i++) {
if (s[x][y + i] != '2') return 0;
if (s[x + l][y + i] != '2') return 0;
if (s[x + i][y] != '2') return 0;
if (s[x + i][y + l] != '2') return 0;
}
return 1;
}
int check2(int x, int y, int l) {
if (y + l >= m || x + 2 * l >= n || y - l < 0 || s[x + 2 * l][y] != '2')
return 0;
for (int i = 1; i <= l; i++) {
if (s[x + i][y + i] != '2') return 0;
if (s[x + i][y - i] != '2') return 0;
if (s[x + 2 * l - i][y - i] != '2') return 0;
if (s[x + 2 * l - i][y + i] != '2') return 0;
}
return 1;
}
int main() {
int T;
long long ans;
char s1[10000], s2[10000];
bool tt;
scanf("%d", &T);
for (int ii = 1; ii <= T; ii++) {
scanf("%d%d", &n, &m);
ans = 0;
for (int i = 0; i <= n - 1; i++) scanf("%s", s[i]);
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= m - 1; j++)
if (s[i][j] == '1') {
t = 0;
dfs(i, j, t);
if (t % 4 == 0 && t <= 4 * min(m, n)) {
ans = ans + check1(i, j, t / 4);
ans = ans + check2(i, j, t / 4);
}
}
printf("%I64d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 0x3f3f3f3f;
const double eps = (1e-10);
stringstream out;
int n, m, k, u, v, deg[200005];
bool isGood[200005];
vector<int> ans(200005);
set<pair<int, int> > good;
vector<pair<int, int> > edges(200005);
vector<vector<pair<int, int> > > adj(200005);
int main() {
ios::sync_with_stdio(false);
cout.precision(10);
cin >> n >> m >> k;
for (int i = 0; i < (int)(m); ++i) {
cin >> u >> v;
--u, --v;
edges[i].first = u, edges[i].second = v;
adj[u].push_back(make_pair(v, i)), adj[v].push_back(make_pair(u, i));
++deg[u], ++deg[v];
}
for (int i = 0; i < (int)(n); ++i)
good.insert(make_pair(deg[i], i)), isGood[i] = true;
while (!good.empty() && good.begin()->first < k) {
u = good.begin()->second;
for (auto p : adj[u]) {
v = p.first;
if (isGood[v]) {
good.erase(make_pair(deg[v], v));
--deg[v];
good.insert(make_pair(deg[v], v));
}
}
isGood[u] = false;
good.erase(make_pair(deg[u], u));
}
for (int i = (m - 1); i >= (int)(0); --i) {
ans[i] = ((int)((good).size()));
u = edges[i].first, v = edges[i].second;
if (isGood[u] && isGood[v]) {
good.erase(make_pair(deg[u], u));
--deg[u];
good.insert(make_pair(deg[u], u));
good.erase(make_pair(deg[v], v));
--deg[v];
good.insert(make_pair(deg[v], v));
while (!good.empty() && good.begin()->first < k) {
u = good.begin()->second;
for (auto p : adj[u]) {
if (p.second >= i) continue;
v = p.first;
if (isGood[v]) {
good.erase(make_pair(deg[v], v));
--deg[v];
good.insert(make_pair(deg[v], v));
}
}
isGood[u] = false;
good.erase(make_pair(deg[u], u));
}
}
}
for (int i = 0; i < (int)(m); ++i) out << ans[i] << '\n';
cout << out.str();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long i, n, mn, k, sum, z1, z2, a[200005], b[200005];
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= k; i++) {
scanf("%d%d", &z1, &z2);
b[z1]++;
b[z2 + 1]--;
}
for (i = 2; i <= n; i++) {
b[i] = b[i] + b[i - 1];
}
sort(b + 1, b + n + 1);
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
sum = sum + b[i] * a[i];
}
cout << sum;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> tree[500500];
int n, a[500500], k, dp[500500];
void dfs(int v, int push) {
if (tree[v].size() > 1 || v == 1) {
int mi = n;
int sum = 0;
for (auto u : tree[v]) {
if (u != push) {
dfs(u, v);
mi = min(mi, dp[u]);
sum += dp[u];
}
}
if (a[v] == 1)
dp[v] = mi;
else
dp[v] = sum;
} else
k++;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++) {
int push;
cin >> push;
tree[push].push_back(i);
tree[i].push_back(push);
dp[i] = 1;
}
dp[1] = 1;
dfs(1, -1);
cout << k - dp[1] + 1;
}
| 5 |
#include <bits/stdc++.h>
int n;
int main() {
scanf("%d", &n);
for (register int i = 0; i <= n; i += 4)
if ((n - i) % 7 == 0) {
for (register int j = 0, sz = i / 4; j < sz; ++j) putchar('4');
for (register int j = 0, sz = (n - i) / 7; j < sz; ++j) putchar('7');
return 0;
}
puts("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int n, m;
bool solve(int k) {
int mi = 0;
for (int i = 1; i <= n; i++) {
if (a[i] + k < m) {
mi = max(mi, a[i]);
if (mi > a[i] + k) return 0;
} else {
if (mi <= (a[i] + k) % m) {
} else {
mi = max(mi, a[i]);
}
}
}
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int L = 0, R = m - 1;
while (L < R) {
int mid = (L + R) / 2;
if (solve(mid)) {
R = mid;
} else {
L = mid + 1;
}
}
cout << L << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct Edge {
int v, c;
Edge(int _v, int _c) : v(_v), c(_c) {}
};
vector<Edge> E;
vector<int> g[N];
int addEdge(int u, int v, int c) {
g[u].emplace_back((int)E.size());
E.emplace_back(v, c);
g[v].emplace_back((int)E.size());
E.emplace_back(u, 0);
return (int)E.size() - 1;
}
int S, T;
int d[N];
int p[N];
bool bfs() {
for (int i = 0; i <= T; ++i) d[i] = -1, p[i] = 0;
queue<int> q;
q.push(S);
d[S] = 0;
while (q.size()) {
int u = q.front();
q.pop();
for (int i : g[u]) {
int v = E[i].v;
if (E[i].c == 0) continue;
if (d[v] < 0) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
return d[T] >= 0;
}
int dfs(int u, int F) {
if (u == T || F == 0) return F;
for (int &i = p[u]; i < (int)g[u].size(); ++i) {
int j = g[u][i];
int v = E[j].v;
if (E[j].c == 0 || d[v] != d[u] + 1) continue;
int res = dfs(v, min(E[j].c, F));
if (res) {
E[j].c -= res;
j ^= 1;
E[j].c += res;
return res;
}
}
return 0;
}
int MaxFlow() {
while (bfs())
while (dfs(S, N))
;
int ans = 0;
for (int i : g[T]) ans += E[i].c;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int b;
cin >> b;
int q;
cin >> q;
vector<pair<int, int> > seg;
for (int i = 0; i < q; ++i) {
int r;
cin >> r;
int c;
cin >> c;
seg.emplace_back(r, c);
}
seg.emplace_back(b, n);
seg.emplace_back(0, 0);
sort(seg.begin(), seg.end());
seg.erase(unique(seg.begin(), seg.end()), seg.end());
S = 0;
T = N - 1;
int tot = (int)seg.size();
for (int i = (int)seg.size() - 1; i; --i) {
seg[i].second -= seg[i - 1].second;
if (seg[i].second < 0) {
cout << "unfair";
return 0;
}
addEdge(S, i, seg[i].second);
int R = seg[i].first;
int L = seg[i - 1].first;
for (int c = 0; c < 5; ++c) {
int F = 0;
F += (R + 5 - c) / 5;
F -= (L + 5 - c) / 5;
addEdge(i, ++tot, F);
addEdge(tot, T - c - 1, F);
}
cerr << "\n";
}
for (int i = 1; i <= 5; ++i) addEdge(T - i, T, n / 5);
if (MaxFlow() == n)
cout << "fair";
else
cout << "unfair";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int M = 59100;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
string s, t, ans;
int n, cnt[11], vis[11];
bool work(int pos, int c) {
vector<int> v;
for (int i = 0; i < 10; i++)
if (vis[i] & 1) v.push_back(i);
if (v.size() > n - pos) return false;
sort(v.rbegin(), v.rend());
int up = n - pos - v.size();
for (int i = 1; i <= up; i++) t[pos++] = '9';
for (int i : v) t[pos++] = i + '0';
return true;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
memset(cnt, 0, sizeof(cnt));
memset(vis, 0, sizeof(vis));
cin >> s;
t = s;
n = s.size();
for (int i = 0; i < n; i++) {
if (i == 0 || i == n - 1)
t[i] = '1';
else
t[i] = '0';
}
if (s <= t) {
for (int i = 1; i <= n - 2; i++) printf("9");
puts("");
} else {
for (int i = 0; i < n; i++) cnt[s[i] - '0']++, t[i] = s[i];
for (int i = n - 1; i >= 0; i--) {
cnt[s[i] - '0']--;
for (int j = 0; j < 10; j++) vis[j] = cnt[j];
for (int c = s[i] - '0' - 1; c >= 0; c--) {
vis[c]++;
t[i] = c + '0';
if (work(i + 1, c)) {
ans = t;
i = -1;
break;
}
vis[c]--;
}
}
cout << ans << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int ans[maxn], idx[maxn];
vector<int> G[maxn];
int d[maxn], vis[maxn];
struct E {
int from, to;
} edges[maxn];
void dfs(int v) {
vis[v] = true;
int len = G[v].size();
for (int i = 0; i < len; i++) {
int id = G[v][i];
int u;
if (v == edges[id].from) {
u = edges[id].to;
} else {
u = edges[id].from;
}
if (!vis[u]) {
dfs(u);
if (d[u]) {
ans[id] = 1;
d[v] ^= 1;
}
}
}
}
int main(void) {
memset(ans, 0, sizeof(ans));
memset(vis, 0, sizeof(vis));
int n, m;
scanf("%d %d", &n, &m);
int cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &d[i]);
if (d[i] == 1) {
cnt++;
}
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &edges[i].from, &edges[i].to);
G[edges[i].from].push_back(i);
G[edges[i].to].push_back(i);
}
if (cnt % 2 == 1) {
for (int i = 1; i <= n; i++) {
if (d[i] == -1) {
cnt++;
d[i] = 1;
break;
}
}
}
if (cnt % 2 != 0) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) {
if (d[i] == -1) {
d[i] = 0;
}
}
dfs(1);
cnt = 0;
for (int i = 1; i <= m; i++) {
if (ans[i]) cnt++;
}
printf("%d\n", cnt);
for (int i = 1; i <= m; i++) {
if (ans[i]) printf("%d%c", i, i == m - 1 ? '\n' : ' ');
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const long long MAX = -1000000000000000000;
const long long MIN = 1000000000000000000;
const long long inf = 1000000000;
const long long KOK = 100000;
const long long LOG = 30;
const long long li = 500005;
const long long mod = 1000000007;
int n, m, b[li], a[li], k, flag, t;
int cev;
string s;
vector<int> v;
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i % 2 == 0) {
if (j % 2 == 1)
printf("B");
else
printf("W");
} else {
if (j % 2 == 1)
printf("W");
else
printf("B");
}
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long x) { cout << x; }
void __print(long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
long long __pow(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res *= x;
y >>= 1;
x *= x;
}
return res;
}
const long long N = 2e3 + 2, INF = 1e9;
long long t, n, m, a, b, c;
bool dp[2 * N][N];
void solve() {
cin >> n;
vector<long long> a(2 * n + 1), b = {0}, pos(2 * n + 1);
for (long long i = 1; i <= 2 * n; i++) cin >> a[i], pos[a[i]] = i;
long long x = pos[2 * n];
long long y = 2 * n;
b.push_back(y - x + 1);
for (long long i = 2 * n - 1; i; i--) {
if (pos[i] < x) y = x - 1, x = pos[i], b.push_back(y - x + 1);
}
for (long long i = 0; i <= 2 * n; i++) {
dp[i][0] = 1;
for (long long j = 1; j <= n; j++) dp[i][j] = 0;
}
dp[0][b[0]] = 1;
for (long long i = 1; i < b.size(); i++) {
for (long long X = 0; X <= n; X++) {
if (b[i] <= X)
dp[i][X] = dp[i - 1][X - b[i]] | dp[i - 1][X];
else
dp[i][X] = dp[i - 1][X];
}
}
if (dp[b.size() - 1][n])
cout << "YES\n";
else
cout << "NO\n";
}
int32_t main() {
cin >> t;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T>
using vv = vector<vector<T>>;
template <class T>
inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
const ll MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
n *= 2;
vv<pii> g(n);
for (int(i) = 0; (i) < (n - 1); ++(i)) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
g[a].emplace_back(b, c);
g[b].emplace_back(a, c);
}
ll mn = 0, mx = 0;
function<int(int, int, int)> dfs = [&](int v, int p, int w) {
int sz = 1;
for (pii e : g[v])
if (e.first != p) sz += dfs(e.first, v, e.second);
mx += w * min<ll>(sz, n - sz);
if (sz % 2) mn += w;
return sz;
};
dfs(0, -1, 0);
cout << mn << " " << mx << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
int tam;
long long res;
cin >> N;
for (tam = 1;; tam++) {
for (res = 0LL; res < (1LL << tam); res++) {
long long w = 0LL;
int carg = 0;
for (long long i = 0LL, pot = 1LL; i < tam; i++, pot *= 10LL) {
if (res & (1LL << i)) {
carg++;
w += 7LL * pot;
} else {
carg--;
w += 4LL * pot;
}
}
if (carg == 0 && w >= N) {
cout << w << endl;
return 0;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, C = 0, x;
map<int, int> M;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
M[x]++;
}
for (map<int, int>::iterator it = M.begin(); it != M.end(); it++) {
C += it->second * (n - it->second);
n -= it->second;
}
cout << C;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long int A, B, i, mA = 1, mB = 1, rem, j, k, m;
scanf("%lld %lld", &A, &B);
if (A < B) {
while (A > 0) {
mA = mA * A;
A--;
m = mA;
}
} else {
while (B > 0) {
mB = mB * B;
B--;
m = mB;
}
}
printf("%lld", m);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
if (m > n) {
if ((m - n) % 2 != 0)
cout << 1 << endl;
else
cout << 2 << endl;
} else if (n > m) {
if ((n - m) % 2 == 0)
cout << 1 << endl;
else
cout << 2 << endl;
} else
cout << 0 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int countSubstring(char *str, char *sub) {
int length = strlen(sub);
if (length == 0) return 0;
int count = 0;
for (str = strstr(str, sub); str; str = strstr(str + length, sub)) ++count;
return count;
}
int main() {
char str[1000000], s1[100];
cin >> str;
cin >> s1;
printf("%d\n", countSubstring(str, s1));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int m[N];
int vis[N][N];
int n, k;
int dis(int i, int j) { return abs(i - (k + 1) / 2) + abs(j - (k + 1) / 2); }
int main() {
cin >> n >> k;
while (n--) {
int m;
cin >> m;
int ma = INF;
int r = -1, c1, c2;
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= k - m + 1; ++j) {
int c = 0;
int s;
for (s = j; s <= j + m - 1; ++s) {
if (vis[i][s])
break;
else
c += dis(i, s);
}
if (s == j + m && c < ma) {
ma = c;
r = i;
c1 = j;
c2 = j + m - 1;
}
}
}
if (r > 0) {
for (int j = c1; j <= c2; ++j) vis[r][j] = true;
cout << r << ' ' << c1 << ' ' << c2 << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int Res = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') f = (ch == '-' ? -f : f), ch = getchar();
while (ch >= '0' && ch <= '9') Res = Res * 10 + ch - '0', ch = getchar();
return Res * f;
}
int Ans = -2e9, N, M, H;
int Na[20][524290], Nb[20][524290];
long long L, A[150005], B[150005];
map<long long, bool> visA, visB;
int main() {
N = read();
H = read();
for (int i = 1; i <= N; i++) A[i] = read(), visA[A[i]] = 1;
M = read();
H = read();
for (int i = 1; i <= M; i++) {
B[i] = read(), visB[B[i]] = 1;
if (visA[B[i]]) Ans = 2;
}
sort(A + 1, A + 1 + N);
sort(B + 1, B + 1 + M);
L = max(B[M] - A[1], max(A[N] - B[1], max(A[N] - A[1], B[M] - B[1])));
for (int i = 1; i <= N; i++) {
for (long long j = 2, p = 1; j <= 2 * L && p <= 18; j <<= 1, p++)
Na[p][A[i] % j]++;
}
for (int i = 1; i <= M; i++) {
for (long long j = 2, p = 1; j <= 2 * L && p <= 18; j <<= 1, p++)
Nb[p][B[i] % j]++;
}
for (int i = 1; i <= N; i++) {
for (long long j = 2, p = 1; j <= 2 * L; j <<= 1, p++) {
if (p <= 18)
Ans = max(Ans, Na[p][A[i] % j] + Nb[p][(A[i] + (j >> 1)) % j]);
else {
int Res = 1;
if (L / (j >> 1) < Ans) break;
for (long long k = A[i] + (j >> 1), s = 1; k <= max(B[M], A[N]);
k += (j >> 1), s ^= 1)
if (s)
Res += visB[k];
else
Res += visA[k];
Ans = max(Ans, Res);
}
}
}
for (int i = 1; i <= M; i++) {
for (long long j = 2, p = 1; j <= 2 * L; j <<= 1, p++) {
if (p <= 18)
Ans = max(Ans, Nb[p][B[i] % j] + Na[p][(B[i] + (j >> 1)) % j]);
else {
int Res = 1;
if (L / (j >> 1) < Ans) break;
for (long long k = B[i] + (j >> 1), s = 0; k <= max(B[M], A[N]);
k += (j >> 1), s ^= 1)
if (s)
Res += visB[k];
else
Res += visA[k];
Ans = max(Ans, Res);
}
}
}
printf("%d\n", Ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int interval[2005][2];
int lista[2005], nr;
int desc[2005], inc[2005];
char s[2005];
int l = 0;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d %d", &interval[i][0], &interval[i][1]);
}
int j = 1;
for (int i = 1; i <= 2 * n; ++i) {
if (nr == 0) {
s[l] = '(';
++l;
desc[j] = i;
++nr;
lista[nr] = j;
++j;
} else {
if (interval[lista[nr]][0] <= i - desc[lista[nr]]) {
s[l] = ')';
++l;
inc[lista[nr]] = i;
--nr;
} else {
s[l] = '(';
++l;
desc[j] = i;
++nr;
lista[nr] = j;
++j;
}
}
}
s[l] = '\0';
int advr = 1;
for (int i = 1; i <= n; ++i) {
if (inc[i] - desc[i] < interval[i][0] || inc[i] - desc[i] > interval[i][1])
advr = 0;
}
if (advr) {
printf("%s", s);
} else {
printf("IMPOSSIBLE");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, l, i, j, k, x, y, mid, low, high, high2, p;
vector<long long> a, b, bb;
long long c[200010];
bool valid(long long t) {
for (low = 0; low < 2 * n; low++) {
if (abs(a[0] - bb[low]) <= t) break;
}
if (low == 2 * n) return false;
for (high = low;; high++) {
if (abs(a[0] - bb[high]) > t) break;
}
high--;
p = high - low;
c[0] = low;
high2 = high;
for (i = 1; i < n; i++) {
while ((abs(a[i] - bb[++low]) > t) && (low < 3 * n))
;
high2 = max(high2, low);
while (abs(a[i] - bb[++high2]) <= t)
;
high2--;
high = min(high, high2 - i);
if (low - i > high) return false;
c[i] = low;
}
return true;
}
int main() {
cin >> n >> l;
a.resize(n);
b.resize(n);
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
bb.resize(4 * n);
for (k = 0; k <= 3; k++) {
for (i = 0; i < n; i++) bb[k * n + i] = k * l - l + b[i];
}
x = 0;
y = l;
while (x < y) {
mid = (x + y) / 2;
if (!valid(mid))
x = mid + 1;
else
y = mid;
}
cout << x << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> d[100001];
int n, m;
string a[100001];
string x[100001], y[100001];
map<string, int> used;
int CNT[100001];
int len[100001];
vector<int> g[100001];
bool was[100001];
pair<int, int> compare(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first)
return a;
else if (a.first > b.first)
return b;
else {
if (a.second < b.second)
return a;
else
return b;
}
}
void dfs(int v) {
was[v] = 1;
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!was[to]) {
d[v] = compare(d[v], d[to]);
dfs(to);
d[v] = compare(d[v], d[to]);
} else
d[v] = compare(d[v], d[to]);
}
}
long long ans1, ans2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> a[i];
for (int j = 0; j < a[i].size(); ++j) a[i][j] = tolower(a[i][j]);
}
int cnt = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> x[i] >> y[i];
int cur1 = 0, cur2 = 0;
for (int j = 0; j < x[i].size(); ++j) {
x[i][j] = tolower(x[i][j]);
if (x[i][j] == 'r') ++cur1;
}
for (int j = 0; j < y[i].size(); ++j) {
y[i][j] = tolower(y[i][j]);
if (y[i][j] == 'r') ++cur2;
}
if (!used[x[i]])
used[x[i]] = ++cnt, CNT[cnt] = cur1, len[cnt] = x[i].length();
if (!used[y[i]])
used[y[i]] = ++cnt, CNT[cnt] = cur2, len[cnt] = y[i].length();
g[used[x[i]]].push_back(used[y[i]]);
}
for (int i = 1; i <= cnt; ++i) d[i] = make_pair(CNT[i], len[i]);
for (int i = 1; i <= cnt; ++i)
if (!was[i]) dfs(i);
for (int i = 1; i <= cnt; ++i) was[i] = 0;
for (int i = cnt; i >= 1; --i)
if (!was[i]) dfs(i);
for (int i = 1; i <= m; ++i) {
if (!used[a[i]]) {
int cur = 0;
for (int j = 0; j < a[i].length(); ++j)
if (a[i][j] == 'r' || a[i][j] == 'R') ++cur;
ans1 += cur;
ans2 += a[i].length();
} else {
ans1 += d[used[a[i]]].first;
ans2 += d[used[a[i]]].second;
}
}
cout << ans1 << ' ' << ans2;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void my_file_in_out() {
freopen("inp.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
inline void OK(string t = "") { cerr << "OK " << t << '\n'; }
inline long double time() { return clock() / (long double)CLOCKS_PER_SEC; }
inline void stop(string t = "PROCESS FINISHED") {
cerr << t << '\n';
exit(0);
}
long long bp(long long c, long long st) {
if (!st) return 1;
if (st & 1) return c * bp(c, st - 1);
return bp(c * c, st >> 1);
}
namespace VECTOR_MAGIC {
template <typename T>
istream &operator>>(istream &inp, vector<T> &a) {
for (auto &elem : a) inp >> elem;
return inp;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &a) {
for (auto &elem : a) out << elem << ' ';
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<vector<T>> &a) {
for (auto &elem : a) out << elem;
return out;
}
template <typename T>
void operator++(vector<T> &a) {
for (auto &el : a) el++;
}
template <typename T>
void operator++(vector<T> &a, T) {
for (auto &el : a) el++;
}
template <typename T>
void operator--(vector<T> &a) {
for (auto &el : a) el--;
}
template <typename T>
void operator--(vector<T> &a, T) {
for (auto &el : a) el--;
}
template <typename T>
void operator+=(vector<T> &a, T X) {
for (auto &el : a) el += X;
}
} // namespace VECTOR_MAGIC
using namespace VECTOR_MAGIC;
mt19937 rnd(time(0));
void calc(vector<int> &p, string &a) {
p.assign(((int)a.size()), 0);
for (int i = 1, j = 0; i < ((int)a.size()) && j < ((int)a.size());) {
if (a[i] == a[j])
p[i++] = ++j;
else if (j == 0)
p[i++] = 0;
else
j = p[j - 1];
}
}
signed main() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a, b;
cin >> n >> a >> b;
string h;
cin >> h;
vector<int> pref(n + 1);
vector<int> ans(n);
for (int i = 0; i < n; i++) {
string tmp = h.substr(i, n - i) + '#' + h.substr(0, i);
calc(pref, tmp);
ans[i] = *max_element(pref.begin() + n - i, pref.end());
}
vector<int> dp(n, 1e9 + 7);
dp[0] = a;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (ans[j + 1] >= i - j) dp[i] = min(dp[i], dp[j] + b);
dp[i] = min(dp[i], dp[j] + a * (i - j));
}
}
cout << dp.back();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int angka, sum;
for (int i = 0; i < n; i++) {
int d, rem, result;
cin >> angka >> sum;
d = sum / angka;
rem = sum % angka;
result = rem * (d + 1) * (d + 1) + (angka - rem) * d * d;
cout << result << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 9;
const long long P = 1000000000 + 7;
long long inv(long long x) {
long long r = 1, n = P - 2;
for (x %= P; n; n >>= 1, x = x * x % P)
if (n & 1) r = r * x % P;
return r;
}
int n;
long long inv_2, inv_n;
long long dp[N][N];
vector<int> G[N];
int dis1[N], dis2[N];
void dfs1(int u, int p) {
dis1[u] = dis1[p] + 1;
for (int v : G[u]) if (v != p) dfs1(v, u);
}
void dfs2(int u, int p) {
dis2[u] = dis2[p] + 1;
for (int v : G[u]) if (v != p) dfs2(v, u);
}
long long query(int u, int v) {
dfs1(u, 0);
dfs2(v, 0);
int d = dis1[v] - 1;
long long res = 0;
for (int i = 1; i <= n; ++i) {
if (dis2[i] - dis1[i] == d) {
res = (res + inv_n) % P;
}
else if (dis2[i] - dis1[i] > -d) {
int x = (d - (dis2[i] - dis1[i])) / 2, y = d - x;
res = (res + dp[x - 1][y - 1] * inv_2 % P * inv_n % P) % P;
}
}
return res;
}
void solve() {
scanf("%d", &n);
inv_2 = inv(2);
inv_n = inv(n);
for (int i = 1; i <= n - 1; ++i) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
if (i == 0 && j == 0) dp[i][j] = 1;
else if (i == 0) dp[i][j] = dp[i][j - 1] * inv_2 % P;
else if (j == 0) dp[i][j] = dp[i - 1][j] * inv_2 % P;
else dp[i][j] = (dp[i][j - 1] + dp[i - 1][j]) * inv_2 % P;
}
}
for (int i = 0; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % P;
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
ans = (ans + query(j, i)) % P;
}
}
printf("%lld\n", ans);
}
int main() {
int T = 1;
while (T--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int A, B, C;
char ans[305][305];
void TL(int i, int j) {
ans[i][j] = '.';
ans[i][j + 1] = '/';
ans[i + 1][j] = '/';
ans[i + 1][j + 1] = '#';
}
void BR(int i, int j) {
ans[i][j] = '#';
ans[i][j + 1] = '/';
ans[i + 1][j] = '/';
ans[i + 1][j + 1] = '.';
}
void TR(int i, int j) {
ans[i][j] = '\\';
ans[i][j + 1] = '.';
ans[i + 1][j] = '#';
ans[i + 1][j + 1] = '\\';
}
void BL(int i, int j) {
ans[i][j] = '\\';
ans[i][j + 1] = '#';
ans[i + 1][j] = '.';
ans[i + 1][j + 1] = '\\';
}
void border(int i, int j) {
bool top = 1, left = 1;
if (ans[i - 1][j] == '#' || ans[i - 1][j + 1] == '#') top = 0;
if (ans[i][j - 1] == '#' || ans[i + 1][j - 1] == '#') left = 0;
if (top && left) {
TL(i, j);
} else if (top) {
TR(i, j);
} else if (left) {
BL(i, j);
} else {
BR(i, j);
}
}
void solve() {
for (int j = 1; j <= M * 2; j++) {
ans[0][j] = '#';
}
int i = 1, j = 1;
for (i = 1; i <= N * 2 && A > 0; i += 2) {
for (j = 1; j <= M * 2 && A > 0; j += 2) {
if (A > 0) {
ans[i][j] = '#';
ans[i][j + 1] = '#';
ans[i + 1][j] = '#';
ans[i + 1][j + 1] = '#';
A--;
} else
break;
}
}
int tp = j;
for (; tp <= M * 2; tp += 2) {
border(i - 2, tp);
}
bool now = 1;
for (tp = j - 2; tp > 0; tp -= 2) {
if (now) {
BR(i, tp);
} else {
BL(i, tp);
}
now ^= 1;
}
for (i = 1; i <= N * 2; i += 2) {
for (j = 1; j <= M * 2; j += 2) {
if (ans[i][j] != 0) continue;
if (B > 0) {
ans[i][j] = '.';
ans[i][j + 1] = '.';
ans[i + 1][j] = '.';
ans[i + 1][j + 1] = '.';
B--;
} else
border(i, j);
}
}
for (i = 3; i <= N * 2; i++) {
for (j = 1; j <= M * 2; j++) {
cout << ans[i][j];
}
cout << "\n";
}
cin >> N;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N >> M >> A >> B >> C;
N++;
A += M;
solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, p;
cin >> n >> p;
for (long long k = (1); k < (40); k++) {
long long x = n - k * p;
if (x >= k && __builtin_popcountll(x) <= k) {
cout << k << endl;
return 0;
}
}
cout << -1 << endl;
}
| 4 |
#include <bits/stdc++.h>
#define rep(i, l, r) for (register int i = l; i <= r; i++)
#define per(i, r, l) for (register int i = r; i >= l; i--)
#define srep(i, l, r) for (register int i = l; i < r; i++)
#define sper(i, r, l) for (register int i = r; i > l; i--)
#define maxn 64
#define offset 64
#define inf 2000000020
using namespace std;
int floor(int x, int y) {
if (x >= 0) return x / y;
x = -x;
return -((x - 1) / y + 1); //XXX
}
int n, num[maxn];
char s[maxn];
/*
int dp[maxn][offset << 1][maxn * 5][maxn * 5];
bool vis[maxn][offset << 1][maxn * 5][maxn * 5];
int DP(int pos, int car, int cp, int cn) {
if (pos >= n) {
if (pos == maxn) return inf;
if (car == offset && !cp && !cn) return 0;
}
if (vis[pos][car][cp][cn]) return dp[pos][car][cp][cn];
vis[pos][car][cp][cn] = 1;
int& ans = dp[pos][car][cp][cn];
ans = inf;
if (cp) ans = min(ans, DP(pos, car, cp - 1, cn));
if (cn) ans = min(ans, DP(pos, car, cp, cn - 1));
car -= offset;
if ((car + cp - cn % 10 + 10) % 10 != num[pos]) return ans;
int _car = floor(car + cp - cn, 10) + offset;
int dd = DP(pos + 1, _car, cp, cn);
if (dd != inf) ans = min(ans, dd + cp + cn);
return ans;
}
*/
#define DP(pos, car, cp, cn) dp[pos][car][cp][cn]
int dp[2][offset << 1][maxn * 5][maxn * 5];
int solve(){ //XXX
int d = 0;
per(pos, maxn, 0) {
d ^= 1;
srep(car, 0, offset << 1) {
rep(cp, 0, 5 * n) {
rep(cn, 0, 5 * n) {
int& ans = dp[d][car][cp][cn];
if (pos >= n) {
if (pos == maxn) {ans = inf; continue;} //XXX
if (car == offset && !cp && !cn) {ans = 0; continue;}
}
//if (vis[pos][car][cp][cn]) return dp[pos][car][cp][cn];
//vis[pos][car][cp][cn] = 1; //XXX
ans = inf;
if (cp) ans = min(ans, DP(d, car, cp - 1, cn));
if (cn) ans = min(ans, DP(d, car, cp, cn - 1));
int __car = car - offset;
if ((10 + __car % 10 + cp - cn % 10 + 10) % 10 != num[pos]) continue;
int _car = floor(__car + cp - cn, 10) + offset;
if (0 <= _car && _car < (offset << 1)) {
int dd = DP(d ^ 1, _car, cp, cn);
if (dd != inf) ans = min(ans, dd + cp + cn);
}
//return ans;
}
}
}
}
return d;
}
int main(){
scanf("%s", s);
n = strlen(s);
srep(i, 0, n) num[i] = s[n - i - 1] - '0';
int d = solve();
int res = inf;
rep(cp, 0, 5 * n) {
rep(cn, 0, 5 * n) {
res = min(res, DP(d, offset, cp, cn));
}
}
cout << res << endl;
//cerr << floor(-2, 10) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct pos {
pair<int, int> a, b, c;
pos(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
this->a = a;
this->b = b;
this->c = c;
}
};
int t, n, m, i, j, c1, c2;
char ch;
int a[105][105];
vector<pos> ans;
vector<pair<int, int>> v0, v1;
void solve(vector<pair<int, int>> &v0, vector<pair<int, int>> &v1) {
if (v1.empty()) return;
if (v1.size() == 3) {
ans.push_back(pos(v1[0], v1[1], v1[2]));
return;
}
if (v1.size() == 4) {
ans.push_back(pos(v1[1], v1[2], v1[3]));
v0.push_back(v1[1]);
v0.push_back(v1[2]);
v0.push_back(v1[3]);
v1.pop_back();
v1.pop_back();
v1.pop_back();
solve(v0, v1);
return;
}
auto aux = v1.back();
v1.pop_back();
if (v0.empty()) {
while (true) {
}
}
auto aux2 = v0.back();
v0.pop_back();
if (v0.empty()) {
while (true) {
}
}
auto aux3 = v0.back();
v0.pop_back();
ans.push_back(pos(aux, aux2, aux3));
v0.push_back(aux);
v1.push_back(aux2);
v1.push_back(aux3);
solve(v0, v1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t) {
t--;
cin >> n >> m;
ans.clear();
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
cin >> ch;
a[i][j] = ch - '0';
}
for (i = 1; i + 2 <= n; i++) {
for (j = 1; j <= m; j++) {
if (!a[i][j]) continue;
c1 = j;
if (j < m)
c2 = j + 1;
else
c2 = j - 1;
a[i][j] ^= 1;
a[i + 1][c1] ^= 1;
a[i + 1][c2] ^= 1;
ans.push_back(pos({i, j}, {i + 1, c1}, {i + 1, c2}));
}
}
for (j = 1; j + 2 <= m; j++) {
if (a[n - 1][j] && a[n][j]) {
ans.push_back(pos({n - 1, j}, {n, j}, {n - 1, j + 1}));
a[n - 1][j] ^= 1;
a[n][j] ^= 1;
a[n - 1][j + 1] ^= 1;
} else if (a[n - 1][j]) {
ans.push_back(pos({n - 1, j}, {n - 1, j + 1}, {n, j + 1}));
a[n - 1][j] ^= 1;
a[n - 1][j + 1] ^= 1;
a[n][j + 1] ^= 1;
} else if (a[n][j]) {
ans.push_back(pos({n, j}, {n - 1, j + 1}, {n, j + 1}));
a[n][j] ^= 1;
a[n - 1][j + 1] ^= 1;
a[n][j + 1] ^= 1;
}
}
v0.clear();
v1.clear();
for (i = n - 1; i <= n; i++)
for (j = m - 1; j <= m; j++) {
if (a[i][j])
v1.push_back({i, j});
else
v0.push_back({i, j});
}
solve(v0, v1);
cout << ans.size() << '\n';
for (auto it : ans) {
cout << it.a.first << ' ' << it.a.second << ' ';
cout << it.b.first << ' ' << it.b.second << ' ';
cout << it.c.first << ' ' << it.c.second << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void sci(T& t) {
cin >> t;
}
template <typename T, typename... Ts>
void sci(T& t, Ts&... ts) {
sci(t);
sci(ts...);
}
int a[222222];
bool used[222222];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
sci(n, m);
int lodd = 1;
int leven = 2;
int codd = 0;
int ceven = 0;
set<int> in_a;
for (int i = 0; i < n; i++) {
sci(a[i]);
if (a[i] & 1) {
codd++;
} else {
ceven++;
}
in_a.insert(a[i]);
}
int aa = 0;
set<int> was;
for (int i = 0; i < n; i++) {
if (was.find(a[i]) != was.end()) {
if (codd < ceven || (codd == ceven && a[i] % 2 == 1)) {
while (in_a.find(lodd) != in_a.end()) {
lodd += 2;
}
if (lodd > m) {
cout << -1;
return 0;
}
aa++;
bool wadd = a[i] % 2 == 1;
a[i] = lodd;
lodd += 2;
if (!wadd) {
codd += 1;
ceven -= 1;
}
} else {
while (in_a.find(leven) != in_a.end()) {
leven += 2;
}
if (leven > m) {
cout << -1;
return 0;
}
aa++;
bool weven = a[i] % 2 == 0;
a[i] = leven;
leven += 2;
if (!weven) {
codd -= 1;
ceven += 1;
}
}
}
was.insert(a[i]);
}
for (int i = 0; codd < ceven && i < n; i++) {
if (a[i] % 2 == 1) {
continue;
}
while (was.find(lodd) != was.end()) {
lodd += 2;
}
if (lodd > m) {
cout << -1;
return 0;
}
aa++;
a[i] = lodd;
lodd += 2;
codd += 1;
ceven -= 1;
}
for (int i = 0; codd > ceven && i < n; i++) {
if (a[i] % 2 == 0) {
continue;
}
while (was.find(leven) != was.end()) {
leven += 2;
}
if (leven > m) {
cout << -1;
return 0;
}
aa++;
a[i] = leven;
leven += 2;
codd -= 1;
ceven += 1;
}
cout << aa << "\n";
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int res[n];
for (int i = 0; i < n; i++) {
res[i] = i + 1;
}
int i = 0;
while (i < n) {
swap(res[i], res[i + 1]);
i += 2;
}
if (n % 2 != 0) {
cout << -1 << endl;
} else {
for (int j = 0; j < n; j++) {
cout << res[j] << " ";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define NMAX 1009
using namespace std;
ll mask;
ll u,d,r,l;
ll n;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
cin>>t;
while(t--)
{
cin>>n>>u>>r>>d>>l;
bool ok=0;
for(mask=0;mask<16;mask++)
{
ll cu=u;
ll cd=d;
ll cl=l;
ll cr=r;
if(mask & 1)
{cu--;cl--;}
if(mask & 2)
{cu--;cr--;}
if(mask & 4)
{cl--;cd--;}
if(mask & 8)
{cd--;cr--;}
if(cd>=0 && cd<=n-2 && cu>=0 && cu<=n-2 && cl>=0 && cl<=n-2 && cr>=0 && cr<=n-2)
{ok=1;break;}
}
if(!ok)
cout<<"NO\n";
else
cout<<"YES\n";
}
return 0;
}
///limitele si tipul de date!!
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i) {
if (i != v.begin()) os << ", ";
os << *i;
}
os << "]";
return os;
}
int n;
vector<int> A, B;
void extend(int u, int v, int& left, int& right, int& minimum, int& maximum,
int extension) {
if (left <= extension && extension <= right) return;
int old_left = left;
int old_right = right;
int old_minimum = minimum;
int old_maximum = maximum;
left = min(left, extension);
right = max(right, extension);
minimum = min(minimum, A[extension]);
maximum = max(maximum, A[extension]);
do {
while (left < old_left) {
--old_left;
minimum = min(minimum, A[old_left]);
maximum = max(maximum, A[old_left]);
}
while (right > old_right) {
++old_right;
minimum = min(minimum, A[old_right]);
maximum = max(maximum, A[old_right]);
}
while (minimum < old_minimum) {
--old_minimum;
left = min(left, B[old_minimum]);
right = max(right, B[old_minimum]);
if (left < u || right > v) {
u = -1023456789;
v = 1023456789;
return;
}
}
while (maximum > old_maximum) {
++old_maximum;
left = min(left, B[old_maximum]);
right = max(right, B[old_maximum]);
if (left < u || right > v) {
u = -1023456789;
v = 1023456789;
return;
}
}
} while (!(left == old_left && right == old_right && minimum == old_minimum &&
maximum == old_maximum));
}
long long solve(int u, int v) {
if (u > v) return 0;
if (v - u <= 50) {
long long res = 0;
for (int i = (int)(u); i <= (int)(v); ++i) {
int minimum = A[i], maximum = A[i];
for (int j = (int)(i); j <= (int)(v); ++j) {
if (A[j] > maximum) {
maximum = A[j];
} else if (A[j] < minimum) {
minimum = A[j];
}
res += (maximum - minimum == j - i);
}
}
return res;
}
int p = (u + v) / 2;
int left, right, minimum, maximum;
vector<pair<int, int> > R;
left = right = p;
minimum = maximum = A[p];
for (int i = (int)(p); i <= (int)(v); ++i) {
extend(u, v, left, right, minimum, maximum, i);
if (right == i) R.push_back(pair<int, int>(left, right));
}
left = right = p;
minimum = maximum = A[p];
int j = 0, k = 0;
long long res = 0;
for (int i = (int)(p); i >= (int)(u); --i) {
extend(u, v, left, right, minimum, maximum, i);
if (left == i) {
while (j < ((int)((R).size())) && R[j].second < right) ++j;
while (k < ((int)((R).size())) && R[k].first >= left) ++k;
res += max(0, k - j);
}
}
return res + solve(u, p - 1) + solve(p + 1, v);
}
int main() {
scanf("%d", &n);
A.resize(n);
B.resize(n);
for (int i = 0; i < (int)(n); ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x, --y;
A[x] = y;
B[y] = x;
}
cout << solve(0, n - 1) << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int n, A, cf, cm;
pair<int, int> a[N];
long long units, prefix[N], suffix[N];
bool comp(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
int main() {
cin >> n >> A >> cf >> cm >> units;
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n, comp);
prefix[0] = suffix[0] = 0;
for (int i = 0; i < n; i++) prefix[i + 1] = prefix[i] + a[i].first;
for (int i = 1; i < n; i++)
suffix[i] = (a[n - i - 1].first - a[n - i].first) * i + suffix[i - 1];
int imax = 0;
long long raised_min = 0, val = -1, bestVal = -1, bestMin = a[n - 1].first;
for (long long i = 0; i <= n; i++) {
long long req = A * i - prefix[i];
long long left = units - req;
if (left < 0) break;
if (i < n) {
int pos = upper_bound(suffix, suffix + n - i, left) - suffix;
pos--;
left -= suffix[pos];
long long up_raise = left / (pos + 1);
raised_min = a[n - pos - 1].first + up_raise;
if (raised_min > A) raised_min = A;
} else
raised_min = A;
val = i * cf + raised_min * cm;
if (val > bestVal) {
imax = i;
bestMin = raised_min;
bestVal = val;
}
}
vector<int> updated(n);
for (int i = 0; i < imax; i++) updated[a[i].second] = A;
for (int i = imax; i < n; i++) {
if (a[i].first < bestMin)
updated[a[i].second] = bestMin;
else
updated[a[i].second] = a[i].first;
}
cout << bestVal << endl;
for (auto x : updated) cout << x << " ";
return 0;
}
| 5 |
// < Rahil Malhotra / ViciousCoder >
#include "bits/stdc++.h"
using namespace std;
template <typename T> void print(T t) { cout<<t<<endl; }
template<typename T, typename... Args> void print(T t, Args... args) { cout<<t<<" "; print(args...); }
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl '\n'
#define int long long
#define double long double
int32_t main()
{
IOS;
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
string arr[n];
int maxrow[11]={};
int maxcol[11]={};
int minrow[11]={};
int mincol[11]={};
for(int i=0;i<11;i++)
{
minrow[i]=n+5;
mincol[i]=n+5;
}
for(int i=0;i<n;i++)
{
cin>>arr[i];
for(int j=0;j<n;j++)
{
maxrow[arr[i][j]-'0']=max(maxrow[arr[i][j]-'0'],i);
maxcol[arr[i][j]-'0']=max(maxcol[arr[i][j]-'0'],j);
minrow[arr[i][j]-'0']=min(minrow[arr[i][j]-'0'],i);
mincol[arr[i][j]-'0']=min(mincol[arr[i][j]-'0'],j);
}
}
int finans[11]={};
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
int get=arr[i][j]-'0';
if(arr[0][j]-'0'==get)
finans[get]=max(finans[get],i*max(n-1-j,j));
else
{
finans[get]=max(finans[get],i*(maxcol[get]-j));
finans[get]=max(finans[get],i*(j-mincol[get]));
}
if(arr[n-1][j]-'0'==get)
finans[get]=max(finans[get],(n-1-i)*max(n-1-j,j));
else
{
finans[get]=max(finans[get],(n-1-i)*(maxcol[get]-j));
finans[get]=max(finans[get],(n-1-i)*(j-mincol[get]));
}
if(arr[i][0]-'0'==get)
finans[get]=max(finans[get],j*max(n-1-i,i));
else
{
finans[get]=max(finans[get],j*(maxrow[get]-i));
finans[get]=max(finans[get],j*(i-minrow[get]));
}
if(arr[i][n-1]-'0'==get)
finans[get]=max(finans[get],(n-1-j)*max(n-1-i,i));
else
{
finans[get]=max(finans[get],(n-1-j)*(maxrow[get]-i));
finans[get]=max(finans[get],(n-1-j)*(i-minrow[get]));
}
}
}
for(int i=0;i<10;i++)
cout<<finans[i]<<" ";
cout<<endl;
}
}
| 4 |
#include <bits/stdc++.h>
const int inf = 1e9 + 7;
using namespace std;
int n, m;
int cl, ce, v;
int l[101000], e[101000];
int fx, fy, tx, ty;
int work(int r, int vv) {
if (fx == tx) return abs(fy - ty);
if (r >= 1 && r <= m)
return abs(fy - r) + abs(ty - r) + (abs(tx - fx) + vv - 1) / vv;
return inf;
}
int main() {
cin >> n >> m >> cl >> ce >> v;
for (int i = 1; i <= cl; i++) cin >> l[i];
l[cl + 1] = m + 1;
for (int i = 1; i <= ce; i++) cin >> e[i];
e[ce + 1] = m + 1;
int T;
cin >> T;
while (T--) {
scanf("%d%d%d%d", &fx, &fy, &tx, &ty);
int i = lower_bound(l, l + cl + 2, fy) - l;
int ans = min(work(l[i - 1], 1), work(l[i], 1));
i = lower_bound(e, e + ce + 2, fy) - e;
ans = min(ans, min(work(e[i - 1], v), work(e[i], v)));
printf("%d\n", ans);
}
return 0;
}
| 4 |
#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;
string s;
cin >> s;
int ans = INT_MAX;
string ref = "RGB";
for (int i = 0; i < 3; i++) {
vector<int> cnt(n, 0);
for (int j = 0; j < n; j++) {
if (s[j] != ref[(j + i) % 3]) {
cnt[j] = 1;
}
if (j != 0) cnt[j] += cnt[j - 1];
if (j >= k) {
ans = min(ans, cnt[j] - cnt[j - k]);
} else if (j == k - 1) {
ans = min(ans, cnt[j]);
}
}
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int dis[30] = {0};
int mark = 0;
for (int i = 0; i < s.length(); i++) {
dis[s[i] - 'a']++;
if (dis[s[i] - 'a'] == 1) {
mark++;
}
}
bool jkl = false;
if (mark == 1) {
cout << "Impossible" << endl;
} else if (mark == 2 && dis[s[1] - 'a'] == s.length() - 1 &&
dis[s[s.length() / 2] - 'a'] == 1) {
cout << "Impossible" << endl;
} else {
for (int i = 1; i < s.length(); i++) {
string now1 = s.substr(0, i);
string now2 = s.substr(i, s.length() - i);
string jug = now2 + now1;
if (jug != s) {
bool op = false;
for (int i = 0; i < jug.length() / 2; i++) {
if (jug[i] != jug[jug.length() - i - 1]) {
op = true;
break;
}
}
if (!op) {
jkl = true;
}
}
}
if (jkl) {
cout << "1" << endl;
} else {
cout << "2" << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct D {
int x, y, z;
D(int _x, int _y, int _z) {
x = _x;
y = _y;
z = _z;
}
D() {}
bool operator<(const D &p) const { return x < p.x; }
};
int n, s;
D a[100010];
int sqr(int x) { return x * x; }
int check(int rr) {
int ans = 0;
for (int i = 0; i < n; i++) {
if (sqr(a[i].x) + sqr(a[i].y) <= rr) ans += a[i].z;
}
return ans;
}
int main() {
scanf("%d %d", &n, &s);
for (int i = 0; i < n; i++) scanf("%d %d %d", &a[i].x, &a[i].y, &a[i].z);
float lt = 0, rt = 200000005, ans = -1;
while (lt <= rt) {
int md = (lt + rt) / 2;
if (check(md) + s >= 1000000)
ans = md, rt = md - 1;
else
lt = md + 1;
}
if (ans == -1) return printf("-1\n"), 0;
printf("%f\n", sqrt(ans));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
inline T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long n, x, res[1000006], top;
bool ok[1000006];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> x;
ok[0] = ok[x] = true;
for (long long i = 1, _b = 1 << n; i < _b; i++) {
if (ok[i]) continue;
res[++top] = i;
ok[x ^ i] = true;
}
cout << top << "\n";
for (long long i = 1, _b = top; i <= _b; i++)
cout << (res[i] ^ res[i - 1]) << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, k, c;
std::cin >> n >> k >> c;
int holidays[c];
int tpresents = 0;
for (int i = 0; i < c; i++) {
std::cin >> holidays[i];
}
if (c == 0) {
tpresents += n / k;
} else {
tpresents += holidays[0] / k;
if (holidays[0] % k != 0) {
tpresents++;
}
int i;
for (i = 1; i < c; i++) {
tpresents += (holidays[i] - holidays[i - 1]) / k;
if ((holidays[i] - holidays[i - 1]) % k != 0) {
tpresents++;
}
}
tpresents += (n - holidays[i - 1]) / k;
}
std::cout << tpresents << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], c[100005];
int m, n, x = 0, s, i;
int main() {
cin >> m >> n;
for (i = 0; i < m; i++) cin >> a[i];
for (i = m - 1; i >= 0; i--) {
if (c[a[i]] == 0) {
c[a[i]] = 1;
x++;
}
a[i] = x;
}
while (n--) {
cin >> s;
cout << a[s - 1] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 6;
int n;
char s[maxn], t[maxn];
long long ans, a[maxn];
void dfs(int x, int w) {
if (s[x + 1] + w < '0' || s[x + 1] + w > '9') dfs(x + 1, -w);
printf("%d %d\n", x, w);
s[x] += w;
s[x + 1] += w;
if (!(--ans)) exit(0);
}
int main() {
scanf("%d%s%s", &n, s + 1, t + 1);
for (int i = 1; i <= n; i++) {
a[i] = -a[i - 1] + t[i] - s[i];
ans += abs(a[i]);
}
if (a[n]) {
puts("-1");
return 0;
}
printf("%lld\n", ans);
if (!ans) return 0;
ans = min(ans, (long long)1e5);
for (int i = 1; i < n; i++)
while (s[i] != t[i]) dfs(i, t[i] > s[i] ? 1 : -1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1000008;
int n, k, pp;
long long A[maxn];
long long y[maxn];
long long inv[maxn];
long long w[maxn];
long long quickpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = 1ll * res * x % 1000000007;
x = 1ll * x * x % 1000000007;
n >>= 1;
}
return res;
}
void init() {
A[0] = pp = 1;
for (long long i = 1; i <= min(n, k + 2); ++i) {
A[i] = 1ll * A[i - 1] * i % 1000000007;
inv[i] = quickpow(n - i, 1000000007 - 2);
pp = (1ll * pp * (n - i) % 1000000007 + 1000000007) % 1000000007;
y[i] = (y[i - 1] + quickpow(i, k)) % 1000000007;
}
for (long long i = 1; i <= min(n, k + 2); ++i) {
w[i] = 1ll * A[i - 1] * A[k + 2 - i] % 1000000007;
if ((k + 2 - i) & 1) w[i] = 1000000007 - w[i];
w[i] = quickpow(w[i], 1000000007 - 2);
}
}
int main() {
scanf("%d%d", &n, &k);
init();
if (n <= k + 2) {
printf("%lld\n", y[n]);
return 0;
}
long long ans = 0;
for (long long i = 1; i <= (k + 2); ++i) {
ans = (ans + 1ll * pp * y[i] % 1000000007 * w[i] % 1000000007 * inv[i] %
1000000007) %
1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long poww(long long a, long long b) {
if (b == 0) return 1;
long long tmp = poww(a, b / 2);
return (b & 1 ? a * tmp * tmp : tmp * tmp);
}
string itos(long long i) {
string s = "";
while (i) {
s += char(i % 10 + '0');
i /= 10;
}
reverse(s.begin(), s.end());
return s;
}
long long stoi(string &s) {
long long tot = 0;
for (int i = (int)s.length() - 1, j = 1; i >= 0; i--, j *= 10) {
tot += j * (s[i] + '0');
}
return tot;
}
int months[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
using namespace std;
long long mod = 1e9 + 7;
void tt() { freopen("test.txt", "r", stdin); }
const int MAX = 1e6 + 10;
double a[MAX];
double st[4 * MAX], lazy[4 * MAX], add[4 * MAX], mul[4 * MAX];
void build(int node, int se, int en) {
if (se == en) {
st[node] = a[se];
mul[node] = 1;
return;
}
int mi = (se + en) / 2;
build(node * 2, se, mi);
build(node * 2 + 1, mi + 1, en);
st[node] = st[node * 2] + st[node * 2 + 1];
mul[node] = 1;
}
void push(int node, int se, int en) {
mul[node * 2] *= mul[node];
mul[node * 2 + 1] *= mul[node];
add[node * 2] *= mul[node];
add[node * 2 + 1] *= mul[node];
add[node * 2] += add[node];
add[node * 2 + 1] += add[node];
int mi = (se + en) / 2;
st[node * 2] = st[node * 2] * mul[node] + (mi - se + 1) * add[node];
st[node * 2 + 1] = st[node * 2 + 1] * mul[node] + (en - mi) * add[node];
st[node] = st[node * 2] + st[node * 2 + 1];
add[node] = 0, mul[node] = 1;
}
double query(int node, int se, int en, int l, int r) {
if (se > r || en < l) {
return 0;
}
if (l <= se && en <= r) {
return st[node];
}
int mi = (se + en) / 2;
push(node, se, en);
double p1 = query(node * 2, se, mi, l, r);
double p2 = query(node * 2 + 1, mi + 1, en, l, r);
return p1 + p2;
}
void update(int node, int se, int en, int l, int r, double tomul,
double toadd) {
if (se > r || en < l) {
return;
}
if (l <= se && en <= r) {
st[node] *= tomul;
st[node] += (en - se + 1) * toadd;
mul[node] *= tomul;
add[node] *= tomul;
add[node] += toadd;
return;
}
int mi = (se + en) / 2;
push(node, se, en);
update(node * 2, se, mi, l, r, tomul, toadd);
update(node * 2 + 1, mi + 1, en, l, r, tomul, toadd);
st[node] = st[node * 2] + st[node * 2 + 1];
}
int main() {
int n, q;
memset(mul, 1, sizeof(mul));
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, 1, n);
while (q--) {
int type, l, r;
cin >> type >> l >> r;
if (type == 1) {
int le, ri;
cin >> le >> ri;
double avg_val1 = query(1, 1, n, l, r) / double(r - l + 1);
double avg_val2 = query(1, 1, n, le, ri) / double(ri - le + 1);
update(1, 1, n, l, r, double(r - l) / double(r - l + 1),
avg_val2 / double(r - l + 1));
update(1, 1, n, le, ri, double(ri - le) / double(ri - le + 1),
avg_val1 / double(ri - le + 1));
} else
cout << setprecision(10) << query(1, 1, n, l, r) << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
int n;
int F[(1 << 24) + 123];
vector<int> msk;
string tobin(int X) {
string res = "";
while (X) {
res += char('0' + X % 2);
X /= 2;
}
reverse((res).begin(), (res).end());
while (res.size() < 24) res = '0' + res;
return res;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
string second;
cin >> second;
int mask = 0;
for (int j = 0; j < (int)second.size(); ++j)
mask = (mask | (1 << (second[j] - 'a')));
msk.push_back(mask);
}
for (auto X : msk) F[X]++;
for (int i = 0; i < 24; ++i)
for (int mask = 0; mask < (1 << 24); ++mask) {
if (mask & (1 << i)) F[mask] += F[mask ^ (1 << i)];
}
int ans = 0;
for (int mask = 0; mask < (1 << 24); ++mask) {
int res = n - F[mask ^ ((1 << 24 - 1))];
ans = (ans ^ (res * res));
}
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void moha() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const long double eps = 1e-10;
int main() {
moha();
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int x = n, z = 1;
for (int i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1] && a[i] + k >= a[i + 1]) {
x -= z;
}
if (a[i] == a[i + 1]) {
z++;
} else {
z = 1;
}
}
cout << x << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
sum = sum * 10 + c - '0';
c = getchar();
}
return f * sum;
}
const int N = 1000005;
const int Mod = 1000000007;
int n, K;
long long inv[N], g[N];
inline long long fpow(long long a, long long b) {
long long ret = 1;
for (; b; a = a * a % Mod, b >>= 1)
if (b & 1) ret = ret * a % Mod;
return ret;
}
signed main() {
n = read();
K = read();
for (int i = 1; i <= n; i++) inv[i] = fpow(i, Mod - 2);
g[0] = 1;
long long sum = 0;
for (int i = 1; i <= n; i++) {
sum = (sum + g[i - 1]) % Mod;
if (i > K) sum = (sum - g[i - K - 1]) % Mod, sum = (sum + Mod) % Mod;
g[i] = sum;
g[i] = g[i] * inv[i] % Mod;
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans = (ans + g[i - 1]) % Mod;
ans = (n - ans) % Mod;
ans = (ans + Mod) % Mod;
for (int i = 1; i < n; i++) ans = ans * i % Mod;
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ed;
vector<int> ans;
vector<int> a;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
a.push_back(k);
}
a.push_back(999999);
ed.push_back(1);
ans.push_back(a[0]);
for (int i = 1; i < a.size(); i++) {
if (a[i] > *(ans.end() - 1)) {
ans.push_back(a[i]);
ed.push_back(ans.size());
} else {
vector<int>::iterator it = lower_bound(ans.begin(), ans.end(), a[i]);
ed.push_back(it - ans.begin() + 1);
*it = a[i];
}
}
vector<bool> flag(a.size(), false);
map<int, multiset<int> > elements;
elements[ed.back()].insert(a.back());
flag[a.size() - 1] = true;
for (int i = a.size() - 1; i >= 0; i--) {
int l = ed[i];
map<int, multiset<int> >::iterator it = elements.find(l + 1);
if (it == elements.end()) continue;
multiset<int>& t = it->second;
if (t.upper_bound(a[i]) != t.end()) {
elements[l].insert(a[i]);
flag[i] = true;
}
}
for (int i = 0; i < a.size() - 1; i++) {
if (!flag[i])
cout << 1;
else {
if (elements[ed[i]].size() == 1)
cout << 3;
else
cout << 2;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = 0; i < n; i++) cout << a[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
char mat[5001][5001];
vector<int> e[5001];
bool vst[5001];
bool dfs(int now, int pre) {
vst[now] = true;
for (int next = 0; next < n; ++next)
if (mat[now][next] - '0') {
if (mat[next][pre] - '0') {
printf("%d %d %d\n", pre + 1, now + 1, next + 1);
return true;
}
if (!vst[next] && dfs(next, now)) return true;
}
return false;
}
int main() {
scanf("%d%*c", &n);
for (int i = 0; i < n; ++i) {
gets(mat[i]);
}
for (int i = 0; i < n; ++i) {
if (!vst[i] && dfs(i, i)) return 0;
}
puts("-1");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod_v(long long num) {
if (num >= 0)
return (num % 1000000007);
else
return (num % 1000000007 + 1000000007) % 1000000007;
}
long long bigmod(long long b, long long p, long long m) {
long long res = 1 % m, x = b % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
int arr[110];
int main() {
int n, last, x, pos;
bool flag;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
last = n;
while (last > 1) {
flag = false;
x = 0;
pos = 0;
for (int i = last - 1; i >= 0; i--) {
if (arr[i] > x) {
flag = true;
x = arr[i];
pos = i;
}
}
if (!flag) break;
if (pos == last - 1) {
last = pos;
continue;
}
for (int i = pos; i <= last - 2; i++) {
swap(arr[i], arr[i + 1]);
printf("%d %d\n", i + 1, i + 2);
}
last = last - 1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> num(n);
for (long long i = 0; i < n; i++) {
cin >> num[i];
}
vector<long long> v(n);
long long mi = num[n - 1];
for (long long i = n - 2; i >= 0; i--) {
v[i] = mi;
if (mi <= num[i])
mi--;
else
mi = min(mi, num[i]);
if (mi < 0) mi = 0;
}
long long ans = 0;
for (long long i = 0; i < n - 1; i++) {
long long a = v[i] - 1;
if (a < 0) a = 0;
ans += min(num[i], a);
}
ans += num[n - 1];
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int M = 1 << 17;
int n, r, c, m, last;
int a[N];
vector<int> G[N];
int d[N];
int pre[N];
int post[N];
struct pm {
vector<int> depth, val;
int ask(int d) {
auto it = upper_bound((depth).begin(), (depth).end(), d);
if (it == depth.begin()) return 1000000007;
return val[it - depth.begin() - 1];
}
void merge(pm &x) {
vector<int> ndepth, nval;
int i = 0, j = 0;
while (i < depth.size() || j < x.depth.size()) {
if (i == depth.size()) {
ndepth.push_back(x.depth[j]);
nval.push_back(x.val[j++]);
} else if (j == x.depth.size()) {
ndepth.push_back(depth[i]);
nval.push_back(val[i++]);
} else if (depth[i] == x.depth[j]) {
ndepth.push_back(depth[i]);
nval.push_back(min(val[i++], x.val[j++]));
} else if (depth[i] < x.depth[j]) {
ndepth.push_back(depth[i]);
nval.push_back(val[i++]);
} else if (x.depth[j] < depth[i]) {
ndepth.push_back(x.depth[j]);
nval.push_back(x.val[j++]);
}
}
depth = ndepth;
val = nval;
for (int i = 1; i < val.size(); ++i) {
val[i] = min(val[i], val[i - 1]);
}
}
};
pm tree[2 * M];
int query(int a, int b, int d, int v = 1, int l = 0, int r = M - 1) {
if (a > b || l > b || a > r) return 1000000007;
if (a <= l && r <= b) return tree[v].ask(d);
return min(query(a, b, d, 2 * v, l, (l + r) / 2),
query(a, b, d, 2 * v + 1, (l + r) / 2 + 1, r));
}
void dfs(int v) {
pre[v] = ++c;
for (auto it : G[v]) {
if (!pre[it]) {
d[it] = d[v] + 1;
dfs(it);
}
}
post[v] = c;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> r;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
dfs(r);
for (int i = 1; i <= n; ++i) {
tree[pre[i] + M].val.push_back(a[i]);
tree[pre[i] + M].depth.push_back(d[i]);
}
for (int i = M - 1; i >= 1; --i) {
tree[i] = tree[2 * i];
tree[i].merge(tree[2 * i + 1]);
}
cin >> m;
while (m--) {
int p, q, x, k;
cin >> p >> q;
x = (p + last) % n + 1;
k = (q + last) % n;
cout << (last = query(pre[x], post[x], d[x] + k)) << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1001];
long long s, mi = 500000, mii;
int main() {
int i, j, n;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= 100; i++) {
s = 0;
int temp;
for (j = 1; j <= n; j++) {
temp = abs(a[j] - i);
if (temp > 1) s += temp - 1;
}
if (s < mi) {
mi = s;
mii = i;
}
}
cout << mii << ' ' << mi << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a, b;
int n, x[200002];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i];
}
sort(x, x + n);
if (n == 1) {
cout << "YES" << endl << "1" << endl << x[0] << endl << 0 << endl << endl;
return 0;
}
a.push_back(x[0]);
for (int i = 1; i < n; i++) {
if (a[a.size() - 1] < x[i])
a.push_back(x[i]);
else
b.push_back(x[i]);
}
if (b.size() != 0) {
for (int i = 0; i < b.size() - 1; i++) {
if (b[i] >= b[i + 1]) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
cout << a.size() << endl;
for (int i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << endl << b.size() << endl;
if (b.size() != 0) {
for (int i = b.size() - 1; i >= 0; i--) {
cout << b[i] << " ";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
const long long N = 1e6 + 6;
void solve() {
long long n, m;
cin >> n >> m;
long long arr[n + 1][m + 1];
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> arr[i][j];
}
long long dp[n + 1][m + 1];
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= m; j++) {
if (i == 0 || j == 0)
dp[i][j] = 0;
else {
if (j == 1)
dp[i][j] = dp[i - 1][j] + arr[i][j];
else {
if (dp[i][j - 1] <= dp[i - 1][j]) {
dp[i][j] = dp[i - 1][j] + arr[i][j];
} else {
dp[i][j] = dp[i - 1][j] + arr[i][j] + (dp[i][j - 1] - dp[i - 1][j]);
}
}
}
}
}
for (long long i = 1; i <= n; i++) {
cout << dp[i][m] << " ";
;
}
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int vis[2][maxn], h[2][maxn];
int main() {
int n, k, hw = -1;
string s[2];
cin >> n >> k >> s[0] >> s[1];
int dx[4] = {1, -1, k, k}, dy[4] = {0, 0, -1, 1};
vis[0][0] = 1;
queue<pair<int, int> > q;
q.push(make_pair(0, 0));
memset(h, -1, sizeof(h));
if (s[0][0] == 'X') {
cout << "NO";
return 0;
}
while (!q.empty()) {
pair<int, int> x = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int nx = x.first + dx[i], ny = x.second + dy[i];
if (nx > -1 && nx < n && ny > -1 && ny < 2 && vis[ny][nx] == 0 &&
s[ny][nx] == '-' && x.first > h[x.second][x.first]) {
q.push(make_pair(nx, ny));
vis[ny][nx] = 1;
h[ny][nx] = h[x.second][x.first] + 1;
}
if (nx >= n) {
cout << "YES";
return 0;
}
}
hw++;
}
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265359;
const long long int Maxi = 1000000000000000001;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, i = 0, j, l, k = 0, p = 0, s = 0, t = 1, x, y, z, r, c;
long long a[100005] = {0};
long long b[100005];
cin >> n;
cin >> a[i] >> b[i];
if (a[i] != b[i]) {
cout << "rated";
return 0;
}
x = a[i], y = b[i];
for (i = 1; i < n; i++) {
cin >> a[i] >> b[i];
if (a[i] > x) p = 1;
if (a[i] != b[i]) {
cout << "rated";
return 0;
}
x = a[i], y = b[i];
}
if (p)
cout << "unrated";
else
cout << "maybe";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[200020];
int main() {
cin >> n;
for (int i = 0; i < n * 2; i++) cin >> a[i];
sort(a, a + 2 * n);
long long ans = (a[n - 1] - a[0]) * (a[n * 2 - 1] - a[n]);
for (int i = 1; i < n; i++) {
ans = min(ans, (a[n + i - 1] - a[i]) * (a[n * 2 - 1] - a[0]));
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2200 + 7;
const long long INF2 = (long long)1e9;
const long long INF = (long long)1e18;
long long n;
long long k;
long long s;
long long d;
long long a[N];
long long c[N];
long long cap[N][N];
long long cost[N][N];
vector<long long> g[N];
long long best[N];
long long par[N];
bool act[N];
void baga(long long a, long long b, long long cp, long long cst) {
g[a].push_back(b);
b[g].push_back(a);
cap[a][b] = cp;
cost[a][b] = cst;
cost[b][a] = -cost[a][b];
}
signed main() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) cin >> c[i];
s = 0;
d = n + 1;
for (long long i = 1; i <= n; i++) {
baga(s, i, 1, a[i]);
baga(i, d, 1, c[i]);
if (i + 1 <= n) baga(i, i + 1, k, 0);
}
n = d + 1;
long long ans = 0, step = 0;
long long ret = INF;
while (1) {
step++;
if (step > k) break;
for (long long i = 0; i < n; i++) {
best[i] = INF;
}
act[s] = 1;
best[s] = 0;
queue<long long> q;
q.push(s);
while (!q.empty()) {
long long a = q.front();
q.pop();
act[a] = 0;
for (auto &b : g[a]) {
if (cap[a][b] > 0 && best[a] + cost[a][b] < best[b]) {
best[b] = best[a] + cost[a][b];
par[b] = a;
if (act[b] == 0) {
act[b] = 1;
q.push(b);
}
}
}
}
if (best[d] == INF) {
break;
}
long long mn = INF, now = d;
while (now != s) {
long long a = par[now];
long long b = now;
mn = min(mn, cap[a][b]);
now = par[now];
}
ans += (long long)best[d] * mn;
now = d;
while (now != s) {
long long a = par[now];
long long b = now;
cap[a][b] -= mn;
cap[b][a] += mn;
now = par[now];
}
}
cout << ans << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maks = 200005;
long long n, m, k, q, a[maks][2], b[maks], x, y, dp[maks][2];
int find_br(long long j, long long u, long long i, long long v) {
long long p = lower_bound(b + 1, b + q + 1, a[j][u]) - b, rt = 1e9;
if (p <= q)
rt = abs(a[j][u] - b[p]) + abs(a[i][v ^ 1] - b[p]) +
abs(a[i][v] - a[i][v ^ 1]);
p = upper_bound(b + 1, b + q + 1, a[j][u]) - b - 1;
if (p)
rt = min(rt, abs(a[j][u] - b[p]) + abs(a[i][v ^ 1] - b[p]) +
abs(a[i][v] - a[i][v ^ 1]));
return rt;
}
int main() {
cin >> n >> m >> k >> q;
for (int i = 1; i < n + 1; ++i) a[i][0] = 1e9, a[i][1] = -1e9;
for (int u = 1; u < k + 1; ++u)
cin >> x >> y, a[x][0] = min(a[x][0], y), a[x][1] = max(a[x][1], y);
a[1][0] = 1, a[1][1] = max(a[1][1], 1ll);
for (int i = 1; i < q + 1; ++i) cin >> b[i];
sort(b + 1, b + q + 1);
memset(dp, 0x3f, sizeof(dp));
dp[1][0] = abs(a[1][1] - 1) + abs(a[1][1] - a[1][0]),
dp[1][1] = abs(a[1][1] - 1);
int j = 1;
for (int i = 2; i < n + 1; ++i) {
if (a[i][0] == 1e9) continue;
for (long long v = 0; v < 2; ++v)
for (long long u = 0; u < 2; ++u)
dp[i][v] = min(dp[i][v], dp[j][u] + find_br(j, u, i, v) + i - j);
j = i;
}
cout << min(dp[j][0], dp[j][1]) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> board(n, vector<int>(m)), sum(n + 1, vector<int>(m + 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (c == 'X') board[i][j] = sum[i + 1][j + 1] = 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
sum[i][j] += sum[i - 1][j];
}
}
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sum[i][j] += sum[i][j - 1];
}
}
auto can_paint = [&](int i, int j, int sz) -> bool {
if (i + sz >= n || i - sz < 0 || j + sz >= m || j - sz < 0) return false;
int e = 2 * sz + 1;
return e * e == sum[i + sz + 1][j + sz + 1] - sum[i + sz + 1][j - sz] -
sum[i - sz][j + sz + 1] + sum[i - sz][j - sz];
};
int dx[] = {-1, 0, 1, 1, 1, 0, -1, -1};
int dy[] = {1, 1, 1, 0, -1, -1, -1, 0};
auto valid = [&](int i, int j) -> bool {
return 0 <= i && i < n && 0 <= j && j < m;
};
auto check = [&](const vector<pair<int, int>> &paint, int T) -> bool {
vector<vector<int>> bo(n, vector<int>(m, 1e9));
queue<pair<int, int>> que;
for (auto &p : paint) {
bo[p.first][p.second] = 0;
que.push(p);
}
while (!que.empty()) {
auto p = que.front();
que.pop();
int t = bo[p.first][p.second];
if (t + 1 > T) continue;
for (int i = 0; i < 8; i++) {
int x = p.first + dx[i], y = p.second + dy[i];
if (!valid(x, y)) return false;
if (t + 1 < bo[x][y]) {
bo[x][y] = t + 1;
que.emplace(x, y);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (board[i][j] != (bo[i][j] != 1e9)) return false;
}
}
return true;
};
auto make_paint = [&](int sz) -> vector<pair<int, int>> {
vector<pair<int, int>> paint;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (can_paint(i, j, sz)) {
paint.emplace_back(i, j);
}
}
}
return paint;
};
auto ok = [&](int sz) -> bool { return check(make_paint(sz), sz); };
int l = 0, r = (min(n, m) - 1) / 2 + 1;
while (l < r - 1) {
int mid = (l + r) / 2;
if (ok(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l << endl;
vector<string> ans(n, string(m, '.'));
auto paint = make_paint(l);
for (auto &p : paint) {
ans[p.first][p.second] = 'X';
}
for (auto &s : ans) {
cout << s << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, i, j, count = 0, flag = 0, m, k, ans = 0;
cin >> n >> k;
long long int a[n], per[n + 1];
queue<pair<long long int, long long int> > q;
bool visit[n];
for (i = 0; i < n; i++) {
cin >> a[i];
q.push({a[i], i});
visit[i] = false;
}
per[0] = 0;
for (i = 1; i <= n; i++) {
per[i] = floor((double)(i * 100) / n + 0.5);
}
long long int completed = 0;
pair<long long int, long long int> pro[k], test[k], temp;
for (i = 0; i < k; i++) {
test[i] = {1, i};
if (!q.empty()) {
temp = q.front();
q.pop();
pro[i] = temp;
} else {
pro[i] = {-1, -1};
}
}
while (completed != n) {
for (i = 0; i < k; i++) {
if (pro[i].first != -1) {
if (test[i].first == per[completed]) {
visit[pro[i].second] = true;
}
}
}
for (i = 0; i < k; i++) {
if (test[i].first == pro[i].first) {
pro[i] = {-1, -1};
completed++;
}
test[i].first++;
}
for (i = 0; i < k; i++) {
if (pro[i].first == -1) {
if (!q.empty()) {
temp = q.front();
q.pop();
pro[i] = temp;
test[i] = {1, i};
} else {
break;
}
}
}
}
for (i = 0; i < n; i++) {
if (visit[i]) {
ans++;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, a, b, t = -1, ans;
cin >> x >> y;
bool vis[100001];
unordered_set<int> vec[100001];
unordered_map<int, int> cc;
for (int i = 1; i <= x; i++) {
cin >> a;
cc[i] = a;
vis[a] = true;
}
for (int i = 0; i < y; i++) {
cin >> a >> b;
if (cc[a] != cc[b]) {
vec[cc[a]].insert(cc[b]);
vec[cc[b]].insert(cc[a]);
}
}
for (int i = 1; i <= 100000; i++) {
if ((int)vec[i].size() > t && vis[i]) {
t = vec[i].size();
ans = i;
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ncrp(long long n, long long r, long long p) {
long long C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long i = 1; i <= n; i++)
for (long long j = min(i, r); j >= 1; j--) C[j] = (C[j] + C[j - 1]) % p;
return C[r];
}
long long mod_exp(long long x, long long y, long long mm) {
x %= mm;
if (y == 0)
return (1);
else if (y % 2 == 0)
return (mod_exp((x * x) % mm, y / 2, mm));
else
return ((x * mod_exp((x * x) % mm, (y - 1) / 2, mm)) % mm);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, r, s;
cin >> n;
r = (sqrt(1 + 8 * n) - 1) / 2;
s = n - (r * (r + 1) / 2);
cout << r << endl;
for (long long i = r; i >= 1; i--) {
if (s != 0) {
cout << i + 1 << " ";
s--;
} else
cout << i << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct nod {
int x, y;
char ch, pre;
} tt, uu;
int dx[2] = {0, 1};
int dy[2] = {1, 0};
int n, k, vis[2020][2020], cost[2020][2020];
char ans[2020 * 2], a[2020][2020];
bool inside(int u, int v) {
if (u <= n && u > 0 && v > 0 && v <= n) return true;
return false;
}
queue<nod> ww;
int main() {
ios::sync_with_stdio(false);
int i, j, tx, ty;
cin >> n >> k;
for (i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (i = 0; i <= 2 * n - 1; i++) ans[i] = 'z';
tt.x = 1;
tt.y = 1;
tt.pre = 'a';
cost[1][1] = (a[1][1] != 'a');
if (a[1][1] == 'a' || k == 0) {
tt.ch = a[1][1];
} else
tt.ch = 'a';
ans[1] = tt.ch;
ww.push(tt);
if (k >= 2 * n - 1) {
for (i = 1; i <= 2 * n - 1; i++) cout << 'a';
return 0;
}
while (!ww.empty()) {
tt = ww.front();
ww.pop();
if (cost[tt.x][tt.y] <= k)
ans[tt.x + tt.y - 1] = 'a';
else if (ans[tt.x + tt.y - 1] < tt.ch)
continue;
for (i = 0; i <= 1; i++) {
tx = tt.x + dx[i];
ty = tt.y + dy[i];
uu.x = tx;
uu.y = ty;
if (!inside(tx, ty)) continue;
if (!cost[tx][ty])
cost[tx][ty] = cost[tt.x][tt.y] + (a[tx][ty] != 'a');
else
cost[tx][ty] = min(cost[tx][ty], cost[tt.x][tt.y] + (a[tx][ty] != 'a'));
uu.pre = min(a[tx - 1][ty], a[tx][ty - 1]);
if (vis[tx][ty])
continue;
else
vis[tx][ty] = 1;
if (uu.pre <= ans[tx + ty - 2] || cost[tx][ty] <= k + 1) {
if (a[tx][ty] <= ans[tx + ty - 1] || cost[tx][ty] <= k + 1) {
if (cost[tx][ty] > k)
ans[tx + ty - 1] = min(ans[tx + ty - 1], a[tx][ty]),
uu.ch = a[tx][ty];
else
ans[tx + ty - 1] = 'a', uu.ch = 'a';
ww.push(uu);
}
}
}
}
for (i = 1; i <= 2 * n - 1; i++) printf("%c", ans[i]);
;
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a;
cin >> n >> k;
vector<int> v;
int ans = 0;
bool flag = 0;
v.push_back(-1);
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
if (a == k) flag = 1;
}
if (flag == 0) {
ans++;
v.push_back(k);
}
sort(v.begin(), v.end());
while (1) {
n = (int)v.size();
n -= 1;
n = (n + 1) / 2;
if (v[n] == k) {
cout << ans;
return 0;
} else if (v[n] > k) {
v.push_back(1);
} else {
v.push_back(100000);
}
ans++;
sort((v).begin(), (v).end());
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
int x = 0, y = 0;
if (s[0] == 'U')
y++;
else
x++;
for (int i = 1; i < n; i++) {
if (x == y && s[i - 1] == s[i]) ans++;
if (s[i] == 'U')
y++;
else
x++;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
long long int n, a, b, i, t;
scanf("%lld %lld %lld", &n, &a, &b);
t = n / a + 1;
for (i = 0; i < t; i++) {
if ((n - (a * i)) % b == 0 && n - (a * i) >= 0) {
printf("YES\n%lld %lld", i, (n - (a * i)) / b);
return 0;
}
}
printf("NO");
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.