solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#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, x;
cin >> n >> x;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
cin >> b[i];
}
sort(b, b + n, greater<int>());
int y = 0;
for (int i = 0; i < n; i++) {
if ((a[i] + b[i]) > x) {
y = 1;
break;
}
}
if (y == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 130;
int dp[4][105];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int cnt = 0;
scanf("%d", &cnt);
if (cnt == 0) {
dp[1][i] = dp[2][i] = 0x3f3f3f3f;
dp[0][i] = min(dp[0][i - 1], min(dp[1][i - 1], dp[2][i - 1])) + 1;
} else if (cnt == 1) {
dp[0][i] = min(dp[0][i - 1], min(dp[1][i - 1], dp[2][i - 1])) + 1;
dp[1][i] = min(dp[0][i - 1], dp[2][i - 1]);
dp[2][i] = 0x3f3f3f3f;
} else if (cnt == 2) {
dp[0][i] = min(dp[0][i - 1], min(dp[1][i - 1], dp[2][i - 1])) + 1;
dp[2][i] = min(dp[0][i - 1], dp[1][i - 1]);
dp[1][i] = 0x3f3f3f3f;
} else if (cnt == 3) {
dp[0][i] = min(dp[0][i - 1], min(dp[1][i - 1], dp[2][i - 1])) + 1;
dp[1][i] = min(dp[0][i - 1], dp[2][i - 1]);
dp[2][i] = min(dp[0][i - 1], dp[1][i - 1]);
}
}
cout << min(min(dp[0][n], dp[1][n]), dp[2][n]) << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
void test() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
if (a[n - 1] >= a[0] + a[1])
cout << 1 << " " << 2 << " " << n << endl;
else
cout << -1 << endl;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
test();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
int all[24][24];
int num[24] = {0};
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++) scanf("%d", &all[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (all[i][j] != j) num[i]++;
int ans = 1;
for (int i = 1; i <= n; i++)
if (num[i] > 2) ans = 0;
for (int i = 1; i <= m; i++)
for (int j = i + 1; j <= m; j++) {
int sol = 1;
for (int k = 1; k <= n; k++)
if (all[k][j] == i && all[k][i] == j && num[k] <= 4)
;
else if (all[k][j] == j && all[k][i] == i && num[k] <= 0)
;
else if (all[k][j] == i && all[k][i] != j && num[k] <= 3)
;
else if (all[k][j] != i && all[k][i] == j && num[k] <= 3)
;
else
sol = 0;
ans |= sol;
}
if (ans)
cout << "YES";
else
cout << "NO";
}
| 7 |
#include <bits/stdc++.h>
const double kEPS = 1e-6;
const int kMaxN = 100;
std::complex<long long> tri[kMaxN][3];
std::complex<long long> p[3 * kMaxN + 2];
double list[3 * kMaxN + 2];
int lsize;
int n;
inline int Sign(double x, double y = 0.0) {
if (fabs(x - y) < kEPS) return 0;
return x < y ? -1 : 1;
}
inline long long Cross(const std::complex<long long> &a,
const std::complex<long long> &b) {
return a.real() * b.imag() - a.imag() * b.real();
}
inline double Cross(const std::complex<long long> &a,
const std::complex<long long> &b, double x, double y) {
return (b.real() - a.real()) * (y - a.imag()) -
(b.imag() - a.imag()) * (x - a.real());
}
inline bool DoubleCmp(double a, double b) { return Sign(a - b) == 0; }
void ReadIn() {
int x, y;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
scanf("%d%d", &x, &y);
tri[i][j] = std::complex<long long>(x, y);
}
if (Cross(tri[i][1] - tri[i][0], tri[i][2] - tri[i][0]) < 0)
std::swap(tri[i][1], tri[i][2]);
}
}
inline double CrossPoint(const std::complex<long long> &a,
const std::complex<long long> &at,
const std::complex<long long> &b,
const std::complex<long long> &bt) {
std::complex<long long> va = at - a, vb = bt - b;
long long q = Cross(va, vb);
long long pa = Cross(b - a, vb), pb = Cross(b - a, va);
if (q == 0) return -1.0;
if (q < 0) {
pa = -pa;
pb = -pb;
q = -q;
}
if (pa <= 0 || pa > q || pb < 0 || pb > q) return -1.0;
return (double)pa / (double)q;
}
inline bool IsInside(double x, double y) {
for (int i = 0; i < n; ++i)
if (Sign(Cross(tri[i][0], tri[i][1], x, y)) > 0 &&
Sign(Cross(tri[i][1], tri[i][2], x, y)) > 0 &&
Sign(Cross(tri[i][2], tri[i][0], x, y)) > 0)
return true;
return false;
}
void Solve() {
double result = 0.0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j) {
lsize = 2;
list[0] = 0.0;
list[1] = 1.0;
for (int k = 0; k < n; ++k)
if (i != k)
for (int l = 0; l < 3; ++l) {
double t = CrossPoint(tri[i][j], tri[i][(j + 1) % 3], tri[k][l],
tri[k][(l + 1) % 3]);
if (Sign(t) >= 0) list[lsize++] = t;
}
std::sort(list, list + lsize);
lsize = std::unique(list, list + lsize, DoubleCmp) - list;
std::complex<long long> v = tri[i][(j + 1) % 3] - tri[i][j];
for (int k = 0; k < lsize - 1; ++k)
if (!IsInside(
tri[i][j].real() + v.real() * (list[k] + list[k + 1]) / 2.0,
tri[i][j].imag() + v.imag() * (list[k] + list[k + 1]) / 2.0))
result += sqrt(v.real() * v.real() + v.imag() * v.imag()) *
(list[k + 1] - list[k]);
}
printf("%lf\n", result);
}
int main() {
ReadIn();
Solve();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x = 0;
cin >> n >> m;
if (n == m) {
cout << n;
return 0;
}
if (n < m) {
cout << "-1";
return 0;
}
while (n) {
if (n >= 2) {
x++;
n -= 2;
} else {
x++;
n -= 1;
}
}
if (x % m == 0) {
cout << x;
} else {
while (true) {
x++;
if (x % m == 0) break;
}
cout << x;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150010;
int pre[N], nex[N];
int pr[N], ne[N];
int n;
int nextt(int x) { return ne[x] == -1 ? x : ne[x] = nextt(ne[x]); }
int pree(int x) { return pr[x] == -1 ? x : pr[x] = pree(pr[x]); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
pre[i] = nex[i] = -1;
pr[i] = ne[i] = -1;
}
int x, y;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
int xx = nextt(x);
int yy = pree(y);
ne[xx] = yy;
pr[yy] = xx;
pre[yy] = xx;
nex[xx] = yy;
}
int pos;
for (int i = 1; i <= n; i++) {
if (nex[i] != -1 && pre[i] == -1) {
pos = i;
break;
}
}
printf("%d", pos);
pos = nex[pos];
while (pos != -1) {
printf(" %d", pos);
pos = nex[pos];
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int t = 399, mod = 998244353;
inline int mo(const register int x) { return x >= mod ? x - mod : x; }
int a[100010], n, k, bl[100010], p[100010], pre[100010], sum[400][100010],
f[400], S[400], dp[100010], lst[100010];
inline void rebuild(const register int x, const register int l,
const register int r, const register int y) {
for (int i = (x - 1) * t + 1; i <= min(n, x * t); i++)
sum[x][p[i]] = 0, p[i] += k - f[x];
for (int i = l; i <= r; i++) p[i] += y;
S[x] = 0;
for (int i = (x - 1) * t + 1; i <= min(n, x * t); i++)
sum[x][p[i]] = mo(sum[x][p[i]] + dp[i]),
S[x] = mo(S[x] + (p[i] <= k) * dp[i]);
f[x] = k;
}
inline void ad(const register int l, const register int r,
const register int x) {
if (bl[l] == bl[r]) {
rebuild(bl[l], l, r, x);
return;
}
rebuild(bl[l], l, bl[l] * t, x);
rebuild(bl[r], (bl[r] - 1) * t + 1, r, x);
for (int i = bl[l] + 1; i < bl[r]; i++) {
f[i] -= x;
if (x > 0) {
if (f[i] + 1 >= 0 && f[i] + 1 < n)
S[i] = mo(S[i] - sum[i][f[i] + 1] + mod);
} else if (f[i] >= 0 && f[i] < n)
S[i] = mo(S[i] + sum[i][f[i]]);
}
}
int main() {
scanf("%d%d", &n, &k);
n++;
for (int i = 1; i <= n; i++) bl[i] = (i - 1) / t + 1;
for (int i = 1; i <= bl[n]; i++) f[i] = k;
for (int i = 2; i <= n; i++) scanf("%d", &a[i]), pre[a[i]] = 1;
dp[1] = 1;
ad(1, 1, 0);
for (int i = 2; i <= n; i++) {
if (pre[a[i]] - 1) ad(lst[pre[a[i]]], pre[a[i]] - 1, -1);
ad(pre[a[i]], i - 1, 1);
lst[i] = pre[a[i]];
pre[a[i]] = i;
for (int j = 1; j <= bl[n]; j++) dp[i] = mo(dp[i] + S[j]);
ad(i, i, 0);
}
cout << dp[n] << endl;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int x[100005], d[100005];
long long L[100005], R[100005];
void cal() {
set<pair<long long, long long>> s;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
L[i] = -1;
if (x[i] < d[i] + d[i]) {
L[i] = 2 * d[i];
}
while (!s.empty()) {
auto p = *s.begin();
if (L[p.second] < x[i]) {
s.erase(p);
} else {
long long tmp = -p.first;
L[i] = (long long)d[i] * 2 + tmp;
break;
}
}
if (L[i] > x[i]) {
if (L[i] >= x[n + 1]) {
puts("0");
exit(0);
}
s.insert({-x[i], i});
}
}
s.clear();
for (int i = n; i >= 1; i--) {
R[i] = (1LL << 60);
if (x[n + 1] - x[i] < d[i] + d[i]) {
R[i] = x[n + 1] - 2 * d[i];
}
while (!s.empty()) {
auto p = *s.begin();
if (R[p.second] > x[i]) {
s.erase(p);
} else {
long long tmp = p.first;
R[i] = (long long)tmp - d[i] * 2;
break;
}
}
if (R[i] < x[i]) {
assert(R[i] > 0);
s.insert({x[i], i});
}
}
long long ans = x[n + 1];
s.clear();
for (int(i) = 1; (i) <= (int)(n); (i)++) {
if (!s.empty() && R[i] < x[i]) {
auto it = s.lower_bound({R[i], -(1LL << 60)});
if (it != s.end()) {
ans = min(x[i] + (*it).second, ans);
}
}
if (L[i] > x[i]) {
s.insert({L[i], -x[i]});
ans = min(ans, (long long)x[n + 1] - x[i]);
}
if (R[i] < x[i]) {
ans = min(ans, (long long)x[i]);
}
}
printf("%.1lf\n", (double)ans / 2);
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n + 2); (i)++) {
scanf("%d", x + i);
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", d + i);
}
cal();
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next, v, mk;
} e[20010 << 2];
int head[20010];
int cnt;
int n, m, l, s, E;
int t, h;
int dis[20010], vis[20010], q[20010];
void link(int x, int y, int z, int w) {
e[cnt] = (edge){y, head[x], z, w};
head[x] = cnt++;
}
void add(int x, int y, int z, int w) {
link(x, y, z, w);
link(y, x, z, w);
}
void SPFA() {
memset(vis, 0, sizeof(vis));
memset(dis, 63, sizeof(dis));
h = 0;
q[t = 1] = s;
vis[s] = 1;
dis[s] = 0;
while (h != t) {
int now = q[h = h % n + 1];
vis[now] = 0;
for (int i = head[now]; ~i; i = e[i].next) {
int y = e[i].to;
if (dis[y] > dis[now] + e[i].v) {
dis[y] = dis[now] + e[i].v;
if (!vis[y]) {
vis[y] = 1;
q[t = t % n + 1] = y;
}
}
}
}
}
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d%d%d%d", &n, &m, &l, &s, &E);
for (int i = 0, x, y, z; i < m; i++) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z ? z : 1, z == 0);
}
SPFA();
if (dis[E] > l) {
printf("NO");
return 0;
}
for (int k = 0; k < n; k++)
for (int i = head[k]; ~i; i = e[i].next)
if (i & 1)
if (e[i].mk) {
if (dis[E] == l) goto YJY;
e[i ^ 1].v = e[i].v = l - dis[E] + 1;
SPFA();
}
if (dis[E] != l) {
printf("NO");
return 0;
}
YJY : {
printf("YES\n");
for (int k = 0; k < n; k++)
for (int i = head[k]; ~i; i = e[i].next)
if (i & 1) printf("%d %d %d\n", e[i ^ 1].to, e[i].to, e[i].v);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> vec;
for (int i = 0; i < n; i++) {
int d;
scanf("%1d", &d);
if (d == 2 || d == 3 || d == 5 || d == 7)
vec.push_back(d);
else if (d == 4)
vec.push_back(3), vec.push_back(2), vec.push_back(2);
else if (d == 6)
vec.push_back(5), vec.push_back(3);
else if (d == 8)
vec.push_back(7), vec.push_back(2), vec.push_back(2), vec.push_back(2);
else if (d == 9)
vec.push_back(7), vec.push_back(3), vec.push_back(3), vec.push_back(2);
}
sort(vec.begin(), vec.end());
for (int i = vec.size(); i--;) printf("%d", vec[i]);
puts("");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 10;
vector<int> g[maxn];
int num[maxn];
int mn, mx;
int n, d;
int ans[maxn], fa[maxn], id[maxn];
bool run() {
cin >> n >> d;
for (int i = 1; i <= n; ++i) g[i].clear();
int rem = n, dep = 0;
mn = 0;
for (int i = 0; i <= n; ++i) {
dep = i;
if (rem <= (1 << i)) {
num[i] = rem;
mn += rem * (i);
break;
}
rem -= (1 << i);
mn += (1 << i) * (i);
}
mx = n * (n - 1) / 2;
if (d < mn) return false;
if (d > mx) return false;
for (int i = 1; i <= n; ++i) ans[i] = 1;
int down = n, up = 2;
while (mx > d) {
ans[down]--;
if (mx - d > down - up + 1) {
ans[up]++;
mx -= down - up;
if (ans[up] == (1 << (up - 1))) ++up;
} else {
for (int j = down + d - mx; j <= n; ++j) {
if (ans[j] != (1 << (j - 1))) {
++ans[j];
mx -= down - j;
break;
}
}
}
--down;
}
return true;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
if (run()) {
printf("YES\n");
int cnt = 1;
for (int i = 1; i <= n; ++i) {
if (!ans[i]) break;
for (int j = 0; j < ans[i]; ++j) g[i].push_back(cnt++);
}
for (int i = 2; i <= n; ++i) {
if (!ans[i]) break;
for (int j = 0; j < ans[i]; ++j) {
fa[g[i][j]] = g[i - 1][j >> 1];
}
}
for (int i = 2; i <= n; ++i) printf("%d%c", fa[i], i == n ? '\n' : ' ');
} else
printf("NO\n");
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
char s[200000];
char t[200000];
int pos[30][110000];
int len[30];
int n, k;
void make(char x, int y) { pos[x - 'a' + 1][++len[x - 'a' + 1]] = y; }
void pre() {
for (int i = 1; i <= k; i++) {
char x = s[i - 1];
make(x, i);
}
}
long long Find(char x, int y, int z) {
int now = x - 'a' + 1;
if (!len[now]) return z;
int l = 1, r = len[now];
while (l < r) {
int mid = (l + r + 1) / 2;
if (pos[now][mid] <= y)
l = mid;
else
r = mid - 1;
}
int ans1 = abs(y - pos[now][l]);
l = 1, r = len[now];
while (l < r) {
int mid = (l + r) / 2;
if (pos[now][mid] >= y)
r = mid;
else
l = mid + 1;
}
int ans2 = abs(pos[now][l] - y);
return min(ans2, ans1);
}
int main() {
cin >> n >> k;
cin >> s;
pre();
for (int i = 1; i <= n; i++) {
cin >> t;
int l = strlen(t);
long long ans = 0;
for (int j = 0; j < l; j++) {
ans += Find(t[j], j + 1, l);
}
cout << ans << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int f[2111111];
int main() {
int n;
while (cin >> n) {
int *a = f;
for (int i = 1; i <= n; ++i) a[i] = i;
for (int i = 2; i <= n; i++) {
a[n + 1] = a[(n - 1) / i * i + 1];
for (int j = (n - 1) / i * i + 1; j >= 1; j -= i) a[j] = a[j - i];
++a;
}
for (int i = 1; i <= n; ++i) cout << a[i] << " ";
cout << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 7;
const int INF = (int)1e9 + 7;
const long long LINF = (long long)1e18 + 7;
const int MOD = (int)1e9 + 7;
void file() {}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
struct Point {
int x, y;
Point() {}
Point(int _x, int _y) { x = _x, y = _y; }
};
struct Vect {
int x, y;
Vect() {}
Vect(int _x, int _y) { x = _x, y = _y; }
Vect(Point a) { x = a.x, y = a.y; }
Vect(Point a, Point b) { x = b.x - a.x, y = b.y - a.y; }
long long operator^(Vect d) { return 1ll * x * d.y - 1ll * y * d.x; }
};
int main() {
file();
int n;
Point C;
n = readInt(), C.x = readInt(), C.y = readInt();
vector<Point> A(n), B;
for (int i = 0; i < n; ++i) {
A[i].x = readInt(), A[i].y = readInt();
}
sort(A.begin(), A.end(), [](Point a, Point b) {
return make_pair(a.x, a.y) > make_pair(b.x, b.y);
});
int maxy = -1;
for (Point i : A) {
if (i.y > maxy) {
B.push_back(i);
maxy = i.y;
}
}
if ((Vect(B[0]) ^ Vect(B[0], C)) <= 0) {
printf("%.10f", max(1.0 * C.x / B[0].x, 1.0 * C.y / B[0].y));
return 0;
}
if ((int)B.size() == 1 || (Vect(B.back()) ^ Vect(B.back(), C)) >= 0) {
printf("%.10f", max(1.0 * C.x / B.back().x, 1.0 * C.y / B.back().y));
return 0;
}
int ind;
for (int i = 0; i < (int)B.size() - 1; ++i) {
if ((Vect(B[i]) ^ Vect(B[i], C)) >= 0) {
ind = i;
} else {
break;
}
}
double ans = 1e18;
int uk = ind + 1;
auto get_ans = [C](int x1, int y1, int x2, int y2) {
double a, b;
if (x1 * y2 - x2 * y1 == 0) {
int yy = max(y1, y2);
int xx = max(x1, x2);
return 1.0 * C.x / xx + 1.0 * C.y / yy;
} else {
b = 1.0 * (1ll * x1 * C.y - 1ll * C.x * y1) /
(1ll * x1 * y2 - 1ll * x2 * y1);
a = 1.0 * (C.x - b * x2) / x1;
return a + b;
}
};
for (int i = ind; i >= 0; --i) {
if (clock() * 1.0 / CLOCKS_PER_SEC > 0.023) {
break;
}
int x1, y1;
x1 = B[i].x, y1 = B[i].y;
double cur;
while (uk + 1 != (int)B.size() &&
get_ans(x1, y1, B[uk + 1].x, B[uk + 1].y) <=
get_ans(x1, y1, B[uk].x, B[uk].y)) {
++uk;
}
cur = get_ans(x1, y1, B[uk].x, B[uk].y);
ans = min(ans, cur);
}
printf("%.10f", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-10;
const int MODULO = 1000000007;
template <int size>
class UnionFind {
int par[size];
int rank[size];
public:
UnionFind() { reset(); }
void reset() {
for (int i = 0; i < (size); i++) par[i] = i, rank[i] = 0;
}
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (rank[x] < rank[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank[x] == rank[y]) rank[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
};
UnionFind<100000> u;
int n, m, k;
vector<int> v[100000];
vector<int> v2[100000];
bool use[100000];
vector<int> use_num;
stack<int> st;
void Unit(int x) {
stack<int> s(st);
while (s.top() != x) {
u.unite(x, s.top());
s.pop();
}
}
void connect(int x) {
st.push(x);
int next = st.top();
use[next] = true;
use_num.push_back(next);
for (__typeof__((v[next]).begin()) it = (v[next]).begin();
it != (v[next]).end(); ++it) {
vector<int>::iterator i = find(v[*it].begin(), v[*it].end(), next);
if (i != v[*it].end()) v[*it].erase(i);
if (use[*it]) {
Unit(*it);
} else {
connect(*it);
}
}
st.pop();
}
class GT {
public:
bool operator()(const pair<int, int>& x, const pair<int, int>& y) {
return less<int>()(x.second, y.second);
}
};
int get_len(int l, int s) {
memset(use, 0, sizeof(use));
priority_queue<pair<int, int>, vector<pair<int, int> >, GT> q;
q.push(pair<int, int>(l, 0));
while (!q.empty()) {
pair<int, int> next = q.top();
q.pop();
if (use[next.first]) continue;
if (next.first == s) return next.second;
use[next.first] = true;
for (__typeof__((v2[next.first]).begin()) it = (v2[next.first]).begin();
it != (v2[next.first]).end(); ++it) {
if (!use[(*it)]) {
int len = next.second;
if (!u.same(next.first, *it)) len++;
q.push(pair<int, int>(*it, len));
}
}
}
return -1;
}
int main() {
iostream::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < (m); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
v2[a].push_back(b);
v2[b].push_back(a);
}
connect(0);
cin >> k;
for (int i = 0; i < (k); i++) {
int s, l;
cin >> s >> l;
s--, l--;
int ans = get_len(s, l);
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename X>
ostream& operator<<(ostream& x, const vector<X>& v) {
for (long long i = 0; i < v.size(); ++i) x << v[i] << " ";
return x;
}
template <typename X>
ostream& operator<<(ostream& x, const set<X>& v) {
for (auto it : v) x << it << " ";
return x;
}
template <typename X, typename Y>
ostream& operator<<(ostream& x, const pair<X, Y>& v) {
x << v.ff << " " << v.ss;
return x;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const unordered_map<T, S>& v) {
for (auto it : v) os << it.first << "=>" << it.second << endl;
return os;
}
struct pair_hash {
inline std::size_t operator()(
const std::pair<long long, long long>& v) const {
return v.first * 31 + v.second;
}
};
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC targett("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
--x;
int adj[n + 2];
memset(adj, 0, sizeof adj);
for (long long i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
adj[a]++;
adj[b]++;
}
if (adj[x] == 1 || n == 1) {
cout << "Ayush" << endl;
continue;
}
n -= 2;
if (n % 2) {
cout << "Ashish" << endl;
} else {
cout << "Ayush" << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 5e3 + 10;
char s[SIZE];
int dp[SIZE];
bool good[128];
int lt[SIZE];
void track(int id, bool ending) {
if (id) track(lt[id], 0);
for (int i = (lt[id] + 1); i < (id + 1); ++i) printf("%c", s[i]);
putchar(ending ? '\n' : ' ');
}
int main() {
good['a'] = 1;
good['e'] = 1;
good['i'] = 1;
good['o'] = 1;
good['u'] = 1;
scanf("%s", (s + 1));
int n = strlen(s + 1);
memset((dp), -1, sizeof((dp)));
dp[0] = 0;
for (int i = (1); i < (n + 1); ++i) {
int cnt = 0;
set<char> dif;
for (int j = i; j > 0; j--) {
if (good[s[j]]) {
cnt = 0;
dif.clear();
} else {
dif.insert(s[j]);
cnt++;
}
if (cnt > 2 && ((int)(dif).size()) > 1) break;
if (dp[j - 1] != -1 && (dp[i] == -1 || dp[j - 1] + 1 < dp[i])) {
dp[i] = dp[j - 1] + 1;
lt[i] = j - 1;
}
}
}
track(n, 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 1e4 + 10, M = 5050 * 8, Z = 1e9 + 7, inf = 0x3f3f3f3f;
template <class T1, class T2>
inline void gadd(T1 &a, T2 b) {
a = (a + b) % Z;
}
int casenum, casei;
int n, m;
vector<int> a[N];
int ST, ED;
int first[N], ID;
struct Edge {
int w, cap, nxt;
} edge[M];
void ins(int x, int y, int cap_) {
edge[++ID] = {y, cap_, first[x]};
first[x] = ID;
edge[++ID] = {x, 0, first[y]};
first[y] = ID;
}
int d[N];
bool bfs() {
memset(d, -1, sizeof(d));
queue<int> q;
q.push(ST);
d[ST] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (int z = first[x]; z; z = edge[z].nxt)
if (edge[z].cap) {
int y = edge[z].w;
if (d[y] == -1) {
d[y] = d[x] + 1;
q.push(y);
if (y == ED) return 1;
}
}
}
return 0;
}
int dfs(int x, int all) {
if (x == ED) return all;
int use = 0;
for (int z = first[x]; z; z = edge[z].nxt)
if (edge[z].cap) {
int y = edge[z].w;
if (d[y] == d[x] + 1) {
int tmp = dfs(y, min(edge[z].cap, all - use));
edge[z].cap -= tmp;
edge[z ^ 1].cap += tmp;
use += tmp;
if (use == all) break;
}
}
if (use == 0) d[x] = -1;
return use;
}
int dinic() {
int ret = 0;
while (bfs()) ret += dfs(ST, inf);
return ret;
}
struct E {
int x, y;
} e[N];
bool check(int top) {
memset(first, 0, sizeof(first));
ID = 1;
for (int i = 1; i <= m; ++i) {
int x = e[i].x, y = e[i].y;
ins(ST, i, 1);
ins(i, x + m, 1);
ins(i, y + m, 1);
}
for (int i = 1; i <= n; ++i) {
ins(i + m, ED, top);
}
return dinic() == m;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
ST = 0;
ED = n + m + 1;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &e[i].x, &e[i].y);
}
int l = m / n + (m % n > 0);
int r = m;
int ans;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
check(ans);
printf("%d\n", ans);
for (int i = 1, j = 4; i <= m; ++i, j += 6) {
if (!edge[j].cap) {
printf("%d %d\n", e[i].x, e[i].y);
} else {
printf("%d %d\n", e[i].y, e[i].x);
}
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long double PI = 4 * atan((long double)1);
const long long MOD = 1000000007;
long long nCr(long long n, long long k) {
long long res = 1;
if (k > n - k) k = n - k;
for (long long i = 0; i < k; i++) res *= (n - i), res /= (i + 1);
return res;
}
long long expo(long long a, long long b, long long M = MOD) {
long long res = 1;
while (b) {
if (b % 2 == 1) res = res * a % M;
b = b / 2;
a = a * a % M;
}
return (res + M) % M;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
cin >> t;
while (t--) {
long long a, b, c;
cin >> a >> b >> c;
long long x = min(a, b);
long long y = max(a, b);
long long n = 2 * (y - x);
if (a > n || b > n || c > n)
cout << -1 << endl;
else {
if (c + n / 2 > n)
cout << (c - n / 2) << endl;
else
cout << (c + n / 2) << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long wllabs(long long x) {
if (x < 0)
return -x;
else
return x;
}
bool can(long long x1, long long y1, long long x2, long long y2, long long x0,
long long y0) {
long long A = x2 - x0;
long long B = y2 - y0;
if (A == 0 && B == 0) return true;
long long det = (x1) * (x1) + (y1) * (y1);
if (det == 0) {
return false;
}
long long al = A * x1 + B * y1;
long long be = A * y1 - B * x1;
if (wllabs(al) % det == 0 && wllabs(be) % det == 0) {
return true;
} else {
return false;
}
}
int main() {
long long x1, y1, x2, y2, x0, y0;
cin >> x0 >> y0;
cin >> x2 >> y2;
cin >> x1 >> y1;
bool f1, f2, f3, f4;
f1 = can(x1, y1, x2, y2, x0, y0);
f2 = can(x1, y1, x2, y2, -x0, -y0);
f3 = can(x1, y1, x2, y2, y0, -x0);
f4 = can(x1, y1, x2, y2, -y0, x0);
if (f1 || f2 || f3 || f4)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::placeholders;
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int ntest;
cin >> ntest;
while (ntest--) {
long long h, n;
cin >> h >> n;
vector<int> a(n);
for (int i = -1; ++i < n;) cin >> a[i];
vector<int> dp(n, INT_MAX);
dp[0] = 0;
for (int i = 0; i++ < n - 1;) {
bool is_next_to = a[i - 1] - 1 == a[i];
dp[i] = min(dp[i], dp[i - 1] + 1);
if (i > 1 and is_next_to) dp[i] = min(dp[i], dp[i - 2]);
}
int ans = dp.back();
if (a.back() == 1 and h > 1) {
ans = min(dp[n - 2], ans);
}
cout << ans << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char ch[101][101];
bool del[101][101];
int n, m;
void check(int i, int j, char le) {
for (int x = j + 1; x < m; x++) {
if (ch[i][x] == le) {
del[i][j] = 0;
del[i][x] = 0;
}
}
for (int x = i + 1; x < n; x++) {
if (ch[x][j] == le) {
del[i][j] = 0;
del[x][j] = 0;
}
}
}
int main() {
memset(del, 1, sizeof del);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> ch[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
check(i, j, ch[i][j]);
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (del[i][j]) cout << ch[i][j];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int d[1000];
int s[1000];
int best[1000];
int main(void) {
int m, k;
cin >> m >> k;
int ans = 0;
for (int i = 0; i < m; i++) {
cin >> d[i];
ans += d[i];
}
for (int i = 0; i < m; i++) cin >> s[i];
best[0] = s[0];
for (int i = 1; i < m; i++) best[i] = max(best[i - 1], s[i]);
int fuel = 0;
for (int i = 0; i < m; i++) {
fuel += s[i];
if (fuel >= d[i])
fuel -= d[i];
else {
while (fuel < d[i]) {
fuel += best[i];
ans += k;
}
fuel -= d[i];
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 201000;
vector<int> v[MAX_N], w[MAX_N], city;
int dp[MAX_N];
void dfs1(int x, int fa) {
int i;
for (i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == fa) continue;
dfs1(y, x);
dp[x] += dp[y];
if (w[x][i] == 0) dp[x]++;
}
}
int ans = 0x3f3f3f3f;
void dfs2(int x, int fa, int val, int tol) {
int i;
int sum = val + tol + dp[x];
if (ans > sum) {
ans = sum;
city.clear();
city.push_back(x);
} else if (ans == sum)
city.push_back(x);
for (i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == fa) continue;
int t = dp[x] - dp[y];
if (w[x][i] == 1)
dfs2(y, x, val + tol + 1, t);
else
dfs2(y, x, val + tol, t - 1);
}
}
int main(void) {
int n, i, x, y;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
w[x].push_back(1);
v[y].push_back(x);
w[y].push_back(0);
}
dfs1(1, 0);
dfs2(1, 0, 0, 0);
cout << ans << "\n";
sort(city.begin(), city.end());
for (i = 0; i < city.size(); i++) {
if (i != 0) printf(" ");
printf("%d", city[i]);
}
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline void using_file(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
mt19937 gen_rand;
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &a) {
os << "(";
os << a.first << ", ";
os << a.second;
os << ")";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &a) {
os << "{";
bool was = false;
for (auto &x : a) {
if (was) {
os << ", ";
}
was = true;
os << x;
}
os << "}";
return os;
}
template <typename T>
inline void debug(const char *sdbg, T x) {
cerr << "The value of " << sdbg << " is " << x << "\n";
};
template <typename T, typename... U>
inline void debug(const char *sdbg, T h, U... t) {
cerr << "The value of ";
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << " is " << h << "\n";
debug(sdbg + 1, t...);
cerr << "\n";
}
template <typename T>
T abs(T x) {
if (x < 0) {
return -x;
} else {
return x;
}
}
template <typename T>
T sqr(T x) {
return x * x;
};
const long long INF_FOR_SHORT_TIME = (long long)(1e9);
template <typename T>
T mul(T a, T b, T m) {
if (a <= INF_FOR_SHORT_TIME && b <= INF_FOR_SHORT_TIME) {
return (a * b) % m;
}
T q = (long long)((long double)a * (long double)b / (long double)m);
T r = a * b - q * m;
return (r + 5 * m) % m;
}
template <typename T, typename U>
T binpow(T a, U n, T MOD) {
T res = 1;
while (n) {
if (n & 1) {
res = mul(res, a, MOD);
}
a = mul(a, a, MOD);
n >>= 1;
}
return res;
};
template <typename T>
int sign(T x) {
if (x < 0) {
return -1;
} else if (x > 0) {
return 1;
} else {
return 0;
}
};
template <typename T>
T gcd(T a, T b) {
if (a > b) {
swap(a, b);
}
while (a) {
b %= a;
swap(a, b);
}
return b;
};
template <typename T>
bool uin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
};
template <typename T>
bool uax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
};
int main() {
gen_rand.seed(time(0));
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
if (n == 1 && m == 1) {
cout << "0\n";
return 0;
}
if (n == 1 || m == 1) {
int cnt = 2;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << cnt++ << " ";
}
cout << "\n";
}
return 0;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << (i + 1) * (n + 1 + j) << " ";
}
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int casos;
scanf("%d", &casos);
int notas[casos];
int posicao[casos];
int aux[casos];
for (int i = 0; i < casos; i++) {
scanf("%d", ¬as[i]);
posicao[i] = notas[i];
}
sort(posicao, posicao + casos);
int n = 1;
for (int i = 0; i < casos; i++) {
aux[casos - 1 - i] = n;
if (posicao[casos - 1 - i] != posicao[casos - 2 - i]) {
n = i + 2;
}
}
for (int i = 0; i < casos; i++) {
for (int j = 0; j < casos; j++) {
if (notas[i] == posicao[j]) {
if ((i + 1) == casos) {
printf("%d\n", aux[j]);
} else {
printf("%d ", aux[j]);
}
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = int(1e6 + 5);
long double f[MAXN];
int n, m, k;
long double C(int n, int m) { return f[n] - f[m] - f[n - m]; }
int main() {
f[0] = 0;
for (int i = 1; i <= MAXN - 4; i++) f[i] = f[i - 1] + log(1.0 * i);
scanf("%d%d%d", &n, &m, &k);
long double ans = 0;
for (int x = 0; x <= n; x++)
for (int y = 0; y <= n; y++)
if (n * (x + y) - x * y <= k) {
int z = n * (x + y) - x * y;
long double tmp = C(n, x) + C(n, y) + C(m - z, k - z) - C(m, k);
ans = min((long double)1e99, ans + exp(tmp));
}
printf("%.10f\n", (double)ans);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAXBUF = 1 << 23;
char B[MAXBUF], *Si = B, *Ti = B;
inline char getc() {
if (Si == Ti) Ti = (Si = B) + fread(B, 1, MAXBUF, stdin);
if (Si == Ti)
return 0;
else
return *Si++;
}
template <class T>
inline void read(T &a) {
static char c;
static int fh;
while (((c = getc()) < '0' || c > '9') && c != '-')
;
if (c == '-')
fh = -1, a = 0;
else
fh = 1, a = c - '0';
while ((c = getc()) <= '9' && c >= '0') a = (a << 3) + (a << 1) + c - '0';
if (fh == -1) a = -a;
}
char Buff[MAXBUF], *sti = Buff;
template <class T>
inline void write(T a) {
if (a == 0) {
*sti++ = '0';
return;
}
if (a < 0) *sti++ = '-', a = -a;
static char c[20];
static int c0;
c0 = 0;
while (a) c[c0++] = a % 10 + '0', a /= 10;
while (c0--) *sti++ = c[c0];
}
int dep[300005], n;
int fa[300005][19];
int p1[300005], c1 = 0;
int p2[300005], c2 = 0;
inline int lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
int del = dep[a] - dep[b], i;
for (i = 0; (1 << i) <= del; i++) {
if (del & (1 << i)) a = fa[a][i];
}
if (a == b) return a;
for (i = 18; i >= 0; i--) {
if (fa[a][i] ^ fa[b][i]) {
a = fa[a][i];
b = fa[b][i];
}
}
return fa[a][0];
}
inline int get(int a, int b) { return dep[a] + dep[b] - 2 * dep[lca(a, b)]; }
int main() {
int i, j, mx = 0, pos;
read(n);
p1[++c1] = 1;
for (i = 2; i <= n + 1; i++) {
read(pos);
fa[i][0] = pos;
dep[i] = dep[pos] + 1;
for (j = 1; (1 << j) <= dep[i]; j++) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
int d1 = (c1 == 0 ? 0 : get(p1[1], i));
int d2 = (c2 == 0 ? 0 : get(p2[1], i));
if (d1 > mx) {
for (j = 1; j <= c2; j++) {
if (get(p2[j], i) == d1) {
p1[++c1] = p2[j];
}
}
c2 = 1;
p2[1] = i;
} else if (d2 > mx) {
for (j = 1; j <= c1; j++) {
if (get(p1[j], i) == d2) {
p2[++c2] = p1[j];
}
}
c1 = 1;
p1[1] = i;
} else if (d1 == mx)
p2[++c2] = i;
else if (d2 == mx)
p1[++c1] = i;
mx = max(mx, max(d1, d2));
write(c1 + c2);
*sti++ = '\n';
}
fwrite(Buff, 1, sti - Buff, stdout);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 500005;
const long long MD = 1000000007;
int mul(int a, int b) { return ((long long)a * (long long)b) % MD; }
int pow(int a, int b) {
int ans = 1;
while (b > 0) {
if (b % 2 == 1) {
ans = mul(ans, a);
}
a = mul(a, a);
b /= 2;
}
return ans;
}
long long c[MX];
map<long long, int> M;
int nxt = 0;
set<int> S[MX];
vector<pair<int, int>> SS[MX];
void add(long long &a, long long b) { a = (a + b) % MD; }
int dsu[MX];
int find(int i) {
if (i == dsu[i]) return i;
return dsu[i] = find(dsu[i]);
}
int merge(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return 0;
dsu[u] = v;
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
long long x = c[u] ^ c[v];
if (M[x] == 0) {
M[x] = ++nxt;
}
S[M[x]].insert(u);
S[M[x]].insert(v);
SS[M[x]].emplace_back(u, v);
}
for (int i = 1; i <= n; i++) dsu[i] = i;
long long ans = 0;
for (int i = 1; i <= nxt; i++) {
int comps = n;
for (auto p : SS[i]) {
comps -= merge(p.first, p.second);
}
add(ans, pow(2, comps));
for (int v : S[i]) {
dsu[v] = v;
}
}
int tmp = pow(2, n);
int tmp2 = pow(2, k);
tmp2 -= nxt;
if (tmp2 < 0) tmp2 += MD;
add(ans, mul(tmp, tmp2));
cout << ans;
}
| 14 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int i,j,k,sb[100500],md,n;
void get(int k){
if(k==0||k>n){return;}
printf("? %d\n",k);fflush(stdout);scanf("%d",&sb[k]);
}
bool chk(int k){return (sb[k]<sb[k-1]&&sb[k]<sb[k+1]);}
void ask(int l,int r){
if(l>r){return;}
md=(l+r)>>1;
get(md-1);get(md);
if(chk(md)){printf("! %d\n",md);exit(0);}
if(chk(md-1)){printf("! %d\n",md-1);exit(0);}
if(sb[md-1]<sb[md]){r=md-1;}
else{l=md+1;}
ask(l,r);
}
int main(){
scanf("%d",&n);
sb[0]=sb[n+1]=1145141919;
ask(1,n);
} | 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, a[N], l[N], r[N];
int main(void) {
int i, j;
while (~scanf("%d", &n)) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
int maxx = 0, temp = 0, cnt = 0, ok = 0;
for (i = 2; i <= n; i++) {
if (a[i] != a[i - 1]) {
if (!ok) {
l[cnt] = i - 1;
ok = 1;
}
temp++;
} else {
if (ok) {
r[cnt++] = i - 1;
maxx = max(maxx, temp + 1);
temp = 0;
ok = 0;
}
}
}
if (ok) {
maxx = max(maxx, temp + 1);
r[cnt++] = n;
}
printf("%d\n", (maxx - 1) / 2);
for (i = 0; i < cnt; i++) {
int low = l[i], up = r[i];
int len = up - low + 1;
if (len % 2) {
for (j = low + 1; j < up; j++) a[j] = a[low];
} else {
int mid = low + up >> 1;
for (j = low; j <= mid; j++) a[j] = a[low];
for (j = mid + 1; j <= up; j++) a[j] = a[up];
}
}
for (i = 1; i <= n; i++) printf("%d%c", a[i], " \n"[i == n]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[(int)1e5 + 5], n, q, d[320][(int)1e5 + 5], p, k;
int K = 320;
int go(int k, int v) {
if (v > n) return 0;
return go(k, v + k + a[v]) + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < K; i++) {
for (int j = n; j >= 1; j--)
if (j + a[j] + i <= n)
d[i][j] = d[i][j + a[j] + i] + 1;
else
d[i][j] = 1;
}
cin >> q;
while (q--) {
cin >> p >> k;
if (k >= K)
cout << go(k, p);
else
cout << d[k][p];
cout << "\n";
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long p = 1e9 + 7;
long long inv(long long a) {
return a == 1 ? 1 : (long long)(p - p / a) * inv(p % a) % p;
}
long long C(long long n, long long m) {
if (m < 0) return 0;
if (n < m) return 0;
if (m > n - m) m = n - m;
long long up = 1, down = 1;
for (long long i = 0; i < m; i++) {
up = up * (n - i) % p;
down = down * (i + 1) % p;
}
return up * inv(down) % p;
}
long long A(long long n, long long m) {
long long ans = 1;
for (long long i = n; i >= n - m + 1; i--) {
ans = (ans * i) % p;
}
return ans;
}
int main() {
long long n, x, pos;
cin >> n >> x >> pos;
long long l = 0, r = n;
long long less = 0, big = 0;
while (l < r) {
int mid = (l + r) >> 1;
if (mid > pos) {
r = mid;
big++;
} else {
l = mid + 1;
if (mid < pos) {
less++;
}
}
}
long long b = C(n - x, big) * A(big, big) % p;
long long s = C(x - 1, less) * A(less, less) % p;
cout << b * s % p * A(n - 1 - less - big, n - 1 - less - big) % p << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct dsu {
vector<int> P, rank;
dsu(int n) : P(n), rank(n) {
for (int i = 0; i < n; i++) {
P[i] = i;
rank[i] = 0;
}
}
int fnd(int i) {
if (i != P[i]) P[i] = fnd(P[i]);
return P[i];
}
void join(int x, int y) {
int PX = fnd(x);
int PY = fnd(y);
if (rank[PX] > rank[PY])
P[PY] = PX;
else
P[PX] = PY;
if (rank[PX] == rank[PY]) rank[PY] = rank[PX] + 1;
}
};
int col[200010];
bool vis[200010];
vector<int> adj[200010];
set<int> ff[200010];
int dis[200010], dis2[100010];
int mx = 0, ind;
void dfs(int i, int par, int dep) {
dis[i] = dep;
if (dep >= mx) ind = i, mx = dep;
for (auto j : ff[i]) {
if (j == par or j == i) continue;
dfs(j, i, dep + 1);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &col[i]);
dsu d(n + 2);
for (int i = 1, x, y; i < n; ++i) {
scanf("%d", &x);
scanf("%d", &y);
adj[x].push_back(y);
adj[y].push_back(x);
if (col[x] == col[y]) d.join(x, y);
}
for (int i = 1; i <= n; ++i) {
int tp = d.fnd(i);
for (auto j : adj[i]) {
ff[tp].insert(d.fnd(j));
}
}
int far;
dfs(d.fnd(1), 0, 0);
mx = 0;
dfs(ind, 0, 0);
cout << (mx + 1) / 2 << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long mod;
int N, M, ONE, TWO;
char inp[505][505];
int col[505], row[505];
int sum[505];
int rev[1010];
bool vis[505][505];
long long DP[505][505];
long long F(int pos, int one, int two) {
if (pos == N) return 1;
if (col[pos] == 0) return F(pos + 1, one, two);
if (vis[one][two]) return DP[one][two];
vis[one][two] = true;
long long ret = 0LL, tmp1 = 0LL, tmp2 = 0LL, tmp3 = 0LL;
if (col[pos] == 1) {
if (one > 0) tmp1 = F(pos + 1, one - 1, two);
if (two > 0) tmp2 = F(pos + 1, one + 1, two - 1);
ret = ((tmp1 * one) % mod + (tmp2 * two) % mod) % mod;
return DP[one][two] = ret;
}
if (col[pos] == 2) {
if (one > 0 && two > 0) {
tmp1 = F(pos + 1, one, two - 1);
tmp1 = (((one * two) % mod) * tmp1) % mod;
}
if (one > 1) {
tmp2 = F(pos + 1, one - 2, two);
tmp2 = ((((one * (one - 1)) / 2) % mod) * tmp2) % mod;
}
if (two > 1) {
tmp3 = F(pos + 1, one + 2, two - 2);
tmp3 = ((((two * (two - 1)) / 2) % mod) * tmp3) % mod;
}
ret = (((tmp1 + tmp2) % mod) + tmp3) % mod;
return DP[one][two] = ret;
}
}
int main() {
int i, j, k;
scanf("%d%d", &N, &M);
cin >> mod;
for (i = 0; i < M; i++) scanf("%s", inp[i]);
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (i = 0; i < M; i++) {
for (j = 0; j < N; j++) row[i] += (inp[i][j] - '0');
}
for (i = 0; i < N; i++) {
for (j = 0; j < M; j++) col[i] += (inp[j][i] - '0');
}
for (i = 0; i < N; i++) row[i] = 2 - row[i];
for (i = 0; i < N; i++) col[i] = 2 - col[i];
ONE = TWO = 0;
for (i = M; i < N; i++) {
if (row[i] == 1) ONE++;
if (row[i] == 2) TWO++;
}
memset(vis, 0, sizeof(vis));
long long ans = F(0, ONE, TWO);
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
using _ii = pair<int, int>;
const int N = 107;
int t, n, k;
i64 dp_in[N][N], dp_out[N][N], C[N][N], f[N][N], ans, mod = 1e9 + 7;
vector<vector<int>> a;
void Pre() {
for (int n = 0; n <= 100; n++) {
for (int k = 0; k <= n; k++) {
if (k == n) {
C[k][n] = 1;
continue;
}
if (k == 0) {
C[k][n] = 1;
continue;
}
if (k == 1) {
C[k][n] = n;
continue;
}
C[k][n] = (C[k - 1][n - 1] + C[k][n - 1]) % mod;
}
}
}
void Test(int h, int le, vector<int> &a) {
cerr << '\n' << "Node " << h << " distance " << le << '\n';
for (auto &i : a) cerr << i << ' ';
}
void DFS(int h, int legacy) {
for (auto &i : a[h]) {
if (i == legacy) continue;
DFS(i, h);
for (int j = 1; j <= n; j++)
dp_in[h][j] = (dp_in[h][j] + dp_in[i][j - 1]) % mod;
}
++dp_in[h][0];
}
void Cal(vector<int> &a, int cnt) {
int m = a.size();
vector<i64> f(cnt + 1);
f[0] = 1;
for (auto &i : a) {
for (int j = cnt; j >= 1; j--) {
f[j] += f[j - 1] * i;
f[j] %= mod;
}
}
i64 temp = f[cnt];
ans = (ans + temp) % mod;
}
void Run(int h, int legacy) {
for (int j = 1; j <= n; j++) {
vector<int> d;
d.push_back(dp_out[h][j]);
for (auto &i : a[h]) {
if (i == legacy) continue;
d.push_back(dp_in[i][j - 1]);
}
Cal(d, k);
}
for (auto &i : a[h]) {
if (i == legacy) continue;
for (int j = 1; j <= n; j++) {
int temp = dp_in[h][j - 1] - (j - 2 >= 0 ? dp_in[i][j - 2] : 0);
dp_out[i][j] = temp + dp_out[h][j - 1];
}
Run(i, h);
}
}
void Test() {
for (int i = 1; i <= n; i++) {
cerr << '\n' << "Node " << i << '\n';
for (int j = 0; j <= n; j++)
cerr << j << ' ' << dp_in[i][j] << ' ' << dp_out[i][j] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> k;
a.resize(n + 1);
for (auto &i : a) i.clear();
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
ans = 0;
memset(dp_in, 0, sizeof(dp_in));
memset(dp_out, 0, sizeof(dp_out));
Pre();
DFS(1, 0);
Run(1, 0);
if (k == 2) ans = (n * (n - 1) / 2) % mod;
cout << ans << '\n';
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
short int i = 0, s = 0, n, x;
cin >> n >> x;
x--;
short int t[n];
for (i = 0; i < n; i++) cin >> t[i];
if (t[x] == 1) s++;
i = 1;
short int plu = 0, minu = 0;
while (x + i < n || x - i >= 0) {
short int c = 0;
plu = 0;
minu = 0;
if (x + i < n) {
c += t[x + i];
plu = 1;
}
if (x - i >= 0) {
c += t[x - i];
minu = 1;
}
i++;
if (plu == 1 && minu == 1 && c == 2)
s += c;
else if ((minu == 0 || plu == 0) && c == 1)
s++;
}
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool b[55][55];
bool vi[55][55];
queue<pair<int, int> > q;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
b[1][1] = 1;
b[n][n] = 0;
vi[1][1] = vi[n][n] = 1;
q.push({1, 1});
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
if (x < n && y < n && !vi[x + 1][y + 1]) {
cout << "? " << x << ' ' << y << ' ' << x + 1 << ' ' << y + 1 << endl;
bool p;
cin >> p;
b[x + 1][y + 1] = b[x][y] ^ (!p);
vi[x + 1][y + 1] = 1;
q.push({x + 1, y + 1});
}
if (x + 1 < n && !vi[x + 2][y]) {
cout << "? " << x << ' ' << y << ' ' << x + 2 << ' ' << y << endl;
bool p;
cin >> p;
b[x + 2][y] = b[x][y] ^ (!p);
vi[x + 2][y] = 1;
q.push({x + 2, y});
}
if (y + 1 < n && !vi[x][y + 2]) {
cout << "? " << x << ' ' << y << ' ' << x << ' ' << y + 2 << endl;
bool p;
cin >> p;
b[x][y + 2] = b[x][y] ^ (!p);
vi[x][y + 2] = 1;
q.push({x, y + 2});
}
}
for (int i = 2; i < n; i++) {
if (b[i - 1][i - 1] != b[i + 1][i + 1]) {
cout << "? " << i - 1 << ' ' << i << ' ' << i << ' ' << i + 1 << endl;
bool p;
cin >> p;
if (p) {
if (b[i - 1][i - 1] == b[i][i]) {
cout << "? " << i - 1 << ' ' << i - 1 << ' ' << i << ' ' << i + 1
<< endl;
bool p;
cin >> p;
b[i - 1][i] = b[i][i] ^ (!p);
b[i][i + 1] = b[i][i] ^ (!p);
} else {
cout << "? " << i - 1 << ' ' << i << ' ' << i + 1 << ' ' << i + 1
<< endl;
bool p;
cin >> p;
b[i - 1][i] = b[i][i] ^ (!p);
b[i][i + 1] = b[i][i] ^ (!p);
}
} else {
if (b[i - 1][i - 1] != b[i][i]) {
cout << "? " << i - 1 << ' ' << i - 1 << ' ' << i << ' ' << i + 1
<< endl;
bool p;
cin >> p;
b[i - 1][i] = b[i][i] ^ (!p);
b[i][i + 1] = b[i - 1][i - 1] ^ (!p);
} else {
cout << "? " << i - 1 << ' ' << i << ' ' << i + 1 << ' ' << i + 1
<< endl;
bool p;
cin >> p;
b[i - 1][i] = b[i + 1][i + 1] ^ (!p);
b[i][i + 1] = b[i][i] ^ (!p);
}
}
vi[i - 1][i] = 1;
vi[i][i + 1] = 1;
q.push({i - 1, i});
q.push({i, i + 1});
break;
}
}
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
if (x < n && y < n && !vi[x + 1][y + 1]) {
cout << "? " << x << ' ' << y << ' ' << x + 1 << ' ' << y + 1 << endl;
bool p;
cin >> p;
b[x + 1][y + 1] = b[x][y] ^ (!p);
vi[x + 1][y + 1] = 1;
q.push({x + 1, y + 1});
}
if (x > 1 && y > 1 && !vi[x - 1][y - 1]) {
cout << "? " << x - 1 << ' ' << y - 1 << ' ' << x << ' ' << y << endl;
bool p;
cin >> p;
b[x - 1][y - 1] = b[x][y] ^ (!p);
vi[x - 1][y - 1] = 1;
q.push({x - 1, y - 1});
}
if (x + 1 < n && !vi[x + 2][y]) {
cout << "? " << x << ' ' << y << ' ' << x + 2 << ' ' << y << endl;
bool p;
cin >> p;
b[x + 2][y] = b[x][y] ^ (!p);
vi[x + 2][y] = 1;
q.push({x + 2, y});
}
if (y + 1 < n && !vi[x][y + 2]) {
cout << "? " << x << ' ' << y << ' ' << x << ' ' << y + 2 << endl;
bool p;
cin >> p;
b[x][y + 2] = b[x][y] ^ (!p);
vi[x][y + 2] = 1;
q.push({x, y + 2});
}
if (y > 2 && !vi[x][y - 2]) {
cout << "? " << x << ' ' << y - 2 << ' ' << x << ' ' << y << endl;
bool p;
cin >> p;
b[x][y - 2] = b[x][y] ^ (!p);
vi[x][y - 2] = 1;
q.push({x, y - 2});
}
}
cout << "!\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << b[i][j];
}
cout << endl;
}
}
| 16 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
std::pair<int, int> DR[] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {-1, -1}, {1, 1}, {1, -1}};
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
~debug() { cerr << endl; }
template <class c>
typename enable_if<sizeof dud<c>(0) != 1, debug&>::type operator<<(c i) {
cerr << boolalpha << i;
return *this;
}
template <class c>
typename enable_if<sizeof dud<c>(0) == 1, debug&>::type operator<<(c i) {
return *this << range(begin(i), end(i));
}
template <class c, class b>
debug& operator<<(pair<b, c> d) {
return *this << "(" << d.first << ", " << d.second << ")";
}
template <class c>
debug& operator<<(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it;
return *this << "]";
}
};
long long gcd(long long a, long long b) {
if (b) return gcd(b, a % b);
return a;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long n;
long long x[1 << 10], y[1 << 10];
pair<long long, long long> f(long long a, long long b) {
long long aa = abs(a);
long long bb = abs(b);
long long g = gcd(aa, bb);
aa /= g;
bb /= g;
if (a) a = aa * (a / abs(a));
b = bb * (b / abs(b));
if (a < 0 && b < 0) {
a = -a;
b = -b;
} else if (a < 0 && b > 0) {
a = -a;
b = -b;
}
if (a == 0) b = 1;
return make_pair(a, b);
}
map<pair<long long, long long>, long long> m;
map<long long, long long> M;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n;
set<long long> st;
for (long long i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
M[x[i]]++;
}
long long num = 0;
for (auto it : M)
if (it.second > 1) num++;
long long ska = num;
set<pair<pair<long long, long long>, pair<long long, long long>>> lines;
for (long long i = 1; i <= n; i++) {
for (long long j = i + 1; j <= n; j++) {
if (x[i] != x[j]) {
pair<long long, long long> k = f(y[j] - y[i], x[j] - x[i]);
pair<long long, long long> z =
f(y[i] * k.second - x[i] * k.first, k.second);
lines.insert(make_pair(k, z));
}
}
}
num += (long long)((lines).size());
num = num * (num - 1);
num /= 2;
for (auto it : lines) {
m[it.first]++;
}
for (auto it : m) {
num -= (it.second * (it.second - 1)) / 2;
}
num -= (ska * (ska - 1)) / 2;
return cout << num, 0;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 1;
int n, q, ar[N], bs, fen[N], ans[N];
vector<pair<int, int> > qry[N];
void update(int x, int v = -1) {
for (; x <= n + 1; x += x & -x) fen[x] += v;
}
int query(int x) {
int res = 0;
for (; x; x -= x & -x) res += fen[x];
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> ar[i], ar[i] -= i;
for (int i = 1; i <= q; i++) {
int l, r;
cin >> l >> r;
qry[n - r].push_back(make_pair(i, l + 1));
}
for (int i = 1; i <= n; i++) {
if (ar[i] <= 0 and bs + query(1) >= -ar[i]) {
int lo = 1, hi = i + 1;
while (lo < hi - 1) {
int mid = lo + hi >> 1;
if (bs + query(mid) >= -ar[i])
lo = mid;
else
hi = mid;
}
bs++;
update(hi);
}
for (auto [id, l] : qry[i]) ans[id] = bs + query(l);
}
for (int i = 1; i <= q; i++) cout << ans[i] << '\n';
}
| 15 |
#include <bits/stdc++.h>
int n, m, x, y, l, ans, now, d[600005], son[600005], ed[600005], next[600005],
b[600005];
void add(int x, int y) { ed[++l] = y, next[l] = son[x], son[x] = l; }
bool dfs(int x, int last) {
b[x] = 1;
for (int p = son[x]; p; p = next[p]) {
int y = ed[p];
if (y == last) continue;
if (y == now) return 1;
if (d[y] > 2 || b[y]) continue;
if (dfs(y, x)) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
scanf("%d%d", &x, &y), d[x]++, d[y]++, add(x, y), add(y, x);
for (int i = 1; i <= n; i++) ans += d[i] & 1;
ans++;
ans /= 2;
for (int i = 1; i <= n; i++)
if (d[i] > 2 && !b[i]) now = i, ans += dfs(i, 0);
if (!ans && m) ans++;
printf("%d %d\n", ans, m);
return 0;
}
| 19 |
#include <bits/stdc++.h>
void sort(int a[], int n) {
int i, j, m;
while (n--) {
for (i = 0; i < n; i++) {
j = i + 1;
if (a[j] < a[i]) {
m = a[j];
a[j] = a[i];
a[i] = m;
}
}
}
}
int main() {
int n, c = 0, a[150], i;
double s = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
s += a[i];
}
if (s / n > 4.49)
printf("0\n");
else {
sort(a, n);
for (i = 0; i < n; i++) {
if (a[i] < 5.00) {
s += 5.00 - a[i];
if (s / n < 4.49)
c++;
else if (s / n >= 4.49 && s / n < 4.5)
c++;
else if (s / n >= 4.5) {
c++;
printf("%d\n", c);
return 0;
}
}
}
if (s / n > 4.49) printf("%d\n", c);
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx")
using namespace std;
template <typename T>
void uin(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
void uax(T &a, T b) {
if (b > a) a = b;
}
const long long LG = 31;
long long d, m;
long long mod(long long x) {
x %= m;
if (x < 0) x += m;
return x;
}
long long dp[100][100];
void solve() {
cin >> d >> m;
for (long long i = 0; i < 100; ++i) {
for (long long j = 0; j < 100; ++j) {
dp[i][j] = 0;
}
}
long long sb = 0;
for (long long i = LG; i >= 0; --i) {
if ((d >> i) & 1) {
sb = i;
break;
}
}
long long ans = 0;
for (long long i = 0; i < sb; ++i) {
dp[1][i] = (1LL << i);
}
dp[1][sb] = d - (1LL << sb) + 1;
for (long long i = 1; i < LG; ++i) {
for (long long last = 0; last < sb; ++last) {
if (dp[i][last] == 0) continue;
for (long long bit = last + 1; bit <= sb; ++bit) {
if (bit < sb) {
dp[i + 1][bit] = mod(dp[i + 1][bit] + dp[i][last] * (1LL << bit));
} else if (bit == sb) {
dp[i + 1][bit] =
mod(dp[i + 1][bit] + dp[i][last] * (d - (1LL << sb) + 1));
}
}
}
}
for (long long i = 1; i <= LG; ++i) {
for (long long j = 0; j <= sb; ++j) {
ans = mod(ans + dp[i][j]);
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > v;
bool f(pair<long long, long long> a, pair<long long, long long> b) {
return (a.first > b.first) || (a.first == b.first && a.second < b.second);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
long long k;
long long s;
long long sum = 0;
for (long long i = 0; i < n; i++) {
sum = 0;
for (long long j = 0; j < 4; j++) {
cin >> k;
sum += k;
}
if (i == 0) {
s = sum;
}
v.push_back({sum, i});
}
sort(v.begin(), v.end(), f);
for (long long i = 0; i < n; i++) {
if (v[i].second == 0) {
cout << i + 1;
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long x, y, n;
cin >> x >> y >> n;
long long per = n / x;
while (1) {
if (per * x + y <= n) {
cout << per * x + y << '\n';
break;
} else
per--;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int modexp(long long int a, long long int n) {
long long int r = 1;
while (n) {
if (n & 1) r = (r * a) % 1000000007;
a = (a * a) % 1000000007;
n >>= 1;
}
return r;
}
bool cmpfunc(const pair<int, int> &u, const pair<int, int> &v) {
if (u.first < v.first) return true;
return false;
}
bool compare(pair<long long int, long long int> p,
pair<long long int, long long int> q) {
if (p.first < q.first)
return true;
else if (p.first == q.first) {
if (p.second < q.second) return true;
return false;
}
return false;
}
void solve() {
long long int h, w;
cin >> h >> w;
long long int ans_h = 0, ans_W = 0;
for (int i = 0; i < 31; i++) {
long long int h1 = (1ll << i);
long long int w1 = min(h1 * 1.25, w + 0.0);
if (h1 * 1.0 / w1 > 1.25 + 0.001 || h1 * 1.0 / w1 < 0.8 - 0.001) continue;
if (h1 > h || w1 > w) continue;
if (h1 * w1 > ans_h * ans_W || (h1 * w1 == ans_h * ans_W && h1 > ans_h))
ans_h = h1, ans_W = w1;
}
for (int i = 0; i < 31; i++) {
long long int w1 = (1 << i);
long long int h1 = min(w1 * 1.25, h + 0.0);
if (h1 * 1.0 / w1 > 1.25 + 0.001 || h1 * 1.0 / w1 < 0.8 - 0.001) continue;
if (w1 > w || h1 > h) continue;
if (h1 * w1 > ans_h * ans_W || (h1 * w1 == ans_h * ans_W && h1 > ans_h))
ans_h = h1, ans_W = w1;
}
cout << ans_h << ' ' << ans_W;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long N = 500005;
long long MAX = 9223372036854775807;
long long MOD = 1000000007;
long long nbr;
bool visited[200005];
vector<long long> mp[200005];
vector<long long> dist;
vector<long long> UI(2 * 1e5 + 5, 0);
void dfs(long long s) {
visited[s] = true;
nbr++;
dist[s]++;
for (int i = 0; i < mp[s].size(); i++) {
if (visited[mp[s][i]] == false) {
dist[mp[s][i]] = dist[s];
dfs(mp[s][i]);
UI[s] += UI[mp[s][i]] + 1;
}
}
}
bool sorti(pair<long long, long long> a, pair<long long, long long> b) {
return a.second > b.second;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
string ch;
cin >> ch;
string res = "";
for (int i = 0; i < n; i++) res += 'a';
long long l = n / 2;
long long s = n / 2 - 1;
long long j = n / 2 + 1;
if (n % 2 == 1) {
res[l] = ch[0];
for (int i = 1; i < ch.size(); i++) {
if (i % 2 == 1) {
if (s != -1) res[s] = ch[i];
s--;
}
if (i % 2 == 0) {
if (j != n) res[j] = ch[i];
j++;
}
}
cout << res;
}
if (n % 2 == 0) {
res[l - 1] = ch[0];
s--;
j--;
for (int i = 1; i < ch.size(); i++) {
if (i == ch.size() - 1) {
res[i] = ch[i];
continue;
}
if (i % 2 == 1) {
if (j != n) res[j] = ch[i];
j++;
}
if (i % 2 == 0) {
if (s != -1) res[s] = ch[i];
s--;
}
}
cout << res;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string str;
vector<int> cnt(26, 0);
int main() {
cin >> str;
for (int i = 0; i < str.size(); i++) cnt[str[i] - 'a']++;
vector<int> odd;
for (int i = 0; i < 26; i++) {
if (cnt[i] % 2) odd.push_back(i);
}
for (int i = 0; i < odd.size() / 2; i++) {
cnt[odd[i]]++;
cnt[odd[odd.size() - 1 - i]]--;
}
string ans = "";
for (int i = 0; i < 26; i++) {
char a = 'a' + i;
for (int j = 0; j < cnt[i] / 2; j++) ans += a;
}
if (odd.size() % 2) {
char a = 'a' + odd[odd.size() / 2];
ans += a;
}
for (int i = 25; i >= 0; i--) {
char a = 'a' + i;
for (int j = 0; j < cnt[i] / 2; j++) ans += a;
}
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
bool mark[N];
vector<int> G[N];
bool DFS(int r, int pr) {
mark[r] = true;
for (int u : G[r])
if (!mark[u]) {
if (DFS(u, r)) return true;
} else if (u != pr)
return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
while (m--) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].push_back(y), G[y].push_back(x);
}
int ans = 0;
for (int i = 0; i < n; i++)
if (!mark[i]) ans += (!DFS(i, -1));
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<char> S;
int main() {
string s;
cin >> s;
bool flag = 0;
S.insert('A');
S.insert('H');
S.insert('I');
S.insert('V');
S.insert('M');
S.insert('O');
S.insert('T');
S.insert('U');
S.insert('W');
S.insert('X');
S.insert('Y');
for (int i = 0; i < s.length(); i++) {
if (s[i] != s[s.length() - 1 - i]) flag = 1;
if (!S.count(s[i])) flag = 1;
}
if (flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int L, b, f, n;
int main() {
vector<int> x((int)2e5);
cin >> L >> b >> f >> n;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int type;
cin >> type;
if (type == 1) {
int len;
cin >> len;
int place = 0, begin = 0;
bool gotcha = false;
for (int j = 0; j < L; j++) {
if (!x[j])
place++;
else
place = 0, begin = j + 1;
if (place == len + b || (place == len && begin == 0)) {
if (begin != 0) begin += b;
bool y = true;
for (int k = j + 1; k <= j + f; k++)
if (x[k]) {
y = false;
break;
}
if (y) {
v.push_back(make_pair(len, begin));
for (int z = begin; z < begin + len; z++) x[z] = true;
cout << begin << endl;
gotcha = true;
break;
}
begin = j + 1;
}
}
if (!gotcha) {
v.push_back(make_pair(-1, -1));
cout << -1 << endl;
}
} else {
int num;
cin >> num;
for (int j = v[num - 1].second; j < v[num - 1].second + v[num - 1].first;
j++)
x[j] = false;
v.push_back(make_pair(-1, -1));
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int MOD = 998244353;
inline int lgput(int a, int b) {
int ans = 1;
while (b > 0) {
if (b & 1) ans = (1LL * ans * a) % MOD;
b >>= 1;
a = (1LL * a * a) % MOD;
}
return ans;
}
inline void mod(int &x) {
if (x >= MOD) x -= MOD;
}
inline void add(int &x, int y) {
x += y;
mod(x);
}
inline void sub(int &x, int y) {
x += MOD - y;
mod(x);
}
inline void mul(int &x, int y) { x = (1LL * x * y) % MOD; }
using namespace std;
inline int get(int x) {
int ans = 0;
while (x > 0) {
ans++;
x /= 10;
}
return ans;
}
int fr[20], pw[100];
int sum[20][20];
int main() {
int i, j, n;
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
pw[0] = 1;
for (i = 1; i < 100; i++) {
pw[i] = (1LL * pw[i - 1] * 10) % MOD;
}
cin >> n;
vector<int> arr(n + 1);
for (i = 1; i <= n; i++) {
cin >> arr[i];
int cur = get(arr[i]);
fr[cur]++;
int p10 = 1;
for (j = cur - 1; j >= 0; j--) {
sum[cur][j] += (arr[i] / p10) % 10;
p10 *= 10;
}
}
int ans = 0;
for (i = 1; i <= n; i++) {
vector<int> aux;
int nr = arr[i];
while (nr > 0) {
aux.push_back(nr % 10);
nr /= 10;
}
reverse(aux.begin(), aux.end());
int d1 = get(arr[i]);
for (int d2 = 1; d2 <= 15; d2++) {
if (fr[d2] == 0) {
continue;
}
if (d1 >= d2) {
for (j = 0; j < d1 - d2; j++) {
ans = (ans + 1LL * fr[d2] * aux[j] * pw[d1 + d2 - j - 1]) % MOD;
}
for (j = 0; j < d2; j++) {
ans = (ans + 1LL * sum[d2][j] * pw[2 * d2 - 2 * j - 2]) % MOD;
ans =
(ans + 1LL * aux[d1 - d2 + j] * pw[2 * d2 - 2 * j - 1] * fr[d2]) %
MOD;
}
} else {
for (j = 0; j < d2 - d1; j++) {
ans = (ans + 1LL * sum[d2][j] * pw[d1 + d2 - j - 1]) % MOD;
}
for (j = 0; j < d1; j++) {
ans = (ans + 1LL * aux[j] * pw[2 * d1 - 2 * j - 1] * fr[d2]) % MOD;
ans =
(ans + 1LL * sum[d2][j + d2 - d1] * pw[2 * d1 - 2 * j - 2]) % MOD;
}
}
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
float a[11][11];
int main() {
long long int n, t;
cin >> n >> t;
a[1][1] = t - 1;
long long int ans = a[1][1] >= 0 ? 1 : 0;
for (int i = 2; i < n + 1; i++) {
for (int j = 1; j < i + 1; j++) {
a[i][j] = -1;
if (a[i - 1][j - 1] >= 0) a[i][j] += a[i - 1][j - 1] / 2;
if (a[i - 1][j] >= 0) a[i][j] += a[i - 1][j] / 2;
if (a[i][j] >= 0) ans++;
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, m, a[N], b[N], f[N][N];
template <class T>
inline bool ten(T &x, const T &y) {
return y < x ? (x = y, 1) : 0;
}
void init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
a[0] = a[n];
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
b[0] = b[n];
memset(f, 0x7f, sizeof(f));
}
void work() {
f[0][0] = 0;
for (int i = 0; i < 4 * n; i++)
for (int j = 0; j < n + n; j++) {
if (j > 0) ten(f[i + 1][j - 1], f[i][j] + b[(i + 1) % n]);
if (j < n + n) ten(f[i + 1][j + 1], f[i][j] + a[(i + 1) % n]);
}
if (m < 4)
printf("%d\n", f[n * m][0]);
else
printf("%I64d\n",
f[n * 4][0] + (long long)(m - 4) / 2 * (f[n * 4][0] - f[n * 2][0]));
}
int main() {
init();
work();
return 0;
}
| 17 |
#include <bits/stdc++.h>
template <typename T>
bool ckmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T>
bool ckmin(T &x, T y) {
return x > y ? x = y, true : false;
}
using namespace std;
const long long inf = 1000000000;
const double Pi = acos(-1);
const long long mod = 998244353;
const double eps = 1e-6;
inline long long fpow(long long a, long long b = mod - 2, long long p = mod) {
a %= p;
long long res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % p;
a = 1ll * a * a % p;
b >>= 1;
}
return res;
}
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writesp(long long x) { write(x), putchar(' '); }
inline void writeln(long long x) {
write(x);
putchar('\n');
}
inline void evil() {
puts("No");
exit(0);
}
long long n, t;
long long a[222222], x[222222];
long long b[222222];
signed main() {
n = read(), t = read();
for (long long i = (1), iE = (n); i <= iE; i++) a[i] = read();
for (long long i = (1), iE = (n); i <= iE; i++) {
x[i] = read();
if (x[i] < i) evil();
}
for (long long i = (1), iE = (n); i <= iE; i++) b[i] = a[i] + t;
long long mx = 0;
for (long long i = (1), iE = (n); i <= iE; i++) {
mx = max(mx, x[i]);
if (mx > i) b[i] = b[i + 1], ++b[i + 1];
}
for (long long L = 1, R = 1; L <= n; L++) {
if (R <= L) R = L + 1;
while (R <= n && a[R] + t <= b[R - 1]) ++R;
if (x[L] != R - 1) evil();
}
puts("Yes");
for (long long i = (1), iE = (n); i <= iE; i++) printf("%lld ", b[i]);
puts("");
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9;
const long long LINF = 2e16;
const int INF = 2e9;
const int magic = 348;
const double eps = 1e-10;
const double pi = acos(-1);
inline int getint() {
char ch;
int res;
bool f;
while (!isdigit(ch = getchar()) && ch != '-') {
}
if (ch == '-')
f = false, res = 0;
else
f = true, res = ch - '0';
while (isdigit(ch = getchar())) res = res * 10 + ch - '0';
return f ? res : -res;
}
int n, q;
inline int mod(long long first) {
while (first >= MOD) first -= MOD;
return first;
}
struct Matrix {
int b[3][3];
inline void init() {
b[1][1] = 0;
b[1][2] = b[2][1] = b[2][2] = 1;
}
inline void clear() {
for (register int i = 1; i <= 2; i++)
for (register int j = 1; j <= 2; j++) b[i][j] = 0;
}
inline Matrix operator+(const Matrix ma) {
Matrix res;
res.clear();
int i, j;
for (i = 1; i <= 2; i++)
for (j = 1; j <= 2; j++)
res.b[i][j] = mod(res.b[i][j] + mod(b[i][j] + ma.b[i][j]));
return res;
}
inline Matrix operator*(const Matrix ma) {
Matrix res;
res.clear();
int i, j, k;
for (i = 1; i <= 2; i++)
for (j = 1; j <= 2; j++)
for (k = 1; k <= 2; k++)
res.b[i][j] =
mod(res.b[i][j] + ((long long)b[i][k] * ma.b[k][j]) % MOD);
return res;
}
inline Matrix operator^(const Matrix ma) {
Matrix res;
res.b[1][1] = res.b[1][2] = 0;
int j, k;
for (j = 1; j <= 2; j++)
for (k = 1; k <= 2; k++)
res.b[1][j] =
mod(res.b[1][j] + ((long long)b[1][k] * ma.b[k][j]) % MOD);
return res;
}
inline Matrix operator&(const Matrix ma) {
Matrix res;
res.b[1][1] = res.b[1][2] = 0;
int j;
for (j = 1; j <= 2; j++)
res.b[1][j] = mod(res.b[1][j] + mod(b[1][j] + ma.b[1][j]));
return res;
}
} trans, ma[200048];
long long fib[200048], sum1[200048], sum2[200048];
int a[200048];
namespace SegmentTree {
struct node {
int left, right, len, lazy;
Matrix ma;
} tree[1000048];
inline Matrix pushup(Matrix first, Matrix second, int starter) {
if (starter) second = second ^ ma[starter];
first = first & second;
return first;
}
inline void pushdown(int cur) {
tree[cur << 1].lazy = mod(tree[cur << 1].lazy + tree[cur].lazy);
tree[cur << 1 | 1].lazy = mod(tree[cur << 1 | 1].lazy + tree[cur].lazy);
tree[cur].lazy = 0;
}
inline Matrix calc_lazy(Matrix first, int ind) {
if (tree[ind].lazy == 0) return first;
first.b[1][1] = mod(first.b[1][1] +
((long long)tree[ind].lazy * sum1[tree[ind].len]) % MOD);
first.b[1][2] = mod(first.b[1][2] +
((long long)tree[ind].lazy * sum2[tree[ind].len]) % MOD);
return first;
}
inline void build(int cur, int left, int right) {
tree[cur].left = left;
tree[cur].right = right;
tree[cur].lazy = 0ll;
tree[cur].len = tree[cur].right - tree[cur].left + 1;
if (left != right) {
int mid = (left + right) >> 1;
build(cur << 1, left, mid);
build(cur << 1 | 1, mid + 1, right);
tree[cur].ma =
pushup(tree[cur << 1].ma, tree[cur << 1 | 1].ma, tree[cur << 1].len);
} else {
tree[cur].ma.b[1][1] = tree[cur].ma.b[1][2] = a[left];
tree[cur].ma.b[2][1] = tree[cur].ma.b[2][2] = 0;
}
}
inline void update(int cur, int pos, int newval) {
if (tree[cur].left == tree[cur].right) {
tree[cur].ma.b[1][1] = tree[cur].ma.b[1][2] = newval;
tree[cur].lazy = 0;
return;
}
pushdown(cur);
int mid = (tree[cur].left + tree[cur].right) >> 1;
if (pos <= mid)
update(cur << 1, pos, newval);
else
update(cur << 1 | 1, pos, newval);
tree[cur].ma = pushup(calc_lazy(tree[cur << 1].ma, cur << 1),
calc_lazy(tree[cur << 1 | 1].ma, cur << 1 | 1),
tree[cur << 1].len);
}
inline Matrix query(int cur, int left, int right, int starter) {
Matrix res;
res.clear();
if (left <= tree[cur].left && tree[cur].right <= right)
return calc_lazy(tree[cur].ma, cur) * ma[starter];
pushdown(cur);
int mid = (tree[cur].left + tree[cur].right) >> 1;
if (left > mid) {
res = query(cur << 1 | 1, left, right, starter);
} else if (right <= mid) {
res = query(cur << 1, left, right, starter);
} else {
Matrix res1 = query(cur << 1, left, tree[cur << 1].right, starter),
res2 = query(cur << 1 | 1, tree[cur << 1 | 1].left, right,
starter + mid - left + 1);
res = res1 + res2;
}
tree[cur].ma = pushup(calc_lazy(tree[cur << 1].ma, cur << 1),
calc_lazy(tree[cur << 1 | 1].ma, cur << 1 | 1),
tree[cur << 1].len);
return res;
}
inline void update(int cur, int left, int right, int delta) {
if (left <= tree[cur].left && tree[cur].right <= right) {
tree[cur].lazy = mod(tree[cur].lazy + delta);
return;
}
pushdown(cur);
int mid = (tree[cur].left + tree[cur].right) >> 1;
if (left <= mid) update(cur << 1, left, right, delta);
if (mid + 1 <= right) update(cur << 1 | 1, left, right, delta);
tree[cur].ma = pushup(calc_lazy(tree[cur << 1].ma, cur << 1),
calc_lazy(tree[cur << 1 | 1].ma, cur << 1 | 1),
tree[cur << 1].len);
}
} // namespace SegmentTree
int main() {
n = getint();
q = getint();
int i, type, pos, newval, l, r, delta;
trans.init();
ma[0].b[1][1] = ma[0].b[2][2] = 1;
ma[0].b[1][2] = ma[0].b[2][1] = 0;
for (i = 1; i <= n + 10; i++) ma[i] = ma[i - 1] * trans;
for (i = 1; i <= n; i++) a[i] = getint();
fib[1] = fib[2] = 1;
for (i = 3; i <= n + 10; i++) fib[i] = mod(fib[i - 1] + fib[i - 2]);
sum1[1] = sum2[1] = 1;
for (i = 2; i <= n + 9; i++)
sum1[i] = mod(sum1[i - 1] + fib[i]),
sum2[i] = mod(sum2[i - 1] + fib[i + 1]);
SegmentTree::build(1, 1, n);
while (q--) {
type = getint();
if (type == 1) {
pos = getint();
newval = getint();
SegmentTree::update(1, pos, newval);
}
if (type == 2) {
l = getint();
r = getint();
printf("%d\n", SegmentTree::query(1, l, r, 0).b[1][1]);
}
if (type == 3) {
l = getint();
r = getint();
delta = getint();
SegmentTree::update(1, l, r, delta);
}
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
int arr[10];
arr[0] = 0;
cin >> t;
arr[0] = 0;
while (t--) {
arr[0] = 0;
string s;
arr[0] = 0;
cin >> s;
arr[0] = 0;
bool f = 0;
arr[0] = 0;
for (int i = 0; i < s.size() - 1; i++) {
arr[0] = 0;
if (s[i] != s[i + 1]) {
arr[0] = 0;
f = 1;
}
}
if (!f) {
arr[0] = 0;
cout << s << endl;
arr[0] = 0;
continue;
}
for (int i = 0; i < s.size() - 1; i++) {
arr[0] = 0;
cout << s[i];
arr[0] = 0;
if (s[i] == s[i + 1]) {
arr[0] = 0;
cout << (s[i] == '0' ? 1 : 0);
}
}
arr[0] = 0;
cout << s[s.size() - 1] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int i, cnt = 0;
cin >> s;
for (i = 0; i < s.size(); i++) {
if (s[i] == '1') cnt++;
}
if (cnt >= 2)
cout << (s.size() + 1) / 2 << endl;
else
cout << s.size() / 2 << endl;
return 0;
}
| 2 |
/* 2013-08-11 09:17:07.794206 */#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
int n;
double ans, dist[5001][5001], a[5001][3];
int main(){
// freopen("d.in", "r", stdin);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lf%lf%lf", &a[i][0], &a[i][1], &a[i][2]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dist[i][j] = sqrt( (a[i][0] - a[j][0]) * (a[i][0] - a[j][0]) + (a[i][1] - a[j][1]) * (a[i][1] - a[j][1]) +
(a[i][2] - a[j][2]) * (a[i][2] - a[j][2]));
ans = 1e20;
for (int i = 2; i <= n; i++)
for (int j = i + 1; j <= n; j++)
ans = min(ans, (dist[1][i] + dist[1][j] + dist[i][j])/2.0);
printf("%.10lf\n", ans);
} | 10 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long long int inf = 10000000000000000LL;
const long long int mod = 1000000007;
struct Node {
vector<int> nbr;
long long int v;
};
long long int dfs(vector<Node>& arr, int v, int d) {
if (d == 0) {
for (int i = 0; i < (arr.size()); ++i) {
arr[i].v = 0;
}
}
for (int i = 0; i < (arr[v].nbr.size()); ++i) {
int to = arr[v].nbr[i];
if (d == 0)
dfs(arr, to, d + 1);
else {
arr[to].v++;
}
}
long long int ans = 0;
if (d == 0) {
for (int i = 0; i < (arr.size()); ++i) {
long long int v = arr[i].v;
ans += v * (v - 1) / 2;
}
ans -= arr[v].v * (arr[v].v - 1) / 2;
}
return ans;
}
void check(int* d) {
d[8]--;
d[9]--;
d[1]--;
d[6]--;
vector<int> arr(4);
arr[0] = 1;
arr[1] = 6;
arr[2] = 8;
arr[3] = 9;
long long int c = 0;
for (int i = ((int)10) - 1; i >= 0; --i) {
if (i == 0) {
break;
}
for (int j = 0; j < (d[i]); ++j) {
c *= 10;
c += i;
c %= 7;
cout << i;
}
}
do {
long long int k = c;
for (int i = 0; i < (4); ++i) {
k *= 10;
k += arr[i];
k %= 7;
}
if (k == 0) {
break;
}
} while (next_permutation(arr.begin(), arr.end()));
for (int i = 0; i < (4); ++i) {
cout << arr[i];
}
for (int j = 0; j < (d[0]); ++j) {
cout << 0;
}
}
int main() {
srand(13);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(2);
int start = clock();
string s;
cin >> s;
int d[10] = {0};
for (int i = 0; i < (s.length()); ++i) {
d[s[i] - '0']++;
}
check(d);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int gene[22];
bool cmp[22];
int pos[22];
vector<vector<int> > AdjList;
bool no_usar[22];
long long memo[(1 << 17)];
long long sol(int mask) {
int id = __builtin_popcount(mask);
if (id == n) return 1;
if (memo[mask] != -1) return memo[mask];
int grados[17];
for (int i = 0; i < n; i++) grados[i] = gene[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
if (mask & (1 << i)) {
for (int j = 0; j < AdjList[i].size(); j++) grados[AdjList[i][j]]--;
}
}
if (cmp[id]) {
if (grados[pos[id]] == 0) {
ans += sol(mask | (1 << pos[id]));
}
} else {
for (int i = 0; i < n; i++) {
if (grados[i] == 0) {
if (mask & (1 << i))
;
else if (!no_usar[i]) {
ans += sol(mask | (1 << i));
}
}
}
}
return memo[mask] = ans;
}
int main() {
int m, x, y;
long long anio;
cin >> n >> anio >> m;
AdjList.assign(n, vector<int>());
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
x--, y--;
AdjList[x].push_back(y);
gene[y]++;
}
anio -= 2000;
long long acum = 0;
for (int i = 0; i < n; i++) {
no_usar[i] = true;
bool tmp = false;
for (int j = 0; j < n; j++)
if (!cmp[j]) {
pos[j] = i;
cmp[j] = true;
memset(memo, -1, sizeof memo);
long long gg = sol(0);
if (acum + gg >= anio) {
tmp = true;
break;
} else {
acum += gg;
}
cmp[j] = false;
}
if (!tmp) {
cout << "The times have changed" << endl;
return 0;
}
}
int ans[22];
for (int i = 0; i < n; i++) {
ans[pos[i]] = i + 1;
}
if (acum + 1 == anio) {
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
} else {
cout << "The times have changed" << endl;
}
}
| 16 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1000000007;
const ll root = 62;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
ll binpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll modInv(ll a) { return binpow(a, MOD - 2); }
const double PI = acos(-1);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0xc0c0c0c0c0c0c0c0;
const int mxN = 100001;
ll arr[mxN];
ll psum[mxN];
pair<ll, ll> all[mxN];
pair<ll, ll> temp[mxN];
ll ans = INFLL;
int n;
bool cmpy(pair<ll, ll> a, pair<ll, ll> b) { return a.second < b.second; }
void upd_ans(pair<ll, ll> a, pair<ll, ll> b) {
ll dist = (a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second);
ans = min(ans, dist);
}
void recurse(int l, int r) {
if (r - l <= 3) {
for (int i = (l); i < (r); ++i) {
for (int j = (i + 1); j < (r); ++j) {
upd_ans(all[i], all[j]);
}
}
sort(all + l, all + r, cmpy);
return;
}
int m = (l + r) >> 1;
recurse(l, m);
recurse(m, r);
int sz = 0;
int pl = l;
int pr = m;
while (pl < m || pr < r) {
if (pl == m) {
temp[sz++] = all[pr++];
} else if (pr == r) {
temp[sz++] = all[pl++];
} else {
temp[sz++] = (all[pl].second < all[pr].second ? all[pl++] : all[pr++]);
}
}
for (int i = (l); i < (r); ++i) {
all[i] = temp[i - l];
}
for (int i = (l); i < (r); ++i) {
for (int k = 1; i + k < r && k < 4; ++k) {
upd_ans(all[i], all[i + k]);
}
}
}
int main() {
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
cin.tie(0)->sync_with_stdio(0);
cin >> n;
for (int i = (1); i < (n + 1); ++i) {
cin >> arr[i];
}
for (int i = (1); i < (n + 1); ++i) {
psum[i] = psum[i - 1] + arr[i];
all[i - 1] = {i, psum[i]};
}
recurse(0, n);
cout << ans << "\n";
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000;
inline int read() {
int rtn = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) rtn = (rtn << 1) + (rtn << 3) + ch - '0';
return rtn * f;
}
int ans1[maxn], ans2[maxn], tmp[maxn];
int main() {
int n = read();
ans1[++ans1[0]] = 1;
ans2[++ans2[0]] = 0;
ans2[++ans2[0]] = 1;
for (int i = 2; i <= n; i++) {
tmp[0] = 0;
swap(ans1, ans2);
for (int i = 1; i <= ans2[0]; i++) tmp[++tmp[0]] = ans2[i];
for (int i = 1; i <= ans1[0]; i++) ans2[i + 1] = ans1[i];
ans2[1] = 0;
ans2[0] = ans1[0] + 1;
int flag = -1;
for (int i = 1; i <= ans2[0]; i++) {
if (abs(tmp[i] - ans2[i]) > 1) {
flag = 1;
break;
}
}
for (int i = 1; i <= ans2[0]; i++) ans2[i] = ans2[i] + flag * tmp[i];
}
printf("%d\n", ans2[0] - 1);
for (int i = 1; i <= ans2[0]; i++) printf("%d ", ans2[i]);
printf("\n%d\n", ans1[0] - 1);
for (int i = 1; i <= ans1[0]; i++) printf("%d ", ans1[i]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const long long SZ = 210, SSZ = 0, APB = 26, one = 93, INF = 0x7FFFFFF,
mod = 1000000007;
long long n, m, cnt, mk[SZ], fail[SZ];
long long arr[SZ], nex[SZ][APB];
long long src[SZ][SZ];
char ch[SZ];
void add(long long pos) {
long long cur = 0;
for (long long i = 1; ch[i]; ++i) {
long long c = ch[i] - 'a';
if (!nex[cur][c]) nex[cur][c] = ++cnt;
cur = nex[cur][c];
}
mk[cur] += arr[pos];
}
void build() {
queue<long long> q;
q.push(0);
for (; q.size();) {
long long fr = q.front();
q.pop();
for (long long i = 0; i < APB; ++i) {
long long t = nex[fr][i];
if (t) {
if (!fr)
fail[t] = 0;
else {
long long u = fail[fr];
for (; u && !nex[u][i]; u = fail[u])
;
u = nex[u][i];
fail[t] = u;
mk[t] += mk[u];
}
q.push(t);
}
}
}
}
long long get_nex(long long x, long long c) {
for (; x && !nex[x][c]; x = fail[x])
;
return nex[x][c];
}
void mul(long long dst[][SZ], long long x[][SZ], long long y[][SZ]) {
long long res[SZ][SZ];
memset(res, -63, sizeof(res));
for (long long i = 0; i <= cnt; ++i) {
for (long long j = 0; j <= cnt; ++j) {
for (long long k = 0; k <= cnt; ++k) {
res[i][j] = max(res[i][j], x[i][k] + y[k][j]);
}
}
}
memcpy(dst, res, sizeof(res));
}
void pow_mod(long long x) {
long long ele[SZ][SZ], res[SZ][SZ];
memcpy(ele, src, sizeof(ele));
memset(res, -63, sizeof(res));
for (long long i = 0; i <= cnt; ++i) res[i][i] = 0;
for (; x; x /= 2) {
if (x & 1) mul(res, res, ele);
mul(ele, ele, ele);
}
memcpy(src, res, sizeof(res));
}
void init() {
cin >> n >> m;
for (long long i = 1; i <= n; ++i) cin >> arr[i];
for (long long i = 1; i <= n; ++i) {
cin >> ch + 1;
add(i);
}
build();
memset(src, -63, sizeof(src));
for (long long i = 0; i <= cnt; ++i) {
for (long long j = 0; j < APB; ++j) {
long long tmp = get_nex(i, j);
src[tmp][i] = mk[tmp];
}
}
pow_mod(m);
long long res = 0;
for (long long i = 0; i <= cnt; ++i) {
res = max(res, src[i][0]);
}
cout << res << endl;
}
void work() {}
int main() {
std::ios::sync_with_stdio(0);
long long casenum;
{
init();
work();
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
using LD = long double;
using PLL = pair<long long, long long>;
using VII = vector<pair<int, int> >;
template <class T>
bool power_2(T v) {
static_assert(std::is_integral<T>::value, "type should be integral");
return v && !(v & (v - 1));
}
template <class T>
istream& operator>>(istream& st, vector<T>& container) {
for (auto& u : container) st >> u;
return st;
}
template <class T>
ostream& operator<<(ostream& st, const vector<T>& container) {
for (auto& u : container) st << u << '\n';
return st;
}
template <class T, size_t N>
istream& operator>>(istream& st, array<T, N>& container) {
for (auto& u : container) st >> u;
return st;
}
template <class T, size_t N>
ostream& operator<<(ostream& st, const array<T, N>& container) {
for (auto u : container) st << u << ' ';
return st;
}
template <class T, class U>
istream& operator>>(istream& st, pair<T, U>& p) {
st >> p.first >> p.second;
return st;
}
template <class T, class U>
ostream& operator<<(ostream& st, pair<T, U> p) {
st << p.first << ' ' << p.second;
return st;
}
template <class T, class U, class V>
pair<T, U> operator*(pair<T, U> p, V val) {
return {p.first * val, p.second * val};
}
template <class T, class U, class V>
pair<T, U> operator/(pair<T, U> p, V val) {
return {p.first / val, p.second / val};
}
template <class T, class U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
template <class T, class U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
template <class T>
T dotProduct(pair<T, T> a, pair<T, T> b) {
return a.first * b.first + a.second * b.second;
}
template <class T>
T crossProduct(pair<T, T> a, pair<T, T> b) {
return a.first * b.second - a.second * b.first;
}
template <class T>
T lengthPow(pair<T, T> a) {
return a.first * a.first + a.second * a.second;
}
template <class T>
LD length(pair<T, T> a) {
return sqrt(lengthPow(a));
}
const int N = 1e6 + 57, inf = 1e9 + 7;
const long long MOD = 1e9 + 7;
const long long INF = 1e18 + 7;
const long double PI = acos(-1);
const LD EPS = 1e-12;
const int pod = 29;
long long hasz[N];
long long potegi[N];
char start;
string s, t;
int pos1 = 0, pos2 = 0;
bool teSame(int a, int b, int c, int d) {
if (b - a != d - c) return 0;
long long odej = 0;
if (a > 0) odej = hasz[a - 1] * potegi[b - a + 1] % MOD;
long long l = (hasz[b] - odej + MOD) % MOD;
if (c > 0) odej = hasz[c - 1] * potegi[d - c + 1] % MOD;
long long p = (hasz[d] - odej + MOD) % MOD;
if (l == p) {
return 1;
int zmiana = (d - c) / 6;
for (int i = 0; i < 6; ++i) {
if (t[a + i * zmiana] != t[c + i * zmiana]) return 0;
}
return 1;
}
return 0;
}
bool check(int dl1, int dl2) {
int pos = 0;
int posS = 0;
int posT = pos2 * dl1;
if (teSame(0, dl1 - 1, posT, posT + dl2 - 1)) return 0;
while (pos < t.size()) {
if (s[posS] == start) {
if (!teSame(0, dl1 - 1, pos, pos + dl1 - 1)) return 0;
pos += dl1;
} else {
if (!teSame(posT, posT + dl2 - 1, pos, pos + dl2 - 1)) return 0;
pos += dl2;
}
++posS;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout << fixed << setprecision(9);
cin >> s >> t;
int n = t.size();
potegi[0] = 1;
for (int i = 1; i <= t.size(); ++i) {
potegi[i] = potegi[i - 1] * pod % MOD;
}
for (int i = 0; i < t.size(); ++i) {
if (i > 0) hasz[i] = hasz[i - 1] * pod % MOD;
hasz[i] += (t[i] - 'a' + 1);
hasz[i] %= MOD;
}
start = s[0];
long long zera = 0, jed = 0;
for (auto u : s) {
if (u == start)
++zera;
else
++jed;
}
for (int i = 0; i < s.size(); ++i) {
if (s[i] != start) {
pos2 = i;
break;
}
}
int res = 0;
long long dl = 1;
while (dl * zera + jed <= t.size()) {
int zostalo = t.size() - dl * zera;
if (zostalo % jed != 0) {
++dl;
continue;
}
int dl2 = zostalo / jed;
if (check(dl, dl2)) ++res;
++dl;
}
cout << res;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
const int inf = 0x3f3f3f3f;
int n, x;
bool is_prim(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
long long pow(long long a, long long b, long long mod) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
int main() {
cin >> n >> x;
if (x == 1 || !is_prim(n + 1))
;
else {
for (int b = x - 1; b > 1; b--) {
bool f = 1;
for (int i = 2; i * i <= n; i++) {
if (n % i) continue;
if (pow(b, i, n + 1) == 1) f = 0;
if (pow(b, n / i, n + 1) == 1) f = 0;
if (f == 0) break;
}
if (f) return printf("%d\n", b), 0;
}
}
puts("-1");
return 0;
}
| 18 |
#include <bits/stdc++.h>
#define ed end()
#define bg begin()
#define mp make_pair
#define pb push_back
#define all(x) x.bg,x.ed
#define newline puts("")
#define si(x) ((int)x.size())
#define rep(i,n) for(int i=1;i<=n;++i)
#define rrep(i,n) for(int i=0;i<n;++i)
#define srep(i,s,t) for(int i=s;i<=t;++i)
#define drep(i,s,t) for(int i=t;i>=s;--i)
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int Maxn = 5e5+10;
const int Inf = 0x7f7f7f7f;
const ll Inf_ll = 1ll*Inf*Inf;
const int Mod = 1e9+7;
const double eps = 1e-7;
int n, num[66];
ll a[Maxn];
void solve(){
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
ll ans = 0;
for(int j=0;j<=60;j++) num[j] = 0;
for(int i=1;i<=n;i++) for(int j=0;j<=60;j++)
if( a[i]&(1ll<<j) ) num[j]++;
for(int i=1;i<=n;i++)
{
ll t1 = 0, t2 = 0;
for(int j=0;j<=60;j++) if( a[i]&(1ll<<j) )
t1 = (t1 + (1ll<<j)%Mod*num[j]%Mod)%Mod;
for(int j=0;j<=60;j++)
{
if( a[i]&(1ll<<j) )
t2 = (t2 + (1ll<<j)%Mod*n%Mod)%Mod;
else
t2 = (t2 + (1ll<<j)%Mod*num[j]%Mod)%Mod;
}
ans = (ans + t1*t2%Mod)%Mod;
}
printf("%lld\n", ans);
return ;
}
int main(){
int T;
scanf("%d",&T);
for(int _=1;_<=T;_++)
{
solve();
}
return 0;
} | 10 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535;
const int MX = 1e2 + 7;
const double val = pi / 180.0;
const int INF = 0x3f3f3f3f;
int a[MX];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int ans = INF;
int flag = 0;
int t = 0;
for (int i = -1000; i <= 1000; ++i) {
int d = abs(a[1] - i);
for (int j = 1; j <= n; ++j) {
d = abs(a[j] - i);
if (d) break;
}
flag = 1;
for (int j = 2; j <= n; ++j) {
if (abs(a[j] - i) == d || a[j] == i)
continue;
else {
flag = 0;
break;
}
}
if (flag) {
if (d >= 0) {
ans = min(ans, d);
t++;
}
}
}
if (!t)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 7;
const int inf = 1e9 + 7;
int gt[maxn][19], a[maxn], last[19], n, q;
int main() {
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int j = 0; j < 19; j++) {
gt[n][j] = n;
last[j] = n;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 19; j++) gt[i][j] = n;
for (int j = 0; j < 19; j++) {
if ((a[i] >> j) & 1) {
for (int k = 0; k < 19; k++) gt[i][k] = min(gt[i][k], gt[last[j]][k]);
gt[i][j] = i;
last[j] = i;
}
}
}
for (int i = 0; i < q; i++) {
int x, y, flag = 0;
cin >> x >> y;
x--;
y--;
for (int j = 0; j < 19; j++) {
if (((a[y] >> j) & 1) && gt[x][j] <= y) {
flag = 1;
break;
}
}
if (flag)
cout << "Shi" << endl;
else
cout << "Fou" << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int64_t INF = 2e9, MOD = 998244353;
int32_t main() {
ios_base::sync_with_stdio(false);
int64_t n, m;
cin >> n >> m;
vector<int64_t> a(n), b(m);
for (int64_t i = 0; i < n; i++) cin >> a[i];
for (int64_t j = 0; j < m; j++) cin >> b[j];
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
int64_t i = 0, ans = 1;
for (int64_t j = 0; j < m; j++) {
int64_t first = -1;
while (i < n && a[i] >= b[j]) {
if (a[i] == b[j] && first == -1) first = i;
i++;
}
if (first == -1)
ans = 0;
else {
if (j == m - 1) continue;
ans = ans * (i - first) % MOD;
}
}
if (i != n) ans = 0;
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
int f(int64_t s, int64_t e) {
return (e % 2 || s > e / 4 * 2) ? (e - s & 1) : (s > e / 4 || f(s, e / 4));
}
int main() {
int n, l = 1, w = 0;
std::cin >> n;
while (n-- && w != l) {
int64_t x, y;
std::cin >> x >> y;
l = (x > y / 2 || f(x, y / 2)) ^ w;
w ^= f(x, y);
}
std::cout << w << ' ' << l << '\n';
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
string G[111];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, -1, 0, 1};
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) cin >> G[i];
int sx, sy, ex, ey;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (G[i][j] == 'S') sx = i, sy = j;
if (G[i][j] == 'E') ex = i, ey = j;
}
}
string str;
cin >> str;
int ans = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (i == j) continue;
for (int p = 0; p < 4; p++) {
if (p == i || p == j) continue;
for (int q = 0; q < 4; q++) {
if (q == p || q == i || q == j) continue;
int tx = sx, ty = sy;
bool ok = true;
for (int k = 0; k < str.size(); k++) {
if (str[k] == '0') tx += dx[i], ty += dy[i];
if (str[k] == '1') tx += dx[j], ty += dy[j];
if (str[k] == '2') tx += dx[p], ty += dy[p];
if (str[k] == '3') tx += dx[q], ty += dy[q];
if (tx >= n || tx < 0 || ty >= m || ty < 0) {
ok = false;
break;
}
if (G[tx][ty] == '#') {
ok = false;
break;
}
if (G[tx][ty] == 'E') {
break;
}
}
if (ok && tx == ex && ty == ey) ans++;
}
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int Fl, Pn, SI = 100;
char mch = ' ', ch, Bf[21];
template <typename t>
void in(t& a) {
a = 0;
ch = getchar();
Fl = 1;
while ((ch < '0') || (ch > '9')) Fl = (ch == '-') ? -Fl : Fl, ch = getchar();
while ((ch >= '0') && (ch <= '9')) a = a * 10 + ch - '0', ch = getchar();
a *= Fl;
}
template <typename t>
void out(t a) {
if (a < 0) putchar('-'), a = -a;
if (a == 0) putchar('0');
while (a) Bf[++Pn] = a % 10 + '0', a /= 10;
while (Pn) putchar(Bf[Pn]), --Pn;
putchar(mch);
}
template <typename t, typename... ARGS>
void in(t& a, ARGS&... args) {
in(a);
in(args...);
}
template <typename t, typename... ARGS>
void out(t a, ARGS... args) {
out(a);
out(args...);
}
using namespace std;
struct node {
int num, ind;
bool operator<(const node& b) const {
if (num != b.num) return num < b.num;
return ind < b.ind;
}
};
priority_queue<node> q;
int n, f[100001], a[100001];
int main() {
in(n);
for (register int i = 1; i <= n; i++) in(a[i]);
for (register int i = 1; i <= n; i++) q.push({a[i], i}), f[i] = -2;
for (register int i = n; i >= 1; i--) {
if (f[i] != -2) continue;
f[i] = -1;
while (!q.empty() && q.top().num > a[i]) {
if (f[q.top().ind] == -2) f[q.top().ind] = i - q.top().ind - 1;
q.pop();
}
}
for (register int i = 1; i <= n; i++) out(f[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m[2], m2, mc[1000];
map<string, int> ms;
int k;
bool v[520][520];
int r[502][502], c[502][502];
int main() {
int h, w;
cin >> h >> w;
char a[502][502];
for (long long int i = 0; i < h; ++i)
for (long long int j = 0; j < w; ++j) cin >> a[i][j];
for (long long int i = 0; i < h; ++i) {
int ct = 0;
for (long long int j = 0; j < w; ++j) {
if (a[i][j] == '.') {
ct++;
if (ct >= 2) {
r[i + 1][j + 1] = r[i + 1][j] + 1;
} else
r[i + 1][j + 1] = r[i + 1][j];
} else
r[i + 1][j + 1] = r[i + 1][j], ct = 0;
}
}
for (long long int i = 0; i < w; ++i) {
int ct = 0;
for (long long int j = 0; j < h; ++j) {
if (a[j][i] == '.') {
ct++;
if (ct >= 2) {
c[j + 1][i + 1] = c[j][i + 1] + 1;
} else
c[j + 1][i + 1] = c[j][i + 1];
} else
c[j + 1][i + 1] = c[j][i + 1], ct = 0;
}
}
int q;
cin >> q;
while (q--) {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
long long int ans = 0;
for (long long int i = r1; i < r2 + 1; ++i) {
ans += r[i][c2] - r[i][c1 - 1] - (r[i][c1] - r[i][c1 - 1]);
}
for (long long int i = c1; i < c2 + 1; ++i) {
ans += c[r2][i] - c[r1 - 1][i] - (c[r1][i] - c[r1 - 1][i]);
}
cout << ans << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
const long long MM = 998244353;
long long begtime = clock();
long long newmod(long long a, long long b) { return ((a % b) + b) % b; }
long long powM(long long a, long long b, long long m) {
if (a <= 0) return 0;
a %= m;
if (!b) return 1;
long long ans = 1LL;
while (b) {
if (b & 1) ans = ans * a % m;
a = a * a % m;
b >>= 1;
}
return ans;
}
long long poww(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a;
a = a * a;
b >>= 1;
}
return ans;
}
template <typename T, typename F>
void chmax(T &a, F b) {
if (b > a) a = b;
}
template <typename T, typename F>
void chmin(T &a, F b) {
if (b < a) a = b;
}
const long long N = 1e6 + 1;
long long solve(long long type, vector<pair<long, long> > t1,
vector<pair<long, long> > t0, long long x) {
long long ans = 0;
long long flag = 0;
while (!flag) {
long long pos = -1, mx = 0;
if (!type) {
type = 1;
for (int i = 0; i < ((long long)t0.size()); i++) {
if (t0[i].first <= x && t0[i].second > mx) {
pos = i;
mx = max(mx, (long long)t0[i].second);
}
}
if (pos == -1) {
flag = 1;
break;
}
ans++;
x += mx;
t0.erase(t0.begin() + pos);
} else {
type = 0;
long long pos = -1, mx = 0;
for (int i = 0; i < ((long long)t1.size()); i++) {
if (t1[i].first <= x && t1[i].second > mx) {
mx = max(mx, (long long)t1[i].second);
pos = i;
}
}
if (pos == -1) {
flag = 1;
break;
}
ans++;
x += mx;
t1.erase(t1.begin() + pos);
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, x;
cin >> n >> x;
vector<pair<long, long> > t0, t1;
for (long long i = 0; i < n; i++) {
long long t;
cin >> t;
long long a, b;
cin >> a >> b;
if (t) {
t1.push_back({a, b});
} else {
t0.push_back({a, b});
}
}
cout << max(solve(1, t1, t0, x), solve(0, t1, t0, x));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y % 2) {
res *= x;
}
y /= 2;
x *= x;
}
return res;
}
long long power(long long x, long long y, long long z) {
long long res = 1;
while (y) {
if (y % 2) {
res = (res * x) % z;
}
y /= 2;
x = (x * x) % z;
}
return res;
}
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
bool sortbysec(const pair<long long, long long>& a,
const pair<long long, long long>& b) {
return (a.second > b.second);
}
long long ceil(long long x, long long y) { return (x / y) + (x % y != 0); }
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
int dxx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dyy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
void solve() {
string s, num;
cin >> s >> num;
long long n = s.size();
long long gd[26];
for (long long i = 0; i < 26; i++) {
gd[i] = num[i] - '0';
}
long long k;
cin >> k;
set<long long> st;
for (long long i = 0; i < n; i++) {
long long cnt = 0;
long long hash = 0;
for (long long j = i; j < n; j++) {
long long val = s[j] - 'a';
hash *= 27;
hash += val + 1;
hash %= 34027797218763967;
if (!gd[val]) {
cnt++;
}
if (cnt <= k) {
st.insert(hash);
}
}
}
cout << st.size();
}
int main() {
long long t;
t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, p, v[301];
int main() {
scanf("%d%d", &p, &n);
bool check = false;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (v[x % p]) {
printf("%d\n", i);
return 0;
}
v[x % p] = true;
}
if (!check) printf("-1\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, m, mb;
double hp, mp, ah, am, a, b;
char c;
cin >> h >> c >> m;
h = h % 12;
if (h == 0 && m == 0) {
cout << "0 0\n";
} else {
hp = (double)h;
mp = (double)m / 5.0;
mb = m / 5;
b = (double)mb;
am = mp * 30.0;
a = (11.0 * (double)m - 60.0 * hp) / 2.0;
ah = am - a;
cout << ah << " " << am << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T max(T a, T b, T c) {
return max(max(a, b), c);
}
template <typename T>
inline T max(T a, T b, T c, T d) {
return max(max(a, b), max(c, d));
}
template <typename T>
inline T min(T a, T b, T c) {
return min(min(a, b), c);
}
template <typename T>
inline T min(T a, T b, T c, T d) {
return min(min(a, b), min(c, d));
}
long long int power(long long int a, long long int n, long long int m) {
a = a % m;
long long int r = 1;
while (n > 0) {
if (n % 2 == 1) r = r * a % m;
a = a * a % m;
n = n / 2;
}
return r;
}
int main() {
std::ios::sync_with_stdio(false);
int p1, p2, p3;
cin >> p1 >> p2 >> p3;
int arr[6] = {0};
arr[min(5, p1)]++;
arr[min(5, p2)]++;
arr[min(5, p3)]++;
if (arr[1] >= 1 || arr[2] >= 2 || arr[3] == 3 || (arr[4] == 2 && arr[2] == 1))
cout << "YES";
else
cout << "NO";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[50010], b[50010];
bool flag[50010];
struct node {
int v, id;
node(int v = 0, int id = 0) : v(v), id(id) {}
bool operator<(const node& a) const { return v < a.v; }
};
void solve() {
string s;
cin >> s;
int n = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == '?') n++;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
int cnt = 0, num = 0;
long long ans = 0;
priority_queue<node> que;
memset(flag, 0, sizeof(flag));
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(')
num++;
else {
num--;
if (s[i] == '?') {
ans += (long long)b[cnt];
que.push(node(b[cnt] - a[cnt], cnt));
cnt++;
}
}
if (num < 0) {
if (que.empty()) {
cout << -1 << endl;
return;
}
num += 2;
ans -= (long long)que.top().v;
flag[que.top().id] = 1;
que.pop();
}
}
if (num > 0) {
cout << -1 << endl;
return;
}
cout << ans << endl;
cnt = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == '?') {
if (flag[cnt])
cout << '(';
else
cout << ')';
cnt++;
} else
cout << s[i];
}
int main() {
solve();
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n / 2; ++i) {
if (a[i] > 0) {
cout << -(abs(a[n - i - 1])) << " ";
} else
cout << abs(a[n - i - 1]) << " ";
}
for (int i = n / 2; i < n; ++i) {
if (a[i] > 0) {
cout << (abs(a[n - i - 1])) << " ";
} else
cout << -(abs(a[n - i - 1])) << " ";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int main() {
scanf("%d:%d", &n, &m);
while (1) {
if (n % 10 == m / 10 && n / 10 == m % 10) break;
ans++;
m++;
if (m == 60) {
m = 0;
n++;
}
if (n == 24) n = 0;
}
printf("%d\n", ans);
return 0;
}
| 2 |
/**
* author: tourist
* created: 13.03.2021 14:01:42
**/
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
long long C;
cin >> n >> C;
vector<long long> w(n - 2);
for (int i = 0; i < n - 2; i++) {
cin >> w[i];
}
long long L = 0;
long long R = w[0];
set<long long> s;
long long k = 1;
long long b = 0;
vector<long long> Ls(n - 2);
vector<long long> Rs(n - 2);
vector<bool> flag(n - 2);
vector<long long> any(n - 2);
Ls[0] = L;
Rs[0] = R;
any[0] = L;
for (int i = 1; i < n - 2; i++) {
bool inside = false;
inside |= (L <= w[i] && w[i] <= R);
if (!inside) {
auto it = s.find((w[i] - b) / k);
inside |= (it != s.end());
}
flag[i] = inside;
if (inside) {
L = 0;
R = w[i];
s.clear();
k = 1;
b = 0;
} else {
if (L <= R && L > w[i]) {
L = -1;
R = -2;
}
while (!s.empty()) {
auto it = (k == 1 ? prev(s.end()) : s.begin());
if (k * (*it) + b <= w[i]) {
break;
}
s.erase(it);
}
if (L > R && s.empty()) {
cout << "NO" << '\n';
return 0;
}
if (L <= R) {
any[i - 1] = L;
} else {
any[i - 1] = k * (*s.begin()) + b;
}
if (L <= R) {
L = w[i] - L;
R = w[i] - R;
swap(L, R);
}
// x -> k * x + b
// I want: x -> w - (k * x + b)
// x -> -k * x + (w - b)
k = -k;
b = w[i] - b;
s.insert((w[i] - b) / k);
}
debug(L, R, s, k, b);
Ls[i] = L;
Rs[i] = R;
}
cout << "YES" << '\n';
vector<long long> d(n - 2);
if (L <= R) {
d.back() = L;
} else {
d.back() = k * (*s.begin()) + b;
}
debug(any);
for (int i = n - 3; i > 0; i--) {
if (flag[i]) {
d[i - 1] = w[i];
} else {
if (d[i] == w[i]) {
d[i - 1] = any[i - 1];
} else {
d[i - 1] = w[i] - d[i];
}
}
assert(0 <= d[i - 1] && d[i - 1] <= w[i - 1]);
}
debug(d);
vector<long long> a(n);
a[0] = 0;
a[1] = w[0] - d[0];
a[2] = w[0];
for (int i = 3; i < n; i++) {
bool found = false;
for (int sign = -1; sign <= 1; sign += 2) {
a[i] = a[i - 1] + sign * d[i - 2];
long long mx = max(a[i], max(a[i - 1], a[i - 2]));
long long mn = min(a[i], min(a[i - 1], a[i - 2]));
if (mx - mn == w[i - 2]) {
found = true;
break;
}
}
assert(found);
}
long long mn = *min_element(a.begin(), a.end());
for (int i = 0; i < n; i++) {
a[i] -= mn;
}
for (int i = 0; i < n; i++) {
if (i > 0) {
cout << " ";
}
cout << a[i];
}
cout << '\n';
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
int arr[100000];
int n, k;
int key[256];
int len[256] = {0};
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int(i) = 0; (i) < (256); (i)++) key[i] = -1;
for (int i = 0; i < n; i++) {
if (key[arr[i]] == -1) {
int s = max(0, arr[i] - k + 1);
while (key[s] != -1) s++;
int kk = s;
int l = arr[i] - s + 1;
if (s - 1 >= 0 && key[s - 1] != -1 && len[s - 1] + l <= k) {
kk = key[s - 1];
l = len[s - 1] + l;
}
for (int m = s; m <= arr[i]; m++) {
key[m] = kk;
}
len[arr[i]] = l;
}
}
for (int(i) = 0; (i) < (n); (i)++) {
cout << key[arr[i]] << " ";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
int A = 4 + (2 * a) + (2 * b) - c;
int B = 2 * (d - 1) + 2 + c;
printf("%d\n", A + B);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 2e5 + 5;
struct Node {
int a[5][5];
Node(int x = 0) { memset(a, 0, sizeof(a)); }
inline Node operator*(const Node &t) const {
Node res;
for (int i = 0; i <= 4; ++i) {
for (int j = 0; j <= 4; ++j) {
res.a[i][j] = -1e9;
for (int k = 0; k <= 4; ++k) {
if (a[i][k] == -1e9 || t.a[k][j] == -1e9) continue;
res.a[i][j] = std::max(res.a[i][j], a[i][k] + t.a[k][j]);
}
}
}
return res;
}
inline void print() {
for (int i = 0; i <= 4; ++i)
for (int j = 0; j <= 4; ++j)
printf("%d%c", a[i][j] == -1e9 ? -1 : a[i][j], " \n"[j == 4]);
}
} sm[MAXN << 2];
int a[MAXN], ps[MAXN];
inline void build(int x, int l, int r) {
if (l == r) {
ps[l] = x;
for (int i = 0; i <= 4; ++i)
for (int j = 0; j <= 4; ++j) sm[x].a[i][j] = -1e9;
for (int i = 0; i <= 4; ++i) sm[x].a[i][i] = 1;
if (a[l] == 2) {
sm[x].a[0][0] = 0;
sm[x].a[1][0] = 1;
}
if (a[l] == 0) {
sm[x].a[1][1] = 0;
sm[x].a[2][1] = 1;
}
if (a[l] == 1) {
sm[x].a[2][2] = 0;
sm[x].a[3][2] = 1;
}
if (a[l] == 7) {
sm[x].a[3][3] = 0;
sm[x].a[4][3] = 1;
}
if (a[l] == 6) {
sm[x].a[3][3] = 0;
sm[x].a[4][4] = 0;
}
return;
}
int mid = (l + r) >> 1;
build(((x) << 1), l, mid);
build(((x) << 1 | 1), mid + 1, r);
sm[x] = sm[((x) << 1 | 1)] * sm[((x) << 1)];
}
inline Node query(int x, int l, int r, int L, int R) {
if (l == L && r == R) return sm[x];
int mid = (l + r) >> 1;
if (R <= mid) return query(((x) << 1), l, mid, L, R);
if (L > mid) return query(((x) << 1 | 1), mid + 1, r, L, R);
return query(((x) << 1 | 1), mid + 1, r, mid + 1, R) *
query(((x) << 1), l, mid, L, mid);
}
char str[MAXN];
int n, q;
int main() {
scanf("%d%d", &n, &q);
scanf("%s", str + 1);
for (int i = 1; i <= n; ++i) a[i] = str[i] - '0';
build(1, 1, n);
for (int i = 1; i <= q; ++i) {
int l, r;
scanf("%d%d", &l, &r);
int ans = query(1, 1, n, l, r).a[4][0];
printf("%d\n", ans == -1e9 ? -1 : r - l + 1 - ans);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int faltu = 0;
int che = 1;
int count(long long int n) {
if (n == 0) return faltu;
int j = n % 10;
if (j == 0 || j == 1)
;
else
che = 0;
n /= 10;
faltu++;
return count(n);
}
int N = 1e5;
vector<bool> prime(N + 1, true);
vector<int> prim;
void pri() {
for (int i = 2; i * i <= N; i++) {
if (prime[i]) {
for (int j = i * i; j <= N; j += i) {
prime[j] = false;
}
}
}
for (int i = 2; i <= N; i++) {
if (prime[i]) prim.push_back(i);
}
return;
}
long long dp[200002];
void fact() {
dp[0] = 1;
for (int i = 1; i < 200002; i++) {
dp[i] = (dp[i - 1] * i) % 1000000007;
}
}
long long moduleinverse(long long x) {
long long res = 1;
long long y = 1000000007 - 2;
x = x % 1000000007;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y /= 2;
x = (x * x) % 1000000007;
}
return res;
}
bool chec(int n, int k) {
while (n) {
if (n % 10 == k) return true;
n = n / 10;
}
return false;
}
long long int loga(long long int a, long long int k) {
long long int ans = 0;
while (a >= k) {
ans++;
a /= k;
}
return ans;
}
long long int modpow(long long int x, long long int n) {
if (n == 0) return 1;
long long int a = modpow(x, n / 2);
a = (a * a) % 1000000007;
if (n % 2 == 1) a = (a * x) % 1000000007;
return a;
}
void solve() {
int n;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
if (s1 == s2) {
cout << 0 << "\n";
return;
}
int a[n], b[n];
for (long long i = 0; i < n; i++) {
a[i] = int(s1[i] - '0');
b[i] = int(s2[i] - '0');
}
int cnt = 0;
vector<int> v;
for (long long i = 0; i < n; i++) {
if (a[n - i - 1] == b[n - i - 1])
continue;
else if (a[0] == b[n - i - 1]) {
v.push_back(1);
a[0] = abs(a[0] - 1);
v.push_back(n - i);
int c[n - i];
for (long long j = 0; j < n - i; j++) {
c[j] = abs(a[j] - 1);
}
for (long long j = n - i - 1; j >= 0; j--) {
a[j] = c[n - i - 1 - j];
}
} else {
v.push_back(n - i);
int c[n - i];
for (long long j = 0; j < n - i; j++) {
c[j] = abs(a[j] - 1);
}
for (long long j = n - i - 1; j >= 0; j--) {
a[j] = c[n - i - 1 - j];
}
}
}
cout << v.size() << "\n";
for (long long i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int test;
cin >> test;
while (test--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[60];
for (int i = 1; i <= 6; ++i) cin >> a[i];
long long ans = 0;
ans -= a[1] * a[1] + a[3] * a[3] + a[5] * a[5];
ans += (a[1] + a[2] + a[3]) * (a[1] + a[2] + a[3]);
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void FAST() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long gcd(long long x, long long y) {
if (x == 0) return y;
return gcd(y % x, x);
}
long long powM(long long x, long long y, long long m) {
long long ans = 1, r = 1;
x %= m;
while (r > 0 && r <= y) {
if (r & y) {
ans *= x;
ans %= m;
}
r <<= 1;
x *= x;
x %= m;
}
return ans;
}
vector<int> Factors(int n) {
vector<int> v;
for (int i = 1; i < sqrt(n) + 1; i++) {
if (n % i == 0) {
if (n / i == i)
v.push_back(i);
else {
v.push_back(i);
v.push_back(n / i);
}
}
}
return v;
}
bool IsPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int lcm(int n, int m) { return ((n * m) / gcd(n, m)); }
int main() {
FAST();
long long t;
t = 1;
while (t--) {
string a, b;
cin >> a >> b;
int l = min(a.size(), b.size());
for (int i = 0; i < min(a.size(), b.size()); i++) {
if (a[a.size() - 1 - i] == b[b.size() - 1 - i])
;
else {
l = i;
break;
}
}
cout << a.size() - l + b.size() - l << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const int MOD = 1e9 + 7;
int n, ans = 0;
long long x[maxn];
vector<int> G[maxn];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void dfs(vector<pair<long long, int> > gcd_ls, int u, int p = 0) {
vector<pair<long long, int> > new_gcd_ls;
new_gcd_ls.emplace_back(x[u], 1);
ans = (ans + x[u]) % MOD;
for (auto item : gcd_ls) {
long long cur_gcd = item.first;
int time = item.second;
long long new_gcd = gcd(cur_gcd, x[u]);
ans = (ans + new_gcd * time) % MOD;
if (new_gcd == new_gcd_ls.back().first) {
new_gcd_ls.back().second += time;
} else {
new_gcd_ls.emplace_back(new_gcd, time);
}
}
for (int v : G[u]) {
if (v == p) {
continue;
}
dfs(new_gcd_ls, v, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%lld", x + i + 1);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs({}, 1);
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct MoData {
int l, r, add, id;
};
const int MAXN = 100100;
vector<int> g[MAXN];
int dep[MAXN];
int par[MAXN][20];
int LOG = 0;
int n;
int cnt[MAXN] = {0};
int f[MAXN];
int ff[MAXN];
bool isGirl[MAXN];
int npath = 0;
int path[2 * MAXN];
int val, to, from, q, p;
int st[MAXN];
int en[MAXN];
MoData mo[MAXN];
int blockSize = 1024;
int countBoy[MAXN] = {0}, countGirl[MAXN] = {0};
long long re = 0;
long long ret[MAXN];
int getLCA(int a, int b) {
if (dep[a] > dep[b]) return getLCA(b, a);
for (int i = LOG - 1; i >= 0; i--) {
if (par[b][i] != -1 && dep[par[b][i]] >= dep[a]) {
b = par[b][i];
}
}
if (a == b) return a;
for (int i = LOG - 1; i >= 0; i--) {
if (par[a][i] != par[b][i]) {
a = par[a][i];
b = par[b][i];
}
}
return par[a][0];
}
void _add(int f, bool girl, int delta) {
re -= 1ll * countGirl[f] * countBoy[f];
if (girl)
countGirl[f] += delta;
else
countBoy[f] += delta;
re += 1ll * countGirl[f] * countBoy[f];
}
void moAdd(int pos) {
int id = path[pos];
cnt[id] ^= 1;
if (cnt[id] == 1)
_add(f[id], isGirl[id], 1);
else
_add(f[id], isGirl[id], -1);
}
void moRemove(int pos) {
int id = path[pos];
if (cnt[id] == 1)
_add(f[id], isGirl[id], -1);
else
_add(f[id], isGirl[id], 1);
cnt[id] ^= 1;
}
bool moDataCmp(const MoData& m1, const MoData& m2) {
int b1 = m1.l / blockSize;
int b2 = m2.l / blockSize;
if (b1 != b2)
return b1 < b2;
else
return m1.r < m2.r;
}
void dfs(int v, int p) {
par[v][0] = p;
if (p != -1) {
dep[v] = dep[p] + 1;
}
st[v] = npath;
path[npath++] = v;
for (int i = 0, __end = (g[v].size()); i < __end; ++i) {
int u = g[v][i];
if (u != p) {
dfs(u, v);
}
}
en[v] = npath;
path[npath++] = v;
}
int main() {
scanf("%d", &n);
for (int i = 0, __end = (n); i < __end; ++i) {
scanf("%d", &val);
isGirl[i] = (1 == val);
}
for (int i = 0, __end = (n); i < __end; ++i) {
scanf("%d", &f[i]);
ff[i] = f[i];
}
sort(ff, ff + n);
for (int i = 0, __end = (n); i < __end; ++i)
f[i] = lower_bound(ff, ff + n, f[i]) - ff;
for (int i = 0, __end = (n - 1); i < __end; ++i) {
scanf("%d%d", &from, &to);
from--;
to--;
g[from].push_back(to);
g[to].push_back(from);
}
for (LOG = 1; (1 << LOG) < n; LOG++)
;
dfs(0, -1);
for (int j = 1; j < LOG; ++j)
for (int i = 0; i < n; ++i) {
if (par[i][j - 1] != -1) {
par[i][j] = par[par[i][j - 1]][j - 1];
}
}
cin >> q;
for (int i = 0, __end = (q); i < __end; ++i) {
scanf("%d%d", &from, &to);
from--;
to--;
if (st[from] > st[to]) swap(from, to);
p = getLCA(from, to);
mo[i].id = i;
if (from == p) {
mo[i].l = st[from];
mo[i].r = st[to];
mo[i].add = -1;
} else {
mo[i].l = en[from];
mo[i].r = st[to];
mo[i].add = p;
}
}
blockSize = (int)sqrt(npath) + 1;
sort(mo, mo + q, moDataCmp);
int moStart = mo[0].l;
int moEnd = moStart - 1;
for (int i = 0, __end = (q); i < __end; ++i) {
int l = mo[i].l;
int r = mo[i].r;
while (moStart < l) moRemove(moStart++);
while (moStart > l) moAdd(--moStart);
while (moEnd < r) moAdd(++moEnd);
while (moEnd > r) moRemove(moEnd--);
if (mo[i].add == -1) {
ret[mo[i].id] = re;
} else {
int p = mo[i].add;
_add(f[p], isGirl[p], 1);
ret[mo[i].id] = re;
_add(f[p], isGirl[p], -1);
}
}
for (int i = 0, __end = (q); i < __end; ++i) printf("%lld\n", ret[i]);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[3][3000], str;
bool flag = 1;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> s[0][i] >> s[1][i];
if (s[0][i].size() <= s[1][i].size())
s[2][i] = s[0][i];
else
s[2][i] = s[1][i];
}
for (int i = 0; i < n; i++) {
cin >> str;
flag = 1;
for (int i = 0; i < m && flag; i++) {
for (int j = 0; j < 2 && flag; j++)
if (str == s[j][i]) {
cout << s[2][i] << " ";
flag = 0;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
long long mx = 0;
for (int j = 0; j < a[i]; j++) {
long long k;
cin >> k;
b[i] = max(mx, k);
mx = b[i];
}
}
long long mx = *max_element(b, b + n);
long long res = 0;
for (int i = 0; i < n; i++) {
res = res + a[i] * (mx - b[i]);
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long k;
int t;
map<pair<int, vector<int> >, long long> mark;
vector<int> num = vector<int>(16);
long long numWay(int digit, vector<int>& vec) {
if (long long x = mark[make_pair(digit, vec)]) return x - 1;
if (digit == 0) {
mark[make_pair(digit, vec)] = 2;
return 1;
}
long long ret = 0;
for (int i = 0; i <= 15; i++)
if (vec[i]) {
vector<int> temp = vec;
temp[i]--;
sort(temp.begin(), temp.end());
ret += numWay(digit - 1, temp);
}
mark[make_pair(digit, vec)] = ret + 1;
return ret;
}
long long valueWithLength(int length) {
vector<int> remain = vector<int>(16);
for (int i = 0; i <= 15; i++) remain[i] = t;
remain[0]--;
return numWay(length - 1, remain) * 15;
}
char hexa(int x) {
if (x < 10) return '0' + x;
return 'a' + x - 10;
}
void calcAns(int remain) {
if (!remain) return;
for (int i = 0; i <= 15; i++)
if (num[i]) {
num[i]--;
long long add = numWay(remain - 1, num);
if (add >= k) {
cout << hexa(i);
calcAns(remain - 1);
return;
}
num[i]++;
k -= add;
}
}
void setup() {
cin >> k >> t;
int length = 1;
while (true) {
long long add = valueWithLength(length);
if (add >= k) break;
length++;
k -= add;
}
for (int i = 0; i <= 15; i++) num[i] = t;
for (int i = 1; i <= 15; i++) {
num[i]--;
long long add = numWay(length - 1, num);
if (add >= k) {
cout << hexa(i);
calcAns(length - 1);
return;
}
num[i]++;
k -= add;
}
}
void xuly() {}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
setup();
xuly();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
const long long inf = 2147383647;
const long long mod = 1000000007;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
int n;
int child[2002], par[2002], smol[2002], val[2002];
vector<int> v[2002];
vector<pair<int, int> > nvec[2002];
void addNum(int node, int toAdd) {
for (int i = 0; i < ((long long)(nvec[node]).size()); i++) {
nvec[node][i].first += toAdd;
val[nvec[node][i].second] = nvec[node][i].first;
}
}
int getMax(int node) {
int res = nvec[node][((long long)(nvec[node]).size()) - 1].first;
return res;
}
void dfs(int node) {
if (!((long long)(v[node]).size())) {
val[node] = 1;
nvec[node].clear();
nvec[node].push_back(make_pair(1, node));
return;
}
int x, y;
for (int i = 0; i < ((long long)(v[node]).size()); i++) {
x = v[node][i];
dfs(x);
}
for (int i = 0; i < ((long long)(v[node]).size()) - 1; i++) {
x = getMax(v[node][i]);
addNum(v[node][i + 1], x);
}
int cnt = smol[node], prev = 0;
nvec[node].clear();
for (int i = 0; i < ((long long)(v[node]).size()); i++) {
x = v[node][i];
for (int j = 0; j < ((long long)(nvec[x]).size()); j++) {
if (!cnt) {
nvec[node].push_back(make_pair(prev + 1, node));
val[node] = prev + 1;
}
if (cnt <= 0) {
nvec[node].push_back(nvec[x][j]);
nvec[node][((long long)(nvec[node]).size()) - 1].first += 1;
val[nvec[node][((long long)(nvec[node]).size()) - 1].second] =
nvec[node][((long long)(nvec[node]).size()) - 1].first;
} else {
nvec[node].push_back(nvec[x][j]);
}
prev = nvec[x][j].first;
cnt--;
}
}
if (!cnt) {
nvec[node].push_back(make_pair(prev + 1, node));
val[node] = prev + 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int root, x, y;
cin >> n;
for (long long i = (1); i <= (n); ++i) {
cin >> par[i] >> smol[i];
if (!par[i]) {
root = i;
continue;
}
v[par[i]].push_back(i);
}
for (long long i = (1); i <= (n); ++i) {
x = par[i];
while (x) {
child[x]++;
x = par[x];
}
}
for (long long i = (1); i <= (n); ++i) {
if (smol[i] > child[i]) {
cout << "NO"
<< "\n";
return 0;
}
}
dfs(root);
cout << "YES"
<< "\n";
for (long long i = (1); i <= (n); ++i) {
cout << val[i] << " ";
}
cout << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int myrand() { return abs((int)mt()); }
struct HopcroftKarp {
static const int maxv = 3e3 + 5;
static const int maxe = 2e6 + 5;
int nx, ny, E, adj[maxe], nxt[maxe], lst[maxv], ptr[maxv], lev[maxv],
que[maxv], matx[maxv], maty[maxv];
void init(int nx, int ny) {
this->nx = nx, this->ny = ny;
E = 0, fill_n(lst, nx, -1);
fill_n(matx, nx, -1), fill_n(maty, ny, -1);
}
void add(int x, int y) { adj[E] = y, nxt[E] = lst[x], lst[x] = E++; }
int bfs() {
int qsize = 0;
for (int x = 0; x < nx; x++)
if (matx[x] != -1)
lev[x] = 0;
else {
lev[x] = 1;
que[qsize++] = x;
}
int found = 0;
for (int i = 0; i < qsize; i++) {
for (int x = que[i], e = lst[x]; ~e; e = nxt[e]) {
int y = adj[e];
if (!~maty[y])
found = 1;
else if (!lev[maty[y]]) {
lev[maty[y]] = lev[x] + 1;
que[qsize++] = maty[y];
}
}
}
return found;
}
int dfs(int x) {
for (int& e = ptr[x]; ~e; e = nxt[e]) {
int y = adj[e];
if (!~maty[y] || (lev[maty[y]] == lev[x] + 1 && dfs(maty[y]))) {
matx[x] = y;
maty[y] = x;
return 1;
}
}
return 0;
}
int maxmat() {
int res = 0;
while (bfs()) {
for (int x = 0; x < nx; x++) ptr[x] = lst[x];
for (int x = 0; x < nx; x++)
if (!~matx[x]) res += dfs(x);
}
return res;
}
int vis[2][maxv];
void dfs(int u, int r) {
vis[r][u] = 1;
if (!r) {
for (int e = lst[u]; ~e; e = nxt[e]) {
int v = adj[e];
if (matx[u] != v && !vis[!r][v]) {
dfs(v, !r);
}
}
} else {
int v = maty[u];
if (~v && !vis[!r][v]) {
dfs(v, !r);
}
}
}
pair<vector<int>, vector<int> > mincover() {
for (int u = (0); u < (nx); ++u)
if (!~matx[u] && !vis[0][u]) {
dfs(u, 0);
}
pair<vector<int>, vector<int> > res;
for (int x = (0); x < (nx); ++x)
if (!vis[0][x]) res.first.push_back(x);
for (int y = (0); y < (ny); ++y)
if (vis[1][y]) res.second.push_back(y);
return res;
}
} hopkarp;
const int maxn = 3000 + 5;
int n;
int x[maxn];
int y[maxn];
int f[maxn][maxn];
int idx[maxn][maxn];
int idy[maxn][maxn];
int gx[maxn];
int gy[maxn];
void chemthan() {
cin >> n;
vector<int> dcx, dcy;
for (int i = (0); i < (n); ++i)
cin >> x[i] >> y[i], dcx.push_back(x[i]), dcy.push_back(y[i]);
sort((dcx).begin(), (dcx).end()),
(dcx).erase(unique((dcx).begin(), (dcx).end()), (dcx).end());
sort((dcy).begin(), (dcy).end()),
(dcy).erase(unique((dcy).begin(), (dcy).end()), (dcy).end());
int cx = int((dcx).size());
int cy = int((dcy).size());
for (int i = (0); i < (n); ++i) {
x[i] = lower_bound((dcx).begin(), (dcx).end(), x[i]) - dcx.begin();
y[i] = lower_bound((dcy).begin(), (dcy).end(), y[i]) - dcy.begin();
f[x[i]][y[i]] = 1;
}
int cidx = 0;
for (int i = (0); i < (cx); ++i) {
for (int j = (0); j < (cy); ++j) {
if (!f[i][j]) {
int nj = j;
while (nj < cy && !f[i][nj]) {
idx[i][nj] = cidx;
nj++;
}
if (!j || nj == cy) {
gx[cidx] = 1;
}
j = nj - 1;
cidx++;
}
}
}
int cidy = 0;
for (int j = (0); j < (cy); ++j) {
for (int i = (0); i < (cx); ++i) {
if (!f[i][j]) {
int ni = i;
while (ni < cx && !f[ni][j]) {
idy[ni][j] = cidy;
ni++;
}
if (!i || ni == cx) {
gy[cidy] = 1;
}
i = ni - 1;
cidy++;
}
}
}
assert(cidx < 3000 && cidy < 3000);
hopkarp.init(cidx, cidy);
for (int i = (0); i < (cx); ++i)
for (int j = (0); j < (cy); ++j) {
if (!f[i][j] && !gx[idx[i][j]] && !gy[idy[i][j]]) {
hopkarp.add(idx[i][j], idy[i][j]);
}
}
int res = hopkarp.maxmat();
pair<vector<int>, vector<int> > cover = hopkarp.mincover();
assert(res == int((cover.first).size()) + int((cover.second).size()));
for (int x : cover.first) {
gx[x] = 1;
}
for (int y : cover.second) {
gy[y] = 1;
}
vector<pair<int, pair<int, int> > > ver, hor;
for (int x = (0); x < (cx); ++x) {
for (int y = (0); y < (cy); ++y) {
if (f[x][y]) {
int ny = y;
while (ny < cy && (f[x][ny] || !gx[idx[x][ny]])) ny++;
ver.push_back(make_pair(x, make_pair(y, ny - 1)));
y = ny - 1;
}
}
}
for (int y = (0); y < (cy); ++y) {
for (int x = (0); x < (cx); ++x) {
if (f[x][y]) {
int nx = x;
while (nx < cx && (f[nx][y] || !gy[idy[nx][y]])) nx++;
hor.push_back(make_pair(y, make_pair(x, nx - 1)));
x = nx - 1;
}
}
}
cout << int((hor).size()) << "\n";
for (auto it : hor) {
cout << dcx[it.second.first] << " " << dcy[it.first] << " "
<< dcx[it.second.second] << " " << dcy[it.first] << "\n";
}
cout << int((ver).size()) << "\n";
for (auto it : ver) {
cout << dcx[it.first] << " " << dcy[it.second.first] << " " << dcx[it.first]
<< " " << dcy[it.second.second] << "\n";
}
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int a[1010], C[1010][1010];
int dp[1010];
int main() {
C[0][0] = 1;
for (int i = 1; i < 1010; i++) {
for (int j = 0; j <= i; j++) {
C[i][j] = C[i - 1][j];
if (j) C[i][j] += C[i - 1][j - 1];
if (C[i][j] >= mod) C[i][j] -= mod;
}
}
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = 0;
for (int i = n; i >= 1; i--) {
int x = a[i];
if (i + x > n || x <= 0) continue;
dp[i] = C[n - i][x];
for (int j = i + 1; j <= n; j++) {
dp[i] = (dp[i] + 1LL * dp[j] * C[j - i - 1][x]) % mod;
}
ans += dp[i];
if (ans >= mod) ans -= mod;
}
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool valid;
long long ans;
void dfs(long long i, vector<pair<long long, long long>> adj[],
long long colour[], long long c[]) {
c[colour[i]]++;
long long j, l = adj[i].size();
for (j = 0; j < l; j++) {
if (colour[adj[i][j].first] == -1) {
colour[adj[i][j].first] = colour[i] ^ adj[i][j].second;
dfs(adj[i][j].first, adj, colour, c);
} else if (colour[adj[i][j].first] != colour[i] ^ adj[i][j].second) {
valid = false;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, n, m, i, j, c[2];
string a;
cin >> t;
for (; t--;) {
valid = true;
ans = 0;
c[0] = c[1] = 0;
cin >> n >> m;
long long colour[n + 1];
for (i = 0; i <= n; i++) {
colour[i] = -1;
}
vector<pair<long long, long long>> adj[n + 1];
for (; m--;) {
cin >> i >> j >> a;
if (a == "imposter") {
adj[i].push_back({j, 1});
adj[j].push_back({i, 1});
} else {
adj[i].push_back({j, 0});
adj[j].push_back({i, 0});
}
}
for (i = 1; i <= n; i++) {
if (colour[i] == -1) {
c[0] = c[1] = 0;
colour[i] = 0;
dfs(i, adj, colour, c);
ans = ans + max(c[0], c[1]);
}
}
if (valid == false) {
ans = -1;
}
cout << ans << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
int b[101] = {0}, c[101] = {0}, vis[101] = {0};
for (int i = 1; i <= k; i++) b[i] = a[i];
int t = 0, ans = 0, d = k + 1;
while (t < n) {
int l = t * 100.0 / n + 0.5;
for (int i = 1; i <= k; i++) {
if (b[i]) {
c[i]++;
if (c[i] == l && !vis[i]) ans++, vis[i] = 1;
if (c[i] >= b[i]) {
c[i] = 0;
if (d <= n)
b[i] = a[d];
else
b[i] = 0;
vis[i] = 0;
d++;
t++;
}
}
}
}
cout << ans << "\n";
}
| 8 |
Subsets and Splits